diff --git a/.formatter.exs b/.formatter.exs
new file mode 100644
index 00000000000..a7df4e3d63d
--- /dev/null
+++ b/.formatter.exs
@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+[
+  inputs: [
+    "lib/*/{lib,scripts,unicode,test}/**/*.{ex,exs}",
+    "lib/*/*.exs",
+    "lib/ex_unit/examples/*.exs",
+    ".formatter.exs"
+  ],
+  locals_without_parens: [
+    # Formatter tests
+    assert_format: 2,
+    assert_format: 3,
+    assert_same: 1,
+    assert_same: 2,
+
+    # Errors tests
+    assert_eval_raise: 3,
+
+    # Float tests
+    float_assert: 1
+  ]
+]
diff --git a/.gitattributes b/.gitattributes
index 1a79d0b894c..ebff1ea6a4e 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 lib/elixir/test/elixir/fixtures/*.txt text eol=lf
+*.ex diff=elixir
+*.exs diff=elixir
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000000..71572d44a19
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+---
+blank_issues_enabled: true
+
+contact_links:
+  - name: Ask questions, support, and general discussions
+    url: https://elixirforum.com/
+    about: Ask questions, provide support, and more on Elixir Forum
+
+  - name: Propose new features
+    url: https://github.com/elixir-lang/elixir/#proposing-new-features
+    about: Propose new features in our mailing list
diff --git a/.github/ISSUE_TEMPLATE/issue.yml b/.github/ISSUE_TEMPLATE/issue.yml
new file mode 100644
index 00000000000..cd1ba44e31e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/issue.yml
@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+---
+name: Report an issue
+description:
+  Tell us about something that is not working the way we (probably) intend
+body:
+  - type: markdown
+    attributes:
+      value: >
+        Thank you for contributing to Elixir! :heart:
+
+
+        Please, do not use this form for guidance, questions or support.
+        Try instead in [Elixir Forum](https://elixirforum.com),
+        the [IRC Chat](https://web.libera.chat/#elixir),
+        [Stack Overflow](https://stackoverflow.com/questions/tagged/elixir),
+        [Slack](https://elixir-slackin.herokuapp.com),
+        [Discord](https://discord.gg/elixir) or in other online communities.
+
+  - type: textarea
+    id: elixir-and-otp-version
+    attributes:
+      label: Elixir and Erlang/OTP versions
+      description: Paste the output of `elixir --version` here.
+    validations:
+      required: true
+
+  - type: input
+    id: os
+    attributes:
+      label: Operating system
+      description: The operating system that this issue is happening on.
+    validations:
+      required: true
+
+  - type: textarea
+    id: current-behavior
+    attributes:
+      label: Current behavior
+      description: >
+        Include code samples, errors, and stacktraces if appropriate.
+
+
+        If reporting a bug, please include the reproducing steps.
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: Expected behavior
+      description: A short description on how you expect the code to behave.
+    validations:
+      required: true
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000000..ea242ad8eef
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000000..b99d2ee667c
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,178 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+name: CI
+
+on:
+  push:
+    paths-ignore:
+      - "lib/**/*.md"
+
+  pull_request:
+    paths-ignore:
+      - "lib/**/*.md"
+
+env:
+  ELIXIR_ASSERT_TIMEOUT: 2000
+  ELIXIRC_OPTS: "--warnings-as-errors"
+  LANG: C.UTF-8
+
+permissions:
+  contents: read
+
+jobs:
+  test_linux:
+    name: Ubuntu 24.04, OTP ${{ matrix.otp_version }}${{ matrix.deterministic && ' (deterministic)' || '' }}${{ matrix.coverage && ' (coverage)' || '' }}
+    runs-on: ubuntu-24.04
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - otp_version: "28.1"
+            deterministic: true
+          - otp_version: "28.1"
+            erlc_opts: "warnings_as_errors"
+            docs: true
+            coverage: true
+          - otp_version: "27.3"
+            erlc_opts: "warnings_as_errors"
+          - otp_version: "27.0"
+            erlc_opts: "warnings_as_errors"
+          - otp_version: "26.0"
+          - otp_version: master
+            development: true
+          - otp_version: maint
+            development: true
+
+    # Earlier Erlang/OTP versions ignored compiler directives
+    # when using warnings_as_errors. So we only set ERLC_OPTS
+    # from Erlang/OTP 27+.
+    env:
+      ERLC_OPTS: ${{ matrix.erlc_opts || '' }}
+    steps:
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+
+      - uses: erlef/setup-beam@e6d7c94229049569db56a7ad5a540c051a010af9 # v1.20.4
+        with:
+          otp-version: ${{ matrix.otp_version }}
+
+      - name: Set ERL_COMPILER_OPTIONS
+        if: ${{ matrix.deterministic }}
+        run: echo "ERL_COMPILER_OPTIONS=deterministic" >> $GITHUB_ENV
+
+      - name: Compile Elixir
+        run: |
+          make compile
+          echo "$PWD/bin" >> $GITHUB_PATH
+
+      - name: Build info
+        run: bin/elixir --version
+
+      - name: Check format
+        run: make test_formatted && echo "All Elixir source code files are properly formatted."
+
+      - name: Erlang test suite
+        run: make test_erlang
+        continue-on-error: ${{ matrix.development == true }}
+
+      - name: Elixir test suite
+        run: make test_elixir
+        continue-on-error: ${{ matrix.development == true }}
+        env:
+          COVER: "${{ matrix.coverage }}"
+
+      - name: Build docs (ExDoc main)
+        if: ${{ matrix.docs }}
+        run: |
+          cd ..
+          git clone https://github.com/elixir-lang/ex_doc.git --depth 1
+          cd ex_doc
+          ../elixir/bin/mix do local.rebar --force + local.hex --force + deps.get + compile
+          cd ../elixir/
+          git fetch --tags
+          DOCS_OPTIONS="--warnings-as-errors" make docs
+
+      - name: "Calculate Coverage"
+        if: ${{ matrix.coverage }}
+        run: make cover | tee "$GITHUB_STEP_SUMMARY"
+
+      - name: "Upload Coverage Artifact"
+        if: ${{ matrix.coverage }}
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        with:
+          name: TestCoverage
+          path: cover/*
+
+      - name: Check reproducible builds
+        if: ${{ matrix.deterministic }}
+        run: |
+          rm -rf .git
+          # Recompile System without .git
+          cd lib/elixir && ../../bin/elixirc -o ebin lib/system.ex && cd -
+          taskset 1 make check_reproducible
+
+  test_windows:
+    name: Windows Server 2022, OTP ${{ matrix.otp_version }}
+    runs-on: windows-2022
+
+    strategy:
+      matrix:
+        otp_version:
+          - "28.1"
+          - "27.3"
+          - "26.2"
+
+    steps:
+      - name: Configure Git
+        run: git config --global core.autocrlf input
+
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+
+      - uses: erlef/setup-beam@e6d7c94229049569db56a7ad5a540c051a010af9 # v1.20.4
+        with:
+          otp-version: ${{ matrix.otp_version }}
+
+      - name: Compile Elixir
+        run: |
+          Remove-Item -Recurse -Force '.git'
+          make compile
+
+      - name: Build info
+        run: bin/elixir --version
+
+      - name: Check format
+        run: make test_formatted && echo "All Elixir source code files are properly formatted."
+
+      - name: Erlang test suite
+        run: make test_erlang
+
+      - name: Elixir test suite
+        run: |
+          Remove-Item 'c:/Windows/System32/drivers/etc/hosts'
+          make test_elixir
+
+  license_compliance:
+    name: Check Licence Compliance
+
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Use HTTPS instead of SSH for Git cloning
+        id: git-config
+        shell: bash
+        run: git config --global url.https://github.com/.insteadOf ssh://git@github.com/
+
+      - name: Checkout project
+        id: checkout
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+
+      - name: "Run OSS Review Toolkit"
+        id: ort
+        uses: ./.github/workflows/ort
+        with:
+          upload-reports: true
+          fail-on-violation: true
+          report-formats: "WebApp"
+          version: "${{ github.sha }}"
diff --git a/.github/workflows/markdown.yml b/.github/workflows/markdown.yml
new file mode 100644
index 00000000000..23a2dc9ab65
--- /dev/null
+++ b/.github/workflows/markdown.yml
@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+name: Markdown Content
+
+on:
+  push:
+    branches:
+      - "main"
+
+    paths: &paths-filter
+      - "**/*.md"
+      - .github/workflows/markdown.yml
+      - .markdownlint-cli2.jsonc
+
+  pull_request:
+    paths: *paths-filter
+
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  LANG: C.UTF-8
+
+jobs:
+  lint:
+    name: Lint Markdown content
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+
+      - name: Run markdownlint-cli2
+        uses: DavidAnson/markdownlint-cli2-action@30a0e04f1870d58f8d717450cc6134995f993c63 # v21.0.0
diff --git a/.github/workflows/notify.exs b/.github/workflows/notify.exs
new file mode 100644
index 00000000000..77251132a3d
--- /dev/null
+++ b/.github/workflows/notify.exs
@@ -0,0 +1,79 @@
+# #!/usr/bin/env elixir
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+[tag] = System.argv()
+
+Mix.install([
+  {:req, "~> 0.2.1"},
+  {:jason, "~> 1.0"}
+])
+
+%{status: 200, body: release} =
+  Req.get!("https://api.github.com/repos/elixir-lang/elixir/releases/tags/#{tag}")
+
+if release["draft"] do
+  raise "cannot notify a draft release"
+end
+
+## Notify on elixir-lang-ann
+
+names_and_checksums =
+  for asset <- release["assets"],
+      name = asset["name"],
+      name =~ ~r/.sha\d+sum$/,
+      do: {name, Req.get!(asset["browser_download_url"]).body}
+
+line_items =
+  for {name, checksum_and_name} <- Enum.sort(names_and_checksums) do
+    [checksum | _] = String.split(checksum_and_name, " ")
+    root = Path.rootname(name)
+    "." <> type = Path.extname(name)
+    "  * #{root} - #{type} - #{checksum}\n"
+  end
+
+body = "https://github.com/elixir-lang/elixir/releases/tag/#{tag}\n\n#{line_items}"
+
+IO.puts([
+  "========================================\n",
+  body,
+  "\n========================================"
+])
+
+mail = %{
+  # The email must have access to post
+  "From" => "jose.valim@dashbit.co",
+  "To" => "elixir-lang-ann@googlegroups.com",
+  "Subject" => "Elixir #{tag} released",
+  "HtmlBody" => body,
+  "MessageStream" => "outbound"
+}
+
+unless System.get_env("DRYRUN") do
+  headers = %{
+    "X-Postmark-Server-Token" => System.fetch_env!("ELIXIR_LANG_ANN_TOKEN")
+  }
+
+  resp = Req.post!("https://api.postmarkapp.com/email", {:json, mail}, headers: headers)
+  IO.puts("#{resp.status} elixir-lang-ann\n#{inspect(resp.body)}")
+end
+
+## Notify on Elixir Forum
+
+post = %{
+  "title" => "Elixir #{tag} released",
+  "raw" => "https://github.com/elixir-lang/elixir/releases/tag/#{tag}\n\n#{release["body"]}",
+  # Elixir News
+  "category" => 28
+}
+
+unless System.get_env("DRYRUN") do
+  headers = %{
+    "api-key" => System.fetch_env!("ELIXIR_FORUM_TOKEN"),
+    "api-username" => "Elixir"
+  }
+
+  resp = Req.post!("https://elixirforum.com/posts.json", {:json, post}, headers: headers)
+  IO.puts("#{resp.status} Elixir Forum\n#{inspect(resp.body)}")
+end
diff --git a/.github/workflows/ort/action.yml b/.github/workflows/ort/action.yml
new file mode 100644
index 00000000000..99cf2e7063e
--- /dev/null
+++ b/.github/workflows/ort/action.yml
@@ -0,0 +1,109 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+name: "Run OSS Review Toolkit"
+description: "Runs OSS Review Toolkit & generates SBoMs"
+inputs:
+  report-formats:
+    description: "ORT Report Formats"
+    required: true
+  fail-on-violation:
+    description: "Whether to fail on violation."
+    required: false
+    default: false
+  upload-reports:
+    description: "Whether to upload all reports"
+    required: false
+    default: false
+  version:
+    description: "Elixir Version (Tag / SHA)"
+    required: true
+
+outputs:
+  results-path:
+    description: "See oss-review-toolkit/ort-ci-github-action action"
+    value: "${{ steps.ort.outputs.results-path }}"
+  results-sbom-cyclonedx-xml-path:
+    description: "See oss-review-toolkit/ort-ci-github-action action"
+    value: "${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}"
+  results-sbom-cyclonedx-json-path:
+    description: "See oss-review-toolkit/ort-ci-github-action action"
+    value: "${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}"
+  results-sbom-spdx-yml-path:
+    description: "See oss-review-toolkit/ort-ci-github-action action"
+    value: "${{ steps.ort.outputs.results-sbom-spdx-yml-path }}"
+  results-sbom-spdx-json-path:
+    description: "See oss-review-toolkit/ort-ci-github-action action"
+    value: "${{ steps.ort.outputs.results-sbom-spdx-json-path }}"
+
+runs:
+  using: "composite"
+  steps:
+    - name: Fetch Default ORT Config
+      id: fetch-default-ort-config
+      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        repository: oss-review-toolkit/ort-config
+        ref: "main"
+        path: ".ort-config"
+
+    - name: Setup ORT Config
+      id: setup-ort-config
+      shell: bash
+      run: |
+        mkdir -p "/$HOME/.ort/"
+
+        # Move Fetched Default Config into Place
+        mv .ort-config "$HOME/.ort/config"
+        
+        # Append Global ORT Config
+        cat .ort/config/config.yml >> "$HOME/.ort/config/config.yml"
+        
+        # Override Default Evaluator Rules
+        cp .ort/config/evaluator.rules.kts "$HOME/.ort/config/evaluator.rules.kts"
+
+        # Add Package Configurations
+        mkdir -p "$HOME/.ort/config/package-configurations/SpdxDocumentFile/The Elixir Team"
+        for FILE in .ort/package-configurations/*.yml; do
+          COMPONENT="$(basename "$FILE")"
+          cp "$FILE" "$HOME/.ort/config/package-configurations/SpdxDocumentFile/The Elixir Team/$COMPONENT"
+          sed -i -E \
+            "s/(\"SpdxDocumentFile:The Elixir Team:.+:)\"/\1${ELIXIR_VERSION}\"/" \
+            "$HOME/.ort/config/package-configurations/SpdxDocumentFile/The Elixir Team/$COMPONENT"
+        done
+
+        # Set Version in SPDX & Config
+        sed -i "s/# elixir-version-insert/versionInfo: '${ELIXIR_VERSION}'/" project.spdx.yml
+        sed -i -E "s/(\"SpdxDocumentFile:The Elixir Team:.+:)\"/\1${ELIXIR_VERSION}\"/" .ort.yml
+        sed -i "s|https://github.com/elixir-lang/elixir.git|${ELIXIR_REPO}@${ELIXIR_VERSION}|" project.spdx.yml
+      env:
+        ELIXIR_VERSION: "${{ inputs.version }}"
+        ELIXIR_REPO: "${{ github.server_url }}/${{ github.repository }}.git"
+
+    - name: "Cache ScanCode"
+      uses: actions/cache@d4323d4df104b026a6aa633fdb11d772146be0bf # v4.2.2
+      with:
+        path: "~/.cache/scancode-tk"
+        key: ${{ runner.os }}-scancode
+
+    - name: Run OSS Review Toolkit
+      id: ort
+      uses: oss-review-toolkit/ort-ci-github-action@1805edcf1f4f55f35ae6e4d2d9795ccfb29b6021 # v1.1.0
+      with:
+        image: ghcr.io/oss-review-toolkit/ort-minimal:65.0.0
+        run: >-
+          labels,
+          cache-dependencies,
+          cache-scan-results,
+          analyzer,
+          scanner,
+          advisor,
+          evaluator,
+          reporter,
+          ${{ inputs.upload-reports == 'true' && 'upload-results' || '' }}
+        fail-on: "${{ inputs.fail-on-violation == 'true' && 'violations,issues' || '' }}"
+        report-formats: "${{ inputs.report-formats }}"
+        ort-cli-report-args: >-
+          -O CycloneDX=output.file.formats=json,xml
+          -O SpdxDocument=outputFileFormats=JSON,YAML
+        sw-version: "${{ inputs.version }}"
diff --git a/.github/workflows/posix_compliance.yml b/.github/workflows/posix_compliance.yml
new file mode 100644
index 00000000000..16d10ee94d1
--- /dev/null
+++ b/.github/workflows/posix_compliance.yml
@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+name: POSIX Compliance
+
+on:
+  push:
+    paths: &paths-filter
+      - .github/workflows/posix_compliance.yml
+      - bin/elixir
+      - bin/elixirc
+      - bin/iex
+
+  pull_request:
+    paths: *paths-filter
+
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  LANG: C.UTF-8
+
+jobs:
+  check_posix_compliance:
+    name: Check POSIX compliance
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+
+      - name: Install ShellCheck
+        run: |
+          sudo apt update
+          sudo apt install -y shellcheck
+
+      - name: Run ShellCheck on bin/ dir
+        run: |
+          shellcheck -e SC2039,2086 bin/elixir && \
+            echo "bin/elixir is POSIX compliant"
+
+          shellcheck bin/elixirc && \
+            echo "bin/elixirc is POSIX compliant"
+
+          shellcheck bin/iex && \
+            echo "bin/iex is POSIX compliant"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000000..59c1aa80351
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,439 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+name: Releases
+
+on:
+  push:
+    branches:
+      - main
+      - v*.*
+
+    tags:
+      - v*
+
+  workflow_dispatch:
+
+env:
+  ELIXIR_OPTS: "--warnings-as-errors"
+  LANG: C.UTF-8
+
+permissions:
+  contents: read
+
+jobs:
+  create_draft_release:
+    name: Create draft release
+    runs-on: ubuntu-24.04
+
+    permissions:
+      contents: write
+
+    env:
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    steps:
+      - name: Create draft release
+        if: github.ref_type != 'branch'
+        run: |
+          gh release create \
+            --repo ${{ github.repository }} \
+            --title ${{ github.ref_name }} \
+            --notes '' \
+            --draft \
+            ${{ github.ref_name }}
+
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        if: github.ref_type == 'branch'
+
+      - name: Update ${{ github.ref_name }}-latest
+        if: github.ref_type == 'branch'
+        run: |
+          ref_name=${{ github.ref_name }}-latest
+
+          if ! gh release view $ref_name; then
+            gh release create \
+              --latest=false \
+              --title $ref_name \
+              --notes "Automated release for latest ${{ github.ref_name }}." \
+              $ref_name
+          fi
+
+          git tag $ref_name --force
+          git push origin $ref_name --force
+
+  build:
+    name: Ubuntu 24.04, OTP ${{ matrix.otp_version }}${{ matrix.build_docs && ' (build docs)' || '' }}
+    runs-on: ubuntu-24.04
+
+    strategy:
+      fail-fast: true
+      matrix:
+        include:
+          - otp: 26
+            otp_version: "26.0"
+
+          - otp: 27
+            otp_version: "27.0"
+
+          - otp: 28
+            otp_version: "28.0"
+            build_docs: build_docs
+
+    steps:
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+
+      - name: "Build Release"
+        uses: ./.github/workflows/release_pre_built
+        with:
+          otp_version: ${{ matrix.otp_version }}
+          otp: ${{ matrix.otp }}
+          build_docs: ${{ matrix.build_docs }}
+
+      - name: Create Docs Hashes
+        if: matrix.build_docs
+        run: |
+          shasum -a 1   Docs.zip > Docs.zip.sha1sum
+          shasum -a 256 Docs.zip > Docs.zip.sha256sum
+
+      - name: "Upload Linux release artifacts"
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        with:
+          name: build-linux-elixir-otp-${{ matrix.otp }}
+          path: elixir-otp-${{ matrix.otp }}.zip
+
+      - name: "Upload Windows release artifacts"
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        with:
+          name: build-windows-elixir-otp-${{ matrix.otp }}
+          path: elixir-otp-${{ matrix.otp }}.exe
+
+      - name: "Upload doc artifacts"
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        if: matrix.build_docs
+        with:
+          name: Docs
+          path: Docs.zip*
+
+  sign:
+    name: Sign files, ${{ matrix.flavor == 'windows' && 'Windows' || matrix.flavor == 'linux' && 'Linux' || matrix.flavor }}, OTP ${{ matrix.otp }}
+    needs: [build]
+    environment: release
+    strategy:
+      fail-fast: true
+      matrix:
+        otp: [26, 27, 28]
+        flavor: [windows, linux]
+
+    env:
+      RELEASE_FILE: elixir-otp-${{ matrix.otp }}.${{ matrix.flavor == 'linux' && 'zip' || 'exe' }}
+
+    runs-on: ${{ matrix.flavor == 'linux' && 'ubuntu-24.04' || 'windows-2022' }}
+
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - name: "Download build"
+        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+        with:
+          name: build-${{ matrix.flavor }}-elixir-otp-${{ matrix.otp }}
+
+      - name: Log in to Azure
+        if: ${{ matrix.flavor == 'windows' && vars.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
+        uses: azure/login@a457da9ea143d694b1b9c7c869ebb04ebe844ef5 # v2.3.0
+        with:
+          client-id: ${{ secrets.AZURE_CLIENT_ID }}
+          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
+          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+
+      - name: "Sign files with Trusted Signing"
+        uses: azure/trusted-signing-action@fc390cf8ed0f14e248a542af1d838388a47c7a7c # v0.5.10
+        if: ${{ matrix.flavor == 'windows' && vars.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
+        with:
+          endpoint: https://eus.codesigning.azure.net/
+          trusted-signing-account-name: ${{ vars.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
+          certificate-profile-name: ${{ vars.AZURE_CERTIFICATE_PROFILE_NAME }}
+          files-folder: ${{ github.workspace }}
+          files-folder-filter: exe
+          file-digest: SHA256
+          timestamp-rfc3161: http://timestamp.acs.microsoft.com
+          timestamp-digest: SHA256
+
+      - name: Create Release Hashes
+        if: matrix.flavor == 'windows'
+        shell: pwsh
+        run: |
+          $sha1 = Get-FileHash "$env:RELEASE_FILE" -Algorithm SHA1
+          $sha1.Hash.ToLower() + "  " + $env:RELEASE_FILE | Out-File "$env:RELEASE_FILE.sha1sum"
+
+          $sha256 = Get-FileHash "$env:RELEASE_FILE" -Algorithm SHA256
+          $sha256.Hash.ToLower() + "  " + $env:RELEASE_FILE | Out-File "$env:RELEASE_FILE.sha256sum"
+
+      - name: Create Release Hashes
+        if: matrix.flavor == 'linux'
+        shell: bash
+        run: |
+          shasum -a 1   "$RELEASE_FILE" > "${RELEASE_FILE}.sha1sum"
+          shasum -a 256 "$RELEASE_FILE" > "${RELEASE_FILE}.sha256sum"
+
+      - name: "Upload Linux release artifacts"
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        with:
+          name: sign-${{ matrix.flavor }}-elixir-otp-${{ matrix.otp }}
+          path: ${{ env.RELEASE_FILE }}*
+
+  sbom:
+    name: Generate SBoM
+    needs: [build, sign]
+    runs-on: ubuntu-24.04
+
+    permissions:
+      contents: write
+      id-token: write
+      attestations: write
+
+    steps:
+      - name: Use HTTPS instead of SSH for Git cloning
+        id: git-config
+        shell: bash
+        run: git config --global url.https://github.com/.insteadOf ssh://git@github.com/
+
+      - name: Checkout project
+        id: checkout
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+
+      - name: "Download Build Artifacts"
+        id: download-build-artifacts
+        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+        with:
+          pattern: "{sign-*-elixir-otp-*,Docs}"
+          merge-multiple: true
+          path: /tmp/build-artifacts/
+
+      - name: "Run OSS Review Toolkit"
+        id: ort
+        uses: ./.github/workflows/ort
+        with:
+          report-formats: "CycloneDx,SpdxDocument"
+          version: "${{ github.ref_type	== 'tag' && github.ref_name || github.sha }}"
+
+      - name: Attest Distribution Assets with SBoM
+        id: attest-sbom
+        uses: actions/attest-sbom@4651f806c01d8637787e274ac3bdf724ef169f34 # v3.0.0
+        with:
+          subject-path: |
+            /tmp/build-artifacts/{elixir-otp-*.*,Docs.zip}
+            ${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}
+            ${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}
+            ${{ steps.ort.outputs.results-sbom-spdx-yml-path }}
+            ${{ steps.ort.outputs.results-sbom-spdx-json-path }}
+          sbom-path: "${{ steps.ort.outputs.results-sbom-spdx-json-path }}"
+
+      - name: "Copy SBoM provenance"
+        id: sbom-provenance
+        shell: bash
+        run: |
+          mkdir attestations
+
+          for FILE in /tmp/build-artifacts/{elixir-otp-*.*,Docs.zip}; do
+            cp "$ATTESTATION" "attestations/$(basename "$FILE").sigstore"
+          done
+
+          cp "$ATTESTATION" "attestations/$(basename "${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}").sigstore"
+          cp "$ATTESTATION" "attestations/$(basename "${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}").sigstore"
+          cp "$ATTESTATION" "attestations/$(basename "${{ steps.ort.outputs.results-sbom-spdx-yml-path }}").sigstore"
+          cp "$ATTESTATION" "attestations/$(basename "${{ steps.ort.outputs.results-sbom-spdx-json-path }}").sigstore"
+        env:
+          ATTESTATION: "${{ steps.attest-sbom.outputs.bundle-path }}"
+
+      - name: "Assemble Release SBoM Artifacts"
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        with:
+          name: "SBoM"
+          path: |
+            ${{ steps.ort.outputs.results-sbom-cyclonedx-xml-path }}
+            ${{ steps.ort.outputs.results-sbom-cyclonedx-json-path }}
+            ${{ steps.ort.outputs.results-sbom-spdx-yml-path }}
+            ${{ steps.ort.outputs.results-sbom-spdx-json-path }}
+
+      - name: "Assemble Distribution Attestations"
+        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        with:
+          name: "Attestations"
+          path: "attestations/*.sigstore"
+
+  upload-release:
+    name: Upload release
+    needs: [create_draft_release, build, sign, sbom]
+    runs-on: ubuntu-24.04
+
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+        with:
+          pattern: "{sign-*-elixir-otp-*,Docs,SBoM,Attestations}"
+          merge-multiple: true
+
+      - name: Upload Pre-build
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          if [ "${{ github.ref_type }}" == "branch" ]; then
+            tag=${{ github.ref_name }}-latest
+          else
+            tag="${{ github.ref_name }}"
+          fi
+
+          gh release upload \
+            --repo ${{ github.repository }} \
+            --clobber \
+            "$tag" \
+            elixir-otp-*.zip \
+            elixir-otp-*.zip.sha{1,256}sum \
+            elixir-otp-*.zip.sigstore \
+            elixir-otp-*.exe \
+            elixir-otp-*.exe.sha{1,256}sum \
+            elixir-otp-*.exe.sigstore \
+            Docs.zip \
+            Docs.zip.sha{1,256}sum \
+            Docs.zip.sigstore \
+            bom.*
+
+  upload-builds-hex-pm:
+    name: Upload builds to hex.pm
+    runs-on: ubuntu-24.04
+    needs: [build, sign]
+    concurrency: builds-hex-pm
+    environment: release
+
+    env:
+      AWS_ACCESS_KEY_ID: ${{ secrets.HEX_AWS_ACCESS_KEY_ID }}
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.HEX_AWS_SECRET_ACCESS_KEY }}
+      AWS_REGION: ${{ vars.HEX_AWS_REGION }}
+      AWS_S3_BUCKET: ${{ vars.HEX_AWS_S3_BUCKET }}
+
+    steps:
+      - name: "Check if variables are set up"
+        if: "${{ ! vars.HEX_AWS_REGION }}"
+        run: |
+          echo "Required variables for uploading to hex.pm are not set up, skipping..."
+          exit 1
+
+      - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+        with:
+          pattern: "{sign-*-elixir-otp-*,Docs}"
+          merge-multiple: true
+
+      - name: Init purge keys file
+        run: |
+          touch purge_keys.txt
+
+      - name: Upload Precompiled to S3
+        run: |
+          ref_name=${{ github.ref_name }}
+
+          oldest_otp=$(find . -type f -name 'elixir-otp-*.zip' | sed -r 's/^.*elixir-otp-([[:digit:]]+)\.zip$/\1/' | sort -n | head -n 1)
+
+          for zip in $(find . -type f -name 'elixir-otp-*.zip' | sed 's/^\.\///'); do
+            dest=${zip/elixir/${ref_name}}
+            surrogate_key=${dest/.zip$/}
+
+            aws s3 cp "${zip}" "s3://${AWS_S3_BUCKET}/builds/elixir/${dest}" \
+              --cache-control "public,max-age=3600" \
+              --metadata "{\"surrogate-key\":\"builds builds/elixir builds/elixir/${surrogate_key}\",\"surrogate-control\":\"public,max-age=604800\"}"
+            echo "builds/elixir/${surrogate_key}" >> purge_keys.txt
+
+            if [ "$zip" == "elixir-otp-${oldest_otp}.zip" ]; then
+              aws s3 cp "${zip}" "s3://${AWS_S3_BUCKET}/builds/elixir/${ref_name}.zip" \
+                --cache-control "public,max-age=3600" \
+                --metadata "{\"surrogate-key\":\"builds builds/elixir builds/elixir/${ref_name}\",\"surrogate-control\":\"public,max-age=604800\"}"
+              echo builds/elixir/${ref_name} >> purge_keys.txt
+            fi
+          done
+
+      - name: Upload Docs to S3
+        run: |
+          version=$(echo ${{ github.ref_name }} | sed -e 's/^v//g')
+
+          unzip Docs.zip
+
+          for f in doc/*; do
+            if [ -d "$f" ]; then
+              app=$(echo "$f" | sed s/"doc\/"//)
+              tarball="${app}-${version}.tar.gz"
+              surrogate_key="docs/${app}-${version}"
+
+              tar -czf "${tarball}" -C "doc/${app}" .
+              aws s3 cp "${tarball}" "s3://${AWS_S3_BUCKET}/docs/${tarball}" \
+                --cache-control "public,max-age=3600" \
+                --metadata "{\"surrogate-key\":\"${surrogate_key}\",\"surrogate-control\":\"public,max-age=604800\"}"
+              echo "${surrogate_key}" >> ../purge_keys.txt
+            fi
+          done
+
+      - name: Update builds txt
+        run: |
+          date="$(date -u '+%Y-%m-%dT%H:%M:%SZ')"
+          ref_name=${{ github.ref_name }}
+
+          oldest_otp=$(find . -name 'elixir-otp-*.zip.sha256sum' | sed -r 's/^.*elixir-otp-([[:digit:]]+)\.zip\.sha256sum$/\1/' | sort -n | head -n 1)
+
+          aws s3 cp "s3://${AWS_S3_BUCKET}/builds/elixir/builds.txt" builds.txt || true
+          touch builds.txt
+
+          for sha256_file in $(find . -name 'elixir-otp-*.zip.sha256sum' | sed 's/^\.\///'); do
+            otp_version=$(echo "${sha256_file}" | sed -r 's/^elixir-otp-([[:digit:]]+)\.zip\.sha256sum/otp-\1/')
+            build_sha256=$(cut -d ' ' -f 1 "${sha256_file}")
+
+            sed -i "/^${ref_name}-${otp_version} /d" builds.txt
+            echo -e "${ref_name}-${otp_version} ${{ github.sha }} ${date} ${build_sha256} \n$(cat builds.txt)" > builds.txt
+
+            if [ "${otp_version}" == "otp-${oldest_otp}" ]; then
+              sed -i "/^${ref_name} /d" builds.txt
+              echo -e "${ref_name} ${{ github.sha }} ${date} ${build_sha256} \n$(cat builds.txt)" > builds.txt
+            fi
+          done
+
+          sort -u -k1,1 -o builds.txt builds.txt
+          aws s3 cp builds.txt "s3://${AWS_S3_BUCKET}/builds/elixir/builds.txt" \
+            --cache-control "public,max-age=3600" \
+            --metadata '{"surrogate-key":"builds builds/elixir builds/elixir/txt","surrogate-control":"public,max-age=604800"}'
+
+          echo 'builds/elixir/txt' >> purge_keys.txt
+
+      - name: Flush cache
+        if: github.repository == 'elixir-lang/elixir'
+        run: |
+          function purge_key() {
+            curl \
+               -X POST \
+               -H "Fastly-Key: ${FASTLY_KEY}" \
+               -H "Accept: application/json" \
+               -H "Content-Length: 0" \
+               "https://api.fastly.com/service/$1/purge/$2"
+          }
+
+          function purge() {
+            purge_key ${FASTLY_REPO_SERVICE_ID} $1
+            purge_key ${FASTLY_BUILDS_SERVICE_ID} $1
+            sleep 2
+            purge_key ${FASTLY_REPO_SERVICE_ID} $1
+            purge_key ${FASTLY_BUILDS_SERVICE_ID} $1
+            sleep 2
+            purge_key ${FASTLY_REPO_SERVICE_ID} $1
+            purge_key ${FASTLY_BUILDS_SERVICE_ID} $1
+          }
+
+          for key in $(cat purge_keys.txt); do
+            purge "${key}"
+          done
+
+        env:
+          FASTLY_REPO_SERVICE_ID: ${{ secrets.HEX_FASTLY_REPO_SERVICE_ID }}
+          FASTLY_BUILDS_SERVICE_ID: ${{ secrets.HEX_FASTLY_BUILDS_SERVICE_ID }}
+          FASTLY_KEY: ${{ secrets.HEX_FASTLY_KEY }}
diff --git a/.github/workflows/release_notifications.yml b/.github/workflows/release_notifications.yml
new file mode 100644
index 00000000000..630d16f5294
--- /dev/null
+++ b/.github/workflows/release_notifications.yml
@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+name: Release Notifications
+
+on:
+  release:
+    types:
+      - published
+
+permissions:
+  contents: read
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    name: Notify
+
+    steps:
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+
+      - uses: erlef/setup-beam@e6d7c94229049569db56a7ad5a540c051a010af9 # v1.20.4
+        with:
+          otp-version: "27.3"
+          elixir-version: "1.18.3"
+
+      - name: Run Elixir script
+        env:
+          ELIXIR_FORUM_TOKEN: ${{ secrets.ELIXIR_FORUM_TOKEN }}
+          ELIXIR_LANG_ANN_TOKEN: ${{ secrets.ELIXIR_LANG_ANN_TOKEN }}
+        run: |
+          elixir .github/workflows/notify.exs ${{ github.ref_name }}
diff --git a/.github/workflows/release_pre_built/action.yml b/.github/workflows/release_pre_built/action.yml
new file mode 100644
index 00000000000..22fc1b04729
--- /dev/null
+++ b/.github/workflows/release_pre_built/action.yml
@@ -0,0 +1,75 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+name: Release Pre-build
+description: "Builds Elixir release, ExDoc and generates docs"
+
+inputs:
+  otp:
+    description: "The major OTP version"
+
+  otp_version:
+    description: "The exact OTP version (major.minor[.patch])"
+
+  build_docs:
+    description: "Whether docs have to be built"
+
+runs:
+  using: "composite"
+
+  steps:
+    - uses: erlef/setup-beam@5304e04ea2b355f03681464e683d92e3b2f18451 # v1.18.2
+      with:
+        otp-version: ${{ inputs.otp_version }}
+        version-type: strict
+
+    - name: Build Elixir Release
+      shell: bash
+      run: |
+        make Precompiled.zip
+        mv Precompiled.zip elixir-otp-${{ inputs.otp }}.zip
+        echo "$PWD/bin" >> $GITHUB_PATH
+
+    - name: Install NSIS
+      shell: bash
+      run: |
+        sudo apt update
+        sudo apt install -y nsis
+
+    - name: Build Elixir Windows Installer
+      shell: bash
+      run: |
+        export OTP_VERSION=${{ inputs.otp_version }}
+        export ELIXIR_ZIP=$PWD/elixir-otp-${{ inputs.otp }}.zip
+        (cd lib/elixir/scripts/windows_installer && ./build.sh)
+        mv lib/elixir/scripts/windows_installer/tmp/elixir-otp-${{ inputs.otp }}.exe .
+    - name: Get ExDoc ref
+      if: ${{ inputs.build_docs }}
+      shell: bash
+      run: |
+        if [ "${{ github.ref_name }}" = "main" ]; then
+          ref=main
+        else
+          ref=v$(curl -s https://hex.pm/api/packages/ex_doc | jq --raw-output '.latest_stable_version')
+        fi
+        echo "EX_DOC_REF=$ref" >> $GITHUB_ENV
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      if: ${{ inputs.build_docs }}
+      with:
+        repository: elixir-lang/ex_doc
+        ref: ${{ env.EX_DOC_REF }}
+        path: ex_doc
+    - name: Build ex_doc
+      if: ${{ inputs.build_docs }}
+      shell: bash
+      run: |
+        mv ex_doc ../ex_doc
+        cd ../ex_doc
+        ../elixir/bin/mix do local.rebar --force + local.hex --force + deps.get + compile
+        cd ../elixir
+    - name: Build Docs
+      if: ${{ inputs.build_docs }}
+      shell: bash
+      run: |
+        git fetch --tags
+        make Docs.zip
diff --git a/.gitignore b/.gitignore
index 9f5a6a2479e..ea78a647a17 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,14 +1,19 @@
-/.eunit
-/.release
-/docs
-/ebin
-/lib/*/ebin/*
-/lib/*/tmp
-/lib/elixir/src/elixir.app.src
-/lib/elixir/src/*_lexer.erl
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+/doc/
+/lib/*/ebin/
+/lib/*/_build/
+/lib/*/tmp/
 /lib/elixir/src/*_parser.erl
-/lib/elixir/test/ebin
-/rel/elixir
+/lib/elixir/test/ebin/
+/man/elixir.1
+/man/iex.1
+/Docs.zip
+/Precompiled.zip
+/.eunit
+.elixir.plt
 erl_crash.dump
-.dialyzer_plt
-.dialyzer.base_plt
+/cover/
+.tool-versions
diff --git a/.markdownlint-cli2.jsonc b/.markdownlint-cli2.jsonc
new file mode 100644
index 00000000000..4b35e0693b0
--- /dev/null
+++ b/.markdownlint-cli2.jsonc
@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2021 The Elixir Team
+{
+  "globs": [
+    "**/*.md"
+  ],
+  "ignores": [
+    ".git/**"
+  ],
+  "gitignore": true,
+  "config": {
+    // Consecutive header levels (h1 -> h2 -> h3).
+    "MD001": false,
+    // Header style. We use #s.
+    "MD003": {
+      "style": "atx"
+    },
+    // Style of unordered lists..
+    "MD007": {
+      "indent": 2,
+      "start_indented": true
+    },
+    // Line length. Who cares.
+    "MD013": false,
+    // This warns if you have "console" or "shell" code blocks with a dollar sign $ that
+    // don't show output. We use those a lot, so this is fine for us.
+    "MD014": false,
+    // Multiple headings with the same content.
+    "MD024": {
+      // Duplication is allowed for headings with different parents.
+      "siblings_only": true
+    },
+    // Trailing punctuation in heading.
+    // Some headers finish with ! because it refers to a function name. Therefore we remove ! from
+    // the default values.
+    "MD026": {
+      "punctuation": ".,;:。，；：！"
+    },
+    // Allow empty line between block quotes. Used by contiguous admonition blocks.
+    "MD028": false,
+    // Allowed HTML inline elements.
+    "MD033": {
+      "allowed_elements": [
+        "h1",
+        "a",
+        "br",
+        "img",
+        "picture",
+        "source",
+        "noscript",
+        "p",
+        "script"
+      ]
+    },
+    // This warns if you have spaces in code blocks. Sometimes, that's fine.
+    "MD038": false,
+    // Code block style. We don't care if it's fenced or indented.
+    "MD046": false,
+    // Our tables are too large to align.
+    "MD060": false
+  }
+}
\ No newline at end of file
diff --git a/.ort.yml b/.ort.yml
new file mode 100644
index 00000000000..36153b73e30
--- /dev/null
+++ b/.ort.yml
@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+excludes:
+  paths:
+    - pattern: "man/*"
+      reason: "DOCUMENTATION_OF"
+      comment: "Documentation"
+    - pattern: ".github/**/*"
+      reason: "BUILD_TOOL_OF"
+      comment: "Documentation"
+    - pattern: ".ort/**/*"
+      reason: "BUILD_TOOL_OF"
+      comment: "Documentation"
+
+    # Unfortunately we'll have to repeat all package level excludes here
+    # Make sure to keep them in sync with the package configuration in
+    # .ort/package-configurations
+    - pattern: "lib/*/pages/**/*"
+      reason: "DOCUMENTATION_OF"
+      comment: "Documentation"
+    - pattern: "lib/*/test/**/*"
+      reason: "TEST_OF"
+      comment: "Tests"
+    - pattern: "lib/*/scripts/**/*"
+      reason: "BUILD_TOOL_OF"
+      comment: "Build Tool"
+    - pattern: "lib/*/examples/**/*"
+      reason: "EXAMPLE_OF"
+      comment: "Example"
+
+curations:
+  license_findings:
+    # Version File
+    - path: "VERSION"
+      reason: "NOT_DETECTED"
+      comment: "Apply Trademark Policy to VERSION file"
+      detected_license: "NONE"
+      concluded_license: "Apache-2.0"
+
+    # Wrongly Identified
+    - path: ".gitignore"
+      reason: "INCORRECT"
+      comment: "Ignored by ScanCode"
+      detected_license: "NONE"
+      concluded_license: "Apache-2.0"
+    - path: ".gitattributes"
+      reason: "INCORRECT"
+      comment: "Ignored by ScanCode"
+      detected_license: "NONE"
+      concluded_license: "Apache-2.0"
+    - path: "CONTRIBUTING.md"
+      reason: "INCORRECT"
+      comment: "Wrongly identified TSL license"
+      detected_license: "Apache-2.0 OR NOASSERTION OR LicenseRef-scancode-tsl-2020"
+      concluded_license: "Apache-2.0"
+    - path: "OPEN_SOURCE_POLICY.md"
+      reason: "INCORRECT"
+      comment: "Wrongly identified NOASSERTION"
+      detected_license: "NOASSERTION"
+      concluded_license: "Apache-2.0"
+
+    # Unfortunately we'll have to repeat all package level license curations here
+    # Make sure to keep them in sync with the package configuration in
+    # .ort/package-configurations
+
+    # Test Fixtures
+    - path: "lib/*/test/fixtures/**/*"
+      reason: "NOT_DETECTED"
+      comment: "Apply default license to test fixtures"
+      detected_license: "NONE"
+      concluded_license: "Apache-2.0"
+
+    # Logos
+    - path: "lib/elixir/pages/images/logo.png"
+      reason: "NOT_DETECTED"
+      comment: "Apply Trademark Policy to Elixir Logo"
+      detected_license: "NONE"
+      concluded_license: "LicenseRef-elixir-trademark-policy"
+    - path: "lib/elixir/scripts/windows_installer/assets/Elixir.ico"
+      reason: "NOT_DETECTED"
+      comment: "Apply Trademark Policy to Elixir Logo"
+      detected_license: "NONE"
+      concluded_license: "LicenseRef-elixir-trademark-policy"
+
+    # Documentation Images
+    - path: "lib/elixir/pages/images/**/*.png"
+      reason: "NOT_DETECTED"
+      comment: "Apply default license to all images"
+      detected_license: "NONE"
+      concluded_license: "Apache-2.0"
+
+    # Test Fixtures
+    - path: "lib/elixir/test/elixir/fixtures/**/*"
+      reason: "NOT_DETECTED"
+      comment: "Apply default license to test fixtures"
+      detected_license: "NONE"
+      concluded_license: "Apache-2.0"
+
+    # Unicode
+    - path: "lib/elixir/unicode/*.txt"
+      reason: "NOT_DETECTED"
+      comment: "Apply default license to unicode files"
+      detected_license: "NONE"
+      concluded_license: "LicenseRef-scancode-unicode"
+
+    # Wrongly Identified
+    - path: "lib/elixir/pages/references/library-guidelines.md"
+      reason: "INCORRECT"
+      comment: |
+        The guide mentions multiple licenses for users to choose from.
+        It however is not licensed itself by the mentioned licenses.
+      concluded_license: "Apache-2.0"
+    - path: "lib/elixir/scripts/windows_installer/.gitignore"
+      reason: "INCORRECT"
+      comment: "Ignored by ScanCode"
+      detected_license: "NONE"
+      concluded_license: "Apache-2.0"
diff --git a/.ort/config/config.yml b/.ort/config/config.yml
new file mode 100644
index 00000000000..3d72346ad8e
--- /dev/null
+++ b/.ort/config/config.yml
@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+ort:
+  enableRepositoryPackageCurations: true
+  enableRepositoryPackageConfigurations: true
+
+  scanner:
+    skipConcluded: false
+    includeFilesWithoutFindings: true
+
+  analyzer:
+    allowDynamicVersions: true
+    enabledPackageManagers: [SpdxDocumentFile]
+
+  reporter:
+    reporters:
+      SpdxDocument:
+        options:
+          creationInfoOrganization: The Elixir Team
+          documentName: "Elixir Source SPDX Document"
diff --git a/.ort/config/evaluator.rules.kts b/.ort/config/evaluator.rules.kts
new file mode 100644
index 00000000000..1afc2b50e80
--- /dev/null
+++ b/.ort/config/evaluator.rules.kts
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2019 The ORT Project Authors (see <https://github.com/oss-review-toolkit/ort/blob/main/NOTICE>)
+ * Copyright (c) 2021 The Elixir Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+ // Docs: https://oss-review-toolkit.org/ort/docs/configuration/evaluator-rules
+
+val whitelistedLicenses = listOf(
+  // License for Elixir & Imported Erlang Projects
+  "Apache-2.0",
+  // License for the Elixir Logo
+  "LicenseRef-elixir-trademark-policy",
+  "LicenseRef-scancode-elixir-trademark-policy",
+  // License for included Unicode Files
+  "LicenseRef-scancode-unicode",
+  // DCO for committers
+  "LicenseRef-scancode-dco-1.1"
+).map { SpdxSingleLicenseExpression.parse(it) }.toSet()
+
+fun PackageRule.howToFixDefault() = """
+      * Check if this license violation is intended
+      * Adjust evaluation rules in `.ort/config/evaluator.rules.kts`
+    """.trimIndent()
+
+fun PackageRule.LicenseRule.isHandled() =
+  object : RuleMatcher {
+    override val description = "isHandled($license)"
+
+    override fun matches() = license in whitelistedLicenses
+  }
+
+fun RuleSet.unhandledLicenseRule() = packageRule("UNHANDLED_LICENSE") {
+  // Do not trigger this rule on packages that have been excluded in the .ort.yml.
+  require {
+    -isExcluded()
+  }
+
+  // Define a rule that is executed for each license of the package.
+  licenseRule("UNHANDLED_LICENSE", LicenseView.CONCLUDED_OR_DECLARED_AND_DETECTED) {
+    require {
+      -isExcluded()
+      -isHandled()
+    }
+
+    // Throw an error message including guidance how to fix the issue.
+    error(
+      "The license $license is currently not covered by policy rules. " +
+        "The license was ${licenseSource.name.lowercase()} in package " +
+        "${pkg.metadata.id.toCoordinates()}.",
+      howToFixDefault()
+    )
+  }
+}
+
+fun RuleSet.unmappedDeclaredLicenseRule() = packageRule("UNMAPPED_DECLARED_LICENSE") {
+  require {
+    -isExcluded()
+  }
+
+  resolvedLicenseInfo.licenseInfo.declaredLicenseInfo.processed.unmapped.forEach { unmappedLicense ->
+    warning(
+      "The declared license '$unmappedLicense' could not be mapped to a valid license or parsed as an SPDX " +
+        "expression. The license was found in package ${pkg.metadata.id.toCoordinates()}.",
+      howToFixDefault()
+    )
+  }
+}
+
+val ruleSet = ruleSet(ortResult, licenseInfoResolver, resolutionProvider) {
+  unhandledLicenseRule()
+  unmappedDeclaredLicenseRule()
+}
+
+ruleViolations += ruleSet.violations
diff --git a/.ort/package-configurations/eex.yml b/.ort/package-configurations/eex.yml
new file mode 100644
index 00000000000..b205a6f65e0
--- /dev/null
+++ b/.ort/package-configurations/eex.yml
@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+id: "SpdxDocumentFile:The Elixir Team:eex:"
+path_excludes:
+  - pattern: "lib/eex/test/**/*"
+    reason: "TEST_OF"
+    comment: "Tests"
+license_finding_curations:
+  # Test Fixtures
+  - path: "lib/eex/test/fixtures/**/*"
+    reason: "NOT_DETECTED"
+    comment: "Apply default license to test fixtures"
+    detected_license: "NONE"
+    concluded_license: "Apache-2.0"
diff --git a/.ort/package-configurations/elixir.yml b/.ort/package-configurations/elixir.yml
new file mode 100644
index 00000000000..a9324799d69
--- /dev/null
+++ b/.ort/package-configurations/elixir.yml
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+id: "SpdxDocumentFile:The Elixir Team:elixir:"
+path_excludes:
+  - pattern: "lib/elixir/pages/**/*"
+    reason: "DOCUMENTATION_OF"
+    comment: "Documentation"
+  - pattern: "lib/elixir/scripts/**/*"
+    reason: "BUILD_TOOL_OF"
+    comment: "Build Tool"
+  - pattern: "lib/elixir/test/**/*"
+    reason: "TEST_OF"
+    comment: "Tests"
+license_finding_curations:
+  # Logos
+  - path: "lib/elixir/pages/images/logo.png"
+    reason: "NOT_DETECTED"
+    comment: "Apply Trademark Policy to Elixir Logo"
+    detected_license: "NONE"
+    concluded_license: "LicenseRef-elixir-trademark-policy"
+  - path: "lib/elixir/scripts/windows_installer/assets/Elixir.ico"
+    reason: "NOT_DETECTED"
+    comment: "Apply Trademark Policy to Elixir Logo"
+    detected_license: "NONE"
+    concluded_license: "LicenseRef-elixir-trademark-policy"
+
+  # Documentation Images
+  - path: "lib/elixir/pages/images/**/*.png"
+    reason: "NOT_DETECTED"
+    comment: "Apply default license to all images"
+    detected_license: "NONE"
+    concluded_license: "Apache-2.0"
+
+  # Test Fixtures
+  - path: "lib/elixir/test/elixir/fixtures/**/*"
+    reason: "NOT_DETECTED"
+    comment: "Apply default license to test fixtures"
+    detected_license: "NONE"
+    concluded_license: "Apache-2.0"
+
+  # Unicode
+  - path: "lib/elixir/unicode/*.txt"
+    reason: "NOT_DETECTED"
+    comment: "Apply default license to unicode files"
+    detected_license: "NONE"
+    concluded_license: "LicenseRef-scancode-unicode"
+
+  # Wrongly Identified
+  - path: "lib/elixir/pages/references/library-guidelines.md"
+    reason: "INCORRECT"
+    comment: |
+      The guide mentions multiple licenses for users to choose from.
+      It however is not licensed itself by the mentioned licenses.
+    concluded_license: "Apache-2.0"
+  - path: "lib/elixir/scripts/windows_installer/.gitignore"
+    reason: "INCORRECT"
+    comment: "Ignored by ScanCode"
+    detected_license: "NONE"
+    concluded_license: "Apache-2.0"
diff --git a/.ort/package-configurations/ex_unit.yml b/.ort/package-configurations/ex_unit.yml
new file mode 100644
index 00000000000..57c6bf498d8
--- /dev/null
+++ b/.ort/package-configurations/ex_unit.yml
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+id: "SpdxDocumentFile:The Elixir Team:exunit:"
+path_excludes:
+  - pattern: "lib/ex_unit/examples/**/*"
+    reason: "EXAMPLE_OF"
+    comment: "Example"
+  - pattern: "lib/ex_unit/test/**/*"
+    reason: "TEST_OF"
+    comment: "Tests"
+license_finding_curations:
+  # Test Fixtures
+  - path: "lib/ex_unit/test/fixtures/**/*"
+    reason: "NOT_DETECTED"
+    comment: "Apply default license to test fixtures"
+    detected_license: "NONE"
+    concluded_license: "Apache-2.0"
diff --git a/.ort/package-configurations/logger.yml b/.ort/package-configurations/logger.yml
new file mode 100644
index 00000000000..4005427948d
--- /dev/null
+++ b/.ort/package-configurations/logger.yml
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+id: "SpdxDocumentFile:The Elixir Team:logger:"
+path_excludes:
+  - pattern: "lib/logger/test/**/*"
+    reason: "TEST_OF"
+    comment: "Tests"
diff --git a/.ort/package-configurations/mix.yml b/.ort/package-configurations/mix.yml
new file mode 100644
index 00000000000..a45db2bc6c0
--- /dev/null
+++ b/.ort/package-configurations/mix.yml
@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+id: "SpdxDocumentFile:The Elixir Team:mix:"
+path_excludes:
+  - pattern: "lib/mix/test/**/*"
+    reason: "TEST_OF"
+    comment: "Tests"
+license_finding_curations:
+  # Test Fixtures
+  - path: "lib/mix/test/fixtures/**/*"
+    reason: "NOT_DETECTED"
+    comment: "Apply default license to test fixtures"
+    detected_license: "NONE"
+    concluded_license: "Apache-2.0"
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index dcb0d1f96b1..00000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,9 +0,0 @@
-language: erlang
-script: "make compile && rm -rf .git && make test"
-notifications:
-  irc: "irc.freenode.org#elixir-lang"
-  recipients:
-    - jose.valim@plataformatec.com.br
-    - eric.meadows.jonsson@gmail.com
-otp_release:
-  - 17.0
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 104d62bc78f..34f9504f316 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,1133 +1,76 @@
-# Changelog
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
 
-## v0.14.3-dev
+# Changelog for Elixir v1.20
 
-* Enhancements
+## Type system improvements
 
-* Bug fixes
-  * [Kernel] `|>`, `<<<`, `>>>` and `^^^` were made left associative in operator table
-  * [Kernel] `<`, `>`, `<=`, `>=` were given higher precedence than comparison ones (`==`, `!=`, etc) in operator table
+### Full type inference
 
-* Soft deprecations (no warnings emitted)
+Elixir now performs inference of whole functions. The best way to show the new capabilities are with examples. Take the following code:
 
-* Deprecations
+```elixir
+def add_foo_and_bar(data) do
+  data.foo + data.bar
+end
+```
 
-* Backwards incompatible changes
+Elixir now infers that the function expects a `map` as first argument, and the map must have the keys `.foo` and `.bar` whose values are either `integer()` or `float()`. The return type will be either `integer()` or `float()`.
 
-## v0.14.2 (2014-06-29)
+Here is another example:
 
-* Enhancements
-  * [Enum] Improve performance of `Enum.join/2` and `Enum.map_join/3` by using iolists
-  * [Kernel] Ensure compatibility with Erlang 17.1
-  * [Kernel] Support `@external_resource` attribute to external dependencies to a module
-  * [Mix] Allow built Git dependencies to run on a system without Git by passing `--no-deps-check`
-  * [Mix] Add `MIX_ARCHIVES` env variable (it is recommended for Elixir build tools to swap this environment)
-  * [Task] Set `:proc_lib` initial call on task to aid debugging
-  * [Typespec] Delay typespec compilation to after expansion
-  * [URI] Allow `parse/1` now accepts `%URI{}` as argument and return the uri itself
+```elixir
+def sum_to_string(a, b) do
+  Integer.to_string(a + b)
+end
+```
 
-* Bug fixes
-  * [CLI] Support paths inside archives in `-pa` and `-pz` options
-  * [IEx] Remove delay when printing data from the an application start callback
-  * [IEx] Ensure we show a consistent error when we cannot evaluate `.iex.exs`
-  * [Kernel] Ensure derived protocols are defined with a file
-  * [Kernel] Change precedence of `&` to not special case `/`
-  * [Kernel] Ensure we can only use variables and `\\` as arguments of bodyless clause
+Even though the `+` operator works with both integers and floats, Elixir infers that `a` and `b` must be both integers, as the result of `+` is given to a function that expects an integer. The inferred type information is then used during type checking to find possible typing errors.
 
-* Soft deprecations (no warnings emitted)
-  * [EEx] Using `EEx.TransformerEngine` and `EEx.AssignsEngine` are deprecated in favor of function composition with `Macro.prewalk/1` (see `EEx.SmartEngine` for an example)
-  * [Kernel] `Kernel.xor/2` is deprecated
-  * [Mix] `Mix.Generator.from_file/1` is deprecated in favor of passing `from_file: file` option to `embed_text/2` and `embed_template/2` (note though that `from_file/1` expects a path relative to the current file while the `from_file: file` expects one relative to the current working directory)
+### Acknowledgements
 
-* Deprecations
-  * [Kernel] `size/1` is deprecated in favor of `byte_size/1` and `tuple_size/1` (this change was soft deprecated two releases ago)
+The type system was made possible thanks to a partnership between [CNRS](https://www.cnrs.fr/) and [Remote](https://remote.com/). The development work is currently sponsored by [Fresha](https://www.fresha.com/) and [Dashbit](https://dashbit.co/).
 
-* Backwards incompatible changes
-  * [CLI] Remove support for the `--gen-debug` option as its usage is not documented by OTP
-  * [Kernel] Sigils no longer balance start and end tokens, e.g. the sigil `~s(f(o)o)` is no longer valid as it finishes in the first closing `)`
-  * [Kernel] Variables set in `cond` clause heads are no longer available outside of that particular `cond` clause (this is the behaviour also found in `case`, `receive` and friends)
-  * [System] `build_info/0` now returns a map
+## v1.20.0-dev
 
-## v0.14.1 (2014-06-18)
+### 1. Enhancements
 
-* Enhancements
-  * [Base] Decoding and encoding functions now accept the `:case` as an option
-  * [ExUnit] The test process now exits with `:shutdown` reason
-  * [GenEvent] `GenEvent.stream/2` now accepts `:sync` and `:async` modes
-  * [Node] Add `Node.start/3` and `Node.stop/0`
-  * [String] Updated Unicode database to 7.0
-  * [Task] Log when tasks crash
+#### Elixir
 
-* Bug fixes
-  * [Enum] `Enum.slice/2` and `Enum.slice/3` always returns a list (and never nil)
-  * [Kernel] Disambiguate (w)erl to (w)erl.exe
-  * [Mix] Ensure umbrella project is recompiled when a dependency inside an umbrella child changes
-  * [OptionParser] Do not allow underscores in option names
-  * [Path] Fix path expansion of `"/.."`
-  * [Path] Do not match files starting with `.` in `Path.wildcard/2` by default
-  * [Process] `Process.info(pid, :registered_name)` returns `{:registered_name, nil}` if there is no registered name
-  * [String] `String.slice/2` and `String.slice/3` always returns a list (and never nil)
-  * [URI] `encode/1` does not escape reserved/unreserved characters by default nor encodes whitespace as `+` (check `URI.encode_www_form/1` and `URI.decode_www_form/1` for previous behaviour)
+  * [Enum] Add `Enum.min_max` sorter
+  * [Integer] Add `Integer.ceil_div/2`
+  * [Kernel] Print intermediate results of `dbg` for pipes
+  * [Kernel] Warn on unused requires
+  * [Regex] Add `Regex.import/1` to import regexes defined with `/E`
 
-* Deprecations
-  * [Mix] `:escript_*` options were moved into a single `:escript` group
+#### ExUnit
 
-* Backwards incompatible changes
-  * [GenEvent] `GenEvent.stream/2` defaults to `:sync` mode
-  * [Kernel] Remove `get_in/1`
+  * [ExUnit.CaptureLog] Add `:formatter` option for custom log formatting
 
-## v0.14.0 (2014-06-08)
+#### Mix
 
-* Enhancements
-  * [ExUnit] Add `on_exit/1` callbacks that are guaranteed to run once the test process exits and always in another process
-  * [Kernel] Store documentation in the abstract code to avoid loading them when the module is loaded
-  * [Kernel] Add `get_in/2`, `put_in/3`, `update_in/3` and `get_and_update_in/3` to handle nested data structure operations
-  * [Kernel] Add `get_in/1`, `put_in/2`, `update_in/2` and `get_and_update_in/2` to handle nested data structure operations via paths
-  * [Mix] Add `Mix.Config` to ease definition of configuration files
-  * [Mix] Add `mix loadconfig` task that can be called multiple times to load external configs
-  * [Mix] Support `--config` option on `mix run`
-  * [Mix] Support `HTTP_PROXY` and `HTTPS_PROXY` on Mix url commands
-  * [Mix] Support `--names` options in `mix help` which emit only names (useful for autocompletion)
-  * [Protocol] Add `Protocol.consolidate/2`, `Protocol.consolidated?/1` and a `mix compile.protocols` task for protocol consolidation
-  * [Protocol] Add `Protocol.derive/3` for runtime deriving of a struct
-  * [String] Add `String.chunk/2`
-  * [Struct] Add support for `@derive` before `defstruct/2` definitions
+  * [mix test] Add `mix test --dry-run`
 
-* Bug fixes
-  * [File] `File.rm` now consistently deletes read-only across operating systems
-  * [Kernel] Ensure Mix `_build` structure works on Windows when copying projects
-  * [Kernel] Ensure `1.0E10` (with uppercase E) is also valid syntax
-  * [Mix] Fix `mix do` task for Windows' powershell users
-  * [Path] Fix `Path.absname("/")` and `Path.expand("/")` to return the absolute path `"/"`.
+### 2. Bug fixes
 
-* Soft deprecations (no warnings emitted)
-  * [Kernel] `size/1` is deprecated, please use `byte_size/1` or `tuple_size/1` instead
-  * [ExUnit] `teardown/2` and `teardown_all/2` are deprecated in favor of `on_exit/1` callbacks
+### 3. Soft deprecations (no warnings emitted)
 
-* Deprecations
-  * [Access] `Access.access/2` is deprecated in favor of `Access.get/2`
-  * [Dict] `Dict.Behaviour` is deprecated in favor of `Dict`
-  * [Kernel] `Application.Behaviour`, `GenEvent.Behaviour`, `GenServer.Behaviour` and `Supervisor.Behaviour` are deprecated in favor of `Application`, `GenEvent`, `GenServer` and `Supervisor`
-  * [Kernel] `defexception/3` is deprecated in favor of `defexception/1`
-  * [Kernel] `raise/3` is deprecated in favor of `reraise/2`
-  * [Kernel] `set_elem/3` is deprecated in favor of `put_elem/3`
-  * [Kernel] Passing an atom `var!/1` is deprecated, variables can be built dynamically with `Macro.var/2`
-  * [Mix] Exceptions that define a `:mix_error` field to be compatible with Mix are no longer supported. Instead please provide a `:mix` field and use `Mix.raise/1` and `Mix.raise/2`
+### 4. Hard deprecations
 
-* Backwards incompatible changes
-  * [Access] `Kernel.access/2` no longer exists and the `Access` protocol now requires `get/2` (instead of `access/2`) and `get_and_update/3` to be implemented
-  * [Kernel] Retrieving docs as `module.__info__(:docs)` is no longer supported, please use `Code.get_docs/2` instead
-  * [Kernel] `Code.compiler_options/1` no longer accepts custom options, only the ones specified by Elixir (use mix config instead)
-  * [Mix] `mix new` no longer generates a supevision tree by default, please pass `--sup` instead
-  * [Task] Tasks are automatically linked to callers and a failure in the task will crash the caller directly
+#### Elixir
 
-## v0.13.3 (2014-05-24)
+  * [File] `File.stream!(path, modes, lines_or_bytes)` is deprecated in favor of `File.stream!(path, lines_or_bytes, modes)`
+  * [Kernel] Matching on the size inside a bit pattern now requires the pin operator for consistency, such as `<<x::size(^existing_var)>>`
+  * [Kernel.ParallelCompiler] `Kernel.ParallelCompiler.async/1` is deprecated in favor of `Kernel.ParallelCompiler.pmap/2`, which is more performant and addresses known limitations
 
-* Enhancements
-  * [OptionParser] Add `:strict` option that only parses known switches
-  * [OptionParser] Add `next/2` useful for manual parsing of options
-  * [Macro] Add `Macro.prewalk/2/3` and `Macro.postwalk/2/3`
-  * [Kernel] `GenEvent`, `GenServer`, `Supervisor`, `Agent` and `Task` modules added
-  * [Kernel] Make deprecations compiler warnings to avoid the same deprecation being printed multiple times
+#### Logger
 
-* Bug fixes
-  * [Enum] Fix `Enum.join/2` and `Enum.map_join/3` for empty binaries at the beginning of the collection
-  * [ExUnit] Ensure the formatter doesn't error when printing :EXITs
-  * [Kernel] Rename `ELIXIR_ERL_OPTS` to `ELIXIR_ERL_OPTIONS` for consistency with `ERL_COMPILER_OPTIONS`
-  * [OptionParser] Parse `-` as a plain argument
-  * [OptionParser] `--` is always removed from argument list on `parse/2` and when it is the leading entry on `parse_head/2`
-  * [Regex] Properly escape regex (previously regex controls were double escaped)
+  * [Logger] `Logger.*_backend` functions are deprecated in favor of handlers. If you really want to keep on using backends, see the `:logger_backends` package
+  * [Logger] `Logger.enable/1` and `Logger.disable/1` have been deprecated in favor of `Logger.put_process_level/2` and `Logger.delete_process_level/1`
 
-* Soft deprecations (no warnings emitted)
-  * [Dict] `Dict.Behaviour` is deprecated in favor of `Dict`
-  * [Kernel] `Application.Behaviour`, `GenEvent.Behaviour`, `GenServer.Behaviour` and `Supervisor.Behaviour` are deprecated in favor of `Application`, `GenEvent`, `GenServer` and `Supervisor`
-  * [Kernel] `defexception/3` is deprecated in favor of `defexception/1`
-  * [Kernel] `raise/3` is deprecated in favor of `reraise/2`
-  * [Kernel] `set_elem/3` is deprecated in favor of `put_elem/3`
+## v1.19
 
-* Soft deprecations for conversions (no warnings emitted)
-  * [Kernel] `atom_to_binary/1` and `atom_to_list/1` are deprecated in favor of `Atom.to_string/1` and `Atom.to_char_list/1`
-  * [Kernel] `bitstring_to_list/1` and `list_to_bitstring/1` are deprecated in favor of the `:erlang` ones
-  * [Kernel] `binary_to_atom/1`, `binary_to_existing_atom/1`, `binary_to_float/1`, `binary_to_integer/1` and `binary_to_integer/2` are deprecated in favor of conversion functions in `String`
-  * [Kernel] `float_to_binary/*` and `float_to_list/*` are deprecated in favor of `Float.to_string/*` and `Float.to_char_list/*`
-  * [Kernel] `integer_to_binary/*` and `integer_to_list/*` are deprecated in favor of `Integer.to_string/*` and `Integer.to_char_list/*`
-  * [Kernel] `iodata_to_binary/1` and `iodata_length/1` are deprecated `IO.iodata_to_binary/1` and `IO.iodata_length/1`
-  * [Kernel] `list_to_atom/1`, `list_to_existing_atom/1`, `list_to_float/1`, `list_to_integer/1`, `list_to_integer/2` and `list_to_tuple/1` are deprecated in favor of conversion functions in `List`
-  * [Kernel] `tuple_to_list/1` is deprecated in favor of `Tuple.to_list/1`
-  * [List] `List.from_char_data/1` and `List.from_char_data!/1` deprecated in favor of `String.to_char_list/1`
-  * [String] `String.from_char_data/1` and `String.from_char_data!/1` deprecated in favor of `List.to_string/1`
-
-* Deprecations
-  * [Kernel] `is_exception/1`, `is_record/1` and `is_record/2` are deprecated in favor of `Exception.exception?1`, `Record.record?/1` and `Record.record?/2`
-  * [Kernel] `defrecord/3` is deprecated in favor of structs
-  * [Kernel] `:hygiene` in `quote` is deprecated
-  * [Mix] `Mix.project/0` is deprecated in favor of `Mix.Project.config/0`
-  * [Process] `Process.spawn/1`, `Process.spawn/3`, `Process.spawn_link/1`, `Process.spawn_link/3`, `Process.spawn_monitor/1`, `Process.spawn_monitor/3`, `Process.send/2` and `Process.self/0` are deprecated in favor of the ones in `Kernel`
-
-* Backwards incompatible changes
-  * [Exception] Exceptions now generate structs instead of records
-  * [OptionParser] Errors on parsing returns the switch and value as binaries (unparsed)
-  * [String] `String.to_char_list/1` (previously deprecated) no longer returns a tuple but the char list only and raises in case of failure
-
-## v0.13.2 (2014-05-11)
-
-* Enhancements
-  * [Application] Add an Application module with common functions to work with OTP applications
-  * [Exception] Add `Exception.message/1`, `Exception.format_banner/1`, `Exception.format_exit/1` and `Exception.format/1`
-  * [File] Add `File.ln_s/1`
-  * [Mix] `mix deps.clean` now works accross environments
-  * [Mix] Support line numbers in `mix test`, e.g. test/some/file_test.exs:12
-  * [Mix] Use `@file` attributes to detect dependencies in between `.ex` and external files. This means changing an `.eex` file will no longer recompile the whole project only the files that depend directly on it
-  * [Mix] Support application configurations in `config/config.exs`
-  * [Mix] Support user-wide configuration with `~/.mix/config.exs`
-  * [Mix] `mix help` now uses ANSI formatting to print guides
-  * [Regex] Support functions in `Regex.replace/4`
-  * [String] Support `:parts` in `String.split/3`
-
-* Bug fixes
-  * [Code] Ensure we don't lose the caller stacktrace on code evaluation
-  * [IEx] Exit signals now exits the IEx evaluator and a new one is spawned on its place
-  * [IEx] Ensure we don't prune too much stacktrace when reporting failures
-  * [IEx] Fix an issue where `iex.bat` on Windows was not passing the proper parameters forward
-  * [Kernel] Ensure modules defined on root respect defined aliases
-  * [Kernel] Do not wrap single lists in `:__block__`
-  * [Kernel] Ensure emitted beam code works nicely with dialyzer
-  * [Kernel] Do not allow a module named `Elixir` to be defined
-  * [Kernel] Create remote funs even if mod is a variable in capture `&mod.fun/arity`
-  * [Kernel] Improve compiler message when duplicated modules are detected
-  * [Mix] Generate `.gitignore` for `--umbrella` projects
-  * [Mix] Verify if a git dependency in deps has a proper git checkout and clean it automatically when it doesn't
-  * [Mix] Ensure `mix test` works with `IEx.pry/0`
-  * [System] Convert remaining functions in System to rely on char data
-
-* Soft deprecations (no warnings emitted)
-  * [Exception] `exception.message` is deprecated in favor `Exception.message/1` for retrieving exception messages
-  * [Kernel] `is_exception/1`, `is_record/1` and `is_record/2` are deprecated in favor of `Exception.exception?1`, `Record.record?/1` and `Record.record?/2`
-  * [Mix] `Mix.project/0` is deprecated in favor of `Mix.Project.config/0`
-  * [Process] `Process.spawn/1`, `Process.spawn/3`, `Process.spawn_link/1`, `Process.spawn_link/3`, `Process.spawn_monitor/1`, `Process.spawn_monitor/3`, `Process.send/2` and `Process.self/0` are deprecated in favor of the ones in `Kernel`
-
-* Deprecations
-  * [IEx] IEx.Options is deprecated in favor of `IEx.configure/1` and `IEx.configuration/0`
-  * [Kernel] `lc` and `bc` comprehensions are deprecated in favor of `for`
-  * [Macro] `Macro.safe_terms/1` is deprecated
-  * [Process] `Process.delete/0` is deprecated
-  * [Regex] Deprecate `:global` option in `Regex.split/3` in favor of `parts: :infinity`
-  * [String] Deprecate `:global` option in `String.split/3` in favor of `parts: :infinity`
-
-* Backwards incompatible changes
-  * [ExUnit] `ExUnit.Test` and `ExUnit.TestCase` has been converted to structs
-  * [ExUnit] The test and callback context has been converted to maps
-  * [Kernel] `File.Stat`, `HashDict`, `HashSet`, `Inspect.Opts`, `Macro.Env`, `Range`, `Regex` and `Version.Requirement` have been converted to structs. This means `is_record/2` checks will no longer work, instead, you can pattern match on them using `%Range{}` and similar
-  * [URI] The `URI.Info` record has now become the `URI` struct
-  * [Version] The `Version.Schema` record has now become the `Version` struct
-
-## v0.13.1 (2014-04-27)
-
-* Enhancements
-  * [Mix] Support `MIX_EXS` as configuration for running the current mix.exs file
-  * [Mix] Support Hex out of the box. This means users do not need to install Hex directly, instead, Mix will prompt whenever there is a need to have Hex installed
-
-* Bug fixes
-  * [ExUnit] Ensure doctest failures are properly reported
-  * [Kernel] Fix a bug where comprehensions arguments were not properly take into account in the variable scope
-  * [Mix] Fix issue on rebar install when the endpoint was redirecting to a relative uri
-
-* Soft deprecations (no warnings emitted)
-  * [Kernel] `iolist_size` and `iolist_to_binary` are deprecated in favor of `iodata_length` and `iodata_to_binary`
-  * [String] `String.to_char_list/1` is deprecated in favor of `List.from_char_data/1`
-  * [String] `String.from_char_list/1` is deprecated in favor of `String.from_char_data/1`
-
-* Deprecations
-  * [Mix] `:env` key in project configuration is deprecated
-  * [Regex] `Regex.groups/1` is deprecated in favor of `Regex.names/1`
-
-* Backwards incompatible changes
-  * [Macro] `Macro.unpipe/1` now returns tuples and `Macro.pipe/2` was removed in favor of `Macro.pipe/3` which explicitly expects the second element of the tuple returned by the new `Macro.unpipe/1`
-  * [Path] The functions in Path now only emit strings as result, regardless if the input was a char list or a string
-  * [Path] Atoms are no longer supported in Path functions
-  * [Regex] Regexes are no longer unicode by default. Instead, they must be explicitly marked with the `u` option
-
-## v0.13.0 (2014-04-20)
-
-* Enhancements
-  * [Base] Add `Base` module which does conversions to bases 16, 32, hex32, 64 and url64
-  * [Code] Add `Code.eval_file/2`
-  * [Collectable] Add the `Collectable` protocol that empowers `Enum.into/2` and `Stream.into/2` and the `:into` option in comprehensions
-  * [Collectable] Implement `Collectable` for lists, dicts, bitstrings, functions and provide both `File.Stream` and `IO.Stream`
-  * [EEx] Add `handle_body/1` callback to `EEx.Engine`
-  * [Enum] Add `Enum.group_by/2`, `Enum.into/2`, `Enum.into/3`, `Enum.traverse/2` and `Enum.sum/2`
-  * [ExUnit] Randomize cases and tests suite runs, allow seed configuration and the `--seed` flag via `mix test`
-  * [ExUnit] Support `--only` for filtering when running tests with `mix test`
-  * [ExUnit] Raise an error if another `capture_io` process already captured the device
-  * [ExUnit] Improve formatter to show source code and rely on lhs and rhs (instead of expected and actual)
-  * [IEx] Allow prompt configuration with the `:prompt` option
-  * [IEx] Use werl on Windows
-  * [Kernel] Support `ERL_PATH` in `bin/elixir`
-  * [Kernel] Support interpolation in keyword syntax
-  * [Map] Add a Map module and support 17.0 maps and structs
-  * [Mix] Add dependency option `:only` to specify the dependency environment. `mix deps.get` and `mix deps.update` works accross all environment unless `--only` is specified
-  * [Mix] Add `Mix.Shell.prompt/1`
-  * [Mix] Ensure the project is compiled in case Mix' CLI cannot find a task
-  * [Node] Add `Node.ping/1`
-  * [Process] Include `Process.send/3` and support the `--gen-debug` option
-  * [Regex] Regexes no longer need the "g" option when there is a need to use named captures
-  * [Stream] Add `Stream.into/2` and `Stream.into/3`
-  * [StringIO] Add a `StringIO` module that allows a String to be used as IO device
-  * [System] Add `System.delete_env/1` to remove a variable from the environment
-
-* Bug fixes
-  * [CLI] Ensure `--app` is handled as an atom before processing
-  * [ExUnit] Ensure `ExUnit.Assertions` does not emit compiler warnings for `assert_receive`
-  * [Kernel] Ensure the same pid is not queued twice in the parallel compiler
-  * [Macro] `Macro.to_string/2` considers proper precedence when translating `!(foo > bar)` into a string
-  * [Mix] Automatically recompile on outdated Elixir version and show proper error messages
-  * [Mix] Ensure generated `.app` file includes core dependencies
-  * [Mix] Allow a dependency with no SCM to be overridden
-  * [Mix] Allow queries in `mix local.install` URL
-  * [OptionParser] Do not recognize undefined aliases as switches
-
-* Soft deprecations (no warnings emitted)
-  * [Kernel] `lc` and `bc` comprehensions are deprecated in favor of `for`
-  * [ListDict] `ListDict` is deprecated in favor of `Map`
-  * [Record] `defrecord/2`, `defrecordp/3`, `is_record/1` and `is_record/2` macros in Kernel are deprecated. Instead, use the new macros and API defined in the `Record` module
-
-* Deprecations
-  * [Dict] `Dict.empty/1`, `Dict.new/1` and `Dict.new/2` are deprecated
-  * [Exception] `Exception.normalize/1` is deprecated in favor of `Exception.normalize/2`
-
-* Backwards incompatible changes
-  * [ExUnit] Formatters are now required to be a GenEvent and `ExUnit.run/2` returns a map with results
-
-## v0.12.5 (2014-03-09)
-
-* Bug fixes
-  * [Kernel] Ensure `try` does not generate an after clause. Generating an after clause forbade clauses in the `else` part from being tail recursive. This should improve performance and memory consumption of `Stream` functions
-  * [Mix] Automatically recompile on outdated Elixir version and show proper error messages
-
-* Deprecations
-  * [File] `File.stream_to!/3` is deprecated
-  * [GenFSM] `GenFSM` is deprecated
-  * [Kernel] `%` for sigils is deprecated in favor of `~`
-  * [Kernel] `is_range/1` and `is_regex/1` are deprecated in favor of `Range.range?/1` and `Regex.regex?/1`
-  * [Stream] `Stream.after/1` is deprecated
-  * [URI] `URI.decode_query/1` is deprecated in favor of `URI.decode_query/2` with explicit dict argument
-  * [URI] Passing lists as key or values in `URI.encode_query/1` is deprecated
-
-* Backwards incompatible changes
-  * [Mix] Remove `MIX_GIT_FORCE_HTTPS` as Git itself already provides mechanisms for doing so
-
-## v0.12.4 (2014-02-12)
-
-* Enhancements
-  * [Mix] `mix deps.get` and `mix deps.update` no longer compile dependencies afterwards. Instead, they mark the dependencies which are going to be automatically compiled next time `deps.check` is invoked (which is done automatically by most mix tasks). This means users should have a better workflow when migrating in between environments
-
-* Deprecations
-  * [Kernel] `//` for default arguments is deprecated in favor of `\\`
-  * [Kernel] Using `%` for sigils is deprecated in favor of `~`. This is a soft deprecation, no warnings will be emitted for it in this release
-  * [Kernel] Using `^` inside function clause heads is deprecated, please use a guard instead
-
-* Backwards incompatible changes
-  * [ExUnit] `CaptureIO` returns an empty string instead of nil when there is no capture
-  * [Version] The `Version` module now only works with SemVer. The functions `Version.parse/1` and `Version.parse_requirement/1` now return `{:ok,res} | :error` for the cases you want to handle non SemVer cases manually. All other functions will trigger errors on non semantics versions
-
-## v0.12.3 (2014-02-02)
-
-* Enhancements
-  * [Kernel] Warnings now are explicitly tagged with "warning:" in messages
-  * [Kernel] Explicit functions inlined by the compiler, including operators. This means that `Kernel.+/2` will now expand to `:erlang.+/2` and so on
-  * [Mix] Do not fail if a Mix dependency relies on an outdated Elixir version
-  * [Process] Add `Process.send/2` and `Process.send_after/3`
-  * [Version] Add `Version.compare/2`
-
-* Bug fixes
-  * [Atom] Inspect `:...` and `:foo@bar` without quoting
-  * [Keyword] The list `[1, 2, three: :four]` now correctly expands to `[1, 2, {:three, :four}]`
-  * [Kernel] Ensure undefined `@attributes` shows proper stacktrace in warnings
-  * [Kernel] Guarantee nullary funs/macros are allowed in guards
-  * [Process] Ensure monitoring functions are inlined by the compiler
-
-* Deprecations
-  * [IEx] The helper `m/0` has been deprecated. The goal is to group all runtime statistic related helpers into a single module
-  * [Kernel] `binary_to_term/1`, `binary_to_term/2`, `term_to_binary/1` and `term_to_binary/2` are deprecated in favor of their counterparts in the `:erlang` module
-  * [Kernel] `//` for default arguments is deprecated in favor of `\\`. This is a soft deprecation, no warnings will be emitted for it in this release
-  * [Kernel] Deprecated `@behavior` in favor of `@behaviour`
-  * [Record] `to_keywords`, `getter` and `list getter` functionalities in `defrecordp` are deprecated
-  * [Record] `Record.import/2` is deprecated
-
-* Backwards incompatible changes
-  * [Dict] Implementations of `equal?/2` and `merge/2` in `HashDict` and `ListDict` are no longer polymorphic. To get polymorphism, use the functions in `Dict` instead
-  * [File] `File.cp/3` and `File.cp_r/3` no longer carry Unix semantics where the function behaves differently if the destination is an existing previous directory or not. It now always copies source to destination, doing it recursively in the latter
-  * [IEx] IEx now loads the `.iex.exs` file instead of `.iex`
-  * [Kernel] Remove `**` from the list of allowed operators
-  * [Kernel] Limit sigils delimiters to one of the following: `<>`, `{}`, `[]`, `()`, `||`, `//`, `"` and `'`
-  * [Range] `Range` is no longer a record, instead use `first .. last` if you need pattern matching
-  * [Set] Implementations of `difference/2`, `disjoint?/2`, `equal?/2`, `intersection/2`, `subset?/2` and `union/2` in `HashSet` are no longer polymorphic. To get polymorphism, use the functions in `Set` instead
-
-## v0.12.2 (2014-01-15)
-
-* Enhancements
-  * [EEx] Allow `EEx.AssignsEngine` to accept any Dict
-  * [Enum] Add `Enum.flat_map_reduce/3`
-  * [ExUnit] Support `@moduletag` in ExUnit cases
-  * [Kernel] Improve stacktraces to be relative to the compilation path and include the related application
-  * [Stream] Add `Stream.transform/3`
-
-* Bug fixes
-  * [ExUnit] `:include` in ExUnit only has effect if a test was previously excluded with `:exclude`
-  * [ExUnit] Only run `setup_all` and `teardown_all` if there are tests in the case
-  * [Kernel] Ensure bitstring modifier arguments are expanded
-  * [Kernel] Ensure compiler does not block on missing modules
-  * [Kernel] Ensure `<>/2` works only with binaries
-  * [Kernel] Fix usage of string literals inside `<<>>` when `utf8`/`utf16`/`utf32` is used as specifier
-  * [Mix] Ensure mix properly copies _build dependencies on Windows
-
-* Deprecations
-  * [Enum] Deprecate `Enum.first/1` in favor of `Enum.at/2` and `List.first/1`
-  * [Kernel] Deprecate continuable heredocs. In previous versions, Elixir would continue parsing on the same line the heredoc started, this behaviour has been deprecated
-  * [Kernel] `is_alive/0` is deprecated in favor of `Node.alive?`
-  * [Kernel] `Kernel.inspect/2` with `Inspect.Opts[]` is deprecated in favor of `Inspect.Algebra.to_doc/2`
-  * [Kernel] `Kernel.inspect/2` with `:raw` option is deprecated, use `:records` option instead
-  * [Kernel] Deprecate `<-/2` in favor of `send/2`
-
-* Backwards incompatible changes
-  * [String] Change `String.next_grapheme/1` and `String.next_codepoint/1` to return `nil` on string end
-
-## v0.12.1 (2014-01-04)
-
-* Enhancements
-  * [ExUnit] Support `:include` and `:exclude` configuration options to filter which tests should run based on their tags. Those options are also supported via `mix test` as `--include` and `--exclude`
-  * [ExUnit] Allow doctests to match against `#MyModule<>`
-
-* Bug fixes
-  * [CLI] Abort when a pattern given to elixirc does not match any file
-  * [Float] Fix `Float.parse/1` to handle numbers of the form "-0.x"
-  * [IEx] Improve error message for `IEx.Helpers.r` when module does not exist
-  * [Mix] Ensure `deps.get` updates origin if lock origin and dep origin do not match
-  * [Mix] Use relative symlinks in _build
-  * [Typespec] Fix conversion of unary ops from typespec format to ast
-  * [Typespec] Fix handling of `tuple()` and `{}`
-
-* Deprecations
-  * [Kernel] Do not leak clause heads. Previously, a variable defined in a case/receive head clauses would leak to the outer scope. This behaviour is deprecated and will be removed in the next release.
-  * [Kernel] Deprecate `__FILE__` in favor of `__DIR__` or `__ENV__.file`
-
-* Backwards incompatible changes
-  * [GenFSM] GenServer now stops on unknown event/sync_event requests
-  * [GenServer] GenServer now stops on unknown call/cast requests
-  * [Kernel] Change how `->` is represented in AST. Now each clause is represented by its own AST node which makes composition easier. See commit 51aef55 for more information.
-
-## v0.12.0 (2013-12-15)
-
-* Enhancements
-  * [Exception] Allow `exception/1` to be overridden and promote it as the main mechanism to customize exceptions
-  * [File] Add `File.stream_to!/3`
-  * [Float] Add `Float.floor/1`, `Float.ceil/1` and `Float.round/3`
-  * [Kernel] Add `List.delete_at/2` and `List.updated_at/3`
-  * [Kernel] Add `Enum.reverse/2`
-  * [Kernel] Implement `defmodule/2`, `@/1`, `def/2` and friends in Elixir itself. `case/2`, `try/2` and `receive/1` have been made special forms. `var!/1`, `var!/2` and `alias!/1` have also been implemented in Elixir and demoted from special forms
-  * [Record] Support dynamic fields in `defrecordp`
-  * [Stream] Add `Stream.resource/3`
-  * [Stream] Add `Stream.zip/2`, `Stream.filter_map/3`, `Stream.each/2`, `Stream.take_every/2`, `Stream.chunk/2`, `Stream.chunk/3`, `Stream.chunk/4`, `Stream.chunk_by/2`, `Stream.scan/2`, `Stream.scan/3`, `Stream.uniq/2`, `Stream.after/2` and `Stream.run/1`
-  * [Stream] Support `Stream.take/2` and `Stream.drop/2` with negative counts
-
-* Bug fixes
-  * [HashDict] Ensure a `HashDict` stored in an attribute can be accessed via the attribute
-  * [Enum] Fix bug in `Enum.chunk/4` where you'd get an extra element when the enumerable was a multiple of the counter and a pad was given
-  * [IEx] Ensure `c/2` helper works with full paths
-  * [Kernel] `quote location: :keep` now only affects definitions in order to keep the proper trace in definition exceptions
-  * [Mix] Also symlink `include` directories in _build dependencies
-  * [Version] Fix `Version.match?/2` with `~>` and versions with alphanumeric build info (like `-dev`)
-
-* Deprecations
-  * [Enum] `Enumerable.count/1` and `Enumerable.member?/2` should now return tagged tuples. Please see `Enumerable` docs for more info
-  * [Enum] Deprecate `Enum.chunks/2`, `Enum.chunks/4` and `Enum.chunks_by/2` in favor of `Enum.chunk/2`, `Enum.chunk/4` and `Enum.chunk_by/2`
-  * [File] `File.binstream!/3` is deprecated. Simply use `File.stream!/3` which is able to figure out if `stream` or `binstream` operations should be used
-  * [Macro] `Macro.extract_args/1` is deprecated in favor of `Macro.decompose_call/1`
-
-* Backwards incompatible changes
-  * [Enum] Behaviour of `Enum.drop/2` and `Enum.take/2` has been switched when given negative counts
-  * [Enum] Behaviour of `Enum.zip/2` has been changed to stop as soon as the first enumerable finishes
-  * [Enum] `Enumerable.reduce/3` protocol has changed to support suspension. Please see `Enumerable` docs for more info
-  * [Mix] Require `:escript_main_module` to be set before generating escripts
-  * [Range] `Range.Iterator` protocol has changed in order to work with the new `Enumerable.reduce/3`. Please see `Range.Iterator` docs for more info
-  * [Stream] The `Stream.Lazy` structure has changed to accumulate functions and accumulators as we go (its inspected representation has also changed)
-  * [Typespec] `when` clauses were moved to the outer part of the spec and should be in the keywords format. So `add(a, b) when is_subtype(a, integer) and is_subtype(b, integer) :: integer` should now be written as `add(a, b) :: integer when a: integer, b: integer`
-
-## v0.11.2 (2013-11-14)
-
-* Enhancements
-  * [Mix] Add `mix iex` that redirects users to the proper `iex -S mix` command
-  * [Mix] Support `build_per_environment: true` in project configuration that manages a separete build per environment, useful when you have per-environment behaviour/compilation
-
-* Backwards incompatible changes
-  * [Mix] Mix now compiles files to `_build`. Projects should update just fine, however documentation and books may want to update to the latest information
-
-## v0.11.1 (2013-11-07)
-
-* Enhancements
-  * [Mix] Improve dependency convergence by explicitly checking each requirement instead of expecting all requirements to be equal
-  * [Mix] Support optional dependencies with `optional: true`. Optional dependencies are downloaded for the current project but they are automatically skipped when such project is used as a dependency
-
-* Bug fixes
-  * [Kernel] Set compilation status per ParallelCompiler and not globally
-  * [Mix] Ensure Mix does not load previous dependencies versions before `deps.get`/`deps.update`
-  * [Mix] Ensure umbrella apps are sorted before running recursive commands
-  * [Mix] Ensure umbrella apps run in the same environment as the parent project
-  * [Mix] Ensure dependency tree is topsorted before compiling
-  * [Mix] Raise error when duplicated projects are pushed into the stack
-  * [URI] Allow lowercase escapes in URI
-
-* Backwards incompatible changes
-  * [Mix] Setting `:load_paths` in your project configuration is deprecated
-
-## v0.11.0 (2013-11-02)
-
-* Enhancements
-  * [Code] Eval now returns variables from other contexts
-  * [Dict] Document and enforce all dicts use the match operator (`===`) when checking for keys
-  * [Enum] Add `Enum.slice/2` with a range
-  * [Enum] Document and enforce `Enum.member?/2` to use the match operator (`===`)
-  * [IEx] Split `IEx.Evaluator` from `IEx.Server` to allow custom evaluators
-  * [IEx] Add support for `IEx.pry` which halts a given process for inspection
-  * [IO] Add specs and allow some IO APIs to receive any data that implements `String.Chars`
-  * [Kernel] Improve stacktraces on command line interfaces
-  * [Kernel] Sigils can now handle balanced tokens as in `%s(f(o)o)`
-  * [Kernel] Emit warnings when an alias is not used
-  * [Macro] Add `Macro.pipe/3` and `Macro.unpipe/1` for building pipelines
-  * [Mix] Allow umbrella children to share dependencies between them
-  * [Mix] Allow mix to be escriptize'd
-  * [Mix] Speed mix projects compilation by relying on more manifests information
-  * [Protocol] Protocols now provide `impl_for/1` and `impl_for!/1` functions which receive a structure and returns its respective implementation, otherwise returns nil or an error
-  * [Set] Document and enforce all sets use the match operator (`===`) when checking for keys
-  * [String] Update to Unicode 6.3.0
-  * [String] Add `String.slice/2` with a range
-
-* Bug fixes
-  * [Exception] Ensure `defexception` fields can be set dynamically
-  * [Kernel] Guarantee aliases hygiene is respected when the current module name is not known upfront
-  * [Kernel] `Kernel.access/2` no longer flattens lists
-  * [Mix] Ensure cyclic dependencies are properly handled
-  * [String] Implement the extended grapheme cluster algorithm for `String` operations
-
-* Deprecations
-  * [Kernel] `pid_to_list/1`, `list_to_pid/1`, `binary_to_atom/2`, `binary_to_existing_atom/2` and `atom_to_binary/2` are deprecated in favor of their counterparts in the `:erlang` module
-  * [Kernel] `insert_elem/3` and `delete_elem/2` are deprecated in favor of `Tuple.insert_at/3` and `Tuple.delete_at/2`
-  * [Kernel] Use of `in` inside matches (as in `x in [1,2,3] -> x`) is deprecated in favor of the guard syntax (`x when x in [1,2,3]`)
-  * [Macro] `Macro.expand_all/2` is deprecated
-  * [Protocol] `@only` and `@except` in protocols are now deprecated
-  * [Protocol] Protocols no longer fallback to `Any` out of the box (this functionality needs to be explicitly enabled by setting `@fallback_to_any` to true)
-  * [String] `String.to_integer/1` and `String.to_float/1` are deprecated in favor of `Integer.parse/1` and `Float.parse/1`
-
-* Backwards incompatible changes
-  * [CLI] Reading `.elixirrc` has been dropped in favor of setting env vars
-  * [Kernel] `Kernel.access/2` now expects the second argument to be a compile time list
-  * [Kernel] `fn -> end` quoted expression is no longer wrapped in a `do` keyword
-  * [Kernel] Quoted variables from the same module must be explicitly shared. Previously, if a function returned `quote do: a = 1`, another function from the same module could access it as `quote do: a`. This has been fixed and the variables must be explicitly shared with `var!(a, __MODULE__)`
-  * [Mix] Umbrella apps now treat children apps as dependencies. This means all dependencies will be checked out in the umbrela `deps` directory. On upgrade, child apps need to point to the umbrella project by setting `deps_path: "../../deps_path", lockfile: "../../mix.lock"` in their project config
-  * [Process] `Process.group_leader/2` args have been reversed so the "subject" comes first
-  * [Protocol] Protocol no longer dispatches to `Number`, but to `Integer` and `Float`
-
-## v0.10.3 (2013-10-02)
-
-* Enhancements
-  * [Enum] Add `Enum.take_every/2`
-  * [IEx] IEx now respects signals sent from the Ctrl+G menu
-  * [Kernel] Allow documentation for types with `@typedoc`
-  * [Mix] Allow apps to be selected in umbrella projects
-  * [Record] Generated record functions `new` and `update` also take options with strings as keys
-  * [Stream] Add `Stream.unfold/1`
-
-* Bug fixes
-  * [Dict] Fix a bug when a HashDict was marked as equal when one was actually a subset of the other
-  * [EEx] Solve issue where `do` blocks inside templates were not properly aligned
-  * [ExUnit] Improve checks and have better error reports on poorly aligned doctests
-  * [Kernel] Fix handling of multiple heredocs on the same line
-  * [Kernel] Provide better error messages for match, guard and quoting errors
-  * [Kernel] Make `Kernel.raise/2` a macro to avoid messing up stacktraces
-  * [Kernel] Ensure `&()` works on quoted blocks with only one expression
-  * [Mix] Address an issue where a dependency was not compiled in the proper order when specified in different projects
-  * [Mix] Ensure `compile: false` is a valid mechanism for disabling the compilation of dependencies
-  * [Regex] Fix bug on `Regex.scan/3` when capturing groups and the regex has no groups
-  * [String] Fix a bug with `String.split/2` when given an empty pattern
-  * [Typespec] Guarantee typespecs error reports point to the proper line
-
-* Deprecations
-  * [Kernel] The previous partial application syntax (without the `&` operator) has now been deprecated
-  * [Regex] `Regex.captures/3` is deprecated in favor of `Regex.named_captures/3`
-  * [String] `String.valid_codepoint?/1` is deprecated in favor of pattern matching with `<<_ :: utf8 >>`
-
-* Backwards incompatible changes
-  * [IEx] The `r/0` helper has been removed as it caused surprising behaviour when many modules with dependencies were accumulated
-  * [Mix] `Mix.Version` was renamed to `Version`
-  * [Mix] `File.IteratorError` was renamed to `IO.StreamError`
-  * [Mix] `mix new` now defaults to the `--sup` option, use `--bare` to get the previous behaviour
-
-## v0.10.2 (2013-09-03)
-
-* Enhancements
-  * [CLI] Add `--verbose` to elixirc, which now is non-verbose by default
-  * [Dict] Add `Dict.Behaviour` as a convenience to create your own dictionaries
-  * [Enum] Add `Enum.split/2`, `Enum.reduce/2`, `Enum.flat_map/2`, `Enum.chunk/2`, `Enum.chunk/4`, `Enum.chunk_by/2`, `Enum.concat/1` and `Enum.concat/2`
-  * [Enum] Support negative indices in `Enum.at/fetch/fetch!`
-  * [ExUnit] Show failures on CLIFormatter as soon as they pop up
-  * [IEx] Allow for strings in `h` helper
-  * [IEx] Helpers `r` and `c` can handle erlang sources
-  * [Integer] Add `odd?/1` and `even?/1`
-  * [IO] Added support to specifying a number of bytes to stream to `IO.stream`, `IO.binstream`, `File.stream!` and `File.binstream!`
-  * [Kernel] Include file and line on error report for overriding an existing function/macro
-  * [Kernel] Convert external functions into quoted expressions. This allows record fields to contain functions as long as they point to an `&Mod.fun/arity`
-  * [Kernel] Allow `foo?` and `bar!` as valid variable names
-  * [List] Add `List.replace_at/3`
-  * [Macro] Improve printing of the access protocol on `Macro.to_string/1`
-  * [Macro] Add `Macro.to_string/2` to support annotations on the converted string
-  * [Mix] Automatically recompile a project if the Elixir version changes
-  * [Path] Add `Path.relative_to_cwd/2`
-  * [Regex] Allow erlang `re` options when compiling Elixir regexes
-  * [Stream] Add `Stream.concat/1`, `Stream.concat/2` and `Stream.flat_map/2`
-  * [String] Add regex pattern support to `String.replace/3`
-  * [String] Add `String.ljust/2`, `String.rjust/2`, `String.ljust/3` and `String.rjust/3`
-  * [URI] `URI.parse/1` supports IPv6 addresses
-
-* Bug fixes
-  * [Behaviour] Do not compile behaviour docs if docs are disabled on compilation
-  * [ExUnit] Doctests no longer eat too much space and provides detailed reports for poorly indented lines
-  * [File] Fix a bug where `File.touch(file, datetime)` was not setting the proper datetime when the file did not exist
-  * [Kernel] Limit `inspect` results to 50 items by default to avoid printing too much data
-  * [Kernel] Return a readable error on oversized atoms
-  * [Kernel] Allow functions ending with `?` or `!` to be captured
-  * [Kernel] Fix default shutdown of child supervisors to `:infinity`
-  * [Kernel] Fix regression when calling a function/macro ending with bang, followed by `do/end` blocks
-  * [List] Fix bug on `List.insert_at/3` that added the item at the wrong position for negative indexes
-  * [Macro] `Macro.escape/2` can now escape improper lists
-  * [Mix] Fix `Mix.Version` matching on pre-release info
-  * [Mix] Ensure `watch_exts` trigger full recompilation on change with `mix compile`
-  * [Mix] Fix regression on `mix clean --all`
-  * [String] `String.strip/2` now supports removing unicode characters
-  * [String] `String.slice/3` still returns the proper result when there is no length to be extracted
-  * [System] `System.get_env/0` now returns a list of tuples as previously advertised
-
-* Deprecations
-  * [Dict] `Dict.update/3` is deprecated in favor of `Dict.update!/3`
-  * [Enum] `Enum.min/2` and `Enum.max/2` are deprecated in favor of `Enum.min_by/2` and `Enum.max_by/2`
-  * [Enum] `Enum.join/2` and `Enum.map_join/3` with a char list are deprecated
-  * [IO] `IO.stream(device)` and `IO.binstream(device)` are deprecated in favor of `IO.stream(device, :line)` and `IO.binstream(device, :line)`
-  * [Kernel] `list_to_binary/1`, `binary_to_list/1` and `binary_to_list/3` are deprecated in favor of `String.from_char_list!/1` and `String.to_char_list!/1` for characters and `:binary.list_to_bin/1`, `:binary.bin_to_list/1` and `:binary.bin_to_list/3` for bytes
-  * [Kernel] `to_binary/1` is deprecated in favor of `to_string/1`
-  * [Kernel] Deprecate `def/4` and friends in favor of `def/2` with unquote and friends
-  * [Kernel] Deprecate `%b` and `%B` in favor of `%s` and `%S`
-  * [List] `List.concat/2` is deprecated in favor of `Enum.concat/2`
-  * [Macro] `Macro.unescape_binary/1` and `Macro.unescape_binary/2` are deprecated in favor of `Macro.unescape_string/1` and `Macro.unescape_string/2`
-  * [Mix] `:umbrella` option for umbrella paths has been deprecated in favor of `:in_umbrella`
-
-* Backwards incompatible changes
-  * [IO] IO functions now only accept iolists as arguments
-  * [Kernel] `Binary.Chars` was renamed to `String.Chars`
-  * [Kernel] The previous ambiguous import syntax `import :functions, Foo` was removed in favor of `import Foo, only: :functions`
-  * [OptionParser] `parse` and `parse_head` now returns a tuple with three elements instead of two
-
-## v0.10.1 (2013-08-03)
-
-* Enhancements
-  * [Behaviour] Add support for `defmacrocallback/1`
-  * [Enum] Add `Enum.shuffle/1`
-  * [ExUnit] The `:trace` option now also reports run time for each test
-  * [ExUnit] Add support for `:color` to enable/disable ANSI coloring
-  * [IEx] Add the `clear` helper to clear the screen.
-  * [Kernel] Add the capture operator `&`
-  * [Kernel] Add support for `GenFSM.Behaviour`
-  * [Kernel] Functions now points to the module and function they were defined when inspected
-  * [Kernel] A documentation attached to a function that is never defined now prints warnings
-  * [List] Add `List.keysort/2`
-  * [Mix] `:test_helper` project configuration did not affect `mix test` and was therefore removed. A `test/test_helper.exs` file is still necessary albeit it doesn't need to be automatically required in each test file
-  * [Mix] Add manifests for yecc, leex and Erlang compilers, making it easier to detect dependencies in between compilers and providing a more useful clean behaviour
-  * [Mix] `mix help` now outputs information about the default mix task
-  * [Mix] Add `--no-deps-check` option to `mix run`, `mix compile` and friends to not check dependency status
-  * [Mix] Add support for `MIX_GIT_FORCE_HTTPS` system environment that forces HTTPS for known providers, useful when the regular git port is blocked. This configuration does not affect the `mix.lock` results
-  * [Mix] Allow coverage tool to be pluggable via the `:test_coverage` configuration
-  * [Mix] Add `mix cmd` as a convenience to run a command recursively in child apps in an umbrella application
-  * [Mix] Support `umbrella: true` in dependencies as a convenience for setting up umbrella path deps
-  * [Mix] `mix run` now behaves closer to the `elixir` command and properly mangles the ARGV
-  * [String] Add `Regex.scan/3` now supports capturing groups
-  * [String] Add `String.reverse/1`
-
-* Bug fixes
-  * [Behaviour] Ensure callbacks are stored in the definition order
-  * [CLI] Speed up boot time on Elixir .bat files
-  * [IEx] Reduce cases where IEx parser can get stuck
-  * [Kernel] Improve error messages when the use of an operator has no effect
-  * [Kernel] Fix a bug where warnings were not being generated when imported macros conflicted with local functions or macros
-  * [Kernel] Document that `on_definition` can only be a function as it is evaluated inside the function context
-  * [Kernel] Ensure `%w` sigils with no interpolation are fully expanded at compile time
-  * [Mix] `mix deps.update`, `mix deps.clean` and `mix deps.unlock` no longer change all dependencies unless `--all` is given
-  * [Mix] Always run ` mix loadpaths` on `mix app.start`, even if `--no-compile` is given
-  * [OptionParser] Do not add boolean flags to the end result if they were not given
-  * [OptionParser] Do not parse non-boolean flags as booleans when true or false are given
-  * [OptionParser] Ensure `:keep` and `:integer`|`:float` can be given together as options
-  * [OptionParser] Ensure `--no-flag` sets `:flag` to false when `:flag` is a registered boolean switch
-
-* Deprecations
-  * [Kernel] `function(Mod.fun/arity)` and `function(fun/arity)` are deprecated in favor of `&Mod.fun/arity` and `&fun/arity`
-  * [Kernel] `function/3` is deprecated in favor of `Module.function/3`
-  * [Kernel] `Kernel.ParallelCompiler` now receives a set of callbacks instead of a single one
-  * [Mix] `:test_coverage` option now expect keywords arguments and the `--cover` flag is now treated as a boolean
-
-* Backwards incompatible changes
-  * [Regex] `Regex.scan/3` now always returns a list of lists, normalizing the result, instead of list with mixed lists and binaries
-  * [System] `System.halt/2` was removed since the current Erlang implementation of such function is bugged
-
-## v0.10.0 (2013-07-15)
-
-* Enhancements
-  * [ExUnit] Support `trace: true` option which gives detailed reporting on test runs
-  * [HashDict] Optimize `HashDict` to store pairs in a cons cell reducing storage per key by half
-  * [Kernel] Add pretty printing support for inspect
-  * [Kernel] Add document algebra library used as the foundation for pretty printing
-  * [Kernel] Add `defrecordp/3` that enables specifying the first element of the tuple
-  * [Kernel] Add the `Set` API and a hash based implementation via `HashSet`
-  * [Kernel] Add `Stream` as composable, lazy-enumerables
-  * [Mix] `mix archive` now includes the version of the generated archive
-  * [Mix] Mix now requires explicit dependency overriding to be given with `override: true`
-  * [Mix] Projects can now define an `:elixir` key to outline supported Elixir versions
-  * [Typespec] Improve error messages to contain file, line and the typespec itself
-
-* Bug fixes
-  * [CLI] Elixir can now run on Unix directories with `:` in its path
-  * [Kernel] `match?/2` does not leak variables to outer scope
-  * [Kernel] Keep `head|tail` format when splicing at the tail
-  * [Kernel] Ensure variables defined in the module body are not passed to callbacks
-  * [Mix] On dependencies conflict, show from where each source is coming from
-  * [Mix] Empty projects no longer leave empty ebin files on `mix compile`
-  * [Module] Calling `Module.register_attribute/3` no longer automatically changes it to persisted or accumulated
-
-* Deprecations
-  * [Enum] Receiving the index of iteration in `Enum.map/2` and `Enum.each/2` is deprecated in favor of `Stream.with_index/1`
-  * [File] `File.iterator/1` and `File.biniterator/1` are deprecated in favor of `IO.stream/1` and `IO.binstream/1`
-  * [File] `File.iterator!/2` and `File.biniterator!/2` are deprecated in favor of `File.stream!/2` and `File.binstream!/2`
-  * [Kernel] Deprecate recently added `quote binding: ...` in favor of the clearer `quote bind_quoted: ...`
-  * [Kernel] Deprecate `Kernel.float/1` in favor of a explicit conversion
-  * [Mix] Deprecate `mix run EXPR` in favor of `mix run -e EXPR`
-  * [Record] `Record.__index__/2` deprecated in favor of `Record.__record__(:index, key)`
-
-* Backwards incompatible changes
-  * [Kernel] The `Binary.Inspect` protocol has been renamed to `Inspect`
-  * [Kernel] Tighten up the grammar rules regarding parentheses omission, previously the examples below would compile but now they raise an error message:
-
-            do_something 1, is_list [], 3
-            [1, is_atom :foo, 3]
-
-  * [Module] Calling `Module.register_attribute/3` no longer automatically changes it to persisted or accumulated
-  * [Record] First element of a record via `defrecordp` is now the `defrecordp` name and no longer the current atom
-  * [URI] Remove custom URI parsers in favor of `URI.default_port/2`
-
-## v0.9.3 (2013-06-23)
-
-* Enhancements
-  * [File] Add `File.chgrp`, `File.chmod` and `File.chown`
-  * [Kernel] Add `--warnings-as-errors` to Elixir's compiler options
-  * [Kernel] Print warnings to stderr
-  * [Kernel] Warn on undefined module attributes
-  * [Kernel] Emit warning for `x in []` in guards
-  * [Kernel] Add `binding/0` and `binding/1` for retrieving bindings
-  * [Kernel] `quote` now allows a binding as an option
-  * [Macro] Add `Macro.expand_once/2` and `Macro.expand_all/2`
-  * [Mix] Implement `Mix.Version` for basic versioning semantics
-  * [Mix] Support creation and installation of archives (.ez files)
-  * [Mix] `github: ...` shortcut now uses the faster `git` schema instead of `https`
-  * [Record] Allow types to be given to `defrecordp`
-
-* Bug fixes
-  * [Kernel] The elixir executable on Windows now supports the same options as the UNIX one
-  * [Kernel] Improve error messages on default clauses clash
-  * [Kernel] `__MODULE__.Foo` now returns `Foo` when outside of a Module
-  * [Kernel] Improve error messages when default clauses from different definitions collide
-  * [Kernel] `^x` variables should always refer to the value before the expression
-  * [Kernel] Allow `(x, y) when z` in function clauses and try expressions
-  * [Mix] Mix now properly evaluates rebar scripts
-
-* Deprecations
-  * [Code] `Code.string_to_ast/1` has been deprecated in favor of `Code.string_to_quoted/1`
-  * [Macro] `Macro.to_binary/1` has been deprecated in favor of `Macro.to_string/1`
-  * [Typespec] Deprecate `(fun(...) -> ...)` in favor of `(... -> ...)`
-
-* Backwards incompatible changes
-  * [Bitwise] Precedence of operators used by the Bitwise module were changed, check `elixir_parser.yrl` for more information
-  * [File] `rm_rf` and `cp_r` now returns a tuple with three elements on failures
-  * [Kernel] The quoted representation for `->` clauses changed from a tuple with two elements to a tuple with three elements to support metadata
-  * [Kernel] Sigils now dispatch to `sigil_$` instead of `__$__` where `$` is the sigil character
-  * [Macro] `Macro.expand/2` now expands until final form. Although this is backwards incompatible, it is very likely you do not need to change your code, since expansion until its final form is recommended, particularly if you are expecting an atom out of it
-  * [Mix] No longer support beam files on `mix local`
-
-## v0.9.2 (2013-06-13)
-
-* Enhancements
-  * [ExUnit] `capture_io` now captures prompt by default
-  * [Mix] Automatically import git dependencies from Rebar
-  * [Mix] Support for dependencies directly from the umbrella application
-  * [Regex] Add `Regex.escape`
-  * [String] Add `String.contains?`
-  * [URI] Implement `Binary.Chars` (aka `to_binary`) for `URI.Info`
-
-* Bug fixes
-  * [HashDict] Ensure HashDict uses exact match throughout its implementation
-  * [IEx] Do not interpret ANSI codes in IEx results
-  * [IEx] Ensure `--cookie` is set before accessing remote shell
-  * [Kernel] Do not ignore nil when dispatching protocols to avoid infinite loops
-  * [Mix] Fix usage of shell expressions in `Mix.Shell.cmd`
-  * [Mix] Start the application by default on escripts
-
-* Deprecations
-  * [Regex] `Regex.index/2` is deprecated in favor `Regex.run/3`
-  * [Kernel] `super` no longer supports implicit arguments
-
-* Backwards incompatible changes
-  * [Kernel] The `=~` operator now returns true or false instead of an index
-
-## v0.9.1 (2013-05-30)
-
-* Enhancements
-  * [IEx] Limit the number of entries kept in history and allow it to be configured
-  * [Kernel] Add `String.start_with?` and `String.end_with?`
-  * [Typespec] Allow keywords, e.g. `[foo: integer, bar: boolean | module]`, in typespecs
-
-* Bug fixes
-  * [Dict] `Enum.to_list` and `Dict.to_list` now return the same results for dicts
-  * [IEx] Enable shell customization via the `IEx.Options` module
-  * [Kernel] Fix a bug where `unquote_splicing` did not work on the left side of a stab op
-  * [Kernel] Unused functions with cyclic dependencies are now also warned as unused
-  * [Mix] Fix a bug where `mix deps.get` was not retrieving nested dependencies
-  * [Record] Fix a bug where nested records cannot be defined
-  * [Record] Fix a bug where a record named Record cannot be defined
-
-## v0.9.0 (2013-05-23)
-
-* Enhancements
-  * [ExUnit] `ExUnit.CaptureIO` now accepts an input to be used during capture
-  * [IEx] Add support for .iex files that are loaded during shell's boot process
-  * [IEx] Add `import_file/1` helper
-
-* Backwards incompatible changes
-  * [Enum] `Enum.Iterator` was replaced by the more composable and functional `Enumerable` protocol which supports reductions
-  * [File] `File.iterator/1` and `File.biniterator/1` have been removed in favor of the safe `File.iterator!/1` and `File.biniterator!/1` ones
-  * [Kernel] Erlang R15 is no longer supported
-  * [Kernel] Elixir modules are now represented as `Elixir.ModuleName` (using `.` instead of `-` as separator)
-
-## v0.8.3 (2013-05-22)
-
-* Enhancements
-  * [CLI] Flags `-p` and `-pr` fails if pattern match no files
-  * [CLI] Support `--hidden` and `--cookie` flags for distributed Erlang
-  * [Enum] Add `Enum.to_list/1`, `Enum.member?/2`, `Enum.uniq/2`, `Enum.max/1`, `Enum.max/2`, `Enum.min/1` and `Enum.min/2`
-  * [ExUnit] Add `ExUnit.CaptureIO` for IO capturing during tests
-  * [ExUnit] Consider load time on ExUnit time reports
-  * [IEx] Support `ls` with colored output
-  * [IEx] Add `#iex:break` to break incomplete expressions
-  * [Kernel] Add `Enum.at`, `Enum.fetch` and `Enum.fetch!`
-  * [Kernel] Add `String.to_integer` and `String.to_float`
-  * [Kernel] Add `Dict.take`, `Dict.drop`, `Dict.split`, `Dict.pop` and `Dict.fetch!`
-  * [Kernel] Many optimizations for code compilation
-  * [Kernel] `in` can be used with right side expression outside guards
-  * [Kernel] Add `Node.get_cookie/0` and `Node.set_cookie/2`
-  * [Kernel] Add `__DIR__`
-  * [Kernel] Expand macros and attributes on quote, import, alias and require
-  * [Kernel] Improve warnings related to default arguments
-  * [Keyword] Add `Keyword.delete_first/2`
-  * [Mix] Add `local.rebar` to download a local copy of rebar, and change `deps.compile` to use it if needed
-  * [Mix] Support umbrella applications
-  * [Mix] Load beam files available at `MIX_PATH` on CLI usage
-  * [String] Add `String.valid?` and `String.valid_character?`
-
-* Bug fixes
-  * [ExUnit] Handle exit messages from in ExUnit
-  * [ExUnit] Failures on ExUnit's setup_all now invalidates all tests
-  * [Kernel] Ensure we don't splice keyword args unecessarily
-  * [Kernel] Private functions used by private macros no longer emit an unused warning
-  * [Kernel] Ensure Elixir won't trip on empty receive blocks
-  * [Kernel] `String.slice` now returns an empty string when out of range by 1
-  * [Mix] Generate manifest files after compilation to avoid depending on directory timestamps and to remove unused .beam files
-  * [Path] `Path.expand/2` now correctly expands `~` in the second argument
-  * [Regex] Fix badmatch with `Regex.captures(%r/(.)/g, "cat")`
-  * [URI] Downcase host and scheme and URIs
-
-* Deprecations
-  * [Code] `Code.eval` is deprecated in favor of `Code.eval_string`
-  * [Exception] `Exception.format_entry` is deprecated in favor of `Exception.format_stacktrace_entry`
-  * [ExUnit] `assert left inlist right` is deprecated in favor of `assert left in right`
-  * [IO] `IO.getb` is deprecated in favor of `IO.getn`
-  * [List] `List.member?/2` is deprecated in favor of `Enum.member?/2`
-  * [Kernel] `var_context` in quote was deprecated in favor of `context`
-  * [Kernel] `Enum.at!` and `Dict.get!` is deprecated in favor of `Enum.fetch!` and `Dict.fetch!`
-
-* Backwards incompatible changes
-  * [Dict] `List.Dict` was moved to `ListDict`
-  * [IO] `IO.gets`, `IO.getn` and friends now return binaries when reading from stdio
-  * [Kernel] Precedence of `|>` has changed to lower to support constructs like `1..5 |> Enum.to_list`
-  * [Mix] `mix escriptize` now receives arguments as binaries
-
-## v0.8.2 (2013-04-20)
-
-* Enhancements
-  * [ExUnit] Use ANSI escape codes in CLI output
-  * [ExUnit] Include suite run time on CLI results
-  * [ExUnit] Add support to doctests, allowing test cases to be generated from code samples
-  * [File] Add `File.ls` and `File.ls!`
-  * [IEx] Support `pwd` and `cd` helpers
-  * [Kernel] Better error reporting for invalid bitstring generators
-  * [Kernel] Improve meta-programming by allowing `unquote` on `def/2`, `defp/2`, `defmacro/2` and `defmacrop/2`
-  * [Kernel] Add support to R16B new functions: `insert_elem/3` and `delete_elem/2`
-  * [Kernel] Import conflicts are now lazily handled. If two modules import the same functions, it will fail only if the function is invoked
-  * [Mix] Support `--cover` on mix test and `test_coverage` on Mixfiles
-  * [Record] Each record now provides `Record.options` with the options supported by its `new` and `update` functions
-
-* Bug fixes
-  * [Binary] inspect no longer escapes standalone hash `#`
-  * [IEx] The `h` helper can now retrieve docs for special forms
-  * [Kernel] Record optimizations were not being triggered in functions inside the record module
-  * [Kernel] Aliases defined inside macros should be carried over
-  * [Kernel] Fix a bug where nested records could not use the Record[] syntax
-  * [Path] Fix a bug on `Path.expand` when expanding paths starting with `~`
-
-* Deprecations
-  * [Kernel] `setelem/3` is deprecated in favor of `set_elem/3`
-  * [Kernel] `function(:is_atom, 1)` is deprecated in favor of `function(is_atom/1)`
-
-* Backwards incompatible changes
-  * [Kernel] `unquote` now only applies to the closest quote. If your code contains a quote that contains another quote that calls unquote, it will no longer work. Use `Macro.escape` instead and pass your quoted contents up in steps, for example:
-
-            quote do
-              quote do: unquote(x)
-            end
-
-      should become:
-
-            quote do
-              unquote(Macro.escape(x))
-            end
-
-## v0.8.1 (2013-02-17)
-
-* Enhancements
-  * [ExUnit] Tests can now receive metadata set on setup/teardown callbacks
-  * [ExUnit] Add support to ExUnit.CaseTemplate to share callbacks in between test cases
-  * [IO] Add `IO.ANSI` to make it easy to write ANSI escape codes
-  * [Kernel] Better support for Unicode lists
-  * [Kernel] Reduce variables footprint in `case`/`receive` clauses
-  * [Kernel] Disable native compilation when on_load attributes is present to work around an Erlang bug
-  * [Macro] `Macro.expand` also considers macros from the current `__ENV__` module
-  * [Mix] Improve support for compilation of `.erl` files
-  * [Mix] Add support for compilation of `.yrl` and `.xrl` files
-  * [OptionParser] Switches are now overridden by default but can be kept in order if chosen
-  * [Typespec] Better error reporting for invalid typespecs
-
-* Bug fixes
-  * [Mix] Allow Mix projects to be generated with just one letter
-
-* Backwards incompatible changes
-  * [Kernel] `before_compile` and `after_compile` callbacks now receive the environment as first argument instead of the module
-
-* Deprecations
-  * [ExUnit] Explicitly defined test/setup/teardown functions are deprecated
-  * [Kernel] Tidy up and clean `quote` API
-  * [Kernel] Old `:local.(args)` syntax is deprecated
-  * [Process] `Process.self` is deprecated in favor `Kernel.self`
-
-## v0.8.0 (2013-01-28)
-
-* Enhancements
-  * [Binary] Support `<< "string" :: utf8 >>` as in Erlang
-  * [Binary] Support `\a` escape character in binaries
-  * [Binary] Support syntax shortcut for specifying size in bit syntax
-  * [CLI] Support `--app` option to start an application and its dependencies
-  * [Dict] Support `put_new` in `Dict` and `Keyword`
-  * [Dict] Add `ListDict` and a faster `HashDict` implementation
-  * [ExUnit] ExUnit now supports multiple runs in the same process
-  * [ExUnit] Failures in ExUnit now shows a tailored stacktrace
-  * [ExUnit] Introduce `ExUnit.ExpectationError` to provide better error messages
-  * [Kernel] Introduce `Application.Behaviour` to define application module callbacks
-  * [Kernel] Introduce `Supervisor.Behaviour` to define supervisors callbacks
-  * [Kernel] More optimizations were added to Record handling
-  * [Kernel] `?\x` and `?\` are now supported ways to retrieve a codepoint
-  * [Kernel] Octal numbers can now be defined as `0777`
-  * [Kernel] Improve macros hygiene regarding variables, aliases and imports
-  * [Mix] Mix now starts the current application before run, iex, test and friends
-  * [Mix] Mix now provides basic support for compiling `.erl` files
-  * [Mix] `mix escriptize` only generates escript if necessary and accept `--force` and `--no-compile` as options
-  * [Path] Introduce `Path` module to hold filesystem paths related functions
-  * [String] Add `String.capitalize` and `String.slice`
-  * [System] Add `System.tmp_dir`, `System.cwd` and `System.user_home`
-
-* Bug fixes
-  * [Kernel] `import` with `only` accepts functions starting with underscore
-  * [String] `String.first` and `String.last` return nil for empty binaries
-  * [String] `String.rstrip` and `String.lstrip` now verify if argument is a binary
-  * [Typespec] Support `...` inside typespec's lists
-
-* Backwards incompatible changes
-  * [Kernel] The AST now allows metadata to be attached to each node. This means the second item in the AST is no longer an integer (representing the line), but a keywords list. Code that relies on the line information from AST or that manually generate AST nodes need to be properly updated
-
-* Deprecations
-  * [Dict] Deprecate `Binary.Dict` and `OrdDict` in favor of `HashDict` and `ListDict`
-  * [File] Deprecate path related functions in favor of the module `Path`
-  * [Kernel] The `/>` operator has been deprecated in favor of `|>`
-  * [Mix] `Mix.Project.sources` is deprecated in favor of `Mix.Project.config_files`
-  * [Mix] `mix iex` is no longer functional, please use `iex -S mix`
-  * [OptionParser] `:flags` option was deprecated in favor of `:switches` to support many types
-
-## v0.7.2 (2012-12-04)
-
-* Enhancements
-  * [CLI] `--debug-info` is now true by default
-  * [ExUnit] Make ExUnit exit happen in two steps allowing developers to add custom `at_exit` hooks
-  * [IEx] Many improvements to helpers functions `h/1`, `s/1` and others
-  * [Kernel] Functions defined with `fn` can now handle many clauses
-  * [Kernel] Raise an error if clauses with different arities are defined in the same function
-  * [Kernel] `function` macro now accepts arguments in `M.f/a` and `f/a` formats
-  * [Macro] Improvements to `Macro.to_binary`
-  * [Mix] Mix now echoes the output as it comes when executing external commands such as git or rebar
-  * [Mix] Mix now validates `application` callback's values
-  * [Record] Record accessors are now optimized and can be up to 6x faster in some cases
-  * [String] Support `\xXX` and `\x{HEX}` escape sequences in strings, char lists and regexes
-
-* Bug fixes
-  * [Bootstrap] Compiling Elixir source no longer fails if environment variables contain utf-8 entries
-  * [IEx] IEx will now wait for all command line options to be processed before starting
-  * [Kernel] Ensure proper stacktraces when showing deprecations
-
-* Deprecations
-  * [Enum] `Enum.qsort` is deprecated in favor of `Enum.sort`
-  * [List] `List.sort` and `List.uniq` have been deprecated in favor of their `Enum` counterparts
-  * [Record] Default-based generated functions are deprecated
-  * [Typespec] Enhancements and deprecations to the `@spec/@callback` and the fun type syntax
-
-## v0.7.1 (2012-11-18)
-
-* Enhancements
-  * [IEx] Only show documented functions and also show docs for default generated functions
-  * [IO] Add `IO.binread`, `IO.binwrite` and `IO.binreadline` to handle raw binary file operations
-  * [ExUnit] Add support for user configuration at `HOME/.ex_unit.exs`
-  * [ExUnit] Add support for custom formatters via a well-defined behaviour
-  * [Kernel] Add support for `defrecordp`
-  * [Kernel] Improved dialyzer support
-  * [Kernel] Improved error messages when creating functions with aliases names
-  * [Mix] Improve SCM behaviour to allow more robust integration
-  * [Mix] Changing deps information on `mix.exs` forces users to fetch new dependencies
-  * [Mix] Support (parallel) requires on mix run
-  * [Mix] Support `-q` when running tests to compile only changed files
-  * [String] Support `String.downcase` and `String.upcase` according to Unicode 6.2.0
-  * [String] Add support for graphemes in `String.length`, `String.at` and others
-  * [Typespec] Support `@opaque` as attribute
-  * [Typespec] Define a default type `t` for protocols and records
-  * [Typespec] Add support for the access protocol in typespecs
-
-* Bug fixes
-  * [Kernel] Fix an issue where variables inside clauses remained unassigned
-  * [Kernel] Ensure `defoverridable` functions can be referred in many clauses
-  * [Kernel] Allow keywords as function names when following a dot (useful when integrating with erlang libraries)
-  * [File] File is opened by default on binary mode instead of utf-8
-
-* Deprecations
-  * [Behaviour] `defcallback/1` is deprecated in favor of `defcallback/2` which matches erlang `@callbacks`
-  * [Enum] `Enum.times` is deprecated in favor of using ranges
-  * [System] `halt` moved to `System` module
-
-## v0.7.0 (2012-10-20)
-
-* Enhancements
-  * [Behaviour] Add Behaviour with a simple callback DSL to define callbacks
-  * [Binary] Add a Dict binary that converts its keys to binaries on insertion
-  * [Binary] Optimize `Binary.Inspect` and improve inspect for floats
-  * [CLI] Support `--detached` option
-  * [Code] `Code.string_to_ast` supports `:existing_atoms_only` as an option in order to guarantee no new atoms is generated when parsing the code
-  * [EEx] Support `<%%` and `<%#` tags
-  * [ExUnit] Support `after_spawn` callbacks which are invoked after each process is spawned
-  * [ExUnit] Support context data in `setup_all`, `setup`, `teardown` and `teardown_all` callbacks
-  * [IEx] Support `after_spawn` callbacks which are invoked after each process is spawned
-  * [Kernel] Better error messages when invalid options are given to `import`, `alias` or `require`
-  * [Kernel] Allow partial application on literals, for example: `{&1, &2}` to build tuples or `[&1|&2]` to build cons cells
-  * [Kernel] Added `integer_to_binary` and `binary_to_integer`
-  * [Kernel] Added `float_to_binary` and `binary_to_float`
-  * [Kernel] Many improvements to `unquote` and `unquote_splicing`. For example, `unquote(foo).unquote(bar)(args)` is supported and no longer need to be written via `apply`
-  * [Keyword] Keyword list is no longer ordered according to Erlang terms but the order in which they are specified
-  * [List] Add `List.keyreplace` and `List.keystore`
-  * [Macro]  Support `Macro.safe_term` which returns `:ok` if an expression does not execute code and is made only of raw data types
-  * [Mix] Add support for environments - the current environment can be set via `MIX_ENV`
-  * [Mix] Add support for handling and fetching dependencies' dependencies
-  * [Module] Support module creation via `Module.create`
-  * [Range] Support decreasing ranges
-  * [Record] Improvements to the Record API, added `Record.defmacros`
-  * [Regex] Add `:return` option to `Regex.run` and `Regex.scan`
-  * [String] Add a String module responsible for handling UTf-8 binaries
-
-* Bug fixes
-  * [File] `File.cp` and `File.cp_r` now preserves the file's mode
-  * [IEx] Fix a bug where printing to `:stdio` on `IEx` was causing it to hang
-  * [Macro] Fix a bug where quoted expressions were not behaving the same as their non-quoted counterparts
-  * [Mix] `mix deps.get [DEPS]` now only gets the specified dependencies
-  * [Mix] Mix now exits with status 1 in case of failures
-  * [Protocol] Avoid false positives on protocol dispatch (a bug caused the dispatch to be triggered to an invalid protocol)
-
-* Backwards incompatible changes
-  * [ExUnit] `setup` and `teardown` callbacks now receives the test name as second argument
-  * [Kernel] Raw function definition with `def/4`, `defp/4`, `defmacro/4`, `defmacrop/4` now evaluates all arguments. The previous behaviour was accidental and did not properly evaluate all arguments
-  * [Kernel] Change tuple-related (`elem` and `setelem`), Enum functions (`find_index`, `nth!` and `times`) and List functions (List.key*) to zero-index
-
-* Deprecations
-  * [Code] `Code.require_file` and `Code.load_file` now expect the full name as argument
-  * [Enum] `List.reverse/1` and `List.zip/2` were moved to `Enum`
-  * [GenServer] Rename `GenServer.Behavior` to `GenServer.Behaviour`
-  * [Kernel] Bitstring syntax now uses `::` instead of `|`
-  * [Kernel] `Erlang.` syntax is deprecated in favor of simply using atoms
-  * [Module] `Module.read_attribute` and `Module.add_attribute` deprecated in favor of `Module.get_attribute` and `Module.put_attribute` which mimics Dict API
-
-## v0.6.0 (2012-08-01)
-
-* Backwards incompatible changes
-  * [Kernel] Compile files now follow `Elixir-ModuleName` convention to solve issues with Erlang embedded mode. This removes the `__MAIN__` pseudo-variable as modules are now located inside `Elixir` namespace
-  * [Kernel] `__using__` callback triggered by `use` now receives just one argument. Caller information can be accessed via macros using `__CALLER__`
-  * [Kernel] Comprehensions syntax changed to be more compatible with Erlang behaviour
-  * [Kernel] loop and recur are removed in favor of recursion with named functions
-  * [Module] Removed data functions in favor of unifying the attributes API
-
-* Deprecations
-  * [Access] The semantics of the access protocol were reduced from a broad query API to simple data structure key-based access
-  * [ExUnit] Some assertions are deprecated in favor of simply using `assert()`
-  * [File] `File.read_info` is deprecated in favor of `File.stat`
-  * [IO] `IO.print` is deprecated in favor of `IO.write`
-  * [Kernel] Deprecate `__LINE__` and `__FUNCTION__` in favor of `__ENV__.line` and `__ENV__.function`
-  * [Kernel] Deprecate `in_guard` in favor of `__CALLER__.in_guard?`
-  * [Kernel] `refer` is deprecated in favor of `alias`
-  * [Module] `Module.add_compile_callback(module, target, callback)` is deprecated in favor of `Module.put_attribute(module, :before_compile, {target, callback})`
-  * [Module] `Module.function_defined?` is deprecated in favor of `Module.defines?`
-  * [Module] `Module.defined_functions` is deprecated in favor of `Module.definitions_in`
-
-* Enhancements
-  * [Enum] Enhance Enum protocol to support `Enum.count`
-  * [Enum] Optimize functions when a list is given as collection
-  * [Enum] Add `find_index`, `nth!` and others
-  * [ExUnit] Support setup and teardown callbacks
-  * [IEx] IEx now provides autocomplete if the OS supports tty
-  * [IEx] IEx now supports remsh
-  * [IEx] Elixir now defaults to compile with documentation and `d` can be used in IEx to print modules and functions documentation
-  * [IEx] Functions `c` and `m` are available in IEx to compile and print available module information. Functions `h` and `v` are available to show history and print previous commands values
-  * [IO/File] Many improvements to `File` and `IO` modules
-  * [Kernel] Operator `!` is now allowed in guard clauses
-  * [Kernel] Introduce operator `=~` for regular expression matches
-  * [Kernel] Compiled docs now include the function signature
-  * [Kernel] `defmodule` do not start a new variable scope, this improves meta-programming capabilities
-  * [Kernel] quote special form now supports line and unquote as options
-  * [Kernel] Document the macro `@` and allow attributes to be read inside functions
-  * [Kernel] Add support to the `%R` sigil. The same as `%r`, but without interpolation or escaping. Both implementations were also optimized to generate the regex at compilation time
-  * [Kernel] Add `__ENV__` which returns a `Macro.Env` record with information about the compilation environment
-  * [Kernel] Add `__CALLER__` inside macros which returns a `Macro.Env` record with information about the calling site
-  * [Macro] Add `Macro.expand`, useful for debugging what a macro expands to
-  * [Mix] First Mix public release
-  * [Module] Add support to `@before_compile` and `@after_compile` callbacks. The first receives the module name while the latter receives the module name and its object code
-  * [OptionParser] Make OptionParser public, add support to flags and improved switch parsing
-  * [Range] Add a Range module with support to `in` operator (`x in 1..3`) and iterators
-  * [Record] Allow `Record[_: value]` to set a default value to all records fields, as in Erlang
-  * [Record] Records now provide a `to_keywords` function
-  * [Regex] Back references are now properly supported
-  * [System] Add `System.find_executable`
-
-## v0.5.0 (2012-05-24)
-
-* First official release
+The CHANGELOG for v1.19 releases can be found [in the v1.19 branch](https://github.com/elixir-lang/elixir/blob/v1.19/CHANGELOG.md).
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 00000000000..e1505186946
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,72 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
+# Code of Conduct
+
+Contact: <elixir-lang-conduct@googlegroups.com>
+
+## Why have a Code of Conduct?
+
+As contributors and maintainers of this project, we are committed to providing a friendly, safe and welcoming environment for all, regardless of age, disability, gender, nationality, race, religion, sexuality, or similar personal characteristic.
+
+The goal of the Code of Conduct is to specify a baseline standard of behavior so that people with different social values and communication styles can talk about Elixir effectively, productively, and respectfully, even in face of disagreements. The Code of Conduct also provides a mechanism for resolving conflicts in the community when they arise.
+
+## Our Values
+
+These are the values Elixir developers should aspire to:
+
+  * Be friendly and welcoming
+  * Be kind
+    * Remember that people have varying communication styles and that not everyone is using their native language. (Meaning and tone can be lost in translation.)
+    * Interpret the arguments of others in good faith, do not seek to disagree.
+    * When we do disagree, try to understand why.
+  * Be thoughtful
+    * Productive communication requires effort. Think about how your words will be interpreted.
+    * Remember that sometimes it is best to refrain entirely from commenting.
+  * Be respectful
+    * In particular, respect differences of opinion. It is important that we resolve disagreements and differing views constructively.
+  * Be constructive
+    * Avoid derailing: stay on topic; if you want to talk about something else, start a new conversation.
+    * Avoid unconstructive criticism: don't merely decry the current state of affairs; offer — or at least solicit — suggestions as to how things may be improved.
+    * Avoid harsh words and stern tone: we are all aligned towards the well-being of the community and the progress of the ecosystem. Harsh words exclude, demotivate, and lead to unnecessary conflict.
+    * Avoid snarking (pithy, unproductive, sniping comments).
+    * Avoid microaggressions (brief and commonplace verbal, behavioral and environmental indignities that communicate hostile, derogatory or negative slights and insults towards a project, person or group).
+  * Be responsible
+    * What you say and do matters. Take responsibility for your words and actions, including their consequences, whether intended or otherwise.
+
+The following actions are explicitly forbidden:
+
+  * Insulting, demeaning, hateful, or threatening remarks.
+  * Discrimination based on age, disability, gender, nationality, race, religion, sexuality, or similar personal characteristic.
+  * Bullying or systematic harassment.
+  * Unwelcome sexual advances.
+  * Incitement to any of these.
+
+## Where does the Code of Conduct apply?
+
+If you participate in or contribute to the Elixir ecosystem in any way, you are encouraged to follow the Code of Conduct while doing so.
+
+Explicit enforcement of the Code of Conduct applies to the official mediums operated by the Elixir project:
+
+  * The [official GitHub projects][1] and code reviews.
+  * The official elixir-lang mailing lists.
+  * The **[#elixir][2]** IRC channel on [Libera.Chat][3].
+
+Other Elixir activities (such as conferences, meetups, and unofficial forums) are encouraged to adopt this Code of Conduct. Such groups must provide their own contact information.
+
+Project maintainers may block, remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by emailing: <elixir-lang-conduct@googlegroups.com>. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. **All reports will be kept confidential**.
+
+**The goal of the Code of Conduct is to resolve conflicts in the most harmonious way possible**. We hope that in most cases issues may be resolved through polite discussion and mutual agreement. Bannings and other forceful measures are to be employed only as a last resort. **Do not** post about the issue publicly or try to rally sentiment against a particular individual or group.
+
+## Acknowledgements
+
+This document was based on the Code of Conduct from the Go project (dated Sep/2021) and the Contributor Covenant (v1.4).
+
+[1]: https://github.com/elixir-lang/
+[2]: https://web.libera.chat/#elixir
+[3]: https://libera.chat/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7497c70c66a..c76fdfd97f7 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,286 +1,205 @@
-# Contributing to Elixir
-
-Please take a moment to review this document in order to make the contribution
-process easy and effective for everyone involved!
-
-## Using the issue tracker
-
-Use the issues tracker for:
-
-* [bug reports](#bugs-reports)
-* [submitting pull requests](#pull-requests)
-
-Please **do not** use the issues tracker for personal support requests nor feature requests. Support requests should be send to:
-
-* [the elixir-talk mailing list](http://groups.google.com/group/elixir-lang-talk)
-* [Stack Overflow](http://stackoverflow.com/questions/ask?tags=elixir)
-* [#elixir-lang](irc://chat.freenode.net/elixir-lang)
-
-Feature requests can be discussed on [the elixir-core mailing list](http://groups.google.com/group/elixir-lang-core).
-
-We do our best to keep the issues tracker tidy and organized, making it useful
-for everyone. For example, we classify open issues per application and perceived
-difficulty of the issue, making it easier for developers to
-[contribute to Elixir](#contributing).
-
-## Bug reports
-
-A bug is a _demonstrable problem_ that is caused by the code in the repository.
-Good bug reports are extremely helpful - thank you!
-
-Guidelines for bug reports:
-
-1. **Use the GitHub issue search** &mdash; check if the issue has already been
-   reported.
-
-2. **Check if the issue has been fixed** &mdash; try to reproduce it using the
-   `master` branch in the repository.
-
-3. **Isolate and report the problem** &mdash; ideally create a reduced test
-   case.
-
-Please try to be as detailed as possible in your report. Include information about
-your Operating System, your Erlang and Elixir versions. Please provide steps to
-reproduce the issue as well as the outcome you were expecting! All these details
-will help developers to fix any potential bugs.
-
-Example:
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
 
-> Short and descriptive example bug report title
->
-> A summary of the issue and the environment in which it occurs. If suitable,
-> include the steps required to reproduce the bug.
->
-> 1. This is the first step
-> 2. This is the second step
-> 3. Further steps, etc.
->
-> `<url>` - a link to the reduced test case (e.g. a GitHub Gist)
->
-> Any other information you want to share that is relevant to the issue being
-> reported. This might include the lines of code that you have identified as
-> causing the bug, and potential solutions (and your opinions on their
-> merits).
-
-## Feature requests
-
-Feature requests are welcome and should be discussed on [the elixir-core mailing list](http://groups.google.com/group/elixir-lang-core). But take a moment to find
-out whether your idea fits with the scope and aims of the project. It's up to *you*
-to make a strong case to convince the community of the merits of this feature.
-Please provide as much detail and context as possible.
+# Contributing to Elixir
 
-## Contributing
+We invite contributions to Elixir. To contribute, there are a few
+things you need to know about the code. First, Elixir code is divided
+by each application inside the `lib` folder:
 
-We incentivize everyone to contribute to Elixir and help us tackle
-existing issues! To do so, there are a few things you need to know
-about the code. First, Elixir code is divided in applications inside
-the `lib` folder:
+  * `elixir` - Elixir's kernel and standard library
 
-* `elixir` - Contains Elixir's kernel and stdlib
+  * `eex` - EEx is the template engine that allows you to embed Elixir
 
-* `eex` - Template engine that allows you to embed Elixir
+  * `ex_unit` - ExUnit is a simple test framework that ships with Elixir
 
-* `ex_unit` - Simple test framework that ships with Elixir
+  * `iex` - IEx stands for Interactive Elixir: Elixir's interactive shell
 
-* `iex` — IEx, Elixir's interactive shell
+  * `logger` - Logger is the built-in logger
 
-* `mix` — Elixir's build tool
+  * `mix` - Mix is Elixir's build tool
 
-You can run all tests in the root directory with `make test` and you can
-also run tests for a specific framework `make test_#{NAME}`, for example,
-`make test_ex_unit`.
+You can run all tests in the root directory with `make test`. You can
+also run tests for a specific framework with `make test_#{APPLICATION}`, for example,
+`make test_ex_unit`. If you just changed something in Elixir's standard
+library, you can run only that portion through `make test_stdlib`.
 
-In case you are changing a single file, you can compile and run tests only
-for that particular file for fast development cycles. For example, if you
+If you are only changing one file, you can choose to compile and run tests
+for that specific file for faster development cycles. For example, if you
 are changing the String module, you can compile it and run its tests as:
 
-    $ bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
-    $ bin/elixir lib/elixir/test/elixir/string_test.exs
-
-After your changes are done, please remember to run the full suite with
-`make test`.
-
-From time to time, your tests may fail in an existing Elixir checkout and
-may require a clean start by running `make clean compile`. You can always
-check [the official build status on Travis-CI](https://travis-ci.org/elixir-lang/elixir).
-
-With tests running and passing, you are ready to contribute to Elixir and
-send your pull requests.
+```sh
+bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
+bin/elixir lib/elixir/test/elixir/string_test.exs
+```
 
-### Building on Windows
+Some test files need their `test_helper.exs` to be explicitly required
+before, such as:
 
-There are a few extra steps you'll need to take for contributing from Windows.
-Basically, once you have Erlang 17, Git, and MSYS from MinGW on your system,
-you're all set.  Specifically, here's what you need to do to get up and running:
+```sh
+bin/elixir -r lib/logger/test/test_helper.exs lib/logger/test/logger_test.exs
+```
 
-1. Install [Git](http://www.git-scm.com/download/win), 
-[Erlang](http://www.erlang.org/download.html), and the
-[MinGW Installation Manager](http://sourceforge.net/projects/mingw/files/latest/download?source=files).
-2. Use the MinGW Installation Manager to install the msys-bash, msys-make, and
-msys-grep packages.
-3. Add `;C:\Program Files (x86)\Git\bin;C:\Program Files\erl6.0\bin;C:\Program Files\erl6.0\erts-6.0\bin;C:\MinGW\msys\1.0\bin`
-to your "Path" environment variable .  (This is under Control Panel > System 
-and Security > System > Advanced system settings > Environment Variables > 
-System variables)
+You can also use the `LINE` env var to run a single test:
 
-You can now work in the Command Prompt similar to how you would on other OS'es,
-except for some things (like creating symlinks) you'll need to run the Command
-Prompt as an Administrator.
+```sh
+LINE=123 bin/elixir lib/elixir/test/elixir/string_test.exs
+````
 
-## Contributing Documentation
+To recompile all (including Erlang modules):
 
-Code documentation (`@doc`, `@moduledoc`, `@typedoc`) has a special convention:
-the first paragraph is considered to be a short summary.
+```sh
+make compile
+```
 
-For functions, macros and callbacks say what it will do. For example write
-something like:
+After your changes are done, please remember to run `make format` to guarantee
+all files are properly formatted, then run the full suite with
+`make test`.
 
-```elixir
-@doc """
-Returns only those elements for which `fun` is true.
+If your contribution fails during the bootstrapping of the language,
+you can rebuild the language from scratch with:
 
-...
-"""
-def filter(collection, fun) ...
+```sh
+make clean_elixir compile
 ```
 
-For modules, protocols and types say what it is. For example write
-something like:
-
-```elixir
-defmodule File.Stat do
-  @moduledoc """
-  Information about a file.
+Similarly, if you can not get Elixir to compile or the tests to pass after
+updating an existing checkout, run `make clean compile`. You can check
+[the official build status](https://github.com/elixir-lang/elixir/actions/workflows/ci.yml).
+More tasks can be found by reading the [Makefile](Makefile).
 
-  ...
-  """
+We encourage contributors to write tests that capture both existing and newly
+introduced behavior, especially for bug fixes and major changes:
 
-  defstruct [...]
-end
-```
+  * **Bug Fixes:** If you are fixing a bug, please try to include a test that
+    *fails* before your change and *passes* afterward. This makes it easier to
+    confirm that the fix addresses the underlying issue and helps prevent
+    regressions in the future.
 
-Keep in mind that the first paragraph might show up in a summary somewhere, long
-texts in the first paragraph create very ugly summaries. As a rule of thumb
-anything longer than 80 characters is too long.
+  * **New Features or Major Changes:** If you are adding a new feature or making
+    major changes to existing functionality, please add tests that cover the
+    major parts of that functionality. Aim to have the best code coverage possible.
 
-Try to keep unneccesary details out of the first paragraph, it's only there to
-give a user a quick idea of what the documented "thing" does/is. The rest of the
-documentation string can contain the details, for example when a value and when
-`nil` is returned.
+With tests running and passing, you are ready to contribute to Elixir and
+[send a pull request](https://help.github.com/articles/using-pull-requests/).
+We have saved some excellent pull requests we have received in the past in
+case you are looking for some examples:
 
-If possible include examples, preferably in a form that works with doctests. For
-example:
+  * [Implement Enum.member? - Pull request](https://github.com/elixir-lang/elixir/pull/992)
 
-```elixir
-@doc """
-Return only those elements for which `fun` is true.
+  * [Add String.valid? - Pull request](https://github.com/elixir-lang/elixir/pull/1058)
 
-## Examples
+  * [Implement capture_io for ExUnit - Pull request](https://github.com/elixir-lang/elixir/pull/1059)
 
-    iex> Enum.filter([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
-    [2]
+## Reviewing changes
 
-"""
-def filter(collection, fun) ...
-```
+Once a pull request is sent, the Elixir team will review your changes.
+We outline our process below to clarify the roles of everyone involved.
 
-This makes it easy to test the examples so that they don't go stale and examples
-are often a great help in explaining what a function does.
+All pull requests must be approved by two committers before being merged into
+the repository. If changes are necessary, the team will leave appropriate
+comments requesting changes to the code. Unfortunately, we cannot guarantee a
+pull request will be merged, even when modifications are requested, as the Elixir
+team will re-evaluate the contribution as it changes.
 
-## Pull requests
+Committers may also push style changes directly to your branch. If you would
+rather manage all changes yourself, you can disable the "Allow edits from maintainers"
+feature when submitting your pull request.
 
-Good pull requests - patches, improvements, new features - are a fantastic
-help. They should remain focused in scope and avoid containing unrelated
-commits.
+The Elixir team may optionally assign someone to review a pull request.
+If someone is assigned, they must explicitly approve the code before
+another team member can merge it.
 
-**IMPORTANT**: By submitting a patch, you agree that your work will be
-licensed under the license used by the project.
+When the review finishes, your pull request will be squashed and merged
+into the repository. If you have carefully organized your commits and
+believe they should be merged without squashing, please mention it in
+a comment.
 
-If you have any large pull request in mind (e.g. implementing features,
-refactoring code, etc), **please ask first** otherwise you risk spending
-a lot of time working on something that the project's developers might
-not want to merge into the project.
+## Licensing and Compliance Requirements
 
-Please adhere to the coding conventions in the project (indentation,
-accurate comments, etc.) and don't forget to add your own tests and
-documentation. When working with git, we recommend the following process
-in order to craft an excellent pull request:
+Please review our [Open Source Policy](OPEN_SOURCE_POLICY.md) for complete
+guidelines on licensing and compliance. Below is a summary of the key points
+affecting **all external contributors**:
 
-1. [Fork](http://help.github.com/fork-a-repo/) the project, clone your fork,
-   and configure the remotes:
+  * Accepted Licenses: Any code contributed must be licensed under the
+    `Apache-2.0` license.
 
-   ```bash
-   # Clone your fork of the repo into the current directory
-   git clone https://github.com/<your-username>/elixir
-   # Navigate to the newly cloned directory
-   cd elixir
-   # Assign the original repo to a remote called "upstream"
-   git remote add upstream https://github.com/elixir-lang/elixir
-   ```
+  * SPDX License Headers: With the exception of approved test fixture files,
+    all new or modified files in a pull request must include correct SPDX
+    headers. If you are creating a new file under the `Apache-2.0` license, for
+    instance, please use:
 
-2. If you cloned a while ago, get the latest changes from upstream:
+    ```elixir
+    # SPDX-License-Identifier: Apache-2.0
+    # SPDX-FileCopyrightText: 2021 The Elixir Team
+    ```
 
-   ```bash
-   git checkout master
-   git pull upstream master
-   ```
+  * No Executable Binaries: Contributions must **not** include any executable
+    binary files. If you require an exception (for example, certain test artifacts),
+    please see the policy on how to request approval and document exceptions.
 
-3. Create a new topic branch (off of `master`) to contain your feature, change,
-   or fix.
+  * Preserving Copyright and License Info: If you copy code from elsewhere,
+    ensure that **all original copyright and license notices remain intact**. If
+    they are missing or incomplete, you must add them.
 
-   **IMPORTANT**: Making changes in `master` is discouraged. You should always
-   keep your local `master` in sync with upstream `master` and make your
-   changes in topic branches.
+  * Failure to Comply: Pull requests that do not meet these licensing and
+    compliance standards will be rejected or require modifications before merging.
 
-   ```bash
-   git checkout -b <topic-branch-name>
-   ```
+  * Developer Certificate of Origin: All contributions are subject to the
+    Developer Certificate of Origin.
 
-4. Commit your changes in logical chunks. Keep your commit messages organized,
-   with a short description in the first line and more detailed information on
-   the following lines. Feel free to use Git's
-   [interactive rebase](https://help.github.com/articles/interactive-rebase)
-   feature to tidy up your commits before making them public.
+    ```text
+    By making a contribution to this project, I certify that:
 
-5. Make sure all the tests are still passing.
+    (a) The contribution was created in whole or in part by me and I
+        have the right to submit it under the open source license
+        indicated in the file; or
 
-   ```bash
-   make test
-   ```
+    (b) The contribution is based upon previous work that, to the 
+        best of my knowledge, is covered under an appropriate open 
+        source license and I have the right under that license to   
+        submit that work with modifications, whether created in whole
+        or in part by me, under the same open source license (unless
+        I am permitted to submit under a different license), as 
+        Indicated in the file; or
 
-   This command will compile the code in your branch and use that
-   version of Elixir to run the tests. This is needed to ensure your changes can
-   pass all the tests.
+    (c) The contribution was provided directly to me by some other
+        person who certified (a), (b) or (c) and I have not modified
+        it.
 
-6. Push your topic branch up to your fork:
+    (d) I understand and agree that this project and the contribution
+        are public and that a record of the contribution (including 
+        all personal information I submit with it, including my
+        sign-off) is maintained indefinitely and may be redistributed
+        consistent with this project or the open source license(s)
+        involved.
+    ```
 
-   ```bash
-   git push origin <topic-branch-name>
-   ```
+    See <http://developercertificate.org/> for a copy of the Developer Certificate
+    of Origin license.
 
-7. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/)
-    with a clear title and description.
+## Building documentation
 
-8. If you haven't updated your pull request for a while, you should consider
-   rebasing on master and resolving any conflicts.
+Building the documentation requires that [ExDoc](https://github.com/elixir-lang/ex_doc)
+is installed and built alongside Elixir.
 
-   **IMPORTANT**: _Never ever_ merge upstream `master` into your branches. You
-   should always `git rebase` on `master` to bring your changes up to date when
-   necessary.
+After cloning and compiling Elixir, run:
 
-   ```bash
-   git checkout master
-   git pull upstream master
-   git checkout <your-topic-branch>
-   git rebase master
-   ```
+```sh
+elixir_dir=$(pwd)
+cd .. && git clone https://github.com/elixir-lang/ex_doc.git
+cd ex_doc && "${elixir_dir}/bin/elixir" "${elixir_dir}/bin/mix" do deps.get + compile
 
-We have saved some excellent pull requests we have received in the past in case
-you are looking for some examples:
+# Now we will go back to Elixir's root directory,
+cd "${elixir_dir}"
 
-* https://github.com/elixir-lang/elixir/pull/992
-* https://github.com/elixir-lang/elixir/pull/1041
-* https://github.com/elixir-lang/elixir/pull/1058
-* https://github.com/elixir-lang/elixir/pull/1059
+# and generate HTML and EPUB documents:
+make docs
+```
 
-Thank you for your contributions!
+This will produce documentation sets for `elixir`, `eex`, `ex_unit`, `iex`, `logger`,
+and `mix` under the `doc` directory. If you are planning to contribute documentation,
+[please check our best practices for writing documentation](https://hexdocs.pm/elixir/writing-documentation.html).
diff --git a/LEGAL b/LEGAL
deleted file mode 100644
index 8948b8ad2f0..00000000000
--- a/LEGAL
+++ /dev/null
@@ -1,8 +0,0 @@
-LEGAL NOTICE INFORMATION
-------------------------
-
-All the files in this distribution are covered under either Elixir's
-license (see the file LICENSE) except the files mentioned below that
-contains sections that are under Erlang's License (EPL):
-
-lib/elixir/src/elixir_parser.erl (generated by build scripts)
diff --git a/LICENSE b/LICENSE
index d3a92d217c9..d9a10c0d8e8 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,13 +1,176 @@
-Copyright 2012-2013 Plataformatec.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
 
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
-      http://www.apache.org/licenses/LICENSE-2.0
+   1. Definitions.
 
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
\ No newline at end of file
+      "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
diff --git a/LICENSES/Apache-2.0.txt b/LICENSES/Apache-2.0.txt
new file mode 100644
index 00000000000..137069b8238
--- /dev/null
+++ b/LICENSES/Apache-2.0.txt
@@ -0,0 +1,73 @@
+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.
diff --git a/LICENSES/LicenseRef-elixir-trademark-policy.txt b/LICENSES/LicenseRef-elixir-trademark-policy.txt
new file mode 100644
index 00000000000..b94911196dc
--- /dev/null
+++ b/LICENSES/LicenseRef-elixir-trademark-policy.txt
@@ -0,0 +1,98 @@
+ELIXIR TEAM TRADEMARKS POLICY
+
+This document outlines the policy for allowed usage of the “Elixir” word and the
+Elixir logo by other parties.
+
+“Elixir” and the Elixir logo are registered trademarks of the Elixir Team. The
+Elixir Team believes in a decentralized approach to growing the community and
+the ecosystem, independent of the Elixir project and the Elixir Team.
+
+Anyone can use the Elixir trademarks if that use of the trademark is nominative.
+The trademarks must not be used to disparage the project and its community, nor
+be used in any way to imply ownership, endorsement, or association with the
+Elixir project and the Elixir Team.
+
+You must not visually combine the Elixir logo with any other images, or change
+the logo in any way other than ways required by printing restrictions. If you
+want to create your own visual identity in relation to Elixir, you might use the
+shape of an unrelated “water drop” as part of your design, as seen in many
+community projects and initiatives. You must not combine or modify the Elixir
+logo.
+
+The Elixir logo is available in our repository in both vertical and horizontal
+versions.
+
+Nominative use
+The “nominative use” (or “nominative fair use”) is a legal doctrine that
+authorizes everyone (even commercial companies) to use or refer to the trademark
+of another if:
+
+The product or service in question must be one not readily identifiable without
+use of the trademark.
+
+Only so much of the mark or marks may be used as is reasonably necessary to
+identify the product or service.
+
+The organization using the mark must do nothing that would, in conjunction with
+the mark, suggest sponsorship or endorsement by the trademark holder.
+
+Our trademarks must be used to refer to the Elixir programming language.
+
+Examples of permitted use
+All examples listed next must strictly adhere to the terms outlined in the
+previous sections:
+
+Usage of the Elixir logo to say a technology is “powered by Elixir” under
+nominative use. Linking back to the Elixir website, if possible, is appreciated.
+
+Usage of the Elixir logo to display it as a supported technology in a service or
+platform. For instance, you may say “we support Elixir” and use the Elixir logo,
+but you may not refer to yourself as “the Elixir platform” nor imply any form of
+endorsement or association with Elixir.
+
+Usage of the Elixir logo in non-commercial community meetups, in presentations,
+and in courses when referring to the language and its ecosystem under nominative
+use.
+
+Usage of the Elixir logo in non-commercial swag (stickers, t-shirts, mugs, etc)
+to promote the Elixir programming language. The Elixir marks must be the only
+marks featured in the product. You need permission to make swag that include
+Elixir and other third party marks in them.
+
+Inclusion of the Elixir logo in non-commercial icon sets. Use of the Elixir
+icons must still adhere to Elixir’s trademark policies.
+
+Usage of the “Elixir” word in book titles, meetups, conferences, and podcasts.
+You must not use the word to imply uniqueness or endorsement from the Elixir
+team. “The Elixir book” and “The Elixir podcast” are not permitted.
+“Elixir in Action”, “Thinking Elixir”, and “Kraków Elixir User Group” are valid
+examples already in use today.
+
+Usage of the “Elixir” word in the names of freely distributed software and
+hardware products is allowed when referring to use with or suitability for the
+Elixir programming language, such as wxElixir, Elixirsense, etc. If the product
+includes the Elixir programming language itself, then you must also respect its
+license.
+
+Examples of not permitted use
+Here is a non-exhaustive list of non permitted uses of the marks:
+
+Usage of the Elixir logo in book covers, conferences, and podcasts.
+
+Usage of the Elixir logo as the mark of third party projects, even in combination
+with other marks.
+
+Naming any company or product after Elixir, such as “The Elixir Hosting”,
+“The Elixir Consultants”, etc.
+
+Examples that require permission
+Here are some examples that may be granted permission upon request:
+
+Selling merchandise (stickers, t-shirts, mugs, etc).
+You can request permission by emailing trademarks@elixir-lang.org.
+
+Important note
+Nothing in this page shall be interpreted to allow any third party to claim any
+association with the Elixir project and the Elixir Team, or to imply any
+approval or support by the Elixir project and the Elixir Team for any third
+party products, services, or events.
diff --git a/LICENSES/LicenseRef-scancode-unicode.txt b/LICENSES/LicenseRef-scancode-unicode.txt
new file mode 100644
index 00000000000..24438a47d73
--- /dev/null
+++ b/LICENSES/LicenseRef-scancode-unicode.txt
@@ -0,0 +1,58 @@
+UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
+
+Unicode Data Files include all data files under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/, and
+http://www.unicode.org/cldr/data/ . Unicode Software includes any source
+code published in the Unicode Standard or under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/, and
+http://www.unicode.org/cldr/data/.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S DATA
+FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"), YOU UNEQUIVOCALLY
+ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS OF THIS
+AGREEMENT. IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE
+OR USE THE DATA FILES OR SOFTWARE.
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright ©  Unicode, Inc. All rights reserved. Distributed under
+the Terms of Use in http://www.unicode.org/copyright.html.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of the Unicode data files and any associated documentation (the
+"Data Files") or Unicode software and any associated documentation (the
+"Software") to deal in the Data Files or Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, and/or sell copies of the Data Files or Software,
+and to permit persons to whom the Data Files or Software are furnished
+to do so, provided that
+
+(a) the above copyright notice(s) and this permission notice appear with
+all copies of the Data Files or Software,
+
+(b) both the above copyright notice(s) and this permission notice appear
+in associated documentation, and
+
+(c) there is clear notice in each modified Data File or in the Software
+as well as in the documentation associated with the Data File(s) or
+Software that the data or software has been modified.
+
+THE DATA FILES AND SOFTWARE ARE 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 OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR
+ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER
+RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
+
+Unicode and the Unicode logo are trademarks of Unicode, Inc., and may be
+registered in some jurisdictions. All other trademarks and registered
+trademarks mentioned herein are the property of their respective owners.
diff --git a/Makefile b/Makefile
index b660c202c21..24d02701acc 100644
--- a/Makefile
+++ b/Makefile
@@ -1,95 +1,125 @@
-REBAR := rebar
-ELIXIRC := bin/elixirc --verbose --ignore-module-conflict
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+PREFIX ?= /usr/local
+TEST_FILES ?= "*_test.exs"
+SHARE_PREFIX ?= $(PREFIX)/share
+MAN_PREFIX ?= $(SHARE_PREFIX)/man
+CANONICAL := main/
+ELIXIRC := bin/elixirc --ignore-module-conflict $(ELIXIRC_OPTS)
+ELIXIRC_MIN_SIG := $(ELIXIRC) -e 'Code.put_compiler_option :infer_signatures, []'
 ERLC := erlc -I lib/elixir/include
+ERL_MAKE := erl -make
 ERL := erl -I lib/elixir/include -noshell -pa lib/elixir/ebin
+GENERATE_APP := $(CURDIR)/lib/elixir/scripts/generate_app.escript
 VERSION := $(strip $(shell cat VERSION))
 Q := @
-PREFIX := /usr/local
 LIBDIR := lib
+BINDIR := bin
 INSTALL = install
 INSTALL_DIR = $(INSTALL) -m755 -d
 INSTALL_DATA = $(INSTALL) -m644
 INSTALL_PROGRAM = $(INSTALL) -m755
+GIT_REVISION = $(strip $(shell git rev-parse HEAD 2> /dev/null ))
+GIT_TAG = $(strip $(shell head="$(call GIT_REVISION)"; git tag --points-at $$head 2> /dev/null | grep -v latest | tail -1))
+SOURCE_DATE_EPOCH_PATH = lib/elixir/tmp/ebin_reproducible
+SOURCE_DATE_EPOCH_FILE = $(SOURCE_DATE_EPOCH_PATH)/SOURCE_DATE_EPOCH
 
-.PHONY: install compile erlang elixir dialyze test clean docs release_docs release_zip check_erlang_release
-.NOTPARALLEL: compile
+.PHONY: cover install install_man build_plt clean_plt dialyze test check_reproducible clean clean_elixir clean_man format docs Docs.zip Precompiled.zip zips
+.NOTPARALLEL:
 
 #==> Functions
 
-# This check should work for older versions like R16B
-# as well as new verions like 17.1 and 18
 define CHECK_ERLANG_RELEASE
-	$(Q) erl -noshell -eval 'io:fwrite("~s", [erlang:system_info(otp_release)])' -s erlang halt | grep -q '^1[789]'; \
-		if [ $$? != 0 ]; then                                                                                        \
-		   echo "At least Erlang 17.0 is required to build Elixir";                                                  \
-		   exit 1;                                                                                                   \
-		fi;
+	erl -noshell -eval '{V,_} = string:to_integer(erlang:system_info(otp_release)), io:fwrite("~s", [is_integer(V) and (V >= 26)])' -s erlang halt | grep -q '^true'; \
+		if [ $$? != 0 ]; then \
+		  echo "At least Erlang/OTP 26.0 is required to build Elixir"; \
+		  exit 1; \
+		fi
 endef
 
 define APP_TEMPLATE
 $(1): lib/$(1)/ebin/Elixir.$(2).beam lib/$(1)/ebin/$(1).app
 
 lib/$(1)/ebin/$(1).app: lib/$(1)/mix.exs
-	$(Q) mkdir -p lib/$(1)/_build/shared/lib/$(1)
-	$(Q) cp -R lib/$(1)/ebin lib/$(1)/_build/shared/lib/$(1)/
-	$(Q) cd lib/$(1) && ../../bin/elixir -e "Mix.start(:permanent, [])" -r mix.exs -e "Mix.Task.run('compile.app')"
-	$(Q) cp lib/$(1)/_build/shared/lib/$(1)/ebin/$(1).app lib/$(1)/ebin/$(1).app
-	$(Q) rm -rf lib/$(1)/_build
+	$(Q) cd lib/$(1) && ../../bin/elixir -e 'Mix.start(:permanent, [])' -r mix.exs -e 'Mix.Task.run("compile.app", ~w[--compile-path ebin])'
 
 lib/$(1)/ebin/Elixir.$(2).beam: $(wildcard lib/$(1)/lib/*.ex) $(wildcard lib/$(1)/lib/*/*.ex) $(wildcard lib/$(1)/lib/*/*/*.ex)
 	@ echo "==> $(1) (compile)"
 	@ rm -rf lib/$(1)/ebin
 	$(Q) cd lib/$(1) && ../../$$(ELIXIRC) "lib/**/*.ex" -o ebin
 
-test_$(1): $(1)
-	@ echo "==> $(1) (exunit)"
-	$(Q) cd lib/$(1) && ../../bin/elixir -r "test/test_helper.exs" -pr "test/**/*_test.exs";
+test_$(1): test_formatted $(1)
+	@ echo "==> $(1) (ex_unit)"
+	$(Q) cd lib/$(1) && ../../bin/elixir -r "test/test_helper.exs" -pr "test/**/$(TEST_FILES)";
+
+cover/ex_unit_$(1).coverdata:
+	$(Q) COVER="1" $(MAKE) test_$(1)
+cover/combined.coverdata: cover/ex_unit_$(1).coverdata
+endef
+
+define WRITE_SOURCE_DATE_EPOCH
+$(shell mkdir -p $(SOURCE_DATE_EPOCH_PATH) && bin/elixir -e \
+  'IO.puts System.build_info()[:date] \
+   |> DateTime.from_iso8601() \
+   |> elem(1) \
+   |> DateTime.to_unix()' > $(SOURCE_DATE_EPOCH_FILE))
+endef
+
+define READ_SOURCE_DATE_EPOCH
+$(strip $(shell cat $(SOURCE_DATE_EPOCH_FILE)))
 endef
 
 #==> Compilation tasks
 
-KERNEL:=lib/elixir/ebin/Elixir.Kernel.beam
-UNICODE:=lib/elixir/ebin/Elixir.String.Unicode.beam
+APP := lib/elixir/ebin/elixir.app
+EEX := lib/eex/ebin/Elixir.EEx.beam
+ELIXIR := lib/elixir/ebin/elixir.beam
+PARSER := lib/elixir/src/elixir_parser.erl
+KERNEL := lib/elixir/ebin/Elixir.Kernel.beam
+UNICODE := lib/elixir/ebin/Elixir.String.Unicode.beam
 
 default: compile
 
-compile: lib/elixir/src/elixir.app.src erlang elixir
+compile: erlang elixir
 
-lib/elixir/src/elixir.app.src: src/elixir.app.src
-	$(Q) $(call CHECK_ERLANG_RELEASE)
-	$(Q) rm -rf lib/elixir/src/elixir.app.src
-	$(Q) echo "%% This file is automatically generated from <project_root>/src/elixir.app.src" \
-	                             >lib/elixir/src/elixir.app.src
-	$(Q) cat src/elixir.app.src >>lib/elixir/src/elixir.app.src
+erlang: $(ELIXIR)
+$(ELIXIR): $(PARSER) lib/elixir/src/*
+	$(Q) if [ ! -f $(APP) ]; then $(call CHECK_ERLANG_RELEASE); fi
+	$(Q) cd lib/elixir && mkdir -p ebin && $(ERL_MAKE)
+	$(Q) $(GENERATE_APP) $(VERSION)
 
-erlang:
-	$(Q) cd lib/elixir && ../../$(REBAR) compile
+$(PARSER): lib/elixir/src/elixir_parser.yrl
+	$(Q) erlc -o $@ +'{verbose,true}' +'{report,true}' $<
 
-# Since Mix depends on EEx and EEx depends on
-# Mix, we first compile EEx without the .app
-# file, then mix and then compile EEx fully
-elixir: stdlib lib/eex/ebin/Elixir.EEx.beam mix ex_unit eex iex
+# Since Mix depends on EEx and EEx depends on Mix,
+# we first compile EEx without the .app file,
+# then Mix, and then compile EEx fully
+elixir: stdlib $(EEX) mix ex_unit logger eex iex
+stdlib: $(KERNEL) $(UNICODE) $(APP)
 
-stdlib: $(KERNEL) VERSION
-$(KERNEL): lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex
-	$(Q) if [ ! -f $(KERNEL) ]; then                    \
-		echo "==> bootstrap (compile)";                 \
-		$(ERL) -s elixir_compiler core -s erlang halt;  \
+$(KERNEL): lib/elixir/src/* lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex VERSION
+	$(Q) if [ ! -f $(KERNEL) ]; then \
+		echo "==> bootstrap (compile)"; \
+		$(ERL) -s elixir_compiler bootstrap -s erlang halt; \
+		"$(MAKE)" unicode; \
 	fi
 	@ echo "==> elixir (compile)";
-	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/kernel.ex" -o ebin;
-	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/**/*.ex" -o ebin;
-	$(Q) $(MAKE) unicode
-	$(Q) rm -rf lib/elixir/ebin/elixir.app
-	$(Q) cd lib/elixir && ../../$(REBAR) compile
+	$(Q) cd lib/elixir && ../../$(ELIXIRC_MIN_SIG) "lib/**/*.ex" -o ebin;
+
+$(APP): lib/elixir/src/elixir.app.src lib/elixir/ebin VERSION $(GENERATE_APP)
+	$(Q) $(GENERATE_APP) $(VERSION)
 
 unicode: $(UNICODE)
 $(UNICODE): lib/elixir/unicode/*
 	@ echo "==> unicode (compile)";
-	@ echo "This step can take up to a minute to compile in order to embed the Unicode database"
-	$(Q) cd lib/elixir && ../../$(ELIXIRC) unicode/unicode.ex -o ebin;
+	$(Q) $(ELIXIRC_MIN_SIG) lib/elixir/unicode/unicode.ex -o lib/elixir/ebin;
+	$(Q) $(ELIXIRC_MIN_SIG) lib/elixir/unicode/tokenizer.ex -o lib/elixir/ebin;
+	$(Q) $(ELIXIRC_MIN_SIG) lib/elixir/unicode/security.ex -o lib/elixir/ebin;
 
 $(eval $(call APP_TEMPLATE,ex_unit,ExUnit))
+$(eval $(call APP_TEMPLATE,logger,Logger))
 $(eval $(call APP_TEMPLATE,eex,EEx))
 $(eval $(call APP_TEMPLATE,mix,Mix))
 $(eval $(call APP_TEMPLATE,iex,IEx))
@@ -97,64 +127,151 @@ $(eval $(call APP_TEMPLATE,iex,IEx))
 install: compile
 	@ echo "==> elixir (install)"
 	$(Q) for dir in lib/*; do \
+		rm -rf $(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin; \
 		$(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
 		$(INSTALL_DATA) $$dir/ebin/* "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
 	done
 	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin"
 	$(Q) $(INSTALL_PROGRAM) $(filter-out %.ps1, $(filter-out %.bat, $(wildcard bin/*))) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin"
-	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/bin"
-	$(Q) for file in "$(DESTDIR)$(PREFIX)"/$(LIBDIR)/elixir/bin/* ; do \
-		ln -sf "../$(LIBDIR)/elixir/bin/$${file##*/}" "$(DESTDIR)$(PREFIX)/bin/" ; \
+	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(BINDIR)"
+	$(Q) for file in "$(DESTDIR)$(PREFIX)"/$(LIBDIR)/elixir/bin/*; do \
+		ln -sf "../$(LIBDIR)/elixir/bin/$${file##*/}" "$(DESTDIR)$(PREFIX)/$(BINDIR)/"; \
 	done
-
-clean:
-	cd lib/elixir && ../../$(REBAR) clean
+	"$(MAKE)" install_man
+
+check_reproducible: compile
+	$(Q) echo "==> Checking for reproducible builds..."
+	$(Q) rm -rf lib/*/tmp/ebin_reproducible/
+	$(call WRITE_SOURCE_DATE_EPOCH)
+	$(Q) mkdir -p lib/elixir/tmp/ebin_reproducible/ \
+	              lib/eex/tmp/ebin_reproducible/ \
+	              lib/ex_unit/tmp/ebin_reproducible/ \
+	              lib/iex/tmp/ebin_reproducible/ \
+	              lib/logger/tmp/ebin_reproducible/ \
+	              lib/mix/tmp/ebin_reproducible/
+	$(Q) mv lib/elixir/ebin/* lib/elixir/tmp/ebin_reproducible/
+	$(Q) mv lib/eex/ebin/* lib/eex/tmp/ebin_reproducible/
+	$(Q) mv lib/ex_unit/ebin/* lib/ex_unit/tmp/ebin_reproducible/
+	$(Q) mv lib/iex/ebin/* lib/iex/tmp/ebin_reproducible/
+	$(Q) mv lib/logger/ebin/* lib/logger/tmp/ebin_reproducible/
+	$(Q) mv lib/mix/ebin/* lib/mix/tmp/ebin_reproducible/
+	$(Q) rm -rf lib/*/ebin
+	SOURCE_DATE_EPOCH=$(call READ_SOURCE_DATE_EPOCH) "$(MAKE)" compile
+	$(Q) echo "Diffing..."
+	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/elixir/ebin/ lib/elixir/tmp/ebin_reproducible/
+	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/eex/ebin/ lib/eex/tmp/ebin_reproducible/
+	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/ex_unit/ebin/ lib/ex_unit/tmp/ebin_reproducible/
+	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/iex/ebin/ lib/iex/tmp/ebin_reproducible/
+	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/logger/ebin/ lib/logger/tmp/ebin_reproducible/
+	$(Q) bin/elixir lib/elixir/scripts/diff.exs lib/mix/ebin/ lib/mix/tmp/ebin_reproducible/
+	$(Q) echo "Builds are reproducible"
+
+clean: clean_man
 	rm -rf ebin
 	rm -rf lib/*/ebin
-	rm -rf lib/elixir/test/ebin
-	rm -rf lib/*/tmp
-	rm -rf lib/mix/test/fixtures/git_repo
-	rm -rf lib/mix/test/fixtures/deps_on_git_repo
-	rm -rf lib/mix/test/fixtures/git_rebar
-	rm -rf lib/elixir/src/elixir.app.src
-
-clean_exbeam:
+	rm -rf $(PARSER)
+	rm -rf lib/*/_build/
+	rm -rf lib/*/tmp/
+	rm -rf lib/elixir/test/ebin/
+	rm -rf lib/mix/test/fixtures/deps_on_git_repo/
+	rm -rf lib/mix/test/fixtures/git_rebar/
+	rm -rf lib/mix/test/fixtures/git_repo/
+	rm -rf lib/mix/test/fixtures/git_sparse_repo/
+	rm -rf lib/mix/test/fixtures/archive/ebin/
+	rm -f erl_crash.dump
+	rm -rf cover
+
+clean_elixir:
 	$(Q) rm -f lib/*/ebin/Elixir.*.beam
 
-#==> Release tasks
-
-SOURCE_REF = $(shell head="$$(git rev-parse HEAD)" tag="$$(git tag --points-at $$head | tail -1)" ; echo "$${tag:-$$head}\c")
-DOCS = bin/elixir ../ex_doc/bin/ex_doc "$(1)" "$(VERSION)" "lib/$(2)/ebin" -m "$(3)" -u "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)" -o docs/$(2) -p http://elixir-lang.org/docs.html
-
-docs: compile ../ex_doc/bin/ex_doc
-	$(Q) rm -rf docs
-	$(call DOCS,Elixir,elixir,Kernel)
-	$(call DOCS,EEx,eex,EEx)
-	$(call DOCS,Mix,mix,Mix)
-	$(call DOCS,IEx,iex,IEx)
-	$(call DOCS,ExUnit,ex_unit,ExUnit)
+#==> Documentation tasks
+
+SOURCE_REF = $(shell tag="$(call GIT_TAG)" revision="$(call GIT_REVISION)"; echo "$${tag:-$$revision}")
+DOCS_COMPILE = CANONICAL=$(CANONICAL) bin/elixir ../ex_doc/bin/ex_doc "$(1)" "$(VERSION)" "lib/$(2)/ebin" --main "$(3)" --source-url "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)" --logo lib/elixir/pages/images/logo.png --output doc/$(2) --canonical "https://hexdocs.pm/$(2)/$(CANONICAL)" --homepage-url "https://elixir-lang.org/docs.html" $(DOCS_OPTIONS) $(4)
+DOCS_CONFIG = bin/elixir lib/elixir/scripts/docs_config.exs "$(1)"
+
+docs: compile ../ex_doc/bin/ex_doc docs_elixir docs_eex docs_mix docs_iex docs_ex_unit docs_logger
+
+docs_elixir: compile ../ex_doc/bin/ex_doc
+	@ echo "==> ex_doc (elixir)"
+	$(Q) rm -rf doc/elixir
+	$(call DOCS_COMPILE,Elixir,elixir,Kernel,--config "lib/elixir/scripts/elixir_docs.exs")
+	$(call DOCS_CONFIG,elixir)
+
+docs_eex: compile ../ex_doc/bin/ex_doc
+	@ echo "==> ex_doc (eex)"
+	$(Q) rm -rf doc/eex
+	$(call DOCS_COMPILE,EEx,eex,EEx,--config "lib/elixir/scripts/mix_docs.exs")
+	$(call DOCS_CONFIG,eex)
+
+docs_mix: compile ../ex_doc/bin/ex_doc
+	@ echo "==> ex_doc (mix)"
+	$(Q) rm -rf doc/mix
+	$(call DOCS_COMPILE,Mix,mix,Mix,--config "lib/elixir/scripts/mix_docs.exs")
+	$(call DOCS_CONFIG,mix)
+
+docs_iex: compile ../ex_doc/bin/ex_doc
+	@ echo "==> ex_doc (iex)"
+	$(Q) rm -rf doc/iex
+	$(call DOCS_COMPILE,IEx,iex,IEx,--config "lib/elixir/scripts/mix_docs.exs")
+	$(call DOCS_CONFIG,iex)
+
+docs_ex_unit: compile ../ex_doc/bin/ex_doc
+	@ echo "==> ex_doc (ex_unit)"
+	$(Q) rm -rf doc/ex_unit
+	$(call DOCS_COMPILE,ExUnit,ex_unit,ExUnit,--config "lib/elixir/scripts/mix_docs.exs")
+	$(call DOCS_CONFIG,ex_unit)
+
+docs_logger: compile ../ex_doc/bin/ex_doc
+	@ echo "==> ex_doc (logger)"
+	$(Q) rm -rf doc/logger
+	$(call DOCS_COMPILE,Logger,logger,Logger,--config "lib/elixir/scripts/mix_docs.exs")
+	$(call DOCS_CONFIG,logger)
 
 ../ex_doc/bin/ex_doc:
-	@ echo "ex_doc is not found in ../ex_doc as expected. See README for more information."
+	@ echo "ex_doc is not found in ../ex_doc as expected. See CONTRIBUTING.md for more information."
 	@ false
 
-release_zip: compile
-	rm -rf v$(VERSION).zip
-	zip -9 -r v$(VERSION).zip bin CHANGELOG.md LEGAL lib/*/ebin LICENSE README.md VERSION
+#==> Zip tasks
+
+Docs.zip: docs
+	rm -f Docs.zip
+	zip -9 -r Docs.zip CHANGELOG.md doc LICENSE README.md
+	@ echo "Docs file created $(CURDIR)/Docs.zip"
+
+Precompiled.zip: build_man compile
+	rm -f Precompiled.zip
+	zip -9 -r Precompiled.zip bin CHANGELOG.md lib/*/ebin lib/*/lib LICENSE Makefile man README.md VERSION
+	@ echo "Precompiled file created $(CURDIR)/Precompiled.zip"
+
+#==> Test tasks
 
-release_docs: docs
-	cd ../docs
-	rm -rf ../docs/master
-	mv docs ../docs/master
+test: test_formatted test_erlang test_elixir
 
-#==> Tests tasks
+test_windows: test test_taskkill
 
-test: test_erlang test_elixir
+test_taskkill:
+	taskkill //IM erl.exe //F //T //FI "MEMUSAGE gt 0"
+	taskkill //IM epmd.exe //F //T //FI "MEMUSAGE gt 0"
 
 TEST_ERL = lib/elixir/test/erlang
 TEST_EBIN = lib/elixir/test/ebin
 TEST_ERLS = $(addprefix $(TEST_EBIN)/, $(addsuffix .beam, $(basename $(notdir $(wildcard $(TEST_ERL)/*.erl)))))
 
+define FORMAT
+	$(Q) if [ "$(OS)" = "Windows_NT" ]; then \
+		cmd //C call ./bin/mix.bat format $(1); \
+	else \
+		bin/elixir bin/mix format $(1); \
+	fi
+endef
+
+format: compile
+	$(call FORMAT)
+
+test_formatted: compile
+	$(call FORMAT,--check-formatted)
+
 test_erlang: compile $(TEST_ERLS)
 	@ echo "==> elixir (eunit)"
 	$(Q) $(ERL) -pa $(TEST_EBIN) -s test_helper test;
@@ -164,25 +281,68 @@ $(TEST_EBIN)/%.beam: $(TEST_ERL)/%.erl
 	$(Q) mkdir -p $(TEST_EBIN)
 	$(Q) $(ERLC) -o $(TEST_EBIN) $<
 
-test_elixir: test_stdlib test_ex_unit test_doc_test test_mix test_eex test_iex
-
-test_doc_test: compile
-	@ echo "==> doctest (exunit)"
-	$(Q) cd lib/elixir && ../../bin/elixir -r "test/doc_test.exs";
+test_elixir: test_stdlib test_ex_unit test_logger test_eex test_iex test_mix
 
 test_stdlib: compile
-	@ echo "==> elixir (exunit)"
+	@ echo "==> elixir (ex_unit)"
 	$(Q) exec epmd & exit
-	$(Q) cd lib/elixir && ../../bin/elixir -r "test/elixir/test_helper.exs" -pr "test/elixir/**/*_test.exs";
+	$(Q) if [ "$(OS)" = "Windows_NT" ]; then \
+		cd lib/elixir && cmd //C call ../../bin/elixir.bat --sname primary -r "test/elixir/test_helper.exs" -pr "test/elixir/**/$(TEST_FILES)"; \
+	else \
+		cd lib/elixir && ../../bin/elixir --sname primary -r "test/elixir/test_helper.exs" -pr "test/elixir/**/$(TEST_FILES)"; \
+	fi
+
+cover/ex_unit_elixir.coverdata:
+	$(Q) COVER="1" $(MAKE) test_stdlib
+cover/combined.coverdata: cover/ex_unit_elixir.coverdata
+
+cover/combined.coverdata:
+	bin/elixir ./lib/elixir/scripts/cover.exs
+
+cover: cover/combined.coverdata
+
+#==> Dialyzer tasks
+
+DIALYZER_OPTS = --no_check_plt --fullpath -Werror_handling -Wunmatched_returns -Wunderspecs
+PLT = .elixir.plt
 
-.dialyzer.base_plt:
-	@ echo "==> Adding Erlang/OTP basic applications to a new base PLT"
-	$(Q) dialyzer --output_plt .dialyzer.base_plt --build_plt --apps erts kernel stdlib compiler tools syntax_tools parsetools
+$(PLT):
+	@ echo "==> Building PLT with Elixir's dependencies..."
+	$(Q) dialyzer --output_plt $(PLT) --build_plt --apps erts kernel stdlib compiler syntax_tools parsetools tools ssl inets crypto runtime_tools ftp tftp mnesia public_key asn1 sasl
 
-dialyze: .dialyzer.base_plt
-	$(Q) rm -f .dialyzer_plt
-	$(Q) cp .dialyzer.base_plt .dialyzer_plt
-	@ echo "==> Adding Elixir to PLT..."
-	$(Q) dialyzer --plt .dialyzer_plt --add_to_plt -r lib/elixir/ebin lib/ex_unit/ebin lib/eex/ebin lib/iex/ebin lib/mix/ebin
+clean_plt:
+	$(Q) rm -f $(PLT)
+
+build_plt: clean_plt $(PLT)
+
+dialyze: compile $(PLT)
 	@ echo "==> Dialyzing Elixir..."
-	$(Q) dialyzer --plt .dialyzer_plt -r lib/elixir/ebin lib/ex_unit/ebin lib/eex/ebin lib/iex/ebin lib/mix/ebin
+	$(Q) dialyzer -pa lib/elixir/ebin --plt $(PLT) $(DIALYZER_OPTS) lib/*/ebin
+
+#==> Man page tasks
+
+build_man: man/iex.1 man/elixir.1
+
+define BUILD_MANPAGES
+man/$(APP).1:
+	$(Q) cp man/$(APP).1.in man/$(APP).1
+	$(Q) sed -i.bak "/{COMMON}/r man/common" man/$(APP).1
+	$(Q) sed -i.bak "/{COMMON}/d" man/$(APP).1
+	$(Q) rm -f man/$(APP).1.bak
+endef
+
+$(foreach APP, elixir iex, $(eval $(BUILD_MANPAGES)))
+
+clean_man:
+	rm -f man/elixir.1
+	rm -f man/elixir.1.bak
+	rm -f man/iex.1
+	rm -f man/iex.1.bak
+
+install_man: build_man
+	$(Q) mkdir -p $(DESTDIR)$(MAN_PREFIX)/man1
+	$(Q) $(INSTALL_DATA) man/elixir.1  $(DESTDIR)$(MAN_PREFIX)/man1
+	$(Q) $(INSTALL_DATA) man/elixirc.1 $(DESTDIR)$(MAN_PREFIX)/man1
+	$(Q) $(INSTALL_DATA) man/iex.1     $(DESTDIR)$(MAN_PREFIX)/man1
+	$(Q) $(INSTALL_DATA) man/mix.1     $(DESTDIR)$(MAN_PREFIX)/man1
+	"$(MAKE)" clean_man
diff --git a/OPEN_SOURCE_POLICY.md b/OPEN_SOURCE_POLICY.md
new file mode 100644
index 00000000000..381975f0db0
--- /dev/null
+++ b/OPEN_SOURCE_POLICY.md
@@ -0,0 +1,165 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Open Source Policy
+
+## 1. Introduction
+
+This Open Source Policy outlines the licensing, contribution, and compliance
+requirements for all code released under the Elixir project. By adhering to
+these guidelines, we ensure that our community, maintainers, and contributors
+uphold both legal and ethical standards while fostering a collaborative,
+transparent environment.
+
+This policy exists to support and protect the Elixir community. It aims to
+balance openness, collaboration, and respect for all contributors’ rights,
+ensuring that Elixir remains a trusted and innovative open source project.
+
+## 2. Scope
+
+This policy applies to the Elixir Programming language, located at
+<https://github.com/elixir-lang/elixir>. It covers every file, and contribution
+made, including documentation and any associated assets.
+
+## 3. Licensing
+
+All code released by the Elixir team is licensed under the
+[Apache-2.0](./LICENSES/Apache-2.0.txt) license. Additionally, the following
+licenses are recognized as permissible in this project:
+
+  - The Unicode license, as documented at
+    [LicenseRef-scancode-unicode](./LICENSES/LicenseRef-scancode-unicode.txt)
+
+  - The Elixir Trademark Policy, as documented at
+    [LicenseRef-elixir-trademark-policy](./LICENSES/LicenseRef-elixir-trademark-policy.txt)
+
+These licenses are considered acceptable for any files or code that form part of
+an Elixir repository. If a contribution requires a different license, it must
+either be rejected or prompt an update to this policy.
+
+## 4. Contributing to the Elixir repository
+
+Any code contributed to the Elixir repository must fall under one of the accepted
+licenses (Apache-2.0, Unicode, or Elixir Trademark). Contributions under any
+other license will be rejected unless this policy is formally revised to include
+that license. All files except those specifically exempted (e.g., certain test
+fixture files) must contain SPDX license and copyright headers
+(`SPDX-License-Identifier` and `SPDX-FileCopyrightText`). If a file qualifies
+for an exception, this must be configured in the ORT (Open Source Review Toolkit)
+configuration and undergo review.
+
+Contributions must not introduce executable binary files into the codebase.
+
+## 5. Preservation of Copyright and License Information
+
+Any third-party code incorporated into the Elixir repository must retain original
+copyright and license headers. If no such headers exist in the source, they must
+be added. This practice ensures that original authors receive proper credit and
+that the licensing lineage is preserved.
+
+## 6. Objectives
+
+The Elixir project aims to promote a culture of responsible open source usage.
+Specifically, our objectives include:
+
+### 6.1 Clearly Define and Communicate Licensing & Compliance Policies
+
+We will identify and document all third-party dependencies, ensure that license
+information is communicated clearly, and maintain a project-wide license policy
+or compliance handbook.
+
+### 6.2 Implement Clear Processes for Reviewing Contributions
+
+We will provide well-defined contribution guidelines. We implement the
+Developer Certificate of Origin (DCO) for additional clarity regarding
+contributor rights and obligations.
+
+### 6.3 Track and Audit Third-Party Code Usage
+
+All projects will implement a Software Bill of Materials (SBoM) strategy and
+regularly verify license compliance for direct and transitive dependencies.
+
+### 6.4 Monitor and Continuously Improve Open Source Compliance
+
+We will conduct periodic internal audits, integrate compliance checks into
+continuous integration (CI/CD) pipelines, and regularly review and refine these
+objectives to align with best practices.
+
+## 7. Roles and Responsibilities
+
+### 7.1 Core Team Member
+
+Core Team Members are responsible for being familiar with this policy and
+ensuring it is consistently enforced. They must demonstrate sufficient
+competencies to understand the policy requirements and must reject or request
+changes to any pull requests that violate these standards.
+
+### 7.2 Contributor
+
+Contributors are expected to follow this policy when submitting code. If a
+contributor submits a pull request that does not comply with the policy
+(e.g., introduces a disallowed license), Core Team Members have the authority to
+reject it or request changes. No special competencies are required for
+contributors beyond awareness and adherence to the policy.
+
+### 7.3 EEF CISO
+
+The CISO designated by the Erlang Ecosystem Foundation (EEF) provides oversight
+on queries and guidance regarding open source compliance or legal matters for
+Elixir. The CISO is responsible for checking ongoing compliance with the policy,
+escalating potential violations to the Core Team, and involving legal counsel if
+necessary. This role does not require legal expertise but does involve
+initiating legal or community discussions when needed.
+
+## 8. Implications of Failing to Follow the Program Requirements
+
+If a violation of this policy is identified, the Elixir Core Team will undertake
+the following actions:
+
+## 8.1 Review the Codebase for Additional Violations
+
+We will investigate the codebase thoroughly to detect any similar instances of
+non-compliance.
+
+## 8.2 Review and Update the Process or Policy
+
+In collaboration with the EEF CISO, the Elixir Core Team will assess the policy
+and our internal workflows, making any necessary clarifications or amendments to
+reduce the likelihood of recurrence.
+
+## 8.3 Notify and Train Core Team Members
+
+We will ensure that all active Core Team Members are informed about any policy
+changes and understand how to apply them in everyday development.
+
+## 8.4 Remove or Replace the Offending Code
+
+If required, we will remove or replace the non-compliant code.
+
+## 9. Contact
+
+The project maintains a private mailing list at
+[policy@elixir-lang.org](mailto:policy@elixir-lang.org) for handling licensing
+and policy-related queries. Email is the preferred communication channel, and
+the EEF CISO will be included on this list to provide assistance and ensure
+timely responses. While solutions may take longer to implement, the project
+commits to acknowledging all queries within five business days.
+
+## 10. External Contributions of Core Team Members
+
+When Core Team Members contribute to repositories outside Elixir, they do so in
+a personal capacity or via their employer. They will not act as official
+representatives of the Elixir team in those external contexts.
+
+## 11. Policy Review and Amendments
+
+This policy will be revisited annually to address new concerns, accommodate
+changes in community standards, or adjust to emerging legal or technical
+requirements. Proposed amendments must be reviewed by the Core Team and, if
+necessary, by the EEF CISO. Any significant changes will be communicated to
+contributors and made publicly available.
+
+*Effective Date: 2025-02-20*  
+*Last Reviewed: 2025-11-20*
diff --git a/README.md b/README.md
index 5bfeb70f5ff..e82eb0e4341 100644
--- a/README.md
+++ b/README.md
@@ -1,57 +1,158 @@
-![Elixir](https://github.com/elixir-lang/elixir-lang.github.com/raw/master/images/logo/logo.png)
-=========
-[![Build Status](https://secure.travis-ci.org/elixir-lang/elixir.svg?branch=master "Build Status")](http://travis-ci.org/elixir-lang/elixir)
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
 
-For more about Elixir, installation and documentation, [check Elixir's website](http://elixir-lang.org/).
+<h1>
+ <picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://github.com/elixir-lang/elixir-lang.github.com/raw/main/images/logo/logo-dark.png">
+  <img alt="Elixir logo" src="https://github.com/elixir-lang/elixir-lang.github.com/raw/main/images/logo/logo.png" width="200">
+ </picture>
+</h1>
 
-## Usage
+[![CI](https://github.com/elixir-lang/elixir/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/elixir-lang/elixir/actions/workflows/ci.yml?query=branch%3Amain)
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/10187/badge)](https://www.bestpractices.dev/projects/10187)
 
-If you want to contribute to Elixir or run it from source, clone this repository to your machine, compile and test it:
+Elixir is a dynamic, functional language designed for building scalable
+and maintainable applications.
 
-    $ git clone https://github.com/elixir-lang/elixir.git
-    $ cd elixir
-    $ make clean test
+For more about Elixir, installation and documentation,
+[check Elixir's website](https://elixir-lang.org/).
 
-If Elixir fails to build (specifically when pulling in a new version via git), be sure to remove any previous build artifacts by running `make clean`, then `make test`.
+## Policies
 
-If tests pass, you are ready to move on to the [Getting Started guide][1] or to try Interactive Elixir by running: `bin/iex` in your terminal.
+New releases are announced in the [announcement mailing list][8].
+You can subscribe by sending an email to <elixir-lang-ann+subscribe@googlegroups.com>
+and replying to the confirmation email.
 
-However, if tests fail, it is likely you have an outdated Erlang version (Elixir requires Erlang 17.0 or later). You can check your Erlang version by calling `erl` in the command line. You will see some information as follows:
+All security releases [will be tagged with `[security]`][10]. For more
+information, please read our [Security Policy][9].
 
-    Erlang/OTP 17 [erts-6.0] [source-07b8f44] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false]
+All interactions in our official communication channels follow our
+[Code of Conduct][1].
 
-If you have the correct version and tests still fail, feel free to [open an issue][2].
+All contributions are required to conform to our [Open Source Policy][11].
 
-## Building documentation
+## Bug reports
 
-Building the documentation requires [ex_doc](https://github.com/elixir-lang/ex_doc) to be installed and built in the same containing folder as elixir.
+For reporting bugs, [visit our issue tracker][2] and follow the steps
+for reporting a new issue. **Please disclose security vulnerabilities
+privately [in our Security page](https://github.com/elixir-lang/elixir/security)**.
 
-    # After cloning and compiling Elixir
-    $ git clone git://github.com/elixir-lang/ex_doc.git
-    $ cd ex_doc && ../elixir/bin/mix compile
-    $ cd ../elixir && make docs
+All currently open bugs related to Elixir are listed in the issues tracker.
+The Elixir team uses the issues tracker to focus on *actionable items*,
+including planned enhancements in the short and medium term. We also do
+our best to label entries for clarity and to ease collaboration.
 
-## Contributing
+Our *actionable item policy* has some important consequences, such as:
+
+  * Proposing new features as well as requests for support, help, and
+    guidance must be done in their own spaces, detailed next.
+
+  * Issues we have identified to be outside of Elixir's scope,
+    such as an upstream bug, will be closed (and requested to be moved
+    elsewhere if appropriate).
+
+  * We actively close unrelated and non-actionable issues to keep the
+    issues tracker tidy. If you believe we got something wrong, drop a
+    comment and we can always reopen the issue.
+
+By keeping the overall issues tracker tidy and organized, the community
+can easily peek at what is coming in new releases and also get involved
+by commenting on existing issues and submitting pull requests. Please
+remember to keep the tone positive and be kind! For more information,
+see the [Code of Conduct][1].
+
+## Discussions, support, and help
+
+For general discussions, support, and help, please use the community
+spaces [listed on the sidebar of the Elixir website](https://elixir-lang.org/),
+such as forums, chat platforms, etc, where the wider community will be available
+to help you.
+
+## Proposing new features
+
+We encourage you to first propose new features in the community spaces
+listed above. These discussions help refine ideas and gather feedback before
+submission. Our website also includes [a general outline of the language
+history and its current development focus](https://elixir-lang.org/development.html).
 
-We appreciate any contribution to Elixir, so check out our [CONTRIBUTING.md](CONTRIBUTING.md) guide for more information. We usually keep a list of features and bugs [in the issue tracker][2].
+Once you are ready, you can submit your proposal to the [Elixir Core
+mailing list][3], either through the web interface or by subscribing to
+it at <elixir-lang-core+subscribe@googlegroups.com>. Remember to include
+a clear problem description, compare the proposed solution to existing
+alternatives in the Elixir ecosystem (and in other languages if possible),
+and consider the potential impact your changes will have on the codebase and
+community.
 
-## Important links
+Once a proposal is accepted, it will be added to [the issue tracker][2].
+Features and bug fixes that have already been merged and will be included
+in the next release are then "closed" and added to the [changelog][7]
+before release.
 
-* \#elixir-lang on freenode IRC
-* [Website][1]
-* [Issue tracker][2]
-* [elixir-talk Mailing list (questions)][3]
-* [elixir-core Mailing list (development)][4]
+## Compiling from source
+
+For the many different ways to install Elixir,
+[see our installation instructions on the website](https://elixir-lang.org/install.html).
+However, if you want to contribute to Elixir, you will need to compile from source.
+
+First, [install Erlang](https://elixir-lang.org/install.html#installing-erlang).
+After that, clone this repository to your machine, compile and test it:
+
+```sh
+git clone https://github.com/elixir-lang/elixir.git
+cd elixir
+make
+```
+
+> Note: if you are running on Windows,
+[this article includes important notes for compiling Elixir from source
+on Windows](https://github.com/elixir-lang/elixir/wiki/Windows).
+
+In case you want to use this Elixir version as your system version,
+you need to add the `bin` directory to [your PATH environment variable](https://elixir-lang.org/install.html#setting-path-environment-variable).
+
+When updating the repository, you may want to run `make clean` before
+recompiling. For deterministic builds, you should set the environment
+variable `ERL_COMPILER_OPTIONS=deterministic`.
+
+## Contributing
 
-  [1]: http://elixir-lang.org
+Contributions to Elixir are always welcome! Before you get started, please check
+out our [CONTRIBUTING.md](CONTRIBUTING.md) file. There you will find detailed
+guidelines on how to set up your environment, run the test suite, format your
+code, and submit pull requests. We also include information on our review
+process, licensing requirements, and helpful tips to ensure a smooth
+contribution experience.
+
+## Development links
+
+  * [Elixir Documentation][6]
+  * [Elixir Core Mailing list (development)][3]
+  * [Announcement mailing list][8]
+  * [Code of Conduct][1]
+  * [Issue tracker][2]
+  * [Changelog][7]
+  * [Security Policy][9]
+  * **[#elixir][4]** on [Libera.Chat][5] IRC
+
+  [1]: CODE_OF_CONDUCT.md
   [2]: https://github.com/elixir-lang/elixir/issues
-  [3]: http://groups.google.com/group/elixir-lang-talk
-  [4]: http://groups.google.com/group/elixir-lang-core
+  [3]: https://groups.google.com/group/elixir-lang-core
+  [4]: https://web.libera.chat/#elixir
+  [5]: https://libera.chat
+  [6]: https://elixir-lang.org/docs.html
+  [7]: CHANGELOG.md
+  [8]: https://groups.google.com/group/elixir-lang-ann
+  [9]: SECURITY.md
+  [10]: https://groups.google.com/forum/#!searchin/elixir-lang-ann/%5Bsecurity%5D%7Csort:date
+  [11]: OPEN_SOURCE_POLICY.md
 
 ## License
 
-"Elixir" and the Elixir logo are copyright (c) 2012 Plataformatec.
+"Elixir" and the Elixir logo are registered trademarks of The Elixir Team.
 
-Elixir source code is released under Apache 2 License with some parts under Erlang's license (EPL).
+Elixir source code is released under Apache License 2.0.
 
-Check [LEGAL](LEGAL) and [LICENSE](LICENSE) files for more information.
+Check [LICENSE](LICENSE) file for more information.
diff --git a/RELEASE.md b/RELEASE.md
index 965ace69e87..b93f1b68932 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -1,31 +1,55 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
 # Release process
 
-This document simply outlines the release process:
+## Shipping a new version
+
+1. Update version in /VERSION, bin/elixir, and bin/elixir.bat
+
+2. Ensure /CHANGELOG.md is updated, versioned and add the current date
+
+3. Update "Compatibility and Deprecations" if a new OTP version is supported
+
+4. Commit changes above with title "Release vVERSION" and push it
+
+5. Once GitHub actions completes, generate a new tag, and push it
+
+6. Wait until GitHub Actions publish artifacts to the draft release
+
+7. Copy the relevant bits from /CHANGELOG.md to the GitHub release and publish it (link to the announcement if there is one)
+
+8. Update `_data/elixir-versions.yml` (except for RCs) in `elixir-lang/elixir-lang.github.com`
+
+## Creating a new vMAJOR.MINOR branch (before first rc)
+
+### In the new branch
 
-1. Remove `-dev` extension from VERSION
+1. Comment out `CANONICAL := main/` in /Makefile
 
-2. Ensure CHANGELOG is updated and timestamp
+2. Update tables in /SECURITY.md and "Compatibility and Deprecations"
 
-3. Commit changes above with title "Release vVERSION" and generate new tag
+3. Commit "Branch out vMAJOR.MINOR"
 
-4. Run `make clean test` to ensure all tests pass from scratch and the CI is green
+### Back in main
 
-5. Push master and tags
+1. Bump /VERSION file, bin/elixir, and bin/elixir.bat
 
-6. Release new docs with `make release_docs`, move docs to `docs/stable`
+2. Start new /CHANGELOG.md
 
-7. Release new zip with `make release_zip`, push new zip to GitHub Releases
+3. Update tables in /SECURITY.md and in "Compatibility and Deprecations"
 
-8. Merge master into stable branch and push it
+4. Commit "Start vMAJOR.MINOR+1"
 
-9. After release, bump versions, add `-dev` back and commit
+## Changing supported Erlang/OTP versions
 
-10. `make release_docs` once again and push it to `elixir-lang.org`
+1. Update the table in Compatibility and Deprecations
 
-11. Also update `release` file in `elixir-lang.org`
+2. Update `otp_release` checks in `/Makefile` and `/lib/elixir/src/elixir.erl`
 
-## Places where version is mentioned
+3. Update relevant CI workflows in `/.github/workflows/*.yml` - for release workflows, outdated/recently added Erlang/OTP versions must run conditionally
 
-* VERSION
-* CHANGELOG
-* src/elixir.app.src
+4. Remove `otp_release` version checks that are no longer needed
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000000..d132954cc5b
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,30 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
+# Security Policy
+
+## Supported versions
+
+Elixir applies bug fixes only to the latest minor branch. Security patches are available for the last 5 minor branches:
+
+Elixir version | Support
+:------------- | :-----------------------------
+1.20           | Development
+1.19           | Bug fixes and security patches
+1.18           | Security patches only
+1.17           | Security patches only
+1.16           | Security patches only
+1.15           | Security patches only
+
+## Announcements
+
+New releases are announced in the read-only [announcements mailing list](https://groups.google.com/group/elixir-lang-ann). You can subscribe by sending an email to <elixir-lang-ann+subscribe@googlegroups.com> and replying to the confirmation email. Security notifications [will be tagged with `[security]`](https://groups.google.com/forum/#!searchin/elixir-lang-ann/%5Bsecurity%5D%7Csort:date).
+
+You may also see [all releases](https://github.com/elixir-lang/elixir/releases) and [consult all disclosed vulnerabilities](https://github.com/elixir-lang/elixir/security) on GitHub.
+
+## Reporting a vulnerability
+
+[Please disclose security vulnerabilities privately via GitHub](https://github.com/elixir-lang/elixir/security).
diff --git a/VERSION b/VERSION
index 49ccc4f4b86..734375f897d 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.14.3-dev
\ No newline at end of file
+1.20.0-dev
diff --git a/bin/elixir b/bin/elixir
index d63c1d206fc..40d3a6d8c4c 100755
--- a/bin/elixir
+++ b/bin/elixir
@@ -1,26 +1,68 @@
 #!/bin/sh
-if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
-  echo "Usage: `basename $0` [options] [.exs file] [data]
-
-  -v                Prints version and exit
-  -e \"command\"      Evaluates the given command (*)
-  -r \"file\"         Requires the given files/patterns (*)
-  -S \"script\"       Finds and executes the given script
-  -pr \"file\"        Requires the given files/patterns in parallel (*)
-  -pa \"path\"        Prepends the given path to Erlang code path (*)
-  -pz \"path\"        Appends the given path to Erlang code path (*)
-  --app \"app\"       Start the given app and its dependencies (*)
-  --erl \"switches\"  Switches to be passed down to erlang (*)
-  --name \"name\"     Makes and assigns a name to the distributed node
-  --sname \"name\"    Makes and assigns a short name to the distributed node
-  --cookie \"cookie\" Sets a cookie for this distributed node
-  --hidden          Makes a hidden node
-  --detached        Starts the Erlang VM detached from console
-  --no-halt         Does not halt the Erlang VM after execution
-
-** Options marked with (*) can be given more than once
-** Options given after the .exs file or -- are passed down to the executed code
-** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS or --erl" >&2
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+set -e
+
+ELIXIR_VERSION=1.20.0-dev
+
+if [ $# -eq 0 ] || { [ $# -eq 1 ] && { [ "$1" = "--help" ] || [ "$1" = "-h" ]; }; }; then
+  cat <<USAGE >&2
+Usage: $(basename "$0") [options] [.exs file] [data]
+
+## General options
+
+  -e "COMMAND"                 Evaluates the given command (*)
+  -h, --help                   Prints this message (standalone)
+  -r "FILE"                    Requires the given files/patterns (*)
+  -S SCRIPT                    Finds and executes the given script in \$PATH
+  -pr "FILE"                   Requires the given files/patterns in parallel (*)
+  -pa "PATH"                   Prepends the given path to Erlang code path (*)
+  -pz "PATH"                   Appends the given path to Erlang code path (*)
+  -v, --version                Prints Erlang/OTP and Elixir versions (standalone)
+
+  --color, --no-color          Enables or disables ANSI coloring
+  --erl "SWITCHES"             Switches to be passed down to Erlang (*)
+  --eval "COMMAND"             Evaluates the given command, same as -e (*)
+  --logger-otp-reports BOOL    Enables or disables OTP reporting
+  --logger-sasl-reports BOOL   Enables or disables SASL reporting
+  --no-halt                    Does not halt the Erlang VM after execution
+  --short-version              Prints Elixir version (standalone)
+
+Options given after the .exs file or -- are passed down to the executed code.
+Options can be passed to the Erlang runtime using \$ELIXIR_ERL_OPTIONS or --erl.
+
+## Distribution options
+
+The following options are related to node distribution.
+
+  --cookie COOKIE              Sets a cookie for this distributed node
+  --hidden                     Makes a hidden node
+  --name NAME                  Makes and assigns a name to the distributed node
+  --rpc-eval NODE "COMMAND"    Evaluates the given command on the given remote node (*)
+  --sname NAME                 Makes and assigns a short name to the distributed node
+
+--name and --sname may be set to undefined so one is automatically generated.
+
+## Release options
+
+The following options are generally used under releases.
+
+  --boot "FILE"                Uses the given FILE.boot to start the system
+  --boot-var VAR "VALUE"       Makes \$VAR available as VALUE to FILE.boot (*)
+  --erl-config "FILE"          Loads configuration in FILE.config written in Erlang (*)
+  --pipe-to "PIPEDIR" "LOGDIR" Starts the Erlang VM as a named PIPEDIR and LOGDIR
+  --vm-args "FILE"             Passes the contents in file as arguments to the VM
+
+--pipe-to starts Elixir detached from console (Unix-like only).
+It will attempt to create PIPEDIR and LOGDIR if they don't exist.
+See run_erl to learn more. To reattach, run: to_erl PIPEDIR.
+
+** Options marked with (*) can be given more than once.
+** Standalone options can't be combined with other options.
+USAGE
   exit 1
 fi
 
@@ -30,64 +72,175 @@ readlink_f () {
   if [ -h "$filename" ]; then
     readlink_f "$(readlink "$filename")"
   else
-    echo "`pwd -P`/$filename"
+    echo "$(pwd -P)/$filename"
   fi
 }
 
-MODE="elixir"
+if [ $# -eq 1 ] && [ "$1" = "--short-version" ]; then
+  echo "$ELIXIR_VERSION"
+  exit 0
+fi
+
+# Stores static Erlang arguments and --erl (which is passed as is)
 ERL=""
+
+# Stores erl arguments preserving spaces/quotes (mimics an array)
+erl_set () {
+  eval "E${E}=\$1"
+  E=$((E + 1))
+}
+
+# Checks if a string starts with prefix. Usage: starts_with "$STRING" "$PREFIX"
+starts_with () {
+  case $1 in
+    "$2"*) true;;
+    *) false;;
+  esac
+}
+
+ERL_EXEC="erl"
+MODE="cli"
 I=1
+E=0
+LENGTH=$#
+set -- "$@" -extra
 
-while [ $I -le $# ]; do
-  S=1
-  eval "PEEK=\${$I}"
-  case "$PEEK" in
+while [ $I -le $LENGTH ]; do
+  # S counts to be shifted, C counts to be copied
+  S=0
+  C=0
+  case "$1" in
+    +elixirc)
+        C=1
+        ;;
     +iex)
+        C=1
         MODE="iex"
         ;;
-    +elixirc)
-        MODE="elixirc"
+    -v|--no-halt|--color|--no-color)
+        C=1
+        ;;
+    -e|-r|-pr|-pa|-pz|--eval|--remsh|--dot-iex|--dbg)
+        C=2
         ;;
-    -v|--compile|--no-halt)
+    --rpc-eval)
+        C=3
         ;;
-    -e|-r|-pr|-pa|-pz|--remsh|--app)
+    --hidden)
+        S=1
+        ERL="$ERL -hidden"
+        ;;
+    --logger-otp-reports)
         S=2
+        if [ "$2" = 'true' ] || [ "$2" = 'false' ]; then
+          ERL="$ERL -logger handle_otp_reports $2"
+        fi
         ;;
-    --detached|--hidden)
-        ERL="$ERL `echo $PEEK | cut -c 2-`"
+    --logger-sasl-reports)
+        S=2
+        if [ "$2" = 'true' ] || [ "$2" = 'false' ]; then
+          ERL="$ERL -logger handle_sasl_reports $2"
+        fi
+        ;;
+    --erl)
+        S=2
+        ERL="$ERL $2"
         ;;
     --cookie)
-        I=$(expr $I + 1)
-        eval "VAL=\${$I}"
-        ERL="$ERL -setcookie "$VAL""
+        S=2
+        erl_set "-setcookie"
+        erl_set "$2"
         ;;
     --sname|--name)
-        I=$(expr $I + 1)
-        eval "VAL=\${$I}"
-        ERL="$ERL `echo $PEEK | cut -c 2-` "$VAL""
+        S=2
+        erl_set "$(echo "$1" | cut -c 2-)"
+        erl_set "$2"
         ;;
-    --erl)
-        I=$(expr $I + 1)
-        eval "VAL=\${$I}"
-        ERL="$ERL "$VAL""
+    --erl-config)
+        S=2
+        erl_set "-config"
+        erl_set "$2"
+        ;;
+    --vm-args)
+        S=2
+        erl_set "-args_file"
+        erl_set "$2"
+        ;;
+    --boot)
+        S=2
+        erl_set "-boot"
+        erl_set "$2"
+        ;;
+    --boot-var)
+        S=3
+        erl_set "-boot_var"
+        erl_set "$2"
+        erl_set "$3"
+        ;;
+    --pipe-to)
+        S=3
+        RUN_ERL_PIPE="$2"
+        RUN_ERL_LOG="$3"
+        if [ "$(starts_with "$RUN_ERL_PIPE" "-")" ]; then
+          echo "--pipe-to : PIPEDIR cannot be a switch" >&2 && exit 1
+        elif [ "$(starts_with "$RUN_ERL_LOG" "-")" ]; then
+          echo "--pipe-to : LOGDIR cannot be a switch" >&2 && exit 1
+        fi
         ;;
     *)
+        while [ $I -le $LENGTH ]; do
+          I=$((I + 1))
+          set -- "$@" "$1"
+          shift
+        done
         break
         ;;
   esac
-  I=$(expr $I + $S)
+
+  while [ $I -le $LENGTH ] && [ $C -gt 0 ]; do
+    C=$((C - 1))
+    I=$((I + 1))
+    set -- "$@" "$1"
+    shift
+  done
+
+  I=$((I + S))
+  shift $S
+done
+
+I=$((E - 1))
+while [ $I -ge 0 ]; do
+  eval "VAL=\$E$I"
+  set -- "$VAL" "$@"
+  I=$((I - 1))
 done
 
 SELF=$(readlink_f "$0")
 SCRIPT_PATH=$(dirname "$SELF")
-if [ "$MODE" != "iex" ]; then ERL="$ERL -noshell -s elixir start_cli"; fi
 
-if [ -z "$ERL_PATH" ]; then
-  if [ -f "$SCRIPT_PATH/../releases/RELEASES" ] && [ -f "$SCRIPT_PATH/erl" ]; then
-    ERL_PATH="$SCRIPT_PATH"/erl
-  else
-    ERL_PATH=erl
-  fi
+if [ "$OSTYPE" = "cygwin" ]; then SCRIPT_PATH=$(cygpath -m "$SCRIPT_PATH"); fi
+if [ "$MODE" != "iex" ]; then ERL="-s elixir start_cli $ERL"; fi
+
+# One MAY change ERTS_BIN= but you MUST NOT change
+# ERTS_BIN=$ERTS_BIN as it is handled by Elixir releases.
+ERTS_BIN=
+ERTS_BIN="$ERTS_BIN"
+
+set -- "$ERTS_BIN$ERL_EXEC" -noshell -elixir_root "$SCRIPT_PATH"/../lib -pa "$SCRIPT_PATH"/../lib/elixir/ebin $ELIXIR_ERL_OPTIONS $ERL "$@"
+
+if [ -n "$RUN_ERL_PIPE" ]; then
+  ESCAPED=""
+  for PART in "$@"; do
+    ESCAPED="$ESCAPED $(printf '%s' "$PART" | sed 's@[^a-zA-Z0-9_/-]@\\&@g')"
+  done
+  mkdir -p "$RUN_ERL_PIPE"
+  mkdir -p "$RUN_ERL_LOG"
+  ERL_EXEC="run_erl"
+  set -- "$ERTS_BIN$ERL_EXEC" -daemon "$RUN_ERL_PIPE/" "$RUN_ERL_LOG/" "$ESCAPED"
 fi
 
-exec "$ERL_PATH" -pa "$SCRIPT_PATH"/../lib/*/ebin $ELIXIR_ERL_OPTIONS $ERL -extra "$@"
+if [ -n "$ELIXIR_CLI_DRY_RUN" ]; then
+  echo "$@"
+else
+  exec "$@"
+fi
diff --git a/bin/elixir.bat b/bin/elixir.bat
index 3ed6dda1150..3b4fb11721f 100644
--- a/bin/elixir.bat
+++ b/bin/elixir.bat
@@ -1,95 +1,149 @@
 @echo off
-if "%1"==""       goto documentation
-if "%1"=="--help" goto documentation
-if "%1"=="-h"     goto documentation
-if "%1"=="/h"     goto documentation
+
+:: SPDX-License-Identifier: Apache-2.0
+:: SPDX-FileCopyrightText: 2021 The Elixir Team
+:: SPDX-FileCopyrightText: 2012 Plataformatec
+
+set ELIXIR_VERSION=1.20.0-dev
+
+if    ""%1""==""""                if ""%2""=="""" goto documentation
+if /I ""%1""==""--help""          if ""%2""=="""" goto documentation
+if /I ""%1""==""-h""              if ""%2""=="""" goto documentation
+if /I ""%1""==""/h""              if ""%2""=="""" goto documentation
+if    ""%1""==""/?""              if ""%2""=="""" goto documentation
+if /I ""%1""==""--short-version"" if ""%2""=="""" goto shortversion
 goto parseopts
 
 :documentation
 echo Usage: %~nx0 [options] [.exs file] [data]
 echo.
-echo   -v                Prints version and exit
-echo   -e command        Evaluates the given command (*)
-echo   -r file           Requires the given files/patterns (*)
-echo   -S script         Finds and executes the given script
-echo   -pr file          Requires the given files/patterns in parallel (*)
-echo   -pa path          Prepends the given path to Erlang code path (*)
-echo   -pz path          Appends the given path to Erlang code path (*)
-echo   --app app         Start the given app and its dependencies (*)
-echo   --erl switches    Switches to be passed down to erlang (*)
-echo   --name name       Makes and assigns a name to the distributed node
-echo   --sname name      Makes and assigns a short name to the distributed node
-echo   --cookie cookie   Sets a cookie for this distributed node
-echo   --hidden          Makes a hidden node
-echo   --detached        Starts the Erlang VM detached from console
-echo   --no-halt         Does not halt the Erlang VM after execution
+echo ## General options
+echo.
+echo   -e "COMMAND"                 Evaluates the given command (*)
+echo   -h, --help                   Prints this message (standalone)
+echo   -r "FILE"                    Requires the given files/patterns (*)
+echo   -S SCRIPT                    Finds and executes the given script in $PATH
+echo   -pr "FILE"                   Requires the given files/patterns in parallel (*)
+echo   -pa "PATH"                   Prepends the given path to Erlang code path (*)
+echo   -pz "PATH"                   Appends the given path to Erlang code path (*)
+echo   -v, --version                Prints Erlang/OTP and Elixir versions (standalone)
+echo.
+echo   --color, --no-color          Enables or disables ANSI coloring
+echo   --erl "SWITCHES"             Switches to be passed down to Erlang (*)
+echo   --eval "COMMAND"             Evaluates the given command, same as -e (*)
+echo   --logger-otp-reports BOOL    Enables or disables OTP reporting
+echo   --logger-sasl-reports BOOL   Enables or disables SASL reporting
+echo   --no-halt                    Does not halt the Erlang VM after execution
+echo   --short-version              Prints Elixir version (standalone)
+echo.
+echo Options given after the .exs file or -- are passed down to the executed code.
+echo Options can be passed to the Erlang runtime using $ELIXIR_ERL_OPTIONS or --erl.
+echo.
+echo ## Distribution options
+echo.
+echo The following options are related to node distribution.
+echo.
+echo   --cookie COOKIE              Sets a cookie for this distributed node
+echo   --hidden                     Makes a hidden node
+echo   --name NAME                  Makes and assigns a name to the distributed node
+echo   --rpc-eval NODE "COMMAND"    Evaluates the given command on the given remote node (*)
+echo   --sname NAME                 Makes and assigns a short name to the distributed node
+echo.
+echo --name and --sname may be set to undefined so one is automatically generated.
+echo.
+echo ## Release options
+echo.
+echo The following options are generally used under releases.
+echo.
+echo   --boot "FILE"                Uses the given FILE.boot to start the system
+echo   --boot-var VAR "VALUE"       Makes $VAR available as VALUE to FILE.boot (*)
+echo   --erl-config "FILE"          Loads configuration in FILE.config written in Erlang (*)
+echo   --vm-args "FILE"             Passes the contents in file as arguments to the VM
 echo.
-echo ** Options marked with (*) can be given more than once
-echo ** Options given after the .exs file or -- are passed down to the executed code
-echo ** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS or --erl
-goto :EOF
+echo --pipe-to is not supported on Windows. If set, Elixir won't boot.
+echo.
+echo ** Options marked with (*) can be given more than once.
+echo ** Standalone options can't be combined with other options.
+goto end
+
+:shortversion
+echo %ELIXIR_VERSION%
+goto end
 
 :parseopts
+setlocal enabledelayedexpansion
 
 rem Parameters for Erlang
 set parsErlang=
 
-rem Make sure we keep a copy of all parameters
-set allPars=%*
-
-rem Get the original path name from the batch file
-set originPath=%~dp0
-
 rem Optional parameters before the "-extra" parameter
 set beforeExtra=
 
-rem Flag which determines whether or not to use werl vs erl
-set useWerl=0
+rem Option which determines whether the loop is over
+set endLoop=0
+
+rem Designates the path to the current script
+set SCRIPT_PATH=%~dp0
+
+rem Designates the path to the ERTS system
+set ERTS_BIN=
+set ERTS_BIN=!ERTS_BIN!
 
 rem Recursive loop called for each parameter that parses the cmd line parameters
 :startloop
-set par="%1"
-shift
-if "%par%"=="" (
-  rem if no parameters defined
-  goto :expand_erl_libs
-)
-if "%par%"=="""" (
-  rem if no parameters defined - special case for parameter that is already quoted
-  goto :expand_erl_libs
+set "par=%~1"
+if "!par!"=="" (
+  rem skip if no parameter
+  goto run
 )
+shift
+set par="!par:"=\"!"
 rem ******* EXECUTION OPTIONS **********************
-IF "%par%"==""+iex"" (Set useWerl=1)
+if !par!=="+iex"     (set useIEx=1 && goto startloop)
+if !par!=="+elixirc" (goto startloop)
+rem ******* ELIXIR PARAMETERS **********************
+if ""==!par:-e=!          (shift && goto startloop)
+if ""==!par:--eval=!      (shift && goto startloop)
+if ""==!par:--rpc-eval=!  (shift && shift && goto startloop)
+if ""==!par:-r=!          (shift && goto startloop)
+if ""==!par:-pr=!         (shift && goto startloop)
+if ""==!par:-pa=!         (shift && goto startloop)
+if ""==!par:-pz=!         (shift && goto startloop)
+if ""==!par:-v=!          (goto startloop)
+if ""==!par:--version=!   (goto startloop)
+if ""==!par:--no-halt=!   (goto startloop)
+if ""==!par:--color=!     (goto startloop)
+if ""==!par:--no-color=!  (goto startloop)
+if ""==!par:--remsh=!     (shift && goto startloop)
+if ""==!par:--dot-iex=!   (shift && goto startloop)
+if ""==!par:--dbg=!       (shift && goto startloop)
 rem ******* ERLANG PARAMETERS **********************
-IF NOT "%par%"=="%par:--detached=%" (Set parsErlang=%parsErlang% -detached) 
-IF NOT "%par%"=="%par:--hidden=%"   (Set parsErlang=%parsErlang% -hidden)
-IF NOT "%par%"=="%par:--cookie=%"   (Set parsErlang=%parsErlang% -setcookie %1 && shift)
-IF NOT "%par%"=="%par:--sname=%"    (Set parsErlang=%parsErlang% -sname %1 && shift) 
-IF NOT "%par%"=="%par:--name=%"     (Set parsErlang=%parsErlang% -name %1 && shift) 
-IF NOT "%par%"=="%par:--erl=%"      (Set beforeExtra=%beforeExtra% %~1 && shift) 
-rem ******* elixir parameters **********************
-rem Note: we don't have to do anything with options that don't take an argument
-IF NOT "%par%"=="%par:-e=%"      (shift) 
-IF NOT "%par%"=="%par:-r=%"      (shift) 
-IF NOT "%par%"=="%par:-pr=%"     (shift) 
-IF NOT "%par%"=="%par:-pa=%"     (shift) 
-IF NOT "%par%"=="%par:-pz=%"     (shift) 
-IF NOT "%par%"=="%par:--app=%"   (shift) 
-IF NOT "%par%"=="%par:--remsh=%" (shift) 
-goto:startloop
+if ""==!par:--boot=!                (set "parsErlang=!parsErlang! -boot "%~1"" && shift && goto startloop)
+if ""==!par:--boot-var=!            (set "parsErlang=!parsErlang! -boot_var "%~1" "%~2"" && shift && shift && goto startloop)
+if ""==!par:--cookie=!              (set "parsErlang=!parsErlang! -setcookie "%~1"" && shift && goto startloop)
+if ""==!par:--hidden=!              (set "parsErlang=!parsErlang! -hidden" && goto startloop)
+if ""==!par:--erl-config=!          (set "parsErlang=!parsErlang! -config "%~1"" && shift && goto startloop)
+if ""==!par:--logger-otp-reports=!  (set "parsErlang=!parsErlang! -logger handle_otp_reports %1" && shift && goto startloop)
+if ""==!par:--logger-sasl-reports=! (set "parsErlang=!parsErlang! -logger handle_sasl_reports %1" && shift && goto startloop)
+if ""==!par:--name=!                (set "parsErlang=!parsErlang! -name "%~1"" && shift && goto startloop)
+if ""==!par:--sname=!               (set "parsErlang=!parsErlang! -sname "%~1"" && shift && goto startloop)
+if ""==!par:--vm-args=!             (set "parsErlang=!parsErlang! -args_file "%~1"" && shift && goto startloop)
+if ""==!par:--erl=!                 (set "beforeExtra=!beforeExtra! %~1" && shift && goto startloop)
+if ""==!par:--pipe-to=!             (echo --pipe-to : Option is not supported on Windows && goto end)
 
-rem ******* assume all pre-params are parsed ********************
-:expand_erl_libs
-rem ******* expand all ebin paths as Windows does not support the ..\*\ebin wildcard ********************
-SETLOCAL enabledelayedexpansion
-set ext_libs=
-for  /d %%d in ("%originPath%..\lib\*.") do (
-  set ext_libs=!ext_libs! -pa "%%~fd\ebin"
-)
-SETLOCAL disabledelayedexpansion
 :run
-IF %useWerl% EQU 1 (
-    werl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% -s elixir start_cli %beforeExtra% -extra %*
-) ELSE (
-    erl.exe %ext_libs% -noshell %ELIXIR_ERL_OPTIONS% %parsErlang% -s elixir start_cli %beforeExtra% -extra %*
+setlocal disabledelayedexpansion
+if not defined useIEx (
+  set beforeExtra=-s elixir start_cli %beforeExtra%
+)
+
+set beforeExtra=-noshell -elixir_root "%SCRIPT_PATH%..\lib" -pa "%SCRIPT_PATH%..\lib\elixir\ebin" %beforeExtra%
+
+if defined ELIXIR_CLI_DRY_RUN (
+  echo "%ERTS_BIN%erl.exe" %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
+) else (
+  "%ERTS_BIN%erl.exe" %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
 )
+exit /B %ERRORLEVEL%
+:end
+endlocal
diff --git a/bin/elixirc b/bin/elixirc
index 109eca106cc..5c07d5d76ee 100755
--- a/bin/elixirc
+++ b/bin/elixirc
@@ -1,17 +1,30 @@
 #!/bin/sh
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+set -e
+
 if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
-  echo "Usage: `basename $0` [elixir switches] [compiler switches] [.ex files]
-
-  -o               The directory to output compiled files
-  --no-docs        Do not attach documentation to compiled modules
-  --no-debug-info  Do not attach debug info to compiled modules
-  --ignore-module-conflict
-  --warnings-as-errors Treat warnings as errors and return non-zero exit code
-  --verbose        Print informational messages.
-
-** Options given after -- are passed down to the executed code
-** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS
-** Options can be passed to the erlang compiler using ERL_COMPILER_OPTIONS" >&2
+  cat <<USAGE >&2
+Usage: $(basename "$0") [elixir switches] [compiler switches] [.ex files]
+
+  -h, --help                Prints this message and exits
+  -o                        The directory to output compiled files
+  -v, --version             Prints Elixir version and exits (standalone)
+
+  --ignore-module-conflict  Does not emit warnings if a module was previously defined
+  --no-debug-info           Does not attach debug info to compiled modules
+  --no-docs                 Does not attach documentation to compiled modules
+  --profile time            Profile the time to compile modules
+  --verbose                 Prints compilation status
+  --warnings-as-errors      Treats warnings as errors and return non-zero exit status
+
+Options given after -- are passed down to the executed code.
+Options can be passed to the Erlang runtime using \$ELIXIR_ERL_OPTIONS.
+Options can be passed to the Erlang compiler using \$ERL_COMPILER_OPTIONS.
+USAGE
   exit 1
 fi
 
@@ -21,7 +34,7 @@ readlink_f () {
   if [ -h "$filename" ]; then
     readlink_f "$(readlink "$filename")"
   else
-    echo "`pwd -P`/$filename"
+    echo "$(pwd -P)/$filename"
   fi
 }
 
diff --git a/bin/elixirc.bat b/bin/elixirc.bat
index 9d118975d25..d1b0599f818 100644
--- a/bin/elixirc.bat
+++ b/bin/elixirc.bat
@@ -1,10 +1,17 @@
 @echo off
+
+:: SPDX-License-Identifier: Apache-2.0
+:: SPDX-FileCopyrightText: 2021 The Elixir Team
+:: SPDX-FileCopyrightText: 2012 Plataformatec
+
+setlocal
 set argc=0
 for %%A in (%*) do (
-    if "%%A"=="--help" goto documentation
-    if "%%A"=="-h"     goto documentation
-    if "%%A"=="/h"     goto documentation
-    set /A argc+=1
+  if /I "%%A"=="--help" goto documentation
+  if /I "%%A"=="-h"     goto documentation
+  if /I "%%A"=="/h"     goto documentation
+  if    "%%A"=="/?"     goto documentation
+  set /A argc+=1
 )
 if %argc%==0 goto documentation
 goto run
@@ -12,15 +19,24 @@ goto run
 :documentation
 echo Usage: %~nx0 [elixir switches] [compiler switches] [.ex files]
 echo.
-echo  -o               The directory to output compiled files
-echo  --no-docs        Do not attach documentation to compiled modules
-echo  --no-debug-info  Do not attach debug info to compiled modules
-echo  --ignore-module-conflict
-echo  --warnings-as-errors Treat warnings as errors and return non-zero exit code
-echo  --verbose        Print informational messages.
+echo   -h, --help                Prints this message and exits
+echo   -o                        The directory to output compiled files
+echo   -v, --version             Prints Elixir version and exits (standalone)
+echo.
+echo   --ignore-module-conflict  Does not emit warnings if a module was previously defined
+echo   --no-debug-info           Does not attach debug info to compiled modules
+echo   --no-docs                 Does not attach documentation to compiled modules
+echo   --profile time            Profile the time to compile modules
+echo   --verbose                 Prints compilation status
+echo   --warnings-as-errors      Treats warnings as errors and returns non-zero exit status
 echo.
 echo ** Options given after -- are passed down to the executed code
-echo ** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS
-echo ** Options can be passed to the erlang compiler using ERL_COMPILER_OPTIONS >&2
+echo ** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS
+echo ** Options can be passed to the Erlang compiler using ERL_COMPILER_OPTIONS
+goto end
+
 :run
 call "%~dp0\elixir.bat" +elixirc %*
+
+:end
+endlocal
diff --git a/bin/iex b/bin/iex
index e5187f2b08d..ba433a3ce0b 100755
--- a/bin/iex
+++ b/bin/iex
@@ -1,28 +1,25 @@
 #!/bin/sh
-if [ $# -gt 0 ] && ([ "$1" = "--help" ] || [ "$1" = "-h" ]); then
-  echo "Usage: `basename $0` [options] [.exs file] [data]
-
-  -v                Prints version
-  -e \"command\"      Evaluates the given command (*)
-  -r \"file\"         Requires the given files/patterns (*)
-  -S \"script\"       Finds and executes the given script
-  -pr \"file\"        Requires the given files/patterns in parallel (*)
-  -pa \"path\"        Prepends the given path to Erlang code path (*)
-  -pz \"path\"        Appends the given path to Erlang code path (*)
-  --app \"app\"       Start the given app and its dependencies (*)
-  --erl \"switches\"  Switches to be passed down to erlang (*)
-  --name \"name\"     Makes and assigns a name to the distributed node
-  --sname \"name\"    Makes and assigns a short name to the distributed node
-  --cookie \"cookie\" Sets a cookie for this distributed node
-  --hidden          Makes a hidden node
-  --detached        Starts the Erlang VM detached from console
-  --remsh \"name\"    Connects to a node using a remote shell
-  --dot-iex \"path\"  Overrides default .iex.exs file and uses path instead;
-                    path can be empty, then no file will be loaded
-
-** Options marked with (*) can be given more than once
-** Options given after the .exs file or -- are passed down to the executed code
-** Options can be passed to the VM using ELIXIR_ERL_OPTIONS or --erl" >&2
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+set -e
+
+if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
+  cat <<USAGE >&2
+Usage: $(basename "$0") [options] [.exs file] [data]
+
+The following options are exclusive to IEx:
+
+  --dbg pry           Sets the backend for Kernel.dbg/2 to IEx.pry/0
+  --dot-iex "FILE"    Evaluates FILE, line by line, to set up IEx' environment.
+                      Defaults to evaluating .iex.exs or ~/.iex.exs, if any exists.
+                      If FILE is empty, then no file will be loaded.
+  --remsh NAME        Connects to a node using a remote shell.
+
+It accepts all other options listed by "elixir --help".
+USAGE
   exit 1
 fi
 
@@ -32,10 +29,10 @@ readlink_f () {
   if [ -h "$filename" ]; then
     readlink_f "$(readlink "$filename")"
   else
-    echo "`pwd -P`/$filename"
+    echo "$(pwd -P)/$filename"
   fi
 }
 
 SELF=$(readlink_f "$0")
 SCRIPT_PATH=$(dirname "$SELF")
-exec "$SCRIPT_PATH"/elixir --no-halt --erl "-user Elixir.IEx.CLI" +iex "$@"
+exec "$SCRIPT_PATH"/elixir --no-halt --erl "-user elixir" +iex "$@"
diff --git a/bin/iex.bat b/bin/iex.bat
index 717714c3605..5739f66081b 100644
--- a/bin/iex.bat
+++ b/bin/iex.bat
@@ -1,2 +1,31 @@
 @echo off
-call "%~dp0\elixir.bat" +iex --erl "-user Elixir.IEx.CLI" --no-halt %*
+
+:: SPDX-License-Identifier: Apache-2.0
+:: SPDX-FileCopyrightText: 2021 The Elixir Team
+:: SPDX-FileCopyrightText: 2012 Plataformatec
+
+setlocal
+if /I ""%1""==""--help"" goto documentation
+if /I ""%1""==""-h""     goto documentation
+if /I ""%1""==""/h""     goto documentation
+if    ""%1""==""/?""     goto documentation
+goto run
+
+:documentation
+echo Usage: %~nx0 [options] [.exs file] [data]
+echo.
+echo The following options are exclusive to IEx:
+echo.
+echo   --dbg pry           Sets the backend for Kernel.dbg/2 to IEx.pry/0
+echo   --dot-iex "FILE"    Evaluates FILE, line by line, to set up IEx' environment.
+echo                       Defaults to evaluating .iex.exs or ~/.iex.exs, if any exists.
+echo                       If FILE is empty, then no file will be loaded.
+echo   --remsh NAME        Connects to a node using a remote shell
+echo.
+echo It accepts all other options listed by "elixir --help".
+goto end
+
+:run
+call "%~dp0\elixir.bat" --no-halt --erl "-user elixir" +iex %*
+:end
+endlocal
diff --git a/bin/mix b/bin/mix
index 9dab2afd5ce..ef962748ae0 100755
--- a/bin/mix
+++ b/bin/mix
@@ -1,3 +1,7 @@
 #!/usr/bin/env elixir
-Mix.start
-Mix.CLI.main
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Mix.CLI.main()
diff --git a/bin/mix.bat b/bin/mix.bat
index 435a5257340..b0fde891d57 100644
--- a/bin/mix.bat
+++ b/bin/mix.bat
@@ -1,2 +1,7 @@
 @echo off
+
+:: SPDX-License-Identifier: Apache-2.0
+:: SPDX-FileCopyrightText: 2021 The Elixir Team
+:: SPDX-FileCopyrightText: 2012 Plataformatec
+
 call "%~dp0\elixir.bat" "%~dp0\mix" %*
diff --git a/bin/mix.ps1 b/bin/mix.ps1
old mode 100644
new mode 100755
index 9a4a36005cf..1bee46dc8d7
--- a/bin/mix.ps1
+++ b/bin/mix.ps1
@@ -1,27 +1,27 @@
-# Initialize with path to mix.bat relative to caller's working directory
-$toCmd = '' + (Resolve-Path -relative (Split-Path $MyInvocation.MyCommand.Path)) + '\mix.bat'
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-foreach ($arg in $args)
+# Store path to mix.bat as a FileInfo object
+$mixBatPath = (Get-ChildItem (((Get-ChildItem $MyInvocation.MyCommand.Path).Directory.FullName) + '\mix.bat'))
+$newArgs = @()
+
+for ($i = 0; $i -lt $args.length; $i++)
 {
-  $toCmd += ' '
-  
-  if ($arg -is [array])
+  if ($args[$i] -is [array])
   {
     # Commas created the array so we need to reintroduce those commas
-    for ($i = 0; $i -lt $arg.length; $i++)
+    for ($j = 0; $j -lt $args[$i].length - 1; $j++)
     {
-      $toCmd += $arg[$i]
-      if ($i -ne ($arg.length - 1))
-      {
-        $toCmd += ', '
-      }
+      $newArgs += ($args[$i][$j] + ',')
     }
+    $newArgs += $args[$i][-1]
   }
   else
   {
-    $toCmd += $arg
+    $newArgs += $args[$i]
   }
 }
 
 # Corrected arguments are ready to pass to batch file
-cmd /c $toCmd
\ No newline at end of file
+& $mixBatPath $newArgs
\ No newline at end of file
diff --git a/lib/eex/lib/eex.ex b/lib/eex/lib/eex.ex
index fd0095db04b..d7591873211 100644
--- a/lib/eex/lib/eex.ex
+++ b/lib/eex/lib/eex.ex
@@ -1,120 +1,167 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule EEx.SyntaxError do
-  defexception [:message]
+  defexception [:file, :line, :column, :snippet, message: "syntax error"]
+
+  @impl true
+  def message(exception) do
+    %{file: file, line: line, column: column, message: message, snippet: snippet} = exception
+
+    Exception.format_file_line_column(file && Path.relative_to_cwd(file), line, column, " ") <>
+      message <> (snippet || "")
+  end
 end
 
 defmodule EEx do
   @moduledoc ~S"""
-  EEx stands for Embedded Elixir. It allows you to embed
-  Elixir code inside a string in a robust way:
+  EEx stands for Embedded Elixir.
 
-      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
-      "foo baz"
+  Embedded Elixir allows you to embed Elixir code inside a string
+  in a robust way.
 
-  ## API
+      iex> EEx.eval_string("foo <%= bar %>", bar: "baz")
+      "foo baz"
 
-  This module provides 3 main APIs for you to use:
+  This module provides three main APIs for you to use:
 
-    1. Evaluate a string (`eval_string`) or a file (`eval_file`)
+    1. Evaluate a string (`eval_string/3`) or a file (`eval_file/3`)
        directly. This is the simplest API to use but also the
-       slowest, since the code is evaluated and not compiled before.
+       slowest, since the code is evaluated at runtime and not precompiled.
 
-    2. Define a function from a string (`function_from_string`)
-       or a file (`function_from_file`). This allows you to embed
+    2. Define a function from a string (`function_from_string/5`)
+       or a file (`function_from_file/5`). This allows you to embed
        the template as a function inside a module which will then
        be compiled. This is the preferred API if you have access
        to the template at compilation time.
 
-    3. Compile a string (`compile_string`) or a file (`compile_file`)
+    3. Compile a string (`compile_string/2`) or a file (`compile_file/2`)
        into Elixir syntax tree. This is the API used by both functions
        above and is available to you if you want to provide your own
        ways of handling the compiled template.
 
+  The APIs above support several options, documented below. You may
+  also pass an engine which customizes how the EEx code is compiled.
+
   ## Options
 
-  All functions in this module accepts EEx-related options.
-  They are:
+  All functions in this module, unless otherwise noted, accept EEx-related
+  options. They are:
 
-    * `:line`   - the line to be used as the template start. Defaults to 1.
-    * `:file`   - the file to be used in the template. Defaults to the given
-                  file the template is read from or to "nofile" when compiling
-                  from a string.
-    * `:engine` - the EEx engine to be used for compilation.
+    * `:file` - the file to be used in the template. Defaults to the given
+      file the template is read from or to `"nofile"` when compiling from a string.
 
-  ## Engine
+    * `:line` - the line to be used as the template start. Defaults to `1`.
 
-  EEx has the concept of engines which allows you to modify or
-  transform the code extracted from the given string or file.
+    * `:indentation` - (since v1.11.0) an integer added to the column after every
+      new line. Defaults to `0`.
 
-  By default, `EEx` uses the `EEx.SmartEngine` that provides some
-  conveniences on top of the simple `EEx.Engine`.
+    * `:engine` - the EEx engine to be used for compilation. Defaults to `EEx.SmartEngine`.
+
+    * `:trim` - if `true`, trims whitespace left and right of quotation as
+      long as at least one newline is present. All subsequent newlines and
+      spaces are removed but one newline is retained. Defaults to `false`.
+
+    * `:parser_options` - (since: 1.13.0) allow customizing the parsed code
+      that is generated. See `Code.string_to_quoted/2` for available options.
+      Note that the options `:file`, `:line` and `:column` are ignored if
+      passed in. Defaults to `Code.get_compiler_option(:parser_options)`
+      (which defaults to `[]` if not set).
+
+  ## Tags
+
+  EEx supports multiple tags, declared below:
 
-  ### Tags
+      <% Elixir expression: executes code but discards output %>
+      <%= Elixir expression: executes code and prints result %>
+      <%% EEx quotation: returns the contents inside the tag as is %>
+      <%!-- Comments: they are discarded from source --%>
 
-  `EEx.SmartEngine` supports the following tags:
+  EEx supports additional tags, that may be used by some engines,
+  but they do not have a meaning by default:
 
-      <% Elixir expression - inline with output %>
-      <%= Elixir expression - replace with result %>
-      <%% EEx quotation - returns the contents inside %>
-      <%# Comments - they are discarded from source %>
+      <%| ... %>
+      <%/ ... %>
 
-  All expressions that output something to the template
-  **must** use the equals sign (`=`). Since everything in
-  Elixir is a macro, there are no exceptions for this rule.
-  For example, while some template languages would special-
-  case `if` clauses, they are treated the same in EEx and
-  also require `=` in order to have their result printed:
+  ## Engine
 
-      <%= if true do %>
-        It is obviously true
-      <% else %>
-        This will never appear
-      <% end %>
+  EEx has the concept of engines which allows you to modify or
+  transform the code extracted from the given string or file.
 
-  Notice that different engines may have different rules
-  for each tag. Other tags may be added in future versions.
+  By default, `EEx` uses the `EEx.SmartEngine` that provides some
+  conveniences on top of the simple `EEx.Engine`.
 
-  ### Macros
+  ### `EEx.SmartEngine`
 
-  `EEx.SmartEngine` also adds some macros to your template.
-  An example is the `@` macro which allows easy data access
-  in a template:
+  The smart engine uses EEx default rules and adds the `@` construct
+  for reading template assigns:
 
-      iex> EEx.eval_string "<%= @foo %>", assigns: [foo: 1]
+      iex> EEx.eval_string("<%= @foo %>", assigns: [foo: 1])
       "1"
 
-  In other words, `<%= @foo %>` is simply translated to:
+  In other words, `<%= @foo %>` translates to:
 
-      <%= Dict.get assigns, :foo %>
+      <%= {:ok, v} = Access.fetch(assigns, :foo); v %>
 
-  The assigns extension is useful when the number of variables
+  The `assigns` extension is useful when the number of variables
   required by the template is not specified at compilation time.
   """
 
+  @type line :: non_neg_integer
+  @type column :: non_neg_integer
+  @type marker :: [?=] | [?/] | [?|] | []
+  @type metadata :: %{column: column, line: line}
+  @type token ::
+          {:comment, charlist, metadata}
+          | {:text, charlist, metadata}
+          | {:expr | :start_expr | :middle_expr | :end_expr, marker, charlist, metadata}
+          | {:eof, metadata}
+
+  @type tokenize_opt ::
+          {:file, binary()}
+          | {:line, line}
+          | {:column, column}
+          | {:indentation, non_neg_integer}
+          | {:trim, boolean()}
+
+  @type compile_opt ::
+          tokenize_opt
+          | {:engine, module()}
+          | {:parser_options, Code.parser_opts()}
+          | {atom(), term()}
+
   @doc """
-  Generates a function definition from the string.
+  Generates a function definition from the given string.
 
-  The kind (`:def` or `:defp`) must be given, the
-  function name, its arguments and the compilation options.
+  The first argument is the kind of the generated function (`:def` or `:defp`).
+  The `name` argument is the name that the generated function will have.
+  `template` is the string containing the EEx template. `args` is a list of arguments
+  that the generated function will accept. They will be available inside the EEx
+  template.
+
+  The supported `options` are described [in the module docs](#module-options).
+  Additional options are passed to the underlying engine.
 
   ## Examples
 
       iex> defmodule Sample do
       ...>   require EEx
-      ...>   EEx.function_from_string :def, :sample, "<%= a + b %>", [:a, :b]
+      ...>   EEx.function_from_string(:def, :sample, "<%= a + b %>", [:a, :b])
       ...> end
       iex> Sample.sample(1, 2)
       "3"
 
   """
-  defmacro function_from_string(kind, name, source, args \\ [], options \\ []) do
-    quote bind_quoted: binding do
-      info = Keyword.merge [file: __ENV__.file, line: __ENV__.line], options
-      args = Enum.map args, fn arg -> {arg, [line: info[:line]], nil} end
-      compiled = EEx.compile_string(source, info)
+  defmacro function_from_string(kind, name, template, args \\ [], options \\ []) do
+    quote bind_quoted: binding() do
+      info = Keyword.merge([file: __ENV__.file, line: __ENV__.line], options)
+      args = Enum.map(args, fn arg -> {arg, [line: info[:line]], nil} end)
+      compiled = EEx.compile_string(template, info)
 
       case kind do
-        :def  -> def(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
-        :defp -> defp(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
+        :def -> def unquote(name)(unquote_splicing(args)), do: unquote(compiled)
+        :defp -> defp unquote(name)(unquote_splicing(args)), do: unquote(compiled)
       end
     end
   end
@@ -122,12 +169,17 @@ defmodule EEx do
   @doc """
   Generates a function definition from the file contents.
 
-  The kind (`:def` or `:defp`) must be given, the
-  function name, its arguments and the compilation options.
+  The first argument is the kind of the generated function (`:def` or `:defp`).
+  The `name` argument is the name that the generated function will have.
+  `file` is the path to the EEx template file. `args` is a list of arguments
+  that the generated function will accept. They will be available inside the EEx
+  template.
 
   This function is useful in case you have templates but
   you want to precompile inside a module for speed.
 
+  The supported `options` are described [in the module docs](#module-options).
+
   ## Examples
 
       # sample.eex
@@ -136,80 +188,183 @@ defmodule EEx do
       # sample.ex
       defmodule Sample do
         require EEx
-        EEx.function_from_file :def, :sample, "sample.eex", [:a, :b]
+        EEx.function_from_file(:def, :sample, "sample.eex", [:a, :b])
       end
 
       # iex
-      Sample.sample(1, 2) #=> "3"
+      Sample.sample(1, 2)
+      #=> "3"
 
   """
   defmacro function_from_file(kind, name, file, args \\ [], options \\ []) do
-    quote bind_quoted: binding do
-      info = Keyword.merge options, [file: file, line: 1]
-      args = Enum.map args, fn arg -> {arg, [line: 1], nil} end
+    quote bind_quoted: binding() do
+      info = Keyword.merge([file: IO.chardata_to_string(file), line: 1], options)
+      args = Enum.map(args, fn arg -> {arg, [line: 1], nil} end)
       compiled = EEx.compile_file(file, info)
 
       @external_resource file
       @file file
       case kind do
-        :def  -> def(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
-        :defp -> defp(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
+        :def -> def unquote(name)(unquote_splicing(args)), do: unquote(compiled)
+        :defp -> defp unquote(name)(unquote_splicing(args)), do: unquote(compiled)
       end
     end
   end
 
   @doc """
-  Get a string `source` and generate a quoted expression
+  Gets a string `source` and generates a quoted expression
   that can be evaluated by Elixir or compiled to a function.
+
+  This is useful if you want to compile a EEx template into code and inject
+  that code somewhere or evaluate it at runtime.
+
+  The generated quoted code will use variables defined in the template that
+  will be taken from the context where the code is evaluated. If you
+  have a template such as `<%= a + b %>`, then the returned quoted code
+  will use the `a` and `b` variables in the context where it's evaluated. See
+  examples below.
+
+  The supported `options` are described [in the module docs](#module-options).
+
+  ## Examples
+
+      iex> quoted = EEx.compile_string("<%= a + b %>")
+      iex> {result, _bindings} = Code.eval_quoted(quoted, a: 1, b: 2)
+      iex> result
+      "3"
+
   """
-  def compile_string(source, options \\ []) do
-    EEx.Compiler.compile(source, options)
+  @spec compile_string(String.t(), [compile_opt]) :: Macro.t()
+  def compile_string(source, options \\ []) when is_binary(source) and is_list(options) do
+    tokenize_opts = Keyword.take(options, [:file, :line, :column, :indentation, :trim])
+
+    case tokenize(source, tokenize_opts) do
+      {:ok, tokens} ->
+        EEx.Compiler.compile(tokens, source, options)
+
+      {:error, message, %{column: column, line: line}} ->
+        file = options[:file] || "nofile"
+        raise EEx.SyntaxError, file: file, line: line, column: column, message: message
+    end
   end
 
   @doc """
-  Get a `filename` and generate a quoted expression
+  Gets a `filename` and generates a quoted expression
   that can be evaluated by Elixir or compiled to a function.
+
+  This is useful if you want to compile a EEx template into code and inject
+  that code somewhere or evaluate it at runtime.
+
+  The generated quoted code will use variables defined in the template that
+  will be taken from the context where the code is evaluated. If you
+  have a template such as `<%= a + b %>`, then the returned quoted code
+  will use the `a` and `b` variables in the context where it's evaluated. See
+  examples below.
+
+  The supported `options` are described [in the module docs](#module-options).
+
+  ## Examples
+
+      # sample.eex
+      <%= a + b %>
+
+      # In code:
+      quoted = EEx.compile_file("sample.eex")
+      {result, _bindings} = Code.eval_quoted(quoted, a: 1, b: 2)
+      result
+      #=> "3"
+
   """
-  def compile_file(filename, options \\ []) do
-    options = Keyword.merge options, [file: filename, line: 1]
+  @spec compile_file(Path.t(), [compile_opt]) :: Macro.t()
+  def compile_file(filename, options \\ []) when is_list(options) do
+    filename = IO.chardata_to_string(filename)
+    options = Keyword.merge([file: filename, line: 1], options)
     compile_string(File.read!(filename), options)
   end
 
   @doc """
-  Get a string `source` and evaluate the values using the `bindings`.
+  Gets a string `source` and evaluate the values using the `bindings`.
+
+  The supported `options` are described [in the module docs](#module-options).
 
   ## Examples
 
-      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
+      iex> EEx.eval_string("foo <%= bar %>", bar: "baz")
       "foo baz"
 
   """
-  def eval_string(source, bindings \\ [], options \\ []) do
+  @spec eval_string(String.t(), keyword, [compile_opt]) :: term()
+  def eval_string(source, bindings \\ [], options \\ [])
+      when is_binary(source) and is_list(bindings) and is_list(options) do
     compiled = compile_string(source, options)
     do_eval(compiled, bindings, options)
   end
 
   @doc """
-  Get a `filename` and evaluate the values using the `bindings`.
+  Gets a `filename` and evaluate the values using the `bindings`.
+
+  The supported `options` are described [in the module docs](#module-options).
 
   ## Examples
 
-      # sample.ex
+      # sample.eex
       foo <%= bar %>
 
-      # iex
-      EEx.eval_file "sample.ex", [bar: "baz"] #=> "foo baz"
+      # IEx
+      EEx.eval_file("sample.eex", bar: "baz")
+      #=> "foo baz"
 
   """
-  def eval_file(filename, bindings \\ [], options \\ []) do
-    options  = Keyword.put options, :file, filename
+  @spec eval_file(Path.t(), keyword, [compile_opt]) :: String.t()
+  def eval_file(filename, bindings \\ [], options \\ [])
+      when is_list(bindings) and is_list(options) do
+    filename = IO.chardata_to_string(filename)
+    options = Keyword.put_new(options, :file, filename)
     compiled = compile_file(filename, options)
     do_eval(compiled, bindings, options)
   end
 
+  @doc """
+  Tokenize the given contents according to the given options.
+
+  ## Options
+
+    * `:line` - An integer to start as line. Default is 1.
+    * `:column` - An integer to start as column. Default is 1.
+    * `:indentation` - An integer that indicates the indentation. Default is 0.
+    * `:trim` - Tells the tokenizer to either trim the content or not. Default is false.
+    * `:file` - Can be either a file or a string "nofile".
+
+  ## Examples
+
+      iex> EEx.tokenize(~c"foo", line: 1, column: 1)
+      {:ok, [{:text, ~c"foo", %{column: 1, line: 1}}, {:eof, %{column: 4, line: 1}}]}
+
+  ## Result
+
+  It returns `{:ok, [token]}` where a token is one of:
+
+    * `{:text, content, %{column: column, line: line}}`
+    * `{:expr, marker, content, %{column: column, line: line}}`
+    * `{:start_expr, marker, content, %{column: column, line: line}}`
+    * `{:middle_expr, marker, content, %{column: column, line: line}}`
+    * `{:end_expr, marker, content, %{column: column, line: line}}`
+    * `{:eof, %{column: column, line: line}}`
+
+  Or `{:error, message, %{column: column, line: line}}` in case of errors.
+  Note new tokens may be added in the future.
+  """
+  @doc since: "1.14.0"
+  @spec tokenize([char()] | String.t(), [tokenize_opt]) ::
+          {:ok, [token()]} | {:error, String.t(), metadata()}
+  def tokenize(contents, opts \\ []) do
+    EEx.Compiler.tokenize(contents, opts)
+  end
+
   ### Helpers
 
   defp do_eval(compiled, bindings, options) do
+    options = Keyword.take(options, [:file, :line, :module, :prune_binding])
     {result, _} = Code.eval_quoted(compiled, bindings, options)
     result
   end
diff --git a/lib/eex/lib/eex/compiler.ex b/lib/eex/lib/eex/compiler.ex
index c34ef566c60..56d0a413971 100644
--- a/lib/eex/lib/eex/compiler.ex
+++ b/lib/eex/lib/eex/compiler.ex
@@ -1,100 +1,485 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule EEx.Compiler do
   @moduledoc false
 
   # When changing this setting, don't forget to update the docs for EEx
   @default_engine EEx.SmartEngine
+  @h_spaces [?\s, ?\t]
+  @all_spaces [?\s, ?\t, ?\n, ?\r]
+
+  @doc """
+  Tokenize EEx contents.
+  """
+  def tokenize(contents, opts) when is_binary(contents) do
+    tokenize(String.to_charlist(contents), contents, opts)
+  end
+
+  def tokenize(contents, opts) when is_list(contents) do
+    tokenize(contents, List.to_string(contents), opts)
+  end
+
+  def tokenize(contents, source, opts) when is_list(contents) do
+    file = opts[:file] || "nofile"
+    line = opts[:line] || 1
+    trim = opts[:trim] || false
+    indentation = opts[:indentation] || 0
+    column = indentation + (opts[:column] || 1)
+
+    state = %{trim: trim, indentation: indentation, file: file, source: source}
+
+    {contents, line, column} =
+      (trim && trim_init(contents, line, column, state)) || {contents, line, column}
+
+    tokenize(contents, line, column, state, [{line, column}], [])
+  end
+
+  defp tokenize(~c"<%%" ++ t, line, column, state, buffer, acc) do
+    tokenize(t, line, column + 3, state, [?%, ?< | buffer], acc)
+  end
+
+  defp tokenize(~c"<%!--" ++ t, line, column, state, buffer, acc) do
+    case comment(t, line, column + 5, state, []) do
+      {:error, message} ->
+        meta = %{line: line, column: column}
+        {:error, message <> code_snippet(state.source, state.indentation, meta), meta}
+
+      {:ok, new_line, new_column, rest, comments} ->
+        token = {:comment, Enum.reverse(comments), %{line: line, column: column}}
+        trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, &[token | &1])
+    end
+  end
+
+  # TODO: Remove me on Elixir v2.0
+  defp tokenize(~c"<%#" ++ t, line, column, state, buffer, acc) do
+    IO.warn("<%# is deprecated, use <%!-- or add a space between <% and # instead",
+      line: line,
+      column: column,
+      file: state.file
+    )
+
+    case expr(t, line, column + 3, state, []) do
+      {:error, message} ->
+        {:error, message, %{line: line, column: column}}
+
+      {:ok, _, new_line, new_column, rest} ->
+        trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, & &1)
+    end
+  end
+
+  defp tokenize(~c"<%" ++ t, line, column, state, buffer, acc) do
+    {marker, t} = retrieve_marker(t)
+    marker_length = length(marker)
+
+    case expr(t, line, column + 2 + marker_length, state, []) do
+      {:error, message} ->
+        meta = %{line: line, column: column}
+        {:error, message <> code_snippet(state.source, state.indentation, meta), meta}
+
+      {:ok, expr, new_line, new_column, rest} ->
+        {key, expr} =
+          case :elixir_tokenizer.tokenize(expr, 1, file: "eex", check_terminators: false) do
+            {:ok, _line, _column, _warnings, rev_tokens, []} ->
+              # We ignore warnings because the code will be tokenized
+              # again later with the right line+column info
+              token_key(rev_tokens, expr)
+
+            {:error, _, _, _, _} ->
+              {:expr, expr}
+          end
+
+        marker =
+          if key in [:middle_expr, :end_expr] and marker != ~c"" do
+            message =
+              "unexpected beginning of EEx tag \"<%#{marker}\" on \"<%#{marker}#{expr}%>\", " <>
+                "please remove \"#{marker}\""
+
+            IO.warn(message, file: state.file, line: line, column: column)
+            ~c""
+          else
+            marker
+          end
+
+        token = {key, marker, expr, %{line: line, column: column}}
+        trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, &[token | &1])
+    end
+  end
+
+  defp tokenize([?\n | t], line, _column, state, buffer, acc) do
+    tokenize(t, line + 1, state.indentation + 1, state, [?\n | buffer], acc)
+  end
+
+  defp tokenize([h | t], line, column, state, buffer, acc) do
+    tokenize(t, line, column + 1, state, [h | buffer], acc)
+  end
+
+  defp tokenize([], line, column, _state, buffer, acc) do
+    eof = {:eof, %{line: line, column: column}}
+    {:ok, Enum.reverse([eof | tokenize_text(buffer, acc)])}
+  end
+
+  defp trim_and_tokenize(rest, line, column, state, buffer, acc, fun) do
+    {rest, line, column, buffer} = trim_if_needed(rest, line, column, state, buffer)
+
+    acc = tokenize_text(buffer, acc)
+    tokenize(rest, line, column, state, [{line, column}], fun.(acc))
+  end
+
+  # Retrieve marker for <%
+
+  defp retrieve_marker([marker | t]) when marker in [?=, ?/, ?|] do
+    {[marker], t}
+  end
+
+  defp retrieve_marker(t) do
+    {~c"", t}
+  end
+
+  # Tokenize a multi-line comment until we find --%>
+
+  defp comment([?-, ?-, ?%, ?> | t], line, column, _state, buffer) do
+    {:ok, line, column + 4, t, buffer}
+  end
+
+  defp comment([?\n | t], line, _column, state, buffer) do
+    comment(t, line + 1, state.indentation + 1, state, [?\n | buffer])
+  end
+
+  defp comment([head | t], line, column, state, buffer) do
+    comment(t, line, column + 1, state, [head | buffer])
+  end
+
+  defp comment([], _line, _column, _state, _buffer) do
+    {:error, "expected closing '--%>' for EEx expression"}
+  end
+
+  # Tokenize an expression until we find %>
+
+  defp expr([?%, ?> | t], line, column, _state, buffer) do
+    {:ok, Enum.reverse(buffer), line, column + 2, t}
+  end
+
+  defp expr([?\n | t], line, _column, state, buffer) do
+    expr(t, line + 1, state.indentation + 1, state, [?\n | buffer])
+  end
+
+  defp expr([h | t], line, column, state, buffer) do
+    expr(t, line, column + 1, state, [h | buffer])
+  end
+
+  defp expr([], _line, _column, _state, _buffer) do
+    {:error, "expected closing '%>' for EEx expression"}
+  end
+
+  # Receives tokens and check if it is a start, middle or an end token.
+  defp token_key(rev_tokens, expr) do
+    case {Enum.reverse(rev_tokens), drop_eol(rev_tokens)} do
+      {[{:end, _} | _], [{:do, _} | _]} ->
+        {:middle_expr, expr}
+
+      {_, [{:do, _} | _]} ->
+        {:start_expr, maybe_append_space(expr)}
+
+      {_, [{:block_identifier, _, _} | _]} ->
+        {:middle_expr, maybe_append_space(expr)}
+
+      {[{:end, _} | _], [{:stab_op, _, _} | _]} ->
+        {:middle_expr, expr}
+
+      {_, [{:stab_op, _, _} | reverse_tokens]} ->
+        fn_index = Enum.find_index(reverse_tokens, &match?({:fn, _}, &1)) || :infinity
+        end_index = Enum.find_index(reverse_tokens, &match?({:end, _}, &1)) || :infinity
+
+        if end_index > fn_index do
+          {:start_expr, expr}
+        else
+          {:middle_expr, expr}
+        end
+
+      {tokens, _} ->
+        case Enum.drop_while(tokens, &closing_bracket?/1) do
+          [{:end, _} | _] -> {:end_expr, expr}
+          _ -> {:expr, expr}
+        end
+    end
+  end
+
+  defp drop_eol([{:eol, _} | rest]), do: drop_eol(rest)
+  defp drop_eol(rest), do: rest
+
+  defp maybe_append_space([?\s]), do: [?\s]
+  defp maybe_append_space([h]), do: [h, ?\s]
+  defp maybe_append_space([h | t]), do: [h | maybe_append_space(t)]
+
+  defp closing_bracket?({closing, _}) when closing in ~w"( [ {"a, do: true
+  defp closing_bracket?(_), do: false
+
+  # Tokenize the buffered text by appending
+  # it to the given accumulator.
+
+  defp tokenize_text([{_line, _column}], acc) do
+    acc
+  end
+
+  defp tokenize_text(buffer, acc) do
+    [{line, column} | buffer] = Enum.reverse(buffer)
+    [{:text, buffer, %{line: line, column: column}} | acc]
+  end
+
+  ## Trim
+
+  defp trim_if_needed(rest, line, column, state, buffer) do
+    if state.trim do
+      buffer = trim_left(buffer, 0)
+      {rest, line, column} = trim_right(rest, line, column, 0, state)
+      {rest, line, column, buffer}
+    else
+      {rest, line, column, buffer}
+    end
+  end
+
+  defp trim_init([h | t], line, column, state) when h in @h_spaces,
+    do: trim_init(t, line, column + 1, state)
+
+  defp trim_init([?\r, ?\n | t], line, _column, state),
+    do: trim_init(t, line + 1, state.indentation + 1, state)
+
+  defp trim_init([?\n | t], line, _column, state),
+    do: trim_init(t, line + 1, state.indentation + 1, state)
+
+  defp trim_init([?<, ?% | _] = rest, line, column, _state),
+    do: {rest, line, column}
+
+  defp trim_init(_, _, _, _), do: false
+
+  defp trim_left(buffer, count) do
+    case trim_whitespace(buffer, 0) do
+      {[?\n, ?\r | rest], _} -> trim_left(rest, count + 1)
+      {[?\n | rest], _} -> trim_left(rest, count + 1)
+      _ when count > 0 -> [?\n | buffer]
+      _ -> buffer
+    end
+  end
+
+  defp trim_right(rest, line, column, last_column, state) do
+    case trim_whitespace(rest, column) do
+      {[?\r, ?\n | rest], column} ->
+        trim_right(rest, line + 1, state.indentation + 1, column + 1, state)
+
+      {[?\n | rest], column} ->
+        trim_right(rest, line + 1, state.indentation + 1, column, state)
+
+      {[], column} ->
+        {[], line, column}
+
+      _ when last_column > 0 ->
+        {[?\n | rest], line - 1, last_column}
+
+      _ ->
+        {rest, line, column}
+    end
+  end
+
+  defp trim_whitespace([h | t], column) when h in @h_spaces, do: trim_whitespace(t, column + 1)
+  defp trim_whitespace(list, column), do: {list, column}
 
   @doc """
   This is the compilation entry point. It glues the tokenizer
   and the engine together by handling the tokens and invoking
   the engine every time a full expression or text is received.
   """
-  def compile(source, opts) do
-    file   = opts[:file] || "nofile"
-    line   = opts[:line] || 1
-    tokens = EEx.Tokenizer.tokenize(source, line)
-    state  = %{engine: opts[:engine] || @default_engine,
-               file: file, line: line, quoted: [], start_line: nil}
-    generate_buffer(tokens, "", [], state)
+  @spec compile([EEx.token()], String.t(), keyword) :: Macro.t()
+  def compile(tokens, source, opts) do
+    file = opts[:file] || "nofile"
+    line = opts[:line] || 1
+    indentation = opts[:indentation] || 0
+    parser_options = opts[:parser_options] || Code.get_compiler_option(:parser_options)
+    engine = opts[:engine] || @default_engine
+
+    state = %{
+      engine: engine,
+      file: file,
+      source: source,
+      line: line,
+      quoted: [],
+      parser_options: [indentation: indentation] ++ parser_options,
+      indentation: indentation
+    }
+
+    init = state.engine.init(opts)
+
+    if function_exported?(state.engine, :handle_text, 2) and
+         not function_exported?(state.engine, :handle_text, 3) do
+      IO.warn(
+        "#{inspect(state.engine)}.handle_text/2 is deprecated, implement handle_text/3 instead"
+      )
+    end
+
+    generate_buffer(tokens, init, [], state)
   end
 
-  # Generates the buffers by handling each expression from the tokenizer
+  # Ignore tokens related to comment.
+  defp generate_buffer([{:comment, _chars, _meta} | rest], buffer, scope, state) do
+    generate_buffer(rest, buffer, scope, state)
+  end
+
+  # Generates the buffers by handling each expression from the tokenizer.
+  # It returns Macro.t/0 or it raises.
 
-  defp generate_buffer([{:text, chars}|t], buffer, scope, state) do
-    buffer = state.engine.handle_text(buffer, IO.chardata_to_string(chars))
-    generate_buffer(t, buffer, scope, state)
+  defp generate_buffer([{:text, chars, meta} | rest], buffer, scope, state) do
+    buffer =
+      if function_exported?(state.engine, :handle_text, 3) do
+        meta = [line: meta.line, column: meta.column]
+        state.engine.handle_text(buffer, meta, IO.chardata_to_string(chars))
+      else
+        # TODO: Remove this on Elixir v2.0. The deprecation is on init.
+        state.engine.handle_text(buffer, IO.chardata_to_string(chars))
+      end
+
+    generate_buffer(rest, buffer, scope, state)
   end
 
-  defp generate_buffer([{:expr, line, mark, chars}|t], buffer, scope, state) do
-    expr = Code.string_to_quoted!(chars, [line: line, file: state.file])
-    buffer = state.engine.handle_expr(buffer, mark, expr)
-    generate_buffer(t, buffer, scope, state)
+  defp generate_buffer([{:expr, mark, chars, meta} | rest], buffer, scope, state) do
+    options =
+      [file: state.file, line: meta.line, column: column(meta.column, mark)] ++
+        state.parser_options
+
+    expr = Code.string_to_quoted!(chars, options)
+    buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), expr)
+    generate_buffer(rest, buffer, scope, state)
   end
 
-  defp generate_buffer([{:start_expr, start_line, mark, chars}|t], buffer, scope, state) do
-    {contents, line, t} = look_ahead_text(t, start_line, chars)
-    {contents, t} = generate_buffer(t, "", [contents|scope],
-                                    %{state | quoted: [], line: line, start_line: start_line})
-    buffer = state.engine.handle_expr(buffer, mark, contents)
-    generate_buffer(t, buffer, scope, state)
+  defp generate_buffer(
+         [{:start_expr, mark, chars, meta} | rest],
+         buffer,
+         scope,
+         state
+       ) do
+    {rest, line, contents} = look_ahead_middle(rest, meta.line, chars) || {rest, meta.line, chars}
+    start_line = meta.line
+    start_column = column(meta.column, mark)
+
+    {contents, rest} =
+      generate_buffer(
+        rest,
+        state.engine.handle_begin(buffer),
+        [{contents, start_line, start_column} | scope],
+        %{state | quoted: [], line: line}
+      )
+
+    if mark == ~c"" and not match?({:=, _, [_, _]}, contents) do
+      message =
+        "the contents of this expression won't be output unless the EEx block starts with \"<%=\""
+
+      IO.warn(message, file: state.file, line: meta.line, column: meta.column)
+    end
+
+    buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), contents)
+    generate_buffer(rest, buffer, scope, state)
+  end
+
+  defp generate_buffer(
+         [{:middle_expr, ~c"", chars, meta} | rest],
+         buffer,
+         [{current, current_line, current_column} | scope],
+         state
+       ) do
+    {wrapped, state} = wrap_expr(current, meta.line, buffer, chars, state)
+    state = %{state | line: meta.line}
+
+    generate_buffer(
+      rest,
+      state.engine.handle_begin(buffer),
+      [{wrapped, current_line, current_column} | scope],
+      state
+    )
   end
 
-  defp generate_buffer([{:middle_expr, line, _, chars}|t], buffer, [current|scope], state) do
-    {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
-    generate_buffer(t, "", [wrapped|scope], %{state | line: line})
+  defp generate_buffer([{:middle_expr, _, chars, meta} | _tokens], _buffer, [], state) do
+    message = "unexpected middle of expression <%#{chars}%>"
+    syntax_error!(message, meta, state)
   end
 
-  defp generate_buffer([{:end_expr, line, _, chars}|t], buffer, [current|_], state) do
-    {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
-    tuples = Code.string_to_quoted!(wrapped, [line: state.start_line, file: state.file])
+  defp generate_buffer(
+         [{:end_expr, ~c"", chars, meta} | rest],
+         buffer,
+         [{current, line, column} | _],
+         state
+       ) do
+    {wrapped, state} = wrap_expr(current, meta.line, buffer, chars, state)
+    options = [file: state.file, line: line, column: column] ++ state.parser_options
+    tuples = Code.string_to_quoted!(wrapped, options)
     buffer = insert_quoted(tuples, state.quoted)
-    {buffer, t}
+    {buffer, rest}
   end
 
-  defp generate_buffer([{:end_expr, line, _, chars}|_], _buffer, [], _state) do
-    raise EEx.SyntaxError, message: "unexpected token: #{inspect chars} at line #{inspect line}"
+  defp generate_buffer([{:end_expr, _, chars, meta} | _], _buffer, [], state) do
+    message = "unexpected end of expression <%#{chars}%>"
+    syntax_error!(message, meta, state)
   end
 
-  defp generate_buffer([], buffer, [], state) do
+  defp generate_buffer([{:eof, _meta}], buffer, [], state) do
     state.engine.handle_body(buffer)
   end
 
-  defp generate_buffer([], _buffer, _scope, _state) do
-    raise EEx.SyntaxError, message: "unexpected end of string. expecting a closing <% end %>."
+  defp generate_buffer([{:eof, _meta}], _buffer, [{content, line, column} | _scope], state) do
+    message = "expected a closing '<% end %>' for block expression in EEx"
+    expr_meta = non_whitespace_meta(content, line, column, state)
+    syntax_error!(message, expr_meta, state)
   end
 
+  defp non_whitespace_meta([space | rest], line, column, state) when space in @h_spaces,
+    do: non_whitespace_meta(rest, line, column + 1, state)
+
+  defp non_whitespace_meta([?\n | rest], line, _column, state),
+    do: non_whitespace_meta(rest, line + 1, state.indentation + 1, state)
+
+  defp non_whitespace_meta(_, line, column, _),
+    do: %{line: line, column: column}
+
   # Creates a placeholder and wrap it inside the expression block
 
   defp wrap_expr(current, line, buffer, chars, state) do
     new_lines = List.duplicate(?\n, line - state.line)
     key = length(state.quoted)
-    placeholder = '__EEX__(' ++ Integer.to_char_list(key) ++ ');'
-    {current ++ placeholder ++ new_lines ++ chars,
-     %{state | quoted: [{key, buffer}|state.quoted]}}
+    placeholder = ~c"__EEX__(" ++ Integer.to_charlist(key) ++ ~c");"
+    count = current ++ placeholder ++ new_lines ++ chars
+    new_state = %{state | quoted: [{key, state.engine.handle_end(buffer)} | state.quoted]}
+
+    {count, new_state}
   end
 
-  # Look text ahead on expressions
+  # Look middle expressions that immediately follow a start_expr
 
-  defp look_ahead_text([{:text, text}, {:middle_expr, line, _, chars}|t]=list, start, contents) do
+  defp look_ahead_middle([{:comment, _comment, _meta} | rest], start, contents),
+    do: look_ahead_middle(rest, start, contents)
+
+  defp look_ahead_middle([{:text, text, _meta} | rest], start, contents) do
     if only_spaces?(text) do
-      {contents ++ text ++ chars, line, t}
+      look_ahead_middle(rest, start, contents ++ text)
     else
-      {contents, start, list}
+      nil
     end
   end
 
-  defp look_ahead_text(t, start, contents) do
-    {contents, start, t}
+  defp look_ahead_middle([{:middle_expr, _, chars, meta} | rest], _start, contents) do
+    {rest, meta.line, contents ++ chars}
+  end
+
+  defp look_ahead_middle(_tokens, _start, _contents) do
+    nil
   end
 
   defp only_spaces?(chars) do
-    Enum.all?(chars, &(&1 in [?\s, ?\t, ?\r, ?\n]))
+    Enum.all?(chars, &(&1 in @all_spaces))
   end
 
   # Changes placeholder to real expression
 
   defp insert_quoted({:__EEX__, _, [key]}, quoted) do
-    {^key, value} = List.keyfind quoted, key, 0
+    {^key, value} = List.keyfind(quoted, key, 0)
     value
   end
 
@@ -107,10 +492,49 @@ defmodule EEx.Compiler do
   end
 
   defp insert_quoted(list, quoted) when is_list(list) do
-    Enum.map list, &insert_quoted(&1, quoted)
+    Enum.map(list, &insert_quoted(&1, quoted))
   end
 
   defp insert_quoted(other, _quoted) do
     other
   end
+
+  defp column(column, mark) do
+    # length(~c"<%") == 2
+    column + 2 + length(mark)
+  end
+
+  defp syntax_error!(message, meta, state) do
+    raise EEx.SyntaxError,
+      message: message,
+      snippet: code_snippet(state.source, state.indentation, meta),
+      file: state.file,
+      line: meta.line,
+      column: meta.column
+  end
+
+  defp code_snippet(source, indentation, meta) do
+    line_start = max(meta.line - 3, 1)
+    line_end = meta.line
+    digits = line_end |> Integer.to_string() |> byte_size()
+    number_padding = String.duplicate(" ", digits)
+    indentation = String.duplicate(" ", indentation)
+
+    source
+    |> String.split(["\r\n", "\n"])
+    |> Enum.slice((line_start - 1)..(line_end - 1))
+    |> Enum.map_reduce(line_start, fn
+      expr, line_number when line_number == line_end ->
+        arrow = String.duplicate(" ", meta.column - 1) <> "^"
+        {"#{line_number} | #{indentation}#{expr}\n #{number_padding}| #{arrow}", line_number + 1}
+
+      expr, line_number ->
+        line_number_padding = String.pad_leading("#{line_number}", digits)
+        {"#{line_number_padding} | #{indentation}#{expr}", line_number + 1}
+    end)
+    |> case do
+      {[], _} -> ""
+      {snippet, _} -> Enum.join(["\n #{number_padding}|" | snippet], "\n")
+    end
+  end
 end
diff --git a/lib/eex/lib/eex/engine.ex b/lib/eex/lib/eex/engine.ex
index 257f2f46d18..12234f048c8 100644
--- a/lib/eex/lib/eex/engine.ex
+++ b/lib/eex/lib/eex/engine.ex
@@ -1,112 +1,229 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule EEx.Engine do
   @moduledoc ~S"""
   Basic EEx engine that ships with Elixir.
 
-  An engine needs to implement three functions:
+  An engine needs to implement all callbacks below.
+
+  This module also ships with a default engine implementation
+  you can delegate to. See `EEx.SmartEngine` as an example.
+  """
 
-    * `handle_body(quoted)` - receives the final built quoted
-      expression, should do final post-processing and return a
-      quoted expression.
+  @type state :: term
 
-    * `handle_text(buffer, text)` - it receives the buffer,
-      the text and must return a new quoted expression.
+  @doc """
+  Called at the beginning of every template.
 
-    * `handle_expr(buffer, marker, expr)` - it receives the buffer,
-      the marker, the expr and must return a new quoted expression.
+  It receives the options during compilation, including the
+  ones managed by EEx, such as `:line` and `:file`, as well
+  as custom engine options.
 
-      The marker is what follows exactly after `<%`. For example,
-      `<% foo %>` has an empty marker, but `<%= foo %>` has `"="`
-      as marker. The allowed markers so far are: `""` and `"="`.
+  It must return the initial state.
+  """
+  @callback init(opts :: keyword) :: state
 
-      Read `handle_expr/3` below for more information about the markers
-      implemented by default by this engine.
+  @doc """
+  Called at the end of every template.
 
-  `EEx.Engine` can be used directly if one desires to use the
-  default implementations for the functions above.
+  It must return Elixir's quoted expressions for the template.
   """
+  @callback handle_body(state) :: Macro.t()
 
-  use Behaviour
+  @doc """
+  Called for the text/static parts of a template.
 
-  defcallback handle_body(Macro.t) :: Macro.t
-  defcallback handle_text(Macro.t, binary) :: Macro.t
-  defcallback handle_expr(Macro.t, binary, Macro.t) :: Macro.t
+  It must return the updated state.
+  """
+  @callback handle_text(state, [line: pos_integer, column: pos_integer], text :: String.t()) ::
+              state
+
+  @doc """
+  Called for the dynamic/code parts of a template.
+
+  The marker is what follows exactly after `<%`. For example,
+  `<% foo %>` has an empty marker, but `<%= foo %>` has `"="`
+  as marker. The allowed markers so far are:
+
+    * `""`
+    * `"="`
+    * `"/"`
+    * `"|"`
+
+  Markers `"/"` and `"|"` are only for use in custom EEx engines
+  and are not implemented by default. Using them without an
+  appropriate implementation raises `EEx.SyntaxError`.
+
+  It must return the updated state.
+  """
+  @callback handle_expr(state, marker :: String.t(), expr :: Macro.t()) :: state
+
+  @doc """
+  Invoked at the beginning of every nesting.
+
+  It must return a new state that is used only inside the nesting.
+  Once the nesting terminates, the current `state` is resumed.
+  """
+  @callback handle_begin(state) :: state
+
+  @doc """
+  Invokes at the end of a nesting.
+
+  It must return Elixir's quoted expressions for the nesting.
+  """
+  @callback handle_end(state) :: Macro.t()
 
   @doc false
+  @deprecated "Use explicit delegation to EEx.Engine instead"
   defmacro __using__(_) do
     quote do
       @behaviour EEx.Engine
 
-      def handle_body(body) do
-        EEx.Engine.handle_body(body)
+      def init(opts) do
+        EEx.Engine.init(opts)
+      end
+
+      def handle_body(state) do
+        EEx.Engine.handle_body(state)
+      end
+
+      def handle_begin(state) do
+        EEx.Engine.handle_begin(state)
+      end
+
+      def handle_end(state) do
+        EEx.Engine.handle_end(state)
       end
 
-      def handle_text(buffer, text) do
-        EEx.Engine.handle_text(buffer, text)
+      def handle_text(state, text) do
+        EEx.Engine.handle_text(state, [], text)
       end
 
-      def handle_expr(buffer, mark, expr) do
-        EEx.Engine.handle_expr(buffer, mark, expr)
+      def handle_expr(state, marker, expr) do
+        EEx.Engine.handle_expr(state, marker, expr)
       end
 
-      defoverridable [handle_body: 1, handle_expr: 3, handle_text: 2]
+      defoverridable EEx.Engine
     end
   end
 
   @doc """
   Handles assigns in quoted expressions.
 
+  A warning will be printed on missing assigns.
+  Future versions will raise.
+
   This can be added to any custom engine by invoking
-  `handle_assign/3` with `Macro.prewalk/1`:
+  `handle_assign/1` with `Macro.prewalk/2`:
 
-      def handle_expr(buffer, token, expr) do
+      def handle_expr(state, token, expr) do
         expr = Macro.prewalk(expr, &EEx.Engine.handle_assign/1)
-        EEx.Engine.handle_expr(buffer, token, expr)
+        super(state, token, expr)
       end
 
   """
-  def handle_assign({:@, line, [{name, _, atom}]}) when is_atom(name) and is_atom(atom) do
-    quote line: line, do: Dict.get(var!(assigns), unquote(name))
+  @spec handle_assign(Macro.t()) :: Macro.t()
+  def handle_assign({:@, meta, [{name, _, atom}]}) when is_atom(name) and is_atom(atom) do
+    line = meta[:line] || 0
+    quote(line: line, do: EEx.Engine.fetch_assign!(var!(assigns), unquote(name)))
   end
 
   def handle_assign(arg) do
     arg
   end
 
-  @doc """
-  The default implementation implementation simply returns the
-  given expression.
-  """
-  def handle_body(quoted) do
-    quoted
+  @doc false
+  # TODO: Raise on v2.0
+  @spec fetch_assign!(Access.t(), Access.key()) :: term | nil
+  def fetch_assign!(assigns, key) do
+    case Access.fetch(assigns, key) do
+      {:ok, val} ->
+        val
+
+      :error ->
+        keys = Enum.map(assigns, &elem(&1, 0))
+
+        IO.warn(
+          "assign @#{key} not available in EEx template. " <>
+            "Please ensure all assigns are given as options. " <>
+            "Available assigns: #{inspect(keys)}"
+        )
+
+        nil
+    end
   end
 
-  @doc """
-  The default implementation simply concatenates text to the buffer.
-  """
-  def handle_text(buffer, text) do
-    quote do: unquote(buffer) <> unquote(text)
+  @doc "Default implementation for `c:init/1`."
+  def init(_opts) do
+    %{
+      binary: [],
+      dynamic: [],
+      vars_count: 0
+    }
   end
 
-  @doc """
-  Implements expressions according to the markers.
+  @doc "Default implementation for `c:handle_begin/1`."
+  def handle_begin(state) do
+    check_state!(state)
+    %{state | binary: [], dynamic: []}
+  end
 
-      <% Elixir expression - inline with output %>
-      <%= Elixir expression - replace with result %>
+  @doc "Default implementation for `c:handle_end/1`."
+  def handle_end(quoted) do
+    handle_body(quoted)
+  end
 
-  All other markers are not implemented by this engine.
-  """
-  def handle_expr(buffer, "=", expr) do
-    quote do
-      tmp = unquote(buffer)
-      tmp <> to_string(unquote(expr))
-    end
+  @doc "Default implementation for `c:handle_body/1`."
+  def handle_body(state) do
+    check_state!(state)
+    %{binary: binary, dynamic: dynamic} = state
+    binary = {:<<>>, [], Enum.reverse(binary)}
+    dynamic = [binary | dynamic]
+    {:__block__, [], Enum.reverse(dynamic)}
   end
 
-  def handle_expr(buffer, "", expr) do
-    quote do
-      tmp = unquote(buffer)
-      unquote(expr)
-      tmp
-    end
+  @doc "Default implementation for `c:handle_text/3`."
+  def handle_text(state, _meta, text) do
+    check_state!(state)
+    %{binary: binary} = state
+    %{state | binary: [text | binary]}
+  end
+
+  @doc "Default implementation for `c:handle_expr/3`."
+  def handle_expr(state, "=", ast) do
+    check_state!(state)
+    %{binary: binary, dynamic: dynamic, vars_count: vars_count} = state
+    var = Macro.var(:"arg#{vars_count}", __MODULE__)
+
+    ast =
+      quote do
+        unquote(var) = String.Chars.to_string(unquote(ast))
+      end
+
+    segment =
+      quote do
+        unquote(var) :: binary
+      end
+
+    %{state | dynamic: [ast | dynamic], binary: [segment | binary], vars_count: vars_count + 1}
+  end
+
+  def handle_expr(state, "", ast) do
+    %{dynamic: dynamic} = state
+    %{state | dynamic: [ast | dynamic]}
+  end
+
+  def handle_expr(_state, marker, _ast) when marker in ["/", "|"] do
+    raise EEx.SyntaxError,
+          "unsupported EEx syntax <%#{marker} %> (the syntax is valid but not supported by the current EEx engine)"
+  end
+
+  defp check_state!(%{binary: _, dynamic: _, vars_count: _}), do: :ok
+
+  defp check_state!(state) do
+    raise "unexpected EEx.Engine state: #{inspect(state)}. " <>
+            "This typically means a bug or an outdated EEx.Engine or tool"
   end
 end
diff --git a/lib/eex/lib/eex/smart_engine.ex b/lib/eex/lib/eex/smart_engine.ex
index c59db81596f..4604adeb89f 100644
--- a/lib/eex/lib/eex/smart_engine.ex
+++ b/lib/eex/lib/eex/smart_engine.ex
@@ -1,62 +1,6 @@
-defmodule EEx.TransformerEngine do
-  @moduledoc false
-
-  @doc false
-  defmacro __using__(_) do
-    quote do
-      @behaviour EEx.Engine
-
-      def handle_body(body) do
-        EEx.Engine.handle_body(body)
-      end
-
-      def handle_text(buffer, text) do
-        EEx.Engine.handle_text(buffer, text)
-      end
-
-      def handle_expr(buffer, mark, expr) do
-        EEx.Engine.handle_expr(buffer, mark, transform(expr))
-      end
-
-      defp transform({a, b, c}) do
-        {transform(a), b, transform(c)}
-      end
-
-      defp transform({a, b}) do
-        {transform(a), transform(b)}
-      end
-
-      defp transform(list) when is_list(list) do
-        for i <- list, do: transform(i)
-      end
-
-      defp transform(other) do
-        other
-      end
-
-      defoverridable [transform: 1, handle_body: 1, handle_expr: 3, handle_text: 2]
-    end
-  end
-end
-
-defmodule EEx.AssignsEngine do
-  @moduledoc false
-
-  @doc false
-  defmacro __using__(_) do
-    quote unquote: false do
-      defp transform({:@, line, [{name, _, atom}]}) when is_atom(name) and is_atom(atom) do
-        quote do: Dict.get(var!(assigns), unquote(name))
-      end
-
-      defp transform(arg) do
-        super(arg)
-      end
-
-      defoverridable [transform: 1]
-    end
-  end
-end
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
 defmodule EEx.SmartEngine do
   @moduledoc """
@@ -71,9 +15,9 @@ defmodule EEx.SmartEngine do
       "1"
 
   In the example above, we can access the value `foo` under
-  the binding `assigns` using `@foo`. This is useful when
-  a template, after compiled, may receive different assigns
-  and the developer don't want to recompile it for each
+  the binding `assigns` using `@foo`. This is useful because
+  a template, after being compiled, can receive different
+  assigns and would not require recompilation for each
   variable set.
 
   Assigns can also be used when compiled to a function:
@@ -84,18 +28,35 @@ defmodule EEx.SmartEngine do
       # sample.ex
       defmodule Sample do
         require EEx
-        EEx.function_from_file :def, :sample, "sample.eex", [:assigns]
+        EEx.function_from_file(:def, :sample, "sample.eex", [:assigns])
       end
 
       # iex
-      Sample.sample(a: 1, b: 2) #=> "3"
+      Sample.sample(a: 1, b: 2)
+      #=> "3"
 
   """
 
-  use EEx.Engine
+  @behaviour EEx.Engine
+
+  @impl true
+  defdelegate init(opts), to: EEx.Engine
+
+  @impl true
+  defdelegate handle_body(state), to: EEx.Engine
+
+  @impl true
+  defdelegate handle_begin(state), to: EEx.Engine
+
+  @impl true
+  defdelegate handle_end(state), to: EEx.Engine
+
+  @impl true
+  defdelegate handle_text(state, meta, text), to: EEx.Engine
 
-  def handle_expr(buffer, mark, expr) do
+  @impl true
+  def handle_expr(state, marker, expr) do
     expr = Macro.prewalk(expr, &EEx.Engine.handle_assign/1)
-    super(buffer, mark, expr)
+    EEx.Engine.handle_expr(state, marker, expr)
   end
 end
diff --git a/lib/eex/lib/eex/tokenizer.ex b/lib/eex/lib/eex/tokenizer.ex
deleted file mode 100644
index 44d5b681eed..00000000000
--- a/lib/eex/lib/eex/tokenizer.ex
+++ /dev/null
@@ -1,161 +0,0 @@
-defmodule EEx.Tokenizer do
-  @moduledoc false
-
-  @doc """
-  Tokenizes the given char list or binary.
-  It returns 4 different types of tokens as result:
-
-    * `{:text, contents}`
-    * `{:expr, line, marker, contents}`
-    * `{:start_expr, line, marker, contents}`
-    * `{:middle_expr, line, marker, contents}`
-    * `{:end_expr, line, marker, contents}`
-
-  """
-  def tokenize(bin, line) when is_binary(bin) do
-    tokenize(String.to_char_list(bin), line)
-  end
-
-  def tokenize(list, line) do
-    Enum.reverse(tokenize(list, line, [], []))
-  end
-
-  defp tokenize('<%%' ++ t, line, buffer, acc) do
-    {buffer, new_line, rest} = tokenize_expr t, line, [?%, ?<|buffer]
-    tokenize rest, new_line, [?>, ?%|buffer], acc
-  end
-
-  defp tokenize('<%#' ++ t, line, buffer, acc) do
-    {_, new_line, rest} = tokenize_expr t, line, []
-    tokenize rest, new_line, buffer, acc
-  end
-
-  defp tokenize('<%' ++ t, line, buffer, acc) do
-    {marker, t} = retrieve_marker(t)
-    {expr, new_line, rest} = tokenize_expr t, line, []
-
-    token = token_name(expr)
-    acc   = tokenize_text(buffer, acc)
-    final = {token, line, marker, Enum.reverse(expr)}
-    tokenize rest, new_line, [], [final | acc]
-  end
-
-  defp tokenize('\n' ++ t, line, buffer, acc) do
-    tokenize t, line + 1, [?\n|buffer], acc
-  end
-
-  defp tokenize([h|t], line, buffer, acc) do
-    tokenize t, line, [h|buffer], acc
-  end
-
-  defp tokenize([], _line, buffer, acc) do
-    tokenize_text(buffer, acc)
-  end
-
-  # Retrieve marker for <%
-
-  defp retrieve_marker('=' ++ t) do
-    {"=", t}
-  end
-
-  defp retrieve_marker(t) do
-    {"", t}
-  end
-
-  # Tokenize an expression until we find %>
-
-  defp tokenize_expr([?%, ?>|t], line, buffer) do
-    {buffer, line, t}
-  end
-
-  defp tokenize_expr('\n' ++ t, line, buffer) do
-    tokenize_expr t, line + 1, [?\n|buffer]
-  end
-
-  defp tokenize_expr([h|t], line, buffer) do
-    tokenize_expr t, line, [h|buffer]
-  end
-
-  defp tokenize_expr([], _line, _buffer) do
-    raise EEx.SyntaxError, message: "missing token: %>"
-  end
-
-  # Receive an expression content and check
-  # if it is a start, middle or an end token.
-  #
-  # Start tokens finish with `do` and `fn ->`
-  # Middle tokens are marked with `->` or keywords
-  # End tokens contain only the end word
-
-  defp token_name([h|t]) when h in [?\s, ?\t] do
-    token_name(t)
-  end
-
-  defp token_name('od' ++ [h|_]) when h in [?\s, ?\t, ?)] do
-    :start_expr
-  end
-
-  defp token_name('>-' ++ rest) do
-    rest = Enum.reverse(rest)
-
-    # Tokenize the remaining passing check_terminators as
-    # false, which relax the tokenizer to not error on
-    # unmatched pairs. Then, we check if there is a "fn"
-    # token and, if so, it is not followed by an "end"
-    # token. If this is the case, we are on a start expr.
-    case :elixir_tokenizer.tokenize(rest, 1, file: "eex", check_terminators: false) do
-      {:ok, _line, tokens} ->
-        tokens   = Enum.reverse(tokens)
-        fn_index = fn_index(tokens)
-
-        if fn_index && end_index(tokens) > fn_index do
-          :start_expr
-        else
-          :middle_expr
-        end
-      _error ->
-        :middle_expr
-    end
-  end
-
-  defp token_name('esle' ++ t),   do: check_spaces(t, :middle_expr)
-  defp token_name('retfa' ++ t),  do: check_spaces(t, :middle_expr)
-  defp token_name('hctac' ++ t),  do: check_spaces(t, :middle_expr)
-  defp token_name('eucser' ++ t), do: check_spaces(t, :middle_expr)
-  defp token_name('dne' ++ t),    do: check_spaces(t, :end_expr)
-
-  defp token_name(_) do
-    :expr
-  end
-
-  defp fn_index(tokens) do
-    Enum.find_index tokens, fn
-      {:fn_paren, _} -> true
-      {:fn, _}       -> true
-      _                -> false
-    end
-  end
-
-  defp end_index(tokens) do
-    Enum.find_index(tokens, &match?({:end, _}, &1)) || :infinity
-  end
-
-  defp check_spaces(string, token) do
-    if Enum.all?(string, &(&1 in [?\s, ?\t])) do
-      token
-    else
-      :expr
-    end
-  end
-
-  # Tokenize the buffered text by appending
-  # it to the given accumulator.
-
-  defp tokenize_text([], acc) do
-    acc
-  end
-
-  defp tokenize_text(buffer, acc) do
-    [{:text, Enum.reverse(buffer)} | acc]
-  end
-end
diff --git a/lib/eex/mix.exs b/lib/eex/mix.exs
index 0a2877473c5..acf9eb901fd 100644
--- a/lib/eex/mix.exs
+++ b/lib/eex/mix.exs
@@ -1,9 +1,15 @@
-defmodule EEx.Mixfile do
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule EEx.MixProject do
   use Mix.Project
 
   def project do
-    [app: :eex,
-     version: System.version,
-     build_per_environment: false]
+    [
+      app: :eex,
+      version: System.version(),
+      build_per_environment: false
+    ]
   end
 end
diff --git a/lib/eex/test/eex/smart_engine_test.exs b/lib/eex/test/eex/smart_engine_test.exs
index 1003da8da15..a4c3ee1cc13 100644
--- a/lib/eex/test/eex/smart_engine_test.exs
+++ b/lib/eex/test/eex/smart_engine_test.exs
@@ -1,26 +1,54 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule EEx.SmartEngineTest do
   use ExUnit.Case, async: true
 
   test "evaluates simple string" do
-    assert_eval "foo bar", "foo bar"
+    assert_eval("foo bar", "foo bar")
   end
 
   test "evaluates with assigns as keywords" do
-    assert_eval "1", "<%= @foo %>", assigns: [foo: 1]
+    assert_eval("1", "<%= @foo %>", assigns: [foo: 1])
   end
 
   test "evaluates with assigns as a map" do
-    assert_eval "1", "<%= @foo %>", assigns: %{foo: 1}
+    assert_eval("1", "<%= @foo %>", assigns: %{foo: 1})
+  end
+
+  test "error with missing assigns" do
+    stderr =
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        assert_eval("", "<%= @foo %>", assigns: %{})
+      end)
+
+    assert stderr =~ "assign @foo not available in EEx template"
   end
 
   test "evaluates with loops" do
-    assert_eval "1\n2\n3\n", "<%= for x <- [1, 2, 3] do %><%= x %>\n<% end %>"
+    assert_eval("1\n2\n3\n", "<%= for x <- [1, 2, 3] do %><%= x %>\n<% end %>")
+  end
+
+  test "preserves line numbers in assignments" do
+    result = EEx.compile_string("foo\n<%= @hello %>", engine: EEx.SmartEngine)
+
+    Macro.prewalk(result, fn
+      {_left, meta, [_, :hello]} ->
+        assert Keyword.get(meta, :line) == 2
+        send(self(), :found)
+
+      node ->
+        node
+    end)
+
+    assert_received :found
   end
 
   defp assert_eval(expected, actual, binding \\ []) do
-    result = EEx.eval_string(actual, binding, file: __ENV__.file)
+    result = EEx.eval_string(actual, binding, file: __ENV__.file, engine: EEx.SmartEngine)
     assert result == expected
   end
 end
diff --git a/lib/eex/test/eex/tokenizer_test.exs b/lib/eex/test/eex/tokenizer_test.exs
index d58268b0903..434821dc984 100644
--- a/lib/eex/test/eex/tokenizer_test.exs
+++ b/lib/eex/test/eex/tokenizer_test.exs
@@ -1,105 +1,370 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule EEx.TokenizerTest do
   use ExUnit.Case, async: true
-  require EEx.Tokenizer, as: T
 
-  test "simple chars lists" do
-    assert T.tokenize('foo', 1) == [ {:text, 'foo'} ]
+  @opts [indentation: 0, trim: false]
+
+  test "simple charlists" do
+    assert EEx.tokenize(~c"foo", @opts) ==
+             {:ok, [{:text, ~c"foo", %{column: 1, line: 1}}, {:eof, %{column: 4, line: 1}}]}
   end
 
   test "simple strings" do
-    assert T.tokenize("foo", 1) == [ {:text, 'foo'} ]
+    assert EEx.tokenize("foo", @opts) ==
+             {:ok, [{:text, ~c"foo", %{column: 1, line: 1}}, {:eof, %{column: 4, line: 1}}]}
   end
 
   test "strings with embedded code" do
-    assert T.tokenize('foo <% bar %>', 1) == [ {:text, 'foo '}, {:expr, 1, "", ' bar '} ]
+    assert EEx.tokenize(~c"foo <% bar %>", @opts) ==
+             {:ok,
+              [
+                {:text, ~c"foo ", %{column: 1, line: 1}},
+                {:expr, ~c"", ~c" bar ", %{column: 5, line: 1}},
+                {:eof, %{column: 14, line: 1}}
+              ]}
   end
 
   test "strings with embedded equals code" do
-    assert T.tokenize('foo <%= bar %>', 1) == [ {:text, 'foo '}, {:expr, 1, "=", ' bar '} ]
+    assert EEx.tokenize(~c"foo <%= bar %>", @opts) ==
+             {:ok,
+              [
+                {:text, ~c"foo ", %{column: 1, line: 1}},
+                {:expr, ~c"=", ~c" bar ", %{column: 5, line: 1}},
+                {:eof, %{column: 15, line: 1}}
+              ]}
+  end
+
+  test "strings with embedded slash code" do
+    assert EEx.tokenize(~c"foo <%/ bar %>", @opts) ==
+             {:ok,
+              [
+                {:text, ~c"foo ", %{column: 1, line: 1}},
+                {:expr, ~c"/", ~c" bar ", %{column: 5, line: 1}},
+                {:eof, %{column: 15, line: 1}}
+              ]}
+  end
+
+  test "strings with embedded pipe code" do
+    assert EEx.tokenize(~c"foo <%| bar %>", @opts) ==
+             {:ok,
+              [
+                {:text, ~c"foo ", %{column: 1, line: 1}},
+                {:expr, ~c"|", ~c" bar ", %{column: 5, line: 1}},
+                {:eof, %{column: 15, line: 1}}
+              ]}
   end
 
   test "strings with more than one line" do
-    assert T.tokenize('foo\n<%= bar %>', 1) == [ {:text, 'foo\n'}, {:expr, 2, "=", ' bar '} ]
+    assert EEx.tokenize(~c"foo\n<%= bar %>", @opts) ==
+             {:ok,
+              [
+                {:text, ~c"foo\n", %{column: 1, line: 1}},
+                {:expr, ~c"=", ~c" bar ", %{column: 1, line: 2}},
+                {:eof, %{column: 11, line: 2}}
+              ]}
   end
 
   test "strings with more than one line and expression with more than one line" do
-    string = '''
-foo <%= bar
+    string = ~c"""
+    foo <%= bar
+
+    baz %>
+    <% foo %>
+    """
 
-baz %>
-<% foo %>
-'''
+    exprs = [
+      {:text, ~c"foo ", %{column: 1, line: 1}},
+      {:expr, ~c"=", ~c" bar\n\nbaz ", %{column: 5, line: 1}},
+      {:text, ~c"\n", %{column: 7, line: 3}},
+      {:expr, ~c"", ~c" foo ", %{column: 1, line: 4}},
+      {:text, ~c"\n", %{column: 10, line: 4}},
+      {:eof, %{column: 1, line: 5}}
+    ]
 
-    assert T.tokenize(string, 1) == [
-      {:text, 'foo '},
-      {:expr, 1, "=", ' bar\n\nbaz '},
-      {:text, '\n'},
-      {:expr, 4, "", ' foo '},
-      {:text, '\n'}
-    ] 
+    assert EEx.tokenize(string, @opts) == {:ok, exprs}
   end
 
   test "quotation" do
-    assert T.tokenize('foo <%% true %>', 1) == [
-      {:text, 'foo <% true %>'}
+    assert EEx.tokenize(~c"foo <%% true %>", @opts) ==
+             {:ok,
+              [
+                {:text, ~c"foo <% true %>", %{column: 1, line: 1}},
+                {:eof, %{column: 16, line: 1}}
+              ]}
+  end
+
+  test "quotation with do-end" do
+    assert EEx.tokenize(~c"foo <%% true do %>bar<%% end %>", @opts) ==
+             {:ok,
+              [
+                {:text, ~c"foo <% true do %>bar<% end %>", %{column: 1, line: 1}},
+                {:eof, %{column: 32, line: 1}}
+              ]}
+  end
+
+  test "quotation with interpolation" do
+    exprs = [
+      {:text, ~c"a <% b ", %{column: 1, line: 1}},
+      {:expr, ~c"=", ~c" c ", %{column: 9, line: 1}},
+      {:text, ~c" ", %{column: 17, line: 1}},
+      {:expr, ~c"=", ~c" d ", %{column: 18, line: 1}},
+      {:text, ~c" e %> f", %{column: 26, line: 1}},
+      {:eof, %{column: 33, line: 1}}
     ]
+
+    assert EEx.tokenize(~c"a <%% b <%= c %> <%= d %> e %> f", @opts) == {:ok, exprs}
+  end
+
+  test "improperly formatted quotation with interpolation" do
+    exprs = [
+      {:text, ~c"<%% a <%= b %> c %>", %{column: 1, line: 1}},
+      {:eof, %{column: 22, line: 1}}
+    ]
+
+    assert EEx.tokenize(~c"<%%% a <%%= b %> c %>", @opts) == {:ok, exprs}
+  end
+
+  test "EEx comments" do
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      exprs = [
+        {:text, ~c"foo ", %{column: 1, line: 1}},
+        {:eof, %{column: 16, line: 1}}
+      ]
+
+      assert EEx.tokenize(~c"foo <%# true %>", @opts) == {:ok, exprs}
+
+      exprs = [
+        {:text, ~c"foo ", %{column: 1, line: 1}},
+        {:eof, %{column: 8, line: 2}}
+      ]
+
+      assert EEx.tokenize(~c"foo <%#\ntrue %>", @opts) == {:ok, exprs}
+    end)
   end
 
-  test "quotation with do/end" do
-    assert T.tokenize('foo <%% true do %>bar<%% end %>', 1) == [
-      {:text, 'foo <% true do %>bar<% end %>'}
+  test "EEx multi-line comments" do
+    exprs = [
+      {:text, ~c"foo ", %{column: 1, line: 1}},
+      {:comment, ~c" true ", %{column: 5, line: 1}},
+      {:text, ~c" bar", %{column: 20, line: 1}},
+      {:eof, %{column: 24, line: 1}}
+    ]
+
+    assert EEx.tokenize(~c"foo <%!-- true --%> bar", @opts) == {:ok, exprs}
+
+    exprs = [
+      {:text, ~c"foo ", %{column: 1, line: 1}},
+      {:comment, ~c" \ntrue\n ", %{column: 5, line: 1}},
+      {:text, ~c" bar", %{column: 6, line: 3}},
+      {:eof, %{column: 10, line: 3}}
+    ]
+
+    assert EEx.tokenize(~c"foo <%!-- \ntrue\n --%> bar", @opts) == {:ok, exprs}
+
+    exprs = [
+      {:text, ~c"foo ", %{column: 1, line: 1}},
+      {:comment, ~c" <%= true %> ", %{column: 5, line: 1}},
+      {:text, ~c" bar", %{column: 27, line: 1}},
+      {:eof, %{column: 31, line: 1}}
     ]
+
+    assert EEx.tokenize(~c"foo <%!-- <%= true %> --%> bar", @opts) == {:ok, exprs}
   end
 
-  test "comments" do
-    assert T.tokenize('foo <%# true %>', 1) == [
-      {:text, 'foo '}
+  test "Elixir comments" do
+    exprs = [
+      {:text, ~c"foo ", %{column: 1, line: 1}},
+      {:expr, [], ~c" true # this is a boolean ", %{column: 5, line: 1}},
+      {:eof, %{column: 35, line: 1}}
     ]
+
+    assert EEx.tokenize(~c"foo <% true # this is a boolean %>", @opts) == {:ok, exprs}
   end
 
-  test "comments with do/end" do
-    assert T.tokenize('foo <%# true do %>bar<%# end %>', 1) == [
-      {:text, 'foo bar'}
+  test "Elixir comments with do-end" do
+    exprs = [
+      {:start_expr, [], ~c" if true do # startif ", %{column: 1, line: 1}},
+      {:text, ~c"text", %{column: 27, line: 1}},
+      {:end_expr, [], ~c" end # closeif ", %{column: 31, line: 1}},
+      {:eof, %{column: 50, line: 1}}
     ]
+
+    assert EEx.tokenize(~c"<% if true do # startif %>text<% end # closeif %>", @opts) ==
+             {:ok, exprs}
   end
 
   test "strings with embedded do end" do
-    assert T.tokenize('foo <% if true do %>bar<% end %>', 1) == [
-      {:text, 'foo '},
-      {:start_expr, 1, "", ' if true do '},
-      {:text, 'bar'},
-      {:end_expr, 1, "", ' end '}
+    exprs = [
+      {:text, ~c"foo ", %{column: 1, line: 1}},
+      {:start_expr, ~c"", ~c" if true do ", %{column: 5, line: 1}},
+      {:text, ~c"bar", %{column: 21, line: 1}},
+      {:end_expr, ~c"", ~c" end ", %{column: 24, line: 1}},
+      {:eof, %{column: 33, line: 1}}
     ]
+
+    assert EEx.tokenize(~c"foo <% if true do %>bar<% end %>", @opts) == {:ok, exprs}
   end
 
   test "strings with embedded -> end" do
-    assert T.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', 1) == [
-      {:text, 'foo '},
-      {:start_expr, 1, "", ' cond do '},
-      {:middle_expr, 1, "", ' false -> '},
-      {:text, 'bar'},
-      {:middle_expr, 1, "", ' true -> '},
-      {:text, 'baz'},
-      {:end_expr, 1, "", ' end '}
+    exprs = [
+      {:text, ~c"foo ", %{column: 1, line: 1}},
+      {:start_expr, ~c"", ~c" cond do ", %{column: 5, line: 1}},
+      {:middle_expr, ~c"", ~c" false -> ", %{column: 18, line: 1}},
+      {:text, ~c"bar", %{column: 32, line: 1}},
+      {:middle_expr, ~c"", ~c" true -> ", %{column: 35, line: 1}},
+      {:text, ~c"baz", %{column: 48, line: 1}},
+      {:end_expr, ~c"", ~c" end ", %{column: 51, line: 1}},
+      {:eof, %{column: 60, line: 1}}
     ]
+
+    assert EEx.tokenize(~c"foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>", @opts) ==
+             {:ok, exprs}
+  end
+
+  test "strings with fn-end with newline" do
+    exprs = [
+      {:start_expr, ~c"=", ~c" a fn ->\n", %{column: 1, line: 1}},
+      {:text, ~c"foo", %{column: 3, line: 2}},
+      {:end_expr, [], ~c" end ", %{column: 6, line: 2}},
+      {:eof, %{column: 15, line: 2}}
+    ]
+
+    assert EEx.tokenize(~c"<%= a fn ->\n%>foo<% end %>", @opts) ==
+             {:ok, exprs}
+  end
+
+  test "strings with multiple fn-end" do
+    exprs = [
+      {:start_expr, ~c"=", ~c" a fn -> ", %{column: 1, line: 1}},
+      {:text, ~c"foo", %{column: 15, line: 1}},
+      {:middle_expr, ~c"", ~c" end, fn -> ", %{column: 18, line: 1}},
+      {:text, ~c"bar", %{column: 34, line: 1}},
+      {:end_expr, ~c"", ~c" end ", %{column: 37, line: 1}},
+      {:eof, %{column: 46, line: 1}}
+    ]
+
+    assert EEx.tokenize(~c"<%= a fn -> %>foo<% end, fn -> %>bar<% end %>", @opts) ==
+             {:ok, exprs}
+  end
+
+  test "strings with fn-end followed by do block" do
+    exprs = [
+      {:start_expr, ~c"=", ~c" a fn -> ", %{column: 1, line: 1}},
+      {:text, ~c"foo", %{column: 15, line: 1}},
+      {:middle_expr, ~c"", ~c" end do ", %{column: 18, line: 1}},
+      {:text, ~c"bar", %{column: 30, line: 1}},
+      {:end_expr, ~c"", ~c" end ", %{column: 33, line: 1}},
+      {:eof, %{column: 42, line: 1}}
+    ]
+
+    assert EEx.tokenize(~c"<%= a fn -> %>foo<% end do %>bar<% end %>", @opts) == {:ok, exprs}
   end
 
   test "strings with embedded keywords blocks" do
-    assert T.tokenize('foo <% if true do %>bar<% else %>baz<% end %>', 1) == [
-      {:text, 'foo '},
-      {:start_expr, 1, "", ' if true do '},
-      {:text, 'bar'},
-      {:middle_expr, 1, "", ' else '},
-      {:text, 'baz'},
-      {:end_expr, 1, "", ' end '}
+    exprs = [
+      {:text, ~c"foo ", %{column: 1, line: 1}},
+      {:start_expr, ~c"", ~c" if true do ", %{column: 5, line: 1}},
+      {:text, ~c"bar", %{column: 21, line: 1}},
+      {:middle_expr, ~c"", ~c" else ", %{column: 24, line: 1}},
+      {:text, ~c"baz", %{column: 34, line: 1}},
+      {:end_expr, ~c"", ~c" end ", %{column: 37, line: 1}},
+      {:eof, %{column: 46, line: 1}}
     ]
+
+    assert EEx.tokenize(~c"foo <% if true do %>bar<% else %>baz<% end %>", @opts) ==
+             {:ok, exprs}
   end
 
-  test "raise syntax error when there is start mark and no end mark" do
-    assert_raise EEx.SyntaxError, "missing token: %>", fn ->
-      T.tokenize('foo <% :bar', 1)
+  test "trim mode" do
+    template = ~c"\t<%= if true do %> \n TRUE \n  <% else %>\n FALSE \n  <% end %>  \n\n  "
+
+    exprs = [
+      {:start_expr, ~c"=", ~c" if true do ", %{column: 2, line: 1}},
+      {:text, ~c"\n TRUE \n", %{column: 20, line: 1}},
+      {:middle_expr, ~c"", ~c" else ", %{column: 3, line: 3}},
+      {:text, ~c"\n FALSE \n", %{column: 13, line: 3}},
+      {:end_expr, ~c"", ~c" end ", %{column: 3, line: 5}},
+      {:eof, %{column: 3, line: 7}}
+    ]
+
+    assert EEx.tokenize(template, [trim: true] ++ @opts) == {:ok, exprs}
+  end
+
+  test "trim mode with multi-line comment" do
+    exprs = [
+      {:comment, ~c" comment ", %{column: 3, line: 1}},
+      {:text, ~c"\n123", %{column: 23, line: 1}},
+      {:eof, %{column: 4, line: 2}}
+    ]
+
+    assert EEx.tokenize(~c"  <%!-- comment --%>  \n123", [trim: true] ++ @opts) == {:ok, exprs}
+  end
+
+  test "trim mode with CRLF" do
+    exprs = [
+      {:text, ~c"0\n", %{column: 1, line: 1}},
+      {:expr, ~c"=", ~c" 12 ", %{column: 3, line: 2}},
+      {:text, ~c"\n34", %{column: 15, line: 2}},
+      {:eof, %{column: 3, line: 3}}
+    ]
+
+    assert EEx.tokenize(~c"0\r\n  <%= 12 %>  \r\n34", [trim: true] ++ @opts) == {:ok, exprs}
+  end
+
+  test "trim mode set to false" do
+    exprs = [
+      {:text, ~c" ", %{column: 1, line: 1}},
+      {:expr, ~c"=", ~c" 12 ", %{column: 2, line: 1}},
+      {:text, ~c" \n", %{column: 11, line: 1}},
+      {:eof, %{column: 1, line: 2}}
+    ]
+
+    assert EEx.tokenize(~c" <%= 12 %> \n", [trim: false] ++ @opts) == {:ok, exprs}
+  end
+
+  test "trim mode no false positives" do
+    assert_not_trimmed = fn x ->
+      assert EEx.tokenize(x, [trim: false] ++ @opts) == EEx.tokenize(x, @opts)
     end
+
+    assert_not_trimmed.(~c"foo <%= \"bar\" %>  ")
+    assert_not_trimmed.(~c"\n  <%= \"foo\" %>bar")
+    assert_not_trimmed.(~c"  <%% hello %>  ")
+    assert_not_trimmed.(~c"  <%= 01 %><%= 23 %>\n")
+  end
+
+  test "returns error when there is start mark and no end mark" do
+    message = """
+    expected closing '%>' for EEx expression
+      |
+    1 | foo <% :bar
+      |     ^\
+    """
+
+    assert EEx.tokenize(~c"foo <% :bar", @opts) ==
+             {:error, message, %{column: 5, line: 1}}
+
+    message = """
+    expected closing '--%>' for EEx expression
+      |
+    1 | <%!-- foo
+      | ^\
+    """
+
+    assert EEx.tokenize(~c"<%!-- foo", @opts) == {:error, message, %{column: 1, line: 1}}
+  end
+
+  test "marks invalid expressions as regular expressions" do
+    assert EEx.tokenize(~c"<% 1 $ 2 %>", @opts) ==
+             {:ok,
+              [
+                {:expr, [], ~c" 1 $ 2 ", %{column: 1, line: 1}},
+                {:eof, %{column: 12, line: 1}}
+              ]}
   end
 end
diff --git a/lib/eex/test/eex_test.exs b/lib/eex/test/eex_test.exs
index 5cd9318b33c..5214b3afc64 100644
--- a/lib/eex/test/eex_test.exs
+++ b/lib/eex/test/eex_test.exs
@@ -1,39 +1,40 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 require EEx
 
 defmodule EExTest.Compiled do
   def before_compile do
-    fill_in_stacktrace
-    {__ENV__.line, hd(tl(System.stacktrace))}
+    {__ENV__.line, hd(tl(get_stacktrace()))}
   end
 
-  EEx.function_from_string :def, :string_sample, "<%= a + b %>", [:a, :b]
+  EEx.function_from_string(:def, :string_sample, "<%= a + b %>", [:a, :b])
 
   filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
-  EEx.function_from_file :defp, :private_file_sample, filename, [:bar]
+  EEx.function_from_file(:defp, :private_file_sample, filename, [:bar])
 
   filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
-  EEx.function_from_file :def, :public_file_sample, filename, [:bar]
+  EEx.function_from_file(:def, :public_file_sample, filename, [:bar])
 
   def file_sample(arg), do: private_file_sample(arg)
 
   def after_compile do
-    fill_in_stacktrace
-    {__ENV__.line, hd(tl(System.stacktrace))}
+    {__ENV__.line, hd(tl(get_stacktrace()))}
   end
 
   @file "unknown"
   def unknown do
-    fill_in_stacktrace
-    {__ENV__.line, hd(tl(System.stacktrace))}
+    {__ENV__.line, hd(tl(get_stacktrace()))}
   end
 
-  defp fill_in_stacktrace do
+  defp get_stacktrace do
     try do
-      :erlang.error "failed"
-    catch
-      :error, _ -> System.stacktrace
+      :erlang.error("failed")
+    rescue
+      _ -> __STACKTRACE__
     end
   end
 end
@@ -50,331 +51,911 @@ defmodule EExTest do
   use ExUnit.Case, async: true
 
   doctest EEx
-  doctest EEx.AssignsEngine
+  doctest EEx.Engine
+  doctest EEx.SmartEngine
 
-  test "evaluates simple string" do
-    assert_eval "foo bar", "foo bar"
-  end
+  describe "evaluates" do
+    test "simple string" do
+      assert_eval("foo bar", "foo bar")
+    end
 
-  test "evaluates with embedded" do
-    assert_eval "foo bar", "foo <%= :bar %>"
-  end
+    test "Unicode" do
+      template = """
+        • <%= "•" %> •
+        <%= "Jößé Vâlìm" %> Jößé Vâlìm
+      """
 
-  test "evaluates with embedded and the binding" do
-    assert EEx.eval_string("foo <%= bar %>", [bar: 1]) == "foo 1"
-  end
+      assert_eval("  • • •\n  Jößé Vâlìm Jößé Vâlìm\n", template)
+    end
 
-  test "evaluates with embedded do end" do
-    assert_eval "foo bar", "foo <%= if true do %>bar<% end %>"
-  end
+    test "no spaces" do
+      string = """
+      <%=cond do%>
+      <%false ->%>
+        this
+      <%true ->%>
+        that
+      <%end%>
+      """
+
+      expected = "\n  that\n\n"
+      assert_eval(expected, string, [])
+    end
 
-  test "evaluates with embedded do end and eval the expression" do
-    assert_eval "foo ", "foo <%= if false do %>bar<% end %>"
-  end
+    test "trim mode" do
+      string = "<%= 123 %> \n  \n  <%= 789 %>"
+      expected = "123\n789"
+      assert_eval(expected, string, [], trim: true)
 
-  test "evaluates with embedded do end and nested print expression" do
-    assert_eval "foo bar", "foo <%= if true do %><%= :bar %><% end %>"
-  end
+      string = "<%= 123 %> \n456\n  <%= 789 %>"
+      expected = "123\n456\n789"
+      assert_eval(expected, string, [], trim: true)
 
-  test "evaluates with embedded do end and nested expressions" do
-    assert_eval "foo bar baz", "foo <%= if true do %>bar <% Process.put(:eex_text, 1) %><%= :baz %><% end %>"
-    assert Process.get(:eex_text) == 1
-  end
+      string = "<%= 123 %> \n\n456\n\n  <%= 789 %>"
+      expected = "123\n456\n789"
+      assert_eval(expected, string, [], trim: true)
 
-  test "evaluates with embedded middle expression" do
-    assert_eval "foo bar", "foo <%= if true do %>bar<% else %>baz<% end %>"
-  end
+      string = "<%= 123 %> \n  \n456\n  \n  <%= 789 %>"
+      expected = "123\n456\n789"
+      assert_eval(expected, string, [], trim: true)
 
-  test "evaluates with embedded middle expression and eval the expression" do
-    assert_eval "foo baz", "foo <%= if false do %>bar<% else %>baz<% end %>"
-  end
+      string = "\n  <%= 123 %> \n  <%= 456 %>  \n  <%= 789 %>  \n"
+      expected = "123\n456\n789"
+      assert_eval(expected, string, [], trim: true)
 
-  test "evaluates with nested start expression" do
-    assert_eval "foo bar", "foo <%= if true do %><%= if true do %>bar<% end %><% end %>"
-  end
+      string = "\r\n  <%= 123 %> \r\n  <%= 456 %>  \r\n  <%= 789 %>  \r\n"
+      expected = "123\n456\n789"
+      assert_eval(expected, string, [], trim: true)
+    end
 
-  test "evaluates with nested middle expression" do
-    assert_eval "foo baz", "foo <%= if true do %><%= if false do %>bar<% else %>baz<% end %><% end %>"
-  end
+    test "trim mode with middle expression" do
+      string = """
+      <%= cond do %>
+      <% false -> %>
+        this
+      <% true -> %>
+        that
+      <% end %>
+      """
+
+      expected = "\n  that\n"
+      assert_eval(expected, string, [], trim: true)
+    end
 
-  test "evaluates with defined variable" do
-    assert_eval "foo 1", "foo <% bar = 1 %><%= bar %>"
-  end
+    test "trim mode with multiple lines" do
+      string = """
+      <%= "First line" %>
+      <%= "Second line" %>
+      <%= "Third line" %>
+      <%= "Fourth line" %>
+      """
 
-  test "evaluates with require code" do
-    assert_eval "foo 1,2,3", "foo <% require Enum, as: E %><%= E.join [1, 2, 3], \",\" %>"
-  end
+      expected = "First line\nSecond line\nThird line\nFourth line"
+      assert_eval(expected, string, [], trim: true)
+    end
 
-  test "evaluates with end of token" do
-    assert_eval "foo bar %>", "foo bar %>"
-  end
+    test "trim mode with no spaces" do
+      string = """
+      <%=if true do%>
+        this
+      <%else%>
+        that
+      <%end%>
+      """
+
+      expected = "\n  this\n"
+      assert_eval(expected, string, [], trim: true)
+
+      string = """
+      <%=cond do%>
+      <%false ->%>
+        this
+      <%true ->%>
+        that
+      <%end%>
+      """
+
+      expected = "\n  that\n"
+      assert_eval(expected, string, [], trim: true)
+    end
 
-  test "raises a syntax error when the token is invalid" do
-    assert_raise EEx.SyntaxError, "missing token: %>", fn ->
-      EEx.compile_string "foo <%= bar"
+    test "embedded code" do
+      assert_eval("foo bar", "foo <%= :bar %>")
     end
-  end
 
-  test "raises a syntax error when end expression is found without a start expression" do
-    assert_raise EEx.SyntaxError, "unexpected token: ' end ' at line 1",  fn ->
-      EEx.compile_string "foo <% end %>"
+    test "embedded code with binding" do
+      assert EEx.eval_string("foo <%= bar %>", bar: 1) == "foo 1"
     end
-  end
 
-  test "raises a syntax error when start expression is found without an end expression" do
-    assert_raise EEx.SyntaxError, "unexpected end of string. expecting a closing <% end %>.", fn ->
-      EEx.compile_string "foo <% if true do %>"
+    test "embedded code with do end when true" do
+      assert_eval("foo bar", "foo <%= if true do %>bar<% end %>")
     end
-  end
 
-  test "raises a syntax error when nested end expression is found without an start expression" do
-    assert_raise EEx.SyntaxError, "unexpected token: ' end ' at line 1", fn ->
-      EEx.compile_string "foo <% if true do %><% end %><% end %>"
+    test "embedded code with do end when false" do
+      assert_eval("foo ", "foo <%= if false do %>bar<% end %>")
+    end
+
+    test "embedded code with do preceded by bracket" do
+      assert_eval("foo bar", "foo <%= if {true}do %>bar<% end %>")
+      assert_eval("foo bar", "foo <%= if (true)do %>bar<% end %>")
+      assert_eval("foo bar", "foo <%= if [true]do %>bar<% end %>")
     end
-  end
 
-  test "respects line numbers" do
-    expected = """
-foo
-2
-"""
+    test "embedded code with do end and expression" do
+      assert_eval("foo bar", "foo <%= if true do %><%= :bar %><% end %>")
+    end
 
-    string = """
-foo
-<%= __ENV__.line %>
-"""
+    test "embedded code with do end and multiple expressions" do
+      assert_eval(
+        "foo bar baz",
+        "foo <%= if true do %>bar <% Process.put(:eex_text, 1) %><%= :baz %><% end %>"
+      )
 
-    assert_eval expected, string
-  end
+      assert Process.get(:eex_text) == 1
+    end
 
-  test "respects line numbers inside nested expressions" do
-    expected = """
-foo
+    test "embedded code with middle expression" do
+      assert_eval("foo bar", "foo <%= if true do %>bar<% else %>baz<% end %>")
+    end
 
-3
+    test "embedded code with evaluated middle expression" do
+      assert_eval("foo baz", "foo <%= if false do %>bar<% else %>baz<% end %>")
+    end
 
-5
-"""
+    test "embedded code with multi-line comments in do end" do
+      assert_eval("foo bar", "foo <%= case true do %><%!-- comment --%><% true -> %>bar<% end %>")
 
-    string = """
-foo
-<%= if true do %>
-<%= __ENV__.line %>
-<% end %>
-<%= __ENV__.line %>
-"""
+      assert_eval(
+        "foo\n\nbar\n",
+        "foo\n<%= case true do %>\n<%!-- comment --%>\n<% true -> %>\nbar\n<% end %>"
+      )
+    end
 
-    assert_eval expected, string
-  end
+    test "embedded code with nested do end" do
+      assert_eval("foo bar", "foo <%= if true do %><%= if true do %>bar<% end %><% end %>")
+    end
 
-  test "respects line numbers inside start expression" do
-    expected = """
-foo
+    test "embedded code with nested do end with middle expression" do
+      assert_eval(
+        "foo baz",
+        "foo <%= if true do %><%= if false do %>bar<% else %>baz<% end %><% end %>"
+      )
+    end
 
-true
+    test "embedded code with end followed by bracket" do
+      assert_eval(
+        " 101  102  103 ",
+        "<%= Enum.map([1, 2, 3], fn x -> %> <%= 100 + x %> <% end) %>"
+      )
+
+      assert_eval(
+        " 101  102  103 ",
+        "<%= Enum.map([1, 2, 3], fn x ->\n%> <%= 100 + x %> <% end) %>"
+      )
+
+      assert_eval(
+        " 101  102  103 ",
+        "<%= apply Enum, :map, [[1, 2, 3], fn x -> %> <%= 100 + x %> <% end] %>"
+      )
+
+      assert_eval(
+        " 101  102  103 ",
+        "<%= #{__MODULE__}.tuple_map {[1, 2, 3], fn x -> %> <%= 100 + x %> <% end} %>"
+      )
+
+      assert_eval(
+        " 101  102  103 ",
+        "<%= apply(Enum, :map, [[1, 2, 3], fn x -> %> <%= 100 + x %> <% end]) %>"
+      )
+
+      assert_eval(
+        " 101  102  103 ",
+        "<%= Enum.map([1, 2, 3], (fn x -> %> <%= 100 + x %> <% end) ) %>"
+      )
+    end
 
-5
-"""
+    test "embedded code with variable definition" do
+      assert_eval("foo 1", "foo <% bar = 1 %><%= bar %>")
+    end
 
-    string = """
-foo
-<%= if __ENV__.line == 2 do %>
-<%= true %>
-<% end %>
-<%= __ENV__.line %>
-"""
+    test "embedded code with require" do
+      assert_eval("foo 1,2,3", "foo <% require Enum, as: E %><%= E.join [1, 2, 3], \",\" %>")
+    end
 
-    assert_eval expected, string
+    test "with end of token" do
+      assert_eval("foo bar %>", "foo bar %>")
+    end
   end
 
-  test "respects line numbers inside middle expression with ->" do
-    expected = """
-foo
+  describe "raises syntax errors" do
+    test "with relative file information" do
+      message = """
+      foobar.eex:1:5: expected closing '%>' for EEx expression
+        |
+      1 | foo <%= bar
+        |     ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("foo <%= bar", file: Path.join(File.cwd!(), "foobar.eex"))
+      end
+    end
+
+    test "when <%!-- is not closed" do
+      message = """
+      my_file.eex:1:5: expected closing '--%>' for EEx expression
+        |
+      1 | foo <%!-- bar
+        |     ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("foo <%!-- bar", file: "my_file.eex")
+      end
+    end
 
-true
+    test "when the token is invalid" do
+      message = """
+      nofile:1:5: expected closing '%>' for EEx expression
+        |
+      1 | foo <%= bar
+        |     ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("foo <%= bar")
+      end
+    end
 
-7
-"""
+    test "when middle expression is found without a start expression" do
+      message = """
+      nofile:5:1: unexpected middle of expression <% else %>
+        |
+      2 | <%= "content" %>
+      3 | <%= if true %>
+      4 |   <%= "foo" %>
+      5 | <% else %>
+        | ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string(
+          ~s(<h1>Hi!</h1>\n<%= "content" %>\n<%= if true %>\n  <%= "foo" %>\n<% else %>\n  bar<% end %>)
+        )
+      end
+    end
 
-    string = """
-foo
-<%= cond do %>
-<% false -> %> false
-<% __ENV__.line == 4 -> %>
-<%= true %>
-<% end %>
-<%= __ENV__.line %>
-"""
+    test "proper format line number of code snippet" do
+      message = """
+      nofile:11:1: unexpected middle of expression <% else %>
+         |
+       8 | <%= "content" %>
+       9 | <%= if true %>
+      10 |   <%= "foo" %>
+      11 | <% else %>
+         | ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string(
+          ~s(\n\n\n\n\n\n<h1>Hi!</h1>\n<%= "content" %>\n<%= if true %>\n  <%= "foo" %>\n<% else %>\n  bar<% end %>)
+        )
+      end
+    end
 
-    assert_eval expected, string
-  end
+    test "when there is only middle expression" do
+      message = """
+      nofile:1:1: unexpected middle of expression <% else %>
+        |
+      1 | <% else %>
+        | ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string(~s(<% else %>))
+      end
+    end
 
-  test "respects line number inside middle expressions with keywords" do
-    expected = """
-foo
+    test "when it is missing a `do` in case expr" do
+      message = """
+      nofile:3:3: unexpected middle of expression <% :something -> %>
+        |
+      1 | content
+      2 | <%= case @var %>
+      3 |   <% :something -> %>
+        |   ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("content\n<%= case @var %>\n  <% :something -> %>\n    bar<% end %>")
+      end
+    end
 
-5
+    test "when it is a `do` in cond expr" do
+      message = """
+      nofile:3:3: unexpected middle of expression <% true -> %>
+        |
+      1 | content
+      2 | <%= cond %>
+      3 |   <% true -> %>
+        |   ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("content\n<%= cond %>\n  <% true -> %>\n    bar<% end %>")
+      end
+    end
 
-7
-"""
+    test "when end expression is found without a start expression" do
+      message = """
+      nofile:1:5: unexpected end of expression <% end %>
+        |
+      1 | foo <% end %>
+        |     ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("foo <% end %>")
+      end
+    end
 
-    string = """
-foo
-<%= if false do %>
-<%= __ENV__.line %>
-<% else %>
-<%= __ENV__.line %>
-<% end %>
-<%= __ENV__.line %>
-"""
+    test "when start expression is found without an end expression" do
+      message = """
+      nofile:2:5: expected a closing '<% end %>' for block expression in EEx
+        |
+      1 | foo
+      2 | <%= if true do %>
+        |     ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("foo\n<%= if true do %>\nfoo\n")
+      end
+
+      message = """
+      nofile:3:3: expected a closing '<% end %>' for block expression in EEx
+        |
+      1 | foo
+      2 | <%=
+      3 |   if true do %>
+        |   ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("foo\n<%=\n  if true do %>\nfoo\n", indentation: 0)
+      end
+
+      message = """
+      nofile:3:6: expected a closing '<% end %>' for block expression in EEx
+        |
+      1 |    foo
+      2 |    <%=
+      3 |      if true do %>
+        |      ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("foo\n<%=\n  if true do %>\nfoo\n", indentation: 3)
+      end
+    end
 
-    assert_eval expected, string
-  end
+    test "when start expression with middle expression is found without an end expression" do
+      message = """
+      nofile:2:5: expected a closing '<% end %>' for block expression in EEx
+        |
+      1 | foo
+      2 | <%= if true do %>
+        |     ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("foo\n<%= if true do %>\nfoo\n<% else %>\n")
+      end
+    end
+
+    test "when multiple start expressions is found without an end expression" do
+      message = """
+      nofile:5:5: expected a closing '<% end %>' for block expression in EEx
+        |
+      2 | <%= if true do %>
+      3 |   <%= @something %>
+      4 |\s
+      5 | <%= if @var do %>
+        |     ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string(
+          "foo\n<%= if true do %>\n  <%= @something %>\n\n<%= if @var do %>\nfoo\n"
+        )
+      end
+    end
+
+    test "when nested end expression is found without a start expression" do
+      message = """
+      nofile:1:31: unexpected end of expression <% end %>
+        |
+      1 | foo <%= if true do %><% end %><% end %>
+        |                               ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("foo <%= if true do %><% end %><% end %>")
+      end
+    end
+
+    test "when trying to use marker '|' without implementation" do
+      msg =
+        ~r/unsupported EEx syntax <%| %> \(the syntax is valid but not supported by the current EEx engine\)/
 
-  test "properly handle functions" do
-    expected = """
+      assert_raise EEx.SyntaxError, msg, fn ->
+        EEx.compile_string("<%| true %>")
+      end
+    end
 
-Number 1
+    test "when trying to use marker '/' without implementation" do
+      msg =
+        ~r/unsupported EEx syntax <%\/ %> \(the syntax is valid but not supported by the current EEx engine\)/
 
-Number 2
+      assert_raise EEx.SyntaxError, msg, fn ->
+        EEx.compile_string("<%/ true %>")
+      end
+    end
 
-Number 3
+    test "from Elixir parser" do
+      line = __ENV__.line + 6
+
+      message =
+        assert_raise TokenMissingError, fn ->
+          EEx.compile_string(
+            """
+            <li>
+              <strong>Some:</strong>
+              <%= true && @some[ %>
+            </li>
+            """,
+            file: __ENV__.file,
+            line: line,
+            indentation: 12
+          )
+        end
+
+      assert message |> Exception.message() |> strip_ansi() =~ """
+                  │
+              514 │                   true && @some[\s
+                  │                                │ └ missing closing delimiter (expected "]")
+                  │                                └ unclosed delimiter
+             """
+    end
 
-"""
+    test "from Elixir parser with line breaks" do
+      line = __ENV__.line + 6
+
+      message =
+        assert_raise TokenMissingError, fn ->
+          EEx.compile_string(
+            """
+            <li>
+              <strong>Some:</strong>
+              <%= true &&
+                @some[ %>
+            </li>
+            """,
+            file: __ENV__.file,
+            line: line,
+            indentation: 12
+          )
+        end
+
+      assert message |> Exception.message() |> strip_ansi() =~ """
+                  │
+              #{line + 3} │                 @some[\s
+                  │                      │ └ missing closing delimiter (expected "]")
+                  │                      └ unclosed delimiter
+             """
+    end
 
-    string = """
-<%= Enum.map [1, 2, 3], fn x -> %>
-Number <%= x %>
-<% end %>
-"""
+    test "honor line numbers" do
+      assert_raise EEx.SyntaxError,
+                   "nofile:100:6: expected closing '%>' for EEx expression",
+                   fn ->
+                     EEx.compile_string("foo\n bar <%= baz", line: 99)
+                   end
+    end
 
-    assert_eval expected, string
+    test "honor file names" do
+      message = """
+      my_file.eex:1:5: expected closing '%>' for EEx expression
+        |
+      1 | foo <%= bar
+        |     ^\
+      """
+
+      assert_raise EEx.SyntaxError, message, fn ->
+        EEx.compile_string("foo <%= bar", file: "my_file.eex")
+      end
+    end
   end
 
-  test "do not consider already finished functions" do
-    expected = """
-foo
+  describe "warnings" do
+    test "when middle expression has a modifier" do
+      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               EEx.compile_string("foo <%= if true do %>true<%= else %>false<% end %>")
+             end) =~ ~s[unexpected beginning of EEx tag \"<%=\" on \"<%= else %>\"]
+    end
 
-true
+    test "when end expression has a modifier" do
+      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               EEx.compile_string("foo <%= if true do %>true<% else %>false<%= end %>")
+             end) =~
+               ~s[unexpected beginning of EEx tag \"<%=\" on \"<%= end %>\"]
+    end
 
-"""
+    test "unused \"do\" block without \"<%=\" modifier" do
+      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               EEx.compile_string("<% if true do %>I'm invisible!<% end %>")
+             end) =~ "the contents of this expression won't be output"
 
-    string = """
-foo
-<%= cond do %>
-<% false -> %> false
-<% fn -> 1 end -> %>
-<%= true %>
-<% end %>
-"""
+      # These are fine though
+      EEx.compile_string("<% foo = fn -> %>Hello<% end %>")
+      EEx.compile_string("<% foo = if true do %>Hello<% end %>")
+    end
 
-    assert_eval expected, string
-  end
+    test "from tokenizer" do
+      warning =
+        ExUnit.CaptureIO.capture_io(:stderr, fn ->
+          EEx.compile_string(~s'<%= :"foo" %>', file: "tokenizer.ex")
+        end)
 
-  test "evaluates nested do expressions" do
-    string = """
-    <% y = ["a", "b", "c"] %>
-    <%= cond do %>
-     <% "a" in y -> %>
-      Good
-     <% true -> %>
-      <% if true do %>true<% else %>false<% end %>
-      Bad
-    <% end %>
-    """
-
-    assert_eval "\n\n  Good\n \n", string
+      assert warning =~ "found quoted atom \"foo\" but the quotes are not required"
+      assert warning =~ "tokenizer.ex:1:5"
+    end
   end
 
-  test "for comprehensions" do
-    string = """
-    <%= for _name <- packages || [] do %>
-    <% end %>
-    <%= all || :done %>
-    """
-    assert_eval "\ndone\n", string, packages: nil, all: nil
-  end
+  describe "environment" do
+    test "respects line numbers" do
+      expected = """
+      foo
+      2
+      """
 
-  test "unicode" do
-    template = """
-      • <%= "•" %> •
-      <%= "Jößé Vâlìm" %> Jößé Vâlìm
-    """
-    result = EEx.eval_string(template)
-    assert result == "  • • •\n  Jößé Vâlìm Jößé Vâlìm\n"
-  end
+      string = """
+      foo
+      <%= __ENV__.line %>
+      """
 
-  test "evaluates the source from a given file" do
-    filename = Path.join(__DIR__, "fixtures/eex_template.eex")
-    result = EEx.eval_file(filename)
-    assert result == "foo bar.\n"
-  end
+      assert_eval(expected, string)
+    end
 
-  test "evaluates the source from a given file with bindings" do
-    filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
-    result = EEx.eval_file(filename, [bar: 1])
-    assert result == "foo 1\n"
-  end
+    test "respects line numbers inside nested expressions" do
+      expected = """
+      foo
+
+      3
+
+      5
+      """
+
+      string = """
+      foo
+      <%= if true do %>
+      <%= __ENV__.line %>
+      <% end %>
+      <%= __ENV__.line %>
+      """
+
+      assert_eval(expected, string)
+    end
+
+    test "respects line numbers inside start expression" do
+      expected = """
+      foo
+
+      true
+
+      5
+      """
+
+      string = """
+      foo
+      <%= if __ENV__.line == 2 do %>
+      <%= true %>
+      <% end %>
+      <%= __ENV__.line %>
+      """
+
+      assert_eval(expected, string)
+    end
+
+    test "respects line numbers inside middle expression with ->" do
+      expected = """
+      foo
+
+      true
+
+      7
+      """
+
+      string = """
+      foo
+      <%= cond do %>
+      <% false -> %> false
+      <% __ENV__.line == 4 -> %>
+      <%= true %>
+      <% end %>
+      <%= __ENV__.line %>
+      """
+
+      assert_eval(expected, string)
+    end
+
+    test "respects line number inside middle expressions with keywords" do
+      expected = """
+      foo
+
+      5
+
+      7
+      """
 
-  test "raises an Exception when there's an error with the given file" do
-    assert_raise File.Error, "could not read file non-existent.eex: no such file or directory", fn ->
-      filename = "non-existent.eex"
-      EEx.compile_file(filename)
+      string = """
+      foo
+      <%= if false do %>
+      <%= __ENV__.line %>
+      <% else %>
+      <%= __ENV__.line %>
+      <% end %>
+      <%= __ENV__.line %>
+      """
+
+      assert_eval(expected, string)
+    end
+
+    test "respects files" do
+      assert_eval("sample.ex", "<%= __ENV__.file %>", [], file: "sample.ex")
     end
   end
 
-  test "sets external resource attribute" do
-    assert EExTest.Compiled.__info__(:attributes)[:external_resource] ==
-           [Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")]
+  describe "clauses" do
+    test "inside functions" do
+      expected = """
+
+      Number 1
+
+      Number 2
+
+      Number 3
+
+      """
+
+      string = """
+      <%= Enum.map [1, 2, 3], fn x -> %>
+      Number <%= x %>
+      <% end %>
+      """
+
+      assert_eval(expected, string)
+    end
+
+    test "inside multiple functions" do
+      expected = """
+
+      A 1
+
+      B 2
+
+      A 3
+
+      """
+
+      string = """
+      <%= #{__MODULE__}.switching_map [1, 2, 3], fn x -> %>
+      A <%= x %>
+      <% end, fn x -> %>
+      B <%= x %>
+      <% end %>
+      """
+
+      assert_eval(expected, string)
+    end
+
+    test "inside callback and do block" do
+      expected = """
+
+
+      A 1
+
+      B 2
+
+      A 3
+
+      """
+
+      string = """
+      <% require #{__MODULE__} %>
+      <%= #{__MODULE__}.switching_macro [1, 2, 3], fn x -> %>
+      A <%= x %>
+      <% end do %>
+      B <%= x %>
+      <% end %>
+      """
+
+      assert_eval(expected, string)
+    end
+
+    test "inside cond" do
+      expected = """
+      foo
+
+      true
+
+      """
+
+      string = """
+      foo
+      <%= cond do %>
+      <% false -> %> false
+      <% fn -> 1 end -> %>
+      <%= true %>
+      <% end %>
+      """
+
+      assert_eval(expected, string)
+    end
+
+    test "inside cond with do end" do
+      string = """
+      <% y = ["a", "b", "c"] %>
+      <%= cond do %>
+       <% "a" in y -> %>
+        Good
+       <% true -> %>
+        <%= if true do %>true<% else %>false<% end %>
+        Bad
+      <% end %>
+      """
+
+      assert_eval("\n\n  Good\n \n", string)
+    end
+
+    test "line and column meta" do
+      indentation = 12
+
+      ast =
+        EEx.compile_string(
+          """
+          <%= f() %> <% f() %>
+            <%= f fn -> %>
+              <%= f() %>
+            <% end %>
+          """,
+          indentation: indentation
+        )
+
+      {_, calls} =
+        Macro.prewalk(ast, [], fn
+          {:f, meta, _args} = expr, acc -> {expr, [meta | acc]}
+          other, acc -> {other, acc}
+        end)
+
+      assert Enum.reverse(calls) == [
+               [line: 1, column: indentation + 5],
+               [line: 1, column: indentation + 15],
+               [line: 2, column: indentation + 7],
+               [line: 3, column: indentation + 9]
+             ]
+    end
   end
 
-  test "defined from string" do
-    assert EExTest.Compiled.string_sample(1, 2) == "3"
+  describe "buffers" do
+    test "inside comprehensions" do
+      string = """
+      <%= for _name <- packages || [] do %>
+      <% end %>
+      <%= all || :done %>
+      """
+
+      assert_eval("\ndone\n", string, packages: nil, all: nil)
+    end
   end
 
-  test "defined from file" do
-    assert EExTest.Compiled.file_sample(1) == "foo 1\n"
-    assert EExTest.Compiled.public_file_sample(1) == "foo 1\n"
+  describe "from file" do
+    test "evaluates the source" do
+      filename = Path.join(__DIR__, "fixtures/eex_template.eex")
+      result = EEx.eval_file(filename)
+      assert_normalized_newline_equal("foo bar.\n", result)
+    end
+
+    test "evaluates the source with bindings" do
+      filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
+      result = EEx.eval_file(filename, bar: 1)
+      assert_normalized_newline_equal("foo 1\n", result)
+    end
+
+    test "raises an Exception when file is missing" do
+      msg = "could not read file \"non-existent.eex\": no such file or directory"
+
+      assert_raise File.Error, msg, fn ->
+        filename = "non-existent.eex"
+        EEx.compile_file(filename)
+      end
+    end
+
+    test "sets external resource attribute" do
+      assert EExTest.Compiled.__info__(:attributes)[:external_resource] ==
+               [Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")]
+    end
+
+    test "supports t:Path.t() paths" do
+      filename = to_charlist(Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex"))
+      result = EEx.eval_file(filename, bar: 1)
+      assert_normalized_newline_equal("foo 1\n", result)
+    end
+
+    test "supports overriding file and line through options" do
+      filename = Path.join(__DIR__, "fixtures/eex_template_with_syntax_error.eex")
+
+      assert_raise EEx.SyntaxError,
+                   "my_file.eex:10:5: expected closing '%>' for EEx expression",
+                   fn ->
+                     EEx.eval_file(filename, _bindings = [], file: "my_file.eex", line: 10)
+                   end
+    end
   end
 
-  test "defined from file do not affect backtrace" do
-    assert EExTest.Compiled.before_compile ==
-      {8,
-        {EExTest.Compiled,
-          :before_compile,
-          0,
-          [file: to_char_list(Path.relative_to_cwd(__ENV__.file)), line: 7]
-       }
-     }
-
-    assert EExTest.Compiled.after_compile ==
-      {23,
-        {EExTest.Compiled,
-          :after_compile,
-          0,
-          [file: to_char_list(Path.relative_to_cwd(__ENV__.file)), line: 22]
-       }
-     }
-
-    assert EExTest.Compiled.unknown ==
-      {29,
-        {EExTest.Compiled,
-          :unknown,
-          0,
-          [file: 'unknown', line: 28]
-       }
-     }
+  describe "precompiled" do
+    test "from string" do
+      assert EExTest.Compiled.string_sample(1, 2) == "3"
+    end
+
+    test "from file" do
+      assert_normalized_newline_equal("foo 1\n", EExTest.Compiled.file_sample(1))
+      assert_normalized_newline_equal("foo 1\n", EExTest.Compiled.public_file_sample(1))
+    end
+
+    test "from file does not affect backtrace" do
+      file = to_charlist(Path.relative_to_cwd(__ENV__.file))
+
+      assert EExTest.Compiled.before_compile() ==
+               {11, {EExTest.Compiled, :before_compile, 0, [file: file, line: 11]}}
+
+      assert EExTest.Compiled.after_compile() ==
+               {25, {EExTest.Compiled, :after_compile, 0, [file: file, line: 25]}}
+
+      assert EExTest.Compiled.unknown() ==
+               {30, {EExTest.Compiled, :unknown, 0, [file: ~c"unknown", line: 30]}}
+    end
   end
 
   defmodule TestEngine do
     @behaviour EEx.Engine
 
+    def init(_opts) do
+      "INIT"
+    end
+
     def handle_body(body) do
-      {:wrapped, body}
+      "BODY(#{body})"
+    end
+
+    def handle_begin(_) do
+      "BEGIN"
+    end
+
+    def handle_end(buffer) do
+      buffer <> ":END"
     end
 
-    def handle_text(buffer, text) do
-      EEx.Engine.handle_text(buffer, text)
+    def handle_text(buffer, meta, text) do
+      buffer <> ":TEXT-#{meta[:line]}-#{meta[:column]}(#{String.trim(text)})"
+    end
+
+    def handle_expr(buffer, "/", expr) do
+      buffer <> ":DIV(#{Macro.to_string(expr)})"
+    end
+
+    def handle_expr(buffer, "=", expr) do
+      buffer <> ":EQUAL(#{Macro.to_string(expr)})"
     end
 
     def handle_expr(buffer, mark, expr) do
@@ -382,12 +963,80 @@ foo
     end
   end
 
-  test "calls handle_body" do
-    assert {:wrapped, "foo"} = EEx.eval_string("foo", [], engine: TestEngine)
+  describe "custom engines" do
+    test "text" do
+      assert_eval("BODY(INIT:TEXT-1-1(foo))", "foo", [], engine: TestEngine)
+    end
+
+    test "custom marker" do
+      assert_eval("BODY(INIT:TEXT-1-1(foo):DIV(:bar))", "foo <%/ :bar %>", [], engine: TestEngine)
+    end
+
+    test "begin/end" do
+      assert_eval(
+        ~s[BODY(INIT:TEXT-1-1(foo):EQUAL(if do\n  "BEGIN:TEXT-1-17(this):END"\nelse\n  "BEGIN:TEXT-1-31(that):END"\nend))],
+        "foo <%= if do %>this<% else %>that<% end %>",
+        [],
+        engine: TestEngine
+      )
+    end
+
+    test "not implemented custom marker" do
+      msg =
+        ~r/unsupported EEx syntax <%| %> \(the syntax is valid but not supported by the current EEx engine\)/
+
+      assert_raise EEx.SyntaxError, msg, fn ->
+        assert_eval({:wrapped, "foo baz"}, "foo <%| :bar %>", [], engine: TestEngine)
+      end
+    end
+  end
+
+  describe "parser options" do
+    test "customizes parsed code" do
+      atoms_encoder = fn "not_jose", _ -> {:ok, :jose} end
+
+      assert_eval("valid", "<%= not_jose %>", [jose: "valid"],
+        parser_options: [static_atoms_encoder: atoms_encoder]
+      )
+    end
+  end
+
+  @strip_ansi [IO.ANSI.green(), IO.ANSI.red(), IO.ANSI.reset()]
+
+  defp strip_ansi(doc) do
+    String.replace(doc, @strip_ansi, "")
   end
 
-  defp assert_eval(expected, actual, binding \\ []) do
-    result = EEx.eval_string(actual, binding, file: __ENV__.file, engine: EEx.Engine)
+  defp assert_eval(expected, actual, binding \\ [], opts \\ []) do
+    opts = Keyword.merge([file: __ENV__.file, engine: opts[:engine] || EEx.Engine], opts)
+    result = EEx.eval_string(actual, binding, opts)
     assert result == expected
   end
+
+  defp assert_normalized_newline_equal(expected, actual) do
+    assert String.replace(expected, "\r\n", "\n") == String.replace(actual, "\r\n", "\n")
+  end
+
+  def tuple_map({list, callback}) do
+    Enum.map(list, callback)
+  end
+
+  def switching_map(list, a, b) do
+    list
+    |> Enum.with_index()
+    |> Enum.map(fn
+      {element, index} when rem(index, 2) == 0 -> a.(element)
+      {element, index} when rem(index, 2) == 1 -> b.(element)
+    end)
+  end
+
+  defmacro switching_macro(list, a, do: block) do
+    quote do
+      b = fn var!(x) ->
+        unquote(block)
+      end
+
+      unquote(__MODULE__).switching_map(unquote(list), unquote(a), b)
+    end
+  end
 end
diff --git a/lib/eex/test/fixtures/eex_template_with_syntax_error.eex b/lib/eex/test/fixtures/eex_template_with_syntax_error.eex
new file mode 100644
index 00000000000..e8aa61680f4
--- /dev/null
+++ b/lib/eex/test/fixtures/eex_template_with_syntax_error.eex
@@ -0,0 +1 @@
+foo <%= bar
diff --git a/lib/eex/test/test_helper.exs b/lib/eex/test/test_helper.exs
index bf1bd1990e9..4d157609935 100644
--- a/lib/eex/test/test_helper.exs
+++ b/lib/eex/test/test_helper.exs
@@ -1 +1,15 @@
-ExUnit.start [trace: "--trace" in System.argv]
\ No newline at end of file
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+{line_exclude, line_include} =
+  if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
+
+Code.require_file("../../elixir/scripts/cover_record.exs", __DIR__)
+CoverageRecorder.maybe_record("eex")
+
+ExUnit.start(
+  trace: !!System.get_env("TRACE"),
+  include: line_include,
+  exclude: line_exclude
+)
diff --git a/lib/elixir/Emakefile b/lib/elixir/Emakefile
new file mode 100644
index 00000000000..2d3d2e5e3e1
--- /dev/null
+++ b/lib/elixir/Emakefile
@@ -0,0 +1,20 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+{'src/*', [
+  warn_unused_vars,
+  warn_export_all,
+  warn_shadow_vars,
+  warn_unused_import,
+  warn_unused_function,
+  warn_bif_clash,
+  warn_unused_record,
+  warn_deprecated_function,
+  warn_obsolete_guard,
+  warn_exported_vars,
+  %% Enable this when we require Erlang/OTP 27+
+  %% warnings_as_errors,
+  debug_info,
+  {outdir, "ebin/"}
+]}.
diff --git a/lib/elixir/include/elixir.hrl b/lib/elixir/include/elixir.hrl
deleted file mode 100644
index 9d536c9184a..00000000000
--- a/lib/elixir/include/elixir.hrl
+++ /dev/null
@@ -1,68 +0,0 @@
--define(m(M, K), maps:get(K, M)).
--define(line(Opts), elixir_utils:get_line(Opts)).
-
--record(elixir_scope, {
-  context=nil,             %% can be match, guards or nil
-  extra=nil,               %% extra information about the context, like fn_match and map_key
-  noname=false,            %% when true, don't add new names (used by try)
-  super=false,             %% when true, it means super was invoked
-  caller=false,            %% when true, it means caller was invoked
-  return=true,             %% when true, the return value is used
-  module=nil,              %% the current module
-  function=nil,            %% the current function
-  vars=[],                 %% a dict of defined variables and their alias
-  backup_vars=nil,         %% a copy of vars to be used on ^var
-  match_vars=nil,          %% a set of all variables defined in a particular match
-  export_vars=nil,         %% a dict of all variables defined in a particular clause
-  extra_guards=nil,        %% extra guards from args expansion
-  counter=[],              %% a dict counting the variables defined
-  file=(<<"nofile">>)      %% the current scope filename
-}).
-
--record(elixir_quote, {
-  line=false,
-  keep=false,
-  context=nil,
-  vars_hygiene=true,
-  aliases_hygiene=true,
-  imports_hygiene=true,
-  unquote=true,
-  unquoted=false,
-  escape=false
-}).
-
--record(elixir_tokenizer, {
-  file,
-  terminators=[],
-  check_terminators=true,
-  existing_atoms_only=false
-}).
-
-%% Used in tokenization and interpolation
-
-%% Numbers
--define(is_hex(S), ?is_digit(S) orelse (S >= $A andalso S =< $F) orelse (S >= $a andalso S =< $f)).
--define(is_bin(S), S >= $0 andalso S =< $1).
--define(is_octal(S), S >= $0 andalso S =< $7).
--define(is_leading_octal(S), S >= $0 andalso S =< $3).
-
-%% Digits and letters
--define(is_digit(S), S >= $0 andalso S =< $9).
--define(is_upcase(S), S >= $A andalso S =< $Z).
--define(is_downcase(S), S >= $a andalso S =< $z).
-
-%% Atoms
--define(is_atom_start(S), ?is_quote(S) orelse ?is_upcase(S) orelse ?is_downcase(S) orelse (S == $_)).
--define(is_atom(S), ?is_identifier(S) orelse (S == $@)).
-
--define(is_identifier(S), ?is_digit(S) orelse ?is_upcase(S) orelse ?is_downcase(S) orelse (S == $_)).
--define(is_sigil(S), (S == $/) orelse (S == $<) orelse (S == $") orelse (S == $') orelse
-                     (S == $[) orelse (S == $() orelse (S == ${) orelse (S == $|)).
-
-%% Quotes
--define(is_quote(S), S == $" orelse S == $').
-
-%% Spaces
--define(is_horizontal_space(S), (S == $\s) orelse (S == $\t)).
--define(is_vertical_space(S), (S == $\r) orelse (S == $\n)).
--define(is_space(S), ?is_horizontal_space(S) orelse ?is_vertical_space(S)).
diff --git a/lib/elixir/lib/access.ex b/lib/elixir/lib/access.ex
index acf88b370b6..bacf3bc4e87 100644
--- a/lib/elixir/lib/access.ex
+++ b/lib/elixir/lib/access.ex
@@ -1,19 +1,23 @@
-defprotocol Access do
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Access do
   @moduledoc """
-  The Access protocol is used by `foo[bar]` and also
-  empowers the nested update functions in Kernel.
+  Key-based access to data structures.
 
-  For instance, `foo[bar]` translates `Access.get(foo, bar)`.
-  `Kernel.get_in/2`, `Kernel.put_in/3`, `Kernel.update_in/3` and
-  `Kernel.get_and_update_in/3` are also all powered by the Access
-  protocol.
+  The `Access` module defines a behaviour for dynamically accessing
+  keys of any type in a data structure via the `data[key]` syntax.
 
-  This protocol is implemented by default for keywords, maps
-  and dictionary like types:
+  `Access` supports keyword lists (`Keyword`) and maps (`Map`) out
+  of the box. Keywords supports only atoms keys, keys for maps can
+  be of any type. Both return `nil` if the key does not exist:
 
       iex> keywords = [a: 1, b: 2]
       iex> keywords[:a]
       1
+      iex> keywords[:c]
+      nil
 
       iex> map = %{a: 1, b: 2}
       iex> map[:a]
@@ -23,127 +27,1173 @@ defprotocol Access do
       iex> star_ratings[1.5]
       "★☆"
 
-  The key comparison must be implemented using the `===` operator.
+  This syntax is very convenient as it can be nested arbitrarily:
+
+      iex> keywords = [a: 1, b: 2]
+      iex> keywords[:c][:unknown]
+      nil
+
+  This works because accessing anything on a `nil` value, returns
+  `nil` itself:
+
+      iex> nil[:a]
+      nil
+
+  ## Maps and structs
+
+  While the access syntax is allowed in maps via `map[key]`,
+  if your map is made of predefined atom keys, you should prefer
+  to access those atom keys with `map.key` instead of `map[key]`,
+  as `map.key` will raise if the key is missing (which is not
+  supposed to happen if the keys are predefined) or if `map` is
+  `nil`.
+
+  Similarly, since structs are maps and structs have predefined
+  keys, they only allow the `struct.key` syntax and they do not
+  allow the `struct[key]` access syntax.
+
+  In other words, the `map[key]` syntax is loose, returning `nil`
+  for missing keys, while the `map.key` syntax is strict, raising
+  for both nil values and missing keys.
+
+  To bridge this gap, Elixir provides the `get_in/1` and `get_in/2`
+  functions, which are capable of traversing nested data structures,
+  even in the presence of `nil`s:
+
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_in(users["john"].age)
+      27
+      iex> get_in(users["unknown"].age)
+      nil
+
+  Notice how, even if no user was found, `get_in/1` returned `nil`.
+  Outside of `get_in/1`, trying to access the field `.age` on `nil`
+  would raise.
+
+  The `get_in/2` function takes one step further by allowing
+  different accessors to be mixed in. For example, given a user
+  map with the `:name` and `:languages` keys, here is how to
+  access the name of all programming languages:
+
+        iex> languages = [
+        ...>   %{name: "elixir", type: :functional},
+        ...>   %{name: "c", type: :procedural}
+        ...> ]
+        iex> user = %{name: "john", languages: languages}
+        iex> get_in(user, [:languages, Access.all(), :name])
+        ["elixir", "c"]
+
+  This module provides convenience functions for traversing other
+  structures, like tuples and lists. As we will see next, they can
+  even be used to update nested data structures.
+
+  If you want to learn more about the dual nature of maps in Elixir,
+  as they can be either for structured data or as a key-value store,
+  see the `Map` module.
+
+  ## Updating nested data structures
+
+  The access syntax can also be used with the `Kernel.put_in/2`,
+  `Kernel.update_in/2`, `Kernel.get_and_update_in/2`, and `Kernel.pop_in/1`
+  macros to further manipulate values in nested data structures:
+
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> put_in(users["john"].age, 28)
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
+
+  As shown in the previous section, you can also use the
+  `Kernel.put_in/3`, `Kernel.update_in/3`, `Kernel.pop_in/2`, and
+  `Kernel.get_and_update_in/3` functions to provide nested
+  custom accessors. For instance, given a user map with the
+  `:name` and `:languages` keys, here is how to deeply traverse
+  the map and convert all language names to uppercase:
+
+      iex> languages = [
+      ...>   %{name: "elixir", type: :functional},
+      ...>   %{name: "c", type: :procedural}
+      ...> ]
+      iex> user = %{name: "john", languages: languages}
+      iex> update_in(user, [:languages, Access.all(), :name], &String.upcase/1)
+      %{
+        name: "john",
+        languages: [
+          %{name: "ELIXIR", type: :functional},
+          %{name: "C", type: :procedural}
+        ]
+      }
+
+  See the functions `key/1`, `key!/1`, `elem/1`, and `all/0` for
+  some of the available accessors.
   """
 
+  @type container :: keyword | struct | map
+  @type nil_container :: nil
+  @type t :: container | nil_container | any
+  @type key :: any
+  @type value :: any
+
+  @type get_fun(data) ::
+          (:get, data, (term -> term) -> new_data :: container)
+
+  @type get_and_update_fun(data, current_value) ::
+          (:get_and_update, data, (term -> term) ->
+             {current_value, new_data :: container} | :pop)
+
+  @type access_fun(data, current_value) ::
+          get_fun(data) | get_and_update_fun(data, current_value)
+
   @doc """
-  Accesses the given key in the container.
+  Invoked in order to access the value stored under `key` in the given term `term`.
+
+  This function should return `{:ok, value}` where `value` is the value under
+  `key` if the key exists in the term, or `:error` if the key does not exist in
+  the term.
+
+  Many of the functions defined in the `Access` module internally call this
+  function. This function is also used when the square-brackets access syntax
+  (`structure[key]`) is used: the `fetch/2` callback implemented by the module
+  that defines the `structure` struct is invoked and if it returns `{:ok,
+  value}` then `value` is returned, or if it returns `:error` then `nil` is
+  returned.
+
+  See the `Map.fetch/2` and `Keyword.fetch/2` implementations for examples of
+  how to implement this callback.
+  """
+  @callback fetch(term :: t, key) :: {:ok, value} | :error
+
+  @doc """
+  Invoked in order to access the value under `key` and update it at the same time.
+
+  The implementation of this callback should invoke `fun` with the value under
+  `key` in the passed structure `data`, or with `nil` if `key` is not present in it.
+  This function must return either `{current_value, new_value}` or `:pop`.
+
+  If the passed function returns `{current_value, new_value}`,
+  the return value of this callback should be `{current_value, new_data}`, where:
+
+    * `current_value` is the retrieved value (which can be operated on before being returned)
+
+    * `new_value` is the new value to be stored under `key`
+
+    * `new_data` is `data` after updating the value of `key` with `new_value`.
+
+  If the passed function returns `:pop`, the return value of this callback
+  must be `{value, new_data}` where `value` is the value under `key`
+  (or `nil` if not present) and `new_data` is `data` without `key`.
+
+  See the implementations of `Map.get_and_update/3` or `Keyword.get_and_update/3`
+  for more examples.
   """
-  @spec get(t, term) :: t
-  def get(container, key)
+  @callback get_and_update(data, key, (value | nil -> {current_value, new_value :: value} | :pop)) ::
+              {current_value, new_data :: data}
+            when current_value: value, data: container
 
   @doc """
-  Gets a value and updates the given `key` in one pass.
+  Invoked to "pop" the value under `key` out of the given data structure.
 
-  The function must receive the value for the given `key`
-  (or `nil` if the key doesn't exist in `container`) and
-  the function must return a tuple containing the `get`
-  value and the new value to be stored in the `container`.
+  When `key` exists in the given structure `data`, the implementation should
+  return a `{value, new_data}` tuple where `value` is the value that was under
+  `key` and `new_data` is `term` without `key`.
+
+  When `key` is not present in the given structure, a tuple `{value, data}`
+  should be returned, where `value` is implementation-defined.
+
+  See the implementations for `Map.pop/3` or `Keyword.pop/3` for more examples.
   """
-  @spec get_and_update(t, term, (term -> {get, term})) :: {get, t} when get: var
-  def get_and_update(container, key, fun)
-end
+  @callback pop(data, key) :: {value, data} when data: container
+
+  defmacrop raise_undefined_behaviour(exception, module, top) do
+    quote do
+      exception =
+        case __STACKTRACE__ do
+          [unquote(top) | _] ->
+            reason =
+              """
+              #{inspect(unquote(module))} does not implement the Access behaviour
 
-defimpl Access, for: List do
-  def get(dict, key) when is_atom(key) do
-    case :lists.keyfind(key, 1, dict) do
-      {^key, value} -> value
-      false -> nil
+              You can use the "struct.field" syntax to access struct fields. \
+              You can also use Access.key!/1 to access struct fields dynamically \
+              inside get_in/put_in/update_in\
+              """
+
+            %{unquote(exception) | reason: reason}
+
+          _ ->
+            unquote(exception)
+        end
+
+      reraise exception, __STACKTRACE__
     end
   end
 
-  def get(_dict, key) do
-    raise ArgumentError,
-      "the access protocol for lists expect the key to be an atom, got: #{inspect key}"
+  @doc """
+  Fetches the value for the given key in a container (a map, keyword
+  list, or struct that implements the `Access` behaviour).
+
+  Returns `{:ok, value}` where `value` is the value under `key` if there is such
+  a key, or `:error` if `key` is not found.
+
+  ## Examples
+
+      iex> Access.fetch(%{name: "meg", age: 26}, :name)
+      {:ok, "meg"}
+
+      iex> Access.fetch([ordered: true, on_timeout: :exit], :timeout)
+      :error
+
+  """
+  @spec fetch(container, term) :: {:ok, term} | :error
+  @spec fetch(nil_container, any) :: :error
+  def fetch(container, key)
+
+  def fetch(%module{} = container, key) do
+    module.fetch(container, key)
+  rescue
+    exception in UndefinedFunctionError ->
+      raise_undefined_behaviour(exception, module, {^module, :fetch, [^container, ^key], _})
   end
 
-  def get_and_update(dict, key, fun) when is_atom(key) do
-    get_and_update(dict, [], key, fun)
+  def fetch(map, key) when is_map(map) do
+    case map do
+      %{^key => value} -> {:ok, value}
+      _ -> :error
+    end
   end
 
-  defp get_and_update([{key, value}|t], acc, key, fun) do
-    {get, update} = fun.(value)
-    {get, :lists.reverse(acc, [{key, update}|t])}
+  def fetch(list, key) when is_list(list) and is_atom(key) do
+    case :lists.keyfind(key, 1, list) do
+      {_, value} -> {:ok, value}
+      false -> :error
+    end
   end
 
-  defp get_and_update([h|t], acc, key, fun) do
-    get_and_update(t, [h|acc], key, fun)
+  def fetch(list, key) when is_list(list) do
+    raise ArgumentError,
+          "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
   end
 
-  defp get_and_update([], acc, key, fun) do
-    {get, update} = fun.(nil)
-    {get, [{key, update}|:lists.reverse(acc)]}
+  def fetch(nil, _key) do
+    :error
   end
-end
 
-defimpl Access, for: Map do
-  def get(map, key) do
-    case :maps.find(key, map) do
+  @doc """
+  Same as `fetch/2` but returns the value directly,
+  or raises a `KeyError` exception if `key` is not found.
+
+  ## Examples
+
+      iex> Access.fetch!(%{name: "meg", age: 26}, :name)
+      "meg"
+
+  """
+  @doc since: "1.10.0"
+  @spec fetch!(container, term) :: term
+  def fetch!(container, key) do
+    case fetch(container, key) do
       {:ok, value} -> value
-      :error -> nil
+      :error -> raise(KeyError, key: key, term: container)
     end
   end
 
-  def get_and_update(map, key, fun) do
-    value =
-      case :maps.find(key, map) do
-        {:ok, value} -> value
-        :error -> nil
-      end
+  @doc """
+  Gets the value for the given key in a container (a map, keyword
+  list, or struct that implements the `Access` behaviour).
 
-    {get, update} = fun.(value)
-    {get, :maps.put(key, update, map)}
-  end
+  Returns the value under `key` if there is such a key, or `default` if `key` is
+  not found.
+
+  ## Examples
 
-  def get!(%{} = map, key) do
-    case :maps.find(key, map) do
+      iex> Access.get(%{name: "john"}, :name, "default name")
+      "john"
+      iex> Access.get(%{name: "john"}, :age, 25)
+      25
+
+      iex> Access.get([ordered: true], :timeout)
+      nil
+
+  """
+  @spec get(container, term, term) :: term
+  @spec get(nil_container, any, default) :: default when default: var
+  def get(container, key, default \\ nil)
+
+  # Reimplementing the same logic as Access.fetch/2 here is done for performance, since
+  # this is called a lot and calling fetch/2 means introducing some overhead (like
+  # building the "{:ok, _}" tuple and deconstructing it back right away).
+
+  def get(%module{} = container, key, default) do
+    try do
+      module.fetch(container, key)
+    rescue
+      exception in UndefinedFunctionError ->
+        raise_undefined_behaviour(exception, module, {^module, :fetch, [^container, ^key], _})
+    else
       {:ok, value} -> value
-      :error -> raise KeyError, key: key, term: map
+      :error -> default
     end
   end
 
-  def get!(other, key) do
-    raise ArgumentError,
-      "could not get key #{inspect key}. Expected map/struct, got: #{inspect other}"
+  def get(map, key, default) when is_map(map) do
+    case map do
+      %{^key => value} -> value
+      _ -> default
+    end
   end
 
-  def get_and_update!(%{} = map, key, fun) do
-    case :maps.find(key, map) do
-      {:ok, value} ->
-        {get, update} = fun.(value)
-        {get, :maps.put(key, update, map)}
-      :error ->
-        raise KeyError, key: key, term: map
+  def get(list, key, default) when is_list(list) and is_atom(key) do
+    case :lists.keyfind(key, 1, list) do
+      {_, value} -> value
+      false -> default
     end
   end
 
-  def get_and_update!(other, key, _fun) do
+  def get(list, key, _default) when is_list(list) and is_integer(key) do
+    raise ArgumentError, """
+    the Access module does not support accessing lists by index, got: #{inspect(key)}
+
+    Accessing a list by index is typically discouraged in Elixir, \
+    instead we prefer to use the Enum module to manipulate lists \
+    as a whole. If you really must access a list element by index, \
+    you can use Enum.at/2 or the functions in the List module\
+    """
+  end
+
+  def get(list, key, _default) when is_list(list) do
+    raise ArgumentError, """
+    the Access module supports only keyword lists (with atom keys), got: #{inspect(key)}
+
+    If you want to search lists of tuples, use List.keyfind/3\
+    """
+  end
+
+  def get(nil, _key, default) do
+    default
+  end
+
+  @doc """
+  Gets and updates the given key in a `container` (a map, a keyword list,
+  a struct that implements the `Access` behaviour).
+
+  The `fun` argument receives the value of `key` (or `nil` if `key` is not
+  present in `container`) and must return a two-element tuple `{current_value, new_value}`:
+  the "get" value `current_value` (the retrieved value, which can be operated on before
+  being returned) and the new value to be stored under `key` (`new_value`).
+  `fun` may also return `:pop`, which means the current value
+  should be removed from the container and returned.
+
+  The returned value is a two-element tuple with the "get" value returned by
+  `fun` and a new container with the updated value under `key`.
+
+  ## Examples
+
+      iex> Access.get_and_update([a: 1], :a, fn current_value ->
+      ...>   {current_value, current_value + 1}
+      ...> end)
+      {1, [a: 2]}
+
+  """
+  @spec get_and_update(data, key, (value | nil -> {current_value, new_value :: value} | :pop)) ::
+          {current_value, new_data :: data}
+        when current_value: var, data: container
+  def get_and_update(container, key, fun)
+
+  def get_and_update(%module{} = container, key, fun) do
+    module.get_and_update(container, key, fun)
+  rescue
+    exception in UndefinedFunctionError ->
+      raise_undefined_behaviour(
+        exception,
+        module,
+        {^module, :get_and_update, [^container, ^key, ^fun], _}
+      )
+  end
+
+  def get_and_update(map, key, fun) when is_map(map) do
+    Map.get_and_update(map, key, fun)
+  end
+
+  def get_and_update(list, key, fun) when is_list(list) and is_atom(key) do
+    Keyword.get_and_update(list, key, fun)
+  end
+
+  def get_and_update(list, key, _fun) when is_list(list) and is_integer(key) do
+    raise ArgumentError, """
+    the Access module does not support accessing lists by index, got: #{inspect(key)}
+
+    Accessing a list by index is typically discouraged in Elixir, \
+    instead we prefer to use the Enum module to manipulate lists \
+    as a whole. If you really must modify a list element by index, \
+    you can use Access.at/1 or the functions in the List module\
+    """
+  end
+
+  def get_and_update(list, key, _fun) when is_list(list) do
     raise ArgumentError,
-      "could not update key #{inspect key}. Expected map/struct, got: #{inspect other}"
+          "the Access module supports only keyword lists (with atom keys), got: " <> inspect(key)
   end
-end
 
-defimpl Access, for: Atom do
-  def get(nil, _) do
-    nil
+  def get_and_update(nil, key, _fun) do
+    raise ArgumentError, "could not put/update key #{inspect(key)} on a nil value"
+  end
+
+  @doc """
+  Removes the entry with a given key from a container (a map, keyword
+  list, or struct that implements the `Access` behaviour).
+
+  Returns a tuple containing the value associated with the key and the
+  updated container. `nil` is returned for the value if the key isn't
+  in the container.
+
+  ## Examples
+
+  With a map:
+
+      iex> Access.pop(%{name: "Elixir", creator: "Valim"}, :name)
+      {"Elixir", %{creator: "Valim"}}
+
+  A keyword list:
+
+      iex> Access.pop([name: "Elixir", creator: "Valim"], :name)
+      {"Elixir", [creator: "Valim"]}
+
+  An unknown key:
+
+      iex> Access.pop(%{name: "Elixir", creator: "Valim"}, :year)
+      {nil, %{creator: "Valim", name: "Elixir"}}
+
+  """
+  @spec pop(data, key) :: {value, data} when data: container
+  def pop(%module{} = container, key) do
+    module.pop(container, key)
+  rescue
+    exception in UndefinedFunctionError ->
+      raise_undefined_behaviour(exception, module, {^module, :pop, [^container, ^key], _})
   end
 
-  def get(atom, _) do
-    undefined(atom)
+  def pop(map, key) when is_map(map) do
+    Map.pop(map, key)
   end
 
-  def get_and_update(nil, _, fun) do
-    fun.(nil)
+  def pop(list, key) when is_list(list) do
+    Keyword.pop(list, key)
   end
 
-  def get_and_update(atom, _key, _fun) do
-    undefined(atom)
+  def pop(nil, key) do
+    raise ArgumentError, "could not pop key #{inspect(key)} on a nil value"
   end
 
-  defp undefined(atom) do
-    raise Protocol.UndefinedError,
-      protocol: @protocol,
-      value: atom,
-      description: "only the nil atom is supported"
+  ## Accessors
+
+  @doc """
+  Returns a function that accesses the given key in a map/struct.
+
+  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
+  `Kernel.get_and_update_in/3`, and friends.
+
+  The returned function uses the default value if the key does not exist.
+  This can be used to specify defaults and safely traverse missing keys:
+
+      iex> get_in(%{}, [Access.key(:user, %{}), Access.key(:name, "meg")])
+      "meg"
+
+  Such is also useful when using update functions, allowing us to introduce
+  values as we traverse the data structure for updates:
+
+      iex> put_in(%{}, [Access.key(:user, %{}), Access.key(:name)], "Mary")
+      %{user: %{name: "Mary"}}
+
+  ## Examples
+
+      iex> map = %{user: %{name: "john"}}
+      iex> get_in(map, [Access.key(:unknown, %{}), Access.key(:name, "john")])
+      "john"
+      iex> get_and_update_in(map, [Access.key(:user), Access.key(:name)], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {"john", %{user: %{name: "JOHN"}}}
+      iex> pop_in(map, [Access.key(:user), Access.key(:name)])
+      {"john", %{user: %{}}}
+
+  An error is raised if the accessed structure is not a map or a struct:
+
+      iex> get_in([], [Access.key(:foo)])
+      ** (BadMapError) expected a map, got:
+      ...
+  """
+  @spec key(key, term) :: access_fun(data :: struct | map, current_value :: term)
+  def key(key, default \\ nil) do
+    fn
+      :get, data, next ->
+        next.(Map.get(data, key, default))
+
+      :get_and_update, data, next ->
+        value = Map.get(data, key, default)
+
+        case next.(value) do
+          {get, update} -> {get, Map.put(data, key, update)}
+          :pop -> {value, Map.delete(data, key)}
+        end
+    end
+  end
+
+  @doc """
+  Returns a function that accesses the given key in a map/struct.
+
+  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
+  `Kernel.get_and_update_in/3`, and friends.
+
+  Similar to `key/2`, but the returned function raises if the key does not exist.
+
+  ## Examples
+
+      iex> map = %{user: %{name: "john"}}
+      iex> get_in(map, [Access.key!(:user), Access.key!(:name)])
+      "john"
+      iex> get_and_update_in(map, [Access.key!(:user), Access.key!(:name)], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {"john", %{user: %{name: "JOHN"}}}
+      iex> pop_in(map, [Access.key!(:user), Access.key!(:name)])
+      {"john", %{user: %{}}}
+      iex> get_in(map, [Access.key!(:user), Access.key!(:unknown)])
+      ** (KeyError) key :unknown not found in:
+      ...
+
+  The examples above could be partially written as:
+
+      iex> map = %{user: %{name: "john"}}
+      iex> map.user.name
+      "john"
+      iex> get_and_update_in(map.user.name, fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {"john", %{user: %{name: "JOHN"}}}
+
+  However, it is not possible to remove fields using the dot notation,
+  as it is implied those fields must also be present. In any case,
+  `Access.key!/1` is useful when the key is not known in advance
+  and must be accessed dynamically.
+
+  An error is raised if the accessed structure is not a map/struct:
+
+      iex> get_in([], [Access.key!(:foo)])
+      ** (RuntimeError) Access.key!/1 expected a map/struct, got: []
+
+  """
+  @spec key!(key) :: access_fun(data :: struct | map, current_value :: term)
+  def key!(key) do
+    fn
+      :get, %{} = data, next ->
+        next.(Map.fetch!(data, key))
+
+      :get_and_update, %{} = data, next ->
+        value = Map.fetch!(data, key)
+
+        case next.(value) do
+          {get, update} -> {get, Map.put(data, key, update)}
+          :pop -> {value, Map.delete(data, key)}
+        end
+
+      _op, data, _next ->
+        raise "Access.key!/1 expected a map/struct, got: #{inspect(data)}"
+    end
+  end
+
+  @doc ~S"""
+  Returns a function that accesses the element at the given index in a tuple.
+
+  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
+  `Kernel.get_and_update_in/3`, and friends.
+
+  The returned function raises if `index` is out of bounds.
+
+  Note that popping elements out of tuples is not possible and raises an
+  error.
+
+  ## Examples
+
+      iex> map = %{user: {"john", 27}}
+      iex> get_in(map, [:user, Access.elem(0)])
+      "john"
+      iex> get_and_update_in(map, [:user, Access.elem(0)], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {"john", %{user: {"JOHN", 27}}}
+      iex> pop_in(map, [:user, Access.elem(0)])
+      ** (RuntimeError) cannot pop data from a tuple
+
+  An error is raised if the accessed structure is not a tuple:
+
+      iex> get_in(%{}, [Access.elem(0)])
+      ** (RuntimeError) Access.elem/1 expected a tuple, got: %{}
+
+  """
+  @spec elem(non_neg_integer) :: access_fun(data :: tuple, current_value :: term)
+  def elem(index) when is_integer(index) and index >= 0 do
+    pos = index + 1
+
+    fn
+      :get, data, next when is_tuple(data) ->
+        next.(:erlang.element(pos, data))
+
+      :get_and_update, data, next when is_tuple(data) ->
+        value = :erlang.element(pos, data)
+
+        case next.(value) do
+          {get, update} -> {get, :erlang.setelement(pos, data, update)}
+          :pop -> raise "cannot pop data from a tuple"
+        end
+
+      _op, data, _next ->
+        raise "Access.elem/1 expected a tuple, got: #{inspect(data)}"
+    end
+  end
+
+  @doc ~S"""
+  Returns a function that accesses all the elements in a list.
+
+  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
+  `Kernel.get_and_update_in/3`, and friends.
+
+  ## Examples
+
+      iex> list = [%{name: "john"}, %{name: "mary"}]
+      iex> get_in(list, [Access.all(), :name])
+      ["john", "mary"]
+      iex> get_and_update_in(list, [Access.all(), :name], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {["john", "mary"], [%{name: "JOHN"}, %{name: "MARY"}]}
+      iex> pop_in(list, [Access.all(), :name])
+      {["john", "mary"], [%{}, %{}]}
+
+  Here is an example that traverses the list dropping even
+  numbers and multiplying odd numbers by 2:
+
+      iex> require Integer
+      iex> get_and_update_in([1, 2, 3, 4, 5], [Access.all()], fn num ->
+      ...>   if Integer.is_even(num), do: :pop, else: {num, num * 2}
+      ...> end)
+      {[1, 2, 3, 4, 5], [2, 6, 10]}
+
+  An error is raised if the accessed structure is not a list:
+
+      iex> get_in(%{}, [Access.all()])
+      ** (RuntimeError) Access.all/0 expected a list, got: %{}
+
+  """
+  @spec all() :: access_fun(data :: list, current_value :: list)
+  def all() do
+    &all/3
+  end
+
+  defp all(:get, data, next) when is_list(data) do
+    Enum.map(data, next)
+  end
+
+  defp all(:get_and_update, data, next) when is_list(data) do
+    all(data, next, _gets = [], _updates = [])
+  end
+
+  defp all(_op, data, _next) do
+    raise "Access.all/0 expected a list, got: #{inspect(data)}"
+  end
+
+  defp all([head | rest], next, gets, updates) do
+    case next.(head) do
+      {get, update} -> all(rest, next, [get | gets], [update | updates])
+      :pop -> all(rest, next, [head | gets], updates)
+    end
+  end
+
+  defp all([], _next, gets, updates) do
+    {:lists.reverse(gets), :lists.reverse(updates)}
+  end
+
+  @doc ~S"""
+  Returns a function that accesses the element at `index` (zero based) of a list.
+
+  Keep in mind that index lookups in lists take linear time: the larger the list,
+  the longer it will take to access its index. Therefore index-based operations
+  are generally avoided in favor of other functions in the `Enum` module.
+
+  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
+  `Kernel.get_and_update_in/3`, and friends.
+
+  ## Examples
+
+      iex> list = [%{name: "john"}, %{name: "mary"}]
+      iex> get_in(list, [Access.at(1), :name])
+      "mary"
+      iex> get_in(list, [Access.at(-1), :name])
+      "mary"
+      iex> get_and_update_in(list, [Access.at(0), :name], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {"john", [%{name: "JOHN"}, %{name: "mary"}]}
+      iex> get_and_update_in(list, [Access.at(-1), :name], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {"mary", [%{name: "john"}, %{name: "MARY"}]}
+
+  `at/1` can also be used to pop elements out of a list or
+  a key inside of a list:
+
+      iex> list = [%{name: "john"}, %{name: "mary"}]
+      iex> pop_in(list, [Access.at(0)])
+      {%{name: "john"}, [%{name: "mary"}]}
+      iex> pop_in(list, [Access.at(0), :name])
+      {"john", [%{}, %{name: "mary"}]}
+
+  When the index is out of bounds, `nil` is returned and the update function is never called:
+
+      iex> list = [%{name: "john"}, %{name: "mary"}]
+      iex> get_in(list, [Access.at(10), :name])
+      nil
+      iex> get_and_update_in(list, [Access.at(10), :name], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {nil, [%{name: "john"}, %{name: "mary"}]}
+
+  An error is raised if the accessed structure is not a list:
+
+      iex> get_in(%{}, [Access.at(1)])
+      ** (RuntimeError) Access.at/1 expected a list, got: %{}
+
+  """
+  @spec at(integer) :: access_fun(data :: list, current_value :: term)
+  def at(index) when is_integer(index) do
+    fn op, data, next -> at(op, data, index, next) end
+  end
+
+  defp at(:get, data, index, next) when is_list(data) do
+    data |> Enum.at(index) |> next.()
+  end
+
+  defp at(:get_and_update, data, index, next) when is_list(data) do
+    get_and_update_at(data, index, next, [], fn -> nil end)
+  end
+
+  defp at(_op, data, _index, _next) do
+    raise "Access.at/1 expected a list, got: #{inspect(data)}"
+  end
+
+  defp get_and_update_at([head | rest], 0, next, updates, _default_fun) do
+    case next.(head) do
+      {get, update} -> {get, :lists.reverse([update | updates], rest)}
+      :pop -> {head, :lists.reverse(updates, rest)}
+    end
+  end
+
+  defp get_and_update_at([_ | _] = list, index, next, updates, default_fun) when index < 0 do
+    list_length = length(list)
+
+    if list_length + index >= 0 do
+      get_and_update_at(list, list_length + index, next, updates, default_fun)
+    else
+      {default_fun.(), list}
+    end
+  end
+
+  defp get_and_update_at([head | rest], index, next, updates, default_fun) when index > 0 do
+    get_and_update_at(rest, index - 1, next, [head | updates], default_fun)
+  end
+
+  defp get_and_update_at([], _index, _next, updates, default_fun) do
+    {default_fun.(), :lists.reverse(updates)}
+  end
+
+  @doc ~S"""
+  Same as `at/1` except that it raises `Enum.OutOfBoundsError`
+  if the given index is out of bounds.
+
+  ## Examples
+
+      iex> get_in([:a, :b, :c], [Access.at!(2)])
+      :c
+      iex> get_in([:a, :b, :c], [Access.at!(3)])
+      ** (Enum.OutOfBoundsError) out of bounds error at position 3 when traversing enumerable [:a, :b, :c]
+
+  """
+  @doc since: "1.11.0"
+  @spec at!(integer) :: access_fun(data :: list, current_value :: term)
+  def at!(index) when is_integer(index) do
+    fn op, data, next -> at!(op, data, index, next) end
+  end
+
+  defp at!(:get, data, index, next) when is_list(data) do
+    case Enum.fetch(data, index) do
+      {:ok, value} -> next.(value)
+      :error -> raise Enum.OutOfBoundsError, index: index, enumerable: data
+    end
+  end
+
+  defp at!(:get_and_update, data, index, next) when is_list(data) do
+    get_and_update_at(data, index, next, [], fn ->
+      raise Enum.OutOfBoundsError, index: index, enumerable: data
+    end)
+  end
+
+  defp at!(_op, data, _index, _next) do
+    raise "Access.at!/1 expected a list, got: #{inspect(data)}"
+  end
+
+  @doc ~S"""
+  Returns a function that accesses all elements of a list that match the provided predicate.
+
+  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
+  `Kernel.get_and_update_in/3`, and friends.
+
+  ## Examples
+
+      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
+      iex> get_in(list, [Access.filter(&(&1.salary > 20)), :name])
+      ["francine"]
+      iex> get_and_update_in(list, [Access.filter(&(&1.salary <= 20)), :name], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {["john"], [%{name: "JOHN", salary: 10}, %{name: "francine", salary: 30}]}
+
+  `filter/1` can also be used to pop elements out of a list or
+  a key inside of a list:
+
+      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
+      iex> pop_in(list, [Access.filter(&(&1.salary >= 20))])
+      {[%{name: "francine", salary: 30}], [%{name: "john", salary: 10}]}
+      iex> pop_in(list, [Access.filter(&(&1.salary >= 20)), :name])
+      {["francine"], [%{name: "john", salary: 10}, %{salary: 30}]}
+
+  When no match is found, an empty list is returned and the update function is never called
+
+      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
+      iex> get_in(list, [Access.filter(&(&1.salary >= 50)), :name])
+      []
+      iex> get_and_update_in(list, [Access.filter(&(&1.salary >= 50)), :name], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {[], [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]}
+
+  An error is raised if the predicate is not a function or is of the incorrect arity:
+
+      iex> get_in([], [Access.filter(5)])
+      ** (FunctionClauseError) no function clause matching in Access.filter/1
+
+  An error is raised if the accessed structure is not a list:
+
+      iex> get_in(%{}, [Access.filter(fn a -> a == 10 end)])
+      ** (RuntimeError) Access.filter/1 expected a list, got: %{}
+
+  """
+  @doc since: "1.6.0"
+  @spec filter((term -> boolean)) :: access_fun(data :: list, current_value :: list)
+  def filter(func) when is_function(func) do
+    fn op, data, next -> filter(op, data, func, next) end
+  end
+
+  defp filter(:get, data, func, next) when is_list(data) do
+    for elem <- data, func.(elem), do: next.(elem)
+  end
+
+  defp filter(:get_and_update, data, func, next) when is_list(data) do
+    get_and_update_filter(data, func, next, [], [])
+  end
+
+  defp filter(_op, data, _func, _next) do
+    raise "Access.filter/1 expected a list, got: #{inspect(data)}"
+  end
+
+  defp get_and_update_filter([head | rest], func, next, updates, gets) do
+    if func.(head) do
+      case next.(head) do
+        {get, update} ->
+          get_and_update_filter(rest, func, next, [update | updates], [get | gets])
+
+        :pop ->
+          get_and_update_filter(rest, func, next, updates, [head | gets])
+      end
+    else
+      get_and_update_filter(rest, func, next, [head | updates], gets)
+    end
+  end
+
+  defp get_and_update_filter([], _func, _next, updates, gets) do
+    {:lists.reverse(gets), :lists.reverse(updates)}
+  end
+
+  @doc ~S"""
+  Returns a function that accesses all items of a list that are within the provided range.
+
+  The range will be normalized following the same rules from `Enum.slice/2`.
+
+  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
+  `Kernel.get_and_update_in/3`, and friends.
+
+  ## Examples
+
+      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}, %{name: "vitor", salary: 25}]
+      iex> get_in(list, [Access.slice(1..2), :name])
+      ["francine", "vitor"]
+      iex> get_and_update_in(list, [Access.slice(1..3//2), :name], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {["francine"], [%{name: "john", salary: 10}, %{name: "FRANCINE", salary: 30}, %{name: "vitor", salary: 25}]}
+
+  `slice/1` can also be used to pop elements out of a list or
+  a key inside of a list:
+
+      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}, %{name: "vitor", salary: 25}]
+      iex> pop_in(list, [Access.slice(-2..-1)])
+      {[%{name: "francine", salary: 30}, %{name: "vitor", salary: 25}], [%{name: "john", salary: 10}]}
+      iex> pop_in(list, [Access.slice(-2..-1), :name])
+      {["francine", "vitor"], [%{name: "john", salary: 10}, %{salary: 30}, %{salary: 25}]}
+
+  When no match is found, an empty list is returned and the update function is never called
+
+      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}, %{name: "vitor", salary: 25}]
+      iex> get_in(list, [Access.slice(5..10//2), :name])
+      []
+      iex> get_and_update_in(list, [Access.slice(5..10//2), :name], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {[], [%{name: "john", salary: 10}, %{name: "francine", salary: 30}, %{name: "vitor", salary: 25}]}
+
+  An error is raised if the accessed structure is not a list:
+
+      iex> get_in(%{}, [Access.slice(2..10//3)])
+      ** (ArgumentError) Access.slice/1 expected a list, got: %{}
+
+  An error is raised if the step of the range is negative:
+
+      iex> get_in([], [Access.slice(2..10//-1)])
+      ** (ArgumentError) Access.slice/1 does not accept ranges with negative steps, got: 2..10//-1
+
+  """
+  @doc since: "1.14"
+  @spec slice(Range.t()) :: access_fun(data :: list, current_value :: list)
+  def slice(%Range{} = range) do
+    if range.step > 0 do
+      fn op, data, next -> slice(op, data, range, next) end
+    else
+      raise ArgumentError,
+            "Access.slice/1 does not accept ranges with negative steps, got: #{inspect(range)}"
+    end
+  end
+
+  defp slice(:get, data, %Range{} = range, next) when is_list(data) do
+    data
+    |> Enum.slice(range)
+    |> Enum.map(next)
+  end
+
+  defp slice(:get_and_update, data, range, next) when is_list(data) do
+    range = normalize_range(range, data)
+
+    if range.first > range.last do
+      {[], data}
+    else
+      get_and_update_slice(data, range, next, [], [], 0)
+    end
+  end
+
+  defp slice(_op, data, _range, _next) do
+    raise ArgumentError, "Access.slice/1 expected a list, got: #{inspect(data)}"
+  end
+
+  @doc """
+  Returns a function that accesses all values in a map or a keyword list.
+
+  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
+  `Kernel.get_and_update_in/3`, and friends.
+
+  ## Examples
+
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_in(users, [Access.values(), :age]) |> Enum.sort()
+      [23, 27]
+      iex> update_in(users, [Access.values(), :age], fn age -> age + 1 end)
+      %{"john" => %{age: 28}, "meg" => %{age: 24}}
+      iex> put_in(users, [Access.values(), :planet], "Earth")
+      %{"john" => %{age: 27, planet: "Earth"}, "meg" => %{age: 23, planet: "Earth"}}
+
+  Values in keyword lists can be accessed as well:
+
+      iex> users = [john: %{age: 27}, meg: %{age: 23}]
+      iex> get_and_update_in(users, [Access.values(), :age], fn age -> {age, age + 1} end)
+      {[27, 23], [john: %{age: 28}, meg: %{age: 24}]}
+
+  By returning `:pop` from an accessor function, you can remove the accessed key and value
+  from the map or keyword list:
+
+      iex> require Integer
+      iex> numbers = [one: 1, two: 2, three: 3, four: 4]
+      iex> get_and_update_in(numbers, [Access.values()], fn num ->
+      ...>   if Integer.is_even(num), do: :pop, else: {num, to_string(num)}
+      ...> end)
+      {[1, 2, 3, 4], [one: "1", three: "3"]}
+
+  An error is raised if the accessed structure is not a map nor a keyword list:
+
+      iex> get_in([1, 2, 3], [Access.values()])
+      ** (RuntimeError) Access.values/0 expected a map or a keyword list, got: [1, 2, 3]
+  """
+  @doc since: "1.19.0"
+  @spec values() :: Access.access_fun(data :: map() | keyword(), current_value :: list())
+  def values do
+    &values/3
+  end
+
+  defp values(:get, data = %{}, next) do
+    Enum.map(data, fn {_key, value} -> next.(value) end)
+  end
+
+  defp values(:get_and_update, data = %{}, next) do
+    {reverse_gets, updated_data} =
+      Enum.reduce(data, {[], %{}}, fn {key, value}, {gets, data_acc} ->
+        case next.(value) do
+          {get, update} -> {[get | gets], Map.put(data_acc, key, update)}
+          :pop -> {[value | gets], data_acc}
+        end
+      end)
+
+    {Enum.reverse(reverse_gets), updated_data}
+  end
+
+  defp values(op, data = [], next) do
+    values_keyword(op, data, next)
+  end
+
+  defp values(op, data = [{key, _value} | _tail], next) when is_atom(key) do
+    values_keyword(op, data, next)
+  end
+
+  defp values(_op, data, _next) do
+    raise "Access.values/0 expected a map or a keyword list, got: #{inspect(data)}"
+  end
+
+  defp values_keyword(:get, data, next) do
+    Enum.map(data, fn {key, value} when is_atom(key) -> next.(value) end)
+  end
+
+  defp values_keyword(:get_and_update, data, next) do
+    {reverse_gets, reverse_updated_data} =
+      Enum.reduce(data, {[], []}, fn {key, value}, {gets, data_acc} when is_atom(key) ->
+        case next.(value) do
+          {get, update} -> {[get | gets], [{key, update} | data_acc]}
+          :pop -> {[value | gets], data_acc}
+        end
+      end)
+
+    {Enum.reverse(reverse_gets), Enum.reverse(reverse_updated_data)}
+  end
+
+  defp normalize_range(%Range{first: first, last: last, step: step}, list)
+       when first < 0 or last < 0 do
+    count = length(list)
+    first = if first >= 0, do: first, else: Kernel.max(first + count, 0)
+    last = if last >= 0, do: last, else: last + count
+    Range.new(first, last, step)
+  end
+
+  defp normalize_range(range, _list), do: range
+
+  defp get_and_update_slice([head | rest], range, next, updates, gets, index) do
+    if index in range do
+      case next.(head) do
+        :pop ->
+          get_and_update_slice(rest, range, next, updates, [head | gets], index + 1)
+
+        {get, update} ->
+          get_and_update_slice(
+            rest,
+            range,
+            next,
+            [update | updates],
+            [get | gets],
+            index + 1
+          )
+      end
+    else
+      get_and_update_slice(rest, range, next, [head | updates], gets, index + 1)
+    end
+  end
+
+  defp get_and_update_slice([], _range, _next, updates, gets, _index) do
+    {:lists.reverse(gets), :lists.reverse(updates)}
+  end
+
+  @doc ~S"""
+  Returns a function that accesses the first element of a list that matches the provided predicate.
+
+  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
+  `Kernel.get_and_update_in/3`, and friends.
+
+  ## Examples
+
+      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
+      iex> get_in(list, [Access.find(&(&1.salary > 20)), :name])
+      "francine"
+      iex> get_and_update_in(list, [Access.find(&(&1.salary <= 40)), :name], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {"john", [%{name: "JOHN", salary: 10}, %{name: "francine", salary: 30}]}
+
+  `find/1` can also be used to pop the first found element out of a list or
+  a key inside of a list:
+
+      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
+      iex> pop_in(list, [Access.find(&(&1.salary <= 40))])
+      {%{name: "john", salary: 10}, [%{name: "francine", salary: 30}]}
+
+  When no match is found, nil is returned and the update function is never called
+
+      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
+      iex> get_in(list, [Access.find(&(&1.salary >= 50)), :name])
+      nil
+      iex> get_and_update_in(list, [Access.find(&(&1.salary >= 50)), :name], fn prev ->
+      ...>   {prev, String.upcase(prev)}
+      ...> end)
+      {nil, [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]}
+
+  An error is raised if the predicate is not a function or is of the incorrect arity:
+
+      iex> get_in([], [Access.find(5)])
+      ** (FunctionClauseError) no function clause matching in Access.find/1
+
+  An error is raised if the accessed structure is not a list:
+
+      iex> get_in(%{}, [Access.find(fn a -> a == 10 end)])
+      ** (RuntimeError) Access.find/1 expected a list, got: %{}
+  """
+  @doc since: "1.17.0"
+  @spec find((term -> as_boolean(term))) :: access_fun(data :: list, current_value :: term)
+  def find(predicate) when is_function(predicate, 1) do
+    fn op, data, next -> find(op, data, predicate, next) end
+  end
+
+  defp find(:get, data, predicate, next) when is_list(data) do
+    data |> Enum.find(predicate) |> next.()
+  end
+
+  defp find(:get_and_update, data, predicate, next) when is_list(data) do
+    get_and_update_find(data, [], predicate, next)
+  end
+
+  defp find(_op, data, _predicate, _next) do
+    raise "Access.find/1 expected a list, got: #{inspect(data)}"
+  end
+
+  defp get_and_update_find([], updates, _predicate, _next) do
+    {nil, :lists.reverse(updates)}
+  end
+
+  defp get_and_update_find([head | rest], updates, predicate, next) do
+    if predicate.(head) do
+      case next.(head) do
+        {get, update} -> {get, :lists.reverse([update | updates], rest)}
+        :pop -> {head, :lists.reverse(updates, rest)}
+      end
+    else
+      get_and_update_find(rest, [head | updates], predicate, next)
+    end
   end
 end
diff --git a/lib/elixir/lib/agent.ex b/lib/elixir/lib/agent.ex
index 628f0675f79..df0cbd3e534 100644
--- a/lib/elixir/lib/agent.ex
+++ b/lib/elixir/lib/agent.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Agent do
   @moduledoc """
   Agents are a simple abstraction around state.
@@ -6,41 +10,61 @@ defmodule Agent do
   must be accessed from different processes or by the same process
   at different points in time.
 
-  The Agent module provides a basic server implementation that
+  The `Agent` module provides a basic server implementation that
   allows state to be retrieved and updated via a simple API.
 
   ## Examples
 
-  For example, in the Mix tool that ships with Elixir, we need
-  to keep a set of all tasks executed by a given project. Since
-  this set is shared, we can implement it with an Agent:
+  For example, the following agent implements a counter:
+
+      defmodule Counter do
+        use Agent
 
-      defmodule Mix.TasksServer do
-        def start_link do
-          Agent.start_link(fn -> HashSet.new end, name: __MODULE__)
+        def start_link(initial_value) do
+          Agent.start_link(fn -> initial_value end, name: __MODULE__)
         end
 
-        @doc "Checks if the task has already executed"
-        def executed?(task, project) do
-          item = {task, project}
-          Agent.get(__MODULE__, fn set ->
-            item in set
-          end)
+        def value do
+          Agent.get(__MODULE__, & &1)
         end
 
-        @doc "Marks a task as executed"
-        def put_task(task, project) do
-          item = {task, project}
-          Agent.update(__MODULE__, &Set.put(&1, item))
+        def increment do
+          Agent.update(__MODULE__, &(&1 + 1))
         end
       end
 
-  Note that agents still provide a segregation between the
-  client and server APIs, as seen in GenServers. In particular,
-  all code inside the function passed to the agent is executed
-  by the agent. This distinction is important because you may
-  want to avoid expensive operations inside the agent, as it will
-  effectively block the agent until the request is fulfilled.
+  Usage would be:
+
+      Counter.start_link(0)
+      #=> {:ok, #PID<0.123.0>}
+
+      Counter.value()
+      #=> 0
+
+      Counter.increment()
+      #=> :ok
+
+      Counter.increment()
+      #=> :ok
+
+      Counter.value()
+      #=> 2
+
+  Thanks to the agent server process, the counter can be safely incremented
+  concurrently.
+
+  > #### `use Agent` {: .info}
+  >
+  > When you `use Agent`, the `Agent` module will define a
+  > `child_spec/1` function, so your module can be used
+  > as a child in a supervision tree.
+
+  Agents provide a segregation between the client and server APIs (similar to
+  `GenServer`s). In particular, the functions passed as arguments to the calls to
+  `Agent` functions are invoked inside the agent (the server). This distinction
+  is important because you may want to avoid expensive operations inside the
+  agent, as they will effectively block the agent until the request is
+  fulfilled.
 
   Consider these two examples:
 
@@ -51,51 +75,112 @@ defmodule Agent do
 
       # Compute in the agent/client
       def get_something(agent) do
-        Agent.get(agent, &(&1)) |> do_something_expensive()
+        Agent.get(agent, & &1) |> do_something_expensive()
       end
 
-  The first one blocks the agent while the second one copies
-  all the state to the client and executes the operation in the client.
-  The trade-off here is exactly if the data is small enough to be
-  sent to the client cheaply or large enough to require processing on
-  the server (or at least some initial processing).
+  The first function blocks the agent. The second function copies all the state
+  to the client and then executes the operation in the client. One aspect to
+  consider is whether the data is large enough to require processing in the server,
+  at least initially, or small enough to be sent to the client cheaply. Another
+  factor is whether the data needs to be processed atomically: getting the
+  state and calling `do_something_expensive(state)` outside of the agent means
+  that the agent's state can be updated in the meantime. This is specially
+  important in case of updates as computing the new state in the client rather
+  than in the server can lead to race conditions if multiple clients are trying
+  to update the same state to different values.
+
+  ## How to supervise
+
+  An `Agent` is most commonly started under a supervision tree.
+  When we invoke `use Agent`, it automatically defines a `child_spec/1`
+  function that allows us to start the agent directly under a supervisor.
+  To start an agent under a supervisor with an initial counter of 0,
+  one may do:
+
+      children = [
+        {Counter, 0}
+      ]
+
+      Supervisor.start_link(children, strategy: :one_for_all)
+
+  While one could also simply pass the `Counter` as a child to the supervisor,
+  such as:
+
+      children = [
+        Counter # Same as {Counter, []}
+      ]
+
+      Supervisor.start_link(children, strategy: :one_for_all)
+
+  The definition above wouldn't work for this particular example,
+  as it would attempt to start the counter with an initial value
+  of an empty list. However, this may be a viable option in your
+  own agents. A common approach is to use a keyword list, as that
+  would allow setting the initial value and giving a name to the
+  counter process, for example:
+
+      def start_link(opts) do
+        {initial_value, opts} = Keyword.pop(opts, :initial_value, 0)
+        Agent.start_link(fn -> initial_value end, opts)
+      end
+
+  and then you can use `Counter`, `{Counter, name: :my_counter}` or
+  even `{Counter, initial_value: 0, name: :my_counter}` as a child
+  specification.
+
+  `use Agent` also accepts a list of options which configures the
+  child specification and therefore how it runs under a supervisor.
+  The generated `child_spec/1` can be customized with the following options:
 
-  ## Name Registration
+    * `:id` - the child specification identifier, defaults to the current module
+    * `:restart` - when the child should be restarted, defaults to `:permanent`
+    * `:shutdown` - how to shut down the child, either immediately or by giving it time to shut down
 
-  An Agent is bound to the same name registration rules as GenServers.
-  Read more about it in the `GenServer` docs.
+  For example:
+
+      use Agent, restart: :transient, shutdown: 10_000
+
+  See the "Child specification" section in the `Supervisor` module for more
+  detailed information. The `@doc` annotation immediately preceding
+  `use Agent` will be attached to the generated `child_spec/1` function.
+
+  ## Name registration
+
+  An agent is bound to the same name registration rules as GenServers.
+  Read more about it in the `GenServer` documentation.
 
   ## A word on distributed agents
 
   It is important to consider the limitations of distributed agents. Agents
-  work by sending anonymous functions between the caller and the agent.
-  In a distributed setup with multiple nodes, agents only work if the caller
-  (client) and the agent have the same version of a given module.
-
-  This setup may exhibit issues when doing "rolling upgrades". By rolling
-  upgrades we mean the following situation: you wish to deploy a new version of
-  your software by *shutting down* some of your nodes and replacing them with
-  nodes running a new version of the software. In this setup, part of your
-  environment will have one version of a given module and the other part
-  another version (the newer one) of the same module; this may cause agents to
-  crash. That said, if you plan to run in distributed environments, agents
-  should likely be avoided.
-
-  Note, however, that agents work fine if you want to perform hot code
-  swapping, as it keeps both the old and new versions of a given module.
-  We detail how to do hot code swapping with agents in the next section.
+  provide two APIs, one that works with anonymous functions and another
+  that expects an explicit module, function, and arguments.
+
+  In a distributed setup with multiple nodes, the API that accepts anonymous
+  functions only works if the caller (client) and the agent have the same
+  version of the caller module.
+
+  Keep in mind this issue also shows up when performing "rolling upgrades"
+  with agents. By rolling upgrades we mean the following situation: you wish
+  to deploy a new version of your software by *shutting down* some of your
+  nodes and replacing them with nodes running a new version of the software.
+  In this setup, part of your environment will have one version of a given
+  module and the other part another version (the newer one) of the same module.
+
+  The best solution is to simply use the explicit module, function, and arguments
+  APIs when working with distributed agents.
 
   ## Hot code swapping
 
   An agent can have its code hot swapped live by simply passing a module,
-  function and args tuple to the update instruction. For example, imagine
+  function, and arguments tuple to the update instruction. For example, imagine
   you have an agent named `:sample` and you want to convert its inner state
-  from some dict structure to a map. It can be done with the following
+  from a keyword list to a map. It can be done with the following
   instruction:
 
       {:update, :sample, {:advanced, {Enum, :into, [%{}]}}}
 
-  The agent's state will be added to the given list as the first argument.
+  The agent's state will be added to the given list of arguments (`[%{}]`) as
+  the first argument.
   """
 
   @typedoc "Return values of `start*` functions"
@@ -111,13 +196,50 @@ defmodule Agent do
   @type state :: term
 
   @doc """
-  Starts an agent linked to the current process.
+  Returns a specification to start an agent under a supervisor.
+
+  See the "Child specification" section in the `Supervisor` module for more detailed information.
+  """
+  @doc since: "1.5.0"
+  def child_spec(arg) do
+    %{
+      id: Agent,
+      start: {Agent, :start_link, [arg]}
+    }
+  end
+
+  @doc false
+  defmacro __using__(opts) do
+    quote location: :keep, bind_quoted: [opts: opts] do
+      if not Module.has_attribute?(__MODULE__, :doc) do
+        @doc """
+        Returns a specification to start this module under a supervisor.
+
+        See `Supervisor`.
+        """
+      end
+
+      def child_spec(arg) do
+        default = %{
+          id: __MODULE__,
+          start: {__MODULE__, :start_link, [arg]}
+        }
+
+        Supervisor.child_spec(default, unquote(Macro.escape(opts)))
+      end
+
+      defoverridable child_spec: 1
+    end
+  end
+
+  @doc """
+  Starts an agent linked to the current process with the given function.
 
   This is often used to start the agent as part of a supervision tree.
 
-  Once the agent is spawned, the given function is invoked and its return
-  value is used as the agent state. Note that `start_link` does not return
-  until the given function has returned.
+  Once the agent is spawned, the given function `fun` is invoked in the server
+  process, and should return the initial agent state. Note that `start_link/2`
+  does not return until the given function has returned.
 
   ## Options
 
@@ -129,7 +251,7 @@ defmodule Agent do
   and the start function will return `{:error, :timeout}`.
 
   If the `:debug` option is present, the corresponding function in the
-  [`:sys` module](http://www.erlang.org/doc/man/sys.html) will be invoked.
+  [`:sys` module](`:sys`) will be invoked.
 
   If the `:spawn_opt` option is present, its value will be passed as options
   to the underlying process as in `Process.spawn/4`.
@@ -137,36 +259,86 @@ defmodule Agent do
   ## Return values
 
   If the server is successfully created and initialized, the function returns
-  `{:ok, pid}`, where `pid` is the pid of the server. If there already exists
-  an agent with the specified name, the function returns
-  `{:error, {:already_started, pid}}` with the pid of that process.
+  `{:ok, pid}`, where `pid` is the PID of the server. If an agent with the
+  specified name already exists, the function returns
+  `{:error, {:already_started, pid}}` with the PID of that process.
+
+  If the given function callback fails, the function returns `{:error, reason}`.
+
+  ## Examples
+
+      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
+      iex> Agent.get(pid, fn state -> state end)
+      42
+
+      iex> {:error, {exception, _stacktrace}} = Agent.start(fn -> raise "oops" end)
+      iex> exception
+      %RuntimeError{message: "oops"}
 
-  If the given function callback fails with `reason`, the function returns
-  `{:error, reason}`.
   """
-  @spec start_link((() -> term), GenServer.options) :: on_start
+  @spec start_link((-> term), GenServer.options()) :: on_start
   def start_link(fun, options \\ []) when is_function(fun, 0) do
     GenServer.start_link(Agent.Server, fun, options)
   end
 
+  @doc """
+  Starts an agent linked to the current process.
+
+  Same as `start_link/2` but a module, function, and arguments are expected
+  instead of an anonymous function; `fun` in `module` will be called with the
+  given arguments `args` to initialize the state.
+  """
+  @spec start_link(module, atom, [term], GenServer.options()) :: on_start
+  def start_link(module, fun, args, options \\ []) do
+    GenServer.start_link(Agent.Server, {module, fun, args}, options)
+  end
+
   @doc """
   Starts an agent process without links (outside of a supervision tree).
 
   See `start_link/2` for more information.
+
+  ## Examples
+
+      iex> {:ok, pid} = Agent.start(fn -> 42 end)
+      iex> Agent.get(pid, fn state -> state end)
+      42
+
   """
-  @spec start((() -> term), GenServer.options) :: on_start
+  @spec start((-> term), GenServer.options()) :: on_start
   def start(fun, options \\ []) when is_function(fun, 0) do
     GenServer.start(Agent.Server, fun, options)
   end
 
   @doc """
-  Gets the agent value and executes the given function.
+  Starts an agent without links with the given module, function, and arguments.
+
+  See `start_link/4` for more information.
+  """
+  @spec start(module, atom, [term], GenServer.options()) :: on_start
+  def start(module, fun, args, options \\ []) do
+    GenServer.start(Agent.Server, {module, fun, args}, options)
+  end
+
+  @doc """
+  Gets an agent value via the given anonymous function.
 
   The function `fun` is sent to the `agent` which invokes the function
   passing the agent state. The result of the function invocation is
-  returned.
+  returned from this function.
+
+  `timeout` is an integer greater than zero which specifies how many
+  milliseconds are allowed before the agent executes the function and returns
+  the result value, or the atom `:infinity` to wait indefinitely. If no result
+  is received within the specified time, the function call fails and the caller
+  exits.
+
+  ## Examples
+
+      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
+      iex> Agent.get(pid, fn state -> state end)
+      42
 
-  A timeout can also be specified (it has a default value of 5000).
   """
   @spec get(agent, (state -> a), timeout) :: a when a: var
   def get(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -174,14 +346,40 @@ defmodule Agent do
   end
 
   @doc """
-  Gets and updates the agent state in one operation.
+  Gets an agent value via the given function.
+
+  Same as `get/3` but a module, function, and arguments are expected
+  instead of an anonymous function. The state is added as first
+  argument to the given list of arguments.
+  """
+  @spec get(agent, module, atom, [term], timeout) :: term
+  def get(agent, module, fun, args, timeout \\ 5000) do
+    GenServer.call(agent, {:get, {module, fun, args}}, timeout)
+  end
+
+  @doc """
+  Gets and updates the agent state in one operation via the given anonymous
+  function.
 
   The function `fun` is sent to the `agent` which invokes the function
   passing the agent state. The function must return a tuple with two
-  elements, the first being the value to return (i.e. the `get` value)
-  and the second one is the new state.
+  elements, the first being the value to return (that is, the "get" value)
+  and the second one being the new state of the agent.
+
+  `timeout` is an integer greater than zero which specifies how many
+  milliseconds are allowed before the agent executes the function and returns
+  the result value, or the atom `:infinity` to wait indefinitely. If no result
+  is received within the specified time, the function call fails and the caller
+  exits.
+
+  ## Examples
+
+      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
+      iex> Agent.get_and_update(pid, fn state -> {state, state + 1} end)
+      42
+      iex> Agent.get(pid, fn state -> state end)
+      43
 
-  A timeout can also be specified (it has a default value of 5000).
   """
   @spec get_and_update(agent, (state -> {a, state}), timeout) :: a when a: var
   def get_and_update(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -189,40 +387,132 @@ defmodule Agent do
   end
 
   @doc """
-  Updates the agent state.
+  Gets and updates the agent state in one operation via the given function.
+
+  Same as `get_and_update/3` but a module, function, and arguments are expected
+  instead of an anonymous function. The state is added as first
+  argument to the given list of arguments.
+  """
+  @spec get_and_update(agent, module, atom, [term], timeout) :: term
+  def get_and_update(agent, module, fun, args, timeout \\ 5000) do
+    GenServer.call(agent, {:get_and_update, {module, fun, args}}, timeout)
+  end
+
+  @doc """
+  Updates the agent state via the given anonymous function.
 
   The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The function must return the new state.
+  passing the agent state. The return value of `fun` becomes the new
+  state of the agent.
 
-  A timeout can also be specified (it has a default value of 5000).
   This function always returns `:ok`.
+
+  `timeout` is an integer greater than zero which specifies how many
+  milliseconds are allowed before the agent executes the function and returns
+  the result value, or the atom `:infinity` to wait indefinitely. If no result
+  is received within the specified time, the function call fails and the caller
+  exits.
+
+  ## Examples
+
+      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
+      iex> Agent.update(pid, fn state -> state + 1 end)
+      :ok
+      iex> Agent.get(pid, fn state -> state end)
+      43
+
   """
-  @spec update(agent, (state -> state)) :: :ok
+  @spec update(agent, (state -> state), timeout) :: :ok
   def update(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
     GenServer.call(agent, {:update, fun}, timeout)
   end
 
   @doc """
-  Performs a cast (fire and forget) operation on the agent state.
+  Updates the agent state via the given function.
+
+  Same as `update/3` but a module, function, and arguments are expected
+  instead of an anonymous function. The state is added as first
+  argument to the given list of arguments.
+
+  ## Examples
+
+      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
+      iex> Agent.update(pid, Kernel, :+, [12])
+      :ok
+      iex> Agent.get(pid, fn state -> state end)
+      54
+
+  """
+  @spec update(agent, module, atom, [term], timeout) :: :ok
+  def update(agent, module, fun, args, timeout \\ 5000) do
+    GenServer.call(agent, {:update, {module, fun, args}}, timeout)
+  end
+
+  @doc """
+  Performs a cast (*fire and forget*) operation on the agent state.
 
   The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The function must return the new state.
+  passing the agent state. The return value of `fun` becomes the new
+  state of the agent.
+
+  Note that `cast` returns `:ok` immediately, regardless of whether `agent` (or
+  the node it should live on) exists.
+
+  ## Examples
+
+      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
+      iex> Agent.cast(pid, fn state -> state + 1 end)
+      :ok
+      iex> Agent.get(pid, fn state -> state end)
+      43
 
-  Note that `cast` returns `:ok` immediately, regardless of whether the
-  destination node or agent exists.
   """
   @spec cast(agent, (state -> state)) :: :ok
   def cast(agent, fun) when is_function(fun, 1) do
-    GenServer.cast(agent, fun)
+    GenServer.cast(agent, {:cast, fun})
+  end
+
+  @doc """
+  Performs a cast (*fire and forget*) operation on the agent state.
+
+  Same as `cast/2` but a module, function, and arguments are expected
+  instead of an anonymous function. The state is added as first
+  argument to the given list of arguments.
+
+  ## Examples
+
+      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
+      iex> Agent.cast(pid, Kernel, :+, [12])
+      :ok
+      iex> Agent.get(pid, fn state -> state end)
+      54
+
+  """
+  @spec cast(agent, module, atom, [term]) :: :ok
+  def cast(agent, module, fun, args) do
+    GenServer.cast(agent, {:cast, {module, fun, args}})
   end
 
   @doc """
-  Stops the agent.
+  Synchronously stops the agent with the given `reason`.
+
+  It returns `:ok` if the agent terminates with the given
+  reason. If the agent terminates with another reason, the call will
+  exit.
+
+  This function keeps OTP semantics regarding error reporting.
+  If the reason is any other than `:normal`, `:shutdown` or
+  `{:shutdown, _}`, an error report will be logged.
+
+  ## Examples
+
+      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
+      iex> Agent.stop(pid)
+      :ok
 
-  Returns `:ok` if the agent is stopped within the given `timeout`.
   """
-  @spec stop(agent, timeout) :: :ok
-  def stop(agent, timeout \\ 5000) do
-    GenServer.call(agent, :stop, timeout)
+  @spec stop(agent, reason :: term, timeout) :: :ok
+  def stop(agent, reason \\ :normal, timeout \\ :infinity) do
+    GenServer.stop(agent, reason, timeout)
   end
 end
diff --git a/lib/elixir/lib/agent/server.ex b/lib/elixir/lib/agent/server.ex
index 0b06e4cddbe..cba85b49ac9 100644
--- a/lib/elixir/lib/agent/server.ex
+++ b/lib/elixir/lib/agent/server.ex
@@ -1,53 +1,55 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Agent.Server do
   @moduledoc false
 
   use GenServer
 
   def init(fun) do
-    {:ok, fun.()}
+    _ = initial_call(fun)
+    {:ok, run(fun, [])}
   end
 
   def handle_call({:get, fun}, _from, state) do
-    {:reply, fun.(state), state}
+    {:reply, run(fun, [state]), state}
   end
 
   def handle_call({:get_and_update, fun}, _from, state) do
-    {reply, state} = fun.(state)
-    {:reply, reply, state}
+    case run(fun, [state]) do
+      {reply, state} -> {:reply, reply, state}
+      other -> {:stop, {:bad_return_value, other}, state}
+    end
   end
 
   def handle_call({:update, fun}, _from, state) do
-    {:reply, :ok, fun.(state)}
+    {:reply, :ok, run(fun, [state])}
   end
 
-  def handle_call(:stop, _from, state) do
-    {:stop, :normal, :ok, state}
+  def handle_cast({:cast, fun}, state) do
+    {:noreply, run(fun, [state])}
   end
 
-  def handle_call(msg, from, state) do
-    super(msg, from, state)
+  def code_change(_old, state, fun) do
+    {:ok, run(fun, [state])}
   end
 
-  def handle_cast(fun, state) when is_function(fun, 1) do
-    {:noreply, fun.(state)}
+  defp initial_call(mfa) do
+    _ = Process.put(:"$initial_call", get_initial_call(mfa))
+    :ok
   end
 
-  def handle_cast(msg, state) do
-    super(msg, state)
+  defp get_initial_call(fun) when is_function(fun, 0) do
+    {:module, module} = Function.info(fun, :module)
+    {:name, name} = Function.info(fun, :name)
+    {module, name, 0}
   end
 
-  def code_change(_old, state, { m, f, a }) do
-    {:ok, apply(m, f, [state|a])}
+  defp get_initial_call({mod, fun, args}) do
+    {mod, fun, length(args)}
   end
 
-  def terminate(_reason, _state) do
-    # There is a race condition if the agent is
-    # restarted too fast and it is registered.
-    try do
-      self |> :erlang.process_info(:registered_name) |> elem(1) |> Process.unregister
-    rescue
-      _ -> :ok
-    end
-    :ok
-  end
+  defp run({m, f, a}, extra), do: apply(m, f, extra ++ a)
+  defp run(fun, extra), do: apply(fun, extra)
 end
diff --git a/lib/elixir/lib/application.ex b/lib/elixir/lib/application.ex
index 691704e0258..de8fe127fa6 100644
--- a/lib/elixir/lib/application.ex
+++ b/lib/elixir/lib/application.ex
@@ -1,213 +1,943 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Application do
   @moduledoc """
   A module for working with applications and defining application callbacks.
 
-  In Elixir (actually, in Erlang/OTP), an application is a component
-  implementing some specific functionality, that can be started and stopped
-  as a unit, and which can be re-used in other systems as well.
-
-  Applications are defined with an application file named `APP.app` where
-  `APP` is the APP name, usually in `underscore_case` convention. The
-  application file must reside in the same `ebin` directory as the
-  application's modules bytecode.
+  Applications are the idiomatic way to package software in Erlang/OTP. To get
+  the idea, they are similar to the "library" concept common in other
+  programming languages, but with some additional characteristics.
 
-  In Elixir, Mix is responsible for compiling your source code and
-  generating your application `.app` file. Furthermore, Mix is also
-  responsible for configuring, starting and stopping your application
-  and its dependencies. For this reason, this documentation will focus
-  on the remaining aspects of your application: the application environment,
-  and the application callback module.
+  An application is a component implementing some specific functionality, with a
+  standardized directory structure, configuration, and life cycle. Applications
+  are *loaded*, *started*, and *stopped*. Each application also has its own
+  environment, which provides a unified API for configuring each application.
 
-  You can learn more about Mix compilation of `.app` files by typing
-  `mix help compile.app`.
+  Developers typically interact with the application environment and its
+  callback module. Therefore those will be the topics we will cover first
+  before jumping into details about the application resource file and life cycle.
 
-  ## Application environment
+  ## The application environment
 
-  Once an application is started, OTP provides an application environment
-  that can be used to configure applications.
+  Each application has its own environment. The environment is a keyword list
+  that maps atoms to terms. Note that this environment is unrelated to the
+  operating system environment.
 
-  Assuming you are inside a Mix project, you can edit your application
-  function in the `mix.exs` file to the following:
+  By default, the environment of an application is an empty list. In a Mix
+  project's `mix.exs` file, you can set the `:env` key in `application/0`:
 
       def application do
-        [env: [hello: :world]]
+        [env: [db_host: "localhost"]]
+      end
+
+  Now, in your application, you can read this environment by using functions
+  such as `fetch_env!/2` and friends:
+
+      defmodule MyApp.DBClient do
+        def start_link() do
+          SomeLib.DBClient.start_link(host: db_host())
+        end
+
+        defp db_host do
+          Application.fetch_env!(:my_app, :db_host)
+        end
       end
 
-  In the application function, we can define the default environment values
-  for our application. By starting your application with `iex -S mix`, you
-  can access the default value:
+  In Mix projects, the environment of the application and its dependencies can
+  be overridden via the `config/config.exs` and `config/runtime.exs` files. The
+  former is loaded at build-time, before your code compiles, and the latter at
+  runtime, just before your app starts. For example, someone using your application
+  can override its `:db_host` environment variable as follows:
+
+      import Config
+      config :my_app, :db_host, "db.local"
+
+  See the "Configuration" section in the `Mix` module for more information.
+  You can also change the application environment dynamically by using functions
+  such as `put_env/3` and `delete_env/2`.
+
+  > #### Application environment in libraries {: .info}
+  >
+  > If you are writing a library to be used by other developers,
+  > it is generally recommended to avoid the application environment, as the
+  > application environment is effectively a global storage. For more information,
+  > read about this [anti-pattern](design-anti-patterns.md#using-application-configuration-for-libraries).
+
+  > #### Reading the environment of other applications {: .warning}
+  >
+  > Each application is responsible for its own environment. Do not
+  > use the functions in this module for directly accessing or modifying
+  > the environment of other applications. Whenever you change the application
+  > environment, Elixir's build tool will only recompile the files that
+  > belong to that application. So if you read the application environment
+  > of another application, there is a chance you will be depending on
+  > outdated configuration, as your file won't be recompiled as it changes.
+
+  ## Compile-time environment
+
+  In the previous example, we read the application environment at runtime:
+
+      defmodule MyApp.DBClient do
+        def start_link() do
+          SomeLib.DBClient.start_link(host: db_host())
+        end
 
-      Application.get_env(:APP_NAME, :hello)
-      #=> {:ok, :hello}
+        defp db_host do
+          Application.fetch_env!(:my_app, :db_host)
+        end
+      end
 
-  It is also possible to put and delete values from the application value,
-  including new values that are not defined in the environment file (although
-  those should be avoided).
+  In other words, the environment key `:db_host` for application `:my_app`
+  will only be read when `MyApp.DBClient` effectively starts. While reading
+  the application environment at runtime is the preferred approach, in some
+  rare occasions you may want to use the application environment to configure
+  the compilation of a certain project. However, if you try to access
+  `Application.fetch_env!/2` outside of a function:
 
-  In the future, we plan to support configuration files which allows
-  developers to configure the environment of their dependencies.
+      defmodule MyApp.DBClient do
+        @db_host Application.fetch_env!(:my_app, :db_host)
 
-  Keep in mind that each application is responsible for its environment.
-  Do not use the functions in this module for directly access or modify
-  the environment of other application (as it may lead to inconsistent
-  data in the application environment).
+        def start_link() do
+          SomeLib.DBClient.start_link(host: @db_host)
+        end
+      end
 
-  ## Application module callback
+  You might see warnings and errors:
 
-  Often times, an application defines a supervision tree that must be started
-  and stopped when the application starts and stops. For such, we need to
-  define an application module callback. The first step is to define the
-  module callback in the application definition in the `mix.exs` file:
+      warning: Application.fetch_env!/2 is discouraged in the module body,
+      use Application.compile_env/3 instead
+        iex:3: MyApp.DBClient
+
+      ** (ArgumentError) could not fetch application environment :db_host
+      for application :my_app because the application was not loaded nor
+      configured
+
+  This happens because, when defining modules, the application environment
+  is not yet available. Luckily, the warning tells us how to solve this
+  issue, by using `Application.compile_env/3` instead:
+
+      defmodule MyApp.DBClient do
+        @db_host Application.compile_env(:my_app, :db_host, "db.local")
+
+        def start_link() do
+          SomeLib.DBClient.start_link(host: @db_host)
+        end
+      end
+
+  The difference here is that `compile_env` expects the default value to be
+  given as an argument, instead of using the `def application` function of
+  your `mix.exs`. Furthermore, by using `compile_env/3`, tools like Mix will
+  store the values used during compilation and compare the compilation values
+  with the runtime values whenever your system starts, raising an error in
+  case they differ.
+
+  In any case, compile-time environments should be avoided. Whenever possible,
+  reading the application environment at runtime should be the first choice.
+
+  ## The application callback module
+
+  Applications can be loaded, started, and stopped. Generally, build tools
+  like Mix take care of starting an application and all of its dependencies
+  for you, but you can also do it manually by calling:
+
+      {:ok, _} = Application.ensure_all_started(:some_app)
+
+  When an application starts, developers may configure a callback module
+  that executes custom code. Developers use this callback to start the
+  application supervision tree.
+
+  The first step to do so is to add a `:mod` key to the `application/0`
+  definition in your `mix.exs` file. It expects a tuple, with the application
+  callback module and start argument (commonly an empty list):
 
       def application do
         [mod: {MyApp, []}]
       end
 
-  Our application now requires the `MyApp` module to provide an application
-  callback. This can be done by invoking `use Application` in that module
-  and defining a `start/2` callback, for example:
+  The `MyApp` module given to `:mod` needs to implement the `Application` behaviour.
+  This can be done by putting `use Application` in that module and implementing the
+  `c:start/2` callback, for example:
 
       defmodule MyApp do
         use Application
 
         def start(_type, _args) do
-          MyApp.Supervisor.start_link()
+          children = []
+          Supervisor.start_link(children, strategy: :one_for_one)
         end
       end
 
-  `start/2` most commonly returns `{:ok, pid}` or `{:ok, pid, state}` where
-  `pid` identifies the supervision tree and the state is the application state.
-  `args` is second element of the tuple given to the `:mod` option.
+  > #### `use Application` {: .info}
+  >
+  > When you `use Application`, the `Application` module will
+  > set `@behaviour Application` and define an overridable
+  > definition for the `c:stop/1` function, which is required
+  > by Erlang/OTP.
+
+  The `c:start/2` callback has to spawn and link a supervisor and return `{:ok,
+  pid}` or `{:ok, pid, state}`, where `pid` is the PID of the supervisor, and
+  `state` is an optional application state. `args` is the second element of the
+  tuple given to the `:mod` option.
+
+  The `type` argument passed to `c:start/2` is usually `:normal` unless in a
+  distributed setup where application takeovers and failovers are configured.
+  Distributed applications are beyond the scope of this documentation.
+
+  When an application is shutting down, its `c:stop/1` callback is called after
+  the supervision tree has been stopped by the runtime. This callback allows the
+  application to do any final cleanup. The argument is the state returned by
+  `c:start/2`, if it did, or `[]` otherwise. The return value of `c:stop/1` is
+  ignored.
+
+  By using `Application`, modules get a default implementation of `c:stop/1`
+  that ignores its argument and returns `:ok`, but it can be overridden.
+
+  Application callback modules may also implement the optional callback
+  `c:prep_stop/1`. If present, `c:prep_stop/1` is invoked before the supervision
+  tree is terminated. Its argument is the state returned by `c:start/2`, if it did,
+  or `[]` otherwise, and its return value is passed to `c:stop/1`.
+
+  ## The application resource file
+
+  In the sections above, we have configured an application in the
+  `application/0` section of the `mix.exs` file. Ultimately, Mix will use
+  this configuration to create an [*application resource
+  file*](https://www.erlang.org/doc/man/app), which is a file called
+  `APP_NAME.app`. For example, the application resource file of the OTP
+  application `ex_unit` is called `ex_unit.app`.
+
+  You can learn more about the generation of application resource files in
+  the documentation of `Mix.Tasks.Compile.App`, available as well by running
+  `mix help compile.app`.
+
+  ## The application life cycle
+
+  ### Loading applications
+
+  Applications are *loaded*, which means that the runtime finds and processes
+  their resource files:
+
+      Application.load(:ex_unit)
+      #=> :ok
+
+  When an application is loaded, the environment specified in its resource file
+  is merged with any overrides from config files.
+
+  Loading an application *does not* load its modules.
+
+  In practice, you rarely load applications by hand because that is part of the
+  start process, explained next.
+
+  ### Starting applications
+
+  Applications are also *started*:
+
+      Application.start(:ex_unit)
+      #=> :ok
+
+  Once your application is compiled, running your system is a matter of starting
+  your current application and its dependencies. Differently from other languages,
+  Elixir does not have a `main` procedure that is responsible for starting your
+  system. Instead, you start one or more applications, each with their own
+  initialization and termination logic.
+
+  When an application is started, the `Application.load/1` is automatically
+  invoked if it hasn't been done yet. Then, it checks if the dependencies listed
+  in the `applications` key of the resource file are already started. Having at
+  least one dependency not started is an error condition. Functions like
+  `ensure_all_started/1` take care of starting an application and all of its
+  dependencies for you.
+
+  If the application does not have a callback module configured, starting is
+  done at this point. Otherwise, its `c:start/2` callback is invoked. The PID of
+  the top-level supervisor returned by this function is stored by the runtime
+  for later use, and the returned application state is saved too, if any.
+
+  ### Stopping applications
+
+  Started applications are, finally, *stopped*:
+
+      Application.stop(:ex_unit)
+      #=> :ok
+
+  Stopping an application without a callback module defined, is in practice a
+  no-op, except for some system tracing.
+
+  Stopping an application with a callback module has three steps:
+
+    1. If present, invoke the optional callback `c:prep_stop/1`.
+    2. Terminate the top-level supervisor.
+    3. Invoke the required callback `c:stop/1`.
+
+  The arguments passed to the callbacks are related to the state optionally
+  returned by `c:start/2`, and are documented in the section about the callback
+  module above.
+
+  It is important to highlight that step 2 is a blocking one. Termination of a
+  supervisor triggers a recursive chain of children terminations, therefore
+  orderly shutting down all descendant processes. The `c:stop/1` callback is
+  invoked only after termination of the whole supervision tree.
+
+  Shutting down a live system cleanly can be done by calling `System.stop/1`. It
+  will shut down every application in the reverse order they were started.
+
+  By default, a SIGTERM from the operating system will automatically translate to
+  `System.stop/0`. You can also have more explicit control over operating system
+  signals via the `:os.set_signal/2` function.
+
+  ## Tooling
+
+  The Mix build tool automates most of the application management tasks. For example,
+  `mix test` automatically starts your application dependencies and your application
+  itself before your test runs. `mix run --no-halt` boots your current project and
+  can be used to start a long running system. See `mix help run`.
+
+  Developers can also use `mix release` to build **releases**. Releases are able to
+  package all of your source code as well as the Erlang VM into a single directory.
+  Releases also give you explicit control over how each application is started and in
+  which order. They also provide a more streamlined mechanism for starting and
+  stopping systems, debugging, logging, as well as system monitoring.
+
+  Finally, Elixir provides tools such as escripts and archives, which are
+  different mechanisms for packaging your application. Those are typically used
+  when tools must be shared between developers and not as deployment options.
+  See `mix help archive.build` and `mix help escript.build` for more detail.
+
+  ## Further information
+
+  For further details on applications please check the documentation of the
+  [`:application` Erlang module](`:application`), and the
+  [Applications](https://www.erlang.org/doc/design_principles/applications.html)
+  section of the [OTP Design Principles User's
+  Guide](https://www.erlang.org/doc/design_principles/users_guide.html).
+  """
+
+  @doc """
+  Called when an application is started.
+
+  This function is called when an application is started using
+  `Application.start/2` (and functions on top of that, such as
+  `Application.ensure_started/2`). This function should start the top-level
+  process of the application (which should be the top supervisor of the
+  application's supervision tree if the application follows the OTP design
+  principles around supervision).
+
+  `start_type` defines how the application is started:
+
+    * `:normal` - used if the startup is a normal startup or if the application
+      is distributed and is started on the current node because of a failover
+      from another node and the application specification key `:start_phases`
+      is `:undefined`.
+    * `{:takeover, node}` - used if the application is distributed and is
+      started on the current node because of a failover on the node `node`.
+    * `{:failover, node}` - used if the application is distributed and is
+      started on the current node because of a failover on node `node`, and the
+      application specification key `:start_phases` is not `:undefined`.
+
+  `start_args` are the arguments passed to the application in the `:mod`
+  specification key (for example, `mod: {MyApp, [:my_args]}`).
+
+  This function should either return `{:ok, pid}` or `{:ok, pid, state}` if
+  startup is successful. `pid` should be the PID of the top supervisor. `state`
+  can be an arbitrary term, and if omitted will default to `[]`; if the
+  application is later stopped, `state` is passed to the `stop/1` callback (see
+  the documentation for the `c:stop/1` callback for more information).
+
+  `use Application` provides no default implementation for the `start/2`
+  callback.
+  """
+  @callback start(start_type, start_args :: term) ::
+              {:ok, pid}
+              | {:ok, pid, state}
+              | {:error, reason :: term}
+
+  @doc """
+  Called before stopping the application.
+
+  This function is called before the top-level supervisor is terminated. It
+  receives the state returned by `c:start/2`, if it did, or `[]` otherwise.
+  The return value is later passed to `c:stop/1`.
+  """
+  @callback prep_stop(state) :: state
+
+  @doc """
+  Called after an application has been stopped.
+
+  This function is called after an application has been stopped, i.e., after its
+  supervision tree has been stopped. It should do the opposite of what the
+  `c:start/2` callback did, and should perform any necessary cleanup. The return
+  value of this callback is ignored.
+
+  `state` is the state returned by `c:start/2`, if it did, or `[]` otherwise.
+  If the optional callback `c:prep_stop/1` is present, `state` is its return
+  value instead.
+
+  `use Application` defines a default implementation of this function which does
+  nothing and just returns `:ok`.
+  """
+  @callback stop(state) :: term
 
-  The `type` passed into `start/2` is usually `:normal` unless in a distributed
-  setup where applications takeover and failovers are configured. This particular
-  aspect of applications can be read with more detail in the OTP documentation:
+  @doc """
+  Starts an application in synchronous phases.
 
-    * http://www.erlang.org/doc/man/application.html
-    * http://www.erlang.org/doc/design_principles/applications.html
+  This function is called after `start/2` finishes but before
+  `Application.start/2` returns. It will be called once for every start phase
+  defined in the application's (and any included applications') specification,
+  in the order they are listed in.
+  """
+  @callback start_phase(phase :: term, start_type, phase_args :: term) ::
+              :ok | {:error, reason :: term}
+
+  @doc """
+  Callback invoked after code upgrade, if the application environment
+  has changed.
 
-  A developer may also implement the `stop/1` callback (automatically defined
-  by `use Application`) which does any application cleanup. It receives the
-  application state and can return any value. Notice that shutting down the
-  supervisor is automatically handled by the VM;
+  `changed` is a keyword list of keys and their changed values in the
+  application environment. `new` is a keyword list with all new keys
+  and their values. `removed` is a list with all removed keys.
   """
+  @callback config_change(changed, new, removed) :: :ok
+            when changed: keyword, new: keyword, removed: [atom]
+
+  @optional_callbacks start_phase: 3, prep_stop: 1, config_change: 3
 
   @doc false
   defmacro __using__(_) do
     quote location: :keep do
-      @behaviour :application
+      @behaviour Application
 
       @doc false
       def stop(_state) do
         :ok
       end
 
-      defoverridable [stop: 1]
+      defoverridable Application
     end
   end
 
+  @application_keys [
+    :description,
+    :id,
+    :vsn,
+    :modules,
+    :maxP,
+    :maxT,
+    :registered,
+    :included_applications,
+    :optional_applications,
+    :applications,
+    :mod,
+    :start_phases
+  ]
+
+  application_key_specs = Enum.reduce(@application_keys, &{:|, [], [&1, &2]})
+
   @type app :: atom
   @type key :: atom
+  @type application_key :: unquote(application_key_specs)
   @type value :: term
-  @type start_type :: :permanent | :transient | :temporary
+  @type state :: term
+  @type start_type :: :normal | {:takeover, node} | {:failover, node}
+
+  @typedoc """
+  Specifies the type of the application:
+
+    * `:permanent` - if `app` terminates, all other applications and the entire
+      node are also terminated.
+
+    * `:transient` - if `app` terminates with `:normal` reason, it is reported
+      but no other applications are terminated. If a transient application
+      terminates abnormally, all other applications and the entire node are
+      also terminated.
+
+    * `:temporary` - if `app` terminates, it is reported but no other
+      applications are terminated (the default).
+
+  Note that it is always possible to stop an application explicitly by calling
+  `stop/1`. Regardless of the type of the application, no other applications will
+  be affected.
+
+  Note also that the `:transient` type is of little practical use, since when a
+  supervision tree terminates, the reason is set to `:shutdown`, not `:normal`.
+  """
+  @type restart_type :: :permanent | :transient | :temporary
+
+  @doc """
+  Returns the spec for `app`.
+
+  The following keys are returned:
+
+    * #{Enum.map_join(@application_keys, "\n  * ", &"`#{inspect(&1)}`")}
+
+  For a description of all fields, see [Erlang's application
+  specification](https://www.erlang.org/doc/man/app).
+
+  Note the environment is not returned as it can be accessed via
+  `fetch_env/2`. Returns `nil` if the application is not loaded.
+  """
+  @spec spec(app) :: [{application_key, value}] | nil
+  def spec(app) when is_atom(app) do
+    case :application.get_all_key(app) do
+      {:ok, info} -> :lists.keydelete(:env, 1, info)
+      :undefined -> nil
+    end
+  end
+
+  @doc """
+  Returns the value for `key` in `app`'s specification.
+
+  See `spec/1` for the supported keys. If the given
+  specification parameter does not exist, this function
+  will raise. Returns `nil` if the application is not loaded.
+  """
+  @spec spec(app, application_key) :: value | nil
+  def spec(app, key) when is_atom(app) and key in @application_keys do
+    case :application.get_key(app, key) do
+      {:ok, value} -> value
+      :undefined -> nil
+    end
+  end
+
+  @doc """
+  Gets the application for the given module.
+
+  The application is located by analyzing the spec
+  of all loaded applications. Returns `nil` if
+  the module is not listed in any application spec.
+  """
+  @spec get_application(module) :: app | nil
+  def get_application(module) when is_atom(module) do
+    case :application.get_application(module) do
+      {:ok, app} -> app
+      :undefined -> nil
+    end
+  end
 
   @doc """
   Returns all key-value pairs for `app`.
   """
-  @spec get_all_env(app) :: [{key,value}]
-  def get_all_env(app) do
+  @spec get_all_env(app) :: [{key, value}]
+  def get_all_env(app) when is_atom(app) do
     :application.get_all_env(app)
   end
 
   @doc """
-  Returns the value for `key` in `app`'s environment.
+  Reads the application environment at compilation time.
+
+  Similar to `get_env/3`, except it must be used to read values
+  at compile time. This allows Elixir to track when configuration
+  values change between compile time and runtime.
+
+  The first argument is the application name. The second argument
+  `key_or_path` is either an atom key or a path to traverse in
+  search of the configuration, starting with an atom key.
+
+  For example, imagine the following configuration:
 
-  If the specified application is not loaded, or the configuration parameter
-  does not exist, the function returns the `default` value.
+      config :my_app, :key, [foo: [bar: :baz]]
+
+  We can access it during compile time as:
+
+      Application.compile_env(:my_app, :key)
+      #=> [foo: [bar: :baz]]
+
+      Application.compile_env(:my_app, [:key, :foo])
+      #=> [bar: :baz]
+
+      Application.compile_env(:my_app, [:key, :foo, :bar])
+      #=> :baz
+
+  A default value can also be given as third argument. If
+  any of the keys in the path along the way is missing, the
+  default value is used:
+
+      Application.compile_env(:my_app, [:unknown, :foo, :bar], :default)
+      #=> :default
+
+      Application.compile_env(:my_app, [:key, :unknown, :bar], :default)
+      #=> :default
+
+      Application.compile_env(:my_app, [:key, :foo, :unknown], :default)
+      #=> :default
+
+  Giving a path is useful to let Elixir know that only certain paths
+  in a large configuration are compile time dependent.
   """
-  @spec get_env(app, key, value) :: value
-  def get_env(app, key, default \\ nil) do
-    case :application.get_env(app, key) do
+  @doc since: "1.10.0"
+  @spec compile_env(app, key | list, value) :: value
+  defmacro compile_env(app, key_or_path, default \\ nil) do
+    if __CALLER__.function do
+      raise "Application.compile_env/3 cannot be called inside functions, only in the module body"
+    end
+
+    key_or_path = Macro.expand_literals(key_or_path, %{__CALLER__ | function: {:__info__, 1}})
+
+    quote do
+      Application.compile_env(__ENV__, unquote(app), unquote(key_or_path), unquote(default))
+    end
+  end
+
+  @doc """
+  Reads the application environment at compilation time from a macro.
+
+  Typically, developers will use `compile_env/3`. This function must
+  only be invoked from macros which aim to read the compilation environment
+  dynamically.
+
+  It expects a `Macro.Env` as first argument, where the `Macro.Env` is
+  typically the `__CALLER__` in a macro. It raises if `Macro.Env` comes
+  from a function.
+  """
+  @doc since: "1.14.0"
+  @spec compile_env(Macro.Env.t(), app, key | list, value) :: value
+  def compile_env(%Macro.Env{} = env, app, key_or_path, default) do
+    case fetch_compile_env(app, key_or_path, env) do
       {:ok, value} -> value
-      :undefined -> default
+      :error -> default
+    end
+  end
+
+  @doc """
+  Reads the application environment at compilation time or raises.
+
+  This is the same as `compile_env/3` but it raises an
+  `ArgumentError` if the configuration is not available.
+  """
+  @doc since: "1.10.0"
+  @spec compile_env!(app, key | list) :: value
+  defmacro compile_env!(app, key_or_path) do
+    if __CALLER__.function do
+      raise "Application.compile_env!/2 cannot be called inside functions, only in the module body"
     end
+
+    key_or_path = Macro.expand_literals(key_or_path, %{__CALLER__ | function: {:__info__, 1}})
+
+    quote do
+      Application.compile_env!(__ENV__, unquote(app), unquote(key_or_path))
+    end
+  end
+
+  @doc """
+  Reads the application environment at compilation time from a macro
+  or raises.
+
+  Typically, developers will use `compile_env!/2`. This function must
+  only be invoked from macros which aim to read the compilation environment
+  dynamically.
+
+  It expects a `Macro.Env` as first argument, where the `Macro.Env` is
+  typically the `__CALLER__` in a macro. It raises if `Macro.Env` comes
+  from a function.
+  """
+  @doc since: "1.14.0"
+  @spec compile_env!(Macro.Env.t(), app, key | list) :: value
+  def compile_env!(%Macro.Env{} = env, app, key_or_path) do
+    case fetch_compile_env(app, key_or_path, env) do
+      {:ok, value} ->
+        value
+
+      :error ->
+        raise ArgumentError,
+              "could not fetch application environment #{inspect(key_or_path)} for application " <>
+                "#{inspect(app)} #{fetch_env_failed_reason(app, key_or_path)}"
+    end
+  end
+
+  defp fetch_compile_env(app, key, env) when is_atom(key) do
+    fetch_compile_env(app, key, [], env)
+  end
+
+  defp fetch_compile_env(app, [key | paths], env) when is_atom(key),
+    do: fetch_compile_env(app, key, paths, env)
+
+  defp fetch_compile_env(app, key, path, env) do
+    return = traverse_env(fetch_env(app, key), path)
+
+    for tracer <- env.tracers do
+      tracer.trace({:compile_env, app, [key | path], return}, env)
+    end
+
+    return
+  end
+
+  defp traverse_env(return, []), do: return
+  defp traverse_env(:error, _paths), do: :error
+  defp traverse_env({:ok, value}, [key | keys]), do: traverse_env(Access.fetch(value, key), keys)
+
+  @doc """
+  Returns the value for `key` in `app`'s environment.
+
+  If the configuration parameter does not exist, the function returns the
+  `default` value.
+
+  > #### Warning {: .warning}
+  >
+  > You must use this function to read only your own application
+  > environment. Do not read the environment of other applications.
+
+  ## Examples
+
+  `get_env/3` is commonly used to read the configuration of your OTP applications.
+  Since Mix configurations are commonly used to configure applications, we will use
+  this as a point of illustration.
+
+  Consider a new application `:my_app`. `:my_app` contains a database engine which
+  supports a pool of databases. The database engine needs to know the configuration for
+  each of those databases, and that configuration is supplied by key-value pairs in
+  environment of `:my_app`.
+
+      config :my_app, Databases.RepoOne,
+        # A database configuration
+        ip: "localhost",
+        port: 5433
+
+      config :my_app, Databases.RepoTwo,
+        # Another database configuration (for the same OTP app)
+        ip: "localhost",
+        port: 20_717
+
+      config :my_app, my_app_databases: [Databases.RepoOne, Databases.RepoTwo]
+
+  Our database engine used by `:my_app` needs to know what databases exist, and
+  what the database configurations are. The database engine can make a call to
+  `Application.get_env(:my_app, :my_app_databases, [])` to retrieve the list of
+  databases (specified by module names).
+
+  The engine can then traverse each repository in the list and call
+  `Application.get_env(:my_app, Databases.RepoOne)` and so forth to retrieve the
+  configuration of each one. In this case, each configuration will be a keyword
+  list, so you can use the functions in the `Keyword` module or even the `Access`
+  module to traverse it, for example:
+
+      config = Application.get_env(:my_app, Databases.RepoOne)
+      config[:ip]
+
+  """
+  @spec get_env(app, key, value) :: value
+  def get_env(app, key, default \\ nil) when is_atom(app) do
+    maybe_warn_on_app_env_key(app, key)
+    :application.get_env(app, key, default)
   end
 
   @doc """
   Returns the value for `key` in `app`'s environment in a tuple.
 
-  If the specified application is not loaded, or the configuration parameter
-  does not exist, the function returns `:error`.
+  If the configuration parameter does not exist, the function returns `:error`.
+
+  > #### Warning {: .warning}
+  >
+  > You must use this function to read only your own application
+  > environment. Do not read the environment of other applications.
+
+  > #### Application environment in info
+  >
+  > If you are writing a library to be used by other developers,
+  > it is generally recommended to avoid the application environment, as the
+  > application environment is effectively a global storage. For more information,
+  > read our [library guidelines](library-guidelines.md).
   """
   @spec fetch_env(app, key) :: {:ok, value} | :error
-  def fetch_env(app, key) do
+  def fetch_env(app, key) when is_atom(app) do
+    maybe_warn_on_app_env_key(app, key)
+
     case :application.get_env(app, key) do
       {:ok, value} -> {:ok, value}
       :undefined -> :error
     end
   end
 
+  @doc """
+  Returns the value for `key` in `app`'s environment.
+
+  If the configuration parameter does not exist, raises `ArgumentError`.
+
+  > #### Warning {: .warning}
+  >
+  > You must use this function to read only your own application
+  > environment. Do not read the environment of other applications.
+
+  > #### Application environment in info
+  >
+  > If you are writing a library to be used by other developers,
+  > it is generally recommended to avoid the application environment, as the
+  > application environment is effectively a global storage. For more information,
+  > read our [library guidelines](library-guidelines.md).
+  """
+  @spec fetch_env!(app, key) :: value
+  def fetch_env!(app, key) when is_atom(app) do
+    case fetch_env(app, key) do
+      {:ok, value} ->
+        value
+
+      :error ->
+        raise ArgumentError,
+              "could not fetch application environment #{inspect(key)} for application " <>
+                "#{inspect(app)} #{fetch_env_failed_reason(app, key)}"
+    end
+  end
+
+  defp fetch_env_failed_reason(app, key) do
+    vsn = :application.get_key(app, :vsn)
+
+    case vsn do
+      {:ok, _} ->
+        "because configuration at #{inspect(key)} was not set"
+
+      :undefined ->
+        "because the application was not loaded nor configured"
+    end
+  end
+
   @doc """
   Puts the `value` in `key` for the given `app`.
 
+  > #### Compile environment {: .warning}
+  >
+  > Do not use this function to change environment variables read
+  > via `Application.compile_env/2`. The compile environment must
+  > be exclusively set before compilation, in your config files.
+
   ## Options
 
-    * `:timeout`    - the timeout for the change (defaults to 5000ms)
+    * `:timeout` - the timeout for the change (defaults to `5_000` milliseconds)
     * `:persistent` - persists the given value on application load and reloads
 
   If `put_env/4` is called before the application is loaded, the application
   environment values specified in the `.app` file will override the ones
   previously set.
 
-  The persistent option can be set to true when there is a need to guarantee
+  The `:persistent` option can be set to `true` when there is a need to guarantee
   parameters set with this function will not be overridden by the ones defined
   in the application resource file on load. This means persistent values will
   stick after the application is loaded and also on application reload.
   """
-  @spec put_env(app, key, value, [timeout: timeout, persistent: boolean]) :: :ok
-  def put_env(app, key, value, opts \\ []) do
+  @spec put_env(app, key, value, timeout: timeout, persistent: boolean) :: :ok
+  def put_env(app, key, value, opts \\ []) when is_atom(app) and is_list(opts) do
+    maybe_warn_on_app_env_key(app, key)
     :application.set_env(app, key, value, opts)
   end
 
+  @doc """
+  Puts the environment for multiple applications at the same time.
+
+  The given config should not:
+
+    * have the same application listed more than once
+    * have the same key inside the same application listed more than once
+
+  If those conditions are not met, this function will raise.
+
+  This function receives the same options as `put_env/4`. Returns `:ok`.
+
+  ## Examples
+
+      Application.put_all_env(
+        my_app: [
+          key: :value,
+          another_key: :another_value
+        ],
+        another_app: [
+          key: :value
+        ]
+      )
+
+  """
+  @doc since: "1.9.0"
+  @spec put_all_env([{app, [{key, value}]}], timeout: timeout, persistent: boolean) :: :ok
+  def put_all_env(config, opts \\ []) when is_list(config) and is_list(opts) do
+    :application.set_env(config, opts)
+  end
+
   @doc """
   Deletes the `key` from the given `app` environment.
 
-  See `put_env/4` for a description of the options.
+  It receives the same options as `put_env/4`. Returns `:ok`.
   """
-  @spec delete_env(app, key, [timeout: timeout, persistent: boolean]) :: :ok
-  def delete_env(app, key, opts \\ []) do
+  @spec delete_env(app, key, timeout: timeout, persistent: boolean) :: :ok
+  def delete_env(app, key, opts \\ []) when is_atom(app) and is_list(opts) do
+    maybe_warn_on_app_env_key(app, key)
     :application.unset_env(app, key, opts)
   end
 
+  defp maybe_warn_on_app_env_key(_app, key) when is_atom(key),
+    do: :ok
+
+  # TODO: Remove this deprecation warning on 2.0+ and allow list lookups as in compile_env.
+  defp maybe_warn_on_app_env_key(app, key) do
+    message = fn ->
+      "passing non-atom as application env key is deprecated, got: #{inspect(key)}"
+    end
+
+    IO.warn_once({Application, :key, app, key}, message, _stacktrace_drop_levels = 2)
+  end
+
   @doc """
-  Ensures the given `app` is started.
+  Ensures the given `app` is started with `t:restart_type/0`.
 
   Same as `start/2` but returns `:ok` if the application was already
-  started. This is useful in scripts and in test setup, where test
-  applications need to be explicitly started:
+  started.
+  """
+  @spec ensure_started(app, restart_type()) :: :ok | {:error, term}
+  def ensure_started(app, type \\ :temporary) when is_atom(app) and is_atom(type) do
+    :application.ensure_started(app, type)
+  end
 
-      :ok = Application.ensure_started(:my_test_dep)
+  @doc """
+  Ensures the given `app` is loaded.
 
+  Same as `load/1` but returns `:ok` if the application was already
+  loaded.
   """
-  @spec ensure_started(app, start_type) :: :ok | {:error, term}
-  def ensure_started(app, type \\ :temporary) when is_atom(app) do
-    :application.ensure_started(app, type)
+  @doc since: "1.10.0"
+  @spec ensure_loaded(app) :: :ok | {:error, term}
+  def ensure_loaded(app) when is_atom(app) do
+    case :application.load(app) do
+      :ok -> :ok
+      {:error, {:already_loaded, ^app}} -> :ok
+      {:error, _} = error -> error
+    end
   end
 
   @doc """
-  Ensures the given `app` and its applications are started.
+  Ensures the given `app` or `apps` and their child applications are started.
+
+  The second argument is either the `t:restart_type/0` (for consistency with
+  `start/2`) or a keyword list.
+
+  ## Options
+
+    * `:type` - if the application should be started `:temporary` (default),
+      `:permanent`, or `:transient`. See `t:restart_type/0` for more information.
+
+    * `:mode` - (since v1.15.0) if the applications should be started serially
+      (`:serial`, default) or concurrently (`:concurrent`).
 
-  Same as `start/2` but also starts the applications listed under
-  `:applications` in the `.app` file in case they were not previously
-  started.
   """
-  @spec ensure_all_started(app, start_type) :: {:ok, [app]} | {:error, term}
-  def ensure_all_started(app, type \\ :temporary) when is_atom(app) do
-    :application.ensure_all_started(app, type)
+  @spec ensure_all_started(app | [app], type: restart_type(), mode: :serial | :concurrent) ::
+          {:ok, [app]} | {:error, term}
+  @spec ensure_all_started(app | [app], restart_type()) ::
+          {:ok, [app]} | {:error, term}
+  def ensure_all_started(app_or_apps, type_or_opts \\ [])
+
+  def ensure_all_started(app_or_apps, type) when is_atom(type) do
+    ensure_all_started(app_or_apps, type: type)
+  end
+
+  def ensure_all_started(app, opts) when is_atom(app) and is_list(opts) do
+    ensure_all_started([app], opts)
+  end
+
+  @compile {:no_warn_undefined, {:application, :ensure_all_started, 3}}
+
+  def ensure_all_started(apps, opts) when is_list(apps) and is_list(opts) do
+    opts = Keyword.validate!(opts, type: :temporary, mode: :serial)
+    :application.ensure_all_started(apps, opts[:type], opts[:mode])
   end
 
   @doc """
-  Starts the given `app`.
+  Starts the given `app` with `t:restart_type/0`.
 
   If the `app` is not loaded, the application will first be loaded using `load/1`.
   Any included application, defined in the `:included_applications` key of the
@@ -217,31 +947,11 @@ defmodule Application do
   started before this application is. If not, `{:error, {:not_started, app}}` is
   returned, where `app` is the name of the missing application.
 
-  In case you want to automatically  load **and start** all of `app`'s dependencies,
+  In case you want to automatically load **and start** all of `app`'s dependencies,
   see `ensure_all_started/2`.
-
-  The `type` argument specifies the type of the application:
-
-    * `:permanent` - if `app` terminates, all other applications and the entire
-      node are also terminated.
-
-    * `:transient` - if `app` terminates with `:normal` reason, it is reported
-      but no other applications are terminated. If a transient application
-      terminates abnormally, all other applications and the entire node are
-      also terminated.
-
-    * `:temporary` - if `app` terminates, it is reported but no other
-      applications are terminated (the default).
-
-  Note that it is always possible to stop an application explicitly by calling
-  `stop/1`. Regardless of the type of the application, no other applications will
-  be affected.
-
-  Note also that the `:transient` type is of little practical use, since when a
-  supervision tree terminates, the reason is set to `:shutdown`, not `:normal`.
   """
-  @spec start(app, start_type) :: :ok | {:error, term}
-  def start(app, type \\ :temporary) when is_atom(app) do
+  @spec start(app, restart_type()) :: :ok | {:error, term}
+  def start(app, type \\ :temporary) when is_atom(app) and is_atom(type) do
     :application.start(app, type)
   end
 
@@ -251,7 +961,7 @@ defmodule Application do
   When stopped, the application is still loaded.
   """
   @spec stop(app) :: :ok | {:error, term}
-  def stop(app) do
+  def stop(app) when is_atom(app) do
     :application.stop(app)
   end
 
@@ -302,35 +1012,74 @@ defmodule Application do
       #=> "bar-123"
 
   For more information on code paths, check the `Code` module in
-  Elixir and also Erlang's `:code` module.
+  Elixir and also Erlang's [`:code` module](`:code`).
   """
-  @spec app_dir(app) :: String.t
+  @spec app_dir(app) :: String.t()
   def app_dir(app) when is_atom(app) do
     case :code.lib_dir(app) do
       lib when is_list(lib) -> IO.chardata_to_string(lib)
-      {:error, :bad_name} -> raise ArgumentError, "unknown application: #{inspect app}"
+      {:error, :bad_name} -> raise ArgumentError, "unknown application: #{inspect(app)}"
     end
   end
 
   @doc """
   Returns the given path inside `app_dir/1`.
+
+  If `path` is a string, then it will be used as the path inside `app_dir/1`. If
+  `path` is a list of strings, it will be joined (see `Path.join/1`) and the result
+  will be used as the path inside `app_dir/1`.
+
+  ## Examples
+
+      File.mkdir_p!("foo/ebin")
+      Code.prepend_path("foo/ebin")
+
+      Application.app_dir(:foo, "my_path")
+      #=> "foo/my_path"
+
+      Application.app_dir(:foo, ["my", "nested", "path"])
+      #=> "foo/my/nested/path"
+
   """
-  @spec app_dir(app, String.t) :: String.t
-  def app_dir(app, path) when is_binary(path) do
+  @spec app_dir(app, String.t() | [String.t()]) :: String.t()
+  def app_dir(app, path)
+
+  def app_dir(app, path) when is_atom(app) and is_binary(path) do
     Path.join(app_dir(app), path)
   end
 
+  def app_dir(app, path) when is_atom(app) and is_list(path) do
+    Path.join([app_dir(app) | path])
+  end
+
+  @doc """
+  Returns a list with information about the applications which are currently running.
+  """
+  @spec started_applications(timeout) :: [{app, description :: charlist(), vsn :: charlist()}]
+  def started_applications(timeout \\ 5000)
+      when timeout == :infinity or (is_integer(timeout) and timeout >= 0) do
+    :application.which_applications(timeout)
+  end
+
+  @doc """
+  Returns a list with information about the applications which have been loaded.
+  """
+  @spec loaded_applications :: [{app, description :: charlist(), vsn :: charlist()}]
+  def loaded_applications do
+    :application.loaded_applications()
+  end
+
   @doc """
   Formats the error reason returned by `start/2`,
-  `ensure_started/2, `stop/1`, `load/1` and `unload/1`,
+  `ensure_started/2`, `stop/1`, `load/1` and `unload/1`,
   returns a string.
   """
-  @spec format_error(any) :: String.t
+  @spec format_error(any) :: String.t()
   def format_error(reason) do
     try do
-      impl_format_error(reason)
+      do_format_error(reason)
     catch
-      # A user could create an error that looks like a builtin one
+      # A user could create an error that looks like a built-in one
       # causing an error.
       :error, _ ->
         inspect(reason)
@@ -338,68 +1087,67 @@ defmodule Application do
   end
 
   # exit(:normal) call is special cased, undo the special case.
-  defp impl_format_error({{:EXIT, :normal}, {mod, :start, args}}) do
+  defp do_format_error({{:EXIT, :normal}, {mod, :start, args}}) do
     Exception.format_exit({:normal, {mod, :start, args}})
   end
 
   # {:error, reason} return value
-  defp impl_format_error({reason, {mod, :start, args}}) do
-    Exception.format_mfa(mod, :start, args) <> " returned an error: " <>
-      Exception.format_exit(reason)
+  defp do_format_error({reason, {mod, :start, args}}) do
+    Exception.format_mfa(mod, :start, args) <>
+      " returned an error: " <> Exception.format_exit(reason)
   end
 
   # error or exit(reason) call, use exit reason as reason.
-  defp impl_format_error({:bad_return, {{mod, :start, args}, {:EXIT, reason}}}) do
+  defp do_format_error({:bad_return, {{mod, :start, args}, {:EXIT, reason}}}) do
     Exception.format_exit({reason, {mod, :start, args}})
   end
 
   # bad return value
-  defp impl_format_error({:bad_return, {{mod, :start, args}, return}}) do
-    Exception.format_mfa(mod, :start, args) <>
-      " returned a bad value: " <> inspect(return)
+  defp do_format_error({:bad_return, {{mod, :start, args}, return}}) do
+    Exception.format_mfa(mod, :start, args) <> " returned a bad value: " <> inspect(return)
   end
 
-  defp impl_format_error({:already_started, app}) when is_atom(app) do
+  defp do_format_error({:already_started, app}) when is_atom(app) do
     "already started application #{app}"
   end
 
-  defp impl_format_error({:not_started, app}) when is_atom(app) do
+  defp do_format_error({:not_started, app}) when is_atom(app) do
     "not started application #{app}"
   end
 
-  defp impl_format_error({:bad_application, app}) do
+  defp do_format_error({:bad_application, app}) do
     "bad application: #{inspect(app)}"
   end
 
-  defp impl_format_error({:already_loaded, app}) when is_atom(app) do
+  defp do_format_error({:already_loaded, app}) when is_atom(app) do
     "already loaded application #{app}"
   end
 
-  defp impl_format_error({:not_loaded, app}) when is_atom(app) do
+  defp do_format_error({:not_loaded, app}) when is_atom(app) do
     "not loaded application #{app}"
   end
 
-  defp impl_format_error({:invalid_restart_type, restart}) do
+  defp do_format_error({:invalid_restart_type, restart}) do
     "invalid application restart type: #{inspect(restart)}"
   end
 
-  defp impl_format_error({:invalid_name, name}) do
+  defp do_format_error({:invalid_name, name}) do
     "invalid application name: #{inspect(name)}"
   end
 
-  defp impl_format_error({:invalid_options, opts}) do
+  defp do_format_error({:invalid_options, opts}) do
     "invalid application options: #{inspect(opts)}"
   end
 
-  defp impl_format_error({:badstartspec, spec}) do
+  defp do_format_error({:badstartspec, spec}) do
     "bad application start specs: #{inspect(spec)}"
   end
 
-  defp impl_format_error({'no such file or directory', file}) do
+  defp do_format_error({~c"no such file or directory", file}) do
     "could not find application file: #{file}"
   end
 
-  defp impl_format_error(reason) do
+  defp do_format_error(reason) do
     Exception.format_exit(reason)
   end
 end
diff --git a/lib/elixir/lib/atom.ex b/lib/elixir/lib/atom.ex
index 36e62f9f416..1e11f6b9799 100644
--- a/lib/elixir/lib/atom.ex
+++ b/lib/elixir/lib/atom.ex
@@ -1,25 +1,86 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Atom do
-  @doc """
-  Convenience functions for working with atoms.
+  @moduledoc """
+  Atoms are constants whose values are their own name.
+
+  They are often useful to enumerate over distinct values, such as:
+
+      iex> :apple
+      :apple
+      iex> :orange
+      :orange
+      iex> :watermelon
+      :watermelon
+
+  Atoms are equal if their names are equal.
+
+      iex> :apple == :apple
+      true
+      iex> :apple == :orange
+      false
+
+  Often they are used to express the state of an operation, by using
+  values such as `:ok` and `:error`.
+
+  The booleans `true` and `false` are also atoms:
+
+      iex> true == :true
+      true
+      iex> is_atom(false)
+      true
+      iex> is_boolean(:false)
+      true
+
+  Elixir allows you to skip the leading `:` for the atoms `false`, `true`,
+  and `nil`.
+
+  Atoms must be composed of Unicode characters such as letters, numbers,
+  underscore, and `@`. If the keyword has a character that does not
+  belong to the category above, such as spaces, you can wrap it in
+  quotes:
+
+      iex> :"this is an atom with spaces"
+      :"this is an atom with spaces"
+
   """
 
   @doc """
-  Converts an atom to string.
+  Converts an atom to a string.
 
   Inlined by the compiler.
+
+  ## Examples
+
+      iex> Atom.to_string(:foo)
+      "foo"
+
   """
-  @spec to_string(atom) :: String.t
+  @spec to_string(atom) :: String.t()
   def to_string(atom) do
-    :erlang.atom_to_binary(atom, :utf8)
+    :erlang.atom_to_binary(atom)
   end
 
   @doc """
-  Converts an atom to a char list.
+  Converts an atom to a charlist.
 
   Inlined by the compiler.
+
+  ## Examples
+
+      iex> Atom.to_charlist(:"An atom")
+      ~c"An atom"
+
   """
-  @spec to_char_list(atom) :: char_list
-  def to_char_list(atom) do
+  @spec to_charlist(atom) :: charlist
+  def to_charlist(atom) do
     :erlang.atom_to_list(atom)
   end
+
+  @doc false
+  @deprecated "Use Atom.to_charlist/1 instead"
+  @spec to_char_list(atom) :: charlist
+  def to_char_list(atom), do: Atom.to_charlist(atom)
 end
diff --git a/lib/elixir/lib/base.ex b/lib/elixir/lib/base.ex
index ff01c991e73..d2e3da7ca77 100644
--- a/lib/elixir/lib/base.ex
+++ b/lib/elixir/lib/base.ex
@@ -1,151 +1,173 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Base do
   import Bitwise
 
   @moduledoc """
   This module provides data encoding and decoding functions
-  according to [RFC 4648](http://tools.ietf.org/html/rfc4648).
+  according to [RFC 4648](https://tools.ietf.org/html/rfc4648).
 
   This document defines the commonly used base 16, base 32, and base
   64 encoding schemes.
 
   ## Base 16 alphabet
 
-      | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |
-      |------:|---------:|------:|---------:|------:|---------:|------:|---------:|
-      |      0|         0|      4|         4|      8|         8|     12|         C|
-      |      1|         1|      5|         5|      9|         9|     13|         D|
-      |      2|         2|      6|         6|     10|         A|     14|         E|
-      |      3|         3|      7|         7|     11|         B|     15|         F|
+  | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |
+  |------:|:---------|------:|:---------|------:|:---------|------:|:---------|
+  |     0 | 0        |     4 | 4        |     8 | 8        |    12 | C        |
+  |     1 | 1        |     5 | 5        |     9 | 9        |    13 | D        |
+  |     2 | 2        |     6 | 6        |    10 | A        |    14 | E        |
+  |     3 | 3        |     7 | 7        |    11 | B        |    15 | F        |
 
   ## Base 32 alphabet
 
-      | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |
-      |------:|---------:|------:|---------:|------:|---------:|------:|---------:|
-      |      0|         A|      9|         J|     18|         S|     27|         3|
-      |      1|         B|     10|         K|     19|         T|     28|         4|
-      |      2|         C|     11|         L|     20|         U|     29|         5|
-      |      3|         D|     12|         M|     21|         V|     30|         6|
-      |      4|         E|     13|         N|     22|         W|     31|         7|
-      |      5|         F|     14|         O|     23|         X|       |          |
-      |      6|         G|     15|         P|     24|         Y|  (pad)|         =|
-      |      7|         H|     16|         Q|     25|         Z|       |          |
-      |      8|         I|     17|         R|     26|         2|       |          |
+  | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |
+  |------:|:---------|------:|:---------|------:|:---------|------:|:---------|
+  |     0 | A        |     9 | J        |    18 | S        |    27 | 3        |
+  |     1 | B        |    10 | K        |    19 | T        |    28 | 4        |
+  |     2 | C        |    11 | L        |    20 | U        |    29 | 5        |
+  |     3 | D        |    12 | M        |    21 | V        |    30 | 6        |
+  |     4 | E        |    13 | N        |    22 | W        |    31 | 7        |
+  |     5 | F        |    14 | O        |    23 | X        |       |          |
+  |     6 | G        |    15 | P        |    24 | Y        | (pad) | =        |
+  |     7 | H        |    16 | Q        |    25 | Z        |       |          |
+  |     8 | I        |    17 | R        |    26 | 2        |       |          |
 
 
   ## Base 32 (extended hex) alphabet
 
-      | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |
-      |------:|---------:|------:|---------:|------:|---------:|------:|---------:|
-      |      0|         0|      9|         9|     18|         I|     27|         R|
-      |      1|         1|     10|         A|     19|         J|     28|         S|
-      |      2|         2|     11|         B|     20|         K|     29|         T|
-      |      3|         3|     12|         C|     21|         L|     30|         U|
-      |      4|         4|     13|         D|     22|         M|     31|         V|
-      |      5|         5|     14|         E|     23|         N|       |          |
-      |      6|         6|     15|         F|     24|         O|  (pad)|         =|
-      |      7|         7|     16|         G|     25|         P|       |          |
-      |      8|         8|     17|         H|     26|         Q|       |          |
+  | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |
+  |------:|:---------|------:|:---------|------:|:---------|------:|:---------|
+  |     0 | 0        |     9 | 9        |    18 | I        |    27 | R        |
+  |     1 | 1        |    10 | A        |    19 | J        |    28 | S        |
+  |     2 | 2        |    11 | B        |    20 | K        |    29 | T        |
+  |     3 | 3        |    12 | C        |    21 | L        |    30 | U        |
+  |     4 | 4        |    13 | D        |    22 | M        |    31 | V        |
+  |     5 | 5        |    14 | E        |    23 | N        |       |          |
+  |     6 | 6        |    15 | F        |    24 | O        | (pad) | =        |
+  |     7 | 7        |    16 | G        |    25 | P        |       |          |
+  |     8 | 8        |    17 | H        |    26 | Q        |       |          |
 
   ## Base 64 alphabet
 
-      | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |
-      |------:|---------:|------:|---------:|------:|---------:|------:|---------:|
-      |      0|         A|     17|         R|     34|         i|     51|         z|
-      |      1|         B|     18|         S|     35|         j|     52|         0|
-      |      2|         C|     19|         T|     36|         k|     53|         1|
-      |      3|         D|     20|         U|     37|         l|     54|         2|
-      |      4|         E|     21|         V|     38|         m|     55|         3|
-      |      5|         F|     22|         W|     39|         n|     56|         4|
-      |      6|         G|     23|         X|     40|         o|     57|         5|
-      |      7|         H|     24|         Y|     41|         p|     58|         6|
-      |      8|         I|     25|         Z|     42|         q|     59|         7|
-      |      9|         J|     26|         a|     43|         r|     60|         8|
-      |     10|         K|     27|         b|     44|         s|     61|         9|
-      |     11|         L|     28|         c|     45|         t|     62|         +|
-      |     12|         M|     29|         d|     46|         u|     63|         /|
-      |     13|         N|     30|         e|     47|         v|       |          |
-      |     14|         O|     31|         f|     48|         w|  (pad)|         =|
-      |     15|         P|     32|         g|     49|         x|       |          |
-      |     16|         Q|     33|         h|     50|         y|       |          |
+  | Value |  Encoding | Value | Encoding | Value | Encoding | Value | Encoding |
+  |------:|:----------|------:|:---------|------:|:---------|------:|:---------|
+  |     0 | A         |    17 | R        |    34 | i        |    51 | z        |
+  |     1 | B         |    18 | S        |    35 | j        |    52 | 0        |
+  |     2 | C         |    19 | T        |    36 | k        |    53 | 1        |
+  |     3 | D         |    20 | U        |    37 | l        |    54 | 2        |
+  |     4 | E         |    21 | V        |    38 | m        |    55 | 3        |
+  |     5 | F         |    22 | W        |    39 | n        |    56 | 4        |
+  |     6 | G         |    23 | X        |    40 | o        |    57 | 5        |
+  |     7 | H         |    24 | Y        |    41 | p        |    58 | 6        |
+  |     8 | I         |    25 | Z        |    42 | q        |    59 | 7        |
+  |     9 | J         |    26 | a        |    43 | r        |    60 | 8        |
+  |    10 | K         |    27 | b        |    44 | s        |    61 | 9        |
+  |    11 | L         |    28 | c        |    45 | t        |    62 | +        |
+  |    12 | M         |    29 | d        |    46 | u        |    63 | /        |
+  |    13 | N         |    30 | e        |    47 | v        |       |          |
+  |    14 | O         |    31 | f        |    48 | w        | (pad) | =        |
+  |    15 | P         |    32 | g        |    49 | x        |       |          |
+  |    16 | Q         |    33 | h        |    50 | y        |       |          |
 
   ## Base 64 (URL and filename safe) alphabet
 
-      | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |
-      |------:|---------:|------:|---------:|------:|---------:|------:|---------:|
-      |      0|         A|     17|         R|     34|         i|     51|         z|
-      |      1|         B|     18|         S|     35|         j|     52|         0|
-      |      2|         C|     19|         T|     36|         k|     53|         1|
-      |      3|         D|     20|         U|     37|         l|     54|         2|
-      |      4|         E|     21|         V|     38|         m|     55|         3|
-      |      5|         F|     22|         W|     39|         n|     56|         4|
-      |      6|         G|     23|         X|     40|         o|     57|         5|
-      |      7|         H|     24|         Y|     41|         p|     58|         6|
-      |      8|         I|     25|         Z|     42|         q|     59|         7|
-      |      9|         J|     26|         a|     43|         r|     60|         8|
-      |     10|         K|     27|         b|     44|         s|     61|         9|
-      |     11|         L|     28|         c|     45|         t|     62|         -|
-      |     12|         M|     29|         d|     46|         u|     63|         _|
-      |     13|         N|     30|         e|     47|         v|       |          |
-      |     14|         O|     31|         f|     48|         w|  (pad)|         =|
-      |     15|         P|     32|         g|     49|         x|       |          |
-      |     16|         Q|     33|         h|     50|         y|       |          |
+  | Value | Encoding | Value | Encoding | Value | Encoding | Value | Encoding |
+  |------:|:---------|------:|:---------|------:|:---------|------:|:---------|
+  |     0 | A        |    17 | R        |    34 | i        |    51 | z        |
+  |     1 | B        |    18 | S        |    35 | j        |    52 | 0        |
+  |     2 | C        |    19 | T        |    36 | k        |    53 | 1        |
+  |     3 | D        |    20 | U        |    37 | l        |    54 | 2        |
+  |     4 | E        |    21 | V        |    38 | m        |    55 | 3        |
+  |     5 | F        |    22 | W        |    39 | n        |    56 | 4        |
+  |     6 | G        |    23 | X        |    40 | o        |    57 | 5        |
+  |     7 | H        |    24 | Y        |    41 | p        |    58 | 6        |
+  |     8 | I        |    25 | Z        |    42 | q        |    59 | 7        |
+  |     9 | J        |    26 | a        |    43 | r        |    60 | 8        |
+  |    10 | K        |    27 | b        |    44 | s        |    61 | 9        |
+  |    11 | L        |    28 | c        |    45 | t        |    62 | -        |
+  |    12 | M        |    29 | d        |    46 | u        |    63 | _        |
+  |    13 | N        |    30 | e        |    47 | v        |       |          |
+  |    14 | O        |    31 | f        |    48 | w        | (pad) | =        |
+  |    15 | P        |    32 | g        |    49 | x        |       |          |
+  |    16 | Q        |    33 | h        |    50 | y        |       |          |
 
   """
 
-  b16_alphabet    = Enum.with_index '0123456789ABCDEF'
-  b64_alphabet    = Enum.with_index 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-  b64url_alphabet = Enum.with_index 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'
-  b32_alphabet    = Enum.with_index 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
-  b32hex_alphabet = Enum.with_index '0123456789ABCDEFGHIJKLMNOPQRSTUV'
-
-  Enum.each [ {:enc16,    :dec16,    b16_alphabet},
-              {:enc64,    :dec64,    b64_alphabet},
-              {:enc32,    :dec32,    b32_alphabet},
-              {:enc64url, :dec64url, b64url_alphabet},
-              {:enc32hex, :dec32hex, b32hex_alphabet} ], fn({enc, dec, alphabet}) ->
-    for {encoding, value} <- alphabet do
-      defp unquote(enc)(unquote(value)), do: unquote(encoding)
-      defp unquote(dec)(unquote(encoding)), do: unquote(value)
-    end
-    defp unquote(dec)(c) do
-      raise ArgumentError, "non-alphabet digit found: #{<<c>>}"
-    end
-  end
-
-  defp encode_case(:upper, func),
-    do: func
-  defp encode_case(:lower, func),
-    do: &to_lower(func.(&1))
-
-  defp decode_case(:upper, func),
-    do: func
-  defp decode_case(:lower, func),
-    do: &func.(from_lower(&1))
-  defp decode_case(:mixed, func),
-    do: &func.(from_mixed(&1))
-
-  defp to_lower(char) when char in ?A..?Z,
-    do: char + (?a - ?A)
-  defp to_lower(char),
-    do: char
-
-  defp from_lower(char) when char in ?a..?z,
-    do: char - (?a - ?A)
-  defp from_lower(char) when not char in ?A..?Z,
-    do: char
-  defp from_lower(char),
-    do: raise(ArgumentError, "non-alphabet digit found: #{<<char>>}")
-
-  defp from_mixed(char) when char in ?a..?z,
-    do: char - (?a - ?A)
-  defp from_mixed(char),
-    do: char
+  @type encode_case :: :upper | :lower
+  @type decode_case :: :upper | :lower | :mixed
+
+  b16_alphabet = ~c"0123456789ABCDEF"
+  b64_alphabet = ~c"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+  b64url_alphabet = ~c"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+  b32_alphabet = ~c"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
+  b32hex_alphabet = ~c"0123456789ABCDEFGHIJKLMNOPQRSTUV"
+
+  to_lower_enc = &Enum.map(&1, fn c -> if c in ?A..?Z, do: c - ?A + ?a, else: c end)
+
+  to_mixed_dec =
+    &Enum.flat_map(&1, fn {encoding, value} = pair ->
+      if encoding in ?A..?Z do
+        [pair, {encoding - ?A + ?a, value}]
+      else
+        [pair]
+      end
+    end)
+
+  to_lower_dec =
+    &Enum.map(&1, fn {encoding, value} = pair ->
+      if encoding in ?A..?Z do
+        {encoding - ?A + ?a, value}
+      else
+        pair
+      end
+    end)
+
+  to_encode_list = fn alphabet ->
+    for e1 <- alphabet, e2 <- alphabet, do: bsl(e1, 8) + e2
+  end
+
+  to_decode_list = fn alphabet ->
+    alphabet = Enum.sort(alphabet)
+    map = Map.new(alphabet)
+    {min, _} = List.first(alphabet)
+    {max, _} = List.last(alphabet)
+    {min, Enum.map(min..max, &map[&1])}
+  end
+
+  defp bad_character!(byte) do
+    raise ArgumentError,
+          "non-alphabet character found: #{inspect(<<byte>>, binaries: :as_strings)} (byte #{byte})"
+  end
+
+  defp maybe_pad(acc, false, _count), do: acc
+  defp maybe_pad(acc, true, 6), do: acc <> "======"
+  defp maybe_pad(acc, true, 4), do: acc <> "===="
+  defp maybe_pad(acc, true, 3), do: acc <> "==="
+  defp maybe_pad(acc, true, 2), do: acc <> "=="
+  defp maybe_pad(acc, true, 1), do: acc <> "="
+
+  defp remove_ignored(string, nil), do: string
+
+  defp remove_ignored(string, :whitespace) do
+    for <<char::8 <- string>>, char not in ~c"\s\t\r\n", into: <<>>, do: <<char::8>>
+  end
 
   @doc """
   Encodes a binary string into a base 16 encoded string.
 
-  Accepts an atom `:upper` (default) for encoding to upper case characters or
-  `:lower` for lower case characters.
+  ## Options
+
+  The accepted options are:
+
+    * `:case` - specifies the character case to use when encoding
+
+  The values for `:case` can be:
+
+    * `:upper` - uses upper case characters (default)
+    * `:lower` - uses lower case characters
 
   ## Examples
 
@@ -156,20 +178,80 @@ defmodule Base do
       "666f6f626172"
 
   """
-  @spec encode16(binary) :: binary
-  @spec encode16(binary, Keyword.t) :: binary
+  @spec encode16(binary, case: encode_case) :: binary
   def encode16(data, opts \\ []) when is_binary(data) do
-    case = Keyword.get(opts, :case, :upper)
-    do_encode16(data, encode_case(case, &enc16/1))
+    case Keyword.get(opts, :case, :upper) do
+      :upper -> encode16upper(data, "")
+      :lower -> encode16lower(data, "")
+    end
   end
 
+  for {base, alphabet} <- [upper: b16_alphabet, lower: to_lower_enc.(b16_alphabet)] do
+    name = :"encode16#{base}"
+    encoded = to_encode_list.(alphabet)
+
+    @compile {:inline, [{name, 1}]}
+    defp unquote(name)(byte) do
+      elem({unquote_splicing(encoded)}, byte)
+    end
+
+    defp unquote(name)(<<c1, c2, c3, c4, c5, c6, c7, c8, rest::binary>>, acc) do
+      unquote(name)(
+        rest,
+        <<
+          acc::binary,
+          unquote(name)(c1)::16,
+          unquote(name)(c2)::16,
+          unquote(name)(c3)::16,
+          unquote(name)(c4)::16,
+          unquote(name)(c5)::16,
+          unquote(name)(c6)::16,
+          unquote(name)(c7)::16,
+          unquote(name)(c8)::16
+        >>
+      )
+    end
+
+    defp unquote(name)(<<c1, c2, c3, c4, rest::binary>>, acc) do
+      unquote(name)(
+        rest,
+        <<
+          acc::binary,
+          unquote(name)(c1)::16,
+          unquote(name)(c2)::16,
+          unquote(name)(c3)::16,
+          unquote(name)(c4)::16
+        >>
+      )
+    end
+
+    defp unquote(name)(<<c1, c2, rest::binary>>, acc) do
+      unquote(name)(rest, <<acc::binary, unquote(name)(c1)::16, unquote(name)(c2)::16>>)
+    end
+
+    defp unquote(name)(<<c1, rest::binary>>, acc) do
+      unquote(name)(rest, <<acc::binary, unquote(name)(c1)::16>>)
+    end
+
+    defp unquote(name)(<<>>, acc) do
+      acc
+    end
+  end
 
   @doc """
   Decodes a base 16 encoded string into a binary string.
 
-  Accepts an atom `:upper` (default) for decoding from upper case characters or
-  `:lower` for lower case characters. `:mixed` can be given for mixed case
-  characters.
+  ## Options
+
+  The accepted options are:
+
+    * `:case` - specifies the character case to accept when decoding
+
+  The values for `:case` can be:
+
+    * `:upper` - only allows upper case characters (default)
+    * `:lower` - only allows lower case characters
+    * `:mixed` - allows mixed case characters
 
   ## Examples
 
@@ -183,11 +265,9 @@ defmodule Base do
       {:ok, "foobar"}
 
   """
-  @spec decode16(binary) :: {:ok, binary} | :error
-  @spec decode16(binary, Keyword.t) :: {:ok, binary} | :error
-  def decode16(string, opts \\ []) when is_binary(string) do
-    case = Keyword.get(opts, :case, :upper)
-    {:ok, do_decode16(string, decode_case(case, &dec16/1))}
+  @spec decode16(binary, case: decode_case) :: {:ok, binary} | :error
+  def decode16(string, opts \\ []) do
+    {:ok, decode16!(string, opts)}
   rescue
     ArgumentError -> :error
   end
@@ -195,9 +275,17 @@ defmodule Base do
   @doc """
   Decodes a base 16 encoded string into a binary string.
 
-  Accepts an atom `:upper` (default) for decoding from upper case characters or
-  `:lower` for lower case characters. `:mixed` can be given for mixed case
-  characters.
+  ## Options
+
+  The accepted options are:
+
+    * `:case` - specifies the character case to accept when decoding
+
+  The values for `:case` can be:
+
+    * `:upper` - only allows upper case characters (default)
+    * `:lower` - only allows lower case characters
+    * `:mixed` - allows mixed case characters
 
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
@@ -214,39 +302,294 @@ defmodule Base do
       "foobar"
 
   """
-  @spec decode16!(binary) :: binary
-  @spec decode16!(binary, Keyword.t) :: binary
-  def decode16!(string, opts \\ []) when is_binary(string) do
-    case = Keyword.get(opts, :case, :upper)
-    do_decode16(string, decode_case(case, &dec16/1))
+  @spec decode16!(binary, case: decode_case) :: binary
+  def decode16!(string, opts \\ [])
+
+  def decode16!(string, opts) when is_binary(string) and rem(byte_size(string), 2) == 0 do
+    case Keyword.get(opts, :case, :upper) do
+      :upper -> decode16upper!(string, "")
+      :lower -> decode16lower!(string, "")
+      :mixed -> decode16mixed!(string, "")
+    end
+  end
+
+  def decode16!(string, _opts) when is_binary(string) do
+    raise ArgumentError,
+          "string given to decode has wrong length. An even number of bytes was expected, got: #{byte_size(string)}. " <>
+            "Double check your string for unwanted characters or pad it accordingly"
+  end
+
+  @doc """
+  Checks if a string is a valid base 16 encoded string.
+
+  > #### When to use this {: .tip}
+  >
+  > Use this function when you just need to *validate* that a string is
+  > valid base 16 data, without actually producing a decoded output string.
+  > This function is both more performant and memory efficient than using
+  > `decode16/2`, checking that the result is `{:ok, ...}`, and then
+  > discarding the decoded binary.
+
+  ## Options
+
+  Accepts the same options as `decode16/2`.
+
+  ## Examples
+
+      iex> Base.valid16?("666F6F626172")
+      true
+
+      iex> Base.valid16?("666f6f626172", case: :lower)
+      true
+
+      iex> Base.valid16?("666f6F626172", case: :mixed)
+      true
+
+      iex> Base.valid16?("ff", case: :upper)
+      false
+
+  """
+  @doc since: "1.19.0"
+  @spec valid16?(binary, case: decode_case) :: boolean
+  def valid16?(string, opts \\ [])
+
+  def valid16?(string, opts) when is_binary(string) and rem(byte_size(string), 2) == 0 do
+    case Keyword.get(opts, :case, :upper) do
+      :upper -> validate16upper?(string)
+      :lower -> validate16lower?(string)
+      :mixed -> validate16mixed?(string)
+    end
+  end
+
+  def valid16?(string, _opts) when is_binary(string) do
+    false
+  end
+
+  upper = Enum.with_index(b16_alphabet)
+
+  for {base, alphabet} <- [upper: upper, lower: to_lower_dec.(upper), mixed: to_mixed_dec.(upper)] do
+    decode_name = :"decode16#{base}!"
+    validate_name = :"validate16#{base}?"
+    valid_char_name = :"valid_char16#{base}?"
+
+    {min, decoded} = to_decode_list.(alphabet)
+
+    defp unquote(validate_name)(<<>>), do: true
+
+    defp unquote(validate_name)(<<c1, c2, rest::binary>>) do
+      unquote(valid_char_name)(c1) and
+        unquote(valid_char_name)(c2) and
+        unquote(validate_name)(rest)
+    end
+
+    defp unquote(validate_name)(<<_char, _rest::binary>>), do: false
+
+    @compile {:inline, [{valid_char_name, 1}]}
+    defp unquote(valid_char_name)(char)
+         when elem({unquote_splicing(decoded)}, char - unquote(min)) != nil,
+         do: true
+
+    defp unquote(valid_char_name)(_char), do: false
+
+    defp unquote(decode_name)(char) do
+      index = char - unquote(min)
+
+      cond do
+        index not in 0..unquote(length(decoded) - 1) -> bad_character!(char)
+        new_char = elem({unquote_splicing(decoded)}, index) -> new_char
+        true -> bad_character!(char)
+      end
+    end
+
+    defp unquote(decode_name)(<<c1, c2, c3, c4, c5, c6, c7, c8, rest::binary>>, acc) do
+      unquote(decode_name)(
+        rest,
+        <<
+          acc::binary,
+          unquote(decode_name)(c1)::4,
+          unquote(decode_name)(c2)::4,
+          unquote(decode_name)(c3)::4,
+          unquote(decode_name)(c4)::4,
+          unquote(decode_name)(c5)::4,
+          unquote(decode_name)(c6)::4,
+          unquote(decode_name)(c7)::4,
+          unquote(decode_name)(c8)::4
+        >>
+      )
+    end
+
+    defp unquote(decode_name)(<<c1, c2, c3, c4, rest::binary>>, acc) do
+      unquote(decode_name)(
+        rest,
+        <<
+          acc::binary,
+          unquote(decode_name)(c1)::4,
+          unquote(decode_name)(c2)::4,
+          unquote(decode_name)(c3)::4,
+          unquote(decode_name)(c4)::4
+        >>
+      )
+    end
+
+    defp unquote(decode_name)(<<c1::8, c2::8, rest::binary>>, acc) do
+      unquote(decode_name)(
+        rest,
+        <<acc::binary, unquote(decode_name)(c1)::4, unquote(decode_name)(c2)::4>>
+      )
+    end
+
+    defp unquote(decode_name)(<<>>, acc) do
+      acc
+    end
   end
 
   @doc """
   Encodes a binary string into a base 64 encoded string.
 
+  Accepts `padding: false` option which will omit padding from
+  the output string.
+
   ## Examples
 
       iex> Base.encode64("foobar")
       "Zm9vYmFy"
 
+      iex> Base.encode64("foob")
+      "Zm9vYg=="
+
+      iex> Base.encode64("foob", padding: false)
+      "Zm9vYg"
+
+  """
+  @spec encode64(binary, padding: boolean) :: binary
+  def encode64(data, opts \\ []) when is_binary(data) do
+    pad? = Keyword.get(opts, :padding, true)
+    encode64base(data, "", pad?)
+  end
+
+  @doc """
+  Encodes a binary string into a base 64 encoded string with URL and filename
+  safe alphabet.
+
+  Accepts `padding: false` option which will omit padding from
+  the output string.
+
+  ## Examples
+
+      iex> Base.url_encode64(<<255, 127, 254, 252>>)
+      "_3_-_A=="
+
+      iex> Base.url_encode64(<<255, 127, 254, 252>>, padding: false)
+      "_3_-_A"
+
   """
-  @spec encode64(binary) :: binary
-  def encode64(data) when is_binary(data) do
-    do_encode64(data, &enc64/1)
+  @spec url_encode64(binary, padding: boolean) :: binary
+  def url_encode64(data, opts \\ []) when is_binary(data) do
+    pad? = Keyword.get(opts, :padding, true)
+    encode64url(data, "", pad?)
+  end
+
+  for {base, alphabet} <- [base: b64_alphabet, url: b64url_alphabet] do
+    name = :"encode64#{base}"
+    encoded = to_encode_list.(alphabet)
+
+    @compile {:inline, [{name, 1}]}
+    defp unquote(name)(byte) do
+      elem({unquote_splicing(encoded)}, byte)
+    end
+
+    defp unquote(name)(<<c1::12, c2::12, c3::12, c4::12, rest::binary>>, acc, pad?) do
+      unquote(name)(
+        rest,
+        <<
+          acc::binary,
+          unquote(name)(c1)::16,
+          unquote(name)(c2)::16,
+          unquote(name)(c3)::16,
+          unquote(name)(c4)::16
+        >>,
+        pad?
+      )
+    end
+
+    defp unquote(name)(<<c1::12, c2::12, c3::12, c4::4>>, acc, pad?) do
+      <<
+        acc::binary,
+        unquote(name)(c1)::16,
+        unquote(name)(c2)::16,
+        unquote(name)(c3)::16,
+        c4 |> bsl(2) |> unquote(name)() |> band(0x00FF)::8
+      >>
+      |> maybe_pad(pad?, 1)
+    end
+
+    defp unquote(name)(<<c1::12, c2::12, c3::8>>, acc, pad?) do
+      <<
+        acc::binary,
+        unquote(name)(c1)::16,
+        unquote(name)(c2)::16,
+        c3 |> bsl(4) |> unquote(name)()::16
+      >>
+      |> maybe_pad(pad?, 2)
+    end
+
+    defp unquote(name)(<<c1::12, c2::12>>, acc, _pad?) do
+      <<
+        acc::binary,
+        unquote(name)(c1)::16,
+        unquote(name)(c2)::16
+      >>
+    end
+
+    defp unquote(name)(<<c1::12, c2::4>>, acc, pad?) do
+      <<
+        acc::binary,
+        unquote(name)(c1)::16,
+        c2 |> bsl(2) |> unquote(name)() |> band(0x00FF)::8
+      >>
+      |> maybe_pad(pad?, 1)
+    end
+
+    defp unquote(name)(<<c1::8>>, acc, pad?) do
+      <<
+        acc::binary,
+        c1 |> bsl(4) |> unquote(name)()::16
+      >>
+      |> maybe_pad(pad?, 2)
+    end
+
+    defp unquote(name)(<<>>, acc, _pad?) do
+      acc
+    end
   end
 
   @doc """
   Decodes a base 64 encoded string into a binary string.
 
+  Accepts `ignore: :whitespace` option which will ignore all the
+  whitespace characters in the input string.
+
+  Accepts `padding: false` option which will ignore padding from
+  the input string.
+
   ## Examples
 
       iex> Base.decode64("Zm9vYmFy")
       {:ok, "foobar"}
 
+      iex> Base.decode64("Zm9vYmFy\\n", ignore: :whitespace)
+      {:ok, "foobar"}
+
+      iex> Base.decode64("Zm9vYg==")
+      {:ok, "foob"}
+
+      iex> Base.decode64("Zm9vYg", padding: false)
+      {:ok, "foob"}
+
   """
-  @spec decode64(binary) :: {:ok, binary} | :error
-  def decode64(string) when is_binary(string) do
-    {:ok, do_decode64(string, &dec64/1)}
+  @spec decode64(binary, ignore: :whitespace, padding: boolean) :: {:ok, binary} | :error
+  def decode64(string, opts \\ []) when is_binary(string) do
+    {:ok, decode64!(string, opts)}
   rescue
     ArgumentError -> :error
   end
@@ -254,7 +597,11 @@ defmodule Base do
   @doc """
   Decodes a base 64 encoded string into a binary string.
 
-  The following alphabet is used both for encoding and decoding:
+  Accepts `ignore: :whitespace` option which will ignore all the
+  whitespace characters in the input string.
+
+  Accepts `padding: false` option which will ignore padding from
+  the input string.
 
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
@@ -264,40 +611,81 @@ defmodule Base do
       iex> Base.decode64!("Zm9vYmFy")
       "foobar"
 
+      iex> Base.decode64!("Zm9vYmFy\\n", ignore: :whitespace)
+      "foobar"
+
+      iex> Base.decode64!("Zm9vYg==")
+      "foob"
+
+      iex> Base.decode64!("Zm9vYg", padding: false)
+      "foob"
+
   """
-  @spec decode64!(binary) :: binary
-  def decode64!(string) when is_binary(string) do
-    do_decode64(string, &dec64/1)
+  @spec decode64!(binary, ignore: :whitespace, padding: boolean) :: binary
+  def decode64!(string, opts \\ []) when is_binary(string) do
+    pad? = Keyword.get(opts, :padding, true)
+    string |> remove_ignored(opts[:ignore]) |> decode64base!(pad?)
   end
 
   @doc """
-  Encodes a binary string into a base 64 encoded string with URL and filename
-  safe alphabet.
+  Validates a base 64 encoded string.
+
+  > #### When to use this {: .tip}
+  >
+  > Use this function when you just need to *validate* that a string is
+  > valid base 64 data, without actually producing a decoded output string.
+  > This function is both more performant and memory efficient than using
+  > `decode64/2`, checking that the result is `{:ok, ...}`, and then
+  > discarding the decoded binary.
+
+  ## Options
+
+  Accepts the same options as `decode64/2`.
 
   ## Examples
 
-      iex> Base.url_encode64(<<255,127,254,252>>)
-      "_3_-_A=="
+      iex> Base.valid64?("Zm9vYmFy")
+      true
+
+      iex> Base.valid64?("Zm9vYmFy\\n", ignore: :whitespace)
+      true
+
+      iex> Base.valid64?("Zm9vYg==")
+      true
 
   """
-  @spec url_encode64(binary) :: binary
-  def url_encode64(data) when is_binary(data) do
-    do_encode64(data, &enc64url/1)
+  @doc since: "1.19.0"
+  @spec valid64?(binary, ignore: :whitespace, padding: boolean) :: boolean
+  def valid64?(string, opts \\ []) when is_binary(string) do
+    pad? = Keyword.get(opts, :padding, true)
+    string |> remove_ignored(opts[:ignore]) |> validate64base?(pad?)
   end
 
   @doc """
   Decodes a base 64 encoded string with URL and filename safe alphabet
   into a binary string.
 
+  Accepts `ignore: :whitespace` option which will ignore all the
+  whitespace characters in the input string.
+
+  Accepts `padding: false` option which will ignore padding from
+  the input string.
+
   ## Examples
 
       iex> Base.url_decode64("_3_-_A==")
-      {:ok, <<255,127,254,252>>}
+      {:ok, <<255, 127, 254, 252>>}
+
+      iex> Base.url_decode64("_3_-_A==\\n", ignore: :whitespace)
+      {:ok, <<255, 127, 254, 252>>}
+
+      iex> Base.url_decode64("_3_-_A", padding: false)
+      {:ok, <<255, 127, 254, 252>>}
 
   """
-  @spec url_decode64(binary) :: {:ok, binary} | :error
-  def url_decode64(string) when is_binary(string) do
-    {:ok, do_decode64(string, &dec64url/1)}
+  @spec url_decode64(binary, ignore: :whitespace, padding: boolean) :: {:ok, binary} | :error
+  def url_decode64(string, opts \\ []) when is_binary(string) do
+    {:ok, url_decode64!(string, opts)}
   rescue
     ArgumentError -> :error
   end
@@ -306,25 +694,320 @@ defmodule Base do
   Decodes a base 64 encoded string with URL and filename safe alphabet
   into a binary string.
 
+  Accepts `ignore: :whitespace` option which will ignore all the
+  whitespace characters in the input string.
+
+  Accepts `padding: false` option which will ignore padding from
+  the input string.
+
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
 
   ## Examples
 
       iex> Base.url_decode64!("_3_-_A==")
-      <<255,127,254,252>>
+      <<255, 127, 254, 252>>
+
+      iex> Base.url_decode64!("_3_-_A==\\n", ignore: :whitespace)
+      <<255, 127, 254, 252>>
+
+      iex> Base.url_decode64!("_3_-_A", padding: false)
+      <<255, 127, 254, 252>>
+
+  """
+  @spec url_decode64!(binary, ignore: :whitespace, padding: boolean) :: binary
+  def url_decode64!(string, opts \\ []) when is_binary(string) do
+    pad? = Keyword.get(opts, :padding, true)
+    string |> remove_ignored(opts[:ignore]) |> decode64url!(pad?)
+  end
+
+  @doc """
+  Validates a base 64 encoded string with URL and filename safe alphabet.
+
+  > #### When to use this {: .tip}
+  >
+  > Use this function when you just need to *validate* that a string is
+  > valid (URL-safe) base 64 data, without actually producing a decoded
+  > output string. This function is both more performant and memory efficient
+  > than using `url_decode64/2`, checking that the result is `{:ok, ...}`,
+  > and then discarding the decoded binary.
+
+  ## Options
+
+  Accepts the same options as `url_decode64/2`.
+
+  ## Examples
+
+      iex> Base.url_valid64?("_3_-_A==")
+      true
+
+      iex> Base.url_valid64?("_3_-_A==\\n", ignore: :whitespace)
+      true
+
+      iex> Base.url_valid64?("_3_-_A", padding: false)
+      true
 
   """
-  @spec url_decode64!(binary) :: binary
-  def url_decode64!(string) when is_binary(string) do
-    do_decode64(string, &dec64url/1)
+  @doc since: "1.19.0"
+  @spec url_valid64?(binary, ignore: :whitespace, padding: boolean) :: boolean
+  def url_valid64?(string, opts \\ []) when is_binary(string) do
+    pad? = Keyword.get(opts, :padding, true)
+    string |> remove_ignored(opts[:ignore]) |> validate64url?(pad?)
+  end
+
+  for {base, alphabet} <- [base: b64_alphabet, url: b64url_alphabet] do
+    decode_name = :"decode64#{base}!"
+
+    validate_name = :"validate64#{base}?"
+    validate_main_name = :"validate_main64#{validate_name}?"
+    valid_char_name = :"valid_char64#{base}?"
+    {min, decoded} = alphabet |> Enum.with_index() |> to_decode_list.()
+
+    defp unquote(validate_main_name)(<<>>), do: true
+
+    defp unquote(validate_main_name)(
+           <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8, rest::binary>>
+         ) do
+      unquote(valid_char_name)(c1) and
+        unquote(valid_char_name)(c2) and
+        unquote(valid_char_name)(c3) and
+        unquote(valid_char_name)(c4) and
+        unquote(valid_char_name)(c5) and
+        unquote(valid_char_name)(c6) and
+        unquote(valid_char_name)(c7) and
+        unquote(valid_char_name)(c8) and
+        unquote(validate_main_name)(rest)
+    end
+
+    defp unquote(validate_name)(<<>>, _pad?), do: true
+
+    defp unquote(validate_name)(string, pad?) do
+      segs = div(byte_size(string) + 7, 8) - 1
+      <<main::size(^segs)-binary-unit(64), rest::binary>> = string
+      main_valid? = unquote(validate_main_name)(main)
+
+      case rest do
+        _ when not main_valid? ->
+          false
+
+        <<c1::8, c2::8, ?=, ?=>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2)
+
+        <<c1::8, c2::8, c3::8, ?=>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3)
+
+        <<c1::8, c2::8, c3::8, c4::8>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4)
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, ?=, ?=>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4) and
+            unquote(valid_char_name)(c5) and
+            unquote(valid_char_name)(c6)
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, ?=>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4) and
+            unquote(valid_char_name)(c5) and
+            unquote(valid_char_name)(c6) and
+            unquote(valid_char_name)(c7)
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4) and
+            unquote(valid_char_name)(c5) and
+            unquote(valid_char_name)(c6) and
+            unquote(valid_char_name)(c7) and
+            unquote(valid_char_name)(c8)
+
+        <<c1::8, c2::8>> when not pad? ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2)
+
+        <<c1::8, c2::8, c3::8>> when not pad? ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3)
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8>> when not pad? ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4) and
+            unquote(valid_char_name)(c5) and
+            unquote(valid_char_name)(c6)
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8>> when not pad? ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4) and
+            unquote(valid_char_name)(c5) and
+            unquote(valid_char_name)(c6) and
+            unquote(valid_char_name)(c7)
+
+        _ ->
+          false
+      end
+    end
+
+    @compile {:inline, [{valid_char_name, 1}]}
+    defp unquote(valid_char_name)(char)
+         when elem({unquote_splicing(decoded)}, char - unquote(min)) != nil,
+         do: true
+
+    defp unquote(valid_char_name)(_char), do: false
+
+    defp unquote(decode_name)(char) do
+      index = char - unquote(min)
+
+      cond do
+        index not in 0..unquote(length(decoded) - 1) -> bad_character!(char)
+        new_char = elem({unquote_splicing(decoded)}, index) -> new_char
+        true -> bad_character!(char)
+      end
+    end
+
+    defp unquote(decode_name)(<<>>, _pad?), do: <<>>
+
+    defp unquote(decode_name)(string, pad?) do
+      segs = div(byte_size(string) + 7, 8) - 1
+      <<main::size(^segs)-binary-unit(64), rest::binary>> = string
+
+      main =
+        for <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8 <- main>>, into: <<>> do
+          <<
+            unquote(decode_name)(c1)::6,
+            unquote(decode_name)(c2)::6,
+            unquote(decode_name)(c3)::6,
+            unquote(decode_name)(c4)::6,
+            unquote(decode_name)(c5)::6,
+            unquote(decode_name)(c6)::6,
+            unquote(decode_name)(c7)::6,
+            unquote(decode_name)(c8)::6
+          >>
+        end
+
+      case rest do
+        <<c1::8, c2::8, ?=, ?=>> ->
+          <<main::bits, unquote(decode_name)(c1)::6, bsr(unquote(decode_name)(c2), 4)::2>>
+
+        <<c1::8, c2::8, c3::8, ?=>> ->
+          <<main::bits, unquote(decode_name)(c1)::6, unquote(decode_name)(c2)::6,
+            bsr(unquote(decode_name)(c3), 2)::4>>
+
+        <<c1::8, c2::8, c3::8, c4::8>> ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::6,
+            unquote(decode_name)(c2)::6,
+            unquote(decode_name)(c3)::6,
+            unquote(decode_name)(c4)::6
+          >>
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, ?=, ?=>> ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::6,
+            unquote(decode_name)(c2)::6,
+            unquote(decode_name)(c3)::6,
+            unquote(decode_name)(c4)::6,
+            unquote(decode_name)(c5)::6,
+            bsr(unquote(decode_name)(c6), 4)::2
+          >>
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, ?=>> ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::6,
+            unquote(decode_name)(c2)::6,
+            unquote(decode_name)(c3)::6,
+            unquote(decode_name)(c4)::6,
+            unquote(decode_name)(c5)::6,
+            unquote(decode_name)(c6)::6,
+            bsr(unquote(decode_name)(c7), 2)::4
+          >>
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8>> ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::6,
+            unquote(decode_name)(c2)::6,
+            unquote(decode_name)(c3)::6,
+            unquote(decode_name)(c4)::6,
+            unquote(decode_name)(c5)::6,
+            unquote(decode_name)(c6)::6,
+            unquote(decode_name)(c7)::6,
+            unquote(decode_name)(c8)::6
+          >>
+
+        <<c1::8, c2::8>> when not pad? ->
+          <<main::bits, unquote(decode_name)(c1)::6, bsr(unquote(decode_name)(c2), 4)::2>>
+
+        <<c1::8, c2::8, c3::8>> when not pad? ->
+          <<main::bits, unquote(decode_name)(c1)::6, unquote(decode_name)(c2)::6,
+            bsr(unquote(decode_name)(c3), 2)::4>>
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8>> when not pad? ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::6,
+            unquote(decode_name)(c2)::6,
+            unquote(decode_name)(c3)::6,
+            unquote(decode_name)(c4)::6,
+            unquote(decode_name)(c5)::6,
+            bsr(unquote(decode_name)(c6), 4)::2
+          >>
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8>> when not pad? ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::6,
+            unquote(decode_name)(c2)::6,
+            unquote(decode_name)(c3)::6,
+            unquote(decode_name)(c4)::6,
+            unquote(decode_name)(c5)::6,
+            unquote(decode_name)(c6)::6,
+            bsr(unquote(decode_name)(c7), 2)::4
+          >>
+
+        _ ->
+          raise ArgumentError, "incorrect padding"
+      end
+    end
   end
 
   @doc """
   Encodes a binary string into a base 32 encoded string.
 
-  Accepts an atom `:upper` (default) for encoding to upper case characters or
-  `:lower` for lower case characters.
+  ## Options
+
+  The accepted options are:
+
+    * `:case` - specifies the character case to use when encoding
+    * `:padding` - specifies whether to apply padding
+
+  The values for `:case` can be:
+
+    * `:upper` - uses upper case characters (default)
+    * `:lower` - uses lower case characters
+
+  The values for `:padding` can be:
+
+    * `true` - pad the output string to the nearest multiple of 8 (default)
+    * `false` - omit padding from the output string
 
   ## Examples
 
@@ -334,20 +1017,151 @@ defmodule Base do
       iex> Base.encode32("foobar", case: :lower)
       "mzxw6ytboi======"
 
+      iex> Base.encode32("foobar", padding: false)
+      "MZXW6YTBOI"
+
   """
-  @spec encode32(binary) :: binary
-  @spec encode32(binary, Keyword.t) :: binary
+  @spec encode32(binary, case: encode_case, padding: boolean) :: binary
   def encode32(data, opts \\ []) when is_binary(data) do
-    case = Keyword.get(opts, :case, :upper)
-    do_encode32(data, encode_case(case, &enc32/1))
+    pad? = Keyword.get(opts, :padding, true)
+
+    case Keyword.get(opts, :case, :upper) do
+      :upper -> encode32upper(data, "", pad?)
+      :lower -> encode32lower(data, "", pad?)
+    end
+  end
+
+  @doc """
+  Encodes a binary string into a base 32 encoded string with an
+  extended hexadecimal alphabet.
+
+  ## Options
+
+  The accepted options are:
+
+    * `:case` - specifies the character case to use when encoding
+    * `:padding` - specifies whether to apply padding
+
+  The values for `:case` can be:
+
+    * `:upper` - uses upper case characters (default)
+    * `:lower` - uses lower case characters
+
+  The values for `:padding` can be:
+
+    * `true` - pad the output string to the nearest multiple of 8 (default)
+    * `false` - omit padding from the output string
+
+  ## Examples
+
+      iex> Base.hex_encode32("foobar")
+      "CPNMUOJ1E8======"
+
+      iex> Base.hex_encode32("foobar", case: :lower)
+      "cpnmuoj1e8======"
+
+      iex> Base.hex_encode32("foobar", padding: false)
+      "CPNMUOJ1E8"
+
+  """
+  @spec hex_encode32(binary, case: encode_case, padding: boolean) :: binary
+  def hex_encode32(data, opts \\ []) when is_binary(data) do
+    pad? = Keyword.get(opts, :padding, true)
+
+    case Keyword.get(opts, :case, :upper) do
+      :upper -> encode32hexupper(data, "", pad?)
+      :lower -> encode32hexlower(data, "", pad?)
+    end
+  end
+
+  for {base, alphabet} <- [
+        upper: b32_alphabet,
+        lower: to_lower_enc.(b32_alphabet),
+        hexupper: b32hex_alphabet,
+        hexlower: to_lower_enc.(b32hex_alphabet)
+      ] do
+    name = :"encode32#{base}"
+    encoded = to_encode_list.(alphabet)
+
+    @compile {:inline, [{name, 1}]}
+    defp unquote(name)(byte) do
+      elem({unquote_splicing(encoded)}, byte)
+    end
+
+    defp unquote(name)(<<c1::10, c2::10, c3::10, c4::10, rest::binary>>, acc, pad?) do
+      unquote(name)(
+        rest,
+        <<
+          acc::binary,
+          unquote(name)(c1)::16,
+          unquote(name)(c2)::16,
+          unquote(name)(c3)::16,
+          unquote(name)(c4)::16
+        >>,
+        pad?
+      )
+    end
+
+    defp unquote(name)(<<c1::10, c2::10, c3::10, c4::2>>, acc, pad?) do
+      <<
+        acc::binary,
+        unquote(name)(c1)::16,
+        unquote(name)(c2)::16,
+        unquote(name)(c3)::16,
+        c4 |> bsl(3) |> unquote(name)() |> band(0x00FF)::8
+      >>
+      |> maybe_pad(pad?, 1)
+    end
+
+    defp unquote(name)(<<c1::10, c2::10, c3::4>>, acc, pad?) do
+      <<
+        acc::binary,
+        unquote(name)(c1)::16,
+        unquote(name)(c2)::16,
+        c3 |> bsl(1) |> unquote(name)() |> band(0x00FF)::8
+      >>
+      |> maybe_pad(pad?, 3)
+    end
+
+    defp unquote(name)(<<c1::10, c2::6>>, acc, pad?) do
+      <<
+        acc::binary,
+        unquote(name)(c1)::16,
+        c2 |> bsl(4) |> unquote(name)()::16
+      >>
+      |> maybe_pad(pad?, 4)
+    end
+
+    defp unquote(name)(<<c1::8>>, acc, pad?) do
+      <<acc::binary, c1 |> bsl(2) |> unquote(name)()::16>>
+      |> maybe_pad(pad?, 6)
+    end
+
+    defp unquote(name)(<<>>, acc, _pad?) do
+      acc
+    end
   end
 
   @doc """
   Decodes a base 32 encoded string into a binary string.
 
-  Accepts an atom `:upper` (default) for decoding from upper case characters or
-  `:lower` for lower case characters. `:mixed` can be given for mixed case
-  characters.
+  ## Options
+
+  The accepted options are:
+
+    * `:case` - specifies the character case to accept when decoding
+    * `:padding` - specifies whether to require padding
+
+  The values for `:case` can be:
+
+    * `:upper` - only allows  upper case characters (default)
+    * `:lower` - only allows lower case characters
+    * `:mixed` - allows mixed case characters
+
+  The values for `:padding` can be:
+
+    * `true` - requires the input string to be padded to the nearest multiple of 8 (default)
+    * `false` - ignores padding from the input string
 
   ## Examples
 
@@ -360,12 +1174,13 @@ defmodule Base do
       iex> Base.decode32("mzXW6ytBOi======", case: :mixed)
       {:ok, "foobar"}
 
+      iex> Base.decode32("MZXW6YTBOI", padding: false)
+      {:ok, "foobar"}
+
   """
-  @spec decode32(binary) :: {:ok, binary} | :error
-  @spec decode32(binary, Keyword.t) :: {:ok, binary} | :error
+  @spec decode32(binary, case: decode_case, padding: boolean) :: {:ok, binary} | :error
   def decode32(string, opts \\ []) do
-    case = Keyword.get(opts, :case, :upper)
-    {:ok, do_decode32(string, decode_case(case, &dec32/1))}
+    {:ok, decode32!(string, opts)}
   rescue
     ArgumentError -> :error
   end
@@ -373,13 +1188,27 @@ defmodule Base do
   @doc """
   Decodes a base 32 encoded string into a binary string.
 
-  Accepts an atom `:upper` (default) for decoding from upper case characters or
-  `:lower` for lower case characters. `:mixed` can be given for mixed case
-  characters.
-
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
 
+  ## Options
+
+  The accepted options are:
+
+    * `:case` - specifies the character case to accept when decoding
+    * `:padding` - specifies whether to require padding
+
+  The values for `:case` can be:
+
+    * `:upper` - only allows upper case characters (default)
+    * `:lower` - only allows lower case characters
+    * `:mixed` - allows mixed case characters
+
+  The values for `:padding` can be:
+
+    * `true` - requires the input string to be padded to the nearest multiple of 8 (default)
+    * `false` - ignores padding from the input string
+
   ## Examples
 
       iex> Base.decode32!("MZXW6YTBOI======")
@@ -391,44 +1220,81 @@ defmodule Base do
       iex> Base.decode32!("mzXW6ytBOi======", case: :mixed)
       "foobar"
 
+      iex> Base.decode32!("MZXW6YTBOI", padding: false)
+      "foobar"
+
   """
-  @spec decode32!(binary) :: binary
-  @spec decode32!(binary, Keyword.t) :: binary
-  def decode32!(string, opts \\ []) do
-    case = Keyword.get(opts, :case, :upper)
-    do_decode32(string, decode_case(case, &dec32/1))
+  @spec decode32!(binary, case: decode_case, padding: boolean) :: binary
+  def decode32!(string, opts \\ []) when is_binary(string) do
+    pad? = Keyword.get(opts, :padding, true)
+
+    case Keyword.get(opts, :case, :upper) do
+      :upper -> decode32upper!(string, pad?)
+      :lower -> decode32lower!(string, pad?)
+      :mixed -> decode32mixed!(string, pad?)
+    end
   end
 
   @doc """
-  Encodes a binary string into a base 32 encoded string with an
-  extended hexadecimal alphabet.
+  Checks if a base 32 encoded string is valid.
 
-  Accepts an atom `:upper` (default) for encoding to upper case characters or
-  `:lower` for lower case characters.
+  > #### When to use this {: .tip}
+  >
+  > Use this function when you just need to *validate* that a string is
+  > valid base 32 data, without actually producing a decoded output string.
+  > This function is both more performant and memory efficient than using
+  > `decode32/2`, checking that the result is `{:ok, ...}`, and then
+  > discarding the decoded binary.
+
+  ## Options
+
+  Accepts the same options as `decode32/2`.
 
   ## Examples
 
-      iex> Base.hex_encode32("foobar")
-      "CPNMUOJ1E8======"
+      iex> Base.valid32?("MZXW6YTBOI======")
+      true
 
-      iex> Base.hex_encode32("foobar", case: :lower)
-      "cpnmuoj1e8======"
+      iex> Base.valid32?("mzxw6ytboi======", case: :lower)
+      true
+
+      iex> Base.valid32?("zzz")
+      false
 
   """
-  @spec hex_encode32(binary) :: binary
-  @spec hex_encode32(binary, Keyword.t) :: binary
-  def hex_encode32(data, opts \\ []) when is_binary(data) do
-    case = Keyword.get(opts, :case, :upper)
-    do_encode32(data, encode_case(case, &enc32hex/1))
+  @doc since: "1.19.0"
+  @spec valid32?(binary, case: decode_case, padding: boolean) :: boolean()
+  def valid32?(string, opts \\ []) when is_binary(string) do
+    pad? = Keyword.get(opts, :padding, true)
+
+    case Keyword.get(opts, :case, :upper) do
+      :upper -> validate32upper?(string, pad?)
+      :lower -> validate32lower?(string, pad?)
+      :mixed -> validate32mixed?(string, pad?)
+    end
   end
 
   @doc """
   Decodes a base 32 encoded string with extended hexadecimal alphabet
   into a binary string.
 
-  Accepts an atom `:upper` (default) for decoding from upper case characters or
-  `:lower` for lower case characters. `:mixed` can be given for mixed case
-  characters.
+  ## Options
+
+  The accepted options are:
+
+    * `:case` - specifies the character case to accept when decoding
+    * `:padding` - specifies whether to require padding
+
+  The values for `:case` can be:
+
+    * `:upper` - only allows upper case characters (default)
+    * `:lower` - only allows lower case characters
+    * `:mixed` - allows mixed case characters
+
+  The values for `:padding` can be:
+
+    * `true` - requires the input string to be padded to the nearest multiple of 8 (default)
+    * `false` - ignores padding from the input string
 
   ## Examples
 
@@ -441,12 +1307,13 @@ defmodule Base do
       iex> Base.hex_decode32("cpnMuOJ1E8======", case: :mixed)
       {:ok, "foobar"}
 
+      iex> Base.hex_decode32("CPNMUOJ1E8", padding: false)
+      {:ok, "foobar"}
+
   """
-  @spec hex_decode32(binary) :: {:ok, binary} | :error
-  @spec hex_decode32(binary, Keyword.t) :: {:ok, binary} | :error
-  def hex_decode32(string, opts \\ []) when is_binary(string) do
-    case = Keyword.get(opts, :case, :upper)
-    {:ok, do_decode32(string, decode_case(case, &dec32hex/1))}
+  @spec hex_decode32(binary, case: decode_case, padding: boolean) :: {:ok, binary} | :error
+  def hex_decode32(string, opts \\ []) do
+    {:ok, hex_decode32!(string, opts)}
   rescue
     ArgumentError -> :error
   end
@@ -455,13 +1322,27 @@ defmodule Base do
   Decodes a base 32 encoded string with extended hexadecimal alphabet
   into a binary string.
 
-  Accepts an atom `:upper` (default) for decoding from upper case characters or
-  `:lower` for lower case characters. `:mixed` can be given for mixed case
-  characters.
-
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
 
+  ## Options
+
+  The accepted options are:
+
+    * `:case` - specifies the character case to accept when decoding
+    * `:padding` - specifies whether to require padding
+
+  The values for `:case` can be:
+
+    * `:upper` - only allows upper case characters (default)
+    * `:lower` - only allows lower case characters
+    * `:mixed` - allows mixed case characters
+
+  The values for `:padding` can be:
+
+    * `true` - requires the input string to be padded to the nearest multiple of 8 (default)
+    * `false` - ignores padding from the input string
+
   ## Examples
 
       iex> Base.hex_decode32!("CPNMUOJ1E8======")
@@ -473,120 +1354,293 @@ defmodule Base do
       iex> Base.hex_decode32!("cpnMuOJ1E8======", case: :mixed)
       "foobar"
 
+      iex> Base.hex_decode32!("CPNMUOJ1E8", padding: false)
+      "foobar"
+
   """
-  @spec hex_decode32!(binary) :: binary
-  @spec hex_decode32!(binary, Keyword.t) :: binary
+  @spec hex_decode32!(binary, case: decode_case, padding: boolean) :: binary
   def hex_decode32!(string, opts \\ []) when is_binary(string) do
-    case = Keyword.get(opts, :case, :upper)
-    do_decode32(string, decode_case(case, &dec32hex/1))
-  end
-
-  defp do_encode16(<<>>, _), do: <<>>
-  defp do_encode16(data, enc) do
-    for <<c::4 <- data>>, into: <<>>, do: <<enc.(c)::8>>
-  end
-
-  defp do_decode16(<<>>, _), do: <<>>
-  defp do_decode16(string, dec) when rem(byte_size(string), 2) == 0 do
-    for <<c1::8, c2::8 <- string>>, into: <<>>  do
-      <<dec.(c1)::4, dec.(c2)::4>>
-    end
-  end
-  defp do_decode16(_, _) do
-    raise ArgumentError, "odd-length string"
-  end
-
-  defp do_encode64(<<>>, _), do: <<>>
-  defp do_encode64(data, enc) do
-    split =  3 * div(byte_size(data), 3)
-    <<main::[size(split), binary], rest::binary>> = data
-    main = for <<c::6 <- main>>, into: <<>>, do: <<enc.(c)::8>>
-    case rest do
-      <<c1::6, c2::6, c3::4>> ->
-        <<main::binary, enc.(c1)::8, enc.(c2)::8, enc.(bsl(c3, 2))::8, ?=>>
-      <<c1::6, c2::2>> ->
-        <<main::binary, enc.(c1)::8, enc.(bsl(c2, 4))::8, ?=, ?=>>
-      <<>> ->
-        main
-    end
-  end
-
-  defp do_decode64(<<>>, _), do: <<>>
-  defp do_decode64(string, dec) when rem(byte_size(string), 4) == 0 do
-    split = byte_size(string) - 4
-    <<main::[size(split), binary], rest::binary>> = string
-    main = for <<c::8 <- main>>, into: <<>>, do: <<dec.(c)::6>>
-    case rest do
-      <<c1::8, c2::8, ?=, ?=>> ->
-        <<main::binary, dec.(c1)::6, bsr(dec.(c2), 4)::2>>
-      <<c1::8, c2::8, c3::8, ?=>> ->
-        <<main::binary, dec.(c1)::6, dec.(c2)::6, bsr(dec.(c3), 2)::4>>
-      <<c1::8, c2::8, c3::8, c4::8>> ->
-        <<main::binary, dec.(c1)::6, dec.(c2)::6, dec.(c3)::6, dec.(c4)::6>>
-      <<>> ->
-        main
-    end
-  end
-  defp do_decode64(_, _) do
-    raise ArgumentError, "incorrect padding"
-  end
-
-  defp do_encode32(<<>>, _), do: <<>>
-  defp do_encode32(data, enc) do
-    split =  5 * div(byte_size(data), 5)
-    <<main::[size(split), binary], rest::binary>> = data
-    main = for <<c::5 <- main>>, into: <<>>, do: <<enc.(c)::8>>
-    case rest do
-      <<c1::5, c2::5, c3::5, c4::5, c5::5, c6::5, c7::2>> ->
-        <<main::binary,
-          enc.(c1)::8, enc.(c2)::8, enc.(c3)::8, enc.(c4)::8,
-          enc.(c5)::8, enc.(c6)::8, enc.(bsl(c7, 3))::8, ?=>>
-      <<c1::5, c2::5, c3::5, c4::5, c5::4>> ->
-        <<main::binary,
-          enc.(c1)::8, enc.(c2)::8, enc.(c3)::8, enc.(c4)::8,
-          enc.(bsl(c5, 1))::8, ?=,  ?=, ?=>>
-      <<c1::5, c2::5, c3::5, c4::1>> ->
-        <<main::binary,
-          enc.(c1)::8, enc.(c2)::8,  enc.(c3)::8, enc.(bsl(c4, 4))::8,
-          ?=, ?=,  ?=, ?=>>
-      <<c1::5, c2::3>> ->
-        <<main::binary,
-          enc.(c1)::8, enc.(bsl(c2, 2))::8, ?=, ?=,
-          ?=, ?=, ?=, ?=>>
-      <<>> ->
-        main
-    end
-  end
-
-  defp do_decode32(<<>>, _), do: <<>>
-  defp do_decode32(string, dec) when rem(byte_size(string), 8) == 0 do
-    split = byte_size(string) - 8
-    <<main::[size(split), binary], rest::binary>> = string
-    main = for <<c::8 <- main>>, into: <<>>, do: <<dec.(c)::5>>
-    case rest do
-      <<c1::8, c2::8, ?=, ?=, ?=, ?=, ?=, ?=>> ->
-        <<main::binary, dec.(c1)::5, bsr(dec.(c2), 2)::3>>
-      <<c1::8, c2::8, c3::8, c4::8, ?=, ?=, ?=, ?=>> ->
-        <<main::binary,
-          dec.(c1)::5, dec.(c2)::5, dec.(c3)::5, bsr(dec.(c4), 4)::1>>
-      <<c1::8, c2::8, c3::8, c4::8, c5::8, ?=, ?=, ?=>> ->
-        <<main::binary,
-          dec.(c1)::5, dec.(c2)::5, dec.(c3)::5, dec.(c4)::5,
-          bsr(dec.(c5), 1)::4>>
-      <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, ?=>> ->
-        <<main::binary,
-          dec.(c1)::5, dec.(c2)::5, dec.(c3)::5, dec.(c4)::5,
-          dec.(c5)::5, dec.(c6)::5,  bsr(dec.(c7), 3)::2>>
-      <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8>> ->
-        <<main::binary,
-          dec.(c1)::5, dec.(c2)::5, dec.(c3)::5, dec.(c4)::5,
-          dec.(c5)::5, dec.(c6)::5, dec.(c7)::5, dec.(c8)::5>>
-      <<>> ->
-        main
-    end
-  end
-  defp do_decode32(_, _) do
-    raise ArgumentError, "incorrect padding"
+    pad? = Keyword.get(opts, :padding, true)
+
+    case Keyword.get(opts, :case, :upper) do
+      :upper -> decode32hexupper!(string, pad?)
+      :lower -> decode32hexlower!(string, pad?)
+      :mixed -> decode32hexmixed!(string, pad?)
+    end
+  end
+
+  @doc """
+  Checks if a base 32 encoded string with extended hexadecimal alphabet is valid.
+
+  > #### When to use this {: .tip}
+  >
+  > Use this function when you just need to *validate* that a string is
+  > valid (extended hexadecimal) base 32 data, without actually producing
+  > a decoded output string. This function is both more performant and
+  > memory efficient than using `hex_decode32/2`, checking that the result
+  > is `{:ok, ...}`, and then discarding the decoded binary.
+
+  ## Options
+
+  Accepts the same options as `hex_decode32/2`.
+
+  ## Examples
+
+      iex> Base.hex_valid32?("CPNMUOJ1E8======")
+      true
+
+      iex> Base.hex_valid32?("cpnmuoj1e8======", case: :lower)
+      true
+
+      iex> Base.hex_valid32?("zzz", padding: false)
+      false
+
+  """
+  @doc since: "1.19.0"
+  @spec hex_valid32?(binary, case: decode_case, padding: boolean) :: boolean
+  def hex_valid32?(string, opts \\ []) when is_binary(string) do
+    pad? = Keyword.get(opts, :padding, true)
+
+    case Keyword.get(opts, :case, :upper) do
+      :upper -> validate32hexupper?(string, pad?)
+      :lower -> validate32hexlower?(string, pad?)
+      :mixed -> validate32hexmixed?(string, pad?)
+    end
   end
 
+  upper = Enum.with_index(b32_alphabet)
+  hexupper = Enum.with_index(b32hex_alphabet)
+
+  for {base, alphabet} <- [
+        upper: upper,
+        lower: to_lower_dec.(upper),
+        mixed: to_mixed_dec.(upper),
+        hexupper: hexupper,
+        hexlower: to_lower_dec.(hexupper),
+        hexmixed: to_mixed_dec.(hexupper)
+      ] do
+    decode_name = :"decode32#{base}!"
+    validate_name = :"validate32#{base}?"
+    validate_main_name = :"validate_main32#{validate_name}?"
+    valid_char_name = :"valid_char32#{base}?"
+    {min, decoded} = to_decode_list.(alphabet)
+
+    defp unquote(validate_main_name)(<<>>), do: true
+
+    defp unquote(validate_main_name)(
+           <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8, rest::binary>>
+         ) do
+      unquote(valid_char_name)(c1) and
+        unquote(valid_char_name)(c2) and
+        unquote(valid_char_name)(c3) and
+        unquote(valid_char_name)(c4) and
+        unquote(valid_char_name)(c5) and
+        unquote(valid_char_name)(c6) and
+        unquote(valid_char_name)(c7) and
+        unquote(valid_char_name)(c8) and
+        unquote(validate_main_name)(rest)
+    end
+
+    defp unquote(validate_name)(<<>>, _pad?), do: true
+
+    defp unquote(validate_name)(string, pad?) do
+      segs = div(byte_size(string) + 7, 8) - 1
+      <<main::size(^segs)-binary-unit(64), rest::binary>> = string
+      main_valid? = unquote(validate_main_name)(main)
+
+      case rest do
+        _ when not main_valid? ->
+          false
+
+        <<c1::8, c2::8, ?=, ?=, ?=, ?=, ?=, ?=>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2)
+
+        <<c1::8, c2::8, c3::8, c4::8, ?=, ?=, ?=, ?=>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4)
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, ?=, ?=, ?=>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4) and
+            unquote(valid_char_name)(c5)
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, ?=>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4) and
+            unquote(valid_char_name)(c5) and
+            unquote(valid_char_name)(c6) and
+            unquote(valid_char_name)(c7)
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8>> ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4) and
+            unquote(valid_char_name)(c5) and
+            unquote(valid_char_name)(c6) and
+            unquote(valid_char_name)(c7) and
+            unquote(valid_char_name)(c8)
+
+        <<c1::8, c2::8>> when not pad? ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2)
+
+        <<c1::8, c2::8, c3::8, c4::8>> when not pad? ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4)
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8>> when not pad? ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4) and
+            unquote(valid_char_name)(c5)
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8>> when not pad? ->
+          unquote(valid_char_name)(c1) and
+            unquote(valid_char_name)(c2) and
+            unquote(valid_char_name)(c3) and
+            unquote(valid_char_name)(c4) and
+            unquote(valid_char_name)(c5) and
+            unquote(valid_char_name)(c6) and
+            unquote(valid_char_name)(c7)
+
+        _ ->
+          false
+      end
+    end
+
+    @compile {:inline, [{valid_char_name, 1}]}
+    defp unquote(valid_char_name)(char)
+         when elem({unquote_splicing(decoded)}, char - unquote(min)) != nil,
+         do: true
+
+    defp unquote(valid_char_name)(_char), do: false
+
+    defp unquote(decode_name)(char) do
+      index = char - unquote(min)
+
+      cond do
+        index not in 0..unquote(length(decoded) - 1) -> bad_character!(char)
+        new_char = elem({unquote_splicing(decoded)}, index) -> new_char
+        true -> bad_character!(char)
+      end
+    end
+
+    defp unquote(decode_name)(<<>>, _), do: <<>>
+
+    defp unquote(decode_name)(string, pad?) do
+      segs = div(byte_size(string) + 7, 8) - 1
+      <<main::size(^segs)-binary-unit(64), rest::binary>> = string
+
+      main =
+        for <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8 <- main>>, into: <<>> do
+          <<
+            unquote(decode_name)(c1)::5,
+            unquote(decode_name)(c2)::5,
+            unquote(decode_name)(c3)::5,
+            unquote(decode_name)(c4)::5,
+            unquote(decode_name)(c5)::5,
+            unquote(decode_name)(c6)::5,
+            unquote(decode_name)(c7)::5,
+            unquote(decode_name)(c8)::5
+          >>
+        end
+
+      case rest do
+        <<c1::8, c2::8, ?=, ?=, ?=, ?=, ?=, ?=>> ->
+          <<main::bits, unquote(decode_name)(c1)::5, bsr(unquote(decode_name)(c2), 2)::3>>
+
+        <<c1::8, c2::8, c3::8, c4::8, ?=, ?=, ?=, ?=>> ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::5,
+            unquote(decode_name)(c2)::5,
+            unquote(decode_name)(c3)::5,
+            bsr(unquote(decode_name)(c4), 4)::1
+          >>
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, ?=, ?=, ?=>> ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::5,
+            unquote(decode_name)(c2)::5,
+            unquote(decode_name)(c3)::5,
+            unquote(decode_name)(c4)::5,
+            bsr(unquote(decode_name)(c5), 1)::4
+          >>
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, ?=>> ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::5,
+            unquote(decode_name)(c2)::5,
+            unquote(decode_name)(c3)::5,
+            unquote(decode_name)(c4)::5,
+            unquote(decode_name)(c5)::5,
+            unquote(decode_name)(c6)::5,
+            bsr(unquote(decode_name)(c7), 3)::2
+          >>
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8>> ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::5,
+            unquote(decode_name)(c2)::5,
+            unquote(decode_name)(c3)::5,
+            unquote(decode_name)(c4)::5,
+            unquote(decode_name)(c5)::5,
+            unquote(decode_name)(c6)::5,
+            unquote(decode_name)(c7)::5,
+            unquote(decode_name)(c8)::5
+          >>
+
+        <<c1::8, c2::8>> when not pad? ->
+          <<main::bits, unquote(decode_name)(c1)::5, bsr(unquote(decode_name)(c2), 2)::3>>
+
+        <<c1::8, c2::8, c3::8, c4::8>> when not pad? ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::5,
+            unquote(decode_name)(c2)::5,
+            unquote(decode_name)(c3)::5,
+            bsr(unquote(decode_name)(c4), 4)::1
+          >>
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8>> when not pad? ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::5,
+            unquote(decode_name)(c2)::5,
+            unquote(decode_name)(c3)::5,
+            unquote(decode_name)(c4)::5,
+            bsr(unquote(decode_name)(c5), 1)::4
+          >>
+
+        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8>> when not pad? ->
+          <<
+            main::bits,
+            unquote(decode_name)(c1)::5,
+            unquote(decode_name)(c2)::5,
+            unquote(decode_name)(c3)::5,
+            unquote(decode_name)(c4)::5,
+            unquote(decode_name)(c5)::5,
+            unquote(decode_name)(c6)::5,
+            bsr(unquote(decode_name)(c7), 3)::2
+          >>
+
+        _ ->
+          raise ArgumentError, "incorrect padding"
+      end
+    end
+  end
 end
diff --git a/lib/elixir/lib/behaviour.ex b/lib/elixir/lib/behaviour.ex
index 8f882a00294..4a43fccc068 100644
--- a/lib/elixir/lib/behaviour.ex
+++ b/lib/elixir/lib/behaviour.ex
@@ -1,63 +1,41 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Behaviour do
   @moduledoc """
-  Utilities for defining behaviour interfaces.
-
-  Behaviours can be referenced by other modules
-  to ensure they implement required callbacks.
-
-  For example, you can specify the `URI.Parser`
-  behaviour as follows:
-
-      defmodule URI.Parser do
-        use Behaviour
-
-        @doc "Parses the given URL"
-        defcallback parse(uri_info :: URI.t) :: URI.t
-
-        @doc "Defines a default port"
-        defcallback default_port() :: integer
-      end
-
-  And then a module may use it as:
-
-      defmodule URI.HTTP do
-        @behaviour URI.Parser
-        def default_port(), do: 80
-        def parse(info), do: info
-      end
-
-  If the behaviour changes or `URI.HTTP` does
-  not implement one of the callbacks, a warning
-  will be raised.
-
-  ## Implementation
+  Mechanism for handling behaviours.
 
-  Since Erlang R15, behaviours must be defined via
-  `@callback` attributes. `defcallback` is a simple
-  mechanism that defines the `@callback` attribute
-  according to the given type specification. `defcallback` allows
-  documentation to be created for the callback and defines
-  a custom function signature.
+  This module is deprecated. Instead of `defcallback/1` and
+  `defmacrocallback/1`, the `@callback` and `@macrocallback`
+  module attributes can be used respectively. See the
+  documentation for `Module` for more information on these
+  attributes.
 
-  The callbacks and their documentation can be retrieved
-  via the `__behaviour__` callback function.
+  Instead of `MyModule.__behaviour__(:callbacks)`,
+  `MyModule.behaviour_info(:callbacks)` can be used. `behaviour_info/1`
+  is documented in `Module`.
   """
 
+  @moduledoc deprecated: "Use @callback and @macrocallback attributes instead"
+
   @doc """
-  Define a function callback according to the given type specification.
+  Defines a function callback according to the given type specification.
   """
+  @deprecated "Use the @callback module attribute instead"
   defmacro defcallback(spec) do
-    do_defcallback(split_spec(spec, quote(do: term)), __CALLER__)
+    do_defcallback(:def, split_spec(spec, quote(do: term)))
   end
 
   @doc """
-  Define a macro callback according to the given type specification.
+  Defines a macro callback according to the given type specification.
   """
+  @deprecated "Use the @macrocallback module attribute instead"
   defmacro defmacrocallback(spec) do
-    do_defmacrocallback(split_spec(spec, quote(do: Macro.t)), __CALLER__)
+    do_defcallback(:defmacro, split_spec(spec, quote(do: Macro.t())))
   end
 
-  defp split_spec({:when, _, [{:::, _, [spec, return]}, guard]}, _default) do
+  defp split_spec({:when, _, [{:"::", _, [spec, return]}, guard]}, _default) do
     {spec, return, guard}
   end
 
@@ -65,7 +43,7 @@ defmodule Behaviour do
     {spec, default, guard}
   end
 
-  defp split_spec({:::, _, [spec, return]}, _default) do
+  defp split_spec({:"::", _, [spec, return]}, _default) do
     {spec, return, []}
   end
 
@@ -73,40 +51,38 @@ defmodule Behaviour do
     {spec, default, []}
   end
 
-  defp do_defcallback({spec, return, guards}, caller) do
+  defp do_defcallback(kind, {spec, return, guards}) do
     case Macro.decompose_call(spec) do
       {name, args} ->
-        do_callback(:def, name, args, name, length(args), args, return, guards, caller)
-      _ ->
-        raise ArgumentError, "invalid syntax in defcallback #{Macro.to_string(spec)}"
-    end
-  end
+        do_callback(kind, name, args, return, guards)
 
-  defp do_defmacrocallback({spec, return, guards}, caller) do
-    case Macro.decompose_call(spec) do
-      {name, args} ->
-        do_callback(:defmacro, :"MACRO-#{name}", [quote(do: env :: Macro.Env.t)|args],
-                    name, length(args), args, return, guards, caller)
       _ ->
-        raise ArgumentError, "invalid syntax in defmacrocallback #{Macro.to_string(spec)}"
+        raise ArgumentError, "invalid syntax in #{kind}callback #{Macro.to_string(spec)}"
     end
   end
 
-  defp do_callback(kind, name, args, docs_name, docs_arity, _docs_args, return, guards, caller) do
-    Enum.each args, fn
-      {:::, _, [left, right]} ->
+  defp do_callback(kind, name, args, return, guards) do
+    fun = fn
+      {:"::", _, [left, right]} ->
         ensure_not_default(left)
         ensure_not_default(right)
         left
+
       other ->
         ensure_not_default(other)
         other
     end
 
-    quote do
-      @callback unquote(name)(unquote_splicing(args)) :: unquote(return) when unquote(guards)
-      Behaviour.store_docs(__MODULE__, unquote(caller.line), unquote(kind),
-                           unquote(docs_name), unquote(docs_arity))
+    :lists.foreach(fun, args)
+
+    spec =
+      quote do
+        unquote(name)(unquote_splicing(args)) :: unquote(return) when unquote(guards)
+      end
+
+    case kind do
+      :def -> quote(do: @callback(unquote(spec)))
+      :defmacro -> quote(do: @macrocallback(unquote(spec)))
     end
   end
 
@@ -116,37 +92,37 @@ defmodule Behaviour do
 
   defp ensure_not_default(_), do: :ok
 
-  @doc false
-  def store_docs(module, line, kind, name, arity) do
-    doc = Module.get_attribute module, :doc
-    Module.delete_attribute module, :doc
-    Module.put_attribute module, :behaviour_docs, {{name, arity}, line, kind, doc}
-  end
-
   @doc false
   defmacro __using__(_) do
     quote do
-      Module.register_attribute(__MODULE__, :behaviour_docs, accumulate: true)
-      @before_compile unquote(__MODULE__)
-      import unquote(__MODULE__)
-    end
-  end
+      warning =
+        "the Behaviour module is deprecated. Instead of using this module, " <>
+          "use the @callback and @macrocallback module attributes. See the " <>
+          "documentation for Module for more information on these attributes"
 
-  @doc false
-  defmacro __before_compile__(env) do
-    docs = if Code.compiler_options[:docs] do
-      Enum.reverse Module.get_attribute(env.module, :behaviour_docs)
-    end
+      IO.warn(warning)
 
-    quote do
       @doc false
       def __behaviour__(:callbacks) do
         __MODULE__.behaviour_info(:callbacks)
       end
 
       def __behaviour__(:docs) do
-        unquote(Macro.escape(docs))
+        {:docs_v1, _, :elixir, _, _, _, docs} = Code.fetch_docs(__MODULE__)
+
+        for {{kind, name, arity}, line, _, doc, _} <- docs, kind in [:callback, :macrocallback] do
+          case kind do
+            :callback -> {{name, arity}, line, :def, __behaviour__doc_value(doc)}
+            :macrocallback -> {{name, arity}, line, :defmacro, __behaviour__doc_value(doc)}
+          end
+        end
       end
+
+      defp __behaviour__doc_value(%{"en" => doc}), do: doc
+      defp __behaviour__doc_value(:hidden), do: false
+      defp __behaviour__doc_value(_), do: nil
+
+      import unquote(__MODULE__)
     end
   end
 end
diff --git a/lib/elixir/lib/bitwise.ex b/lib/elixir/lib/bitwise.ex
index 9d74a608983..e00ecb76278 100644
--- a/lib/elixir/lib/bitwise.ex
+++ b/lib/elixir/lib/bitwise.ex
@@ -1,41 +1,44 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Bitwise do
   @moduledoc """
-  This module provides macros and operators for bitwise operators.
-  These macros can be used in guards.
+  A set of functions that perform calculations on bits.
 
-  The easiest way to use is to simply import them into
-  your module:
+  All bitwise functions work only on integers, otherwise an
+  `ArithmeticError` is raised. The functions `band/2`,
+  `bor/2`, `bsl/2`, and `bsr/2` also have operators,
+  respectively: `&&&/2`, `|||/2`, `<<</2`, and `>>>/2`.
 
-      iex> use Bitwise
-      iex> bnot 1
-      -2
-      iex> 1 &&& 1
-      1
+  ## Guards
 
-  You can select to include only or skip operators by passing options:
+  All bitwise functions can be used in guards:
 
-      iex> use Bitwise, only_operators: true
-      iex> 1 &&& 1
-      1
+      iex> odd? = fn
+      ...>   int when Bitwise.band(int, 1) == 1 -> true
+      ...>   _ -> false
+      ...> end
+      iex> odd?.(1)
+      true
 
+  All functions in this module are inlined by the compiler.
   """
 
-  @doc """
-  Allow a developer to use this module in their programs with
-  the following options:
+  @doc false
+  @deprecated "import Bitwise instead"
+  defmacro __using__(options) do
+    except =
+      cond do
+        Keyword.get(options, :only_operators) ->
+          [bnot: 1, band: 2, bor: 2, bxor: 2, bsl: 2, bsr: 2]
 
-    * `:only_operators` - include only operators
-    * `:skip_operators` - skip operators
+        Keyword.get(options, :skip_operators) ->
+          ["~~~": 1, &&&: 2, |||: 2, "^^^": 2, <<<: 2, >>>: 2]
 
-  """
-  defmacro __using__(options) do
-    except = cond do
-      Keyword.get(options, :only_operators) ->
-        [bnot: 1, band: 2, bor: 2, bxor: 2, bsl: 2, bsr: 2]
-      Keyword.get(options, :skip_operators) ->
-        [~~~: 1, &&&: 2, |||: 2, ^^^: 2, <<<: 2, >>>: 2]
-      true -> []
-    end
+        true ->
+          []
+      end
 
     quote do
       import Bitwise, except: unquote(except)
@@ -43,86 +46,229 @@ defmodule Bitwise do
   end
 
   @doc """
-  Bitwise not.
+  Calculates the bitwise NOT of the argument.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> bnot(2)
+      -3
+
+      iex> bnot(2) &&& 3
+      1
+
   """
-  defmacro bnot(expr) do
-    quote do: :erlang.bnot(unquote(expr))
+  @doc guard: true
+  @spec bnot(integer) :: integer
+  def bnot(expr) do
+    :erlang.bnot(expr)
   end
 
-  @doc """
-  Bitwise not as operator.
-  """
-  defmacro ~~~expr do
-    quote do: :erlang.bnot(unquote(expr))
+  @doc false
+  def unquote(:"~~~")(expr) do
+    :erlang.bnot(expr)
   end
 
   @doc """
-  Bitwise and.
+  Calculates the bitwise AND of its arguments.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> band(9, 3)
+      1
+
   """
-  defmacro band(left, right) do
-    quote do: :erlang.band(unquote(left), unquote(right))
+  @doc guard: true
+  @spec band(integer, integer) :: integer
+  def band(left, right) do
+    :erlang.band(left, right)
   end
 
   @doc """
-  Bitwise and as operator.
+  Bitwise AND operator.
+
+  Calculates the bitwise AND of its arguments.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> 9 &&& 3
+      1
+
   """
-  defmacro left &&& right do
-    quote do: :erlang.band(unquote(left), unquote(right))
+  @doc guard: true
+  @spec integer &&& integer :: integer
+  def left &&& right do
+    :erlang.band(left, right)
   end
 
   @doc """
-  Bitwise or.
+  Calculates the bitwise OR of its arguments.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> bor(9, 3)
+      11
+
   """
-  defmacro bor(left, right) do
-    quote do: :erlang.bor(unquote(left), unquote(right))
+  @doc guard: true
+  @spec bor(integer, integer) :: integer
+  def bor(left, right) do
+    :erlang.bor(left, right)
   end
 
   @doc """
-  Bitwise or as operator.
+  Bitwise OR operator.
+
+  Calculates the bitwise OR of its arguments.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> 9 ||| 3
+      11
+
   """
-  defmacro left ||| right do
-    quote do: :erlang.bor(unquote(left), unquote(right))
+  @doc guard: true
+  @spec integer ||| integer :: integer
+  def left ||| right do
+    :erlang.bor(left, right)
   end
 
   @doc """
-  Bitwise xor.
+  Calculates the bitwise XOR of its arguments.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> bxor(9, 3)
+      10
+
   """
-  defmacro bxor(left, right) do
-    quote do: :erlang.bxor(unquote(left), unquote(right))
+  @doc guard: true
+  @spec bxor(integer, integer) :: integer
+  def bxor(left, right) do
+    :erlang.bxor(left, right)
   end
 
-  @doc """
-  Bitwise xor as operator.
-  """
-  defmacro left ^^^ right do
-    quote do: :erlang.bxor(unquote(left), unquote(right))
+  @doc false
+  def unquote(:"^^^")(left, right) do
+    :erlang.bxor(left, right)
   end
 
   @doc """
-  Arithmetic bitshift left.
+  Calculates the result of an arithmetic left bitshift.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> bsl(1, 2)
+      4
+
+      iex> bsl(1, -2)
+      0
+
+      iex> bsl(-1, 2)
+      -4
+
+      iex> bsl(-1, -2)
+      -1
+
   """
-  defmacro bsl(left, right) do
-    quote do: :erlang.bsl(unquote(left), unquote(right))
+  @doc guard: true
+  @spec bsl(integer, integer) :: integer
+  def bsl(left, right) do
+    :erlang.bsl(left, right)
   end
 
   @doc """
-  Arithmetic bitshift left as operator.
+  Arithmetic left bitshift operator.
+
+  Calculates the result of an arithmetic left bitshift.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> 1 <<< 2
+      4
+
+      iex> 1 <<< -2
+      0
+
+      iex> -1 <<< 2
+      -4
+
+      iex> -1 <<< -2
+      -1
+
   """
-  defmacro left <<< right do
-    quote do: :erlang.bsl(unquote(left), unquote(right))
+  @doc guard: true
+  @spec integer <<< integer :: integer
+  def left <<< right do
+    :erlang.bsl(left, right)
   end
 
   @doc """
-  Arithmetic bitshift right.
+  Calculates the result of an arithmetic right bitshift.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> bsr(1, 2)
+      0
+
+      iex> bsr(1, -2)
+      4
+
+      iex> bsr(-1, 2)
+      -1
+
+      iex> bsr(-1, -2)
+      -4
+
   """
-  defmacro bsr(left, right) do
-    quote do: :erlang.bsr(unquote(left), unquote(right))
+  @doc guard: true
+  @spec bsr(integer, integer) :: integer
+  def bsr(left, right) do
+    :erlang.bsr(left, right)
   end
 
   @doc """
-  Arithmetic bitshift right as operator.
+  Arithmetic right bitshift operator.
+
+  Calculates the result of an arithmetic right bitshift.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> 1 >>> 2
+      0
+
+      iex> 1 >>> -2
+      4
+
+      iex> -1 >>> 2
+      -1
+
+      iex> -1 >>> -2
+      -4
+
   """
-  defmacro left >>> right do
-    quote do: :erlang.bsr(unquote(left), unquote(right))
+  @doc guard: true
+  @spec integer >>> integer :: integer
+  def left >>> right do
+    :erlang.bsr(left, right)
   end
 end
diff --git a/lib/elixir/lib/calendar.ex b/lib/elixir/lib/calendar.ex
new file mode 100644
index 00000000000..89160389b8d
--- /dev/null
+++ b/lib/elixir/lib/calendar.ex
@@ -0,0 +1,1054 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Calendar do
+  @moduledoc """
+  This module defines the responsibilities for working with
+  calendars, dates, times and datetimes in Elixir.
+
+  It defines types and the minimal implementation
+  for a calendar behaviour in Elixir. The goal of the calendar
+  features in Elixir is to provide a base for interoperability
+  rather than a full-featured datetime API.
+
+  For the actual date, time and datetime structs, see `Date`,
+  `Time`, `NaiveDateTime`, and `DateTime`.
+
+  Types for year, month, day, and more are *overspecified*.
+  For example, the `t:month/0` type is specified as an integer
+  instead of `1..12`. This is because different calendars may
+  have a different number of days per month.
+  """
+
+  @type year :: integer
+  @type month :: pos_integer
+  @type day :: pos_integer
+  @type week :: pos_integer
+  @type day_of_week :: non_neg_integer
+  @type era :: non_neg_integer
+
+  @typedoc """
+  A tuple representing the `day` and the `era`.
+  """
+  @type day_of_era :: {day :: non_neg_integer(), era}
+
+  @type hour :: non_neg_integer
+  @type minute :: non_neg_integer
+  @type second :: non_neg_integer
+
+  @typedoc """
+  The internal time format is used when converting between calendars.
+
+  It represents time as a fraction of a day (starting from midnight).
+  `parts_in_day` specifies how much of the day is already passed,
+  while `parts_per_day` signifies how many parts are there in a day.
+  """
+  @type day_fraction :: {parts_in_day :: non_neg_integer, parts_per_day :: pos_integer}
+
+  @typedoc """
+  The internal date format that is used when converting between calendars.
+
+  This is the number of days including the fractional part that has passed of
+  the last day since `0000-01-01+00:00T00:00.000000` in ISO 8601 notation (also
+  known as *midnight 1 January BC 1* of the proleptic Gregorian calendar).
+  """
+  @type iso_days :: {days :: integer, day_fraction}
+
+  @typedoc """
+  Microseconds with stored precision.
+
+  `value` always represents the total value in microseconds.
+
+  The `precision` represents the number of digits that must be used when
+  representing the microseconds to external format. If the precision is `0`,
+  it means microseconds must be skipped. If the precision is `6`, it means
+  that `value` represents exactly the number of microseconds to be used.
+
+  ## Examples
+
+    * `{0, 0}` means no microseconds.
+    * `{1, 6}` means 1µs.
+    * `{1000, 6}` means 1000µs (which is 1ms but measured at the microsecond precision).
+    * `{1000, 3}` means 1ms (which is measured at the millisecond precision).
+
+  """
+  @type microsecond :: {value :: non_neg_integer, precision :: non_neg_integer}
+
+  @typedoc "A calendar implementation."
+  @type calendar :: module
+
+  @typedoc "The time zone ID according to the IANA tz database (for example, `Europe/Zurich`)."
+  @type time_zone :: String.t()
+
+  @typedoc "The time zone abbreviation (for example, `CET` or `CEST` or `BST`)."
+  @type zone_abbr :: String.t()
+
+  @typedoc """
+  The time zone UTC offset in ISO seconds for standard time.
+
+  See also `t:std_offset/0`.
+  """
+  @type utc_offset :: integer
+
+  @typedoc """
+  The time zone standard offset in ISO seconds (typically not zero in summer times).
+
+  It must be added to `t:utc_offset/0` to get the total offset from UTC used for "wall time".
+  """
+  @type std_offset :: integer
+
+  @typedoc "Any map or struct that contains the date fields."
+  @type date :: %{optional(any) => any, calendar: calendar, year: year, month: month, day: day}
+
+  @typedoc "Any map or struct that contains the time fields."
+  @type time :: %{
+          optional(any) => any,
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: microsecond
+        }
+
+  @typedoc "Any map or struct that contains the naive datetime fields."
+  @type naive_datetime :: %{
+          optional(any) => any,
+          calendar: calendar,
+          year: year,
+          month: month,
+          day: day,
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: microsecond
+        }
+
+  @typedoc "Any map or struct that contains the datetime fields."
+  @type datetime :: %{
+          optional(any) => any,
+          calendar: calendar,
+          year: year,
+          month: month,
+          day: day,
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: microsecond,
+          time_zone: time_zone,
+          zone_abbr: zone_abbr,
+          utc_offset: utc_offset,
+          std_offset: std_offset
+        }
+
+  @typedoc """
+  Specifies the time zone database for calendar operations.
+
+  Many functions in the `DateTime` module require a time zone database.
+  By default, this module uses the default time zone database returned by
+  `Calendar.get_time_zone_database/0`, which defaults to
+  `Calendar.UTCOnlyTimeZoneDatabase`. This database only handles `Etc/UTC`
+  datetimes and returns `{:error, :utc_only_time_zone_database}`
+  for any other time zone.
+
+  Other time zone databases (including ones provided by packages)
+  can be configured as default either via configuration:
+
+      config :elixir, :time_zone_database, CustomTimeZoneDatabase
+
+  or by calling `Calendar.put_time_zone_database/1`.
+
+  See `Calendar.TimeZoneDatabase` for more information on custom
+  time zone databases.
+  """
+  @type time_zone_database :: module()
+
+  @typedoc """
+  Options for formatting dates and times with `strftime/3`.
+  """
+  @type strftime_opts :: [
+          preferred_datetime: String.t(),
+          preferred_date: String.t(),
+          preferred_time: String.t(),
+          am_pm_names: (:am | :pm -> String.t()) | (:am | :pm, map() -> String.t()),
+          month_names: (pos_integer() -> String.t()) | (pos_integer(), map() -> String.t()),
+          abbreviated_month_names:
+            (pos_integer() -> String.t()) | (pos_integer(), map() -> String.t()),
+          day_of_week_names: (pos_integer() -> String.t()) | (pos_integer(), map() -> String.t()),
+          abbreviated_day_of_week_names:
+            (pos_integer() -> String.t()) | (pos_integer(), map() -> String.t())
+        ]
+
+  @doc """
+  Returns how many days there are in the given month of the given year.
+  """
+  @callback days_in_month(year, month) :: day
+
+  @doc """
+  Returns how many months there are in the given year.
+  """
+  @callback months_in_year(year) :: month
+
+  @doc """
+  Returns `true` if the given year is a leap year.
+
+  A leap year is a year of a longer length than normal. The exact meaning
+  is up to the calendar. A calendar must return `false` if it does not support
+  the concept of leap years.
+  """
+  @callback leap_year?(year) :: boolean
+
+  @doc """
+  Calculates the day of the week from the given `year`, `month`, and `day`.
+
+  `starting_on` represents the starting day of the week. All
+  calendars must support at least the `:default` value. They may
+  also support other values representing their days of the week.
+
+  The value of `day_of_week` is an ordinal number meaning that a
+  value of `1` is defined to mean "first day of the week". It is
+  specifically not defined to mean `1` is `Monday`.
+
+  It is a requirement that `first_day_of_week` is less than `last_day_of_week`
+  and that `day_of_week` must be within that range. Therefore it can be said
+  that `day_of_week in first_day_of_week..last_day_of_week//1` must be
+  `true` for all values of `day_of_week`.
+  """
+  @callback day_of_week(year, month, day, starting_on :: :default | atom) ::
+              {day_of_week(), first_day_of_week :: non_neg_integer(),
+               last_day_of_week :: non_neg_integer()}
+
+  @doc """
+  Calculates the day of the year from the given `year`, `month`, and `day`.
+  """
+  @callback day_of_year(year, month, day) :: non_neg_integer()
+
+  @doc """
+  Calculates the quarter of the year from the given `year`, `month`, and `day`.
+  """
+  @callback quarter_of_year(year, month, day) :: non_neg_integer()
+
+  @doc """
+  Calculates the year and era from the given `year`.
+  """
+  @callback year_of_era(year, month, day) :: {year, era}
+
+  @doc """
+  Calculates the day and era from the given `year`, `month`, and `day`.
+  """
+  @callback day_of_era(year, month, day) :: day_of_era()
+
+  @doc """
+  Converts the date into a string according to the calendar.
+  """
+  @callback date_to_string(year, month, day) :: String.t()
+
+  @doc """
+  Converts the naive datetime (without time zone) into a string according to the calendar.
+  """
+  @callback naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) ::
+              String.t()
+
+  @doc """
+  Converts the datetime (with time zone) into a string according to the calendar.
+  """
+  @callback datetime_to_string(
+              year,
+              month,
+              day,
+              hour,
+              minute,
+              second,
+              microsecond,
+              time_zone,
+              zone_abbr,
+              utc_offset,
+              std_offset
+            ) :: String.t()
+
+  @doc """
+  Converts the time into a string according to the calendar.
+  """
+  @callback time_to_string(hour, minute, second, microsecond) :: String.t()
+
+  @doc """
+  Converts the datetime (without time zone) into the `t:iso_days/0` format.
+  """
+  @callback naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) ::
+              iso_days
+
+  @doc """
+  Converts `t:iso_days/0` to the calendar's datetime format.
+  """
+  @callback naive_datetime_from_iso_days(iso_days) ::
+              {year, month, day, hour, minute, second, microsecond}
+
+  @doc """
+  Converts the given time to the `t:day_fraction/0` format.
+  """
+  @callback time_to_day_fraction(hour, minute, second, microsecond) :: day_fraction
+
+  @doc """
+  Converts `t:day_fraction/0` to the calendar's time format.
+  """
+  @callback time_from_day_fraction(day_fraction) :: {hour, minute, second, microsecond}
+
+  @doc """
+  Define the rollover moment for the calendar.
+
+  This is the moment, in your calendar, when the current day ends
+  and the next day starts.
+
+  The result of this function is used to check if two calendars roll over at
+  the same time of day. If they do not, we can only convert datetimes and times
+  between them. If they do, this means that we can also convert dates as well
+  as naive datetimes between them.
+
+  This day fraction should be in its most simplified form possible, to make comparisons fast.
+
+  ## Examples
+
+    * If in your calendar a new day starts at midnight, return `{0, 1}`.
+    * If in your calendar a new day starts at sunrise, return `{1, 4}`.
+    * If in your calendar a new day starts at noon, return `{1, 2}`.
+    * If in your calendar a new day starts at sunset, return `{3, 4}`.
+
+  """
+  @callback day_rollover_relative_to_midnight_utc() :: day_fraction
+
+  @doc """
+  Should return `true` if the given date describes a proper date in the calendar.
+  """
+  @callback valid_date?(year, month, day) :: boolean
+
+  @doc """
+  Should return `true` if the given time describes a proper time in the calendar.
+  """
+  @callback valid_time?(hour, minute, second, microsecond) :: boolean
+
+  @doc """
+  Parses the string representation for a time returned by `c:time_to_string/4`
+  into a time tuple.
+  """
+  @doc since: "1.10.0"
+  @callback parse_time(String.t()) ::
+              {:ok, {hour, minute, second, microsecond}}
+              | {:error, atom}
+
+  @doc """
+  Parses the string representation for a date returned by `c:date_to_string/3`
+  into a date tuple.
+  """
+  @doc since: "1.10.0"
+  @callback parse_date(String.t()) ::
+              {:ok, {year, month, day}}
+              | {:error, atom}
+
+  @doc """
+  Parses the string representation for a naive datetime returned by
+  `c:naive_datetime_to_string/7` into a naive datetime tuple.
+
+  The given string may contain a timezone offset but it is ignored.
+  """
+  @doc since: "1.10.0"
+  @callback parse_naive_datetime(String.t()) ::
+              {:ok, {year, month, day, hour, minute, second, microsecond}}
+              | {:error, atom}
+
+  @doc """
+  Parses the string representation for a datetime returned by
+  `c:datetime_to_string/11` into a datetime tuple.
+
+  The returned datetime must be in UTC. The original `utc_offset`
+  it was written in must be returned in the result.
+  """
+  @doc since: "1.10.0"
+  @callback parse_utc_datetime(String.t()) ::
+              {:ok, {year, month, day, hour, minute, second, microsecond}, utc_offset}
+              | {:error, atom}
+
+  @doc """
+  Converts the given `t:iso_days/0` to the first moment of the day.
+  """
+  @doc since: "1.15.0"
+  @callback iso_days_to_beginning_of_day(iso_days) :: iso_days
+
+  @doc """
+  Converts the given `t:iso_days/0` to the last moment of the day.
+  """
+  @doc since: "1.15.0"
+  @callback iso_days_to_end_of_day(iso_days) :: iso_days
+
+  @doc """
+  Shifts date by given duration according to its calendar.
+  """
+  @doc since: "1.17.0"
+  @callback shift_date(year, month, day, Duration.t()) :: {year, month, day}
+
+  @doc """
+  Shifts naive datetime by given duration according to its calendar.
+  """
+  @doc since: "1.17.0"
+  @callback shift_naive_datetime(
+              year,
+              month,
+              day,
+              hour,
+              minute,
+              second,
+              microsecond,
+              Duration.t()
+            ) :: {year, month, day, hour, minute, second, microsecond}
+
+  @doc """
+  Shifts time by given duration according to its calendar.
+  """
+  @doc since: "1.17.0"
+  @callback shift_time(hour, minute, second, microsecond, Duration.t()) ::
+              {hour, minute, second, microsecond}
+
+  # General Helpers
+
+  @doc """
+  Returns `true` if two calendars have the same moment of starting a new day,
+  `false` otherwise.
+
+  If two calendars are not compatible, we can only convert datetimes and times
+  between them. If they are compatible, this means that we can also convert
+  dates as well as naive datetimes between them.
+  """
+  @doc since: "1.5.0"
+  @spec compatible_calendars?(Calendar.calendar(), Calendar.calendar()) :: boolean
+  def compatible_calendars?(calendar, calendar), do: true
+
+  def compatible_calendars?(calendar1, calendar2) do
+    calendar1.day_rollover_relative_to_midnight_utc() ==
+      calendar2.day_rollover_relative_to_midnight_utc()
+  end
+
+  @doc """
+  Returns a microsecond tuple truncated to a given precision (`:microsecond`,
+  `:millisecond`, or `:second`).
+  """
+  @doc since: "1.6.0"
+  @spec truncate(Calendar.microsecond(), :microsecond | :millisecond | :second) ::
+          Calendar.microsecond()
+  def truncate(microsecond_tuple, :microsecond), do: microsecond_tuple
+
+  def truncate({microsecond, precision}, :millisecond) do
+    output_precision = min(precision, 3)
+    {div(microsecond, 1000) * 1000, output_precision}
+  end
+
+  def truncate(_, :second), do: {0, 0}
+
+  @doc """
+  Sets the current time zone database.
+  """
+  @doc since: "1.8.0"
+  @spec put_time_zone_database(time_zone_database()) :: :ok
+  def put_time_zone_database(database) when is_atom(database) do
+    Application.put_env(:elixir, :time_zone_database, database)
+  end
+
+  @doc """
+  Gets the current time zone database.
+  """
+  @doc since: "1.8.0"
+  @spec get_time_zone_database() :: time_zone_database()
+  def get_time_zone_database() do
+    Application.fetch_env!(:elixir, :time_zone_database)
+  end
+
+  @doc """
+  Formats the given date, time, or datetime into a string.
+
+  The datetime can be any of the `Calendar` types (`Time`, `Date`,
+  `NaiveDateTime`, and `DateTime`) or any map, as long as they
+  contain all of the relevant fields necessary for formatting.
+  For example, if you use `%Y` to format the year, the datetime
+  must have the `:year` field. Therefore, if you pass a `Time`,
+  or a map without the `:year` field to a format that expects `%Y`,
+  an error will be raised.
+
+  Examples of common usage:
+
+      iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], "%y-%m-%d %I:%M:%S %p")
+      "19-08-26 01:52:06 PM"
+
+      iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], "%a, %B %d %Y")
+      "Mon, August 26 2019"
+
+  ## User Options
+
+    * `:preferred_datetime` - a string for the preferred format to show datetimes,
+      it can't contain the `%c` format and defaults to `"%Y-%m-%d %H:%M:%S"`
+      if the option is not received
+
+    * `:preferred_date` - a string for the preferred format to show dates,
+      it can't contain the `%x` format and defaults to `"%Y-%m-%d"`
+      if the option is not received
+
+    * `:preferred_time` - a string for the preferred format to show times,
+      it can't contain the `%X` format and defaults to `"%H:%M:%S"`
+      if the option is not received
+
+    * `:am_pm_names` - a function that receives either `:am` or `:pm`
+      (and also the datetime if the function is arity/2) and returns
+      the name of the period of the day, if the option is not received it defaults
+      to a function that returns `"am"` and `"pm"`, respectively
+
+    *  `:month_names` - a function that receives a number (and also the
+      datetime if the function is arity/2) and returns the name of
+      the corresponding month, if the option is not received it defaults to a
+      function that returns the month names in English
+
+    * `:abbreviated_month_names` - a function that receives a number (and also
+      the datetime if the function is arity/2) and returns the
+      abbreviated name of the corresponding month, if the option is not received it
+      defaults to a function that returns the abbreviated month names in English
+
+    * `:day_of_week_names` - a function that receives a number and (and also the
+      datetime if the function is arity/2) returns the name of
+      the corresponding day of week, if the option is not received it defaults to a
+      function that returns the day of week names in English
+
+    * `:abbreviated_day_of_week_names` - a function that receives a number (and also
+      the datetime if the function is arity/2) and returns the abbreviated name of
+      the corresponding day of week, if the option is not received it defaults to a
+      function that returns the abbreviated day of week names in English
+
+  ## Formatting syntax
+
+  The formatting syntax for the `string_format` argument is a sequence of characters in
+  the following format:
+
+      %<padding><width><format>
+
+  where:
+
+    * `%`: indicates the start of a formatted section
+    * `<padding>`: set the padding (see below)
+    * `<width>`: a number indicating the minimum size of the formatted section
+    * `<format>`: the format itself (see below)
+
+  ### Accepted padding options
+
+    * `-`: no padding, removes all padding from the format
+    * `_`: pad with spaces
+    * `0`: pad with zeroes
+
+  ### Accepted string formats
+
+  The accepted formats for `string_format` are:
+
+  Format | Description                                                             | Examples (in ISO)
+  :----- | :-----------------------------------------------------------------------| :------------------------
+  a      | Abbreviated name of day                                                 | Mon
+  A      | Full name of day                                                        | Monday
+  b      | Abbreviated month name                                                  | Jan
+  B      | Full month name                                                         | January
+  c      | Preferred date+time representation                                      | 2018-10-17 12:34:56
+  d      | Day of the month                                                        | 01, 31
+  f      | Microseconds (uses its precision for width and padding)                 | 000000, 999999, 0123
+  H      | Hour using a 24-hour clock                                              | 00, 23
+  I      | Hour using a 12-hour clock                                              | 01, 12
+  j      | Day of the year                                                         | 001, 366
+  m      | Month                                                                   | 01, 12
+  M      | Minute                                                                  | 00, 59
+  p      | "AM" or "PM" (noon is "PM", midnight as "AM")                           | AM, PM
+  P      | "am" or "pm" (noon is "pm", midnight as "am")                           | am, pm
+  q      | Quarter                                                                 | 1, 2, 3, 4
+  s      | Number of seconds since the Epoch, 1970-01-01 00:00:00+0000 (UTC)       | 1565888877
+  S      | Second                                                                  | 00, 59, 60
+  u      | Day of the week                                                         | 1 (Monday), 7 (Sunday)
+  x      | Preferred date (without time) representation                            | 2018-10-17
+  X      | Preferred time (without date) representation                            | 12:34:56
+  y      | Year as 2-digits                                                        | 01, 01, 86, 18
+  Y      | Year                                                                    | -0001, 0001, 1986
+  z      | +hhmm/-hhmm time zone offset from UTC (empty string if naive)           | +0300, -0530
+  Z      | Time zone abbreviation (empty string if naive)                          | CET, BRST
+  %      | Literal "%" character                                                   | %
+
+  Any other character will be interpreted as an invalid format and raise an error.
+
+  ### `%f` Microseconds
+
+  `%f` does not support width and padding modifiers.  It will be formatted by truncating
+  the microseconds to the precision of the `microseconds` field of the struct, with a
+  minimum precision of 1.
+
+  ## Examples
+
+  Without user options:
+
+      iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], "%y-%m-%d %I:%M:%S %p")
+      "19-08-26 01:52:06 PM"
+
+      iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], "%a, %B %d %Y")
+      "Mon, August 26 2019"
+
+      iex> Calendar.strftime(~U[2020-04-02 13:52:06.0Z], "%B %-d, %Y")
+      "April 2, 2020"
+
+      iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], "%c")
+      "2019-08-26 13:52:06"
+
+  With user options:
+
+      iex> Calendar.strftime(~U[2019-08-26 13:52:06.0Z], "%c", preferred_datetime: "%H:%M:%S %d-%m-%y")
+      "13:52:06 26-08-19"
+
+      iex> Calendar.strftime(
+      ...>  ~U[2019-08-26 13:52:06.0Z],
+      ...>  "%A",
+      ...>  day_of_week_names: fn day_of_week ->
+      ...>    {"segunda-feira", "terça-feira", "quarta-feira", "quinta-feira",
+      ...>    "sexta-feira", "sábado", "domingo"}
+      ...>    |> elem(day_of_week - 1)
+      ...>  end
+      ...>)
+      "segunda-feira"
+
+      iex> Calendar.strftime(
+      ...>  ~U[2019-08-26 13:52:06.0Z],
+      ...>  "%B",
+      ...>  month_names: fn month ->
+      ...>    {"січень", "лютий", "березень", "квітень", "травень", "червень",
+      ...>    "липень", "серпень", "вересень", "жовтень", "листопад", "грудень"}
+      ...>    |> elem(month - 1)
+      ...>  end
+      ...>)
+      "серпень"
+
+   Microsecond formatting:
+
+      iex> Calendar.strftime(~U[2019-08-26 13:52:06Z], "%y-%m-%d %H:%M:%S.%f")
+      "19-08-26 13:52:06.0"
+
+      iex> Calendar.strftime(~U[2019-08-26 13:52:06.048Z], "%y-%m-%d %H:%M:%S.%f")
+      "19-08-26 13:52:06.048"
+
+      iex> Calendar.strftime(~U[2019-08-26 13:52:06.048531Z], "%y-%m-%d %H:%M:%S.%f")
+      "19-08-26 13:52:06.048531"
+
+  """
+  @doc since: "1.11.0"
+  @spec strftime(map(), String.t(), strftime_opts()) :: String.t()
+  def strftime(date_or_time_or_datetime, string_format, user_options \\ [])
+      when is_map(date_or_time_or_datetime) and is_binary(string_format) do
+    parse(
+      string_format,
+      date_or_time_or_datetime,
+      options(user_options),
+      []
+    )
+    |> IO.iodata_to_binary()
+  end
+
+  defp parse("", _datetime, _format_options, acc),
+    do: Enum.reverse(acc)
+
+  defp parse("%" <> rest, datetime, format_options, acc),
+    do: parse_modifiers(rest, nil, nil, {datetime, format_options, acc})
+
+  defp parse(<<char, rest::binary>>, datetime, format_options, acc),
+    do: parse(rest, datetime, format_options, [char | acc])
+
+  defp parse_modifiers("-" <> rest, width, nil, parser_data) do
+    parse_modifiers(rest, width, "", parser_data)
+  end
+
+  defp parse_modifiers("0" <> rest, nil, nil, parser_data) do
+    parse_modifiers(rest, nil, ?0, parser_data)
+  end
+
+  defp parse_modifiers("_" <> rest, width, nil, parser_data) do
+    parse_modifiers(rest, width, ?\s, parser_data)
+  end
+
+  defp parse_modifiers(<<digit, rest::binary>>, width, pad, parser_data) when digit in ?0..?9 do
+    new_width = (width || 0) * 10 + (digit - ?0)
+
+    parse_modifiers(rest, new_width, pad, parser_data)
+  end
+
+  # set default padding if none was specified
+  defp parse_modifiers(<<format, _::binary>> = rest, width, nil, parser_data) do
+    parse_modifiers(rest, width, default_pad(format), parser_data)
+  end
+
+  # set default width if none was specified
+  defp parse_modifiers(<<format, _::binary>> = rest, nil, pad, parser_data) do
+    parse_modifiers(rest, default_width(format), pad, parser_data)
+  end
+
+  defp parse_modifiers(rest, width, pad, {datetime, format_options, acc}) do
+    format_modifiers(rest, width, pad, datetime, format_options, acc)
+  end
+
+  defp am_pm(hour, format_options, datetime) when hour > 11 do
+    apply_format(:pm, format_options.am_pm_names, datetime)
+  end
+
+  defp am_pm(hour, format_options, datetime) when hour <= 11 do
+    apply_format(:am, format_options.am_pm_names, datetime)
+  end
+
+  defp default_pad(format) when format in ~c"aAbBpPZ", do: ?\s
+  defp default_pad(_format), do: ?0
+
+  defp default_width(format) when format in ~c"dHImMSy", do: 2
+  defp default_width(?j), do: 3
+  defp default_width(format) when format in ~c"Yz", do: 4
+  defp default_width(_format), do: 0
+
+  # Literally just %
+  defp format_modifiers("%" <> rest, width, pad, datetime, format_options, acc) do
+    parse(rest, datetime, format_options, [pad_leading("%", width, pad) | acc])
+  end
+
+  # Abbreviated name of day
+  defp format_modifiers("a" <> rest, width, pad, datetime, format_options, acc) do
+    result =
+      datetime
+      |> Date.day_of_week()
+      |> apply_format(format_options.abbreviated_day_of_week_names, datetime)
+      |> pad_leading(width, pad)
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Full name of day
+  defp format_modifiers("A" <> rest, width, pad, datetime, format_options, acc) do
+    result =
+      datetime
+      |> Date.day_of_week()
+      |> apply_format(format_options.day_of_week_names, datetime)
+      |> pad_leading(width, pad)
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Abbreviated month name
+  defp format_modifiers("b" <> rest, width, pad, datetime, format_options, acc) do
+    result =
+      datetime.month
+      |> apply_format(format_options.abbreviated_month_names, datetime)
+      |> pad_leading(width, pad)
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Full month name
+  defp format_modifiers("B" <> rest, width, pad, datetime, format_options, acc) do
+    result =
+      datetime.month
+      |> apply_format(format_options.month_names, datetime)
+      |> pad_leading(width, pad)
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Preferred date+time representation
+  defp format_modifiers(
+         "c" <> _rest,
+         _width,
+         _pad,
+         _datetime,
+         %{preferred_datetime_invoked: true},
+         _acc
+       ) do
+    raise ArgumentError,
+          "tried to format preferred_datetime within another preferred_datetime format"
+  end
+
+  defp format_modifiers("c" <> rest, width, pad, datetime, format_options, acc) do
+    result =
+      format_options.preferred_datetime
+      |> parse(datetime, %{format_options | preferred_datetime_invoked: true}, [])
+      |> pad_preferred(width, pad)
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Day of the month
+  defp format_modifiers("d" <> rest, width, pad, datetime, format_options, acc) do
+    result = datetime.day |> Integer.to_string() |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Microseconds
+  defp format_modifiers("f" <> rest, _width, _pad, datetime, format_options, acc) do
+    {microsecond, precision} = datetime.microsecond
+
+    result =
+      microsecond
+      |> Integer.to_string()
+      |> String.pad_leading(6, "0")
+      |> binary_part(0, max(precision, 1))
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Hour using a 24-hour clock
+  defp format_modifiers("H" <> rest, width, pad, datetime, format_options, acc) do
+    result = datetime.hour |> Integer.to_string() |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Hour using a 12-hour clock
+  defp format_modifiers("I" <> rest, width, pad, datetime, format_options, acc) do
+    result = (rem(datetime.hour + 23, 12) + 1) |> Integer.to_string() |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Day of the year
+  defp format_modifiers("j" <> rest, width, pad, datetime, format_options, acc) do
+    result = datetime |> Date.day_of_year() |> Integer.to_string() |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Month
+  defp format_modifiers("m" <> rest, width, pad, datetime, format_options, acc) do
+    result = datetime.month |> Integer.to_string() |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Minute
+  defp format_modifiers("M" <> rest, width, pad, datetime, format_options, acc) do
+    result = datetime.minute |> Integer.to_string() |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # "AM" or "PM" (noon is "PM", midnight as "AM")
+  defp format_modifiers("p" <> rest, width, pad, datetime, format_options, acc) do
+    result =
+      datetime.hour
+      |> am_pm(format_options, datetime)
+      |> String.upcase()
+      |> pad_leading(width, pad)
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # "am" or "pm" (noon is "pm", midnight as "am")
+  defp format_modifiers("P" <> rest, width, pad, datetime, format_options, acc) do
+    result =
+      datetime.hour
+      |> am_pm(format_options, datetime)
+      |> String.downcase()
+      |> pad_leading(width, pad)
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Quarter
+  defp format_modifiers("q" <> rest, width, pad, datetime, format_options, acc) do
+    result = datetime |> Date.quarter_of_year() |> Integer.to_string() |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Second
+  defp format_modifiers("S" <> rest, width, pad, datetime, format_options, acc) do
+    result = datetime.second |> Integer.to_string() |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Day of the week
+  defp format_modifiers("u" <> rest, width, pad, datetime, format_options, acc) do
+    result = datetime |> Date.day_of_week() |> Integer.to_string() |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Preferred date (without time) representation
+  defp format_modifiers(
+         "x" <> _rest,
+         _width,
+         _pad,
+         _datetime,
+         %{preferred_date_invoked: true},
+         _acc
+       ) do
+    raise ArgumentError,
+          "tried to format preferred_date within another preferred_date format"
+  end
+
+  defp format_modifiers("x" <> rest, width, pad, datetime, format_options, acc) do
+    result =
+      format_options.preferred_date
+      |> parse(datetime, %{format_options | preferred_date_invoked: true}, [])
+      |> pad_preferred(width, pad)
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Preferred time (without date) representation
+  defp format_modifiers(
+         "X" <> _rest,
+         _width,
+         _pad,
+         _datetime,
+         %{preferred_time_invoked: true},
+         _acc
+       ) do
+    raise ArgumentError,
+          "tried to format preferred_time within another preferred_time format"
+  end
+
+  defp format_modifiers("X" <> rest, width, pad, datetime, format_options, acc) do
+    result =
+      format_options.preferred_time
+      |> parse(datetime, %{format_options | preferred_time_invoked: true}, [])
+      |> pad_preferred(width, pad)
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Year as 2-digits
+  defp format_modifiers("y" <> rest, width, pad, datetime, format_options, acc) do
+    result = datetime.year |> rem(100) |> Integer.to_string() |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Year
+  defp format_modifiers("Y" <> rest, width, pad, datetime, format_options, acc) do
+    {sign, year} =
+      if datetime.year < 0 do
+        {?-, -datetime.year}
+      else
+        {[], datetime.year}
+      end
+
+    result = [sign | year |> Integer.to_string() |> pad_leading(width, pad)]
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Epoch time for DateTime with time zones
+  defp format_modifiers(
+         "s" <> rest,
+         _width,
+         _pad,
+         datetime = %{utc_offset: _utc_offset, std_offset: _std_offset},
+         format_options,
+         acc
+       ) do
+    result =
+      datetime
+      |> DateTime.shift_zone!("Etc/UTC")
+      |> NaiveDateTime.diff(~N[1970-01-01 00:00:00])
+      |> Integer.to_string()
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # Epoch time
+  defp format_modifiers("s" <> rest, _width, _pad, datetime, format_options, acc) do
+    result =
+      datetime
+      |> NaiveDateTime.diff(~N[1970-01-01 00:00:00])
+      |> Integer.to_string()
+
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  # +hhmm/-hhmm time zone offset from UTC (empty string if naive)
+  defp format_modifiers(
+         "z" <> rest,
+         width,
+         pad,
+         datetime = %{utc_offset: utc_offset, std_offset: std_offset},
+         format_options,
+         acc
+       ) do
+    absolute_offset = abs(utc_offset + std_offset)
+
+    offset_number =
+      Integer.to_string(div(absolute_offset, 3600) * 100 + rem(div(absolute_offset, 60), 60))
+
+    sign = if utc_offset + std_offset >= 0, do: "+", else: "-"
+    result = "#{sign}#{pad_leading(offset_number, width, pad)}"
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  defp format_modifiers("z" <> rest, _width, _pad, datetime, format_options, acc) do
+    parse(rest, datetime, format_options, ["" | acc])
+  end
+
+  # Time zone abbreviation (empty string if naive)
+  defp format_modifiers("Z" <> rest, width, pad, datetime, format_options, acc) do
+    result = datetime |> Map.get(:zone_abbr, "") |> pad_leading(width, pad)
+    parse(rest, datetime, format_options, [result | acc])
+  end
+
+  defp format_modifiers(rest, _width, _pad, _datetime, _format_options, _acc) do
+    {next, _rest} = String.next_grapheme(rest) || {"", ""}
+    raise ArgumentError, "invalid strftime format: %#{next}"
+  end
+
+  defp pad_preferred(result, width, pad) when length(result) < width do
+    pad_preferred([pad | result], width, pad)
+  end
+
+  defp pad_preferred(result, _width, _pad), do: result
+
+  defp pad_leading(string, count, padding) do
+    to_pad = count - byte_size(string)
+    if to_pad > 0, do: do_pad_leading(to_pad, padding, string), else: string
+  end
+
+  defp do_pad_leading(0, _, acc), do: acc
+
+  defp do_pad_leading(count, padding, acc),
+    do: do_pad_leading(count - 1, padding, [padding | acc])
+
+  defp apply_format(term, formatter, _datetime) when is_function(formatter, 1) do
+    formatter.(term)
+  end
+
+  defp apply_format(term, formatter, datetime) when is_function(formatter, 2) do
+    formatter.(term, datetime)
+  end
+
+  defp apply_format(_term, formatter, _datetime) do
+    raise ArgumentError, "formatter functions must be of arity 1 or 2, got: #{inspect(formatter)}"
+  end
+
+  defp options(user_options) do
+    default_options = %{
+      preferred_date: "%Y-%m-%d",
+      preferred_time: "%H:%M:%S",
+      preferred_datetime: "%Y-%m-%d %H:%M:%S",
+      am_pm_names: fn
+        :am -> "am"
+        :pm -> "pm"
+      end,
+      month_names: fn month ->
+        {"January", "February", "March", "April", "May", "June", "July", "August", "September",
+         "October", "November", "December"}
+        |> elem(month - 1)
+      end,
+      day_of_week_names: fn day_of_week ->
+        {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
+        |> elem(day_of_week - 1)
+      end,
+      abbreviated_month_names: fn month ->
+        {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}
+        |> elem(month - 1)
+      end,
+      abbreviated_day_of_week_names: fn day_of_week ->
+        {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"} |> elem(day_of_week - 1)
+      end,
+      preferred_datetime_invoked: false,
+      preferred_date_invoked: false,
+      preferred_time_invoked: false
+    }
+
+    Enum.reduce(user_options, default_options, fn {key, value}, acc ->
+      if Map.has_key?(acc, key) do
+        %{acc | key => value}
+      else
+        raise ArgumentError, "unknown option #{inspect(key)} given to Calendar.strftime/3"
+      end
+    end)
+  end
+end
diff --git a/lib/elixir/lib/calendar/date.ex b/lib/elixir/lib/calendar/date.ex
new file mode 100644
index 00000000000..35c4b75d3f4
--- /dev/null
+++ b/lib/elixir/lib/calendar/date.ex
@@ -0,0 +1,1190 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Date do
+  @moduledoc """
+  A Date struct and functions.
+
+  The Date struct contains the fields year, month, day and calendar.
+  New dates can be built with the `new/3` function or using the
+  `~D` (see `sigil_D/2`) sigil:
+
+      iex> ~D[2000-01-01]
+      ~D[2000-01-01]
+
+  Both `new/3` and sigil return a struct where the date fields can
+  be accessed directly:
+
+      iex> date = ~D[2000-01-01]
+      iex> date.year
+      2000
+      iex> date.month
+      1
+
+  The functions on this module work with the `Date` struct as well
+  as any struct that contains the same fields as the `Date` struct,
+  such as `NaiveDateTime` and `DateTime`. Such functions expect
+  `t:Calendar.date/0` in their typespecs (instead of `t:t/0`).
+
+  Developers should avoid creating the Date structs directly
+  and instead rely on the functions provided by this module as well
+  as the ones in third-party calendar libraries.
+
+  ## Comparing dates
+
+  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
+  and based on the `Date` struct fields. For proper comparison between
+  dates, use the `compare/2`, `after?/2` and `before?/2` functions.
+  The existence of the `compare/2` function in this module also allows
+  using `Enum.min/2` and `Enum.max/2` functions to get the minimum and
+  maximum date of an `Enum`. For example:
+
+      iex> Enum.min([~D[2017-03-31], ~D[2017-04-01]], Date)
+      ~D[2017-03-31]
+
+  ## Using epochs
+
+  The `add/2`, `diff/2` and `shift/2` functions can be used for computing dates
+  or retrieving the number of days between instants. For example, if there
+  is an interest in computing the number of days from the Unix epoch
+  (1970-01-01):
+
+      iex> Date.diff(~D[2010-04-17], ~D[1970-01-01])
+      14716
+
+      iex> Date.add(~D[1970-01-01], 14_716)
+      ~D[2010-04-17]
+
+      iex> Date.shift(~D[1970-01-01], year: 40, month: 3, week: 2, day: 2)
+      ~D[2010-04-17]
+
+  Those functions are optimized to deal with common epochs, such
+  as the Unix Epoch above or the Gregorian Epoch (0000-01-01).
+  """
+
+  @enforce_keys [:year, :month, :day]
+  defstruct [:year, :month, :day, calendar: Calendar.ISO]
+
+  @type t :: %__MODULE__{
+          year: Calendar.year(),
+          month: Calendar.month(),
+          day: Calendar.day(),
+          calendar: Calendar.calendar()
+        }
+
+  @doc """
+  Returns a range of dates.
+
+  A range of dates represents a discrete number of dates where
+  the first and last values are dates with matching calendars.
+
+  Ranges of dates can be increasing (`first <= last`) and are
+  always inclusive. For a decreasing range, use `range/3` with
+  a step of -1 as first argument.
+
+  ## Examples
+
+      iex> Date.range(~D[1999-01-01], ~D[2000-01-01])
+      Date.range(~D[1999-01-01], ~D[2000-01-01])
+
+  A range of dates implements the `Enumerable` protocol, which means
+  functions in the `Enum` module can be used to work with
+  ranges:
+
+      iex> range = Date.range(~D[2001-01-01], ~D[2002-01-01])
+      iex> range
+      Date.range(~D[2001-01-01], ~D[2002-01-01])
+      iex> Enum.count(range)
+      366
+      iex> ~D[2001-02-01] in range
+      true
+      iex> Enum.take(range, 3)
+      [~D[2001-01-01], ~D[2001-01-02], ~D[2001-01-03]]
+
+  """
+  @doc since: "1.5.0"
+  @spec range(Calendar.date(), Calendar.date()) :: Date.Range.t()
+  def range(%{calendar: calendar} = first, %{calendar: calendar} = last) do
+    {first_days, _} = to_iso_days(first)
+    {last_days, _} = to_iso_days(last)
+
+    step =
+      if first_days <= last_days do
+        1
+      else
+        IO.warn(
+          "a negative range was inferred for Date.range/2, call Date.range/3 instead with -1 as third argument"
+        )
+
+        -1
+      end
+
+    range(first, first_days, last, last_days, calendar, step)
+  end
+
+  def range(%{calendar: _, year: _, month: _, day: _}, %{calendar: _, year: _, month: _, day: _}) do
+    raise ArgumentError, "both dates must have matching calendars"
+  end
+
+  @doc """
+  Returns a range of dates with a step.
+
+  ## Examples
+
+      iex> range = Date.range(~D[2001-01-01], ~D[2002-01-01], 2)
+      iex> range
+      Date.range(~D[2001-01-01], ~D[2002-01-01], 2)
+      iex> Enum.count(range)
+      183
+      iex> ~D[2001-01-03] in range
+      true
+      iex> Enum.take(range, 3)
+      [~D[2001-01-01], ~D[2001-01-03], ~D[2001-01-05]]
+
+  """
+  @doc since: "1.12.0"
+  @spec range(Calendar.date(), Calendar.date(), step :: pos_integer | neg_integer) ::
+          Date.Range.t()
+  def range(%{calendar: calendar} = first, %{calendar: calendar} = last, step)
+      when is_integer(step) and step != 0 do
+    {first_days, _} = to_iso_days(first)
+    {last_days, _} = to_iso_days(last)
+    range(first, first_days, last, last_days, calendar, step)
+  end
+
+  def range(
+        %{calendar: _, year: _, month: _, day: _} = first,
+        %{calendar: _, year: _, month: _, day: _} = last,
+        step
+      ) do
+    raise ArgumentError,
+          "both dates must have matching calendar and the step must be a " <>
+            "non-zero integer, got: #{inspect(first)}, #{inspect(last)}, #{step}"
+  end
+
+  defp range(first, first_days, last, last_days, calendar, step) do
+    %Date.Range{
+      first: %Date{calendar: calendar, year: first.year, month: first.month, day: first.day},
+      last: %Date{calendar: calendar, year: last.year, month: last.month, day: last.day},
+      first_in_iso_days: first_days,
+      last_in_iso_days: last_days,
+      step: step
+    }
+  end
+
+  @doc """
+  Returns the current date in UTC.
+
+  ## Examples
+
+      iex> date = Date.utc_today()
+      iex> date.year >= 2016
+      true
+
+  """
+  @doc since: "1.4.0"
+  @spec utc_today(Calendar.calendar()) :: t
+  def utc_today(calendar \\ Calendar.ISO)
+
+  def utc_today(Calendar.ISO) do
+    {:ok, {year, month, day}, _, _} = Calendar.ISO.from_unix(System.os_time(), :native)
+    %Date{year: year, month: month, day: day}
+  end
+
+  def utc_today(calendar) do
+    %{year: year, month: month, day: day} = DateTime.utc_now(calendar)
+    %Date{year: year, month: month, day: day, calendar: calendar}
+  end
+
+  @doc """
+  Returns `true` if the year in the given `date` is a leap year.
+
+  ## Examples
+
+      iex> Date.leap_year?(~D[2000-01-01])
+      true
+      iex> Date.leap_year?(~D[2001-01-01])
+      false
+      iex> Date.leap_year?(~D[2004-01-01])
+      true
+      iex> Date.leap_year?(~D[1900-01-01])
+      false
+      iex> Date.leap_year?(~N[2004-01-01 01:23:45])
+      true
+
+  """
+  @doc since: "1.4.0"
+  @spec leap_year?(Calendar.date()) :: boolean()
+  def leap_year?(date)
+
+  def leap_year?(%{calendar: calendar, year: year}) do
+    calendar.leap_year?(year)
+  end
+
+  @doc """
+  Returns the number of days in the given `date` month.
+
+  ## Examples
+
+      iex> Date.days_in_month(~D[1900-01-13])
+      31
+      iex> Date.days_in_month(~D[1900-02-09])
+      28
+      iex> Date.days_in_month(~N[2000-02-20 01:23:45])
+      29
+
+  """
+  @doc since: "1.4.0"
+  @spec days_in_month(Calendar.date()) :: Calendar.day()
+  def days_in_month(date)
+
+  def days_in_month(%{calendar: calendar, year: year, month: month}) do
+    calendar.days_in_month(year, month)
+  end
+
+  @doc """
+  Returns the number of months in the given `date` year.
+
+  ## Example
+
+      iex> Date.months_in_year(~D[1900-01-13])
+      12
+
+  """
+  @doc since: "1.7.0"
+  @spec months_in_year(Calendar.date()) :: Calendar.month()
+  def months_in_year(date)
+
+  def months_in_year(%{calendar: calendar, year: year}) do
+    calendar.months_in_year(year)
+  end
+
+  @doc """
+  Builds a new ISO date.
+
+  Expects all values to be integers. Returns `{:ok, date}` if each
+  entry fits its appropriate range, returns `{:error, reason}` otherwise.
+
+  ## Examples
+
+      iex> Date.new(2000, 1, 1)
+      {:ok, ~D[2000-01-01]}
+      iex> Date.new(2000, 13, 1)
+      {:error, :invalid_date}
+      iex> Date.new(2000, 2, 29)
+      {:ok, ~D[2000-02-29]}
+
+      iex> Date.new(2000, 2, 30)
+      {:error, :invalid_date}
+      iex> Date.new(2001, 2, 29)
+      {:error, :invalid_date}
+
+  """
+  @spec new(Calendar.year(), Calendar.month(), Calendar.day(), Calendar.calendar()) ::
+          {:ok, t} | {:error, atom}
+  def new(year, month, day, calendar \\ Calendar.ISO) do
+    if calendar.valid_date?(year, month, day) do
+      {:ok, %Date{year: year, month: month, day: day, calendar: calendar}}
+    else
+      {:error, :invalid_date}
+    end
+  end
+
+  @doc """
+  Builds a new ISO date.
+
+  Expects all values to be integers. Returns `date` if each
+  entry fits its appropriate range, raises if the date is invalid.
+
+  ## Examples
+
+      iex> Date.new!(2000, 1, 1)
+      ~D[2000-01-01]
+      iex> Date.new!(2000, 13, 1)
+      ** (ArgumentError) cannot build date, reason: :invalid_date
+      iex> Date.new!(2000, 2, 29)
+      ~D[2000-02-29]
+  """
+  @doc since: "1.11.0"
+  @spec new!(Calendar.year(), Calendar.month(), Calendar.day(), Calendar.calendar()) :: t
+  def new!(year, month, day, calendar \\ Calendar.ISO) do
+    case new(year, month, day, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, reason} ->
+        raise ArgumentError, "cannot build date, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Converts the given date to a string according to its calendar.
+
+  ## Examples
+
+      iex> Date.to_string(~D[2000-02-28])
+      "2000-02-28"
+      iex> Date.to_string(~N[2000-02-28 01:23:45])
+      "2000-02-28"
+      iex> Date.to_string(~D[-0100-12-15])
+      "-0100-12-15"
+
+  """
+  @spec to_string(Calendar.date()) :: String.t()
+  def to_string(date)
+
+  def to_string(%{calendar: calendar, year: year, month: month, day: day}) do
+    calendar.date_to_string(year, month, day)
+  end
+
+  @doc """
+  Parses the extended "Dates" format described by
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+
+  The year parsed by this function is limited to four digits.
+
+  ## Examples
+
+      iex> Date.from_iso8601("2015-01-23")
+      {:ok, ~D[2015-01-23]}
+
+      iex> Date.from_iso8601("2015:01:23")
+      {:error, :invalid_format}
+
+      iex> Date.from_iso8601("2015-01-32")
+      {:error, :invalid_date}
+
+  """
+  @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
+  def from_iso8601(string, calendar \\ Calendar.ISO) do
+    with {:ok, {year, month, day}} <- Calendar.ISO.parse_date(string) do
+      convert(%Date{year: year, month: month, day: day}, calendar)
+    end
+  end
+
+  @doc """
+  Parses the extended "Dates" format described by
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+
+  Raises if the format is invalid.
+
+  ## Examples
+
+      iex> Date.from_iso8601!("2015-01-23")
+      ~D[2015-01-23]
+      iex> Date.from_iso8601!("2015:01:23")
+      ** (ArgumentError) cannot parse "2015:01:23" as date, reason: :invalid_format
+
+  """
+  @spec from_iso8601!(String.t(), Calendar.calendar()) :: t
+  def from_iso8601!(string, calendar \\ Calendar.ISO) do
+    case from_iso8601(string, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, reason} ->
+        raise ArgumentError, "cannot parse #{inspect(string)} as date, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Converts the given `date` to
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+
+  By default, `Date.to_iso8601/2` returns dates formatted in the "extended"
+  format, for human readability. It also supports the "basic" format through passing the `:basic` option.
+
+  Only supports converting dates which are in the ISO calendar,
+  or other calendars in which the days also start at midnight.
+  Attempting to convert dates from other calendars will raise an `ArgumentError`.
+
+  ## Examples
+
+      iex> Date.to_iso8601(~D[2000-02-28])
+      "2000-02-28"
+
+      iex> Date.to_iso8601(~D[2000-02-28], :basic)
+      "20000228"
+
+      iex> Date.to_iso8601(~N[2000-02-28 00:00:00])
+      "2000-02-28"
+
+  """
+  @spec to_iso8601(Calendar.date(), :extended | :basic) :: String.t()
+  def to_iso8601(date, format \\ :extended)
+
+  def to_iso8601(%{calendar: Calendar.ISO} = date, format) when format in [:basic, :extended] do
+    %{year: year, month: month, day: day} = date
+    Calendar.ISO.date_to_string(year, month, day, format)
+  end
+
+  def to_iso8601(%{calendar: _} = date, format) when format in [:basic, :extended] do
+    date
+    |> convert!(Calendar.ISO)
+    |> to_iso8601()
+  end
+
+  @doc """
+  Converts the given `date` to an Erlang date tuple.
+
+  Only supports converting dates which are in the ISO calendar,
+  or other calendars in which the days also start at midnight.
+  Attempting to convert dates from other calendars will raise.
+
+  ## Examples
+
+      iex> Date.to_erl(~D[2000-01-01])
+      {2000, 1, 1}
+
+      iex> Date.to_erl(~N[2000-01-01 00:00:00])
+      {2000, 1, 1}
+
+  """
+  @spec to_erl(Calendar.date()) :: :calendar.date()
+  def to_erl(date) do
+    %{year: year, month: month, day: day} = convert!(date, Calendar.ISO)
+    {year, month, day}
+  end
+
+  @doc """
+  Converts an Erlang date tuple to a `Date` struct.
+
+  Only supports converting dates which are in the ISO calendar,
+  or other calendars in which the days also start at midnight.
+  Attempting to convert dates from other calendars will return an error tuple.
+
+  ## Examples
+
+      iex> Date.from_erl({2000, 1, 1})
+      {:ok, ~D[2000-01-01]}
+      iex> Date.from_erl({2000, 13, 1})
+      {:error, :invalid_date}
+
+  """
+  @spec from_erl(:calendar.date(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
+  def from_erl(tuple, calendar \\ Calendar.ISO)
+
+  def from_erl({year, month, day}, calendar) do
+    with {:ok, date} <- new(year, month, day, Calendar.ISO), do: convert(date, calendar)
+  end
+
+  @doc """
+  Converts an Erlang date tuple but raises for invalid dates.
+
+  ## Examples
+
+      iex> Date.from_erl!({2000, 1, 1})
+      ~D[2000-01-01]
+      iex> Date.from_erl!({2000, 13, 1})
+      ** (ArgumentError) cannot convert {2000, 13, 1} to date, reason: :invalid_date
+
+  """
+  @spec from_erl!(:calendar.date(), Calendar.calendar()) :: t
+  def from_erl!(tuple, calendar \\ Calendar.ISO) do
+    case from_erl(tuple, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "cannot convert #{inspect(tuple)} to date, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Converts a number of gregorian days to a `Date` struct.
+
+  ## Examples
+
+      iex> Date.from_gregorian_days(1)
+      ~D[0000-01-02]
+      iex> Date.from_gregorian_days(730_485)
+      ~D[2000-01-01]
+      iex> Date.from_gregorian_days(-1)
+      ~D[-0001-12-31]
+
+  """
+  @doc since: "1.11.0"
+  @spec from_gregorian_days(integer(), Calendar.calendar()) :: t
+  def from_gregorian_days(days, calendar \\ Calendar.ISO) when is_integer(days) do
+    from_iso_days({days, 0}, calendar)
+  end
+
+  @doc """
+  Converts a `date` struct to a number of gregorian days.
+
+  ## Examples
+
+      iex> Date.to_gregorian_days(~D[0000-01-02])
+      1
+      iex> Date.to_gregorian_days(~D[2000-01-01])
+      730_485
+      iex> Date.to_gregorian_days(~N[2000-01-01 00:00:00])
+      730_485
+
+  """
+  @doc since: "1.11.0"
+  @spec to_gregorian_days(Calendar.date()) :: integer()
+  def to_gregorian_days(date) do
+    {days, _} = to_iso_days(date)
+    days
+  end
+
+  @doc """
+  Compares two date structs.
+
+  Returns `:gt` if first date is later than the second
+  and `:lt` for vice versa. If the two dates are equal
+  `:eq` is returned.
+
+  ## Examples
+
+      iex> Date.compare(~D[2016-04-16], ~D[2016-04-28])
+      :lt
+
+  This function can also be used to compare across more
+  complex calendar types by considering only the date fields:
+
+      iex> Date.compare(~D[2016-04-16], ~N[2016-04-28 01:23:45])
+      :lt
+      iex> Date.compare(~D[2016-04-16], ~N[2016-04-16 01:23:45])
+      :eq
+      iex> Date.compare(~N[2016-04-16 12:34:56], ~N[2016-04-16 01:23:45])
+      :eq
+
+  """
+  @doc since: "1.4.0"
+  @spec compare(Calendar.date(), Calendar.date()) :: :lt | :eq | :gt
+  def compare(%{calendar: calendar} = date1, %{calendar: calendar} = date2) do
+    %{year: year1, month: month1, day: day1} = date1
+    %{year: year2, month: month2, day: day2} = date2
+
+    case {{year1, month1, day1}, {year2, month2, day2}} do
+      {first, second} when first > second -> :gt
+      {first, second} when first < second -> :lt
+      _ -> :eq
+    end
+  end
+
+  def compare(%{calendar: calendar1} = date1, %{calendar: calendar2} = date2) do
+    if Calendar.compatible_calendars?(calendar1, calendar2) do
+      case {to_iso_days(date1), to_iso_days(date2)} do
+        {first, second} when first > second -> :gt
+        {first, second} when first < second -> :lt
+        _ -> :eq
+      end
+    else
+      raise ArgumentError, """
+      cannot compare #{inspect(date1)} with #{inspect(date2)}.
+
+      This comparison would be ambiguous as their calendars have incompatible day rollover moments.
+      Specify an exact time of day (using DateTime) to resolve this ambiguity
+      """
+    end
+  end
+
+  @doc """
+  Returns `true` if the first date is strictly earlier than the second.
+
+  ## Examples
+
+      iex> Date.before?(~D[2021-01-01], ~D[2022-02-02])
+      true
+      iex> Date.before?(~D[2021-01-01], ~D[2021-01-01])
+      false
+      iex> Date.before?(~D[2022-02-02], ~D[2021-01-01])
+      false
+
+  """
+  @doc since: "1.15.0"
+  @spec before?(Calendar.date(), Calendar.date()) :: boolean()
+  def before?(date1, date2) do
+    compare(date1, date2) == :lt
+  end
+
+  @doc """
+  Returns `true` if the first date is strictly later than the second.
+
+  ## Examples
+
+      iex> Date.after?(~D[2022-02-02], ~D[2021-01-01])
+      true
+      iex> Date.after?(~D[2021-01-01], ~D[2021-01-01])
+      false
+      iex> Date.after?(~D[2021-01-01], ~D[2022-02-02])
+      false
+
+  """
+  @doc since: "1.15.0"
+  @spec after?(Calendar.date(), Calendar.date()) :: boolean()
+  def after?(date1, date2) do
+    compare(date1, date2) == :gt
+  end
+
+  @doc """
+  Converts the given `date` from its calendar to the given `calendar`.
+
+  Returns `{:ok, date}` if the calendars are compatible,
+  or `{:error, :incompatible_calendars}` if they are not.
+
+  See also `Calendar.compatible_calendars?/2`.
+
+  ## Examples
+
+  Imagine someone implements `Calendar.Holocene`, a calendar based on the
+  Gregorian calendar that adds exactly 10 000 years to the current Gregorian
+  year:
+
+      iex> Date.convert(~D[2000-01-01], Calendar.Holocene)
+      {:ok, %Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}}
+
+  """
+  @doc since: "1.5.0"
+  @spec convert(Calendar.date(), Calendar.calendar()) ::
+          {:ok, t} | {:error, :incompatible_calendars}
+  def convert(%{calendar: calendar, year: year, month: month, day: day}, calendar) do
+    {:ok, %Date{calendar: calendar, year: year, month: month, day: day}}
+  end
+
+  def convert(%{calendar: calendar} = date, target_calendar) do
+    if Calendar.compatible_calendars?(calendar, target_calendar) do
+      result_date =
+        date
+        |> to_iso_days()
+        |> from_iso_days(target_calendar)
+
+      {:ok, result_date}
+    else
+      {:error, :incompatible_calendars}
+    end
+  end
+
+  @doc """
+  Similar to `Date.convert/2`, but raises an `ArgumentError`
+  if the conversion between the two calendars is not possible.
+
+  ## Examples
+
+  Imagine someone implements `Calendar.Holocene`, a calendar based on the
+  Gregorian calendar that adds exactly 10 000 years to the current Gregorian
+  year:
+
+      iex> Date.convert!(~D[2000-01-01], Calendar.Holocene)
+      %Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}
+
+  """
+  @doc since: "1.5.0"
+  @spec convert!(Calendar.date(), Calendar.calendar()) :: t
+  def convert!(date, calendar) do
+    case convert(date, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "cannot convert #{inspect(date)} to target calendar #{inspect(calendar)}, " <>
+                "reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Adds the number of days to the given `date`.
+
+  > #### Prefer `shift/2` {: .info}
+  >
+  > Prefer `shift/2` over `add/2`, as it offers a more ergonomic API.
+  >
+  > `add/2` always considers a day to be measured according to the
+  > `Calendar.ISO`.
+
+  The days are counted as Gregorian days, independent of the underlying
+  calendar. The date is returned in the same calendar as it was given in.
+
+  ## Examples
+
+      iex> Date.add(~D[2000-01-03], -2)
+      ~D[2000-01-01]
+      iex> Date.add(~D[2000-01-01], 2)
+      ~D[2000-01-03]
+      iex> Date.add(~N[2000-01-01 09:00:00], 2)
+      ~D[2000-01-03]
+      iex> Date.add(~D[-0010-01-01], -2)
+      ~D[-0011-12-30]
+
+  """
+  @doc since: "1.5.0"
+  @spec add(Calendar.date(), integer()) :: t
+  def add(%{calendar: Calendar.ISO} = date, days) do
+    %{year: year, month: month, day: day} = date
+    {year, month, day} = Calendar.ISO.shift_days({year, month, day}, days)
+    %Date{calendar: Calendar.ISO, year: year, month: month, day: day}
+  end
+
+  def add(%{calendar: calendar} = date, days) do
+    {base_days, fraction} = to_iso_days(date)
+    from_iso_days({base_days + days, fraction}, calendar)
+  end
+
+  @doc """
+  Calculates the difference between two dates, in a full number of days.
+
+  It returns the number of Gregorian days between the dates. Only `Date`
+  structs that follow the same or compatible calendars can be compared
+  this way. If two calendars are not compatible, it will raise.
+
+  ## Examples
+
+      iex> Date.diff(~D[2000-01-03], ~D[2000-01-01])
+      2
+      iex> Date.diff(~D[2000-01-01], ~D[2000-01-03])
+      -2
+      iex> Date.diff(~D[0000-01-02], ~D[-0001-12-30])
+      3
+      iex> Date.diff(~D[2000-01-01], ~N[2000-01-03 09:00:00])
+      -2
+
+  """
+  @doc since: "1.5.0"
+  @spec diff(Calendar.date(), Calendar.date()) :: integer
+  def diff(%{calendar: Calendar.ISO} = date1, %{calendar: Calendar.ISO} = date2) do
+    %{year: year1, month: month1, day: day1} = date1
+    %{year: year2, month: month2, day: day2} = date2
+
+    Calendar.ISO.date_to_iso_days(year1, month1, day1) -
+      Calendar.ISO.date_to_iso_days(year2, month2, day2)
+  end
+
+  def diff(%{calendar: calendar1} = date1, %{calendar: calendar2} = date2) do
+    if Calendar.compatible_calendars?(calendar1, calendar2) do
+      {days1, _} = to_iso_days(date1)
+      {days2, _} = to_iso_days(date2)
+      days1 - days2
+    else
+      raise ArgumentError,
+            "cannot calculate the difference between #{inspect(date1)} and #{inspect(date2)} because their calendars are not compatible and thus the result would be ambiguous"
+    end
+  end
+
+  @doc """
+  Shifts given `date` by `duration` according to its calendar.
+
+  Allowed units are: `:year`, `:month`, `:week`, `:day`.
+
+  When using the default ISO calendar, durations are collapsed and
+  applied in the order of months and then days:
+
+  * when shifting by 1 year and 2 months the date is actually shifted by 14 months
+  * when shifting by 2 weeks and 3 days the date is shifted by 17 days
+
+  When shifting by month, days are rounded down to the nearest valid date.
+
+  Raises an `ArgumentError` when called with time scale units.
+
+  ## Examples
+
+      iex> Date.shift(~D[2016-01-03], month: 2)
+      ~D[2016-03-03]
+      iex> Date.shift(~D[2016-01-30], month: -1)
+      ~D[2015-12-30]
+      iex> Date.shift(~D[2016-01-31], year: 4, day: 1)
+      ~D[2020-02-01]
+      iex> Date.shift(~D[2016-01-03], Duration.new!(month: 2))
+      ~D[2016-03-03]
+
+      # leap years
+      iex> Date.shift(~D[2024-02-29], year: 1)
+      ~D[2025-02-28]
+      iex> Date.shift(~D[2024-02-29], year: 4)
+      ~D[2028-02-29]
+
+      # rounding down
+      iex> Date.shift(~D[2015-01-31], month: 1)
+      ~D[2015-02-28]
+
+  """
+  @doc since: "1.17.0"
+  @spec shift(Calendar.date(), Duration.t() | [unit_pair]) :: t
+        when unit_pair: {:year, integer} | {:month, integer} | {:week, integer} | {:day, integer}
+  def shift(%{calendar: calendar} = date, duration) do
+    %{year: year, month: month, day: day} = date
+    {year, month, day} = calendar.shift_date(year, month, day, __duration__!(duration))
+    %Date{calendar: calendar, year: year, month: month, day: day}
+  end
+
+  @doc false
+  def __duration__!(%Duration{} = duration) do
+    duration
+  end
+
+  # This part is inlined by the compiler on constant values
+  def __duration__!(unit_pairs) do
+    Enum.each(unit_pairs, &validate_duration_unit!/1)
+    struct!(Duration, unit_pairs)
+  end
+
+  defp validate_duration_unit!({unit, _value})
+       when unit in [:hour, :minute, :second, :microsecond] do
+    raise ArgumentError, "unsupported unit #{inspect(unit)}. Expected :year, :month, :week, :day"
+  end
+
+  defp validate_duration_unit!({unit, _value}) when unit not in [:year, :month, :week, :day] do
+    raise ArgumentError, "unknown unit #{inspect(unit)}. Expected :year, :month, :week, :day"
+  end
+
+  defp validate_duration_unit!({_unit, value}) when is_integer(value) do
+    :ok
+  end
+
+  defp validate_duration_unit!({unit, value}) do
+    raise ArgumentError,
+          "unsupported value #{inspect(value)} for #{inspect(unit)}. Expected an integer"
+  end
+
+  @doc false
+  def to_iso_days(%{calendar: Calendar.ISO, year: year, month: month, day: day}) do
+    {Calendar.ISO.date_to_iso_days(year, month, day), {0, 86_400_000_000}}
+  end
+
+  def to_iso_days(%{calendar: calendar, year: year, month: month, day: day}) do
+    calendar.naive_datetime_to_iso_days(year, month, day, 0, 0, 0, {0, 0})
+  end
+
+  defp from_iso_days({days, _}, Calendar.ISO) do
+    {year, month, day} = Calendar.ISO.date_from_iso_days(days)
+    %Date{year: year, month: month, day: day, calendar: Calendar.ISO}
+  end
+
+  defp from_iso_days(iso_days, target_calendar) do
+    {year, month, day, _, _, _, _} = target_calendar.naive_datetime_from_iso_days(iso_days)
+    %Date{year: year, month: month, day: day, calendar: target_calendar}
+  end
+
+  @doc """
+  Calculates the ordinal day of the week of a given `date`.
+
+  Returns the day of the week as an integer. For the ISO 8601
+  calendar (the default), it is an integer from 1 to 7, where
+  1 is Monday and 7 is Sunday.
+
+  An optional `starting_on` value may be supplied, which
+  configures the weekday the week starts on. The default value
+  for it is `:default`, which translates to `:monday` for the
+  built-in ISO 8601 calendar. Any other weekday may be used for
+  `starting_on`, in such cases, that weekday will be considered the first
+  day of the week, and therefore it will be assigned the ordinal number 1.
+
+  The other calendars, the value returned is an ordinal day of week.
+  For example, `1` may mean "first day of the week" and `7` is
+  defined to mean "seventh day of the week". Custom calendars may
+  also accept their own variations of the `starting_on` parameter
+  with their own meaning.
+
+  ## Examples
+
+      # 2016-10-31 is a Monday and by default Monday is the first day of the week
+      iex> Date.day_of_week(~D[2016-10-31])
+      1
+      iex> Date.day_of_week(~D[2016-11-01])
+      2
+      iex> Date.day_of_week(~N[2016-11-01 01:23:45])
+      2
+      iex> Date.day_of_week(~D[-0015-10-30])
+      3
+
+      # 2016-10-31 is a Monday but, as we start the week on Sunday, now it returns 2
+      iex> Date.day_of_week(~D[2016-10-31], :sunday)
+      2
+      iex> Date.day_of_week(~D[2016-11-01], :sunday)
+      3
+      iex> Date.day_of_week(~N[2016-11-01 01:23:45], :sunday)
+      3
+      iex> Date.day_of_week(~D[-0015-10-30], :sunday)
+      4
+
+  """
+  @doc since: "1.4.0"
+  @spec day_of_week(Calendar.date(), starting_on :: :default | atom) :: Calendar.day_of_week()
+  def day_of_week(date, starting_on \\ :default)
+
+  def day_of_week(%{calendar: calendar, year: year, month: month, day: day}, starting_on) do
+    {day_of_week, _first, _last} = calendar.day_of_week(year, month, day, starting_on)
+    day_of_week
+  end
+
+  @doc """
+  Calculates a date that is the first day of the week for the given `date`.
+
+  If the day is already the first day of the week, it returns the
+  day itself. For the built-in ISO calendar, the week starts on Monday.
+  A weekday rather than `:default` can be given as `starting_on`.
+
+  ## Examples
+
+      iex> Date.beginning_of_week(~D[2020-07-11])
+      ~D[2020-07-06]
+      iex> Date.beginning_of_week(~D[2020-07-06])
+      ~D[2020-07-06]
+      iex> Date.beginning_of_week(~D[2020-07-11], :sunday)
+      ~D[2020-07-05]
+      iex> Date.beginning_of_week(~D[2020-07-11], :saturday)
+      ~D[2020-07-11]
+      iex> Date.beginning_of_week(~N[2020-07-11 01:23:45])
+      ~D[2020-07-06]
+
+  """
+  @doc since: "1.11.0"
+  @spec beginning_of_week(Calendar.date(), starting_on :: :default | atom) :: Date.t()
+  def beginning_of_week(date, starting_on \\ :default)
+
+  def beginning_of_week(%{calendar: Calendar.ISO} = date, starting_on) do
+    %{year: year, month: month, day: day} = date
+    iso_days = Calendar.ISO.date_to_iso_days(year, month, day)
+
+    {year, month, day} =
+      case Calendar.ISO.iso_days_to_day_of_week(iso_days, starting_on) do
+        1 ->
+          {year, month, day}
+
+        day_of_week ->
+          Calendar.ISO.date_from_iso_days(iso_days - day_of_week + 1)
+      end
+
+    %Date{calendar: Calendar.ISO, year: year, month: month, day: day}
+  end
+
+  def beginning_of_week(%{calendar: calendar} = date, starting_on) do
+    %{year: year, month: month, day: day} = date
+
+    case calendar.day_of_week(year, month, day, starting_on) do
+      {day_of_week, day_of_week, _} ->
+        %Date{calendar: calendar, year: year, month: month, day: day}
+
+      {day_of_week, first_day_of_week, _} ->
+        add(date, -(day_of_week - first_day_of_week))
+    end
+  end
+
+  @doc """
+  Calculates a date that is the last day of the week for the given `date`.
+
+  If the day is already the last day of the week, it returns the
+  day itself. For the built-in ISO calendar, the week ends on Sunday.
+  A weekday rather than `:default` can be given as `starting_on`.
+
+  ## Examples
+
+      iex> Date.end_of_week(~D[2020-07-11])
+      ~D[2020-07-12]
+      iex> Date.end_of_week(~D[2020-07-05])
+      ~D[2020-07-05]
+      iex> Date.end_of_week(~D[2020-07-06], :sunday)
+      ~D[2020-07-11]
+      iex> Date.end_of_week(~D[2020-07-06], :saturday)
+      ~D[2020-07-10]
+      iex> Date.end_of_week(~N[2020-07-11 01:23:45])
+      ~D[2020-07-12]
+
+  """
+  @doc since: "1.11.0"
+  @spec end_of_week(Calendar.date(), starting_on :: :default | atom) :: Date.t()
+  def end_of_week(date, starting_on \\ :default)
+
+  def end_of_week(%{calendar: Calendar.ISO} = date, starting_on) do
+    %{year: year, month: month, day: day} = date
+    iso_days = Calendar.ISO.date_to_iso_days(year, month, day)
+
+    {year, month, day} =
+      case Calendar.ISO.iso_days_to_day_of_week(iso_days, starting_on) do
+        7 ->
+          {year, month, day}
+
+        day_of_week ->
+          Calendar.ISO.date_from_iso_days(iso_days + 7 - day_of_week)
+      end
+
+    %Date{calendar: Calendar.ISO, year: year, month: month, day: day}
+  end
+
+  def end_of_week(%{calendar: calendar} = date, starting_on) do
+    %{year: year, month: month, day: day} = date
+
+    case calendar.day_of_week(year, month, day, starting_on) do
+      {day_of_week, _, day_of_week} ->
+        %Date{calendar: calendar, year: year, month: month, day: day}
+
+      {day_of_week, _, last_day_of_week} ->
+        add(date, last_day_of_week - day_of_week)
+    end
+  end
+
+  @doc """
+  Calculates the day of the year of a given `date`.
+
+  Returns the day of the year as an integer. For the ISO 8601
+  calendar (the default), it is an integer from 1 to 366.
+
+  ## Examples
+
+      iex> Date.day_of_year(~D[2016-01-01])
+      1
+      iex> Date.day_of_year(~D[2016-11-01])
+      306
+      iex> Date.day_of_year(~D[-0015-10-30])
+      303
+      iex> Date.day_of_year(~D[2004-12-31])
+      366
+
+  """
+  @doc since: "1.8.0"
+  @spec day_of_year(Calendar.date()) :: Calendar.day()
+  def day_of_year(date)
+
+  def day_of_year(%{calendar: calendar, year: year, month: month, day: day}) do
+    calendar.day_of_year(year, month, day)
+  end
+
+  @doc """
+  Calculates the quarter of the year of a given `date`.
+
+  Returns the day of the year as an integer. For the ISO 8601
+  calendar (the default), it is an integer from 1 to 4.
+
+  ## Examples
+
+      iex> Date.quarter_of_year(~D[2016-10-31])
+      4
+      iex> Date.quarter_of_year(~D[2016-01-01])
+      1
+      iex> Date.quarter_of_year(~N[2016-04-01 01:23:45])
+      2
+      iex> Date.quarter_of_year(~D[-0015-09-30])
+      3
+
+  """
+  @doc since: "1.8.0"
+  @spec quarter_of_year(Calendar.date()) :: non_neg_integer()
+  def quarter_of_year(date)
+
+  def quarter_of_year(%{calendar: calendar, year: year, month: month, day: day}) do
+    calendar.quarter_of_year(year, month, day)
+  end
+
+  @doc """
+  Calculates the year-of-era and era for a given
+  calendar year.
+
+  Returns a tuple `{year, era}` representing the
+  year within the era and the era number.
+
+  ## Examples
+
+      iex> Date.year_of_era(~D[0001-01-01])
+      {1, 1}
+      iex> Date.year_of_era(~D[0000-12-31])
+      {1, 0}
+      iex> Date.year_of_era(~D[-0001-01-01])
+      {2, 0}
+
+  """
+  @doc since: "1.8.0"
+  @spec year_of_era(Calendar.date()) :: {Calendar.year(), non_neg_integer()}
+  def year_of_era(date)
+
+  def year_of_era(%{calendar: calendar, year: year, month: month, day: day}) do
+    calendar.year_of_era(year, month, day)
+  end
+
+  @doc """
+  Calculates the day-of-era and era for a given
+  calendar `date`.
+
+  Returns a tuple `{day, era}` representing the
+  day within the era and the era number.
+
+  ## Examples
+
+      iex> Date.day_of_era(~D[0001-01-01])
+      {1, 1}
+
+      iex> Date.day_of_era(~D[0000-12-31])
+      {1, 0}
+
+  """
+  @doc since: "1.8.0"
+  @spec day_of_era(Calendar.date()) :: {Calendar.day(), non_neg_integer()}
+  def day_of_era(date)
+
+  def day_of_era(%{calendar: calendar, year: year, month: month, day: day}) do
+    calendar.day_of_era(year, month, day)
+  end
+
+  @doc """
+  Calculates a date that is the first day of the month for the given `date`.
+
+  ## Examples
+
+      iex> Date.beginning_of_month(~D[2000-01-31])
+      ~D[2000-01-01]
+      iex> Date.beginning_of_month(~D[2000-01-01])
+      ~D[2000-01-01]
+      iex> Date.beginning_of_month(~N[2000-01-31 01:23:45])
+      ~D[2000-01-01]
+
+  """
+  @doc since: "1.11.0"
+  @spec beginning_of_month(Calendar.date()) :: t()
+  def beginning_of_month(date)
+
+  def beginning_of_month(%{year: year, month: month, calendar: calendar}) do
+    %Date{year: year, month: month, day: 1, calendar: calendar}
+  end
+
+  @doc """
+  Calculates a date that is the last day of the month for the given `date`.
+
+  ## Examples
+
+      iex> Date.end_of_month(~D[2000-01-01])
+      ~D[2000-01-31]
+      iex> Date.end_of_month(~D[2000-01-31])
+      ~D[2000-01-31]
+      iex> Date.end_of_month(~N[2000-01-01 01:23:45])
+      ~D[2000-01-31]
+
+  """
+  @doc since: "1.11.0"
+  @spec end_of_month(Calendar.date()) :: t()
+  def end_of_month(date)
+
+  def end_of_month(%{year: year, month: month, calendar: calendar} = date) do
+    day = Date.days_in_month(date)
+    %Date{year: year, month: month, day: day, calendar: calendar}
+  end
+
+  ## Helpers
+
+  defimpl String.Chars do
+    def to_string(%{calendar: calendar, year: year, month: month, day: day}) do
+      calendar.date_to_string(year, month, day)
+    end
+  end
+
+  defimpl Inspect do
+    def inspect(%{calendar: calendar, year: year, month: month, day: day}, _)
+        when calendar != Calendar.ISO or year in -9999..9999 do
+      "~D[" <> calendar.date_to_string(year, month, day) <> suffix(calendar) <> "]"
+    end
+
+    def inspect(%{calendar: Calendar.ISO, year: year, month: month, day: day}, _) do
+      "Date.new!(#{Integer.to_string(year)}, #{Integer.to_string(month)}, #{Integer.to_string(day)})"
+    end
+
+    def inspect(%{calendar: calendar, year: year, month: month, day: day}, _) do
+      "Date.new!(#{Integer.to_string(year)}, #{Integer.to_string(month)}, #{Integer.to_string(day)}, #{inspect(calendar)})"
+    end
+
+    defp suffix(Calendar.ISO), do: ""
+    defp suffix(calendar), do: " " <> inspect(calendar)
+  end
+end
diff --git a/lib/elixir/lib/calendar/date_range.ex b/lib/elixir/lib/calendar/date_range.ex
new file mode 100644
index 00000000000..5e8c652b781
--- /dev/null
+++ b/lib/elixir/lib/calendar/date_range.ex
@@ -0,0 +1,235 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Date.Range do
+  @moduledoc """
+  Returns an inclusive range between dates.
+
+  Ranges must be created with the `Date.range/2` or `Date.range/3` function.
+
+  The following fields are public:
+
+    * `:first` - the initial date on the range
+    * `:last` - the last date on the range
+    * `:step` - (since v1.12.0) the step
+
+  The remaining fields are private and should not be accessed.
+  """
+
+  @type t :: %__MODULE__{
+          first: Date.t(),
+          last: Date.t(),
+          first_in_iso_days: days(),
+          last_in_iso_days: days(),
+          step: pos_integer | neg_integer
+        }
+
+  @typep days() :: integer()
+
+  @enforce_keys [:first, :last, :first_in_iso_days, :last_in_iso_days, :step]
+  defstruct [:first, :last, :first_in_iso_days, :last_in_iso_days, :step]
+
+  defimpl Enumerable do
+    def member?(
+          %Date.Range{
+            first: %{calendar: calendar},
+            first_in_iso_days: first_days,
+            last_in_iso_days: last_days,
+            step: step
+          } = range,
+          %Date{calendar: calendar} = date
+        ) do
+      {days, _} = Date.to_iso_days(date)
+
+      cond do
+        empty?(range) ->
+          {:ok, false}
+
+        first_days <= last_days ->
+          {:ok, first_days <= days and days <= last_days and rem(days - first_days, step) == 0}
+
+        true ->
+          {:ok, last_days <= days and days <= first_days and rem(days - first_days, step) == 0}
+      end
+    end
+
+    def member?(%Date.Range{step: _}, _) do
+      {:ok, false}
+    end
+
+    # TODO: Remove me on v2.0
+    def member?(
+          %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =
+            date_range,
+          date
+        ) do
+      step = if first_days <= last_days, do: 1, else: -1
+      member?(Map.put(date_range, :step, step), date)
+    end
+
+    def count(range) do
+      {:ok, size(range)}
+    end
+
+    def slice(
+          %Date.Range{
+            first_in_iso_days: first,
+            first: %{calendar: calendar},
+            step: step
+          } = range
+        ) do
+      {:ok, size(range), &slice(first + &1 * step, step + &3 - 1, &2, calendar)}
+    end
+
+    # TODO: Remove me on v2.0
+    def slice(
+          %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =
+            date_range
+        ) do
+      step = if first_days <= last_days, do: 1, else: -1
+      slice(Map.put(date_range, :step, step))
+    end
+
+    defp slice(current, _step, 1, calendar) do
+      [date_from_iso_days(current, calendar)]
+    end
+
+    defp slice(current, step, remaining, calendar) when remaining > 1 do
+      [
+        date_from_iso_days(current, calendar)
+        | slice(current + step, step, remaining - 1, calendar)
+      ]
+    end
+
+    def reduce(
+          %Date.Range{
+            first_in_iso_days: first_days,
+            last_in_iso_days: last_days,
+            first: %{calendar: calendar},
+            step: step
+          },
+          acc,
+          fun
+        ) do
+      reduce(first_days, last_days, acc, fun, step, calendar)
+    end
+
+    # TODO: Remove me on v2.0
+    def reduce(
+          %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =
+            date_range,
+          acc,
+          fun
+        ) do
+      step = if first_days <= last_days, do: 1, else: -1
+      reduce(Map.put(date_range, :step, step), acc, fun)
+    end
+
+    defp reduce(_first_days, _last_days, {:halt, acc}, _fun, _step, _calendar) do
+      {:halted, acc}
+    end
+
+    defp reduce(first_days, last_days, {:suspend, acc}, fun, step, calendar) do
+      {:suspended, acc, &reduce(first_days, last_days, &1, fun, step, calendar)}
+    end
+
+    defp reduce(first_days, last_days, {:cont, acc}, fun, step, calendar)
+         when step > 0 and first_days <= last_days
+         when step < 0 and first_days >= last_days do
+      reduce(
+        first_days + step,
+        last_days,
+        fun.(date_from_iso_days(first_days, calendar), acc),
+        fun,
+        step,
+        calendar
+      )
+    end
+
+    defp reduce(_, _, {:cont, acc}, _fun, _step, _calendar) do
+      {:done, acc}
+    end
+
+    defp date_from_iso_days(days, Calendar.ISO) do
+      {year, month, day} = Calendar.ISO.date_from_iso_days(days)
+      %Date{year: year, month: month, day: day, calendar: Calendar.ISO}
+    end
+
+    defp date_from_iso_days(days, calendar) do
+      {year, month, day, _, _, _, _} =
+        calendar.naive_datetime_from_iso_days({days, {0, 86_400_000_000}})
+
+      %Date{year: year, month: month, day: day, calendar: calendar}
+    end
+
+    defp size(%Date.Range{first_in_iso_days: first_days, last_in_iso_days: last_days, step: step})
+         when step > 0 and first_days > last_days,
+         do: 0
+
+    defp size(%Date.Range{first_in_iso_days: first_days, last_in_iso_days: last_days, step: step})
+         when step < 0 and first_days < last_days,
+         do: 0
+
+    defp size(%Date.Range{
+           first_in_iso_days: first_days,
+           last_in_iso_days: last_days,
+           step: step
+         }),
+         do: abs(div(last_days - first_days, step)) + 1
+
+    # TODO: Remove me on v2.0
+    defp size(
+           %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =
+             date_range
+         ) do
+      step = if first_days <= last_days, do: 1, else: -1
+      size(Map.put(date_range, :step, step))
+    end
+
+    defp empty?(%Date.Range{
+           first_in_iso_days: first_days,
+           last_in_iso_days: last_days,
+           step: step
+         })
+         when step > 0 and first_days > last_days,
+         do: true
+
+    defp empty?(%Date.Range{
+           first_in_iso_days: first_days,
+           last_in_iso_days: last_days,
+           step: step
+         })
+         when step < 0 and first_days < last_days,
+         do: true
+
+    defp empty?(%Date.Range{step: _}), do: false
+
+    # TODO: Remove me on v2.0
+    defp empty?(
+           %{__struct__: Date.Range, first_in_iso_days: first_days, last_in_iso_days: last_days} =
+             date_range
+         ) do
+      step = if first_days <= last_days, do: 1, else: -1
+      empty?(Map.put(date_range, :step, step))
+    end
+  end
+
+  defimpl Inspect do
+    import Kernel, except: [inspect: 2]
+
+    def inspect(%Date.Range{first: first, last: last, step: 1}, _) do
+      "Date.range(" <> inspect(first) <> ", " <> inspect(last) <> ")"
+    end
+
+    def inspect(%Date.Range{first: first, last: last, step: step}, _) do
+      "Date.range(" <> inspect(first) <> ", " <> inspect(last) <> ", #{step})"
+    end
+
+    # TODO: Remove me on v2.0
+    def inspect(%{__struct__: Date.Range, first: first, last: last} = date_range, opts) do
+      step = if first <= last, do: 1, else: -1
+      inspect(Map.put(date_range, :step, step), opts)
+    end
+  end
+end
diff --git a/lib/elixir/lib/calendar/datetime.ex b/lib/elixir/lib/calendar/datetime.ex
new file mode 100644
index 00000000000..6cf43e37766
--- /dev/null
+++ b/lib/elixir/lib/calendar/datetime.ex
@@ -0,0 +1,2166 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule DateTime do
+  @moduledoc """
+  A datetime implementation with a time zone.
+
+  This datetime can be seen as a snapshot of a date and time
+  at a given time zone. For such purposes, it also includes both
+  UTC and Standard offsets, as well as the zone abbreviation
+  field used exclusively for formatting purposes. Note future
+  datetimes are not necessarily guaranteed to exist, as time
+  zones may change any time in the future due to geopolitical
+  reasons. See the "Datetimes as snapshots" section for more
+  information.
+
+  Remember, comparisons in Elixir using `==/2`, `>/2`, `</2` and friends
+  are structural and based on the DateTime struct fields. For proper
+  comparison between datetimes, use the `compare/2`, `after?/2` and `before?/2` functions.
+  The existence of the `compare/2` function in this module also allows
+  using `Enum.min/2` and `Enum.max/2` functions to get the minimum and
+  maximum datetime of an `Enum`. For example:
+
+      iex> Enum.min([~U[2022-01-12 00:01:00.00Z], ~U[2021-01-12 00:01:00.00Z]], DateTime)
+      ~U[2021-01-12 00:01:00.00Z]
+
+  Developers should avoid creating the `DateTime` struct directly
+  and instead rely on the functions provided by this module as
+  well as the ones in third-party calendar libraries.
+
+  ## Time zone database
+
+  Many functions in this module require a time zone database.
+  A time zone database is a record of the UTC offsets that its locales have
+  used at various times in the past, are using, and are expected to use in the
+  future.
+  Because those plans can change, it needs to be periodically updated.
+
+  By default, `DateTime` uses the default time zone database returned by
+  `Calendar.get_time_zone_database/0`, which defaults to
+  `Calendar.UTCOnlyTimeZoneDatabase` which only handles "Etc/UTC"
+  datetimes and returns `{:error, :utc_only_time_zone_database}`
+  for any other time zone.
+
+  Other time zone databases can also be configured. Here are some
+  available options and libraries:
+
+    * [`time_zone_info`](https://github.com/hrzndhrn/time_zone_info)
+    * [`tz`](https://github.com/mathieuprog/tz)
+    * [`tzdata`](https://github.com/lau/tzdata)
+    * [`zoneinfo`](https://github.com/smartrent/zoneinfo) -
+      recommended for embedded devices
+
+  To use one of them, first make sure it is added as a dependency in `mix.exs`.
+  It can then be configured either via configuration:
+
+      config :elixir, :time_zone_database, Tz.TimeZoneDatabase
+
+  or by calling `Calendar.put_time_zone_database/1`:
+
+      Calendar.put_time_zone_database(Tz.TimeZoneDatabase)
+
+  See the proper names in the library installation instructions.
+
+  ## Datetimes as snapshots
+
+  In the first section, we described datetimes as a "snapshot of
+  a date and time at a given time zone". To understand precisely
+  what we mean, let's see an example.
+
+  Imagine someone in Poland who wants to schedule a meeting with someone
+  in Brazil in the next year. The meeting will happen at 2:30 AM
+  in the Polish time zone. At what time will the meeting happen in
+  Brazil?
+
+  You can consult the time zone database today, one year before,
+  using the API in this module and it will give you an answer that
+  is valid right now. However, this answer may not be valid in the
+  future. Why? Because both Brazil and Poland may change their timezone
+  rules, ultimately affecting the result. For example, a country may
+  choose to enter or abandon "Daylight Saving Time", which is a
+  process where we adjust the clock one hour forward or one hour
+  back once per year. Whenever the rules change, the exact instant
+  that 2:30 AM in Polish time will be in Brazil may change.
+
+  In other words, whenever working with future DateTimes, there is
+  no guarantee the results you get will always be correct, until
+  the event actually happens. Therefore, when you ask for a future
+  time, the answers you get are a snapshot that reflects the current
+  state of the time zone rules. For datetimes in the past, this is
+  not a problem, because time zone rules do not change for past
+  events.
+
+  To make matters worse, it may be that 2:30 AM in Polish time
+  does not actually even exist or it is ambiguous. If a certain
+  time zone observes "Daylight Saving Time", they will move their
+  clock forward once a year. When this happens, there is a whole
+  hour that does not exist. Then, when they move the clock back,
+  there is a certain hour that will happen twice. So if you want to
+  schedule a meeting when this shift back happens, you would need to
+  explicitly say which occurrence of 2:30 AM you mean: the one in
+  "Summer Time", which occurs before the shift, or the one
+  in "Standard Time", which occurs after it. Applications that are
+  date and time sensitive need to take these scenarios into account
+  and correctly communicate them to users.
+
+  The good news is: Elixir contains all of the building blocks
+  necessary to tackle those problems. The default timezone database
+  used by Elixir, `Calendar.UTCOnlyTimeZoneDatabase`, only works
+  with UTC, which does not observe those issues. Once you bring
+  a proper time zone database, the functions in this module will
+  query the database and return the relevant information. For
+  example, look at how `DateTime.new/4` returns different results
+  based on the scenarios described in this section.
+
+  ## Converting between timezones
+
+  Bearing in mind the cautions above, and assuming you've brought in a full
+  timezone database, here are some examples of common shifts between time
+  zones.
+
+      # Local time to UTC
+      new_york = DateTime.from_naive!(~N[2023-06-26T09:30:00], "America/New_York")
+      #=> #DateTime<2023-06-26 09:30:00-04:00 EDT America/New_York>
+
+      utc = DateTime.shift_zone!(new_york, "Etc/UTC")
+      #=> ~U[2023-06-26 13:30:00Z]
+
+      # UTC to local time
+      DateTime.shift_zone!(utc, "Europe/Paris")
+      #=> #DateTime<2023-06-26 15:30:00+02:00 CEST Europe/Paris>
+
+  """
+
+  @enforce_keys [:year, :month, :day, :hour, :minute, :second] ++
+                  [:time_zone, :zone_abbr, :utc_offset, :std_offset]
+
+  defstruct [
+    :year,
+    :month,
+    :day,
+    :hour,
+    :minute,
+    :second,
+    :time_zone,
+    :zone_abbr,
+    :utc_offset,
+    :std_offset,
+    microsecond: {0, 0},
+    calendar: Calendar.ISO
+  ]
+
+  @type t :: %__MODULE__{
+          year: Calendar.year(),
+          month: Calendar.month(),
+          day: Calendar.day(),
+          calendar: Calendar.calendar(),
+          hour: Calendar.hour(),
+          minute: Calendar.minute(),
+          second: Calendar.second(),
+          microsecond: Calendar.microsecond(),
+          time_zone: Calendar.time_zone(),
+          zone_abbr: Calendar.zone_abbr(),
+          utc_offset: Calendar.utc_offset(),
+          std_offset: Calendar.std_offset()
+        }
+
+  @unix_days :calendar.date_to_gregorian_days({1970, 1, 1})
+  @seconds_per_day 24 * 60 * 60
+
+  @doc """
+  Returns the current datetime in UTC.
+
+  If you want the current time in Unix seconds,
+  use `System.os_time/1` instead.
+
+  You can also pass a time unit to automatically
+  truncate the resulting datetime. This is available
+  since v1.15.0.
+
+  The default unit if none gets passed is `:native`,
+  which results on a default resolution of microseconds.
+
+  ## Examples
+
+      iex> datetime = DateTime.utc_now()
+      iex> datetime.time_zone
+      "Etc/UTC"
+
+      iex> datetime = DateTime.utc_now(:second)
+      iex> datetime.microsecond
+      {0, 0}
+
+  """
+  @spec utc_now(Calendar.calendar() | :native | :microsecond | :millisecond | :second) :: t
+  def utc_now(calendar_or_time_unit \\ Calendar.ISO) do
+    case calendar_or_time_unit do
+      unit when unit in [:microsecond, :millisecond, :second, :native] ->
+        utc_now(unit, Calendar.ISO)
+
+      calendar ->
+        System.os_time() |> from_unix!(:native, calendar)
+    end
+  end
+
+  @doc """
+  Returns the current datetime in UTC, supporting
+  a specific calendar and precision.
+
+  If you want the current time in Unix seconds,
+  use `System.os_time/1` instead.
+
+  ## Examples
+
+      iex> datetime = DateTime.utc_now(:microsecond, Calendar.ISO)
+      iex> datetime.time_zone
+      "Etc/UTC"
+
+      iex> datetime = DateTime.utc_now(:second, Calendar.ISO)
+      iex> datetime.microsecond
+      {0, 0}
+
+  """
+  @doc since: "1.15.0"
+  @spec utc_now(:native | :microsecond | :millisecond | :second, Calendar.calendar()) :: t
+  def utc_now(time_unit, calendar)
+      when time_unit in [:native, :microsecond, :millisecond, :second] do
+    System.os_time(time_unit) |> from_unix!(time_unit, calendar)
+  end
+
+  @doc """
+  Builds a datetime from date and time structs.
+
+  It expects a time zone to put the `DateTime` in.
+  If the time zone is not passed it will default to `"Etc/UTC"`,
+  which always succeeds. Otherwise, the `DateTime` is checked against the time zone database
+  given as `time_zone_database`. See the "Time zone database"
+  section in the module documentation.
+
+  ## Examples
+
+      iex> DateTime.new(~D[2016-05-24], ~T[13:26:08.003], "Etc/UTC")
+      {:ok, ~U[2016-05-24 13:26:08.003Z]}
+
+  When the datetime is ambiguous - for instance during changing from summer
+  to winter time - the two possible valid datetimes are returned in a tuple.
+  The first datetime is also the one which comes first chronologically, while
+  the second one comes last.
+
+      iex> {:ambiguous, first_dt, second_dt} = DateTime.new(~D[2018-10-28], ~T[02:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> first_dt
+      #DateTime<2018-10-28 02:30:00+02:00 CEST Europe/Copenhagen>
+      iex> second_dt
+      #DateTime<2018-10-28 02:30:00+01:00 CET Europe/Copenhagen>
+
+  When there is a gap in wall time - for instance in spring when the clocks are
+  turned forward - the latest valid datetime just before the gap and the first
+  valid datetime just after the gap.
+
+      iex> {:gap, just_before, just_after} = DateTime.new(~D[2019-03-31], ~T[02:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> just_before
+      #DateTime<2019-03-31 01:59:59.999999+01:00 CET Europe/Copenhagen>
+      iex> just_after
+      #DateTime<2019-03-31 03:00:00+02:00 CEST Europe/Copenhagen>
+
+  Most of the time there is one, and just one, valid datetime for a certain
+  date and time in a certain time zone.
+
+      iex> {:ok, datetime} = DateTime.new(~D[2018-07-28], ~T[12:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> datetime
+      #DateTime<2018-07-28 12:30:00+02:00 CEST Europe/Copenhagen>
+
+  """
+  @doc since: "1.11.0"
+  @spec new(Date.t(), Time.t(), Calendar.time_zone(), Calendar.time_zone_database()) ::
+          {:ok, t}
+          | {:ambiguous, first_datetime :: t, second_datetime :: t}
+          | {:gap, t, t}
+          | {:error,
+             :incompatible_calendars | :time_zone_not_found | :utc_only_time_zone_database}
+  def new(
+        date,
+        time,
+        time_zone \\ "Etc/UTC",
+        time_zone_database \\ Calendar.get_time_zone_database()
+      )
+
+  def new(%Date{calendar: calendar} = date, %Time{calendar: calendar} = time, "Etc/UTC", _db) do
+    %{year: year, month: month, day: day} = date
+    %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time
+
+    datetime = %DateTime{
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      std_offset: 0,
+      utc_offset: 0,
+      zone_abbr: "UTC",
+      time_zone: "Etc/UTC"
+    }
+
+    {:ok, datetime}
+  end
+
+  def new(date, time, time_zone, time_zone_database) do
+    with {:ok, naive_datetime} <- NaiveDateTime.new(date, time) do
+      from_naive(naive_datetime, time_zone, time_zone_database)
+    end
+  end
+
+  @doc """
+  Builds a datetime from date and time structs, raising on errors.
+
+  It expects a time zone to put the `DateTime` in.
+  If the time zone is not passed it will default to `"Etc/UTC"`,
+  which always succeeds. Otherwise, the DateTime is checked against the time zone database
+  given as `time_zone_database`. See the "Time zone database"
+  section in the module documentation.
+
+  ## Examples
+
+      iex> DateTime.new!(~D[2016-05-24], ~T[13:26:08.003], "Etc/UTC")
+      ~U[2016-05-24 13:26:08.003Z]
+
+  When the datetime is ambiguous - for instance during changing from summer
+  to winter time - an error will be raised.
+
+      iex> DateTime.new!(~D[2018-10-28], ~T[02:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      ** (ArgumentError) cannot build datetime with ~D[2018-10-28] and ~T[02:30:00] because such instant is ambiguous in time zone Europe/Copenhagen as there is an overlap between #DateTime<2018-10-28 02:30:00+02:00 CEST Europe/Copenhagen> and #DateTime<2018-10-28 02:30:00+01:00 CET Europe/Copenhagen>
+
+  When there is a gap in wall time - for instance in spring when the clocks are
+  turned forward - an error will be raised.
+
+      iex> DateTime.new!(~D[2019-03-31], ~T[02:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      ** (ArgumentError) cannot build datetime with ~D[2019-03-31] and ~T[02:30:00] because such instant does not exist in time zone Europe/Copenhagen as there is a gap between #DateTime<2019-03-31 01:59:59.999999+01:00 CET Europe/Copenhagen> and #DateTime<2019-03-31 03:00:00+02:00 CEST Europe/Copenhagen>
+
+  Most of the time there is one, and just one, valid datetime for a certain
+  date and time in a certain time zone.
+
+      iex> datetime = DateTime.new!(~D[2018-07-28], ~T[12:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> datetime
+      #DateTime<2018-07-28 12:30:00+02:00 CEST Europe/Copenhagen>
+
+  """
+  @doc since: "1.11.0"
+  @spec new!(Date.t(), Time.t(), Calendar.time_zone(), Calendar.time_zone_database()) :: t
+  def new!(
+        date,
+        time,
+        time_zone \\ "Etc/UTC",
+        time_zone_database \\ Calendar.get_time_zone_database()
+      )
+
+  def new!(date, time, time_zone, time_zone_database) do
+    case new(date, time, time_zone, time_zone_database) do
+      {:ok, datetime} ->
+        datetime
+
+      {:ambiguous, dt1, dt2} ->
+        raise ArgumentError,
+              "cannot build datetime with #{inspect(date)} and #{inspect(time)} because such " <>
+                "instant is ambiguous in time zone #{time_zone} as there is an overlap " <>
+                "between #{inspect(dt1)} and #{inspect(dt2)}"
+
+      {:gap, dt1, dt2} ->
+        raise ArgumentError,
+              "cannot build datetime with #{inspect(date)} and #{inspect(time)} because such " <>
+                "instant does not exist in time zone #{time_zone} as there is a gap " <>
+                "between #{inspect(dt1)} and #{inspect(dt2)}"
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "cannot build datetime with #{inspect(date)} and #{inspect(time)}, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Converts the given Unix time to `DateTime`.
+
+  The integer can be given in different unit, according to `System.convert_time_unit/3`,
+  and it will be converted to microseconds internally, which is the maximum precision
+  supported by `DateTime`. In other words, any precision higher than microseconds will
+  lead to truncation.
+
+  Unix times are always in UTC. Therefore the DateTime will be returned in UTC.
+
+  ## Examples
+
+      iex> {:ok, datetime} = DateTime.from_unix(1_464_096_368)
+      iex> datetime
+      ~U[2016-05-24 13:26:08Z]
+
+      iex> {:ok, datetime} = DateTime.from_unix(1_432_560_368_868_569, :microsecond)
+      iex> datetime
+      ~U[2015-05-25 13:26:08.868569Z]
+
+      iex> {:ok, datetime} = DateTime.from_unix(253_402_300_799)
+      iex> datetime
+      ~U[9999-12-31 23:59:59Z]
+
+      iex> {:error, :invalid_unix_time} = DateTime.from_unix(253_402_300_800)
+
+  The unit can also be an integer as in `t:System.time_unit/0`:
+
+      iex> {:ok, datetime} = DateTime.from_unix(143_256_036_886_856, 1024)
+      iex> datetime
+      ~U[6403-03-17 07:05:22.320312Z]
+
+  Negative Unix times are supported up to -377705116800 seconds:
+
+      iex> {:ok, datetime} = DateTime.from_unix(-377_705_116_800)
+      iex> datetime
+      ~U[-9999-01-01 00:00:00Z]
+
+      iex> {:error, :invalid_unix_time} = DateTime.from_unix(-377_705_116_801)
+
+  """
+  @spec from_unix(integer, :native | System.time_unit(), Calendar.calendar()) ::
+          {:ok, t} | {:error, atom}
+  def from_unix(integer, unit \\ :second, calendar \\ Calendar.ISO) when is_integer(integer) do
+    case Calendar.ISO.from_unix(integer, unit) do
+      {:ok, {year, month, day}, {hour, minute, second}, microsecond} ->
+        iso_datetime = %DateTime{
+          year: year,
+          month: month,
+          day: day,
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: microsecond,
+          std_offset: 0,
+          utc_offset: 0,
+          zone_abbr: "UTC",
+          time_zone: "Etc/UTC"
+        }
+
+        convert(iso_datetime, calendar)
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  @doc """
+  Converts the given Unix time to `DateTime`.
+
+  The integer can be given in different unit
+  according to `System.convert_time_unit/3` and it will
+  be converted to microseconds internally.
+
+  Unix times are always in UTC and therefore the DateTime
+  will be returned in UTC.
+
+  ## Examples
+
+      # An easy way to get the Unix epoch is passing 0 to this function
+      iex> DateTime.from_unix!(0)
+      ~U[1970-01-01 00:00:00Z]
+
+      iex> DateTime.from_unix!(1_464_096_368)
+      ~U[2016-05-24 13:26:08Z]
+
+      iex> DateTime.from_unix!(1_432_560_368_868_569, :microsecond)
+      ~U[2015-05-25 13:26:08.868569Z]
+
+      iex> DateTime.from_unix!(143_256_036_886_856, 1024)
+      ~U[6403-03-17 07:05:22.320312Z]
+
+  """
+  @spec from_unix!(integer, :native | System.time_unit(), Calendar.calendar()) :: t
+  def from_unix!(integer, unit \\ :second, calendar \\ Calendar.ISO) do
+    case from_unix(integer, unit, calendar) do
+      {:ok, datetime} ->
+        datetime
+
+      {:error, :invalid_unix_time} ->
+        raise ArgumentError, "invalid Unix time #{integer}"
+    end
+  end
+
+  @doc """
+  Converts the given `NaiveDateTime` to `DateTime`.
+
+  It expects a time zone to put the `NaiveDateTime` in.
+  If the time zone is "Etc/UTC", it always succeeds. Otherwise,
+  the NaiveDateTime is checked against the time zone database
+  given as `time_zone_database`. See the "Time zone database"
+  section in the module documentation.
+
+  ## Examples
+
+      iex> DateTime.from_naive(~N[2016-05-24 13:26:08.003], "Etc/UTC")
+      {:ok, ~U[2016-05-24 13:26:08.003Z]}
+
+  When the datetime is ambiguous - for instance during changing from summer
+  to winter time - the two possible valid datetimes are returned in a tuple.
+  The first datetime is also the one which comes first chronologically, while
+  the second one comes last.
+
+      iex> {:ambiguous, first_dt, second_dt} = DateTime.from_naive(~N[2018-10-28 02:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> first_dt
+      #DateTime<2018-10-28 02:30:00+02:00 CEST Europe/Copenhagen>
+      iex> second_dt
+      #DateTime<2018-10-28 02:30:00+01:00 CET Europe/Copenhagen>
+
+  When there is a gap in wall time - for instance in spring when the clocks are
+  turned forward - the latest valid datetime just before the gap and the first
+  valid datetime just after the gap.
+
+      iex> {:gap, just_before, just_after} = DateTime.from_naive(~N[2019-03-31 02:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> just_before
+      #DateTime<2019-03-31 01:59:59.999999+01:00 CET Europe/Copenhagen>
+      iex> just_after
+      #DateTime<2019-03-31 03:00:00+02:00 CEST Europe/Copenhagen>
+
+  Most of the time there is one, and just one, valid datetime for a certain
+  date and time in a certain time zone.
+
+      iex> {:ok, datetime} = DateTime.from_naive(~N[2018-07-28 12:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> datetime
+      #DateTime<2018-07-28 12:30:00+02:00 CEST Europe/Copenhagen>
+
+  This function accepts any map or struct that contains at least the same fields as a `NaiveDateTime`
+  struct. The most common example of that is a `DateTime`. In this case the information about the time
+  zone of that `DateTime` is completely ignored. This is the same principle as passing a `DateTime` to
+  `Date.to_iso8601/2`. `Date.to_iso8601/2` extracts only the date-specific fields (calendar, year,
+  month and day) of the given structure and ignores all others.
+
+  This way if you have a `DateTime` in one time zone, you can get the same wall time in another time zone.
+  For instance if you have 2018-08-24 10:00:00 in Copenhagen and want a `DateTime` for 2018-08-24 10:00:00
+  in UTC you can do:
+
+      iex> cph_datetime = DateTime.from_naive!(~N[2018-08-24 10:00:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> {:ok, utc_datetime} = DateTime.from_naive(cph_datetime, "Etc/UTC", FakeTimeZoneDatabase)
+      iex> utc_datetime
+      ~U[2018-08-24 10:00:00Z]
+
+  If instead you want a `DateTime` for the same point time in a different time zone see the
+  `DateTime.shift_zone/3` function which would convert 2018-08-24 10:00:00 in Copenhagen
+  to 2018-08-24 08:00:00 in UTC.
+  """
+  @doc since: "1.4.0"
+  @spec from_naive(
+          Calendar.naive_datetime(),
+          Calendar.time_zone(),
+          Calendar.time_zone_database()
+        ) ::
+          {:ok, t}
+          | {:ambiguous, first_datetime :: t, second_datetime :: t}
+          | {:gap, t, t}
+          | {:error,
+             :incompatible_calendars | :time_zone_not_found | :utc_only_time_zone_database}
+
+  def from_naive(
+        naive_datetime,
+        time_zone,
+        time_zone_database \\ Calendar.get_time_zone_database()
+      )
+
+  def from_naive(naive_datetime, "Etc/UTC", _) do
+    utc_period = %{std_offset: 0, utc_offset: 0, zone_abbr: "UTC"}
+    {:ok, from_naive_with_period(naive_datetime, "Etc/UTC", utc_period)}
+  end
+
+  def from_naive(%{calendar: Calendar.ISO} = naive_datetime, time_zone, time_zone_database) do
+    case time_zone_database.time_zone_periods_from_wall_datetime(naive_datetime, time_zone) do
+      {:ok, period} ->
+        {:ok, from_naive_with_period(naive_datetime, time_zone, period)}
+
+      {:ambiguous, first_period, second_period} ->
+        first_datetime = from_naive_with_period(naive_datetime, time_zone, first_period)
+        second_datetime = from_naive_with_period(naive_datetime, time_zone, second_period)
+        {:ambiguous, first_datetime, second_datetime}
+
+      {:gap, {first_period, first_period_until_wall}, {second_period, second_period_from_wall}} ->
+        # `until_wall` is not valid, but any time just before is.
+        # So by subtracting a second and adding .999999 seconds
+        # we get the last microsecond just before.
+        before_naive =
+          first_period_until_wall
+          |> Map.replace!(:microsecond, {999_999, 6})
+          |> NaiveDateTime.add(-1)
+
+        after_naive = second_period_from_wall
+
+        latest_datetime_before = from_naive_with_period(before_naive, time_zone, first_period)
+        first_datetime_after = from_naive_with_period(after_naive, time_zone, second_period)
+        {:gap, latest_datetime_before, first_datetime_after}
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  def from_naive(%{calendar: calendar} = naive_datetime, time_zone, time_zone_database)
+      when calendar != Calendar.ISO do
+    # For non-ISO calendars, convert to ISO, create ISO DateTime, and then
+    # convert to original calendar
+    iso_result =
+      with {:ok, in_iso} <- NaiveDateTime.convert(naive_datetime, Calendar.ISO) do
+        from_naive(in_iso, time_zone, time_zone_database)
+      end
+
+    case iso_result do
+      {:ok, dt} ->
+        convert(dt, calendar)
+
+      {:ambiguous, dt1, dt2} ->
+        with {:ok, dt1converted} <- convert(dt1, calendar),
+             {:ok, dt2converted} <- convert(dt2, calendar),
+             do: {:ambiguous, dt1converted, dt2converted}
+
+      {:gap, dt1, dt2} ->
+        with {:ok, dt1converted} <- convert(dt1, calendar),
+             {:ok, dt2converted} <- convert(dt2, calendar),
+             do: {:gap, dt1converted, dt2converted}
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  defp from_naive_with_period(naive_datetime, time_zone, period) do
+    %{std_offset: std_offset, utc_offset: utc_offset, zone_abbr: zone_abbr} = period
+
+    %{
+      calendar: calendar,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      year: year,
+      month: month,
+      day: day
+    } = naive_datetime
+
+    %DateTime{
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      std_offset: std_offset,
+      utc_offset: utc_offset,
+      zone_abbr: zone_abbr,
+      time_zone: time_zone
+    }
+  end
+
+  @doc """
+  Converts the given `NaiveDateTime` to `DateTime`.
+
+  It expects a time zone to put the NaiveDateTime in.
+  If the time zone is "Etc/UTC", it always succeeds. Otherwise,
+  the NaiveDateTime is checked against the time zone database
+  given as `time_zone_database`. See the "Time zone database"
+  section in the module documentation.
+
+  ## Examples
+
+      iex> DateTime.from_naive!(~N[2016-05-24 13:26:08.003], "Etc/UTC")
+      ~U[2016-05-24 13:26:08.003Z]
+
+      iex> DateTime.from_naive!(~N[2018-05-24 13:26:08.003], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      #DateTime<2018-05-24 13:26:08.003+02:00 CEST Europe/Copenhagen>
+
+  """
+  @doc since: "1.4.0"
+  @spec from_naive!(
+          NaiveDateTime.t(),
+          Calendar.time_zone(),
+          Calendar.time_zone_database()
+        ) :: t
+  def from_naive!(
+        naive_datetime,
+        time_zone,
+        time_zone_database \\ Calendar.get_time_zone_database()
+      ) do
+    case from_naive(naive_datetime, time_zone, time_zone_database) do
+      {:ok, datetime} ->
+        datetime
+
+      {:ambiguous, dt1, dt2} ->
+        raise ArgumentError,
+              "cannot convert #{inspect(naive_datetime)} to datetime because such " <>
+                "instant is ambiguous in time zone #{time_zone} as there is an overlap " <>
+                "between #{inspect(dt1)} and #{inspect(dt2)}"
+
+      {:gap, dt1, dt2} ->
+        raise ArgumentError,
+              "cannot convert #{inspect(naive_datetime)} to datetime because such " <>
+                "instant does not exist in time zone #{time_zone} as there is a gap " <>
+                "between #{inspect(dt1)} and #{inspect(dt2)}"
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "cannot convert #{inspect(naive_datetime)} to datetime, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Changes the time zone of a `DateTime`.
+
+  Returns a `DateTime` for the same point in time, but instead at
+  the time zone provided. It assumes that `DateTime` is valid and
+  exists in the given time zone and calendar.
+
+  By default, it uses the default time zone database returned by
+  `Calendar.get_time_zone_database/0`, which defaults to
+  `Calendar.UTCOnlyTimeZoneDatabase` which only handles "Etc/UTC" datetimes.
+  Other time zone databases can be passed as argument or set globally.
+  See the "Time zone database" section in the module docs.
+
+  ## Examples
+
+      iex> {:ok, pacific_datetime} = DateTime.shift_zone(~U[2018-07-16 10:00:00Z], "America/Los_Angeles", FakeTimeZoneDatabase)
+      iex> pacific_datetime
+      #DateTime<2018-07-16 03:00:00-07:00 PDT America/Los_Angeles>
+
+      iex> DateTime.shift_zone(~U[2018-07-16 10:00:00Z], "bad timezone", FakeTimeZoneDatabase)
+      {:error, :time_zone_not_found}
+
+  """
+  @doc since: "1.8.0"
+  @spec shift_zone(t, Calendar.time_zone(), Calendar.time_zone_database()) ::
+          {:ok, t} | {:error, :time_zone_not_found | :utc_only_time_zone_database}
+  def shift_zone(datetime, time_zone, time_zone_database \\ Calendar.get_time_zone_database())
+
+  def shift_zone(%{time_zone: time_zone} = datetime, time_zone, _) do
+    {:ok, datetime}
+  end
+
+  def shift_zone(datetime, time_zone, time_zone_database) do
+    %{
+      std_offset: std_offset,
+      utc_offset: utc_offset,
+      calendar: calendar,
+      microsecond: {_, precision}
+    } = datetime
+
+    datetime
+    |> to_iso_days()
+    |> apply_tz_offset(utc_offset + std_offset)
+    |> shift_zone_for_iso_days_utc(calendar, precision, time_zone, time_zone_database)
+  end
+
+  defp shift_zone_for_iso_days_utc(iso_days_utc, calendar, precision, time_zone, time_zone_db) do
+    case time_zone_db.time_zone_period_from_utc_iso_days(iso_days_utc, time_zone) do
+      {:ok, %{std_offset: std_offset, utc_offset: utc_offset, zone_abbr: zone_abbr}} ->
+        {year, month, day, hour, minute, second, {microsecond_without_precision, _}} =
+          iso_days_utc
+          |> apply_tz_offset(-(utc_offset + std_offset))
+          |> calendar.naive_datetime_from_iso_days()
+
+        datetime = %DateTime{
+          calendar: calendar,
+          year: year,
+          month: month,
+          day: day,
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: {microsecond_without_precision, precision},
+          std_offset: std_offset,
+          utc_offset: utc_offset,
+          zone_abbr: zone_abbr,
+          time_zone: time_zone
+        }
+
+        {:ok, datetime}
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  @doc """
+  Changes the time zone of a `DateTime` or raises on errors.
+
+  See `shift_zone/3` for more information.
+
+  ## Examples
+
+      iex> DateTime.shift_zone!(~U[2018-07-16 10:00:00Z], "America/Los_Angeles", FakeTimeZoneDatabase)
+      #DateTime<2018-07-16 03:00:00-07:00 PDT America/Los_Angeles>
+
+      iex> DateTime.shift_zone!(~U[2018-07-16 10:00:00Z], "bad timezone", FakeTimeZoneDatabase)
+      ** (ArgumentError) cannot shift ~U[2018-07-16 10:00:00Z] to "bad timezone" time zone, reason: :time_zone_not_found
+
+  """
+  @doc since: "1.10.0"
+  @spec shift_zone!(t, Calendar.time_zone(), Calendar.time_zone_database()) :: t
+  def shift_zone!(datetime, time_zone, time_zone_database \\ Calendar.get_time_zone_database()) do
+    case shift_zone(datetime, time_zone, time_zone_database) do
+      {:ok, datetime} ->
+        datetime
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "cannot shift #{inspect(datetime)} to #{inspect(time_zone)} time zone" <>
+                ", reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Returns the current datetime in the provided time zone.
+
+  By default, it uses the default time_zone returned by
+  `Calendar.get_time_zone_database/0`, which defaults to
+  `Calendar.UTCOnlyTimeZoneDatabase` which only handles "Etc/UTC" datetimes.
+  Other time zone databases can be passed as argument or set globally.
+  See the "Time zone database" section in the module docs.
+
+  ## Examples
+
+      iex> {:ok, datetime} = DateTime.now("Etc/UTC")
+      iex> datetime.time_zone
+      "Etc/UTC"
+
+      iex> DateTime.now("Europe/Copenhagen")
+      {:error, :utc_only_time_zone_database}
+
+      iex> DateTime.now("bad timezone", FakeTimeZoneDatabase)
+      {:error, :time_zone_not_found}
+
+  """
+  @doc since: "1.8.0"
+  @spec now(Calendar.time_zone(), Calendar.time_zone_database()) ::
+          {:ok, t} | {:error, :time_zone_not_found | :utc_only_time_zone_database}
+  def now(time_zone, time_zone_database \\ Calendar.get_time_zone_database())
+
+  def now("Etc/UTC", _) do
+    {:ok, utc_now()}
+  end
+
+  def now(time_zone, time_zone_database) do
+    shift_zone(utc_now(), time_zone, time_zone_database)
+  end
+
+  @doc """
+  Returns the current datetime in the provided time zone or raises on errors
+
+  See `now/2` for more information.
+
+  ## Examples
+
+      iex> datetime = DateTime.now!("Etc/UTC")
+      iex> datetime.time_zone
+      "Etc/UTC"
+
+      iex> DateTime.now!("Europe/Copenhagen")
+      ** (ArgumentError) cannot get current datetime in "Europe/Copenhagen" time zone, reason: :utc_only_time_zone_database
+
+      iex> DateTime.now!("bad timezone", FakeTimeZoneDatabase)
+      ** (ArgumentError) cannot get current datetime in "bad timezone" time zone, reason: :time_zone_not_found
+
+  """
+  @doc since: "1.10.0"
+  @spec now!(Calendar.time_zone(), Calendar.time_zone_database()) :: t
+  def now!(time_zone, time_zone_database \\ Calendar.get_time_zone_database()) do
+    case now(time_zone, time_zone_database) do
+      {:ok, datetime} ->
+        datetime
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "cannot get current datetime in #{inspect(time_zone)} time zone, reason: " <>
+                inspect(reason)
+    end
+  end
+
+  @doc """
+  Converts the given `datetime` to Unix time.
+
+  The `datetime` is expected to be using the ISO calendar
+  with a year greater than or equal to 0.
+
+  It will return the integer with the given unit, according
+  to `System.convert_time_unit/3`. If the given unit is different
+  than microseconds, the returned value will be either truncated
+  or padded accordingly.
+
+  ## Examples
+
+      iex> 1_464_096_368 |> DateTime.from_unix!() |> DateTime.to_unix()
+      1464096368
+
+      iex> dt = %DateTime{calendar: Calendar.ISO, day: 20, hour: 18, microsecond: {273806, 6},
+      ...>                minute: 58, month: 11, second: 19, time_zone: "America/Montevideo",
+      ...>                utc_offset: -10800, std_offset: 3600, year: 2014, zone_abbr: "UYST"}
+      iex> DateTime.to_unix(dt)
+      1416517099
+
+      iex> flamel = %DateTime{calendar: Calendar.ISO, day: 22, hour: 8, microsecond: {527771, 6},
+      ...>                minute: 2, month: 3, second: 25, std_offset: 0, time_zone: "Etc/UTC",
+      ...>                utc_offset: 0, year: 1418, zone_abbr: "UTC"}
+      iex> DateTime.to_unix(flamel)
+      -17412508655
+
+  """
+  @spec to_unix(Calendar.datetime(), :native | System.time_unit()) :: integer
+  def to_unix(datetime, unit \\ :second)
+
+  def to_unix(%{utc_offset: utc_offset, std_offset: std_offset} = datetime, unit) do
+    {days, fraction} = to_iso_days(datetime)
+    unix_units = Calendar.ISO.iso_days_to_unit({days - @unix_days, fraction}, unit)
+    offset_units = System.convert_time_unit(utc_offset + std_offset, :second, unit)
+    unix_units - offset_units
+  end
+
+  @doc """
+  Converts the given `datetime` into a `NaiveDateTime`.
+
+  Because `NaiveDateTime` does not hold time zone information,
+  any time zone related data will be lost during the conversion.
+
+  ## Examples
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 1},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> DateTime.to_naive(dt)
+      ~N[2000-02-29 23:00:07.0]
+
+  """
+  @spec to_naive(Calendar.datetime()) :: NaiveDateTime.t()
+  def to_naive(datetime)
+
+  def to_naive(%{
+        calendar: calendar,
+        year: year,
+        month: month,
+        day: day,
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond,
+        time_zone: _
+      }) do
+    %NaiveDateTime{
+      year: year,
+      month: month,
+      day: day,
+      calendar: calendar,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    }
+  end
+
+  @doc """
+  Converts a `DateTime` into a `Date`.
+
+  Because `Date` does not hold time nor time zone information,
+  data will be lost during the conversion.
+
+  ## Examples
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> DateTime.to_date(dt)
+      ~D[2000-02-29]
+
+  """
+  @spec to_date(Calendar.datetime()) :: Date.t()
+  def to_date(datetime)
+
+  def to_date(%{
+        year: year,
+        month: month,
+        day: day,
+        calendar: calendar,
+        hour: _,
+        minute: _,
+        second: _,
+        microsecond: _,
+        time_zone: _
+      }) do
+    %Date{year: year, month: month, day: day, calendar: calendar}
+  end
+
+  @doc """
+  Converts a `DateTime` into `Time`.
+
+  Because `Time` does not hold date nor time zone information,
+  data will be lost during the conversion.
+
+  ## Examples
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 1},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> DateTime.to_time(dt)
+      ~T[23:00:07.0]
+
+  """
+  @spec to_time(Calendar.datetime()) :: Time.t()
+  def to_time(datetime)
+
+  def to_time(%{
+        year: _,
+        month: _,
+        day: _,
+        calendar: calendar,
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond,
+        time_zone: _
+      }) do
+    %Time{
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      calendar: calendar
+    }
+  end
+
+  @doc """
+  Converts the given datetime to
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601) format.
+
+  By default, `DateTime.to_iso8601/2` returns datetimes formatted in the "extended"
+  format, for human readability. It also supports the "basic" format through passing the `:basic` option.
+
+  You can also optionally specify an offset for the formatted string.
+  If none is given, the one in the given `datetime` is used.
+
+  Only supports converting datetimes which are in the ISO calendar.
+  If another calendar is given, it is automatically converted to ISO.
+  It raises if not possible.
+
+  WARNING: the ISO 8601 datetime format does not contain the time zone nor
+  its abbreviation, which means information is lost when converting to such
+  format.
+
+  ## Examples
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> DateTime.to_iso8601(dt)
+      "2000-02-29T23:00:07+01:00"
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "UTC",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 0, std_offset: 0, time_zone: "Etc/UTC"}
+      iex> DateTime.to_iso8601(dt)
+      "2000-02-29T23:00:07Z"
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
+      iex> DateTime.to_iso8601(dt, :extended)
+      "2000-02-29T23:00:07-04:00"
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
+      iex> DateTime.to_iso8601(dt, :basic)
+      "20000229T230007-0400"
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
+      iex> DateTime.to_iso8601(dt, :extended, 3600)
+      "2000-03-01T04:00:07+01:00"
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
+      iex> DateTime.to_iso8601(dt, :extended, 0)
+      "2000-03-01T03:00:07+00:00"
+
+      iex> dt = %DateTime{year: 2000, month: 3, day: 01, zone_abbr: "UTC",
+      ...>                hour: 03, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 0, std_offset: 0, time_zone: "Etc/UTC"}
+      iex> DateTime.to_iso8601(dt, :extended, 0)
+      "2000-03-01T03:00:07Z"
+
+      iex> {:ok, dt, offset} = DateTime.from_iso8601("2000-03-01T03:00:07Z")
+      iex> "2000-03-01T03:00:07Z" = DateTime.to_iso8601(dt, :extended, offset)
+  """
+  @spec to_iso8601(Calendar.datetime(), :basic | :extended, nil | integer()) :: String.t()
+  def to_iso8601(datetime, format \\ :extended, offset \\ nil)
+
+  def to_iso8601(%{calendar: Calendar.ISO} = datetime, format, offset)
+      when format in [:extended, :basic] do
+    datetime
+    |> to_iso8601_iodata(format, offset)
+    |> IO.iodata_to_binary()
+  end
+
+  def to_iso8601(%{calendar: _} = datetime, format, offset)
+      when format in [:extended, :basic] do
+    datetime
+    |> convert!(Calendar.ISO)
+    |> to_iso8601(format, offset)
+  end
+
+  defp to_iso8601_iodata(datetime, format, nil) do
+    %{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      time_zone: time_zone,
+      utc_offset: utc_offset,
+      std_offset: std_offset
+    } = datetime
+
+    [
+      datetime_to_iodata(year, month, day, hour, minute, second, microsecond, format),
+      Calendar.ISO.offset_to_iodata(utc_offset, std_offset, time_zone, format)
+    ]
+  end
+
+  defp to_iso8601_iodata(
+         %{microsecond: {_, precision}, time_zone: "Etc/UTC"} = datetime,
+         format,
+         0
+       ) do
+    {year, month, day, hour, minute, second, {microsecond, _}} = shift_by_offset(datetime, 0)
+
+    [
+      datetime_to_iodata(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        {microsecond, precision},
+        format
+      ),
+      ?Z
+    ]
+  end
+
+  defp to_iso8601_iodata(datetime, format, offset) do
+    {_, precision} = datetime.microsecond
+    {year, month, day, hour, minute, second, {microsecond, _}} = shift_by_offset(datetime, offset)
+
+    [
+      datetime_to_iodata(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        {microsecond, precision},
+        format
+      ),
+      Calendar.ISO.offset_to_iodata(offset, 0, nil, format)
+    ]
+  end
+
+  defp shift_by_offset(%{calendar: calendar} = datetime, offset) do
+    total_offset = datetime.utc_offset + datetime.std_offset
+
+    datetime
+    |> to_iso_days()
+    # Subtract total original offset in order to get UTC and add the new offset
+    |> Calendar.ISO.add_day_fraction_to_iso_days(offset - total_offset, 86400)
+    |> calendar.naive_datetime_from_iso_days()
+  end
+
+  defp datetime_to_iodata(year, month, day, hour, minute, second, microsecond, format) do
+    [
+      Calendar.ISO.date_to_iodata(year, month, day, format),
+      ?T,
+      Calendar.ISO.time_to_iodata(hour, minute, second, microsecond, format)
+    ]
+  end
+
+  @doc """
+  Parses the extended "Date and time of day" format described by
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+
+  Since ISO 8601 does not include the proper time zone, the given
+  string will be converted to UTC and its offset in seconds will be
+  returned as part of this function. Therefore offset information
+  must be present in the string.
+
+  As specified in the standard, the separator "T" may be omitted if
+  desired as there is no ambiguity within this function.
+
+  Note leap seconds are not supported by the built-in Calendar.ISO.
+
+  ## Examples
+
+      iex> {:ok, datetime, 0} = DateTime.from_iso8601("2015-01-23T23:50:07Z")
+      iex> datetime
+      ~U[2015-01-23 23:50:07Z]
+
+      iex> {:ok, datetime, 9000} = DateTime.from_iso8601("2015-01-23T23:50:07.123+02:30")
+      iex> datetime
+      ~U[2015-01-23 21:20:07.123Z]
+
+      iex> {:ok, datetime, 9000} = DateTime.from_iso8601("2015-01-23T23:50:07,123+02:30")
+      iex> datetime
+      ~U[2015-01-23 21:20:07.123Z]
+
+      iex> {:ok, datetime, 0} = DateTime.from_iso8601("-2015-01-23T23:50:07Z")
+      iex> datetime
+      ~U[-2015-01-23 23:50:07Z]
+
+      iex> {:ok, datetime, 9000} = DateTime.from_iso8601("-2015-01-23T23:50:07,123+02:30")
+      iex> datetime
+      ~U[-2015-01-23 21:20:07.123Z]
+
+      iex> {:ok, datetime, 9000} = DateTime.from_iso8601("20150123T235007.123+0230", :basic)
+      iex> datetime
+      ~U[2015-01-23 21:20:07.123Z]
+
+      iex> DateTime.from_iso8601("2015-01-23P23:50:07")
+      {:error, :invalid_format}
+      iex> DateTime.from_iso8601("2015-01-23T23:50:07")
+      {:error, :missing_offset}
+      iex> DateTime.from_iso8601("2015-01-23 23:50:61")
+      {:error, :invalid_time}
+      iex> DateTime.from_iso8601("2015-01-32 23:50:07")
+      {:error, :invalid_date}
+      iex> DateTime.from_iso8601("2015-01-23T23:50:07.123-00:00")
+      {:error, :invalid_format}
+
+  """
+  @doc since: "1.4.0"
+  @spec from_iso8601(String.t(), Calendar.calendar() | :extended | :basic) ::
+          {:ok, t, Calendar.utc_offset()} | {:error, atom}
+  def from_iso8601(string, format_or_calendar \\ Calendar.ISO)
+
+  def from_iso8601(string, format) when format in [:basic, :extended] do
+    from_iso8601(string, Calendar.ISO, format)
+  end
+
+  def from_iso8601(string, calendar) when is_atom(calendar) do
+    from_iso8601(string, calendar, :extended)
+  end
+
+  @doc """
+  Converts from ISO8601 specifying both a calendar and a mode.
+
+  See `from_iso8601/2` for more information.
+
+  ## Examples
+
+      iex> {:ok, datetime, 9000} = DateTime.from_iso8601("2015-01-23T23:50:07,123+02:30", Calendar.ISO, :extended)
+      iex> datetime
+      ~U[2015-01-23 21:20:07.123Z]
+
+      iex> {:ok, datetime, 9000} = DateTime.from_iso8601("20150123T235007.123+0230", Calendar.ISO, :basic)
+      iex> datetime
+      ~U[2015-01-23 21:20:07.123Z]
+
+  """
+  @spec from_iso8601(String.t(), Calendar.calendar(), :extended | :basic) ::
+          {:ok, t, Calendar.utc_offset()} | {:error, atom}
+  def from_iso8601(string, calendar, format) do
+    with {:ok, {year, month, day, hour, minute, second, microsecond}, offset} <-
+           Calendar.ISO.parse_utc_datetime(string, format) do
+      datetime = %DateTime{
+        year: year,
+        month: month,
+        day: day,
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond,
+        std_offset: 0,
+        utc_offset: 0,
+        zone_abbr: "UTC",
+        time_zone: "Etc/UTC"
+      }
+
+      with {:ok, converted} <- convert(datetime, calendar) do
+        {:ok, converted, offset}
+      end
+    end
+  end
+
+  @doc """
+  Converts a number of gregorian seconds to a `DateTime` struct.
+
+  The returned `DateTime` will have `UTC` timezone, if you want other timezone, please use
+  `DateTime.shift_zone/3`.
+
+  ## Examples
+
+      iex> DateTime.from_gregorian_seconds(1)
+      ~U[0000-01-01 00:00:01Z]
+      iex> DateTime.from_gregorian_seconds(63_755_511_991, {5000, 3})
+      ~U[2020-05-01 00:26:31.005Z]
+      iex> DateTime.from_gregorian_seconds(-1)
+      ~U[-0001-12-31 23:59:59Z]
+
+  """
+  @doc since: "1.11.0"
+  @spec from_gregorian_seconds(integer(), Calendar.microsecond(), Calendar.calendar()) :: t
+  def from_gregorian_seconds(
+        seconds,
+        {microsecond, precision} \\ {0, 0},
+        calendar \\ Calendar.ISO
+      )
+      when is_integer(seconds) do
+    iso_days = Calendar.ISO.gregorian_seconds_to_iso_days(seconds, microsecond)
+
+    {year, month, day, hour, minute, second, {microsecond, _}} =
+      calendar.naive_datetime_from_iso_days(iso_days)
+
+    %DateTime{
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: {microsecond, precision},
+      std_offset: 0,
+      utc_offset: 0,
+      zone_abbr: "UTC",
+      time_zone: "Etc/UTC"
+    }
+  end
+
+  @doc """
+  Converts a `DateTime` struct to a number of gregorian seconds and microseconds.
+
+  ## Examples
+
+      iex> dt = %DateTime{year: 0000, month: 1, day: 1, zone_abbr: "UTC",
+      ...>                hour: 0, minute: 0, second: 1, microsecond: {0, 0},
+      ...>                utc_offset: 0, std_offset: 0, time_zone: "Etc/UTC"}
+      iex> DateTime.to_gregorian_seconds(dt)
+      {1, 0}
+
+      iex> dt = %DateTime{year: 2020, month: 5, day: 1, zone_abbr: "UTC",
+      ...>                hour: 0, minute: 26, second: 31, microsecond: {5000, 0},
+      ...>                utc_offset: 0, std_offset: 0, time_zone: "Etc/UTC"}
+      iex> DateTime.to_gregorian_seconds(dt)
+      {63_755_511_991, 5000}
+
+      iex> dt = %DateTime{year: 2020, month: 5, day: 1, zone_abbr: "CET",
+      ...>                hour: 1, minute: 26, second: 31, microsecond: {5000, 0},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> DateTime.to_gregorian_seconds(dt)
+      {63_755_511_991, 5000}
+
+  """
+  @doc since: "1.11.0"
+  @spec to_gregorian_seconds(Calendar.datetime()) :: {integer(), non_neg_integer()}
+  def to_gregorian_seconds(
+        %{
+          std_offset: std_offset,
+          utc_offset: utc_offset,
+          microsecond: {microsecond, _}
+        } = datetime
+      ) do
+    {days, day_fraction} =
+      datetime
+      |> to_iso_days()
+      |> apply_tz_offset(utc_offset + std_offset)
+
+    seconds_in_day = seconds_from_day_fraction(day_fraction)
+    {days * @seconds_per_day + seconds_in_day, microsecond}
+  end
+
+  @doc """
+  Converts the given `datetime` to a string according to its calendar.
+
+  Unfortunately, there is no standard that specifies rendering of a
+  datetime with its complete time zone information, so Elixir uses a
+  custom (but relatively common) representation which appends the time
+  zone abbreviation and full name to the datetime.
+
+  ## Examples
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> DateTime.to_string(dt)
+      "2000-02-29 23:00:07+01:00 CET Europe/Warsaw"
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "UTC",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 0, std_offset: 0, time_zone: "Etc/UTC"}
+      iex> DateTime.to_string(dt)
+      "2000-02-29 23:00:07Z"
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
+      iex> DateTime.to_string(dt)
+      "2000-02-29 23:00:07-04:00 AMT America/Manaus"
+
+      iex> dt = %DateTime{year: -100, month: 12, day: 19, zone_abbr: "CET",
+      ...>                hour: 3, minute: 20, second: 31, microsecond: {0, 0},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Stockholm"}
+      iex> DateTime.to_string(dt)
+      "-0100-12-19 03:20:31+01:00 CET Europe/Stockholm"
+
+  """
+  @spec to_string(Calendar.datetime()) :: String.t()
+  def to_string(%{calendar: calendar} = datetime) do
+    %{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      time_zone: time_zone,
+      zone_abbr: zone_abbr,
+      utc_offset: utc_offset,
+      std_offset: std_offset
+    } = datetime
+
+    calendar.datetime_to_string(
+      year,
+      month,
+      day,
+      hour,
+      minute,
+      second,
+      microsecond,
+      time_zone,
+      zone_abbr,
+      utc_offset,
+      std_offset
+    )
+  end
+
+  @doc """
+  Compares two datetime structs.
+
+  Returns `:gt` if the first datetime is later than the second
+  and `:lt` for vice versa. If the two datetimes are equal
+  `:eq` is returned.
+
+  Note that both UTC and Standard offsets will be taken into
+  account when comparison is done.
+
+  ## Examples
+
+      iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
+      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
+      iex> dt2 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> DateTime.compare(dt1, dt2)
+      :gt
+
+  """
+  @doc since: "1.4.0"
+  @spec compare(Calendar.datetime(), Calendar.datetime()) :: :lt | :eq | :gt
+  def compare(
+        %{utc_offset: utc_offset1, std_offset: std_offset1} = datetime1,
+        %{utc_offset: utc_offset2, std_offset: std_offset2} = datetime2
+      ) do
+    {days1, {parts1, ppd1}} =
+      datetime1
+      |> to_iso_days()
+      |> apply_tz_offset(utc_offset1 + std_offset1)
+
+    {days2, {parts2, ppd2}} =
+      datetime2
+      |> to_iso_days()
+      |> apply_tz_offset(utc_offset2 + std_offset2)
+
+    # Ensure fraction tuples have same denominator.
+    first = {days1, parts1 * ppd2}
+    second = {days2, parts2 * ppd1}
+
+    cond do
+      first > second -> :gt
+      first < second -> :lt
+      true -> :eq
+    end
+  end
+
+  @doc """
+  Returns `true` if the first datetime is strictly earlier than the second.
+
+  ## Examples
+
+      iex> DateTime.before?(~U[2021-01-01 11:00:00Z], ~U[2022-02-02 11:00:00Z])
+      true
+      iex> DateTime.before?(~U[2021-01-01 11:00:00Z], ~U[2021-01-01 11:00:00Z])
+      false
+      iex> DateTime.before?(~U[2022-02-02 11:00:00Z], ~U[2021-01-01 11:00:00Z])
+      false
+
+  """
+  @doc since: "1.15.0"
+  @spec before?(Calendar.datetime(), Calendar.datetime()) :: boolean()
+  def before?(datetime1, datetime2) do
+    compare(datetime1, datetime2) == :lt
+  end
+
+  @doc """
+  Returns `true` if the first datetime is strictly later than the second.
+
+  ## Examples
+
+      iex> DateTime.after?(~U[2022-02-02 11:00:00Z], ~U[2021-01-01 11:00:00Z])
+      true
+      iex> DateTime.after?(~U[2021-01-01 11:00:00Z], ~U[2021-01-01 11:00:00Z])
+      false
+      iex> DateTime.after?(~U[2021-01-01 11:00:00Z], ~U[2022-02-02 11:00:00Z])
+      false
+
+  """
+  @doc since: "1.15.0"
+  @spec after?(Calendar.datetime(), Calendar.datetime()) :: boolean()
+  def after?(datetime1, datetime2) do
+    compare(datetime1, datetime2) == :gt
+  end
+
+  @doc """
+  Subtracts `datetime2` from `datetime1`.
+
+  The answer can be returned in any `:day`, `:hour`, `:minute`, or any `unit`
+  available from `t:System.time_unit/0`. The unit is measured according to
+  `Calendar.ISO` and defaults to `:second`.
+
+  Fractional results are not supported and are truncated.
+
+  ## Examples
+
+      iex> DateTime.diff(~U[2024-01-15 10:00:10Z], ~U[2024-01-15 10:00:00Z])
+      10
+
+  This function also considers timezone offsets:
+
+      iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
+      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
+      iex> dt2 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> DateTime.diff(dt1, dt2)
+      18000
+      iex> DateTime.diff(dt2, dt1)
+      -18000
+      iex> DateTime.diff(dt1, dt2, :hour)
+      5
+      iex> DateTime.diff(dt2, dt1, :hour)
+      -5
+
+  """
+  @doc since: "1.5.0"
+  @spec diff(
+          Calendar.datetime(),
+          Calendar.datetime(),
+          :day | :hour | :minute | System.time_unit()
+        ) :: integer()
+  def diff(datetime1, datetime2, unit \\ :second)
+
+  def diff(datetime1, datetime2, :day) do
+    diff(datetime1, datetime2, :second) |> div(86400)
+  end
+
+  def diff(datetime1, datetime2, :hour) do
+    diff(datetime1, datetime2, :second) |> div(3600)
+  end
+
+  def diff(datetime1, datetime2, :minute) do
+    diff(datetime1, datetime2, :second) |> div(60)
+  end
+
+  def diff(
+        %{utc_offset: utc_offset1, std_offset: std_offset1} = datetime1,
+        %{utc_offset: utc_offset2, std_offset: std_offset2} = datetime2,
+        unit
+      ) do
+    if not is_integer(unit) and
+         unit not in ~w(second millisecond microsecond nanosecond)a do
+      raise ArgumentError,
+            "unsupported time unit. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}"
+    end
+
+    naive_diff =
+      (datetime1 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(:microsecond)) -
+        (datetime2 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(:microsecond))
+
+    offset_diff = utc_offset2 + std_offset2 - (utc_offset1 + std_offset1)
+
+    System.convert_time_unit(naive_diff, :microsecond, unit) +
+      System.convert_time_unit(offset_diff, :second, unit)
+  end
+
+  @doc """
+  Adds a specified amount of time to a `DateTime`.
+
+  > #### Prefer `shift/2` {: .info}
+  >
+  > Prefer `shift/2` over `add/3`, as it offers a more ergonomic API.
+  >
+  > `add/3` provides a lower-level API which only supports fixed units
+  > such as `:hour` and `:second`, but not `:month` (as the exact length
+  > of a month depends on the current month). `add/3` always considers
+  > the unit to be computed according to the `Calendar.ISO`.
+
+  Accepts an `amount_to_add` in any `unit`. `unit` can be `:day`,
+  `:hour`, `:minute`, `:second` or any subsecond precision from
+  `t:System.time_unit/0` for convenience but ultimately they are
+  all converted to microseconds. Negative values will move backwards
+  in time and the default precision is `:second`.
+
+  This function relies on a contiguous representation of time,
+  ignoring timezone changes. For example, if you add one day when there
+  are summer time/daylight saving time changes, it will also change the
+  time forward or backward by one hour, so the elapsed time is precisely
+  24 hours. Similarly, adding just a few seconds to a datetime just before
+  "spring forward" can cause wall time to increase by more than an hour.
+
+  While this means this function is precise in terms of elapsed time,
+  its result may be confusing in certain use cases. For example, if a
+  user requests a meeting to happen every day at 15:00 and you use this
+  function to compute all future meetings by adding day after day, this
+  function may change the meeting time to 14:00 or 16:00 if there are
+  changes to the current timezone.
+
+  In case you don't want these changes to happen automatically or you
+  want to surface time zone conflicts to the user, you can add to
+  the datetime as a naive datetime and then use `from_naive/2`:
+
+      dt |> NaiveDateTime.add(1, :day) |> DateTime.from_naive(dt.time_zone)
+
+  The above will surface time jumps and ambiguous datetimes, allowing you
+  to deal with them accordingly.
+
+  ## Examples
+
+      iex> dt = DateTime.from_naive!(~N[2018-11-15 10:00:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> dt |> DateTime.add(3600, :second, FakeTimeZoneDatabase)
+      #DateTime<2018-11-15 11:00:00+01:00 CET Europe/Copenhagen>
+
+      iex> DateTime.add(~U[2018-11-15 10:00:00Z], 3600, :second)
+      ~U[2018-11-15 11:00:00Z]
+
+  When adding 3 seconds just before "spring forward" we go from 1:59:59 to 3:00:02:
+
+      iex> dt = DateTime.from_naive!(~N[2019-03-31 01:59:59.123], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> dt |> DateTime.add(3, :second, FakeTimeZoneDatabase)
+      #DateTime<2019-03-31 03:00:02.123+02:00 CEST Europe/Copenhagen>
+
+  When adding 1 day during "spring forward", the hour also changes:
+
+      iex> dt = DateTime.from_naive!(~N[2019-03-31 01:00:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      iex> dt |> DateTime.add(1, :day, FakeTimeZoneDatabase)
+      #DateTime<2019-04-01 02:00:00+02:00 CEST Europe/Copenhagen>
+
+  This operation merges the precision of the naive date time with the given unit:
+
+      iex> result = DateTime.add(~U[2014-10-02 00:29:10Z], 21, :millisecond)
+      ~U[2014-10-02 00:29:10.021Z]
+      iex> result.microsecond
+      {21000, 3}
+
+  """
+  @doc since: "1.8.0"
+  @spec add(
+          Calendar.datetime(),
+          integer,
+          :day | :hour | :minute | System.time_unit(),
+          Calendar.time_zone_database()
+        ) ::
+          t()
+  def add(
+        datetime,
+        amount_to_add,
+        unit \\ :second,
+        time_zone_database \\ Calendar.get_time_zone_database()
+      )
+
+  def add(datetime, amount_to_add, :day, time_zone_database) when is_integer(amount_to_add) do
+    add(datetime, amount_to_add * 86400, :second, time_zone_database)
+  end
+
+  def add(datetime, amount_to_add, :hour, time_zone_database) when is_integer(amount_to_add) do
+    add(datetime, amount_to_add * 3600, :second, time_zone_database)
+  end
+
+  def add(datetime, amount_to_add, :minute, time_zone_database) when is_integer(amount_to_add) do
+    add(datetime, amount_to_add * 60, :second, time_zone_database)
+  end
+
+  def add(%{calendar: calendar} = datetime, amount_to_add, unit, time_zone_database)
+      when is_integer(amount_to_add) do
+    %{
+      microsecond: {_, precision},
+      time_zone: time_zone,
+      utc_offset: utc_offset,
+      std_offset: std_offset
+    } = datetime
+
+    if not is_integer(unit) and unit not in ~w(second millisecond microsecond nanosecond)a do
+      raise ArgumentError,
+            "unsupported time unit. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}"
+    end
+
+    precision = max(Calendar.ISO.time_unit_to_precision(unit), precision)
+
+    result =
+      datetime
+      |> to_iso_days()
+      |> Calendar.ISO.shift_time_unit(amount_to_add, unit)
+      |> apply_tz_offset(utc_offset + std_offset)
+      |> shift_zone_for_iso_days_utc(calendar, precision, time_zone, time_zone_database)
+
+    case result do
+      {:ok, result_datetime} ->
+        result_datetime
+
+      {:error, error} ->
+        raise ArgumentError,
+              "cannot add #{amount_to_add} #{unit} to #{inspect(datetime)} (with time zone " <>
+                "database #{inspect(time_zone_database)}), reason: #{inspect(error)}"
+    end
+  end
+
+  @doc """
+  Shifts given `datetime` by `duration` according to its calendar.
+
+  Allowed units are: `:year`, `:month`, `:week`, `:day`, `:hour`, `:minute`, `:second`, `:microsecond`.
+
+  This operation is equivalent to shifting the datetime wall clock
+  (in other words, the value as someone in that timezone would see
+  on their watch), then applying the time zone offset to convert it
+  to UTC, and finally computing the new timezone in case of shifts.
+  This ensures `shift/3` always returns a valid datetime.
+
+  Consequently, time zones that observe "Daylight Saving Time"
+  or other changes, across summer/winter time will add/remove hours
+  from the resulting datetime:
+
+      dt = DateTime.new!(~D[2019-03-31], ~T[01:00:00], "Europe/Copenhagen")
+      DateTime.shift(dt, hour: 1)
+      #=> #DateTime<2019-03-31 03:00:00+02:00 CEST Europe/Copenhagen>
+
+      dt = DateTime.new!(~D[2018-11-04], ~T[00:00:00], "America/Los_Angeles")
+      DateTime.shift(dt, hour: 2)
+      #=> #DateTime<2018-11-04 01:00:00-08:00 PST America/Los_Angeles>
+
+  Although the first example shows a difference of 2 hours when
+  comparing the wall clocks of the given datetime with the returned one,
+  due to the "spring forward" time jump, the actual elapsed time is
+  still exactly of 1 hour.
+
+  In case you don't want these changes to happen automatically or you
+  want to surface time zone conflicts to the user, you can shift
+  the datetime as a naive datetime and then use `from_naive/2`:
+
+      dt |> NaiveDateTime.shift(duration) |> DateTime.from_naive(dt.time_zone)
+
+  The above will surface time jumps and ambiguous datetimes, allowing you
+  to deal with them accordingly.
+
+  ## ISO calendar considerations
+
+  When using the default ISO calendar, durations are collapsed and
+  applied in the order of months, then seconds and microseconds:
+
+  * when shifting by 1 year and 2 months the date is actually shifted by 14 months
+  * weeks, days and smaller units are collapsed into seconds and microseconds
+
+  When shifting by month, days are rounded down to the nearest valid date.
+
+  ## Examples
+
+      iex> DateTime.shift(~U[2016-01-01 00:00:00Z], month: 2)
+      ~U[2016-03-01 00:00:00Z]
+      iex> DateTime.shift(~U[2016-01-01 00:00:00Z], year: 1, week: 4)
+      ~U[2017-01-29 00:00:00Z]
+      iex> DateTime.shift(~U[2016-01-01 00:00:00Z], minute: -25)
+      ~U[2015-12-31 23:35:00Z]
+      iex> DateTime.shift(~U[2016-01-01 00:00:00Z], minute: 5, microsecond: {500, 4})
+      ~U[2016-01-01 00:05:00.0005Z]
+
+      # leap years
+      iex> DateTime.shift(~U[2024-02-29 00:00:00Z], year: 1)
+      ~U[2025-02-28 00:00:00Z]
+      iex> DateTime.shift(~U[2024-02-29 00:00:00Z], year: 4)
+      ~U[2028-02-29 00:00:00Z]
+
+      # rounding down
+      iex> DateTime.shift(~U[2015-01-31 00:00:00Z], month: 1)
+      ~U[2015-02-28 00:00:00Z]
+
+  """
+  @doc since: "1.17.0"
+  @spec shift(Calendar.datetime(), Duration.duration(), Calendar.time_zone_database()) :: t
+  def shift(datetime, duration, time_zone_database \\ Calendar.get_time_zone_database())
+
+  def shift(%{calendar: calendar, time_zone: "Etc/UTC"} = datetime, duration, _time_zone_database) do
+    %{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    } = datetime
+
+    {year, month, day, hour, minute, second, microsecond} =
+      calendar.shift_naive_datetime(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        __duration__!(duration)
+      )
+
+    %DateTime{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      time_zone: "Etc/UTC",
+      zone_abbr: "UTC",
+      std_offset: 0,
+      utc_offset: 0
+    }
+  end
+
+  def shift(%{calendar: calendar} = datetime, duration, time_zone_database) do
+    %{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      std_offset: std_offset,
+      utc_offset: utc_offset,
+      time_zone: time_zone
+    } = datetime
+
+    {year, month, day, hour, minute, second, {_, precision} = microsecond} =
+      calendar.shift_naive_datetime(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        __duration__!(duration)
+      )
+
+    result =
+      calendar.naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)
+      |> apply_tz_offset(utc_offset + std_offset)
+      |> shift_zone_for_iso_days_utc(calendar, precision, time_zone, time_zone_database)
+
+    case result do
+      {:ok, result_datetime} ->
+        result_datetime
+
+      {:error, error} ->
+        raise ArgumentError,
+              "cannot shift #{inspect(datetime)} to #{inspect(duration)} (with time zone " <>
+                "database #{inspect(time_zone_database)}), reason: #{inspect(error)}"
+    end
+  end
+
+  @doc false
+  defdelegate __duration__!(params), to: Duration, as: :new!
+
+  @doc """
+  Returns the given datetime with the microsecond field truncated to the given
+  precision (`:microsecond`, `:millisecond` or `:second`).
+
+  The given datetime is returned unchanged if it already has lower precision than
+  the given precision.
+
+  ## Examples
+
+      iex> dt1 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: "CET",
+      ...>                 hour: 11, minute: 45, second: 18, microsecond: {123456, 6},
+      ...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Paris"}
+      iex> DateTime.truncate(dt1, :microsecond)
+      #DateTime<2017-11-07 11:45:18.123456+01:00 CET Europe/Paris>
+
+      iex> dt2 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: "CET",
+      ...>                 hour: 11, minute: 45, second: 18, microsecond: {123456, 6},
+      ...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Paris"}
+      iex> DateTime.truncate(dt2, :millisecond)
+      #DateTime<2017-11-07 11:45:18.123+01:00 CET Europe/Paris>
+
+      iex> dt3 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: "CET",
+      ...>                 hour: 11, minute: 45, second: 18, microsecond: {123456, 6},
+      ...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Paris"}
+      iex> DateTime.truncate(dt3, :second)
+      #DateTime<2017-11-07 11:45:18+01:00 CET Europe/Paris>
+
+  """
+  @doc since: "1.6.0"
+  @spec truncate(Calendar.datetime(), :microsecond | :millisecond | :second) :: t()
+  def truncate(%DateTime{microsecond: microsecond} = datetime, precision) do
+    %{datetime | microsecond: Calendar.truncate(microsecond, precision)}
+  end
+
+  def truncate(%{} = datetime_map, precision) do
+    truncate(from_map(datetime_map), precision)
+  end
+
+  @doc """
+  Converts a given `datetime` from one calendar to another.
+
+  If it is not possible to convert unambiguously between the calendars
+  (see `Calendar.compatible_calendars?/2`), an `{:error, :incompatible_calendars}` tuple
+  is returned.
+
+  ## Examples
+
+  Imagine someone implements `Calendar.Holocene`, a calendar based on the
+  Gregorian calendar that adds exactly 10 000 years to the current Gregorian
+  year:
+
+      iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
+      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
+      iex> DateTime.convert(dt1, Calendar.Holocene)
+      {:ok, %DateTime{calendar: Calendar.Holocene, day: 29, hour: 23,
+                      microsecond: {0, 0}, minute: 0, month: 2, second: 7, std_offset: 0,
+                      time_zone: "America/Manaus", utc_offset: -14400, year: 12000,
+                      zone_abbr: "AMT"}}
+
+  """
+  @doc since: "1.5.0"
+  @spec convert(Calendar.datetime(), Calendar.calendar()) ::
+          {:ok, t} | {:error, :incompatible_calendars}
+
+  def convert(%DateTime{calendar: calendar} = datetime, calendar) do
+    {:ok, datetime}
+  end
+
+  def convert(%{calendar: calendar} = datetime, calendar) do
+    {:ok, from_map(datetime)}
+  end
+
+  def convert(%{calendar: dt_calendar, microsecond: {_, precision}} = datetime, calendar) do
+    if Calendar.compatible_calendars?(dt_calendar, calendar) do
+      result_datetime =
+        datetime
+        |> to_iso_days()
+        |> from_iso_days(datetime, calendar, precision)
+
+      {:ok, result_datetime}
+    else
+      {:error, :incompatible_calendars}
+    end
+  end
+
+  @doc """
+  Converts a given `datetime` from one calendar to another.
+
+  If it is not possible to convert unambiguously between the calendars
+  (see `Calendar.compatible_calendars?/2`), an ArgumentError is raised.
+
+  ## Examples
+
+  Imagine someone implements `Calendar.Holocene`, a calendar based on the
+  Gregorian calendar that adds exactly 10 000 years to the current Gregorian
+  year:
+
+      iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
+      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
+      iex> DateTime.convert!(dt1, Calendar.Holocene)
+      %DateTime{calendar: Calendar.Holocene, day: 29, hour: 23,
+                microsecond: {0, 0}, minute: 0, month: 2, second: 7, std_offset: 0,
+                time_zone: "America/Manaus", utc_offset: -14400, year: 12000,
+                zone_abbr: "AMT"}
+
+  """
+  @doc since: "1.5.0"
+  @spec convert!(Calendar.datetime(), Calendar.calendar()) :: t
+  def convert!(datetime, calendar) do
+    case convert(datetime, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, :incompatible_calendars} ->
+        raise ArgumentError,
+              "cannot convert #{inspect(datetime)} to target calendar #{inspect(calendar)}, " <>
+                "reason: #{inspect(datetime.calendar)} and #{inspect(calendar)} have different " <>
+                "day rollover moments, making this conversion ambiguous"
+    end
+  end
+
+  # Keep it multiline for proper function clause errors.
+  defp to_iso_days(%{
+         calendar: calendar,
+         year: year,
+         month: month,
+         day: day,
+         hour: hour,
+         minute: minute,
+         second: second,
+         microsecond: microsecond
+       }) do
+    calendar.naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)
+  end
+
+  defp from_iso_days(iso_days, datetime, calendar, precision) do
+    %{time_zone: time_zone, zone_abbr: zone_abbr, utc_offset: utc_offset, std_offset: std_offset} =
+      datetime
+
+    {year, month, day, hour, minute, second, {microsecond, _}} =
+      calendar.naive_datetime_from_iso_days(iso_days)
+
+    %DateTime{
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: {microsecond, precision},
+      time_zone: time_zone,
+      zone_abbr: zone_abbr,
+      utc_offset: utc_offset,
+      std_offset: std_offset
+    }
+  end
+
+  defp apply_tz_offset(iso_days, 0) do
+    iso_days
+  end
+
+  defp apply_tz_offset(iso_days, offset) do
+    Calendar.ISO.add_day_fraction_to_iso_days(iso_days, -offset, 86400)
+  end
+
+  defp from_map(%{} = datetime_map) do
+    %DateTime{
+      year: datetime_map.year,
+      month: datetime_map.month,
+      day: datetime_map.day,
+      hour: datetime_map.hour,
+      minute: datetime_map.minute,
+      second: datetime_map.second,
+      microsecond: datetime_map.microsecond,
+      time_zone: datetime_map.time_zone,
+      zone_abbr: datetime_map.zone_abbr,
+      utc_offset: datetime_map.utc_offset,
+      std_offset: datetime_map.std_offset
+    }
+  end
+
+  defp seconds_from_day_fraction({parts_in_day, @seconds_per_day}),
+    do: parts_in_day
+
+  defp seconds_from_day_fraction({parts_in_day, parts_per_day}),
+    do: div(parts_in_day * @seconds_per_day, parts_per_day)
+
+  defimpl String.Chars do
+    def to_string(datetime) do
+      %{
+        calendar: calendar,
+        year: year,
+        month: month,
+        day: day,
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond,
+        time_zone: time_zone,
+        zone_abbr: zone_abbr,
+        utc_offset: utc_offset,
+        std_offset: std_offset
+      } = datetime
+
+      calendar.datetime_to_string(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        time_zone,
+        zone_abbr,
+        utc_offset,
+        std_offset
+      )
+    end
+  end
+
+  defimpl Inspect do
+    def inspect(datetime, _) do
+      %{
+        year: year,
+        month: month,
+        day: day,
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond,
+        time_zone: time_zone,
+        zone_abbr: zone_abbr,
+        utc_offset: utc_offset,
+        std_offset: std_offset,
+        calendar: calendar
+      } = datetime
+
+      formatted =
+        calendar.datetime_to_string(
+          year,
+          month,
+          day,
+          hour,
+          minute,
+          second,
+          microsecond,
+          time_zone,
+          zone_abbr,
+          utc_offset,
+          std_offset
+        )
+
+      case datetime do
+        %{utc_offset: 0, std_offset: 0, time_zone: "Etc/UTC", year: year}
+        when calendar != Calendar.ISO or year in -9999..9999 ->
+          "~U[" <> formatted <> suffix(calendar) <> "]"
+
+        _ ->
+          "#DateTime<" <> formatted <> suffix(calendar) <> ">"
+      end
+    end
+
+    defp suffix(Calendar.ISO), do: ""
+    defp suffix(calendar), do: " " <> inspect(calendar)
+  end
+end
diff --git a/lib/elixir/lib/calendar/duration.ex b/lib/elixir/lib/calendar/duration.ex
new file mode 100644
index 00000000000..b96e8b8f030
--- /dev/null
+++ b/lib/elixir/lib/calendar/duration.ex
@@ -0,0 +1,586 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Duration do
+  @moduledoc """
+  Struct and functions for handling durations.
+
+  A `Duration` struct represents a collection of time scale units,
+  allowing for manipulation and calculation of durations.
+
+  Date and time scale units are represented as integers, allowing for
+  both positive and negative values.
+
+  Microseconds are represented using a tuple `{microsecond, precision}`.
+  This ensures compatibility with other calendar types implementing time,
+  such as `Time`, `DateTime`, and `NaiveDateTime`.
+
+  ## Shifting
+
+  The most common use of durations in Elixir's standard library is to
+  "shift" the calendar types.
+
+      iex> Date.shift(~D[2016-01-03], month: 2)
+      ~D[2016-03-03]
+
+  In the example above, `Date.shift/2` automatically converts the units
+  into a `Duration` struct, although one can also be given directly:
+
+      iex> Date.shift(~D[2016-01-03], Duration.new!(month: 2))
+      ~D[2016-03-03]
+
+  It is important to note that shifting is not an arithmetic operation.
+  For example, adding `date + 1 month + 1 month` does not yield the same
+  result as `date + 2 months`. Let's see an example:
+
+      iex> ~D[2016-01-31] |> Date.shift(month: 1) |> Date.shift(month: 1)
+      ~D[2016-03-29]
+
+      iex> ~D[2016-01-31] |> Date.shift(month: 2)
+      ~D[2016-03-31]
+
+  As you can see above, the results differ, which explains why operations
+  with durations are called "shift" rather than "add". This happens because,
+  once we add one month to `2016-01-31`, we get `2016-02-29`. Then adding
+  one extra month gives us `2016-03-29` instead of `2016-03-31`.
+
+  In particular, when applying durations to `Calendar.ISO` types:
+
+    * larger units (such as years and months) are applied before
+      smaller ones (such as weeks, hours, days, and so on)
+
+    * units are collapsed into months (`:year` and `:month`),
+      seconds (`:week`, `:day`, `:hour`, `:minute`, `:second`)
+      and microseconds (`:microsecond`) before they are applied
+
+    * 1 year is equivalent to 12 months, 1 week is equivalent to 7 days.
+      Therefore, 4 weeks _are not_ equivalent to 1 month
+
+    * in case of non-existing dates, the results are rounded down to the
+      nearest valid date
+
+  As the `shift/2` functions are calendar aware, they are guaranteed to return
+  valid date/times, considering leap years as well as DST in applicable time zones.
+
+  ## Intervals
+
+  Durations in Elixir can be combined with stream operations to build intervals.
+  For example, to retrieve the next three Wednesdays starting from 17th April, 2024:
+
+      iex> ~D[2024-04-17] |> Stream.iterate(&Date.shift(&1, week: 1)) |> Enum.take(3)
+      [~D[2024-04-17], ~D[2024-04-24], ~D[2024-05-01]]
+
+  However, once again, it is important to remember that shifting a duration is not
+  arithmetic, so you may want to use the functions in this module depending on what
+  you to achieve. Compare the results of both examples below:
+
+      # Adding one month after the other
+      iex> date = ~D[2016-01-31]
+      iex> duration = Duration.new!(month: 1)
+      iex> stream = Stream.iterate(date, fn prev_date -> Date.shift(prev_date, duration) end)
+      iex> Enum.take(stream, 3)
+      [~D[2016-01-31], ~D[2016-02-29], ~D[2016-03-29]]
+
+      # Multiplying durations by an index
+      iex> date = ~D[2016-01-31]
+      iex> duration = Duration.new!(month: 1)
+      iex> stream = Stream.from_index(fn i -> Date.shift(date, Duration.multiply(duration, i)) end)
+      iex> Enum.take(stream, 3)
+      [~D[2016-01-31], ~D[2016-02-29], ~D[2016-03-31]]
+
+  The second example consistently points to the last day of the month,
+  as it performs operations on the duration, rather than shifting date
+  after date.
+
+  ## Comparing durations
+
+  In order to accurately compare durations, you need to either compare
+  only certain fields or use a reference time instant. This is because
+  some fields are relative to others. For example, you may say that
+  1 month is the same as 30 days, but if you add both of these durations
+  to `~D[2015-02-01]`, you would get different results, as that month
+  has only 28 days.
+
+  Therefore, if you wish to compare durations, one option is to use
+  `Date.shift/2` (or `DateTime.shift/2` or similar), and then compare
+  the dates:
+
+      iex> date = ~D[2015-02-01]
+      iex> Date.compare(Date.shift(date, month: 1), Date.shift(date, day: 30))
+      :lt
+
+  Or alternatively convert the durations to a fixed unit by using `to_timeout/1`,
+  which supports durations only up to weeks, raising if it has the month or year
+  fields set.
+
+      iex> to_timeout(hour: 24) == to_timeout(day: 1)
+      true
+  """
+
+  @moduledoc since: "1.17.0"
+
+  @derive {Inspect, optional: [:year, :month, :week, :day, :hour, :minute, :second, :microsecond]}
+  defstruct year: 0,
+            month: 0,
+            week: 0,
+            day: 0,
+            hour: 0,
+            minute: 0,
+            second: 0,
+            microsecond: {0, 0}
+
+  @typedoc """
+  The duration struct type.
+  """
+  @type t :: %Duration{
+          year: integer,
+          month: integer,
+          week: integer,
+          day: integer,
+          hour: integer,
+          minute: integer,
+          second: integer,
+          microsecond: Calendar.microsecond()
+        }
+
+  @typedoc """
+  The unit pair type specifies a pair of a valid duration unit key and value.
+  """
+  @type unit_pair ::
+          {:year, integer}
+          | {:month, integer}
+          | {:week, integer}
+          | {:day, integer}
+          | {:hour, integer}
+          | {:minute, integer}
+          | {:second, integer}
+          | {:microsecond, Calendar.microsecond()}
+
+  @typedoc """
+  The duration type specifies a `%Duration{}` struct or a keyword list of valid duration unit pairs.
+  """
+  @type duration :: t | [unit_pair]
+
+  @typedoc """
+  Options for `Duration.to_string/2`.
+  """
+  @type to_string_opts :: [
+          units: [
+            year: String.t(),
+            month: String.t(),
+            week: String.t(),
+            day: String.t(),
+            hour: String.t(),
+            minute: String.t(),
+            second: String.t()
+          ],
+          separator: String.t()
+        ]
+
+  @microseconds_per_second 1_000_000
+
+  @doc """
+  Creates a new `Duration` struct from given `unit_pairs`.
+
+  Raises an `ArgumentError` when called with invalid unit pairs.
+
+  ## Examples
+
+      iex> Duration.new!(year: 1, week: 3, hour: 4, second: 1)
+      %Duration{year: 1, week: 3, hour: 4, second: 1}
+      iex> Duration.new!(second: 1, microsecond: {1000, 6})
+      %Duration{second: 1, microsecond: {1000, 6}}
+      iex> Duration.new!(month: 2)
+      %Duration{month: 2}
+
+  """
+  @spec new!(duration()) :: t
+  def new!(%Duration{} = duration) do
+    duration
+  end
+
+  def new!(unit_pairs) do
+    Enum.each(unit_pairs, &validate_unit!/1)
+    struct!(Duration, unit_pairs)
+  end
+
+  defp validate_unit!({:microsecond, {ms, precision}})
+       when is_integer(ms) and precision in 0..6 do
+    :ok
+  end
+
+  defp validate_unit!({:microsecond, microsecond}) do
+    raise ArgumentError,
+          "unsupported value #{inspect(microsecond)} for :microsecond. Expected a tuple {ms, precision} where precision is an integer from 0 to 6"
+  end
+
+  defp validate_unit!({unit, _value})
+       when unit not in [:year, :month, :week, :day, :hour, :minute, :second] do
+    raise ArgumentError,
+          "unknown unit #{inspect(unit)}. Expected :year, :month, :week, :day, :hour, :minute, :second, :microsecond"
+  end
+
+  defp validate_unit!({_unit, value}) when is_integer(value) do
+    :ok
+  end
+
+  defp validate_unit!({unit, value}) do
+    raise ArgumentError,
+          "unsupported value #{inspect(value)} for #{inspect(unit)}. Expected an integer"
+  end
+
+  @doc """
+  Adds units of given durations `d1` and `d2`.
+
+  Respects the the highest microsecond precision of the two.
+
+  ## Examples
+
+      iex> Duration.add(Duration.new!(week: 2, day: 1), Duration.new!(day: 2))
+      %Duration{week: 2, day: 3}
+      iex> Duration.add(Duration.new!(microsecond: {400, 3}), Duration.new!(microsecond: {600, 6}))
+      %Duration{microsecond: {1000, 6}}
+
+  """
+  @spec add(t, t) :: t
+  def add(%Duration{} = d1, %Duration{} = d2) do
+    {m1, p1} = d1.microsecond
+    {m2, p2} = d2.microsecond
+
+    %Duration{
+      year: d1.year + d2.year,
+      month: d1.month + d2.month,
+      week: d1.week + d2.week,
+      day: d1.day + d2.day,
+      hour: d1.hour + d2.hour,
+      minute: d1.minute + d2.minute,
+      second: d1.second + d2.second,
+      microsecond: {m1 + m2, max(p1, p2)}
+    }
+  end
+
+  @doc """
+  Subtracts units of given durations `d1` and `d2`.
+
+  Respects the the highest microsecond precision of the two.
+
+  ## Examples
+
+      iex> Duration.subtract(Duration.new!(week: 2, day: 1), Duration.new!(day: 2))
+      %Duration{week: 2, day: -1}
+      iex> Duration.subtract(Duration.new!(microsecond: {400, 6}), Duration.new!(microsecond: {600, 3}))
+      %Duration{microsecond: {-200, 6}}
+
+  """
+  @spec subtract(t, t) :: t
+  def subtract(%Duration{} = d1, %Duration{} = d2) do
+    {m1, p1} = d1.microsecond
+    {m2, p2} = d2.microsecond
+
+    %Duration{
+      year: d1.year - d2.year,
+      month: d1.month - d2.month,
+      week: d1.week - d2.week,
+      day: d1.day - d2.day,
+      hour: d1.hour - d2.hour,
+      minute: d1.minute - d2.minute,
+      second: d1.second - d2.second,
+      microsecond: {m1 - m2, max(p1, p2)}
+    }
+  end
+
+  @doc """
+  Multiplies `duration` units by given `integer`.
+
+  ## Examples
+
+      iex> Duration.multiply(Duration.new!(day: 1, minute: 15, second: -10), 3)
+      %Duration{day: 3, minute: 45, second: -30}
+      iex> Duration.multiply(Duration.new!(microsecond: {200, 4}), 3)
+      %Duration{microsecond: {600, 4}}
+
+  """
+  @spec multiply(t, integer) :: t
+  def multiply(%Duration{microsecond: {ms, p}} = duration, integer) when is_integer(integer) do
+    %Duration{
+      year: duration.year * integer,
+      month: duration.month * integer,
+      week: duration.week * integer,
+      day: duration.day * integer,
+      hour: duration.hour * integer,
+      minute: duration.minute * integer,
+      second: duration.second * integer,
+      microsecond: {ms * integer, p}
+    }
+  end
+
+  @doc """
+  Negates `duration` units.
+
+  ## Examples
+
+      iex> Duration.negate(Duration.new!(day: 1, minute: 15, second: -10))
+      %Duration{day: -1, minute: -15, second: 10}
+      iex> Duration.negate(Duration.new!(microsecond: {500000, 4}))
+      %Duration{microsecond: {-500000, 4}}
+
+  """
+  @spec negate(t) :: t
+  def negate(%Duration{microsecond: {ms, p}} = duration) do
+    %Duration{
+      year: -duration.year,
+      month: -duration.month,
+      week: -duration.week,
+      day: -duration.day,
+      hour: -duration.hour,
+      minute: -duration.minute,
+      second: -duration.second,
+      microsecond: {-ms, p}
+    }
+  end
+
+  @doc """
+  Parses an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) formatted duration string to a `Duration` struct.
+
+  Duration strings, as well as individual units, may be prefixed with plus/minus signs so that:
+
+  - `-PT6H3M` parses as `%Duration{hour: -6, minute: -3}`
+  - `-PT6H-3M` parses as `%Duration{hour: -6, minute: 3}`
+  - `+PT6H3M` parses as `%Duration{hour: 6, minute: 3}`
+  - `+PT6H-3M` parses as `%Duration{hour: 6, minute: -3}`
+
+  Duration designators must be provided in order of magnitude: `P[n]Y[n]M[n]W[n]DT[n]H[n]M[n]S`.
+
+  Only seconds may be specified with a decimal fraction, using either a comma or a full stop: `P1DT4,5S`.
+
+  ## Examples
+
+      iex> Duration.from_iso8601("P1Y2M3DT4H5M6S")
+      {:ok, %Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}}
+      iex> Duration.from_iso8601("P3Y-2MT3H")
+      {:ok, %Duration{year: 3, month: -2, hour: 3}}
+      iex> Duration.from_iso8601("-PT10H-30M")
+      {:ok, %Duration{hour: -10, minute: 30}}
+      iex> Duration.from_iso8601("PT4.650S")
+      {:ok, %Duration{second: 4, microsecond: {650000, 3}}}
+
+  """
+  @spec from_iso8601(String.t()) :: {:ok, t} | {:error, atom}
+  def from_iso8601(string) when is_binary(string) do
+    case Calendar.ISO.parse_duration(string) do
+      {:ok, duration} ->
+        {:ok, new!(duration)}
+
+      error ->
+        error
+    end
+  end
+
+  @doc """
+  Same as `from_iso8601/1` but raises an `ArgumentError`.
+
+  ## Examples
+
+      iex> Duration.from_iso8601!("P1Y2M3DT4H5M6S")
+      %Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}
+      iex> Duration.from_iso8601!("P10D")
+      %Duration{day: 10}
+
+  """
+  @spec from_iso8601!(String.t()) :: t
+  def from_iso8601!(string) when is_binary(string) do
+    case from_iso8601(string) do
+      {:ok, duration} ->
+        duration
+
+      {:error, reason} ->
+        raise ArgumentError, ~s/failed to parse duration "#{string}". reason: #{inspect(reason)}/
+    end
+  end
+
+  @doc """
+  Converts the given `duration` to a human readable representation.
+
+  ## Options
+
+    * `:units` - the units to be used alongside each duration component.
+      The default units follow the ISO 80000-3 standard:
+
+          [
+            year: "a",
+            month: "mo",
+            week: "wk",
+            day: "d",
+            hour: "h",
+            minute: "min",
+            second: "s"
+          ]
+
+    * `:separator` - a string used to separate the distinct components. Defaults to `" "`.
+
+  ## Examples
+
+      iex> Duration.to_string(Duration.new!(second: 30))
+      "30s"
+      iex> Duration.to_string(Duration.new!(day: 40, hour: 12, minute: 42, second: 12))
+      "40d 12h 42min 12s"
+
+  By default, this function uses ISO 80000-3 units, which uses "a" for years.
+  But you can customize all units via the units option:
+
+      iex> Duration.to_string(Duration.new!(year: 3))
+      "3a"
+      iex> Duration.to_string(Duration.new!(year: 3), units: [year: "y"])
+      "3y"
+
+  You may also choose the separator:
+
+      iex> Duration.to_string(Duration.new!(day: 40, hour: 12, minute: 42, second: 12), separator: ", ")
+      "40d, 12h, 42min, 12s"
+
+  A duration without components is rendered as "0s":
+
+      iex> Duration.to_string(Duration.new!([]))
+      "0s"
+
+  Microseconds are rendered as part of seconds with the appropriate precision:
+
+      iex> Duration.to_string(Duration.new!(second: 1, microsecond: {2_200, 3}))
+      "1.002s"
+      iex> Duration.to_string(Duration.new!(second: 1, microsecond: {-1_200_000, 4}))
+      "-0.2000s"
+
+  """
+  @doc since: "1.18.0"
+  @spec to_string(t, to_string_opts) :: String.t()
+  def to_string(%Duration{} = duration, opts \\ []) do
+    units = Keyword.get(opts, :units, [])
+    separator = Keyword.get(opts, :separator, " ")
+
+    case to_string_year(duration, [], units) do
+      [] ->
+        "0" <> Keyword.get(units, :second, "s")
+
+      [part] ->
+        IO.iodata_to_binary(part)
+
+      parts ->
+        parts |> Enum.reduce(&[&1, separator | &2]) |> IO.iodata_to_binary()
+    end
+  end
+
+  defp to_string_part(0, _units, _key, _default, acc),
+    do: acc
+
+  defp to_string_part(x, units, key, default, acc),
+    do: [[Integer.to_string(x) | Keyword.get(units, key, default)] | acc]
+
+  defp to_string_year(%{year: year} = duration, acc, units) do
+    to_string_month(duration, to_string_part(year, units, :year, "a", acc), units)
+  end
+
+  defp to_string_month(%{month: month} = duration, acc, units) do
+    to_string_week(duration, to_string_part(month, units, :month, "mo", acc), units)
+  end
+
+  defp to_string_week(%{week: week} = duration, acc, units) do
+    to_string_day(duration, to_string_part(week, units, :week, "wk", acc), units)
+  end
+
+  defp to_string_day(%{day: day} = duration, acc, units) do
+    to_string_hour(duration, to_string_part(day, units, :day, "d", acc), units)
+  end
+
+  defp to_string_hour(%{hour: hour} = duration, acc, units) do
+    to_string_minute(duration, to_string_part(hour, units, :hour, "h", acc), units)
+  end
+
+  defp to_string_minute(%{minute: minute} = duration, acc, units) do
+    to_string_second(duration, to_string_part(minute, units, :minute, "min", acc), units)
+  end
+
+  defp to_string_second(%{second: 0, microsecond: {0, _}}, acc, _units) do
+    acc
+  end
+
+  defp to_string_second(%{second: s, microsecond: {ms, p}}, acc, units) do
+    [[second_component(s, ms, p) | Keyword.get(units, :second, "s")] | acc]
+  end
+
+  @doc """
+  Converts the given `duration` to an [ISO 8601-2:2019](https://en.wikipedia.org/wiki/ISO_8601) formatted string.
+
+  This function implements the extension of ISO 8601:2019, allowing weeks to appear between months and days: `P3M3W3D`.
+
+  ## Examples
+
+      iex> Duration.to_iso8601(Duration.new!(year: 3))
+      "P3Y"
+      iex> Duration.to_iso8601(Duration.new!(day: 40, hour: 12, minute: 42, second: 12))
+      "P40DT12H42M12S"
+      iex> Duration.to_iso8601(Duration.new!(second: 30))
+      "PT30S"
+
+      iex> Duration.to_iso8601(Duration.new!([]))
+      "PT0S"
+
+      iex> Duration.to_iso8601(Duration.new!(second: 1, microsecond: {2_200, 3}))
+      "PT1.002S"
+      iex> Duration.to_iso8601(Duration.new!(second: 1, microsecond: {-1_200_000, 4}))
+      "PT-0.2000S"
+  """
+
+  @spec to_iso8601(t) :: String.t()
+  def to_iso8601(%Duration{} = duration) do
+    case {to_iso8601_duration_date(duration), to_iso8601_duration_time(duration)} do
+      {[], []} -> "PT0S"
+      {date, time} -> IO.iodata_to_binary([?P, date, time])
+    end
+  end
+
+  defp to_iso8601_duration_date(%{year: 0, month: 0, week: 0, day: 0}) do
+    []
+  end
+
+  defp to_iso8601_duration_date(%{year: year, month: month, week: week, day: day}) do
+    [pair(year, ?Y), pair(month, ?M), pair(week, ?W), pair(day, ?D)]
+  end
+
+  defp to_iso8601_duration_time(%{hour: 0, minute: 0, second: 0, microsecond: {0, _}}) do
+    []
+  end
+
+  defp to_iso8601_duration_time(%{hour: hour, minute: minute} = d) do
+    [?T, pair(hour, ?H), pair(minute, ?M), second_component(d)]
+  end
+
+  defp second_component(%{second: 0, microsecond: {0, _}}) do
+    []
+  end
+
+  defp second_component(%{second: second, microsecond: {ms, p}}) do
+    [second_component(second, ms, p), ?S]
+  end
+
+  defp second_component(second, _ms, 0) do
+    Integer.to_string(second)
+  end
+
+  defp second_component(second, ms, p) do
+    total_ms = second * @microseconds_per_second + ms
+    second = total_ms |> div(@microseconds_per_second) |> abs()
+    ms = total_ms |> rem(@microseconds_per_second) |> abs()
+    sign = if total_ms < 0, do: ?-, else: []
+
+    [
+      sign,
+      Integer.to_string(second),
+      ?.,
+      Calendar.ISO.microseconds_to_iodata(ms, p)
+    ]
+  end
+
+  @compile {:inline, pair: 2}
+  defp pair(0, _key), do: []
+  defp pair(num, key), do: [Integer.to_string(num), key]
+end
diff --git a/lib/elixir/lib/calendar/iso.ex b/lib/elixir/lib/calendar/iso.ex
new file mode 100644
index 00000000000..172da374c78
--- /dev/null
+++ b/lib/elixir/lib/calendar/iso.ex
@@ -0,0 +1,2173 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Calendar.ISO do
+  @moduledoc """
+  The default calendar implementation, a Gregorian calendar following ISO 8601.
+
+  This calendar implements a proleptic Gregorian calendar and
+  is therefore compatible with the calendar used in most countries
+  today. The proleptic means the Gregorian rules for leap years are
+  applied for all time, consequently the dates give different results
+  before the year 1583 from when the Gregorian calendar was adopted.
+
+  ## ISO 8601 compliance
+
+  The ISO 8601 specification is feature-rich, but allows applications
+  to selectively implement most parts of it. The choices Elixir makes
+  are catalogued below.
+
+  ### Features
+
+  The standard library supports a minimal set of possible ISO 8601 features.
+  Specifically, the parser only supports calendar dates and does not support
+  ordinal and week formats. Additionally, it supports parsing ISO 8601
+  formatted durations, including negative time units and fractional seconds.
+
+  By default Elixir only parses extended-formatted date/times. You can opt-in
+  to parse basic-formatted date/times.
+
+  `NaiveDateTime.to_iso8601/2` and `DateTime.to_iso8601/2` allow you to produce
+  either basic or extended formatted strings, and `Calendar.strftime/2` allows
+  you to format datetimes however else you desire.
+
+  Elixir does not support reduced accuracy formats (for example, a date without
+  the day component) nor decimal precisions in the lowest component (such as
+  `10:01:25,5`).
+
+  #### Examples
+
+  Elixir expects the extended format by default when parsing:
+
+      iex> Calendar.ISO.parse_naive_datetime("2015-01-23T23:50:07")
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}
+      iex> Calendar.ISO.parse_naive_datetime("20150123T235007")
+      {:error, :invalid_format}
+
+  Parsing can be restricted to basic if desired:
+
+      iex> Calendar.ISO.parse_naive_datetime("20150123T235007Z", :basic)
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}
+      iex> Calendar.ISO.parse_naive_datetime("20150123T235007Z", :extended)
+      {:error, :invalid_format}
+
+  Only calendar dates are supported in parsing; ordinal and week dates are not.
+
+      iex> Calendar.ISO.parse_date("2015-04-15")
+      {:ok, {2015, 4, 15}}
+      iex> Calendar.ISO.parse_date("2015-105")
+      {:error, :invalid_format}
+      iex> Calendar.ISO.parse_date("2015-W16")
+      {:error, :invalid_format}
+      iex> Calendar.ISO.parse_date("2015-W016-3")
+      {:error, :invalid_format}
+
+  Years, months, days, hours, minutes, and seconds must be fully specified:
+
+      iex> Calendar.ISO.parse_date("2015-04-15")
+      {:ok, {2015, 4, 15}}
+      iex> Calendar.ISO.parse_date("2015-04")
+      {:error, :invalid_format}
+      iex> Calendar.ISO.parse_date("2015")
+      {:error, :invalid_format}
+
+      iex> Calendar.ISO.parse_time("23:50:07.0123456")
+      {:ok, {23, 50, 7, {12345, 6}}}
+      iex> Calendar.ISO.parse_time("23:50:07")
+      {:ok, {23, 50, 7, {0, 0}}}
+      iex> Calendar.ISO.parse_time("23:50")
+      {:error, :invalid_format}
+      iex> Calendar.ISO.parse_time("23")
+      {:error, :invalid_format}
+
+  ### Extensions
+
+  The parser and formatter adopt one ISO 8601 extension: extended year notation.
+
+  This allows dates to be prefixed with a `+` or `-` sign, extending the range of
+  expressible years from the default (`0000..9999`) to `-9999..9999`. Elixir still
+  restricts years in this format to four digits.
+
+  #### Examples
+
+      iex> Calendar.ISO.parse_date("-2015-01-23")
+      {:ok, {-2015, 1, 23}}
+      iex> Calendar.ISO.parse_date("+2015-01-23")
+      {:ok, {2015, 1, 23}}
+
+      iex> Calendar.ISO.parse_naive_datetime("-2015-01-23 23:50:07")
+      {:ok, {-2015, 1, 23, 23, 50, 7, {0, 0}}}
+      iex> Calendar.ISO.parse_naive_datetime("+2015-01-23 23:50:07")
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}
+
+      iex> Calendar.ISO.parse_utc_datetime("-2015-01-23 23:50:07Z")
+      {:ok, {-2015, 1, 23, 23, 50, 7, {0, 0}}, 0}
+      iex> Calendar.ISO.parse_utc_datetime("+2015-01-23 23:50:07Z")
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}, 0}
+
+  ### Additions
+
+  ISO 8601 does not allow a whitespace instead of `T` as a separator
+  between date and times, both when parsing and formatting.
+  This is a common enough representation, Elixir allows it during parsing.
+
+  The formatting of dates in `NaiveDateTime.to_iso8601/1` and `DateTime.to_iso8601/1`
+  do produce specification-compliant string representations using the `T` separator.
+
+  #### Examples
+
+      iex> Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07.0123456")
+      {:ok, {2015, 1, 23, 23, 50, 7, {12345, 6}}}
+      iex> Calendar.ISO.parse_naive_datetime("2015-01-23T23:50:07.0123456")
+      {:ok, {2015, 1, 23, 23, 50, 7, {12345, 6}}}
+
+      iex> Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:07.0123456Z")
+      {:ok, {2015, 1, 23, 23, 50, 7, {12345, 6}}, 0}
+      iex> Calendar.ISO.parse_utc_datetime("2015-01-23T23:50:07.0123456Z")
+      {:ok, {2015, 1, 23, 23, 50, 7, {12345, 6}}, 0}
+
+  """
+
+  @behaviour Calendar
+
+  @unix_epoch 62_167_219_200
+  unix_start = (315_537_897_600 + @unix_epoch) * -1_000_000
+  unix_end = 315_569_519_999_999_999 - @unix_epoch * 1_000_000
+  @unix_range_microseconds unix_start..unix_end
+
+  defguardp is_format(term) when term in [:basic, :extended]
+
+  @typedoc """
+  "Before the Current Era" or "Before the Common Era" (BCE), for those years less than `1`.
+  """
+  @type bce :: 0
+
+  @typedoc """
+  The "Current Era" or the "Common Era" (CE) which starts in year `1`.
+  """
+  @type ce :: 1
+
+  @typedoc """
+  The calendar era.
+
+  The ISO calendar has two eras:
+  * [CE](`t:ce/0`) - which starts in year `1` and is defined as era `1`.
+  * [BCE](`t:bce/0`) - for those years less than `1` and is defined as era `0`.
+  """
+  @type era :: bce | ce
+  @type year :: -9999..9999
+  @type month :: 1..12
+  @type day :: 1..31
+  @type hour :: 0..23
+  @type minute :: 0..59
+  @type second :: 0..59
+  @type weekday :: :monday | :tuesday | :wednesday | :thursday | :friday | :saturday | :sunday
+  @type utc_offset :: integer
+  @type format :: :basic | :extended
+
+  @typedoc """
+  Microseconds with stored precision.
+
+  The precision represents the number of digits that must be used when
+  representing the microseconds to external format. If the precision is 0,
+  it means microseconds must be skipped.
+  """
+  @type microsecond :: {0..999_999, 0..6}
+
+  @typedoc """
+  Integer that represents the day of the week, where 1 is Monday and 7 is Sunday.
+  """
+  @type day_of_week :: 1..7
+
+  @type day_of_year :: 1..366
+  @type quarter_of_year :: 1..4
+  @type year_of_era :: {1..10_000, era}
+
+  @seconds_per_minute 60
+  @seconds_per_hour 60 * 60
+  # Note that this does *not* handle leap seconds.
+  @seconds_per_day 24 * 60 * 60
+  @last_second_of_the_day @seconds_per_day - 1
+  @microseconds_per_second 1_000_000
+  @parts_per_day @seconds_per_day * @microseconds_per_second
+
+  @datetime_seps [?\s, ?T]
+  @ext_date_sep ?-
+  @ext_time_sep ?:
+
+  # The ISO epoch starts, in this implementation,
+  # with ~D[0000-01-01]. Era "1" starts
+  # on ~D[0001-01-01] which is 366 days later.
+  @iso_epoch 366
+
+  # Constants for date calculations using 400-year era cycles.
+  # The algorithm uses a March-based year where March 1 is day 0.
+  # Reference: Neri C, Schneider L. "Euclidean Affine Functions and
+  # their Application to Calendar Algorithms". Softw Pract Exper. 2022.
+  @days_per_year 365
+  @years_per_era 400
+  @days_per_era @years_per_era * @days_per_year + 97
+  @days_per_4_years 4 * @days_per_year
+  @days_per_100_years 100 * @days_per_year + 24
+  @march_1_offset 31 + 29
+  @unix_epoch_days 719_528
+
+  # Month calculation constants: in a March-based year, each 5-month
+  # cycle has exactly 153 days (31+30+31+30+31 or 31+30+31+30+31).
+  @days_per_5_months 153
+  @months_per_cycle 5
+
+  [match_basic_date, match_ext_date, guard_date, read_date] =
+    quote do
+      [
+        <<y1, y2, y3, y4, m1, m2, d1, d2>>,
+        <<y1, y2, y3, y4, @ext_date_sep, m1, m2, @ext_date_sep, d1, d2>>,
+        y1 >= ?0 and y1 <= ?9 and y2 >= ?0 and y2 <= ?9 and y3 >= ?0 and y3 <= ?9 and y4 >= ?0 and
+          y4 <= ?9 and m1 >= ?0 and m1 <= ?9 and m2 >= ?0 and m2 <= ?9 and d1 >= ?0 and d1 <= ?9 and
+          d2 >= ?0 and d2 <= ?9,
+        {
+          (y1 - ?0) * 1000 + (y2 - ?0) * 100 + (y3 - ?0) * 10 + (y4 - ?0),
+          (m1 - ?0) * 10 + (m2 - ?0),
+          (d1 - ?0) * 10 + (d2 - ?0)
+        }
+      ]
+    end
+
+  [match_basic_time, match_ext_time, guard_time, read_time] =
+    quote do
+      [
+        <<h1, h2, i1, i2, s1, s2>>,
+        <<h1, h2, @ext_time_sep, i1, i2, @ext_time_sep, s1, s2>>,
+        h1 >= ?0 and h1 <= ?9 and h2 >= ?0 and h2 <= ?9 and i1 >= ?0 and i1 <= ?9 and i2 >= ?0 and
+          i2 <= ?9 and s1 >= ?0 and s1 <= ?9 and s2 >= ?0 and s2 <= ?9,
+        {
+          (h1 - ?0) * 10 + (h2 - ?0),
+          (i1 - ?0) * 10 + (i2 - ?0),
+          (s1 - ?0) * 10 + (s2 - ?0)
+        }
+      ]
+    end
+
+  defguardp is_year(year) when is_integer(year)
+  defguardp is_year_BCE(year) when year <= 0
+  defguardp is_year_CE(year) when year >= 1
+  defguardp is_month(month) when month in 1..12
+  defguardp is_day(day) when day in 1..31
+  defguardp is_hour(hour) when hour in 0..23
+  defguardp is_minute(minute) when minute in 0..59
+  defguardp is_second(second) when second in 0..59
+
+  defguardp is_microsecond(microsecond, precision)
+            when microsecond in 0..999_999 and precision in 0..6
+
+  defguardp is_time_zone(term) when is_binary(term)
+  defguardp is_zone_abbr(term) when is_binary(term)
+  defguardp is_utc_offset(offset) when is_integer(offset)
+  defguardp is_std_offset(offset) when is_integer(offset)
+
+  @doc """
+  Converts a `t:System.time_unit/0` to precision.
+
+  Integer-based time units always get maximum precision.
+
+  ## Examples
+
+      iex> Calendar.ISO.time_unit_to_precision(:nanosecond)
+      6
+
+      iex> Calendar.ISO.time_unit_to_precision(:second)
+      0
+
+      iex> Calendar.ISO.time_unit_to_precision(1)
+      6
+
+  """
+  @doc since: "1.15.0"
+  @spec time_unit_to_precision(System.time_unit()) :: 0..6
+  def time_unit_to_precision(:nanosecond), do: 6
+  def time_unit_to_precision(:microsecond), do: 6
+  def time_unit_to_precision(:millisecond), do: 3
+  def time_unit_to_precision(:second), do: 0
+  def time_unit_to_precision(int) when is_integer(int), do: 6
+
+  @doc """
+  Parses a time `string` in the `:extended` format.
+
+  For more information on supported strings, see how this
+  module implements [ISO 8601](#module-iso-8601-compliance).
+
+  ## Examples
+
+      iex> Calendar.ISO.parse_time("23:50:07")
+      {:ok, {23, 50, 7, {0, 0}}}
+
+      iex> Calendar.ISO.parse_time("23:50:07Z")
+      {:ok, {23, 50, 7, {0, 0}}}
+      iex> Calendar.ISO.parse_time("T23:50:07Z")
+      {:ok, {23, 50, 7, {0, 0}}}
+
+  """
+  @doc since: "1.10.0"
+  @impl true
+  @spec parse_time(String.t()) ::
+          {:ok, {hour, minute, second, microsecond}}
+          | {:error, atom}
+  def parse_time(string) when is_binary(string),
+    do: parse_time(string, :extended)
+
+  @doc """
+  Parses a time `string` according to a given `format`.
+
+  The `format` can either be `:basic` or `:extended`.
+
+  For more information on supported strings, see how this
+  module implements [ISO 8601](#module-iso-8601-compliance).
+
+  ## Examples
+
+      iex> Calendar.ISO.parse_time("235007", :basic)
+      {:ok, {23, 50, 7, {0, 0}}}
+      iex> Calendar.ISO.parse_time("235007", :extended)
+      {:error, :invalid_format}
+
+  """
+  @doc since: "1.12.0"
+  @spec parse_time(String.t(), format) ::
+          {:ok, {hour, minute, second, microsecond}}
+          | {:error, atom}
+  def parse_time(string, format) when is_binary(string) and is_format(format) do
+    case string do
+      "T" <> rest -> do_parse_time(rest, format)
+      _ -> do_parse_time(string, format)
+    end
+  end
+
+  defp do_parse_time(<<unquote(match_basic_time), rest::binary>>, :basic)
+       when unquote(guard_time) do
+    {hour, minute, second} = unquote(read_time)
+    parse_formatted_time(hour, minute, second, rest)
+  end
+
+  defp do_parse_time(<<unquote(match_ext_time), rest::binary>>, :extended)
+       when unquote(guard_time) do
+    {hour, minute, second} = unquote(read_time)
+    parse_formatted_time(hour, minute, second, rest)
+  end
+
+  defp do_parse_time(_, _) do
+    {:error, :invalid_format}
+  end
+
+  defp parse_formatted_time(hour, minute, second, rest) do
+    with {microsecond, rest} <- parse_microsecond(rest),
+         {_offset, ""} <- parse_offset(rest) do
+      if valid_time?(hour, minute, second, microsecond) do
+        {:ok, {hour, minute, second, microsecond}}
+      else
+        {:error, :invalid_time}
+      end
+    else
+      _ -> {:error, :invalid_format}
+    end
+  end
+
+  @doc """
+  Parses a date `string` in the `:extended` format.
+
+  For more information on supported strings, see how this
+  module implements [ISO 8601](#module-iso-8601-compliance).
+
+  ## Examples
+
+      iex> Calendar.ISO.parse_date("2015-01-23")
+      {:ok, {2015, 1, 23}}
+
+      iex> Calendar.ISO.parse_date("2015:01:23")
+      {:error, :invalid_format}
+      iex> Calendar.ISO.parse_date("2015-01-32")
+      {:error, :invalid_date}
+
+  """
+  @doc since: "1.10.0"
+  @impl true
+  @spec parse_date(String.t()) ::
+          {:ok, {year, month, day}}
+          | {:error, atom}
+  def parse_date(string) when is_binary(string),
+    do: parse_date(string, :extended)
+
+  @doc """
+  Parses a date `string` according to a given `format`.
+
+  The `format` can either be `:basic` or `:extended`.
+
+  For more information on supported strings, see how this
+  module implements [ISO 8601](#module-iso-8601-compliance).
+
+  ## Examples
+
+      iex> Calendar.ISO.parse_date("20150123", :basic)
+      {:ok, {2015, 1, 23}}
+      iex> Calendar.ISO.parse_date("20150123", :extended)
+      {:error, :invalid_format}
+
+  """
+  @doc since: "1.12.0"
+  @spec parse_date(String.t(), format) ::
+          {:ok, {year, month, day}}
+          | {:error, atom}
+  def parse_date(string, format) when is_binary(string) and is_format(format),
+    do: parse_date_guarded(string, format)
+
+  defp parse_date_guarded("-" <> string, format),
+    do: do_parse_date(string, -1, format)
+
+  defp parse_date_guarded("+" <> string, format),
+    do: do_parse_date(string, 1, format)
+
+  defp parse_date_guarded(string, format),
+    do: do_parse_date(string, 1, format)
+
+  defp do_parse_date(unquote(match_basic_date), multiplier, :basic) when unquote(guard_date) do
+    {year, month, day} = unquote(read_date)
+    parse_formatted_date(year, month, day, multiplier)
+  end
+
+  defp do_parse_date(unquote(match_ext_date), multiplier, :extended) when unquote(guard_date) do
+    {year, month, day} = unquote(read_date)
+    parse_formatted_date(year, month, day, multiplier)
+  end
+
+  defp do_parse_date(_, _, _) do
+    {:error, :invalid_format}
+  end
+
+  defp parse_formatted_date(year, month, day, multiplier) do
+    year = multiplier * year
+
+    if valid_date?(year, month, day) do
+      {:ok, {year, month, day}}
+    else
+      {:error, :invalid_date}
+    end
+  end
+
+  @doc """
+  Parses a naive datetime `string` in the `:extended` format.
+
+  For more information on supported strings, see how this
+  module implements [ISO 8601](#module-iso-8601-compliance).
+
+  ## Examples
+
+      iex> Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07")
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}
+      iex> Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07Z")
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}
+      iex> Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07-02:30")
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}
+
+      iex> Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07.0")
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 1}}}
+      iex> Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07,0123456")
+      {:ok, {2015, 1, 23, 23, 50, 7, {12345, 6}}}
+
+  """
+  @doc since: "1.10.0"
+  @impl true
+  @spec parse_naive_datetime(String.t()) ::
+          {:ok, {year, month, day, hour, minute, second, microsecond}}
+          | {:error, atom}
+  def parse_naive_datetime(string) when is_binary(string),
+    do: parse_naive_datetime(string, :extended)
+
+  @doc """
+  Parses a naive datetime `string` according to a given `format`.
+
+  The `format` can either be `:basic` or `:extended`.
+
+  For more information on supported strings, see how this
+  module implements [ISO 8601](#module-iso-8601-compliance).
+
+  ## Examples
+
+      iex> Calendar.ISO.parse_naive_datetime("20150123 235007", :basic)
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}
+      iex> Calendar.ISO.parse_naive_datetime("20150123 235007", :extended)
+      {:error, :invalid_format}
+
+  """
+  @doc since: "1.12.0"
+  @spec parse_naive_datetime(String.t(), format) ::
+          {:ok, {year, month, day, hour, minute, second, microsecond}}
+          | {:error, atom}
+  def parse_naive_datetime(string, format) when is_binary(string) and is_format(format),
+    do: parse_naive_datetime_guarded(string, format)
+
+  defp parse_naive_datetime_guarded("-" <> string, format),
+    do: do_parse_naive_datetime(string, -1, format)
+
+  defp parse_naive_datetime_guarded("+" <> string, format),
+    do: do_parse_naive_datetime(string, 1, format)
+
+  defp parse_naive_datetime_guarded(string, format),
+    do: do_parse_naive_datetime(string, 1, format)
+
+  defp do_parse_naive_datetime(
+         <<unquote(match_basic_date), datetime_sep, unquote(match_basic_time), rest::binary>>,
+         multiplier,
+         :basic
+       )
+       when unquote(guard_date) and datetime_sep in @datetime_seps and unquote(guard_time) do
+    {year, month, day} = unquote(read_date)
+    {hour, minute, second} = unquote(read_time)
+    parse_formatted_naive_datetime(year, month, day, hour, minute, second, rest, multiplier)
+  end
+
+  defp do_parse_naive_datetime(
+         <<unquote(match_ext_date), datetime_sep, unquote(match_ext_time), rest::binary>>,
+         multiplier,
+         :extended
+       )
+       when unquote(guard_date) and datetime_sep in @datetime_seps and unquote(guard_time) do
+    {year, month, day} = unquote(read_date)
+    {hour, minute, second} = unquote(read_time)
+    parse_formatted_naive_datetime(year, month, day, hour, minute, second, rest, multiplier)
+  end
+
+  defp do_parse_naive_datetime(_, _, _) do
+    {:error, :invalid_format}
+  end
+
+  defp parse_formatted_naive_datetime(year, month, day, hour, minute, second, rest, multiplier) do
+    year = multiplier * year
+
+    with {microsecond, rest} <- parse_microsecond(rest),
+         {_offset, ""} <- parse_offset(rest) do
+      cond do
+        not valid_date?(year, month, day) ->
+          {:error, :invalid_date}
+
+        not valid_time?(hour, minute, second, microsecond) ->
+          {:error, :invalid_time}
+
+        true ->
+          {:ok, {year, month, day, hour, minute, second, microsecond}}
+      end
+    else
+      _ -> {:error, :invalid_format}
+    end
+  end
+
+  @doc """
+  Parses a UTC datetime `string` in the `:extended` format.
+
+  For more information on supported strings, see how this
+  module implements [ISO 8601](#module-iso-8601-compliance).
+
+  ## Examples
+
+      iex> Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:07Z")
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}, 0}
+
+      iex> Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:07+02:30")
+      {:ok, {2015, 1, 23, 21, 20, 7, {0, 0}}, 9000}
+
+      iex> Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:07")
+      {:error, :missing_offset}
+
+  """
+  @doc since: "1.10.0"
+  @impl true
+  @spec parse_utc_datetime(String.t()) ::
+          {:ok, {year, month, day, hour, minute, second, microsecond}, utc_offset}
+          | {:error, atom}
+  def parse_utc_datetime(string) when is_binary(string),
+    do: parse_utc_datetime(string, :extended)
+
+  @doc """
+  Parses a UTC datetime `string` according to a given `format`.
+
+  The `format` can either be `:basic` or `:extended`.
+
+  For more information on supported strings, see how this
+  module implements [ISO 8601](#module-iso-8601-compliance).
+
+  ## Examples
+
+      iex> Calendar.ISO.parse_utc_datetime("20150123 235007Z", :basic)
+      {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}, 0}
+      iex> Calendar.ISO.parse_utc_datetime("20150123 235007Z", :extended)
+      {:error, :invalid_format}
+
+  """
+  @doc since: "1.12.0"
+  @spec parse_utc_datetime(String.t(), format) ::
+          {:ok, {year, month, day, hour, minute, second, microsecond}, utc_offset}
+          | {:error, atom}
+  def parse_utc_datetime(string, format) when is_binary(string) and is_format(format),
+    do: parse_utc_datetime_guarded(string, format)
+
+  defp parse_utc_datetime_guarded("-" <> string, format),
+    do: do_parse_utc_datetime(string, -1, format)
+
+  defp parse_utc_datetime_guarded("+" <> string, format),
+    do: do_parse_utc_datetime(string, 1, format)
+
+  defp parse_utc_datetime_guarded(string, format),
+    do: do_parse_utc_datetime(string, 1, format)
+
+  defp do_parse_utc_datetime(
+         <<unquote(match_basic_date), datetime_sep, unquote(match_basic_time), rest::binary>>,
+         multiplier,
+         :basic
+       )
+       when unquote(guard_date) and datetime_sep in @datetime_seps and unquote(guard_time) do
+    {year, month, day} = unquote(read_date)
+    {hour, minute, second} = unquote(read_time)
+    parse_formatted_utc_datetime(year, month, day, hour, minute, second, rest, multiplier)
+  end
+
+  defp do_parse_utc_datetime(
+         <<unquote(match_ext_date), datetime_sep, unquote(match_ext_time), rest::binary>>,
+         multiplier,
+         :extended
+       )
+       when unquote(guard_date) and datetime_sep in @datetime_seps and unquote(guard_time) do
+    {year, month, day} = unquote(read_date)
+    {hour, minute, second} = unquote(read_time)
+    parse_formatted_utc_datetime(year, month, day, hour, minute, second, rest, multiplier)
+  end
+
+  defp do_parse_utc_datetime(_, _, _) do
+    {:error, :invalid_format}
+  end
+
+  defp parse_formatted_utc_datetime(year, month, day, hour, minute, second, rest, multiplier) do
+    year = multiplier * year
+
+    with {microsecond, rest} <- parse_microsecond(rest),
+         {offset, ""} <- parse_offset(rest) do
+      cond do
+        not valid_date?(year, month, day) ->
+          {:error, :invalid_date}
+
+        not valid_time?(hour, minute, second, microsecond) ->
+          {:error, :invalid_time}
+
+        offset == 0 ->
+          {:ok, {year, month, day, hour, minute, second, microsecond}, offset}
+
+        is_nil(offset) ->
+          {:error, :missing_offset}
+
+        true ->
+          day_fraction = time_to_day_fraction(hour, minute, second, {0, 0})
+
+          {{year, month, day}, {hour, minute, second, _}} =
+            case add_day_fraction_to_iso_days({0, day_fraction}, -offset, 86_400) do
+              {0, day_fraction} ->
+                {{year, month, day}, time_from_day_fraction(day_fraction)}
+
+              {extra_days, day_fraction} ->
+                base_days = date_to_iso_days(year, month, day)
+                {date_from_iso_days(base_days + extra_days), time_from_day_fraction(day_fraction)}
+            end
+
+          {:ok, {year, month, day, hour, minute, second, microsecond}, offset}
+      end
+    else
+      _ -> {:error, :invalid_format}
+    end
+  end
+
+  @doc """
+  Parses an ISO 8601 formatted duration string to a list of `Duration` compabitble unit pairs.
+
+  See `Duration.from_iso8601/1`.
+  """
+  @doc since: "1.17.0"
+  @spec parse_duration(String.t()) :: {:ok, [Duration.unit_pair()]} | {:error, atom}
+  def parse_duration("P" <> string) when byte_size(string) > 0 do
+    parse_duration_date(string, [], year: ?Y, month: ?M, week: ?W, day: ?D)
+  end
+
+  def parse_duration("+P" <> string) when byte_size(string) > 0 do
+    parse_duration_date(string, [], year: ?Y, month: ?M, week: ?W, day: ?D)
+  end
+
+  def parse_duration("-P" <> string) when byte_size(string) > 0 do
+    with {:ok, fields} <- parse_duration_date(string, [], year: ?Y, month: ?M, week: ?W, day: ?D) do
+      {:ok,
+       Enum.map(fields, fn
+         {:microsecond, {value, precision}} -> {:microsecond, {-value, precision}}
+         {unit, value} -> {unit, -value}
+       end)}
+    end
+  end
+
+  def parse_duration(_) do
+    {:error, :invalid_duration}
+  end
+
+  defp parse_duration_date("", acc, _allowed), do: {:ok, acc}
+
+  defp parse_duration_date("T" <> string, acc, _allowed) when byte_size(string) > 0 do
+    parse_duration_time(string, acc, hour: ?H, minute: ?M, second: ?S)
+  end
+
+  defp parse_duration_date(string, acc, allowed) do
+    with {integer, <<next, rest::binary>>} <- Integer.parse(string),
+         {key, allowed} <- find_unit(allowed, next) do
+      parse_duration_date(rest, [{key, integer} | acc], allowed)
+    else
+      _ -> {:error, :invalid_date_component}
+    end
+  end
+
+  defp parse_duration_time("", acc, _allowed), do: {:ok, acc}
+
+  defp parse_duration_time(string, acc, allowed) do
+    case Integer.parse(string) do
+      {second, <<delimiter, _::binary>> = rest} when delimiter in [?., ?,] ->
+        case parse_microsecond(rest) do
+          {{ms, precision}, "S"} ->
+            ms =
+              case string do
+                "-" <> _ ->
+                  -ms
+
+                _ ->
+                  ms
+              end
+
+            {:ok, [second: second, microsecond: {ms, precision}] ++ acc}
+
+          _ ->
+            {:error, :invalid_time_component}
+        end
+
+      {integer, <<next, rest::binary>>} ->
+        case find_unit(allowed, next) do
+          {key, allowed} -> parse_duration_time(rest, [{key, integer} | acc], allowed)
+          false -> {:error, :invalid_time_component}
+        end
+
+      _ ->
+        {:error, :invalid_time_component}
+    end
+  end
+
+  defp find_unit([{key, unit} | rest], unit), do: {key, rest}
+  defp find_unit([_ | rest], unit), do: find_unit(rest, unit)
+  defp find_unit([], _unit), do: false
+
+  @doc """
+  Returns the `t:Calendar.iso_days/0` format of the specified date.
+
+  ## Examples
+
+      iex> Calendar.ISO.naive_datetime_to_iso_days(0, 1, 1, 0, 0, 0, {0, 6})
+      {0, {0, 86400000000}}
+      iex> Calendar.ISO.naive_datetime_to_iso_days(2000, 1, 1, 12, 0, 0, {0, 6})
+      {730485, {43200000000, 86400000000}}
+      iex> Calendar.ISO.naive_datetime_to_iso_days(2000, 1, 1, 13, 0, 0, {0, 6})
+      {730485, {46800000000, 86400000000}}
+      iex> Calendar.ISO.naive_datetime_to_iso_days(-1, 1, 1, 0, 0, 0, {0, 6})
+      {-365, {0, 86400000000}}
+
+  """
+  @doc since: "1.5.0"
+  @impl true
+  @spec naive_datetime_to_iso_days(
+          Calendar.year(),
+          Calendar.month(),
+          Calendar.day(),
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond()
+        ) :: Calendar.iso_days()
+  def naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) do
+    {date_to_iso_days(year, month, day), time_to_day_fraction(hour, minute, second, microsecond)}
+  end
+
+  @doc """
+  Converts the `t:Calendar.iso_days/0` format to the datetime format specified by this calendar.
+
+  ## Examples
+
+      iex> Calendar.ISO.naive_datetime_from_iso_days({0, {0, 86_400}})
+      {0, 1, 1, 0, 0, 0, {0, 6}}
+      iex> Calendar.ISO.naive_datetime_from_iso_days({730_485, {0, 86_400}})
+      {2000, 1, 1, 0, 0, 0, {0, 6}}
+      iex> Calendar.ISO.naive_datetime_from_iso_days({730_485, {43_200, 86_400}})
+      {2000, 1, 1, 12, 0, 0, {0, 6}}
+      iex> Calendar.ISO.naive_datetime_from_iso_days({-365, {0, 86_400_000_000}})
+      {-1, 1, 1, 0, 0, 0, {0, 6}}
+
+  """
+  @doc since: "1.5.0"
+  @spec naive_datetime_from_iso_days(Calendar.iso_days()) :: {
+          Calendar.year(),
+          Calendar.month(),
+          Calendar.day(),
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond()
+        }
+  @impl true
+  def naive_datetime_from_iso_days({days, day_fraction}) do
+    {year, month, day} = date_from_iso_days(days)
+    {hour, minute, second, microsecond} = time_from_day_fraction(day_fraction)
+    {year, month, day, hour, minute, second, microsecond}
+  end
+
+  @doc """
+  Returns the normalized day fraction of the specified time.
+
+  ## Examples
+
+      iex> Calendar.ISO.time_to_day_fraction(0, 0, 0, {0, 6})
+      {0, 86400000000}
+      iex> Calendar.ISO.time_to_day_fraction(12, 34, 56, {123, 6})
+      {45296000123, 86400000000}
+
+  """
+  @doc since: "1.5.0"
+  @impl true
+  @spec time_to_day_fraction(
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond()
+        ) :: Calendar.day_fraction()
+  def time_to_day_fraction(0, 0, 0, {0, _}) do
+    {0, @parts_per_day}
+  end
+
+  def time_to_day_fraction(hour, minute, second, {microsecond, _}) do
+    combined_seconds = hour * @seconds_per_hour + minute * @seconds_per_minute + second
+    {combined_seconds * @microseconds_per_second + microsecond, @parts_per_day}
+  end
+
+  @doc """
+  Converts a day fraction to this Calendar's representation of time.
+
+  ## Examples
+
+      iex> Calendar.ISO.time_from_day_fraction({1, 2})
+      {12, 0, 0, {0, 6}}
+      iex> Calendar.ISO.time_from_day_fraction({13, 24})
+      {13, 0, 0, {0, 6}}
+
+  """
+  @doc since: "1.5.0"
+  @impl true
+  @spec time_from_day_fraction(Calendar.day_fraction()) ::
+          {hour(), minute(), second(), microsecond()}
+  def time_from_day_fraction({0, _}) do
+    {0, 0, 0, {0, 6}}
+  end
+
+  def time_from_day_fraction({parts_in_day, parts_per_day}) do
+    total_microseconds = divide_by_parts_per_day(parts_in_day, parts_per_day)
+
+    {hours, rest_microseconds1} =
+      div_rem(total_microseconds, @seconds_per_hour * @microseconds_per_second)
+
+    {minutes, rest_microseconds2} =
+      div_rem(rest_microseconds1, @seconds_per_minute * @microseconds_per_second)
+
+    {seconds, microseconds} = div_rem(rest_microseconds2, @microseconds_per_second)
+    {hours, minutes, seconds, {microseconds, 6}}
+  end
+
+  defp divide_by_parts_per_day(parts_in_day, @parts_per_day), do: parts_in_day
+
+  defp divide_by_parts_per_day(parts_in_day, parts_per_day),
+    do: div(parts_in_day * @parts_per_day, parts_per_day)
+
+  # Converts year, month, day to count of days since 0000-01-01.
+  @doc false
+  def date_to_iso_days(0, 1, 1), do: 0
+  def date_to_iso_days(1970, 1, 1), do: @unix_epoch_days
+
+  def date_to_iso_days(year, month, day) do
+    ensure_day_in_month!(year, month, day)
+
+    y = if month <= 2, do: year - 1, else: year
+    era = if y >= 0, do: div(y, @years_per_era), else: div(y - 399, @years_per_era)
+    year_of_era = y - era * @years_per_era
+    month_prime = if month > 2, do: month - 3, else: month + 9
+    day_of_year = div(@days_per_5_months * month_prime + 2, @months_per_cycle) + day - 1
+
+    day_of_era =
+      @days_per_year * year_of_era + div(year_of_era, 4) - div(year_of_era, 100) + day_of_year
+
+    era * @days_per_era + day_of_era + @march_1_offset
+  end
+
+  # Converts count of days since 0000-01-01 to {year, month, day} tuple.
+  @doc false
+  def date_from_iso_days(days) do
+    z = days - @march_1_offset
+    era = if z >= 0, do: div(z, @days_per_era), else: div(z - @days_per_era + 1, @days_per_era)
+    day_of_era = z - era * @days_per_era
+
+    year_of_era =
+      div(
+        day_of_era - div(day_of_era, @days_per_4_years) + div(day_of_era, @days_per_100_years) -
+          div(day_of_era, @days_per_era - 1),
+        @days_per_year
+      )
+
+    day_of_year =
+      day_of_era -
+        (@days_per_year * year_of_era + div(year_of_era, 4) - div(year_of_era, 100))
+
+    month_prime = div(@months_per_cycle * day_of_year + 2, @days_per_5_months)
+    day = day_of_year - div(@days_per_5_months * month_prime + 2, @months_per_cycle) + 1
+    month = if month_prime < 10, do: month_prime + 3, else: month_prime - 9
+    year = year_of_era + era * @years_per_era
+    year = if month <= 2, do: year + 1, else: year
+
+    {year, month, day}
+  end
+
+  defp div_rem(int1, int2) do
+    div = div(int1, int2)
+    rem = int1 - div * int2
+
+    if rem >= 0 do
+      {div, rem}
+    else
+      {div - 1, rem + int2}
+    end
+  end
+
+  defp floor_div_positive_divisor(int1, int2) when int1 >= 0, do: div(int1, int2)
+  defp floor_div_positive_divisor(int1, int2), do: -div(-int1 - 1, int2) - 1
+
+  @doc """
+  Returns how many days there are in the given year-month.
+
+  ## Examples
+
+      iex> Calendar.ISO.days_in_month(1900, 1)
+      31
+      iex> Calendar.ISO.days_in_month(1900, 2)
+      28
+      iex> Calendar.ISO.days_in_month(2000, 2)
+      29
+      iex> Calendar.ISO.days_in_month(2001, 2)
+      28
+      iex> Calendar.ISO.days_in_month(2004, 2)
+      29
+      iex> Calendar.ISO.days_in_month(2004, 4)
+      30
+      iex> Calendar.ISO.days_in_month(-1, 5)
+      31
+
+  """
+  @doc since: "1.4.0"
+  @spec days_in_month(year, month) :: 28..31
+  @impl true
+  def days_in_month(year, month) when is_year(year) and is_month(month) do
+    days_in_month_guarded(year, month)
+  end
+
+  defp days_in_month_guarded(year, 2) do
+    if leap_year?(year), do: 29, else: 28
+  end
+
+  defp days_in_month_guarded(_, month) when month in [4, 6, 9, 11], do: 30
+  defp days_in_month_guarded(_, _), do: 31
+
+  @doc """
+  Returns how many months there are in the given year.
+
+  ## Example
+
+      iex> Calendar.ISO.months_in_year(2004)
+      12
+
+  """
+  @doc since: "1.7.0"
+  @impl true
+  @spec months_in_year(year) :: 12
+  def months_in_year(year) when is_year(year) do
+    12
+  end
+
+  @doc """
+  Returns if the given year is a leap year.
+
+  ## Examples
+
+      iex> Calendar.ISO.leap_year?(2000)
+      true
+      iex> Calendar.ISO.leap_year?(2001)
+      false
+      iex> Calendar.ISO.leap_year?(2004)
+      true
+      iex> Calendar.ISO.leap_year?(1900)
+      false
+      iex> Calendar.ISO.leap_year?(-4)
+      true
+
+  """
+  @doc since: "1.3.0"
+  @spec leap_year?(year) :: boolean()
+  @impl true
+  def leap_year?(year) when is_year(year) do
+    rem(year, 4) === 0 and (rem(year, 100) !== 0 or rem(year, 400) === 0)
+  end
+
+  @doc false
+  @deprecated "Use Calendar.ISO.day_of_week/4 instead"
+  def day_of_week(year, month, day) do
+    day_of_week(year, month, day, :default) |> elem(0)
+  end
+
+  @doc """
+  Calculates the day of the week from the given `year`, `month`, and `day`.
+
+  It is an integer from 1 to 7, where 1 is the given `starting_on` weekday.
+  For example, if `starting_on` is set to `:monday`, then 1 is Monday and
+  7 is Sunday.
+
+  `starting_on` can also be `:default`, which is equivalent to `:monday`.
+
+  ## Examples
+
+      iex> Calendar.ISO.day_of_week(2016, 10, 31, :monday)
+      {1, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 1, :monday)
+      {2, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 2, :monday)
+      {3, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 3, :monday)
+      {4, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 4, :monday)
+      {5, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 5, :monday)
+      {6, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 6, :monday)
+      {7, 1, 7}
+      iex> Calendar.ISO.day_of_week(-99, 1, 31, :monday)
+      {4, 1, 7}
+
+      iex> Calendar.ISO.day_of_week(2016, 10, 31, :sunday)
+      {2, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 1, :sunday)
+      {3, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 2, :sunday)
+      {4, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 3, :sunday)
+      {5, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 4, :sunday)
+      {6, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 5, :sunday)
+      {7, 1, 7}
+      iex> Calendar.ISO.day_of_week(2016, 11, 6, :sunday)
+      {1, 1, 7}
+      iex> Calendar.ISO.day_of_week(-99, 1, 31, :sunday)
+      {5, 1, 7}
+
+      iex> Calendar.ISO.day_of_week(2016, 10, 31, :saturday)
+      {3, 1, 7}
+
+  """
+  @doc since: "1.11.0"
+  @spec day_of_week(year, month, day, :default | weekday) :: {day_of_week(), 1, 7}
+  @impl true
+  def day_of_week(year, month, day, starting_on) do
+    iso_days = date_to_iso_days(year, month, day)
+    {iso_days_to_day_of_week(iso_days, starting_on), 1, 7}
+  end
+
+  @doc false
+  def iso_days_to_day_of_week(iso_days, starting_on) do
+    Integer.mod(iso_days + day_of_week_offset(starting_on), 7) + 1
+  end
+
+  defp day_of_week_offset(:default), do: 5
+  defp day_of_week_offset(:wednesday), do: 3
+  defp day_of_week_offset(:thursday), do: 2
+  defp day_of_week_offset(:friday), do: 1
+  defp day_of_week_offset(:saturday), do: 0
+  defp day_of_week_offset(:sunday), do: 6
+  defp day_of_week_offset(:monday), do: 5
+  defp day_of_week_offset(:tuesday), do: 4
+
+  @doc """
+  Calculates the day of the year from the given `year`, `month`, and `day`.
+
+  It is an integer from 1 to 366.
+
+  ## Examples
+
+      iex> Calendar.ISO.day_of_year(2016, 1, 31)
+      31
+      iex> Calendar.ISO.day_of_year(-99, 2, 1)
+      32
+      iex> Calendar.ISO.day_of_year(2018, 2, 28)
+      59
+
+  """
+  @doc since: "1.8.0"
+  @spec day_of_year(year, month, day) :: day_of_year()
+  @impl true
+  def day_of_year(year, month, day) do
+    ensure_day_in_month!(year, month, day)
+    days_before_month(month) + leap_day_offset(year, month) + day
+  end
+
+  @doc """
+  Calculates the quarter of the year from the given `year`, `month`, and `day`.
+
+  It is an integer from 1 to 4.
+
+  ## Examples
+
+      iex> Calendar.ISO.quarter_of_year(2016, 1, 31)
+      1
+      iex> Calendar.ISO.quarter_of_year(2016, 4, 3)
+      2
+      iex> Calendar.ISO.quarter_of_year(-99, 9, 31)
+      3
+      iex> Calendar.ISO.quarter_of_year(2018, 12, 28)
+      4
+
+  """
+  @doc since: "1.8.0"
+  @spec quarter_of_year(year, month, day) :: quarter_of_year()
+  @impl true
+  def quarter_of_year(year, month, day)
+      when is_year(year) and is_month(month) and is_day(day) do
+    div(month - 1, 3) + 1
+  end
+
+  @doc """
+  Calculates the year and era from the given `year`.
+
+  The ISO calendar has two eras: the "current era" (CE) which
+  starts in year `1` and is defined as era `1`. And "before the current
+  era" (BCE) for those years less than `1`, defined as era `0`.
+
+  ## Examples
+
+      iex> Calendar.ISO.year_of_era(1)
+      {1, 1}
+      iex> Calendar.ISO.year_of_era(2018)
+      {2018, 1}
+      iex> Calendar.ISO.year_of_era(0)
+      {1, 0}
+      iex> Calendar.ISO.year_of_era(-1)
+      {2, 0}
+
+  """
+  @doc since: "1.8.0"
+  @spec year_of_era(year) :: {1..10_000, era}
+  def year_of_era(year) when is_year_CE(year), do: {year, 1}
+  def year_of_era(year) when is_year_BCE(year), do: {abs(year) + 1, 0}
+
+  @doc """
+  Calendar callback to compute the year and era from the
+  given `year`, `month` and `day`.
+
+  In the ISO calendar, the new year coincides with the new era,
+  so the `month` and `day` arguments are discarded. If you only
+  have the year available, you can `year_of_era/1` instead.
+
+  ## Examples
+
+      iex> Calendar.ISO.year_of_era(1, 1, 1)
+      {1, 1}
+      iex> Calendar.ISO.year_of_era(2018, 12, 1)
+      {2018, 1}
+      iex> Calendar.ISO.year_of_era(0, 1, 1)
+      {1, 0}
+      iex> Calendar.ISO.year_of_era(-1, 12, 1)
+      {2, 0}
+
+  """
+  @doc since: "1.13.0"
+  @impl true
+  @spec year_of_era(year, month, day) :: {1..10_000, era}
+  def year_of_era(year, _month, _day), do: year_of_era(year)
+
+  @doc """
+  Calculates the day and era from the given `year`, `month`, and `day`.
+
+  ## Examples
+
+      iex> Calendar.ISO.day_of_era(0, 1, 1)
+      {366, 0}
+      iex> Calendar.ISO.day_of_era(1, 1, 1)
+      {1, 1}
+      iex> Calendar.ISO.day_of_era(0, 12, 31)
+      {1, 0}
+      iex> Calendar.ISO.day_of_era(0, 12, 30)
+      {2, 0}
+      iex> Calendar.ISO.day_of_era(-1, 12, 31)
+      {367, 0}
+
+  """
+  @doc since: "1.8.0"
+  @spec day_of_era(year, month, day) :: Calendar.day_of_era()
+  @impl true
+  def day_of_era(year, month, day) when is_year_CE(year) do
+    day = date_to_iso_days(year, month, day) - @iso_epoch + 1
+    {day, 1}
+  end
+
+  def day_of_era(year, month, day) when is_year_BCE(year) do
+    day = abs(date_to_iso_days(year, month, day) - @iso_epoch)
+    {day, 0}
+  end
+
+  @doc """
+  Converts the given time into a string.
+
+  By default, returns times formatted in the "extended" format,
+  for human readability. It also supports the "basic" format
+  by passing the `:basic` option.
+
+  ## Examples
+
+      iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 6})
+      "02:02:02.000002"
+      iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 2})
+      "02:02:02.00"
+      iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 0})
+      "02:02:02"
+
+      iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 6}, :basic)
+      "020202.000002"
+      iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 6}, :extended)
+      "02:02:02.000002"
+
+  """
+  @impl true
+  @doc since: "1.5.0"
+  @spec time_to_string(
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond(),
+          :basic | :extended
+        ) :: String.t()
+  def time_to_string(
+        hour,
+        minute,
+        second,
+        microsecond,
+        format \\ :extended
+      ) do
+    time_to_iodata(hour, minute, second, microsecond, format)
+    |> IO.iodata_to_binary()
+  end
+
+  @doc """
+  Converts the given time into a iodata.
+
+  See `time_to_string/5` for more information.
+
+  ## Examples
+
+      iex> data = Calendar.ISO.time_to_iodata(2, 2, 2, {2, 6})
+      iex> IO.iodata_to_binary(data)
+      "02:02:02.000002"
+
+  """
+  @doc since: "1.19.0"
+  @spec time_to_iodata(
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond(),
+          :basic | :extended
+        ) :: iodata
+  def time_to_iodata(
+        hour,
+        minute,
+        second,
+        {ms_value, ms_precision} = microsecond,
+        format \\ :extended
+      )
+      when is_hour(hour) and is_minute(minute) and is_second(second) and
+             is_microsecond(ms_value, ms_precision) and format in [:basic, :extended] do
+    time_to_iodata_guarded(hour, minute, second, microsecond, format)
+  end
+
+  defp time_to_iodata_guarded(hour, minute, second, {_, 0}, format) do
+    time_to_iodata_format(hour, minute, second, format)
+  end
+
+  defp time_to_iodata_guarded(hour, minute, second, {microsecond, precision}, format) do
+    [
+      time_to_iodata_format(hour, minute, second, format),
+      ?.
+      | microseconds_to_iodata(microsecond, precision)
+    ]
+  end
+
+  @doc false
+  def microseconds_to_iodata(_microsecond, 0), do: []
+  def microseconds_to_iodata(microsecond, 6), do: zero_pad(microsecond, 6)
+
+  def microseconds_to_iodata(microsecond, precision) do
+    num = div(microsecond, scale_factor(precision))
+    zero_pad(num, precision)
+  end
+
+  defp scale_factor(1), do: 100_000
+  defp scale_factor(2), do: 10_000
+  defp scale_factor(3), do: 1_000
+  defp scale_factor(4), do: 100
+  defp scale_factor(5), do: 10
+  defp scale_factor(6), do: 1
+
+  defp time_to_iodata_format(hour, minute, second, :extended) do
+    [zero_pad(hour, 2), ?:, zero_pad(minute, 2), ?: | zero_pad(second, 2)]
+  end
+
+  defp time_to_iodata_format(hour, minute, second, :basic) do
+    [zero_pad(hour, 2), zero_pad(minute, 2) | zero_pad(second, 2)]
+  end
+
+  @doc """
+  Converts the given date into a string.
+
+  By default, returns dates formatted in the "extended" format,
+  for human readability. It also supports the "basic" format
+  by passing the `:basic` option.
+
+  ## Examples
+
+      iex> Calendar.ISO.date_to_string(2015, 2, 28)
+      "2015-02-28"
+      iex> Calendar.ISO.date_to_string(2017, 8, 1)
+      "2017-08-01"
+      iex> Calendar.ISO.date_to_string(-99, 1, 31)
+      "-0099-01-31"
+
+      iex> Calendar.ISO.date_to_string(2015, 2, 28, :basic)
+      "20150228"
+      iex> Calendar.ISO.date_to_string(-99, 1, 31, :basic)
+      "-00990131"
+
+  """
+  @doc since: "1.4.0"
+  @spec date_to_string(year, month, day, :basic | :extended) :: String.t()
+  @impl true
+  def date_to_string(year, month, day, format \\ :extended) do
+    date_to_iodata(year, month, day, format)
+    |> IO.iodata_to_binary()
+  end
+
+  @doc """
+  Converts the given date into a iodata.
+
+  See `date_to_string/4` for more information.
+
+  ## Examples
+
+      iex> data = Calendar.ISO.date_to_iodata(2015, 2, 28)
+      iex> IO.iodata_to_binary(data)
+      "2015-02-28"
+  """
+  @doc since: "1.19.0"
+  @spec date_to_iodata(year, month, day, :basic | :extended) :: iodata
+  def date_to_iodata(year, month, day, format \\ :extended)
+      when is_integer(year) and is_integer(month) and is_integer(day) and
+             format in [:basic, :extended] do
+    date_to_iodata_guarded(year, month, day, format)
+  end
+
+  defp date_to_iodata_guarded(year, month, day, :extended) do
+    [zero_pad(year, 4), ?-, zero_pad(month, 2), ?- | zero_pad(day, 2)]
+  end
+
+  defp date_to_iodata_guarded(year, month, day, :basic) do
+    [zero_pad(year, 4), zero_pad(month, 2) | zero_pad(day, 2)]
+  end
+
+  @doc """
+  Converts the datetime (without time zone) into a string.
+
+  By default, returns datetimes formatted in the "extended" format,
+  for human readability. It also supports the "basic" format
+  by passing the `:basic` option.
+
+  ## Examples
+
+      iex> Calendar.ISO.naive_datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 6})
+      "2015-02-28 01:02:03.000004"
+      iex> Calendar.ISO.naive_datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5})
+      "2017-08-01 01:02:03.00000"
+
+      iex> Calendar.ISO.naive_datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 6}, :basic)
+      "20150228 010203.000004"
+
+  """
+  @doc since: "1.4.0"
+  @impl true
+  @spec naive_datetime_to_string(
+          year,
+          month,
+          day,
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond(),
+          :basic | :extended
+        ) :: String.t()
+  def naive_datetime_to_string(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        format \\ :extended
+      ) do
+    naive_datetime_to_iodata(
+      year,
+      month,
+      day,
+      hour,
+      minute,
+      second,
+      microsecond,
+      format
+    )
+    |> IO.iodata_to_binary()
+  end
+
+  @doc """
+  Converts the given naive_datetime into a iodata.
+
+  See `naive_datetime_to_iodata/8` for more information.
+
+  ## Examples
+
+      iex> data = Calendar.ISO.naive_datetime_to_iodata(2015, 2, 28, 1, 2, 3, {4, 6}, :basic)
+      iex> IO.iodata_to_binary(data)
+      "20150228 010203.000004"
+
+      iex> data = Calendar.ISO.naive_datetime_to_iodata(2015, 2, 28, 1, 2, 3, {4, 6}, :extended)
+      iex> IO.iodata_to_binary(data)
+      "2015-02-28 01:02:03.000004"
+
+  """
+  @doc since: "1.19.0"
+  @spec naive_datetime_to_iodata(
+          year,
+          month,
+          day,
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond(),
+          :basic | :extended
+        ) :: iodata
+  def naive_datetime_to_iodata(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        format \\ :extended
+      ) do
+    [
+      date_to_iodata(year, month, day, format),
+      ?\s
+      | time_to_iodata(hour, minute, second, microsecond, format)
+    ]
+  end
+
+  @doc """
+  Converts the datetime (with time zone) into a string.
+
+  By default, returns datetimes formatted in the "extended" format,
+  for human readability. It also supports the "basic" format
+  by passing the `:basic` option.
+
+  ## Examples
+
+      iex> time_zone = "Etc/UTC"
+      iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, "UTC", 0, 0)
+      "2017-08-01 01:02:03.00000Z"
+      iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, "UTC", 3600, 0)
+      "2017-08-01 01:02:03.00000+01:00"
+      iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, "UTC", 3600, 3600)
+      "2017-08-01 01:02:03.00000+02:00"
+
+      iex> time_zone = "Europe/Berlin"
+      iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, "CET", 3600, 0)
+      "2017-08-01 01:02:03.00000+01:00 CET Europe/Berlin"
+      iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, "CDT", 3600, 3600)
+      "2017-08-01 01:02:03.00000+02:00 CDT Europe/Berlin"
+
+      iex> time_zone = "America/Los_Angeles"
+      iex> Calendar.ISO.datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 5}, time_zone, "PST", -28800, 0)
+      "2015-02-28 01:02:03.00000-08:00 PST America/Los_Angeles"
+      iex> Calendar.ISO.datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 5}, time_zone, "PDT", -28800, 3600)
+      "2015-02-28 01:02:03.00000-07:00 PDT America/Los_Angeles"
+
+      iex> time_zone = "Europe/Berlin"
+      iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, "CET", 3600, 0, :basic)
+      "20170801 010203.00000+0100 CET Europe/Berlin"
+
+  """
+  @doc since: "1.4.0"
+  @impl true
+  @spec datetime_to_string(
+          year,
+          month,
+          day,
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond(),
+          Calendar.time_zone(),
+          Calendar.zone_abbr(),
+          Calendar.utc_offset(),
+          Calendar.std_offset(),
+          :basic | :extended
+        ) :: String.t()
+  def datetime_to_string(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        time_zone,
+        zone_abbr,
+        utc_offset,
+        std_offset,
+        format \\ :extended
+      ) do
+    datetime_to_iodata(
+      year,
+      month,
+      day,
+      hour,
+      minute,
+      second,
+      microsecond,
+      time_zone,
+      zone_abbr,
+      utc_offset,
+      std_offset,
+      format
+    )
+    |> IO.iodata_to_binary()
+  end
+
+  @doc """
+  Converts the given datetime into a iodata.
+
+  See `datetime_to_iodata/12` for more information.
+
+  ## Examples
+
+      iex> time_zone = "Etc/UTC"
+      iex> data = Calendar.ISO.datetime_to_iodata(2017, 8, 1, 1, 2, 3, {4, 5}, time_zone, "UTC", 0, 0)
+      iex> IO.iodata_to_binary(data)
+      "2017-08-01 01:02:03.00000Z"
+
+  """
+  @doc since: "1.19.0"
+  @spec datetime_to_iodata(
+          year,
+          month,
+          day,
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond(),
+          Calendar.time_zone(),
+          Calendar.zone_abbr(),
+          Calendar.utc_offset(),
+          Calendar.std_offset(),
+          :basic | :extended
+        ) :: iodata
+  def datetime_to_iodata(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        time_zone,
+        zone_abbr,
+        utc_offset,
+        std_offset,
+        format \\ :extended
+      )
+      when is_time_zone(time_zone) and is_zone_abbr(zone_abbr) and is_utc_offset(utc_offset) and
+             is_std_offset(std_offset) do
+    [
+      date_to_iodata(year, month, day, format),
+      ?\s,
+      time_to_iodata(hour, minute, second, microsecond, format),
+      offset_to_iodata(utc_offset, std_offset, time_zone, format),
+      zone_to_iodata(utc_offset, std_offset, zone_abbr, time_zone)
+    ]
+  end
+
+  @doc false
+  def offset_to_string(0, 0, "Etc/UTC", _format), do: "Z"
+
+  def offset_to_string(utc, std, zone, format) do
+    offset_to_iodata(utc, std, zone, format)
+    |> IO.iodata_to_binary()
+  end
+
+  @doc false
+  def offset_to_iodata(0, 0, "Etc/UTC", _format), do: ?Z
+
+  def offset_to_iodata(utc, std, _zone, format) do
+    total = utc + std
+    second = abs(total)
+    minute = second |> rem(3600) |> div(60)
+    hour = div(second, 3600)
+    format_offset(total, hour, minute, format)
+  end
+
+  defp format_offset(total, hour, minute, :extended) do
+    [sign(total), zero_pad(hour, 2), ?: | zero_pad(minute, 2)]
+  end
+
+  defp format_offset(total, hour, minute, :basic) do
+    [sign(total), zero_pad(hour, 2) | zero_pad(minute, 2)]
+  end
+
+  defp zone_to_iodata(_, _, _, "Etc/UTC"), do: []
+  defp zone_to_iodata(_, _, abbr, zone), do: [?\s, abbr, ?\s | zone]
+
+  @doc """
+  Determines if the date given is valid according to the proleptic Gregorian calendar.
+
+  ## Examples
+
+      iex> Calendar.ISO.valid_date?(2015, 2, 28)
+      true
+      iex> Calendar.ISO.valid_date?(2015, 2, 30)
+      false
+      iex> Calendar.ISO.valid_date?(-1, 12, 31)
+      true
+      iex> Calendar.ISO.valid_date?(-1, 12, 32)
+      false
+
+  """
+  @doc since: "1.5.0"
+  @impl true
+  @spec valid_date?(year, month, day) :: boolean
+  def valid_date?(year, month, day)
+      when is_integer(year) and is_integer(month) and is_integer(day) do
+    is_month(month) and day in 1..days_in_month(year, month)
+  end
+
+  @doc """
+  Determines if the date given is valid according to the proleptic Gregorian calendar.
+
+  Leap seconds are not supported by the built-in Calendar.ISO.
+
+  ## Examples
+
+      iex> Calendar.ISO.valid_time?(10, 50, 25, {3006, 6})
+      true
+      iex> Calendar.ISO.valid_time?(23, 59, 60, {0, 0})
+      false
+      iex> Calendar.ISO.valid_time?(24, 0, 0, {0, 0})
+      false
+
+  """
+  @doc since: "1.5.0"
+  @impl true
+  @spec valid_time?(Calendar.hour(), Calendar.minute(), Calendar.second(), Calendar.microsecond()) ::
+          boolean
+  def valid_time?(hour, minute, second, {ms_value, ms_precision} = _microsecond)
+      when is_integer(hour) and is_integer(minute) and is_integer(second) and is_integer(ms_value) and
+             is_integer(ms_value) do
+    is_hour(hour) and is_minute(minute) and is_second(second) and
+      is_microsecond(ms_value, ms_precision)
+  end
+
+  @doc """
+  See `c:Calendar.day_rollover_relative_to_midnight_utc/0` for documentation.
+  """
+  @doc since: "1.5.0"
+  @impl true
+  @spec day_rollover_relative_to_midnight_utc() :: {0, 1}
+  def day_rollover_relative_to_midnight_utc() do
+    {0, 1}
+  end
+
+  defp sign(total) when total < 0, do: ?-
+  defp sign(_), do: ?+
+
+  defp zero_pad(val, count) when val >= 0 and count <= 6 do
+    num = Integer.to_string(val)
+
+    case max(count - byte_size(num), 0) do
+      0 -> num
+      1 -> ["0" | num]
+      2 -> ["00" | num]
+      3 -> ["000" | num]
+      4 -> ["0000" | num]
+      5 -> ["00000" | num]
+    end
+  end
+
+  defp zero_pad(val, count) do
+    [?- | zero_pad(-val, count)]
+  end
+
+  @doc """
+  Converts the `t:Calendar.iso_days/0` to the first moment of the day.
+
+  ## Examples
+
+      iex> Calendar.ISO.iso_days_to_beginning_of_day({0, {0, 86_400_000_000}})
+      {0, {0, 86400000000}}
+      iex> Calendar.ISO.iso_days_to_beginning_of_day({730_485, {43_200_000_000, 86_400_000_000}})
+      {730485, {0, 86400000000}}
+      iex> Calendar.ISO.iso_days_to_beginning_of_day({730_485, {46_800_000_000, 86_400_000_000}})
+      {730485, {0, 86400000000}}
+
+  """
+  @doc since: "1.15.0"
+  @impl true
+  @spec iso_days_to_beginning_of_day(Calendar.iso_days()) :: Calendar.iso_days()
+  def iso_days_to_beginning_of_day({days, _day_fraction}) do
+    {days, {0, @parts_per_day}}
+  end
+
+  @doc """
+  Converts the `t:Calendar.iso_days/0` to the last moment of the day.
+
+  ## Examples
+
+      iex> Calendar.ISO.iso_days_to_end_of_day({0, {0, 86_400_000_000}})
+      {0, {86399999999, 86400000000}}
+      iex> Calendar.ISO.iso_days_to_end_of_day({730_485, {43_200_000_000, 86_400_000_000}})
+      {730485, {86399999999, 86400000000}}
+      iex> Calendar.ISO.iso_days_to_end_of_day({730_485, {46_800_000_000, 86_400_000_000}})
+      {730485, {86399999999, 86400000000}}
+
+  """
+  @doc since: "1.15.0"
+  @impl true
+  @spec iso_days_to_end_of_day(Calendar.iso_days()) :: Calendar.iso_days()
+  def iso_days_to_end_of_day({days, _day_fraction}) do
+    {days, {@parts_per_day - 1, @parts_per_day}}
+  end
+
+  @doc """
+  Shifts Date by Duration according to its calendar.
+
+  ## Examples
+
+      iex> Calendar.ISO.shift_date(2016, 1, 3, Duration.new!(month: 2))
+      {2016, 3, 3}
+      iex> Calendar.ISO.shift_date(2016, 2, 29, Duration.new!(month: 1))
+      {2016, 3, 29}
+      iex> Calendar.ISO.shift_date(2016, 1, 31, Duration.new!(month: 1))
+      {2016, 2, 29}
+      iex> Calendar.ISO.shift_date(2016, 1, 31, Duration.new!(year: 4, day: 1))
+      {2020, 2, 1}
+  """
+  @impl true
+  @spec shift_date(year, month, day, Duration.t()) :: {year, month, day}
+  def shift_date(year, month, day, duration) do
+    shift_options = shift_date_options(duration)
+
+    Enum.reduce(shift_options, {year, month, day}, fn
+      {_, 0}, date ->
+        date
+
+      {:month, value}, date ->
+        shift_months(date, value)
+
+      {:day, value}, date ->
+        shift_days(date, value)
+    end)
+  end
+
+  @doc """
+  Shifts NaiveDateTime by Duration according to its calendar.
+
+  ## Examples
+
+      iex> Calendar.ISO.shift_naive_datetime(2016, 1, 3, 0, 0, 0, {0, 0}, Duration.new!(hour: 1))
+      {2016, 1, 3, 1, 0, 0, {0, 0}}
+      iex> Calendar.ISO.shift_naive_datetime(2016, 1, 3, 0, 0, 0, {0, 0}, Duration.new!(hour: 30))
+      {2016, 1, 4, 6, 0, 0, {0, 0}}
+      iex> Calendar.ISO.shift_naive_datetime(2016, 1, 3, 0, 0, 0, {0, 0}, Duration.new!(microsecond: {100, 6}))
+      {2016, 1, 3, 0, 0, 0, {100, 6}}
+  """
+  @impl true
+  @spec shift_naive_datetime(
+          year,
+          month,
+          day,
+          hour,
+          minute,
+          second,
+          microsecond,
+          Duration.t()
+        ) :: {year, month, day, hour, minute, second, microsecond}
+  def shift_naive_datetime(year, month, day, hour, minute, second, microsecond, duration) do
+    shift_options = shift_datetime_options(duration)
+
+    Enum.reduce(shift_options, {year, month, day, hour, minute, second, microsecond}, fn
+      {_, 0}, naive_datetime ->
+        naive_datetime
+
+      {:month, value}, {year, month, day, hour, minute, second, microsecond} ->
+        {new_year, new_month, new_day} = shift_months({year, month, day}, value)
+        {new_year, new_month, new_day, hour, minute, second, microsecond}
+
+      {time_unit, value}, naive_datetime ->
+        shift_time_unit(naive_datetime, value, time_unit)
+    end)
+  end
+
+  @doc """
+  Shifts Time by Duration units according to its calendar.
+
+  ## Examples
+
+      iex> Calendar.ISO.shift_time(13, 0, 0, {0, 0}, Duration.new!(hour: 2))
+      {15, 0, 0, {0, 0}}
+      iex> Calendar.ISO.shift_time(13, 0, 0, {0, 0}, Duration.new!(microsecond: {100, 6}))
+      {13, 0, 0, {100, 6}}
+  """
+  @impl true
+  @spec shift_time(hour, minute, second, microsecond, Duration.t()) ::
+          {hour, minute, second, microsecond}
+  def shift_time(hour, minute, second, microsecond, duration) do
+    shift_options = shift_time_options(duration)
+
+    Enum.reduce(shift_options, {hour, minute, second, microsecond}, fn
+      {_, 0}, time ->
+        time
+
+      {time_unit, value}, time ->
+        shift_time_unit(time, value, time_unit)
+    end)
+  end
+
+  @doc false
+  def shift_days({year, month, day}, days) do
+    {year, month, day} =
+      date_to_iso_days(year, month, day)
+      |> Kernel.+(days)
+      |> date_from_iso_days()
+
+    {year, month, day}
+  end
+
+  defp shift_months({year, month, day}, months) do
+    months_in_year = 12
+    total_months = year * months_in_year + month + months - 1
+
+    new_year = floor_div_positive_divisor(total_months, months_in_year)
+
+    new_month =
+      case rem(total_months, months_in_year) + 1 do
+        new_month when new_month < 1 -> new_month + months_in_year
+        new_month -> new_month
+      end
+
+    new_day = min(day, days_in_month(new_year, new_month))
+
+    {new_year, new_month, new_day}
+  end
+
+  @doc false
+  def shift_time_unit({year, month, day, hour, minute, second, microsecond}, value, unit)
+      when unit in [:second, :millisecond, :microsecond, :nanosecond] or is_integer(unit) do
+    {value, precision} = shift_time_unit_values(value, microsecond)
+
+    {year, month, day, hour, minute, second, {ms_value, _}} =
+      naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)
+      |> shift_time_unit(value, unit)
+      |> naive_datetime_from_iso_days()
+
+    {year, month, day, hour, minute, second, {ms_value, precision}}
+  end
+
+  def shift_time_unit({hour, minute, second, microsecond}, value, unit)
+      when unit in [:second, :millisecond, :microsecond, :nanosecond] or is_integer(unit) do
+    {value, precision} = shift_time_unit_values(value, microsecond)
+
+    {_days, day_fraction} =
+      shift_time_unit({0, time_to_day_fraction(hour, minute, second, microsecond)}, value, unit)
+
+    {hour, minute, second, {microsecond, _}} = time_from_day_fraction(day_fraction)
+
+    {hour, minute, second, {microsecond, precision}}
+  end
+
+  def shift_time_unit({_days, _day_fraction} = iso_days, value, unit)
+      when unit in [:second, :millisecond, :microsecond, :nanosecond] or is_integer(unit) do
+    ppd = System.convert_time_unit(86_400, :second, unit)
+    add_day_fraction_to_iso_days(iso_days, value, ppd)
+  end
+
+  defp shift_time_unit_values({0, _}, {_, original_precision}) do
+    {0, original_precision}
+  end
+
+  defp shift_time_unit_values({ms_value, ms_precision}, {_, _}) do
+    {ms_value, ms_precision}
+  end
+
+  defp shift_time_unit_values(value, {_, original_precision}) do
+    {value, original_precision}
+  end
+
+  defp shift_date_options(%Duration{
+         year: year,
+         month: month,
+         week: week,
+         day: day,
+         hour: 0,
+         minute: 0,
+         second: 0,
+         microsecond: {0, _precision}
+       }) do
+    [
+      month: year * 12 + month,
+      day: week * 7 + day
+    ]
+  end
+
+  defp shift_date_options(_duration) do
+    raise ArgumentError,
+          "cannot shift date by time scale unit. Expected :year, :month, :week, :day"
+  end
+
+  defp shift_datetime_options(%Duration{
+         year: year,
+         month: month,
+         week: week,
+         day: day,
+         hour: hour,
+         minute: minute,
+         second: second,
+         microsecond: microsecond
+       }) do
+    [
+      month: year * 12 + month,
+      second: week * 7 * 86_400 + day * 86_400 + hour * 3600 + minute * 60 + second,
+      microsecond: microsecond
+    ]
+  end
+
+  defp shift_time_options(%Duration{
+         year: 0,
+         month: 0,
+         week: 0,
+         day: 0,
+         hour: hour,
+         minute: minute,
+         second: second,
+         microsecond: microsecond
+       }) do
+    [
+      second: hour * 3600 + minute * 60 + second,
+      microsecond: microsecond
+    ]
+  end
+
+  defp shift_time_options(_duration) do
+    raise ArgumentError,
+          "cannot shift time by date scale unit. Expected :hour, :minute, :second, :microsecond"
+  end
+
+  ## Helpers
+
+  @doc false
+  def from_unix(integer, unit) when is_integer(integer) do
+    total = System.convert_time_unit(integer, unit, :microsecond)
+
+    if total in @unix_range_microseconds do
+      microseconds = Integer.mod(total, @microseconds_per_second)
+      seconds = @unix_epoch + floor_div_positive_divisor(total, @microseconds_per_second)
+      precision = precision_for_unit(unit)
+      {date, time} = iso_seconds_to_datetime(seconds)
+      {:ok, date, time, {microseconds, precision}}
+    else
+      {:error, :invalid_unix_time}
+    end
+  end
+
+  defp precision_for_unit(unit) do
+    case System.convert_time_unit(1, :second, unit) do
+      1 -> 0
+      10 -> 1
+      100 -> 2
+      1_000 -> 3
+      10_000 -> 4
+      100_000 -> 5
+      _ -> 6
+    end
+  end
+
+  defp parse_microsecond("." <> rest) do
+    case parse_microsecond(rest, 0, []) do
+      {[], 0, _} ->
+        :error
+
+      {microsecond, precision, rest} ->
+        scale = scale_factor(precision)
+        {{:erlang.list_to_integer(microsecond) * scale, precision}, rest}
+    end
+  end
+
+  defp parse_microsecond("," <> rest) do
+    parse_microsecond("." <> rest)
+  end
+
+  defp parse_microsecond(rest) do
+    {{0, 0}, rest}
+  end
+
+  defp parse_microsecond(<<head, tail::binary>>, 6, acc) when head in ?0..?9,
+    do: parse_microsecond(tail, 6, acc)
+
+  defp parse_microsecond(<<head, tail::binary>>, precision, acc) when head in ?0..?9,
+    do: parse_microsecond(tail, precision + 1, [head | acc])
+
+  defp parse_microsecond(rest, precision, acc) do
+    {:lists.reverse(acc), precision, rest}
+  end
+
+  defp parse_offset(""), do: {nil, ""}
+  defp parse_offset("Z"), do: {0, ""}
+  defp parse_offset("-00:00"), do: :error
+
+  defp parse_offset(<<?+, h1, h2, ?:, m1, m2, rest::binary>>),
+    do: parse_offset(1, h1, h2, m1, m2, rest)
+
+  defp parse_offset(<<?-, h1, h2, ?:, m1, m2, rest::binary>>),
+    do: parse_offset(-1, h1, h2, m1, m2, rest)
+
+  defp parse_offset(<<?+, h1, h2, m1, m2, rest::binary>>),
+    do: parse_offset(1, h1, h2, m1, m2, rest)
+
+  defp parse_offset(<<?-, h1, h2, m1, m2, rest::binary>>),
+    do: parse_offset(-1, h1, h2, m1, m2, rest)
+
+  defp parse_offset(<<?+, h1, h2, rest::binary>>), do: parse_offset(1, h1, h2, ?0, ?0, rest)
+  defp parse_offset(<<?-, h1, h2, rest::binary>>), do: parse_offset(-1, h1, h2, ?0, ?0, rest)
+  defp parse_offset(_), do: :error
+
+  defp parse_offset(sign, h1, h2, m1, m2, rest) do
+    with true <- h1 in ?0..?2 and h2 in ?0..?9,
+         true <- m1 in ?0..?5 and m2 in ?0..?9,
+         hour = (h1 - ?0) * 10 + h2 - ?0,
+         min = (m1 - ?0) * 10 + m2 - ?0,
+         true <- hour < 24 do
+      {(hour * 60 + min) * 60 * sign, rest}
+    else
+      _ -> :error
+    end
+  end
+
+  @doc false
+  def gregorian_seconds_to_iso_days(seconds, microsecond) do
+    {days, rest_seconds} = div_rem(seconds, @seconds_per_day)
+    microseconds_in_day = rest_seconds * @microseconds_per_second + microsecond
+    day_fraction = {microseconds_in_day, @parts_per_day}
+    {days, day_fraction}
+  end
+
+  @doc false
+  def iso_days_to_unit({days, {parts, ppd}}, unit) do
+    day_microseconds = days * @parts_per_day
+    microseconds = divide_by_parts_per_day(parts, ppd)
+    System.convert_time_unit(day_microseconds + microseconds, :microsecond, unit)
+  end
+
+  @doc false
+  def add_day_fraction_to_iso_days({days, {parts, ppd}}, add, ppd) do
+    normalize_iso_days(days, parts + add, ppd)
+  end
+
+  def add_day_fraction_to_iso_days({days, {parts, ppd}}, add, add_ppd) do
+    parts = parts * add_ppd
+    add = add * ppd
+    gcd = Integer.gcd(ppd, add_ppd)
+    result_parts = div(parts + add, gcd)
+    result_ppd = div(ppd * add_ppd, gcd)
+    normalize_iso_days(days, result_parts, result_ppd)
+  end
+
+  defp normalize_iso_days(days, parts, ppd) do
+    days_offset = div(parts, ppd)
+    parts = rem(parts, ppd)
+
+    if parts < 0 do
+      {days + days_offset - 1, {parts + ppd, ppd}}
+    else
+      {days + days_offset, {parts, ppd}}
+    end
+  end
+
+  defp leap_day_offset(_year, month) when month < 3, do: 0
+
+  defp leap_day_offset(year, _month) do
+    if leap_year?(year), do: 1, else: 0
+  end
+
+  defp days_before_month(1), do: 0
+  defp days_before_month(2), do: 31
+  defp days_before_month(3), do: 59
+  defp days_before_month(4), do: 90
+  defp days_before_month(5), do: 120
+  defp days_before_month(6), do: 151
+  defp days_before_month(7), do: 181
+  defp days_before_month(8), do: 212
+  defp days_before_month(9), do: 243
+  defp days_before_month(10), do: 273
+  defp days_before_month(11), do: 304
+  defp days_before_month(12), do: 334
+
+  defp iso_seconds_to_datetime(seconds) do
+    {days, rest_seconds} = div_rem(seconds, @seconds_per_day)
+
+    date = date_from_iso_days(days)
+    time = seconds_to_time(rest_seconds)
+    {date, time}
+  end
+
+  defp seconds_to_time(seconds) when seconds in 0..@last_second_of_the_day do
+    {hour, rest_seconds} = div_rem(seconds, @seconds_per_hour)
+    {minute, second} = div_rem(rest_seconds, @seconds_per_minute)
+
+    {hour, minute, second}
+  end
+
+  defp ensure_day_in_month!(year, month, day) when is_integer(day) do
+    if day < 1 or day > days_in_month(year, month) do
+      raise ArgumentError, "invalid date: #{date_to_string(year, month, day)}"
+    end
+  end
+end
diff --git a/lib/elixir/lib/calendar/naive_datetime.ex b/lib/elixir/lib/calendar/naive_datetime.ex
new file mode 100644
index 00000000000..732c8062270
--- /dev/null
+++ b/lib/elixir/lib/calendar/naive_datetime.ex
@@ -0,0 +1,1501 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule NaiveDateTime do
+  @moduledoc """
+  A NaiveDateTime struct (without a time zone) and functions.
+
+  The NaiveDateTime struct contains the fields year, month, day, hour,
+  minute, second, microsecond and calendar. New naive datetimes can be
+  built with the `new/2` and `new/8` functions or using the
+  `~N` (see `sigil_N/2`) sigil:
+
+      iex> ~N[2000-01-01 23:00:07]
+      ~N[2000-01-01 23:00:07]
+
+  The date and time fields in the struct can be accessed directly:
+
+      iex> naive = ~N[2000-01-01 23:00:07]
+      iex> naive.year
+      2000
+      iex> naive.second
+      7
+
+  We call them "naive" because this datetime representation does not
+  have a time zone. This means the datetime may not actually exist in
+  certain areas in the world even though it is valid.
+
+  For example, when daylight saving changes are applied by a region,
+  the clock typically moves forward or backward by one hour. This means
+  certain datetimes never occur or may occur more than once. Since
+  `NaiveDateTime` is not validated against a time zone, such errors
+  would go unnoticed.
+
+  Developers should avoid creating the NaiveDateTime structs directly
+  and instead, rely on the functions provided by this module as well
+  as the ones in third-party calendar libraries.
+
+  ## Comparing naive date times
+
+  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
+  and based on the `NaiveDateTime` struct fields. For proper comparison
+  between naive datetimes, use the `compare/2`, `after?/2` and `before?/2` functions.
+  The existence of the `compare/2` function in this module also allows
+  using `Enum.min/2` and `Enum.max/2` functions to get the minimum and
+  maximum naive datetime of an `Enum`. For example:
+
+      iex> Enum.min([~N[2020-01-01 23:00:07], ~N[2000-01-01 23:00:07]], NaiveDateTime)
+      ~N[2000-01-01 23:00:07]
+
+  ## Using epochs
+
+  The `add/3` and `diff/3` functions can be used for computing date
+  times or retrieving the number of seconds between instants.
+  For example, if there is an interest in computing the number of
+  seconds from the Unix epoch (1970-01-01 00:00:00):
+
+      iex> NaiveDateTime.diff(~N[2010-04-17 14:00:00], ~N[1970-01-01 00:00:00])
+      1271512800
+
+      iex> NaiveDateTime.add(~N[1970-01-01 00:00:00], 1_271_512_800)
+      ~N[2010-04-17 14:00:00]
+
+  Those functions are optimized to deal with common epochs, such
+  as the Unix Epoch above or the Gregorian Epoch (0000-01-01 00:00:00).
+  """
+
+  @enforce_keys [:year, :month, :day, :hour, :minute, :second]
+  defstruct [
+    :year,
+    :month,
+    :day,
+    :hour,
+    :minute,
+    :second,
+    microsecond: {0, 0},
+    calendar: Calendar.ISO
+  ]
+
+  @type t :: %__MODULE__{
+          year: Calendar.year(),
+          month: Calendar.month(),
+          day: Calendar.day(),
+          calendar: Calendar.calendar(),
+          hour: Calendar.hour(),
+          minute: Calendar.minute(),
+          second: Calendar.second(),
+          microsecond: Calendar.microsecond()
+        }
+
+  @seconds_per_day 24 * 60 * 60
+
+  @doc """
+  Returns the current naive datetime in UTC.
+
+  Prefer using `DateTime.utc_now/0` when possible as, opposite
+  to `NaiveDateTime`, it will keep the time zone information.
+
+  You can also provide a time unit to automatically truncate
+  the naive datetime. This is available since v1.15.0.
+
+  ## Examples
+
+      iex> naive_datetime = NaiveDateTime.utc_now()
+      iex> naive_datetime.year >= 2016
+      true
+
+      iex> naive_datetime = NaiveDateTime.utc_now(:second)
+      iex> naive_datetime.microsecond
+      {0, 0}
+
+  """
+  @doc since: "1.4.0"
+  @spec utc_now(Calendar.calendar() | :native | :microsecond | :millisecond | :second) :: t
+  def utc_now(calendar_or_time_unit \\ Calendar.ISO)
+
+  def utc_now(time_unit) when time_unit in [:microsecond, :millisecond, :second, :native] do
+    utc_now(time_unit, Calendar.ISO)
+  end
+
+  def utc_now(calendar) do
+    utc_now(:native, calendar)
+  end
+
+  @doc """
+  Returns the current naive datetime in UTC, supporting a specific
+  calendar and precision.
+
+  Prefer using `DateTime.utc_now/2` when possible as, opposite
+  to `NaiveDateTime`, it will keep the time zone information.
+
+  ## Examples
+
+      iex> naive_datetime = NaiveDateTime.utc_now(:second, Calendar.ISO)
+      iex> naive_datetime.year >= 2016
+      true
+
+      iex> naive_datetime = NaiveDateTime.utc_now(:second, Calendar.ISO)
+      iex> naive_datetime.microsecond
+      {0, 0}
+
+  """
+  @doc since: "1.15.0"
+  @spec utc_now(:native | :microsecond | :millisecond | :second, Calendar.calendar()) :: t
+  def utc_now(time_unit, calendar)
+      when time_unit in [:native, :microsecond, :millisecond, :second] do
+    {:ok, {year, month, day}, {hour, minute, second}, microsecond} =
+      Calendar.ISO.from_unix(System.os_time(time_unit), time_unit)
+
+    %NaiveDateTime{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      calendar: Calendar.ISO
+    }
+    |> convert!(calendar)
+  end
+
+  @doc """
+  Returns the "local time" for the machine the Elixir program is running on.
+
+  WARNING: This function can cause insidious bugs. It depends on the time zone
+  configuration at run time. This can changed and be set to a time zone that has
+  daylight saving jumps (spring forward or fall back).
+
+  This function can be used to display what the time is right now for the time
+  zone configuration that the machine happens to have. An example would be a
+  desktop program displaying a clock to the user. For any other uses it is
+  probably a bad idea to use this function.
+
+  For most cases, use `DateTime.now/2` or `DateTime.utc_now/1` instead.
+
+  Does not include fractional seconds.
+
+  ## Examples
+
+      iex> naive_datetime = NaiveDateTime.local_now()
+      iex> naive_datetime.year >= 2019
+      true
+
+  """
+  @doc since: "1.10.0"
+  @spec local_now(Calendar.calendar()) :: t
+  def local_now(calendar \\ Calendar.ISO)
+
+  def local_now(Calendar.ISO) do
+    {{year, month, day}, {hour, minute, second}} = :erlang.localtime()
+    {:ok, ndt} = NaiveDateTime.new(year, month, day, hour, minute, second)
+    ndt
+  end
+
+  def local_now(calendar) do
+    naive_datetime = local_now()
+
+    case convert(naive_datetime, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, :incompatible_calendars} ->
+        raise ArgumentError,
+              ~s(cannot get "local now" in target calendar #{inspect(calendar)}, ) <>
+                "reason: cannot convert from Calendar.ISO to #{inspect(calendar)}."
+    end
+  end
+
+  @doc """
+  Builds a new ISO naive datetime.
+
+  Expects all values to be integers. Returns `{:ok, naive_datetime}`
+  if each entry fits its appropriate range, returns `{:error, reason}`
+  otherwise.
+
+  ## Examples
+
+      iex> NaiveDateTime.new(2000, 1, 1, 0, 0, 0)
+      {:ok, ~N[2000-01-01 00:00:00]}
+      iex> NaiveDateTime.new(2000, 13, 1, 0, 0, 0)
+      {:error, :invalid_date}
+      iex> NaiveDateTime.new(2000, 2, 29, 0, 0, 0)
+      {:ok, ~N[2000-02-29 00:00:00]}
+      iex> NaiveDateTime.new(2000, 2, 30, 0, 0, 0)
+      {:error, :invalid_date}
+      iex> NaiveDateTime.new(2001, 2, 29, 0, 0, 0)
+      {:error, :invalid_date}
+
+      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1})
+      {:ok, ~N[2000-01-01 23:59:59.0]}
+      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 999_999)
+      {:ok, ~N[2000-01-01 23:59:59.999999]}
+      iex> NaiveDateTime.new(2000, 1, 1, 24, 59, 59, 999_999)
+      {:error, :invalid_time}
+      iex> NaiveDateTime.new(2000, 1, 1, 23, 60, 59, 999_999)
+      {:error, :invalid_time}
+      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 60, 999_999)
+      {:error, :invalid_time}
+      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 1_000_000)
+      {:error, :invalid_time}
+
+      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1}, Calendar.ISO)
+      {:ok, ~N[2000-01-01 23:59:59.0]}
+
+  """
+  @spec new(
+          Calendar.year(),
+          Calendar.month(),
+          Calendar.day(),
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond() | non_neg_integer(),
+          Calendar.calendar()
+        ) :: {:ok, t} | {:error, atom}
+  def new(year, month, day, hour, minute, second, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
+
+  def new(year, month, day, hour, minute, second, microsecond, calendar)
+      when is_integer(microsecond) do
+    new(year, month, day, hour, minute, second, {microsecond, 6}, calendar)
+  end
+
+  def new(year, month, day, hour, minute, second, microsecond, calendar) do
+    cond do
+      not calendar.valid_date?(year, month, day) ->
+        {:error, :invalid_date}
+
+      not calendar.valid_time?(hour, minute, second, microsecond) ->
+        {:error, :invalid_time}
+
+      true ->
+        naive_datetime = %NaiveDateTime{
+          calendar: calendar,
+          year: year,
+          month: month,
+          day: day,
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: microsecond
+        }
+
+        {:ok, naive_datetime}
+    end
+  end
+
+  @doc """
+  Builds a new ISO naive datetime.
+
+  Expects all values to be integers. Returns `naive_datetime`
+  if each entry fits its appropriate range, raises if
+  time or date is invalid.
+
+  ## Examples
+
+      iex> NaiveDateTime.new!(2000, 1, 1, 0, 0, 0)
+      ~N[2000-01-01 00:00:00]
+      iex> NaiveDateTime.new!(2000, 2, 29, 0, 0, 0)
+      ~N[2000-02-29 00:00:00]
+      iex> NaiveDateTime.new!(2000, 1, 1, 23, 59, 59, {0, 1})
+      ~N[2000-01-01 23:59:59.0]
+      iex> NaiveDateTime.new!(2000, 1, 1, 23, 59, 59, 999_999)
+      ~N[2000-01-01 23:59:59.999999]
+      iex> NaiveDateTime.new!(2000, 1, 1, 23, 59, 59, {0, 1}, Calendar.ISO)
+      ~N[2000-01-01 23:59:59.0]
+      iex> NaiveDateTime.new!(2000, 1, 1, 24, 59, 59, 999_999)
+      ** (ArgumentError) cannot build naive datetime, reason: :invalid_time
+
+  """
+  @doc since: "1.11.0"
+  @spec new!(
+          Calendar.year(),
+          Calendar.month(),
+          Calendar.day(),
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond() | non_neg_integer(),
+          Calendar.calendar()
+        ) :: t
+  def new!(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond \\ {0, 0},
+        calendar \\ Calendar.ISO
+      )
+
+  def new!(year, month, day, hour, minute, second, microsecond, calendar) do
+    case new(year, month, day, hour, minute, second, microsecond, calendar) do
+      {:ok, naive_datetime} ->
+        naive_datetime
+
+      {:error, reason} ->
+        raise ArgumentError, "cannot build naive datetime, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Builds a naive datetime from date and time structs.
+
+  ## Examples
+
+      iex> NaiveDateTime.new(~D[2010-01-13], ~T[23:00:07.005])
+      {:ok, ~N[2010-01-13 23:00:07.005]}
+
+  """
+  @spec new(Date.t(), Time.t()) :: {:ok, t}
+  def new(date, time)
+
+  def new(%Date{calendar: calendar} = date, %Time{calendar: calendar} = time) do
+    %{year: year, month: month, day: day} = date
+    %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time
+
+    naive_datetime = %NaiveDateTime{
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    }
+
+    {:ok, naive_datetime}
+  end
+
+  @doc """
+  Builds a naive datetime from date and time structs.
+
+  ## Examples
+
+      iex> NaiveDateTime.new!(~D[2010-01-13], ~T[23:00:07.005])
+      ~N[2010-01-13 23:00:07.005]
+
+  """
+  @doc since: "1.11.0"
+  @spec new!(Date.t(), Time.t()) :: t
+  def new!(date, time)
+
+  def new!(%Date{calendar: calendar} = date, %Time{calendar: calendar} = time) do
+    {:ok, naive_datetime} = new(date, time)
+    naive_datetime
+  end
+
+  @doc """
+  Adds a specified amount of time to a `NaiveDateTime`.
+
+  > #### Prefer `shift/2` {: .info}
+  >
+  > Prefer `shift/2` over `add/3`, as it offers a more ergonomic API.
+  >
+  > `add/3` provides a lower-level API which only supports fixed units
+  > such as `:hour` and `:second`, but not `:month` (as the exact length
+  > of a month depends on the current month). `add/3` always considers
+  > the unit to be computed according to the `Calendar.ISO`.
+
+  Accepts an `amount_to_add` in any `unit`. `unit` can be `:day`,
+  `:hour`, `:minute`, `:second` or any subsecond precision from
+  `t:System.time_unit/0` for convenience but ultimately they are
+  all converted to microseconds. Negative values will move backwards
+  in time and the default precision is `:second`.
+
+  ## Examples
+
+  It uses seconds by default:
+
+      # adds seconds by default
+      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2)
+      ~N[2014-10-02 00:29:12]
+
+      # accepts negative offsets
+      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], -2)
+      ~N[2014-10-02 00:29:08]
+
+  It can also work with subsecond precisions:
+
+      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2_000, :millisecond)
+      ~N[2014-10-02 00:29:12.000]
+
+  As well as days/hours/minutes:
+
+      iex> NaiveDateTime.add(~N[2015-02-28 00:29:10], 2, :day)
+      ~N[2015-03-02 00:29:10]
+      iex> NaiveDateTime.add(~N[2015-02-28 00:29:10], 36, :hour)
+      ~N[2015-03-01 12:29:10]
+      iex> NaiveDateTime.add(~N[2015-02-28 00:29:10], 60, :minute)
+      ~N[2015-02-28 01:29:10]
+
+  This operation merges the precision of the naive date time with the given unit:
+
+      iex> result = NaiveDateTime.add(~N[2014-10-02 00:29:10], 21, :millisecond)
+      ~N[2014-10-02 00:29:10.021]
+      iex> result.microsecond
+      {21000, 3}
+
+  Operations on top of gregorian seconds or the Unix epoch are optimized:
+
+      # from Gregorian seconds
+      iex> NaiveDateTime.add(~N[0000-01-01 00:00:00], 63_579_428_950)
+      ~N[2014-10-02 00:29:10]
+
+  Passing a `DateTime` automatically converts it to `NaiveDateTime`,
+  discarding the time zone information:
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> NaiveDateTime.add(dt, 21, :second)
+      ~N[2000-02-29 23:00:28]
+
+  """
+  @doc since: "1.4.0"
+  @spec add(Calendar.naive_datetime(), integer, :day | :hour | :minute | System.time_unit()) :: t
+  def add(naive_datetime, amount_to_add, unit \\ :second)
+
+  def add(naive_datetime, amount_to_add, :day) when is_integer(amount_to_add) do
+    add(naive_datetime, amount_to_add * 86400, :second)
+  end
+
+  def add(naive_datetime, amount_to_add, :hour) when is_integer(amount_to_add) do
+    add(naive_datetime, amount_to_add * 3600, :second)
+  end
+
+  def add(naive_datetime, amount_to_add, :minute) when is_integer(amount_to_add) do
+    add(naive_datetime, amount_to_add * 60, :second)
+  end
+
+  def add(
+        %{calendar: calendar, microsecond: {_, precision}} = naive_datetime,
+        amount_to_add,
+        unit
+      )
+      when is_integer(amount_to_add) do
+    if not is_integer(unit) and unit not in ~w(second millisecond microsecond nanosecond)a do
+      raise ArgumentError,
+            "unsupported time unit. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}"
+    end
+
+    precision = max(Calendar.ISO.time_unit_to_precision(unit), precision)
+
+    naive_datetime
+    |> to_iso_days()
+    |> Calendar.ISO.shift_time_unit(amount_to_add, unit)
+    |> from_iso_days(calendar, precision)
+  end
+
+  @doc """
+  Subtracts `naive_datetime2` from `naive_datetime1`.
+
+  The answer can be returned in any `:day`, `:hour`, `:minute`, or any `unit`
+  available from `t:System.time_unit/0`. The unit is measured according to
+  `Calendar.ISO` and defaults to `:second`.
+
+  Fractional results are not supported and are truncated.
+
+  ## Examples
+
+      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10])
+      2
+      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10], :microsecond)
+      2_000_000
+
+      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10.042], ~N[2014-10-02 00:29:10.021])
+      0
+      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10.042], ~N[2014-10-02 00:29:10.021], :millisecond)
+      21
+
+      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10], ~N[2014-10-02 00:29:12])
+      -2
+      iex> NaiveDateTime.diff(~N[-0001-10-02 00:29:10], ~N[-0001-10-02 00:29:12])
+      -2
+
+  It can also compute the difference in days, hours, or minutes:
+
+      iex> NaiveDateTime.diff(~N[2014-10-10 00:29:10], ~N[2014-10-02 00:29:10], :day)
+      8
+      iex> NaiveDateTime.diff(~N[2014-10-02 12:29:10], ~N[2014-10-02 00:29:10], :hour)
+      12
+      iex> NaiveDateTime.diff(~N[2014-10-02 00:39:10], ~N[2014-10-02 00:29:10], :minute)
+      10
+
+  But it also rounds incomplete days to zero:
+
+      iex> NaiveDateTime.diff(~N[2014-10-10 00:29:09], ~N[2014-10-02 00:29:10], :day)
+      7
+
+  """
+  @doc since: "1.4.0"
+  @spec diff(
+          Calendar.naive_datetime(),
+          Calendar.naive_datetime(),
+          :day | :hour | :minute | System.time_unit()
+        ) :: integer
+
+  def diff(naive_datetime1, naive_datetime2, unit \\ :second)
+
+  def diff(naive_datetime1, naive_datetime2, :day) do
+    diff(naive_datetime1, naive_datetime2, :second) |> div(86400)
+  end
+
+  def diff(naive_datetime1, naive_datetime2, :hour) do
+    diff(naive_datetime1, naive_datetime2, :second) |> div(3600)
+  end
+
+  def diff(naive_datetime1, naive_datetime2, :minute) do
+    diff(naive_datetime1, naive_datetime2, :second) |> div(60)
+  end
+
+  def diff(
+        %{calendar: calendar1} = naive_datetime1,
+        %{calendar: calendar2} = naive_datetime2,
+        unit
+      ) do
+    if not Calendar.compatible_calendars?(calendar1, calendar2) do
+      raise ArgumentError,
+            "cannot calculate the difference between #{inspect(naive_datetime1)} and " <>
+              "#{inspect(naive_datetime2)} because their calendars are not compatible " <>
+              "and thus the result would be ambiguous"
+    end
+
+    if not is_integer(unit) and
+         unit not in ~w(second millisecond microsecond nanosecond)a do
+      raise ArgumentError,
+            "unsupported time unit. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}"
+    end
+
+    units1 = naive_datetime1 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(unit)
+    units2 = naive_datetime2 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(unit)
+    units1 - units2
+  end
+
+  @doc """
+  Shifts given `naive_datetime` by `duration` according to its calendar.
+
+  Allowed units are: `:year`, `:month`, `:week`, `:day`, `:hour`, `:minute`, `:second`, `:microsecond`.
+
+  When using the default ISO calendar, durations are collapsed and
+  applied in the order of months, then seconds and microseconds:
+
+  * when shifting by 1 year and 2 months the date is actually shifted by 14 months
+  * weeks, days and smaller units are collapsed into seconds and microseconds
+
+  When shifting by month, days are rounded down to the nearest valid date.
+
+  ## Examples
+
+      iex> NaiveDateTime.shift(~N[2016-01-31 00:00:00], month: 1)
+      ~N[2016-02-29 00:00:00]
+      iex> NaiveDateTime.shift(~N[2016-01-31 00:00:00], year: 4, day: 1)
+      ~N[2020-02-01 00:00:00]
+      iex> NaiveDateTime.shift(~N[2016-01-31 00:00:00], year: -2, day: 1)
+      ~N[2014-02-01 00:00:00]
+      iex> NaiveDateTime.shift(~N[2016-01-31 00:00:00], second: 45)
+      ~N[2016-01-31 00:00:45]
+      iex> NaiveDateTime.shift(~N[2016-01-31 00:00:00], microsecond: {100, 6})
+      ~N[2016-01-31 00:00:00.000100]
+
+      # leap years
+      iex> NaiveDateTime.shift(~N[2024-02-29 00:00:00], year: 1)
+      ~N[2025-02-28 00:00:00]
+      iex> NaiveDateTime.shift(~N[2024-02-29 00:00:00], year: 4)
+      ~N[2028-02-29 00:00:00]
+
+      # rounding down
+      iex> NaiveDateTime.shift(~N[2015-01-31 00:00:00], month: 1)
+      ~N[2015-02-28 00:00:00]
+
+  """
+  @doc since: "1.17.0"
+  @spec shift(Calendar.naive_datetime(), Duration.duration()) :: t
+  def shift(%{calendar: calendar} = naive_datetime, duration) do
+    %{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    } = naive_datetime
+
+    {year, month, day, hour, minute, second, microsecond} =
+      calendar.shift_naive_datetime(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        __duration__!(duration)
+      )
+
+    %NaiveDateTime{
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    }
+  end
+
+  @doc false
+  defdelegate __duration__!(params), to: Duration, as: :new!
+
+  @doc """
+  Returns the given naive datetime with the microsecond field truncated to the
+  given precision (`:microsecond`, `:millisecond` or `:second`).
+
+  The given naive datetime is returned unchanged if it already has lower precision
+  than the given precision.
+
+  ## Examples
+
+      iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :microsecond)
+      ~N[2017-11-06 00:23:51.123456]
+
+      iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :millisecond)
+      ~N[2017-11-06 00:23:51.123]
+
+      iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :second)
+      ~N[2017-11-06 00:23:51]
+
+  """
+  @doc since: "1.6.0"
+  @spec truncate(t(), :microsecond | :millisecond | :second) :: t()
+  def truncate(%NaiveDateTime{microsecond: microsecond} = naive_datetime, precision) do
+    %{naive_datetime | microsecond: Calendar.truncate(microsecond, precision)}
+  end
+
+  def truncate(
+        %{
+          calendar: calendar,
+          year: year,
+          month: month,
+          day: day,
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: microsecond
+        },
+        precision
+      ) do
+    %NaiveDateTime{
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: Calendar.truncate(microsecond, precision)
+    }
+  end
+
+  @doc """
+  Converts a `NaiveDateTime` into a `Date`.
+
+  Because `Date` does not hold time information,
+  data will be lost during the conversion.
+
+  ## Examples
+
+      iex> NaiveDateTime.to_date(~N[2002-01-13 23:00:07])
+      ~D[2002-01-13]
+
+  """
+  @spec to_date(Calendar.naive_datetime()) :: Date.t()
+  def to_date(%{
+        year: year,
+        month: month,
+        day: day,
+        calendar: calendar,
+        hour: _,
+        minute: _,
+        second: _,
+        microsecond: _
+      }) do
+    %Date{year: year, month: month, day: day, calendar: calendar}
+  end
+
+  @doc """
+  Converts a `NaiveDateTime` into `Time`.
+
+  Because `Time` does not hold date information,
+  data will be lost during the conversion.
+
+  ## Examples
+
+      iex> NaiveDateTime.to_time(~N[2002-01-13 23:00:07])
+      ~T[23:00:07]
+
+  """
+  @spec to_time(Calendar.naive_datetime()) :: Time.t()
+  def to_time(%{
+        year: _,
+        month: _,
+        day: _,
+        calendar: calendar,
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond
+      }) do
+    %Time{
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      calendar: calendar
+    }
+  end
+
+  @doc """
+  Converts the given naive datetime to a string according to its calendar.
+
+  For readability, this function follows the RFC3339 suggestion of removing
+  the "T" separator between the date and time components.
+
+  ## Examples
+
+      iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13])
+      "2000-02-28 23:00:13"
+      iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13.001])
+      "2000-02-28 23:00:13.001"
+      iex> NaiveDateTime.to_string(~N[-0100-12-15 03:20:31])
+      "-0100-12-15 03:20:31"
+
+  This function can also be used to convert a DateTime to a string without
+  the time zone information:
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> NaiveDateTime.to_string(dt)
+      "2000-02-29 23:00:07"
+
+  """
+  @spec to_string(Calendar.naive_datetime()) :: String.t()
+  def to_string(%{calendar: calendar} = naive_datetime) do
+    %{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    } = naive_datetime
+
+    calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)
+  end
+
+  @doc """
+  Parses the extended "Date and time of day" format described by
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+
+  Time zone offset may be included in the string but they will be
+  simply discarded as such information is not included in naive date
+  times.
+
+  As specified in the standard, the separator "T" may be omitted if
+  desired as there is no ambiguity within this function.
+
+  Note leap seconds are not supported by the built-in Calendar.ISO.
+
+  ## Examples
+
+      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07")
+      {:ok, ~N[2015-01-23 23:50:07]}
+      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07")
+      {:ok, ~N[2015-01-23 23:50:07]}
+      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07Z")
+      {:ok, ~N[2015-01-23 23:50:07]}
+
+      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07.0")
+      {:ok, ~N[2015-01-23 23:50:07.0]}
+      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07,0123456")
+      {:ok, ~N[2015-01-23 23:50:07.012345]}
+      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07.0123456")
+      {:ok, ~N[2015-01-23 23:50:07.012345]}
+      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123Z")
+      {:ok, ~N[2015-01-23 23:50:07.123]}
+
+      iex> NaiveDateTime.from_iso8601("2015-01-23P23:50:07")
+      {:error, :invalid_format}
+      iex> NaiveDateTime.from_iso8601("2015:01:23 23-50-07")
+      {:error, :invalid_format}
+      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07A")
+      {:error, :invalid_format}
+      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:61")
+      {:error, :invalid_time}
+      iex> NaiveDateTime.from_iso8601("2015-01-32 23:50:07")
+      {:error, :invalid_date}
+
+      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123+02:30")
+      {:ok, ~N[2015-01-23 23:50:07.123]}
+      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123+00:00")
+      {:ok, ~N[2015-01-23 23:50:07.123]}
+      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-02:30")
+      {:ok, ~N[2015-01-23 23:50:07.123]}
+      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-00:00")
+      {:error, :invalid_format}
+      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-00:60")
+      {:error, :invalid_format}
+      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-24:00")
+      {:error, :invalid_format}
+
+  """
+  @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
+  def from_iso8601(string, calendar \\ Calendar.ISO) do
+    with {:ok, {year, month, day, hour, minute, second, microsecond}} <-
+           Calendar.ISO.parse_naive_datetime(string) do
+      convert(
+        %NaiveDateTime{
+          year: year,
+          month: month,
+          day: day,
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: microsecond
+        },
+        calendar
+      )
+    end
+  end
+
+  @doc """
+  Parses the extended "Date and time of day" format described by
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+
+  Raises if the format is invalid.
+
+  ## Examples
+
+      iex> NaiveDateTime.from_iso8601!("2015-01-23T23:50:07.123Z")
+      ~N[2015-01-23 23:50:07.123]
+      iex> NaiveDateTime.from_iso8601!("2015-01-23T23:50:07,123Z")
+      ~N[2015-01-23 23:50:07.123]
+      iex> NaiveDateTime.from_iso8601!("2015-01-23P23:50:07")
+      ** (ArgumentError) cannot parse "2015-01-23P23:50:07" as naive datetime, reason: :invalid_format
+
+  """
+  @spec from_iso8601!(String.t(), Calendar.calendar()) :: t
+  def from_iso8601!(string, calendar \\ Calendar.ISO) do
+    case from_iso8601(string, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "cannot parse #{inspect(string)} as naive datetime, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Converts the given naive datetime to
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+
+  By default, `NaiveDateTime.to_iso8601/2` returns naive datetimes formatted in the "extended"
+  format, for human readability. It also supports the "basic" format through passing the `:basic` option.
+
+  Only supports converting naive datetimes which are in the ISO calendar,
+  attempting to convert naive datetimes from other calendars will raise.
+
+  ## Examples
+
+      iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13])
+      "2000-02-28T23:00:13"
+
+      iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001])
+      "2000-02-28T23:00:13.001"
+
+      iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001], :basic)
+      "20000228T230013.001"
+
+  This function can also be used to convert a DateTime to ISO 8601 without
+  the time zone information:
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> NaiveDateTime.to_iso8601(dt)
+      "2000-02-29T23:00:07"
+
+  """
+  @spec to_iso8601(Calendar.naive_datetime(), :basic | :extended) :: String.t()
+  def to_iso8601(naive_datetime, format \\ :extended)
+
+  def to_iso8601(%{calendar: Calendar.ISO} = naive_datetime, format)
+      when format in [:basic, :extended] do
+    naive_datetime
+    |> to_iso8601_iodata(format)
+    |> IO.iodata_to_binary()
+  end
+
+  def to_iso8601(%{calendar: _} = naive_datetime, format)
+      when format in [:basic, :extended] do
+    naive_datetime
+    |> convert!(Calendar.ISO)
+    |> to_iso8601(format)
+  end
+
+  defp to_iso8601_iodata(naive_datetime, format) do
+    %{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    } = naive_datetime
+
+    [
+      Calendar.ISO.date_to_iodata(year, month, day, format),
+      ?T,
+      Calendar.ISO.time_to_iodata(hour, minute, second, microsecond, format)
+    ]
+  end
+
+  @doc """
+  Converts a `NaiveDateTime` struct to an Erlang datetime tuple.
+
+  Only supports converting naive datetimes which are in the ISO calendar,
+  attempting to convert naive datetimes from other calendars will raise.
+
+  WARNING: Loss of precision may occur, as Erlang time tuples only store
+  hour/minute/second.
+
+  ## Examples
+
+      iex> NaiveDateTime.to_erl(~N[2000-01-01 13:30:15])
+      {{2000, 1, 1}, {13, 30, 15}}
+
+  This function can also be used to convert a DateTime to an Erlang
+  datetime tuple without the time zone information:
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> NaiveDateTime.to_erl(dt)
+      {{2000, 2, 29}, {23, 00, 07}}
+
+  """
+  @spec to_erl(Calendar.naive_datetime()) :: :calendar.datetime()
+  def to_erl(%{calendar: _} = naive_datetime) do
+    %{year: year, month: month, day: day, hour: hour, minute: minute, second: second} =
+      convert!(naive_datetime, Calendar.ISO)
+
+    {{year, month, day}, {hour, minute, second}}
+  end
+
+  @doc """
+  Converts an Erlang datetime tuple to a `NaiveDateTime` struct.
+
+  Attempting to convert an invalid ISO calendar date will produce an error tuple.
+
+  ## Examples
+
+      iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}})
+      {:ok, ~N[2000-01-01 13:30:15]}
+      iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}}, 5000)
+      {:ok, ~N[2000-01-01 13:30:15.005000]}
+      iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})
+      {:ok, ~N[2000-01-01 13:30:15.005]}
+      iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})
+      {:error, :invalid_date}
+      iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})
+      {:error, :invalid_date}
+
+  """
+  @spec from_erl(
+          :calendar.datetime(),
+          Calendar.microsecond() | non_neg_integer(),
+          Calendar.calendar()
+        ) ::
+          {:ok, t} | {:error, atom}
+  def from_erl(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
+
+  def from_erl({{year, month, day}, {hour, minute, second}}, microsecond, calendar) do
+    with {:ok, iso_naive_dt} <- new(year, month, day, hour, minute, second, microsecond),
+         do: convert(iso_naive_dt, calendar)
+  end
+
+  @doc """
+  Converts an Erlang datetime tuple to a `NaiveDateTime` struct.
+
+  Raises if the datetime is invalid.
+  Attempting to convert an invalid ISO calendar date will produce an error tuple.
+
+  ## Examples
+
+      iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}})
+      ~N[2000-01-01 13:30:15]
+      iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}}, 5000)
+      ~N[2000-01-01 13:30:15.005000]
+      iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})
+      ~N[2000-01-01 13:30:15.005]
+      iex> NaiveDateTime.from_erl!({{2000, 13, 1}, {13, 30, 15}})
+      ** (ArgumentError) cannot convert {{2000, 13, 1}, {13, 30, 15}} to naive datetime, reason: :invalid_date
+
+  """
+  @spec from_erl!(
+          :calendar.datetime(),
+          Calendar.microsecond() | non_neg_integer(),
+          Calendar.calendar()
+        ) :: t
+  def from_erl!(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO) do
+    case from_erl(tuple, microsecond, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "cannot convert #{inspect(tuple)} to naive datetime, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Converts a number of gregorian seconds to a `NaiveDateTime` struct.
+
+  ## Examples
+
+      iex> NaiveDateTime.from_gregorian_seconds(1)
+      ~N[0000-01-01 00:00:01]
+      iex> NaiveDateTime.from_gregorian_seconds(63_755_511_991, {5000, 3})
+      ~N[2020-05-01 00:26:31.005]
+      iex> NaiveDateTime.from_gregorian_seconds(-1)
+      ~N[-0001-12-31 23:59:59]
+
+  """
+  @doc since: "1.11.0"
+  @spec from_gregorian_seconds(integer(), Calendar.microsecond(), Calendar.calendar()) :: t
+  def from_gregorian_seconds(seconds, microsecond_precision \\ {0, 0}, calendar \\ Calendar.ISO)
+
+  def from_gregorian_seconds(seconds, {microsecond, precision}, Calendar.ISO)
+      when is_integer(seconds) do
+    {days, seconds} = div_rem(seconds, 24 * 60 * 60)
+    {hours, seconds} = div_rem(seconds, 60 * 60)
+    {minutes, seconds} = div_rem(seconds, 60)
+    {year, month, day} = Calendar.ISO.date_from_iso_days(days)
+
+    %NaiveDateTime{
+      calendar: Calendar.ISO,
+      year: year,
+      month: month,
+      day: day,
+      hour: hours,
+      minute: minutes,
+      second: seconds,
+      microsecond: {microsecond, precision}
+    }
+  end
+
+  def from_gregorian_seconds(seconds, {microsecond, precision}, calendar)
+      when is_integer(seconds) do
+    iso_days = Calendar.ISO.gregorian_seconds_to_iso_days(seconds, microsecond)
+
+    {year, month, day, hour, minute, second, {microsecond, _}} =
+      calendar.naive_datetime_from_iso_days(iso_days)
+
+    %NaiveDateTime{
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: {microsecond, precision}
+    }
+  end
+
+  defp div_rem(int1, int2) do
+    div = div(int1, int2)
+    rem = int1 - div * int2
+
+    if rem >= 0 do
+      {div, rem}
+    else
+      {div - 1, rem + int2}
+    end
+  end
+
+  @doc """
+  Converts a `NaiveDateTime` struct to a number of gregorian seconds and microseconds.
+
+  ## Examples
+
+      iex> NaiveDateTime.to_gregorian_seconds(~N[0000-01-01 00:00:01])
+      {1, 0}
+      iex> NaiveDateTime.to_gregorian_seconds(~N[2020-05-01 00:26:31.005])
+      {63_755_511_991, 5000}
+
+  """
+  @doc since: "1.11.0"
+  @spec to_gregorian_seconds(Calendar.naive_datetime()) :: {integer(), non_neg_integer()}
+  def to_gregorian_seconds(%{
+        calendar: calendar,
+        year: year,
+        month: month,
+        day: day,
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: {microsecond, precision}
+      }) do
+    {days, day_fraction} =
+      calendar.naive_datetime_to_iso_days(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        {microsecond, precision}
+      )
+
+    seconds_in_day = seconds_from_day_fraction(day_fraction)
+    {days * @seconds_per_day + seconds_in_day, microsecond}
+  end
+
+  @doc """
+  Compares two `NaiveDateTime` structs.
+
+  Returns `:gt` if first is later than the second
+  and `:lt` for vice versa. If the two NaiveDateTime
+  are equal `:eq` is returned.
+
+  ## Examples
+
+      iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15], ~N[2016-04-28 16:19:25])
+      :lt
+      iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15.1], ~N[2016-04-16 13:30:15.01])
+      :gt
+
+  This function can also be used to compare a DateTime without
+  the time zone information:
+
+      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
+      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
+      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
+      iex> NaiveDateTime.compare(dt, ~N[2000-02-29 23:00:07])
+      :eq
+      iex> NaiveDateTime.compare(dt, ~N[2000-01-29 23:00:07])
+      :gt
+      iex> NaiveDateTime.compare(dt, ~N[2000-03-29 23:00:07])
+      :lt
+
+  """
+  @doc since: "1.4.0"
+  @spec compare(Calendar.naive_datetime(), Calendar.naive_datetime()) :: :lt | :eq | :gt
+  def compare(%{calendar: calendar1} = naive_datetime1, %{calendar: calendar2} = naive_datetime2) do
+    if Calendar.compatible_calendars?(calendar1, calendar2) do
+      case {to_iso_days(naive_datetime1), to_iso_days(naive_datetime2)} do
+        {first, second} when first > second -> :gt
+        {first, second} when first < second -> :lt
+        _ -> :eq
+      end
+    else
+      raise ArgumentError, """
+      cannot compare #{inspect(naive_datetime1)} with #{inspect(naive_datetime2)}.
+
+      This comparison would be ambiguous as their calendars have incompatible day rollover moments.
+      Specify an exact time of day (using `DateTime`s) to resolve this ambiguity
+      """
+    end
+  end
+
+  @doc """
+  Returns `true` if the first `NaiveDateTime` is strictly earlier than the second.
+
+  ## Examples
+
+      iex> NaiveDateTime.before?(~N[2021-01-01 11:00:00], ~N[2022-02-02 11:00:00])
+      true
+      iex> NaiveDateTime.before?(~N[2021-01-01 11:00:00], ~N[2021-01-01 11:00:00])
+      false
+      iex> NaiveDateTime.before?(~N[2022-02-02 11:00:00], ~N[2021-01-01 11:00:00])
+      false
+
+  """
+  @doc since: "1.15.0"
+  @spec before?(Calendar.naive_datetime(), Calendar.naive_datetime()) :: boolean()
+  def before?(naive_datetime1, naive_datetime2) do
+    compare(naive_datetime1, naive_datetime2) == :lt
+  end
+
+  @doc """
+  Returns `true` if the first `NaiveDateTime` is strictly later than the second.
+
+  ## Examples
+
+      iex> NaiveDateTime.after?(~N[2022-02-02 11:00:00], ~N[2021-01-01 11:00:00])
+      true
+      iex> NaiveDateTime.after?(~N[2021-01-01 11:00:00], ~N[2021-01-01 11:00:00])
+      false
+      iex> NaiveDateTime.after?(~N[2021-01-01 11:00:00], ~N[2022-02-02 11:00:00])
+      false
+
+  """
+  @doc since: "1.15.0"
+  @spec after?(Calendar.naive_datetime(), Calendar.naive_datetime()) :: boolean()
+  def after?(naive_datetime1, naive_datetime2) do
+    compare(naive_datetime1, naive_datetime2) == :gt
+  end
+
+  @doc """
+  Converts the given `naive_datetime` from one calendar to another.
+
+  If it is not possible to convert unambiguously between the calendars
+  (see `Calendar.compatible_calendars?/2`), an `{:error, :incompatible_calendars}` tuple
+  is returned.
+
+  ## Examples
+
+  Imagine someone implements `Calendar.Holocene`, a calendar based on the
+  Gregorian calendar that adds exactly 10 000 years to the current Gregorian
+  year:
+
+      iex> NaiveDateTime.convert(~N[2000-01-01 13:30:15], Calendar.Holocene)
+      {:ok, %NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,
+                           hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}
+
+  """
+  @doc since: "1.5.0"
+  @spec convert(Calendar.naive_datetime(), Calendar.calendar()) ::
+          {:ok, t} | {:error, :incompatible_calendars}
+
+  # Keep it multiline for proper function clause errors.
+  def convert(%NaiveDateTime{calendar: calendar} = ndt, calendar) do
+    {:ok, ndt}
+  end
+
+  def convert(
+        %{
+          calendar: calendar,
+          year: year,
+          month: month,
+          day: day,
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: microsecond
+        },
+        calendar
+      ) do
+    naive_datetime = %NaiveDateTime{
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    }
+
+    {:ok, naive_datetime}
+  end
+
+  def convert(%{calendar: ndt_calendar, microsecond: {_, precision}} = naive_datetime, calendar) do
+    if Calendar.compatible_calendars?(ndt_calendar, calendar) do
+      result_naive_datetime =
+        naive_datetime
+        |> to_iso_days()
+        |> from_iso_days(calendar, precision)
+
+      {:ok, result_naive_datetime}
+    else
+      {:error, :incompatible_calendars}
+    end
+  end
+
+  @doc """
+  Converts the given `naive_datetime` from one calendar to another.
+
+  If it is not possible to convert unambiguously between the calendars
+  (see `Calendar.compatible_calendars?/2`), an ArgumentError is raised.
+
+  ## Examples
+
+  Imagine someone implements `Calendar.Holocene`, a calendar based on the
+  Gregorian calendar that adds exactly 10 000 years to the current Gregorian
+  year:
+
+      iex> NaiveDateTime.convert!(~N[2000-01-01 13:30:15], Calendar.Holocene)
+      %NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,
+                     hour: 13, minute: 30, second: 15, microsecond: {0, 0}}
+
+  """
+  @doc since: "1.5.0"
+  @spec convert!(Calendar.naive_datetime(), Calendar.calendar()) :: t
+  def convert!(naive_datetime, calendar) do
+    case convert(naive_datetime, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, :incompatible_calendars} ->
+        raise ArgumentError,
+              "cannot convert #{inspect(naive_datetime)} to target calendar #{inspect(calendar)}, " <>
+                "reason: #{inspect(naive_datetime.calendar)} and #{inspect(calendar)} " <>
+                "have different day rollover moments, making this conversion ambiguous"
+    end
+  end
+
+  @doc """
+  Calculates a `NaiveDateTime` that is the first moment for the given `NaiveDateTime`.
+
+  To calculate the beginning of day of a `DateTime`, call this function, then convert back to a `DateTime`:
+
+      datetime
+      |> NaiveDateTime.beginning_of_day()
+      |> DateTime.from_naive(datetime.time_zone)
+
+  Note that the beginning of the day may not exist or be ambiguous
+  in a given timezone, so you must handle those cases accordingly.
+
+  ## Examples
+
+      iex> NaiveDateTime.beginning_of_day(~N[2000-01-01 23:00:07.123456])
+      ~N[2000-01-01 00:00:00.000000]
+
+  """
+  @doc since: "1.15.0"
+  @spec beginning_of_day(Calendar.naive_datetime()) :: t
+  def beginning_of_day(%{calendar: calendar, microsecond: {_, precision}} = naive_datetime) do
+    naive_datetime
+    |> to_iso_days()
+    |> calendar.iso_days_to_beginning_of_day()
+    |> from_iso_days(calendar, precision)
+  end
+
+  @doc """
+  Calculates a `NaiveDateTime` that is the last moment for the given `NaiveDateTime`.
+
+  To calculate the end of day of a `DateTime`, call this function, then convert back to a `DateTime`:
+
+      datetime
+      |> NaiveDateTime.end_of_day()
+      |> DateTime.from_naive(datetime.time_zone)
+
+  Note that the end of the day may not exist or be ambiguous
+  in a given timezone, so you must handle those cases accordingly.
+
+  ## Examples
+
+      iex> NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07.123456])
+      ~N[2000-01-01 23:59:59.999999]
+
+  """
+  @doc since: "1.15.0"
+  @spec end_of_day(Calendar.naive_datetime()) :: t
+  def end_of_day(%{calendar: calendar, microsecond: {_, precision}} = naive_datetime) do
+    end_of_day =
+      naive_datetime
+      |> to_iso_days()
+      |> calendar.iso_days_to_end_of_day()
+      |> from_iso_days(calendar, precision)
+
+    %{microsecond: {microsecond, precision}} = end_of_day
+
+    multiplier = 10 ** (6 - precision)
+
+    %{end_of_day | microsecond: {div(microsecond, multiplier) * multiplier, precision}}
+  end
+
+  ## Helpers
+
+  defp seconds_from_day_fraction({parts_in_day, @seconds_per_day}),
+    do: parts_in_day
+
+  defp seconds_from_day_fraction({parts_in_day, parts_per_day}),
+    do: div(parts_in_day * @seconds_per_day, parts_per_day)
+
+  # Keep it multiline for proper function clause errors.
+  defp to_iso_days(%{
+         calendar: calendar,
+         year: year,
+         month: month,
+         day: day,
+         hour: hour,
+         minute: minute,
+         second: second,
+         microsecond: microsecond
+       }) do
+    calendar.naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)
+  end
+
+  defp from_iso_days(iso_days, calendar, precision) do
+    {year, month, day, hour, minute, second, {microsecond, _}} =
+      calendar.naive_datetime_from_iso_days(iso_days)
+
+    %NaiveDateTime{
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: {microsecond, precision}
+    }
+  end
+
+  defimpl String.Chars do
+    def to_string(naive_datetime) do
+      %{
+        calendar: calendar,
+        year: year,
+        month: month,
+        day: day,
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond
+      } = naive_datetime
+
+      calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)
+    end
+  end
+
+  defimpl Inspect do
+    def inspect(naive_datetime, _) do
+      %{
+        year: year,
+        month: month,
+        day: day,
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond,
+        calendar: calendar
+      } = naive_datetime
+
+      if calendar != Calendar.ISO or year in -9999..9999 do
+        formatted =
+          calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)
+
+        "~N[" <> formatted <> suffix(calendar) <> "]"
+      else
+        "NaiveDateTime.new!(#{Integer.to_string(year)}, #{Integer.to_string(month)}, #{Integer.to_string(day)}, " <>
+          "#{Integer.to_string(hour)}, #{Integer.to_string(minute)}, #{Integer.to_string(second)}, #{inspect(microsecond)})"
+      end
+    end
+
+    defp suffix(Calendar.ISO), do: ""
+    defp suffix(calendar), do: " " <> inspect(calendar)
+  end
+end
diff --git a/lib/elixir/lib/calendar/time.ex b/lib/elixir/lib/calendar/time.ex
new file mode 100644
index 00000000000..831a19aaed3
--- /dev/null
+++ b/lib/elixir/lib/calendar/time.ex
@@ -0,0 +1,1011 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Time do
+  @moduledoc """
+  A Time struct and functions.
+
+  The Time struct contains the fields hour, minute, second and microseconds.
+  New times can be built with the `new/4` function or using the
+  `~T` (see `sigil_T/2`) sigil:
+
+      iex> ~T[23:00:07.001]
+      ~T[23:00:07.001]
+
+  Both `new/4` and sigil return a struct where the time fields can
+  be accessed directly:
+
+      iex> time = ~T[23:00:07.001]
+      iex> time.hour
+      23
+      iex> time.microsecond
+      {1000, 3}
+
+  The functions on this module work with the `Time` struct as well
+  as any struct that contains the same fields as the `Time` struct,
+  such as `NaiveDateTime` and `DateTime`. Such functions expect
+  `t:Calendar.time/0` in their typespecs (instead of `t:t/0`).
+
+  Developers should avoid creating the Time structs directly
+  and instead rely on the functions provided by this module as well
+  as the ones in third-party calendar libraries.
+
+  ## Comparing times
+
+  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
+  and based on the `Time` struct fields. For proper comparison between
+  times, use the `compare/2`, `after?/2` and `before?/2` functions.
+  The existence of the `compare/2` function in this module also allows
+  using `Enum.min/2` and `Enum.max/2` functions to get the minimum and
+  maximum time of an `Enum`. For example:
+
+      iex> Enum.min([~T[23:00:07.001], ~T[10:00:07.001]], Time)
+      ~T[10:00:07.001]
+  """
+
+  @enforce_keys [:hour, :minute, :second]
+  defstruct [:hour, :minute, :second, microsecond: {0, 0}, calendar: Calendar.ISO]
+
+  @type t :: %__MODULE__{
+          hour: Calendar.hour(),
+          minute: Calendar.minute(),
+          second: Calendar.second(),
+          microsecond: Calendar.microsecond(),
+          calendar: Calendar.calendar()
+        }
+
+  @seconds_per_day 24 * 60 * 60
+
+  @doc """
+  Returns the current time in UTC.
+
+  You can pass a time unit to automatically truncate the resulting time.
+
+  The default unit if none gets passed is `:native` which results on a default resolution of microseconds.
+
+  ## Examples
+
+      iex> time = Time.utc_now()
+      iex> time.hour >= 0
+      true
+
+      iex> time = Time.utc_now(:second)
+      iex> time.microsecond
+      {0, 0}
+
+  """
+  @doc since: "1.4.0"
+  @spec utc_now(Calendar.calendar() | :native | :microsecond | :millisecond | :second) :: t
+  def utc_now(calendar_or_time_unit \\ Calendar.ISO) do
+    case calendar_or_time_unit do
+      unit when unit in [:native, :microsecond, :millisecond, :second] ->
+        utc_now(unit, Calendar.ISO)
+
+      calendar ->
+        utc_now(:native, calendar)
+    end
+  end
+
+  @doc """
+  Returns the current time in UTC, supporting a precision and a specific calendar.
+
+  ## Examples
+
+      iex> time = Time.utc_now(:microsecond, Calendar.ISO)
+      iex> time.hour >= 0
+      true
+
+      iex> time = Time.utc_now(:second, Calendar.ISO)
+      iex> time.microsecond
+      {0, 0}
+
+  """
+  @doc since: "1.19.0"
+  @spec utc_now(:native | :microsecond | :millisecond | :second, Calendar.calendar()) :: t
+  def utc_now(time_unit, calendar)
+      when time_unit in [:native, :microsecond, :millisecond, :second] do
+    {:ok, _, time, microsecond} = Calendar.ISO.from_unix(System.os_time(time_unit), time_unit)
+    {hour, minute, second} = time
+
+    iso_time = %Time{
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      calendar: Calendar.ISO
+    }
+
+    convert!(iso_time, calendar)
+  end
+
+  @doc """
+  Builds a new time.
+
+  Expects all values to be integers. Returns `{:ok, time}` if each
+  entry fits its appropriate range, returns `{:error, reason}` otherwise.
+
+  Microseconds can also be given with a precision, which must be an
+  integer between 0 and 6.
+
+  The built-in calendar does not support leap seconds.
+
+  ## Examples
+
+      iex> Time.new(0, 0, 0, 0)
+      {:ok, ~T[00:00:00.000000]}
+      iex> Time.new(23, 59, 59, 999_999)
+      {:ok, ~T[23:59:59.999999]}
+
+      iex> Time.new(24, 59, 59, 999_999)
+      {:error, :invalid_time}
+      iex> Time.new(23, 60, 59, 999_999)
+      {:error, :invalid_time}
+      iex> Time.new(23, 59, 60, 999_999)
+      {:error, :invalid_time}
+      iex> Time.new(23, 59, 59, 1_000_000)
+      {:error, :invalid_time}
+
+      # Invalid precision
+      Time.new(23, 59, 59, {999_999, 10})
+      {:error, :invalid_time}
+
+  """
+  @spec new(
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond() | non_neg_integer(),
+          Calendar.calendar()
+        ) :: {:ok, t} | {:error, atom}
+  def new(hour, minute, second, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
+
+  def new(hour, minute, second, microsecond, calendar) when is_integer(microsecond) do
+    new(hour, minute, second, {microsecond, 6}, calendar)
+  end
+
+  def new(hour, minute, second, {microsecond, precision}, calendar)
+      when is_integer(hour) and is_integer(minute) and is_integer(second) and
+             is_integer(microsecond) and is_integer(precision) do
+    case calendar.valid_time?(hour, minute, second, {microsecond, precision}) do
+      true ->
+        time = %Time{
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: {microsecond, precision},
+          calendar: calendar
+        }
+
+        {:ok, time}
+
+      false ->
+        {:error, :invalid_time}
+    end
+  end
+
+  @doc """
+  Builds a new time.
+
+  Expects all values to be integers. Returns `time` if each
+  entry fits its appropriate range, raises if the time is invalid.
+
+  Microseconds can also be given with a precision, which must be an
+  integer between 0 and 6.
+
+  The built-in calendar does not support leap seconds.
+
+  ## Examples
+
+      iex> Time.new!(0, 0, 0, 0)
+      ~T[00:00:00.000000]
+      iex> Time.new!(23, 59, 59, 999_999)
+      ~T[23:59:59.999999]
+      iex> Time.new!(24, 59, 59, 999_999)
+      ** (ArgumentError) cannot build time, reason: :invalid_time
+  """
+  @doc since: "1.11.0"
+  @spec new!(
+          Calendar.hour(),
+          Calendar.minute(),
+          Calendar.second(),
+          Calendar.microsecond() | non_neg_integer,
+          Calendar.calendar()
+        ) :: t
+  def new!(hour, minute, second, microsecond \\ {0, 0}, calendar \\ Calendar.ISO) do
+    case new(hour, minute, second, microsecond, calendar) do
+      {:ok, time} ->
+        time
+
+      {:error, reason} ->
+        raise ArgumentError, "cannot build time, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Converts the given `time` to a string.
+
+  ## Examples
+
+      iex> Time.to_string(~T[23:00:00])
+      "23:00:00"
+      iex> Time.to_string(~T[23:00:00.001])
+      "23:00:00.001"
+      iex> Time.to_string(~T[23:00:00.123456])
+      "23:00:00.123456"
+
+      iex> Time.to_string(~N[2015-01-01 23:00:00.001])
+      "23:00:00.001"
+      iex> Time.to_string(~N[2015-01-01 23:00:00.123456])
+      "23:00:00.123456"
+
+  """
+  @spec to_string(Calendar.time()) :: String.t()
+  def to_string(time)
+
+  def to_string(%{
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond,
+        calendar: calendar
+      }) do
+    calendar.time_to_string(hour, minute, second, microsecond)
+  end
+
+  @doc """
+  Parses the extended "Local time" format described by
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+
+  Time zone offset may be included in the string but they will be
+  simply discarded as such information is not included in times.
+
+  As specified in the standard, the separator "T" may be omitted if
+  desired as there is no ambiguity within this function.
+
+  ## Examples
+
+      iex> Time.from_iso8601("23:50:07")
+      {:ok, ~T[23:50:07]}
+      iex> Time.from_iso8601("23:50:07Z")
+      {:ok, ~T[23:50:07]}
+      iex> Time.from_iso8601("T23:50:07Z")
+      {:ok, ~T[23:50:07]}
+
+      iex> Time.from_iso8601("23:50:07,0123456")
+      {:ok, ~T[23:50:07.012345]}
+      iex> Time.from_iso8601("23:50:07.0123456")
+      {:ok, ~T[23:50:07.012345]}
+      iex> Time.from_iso8601("23:50:07.123Z")
+      {:ok, ~T[23:50:07.123]}
+
+      iex> Time.from_iso8601("2015:01:23 23-50-07")
+      {:error, :invalid_format}
+      iex> Time.from_iso8601("23:50:07A")
+      {:error, :invalid_format}
+      iex> Time.from_iso8601("23:50:07.")
+      {:error, :invalid_format}
+      iex> Time.from_iso8601("23:50:61")
+      {:error, :invalid_time}
+
+  """
+  @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
+  def from_iso8601(string, calendar \\ Calendar.ISO) do
+    with {:ok, {hour, minute, second, microsecond}} <- Calendar.ISO.parse_time(string) do
+      convert(
+        %Time{hour: hour, minute: minute, second: second, microsecond: microsecond},
+        calendar
+      )
+    end
+  end
+
+  @doc """
+  Parses the extended "Local time" format described by
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+
+  Raises if the format is invalid.
+
+  ## Examples
+
+      iex> Time.from_iso8601!("23:50:07,123Z")
+      ~T[23:50:07.123]
+      iex> Time.from_iso8601!("23:50:07.123Z")
+      ~T[23:50:07.123]
+      iex> Time.from_iso8601!("2015:01:23 23-50-07")
+      ** (ArgumentError) cannot parse "2015:01:23 23-50-07" as time, reason: :invalid_format
+
+  """
+  @spec from_iso8601!(String.t(), Calendar.calendar()) :: t
+  def from_iso8601!(string, calendar \\ Calendar.ISO) do
+    case from_iso8601(string, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, reason} ->
+        raise ArgumentError, "cannot parse #{inspect(string)} as time, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Converts the given time to
+  [ISO 8601:2019](https://en.wikipedia.org/wiki/ISO_8601).
+
+  By default, `Time.to_iso8601/2` returns times formatted in the "extended"
+  format, for human readability. It also supports the "basic" format through
+  passing the `:basic` option.
+
+  ## Examples
+
+      iex> Time.to_iso8601(~T[23:00:13])
+      "23:00:13"
+
+      iex> Time.to_iso8601(~T[23:00:13.001])
+      "23:00:13.001"
+
+      iex> Time.to_iso8601(~T[23:00:13.001], :basic)
+      "230013.001"
+
+      iex> Time.to_iso8601(~N[2010-04-17 23:00:13])
+      "23:00:13"
+
+  """
+  @spec to_iso8601(Calendar.time(), :extended | :basic) :: String.t()
+  def to_iso8601(time, format \\ :extended)
+
+  def to_iso8601(%{calendar: Calendar.ISO} = time, format) when format in [:extended, :basic] do
+    %{
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    } = time
+
+    Calendar.ISO.time_to_string(hour, minute, second, microsecond, format)
+  end
+
+  def to_iso8601(%{calendar: _} = time, format) when format in [:extended, :basic] do
+    time
+    |> convert!(Calendar.ISO)
+    |> to_iso8601(format)
+  end
+
+  @doc """
+  Converts given `time` to an Erlang time tuple.
+
+  WARNING: Loss of precision may occur, as Erlang time tuples
+  only contain hours/minutes/seconds.
+
+  ## Examples
+
+      iex> Time.to_erl(~T[23:30:15.999])
+      {23, 30, 15}
+
+      iex> Time.to_erl(~N[2010-04-17 23:30:15.999])
+      {23, 30, 15}
+
+  """
+  @spec to_erl(Calendar.time()) :: :calendar.time()
+  def to_erl(time) do
+    %{hour: hour, minute: minute, second: second} = convert!(time, Calendar.ISO)
+    {hour, minute, second}
+  end
+
+  @doc """
+  Converts an Erlang time tuple to a `Time` struct.
+
+  ## Examples
+
+      iex> Time.from_erl({23, 30, 15})
+      {:ok, ~T[23:30:15]}
+      iex> Time.from_erl({23, 30, 15}, 5000)
+      {:ok, ~T[23:30:15.005000]}
+      iex> Time.from_erl({23, 30, 15}, {5000, 3})
+      {:ok, ~T[23:30:15.005]}
+      iex> Time.from_erl({24, 30, 15})
+      {:error, :invalid_time}
+
+  """
+  @spec from_erl(
+          :calendar.time(),
+          Calendar.microsecond() | non_neg_integer(),
+          Calendar.calendar()
+        ) ::
+          {:ok, t} | {:error, atom}
+  def from_erl(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
+
+  def from_erl({hour, minute, second}, microsecond, calendar) do
+    with {:ok, time} <- new(hour, minute, second, microsecond, Calendar.ISO),
+         do: convert(time, calendar)
+  end
+
+  @doc """
+  Converts an Erlang time tuple to a `Time` struct.
+
+  ## Examples
+
+      iex> Time.from_erl!({23, 30, 15})
+      ~T[23:30:15]
+      iex> Time.from_erl!({23, 30, 15}, 5000)
+      ~T[23:30:15.005000]
+      iex> Time.from_erl!({23, 30, 15}, {5000, 3})
+      ~T[23:30:15.005]
+      iex> Time.from_erl!({24, 30, 15})
+      ** (ArgumentError) cannot convert {24, 30, 15} to time, reason: :invalid_time
+
+  """
+  @spec from_erl!(:calendar.time(), Calendar.microsecond(), Calendar.calendar()) :: t
+  def from_erl!(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO) do
+    case from_erl(tuple, microsecond, calendar) do
+      {:ok, value} ->
+        value
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "cannot convert #{inspect(tuple)} to time, reason: #{inspect(reason)}"
+    end
+  end
+
+  @doc """
+  Converts a number of seconds after midnight to a `Time` struct.
+
+  ## Examples
+
+      iex> Time.from_seconds_after_midnight(10_000)
+      ~T[02:46:40]
+      iex> Time.from_seconds_after_midnight(30_000, {5000, 3})
+      ~T[08:20:00.005]
+      iex> Time.from_seconds_after_midnight(-1)
+      ~T[23:59:59]
+      iex> Time.from_seconds_after_midnight(100_000)
+      ~T[03:46:40]
+
+  """
+  @doc since: "1.11.0"
+  @spec from_seconds_after_midnight(
+          integer(),
+          Calendar.microsecond(),
+          Calendar.calendar()
+        ) :: t
+  def from_seconds_after_midnight(seconds, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
+      when is_integer(seconds) do
+    seconds_in_day = Integer.mod(seconds, @seconds_per_day)
+
+    {hour, minute, second, {_, _}} =
+      calendar.time_from_day_fraction({seconds_in_day, @seconds_per_day})
+
+    %Time{
+      calendar: calendar,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    }
+  end
+
+  @doc """
+  Converts a `Time` struct to a number of seconds after midnight.
+
+  The returned value is a two-element tuple with the number of seconds and microseconds.
+
+  ## Examples
+
+      iex> Time.to_seconds_after_midnight(~T[23:30:15])
+      {84615, 0}
+      iex> Time.to_seconds_after_midnight(~N[2010-04-17 23:30:15.999])
+      {84615, 999000}
+
+  """
+  @doc since: "1.11.0"
+  @spec to_seconds_after_midnight(Calendar.time()) :: {integer(), non_neg_integer()}
+  def to_seconds_after_midnight(%{microsecond: {microsecond, _precision}} = time) do
+    iso_days = {0, to_day_fraction(time)}
+    {Calendar.ISO.iso_days_to_unit(iso_days, :second), microsecond}
+  end
+
+  @doc """
+  Adds the `amount_to_add` of `unit`s to the given `time`.
+
+  > #### Prefer `shift/2` {: .info}
+  >
+  > Prefer `shift/2` over `add/3`, as it offers a more ergonomic API.
+  >
+  > `add/3` always considers the unit to be computed according to
+  > the `Calendar.ISO`.
+
+  Accepts an `amount_to_add` in any `unit`. `unit` can be
+  `:hour`, `:minute`, `:second` or any subsecond precision from
+  `t:System.time_unit/0` for convenience but ultimately they are
+  all converted to microseconds. Negative values will move backwards
+  in time and the default precision is `:second`.
+
+  Note the result value represents the time of day, meaning that it is cyclic,
+  for instance, it will never go over 24 hours for the ISO calendar.
+
+  ## Examples
+
+      iex> Time.add(~T[10:00:00], 27000)
+      ~T[17:30:00]
+      iex> Time.add(~T[11:00:00.005], 2400)
+      ~T[11:40:00.005]
+      iex> Time.add(~T[00:00:00.000], 86_399_999, :millisecond)
+      ~T[23:59:59.999]
+
+  Negative values are allowed:
+
+      iex> Time.add(~T[23:00:00], -60)
+      ~T[22:59:00]
+
+  Note that the time is cyclic:
+
+      iex> Time.add(~T[17:10:05], 86400)
+      ~T[17:10:05]
+
+  Hours and minutes are also supported:
+
+      iex> Time.add(~T[17:10:05], 2, :hour)
+      ~T[19:10:05]
+      iex> Time.add(~T[17:10:05], 30, :minute)
+      ~T[17:40:05]
+
+  This operation merges the precision of the time with the given unit:
+
+      iex> result = Time.add(~T[00:29:10], 21, :millisecond)
+      ~T[00:29:10.021]
+      iex> result.microsecond
+      {21000, 3}
+
+  """
+  @doc since: "1.6.0"
+  @spec add(Calendar.time(), integer, :hour | :minute | System.time_unit()) :: t
+  def add(time, amount_to_add, unit \\ :second)
+
+  def add(time, amount_to_add, :hour) when is_integer(amount_to_add) do
+    add(time, amount_to_add * 3600, :second)
+  end
+
+  def add(time, amount_to_add, :minute) when is_integer(amount_to_add) do
+    add(time, amount_to_add * 60, :second)
+  end
+
+  def add(%{calendar: calendar, microsecond: {_, precision}} = time, amount_to_add, unit)
+      when is_integer(amount_to_add) do
+    valid? =
+      if is_integer(unit),
+        do: unit > 0,
+        else: unit in ~w(second millisecond microsecond nanosecond)a
+
+    if not valid? do
+      raise ArgumentError,
+            "unsupported time unit. Expected :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got #{inspect(unit)}"
+    end
+
+    %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time
+
+    precision = max(Calendar.ISO.time_unit_to_precision(unit), precision)
+
+    {hour, minute, second, {microsecond, _precision}} =
+      Calendar.ISO.shift_time_unit(
+        {hour, minute, second, microsecond},
+        amount_to_add,
+        unit
+      )
+
+    %Time{
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: {microsecond, precision},
+      calendar: calendar
+    }
+  end
+
+  @doc """
+  Shifts given `time` by `duration` according to its calendar.
+
+  Available duration units are: `:hour`, `:minute`, `:second`, `:microsecond`.
+
+  When using the default ISO calendar, durations are collapsed to seconds and
+  microseconds before they are applied.
+
+  Raises an `ArgumentError` when called with date scale units.
+
+  ## Examples
+
+      iex> Time.shift(~T[01:00:15], hour: 12)
+      ~T[13:00:15]
+      iex> Time.shift(~T[01:35:00], hour: 6, minute: -15)
+      ~T[07:20:00]
+      iex> Time.shift(~T[01:15:00], second: 125)
+      ~T[01:17:05]
+      iex> Time.shift(~T[01:00:15], microsecond: {100, 6})
+      ~T[01:00:15.000100]
+      iex> Time.shift(~T[01:15:00], Duration.new!(second: 65))
+      ~T[01:16:05]
+
+  """
+  @doc since: "1.17.0"
+  @spec shift(Calendar.time(), Duration.t() | [unit_pair]) :: t
+        when unit_pair:
+               {:hour, integer}
+               | {:minute, integer}
+               | {:second, integer}
+               | {:microsecond, {integer, 0..6}}
+  def shift(%{calendar: calendar} = time, duration) do
+    %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time
+
+    {hour, minute, second, microsecond} =
+      calendar.shift_time(hour, minute, second, microsecond, __duration__!(duration))
+
+    %Time{
+      calendar: calendar,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    }
+  end
+
+  @doc false
+  def __duration__!(%Duration{} = duration) do
+    duration
+  end
+
+  # This part is inlined by the compiler on constant values
+  def __duration__!(unit_pairs) do
+    Enum.each(unit_pairs, &validate_duration_unit!/1)
+    struct!(Duration, unit_pairs)
+  end
+
+  defp validate_duration_unit!({:microsecond, {ms, precision}})
+       when is_integer(ms) and precision in 0..6 do
+    :ok
+  end
+
+  defp validate_duration_unit!({:microsecond, microsecond}) do
+    raise ArgumentError,
+          "unsupported value #{inspect(microsecond)} for :microsecond. Expected a tuple {ms, precision} where precision is an integer from 0 to 6"
+  end
+
+  defp validate_duration_unit!({unit, _value}) when unit in [:year, :month, :week, :day] do
+    raise ArgumentError,
+          "unsupported unit #{inspect(unit)}. Expected :hour, :minute, :second, :microsecond"
+  end
+
+  defp validate_duration_unit!({unit, _value})
+       when unit not in [:hour, :minute, :second, :microsecond] do
+    raise ArgumentError,
+          "unknown unit #{inspect(unit)}. Expected :hour, :minute, :second, :microsecond"
+  end
+
+  defp validate_duration_unit!({_unit, value}) when is_integer(value) do
+    :ok
+  end
+
+  defp validate_duration_unit!({unit, value}) do
+    raise ArgumentError,
+          "unsupported value #{inspect(value)} for #{inspect(unit)}. Expected an integer"
+  end
+
+  @doc """
+  Compares two time structs.
+
+  Returns `:gt` if first time is later than the second
+  and `:lt` for vice versa. If the two times are equal
+  `:eq` is returned.
+
+  ## Examples
+
+      iex> Time.compare(~T[16:04:16], ~T[16:04:28])
+      :lt
+      iex> Time.compare(~T[16:04:16], ~T[16:04:16])
+      :eq
+      iex> Time.compare(~T[16:04:16.01], ~T[16:04:16.001])
+      :gt
+
+  This function can also be used to compare across more
+  complex calendar types by considering only the time fields:
+
+      iex> Time.compare(~N[1900-01-01 16:04:16], ~N[2015-01-01 16:04:16])
+      :eq
+      iex> Time.compare(~N[2015-01-01 16:04:16], ~N[2015-01-01 16:04:28])
+      :lt
+      iex> Time.compare(~N[2015-01-01 16:04:16.01], ~N[2000-01-01 16:04:16.001])
+      :gt
+
+  """
+  @doc since: "1.4.0"
+  @spec compare(Calendar.time(), Calendar.time()) :: :lt | :eq | :gt
+  def compare(%{calendar: calendar} = time1, %{calendar: calendar} = time2) do
+    %{hour: hour1, minute: minute1, second: second1, microsecond: {microsecond1, _}} = time1
+    %{hour: hour2, minute: minute2, second: second2, microsecond: {microsecond2, _}} = time2
+
+    case {{hour1, minute1, second1, microsecond1}, {hour2, minute2, second2, microsecond2}} do
+      {first, second} when first > second -> :gt
+      {first, second} when first < second -> :lt
+      _ -> :eq
+    end
+  end
+
+  def compare(time1, time2) do
+    {parts1, ppd1} = to_day_fraction(time1)
+    {parts2, ppd2} = to_day_fraction(time2)
+
+    case {parts1 * ppd2, parts2 * ppd1} do
+      {first, second} when first > second -> :gt
+      {first, second} when first < second -> :lt
+      _ -> :eq
+    end
+  end
+
+  @doc """
+  Returns `true` if the first time is strictly earlier than the second.
+
+  ## Examples
+
+      iex> Time.before?(~T[16:04:16], ~T[16:04:28])
+      true
+      iex> Time.before?(~T[16:04:16], ~T[16:04:16])
+      false
+      iex> Time.before?(~T[16:04:16.01], ~T[16:04:16.001])
+      false
+
+  """
+  @doc since: "1.15.0"
+  @spec before?(Calendar.time(), Calendar.time()) :: boolean()
+  def before?(time1, time2) do
+    compare(time1, time2) == :lt
+  end
+
+  @doc """
+  Returns `true` if the first time is strictly later than the second.
+
+  ## Examples
+
+      iex> Time.after?(~T[16:04:28], ~T[16:04:16])
+      true
+      iex> Time.after?(~T[16:04:16], ~T[16:04:16])
+      false
+      iex> Time.after?(~T[16:04:16.001], ~T[16:04:16.01])
+      false
+
+  """
+  @doc since: "1.15.0"
+  @spec after?(Calendar.time(), Calendar.time()) :: boolean()
+  def after?(time1, time2) do
+    compare(time1, time2) == :gt
+  end
+
+  @doc """
+  Converts given `time` to a different calendar.
+
+  Returns `{:ok, time}` if the conversion was successful,
+  or `{:error, reason}` if it was not, for some reason.
+
+  ## Examples
+
+  Imagine someone implements `Calendar.Holocene`, a calendar based on the
+  Gregorian calendar that adds exactly 10 000 years to the current Gregorian
+  year:
+
+      iex> Time.convert(~T[13:30:15], Calendar.Holocene)
+      {:ok, %Time{calendar: Calendar.Holocene, hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}
+
+  """
+  @doc since: "1.5.0"
+  @spec convert(Calendar.time(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
+
+  # Keep it multiline for proper function clause errors.
+  def convert(
+        %{
+          calendar: calendar,
+          hour: hour,
+          minute: minute,
+          second: second,
+          microsecond: microsecond
+        },
+        calendar
+      ) do
+    time = %Time{
+      calendar: calendar,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    }
+
+    {:ok, time}
+  end
+
+  def convert(%{microsecond: {_, precision}} = time, calendar) do
+    {hour, minute, second, {microsecond, _}} =
+      time
+      |> to_day_fraction()
+      |> calendar.time_from_day_fraction()
+
+    time = %Time{
+      calendar: calendar,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: {microsecond, precision}
+    }
+
+    {:ok, time}
+  end
+
+  @doc """
+  Similar to `Time.convert/2`, but raises an `ArgumentError`
+  if the conversion between the two calendars is not possible.
+
+  ## Examples
+
+  Imagine someone implements `Calendar.Holocene`, a calendar based on the
+  Gregorian calendar that adds exactly 10 000 years to the current Gregorian
+  year:
+
+      iex> Time.convert!(~T[13:30:15], Calendar.Holocene)
+      %Time{calendar: Calendar.Holocene, hour: 13, minute: 30, second: 15, microsecond: {0, 0}}
+
+  """
+  @doc since: "1.5.0"
+  @spec convert!(Calendar.time(), Calendar.calendar()) :: t
+  def convert!(time, calendar) do
+    {:ok, value} = convert(time, calendar)
+    value
+  end
+
+  @doc """
+  Returns the difference between two times, considering only the hour, minute,
+  second and microsecond.
+
+  As with the `compare/2` function both `Time` structs and other structures
+  containing time can be used. If for instance a `NaiveDateTime` or `DateTime`
+  is passed, only the hour, minute, second, and microsecond is considered. Any
+  additional information about a date or time zone is ignored when calculating
+  the difference.
+
+  The answer can be returned in any `:hour`, `:minute`, `:second` or any
+  subsecond `unit` available from `t:System.time_unit/0`. If the first time
+  value is earlier than the second, a negative number is returned.
+
+  The unit is measured according to `Calendar.ISO` and defaults to `:second`.
+  Fractional results are not supported and are truncated.
+
+  ## Examples
+
+      iex> Time.diff(~T[00:29:12], ~T[00:29:10])
+      2
+
+      # When passing a `NaiveDateTime` the date part is ignored.
+      iex> Time.diff(~N[2017-01-01 00:29:12], ~T[00:29:10])
+      2
+
+      # Two `NaiveDateTime` structs could have big differences in the date
+      # but only the time part is considered.
+      iex> Time.diff(~N[2017-01-01 00:29:12], ~N[1900-02-03 00:29:10])
+      2
+
+      iex> Time.diff(~T[00:29:12], ~T[00:29:10], :microsecond)
+      2_000_000
+      iex> Time.diff(~T[00:29:10], ~T[00:29:12], :microsecond)
+      -2_000_000
+
+      iex> Time.diff(~T[02:29:10], ~T[00:29:10], :hour)
+      2
+      iex> Time.diff(~T[02:29:10], ~T[00:29:11], :hour)
+      1
+
+  """
+  @doc since: "1.5.0"
+  @spec diff(Calendar.time(), Calendar.time(), :hour | :minute | System.time_unit()) :: integer
+  def diff(time1, time2, unit \\ :second)
+
+  def diff(time1, time2, :hour) do
+    diff(time1, time2, :second) |> div(3600)
+  end
+
+  def diff(time1, time2, :minute) do
+    diff(time1, time2, :second) |> div(60)
+  end
+
+  def diff(
+        %{
+          calendar: Calendar.ISO,
+          hour: hour1,
+          minute: minute1,
+          second: second1,
+          microsecond: {microsecond1, _}
+        },
+        %{
+          calendar: Calendar.ISO,
+          hour: hour2,
+          minute: minute2,
+          second: second2,
+          microsecond: {microsecond2, _}
+        },
+        unit
+      ) do
+    total =
+      (hour1 - hour2) * 3_600_000_000 + (minute1 - minute2) * 60_000_000 +
+        (second1 - second2) * 1_000_000 + (microsecond1 - microsecond2)
+
+    System.convert_time_unit(total, :microsecond, unit)
+  end
+
+  def diff(time1, time2, unit) do
+    fraction1 = to_day_fraction(time1)
+    fraction2 = to_day_fraction(time2)
+
+    Calendar.ISO.iso_days_to_unit({0, fraction1}, unit) -
+      Calendar.ISO.iso_days_to_unit({0, fraction2}, unit)
+  end
+
+  @doc """
+  Returns the given time with the microsecond field truncated to the given
+  precision (`:microsecond`, `millisecond` or `:second`).
+
+  The given time is returned unchanged if it already has lower precision than
+  the given precision.
+
+  ## Examples
+
+      iex> Time.truncate(~T[01:01:01.123456], :microsecond)
+      ~T[01:01:01.123456]
+
+      iex> Time.truncate(~T[01:01:01.123456], :millisecond)
+      ~T[01:01:01.123]
+
+      iex> Time.truncate(~T[01:01:01.123456], :second)
+      ~T[01:01:01]
+
+  """
+  @doc since: "1.6.0"
+  @spec truncate(t(), :microsecond | :millisecond | :second) :: t()
+  def truncate(%Time{microsecond: microsecond} = time, precision) do
+    %{time | microsecond: Calendar.truncate(microsecond, precision)}
+  end
+
+  ## Helpers
+
+  defp to_day_fraction(%{
+         hour: hour,
+         minute: minute,
+         second: second,
+         microsecond: {_, _} = microsecond,
+         calendar: calendar
+       }) do
+    calendar.time_to_day_fraction(hour, minute, second, microsecond)
+  end
+
+  defimpl String.Chars do
+    def to_string(time) do
+      %{
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond,
+        calendar: calendar
+      } = time
+
+      calendar.time_to_string(hour, minute, second, microsecond)
+    end
+  end
+
+  defimpl Inspect do
+    def inspect(time, _) do
+      %{
+        hour: hour,
+        minute: minute,
+        second: second,
+        microsecond: microsecond,
+        calendar: calendar
+      } = time
+
+      "~T[" <>
+        calendar.time_to_string(hour, minute, second, microsecond) <> suffix(calendar) <> "]"
+    end
+
+    defp suffix(Calendar.ISO), do: ""
+    defp suffix(calendar), do: " " <> inspect(calendar)
+  end
+end
diff --git a/lib/elixir/lib/calendar/time_zone_database.ex b/lib/elixir/lib/calendar/time_zone_database.ex
new file mode 100644
index 00000000000..dcfac50f8da
--- /dev/null
+++ b/lib/elixir/lib/calendar/time_zone_database.ex
@@ -0,0 +1,102 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Calendar.TimeZoneDatabase do
+  @moduledoc """
+  This module defines a behaviour for providing time zone data.
+
+  IANA provides time zone data that includes data about different
+  UTC offsets and standard offsets for time zones.
+  """
+
+  @typedoc """
+  A period where a certain combination of UTC offset, standard offset, and zone
+  abbreviation is in effect.
+
+  For example, one period could be the summer of 2018 in the `Europe/London` timezone,
+  where summer time/daylight saving time is in effect and lasts from spring to autumn.
+  In autumn, the `std_offset` changes along with the `zone_abbr` so a different
+  period is needed during winter.
+  """
+  @type time_zone_period :: %{
+          optional(any) => any,
+          utc_offset: Calendar.utc_offset(),
+          std_offset: Calendar.std_offset(),
+          zone_abbr: Calendar.zone_abbr()
+        }
+
+  @typedoc """
+  Limit for when a certain time zone period begins or ends.
+
+  A beginning is inclusive. An ending is exclusive. For example, if a period is from
+  `2015-03-29 01:00:00` and until `2015-10-25 01:00:00`, the period includes and
+  begins from the beginning of `2015-03-29 01:00:00` and lasts until just before
+  `2015-10-25 01:00:00`.
+
+  A beginning or end for certain periods are infinite, such as the latest
+  period for time zones without DST or plans to change. However, for the purpose
+  of this behaviour, they are only used for gaps in wall time where the needed
+  period limits are at a certain time.
+  """
+  @type time_zone_period_limit :: Calendar.naive_datetime()
+
+  @doc """
+  Time zone period for a point in time in UTC for a specific time zone.
+
+  Takes a time zone name and a point in time for UTC and returns a
+  `time_zone_period` for that point in time.
+  """
+  @doc since: "1.8.0"
+  @callback time_zone_period_from_utc_iso_days(Calendar.iso_days(), Calendar.time_zone()) ::
+              {:ok, time_zone_period}
+              | {:error, :time_zone_not_found | :utc_only_time_zone_database}
+
+  @doc """
+  Possible time zone periods for a certain time zone and wall clock date and time.
+
+  When the provided naive datetime is ambiguous, return a tuple with `:ambiguous`
+  and the two possible periods. The periods in the tuple must be sorted with the
+  first element being the one that begins first.
+
+  When the provided naive datetime is in a gap, such as during the "spring forward" when going
+  from winter time to summer time, return a tuple with `:gap` and two periods with limits
+  in a nested tuple. The first nested two-tuple is the period before the gap and a naive datetime
+  with a limit for when the period ends (wall time). The second nested two-tuple is the period
+  just after the gap and a datetime (wall time) for when the period begins just after the gap.
+
+  If there is only a single possible period for the provided `datetime`, then return a tuple
+  with `:ok` and the `time_zone_period`.
+  """
+  @doc since: "1.8.0"
+  @callback time_zone_periods_from_wall_datetime(Calendar.naive_datetime(), Calendar.time_zone()) ::
+              {:ok, time_zone_period}
+              | {:ambiguous, time_zone_period, time_zone_period}
+              | {:gap, {time_zone_period, time_zone_period_limit},
+                 {time_zone_period, time_zone_period_limit}}
+              | {:error, :time_zone_not_found | :utc_only_time_zone_database}
+end
+
+defmodule Calendar.UTCOnlyTimeZoneDatabase do
+  @moduledoc """
+  Built-in time zone database that works only in the `Etc/UTC` timezone.
+
+  For all other time zones, it returns `{:error, :utc_only_time_zone_database}`.
+  """
+
+  @behaviour Calendar.TimeZoneDatabase
+
+  @impl true
+  def time_zone_period_from_utc_iso_days(_, "Etc/UTC"),
+    do: {:ok, %{std_offset: 0, utc_offset: 0, zone_abbr: "UTC"}}
+
+  def time_zone_period_from_utc_iso_days(_, _),
+    do: {:error, :utc_only_time_zone_database}
+
+  @impl true
+  def time_zone_periods_from_wall_datetime(_, "Etc/UTC"),
+    do: {:ok, %{std_offset: 0, utc_offset: 0, zone_abbr: "UTC"}}
+
+  def time_zone_periods_from_wall_datetime(_, _),
+    do: {:error, :utc_only_time_zone_database}
+end
diff --git a/lib/elixir/lib/code.ex b/lib/elixir/lib/code.ex
index 21ec4ac78d6..54c6a601c00 100644
--- a/lib/elixir/lib/code.ex
+++ b/lib/elixir/lib/code.ex
@@ -1,415 +1,1987 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Code do
-  @moduledoc """
-  Utilities for managing code compilation, code evaluation and code loading.
+  @moduledoc ~S"""
+  Utilities for managing code compilation, code evaluation, and code loading.
+
+  This module complements Erlang's [`:code` module](`:code`)
+  to add behavior which is specific to Elixir. For functions to
+  manipulate Elixir's AST (rather than evaluating it), see the
+  `Macro` module.
+
+  ## Working with files
+
+  This module contains three functions for compiling and evaluating files.
+  Here is a summary of them and their behavior:
+
+    * `require_file/2` - compiles a file and tracks its name. It does not
+      compile the file again if it has been previously required.
+
+    * `compile_file/2` - compiles a file without tracking its name. Compiles the
+      file multiple times when invoked multiple times.
+
+    * `eval_file/2` - evaluates the file contents without tracking its name. It
+      returns the result of the last expression in the file, instead of the modules
+      defined in it. Evaluated files do not trigger the compilation tracers described
+      in the next section.
+
+  In a nutshell, the first must be used when you want to keep track of the files
+  handled by the system, to avoid the same file from being compiled multiple
+  times. This is common in scripts.
+
+  `compile_file/2` must be used when you are interested in the modules defined in a
+  file, without tracking. `eval_file/2` should be used when you are interested in
+  the result of evaluating the file rather than the modules it defines.
+
+  The functions above work with Elixir source. If you want to work
+  with modules compiled to bytecode, which have the `.beam` extension
+  and are typically found below the _build directory of a Mix project,
+  see the functions in Erlang's [`:code`](`:code`) module.
+
+  ## Code loading on the Erlang VM
+
+  Erlang has two modes to load code: interactive and embedded.
+
+  By default, the Erlang VM runs in interactive mode, where modules
+  are loaded as needed. In embedded mode the opposite happens, as all
+  modules need to be loaded upfront or explicitly.
+
+  You can use `ensure_loaded/1` (as well as `ensure_loaded?/1` and
+  `ensure_loaded!/1`) to check if a module is loaded before using it and
+  act.
+
+  ## `ensure_compiled/1` and `ensure_compiled!/1`
+
+  Elixir also includes `ensure_compiled/1` and `ensure_compiled!/1`
+  functions that are a superset of `ensure_loaded/1`.
+
+  Since Elixir's compilation happens in parallel, in some situations
+  you may need to use a module that was not yet compiled, therefore
+  it can't even be loaded.
+
+  When invoked, `ensure_compiled/1` and `ensure_compiled!/1` halt the
+  compilation of the caller until the module becomes available. Note that
+  the distinction between `ensure_compiled/1` and `ensure_compiled!/1`
+  is important: if you are using `ensure_compiled!/1`, you are
+  indicating to the compiler that you can only continue if said module
+  is available.
+
+  If you are using `Code.ensure_compiled/1`, you are implying you may
+  continue without the module and therefore Elixir may return
+  `{:error, :unavailable}` for cases where the module is not yet available
+  (but may be available later on).
+
+  For those reasons, developers must typically use `Code.ensure_compiled!/1`.
+  In particular, do not do this:
+
+      case Code.ensure_compiled(module) do
+        {:module, _} -> module
+        {:error, _} -> raise ...
+      end
+
+  Finally, note you only need `ensure_compiled!/1` to check for modules
+  being defined within the same project. It does not apply to modules from
+  dependencies as dependencies are always compiled upfront.
+
+  In most cases, `ensure_loaded/1` is enough. `ensure_compiled!/1`
+  must be used in rare cases, usually involving macros that need to
+  invoke a module for callback information. The use of `ensure_compiled/1`
+  is even less likely.
+
+  ## Compilation tracers
+
+  Elixir supports compilation tracers, which allow modules to observe constructs
+  handled by the Elixir compiler when compiling files. A tracer is a module
+  that implements the `trace/2` function. The function receives the event name
+  as first argument and `Macro.Env` as second and it must return `:ok`. It is
+  very important for a tracer to do as little work as possible synchronously
+  and dispatch the bulk of the work to a separate process. **Slow tracers will
+  slow down compilation**.
+
+  You can configure your list of tracers via `put_compiler_option/2`. The
+  following events are available to tracers:
+
+    * `:start` - (since v1.11.0) invoked whenever the compiler starts to trace
+      a new lexical context. A lexical context is started when compiling a new
+      file or when defining a module within a function. Note evaluated code
+      does not start a new lexical context (because they don't track unused
+      aliases, imports, etc) but defining a module inside evaluated code will.
+
+      Note this event may be emitted in parallel, where multiple files/modules
+      invoke `:start` and run at the same time. The value of the `lexical_tracker`
+      of the macro environment, albeit opaque, can be used to uniquely identify
+      the environment.
+
+    * `:stop` - (since v1.11.0) invoked whenever the compiler stops tracing a
+      new lexical context, such as a new file.
+
+    * `{:import, meta, module, opts}` - traced whenever `module` is imported.
+      `meta` is the import AST metadata and `opts` are the import options.
+
+    * `{:imported_function, meta, module, name, arity}` and
+      `{:imported_macro, meta, module, name, arity}` - traced whenever an
+      imported function or macro is invoked. `meta` is the call AST metadata,
+      `module` is the module the import is from, followed by the `name` and `arity`
+      of the imported function/macro. A :remote_function/:remote_macro event
+      may still be emitted for the imported module/name/arity.
+
+    * `{:imported_quoted, meta, module, name, [arity]}` - traced whenever an
+      imported function or macro is processed inside a `quote/2`. `meta` is the
+      call AST metadata, `module` is the module the import is from, followed by
+      the `name` and a list of `arities` of the imported function/macro.
+
+    * `{:alias, meta, alias, as, opts}` - traced whenever `alias` is aliased
+      to `as`. `meta` is the alias AST metadata and `opts` are the alias options.
+
+    * `{:alias_expansion, meta, as, alias}` traced whenever there is an alias
+      expansion for a previously defined `alias`, i.e. when the user writes `as`
+      which is expanded to `alias`. `meta` is the alias expansion AST metadata.
+
+    * `{:alias_reference, meta, module}` - traced whenever there is an alias
+      in the code, i.e. whenever the user writes `MyModule.Foo.Bar` in the code,
+      regardless if it was expanded or not.
+
+    * `{:require, meta, module, opts}` - traced whenever `module` is required.
+      `meta` is the require AST metadata and `opts` are the require options.
+      If the `meta` option contains the `:from_macro`, then module was called
+      from within a macro and therefore must be treated as a compile-time dependency.
+
+    * `{:struct_expansion, meta, module, keys}` - traced whenever `module`'s struct
+      is expanded. `meta` is the struct AST metadata and `keys` are the keys being
+      used by expansion
+
+    * `{:remote_function, meta, module, name, arity}` and
+      `{:remote_macro, meta, module, name, arity}` - traced whenever a remote
+      function or macro is referenced. `meta` is the call AST metadata, `module`
+      is the invoked module, followed by the `name` and `arity`.
+
+    * `{:local_function, meta, name, arity}` and
+      `{:local_macro, meta, name, arity}` - traced whenever a local
+      function or macro is referenced. `meta` is the call AST metadata, followed by
+      the `name` and `arity`.
+
+    * `{:compile_env, app, path, return}` - traced whenever `Application.compile_env/3`
+      or `Application.compile_env!/2` are called. `app` is an atom, `path` is a list
+      of keys to traverse in the application environment and `return` is either
+      `{:ok, value}` or `:error`.
+
+    * `:defmodule` - (since v1.16.2) traced as soon as the definition of a module
+      starts. This is invoked early on in the module life cycle, `Module.open?/1`
+      still returns `false` for such traces
+
+    * `{:on_module, bytecode, _ignore}` - (since v1.13.0) traced whenever a module
+      is defined. This is equivalent to the `@after_compile` callback and invoked
+      after any `@after_compile` in the given module. The third element is currently
+      `:none` but it may provide more metadata in the future. It is best to ignore
+      it at the moment. Note that `Module` functions expecting not yet compiled modules
+      (such as `Module.definitions_in/1`) are still available at the time this event
+      is emitted.
+
+  The `:tracers` compiler option can be combined with the `:parser_options`
+  compiler option to enrich the metadata of the traced events above.
+
+  New events may be added at any time in the future, therefore it is advised
+  for the `trace/2` function to have a "catch-all" clause.
+
+  Below is an example tracer that prints all remote function invocations:
+
+      defmodule MyTracer do
+        def trace({:remote_function, _meta, module, name, arity}, env) do
+          IO.puts("#{env.file}:#{env.line} #{inspect(module)}.#{name}/#{arity}")
+          :ok
+        end
+
+        def trace(_event, _env) do
+          :ok
+        end
+      end
+  """
+
+  @typedoc """
+  A list with all variables and their values.
+
+  The binding keys are usually atoms, but they may be a tuple for variables
+  defined in a different context.
+  """
+  @type binding :: [{atom() | tuple(), any}]
+
+  @typedoc """
+  Diagnostics returned by the compiler and code evaluation.
+
+  The file and position relate to where the diagnostic should be shown.
+  If there is a file and position, then the diagnostic is precise
+  and you can use the given file and position for generating snippets,
+  IDEs annotations, and so on. An optional span is available with
+  the line and column the diagnostic ends.
+
+  Otherwise, a stacktrace may be given, which you can place your own
+  heuristics to provide better reporting.
+
+  The source field points to the source file the compiler tracked
+  the error to. For example, a file `lib/foo.ex` may embed `.eex`
+  templates from `lib/foo/bar.eex`. A syntax error on the EEx template
+  will point to file `lib/foo/bar.eex` but the source is `lib/foo.ex`.
+  """
+  @type diagnostic(severity) :: %{
+          required(:source) => Path.t() | nil,
+          required(:file) => Path.t() | nil,
+          required(:severity) => severity,
+          required(:message) => String.t(),
+          required(:position) => position(),
+          required(:stacktrace) => Exception.stacktrace(),
+          required(:span) => {line :: pos_integer(), column :: pos_integer()} | nil,
+          optional(:details) => term(),
+          optional(any()) => any()
+        }
+
+  @typedoc "The line. 0 indicates no line."
+  @type line() :: non_neg_integer()
+
+  @typedoc """
+  The position of the diagnostic.
+
+  Can be either a line number or a `{line, column}`.
+  Line and columns numbers are one-based.
+  A position of `0` represents unknown.
+  """
+  @type position() :: line() | {line :: pos_integer(), column :: pos_integer()}
 
-  This module complements [Erlang's code module](http://www.erlang.org/doc/man/code.html)
-  to add behaviour which is specific to Elixir.
+  @typedoc """
+  Options for code formatting functions.
+  """
+  @type format_opt ::
+          {:file, binary()}
+          | {:line, pos_integer()}
+          | {:line_length, pos_integer()}
+          | {:locals_without_parens, keyword()}
+          | {:force_do_end_blocks, boolean()}
+          | {:migrate, boolean()}
+          | {:migrate_bitstring_modifiers, boolean()}
+          | {:migrate_call_parens_on_pipe, boolean()}
+          | {:migrate_charlists_as_sigils, boolean()}
+          | {:migrate_unless, boolean()}
+          | {atom(), term()}
+
+  @typedoc """
+  Options for `quoted_to_algebra/2`.
+  """
+  @type quoted_to_algebra_opt ::
+          {:line, pos_integer() | nil}
+          | {:escape, boolean()}
+          | {:locals_without_parens, keyword()}
+          | {:comments, [term()]}
+
+  @typedoc """
+  Options for parsing functions that convert strings to quoted expressions.
   """
+  @type parser_opts :: [
+          file: binary(),
+          line: pos_integer(),
+          column: pos_integer(),
+          indentation: non_neg_integer(),
+          columns: boolean(),
+          unescape: boolean(),
+          existing_atoms_only: boolean(),
+          token_metadata: boolean(),
+          literal_encoder: (term(), Macro.metadata() -> term()),
+          static_atoms_encoder: (atom() -> term()),
+          emit_warnings: boolean()
+        ]
+
+  @typedoc """
+  Options for environment evaluation functions like eval_string/3 and eval_quoted/3.
+  """
+  @type env_eval_opts :: [
+          file: binary(),
+          line: pos_integer(),
+          module: module(),
+          prune_binding: boolean()
+        ]
+
+  @boolean_compiler_options [
+    :docs,
+    :debug_info,
+    :ignore_already_consolidated,
+    :ignore_module_conflict,
+    :relative_paths
+  ]
+
+  @list_compiler_options [:tracers, :parser_options]
+
+  @available_compiler_options @boolean_compiler_options ++
+                                @list_compiler_options ++
+                                [:on_undefined_variable, :infer_signatures, :no_warn_undefined]
 
   @doc """
-  List all loaded files.
+  Lists all required files.
+
+  ## Examples
+
+      Code.require_file("../eex/test/eex_test.exs")
+      List.first(Code.required_files()) =~ "eex_test.exs"
+      #=> true
+
   """
+  @doc since: "1.7.0"
+  @spec required_files() :: [binary]
+  def required_files do
+    :elixir_code_server.call(:required)
+  end
+
+  @deprecated "Use Code.required_files/0 instead"
+  @doc false
   def loaded_files do
-    :elixir_code_server.call :loaded
+    required_files()
+  end
+
+  @doc false
+  @deprecated "Use Code.Fragment.cursor_context/2 instead"
+  def cursor_context(code, options \\ []) do
+    Code.Fragment.cursor_context(code, options)
   end
 
   @doc """
-  Remove files from the loaded files list.
+  Removes files from the required files list.
 
   The modules defined in the file are not removed;
   calling this function only removes them from the list,
   allowing them to be required again.
+
+  The list of files is managed per Erlang VM node.
+
+  ## Examples
+
+      # Require EEx test code
+      Code.require_file("../eex/test/eex_test.exs")
+
+      # Now unrequire all files
+      Code.unrequire_files(Code.required_files())
+
+      # Note that modules are still available
+      function_exported?(EExTest.Compiled, :before_compile, 0)
+      #=> true
+
   """
+  @doc since: "1.7.0"
+  @spec unrequire_files([binary]) :: :ok
+  def unrequire_files(files) when is_list(files) do
+    :elixir_code_server.cast({:unrequire_files, files})
+  end
+
+  @deprecated "Use Code.unrequire_files/1 instead"
+  @doc false
   def unload_files(files) do
-    :elixir_code_server.cast {:unload_files, files}
+    unrequire_files(files)
+  end
+
+  @doc """
+  Appends a path to the Erlang VM code path list.
+
+  This is the list of directories the Erlang VM uses for
+  finding module code. The list of files is managed per Erlang
+  VM node.
+
+  The path is expanded with `Path.expand/1` before being appended.
+  It requires the path to exist. Returns a boolean indicating if
+  the path was successfully added.
+
+  ## Examples
+
+      Code.append_path(".")
+      #=> true
+
+      Code.append_path("/does_not_exist")
+      #=> false
+
+  ## Options
+
+    * `:cache` - (since v1.15.0) when true, the code path is cached
+      the first time it is traversed in order to reduce file system
+      operations.
+
+  """
+  @spec append_path(Path.t(), cache: boolean()) :: true | false
+  def append_path(path, opts \\ []) do
+    apply(:code, :add_pathz, [to_charlist(Path.expand(path)) | cache(opts)]) == true
+  end
+
+  @doc """
+  Prepends a path to the Erlang VM code path list.
+
+  This is the list of directories the Erlang VM uses for
+  finding module code. The list of files is managed per Erlang
+  VM node.
+
+  The path is expanded with `Path.expand/1` before being prepended.
+  It requires the path to exist. Returns a boolean indicating if
+  the path was successfully added.
+
+  ## Examples
+
+      Code.prepend_path(".")
+      #=> true
+
+      Code.prepend_path("/does_not_exist")
+      #=> false
+
+  ## Options
+
+    * `:cache` - (since v1.15.0) when true, the code path is cached
+      the first time it is traversed in order to reduce file system
+      operations.
+
+  """
+  @spec prepend_path(Path.t(), cache: boolean()) :: boolean()
+  def prepend_path(path, opts \\ []) do
+    apply(:code, :add_patha, [to_charlist(Path.expand(path)) | cache(opts)]) == true
+  end
+
+  @doc """
+  Prepends a list of `paths` to the Erlang VM code path list.
+
+  This is the list of directories the Erlang VM uses for
+  finding module code. The list of files is managed per Erlang
+  VM node.
+
+  All paths are expanded with `Path.expand/1` before being prepended.
+  Only existing paths are prepended. This function always returns `:ok`,
+  regardless of how many paths were prepended. Use `prepend_path/1`
+  if you need more control.
+
+  ## Examples
+
+      Code.prepend_paths([".", "/does_not_exist"])
+      #=> :ok
+
+  ## Options
+
+    * `:cache` - when true, the code path is cached the first time
+      it is traversed in order to reduce file system operations.
+
+  """
+  @doc since: "1.15.0"
+  @spec prepend_paths([Path.t()], cache: boolean()) :: :ok
+  def prepend_paths(paths, opts \\ []) when is_list(paths) do
+    apply(:code, :add_pathsa, [Enum.map(paths, &to_charlist(Path.expand(&1))) | cache(opts)])
+  end
+
+  @doc """
+  Appends a list of `paths` to the Erlang VM code path list.
+
+  This is the list of directories the Erlang VM uses for
+  finding module code. The list of files is managed per Erlang
+  VM node.
+
+  All paths are expanded with `Path.expand/1` before being appended.
+  Only existing paths are appended. This function always returns `:ok`,
+  regardless of how many paths were appended. Use `append_path/1`
+  if you need more control.
+
+  ## Examples
+
+      Code.append_paths([".", "/does_not_exist"])
+      #=> :ok
+
+  ## Options
+
+    * `:cache` - when true, the code path is cached the first time
+      it is traversed in order to reduce file system operations.
+
+  """
+  @doc since: "1.15.0"
+  @spec append_paths([Path.t()], cache: boolean()) :: :ok
+  def append_paths(paths, opts \\ []) when is_list(paths) do
+    apply(:code, :add_pathsz, [Enum.map(paths, &to_charlist(Path.expand(&1))) | cache(opts)])
+  end
+
+  defp cache(opts) do
+    if function_exported?(:code, :add_path, 2) do
+      if opts[:cache], do: [:cache], else: [:nocache]
+    else
+      []
+    end
+  end
+
+  @doc """
+  Deletes a path from the Erlang VM code path list.
+
+  This is the list of directories the Erlang VM uses for finding
+  module code. The list of files is managed per Erlang VM node.
+
+  The path is expanded with `Path.expand/1` before being deleted. If the
+  path does not exist, this function returns `false`.
+
+  ## Examples
+
+      Code.prepend_path(".")
+      Code.delete_path(".")
+      #=> true
+
+      Code.delete_path("/does_not_exist")
+      #=> false
+
+  """
+  @spec delete_path(Path.t()) :: boolean
+  def delete_path(path) do
+    case :code.del_path(to_charlist(Path.expand(path))) do
+      result when is_boolean(result) ->
+        result
+
+      {:error, :bad_name} ->
+        raise ArgumentError,
+              "invalid argument #{inspect(path)}"
+    end
+  end
+
+  @doc """
+  Deletes a list of paths from the Erlang VM code path list.
+
+  This is the list of directories the Erlang VM uses for finding
+  module code. The list of files is managed per Erlang VM node.
+
+  The path is expanded with `Path.expand/1` before being deleted. If the
+  path does not exist, this function returns `false`.
+  """
+  @doc since: "1.15.0"
+  @spec delete_paths([Path.t()]) :: :ok
+  def delete_paths(paths) when is_list(paths) do
+    for path <- paths do
+      _ = :code.del_path(to_charlist(Path.expand(path)))
+    end
+
+    :ok
+  end
+
+  @doc """
+  Evaluates the contents given by `string`.
+
+  The `binding` argument is a list of all variables and their values.
+  The `opts` argument is a keyword list of environment options.
+
+  **Warning**: `string` can be any Elixir code and will be executed with
+  the same privileges as the Erlang VM: this means that such code could
+  compromise the machine (for example by executing system commands).
+  Don't use `eval_string/3` with untrusted input (such as strings coming
+  from the network).
+
+  ## Options
+
+  It accepts the same options as `env_for_eval/1`. Additionally, you may
+  also pass an environment as second argument, so the evaluation happens
+  within that environment.
+
+  Returns a tuple of the form `{value, binding}`, where `value` is the value
+  returned from evaluating `string`. If an error occurs while evaluating
+  `string`, an exception will be raised.
+
+  `binding` is a list with all variable names and their values after evaluating
+  `string`. The binding keys are usually atoms, but they may be a tuple for variables
+  defined in a different context. The names are in no particular order.
+
+  ## Examples
+
+      iex> {result, binding} = Code.eval_string("a + b", [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
+      iex> result
+      3
+      iex> Enum.sort(binding)
+      [a: 1, b: 2]
+
+      iex> {result, binding} = Code.eval_string("c = a + b", [a: 1, b: 2], __ENV__)
+      iex> result
+      3
+      iex> Enum.sort(binding)
+      [a: 1, b: 2, c: 3]
+
+      iex> {result, binding} = Code.eval_string("a = a + b", [a: 1, b: 2])
+      iex> result
+      3
+      iex> Enum.sort(binding)
+      [a: 3, b: 2]
+
+  For convenience, you can pass `__ENV__/0` as the `opts` argument and
+  all imports, requires and aliases defined in the current environment
+  will be automatically carried over:
+
+      iex> require Integer, warn: false
+      iex> {result, binding} = Code.eval_string("if Integer.is_odd(a), do: a + b", [a: 1, b: 2], __ENV__)
+      iex> result
+      3
+      iex> Enum.sort(binding)
+      [a: 1, b: 2]
+
+  """
+  @spec eval_string(List.Chars.t(), binding, Macro.Env.t() | env_eval_opts) :: {term, binding}
+  def eval_string(string, binding \\ [], opts \\ [])
+
+  def eval_string(string, binding, %Macro.Env{} = env) do
+    validated_eval_string(string, binding, env)
+  end
+
+  def eval_string(string, binding, opts) when is_list(opts) do
+    validated_eval_string(string, binding, opts)
+  end
+
+  defp validated_eval_string(string, binding, opts_or_env) do
+    %{line: line, file: file} = env = env_for_eval(opts_or_env)
+    forms = :elixir.string_to_quoted!(to_charlist(string), line, 1, file, [])
+    {value, binding, _env} = eval_verify(:eval_forms, [forms, binding, env])
+    {value, binding}
+  end
+
+  defp eval_verify(fun, args) do
+    Module.ParallelChecker.verify(fn ->
+      apply(:elixir, fun, args)
+    end)
+  end
+
+  @doc """
+  Executes the given `fun` and capture all diagnostics.
+
+  Diagnostics are warnings and errors emitted during code
+  evaluation or single-file compilation and by functions
+  such as `IO.warn/2`.
+
+  If using `mix compile` or `Kernel.ParallelCompiler`,
+  note they already capture and return diagnostics.
+
+  ## Options
+
+    * `:log` - if the diagnostics should be logged as they happen.
+      Defaults to `false`.
+
+  > #### Rescuing errors {: .info}
+  >
+  > `with_diagnostics/2` does not automatically handle exceptions.
+  > You may capture them by adding a `try/1` in `fun`:
+  >
+  >     {result, all_errors_and_warnings} =
+  >       Code.with_diagnostics(fn ->
+  >         try do
+  >           {:ok, Code.compile_quoted(quoted)}
+  >         rescue
+  >           err -> {:error, err}
+  >         end
+  >       end)
+
+  """
+  @doc since: "1.15.0"
+  @spec with_diagnostics([log: boolean()], (-> result)) ::
+          {result, [diagnostic(:warning | :error)]}
+        when result: term()
+  def with_diagnostics(opts \\ [], fun) do
+    value = :erlang.get(:elixir_code_diagnostics)
+    log = Keyword.get(opts, :log, false)
+    :erlang.put(:elixir_code_diagnostics, {[], log})
+
+    try do
+      result = fun.()
+      {diagnostics, _log?} = :erlang.get(:elixir_code_diagnostics)
+      {result, Enum.reverse(diagnostics)}
+    after
+      if value == :undefined do
+        :erlang.erase(:elixir_code_diagnostics)
+      else
+        :erlang.put(:elixir_code_diagnostics, value)
+      end
+    end
+  end
+
+  @doc """
+  Prints a diagnostic into the standard error.
+
+  A diagnostic is either returned by `Kernel.ParallelCompiler`
+  or by `Code.with_diagnostics/2`.
+
+  ## Options
+
+    * `:snippet` - whether to read the code snippet in the diagnostic location.
+      As it may impact performance, it is not recommended to be used in runtime.
+      Defaults to `true`.
+  """
+  @doc since: "1.15.0"
+  @spec print_diagnostic(diagnostic(:warning | :error), snippet: boolean()) :: :ok
+  def print_diagnostic(diagnostic, opts \\ []) do
+    read_snippet? = Keyword.get(opts, :snippet, true)
+    :elixir_errors.print_diagnostic(diagnostic, read_snippet?)
+    :ok
+  end
+
+  @doc ~S"""
+  Formats the given code `string`.
+
+  The formatter receives a string representing Elixir code and
+  returns iodata representing the formatted code according to
+  pre-defined rules.
+
+  ## Options
+
+  Regular options (do not change the AST):
+
+    * `:file` - the file which contains the string, used for error
+      reporting
+
+    * `:line` - the line the string starts, used for error reporting
+
+    * `:line_length` - the line length to aim for when formatting
+      the document. Defaults to `98`. This value indicates when an expression
+      should be broken over multiple lines but it is not guaranteed
+      to do so. See the "Line length" section below for more information
+
+    * `:locals_without_parens` - a keyword list of name and arity
+      pairs that should be kept without parens whenever possible.
+      The arity may be the atom `:*`, which implies all arities of
+      that name. The formatter already includes a list of functions
+      and this option augments this list.
+
+    * `:force_do_end_blocks` (since v1.9.0) - when `true`, converts all
+      inline usages of `do: ...`,  `else: ...` and friends into `do`-`end`
+      blocks. Defaults to `false`. Note that this option is convergent:
+      once you set it to `true`, **all keywords** will be converted.
+      If you set it to `false` later on, `do`-`end` blocks won't be
+      converted back to keywords.
+
+  Migration options (change the AST), see the "Migration formatting" section below:
+
+    * `:migrate` (since v1.18.0) - when `true`, sets all other migration options
+      to `true` by default. Defaults to `false`.
+
+    * `:migrate_bitstring_modifiers` (since v1.18.0) - when `true`,
+      removes unnecessary parentheses in known bitstring
+      [modifiers](`<<>>/1`), for example `<<foo::binary()>>`
+      becomes `<<foo::binary>>`, or adds parentheses for custom
+      modifiers, where `<<foo::custom_type>>` becomes `<<foo::custom_type()>>`.
+      Defaults to the value of the `:migrate` option. This option changes the AST.
+
+    * `:migrate_call_parens_on_pipe` (since v1.19.0) - when `true`,
+      formats calls on the right-hand side of the pipe operator to always include
+      parentheses, for example `foo |> bar` becomes `foo |> bar()` and
+      `foo |> mod.fun` becomes `foo |> mod.fun()`.
+      Parentheses are always added for qualified calls like `foo |> Bar.bar` even
+      when this option is `false`.
+      Defaults to the value of the `:migrate` option. This option changes the AST.
+
+    * `:migrate_charlists_as_sigils` (since v1.18.0) - when `true`,
+      formats charlists as [`~c`](`Kernel.sigil_c/2`) sigils, for example
+      `'foo'` becomes `~c"foo"`.
+      Defaults to the value of the `:migrate` option. This option changes the AST.
+
+    * `:migrate_unless` (since v1.18.0) - when `true`,
+      rewrites `unless` expressions using `if` with a negated condition, for example
+      `unless foo, do:` becomes `if !foo, do:`.
+      Defaults to the value of the `:migrate` option. This option changes the AST.
+
+  ## Design principles
+
+  The formatter was designed under three principles.
+
+  First, the formatter never changes the semantics of the code by default.
+  This means the input AST and the output AST are almost always equivalent.
+
+  The second principle is to provide as little configuration as possible.
+  This eases the formatter adoption by removing contention points while
+  making sure a single style is followed consistently by the community as
+  a whole.
+
+  The formatter does not hard code names. The formatter will not behave
+  specially because a function is named `defmodule`, `def`, or the like. This
+  principle mirrors Elixir's goal of being an extensible language where
+  developers can extend the language with new constructs as if they were
+  part of the language. When it is absolutely necessary to change behavior
+  based on the name, this behavior should be configurable, such as the
+  `:locals_without_parens` option.
+
+  ## Running the formatter
+
+  The formatter attempts to fit the most it can on a single line and
+  introduces line breaks wherever possible when it cannot.
+
+  In some cases, this may lead to undesired formatting. Therefore, **some
+  code generated by the formatter may not be aesthetically pleasing and
+  may require explicit intervention from the developer**. That's why we
+  do not recommend to run the formatter blindly in an existing codebase.
+  Instead you should format and sanity check each formatted file.
+
+  For example, the formatter may break a long function definition over
+  multiple clauses:
+
+      def my_function(
+        %User{name: name, age: age, ...},
+        arg1,
+        arg2
+      ) do
+        ...
+      end
+
+  While the code above is completely valid, you may prefer to match on
+  the struct variables inside the function body in order to keep the
+  definition on a single line:
+
+      def my_function(%User{} = user, arg1, arg2) do
+        %{name: name, age: age, ...} = user
+        ...
+      end
+
+  In some situations, you can use the fact the formatter does not generate
+  elegant code as a hint for refactoring. Take this code:
+
+      def board?(board_id, %User{} = user, available_permissions, required_permissions) do
+        Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and
+          required_permissions == Enum.to_list(MapSet.intersection(MapSet.new(required_permissions), MapSet.new(available_permissions)))
+      end
+
+  The code above has very long lines and running the formatter is not going
+  to address this issue. In fact, the formatter may make it more obvious that
+  you have complex expressions:
+
+      def board?(board_id, %User{} = user, available_permissions, required_permissions) do
+        Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and
+          required_permissions ==
+            Enum.to_list(
+              MapSet.intersection(
+                MapSet.new(required_permissions),
+                MapSet.new(available_permissions)
+              )
+            )
+      end
+
+  Take such cases as a suggestion that your code should be refactored:
+
+      def board?(board_id, %User{} = user, available_permissions, required_permissions) do
+        Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and
+          matching_permissions?(required_permissions, available_permissions)
+      end
+
+      defp matching_permissions?(required_permissions, available_permissions) do
+        intersection =
+          required_permissions
+          |> MapSet.new()
+          |> MapSet.intersection(MapSet.new(available_permissions))
+          |> Enum.to_list()
+
+        required_permissions == intersection
+      end
+
+  To sum it up: since the formatter cannot change the semantics of your
+  code, sometimes it is necessary to tweak or refactor the code to get
+  optimal formatting. To help better understand how to control the formatter,
+  we describe in the next sections the cases where the formatter keeps the
+  user encoding and how to control multiline expressions.
+
+  ## Line length
+
+  Another point about the formatter is that the `:line_length` configuration
+  indicates when an expression should be broken over multiple lines but it is
+  not guaranteed to do so. In many cases, it is not possible for the formatter
+  to break your code apart, which means it will go over the line length.
+  For example, if you have a long string:
+
+      "this is a very long string that will go over the line length"
+
+  The formatter doesn't know how to break it apart without changing the
+  code underlying syntax representation, so it is up to you to step in:
+
+      "this is a very long string " <>
+         "that will go over the line length"
+
+  The string concatenation makes the code fit on a single line and also
+  gives more options to the formatter.
+
+  This may also appear in keywords such as do/end blocks and operators,
+  where the `do` keyword may go over the line length because there is no
+  opportunity for the formatter to introduce a line break in a readable way.
+  For example, if you do:
+
+      case very_long_expression() do
+      end
+
+  And only the `do` keyword is beyond the line length, Elixir **will not**
+  emit this:
+
+      case very_long_expression()
+      do
+      end
+
+  So it prefers to not touch the line at all and leave `do` above the
+  line limit.
+
+  ## Keeping user's formatting
+
+  The formatter respects the input format in some cases. Those are
+  listed below:
+
+    * Insignificant digits in numbers are kept as is. The formatter,
+      however, always inserts underscores for decimal numbers with more
+      than 5 digits and converts hexadecimal digits to uppercase
+
+    * Strings, charlists, atoms and sigils are kept as is. No character
+      is automatically escaped or unescaped. The choice of delimiter is
+      also respected from the input
+
+    * Newlines inside blocks are kept as in the input except for:
+      1) expressions that take multiple lines will always have an empty
+      line before and after and 2) empty lines are always squeezed
+      together into a single empty line
+
+    * The choice between `:do` keyword and `do`-`end` blocks is left
+      to the user
+
+    * Lists, tuples, bitstrings, maps, structs and function calls will be
+      broken into multiple lines if they are followed by a newline in the
+      opening bracket and preceded by a new line in the closing bracket
+
+    * Newlines before certain operators (such as the pipeline operators)
+      and before other operators (such as comparison operators)
+
+  The behaviors above are not guaranteed. We may remove or add new
+  rules in the future. The goal of documenting them is to provide better
+  understanding on what to expect from the formatter.
+
+  ### Multi-line lists, maps, tuples, and the like
+
+  You can force lists, tuples, bitstrings, maps, structs and function
+  calls to have one entry per line by adding a newline after the opening
+  bracket and a new line before the closing bracket lines. For example:
+
+      [
+        foo,
+        bar
+      ]
+
+  If there are no newlines around the brackets, then the formatter will
+  try to fit everything on a single line, such that the snippet below
+
+      [foo,
+       bar]
+
+  will be formatted as
+
+      [foo, bar]
+
+  You can also force function calls and keywords to be rendered on multiple
+  lines by having each entry on its own line:
+
+      defstruct name: nil,
+                age: 0
+
+  The code above will be kept with one keyword entry per line by the
+  formatter. To avoid that, just squash everything into a single line.
+
+  ### Parens and no parens in function calls
+
+  Elixir has two syntaxes for function calls. With parens and no parens.
+  By default, Elixir will add parens to all calls except for:
+
+    1. calls that have `do`-`end` blocks
+    2. local calls without parens where the name and arity of the local
+       call is also listed under `:locals_without_parens` (except for
+       calls with arity 0, where the compiler always require parens)
+
+  The choice of parens and no parens also affects indentation. When a
+  function call with parens doesn't fit on the same line, the formatter
+  introduces a newline around parens and indents the arguments with two
+  spaces:
+
+      some_call(
+        arg1,
+        arg2,
+        arg3
+      )
+
+  On the other hand, function calls without parens are always indented
+  by the function call length itself, like this:
+
+      some_call arg1,
+                arg2,
+                arg3
+
+  If the last argument is a data structure, such as maps and lists, and
+  the beginning of the data structure fits on the same line as the function
+  call, then no indentation happens, this allows code like this:
+
+      Enum.reduce(some_collection, initial_value, fn element, acc ->
+        # code
+      end)
+
+      some_function_without_parens %{
+        foo: :bar,
+        baz: :bat
+      }
+
+  ## Code comments
+
+  The formatter handles code comments and guarantees a space is always added
+  between the beginning of the comment (#) and the next character.
+
+  The formatter also extracts all trailing comments to their previous line.
+  For example, the code below
+
+      hello #world
+
+  will be rewritten to
+
+      # world
+      hello
+
+  While the formatter attempts to preserve comments in most situations,
+  that's not always possible, because code comments are handled apart from
+  the code representation (AST). While the formatter can preserve code
+  comments between expressions and function arguments, the formatter
+  cannot currently preserve them around operators. For example, the following
+  code:
+
+      foo() ||
+        # also check for bar
+        bar()
+
+  will move the code comments to before the operator usage:
+
+      # also check for bar
+      foo() ||
+        bar()
+
+  In some situations, code comments can be seen as ambiguous by the formatter.
+  For example, the comment in the anonymous function below
+
+      fn
+        arg1 ->
+          body1
+          # comment
+
+        arg2 ->
+          body2
+      end
+
+  and in this one
+
+      fn
+        arg1 ->
+          body1
+
+        # comment
+        arg2 ->
+          body2
+      end
+
+  are considered equivalent (the nesting is discarded alongside most of
+  user formatting). In such cases, the code formatter will always format to
+  the latter.
+
+  ## Newlines
+
+  The formatter converts all newlines in code from `\r\n` to `\n`.
+
+  ## Migration formatting
+
+  As part of the Elixir release cycle, deprecations are being introduced,
+  emitting warnings which might require existing code to be changed.
+  In order to reduce the burden on developers when upgrading Elixir to the
+  next version, the formatter exposes some options, disabled by default,
+  in order to automate this process.
+
+  These options should address most of the typical use cases, but given they
+  introduce changes to the AST, there is a non-zero risk for meta-programming
+  heavy projects that relied on a specific AST, or projects that are
+  re-defining functions from the `Kernel`. In such cases, migrations cannot
+  be applied blindly and some extra changes might be needed in order to
+  address the deprecation warnings.
+  """
+  @doc since: "1.6.0"
+  @spec format_string!(binary, [format_opt]) :: iodata
+  def format_string!(string, opts \\ []) when is_binary(string) and is_list(opts) do
+    {line_length, opts} = Keyword.pop(opts, :line_length, 98)
+
+    to_quoted_opts =
+      [
+        unescape: false,
+        literal_encoder: &{:ok, {:__block__, &2, [&1]}},
+        token_metadata: true,
+        emit_warnings: false
+      ] ++ opts
+
+    {forms, comments} = string_to_quoted_with_comments!(string, to_quoted_opts)
+    to_algebra_opts = [comments: comments] ++ opts
+    doc = Code.Formatter.to_algebra(forms, to_algebra_opts)
+    Inspect.Algebra.format(doc, line_length)
+  end
+
+  @doc """
+  Formats a file.
+
+  See `format_string!/2` for more information on code formatting and
+  available options.
+  """
+  @doc since: "1.6.0"
+  @spec format_file!(binary, [format_opt]) :: iodata
+  def format_file!(file, opts \\ []) when is_binary(file) and is_list(opts) do
+    string = File.read!(file)
+    formatted = format_string!(string, [file: file, line: 1] ++ opts)
+    [formatted, ?\n]
+  end
+
+  @doc """
+  Evaluates the quoted contents.
+
+  **Warning**: Calling this function inside a macro is considered bad
+  practice as it will attempt to evaluate runtime values at compile time.
+  Macro arguments are typically transformed by unquoting them into the
+  returned quoted expressions (instead of evaluated).
+
+  See `eval_string/3` for a description of arguments and return types.
+  The options are described under `env_for_eval/1`.
+
+  ## Examples
+
+      iex> contents = quote(do: var!(a) + var!(b))
+      iex> {result, binding} = Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
+      iex> result
+      3
+      iex> Enum.sort(binding)
+      [a: 1, b: 2]
+
+  For convenience, you can pass `__ENV__/0` as the `opts` argument and
+  all options will be automatically extracted from the current environment:
+
+      iex> contents = quote(do: var!(a) + var!(b))
+      iex> {result, binding} = Code.eval_quoted(contents, [a: 1, b: 2], __ENV__)
+      iex> result
+      3
+      iex> Enum.sort(binding)
+      [a: 1, b: 2]
+
+  """
+  @spec eval_quoted(Macro.t(), binding, Macro.Env.t() | env_eval_opts) :: {term, binding}
+  def eval_quoted(quoted, binding \\ [], env_or_opts \\ []) do
+    {value, binding, _env} =
+      eval_verify(:eval_quoted, [quoted, binding, env_for_eval(env_or_opts)])
+
+    {value, binding}
+  end
+
+  @doc """
+  Returns an environment for evaluation.
+
+  It accepts either a `Macro.Env`, that is then pruned and prepared,
+  or a list of options. It returns an environment that is ready for
+  evaluation.
+
+  Most functions in this module will automatically prepare the given
+  environment for evaluation, so you don't need to explicitly call
+  this function, with the exception of `eval_quoted_with_env/3`,
+  which was designed precisely to be called in a loop, to implement
+  features such as interactive shells or anything else with multiple
+  evaluations.
+
+  ## Options
+
+  If an env is not given, the options can be:
+
+    * `:file` - the file to be considered in the evaluation
+
+    * `:line` - the line on which the script starts
+
+    * `:module` - the module to run the environment on
+
+    * `:prune_binding` - (since v1.14.2) prune binding to keep only
+      variables read or written by the evaluated code. Note that
+      variables used by modules are always pruned, even if later used
+      by the modules. You can submit to the `:on_module` tracer event
+      and access the variables used by the module from its environment.
+  """
+  @doc since: "1.14.0"
+  @spec env_for_eval(Macro.Env.t() | env_eval_opts) :: Macro.Env.t()
+  def env_for_eval(env_or_opts), do: :elixir.env_for_eval(env_or_opts)
+
+  @doc """
+  Evaluates the given `quoted` contents with `binding` and `env`.
+
+  This function is meant to be called in a loop, to implement features
+  such as interactive shells or anything else with multiple evaluations.
+  Therefore, the first time you call this function, you must compute
+  the initial environment with `env_for_eval/1`. The remaining calls
+  must pass the environment that was returned by this function.
+
+  ## Options
+
+  It accepts the same options as `env_for_eval/1`.
+
+  """
+  @doc since: "1.14.0"
+  @spec eval_quoted_with_env(Macro.t(), binding, Macro.Env.t(), env_eval_opts) ::
+          {term, binding, Macro.Env.t()}
+  def eval_quoted_with_env(quoted, binding, %Macro.Env{} = env, opts \\ [])
+      when is_list(binding) do
+    eval_verify(:eval_quoted, [quoted, binding, env, opts])
+  end
+
+  @doc ~S"""
+  Converts the given string to its quoted form.
+
+  Returns `{:ok, quoted_form}` if it succeeds,
+  `{:error, {meta, message_info, token}}` otherwise.
+
+  ## Options
+
+    * `:file` - the filename to be reported in case of parsing errors.
+      Defaults to `"nofile"`.
+
+    * `:line` - the starting line of the string being parsed.
+      Defaults to `1`.
+
+    * `:column` - (since v1.11.0) the starting column of the string being parsed.
+      Defaults to `1`.
+
+    * `:indentation` - (since v1.19.0) the indentation for the string being parsed.
+      This is useful when the code parsed is embedded within another document.
+      Defaults to `0`.
+
+    * `:columns` - when `true`, attach a `:column` key to the quoted
+      metadata. Defaults to `false`.
+
+    * `:unescape` (since v1.10.0) - when `false`, preserves escaped sequences.
+      For example, `"null byte\\t\\x00"` will be kept as is instead of being
+      converted to a bitstring literal. Note if you set this option to false, the
+      resulting AST is no longer valid, but it can be useful to analyze/transform
+      source code, typically in combination with `quoted_to_algebra/2`.
+      Defaults to `true`.
+
+    * `:existing_atoms_only` - when `true`, raises an error
+      when non-existing atoms are found by the tokenizer.
+      Defaults to `false`.
+
+    * `:token_metadata` (since v1.10.0) - when `true`, includes token-related
+      metadata in the expression AST, such as metadata for `do` and `end`
+      tokens, for closing tokens, end of expressions, as well as delimiters
+      for sigils. See `t:Macro.metadata/0`. Defaults to `false`.
+
+    * `:literal_encoder` (since v1.10.0) - how to encode literals in the AST.
+      It must be a function that receives two arguments, the literal and its
+      metadata, and it must return `{:ok, ast :: Macro.t}` or
+      `{:error, reason :: binary}`. If you return anything than the literal
+      itself as the `term`, then the AST is no longer valid. This option
+      may still useful for textual analysis of the source code.
+
+    * `:static_atoms_encoder` - the static atom encoder function, see
+      "The `:static_atoms_encoder` function" section below. Note this
+      option overrides the `:existing_atoms_only` behavior for static
+      atoms but `:existing_atoms_only` is still used for dynamic atoms,
+      such as atoms with interpolations.
+
+    * `:emit_warnings` (since v1.16.0) - when `false`, does not emit
+      tokenizing/parsing related warnings. Defaults to `true`.
+
+  ## `Macro.to_string/2`
+
+  The opposite of converting a string to its quoted form is
+  `Macro.to_string/2`, which converts a quoted form to a string/binary
+  representation.
+
+  ## The `:static_atoms_encoder` function
+
+  When `static_atoms_encoder: &my_encoder/2` is passed as an argument,
+  `my_encoder/2` is called every time the tokenizer needs to create a
+  "static" atom. Static atoms are atoms in the AST that function as
+  aliases, remote calls, local calls, variable names, regular atoms
+  and keyword lists.
+
+  The encoder function will receive the atom name (as a binary) and a
+  keyword list with the current file, line and column. It must return
+  `{:ok, token :: term} | {:error, reason :: binary}`.
+
+  The encoder function is supposed to create an atom from the given
+  string. To produce a valid AST, it is required to return `{:ok, term}`,
+  where `term` is an atom. It is possible to return something other than an atom,
+  however, in that case the AST is no longer "valid" in that it cannot
+  be used to compile or evaluate Elixir code. A use case for this is
+  if you want to use the Elixir parser in a user-facing situation, but
+  you don't want to exhaust the atom table.
+
+  The atom encoder is not called for *all* atoms that are present in
+  the AST. It won't be invoked for the following atoms:
+
+    * operators (`:+`, `:-`, and so on)
+
+    * syntax keywords (`fn`, `do`, `else`, and so on)
+
+    * atoms containing interpolation (`:"#{1 + 1} is two"`), as these
+      atoms are constructed at runtime
+
+    * atoms used to represent single-letter sigils like `:sigil_X`
+      (but multi-letter sigils like `:sigil_XYZ` are encoded).
+
+  ## Examples
+
+      iex> Code.string_to_quoted("1 + 3")
+      {:ok, {:+, [line: 1], [1, 3]}}
+
+      iex> Code.string_to_quoted("1 \ 3")
+      {:error, {[line: 1, column: 4], "syntax error before: ", "\"3\""}}
+
+  """
+  @spec string_to_quoted(List.Chars.t(), parser_opts) ::
+          {:ok, Macro.t()} | {:error, {location :: keyword, binary | {binary, binary}, binary}}
+  def string_to_quoted(string, opts \\ []) when is_list(opts) do
+    file = Keyword.get(opts, :file, "nofile")
+    line = Keyword.get(opts, :line, 1)
+    column = Keyword.get(opts, :column, 1)
+
+    case :elixir.string_to_tokens(to_charlist(string), line, column, file, opts) do
+      {:ok, tokens} ->
+        :elixir.tokens_to_quoted(tokens, file, opts)
+
+      {:error, _error_msg} = error ->
+        error
+    end
   end
 
   @doc """
-  Append a path to the Erlang VM code path.
+  Converts the given string to its quoted form.
 
-  The path is expanded with `Path.expand/1` before being appended.
+  It returns the AST if it succeeds,
+  raises an exception otherwise. The exception is a `TokenMissingError`
+  in case a token is missing (usually because the expression is incomplete),
+  `MismatchedDelimiterError` (in case of mismatched opening and closing delimiters) and
+  `SyntaxError` otherwise.
+
+  Check `string_to_quoted/2` for options information.
   """
-  def append_path(path) do
-    :code.add_pathz(to_char_list(Path.expand path))
+  @spec string_to_quoted!(List.Chars.t(), parser_opts) :: Macro.t()
+  def string_to_quoted!(string, opts \\ []) when is_list(opts) do
+    file = Keyword.get(opts, :file, "nofile")
+    line = Keyword.get(opts, :line, 1)
+    column = Keyword.get(opts, :column, 1)
+    :elixir.string_to_quoted!(to_charlist(string), line, column, file, opts)
   end
 
   @doc """
-  Prepend a path to the Erlang VM code path.
+  Converts the given string to its quoted form and a list of comments.
+
+  This function is useful when performing textual changes to the source code,
+  while preserving information like comments and literals position.
+
+  Returns `{:ok, quoted_form, comments}` if it succeeds,
+  `{:error, {line, error, token}}` otherwise.
+
+  Comments are maps with the following fields:
+
+    * `:line` - The line number of the source code
+
+    * `:text` - The full text of the comment, including the leading `#`
+
+    * `:previous_eol_count` - How many end of lines there are between the comment and the previous AST node or comment
+
+    * `:next_eol_count` - How many end of lines there are between the comment and the next AST node or comment
+
+  Check `string_to_quoted/2` for options information.
+
+  ## Examples
+
+      iex> Code.string_to_quoted_with_comments("\""
+      ...> :foo
+      ...>
+      ...> # Hello, world!
+      ...>
+      ...>
+      ...> # Some more comments!
+      ...> "\"")
+      {:ok, :foo, [
+        %{line: 3, column: 1, previous_eol_count: 2, next_eol_count: 3, text: "\# Hello, world!"},
+        %{line: 6, column: 1, previous_eol_count: 3, next_eol_count: 1, text: "\# Some more comments!"},
+      ]}
+
+      iex> Code.string_to_quoted_with_comments(":foo # :bar")
+      {:ok, :foo, [
+        %{line: 1, column: 6, previous_eol_count: 0, next_eol_count: 0, text: "\# :bar"}
+      ]}
 
-  The path is expanded with `Path.expand/1` before being prepended.
   """
-  def prepend_path(path) do
-    :code.add_patha(to_char_list(Path.expand path))
+  @doc since: "1.13.0"
+  @spec string_to_quoted_with_comments(List.Chars.t(), parser_opts) ::
+          {:ok, Macro.t(), list(map())} | {:error, {location :: keyword, term, term}}
+  def string_to_quoted_with_comments(string, opts \\ []) when is_list(opts) do
+    charlist = to_charlist(string)
+    file = Keyword.get(opts, :file, "nofile")
+    line = Keyword.get(opts, :line, 1)
+    column = Keyword.get(opts, :column, 1)
+
+    Process.put(:code_formatter_comments, [])
+    opts = [preserve_comments: &preserve_comments/5] ++ opts
+
+    with {:ok, tokens} <- :elixir.string_to_tokens(charlist, line, column, file, opts),
+         {:ok, forms} <- :elixir.tokens_to_quoted(tokens, file, opts) do
+      comments = Enum.reverse(Process.get(:code_formatter_comments))
+      {:ok, forms, comments}
+    end
+  after
+    Process.delete(:code_formatter_comments)
   end
 
   @doc """
-  Delete a path from the Erlang VM code path.
+  Converts the given string to its quoted form and a list of comments.
+
+  Returns the AST and a list of comments if it succeeds, raises an exception
+  otherwise. The exception is a `TokenMissingError` in case a token is missing
+  (usually because the expression is incomplete), `SyntaxError` otherwise.
 
-  The path is expanded with `Path.expand/1` before being deleted.
+  Check `string_to_quoted/2` for options information.
   """
-  def delete_path(path) do
-    :code.del_path(to_char_list(Path.expand path))
+  @doc since: "1.13.0"
+  @spec string_to_quoted_with_comments!(List.Chars.t(), parser_opts) :: {Macro.t(), list(map())}
+  def string_to_quoted_with_comments!(string, opts \\ []) do
+    charlist = to_charlist(string)
+
+    case string_to_quoted_with_comments(charlist, opts) do
+      {:ok, forms, comments} ->
+        {forms, comments}
+
+      {:error, {location, error, token}} ->
+        file = Keyword.get(opts, :file, "nofile")
+        line = Keyword.get(opts, :line, 1)
+        column = Keyword.get(opts, :column, 1)
+        input = {charlist, line, column, Keyword.get(opts, :indentation, 0)}
+        :elixir_errors.parse_error(location, file, error, token, input)
+    end
   end
 
-  @doc """
-  Evaluate the contents given by `string`.
+  defp preserve_comments(line, column, tokens, comment, rest) do
+    comments = Process.get(:code_formatter_comments)
 
-  The `binding` argument is a keyword list of variable bindings.
-  The `opts` argument is a keyword list of environment options.
+    comment = %{
+      line: line,
+      column: column,
+      previous_eol_count: min(previous_eol_count(tokens), last_comment_distance(comments, line)),
+      next_eol_count: next_eol_count(rest, 0),
+      text: List.to_string(comment)
+    }
 
-  Those options can be:
+    Process.put(:code_formatter_comments, [comment | comments])
+  end
 
-    * `:file`               - the file to be considered in the evaluation
-    * `:line`               - the line on which the script starts
-    * `:delegate_locals_to` - delegate local calls to the given module,
-                              the default is to not delegate
+  defp next_eol_count([?\s | rest], count), do: next_eol_count(rest, count)
+  defp next_eol_count([?\t | rest], count), do: next_eol_count(rest, count)
+  defp next_eol_count([?\n | rest], count), do: next_eol_count(rest, count + 1)
+  defp next_eol_count([?\r, ?\n | rest], count), do: next_eol_count(rest, count + 1)
+  defp next_eol_count(_, count), do: count
 
-  Additionally, the following scope values can be configured:
+  defp last_comment_distance([%{line: last_line} | _], line), do: line - last_line
+  defp last_comment_distance([], _line), do: :infinity
 
-    * `:aliases` - a list of tuples with the alias and its target
+  defp previous_eol_count([{token, {_, _, count}} | _])
+       when token in [:eol, :",", :";"] and count > 0 do
+    count
+  end
 
-    * `:requires` - a list of modules required
+  defp previous_eol_count([]), do: 1
+  defp previous_eol_count(_), do: 0
 
-    * `:functions` - a list of tuples where the first element is a module
-      and the second a list of imported function names and arity; the list
-      of function names and arity must be sorted
+  @doc ~S"""
+  Converts a quoted expression to an algebra document using Elixir's formatter rules.
 
-    * `:macros` - a list of tuples where the first element is a module
-      and the second a list of imported macro names and arity; the list
-      of function names and arity must be sorted
+  The algebra document can be converted into a string by calling:
 
-  Notice that setting any of the values above overrides Elixir's default
-  values. For example, setting `:requires` to `[]`, will no longer
-  automatically require the `Kernel` module; in the same way setting
-  `:macros` will no longer auto-import `Kernel` macros like `if`, `case`,
-  etc.
+      doc
+      |> Inspect.Algebra.format(:infinity)
+      |> IO.iodata_to_binary()
 
-  Returns a tuple of the form `{value, binding}`,
-  where `value` is the value returned from evaluating `string`.
-  If an error occurs while evaluating `string` an exception will be raised.
+  For a high-level function that does the same, see `Macro.to_string/1`.
 
-  `binding` is a keyword list with the value of all variable bindings
-  after evaluating `string`. The binding key is usually an atom, but it
-  may be a tuple for variables defined in a different context.
+  ## Formatting considerations
 
-  ## Examples
+  The Elixir AST does not contain metadata for literals like strings, lists, or
+  tuples with two elements, which means that the produced algebra document will
+  not respect all of the user preferences and comments may be misplaced.
+  To get better results, you can use the `:token_metadata`, `:unescape` and
+  `:literal_encoder` options to `string_to_quoted/2` to provide additional
+  information to the formatter:
 
-      iex> Code.eval_string("a + b", [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
-      {3, [a: 1, b: 2]}
+      [
+        literal_encoder: &{:ok, {:__block__, &2, [&1]}},
+        token_metadata: true,
+        unescape: false
+      ]
 
-      iex> Code.eval_string("c = a + b", [a: 1, b: 2], __ENV__)
-      {3, [a: 1, b: 2, c: 3]}
+  This will produce an AST that contains information such as `do` blocks start
+  and end lines or sigil delimiters, and by wrapping literals in blocks they can
+  now hold metadata like line number, string delimiter and escaped sequences, or
+  integer formatting (such as `0x2a` instead of `47`). However, **note this AST is
+  not valid**. If you evaluate it, it won't have the same semantics as the regular
+  Elixir AST due to the `:unescape` and `:literal_encoder` options. However,
+  those options are useful if you're doing source code manipulation, where it's
+  important to preserve user choices and comments placing.
 
-      iex> Code.eval_string("a = a + b", [a: 1, b: 2])
-      {3, [a: 3, b: 2]}
+  ## Options
 
-  For convenience, you can pass `__ENV__` as the `opts` argument and
-  all imports, requires and aliases defined in the current environment
-  will be automatically carried over:
+  This function accepts all options supported by `format_string!/2` for controlling
+  code formatting, plus these additional options:
+
+    * `:comments` - the list of comments associated with the quoted expression.
+      Defaults to `[]`. It is recommended that both `:token_metadata` and
+      `:literal_encoder` options are given to `string_to_quoted_with_comments/2`
+      in order to get proper placement for comments
 
-      iex> Code.eval_string("a + b", [a: 1, b: 2], __ENV__)
-      {3, [a: 1, b: 2]}
+    * `:escape` - when `true`, escaped sequences like `\n` will be escaped into
+      `\\n`. If the `:unescape` option was set to `false` when using
+      `string_to_quoted/2`, setting this option to `false` will prevent it from
+      escaping the sequences twice. Defaults to `true`.
 
+  See `format_string!/2` for the full list of formatting options including
+  `:file`, `:line`, `:line_length`, `:locals_without_parens`, `:force_do_end_blocks`,
+  `:syntax_colors`, and all migration options like `:migrate_charlists_as_sigils`.
   """
-  def eval_string(string, binding \\ [], opts \\ [])
+  @doc since: "1.13.0"
+  @spec quoted_to_algebra(Macro.t(), [format_opt() | quoted_to_algebra_opt()]) ::
+          Inspect.Algebra.t()
+  def quoted_to_algebra(quoted, opts \\ []) do
+    quoted
+    |> Code.Normalizer.normalize(opts)
+    |> Code.Formatter.to_algebra(opts)
+  end
 
-  def eval_string(string, binding, %Macro.Env{} = env) do
-    {value, binding, _env, _scope} = :elixir.eval to_char_list(string), binding, Map.to_list(env)
-    {value, binding}
+  @doc """
+  Evaluates the given file.
+
+  Accepts `relative_to` as an argument to tell where the file is located.
+
+  While `require_file/2` and `compile_file/2` return the loaded modules and their
+  bytecode, `eval_file/2` simply evaluates the file contents and returns the
+  evaluation result and its binding (exactly the same return value as `eval_string/3`).
+  """
+  @spec eval_file(binary, nil | binary) :: {term, binding}
+  def eval_file(file, relative_to \\ nil) when is_binary(file) do
+    {charlist, file} = find_file!(file, relative_to)
+    eval_string(charlist, [], file: file, line: 1)
   end
 
-  def eval_string(string, binding, opts) when is_list(opts) do
-    validate_eval_opts(opts)
-    {value, binding, _env, _scope} = :elixir.eval to_char_list(string), binding, opts
-    {value, binding}
+  @deprecated "Use Code.require_file/2 or Code.compile_file/2 instead"
+  @doc false
+  def load_file(file, relative_to \\ nil) when is_binary(file) do
+    {charlist, file} = find_file!(file, relative_to)
+    :elixir_code_server.call({:acquire, file})
+
+    loaded =
+      Module.ParallelChecker.verify(fn ->
+        :elixir_compiler.string(charlist, file, fn _, _ -> :ok end)
+      end)
+
+    :elixir_code_server.cast({:required, file})
+    loaded
   end
 
   @doc """
-  Evaluate the quoted contents.
+  Requires the given `file`.
 
-  See `eval_string/3` for a description of arguments and return values.
+  Accepts `relative_to` as an argument to tell where the file is located.
+  If the file was already required, `require_file/2` doesn't do anything and
+  returns `nil`.
 
-  ## Examples
+  Note that if `require_file/2` is invoked by different processes concurrently,
+  the first process to invoke `require_file/2` acquires a lock and the remaining
+  ones will block until the file is available. This means that if `require_file/2`
+  is called more than once with a given file, that file will be compiled only once.
+  The first process to call `require_file/2` will get the list of loaded modules,
+  others will get `nil`. The list of required files is managed per Erlang VM node.
 
-      iex> contents = quote(do: var!(a) + var!(b))
-      iex> Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
-      {3, [a: 1, b: 2]}
+  See `compile_file/2` if you would like to compile a file without tracking its
+  filenames. Finally, if you would like to get the result of evaluating a file rather
+  than the modules defined in it, see `eval_file/2`.
 
-  For convenience, you can pass `__ENV__` as the `opts` argument and
-  all options will be automatically extracted from the current environment:
+  ## Examples
 
-      iex> contents = quote(do: var!(a) + var!(b))
-      iex> Code.eval_quoted(contents, [a: 1, b: 2], __ENV__)
-      {3, [a: 1, b: 2]}
+  If the file has not been required, it returns the list of modules:
 
-  """
-  def eval_quoted(quoted, binding \\ [], opts \\ [])
+      modules = Code.require_file("eex_test.exs", "../eex/test")
+      List.first(modules)
+      #=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>}
 
-  def eval_quoted(quoted, binding, %Macro.Env{} = env) do
-    {value, binding, _env, _scope} = :elixir.eval_quoted quoted, binding, Map.to_list(env)
-    {value, binding}
-  end
+  If the file has been required, it returns `nil`:
 
-  def eval_quoted(quoted, binding, opts) when is_list(opts) do
-    validate_eval_opts(opts)
-    {value, binding, _env, _scope} = :elixir.eval_quoted quoted, binding, opts
-    {value, binding}
-  end
+      Code.require_file("eex_test.exs", "../eex/test")
+      #=> nil
 
-  defp validate_eval_opts(opts) do
-    if f = opts[:functions], do: validate_imports(:functions, f)
-    if m = opts[:macros],    do: validate_imports(:macros, m)
-    if a = opts[:aliases],   do: validate_aliases(:aliases, a)
-    if r = opts[:requires],  do: validate_requires(:requires, r)
-  end
+  """
+  @spec require_file(binary, nil | binary) :: [{module, binary}] | nil
+  def require_file(file, relative_to \\ nil) when is_binary(file) do
+    {charlist, file} = find_file!(file, relative_to)
+
+    case :elixir_code_server.call({:acquire, file}) do
+      :required ->
+        nil
 
-  defp validate_requires(kind, requires) do
-    valid = is_list(requires) and Enum.all?(requires, &is_atom(&1))
+      :proceed ->
+        loaded =
+          Module.ParallelChecker.verify(fn ->
+            :elixir_compiler.string(charlist, file, fn _, _ -> :ok end)
+          end)
 
-    unless valid do
-      raise ArgumentError, "expected :#{kind} option given to eval in the format: [module]"
+        :elixir_code_server.cast({:required, file})
+        loaded
     end
   end
 
-  defp validate_aliases(kind, aliases) do
-    valid = is_list(aliases) and Enum.all?(aliases, fn {k, v} ->
-      is_atom(k) and is_atom(v)
-    end)
+  @doc """
+  Gets all compilation options from the code server.
 
-    unless valid do
-      raise ArgumentError, "expected :#{kind} option given to eval in the format: [{module, module}]"
-    end
-  end
+  To get individual options, see `get_compiler_option/1`.
+  For a description of all options, see `put_compiler_option/2`.
 
-  defp validate_imports(kind, imports) do
-    valid = is_list(imports) and Enum.all?(imports, fn {k, v} ->
-      is_atom(k) and is_list(v) and Enum.all?(v, fn {name, arity} ->
-        is_atom(name) and is_integer(arity)
-      end)
-    end)
+  ## Examples
+
+      Code.compiler_options()
+      #=> %{debug_info: true, docs: true, ...}
 
-    unless valid do
-      raise ArgumentError, "expected :#{kind} option given to eval in the format: [{module, [{name, arity}]}]"
+  """
+  @spec compiler_options :: map
+  def compiler_options do
+    for key <- @available_compiler_options, into: %{} do
+      {key, :elixir_config.get(key)}
     end
   end
 
   @doc """
-  Convert the given string to its quoted form.
-
-  Returns `{:ok, quoted_form}`
-  if it succeeds, `{:error, {line, error, token}}` otherwise.
-
-  ## Options
+  Stores all given compilation options.
 
-    * `:file` - the filename to be used in stacktraces
-      and the file reported in the `__ENV__` variable
+  Changing the compilation options affect all processes
+  running in a given Erlang VM node. To store individual
+  options and for a description of all options, see
+  `put_compiler_option/2`.
 
-    * `:line` - the line reported in the `__ENV__` variable
+  Returns a map with previous values.
 
-    * `:existing_atoms_only` - when `true`, raises an error
-      when non-existing atoms are found by the tokenizer
+  ## Examples
 
-  ## Macro.to_string/2
+      Code.compiler_options(infer_signatures: false)
+      #=> %{infer_signatures: [:elixir]}
 
-  The opposite of converting a string to its quoted form is
-  `Macro.to_string/2`, which converts a quoted form to a string/binary
-  representation.
   """
-  def string_to_quoted(string, opts \\ []) when is_list(opts) do
-    file = Keyword.get opts, :file, "nofile"
-    line = Keyword.get opts, :line, 1
-    :elixir.string_to_quoted(to_char_list(string), line, file, opts)
+  @spec compiler_options(Enumerable.t({atom, term})) :: %{optional(atom) => term}
+  def compiler_options(opts) do
+    for {key, value} <- opts, into: %{} do
+      previous = get_compiler_option(key)
+      put_compiler_option(key, value)
+      {key, previous}
+    end
   end
 
   @doc """
-  Convert the given string to its quoted form.
+  Returns the value of a given compiler option.
 
-  It returns the ast if it succeeds,
-  raises an exception otherwise. The exception is a `TokenMissingError`
-  in case a token is missing (usually because the expression is incomplete),
-  `SyntaxError` otherwise.
+  For a description of all options, see `put_compiler_option/2`.
+
+  ## Examples
+
+      Code.get_compiler_option(:debug_info)
+      #=> true
 
-  Check `string_to_quoted/2` for options information.
   """
-  def string_to_quoted!(string, opts \\ []) when is_list(opts) do
-    file = Keyword.get opts, :file, "nofile"
-    line = Keyword.get opts, :line, 1
-    :elixir.string_to_quoted!(to_char_list(string), line, file, opts)
+  @doc since: "1.10.0"
+  @spec get_compiler_option(atom) :: term
+  def get_compiler_option(key) when key in @available_compiler_options do
+    :elixir_config.get(key)
+  end
+
+  # TODO: Remove me in Elixir v2.0
+  def get_compiler_option(:warnings_as_errors) do
+    IO.warn(":warnings_as_errors is deprecated as part of Code.get_compiler_option/1")
+    :ok
   end
 
   @doc """
-  Evals the given file.
+  Returns a list with all available compiler options.
 
-  Accepts `relative_to` as an argument to tell where the file is located.
+  For a description of all options, see `put_compiler_option/2`.
+
+  ## Examples
+
+      Code.available_compiler_options()
+      #=> [:docs, :debug_info, ...]
 
-  While `load_file` loads a file and returns the loaded modules and their
-  byte code, `eval_file` simply evalutes the file contents and returns the
-  evaluation result and its bindings.
   """
-  def eval_file(file, relative_to \\ nil) do
-    file = find_file(file, relative_to)
-    eval_string File.read!(file), [], [file: file, line: 1]
+  @spec available_compiler_options() :: [atom]
+  def available_compiler_options do
+    @available_compiler_options
   end
 
   @doc """
-  Load the given file.
+  Stores a compilation option.
 
-  Accepts `relative_to` as an argument to tell where the file is located.
-  If the file was already required/loaded, loads it again.
+  Changing the compilation options affect all processes running in a
+  given Erlang VM node.
+
+  Available options are:
+
+    * `:docs` - when `true`, retains documentation in the compiled module.
+      Defaults to `true`.
+
+    * `:debug_info` - when `true`, retains debug information in the compiled
+      module. This option can also be overridden per module using the `@compile`
+      directive. Defaults to `true`.
+
+      This enables tooling to partially reconstruct the original source code,
+      for instance, to perform static analysis of code. Therefore, disabling
+      `:debug_info` is not recommended as it removes the ability of the
+      Elixir compiler and other tools to provide feedback. If you want to
+      remove the `:debug_info` while deploying, tools like `mix release`
+      already do such by default.
+
+      Other environments, such as `mix test`, automatically disables this
+      via the `:test_elixirc_options` project configuration, as there is
+      typically no need to store debug chunks for test files.
+
+    * `:ignore_already_consolidated` (since v1.10.0) - when `true`, does not warn
+      when a protocol has already been consolidated and a new implementation is added.
+      Defaults to `false`.
+
+    * `:ignore_module_conflict` - when `true`, does not warn when a module has
+      already been defined. Defaults to `false`.
+
+    * `:infer_signatures` (since v1.18.0) - a list of applications of which modules
+      should be using during type inference. When `false`, it disables module-local
+      signature inference used when type checking remote calls to the compiled
+      module. Type checking will be executed regardless of the value of this option.
+      Defaults to `true`, which is equivalent to setting it to `[:elixir]` only.
+
+      When setting this option, we recommend running `mix clean` so the current module
+      may be compiled from scratch. `mix test` automatically disables this option via
+      the `:test_elixirc_options` project configuration, as there is typically no need
+      to infer signatures for test files.
+
+    * `:relative_paths` - when `true`, uses relative paths in quoted nodes,
+      warnings, and errors generated by the compiler. Note disabling this option
+      won't affect runtime warnings and errors. Defaults to `true`.
+
+    * `:no_warn_undefined` (since v1.10.0) - list of modules and `{Mod, fun, arity}`
+      tuples that will not emit warnings that the module or function does not exist
+      at compilation time. Pass atom `:all` to skip warning for all undefined
+      functions. This can be useful when doing dynamic compilation. Defaults to `[]`.
+
+    * `:tracers` (since v1.10.0) - a list of tracers (modules) to be used during
+      compilation. See the module docs for more information. Defaults to `[]`.
+
+    * `:parser_options` (since v1.10.0) - a keyword list of options to be given
+      to the parser when compiling files. It accepts the same options as
+      `string_to_quoted/2` (except by the options that change the AST itself).
+      This can be used in combination with the tracer to retrieve localized
+      information about events happening during compilation. Defaults to `[columns: true]`.
+      This option only affects code compilation functions, such as `compile_string/2`
+      and `compile_file/2` but not `string_to_quoted/2` and friends, as the
+      latter is used for other purposes beyond compilation.
+
+    * `:on_undefined_variable` (since v1.15.0) - either `:raise` or `:warn`.
+      When `:raise` (the default), undefined variables will trigger a compilation
+      error. You may be set it to `:warn` if you want undefined variables to
+      emit a warning and expand as to a local call to the zero-arity function
+      of the same name (for example, `node` would be expanded as `node()`).
+      This `:warn` behavior only exists for compatibility reasons when working
+      with old dependencies, its usage is discouraged and it will be removed
+      in future releases.
+
+  It always returns `:ok`. Raises an error for invalid options.
 
-  It returns a list of tuples `{ModuleName, <<byte_code>>}`, one tuple for
-  each module defined in the file.
+  ## Examples
+
+      Code.put_compiler_option(:debug_info, true)
+      #=> :ok
 
-  Notice that if `load_file` is invoked by different processes concurrently,
-  the target file will be loaded concurrently many times. Check `require_file/2`
-  if you don't want a file to be loaded concurrently.
   """
-  def load_file(file, relative_to \\ nil) when is_binary(file) do
-    file = find_file(file, relative_to)
-    :elixir_code_server.call {:acquire, file}
-    loaded = :elixir_compiler.file file
-    :elixir_code_server.cast {:loaded, file}
-    loaded
+  @doc since: "1.10.0"
+  @spec put_compiler_option(atom, term) :: :ok
+  def put_compiler_option(key, value) when key in @boolean_compiler_options do
+    if not is_boolean(value) do
+      raise "compiler option #{inspect(key)} should be a boolean, got: #{inspect(value)}"
+    end
+
+    :elixir_config.put(key, value)
+    :ok
   end
 
-  @doc """
-  Requires the given `file`.
+  def put_compiler_option(key, value) when key in @list_compiler_options do
+    if not is_list(value) do
+      raise "compiler option #{inspect(key)} should be a list, got: #{inspect(value)}"
+    end
 
-  Accepts `relative_to` as an argument to tell where the file is located.
-  The return value is the same as that of `load_file/2`. If the file was already
-  required/loaded, doesn't do anything and returns `nil`.
+    if key == :parser_options and not Keyword.keyword?(value) do
+      raise "compiler option #{inspect(key)} should be a keyword list, " <>
+              "got: #{inspect(value)}"
+    end
 
-  Notice that if `require_file` is invoked by different processes concurrently,
-  the first process to invoke `require_file` acquires a lock and the remaining
-  ones will block until the file is available. I.e. if `require_file` is called
-  N times with a given file, it will be loaded only once. The first process to
-  call `require_file` will get the list of loaded modules, others will get `nil`.
+    if key == :tracers and not Enum.all?(value, &is_atom/1) do
+      raise "compiler option #{inspect(key)} should be a list of modules, " <>
+              "got: #{inspect(value)}"
+    end
 
-  Check `load_file/2` if you want a file to be loaded multiple times.
-  """
-  def require_file(file, relative_to \\ nil) when is_binary(file) do
-    file = find_file(file, relative_to)
+    :elixir_config.put(key, value)
+    :ok
+  end
 
-    case :elixir_code_server.call({:acquire, file}) do
-      :loaded  ->
-        nil
-      {:queued, ref}  ->
-        receive do {:elixir_code_server, ^ref, :loaded} -> nil end
-      :proceed ->
-        loaded = :elixir_compiler.file file
-        :elixir_code_server.cast {:loaded, file}
-        loaded
-    end
+  def put_compiler_option(:infer_signatures, value) do
+    value =
+      cond do
+        value == false ->
+          false
+
+        value == true ->
+          [:elixir]
+
+        is_list(value) and Enum.all?(value, &is_atom/1) ->
+          value
+
+        true ->
+          raise "compiler option :infer_signatures should be a boolean or a list of applications, got: #{inspect(value)}"
+      end
+
+    :elixir_config.put(:infer_signatures, value)
+    :ok
   end
 
-  @doc """
-  Gets the compilation options from the code server.
+  def put_compiler_option(:no_warn_undefined, value) do
+    if value != :all and not is_list(value) do
+      raise "compiler option :no_warn_undefined should be a list or the atom :all, " <>
+              "got: #{inspect(value)}"
+    end
 
-  Check `compiler_options/1` for more information.
-  """
-  def compiler_options do
-    :elixir_code_server.call :compiler_options
+    :elixir_config.put(:no_warn_undefined, value)
+    :ok
   end
 
-  @doc """
-  Returns a list with the available compiler options.
+  # TODO: Remove me in Elixir v2.0
+  def put_compiler_option(:warnings_as_errors, _value) do
+    IO.warn(
+      ":warnings_as_errors is deprecated as part of Code.put_compiler_option/2, " <>
+        "instead you must pass it as a --warnings-as-errors flag. " <>
+        "If you need to set it as a default in a mix task, you can also set it under aliases: " <>
+        "[compile: \"compile --warnings-as-errors\"]"
+    )
 
-  See `Code.compiler_options/1` for more info.
-  """
-  def available_compiler_options do
-    [:docs, :debug_info, :ignore_module_conflict, :warnings_as_errors]
+    :ok
   end
 
-  @doc """
-  Sets compilation options.
+  # TODO: Remove me in Elixir v2.0
+  def put_compiler_option(:on_undefined_variable, value) when value in [:raise, :warn] do
+    if value == :warn do
+      IO.warn_once(
+        {__MODULE__, :on_undefined_variable},
+        fn ->
+          "setting :on_undefined_variable to :warn is deprecated. " <>
+            "The warning behaviour will be removed in future releases"
+        end,
+        3
+      )
+    end
 
-  These options are global since they are stored by Elixir's Code Server.
+    :elixir_config.put(:on_undefined_variable, value)
+    :ok
+  end
 
-  Available options are:
+  def put_compiler_option(key, _value) do
+    raise "unknown compiler option: #{inspect(key)}"
+  end
 
-    * `:docs` - when `true`, retain documentation in the compiled module,
-      `true` by default
+  @doc """
+  Purge compiler modules.
 
-    * `:debug_info` - when `true`, retain debug information in the compiled
-      module; this allows a developer to reconstruct the original source
-      code, `false` by default
+  The compiler utilizes temporary modules to compile code. For example,
+  `elixir_compiler_1`, `elixir_compiler_2`, and so on. In case the compiled code
+  stores references to anonymous functions or similar, the Elixir compiler
+  may be unable to reclaim those modules, keeping an unnecessary amount of
+  code in memory and eventually leading to modules such as `elixir_compiler_12345`.
 
-    * `:ignore_module_conflict` - when `true`, override modules that were
-      already defined without raising errors, `false` by default
+  This function purges all modules currently kept by the compiler, allowing
+  old compiler module names to be reused. If there are any processes running
+  any code from such modules, they will be terminated too.
 
-    * `:warnings_as_errors` - cause compilation to fail when warnings are
-      generated
+  This function is only meant to be called if you have a long running node
+  that is constantly evaluating code.
 
+  It returns `{:ok, number_of_modules_purged}`.
   """
-  def compiler_options(opts) do
-    {opts, bad} = Keyword.split(opts, available_compiler_options)
-    if bad != [] do
-      bad = bad |> Keyword.keys |> Enum.join(", ")
-      raise ArgumentError, message: "unknown compiler options: #{bad}"
-    end
-    :elixir_code_server.cast {:compiler_options, opts}
+  @doc since: "1.7.0"
+  @spec purge_compiler_modules() :: {:ok, non_neg_integer()}
+  def purge_compiler_modules() do
+    :elixir_code_server.call(:purge_compiler_modules)
   end
 
   @doc """
   Compiles the given string.
 
   Returns a list of tuples where the first element is the module name
-  and the second one is its byte code (as a binary).
-
-  For compiling many files at once, check `Kernel.ParallelCompiler.files/2`.
+  and the second one is its bytecode (as a binary). A `file` can be
+  given as a second argument which will be used for reporting warnings
+  and errors.
+
+  **Warning**: `string` can be any Elixir code and code can be executed with
+  the same privileges as the Erlang VM: this means that such code could
+  compromise the machine (for example by executing system commands).
+  Don't use `compile_string/2` with untrusted input (such as strings coming
+  from the network).
   """
+  @spec compile_string(List.Chars.t(), binary) :: [{module, binary}]
   def compile_string(string, file \\ "nofile") when is_binary(file) do
-    :elixir_compiler.string to_char_list(string), file
+    Module.ParallelChecker.verify(fn ->
+      :elixir_compiler.string(to_charlist(string), file, fn _, _ -> :ok end)
+    end)
   end
 
   @doc """
   Compiles the quoted expression.
 
   Returns a list of tuples where the first element is the module name and
-  the second one is its byte code (as a binary).
+  the second one is its bytecode (as a binary). A `file` can be
+  given as second argument which will be used for reporting warnings
+  and errors.
   """
+  @spec compile_quoted(Macro.t(), binary) :: [{module, binary}]
   def compile_quoted(quoted, file \\ "nofile") when is_binary(file) do
-    :elixir_compiler.quoted quoted, file
+    Module.ParallelChecker.verify(fn ->
+      :elixir_compiler.quoted(quoted, file, fn _, _ -> :ok end)
+    end)
   end
 
   @doc """
-  Ensures the given module is loaded.
+  Compiles the given file.
 
-  If the module is already loaded, this works as no-op. If the module
-  was not yet loaded, it tries to load it.
+  Accepts `relative_to` as an argument to tell where the file is located.
 
-  If it succeeds loading the module, it returns `{:module, module}`.
-  If not, returns `{:error, reason}` with the error reason.
+  Returns a list of tuples where the first element is the module name and
+  the second one is its bytecode (as a binary). Opposite to `require_file/2`,
+  it does not track the filename of the compiled file.
 
-  ## Code loading on the Erlang VM
+  If you would like to get the result of evaluating file rather than the
+  modules defined in it, see `eval_file/2`.
 
-  Erlang has two modes to load code: interactive and embedded.
+  For compiling many files concurrently, see `Kernel.ParallelCompiler.compile/2`.
+  """
+  @doc since: "1.7.0"
+  @spec compile_file(binary, nil | binary) :: [{module, binary}]
+  def compile_file(file, relative_to \\ nil) when is_binary(file) do
+    Module.ParallelChecker.verify(fn ->
+      {charlist, file} = find_file!(file, relative_to)
+      :elixir_compiler.string(charlist, file, fn _, _ -> :ok end)
+    end)
+  end
 
-  By default, the Erlang VM runs in interactive mode, where modules
-  are loaded as needed. In embedded mode the opposite happens, as all
-  modules need to be loaded upfront or explicitly.
+  @doc """
+  Ensures the given module is loaded.
 
-  Therefore, this function is used to check if a module is loaded
-  before using it and allows one to react accordingly. For example, the `URI`
-  module uses this function to check if a specific parser exists for a given
-  URI scheme.
+  If the module is already loaded, this works as no-op. If the module
+  was not yet loaded, it tries to load it.
 
-  ## `Code.ensure_compiled/1`
+  If it succeeds in loading the module, it returns `{:module, module}`.
+  If not, returns `{:error, reason}` with the error reason.
 
-  Elixir also contains an `ensure_compiled/1` function that is a
-  superset of `ensure_loaded/1`.
+  See the module documentation for more information on code loading.
 
-  Since Elixir's compilation happens in parallel, in some situations
-  you may need to use a module that was not yet compiled, therefore
-  it can't even be loaded.
+  ## Examples
 
-  `ensure_compiled/1` halts the current process until the
-  module we are depending on is available.
+      iex> Code.ensure_loaded(Atom)
+      {:module, Atom}
+
+      iex> Code.ensure_loaded(DoesNotExist)
+      {:error, :nofile}
 
-  In most cases, `ensure_loaded/1` is enough. `ensure_compiled/1`
-  must be used in rare cases, usually involving macros that need to
-  invoke a module for callback information.
   """
+  @spec ensure_loaded(module) ::
+          {:module, module} | {:error, :embedded | :badfile | :nofile | :on_load_failure}
   def ensure_loaded(module) when is_atom(module) do
     :code.ensure_loaded(module)
   end
@@ -420,122 +1992,351 @@ defmodule Code do
   Similar to `ensure_loaded/1`, but returns `true` if the module
   is already loaded or was successfully loaded. Returns `false`
   otherwise.
+
+  ## Examples
+
+      iex> Code.ensure_loaded?(String)
+      true
+
   """
-  def ensure_loaded?(module) do
+  @spec ensure_loaded?(module) :: boolean
+  def ensure_loaded?(module) when is_atom(module) do
     match?({:module, ^module}, ensure_loaded(module))
   end
 
   @doc """
-  Ensures the given module is compiled and loaded.
+  Same as `ensure_loaded/1` but raises if the module cannot be loaded.
+  """
+  @doc since: "1.12.0"
+  @spec ensure_loaded!(module) :: module
+  def ensure_loaded!(module) do
+    case ensure_loaded(module) do
+      {:module, module} ->
+        module
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "could not load module #{inspect(module)} due to reason #{inspect(reason)}"
+    end
+  end
 
-  If the module is already loaded, it works as no-op. If the module was
-  not loaded yet, it checks if it needs to be compiled first and then
-  tries to load it.
+  @doc """
+  Ensures the given modules are loaded.
+
+  Similar to `ensure_loaded/1`, but accepts a list of modules instead of a single
+  module, and loads all of them.
+
+  If all modules load successfully, returns `:ok`. Otherwise, returns `{:error, errors}`
+  where `errors` is a list of tuples made of the module and the reason it failed to load.
+
+  ## Examples
+
+      iex> Code.ensure_all_loaded([Atom, String])
+      :ok
+
+      iex> Code.ensure_all_loaded([Atom, DoesNotExist])
+      {:error, [{DoesNotExist, :nofile}]}
+
+  """
+  @doc since: "1.15.0"
+  @spec ensure_all_loaded([module]) :: :ok | {:error, [{module, reason}]}
+        when reason: :badfile | :nofile | :on_load_failure
+  def ensure_all_loaded(modules) when is_list(modules) do
+    :code.ensure_modules_loaded(modules)
+  end
+
+  @doc """
+  Same as `ensure_all_loaded/1` but raises if any of the modules cannot be loaded.
+  """
+  @doc since: "1.15.0"
+  @spec ensure_all_loaded!([module]) :: :ok
+  def ensure_all_loaded!(modules) do
+    case ensure_all_loaded(modules) do
+      :ok ->
+        :ok
+
+      {:error, errors} ->
+        formatted_errors =
+          errors
+          |> Enum.sort()
+          |> Enum.map_join("\n", fn {module, reason} ->
+            "  * #{inspect(module)} due to reason #{inspect(reason)}"
+          end)
+
+        raise ArgumentError, "could not load the following modules:\n\n" <> formatted_errors
+    end
+  end
+
+  @doc """
+  Similar to `ensure_compiled!/1` but indicates you can continue without said module.
+
+  While `ensure_compiled!/1` indicates to the Elixir compiler you can
+  only continue when said module is available, this function indicates
+  you may continue compilation without said module.
 
-  If it succeeds loading the module, it returns `{:module, module}`.
+  If it succeeds in loading the module, it returns `{:module, module}`.
   If not, returns `{:error, reason}` with the error reason.
+  If the module being checked is currently in a compiler deadlock,
+  this function returns `{:error, :unavailable}`. Unavailable doesn't
+  necessarily mean the module doesn't exist, just that it is not currently
+  available, but it (or may not) become available in the future.
+
+  Therefore, if you can only continue if the module is available, use
+  `ensure_compiled!/1` instead. In particular, do not do this:
+
+      case Code.ensure_compiled(module) do
+        {:module, _} -> module
+        {:error, _} -> raise ...
+      end
 
-  Check `ensure_loaded/1` for more information on module loading
-  and when to use `ensure_loaded/1` or `ensure_compiled/1`.
+  See the module documentation for more information on code loading.
   """
+  @spec ensure_compiled(module) ::
+          {:module, module}
+          | {:error, :embedded | :badfile | :nofile | :on_load_failure | :unavailable}
   def ensure_compiled(module) when is_atom(module) do
+    ensure_compiled(module, :soft)
+  end
+
+  @doc """
+  Ensures the given module is compiled and loaded.
+
+  If the module is already loaded, it works as no-op. If the module was
+  not compiled yet, `ensure_compiled!/1` halts the compilation of the caller
+  until the module given to `ensure_compiled!/1` becomes available or
+  all files for the current project have been compiled. If compilation
+  finishes and the module is not available or is in a deadlock, an error
+  is raised.
+
+  Given this function halts compilation, use it carefully. In particular,
+  avoid using it to guess which modules are in the system. Overuse of this
+  function can also lead to deadlocks, where two modules check at the same time
+  if the other is compiled. This returns a specific unavailable error code,
+  where we cannot successfully verify a module is available or not.
+
+  See the module documentation for more information on code loading.
+  """
+  @doc since: "1.12.0"
+  @spec ensure_compiled!(module) :: module
+  def ensure_compiled!(module) do
+    case ensure_compiled(module, :hard) do
+      {:module, module} ->
+        module
+
+      {:error, reason} ->
+        raise ArgumentError,
+              "could not load module #{inspect(module)} due to reason #{inspect(reason)}"
+    end
+  end
+
+  defp ensure_compiled(module, mode) do
     case :code.ensure_loaded(module) do
       {:error, :nofile} = error ->
-        case :erlang.get(:elixir_ensure_compiled) do
-          :undefined -> error
-          _ ->
-            try do
-              module.__info__(:module)
-              {:module, module}
-            rescue
-              UndefinedFunctionError -> error
-            end
+        if can_await_module_compilation?() do
+          case Kernel.ErrorHandler.ensure_compiled(module, :module, mode, nil) do
+            :found -> {:module, module}
+            :deadlock -> {:error, :unavailable}
+            :not_found -> {:error, :nofile}
+          end
+        else
+          error
         end
-      other -> other
+
+      other ->
+        other
     end
   end
 
   @doc """
-  Ensures the given module is compiled and loaded.
+  Returns `true` if the module is loaded.
+
+  This function doesn't attempt to load the module. For such behavior,
+  `ensure_loaded?/1` can be used.
+
+  ## Examples
+
+      iex> Code.loaded?(String)
+      true
+
+      iex> Code.loaded?(NotYetLoaded)
+      false
 
-  Similar to `ensure_compiled/1`, but returns `true` if the module
-  is already loaded or was successfully loaded and compiled.
-  Returns `false` otherwise.
   """
-  def ensure_compiled?(module) do
-    match?({:module, ^module}, ensure_compiled(module))
+  @doc since: "1.15.0"
+  @spec loaded?(module) :: boolean
+  def loaded?(module) do
+    :erlang.module_loaded(module)
   end
 
   @doc """
-  Returns the docs for the given module.
+  Returns `true` if the current process can await for module compilation.
+
+  When compiling Elixir code via `Kernel.ParallelCompiler`, which is
+  used by Mix and `elixirc`, calling a module that has not yet been
+  compiled will block the caller until the module becomes available.
+  Executing Elixir scripts, such as passing a filename to `elixir`,
+  does not await.
+  """
+  @doc since: "1.11.0"
+  @spec can_await_module_compilation? :: boolean
+  def can_await_module_compilation? do
+    :erlang.process_info(self(), :error_handler) == {:error_handler, Kernel.ErrorHandler}
+  end
+
+  @doc false
+  @deprecated "Use Code.ensure_compiled/1 instead (see the proper disclaimers in its docs)"
+  def ensure_compiled?(module) when is_atom(module) do
+    match?({:module, ^module}, ensure_compiled(module))
+  end
+
+  @doc ~S"""
+  Returns the docs for the given module or path to `.beam` file.
 
   When given a module name, it finds its BEAM code and reads the docs from it.
 
-  When given a path to a .beam file, it will load the docs directly from that
+  When given a path to a `.beam` file, it will load the docs directly from that
   file.
 
-  The return value depends on the `kind` value:
+  It returns the term stored in the documentation chunk in the format defined by
+  [EEP 48](https://www.erlang.org/eeps/eep-0048.html) or `{:error, reason}` if
+  the chunk is not available.
 
-    * `:docs` - list of all docstrings attached to functions and macros
-      using the `@doc` attribute
+  ## Examples
 
-    * `:moduledoc` - tuple `{<line>, <doc>}` where `line` is the line on
-      which module definition starts and `doc` is the string
-      attached to the module using the `@moduledoc` attribute
+      # Module documentation of an existing module
+      iex> {:docs_v1, _, :elixir, _, %{"en" => module_doc}, _, _} = Code.fetch_docs(Atom)
+      iex> module_doc |> String.split("\n") |> Enum.at(0)
+      "Atoms are constants whose values are their own name."
 
-    * `:all` - a keyword list with both `:docs` and `:moduledoc`
+      # A module that doesn't exist
+      iex> Code.fetch_docs(ModuleNotGood)
+      {:error, :module_not_found}
 
   """
-  def get_docs(module, kind) when is_atom(module) do
-    case :code.get_object_code(module) do
-      {_module, bin, _beam_path} ->
-        do_get_docs(bin, kind)
+  @doc since: "1.7.0"
+  @spec fetch_docs(module | String.t()) ::
+          {:docs_v1, annotation, beam_language, format, module_doc :: doc_content, metadata,
+           docs :: [doc_element]}
+          | {:error,
+             :module_not_found
+             | :chunk_not_found
+             | {:invalid_chunk, binary}
+             | :invalid_beam}
+        when annotation: :erl_anno.anno(),
+             beam_language: :elixir | :erlang | atom(),
+             doc_content: %{optional(binary) => binary} | :none | :hidden,
+             doc_element:
+               {{kind :: atom, function_name :: atom, arity}, annotation, signature, doc_content,
+                metadata},
+             format: binary,
+             signature: [binary],
+             metadata: map
+  def fetch_docs(module_or_path)
+
+  def fetch_docs(module) when is_atom(module) do
+    case get_beam_and_path(module) do
+      {bin, beam_path} ->
+        case fetch_docs_from_beam(bin) do
+          {:error, :chunk_not_found} ->
+            app_root = Path.expand(Path.join(["..", ".."]), beam_path)
+            path = Path.join([app_root, "doc", "chunks", "#{module}.chunk"])
+            fetch_docs_from_chunk(path)
+
+          other ->
+            other
+        end
+
+      :error ->
+        case :code.is_loaded(module) do
+          {:file, :preloaded} ->
+            # The ERTS directory is not necessarily included in releases
+            # unless it is listed as an extra application.
+            case :code.lib_dir(:erts) do
+              path when is_list(path) ->
+                path = Path.join([path, "doc", "chunks", "#{module}.chunk"])
+                fetch_docs_from_chunk(path)
+
+              {:error, _} ->
+                {:error, :chunk_not_found}
+            end
 
-      :error -> nil
+          _ ->
+            {:error, :module_not_found}
+        end
     end
   end
 
-  def get_docs(binpath, kind) when is_binary(binpath) do
-    do_get_docs(String.to_char_list(binpath), kind)
+  def fetch_docs(path) when is_binary(path) do
+    fetch_docs_from_beam(String.to_charlist(path))
+  end
+
+  defp get_beam_and_path(module) do
+    with {^module, beam, filename} <- :code.get_object_code(module),
+         info_pairs when is_list(info_pairs) <- :beam_lib.info(beam),
+         {:ok, ^module} <- Keyword.fetch(info_pairs, :module) do
+      {beam, filename}
+    else
+      _ -> :error
+    end
   end
 
-  @docs_chunk 'ExDc'
+  @docs_chunk [?D, ?o, ?c, ?s]
 
-  defp do_get_docs(bin_or_path, kind) do
+  defp fetch_docs_from_beam(bin_or_path) do
     case :beam_lib.chunks(bin_or_path, [@docs_chunk]) do
       {:ok, {_module, [{@docs_chunk, bin}]}} ->
-        lookup_docs(:erlang.binary_to_term(bin), kind)
+        load_docs_chunk(bin)
+
+      {:error, :beam_lib, {:missing_chunk, _, @docs_chunk}} ->
+        {:error, :chunk_not_found}
 
-      {:error, :beam_lib, {:missing_chunk, _, @docs_chunk}} -> nil
+      {:error, :beam_lib, {:file_error, _, :enoent}} ->
+        {:error, :module_not_found}
+
+      {:error, :beam_lib, _} ->
+        {:error, :invalid_beam}
     end
   end
 
-  defp lookup_docs({:elixir_docs_v1, docs}, kind),
-    do: do_lookup_docs(docs, kind)
+  defp fetch_docs_from_chunk(path) do
+    case File.read(path) do
+      {:ok, bin} ->
+        load_docs_chunk(bin)
+
+      {:error, _} ->
+        {:error, :chunk_not_found}
+    end
+  end
 
-  # unsupported chunk version
-  defp lookup_docs(_, _), do: nil
+  defp load_docs_chunk(bin) do
+    :erlang.binary_to_term(bin)
+  rescue
+    _ ->
+      {:error, {:invalid_chunk, bin}}
+  end
 
-  defp do_lookup_docs(docs, :all), do: docs
-  defp do_lookup_docs(docs, kind) when kind in [:docs, :moduledoc],
-    do: Keyword.get(docs, kind)
+  @doc false
+  @deprecated "Code.get_docs/2 always returns nil as its outdated documentation is no longer stored on BEAM files. Use Code.fetch_docs/1 instead"
+  def get_docs(_module, _kind) do
+    nil
+  end
 
   ## Helpers
 
   # Finds the file given the relative_to path.
   #
   # If the file is found, returns its path in binary, fails otherwise.
-  defp find_file(file, relative_to) do
-    file = if relative_to do
-      Path.expand(file, relative_to)
-    else
-      Path.expand(file)
-    end
-
-    if File.regular?(file) do
-      file
-    else
-      raise Code.LoadError, file: file
+  defp find_file!(file, relative_to) do
+    file =
+      if relative_to do
+        Path.expand(file, relative_to)
+      else
+        Path.expand(file)
+      end
+
+    case File.read(file) do
+      {:ok, bin} -> {String.to_charlist(bin), file}
+      {:error, reason} -> raise Code.LoadError, file: file, reason: reason
     end
   end
 end
diff --git a/lib/elixir/lib/code/formatter.ex b/lib/elixir/lib/code/formatter.ex
new file mode 100644
index 00000000000..70ea70ae0e8
--- /dev/null
+++ b/lib/elixir/lib/code/formatter.ex
@@ -0,0 +1,2605 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Code.Formatter do
+  @moduledoc false
+  import Inspect.Algebra, except: [format: 2, surround: 3, surround: 4]
+
+  @double_quote "\""
+  @double_heredoc "\"\"\""
+  @single_quote "'"
+  @single_heredoc "'''"
+  @sigil_c_double "~c\""
+  @sigil_c_single "~c'"
+  @sigil_c_heredoc "~c\"\"\""
+  @newlines 2
+  @min_line 0
+  @max_line 9_999_999
+  @empty empty()
+  @ampersand_prec Code.Identifier.unary_op(:&) |> elem(1)
+
+  # Operators that are composed of multiple binary operators
+  @multi_binary_operators [:..//]
+
+  # Operators that do not have space between operands
+  @no_space_binary_operators [:.., :"//"]
+
+  # Operators that do not have newline between operands (as well as => and keywords)
+  @no_newline_binary_operators [:\\, :in]
+
+  # Left associative operators that start on the next line in case of breaks (always pipes)
+  @pipeline_operators [:|>, :~>>, :<<~, :~>, :<~, :<~>, :"<|>"]
+
+  # Right associative operators that start on the next line in case of breaks
+  @right_new_line_before_binary_operators [:|, :when]
+
+  # Operators that are logical cannot be mixed without parens
+  @required_parens_logical_binary_operands [:|||, :||, :or, :&&&, :&&, :and]
+
+  # Operators with next break fits
+  @next_break_fits_operators [:<-, :==, :!=, :=~, :===, :!==, :<, :>, :<=, :>=, :=, :"::"]
+
+  # Operators that always require parens even
+  # when they are their own parents as they are not semantically associative
+  @required_parens_even_when_parent [:--, :---]
+
+  # Operators that always require parens on operands
+  # when they are the parent of another operator with a difference precedence
+  # Most operators are listed, except comparison, arithmetic, and low precedence
+  @required_parens_on_binary_operands [
+    :<<<,
+    :>>>,
+    :|>,
+    :<~,
+    :~>,
+    :<<~,
+    :~>>,
+    :<~>,
+    :"<|>",
+    :in,
+    :"^^^",
+    :"//",
+    :++,
+    :--,
+    :+++,
+    :---,
+    :<>,
+    :..
+  ]
+
+  @locals_without_parens [
+    # Special forms
+    alias: 1,
+    alias: 2,
+    case: 2,
+    cond: 1,
+    for: :*,
+    import: 1,
+    import: 2,
+    quote: 1,
+    quote: 2,
+    receive: 1,
+    require: 1,
+    require: 2,
+    try: 1,
+    with: :*,
+
+    # Kernel
+    def: 1,
+    def: 2,
+    defp: 1,
+    defp: 2,
+    defguard: 1,
+    defguardp: 1,
+    defmacro: 1,
+    defmacro: 2,
+    defmacrop: 1,
+    defmacrop: 2,
+    defmodule: 2,
+    defdelegate: 2,
+    defexception: 1,
+    defoverridable: 1,
+    defstruct: 1,
+    destructure: 2,
+    raise: 1,
+    raise: 2,
+    reraise: 2,
+    reraise: 3,
+    if: 2,
+    unless: 2,
+    use: 1,
+    use: 2,
+
+    # Stdlib,
+    defrecord: 2,
+    defrecord: 3,
+    defrecordp: 2,
+    defrecordp: 3,
+
+    # Testing
+    assert: 1,
+    assert: 2,
+    assert_in_delta: 3,
+    assert_in_delta: 4,
+    assert_raise: 2,
+    assert_raise: 3,
+    assert_receive: 1,
+    assert_receive: 2,
+    assert_receive: 3,
+    assert_received: 1,
+    assert_received: 2,
+    doctest: 1,
+    doctest: 2,
+    refute: 1,
+    refute: 2,
+    refute_in_delta: 3,
+    refute_in_delta: 4,
+    refute_receive: 1,
+    refute_receive: 2,
+    refute_receive: 3,
+    refute_received: 1,
+    refute_received: 2,
+    setup: 1,
+    setup: 2,
+    setup_all: 1,
+    setup_all: 2,
+    test: 1,
+    test: 2,
+
+    # Mix config
+    config: 2,
+    config: 3,
+    import_config: 1
+  ]
+
+  @do_end_keywords [:rescue, :catch, :else, :after]
+
+  @doc """
+  Converts the quoted expression into an algebra document.
+  """
+  @spec to_algebra(Macro.t(), keyword()) :: Inspect.Algebra.t()
+  def to_algebra(quoted, opts \\ []) do
+    comments = Keyword.get(opts, :comments, [])
+
+    state =
+      comments
+      |> Enum.map(&format_comment/1)
+      |> gather_comments()
+      |> state(opts)
+
+    {doc, _} = block_to_algebra(quoted, @min_line, @max_line, state)
+    doc
+  end
+
+  @doc """
+  Lists all default locals without parens.
+  """
+  def locals_without_parens do
+    @locals_without_parens
+  end
+
+  @doc """
+  Checks if a function is a local without parens.
+  """
+  def local_without_parens?(fun, arity, locals_without_parens) do
+    arity > 0 and
+      Enum.any?(locals_without_parens, fn {key, val} ->
+        key == fun and (val == :* or val == arity)
+      end)
+  end
+
+  defp state(comments, opts) do
+    force_do_end_blocks = Keyword.get(opts, :force_do_end_blocks, false)
+    locals_without_parens = Keyword.get(opts, :locals_without_parens, [])
+    file = Keyword.get(opts, :file, nil)
+    sigils = Keyword.get(opts, :sigils, [])
+    migrate = Keyword.get(opts, :migrate, false)
+    migrate_bitstring_modifiers = Keyword.get(opts, :migrate_bitstring_modifiers, migrate)
+    migrate_call_parens_on_pipe = Keyword.get(opts, :migrate_call_parens_on_pipe, migrate)
+    migrate_charlists_as_sigils = Keyword.get(opts, :migrate_charlists_as_sigils, migrate)
+    migrate_unless = Keyword.get(opts, :migrate_unless, migrate)
+    syntax_colors = Keyword.get(opts, :syntax_colors, [])
+
+    sigils =
+      Map.new(sigils, fn {key, value} ->
+        with true <- is_atom(key) and is_function(value, 2),
+             name = Atom.to_charlist(key),
+             true <- Enum.all?(name, &(&1 in ?A..?Z)) do
+          {name, value}
+        else
+          _ ->
+            raise ArgumentError,
+                  ":sigils must be a keyword list with uppercased atoms as keys and an " <>
+                    "anonymous function expecting two arguments as value, got: #{inspect(sigils)}"
+        end
+      end)
+
+    %{
+      force_do_end_blocks: force_do_end_blocks,
+      locals_without_parens: locals_without_parens ++ locals_without_parens(),
+      operand_nesting: 2,
+      skip_eol: false,
+      comments: comments,
+      sigils: sigils,
+      file: file,
+      migrate_bitstring_modifiers: migrate_bitstring_modifiers,
+      migrate_call_parens_on_pipe: migrate_call_parens_on_pipe,
+      migrate_charlists_as_sigils: migrate_charlists_as_sigils,
+      migrate_unless: migrate_unless,
+      inspect_opts: %Inspect.Opts{syntax_colors: syntax_colors}
+    }
+  end
+
+  defp format_comment(%{text: text} = comment) do
+    %{comment | text: format_comment_text(text)}
+  end
+
+  defp format_comment_text("#"), do: "#"
+  defp format_comment_text("#!" <> rest), do: "#!" <> rest
+  defp format_comment_text("##" <> rest), do: "#" <> format_comment_text("#" <> rest)
+  defp format_comment_text("# " <> rest), do: "# " <> rest
+  defp format_comment_text("#" <> rest), do: "# " <> rest
+
+  # If there is a no new line before, we can't gather all followup comments.
+  defp gather_comments([%{previous_eol_count: 0} = comment | comments]) do
+    comment = %{comment | previous_eol_count: @newlines}
+    [comment | gather_comments(comments)]
+  end
+
+  defp gather_comments([comment | comments]) do
+    %{line: line, next_eol_count: next_eol_count, text: doc} = comment
+
+    {next_eol_count, comments, doc} =
+      gather_followup_comments(line + 1, next_eol_count, comments, doc)
+
+    comment = %{comment | next_eol_count: next_eol_count, text: doc}
+    [comment | gather_comments(comments)]
+  end
+
+  defp gather_comments([]) do
+    []
+  end
+
+  defp gather_followup_comments(line, _, [%{line: line} = comment | comments], doc)
+       when comment.previous_eol_count != 0 do
+    %{next_eol_count: next_eol_count, text: text} = comment
+    gather_followup_comments(line + 1, next_eol_count, comments, line(doc, text))
+  end
+
+  defp gather_followup_comments(_line, next_eol_count, comments, doc) do
+    {next_eol_count, comments, doc}
+  end
+
+  # Special AST nodes from compiler feedback
+
+  defp quoted_to_algebra({{:special, :clause_args}, _meta, [args]}, _context, state) do
+    {doc, state} = clause_args_to_algebra(args, state)
+    {group(doc), state}
+  end
+
+  defp quoted_to_algebra({{:special, :bitstring_segment}, _meta, [arg, last]}, _context, state) do
+    bitstring_segment_to_algebra({arg, -1}, state, last)
+  end
+
+  defp quoted_to_algebra({var, _meta, var_context}, _context, state) when is_atom(var_context) do
+    {var |> Atom.to_string() |> string() |> color_doc(:variable, state.inspect_opts), state}
+  end
+
+  defp quoted_to_algebra({:<<>>, meta, entries}, _context, state) do
+    cond do
+      entries == [] ->
+        {"<<>>", state}
+
+      not interpolated?(entries) ->
+        bitstring_to_algebra(meta, entries, state)
+
+      meta[:delimiter] == ~s["""] ->
+        {doc, state} =
+          entries
+          |> prepend_heredoc_line()
+          |> interpolation_to_algebra(~s["""], state, @double_heredoc, @double_heredoc)
+
+        {force_unfit(doc), state}
+
+      true ->
+        interpolation_to_algebra(entries, @double_quote, state, @double_quote, @double_quote)
+    end
+  end
+
+  # TODO: Remove this clause on Elixir v2.0 once single-quoted charlists are removed
+  defp quoted_to_algebra(
+         {{:., _, [List, :to_charlist]}, meta, [entries]} = quoted,
+         context,
+         state
+       ) do
+    cond do
+      not list_interpolated?(entries) ->
+        remote_to_algebra(quoted, context, state)
+
+      meta[:delimiter] == ~s['''] ->
+        {opener, quotes} = get_charlist_quotes(:heredoc, state)
+
+        {doc, state} =
+          entries
+          |> prepend_heredoc_line()
+          |> list_interpolation_to_algebra(quotes, state, opener, quotes)
+
+        {force_unfit(doc), state}
+
+      true ->
+        {opener, quotes} = get_charlist_quotes({:regular, entries}, state)
+        list_interpolation_to_algebra(entries, quotes, state, opener, quotes)
+    end
+  end
+
+  defp quoted_to_algebra(
+         {{:., _, [:erlang, :binary_to_atom]}, _, [{:<<>>, _, entries}, :utf8]} = quoted,
+         context,
+         state
+       ) do
+    if interpolated?(entries) do
+      interpolation_to_algebra(entries, @double_quote, state, ":\"", @double_quote)
+    else
+      remote_to_algebra(quoted, context, state)
+    end
+  end
+
+  # foo[bar]
+  defp quoted_to_algebra({{:., _, [Access, :get]}, meta, [target, arg]}, _context, state) do
+    {target_doc, state} = remote_target_to_algebra(target, state)
+
+    {access_doc, state} =
+      if keyword?(arg) do
+        list_to_algebra(meta, arg, state)
+      else
+        list_to_algebra(meta, [arg], state)
+      end
+
+    {concat(target_doc, access_doc), state}
+  end
+
+  # %Foo{}
+  # %name{foo: 1}
+  # %name{bar | foo: 1}
+  defp quoted_to_algebra({:%, _, [name, {:%{}, meta, args}]}, _context, state) do
+    {name_doc, state} = quoted_to_algebra(name, :parens_arg, state)
+    map_to_algebra(meta, name_doc, args, state)
+  end
+
+  # %{foo: 1}
+  # %{foo => bar}
+  # %{name | foo => bar}
+  defp quoted_to_algebra({:%{}, meta, args}, _context, state) do
+    map_to_algebra(meta, @empty, args, state)
+  end
+
+  # {}
+  # {1, 2}
+  defp quoted_to_algebra({:{}, meta, args}, _context, state) do
+    tuple_to_algebra(meta, args, :flex_break, state)
+  end
+
+  defp quoted_to_algebra({:__block__, meta, [{left, right}]}, _context, state) do
+    tuple_to_algebra(meta, [left, right], :flex_break, state)
+  end
+
+  # (left -> right)
+  defp quoted_to_algebra({:__block__, _, [[{:->, _, _} | _] = clauses]}, _context, state) do
+    paren_fun_to_algebra(clauses, @max_line, @min_line, state)
+  end
+
+  defp quoted_to_algebra({:__block__, meta, [list]}, _context, state) when is_list(list) do
+    case meta[:delimiter] do
+      ~s['''] ->
+        {opener, quotes} = get_charlist_quotes(:heredoc, state)
+        string = list |> List.to_string() |> escape_heredoc(quotes)
+        {opener |> concat(string) |> concat(quotes) |> force_unfit(), state}
+
+      ~s['] ->
+        string = list |> List.to_string()
+        {opener, quotes} = get_charlist_quotes({:regular, [string]}, state)
+        string = escape_string(string, quotes)
+        {opener |> concat(string) |> concat(quotes), state}
+
+      _other ->
+        list_to_algebra(meta, list, state)
+    end
+  end
+
+  defp quoted_to_algebra({:__block__, meta, [string]}, _context, state) when is_binary(string) do
+    if meta[:delimiter] == ~s["""] do
+      string = escape_heredoc(string, ~s["""])
+
+      {@double_heredoc
+       |> concat(string)
+       |> concat(@double_heredoc)
+       |> color_doc(:string, state.inspect_opts)
+       |> force_unfit(), state}
+    else
+      string = escape_string(string, @double_quote)
+
+      {@double_quote
+       |> concat(string)
+       |> concat(@double_quote)
+       |> color_doc(:string, state.inspect_opts), state}
+    end
+  end
+
+  defp quoted_to_algebra({:__block__, meta, [atom]}, _context, state) when is_atom(atom) do
+    {atom_to_algebra(atom, meta, state.inspect_opts), state}
+  end
+
+  defp quoted_to_algebra({:__block__, meta, [integer]}, _context, state)
+       when is_integer(integer) do
+    {Keyword.fetch!(meta, :token) |> integer_to_algebra(state.inspect_opts), state}
+  end
+
+  defp quoted_to_algebra({:__block__, meta, [float]}, _context, state) when is_float(float) do
+    {Keyword.fetch!(meta, :token) |> float_to_algebra(state.inspect_opts), state}
+  end
+
+  # (unquote_splicing(...))
+  defp quoted_to_algebra(
+         {:__block__, _meta, [{:unquote_splicing, meta, [_] = args}]},
+         context,
+         state
+       ) do
+    {doc, state} = local_to_algebra(:unquote_splicing, meta, args, context, state)
+    {wrap_in_parens(doc), state}
+  end
+
+  defp quoted_to_algebra({:__block__, _meta, [arg]}, context, state) do
+    quoted_to_algebra(arg, context, state)
+  end
+
+  defp quoted_to_algebra({:__block__, _meta, []}, _context, state) do
+    {color_doc("nil", nil, state.inspect_opts), state}
+  end
+
+  defp quoted_to_algebra({:__block__, meta, args} = block, _context, state) when is_list(args) do
+    {block, state} = block_to_algebra(block, line(meta), closing_line(meta), state)
+    {surround("(", block, ")"), state}
+  end
+
+  defp quoted_to_algebra({:__aliases__, _meta, [head | tail]}, context, state) do
+    {doc, state} =
+      if is_atom(head) do
+        {Atom.to_string(head), state}
+      else
+        quoted_to_algebra_with_parens_if_operator(head, context, state)
+      end
+
+    {Enum.reduce(tail, doc, &concat(&2, "." <> Atom.to_string(&1)))
+     |> color_doc(:atom, state.inspect_opts), state}
+  end
+
+  # &1
+  # &local(&1)
+  # &local/1
+  # &Mod.remote/1
+  # & &1
+  # & &1 + &2
+  defp quoted_to_algebra({:&, _, [arg]}, context, state) do
+    capture_to_algebra(arg, context, state)
+  end
+
+  defp quoted_to_algebra({:@, meta, [arg]}, context, state) do
+    module_attribute_to_algebra(meta, arg, context, state)
+  end
+
+  # not(left in right)
+  # left not in right
+  defp quoted_to_algebra({:not, meta, [{:in, _, [left, right]}]}, context, state) do
+    binary_op_to_algebra(:in, "not in", meta, left, right, context, state)
+  end
+
+  # disable migrate_call_parens_on_pipe within defmacro
+  defp quoted_to_algebra(
+         {atom, _, [{:|>, _, _}, _]} = ast,
+         context,
+         %{migrate_call_parens_on_pipe: true} = state
+       )
+       when atom in [:defmacro, :defmacrop] do
+    quoted_to_algebra(ast, context, %{state | migrate_call_parens_on_pipe: false})
+  end
+
+  defp quoted_to_algebra(
+         {atom, _, [{:unless, _, _}, _]} = ast,
+         context,
+         %{migrate_unless: true} = state
+       )
+       when atom in [:defmacro, :defmacrop] do
+    quoted_to_algebra(ast, context, %{state | migrate_unless: false})
+  end
+
+  # rewrite unless as if!
+  defp quoted_to_algebra(
+         {:unless, meta, [condition, block]},
+         context,
+         %{migrate_unless: true} = state
+       ) do
+    quoted_to_algebra({:if, meta, [negate_condition(condition), block]}, context, state)
+  end
+
+  # a |> b() |> unless(...) => a |> b() |> Kernel.!() |> unless(...)
+  defp quoted_to_algebra(
+         {:|>, meta1, [{:|>, _, _} = condition, {:unless, meta2, [block]}]},
+         context,
+         %{migrate_unless: true} = state
+       ) do
+    negated_condition = {:|>, [], [condition, {{:., [], [Kernel, :!]}, [closing: []], []}]}
+
+    quoted_to_algebra(
+      {:|>, meta1, [negated_condition, {:if, meta2, [block]}]},
+      context,
+      state
+    )
+  end
+
+  # condition |> unless(...) => negated(condition) |> unless(...)
+  defp quoted_to_algebra(
+         {:|>, meta1, [condition, {:unless, meta2, [block]}]},
+         context,
+         %{migrate_unless: true} = state
+       ) do
+    quoted_to_algebra(
+      {:|>, meta1, [negate_condition(condition), {:if, meta2, [block]}]},
+      context,
+      state
+    )
+  end
+
+  # ..
+  defp quoted_to_algebra({:.., _meta, []}, context, state) do
+    if context in [:no_parens_arg, :no_parens_one_arg] do
+      {"(..)", state}
+    else
+      {"..", state}
+    end
+  end
+
+  # ...
+  defp quoted_to_algebra({:..., _meta, []}, _context, state) do
+    {"...", state}
+  end
+
+  # 1..2//3
+  defp quoted_to_algebra({:..//, meta, [left, middle, right]}, context, state) do
+    quoted_to_algebra({:"//", meta, [{:.., meta, [left, middle]}, right]}, context, state)
+  end
+
+  defp quoted_to_algebra({:fn, meta, [_ | _] = clauses}, _context, state) do
+    anon_fun_to_algebra(clauses, line(meta), closing_line(meta), state, eol?(meta, state))
+  end
+
+  defp quoted_to_algebra({fun, meta, args}, context, state) when is_atom(fun) and is_list(args) do
+    with :error <- maybe_sigil_to_algebra(fun, meta, args, state),
+         :error <- maybe_unary_op_to_algebra(fun, meta, args, context, state),
+         :error <- maybe_binary_op_to_algebra(fun, meta, args, context, state),
+         do: local_to_algebra(fun, meta, args, context, state)
+  end
+
+  defp quoted_to_algebra({_, _, args} = quoted, context, state) when is_list(args) do
+    remote_to_algebra(quoted, context, state)
+  end
+
+  # [keyword: :list] (inner part)
+  # %{:foo => :bar} (inner part)
+  defp quoted_to_algebra(list, context, state) when is_list(list) do
+    many_args_to_algebra(list, state, &quoted_to_algebra(&1, context, &2))
+  end
+
+  # keyword: :list
+  # key => value
+  defp quoted_to_algebra({left_arg, right_arg}, context, state) do
+    {left, op, right, state} =
+      if keyword_key?(left_arg) do
+        {left, state} =
+          case left_arg do
+            {:__block__, _, [atom]} when is_atom(atom) ->
+              formatted = Macro.inspect_atom(:key, atom, escape: &escape_atom/2)
+
+              {formatted
+               |> string()
+               |> color_doc(:atom, state.inspect_opts), state}
+
+            {{:., _, [:erlang, :binary_to_atom]}, _, [{:<<>>, _, entries}, :utf8]} ->
+              interpolation_to_algebra(entries, @double_quote, state, "\"", "\":")
+          end
+
+        {right, state} = quoted_to_algebra(right_arg, context, state)
+        {left, "", right, state}
+      else
+        {left, state} = quoted_to_algebra(left_arg, context, state)
+        {right, state} = quoted_to_algebra(right_arg, context, state)
+        left = wrap_in_parens_if_binary_operator(left, left_arg)
+        {left, " =>", right, state}
+      end
+
+    doc =
+      concat(
+        group(left),
+        with_next_break_fits(next_break_fits?(right_arg, state), right, fn right ->
+          nest(glue(op, right), 2, :break)
+        end)
+      )
+
+    {doc, state}
+  end
+
+  # #PID's and #Ref's may appear on regular AST
+  # Other foreign structures, such as maps and structs,
+  # may appear from Macro.to_string, so we stick a limit,
+  # although they won't be formatted accordingly.
+  defp quoted_to_algebra(unknown, _context, state) do
+    {inspect(unknown, printable_limit: :infinity), state}
+  end
+
+  ## Blocks
+
+  defp block_to_algebra([{:->, _, _} | _] = paren_fun, min_line, max_line, state) do
+    paren_fun_to_algebra(paren_fun, min_line, max_line, state)
+  end
+
+  defp block_to_algebra({:__block__, _, []}, min_line, max_line, state) do
+    block_args_to_algebra([], min_line, max_line, state)
+  end
+
+  defp block_to_algebra({:__block__, _, [_, _ | _] = args}, min_line, max_line, state) do
+    block_args_to_algebra(args, min_line, max_line, state)
+  end
+
+  defp block_to_algebra(block, min_line, max_line, state) do
+    block_args_to_algebra([block], min_line, max_line, state)
+  end
+
+  defp block_args_to_algebra(args, min_line, max_line, state) do
+    quoted_to_algebra = fn {kind, meta, _} = arg, _args, state ->
+      newlines = meta[:end_of_expression][:newlines] || 1
+      {doc, state} = quoted_to_algebra(arg, :block, state)
+      {{doc, block_next_line(kind), newlines}, state}
+    end
+
+    {args_docs, _comments?, state} =
+      quoted_to_algebra_with_comments(args, [], min_line, max_line, state, quoted_to_algebra)
+
+    case args_docs do
+      [] -> {@empty, state}
+      [line] -> {line, state}
+      lines -> {lines |> Enum.reduce(&line(&2, &1)) |> force_unfit(), state}
+    end
+  end
+
+  defp block_next_line(:@), do: @empty
+  defp block_next_line(_), do: break("")
+
+  ## Operators
+
+  defp maybe_unary_op_to_algebra(fun, meta, args, context, state) do
+    with [arg] <- args,
+         {_, _} <- Code.Identifier.unary_op(fun) do
+      unary_op_to_algebra(fun, meta, arg, context, state)
+    else
+      _ -> :error
+    end
+  end
+
+  defp unary_op_to_algebra(op, _meta, arg, context, state) do
+    {doc, state} = quoted_to_algebra(arg, force_many_args_or_operand(context, :operand), state)
+
+    # not and ! are nestable, all others are not.
+    doc =
+      case arg do
+        {^op, _, [_]} when op in [:!, :not] -> doc
+        _ -> wrap_in_parens_if_operator(doc, arg)
+      end
+
+    # not requires a space unless the doc was wrapped in parens.
+    op_string =
+      if op == :not do
+        "not "
+      else
+        Atom.to_string(op)
+      end
+
+    {color_doc(op_string, :operator, state.inspect_opts) |> concat(doc), state}
+  end
+
+  defp maybe_binary_op_to_algebra(fun, meta, args, context, state) do
+    with [left, right] <- args,
+         {_, _} <- augmented_binary_op(fun) do
+      binary_op_to_algebra(fun, Atom.to_string(fun), meta, left, right, context, state)
+    else
+      _ -> :error
+    end
+  end
+
+  # There are five kinds of operators.
+  #
+  #   1. no space binary operators, for example,  1..2
+  #   2. no newline binary operators, for example, left in right
+  #   3. strict newlines before a left precedent operator, for example, foo |> bar |> baz
+  #   4. strict newlines before a right precedent operator, for example, foo when bar when baz
+  #   5. flex newlines after the operator, for example, foo ++ bar ++ baz
+  #
+  # Cases 1, 2 and 5 are handled fairly easily by relying on the
+  # operator precedence and making sure nesting is applied only once.
+  #
+  # Cases 3 and 4 are the complex ones, as it requires passing the
+  # strict or flex mode around.
+  defp binary_op_to_algebra(op, op_string, meta, left_arg, right_arg, context, state) do
+    %{operand_nesting: nesting} = state
+    binary_op_to_algebra(op, op_string, meta, left_arg, right_arg, context, state, nesting)
+  end
+
+  defp binary_op_to_algebra(op, op_string, meta, left_arg, right_arg, context, state, _nesting)
+       when op in @right_new_line_before_binary_operators do
+    op_info = augmented_binary_op(op)
+    op_string = op_string <> " "
+    left_context = left_op_context(context)
+    right_context = right_op_context(context)
+
+    min_line =
+      case left_arg do
+        {_, left_meta, _} -> line(left_meta)
+        _ -> line(meta)
+      end
+
+    {operands, max_line} =
+      unwrap_right(right_arg, op, meta, right_context, [{{:root, left_context}, left_arg}])
+
+    fun = fn
+      {{:root, context}, arg}, _args, state ->
+        {doc, state} = binary_operand_to_algebra(arg, context, state, op, op_info, :left, 2)
+        {{doc, @empty, 1}, state}
+
+      {{kind, context}, arg}, _args, state ->
+        {doc, state} = binary_operand_to_algebra(arg, context, state, op, op_info, kind, 0)
+        doc = doc |> nest_by_length(op_string) |> force_keyword(arg)
+        {{concat(op_string, doc), @empty, 1}, state}
+    end
+
+    {doc, state} =
+      operand_to_algebra_with_comments(operands, meta, min_line, max_line, context, state, fun)
+
+    if keyword?(right_arg) and context in [:parens_arg, :no_parens_arg] do
+      {wrap_in_parens(doc), state}
+    else
+      {doc, state}
+    end
+  end
+
+  defp binary_op_to_algebra(op, _, meta, left_arg, right_arg, context, state, _nesting)
+       when op in @pipeline_operators do
+    op_info = augmented_binary_op(op)
+    left_context = left_op_context(context)
+    right_context = right_op_context(context)
+    max_line = line(meta)
+
+    {pipes, min_line} =
+      unwrap_pipes(left_arg, meta, left_context, [{{op, right_context}, right_arg}])
+
+    fun = fn
+      {{:root, context}, arg}, _args, state ->
+        {doc, state} = binary_operand_to_algebra(arg, context, state, op, op_info, :left, 2)
+        {{doc, @empty, 1}, state}
+
+      {{op, context}, arg}, _args, state ->
+        op_info = augmented_binary_op(op)
+        op_string = Atom.to_string(op) <> " "
+        {doc, state} = binary_operand_to_algebra(arg, context, state, op, op_info, :right, 0)
+        {{concat(op_string, doc), @empty, 1}, state}
+    end
+
+    operand_to_algebra_with_comments(pipes, meta, min_line, max_line, context, state, fun)
+  end
+
+  defp binary_op_to_algebra(op, op_string, meta, left_arg, right_arg, context, state, nesting) do
+    op_info = augmented_binary_op(op)
+    left_context = left_op_context(context)
+    right_context = right_op_context(context)
+
+    {left, state} =
+      binary_operand_to_algebra(left_arg, left_context, state, op, op_info, :left, 2)
+
+    {right, state} =
+      binary_operand_to_algebra(right_arg, right_context, state, op, op_info, :right, 0)
+
+    {op_string, right} =
+      cond do
+        op in @no_space_binary_operators ->
+          {op_string, group(right)}
+
+        op in @no_newline_binary_operators ->
+          {" " <> op_string <> " ", group(right)}
+
+        true ->
+          eol? = eol?(meta, state)
+
+          next_break_fits? =
+            op in @next_break_fits_operators and next_break_fits?(right_arg, state) and not eol?
+
+          {" " <> op_string,
+           with_next_break_fits(next_break_fits?, right, fn right ->
+             right = nest(concat(break(), right), nesting, :break)
+             if eol?, do: force_unfit(right), else: right
+           end)}
+      end
+
+    op_doc = color_doc(op_string, :operator, state.inspect_opts)
+    doc = concat(concat(group(left), op_doc), group(right))
+    {doc, state}
+  end
+
+  # TODO: We can remove this workaround once we remove
+  # ?rearrange_uop from the parser on v2.0.
+  # (! left) in right
+  # (not left) in right
+  defp binary_operand_to_algebra(
+         {:__block__, _, [{op, meta, [arg]}]},
+         context,
+         state,
+         :in,
+         _parent_info,
+         :left,
+         _nesting
+       )
+       when op in [:not, :!] do
+    {doc, state} = unary_op_to_algebra(op, meta, arg, context, state)
+    {wrap_in_parens(doc), state}
+  end
+
+  # |> var
+  # |> var()
+  defp binary_operand_to_algebra(
+         {var, meta, var_context},
+         context,
+         %{migrate_call_parens_on_pipe: true} = state,
+         :|>,
+         _parent_info,
+         :right,
+         _nesting
+       )
+       when is_atom(var) and is_atom(var_context) do
+    operand = {var, meta, []}
+    quoted_to_algebra(operand, context, state)
+  end
+
+  # |> var.fun
+  # |> var.fun()
+  defp binary_operand_to_algebra(
+         {{:., _, [_, fun]} = call, meta, []},
+         context,
+         %{migrate_call_parens_on_pipe: true} = state,
+         :|>,
+         _parent_info,
+         :right,
+         _nesting
+       )
+       when is_atom(fun) do
+    meta = Keyword.put_new_lazy(meta, :closing, fn -> [line: meta[:line]] end)
+    quoted_to_algebra({call, meta, []}, context, state)
+  end
+
+  defp binary_operand_to_algebra(operand, context, state, parent_op, parent_info, side, nesting) do
+    {parent_assoc, parent_prec} = parent_info
+
+    with {op, meta, [left, right]} <- operand,
+         op_info = augmented_binary_op(op),
+         {_assoc, prec} <- op_info do
+      op_string = Atom.to_string(op)
+
+      cond do
+        # If we have the same operator and it is in the correct side,
+        # we don't add parens unless it is explicitly required.
+        parent_assoc == side and op == parent_op and op not in @required_parens_even_when_parent ->
+          binary_op_to_algebra(op, op_string, meta, left, right, context, state, nesting)
+
+        # If the operator requires parens (most of them do) or we are mixing logical operators
+        # or the precedence is inverted or it is in the wrong side, then we *need* parenthesis.
+        (parent_op in @required_parens_on_binary_operands and op not in @no_space_binary_operators) or
+          (op in @required_parens_logical_binary_operands and
+             parent_op in @required_parens_logical_binary_operands) or parent_prec > prec or
+            (parent_prec == prec and parent_assoc != side) ->
+          {operand, state} =
+            binary_op_to_algebra(op, op_string, meta, left, right, context, state, 2)
+
+          {wrap_in_parens(operand), state}
+
+        # Otherwise, we rely on precedence but also nest.
+        true ->
+          binary_op_to_algebra(op, op_string, meta, left, right, context, state, 2)
+      end
+    else
+      {:&, _, [arg]}
+      when not is_integer(arg) and side == :left
+      when not is_integer(arg) and parent_assoc == :left and parent_prec > @ampersand_prec ->
+        {doc, state} = quoted_to_algebra(operand, context, state)
+        {wrap_in_parens(doc), state}
+
+      _ ->
+        quoted_to_algebra(operand, context, state)
+    end
+  end
+
+  defp unwrap_pipes({op, meta, [left, right]}, _meta, context, acc)
+       when op in @pipeline_operators do
+    left_context = left_op_context(context)
+    right_context = right_op_context(context)
+    unwrap_pipes(left, meta, left_context, [{{op, right_context}, right} | acc])
+  end
+
+  defp unwrap_pipes(left, meta, context, acc) do
+    min_line =
+      case left do
+        {_, meta, _} -> line(meta)
+        _ -> line(meta)
+      end
+
+    {[{{:root, context}, left} | acc], min_line}
+  end
+
+  defp unwrap_right({op, meta, [left, right]}, op, _meta, context, acc) do
+    left_context = left_op_context(context)
+    right_context = right_op_context(context)
+    unwrap_right(right, op, meta, right_context, [{{:left, left_context}, left} | acc])
+  end
+
+  defp unwrap_right(right, _op, meta, context, acc) do
+    acc = [{{:right, context}, right} | acc]
+    {Enum.reverse(acc), line(meta)}
+  end
+
+  defp operand_to_algebra_with_comments(operands, meta, min_line, max_line, context, state, fun) do
+    # If we are in a no_parens_one_arg expression, we actually cannot
+    # extract comments from the first operand, because it would rewrite:
+    #
+    #     @spec function(x) ::
+    #             # Comment
+    #             any
+    #           when x: any
+    #
+    # to:
+    #
+    #     @spec # Comment
+    #           function(x) ::
+    #             any
+    #           when x: any
+    #
+    # Instead we get:
+    #
+    #     @spec function(x) ::
+    #             any
+    #           # Comment
+    #           when x: any
+    #
+    # Which may look counter-intuitive but it actually makes sense,
+    # as the closest possible location for the comment is the when
+    # operator.
+    {operands, acc, state} =
+      if context == :no_parens_one_arg do
+        [operand | operands] = operands
+        {doc_triplet, state} = fun.(operand, :unused, state)
+        {operands, [doc_triplet], state}
+      else
+        {operands, [], state}
+      end
+
+    {docs, comments?, state} =
+      quoted_to_algebra_with_comments(operands, acc, min_line, max_line, state, fun)
+
+    if comments? or eol?(meta, state) do
+      {docs |> Enum.reduce(&line(&2, &1)) |> force_unfit(), state}
+    else
+      {docs |> Enum.reduce(&glue(&2, &1)), state}
+    end
+  end
+
+  ## Module attributes
+
+  # @Foo
+  # @Foo.Bar
+  defp module_attribute_to_algebra(_meta, {:__aliases__, _, [_, _ | _]} = quoted, _context, state) do
+    {doc, state} = quoted_to_algebra(quoted, :parens_arg, state)
+    {concat(concat("@(", doc), ")"), state}
+  end
+
+  # @foo bar
+  # @foo(bar)
+  defp module_attribute_to_algebra(meta, {name, call_meta, [_] = args} = expr, context, state)
+       when is_atom(name) and name not in [:__block__, :__aliases__] do
+    if Macro.classify_atom(name) == :identifier do
+      {{call_doc, state}, wrap_in_parens?} =
+        call_args_to_algebra(args, call_meta, context, :skip_unless_many_args, false, state)
+
+      doc =
+        "@#{name}"
+        |> string()
+        |> concat(call_doc)
+
+      doc = if wrap_in_parens?, do: wrap_in_parens(doc), else: doc
+      {doc, state}
+    else
+      unary_op_to_algebra(:@, meta, expr, context, state)
+    end
+  end
+
+  # @foo
+  # @(foo.bar())
+  defp module_attribute_to_algebra(meta, quoted, context, state) do
+    unary_op_to_algebra(:@, meta, quoted, context, state)
+  end
+
+  ## Capture operator
+
+  defp capture_to_algebra(integer, _context, state) when is_integer(integer) do
+    {"&" <> Integer.to_string(integer), state}
+  end
+
+  defp capture_to_algebra(arg, context, state) do
+    {doc, state} = capture_target_to_algebra(arg, context, state)
+
+    case format_to_string(doc) do
+      <<"&", _::binary>> -> {concat("& ", doc), state}
+      <<int, _::binary>> when int in ?0..?9 -> {concat("& ", doc), state}
+      _ -> {concat("&", doc), state}
+    end
+  end
+
+  defp capture_target_to_algebra(
+         {:/, _, [{{:., _, [target, fun]}, _, []}, {:__block__, _, [arity]}]},
+         _context,
+         state
+       )
+       when is_atom(fun) and is_integer(arity) do
+    {target_doc, state} = remote_target_to_algebra(target, state)
+    fun = Macro.inspect_atom(:remote_call, fun, escape: &escape_atom/2)
+    {target_doc |> nest(1) |> concat(string(".#{fun}/#{arity}")), state}
+  end
+
+  defp capture_target_to_algebra(
+         {:/, _, [{name, _, var_context}, {:__block__, _, [arity]}]},
+         _context,
+         state
+       )
+       when is_atom(name) and is_atom(var_context) and is_integer(arity) do
+    {string("#{name}/#{arity}"), state}
+  end
+
+  defp capture_target_to_algebra(arg, context, state) do
+    {doc, state} = quoted_to_algebra(arg, context, state)
+    {wrap_in_parens_if_operator(doc, arg), state}
+  end
+
+  ## Calls (local, remote and anonymous)
+
+  # expression.{arguments}
+  defp remote_to_algebra({{:., _, [target, :{}]}, meta, args}, _context, state) do
+    {target_doc, state} = remote_target_to_algebra(target, state)
+    {call_doc, state} = tuple_to_algebra(meta, args, :break, state)
+    {concat(concat(target_doc, "."), call_doc), state}
+  end
+
+  # expression.(arguments)
+  defp remote_to_algebra({{:., _, [target]}, meta, args}, context, state) do
+    {target_doc, state} = remote_target_to_algebra(target, state)
+
+    {{call_doc, state}, wrap_in_parens?} =
+      call_args_to_algebra(args, meta, context, :skip_if_do_end, true, state)
+
+    doc = concat(concat(target_doc, "."), call_doc)
+    doc = if wrap_in_parens?, do: wrap_in_parens(doc), else: doc
+    {doc, state}
+  end
+
+  # Mod.function()
+  # var.function
+  # expression.function(arguments)
+  defp remote_to_algebra({{:., _, [target, fun]}, meta, args}, context, state)
+       when is_atom(fun) do
+    {target_doc, state} = remote_target_to_algebra(target, state)
+
+    fun_doc =
+      Macro.inspect_atom(:remote_call, fun, escape: &escape_atom/2)
+      |> string()
+      |> color_doc(:call, state.inspect_opts)
+
+    remote_doc = target_doc |> concat(".") |> concat(fun_doc)
+
+    if args == [] and not remote_target_is_a_module?(target) and not meta?(meta, :closing) do
+      {remote_doc, state}
+    else
+      {{call_doc, state}, wrap_in_parens?} =
+        call_args_to_algebra(args, meta, context, :skip_if_do_end, true, state)
+
+      doc = concat(remote_doc, call_doc)
+      doc = if wrap_in_parens?, do: wrap_in_parens(doc), else: doc
+      {doc, state}
+    end
+  end
+
+  # call(call)(arguments)
+  defp remote_to_algebra({target, meta, args}, context, state) do
+    {target_doc, state} = quoted_to_algebra(target, :no_parens_arg, state)
+
+    {{call_doc, state}, wrap_in_parens?} =
+      call_args_to_algebra(args, meta, context, :required, true, state)
+
+    doc = concat(target_doc, call_doc)
+    doc = if wrap_in_parens?, do: wrap_in_parens(doc), else: doc
+    {doc, state}
+  end
+
+  defp remote_target_is_a_module?(target) do
+    case target do
+      {:__MODULE__, _, context} when is_atom(context) -> true
+      {:__block__, _, [atom]} when is_atom(atom) -> true
+      {:__aliases__, _, _} -> true
+      _ -> false
+    end
+  end
+
+  defp remote_target_to_algebra({:fn, _, [_ | _]} = quoted, state) do
+    # This change is not semantically required but for beautification.
+    {doc, state} = quoted_to_algebra(quoted, :no_parens_arg, state)
+    {wrap_in_parens(doc), state}
+  end
+
+  defp remote_target_to_algebra(quoted, state) do
+    quoted_to_algebra_with_parens_if_operator(quoted, :no_parens_arg, state)
+  end
+
+  # function(arguments)
+  defp local_to_algebra(fun, meta, args, context, state) when is_atom(fun) do
+    skip_parens =
+      cond do
+        meta?(meta, :closing) ->
+          :skip_if_only_do_end
+
+        local_without_parens?(fun, length(args), state.locals_without_parens) ->
+          :skip_unless_many_args
+
+        true ->
+          :skip_if_do_end
+      end
+
+    {{call_doc, state}, wrap_in_parens?} =
+      call_args_to_algebra(args, meta, context, skip_parens, true, state)
+
+    doc =
+      fun
+      |> Atom.to_string()
+      |> string()
+      |> color_doc(:call, state.inspect_opts)
+      |> concat(call_doc)
+
+    doc = if wrap_in_parens?, do: wrap_in_parens(doc), else: doc
+    {doc, state}
+  end
+
+  # parens may be one of:
+  #
+  #   * :skip_unless_many_args - skips parens unless we are the argument context
+  #   * :skip_if_only_do_end - skip parens if we are do-end and the only arg
+  #   * :skip_if_do_end - skip parens if we are do-end
+  #   * :required - never skip parens
+  #
+  defp call_args_to_algebra([], meta, _context, _parens, _list_to_keyword?, state) do
+    {args_doc, _join, state} =
+      args_to_algebra_with_comments([], meta, false, :none, :break, state, &{&1, &2})
+
+    {{surround("(", args_doc, ")"), state}, false}
+  end
+
+  defp call_args_to_algebra(args, meta, context, parens, list_to_keyword?, state) do
+    {rest, last} = split_last(args)
+
+    if blocks = do_end_blocks(meta, last, state) do
+      {call_doc, state} =
+        case rest do
+          [] when parens == :required ->
+            {"() do", state}
+
+          [] ->
+            {" do", state}
+
+          _ ->
+            no_parens? = parens not in [:required, :skip_if_only_do_end]
+            call_args_to_algebra_no_blocks(meta, rest, no_parens?, list_to_keyword?, " do", state)
+        end
+
+      {blocks_doc, state} = do_end_blocks_to_algebra(blocks, state)
+      call_doc = call_doc |> concat(blocks_doc) |> line("end") |> force_unfit()
+      {{call_doc, state}, context in [:no_parens_arg, :no_parens_one_arg]}
+    else
+      no_parens? =
+        parens == :skip_unless_many_args and
+          context in [:block, :operand, :no_parens_one_arg, :parens_one_arg]
+
+      res =
+        call_args_to_algebra_no_blocks(meta, args, no_parens?, list_to_keyword?, @empty, state)
+
+      {res, false}
+    end
+  end
+
+  defp call_args_to_algebra_no_blocks(meta, args, skip_parens?, list_to_keyword?, extra, state) do
+    {left, right} = split_last(args)
+    {keyword?, right} = last_arg_to_keyword(right, list_to_keyword?, skip_parens?, state.comments)
+
+    context =
+      if left == [] and not keyword? do
+        if skip_parens?, do: :no_parens_one_arg, else: :parens_one_arg
+      else
+        if skip_parens?, do: :no_parens_arg, else: :parens_arg
+      end
+
+    args = if keyword?, do: left ++ right, else: left ++ [right]
+    many_eol? = match?([_, _ | _], args) and eol?(meta, state)
+    no_generators? = no_generators?(args)
+    to_algebra_fun = &quoted_to_algebra(&1, context, &2)
+
+    {args_doc, next_break_fits?, state} =
+      if left != [] and keyword? and no_generators? do
+        join = if force_args?(left) or many_eol?, do: :line, else: :break
+
+        {left_doc, _join, state} =
+          args_to_algebra_with_comments(
+            left,
+            Keyword.delete(meta, :closing),
+            skip_parens?,
+            :force_comma,
+            join,
+            state,
+            to_algebra_fun
+          )
+
+        join = if force_args?(right) or force_args?(args) or many_eol?, do: :line, else: :break
+
+        {right_doc, _join, state} =
+          args_to_algebra_with_comments(right, meta, false, :none, join, state, to_algebra_fun)
+
+        right_doc = apply(Inspect.Algebra, join, []) |> concat(right_doc)
+
+        args_doc =
+          if skip_parens? do
+            left_doc
+            |> concat(group(right_doc, :optimistic))
+            |> nest(:cursor, :break)
+          else
+            right_doc =
+              right_doc
+              |> nest(2, :break)
+              |> concat(break(""))
+              |> concat(")")
+              |> group(:optimistic)
+
+            concat(nest(left_doc, 2, :break), right_doc)
+          end
+
+        {args_doc, true, state}
+      else
+        join = if force_args?(args) or many_eol?, do: :line, else: :break
+        next_break_fits? = join == :break and next_break_fits?(right, state)
+        last_arg_mode = if next_break_fits?, do: :next_break_fits, else: :none
+
+        {args_doc, _join, state} =
+          args_to_algebra_with_comments(
+            args,
+            meta,
+            skip_parens?,
+            last_arg_mode,
+            join,
+            state,
+            to_algebra_fun
+          )
+
+        # If we have a single argument, then we won't have an option to break
+        # before the "extra" part, so we ungroup it and build it later.
+        args_doc = ungroup_if_group(args_doc)
+
+        args_doc =
+          if skip_parens? do
+            nest(args_doc, :cursor, :break)
+          else
+            nest(args_doc, 2, :break) |> concat(break("")) |> concat(")")
+          end
+
+        {args_doc, next_break_fits?, state}
+      end
+
+    doc =
+      cond do
+        left != [] and keyword? and skip_parens? and no_generators? ->
+          " "
+          |> concat(args_doc)
+          |> nest(2)
+          |> concat(extra)
+
+        skip_parens? ->
+          " "
+          |> concat(args_doc)
+          |> concat(extra)
+
+        true ->
+          "("
+          |> concat(break(""))
+          |> nest(2, :break)
+          |> concat(args_doc)
+          |> concat(extra)
+      end
+
+    if next_break_fits? do
+      {group(doc, :pessimistic), state}
+    else
+      {group(doc), state}
+    end
+  end
+
+  defp no_generators?(args) do
+    not Enum.any?(args, &match?({:<-, _, [_, _]}, &1))
+  end
+
+  defp do_end_blocks(meta, [{{:__block__, _, [:do]}, _} | rest] = blocks, state) do
+    if meta?(meta, :do) or can_force_do_end_blocks?(rest, state) do
+      blocks
+      |> Enum.map(fn {{:__block__, meta, [key]}, value} -> {key, line(meta), value} end)
+      |> do_end_blocks_with_range(end_line(meta))
+    end
+  end
+
+  defp do_end_blocks(_, _, _), do: nil
+
+  defp can_force_do_end_blocks?(rest, state) do
+    state.force_do_end_blocks and
+      Enum.all?(rest, fn {{:__block__, _, [key]}, _} -> key in @do_end_keywords end)
+  end
+
+  defp do_end_blocks_with_range([{key1, line1, value1}, {_, line2, _} = h | t], end_line) do
+    [{key1, line1, line2, value1} | do_end_blocks_with_range([h | t], end_line)]
+  end
+
+  defp do_end_blocks_with_range([{key, line, value}], end_line) do
+    [{key, line, end_line, value}]
+  end
+
+  defp do_end_blocks_to_algebra([{:do, line, end_line, value} | blocks], state) do
+    {acc, state} = do_end_block_to_algebra(@empty, line, end_line, value, state)
+
+    Enum.reduce(blocks, {acc, state}, fn {key, line, end_line, value}, {acc, state} ->
+      {doc, state} = do_end_block_to_algebra(Atom.to_string(key), line, end_line, value, state)
+      {line(acc, doc), state}
+    end)
+  end
+
+  defp do_end_block_to_algebra(key_doc, line, end_line, value, state) do
+    case clauses_to_algebra(value, line, end_line, state) do
+      {@empty, state} -> {key_doc, state}
+      {value_doc, state} -> {key_doc |> line(value_doc) |> nest(2), state}
+    end
+  end
+
+  ## Interpolation
+
+  defp list_interpolated?(entries) do
+    Enum.all?(entries, fn
+      {{:., _, [Kernel, :to_string]}, _, [_]} -> true
+      entry when is_binary(entry) -> true
+      _ -> false
+    end)
+  end
+
+  defp interpolated?(entries) do
+    Enum.all?(entries, fn
+      {:"::", _, [{{:., _, [Kernel, :to_string]}, _, [_]}, {:binary, _, _}]} -> true
+      entry when is_binary(entry) -> true
+      _ -> false
+    end)
+  end
+
+  defp prepend_heredoc_line([entry | entries]) when is_binary(entry) do
+    ["\n" <> entry | entries]
+  end
+
+  defp prepend_heredoc_line(entries) do
+    ["\n" | entries]
+  end
+
+  defp list_interpolation_to_algebra([entry | entries], escape, state, acc, last)
+       when is_binary(entry) do
+    acc = concat(acc, escape_string(entry, escape))
+    list_interpolation_to_algebra(entries, escape, state, acc, last)
+  end
+
+  defp list_interpolation_to_algebra([entry | entries], escape, state, acc, last) do
+    {{:., _, [Kernel, :to_string]}, _meta, [quoted]} = entry
+    {doc, state} = interpolation_to_algebra(quoted, state)
+    list_interpolation_to_algebra(entries, escape, state, concat(acc, doc), last)
+  end
+
+  defp list_interpolation_to_algebra([], _escape, state, acc, last) do
+    {concat(acc, last), state}
+  end
+
+  defp interpolation_to_algebra([entry | entries], escape, state, acc, last)
+       when is_binary(entry) do
+    acc = concat(acc, escape_string(entry, escape))
+    interpolation_to_algebra(entries, escape, state, acc, last)
+  end
+
+  defp interpolation_to_algebra([entry | entries], escape, state, acc, last) do
+    {:"::", _, [{{:., _, [Kernel, :to_string]}, _meta, [quoted]}, {:binary, _, _}]} = entry
+    {doc, state} = interpolation_to_algebra(quoted, state)
+    interpolation_to_algebra(entries, escape, state, concat(acc, doc), last)
+  end
+
+  defp interpolation_to_algebra([], _escape, state, acc, last) do
+    {concat(acc, last), state}
+  end
+
+  defp interpolation_to_algebra(quoted, %{skip_eol: skip_eol} = state) do
+    {doc, state} = block_to_algebra(quoted, @max_line, @min_line, %{state | skip_eol: true})
+    {no_limit(surround("\#{", doc, "}")), %{state | skip_eol: skip_eol}}
+  end
+
+  ## Sigils
+
+  defp maybe_sigil_to_algebra(fun, meta, args, state) do
+    with <<"sigil_", name::binary>> <- Atom.to_string(fun),
+         [{:<<>>, _, entries}, modifiers] when is_list(modifiers) <- args,
+         opening_delimiter when not is_nil(opening_delimiter) <- meta[:delimiter] do
+      doc = <<?~, name::binary, opening_delimiter::binary>>
+
+      entries =
+        case Map.fetch(state.sigils, String.to_charlist(name)) do
+          {:ok, callback} ->
+            metadata = [
+              file: state.file,
+              line: meta[:line],
+              sigil: String.to_atom(name),
+              modifiers: modifiers,
+              opening_delimiter: opening_delimiter
+            ]
+
+            case callback.(hd(entries), metadata) do
+              iodata when is_binary(iodata) or is_list(iodata) ->
+                [IO.iodata_to_binary(iodata)]
+
+              other ->
+                raise ArgumentError,
+                      "expected sigil callback to return iodata, got: #{inspect(other)}"
+            end
+
+          :error ->
+            entries
+        end
+
+      if opening_delimiter in [@double_heredoc, @single_heredoc] do
+        closing_delimiter = concat(opening_delimiter, List.to_string(modifiers))
+
+        {doc, state} =
+          entries
+          |> prepend_heredoc_line()
+          |> interpolation_to_algebra(opening_delimiter, state, doc, closing_delimiter)
+
+        {force_unfit(doc), state}
+      else
+        escape = closing_sigil_delimiter(opening_delimiter)
+        closing_delimiter = concat(escape, List.to_string(modifiers))
+        interpolation_to_algebra(entries, escape, state, doc, closing_delimiter)
+      end
+    else
+      _ ->
+        :error
+    end
+  end
+
+  defp closing_sigil_delimiter("("), do: ")"
+  defp closing_sigil_delimiter("["), do: "]"
+  defp closing_sigil_delimiter("{"), do: "}"
+  defp closing_sigil_delimiter("<"), do: ">"
+  defp closing_sigil_delimiter(other) when other in ["\"", "'", "|", "/"], do: other
+
+  ## Bitstrings
+
+  defp bitstring_to_algebra(meta, args, state) do
+    last = length(args) - 1
+    join = if eol?(meta, state), do: :line, else: :flex_break
+    to_algebra_fun = &bitstring_segment_to_algebra(&1, &2, last)
+
+    {args_doc, join, state} =
+      args
+      |> Enum.with_index()
+      |> args_to_algebra_with_comments(meta, false, :none, join, state, to_algebra_fun)
+
+    if join == :flex_break do
+      {"<<" |> concat(args_doc) |> nest(2) |> concat(">>") |> group(), state}
+    else
+      {surround("<<", args_doc, ">>"), state}
+    end
+  end
+
+  defp bitstring_segment_to_algebra({{:<-, meta, [left, right]}, i}, state, last) do
+    left = {{:special, :bitstring_segment}, meta, [left, last]}
+    {doc, state} = quoted_to_algebra({:<-, meta, [left, right]}, :parens_arg, state)
+    {bitstring_wrap_parens(doc, i, last), state}
+  end
+
+  defp bitstring_segment_to_algebra({{:"::", _, [segment, spec]}, i}, state, last) do
+    {doc, state} = quoted_to_algebra(segment, :parens_arg, state)
+
+    {spec, state} =
+      bitstring_spec_to_algebra(spec, state, state.migrate_bitstring_modifiers, :"::")
+
+    spec = wrap_in_parens_if_inspected_atom(spec)
+    spec = if i == last, do: bitstring_wrap_parens(spec, i, last), else: spec
+
+    doc =
+      doc
+      |> bitstring_wrap_parens(i, -1)
+      |> concat("::")
+      |> concat(spec)
+
+    {doc, state}
+  end
+
+  defp bitstring_segment_to_algebra({segment, i}, state, last) do
+    {doc, state} = quoted_to_algebra(segment, :parens_arg, state)
+    {bitstring_wrap_parens(doc, i, last), state}
+  end
+
+  defp bitstring_spec_to_algebra({op, _, [left, right]}, state, normalize_modifiers, paren_op)
+       when op in [:-, :*] do
+    normalize_modifiers = normalize_modifiers && op != :*
+    {left, state} = bitstring_spec_to_algebra(left, state, normalize_modifiers, op)
+    {right, state} = bitstring_spec_element_to_algebra(right, state, normalize_modifiers)
+    doc = concat(concat(left, Atom.to_string(op)), right)
+    doc = if paren_op == :*, do: wrap_in_parens(doc), else: doc
+    {doc, state}
+  end
+
+  defp bitstring_spec_to_algebra(spec, state, normalize_modifiers, _paren_op) do
+    bitstring_spec_element_to_algebra(spec, state, normalize_modifiers)
+  end
+
+  defp bitstring_spec_element_to_algebra(
+         {atom, meta, empty_args},
+         state,
+         _normalize_modifiers = true
+       )
+       when is_atom(atom) and empty_args in [nil, []] do
+    empty_args = bitstring_spec_normalize_empty_args(atom)
+    quoted_to_algebra_with_parens_if_operator({atom, meta, empty_args}, :parens_arg, state)
+  end
+
+  defp bitstring_spec_element_to_algebra(spec_element, state, _normalize_modifiers) do
+    quoted_to_algebra_with_parens_if_operator(spec_element, :parens_arg, state)
+  end
+
+  defp bitstring_spec_normalize_empty_args(:_), do: nil
+
+  defp bitstring_spec_normalize_empty_args(atom) do
+    case :elixir_bitstring.validate_spec(atom, nil) do
+      :none -> []
+      _ -> nil
+    end
+  end
+
+  defp bitstring_wrap_parens(doc, i, last) when i == 0 or i == last do
+    string = format_to_string(doc)
+
+    if (i == 0 and String.starts_with?(string, ["~", "<<"])) or
+         (i == last and String.ends_with?(string, [">>"])) do
+      wrap_in_parens(doc)
+    else
+      doc
+    end
+  end
+
+  defp bitstring_wrap_parens(doc, _, _), do: doc
+
+  ## Literals
+
+  defp list_to_algebra(meta, args, state) do
+    join = if eol?(meta, state), do: :line, else: :break
+    fun = &quoted_to_algebra(&1, :parens_arg, &2)
+
+    {args_doc, _join, state} =
+      args_to_algebra_with_comments(args, meta, false, :none, join, state, fun)
+
+    left_bracket = color_doc("[", :list, state.inspect_opts)
+    right_bracket = color_doc("]", :list, state.inspect_opts)
+
+    {surround(left_bracket, args_doc, right_bracket), state}
+  end
+
+  defp map_to_algebra(meta, name_doc, [{:|, _, [left, right]}], state) do
+    join = if eol?(meta, state), do: :line, else: :break
+    fun = &quoted_to_algebra(&1, :parens_arg, &2)
+    {left_doc, state} = fun.(left, state)
+
+    {right_doc, _join, state} =
+      args_to_algebra_with_comments(right, meta, false, :none, join, state, fun)
+
+    args_doc =
+      left_doc
+      |> wrap_in_parens_if_binary_operator(left)
+      |> glue(concat("| ", nest(right_doc, 2)))
+
+    do_map_to_algebra(name_doc, args_doc, state)
+  end
+
+  defp map_to_algebra(meta, name_doc, args, state) do
+    join = if eol?(meta, state), do: :line, else: :break
+    fun = &quoted_to_algebra(&1, :parens_arg, &2)
+
+    {args_doc, _join, state} =
+      args_to_algebra_with_comments(args, meta, false, :none, join, state, fun)
+
+    do_map_to_algebra(name_doc, args_doc, state)
+  end
+
+  defp do_map_to_algebra(name_doc, args_doc, state) do
+    name_doc = "%" |> concat(name_doc) |> concat("{") |> color_doc(:map, state.inspect_opts)
+    {surround(name_doc, args_doc, color_doc("}", :map, state.inspect_opts)), state}
+  end
+
+  defp tuple_to_algebra(meta, args, join, state) do
+    join = if eol?(meta, state), do: :line, else: join
+    fun = &quoted_to_algebra(&1, :parens_arg, &2)
+
+    {args_doc, join, state} =
+      args_to_algebra_with_comments(args, meta, false, :none, join, state, fun)
+
+    left_bracket = color_doc("{", :tuple, state.inspect_opts)
+    right_bracket = color_doc("}", :tuple, state.inspect_opts)
+
+    if join == :flex_break do
+      {left_bracket |> concat(args_doc) |> nest(1) |> concat(right_bracket) |> group(), state}
+    else
+      {surround(left_bracket, args_doc, right_bracket), state}
+    end
+  end
+
+  defp atom_to_algebra(atom, _, inspect_opts) when atom in [true, false] do
+    Atom.to_string(atom) |> color_doc(:boolean, inspect_opts)
+  end
+
+  defp atom_to_algebra(nil, _, inspect_opts) do
+    Atom.to_string(nil) |> color_doc(nil, inspect_opts)
+  end
+
+  defp atom_to_algebra(:\\, meta, inspect_opts) do
+    # Since we parse strings without unescaping, the atoms
+    # :\\ and :"\\" have the same representation, so we need
+    # to check the delimiter and handle them accordingly.
+    string =
+      case Keyword.get(meta, :delimiter) do
+        "\"" -> ":\"\\\\\""
+        _ -> ":\\\\"
+      end
+
+    string(string) |> color_doc(:atom, inspect_opts)
+  end
+
+  defp atom_to_algebra(atom, _, inspect_opts) do
+    string = Atom.to_string(atom)
+
+    iodata =
+      if Macro.classify_atom(atom) in [:unquoted, :identifier] do
+        [?:, string]
+      else
+        [?:, ?", String.replace(string, "\"", "\\\""), ?"]
+      end
+
+    iodata |> IO.iodata_to_binary() |> string() |> color_doc(:atom, inspect_opts)
+  end
+
+  defp integer_to_algebra(text, inspect_otps) do
+    case text do
+      <<?0, ?x, rest::binary>> ->
+        "0x" <> String.upcase(rest)
+
+      <<?0, base, _::binary>> = digits when base in [?b, ?o] ->
+        digits
+
+      <<??, _::binary>> = char ->
+        char
+
+      decimal ->
+        insert_underscores(decimal)
+    end
+    |> color_doc(:number, inspect_otps)
+  end
+
+  defp float_to_algebra(text, inspect_otps) do
+    [int_part, decimal_part] = :binary.split(text, ".")
+    decimal_part = String.downcase(decimal_part)
+
+    string = insert_underscores(int_part) <> "." <> decimal_part
+    color_doc(string, :number, inspect_otps)
+  end
+
+  defp insert_underscores("-" <> digits) do
+    "-" <> insert_underscores(digits)
+  end
+
+  defp insert_underscores(digits) do
+    byte_size = byte_size(digits)
+
+    cond do
+      digits =~ "_" ->
+        digits
+
+      byte_size >= 6 ->
+        offset = rem(byte_size, 3)
+        {prefix, rest} = String.split_at(digits, offset)
+        do_insert_underscores(prefix, rest)
+
+      true ->
+        digits
+    end
+  end
+
+  defp do_insert_underscores(acc, ""), do: acc
+
+  defp do_insert_underscores("", <<next::binary-3, rest::binary>>),
+    do: do_insert_underscores(next, rest)
+
+  defp do_insert_underscores(acc, <<next::binary-3, rest::binary>>),
+    do: do_insert_underscores(<<acc::binary, "_", next::binary>>, rest)
+
+  defp escape_heredoc(string, escape) do
+    string = String.replace(string, escape, "\\" <> escape)
+    heredoc_to_algebra(["" | String.split(string, "\n")])
+  end
+
+  defp escape_string(string, <<_, _, _>> = escape) do
+    string = String.replace(string, escape, "\\" <> escape)
+    heredoc_to_algebra(String.split(string, "\n"))
+  end
+
+  defp escape_string(string, escape) when is_binary(escape) do
+    string
+    |> String.replace(escape, "\\" <> escape)
+    |> String.split("\n")
+    |> Enum.reverse()
+    |> Enum.map(&string/1)
+    |> Enum.reduce(&concat(&1, concat(nest(line(), :reset), &2)))
+  end
+
+  defp heredoc_to_algebra([string]) do
+    string(string)
+  end
+
+  defp heredoc_to_algebra(["" | rest]) do
+    rest
+    |> heredoc_line()
+    |> concat(heredoc_to_algebra(rest))
+  end
+
+  defp heredoc_to_algebra([string | rest]) do
+    string
+    |> string()
+    |> concat(heredoc_line(rest))
+    |> concat(heredoc_to_algebra(rest))
+  end
+
+  defp heredoc_line(["", _ | _]), do: nest(line(), :reset)
+  defp heredoc_line(["\r", _ | _]), do: nest(line(), :reset)
+  defp heredoc_line(_), do: line()
+
+  defp args_to_algebra_with_comments(args, meta, skip_parens?, last_arg_mode, join, state, fun) do
+    min_line = line(meta)
+    max_line = closing_line(meta)
+
+    arg_to_algebra = fn arg, args, state ->
+      {doc, state} = fun.(arg, state)
+
+      doc =
+        case args do
+          [_ | _] ->
+            concat_to_last_group(doc, ",")
+
+          [] when last_arg_mode == :force_comma ->
+            concat_to_last_group(doc, ",")
+
+          [] when last_arg_mode == :next_break_fits ->
+            doc |> ungroup_if_group() |> group(:optimistic)
+
+          [] when last_arg_mode == :none ->
+            doc
+        end
+
+      {{doc, @empty, 1}, state}
+    end
+
+    # If skipping parens, we cannot extract the comments of the first
+    # argument as there is no place to move them to, so we handle it now.
+    {args, acc, state} =
+      case args do
+        [head | tail] when skip_parens? ->
+          {doc_triplet, state} = arg_to_algebra.(head, tail, state)
+          {tail, [doc_triplet], state}
+
+        _ ->
+          {args, [], state}
+      end
+
+    {args_docs, comments?, state} =
+      quoted_to_algebra_with_comments(args, acc, min_line, max_line, state, arg_to_algebra)
+
+    cond do
+      args_docs == [] ->
+        {@empty, :empty, state}
+
+      join == :line or comments? ->
+        {args_docs |> Enum.reduce(&line(&2, &1)) |> force_unfit(), :line, state}
+
+      join == :break ->
+        {args_docs |> Enum.reduce(&glue(&2, &1)), :break, state}
+
+      join == :flex_break ->
+        {args_docs |> Enum.reduce(&flex_glue(&2, &1)), :flex_break, state}
+    end
+  end
+
+  ## Anonymous functions
+
+  # fn -> block end
+  defp anon_fun_to_algebra(
+         [{:->, meta, [[], body]}] = clauses,
+         _min_line,
+         max_line,
+         state,
+         _multi_clauses_style
+       ) do
+    min_line = line(meta)
+    {body_doc, state} = block_to_algebra(body, min_line, max_line, state)
+    break_or_line = clause_break_or_line(clauses, state)
+
+    doc =
+      "fn ->"
+      |> concat(break_or_line)
+      |> concat(body_doc)
+      |> nest(2)
+      |> concat(break_or_line)
+      |> concat("end")
+      |> maybe_force_clauses(clauses, state)
+      |> group()
+
+    {doc, state}
+  end
+
+  # fn x -> y end
+  # fn x ->
+  #   y
+  # end
+  defp anon_fun_to_algebra(
+         [{:->, meta, [args, body]}] = clauses,
+         _min_line,
+         max_line,
+         state,
+         false = _multi_clauses_style
+       ) do
+    min_line = line(meta)
+    {args_doc, state} = clause_args_to_algebra(args, min_line, state)
+    {body_doc, state} = block_to_algebra(body, min_line, max_line, state)
+
+    head =
+      args_doc
+      |> ungroup_if_group()
+      |> concat(" ->")
+      |> nest(:cursor)
+      |> group()
+
+    break_or_line = clause_break_or_line(clauses, state)
+
+    doc =
+      "fn "
+      |> concat(head)
+      |> concat(break_or_line)
+      |> concat(body_doc)
+      |> nest(2)
+      |> concat(break_or_line)
+      |> concat("end")
+      |> maybe_force_clauses(clauses, state)
+      |> group()
+
+    {doc, state}
+  end
+
+  # fn
+  #   args1 ->
+  #     block1
+  #   args2 ->
+  #     block2
+  # end
+  defp anon_fun_to_algebra(clauses, min_line, max_line, state, _multi_clauses_style) do
+    {clauses_doc, state} = clauses_to_algebra(clauses, min_line, max_line, state)
+    {"fn" |> line(clauses_doc) |> nest(2) |> line("end") |> force_unfit(), state}
+  end
+
+  ## Type functions
+
+  # (-> block)
+  defp paren_fun_to_algebra([{:->, meta, [[], body]}] = clauses, _min_line, max_line, state) do
+    min_line = line(meta)
+    {body_doc, state} = block_to_algebra(body, min_line, max_line, state)
+
+    doc =
+      "(-> "
+      |> concat(nest(body_doc, :cursor))
+      |> concat(")")
+      |> maybe_force_clauses(clauses, state)
+      |> group()
+
+    {doc, state}
+  end
+
+  # (x -> y)
+  # (x ->
+  #    y)
+  defp paren_fun_to_algebra([{:->, meta, [args, body]}] = clauses, _min_line, max_line, state) do
+    min_line = line(meta)
+    {args_doc, state} = clause_args_to_algebra(args, min_line, state)
+    {body_doc, state} = block_to_algebra(body, min_line, max_line, state)
+    break_or_line = clause_break_or_line(clauses, state)
+
+    doc =
+      args_doc
+      |> ungroup_if_group()
+      |> concat(" ->")
+      |> group()
+      |> concat(break_or_line |> concat(body_doc) |> nest(2))
+      |> wrap_in_parens()
+      |> maybe_force_clauses(clauses, state)
+      |> group()
+
+    {doc, state}
+  end
+
+  # (
+  #   args1 ->
+  #     block1
+  #   args2 ->
+  #     block2
+  # )
+  defp paren_fun_to_algebra(clauses, min_line, max_line, state) do
+    {clauses_doc, state} = clauses_to_algebra(clauses, min_line, max_line, state)
+    {"(" |> line(clauses_doc) |> nest(2) |> line(")") |> force_unfit(), state}
+  end
+
+  ## Clauses
+
+  defp multi_line_clauses?(clauses, state) do
+    Enum.any?(clauses, fn {:->, meta, [_, block]} ->
+      eol?(meta, state) or multi_line_block?(block)
+    end)
+  end
+
+  defp multi_line_block?({:__block__, _, [_, _ | _]}), do: true
+  defp multi_line_block?(_), do: false
+
+  defp clause_break_or_line(clauses, state) do
+    if multi_line_clauses?(clauses, state), do: line(), else: break()
+  end
+
+  defp maybe_force_clauses(doc, clauses, state) do
+    if multi_line_clauses?(clauses, state), do: force_unfit(doc), else: doc
+  end
+
+  defp clauses_to_algebra([{:->, _, _} | _] = clauses, min_line, max_line, state) do
+    [clause | clauses] = add_max_line_to_last_clause(clauses, max_line)
+    {clause_doc, state} = clause_to_algebra(clause, min_line, state)
+
+    {clauses_doc, state} =
+      Enum.reduce(clauses, {clause_doc, state}, fn clause, {doc_acc, state_acc} ->
+        {clause_doc, state_acc} = clause_to_algebra(clause, min_line, state_acc)
+
+        doc_acc =
+          doc_acc
+          |> concat(maybe_empty_line())
+          |> line(clause_doc)
+
+        {doc_acc, state_acc}
+      end)
+
+    {clauses_doc |> maybe_force_clauses([clause | clauses], state) |> group(), state}
+  end
+
+  defp clauses_to_algebra(other, min_line, max_line, state) do
+    case block_to_algebra(other, min_line, max_line, state) do
+      {@empty, state} -> {@empty, state}
+      {doc, state} -> {group(doc), state}
+    end
+  end
+
+  defp clause_to_algebra({:->, meta, [[], body]}, _min_line, state) do
+    {body_doc, state} = block_to_algebra(body, line(meta), closing_line(meta), state)
+    {"() ->" |> glue(body_doc) |> nest(2), state}
+  end
+
+  defp clause_to_algebra({:->, meta, [args, body]}, min_line, state) do
+    %{operand_nesting: nesting} = state
+
+    state = %{state | operand_nesting: nesting + 2}
+    {args_doc, state} = clause_args_to_algebra(args, min_line, state)
+
+    state = %{state | operand_nesting: nesting}
+    {body_doc, state} = block_to_algebra(body, min_line, closing_line(meta), state)
+
+    doc =
+      args_doc
+      |> ungroup_if_group()
+      |> concat(" ->")
+      |> group()
+      |> concat(break() |> concat(body_doc) |> nest(2))
+
+    {doc, state}
+  end
+
+  defp add_max_line_to_last_clause([{op, meta, args}], max_line) do
+    [{op, [closing: [line: max_line]] ++ meta, args}]
+  end
+
+  defp add_max_line_to_last_clause([clause | clauses], max_line) do
+    [clause | add_max_line_to_last_clause(clauses, max_line)]
+  end
+
+  defp clause_args_to_algebra(args, min_line, state) do
+    arg_to_algebra = fn arg, _args, state ->
+      {doc, state} = clause_args_to_algebra(arg, state)
+      {{doc, @empty, 1}, state}
+    end
+
+    {args_docs, comments?, state} =
+      quoted_to_algebra_with_comments([args], [], min_line, @min_line, state, arg_to_algebra)
+
+    if comments? do
+      {Enum.reduce(args_docs, &line(&2, &1)), state}
+    else
+      {Enum.reduce(args_docs, &glue(&2, &1)), state}
+    end
+  end
+
+  # fn a, b, c when d -> e end
+  defp clause_args_to_algebra([{:when, meta, args}], state) do
+    {args, right} = split_last(args)
+
+    # If there are any keywords, wrap them in lists
+    args =
+      Enum.map(args, fn
+        [_ | _] = keyword -> {:__block__, [], [keyword]}
+        other -> other
+      end)
+
+    left = {{:special, :clause_args}, meta, [args]}
+    binary_op_to_algebra(:when, "when", meta, left, right, :no_parens_arg, state)
+  end
+
+  # fn () -> e end
+  defp clause_args_to_algebra([], state) do
+    {"()", state}
+  end
+
+  # fn a, b, c -> e end
+  defp clause_args_to_algebra(args, state) do
+    many_args_to_algebra(args, state, &quoted_to_algebra(&1, :no_parens_arg, &2))
+  end
+
+  ## Quoted helpers for comments
+
+  defp quoted_to_algebra_with_comments(args, acc, min_line, max_line, state, fun) do
+    {pre_comments, state} =
+      get_and_update_in(state.comments, fn comments ->
+        Enum.split_while(comments, fn %{line: line} -> line <= min_line end)
+      end)
+
+    {reverse_docs, comments?, state} =
+      if state.comments == [] do
+        each_quoted_to_algebra_without_comments(args, acc, state, fun)
+      else
+        each_quoted_to_algebra_with_comments(args, acc, max_line, state, false, fun)
+      end
+
+    docs = merge_algebra_with_comments(Enum.reverse(reverse_docs), @empty)
+    {docs, comments?, update_in(state.comments, &(pre_comments ++ &1))}
+  end
+
+  defp each_quoted_to_algebra_without_comments([], acc, state, _fun) do
+    {acc, false, state}
+  end
+
+  defp each_quoted_to_algebra_without_comments([arg | args], acc, state, fun) do
+    {doc_triplet, state} = fun.(arg, args, state)
+    acc = [doc_triplet | acc]
+    each_quoted_to_algebra_without_comments(args, acc, state, fun)
+  end
+
+  defp each_quoted_to_algebra_with_comments([], acc, max_line, state, comments?, _fun) do
+    {acc, comments, comments?} = extract_comments_before(max_line, acc, state.comments, comments?)
+    {acc, comments?, %{state | comments: comments}}
+  end
+
+  defp each_quoted_to_algebra_with_comments([arg | args], acc, max_line, state, comments?, fun) do
+    case traverse_line(arg, {@max_line, @min_line}) do
+      {@max_line, @min_line} ->
+        {doc_triplet, state} = fun.(arg, args, state)
+        acc = [doc_triplet | acc]
+        each_quoted_to_algebra_with_comments(args, acc, max_line, state, comments?, fun)
+
+      {doc_start, doc_end} ->
+        {acc, comments, comments?} =
+          extract_comments_before(doc_start, acc, state.comments, comments?)
+
+        {doc_triplet, state} = fun.(arg, args, %{state | comments: comments})
+
+        {acc, comments, comments?} =
+          extract_comments_trailing(doc_start, doc_end, acc, state.comments, comments?)
+
+        acc = [adjust_trailing_newlines(doc_triplet, doc_end, comments) | acc]
+        state = %{state | comments: comments}
+        each_quoted_to_algebra_with_comments(args, acc, max_line, state, comments?, fun)
+    end
+  end
+
+  defp extract_comments_before(max, acc, [%{line: line} = comment | rest], _) when line < max do
+    %{previous_eol_count: previous, next_eol_count: next, text: doc} = comment
+    acc = [{doc, @empty, next} | add_previous_to_acc(acc, previous)]
+    extract_comments_before(max, acc, rest, true)
+  end
+
+  defp extract_comments_before(_max, acc, rest, comments?) do
+    {acc, rest, comments?}
+  end
+
+  defp add_previous_to_acc([{doc, next_line, newlines} | acc], previous) when newlines < previous,
+    do: [{doc, next_line, previous} | acc]
+
+  defp add_previous_to_acc(acc, _previous),
+    do: acc
+
+  defp extract_comments_trailing(min, max, acc, [%{line: line, text: doc_comment} | rest], _)
+       when line >= min and line <= max do
+    acc = [{doc_comment, @empty, 1} | acc]
+    extract_comments_trailing(min, max, acc, rest, true)
+  end
+
+  defp extract_comments_trailing(_min, _max, acc, rest, comments?) do
+    {acc, rest, comments?}
+  end
+
+  # If the document is immediately followed by comment which is followed by newlines,
+  # its newlines wouldn't have considered the comment, so we need to adjust it.
+  defp adjust_trailing_newlines({doc, next_line, newlines}, doc_end, [%{line: line} | _])
+       when newlines > 1 and line == doc_end + 1 do
+    {doc, next_line, 1}
+  end
+
+  defp adjust_trailing_newlines(doc_triplet, _, _), do: doc_triplet
+
+  defp traverse_line({expr, meta, args}, {min, max}) do
+    # This is a hot path, so use :lists.keyfind/3 instead Keyword.fetch!/2
+    acc =
+      case :lists.keyfind(:line, 1, meta) do
+        {:line, line} -> {min(line, min), max(line, max)}
+        false -> {min, max}
+      end
+
+    traverse_line(args, traverse_line(expr, acc))
+  end
+
+  defp traverse_line({left, right}, acc) do
+    traverse_line(right, traverse_line(left, acc))
+  end
+
+  defp traverse_line(args, acc) when is_list(args) do
+    Enum.reduce(args, acc, &traverse_line/2)
+  end
+
+  defp traverse_line(_, acc) do
+    acc
+  end
+
+  # Below are the rules for line rendering in the formatter:
+  #
+  #   1. respect the user's choice
+  #   2. and add empty lines around expressions that take multiple lines
+  #      (except for module attributes)
+  #   3. empty lines are collapsed as to not exceed more than one
+  #
+  defp merge_algebra_with_comments([{doc, next_line, newlines} | docs], left) do
+    right = if newlines >= @newlines, do: line(), else: next_line
+
+    doc =
+      if left != @empty do
+        concat(left, doc)
+      else
+        doc
+      end
+
+    doc =
+      if docs != [] and right != @empty do
+        concat(doc, concat(collapse_lines(2), right))
+      else
+        doc
+      end
+
+    [group(doc) | merge_algebra_with_comments(docs, right)]
+  end
+
+  defp merge_algebra_with_comments([], _) do
+    []
+  end
+
+  ## Quoted helpers
+
+  defp left_op_context(context), do: force_many_args_or_operand(context, :parens_arg)
+  defp right_op_context(context), do: force_many_args_or_operand(context, :operand)
+
+  defp force_many_args_or_operand(:no_parens_one_arg, _choice), do: :no_parens_arg
+  defp force_many_args_or_operand(:parens_one_arg, _choice), do: :parens_arg
+  defp force_many_args_or_operand(:no_parens_arg, _choice), do: :no_parens_arg
+  defp force_many_args_or_operand(:parens_arg, _choice), do: :parens_arg
+  defp force_many_args_or_operand(:operand, choice), do: choice
+  defp force_many_args_or_operand(:block, choice), do: choice
+
+  defp quoted_to_algebra_with_parens_if_operator(ast, context, state) do
+    {doc, state} = quoted_to_algebra(ast, context, state)
+    {wrap_in_parens_if_operator(doc, ast), state}
+  end
+
+  defp wrap_in_parens_if_operator(doc, {:__block__, _, [expr]}) do
+    wrap_in_parens_if_operator(doc, expr)
+  end
+
+  defp wrap_in_parens_if_operator(doc, quoted) do
+    if operator?(quoted) and not module_attribute_read?(quoted) and not integer_capture?(quoted) do
+      wrap_in_parens(doc)
+    else
+      doc
+    end
+  end
+
+  defp wrap_in_parens_if_binary_operator(doc, quoted) do
+    if binary_operator?(quoted) do
+      wrap_in_parens(doc)
+    else
+      doc
+    end
+  end
+
+  defp wrap_in_parens_if_inspected_atom(":" <> _ = doc) do
+    "(" <> doc <> ")"
+  end
+
+  defp wrap_in_parens_if_inspected_atom(doc) do
+    doc
+  end
+
+  defp wrap_in_parens(doc) do
+    concat(concat("(", nest(doc, :cursor)), ")")
+  end
+
+  defp many_args_to_algebra([arg | args], state, fun) do
+    Enum.reduce(args, fun.(arg, state), fn arg, {doc_acc, state_acc} ->
+      {arg_doc, state_acc} = fun.(arg, state_acc)
+      {glue(concat(doc_acc, ","), arg_doc), state_acc}
+    end)
+  end
+
+  defp module_attribute_read?({:@, _, [{var, _, var_context}]})
+       when is_atom(var) and is_atom(var_context) do
+    Macro.classify_atom(var) == :identifier
+  end
+
+  defp module_attribute_read?(_), do: false
+
+  defp integer_capture?({:&, _, [integer]}) when is_integer(integer), do: true
+  defp integer_capture?(_), do: false
+
+  defp operator?(quoted) do
+    unary_operator?(quoted) or binary_operator?(quoted)
+  end
+
+  # We convert ..// into two operators for simplicity,
+  # so we need to augment the binary table.
+  defp augmented_binary_op(:"//"), do: {:right, 190}
+  defp augmented_binary_op(op), do: Code.Identifier.binary_op(op)
+
+  defp binary_operator?(quoted) do
+    case quoted do
+      {op, _, [_, _, _]} when op in @multi_binary_operators -> true
+      {op, _, [_, _]} when is_atom(op) -> augmented_binary_op(op) != :error
+      _ -> false
+    end
+  end
+
+  defp unary_operator?(quoted) do
+    case quoted do
+      {op, _, [_]} when is_atom(op) -> Code.Identifier.unary_op(op) != :error
+      _ -> false
+    end
+  end
+
+  defp with_next_break_fits(condition, doc, fun) do
+    if condition do
+      doc
+      |> group(:optimistic)
+      |> fun.()
+      |> group(:pessimistic)
+    else
+      doc
+      |> group()
+      |> fun.()
+      |> group()
+    end
+  end
+
+  defp next_break_fits?({:{}, meta, _args}, state) do
+    eol_or_comments?(meta, state)
+  end
+
+  defp next_break_fits?({:__block__, meta, [{_, _}]}, state) do
+    eol_or_comments?(meta, state)
+  end
+
+  defp next_break_fits?({:<<>>, meta, [_ | _] = entries}, state) do
+    meta[:delimiter] == ~s["""] or
+      (not interpolated?(entries) and eol_or_comments?(meta, state))
+  end
+
+  # TODO: Remove this clause on Elixir v2.0 once single-quoted charlists are removed
+  defp next_break_fits?({{:., _, [List, :to_charlist]}, meta, [[_ | _]]}, _state) do
+    meta[:delimiter] == ~s[''']
+  end
+
+  defp next_break_fits?({{:., _, [_left, :{}]}, _, _}, _state) do
+    true
+  end
+
+  defp next_break_fits?({:__block__, meta, [string]}, _state) when is_binary(string) do
+    meta[:delimiter] == ~s["""]
+  end
+
+  defp next_break_fits?({:__block__, meta, [list]}, _state) when is_list(list) do
+    meta[:delimiter] != ~s[']
+  end
+
+  defp next_break_fits?({form, _, [_ | _]}, _state) when form in [:fn, :%{}, :%] do
+    true
+  end
+
+  defp next_break_fits?({fun, meta, args}, _state) when is_atom(fun) and is_list(args) do
+    meta[:delimiter] in [@double_heredoc, @single_heredoc] and
+      fun |> Atom.to_string() |> String.starts_with?("sigil_")
+  end
+
+  defp next_break_fits?({{:__block__, _, [atom]}, expr}, state) when is_atom(atom) do
+    next_break_fits?(expr, state)
+  end
+
+  defp next_break_fits?(_, _state) do
+    false
+  end
+
+  defp eol_or_comments?(meta, %{comments: comments} = state) do
+    eol?(meta, state) or
+      (
+        min_line = line(meta)
+        max_line = closing_line(meta)
+        Enum.any?(comments, fn %{line: line} -> line > min_line and line < max_line end)
+      )
+  end
+
+  # A literal list is a keyword or (... -> ...)
+  defp last_arg_to_keyword([_ | _] = arg, _list_to_keyword?, _skip_parens?, _comments) do
+    {keyword?(arg), arg}
+  end
+
+  # This is a list of tuples, it can be converted to keywords.
+  defp last_arg_to_keyword(
+         {:__block__, meta, [[_ | _] = arg]} = block,
+         true,
+         skip_parens?,
+         comments
+       ) do
+    cond do
+      not keyword?(arg) ->
+        {false, block}
+
+      skip_parens? ->
+        block_line = line(meta)
+        {{_, arg_meta, _}, _} = hd(arg)
+        first_line = line(arg_meta)
+
+        case Enum.drop_while(comments, fn %{line: line} -> line <= block_line end) do
+          [%{line: line} | _] when line <= first_line ->
+            {false, block}
+
+          _ ->
+            {true, arg}
+        end
+
+      true ->
+        {true, arg}
+    end
+  end
+
+  # Otherwise we don't have a keyword.
+  defp last_arg_to_keyword(arg, _list_to_keyword?, _skip_parens?, _comments) do
+    {false, arg}
+  end
+
+  defp force_args?(args) do
+    match?([_ | _], args) and force_args?(args, %{})
+  end
+
+  defp force_args?([[arg | _] | args], lines) do
+    force_args?([arg | args], lines)
+  end
+
+  defp force_args?([arg | args], lines) do
+    line =
+      case arg do
+        {{_, meta, _}, _} -> meta[:line]
+        {_, meta, _} -> meta[:line]
+      end
+
+    cond do
+      # Line may be missing from non-formatter AST
+      is_nil(line) -> force_args?(args, lines)
+      Map.has_key?(lines, line) -> false
+      true -> force_args?(args, Map.put(lines, line, true))
+    end
+  end
+
+  defp force_args?([], lines), do: map_size(lines) >= 2
+
+  defp force_keyword(doc, arg) do
+    if force_args?(arg), do: force_unfit(doc), else: doc
+  end
+
+  defp keyword?([{_, _} | list]), do: keyword?(list)
+  defp keyword?(rest), do: rest == []
+
+  defp keyword_key?({:__block__, meta, [atom]}) when is_atom(atom),
+    do: meta[:format] == :keyword
+
+  defp keyword_key?({{:., _, [:erlang, :binary_to_atom]}, meta, [{:<<>>, _, _}, :utf8]}),
+    do: meta[:format] == :keyword
+
+  defp keyword_key?(_),
+    do: false
+
+  defp eol?(_meta, %{skip_eol: true}), do: false
+  defp eol?(meta, _state), do: Keyword.get(meta, :newlines, 0) > 0
+
+  defp meta?(meta, key) do
+    is_list(meta[key])
+  end
+
+  defp line(meta) do
+    meta[:line] || @max_line
+  end
+
+  defp end_line(meta) do
+    meta[:end][:line] || @min_line
+  end
+
+  defp closing_line(meta) do
+    meta[:closing][:line] || @min_line
+  end
+
+  defp escape_atom(string, char) do
+    String.replace(string, <<char>>, <<?\\, char>>)
+  end
+
+  ## Algebra helpers
+
+  # Relying on the inner document is brittle and error prone.
+  # It would be best if we had a mechanism to apply this.
+  defp concat_to_last_group([left | right], concat) do
+    [left | concat_to_last_group(right, concat)]
+  end
+
+  defp concat_to_last_group({:doc_group, group, mode}, concat) do
+    {:doc_group, concat(group, concat), mode}
+  end
+
+  defp concat_to_last_group(other, concat) do
+    concat(other, concat)
+  end
+
+  defp ungroup_if_group({:doc_group, group, _mode}), do: group
+  defp ungroup_if_group(other), do: other
+
+  defp format_to_string(doc) do
+    doc |> Inspect.Algebra.format(:infinity) |> IO.iodata_to_binary()
+  end
+
+  defp maybe_empty_line() do
+    nest(break(""), :reset)
+  end
+
+  defp surround(left, doc, right) do
+    if doc == @empty do
+      concat(left, right)
+    else
+      group(glue(nest(glue(left, "", doc), 2, :break), "", right))
+    end
+  end
+
+  defp nest_by_length(doc, string) do
+    nest(doc, String.length(string))
+  end
+
+  defp split_last(list) do
+    {left, [right]} = Enum.split(list, -1)
+    {left, right}
+  end
+
+  defp get_charlist_quotes(:heredoc, state) do
+    if state.migrate_charlists_as_sigils do
+      {@sigil_c_heredoc, @double_heredoc}
+    else
+      {@single_heredoc, @single_heredoc}
+    end
+  end
+
+  defp get_charlist_quotes({:regular, chunks}, state) do
+    cond do
+      !state.migrate_charlists_as_sigils -> {@single_quote, @single_quote}
+      Enum.any?(chunks, &has_double_quote?/1) -> {@sigil_c_single, @single_quote}
+      true -> {@sigil_c_double, @double_quote}
+    end
+  end
+
+  defp has_double_quote?(chunk) do
+    is_binary(chunk) and chunk =~ @double_quote
+  end
+
+  # Migration rewrites
+
+  @bool_operators [
+    :>,
+    :>=,
+    :<,
+    :<=,
+    :in
+  ]
+  @guards [
+    :is_atom,
+    :is_boolean,
+    :is_nil,
+    :is_number,
+    :is_integer,
+    :is_float,
+    :is_binary,
+    :is_map,
+    :is_struct,
+    :is_non_struct_map,
+    :is_exception,
+    :is_list,
+    :is_tuple,
+    :is_function,
+    :is_reference,
+    :is_pid,
+    :is_port
+  ]
+
+  defp negate_condition(condition) do
+    case condition do
+      {neg, _, [condition]} when neg in [:!, :not] -> condition
+      {op, _, [_, _]} when op in @bool_operators -> {:not, [], [condition]}
+      {guard, _, [_ | _]} when guard in @guards -> {:not, [], [condition]}
+      {:==, meta, [left, right]} -> {:!=, meta, [left, right]}
+      {:===, meta, [left, right]} -> {:!==, meta, [left, right]}
+      {:!=, meta, [left, right]} -> {:==, meta, [left, right]}
+      {:!==, meta, [left, right]} -> {:===, meta, [left, right]}
+      _ -> {:!, [], [condition]}
+    end
+  end
+end
diff --git a/lib/elixir/lib/code/fragment.ex b/lib/elixir/lib/code/fragment.ex
new file mode 100644
index 00000000000..c4dcd2b8e87
--- /dev/null
+++ b/lib/elixir/lib/code/fragment.ex
@@ -0,0 +1,1346 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Code.Fragment do
+  @moduledoc """
+  This module provides conveniences for analyzing fragments of
+  textual code and extract available information whenever possible.
+
+  This module should be considered experimental.
+  """
+
+  @type position :: {line :: pos_integer(), column :: pos_integer()}
+
+  @typedoc """
+  Options for cursor context functions.
+
+  Currently, these options are not used but reserved for future extensibility.
+  """
+  @type cursor_opts :: []
+
+  @typedoc """
+  Options for converting code fragments to quoted expressions.
+  """
+  @type container_cursor_to_quoted_opts :: [
+          file: String.t(),
+          line: pos_integer(),
+          column: pos_integer(),
+          columns: boolean(),
+          token_metadata: boolean(),
+          literal_encoder: (term(), Macro.metadata() -> term()),
+          trailing_fragment: String.t()
+        ]
+
+  @doc ~S"""
+  Returns the list of lines in the given string, preserving their line endings.
+
+  Only the line endings recognized by the Elixir compiler are
+  considered, namely `\r\n` and `\n`. If you would like the retrieve
+  lines without their line endings, use `String.split(string, ["\r\n", "\n"])`.
+
+  ## Examples
+
+      iex> Code.Fragment.lines("foo\r\nbar\r\nbaz")
+      ["foo\r\n", "bar\r\n", "baz"]
+
+      iex> Code.Fragment.lines("foo\nbar\nbaz")
+      ["foo\n", "bar\n", "baz"]
+
+      iex> Code.Fragment.lines("")
+      [""]
+
+  """
+  @doc since: "1.19.0"
+  def lines(string) do
+    lines(string, <<>>)
+  end
+
+  defp lines(<<?\n, rest::binary>>, acc),
+    do: [<<acc::binary, ?\n>> | lines(rest, <<>>)]
+
+  defp lines(<<char, rest::binary>>, acc),
+    do: lines(rest, <<acc::binary, char>>)
+
+  defp lines(<<>>, acc),
+    do: [acc]
+
+  @doc """
+  Receives a string and returns the cursor context.
+
+  This function receives a string with an Elixir code fragment,
+  representing a cursor position, and based on the string, it
+  provides contextual information about the latest token.
+  The return of this function can then be used to provide tips,
+  suggestions, and autocompletion functionality.
+
+  This function performs its analyses on tokens. This means
+  it does not understand how constructs are nested within each
+  other. See the "Limitations" section below.
+
+  Consider adding a catch-all clause when handling the return
+  type of this function as new cursor information may be added
+  in future releases.
+
+  ## Examples
+
+      iex> Code.Fragment.cursor_context("")
+      :expr
+
+      iex> Code.Fragment.cursor_context("hello_wor")
+      {:local_or_var, ~c"hello_wor"}
+
+  ## Return values
+
+    * `{:alias, charlist}` - the context is an alias, potentially
+      a nested one, such as `Hello.Wor` or `HelloWor`
+
+    * `{:alias, inside_alias, charlist}` - the context is an alias, potentially
+      a nested one, where `inside_alias` is an expression `{:module_attribute, charlist}`
+      or `{:local_or_var, charlist}` and `charlist` is a static part
+      Examples are `__MODULE__.Submodule` or `@hello.Submodule`
+
+    * `{:block_keyword_or_binary_operator, charlist}` - may be a block keyword (do, end, after,
+      catch, else, rescue) or a binary operator
+
+    * `{:dot, inside_dot, charlist}` - the context is a dot
+      where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`,
+      `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot`
+      itself. If a var is given, this may either be a remote call or a map
+      field access. Examples are `Hello.wor`, `:hello.wor`, `hello.wor`,
+      `Hello.nested.wor`, `hello.nested.wor`, and `@hello.world`. If `charlist`
+      is empty and `inside_dot` is an alias, then the autocompletion may either
+      be an alias or a remote call.
+
+    * `{:dot_arity, inside_dot, charlist}` - the context is a dot arity
+      where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`,
+      `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot`
+      itself. If a var is given, it must be a remote arity. Examples are
+      `Hello.world/`, `:hello.world/`, `hello.world/2`, and `@hello.world/2`
+
+    * `{:dot_call, inside_dot, charlist}` - the context is a dot
+      call. This means parentheses or space have been added after the expression.
+      where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`,
+      `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot`
+      itself. If a var is given, it must be a remote call. Examples are
+      `Hello.world(`, `:hello.world(`, `Hello.world `, `hello.world(`, `hello.world `,
+      and `@hello.world(`
+
+    * `:expr` - may be any expression. Autocompletion may suggest an alias,
+      local or var
+
+    * `{:local_or_var, charlist}` - the context is a variable or a local
+      (import or local) call, such as `hello_wor`
+
+    * `{:local_arity, charlist}` - the context is a local (import or local)
+      arity, such as `hello_world/`
+
+    * `{:local_call, charlist}` - the context is a local (import or local)
+      call, such as `hello_world(` and `hello_world `
+
+    * `{:anonymous_call, inside_caller}` - the context is an anonymous
+      call, such as `fun.(` and `@fun.(`.
+
+    * `{:module_attribute, charlist}` - the context is a module attribute,
+      such as `@hello_wor`
+
+    * `{:operator, charlist}` - the context is an operator, such as `+` or
+      `==`. Note textual operators, such as `when` do not appear as operators
+      but rather as `:local_or_var`. `@` is never an `:operator` and always a
+      `:module_attribute`
+
+    * `{:operator_arity, charlist}` - the context is an operator arity, which
+      is an operator followed by /, such as `+/`, `not/` or `when/`
+
+    * `{:operator_call, charlist}` - the context is an operator call, which is
+      an operator followed by space, such as `left + `, `not ` or `x when `
+
+    * `:none` - no context possible
+
+    * `{:sigil, charlist}` - the context is a sigil. It may be either the beginning
+      of a sigil, such as `~` or `~s`, or an operator starting with `~`, such as
+      `~>` and `~>>`
+
+    * `{:struct, inside_struct}` - the context is a struct, such as `%`, `%UR` or `%URI`.
+      `inside_struct` can either be a `charlist` in case of a static alias or an
+      expression `{:alias, inside_alias, charlist}`, `{:module_attribute, charlist}`,
+      `{:local_or_var, charlist}`, `{:dot, inside_dot, charlist}`
+
+    * `{:unquoted_atom, charlist}` - the context is an unquoted atom. This
+      can be any atom or an atom representing a module
+
+  We recommend looking at the test suite of this function for a complete list
+  of examples and their return values.
+
+  ## Limitations
+
+  The analysis is based on the current token, by analysing the last line of
+  the input. For example, this code:
+
+      iex> Code.Fragment.cursor_context("%URI{")
+      :expr
+
+  returns `:expr`, which suggests any variable, local function or alias
+  could be used. However, given we are inside a struct, the best suggestion
+  would be a struct field. In such cases, you can use
+  `container_cursor_to_quoted`, which will return the container of the AST
+  the cursor is currently within. You can then analyse this AST to provide
+  completion of field names.
+
+  As a consequence of its token-based implementation, this function considers
+  only the last line of the input. This means it will show suggestions inside
+  strings, heredocs, etc, which is intentional as it helps with doctests,
+  references, and more.
+  """
+  @doc since: "1.13.0"
+  @spec cursor_context(List.Chars.t(), cursor_opts()) ::
+          {:alias, charlist}
+          | {:alias, inside_alias, charlist}
+          | {:block_keyword_or_binary_operator, charlist}
+          | {:dot, inside_dot, charlist}
+          | {:dot_arity, inside_dot, charlist}
+          | {:dot_call, inside_dot, charlist}
+          | :expr
+          | {:local_or_var, charlist}
+          | {:local_arity, charlist}
+          | {:local_call, charlist}
+          | {:anonymous_call, inside_caller}
+          | {:module_attribute, charlist}
+          | {:operator, charlist}
+          | {:operator_arity, charlist}
+          | {:operator_call, charlist}
+          | :none
+          | {:sigil, charlist}
+          | {:struct, inside_struct}
+          | {:unquoted_atom, charlist}
+        when inside_dot:
+               {:alias, charlist}
+               | {:alias, inside_alias, charlist}
+               | {:dot, inside_dot, charlist}
+               | {:module_attribute, charlist}
+               | {:unquoted_atom, charlist}
+               | {:var, charlist}
+               | :expr,
+             inside_alias:
+               {:local_or_var, charlist}
+               | {:module_attribute, charlist},
+             inside_struct:
+               charlist
+               | {:alias, inside_alias, charlist}
+               | {:local_or_var, charlist}
+               | {:module_attribute, charlist}
+               | {:dot, inside_dot, charlist},
+             inside_caller: {:var, charlist} | {:module_attribute, charlist}
+  def cursor_context(fragment, opts \\ [])
+
+  def cursor_context(fragment, opts)
+      when (is_binary(fragment) or is_list(fragment)) and is_list(opts) do
+    fragment
+    |> last_line()
+    |> :lists.reverse()
+    |> codepoint_cursor_context(opts)
+    |> elem(0)
+  end
+
+  def cursor_context(other, opts) when is_list(opts) do
+    cursor_context(to_charlist(other), opts)
+  end
+
+  @operators ~c"\\<>+-*/:=|&~^%!$"
+  @starting_punctuation ~c",([{;"
+  @closing_punctuation ~c")]}\"'"
+  @space ~c"\t\s"
+  @trailing_identifier ~c"?!"
+  @tilde_op_prefix ~c"<=~"
+
+  @non_identifier @trailing_identifier ++
+                    @operators ++ @starting_punctuation ++ @closing_punctuation ++ @space ++ [?.]
+
+  @textual_operators ~w(when not and or in)c
+  @keywords ~w(do end after else catch rescue fn true false nil)c
+
+  defp codepoint_cursor_context(reverse, _opts) do
+    {stripped, spaces} = strip_spaces(reverse, 0)
+
+    case stripped do
+      # It is empty
+      [] -> {:expr, 0}
+      # Structs
+      [?%, ?:, ?: | _] -> {{:struct, ~c""}, 1}
+      [?%, ?: | _] -> {{:unquoted_atom, ~c"%"}, 2}
+      [?% | _] -> {{:struct, ~c""}, 1}
+      # Token/AST only operators
+      [?>, ?= | rest] when rest == [] or hd(rest) != ?: -> {:expr, 0}
+      [?>, ?- | rest] when rest == [] or hd(rest) != ?: -> {:expr, 0}
+      # Two-digit containers
+      [?<, ?< | rest] when rest == [] or hd(rest) != ?< -> {:expr, 0}
+      # Ambiguity around :
+      [?: | rest] when rest == [] or hd(rest) != ?: -> unquoted_atom_or_expr(spaces)
+      # Dots
+      [?.] -> {:none, 0}
+      [?. | rest] when hd(rest) not in ~c".:" -> dot(rest, spaces + 1, ~c"")
+      # It is a local or remote call with parens
+      [?( | rest] -> call_to_cursor_context(strip_spaces(rest, spaces + 1))
+      # A local arity definition
+      [?/ | rest] -> arity_to_cursor_context(strip_spaces(rest, spaces + 1))
+      # Starting a new expression
+      [h | _] when h in @starting_punctuation -> {:expr, 0}
+      # It is keyword, binary operator, a local or remote call without parens
+      rest when spaces > 0 -> closing_or_call_to_cursor_context({rest, spaces})
+      # It is an identifier
+      _ -> identifier_to_cursor_context(reverse, spaces, false)
+    end
+  end
+
+  defp strip_spaces([h | rest], count) when h in @space, do: strip_spaces(rest, count + 1)
+  defp strip_spaces(rest, count), do: {rest, count}
+
+  defp unquoted_atom_or_expr(0), do: {{:unquoted_atom, ~c""}, 1}
+  defp unquoted_atom_or_expr(_), do: {:expr, 0}
+
+  defp arity_to_cursor_context({reverse, spaces}) do
+    case identifier_to_cursor_context(reverse, spaces, true) do
+      {{:local_or_var, acc}, count} -> {{:local_arity, acc}, count}
+      {{:dot, base, acc}, count} -> {{:dot_arity, base, acc}, count}
+      {{:operator, acc}, count} -> {{:operator_arity, acc}, count}
+      {{:sigil, _}, _} -> {:none, 0}
+      {_, _} -> {{:operator, ~c"/"}, 1}
+    end
+  end
+
+  defp call_to_cursor_context({reverse, spaces}) do
+    with [?. | rest] <- reverse,
+         {rest, spaces} = strip_spaces(rest, spaces),
+         [h | _] when h not in @non_identifier <- rest do
+      case identifier_to_cursor_context(rest, spaces, true) do
+        {{:local_or_var, acc}, count} -> {{:anonymous_call, {:var, acc}}, count + 1}
+        {{:module_attribute, _} = attr, count} -> {{:anonymous_call, attr}, count + 1}
+        {_, _} -> {:none, 0}
+      end
+    else
+      _ ->
+        case identifier_to_cursor_context(reverse, spaces, true) do
+          {{:local_or_var, acc}, count} -> {{:local_call, acc}, count}
+          {{:dot, base, acc}, count} -> {{:dot_call, base, acc}, count}
+          {{:operator, acc}, count} -> {{:operator_call, acc}, count}
+          {_, _} -> {:none, 0}
+        end
+    end
+  end
+
+  defp closing_or_call_to_cursor_context({reverse, spaces}) do
+    if closing?(reverse) do
+      {{:block_keyword_or_binary_operator, ~c""}, 0}
+    else
+      call_to_cursor_context({reverse, spaces})
+    end
+  end
+
+  defp identifier_to_cursor_context([?., ?., ?: | _], n, _), do: {{:unquoted_atom, ~c".."}, n + 3}
+  defp identifier_to_cursor_context([?., ?., ?. | _], n, _), do: {{:operator, ~c"..."}, n + 3}
+  defp identifier_to_cursor_context([?., ?: | _], n, _), do: {{:unquoted_atom, ~c"."}, n + 2}
+  defp identifier_to_cursor_context([?., ?. | _], n, _), do: {{:operator, ~c".."}, n + 2}
+
+  defp identifier_to_cursor_context(reverse, count, call_op?) do
+    case identifier(reverse, count) do
+      :none ->
+        {:none, 0}
+
+      :operator ->
+        operator(reverse, count, [], call_op?)
+
+      {:struct, {:module_attribute, acc}, count} ->
+        {{:struct, {:module_attribute, acc}}, count + 1}
+
+      {:module_attribute, acc, count} ->
+        {{:module_attribute, acc}, count}
+
+      {:sigil, acc, count} ->
+        {{:sigil, acc}, count}
+
+      {:unquoted_atom, acc, count} ->
+        {{:unquoted_atom, acc}, count}
+
+      {:alias, rest, acc, count} ->
+        case strip_spaces(rest, count) do
+          {~c"." ++ rest, count} when rest == [] or hd(rest) != ?. ->
+            nested_alias(rest, count + 1, acc)
+
+          {~c"%" ++ _, count} ->
+            {{:struct, acc}, count + 1}
+
+          _ ->
+            {{:alias, acc}, count}
+        end
+
+      {:identifier, _, acc, count} when call_op? and acc in @textual_operators ->
+        {{:operator, acc}, count}
+
+      {:identifier, [?%], acc, count} ->
+        case identifier_to_cursor_context(acc |> Enum.reverse(), count, true) do
+          {{:local_or_var, _} = identifier, _} -> {{:struct, identifier}, count + 1}
+          _ -> {:none, 0}
+        end
+
+      {:identifier, rest, acc, count} ->
+        case strip_spaces(rest, count) do
+          {~c"." ++ rest, count} when rest == [] or hd(rest) != ?. ->
+            dot(rest, count + 1, acc)
+
+          {rest, rest_count} ->
+            response =
+              if rest_count > count and closing?(rest),
+                do: :block_keyword_or_binary_operator,
+                else: :local_or_var
+
+            {{response, acc}, count}
+        end
+
+      {:capture_arg, acc, count} ->
+        {{:capture_arg, acc}, count}
+    end
+  end
+
+  # If it is a closing punctuation
+  defp closing?([h | _]) when h in @closing_punctuation, do: true
+  # Closing bitstring (but deal with operators)
+  defp closing?([?>, ?> | rest]), do: rest == [] or hd(rest) not in [?>, ?~]
+  # Keywords
+  defp closing?(rest) do
+    case split_non_identifier(rest, []) do
+      {~c"nil", _} -> true
+      {~c"true", _} -> true
+      {~c"false", _} -> true
+      {[digit | _], _} when digit in ?0..?9 -> true
+      {[upper | _], _} when upper in ?A..?Z -> true
+      {[_ | _], [?: | rest]} -> rest == [] or hd(rest) != ?:
+      {_, _} -> false
+    end
+  end
+
+  defp split_non_identifier([h | t], acc) when h not in @non_identifier,
+    do: split_non_identifier(t, [h | acc])
+
+  defp split_non_identifier(rest, acc), do: {acc, rest}
+
+  defp identifier([?? | rest], count), do: check_identifier(rest, count + 1, [??])
+  defp identifier([?! | rest], count), do: check_identifier(rest, count + 1, [?!])
+  defp identifier(rest, count), do: check_identifier(rest, count, [])
+
+  defp check_identifier([h | t], count, acc) when h not in @non_identifier,
+    do: rest_identifier(t, count + 1, [h | acc])
+
+  defp check_identifier(_, _, _), do: :operator
+
+  defp rest_identifier([h | rest], count, acc) when h not in @non_identifier do
+    rest_identifier(rest, count + 1, [h | acc])
+  end
+
+  defp rest_identifier(rest, count, [?@ | acc]) do
+    case tokenize_identifier(rest, count, acc) do
+      {:identifier, [?% | _rest], acc, count} -> {:struct, {:module_attribute, acc}, count}
+      {:identifier, _rest, acc, count} -> {:module_attribute, acc, count}
+      :none when acc == [] -> {:module_attribute, ~c"", count}
+      _ -> :none
+    end
+  end
+
+  defp rest_identifier([?~ | rest], count, [letter])
+       when (letter in ?A..?Z or letter in ?a..?z) and
+              (rest == [] or hd(rest) not in @tilde_op_prefix) do
+    {:sigil, [letter], count + 1}
+  end
+
+  defp rest_identifier([?: | rest], count, acc) when rest == [] or hd(rest) != ?: do
+    case String.Tokenizer.tokenize(acc) do
+      {_, _, [], _, _, _} -> {:unquoted_atom, acc, count + 1}
+      _ -> :none
+    end
+  end
+
+  defp rest_identifier([?? | _], _count, _acc) do
+    :none
+  end
+
+  defp rest_identifier([?& | tail] = rest, count, acc) when tail == [] or hd(tail) != ?& do
+    if Enum.all?(acc, &(&1 in ?0..?9)) do
+      {:capture_arg, [?& | acc], count + 1}
+    else
+      tokenize_identifier(rest, count, acc)
+    end
+  end
+
+  defp rest_identifier(rest, count, acc) do
+    tokenize_identifier(rest, count, acc)
+  end
+
+  defp tokenize_identifier(rest, count, acc) do
+    case String.Tokenizer.tokenize(acc) do
+      # Not actually an atom cause rest is not a :
+      {:atom, _, _, _, _, _} ->
+        :none
+
+      # Aliases must be ascii only
+      {:alias, _, _, _, false, _} ->
+        :none
+
+      {kind, _, [], _, _, extra} ->
+        if :at in extra do
+          :none
+        else
+          {kind, rest, acc, count}
+        end
+
+      _ ->
+        :none
+    end
+  end
+
+  defp nested_alias(rest, count, acc) do
+    {rest, count} = strip_spaces(rest, count)
+
+    case identifier_to_cursor_context(rest, count, true) do
+      {{:struct, prev}, count} when is_list(prev) ->
+        {{:struct, prev ++ ~c"." ++ acc}, count}
+
+      {{:struct, {:alias, parent, prev}}, count} ->
+        {{:struct, {:alias, parent, prev ++ ~c"." ++ acc}}, count}
+
+      {{:struct, prev}, count} ->
+        {{:struct, {:alias, prev, acc}}, count}
+
+      {{:alias, prev}, count} ->
+        {{:alias, prev ++ ~c"." ++ acc}, count}
+
+      {{:alias, parent, prev}, count} ->
+        {{:alias, parent, prev ++ ~c"." ++ acc}, count}
+
+      {{:local_or_var, prev}, count} ->
+        {{:alias, {:local_or_var, prev}, acc}, count}
+
+      {{:module_attribute, prev}, count} ->
+        {{:alias, {:module_attribute, prev}, acc}, count}
+
+      _ ->
+        {:none, 0}
+    end
+  end
+
+  defp dot(rest, count, acc) do
+    {rest, count} = strip_spaces(rest, count)
+
+    case identifier_to_cursor_context(rest, count, true) do
+      {{:local_or_var, var}, count} ->
+        {{:dot, {:var, var}, acc}, count}
+
+      {{:unquoted_atom, _} = prev, count} ->
+        {{:dot, prev, acc}, count}
+
+      {{:alias, _} = prev, count} ->
+        {{:dot, prev, acc}, count}
+
+      {{:alias, _, _} = prev, count} ->
+        {{:dot, prev, acc}, count}
+
+      {{:struct, inner}, count} when is_list(inner) ->
+        {{:struct, {:dot, {:alias, inner}, acc}}, count}
+
+      {{:struct, inner}, count} ->
+        {{:struct, {:dot, inner, acc}}, count}
+
+      {{:dot, _, _} = prev, count} ->
+        {{:dot, prev, acc}, count}
+
+      {{:module_attribute, _} = prev, count} ->
+        {{:dot, prev, acc}, count}
+
+      {:expr, count} ->
+        {{:dot, :expr, acc}, count}
+
+      {_, _} ->
+        {:none, 0}
+    end
+  end
+
+  defp operator([h | rest], count, acc, call_op?) when h in @operators do
+    operator(rest, count + 1, [h | acc], call_op?)
+  end
+
+  # If we are opening a sigil, ignore the operator.
+  defp operator([letter, ?~ | rest], _count, [op], _call_op?)
+       when op in ~c"<|/" and (letter in ?A..?Z or letter in ?a..?z) and
+              (rest == [] or hd(rest) not in @tilde_op_prefix) do
+    {:none, 0}
+  end
+
+  defp operator(rest, count, ~c"~", call_op?) do
+    {rest, _} = strip_spaces(rest, count)
+
+    if call_op? or match?([?. | rest] when rest == [] or hd(rest) != ?., rest) do
+      {:none, 0}
+    else
+      {{:sigil, ~c""}, count}
+    end
+  end
+
+  defp operator([?) | rest], _, [], true) when hd(rest) != ?? do
+    {:expr, 0}
+  end
+
+  defp operator(rest, count, acc, _call_op?) do
+    case :elixir_tokenizer.tokenize(acc, 1, 1, []) do
+      {:ok, _, _, _, [{:atom, _, _}], []} ->
+        {{:unquoted_atom, tl(acc)}, count}
+
+      {:ok, _, _, _, [{_, _, op}], []} ->
+        {rest, dot_count} = strip_spaces(rest, count)
+
+        cond do
+          Code.Identifier.unary_op(op) == :error and Code.Identifier.binary_op(op) == :error ->
+            {:none, 0}
+
+          match?([?. | rest] when rest == [] or hd(rest) != ?., rest) ->
+            dot(tl(rest), dot_count + 1, acc)
+
+          true ->
+            {{:operator, acc}, count}
+        end
+
+      _ ->
+        {:none, 0}
+    end
+  end
+
+  @doc """
+  Receives a string and returns the surround context.
+
+  This function receives a string with an Elixir code fragment
+  and a `position`. It returns a map containing the beginning
+  and ending of the identifier alongside its context, or `:none`
+  if there is nothing with a known context. This is useful to
+  provide mouse-over and highlight functionality in editors.
+
+  The difference between `cursor_context/2` and `surround_context/3`
+  is that the former assumes the expression in the code fragment
+  is incomplete. For example, `do` in `cursor_context/2` may be
+  a keyword or a variable or a local call, while `surround_context/3`
+  assumes the expression in the code fragment is complete, therefore
+  `do` would always be a keyword.
+
+  The `position` contains both the `line` and `column`, both starting
+  with the index of 1. The column must precede the surrounding expression.
+  For example, the expression `foo`, will return something for the columns
+  1, 2, and 3, but not 4:
+
+      foo
+      ^ column 1
+
+      foo
+       ^ column 2
+
+      foo
+        ^ column 3
+
+      foo
+         ^ column 4
+
+  The returned map contains the column the expression starts and the
+  first column after the expression ends.
+
+  Similar to `cursor_context/2`, this function is also token-based
+  and may not be accurate under all circumstances. See the
+  "Return values" and "Limitations" section under `cursor_context/2`
+  for more information.
+
+  ## Examples
+
+      iex> Code.Fragment.surround_context("foo", {1, 1})
+      %{begin: {1, 1}, context: {:local_or_var, ~c"foo"}, end: {1, 4}}
+
+  ## Differences to `cursor_context/2`
+
+  Because `surround_context/3` attempts to capture complex expressions,
+  it has some differences to `cursor_context/2`:
+
+    * `dot_call`/`dot_arity` and `operator_call`/`operator_arity`
+      are collapsed into `dot` and `operator` contexts respectively
+      as there aren't any meaningful distinctions between them
+
+    * On the other hand, this function still makes a distinction between
+      `local_call`/`local_arity` and `local_or_var`, since the latter can
+      be a local or variable
+
+    * `@` when not followed by any identifier is returned as `{:operator, ~c"@"}`
+      (in contrast to `{:module_attribute, ~c""}` in `cursor_context/2`
+
+    * This function never returns empty sigils `{:sigil, ~c""}` or empty structs
+      `{:struct, ~c""}` as context
+
+    * This function returns keywords as `{:keyword, ~c"do"}`
+
+    * This function never returns `:expr`
+
+  We recommend looking at the test suite of this function for a complete list
+  of examples and their return values.
+  """
+  @doc since: "1.13.0"
+  @spec surround_context(List.Chars.t(), position(), cursor_opts()) ::
+          %{begin: position, end: position, context: context} | :none
+        when context:
+               {:alias, charlist}
+               | {:alias, inside_alias, charlist}
+               | {:dot, inside_dot, charlist}
+               | {:local_or_var, charlist}
+               | {:local_arity, charlist}
+               | {:local_call, charlist}
+               | {:module_attribute, charlist}
+               | {:operator, charlist}
+               | {:sigil, charlist}
+               | {:struct, inside_struct}
+               | {:unquoted_atom, charlist}
+               | {:keyword, charlist}
+               | {:key, charlist}
+               | {:capture_arg, charlist},
+             inside_dot:
+               {:alias, charlist}
+               | {:alias, inside_alias, charlist}
+               | {:dot, inside_dot, charlist}
+               | {:module_attribute, charlist}
+               | {:unquoted_atom, charlist}
+               | {:var, charlist}
+               | :expr,
+             inside_alias:
+               {:local_or_var, charlist}
+               | {:module_attribute, charlist},
+             inside_struct:
+               charlist
+               | {:alias, inside_alias, charlist}
+               | {:local_or_var, charlist}
+               | {:module_attribute, charlist}
+               | {:dot, inside_dot, charlist}
+  def surround_context(fragment, position, options \\ [])
+
+  def surround_context(string, {line, column}, opts)
+      when (is_binary(string) or is_list(string)) and is_list(opts) do
+    {charlist, lines_before_lengths, lines_current_and_after_lengths} =
+      surround_line(string, line, column)
+
+    prepended_columns = Enum.sum(lines_before_lengths)
+
+    charlist
+    |> position_surround_context(line, column + prepended_columns, opts)
+    |> to_multiline_range(
+      prepended_columns,
+      lines_before_lengths,
+      lines_current_and_after_lengths
+    )
+  end
+
+  def surround_context(other, {_, _} = position, opts) do
+    surround_context(to_charlist(other), position, opts)
+  end
+
+  defp position_surround_context(charlist, line, column, opts)
+       when is_integer(line) and line >= 1 and is_integer(column) and column >= 1 do
+    {reversed_pre, post} = string_reverse_at(charlist, column - 1, [])
+    {reversed_pre, post} = adjust_position(reversed_pre, post)
+
+    case take_identifier(post, []) do
+      {_, [], _} ->
+        maybe_operator(reversed_pre, post, line, opts)
+
+      {:identifier, reversed_post, rest} ->
+        {keyword_key?, rest} =
+          case rest do
+            [?: | tail] when tail == [] or hd(tail) in @space ->
+              {true, rest}
+
+            _ ->
+              {rest, _} = strip_spaces(rest, 0)
+              {false, rest}
+          end
+
+        reversed = reversed_post ++ reversed_pre
+
+        case codepoint_cursor_context(reversed, opts) do
+          {{:struct, acc}, offset} ->
+            build_surround({:struct, acc}, reversed, line, offset)
+
+          {{:alias, acc}, offset} ->
+            build_surround({:alias, acc}, reversed, line, offset)
+
+          {{:alias, parent, acc}, offset} ->
+            build_surround({:alias, parent, acc}, reversed, line, offset)
+
+          {{:dot, _, [_ | _]} = dot, offset} ->
+            build_surround(dot, reversed, line, offset)
+
+          {{:local_or_var, acc}, offset} when keyword_key? ->
+            build_surround({:key, acc}, reversed, line, offset)
+
+          {{:local_or_var, acc}, offset} when hd(rest) == ?( ->
+            build_surround({:local_call, acc}, reversed, line, offset)
+
+          {{:local_or_var, acc}, offset} when hd(rest) == ?/ ->
+            build_surround({:local_arity, acc}, reversed, line, offset)
+
+          {{:local_or_var, acc}, offset} when acc in @textual_operators ->
+            build_surround({:operator, acc}, reversed, line, offset)
+
+          {{:local_or_var, acc}, offset} when acc in @keywords ->
+            build_surround({:keyword, acc}, reversed, line, offset)
+
+          {{:local_or_var, acc}, offset} ->
+            build_surround({:local_or_var, acc}, reversed, line, offset)
+
+          {{:block_keyword_or_binary_operator, acc}, offset} when acc in @textual_operators ->
+            build_surround({:operator, acc}, reversed, line, offset)
+
+          {{:block_keyword_or_binary_operator, acc}, offset} when acc in @keywords ->
+            build_surround({:keyword, acc}, reversed, line, offset)
+
+          {{:module_attribute, ~c""}, offset} ->
+            build_surround({:operator, ~c"@"}, reversed, line, offset)
+
+          {{:module_attribute, acc}, offset} ->
+            build_surround({:module_attribute, acc}, reversed, line, offset)
+
+          {{:sigil, acc}, offset} ->
+            build_surround({:sigil, acc}, reversed, line, offset)
+
+          {{:unquoted_atom, acc}, offset} ->
+            build_surround({:unquoted_atom, acc}, reversed, line, offset)
+
+          {{:capture_arg, acc}, offset} ->
+            build_surround({:capture_arg, acc}, reversed, line, offset)
+
+          _ ->
+            maybe_operator(reversed_pre, post, line, opts)
+        end
+
+      {:alias, reversed_post, _rest} ->
+        reversed = reversed_post ++ reversed_pre
+
+        case codepoint_cursor_context(reversed, opts) do
+          {{:alias, acc}, offset} ->
+            build_surround({:alias, acc}, reversed, line, offset)
+
+          {{:alias, parent, acc}, offset} ->
+            build_surround({:alias, parent, acc}, reversed, line, offset)
+
+          {{:struct, acc}, offset} ->
+            build_surround({:struct, acc}, reversed, line, offset)
+
+          _ ->
+            :none
+        end
+    end
+  end
+
+  defp maybe_operator(reversed_pre, post, line, opts) do
+    case take_operator(post, []) do
+      {[], _rest} ->
+        :none
+
+      {reversed_post, rest} ->
+        reversed = reversed_post ++ reversed_pre
+
+        case codepoint_cursor_context(reversed, opts) do
+          {{:operator, ~c"&"}, offset} when hd(rest) in ?0..?9 ->
+            arg = Enum.take_while(rest, &(&1 in ?0..?9))
+
+            build_surround(
+              {:capture_arg, ~c"&" ++ arg},
+              :lists.reverse(arg, reversed),
+              line,
+              offset + length(arg)
+            )
+
+          {{:operator, acc}, offset} ->
+            build_surround({:operator, acc}, reversed, line, offset)
+
+          {{:sigil, ~c""}, offset} when hd(rest) in ?A..?Z or hd(rest) in ?a..?z ->
+            build_surround({:sigil, [hd(rest)]}, [hd(rest) | reversed], line, offset + 1)
+
+          {{:dot, _, [_ | _]} = dot, offset} ->
+            build_surround(dot, reversed, line, offset)
+
+          _ ->
+            :none
+        end
+    end
+  end
+
+  defp build_surround(context, reversed, line, offset) do
+    {post, reversed_pre} = enum_reverse_at(reversed, offset, [])
+    pre = :lists.reverse(reversed_pre)
+    pre_length = :string.length(pre) + 1
+
+    %{
+      context: context,
+      begin: {line, pre_length},
+      end: {line, pre_length + :string.length(post)}
+    }
+  end
+
+  defp take_identifier([h | t], acc) when h in @trailing_identifier,
+    do: {:identifier, [h | acc], t}
+
+  defp take_identifier([h | t], acc) when h not in @non_identifier,
+    do: take_identifier(t, [h | acc])
+
+  defp take_identifier(rest, acc) do
+    with {[?. | t], _} <- strip_spaces(rest, 0),
+         {[h | _], _} when h in ?A..?Z <- strip_spaces(t, 0) do
+      take_alias(rest, acc)
+    else
+      _ -> {:identifier, acc, rest}
+    end
+  end
+
+  defp take_alias([h | t], acc) when h in ?A..?Z or h in ?a..?z or h in ?0..?9 or h == ?_,
+    do: take_alias(t, [h | acc])
+
+  defp take_alias(rest, acc) do
+    with {[?. | t], acc} <- move_spaces(rest, acc),
+         {[h | t], acc} when h in ?A..?Z <- move_spaces(t, [?. | acc]) do
+      take_alias(t, [h | acc])
+    else
+      _ -> {:alias, acc, rest}
+    end
+  end
+
+  defp take_operator([h | t], acc) when h in @operators, do: take_operator(t, [h | acc])
+  defp take_operator([h | t], acc) when h == ?., do: take_operator(t, [h | acc])
+  defp take_operator(rest, acc), do: {acc, rest}
+
+  # Unquoted atom handling
+  defp adjust_position(reversed_pre, [?: | post])
+       when hd(post) != ?: and (reversed_pre == [] or hd(reversed_pre) != ?:) do
+    {[?: | reversed_pre], post}
+  end
+
+  defp adjust_position(reversed_pre, [?% | post]) do
+    adjust_position([?% | reversed_pre], post)
+  end
+
+  # Dot/struct handling
+  defp adjust_position(reversed_pre, post) do
+    case move_spaces(post, reversed_pre) do
+      # If we are between spaces and a dot, move past the dot
+      {[?. | post], reversed_pre} when hd(post) != ?. and hd(reversed_pre) != ?. ->
+        {post, reversed_pre} = move_spaces(post, [?. | reversed_pre])
+        {reversed_pre, post}
+
+      _ ->
+        case strip_spaces(reversed_pre, 0) do
+          # If there is a dot to our left, make sure to move to the first character
+          {[?. | rest], _} when rest == [] or hd(rest) not in ~c".:" ->
+            {post, reversed_pre} = move_spaces(post, reversed_pre)
+            {reversed_pre, post}
+
+          # If there is a % to our left, make sure to move to the first character
+          {[?% | _], _} ->
+            case move_spaces(post, reversed_pre) do
+              {[h | _] = post, reversed_pre} when h in ?A..?Z ->
+                {reversed_pre, post}
+
+              _ ->
+                {reversed_pre, post}
+            end
+
+          _ ->
+            {reversed_pre, post}
+        end
+    end
+  end
+
+  defp move_spaces([h | t], acc) when h in @space, do: move_spaces(t, [h | acc])
+  defp move_spaces(t, acc), do: {t, acc}
+
+  defp string_reverse_at(charlist, 0, acc), do: {acc, charlist}
+
+  defp string_reverse_at(charlist, n, acc) do
+    case :unicode_util.gc(charlist) do
+      [gc | cont] when is_integer(gc) -> string_reverse_at(cont, n - 1, [gc | acc])
+      [gc | cont] when is_list(gc) -> string_reverse_at(cont, n - 1, :lists.reverse(gc, acc))
+      [] -> {acc, []}
+    end
+  end
+
+  defp enum_reverse_at([h | t], n, acc) when n > 0, do: enum_reverse_at(t, n - 1, [h | acc])
+  defp enum_reverse_at(rest, _, acc), do: {acc, rest}
+
+  defp last_line(binary) when is_binary(binary) do
+    [last_line | lines_reverse] =
+      binary
+      |> String.split(["\r\n", "\n"])
+      |> Enum.reverse()
+
+    prepend_cursor_lines(lines_reverse, String.to_charlist(last_line))
+  end
+
+  defp last_line(charlist) when is_list(charlist) do
+    [last_line | lines_reverse] =
+      charlist
+      |> :string.replace(~c"\r\n", ~c"\n", :all)
+      |> :string.join(~c"")
+      |> :string.split(~c"\n", :all)
+      |> Enum.reverse()
+
+    prepend_cursor_lines(lines_reverse, last_line)
+  end
+
+  defp prepend_cursor_lines(lines, last_line) do
+    with [line | lines] <- lines,
+         {trimmed_line, incomplete?} = ends_as_incomplete(to_charlist(line), [], true),
+         true <- incomplete? or starts_with_dot?(last_line) do
+      prepend_cursor_lines(lines, Enum.reverse(trimmed_line, last_line))
+    else
+      _ -> last_line
+    end
+  end
+
+  defp starts_with_dot?([?. | _]), do: true
+  defp starts_with_dot?([h | t]) when h in @space, do: starts_with_dot?(t)
+  defp starts_with_dot?(_), do: false
+
+  defp ends_as_incomplete([?# | _], acc, incomplete?),
+    do: {acc, incomplete?}
+
+  defp ends_as_incomplete([h | t], acc, _incomplete?) when h in [?(, ?.],
+    do: ends_as_incomplete(t, [h | acc], true)
+
+  defp ends_as_incomplete([h | t], acc, incomplete?) when h in @space,
+    do: ends_as_incomplete(t, [h | acc], incomplete?)
+
+  defp ends_as_incomplete([h | t], acc, _incomplete?),
+    do: ends_as_incomplete(t, [h | acc], false)
+
+  defp ends_as_incomplete([], acc, incomplete?),
+    do: {acc, incomplete?}
+
+  defp surround_line(binary, line, column) when is_binary(binary) do
+    binary
+    |> String.split(["\r\n", "\n"])
+    |> Enum.map(&String.to_charlist/1)
+    |> surround_lines(line, column)
+  end
+
+  defp surround_line(charlist, line, column) when is_list(charlist) do
+    charlist
+    |> :string.replace(~c"\r\n", ~c"\n", :all)
+    |> :string.join(~c"")
+    |> :string.split(~c"\n", :all)
+    |> surround_lines(line, column)
+  end
+
+  defp surround_lines(lines, line, column) do
+    {lines_before_reverse, cursor_line, lines_after} = split_at(lines, line, [])
+    {trimmed_cursor_line, incomplete?} = ends_as_incomplete(to_charlist(cursor_line), [], true)
+
+    reversed_cursor_line =
+      if column - 1 > length(trimmed_cursor_line) do
+        # Don't strip comments if cursor is inside a comment
+        Enum.reverse(cursor_line)
+      else
+        trimmed_cursor_line
+      end
+
+    {cursor_line, after_lengths} =
+      append_surround_lines(lines_after, [], [reversed_cursor_line], incomplete?)
+
+    {cursor_line, before_lengths} = prepend_surround_lines(lines_before_reverse, [], cursor_line)
+    {cursor_line, before_lengths, [length(reversed_cursor_line) | after_lengths]}
+  end
+
+  defp split_at([line], _, acc), do: {acc, line, []}
+  defp split_at([line | lines], 1, acc), do: {acc, line, lines}
+  defp split_at([line | lines], count, acc), do: split_at(lines, count - 1, [line | acc])
+
+  defp prepend_surround_lines(lines, lengths, last_line) do
+    with [line | lines] <- lines,
+         {trimmed_line, incomplete?} = ends_as_incomplete(to_charlist(line), [], true),
+         true <- incomplete? or starts_with_dot?(last_line) do
+      lengths = [length(trimmed_line) | lengths]
+      prepend_surround_lines(lines, lengths, Enum.reverse(trimmed_line, last_line))
+    else
+      _ -> {last_line, Enum.reverse(lengths)}
+    end
+  end
+
+  defp append_surround_lines(lines, lengths, acc_lines, incomplete?) do
+    with [line | lines] <- lines,
+         line = to_charlist(line),
+         true <- incomplete? or starts_with_dot?(line) do
+      {trimmed_line, incomplete?} = ends_as_incomplete(line, [], true)
+      lengths = [length(trimmed_line) | lengths]
+      append_surround_lines(lines, lengths, [trimmed_line | acc_lines], incomplete?)
+    else
+      _ -> {Enum.reduce(acc_lines, [], &Enum.reverse/2), Enum.reverse(lengths)}
+    end
+  end
+
+  defp to_multiline_range(:none, _, _, _), do: :none
+
+  defp to_multiline_range(
+         %{begin: {begin_line, begin_column}, end: {end_line, end_column}} = context,
+         prepended,
+         lines_before_lengths,
+         lines_current_and_after_lengths
+       ) do
+    {begin_line, begin_column} =
+      Enum.reduce_while(lines_before_lengths, {begin_line, begin_column - prepended}, fn
+        line_length, {acc_line, acc_column} ->
+          if acc_column < 1 do
+            {:cont, {acc_line - 1, acc_column + line_length}}
+          else
+            {:halt, {acc_line, acc_column}}
+          end
+      end)
+
+    {end_line, end_column} =
+      Enum.reduce_while(lines_current_and_after_lengths, {end_line, end_column - prepended}, fn
+        line_length, {acc_line, acc_column} ->
+          if acc_column > line_length + 1 do
+            {:cont, {acc_line + 1, acc_column - line_length}}
+          else
+            {:halt, {acc_line, acc_column}}
+          end
+      end)
+
+    %{context | begin: {begin_line, begin_column}, end: {end_line, end_column}}
+  end
+
+  @doc """
+  Receives a string and returns a quoted expression
+  with the cursor AST position within its parent expression.
+
+  This function receives a string with an Elixir code fragment,
+  representing a cursor position, and converts such string to
+  AST with the inclusion of special `__cursor__()` node representing
+  the cursor position within its container (i.e. its parent).
+
+  For example, take this code, which would be given as input:
+
+      max(some_value,
+
+  This function will return the AST equivalent to:
+
+      max(some_value, __cursor__())
+
+  In other words, this function is capable of closing any open
+  brackets and insert the cursor position. Other content at the
+  cursor position which is not a parent is discarded.
+  For example, if this is given as input:
+
+      max(some_value, another_val
+
+  It will return the same AST:
+
+      max(some_value, __cursor__())
+
+  Similarly, if only this is given:
+
+      max(some_va
+
+  Then it returns:
+
+      max(__cursor__())
+
+  Calls without parenthesis are also supported, as we assume the
+  brackets are implicit.
+
+  Tuples, lists, maps, and binaries all retain the cursor position:
+
+      max(some_value, [1, 2,
+
+  Returns the following AST:
+
+      max(some_value, [1, 2, __cursor__()])
+
+  Keyword lists (and do-end blocks) are also retained. The following:
+
+      if(some_value, do:
+      if(some_value, do: :token
+      if(some_value, do: 1 + val
+
+  all return:
+
+      if(some_value, do: __cursor__())
+
+  For multi-line blocks, all previous lines are preserved.
+
+  The AST returned by this function is not safe to evaluate but
+  it can be analyzed and expanded.
+
+  ## Examples
+
+  Function call:
+
+      iex> Code.Fragment.container_cursor_to_quoted("max(some_value, ")
+      {:ok, {:max, [line: 1], [{:some_value, [line: 1], nil}, {:__cursor__, [line: 1], []}]}}
+
+  Containers (for example, a list):
+
+      iex> Code.Fragment.container_cursor_to_quoted("[some, value")
+      {:ok, [{:some, [line: 1], nil}, {:__cursor__, [line: 1], []}]}
+
+  If an expression is complete, then the whole expression is discarded
+  and only the parent is returned:
+
+      iex> Code.Fragment.container_cursor_to_quoted("if(is_atom(var)")
+      {:ok, {:if, [line: 1], [{:__cursor__, [line: 1], []}]}}
+
+  this means complete expressions themselves return only the cursor:
+
+      iex> Code.Fragment.container_cursor_to_quoted("if(is_atom(var))")
+      {:ok, {:__cursor__, [line: 1], []}}
+
+  Operators are also included from Elixir v1.15:
+
+      iex> Code.Fragment.container_cursor_to_quoted("foo +")
+      {:ok, {:+, [line: 1], [{:foo, [line: 1], nil}, {:__cursor__, [line: 1], []}]}}
+
+  In order to parse the left-side of `->` properly, which appears both
+  in anonymous functions and do-end blocks, the trailing fragment option
+  must be given with the rest of the contents:
+
+      iex> Code.Fragment.container_cursor_to_quoted("fn x", trailing_fragment: " -> :ok end")
+      {:ok, {:fn, [line: 1], [{:->, [line: 1], [[{:__cursor__, [line: 1], []}], :ok]}]}}
+
+  ## Options
+
+    * `:file` - the filename to be reported in case of parsing errors.
+      Defaults to `"nofile"`.
+
+    * `:line` - the starting line of the string being parsed.
+      Defaults to `1`.
+
+    * `:column` - the starting column of the string being parsed.
+      Defaults to `1`.
+
+    * `:columns` - when `true`, attach a `:column` key to the quoted
+      metadata. Defaults to `false`.
+
+    * `:token_metadata` - when `true`, includes token-related
+      metadata in the expression AST, such as metadata for `do` and `end`
+      tokens, for closing tokens, end of expressions, as well as delimiters
+      for sigils. See `t:Macro.metadata/0`. Defaults to `false`.
+
+    * `:literal_encoder` - a function to encode literals in the AST.
+      See the documentation for `Code.string_to_quoted/2` for more information.
+
+    * `:trailing_fragment` (since v1.18.0) - the rest of the contents after
+      the cursor. This is necessary to correctly complete anonymous functions
+      and the left-hand side of `->`
+
+  """
+  @doc since: "1.13.0"
+  @spec container_cursor_to_quoted(List.Chars.t(), container_cursor_to_quoted_opts()) ::
+          {:ok, Macro.t()} | {:error, {location :: keyword, binary | {binary, binary}, binary}}
+  def container_cursor_to_quoted(fragment, opts \\ []) do
+    {trailing_fragment, opts} = Keyword.pop(opts, :trailing_fragment)
+    opts = Keyword.take(opts, [:columns, :token_metadata, :literal_encoder])
+    opts = [check_terminators: {:cursor, []}, emit_warnings: false] ++ opts
+
+    file = Keyword.get(opts, :file, "nofile")
+    line = Keyword.get(opts, :line, 1)
+    column = Keyword.get(opts, :column, 1)
+
+    case :elixir_tokenizer.tokenize(to_charlist(fragment), line, column, opts) do
+      {:ok, line, column, _warnings, rev_tokens, rev_terminators}
+      when trailing_fragment == nil ->
+        {rev_tokens, rev_terminators} =
+          with [close, open, {_, _, :__cursor__} = cursor | rev_tokens] <- rev_tokens,
+               {_, [_ | after_fn]} <- Enum.split_while(rev_terminators, &(elem(&1, 0) != :fn)),
+               true <- maybe_missing_stab?(rev_tokens, false),
+               [_ | rev_tokens] <- Enum.drop_while(rev_tokens, &(elem(&1, 0) != :fn)) do
+            {[close, open, cursor | rev_tokens], after_fn}
+          else
+            _ -> {rev_tokens, rev_terminators}
+          end
+
+        tokens = reverse_tokens(line, column, rev_tokens, rev_terminators)
+        :elixir.tokens_to_quoted(tokens, file, opts)
+
+      {:ok, line, column, _warnings, rev_tokens, rev_terminators} ->
+        tokens =
+          with {before_start, [_ | _] = after_start} <-
+                 Enum.split_while(rev_terminators, &(elem(&1, 0) not in [:do, :fn])),
+               true <- maybe_missing_stab?(rev_tokens, true),
+               opts =
+                 Keyword.put(opts, :check_terminators, {:cursor, before_start}),
+               {:error, {meta, _, ~c"end"}, _rest, _warnings, trailing_rev_tokens} <-
+                 :elixir_tokenizer.tokenize(to_charlist(trailing_fragment), line, column, opts) do
+            trailing_tokens =
+              reverse_tokens(meta[:line], meta[:column], trailing_rev_tokens, after_start)
+
+            # If the cursor has its own line, then we do not trim new lines trailing tokens.
+            # Otherwise we want to drop any newline so we drop the next tokens after eol.
+            trailing_tokens =
+              case rev_tokens do
+                [_close, _open, {_, _, :__cursor__}, {:eol, _} | _] -> trailing_tokens
+                _ -> Enum.drop_while(trailing_tokens, &match?({:eol, _}, &1))
+              end
+
+            Enum.reverse(rev_tokens, drop_tokens(trailing_tokens, 0))
+          else
+            _ -> reverse_tokens(line, column, rev_tokens, rev_terminators)
+          end
+
+        :elixir.tokens_to_quoted(tokens, file, opts)
+
+      {:error, info, _rest, _warnings, _so_far} ->
+        {:error, :elixir.format_token_error(info)}
+    end
+  end
+
+  defp reverse_tokens(line, column, tokens, terminators) do
+    {terminators, _} =
+      Enum.map_reduce(terminators, column, fn {start, _, _}, column ->
+        atom = :elixir_tokenizer.terminator(start)
+
+        {{atom, {line, column, nil}}, column + length(Atom.to_charlist(atom))}
+      end)
+
+    Enum.reverse(tokens, terminators)
+  end
+
+  # Otherwise we drop all tokens, trying to build a minimal AST
+  # for cursor completion.
+  defp drop_tokens([{:"}", _} | _] = tokens, 0), do: tokens
+  defp drop_tokens([{:"]", _} | _] = tokens, 0), do: tokens
+  defp drop_tokens([{:")", _} | _] = tokens, 0), do: tokens
+  defp drop_tokens([{:">>", _} | _] = tokens, 0), do: tokens
+  defp drop_tokens([{:end, _} | _] = tokens, 0), do: tokens
+  defp drop_tokens([{:",", _} | _] = tokens, 0), do: tokens
+  defp drop_tokens([{:";", _} | _] = tokens, 0), do: tokens
+  defp drop_tokens([{:eol, _} | _] = tokens, 0), do: tokens
+  defp drop_tokens([{:stab_op, _, :->} | _] = tokens, 0), do: tokens
+
+  defp drop_tokens([{:"}", _} | tokens], counter), do: drop_tokens(tokens, counter - 1)
+  defp drop_tokens([{:"]", _} | tokens], counter), do: drop_tokens(tokens, counter - 1)
+  defp drop_tokens([{:")", _} | tokens], counter), do: drop_tokens(tokens, counter - 1)
+  defp drop_tokens([{:">>", _} | tokens], counter), do: drop_tokens(tokens, counter - 1)
+  defp drop_tokens([{:end, _} | tokens], counter), do: drop_tokens(tokens, counter - 1)
+
+  defp drop_tokens([{:"{", _} | tokens], counter), do: drop_tokens(tokens, counter + 1)
+  defp drop_tokens([{:"[", _} | tokens], counter), do: drop_tokens(tokens, counter + 1)
+  defp drop_tokens([{:"(", _} | tokens], counter), do: drop_tokens(tokens, counter + 1)
+  defp drop_tokens([{:"<<", _} | tokens], counter), do: drop_tokens(tokens, counter + 1)
+  defp drop_tokens([{:fn, _} | tokens], counter), do: drop_tokens(tokens, counter + 1)
+  defp drop_tokens([{:do, _} | tokens], counter), do: drop_tokens(tokens, counter + 1)
+
+  defp drop_tokens([_ | tokens], counter), do: drop_tokens(tokens, counter)
+  defp drop_tokens([], _counter), do: []
+
+  defp maybe_missing_stab?([{:after, _} | _], _stab_choice?), do: true
+  defp maybe_missing_stab?([{:do, _} | _], _stab_choice?), do: true
+  defp maybe_missing_stab?([{:fn, _} | _], _stab_choice?), do: true
+  defp maybe_missing_stab?([{:else, _} | _], _stab_choice?), do: true
+  defp maybe_missing_stab?([{:catch, _} | _], _stab_choice?), do: true
+  defp maybe_missing_stab?([{:rescue, _} | _], _stab_choice?), do: true
+  defp maybe_missing_stab?([{:stab_op, _, :->} | _], stab_choice?), do: stab_choice?
+  defp maybe_missing_stab?([_ | tail], stab_choice?), do: maybe_missing_stab?(tail, stab_choice?)
+  defp maybe_missing_stab?([], _stab_choice?), do: false
+end
diff --git a/lib/elixir/lib/code/identifier.ex b/lib/elixir/lib/code/identifier.ex
new file mode 100644
index 00000000000..b3adeb5692f
--- /dev/null
+++ b/lib/elixir/lib/code/identifier.ex
@@ -0,0 +1,188 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Code.Identifier do
+  @moduledoc false
+
+  @doc """
+  Checks if the given identifier is an unary op.
+
+  ## Examples
+
+      iex> Code.Identifier.unary_op(:+)
+      {:non_associative, 300}
+
+  """
+  @spec unary_op(atom) :: {:non_associative, precedence :: pos_integer} | :error
+  def unary_op(op) do
+    cond do
+      op in [:&, :...] -> {:non_associative, 90}
+      op in [:!, :^, :not, :+, :-, :"~~~"] -> {:non_associative, 300}
+      op in [:@] -> {:non_associative, 320}
+      true -> :error
+    end
+  end
+
+  @doc """
+  Checks if the given identifier is a binary op.
+
+  ## Examples
+
+      iex> Code.Identifier.binary_op(:+)
+      {:left, 210}
+
+  """
+  @spec binary_op(atom) :: {:left | :right, precedence :: pos_integer} | :error
+  def binary_op(op) do
+    cond do
+      op in [:<-, :\\] -> {:left, 40}
+      op in [:when] -> {:right, 50}
+      op in [:"::"] -> {:right, 60}
+      op in [:|] -> {:right, 70}
+      op in [:=] -> {:right, 100}
+      op in [:||, :|||, :or] -> {:left, 120}
+      op in [:&&, :&&&, :and] -> {:left, 130}
+      op in [:==, :!=, :=~, :===, :!==] -> {:left, 140}
+      op in [:<, :<=, :>=, :>] -> {:left, 150}
+      op in [:|>, :<<<, :>>>, :<~, :~>, :<<~, :~>>, :<~>, :"<|>"] -> {:left, 160}
+      op in [:in] -> {:left, 170}
+      op in [:"^^^"] -> {:left, 180}
+      op in [:++, :--, :.., :<>, :+++, :---] -> {:right, 200}
+      op in [:+, :-] -> {:left, 210}
+      op in [:*, :/] -> {:left, 220}
+      op in [:**] -> {:left, 230}
+      op in [:.] -> {:left, 310}
+      true -> :error
+    end
+  end
+
+  @doc """
+  Extracts the name and arity of the parent from the anonymous function identifier.
+  """
+  # Example of this format: -NAME/ARITY-fun-COUNT-
+  def extract_anonymous_fun_parent(atom) when is_atom(atom) do
+    with "-" <> rest <- Atom.to_string(atom),
+         [trailing | reversed] = rest |> String.split("/") |> Enum.reverse(),
+         [arity, _inner, _count, ""] <- String.split(trailing, "-") do
+      {reversed |> Enum.reverse() |> Enum.join("/") |> String.to_atom(), arity}
+    else
+      _ -> :error
+    end
+  end
+
+  @doc """
+  Escapes the given identifier.
+  """
+  @spec escape(binary(), char() | nil, :infinity | non_neg_integer, (char() -> iolist() | false)) ::
+          {escaped :: binary(), remaining :: binary()}
+  def escape(binary, char, limit \\ :infinity, fun \\ &escape_map/1)
+      when (is_binary(binary) and ((char in 0..0x10FFFF or is_nil(char)) and limit == :infinity)) or
+             (is_integer(limit) and limit >= 0) do
+    escape(binary, char, limit, <<>>, fun)
+  end
+
+  defp escape(<<_, _::binary>> = binary, _char, 0, acc, _fun) do
+    {acc, binary}
+  end
+
+  defp escape(<<char, t::binary>>, char, count, acc, fun) do
+    escape(t, char, decrement(count), <<acc::binary, ?\\, char>>, fun)
+  end
+
+  defp escape(<<?#, ?{, t::binary>>, char, count, acc, fun) do
+    escape(t, char, decrement(count), <<acc::binary, ?\\, ?#, ?{>>, fun)
+  end
+
+  defp escape(<<h::utf8, t::binary>>, char, count, acc, fun) do
+    if value = fun.(h) do
+      value = IO.iodata_to_binary(value)
+      escape(t, char, decrement(count), <<acc::binary, value::binary>>, fun)
+    else
+      escape(t, char, decrement(count), escape_char(h, acc), fun)
+    end
+  end
+
+  defp escape(<<a::4, b::4, t::binary>>, char, count, acc, fun) do
+    escape(t, char, decrement(count), <<acc::binary, ?\\, ?x, to_hex(a), to_hex(b)>>, fun)
+  end
+
+  defp escape(<<>>, _char, _count, acc, _fun) do
+    {acc, <<>>}
+  end
+
+  defp escape_char(0, acc), do: <<acc::binary, ?\\, ?0>>
+
+  defp escape_char(char, acc)
+       # Some characters that are confusing (zero-width / alternative spaces) are displayed
+       # using their unicode representation:
+       # https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Special-purpose_characters
+
+       # BOM
+       when char == 0xFEFF
+       # Mathematical invisibles
+       when char in 0x2061..0x2064
+       # Bidirectional neutral
+       when char in [0x061C, 0x200E, 0x200F]
+       # Bidirectional general (source of vulnerabilities)
+       when char in 0x202A..0x202E
+       when char in 0x2066..0x2069
+       # Interlinear annotations
+       when char in 0xFFF9..0xFFFC
+       # Zero-width joiners and non-joiners
+       when char in [0x200C, 0x200D, 0x034F]
+       # Non-break space / zero-width space
+       when char in [0x00A0, 0x200B, 0x2060]
+       # Line/paragraph separators
+       when char in [0x2028, 0x2029]
+       # Spaces
+       when char in 0x2000..0x200A
+       when char == 0x205F do
+    <<a::4, b::4, c::4, d::4>> = <<char::16>>
+    <<acc::binary, ?\\, ?u, to_hex(a), to_hex(b), to_hex(c), to_hex(d)>>
+  end
+
+  defp escape_char(char, acc)
+       when char in 0x20..0x7E
+       when char in 0xA0..0xD7FF
+       when char in 0xE000..0xFFFD
+       when char in 0x10000..0x10FFFF do
+    <<acc::binary, char::utf8>>
+  end
+
+  defp escape_char(char, acc) when char < 0x100 do
+    <<a::4, b::4>> = <<char::8>>
+    <<acc::binary, ?\\, ?x, to_hex(a), to_hex(b)>>
+  end
+
+  defp escape_char(char, acc) when char < 0x10000 do
+    <<a::4, b::4, c::4, d::4>> = <<char::16>>
+    <<acc::binary, ?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c), to_hex(d), ?}>>
+  end
+
+  defp escape_char(char, acc) when char < 0x1000000 do
+    <<a::4, b::4, c::4, d::4, e::4, f::4>> = <<char::24>>
+
+    <<acc::binary, ?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c), to_hex(d), to_hex(e), to_hex(f),
+      ?}>>
+  end
+
+  defp escape_map(?\a), do: "\\a"
+  defp escape_map(?\b), do: "\\b"
+  defp escape_map(?\d), do: "\\d"
+  defp escape_map(?\e), do: "\\e"
+  defp escape_map(?\f), do: "\\f"
+  defp escape_map(?\n), do: "\\n"
+  defp escape_map(?\r), do: "\\r"
+  defp escape_map(?\t), do: "\\t"
+  defp escape_map(?\v), do: "\\v"
+  defp escape_map(?\\), do: "\\\\"
+  defp escape_map(_), do: false
+
+  @compile {:inline, to_hex: 1, decrement: 1}
+  defp to_hex(c) when c in 0..9, do: ?0 + c
+  defp to_hex(c) when c in 10..15, do: ?A + c - 10
+
+  defp decrement(:infinity), do: :infinity
+  defp decrement(counter), do: counter - 1
+end
diff --git a/lib/elixir/lib/code/normalizer.ex b/lib/elixir/lib/code/normalizer.ex
new file mode 100644
index 00000000000..a4aa9492ec1
--- /dev/null
+++ b/lib/elixir/lib/code/normalizer.ex
@@ -0,0 +1,612 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Code.Normalizer do
+  @moduledoc false
+
+  defguard is_literal(x)
+           when is_integer(x) or
+                  is_float(x) or
+                  is_binary(x) or
+                  is_atom(x)
+
+  @doc """
+  Wraps literals in the quoted expression to conform to the AST format expected
+  by the formatter.
+  """
+  @spec normalize(Macro.t(), keyword()) :: Macro.t()
+  def normalize(quoted, opts \\ []) do
+    line = Keyword.get(opts, :line, nil)
+    escape = Keyword.get(opts, :escape, true)
+    locals_without_parens = Keyword.get(opts, :locals_without_parens, [])
+
+    state = %{
+      escape: escape,
+      parent_meta: [line: line],
+      locals_without_parens: locals_without_parens ++ Code.Formatter.locals_without_parens()
+    }
+
+    do_normalize(quoted, state)
+  end
+
+  # Wrapped literals should receive the block meta
+  defp do_normalize({:__block__, meta, [literal]}, state)
+       when not is_tuple(literal) or tuple_size(literal) == 2 do
+    normalize_literal(literal, meta, state)
+  end
+
+  # Only normalize the first argument of an alias if it's not an atom
+  defp do_normalize({:__aliases__, meta, [first | rest]}, state) when not is_atom(first) do
+    meta = patch_meta_line(meta, state.parent_meta)
+    first = do_normalize(first, %{state | parent_meta: meta})
+    {:__aliases__, meta, [first | rest]}
+  end
+
+  defp do_normalize({:__aliases__, _, _} = quoted, _state) do
+    quoted
+  end
+
+  # Skip captured arguments like &1
+  defp do_normalize({:&, meta, [term]}, state) when is_integer(term) do
+    meta = patch_meta_line(meta, state.parent_meta)
+    {:&, meta, [term]}
+  end
+
+  # Ranges
+  defp do_normalize(left..right//step, state) do
+    left = do_normalize(left, state)
+    right = do_normalize(right, state)
+    meta = meta_line(state)
+
+    if step == 1 do
+      {:.., meta, [left, right]}
+    else
+      step = do_normalize(step, state)
+      {:..//, meta, [left, right, step]}
+    end
+  end
+
+  # Bit containers
+  defp do_normalize({:<<>>, _, args} = quoted, state) when is_list(args) do
+    normalize_bitstring(quoted, state)
+  end
+
+  # Atoms with interpolations
+  defp do_normalize(
+         {{:., dot_meta, [:erlang, :binary_to_atom]}, call_meta,
+          [{:<<>>, _, parts} = string, :utf8]},
+         state
+       )
+       when is_list(parts) do
+    dot_meta = patch_meta_line(dot_meta, state.parent_meta)
+    call_meta = patch_meta_line(call_meta, dot_meta)
+
+    utf8 =
+      if parts == [] or binary_interpolated?(parts) do
+        # a non-normalized :utf8 atom signals an atom interpolation
+        :utf8
+      else
+        normalize_literal(:utf8, [], state)
+      end
+
+    string =
+      if state.escape do
+        normalize_bitstring(string, state, true)
+      else
+        normalize_bitstring(string, state)
+      end
+
+    {{:., dot_meta, [:erlang, :binary_to_atom]}, call_meta, [string, utf8]}
+  end
+
+  # Charlists with interpolations
+  # TODO: Remove this clause on Elixir v2.0 once single-quoted charlists are removed
+  defp do_normalize({{:., dot_meta, [List, :to_charlist]}, call_meta, [parts]} = quoted, state) do
+    if list_interpolated?(parts) do
+      parts =
+        Enum.map(parts, fn
+          {{:., part_dot_meta, [Kernel, :to_string]}, part_call_meta, args} ->
+            args = normalize_args(args, state)
+
+            {{:., part_dot_meta, [Kernel, :to_string]}, part_call_meta, args}
+
+          part when is_binary(part) ->
+            if state.escape do
+              maybe_escape_literal(part, state)
+            else
+              part
+            end
+        end)
+
+      {{:., dot_meta, [List, :to_charlist]}, call_meta, [parts]}
+    else
+      normalize_call(quoted, state)
+    end
+  end
+
+  # Don't normalize the `Access` atom in access syntax
+  defp do_normalize({:., meta, [Access, :get]}, state) do
+    meta = patch_meta_line(meta, state.parent_meta)
+    {:., meta, [Access, :get]}
+  end
+
+  # The right hand side is an atom in the AST but it's not an atom literal, so
+  # it should not be wrapped. However, it should be escaped if applicable.
+  defp do_normalize({:., meta, [left, right]}, state) when is_atom(right) do
+    meta = patch_meta_line(meta, state.parent_meta)
+
+    left = do_normalize(left, %{state | parent_meta: meta})
+    right = maybe_escape_literal(right, state)
+
+    {:., meta, [left, right]}
+  end
+
+  # left -> right
+  defp do_normalize({:->, meta, [left, right]}, state) do
+    meta = patch_meta_line(meta, state.parent_meta)
+
+    left = normalize_args(left, %{state | parent_meta: meta})
+    right = do_normalize(right, %{state | parent_meta: meta})
+    {:->, meta, [left, right]}
+  end
+
+  # Maps
+  defp do_normalize({:%{}, meta, args}, state) when is_list(args) do
+    meta =
+      if meta == [] do
+        line = state.parent_meta[:line]
+        [line: line, closing: [line: line]]
+      else
+        meta
+      end
+
+    state = %{state | parent_meta: meta}
+
+    args =
+      case args do
+        [{:|, pipe_meta, [left, right]}] ->
+          left = do_normalize(left, state)
+          right = normalize_map_args(right, state)
+          [{:|, pipe_meta, [left, right]}]
+
+        args ->
+          normalize_map_args(args, state)
+      end
+
+    {:%{}, meta, args}
+  end
+
+  # Sigils
+  defp do_normalize({sigil, meta, [{:<<>>, _, args} = string, modifiers]} = quoted, state)
+       when is_atom(sigil) and is_list(args) and is_list(modifiers) do
+    with "sigil_" <> _ <- Atom.to_string(sigil),
+         true <- binary_interpolated?(args),
+         true <- List.ascii_printable?(modifiers) do
+      meta =
+        meta
+        |> patch_meta_line(state.parent_meta)
+        |> Keyword.put_new(:delimiter, "\"")
+
+      {sigil, meta, [do_normalize(string, %{state | parent_meta: meta}), modifiers]}
+    else
+      _ ->
+        normalize_call(quoted, state)
+    end
+  end
+
+  # Tuples
+  defp do_normalize({:{}, meta, args} = quoted, state) when is_list(args) do
+    {last_arg, args} = List.pop_at(args, -1)
+
+    if args != [] and match?([_ | _], last_arg) and keyword?(last_arg) do
+      args = normalize_args(args, state)
+      kw_list = normalize_kw_args(last_arg, state, true)
+      {:{}, meta, args ++ kw_list}
+    else
+      normalize_call(quoted, state)
+    end
+  end
+
+  # Module attributes
+  defp do_normalize({:@, meta, [{name, name_meta, [value]}]}, state) do
+    value =
+      cond do
+        keyword?(value) and value != [] ->
+          normalize_kw_args(value, state, true)
+
+        is_list(value) ->
+          normalize_literal(value, meta, state)
+
+        true ->
+          do_normalize(value, state)
+      end
+
+    {:@, meta, [{name, name_meta, [value]}]}
+  end
+
+  # Regular blocks
+  defp do_normalize({:__block__, meta, args}, state) when is_list(args) do
+    {:__block__, meta, normalize_args(args, state)}
+  end
+
+  # Calls
+  defp do_normalize({_, _, args} = quoted, state) when is_list(args) do
+    normalize_call(quoted, state)
+  end
+
+  # Vars
+  defp do_normalize({_, _, context} = quoted, _state) when is_atom(context) do
+    quoted
+  end
+
+  # Literals
+  defp do_normalize(quoted, state) do
+    normalize_literal(quoted, [], state)
+  end
+
+  # Numbers
+  defp normalize_literal(number, meta, state) when is_number(number) do
+    meta =
+      meta
+      |> Keyword.put_new(:token, inspect(number))
+      |> patch_meta_line(state.parent_meta)
+
+    {:__block__, meta, [number]}
+  end
+
+  # Atom, Strings
+  defp normalize_literal(literal, meta, state) when is_atom(literal) or is_binary(literal) do
+    meta = patch_meta_line(meta, state.parent_meta)
+    literal = maybe_escape_literal(literal, state)
+
+    if is_atom(literal) and Macro.classify_atom(literal) == :alias and
+         is_nil(meta[:delimiter]) do
+      segments =
+        case Atom.to_string(literal) do
+          "Elixir" ->
+            [:"Elixir"]
+
+          "Elixir." <> segments ->
+            segments
+            |> String.split(".")
+            |> Enum.map(&String.to_atom/1)
+        end
+
+      {:__aliases__, meta, segments}
+    else
+      {:__block__, meta, [literal]}
+    end
+  end
+
+  # 2-tuples
+  defp normalize_literal({left, right}, meta, state) do
+    meta = patch_meta_line(meta, state.parent_meta)
+    state = %{state | parent_meta: meta}
+
+    if match?([_ | _], right) and keyword?(right) do
+      {:__block__, meta, [{do_normalize(left, state), normalize_kw_args(right, state, true)}]}
+    else
+      {:__block__, meta, [{do_normalize(left, state), do_normalize(right, state)}]}
+    end
+  end
+
+  # Lists
+  defp normalize_literal(list, meta, state) when is_list(list) do
+    if list != [] and List.ascii_printable?(list) do
+      # It's a charlist, we normalize it as a ~C sigil
+      string =
+        if state.escape do
+          {iolist, _} = Code.Identifier.escape(IO.chardata_to_string(list), nil)
+          IO.iodata_to_binary(iolist)
+        else
+          List.to_string(list)
+        end
+
+      meta = patch_meta_line([delimiter: "\""], state.parent_meta)
+
+      {:sigil_c, meta, [{:<<>>, [], [string]}, []]}
+    else
+      meta =
+        if line = state.parent_meta[:line] do
+          meta
+          |> Keyword.put_new(:closing, line: line)
+          |> patch_meta_line(state.parent_meta)
+        else
+          meta
+        end
+
+      {:__block__, meta, [normalize_kw_args(list, state, false)]}
+    end
+  end
+
+  # Probably an invalid value, wrap it and send it upstream
+  defp normalize_literal(quoted, meta, _state) do
+    {:__block__, meta, [quoted]}
+  end
+
+  defp normalize_call({form, meta, args}, state) do
+    meta = patch_meta_line(meta, state.parent_meta)
+    arity = length(args)
+
+    # Only normalize the form if it's a qualified call
+    form =
+      if is_atom(form) do
+        form
+      else
+        do_normalize(form, %{state | parent_meta: meta})
+      end
+
+    meta =
+      if is_nil(meta[:no_parens]) and is_nil(meta[:closing]) and is_nil(meta[:do]) and
+           not Code.Formatter.local_without_parens?(form, arity, state.locals_without_parens) do
+        [closing: [line: meta[:line]]] ++ meta
+      else
+        meta
+      end
+
+    last = List.last(args)
+
+    cond do
+      not allow_keyword?(form, arity) ->
+        args = normalize_args(args, %{state | parent_meta: meta})
+        {form, meta, args}
+
+      Keyword.has_key?(meta, :do) ->
+        # def foo do :ok end
+        # def foo, do: :ok
+        normalize_kw_blocks(form, meta, args, state)
+
+      match?([{:do, _} | _], last) and Keyword.keyword?(last) ->
+        # Non normalized kw blocks
+        line = state.parent_meta[:line] || meta[:line]
+        meta = meta ++ [do: [line: line], end: [line: line]]
+        normalize_kw_blocks(form, meta, args, state)
+
+      true ->
+        args = normalize_args(args, %{state | parent_meta: meta})
+        {last_arg, leading_args} = List.pop_at(args, -1, [])
+
+        last_args =
+          case last_arg do
+            {:__block__, _meta, [[{{:__block__, key_meta, _}, _} | _] = keyword]} ->
+              cond do
+                key_meta[:format] == :keyword ->
+                  [keyword]
+
+                block_keyword?(keyword) ->
+                  [
+                    Enum.map(keyword, fn {{:__block__, meta, args}, value} ->
+                      {{:__block__, [format: :keyword] ++ meta, args}, value}
+                    end)
+                  ]
+
+                true ->
+                  [last_arg]
+              end
+
+            [] ->
+              []
+
+            _ ->
+              [last_arg]
+          end
+
+        {form, meta, leading_args ++ last_args}
+    end
+  end
+
+  defp block_keyword?([{{:__block__, _, [key]}, _val} | tail]) when is_atom(key),
+    do: block_keyword?(tail)
+
+  defp block_keyword?([]), do: true
+  defp block_keyword?(_), do: false
+
+  defp allow_keyword?(:when, 2), do: true
+  defp allow_keyword?(:{}, _), do: false
+  defp allow_keyword?(op, arity), do: not is_atom(op) or not Macro.operator?(op, arity)
+
+  defp normalize_bitstring({:<<>>, meta, parts}, state, escape_interpolation \\ false) do
+    meta = patch_meta_line(meta, state.parent_meta)
+
+    parts =
+      if binary_interpolated?(parts) do
+        normalize_interpolation_parts(parts, %{state | parent_meta: meta}, escape_interpolation)
+      else
+        state = %{state | parent_meta: meta}
+
+        Enum.map(parts, fn part ->
+          with {:"::", meta, [left, _]} <- part,
+               true <- meta[:inferred_bitstring_spec] do
+            do_normalize(left, state)
+          else
+            _ -> do_normalize(part, state)
+          end
+        end)
+      end
+
+    {:<<>>, meta, parts}
+  end
+
+  defp normalize_interpolation_parts(parts, state, escape_interpolation) do
+    Enum.map(parts, fn
+      {:"::", interpolation_meta,
+       [
+         {{:., dot_meta, [Kernel, :to_string]}, middle_meta, [middle]},
+         {:binary, binary_meta, context}
+       ]} ->
+        middle = do_normalize(middle, %{state | parent_meta: dot_meta})
+
+        {:"::", interpolation_meta,
+         [
+           {{:., dot_meta, [Kernel, :to_string]}, middle_meta, [middle]},
+           {:binary, binary_meta, context}
+         ]}
+
+      part ->
+        if escape_interpolation do
+          maybe_escape_literal(part, state)
+        else
+          part
+        end
+    end)
+  end
+
+  defp normalize_map_args(args, state) do
+    Enum.map(normalize_kw_args(args, state, false), fn
+      {:__block__, _, [{_, _} = pair]} -> pair
+      pair -> pair
+    end)
+  end
+
+  defp normalize_kw_blocks(form, meta, args, state) do
+    {kw_blocks, leading_args} = List.pop_at(args, -1)
+
+    kw_blocks =
+      Enum.map(kw_blocks, fn {tag, block} ->
+        block = do_normalize(block, %{state | parent_meta: meta})
+
+        block =
+          case block do
+            {_, _, [[{:->, _, _} | _] = block]} -> block
+            block -> block
+          end
+
+        # Only wrap the tag if it isn't already wrapped
+        tag =
+          case tag do
+            {:__block__, _, _} -> tag
+            _ -> {:__block__, [line: meta[:line]], [tag]}
+          end
+
+        {tag, block}
+      end)
+
+    leading_args = normalize_args(leading_args, %{state | parent_meta: meta})
+    {form, meta, leading_args ++ [kw_blocks]}
+  end
+
+  defp normalize_kw_args(elems, state, keyword?)
+
+  defp normalize_kw_args(
+         [{{:__block__, key_meta, [key]}, value} = first | rest] = current,
+         state,
+         keyword?
+       )
+       when is_atom(key) do
+    keyword? = keyword? or keyword?(current)
+
+    first =
+      if key_meta[:format] == :keyword and not keyword? do
+        key_meta = Keyword.delete(key_meta, :format)
+        line = key_meta[:line] || meta_line(state)
+        {:__block__, [line: line], [{{:__block__, key_meta, [key]}, value}]}
+      else
+        first
+      end
+
+    [first | normalize_kw_args(rest, state, keyword?)]
+  end
+
+  defp normalize_kw_args([{left, right} | rest] = current, state, keyword?) do
+    keyword? = keyword? or keyword?(current)
+
+    left =
+      if keyword? do
+        meta = [format: :keyword] ++ meta_line(state)
+        {:__block__, meta, [maybe_escape_literal(left, state)]}
+      else
+        do_normalize(left, state)
+      end
+
+    right = do_normalize(right, state)
+
+    pair =
+      with {:__block__, meta, _} <- left,
+           :keyword <- meta[:format] do
+        {left, right}
+      else
+        _ -> {:__block__, meta_line(state), [{left, right}]}
+      end
+
+    [pair | normalize_kw_args(rest, state, keyword?)]
+  end
+
+  defp normalize_kw_args([first | rest], state, keyword?) do
+    [do_normalize(first, state) | normalize_kw_args(rest, state, keyword?)]
+  end
+
+  defp normalize_kw_args([], _state, _keyword?) do
+    []
+  end
+
+  defp normalize_args(args, state) do
+    Enum.map(args, &do_normalize(&1, state))
+  end
+
+  defp maybe_escape_literal(string, %{escape: true}) when is_binary(string) do
+    {string, _} = Code.Identifier.escape(string, nil)
+    IO.iodata_to_binary(string)
+  end
+
+  defp maybe_escape_literal(atom, %{escape: true} = state) when is_atom(atom) do
+    atom
+    |> Atom.to_string()
+    |> maybe_escape_literal(state)
+    |> String.to_atom()
+  end
+
+  defp maybe_escape_literal(term, _) do
+    term
+  end
+
+  defp binary_interpolated?(parts) do
+    Enum.all?(parts, fn
+      {:"::", _, [{{:., _, [Kernel, :to_string]}, _, [_]}, {:binary, _, _}]} -> true
+      binary when is_binary(binary) -> true
+      _ -> false
+    end)
+  end
+
+  defp list_interpolated?(parts) do
+    Enum.all?(parts, fn
+      {{:., _, [Kernel, :to_string]}, _, [_]} -> true
+      binary when is_binary(binary) -> true
+      _ -> false
+    end)
+  end
+
+  defp patch_meta_line(meta, parent_meta) do
+    with nil <- meta[:line],
+         line when is_integer(line) <- parent_meta[:line] do
+      [line: line] ++ meta
+    else
+      _ -> meta
+    end
+  end
+
+  defp meta_line(state) do
+    if line = state.parent_meta[:line] do
+      [line: line]
+    else
+      []
+    end
+  end
+
+  defp keyword?([{{:__block__, key_meta, [key]}, _} | rest]) when is_atom(key) do
+    if key_meta[:format] == :keyword do
+      keyword?(rest)
+    else
+      false
+    end
+  end
+
+  defp keyword?([{key, _value} | rest]) when is_atom(key) do
+    case Atom.to_charlist(key) do
+      ~c"Elixir." ++ _ -> false
+      _ -> keyword?(rest)
+    end
+  end
+
+  defp keyword?([]), do: true
+  defp keyword?(_other), do: false
+end
diff --git a/lib/elixir/lib/code/typespec.ex b/lib/elixir/lib/code/typespec.ex
new file mode 100644
index 00000000000..f04cac439f7
--- /dev/null
+++ b/lib/elixir/lib/code/typespec.ex
@@ -0,0 +1,430 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Code.Typespec do
+  @moduledoc false
+
+  @doc """
+  Converts a spec clause back to Elixir quoted expression.
+  """
+  @spec spec_to_quoted(atom, tuple) :: {atom, keyword, [Macro.t()]}
+  def spec_to_quoted(name, spec)
+
+  def spec_to_quoted(name, {:type, anno, :fun, [{:type, _, :product, args}, result]})
+      when is_atom(name) do
+    meta = meta(anno)
+    body = {name, meta, Enum.map(args, &typespec_to_quoted/1)}
+
+    vars =
+      for type_expr <- args ++ [result],
+          var <- collect_vars(type_expr),
+          uniq: true,
+          do: {var, {:var, meta, nil}}
+
+    spec = {:"::", meta, [body, typespec_to_quoted(result)]}
+
+    if vars == [] do
+      spec
+    else
+      {:when, meta, [spec, vars]}
+    end
+  end
+
+  def spec_to_quoted(name, {:type, anno, :bounded_fun, [type, constrs]}) when is_atom(name) do
+    meta = meta(anno)
+    {:type, _, :fun, [{:type, _, :product, args}, result]} = type
+
+    guards =
+      for {:type, _, :constraint, [{:atom, _, :is_subtype}, [{:var, _, var}, type]]} <- constrs do
+        {erl_to_ex_var(var), typespec_to_quoted(type)}
+      end
+
+    ignore_vars = Keyword.keys(guards)
+
+    vars =
+      for type_expr <- args ++ [result],
+          var <- collect_vars(type_expr),
+          var not in ignore_vars,
+          uniq: true,
+          do: {var, {:var, meta, nil}}
+
+    args = for arg <- args, do: typespec_to_quoted(arg)
+
+    when_args = [
+      {:"::", meta, [{name, meta, args}, typespec_to_quoted(result)]},
+      guards ++ vars
+    ]
+
+    {:when, meta, when_args}
+  end
+
+  @doc """
+  Converts a type clause back to Elixir AST.
+  """
+  def type_to_quoted(type)
+
+  def type_to_quoted({{:record, record}, fields, args}) when is_atom(record) do
+    fields = for field <- fields, do: typespec_to_quoted(field)
+    args = for arg <- args, do: typespec_to_quoted(arg)
+    type = {:{}, [], [record | fields]}
+    quote(do: unquote(record)(unquote_splicing(args)) :: unquote(type))
+  end
+
+  def type_to_quoted({name, type, args}) when is_atom(name) do
+    args = for arg <- args, do: typespec_to_quoted(arg)
+    quote(do: unquote(name)(unquote_splicing(args)) :: unquote(typespec_to_quoted(type)))
+  end
+
+  @doc """
+  Returns all types available from the module's BEAM code.
+
+  The result is returned as a list of tuples where the first
+  element is the type (`:typep`, `:type` and `:opaque`).
+
+  The module must have a corresponding BEAM file which can be
+  located by the runtime system. The types will be in the Erlang
+  Abstract Format.
+  """
+  @spec fetch_types(module | binary) :: {:ok, [tuple]} | :error
+  def fetch_types(module) when is_atom(module) or is_binary(module) do
+    case typespecs_abstract_code(module) do
+      {:ok, abstract_code} ->
+        exported_types = for {:attribute, _, :export_type, types} <- abstract_code, do: types
+        exported_types = List.flatten(exported_types)
+
+        types =
+          for {:attribute, _, kind, {name, _, args} = type} <- abstract_code,
+              kind in [:opaque, :type] do
+            cond do
+              kind == :opaque -> {:opaque, type}
+              {name, length(args)} in exported_types -> {:type, type}
+              true -> {:typep, type}
+            end
+          end
+
+        {:ok, types}
+
+      _ ->
+        :error
+    end
+  end
+
+  @doc """
+  Returns all specs available from the module's BEAM code.
+
+  The result is returned as a list of tuples where the first
+  element is spec name and arity and the second is the spec.
+
+  The module must have a corresponding BEAM file which can be
+  located by the runtime system. The types will be in the Erlang
+  Abstract Format.
+  """
+  @spec fetch_specs(module | binary) :: {:ok, [tuple]} | :error
+  def fetch_specs(module) when is_atom(module) or is_binary(module) do
+    case typespecs_abstract_code(module) do
+      {:ok, abstract_code} ->
+        {:ok, for({:attribute, _, :spec, value} <- abstract_code, do: value)}
+
+      :error ->
+        :error
+    end
+  end
+
+  @doc """
+  Returns all callbacks available from the module's BEAM code.
+
+  The result is returned as a list of tuples where the first
+  element is spec name and arity and the second is the spec.
+
+  The module must have a corresponding BEAM file
+  which can be located by the runtime system. The types will be
+  in the Erlang Abstract Format.
+  """
+  @spec fetch_callbacks(module | binary) :: {:ok, [tuple]} | :error
+  def fetch_callbacks(module) when is_atom(module) or is_binary(module) do
+    case typespecs_abstract_code(module) do
+      {:ok, abstract_code} ->
+        {:ok, for({:attribute, _, :callback, value} <- abstract_code, do: value)}
+
+      :error ->
+        :error
+    end
+  end
+
+  defp typespecs_abstract_code(module) do
+    with {module, binary} <- get_module_and_beam(module),
+         {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} <-
+           :beam_lib.chunks(binary, [:debug_info]) do
+      case data do
+        {:elixir_v1, %{}, specs} ->
+          # Fast path to avoid translation to Erlang from Elixir.
+          {:ok, specs}
+
+        _ ->
+          case backend.debug_info(:erlang_v1, module, data, []) do
+            {:ok, abstract_code} -> {:ok, abstract_code}
+            _ -> :error
+          end
+      end
+    else
+      _ -> :error
+    end
+  end
+
+  defp get_module_and_beam(module) when is_atom(module) do
+    with {^module, beam, _filename} <- :code.get_object_code(module),
+         info_pairs when is_list(info_pairs) <- :beam_lib.info(beam),
+         {:ok, ^module} <- Keyword.fetch(info_pairs, :module) do
+      {module, beam}
+    else
+      _ -> :error
+    end
+  end
+
+  defp get_module_and_beam(beam) when is_binary(beam) do
+    case :beam_lib.info(beam) do
+      [_ | _] = info -> {info[:module], beam}
+      _ -> :error
+    end
+  end
+
+  ## To AST conversion
+
+  defp collect_vars({:ann_type, _anno, args}) when is_list(args) do
+    []
+  end
+
+  defp collect_vars({:type, _anno, _kind, args}) when is_list(args) do
+    Enum.flat_map(args, &collect_vars/1)
+  end
+
+  defp collect_vars({:remote_type, _anno, args}) when is_list(args) do
+    Enum.flat_map(args, &collect_vars/1)
+  end
+
+  defp collect_vars({:typed_record_field, _anno, type}) do
+    collect_vars(type)
+  end
+
+  defp collect_vars({:paren_type, _anno, [type]}) do
+    collect_vars(type)
+  end
+
+  defp collect_vars({:var, _anno, var}) do
+    [erl_to_ex_var(var)]
+  end
+
+  defp collect_vars(_) do
+    []
+  end
+
+  defp typespec_to_quoted({:user_type, anno, name, args}) do
+    args = for arg <- args, do: typespec_to_quoted(arg)
+    {name, meta(anno), args}
+  end
+
+  defp typespec_to_quoted({:type, anno, :tuple, :any}) do
+    {:tuple, meta(anno), []}
+  end
+
+  defp typespec_to_quoted({:type, anno, :tuple, args}) do
+    args = for arg <- args, do: typespec_to_quoted(arg)
+    {:{}, meta(anno), args}
+  end
+
+  defp typespec_to_quoted({:type, _anno, :list, [{:type, _, :union, unions} = arg]}) do
+    case unpack_typespec_kw(unions, []) do
+      {:ok, ast} -> ast
+      :error -> [typespec_to_quoted(arg)]
+    end
+  end
+
+  defp typespec_to_quoted({:type, anno, :list, []}) do
+    {:list, meta(anno), []}
+  end
+
+  defp typespec_to_quoted({:type, _anno, :list, [arg]}) do
+    [typespec_to_quoted(arg)]
+  end
+
+  defp typespec_to_quoted({:type, anno, :nonempty_list, []}) do
+    [{:..., meta(anno), nil}]
+  end
+
+  defp typespec_to_quoted({:type, anno, :nonempty_list, [arg]}) do
+    [typespec_to_quoted(arg), {:..., meta(anno), nil}]
+  end
+
+  defp typespec_to_quoted({:type, anno, :map, :any}) do
+    {:map, meta(anno), []}
+  end
+
+  defp typespec_to_quoted({:type, anno, :map, fields}) do
+    fields =
+      Enum.map(fields, fn
+        {:type, _, :map_field_assoc, :any} ->
+          {{:optional, [], [{:any, [], []}]}, {:any, [], []}}
+
+        {:type, _, :map_field_exact, [{:atom, _, k}, v]} ->
+          {k, typespec_to_quoted(v)}
+
+        {:type, _, :map_field_exact, [k, v]} ->
+          {{:required, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)}
+
+        {:type, _, :map_field_assoc, [k, v]} ->
+          {{:optional, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)}
+      end)
+
+    case List.keytake(fields, :__struct__, 0) do
+      {{:__struct__, struct}, fields_pruned} when is_atom(struct) and struct != nil ->
+        map_pruned = {:%{}, meta(anno), fields_pruned}
+        {:%, meta(anno), [struct, map_pruned]}
+
+      _ ->
+        {:%{}, meta(anno), fields}
+    end
+  end
+
+  defp typespec_to_quoted({:type, anno, :binary, [arg1, arg2]}) do
+    line = meta(anno)[:line]
+
+    case {typespec_to_quoted(arg1), typespec_to_quoted(arg2)} do
+      {arg1, 0} ->
+        quote(line: line, do: <<_::unquote(arg1)>>)
+
+      {0, arg2} ->
+        quote(line: line, do: <<_::_*unquote(arg2)>>)
+
+      {arg1, arg2} ->
+        quote(line: line, do: <<_::unquote(arg1), _::_*unquote(arg2)>>)
+    end
+  end
+
+  defp typespec_to_quoted({:type, anno, :union, args}) do
+    args = for arg <- args, do: typespec_to_quoted(arg)
+    Enum.reduce(Enum.reverse(args), fn arg, expr -> {:|, meta(anno), [arg, expr]} end)
+  end
+
+  defp typespec_to_quoted({:type, anno, :fun, [{:type, _, :product, args}, result]}) do
+    args = for arg <- args, do: typespec_to_quoted(arg)
+    [{:->, meta(anno), [args, typespec_to_quoted(result)]}]
+  end
+
+  defp typespec_to_quoted({:type, anno, :fun, [args, result]}) do
+    [{:->, meta(anno), [[typespec_to_quoted(args)], typespec_to_quoted(result)]}]
+  end
+
+  defp typespec_to_quoted({:type, anno, :range, [left, right]}) do
+    {:.., meta(anno), [typespec_to_quoted(left), typespec_to_quoted(right)]}
+  end
+
+  defp typespec_to_quoted({:type, _anno, nil, []}) do
+    []
+  end
+
+  defp typespec_to_quoted({:type, anno, name, args}) do
+    args = for arg <- args, do: typespec_to_quoted(arg)
+    {name, meta(anno), args}
+  end
+
+  defp typespec_to_quoted({:var, anno, var}) do
+    {erl_to_ex_var(var), meta(anno), nil}
+  end
+
+  defp typespec_to_quoted({:op, anno, op, arg}) when op in [:+, :-] do
+    {op, meta(anno), [typespec_to_quoted(arg)]}
+  end
+
+  defp typespec_to_quoted({:op, anno, :*, arg1, arg2}) do
+    {:*, meta(anno), [typespec_to_quoted(arg1), typespec_to_quoted(arg2)]}
+  end
+
+  defp typespec_to_quoted({:remote_type, anno, [mod, name, args]}) do
+    remote_type(anno, mod, name, args)
+  end
+
+  defp typespec_to_quoted({:ann_type, anno, [var, type]}) do
+    {:"::", meta(anno), [typespec_to_quoted(var), typespec_to_quoted(type)]}
+  end
+
+  defp typespec_to_quoted(
+         {:typed_record_field, {:record_field, anno1, {:atom, anno2, name}}, type}
+       ) do
+    typespec_to_quoted({:ann_type, anno1, [{:var, anno2, name}, type]})
+  end
+
+  defp typespec_to_quoted({:type, _, :any}) do
+    quote(do: ...)
+  end
+
+  defp typespec_to_quoted({:paren_type, _, [type]}) do
+    typespec_to_quoted(type)
+  end
+
+  defp typespec_to_quoted({type, _anno, atom}) when is_atom(type) do
+    atom
+  end
+
+  defp typespec_to_quoted(other), do: other
+
+  ## Helpers
+
+  defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :charlist}, []) do
+    typespec_to_quoted({:type, anno, :charlist, []})
+  end
+
+  defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :nonempty_charlist}, []) do
+    typespec_to_quoted({:type, anno, :nonempty_charlist, []})
+  end
+
+  defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :struct}, []) do
+    typespec_to_quoted({:type, anno, :struct, []})
+  end
+
+  defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :as_boolean}, [arg]) do
+    typespec_to_quoted({:type, anno, :as_boolean, [arg]})
+  end
+
+  defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :keyword}, args) do
+    typespec_to_quoted({:type, anno, :keyword, args})
+  end
+
+  defp remote_type(anno, mod, name, args) do
+    args = for arg <- args, do: typespec_to_quoted(arg)
+    dot = {:., meta(anno), [typespec_to_quoted(mod), typespec_to_quoted(name)]}
+    {dot, meta(anno), args}
+  end
+
+  defp erl_to_ex_var(var) do
+    case Atom.to_string(var) do
+      <<"_", c::utf8, rest::binary>> ->
+        String.to_atom("_#{String.downcase(<<c::utf8>>)}#{rest}")
+
+      <<c::utf8, rest::binary>> ->
+        String.to_atom("#{String.downcase(<<c::utf8>>)}#{rest}")
+    end
+  end
+
+  defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]} | t], acc) do
+    unpack_typespec_kw(t, [{atom, typespec_to_quoted(type)} | acc])
+  end
+
+  defp unpack_typespec_kw([], acc) do
+    {:ok, Enum.reverse(acc)}
+  end
+
+  defp unpack_typespec_kw(_, _acc) do
+    :error
+  end
+
+  defp meta(anno) do
+    case :erl_anno.location(anno) do
+      {line, column} ->
+        [line: line, column: column]
+
+      line when is_integer(line) ->
+        [line: line]
+    end
+  end
+end
diff --git a/lib/elixir/lib/collectable.ex b/lib/elixir/lib/collectable.ex
index 426f290a4e7..3433fb3f204 100644
--- a/lib/elixir/lib/collectable.ex
+++ b/lib/elixir/lib/collectable.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defprotocol Collectable do
   @moduledoc """
   A protocol to traverse data structures.
@@ -8,110 +12,184 @@ defprotocol Collectable do
       iex> Enum.into([a: 1, b: 2], %{})
       %{a: 1, b: 2}
 
-  If a collection implements both `Enumerable` and `Collectable`, both
-  operations can be combined with `Enum.traverse/2`:
-
-      iex> Enum.traverse(%{a: 1, b: 2}, fn {k, v} -> {k, v * 2} end)
-      %{a: 2, b: 4}
-
   ## Why Collectable?
 
   The `Enumerable` protocol is useful to take values out of a collection.
   In order to support a wide range of values, the functions provided by
   the `Enumerable` protocol do not keep shape. For example, passing a
-  dictionary to `Enum.map/2` always returns a list.
+  map to `Enum.map/2` always returns a list.
 
   This design is intentional. `Enumerable` was designed to support infinite
   collections, resources and other structures with fixed shape. For example,
-  it doesn't make sense to insert values into a range, as it has a fixed
-  shape where just the range limits are stored.
+  it doesn't make sense to insert values into a `Range`, as it has a
+  fixed shape where only the range limits and step are stored.
 
   The `Collectable` module was designed to fill the gap left by the
-  `Enumerable` protocol. It provides two functions: `into/1` and `empty/1`.
+  `Enumerable` protocol. `Collectable.into/1` can be seen as the opposite of
+  `Enumerable.reduce/3`. If the functions in `Enumerable` are about taking values out,
+  then `Collectable.into/1` is about collecting those values into a structure.
+
+  ## Examples
+
+  To show how to manually use the `Collectable` protocol, let's play with a
+  simplified implementation for `MapSet`.
+
+      iex> {initial_acc, collector_fun} = Collectable.into(MapSet.new())
+      iex> updated_acc = Enum.reduce([1, 2, 3], initial_acc, fn elem, acc ->
+      ...>   collector_fun.(acc, {:cont, elem})
+      ...> end)
+      iex> collector_fun.(updated_acc, :done)
+      MapSet.new([1, 2, 3])
+
+  To show how the protocol can be implemented, we can again look at the
+  simplified implementation for `MapSet`. In this implementation "collecting" elements
+  simply means inserting them in the set through `MapSet.put/2`.
+
+      defimpl Collectable, for: MapSet do
+        def into(map_set) do
+          collector_fun = fn
+            map_set_acc, {:cont, elem} ->
+              MapSet.put(map_set_acc, elem)
+
+            map_set_acc, :done ->
+              map_set_acc
 
-  `into/1` can be seen as the opposite of `Enumerable.reduce/3`. If
-  `Enumerable` is about taking values out, `Collectable.into/1` is about
-  collecting those values into a structure.
+            _map_set_acc, :halt ->
+              :ok
+          end
+
+          initial_acc = map_set
+
+          {initial_acc, collector_fun}
+        end
+      end
+
+  So now we can call `Enum.into/2`:
+
+      iex> Enum.into([1, 2, 3], MapSet.new())
+      MapSet.new([1, 2, 3])
 
-  `empty/1` receives a collectable and returns an empty version of the
-  same collectable. By combining the enumerable functionality with `into/1`
-  and `empty/1`, one can, for example, implement a traversal mechanism.
   """
 
   @type command :: {:cont, term} | :done | :halt
 
   @doc """
-  Receives a collectable structure and returns an empty one.
-  """
-  @spec empty(t) :: t
-  def empty(collectable)
+  Returns an initial accumulator and a "collector" function.
 
-  @doc """
-  Returns a function that collects values alongside
-  the initial accumulation value.
+  Receives a `collectable` which can be used as the initial accumulator that will
+  be passed to the function.
 
-  The returned function receives a collectable and injects a given
-  value into it for every `{:cont, term}` instruction.
+  The collector function receives a term and a command and injects the term into
+  the collectable accumulator on every `{:cont, term}` command.
 
-  `:done` is passed when no further values will be injected, useful
-  for closing resources and normalizing values. A collectable must
-  be returned on `:done`.
+  `:done` is passed as a command when no further values will be injected. This
+  is useful when there's a need to close resources or normalizing values. A
+  collectable must be returned when the command is `:done`.
 
-  If injection is suddenly interrupted, `:halt` is passed and it can
-  return any value, as it won't be used.
+  If injection is suddenly interrupted, `:halt` is passed and the function
+  can return any value as it won't be used.
+
+  For examples on how to use the `Collectable` protocol and `into/1` see the
+  module documentation.
   """
-  @spec into(t) :: {term, (term, command -> t | term)}
+  @spec into(t) :: {initial_acc :: term, collector :: (term, command -> t | term)}
   def into(collectable)
 end
 
 defimpl Collectable, for: List do
-  def empty(_list) do
-    []
-  end
-
-  def into(original) do
-    {[], fn
-      list, {:cont, x} -> [x|list]
-      list, :done -> original ++ :lists.reverse(list)
-      _, :halt -> :ok
-    end}
+  def into(list) do
+    # TODO: Change the behavior so the into always comes last on Elixir v2.0
+    if list != [] do
+      IO.warn(
+        "the Collectable protocol is deprecated for non-empty lists. The behavior of " <>
+          "Enum.into/2 and \"for\" comprehensions with an :into option is incorrect " <>
+          "when collecting into non-empty lists. If you're collecting into a non-empty keyword " <>
+          "list, consider using Keyword.merge/2 instead. If you're collecting into a non-empty " <>
+          "list, consider concatenating the two lists with the ++ operator."
+      )
+    end
+
+    fun = fn
+      list_acc, {:cont, elem} ->
+        [elem | list_acc]
+
+      list_acc, :done ->
+        list ++ :lists.reverse(list_acc)
+
+      _list_acc, :halt ->
+        :ok
+    end
+
+    {[], fun}
   end
 end
 
 defimpl Collectable, for: BitString do
-  def empty(_bitstring) do
-    ""
-  end
+  def into(binary) when is_binary(binary) do
+    fun = fn
+      acc, {:cont, x} when is_binary(x) and is_list(acc) ->
+        [acc | x]
 
-  def into(original) do
-    {original, fn
-      bitstring, {:cont, x} -> <<bitstring :: bits, x :: bits>>
-      bitstring, :done -> bitstring
-      _, :halt -> :ok
-    end}
-  end
-end
+      acc, {:cont, x} when is_bitstring(x) and is_bitstring(acc) ->
+        <<acc::bitstring, x::bitstring>>
+
+      acc, {:cont, x} when is_bitstring(x) ->
+        <<IO.iodata_to_binary(acc)::bitstring, x::bitstring>>
+
+      acc, :done when is_bitstring(acc) ->
+        acc
+
+      acc, :done ->
+        IO.iodata_to_binary(acc)
+
+      __acc, :halt ->
+        :ok
+
+      _acc, {:cont, other} ->
+        raise ArgumentError,
+              "collecting into a binary requires a bitstring, got: #{inspect(other)}"
+    end
 
-defimpl Collectable, for: Function do
-  def empty(function) do
-    function
+    {[binary], fun}
   end
 
-  def into(function) do
-    {function, function}
+  def into(bitstring) do
+    fun = fn
+      acc, {:cont, x} when is_bitstring(x) ->
+        <<acc::bitstring, x::bitstring>>
+
+      acc, :done ->
+        acc
+
+      _acc, :halt ->
+        :ok
+
+      _acc, {:cont, other} ->
+        raise ArgumentError,
+              "collecting into a bitstring requires a bitstring, got: #{inspect(other)}"
+    end
+
+    {bitstring, fun}
   end
 end
 
 defimpl Collectable, for: Map do
-  def empty(_map) do
-    %{}
-  end
+  def into(map) do
+    fun = fn
+      map_acc, {:cont, {key, value}} ->
+        Map.put(map_acc, key, value)
+
+      map_acc, :done ->
+        map_acc
+
+      _map_acc, :halt ->
+        :ok
+
+      _map_acc, {:cont, other} ->
+        raise ArgumentError,
+              "collecting into a map requires {key, value} tuples, got: #{inspect(other)}"
+    end
 
-  def into(original) do
-    {original, fn
-      map, {:cont, {k, v}} -> :maps.put(k, v, map)
-      map, :done -> map
-      _, :halt -> :ok
-    end}
+    {map, fun}
   end
 end
diff --git a/lib/elixir/lib/config.ex b/lib/elixir/lib/config.ex
new file mode 100644
index 00000000000..409512b84f2
--- /dev/null
+++ b/lib/elixir/lib/config.ex
@@ -0,0 +1,397 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Config do
+  @moduledoc ~S"""
+  A simple keyword-based configuration API.
+
+  ## Example
+
+  This module is most commonly used to define application configuration,
+  typically in `config/config.exs`:
+
+      import Config
+
+      config :some_app,
+        key1: "value1",
+        key2: "value2"
+
+      import_config "#{config_env()}.exs"
+
+  `import Config` will import the functions `config/2`, `config/3`
+  `config_env/0`, `config_target/0`, and `import_config/1`
+  to help you manage your configuration.
+
+  `config/2` and `config/3` are used to define key-value configuration
+  for a given application. Once Mix starts, it will automatically
+  evaluate the configuration file and persist the configuration above
+  into `:some_app`'s application environment, which can be accessed in
+  as follows:
+
+      "value1" = Application.fetch_env!(:some_app, :key1)
+
+  Finally, the line `import_config "#{config_env()}.exs"` will import
+  other config files based on the current configuration environment,
+  such as `config/dev.exs` and `config/test.exs`.
+
+  `Config` also provides a low-level API for evaluating and reading
+  configuration, under the `Config.Reader` module.
+
+  > #### Avoid application environment in libraries {: .info}
+  >
+  > If you are writing a library to be used by other developers,
+  > it is generally recommended to avoid the application environment, as the
+  > application environment is effectively a global storage. Also note that
+  > the `config/config.exs` of a library is not evaluated when the library is
+  > used as a dependency, as configuration is always meant to configure the
+  > current project. For more information, see ["Using application configuration for
+  > libraries"](design-anti-patterns.md#using-application-configuration-for-libraries).
+
+  ## Migrating from `use Mix.Config`
+
+  The `Config` module in Elixir was introduced in v1.9 as a replacement to
+  `use Mix.Config`, which was specific to Mix and has been deprecated.
+
+  You can leverage `Config` instead of `use Mix.Config` in three steps. The first
+  step is to replace `use Mix.Config` at the top of your config files by
+  `import Config`.
+
+  The second is to make sure your `import_config/1` calls do not have a
+  wildcard character. If so, you need to perform the wildcard lookup
+  manually. For example, if you did:
+
+      import_config "../apps/*/config/config.exs"
+
+  It has to be replaced by:
+
+      for config <- "../apps/*/config/config.exs" |> Path.expand(__DIR__) |> Path.wildcard() do
+        import_config config
+      end
+
+  The last step is to replace all `Mix.env()` calls in the config files with `config_env()`.
+
+  Keep in mind you must also avoid using `Mix.env()` inside your project files.
+  To check the environment at _runtime_, you may add a configuration key:
+
+      # config.exs
+      ...
+      config :my_app, env: config_env()
+
+  Then, in other scripts and modules, you may get the environment with
+  `Application.fetch_env!/2`:
+
+      # router.exs
+      ...
+      if Application.fetch_env!(:my_app, :env) == :prod do
+        ...
+      end
+
+  The only places where you may access functions from the `Mix` module are
+  the `mix.exs` file and inside custom Mix tasks, which are always within
+  the `Mix.Tasks` namespace.
+
+  ## `config/runtime.exs`
+
+  For runtime configuration, you can use the `config/runtime.exs` file.
+  It is executed right before applications start in both Mix and releases
+  (assembled with `mix release`).
+  """
+
+  @type config_opts :: [
+          imports: [Path.t()] | :disabled,
+          env: atom(),
+          target: atom()
+        ]
+
+  @opts_key {__MODULE__, :opts}
+  @config_key {__MODULE__, :config}
+  @imports_key {__MODULE__, :imports}
+
+  defp get_opts!(), do: Process.get(@opts_key) || raise_improper_use!()
+  defp put_opts(value), do: Process.put(@opts_key, value)
+  defp delete_opts(), do: Process.delete(@opts_key)
+
+  defp get_config!(), do: Process.get(@config_key) || raise_improper_use!()
+  defp put_config(value), do: Process.put(@config_key, value)
+  defp delete_config(), do: Process.delete(@config_key)
+
+  defp get_imports!(), do: Process.get(@imports_key) || raise_improper_use!()
+  defp put_imports(value), do: Process.put(@imports_key, value)
+  defp delete_imports(), do: Process.delete(@imports_key)
+
+  defp raise_improper_use!() do
+    raise "could not set configuration via Config. " <>
+            "This usually means you are trying to execute a configuration file " <>
+            "directly, instead of reading it with Config.Reader"
+  end
+
+  @doc """
+  Configures the given `root_key`.
+
+  Keyword lists are always deep-merged.
+
+  ## Examples
+
+  The given `opts` are merged into the existing configuration
+  for the given `root_key`. Conflicting keys are overridden by the
+  ones specified in `opts`, unless they are keywords, which are
+  deep merged recursively. For example, the application configuration
+  below
+
+      config :logger,
+        level: :warn,
+
+      config :logger,
+        level: :info,
+        truncate: 1024
+
+  will have a final configuration for `:logger` of:
+
+      [level: :info, truncate: 1024]
+
+  """
+  @doc since: "1.9.0"
+  def config(root_key, opts) when is_atom(root_key) and is_list(opts) do
+    if not Keyword.keyword?(opts) do
+      raise ArgumentError, "config/2 expected a keyword list, got: #{inspect(opts)}"
+    end
+
+    get_config!()
+    |> __merge__([{root_key, opts}])
+    |> put_config()
+  end
+
+  @doc """
+  Configures the given `key` for the given `root_key`.
+
+  Keyword lists are always deep merged.
+
+  ## Examples
+
+  The given `opts` are merged into the existing values for `key`
+  in the given `root_key`. Conflicting keys are overridden by the
+  ones specified in `opts`, unless they are keywords, which are
+  deep merged recursively. For example, the application configuration
+  below
+
+      config :ecto, Repo,
+        log_level: :warn,
+        adapter: Ecto.Adapters.Postgres,
+        metadata: [read_only: true]
+
+      config :ecto, Repo,
+        log_level: :info,
+        pool_size: 10,
+        metadata: [replica: true]
+
+  will have a final value of the configuration for the `Repo`
+  key in the `:ecto` application of:
+
+      Application.get_env(:ecto, Repo)
+      #=> [
+      #=>   log_level: :info,
+      #=>   pool_size: 10,
+      #=>   adapter: Ecto.Adapters.Postgres,
+      #=>   metadata: [read_only: true, replica: true]
+      #=> ]
+
+  """
+  @doc since: "1.9.0"
+  def config(root_key, key, opts) when is_atom(root_key) and is_atom(key) do
+    get_config!()
+    |> __merge__([{root_key, [{key, opts}]}])
+    |> put_config()
+  end
+
+  @doc """
+  Reads the configuration for the given root key.
+
+  This function only reads the configuration from a previous
+  `config/2` or `config/3` call. If `root_key` points to an
+  application, it does not read its actual application environment.
+  Its main use case is to make it easier to access and share
+  configuration values across files.
+
+  If the `root_key` was not configured, it returns `nil`.
+
+  ## Examples
+
+      # In config/config.exs
+      config :my_app, foo: :bar
+
+      # In config/dev.exs
+      config :another_app, foo: read_config(:my_app)[:foo] || raise "missing parent configuration"
+
+  """
+  @doc since: "1.18.0"
+  def read_config(root_key) when is_atom(root_key) do
+    get_config!()[root_key]
+  end
+
+  @doc """
+  Returns the environment this configuration file is executed on.
+
+  In Mix projects this function returns the environment this configuration
+  file is executed on. 
+  In releases, returns the `MIX_ENV` specified when running `mix release`.
+
+  This is most often used to execute conditional code:
+
+      if config_env() == :prod do
+        config :my_app, :debug, false
+      end
+
+  """
+  @doc since: "1.11.0"
+  defmacro config_env() do
+    quote do
+      Config.__env__!()
+    end
+  end
+
+  @doc false
+  @spec __env__!() :: atom()
+  def __env__!() do
+    elem(get_opts!(), 0) || raise "no :env key was given to this configuration file"
+  end
+
+  @doc """
+  Returns the target this configuration file is executed on.
+
+  This is most often used to execute conditional code:
+
+      if config_target() == :host do
+        config :my_app, :debug, false
+      end
+
+  """
+  @doc since: "1.11.0"
+  defmacro config_target() do
+    quote do
+      Config.__target__!()
+    end
+  end
+
+  @doc false
+  @spec __target__!() :: atom()
+  def __target__!() do
+    elem(get_opts!(), 1) || raise "no :target key was given to this configuration file"
+  end
+
+  @doc ~S"""
+  Imports configuration from the given file.
+
+  In case the file doesn't exist, an error is raised.
+
+  If file is a relative, it will be expanded relatively to the
+  directory the current configuration file is in.
+
+  ## Examples
+
+  This is often used to emulate configuration across environments:
+
+      import_config "#{config_env()}.exs"
+
+  Note, however, some configuration files, such as `config/runtime.exs`
+  does not support imports, as they are meant to be copied across
+  systems.
+  """
+  @doc since: "1.9.0"
+  defmacro import_config(file) do
+    quote do
+      Config.__import__!(Path.expand(unquote(file), __DIR__))
+      :ok
+    end
+  end
+
+  @doc false
+  @spec __import__!(Path.t()) :: {term, Code.binding()}
+  def __import__!(file) when is_binary(file) do
+    import_config!(file, File.read!(file), true)
+  end
+
+  @doc false
+  @spec __eval__!(Path.t(), binary(), config_opts) :: {keyword, [Path.t()] | :disabled}
+  def __eval__!(file, content, opts \\ []) when is_binary(file) and is_list(opts) do
+    env = Keyword.get(opts, :env)
+    target = Keyword.get(opts, :target)
+    imports = Keyword.get(opts, :imports, [])
+
+    previous_opts = put_opts({env, target})
+    previous_config = put_config([])
+    previous_imports = put_imports(imports)
+
+    try do
+      {eval_config, _} = import_config!(file, content, false)
+
+      case get_config!() do
+        [] when is_list(eval_config) ->
+          {validate!(eval_config, file), get_imports!()}
+
+        pdict_config ->
+          {pdict_config, get_imports!()}
+      end
+    after
+      if previous_opts, do: put_opts(previous_opts), else: delete_opts()
+      if previous_config, do: put_config(previous_config), else: delete_config()
+      if previous_imports, do: put_imports(previous_imports), else: delete_imports()
+    end
+  end
+
+  defp import_config!(file, contents, raise_when_disabled?) do
+    current_imports = get_imports!()
+
+    cond do
+      current_imports == :disabled ->
+        if raise_when_disabled? do
+          raise "import_config/1 is not enabled for this configuration file. " <>
+                  "Some configuration files do not allow importing other files " <>
+                  "as they are often copied to external systems"
+        end
+
+      file in current_imports ->
+        raise ArgumentError,
+              "attempting to load configuration #{Path.relative_to_cwd(file)} recursively"
+
+      true ->
+        put_imports([file | current_imports])
+        :ok
+    end
+
+    Code.eval_string(contents, [], file: file)
+  end
+
+  @doc false
+  def __merge__(config1, config2) when is_list(config1) and is_list(config2) do
+    Keyword.merge(config1, config2, fn _, app1, app2 ->
+      Keyword.merge(app1, app2, &deep_merge/3)
+    end)
+  end
+
+  defp deep_merge(_key, value1, value2) do
+    if Keyword.keyword?(value1) and Keyword.keyword?(value2) do
+      Keyword.merge(value1, value2, &deep_merge/3)
+    else
+      value2
+    end
+  end
+
+  defp validate!(config, file) do
+    Enum.all?(config, fn
+      {app, value} when is_atom(app) ->
+        if Keyword.keyword?(value) do
+          true
+        else
+          raise ArgumentError,
+                "expected config for app #{inspect(app)} in #{Path.relative_to_cwd(file)} " <>
+                  "to return keyword list, got: #{inspect(value)}"
+        end
+
+      _ ->
+        false
+    end)
+
+    config
+  end
+end
diff --git a/lib/elixir/lib/config/provider.ex b/lib/elixir/lib/config/provider.ex
new file mode 100644
index 00000000000..b039a2233c7
--- /dev/null
+++ b/lib/elixir/lib/config/provider.ex
@@ -0,0 +1,449 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Config.Provider do
+  @moduledoc """
+  Specifies a provider API that loads configuration during boot.
+
+  Config providers are typically used during releases to load
+  external configuration while the system boots. This is done
+  by starting the VM with the minimum amount of applications
+  running, then invoking all of the providers, and then
+  restarting the system. This requires a mutable configuration
+  file on disk, as the results of the providers are written to
+  the file system. For more information on runtime configuration,
+  see `mix release`.
+
+  ## Multiple config files
+
+  One common use of config providers is to specify multiple
+  configuration files in a release. Elixir ships with one provider,
+  called `Config.Reader`, which is capable of handling Elixir's
+  built-in config files.
+
+  For example, imagine you want to list some basic configuration
+  on Mix's built-in `config/runtime.exs` file, but you also want
+  to support additional configuration files. To do so, you can add
+  this inside the `def project` portion of  your `mix.exs`:
+
+      releases: [
+        demo: [
+          config_providers: [
+            {Config.Reader, {:system, "RELEASE_ROOT", "/extra_config.exs"}}
+          ]
+        ]
+      ]
+
+  You can place this `extra_config.exs` file in your release in
+  multiple ways:
+
+    1. If it is available on the host when assembling the release,
+      you can place it on "rel/overlays/extra_config.exs" and it
+      will be automatically copied to the release root
+
+    2. If it is available on the target during deployment, you can
+      simply copy it to the release root as a step in your deployment
+
+  Now once the system boots, it will load both `config/runtime.exs`
+  and `extra_config.exs` early in the boot process. You can learn
+  more options on `Config.Reader`.
+
+  ## Custom config provider
+
+  You can also implement custom config providers, similar to how
+  `Config.Reader` works. For example, imagine you need to load
+  some configuration from a JSON file and load that into the system.
+  Said configuration provider would look like:
+
+      defmodule JSONConfigProvider do
+        @behaviour Config.Provider
+
+        # Let's pass the path to the JSON file as config
+        @impl true
+        def init(path) when is_binary(path), do: path
+
+        @impl true
+        def load(config, path) do
+          # We need to start any app we may depend on.
+          {:ok, _} = Application.ensure_all_started(:jason)
+
+          json = path |> File.read!() |> Jason.decode!()
+
+          Config.Reader.merge(
+            config,
+            my_app: [
+              some_value: json["my_app_some_value"],
+              another_value: json["my_app_another_value"],
+            ]
+          )
+        end
+      end
+
+  Then, when specifying your release, you can specify the provider in
+  the release configuration:
+
+      releases: [
+        demo: [
+          config_providers: [
+            {JSONConfigProvider, "/etc/config.json"}
+          ]
+        ]
+      ]
+
+  """
+
+  @type config :: keyword
+  @type state :: term
+
+  @typedoc """
+  A path pointing to a configuration file.
+
+  Since configuration files are often accessed on target machines,
+  it can be expressed either as:
+
+    * a binary representing an absolute path
+
+    * a `{:system, system_var, path}` tuple where the config is the
+      concatenation of the environment variable `system_var` with
+      the given `path`
+
+  """
+  @type config_path :: {:system, binary(), binary()} | binary()
+
+  @typedoc """
+  Options for `init/3`.
+  """
+  @type init_opts :: [
+          extra_config: config(),
+          prune_runtime_sys_config_after_boot: boolean(),
+          reboot_system_after_config: boolean(),
+          validate_compile_env: [{atom(), [atom()], term()}]
+        ]
+
+  @doc """
+  Invoked when initializing a config provider.
+
+  A config provider is typically initialized on the machine
+  where the system is assembled and not on the target machine.
+  The `c:init/1` callback is useful to verify the arguments
+  given to the provider and prepare the state that will be
+  given to `c:load/2`.
+
+  Furthermore, because the state returned by `c:init/1` can
+  be written to text-based config files, it should be
+  restricted only to simple data types, such as integers,
+  strings, atoms, tuples, maps, and lists. Entries such as
+  PIDs, references, and functions cannot be serialized.
+  """
+  @callback init(term) :: state
+
+  @doc """
+  Loads configuration (typically during system boot).
+
+  It receives the current `config` and the `state` returned by
+  `c:init/1`. Then, you typically read the extra configuration
+  from an external source and merge it into the received `config`.
+  Merging should be done with `Config.Reader.merge/2`, as it
+  performs deep merge. It should return the updated config.
+
+  Note that `c:load/2` is typically invoked very early in the
+  boot process, therefore if you need to use an application
+  in the provider, it is your responsibility to start it.
+  """
+  @callback load(config, state) :: config
+
+  @doc false
+  defstruct [
+    :providers,
+    :config_path,
+    extra_config: [],
+    prune_runtime_sys_config_after_boot: false,
+    reboot_system_after_config: false,
+    validate_compile_env: false
+  ]
+
+  @reserved_apps [:kernel, :stdlib]
+
+  @doc """
+  Validates a `t:config_path/0`.
+  """
+  @doc since: "1.9.0"
+  @spec validate_config_path!(config_path) :: :ok
+  def validate_config_path!({:system, name, path})
+      when is_binary(name) and is_binary(path),
+      do: :ok
+
+  def validate_config_path!(path) do
+    if is_binary(path) and Path.type(path) != :relative do
+      :ok
+    else
+      raise ArgumentError, """
+      expected configuration path to be:
+
+        * a binary representing an absolute path
+        * a tuple {:system, system_var, path} where the config is the \
+      concatenation of the `system_var` with the given `path`
+
+      Got: #{inspect(path)}
+      """
+    end
+  end
+
+  @doc """
+  Resolves a `t:config_path/0` to an actual path.
+  """
+  @doc since: "1.9.0"
+  @spec resolve_config_path!(config_path) :: binary
+  def resolve_config_path!(path) when is_binary(path), do: path
+  def resolve_config_path!({:system, name, path}), do: System.fetch_env!(name) <> path
+
+  # Private keys
+  @init_key :config_provider_init
+  @booted_key :config_provider_booted
+
+  # Public keys
+  @reboot_mode_key :config_provider_reboot_mode
+
+  @doc false
+  @spec init([{module(), term()}], config_path(), init_opts()) :: config()
+  def init(providers, config_path, opts \\ []) when is_list(providers) and is_list(opts) do
+    validate_config_path!(config_path)
+    providers = for {provider, init} <- providers, do: {provider, provider.init(init)}
+    init = struct!(%Config.Provider{config_path: config_path, providers: providers}, opts)
+    [elixir: [{@init_key, init}]]
+  end
+
+  @doc false
+  def boot(reboot_fun \\ &restart_and_sleep/0) do
+    # The config provider typically runs very early in the
+    # release process, so we need to make sure Elixir is started
+    # before we go around running Elixir code.
+    {:ok, _} = :application.ensure_all_started(:elixir)
+
+    case Application.fetch_env(:elixir, @booted_key) do
+      {:ok, {:booted, path}} ->
+        path && File.rm(path)
+
+        with {:ok, %Config.Provider{} = provider} <- Application.fetch_env(:elixir, @init_key) do
+          maybe_validate_compile_env(provider)
+        end
+
+        :booted
+
+      _ ->
+        case Application.fetch_env(:elixir, @init_key) do
+          {:ok, %Config.Provider{} = provider} ->
+            path = resolve_config_path!(provider.config_path)
+            reboot_config = [elixir: [{@booted_key, booted_value(provider, path)}]]
+            boot_providers(path, provider, reboot_config, reboot_fun)
+
+          _ ->
+            :skip
+        end
+    end
+  end
+
+  defp boot_providers(path, provider, reboot_config, reboot_fun) do
+    original_config = read_config!(path)
+
+    config =
+      original_config
+      |> Config.__merge__(provider.extra_config)
+      |> run_providers(provider)
+
+    if provider.reboot_system_after_config do
+      config
+      |> Config.__merge__(reboot_config)
+      |> write_config!(path)
+
+      reboot_fun.()
+    else
+      for app <- @reserved_apps, config[app] != original_config[app] do
+        abort("""
+        Cannot configure #{inspect(app)} because :reboot_system_after_config has been set \
+        to false and #{inspect(app)} has already been loaded, meaning any further \
+        configuration won't have an effect.
+
+        The configuration for #{inspect(app)} before config providers was:
+
+        #{inspect(original_config[app])}
+
+        The configuration for #{inspect(app)} after config providers was:
+
+        #{inspect(config[app])}
+        """)
+      end
+
+      _ = Application.put_all_env(config, persistent: true)
+      maybe_validate_compile_env(provider)
+      :ok
+    end
+  end
+
+  defp maybe_validate_compile_env(provider) do
+    with [_ | _] = compile_env <- provider.validate_compile_env,
+         {:error, message} <- validate_compile_env(compile_env) do
+      abort(message)
+    end
+  end
+
+  @doc false
+  def valid_compile_env?(compile_env) do
+    Enum.all?(compile_env, fn {app, [key | path], compile_return} ->
+      try do
+        traverse_env(Application.fetch_env(app, key), path) == compile_return
+      rescue
+        _ -> false
+      end
+    end)
+  end
+
+  @doc false
+  def validate_compile_env(compile_env, ensure_loaded? \\ true)
+
+  def validate_compile_env([{app, [key | path], compile_return} | compile_env], ensure_loaded?) do
+    if ensure_app_loaded?(app, ensure_loaded?) do
+      try do
+        traverse_env(Application.fetch_env(app, key), path)
+      rescue
+        e ->
+          {:error,
+           """
+           application #{inspect(app)} failed reading its compile environment #{path(key, path)}:
+
+           #{Exception.format(:error, e, __STACKTRACE__)}
+
+           Expected it to match the compile time value of #{return_to_text(compile_return)}.
+
+           #{compile_env_tips(app)}
+           """}
+      else
+        ^compile_return ->
+          validate_compile_env(compile_env, ensure_loaded?)
+
+        runtime_return ->
+          {:error,
+           """
+           the application #{inspect(app)} has a different value set #{path(key, path)} \
+           during runtime compared to compile time. Since this application environment entry was \
+           marked as compile time, this difference can lead to different behavior than expected:
+
+             * Compile time value #{return_to_text(compile_return)}
+             * Runtime value #{return_to_text(runtime_return)}
+
+           #{compile_env_tips(app)}
+           """}
+      end
+    else
+      validate_compile_env(compile_env, ensure_loaded?)
+    end
+  end
+
+  def validate_compile_env([], _ensure_loaded?) do
+    :ok
+  end
+
+  defp ensure_app_loaded?(app, true), do: Application.ensure_loaded(app) == :ok
+  defp ensure_app_loaded?(app, false), do: Application.spec(app, :vsn) != nil
+
+  defp path(key, []), do: "for key #{inspect(key)}"
+  defp path(key, path), do: "for path #{inspect(path)} inside key #{inspect(key)}"
+
+  defp compile_env_tips(app),
+    do: """
+    To fix this error, you might:
+
+      * Make the runtime value match the compile time one
+
+      * Recompile your project. If the misconfigured application is a dependency, \
+    you may need to run "mix deps.clean #{app} --build"
+
+      * Alternatively, you can disable this check. If you are using releases, you can \
+    set :validate_compile_env to false in your release configuration. If you are \
+    using Mix to start your system, you can pass the --no-validate-compile-env flag
+    """
+
+  defp return_to_text({:ok, value}), do: "was set to: #{inspect(value)}"
+  defp return_to_text(:error), do: "was not set"
+
+  defp traverse_env(return, []), do: return
+  defp traverse_env(:error, _paths), do: :error
+  defp traverse_env({:ok, value}, [key | keys]), do: traverse_env(Access.fetch(value, key), keys)
+
+  @compile {:no_warn_undefined, {:init, :restart, 1}}
+  defp restart_and_sleep() do
+    mode = Application.get_env(:elixir, @reboot_mode_key)
+
+    if mode in [:embedded, :interactive] do
+      :init.restart(mode: mode)
+    else
+      :init.restart()
+    end
+
+    Process.sleep(:infinity)
+  end
+
+  defp booted_value(%{prune_runtime_sys_config_after_boot: true}, path), do: {:booted, path}
+  defp booted_value(%{prune_runtime_sys_config_after_boot: false}, _path), do: {:booted, nil}
+
+  defp read_config!(path) do
+    case :file.consult(path) do
+      {:ok, [inner]} ->
+        inner
+
+      {:error, reason} ->
+        bad_path_abort(
+          "Could not read runtime configuration due to reason: #{inspect(reason)}",
+          path
+        )
+    end
+  end
+
+  defp run_providers(config, %{providers: providers}) do
+    Enum.reduce(providers, config, fn {provider, state}, acc ->
+      try do
+        provider.load(acc, state)
+      catch
+        kind, error ->
+          IO.puts(:stderr, "ERROR! Config provider #{inspect(provider)} failed with:")
+          IO.puts(:stderr, Exception.format(kind, error, __STACKTRACE__))
+          :erlang.raise(kind, error, __STACKTRACE__)
+      else
+        term when is_list(term) ->
+          term
+
+        term ->
+          abort("Expected provider #{inspect(provider)} to return a list, got: #{inspect(term)}")
+      end
+    end)
+  end
+
+  defp write_config!(config, path) do
+    contents = :io_lib.format("%% coding: utf-8~n~tw.~n", [config])
+
+    case File.write(path, IO.chardata_to_string(contents)) do
+      :ok ->
+        :ok
+
+      {:error, reason} ->
+        bad_path_abort(
+          "Could not write runtime configuration due to reason: #{inspect(reason)}",
+          path
+        )
+    end
+  end
+
+  defp bad_path_abort(msg, path) do
+    abort(
+      msg <>
+        ". Please make sure #{inspect(path)} is writable and accessible " <>
+        "or choose a different path"
+    )
+  end
+
+  defp abort(msg) do
+    IO.puts("ERROR! " <> msg)
+    :erlang.raise(:error, "aborting boot", [{Config.Provider, :boot, 2, []}])
+  end
+end
diff --git a/lib/elixir/lib/config/reader.ex b/lib/elixir/lib/config/reader.ex
new file mode 100644
index 00000000000..3a259d3602e
--- /dev/null
+++ b/lib/elixir/lib/config/reader.ex
@@ -0,0 +1,148 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Config.Reader do
+  @moduledoc """
+  API for reading config files defined with `Config`.
+
+  ## As a provider
+
+  `Config.Reader` can also be used as a `Config.Provider`. A config
+  provider is used during releases to customize how applications are
+  configured. When used as a provider, it expects a single argument:
+  the configuration path (as outlined in `t:Config.Provider.config_path/0`)
+  for the file to be read and loaded during the system boot.
+
+  For example, if you expect the target system to have a config file
+  in an absolute path, you can add this inside the `def project` portion
+  of  your `mix.exs`:
+
+      releases: [
+        demo: [
+          config_providers: [
+            {Config.Reader, "/etc/config.exs"}
+          ]
+        ]
+      ]
+
+  Or if you want to read a custom path inside the release:
+
+      config_providers: [{Config.Reader, {:system, "RELEASE_ROOT", "/config.exs"}}]
+
+  You can also pass a keyword list of options to the reader,
+  where the `:path` is a required key:
+
+      config_providers: [
+        {Config.Reader,
+         path: "/etc/config.exs",
+         env: :prod,
+         imports: :disabled}
+      ]
+
+  Remember Mix already loads `config/runtime.exs` by default.
+  For more examples and scenarios, see the `Config.Provider` module.
+  """
+
+  @behaviour Config.Provider
+
+  @type config_opts :: [
+          imports: [Path.t()] | :disabled,
+          env: atom(),
+          target: atom()
+        ]
+
+  @impl true
+  def init(opts) when is_list(opts) do
+    {path, opts} = Keyword.pop!(opts, :path)
+    Config.Provider.validate_config_path!(path)
+    {path, opts}
+  end
+
+  def init(path) do
+    init(path: path)
+  end
+
+  @impl true
+  def load(config, {path, opts}) do
+    merge(config, path |> Config.Provider.resolve_config_path!() |> read!(opts))
+  end
+
+  @doc """
+  Evaluates the configuration `contents` for the given `file`.
+
+  Accepts the same options as `read!/2`.
+  """
+  @doc since: "1.11.0"
+  @spec eval!(Path.t(), binary, config_opts) :: keyword
+  def eval!(file, contents, opts \\ [])
+      when is_binary(file) and is_binary(contents) and is_list(opts) do
+    Config.__eval__!(Path.expand(file), contents, opts) |> elem(0)
+  end
+
+  @doc """
+  Reads the configuration file.
+
+  ## Options
+
+    * `:imports` - a list of already imported paths or `:disabled`
+      to disable imports
+
+    * `:env` - the environment the configuration file runs on.
+      See `Config.config_env/0` for sample usage
+
+    * `:target` - the target the configuration file runs on.
+      See `Config.config_target/0` for sample usage
+
+  """
+  @doc since: "1.9.0"
+  @spec read!(Path.t(), config_opts) :: keyword
+  def read!(file, opts \\ []) when is_binary(file) and is_list(opts) do
+    file = Path.expand(file)
+    Config.__eval__!(file, File.read!(file), opts) |> elem(0)
+  end
+
+  @doc """
+  Reads the given configuration file and returns the configuration
+  with its imports.
+
+  Accepts the same options as `read!/2`. Although note the `:imports`
+  option cannot be disabled in `read_imports!/2`.
+  """
+  @doc since: "1.9.0"
+  @spec read_imports!(Path.t(), config_opts) :: {keyword, [Path.t()]}
+  def read_imports!(file, opts \\ []) when is_binary(file) and is_list(opts) do
+    if opts[:imports] == :disabled do
+      raise ArgumentError, ":imports must be a list of paths"
+    end
+
+    file = Path.expand(file)
+    Config.__eval__!(file, File.read!(file), opts)
+  end
+
+  @doc """
+  Merges two configurations.
+
+  The configurations are merged together with the values in
+  the second one having higher preference than the first in
+  case of conflicts. In case both values are set to keyword
+  lists, it deep merges them.
+
+  ## Examples
+
+      iex> Config.Reader.merge([app: [k: :v1]], [app: [k: :v2]])
+      [app: [k: :v2]]
+
+      iex> Config.Reader.merge([app: [k: [v1: 1, v2: 2]]], [app: [k: [v2: :a, v3: :b]]])
+      [app: [k: [v1: 1, v2: :a, v3: :b]]]
+
+      iex> Config.Reader.merge([app1: []], [app2: []])
+      [app1: [], app2: []]
+
+  """
+  @doc since: "1.9.0"
+  @spec merge(keyword, keyword) :: keyword
+  def merge(config1, config2) when is_list(config1) and is_list(config2) do
+    Config.__merge__(config1, config2)
+  end
+end
diff --git a/lib/elixir/lib/dict.ex b/lib/elixir/lib/dict.ex
index 3f3b5d3e444..7a0cd02d2e4 100644
--- a/lib/elixir/lib/dict.ex
+++ b/lib/elixir/lib/dict.ex
@@ -1,139 +1,39 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Dict do
   @moduledoc ~S"""
-  This module specifies the Dict API expected to be
-  implemented by different dictionaries. It also provides
-  functions that redirect to the underlying Dict, allowing
-  a developer to work with different Dict implementations
-  using one API.
-
-  To create a new dict, use the `new` functions defined
-  by each dict type:
-
-      HashDict.new  #=> creates an empty HashDict
-
-  In the examples below, `dict_impl` means a specific
-  `Dict` implementation, for example `HashDict` or `Map`.
-
-  ## Protocols
-
-  Besides implementing the functions in this module, all
-  dictionaries are required to implement the `Access`
-  protocol:
-
-      iex> dict = dict_impl.new
-      iex> dict = Dict.put(dict, :hello, :world)
-      iex> dict[:hello]
-      :world
-
-  As well as the `Enumerable` and `Collectable` protocols.
-
-  ## Match
+  Generic API for dictionaries.
 
-  Dictionaries are required to implement all operations
-  using the match (`===`) operator.
-
-  ## Default implementation
-
-  Default implementations for some functions in the `Dict` module
-  are provided via `use Dict`.
-
-  For example:
-
-      defmodule MyDict do
-        use Dict
-
-        # implement required functions (see below)
-        # override default implementations if optimization
-        # is needed
-      end
-
-  The client module must contain the following functions:
-
-    * `delete/2`
-    * `fetch/2`
-    * `put/3`
-    * `reduce/3`
-    * `size/1`
-
-  All functions, except `reduce/3`, are required by the Dict behaviour.
-  `reduce/3` must be implemtented as per the Enumerable protocol.
-
-  Based on these functions, `Dict` generates default implementations
-  for the following functions:
-
-    * `drop/2`
-    * `equal?/2`
-    * `fetch!/2`
-    * `get/2`
-    * `get/3`
-    * `has_key?/2`
-    * `keys/1`
-    * `merge/2`
-    * `merge/3`
-    * `pop/2`
-    * `pop/3`
-    * `put_new/3`
-    * `split/2`
-    * `take/2`
-    * `to_list/1`
-    * `update/4`
-    * `update!/3`
-    * `values/1`
-
-  All of these functions are defined as overridable, so you can provide
-  your own implementation if needed.
-
-  Note you can also test your custom module via `Dict`'s doctests:
-
-      defmodule MyDict do
-        # ...
-      end
-
-      defmodule MyTests do
-        use ExUnit.Case
-        doctest Dict
-        defp dict_impl, do: MyDict
-      end
+  If you need a general dictionary, use the `Map` module.
+  If you need to manipulate keyword lists, use `Keyword`.
 
+  To convert maps into keywords and vice-versa, use the
+  `new` function in the respective modules.
   """
 
-  use Behaviour
+  @moduledoc deprecated: "Use Map or Keyword modules instead"
 
   @type key :: any
   @type value :: any
   @type t :: list | map
 
-  defcallback new :: t
-  defcallback delete(t, key) :: t
-  defcallback drop(t, Enum.t) :: t
-  defcallback equal?(t, t) :: boolean
-  defcallback get(t, key) :: value
-  defcallback get(t, key, value) :: value
-  defcallback fetch(t, key) :: {:ok, value} | :error
-  defcallback fetch!(t, key) :: value | no_return
-  defcallback has_key?(t, key) :: boolean
-  defcallback keys(t) :: [key]
-  defcallback merge(t, t) :: t
-  defcallback merge(t, t, (key, value, value -> value)) :: t
-  defcallback pop(t, key) :: {value, t}
-  defcallback pop(t, key, value) :: {value, t}
-  defcallback put(t, key, value) :: t
-  defcallback put_new(t, key, value) :: t
-  defcallback size(t) :: non_neg_integer()
-  defcallback split(t, Enum.t) :: {t, t}
-  defcallback take(t, Enum.t) :: t
-  defcallback to_list(t) :: list()
-  defcallback update(t, key, value, (value -> value)) :: t
-  defcallback update!(t, key, (value -> value)) :: t | no_return
-  defcallback values(t) :: list(value)
+  message =
+    "Use the Map module for working with maps or the Keyword module for working with keyword lists"
 
   defmacro __using__(_) do
     # Use this import to guarantee proper code expansion
     import Kernel, except: [size: 1]
 
+    if __CALLER__.module != HashDict do
+      IO.warn("use Dict is deprecated. " <> unquote(message), __CALLER__)
+    end
+
     quote do
-      @behaviour Dict
+      message = "Use maps and the Map module instead"
 
+      @deprecated message
       def get(dict, key, default \\ nil) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -141,6 +41,22 @@ defmodule Dict do
         end
       end
 
+      @deprecated message
+      def get_lazy(dict, key, fun) when is_function(fun, 0) do
+        case fetch(dict, key) do
+          {:ok, value} -> value
+          :error -> fun.()
+        end
+      end
+
+      @deprecated message
+      def get_and_update(dict, key, fun) do
+        current_value = get(dict, key)
+        {get, new_value} = fun.(current_value)
+        {get, put(dict, key, new_value)}
+      end
+
+      @deprecated message
       def fetch!(dict, key) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -148,23 +64,35 @@ defmodule Dict do
         end
       end
 
+      @deprecated message
       def has_key?(dict, key) do
-        match? {:ok, _}, fetch(dict, key)
+        match?({:ok, _}, fetch(dict, key))
       end
 
+      @deprecated message
       def put_new(dict, key, value) do
         case has_key?(dict, key) do
-          true  -> dict
+          true -> dict
           false -> put(dict, key, value)
         end
       end
 
+      @deprecated message
+      def put_new_lazy(dict, key, fun) when is_function(fun, 0) do
+        case has_key?(dict, key) do
+          true -> dict
+          false -> put(dict, key, fun.())
+        end
+      end
+
+      @deprecated message
       def drop(dict, keys) do
         Enum.reduce(keys, dict, &delete(&2, &1))
       end
 
+      @deprecated message
       def take(dict, keys) do
-        Enum.reduce(keys, new, fn key, acc ->
+        Enum.reduce(keys, new(), fn key, acc ->
           case fetch(dict, key) do
             {:ok, value} -> put(acc, key, value)
             :error -> acc
@@ -172,41 +100,49 @@ defmodule Dict do
         end)
       end
 
+      @deprecated message
       def to_list(dict) do
-        reduce(dict, {:cont, []}, fn
-          kv, acc -> {:cont, [kv|acc]}
-        end) |> elem(1) |> :lists.reverse
+        reduce(dict, {:cont, []}, fn kv, acc -> {:cont, [kv | acc]} end)
+        |> elem(1)
+        |> :lists.reverse()
       end
 
+      @deprecated message
       def keys(dict) do
-        reduce(dict, {:cont, []}, fn
-          {k, _}, acc -> {:cont, [k|acc]}
-        end) |> elem(1) |> :lists.reverse
+        reduce(dict, {:cont, []}, fn {k, _}, acc -> {:cont, [k | acc]} end)
+        |> elem(1)
+        |> :lists.reverse()
       end
 
+      @deprecated message
       def values(dict) do
-        reduce(dict, {:cont, []}, fn
-          {_, v}, acc -> {:cont, [v|acc]}
-        end) |> elem(1) |> :lists.reverse
+        reduce(dict, {:cont, []}, fn {_, v}, acc -> {:cont, [v | acc]} end)
+        |> elem(1)
+        |> :lists.reverse()
       end
 
+      @deprecated message
       def equal?(dict1, dict2) do
         # Use this import to avoid conflicts in the user code
         import Kernel, except: [size: 1]
 
         case size(dict1) == size(dict2) do
-          false -> false
-          true  ->
-            reduce(dict1, {:cont, true}, fn({k, v}, _acc) ->
+          false ->
+            false
+
+          true ->
+            reduce(dict1, {:cont, true}, fn {k, v}, _acc ->
               case fetch(dict2, k) do
                 {:ok, ^v} -> {:cont, true}
                 _ -> {:halt, false}
               end
-            end) |> elem(1)
+            end)
+            |> elem(1)
         end
       end
 
-      def merge(dict1, dict2, fun \\ fn(_k, _v1, v2) -> v2 end) do
+      @deprecated message
+      def merge(dict1, dict2, fun \\ fn _k, _v1, v2 -> v2 end) do
         # Use this import to avoid conflicts in the user code
         import Kernel, except: [size: 1]
 
@@ -218,444 +154,263 @@ defmodule Dict do
           reduce(dict2, {:cont, dict1}, fn {k, v2}, acc ->
             {:cont, update(acc, k, v2, &fun.(k, &1, v2))}
           end)
-        end |> elem(1)
+        end
+        |> elem(1)
       end
 
-      def update(dict, key, initial, fun) do
+      @deprecated message
+      def update(dict, key, default, fun) do
         case fetch(dict, key) do
           {:ok, value} ->
             put(dict, key, fun.(value))
+
           :error ->
-            put(dict, key, initial)
+            put(dict, key, default)
         end
       end
 
+      @deprecated message
       def update!(dict, key, fun) do
         case fetch(dict, key) do
           {:ok, value} ->
             put(dict, key, fun.(value))
+
           :error ->
             raise KeyError, key: key, term: dict
         end
       end
 
+      @deprecated message
       def pop(dict, key, default \\ nil) do
         case fetch(dict, key) do
           {:ok, value} ->
             {value, delete(dict, key)}
+
           :error ->
             {default, dict}
         end
       end
 
+      @deprecated message
+      def pop_lazy(dict, key, fun) when is_function(fun, 0) do
+        case fetch(dict, key) do
+          {:ok, value} ->
+            {value, delete(dict, key)}
+
+          :error ->
+            {fun.(), dict}
+        end
+      end
+
+      @deprecated message
       def split(dict, keys) do
-        Enum.reduce(keys, {new, dict}, fn key, {inc, exc} = acc ->
+        Enum.reduce(keys, {new(), dict}, fn key, {inc, exc} = acc ->
           case fetch(exc, key) do
             {:ok, value} ->
               {put(inc, key, value), delete(exc, key)}
+
             :error ->
               acc
           end
         end)
       end
 
-      defoverridable merge: 2, merge: 3, equal?: 2, to_list: 1, keys: 1,
-                     values: 1, take: 2, drop: 2, get: 2, get: 3, fetch!: 2,
-                     has_key?: 2, put_new: 3, pop: 2, pop: 3, split: 2,
-                     update: 4, update!: 3
+      defoverridable merge: 2,
+                     merge: 3,
+                     equal?: 2,
+                     to_list: 1,
+                     keys: 1,
+                     values: 1,
+                     take: 2,
+                     drop: 2,
+                     get: 2,
+                     get: 3,
+                     fetch!: 2,
+                     has_key?: 2,
+                     put_new: 3,
+                     pop: 2,
+                     pop: 3,
+                     split: 2,
+                     update: 4,
+                     update!: 3,
+                     get_and_update: 3,
+                     get_lazy: 3,
+                     pop_lazy: 3,
+                     put_new_lazy: 3
     end
   end
 
-
   defmacrop target(dict) do
     quote do
       case unquote(dict) do
-        %{__struct__: x} when is_atom(x) ->
-          x
-        %{} ->
-          Map
-        x when is_list(x) ->
-          Keyword
-        x ->
-          unsupported_dict(x)
+        %module{} -> module
+        %{} -> Map
+        dict when is_list(dict) -> Keyword
+        dict -> unsupported_dict(dict)
       end
     end
   end
 
-  @doc """
-  Returns a list of all keys in `dict`.
-  The keys are not guaranteed to be in any order.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> Enum.sort(Dict.keys(d))
-      [:a,:b]
-
-  """
+  @deprecated message
   @spec keys(t) :: [key]
   def keys(dict) do
     target(dict).keys(dict)
   end
 
-  @doc """
-  Returns a list of all values in `dict`.
-  The values are not guaranteed to be in any order.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> Enum.sort(Dict.values(d))
-      [1,2]
-
-  """
+  @deprecated message
   @spec values(t) :: [value]
   def values(dict) do
     target(dict).values(dict)
   end
 
-  @doc """
-  Returns the number of elements in `dict`.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> Dict.size(d)
-      2
-
-  """
+  @deprecated message
   @spec size(t) :: non_neg_integer
   def size(dict) do
     target(dict).size(dict)
   end
 
-  @doc """
-  Returns whether the given `key` exists in the given `dict`.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1], dict_impl.new)
-      iex> Dict.has_key?(d, :a)
-      true
-      iex> Dict.has_key?(d, :b)
-      false
-
-  """
+  @deprecated message
   @spec has_key?(t, key) :: boolean
   def has_key?(dict, key) do
     target(dict).has_key?(dict, key)
   end
 
-  @doc """
-  Returns the value associated with `key` in `dict`. If `dict` does not
-  contain `key`, returns `default` (or `nil` if not provided).
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1], dict_impl.new)
-      iex> Dict.get(d, :a)
-      1
-      iex> Dict.get(d, :b)
-      nil
-      iex> Dict.get(d, :b, 3)
-      3
-  """
+  @deprecated message
   @spec get(t, key, value) :: value
   def get(dict, key, default \\ nil) do
     target(dict).get(dict, key, default)
   end
 
-  @doc """
-  Returns `{:ok, value}` associated with `key` in `dict`.
-  If `dict` does not contain `key`, returns `:error`.
-
-  ## Examples
+  @deprecated message
+  @spec get_lazy(t, key, (-> value)) :: value
+  def get_lazy(dict, key, fun) do
+    target(dict).get_lazy(dict, key, fun)
+  end
 
-      iex> d = Enum.into([a: 1], dict_impl.new)
-      iex> Dict.fetch(d, :a)
-      {:ok, 1}
-      iex> Dict.fetch(d, :b)
-      :error
+  @deprecated message
+  @spec get_and_update(t, key, (value -> {value, value})) :: {value, t}
+  def get_and_update(dict, key, fun) do
+    target(dict).get_and_update(dict, key, fun)
+  end
 
-  """
+  @deprecated message
   @spec fetch(t, key) :: value
   def fetch(dict, key) do
     target(dict).fetch(dict, key)
   end
 
-  @doc """
-  Returns the value associated with `key` in `dict`. If `dict` does not
-  contain `key`, it raises `KeyError`.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1], dict_impl.new)
-      iex> Dict.fetch!(d, :a)
-      1
-
-  """
-  @spec fetch!(t, key) :: value | no_return
+  @deprecated message
+  @spec fetch!(t, key) :: value
   def fetch!(dict, key) do
     target(dict).fetch!(dict, key)
   end
 
-  @doc """
-  Stores the given `value` under `key` in `dict`.
-  If `dict` already has `key`, the stored value is replaced by the new one.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> d = Dict.put(d, :a, 3)
-      iex> Dict.get(d, :a)
-      3
-
-  """
+  @deprecated message
   @spec put(t, key, value) :: t
   def put(dict, key, val) do
     target(dict).put(dict, key, val)
   end
 
-  @doc """
-  Puts the given `value` under `key` in `dict` unless `key` already exists.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> d = Dict.put_new(d, :a, 3)
-      iex> Dict.get(d, :a)
-      1
-
-  """
+  @deprecated message
   @spec put_new(t, key, value) :: t
   def put_new(dict, key, val) do
     target(dict).put_new(dict, key, val)
   end
 
-  @doc """
-  Removes the entry stored under the given `key` from `dict`.
-  If `dict` does not contain `key`, returns the dictionary unchanged.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> d = Dict.delete(d, :a)
-      iex> Dict.get(d, :a)
-      nil
-
-      iex> d = Enum.into([b: 2], dict_impl.new)
-      iex> Dict.delete(d, :a) == d
-      true
+  @deprecated message
+  @spec put_new_lazy(t, key, (-> value)) :: t
+  def put_new_lazy(dict, key, fun) do
+    target(dict).put_new_lazy(dict, key, fun)
+  end
 
-  """
+  @deprecated message
   @spec delete(t, key) :: t
   def delete(dict, key) do
     target(dict).delete(dict, key)
   end
 
-  @doc """
-  Merges the dict `b` into dict `a`.
-
-  If one of the dict `b` entries already exists in the `dict`,
-  the functions in entries in `b` have higher precedence unless a
-  function is given to resolve conflicts.
-
-  Notice this function is polymorphic as it merges dicts of any
-  type. Each dict implementation also provides a `merge` function,
-  but they can only merge dicts of the same type.
-
-  ## Examples
-
-      iex> d1 = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> d2 = Enum.into([a: 3, d: 4], dict_impl.new)
-      iex> d = Dict.merge(d1, d2)
-      iex> [a: Dict.get(d, :a), b: Dict.get(d, :b), d: Dict.get(d, :d)]
-      [a: 3, b: 2, d: 4]
+  @deprecated message
+  @spec merge(t, t) :: t
+  def merge(dict1, dict2) do
+    target1 = target(dict1)
+    target2 = target(dict2)
 
-      iex> d1 = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> d2 = Enum.into([a: 3, d: 4], dict_impl.new)
-      iex> d = Dict.merge(d1, d2, fn(_k, v1, v2) ->
-      ...>   v1 + v2
-      ...> end)
-      iex> [a: Dict.get(d, :a), b: Dict.get(d, :b), d: Dict.get(d, :d)]
-      [a: 4, b: 2, d: 4]
+    if target1 == target2 do
+      target1.merge(dict1, dict2)
+    else
+      do_merge(target1, dict1, dict2, fn _k, _v1, v2 -> v2 end)
+    end
+  end
 
-  """
+  @deprecated message
   @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(dict1, dict2, fun \\ fn(_k, _v1, v2) -> v2 end) do
+  def merge(dict1, dict2, fun) do
     target1 = target(dict1)
     target2 = target(dict2)
 
     if target1 == target2 do
       target1.merge(dict1, dict2, fun)
     else
-      Enumerable.reduce(dict2, {:cont, dict1}, fn({k, v}, acc) ->
-        {:cont, target1.update(acc, k, v, fn(other) -> fun.(k, other, v) end)}
-      end) |> elem(1)
+      do_merge(target1, dict1, dict2, fun)
     end
   end
 
-  @doc """
-  Returns the value associated with `key` in `dict` as
-  well as the `dict` without `key`.
-
-  ## Examples
-
-      iex> dict = Enum.into([a: 1], dict_impl.new)
-      iex> {v, d} = Dict.pop dict, :a
-      iex> {v, Enum.sort(d)}
-      {1,[]}
-
-      iex> dict = Enum.into([a: 1], dict_impl.new)
-      iex> {v, d} = Dict.pop dict, :b
-      iex> {v, Enum.sort(d)}
-      {nil,[a: 1]}
-
-      iex> dict = Enum.into([a: 1], dict_impl.new)
-      iex> {v, d} = Dict.pop dict, :b, 3
-      iex> {v, Enum.sort(d)}
-      {3,[a: 1]}
+  defp do_merge(target1, dict1, dict2, fun) do
+    Enumerable.reduce(dict2, {:cont, dict1}, fn {k, v}, acc ->
+      {:cont, target1.update(acc, k, v, fn other -> fun.(k, other, v) end)}
+    end)
+    |> elem(1)
+  end
 
-  """
+  @deprecated message
   @spec pop(t, key, value) :: {value, t}
   def pop(dict, key, default \\ nil) do
     target(dict).pop(dict, key, default)
   end
 
-  @doc """
-  Update a value in `dict` by calling `fun` on the value to get a new
-  value. An exception is generated if `key` is not present in the dict.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> d = Dict.update!(d, :a, fn(val) -> -val end)
-      iex> Dict.get(d, :a)
-      -1
+  @deprecated message
+  @spec pop_lazy(t, key, (-> value)) :: {value, t}
+  def pop_lazy(dict, key, fun) do
+    target(dict).pop_lazy(dict, key, fun)
+  end
 
-  """
+  @deprecated message
   @spec update!(t, key, (value -> value)) :: t
   def update!(dict, key, fun) do
     target(dict).update!(dict, key, fun)
   end
 
-  @doc """
-  Update a value in `dict` by calling `fun` on the value to get a new value. If
-  `key` is not present in `dict` then `initial` will be stored as the first
-  value.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> d = Dict.update(d, :c, 3, fn(val) -> -val end)
-      iex> Dict.get(d, :c)
-      3
-
-  """
+  @deprecated message
   @spec update(t, key, value, (value -> value)) :: t
-  def update(dict, key, initial, fun) do
-    target(dict).update(dict, key, initial, fun)
+  def update(dict, key, default, fun) do
+    target(dict).update(dict, key, default, fun)
   end
 
-  @doc """
-  Returns a tuple of two dicts, where the first dict contains only
-  entries from `dict` with keys in `keys`, and the second dict
-  contains only entries from `dict` with keys not in `keys`
-
-  Any non-member keys are ignored.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2, c: 3, d: 4], dict_impl.new)
-      iex> {d1, d2} = Dict.split(d, [:a, :c, :e])
-      iex> {Dict.to_list(d1) |> Enum.sort, Dict.to_list(d2) |> Enum.sort}
-      {[a: 1, c: 3], [b: 2, d: 4]}
-
-      iex> d = Enum.into([], dict_impl.new)
-      iex> {d1, d2} = Dict.split(d, [:a, :c])
-      iex> {Dict.to_list(d1), Dict.to_list(d2)}
-      {[], []}
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> {d1, d2} = Dict.split(d, [:a, :b, :c])
-      iex> {Dict.to_list(d1) |> Enum.sort, Dict.to_list(d2)}
-      {[a: 1, b: 2], []}
-
-  """
+  @deprecated message
   @spec split(t, [key]) :: {t, t}
   def split(dict, keys) do
     target(dict).split(dict, keys)
   end
 
-  @doc """
-  Returns a new dict where the given `keys` are removed from `dict`.
-  Any non-member keys are ignored.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> d = Dict.drop(d, [:a, :c, :d])
-      iex> Dict.to_list(d)
-      [b: 2]
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> d = Dict.drop(d, [:c, :d])
-      iex> Dict.to_list(d) |> Enum.sort
-      [a: 1, b: 2]
-
-  """
+  @deprecated message
   @spec drop(t, [key]) :: t
   def drop(dict, keys) do
     target(dict).drop(dict, keys)
   end
 
-  @doc """
-  Returns a new dict where only the keys in `keys` from `dict` are included.
-
-  Any non-member keys are ignored.
-
-  ## Examples
-
-      iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      iex> d = Dict.take(d, [:a, :c, :d])
-      iex> Dict.to_list(d)
-      [a: 1]
-      iex> d = Dict.take(d, [:c, :d])
-      iex> Dict.to_list(d)
-      []
-
-  """
+  @deprecated message
   @spec take(t, [key]) :: t
   def take(dict, keys) do
     target(dict).take(dict, keys)
   end
 
-  @doc false
+  @deprecated message
   @spec empty(t) :: t
   def empty(dict) do
     target(dict).empty(dict)
   end
 
-  @doc """
-  Check if two dicts are equal using `===`.
-
-  Notice this function is polymorphic as it compares dicts of any
-  type. Each dict implementation also provides an `equal?` function,
-  but they can only compare dicts of the same type.
-
-  ## Examples
-
-      iex> a = Enum.into([a: 2, b: 3, f: 5, c: 123], dict_impl.new)
-      iex> b = [a: 2, b: 3, f: 5, c: 123]
-      iex> Dict.equal?(a, b)
-      true
-
-      iex> a = Enum.into([a: 2, b: 3, f: 5, c: 123], dict_impl.new)
-      iex> b = []
-      iex> Dict.equal?(a, b)
-      false
-
-  """
+  @deprecated message
   @spec equal?(t, t) :: boolean
   def equal?(dict1, dict2) do
     target1 = target(dict1)
@@ -666,28 +421,27 @@ defmodule Dict do
         target1.equal?(dict1, dict2)
 
       target1.size(dict1) == target2.size(dict2) ->
-        Enumerable.reduce(dict2, {:cont, true}, fn({k, v}, _acc) ->
+        Enumerable.reduce(dict2, {:cont, true}, fn {k, v}, _acc ->
           case target1.fetch(dict1, k) do
             {:ok, ^v} -> {:cont, true}
-            _           -> {:halt, false}
+            _ -> {:halt, false}
           end
-        end) |> elem(1)
+        end)
+        |> elem(1)
 
       true ->
         false
     end
   end
 
-  @doc """
-  Returns a list of key-value pairs stored in `dict`.
-  No particular order is enforced.
-  """
+  @deprecated message
   @spec to_list(t) :: list
   def to_list(dict) do
     target(dict).to_list(dict)
   end
 
+  @spec unsupported_dict(t) :: no_return
   defp unsupported_dict(dict) do
-    raise ArgumentError, "unsupported dict: #{inspect dict}"
+    raise ArgumentError, "unsupported dict: #{inspect(dict)}"
   end
 end
diff --git a/lib/elixir/lib/dynamic_supervisor.ex b/lib/elixir/lib/dynamic_supervisor.ex
new file mode 100644
index 00000000000..e0f896a97ae
--- /dev/null
+++ b/lib/elixir/lib/dynamic_supervisor.ex
@@ -0,0 +1,1125 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule DynamicSupervisor do
+  @moduledoc ~S"""
+  A supervisor optimized to only start children dynamically.
+
+  The `Supervisor` module was designed to handle mostly static children
+  that are started in the given order when the supervisor starts. A
+  `DynamicSupervisor` starts with no children. Instead, children are
+  started on demand via `start_child/2` and there is no ordering between
+  children. This allows the `DynamicSupervisor` to hold millions of
+  children by using efficient data structures and to execute certain
+  operations, such as shutting down, concurrently.
+
+  ## Examples
+
+  A dynamic supervisor is started with no children and often with a name:
+
+      children = [
+        {DynamicSupervisor, name: MyApp.DynamicSupervisor, strategy: :one_for_one}
+      ]
+
+      Supervisor.start_link(children, strategy: :one_for_one)
+
+  The options given in the child specification are documented in `start_link/1`.
+
+  Once the dynamic supervisor is running, we can use it to start children
+  on demand. Given this sample `GenServer`:
+
+      defmodule Counter do
+        use GenServer
+
+        def start_link(initial) do
+          GenServer.start_link(__MODULE__, initial)
+        end
+
+        def inc(pid) do
+          GenServer.call(pid, :inc)
+        end
+
+        def init(initial) do
+          {:ok, initial}
+        end
+
+        def handle_call(:inc, _, count) do
+          {:reply, count, count + 1}
+        end
+      end
+
+  We can use `start_child/2` with a child specification to start a `Counter`
+  server:
+
+      {:ok, counter1} = DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Counter, 0})
+      Counter.inc(counter1)
+      #=> 0
+
+      {:ok, counter2} = DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Counter, 10})
+      Counter.inc(counter2)
+      #=> 10
+
+      DynamicSupervisor.count_children(MyApp.DynamicSupervisor)
+      #=> %{active: 2, specs: 2, supervisors: 0, workers: 2}
+
+  ## Scalability and partitioning
+
+  The `DynamicSupervisor` is a single process responsible for starting
+  other processes. In some applications, the `DynamicSupervisor` may
+  become a bottleneck. To address this, you can start multiple instances
+  of the `DynamicSupervisor` and then pick a "random" instance to start
+  the child on.
+
+  Instead of:
+
+      children = [
+        {DynamicSupervisor, name: MyApp.DynamicSupervisor}
+      ]
+
+  and:
+
+      DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Counter, 0})
+
+  You can do this:
+
+      children = [
+        {PartitionSupervisor,
+         child_spec: DynamicSupervisor,
+         name: MyApp.DynamicSupervisors}
+      ]
+
+  and then:
+
+      DynamicSupervisor.start_child(
+        {:via, PartitionSupervisor, {MyApp.DynamicSupervisors, self()}},
+        {Counter, 0}
+      )
+
+  In the code above, we start a partition supervisor that will by default
+  start a dynamic supervisor for each core in your machine. Then, instead
+  of calling the `DynamicSupervisor` by name, you call it through the
+  partition supervisor, using `self()` as the routing key. This means each
+  process will be assigned one of the existing dynamic supervisors.
+  Read the `PartitionSupervisor` docs for more information.
+
+  ## Module-based supervisors
+
+  Similar to `Supervisor`, dynamic supervisors also support module-based
+  supervisors.
+
+      defmodule MyApp.DynamicSupervisor do
+        # Automatically defines child_spec/1
+        use DynamicSupervisor
+
+        def start_link(init_arg) do
+          DynamicSupervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
+        end
+
+        @impl true
+        def init(_init_arg) do
+          DynamicSupervisor.init(strategy: :one_for_one)
+        end
+      end
+
+  See the `Supervisor` docs for a discussion of when you may want to use
+  module-based supervisors. A `@doc` annotation immediately preceding
+  `use DynamicSupervisor` will be attached to the generated `child_spec/1`
+  function.
+
+  > #### `use DynamicSupervisor` {: .info}
+  >
+  > When you `use DynamicSupervisor`, the `DynamicSupervisor` module will
+  > set `@behaviour DynamicSupervisor` and define a `child_spec/1`
+  > function, so your module can be used as a child in a supervision tree.
+
+  ## Name registration
+
+  A supervisor is bound to the same name registration rules as a `GenServer`.
+  Read more about these rules in the documentation for `GenServer`.
+  """
+
+  @behaviour GenServer
+
+  @doc """
+  Callback invoked to start the supervisor and during hot code upgrades.
+
+  Developers typically invoke `DynamicSupervisor.init/1` at the end of
+  their init callback to return the proper supervision flags.
+  """
+  @callback init(init_arg :: term) :: {:ok, sup_flags()} | :ignore
+
+  @typedoc "The supervisor flags returned on init"
+  @type sup_flags() :: %{
+          strategy: strategy(),
+          intensity: non_neg_integer(),
+          period: pos_integer(),
+          max_children: non_neg_integer() | :infinity,
+          extra_arguments: [term()]
+        }
+
+  @typedoc "Options given to `start_link/1` and `init/1` functions"
+  @type init_option ::
+          {:strategy, strategy()}
+          | {:max_restarts, non_neg_integer()}
+          | {:max_seconds, pos_integer()}
+          | {:max_children, non_neg_integer() | :infinity}
+          | {:extra_arguments, [term()]}
+
+  @typedoc "Supported strategies"
+  @type strategy :: :one_for_one
+
+  @typedoc """
+  Return values of `start_child` functions.
+
+  Unlike `Supervisor`, this module ignores the child spec ids,
+  so `{:error, {:already_started, pid}}` is not returned for child specs
+  given with the same id. `{:error, {:already_started, pid}}` is returned
+  however if a duplicate name is used when using
+  [name registration](`m:GenServer#module-name-registration`).
+  """
+  @type on_start_child ::
+          {:ok, pid}
+          | {:ok, pid, info :: term}
+          | :ignore
+          | {:error, {:already_started, pid} | :max_children | term}
+
+  # In this struct, `args` refers to the arguments passed to init/1 (the `init_arg`).
+  defstruct [
+    :args,
+    :extra_arguments,
+    :mod,
+    :name,
+    :strategy,
+    :max_children,
+    :max_restarts,
+    :max_seconds,
+    children: %{},
+    restarts: []
+  ]
+
+  @doc """
+  Returns a specification to start a dynamic supervisor under a supervisor.
+
+  It accepts the same options as `start_link/1`.
+
+  See `Supervisor` for more information about child specifications.
+  """
+  @doc since: "1.6.1"
+  @spec child_spec([init_option() | GenServer.option()]) :: Supervisor.child_spec()
+  def child_spec(options) when is_list(options) do
+    id =
+      case Keyword.get(options, :name, DynamicSupervisor) do
+        name when is_atom(name) -> name
+        {:global, name} -> name
+        {:via, _module, name} -> name
+      end
+
+    %{
+      id: id,
+      start: {DynamicSupervisor, :start_link, [options]},
+      type: :supervisor
+    }
+  end
+
+  @doc false
+  defmacro __using__(opts) do
+    quote location: :keep, bind_quoted: [opts: opts] do
+      @behaviour DynamicSupervisor
+      if not Module.has_attribute?(__MODULE__, :doc) do
+        @doc """
+        Returns a specification to start this module under a supervisor.
+
+        See `Supervisor`.
+        """
+      end
+
+      def child_spec(arg) do
+        default = %{
+          id: __MODULE__,
+          start: {__MODULE__, :start_link, [arg]},
+          type: :supervisor
+        }
+
+        Supervisor.child_spec(default, unquote(Macro.escape(opts)))
+      end
+
+      defoverridable child_spec: 1
+    end
+  end
+
+  @doc """
+  Starts a supervisor with the given options.
+
+  This function is typically not invoked directly, instead it is invoked
+  when using a `DynamicSupervisor` as a child of another supervisor:
+
+      children = [
+        {DynamicSupervisor, name: MySupervisor}
+      ]
+
+  If the supervisor is successfully spawned, this function returns
+  `{:ok, pid}`, where `pid` is the PID of the supervisor. If the supervisor
+  is given a name and a process with the specified name already exists,
+  the function returns `{:error, {:already_started, pid}}`, where `pid`
+  is the PID of that process.
+
+  Note that a supervisor started with this function is linked to the parent
+  process and exits not only on crashes but also if the parent process exits
+  with `:normal` reason.
+
+  ## Options
+
+    * `:name` - registers the supervisor under the given name.
+      The supported values are described under the "Name registration"
+      section in the `GenServer` module docs.
+
+    * `:strategy` - the restart strategy option. The only supported
+      value is `:one_for_one` which means that no other child is
+      terminated if a child process terminates. You can learn more
+      about strategies in the `Supervisor` module docs.
+
+    * `:max_restarts` - the maximum number of restarts allowed in
+      a time frame. Defaults to `3`.
+
+    * `:max_seconds` - the time frame in which `:max_restarts` applies.
+      Defaults to `5`.
+
+    * `:max_children` - the maximum amount of children to be running
+      under this supervisor at the same time. When `:max_children` is
+      exceeded, `start_child/2` returns `{:error, :max_children}`. Defaults
+      to `:infinity`.
+
+    * `:extra_arguments` - arguments that are prepended to the arguments
+      specified in the child spec given to `start_child/2`. Defaults to
+      an empty list.
+
+    * Any of the standard [GenServer options](`t:GenServer.option/0`)
+
+  """
+  @doc since: "1.6.0"
+  @spec start_link([init_option | GenServer.option()]) :: Supervisor.on_start()
+  def start_link(options) when is_list(options) do
+    keys = [:extra_arguments, :max_children, :max_seconds, :max_restarts, :strategy]
+    {sup_opts, start_opts} = Keyword.split(options, keys)
+    start_link(Supervisor.Default, init(sup_opts), start_opts)
+  end
+
+  @doc """
+  Starts a module-based supervisor process with the given `module` and `init_arg`.
+
+  To start the supervisor, the `c:init/1` callback will be invoked in the given
+  `module`, with `init_arg` as its argument. The `c:init/1` callback must return a
+  supervisor specification which can be created with the help of the `init/1`
+  function.
+
+  If the `c:init/1` callback returns `:ignore`, this function returns
+  `:ignore` as well and the supervisor terminates with reason `:normal`.
+  If it fails or returns an incorrect value, this function returns
+  `{:error, term}` where `term` is a term with information about the
+  error, and the supervisor terminates with reason `term`.
+
+  The `:name` option can also be given in order to register a supervisor
+  name, the supported values are described in the "Name registration"
+  section in the `GenServer` module docs.
+
+  If the supervisor is successfully spawned, this function returns
+  `{:ok, pid}`, where `pid` is the PID of the supervisor. If the supervisor
+  is given a name and a process with the specified name already exists,
+  the function returns `{:error, {:already_started, pid}}`, where `pid`
+  is the PID of that process.
+
+  Note that a supervisor started with this function is linked to the parent
+  process and exits not only on crashes but also if the parent process exits
+  with `:normal` reason.
+
+  ## Options
+
+  This function accepts any regular [`GenServer` options](`t:GenServer.option/0`).
+  Options specific to `DynamicSupervisor` must be returned from the `c:init/1`
+  callback.
+  """
+  @doc since: "1.6.0"
+  @spec start_link(module, term, [GenServer.option()]) :: Supervisor.on_start()
+  def start_link(module, init_arg, opts \\ []) do
+    GenServer.start_link(__MODULE__, {module, init_arg, opts[:name]}, opts)
+  end
+
+  @doc """
+  Dynamically adds a child specification to `supervisor` and starts that child.
+
+  `child_spec` should be a valid [child specification](`m:Supervisor#module-child-specification`).
+  The child process will be started as defined in the child specification. Note that while
+  the `:id` field is still required in the spec, the value is ignored and
+  therefore does not need to be unique. Unlike `Supervisor`, this module does not
+  return `{:error, {:already_started, pid}}` for child specs given with the same id.
+  `{:error, {:already_started, pid}}` is returned however if a duplicate name is
+  used when using [name registration](`m:GenServer#module-name-registration`).
+
+  This function will block the `DynamicSupervisor` until the child initializes.
+  When starting too many processes dynamically, you may want to use a
+  `PartitionSupervisor` to split the work across multiple processes.
+
+  If the child process start function returns `{:ok, child}` or `{:ok, child,
+  info}`, then child specification and PID are added to the supervisor and
+  this function returns the same value.
+
+  If the child process start function returns `:ignore`, then no child is added
+  to the supervision tree and this function returns `:ignore` too.
+
+  If the child process start function returns an error tuple or an erroneous
+  value, or if it fails, the child specification is discarded and this function
+  returns `{:error, error}` where `error` is the error or erroneous value
+  returned from child process start function, or failure reason if it fails.
+
+  If the supervisor already has N children in a way that N exceeds the amount
+  of `:max_children` set on the supervisor initialization (see `init/1`), then
+  this function returns `{:error, :max_children}`.
+  """
+  @doc since: "1.6.0"
+  @spec start_child(
+          Supervisor.supervisor(),
+          Supervisor.child_spec()
+          | {module, term}
+          | module
+          | (old_erlang_child_spec :: :supervisor.child_spec())
+        ) ::
+          on_start_child()
+  def start_child(supervisor, {_, _, _, _, _, _} = child_spec) do
+    validate_and_start_child(supervisor, child_spec)
+  end
+
+  def start_child(supervisor, child_spec) do
+    validate_and_start_child(supervisor, Supervisor.child_spec(child_spec, []))
+  end
+
+  defp validate_and_start_child(supervisor, child_spec) do
+    case validate_child(child_spec) do
+      {:ok, child} -> call(supervisor, {:start_child, child})
+      error -> {:error, error}
+    end
+  end
+
+  defp validate_child(%{id: _, start: {mod, _, _} = start} = child) do
+    restart = Map.get(child, :restart, :permanent)
+    type = Map.get(child, :type, :worker)
+    modules = Map.get(child, :modules, [mod])
+    significant = Map.get(child, :significant, false)
+
+    shutdown =
+      case type do
+        :worker -> Map.get(child, :shutdown, 5_000)
+        :supervisor -> Map.get(child, :shutdown, :infinity)
+      end
+
+    validate_child(start, restart, shutdown, type, modules, significant)
+  end
+
+  defp validate_child({_, start, restart, shutdown, type, modules}) do
+    validate_child(start, restart, shutdown, type, modules, false)
+  end
+
+  defp validate_child(other) do
+    {:invalid_child_spec, other}
+  end
+
+  defp validate_child(start, restart, shutdown, type, modules, significant) do
+    with :ok <- validate_start(start),
+         :ok <- validate_restart(restart),
+         :ok <- validate_shutdown(shutdown),
+         :ok <- validate_type(type),
+         :ok <- validate_modules(modules),
+         :ok <- validate_significant(significant) do
+      {:ok, {start, restart, shutdown, type, modules}}
+    end
+  end
+
+  defp validate_start({m, f, args}) when is_atom(m) and is_atom(f) and is_list(args), do: :ok
+  defp validate_start(mfa), do: {:invalid_mfa, mfa}
+
+  defp validate_type(type) when type in [:supervisor, :worker], do: :ok
+  defp validate_type(type), do: {:invalid_child_type, type}
+
+  defp validate_restart(restart) when restart in [:permanent, :temporary, :transient], do: :ok
+  defp validate_restart(restart), do: {:invalid_restart_type, restart}
+
+  defp validate_shutdown(shutdown) when is_integer(shutdown) and shutdown >= 0, do: :ok
+  defp validate_shutdown(shutdown) when shutdown in [:infinity, :brutal_kill], do: :ok
+  defp validate_shutdown(shutdown), do: {:invalid_shutdown, shutdown}
+
+  defp validate_significant(false), do: :ok
+  defp validate_significant(significant), do: {:invalid_significant, significant}
+
+  defp validate_modules(:dynamic), do: :ok
+
+  defp validate_modules(mods) do
+    if is_list(mods) and Enum.all?(mods, &is_atom/1) do
+      :ok
+    else
+      {:invalid_modules, mods}
+    end
+  end
+
+  @doc """
+  Terminates the given child identified by `pid`.
+
+  This function will block the `DynamicSupervisor` until the child
+  terminates, which may take an arbitrary amount of time if the child
+  is trapping exits and implements its own terminate callback.
+  For this reason, it is often better to ask the child process
+  itself to terminate, often by declaring in its child spec it has
+  a restart strategy of `:transient` (or `:temporary`) and then
+  sending it a message to stop with reason `:shutdown`.
+
+  If successful, this function returns `:ok`. If there is no process with
+  the given PID, this function returns `{:error, :not_found}`.
+  """
+  @doc since: "1.6.0"
+  @spec terminate_child(Supervisor.supervisor(), pid) :: :ok | {:error, :not_found}
+  def terminate_child(supervisor, pid) when is_pid(pid) do
+    call(supervisor, {:terminate_child, pid})
+  end
+
+  @doc """
+  Returns a list with information about all children of the given supervisor.
+
+  Note that calling this function when supervising a large number
+  of children under low memory conditions can bring the system down due to an
+  out of memory error.
+
+  This function returns a list of tuples containing:
+
+    * `id` - it is always `:undefined` for dynamic supervisors
+
+    * `child` - the PID of the corresponding child process or the
+      atom `:restarting` if the process is about to be restarted
+
+    * `type` - `:worker` or `:supervisor` as defined in the child
+      specification
+
+    * `modules` - as defined in the child specification
+
+  """
+  @doc since: "1.6.0"
+  @spec which_children(Supervisor.supervisor()) :: [
+          # module() | :dynamic here because :supervisor.modules() is not exported
+          {:undefined, pid | :restarting, :worker | :supervisor, [module()] | :dynamic}
+        ]
+  def which_children(supervisor) do
+    call(supervisor, :which_children)
+  end
+
+  @doc """
+  Returns a map containing count values for the supervisor.
+
+  The map contains the following keys:
+
+    * `:specs` - the number of children processes
+
+    * `:active` - the count of all actively running child processes managed by
+      this supervisor
+
+    * `:supervisors` - the count of all supervisors whether or not the child
+      process is still alive
+
+    * `:workers` - the count of all workers, whether or not the child process
+      is still alive
+
+  """
+  @doc since: "1.6.0"
+  @spec count_children(Supervisor.supervisor()) :: %{
+          specs: non_neg_integer,
+          active: non_neg_integer,
+          supervisors: non_neg_integer,
+          workers: non_neg_integer
+        }
+  def count_children(supervisor) do
+    call(supervisor, :count_children) |> :maps.from_list()
+  end
+
+  @doc """
+  Synchronously stops the given supervisor with the given `reason`.
+
+  It returns `:ok` if the supervisor terminates with the given
+  reason. If it terminates with another reason, the call exits.
+
+  This function keeps OTP semantics regarding error reporting.
+  If the reason is any other than `:normal`, `:shutdown` or
+  `{:shutdown, _}`, an error report is logged.
+  """
+  @doc since: "1.7.0"
+  @spec stop(Supervisor.supervisor(), reason :: term, timeout) :: :ok
+  def stop(supervisor, reason \\ :normal, timeout \\ :infinity) do
+    GenServer.stop(supervisor, reason, timeout)
+  end
+
+  @doc """
+  Receives a set of `options` that initializes a dynamic supervisor.
+
+  This is typically invoked at the end of the `c:init/1` callback of
+  module-based supervisors. See the "Module-based supervisors" section
+  in the module documentation for more information.
+
+  It accepts the same `options` as `start_link/1` (except for `:name`)
+  and it returns a tuple containing the supervisor options.
+
+  ## Examples
+
+      def init(_arg) do
+        DynamicSupervisor.init(max_children: 1000)
+      end
+
+  """
+  @doc since: "1.6.0"
+  @spec init([init_option]) :: {:ok, sup_flags()}
+  def init(options) when is_list(options) do
+    strategy = Keyword.get(options, :strategy, :one_for_one)
+    intensity = Keyword.get(options, :max_restarts, 3)
+    period = Keyword.get(options, :max_seconds, 5)
+    max_children = Keyword.get(options, :max_children, :infinity)
+    extra_arguments = Keyword.get(options, :extra_arguments, [])
+
+    flags = %{
+      strategy: strategy,
+      intensity: intensity,
+      period: period,
+      max_children: max_children,
+      extra_arguments: extra_arguments
+    }
+
+    {:ok, flags}
+  end
+
+  ## Callbacks
+
+  @impl true
+  def init({mod, init_arg, name}) do
+    Process.put(:"$initial_call", {:supervisor, mod, 1})
+    Process.flag(:trap_exit, true)
+
+    case mod.init(init_arg) do
+      {:ok, flags} when is_map(flags) ->
+        name =
+          cond do
+            is_nil(name) -> {self(), mod}
+            is_atom(name) -> {:local, name}
+            is_tuple(name) -> name
+          end
+
+        state = %DynamicSupervisor{mod: mod, args: init_arg, name: name}
+
+        case init(state, flags) do
+          {:ok, state} -> {:ok, state}
+          {:error, reason} -> {:stop, {:supervisor_data, reason}}
+        end
+
+      :ignore ->
+        :ignore
+
+      other ->
+        {:stop, {:bad_return, {mod, :init, other}}}
+    end
+  end
+
+  defp init(state, flags) do
+    extra_arguments = Map.get(flags, :extra_arguments, [])
+    max_children = Map.get(flags, :max_children, :infinity)
+    max_restarts = Map.get(flags, :intensity, 1)
+    max_seconds = Map.get(flags, :period, 5)
+    strategy = Map.get(flags, :strategy, :one_for_one)
+    auto_shutdown = Map.get(flags, :auto_shutdown, :never)
+
+    with :ok <- validate_strategy(strategy),
+         :ok <- validate_restarts(max_restarts),
+         :ok <- validate_seconds(max_seconds),
+         :ok <- validate_dynamic(max_children),
+         :ok <- validate_extra_arguments(extra_arguments),
+         :ok <- validate_auto_shutdown(auto_shutdown) do
+      {:ok,
+       %{
+         state
+         | extra_arguments: extra_arguments,
+           max_children: max_children,
+           max_restarts: max_restarts,
+           max_seconds: max_seconds,
+           strategy: strategy
+       }}
+    end
+  end
+
+  defp validate_strategy(strategy) when strategy in [:one_for_one], do: :ok
+  defp validate_strategy(strategy), do: {:error, {:invalid_strategy, strategy}}
+
+  defp validate_restarts(restart) when is_integer(restart) and restart >= 0, do: :ok
+  defp validate_restarts(restart), do: {:error, {:invalid_intensity, restart}}
+
+  defp validate_seconds(seconds) when is_integer(seconds) and seconds > 0, do: :ok
+  defp validate_seconds(seconds), do: {:error, {:invalid_period, seconds}}
+
+  defp validate_dynamic(:infinity), do: :ok
+  defp validate_dynamic(dynamic) when is_integer(dynamic) and dynamic >= 0, do: :ok
+  defp validate_dynamic(dynamic), do: {:error, {:invalid_max_children, dynamic}}
+
+  defp validate_extra_arguments(list) when is_list(list), do: :ok
+  defp validate_extra_arguments(extra), do: {:error, {:invalid_extra_arguments, extra}}
+
+  defp validate_auto_shutdown(auto_shutdown) when auto_shutdown in [:never], do: :ok
+
+  defp validate_auto_shutdown(auto_shutdown),
+    do: {:error, {:invalid_auto_shutdown, auto_shutdown}}
+
+  @impl true
+  def handle_call(:which_children, _from, state) do
+    %{children: children} = state
+
+    reply =
+      for {pid, args} <- children do
+        case args do
+          {:restarting, {_, _, _, type, modules}} ->
+            {:undefined, :restarting, type, modules}
+
+          {_, _, _, type, modules} ->
+            {:undefined, pid, type, modules}
+        end
+      end
+
+    {:reply, reply, state}
+  end
+
+  def handle_call(:count_children, _from, state) do
+    %{children: children} = state
+    specs = map_size(children)
+
+    {active, workers, supervisors} =
+      Enum.reduce(children, {0, 0, 0}, fn
+        {_pid, {:restarting, {_, _, _, :worker, _}}}, {active, worker, supervisor} ->
+          {active, worker + 1, supervisor}
+
+        {_pid, {:restarting, {_, _, _, :supervisor, _}}}, {active, worker, supervisor} ->
+          {active, worker, supervisor + 1}
+
+        {_pid, {_, _, _, :worker, _}}, {active, worker, supervisor} ->
+          {active + 1, worker + 1, supervisor}
+
+        {_pid, {_, _, _, :supervisor, _}}, {active, worker, supervisor} ->
+          {active + 1, worker, supervisor + 1}
+      end)
+
+    reply = [specs: specs, active: active, supervisors: supervisors, workers: workers]
+    {:reply, reply, state}
+  end
+
+  def handle_call({:terminate_child, pid}, _from, %{children: children} = state) do
+    case children do
+      %{^pid => info} ->
+        :ok = terminate_children(%{pid => info}, state)
+        {:reply, :ok, delete_child(pid, state)}
+
+      %{} ->
+        {:reply, {:error, :not_found}, state}
+    end
+  end
+
+  def handle_call({:start_task, args, restart, shutdown}, from, state) do
+    {init_restart, init_shutdown} = Process.get(Task.Supervisor)
+
+    if restart == nil and init_restart != :temporary do
+      {:reply, {:restart, init_restart}, state}
+    else
+      restart = restart || init_restart
+      shutdown = shutdown || init_shutdown
+
+      child =
+        {{Task.Supervised, :start_link, args}, restart, shutdown, :worker, [Task.Supervised]}
+
+      handle_call({:start_child, child}, from, state)
+    end
+  end
+
+  def handle_call({:start_child, child}, _from, state) do
+    %{children: children, max_children: max_children} = state
+
+    if map_size(children) < max_children do
+      handle_start_child(child, state)
+    else
+      {:reply, {:error, :max_children}, state}
+    end
+  end
+
+  defp handle_start_child({{m, f, args} = mfa, restart, shutdown, type, modules}, state) do
+    %{extra_arguments: extra} = state
+
+    case reply = start_child(m, f, extra ++ args) do
+      {:ok, pid, _} ->
+        {:reply, reply, save_child(pid, mfa, restart, shutdown, type, modules, state)}
+
+      {:ok, pid} ->
+        {:reply, reply, save_child(pid, mfa, restart, shutdown, type, modules, state)}
+
+      _ ->
+        {:reply, reply, state}
+    end
+  end
+
+  defp start_child(m, f, a) do
+    try do
+      apply(m, f, a)
+    catch
+      kind, reason ->
+        {:error, exit_reason(kind, reason, __STACKTRACE__)}
+    else
+      {:ok, pid, extra} when is_pid(pid) -> {:ok, pid, extra}
+      {:ok, pid} when is_pid(pid) -> {:ok, pid}
+      :ignore -> :ignore
+      {:error, _} = error -> error
+      other -> {:error, other}
+    end
+  end
+
+  defp save_child(pid, mfa, restart, shutdown, type, modules, state) do
+    mfa = mfa_for_restart(mfa, restart)
+    put_in(state.children[pid], {mfa, restart, shutdown, type, modules})
+  end
+
+  defp mfa_for_restart({m, f, _}, :temporary), do: {m, f, :undefined}
+  defp mfa_for_restart(mfa, _), do: mfa
+
+  defp exit_reason(:exit, reason, _), do: reason
+  defp exit_reason(:error, reason, stack), do: {reason, stack}
+  defp exit_reason(:throw, value, stack), do: {{:nocatch, value}, stack}
+
+  @impl true
+  def handle_cast(_msg, state) do
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_info({:EXIT, pid, reason}, state) do
+    case maybe_restart_child(pid, reason, state) do
+      {:ok, state} -> {:noreply, state}
+      {:shutdown, state} -> {:stop, :shutdown, state}
+    end
+  end
+
+  def handle_info({:"$gen_restart", pid}, state) do
+    %{children: children} = state
+
+    case children do
+      %{^pid => restarting_args} ->
+        {:restarting, child} = restarting_args
+
+        case restart_child(pid, child, state) do
+          {:ok, state} -> {:noreply, state}
+          {:shutdown, state} -> {:stop, :shutdown, state}
+        end
+
+      # We may hit clause if we send $gen_restart and then
+      # someone calls terminate_child, removing the child.
+      %{} ->
+        {:noreply, state}
+    end
+  end
+
+  def handle_info(msg, state) do
+    :logger.error(
+      %{
+        label: {DynamicSupervisor, :unexpected_msg},
+        report: %{
+          msg: msg
+        }
+      },
+      %{
+        domain: [:otp, :elixir],
+        error_logger: %{tag: :error_msg},
+        report_cb: &__MODULE__.format_report/1
+      }
+    )
+
+    {:noreply, state}
+  end
+
+  @impl true
+  def code_change(_, %{mod: mod, args: init_arg} = state, _) do
+    case mod.init(init_arg) do
+      {:ok, flags} when is_map(flags) ->
+        case init(state, flags) do
+          {:ok, state} -> {:ok, state}
+          {:error, reason} -> {:error, {:supervisor_data, reason}}
+        end
+
+      :ignore ->
+        {:ok, state}
+
+      error ->
+        error
+    end
+  end
+
+  @impl true
+  def terminate(_, %{children: children} = state) do
+    :ok = terminate_children(children, state)
+  end
+
+  defp terminate_children(children, state) do
+    {pids, times, stacks} = monitor_children(children)
+    size = map_size(pids)
+
+    timers =
+      Enum.reduce(times, %{}, fn {time, pids}, acc ->
+        Map.put(acc, :erlang.start_timer(time, self(), :kill), pids)
+      end)
+
+    stacks = wait_children(pids, size, timers, stacks)
+
+    for {pid, {child, reason}} <- stacks do
+      report_error(:shutdown_error, reason, pid, child, state)
+    end
+
+    :ok
+  end
+
+  defp monitor_children(children) do
+    Enum.reduce(children, {%{}, %{}, %{}}, fn
+      {_, {:restarting, _}}, acc ->
+        acc
+
+      {pid, {_, restart, _, _, _} = child}, {pids, times, stacks} ->
+        case monitor_child(pid) do
+          :ok ->
+            times = exit_child(pid, child, times)
+            {Map.put(pids, pid, child), times, stacks}
+
+          {:error, :normal} when restart != :permanent ->
+            {pids, times, stacks}
+
+          {:error, reason} ->
+            {pids, times, Map.put(stacks, pid, {child, reason})}
+        end
+    end)
+  end
+
+  defp monitor_child(pid) do
+    ref = Process.monitor(pid)
+    Process.unlink(pid)
+
+    receive do
+      {:EXIT, ^pid, reason} ->
+        receive do
+          {:DOWN, ^ref, :process, ^pid, _} -> {:error, reason}
+        end
+    after
+      0 -> :ok
+    end
+  end
+
+  defp exit_child(pid, {_, _, shutdown, _, _}, times) do
+    case shutdown do
+      :brutal_kill ->
+        Process.exit(pid, :kill)
+        times
+
+      :infinity ->
+        Process.exit(pid, :shutdown)
+        times
+
+      time ->
+        Process.exit(pid, :shutdown)
+        Map.update(times, time, [pid], &[pid | &1])
+    end
+  end
+
+  defp wait_children(_pids, 0, timers, stacks) do
+    for {timer, _} <- timers do
+      _ = :erlang.cancel_timer(timer)
+
+      receive do
+        {:timeout, ^timer, :kill} -> :ok
+      after
+        0 -> :ok
+      end
+    end
+
+    stacks
+  end
+
+  defp wait_children(pids, size, timers, stacks) do
+    receive do
+      {:DOWN, _ref, :process, pid, reason} ->
+        case pids do
+          %{^pid => child} ->
+            stacks = wait_child(pid, child, reason, stacks)
+            wait_children(pids, size - 1, timers, stacks)
+
+          %{} ->
+            wait_children(pids, size, timers, stacks)
+        end
+
+      {:timeout, timer, :kill} ->
+        for pid <- Map.fetch!(timers, timer), do: Process.exit(pid, :kill)
+        wait_children(pids, size, Map.delete(timers, timer), stacks)
+    end
+  end
+
+  defp wait_child(pid, {_, _, :brutal_kill, _, _} = child, reason, stacks) do
+    case reason do
+      :killed -> stacks
+      _ -> Map.put(stacks, pid, {child, reason})
+    end
+  end
+
+  defp wait_child(pid, {_, restart, _, _, _} = child, reason, stacks) do
+    case reason do
+      {:shutdown, _} -> stacks
+      :shutdown -> stacks
+      :normal when restart != :permanent -> stacks
+      reason -> Map.put(stacks, pid, {child, reason})
+    end
+  end
+
+  defp maybe_restart_child(pid, reason, %{children: children} = state) do
+    case children do
+      %{^pid => {_, restart, _, _, _} = child} ->
+        maybe_restart_child(restart, reason, pid, child, state)
+
+      %{} ->
+        {:ok, state}
+    end
+  end
+
+  defp maybe_restart_child(:permanent, reason, pid, child, state) do
+    report_error(:child_terminated, reason, pid, child, state)
+    restart_child(pid, child, state)
+  end
+
+  defp maybe_restart_child(_, :normal, pid, _child, state) do
+    {:ok, delete_child(pid, state)}
+  end
+
+  defp maybe_restart_child(_, :shutdown, pid, _child, state) do
+    {:ok, delete_child(pid, state)}
+  end
+
+  defp maybe_restart_child(_, {:shutdown, _}, pid, _child, state) do
+    {:ok, delete_child(pid, state)}
+  end
+
+  defp maybe_restart_child(:transient, reason, pid, child, state) do
+    report_error(:child_terminated, reason, pid, child, state)
+    restart_child(pid, child, state)
+  end
+
+  defp maybe_restart_child(:temporary, reason, pid, child, state) do
+    report_error(:child_terminated, reason, pid, child, state)
+    {:ok, delete_child(pid, state)}
+  end
+
+  defp delete_child(pid, %{children: children} = state) do
+    %{state | children: Map.delete(children, pid)}
+  end
+
+  defp restart_child(pid, child, state) do
+    case add_restart(state) do
+      {:ok, %{strategy: strategy} = state} ->
+        case restart_child(strategy, pid, child, state) do
+          {:ok, state} ->
+            {:ok, state}
+
+          {:try_again, state} ->
+            send(self(), {:"$gen_restart", pid})
+            {:ok, state}
+        end
+
+      {:shutdown, state} ->
+        report_error(:shutdown, :reached_max_restart_intensity, pid, child, state)
+        {:shutdown, delete_child(pid, state)}
+    end
+  end
+
+  defp add_restart(state) do
+    %{max_seconds: max_seconds, max_restarts: max_restarts, restarts: restarts} = state
+
+    now = :erlang.monotonic_time(1)
+    restarts = add_restart([now | restarts], now, max_seconds)
+    state = %{state | restarts: restarts}
+
+    if length(restarts) <= max_restarts do
+      {:ok, state}
+    else
+      {:shutdown, state}
+    end
+  end
+
+  defp add_restart(restarts, now, period) do
+    for then <- restarts, now <= then + period, do: then
+  end
+
+  defp restart_child(:one_for_one, current_pid, child, state) do
+    {{m, f, args} = mfa, restart, shutdown, type, modules} = child
+    %{extra_arguments: extra} = state
+
+    case start_child(m, f, extra ++ args) do
+      {:ok, pid, _} ->
+        state = delete_child(current_pid, state)
+        {:ok, save_child(pid, mfa, restart, shutdown, type, modules, state)}
+
+      {:ok, pid} ->
+        state = delete_child(current_pid, state)
+        {:ok, save_child(pid, mfa, restart, shutdown, type, modules, state)}
+
+      :ignore ->
+        {:ok, delete_child(current_pid, state)}
+
+      {:error, reason} ->
+        report_error(:start_error, reason, {:restarting, current_pid}, child, state)
+        state = put_in(state.children[current_pid], {:restarting, child})
+        {:try_again, state}
+    end
+  end
+
+  defp report_error(error, reason, pid, child, %{name: name, extra_arguments: extra}) do
+    :logger.error(
+      %{
+        label: {:supervisor, error},
+        report: [
+          {:supervisor, name},
+          {:errorContext, error},
+          {:reason, reason},
+          {:offender, extract_child(pid, child, extra)}
+        ]
+      },
+      %{
+        domain: [:otp, :sasl],
+        report_cb: &:logger.format_otp_report/1,
+        logger_formatter: %{title: "SUPERVISOR REPORT"},
+        error_logger: %{tag: :error_report, type: :supervisor_report}
+      }
+    )
+  end
+
+  defp extract_child(pid, {{m, f, args}, restart, shutdown, type, _modules}, extra) do
+    [
+      pid: pid,
+      id: :undefined,
+      mfargs: {m, f, extra ++ args},
+      restart_type: restart,
+      shutdown: shutdown,
+      child_type: type
+    ]
+  end
+
+  ## Helpers
+
+  @compile {:inline, call: 2}
+
+  defp call(supervisor, req) do
+    GenServer.call(supervisor, req, :infinity)
+  end
+
+  @doc false
+  def format_report(%{
+        label: {__MODULE__, :unexpected_msg},
+        report: %{msg: msg}
+      }) do
+    {~c"DynamicSupervisor received unexpected message: ~p~n", [msg]}
+  end
+end
diff --git a/lib/elixir/lib/enum.ex b/lib/elixir/lib/enum.ex
index 46c97a9bc5a..8a8a3e89937 100644
--- a/lib/elixir/lib/enum.ex
+++ b/lib/elixir/lib/enum.ex
@@ -1,38 +1,76 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defprotocol Enumerable do
   @moduledoc """
   Enumerable protocol used by `Enum` and `Stream` modules.
 
   When you invoke a function in the `Enum` module, the first argument
-  is usually a collection that must implement this protocol. For example,
-  the expression
-
-      Enum.map([1, 2, 3], &(&1 * 2))
-
-  invokes underneath `Enumerable.reduce/3` to perform the reducing
-  operation that builds a mapped list by calling the mapping function
-  `&(&1 * 2)` on every element in the collection and cons'ing the
-  element with an accumulated list.
+  is usually a collection that must implement this protocol.
+  For example, the expression `Enum.map([1, 2, 3], &(&1 * 2))`
+  invokes `Enumerable.reduce/3` to perform the reducing operation that
+  builds a mapped list by calling the mapping function `&(&1 * 2)` on
+  every element in the collection and consuming the element with an
+  accumulated list.
 
   Internally, `Enum.map/2` is implemented as follows:
 
-      def map(enum, fun) do
-        reducer = fn x, acc -> {:cont, [fun.(x)|acc]} end
-        Enumerable.reduce(enum, {:cont, []}, reducer) |> elem(1) |> :lists.reverse()
+      def map(enumerable, fun) do
+        reducer = fn x, acc -> {:cont, [fun.(x) | acc]} end
+        Enumerable.reduce(enumerable, {:cont, []}, reducer) |> elem(1) |> :lists.reverse()
+      end
+
+  Note that the user-supplied function is wrapped into a `t:reducer/0` function.
+  The `t:reducer/0` function must return a tagged tuple after each step,
+  as described in the `t:acc/0` type. At the end, `Enumerable.reduce/3`
+  returns `t:result/0`.
+
+  This protocol uses tagged tuples to exchange information between the
+  reducer function and the data type that implements the protocol. This
+  allows enumeration of resources, such as files, to be done efficiently
+  while also guaranteeing the resource will be closed at the end of the
+  enumeration. This protocol also allows suspension of the enumeration,
+  which is useful when interleaving between many enumerables is required
+  (as in the `zip/1` and `zip/2` functions).
+
+  This protocol requires four functions to be implemented, `reduce/3`,
+  `count/1`, `member?/2`, and `slice/1`. The core of the protocol is the
+  `reduce/3` function. All other functions exist as optimizations paths
+  for data structures that can implement certain properties in better
+  than linear time.
+
+  ## Default implementation for lists
+
+  Sometimes you may want to implement this protocol for a list contained
+  in struct. This can be done by delegating to the `Enumerable.List` module
+  in the `reduce/3` implementation and providing a straight-forward
+  implementation for the remaining ones:
+
+      defimpl Enumerable, for: CustomStruct do
+        def count(struct), do: {:ok, length(struct.items)}
+        def member?(struct, value), do: {:ok, value in struct.items}
+        def slice(struct), do: {:error, __MODULE__}
+        def reduce(struct, acc, fun), do: Enumerable.List.reduce(struct.items, acc, fun)
       end
+  """
+
+  @typedoc """
+  An enumerable of elements of type `element`.
 
-  Notice the user given function is wrapped into a `reducer` function.
-  The `reducer` function must return a tagged tuple after each step,
-  as described in the `acc/0` type.
+  This type is equivalent to `t:t/0` but is especially useful for documentation.
 
-  The reason the accumulator requires a tagged tuple is to allow the
-  reducer function to communicate to the underlying enumerable the end
-  of enumeration, allowing any open resource to be properly closed. It
-  also allows suspension of the enumeration, which is useful when
-  interleaving between many enumerables is required (as in zip).
+  For example, imagine you define a function that expects an enumerable of
+  integers and returns an enumerable of strings:
+
+      @spec integers_to_strings(Enumerable.t(integer())) :: Enumerable.t(String.t())
+      def integers_to_strings(integers) do
+        Stream.map(integers, &Integer.to_string/1)
+      end
 
-  Finally, `Enumerable.reduce/3` will return another tagged tuple,
-  as represented by the `result/0` type.
   """
+  @typedoc since: "1.14.0"
+  @type t(_element) :: t()
 
   @typedoc """
   The accumulator value for each step.
@@ -44,10 +82,10 @@ defprotocol Enumerable do
     * `:suspend` - the enumeration should be suspended immediately
 
   Depending on the accumulator value, the result returned by
-  `Enumerable.reduce/3` will change. Please check the `result`
-  type docs for more information.
+  `Enumerable.reduce/3` will change. Please check the `t:result/0`
+  type documentation for more information.
 
-  In case a reducer function returns a `:suspend` accumulator,
+  In case a `t:reducer/0` function returns a `:suspend` accumulator,
   it must be explicitly handled by the caller and never leak.
   """
   @type acc :: {:cont, term} | {:halt, term} | {:suspend, term}
@@ -55,28 +93,37 @@ defprotocol Enumerable do
   @typedoc """
   The reducer function.
 
-  Should be called with the collection element and the
-  accumulator contents. Returns the accumulator for
-  the next enumeration step.
+  Should be called with the `enumerable` element and the
+  accumulator contents.
+
+  Returns the accumulator for the next enumeration step.
   """
-  @type reducer :: (term, term -> acc)
+  @type reducer :: (element :: term, element_acc :: term -> acc)
 
   @typedoc """
   The result of the reduce operation.
 
   It may be *done* when the enumeration is finished by reaching
   its end, or *halted*/*suspended* when the enumeration was halted
-  or suspended by the reducer function.
-
-  In case a reducer function returns the `:suspend` accumulator, the
-  `:suspended` tuple must be explicitly handled by the caller and
-  never leak. In practice, this means regular enumeration functions
-  just need to be concerned about `:done` and `:halted` results.
-
-  Furthermore, a `:suspend` call must always be followed by another call,
-  eventually halting or continuing until the end.
+  or suspended by the tagged accumulator.
+
+  In case the tagged `:halt` accumulator is given, the `:halted` tuple
+  with the accumulator must be returned. Functions like `Enum.take_while/2`
+  use `:halt` underneath and can be used to test halting enumerables.
+
+  In case the tagged `:suspend` accumulator is given, the caller must
+  return the `:suspended` tuple with the accumulator and a continuation.
+  The caller is then responsible of managing the continuation and the
+  caller must always call the continuation, eventually halting or continuing
+  until the end. `Enum.zip/2` uses suspension, so it can be used to test
+  whether your implementation handles suspension correctly. You can also use
+  `Stream.zip/2` with `Enum.take_while/2` to test the combination of
+  `:suspend` with `:halt`.
   """
-  @type result :: {:done, term} | {:halted, term} | {:suspended, term, continuation}
+  @type result ::
+          {:done, term}
+          | {:halted, term}
+          | {:suspended, term, continuation}
 
   @typedoc """
   A partially applied reduce function.
@@ -85,192 +132,350 @@ defprotocol Enumerable do
   the enumeration is suspended. When invoked, it expects
   a new accumulator and it returns the result.
 
-  A continuation is easily implemented as long as the reduce
+  A continuation can be trivially implemented as long as the reduce
   function is defined in a tail recursive fashion. If the function
   is tail recursive, all the state is passed as arguments, so
-  the continuation would simply be the reducing function partially
-  applied.
+  the continuation is the reducing function partially applied.
   """
   @type continuation :: (acc -> result)
 
+  @typedoc """
+  A slicing function that receives the initial position,
+  the number of elements in the slice, and the step.
+
+  The `start` position is a number `>= 0` and guaranteed to
+  exist in the `enumerable`. The length is a number `>= 1`
+  in a way that `start + length * step <= count`, where
+  `count` is the maximum amount of elements in the enumerable.
+
+  The function should return a non empty list where
+  the amount of elements is equal to `length`.
+  """
+  @type slicing_fun ::
+          (start :: non_neg_integer, length :: pos_integer, step :: pos_integer -> [term()])
+
+  @typedoc """
+  Receives an enumerable and returns a list.
+  """
+  @type to_list_fun :: (t -> [term()])
+
   @doc """
-  Reduces the collection into a value.
+  Reduces the `enumerable` into an element.
 
   Most of the operations in `Enum` are implemented in terms of reduce.
-  This function should apply the given `reducer` function to each
-  item in the collection and proceed as expected by the returned accumulator.
+  This function should apply the given `t:reducer/0` function to each
+  element in the `enumerable` and proceed as expected by the returned
+  accumulator.
+
+  See the documentation of the types `t:result/0` and `t:acc/0` for
+  more information.
+
+  ## Examples
 
   As an example, here is the implementation of `reduce` for lists:
 
-      def reduce(_,     {:halt, acc}, _fun),   do: {:halted, acc}
-      def reduce(list,  {:suspend, acc}, fun), do: {:suspended, acc, &reduce(list, &1, fun)}
-      def reduce([],    {:cont, acc}, _fun),   do: {:done, acc}
-      def reduce([h|t], {:cont, acc}, fun),    do: reduce(t, fun.(h, acc), fun)
+      def reduce(_list, {:halt, acc}, _fun), do: {:halted, acc}
+      def reduce(list, {:suspend, acc}, fun), do: {:suspended, acc, &reduce(list, &1, fun)}
+      def reduce([], {:cont, acc}, _fun), do: {:done, acc}
+      def reduce([head | tail], {:cont, acc}, fun), do: reduce(tail, fun.(head, acc), fun)
 
   """
   @spec reduce(t, acc, reducer) :: result
-  def reduce(collection, acc, fun)
+  def reduce(enumerable, acc, fun)
 
   @doc """
-  Checks if a value exists within the collection.
+  Retrieves the number of elements in the `enumerable`.
 
-  It should return `{:ok, boolean}`.
+  It should return `{:ok, count}` if you can count the number of elements
+  in `enumerable` in a faster way than fully traversing it.
 
-  If `{:error, __MODULE__}` is returned a default algorithm using `reduce` and
-  the match (`===`) operator is used. This algorithm runs in linear time.
+  Otherwise it should return `{:error, __MODULE__}` and a default algorithm
+  built on top of `reduce/3` that runs in linear time will be used.
+  """
+  @spec count(t) :: {:ok, non_neg_integer} | {:error, module}
+  def count(enumerable)
+
+  @doc """
+  Checks if an `element` exists within the `enumerable`.
 
-  Please force use of the default algorithm unless you can implement an
-  algorithm that is significantly faster.
+  It should return `{:ok, boolean}` if you can check the membership of a
+  given element in `enumerable` with `===/2` without traversing the whole
+  of it.
+
+  Otherwise it should return `{:error, __MODULE__}` and a default algorithm
+  built on top of `reduce/3` that runs in linear time will be used.
+
+  When called outside guards, the [`in`](`in/2`) and [`not in`](`in/2`)
+  operators work by using this function.
   """
   @spec member?(t, term) :: {:ok, boolean} | {:error, module}
-  def member?(collection, value)
+  def member?(enumerable, element)
 
   @doc """
-  Retrieves the collection's size.
+  Returns a function that slices the data structure contiguously.
+
+  It should return either:
+
+    * `{:ok, size, slicing_fun}` - if the `enumerable` has a known
+      bound and can access a position in the `enumerable` without
+      traversing all previous elements. The `slicing_fun` will receive
+      a `start` position, the `amount` of elements to fetch, and a
+      `step`.
 
-  It should return `{:ok, size}`.
+    * `{:ok, size, to_list_fun}` - if the `enumerable` has a known bound
+      and can access a position in the `enumerable` by first converting
+      it to a list via `to_list_fun`.
 
-  If `{:error, __MODULE__}` is returned a default algorithm using `reduce` and
-  the match (`===`) operator is used. This algorithm runs in linear time.
+    * `{:error, __MODULE__}` - the enumerable cannot be sliced efficiently
+      and a default algorithm built on top of `reduce/3` that runs in
+      linear time will be used.
 
-  Please force use of the default algorithm unless you can implement an
-  algorithm that is significantly faster.
+  ## Differences to `count/1`
+
+  The `size` value returned by this function is used for boundary checks,
+  therefore it is extremely important that this function only returns `:ok`
+  if retrieving the `size` of the `enumerable` is cheap, fast, and takes
+  constant time. Otherwise the simplest of operations, such as
+  `Enum.at(enumerable, 0)`, will become too expensive.
+
+  On the other hand, the `count/1` function in this protocol should be
+  implemented whenever you can count the number of elements in the collection
+  without traversing it.
   """
-  @spec count(t) :: {:ok, non_neg_integer} | {:error, module}
-  def count(collection)
+  @spec slice(t) ::
+          {:ok, size :: non_neg_integer(), slicing_fun() | to_list_fun()}
+          | {:error, module()}
+  def slice(enumerable)
 end
 
 defmodule Enum do
   import Kernel, except: [max: 2, min: 2]
 
   @moduledoc """
-  Provides a set of algorithms that enumerate over collections according to the
-  `Enumerable` protocol:
-
-      iex> Enum.map([1, 2, 3], fn(x) -> x * 2 end)
-      [2,4,6]
+  Functions for working with collections (known as enumerables).
 
-  Some particular types, like dictionaries, yield a specific format on
-  enumeration. For dicts, the argument is always a `{key, value}` tuple:
+  In Elixir, an enumerable is any data type that implements the
+  `Enumerable` protocol. `List`s (`[1, 2, 3]`), `Map`s (`%{foo: 1, bar: 2}`)
+  and `Range`s (`1..3`) are common data types used as enumerables:
 
-      iex> dict = %{a: 1, b: 2}
-      iex> Enum.map(dict, fn {k, v} -> {k, v * 2} end)
-      [a: 2, b: 4]
+      iex> Enum.map([1, 2, 3], fn x -> x * 2 end)
+      [2, 4, 6]
 
-  Note that the functions in the `Enum` module are eager: they always start
-  the enumeration of the given collection. The `Stream` module allows
-  lazy enumeration of collections and provides infinite streams.
+      iex> Enum.sum([1, 2, 3])
+      6
 
-  Since the majority of the functions in `Enum` enumerate the whole
-  collection and return a list as result, infinite streams need to
-  be carefully used with such functions, as they can potentially run
-  forever. For example:
+      iex> Enum.map(1..3, fn x -> x * 2 end)
+      [2, 4, 6]
 
-      Enum.each Stream.cycle([1,2,3]), &IO.puts(&1)
+      iex> Enum.sum(1..3)
+      6
 
+      iex> map = %{"a" => 1, "b" => 2}
+      iex> Enum.map(map, fn {k, v} -> {k, v * 2} end)
+      [{"a", 2}, {"b", 4}]
+
+  Many other enumerables exist in the language, such as `MapSet`s
+  and the data type returned by `File.stream!/3` which allows a file to be
+  traversed as if it was an enumerable.
+
+  For a general overview of all functions in the `Enum` module, see
+  [the `Enum` cheatsheet](enum-cheat.cheatmd).
+
+  The functions in this module work in linear time. This means that, the
+  time it takes to perform an operation grows at the same rate as the length
+  of the enumerable. This is expected on operations such as `Enum.map/2`.
+  After all, if we want to traverse every element on a list, the longer the
+  list, the more elements we need to traverse, and the longer it will take.
+
+  This linear behavior should also be expected on operations like `count/1`,
+  `member?/2`, `at/2` and similar. While Elixir does allow data types to
+  provide performant variants for such operations, you should not expect it
+  to always be available, since the `Enum` module is meant to work with a
+  large variety of data types and not all data types can provide optimized
+  behavior.
+
+  Finally, note the functions in the `Enum` module are eager: they will
+  traverse the enumerable as soon as they are invoked. This is particularly
+  dangerous when working with infinite enumerables. In such cases, you should
+  use the `Stream` module, which allows you to lazily express computations,
+  without traversing collections, and work with possibly infinite collections.
+  See the `Stream` module for examples and documentation.
   """
 
   @compile :inline_list_funcs
 
-  @type t :: Enumerable.t
+  @type t :: Enumerable.t()
+  @type acc :: any
   @type element :: any
-  @type index :: non_neg_integer
+
+  @typedoc "Zero-based index. It can also be a negative integer."
+  @type index :: integer
+
   @type default :: any
 
-  # Require Stream.Reducers and its callbacks
   require Stream.Reducers, as: R
 
-  defmacrop cont(_, entry, acc) do
-    quote do: {:cont, [unquote(entry)|unquote(acc)]}
+  defmacrop skip(acc) do
+    acc
+  end
+
+  defmacrop next(_, entry, acc) do
+    quote(do: [unquote(entry) | unquote(acc)])
   end
 
-  defmacrop acc(h, n, _) do
-    quote do: {unquote(h), unquote(n)}
+  defmacrop acc(head, state, _) do
+    quote(do: {unquote(head), unquote(state)})
   end
 
-  defmacrop cont_with_acc(f, entry, h, n, _) do
+  defmacrop next_with_acc(_, entry, head, state, _) do
     quote do
-      {:cont, {[unquote(entry)|unquote(h)], unquote(n)}}
+      {[unquote(entry) | unquote(head)], unquote(state)}
     end
   end
 
   @doc """
-  Invokes the given `fun` for each item in the `collection` and returns `false`
-  if at least one invocation returns `false`. Otherwise returns `true`.
+  Returns `true` if all elements in `enumerable` are truthy.
+
+  When an element has a falsy value (`false` or `nil`) iteration stops immediately
+  and `false` is returned. In all other cases `true` is returned.
 
   ## Examples
 
-      iex> Enum.all?([2, 4, 6], fn(x) -> rem(x, 2) == 0 end)
+      iex> Enum.all?([1, 2, 3])
       true
 
-      iex> Enum.all?([2, 3, 4], fn(x) -> rem(x, 2) == 0 end)
+      iex> Enum.all?([1, nil, 3])
       false
 
-  If no function is given, it defaults to checking if
-  all items in the collection evaluate to `true`.
+      iex> Enum.all?([])
+      true
 
-      iex> Enum.all?([1, 2, 3])
+  """
+  @spec all?(t) :: boolean
+  def all?(enumerable) when is_list(enumerable) do
+    all_list(enumerable)
+  end
+
+  def all?(enumerable) do
+    Enumerable.reduce(enumerable, {:cont, true}, fn entry, _ ->
+      if entry, do: {:cont, true}, else: {:halt, false}
+    end)
+    |> elem(1)
+  end
+
+  @doc """
+  Returns `true` if `fun.(element)` is truthy for all elements in `enumerable`.
+
+  Iterates over `enumerable` and invokes `fun` on each element. If `fun` ever
+  returns a falsy value (`false` or `nil`), iteration stops immediately and
+  `false` is returned. Otherwise, `true` is returned.
+
+  ## Examples
+
+      iex> Enum.all?([2, 4, 6], fn x -> rem(x, 2) == 0 end)
       true
 
-      iex> Enum.all?([1, nil, 3])
+      iex> Enum.all?([2, 3, 4], fn x -> rem(x, 2) == 0 end)
       false
 
+      iex> Enum.all?([], fn _ -> nil end)
+      true
+
+  As the last example shows, `Enum.all?/2` returns `true` if `enumerable` is
+  empty, regardless of `fun`. In an empty enumerable there is no element for
+  which `fun` returns a falsy value, so the result must be `true`. This is a
+  well-defined logical argument for empty collections.
+
   """
-  @spec all?(t) :: boolean
   @spec all?(t, (element -> as_boolean(term))) :: boolean
+  def all?(enumerable, fun) when is_list(enumerable) do
+    predicate_list(enumerable, true, fun)
+  end
 
-  def all?(collection, fun \\ fn(x) -> x end)
-
-  def all?(collection, fun) when is_list(collection) do
-    do_all?(collection, fun)
+  def all?(first..last//step, fun) do
+    predicate_range(first, last, step, true, fun)
   end
 
-  def all?(collection, fun) do
-    Enumerable.reduce(collection, {:cont, true}, fn(entry, _) ->
+  def all?(enumerable, fun) do
+    Enumerable.reduce(enumerable, {:cont, true}, fn entry, _ ->
       if fun.(entry), do: {:cont, true}, else: {:halt, false}
-    end) |> elem(1)
+    end)
+    |> elem(1)
   end
 
   @doc """
-  Invokes the given `fun` for each item in the `collection` and returns `true` if
-  at least one invocation returns `true`. Returns `false` otherwise.
+  Returns `true` if at least one element in `enumerable` is truthy.
+
+  When an element has a truthy value (neither `false` nor `nil`) iteration stops
+  immediately and `true` is returned. In all other cases `false` is returned.
 
   ## Examples
 
-      iex> Enum.any?([2, 4, 6], fn(x) -> rem(x, 2) == 1 end)
+      iex> Enum.any?([false, false, false])
       false
 
-      iex> Enum.any?([2, 3, 4], fn(x) -> rem(x, 2) == 1 end)
+      iex> Enum.any?([false, true, false])
       true
 
-  If no function is given, it defaults to checking if
-  at least one item in the collection evaluates to `true`.
+      iex> Enum.any?([])
+      false
 
-      iex> Enum.any?([false, false, false])
+  """
+  @spec any?(t) :: boolean
+  def any?(enumerable) when is_list(enumerable) do
+    any_list(enumerable)
+  end
+
+  def any?(enumerable) do
+    Enumerable.reduce(enumerable, {:cont, false}, fn entry, _ ->
+      if entry, do: {:halt, true}, else: {:cont, false}
+    end)
+    |> elem(1)
+  end
+
+  @doc """
+  Returns `true` if `fun.(element)` is truthy for at least one element in `enumerable`.
+
+  Iterates over the `enumerable` and invokes `fun` on each element. When an invocation
+  of `fun` returns a truthy value (neither `false` nor `nil`) iteration stops
+  immediately and `true` is returned. In all other cases `false` is returned.
+
+  ## Examples
+
+      iex> Enum.any?([2, 4, 6], fn x -> rem(x, 2) == 1 end)
       false
 
-      iex> Enum.any?([false, true, false])
+      iex> Enum.any?([2, 3, 4], fn x -> rem(x, 2) == 1 end)
       true
 
+      iex> Enum.any?([], fn x -> x > 0 end)
+      false
+
   """
-  @spec any?(t) :: boolean
   @spec any?(t, (element -> as_boolean(term))) :: boolean
+  def any?(enumerable, fun) when is_list(enumerable) do
+    predicate_list(enumerable, false, fun)
+  end
 
-  def any?(collection, fun \\ fn(x) -> x end)
-
-  def any?(collection, fun) when is_list(collection) do
-    do_any?(collection, fun)
+  def any?(first..last//step, fun) do
+    predicate_range(first, last, step, false, fun)
   end
 
-  def any?(collection, fun) do
-    Enumerable.reduce(collection, {:cont, false}, fn(entry, _) ->
+  def any?(enumerable, fun) do
+    Enumerable.reduce(enumerable, {:cont, false}, fn entry, _ ->
       if fun.(entry), do: {:halt, true}, else: {:cont, false}
-    end) |> elem(1)
+    end)
+    |> elem(1)
   end
 
   @doc """
-  Finds the element at the given index (zero-based).
-  Returns `default` if index is out of bounds.
+  Finds the element at the given `index` (zero-based).
+
+  Returns `default` if `index` is out of bounds.
+
+  A negative `index` can be passed, which means the `enumerable` is
+  enumerated once and the `index` is counted from the end (for example,
+  `-1` finds the last element).
 
   ## Examples
 
@@ -287,67 +492,155 @@ defmodule Enum do
       :none
 
   """
-  @spec at(t, integer) :: element | nil
-  @spec at(t, integer, default) :: element | default
-  def at(collection, n, default \\ nil) do
-    case fetch(collection, n) do
-      {:ok, h} -> h
-      :error     -> default
+  @spec at(t, index, default) :: element | default
+  def at(enumerable, index, default \\ nil) when is_integer(index) do
+    case slice_forward(enumerable, index, 1, 1) do
+      [value] -> value
+      [] -> default
     end
   end
 
+  @doc false
+  @deprecated "Use Enum.chunk_every/2 instead"
+  def chunk(enumerable, count), do: chunk(enumerable, count, count, nil)
+
+  @doc false
+  @deprecated "Use Enum.chunk_every/3 instead"
+  def chunk(enum, n, step) do
+    chunk_every(enum, n, step, :discard)
+  end
+
+  @doc false
+  @deprecated "Use Enum.chunk_every/4 instead"
+  def chunk(enumerable, count, step, leftover) do
+    chunk_every(enumerable, count, step, leftover || :discard)
+  end
+
   @doc """
-  Shortcut to `chunk(coll, n, n)`.
+  Shortcut to `chunk_every(enumerable, count, count)`.
   """
-  @spec chunk(t, non_neg_integer) :: [list]
-  def chunk(coll, n), do: chunk(coll, n, n, nil)
+  @doc since: "1.5.0"
+  @spec chunk_every(t, pos_integer) :: [list]
+  def chunk_every(enumerable, count), do: chunk_every(enumerable, count, count, [])
 
   @doc """
-  Returns a collection of lists containing `n` items each, where
-  each new chunk starts `step` elements into the collection.
+  Returns list of lists containing `count` elements each, where
+  each new chunk starts `step` elements into the `enumerable`.
+
+  `step` is optional and, if not passed, defaults to `count`, i.e.
+  chunks do not overlap. Chunking will stop as soon as the collection
+  ends or when we emit an incomplete chunk.
+
+  If the last chunk does not have `count` elements to fill the chunk,
+  elements are taken from `leftover` to fill in the chunk. If `leftover`
+  does not have enough elements to fill the chunk, then a partial chunk
+  is returned with less than `count` elements.
 
-  `step` is optional and, if not passed, defaults to `n`, i.e.
-  chunks do not overlap. If the final chunk does not have `n`
-  elements to fill the chunk, elements are taken as necessary
-  from `pad` if it was passed. If `pad` is passed and does not
-  have enough elements to fill the chunk, then the chunk is
-  returned anyway with less than `n` elements. If `pad` is not
-  passed at all or is `nil`, then the partial chunk is discarded
-  from the result.
+  If `:discard` is given in `leftover`, the last chunk is discarded
+  unless it has exactly `count` elements.
 
   ## Examples
 
-      iex> Enum.chunk([1, 2, 3, 4, 5, 6], 2)
+      iex> Enum.chunk_every([1, 2, 3, 4, 5, 6], 2)
       [[1, 2], [3, 4], [5, 6]]
 
-      iex> Enum.chunk([1, 2, 3, 4, 5, 6], 3, 2)
+      iex> Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard)
       [[1, 2, 3], [3, 4, 5]]
 
-      iex> Enum.chunk([1, 2, 3, 4, 5, 6], 3, 2, [7])
+      iex> Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, [7])
       [[1, 2, 3], [3, 4, 5], [5, 6, 7]]
 
-      iex> Enum.chunk([1, 2, 3, 4, 5, 6], 3, 3, [])
-      [[1, 2, 3], [4, 5, 6]]
+      iex> Enum.chunk_every([1, 2, 3, 4], 3, 3, [])
+      [[1, 2, 3], [4]]
+
+      iex> Enum.chunk_every([1, 2, 3, 4], 10)
+      [[1, 2, 3, 4]]
+
+      iex> Enum.chunk_every([1, 2, 3, 4, 5], 2, 3, [])
+      [[1, 2], [4, 5]]
+
+      iex> Enum.chunk_every([1, 2, 3, 4], 3, 3, Stream.cycle([0]))
+      [[1, 2, 3], [4, 0, 0]]
 
   """
-  @spec chunk(t, non_neg_integer, non_neg_integer) :: [list]
-  @spec chunk(t, non_neg_integer, non_neg_integer, t | nil) :: [list]
-  def chunk(coll, n, step, pad \\ nil) when n > 0 and step > 0 do
-    limit = :erlang.max(n, step)
+  @doc since: "1.5.0"
+  @spec chunk_every(t, pos_integer, pos_integer, t | :discard) :: [list]
+  def chunk_every(enumerable, count, step, leftover \\ [])
+      when is_integer(count) and count > 0 and is_integer(step) and step > 0 do
+    R.chunk_every(&chunk_while/4, enumerable, count, step, leftover)
+  end
 
-    {_, {acc, {buffer, i}}} =
-      Enumerable.reduce(coll, {:cont, {[], {[], 0}}}, R.chunk(n, step, limit))
+  @doc """
+  Chunks the `enumerable` with fine grained control when every chunk is emitted.
 
-    if nil?(pad) || i == 0 do
-      :lists.reverse(acc)
-    else
-      buffer = :lists.reverse(buffer) ++ take(pad, n - i)
-      :lists.reverse([buffer|acc])
+  `chunk_fun` receives the current element and the accumulator and must return:
+
+    * `{:cont, chunk, acc}` to emit a chunk and continue with the accumulator
+    * `{:cont, acc}` to not emit any chunk and continue with the accumulator
+    * `{:halt, acc}` to halt chunking over the `enumerable`.
+
+  `after_fun` is invoked with the final accumulator when iteration is
+  finished (or `halt`ed) to handle any trailing elements that were returned
+  as part of an accumulator, but were not emitted as a chunk by `chunk_fun`.
+  It must return:
+
+    * `{:cont, chunk, acc}` to emit a chunk. The chunk will be appended to the
+      list of already emitted chunks.
+    * `{:cont, acc}` to not emit a chunk
+
+  The `acc` in `after_fun` is required in order to mirror the tuple format
+  from `chunk_fun` but it will be discarded since the traversal is complete.
+
+  Returns a list of emitted chunks.
+
+  ## Examples
+
+      iex> chunk_fun = fn element, acc ->
+      ...>   if rem(element, 2) == 0 do
+      ...>     {:cont, Enum.reverse([element | acc]), []}
+      ...>   else
+      ...>     {:cont, [element | acc]}
+      ...>   end
+      ...> end
+      iex> after_fun = fn
+      ...>   [] -> {:cont, []}
+      ...>   acc -> {:cont, Enum.reverse(acc), []}
+      ...> end
+      iex> Enum.chunk_while(1..10, [], chunk_fun, after_fun)
+      [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
+      iex> Enum.chunk_while([1, 2, 3, 5, 7], [], chunk_fun, after_fun)
+      [[1, 2], [3, 5, 7]]
+
+  """
+  @doc since: "1.5.0"
+  @spec chunk_while(
+          t,
+          acc,
+          (element, acc -> {:cont, chunk, acc} | {:cont, acc} | {:halt, acc}),
+          (acc -> {:cont, chunk, acc} | {:cont, acc})
+        ) :: Enumerable.t()
+        when chunk: any
+  def chunk_while(enumerable, acc, chunk_fun, after_fun) do
+    {_, {res, acc}} =
+      Enumerable.reduce(enumerable, {:cont, {[], acc}}, fn entry, {buffer, acc} ->
+        case chunk_fun.(entry, acc) do
+          {:cont, chunk, acc} -> {:cont, {[chunk | buffer], acc}}
+          {:cont, acc} -> {:cont, {buffer, acc}}
+          {:halt, acc} -> {:halt, {buffer, acc}}
+        end
+      end)
+
+    case after_fun.(acc) do
+      {:cont, _acc} -> :lists.reverse(res)
+      {:cont, chunk, _acc} -> :lists.reverse([chunk | res])
     end
   end
 
   @doc """
-  Splits `coll` on every element for which `fun` returns a new value.
+  Splits enumerable on every element for which `fun` returns a new
+  value.
+
+  Returns a list of lists.
 
   ## Examples
 
@@ -356,47 +649,48 @@ defmodule Enum do
 
   """
   @spec chunk_by(t, (element -> any)) :: [list]
-  def chunk_by(coll, fun) do
-    {_, {acc, res}} =
-      Enumerable.reduce(coll, {:cont, {[], nil}}, R.chunk_by(fun))
-
-    case res do
-      {buffer, _} ->
-        :lists.reverse([:lists.reverse(buffer) | acc])
-      nil ->
-        []
-    end
+  def chunk_by(enumerable, fun) do
+    R.chunk_by(&chunk_while/4, enumerable, fun)
   end
 
   @doc """
-  Given an enumerable of enumerables, concatenate the enumerables into a single list.
+  Given an enumerable of enumerables, concatenates the `enumerables` into
+  a single list.
 
   ## Examples
 
       iex> Enum.concat([1..3, 4..6, 7..9])
-      [1,2,3,4,5,6,7,8,9]
+      [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
       iex> Enum.concat([[1, [2], 3], [4], [5, 6]])
-      [1,[2],3,4,5,6]
+      [1, [2], 3, 4, 5, 6]
 
   """
   @spec concat(t) :: t
-  def concat(enumerables) do
-    do_concat(enumerables)
+  def concat(enumerables)
+
+  def concat(list) when is_list(list) do
+    concat_list(list)
+  end
+
+  def concat(enums) do
+    concat_enum(enums)
   end
 
   @doc """
-  Concatenates the enumerable on the right with the enumerable on the left.
+  Concatenates the enumerable on the `right` with the enumerable on the
+  `left`.
 
-  This function produces the same result as the `Kernel.++/2` operator for lists.
+  This function produces the same result as the `++/2` operator
+  for lists.
 
   ## Examples
 
       iex> Enum.concat(1..3, 4..6)
-      [1,2,3,4,5,6]
+      [1, 2, 3, 4, 5, 6]
 
       iex> Enum.concat([1, 2, 3], [4, 5, 6])
-      [1,2,3,4,5,6]
+      [1, 2, 3, 4, 5, 6]
 
   """
   @spec concat(t, t) :: t
@@ -405,16 +699,11 @@ defmodule Enum do
   end
 
   def concat(left, right) do
-    do_concat([left, right])
-  end
-
-  defp do_concat(enumerable) do
-    fun = &[&1|&2]
-    reduce(enumerable, [], &reduce(&1, &2, fun)) |> :lists.reverse
+    concat_enum([left, right])
   end
 
   @doc """
-  Returns the collection's size.
+  Returns the size of the `enumerable`.
 
   ## Examples
 
@@ -423,45 +712,156 @@ defmodule Enum do
 
   """
   @spec count(t) :: non_neg_integer
-  def count(collection) when is_list(collection) do
-    :erlang.length(collection)
+  def count(enumerable) when is_list(enumerable) do
+    length(enumerable)
   end
 
-  def count(collection) do
-    case Enumerable.count(collection) do
+  def count(enumerable) do
+    case Enumerable.count(enumerable) do
       {:ok, value} when is_integer(value) ->
         value
+
       {:error, module} ->
-        module.reduce(collection, {:cont, 0}, fn
-          _, acc -> {:cont, acc + 1}
-        end) |> elem(1)
+        enumerable |> module.reduce({:cont, 0}, fn _, acc -> {:cont, acc + 1} end) |> elem(1)
     end
   end
 
   @doc """
-  Returns the count of items in the collection for which
-  `fun` returns `true`.
+  Returns the count of elements in the `enumerable` for which `fun` returns
+  a truthy value.
 
   ## Examples
 
-      iex> Enum.count([1, 2, 3, 4, 5], fn(x) -> rem(x, 2) == 0 end)
+      iex> Enum.count([1, 2, 3, 4, 5], fn x -> rem(x, 2) == 0 end)
       2
 
   """
   @spec count(t, (element -> as_boolean(term))) :: non_neg_integer
-  def count(collection, fun) do
-    Enumerable.reduce(collection, {:cont, 0}, fn(entry, acc) ->
-      {:cont, if(fun.(entry), do: acc + 1, else: acc)}
-    end) |> elem(1)
+  def count(enumerable, fun) do
+    reduce(enumerable, 0, fn entry, acc ->
+      if(fun.(entry), do: acc + 1, else: acc)
+    end)
+  end
+
+  @doc """
+  Counts the enumerable stopping at `limit`.
+
+  This is useful for checking certain properties of the count of an enumerable
+  without having to actually count the entire enumerable. For example, if you
+  wanted to check that the count was exactly, at least, or more than a value.
+
+  If the enumerable implements `c:Enumerable.count/1`, the enumerable is
+  not traversed and we return the lower of the two numbers. To force
+  enumeration, use `count_until/3` with `fn _ -> true end` as the second
+  argument.
+
+  ## Examples
+
+      iex> Enum.count_until(1..20, 5)
+      5
+      iex> Enum.count_until(1..20, 50)
+      20
+      iex> Enum.count_until(1..10, 10) == 10 # At least 10
+      true
+      iex> Enum.count_until(1..11, 10 + 1) > 10 # More than 10
+      true
+      iex> Enum.count_until(1..5, 10) < 10 # Less than 10
+      true
+      iex> Enum.count_until(1..10, 10 + 1) == 10 # Exactly ten
+      true
+
+  """
+  @doc since: "1.12.0"
+  @spec count_until(t, pos_integer) :: non_neg_integer
+  def count_until(enumerable, limit) when is_integer(limit) and limit > 0 do
+    case enumerable do
+      list when is_list(list) -> count_until_list(list, limit, 0)
+      _ -> count_until_enum(enumerable, limit)
+    end
+  end
+
+  @doc """
+  Counts the elements in the enumerable for which `fun` returns a truthy value, stopping at `limit`.
+
+  See `count/2` and `count_until/2` for more information.
+
+  ## Examples
+
+      iex> Enum.count_until(1..20, fn x -> rem(x, 2) == 0 end, 7)
+      7
+      iex> Enum.count_until(1..20, fn x -> rem(x, 2) == 0 end, 11)
+      10
+  """
+  @doc since: "1.12.0"
+  @spec count_until(t, (element -> as_boolean(term)), pos_integer) :: non_neg_integer
+  def count_until(enumerable, fun, limit) when is_integer(limit) and limit > 0 do
+    case enumerable do
+      list when is_list(list) -> count_until_list(list, fun, limit, 0)
+      _ -> count_until_enum(enumerable, fun, limit)
+    end
+  end
+
+  @doc """
+  Enumerates the `enumerable`, returning a list where all consecutive
+  duplicate elements are collapsed to a single element.
+
+  Elements are compared using `===/2`.
+
+  If you want to remove all duplicate elements, regardless of order,
+  see `uniq/1`.
+
+  ## Examples
+
+      iex> Enum.dedup([1, 2, 3, 3, 2, 1])
+      [1, 2, 3, 2, 1]
+
+      iex> Enum.dedup([1, 1, 2, 2.0, :three, :three])
+      [1, 2, 2.0, :three]
+
+  """
+  @spec dedup(t) :: list
+  def dedup(enumerable) when is_list(enumerable) do
+    dedup_list(enumerable, []) |> :lists.reverse()
+  end
+
+  def dedup(enumerable) do
+    reduce(enumerable, [], fn x, acc ->
+      case acc do
+        [^x | _] -> acc
+        _ -> [x | acc]
+      end
+    end)
+    |> :lists.reverse()
+  end
+
+  @doc """
+  Enumerates the `enumerable`, returning a list where all consecutive
+  duplicate elements are collapsed to a single element.
+
+  The function `fun` maps every element to a term which is used to
+  determine if two elements are duplicates.
+
+  ## Examples
+
+      iex> Enum.dedup_by([{1, :a}, {2, :b}, {2, :c}, {1, :a}], fn {x, _} -> x end)
+      [{1, :a}, {2, :b}, {1, :a}]
+
+      iex> Enum.dedup_by([5, 1, 2, 3, 2, 1], fn x -> x > 2 end)
+      [5, 1, 3, 2]
+
+  """
+  @spec dedup_by(t, (element -> term)) :: list
+  def dedup_by(enumerable, fun) do
+    {list, _} = reduce(enumerable, {[], []}, R.dedup(fun))
+    :lists.reverse(list)
   end
 
   @doc """
-  Drops the first `count` items from `collection`.
+  Drops the `amount` of elements from the `enumerable`.
 
-  If a negative value `count` is given, the last `count`
-  values will be dropped. The collection is enumerated
-  once to retrieve the proper index and the remaining
-  calculation is performed from the end.
+  If a negative `amount` is given, the `amount` of last values will be dropped.
+  The `enumerable` will be enumerated once to retrieve the proper index and
+  the remaining calculation is performed from the end.
 
   ## Examples
 
@@ -472,79 +872,122 @@ defmodule Enum do
       []
 
       iex> Enum.drop([1, 2, 3], 0)
-      [1,2,3]
+      [1, 2, 3]
 
       iex> Enum.drop([1, 2, 3], -1)
-      [1,2]
+      [1, 2]
 
   """
   @spec drop(t, integer) :: list
-  def drop(collection, count) when is_list(collection) and count >= 0 do
-    do_drop(collection, count)
+  def drop(enumerable, amount)
+      when is_list(enumerable) and is_integer(amount) and amount >= 0 do
+    drop_list(enumerable, amount)
   end
 
-  def drop(collection, count) when count >= 0 do
-    res =
-      reduce(collection, count, fn
-        x, acc when is_list(acc) -> [x|acc]
-        x, 0                     -> [x]
-        _, acc when acc > 0      -> acc - 1
-      end)
-    if is_list(res), do: :lists.reverse(res), else: []
+  def drop(enumerable, 0) do
+    to_list(enumerable)
+  end
+
+  def drop(enumerable, amount) when is_integer(amount) and amount > 0 do
+    {result, _} = reduce(enumerable, {[], amount}, R.drop())
+    if is_list(result), do: :lists.reverse(result), else: []
+  end
+
+  def drop(enumerable, amount) when is_integer(amount) and amount < 0 do
+    {count, fun} = slice_count_and_fun(enumerable, 1)
+    amount = Kernel.min(amount + count, count)
+
+    if amount > 0 do
+      fun.(0, amount, 1)
+    else
+      []
+    end
   end
 
-  def drop(collection, count) when count < 0 do
-    do_drop(reverse(collection), abs(count)) |> :lists.reverse
+  @doc """
+  Returns a list of every `nth` element in the `enumerable` dropped,
+  starting with the first element.
+
+  The first element is always dropped, unless `nth` is 0.
+
+  The second argument specifying every `nth` element must be a non-negative
+  integer.
+
+  ## Examples
+
+      iex> Enum.drop_every(1..10, 2)
+      [2, 4, 6, 8, 10]
+
+      iex> Enum.drop_every(1..10, 0)
+      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+      iex> Enum.drop_every([1, 2, 3], 1)
+      []
+
+  """
+  @spec drop_every(t, non_neg_integer) :: list
+  def drop_every(enumerable, nth)
+
+  def drop_every(_enumerable, 1), do: []
+  def drop_every(enumerable, 0), do: to_list(enumerable)
+  def drop_every([], nth) when is_integer(nth), do: []
+
+  def drop_every(enumerable, nth) when is_integer(nth) and nth > 1 do
+    {res, _} = reduce(enumerable, {[], :first}, R.drop_every(nth))
+    :lists.reverse(res)
   end
 
   @doc """
-  Drops items at the beginning of `collection` while `fun` returns `true`.
+  Drops elements at the beginning of the `enumerable` while `fun` returns a
+  truthy value.
 
   ## Examples
 
-      iex> Enum.drop_while([1, 2, 3, 4, 5], fn(x) -> x < 3 end)
-      [3,4,5]
+      iex> Enum.drop_while([1, 2, 3, 2, 1], fn x -> x < 3 end)
+      [3, 2, 1]
 
   """
   @spec drop_while(t, (element -> as_boolean(term))) :: list
-  def drop_while(collection, fun) when is_list(collection) do
-    do_drop_while(collection, fun)
+  def drop_while(enumerable, fun) when is_list(enumerable) do
+    drop_while_list(enumerable, fun)
   end
 
-  def drop_while(collection, fun) do
-    {_, {res, _}} =
-      Enumerable.reduce(collection, {:cont, {[], true}}, R.drop_while(fun))
+  def drop_while(enumerable, fun) do
+    {res, _} = reduce(enumerable, {[], true}, R.drop_while(fun))
     :lists.reverse(res)
   end
 
   @doc """
-  Invokes the given `fun` for each item in the `collection`.
+  Invokes the given `fun` for each element in the `enumerable`.
+
   Returns `:ok`.
 
   ## Examples
 
-      Enum.each(["some", "example"], fn(x) -> IO.puts x end)
+      Enum.each(["some", "example"], fn x -> IO.puts(x) end)
       "some"
       "example"
       #=> :ok
 
   """
   @spec each(t, (element -> any)) :: :ok
-  def each(collection, fun) when is_list(collection) do
-    :lists.foreach(fun, collection)
-    :ok
+  def each(enumerable, fun) when is_list(enumerable) do
+    :lists.foreach(fun, enumerable)
   end
 
-  def each(collection, fun) do
-    reduce(collection, nil, fn(entry, _) ->
+  def each(enumerable, fun) do
+    reduce(enumerable, nil, fn entry, _ ->
       fun.(entry)
       nil
     end)
+
     :ok
   end
 
   @doc """
-  Returns `true` if the collection is empty, otherwise `false`.
+  Determines if the `enumerable` is empty.
+
+  Returns `true` if `enumerable` is empty, otherwise `false`.
 
   ## Examples
 
@@ -556,20 +999,29 @@ defmodule Enum do
 
   """
   @spec empty?(t) :: boolean
-  def empty?(collection) when is_list(collection) do
-    collection == []
+  def empty?(enumerable) when is_list(enumerable) do
+    enumerable == []
   end
 
-  def empty?(collection) do
-    Enumerable.reduce(collection, {:cont, true}, fn(_, _) -> {:halt, false} end) |> elem(1)
+  def empty?(enumerable) do
+    case Enumerable.slice(enumerable) do
+      {:ok, value, _} ->
+        value == 0
+
+      {:error, module} ->
+        enumerable
+        |> module.reduce({:cont, true}, fn _, _ -> {:halt, false} end)
+        |> elem(1)
+    end
   end
 
   @doc """
-  Finds the element at the given index (zero-based).
+  Finds the element at the given `index` (zero-based).
+
   Returns `{:ok, element}` if found, otherwise `:error`.
 
-  A negative index can be passed, which means the collection is
-  enumerated once and the index is counted from the end (i.e.
+  A negative `index` can be passed, which means the `enumerable` is
+  enumerated once and the `index` is counted from the end (for example,
   `-1` fetches the last element).
 
   ## Examples
@@ -577,6 +1029,9 @@ defmodule Enum do
       iex> Enum.fetch([2, 4, 6], 0)
       {:ok, 2}
 
+      iex> Enum.fetch([2, 4, 6], -3)
+      {:ok, 2}
+
       iex> Enum.fetch([2, 4, 6], 2)
       {:ok, 6}
 
@@ -584,35 +1039,19 @@ defmodule Enum do
       :error
 
   """
-  @spec fetch(t, integer) :: {:ok, element} | :error
-  def fetch(collection, n) when is_list(collection) and n >= 0 do
-    do_fetch(collection, n)
-  end
-
-  def fetch(collection, n) when n >= 0 do
-    res =
-      Enumerable.reduce(collection, {:cont, 0}, fn(entry, acc) ->
-        if acc == n do
-          {:halt, entry}
-        else
-          {:cont, acc + 1}
-        end
-      end)
-
-    case res do
-      {:halted, entry} -> {:ok, entry}
-      {:done, _} -> :error
+  @spec fetch(t, index) :: {:ok, element} | :error
+  def fetch(enumerable, index) when is_integer(index) do
+    case slice_forward(enumerable, index, 1, 1) do
+      [value] -> {:ok, value}
+      [] -> :error
     end
   end
 
-  def fetch(collection, n) when n < 0 do
-    do_fetch(reverse(collection), abs(n + 1))
-  end
-
   @doc """
-  Finds the element at the given index (zero-based).
-  Raises `OutOfBoundsError` if the given position
-  is outside the range of the collection.
+  Finds the element at the given `index` (zero-based).
+
+  Raises `OutOfBoundsError` if the given `index` is outside the range of
+  the `enumerable`.
 
   ## Examples
 
@@ -623,195 +1062,260 @@ defmodule Enum do
       6
 
       iex> Enum.fetch!([2, 4, 6], 4)
-      ** (Enum.OutOfBoundsError) out of bounds error
+      ** (Enum.OutOfBoundsError) out of bounds error at position 4 when traversing enumerable [2, 4, 6]
 
   """
-  @spec fetch!(t, integer) :: element | no_return
-  def fetch!(collection, n) do
-    case fetch(collection, n) do
-      {:ok, h} -> h
-      :error     -> raise Enum.OutOfBoundsError
+  @spec fetch!(t, index) :: element
+  def fetch!(enumerable, index) when is_integer(index) do
+    case slice_forward(enumerable, index, 1, 1) do
+      [value] -> value
+      [] -> raise Enum.OutOfBoundsError, index: index, enumerable: enumerable
     end
   end
 
   @doc """
-  Filters the collection, i.e. returns only those elements
-  for which `fun` returns `true`.
+  Filters the `enumerable`, i.e. returns only those elements
+  for which `fun` returns a truthy value.
+
+  See also `reject/2` which discards all elements where the
+  function returns a truthy value.
 
   ## Examples
 
-      iex> Enum.filter([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
+      iex> Enum.filter([1, 2, 3], fn x -> rem(x, 2) == 0 end)
       [2]
+      iex> Enum.filter(["apple", "pear", "banana"], fn fruit -> String.contains?(fruit, "a") end)
+      ["apple", "pear", "banana"]
+      iex> Enum.filter([4, 21, 24, 904], fn seconds -> seconds > 1000 end)
+      []
+
+  Keep in mind that `filter` is not capable of filtering and
+  transforming an element at the same time. If you would like
+  to do so, consider using `flat_map/2`. For example, if you
+  want to convert all strings that represent an integer and
+  discard the invalid one in one pass:
+
+      strings = ["1234", "abc", "12ab"]
+
+      Enum.flat_map(strings, fn string ->
+        case Integer.parse(string) do
+          # transform to integer
+          {int, _rest} -> [int]
+          # skip the value
+          :error -> []
+        end
+      end)
 
   """
   @spec filter(t, (element -> as_boolean(term))) :: list
-  def filter(collection, fun) when is_list(collection) do
-    for item <- collection, fun.(item), do: item
+  def filter(enumerable, fun) when is_list(enumerable) do
+    filter_list(enumerable, fun)
   end
 
-  def filter(collection, fun) do
-    Enumerable.reduce(collection, {:cont, []}, R.filter(fun))
-    |> elem(1) |> :lists.reverse
+  def filter(enumerable, fun) do
+    reduce(enumerable, [], R.filter(fun)) |> :lists.reverse()
   end
 
-  @doc """
-  Filters the collection and maps its values in one pass.
-
-  ## Examples
-
-      iex> Enum.filter_map([1, 2, 3], fn(x) -> rem(x, 2) == 0 end, &(&1 * 2))
-      [4]
-
-  """
-  @spec filter_map(t, (element -> as_boolean(term)), (element -> element)) :: list
-  def filter_map(collection, filter, mapper) when is_list(collection) do
-    for item <- collection, filter.(item), do: mapper.(item)
+  @doc false
+  @deprecated "Use Enum.filter/2 + Enum.map/2 or for comprehensions instead"
+  def filter_map(enumerable, filter, mapper) when is_list(enumerable) do
+    for element <- enumerable, filter.(element), do: mapper.(element)
   end
 
-  def filter_map(collection, filter, mapper) do
-    Enumerable.reduce(collection, {:cont, []}, R.filter_map(filter, mapper))
-    |> elem(1) |> :lists.reverse
+  def filter_map(enumerable, filter, mapper) do
+    enumerable
+    |> reduce([], R.filter_map(filter, mapper))
+    |> :lists.reverse()
   end
 
   @doc """
-  Returns the first item for which `fun` returns a truthy value. If no such
-  item is found, returns `ifnone`.
+  Returns the first element for which `fun` returns a truthy value.
+  If no such element is found, returns `default`.
 
   ## Examples
 
-      iex> Enum.find([2, 4, 6], fn(x) -> rem(x, 2) == 1 end)
-      nil
+      iex> Enum.find([2, 3, 4], fn x -> rem(x, 2) == 1 end)
+      3
 
-      iex> Enum.find([2, 4, 6], 0, fn(x) -> rem(x, 2) == 1 end)
+      iex> Enum.find([2, 4, 6], fn x -> rem(x, 2) == 1 end)
+      nil
+      iex> Enum.find([2, 4, 6], 0, fn x -> rem(x, 2) == 1 end)
       0
 
-      iex> Enum.find([2, 3, 4], fn(x) -> rem(x, 2) == 1 end)
-      3
-
   """
-  @spec find(t, (element -> any)) :: element | nil
   @spec find(t, default, (element -> any)) :: element | default
-  def find(collection, ifnone \\ nil, fun)
+  def find(enumerable, default \\ nil, fun)
 
-  def find(collection, ifnone, fun) when is_list(collection) do
-    do_find(collection, ifnone, fun)
+  def find(enumerable, default, fun) when is_list(enumerable) do
+    find_list(enumerable, default, fun)
   end
 
-  def find(collection, ifnone, fun) do
-    Enumerable.reduce(collection, {:cont, ifnone}, fn(entry, ifnone) ->
-      if fun.(entry), do: {:halt, entry}, else: {:cont, ifnone}
-    end) |> elem(1)
+  def find(enumerable, default, fun) do
+    Enumerable.reduce(enumerable, {:cont, default}, fn entry, default ->
+      if fun.(entry), do: {:halt, entry}, else: {:cont, default}
+    end)
+    |> elem(1)
   end
 
   @doc """
-  Similar to `find/3`, but returns the value of the function
-  invocation instead of the element itself.
+  Similar to `find/3`, but returns the index (zero-based)
+  of the element instead of the element itself.
 
   ## Examples
 
-      iex> Enum.find_value([2, 4, 6], fn(x) -> rem(x, 2) == 1 end)
+      iex> Enum.find_index([2, 4, 6], fn x -> rem(x, 2) == 1 end)
       nil
 
-      iex> Enum.find_value([2, 3, 4], fn(x) -> rem(x, 2) == 1 end)
-      true
+      iex> Enum.find_index([2, 3, 4], fn x -> rem(x, 2) == 1 end)
+      1
 
   """
-  @spec find_value(t, (element -> any)) :: any | :nil
-  @spec find_value(t, any, (element -> any)) :: any | :nil
-  def find_value(collection, ifnone \\ nil, fun)
-
-  def find_value(collection, ifnone, fun) when is_list(collection) do
-    do_find_value(collection, ifnone, fun)
+  @spec find_index(t, (element -> any)) :: non_neg_integer | nil
+  def find_index(enumerable, fun) when is_list(enumerable) do
+    find_index_list(enumerable, 0, fun)
   end
 
-  def find_value(collection, ifnone, fun) do
-    Enumerable.reduce(collection, {:cont, ifnone}, fn(entry, ifnone) ->
-      fun_entry = fun.(entry)
-      if fun_entry, do: {:halt, fun_entry}, else: {:cont, ifnone}
-    end) |> elem(1)
+  def find_index(enumerable, fun) do
+    result =
+      Enumerable.reduce(enumerable, {:cont, {:not_found, 0}}, fn entry, {_, index} ->
+        if fun.(entry), do: {:halt, {:found, index}}, else: {:cont, {:not_found, index + 1}}
+      end)
+
+    case elem(result, 1) do
+      {:found, index} -> index
+      {:not_found, _} -> nil
+    end
   end
 
   @doc """
-  Similar to `find/3`, but returns the index (zero-based)
-  of the element instead of the element itself.
+  Similar to `find/3`, but returns the value of the function
+  invocation instead of the element itself.
+
+  The return value is considered to be found when the result is truthy
+  (neither `nil` nor `false`).
 
   ## Examples
 
-      iex> Enum.find_index([2, 4, 6], fn(x) -> rem(x, 2) == 1 end)
+      iex> Enum.find_value([2, 3, 4], fn x ->
+      ...>   if x > 2, do: x * x
+      ...> end)
+      9
+
+      iex> Enum.find_value([2, 4, 6], fn x -> rem(x, 2) == 1 end)
       nil
 
-      iex> Enum.find_index([2, 3, 4], fn(x) -> rem(x, 2) == 1 end)
-      1
+      iex> Enum.find_value([2, 3, 4], fn x -> rem(x, 2) == 1 end)
+      true
+
+      iex> Enum.find_value([1, 2, 3], "no bools!", &is_boolean/1)
+      "no bools!"
 
   """
-  @spec find_index(t, (element -> any)) :: index | :nil
-  def find_index(collection, fun) when is_list(collection) do
-    do_find_index(collection, 0, fun)
-  end
+  @spec find_value(t, default, (element -> found_value)) :: found_value | default
+        when found_value: term
+  def find_value(enumerable, default \\ nil, fun)
 
-  def find_index(collection, fun) do
-    res =
-      Enumerable.reduce(collection, {:cont, 0}, fn(entry, acc) ->
-        if fun.(entry), do: {:halt, acc}, else: {:cont, acc + 1}
-      end)
+  def find_value(enumerable, default, fun) when is_list(enumerable) do
+    find_value_list(enumerable, default, fun)
+  end
 
-    case res do
-      {:halted, entry} -> entry
-      {:done, _} -> nil
-    end
+  def find_value(enumerable, default, fun) do
+    Enumerable.reduce(enumerable, {:cont, default}, fn entry, default ->
+      fun_entry = fun.(entry)
+      if fun_entry, do: {:halt, fun_entry}, else: {:cont, default}
+    end)
+    |> elem(1)
   end
 
   @doc """
-  Returns a new collection appending the result of invoking `fun`
-  on each corresponding item of `collection`.
+  Maps the given `fun` over `enumerable` and flattens the result only one level deep.
 
-  The given function should return an enumerable.
+  This function returns a new enumerable built by appending the result of invoking `fun`
+  on each element of `enumerable` together; conceptually, this is similar to a
+  combination of `map/2` and `concat/1`.
 
   ## Examples
 
-      iex> Enum.flat_map([:a, :b, :c], fn(x) -> [x, x] end)
+      iex> Enum.flat_map([:a, :b, :c], fn x -> [x, x] end)
       [:a, :a, :b, :b, :c, :c]
 
-      iex> Enum.flat_map([{1,3}, {4,6}], fn({x,y}) -> x..y end)
+      iex> Enum.flat_map([{1, 3}, {4, 6}], fn {x, y} -> x..y end)
       [1, 2, 3, 4, 5, 6]
 
+      iex> Enum.flat_map([:a, :b, :c], fn x -> [[x]] end)
+      [[:a], [:b], [:c]]
+
+  This is frequently used to to transform and filter in one pass, returning empty
+  lists to exclude results:
+
+      iex> Enum.flat_map([4, 0, 2, 0], fn x ->
+      ...>   if x != 0, do: [1 / x], else: []
+      ...> end)
+      [0.25, 0.5]
+
   """
   @spec flat_map(t, (element -> t)) :: list
-  def flat_map(collection, fun) do
-    reduce(collection, [], fn(entry, acc) ->
-      reduce(fun.(entry), acc, &[&1|&2])
-    end) |> :lists.reverse
+  def flat_map(enumerable, fun) when is_list(enumerable) do
+    flat_map_list(enumerable, fun)
+  end
+
+  def flat_map(enumerable, fun) do
+    reduce(enumerable, [], fn entry, acc ->
+      case fun.(entry) do
+        [] -> acc
+        list when is_list(list) -> [list | acc]
+        other -> [to_list(other) | acc]
+      end
+    end)
+    |> flat_reverse([])
   end
 
+  # the first clause is an optimization
+  defp flat_reverse([[elem] | t], acc), do: flat_reverse(t, [elem | acc])
+  defp flat_reverse([h | t], acc), do: flat_reverse(t, h ++ acc)
+  defp flat_reverse([], acc), do: acc
+
   @doc """
-  Maps and reduces a collection, flattening the given results.
+  Maps and reduces an `enumerable`, flattening the results only one level deep.
 
-  It expects an accumulator and a function that receives each stream item
-  and an accumulator, and must return a tuple containing a new stream
-  (often a list) with the new accumulator or a tuple with `:halt` as first
-  element and the accumulator as second.
+  It expects an accumulator and a function that receives each enumerable
+  element, and must return a tuple containing a new enumerable (often a list)
+  with the new accumulator or a tuple with `:halt` as first element and
+  the accumulator as second.
+
+  Returns a 2-element tuple where the first element is the results flattened one level deep and
+  the second element is the last accumulator.
 
   ## Examples
 
-      iex> enum = 1..100
+      iex> enumerable = 1..100
       iex> n = 3
-      iex> Enum.flat_map_reduce(enum, 0, fn i, acc ->
-      ...>   if acc < n, do: {[i], acc + 1}, else: {:halt, acc}
+      iex> Enum.flat_map_reduce(enumerable, 0, fn x, acc ->
+      ...>   if acc < n, do: {[x], acc + 1}, else: {:halt, acc}
       ...> end)
-      {[1,2,3], 3}
+      {[1, 2, 3], 3}
+
+      iex> Enum.flat_map_reduce(1..5, 0, fn x, acc -> {[[x]], acc + x} end)
+      {[[1], [2], [3], [4], [5]], 15}
 
   """
-  @spec flat_map_reduce(t, acc, fun) :: {[any], any} when
-        fun: (element, acc -> {t, acc} | {:halt, acc}),
-        acc: any
-  def flat_map_reduce(collection, acc, fun) do
+  @spec flat_map_reduce(t, acc, fun) :: {[any], acc}
+        when fun: (element, acc -> {t, acc} | {:halt, acc})
+  def flat_map_reduce(enumerable, acc, fun) do
     {_, {list, acc}} =
-      Enumerable.reduce(collection, {:cont, {[], acc}}, fn(entry, {list, acc}) ->
+      Enumerable.reduce(enumerable, {:cont, {[], acc}}, fn entry, {list, acc} ->
         case fun.(entry, acc) do
           {:halt, acc} ->
             {:halt, {list, acc}}
+
+          {[], acc} ->
+            {:cont, {list, acc}}
+
+          {[entry], acc} ->
+            {:cont, {[entry | list], acc}}
+
           {entries, acc} ->
-            {:cont, {reduce(entries, list, &[&1|&2]), acc}}
+            {:cont, {reduce(entries, list, &[&1 | &2]), acc}}
         end
       end)
 
@@ -819,9 +1323,126 @@ defmodule Enum do
   end
 
   @doc """
-  Intersperses `element` between each element of the enumeration.
+  Returns a map with keys as unique elements of `enumerable` and values
+  as the count of every element.
+
+  ## Examples
+
+      iex> Enum.frequencies(~w{ant buffalo ant ant buffalo dingo})
+      %{"ant" => 3, "buffalo" => 2, "dingo" => 1}
+
+  """
+  @doc since: "1.10.0"
+  @spec frequencies(t) :: map
+  def frequencies(enumerable) do
+    reduce(enumerable, %{}, fn key, acc ->
+      case acc do
+        %{^key => value} -> %{acc | key => value + 1}
+        %{} -> Map.put(acc, key, 1)
+      end
+    end)
+  end
+
+  @doc """
+  Returns a map with keys as unique elements given by `key_fun` and values
+  as the count of every element.
+
+  ## Examples
+
+      iex> Enum.frequencies_by(~w{aa aA bb cc}, &String.downcase/1)
+      %{"aa" => 2, "bb" => 1, "cc" => 1}
+
+      iex> Enum.frequencies_by(~w{aaa aA bbb cc c}, &String.length/1)
+      %{3 => 2, 2 => 2, 1 => 1}
+
+  """
+  @doc since: "1.10.0"
+  @spec frequencies_by(t, (element -> any)) :: map
+  def frequencies_by(enumerable, key_fun) when is_function(key_fun) do
+    reduce(enumerable, %{}, fn entry, acc ->
+      key = key_fun.(entry)
+
+      case acc do
+        %{^key => value} -> %{acc | key => value + 1}
+        %{} -> Map.put(acc, key, 1)
+      end
+    end)
+  end
+
+  @doc """
+  Splits the `enumerable` into groups based on `key_fun`.
+
+  The result is a map where each key is given by `key_fun`
+  and each value is a list of elements given by `value_fun`.
+  The order of elements within each list is preserved from the `enumerable`.
+  However, like all maps, the resulting map is unordered.
+
+  ## Examples
+
+      iex> Enum.group_by(~w{ant buffalo cat dingo}, &String.length/1)
+      %{3 => ["ant", "cat"], 5 => ["dingo"], 7 => ["buffalo"]}
+
+      iex> Enum.group_by(~w{ant buffalo cat dingo}, &String.length/1, &String.first/1)
+      %{3 => ["a", "c"], 5 => ["d"], 7 => ["b"]}
+
+  The key can be any Elixir value. For example, you may use a tuple
+  to group by multiple keys:
+
+      iex> collection = [
+      ...>   %{id: 1, lang: "Elixir", seq: 1},
+      ...>   %{id: 1, lang: "Java", seq: 1},
+      ...>   %{id: 1, lang: "Ruby", seq: 2},
+      ...>   %{id: 2, lang: "Python", seq: 1},
+      ...>   %{id: 2, lang: "C#", seq: 2},
+      ...>   %{id: 2, lang: "Haskell", seq: 2},
+      ...> ]
+      iex> Enum.group_by(collection, &{&1.id, &1.seq})
+      %{
+        {1, 1} => [%{id: 1, lang: "Elixir", seq: 1}, %{id: 1, lang: "Java", seq: 1}],
+        {1, 2} => [%{id: 1, lang: "Ruby", seq: 2}],
+        {2, 1} => [%{id: 2, lang: "Python", seq: 1}],
+        {2, 2} => [%{id: 2, lang: "C#", seq: 2}, %{id: 2, lang: "Haskell", seq: 2}]
+      }
+      iex> Enum.group_by(collection, &{&1.id, &1.seq}, &{&1.id, &1.lang})
+      %{
+        {1, 1} => [{1, "Elixir"}, {1, "Java"}],
+        {1, 2} => [{1, "Ruby"}],
+        {2, 1} => [{2, "Python"}],
+        {2, 2} => [{2, "C#"}, {2, "Haskell"}]
+      }
+
+  """
+  @spec group_by(t, (element -> any), (element -> any)) :: map
+  def group_by(enumerable, key_fun, value_fun \\ fn x -> x end)
+
+  def group_by(enumerable, key_fun, value_fun) when is_function(key_fun) do
+    reduce(reverse(enumerable), %{}, fn entry, acc ->
+      key = key_fun.(entry)
+      value = value_fun.(entry)
+
+      case acc do
+        %{^key => existing} -> %{acc | key => [value | existing]}
+        %{} -> Map.put(acc, key, [value])
+      end
+    end)
+  end
+
+  def group_by(enumerable, dict, fun) do
+    IO.warn(
+      "Enum.group_by/3 with a map/dictionary as second element is deprecated. " <>
+        "A map is used by default and it is no longer required to pass one to this function"
+    )
+
+    # Avoid warnings about Dict
+    dict_module = String.to_atom("Dict")
 
-  Complexity: O(n)
+    reduce(reverse(enumerable), dict, fn entry, categories ->
+      dict_module.update(categories, fun.(entry), [entry], &[entry | &1])
+    end)
+  end
+
+  @doc """
+  Intersperses `separator` between each element of the enumeration.
 
   ## Examples
 
@@ -836,91 +1457,204 @@ defmodule Enum do
 
   """
   @spec intersperse(t, element) :: list
-  def intersperse(collection, element) do
+  def intersperse(enumerable, separator) when is_list(enumerable) do
+    case enumerable do
+      [] -> []
+      list -> intersperse_non_empty_list(list, separator)
+    end
+  end
+
+  def intersperse(enumerable, separator) do
     list =
-      reduce(collection, [], fn(x, acc) ->
-        [x, element | acc]
-      end) |> :lists.reverse()
+      enumerable
+      |> reduce([], fn x, acc -> [x, separator | acc] end)
+      |> :lists.reverse()
 
+    # Head is a superfluous separator
     case list do
-      []    -> []
-      [_|t] -> t  # Head is a superfluous intersperser element
+      [] -> []
+      [_ | t] -> t
     end
   end
 
   @doc """
-  Inserts the given enumerable into a collectable.
+  Inserts the given `enumerable` into a `collectable`.
+
+  Note that passing a non-empty list as the `collectable` is deprecated.
+  If you're collecting into a non-empty keyword list, consider using
+  `Keyword.merge(collectable, Enum.to_list(enumerable))`. If you're collecting
+  into a non-empty list, consider something like `Enum.to_list(enumerable) ++ collectable`.
 
   ## Examples
 
-      iex> Enum.into([1, 2], [0])
-      [0, 1, 2]
+      iex> Enum.into([1, 2], [])
+      [1, 2]
 
       iex> Enum.into([a: 1, b: 2], %{})
       %{a: 1, b: 2}
 
+      iex> Enum.into(%{a: 1}, %{b: 2})
+      %{a: 1, b: 2}
+
+      iex> Enum.into([a: 1, a: 2], %{})
+      %{a: 2}
+
+      iex> Enum.into([a: 2], %{a: 1, b: 3})
+      %{a: 2, b: 3}
+
   """
-  @spec into(Enumerable.t, Collectable.t) :: Collectable.t
-  def into(collection, list) when is_list(list) do
-    list ++ to_list(collection)
+  @spec into(Enumerable.t(), Collectable.t()) :: Collectable.t()
+  def into(enumerable, collectable)
+
+  def into(enumerable, []) do
+    to_list(enumerable)
+  end
+
+  def into(enumerable, collectable) when is_struct(collectable, MapSet) do
+    if MapSet.size(collectable) == 0 do
+      MapSet.new(enumerable)
+    else
+      MapSet.new(enumerable) |> MapSet.union(collectable)
+    end
+  end
+
+  def into(%_{} = enumerable, collectable) do
+    into_protocol(enumerable, collectable)
+  end
+
+  def into(enumerable, %_{} = collectable) do
+    into_protocol(enumerable, collectable)
+  end
+
+  def into(enumerable, %{} = collectable) do
+    if map_size(collectable) == 0 do
+      into_map(enumerable)
+    else
+      into_map(enumerable, collectable)
+    end
   end
 
-  def into(collection, %{} = map) when is_list(collection) and map_size(map) == 0 do
-    :maps.from_list(collection)
+  def into(enumerable, collectable) do
+    into_protocol(enumerable, collectable)
   end
 
-  def into(collection, collectable) do
+  defp into_map(%{} = enumerable), do: enumerable
+  defp into_map(enumerable) when is_list(enumerable), do: :maps.from_list(enumerable)
+  defp into_map(enumerable), do: enumerable |> Enum.to_list() |> :maps.from_list()
+
+  defp into_map(%{} = enumerable, collectable), do: Map.merge(collectable, enumerable)
+
+  defp into_map(enumerable, collectable) when is_list(enumerable),
+    do: Map.merge(collectable, :maps.from_list(enumerable))
+
+  defp into_map(enumerable, collectable),
+    do: reduce(enumerable, collectable, fn {key, val}, acc -> Map.put(acc, key, val) end)
+
+  defp into_protocol(enumerable, collectable) do
     {initial, fun} = Collectable.into(collectable)
-    into(collection, initial, fun, fn x, acc ->
-      fun.(acc, {:cont, x})
+
+    try do
+      reduce_into_protocol(enumerable, initial, fun)
+    catch
+      kind, reason ->
+        fun.(initial, :halt)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      acc -> fun.(acc, :done)
+    end
+  end
+
+  defp reduce_into_protocol(enumerable, initial, fun) when is_list(enumerable) do
+    :lists.foldl(fn x, acc -> fun.(acc, {:cont, x}) end, initial, enumerable)
+  end
+
+  defp reduce_into_protocol(enumerable, initial, fun) do
+    enumerable
+    |> Enumerable.reduce({:cont, initial}, fn x, acc ->
+      {:cont, fun.(acc, {:cont, x})}
     end)
+    |> elem(1)
   end
 
   @doc """
-  Inserts the given enumerable into a collectable
-  according to the transformation function.
+  Inserts the given `enumerable` into a `collectable` according to the
+  transformation function.
 
   ## Examples
 
-      iex> Enum.into([2, 3], [3], fn x -> x * 3 end)
+      iex> Enum.into([1, 2, 3], [], fn x -> x * 3 end)
       [3, 6, 9]
 
+      iex> Enum.into(%{a: 1, b: 2}, %{c: 3}, fn {k, v} -> {k, v * 2} end)
+      %{a: 2, b: 4, c: 3}
+
   """
-  @spec into(Enumerable.t, Collectable.t, (term -> term)) :: Collectable.t
+  @spec into(Enumerable.t(), Collectable.t(), (term -> term)) :: Collectable.t()
+  def into(enumerable, [], transform) do
+    map(enumerable, transform)
+  end
 
-  def into(collection, list, transform) when is_list(list) and is_function(transform, 1) do
-    list ++ map(collection, transform)
+  def into(enumerable, collectable, transform) when is_struct(collectable, MapSet) do
+    if MapSet.size(collectable) == 0 do
+      MapSet.new(enumerable, transform)
+    else
+      MapSet.new(enumerable, transform) |> MapSet.union(collectable)
+    end
   end
 
-  def into(collection, collectable, transform) when is_function(transform, 1) do
-    {initial, fun} = Collectable.into(collectable)
-    into(collection, initial, fun, fn x, acc ->
-      fun.(acc, {:cont, transform.(x)})
-    end)
+  def into(enumerable, %_{} = collectable, transform) do
+    into_protocol(enumerable, collectable, transform)
   end
 
-  defp into(collection, initial, fun, callback) do
+  def into(enumerable, %{} = collectable, transform) do
+    if map_size(collectable) == 0 do
+      enumerable |> map(transform) |> :maps.from_list()
+    else
+      reduce(enumerable, collectable, fn entry, acc ->
+        {key, val} = transform.(entry)
+        Map.put(acc, key, val)
+      end)
+    end
+  end
+
+  def into(enumerable, collectable, transform) do
+    into_protocol(enumerable, collectable, transform)
+  end
+
+  defp into_protocol(enumerable, collectable, transform) do
+    {initial, fun} = Collectable.into(collectable)
+
     try do
-      reduce(collection, initial, callback)
+      reduce_into_protocol(enumerable, initial, transform, fun)
     catch
       kind, reason ->
-        stacktrace = System.stacktrace
         fun.(initial, :halt)
-        :erlang.raise(kind, reason, stacktrace)
+        :erlang.raise(kind, reason, __STACKTRACE__)
     else
       acc -> fun.(acc, :done)
     end
   end
 
+  defp reduce_into_protocol(enumerable, initial, transform, fun) when is_list(enumerable) do
+    :lists.foldl(fn x, acc -> fun.(acc, {:cont, transform.(x)}) end, initial, enumerable)
+  end
+
+  defp reduce_into_protocol(enumerable, initial, transform, fun) do
+    enumerable
+    |> Enumerable.reduce({:cont, initial}, fn x, acc ->
+      {:cont, fun.(acc, {:cont, transform.(x)})}
+    end)
+    |> elem(1)
+  end
+
   @doc """
-  Joins the given `collection` according to `joiner`.
-  `joiner` can be either a binary or a list and the
-  result will be of the same type as `joiner`. If
-  `joiner` is not passed at all, it defaults to an
-  empty binary.
+  Joins the given `enumerable` into a string using `joiner` as a
+  separator.
 
-  All items in the collection must be convertible
-  to a binary, otherwise an error is raised.
+  If `joiner` is not passed at all, it defaults to an empty string.
+
+  All elements in the `enumerable` must be convertible to a string
+  or be a binary, otherwise an error is raised.
 
   ## Examples
 
@@ -930,347 +1664,887 @@ defmodule Enum do
       iex> Enum.join([1, 2, 3], " = ")
       "1 = 2 = 3"
 
+      iex> Enum.join([["a", "b"], ["c", "d", "e", ["f", "g"]], "h", "i"], " ")
+      "ab cdefg h i"
+
   """
-  @spec join(t) :: String.t
-  @spec join(t, String.t) :: String.t
-  def join(collection, joiner \\ "")
+  @spec join(t, binary()) :: binary()
+  def join(enumerable, joiner \\ "")
+
+  def join(enumerable, "") do
+    enumerable
+    |> map(&entry_to_string(&1))
+    |> IO.iodata_to_binary()
+  end
+
+  def join(enumerable, joiner) when is_list(enumerable) and is_binary(joiner) do
+    join_list(enumerable, joiner)
+  end
+
+  def join(enumerable, joiner) when is_binary(joiner) do
+    reduced =
+      reduce(enumerable, :first, fn
+        entry, :first -> entry_to_string(entry)
+        entry, acc -> [acc, joiner | entry_to_string(entry)]
+      end)
 
-  def join(collection, joiner) when is_binary(joiner) do
-    reduced = reduce(collection, :first, fn
-      entry, :first -> enum_to_string(entry)
-      entry, acc -> [acc, joiner|enum_to_string(entry)]
-    end)
     if reduced == :first do
       ""
     else
-      IO.iodata_to_binary reduced
+      IO.iodata_to_binary(reduced)
     end
   end
 
   @doc """
-  Returns a new collection, where each item is the result
-  of invoking `fun` on each corresponding item of `collection`.
+  Returns a list where each element is the result of invoking
+  `fun` on each corresponding element of `enumerable`.
 
-  For dicts, the function expects a key-value tuple.
+  For maps, the function expects a key-value tuple.
 
   ## Examples
 
-      iex> Enum.map([1, 2, 3], fn(x) -> x * 2 end)
+      iex> Enum.map([1, 2, 3], fn x -> x * 2 end)
       [2, 4, 6]
 
-      iex> Enum.map([a: 1, b: 2], fn({k, v}) -> {k, -v} end)
+      iex> Enum.map([a: 1, b: 2], fn {k, v} -> {k, -v} end)
       [a: -1, b: -2]
 
   """
   @spec map(t, (element -> any)) :: list
-  def map(collection, fun) when is_list(collection) do
-    for item <- collection, do: fun.(item)
+  def map(enumerable, fun)
+
+  def map(enumerable, fun) when is_list(enumerable) do
+    :lists.map(fun, enumerable)
   end
 
-  def map(collection, fun) do
-    Enumerable.reduce(collection, {:cont, []}, R.map(fun)) |> elem(1) |> :lists.reverse
+  def map(first..last//step, fun) do
+    map_range(first, last, step, fun)
+  end
+
+  def map(enumerable, fun) do
+    reduce(enumerable, [], R.map(fun)) |> :lists.reverse()
   end
 
   @doc """
-  Maps and joins the given `collection` in one pass.
-  `joiner` can be either a binary or a list and the
-  result will be of the same type as `joiner`. If
-  `joiner` is not passed at all, it defaults to an
-  empty binary.
+  Returns a list of results of invoking `fun` on every `nth`
+  element of `enumerable`, starting with the first element.
+
+  The first element is always passed to the given function, unless `nth` is `0`.
+
+  The second argument specifying every `nth` element must be a non-negative
+  integer.
 
-  All items in the collection must be convertible
-  to a binary, otherwise an error is raised.
+  If `nth` is `0`, then `enumerable` is directly converted to a list,
+  without `fun` being ever applied.
 
   ## Examples
 
-      iex> Enum.map_join([1, 2, 3], &(&1 * 2))
-      "246"
+      iex> Enum.map_every(1..10, 2, fn x -> x + 1000 end)
+      [1001, 2, 1003, 4, 1005, 6, 1007, 8, 1009, 10]
 
-      iex> Enum.map_join([1, 2, 3], " = ", &(&1 * 2))
-      "2 = 4 = 6"
+      iex> Enum.map_every(1..10, 3, fn x -> x + 1000 end)
+      [1001, 2, 3, 1004, 5, 6, 1007, 8, 9, 1010]
+
+      iex> Enum.map_every(1..5, 0, fn x -> x + 1000 end)
+      [1, 2, 3, 4, 5]
+
+      iex> Enum.map_every([1, 2, 3], 1, fn x -> x + 1000 end)
+      [1001, 1002, 1003]
 
   """
-  @spec map_join(t, (element -> any)) :: String.t
-  @spec map_join(t, String.t, (element -> any)) :: String.t
-  def map_join(collection, joiner \\ "", mapper)
+  @doc since: "1.4.0"
+  @spec map_every(t, non_neg_integer, (element -> any)) :: list
+  def map_every(enumerable, nth, fun)
 
-  def map_join(collection, joiner, mapper) when is_binary(joiner) do
-    reduced = reduce(collection, :first, fn
-      entry, :first -> enum_to_string(mapper.(entry))
-      entry, acc    -> [acc, joiner|enum_to_string(mapper.(entry))]
-    end)
+  def map_every(enumerable, 1, fun), do: map(enumerable, fun)
+  def map_every(enumerable, 0, _fun), do: to_list(enumerable)
+  def map_every([], nth, _fun) when is_integer(nth) and nth > 1, do: []
+
+  def map_every(enumerable, nth, fun) when is_integer(nth) and nth > 1 do
+    {res, _} = reduce(enumerable, {[], :first}, R.map_every(nth, fun))
+    :lists.reverse(res)
+  end
+
+  @doc """
+  Maps and intersperses the given enumerable in one pass.
+
+  ## Examples
+
+      iex> Enum.map_intersperse([1, 2, 3], :a, &(&1 * 2))
+      [2, :a, 4, :a, 6]
+  """
+  @doc since: "1.10.0"
+  @spec map_intersperse(t, element(), (element -> any())) :: list()
+  def map_intersperse(enumerable, separator, mapper)
+
+  def map_intersperse(enumerable, separator, mapper) when is_list(enumerable) do
+    map_intersperse_list(enumerable, separator, mapper)
+  end
+
+  def map_intersperse(enumerable, separator, mapper) do
+    reduced =
+      reduce(enumerable, :first, fn
+        entry, :first -> [mapper.(entry)]
+        entry, acc -> [mapper.(entry), separator | acc]
+      end)
 
     if reduced == :first do
-      ""
+      []
     else
-      IO.iodata_to_binary reduced
+      :lists.reverse(reduced)
     end
   end
 
   @doc """
-  Invokes the given `fun` for each item in the `collection`
-  while also keeping an accumulator. Returns a tuple where
-  the first element is the mapped collection and the second
-  one is the final accumulator.
+  Maps and joins the given `enumerable` in one pass.
+
+  If `joiner` is not passed at all, it defaults to an empty string.
+
+  All elements returned from invoking the `mapper` must be convertible to
+  a string, otherwise an error is raised.
+
+  ## Examples
+
+      iex> Enum.map_join([1, 2, 3], &(&1 * 2))
+      "246"
+
+      iex> Enum.map_join([1, 2, 3], " = ", &(&1 * 2))
+      "2 = 4 = 6"
+
+  """
+  @spec map_join(t, String.t(), (element -> String.Chars.t())) :: String.t()
+  def map_join(enumerable, joiner \\ "", mapper) when is_binary(joiner) do
+    enumerable
+    |> map_intersperse(joiner, &entry_to_string(mapper.(&1)))
+    |> IO.iodata_to_binary()
+  end
+
+  @doc """
+  Invokes the given function to each element in the `enumerable` to reduce
+  it to a single element, while keeping an accumulator.
+
+  Returns a tuple where the first element is the mapped enumerable and
+  the second one is the final accumulator.
 
-  For dicts, the first tuple element must be a `{key, value}`
-  tuple.
+  The function, `fun`, receives two arguments: the first one is the
+  element, and the second one is the accumulator. `fun` must return
+  a tuple with two elements in the form of `{result, accumulator}`.
+
+  For maps, the first tuple element must be a `{key, value}` tuple.
 
   ## Examples
 
-      iex> Enum.map_reduce([1, 2, 3], 0, fn(x, acc) -> {x * 2, x + acc} end)
+      iex> Enum.map_reduce([1, 2, 3], 0, fn x, acc -> {x * 2, x + acc} end)
       {[2, 4, 6], 6}
 
   """
-  @spec map_reduce(t, any, (element, any -> any)) :: any
-  def map_reduce(collection, acc, fun) when is_list(collection) do
-    :lists.mapfoldl(fun, acc, collection)
+  @spec map_reduce(t, acc, (element, acc -> {element, acc})) :: {list, acc}
+  def map_reduce(enumerable, acc, fun) when is_list(enumerable) do
+    :lists.mapfoldl(fun, acc, enumerable)
   end
 
-  def map_reduce(collection, acc, fun) do
-    {list, acc} = reduce(collection, {[], acc}, fn(entry, {list, acc}) ->
-      {new_entry, acc} = fun.(entry, acc)
-      {[new_entry|list], acc}
-    end)
+  def map_reduce(enumerable, acc, fun) do
+    {list, acc} =
+      reduce(enumerable, {[], acc}, fn entry, {list, acc} ->
+        {new_entry, acc} = fun.(entry, acc)
+        {[new_entry | list], acc}
+      end)
+
     {:lists.reverse(list), acc}
   end
 
+  @doc false
+  def max(list = [_ | _]), do: :lists.max(list)
+
+  @doc false
+  def max(list = [_ | _], empty_fallback) when is_function(empty_fallback, 0) do
+    :lists.max(list)
+  end
+
+  @doc false
+  @spec max(t, (-> empty_result)) :: element | empty_result when empty_result: any
+  def max(enumerable, empty_fallback) when is_function(empty_fallback, 0) do
+    max(enumerable, &>=/2, empty_fallback)
+  end
+
   @doc """
-  Returns the maximum value.
-  Raises `EmptyError` if the collection is empty.
+  Returns the maximal element in the `enumerable` according
+  to Erlang's term ordering.
+
+  By default, the comparison is done with the [`>=`](`>=/2`) sorter function.
+  If multiple elements are considered maximal, the first one that
+  was found is returned. If you want the last element considered
+  maximal to be returned, the sorter function should not return true
+  for equal elements.
+
+  If the enumerable is empty, the provided `empty_fallback` is called.
+  The default `empty_fallback` raises `Enum.EmptyError`.
 
   ## Examples
 
       iex> Enum.max([1, 2, 3])
       3
 
+  The fact this function uses Erlang's term ordering means that the comparison
+  is structural and not semantic. For example:
+
+      iex> Enum.max([~D[2017-03-31], ~D[2017-04-01]])
+      ~D[2017-03-31]
+
+  In the example above, `max/2` returned March 31st instead of April 1st
+  because the structural comparison compares the day before the year.
+  For this reason, most structs provide a "compare" function, such as
+  `Date.compare/2`, which receives two structs and returns `:lt` (less-than),
+  `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the
+  sorting function, Elixir will automatically use the `compare/2` function
+  of said module:
+
+      iex> Enum.max([~D[2017-03-31], ~D[2017-04-01]], Date)
+      ~D[2017-04-01]
+
+  Finally, if you don't want to raise on empty enumerables, you can pass
+  the empty fallback:
+
+      iex> Enum.max([], &>=/2, fn -> 0 end)
+      0
+
   """
-  @spec max(t) :: element | no_return
-  def max(collection) do
-    reduce(collection, &Kernel.max(&1, &2))
+  @spec max(t, (element, element -> boolean) | module()) ::
+          element | empty_result
+        when empty_result: any
+  @spec max(t, (element, element -> boolean) | module(), (-> empty_result)) ::
+          element | empty_result
+        when empty_result: any
+  def max(enumerable, sorter \\ &>=/2, empty_fallback \\ fn -> raise Enum.EmptyError end) do
+    aggregate(enumerable, max_sort_fun(sorter), empty_fallback)
+  end
+
+  defp max_sort_fun(sorter) when is_function(sorter, 2), do: sorter
+  defp max_sort_fun(module) when is_atom(module), do: &(module.compare(&1, &2) != :lt)
+
+  @doc false
+  @spec max_by(
+          t,
+          (element -> any),
+          (-> empty_result) | (element, element -> boolean) | module()
+        ) :: element | empty_result
+        when empty_result: any
+  def max_by(enumerable, fun, empty_fallback)
+      when is_function(fun, 1) and is_function(empty_fallback, 0) do
+    max_by(enumerable, fun, &>=/2, empty_fallback)
   end
 
   @doc """
-  Returns the maximum value as calculated by the given function.
-  Raises `EmptyError` if the collection is empty.
+  Returns the maximal element in the `enumerable` as calculated
+  by the given `fun`.
+
+  By default, the comparison is done with the [`>=`](`>=/2`) sorter function.
+  If multiple elements are considered maximal, the first one that
+  was found is returned. If you want the last element considered
+  maximal to be returned, the sorter function should not return true
+  for equal elements.
+
+  Calls the provided `empty_fallback` function and returns its value if
+  `enumerable` is empty. The default `empty_fallback` raises `Enum.EmptyError`.
 
   ## Examples
 
-      iex> Enum.max_by(["a", "aa", "aaa"], fn(x) -> String.length(x) end)
+      iex> Enum.max_by(["a", "aa", "aaa"], fn x -> String.length(x) end)
       "aaa"
 
-  """
-  @spec max_by(t, (element -> any)) :: element | no_return
-  def max_by([h|t], fun) do
-    reduce(t, {h, fun.(h)}, fn(entry, {_, fun_max} = old) ->
-      fun_entry = fun.(entry)
-      if(fun_entry > fun_max, do: {entry, fun_entry}, else: old)
-    end) |> elem(0)
-  end
-
-  def max_by([], _fun) do
-    raise Enum.EmptyError
-  end
+      iex> Enum.max_by(["a", "aa", "aaa", "b", "bbb"], &String.length/1)
+      "aaa"
 
-  def max_by(collection, fun) do
-    result =
-      reduce(collection, :first, fn
-        entry, {_, fun_max} = old ->
-          fun_entry = fun.(entry)
-          if(fun_entry > fun_max, do: {entry, fun_entry}, else: old)
-        entry, :first ->
-          {entry, fun.(entry)}
-      end)
+  The fact this function uses Erlang's term ordering means that the
+  comparison is structural and not semantic. Therefore, if you want
+  to compare structs, most structs provide a "compare" function, such as
+  `Date.compare/2`, which receives two structs and returns `:lt` (less-than),
+  `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the
+  sorting function, Elixir will automatically use the `compare/2` function
+  of said module:
+
+      iex> users = [
+      ...>   %{name: "Ellis", birthday: ~D[1943-05-11]},
+      ...>   %{name: "Lovelace", birthday: ~D[1815-12-10]},
+      ...>   %{name: "Turing", birthday: ~D[1912-06-23]}
+      ...> ]
+      iex> Enum.max_by(users, &(&1.birthday), Date)
+      %{name: "Ellis", birthday: ~D[1943-05-11]}
+
+  Finally, if you don't want to raise on empty enumerables, you can pass
+  the empty fallback:
+
+      iex> Enum.max_by([], &String.length/1, fn -> nil end)
+      nil
 
-    case result do
-      :first       -> raise Enum.EmptyError
-      {entry, _} -> entry
-    end
+  """
+  @spec max_by(
+          t,
+          (element -> any),
+          (element, element -> boolean) | module(),
+          (-> empty_result)
+        ) :: element | empty_result
+        when empty_result: any
+  def max_by(enumerable, fun, sorter \\ &>=/2, empty_fallback \\ fn -> raise Enum.EmptyError end)
+      when is_function(fun, 1) do
+    aggregate_by(enumerable, fun, max_sort_fun(sorter), empty_fallback)
   end
 
   @doc """
-  Checks if `value` exists within the `collection`.
+  Checks if `element` exists within the `enumerable`.
 
-  Membership is tested with the match (`===`) operator, although
-  enumerables like ranges may include floats inside the given
-  range.
+  Membership is tested with the match (`===/2`) operator.
 
   ## Examples
 
       iex> Enum.member?(1..10, 5)
       true
+      iex> Enum.member?(1..10, 5.0)
+      false
+
+      iex> Enum.member?([1.0, 2.0, 3.0], 2)
+      false
+      iex> Enum.member?([1.0, 2.0, 3.0], 2.000)
+      true
 
       iex> Enum.member?([:a, :b, :c], :d)
       false
 
+
+  When called outside guards, the [`in`](`in/2`) and [`not in`](`in/2`)
+  operators work by using this function.
   """
   @spec member?(t, element) :: boolean
-  def member?(collection, value) when is_list(collection) do
-    :lists.member(value, collection)
+  def member?(enumerable, element) when is_list(enumerable) do
+    :lists.member(element, enumerable)
   end
 
-  def member?(collection, value) do
-    case Enumerable.member?(collection, value) do
-      {:ok, value} when is_boolean(value) ->
-        value
+  def member?(enumerable, element) do
+    case Enumerable.member?(enumerable, element) do
+      {:ok, element} when is_boolean(element) ->
+        element
+
       {:error, module} ->
-        module.reduce(collection, {:cont, false}, fn
-          v, _ when v === value -> {:halt, true}
-          _, _                  -> {:cont, false}
-        end) |> elem(1)
+        module.reduce(enumerable, {:cont, false}, fn
+          v, _ when v === element -> {:halt, true}
+          _, _ -> {:cont, false}
+        end)
+        |> elem(1)
     end
   end
 
+  @doc false
+  def min(list = [_ | _]), do: :lists.min(list)
+
+  @doc false
+  def min(list = [_ | _], empty_fallback) when is_function(empty_fallback, 0) do
+    :lists.min(list)
+  end
+
+  @doc false
+  @spec min(t, (-> empty_result)) :: element | empty_result when empty_result: any
+  def min(enumerable, empty_fallback) when is_function(empty_fallback, 0) do
+    min(enumerable, &<=/2, empty_fallback)
+  end
+
   @doc """
-  Returns the minimum value.
-  Raises `EmptyError` if the collection is empty.
+  Returns the minimal element in the `enumerable` according
+  to Erlang's term ordering.
+
+  By default, the comparison is done with the [`<=`](`<=/2`) sorter function.
+  If multiple elements are considered minimal, the first one that
+  was found is returned. If you want the last element considered
+  minimal to be returned, the sorter function should not return true
+  for equal elements.
+
+  If the enumerable is empty, the provided `empty_fallback` is called.
+  The default `empty_fallback` raises `Enum.EmptyError`.
 
   ## Examples
 
       iex> Enum.min([1, 2, 3])
       1
 
+  The fact this function uses Erlang's term ordering means that the comparison
+  is structural and not semantic. For example:
+
+      iex> Enum.min([~D[2017-03-31], ~D[2017-04-01]])
+      ~D[2017-04-01]
+
+  In the example above, `min/2` returned April 1st instead of March 31st
+  because the structural comparison compares the day before the year.
+  For this reason, most structs provide a "compare" function, such as
+  `Date.compare/2`, which receives two structs and returns `:lt` (less-than),
+  `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the
+  sorting function, Elixir will automatically use the `compare/2` function
+  of said module:
+
+      iex> Enum.min([~D[2017-03-31], ~D[2017-04-01]], Date)
+      ~D[2017-03-31]
+
+  Finally, if you don't want to raise on empty enumerables, you can pass
+  the empty fallback:
+
+      iex> Enum.min([], fn -> 0 end)
+      0
+
   """
-  @spec min(t) :: element | no_return
-  def min(collection) do
-    reduce(collection, &Kernel.min(&1, &2))
+  @spec min(t, (element, element -> boolean) | module()) ::
+          element | empty_result
+        when empty_result: any
+  @spec min(t, (element, element -> boolean) | module(), (-> empty_result)) ::
+          element | empty_result
+        when empty_result: any
+  def min(enumerable, sorter \\ &<=/2, empty_fallback \\ fn -> raise Enum.EmptyError end) do
+    aggregate(enumerable, min_sort_fun(sorter), empty_fallback)
+  end
+
+  defp min_sort_fun(sorter) when is_function(sorter, 2), do: sorter
+  defp min_sort_fun(module) when is_atom(module), do: &(module.compare(&1, &2) != :gt)
+
+  @doc false
+  @spec min_by(
+          t,
+          (element -> any),
+          (-> empty_result) | (element, element -> boolean) | module()
+        ) :: element | empty_result
+        when empty_result: any
+  def min_by(enumerable, fun, empty_fallback)
+      when is_function(fun, 1) and is_function(empty_fallback, 0) do
+    min_by(enumerable, fun, &<=/2, empty_fallback)
   end
 
   @doc """
-  Returns the minimum value as calculated by the given function.
-  Raises `EmptyError` if the collection is empty.
+  Returns the minimal element in the `enumerable` as calculated
+  by the given `fun`.
+
+  By default, the comparison is done with the [`<=`](`<=/2`) sorter function.
+  If multiple elements are considered minimal, the first one that
+  was found is returned. If you want the last element considered
+  minimal to be returned, the sorter function should not return true
+  for equal elements.
+
+  Calls the provided `empty_fallback` function and returns its value if
+  `enumerable` is empty. The default `empty_fallback` raises `Enum.EmptyError`.
 
   ## Examples
 
-      iex> Enum.min_by(["a", "aa", "aaa"], fn(x) -> String.length(x) end)
+      iex> Enum.min_by(["a", "aa", "aaa"], fn x -> String.length(x) end)
       "a"
 
-  """
-  @spec min_by(t, (element -> any)) :: element | no_return
-  def min_by([h|t], fun) do
-    reduce(t, {h, fun.(h)}, fn(entry, {_, fun_min} = old) ->
-      fun_entry = fun.(entry)
-      if(fun_entry < fun_min, do: {entry, fun_entry}, else: old)
-    end) |> elem(0)
-  end
-
-  def min_by([], _fun) do
-    raise Enum.EmptyError
-  end
+      iex> Enum.min_by(["a", "aa", "aaa", "b", "bbb"], &String.length/1)
+      "a"
 
-  def min_by(collection, fun) do
-    result =
-      reduce(collection, :first, fn
-        entry, {_, fun_min} = old ->
-          fun_entry = fun.(entry)
-          if(fun_entry < fun_min, do: {entry, fun_entry}, else: old)
-        entry, :first ->
-          {entry, fun.(entry)}
-      end)
+  The fact this function uses Erlang's term ordering means that the
+  comparison is structural and not semantic. Therefore, if you want
+  to compare structs, most structs provide a "compare" function, such as
+  `Date.compare/2`, which receives two structs and returns `:lt` (less-than),
+  `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the
+  sorting function, Elixir will automatically use the `compare/2` function
+  of said module:
+
+      iex> users = [
+      ...>   %{name: "Ellis", birthday: ~D[1943-05-11]},
+      ...>   %{name: "Lovelace", birthday: ~D[1815-12-10]},
+      ...>   %{name: "Turing", birthday: ~D[1912-06-23]}
+      ...> ]
+      iex> Enum.min_by(users, &(&1.birthday), Date)
+      %{name: "Lovelace", birthday: ~D[1815-12-10]}
+
+  Finally, if you don't want to raise on empty enumerables, you can pass
+  the empty fallback:
+
+      iex> Enum.min_by([], &String.length/1, fn -> nil end)
+      nil
 
-    case result do
-      :first       -> raise Enum.EmptyError
-      {entry, _} -> entry
-    end
+  """
+  @spec min_by(
+          t,
+          (element -> any),
+          (element, element -> boolean) | module(),
+          (-> empty_result)
+        ) :: element | empty_result
+        when empty_result: any
+  def min_by(enumerable, fun, sorter \\ &<=/2, empty_fallback \\ fn -> raise Enum.EmptyError end)
+      when is_function(fun, 1) do
+    aggregate_by(enumerable, fun, min_sort_fun(sorter), empty_fallback)
   end
 
   @doc """
-  Returns the sum of all values.
+  Returns a tuple with the minimal and the maximal elements in the
+  enumerable.
 
-  Raises `ArithmeticError` if collection contains a non-numeric value.
+  By default, the comparison is done with the [`<`](`</2`) sorter function,
+  as the function must not return true for equal elements.
 
   ## Examples
 
-      iex> Enum.sum([1, 2, 3])
-      6
+      iex> Enum.min_max([2, 3, 1])
+      {1, 3}
+
+      iex> Enum.min_max(["foo", "bar", "baz"])
+      {"bar", "foo"}
+
+      iex> Enum.min_max([], fn -> {nil, nil} end)
+      {nil, nil}
+
+  The fact this function uses Erlang's term ordering means that the
+  comparison is structural and not semantic. Therefore, if you want
+  to compare structs, most structs provide a "compare" function, such as
+  `Date.compare/2`, which receives two structs and returns `:lt` (less-than),
+  `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the
+  sorting function, Elixir will automatically use the `compare/2` function
+  of said module:
+
+      iex> dates = [
+      ...>   ~D[2019-01-01],
+      ...>   ~D[2020-01-01],
+      ...>   ~D[2018-01-01]
+      ...> ]
+      iex> Enum.min_max(dates, Date)
+      {~D[2018-01-01], ~D[2020-01-01]}
+
+  You can also pass a custom sorting function:
+
+      iex> Enum.min_max([2, 3, 1], &>/2)
+      {3, 1}
+
+  Finally, if you don't want to raise on empty enumerables, you can pass
+  the empty fallback:
+
+      iex> Enum.min_max([], fn -> nil end)
+      nil
 
   """
-  @spec sum(t) :: number
-  def sum(collection) do
-    reduce(collection, 0, &+/2)
+  @spec min_max(t, (element, element -> boolean) | module()) :: {element, element}
+  @spec min_max(t, (-> empty_result)) :: {element, element} | empty_result when empty_result: any
+  @spec min_max(t, (element, element -> boolean) | module(), (-> empty_result)) ::
+          {element, element} | empty_result
+        when empty_result: any
+
+  def min_max(enumerable, sorter_or_empty_fallback \\ fn -> raise Enum.EmptyError end)
+
+  def min_max(first..last//step = range, empty_fallback)
+      when is_function(empty_fallback, 0) do
+    case Range.size(range) do
+      0 ->
+        empty_fallback.()
+
+      _ ->
+        last = last - rem(last - first, step)
+        {Kernel.min(first, last), Kernel.max(first, last)}
+    end
+  end
+
+  def min_max(enumerable, empty_fallback)
+      when is_function(empty_fallback, 0) do
+    min_max(enumerable, &</2, empty_fallback)
+  end
+
+  def min_max(enumerable, sorter) when is_atom(sorter) do
+    min_max(enumerable, min_max_sort_fun(sorter))
+  end
+
+  def min_max(enumerable, sorter) when is_function(sorter, 2) do
+    min_max(enumerable, sorter, fn -> raise Enum.EmptyError end)
+  end
+
+  def min_max(enumerable, sorter, empty_fallback)
+      when is_atom(sorter) and is_function(empty_fallback, 0) do
+    min_max(enumerable, min_max_sort_fun(sorter), empty_fallback)
+  end
+
+  def min_max(enumerable, sorter, empty_fallback)
+      when is_function(sorter, 2) and is_function(empty_fallback, 0) do
+    first_fun = &[&1 | &1]
+
+    reduce_fun = fn entry, [min | max] = acc ->
+      cond do
+        sorter.(entry, min) ->
+          [entry | max]
+
+        sorter.(max, entry) ->
+          [min | entry]
+
+        true ->
+          acc
+      end
+    end
+
+    case reduce_by(enumerable, first_fun, reduce_fun) do
+      :empty -> empty_fallback.()
+      [min | max] -> {min, max}
+    end
+  end
+
+  @doc false
+  @spec min_max_by(t, (element -> any), (-> empty_result)) :: {element, element} | empty_result
+        when empty_result: any
+  def min_max_by(enumerable, fun, empty_fallback)
+      when is_function(fun, 1) and is_function(empty_fallback, 0) do
+    min_max_by(enumerable, fun, &</2, empty_fallback)
+  end
+
+  @doc """
+  Returns a tuple with the minimal and the maximal elements in the
+  enumerable as calculated by the given function.
+
+  By default, the comparison is done with the [`<`](`</2`) sorter function,
+  as the function must not return `true` for equal elements.
+
+  ## Examples
+
+      iex> Enum.min_max_by(["aaa", "bb", "c"], fn x -> String.length(x) end)
+      {"c", "aaa"}
+
+      iex> Enum.min_max_by(["aaa", "a", "bb", "c", "ccc"], &String.length/1)
+      {"a", "aaa"}
+
+      iex> Enum.min_max_by([], &String.length/1, fn -> {nil, nil} end)
+      {nil, nil}
+
+  The fact this function uses Erlang's term ordering means that the
+  comparison is structural and not semantic. Therefore, if you want
+  to compare structs, most structs provide a "compare" function, such as
+  `Date.compare/2`, which receives two structs and returns `:lt` (less-than),
+  `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the
+  sorting function, Elixir will automatically use the `compare/2` function
+  of said module:
+
+      iex> users = [
+      ...>   %{name: "Ellis", birthday: ~D[1943-05-11]},
+      ...>   %{name: "Lovelace", birthday: ~D[1815-12-10]},
+      ...>   %{name: "Turing", birthday: ~D[1912-06-23]}
+      ...> ]
+      iex> Enum.min_max_by(users, &(&1.birthday), Date)
+      {
+        %{name: "Lovelace", birthday: ~D[1815-12-10]},
+        %{name: "Ellis", birthday: ~D[1943-05-11]}
+      }
+
+  Finally, if you don't want to raise on empty enumerables, you can pass
+  the empty fallback:
+
+      iex> Enum.min_max_by([], &String.length/1, fn -> nil end)
+      nil
+
+  """
+  @spec min_max_by(t, (element -> any), (element, element -> boolean) | module()) ::
+          {element, element} | empty_result
+        when empty_result: any
+  @spec min_max_by(
+          t,
+          (element -> any),
+          (element, element -> boolean) | module(),
+          (-> empty_result)
+        ) :: {element, element} | empty_result
+        when empty_result: any
+  def min_max_by(
+        enumerable,
+        fun,
+        sorter_or_empty_fallback \\ &</2,
+        empty_fallback \\ fn -> raise Enum.EmptyError end
+      )
+
+  def min_max_by(enumerable, fun, sorter, empty_fallback)
+      when is_function(fun, 1) and is_atom(sorter) and is_function(empty_fallback, 0) do
+    min_max_by(enumerable, fun, min_max_sort_fun(sorter), empty_fallback)
+  end
+
+  def min_max_by(enumerable, fun, sorter, empty_fallback)
+      when is_function(fun, 1) and is_function(sorter, 2) and is_function(empty_fallback, 0) do
+    first_fun = fn entry ->
+      fun_entry = fun.(entry)
+      {entry, entry, fun_entry, fun_entry}
+    end
+
+    reduce_fun = fn entry, {prev_min, prev_max, fun_min, fun_max} = acc ->
+      fun_entry = fun.(entry)
+
+      cond do
+        sorter.(fun_entry, fun_min) ->
+          {entry, prev_max, fun_entry, fun_max}
+
+        sorter.(fun_max, fun_entry) ->
+          {prev_min, entry, fun_min, fun_entry}
+
+        true ->
+          acc
+      end
+    end
+
+    case reduce_by(enumerable, first_fun, reduce_fun) do
+      :empty -> empty_fallback.()
+      {min, max, _, _} -> {min, max}
+    end
   end
 
+  defp min_max_sort_fun(module) when is_atom(module), do: &(module.compare(&1, &2) == :lt)
+
   @doc """
-  Partitions `collection` into two collections, where the first one contains elements
-  for which `fun` returns a truthy value, and the second one -- for which `fun`
-  returns `false` or `nil`.
+  Splits the `enumerable` in two lists according to the given function `fun`.
+
+  Splits the given `enumerable` in two lists by calling `fun` with each element
+  in the `enumerable` as its only argument. Returns a tuple with the first list
+  containing all the elements in `enumerable` for which applying `fun` returned
+  a truthy value, and a second list with all the elements for which applying
+  `fun` returned a falsy value (`false` or `nil`).
+
+  The elements in both the returned lists are in the same relative order as they
+  were in the original enumerable (if such enumerable was ordered, like a
+  list). See the examples below.
 
   ## Examples
 
-      iex> Enum.partition([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
-      {[2], [1,3]}
+      iex> Enum.split_with([5, 4, 3, 2, 1, 0], fn x -> rem(x, 2) == 0 end)
+      {[4, 2, 0], [5, 3, 1]}
+
+      iex> Enum.split_with([a: 1, b: -2, c: 1, d: -3], fn {_k, v} -> v < 0 end)
+      {[b: -2, d: -3], [a: 1, c: 1]}
+
+      iex> Enum.split_with([a: 1, b: -2, c: 1, d: -3], fn {_k, v} -> v > 50 end)
+      {[], [a: 1, b: -2, c: 1, d: -3]}
+
+      iex> Enum.split_with([], fn {_k, v} -> v > 50 end)
+      {[], []}
 
   """
-  @spec partition(t, (element -> any)) :: {list, list}
-  def partition(collection, fun) do
+  @doc since: "1.4.0"
+  @spec split_with(t, (element -> as_boolean(term))) :: {list, list}
+  def split_with(enumerable, fun) do
     {acc1, acc2} =
-      reduce(collection, {[], []}, fn(entry, {acc1, acc2}) ->
+      reduce(enumerable, {[], []}, fn entry, {acc1, acc2} ->
         if fun.(entry) do
-          {[entry|acc1], acc2}
+          {[entry | acc1], acc2}
         else
-          {acc1, [entry|acc2]}
+          {acc1, [entry | acc2]}
         end
       end)
 
     {:lists.reverse(acc1), :lists.reverse(acc2)}
   end
 
+  @doc false
+  @deprecated "Use Enum.split_with/2 instead"
+  def partition(enumerable, fun) do
+    split_with(enumerable, fun)
+  end
+
   @doc """
-  Splits `collection` into groups based on `fun`.
+  Returns a random element of an `enumerable`.
 
-  The result is a dict (by default a map) where each key is
-  a group and each value is a list of elements from `collection`
-  for which `fun` returned that group. Ordering is not necessarily
-  preserved.
+  Raises `Enum.EmptyError` if `enumerable` is empty.
+
+  This function uses Erlang's [`:rand` module](`:rand`) to calculate
+  the random value. Check its documentation for setting a
+  different random algorithm or a different seed.
+
+  If a range is passed into the function, this function will pick a
+  random value between the range limits, without traversing the whole
+  range (thus executing in constant time and constant memory).
 
   ## Examples
 
-      iex> Enum.group_by(~w{ant buffalo cat dingo}, &String.length/1)
-      %{3 => ["cat", "ant"], 7 => ["buffalo"], 5 => ["dingo"]}
+  The examples below use the `:exsss` pseudorandom algorithm since it's
+  the default from Erlang/OTP 22:
+
+      # Although not necessary, let's seed the random algorithm
+      iex> :rand.seed(:exsss, {100, 101, 102})
+      iex> Enum.random([1, 2, 3])
+      2
+      iex> Enum.random([1, 2, 3])
+      1
+      iex> Enum.random(1..1_000)
+      309
 
+  ## Implementation
+
+  The random functions in this module implement reservoir sampling,
+  which allows them to sample infinite collections. In particular,
+  we implement Algorithm L, as described in by Kim-Hung Li in
+  "Reservoir-Sampling Algorithms of Time Complexity O(n(1+log(N/n)))".
   """
-  @spec group_by(t, dict, (element -> any)) :: dict when dict: Dict.t
-  def group_by(collection, dict \\ %{}, fun) do
-    reduce(collection, dict, fn(entry, categories) ->
-      Dict.update(categories, fun.(entry), [entry], &[entry|&1])
-    end)
+  @spec random(t) :: element
+  def random(enumerable)
+
+  def random(enumerable) when is_list(enumerable) do
+    case length(enumerable) do
+      0 -> raise Enum.EmptyError
+      length -> enumerable |> drop_list(random_count(length)) |> hd()
+    end
   end
 
-  @doc """
-  Invokes `fun` for each element in the collection passing that element and the
-  accumulator `acc` as arguments. `fun`'s return value is stored in `acc`.
-  Returns the accumulator.
+  def random(first.._//step = range) do
+    case Range.size(range) do
+      0 -> raise Enum.EmptyError
+      size -> first + random_count(size) * step
+    end
+  end
 
-  ## Examples
+  def random(enumerable) do
+    result =
+      case Enumerable.slice(enumerable) do
+        {:ok, 0, _} ->
+          []
 
-      iex> Enum.reduce([1, 2, 3], 0, fn(x, acc) -> x + acc end)
-      6
+        {:ok, count, fun} when is_function(fun, 1) ->
+          slice_list(fun.(enumerable), random_count(count), 1, 1)
 
-  """
-  @spec reduce(t, any, (element, any -> any)) :: any
-  def reduce(collection, acc, fun) when is_list(collection) do
-    :lists.foldl(fun, acc, collection)
+        {:ok, count, fun} when is_function(fun, 3) ->
+          fun.(random_count(count), 1, 1)
+
+        # TODO: Remove me on v2.0
+        {:ok, count, fun} when is_function(fun, 2) ->
+          IO.warn(
+            "#{inspect(Enumerable.impl_for(enumerable))} must return a three arity function on slice/1"
+          )
+
+          fun.(random_count(count), 1)
+
+        {:error, _} ->
+          take_random(enumerable, 1)
+      end
+
+    case result do
+      [] -> raise Enum.EmptyError
+      [elem] -> elem
+    end
   end
 
-  def reduce(collection, acc, fun) do
-    Enumerable.reduce(collection, {:cont, acc},
-                      fn x, acc -> {:cont, fun.(x, acc)} end) |> elem(1)
+  defp random_count(count) do
+    :rand.uniform(count) - 1
   end
 
   @doc """
-  Invokes `fun` for each element in the collection passing that element and the
-  accumulator `acc` as arguments. `fun`'s return value is stored in `acc`.
-  The first element of the collection is used as the initial value of `acc`.
-  Returns the accumulator.
+  Invokes `fun` for each element in the `enumerable` with the
+  accumulator.
+
+  Raises `Enum.EmptyError` if `enumerable` is empty.
+
+  The first element of the `enumerable` is used as the initial value
+  of the accumulator. Then, the function is invoked with the next
+  element and the accumulator. The result returned by the function
+  is used as the accumulator for the next iteration, recursively.
+  When the `enumerable` is done, the last accumulator is returned.
+
+  Since the first element of the enumerable is used as the initial
+  value of the accumulator, `fun` will only be executed `n - 1` times
+  where `n` is the length of the enumerable. This function won't call
+  the specified function for enumerables that are one-element long.
+
+  If you wish to use another value for the accumulator, use
+  `Enum.reduce/3`.
 
   ## Examples
 
-      iex> Enum.reduce([1, 2, 3, 4], fn(x, acc) -> x * acc end)
+      iex> Enum.reduce([1, 2, 3, 4], fn x, acc -> x * acc end)
       24
 
   """
-  @spec reduce(t, (element, any -> any)) :: any
-  def reduce([h|t], fun) do
+  @spec reduce(t, (element, acc -> acc)) :: acc
+  def reduce(enumerable, fun)
+
+  def reduce([h | t], fun) do
     reduce(t, h, fun)
   end
 
@@ -1278,41 +2552,140 @@ defmodule Enum do
     raise Enum.EmptyError
   end
 
-  def reduce(collection, fun) do
-    result =
-      Enumerable.reduce(collection, {:cont, :first}, fn
-        x, :first ->
-          {:cont, {:acc, x}}
-        x, {:acc, acc} ->
-          {:cont, {:acc, fun.(x, acc)}}
-      end) |> elem(1)
-
-    case result do
-      :first        -> raise Enum.EmptyError
+  def reduce(enumerable, fun) do
+    Enumerable.reduce(enumerable, {:cont, :first}, fn
+      x, {:acc, acc} -> {:cont, {:acc, fun.(x, acc)}}
+      x, :first -> {:cont, {:acc, x}}
+    end)
+    |> elem(1)
+    |> case do
+      :first -> raise Enum.EmptyError
       {:acc, acc} -> acc
     end
   end
 
   @doc """
-  Returns elements of collection for which `fun` returns `false`.
+  Invokes `fun` for each element in the `enumerable` with the accumulator.
+
+  The initial value of the accumulator is `acc`. The function is invoked for
+  each element in the enumerable with the accumulator. The result returned
+  by the function is used as the accumulator for the next iteration.
+  The function returns the last accumulator.
+
+  ## Examples
+
+      iex> Enum.reduce([1, 2, 3], 0, fn x, acc -> x + acc end)
+      6
+
+      iex> Enum.reduce(%{a: 2, b: 3, c: 4}, 0, fn {_key, val}, acc -> acc + val end)
+      9
+
+  ## Reduce as a building block
+
+  Reduce (sometimes called `fold`) is a basic building block in functional
+  programming. Almost all of the functions in the `Enum` module can be
+  implemented on top of reduce. Those functions often rely on other operations,
+  such as `Enum.reverse/1`, which are optimized by the runtime.
+
+  For example, we could implement `map/2` in terms of `reduce/3` as follows:
+
+      def my_map(enumerable, fun) do
+        enumerable
+        |> Enum.reduce([], fn x, acc -> [fun.(x) | acc] end)
+        |> Enum.reverse()
+      end
+
+  In the example above, `Enum.reduce/3` accumulates the result of each call
+  to `fun` into a list in reverse order, which is correctly ordered at the
+  end by calling `Enum.reverse/1`.
+
+  Implementing functions like `map/2`, `filter/2` and others are a good
+  exercise for understanding the power behind `Enum.reduce/3`. When an
+  operation cannot be expressed by any of the functions in the `Enum`
+  module, developers will most likely resort to `reduce/3`.
+  """
+  @spec reduce(t, acc, (element, acc -> acc)) :: acc
+  def reduce(enumerable, acc, fun) when is_list(enumerable) do
+    :lists.foldl(fun, acc, enumerable)
+  end
+
+  def reduce(first..last//step, acc, fun) do
+    reduce_range(first, last, step, acc, fun)
+  end
+
+  def reduce(%_{} = enumerable, acc, fun) do
+    reduce_enumerable(enumerable, acc, fun)
+  end
+
+  def reduce(%{} = enumerable, acc, fun) do
+    :maps.fold(fn k, v, acc -> fun.({k, v}, acc) end, acc, enumerable)
+  end
+
+  def reduce(enumerable, acc, fun) do
+    reduce_enumerable(enumerable, acc, fun)
+  end
+
+  @doc """
+  Reduces `enumerable` until `fun` returns `{:halt, term}`.
+
+  The return value for `fun` is expected to be
+
+    * `{:cont, acc}` to continue the reduction with `acc` as the new
+      accumulator or
+    * `{:halt, acc}` to halt the reduction
+
+  If `fun` returns `{:halt, acc}` the reduction is halted and the function
+  returns `acc`. Otherwise, if the enumerable is exhausted, the function returns
+  the accumulator of the last `{:cont, acc}`.
+
+  ## Examples
+
+      iex> Enum.reduce_while(1..100, 0, fn x, acc ->
+      ...>   if x < 5 do
+      ...>     {:cont, acc + x}
+      ...>   else
+      ...>     {:halt, acc}
+      ...>   end
+      ...> end)
+      10
+      iex> Enum.reduce_while(1..100, 0, fn x, acc ->
+      ...>   if x > 0 do
+      ...>     {:cont, acc + x}
+      ...>   else
+      ...>     {:halt, acc}
+      ...>   end
+      ...> end)
+      5050
+
+  """
+  @spec reduce_while(t, any, (element, any -> {:cont, any} | {:halt, any})) :: any
+  def reduce_while(enumerable, acc, fun) do
+    Enumerable.reduce(enumerable, {:cont, acc}, fun) |> elem(1)
+  end
+
+  @doc """
+  Returns a list of elements in `enumerable` excluding those for which the function `fun` returns
+  a truthy value.
+
+  See also `filter/2`.
 
   ## Examples
 
-      iex> Enum.reject([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
+      iex> Enum.reject([1, 2, 3], fn x -> rem(x, 2) == 0 end)
       [1, 3]
 
   """
   @spec reject(t, (element -> as_boolean(term))) :: list
-  def reject(collection, fun) when is_list(collection) do
-    for item <- collection, !fun.(item), do: item
+  def reject(enumerable, fun) when is_list(enumerable) do
+    reject_list(enumerable, fun)
   end
 
-  def reject(collection, fun) do
-    Enumerable.reduce(collection, {:cont, []}, R.reject(fun)) |> elem(1) |> :lists.reverse
+  def reject(enumerable, fun) do
+    reduce(enumerable, [], R.reject(fun)) |> :lists.reverse()
   end
 
   @doc """
-  Reverses the collection.
+  Returns a list of elements in `enumerable` in reverse order.
 
   ## Examples
 
@@ -1321,18 +2694,20 @@ defmodule Enum do
 
   """
   @spec reverse(t) :: list
-  def reverse(collection) when is_list(collection) do
-    :lists.reverse(collection)
-  end
+  def reverse(enumerable)
 
-  def reverse(collection) do
-    reverse(collection, [])
-  end
+  def reverse([]), do: []
+  def reverse([_] = list), do: list
+  def reverse([element1, element2]), do: [element2, element1]
+  def reverse([element1, element2 | rest]), do: :lists.reverse(rest, [element2, element1])
+  def reverse(enumerable), do: reduce(enumerable, [], &[&1 | &2])
 
   @doc """
-  Reverses the collection and appends the tail.
+  Reverses the elements in `enumerable`, appends the `tail`, and returns
+  it as a list.
+
   This is an optimization for
-  `Enum.concat(Enum.reverse(collection), tail)`.
+  `enumerable |> Enum.reverse() |> Enum.concat(tail)`.
 
   ## Examples
 
@@ -1341,637 +2716,2163 @@ defmodule Enum do
 
   """
   @spec reverse(t, t) :: list
-  def reverse(collection, tail) when is_list(collection) and is_list(tail) do
-    :lists.reverse(collection, tail)
+  def reverse(enumerable, tail) when is_list(enumerable) do
+    :lists.reverse(enumerable, to_list(tail))
   end
 
-  def reverse(collection, tail) do
-    reduce(collection, to_list(tail), fn(entry, acc) ->
-      [entry|acc]
+  def reverse(enumerable, tail) do
+    reduce(enumerable, to_list(tail), fn entry, acc ->
+      [entry | acc]
     end)
   end
 
   @doc """
-  Applies the given function to each element in the collection,
-  storing the result in a list and passing it as the accumulator
-  for the next computation.
+  Reverses the `enumerable` in the range from initial `start_index`
+  through `count` elements.
+
+  If `count` is greater than the size of the rest of the `enumerable`,
+  then this function will reverse the rest of the enumerable.
 
   ## Examples
 
-      iex> Enum.scan(1..5, &(&1 + &2))
-      [1,3,6,10,15]
+      iex> Enum.reverse_slice([1, 2, 3, 4, 5, 6], 2, 4)
+      [1, 2, 6, 5, 4, 3]
 
   """
-  @spec scan(t, (element, any -> any)) :: list
-  def scan(enum, fun) do
-    {_, {res, _}} =
-      Enumerable.reduce(enum, {:cont, {[], :first}}, R.scan_2(fun))
-    :lists.reverse(res)
+  @spec reverse_slice(t, non_neg_integer, non_neg_integer) :: list
+  def reverse_slice(enumerable, start_index, count)
+      when is_integer(start_index) and start_index >= 0 and is_integer(count) and count >= 0 do
+    list = reverse(enumerable)
+    length = length(list)
+    count = Kernel.min(count, length - start_index)
+
+    if count > 0 do
+      reverse_slice(list, length, start_index + count, count, [])
+    else
+      :lists.reverse(list)
+    end
   end
 
   @doc """
-  Applies the given function to each element in the collection,
-  storing the result in a list and passing it as the accumulator
-  for the next computation. Uses the given `acc` as the starting value.
+  Slides a single or multiple elements given by `range_or_single_index` from `enumerable`
+  to `insertion_index`.
 
-  ## Examples
+  The semantics of the range to be moved match the semantics of `Enum.slice/2`.
+  Specifically, that means:
 
-      iex> Enum.scan(1..5, 0, &(&1 + &2))
-      [1,3,6,10,15]
+   * Indices are normalized, meaning that negative indexes will be counted from the end
+      (for example, -1 means the last element of the enumerable). This will result in *two*
+      traversals of your enumerable on types like lists that don't provide a constant-time count.
 
-  """
-  @spec scan(t, any, (element, any -> any)) :: list
-  def scan(enum, acc, fun) do
-    {_, {res, _}} =
-      Enumerable.reduce(enum, {:cont, {[], acc}}, R.scan_3(fun))
-    :lists.reverse(res)
-  end
+    * If the normalized index range's `last` is out of bounds, the range is truncated to the last element.
 
-  @doc """
-  Returns a list of collection elements shuffled.
+    * If the normalized index range's `first` is out of bounds, the selected range for sliding
+      will be empty, so you'll get back your input list.
 
-  Notice that you need to explicitly call `:random.seed/1` and
-  set a seed value for the random algorithm. Otherwise, the
-  default seed will be set which will always return the same
-  result. For example, one could do the following to set a seed
-  dynamically:
+    * Decreasing ranges (such as `5..0//1`) also select an empty range to be moved,
+      so you'll get back your input list.
 
-      :random.seed(:erlang.now)
+    * Ranges with any step but 1 will raise an error.
 
   ## Examples
 
-      iex> Enum.shuffle([1, 2, 3])
-      [3, 2, 1]
-      iex> Enum.shuffle([1, 2, 3])
-      [3, 1, 2]
+      # Slide a single element
+      iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 5, 1)
+      [:a, :f, :b, :c, :d, :e, :g]
 
-  """
-  @spec shuffle(t) :: list
-  def shuffle(collection) do
-    randomized = reduce(collection, [], fn x, acc ->
-      [{:random.uniform, x}|acc]
-    end)
-    unwrap(:lists.keysort(1, randomized), [])
-  end
+      # Slide a range of elements towards the head of the list
+      iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 3..5, 1)
+      [:a, :d, :e, :f, :b, :c, :g]
 
-  @doc """
-  Returns a subset list of the given collection. Drops elements
-  until element position `start`, then takes `count` elements.
-  
-  If the count is greater than collection length, it returns as
-  much as possible. If zero, then it returns `[]`.
+      # Slide a range of elements towards the tail of the list
+      iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 1..3, 5)
+      [:a, :e, :f, :b, :c, :d, :g]
 
-  ## Examples
+      # Slide with negative indices (counting from the end)
+      iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 3..-1//1, 2)
+      [:a, :b, :d, :e, :f, :g, :c]
+      iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], -4..-2, 1)
+      [:a, :d, :e, :f, :b, :c, :g]
 
-      iex> Enum.slice(1..100, 5, 10)
-      [6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+      # Insert at negative indices (counting from the end)
+      iex> Enum.slide([:a, :b, :c, :d, :e, :f, :g], 3, -1)
+      [:a, :b, :c, :e, :f, :g, :d]
 
-      iex> Enum.slice(1..10, 5, 100)
-      [6, 7, 8, 9, 10]
+  """
+  @doc since: "1.13.0"
+  @spec slide(t, Range.t() | index, index) :: list
+  def slide(enumerable, range_or_single_index, insertion_index)
 
-      iex> Enum.slice(1..10, 5, 0)
-      []
+  def slide(enumerable, single_index, insertion_index) when is_integer(single_index) do
+    slide(enumerable, single_index..single_index, insertion_index)
+  end
 
-  """
-  @spec slice(t, integer, non_neg_integer) :: list
-  
-  def slice(_coll, _start, 0), do: []
+  # This matches the behavior of Enum.slice/2
+  def slide(_, _.._//step = index_range, _insertion_index) when step != 1 do
+    raise ArgumentError,
+          "Enum.slide/3 does not accept ranges with custom steps, got: #{inspect(index_range)}"
+  end
 
-  def slice(coll, start, count) when start < 0 do
-    {list, new_start} = enumerate_and_count(coll, start)
-    if new_start >= 0 do
-      slice(list, new_start, count)
+  # Normalize negative input ranges like Enum.slice/2
+  def slide(enumerable, first..last//_, insertion_index)
+      when first < 0 or last < 0 or insertion_index < 0 do
+    count = Enum.count(enumerable)
+    normalized_first = if first >= 0, do: first, else: Kernel.max(first + count, 0)
+    normalized_last = if last >= 0, do: last, else: last + count
+
+    normalized_insertion_index =
+      if insertion_index >= 0, do: insertion_index, else: insertion_index + count
+
+    if normalized_first < count and normalized_first != normalized_insertion_index do
+      normalized_range = normalized_first..normalized_last//1
+      slide(enumerable, normalized_range, normalized_insertion_index)
     else
-      []
+      Enum.to_list(enumerable)
     end
   end
 
-  def slice(coll, start, count) when is_list(coll) and start >= 0 and count > 0 do
-    do_slice(coll, start, count)
+  def slide(enumerable, insertion_index.._//_, insertion_index) do
+    Enum.to_list(enumerable)
   end
 
-  def slice(coll, start, count) when start >= 0 and count > 0 do
-    {_, _, list} = Enumerable.reduce(coll, {:cont, {start, count, []}}, fn
-      _entry, {start, count, _list} when start > 0 ->
-        {:cont, {start-1, count, []}}
-      entry, {start, count, list} when count > 1 ->
-        {:cont, {start, count-1, [entry|list]}}
-      entry, {start, count, list} ->
-        {:halt, {start, count, [entry|list]}}
-    end) |> elem(1)
+  def slide(_, first..last//_, insertion_index)
+      when insertion_index > first and insertion_index <= last do
+    raise ArgumentError,
+          "insertion index for slide must be outside the range being moved " <>
+            "(tried to insert #{first}..#{last} at #{insertion_index})"
+  end
 
-    :lists.reverse(list)
+  def slide(enumerable, first..last//_, _insertion_index) when first > last do
+    Enum.to_list(enumerable)
   end
 
-  @doc """
-  Returns a subset list of the given collection. Drops elements
-  until element position `range.first`, then takes elements until element
-  position `range.last` (inclusive).
+  # Guarantees at this point: step size == 1 and first <= last and (insertion_index < first or insertion_index > last)
+  def slide(enumerable, first..last//_, insertion_index) do
+    impl = if is_list(enumerable), do: &slide_list_start/4, else: &slide_any/4
 
-  Positions are calculated by adding the number of items in the collection to
-  negative positions (so position -3 in a collection with count 5 becomes
-  position 2).
+    cond do
+      insertion_index <= first -> impl.(enumerable, insertion_index, first, last)
+      insertion_index > last -> impl.(enumerable, first, last + 1, insertion_index)
+    end
+  end
 
-  The first position (after adding count to negative positions) must be smaller
-  or equal to the last position.
+  # Takes the range from middle..last and moves it to be in front of index start
+  defp slide_any(enumerable, start, middle, last) do
+    # We're going to deal with 4 "chunks" of the enumerable:
+    # 0. "Head," before the start index
+    # 1. "Slide back," between start (inclusive) and middle (exclusive)
+    # 2. "Slide front," between middle (inclusive) and last (inclusive)
+    # 3. "Tail," after last
+    #
+    # But, we're going to accumulate these into only two lists: pre and post.
+    # We'll reverse-accumulate the head into our pre list, then "slide back" into post,
+    # then "slide front" into pre, then "tail" into post.
+    #
+    # Then at the end, we're going to reassemble and reverse them, and end up with the
+    # chunks in the correct order.
+    {_size, pre, post} =
+      reduce(enumerable, {0, [], []}, fn item, {index, pre, post} ->
+        {pre, post} =
+          cond do
+            index < start -> {[item | pre], post}
+            index >= start and index < middle -> {pre, [item | post]}
+            index >= middle and index <= last -> {[item | pre], post}
+            true -> {pre, [item | post]}
+          end
+
+        {index + 1, pre, post}
+      end)
 
-  If the start of the range is not a valid offset for the given
-  collection or if the range is in reverse order, returns `[]`.
+    :lists.reverse(pre, :lists.reverse(post))
+  end
 
-  ## Examples
+  # Like slide_any/4 above, this optimized implementation of slide for lists depends
+  # on the indices being sorted such that we're moving middle..last to be in front of start.
+  defp slide_list_start([h | t], start, middle, last)
+       when start > 0 and start <= middle and middle <= last do
+    [h | slide_list_start(t, start - 1, middle - 1, last - 1)]
+  end
 
-      iex> Enum.slice(1..100, 5..10)
-      [6, 7, 8, 9, 10, 11]
+  defp slide_list_start(list, 0, middle, last), do: slide_list_middle(list, middle, last, [])
+  defp slide_list_start([], _start, _middle, _last), do: []
 
-      iex> Enum.slice(1..10, 5..20)
-      [6, 7, 8, 9, 10]
+  defp slide_list_middle([h | t], middle, last, acc) when middle > 0 do
+    slide_list_middle(t, middle - 1, last - 1, [h | acc])
+  end
 
-      iex> Enum.slice(1..10, 11..20)
-      []
+  defp slide_list_middle(list, 0, last, start_to_middle) do
+    {slid_range, tail} = slide_list_last(list, last + 1, [])
+    slid_range ++ :lists.reverse(start_to_middle, tail)
+  end
 
-      iex> Enum.slice(1..10, 6..5)
-      []
+  # You asked for a middle index off the end of the list... you get what we've got
+  defp slide_list_middle([], _, _, acc) do
+    :lists.reverse(acc)
+  end
 
-  """
-  @spec slice(t, Range.t) :: list
-  def slice(coll, first..last) when first >= 0 and last >= 0 do
-    # Simple case, which works on infinite collections
-    if last - first >= 0 do
-      slice(coll, first, last - first + 1)
-    else
-      []
-    end
+  defp slide_list_last([h | t], last, acc) when last > 0 do
+    slide_list_last(t, last - 1, [h | acc])
   end
 
-  def slice(coll, first..last) do
-    {list, count} = enumerate_and_count(coll, 0)
-    corr_first = if first >= 0, do: first, else: first + count
-    corr_last = if last >= 0, do: last, else: last + count
-    length = corr_last - corr_first + 1
-    if corr_first >= 0 and length > 0 do
-      slice(list, corr_first, length)
-    else
-      []
-    end
+  defp slide_list_last(rest, 0, acc) do
+    {:lists.reverse(acc), rest}
+  end
+
+  defp slide_list_last([], _, acc) do
+    {:lists.reverse(acc), []}
   end
 
   @doc """
-  Sorts the collection according to Elixir's term ordering.
+  Passes each element from `enumerable` to the `fun` as the first argument,
+  stores the `fun` result in a list and passes the result as the second argument
+  for the next computation.
 
-  Uses the merge sort algorithm.
+  The `fun` isn't applied for the first element of the `enumerable`,
+  the element is taken as it is.
 
   ## Examples
 
-      iex> Enum.sort([3, 2, 1])
-      [1, 2, 3]
+      iex> Enum.scan(["a", "b", "c", "d", "e"], fn element, acc -> element <> String.first(acc) end)
+      ["a", "ba", "cb", "dc", "ed"]
+
+      iex> Enum.scan(1..5, fn element, acc -> element + acc end)
+      [1, 3, 6, 10, 15]
 
   """
-  @spec sort(t) :: list
-  def sort(collection) when is_list(collection) do
-    :lists.sort(collection)
+  @spec scan(t, (element, any -> any)) :: list
+  def scan(enumerable, fun)
+
+  def scan([], _fun), do: []
+
+  def scan([elem | rest], fun) do
+    scanned = scan_list(rest, elem, fun)
+    [elem | scanned]
   end
 
-  def sort(collection) do
-    sort(collection, &(&1 <= &2))
+  def scan(enumerable, fun) do
+    {res, _} = reduce(enumerable, {[], :first}, R.scan2(fun))
+    :lists.reverse(res)
   end
 
   @doc """
-  Sorts the collection by the given function.
+  Passes each element from `enumerable` to the `fun` as the first argument,
+  stores the `fun` result in a list and passes the result as the second argument
+  for the next computation.
 
-  This function uses the merge sort algorithm. The given function
-  must return false if the first argument is less than right one.
+  Passes the given `acc` as the second argument for the `fun` with the first element.
 
   ## Examples
 
-      iex> Enum.sort([1, 2, 3], &(&1 > &2))
-      [3, 2, 1]
+      iex> Enum.scan(["a", "b", "c", "d", "e"], "_", fn element, acc -> element <> String.first(acc) end)
+      ["a_", "ba", "cb", "dc", "ed"]
 
-  The sorting algorithm will be stable as long as the given function
-  returns true for values considered equal:
+      iex> Enum.scan(1..5, 0, fn element, acc -> element + acc end)
+      [1, 3, 6, 10, 15]
 
-      iex> Enum.sort ["some", "kind", "of", "monster"], &(byte_size(&1) <= byte_size(&2))
-      ["of", "some", "kind", "monster"]
+  """
+  @spec scan(t, any, (element, any -> any)) :: list
+  def scan(enumerable, acc, fun) when is_list(enumerable) do
+    scan_list(enumerable, acc, fun)
+  end
 
-  If the function does not return true, the sorting is not stable and
-  the order of equal terms may be shuffled:
+  def scan(enumerable, acc, fun) do
+    {res, _} = reduce(enumerable, {[], acc}, R.scan3(fun))
+    :lists.reverse(res)
+  end
 
-      iex> Enum.sort ["some", "kind", "of", "monster"], &(byte_size(&1) < byte_size(&2))
-      ["of", "kind", "some", "monster"]
+  @doc """
+  Returns a list with the elements of `enumerable` shuffled.
+
+  This function uses Erlang's [`:rand` module](`:rand`) to calculate
+  the random value. Check its documentation for setting a
+  different random algorithm or a different seed.
+
+  ## Examples
+
+  The examples below use the `:exsss` pseudorandom algorithm since it's
+  the default from Erlang/OTP 22:
+
+      # Although not necessary, let's seed the random algorithm
+      iex> :rand.seed(:exsss, {11, 22, 33})
+      iex> Enum.shuffle([1, 2, 3])
+      [2, 1, 3]
+      iex> Enum.shuffle([1, 2, 3])
+      [2, 3, 1]
 
   """
-  @spec sort(t, (element, element -> boolean)) :: list
-  def sort(collection, fun) when is_list(collection) do
-    :lists.sort(fun, collection)
-  end
+  @spec shuffle(t) :: list
+  def shuffle(enumerable) do
+    randomized =
+      reduce(enumerable, [], fn x, acc ->
+        [{:rand.uniform(), x} | acc]
+      end)
 
-  def sort(collection, fun) do
-    reduce(collection, [], &sort_reducer(&1, &2, fun)) |> sort_terminator(fun)
+    shuffle_unwrap(:lists.keysort(1, randomized))
   end
 
+  defp shuffle_unwrap([{_, h} | rest]), do: [h | shuffle_unwrap(rest)]
+  defp shuffle_unwrap([]), do: []
+
   @doc """
-  Splits the enumerable into two collections, leaving `count`
-  elements in the first one. If `count` is a negative number,
-  it starts counting from the back to the beginning of the
-  collection.
+  Returns a subset list of the given `enumerable` by `index_range`.
 
-  Be aware that a negative `count` implies the collection
-  will be enumerated twice: once to calculate the position, and
-  a second time to do the actual splitting.
+  `index_range` must be a `Range`. Given an `enumerable`, it drops
+  elements before `index_range.first` (zero-base), then it takes elements
+  until element `index_range.last` (inclusively).
+
+  Indexes are normalized, meaning that negative indexes will be counted
+  from the end (for example, `-1` means the last element of the `enumerable`).
+
+  If `index_range.last` is out of bounds, then it is assigned as the index
+  of the last element.
+
+  If the normalized `index_range.first` is out of bounds of the given
+  `enumerable`, or this one is greater than the normalized `index_range.last`,
+  then `[]` is returned.
+
+  If a step `n` (other than `1`) is used in `index_range`, then it takes
+  every `n`th element from `index_range.first` to `index_range.last`
+  (according to the same rules described above).
 
   ## Examples
 
-      iex> Enum.split([1, 2, 3], 2)
-      {[1,2], [3]}
+      iex> Enum.slice([1, 2, 3, 4, 5], 1..3)
+      [2, 3, 4]
 
-      iex> Enum.split([1, 2, 3], 10)
-      {[1,2,3], []}
+      iex> Enum.slice([1, 2, 3, 4, 5], 3..10)
+      [4, 5]
 
-      iex> Enum.split([1, 2, 3], 0)
-      {[], [1,2,3]}
+      # Last three elements (negative indexes)
+      iex> Enum.slice([1, 2, 3, 4, 5], -3..-1)
+      [3, 4, 5]
 
-      iex> Enum.split([1, 2, 3], -1)
-      {[1,2], [3]}
+  For ranges where `start > stop`, you need to explicit
+  mark them as increasing:
 
-      iex> Enum.split([1, 2, 3], -5)
-      {[], [1,2,3]}
+      iex> Enum.slice([1, 2, 3, 4, 5], 1..-2//1)
+      [2, 3, 4]
+
+  The step can be any positive number. For example, to
+  get every 2 elements of the collection:
+
+      iex> Enum.slice([1, 2, 3, 4, 5], 0..-1//2)
+      [1, 3, 5]
+
+  To get every third element of the first ten elements:
+
+      iex> integers = Enum.to_list(1..20)
+      iex> Enum.slice(integers, 0..9//3)
+      [1, 4, 7, 10]
+
+  If the first position is after the end of the enumerable
+  or after the last position of the range, it returns an
+  empty list:
+
+      iex> Enum.slice([1, 2, 3, 4, 5], 6..10)
+      []
+
+      # first is greater than last
+      iex> Enum.slice([1, 2, 3, 4, 5], 6..5//1)
+      []
 
   """
-  @spec split(t, integer) :: {list, list}
-  def split(collection, count) when is_list(collection) and count >= 0 do
-    do_split(collection, count, [])
-  end
+  @doc since: "1.6.0"
+  @spec slice(t, Range.t()) :: list
+  def slice(enumerable, first..last//step = index_range) do
+    # TODO: Support negative steps as a reverse on Elixir v2.0.
+    cond do
+      step > 0 ->
+        slice_range(enumerable, first, last, step)
 
-  def split(collection, count) when count >= 0 do
-    {_, list1, list2} =
-      reduce(collection, {count, [], []}, fn(entry, {counter, acc1, acc2}) ->
-        if counter > 0 do
-          {counter - 1, [entry|acc1], acc2}
-        else
-          {counter, acc1, [entry|acc2]}
-        end
-      end)
+      step == -1 and first > last ->
+        IO.warn(
+          "negative steps are not supported in Enum.slice/2, pass #{first}..#{last}//1 instead"
+        )
+
+        slice_range(enumerable, first, last, 1)
+
+      true ->
+        raise ArgumentError,
+              "Enum.slice/2 does not accept ranges with negative steps, got: #{inspect(index_range)}"
+    end
+  end
+
+  # TODO: Remove me on v2.0
+  def slice(enumerable, %{__struct__: Range, first: first, last: last} = index_range) do
+    step = if first <= last, do: 1, else: -1
+    slice(enumerable, Map.put(index_range, :step, step))
+  end
+
+  defp slice_range(enumerable, first, -1, step) when first >= 0 do
+    if step == 1 do
+      drop(enumerable, first)
+    else
+      enumerable |> drop(first) |> take_every_list(step - 1)
+    end
+  end
+
+  defp slice_range(enumerable, first, last, step)
+       when last >= first and last >= 0 and first >= 0 do
+    slice_forward(enumerable, first, last - first + 1, step)
+  end
+
+  defp slice_range(enumerable, first, last, step) do
+    {count, fun} = slice_count_and_fun(enumerable, step)
+    first = if first >= 0, do: first, else: Kernel.max(first + count, 0)
+    last = if last >= 0, do: last, else: last + count
+    amount = last - first + 1
+
+    if first < count and amount > 0 do
+      amount = Kernel.min(amount, count - first)
+      amount = amount_with_step(amount, step)
+      fun.(first, amount, step)
+    else
+      []
+    end
+  end
+
+  defp amount_with_step(amount, 1), do: amount
+  defp amount_with_step(amount, step), do: div(amount - 1, step) + 1
+
+  @doc """
+  Returns a subset list of the given `enumerable`, from `start_index` (zero-based)
+  with `amount` number of elements if available.
+
+  Given an `enumerable`, it drops elements right before element `start_index`;
+  then, it takes `amount` of elements, returning as many elements as possible if
+  there are not enough elements.
+
+  A negative `start_index` can be passed, which means the `enumerable` is
+  enumerated once and the index is counted from the end (for example,
+  `-1` starts slicing from the last element).
+
+  It returns `[]` if `amount` is `0` or if `start_index` is out of bounds.
+
+  ## Examples
+
+      iex> Enum.slice(1..100, 5, 10)
+      [6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+
+      # amount to take is greater than the number of elements
+      iex> Enum.slice(1..10, 5, 100)
+      [6, 7, 8, 9, 10]
+
+      iex> Enum.slice(1..10, 5, 0)
+      []
+
+      # using a negative start index
+      iex> Enum.slice(1..10, -6, 3)
+      [5, 6, 7]
+      iex> Enum.slice(1..10, -11, 5)
+      [1, 2, 3, 4, 5]
+
+      # out of bound start index
+      iex> Enum.slice(1..10, 10, 5)
+      []
+
+  """
+  @spec slice(t, index, non_neg_integer) :: list
+  def slice(_enumerable, start_index, 0) when is_integer(start_index), do: []
+
+  def slice(enumerable, start_index, amount)
+      when is_integer(start_index) and start_index < 0 and is_integer(amount) and amount >= 0 do
+    {count, fun} = slice_count_and_fun(enumerable, 1)
+    start_index = Kernel.max(count + start_index, 0)
+    amount = Kernel.min(amount, count - start_index)
+
+    if amount > 0 do
+      fun.(start_index, amount, 1)
+    else
+      []
+    end
+  end
+
+  def slice(enumerable, start_index, amount)
+      when is_integer(start_index) and is_integer(amount) and amount >= 0 do
+    slice_forward(enumerable, start_index, amount, 1)
+  end
+
+  @doc """
+  Sorts the `enumerable` according to Erlang's term ordering.
+
+  This function uses the merge sort algorithm. Do not use this
+  function to sort structs, see `sort/2` for more information.
+
+  ## Examples
+
+      iex> Enum.sort([3, 2, 1])
+      [1, 2, 3]
+
+  """
+  @spec sort(t) :: list
+  def sort(enumerable) when is_list(enumerable) do
+    :lists.sort(enumerable)
+  end
+
+  def sort(enumerable) do
+    sort(enumerable, &(&1 <= &2))
+  end
+
+  @doc """
+  Sorts the `enumerable` by the given function.
+
+  This function uses the merge sort algorithm. The given function should compare
+  two arguments, and return `true` if the first argument precedes or is in the
+  same place as the second one.
+
+  ## Examples
+
+      iex> Enum.sort([1, 2, 3], &(&1 >= &2))
+      [3, 2, 1]
+
+  The sorting algorithm will be stable as long as the given function
+  returns `true` for values considered equal:
+
+      iex> Enum.sort(["some", "kind", "of", "monster"], &(byte_size(&1) <= byte_size(&2)))
+      ["of", "some", "kind", "monster"]
+
+  If the function does not return `true` for equal values, the sorting
+  is not stable and the order of equal terms may be shuffled.
+  For example:
+
+      iex> Enum.sort(["some", "kind", "of", "monster"], &(byte_size(&1) < byte_size(&2)))
+      ["of", "kind", "some", "monster"]
+
+  ## Ascending and descending (since v1.10.0)
+
+  `sort/2` allows a developer to pass `:asc` or `:desc` as the sorter, which is a convenience for
+  [`&<=/2`](`<=/2`) and [`&>=/2`](`>=/2`) respectively.
+
+      iex> Enum.sort([2, 3, 1], :asc)
+      [1, 2, 3]
+      iex> Enum.sort([2, 3, 1], :desc)
+      [3, 2, 1]
+
+  ## Sorting structs
+
+  Do not use `</2`, `<=/2`, `>/2`, `>=/2` and friends when sorting structs.
+  That's because the built-in operators above perform structural comparison
+  and not a semantic one. Imagine we sort the following list of dates:
+
+      iex> dates = [~D[2019-01-01], ~D[2020-03-02], ~D[2019-06-06]]
+      iex> Enum.sort(dates)
+      [~D[2019-01-01], ~D[2020-03-02], ~D[2019-06-06]]
+
+  Note that the returned result is incorrect, because `sort/1` by default uses
+  `<=/2`, which will compare their structure. When comparing structures, the
+  fields are compared in alphabetical order, which means the dates above will
+  be compared by `day`, `month` and then `year`, which is the opposite of what
+  we want.
+
+  For this reason, most structs provide a "compare" function, such as
+  `Date.compare/2`, which receives two structs and returns `:lt` (less-than),
+  `:eq` (equal to), and `:gt` (greater-than). If you pass a module as the
+  sorting function, Elixir will automatically use the `compare/2` function
+  of said module:
+
+      iex> dates = [~D[2019-01-01], ~D[2020-03-02], ~D[2019-06-06]]
+      iex> Enum.sort(dates, Date)
+      [~D[2019-01-01], ~D[2019-06-06], ~D[2020-03-02]]
+
+  To retrieve all dates in descending order, you can wrap the module in
+  a tuple with `:asc` or `:desc` as first element:
+
+      iex> dates = [~D[2019-01-01], ~D[2020-03-02], ~D[2019-06-06]]
+      iex> Enum.sort(dates, {:asc, Date})
+      [~D[2019-01-01], ~D[2019-06-06], ~D[2020-03-02]]
+      iex> dates = [~D[2019-01-01], ~D[2020-03-02], ~D[2019-06-06]]
+      iex> Enum.sort(dates, {:desc, Date})
+      [~D[2020-03-02], ~D[2019-06-06], ~D[2019-01-01]]
+
+  """
+  @spec sort(
+          t,
+          (element, element -> boolean) | :asc | :desc | module() | {:asc | :desc, module()}
+        ) :: list
+  def sort(enumerable, sorter) when is_list(enumerable) do
+    case sorter do
+      :asc -> :lists.sort(enumerable)
+      :desc -> :lists.sort(enumerable) |> :lists.reverse()
+      _ -> :lists.sort(to_sort_fun(sorter), enumerable)
+    end
+  end
+
+  def sort(enumerable, sorter) do
+    fun = to_sort_fun(sorter)
+
+    reduce(enumerable, [], &sort_reducer(&1, &2, fun))
+    |> sort_terminator(fun)
+  end
+
+  defp to_sort_fun(sorter) when is_function(sorter, 2), do: sorter
+  defp to_sort_fun(:asc), do: &<=/2
+  defp to_sort_fun(:desc), do: &>=/2
+  defp to_sort_fun(module) when is_atom(module), do: &(module.compare(&1, &2) != :gt)
+  defp to_sort_fun({:asc, module}) when is_atom(module), do: &(module.compare(&1, &2) != :gt)
+  defp to_sort_fun({:desc, module}) when is_atom(module), do: &(module.compare(&1, &2) != :lt)
+
+  @doc """
+  Sorts the mapped results of the `enumerable` according to the provided `sorter`
+  function.
+
+  This function maps each element of the `enumerable` using the
+  provided `mapper` function. The enumerable is then sorted by
+  the mapped elements using the `sorter`, which defaults to `:asc`
+  and sorts the elements ascendingly.
+
+  `sort_by/3` differs from `sort/2` in that it only calculates the
+  comparison value for each element in the enumerable once instead of
+  once for each element in each comparison. If the same function is
+  being called on both elements, it's more efficient to use `sort_by/3`.
+
+  ## Ascending and descending (since v1.10.0)
+
+  `sort_by/3` allows a developer to pass `:asc` or `:desc` as the sorter,
+  which is a convenience for [`&<=/2`](`<=/2`) and [`&>=/2`](`>=/2`) respectively:
+      iex> Enum.sort_by([2, 3, 1], &(&1), :asc)
+      [1, 2, 3]
+
+      iex> Enum.sort_by([2, 3, 1], &(&1), :desc)
+      [3, 2, 1]
+
+  ## Examples
+
+  Using the default `sorter` of `:asc` :
+
+      iex> Enum.sort_by(["some", "kind", "of", "monster"], &byte_size/1)
+      ["of", "some", "kind", "monster"]
+
+  Sorting by multiple properties - first by size, then by first letter
+  (this takes advantage of the fact that tuples are compared element-by-element):
+
+      iex> Enum.sort_by(["some", "kind", "of", "monster"], &{byte_size(&1), String.first(&1)})
+      ["of", "kind", "some", "monster"]
+
+  Similar to `sort/2`, you can pass a custom sorter:
+
+      iex> Enum.sort_by(["some", "kind", "of", "monster"], &byte_size/1, :desc)
+      ["monster", "some", "kind", "of"]
+
+  As in `sort/2`, avoid using the default sorting function to sort
+  structs, as by default it performs structural comparison instead of
+  a semantic one. In such cases, you shall pass a sorting function as
+  third element or any module that implements a `compare/2` function.
+  For example, to sort users by their birthday in both ascending and
+  descending order respectively:
+
+      iex> users = [
+      ...>   %{name: "Ellis", birthday: ~D[1943-05-11]},
+      ...>   %{name: "Lovelace", birthday: ~D[1815-12-10]},
+      ...>   %{name: "Turing", birthday: ~D[1912-06-23]}
+      ...> ]
+      iex> Enum.sort_by(users, &(&1.birthday), Date)
+      [
+        %{name: "Lovelace", birthday: ~D[1815-12-10]},
+        %{name: "Turing", birthday: ~D[1912-06-23]},
+        %{name: "Ellis", birthday: ~D[1943-05-11]}
+      ]
+      iex> Enum.sort_by(users, &(&1.birthday), {:desc, Date})
+      [
+        %{name: "Ellis", birthday: ~D[1943-05-11]},
+        %{name: "Turing", birthday: ~D[1912-06-23]},
+        %{name: "Lovelace", birthday: ~D[1815-12-10]}
+      ]
+
+  ## Performance characteristics
+
+  As detailed in the initial section, `sort_by/3` calculates the comparison
+  value for each element in the enumerable once instead of once for each
+  element in each comparison. This implies `sort_by/3` must do an initial
+  pass on the data to compute those values.
+
+  However, if those values are cheap to compute, for example, you have
+  already extracted the field you want to sort by into a tuple, then those
+  extra passes become overhead. In such cases, consider using `List.keysort/3`
+  instead.
+
+  Let's see an example. Imagine you have a list of products and you have a
+  list of IDs. You want to keep all products that are in the given IDs and
+  return their names sorted by their price. You could write it like this:
+
+      for(
+        product <- products,
+        product.id in ids,
+        do: product
+      )
+      |> Enum.sort_by(& &1.price)
+      |> Enum.map(& &1.name)
+
+  However, you could also write it like this:
+
+      for(
+        product <- products,
+        product.id in ids,
+        do: {product.name, product.price}
+      )
+      |> List.keysort(1)
+      |> Enum.map(&elem(&1, 0))
+
+  Using `List.keysort/3` will be a better choice for performance sensitive
+  code as it avoids additional traversals.
+  """
+  @spec sort_by(
+          t,
+          (element -> mapped_element),
+          (element, element -> boolean) | :asc | :desc | module() | {:asc | :desc, module()}
+        ) ::
+          list
+        when mapped_element: element
+  def sort_by(enumerable, mapper, sorter \\ :asc)
+
+  def sort_by(enumerable, mapper, :desc) when is_function(mapper, 1) do
+    enumerable
+    |> reduce([], &[{&1, mapper.(&1)} | &2])
+    |> List.keysort(1, :asc)
+    |> List.foldl([], &[elem(&1, 0) | &2])
+  end
+
+  def sort_by(enumerable, mapper, sorter) when is_function(mapper, 1) do
+    enumerable
+    |> map(&{&1, mapper.(&1)})
+    |> List.keysort(1, sorter)
+    |> map(&elem(&1, 0))
+  end
+
+  @doc """
+  Splits the `enumerable` into two enumerables, leaving `count`
+  elements in the first one.
+
+  If `count` is a negative number, it starts counting from the
+  back to the beginning of the `enumerable`.
+
+  Be aware that a negative `count` implies the `enumerable`
+  will be enumerated twice: once to calculate the position, and
+  a second time to do the actual splitting.
+
+  ## Examples
+
+      iex> Enum.split([1, 2, 3], 2)
+      {[1, 2], [3]}
+
+      iex> Enum.split([1, 2, 3], 10)
+      {[1, 2, 3], []}
+
+      iex> Enum.split([1, 2, 3], 0)
+      {[], [1, 2, 3]}
+
+      iex> Enum.split([1, 2, 3], -1)
+      {[1, 2], [3]}
+
+      iex> Enum.split([1, 2, 3], -5)
+      {[], [1, 2, 3]}
+
+  """
+  @spec split(t, integer) :: {list, list}
+  def split(enumerable, count) when is_list(enumerable) and is_integer(count) and count >= 0 do
+    split_list(enumerable, count, [])
+  end
+
+  def split(enumerable, count) when is_integer(count) and count >= 0 do
+    {_, list1, list2} =
+      reduce(enumerable, {count, [], []}, fn entry, {counter, acc1, acc2} ->
+        if counter > 0 do
+          {counter - 1, [entry | acc1], acc2}
+        else
+          {counter, acc1, [entry | acc2]}
+        end
+      end)
+
+    {:lists.reverse(list1), :lists.reverse(list2)}
+  end
+
+  def split(enumerable, count) when is_integer(count) and count < 0 do
+    split_reverse_list(reverse(enumerable), -count, [])
+  end
+
+  @doc """
+  Splits enumerable in two at the position of the element for which
+  `fun` returns a falsy value (`false` or `nil`) for the first time.
+
+  It returns a two-element tuple with two lists of elements.
+  The element that triggered the split is part of the second list.
+
+  ## Examples
+
+      iex> Enum.split_while([1, 2, 3, 4], fn x -> x < 3 end)
+      {[1, 2], [3, 4]}
+
+      iex> Enum.split_while([1, 2, 3, 4], fn x -> x < 0 end)
+      {[], [1, 2, 3, 4]}
+
+      iex> Enum.split_while([1, 2, 3, 4], fn x -> x > 0 end)
+      {[1, 2, 3, 4], []}
+
+  """
+  @spec split_while(t, (element -> as_boolean(term))) :: {list, list}
+  def split_while(enumerable, fun) when is_list(enumerable) do
+    split_while_list(enumerable, fun, [])
+  end
+
+  def split_while(enumerable, fun) do
+    {list1, list2} =
+      reduce(enumerable, {[], []}, fn
+        entry, {acc1, []} ->
+          if(fun.(entry), do: {[entry | acc1], []}, else: {acc1, [entry]})
+
+        entry, {acc1, acc2} ->
+          {acc1, [entry | acc2]}
+      end)
+
+    {:lists.reverse(list1), :lists.reverse(list2)}
+  end
+
+  @doc """
+  Returns the sum of all elements.
+
+  Raises `ArithmeticError` if `enumerable` contains a non-numeric value.
+
+  If you need to apply a transformation first, consider using `Enum.sum_by/2` instead.
+
+  ## Examples
+
+      iex> Enum.sum([1, 2, 3])
+      6
+
+      iex> Enum.sum(1..10)
+      55
+
+      iex> Enum.sum(1..10//2)
+      25
+
+  """
+  @spec sum(t) :: number
+  def sum(enumerable)
+
+  def sum(first..last//step = range) do
+    range
+    |> Range.size()
+    |> Kernel.*(first + last - rem(last - first, step))
+    |> div(2)
+  end
+
+  def sum(enumerable) do
+    reduce(enumerable, 0, &+/2)
+  end
+
+  @doc """
+  Maps and sums the given `enumerable` in one pass.
+
+  Raises `ArithmeticError` if `mapper` returns a non-numeric value.
+
+  ## Examples
+
+      iex> Enum.sum_by([%{count: 1}, %{count: 2}, %{count: 3}], fn x -> x.count end)
+      6
+
+      iex> Enum.sum_by(1..3, fn x -> x ** 2 end)
+      14
+
+      iex> Enum.sum_by([], fn x -> x.count end)
+      0
+
+  Filtering can be achieved by returning `0` to ignore elements:
+
+      iex> Enum.sum_by([1, -2, 3], fn x -> if x > 0, do: x, else: 0 end)
+      4
+
+  """
+  @doc since: "1.18.0"
+  @spec sum_by(t, (element -> number)) :: number
+  def sum_by(enumerable, mapper)
+
+  def sum_by(list, mapper) when is_list(list) and is_function(mapper, 1) do
+    sum_by_list(list, mapper, 0)
+  end
+
+  def sum_by(enumerable, mapper) when is_function(mapper, 1) do
+    reduce(enumerable, 0, fn x, acc -> acc + mapper.(x) end)
+  end
+
+  @doc """
+  Returns the product of all elements.
+
+  Raises `ArithmeticError` if `enumerable` contains a non-numeric value.
+
+  If you need to apply a transformation first, consider using `Enum.product_by/2` instead.
+
+  ## Examples
+
+      iex> Enum.product([])
+      1
+      iex> Enum.product([2, 3, 4])
+      24
+      iex> Enum.product([2.0, 3.0, 4.0])
+      24.0
+
+  """
+  @doc since: "1.12.0"
+  @spec product(t) :: number
+  def product(enumerable) do
+    reduce(enumerable, 1, &*/2)
+  end
+
+  @doc """
+  Maps and computes the product of the given `enumerable` in one pass.
+
+  Raises `ArithmeticError` if `mapper` returns a non-numeric value.
+
+  ## Examples
+
+      iex> Enum.product_by([%{count: 2}, %{count: 4}, %{count: 3}], fn x -> x.count end)
+      24
+
+      iex> Enum.product_by(1..3, fn x -> x ** 2 end)
+      36
+
+      iex> Enum.product_by([], fn x -> x.count end)
+      1
+
+  Filtering can be achieved by returning `1` to ignore elements:
+
+      iex> Enum.product_by([2, -1, 3], fn x -> if x > 0, do: x, else: 1 end)
+      6
+
+  """
+  @doc since: "1.18.0"
+  @spec product_by(t, (element -> number)) :: number
+  def product_by(enumerable, mapper)
+
+  def product_by(list, mapper) when is_list(list) and is_function(mapper, 1) do
+    product_by_list(list, mapper, 1)
+  end
+
+  def product_by(enumerable, mapper) when is_function(mapper, 1) do
+    reduce(enumerable, 1, fn x, acc -> acc * mapper.(x) end)
+  end
+
+  @doc """
+  Takes an `amount` of elements from the beginning or the end of the `enumerable`.
+
+  If a positive `amount` is given, it takes the `amount` elements from the
+  beginning of the `enumerable`.
+
+  If a negative `amount` is given, the `amount` of elements will be taken from the end.
+  The `enumerable` will be enumerated once to retrieve the proper index and
+  the remaining calculation is performed from the end.
+
+  If amount is `0`, it returns `[]`.
+
+  ## Examples
+
+      iex> Enum.take([1, 2, 3], 2)
+      [1, 2]
+
+      iex> Enum.take([1, 2, 3], 10)
+      [1, 2, 3]
+
+      iex> Enum.take([1, 2, 3], 0)
+      []
+
+      iex> Enum.take([1, 2, 3], -1)
+      [3]
+
+  """
+  @spec take(t, integer) :: list
+  def take(enumerable, amount)
+
+  def take(_enumerable, 0), do: []
+
+  def take(enumerable, amount)
+      when is_list(enumerable) and is_integer(amount) and amount > 0 do
+    take_list(enumerable, amount)
+  end
+
+  def take(enumerable, amount) when is_integer(amount) and amount > 0 do
+    {_, {res, _}} =
+      Enumerable.reduce(enumerable, {:cont, {[], amount}}, fn entry, {list, n} ->
+        case n do
+          1 -> {:halt, {[entry | list], n - 1}}
+          _ -> {:cont, {[entry | list], n - 1}}
+        end
+      end)
+
+    :lists.reverse(res)
+  end
+
+  def take(enumerable, amount) when is_integer(amount) and amount < 0 do
+    case slice_count_and_fun(enumerable, 1) do
+      {0, _fun} ->
+        []
+
+      {count, fun} ->
+        first = Kernel.max(amount + count, 0)
+        fun.(first, count - first, 1)
+    end
+  end
+
+  @doc """
+  Returns a list of every `nth` element in the `enumerable`,
+  starting with the first element.
+
+  The first element is always included, unless `nth` is 0.
+
+  The second argument specifying every `nth` element must be a non-negative
+  integer.
+
+  ## Examples
+
+      iex> Enum.take_every(1..10, 2)
+      [1, 3, 5, 7, 9]
+
+      iex> Enum.take_every(1..10, 0)
+      []
+
+      iex> Enum.take_every([1, 2, 3], 1)
+      [1, 2, 3]
+
+  """
+  @spec take_every(t, non_neg_integer) :: list
+  def take_every(enumerable, nth)
+
+  def take_every(_enumerable, 0), do: []
+  def take_every(enumerable, 1), do: to_list(enumerable)
+
+  def take_every(list, nth) when is_list(list) and is_integer(nth) and nth > 1 do
+    take_every_list(list, nth - 1)
+  end
+
+  def take_every(enumerable, nth) when is_integer(nth) and nth > 1 do
+    {res, _} = reduce(enumerable, {[], :first}, R.take_every(nth))
+    :lists.reverse(res)
+  end
+
+  @doc """
+  Takes `count` random elements from `enumerable`.
+
+  Note that this function will traverse the whole `enumerable` to
+  get the random sublist.
+
+  See `random/1` for notes on implementation and random seed.
+
+  ## Examples
+
+      # Although not necessary, let's seed the random algorithm
+      iex> :rand.seed(:exsss, {1, 2, 3})
+      iex> Enum.take_random(1..10, 2)
+      [6, 1]
+      iex> Enum.take_random(?a..?z, 5)
+      ~c"bkzmt"
+
+  """
+  @spec take_random(t, non_neg_integer) :: list
+  def take_random(enumerable, count)
+  def take_random(_enumerable, 0), do: []
+  def take_random([], _), do: []
+
+  def take_random(enumerable, 1) do
+    enumerable
+    |> reduce({0, 0, 1.0, nil}, fn
+      elem, {idx, idx, w, _current} ->
+        {jdx, w} = take_jdx_w(idx, w, 1)
+        {idx + 1, jdx, w, elem}
+
+      _elem, {idx, jdx, w, current} ->
+        {idx + 1, jdx, w, current}
+    end)
+    |> case do
+      {0, 0, 1.0, nil} -> []
+      {_idx, _jdx, _w, current} -> [current]
+    end
+  end
+
+  def take_random(enumerable, count) when count in 0..128 do
+    sample = Tuple.duplicate(nil, count)
+
+    reducer = fn
+      elem, {idx, jdx, w, sample} when idx < count ->
+        rand = take_index(idx)
+        sample = sample |> put_elem(idx, elem(sample, rand)) |> put_elem(rand, elem)
+
+        if idx == jdx do
+          {jdx, w} = take_jdx_w(idx, w, count)
+          {idx + 1, jdx, w, sample}
+        else
+          {idx + 1, jdx, w, sample}
+        end
+
+      elem, {idx, idx, w, sample} ->
+        pos = :rand.uniform(count) - 1
+        {jdx, w} = take_jdx_w(idx, w, count)
+        {idx + 1, jdx, w, put_elem(sample, pos, elem)}
+
+      _elem, {idx, jdx, w, sample} ->
+        {idx + 1, jdx, w, sample}
+    end
+
+    {size, _, _, sample} = reduce(enumerable, {0, count - 1, 1.0, sample}, reducer)
+
+    if count < size do
+      Tuple.to_list(sample)
+    else
+      take_tupled(sample, size, [])
+    end
+  end
+
+  def take_random(enumerable, count) when is_integer(count) and count >= 0 do
+    reducer = fn
+      elem, {idx, jdx, w, sample} when idx < count ->
+        rand = take_index(idx)
+        sample = sample |> Map.put(idx, Map.get(sample, rand)) |> Map.put(rand, elem)
+
+        if idx == jdx do
+          {jdx, w} = take_jdx_w(idx, w, count)
+          {idx + 1, jdx, w, sample}
+        else
+          {idx + 1, jdx, w, sample}
+        end
+
+      elem, {idx, idx, w, sample} ->
+        pos = :rand.uniform(count) - 1
+        {jdx, w} = take_jdx_w(idx, w, count)
+        {idx + 1, jdx, w, %{sample | pos => elem}}
+
+      _elem, {idx, jdx, w, sample} ->
+        {idx + 1, jdx, w, sample}
+    end
+
+    {size, _, _, sample} = reduce(enumerable, {0, count - 1, 1.0, %{}}, reducer)
+    take_mapped(sample, Kernel.min(count, size), [])
+  end
+
+  @compile {:inline, take_jdx_w: 3, take_index: 1}
+  defp take_jdx_w(idx, w, count) do
+    w = w * :math.exp(:math.log(:rand.uniform()) / count)
+    jdx = idx + floor(:math.log(:rand.uniform()) / :math.log(1 - w)) + 1
+    {jdx, w}
+  end
+
+  defp take_index(0), do: 0
+  defp take_index(idx), do: :rand.uniform(idx + 1) - 1
+
+  defp take_tupled(_sample, 0, acc), do: acc
+
+  defp take_tupled(sample, position, acc) do
+    position = position - 1
+    take_tupled(sample, position, [elem(sample, position) | acc])
+  end
+
+  defp take_mapped(_sample, 0, acc), do: acc
+
+  defp take_mapped(sample, position, acc) do
+    position = position - 1
+    take_mapped(sample, position, [Map.fetch!(sample, position) | acc])
+  end
+
+  @doc """
+  Takes the elements from the beginning of the `enumerable` while `fun` returns
+  a truthy value.
+
+  ## Examples
+
+      iex> Enum.take_while([1, 2, 3], fn x -> x < 3 end)
+      [1, 2]
+
+  """
+  @spec take_while(t, (element -> as_boolean(term))) :: list
+  def take_while(enumerable, fun) when is_list(enumerable) do
+    take_while_list(enumerable, fun)
+  end
+
+  def take_while(enumerable, fun) do
+    {_, res} =
+      Enumerable.reduce(enumerable, {:cont, []}, fn entry, acc ->
+        if fun.(entry) do
+          {:cont, [entry | acc]}
+        else
+          {:halt, acc}
+        end
+      end)
+
+    :lists.reverse(res)
+  end
+
+  @doc """
+  Converts `enumerable` to a list.
+
+  ## Examples
+
+      iex> Enum.to_list(1..3)
+      [1, 2, 3]
+
+  """
+  @spec to_list(t) :: [element]
+  def to_list(enumerable) when is_list(enumerable), do: enumerable
+  def to_list(%{__struct__: Range} = range), do: Range.to_list(range)
+  def to_list(%_{} = enumerable), do: reverse(enumerable) |> :lists.reverse()
+  def to_list(%{} = enumerable), do: Map.to_list(enumerable)
+  def to_list(enumerable), do: reverse(enumerable) |> :lists.reverse()
+
+  @doc """
+  Enumerates the `enumerable`, removing all duplicate elements.
+
+  The first occurrence of each element is kept and all following
+  duplicates are removed. The overall order is preserved.
+
+  ## Examples
+
+      iex> Enum.uniq([1, 2, 3, 3, 2, 1])
+      [1, 2, 3]
+
+  """
+  @spec uniq(t) :: list
+  def uniq(enumerable) do
+    uniq_by(enumerable, fn x -> x end)
+  end
+
+  @doc false
+  @deprecated "Use Enum.uniq_by/2 instead"
+  def uniq(enumerable, fun) do
+    uniq_by(enumerable, fun)
+  end
+
+  @doc """
+  Enumerates the `enumerable`, by removing the elements for which
+  function `fun` returned duplicate elements.
+
+  The function `fun` maps every element to a term. Two elements are
+  considered duplicates if the return value of `fun` is equal for
+  both of them.
+
+  The first occurrence of each element is kept and all following
+  duplicates are removed. The overall order is preserved.
+
+  ## Example
+
+      iex> Enum.uniq_by([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end)
+      [{1, :x}, {2, :y}]
+
+      iex> Enum.uniq_by([a: {:tea, 2}, b: {:tea, 2}, c: {:coffee, 1}], fn {_, y} -> y end)
+      [a: {:tea, 2}, c: {:coffee, 1}]
+
+  """
+  @spec uniq_by(t, (element -> term)) :: list
+
+  def uniq_by(enumerable, fun) when is_list(enumerable) do
+    uniq_list(enumerable, %{}, fun)
+  end
+
+  def uniq_by(enumerable, fun) do
+    {list, _} = reduce(enumerable, {[], %{}}, R.uniq_by(fun))
+    :lists.reverse(list)
+  end
+
+  @doc """
+  Opposite of `zip/2`. Extracts two-element tuples from the
+  given `enumerable` and groups them together.
+
+  It takes an `enumerable` with elements being two-element tuples and returns
+  a tuple with two lists, each of which is formed by the first and
+  second element of each tuple, respectively.
+
+  This function fails unless `enumerable` is or can be converted into a
+  list of tuples with *exactly* two elements in each tuple.
+
+  ## Examples
+
+      iex> Enum.unzip([{:a, 1}, {:b, 2}, {:c, 3}])
+      {[:a, :b, :c], [1, 2, 3]}
+
+  """
+  @spec unzip(t) :: {[element], [element]}
+  def unzip(enumerable)
+
+  def unzip([_ | _] = list) do
+    :lists.reverse(list) |> unzip([], [])
+  end
+
+  def unzip([]) do
+    {[], []}
+  end
+
+  def unzip(enumerable) do
+    {list1, list2} =
+      reduce(enumerable, {[], []}, fn {el1, el2}, {list1, list2} ->
+        {[el1 | list1], [el2 | list2]}
+      end)
 
     {:lists.reverse(list1), :lists.reverse(list2)}
   end
 
-  def split(collection, count) when count < 0 do
-    do_split_reverse(reverse(collection), abs(count), [])
+  defp unzip([{el1, el2} | reversed_list], list1, list2) do
+    unzip(reversed_list, [el1 | list1], [el2 | list2])
+  end
+
+  defp unzip([], list1, list2) do
+    {list1, list2}
+  end
+
+  @doc """
+  Returns the `enumerable` with each element wrapped in a tuple
+  alongside its index or according to a given function.
+
+  If an integer offset is given as `fun_or_offset`, it will index from the given
+  offset instead of from zero.
+
+  If a 2-arity function is given as `fun_or_offset`, the function will be invoked
+  for each element in `enumerable` as the first argument and with a zero-based
+  index as the second. `with_index/2` returns a list with the result of each invocation.
+
+  ## Examples
+
+      iex> Enum.with_index([:a, :b, :c])
+      [a: 0, b: 1, c: 2]
+
+      iex> Enum.with_index([:a, :b, :c], 3)
+      [a: 3, b: 4, c: 5]
+
+      iex> Enum.with_index([:a, :b, :c], fn element, index -> {index, element} end)
+      [{0, :a}, {1, :b}, {2, :c}]
+
+  """
+  @spec with_index(t, integer) :: [{term, integer}]
+  @spec with_index(t, (element, index -> value)) :: [value] when value: any
+  def with_index(enumerable, fun_or_offset \\ 0)
+
+  def with_index(enumerable, offset) when is_list(enumerable) and is_integer(offset) do
+    with_index_list(enumerable, offset)
+  end
+
+  def with_index(enumerable, fun) when is_list(enumerable) and is_function(fun, 2) do
+    with_index_list(enumerable, 0, fun)
+  end
+
+  def with_index(enumerable, offset) when is_integer(offset) do
+    enumerable
+    |> map_reduce(offset, fn x, i -> {{x, i}, i + 1} end)
+    |> elem(0)
+  end
+
+  def with_index(enumerable, fun) when is_function(fun, 2) do
+    enumerable
+    |> map_reduce(0, fn x, i -> {fun.(x, i), i + 1} end)
+    |> elem(0)
+  end
+
+  @doc """
+  Zips corresponding elements from two enumerables into a list
+  of tuples.
+
+  Because a list of two-element tuples with atoms as the first
+  tuple element is a keyword list (`Keyword`), zipping a first list
+  of atoms with a second list of any kind creates a keyword list.
+
+  The zipping finishes as soon as either enumerable completes.
+
+  ## Examples
+
+      iex> Enum.zip([1, 2, 3], [:a, :b, :c])
+      [{1, :a}, {2, :b}, {3, :c}]
+
+      iex> Enum.zip([:a, :b, :c], [1, 2, 3])
+      [a: 1, b: 2, c: 3]
+
+      iex> Enum.zip([1, 2, 3, 4, 5], [:a, :b, :c])
+      [{1, :a}, {2, :b}, {3, :c}]
+
+  """
+  @spec zip(t, t) :: [{any, any}]
+  def zip(enumerable1, enumerable2) when is_list(enumerable1) and is_list(enumerable2) do
+    zip_list(enumerable1, enumerable2, [])
+  end
+
+  def zip(enumerable1, enumerable2) do
+    zip([enumerable1, enumerable2])
+  end
+
+  @doc """
+  Zips corresponding elements from a finite collection of enumerables
+  into a list of tuples.
+
+  The zipping finishes as soon as any enumerable in the given collection completes.
+
+  ## Examples
+
+      iex> Enum.zip([[1, 2, 3], [:a, :b, :c], ["foo", "bar", "baz"]])
+      [{1, :a, "foo"}, {2, :b, "bar"}, {3, :c, "baz"}]
+
+      iex> Enum.zip([[1, 2, 3, 4, 5], [:a, :b, :c]])
+      [{1, :a}, {2, :b}, {3, :c}]
+
+  """
+  @doc since: "1.4.0"
+  @spec zip(enumerables) :: [tuple()] when enumerables: [t()] | t()
+  def zip([]), do: []
+
+  def zip(enumerables) do
+    zip_reduce(enumerables, [], &[List.to_tuple(&1) | &2])
+    |> :lists.reverse()
+  end
+
+  @doc """
+  Zips corresponding elements from two enumerables into a list, transforming them with
+  the `zip_fun` function as it goes.
+
+  The corresponding elements from each collection are passed to the provided two-arity `zip_fun`
+  function in turn. Returns a list that contains the result of calling `zip_fun` for each pair of
+  elements.
+
+  The zipping finishes as soon as either enumerable runs out of elements.
+
+  ## Zipping Maps
+
+  It's important to remember that zipping inherently relies on order.
+  If you zip two lists you get the element at the index from each list in turn.
+  If we zip two maps together it's tempting to think that you will get the given
+  key in the left map and the matching key in the right map, but there is no such
+  guarantee because map keys are not ordered! Consider the following:
+
+      left = %{:a => 1, 1 => 3}
+      right = %{:a => 1, :b => :c}
+      Enum.zip(left, right)
+      #=> [{{1, 3}, {:a, 1}}, {{:a, 1}, {:b, :c}}]
+
+  As you can see `:a` does not get paired with `:a`. If this is what you want,
+  you should use `Map.merge/3`.
+
+  ## Examples
+
+      iex> Enum.zip_with([1, 2], [3, 4], fn x, y -> x + y end)
+      [4, 6]
+
+      iex> Enum.zip_with([1, 2], [3, 4, 5, 6], fn x, y -> x + y end)
+      [4, 6]
+
+      iex> Enum.zip_with([1, 2, 5, 6], [3, 4], fn x, y -> x + y end)
+      [4, 6]
+
+  """
+  @doc since: "1.12.0"
+  @spec zip_with(t, t, (enum1_elem :: term, enum2_elem :: term -> term)) :: [term]
+  def zip_with(enumerable1, enumerable2, zip_fun)
+      when is_list(enumerable1) and is_list(enumerable2) and is_function(zip_fun, 2) do
+    zip_with_list(enumerable1, enumerable2, zip_fun)
+  end
+
+  def zip_with(enumerable1, enumerable2, zip_fun) when is_function(zip_fun, 2) do
+    zip_reduce(enumerable1, enumerable2, [], fn l, r, acc -> [zip_fun.(l, r) | acc] end)
+    |> :lists.reverse()
+  end
+
+  @doc """
+  Zips corresponding elements from a finite collection of enumerables
+  into list, transforming them with the `zip_fun` function as it goes.
+
+  The first element from each of the enums in `enumerables` will be put
+  into a list which is then passed to the one-arity `zip_fun` function.
+  Then, the second elements from each of the enums are put into a list
+  and passed to `zip_fun`, and so on until any one of the enums in
+  `enumerables` runs out of elements.
+
+  Returns a list with all the results of calling `zip_fun`.
+
+  ## Examples
+
+      iex> Enum.zip_with([[1, 2], [3, 4], [5, 6]], fn [x, y, z] -> x + y + z end)
+      [9, 12]
+
+      iex> Enum.zip_with([[1, 2], [3, 4]], fn [x, y] -> x + y end)
+      [4, 6]
+
+  """
+  @doc since: "1.12.0"
+  @spec zip_with(t, ([term] -> term)) :: [term]
+  def zip_with([], _fun), do: []
+
+  def zip_with(enumerables, zip_fun) do
+    zip_reduce(enumerables, [], fn values, acc -> [zip_fun.(values) | acc] end)
+    |> :lists.reverse()
+  end
+
+  @doc """
+  Reduces over two enumerables halting as soon as either enumerable is empty.
+
+  In practice, the behavior provided by this function can be achieved with:
+
+      Enum.reduce(Stream.zip(left, right), acc, reducer)
+
+  But `zip_reduce/4` exists for convenience purposes.
+
+  ## Examples
+
+      iex> Enum.zip_reduce([1, 2], [3, 4], 0, fn x, y, acc -> x + y + acc end)
+      10
+
+  If one of the lists has more entries than the others,
+  those entries are discarded:
+
+      iex> Enum.zip_reduce([1, 2, 3], [4, 5], [], fn x, y, acc -> [x + y | acc] end)
+      [7, 5]
+  """
+  @doc since: "1.12.0"
+  @spec zip_reduce(t, t, acc, (enum1_elem :: term, enum2_elem :: term, acc -> acc)) :: acc
+        when acc: term
+  def zip_reduce(left, right, acc, reducer)
+      when is_list(left) and is_list(right) and is_function(reducer, 3) do
+    zip_reduce_list(left, right, acc, reducer)
+  end
+
+  def zip_reduce(left, right, acc, reducer) when is_function(reducer, 3) do
+    reduce = fn [l, r], acc -> {:cont, reducer.(l, r, acc)} end
+    R.zip_with([left, right], & &1).({:cont, acc}, reduce) |> elem(1)
+  end
+
+  @doc """
+  Reduces over all of the given enumerables, halting as soon as any enumerable is
+  empty.
+
+  The reducer will receive 2 args: a list of elements (one from each enum) and the
+  accumulator.
+
+  In practice, the behavior provided by this function can be achieved with:
+
+      Enum.reduce(Stream.zip(enums), acc, reducer)
+
+  But `zip_reduce/3` exists for convenience purposes.
+
+  ## Examples
+
+      iex> enums = [[1, 1], [2, 2], [3, 3]]
+      ...>  Enum.zip_reduce(enums, [], fn elements, acc ->
+      ...>    [List.to_tuple(elements) | acc]
+      ...> end)
+      [{1, 2, 3}, {1, 2, 3}]
+
+  If one of the lists has more entries than the others,
+  those entries are discarded:
+
+      iex> enums = [[1, 2], [a: 3, b: 4], [5, 6, 7]]
+      ...> Enum.zip_reduce(enums, [], fn elements, acc ->
+      ...>   [List.to_tuple(elements) | acc]
+      ...> end)
+      [{2, {:b, 4}, 6}, {1, {:a, 3}, 5}]
+  """
+  @doc since: "1.12.0"
+  @spec zip_reduce(t, acc, ([term], acc -> acc)) :: acc when acc: term
+  def zip_reduce([], acc, reducer) when is_function(reducer, 2), do: acc
+
+  def zip_reduce(enumerables, acc, reducer) when is_function(reducer, 2) do
+    R.zip_with(enumerables, & &1).({:cont, acc}, &{:cont, reducer.(&1, &2)}) |> elem(1)
+  end
+
+  ## Helpers
+
+  @compile {:inline,
+            entry_to_string: 1,
+            reduce: 3,
+            reduce_by: 3,
+            reduce_enumerable: 3,
+            reduce_range: 5,
+            map_range: 4}
+
+  defp entry_to_string(entry) when is_binary(entry), do: entry
+  defp entry_to_string(entry), do: String.Chars.to_string(entry)
+
+  defp aggregate([head | tail], fun, _empty) do
+    aggregate_list(tail, head, fun)
+  end
+
+  defp aggregate([], _fun, empty) do
+    empty.()
+  end
+
+  defp aggregate(first..last//step = range, fun, empty) do
+    case Range.size(range) do
+      0 ->
+        empty.()
+
+      _ ->
+        last = last - rem(last - first, step)
+
+        case fun.(first, last) do
+          true -> first
+          false -> last
+        end
+    end
+  end
+
+  defp aggregate(enumerable, fun, empty) do
+    ref = make_ref()
+
+    enumerable
+    |> reduce(ref, fn
+      element, ^ref ->
+        element
+
+      element, acc ->
+        case fun.(acc, element) do
+          true -> acc
+          false -> element
+        end
+    end)
+    |> case do
+      ^ref -> empty.()
+      result -> result
+    end
+  end
+
+  defp aggregate_list([head | tail], acc, fun) do
+    acc =
+      case fun.(acc, head) do
+        true -> acc
+        false -> head
+      end
+
+    aggregate_list(tail, acc, fun)
+  end
+
+  defp aggregate_list([], acc, _fun), do: acc
+
+  defp aggregate_by(enumerable, fun, sorter, empty_fallback) do
+    first_fun = &[&1 | fun.(&1)]
+
+    reduce_fun = fn entry, [_ | fun_ref] = old ->
+      fun_entry = fun.(entry)
+
+      case sorter.(fun_ref, fun_entry) do
+        true -> old
+        false -> [entry | fun_entry]
+      end
+    end
+
+    case reduce_by(enumerable, first_fun, reduce_fun) do
+      :empty -> empty_fallback.()
+      [entry | _] -> entry
+    end
+  end
+
+  defp reduce_by([head | tail], first, fun) do
+    :lists.foldl(fun, first.(head), tail)
+  end
+
+  defp reduce_by([], _first, _fun) do
+    :empty
+  end
+
+  defp reduce_by(enumerable, first, fun) do
+    reduce(enumerable, :empty, fn
+      element, :empty -> first.(element)
+      element, acc -> fun.(element, acc)
+    end)
+  end
+
+  ## Implementations
+
+  ## all?/1
+
+  defp all_list([h | t]) do
+    if h do
+      all_list(t)
+    else
+      false
+    end
+  end
+
+  defp all_list([]) do
+    true
+  end
+
+  ## any?/1
+
+  defp any_list([h | t]) do
+    if h do
+      true
+    else
+      any_list(t)
+    end
+  end
+
+  defp any_list([]) do
+    false
   end
 
-  @doc """
-  Splits `collection` in two while `fun` returns `true`.
-
-  ## Examples
+  ## any?/2 all?/2
 
-      iex> Enum.split_while([1, 2, 3, 4], fn(x) -> x < 3 end)
-      {[1, 2], [3, 4]}
+  defp predicate_list([h | t], initial, fun) do
+    if !!fun.(h) == initial do
+      predicate_list(t, initial, fun)
+    else
+      not initial
+    end
+  end
 
-  """
-  @spec split_while(t, (element -> as_boolean(term))) :: {list, list}
-  def split_while(collection, fun) when is_list(collection) do
-    do_split_while(collection, fun, [])
+  defp predicate_list([], initial, _) do
+    initial
   end
 
-  def split_while(collection, fun) do
-    {list1, list2} =
-      reduce(collection, {[], []}, fn
-        entry, {acc1, []} ->
-          if(fun.(entry), do: {[entry|acc1], []}, else: {acc1, [entry]})
-        entry, {acc1, acc2} ->
-          {acc1, [entry|acc2]}
-      end)
+  defp predicate_range(first, last, step, initial, fun)
+       when step > 0 and first <= last
+       when step < 0 and first >= last do
+    if !!fun.(first) == initial do
+      predicate_range(first + step, last, step, initial, fun)
+    else
+      not initial
+    end
+  end
 
-    {:lists.reverse(list1), :lists.reverse(list2)}
+  defp predicate_range(_first, _last, _step, initial, _fun) do
+    initial
   end
 
-  @doc """
-  Takes the first `count` items from the collection.
+  ## concat
 
-  If a negative `count` is given, the last `count` values will
-  be taken. For such, the collection is fully enumerated keeping up
-  to `2 * count` elements in memory. Once the end of the collection is
-  reached, the last `count` elements are returned.
+  defp concat_list([h | t]) when is_list(h), do: h ++ concat_list(t)
+  defp concat_list([h | t]), do: concat_enum([h | t])
+  defp concat_list([]), do: []
 
-  ## Examples
+  defp concat_enum(enum) do
+    fun = &[&1 | &2]
+    enum |> reduce([], &reduce(&1, &2, fun)) |> :lists.reverse()
+  end
 
-      iex> Enum.take([1, 2, 3], 2)
-      [1,2]
+  # count_until
 
-      iex> Enum.take([1, 2, 3], 10)
-      [1,2,3]
+  @compile {:inline, count_until_list: 3}
 
-      iex> Enum.take([1, 2, 3], 0)
-      []
+  defp count_until_list([], _limit, acc), do: acc
 
-      iex> Enum.take([1, 2, 3], -1)
-      [3]
+  defp count_until_list([_head | tail], limit, acc) do
+    case acc + 1 do
+      ^limit -> limit
+      acc -> count_until_list(tail, limit, acc)
+    end
+  end
 
-  """
-  @spec take(t, integer) :: list
+  defp count_until_enum(enumerable, limit) do
+    case Enumerable.count(enumerable) do
+      {:ok, value} ->
+        Kernel.min(value, limit)
 
-  def take(_collection, 0) do
-    []
+      {:error, module} ->
+        module.reduce(enumerable, {:cont, 0}, fn _entry, acc ->
+          case acc + 1 do
+            ^limit -> {:halt, limit}
+            acc -> {:cont, acc}
+          end
+        end)
+        |> elem(1)
+    end
   end
 
-  def take(collection, count) when is_list(collection) and count > 0 do
-    do_take(collection, count)
-  end
+  @compile {:inline, count_until_list: 4}
 
-  def take(collection, count) when count > 0 do
-    {_, {res, _}} =
-      Enumerable.reduce(collection, {:cont, {[], count}}, fn(entry, {list, count}) ->
-        if count > 1 do
-          {:cont, {[entry|list], count - 1}}
-        else
-          {:halt, {[entry|list], count}}
-        end
-      end)
-    :lists.reverse(res)
+  defp count_until_list([], _fun, _limit, acc), do: acc
+
+  defp count_until_list([head | tail], fun, limit, acc) do
+    if fun.(head) do
+      case acc + 1 do
+        ^limit -> limit
+        acc -> count_until_list(tail, fun, limit, acc)
+      end
+    else
+      count_until_list(tail, fun, limit, acc)
+    end
   end
 
-  def take(collection, count) when count < 0 do
-    Stream.take(collection, count).({:cont, []}, &{:cont, [&1|&2]})
-    |> elem(1) |> :lists.reverse
+  defp count_until_enum(enumerable, fun, limit) do
+    Enumerable.reduce(enumerable, {:cont, 0}, fn entry, acc ->
+      if fun.(entry) do
+        case acc + 1 do
+          ^limit -> {:halt, limit}
+          acc -> {:cont, acc}
+        end
+      else
+        {:cont, acc}
+      end
+    end)
+    |> elem(1)
   end
 
-  @doc """
-  Returns a collection of every `nth` item in the collection,
-  starting with the first element.
+  # dedup
 
-  ## Examples
+  defp dedup_list([value | tail], acc) do
+    acc =
+      case acc do
+        [^value | _] -> acc
+        _ -> [value | acc]
+      end
 
-      iex> Enum.take_every(1..10, 2)
-      [1, 3, 5, 7, 9]
+    dedup_list(tail, acc)
+  end
 
-  """
-  @spec take_every(t, integer) :: list
-  def take_every(_collection, 0), do: []
-  def take_every(collection, nth) do
-    {_, {res, _}} =
-      Enumerable.reduce(collection, {:cont, {[], :first}}, R.take_every(nth))
-    :lists.reverse(res)
+  defp dedup_list([], acc) do
+    acc
   end
 
-  @doc """
-  Takes the items at the beginning of `collection` while `fun` returns `true`.
+  ## drop
 
-  ## Examples
+  defp drop_list(list, 0), do: list
+  defp drop_list([_ | tail], counter), do: drop_list(tail, counter - 1)
+  defp drop_list([], _), do: []
 
-      iex> Enum.take_while([1, 2, 3], fn(x) -> x < 3 end)
-      [1, 2]
+  ## drop_while
 
-  """
-  @spec take_while(t, (element -> as_boolean(term))) :: list
-  def take_while(collection, fun) when is_list(collection) do
-    do_take_while(collection, fun)
+  defp drop_while_list([head | tail], fun) do
+    if fun.(head) do
+      drop_while_list(tail, fun)
+    else
+      [head | tail]
+    end
   end
 
-  def take_while(collection, fun) do
-    Enumerable.reduce(collection, {:cont, []}, R.take_while(fun))
-    |> elem(1) |> :lists.reverse
+  defp drop_while_list([], _) do
+    []
   end
 
-  @doc """
-  Convert `collection` to a list.
-
-  ## Examples
+  ## filter
 
-      iex> Enum.to_list(1 .. 3)
-      [1, 2, 3]
+  defp filter_list([head | tail], fun) do
+    if fun.(head) do
+      [head | filter_list(tail, fun)]
+    else
+      filter_list(tail, fun)
+    end
+  end
 
-  """
-  @spec to_list(t) :: [term]
-  def to_list(collection) when is_list(collection) do
-    collection
+  defp filter_list([], _fun) do
+    []
   end
 
-  def to_list(collection) do
-    reverse(collection) |> :lists.reverse
+  ## find
+
+  defp find_list([head | tail], default, fun) do
+    if fun.(head) do
+      head
+    else
+      find_list(tail, default, fun)
+    end
   end
 
+  defp find_list([], default, _) do
+    default
+  end
 
-  @doc """
-  Traverses the given enumerable keeping its shape.
+  ## find_index
 
-  It also expects the enumerable to implement the `Collectable` protocol.
+  defp find_index_list([head | tail], counter, fun) do
+    if fun.(head) do
+      counter
+    else
+      find_index_list(tail, counter + 1, fun)
+    end
+  end
 
-  ## Examples
+  defp find_index_list([], _, _) do
+    nil
+  end
 
-      iex> Enum.traverse(%{a: 1, b: 2}, fn {k, v} -> {k, v * 2} end)
-      %{a: 2, b: 4}
+  ## find_value
 
-  """
-  @spec traverse(Enumerable.t, (term -> term)) :: Collectable.t
-  def traverse(collection, transform) when is_list(collection) do
-    :lists.map(transform, collection)
+  defp find_value_list([head | tail], default, fun) do
+    fun.(head) || find_value_list(tail, default, fun)
   end
 
-  def traverse(collection, transform) do
-    into(collection, Collectable.empty(collection), transform)
+  defp find_value_list([], default, _) do
+    default
   end
 
-  @doc """
-  Enumerates the collection, removing all duplicated items.
+  ## flat_map
 
-  ## Examples
+  defp flat_map_list([head | tail], fun) do
+    case fun.(head) do
+      # the two first clauses are an optimization
+      [] -> flat_map_list(tail, fun)
+      [elem] -> [elem | flat_map_list(tail, fun)]
+      list when is_list(list) -> list ++ flat_map_list(tail, fun)
+      other -> to_list(other) ++ flat_map_list(tail, fun)
+    end
+  end
 
-      iex> Enum.uniq([1, 2, 3, 2, 1])
-      [1, 2, 3]
+  defp flat_map_list([], _fun) do
+    []
+  end
 
-      iex> Enum.uniq([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end)
-      [{1,:x}, {2,:y}]
+  ## intersperse
 
-  """
-  @spec uniq(t) :: list
-  @spec uniq(t, (element -> term)) :: list
-  def uniq(collection, fun \\ fn x -> x end)
+  defp intersperse_non_empty_list([head], _separator), do: [head]
 
-  def uniq(collection, fun) when is_list(collection) do
-    do_uniq(collection, [], fun)
+  defp intersperse_non_empty_list([head | rest], separator) do
+    [head, separator | intersperse_non_empty_list(rest, separator)]
   end
 
-  def uniq(collection, fun) do
-    {_, {list, _}} =
-      Enumerable.reduce(collection, {:cont, {[], []}}, R.uniq(fun))
-    :lists.reverse(list)
-  end
+  ## join
 
-  @doc """
-  Zips corresponding elements from two collections into one list
-  of tuples.
+  defp join_list([], _joiner), do: ""
 
-  The zipping finishes as soon as any enumerable completes.
+  defp join_list(list, joiner) do
+    join_non_empty_list(list, joiner, [])
+    |> :lists.reverse()
+    |> IO.iodata_to_binary()
+  end
 
-  ## Examples
+  defp join_non_empty_list([first], _joiner, acc), do: [entry_to_string(first) | acc]
 
-      iex> Enum.zip([1, 2, 3], [:a, :b, :c])
-      [{1,:a},{2,:b},{3,:c}]
+  defp join_non_empty_list([first | rest], joiner, acc) do
+    join_non_empty_list(rest, joiner, [joiner, entry_to_string(first) | acc])
+  end
 
-      iex> Enum.zip([1,2,3,4,5], [:a, :b, :c])
-      [{1,:a},{2,:b},{3,:c}]
+  ## map
 
-  """
-  @spec zip(t, t) :: [{any, any}]
-  def zip(coll1, coll2) when is_list(coll1) and is_list(coll2) do
-    do_zip(coll1, coll2)
+  defp map_range(first, last, step, fun)
+       when step > 0 and first <= last
+       when step < 0 and first >= last do
+    [fun.(first) | map_range(first + step, last, step, fun)]
   end
 
-  def zip(coll1, coll2) do
-    Stream.zip(coll1, coll2).({:cont, []}, &{:cont, [&1|&2]}) |> elem(1) |> :lists.reverse
+  defp map_range(_first, _last, _step, _fun) do
+    []
   end
 
-  @doc """
-  Returns the collection with each element wrapped in a tuple
-  alongside its index.
-
-  ## Examples
+  ## map_intersperse
 
-      iex> Enum.with_index [1,2,3]
-      [{1,0},{2,1},{3,2}]
+  defp map_intersperse_list([], _, _),
+    do: []
 
-  """
-  @spec with_index(t) :: list({element, non_neg_integer})
-  def with_index(collection) do
-    map_reduce(collection, 0, fn x, acc ->
-      {{x, acc}, acc + 1}
-    end) |> elem(0)
-  end
+  defp map_intersperse_list([last], _, mapper),
+    do: [mapper.(last)]
 
-  ## Helpers
+  defp map_intersperse_list([head | rest], separator, mapper),
+    do: [mapper.(head), separator | map_intersperse_list(rest, separator, mapper)]
 
-  @compile {:inline, enum_to_string: 1}
+  ## reduce
 
-  defp enumerate_and_count(collection, count) when is_list(collection) do
-    {collection, length(collection) - abs(count)}
+  defp reduce_range(first, last, step, acc, fun)
+       when step > 0 and first <= last
+       when step < 0 and first >= last do
+    reduce_range(first + step, last, step, fun.(first, acc), fun)
   end
 
-  defp enumerate_and_count(collection, count) do
-    map_reduce(collection, -abs(count), fn(x, acc) -> {x, acc + 1} end)
+  defp reduce_range(_first, _last, _step, acc, _fun) do
+    acc
   end
 
-  defp enum_to_string(entry) when is_binary(entry), do: entry
-  defp enum_to_string(entry), do: String.Chars.to_string(entry)
-
-  ## Implementations
+  defp reduce_enumerable(enumerable, acc, fun) do
+    Enumerable.reduce(enumerable, {:cont, acc}, fn x, acc -> {:cont, fun.(x, acc)} end) |> elem(1)
+  end
 
-  ## all?
+  ## reject
 
-  defp do_all?([h|t], fun) do
-    if fun.(h) do
-      do_all?(t, fun)
+  defp reject_list([head | tail], fun) do
+    if fun.(head) do
+      reject_list(tail, fun)
     else
-      false
+      [head | reject_list(tail, fun)]
     end
   end
 
-  defp do_all?([], _) do
-    true
+  defp reject_list([], _fun) do
+    []
   end
 
-  ## any?
+  ## reverse_slice
 
-  defp do_any?([h|t], fun) do
-    if fun.(h) do
-      true
-    else
-      do_any?(t, fun)
-    end
+  defp reverse_slice(rest, idx, idx, count, acc) do
+    {slice, rest} = head_slice(rest, count, [])
+    :lists.reverse(rest, :lists.reverse(slice, acc))
   end
 
-  defp do_any?([], _) do
-    false
+  defp reverse_slice([elem | rest], idx, start, count, acc) do
+    reverse_slice(rest, idx - 1, start, count, [elem | acc])
   end
 
-  ## fetch
+  defp head_slice(rest, 0, acc), do: {acc, rest}
 
-  defp do_fetch([h|_], 0), do: {:ok, h}
-  defp do_fetch([_|t], n), do: do_fetch(t, n - 1)
-  defp do_fetch([], _),    do: :error
+  defp head_slice([elem | rest], count, acc) do
+    head_slice(rest, count - 1, [elem | acc])
+  end
 
-  ## drop
+  ## scan
 
-  defp do_drop([_|t], counter) when counter > 0 do
-    do_drop(t, counter - 1)
-  end
+  defp scan_list([], _acc, _fun), do: []
 
-  defp do_drop(list, 0) do
-    list
+  defp scan_list([elem | rest], acc, fun) do
+    acc = fun.(elem, acc)
+    [acc | scan_list(rest, acc, fun)]
   end
 
-  defp do_drop([], _) do
-    []
-  end
+  ## slice
 
-  ## drop_while
+  defp slice_forward(enumerable, start, amount, step) when start < 0 do
+    {count, fun} = slice_count_and_fun(enumerable, step)
+    start = count + start
 
-  defp do_drop_while([h|t], fun) do
-    if fun.(h) do
-      do_drop_while(t, fun)
+    if start >= 0 do
+      amount = Kernel.min(amount, count - start)
+      amount = amount_with_step(amount, step)
+      fun.(start, amount, step)
     else
-      [h|t]
+      []
     end
   end
 
-  defp do_drop_while([], _) do
-    []
+  defp slice_forward(list, start, amount, step) when is_list(list) do
+    amount = amount_with_step(amount, step)
+    slice_list(list, start, amount, step)
   end
 
-  ## find
+  defp slice_forward(enumerable, start, amount, step) do
+    case Enumerable.slice(enumerable) do
+      {:ok, count, _} when start >= count ->
+        []
 
-  defp do_find([h|t], ifnone, fun) do
-    if fun.(h) do
-      h
-    else
-      do_find(t, ifnone, fun)
-    end
-  end
+      {:ok, count, fun} when is_function(fun, 1) ->
+        amount = Kernel.min(amount, count - start) |> amount_with_step(step)
+        enumerable |> fun.() |> slice_exact(start, amount, step, count)
 
-  defp do_find([], ifnone, _) do
-    ifnone
-  end
+      {:ok, count, fun} when is_function(fun, 3) ->
+        amount = Kernel.min(amount, count - start) |> amount_with_step(step)
+        fun.(start, amount, step)
 
-  ## find_index
+      # TODO: Remove me on v2.0
+      {:ok, count, fun} when is_function(fun, 2) ->
+        IO.warn(
+          "#{inspect(Enumerable.impl_for(enumerable))} must return a three arity function on slice/1"
+        )
 
-  defp do_find_index([h|t], counter, fun) do
-    if fun.(h) do
-      counter
+        amount = Kernel.min(amount, count - start)
+
+        if step == 1 do
+          fun.(start, amount)
+        else
+          fun.(start, Kernel.min(amount * step, count - start))
+          |> take_every_list(amount, step - 1)
+        end
+
+      {:error, module} ->
+        slice_enum(enumerable, module, start, amount, step)
+    end
+  end
+
+  defp slice_list(list, start, amount, step) do
+    if step == 1 do
+      list |> drop_list(start) |> take_list(amount)
     else
-      do_find_index(t, counter + 1, fun)
+      list |> drop_list(start) |> take_every_list(amount, step - 1)
     end
   end
 
-  defp do_find_index([], _, _) do
-    nil
+  defp slice_enum(enumerable, module, start, amount, 1) do
+    {_, {_, _, slice}} =
+      module.reduce(enumerable, {:cont, {start, amount, []}}, fn
+        _entry, {start, amount, _list} when start > 0 ->
+          {:cont, {start - 1, amount, []}}
+
+        entry, {start, amount, list} when amount > 1 ->
+          {:cont, {start, amount - 1, [entry | list]}}
+
+        entry, {start, amount, list} ->
+          {:halt, {start, amount, [entry | list]}}
+      end)
+
+    :lists.reverse(slice)
   end
 
-  ## find_value
+  defp slice_enum(enumerable, module, start, amount, step) do
+    {_, {_, _, _, slice}} =
+      module.reduce(enumerable, {:cont, {start, amount, 1, []}}, fn
+        _entry, {start, amount, to_drop, _list} when start > 0 ->
+          {:cont, {start - 1, amount, to_drop, []}}
+
+        entry, {start, amount, to_drop, list} when amount > 1 ->
+          case to_drop do
+            1 -> {:cont, {start, amount - 1, step, [entry | list]}}
+            _ -> {:cont, {start, amount - 1, to_drop - 1, list}}
+          end
+
+        entry, {start, amount, to_drop, list} ->
+          case to_drop do
+            1 -> {:halt, {start, amount, to_drop, [entry | list]}}
+            _ -> {:halt, {start, amount, to_drop, list}}
+          end
+      end)
 
-  defp do_find_value([h|t], ifnone, fun) do
-    fun.(h) || do_find_value(t, ifnone, fun)
+    :lists.reverse(slice)
   end
 
-  defp do_find_value([], ifnone, _) do
-    ifnone
+  defp slice_count_and_fun(list, _step) when is_list(list) do
+    length = length(list)
+    {length, &slice_exact(list, &1, &2, &3, length)}
   end
 
-  ## shuffle
+  defp slice_count_and_fun(enumerable, step) do
+    case Enumerable.slice(enumerable) do
+      {:ok, count, fun} when is_function(fun, 1) ->
+        {count, &slice_exact(fun.(enumerable), &1, &2, &3, count)}
+
+      {:ok, count, fun} when is_function(fun, 3) ->
+        {count, fun}
+
+      # TODO: Remove me on v2.0
+      {:ok, count, fun} when is_function(fun, 2) ->
+        IO.warn(
+          "#{inspect(Enumerable.impl_for(enumerable))} must return a three arity function on slice/1"
+        )
+
+        if step == 1 do
+          {count, fn start, amount, 1 -> fun.(start, amount) end}
+        else
+          {count,
+           fn start, amount, step ->
+             fun.(start, Kernel.min(amount * step, count - start))
+             |> take_every_list(amount, step - 1)
+           end}
+        end
 
-  defp unwrap([{_, h} | collection], t) do
-    unwrap(collection, [h|t])
+      {:error, module} ->
+        {list, count} =
+          enumerable
+          |> module.reduce({:cont, {[], 0}}, fn elem, {acc, count} ->
+            {:cont, {[elem | acc], count + 1}}
+          end)
+          |> elem(1)
+
+        {count,
+         fn start, amount, step ->
+           list |> :lists.reverse() |> slice_exact(start, amount, step, count)
+         end}
+    end
   end
 
-  defp unwrap([], t), do: t
+  # Slice a list when we know the bounds
+  defp slice_exact(_list, _start, 0, _step, _), do: []
+
+  defp slice_exact(list, start, amount, 1, size) when start + amount == size,
+    do: list |> drop_exact(start)
+
+  defp slice_exact(list, start, amount, 1, _),
+    do: list |> drop_exact(start) |> take_exact(amount)
+
+  defp slice_exact(list, start, amount, step, _),
+    do: list |> drop_exact(start) |> take_every_list(amount, step - 1)
+
+  defp drop_exact(list, 0), do: list
+  defp drop_exact([_ | tail], amount), do: drop_exact(tail, amount - 1)
+
+  defp take_exact(_list, 0), do: []
+  defp take_exact([head | tail], amount), do: [head | take_exact(tail, amount - 1)]
 
   ## sort
 
   defp sort_reducer(entry, {:split, y, x, r, rs, bool}, fun) do
     cond do
       fun.(y, entry) == bool ->
-        {:split, entry, y, [x|r], rs, bool}
+        {:split, entry, y, [x | r], rs, bool}
+
       fun.(x, entry) == bool ->
-        {:split, y, entry, [x|r], rs, bool}
+        {:split, y, entry, [x | r], rs, bool}
+
       r == [] ->
         {:split, y, x, [entry], rs, bool}
+
       true ->
         {:pivot, y, x, r, rs, entry, bool}
     end
@@ -1981,10 +4882,13 @@ defmodule Enum do
     cond do
       fun.(y, entry) == bool ->
         {:pivot, entry, y, [x | r], rs, s, bool}
+
       fun.(x, entry) == bool ->
         {:pivot, y, entry, [x | r], rs, s, bool}
+
       fun.(s, entry) == bool ->
         {:split, entry, s, [], [[y, x | r] | rs], bool}
+
       true ->
         {:split, s, entry, [], [[y, x | r] | rs], bool}
     end
@@ -1995,7 +4899,7 @@ defmodule Enum do
   end
 
   defp sort_reducer(entry, acc, _fun) do
-    [entry|acc]
+    [entry | acc]
   end
 
   defp sort_terminator({:split, y, x, r, rs, bool}, fun) do
@@ -2010,214 +4914,306 @@ defmodule Enum do
     acc
   end
 
-  defp sort_merge(list, fun, true), do:
-    reverse_sort_merge(list, [], fun, true)
+  defp sort_merge(list, fun, true), do: reverse_sort_merge(list, [], fun, true)
 
-  defp sort_merge(list, fun, false), do:
-    sort_merge(list, [], fun, false)
+  defp sort_merge(list, fun, false), do: sort_merge(list, [], fun, false)
 
+  defp sort_merge([t1, [h2 | t2] | l], acc, fun, true),
+    do: sort_merge(l, [sort_merge1(t1, h2, t2, [], fun, false) | acc], fun, true)
 
-  defp sort_merge([t1, [h2 | t2] | l], acc, fun, true), do:
-    sort_merge(l, [sort_merge_1(t1, h2, t2, [], fun, false) | acc], fun, true)
-
-  defp sort_merge([[h2 | t2], t1 | l], acc, fun, false), do:
-    sort_merge(l, [sort_merge_1(t1, h2, t2, [], fun, false) | acc], fun, false)
+  defp sort_merge([[h2 | t2], t1 | l], acc, fun, false),
+    do: sort_merge(l, [sort_merge1(t1, h2, t2, [], fun, false) | acc], fun, false)
 
   defp sort_merge([l], [], _fun, _bool), do: l
 
-  defp sort_merge([l], acc, fun, bool), do:
-    reverse_sort_merge([:lists.reverse(l, []) | acc], [], fun, bool)
-
-  defp sort_merge([], acc, fun, bool), do:
-    reverse_sort_merge(acc, [], fun, bool)
+  defp sort_merge([l], acc, fun, bool),
+    do: reverse_sort_merge([:lists.reverse(l, []) | acc], [], fun, bool)
 
+  defp sort_merge([], acc, fun, bool), do: reverse_sort_merge(acc, [], fun, bool)
 
-  defp reverse_sort_merge([[h2 | t2], t1 | l], acc, fun, true), do:
-    reverse_sort_merge(l, [sort_merge_1(t1, h2, t2, [], fun, true) | acc], fun, true)
+  defp reverse_sort_merge([[h2 | t2], t1 | l], acc, fun, true),
+    do: reverse_sort_merge(l, [sort_merge1(t1, h2, t2, [], fun, true) | acc], fun, true)
 
-  defp reverse_sort_merge([t1, [h2 | t2] | l], acc, fun, false), do:
-    reverse_sort_merge(l, [sort_merge_1(t1, h2, t2, [], fun, true) | acc], fun, false)
+  defp reverse_sort_merge([t1, [h2 | t2] | l], acc, fun, false),
+    do: reverse_sort_merge(l, [sort_merge1(t1, h2, t2, [], fun, true) | acc], fun, false)
 
-  defp reverse_sort_merge([l], acc, fun, bool), do:
-    sort_merge([:lists.reverse(l, []) | acc], [], fun, bool)
+  defp reverse_sort_merge([l], acc, fun, bool),
+    do: sort_merge([:lists.reverse(l, []) | acc], [], fun, bool)
 
-  defp reverse_sort_merge([], acc, fun, bool), do:
-    sort_merge(acc, [], fun, bool)
+  defp reverse_sort_merge([], acc, fun, bool), do: sort_merge(acc, [], fun, bool)
 
-
-  defp sort_merge_1([h1 | t1], h2, t2, m, fun, bool) do
+  defp sort_merge1([h1 | t1], h2, t2, m, fun, bool) do
     if fun.(h1, h2) == bool do
-      sort_merge_2(h1, t1, t2, [h2 | m], fun, bool)
+      sort_merge2(h1, t1, t2, [h2 | m], fun, bool)
     else
-      sort_merge_1(t1, h2, t2, [h1 | m], fun, bool)
+      sort_merge1(t1, h2, t2, [h1 | m], fun, bool)
     end
   end
 
-  defp sort_merge_1([], h2, t2, m, _fun, _bool), do:
-    :lists.reverse(t2, [h2 | m])
-
+  defp sort_merge1([], h2, t2, m, _fun, _bool), do: :lists.reverse(t2, [h2 | m])
 
-  defp sort_merge_2(h1, t1, [h2 | t2], m, fun, bool) do
+  defp sort_merge2(h1, t1, [h2 | t2], m, fun, bool) do
     if fun.(h1, h2) == bool do
-      sort_merge_2(h1, t1, t2, [h2 | m], fun, bool)
+      sort_merge2(h1, t1, t2, [h2 | m], fun, bool)
     else
-      sort_merge_1(t1, h2, t2, [h1 | m], fun, bool)
+      sort_merge1(t1, h2, t2, [h1 | m], fun, bool)
     end
   end
 
-  defp sort_merge_2(h1, t1, [], m, _fun, _bool), do:
-    :lists.reverse(t1, [h1 | m])
+  defp sort_merge2(h1, t1, [], m, _fun, _bool), do: :lists.reverse(t1, [h1 | m])
 
   ## split
 
-  defp do_split([h|t], counter, acc) when counter > 0 do
-    do_split(t, counter - 1, [h|acc])
+  defp split_list([head | tail], counter, acc) when counter > 0 do
+    split_list(tail, counter - 1, [head | acc])
   end
 
-  defp do_split(list, 0, acc) do
+  defp split_list(list, 0, acc) do
     {:lists.reverse(acc), list}
   end
 
-  defp do_split([], _, acc) do
+  defp split_list([], _, acc) do
     {:lists.reverse(acc), []}
   end
 
-  defp do_split_reverse([h|t], counter, acc) when counter > 0 do
-    do_split_reverse(t, counter - 1, [h|acc])
+  defp split_reverse_list([head | tail], counter, acc) when counter > 0 do
+    split_reverse_list(tail, counter - 1, [head | acc])
   end
 
-  defp do_split_reverse(list, 0, acc) do
+  defp split_reverse_list(list, 0, acc) do
     {:lists.reverse(list), acc}
   end
 
-  defp do_split_reverse([], _, acc) do
+  defp split_reverse_list([], _, acc) do
     {[], acc}
   end
 
   ## split_while
 
-  defp do_split_while([h|t], fun, acc) do
-    if fun.(h) do
-      do_split_while(t, fun, [h|acc])
+  defp split_while_list([head | tail], fun, acc) do
+    if fun.(head) do
+      split_while_list(tail, fun, [head | acc])
     else
-      {:lists.reverse(acc), [h|t]}
+      {:lists.reverse(acc), [head | tail]}
     end
   end
 
-  defp do_split_while([], _, acc) do
+  defp split_while_list([], _, acc) do
     {:lists.reverse(acc), []}
   end
 
+  ## sum_by
+
+  defp sum_by_list([], _, acc), do: acc
+  defp sum_by_list([h | t], mapper, acc), do: sum_by_list(t, mapper, acc + mapper.(h))
+
+  ## product_by
+
+  defp product_by_list([], _, acc), do: acc
+  defp product_by_list([h | t], mapper, acc), do: product_by_list(t, mapper, acc * mapper.(h))
+
   ## take
 
-  defp do_take([h|t], counter) when counter > 0 do
-    [h|do_take(t, counter - 1)]
-  end
+  defp take_list(_list, 0), do: []
+  defp take_list([head | tail], counter), do: [head | take_list(tail, counter - 1)]
+  defp take_list([], _counter), do: []
 
-  defp do_take(_list, 0) do
-    []
-  end
+  defp take_every_list([head | tail], to_drop),
+    do: [head | tail |> drop_list(to_drop) |> take_every_list(to_drop)]
 
-  defp do_take([], _) do
-    []
-  end
+  defp take_every_list([], _to_drop), do: []
+
+  defp take_every_list(_list, 0, _to_drop), do: []
+
+  defp take_every_list([head | tail], counter, to_drop),
+    do: [head | tail |> drop_list(to_drop) |> take_every_list(counter - 1, to_drop)]
+
+  defp take_every_list([], _counter, _to_drop), do: []
 
   ## take_while
 
-  defp do_take_while([h|t], fun) do
-    if fun.(h) do
-      [h|do_take_while(t, fun)]
+  defp take_while_list([head | tail], fun) do
+    if fun.(head) do
+      [head | take_while_list(tail, fun)]
     else
       []
     end
   end
 
-  defp do_take_while([], _) do
+  defp take_while_list([], _) do
     []
   end
 
   ## uniq
 
-  defp do_uniq([h|t], acc, fun) do
-    fun_h = fun.(h)
-    case :lists.member(fun_h, acc) do
-      true  -> do_uniq(t, acc, fun)
-      false -> [h|do_uniq(t, [fun_h|acc], fun)]
+  defp uniq_list([head | tail], set, fun) do
+    value = fun.(head)
+
+    case set do
+      %{^value => true} -> uniq_list(tail, set, fun)
+      %{} -> [head | uniq_list(tail, Map.put(set, value, true), fun)]
     end
   end
 
-  defp do_uniq([], _acc, _fun) do
+  defp uniq_list([], _set, _fun) do
     []
   end
 
-  ## zip
+  ## with_index
 
-  defp do_zip([h1|next1], [h2|next2]) do
-    [{h1, h2}|do_zip(next1, next2)]
+  defp with_index_list([head | tail], offset) do
+    [{head, offset} | with_index_list(tail, offset + 1)]
   end
 
-  defp do_zip(_, []), do: []
-  defp do_zip([], _), do: []
+  defp with_index_list([], _offset), do: []
 
-  ## slice
-
-  defp do_slice([], _start, _count) do
-    []
+  defp with_index_list([head | tail], offset, fun) do
+    [fun.(head, offset) | with_index_list(tail, offset + 1, fun)]
   end
 
-  defp do_slice(_list, _start, 0) do
-    []
+  defp with_index_list([], _offset, _fun), do: []
+
+  ## zip
+
+  defp zip_list([head1 | next1], [head2 | next2], acc) do
+    zip_list(next1, next2, [{head1, head2} | acc])
   end
 
-  defp do_slice([h|t], 0, count) do
-    [h|do_slice(t, 0, count-1)]
+  defp zip_list([], _, acc), do: :lists.reverse(acc)
+  defp zip_list(_, [], acc), do: :lists.reverse(acc)
+
+  defp zip_with_list([head1 | next1], [head2 | next2], fun) do
+    [fun.(head1, head2) | zip_with_list(next1, next2, fun)]
   end
 
-  defp do_slice([_|t], start, count) do
-    do_slice(t, start-1, count)
+  defp zip_with_list(_, [], _fun), do: []
+  defp zip_with_list([], _, _fun), do: []
+
+  defp zip_reduce_list([head1 | next1], [head2 | next2], acc, fun) do
+    zip_reduce_list(next1, next2, fun.(head1, head2, acc), fun)
   end
+
+  defp zip_reduce_list(_, [], acc, _fun), do: acc
+  defp zip_reduce_list([], _, acc, _fun), do: acc
 end
 
 defimpl Enumerable, for: List do
-  def reduce(_,     {:halt, acc}, _fun),   do: {:halted, acc}
-  def reduce(list,  {:suspend, acc}, fun), do: {:suspended, acc, &reduce(list, &1, fun)}
-  def reduce([],    {:cont, acc}, _fun),   do: {:done, acc}
-  def reduce([h|t], {:cont, acc}, fun),    do: reduce(t, fun.(h, acc), fun)
-
-  def member?(_list, _value),
-    do: {:error, __MODULE__}
-  def count(_list),
-    do: {:error, __MODULE__}
+  def count(list), do: {:ok, length(list)}
+
+  def member?(list, value), do: {:ok, :lists.member(value, list)}
+
+  def slice([]), do: {:ok, 0, fn _, _, _ -> [] end}
+  def slice(_list), do: {:error, __MODULE__}
+
+  def reduce(_list, {:halt, acc}, _fun), do: {:halted, acc}
+  def reduce(list, {:suspend, acc}, fun), do: {:suspended, acc, &reduce(list, &1, fun)}
+  def reduce([], {:cont, acc}, _fun), do: {:done, acc}
+  def reduce([head | tail], {:cont, acc}, fun), do: reduce(tail, fun.(head, acc), fun)
 end
 
 defimpl Enumerable, for: Map do
-  def reduce(map, acc, fun) do
-    do_reduce(:maps.to_list(map), acc, fun)
+  def count(map) do
+    {:ok, map_size(map)}
   end
 
-  defp do_reduce(_,     {:halt, acc}, _fun),   do: {:halted, acc}
-  defp do_reduce(list,  {:suspend, acc}, fun), do: {:suspended, acc, &do_reduce(list, &1, fun)}
-  defp do_reduce([],    {:cont, acc}, _fun),   do: {:done, acc}
-  defp do_reduce([h|t], {:cont, acc}, fun),    do: do_reduce(t, fun.(h, acc), fun)
-
   def member?(map, {key, value}) do
-    {:ok, match?({:ok, ^value}, :maps.find(key, map))}
+    {:ok, match?(%{^key => ^value}, map)}
   end
 
   def member?(_map, _other) do
     {:ok, false}
   end
 
-  def count(map) do
-    {:ok, map_size(map)}
+  def slice(map) do
+    size = map_size(map)
+    {:ok, size, &:maps.to_list/1}
+  end
+
+  def reduce(map, acc, fun) do
+    Enumerable.List.reduce(:maps.to_list(map), acc, fun)
   end
 end
 
 defimpl Enumerable, for: Function do
-  def reduce(function, acc, fun) when is_function(function, 2),
-    do: function.(acc, fun)
-  def member?(_function, _value),
-    do: {:error, __MODULE__}
-  def count(_function),
-    do: {:error, __MODULE__}
+  def count(_function), do: {:error, __MODULE__}
+  def member?(_function, _value), do: {:error, __MODULE__}
+  def slice(_function), do: {:error, __MODULE__}
+
+  def reduce(function, acc, fun) when is_function(function, 2), do: function.(acc, fun)
+
+  def reduce(function, _acc, _fun) do
+    raise Protocol.UndefinedError,
+      protocol: @protocol,
+      value: function,
+      description: "only anonymous functions of arity 2 are enumerable"
+  end
+end
+
+defimpl Enumerable, for: Range do
+  def reduce(first..last//step, acc, fun) do
+    reduce(first, last, acc, fun, step)
+  end
+
+  # TODO: Remove me on v2.0
+  def reduce(%{__struct__: Range, first: first, last: last} = range, acc, fun) do
+    step = if first <= last, do: 1, else: -1
+    reduce(Map.put(range, :step, step), acc, fun)
+  end
+
+  defp reduce(_first, _last, {:halt, acc}, _fun, _step) do
+    {:halted, acc}
+  end
+
+  defp reduce(first, last, {:suspend, acc}, fun, step) do
+    {:suspended, acc, &reduce(first, last, &1, fun, step)}
+  end
+
+  defp reduce(first, last, {:cont, acc}, fun, step)
+       when step > 0 and first <= last
+       when step < 0 and first >= last do
+    reduce(first + step, last, fun.(first, acc), fun, step)
+  end
+
+  defp reduce(_, _, {:cont, acc}, _fun, _up) do
+    {:done, acc}
+  end
+
+  def member?(first..last//step, value) when is_integer(value) do
+    if step > 0 do
+      {:ok, first <= value and value <= last and rem(value - first, step) == 0}
+    else
+      {:ok, last <= value and value <= first and rem(value - first, step) == 0}
+    end
+  end
+
+  # TODO: Remove me on v2.0
+  def member?(%{__struct__: Range, first: first, last: last} = range, value)
+      when is_integer(value) do
+    step = if first <= last, do: 1, else: -1
+    member?(Map.put(range, :step, step), value)
+  end
+
+  def member?(_, _value) do
+    {:ok, false}
+  end
+
+  def count(range) do
+    {:ok, Range.size(range)}
+  end
+
+  def slice(first.._//step = range) do
+    {:ok, Range.size(range), &slice(first + &1 * step, step + &3 - 1, &2)}
+  end
+
+  # TODO: Remove me on v2.0
+  def slice(%{__struct__: Range, first: first, last: last} = range) do
+    step = if first <= last, do: 1, else: -1
+    slice(Map.put(range, :step, step))
+  end
+
+  defp slice(current, _step, 1), do: [current]
+
+  defp slice(current, step, remaining) when remaining > 1 do
+    [current | slice(current + step, step, remaining - 1)]
+  end
 end
diff --git a/lib/elixir/lib/exception.ex b/lib/elixir/lib/exception.ex
index 398f0f1f5a6..209980d5e0c 100644
--- a/lib/elixir/lib/exception.ex
+++ b/lib/elixir/lib/exception.ex
@@ -1,53 +1,110 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Exception do
   @moduledoc """
-  Functions to format throw/catch/exit and exceptions.
+  Functions for dealing with throw/catch/exit and exceptions.
+
+  This module also defines the behaviour required by custom
+  exceptions. To define your own, see `defexception/1`.
 
-  Note that stacktraces in Elixir are updated on throw,
-  errors and exits. For example, at any given moment,
-  `System.stacktrace` will return the stacktrace for the
-  last throw/error/exit that ocurred in the current process.
+  ## Formatting functions
 
-  Do not rely on the particular format returned by the `format`
+  Several functions in this module help format exceptions.
+  Some of these functions expect the stacktrace as argument.
+  The stacktrace is typically available inside catch and
+  rescue by using the `__STACKTRACE__/0` variable.
+
+  Do not rely on the particular format returned by the
   functions in this module. They may be changed in future releases
   in order to better suit Elixir's tool chain. In other words,
-  by using the functions in this module it is guarantee you will
+  by using the functions in this module it is guaranteed you will
   format exceptions as in the current Elixir version being used.
   """
 
-  @typedoc "The exception type (as generated by defexception)"
-  @type t :: %{__struct__: module, __exception__: true}
+  @typedoc "The exception type"
+  @type t :: %{
+          required(:__struct__) => module,
+          required(:__exception__) => true,
+          optional(atom) => any
+        }
 
   @typedoc "The kind handled by formatting functions"
-  @type kind :: :error | :exit | :throw | {:EXIT, pid}
+  @type kind :: :error | non_error_kind
+  @type non_error_kind :: :exit | :throw | {:EXIT, pid}
 
   @type stacktrace :: [stacktrace_entry]
   @type stacktrace_entry ::
-        {module, function, arity_or_args, location} |
-        {function, arity_or_args, location}
+          {module, atom, arity_or_args, location}
+          | {(... -> any), arity_or_args, location}
+
+  @type arity_or_args :: non_neg_integer | list
+  @type location :: keyword
 
-  @typep arity_or_args :: non_neg_integer | list
-  @typep location :: Keyword.t
+  @doc """
+  Receives the arguments given to `raise/2` and returns the exception struct.
 
+  The default implementation accepts either a set of keyword arguments
+  that is merged into the struct or a string to be used as the exception's message.
+  """
   @callback exception(term) :: t
-  @callback message(t) :: String.t
 
   @doc """
-  Returns true if the given argument is an exception.
+  Receives the exception struct and must return its message.
+
+  Many exceptions have a message field which by default is accessed
+  by this function. However, if an exception does not have a message field,
+  this function must be explicitly implemented.
+  """
+  @callback message(t) :: String.t()
+
+  @doc """
+  Called from `Exception.blame/3` to augment the exception struct.
+
+  Can be used to collect additional information about the exception
+  or do some additional expensive computation.
   """
-  def exception?(%{__struct__: struct, __exception__: true}) when is_atom(struct), do: true
+  @callback blame(t, stacktrace) :: {t, stacktrace}
+  @optional_callbacks [blame: 2]
+
+  @doc false
+  # Callback for formatting Erlang exceptions
+  def format_error(%struct{} = exception, _stacktrace) do
+    %{general: message(exception), reason: "#" <> Atom.to_string(struct)}
+  end
+
+  @doc false
+  @deprecated "Use Kernel.is_exception/1 instead"
+  def exception?(term)
+  def exception?(%_{__exception__: true}), do: true
   def exception?(_), do: false
 
   @doc """
-  Gets the message for an exception.
+  Gets the message for an `exception`.
+
+  This function will invoke the `c:message/1` callback on the exception
+  module to retrieve the message. If the callback raises an exception or
+  returns a non-binary value, this function will rescue the error and
+  return a descriptive error message instead.
   """
-  def message(%{__struct__: module, __exception__: true} = exception) when is_atom(module) do
+  @spec message(t) :: String.t()
+  def message(%module{__exception__: true} = exception) do
     try do
       module.message(exception)
     rescue
-      e ->
-        raise ArgumentError,
-          "Got #{inspect e.__struct__} with message " <>
-          "\"#{message(e)}\" while retrieving message for #{inspect(exception)}"
+      caught_exception ->
+        "got #{inspect(caught_exception.__struct__)} with message " <>
+          "#{inspect(message(caught_exception))} while retrieving Exception.message/1 " <>
+          "for #{inspect(exception)}. Stacktrace:\n#{format_stacktrace(__STACKTRACE__)}"
+    else
+      result when is_binary(result) ->
+        result
+
+      result ->
+        "got #{inspect(result)} " <>
+          "while retrieving Exception.message/1 for #{inspect(exception)} " <>
+          "(expected a string)"
     end
   end
 
@@ -59,47 +116,29 @@ defmodule Exception do
   normalizes only `:error`, returning the untouched payload
   for others.
 
-  The third argument, a stacktrace, is optional. If it is
-  not supplied `System.stacktrace/0` will sometimes be used
-  to get additional information for the `kind` `:error`. If
-  the stacktrace is unknown and `System.stacktrace/0` would
-  not return the stacktrace corresponding to the exception
-  an empty stacktrace, `[]`, must be used.
+  The third argument is the stacktrace which is used to enrich
+  a normalized error with more information. It is only used when
+  the kind is an error.
   """
   @spec normalize(:error, any, stacktrace) :: t
-  @spec normalize(kind, payload, stacktrace) :: payload when payload: var
-
-  # Generating a stacktrace is expensive, default to nil
-  # to only fetch it when needed.
-  def normalize(kind, payload, stacktrace \\ nil)
-
-  def normalize(:error, exception, stacktrace) do
-    if exception?(exception) do
-      exception
-    else
-      ErlangError.normalize(exception, stacktrace)
-    end
-  end
-
-  def normalize(_kind, payload, _stacktrace) do
-    payload
-  end
+  @spec normalize(non_error_kind, payload, stacktrace) :: payload when payload: var
+  def normalize(kind, payload, stacktrace \\ [])
+  def normalize(:error, %_{__exception__: true} = payload, _stacktrace), do: payload
+  def normalize(:error, payload, stacktrace), do: ErlangError.normalize(payload, stacktrace)
+  def normalize(_kind, payload, _stacktrace), do: payload
 
   @doc """
-  Normalizes and formats any throw, error and exit.
+  Normalizes and formats any throw/error/exit.
 
   The message is formatted and displayed in the same
   format as used by Elixir's CLI.
 
-  The third argument, a stacktrace, is optional. If it is
-  not supplied `System.stacktrace/0` will sometimes be used
-  to get additional information for the `kind` `:error`. If
-  the stacktrace is unknown and `System.stacktrace/0` would
-  not return the stacktrace corresponding to the exception
-  an empty stacktrace, `[]`, must be used.
+  The third argument is the stacktrace which is used to enrich
+  a normalized error with more information. It is only used when
+  the kind is an error.
   """
-  @spec format_banner(kind, any, stacktrace | nil) :: String.t
-  def format_banner(kind, exception, stacktrace \\ nil)
+  @spec format_banner(kind, any, stacktrace) :: String.t()
+  def format_banner(kind, exception, stacktrace \\ [])
 
   def format_banner(:error, exception, stacktrace) do
     exception = normalize(:error, exception, stacktrace)
@@ -107,7 +146,7 @@ defmodule Exception do
   end
 
   def format_banner(:throw, reason, _stacktrace) do
-   "** (throw) " <> inspect(reason)
+    "** (throw) " <> inspect(reason)
   end
 
   def format_banner(:exit, reason, _stacktrace) do
@@ -115,98 +154,355 @@ defmodule Exception do
   end
 
   def format_banner({:EXIT, pid}, reason, _stacktrace) do
-    "** (EXIT from #{inspect pid}) " <> format_exit(reason, <<"\n    ">>)
+    "** (EXIT from #{inspect(pid)}) " <> format_exit(reason, <<"\n    ">>)
   end
 
   @doc """
-  Normalizes and formats throw/errors/exits and stacktrace.
+  Normalizes and formats throws/errors/exits and stacktraces.
 
   It relies on `format_banner/3` and `format_stacktrace/1`
   to generate the final format.
 
-  Note that `{:EXIT, pid}` do not generate a stacktrace though
-  (as they are retrieved as messages without stacktraces).
+  If `kind` is `{:EXIT, pid}`, it does not generate a stacktrace,
+  as such exits are retrieved as messages without stacktraces.
   """
-
-  @spec format(kind, any, stacktrace | nil) :: String.t
-
-  def format(kind, payload, stacktrace \\ nil)
+  @spec format(kind, any, stacktrace) :: String.t()
+  def format(kind, payload, stacktrace \\ [])
 
   def format({:EXIT, _} = kind, any, _) do
     format_banner(kind, any)
   end
 
   def format(kind, payload, stacktrace) do
-    stacktrace = stacktrace || System.stacktrace
     message = format_banner(kind, payload, stacktrace)
+
     case stacktrace do
       [] -> message
-      _  -> message <> "\n" <> format_stacktrace(stacktrace)
+      _ -> message <> "\n" <> format_stacktrace(stacktrace)
+    end
+  end
+
+  @doc false
+  def __format_message_with_term__(message, term) do
+    inspected =
+      term
+      |> inspect(pretty: true)
+      |> String.split("\n")
+      |> Enum.map_intersperse("\n", fn
+        "" -> ""
+        line -> "    " <> line
+      end)
+
+    IO.iodata_to_binary([message, "\n\n", inspected, "\n"])
+  end
+
+  @doc """
+  Attaches information to throws/errors/exits for extra debugging.
+
+  This operation is potentially expensive, as it reads data
+  from the file system, parses beam files, evaluates code and
+  so on.
+
+  If `kind` argument is `:error` and the `error` is an Erlang exception, this function will
+  normalize it. If the `error` argument is an Elixir exception, this function will invoke
+  the optional `c:blame/2` callback on the exception module if it is implemented.
+  Unlike `message/1`, this function will not rescue errors - if the callback raises an exception,
+  the error will propagate to the caller. It is your choice if you want to rescue and return
+  the original exception, return a different exception, or let it cascade.
+  """
+  @doc since: "1.5.0"
+  @spec blame(:error, any, stacktrace) :: {t, stacktrace}
+  @spec blame(non_error_kind, payload, stacktrace) :: {payload, stacktrace} when payload: var
+  def blame(kind, error, stacktrace)
+
+  def blame(:error, error, stacktrace) do
+    %module{} = struct = normalize(:error, error, stacktrace)
+
+    if Code.ensure_loaded?(module) and function_exported?(module, :blame, 2) do
+      module.blame(struct, stacktrace)
+    else
+      {struct, stacktrace}
+    end
+  end
+
+  def blame(_kind, reason, stacktrace) do
+    {reason, stacktrace}
+  end
+
+  @doc """
+  Blames the invocation of the given module, function and arguments.
+
+  This function will retrieve the available clauses from bytecode
+  and evaluate them against the given arguments. The clauses are
+  returned as a list of `{args, guards}` pairs where each argument
+  and each top-level condition in a guard separated by `and`/`or`
+  is wrapped in a tuple with blame metadata.
+
+  This function returns either `{:ok, definition, clauses}` or `:error`.
+  Where `definition` is `:def`, `:defp`, `:defmacro` or `:defmacrop`.
+  """
+  @doc since: "1.5.0"
+  @spec blame_mfa(module, function :: atom, args :: [term]) ::
+          {:ok, :def | :defp | :defmacro | :defmacrop, [{args :: [term], guards :: [term]}]}
+          | :error
+  def blame_mfa(module, function, args)
+      when is_atom(module) and is_atom(function) and is_list(args) do
+    try do
+      blame_mfa(module, function, length(args), args)
+    rescue
+      _ -> :error
+    end
+  end
+
+  defp blame_mfa(module, function, arity, call_args) do
+    with [_ | _] = path <- :code.which(module),
+         {:ok, {_, [debug_info: debug_info]}} <- :beam_lib.chunks(path, [:debug_info]),
+         {:debug_info_v1, backend, data} <- debug_info,
+         {:ok, %{definitions: defs}} <- backend.debug_info(:elixir_v1, module, data, []),
+         {_, kind, _, clauses} <- List.keyfind(defs, {function, arity}, 0) do
+      clauses =
+        for {meta, ex_args, guards, _block} <- clauses do
+          scope = :elixir_erl.scope(meta, true)
+          ann = :elixir_erl.get_ann(meta)
+
+          {erl_args, scope} =
+            :elixir_erl_clauses.match(ann, &:elixir_erl_pass.translate_args/3, ex_args, scope)
+
+          {args, binding} =
+            [call_args, ex_args, erl_args]
+            |> Enum.zip()
+            |> Enum.map_reduce([], &blame_arg/2)
+
+          guards =
+            guards
+            |> Enum.map(&blame_guard(&1, ann, scope, binding))
+            |> Enum.map(&Macro.prewalk(&1, fn guard -> translate_guard(guard) end))
+
+          {args, guards}
+        end
+
+      {:ok, kind, clauses}
+    else
+      _ -> :error
+    end
+  end
+
+  defp map_node?({:is_map, _, [_]}), do: true
+  defp map_node?(_), do: false
+  defp map_key_node?({:is_map_key, _, [_, _]}), do: true
+  defp map_key_node?(_), do: false
+
+  defp struct_validation_node?(
+         {:is_atom, _, [{{:., [], [:erlang, :map_get]}, _, [:__struct__, _]}]}
+       ),
+       do: true
+
+  defp struct_validation_node?(
+         {:==, _, [{{:., [], [:erlang, :map_get]}, _, [:__struct__, _]}, _module]}
+       ),
+       do: true
+
+  defp struct_validation_node?(_), do: false
+
+  defp struct_macro?(
+         {:and, _,
+          [
+            {:and, _, [%{node: node_1 = {_, _, [arg]}}, %{node: node_2 = {_, _, [arg, _]}}]},
+            %{node: node_3 = {_, _, [{_, _, [_, arg]}]}}
+          ]}
+       ),
+       do: map_node?(node_1) and map_key_node?(node_2) and struct_validation_node?(node_3)
+
+  defp struct_macro?(
+         {:and, _,
+          [
+            {:and, _,
+             [
+               {:and, _,
+                [
+                  %{node: node_1 = {_, _, [arg]}},
+                  {:or, _, [%{node: {:is_atom, _, [_]}}, %{node: :fail}]}
+                ]},
+               %{node: node_2 = {_, _, [arg, _]}}
+             ]},
+            %{node: node_3 = {_, _, [{_, _, [_, arg]}, _]}}
+          ]}
+       ),
+       do: map_node?(node_1) and map_key_node?(node_2) and struct_validation_node?(node_3)
+
+  defp struct_macro?(_), do: false
+
+  defp translate_guard(guard) do
+    if struct_macro?(guard) do
+      undo_is_struct_guard(guard)
+    else
+      guard
+    end
+  end
+
+  defp undo_is_struct_guard({:and, meta, [_, %{node: {_, _, [{_, _, [_, arg]} | optional]}}]}) do
+    args =
+      case optional do
+        [] -> [arg]
+        [module] -> [arg, module]
+      end
+
+    %{match?: meta[:value], node: {:is_struct, meta, args}}
+  end
+
+  defp blame_arg({call_arg, ex_arg, erl_arg}, binding) do
+    {match?, binding} = blame_arg(erl_arg, call_arg, binding)
+    {blame_wrap(match?, rewrite_arg(ex_arg)), binding}
+  end
+
+  defp blame_arg(erl_arg, call_arg, binding) do
+    binding = :orddict.store(:VAR, call_arg, binding)
+
+    try do
+      ann = :erl_anno.new(0)
+
+      {:value, _, binding} =
+        :erl_eval.expr({:match, ann, erl_arg, {:var, ann, :VAR}}, binding, :none)
+
+      {true, binding}
+    rescue
+      _ -> {false, binding}
+    end
+  end
+
+  defp rewrite_arg(arg) do
+    Macro.prewalk(arg, fn
+      {:%{}, meta, [__struct__: Range, first: first, last: last, step: step]} ->
+        {:..//, meta, [first, last, step]}
+
+      other ->
+        other
+    end)
+  end
+
+  defp blame_guard({{:., _, [:erlang, op]}, meta, [left, right]}, ann, scope, binding)
+       when op == :andalso or op == :orelse do
+    guards = [
+      blame_guard(left, ann, scope, binding),
+      blame_guard(right, ann, scope, binding)
+    ]
+
+    kernel_op =
+      case op do
+        :orelse -> :or
+        :andalso -> :and
+      end
+
+    evaluate_guard(kernel_op, meta, guards)
+  end
+
+  defp blame_guard(ex_guard, ann, scope, binding) do
+    ex_guard
+    |> blame_guard?(binding, ann, scope)
+    |> blame_wrap(rewrite_guard(ex_guard))
+  end
+
+  defp blame_guard?(ex_guard, binding, ann, scope) do
+    {erl_guard, _} = :elixir_erl_pass.translate(ex_guard, ann, scope)
+    {:value, true, _} = :erl_eval.expr(erl_guard, binding, :none)
+    true
+  rescue
+    _ -> false
+  end
+
+  defp evaluate_guard(kernel_op, meta, guards = [_, _]) do
+    [x, y] = Enum.map(guards, &evaluate_guard/1)
+
+    logic_value =
+      case kernel_op do
+        :or -> x or y
+        :and -> x and y
+      end
+
+    {kernel_op, Keyword.put(meta, :value, logic_value), guards}
+  end
+
+  defp evaluate_guard(%{match?: value}), do: value
+  defp evaluate_guard({_, meta, _}) when is_list(meta), do: meta[:value]
+
+  defp rewrite_guard(guard) do
+    Macro.prewalk(guard, fn
+      {{:., _, [mod, fun]}, meta, args} -> erl_to_ex(mod, fun, args, meta)
+      other -> other
+    end)
+  end
+
+  defp erl_to_ex(mod, fun, args, meta) do
+    case :elixir_rewrite.erl_to_ex(mod, fun, args) do
+      {Kernel, fun, args, _} -> {fun, meta, args}
+      {mod, fun, args, _} -> {{:., [], [mod, fun]}, meta, args}
     end
   end
 
+  defp blame_wrap(match?, ast), do: %{match?: match?, node: ast}
+
   @doc """
-  Formats an exit, returns a string.
+  Formats an exit. It returns a string.
 
   Often there are errors/exceptions inside exits. Exits are often
   wrapped by the caller and provide stacktraces too. This function
   formats exits in a way to nicely show the exit reason, caller
   and stacktrace.
   """
-  @spec format_exit(any) :: String.t
+  @spec format_exit(any) :: String.t()
   def format_exit(reason) do
     format_exit(reason, <<"\n    ">>)
   end
 
   # 2-Tuple could be caused by an error if the second element is a stacktrace.
   defp format_exit({exception, maybe_stacktrace} = reason, joiner)
-      when is_list(maybe_stacktrace) and maybe_stacktrace !== [] do
+       when is_list(maybe_stacktrace) and maybe_stacktrace !== [] do
     try do
       Enum.map(maybe_stacktrace, &format_stacktrace_entry/1)
+    catch
+      :error, _ ->
+        # Not a stacktrace, was an exit.
+        format_exit_reason(reason)
     else
       formatted_stacktrace ->
         # Assume a non-empty list formattable as stacktrace is a
         # stacktrace, so exit was caused by an error.
-        message = "an exception was raised:" <> joiner <>
-          format_banner(:error, exception, maybe_stacktrace)
+        message =
+          "an exception was raised:" <>
+            joiner <> format_banner(:error, exception, maybe_stacktrace)
+
         Enum.join([message | formatted_stacktrace], joiner <> <<"    ">>)
-    catch
-      :error, _ ->
-        # Not a stacktrace, was an exit.
-        format_exit_reason(reason)
     end
   end
 
   # :supervisor.start_link returns this error reason when it fails to init
   # because a child's start_link raises.
-  defp format_exit({:shutdown,
-      {:failed_to_start_child, child, {:EXIT, reason}}}, joiner) do
+  defp format_exit({:shutdown, {:failed_to_start_child, child, {:EXIT, reason}}}, joiner) do
     format_start_child(child, reason, joiner)
   end
 
   # :supervisor.start_link returns this error reason when it fails to init
   # because a child's start_link returns {:error, reason}.
-  defp format_exit({:shutdown, {:failed_to_start_child, child, reason}},
-      joiner) do
+  defp format_exit({:shutdown, {:failed_to_start_child, child, reason}}, joiner) do
     format_start_child(child, reason, joiner)
   end
 
   # 2-Tuple could be an exit caused by mfa if second element is mfa, args
   # must be a list of arguments - max length 255 due to max arity.
   defp format_exit({reason2, {mod, fun, args}} = reason, joiner)
-      when length(args) < 256 do
+       when length(args) < 256 do
     try do
       format_mfa(mod, fun, args)
-    else
-      mfa ->
-        # Assume tuple formattable as an mfa is an mfa, so exit was caused by
-        # failed mfa.
-        "exited in: " <> mfa <> joiner <>
-          "** (EXIT) " <> format_exit(reason2, joiner <> <<"    ">>)
     catch
       :error, _ ->
         # Not an mfa, was an exit.
         format_exit_reason(reason)
+    else
+      mfa ->
+        # Assume tuple formattable as an mfa is an mfa,
+        # so exit was caused by failed mfa.
+        "exited in: " <>
+          mfa <> joiner <> "** (EXIT) " <> format_exit(reason2, joiner <> <<"    ">>)
     end
   end
 
@@ -221,12 +517,13 @@ defmodule Exception do
     "shutdown: #{inspect(reason)}"
   end
 
+  defp format_exit_reason(:calling_self), do: "process attempted to call itself"
   defp format_exit_reason(:timeout), do: "time out"
   defp format_exit_reason(:killed), do: "killed"
   defp format_exit_reason(:noconnection), do: "no connection"
 
   defp format_exit_reason(:noproc) do
-    "no process"
+    "no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started"
   end
 
   defp format_exit_reason({:nodedown, node_name}) when is_atom(node_name) do
@@ -253,29 +550,29 @@ defmodule Exception do
 
   # :supervisor.start_link error reasons
 
-  # If value is a list will be be formatted by mfa exit in format_exit/1
+  # If value is a list will be formatted by mfa exit in format_exit/1
   defp format_exit_reason({:bad_return, {mod, :init, value}})
-      when is_atom(mod) do
+       when is_atom(mod) do
     format_mfa(mod, :init, 1) <> " returned a bad value: " <> inspect(value)
   end
 
   defp format_exit_reason({:bad_start_spec, start_spec}) do
-    "bad start spec: invalid children: " <> inspect(start_spec)
+    "bad child specification, invalid children: " <> inspect(start_spec)
   end
 
   defp format_exit_reason({:start_spec, start_spec}) do
-    "bad start spec: " <> format_sup_spec(start_spec)
+    "bad child specification, " <> format_sup_spec(start_spec)
   end
 
   defp format_exit_reason({:supervisor_data, data}) do
-    "bad supervisor data: " <> format_sup_data(data)
+    "bad supervisor configuration, " <> format_sup_data(data)
   end
 
   defp format_exit_reason(reason), do: inspect(reason)
 
   defp format_start_child(child, reason, joiner) do
-    "shutdown: failed to start child: " <> inspect(child) <> joiner <>
-      "** (EXIT) " <> format_exit(reason, joiner <> <<"    ">>)
+    "shutdown: failed to start child: " <>
+      inspect(child) <> joiner <> "** (EXIT) " <> format_exit(reason, joiner <> <<"    ">>)
   end
 
   defp format_sup_data({:invalid_type, type}) do
@@ -287,49 +584,70 @@ defmodule Exception do
   end
 
   defp format_sup_data({:invalid_intensity, intensity}) do
-    "invalid intensity: " <> inspect(intensity)
+    "invalid max_restarts (intensity): " <> inspect(intensity)
   end
 
   defp format_sup_data({:invalid_period, period}) do
-    "invalid period: " <> inspect(period)
+    "invalid max_seconds (period): " <> inspect(period)
+  end
+
+  defp format_sup_data({:invalid_max_children, max_children}) do
+    "invalid max_children: " <> inspect(max_children)
+  end
+
+  defp format_sup_data({:invalid_extra_arguments, extra}) do
+    "invalid extra_arguments: " <> inspect(extra)
   end
 
-  defp format_sup_data(other), do: inspect(other)
+  defp format_sup_data(other), do: "got: #{inspect(other)}"
+
+  defp format_sup_spec({:duplicate_child_name, id}) do
+    """
+    more than one child specification has the id: #{inspect(id)}.
+    If using maps as child specifications, make sure the :id keys are unique.
+    If using a module or {module, arg} as child, use Supervisor.child_spec/2 to change the :id, for example:
+
+        children = [
+          Supervisor.child_spec({MyWorker, arg}, id: :my_worker_1),
+          Supervisor.child_spec({MyWorker, arg}, id: :my_worker_2)
+        ]
+    """
+  end
 
   defp format_sup_spec({:invalid_child_spec, child_spec}) do
-   "invalid child spec: " <> inspect(child_spec)
+    "invalid child specification: #{inspect(child_spec)}"
   end
 
   defp format_sup_spec({:invalid_child_type, type}) do
-    "invalid child type: " <> inspect(type)
+    "invalid child type: #{inspect(type)}. Must be :worker or :supervisor."
   end
 
   defp format_sup_spec({:invalid_mfa, mfa}) do
-    "invalid mfa: " <> inspect(mfa)
+    "invalid mfa: #{inspect(mfa)}"
   end
 
   defp format_sup_spec({:invalid_restart_type, restart}) do
-    "invalid restart type: " <> inspect(restart)
+    "invalid restart type: #{inspect(restart)}. Must be :permanent, :transient or :temporary."
   end
 
   defp format_sup_spec({:invalid_shutdown, shutdown}) do
-    "invalid shutdown: " <> inspect(shutdown)
+    "invalid shutdown: #{inspect(shutdown)}. Must be an integer >= 0, :infinity or :brutal_kill."
   end
 
   defp format_sup_spec({:invalid_module, mod}) do
-    "invalid module: " <> inspect(mod)
+    "invalid module: #{inspect(mod)}. Must be an atom."
   end
 
   defp format_sup_spec({:invalid_modules, modules}) do
-    "invalid modules: " <> inspect(modules)
+    "invalid modules: #{inspect(modules)}. Must be a list of atoms or :dynamic."
   end
 
-  defp format_sup_spec(other), do: inspect(other)
+  defp format_sup_spec(other), do: "got: #{inspect(other)}"
 
   @doc """
   Receives a stacktrace entry and formats it into a string.
   """
-  @spec format_stacktrace_entry(stacktrace_entry) :: String.t
+  @spec format_stacktrace_entry(stacktrace_entry) :: String.t()
   def format_stacktrace_entry(entry)
 
   # From Macro.Env.stacktrace
@@ -356,9 +674,19 @@ defmodule Exception do
   end
 
   defp format_application(module) do
+    # We cannot use Application due to bootstrap issues
     case :application.get_application(module) do
-      {:ok, app} -> "(" <> Atom.to_string(app) <> ") "
-      :undefined   -> ""
+      {:ok, app} ->
+        case :application.get_key(app, :vsn) do
+          {:ok, vsn} when is_list(vsn) ->
+            "(" <> Atom.to_string(app) <> " " <> List.to_string(vsn) <> ") "
+
+          _ ->
+            "(" <> Atom.to_string(app) <> ") "
+        end
+
+      :undefined ->
+        ""
     end
   end
 
@@ -368,14 +696,20 @@ defmodule Exception do
   A stacktrace must be given as an argument. If not, the stacktrace
   is retrieved from `Process.info/2`.
   """
+  @spec format_stacktrace(stacktrace | nil) :: String.t()
   def format_stacktrace(trace \\ nil) do
-    trace = trace || case Process.info(self, :current_stacktrace) do
-      {:current_stacktrace, t} -> Enum.drop(t, 3)
-    end
+    trace =
+      if trace do
+        trace
+      else
+        case Process.info(self(), :current_stacktrace) do
+          {:current_stacktrace, t} -> Enum.drop(t, 3)
+        end
+      end
 
     case trace do
       [] -> "\n"
-      s  -> "    " <> Enum.map_join(s, "\n    ", &format_stacktrace_entry(&1)) <> "\n"
+      _ -> "    " <> Enum.map_join(trace, "\n    ", &format_stacktrace_entry(&1)) <> "\n"
     end
   end
 
@@ -385,12 +719,13 @@ defmodule Exception do
 
   ## Examples
 
-      Exception.format_fa(fn -> end, 1)
+      Exception.format_fa(fn -> nil end, 1)
       #=> "#Function<...>/1"
 
   """
+  @spec format_fa(fun, arity) :: String.t()
   def format_fa(fun, arity) when is_function(fun) do
-    "#{inspect fun}#{format_arity(arity)}"
+    "#{inspect(fun)}#{format_arity(arity)}"
   end
 
   @doc """
@@ -400,31 +735,30 @@ defmodule Exception do
 
   ## Examples
 
-      iex> Exception.format_mfa Foo, :bar, 1
+      iex> Exception.format_mfa(Foo, :bar, 1)
       "Foo.bar/1"
 
-      iex> Exception.format_mfa Foo, :bar, []
+      iex> Exception.format_mfa(Foo, :bar, [])
       "Foo.bar()"
 
-      iex> Exception.format_mfa nil, :bar, []
+      iex> Exception.format_mfa(nil, :bar, [])
       "nil.bar()"
 
   Anonymous functions are reported as -func/arity-anonfn-count-,
   where func is the name of the enclosing function. Convert to
   "anonymous fn in func/arity"
   """
+  @spec format_mfa(module, atom, arity_or_args) :: String.t()
   def format_mfa(module, fun, arity) when is_atom(module) and is_atom(fun) do
-    fun =
-      case inspect(fun) do
-        ":" <> fun -> fun
-        fun -> fun
-      end
-
-    case match?("\"-" <> _, fun) and String.split(fun, "-") do
-      [ "\"", outer_fun, "fun", _count, "\"" ] ->
-        "anonymous fn#{format_arity(arity)} in #{inspect module}.#{outer_fun}"
-      _ ->
-        "#{inspect module}.#{fun}#{format_arity(arity)}"
+    case Code.Identifier.extract_anonymous_fun_parent(fun) do
+      {outer_name, outer_arity} ->
+        "anonymous fn#{format_arity(arity)} in " <>
+          "#{Macro.inspect_atom(:literal, module)}." <>
+          "#{Macro.inspect_atom(:remote_call, outer_name)}/#{outer_arity}"
+
+      :error ->
+        "#{Macro.inspect_atom(:literal, module)}." <>
+          "#{Macro.inspect_atom(:remote_call, fun)}#{format_arity(arity)}"
     end
   end
 
@@ -438,8 +772,9 @@ defmodule Exception do
   end
 
   @doc """
-  Formats the given file and line as shown in stacktraces.
-  If any of the values are nil, they are omitted.
+  Formats the given `file` and `line` as shown in stacktraces.
+
+  If any of the values are `nil`, they are omitted.
 
   ## Examples
 
@@ -453,292 +788,1795 @@ defmodule Exception do
       ""
 
   """
-  def format_file_line(file, line) do
-    format_file_line(file, line, "")
+  @spec format_file_line(String.t() | nil, non_neg_integer | nil, String.t()) :: String.t()
+  def format_file_line(file, line, suffix \\ "") do
+    cond do
+      is_nil(file) -> ""
+      is_nil(line) or line == 0 -> "#{file}:#{suffix}"
+      true -> "#{file}:#{line}:#{suffix}"
+    end
   end
 
-  defp format_file_line(file, line, suffix) do
-    if file do
-      if line && line != 0 do
-        "#{file}:#{line}:#{suffix}"
-      else
-        "#{file}:#{suffix}"
-      end
-    else
+  @doc """
+  Formats the given `file`, `line`, and `column` as shown in stacktraces.
+
+  If any of the values are `nil`, they are omitted.
+
+  ## Examples
+
+      iex> Exception.format_file_line_column("foo", 1, 2)
+      "foo:1:2:"
+
+      iex> Exception.format_file_line_column("foo", 1, nil)
+      "foo:1:"
+
+      iex> Exception.format_file_line_column("foo", nil, nil)
+      "foo:"
+
+      iex> Exception.format_file_line_column("foo", nil, 2)
+      "foo:"
+
+      iex> Exception.format_file_line_column(nil, nil, nil)
       ""
+
+  """
+  @spec format_file_line_column(
+          String.t() | nil,
+          non_neg_integer | nil,
+          non_neg_integer | nil,
+          String.t()
+        ) :: String.t()
+  def format_file_line_column(file, line, column, suffix \\ "") do
+    cond do
+      is_nil(file) -> ""
+      is_nil(line) or line == 0 -> "#{file}:#{suffix}"
+      is_nil(column) or column == 0 -> "#{file}:#{line}:#{suffix}"
+      true -> "#{file}:#{line}:#{column}:#{suffix}"
     end
   end
 
   defp format_location(opts) when is_list(opts) do
-    format_file_line Keyword.get(opts, :file), Keyword.get(opts, :line), " "
+    case opts[:column] do
+      nil -> format_file_line(Keyword.get(opts, :file), Keyword.get(opts, :line), " ")
+      col -> format_file_line_column(Keyword.get(opts, :file), Keyword.get(opts, :line), col, " ")
+    end
+  end
+
+  @doc false
+  def format_delimiter(delimiter) do
+    if delimiter |> Atom.to_string() |> String.contains?(["\"", "'"]),
+      do: delimiter,
+      else: ~s("#{delimiter}")
+  end
+
+  @doc false
+  def format_snippet(
+        {start_line, _start_column} = start_pos,
+        {end_line, end_column} = end_pos,
+        description,
+        file,
+        lines,
+        start_message,
+        end_message
+      )
+      when start_line < end_line do
+    max_digits = digits(end_line)
+    general_padding = max(2, max_digits) + 1
+    padding = n_spaces(general_padding)
+
+    relevant_lines =
+      if end_line - start_line < 5 do
+        line_range(lines, start_pos, end_pos, padding, max_digits, start_message, end_message)
+      else
+        trimmed_inbetween_lines(
+          lines,
+          start_pos,
+          end_pos,
+          padding,
+          max_digits,
+          start_message,
+          end_message
+        )
+      end
+
+    """
+     #{padding}#{red("error:")} #{pad_message(description, padding)}
+     #{padding}│
+    #{relevant_lines}
+     #{padding}│
+     #{padding}└─ #{Path.relative_to_cwd(file)}:#{end_line}:#{end_column}\
+    """
+  end
+
+  def format_snippet(
+        {start_line, start_column},
+        {end_line, end_column},
+        description,
+        file,
+        lines,
+        start_message,
+        end_message
+      )
+      when start_line == end_line do
+    max_digits = digits(end_line)
+    general_padding = max(2, max_digits) + 1
+    padding = n_spaces(general_padding)
+    formatted_line = [line_padding(end_line, max_digits), to_string(end_line), " │ ", hd(lines)]
+
+    mismatched_closing_line =
+      [
+        n_spaces(start_column - 1),
+        red("│"),
+        format_end_message(end_column - start_column, end_message)
+      ]
+
+    unclosed_delimiter_line =
+      [padding, " │ ", format_start_message(start_column, start_message)]
+
+    below_line = [padding, " │ ", mismatched_closing_line, "\n", unclosed_delimiter_line]
+
+    """
+     #{padding}#{red("error:")} #{pad_message(description, padding)}
+     #{padding}│
+    #{formatted_line}
+    #{below_line}
+     #{padding}│
+     #{padding}└─ #{Path.relative_to_cwd(file)}:#{end_line}:#{end_column}\
+    """
+  end
+
+  defp line_padding(line_number, max_digits) do
+    line_digits = digits(line_number)
+
+    spacing =
+      if line_digits == 1 do
+        max(2, max_digits)
+      else
+        max_digits - line_digits + 1
+      end
+
+    n_spaces(spacing)
+  end
+
+  defp n_spaces(n), do: String.duplicate(" ", n)
+
+  defp digits(number, acc \\ 1)
+  defp digits(number, acc) when number < 10, do: acc
+  defp digits(number, acc), do: digits(div(number, 10), acc + 1)
+
+  defp trimmed_inbetween_lines(
+         lines,
+         {start_line, start_column},
+         {end_line, end_column},
+         padding,
+         max_digits,
+         start_message,
+         end_message
+       ) do
+    start_padding = line_padding(start_line, max_digits)
+    end_padding = line_padding(end_line, max_digits)
+    first_line = hd(lines)
+    last_line = List.last(lines)
+
+    """
+    #{start_padding}#{start_line} │ #{first_line}
+     #{padding}│ #{format_start_message(start_column, start_message)}
+     ...
+    #{end_padding}#{end_line} │ #{last_line}
+     #{padding}│ #{format_end_message(end_column, end_message)}\
+    """
+  end
+
+  defp line_range(
+         lines,
+         {start_line, start_column},
+         {end_line, end_column},
+         padding,
+         max_digits,
+         start_message,
+         end_message
+       ) do
+    Enum.zip_with(lines, start_line..end_line, fn line, line_number ->
+      line_padding = line_padding(line_number, max_digits)
+
+      cond do
+        line_number == start_line ->
+          [
+            line_padding,
+            to_string(line_number),
+            " │ ",
+            line,
+            "\n",
+            padding,
+            " │ ",
+            format_start_message(start_column, start_message)
+          ]
+
+        line_number == end_line ->
+          [
+            line_padding,
+            to_string(line_number),
+            " │ ",
+            line,
+            "\n",
+            padding,
+            " │ ",
+            format_end_message(end_column, end_message)
+          ]
+
+        true ->
+          [line_padding, to_string(line_number), " │ ", line]
+      end
+    end)
+    |> Enum.intersperse("\n")
+  end
+
+  defp format_end_message(end_column, message),
+    do: [
+      n_spaces(end_column - 1),
+      red(message)
+    ]
+
+  defp format_start_message(start_column, message),
+    do: [n_spaces(start_column - 1), red(message)]
+
+  defp pad_message(message, padding), do: String.replace(message, "\n", "\n #{padding}")
+
+  defp red(string) do
+    if IO.ANSI.enabled?() do
+      [IO.ANSI.red(), string, IO.ANSI.reset()]
+    else
+      string
+    end
   end
 end
 
-# Some exceptions implement `message/1` instead of `exception/1` mostly
+# Some exceptions implement "message/1" instead of "exception/1" mostly
 # for bootstrap reasons. It is recommended for applications to implement
-# `exception/1` instead of `message/1` as described in `defexception/1`
+# "exception/1" instead of "message/1" as described in "defexception/1"
 # docs.
 
 defmodule RuntimeError do
-  defexception message: "runtime error"
+  @moduledoc """
+  An exception for a generic runtime error.
 
-  def exception(msg) when is_binary(msg) do
-    %RuntimeError{message: msg}
-  end
+  This is the exception that `raise/1` raises when you pass it only a string as
+  a message:
 
-  def exception(arg) do
-    super(arg)
-  end
+      iex> raise "oops!"
+      ** (RuntimeError) oops!
+
+  You should use this exceptions sparingly, since most of the time it might be
+  better to define your own exceptions specific to your application or library.
+  Sometimes, however, there are situations in which you don't expect a condition to
+  happen, but you want to give a meaningful error message if it does. In those cases,
+  `RuntimeError` can be a good choice.
+
+  ## Fields
+
+  `RuntimeError` exceptions have a single field, `:message` (a `t:String.t/0`),
+  which is public and can be accessed freely when reading or creating `RuntimeError`
+  exceptions.
+  """
+
+  defexception message: "runtime error"
 end
 
 defmodule ArgumentError do
-  defexception message: "argument error"
+  @moduledoc """
+  An exception raised when an argument to a function is invalid.
 
-  def exception(msg) when is_binary(msg) do
-    %ArgumentError{message: msg}
-  end
+  You can raise this exception when you want to signal that an argument to
+  a function is invalid. For example, this exception is raised when calling
+  `Integer.to_string/1` with an invalid argument:
 
-  def exception(arg) do
-    super(arg)
-  end
+      iex> Integer.to_string(1.0)
+      ** (ArgumentError) errors were found at the given arguments:
+      ...
+
+  `ArgumentError` exceptions have a single field, `:message` (a `t:String.t/0`),
+  which is public and can be accessed freely when reading or creating `ArgumentError`
+  exceptions.
+  """
+
+  defexception message: "argument error"
 end
 
 defmodule ArithmeticError do
-  defexception []
+  @moduledoc """
+  An exception raised on invalid arithmetic operations.
 
-  def message(_) do
-    "bad argument in arithmetic expression"
-  end
-end
+  For example, this exception is raised if you divide by `0`:
 
-defmodule SystemLimitError do
-  defexception []
+      iex> 1 / 0
+      ** (ArithmeticError) bad argument in arithmetic expression
+  """
 
-  def message(_) do
-    "a system limit has been reached"
-  end
-end
+  defexception message: "bad argument in arithmetic expression"
 
-defmodule SyntaxError do
-  defexception [file: nil, line: nil, description: "syntax error"]
+  @unary_ops [:+, :-]
+  @binary_ops [:+, :-, :*, :/]
+  @binary_funs [:div, :rem]
+  @bitwise_binary_funs [:band, :bor, :bxor, :bsl, :bsr]
 
-  def message(exception) do
-    Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
-      " " <> exception.description
-  end
-end
+  @impl true
+  def blame(%{message: message} = exception, [{:erlang, fun, args, _} | _] = stacktrace) do
+    message =
+      message <>
+        case {fun, args} do
+          {op, [a]} when op in @unary_ops ->
+            ": #{op}(#{inspect(a)})"
 
-defmodule TokenMissingError do
-  defexception [file: nil, line: nil, description: "expression is incomplete"]
+          {op, [a, b]} when op in @binary_ops ->
+            ": #{inspect(a)} #{op} #{inspect(b)}"
 
-  def message(exception) do
-    Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
-      " " <> exception.description
-  end
-end
+          {fun, [a, b]} when fun in @binary_funs ->
+            ": #{fun}(#{inspect(a)}, #{inspect(b)})"
 
-defmodule CompileError do
-  defexception [file: nil, line: nil, description: "compile error"]
+          {fun, [a, b]} when fun in @bitwise_binary_funs ->
+            ": Bitwise.#{fun}(#{inspect(a)}, #{inspect(b)})"
 
-  def message(exception) do
-    Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
-      " " <> exception.description
-  end
-end
+          {:bnot, [a]} ->
+            ": Bitwise.bnot(#{inspect(a)})"
 
-defmodule BadFunctionError do
-  defexception [term: nil]
+          _ ->
+            ""
+        end
 
-  def message(exception) do
-    "expected a function, got: #{inspect(exception.term)}"
+    {%{exception | message: message}, stacktrace}
   end
-end
-
-defmodule BadStructError do
-  defexception [struct: nil, term: nil]
 
-  def message(exception) do
-    "expected a struct named #{inspect(exception.struct)}, got: #{inspect(exception.term)}"
+  def blame(exception, stacktrace) do
+    {exception, stacktrace}
   end
 end
 
-defmodule MatchError do
-  defexception [term: nil]
+defmodule SystemLimitError do
+  @moduledoc """
+  An exception raised when a system limit has been reached.
 
-  def message(exception) do
-    "no match of right hand side value: #{inspect(exception.term)}"
-  end
-end
+  For example, this can happen if you try to create an atom that is too large:
 
-defmodule CaseClauseError do
-  defexception [term: nil]
+      iex> String.to_atom(String.duplicate("a", 100_000))
+      ** (SystemLimitError) a system limit has been reached
+  """
 
-  def message(exception) do
-    "no case clause matching: #{inspect(exception.term)}"
-  end
+  defexception message: "a system limit has been reached"
 end
 
-defmodule CondClauseError do
-  defexception []
+defmodule MismatchedDelimiterError do
+  @moduledoc """
+  An exception raised when a mismatched delimiter is found when parsing code.
+
+  For example:
+
+      iex> Code.eval_string("[1, 2, 3}")
+      ** (MismatchedDelimiterError) mismatched delimiter found on nofile:1:9:
+      ...
+
+  The following fields of this exceptions are public and can be accessed freely:
+
+    * `:file` (`t:Path.t/0` or `nil`) - the file where the error occurred, or `nil` if
+      the error occurred in code that did not come from a file
+    * `:line` - the line for the opening delimiter
+    * `:column` - the column for the opening delimiter
+    * `:end_line` - the line for the mismatched closing delimiter
+    * `:end_column` - the column for the mismatched closing delimiter
+    * `:opening_delimiter` - an atom representing the opening delimiter
+    * `:closing_delimiter` - an atom representing the mismatched closing delimiter
+    * `:expected_delimiter` - an atom representing the closing delimiter
+    * `:description` - a description of the mismatched delimiter error
+  """
 
-  def message(_exception) do
-    "no cond clause evaluated to a true value"
+  defexception [
+    :file,
+    :line,
+    :column,
+    :end_line,
+    :end_column,
+    :opening_delimiter,
+    :closing_delimiter,
+    :expected_delimiter,
+    :snippet,
+    description: "mismatched delimiter error"
+  ]
+
+  @impl true
+  def message(%{
+        line: start_line,
+        column: start_column,
+        end_line: end_line,
+        end_column: end_column,
+        description: description,
+        expected_delimiter: expected_delimiter,
+        file: file,
+        snippet: snippet
+      }) do
+    start_pos = {start_line, start_column}
+    end_pos = {end_line, end_column}
+    lines = String.split(snippet, "\n")
+    expected_delimiter = Exception.format_delimiter(expected_delimiter)
+
+    start_message = "└ unclosed delimiter"
+    end_message = ~s/└ mismatched closing delimiter (expected #{expected_delimiter})/
+
+    snippet =
+      Exception.format_snippet(
+        start_pos,
+        end_pos,
+        description,
+        file,
+        lines,
+        start_message,
+        end_message
+      )
+
+    format_message(file, end_line, end_column, snippet)
+  end
+
+  defp format_message(file, line, column, message) do
+    location = Exception.format_file_line_column(Path.relative_to_cwd(file), line, column)
+    "mismatched delimiter found on " <> location <> "\n" <> message
   end
 end
 
-defmodule TryClauseError do
-  defexception [term: nil]
+defmodule SyntaxError do
+  @moduledoc """
+  An exception raised when there's a syntax error when parsing code.
 
-  def message(exception) do
-    "no try clause matching: #{inspect(exception.term)}"
-  end
-end
+  For example:
 
-defmodule BadArityError do
-  defexception [function: nil, args: nil]
+      iex> Code.eval_string("5 + 5h")
+      ** (SyntaxError) invalid syntax found on nofile:1:5:
+      ...
 
-  def message(exception) do
-    fun  = exception.function
-    args = exception.args
-    insp = Enum.map_join(args, ", ", &inspect/1)
-    {:arity, arity} = :erlang.fun_info(fun, :arity)
-    "#{inspect(fun)} with arity #{arity} called with #{count(length(args), insp)}"
+  The following fields of this exceptions are public and can be accessed freely:
+
+    * `:file` (`t:Path.t/0` or `nil`) - the file where the error occurred, or `nil` if
+      the error occurred in code that did not come from a file
+    * `:line` - the line where the error occurred
+    * `:column` - the column where the error occurred
+    * `:description` - a description of the syntax error
+  """
+
+  defexception [:file, :line, :column, :snippet, description: "syntax error"]
+
+  @impl true
+  def message(%{
+        file: file,
+        line: line,
+        column: column,
+        description: description,
+        snippet: snippet
+      })
+      when not is_nil(snippet) and not is_nil(column) do
+    snippet =
+      :elixir_errors.format_snippet(:error, {line, column}, file, description, snippet, %{})
+
+    format_message(file, line, column, snippet)
   end
 
-  defp count(0, _insp), do: "no arguments"
-  defp count(1, insp),  do: "1 argument (#{insp})"
-  defp count(x, insp),  do: "#{x} arguments (#{insp})"
-end
+  @impl true
+  def message(%{
+        file: file,
+        line: line,
+        column: column,
+        description: description
+      }) do
+    snippet =
+      :elixir_errors.format_snippet(:error, {line, column}, file, description, nil, %{})
 
-defmodule UndefinedFunctionError do
-  defexception [module: nil, function: nil, arity: nil]
+    padded = "   " <> String.replace(snippet, "\n", "\n   ")
+    format_message(file, line, column, padded)
+  end
 
-  def message(exception) do
-    if exception.function do
-      formatted = Exception.format_mfa exception.module, exception.function, exception.arity
-      "undefined function: #{formatted}"
-    else
-      "undefined function"
-    end
+  defp format_message(file, line, column, message) do
+    location = Exception.format_file_line_column(Path.relative_to_cwd(file), line, column)
+    "invalid syntax found on " <> location <> "\n" <> message
   end
 end
 
-defmodule FunctionClauseError do
-  defexception [module: nil, function: nil, arity: nil]
+defmodule TokenMissingError do
+  @moduledoc """
+  An exception raised when a token is missing when parsing code.
+
+  For example:
+
+      iex> Code.eval_string("[1, 2, 3")
+      ** (TokenMissingError) token missing on nofile:1:9:
+      ...
+
+  The following fields of this exceptions are public and can be accessed freely:
+
+    * `:file` (`t:Path.t/0` or `nil`) - the file where the error occurred, or `nil` if
+      the error occurred in code that did not come from a file
+    * `:line` - the line for the opening delimiter
+    * `:column` - the column for the opening delimiter
+    * `:end_line` - the line for the end of the string
+    * `:end_column` - the column for the end of the string
+    * `:opening_delimiter` - an atom representing the opening delimiter
+    * `:expected_delimiter` - an atom representing the expected delimiter
+    * `:description` - a description of the missing token error
+
+  This is mostly raised by Elixir tooling when compiling and evaluating code.
+  """
+
+  defexception [
+    :file,
+    :line,
+    :column,
+    :end_line,
+    :end_column,
+    :snippet,
+    :opening_delimiter,
+    :expected_delimiter,
+    description: "expression is incomplete"
+  ]
+
+  @impl true
+  def message(%{
+        file: file,
+        line: line,
+        column: column,
+        end_line: end_line,
+        description: description,
+        expected_delimiter: expected_delimiter,
+        snippet: snippet
+      })
+      when not is_nil(snippet) and not is_nil(column) and not is_nil(end_line) do
+    {trimmed, [last_line | _] = reversed_lines} =
+      snippet
+      |> String.split("\n")
+      |> Enum.reverse()
+      |> Enum.split_while(&(&1 == ""))
+
+    end_line = end_line - length(trimmed)
+    end_column = String.length(last_line) + 1
+
+    start_pos = {line, column}
+    end_pos = {end_line, end_column}
+    expected_delimiter = Exception.format_delimiter(expected_delimiter)
+
+    start_message = ~s/└ unclosed delimiter/
+    end_message = ~s/└ missing closing delimiter (expected #{expected_delimiter})/
+
+    snippet =
+      Exception.format_snippet(
+        start_pos,
+        end_pos,
+        description,
+        file,
+        Enum.reverse(reversed_lines),
+        start_message,
+        end_message
+      )
+
+    format_message(file, end_line, end_column, snippet)
+  end
+
+  @impl true
+  def message(%{
+        file: file,
+        line: line,
+        column: column,
+        snippet: snippet,
+        description: description
+      }) do
+    snippet =
+      :elixir_errors.format_snippet(:error, {line, column}, file, description, snippet, %{})
+
+    format_message(file, line, column, snippet)
+  end
+
+  defp format_message(file, line, column, message) do
+    location = Exception.format_file_line_column(Path.relative_to_cwd(file), line, column)
+    "token missing on " <> location <> "\n" <> message
+  end
+end
+
+defmodule CompileError do
+  @moduledoc """
+  An exception raised when there's an error when compiling code.
+
+  For example:
+
+      1 = y
+      ** (CompileError) iex:1: undefined variable "y"
+
+  The following fields of this exceptions are public and can be accessed freely:
+
+    * `:file` (`t:Path.t/0` or `nil`) - the file where the error occurred, or `nil` if
+      the error occurred in code that did not come from a file
+    * `:line` (`t:non_neg_integer/0`) - the line where the error occurred
+    * `:description` (`t:String.t/0`) - a description of the compile error
+
+  This is mostly raised by Elixir tooling when compiling and evaluating code.
+  """
+
+  defexception [:file, :line, description: "compile error"]
+
+  @impl true
+  def message(%{file: file, line: line, description: description}) do
+    case Exception.format_file_line(file && Path.relative_to_cwd(file), line) do
+      "" -> description
+      formatted -> formatted <> " " <> description
+    end
+  end
+end
+
+defmodule Kernel.TypespecError do
+  @moduledoc """
+  An exception raised when there's an error in a typespec.
+
+  For example, if your typespec definition points to an invalid type, you get an exception:
+
+      @type my_type :: intger()
+
+  will raise:
+
+      ** (Kernel.TypespecError) type intger/0 undefined
+
+  The following fields of this exceptions are public and can be accessed freely:
+
+    * `:file` (`t:Path.t/0` or `nil`) - the file where the error occurred, or `nil` if
+      the error occurred in code that did not come from a file
+    * `:line` (`t:non_neg_integer/0`) - the line where the error occurred
+  """
+
+  defexception [:file, :line, :description]
+
+  @impl true
+  def message(%{file: file, line: line, description: description}) do
+    case Exception.format_file_line(file && Path.relative_to_cwd(file), line) do
+      "" -> description
+      formatted -> formatted <> " " <> description
+    end
+  end
+end
+
+defmodule BadFunctionError do
+  @moduledoc """
+  An exception raised when a function is expected, but something else was given.
+
+  For example:
+
+      iex> value = "hello"
+      iex> value.()
+      ** (BadFunctionError) expected a function, got: "hello"
+  """
+
+  defexception [:term]
+
+  @impl true
+  def message(%{term: term}) when is_function(term) do
+    "function #{inspect(term)} is invalid, likely because it points to an old version of the code"
+  end
 
   def message(exception) do
-    if exception.function do
-      formatted = Exception.format_mfa exception.module, exception.function, exception.arity
-      "no function clause matching in #{formatted}"
+    "expected a function, got: #{inspect(exception.term)}"
+  end
+end
+
+defmodule BadMapError do
+  @moduledoc """
+  An exception raised when a map is expected, but something else was given.
+
+  For example:
+
+      iex> value = "hello"
+      iex> %{value | key: "value"}
+      ** (BadMapError) expected a map, got:
+      ...
+  """
+
+  defexception [:term]
+
+  @impl true
+  def message(exception) do
+    Exception.__format_message_with_term__(
+      "expected a map, got:",
+      exception.term
+    )
+  end
+end
+
+defmodule BadBooleanError do
+  @moduledoc """
+  An exception raised when a boolean is expected, but something else was given.
+
+  This exception is raised by `and` and `or` when the first argument is not a boolean:
+
+      iex> 123 and true
+      ** (BadBooleanError) expected a boolean on left-side of "and", got:
+      ...
+  """
+
+  defexception [:term, :operator]
+
+  @impl true
+  def message(exception) do
+    Exception.__format_message_with_term__(
+      "expected a boolean on left-side of \"#{exception.operator}\", got:",
+      exception.term
+    )
+  end
+end
+
+defmodule MatchError do
+  @moduledoc """
+  An exception raised when a pattern match (`=/2`) fails.
+
+  For example:
+
+      iex> [_ | _] = []
+      ** (MatchError) no match of right hand side value:
+      ...
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:term` (`t:term/0`) - the term that did not match the pattern
+
+  """
+
+  defexception [:term]
+
+  @impl true
+  def message(exception) do
+    Exception.__format_message_with_term__(
+      "no match of right hand side value:",
+      exception.term
+    )
+  end
+end
+
+defmodule CaseClauseError do
+  @moduledoc """
+  An exception raised when a term in a `case/2` expression
+  does not match any of the defined `->` clauses.
+
+  For example:
+
+      iex> case System.unique_integer() do
+      ...>   bin when is_binary(bin) -> :oops
+      ...>   :ok -> :neither_this_one
+      ...> end
+      ** (CaseClauseError) no case clause matching:
+      ...
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:term` (`t:term/0`) - the term that did not match any of the clauses
+  """
+
+  defexception [:term]
+
+  @impl true
+  def message(exception) do
+    Exception.__format_message_with_term__(
+      "no case clause matching:",
+      exception.term
+    )
+  end
+end
+
+defmodule WithClauseError do
+  @moduledoc """
+  An exception raised when a term in a `with/1` expression
+  does not match any of the defined `->` clauses in its `else`.
+
+  For example, this exception gets raised for a `with/1` like the following, because
+  the `{:ok, 2}` term does not match the `:error` or `{:error, _}` clauses in the
+  `else`:
+
+      iex> with {:ok, 1} <- {:ok, 2} do
+      ...>   :woah
+      ...> else
+      ...>   :error -> :error
+      ...>   {:error, _} -> :error
+      ...> end
+      ** (WithClauseError) no with clause matching:
+      ...
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:term` (`t:term/0`) - the term that did not match any of the clauses
+  """
+
+  defexception [:term]
+
+  @impl true
+  def message(exception) do
+    Exception.__format_message_with_term__(
+      "no with clause matching:",
+      exception.term
+    )
+  end
+end
+
+defmodule CondClauseError do
+  @moduledoc """
+  An exception raised when no clauses in a `cond/1` expression evaluate to a truthy value.
+
+  For example, this exception gets raised for a `cond/1` like the following:
+
+      iex> cond do
+      ...>   1 + 1 == 3 -> :woah
+      ...>   nil -> "yeah this won't happen"
+      ...> end
+      ** (CondClauseError) no cond clause evaluated to a truthy value
+  """
+
+  defexception []
+
+  @impl true
+  def message(_exception) do
+    "no cond clause evaluated to a truthy value"
+  end
+end
+
+defmodule TryClauseError do
+  @moduledoc """
+  An exception raised when none of the `else` clauses in a `try/1` match.
+
+  For example:
+
+      iex> try do
+      ...>   :ok
+      ...> rescue
+      ...>   e -> e
+      ...> else
+      ...>   # :ok -> :ok is missing
+      ...>   :not_ok -> :not_ok
+      ...> end
+      ** (TryClauseError) no try clause matching:
+      ...
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:term` (`t:term/0`) - the term that did not match any of the clauses
+
+  """
+  defexception [:term]
+
+  @impl true
+  def message(exception) do
+    Exception.__format_message_with_term__(
+      "no try clause matching:",
+      exception.term
+    )
+  end
+end
+
+defmodule BadArityError do
+  @moduledoc """
+  An exception raised when a function is called with the wrong number of arguments.
+
+  For example:
+
+      my_function = fn x, y -> x + y end
+      my_function.(42)
+      ** (BadArityError) #Function<41.39164016/2 in :erl_eval.expr/6> with arity 2 called with 1 argument (42)
+  """
+
+  defexception [:function, :args]
+
+  @impl true
+  def message(exception) do
+    fun = exception.function
+    args = exception.args
+    insp = Enum.map_join(args, ", ", &inspect/1)
+    {:arity, arity} = Function.info(fun, :arity)
+    "#{inspect(fun)} with arity #{arity} called with #{count(length(args), insp)}"
+  end
+
+  defp count(0, _insp), do: "no arguments"
+  defp count(1, insp), do: "1 argument (#{insp})"
+  defp count(x, insp), do: "#{x} arguments (#{insp})"
+end
+
+defmodule UndefinedFunctionError do
+  @moduledoc """
+  An exception raised when a function is invoked that is not defined.
+
+  For example:
+
+      # Let's use apply/3 as otherwise Elixir emits a compile-time warning
+      iex> apply(String, :non_existing_fun, ["hello"])
+      ** (UndefinedFunctionError) function String.non_existing_fun/1 is undefined or private
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:module` (`t:module/0`) - the module name
+    * `:function` (`t:atom/0`) - the function name
+    * `:arity` (`t:non_neg_integer/0`) - the arity of the function
+  """
+
+  @function_threshold 0.77
+  @max_suggestions 5
+  defexception [:module, :function, :arity, :reason, :message]
+
+  @impl true
+  def message(%{message: nil} = exception) do
+    %{reason: reason, module: module, function: function, arity: arity} = exception
+    {message, hint_type} = message(reason, module, function, arity)
+    message <> if(hint_type == :suggest_module, do: hint_for_missing_alias(module), else: "")
+  end
+
+  def message(%{message: message}) do
+    message
+  end
+
+  defp message(nil, module, function, arity) do
+    cond do
+      is_nil(function) or is_nil(arity) ->
+        {"undefined function", :suggest_module}
+
+      is_nil(module) ->
+        formatted_fun = Exception.format_mfa(module, function, arity)
+        {"function #{formatted_fun} is undefined", :suggest_module}
+
+      function_exported?(module, :module_info, 0) ->
+        message(:"function not exported", module, function, arity)
+
+      true ->
+        message(:"module could not be loaded", module, function, arity)
+    end
+  end
+
+  defp message(:"module could not be loaded", module, function, arity) do
+    formatted_fun = Exception.format_mfa(module, function, arity)
+
+    {"function #{formatted_fun} is undefined (module #{inspect(module)} is not available)",
+     :suggest_module}
+  end
+
+  defp message(:"function not exported", module, function, arity) do
+    formatted_fun = Exception.format_mfa(module, function, arity)
+    {"function #{formatted_fun} is undefined or private", :suggest_function}
+  end
+
+  defp message(:"undefined local", nil, function, arity) do
+    {"function #{function}/#{arity} is undefined (there is no such import)", :no_hint}
+  end
+
+  defp message(reason, module, function, arity) do
+    formatted_fun = Exception.format_mfa(module, function, arity)
+    {"function #{formatted_fun} is undefined (#{reason})", :suggest_module}
+  end
+
+  @impl true
+  def blame(exception, stacktrace) do
+    %{reason: reason, module: module, function: function, arity: arity} = exception
+    {message, hint_type} = message(reason, module, function, arity)
+    message = message <> hint(module, function, arity, hint_type)
+    {%{exception | message: message}, stacktrace}
+  end
+
+  defp hint(_, _, _, :no_hint), do: ""
+
+  defp hint(nil, _function, 0, _hint_type) do
+    ". If you are using the dot syntax, such as module.function(), " <>
+      "make sure the left-hand side of the dot is a module atom"
+  end
+
+  defp hint(module, function, arity, :suggest_function) do
+    hint_for_behaviour(module, function, arity) <>
+      hint_for_loaded_module(module, function, arity)
+  end
+
+  defp hint(module, function, arity, :suggest_module) do
+    hint_for_missing_module(module, function, arity)
+  end
+
+  defp hint_for_missing_alias(module) do
+    with "Elixir." <> rest <- Atom.to_string(module),
+         false <- rest =~ "." do
+      ". Make sure the module name is correct and has been specified in full (or that an alias has been defined)"
+    else
+      _ -> ""
+    end
+  end
+
+  @doc false
+  def hint_for_missing_module(module, function, arity) do
+    downcased_module = downcase_module_name(module)
+    stripped_module = module |> Atom.to_string() |> String.replace_leading("Elixir.", "")
+
+    candidates =
+      for {name, _, _} = candidate <- :code.all_available(),
+          downcase_module_name(name) == downcased_module or
+            String.ends_with?(List.to_string(name), stripped_module),
+          {:module, module} <- [load_module(candidate)],
+          function_exported?(module, function, arity),
+          do: module
+
+    if candidates != [] do
+      suggestions =
+        candidates
+        |> Enum.take(@max_suggestions)
+        |> Enum.sort(:asc)
+        |> Enum.map(fn module ->
+          ["\n      * ", Exception.format_mfa(module, function, arity)]
+        end)
+
+      ". Did you mean:\n#{suggestions}\n"
+    else
+      hint_for_missing_alias(module)
+    end
+  end
+
+  defp load_module({name, _path, _loaded?}) do
+    name
+    |> List.to_atom()
+    |> Code.ensure_loaded()
+  end
+
+  defp downcase_module_name(module) do
+    module
+    |> to_string()
+    |> String.downcase(:ascii)
+  end
+
+  @doc false
+  def hint_for_loaded_module(module, function, arity) do
+    cond do
+      macro_exported?(module, function, arity) ->
+        ". However, there is a macro with the same name and arity. " <>
+          "Be sure to require #{inspect(module)} if you intend to invoke this macro"
+
+      message = otp_obsolete(module, function, arity) ->
+        ", #{message}"
+
+      true ->
+        IO.iodata_to_binary(did_you_mean(module, function))
+    end
+  end
+
+  defp otp_obsolete(module, function, arity) do
+    case :otp_internal.obsolete(module, function, arity) do
+      {:removed, [_ | _] = string} -> string
+      _ -> nil
+    end
+  end
+
+  defp hint_for_behaviour(module, function, arity) do
+    case behaviours_for(module) do
+      [] ->
+        ""
+
+      behaviours ->
+        case Enum.find(behaviours, &expects_callback?(&1, function, arity)) do
+          nil -> ""
+          behaviour -> ", but the behaviour #{inspect(behaviour)} expects it to be present"
+        end
+    end
+  rescue
+    # In case the module was removed while we are computing this
+    UndefinedFunctionError -> ""
+  end
+
+  defp behaviours_for(module) do
+    :attributes
+    |> module.module_info()
+    |> Keyword.get(:behaviour, [])
+  end
+
+  defp expects_callback?(behaviour, function, arity) do
+    callbacks =
+      behaviour.behaviour_info(:callbacks) -- behaviour.behaviour_info(:optional_callbacks)
+
+    Enum.member?(callbacks, {function, arity})
+  end
+
+  ## Shared helpers across hints
+
+  defp did_you_mean(module, function) do
+    exports = exports_for(module)
+
+    result =
+      case Keyword.take(exports, [function]) do
+        [] ->
+          candidates = exports -- deprecated_functions_for(module)
+          base = Atom.to_string(function)
+
+          for {key, val} <- candidates,
+              dist = String.jaro_distance(base, Atom.to_string(key)),
+              dist >= @function_threshold,
+              do: {dist, key, val}
+
+        arities ->
+          for {key, val} <- arities, do: {1.0, key, val}
+      end
+      |> Enum.sort(&(elem(&1, 0) >= elem(&2, 0)))
+      |> Enum.take(@max_suggestions)
+      |> Enum.sort(&(elem(&1, 1) <= elem(&2, 1)))
+
+    case result do
+      [] -> []
+      suggestions -> [". Did you mean:\n\n" | Enum.map(suggestions, &format_fa/1)]
+    end
+  end
+
+  defp format_fa({_dist, fun, arity}) do
+    ["    * ", Macro.inspect_atom(:remote_call, fun), ?/, Integer.to_string(arity), ?\n]
+  end
+
+  defp exports_for(module) do
+    if function_exported?(module, :__info__, 1) do
+      module.__info__(:macros) ++ module.__info__(:functions)
     else
-      "no function clause matches"
+      module.module_info(:exports)
+    end
+  rescue
+    # In case the module was removed while we are computing this
+    UndefinedFunctionError -> []
+  end
+
+  defp deprecated_functions_for(module) do
+    if function_exported?(module, :__info__, 1) do
+      for {name_arity, _message} <- module.__info__(:deprecated), do: name_arity
+    else
+      []
+    end
+  rescue
+    # In case the module was removed while we are computing this
+    UndefinedFunctionError -> []
+  end
+end
+
+defmodule FunctionClauseError do
+  @moduledoc """
+  An exception raised when a function call doesn't match any defined clause.
+
+  For example:
+
+      iex> URI.parse(:wrong_argument)
+      ** (FunctionClauseError) no function clause matching in URI.parse/1
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:module` (`t:module/0`) - the module name
+    * `:function` (`t:atom/0`) - the function name
+    * `:arity` (`t:non_neg_integer/0`) - the arity of the function
+  """
+
+  defexception [:module, :function, :arity, :kind, :args, :clauses]
+
+  @clause_limit 10
+
+  @impl true
+  def message(exception) do
+    case exception do
+      %{function: nil} ->
+        "no function clause matches"
+
+      %{module: module, function: function, arity: arity} ->
+        formatted = Exception.format_mfa(module, function, arity)
+        blamed = blame(exception, &inspect/1, &blame_match/1)
+        "no function clause matching in #{formatted}" <> blamed
+    end
+  end
+
+  @impl true
+  def blame(%{module: module, function: function, arity: arity} = exception, stacktrace) do
+    case stacktrace do
+      [{^module, ^function, args, meta} | rest] when length(args) == arity ->
+        exception =
+          case Exception.blame_mfa(module, function, args) do
+            {:ok, kind, clauses} -> %{exception | args: args, kind: kind, clauses: clauses}
+            :error -> %{exception | args: args}
+          end
+
+        {exception, [{module, function, arity, meta} | rest]}
+
+      stacktrace ->
+        {exception, stacktrace}
     end
   end
+
+  defp blame_match(%{match?: true, node: node}), do: Macro.to_string(node)
+  defp blame_match(%{match?: false, node: node}), do: "-" <> Macro.to_string(node) <> "-"
+
+  @doc false
+  def blame(%{args: nil}, _, _) do
+    ""
+  end
+
+  def blame(exception, inspect_fun, fun) do
+    %{module: module, function: function, arity: arity, kind: kind, args: args, clauses: clauses} =
+      exception
+
+    mfa = Exception.format_mfa(module, function, arity)
+
+    format_clause_fun = fn {args, guards} ->
+      args = Enum.map_join(args, ", ", fun)
+      base = "    #{kind} #{function}(#{args})"
+      Enum.reduce(guards, base, &"#{&2} when #{clause_to_string(&1, fun, 0)}") <> "\n"
+    end
+
+    "\n\nThe following arguments were given to #{mfa}:\n" <>
+      "#{format_args(args, inspect_fun)}" <>
+      "#{format_clauses(clauses, format_clause_fun, @clause_limit)}"
+  end
+
+  defp clause_to_string({op, _, [left, right]} = node, fun, parent) do
+    case Code.Identifier.binary_op(op) do
+      {_side, precedence} ->
+        left = clause_to_string(left, fun, precedence)
+        right = clause_to_string(right, fun, precedence)
+
+        if parent > precedence do
+          "(" <> left <> " #{op} " <> right <> ")"
+        else
+          left <> " #{op} " <> right
+        end
+
+      _ ->
+        fun.(node)
+    end
+  end
+
+  defp clause_to_string(node, fun, _precedence), do: fun.(node)
+
+  defp format_args(args, inspect_fun) do
+    args
+    |> Enum.with_index(1)
+    |> Enum.map(fn {arg, i} ->
+      [pad("\n# "), Integer.to_string(i), pad("\n"), pad(inspect_fun.(arg)), "\n"]
+    end)
+  end
+
+  defp format_clauses(clauses, format_clause_fun, limit)
+  defp format_clauses(nil, _, _), do: ""
+  defp format_clauses([], _, _), do: ""
+
+  defp format_clauses(clauses, format_clause_fun, limit) do
+    top_clauses =
+      clauses
+      |> Enum.take(limit)
+      |> Enum.map(format_clause_fun)
+
+    [
+      "\nAttempted function clauses (showing #{length(top_clauses)} out of #{length(clauses)}):",
+      "\n\n",
+      top_clauses,
+      non_visible_clauses(length(clauses) - limit)
+    ]
+  end
+
+  defp non_visible_clauses(n) when n <= 0, do: []
+  defp non_visible_clauses(1), do: ["    ...\n    (1 clause not shown)\n"]
+  defp non_visible_clauses(n), do: ["    ...\n    (#{n} clauses not shown)\n"]
+
+  defp pad(string) do
+    String.replace(string, "\n", "\n    ")
+  end
 end
 
 defmodule Code.LoadError do
-  defexception [:file, :message]
+  @moduledoc """
+  An exception raised when a file cannot be loaded.
+
+  This is typically raised by functions in the `Code` module, for example:
+
+      Code.require_file("missing_file.exs")
+      ** (Code.LoadError) could not load missing_file.exs. Reason: enoent
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:file` (`t:String.t/0`) - the file name
+    * `:reason` (`t:term/0`) - the reason why the file could not be loaded
+  """
+
+  defexception [:file, :message, :reason]
 
   def exception(opts) do
     file = Keyword.fetch!(opts, :file)
-    %Code.LoadError{message: "could not load #{file}", file: file}
+    reason = Keyword.fetch!(opts, :reason)
+    message = "could not load #{file}. Reason: #{reason}"
+    %Code.LoadError{message: message, file: file, reason: reason}
   end
 end
 
 defmodule Protocol.UndefinedError do
-  defexception [protocol: nil, value: nil, description: nil]
+  @moduledoc """
+  An exception raised when a protocol is not implemented for a given value.
 
-  def message(exception) do
-    msg = "protocol #{inspect exception.protocol} not implemented for #{inspect exception.value}"
-    if exception.description do
-      msg <> ", " <> exception.description
-    else
-      msg
+  For example:
+
+      iex> Enum.at("A string!", 0)
+      ** (Protocol.UndefinedError) protocol Enumerable not implemented for BitString
+      ...
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:protocol` (`t:module/0`) - the protocol that is not implemented
+    * `:value` (`t:term/0`) - the value that does not implement the protocol
+  """
+
+  defexception [:protocol, :value, description: ""]
+
+  @impl true
+  def message(%{protocol: protocol, value: value, description: description}) do
+    inspected =
+      value
+      |> inspect(pretty: true)
+      # Indent only lines with contents on them
+      |> String.replace(~r/^(?=.+)/m, "    ")
+
+    "protocol #{inspect(protocol)} not implemented for " <>
+      value_type(value) <>
+      maybe_description(description) <>
+      maybe_available(protocol) <>
+      """
+
+
+      Got value:
+
+      #{inspected}
+      """
+  end
+
+  defp value_type(%{__struct__: struct}), do: "#{inspect(struct)} (a struct)"
+  defp value_type(value) when is_atom(value), do: "Atom"
+  defp value_type(value) when is_bitstring(value), do: "BitString"
+  defp value_type(value) when is_float(value), do: "Float"
+  defp value_type(value) when is_function(value), do: "Function"
+  defp value_type(value) when is_integer(value), do: "Integer"
+  defp value_type(value) when is_list(value), do: "List"
+  defp value_type(value) when is_map(value), do: "Map"
+  defp value_type(value) when is_pid(value), do: "PID"
+  defp value_type(value) when is_port(value), do: "Port"
+  defp value_type(value) when is_reference(value), do: "Reference"
+  defp value_type(value) when is_tuple(value), do: "Tuple"
+
+  defp maybe_description(""), do: ""
+  defp maybe_description(description), do: ", " <> description
+
+  defp maybe_available(protocol) do
+    case protocol.__protocol__(:impls) do
+      {:consolidated, []} ->
+        ". There are no implementations for this protocol."
+
+      {:consolidated, types} ->
+        ". This protocol is implemented for: " <>
+          Enum.map_join(types, ", ", &inspect/1)
+
+      :not_consolidated ->
+        ""
     end
   end
 end
 
 defmodule KeyError do
-  defexception key: nil, term: nil
+  @moduledoc """
+  An exception raised when a key is not found in a data structure.
 
-  def message(exception) do
-    "key #{inspect exception.key} not found in: #{inspect exception.term}"
+  For example, this is raised by `Map.fetch!/2` when the given key
+  cannot be found in the given map:
+
+      iex> map = %{name: "Alice", age: 25}
+      iex> Map.fetch!(map, :first_name)
+      ** (KeyError) key :first_name not found in:
+      ...
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:term` (`t:term/0`) - the data structure that was searched
+    * `:key` (`t:term/0`) - the key that was not found
+  """
+
+  defexception [:key, :term, :message]
+
+  @impl true
+  def message(exception = %{message: nil}), do: message(exception.key, exception.term)
+  def message(%{message: message}), do: message
+
+  defp message(key, term) do
+    message = "key #{inspect(key)} not found"
+
+    cond do
+      term == nil ->
+        message
+
+      is_atom(term) and is_atom(key) ->
+        message <>
+          " in: #{inspect(term)} (if instead you want to invoke #{inspect(term)}.#{key}(), " <>
+          "make sure to add parentheses after the function name)"
+
+      true ->
+        Exception.__format_message_with_term__(
+          message <> " in:",
+          term
+        )
+    end
+  end
+
+  @impl true
+  def blame(exception = %{message: message}, stacktrace) when is_binary(message) do
+    {exception, stacktrace}
+  end
+
+  def blame(exception, stacktrace) do
+    %{term: term, key: key} = exception
+    message = message(key, term)
+
+    if is_atom(key) and (map_with_atom_keys_only?(term) or Keyword.keyword?(term)) do
+      hint = did_you_mean(key, available_keys(term))
+      message = message <> IO.iodata_to_binary(hint)
+      {%{exception | message: message}, stacktrace}
+    else
+      {%{exception | message: message}, stacktrace}
+    end
+  end
+
+  defp map_with_atom_keys_only?(term) do
+    is_map(term) and Enum.all?(Map.to_list(term), fn {k, _} -> is_atom(k) end)
+  end
+
+  defp available_keys(term) when is_map(term), do: Map.keys(term)
+  defp available_keys(term) when is_list(term), do: Keyword.keys(term)
+
+  @threshold 0.77
+  @max_suggestions 5
+  defp did_you_mean(missing_key, available_keys) do
+    stringified_key = Atom.to_string(missing_key)
+
+    suggestions =
+      for key <- available_keys,
+          distance = String.jaro_distance(stringified_key, Atom.to_string(key)),
+          distance >= @threshold,
+          do: {distance, key}
+
+    case suggestions do
+      [] -> []
+      suggestions -> ["\nDid you mean:\n\n" | format_suggestions(suggestions)]
+    end
+  end
+
+  defp format_suggestions(suggestions) do
+    suggestions
+    |> Enum.sort(&(elem(&1, 0) >= elem(&2, 0)))
+    |> Enum.take(@max_suggestions)
+    |> Enum.sort(&(elem(&1, 1) <= elem(&2, 1)))
+    |> Enum.map(fn {_, key} -> ["    * ", inspect(key), ?\n] end)
   end
 end
 
 defmodule UnicodeConversionError do
+  @moduledoc """
+  An exception raised when converting data to or from Unicode.
+
+  For example:
+
+      iex> String.to_charlist(<<0xFF>>)
+      ** (UnicodeConversionError) invalid encoding starting at <<255>>
+
+  """
   defexception [:encoded, :message]
 
   def exception(opts) do
     %UnicodeConversionError{
       encoded: Keyword.fetch!(opts, :encoded),
-      message: "#{Keyword.fetch!(opts, :kind)} #{detail Keyword.fetch!(opts, :rest)}"
+      message: "#{Keyword.fetch!(opts, :kind)} #{detail(Keyword.fetch!(opts, :rest))}"
     }
   end
 
   defp detail(rest) when is_binary(rest) do
-    "encoding starting at #{inspect rest}"
+    "encoding starting at #{inspect(rest)}"
   end
 
-  defp detail([h|_]) do
+  defp detail([h | _]) when is_integer(h) do
     "code point #{h}"
   end
+
+  defp detail([h | _]) do
+    detail(h)
+  end
+end
+
+defmodule MissingApplicationsError do
+  @moduledoc """
+  An exception that is raised when an application depends on one or more
+  missing applications.
+
+  This exception is used by Mix and other tools. It can also be used by library authors
+  when their library only requires an external application (like a dependency) for a subset
+  of features.
+
+  The fields of this exception are public. See `t:t/0`.
+
+  *Available since v1.18.0.*
+
+  ## Examples
+
+      unless Application.spec(:plug, :vsn) do
+        raise MissingApplicationsError,
+          description: "application :plug is required for testing Plug-related functionality",
+          apps: [{:plug, "~> 1.0"}]
+      end
+
+  """
+
+  @moduledoc since: "1.18.0"
+
+  @type t() :: %__MODULE__{
+          apps: [{Application.app(), Version.requirement()}, ...],
+          description: String.t()
+        }
+
+  defexception apps: [], description: "missing applications found"
+
+  @impl true
+  def message(%__MODULE__{apps: apps, description: description}) do
+    # We explicitly format these as tuples so that they're easier to copy-paste
+    # into dependencies.
+    formatted_apps =
+      Enum.map(apps, fn {app_name, requirement} ->
+        ~s(\n  {#{inspect(app_name)}, "#{requirement}"})
+      end)
+
+    """
+    #{description}
+
+    To address this, include these applications as your dependencies:
+    #{formatted_apps}\
+    """
+  end
 end
 
 defmodule Enum.OutOfBoundsError do
-  defexception []
+  @moduledoc """
+  An exception that is raised when a function expects an enumerable to have
+  a certain size but finds that it is too small.
+
+  For example:
+
+      iex> Enum.fetch!([1, 2, 3], 5)
+      ** (Enum.OutOfBoundsError) out of bounds error at position 5 when traversing enumerable [1, 2, 3]
+  """
 
-  def message(_) do
-    "out of bounds error"
+  defexception [:enumerable, :index, :message]
+
+  @impl true
+  def message(exception = %{message: nil}), do: message(exception.index, exception.enumerable)
+  def message(%{message: message}), do: message
+
+  def message(index, enumerable) do
+    "out of bounds error" <>
+      if index do
+        " at position #{index}"
+      else
+        ""
+      end <>
+      if enumerable do
+        " when traversing enumerable #{inspect(enumerable)}"
+      else
+        ""
+      end
   end
 end
 
 defmodule Enum.EmptyError do
-  defexception []
+  @moduledoc """
+  An exception that is raised when something expects a non-empty enumerable
+  but finds an empty one.
 
-  def message(_) do
-    "empty error"
-  end
+  For example:
+
+      iex> Enum.min([])
+      ** (Enum.EmptyError) empty error
+
+  """
+
+  defexception message: "empty error"
 end
 
 defmodule File.Error do
-  defexception [reason: nil, action: "", path: nil]
+  @moduledoc """
+  An exception that is raised when a file operation fails.
+
+  For example, this exception is raised, when trying to read a non existent file:
+
+      iex> File.read!("nonexistent_file.txt")
+      ** (File.Error) could not read file "nonexistent_file.txt": no such file or directory
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:path` (`t:Path.t/0`) - the path of the file that caused the error
+    * `:reason` (`t:File.posix/0`) - the reason for the error
+
+  """
+
+  defexception [:reason, :path, action: ""]
+
+  @impl true
+  def message(%{action: action, reason: reason, path: path}) do
+    formatted =
+      case {action, reason} do
+        {"remove directory", :eexist} ->
+          "directory is not empty"
+
+        _ ->
+          IO.iodata_to_binary(:file.format_error(reason))
+      end
+
+    "could not #{action} #{inspect(path)}: #{formatted}"
+  end
+end
+
+defmodule File.CopyError do
+  @moduledoc """
+  An exception that is raised when copying a file fails.
+
+  For example, this exception is raised when trying to copy to file or directory that isn't present:
 
+      iex> File.cp_r!("non_existent", "source_dir/subdir")
+      ** (File.CopyError) could not copy recursively from "non_existent" to "source_dir/subdir". non_existent: no such file or directory
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:source` (`t:Path.t/0`) - the source path
+    * `:destination` (`t:Path.t/0`) - the destination path
+    * `:reason` (`t:File.posix/0`) - the reason why the file could not be copied
+
+  """
+
+  defexception [:reason, :source, :destination, on: "", action: ""]
+
+  @impl true
   def message(exception) do
     formatted = IO.iodata_to_binary(:file.format_error(exception.reason))
-    "could not #{exception.action} #{exception.path}: #{formatted}"
+
+    location =
+      case exception.on do
+        "" -> ""
+        on -> ". #{on}"
+      end
+
+    "could not #{exception.action} from #{inspect(exception.source)} to " <>
+      "#{inspect(exception.destination)}#{location}: #{formatted}"
   end
 end
 
-defmodule File.CopyError do
-  defexception [reason: nil, action: "", source: nil, destination: nil, on: nil]
+defmodule File.RenameError do
+  @moduledoc """
+  An exception that is raised when renaming a file fails.
+
+  For example, this exception is raised when trying to rename a file that isn't present:
+
+    iex> File.rename!("source.txt", "target.txt")
+    ** (File.RenameError) could not rename from "source.txt" to "target.txt": no such file or directory
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:source` (`t:Path.t/0`) - the source path
+    * `:destination` (`t:Path.t/0`) - the destination path
+    * `:reason` (`t:File.posix/0`) - the reason why the file could not be renamed
 
+  """
+
+  defexception [:reason, :source, :destination, on: "", action: ""]
+
+  @impl true
   def message(exception) do
     formatted = IO.iodata_to_binary(:file.format_error(exception.reason))
-    location  = if on = exception.on, do: ". #{on}", else: ""
-    "could not #{exception.action} from #{exception.source} to " <>
-      "#{exception.destination}#{location}: #{formatted}"
+
+    location =
+      case exception.on do
+        "" -> ""
+        on -> ". #{on}"
+      end
+
+    "could not #{exception.action} from #{inspect(exception.source)} to " <>
+      "#{inspect(exception.destination)}#{location}: #{formatted}"
   end
 end
 
-defmodule ErlangError do
-  defexception [original: nil]
+defmodule File.LinkError do
+  @moduledoc """
+  An exception that is raised when linking a file fails.
+
+  For example, this exception is raised when trying to link to file that isn't present:
+
+      iex> File.ln!("existing.txt", "link.txt")
+      ** (File.LinkError) could not create hard link from "link.txt" to "existing.txt": no such file or directory
+
+  The following fields of this exception are public and can be accessed freely:
+
+    * `:existing` (`t:Path.t/0`) - the existing file to link
+    * `:new` (`t:Path.t/0`) - the link destination
+    * `:reason` (`t:File.posix/0`) - the reason why the file could not be linked
+
+  """
+
+  defexception [:reason, :existing, :new, action: ""]
 
+  @impl true
   def message(exception) do
-    "erlang error: #{inspect(exception.original)}"
+    formatted = IO.iodata_to_binary(:file.format_error(exception.reason))
+
+    "could not #{exception.action} from #{inspect(exception.new)} to " <>
+      "#{inspect(exception.existing)}: #{formatted}"
+  end
+end
+
+defmodule ErlangError do
+  @moduledoc """
+  An exception raised when invoking an Erlang code that errors
+  with a value not handled by Elixir.
+
+  Most common error reasons, such as `:badarg` are automatically
+  converted into exceptions by Elixir. However, you may invoke some
+  code that emits a custom error reason and those get wrapped into
+  `ErlangError`:
+
+      iex> :erlang.error(:some_invalid_error)
+      ** (ErlangError) Erlang error: :some_invalid_error
+  """
+
+  defexception [:original, :reason]
+
+  @impl true
+  def message(exception)
+
+  def message(%__MODULE__{original: original, reason: nil}) do
+    "Erlang error: #{inspect(original)}"
+  end
+
+  def message(%__MODULE__{original: original, reason: reason}) do
+    IO.iodata_to_binary(["Erlang error: ", inspect(original), reason])
   end
 
   @doc false
-  def normalize(:badarg, _stacktrace) do
-    %ArgumentError{}
+  def normalize(:badarg, stacktrace) do
+    case stacktrace do
+      [{:erlang, :apply, [module, function, args], _} | _] when not is_atom(module) ->
+        message =
+          cond do
+            is_map(module) and is_atom(function) and is_map_key(module, function) ->
+              "you attempted to apply a function named #{inspect(function)} on a map/struct. " <>
+                "If you are using Kernel.apply/3, make sure the module is an atom. " <>
+                if is_function(Map.get(module, function)) do
+                  "If you are trying to invoke an anonymous function in a map/struct, " <>
+                    "add a dot between the function name and the parenthesis: map.#{function}.()"
+                else
+                  "If you are using the dot syntax, ensure there are no parentheses " <>
+                    "after the field name, such as map.#{function}"
+                end
+
+            is_atom(function) and args == [] ->
+              "you attempted to apply a function named #{inspect(function)} on #{inspect(module)}. " <>
+                "If you are using Kernel.apply/3, make sure the module is an atom. " <>
+                "If you are using the dot syntax, such as module.function(), " <>
+                "make sure the left-hand side of the dot is an atom representing a module"
+
+            true ->
+              "you attempted to apply a function on #{inspect(module)}. " <>
+                "Modules (the first argument of apply) must always be an atom"
+          end
+
+        %ArgumentError{message: message}
+
+      _ ->
+        case error_info(:badarg, stacktrace, "errors were found at the given arguments") do
+          {:ok, reason, details} -> %ArgumentError{message: reason <> details}
+          :error -> %ArgumentError{}
+        end
+    end
   end
 
   def normalize(:badarith, _stacktrace) do
     %ArithmeticError{}
   end
 
-  def normalize(:system_limit, _stacktrace) do
-    %SystemLimitError{}
+  def normalize(:system_limit, stacktrace) do
+    default_reason = "a system limit has been reached due to errors at the given arguments"
+
+    case error_info(:system_limit, stacktrace, default_reason) do
+      {:ok, reason, details} -> %SystemLimitError{message: reason <> details}
+      :error -> %SystemLimitError{}
+    end
   end
 
   def normalize(:cond_clause, _stacktrace) do
@@ -753,29 +2591,65 @@ defmodule ErlangError do
     %BadFunctionError{term: term}
   end
 
-  def normalize({:badstruct, struct, term}, _stacktrace) do
-    %BadStructError{struct: struct, term: term}
-  end
-
   def normalize({:badmatch, term}, _stacktrace) do
     %MatchError{term: term}
   end
 
+  def normalize({:badmap, term}, _stacktrace) do
+    %BadMapError{term: term}
+  end
+
+  def normalize({:badbool, op, term}, _stacktrace) do
+    %BadBooleanError{operator: op, term: term}
+  end
+
+  def normalize({:badkey, key}, stacktrace) do
+    term =
+      case stacktrace do
+        [{Map, :get_and_update!, [map, _, _], _} | _] -> map
+        [{Map, :update!, [map, _, _], _} | _] -> map
+        [{:maps, :update, [_, _, map], _} | _] -> map
+        [{:maps, :get, [_, map], _} | _] -> map
+        [{:erlang, :map_get, [_, map], _} | _] -> map
+        _ -> nil
+      end
+
+    %KeyError{key: key, term: term}
+  end
+
+  def normalize({:badkey, key, map}, _stacktrace) when is_map(map) do
+    %KeyError{key: key, term: map}
+  end
+
+  def normalize({:badkey, key, term}, _stacktrace) do
+    message =
+      "key #{inspect(key)} not found in: #{inspect(term, pretty: true, limit: :infinity)}\n\n" <>
+        "If you are using the dot syntax, such as map.field, " <>
+        "make sure the left-hand side of the dot is a map"
+
+    %KeyError{key: key, term: term, message: message}
+  end
+
   def normalize({:case_clause, term}, _stacktrace) do
     %CaseClauseError{term: term}
   end
 
+  # :else_clause is aligned on what Erlang returns for `maybe`
+  def normalize({:else_clause, term}, _stacktrace) do
+    %WithClauseError{term: term}
+  end
+
   def normalize({:try_clause, term}, _stacktrace) do
     %TryClauseError{term: term}
   end
 
   def normalize(:undef, stacktrace) do
-    {mod, fun, arity} = from_stacktrace(stacktrace || :erlang.get_stacktrace)
+    {mod, fun, arity} = from_stacktrace(stacktrace)
     %UndefinedFunctionError{module: mod, function: fun, arity: arity}
   end
 
   def normalize(:function_clause, stacktrace) do
-    {mod, fun, arity} = from_stacktrace(stacktrace || :erlang.get_stacktrace)
+    {mod, fun, arity} = from_stacktrace(stacktrace)
     %FunctionClauseError{module: mod, function: fun, arity: arity}
   end
 
@@ -783,19 +2657,64 @@ defmodule ErlangError do
     %ArgumentError{message: "argument error: #{inspect(payload)}"}
   end
 
-  def normalize(other, _stacktrace) do
-    %ErlangError{original: other}
+  def normalize(other, stacktrace) do
+    case error_info(other, stacktrace, "") do
+      {:ok, _reason, details} -> %ErlangError{original: other, reason: details}
+      :error -> %ErlangError{original: other}
+    end
   end
 
-  defp from_stacktrace([{module, function, args, _}|_]) when is_list(args) do
+  defp from_stacktrace([{module, function, args, _} | _]) when is_list(args) do
     {module, function, length(args)}
   end
 
-  defp from_stacktrace([{module, function, arity, _}|_]) do
+  defp from_stacktrace([{module, function, arity, _} | _]) do
     {module, function, arity}
   end
 
   defp from_stacktrace(_) do
     {nil, nil, nil}
   end
+
+  defp error_info(erl_exception, stacktrace, default_reason) do
+    with [{module, fun, args_or_arity, opts} | tail] <- stacktrace,
+         %{} = error_info <- opts[:error_info] do
+      error_module = Map.get(error_info, :module, module)
+      error_fun = Map.get(error_info, :function, :format_error)
+
+      error_info = Map.put(error_info, :pretty_printer, &inspect/1)
+      head = {module, fun, args_or_arity, Keyword.put(opts, :error_info, error_info)}
+
+      extra =
+        try do
+          apply(error_module, error_fun, [erl_exception, [head | tail]])
+        rescue
+          _ -> %{}
+        end
+
+      arity = if is_integer(args_or_arity), do: args_or_arity, else: length(args_or_arity)
+      args_errors = Map.take(extra, Enum.to_list(1..arity//1))
+      reason = Map.get(extra, :reason, default_reason)
+
+      cond do
+        map_size(args_errors) > 0 ->
+          {:ok, reason, IO.iodata_to_binary([":\n\n" | Enum.map(args_errors, &arg_error/1)])}
+
+        general = extra[:general] ->
+          {:ok, reason, ": " <> IO.chardata_to_string(general)}
+
+        true ->
+          :error
+      end
+    else
+      _ -> :error
+    end
+  end
+
+  defp arg_error({n, message}), do: "  * #{nth(n)} argument: #{message}\n"
+
+  defp nth(1), do: "1st"
+  defp nth(2), do: "2nd"
+  defp nth(3), do: "3rd"
+  defp nth(n), do: "#{n}th"
 end
diff --git a/lib/elixir/lib/file.ex b/lib/elixir/lib/file.ex
index 23cc854db4c..255df12a0b5 100644
--- a/lib/elixir/lib/file.ex
+++ b/lib/elixir/lib/file.ex
@@ -1,37 +1,47 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule File do
   @moduledoc ~S"""
   This module contains functions to manipulate files.
 
   Some of those functions are low-level, allowing the user
-  to interact with the file or IO devices, like `open/2`,
+  to interact with files or IO devices, like `open/2`,
   `copy/3` and others. This module also provides higher
   level functions that work with filenames and have their naming
-  based on UNIX variants. For example, one can copy a file
+  based on Unix variants. For example, one can copy a file
   via `cp/3` and remove files and directories recursively
-  via `rm_rf/1`
+  via `rm_rf/1`.
+
+  Paths given to functions in this module can be either relative to the
+  current working directory (as returned by `File.cwd/0`), or absolute
+  paths. Shell conventions like `~` are not expanded automatically.
+  To use paths like `~/Downloads`, you can use `Path.expand/1` or
+  `Path.expand/2` to expand your path to an absolute path.
 
   ## Encoding
 
   In order to write and read files, one must use the functions
-  in the `IO` module. By default, a file is opened in binary mode
+  in the `IO` module. By default, a file is opened in binary mode,
   which requires the functions `IO.binread/2` and `IO.binwrite/2`
   to interact with the file. A developer may pass `:utf8` as an
   option when opening the file, then the slower `IO.read/2` and
   `IO.write/2` functions must be used as they are responsible for
-  doing the proper conversions and data guarantees.
+  doing the proper conversions and providing the proper data guarantees.
 
-  Note that filenames when given as char lists in Elixir are
+  Note that filenames when given as charlists in Elixir are
   always treated as UTF-8. In particular, we expect that the
-  shell and the operating system are configured to use UTF8
-  encoding. Binary filenames are considering raw and passed
-  to the OS as is.
+  shell and the operating system are configured to use UTF-8
+  encoding. Binary filenames are considered raw and passed
+  to the operating system as is.
 
   ## API
 
   Most of the functions in this module return `:ok` or
   `{:ok, result}` in case of success, `{:error, reason}`
-  otherwise. Those function are also followed by a variant
-  that ends with `!` which returns the result (without the
+  otherwise. Those functions also have a variant
+  that ends with `!` which returns the result (instead of the
   `{:ok, result}` tuple) in case of success or raises an
   exception in case it fails. For example:
 
@@ -47,15 +57,15 @@ defmodule File do
       File.read!("invalid.txt")
       #=> raises File.Error
 
-  In general, a developer should use the former in case he wants
+  In general, a developer should use the former in case they want
   to react if the file does not exist. The latter should be used
-  when the developer expects his software to fail in case the
+  when the developer expects their software to fail in case the
   file cannot be read (i.e. it is literally an exception).
 
   ## Processes and raw files
 
   Every time a file is opened, Elixir spawns a new process. Writing
-  to a file is equivalent to sending messages to that process that
+  to a file is equivalent to sending messages to the process that
   writes to the file descriptor.
 
   This means files can be passed between nodes and message passing
@@ -63,44 +73,163 @@ defmodule File do
 
   However, you may not always want to pay the price for this abstraction.
   In such cases, a file can be opened in `:raw` mode. The options `:read_ahead`
-  and `:delayed_write` are also useful when operating large files or
+  and `:delayed_write` are also useful when operating on large files or
   working with files in tight loops.
 
-  Check http://www.erlang.org/doc/man/file.html#open-2 for more information
-  about such options and other performance considerations.
-  """
+  Check `:file.open/2` for more information about such options and
+  other performance considerations.
+
+  ## Seeking within a file
+
+  You may also use any of the functions from the [`:file`](`:file`)
+  module to interact with files returned by Elixir. For example,
+  to read from a specific position in a file, use `:file.pread/3`:
+
+      File.write!("example.txt", "Eats, Shoots & Leaves")
+      file = File.open!("example.txt")
+      :file.pread(file, 15, 6)
+      #=> {:ok, "Leaves"}
 
-  alias :file, as: F
+  Alternatively, if you need to keep track of the current position,
+  use `:file.position/2` and `:file.read/2`:
+
+      :file.position(file, 6)
+      #=> {:ok, 6}
+      :file.read(file, 6)
+      #=> {:ok, "Shoots"}
+      :file.position(file, {:cur, -12})
+      #=> {:ok, 0}
+      :file.read(file, 4)
+      #=> {:ok, "Eats"}
+  """
 
   @type posix :: :file.posix()
   @type io_device :: :file.io_device()
+  @type file_descriptor :: :file.fd()
   @type stat_options :: [time: :local | :universal | :posix]
+  @type mode ::
+          :append
+          | :binary
+          | :charlist
+          | :compressed
+          | :delayed_write
+          | :exclusive
+          | :raw
+          | :read
+          | :read_ahead
+          | :sync
+          | :write
+          | {:read_ahead, pos_integer}
+          | {:delayed_write, non_neg_integer, non_neg_integer}
+          | encoding_mode()
+
+  @type encoding_mode ::
+          :utf8
+          | {
+              :encoding,
+              :latin1
+              | :unicode
+              | :utf8
+              | :utf16
+              | :utf32
+              | {:utf16, :big | :little}
+              | {:utf32, :big | :little}
+            }
+
+  @type stream_mode ::
+          encoding_mode()
+          | read_offset_mode()
+          | :append
+          | :compressed
+          | :delayed_write
+          | :trim_bom
+          | {:read_ahead, pos_integer | false}
+          | {:delayed_write, non_neg_integer, non_neg_integer}
+
+  @type read_offset_mode :: {:read_offset, non_neg_integer()}
+
+  @type erlang_time ::
+          {{year :: non_neg_integer(), month :: 1..12, day :: 1..31},
+           {hour :: 0..23, minute :: 0..59, second :: 0..59}}
+
+  @type posix_time :: integer()
+
+  @type on_conflict_callback :: (Path.t(), Path.t() -> boolean)
 
   @doc """
   Returns `true` if the path is a regular file.
 
+  This function follows symbolic links, so if a symbolic link points to a
+  regular file, `true` is returned.
+
+  ## Options
+
+  The supported options are:
+
+    * `:raw` - a single atom to bypass the file server and only check
+      for the file locally
+
   ## Examples
 
-      File.regular? __ENV__.file #=> true
+      File.regular?(__ENV__.file)
+      #=> true
 
   """
-  @spec regular?(Path.t) :: boolean
-  def regular?(path) do
-    :elixir_utils.read_file_type(IO.chardata_to_string(path)) == {:ok, :regular}
+  @spec regular?(Path.t(), [regular_option]) :: boolean
+        when regular_option: :raw
+  def regular?(path, opts \\ []) do
+    :elixir_utils.read_file_type(IO.chardata_to_string(path), opts) == {:ok, :regular}
   end
 
   @doc """
-  Returns `true` if the path is a directory.
+  Returns `true` if the given path is a directory.
+
+  This function follows symbolic links, so if a symbolic link points to a
+  directory, `true` is returned.
+
+  ## Options
+
+  The supported options are:
+
+    * `:raw` - a single atom to bypass the file server and only check
+      for the file locally
+
+  ## Examples
+
+      File.dir?("./test")
+      #=> true
+
+      File.dir?("test")
+      #=> true
+
+      File.dir?("/usr/bin")
+      #=> true
+
+      File.dir?("~/Downloads")
+      #=> false
+
+      "~/Downloads" |> Path.expand() |> File.dir?()
+      #=> true
+
   """
-  @spec dir?(Path.t) :: boolean
-  def dir?(path) do
-    :elixir_utils.read_file_type(IO.chardata_to_string(path)) == {:ok, :directory}
+  @spec dir?(Path.t(), [dir_option]) :: boolean
+        when dir_option: :raw
+  def dir?(path, opts \\ []) do
+    :elixir_utils.read_file_type(IO.chardata_to_string(path), opts) == {:ok, :directory}
   end
 
   @doc """
   Returns `true` if the given path exists.
-  It can be regular file, directory, socket,
-  symbolic link, named pipe or device file.
+
+  It can be a regular file, directory, socket, symbolic link, named pipe, or device file.
+  Returns `false` for symbolic links pointing to non-existing targets.
+
+  ## Options
+
+  The supported options are:
+
+    * `:raw` - a single atom to bypass the file server and only check
+      for the file locally
 
   ## Examples
 
@@ -114,55 +243,91 @@ defmodule File do
       #=> true
 
   """
-  @spec exists?(Path.t) :: boolean
-  def exists?(path) do
-    match?({:ok, _}, F.read_file_info(IO.chardata_to_string(path)))
+  @spec exists?(Path.t(), [exists_option]) :: boolean
+        when exists_option: :raw
+  def exists?(path, opts \\ []) do
+    opts = [{:time, :posix}] ++ opts
+    match?({:ok, _}, :file.read_file_info(IO.chardata_to_string(path), opts))
   end
 
   @doc """
-  Tries to create the directory `path`. Missing parent directories are not created.
+  Tries to create the directory `path`.
+
+  Missing parent directories are not created.
   Returns `:ok` if successful, or `{:error, reason}` if an error occurs.
 
   Typical error reasons are:
 
     * `:eacces`  - missing search or write permissions for the parent
-                   directories of `path`
+      directories of `path`
     * `:eexist`  - there is already a file or directory named `path`
     * `:enoent`  - a component of `path` does not exist
-    * `:enospc`  - there is a no space left on the device
+    * `:enospc`  - there is no space left on the device
     * `:enotdir` - a component of `path` is not a directory;
-                   on some platforms, `:enoent` is returned instead
+      on some platforms, `:enoent` is returned instead
+
+  ## Examples
+
+      File.mkdir("test/unit")
+      #=> :ok
+
+      File.mkdir("non/existing")
+      #=> {:error, :enoent}
   """
-  @spec mkdir(Path.t) :: :ok | {:error, posix}
+  @spec mkdir(Path.t()) :: :ok | {:error, posix | :badarg}
   def mkdir(path) do
-    F.make_dir(IO.chardata_to_string(path))
+    :file.make_dir(IO.chardata_to_string(path))
   end
 
   @doc """
-  Same as `mkdir/1`, but raises an exception in case of failure. Otherwise `:ok`.
+  Same as `mkdir/1`, but raises a `File.Error` exception in case of failure.
+  Otherwise `:ok`.
+
+  ## Examples
+
+      File.mkdir!("test/unit")
+      #=> :ok
+
+      File.mkdir!("non/existing")
+      ** (File.Error) could not make directory "non/existing": no such file or directory
   """
-  @spec mkdir!(Path.t) :: :ok | no_return
+  @spec mkdir!(Path.t()) :: :ok
   def mkdir!(path) do
-    path = IO.chardata_to_string(path)
     case mkdir(path) do
-      :ok -> :ok
+      :ok ->
+        :ok
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "make directory", path: path
+        raise File.Error,
+          reason: reason,
+          action: "make directory",
+          path: IO.chardata_to_string(path)
     end
   end
 
   @doc """
-  Tries to create the directory `path`. Missing parent directories are created.
-  Returns `:ok` if successful, or `{:error, reason}` if an error occurs.
+  Tries to create the directory `path`.
+
+  Missing parent directories are created. Returns `:ok` if successful, or
+  `{:error, reason}` if an error occurs.
 
   Typical error reasons are:
 
     * `:eacces`  - missing search or write permissions for the parent
-                   directories of `path`
-    * `:enospc`  - there is a no space left on the device
+      directories of `path`
+    * `:enospc`  - there is no space left on the device
     * `:enotdir` - a component of `path` is not a directory
+    * `:eperm`   - missed required permissions
+
+  ## Examples
+
+      File.mkdir_p("non/existing/parents")
+      #=> :ok
+
+      File.mkdir_p("/usr/sbin/temp")
+      #=> {:error, :eperm}
   """
-  @spec mkdir_p(Path.t) :: :ok | {:error, posix}
+  @spec mkdir_p(Path.t()) :: :ok | {:error, posix | :badarg}
   def mkdir_p(path) do
     do_mkdir_p(IO.chardata_to_string(path))
   end
@@ -172,35 +337,50 @@ defmodule File do
   end
 
   defp do_mkdir_p(path) do
-    if dir?(path) do
+    parent = Path.dirname(path)
+
+    if parent == path do
       :ok
     else
-      parent = Path.dirname(path)
-      if parent == path do
-        # Protect against infinite loop
-        {:error, :einval}
-      else
-        _ = do_mkdir_p(parent)
-        case :file.make_dir(path) do
-          {:error, :eexist} = error ->
-            if dir?(path), do: :ok, else: error
-          other ->
-            other
-        end
+      case do_mkdir_p(parent) do
+        :ok ->
+          case :file.make_dir(path) do
+            {:error, :eexist} ->
+              if dir?(path), do: :ok, else: {:error, :enotdir}
+
+            other ->
+              other
+          end
+
+        e ->
+          e
       end
     end
   end
 
   @doc """
-  Same as `mkdir_p/1`, but raises an exception in case of failure. Otherwise `:ok`.
+  Same as `mkdir_p/1`, but raises a `File.Error` exception in case of failure.
+  Otherwise `:ok`.
+
+  ## Examples
+
+      File.mkdir_p!("non/existing/parents")
+      #=> :ok
+
+      File.mkdir_p!("/usr/sbin/temp")
+      ** (File.Error) could not make directory (with -p) "/usr/sbin/temp": not owner
   """
-  @spec mkdir_p!(Path.t) :: :ok | no_return
+  @spec mkdir_p!(Path.t()) :: :ok
   def mkdir_p!(path) do
-    path = IO.chardata_to_string(path)
     case mkdir_p(path) do
-      :ok -> :ok
+      :ok ->
+        :ok
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "make directory (with -p)", path: path
+        raise File.Error,
+          reason: reason,
+          action: "make directory (with -p)",
+          path: IO.chardata_to_string(path)
     end
   end
 
@@ -212,31 +392,47 @@ defmodule File do
 
     * `:enoent`  - the file does not exist
     * `:eacces`  - missing permission for reading the file,
-                   or for searching one of the parent directories
+      or for searching one of the parent directories
     * `:eisdir`  - the named file is a directory
     * `:enotdir` - a component of the file name is not a directory;
-                   on some platforms, `:enoent` is returned instead
+      on some platforms, `:enoent` is returned instead
     * `:enomem`  - there is not enough memory for the contents of the file
 
   You can use `:file.format_error/1` to get a descriptive string of the error.
+
+  ## Examples
+
+      File.read("hello.txt")
+      #=> {:ok, "world"}
+
+      File.read("non_existing.txt")
+      #=> {:error, :enoent}
   """
-  @spec read(Path.t) :: {:ok, binary} | {:error, posix}
+  @spec read(Path.t()) :: {:ok, binary} | {:error, posix | :badarg | :terminated | :system_limit}
   def read(path) do
-    F.read_file(IO.chardata_to_string(path))
+    :file.read_file(IO.chardata_to_string(path))
   end
 
   @doc """
-  Returns binary with the contents of the given filename or raises
-  `File.Error` if an error occurs.
+  Returns a binary with the contents of the given filename,
+  or raises a `File.Error` exception if an error occurs.
+
+  ## Examples
+
+      File.read!("hello.txt")
+      #=> "world"
+
+      File.read!("non_existing.txt")
+      ** (File.Error) could not read file "non_existing.txt": no such file or directory
   """
-  @spec read!(Path.t) :: binary | no_return
+  @spec read!(Path.t()) :: binary
   def read!(path) do
-    path = IO.chardata_to_string(path)
     case read(path) do
       {:ok, binary} ->
         binary
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "read file", path: path
+        raise File.Error, reason: reason, action: "read file", path: IO.chardata_to_string(path)
     end
   end
 
@@ -250,83 +446,353 @@ defmodule File do
 
   The accepted options are:
 
-    * `:time` - `:local | :universal | :posix`; default: `:local`
+    * `:time` - configures how the file timestamps are returned
+
+  The values for `:time` can be:
+
+    * `:universal` - returns a `{date, time}` tuple in UTC (default)
+    * `:local` - returns a `{date, time}` tuple using the same time zone as the
+      machine
+    * `:posix` - returns the time as integer seconds since epoch
+
+  Note: Since file times are stored in POSIX time format on most operating systems,
+  it is faster to retrieve file information with the `time: :posix` option.
+
+  ## Examples
+
+      File.stat("hello.txt")
+      #=> {:ok, %File.Stat{...}}
 
+      File.stat("non_existing.txt", time: :posix)
+      #=> {:error, :enoent}
   """
-  @spec stat(Path.t, stat_options) :: {:ok, File.Stat.t} | {:error, posix}
+  @spec stat(Path.t(), stat_options) :: {:ok, File.Stat.t()} | {:error, posix | :badarg}
   def stat(path, opts \\ []) do
-    case F.read_file_info(IO.chardata_to_string(path), opts) do
+    opts = Keyword.put_new(opts, :time, :universal)
+
+    case :file.read_file_info(IO.chardata_to_string(path), opts) do
       {:ok, fileinfo} ->
         {:ok, File.Stat.from_record(fileinfo)}
+
       error ->
         error
     end
   end
 
   @doc """
-  Same as `stat/2` but returns the `File.Stat` directly and
-  throws `File.Error` if an error is returned.
+  Same as `stat/2` but returns the `File.Stat` directly,
+  or raises a `File.Error` exception if an error is returned.
+
+  ## Examples
+
+      File.stat!("hello.txt")
+      #=> %File.Stat{...}
+
+      File.stat!("non_existing.txt", time: :posix)
+      ** (File.Error) could not read file stats "non_existing.txt": no such file or directory
   """
-  @spec stat!(Path.t, stat_options) :: File.Stat.t | no_return
+  @spec stat!(Path.t(), stat_options) :: File.Stat.t()
   def stat!(path, opts \\ []) do
-    path = IO.chardata_to_string(path)
     case stat(path, opts) do
-      {:ok, info}      -> info
+      {:ok, info} ->
+        info
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "read file stats", path: path
+        raise File.Error,
+          reason: reason,
+          action: "read file stats",
+          path: IO.chardata_to_string(path)
+    end
+  end
+
+  @doc """
+  Returns information about the `path`. If the file is a symlink, sets
+  the `type` to `:symlink` and returns a `File.Stat` struct for the link. For any
+  other file, returns exactly the same values as `stat/2`.
+
+  For more details, see `:file.read_link_info/2`.
+
+  ## Options
+
+  The accepted options are:
+
+    * `:time` - configures how the file timestamps are returned
+
+  The values for `:time` can be:
+
+    * `:universal` - returns a `{date, time}` tuple in UTC (default)
+    * `:local` - returns a `{date, time}` tuple using the machine time
+    * `:posix` - returns the time as integer seconds since epoch
+
+  Note: Since file times are stored in POSIX time format on most operating systems,
+  it is faster to retrieve file information with the `time: :posix` option.
+
+  ## Examples
+
+      File.lstat("link_to_hello")
+      #=> {:ok, %File.Stat{type: :symlink, ...}}
+
+      File.lstat("non_existing.txt", time: :posix)
+      #=> {:error, :enoent}
+  """
+  @spec lstat(Path.t(), stat_options) :: {:ok, File.Stat.t()} | {:error, posix | :badarg}
+  def lstat(path, opts \\ []) do
+    opts = Keyword.put_new(opts, :time, :universal)
+
+    case :file.read_link_info(IO.chardata_to_string(path), opts) do
+      {:ok, fileinfo} ->
+        {:ok, File.Stat.from_record(fileinfo)}
+
+      error ->
+        error
     end
   end
 
   @doc """
-  Writes the given `File.Stat` back to the filesystem at the given
+  Same as `lstat/2` but returns the `File.Stat` struct directly,
+  or raises a `File.Error` exception if an error is returned.
+
+  ## Examples
+
+      File.lstat!("link_to_hello")
+      #=> %File.Stat{type: :symlink, ...}
+
+      File.lstat!("non_existing.txt", time: :posix)
+      ** (File.Error) could not read file stats "non_existing.txt": no such file or directory
+  """
+  @spec lstat!(Path.t(), stat_options) :: File.Stat.t()
+  def lstat!(path, opts \\ []) do
+    case lstat(path, opts) do
+      {:ok, info} ->
+        info
+
+      {:error, reason} ->
+        raise File.Error,
+          reason: reason,
+          action: "read file stats",
+          path: IO.chardata_to_string(path)
+    end
+  end
+
+  @doc """
+  Reads the symbolic link at `path`.
+
+  If `path` exists and is a symlink, returns `{:ok, target}`, otherwise returns
+  `{:error, reason}`.
+
+  For more details, see `:file.read_link/1`.
+
+  Typical error reasons are:
+
+    * `:einval` - path is not a symbolic link
+    * `:enoent` - path does not exist
+    * `:enotsup` - symbolic links are not supported on the current platform
+
+  ## Examples
+
+      File.read_link("link_to_hello")
+      #=> {:ok, "hello.txt"}
+
+      File.read_link("hello.txt")
+      #=> {:error, :einval}
+  """
+  @doc since: "1.5.0"
+  @spec read_link(Path.t()) :: {:ok, binary} | {:error, posix | :badarg}
+  def read_link(path) do
+    case path |> IO.chardata_to_string() |> :file.read_link() do
+      {:ok, target} -> {:ok, IO.chardata_to_string(target)}
+      error -> error
+    end
+  end
+
+  @doc """
+  Same as `read_link/1` but returns the target directly,
+  or raises a `File.Error` exception if an error is returned.
+
+  ## Examples
+
+      File.read_link!("link_to_hello")
+      #=> "hello.txt"
+
+      File.read_link!("hello.txt")
+      ** (File.Error) could not read link "hello.txt": invalid argument
+  """
+  @doc since: "1.5.0"
+  @spec read_link!(Path.t()) :: binary
+  def read_link!(path) do
+    case read_link(path) do
+      {:ok, resolved} ->
+        resolved
+
+      {:error, reason} ->
+        raise File.Error, reason: reason, action: "read link", path: IO.chardata_to_string(path)
+    end
+  end
+
+  @doc """
+  Writes the given `File.Stat` back to the file system at the given
   path. Returns `:ok` or `{:error, reason}`.
+
+  ## Examples
+
+      File.write_stat("hello.txt", new_stat)
+      #=> :ok
+
+      File.write_stat("non_existing.txt", new_stat)
+      #=> {:error, :enoent}
   """
-  @spec write_stat(Path.t, File.Stat.t, stat_options) :: :ok | {:error, posix}
+  @spec write_stat(Path.t(), File.Stat.t(), stat_options) :: :ok | {:error, posix | :badarg}
   def write_stat(path, stat, opts \\ []) do
-    F.write_file_info(IO.chardata_to_string(path), File.Stat.to_record(stat), opts)
+    opts = Keyword.put_new(opts, :time, :universal)
+    :file.write_file_info(IO.chardata_to_string(path), File.Stat.to_record(stat), opts)
   end
 
   @doc """
-  Same as `write_stat/3` but raises an exception if it fails.
+  Same as `write_stat/3` but raises a `File.Error` exception if it fails.
   Returns `:ok` otherwise.
+
+  ## Examples
+
+      File.write_stat!("hello.txt", new_stat)
+      #=> :ok
+
+      File.write_stat!("non_existing.txt", new_stat)
+      ** (File.Error) could not write file stats "non_existing.txt": no such file or directory
   """
-  @spec write_stat!(Path.t, File.Stat.t, stat_options) :: :ok | no_return
+  @spec write_stat!(Path.t(), File.Stat.t(), stat_options) :: :ok
   def write_stat!(path, stat, opts \\ []) do
-    path = IO.chardata_to_string(path)
     case write_stat(path, stat, opts) do
-      :ok -> :ok
+      :ok ->
+        :ok
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "write file stats", path: path
+        raise File.Error,
+          reason: reason,
+          action: "write file stats",
+          path: IO.chardata_to_string(path)
     end
   end
 
   @doc """
   Updates modification time (mtime) and access time (atime) of
-  the given file. File is created if it doesn’t exist.
+  the given file.
+
+  The file is created if it doesn't exist. Requires datetime in UTC
+  (as returned by `:erlang.universaltime()`) or an integer
+  representing the POSIX timestamp (as returned by `System.os_time(:second)`).
+
+  In Unix-like systems, changing the modification time may require
+  you to be either `root` or the owner of the file. Having write
+  access may not be enough. In those cases, touching the file the
+  first time (to create it) will succeed, but touching an existing
+  file with fail with `{:error, :eperm}`.
+
+  ## Examples
+
+      File.touch("/tmp/a.txt", {{2018, 1, 30}, {13, 59, 59}})
+      #=> :ok
+      File.touch("/fakedir/b.txt", {{2018, 1, 30}, {13, 59, 59}})
+      {:error, :enoent}
+
+      File.touch("/tmp/a.txt", 1_544_519_753)
+      #=> :ok
+
   """
-  @spec touch(Path.t, :calendar.datetime) :: :ok | {:error, posix}
-  def touch(path, time \\ :calendar.local_time) do
+  @spec touch(Path.t(), erlang_time() | posix_time()) ::
+          :ok | {:error, posix | :badarg | :terminated | :system_limit}
+  def touch(path, time \\ System.os_time(:second))
+
+  def touch(path, time) when is_tuple(time) do
     path = IO.chardata_to_string(path)
-    case F.change_time(path, time) do
-      {:error, :enoent} ->
-        write(path, "")
-        F.change_time(path, time)
-      other ->
-        other
-    end
+
+    with {:error, :enoent} <- :elixir_utils.change_universal_time(path, time),
+         :ok <- write(path, "", [:raw, :append]),
+         do: :elixir_utils.change_universal_time(path, time)
+  end
+
+  def touch(path, time) when is_integer(time) do
+    path = IO.chardata_to_string(path)
+
+    with {:error, :enoent} <- :elixir_utils.change_posix_time(path, time),
+         :ok <- write(path, "", [:raw, :append]),
+         do: :elixir_utils.change_posix_time(path, time)
   end
 
   @doc """
-  Same as `touch/2` but raises an exception if it fails.
+  Same as `touch/2` but raises a `File.Error` exception if it fails.
   Returns `:ok` otherwise.
+
+  The file is created if it doesn't exist. Requires datetime in UTC
+  (as returned by `:erlang.universaltime()`) or an integer
+  representing the POSIX timestamp (as returned by `System.os_time(:second)`).
+
+  ## Examples
+
+      File.touch!("/tmp/a.txt", {{2018, 1, 30}, {13, 59, 59}})
+      #=> :ok
+      File.touch!("/fakedir/b.txt", {{2018, 1, 30}, {13, 59, 59}})
+      ** (File.Error) could not touch "/fakedir/b.txt": no such file or directory
+
+      File.touch!("/tmp/a.txt", 1_544_519_753)
+
   """
-  @spec touch!(Path.t, :calendar.datetime) :: :ok | no_return
-  def touch!(path, time \\ :calendar.local_time) do
-    path = IO.chardata_to_string(path)
+  @spec touch!(Path.t(), erlang_time() | posix_time()) :: :ok
+  def touch!(path, time \\ System.os_time(:second)) do
     case touch(path, time) do
-      :ok -> :ok
+      :ok ->
+        :ok
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "touch", path: path
+        raise File.Error, reason: reason, action: "touch", path: IO.chardata_to_string(path)
+    end
+  end
+
+  @doc """
+  Creates a hard link `new` to the file `existing`.
+
+  Returns `:ok` if successful, `{:error, reason}` otherwise.
+  If the operating system does not support hard links, returns
+  `{:error, :enotsup}`.
+
+  ## Examples
+
+      File.ln("hello.txt", "hard_link_to_hello")
+      #=> :ok
+
+      File.ln("non_existing.txt", "link")
+      #=> {:error, :enoent}
+  """
+  @doc since: "1.5.0"
+  @spec ln(Path.t(), Path.t()) :: :ok | {:error, posix | :badarg}
+  def ln(existing, new) do
+    :file.make_link(IO.chardata_to_string(existing), IO.chardata_to_string(new))
+  end
+
+  @doc """
+  Same as `ln/2` but raises a `File.LinkError` exception if it fails.
+  Returns `:ok` otherwise.
+
+  ## Examples
+
+      File.ln!("hello.txt", "hard_link_to_hello")
+      #=> :ok
+
+      File.ln!("non_existing.txt", "link")
+      ** (File.LinkError) could not create hard link from "non_existing.txt" to "link": no such file or directory
+  """
+  @doc since: "1.5.0"
+  @spec ln!(Path.t(), Path.t()) :: :ok
+  def ln!(existing, new) do
+    case ln(existing, new) do
+      :ok ->
+        :ok
+
+      {:error, reason} ->
+        raise File.LinkError,
+          reason: reason,
+          action: "create hard link",
+          existing: IO.chardata_to_string(existing),
+          new: IO.chardata_to_string(new)
     end
   end
 
@@ -336,15 +802,59 @@ defmodule File do
   Returns `:ok` if successful, `{:error, reason}` otherwise.
   If the operating system does not support symlinks, returns
   `{:error, :enotsup}`.
+
+  Creates a symlink even if the `existing` target actually doesn't exist
+
+  ## Examples
+
+      File.ln_s("hello.txt", "link_to_hello")
+      #=> :ok
+
+      File.ln_s("non_existing.txt", "link")
+      #=> :ok
+
+      # Returns error if `new` file exists
+      File.ln_s("non_existing.txt", "existed_link")
+      #=> {:error, :eexist}
   """
+  @doc since: "1.5.0"
+  @spec ln_s(Path.t(), Path.t()) :: :ok | {:error, posix | :badarg}
   def ln_s(existing, new) do
-    F.make_symlink(existing, new)
+    :file.make_symlink(IO.chardata_to_string(existing), IO.chardata_to_string(new))
+  end
+
+  @doc """
+  Same as `ln_s/2` but raises a `File.LinkError` exception if it fails.
+  Returns `:ok` otherwise.
+
+  ## Examples
+
+      File.ln_s!("hello.txt", "link_to_hello")
+      #=> :ok
+
+      # Raises if `new` file exists
+      File.ln_s!("non_existing.txt", "existed_link")
+      ** (File.LinkError) could not create symlink from "non_existing.txt" to "existed_link": file already exists
+  """
+  @spec ln_s!(Path.t(), Path.t()) :: :ok
+  def ln_s!(existing, new) do
+    case ln_s(existing, new) do
+      :ok ->
+        :ok
+
+      {:error, reason} ->
+        raise File.LinkError,
+          reason: reason,
+          action: "create symlink",
+          existing: IO.chardata_to_string(existing),
+          new: IO.chardata_to_string(new)
+    end
   end
 
   @doc """
   Copies the contents of `source` to `destination`.
 
-  Both parameters can be a filename or an io device opened
+  Both parameters can be a filename or an IO device opened
   with `open/2`. `bytes_count` specifies the number of
   bytes to copy, the default being `:infinity`.
 
@@ -362,222 +872,472 @@ defmodule File do
 
   Typical error reasons are the same as in `open/2`,
   `read/1` and `write/3`.
+
+  ## Examples
+
+      File.copy("hello.txt", "hello_copy.txt")
+      #=> {:ok, 6}
+
+      File.copy("non_existing.txt", "copy.txt")
+      #=> {:error, :enoent}
   """
-  @spec copy(Path.t, Path.t, pos_integer | :infinity) :: {:ok, non_neg_integer} | {:error, posix}
+  @spec copy(Path.t() | io_device, Path.t() | io_device, pos_integer | :infinity) ::
+          {:ok, non_neg_integer} | {:error, posix | :badarg | :terminated}
   def copy(source, destination, bytes_count \\ :infinity) do
-    F.copy(IO.chardata_to_string(source), IO.chardata_to_string(destination), bytes_count)
+    source = normalize_path_or_io_device(source)
+    destination = normalize_path_or_io_device(destination)
+
+    :file.copy(source, destination, bytes_count)
   end
 
   @doc """
-  The same as `copy/3` but raises an `File.CopyError` if it fails.
+  The same as `copy/3` but raises a `File.CopyError` exception if it fails.
   Returns the `bytes_copied` otherwise.
+
+  ## Examples
+
+      File.copy!("hello.txt", "hello_copy.txt")
+      #=> 6
+
+      File.copy!("non_existing.txt", "copy.txt")
+      ** (File.CopyError) could not copy from "non_existing.txt" to "copy.txt": no such file or directory
   """
-  @spec copy!(Path.t, Path.t, pos_integer | :infinity) :: non_neg_integer | no_return
+  @spec copy!(Path.t() | io_device, Path.t() | io_device, pos_integer | :infinity) ::
+          non_neg_integer
   def copy!(source, destination, bytes_count \\ :infinity) do
-    source = IO.chardata_to_string(source)
-    destination = IO.chardata_to_string(destination)
     case copy(source, destination, bytes_count) do
-      {:ok, bytes_count} -> bytes_count
+      {:ok, bytes_count} ->
+        bytes_count
+
       {:error, reason} ->
-        raise File.CopyError, reason: reason, action: "copy",
-          source: source, destination: destination
+        raise File.CopyError,
+          reason: reason,
+          action: "copy",
+          source: normalize_path_or_io_device(source),
+          destination: normalize_path_or_io_device(destination)
     end
   end
 
   @doc """
-  Copies the contents in `source` to `destination` preserving its mode.
+  Renames the `source` file to `destination` file.  It can be used to move files
+  (and directories) between directories.  If moving a file, you must fully
+  specify the `destination` filename, it is not sufficient to simply specify
+  its directory.
 
-  If a file already exists in the destination, it invokes a
-  callback which should return `true` if the existing file
-  should be overwritten, `false` otherwise. It defaults to return `true`.
+  Returns `:ok` in case of success, `{:error, reason}` otherwise.
 
-  It returns `:ok` in case of success, returns
-  `{:error, reason}` otherwise.
+  Note: The command `mv` in Unix-like systems behaves differently depending on
+  whether `source` is a file and the `destination` is an existing directory.
+  We have chosen to explicitly disallow this behavior.
 
-  If you want to copy contents from an io device to another device
-  or do a straight copy from a source to a destination without
-  preserving modes, check `copy/3` instead.
+  ## Examples
+
+      # Rename file "a.txt" to "b.txt"
+      File.rename("a.txt", "b.txt")
+      #=> :ok
+
+      # Rename directory "samples" to "tmp"
+      File.rename("samples", "tmp")
+      #=> :ok
 
-  Note: The command `cp` in Unix systems behaves differently depending
-  if `destination` is an existing directory or not. We have chosen to
-  explicitly disallow this behaviour. If destination is a directory, an
-  error will be returned.
+      File.rename("non_existing.txt", "existing.txt")
+      #=> {:error, :enoent}
   """
-  @spec cp(Path.t, Path.t, (Path.t, Path.t -> boolean)) :: :ok | {:error, posix}
-  def cp(source, destination, callback \\ fn(_, _) -> true end) do
+  @doc since: "1.1.0"
+  @spec rename(Path.t(), Path.t()) :: :ok | {:error, posix | :badarg}
+  def rename(source, destination) do
     source = IO.chardata_to_string(source)
     destination = IO.chardata_to_string(destination)
+    :file.rename(source, destination)
+  end
+
+  @doc """
+  The same as `rename/2` but raises a `File.RenameError` exception if it fails.
+  Returns `:ok` otherwise.
+
+  ## Examples
+
+      File.rename!("samples", "tmp")
+      #=> :ok
+
+      File.rename!("non_existing.txt", "existing.txt")
+      ** (File.RenameError) could not rename from "non_existing.txt" to "existing.txt": no such file or directory
+  """
+  @doc since: "1.9.0"
+  @spec rename!(Path.t(), Path.t()) :: :ok
+  def rename!(source, destination) do
+    case rename(source, destination) do
+      :ok ->
+        :ok
+
+      {:error, reason} ->
+        raise File.RenameError,
+          reason: reason,
+          action: "rename",
+          source: IO.chardata_to_string(source),
+          destination: IO.chardata_to_string(destination)
+    end
+  end
 
-    case do_cp_file(source, destination, callback, []) do
+  @doc ~S"""
+  Copies the contents of `source_file` to `destination_file` preserving its modes.
+
+  `source_file` must be a file or a symbolic link to one. `destination_file` must
+  be a path to a non-existent file. If either is a directory, `{:error, :eisdir}`
+  will be returned.
+
+  The function returns `:ok` in case of success. Otherwise, it returns
+  `{:error, reason}`.
+
+  If you want to copy contents from an IO device to another device
+  or do a straight copy from a source to a destination without
+  preserving modes, check `copy/3` instead.
+
+  Note: The command `cp` in Unix-like systems behaves differently depending on
+  whether the destination is an existing directory or not. We have chosen to
+  explicitly disallow copying to a destination which is a directory,
+  and an error will be returned if tried.
+
+  ## Options
+
+    * `:on_conflict` - (since v1.14.0) Invoked when a file already exists in the destination.
+      The function receives arguments for `source_file` and `destination_file`. It should
+      return `true` if the existing file should be overwritten, `false` if otherwise.
+      The default callback returns `true`. On earlier versions, this callback could be
+      given as third argument, but such behavior is now deprecated.
+
+  ## Examples
+
+      File.cp("hello.txt", "hello_copy.txt")
+      #=> :ok
+
+      File.cp("hello.txt", "hello_copy.txt", on_conflict: fn source, destination ->
+        IO.gets("Overwriting #{destination} by #{source}. Type y to confirm. ") == "y\n"
+      end)
+      #=> :ok
+
+      File.cp("non_existing.txt", "copy.txt")
+      #=> {:error, :enoent}
+  """
+  @spec cp(Path.t(), Path.t(), on_conflict: on_conflict_callback) ::
+          :ok | {:error, posix | :badarg | :terminated}
+  def cp(source_file, destination_file, options \\ [])
+
+  # TODO: Deprecate me on Elixir v1.19
+  def cp(source_file, destination_file, callback) when is_function(callback, 2) do
+    IO.warn_once(
+      {__MODULE__, :cp},
+      fn ->
+        "passing a callback to File.cp/3 is deprecated, pass it as a on_conflict: callback option instead"
+      end,
+      3
+    )
+
+    cp(source_file, destination_file, on_conflict: callback)
+  end
+
+  def cp(source_file, destination_file, options) when is_list(options) do
+    on_conflict = Keyword.get(options, :on_conflict, fn _, _ -> true end)
+    source_file = IO.chardata_to_string(source_file)
+    destination_file = IO.chardata_to_string(destination_file)
+
+    case do_cp_file(source_file, destination_file, on_conflict, []) do
       {:error, reason, _} -> {:error, reason}
       _ -> :ok
     end
   end
 
-  @doc """
-  The same as `cp/3`, but raises `File.CopyError` if it fails.
-  Returns the list of copied files otherwise.
+  defp path_differs?(path, path), do: false
+
+  defp path_differs?(p1, p2) do
+    Path.expand(p1) !== Path.expand(p2)
+  end
+
+  @doc ~S"""
+  The same as `cp/3`, but raises a `File.CopyError` exception if it fails.
+  Returns `:ok` otherwise.
+
+  ## Examples
+
+      File.cp!("hello.txt", "hello_copy.txt")
+      #=> :ok
+
+      File.cp!("hello.txt", "hello_copy.txt", on_conflict: fn source, destination ->
+        IO.gets("Overwriting #{destination} by #{source}. Type y to confirm. ") == "y\n"
+      end)
+      #=> :ok
+
+      File.cp!("non_existing.txt", "copy.txt")
+      ** (File.CopyError) could not copy from "non_existing.txt" to "copy.txt": no such file or directory
   """
-  @spec cp!(Path.t, Path.t, (Path.t, Path.t -> boolean)) :: :ok | no_return
-  def cp!(source, destination, callback \\ fn(_, _) -> true end) do
-    source = IO.chardata_to_string(source)
-    destination = IO.chardata_to_string(destination)
+  @spec cp!(Path.t(), Path.t(), on_conflict: on_conflict_callback) :: :ok
+  def cp!(source_file, destination_file, options \\ []) do
+    case cp(source_file, destination_file, options) do
+      :ok ->
+        :ok
 
-    case cp(source, destination, callback) do
-      :ok -> :ok
       {:error, reason} ->
-        raise File.CopyError, reason: reason, action: "copy recursively",
-          source: source, destination: destination
+        raise File.CopyError,
+          reason: reason,
+          action: "copy",
+          source: IO.chardata_to_string(source_file),
+          destination: IO.chardata_to_string(destination_file)
     end
   end
 
   @doc ~S"""
-  Copies the contents in source to destination.
+  Copies the contents in `source` to `destination` recursively, maintaining the
+  source directory structure and modes.
 
-  If the source is a file, it copies `source` to
-  `destination`. If the source is a directory, it copies
-  the contents inside source into the destination.
+  If `source` is a file or a symbolic link to it, `destination` must be a path
+  to an existent file, a symbolic link to one, or a path to a non-existent file.
 
-  If a file already exists in the destination,
-  it invokes a callback which should return
-  `true` if the existing file should be overwritten,
-  `false` otherwise. It defaults to return `true`.
+  If `source` is a directory, or a symbolic link to it, then `destination` must
+  be an existent `directory` or a symbolic link to one, or a path to a non-existent directory.
 
-  If a directory already exists in the destination
-  where a file is meant to be (or otherwise), this
-  function will fail.
+  If the source is a file, it copies `source` to `destination`. If the `source`
+  is a directory, it copies the contents inside source into the `destination` directory.
 
-  This function may fail while copying files,
-  in such cases, it will leave the destination
-  directory in a dirty state, where already
-  copied files won't be removed.
+  If a file already exists in the destination, it invokes the optional `on_conflict`
+  callback given as an option. See "Options" for more information.
 
-  It returns `{:ok, files_and_directories}` in case of
-  success with all files and directories copied in no
-  specific order, `{:error, reason, file}` otherwise.
+  This function may fail while copying files, in such cases, it will leave the
+  destination directory in a dirty state, where file which have already been
+  copied won't be removed.
 
-  Note: The command `cp` in Unix systems behaves differently
-  depending if `destination` is an existing directory or not.
-  We have chosen to explicitly disallow this behaviour.
+  The function returns `{:ok, files_and_directories}` in case of
+  success, `files_and_directories` lists all files and directories copied in no
+  specific order. It returns `{:error, reason, file}` otherwise.
+
+  Note: The command `cp` in Unix-like systems behaves differently depending on
+  whether `destination` is an existing directory or not. We have chosen to
+  explicitly disallow this behavior. If `source` is a `file` and `destination`
+  is a directory, `{:error, :eisdir}` will be returned.
+
+  ## Options
+
+    * `:on_conflict` - (since v1.14.0) Invoked when a file already exists in the destination.
+      The function receives arguments for `source` and `destination`. It should return
+      `true` if the existing file should be overwritten, `false` if otherwise. The default
+      callback returns `true`. On earlier versions, this callback could be given as third
+      argument, but such behavior is now deprecated.
+
+    * `:dereference_symlinks` - (since v1.14.0) By default, this function will copy symlinks
+      by creating symlinks that point to the same location. This option forces symlinks to be
+      dereferenced and have their contents copied instead when set to `true`. If the dereferenced
+      files do not exist, than the operation fails. The default is `false`.
 
   ## Examples
 
-      # Copies "a.txt" to "tmp"
-      File.cp_r "a.txt", "tmp.txt"
+      # Copies file "a.txt" to "b.txt"
+      File.cp_r("a.txt", "b.txt")
+      #=> {:ok, ["b.txt"]}
 
       # Copies all files in "samples" to "tmp"
-      File.cp_r "samples", "tmp"
+      File.cp_r("samples", "tmp")
+      #=> {:ok, ["z.txt", "y.txt", "x.txt]}
 
       # Same as before, but asks the user how to proceed in case of conflicts
-      File.cp_r "samples", "tmp", fn(source, destination) ->
-        IO.gets("Overwriting #{destination} by #{source}. Type y to confirm.") == "y"
-      end
+      File.cp_r("samples", "tmp", on_conflict: fn source, destination ->
+        IO.gets("Overwriting #{destination} by #{source}. Type y to confirm. ") == "y\n"
+      end)
+      #=> {:ok, ["z.txt", "y.txt", "x.txt]}
 
+      File.cp_r("non_existing.txt", "copy.txt")
+      #=> {:error, :enoent}
   """
-  @spec cp_r(Path.t, Path.t, (Path.t, Path.t -> boolean)) :: {:ok, [binary]} | {:error, posix, binary}
-  def cp_r(source, destination, callback \\ fn(_, _) -> true end) when is_function(callback) do
-    source = IO.chardata_to_string(source)
-    destination = IO.chardata_to_string(destination)
-
-    case do_cp_r(source, destination, callback, []) do
+  @spec cp_r(Path.t(), Path.t(),
+          on_conflict: on_conflict_callback,
+          dereference_symlinks: boolean()
+        ) ::
+          {:ok, [binary]} | {:error, posix | :badarg | :terminated, binary}
+
+  def cp_r(source, destination, options \\ [])
+
+  # TODO: Deprecate me on Elixir v1.19
+  def cp_r(source, destination, callback) when is_function(callback, 2) do
+    IO.warn_once(
+      {__MODULE__, :cp_r},
+      fn ->
+        "passing a callback to File.cp_r/3 is deprecated, pass it as a on_conflict: callback option instead"
+      end,
+      3
+    )
+
+    cp_r(source, destination, on_conflict: callback)
+  end
+
+  def cp_r(source, destination, options) when is_list(options) do
+    on_conflict = Keyword.get(options, :on_conflict, fn _, _ -> true end)
+    dereference? = Keyword.get(options, :dereference_symlinks, false)
+
+    source =
+      source
+      |> IO.chardata_to_string()
+      |> assert_no_null_byte!("File.cp_r/3")
+
+    destination =
+      destination
+      |> IO.chardata_to_string()
+      |> assert_no_null_byte!("File.cp_r/3")
+
+    case do_cp_r(source, destination, on_conflict, dereference?, []) do
       {:error, _, _} = error -> error
       res -> {:ok, res}
     end
   end
 
   @doc """
-  The same as `cp_r/3`, but raises `File.CopyError` if it fails.
+  The same as `cp_r/3`, but raises a `File.CopyError` exception if it fails.
   Returns the list of copied files otherwise.
+
+  ## Examples
+
+      File.cp_r!("a.txt", "b.txt")
+      #=> ["b.txt"]
+
+      File.cp_r!("samples", "tmp")
+      #=> ["z.txt", "y.txt", "x.txt]
+
+      File.cp_r!("non_existing.txt", "copy.txt")
+      ** (File.CopyError) could not copy recursively from "non_existing.txt" to "copy.txt". non_existing.txt: no such file or directory
   """
-  @spec cp_r!(Path.t, Path.t, (Path.t, Path.t -> boolean)) :: [binary] | no_return
-  def cp_r!(source, destination, callback \\ fn(_, _) -> true end) do
-    source = IO.chardata_to_string(source)
-    destination = IO.chardata_to_string(destination)
+  @spec cp_r!(Path.t(), Path.t(),
+          on_conflict: on_conflict_callback,
+          dereference_symlinks: boolean()
+        ) :: [binary]
+  def cp_r!(source, destination, options \\ []) do
+    case cp_r(source, destination, options) do
+      {:ok, files} ->
+        files
 
-    case cp_r(source, destination, callback) do
-      {:ok, files} -> files
       {:error, reason, file} ->
-        raise File.CopyError, reason: reason, action: "copy recursively",
-          source: source, destination: destination, on: file
+        raise File.CopyError,
+          reason: reason,
+          action: "copy recursively",
+          on: file,
+          source: IO.chardata_to_string(source),
+          destination: IO.chardata_to_string(destination)
     end
   end
 
-  # src may be a file or a directory, dest is definitely
-  # a directory. Returns nil unless an error is found.
-  defp do_cp_r(src, dest, callback, acc) when is_list(acc) do
+  defp do_cp_r(src, dest, on_conflict, dereference?, acc) when is_list(acc) do
     case :elixir_utils.read_link_type(src) do
       {:ok, :regular} ->
-        do_cp_file(src, dest, callback, acc)
+        case do_cp_file(src, dest, on_conflict, acc) do
+          # we don't have a way to make a distinction between a non-existing src
+          # or dest being a non-existing dir in the case of :enoent,
+          # but we already know that src exists here.
+          {:error, :enoent, _} -> {:error, :enoent, dest}
+          other -> other
+        end
+
       {:ok, :symlink} ->
-        case F.read_link(src) do
-          {:ok, link} -> do_cp_link(link, src, dest, callback, acc)
-          {:error, reason} -> {:error, reason, src}
+        case :file.read_link(src) do
+          {:ok, link} when dereference? ->
+            do_cp_r(Path.expand(link, Path.dirname(src)), dest, on_conflict, dereference?, acc)
+
+          {:ok, link} ->
+            do_cp_link(link, src, dest, on_conflict, acc)
+
+          {:error, reason} ->
+            {:error, reason, src}
         end
+
       {:ok, :directory} ->
-        case F.list_dir(src) do
+        case :file.list_dir(src) do
           {:ok, files} ->
             case mkdir(dest) do
               success when success in [:ok, {:error, :eexist}] ->
-                Enum.reduce(files, [dest|acc], fn(x, acc) ->
-                  do_cp_r(Path.join(src, x), Path.join(dest, x), callback, acc)
+                Enum.reduce(files, [dest | acc], fn x, acc ->
+                  do_cp_r(Path.join(src, x), Path.join(dest, x), on_conflict, dereference?, acc)
                 end)
-              {:error, reason} -> {:error, reason, dest}
+
+              {:error, reason} ->
+                {:error, reason, dest}
             end
-          {:error, reason} -> {:error, reason, src}
+
+          {:error, reason} ->
+            {:error, reason, src}
         end
-      {:ok, _} -> {:error, :eio, src}
-      {:error, reason} -> {:error, reason, src}
+
+      {:ok, _} ->
+        {:error, :eio, src}
+
+      {:error, reason} ->
+        {:error, reason, src}
     end
   end
 
-  # If we reach this clause, there was an error while
-  # processing a file.
-  defp do_cp_r(_, _, _, acc) do
+  # If we reach this clause, there was an error while processing a file.
+  defp do_cp_r(_, _, _, _, acc) do
     acc
   end
 
-  defp copy_file_mode!(src, dest) do
-    write_stat!(dest, %{stat!(dest) | mode: stat!(src).mode})
+  defp copy_file_mode(src, dest) do
+    with {:ok, dest_fileinfo} <- stat(dest),
+         {:ok, src_fileinfo} <- stat(src) do
+      write_stat(dest, %{dest_fileinfo | mode: src_fileinfo.mode})
+    end
   end
 
   # Both src and dest are files.
-  defp do_cp_file(src, dest, callback, acc) do
-    case F.copy(src, {dest, [:exclusive]}) do
+  defp do_cp_file(src, dest, on_conflict, acc) do
+    case :file.copy(src, {dest, [:exclusive]}) do
       {:ok, _} ->
-        copy_file_mode!(src, dest)
-        [dest|acc]
+        case copy_file_mode(src, dest) do
+          :ok ->
+            [dest | acc]
+
+          {:error, reason} ->
+            {:error, reason, src}
+        end
+
       {:error, :eexist} ->
-        if callback.(src, dest) do
-          rm(dest)
+        if path_differs?(src, dest) and on_conflict.(src, dest) do
           case copy(src, dest) do
             {:ok, _} ->
-              copy_file_mode!(src, dest)
-              [dest|acc]
-            {:error, reason} -> {:error, reason, src}
+              case copy_file_mode(src, dest) do
+                :ok ->
+                  [dest | acc]
+
+                {:error, reason} ->
+                  {:error, reason, src}
+              end
+
+            {:error, reason} ->
+              {:error, reason, src}
           end
         else
           acc
         end
-      {:error, reason} -> {:error, reason, src}
+
+      {:error, reason} ->
+        {:error, reason, src}
     end
   end
 
   # Both src and dest are files.
-  defp do_cp_link(link, src, dest, callback, acc) do
-    case F.make_symlink(link, dest) do
+  defp do_cp_link(link, src, dest, on_conflict, acc) do
+    case :file.make_symlink(link, dest) do
       :ok ->
-        [dest|acc]
+        [dest | acc]
+
       {:error, :eexist} ->
-        if callback.(src, dest) do
-          rm(dest)
-          case F.make_symlink(link, dest) do
-            :ok -> [dest|acc]
+        if path_differs?(src, dest) and on_conflict.(src, dest) do
+          # If rm/1 fails, :file.make_symlink/2 will fail
+          _ = rm(dest)
+
+          case :file.make_symlink(link, dest) do
+            :ok -> [dest | acc]
             {:error, reason} -> {:error, reason, src}
           end
         else
           acc
         end
-      {:error, reason} -> {:error, reason, src}
+
+      {:error, reason} ->
+        {:error, reason, src}
     end
   end
 
@@ -588,39 +1348,66 @@ defmodule File do
   contents are overwritten. Returns `:ok` if successful, or `{:error, reason}`
   if an error occurs.
 
+  `content` must be `iodata` (a list of bytes or a binary). Setting the
+  encoding for this function has no effect.
+
   **Warning:** Every time this function is invoked, a file descriptor is opened
   and a new process is spawned to write to the file. For this reason, if you are
   doing multiple writes in a loop, opening the file via `File.open/2` and using
   the functions in `IO` to write to the file will yield much better performance
-  then calling this function multiple times.
+  than calling this function multiple times.
 
   Typical error reasons are:
 
     * `:enoent`  - a component of the file name does not exist
     * `:enotdir` - a component of the file name is not a directory;
-                   on some platforms, enoent is returned instead
-    * `:enospc`  - there is a no space left on the device
+      on some platforms, `:enoent` is returned instead
+    * `:enospc`  - there is no space left on the device
     * `:eacces`  - missing permission for writing the file or searching one of
-                   the parent directories
+      the parent directories
     * `:eisdir`  - the named file is a directory
 
-  Check `File.open/2` for other available options.
+  Check `File.open/2` for the list of available `modes`.
+
+  ## Examples
+
+      File.write("hello.txt", "world!")
+      #=> :ok
+
+      File.write("temp", "world!")
+      #=> {:error, :eisdir}
+
   """
-  @spec write(Path.t, iodata, list) :: :ok | {:error, posix}
+  @spec write(Path.t(), iodata, [mode]) ::
+          :ok | {:error, posix | :badarg | :terminated | :system_limit}
   def write(path, content, modes \\ []) do
-    F.write_file(IO.chardata_to_string(path), content, modes)
+    modes = normalize_modes(modes, false)
+    :file.write_file(IO.chardata_to_string(path), content, modes)
   end
 
   @doc """
-  Same as `write/3` but raises an exception if it fails, returns `:ok` otherwise.
+  Same as `write/3` but raises a `File.Error` exception if it fails.
+  Returns `:ok` otherwise.
+
+  ## Examples
+
+      File.write!("hello.txt", "world!")
+      #=> :ok
+
+      File.write!("temp", "world!")
+      ** (File.Error) could not write to file "temp": illegal operation on a directory
   """
-  @spec write!(Path.t, iodata, list) :: :ok | no_return
+  @spec write!(Path.t(), iodata, [mode]) :: :ok
   def write!(path, content, modes \\ []) do
-    path = IO.chardata_to_string(path)
-    case F.write_file(path, content, modes) do
-      :ok -> :ok
+    case write(path, content, modes) do
+      :ok ->
+        :ok
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "write to file", path: path
+        raise File.Error,
+          reason: reason,
+          action: "write to file",
+          path: IO.chardata_to_string(path)
     end
   end
 
@@ -628,6 +1415,7 @@ defmodule File do
   Tries to delete the file `path`.
 
   Returns `:ok` if successful, or `{:error, reason}` if an error occurs.
+
   Note the file is deleted even if in read-only mode.
 
   Typical error reasons are:
@@ -636,89 +1424,128 @@ defmodule File do
     * `:eacces`  - missing permission for the file or one of its parents
     * `:eperm`   - the file is a directory and user is not super-user
     * `:enotdir` - a component of the file name is not a directory;
-                   on some platforms, enoent is returned instead
+      on some platforms, `:enoent` is returned instead
     * `:einval`  - filename had an improper type, such as tuple
 
   ## Examples
 
-      File.rm('file.txt')
+      File.rm("file.txt")
       #=> :ok
 
-      File.rm('tmp_dir/')
+      File.rm("tmp_dir/")
       #=> {:error, :eperm}
-
   """
-  @spec rm(Path.t) :: :ok | {:error, posix}
+  @spec rm(Path.t()) :: :ok | {:error, posix | :badarg}
   def rm(path) do
     path = IO.chardata_to_string(path)
-    case F.delete(path) do
+
+    case :file.delete(path) do
       :ok ->
         :ok
+
       {:error, :eacces} = e ->
         change_mode_windows(path) || e
+
       {:error, _} = e ->
         e
     end
   end
 
   defp change_mode_windows(path) do
-    if match? {:win32, _}, :os.type do
-      case F.read_file_info(IO.chardata_to_string(path)) do
+    if match?({:win32, _}, :os.type()) do
+      case :file.read_file_info(path) do
         {:ok, file_info} when elem(file_info, 3) in [:read, :none] ->
-          File.chmod(path, (elem(file_info, 7) + 0200))
-          F.delete(path)
+          change_mode_windows(path, file_info)
+
         _ ->
           nil
       end
     end
   end
 
+  defp change_mode_windows(path, file_info) do
+    case chmod(path, elem(file_info, 7) + 0o200) do
+      :ok -> :file.delete(path)
+      {:error, _reason} = error -> error
+    end
+  end
+
   @doc """
-  Same as `rm/1`, but raises an exception in case of failure. Otherwise `:ok`.
+  Same as `rm/1`, but raises a `File.Error` exception in case of failure.
+  Otherwise `:ok`.
+
+  ## Examples
+
+      File.rm!("file.txt")
+      #=> :ok
+
+      File.rm!("non_existing/")
+      ** (File.Error) could not remove file "non_existing/": no such file or directory
   """
-  @spec rm!(Path.t) :: :ok | no_return
+  @spec rm!(Path.t()) :: :ok
   def rm!(path) do
-    path = IO.chardata_to_string(path)
     case rm(path) do
-      :ok -> :ok
+      :ok ->
+        :ok
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "remove file", path: path
+        raise File.Error, reason: reason, action: "remove file", path: IO.chardata_to_string(path)
     end
   end
 
   @doc """
   Tries to delete the dir at `path`.
+
   Returns `:ok` if successful, or `{:error, reason}` if an error occurs.
+  It returns `{:error, :eexist}` if the directory is not empty.
 
   ## Examples
 
-      File.rmdir('tmp_dir')
+      File.rmdir("tmp_dir")
       #=> :ok
 
-      File.rmdir('file.txt')
-      #=> {:error, :enotdir}
+      File.rmdir("non_empty_dir")
+      #=> {:error, :eexist}
 
+      File.rmdir("file.txt")
+      #=> {:error, :enotdir}
   """
-  @spec rmdir(Path.t) :: :ok | {:error, posix}
+  @spec rmdir(Path.t()) :: :ok | {:error, posix | :badarg}
   def rmdir(path) do
-    F.del_dir(IO.chardata_to_string(path))
+    :file.del_dir(IO.chardata_to_string(path))
   end
 
   @doc """
-  Same as `rmdir/1`, but raises an exception in case of failure. Otherwise `:ok`.
+  Same as `rmdir/1`, but raises a `File.Error` exception in case of failure.
+  Otherwise `:ok`.
+
+  ## Examples
+
+      File.rmdir!("tmp_dir")
+      #=> :ok
+
+      File.rmdir!("non_empty_dir")
+      ** (File.Error) could not remove directory "non_empty_dir": directory is not empty
+
+      File.rmdir!("file.txt")
+      ** (File.Error) could not remove directory "file.txt": not a directory
   """
-  @spec rmdir!(Path.t) :: :ok | {:error, posix}
+  @spec rmdir!(Path.t()) :: :ok
   def rmdir!(path) do
-    path = IO.chardata_to_string(path)
     case rmdir(path) do
-      :ok -> :ok
+      :ok ->
+        :ok
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "remove directory", path: path
+        raise File.Error,
+          reason: reason,
+          action: "remove directory",
+          path: IO.chardata_to_string(path)
     end
   end
 
   @doc """
-  Remove files and directories recursively at the given `path`.
+  Removes files and directories recursively at the given `path`.
   Symlinks are not followed but simply removed, non-existing
   files are simply ignored (i.e. doesn't make this function fail).
 
@@ -728,117 +1555,156 @@ defmodule File do
 
   ## Examples
 
-      File.rm_rf "samples"
+      File.rm_rf("samples")
       #=> {:ok, ["samples", "samples/1.txt"]}
 
-      File.rm_rf "unknown"
+      File.rm_rf("unknown")
       #=> {:ok, []}
 
+      File.rm_rf("/tmp")
+      #=> {:error, :eperm, "/tmp"}
   """
-  @spec rm_rf(Path.t) :: {:ok, [binary]} | {:error, posix, binary}
+  @spec rm_rf(Path.t()) :: {:ok, [binary]} | {:error, posix | :badarg, binary}
   def rm_rf(path) do
-    do_rm_rf(IO.chardata_to_string(path), {:ok, []})
+    {major, _} = :os.type()
+
+    path
+    |> IO.chardata_to_string()
+    |> assert_no_null_byte!("File.rm_rf/1")
+    |> do_rm_rf([], major)
   end
 
-  defp do_rm_rf(path, {:ok, _} = entry) do
-    case safe_list_dir(path) do
+  defp do_rm_rf(path, acc, major) do
+    case safe_list_dir(path, major) do
       {:ok, files} when is_list(files) ->
-        res =
-          Enum.reduce files, entry, fn(file, tuple) ->
-            do_rm_rf(Path.join(path, file), tuple)
-          end
-
-        case res do
-          {:ok, acc} ->
-            case rmdir(path) do
-              :ok -> {:ok, [path|acc]}
-              {:error, :enoent} -> res
-              {:error, reason} -> {:error, reason, path}
+        acc =
+          Enum.reduce(files, acc, fn file, acc ->
+            # In case we can't delete, continue anyway, we might succeed
+            # to delete it on Windows due to how they handle symlinks.
+            case do_rm_rf(Path.join(path, file), acc, major) do
+              {:ok, acc} -> acc
+              {:error, _, _} -> acc
             end
-          reason ->
-            reason
+          end)
+
+        case rmdir(path) do
+          :ok -> {:ok, [path | acc]}
+          {:error, :enoent} -> {:ok, acc}
+          {:error, reason} -> {:error, reason, path}
         end
-      {:ok, :directory} -> do_rm_directory(path, entry)
-      {:ok, :regular} -> do_rm_regular(path, entry)
-      {:error, reason} when reason in [:enoent, :enotdir] -> entry
-      {:error, reason} -> {:error, reason, path}
-    end
-  end
 
-  defp do_rm_rf(_, reason) do
-    reason
+      {:ok, :directory} ->
+        do_rm_directory(path, acc)
+
+      {:ok, :regular} ->
+        do_rm_regular(path, acc)
+
+      {:error, reason} when reason in [:enoent, :enotdir] ->
+        {:ok, acc}
+
+      {:error, reason} ->
+        {:error, reason, path}
+    end
   end
 
-  defp do_rm_regular(path, {:ok, acc} = entry) do
+  defp do_rm_regular(path, acc) do
     case rm(path) do
-      :ok -> {:ok, [path|acc]}
-      {:error, :enoent} -> entry
+      :ok -> {:ok, [path | acc]}
+      {:error, :enoent} -> {:ok, acc}
       {:error, reason} -> {:error, reason, path}
     end
   end
 
-  # On windows, symlinks are treated as directory and must be removed
-  # with rmdir/1. But on Unix, we remove them via rm/1. So we first try
-  # to remove it as a directory and, if we get :enotdir, we fallback to
-  # a file removal.
-  defp do_rm_directory(path, {:ok, acc} = entry) do
+  # On Windows, symlinks are treated as directory and must be removed
+  # with rmdir/1. But on Unix-like systems, we remove them via rm/1.
+  # So we first try to remove it as a directory and, if we get :enotdir,
+  # we fall back to a file removal.
+  defp do_rm_directory(path, acc) do
     case rmdir(path) do
-      :ok -> {:ok, [path|acc]}
-      {:error, :enotdir} -> do_rm_regular(path, entry)
-      {:error, :enoent} -> entry
+      :ok -> {:ok, [path | acc]}
+      {:error, :enotdir} -> do_rm_regular(path, acc)
+      {:error, :enoent} -> {:ok, acc}
       {:error, reason} -> {:error, reason, path}
     end
   end
 
-  defp safe_list_dir(path) do
+  defp safe_list_dir(path, major) do
     case :elixir_utils.read_link_type(path) do
-      {:ok, :symlink} ->
+      {:ok, :directory} ->
+        # If we cannot read the files, try to delete it anyway
+        case :file.list_dir_all(path) do
+          {:ok, files} -> {:ok, files}
+          {:error, _} -> {:ok, :directory}
+        end
+
+      {:ok, :symlink} when major == :win32 ->
         case :elixir_utils.read_file_type(path) do
           {:ok, :directory} -> {:ok, :directory}
           _ -> {:ok, :regular}
         end
-      {:ok, :directory} ->
-        F.list_dir(path)
+
       {:ok, _} ->
         {:ok, :regular}
+
+      {:error, :eio} when major == :win32 ->
+        # unix domain socket returns `{:error, :eio}`
+        # on other platforms the result is `{:ok, :regular}`
+        {:ok, :regular}
+
       {:error, reason} ->
         {:error, reason}
     end
   end
 
   @doc """
-  Same as `rm_rf/1` but raises `File.Error` in case of failures,
-  otherwise the list of files or directories removed.
+  Same as `rm_rf/1` but raises a `File.Error` exception in case of failures,
+  otherwise returns the list of files or directories removed.
+
+  ## Examples
+
+      File.rm_rf!("samples")
+      #=> ["samples", "samples/1.txt"]
+
+      File.rm_rf!("unknown")
+      #=> []
+
+      File.rm_rf!("/tmp")
+      ** (File.Error) could not remove files and directories recursively from "/tmp": not owner
   """
-  @spec rm_rf!(Path.t) :: [binary] | no_return
+  @spec rm_rf!(Path.t()) :: [binary]
   def rm_rf!(path) do
-    path = IO.chardata_to_string(path)
     case rm_rf(path) do
-      {:ok, files} -> files
+      {:ok, files} ->
+        files
+
       {:error, reason, _} ->
-        raise File.Error, reason: reason, path: path,
+        raise File.Error,
+          reason: reason,
+          path: IO.chardata_to_string(path),
           action: "remove files and directories recursively from"
     end
   end
 
   @doc ~S"""
-  Opens the given `path` according to the given list of modes.
+  Opens the given `path`.
 
-  In order to write and read files, one must use the functions
-  in the `IO` module. By default, a file is opened in binary mode
-  which requires the functions `IO.binread/2` and `IO.binwrite/2`
-  to interact with the file. A developer may pass `:utf8` as an
-  option when opening the file and then all other functions from
-  `IO` are available, since they work directly with Unicode data.
+  `modes_or_function` can either be a list of modes or a function. If it's a
+  list, it's considered to be a list of modes (that are documented below). If
+  it's a function, then it's equivalent to calling `open(path, [],
+  modes_or_function)`. See the documentation for `open/3` for more information
+  on this function.
 
   The allowed modes:
 
+    * `:binary` - opens the file in binary mode, disabling special handling of
+      Unicode sequences (default mode).
+
     * `:read` - the file, which must exist, is opened for reading.
 
     * `:write` - the file is opened for writing. It is created if it does not
       exist.
 
-      If the file does exists, and if write is not combined with read, the file
+      If the file does exist, and if write is not combined with read, the file
       will be truncated.
 
     * `:append` - the file will be opened for writing, and it will be created
@@ -848,8 +1714,8 @@ defmodule File do
     * `:exclusive` - the file, when opened for writing, is created if it does
       not exist. If the file exists, open will return `{:error, :eexist}`.
 
-    * `:char_list` - when this term is given, read operations on the file will
-      return char lists rather than binaries.
+    * `:charlist` - when this term is given, read operations on the file will
+      return charlists rather than binaries.
 
     * `:compressed` - makes it possible to read or write gzip compressed files.
 
@@ -859,29 +1725,46 @@ defmodule File do
 
     * `:utf8` - this option denotes how data is actually stored in the disk
       file and makes the file perform automatic translation of characters to
-      and from utf-8.
+      and from UTF-8.
 
       If data is sent to a file in a format that cannot be converted to the
-      utf-8 or if data is read by a function that returns data in a format that
+      UTF-8 or if data is read by a function that returns data in a format that
       cannot cope with the character range of the data, an error occurs and the
       file will be closed.
 
-  Check http://www.erlang.org/doc/man/file.html#open-2 for more information about
-  other options like `:read_ahead` and `:delayed_write`.
+    * `:delayed_write`, `:raw`, `:ram`, `:read_ahead`, `:sync`, `{:encoding, ...}`,
+      `{:read_ahead, pos_integer}`, `{:delayed_write, non_neg_integer, non_neg_integer}` -
+      for more information about these options see `:file.open/2`.
 
   This function returns:
 
-    * `{:ok, io_device}` - the file has been opened in the requested mode.
+    * `{:ok, io_device | file_descriptor}` - the file has been opened in
+      the requested mode. We explore the differences between these two results
+      in the following section
+
+    * `{:error, reason}` - the file could not be opened due to `reason`.
+
+  ## IO devices
+
+  By default, this function returns an IO device. An `io_device` is
+  a process which handles the file and you can interact with it using
+  the functions in the `IO` module. By default, a file is opened in
+  `:binary` mode, which requires the functions `IO.binread/2` and
+  `IO.binwrite/2` to interact with the file. A developer may pass `:utf8`
+  as a mode when opening the file and then all other functions from
+  `IO` are available, since they work directly with Unicode data.
 
-      `io_device` is actually the pid of the process which handles the file.
-      This process is linked to the process which originally opened the file.
-      If any process to which the `io_device` is linked terminates, the file
-      will be closed and the process itself will be terminated.
+  Given the IO device is a file, if the owner process terminates,
+  the file is closed and the process itself terminates too. If any
+  process to which the `io_device` is linked terminates, the file
+  will be closed and the process itself will be terminated.
 
-      An `io_device` returned from this call can be used as an argument to the
-      `IO` module functions.
+  ## File descriptors
 
-    * `{:error, reason}` - the file could not be opened.
+  When the `:raw` or `:ram` modes are given, this function returns
+  a low-level file descriptors. This avoids creating a process but
+  requires using the functions in the [`:file`](`:file`) module to
+  interact with it.
 
   ## Examples
 
@@ -890,25 +1773,29 @@ defmodule File do
       File.close(file)
 
   """
-  @spec open(Path.t, list) :: {:ok, io_device} | {:error, posix}
-  def open(path, modes \\ [])
+  @spec open(Path.t(), [mode | :ram]) ::
+          {:ok, io_device | file_descriptor} | {:error, posix | :badarg | :system_limit}
+  @spec open(Path.t(), (io_device | file_descriptor -> res)) ::
+          {:ok, res} | {:error, posix | :badarg | :system_limit}
+        when res: var
+  def open(path, modes_or_function \\ [])
 
   def open(path, modes) when is_list(modes) do
-    F.open(IO.chardata_to_string(path), open_defaults(modes, true))
+    :file.open(IO.chardata_to_string(path), normalize_modes(modes, true))
   end
 
-  def open(path, function) when is_function(function) do
+  def open(path, function) when is_function(function, 1) do
     open(path, [], function)
   end
 
   @doc """
-  Similar to `open/2` but expects a function as last argument.
+  Similar to `open/2` but expects a function as its last argument.
 
-  The file is opened, given to the function as argument and
+  The file is opened, given to the function as an argument and
   automatically closed after the function returns, regardless
   if there was an error when executing the function.
 
-  It returns `{:ok, function_result}` in case of success,
+  Returns `{:ok, function_result}` in case of success,
   `{:error, reason}` otherwise.
 
   This function expects the file to be closed with success,
@@ -916,119 +1803,212 @@ defmodule File do
   is given. For this reason, we do not recommend passing
   `:delayed_write` to this function.
 
+  See `open/2` for the list of available `modes`.
+
   ## Examples
 
-      File.open("file.txt", [:read, :write], fn(file) ->
+      File.open("file.txt", [:read, :write], fn file ->
         IO.read(file, :line)
       end)
-
+      #=> {:ok, "file content"}
   """
-  @spec open(Path.t, list, (io_device -> res)) :: {:ok, res} | {:error, posix} when res: var
-  def open(path, modes, function) do
+  @spec open(Path.t(), [mode | :ram], (io_device | file_descriptor -> res)) ::
+          {:ok, res} | {:error, posix | :badarg | :system_limit}
+        when res: var
+  def open(path, modes, function) when is_list(modes) and is_function(function, 1) do
     case open(path, modes) do
-      {:ok, device} ->
+      {:ok, io_device} ->
         try do
-          {:ok, function.(device)}
+          {:ok, function.(io_device)}
         after
-          :ok = close(device)
+          :ok = close(io_device)
         end
-      other -> other
+
+      other ->
+        other
     end
   end
 
   @doc """
-  Same as `open/2` but raises an error if file could not be opened.
+  Similar to `open/2` but raises a `File.Error` exception if the file
+  could not be opened. Returns the IO device otherwise.
+
+  See `open/2` for the list of available modes.
+
+  ## Examples
 
-  Returns the `io_device` otherwise.
+      File.open!("file.txt", fn file ->
+        IO.read(file, :line)
+      end)
+      #=> "file content"
   """
-  @spec open!(Path.t, list) :: io_device | no_return
-  def open!(path, modes \\ []) do
-    path = IO.chardata_to_string(path)
-    case open(path, modes) do
-      {:ok, device}    -> device
+  @spec open!(Path.t(), [mode | :ram]) :: io_device | file_descriptor
+  @spec open!(Path.t(), (io_device | file_descriptor -> res)) :: res when res: var
+  def open!(path, modes_or_function \\ []) do
+    case open(path, modes_or_function) do
+      {:ok, io_device_or_function_result} ->
+        io_device_or_function_result
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "open", path: path
+        raise File.Error, reason: reason, action: "open", path: IO.chardata_to_string(path)
     end
   end
 
   @doc """
-  Same as `open/3` but raises an error if file could not be opened.
+  Similar to `open/3` but raises a `File.Error` exception if the file
+  could not be opened.
+
+  If it succeeds opening the file, it returns the `function` result on the IO device.
+
+  See `open/2` for the list of available `modes`.
 
-  Returns the function result otherwise.
+  ## Examples
+
+      File.open!("file.txt", [:read, :write], fn file ->
+        IO.read(file, :line)
+      end)
+      #=> "file content"
   """
-  @spec open!(Path.t, list, (io_device -> res)) :: res | no_return when res: var
+  @spec open!(Path.t(), [mode | :ram], (io_device | file_descriptor -> res)) :: res when res: var
   def open!(path, modes, function) do
-    path = IO.chardata_to_string(path)
     case open(path, modes, function) do
-      {:ok, device}    -> device
+      {:ok, function_result} ->
+        function_result
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "open", path: path
+        raise File.Error, reason: reason, action: "open", path: IO.chardata_to_string(path)
     end
   end
 
   @doc """
   Gets the current working directory.
 
-  In rare circumstances, this function can fail on Unix. It may happen
-  if read permission does not exist for the parent directories of the
+  In rare circumstances, this function can fail on Unix-like systems. It may happen
+  if read permissions do not exist for the parent directories of the
   current directory. For this reason, returns `{:ok, cwd}` in case
   of success, `{:error, reason}` otherwise.
+
+  ## Examples
+
+      File.cwd()
+      #=> {:ok, "/Users/user/elixir/elixir_lang"}
+
+      # Missing read permission for one of the parents of the current directory
+      File.cwd()
+      #=> {:error, :eacces}
   """
-  @spec cwd() :: {:ok, binary} | {:error, posix}
+  @spec cwd() :: {:ok, binary} | {:error, posix | :badarg}
   def cwd() do
-    case F.get_cwd do
-      {:ok, base} -> {:ok, IO.chardata_to_string(base)}
+    case :file.get_cwd() do
+      {:ok, base} -> {:ok, IO.chardata_to_string(fix_drive_letter(base))}
       {:error, _} = error -> error
     end
   end
 
+  defp fix_drive_letter([l, ?:, ?/ | rest] = original) when l in ?A..?Z do
+    case :os.type() do
+      {:win32, _} -> [l + ?a - ?A, ?:, ?/ | rest]
+      _ -> original
+    end
+  end
+
+  defp fix_drive_letter(original), do: original
+
   @doc """
-  The same as `cwd/0`, but raises an exception if it fails.
+  The same as `cwd/0`, but raises a `File.Error` exception if it fails.
+
+  ## Examples
+
+      File.cwd!()
+      #=> "/Users/user/elixir/elixir_lang"
   """
-  @spec cwd!() :: binary | no_return
+  @spec cwd!() :: binary
   def cwd!() do
-    case F.get_cwd do
-      {:ok, cwd} -> IO.chardata_to_string(cwd)
+    case cwd() do
+      {:ok, cwd} ->
+        cwd
+
       {:error, reason} ->
-          raise File.Error, reason: reason, action: "get current working directory"
+        raise File.Error, reason: reason, action: "get current working directory"
     end
   end
 
   @doc """
   Sets the current working directory.
 
+  The current working directory is set for the BEAM globally. This can lead to
+  race conditions if multiple processes are changing the current working
+  directory concurrently. To run an external command in a given directory
+  without changing the global current working directory, use the `:cd` option
+  of `System.cmd/3` and `Port.open/2`.
+
   Returns `:ok` if successful, `{:error, reason}` otherwise.
+
+  ## Examples
+
+      File.cd("bin")
+      #=> :ok
+
+      File.cd("non_existing_dir")
+      #=> {:error, :enoent}
   """
-  @spec cd(Path.t) :: :ok | {:error, posix}
+  @spec cd(Path.t()) :: :ok | {:error, posix | :badarg | :no_translation}
   def cd(path) do
-    F.set_cwd(IO.chardata_to_string(path))
+    :file.set_cwd(IO.chardata_to_string(path))
   end
 
   @doc """
-  The same as `cd/1`, but raises an exception if it fails.
+  The same as `cd/1`, but raises a `File.Error` exception if it fails.
+
+  ## Examples
+
+      File.cd!("bin")
+      #=> :ok
+
+      File.cd!("non_existing_dir")
+      ** (File.Error) could not set current working directory to "non_existing_dir": no such file or directory
   """
-  @spec cd!(Path.t) :: :ok | no_return
+  @spec cd!(Path.t()) :: :ok
   def cd!(path) do
-    path = IO.chardata_to_string(path)
-    case F.set_cwd(path) do
-      :ok -> :ok
+    case cd(path) do
+      :ok ->
+        :ok
+
       {:error, reason} ->
-          raise File.Error, reason: reason, action: "set current working directory to", path: path
+        raise File.Error,
+          reason: reason,
+          action: "set current working directory to",
+          path: IO.chardata_to_string(path)
     end
   end
 
   @doc """
   Changes the current directory to the given `path`,
-  executes the given function and then revert back
-  to the previous path regardless if there is an exception.
+  executes the given function and then reverts back
+  to the previous path regardless of whether there is an exception.
+
+  The current working directory is temporarily set for the BEAM globally. This
+  can lead to race conditions if multiple processes are changing the current
+  working directory concurrently. To run an external command in a given
+  directory without changing the global current working directory, use the
+  `:cd` option of `System.cmd/3` and `Port.open/2`.
 
   Raises an error if retrieving or changing the current
   directory fails.
+
+  ## Examples
+
+      File.cd!("bin", fn -> do_something() end)
+      #=> :result_of_do_something
+
+      File.cd!("non_existing_dir", fn -> do_something() end)
+      ** (File.Error) could not set current working directory to "non_existing_dir": no such file or directory
   """
-  @spec cd!(Path.t, (() -> res)) :: res | no_return when res: var
+  @spec cd!(Path.t(), (-> res)) :: res when res: var
   def cd!(path, function) do
-    old = cwd!
+    old = cwd!()
     cd!(path)
+
     try do
       function.()
     after
@@ -1037,30 +2017,54 @@ defmodule File do
   end
 
   @doc """
-  Returns list of files in the given directory.
+  Returns the list of files in the given directory.
 
-  It returns `{:ok, [files]}` in case of success,
+  Hidden files are not ignored and the results are *not* sorted.
+
+  Since directories are considered files by the file system,
+  they are also included in the returned value.
+
+  Returns `{:ok, files}` in case of success,
   `{:error, reason}` otherwise.
+
+  ## Examples
+
+      File.ls("bin")
+      #=> {:ok, ["iex", "elixir"]}
+
+      File.ls("non_existing_dir")
+      #=> {:error, :enoent}
   """
-  @spec ls(Path.t) :: {:ok, [binary]} | {:error, posix}
+  @spec ls(Path.t()) :: {:ok, [binary]} | {:error, posix | :badarg | {:no_translation, binary}}
   def ls(path \\ ".") do
-    case F.list_dir(IO.chardata_to_string(path)) do
+    case :file.list_dir(IO.chardata_to_string(path)) do
       {:ok, file_list} -> {:ok, Enum.map(file_list, &IO.chardata_to_string/1)}
       {:error, _} = error -> error
     end
   end
 
   @doc """
-  The same as `ls/1` but raises `File.Error`
-  in case of an error.
+  The same as `ls/1` but raises a `File.Error` exception in case of an error.
+
+  ## Examples
+
+      File.ls!("bin")
+      #=> ["iex", "elixir"]
+
+      File.ls!("non_existing_dir")
+      ** (File.Error) could not list directory "non_existing_dir": no such file or directory
   """
-  @spec ls!(Path.t) :: [binary] | no_return
+  @spec ls!(Path.t()) :: [binary]
   def ls!(path \\ ".") do
-    path = IO.chardata_to_string(path)
     case ls(path) do
-      {:ok, value} -> value
+      {:ok, value} ->
+        value
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "list directory", path: path
+        raise File.Error,
+          reason: reason,
+          action: "list directory",
+          path: IO.chardata_to_string(path)
     end
   end
 
@@ -1070,132 +2074,305 @@ defmodule File do
 
   Note that if the option `:delayed_write` was used when opening the file,
   `close/1` might return an old write error and not even try to close the file.
-  See `open/2`.
+  See `open/2` for more information.
+
+  ## Examples
+
+      {:ok, file} = File.open("hello.txt")
+      File.close(file)
+      #=> :ok
+
+      File.close(:not_an_io_device)
+      #=> {:error, :badarg}
   """
   @spec close(io_device) :: :ok | {:error, posix | :badarg | :terminated}
   def close(io_device) do
-    F.close(io_device)
+    :file.close(io_device)
   end
 
   @doc """
+  Shortcut for `File.stream!/3`.
+  """
+  @spec stream!(Path.t(), :line | pos_integer | [stream_mode]) :: File.Stream.t()
+  def stream!(path, line_or_bytes_modes \\ [])
+
+  def stream!(path, modes) when is_list(modes),
+    do: stream!(path, :line, modes)
+
+  def stream!(path, line_or_bytes) when is_integer(line_or_bytes) or line_or_bytes == :line,
+    do: stream!(path, line_or_bytes, [])
+
+  @doc ~S"""
   Returns a `File.Stream` for the given `path` with the given `modes`.
 
   The stream implements both `Enumerable` and `Collectable` protocols,
   which means it can be used both for read and write.
 
-  The `line_or_byte` argument configures how the file is read when
-  streaming, by `:line` (default) or by a given number of bytes.
+  The `line_or_bytes` argument configures how the file is read when
+  streaming, by `:line` (default) or by a given number of bytes. When
+  using the `:line` option, CRLF line breaks (`"\r\n"`) are normalized
+  to LF (`"\n"`).
+
+  Similar to other file operations, a stream can be created in one node
+  and forwarded to another node. Once the stream is opened in another node,
+  a request will be sent to the creator node to spawn a process for file
+  streaming.
 
   Operating the stream can fail on open for the same reasons as
-  `File.open!/2`. Note that the file is automatically opened only and
-  every time streaming begins. There is no need to pass `:read` and
-  `:write` modes, as those are automatically set by Elixir.
+  `File.open!/2`. Note that the file is automatically opened each time streaming
+  begins. There is no need to pass `:read` and `:write` modes, as those are
+  automatically set by Elixir.
 
   ## Raw files
 
   Since Elixir controls when the streamed file is opened, the underlying
   device cannot be shared and as such it is convenient to open the file
   in raw mode for performance reasons. Therefore, Elixir **will** open
-  streams in `:raw` mode with the `:read_ahead` option unless an encoding
-  is specified.
+  streams in `:raw` mode with the `:read_ahead` option if the stream is
+  open in the same node as it is created and no encoding has been specified.
+  This means any data streamed into the file must be converted to `t:iodata/0`
+  type. If you pass, for example, `[encoding: :utf8]` or
+  `[encoding: {:utf16, :little}]` in the modes parameter, the underlying stream
+  will use `IO.write/2` and the `String.Chars` protocol to convert the data.
+  See `IO.binwrite/2` and `IO.write/2` .
 
   One may also consider passing the `:delayed_write` option if the stream
   is meant to be written to under a tight loop.
+
+  ## Byte order marks and read offset
+
+  If you pass `:trim_bom` in the modes parameter, the stream will
+  trim UTF-8, UTF-16 and UTF-32 byte order marks when reading from file.
+
+  Note that this function does not try to discover the file encoding
+  based on BOM. From Elixir v1.16.0, you may also pass a `:read_offset`
+  that is skipped whenever enumerating the stream (if both `:read_offset`
+  and `:trim_bom` are given, the offset is skipped after the BOM).
+
+  See `Stream.run/1` for an example of streaming into a file.
+
+  ## Examples
+
+      # Read a utf8 text file which may include BOM
+      File.stream!("./test/test.txt", [:trim_bom, encoding: :utf8])
+      #=> %File.Stream{path: "./test/test.txt", ...}
+
+      # Read in 2048 byte chunks rather than lines
+      File.stream!("./test/test.data", 2048)
+      #=> %File.Stream{path: "./test/test.data", ...}
   """
-  def stream!(path, modes \\ [], line_or_bytes \\ :line) do
-    modes = open_defaults(modes, true)
-    File.Stream.__build__(IO.chardata_to_string(path), modes, line_or_bytes)
+  @spec stream!(Path.t(), :line | pos_integer, [stream_mode]) :: File.Stream.t()
+  def stream!(path, line_or_bytes, modes)
+
+  def stream!(path, modes, line_or_bytes) when is_list(modes) do
+    # TODO: Remove me on Elixir 2.0
+    IO.warn(
+      "File.stream!(path, modes, line_or_byte) is deprecated, " <>
+        "invoke File.stream!(path, line_or_bytes, modes) instead"
+    )
+
+    stream!(path, line_or_bytes, modes)
+  end
+
+  def stream!(path, line_or_bytes, modes) do
+    modes = normalize_modes(modes, true)
+    File.Stream.__build__(IO.chardata_to_string(path), line_or_bytes, modes)
   end
 
   @doc """
-  Changes the unix file `mode` for a given `file`.
-  Returns `:ok` on success, or `{:error, reason}`
-  on failure.
+  Changes the `mode` for a given `file`.
+
+  Returns `:ok` on success, or `{:error, reason}` on failure.
+
+  ## Permissions
+
+  File permissions are specified by adding together the following octal modes:
+
+    * `0o400` - read permission: owner
+    * `0o200` - write permission: owner
+    * `0o100` - execute permission: owner
+
+    * `0o040` - read permission: group
+    * `0o020` - write permission: group
+    * `0o010` - execute permission: group
+
+    * `0o004` - read permission: other
+    * `0o002` - write permission: other
+    * `0o001` - execute permission: other
+
+  For example, setting the mode `0o755` gives it
+  write, read and execute permission to the owner
+  and both read and execute permission to group
+  and others.
+
+  ## Examples
+
+      File.chmod("hello.txt", 0o755)
+      #=> :ok
+
+      File.chmod("non_existing.txt", 0o755)
+      #=> {:error, :enoent}
   """
-  @spec chmod(Path.t, integer) :: :ok | {:error, posix}
+  @spec chmod(Path.t(), non_neg_integer) :: :ok | {:error, posix | :badarg}
   def chmod(path, mode) do
-    F.change_mode(IO.chardata_to_string(path), mode)
+    :file.change_mode(IO.chardata_to_string(path), mode)
   end
 
   @doc """
-  Same as `chmod/2`, but raises an exception in case of failure. Otherwise `:ok`.
+  Same as `chmod/2`, but raises a `File.Error` exception in case of failure.
+  Otherwise `:ok`.
+
+  ## Examples
+
+      File.chmod!("hello.txt", 0o755)
+      #=> :ok
+
+      File.chmod!("non_existing.txt", 0o755)
+      ** (File.Error) could not change mode for "non_existing.txt": no such file or directory
   """
-  @spec chmod!(Path.t, integer) :: :ok | no_return
+  @spec chmod!(Path.t(), non_neg_integer) :: :ok
   def chmod!(path, mode) do
-    path = IO.chardata_to_string(path)
     case chmod(path, mode) do
-      :ok -> :ok
+      :ok ->
+        :ok
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "change mode for", path: path
+        raise File.Error,
+          reason: reason,
+          action: "change mode for",
+          path: IO.chardata_to_string(path)
     end
   end
 
   @doc """
-  Changes the user group given by the group id `gid`
+  Changes the group given by the group ID `gid`
   for a given `file`. Returns `:ok` on success, or
   `{:error, reason}` on failure.
+
+  ## Examples
+
+      File.chgrp("hello.txt", 10)
+      #=> :ok
+
+      File.chgrp("non_existing.txt", 10)
+      #=> {:error, :enoent}
   """
-  @spec chgrp(Path.t, integer) :: :ok | {:error, posix}
+  @spec chgrp(Path.t(), non_neg_integer) :: :ok | {:error, posix | :badarg}
   def chgrp(path, gid) do
-    F.change_group(IO.chardata_to_string(path), gid)
+    :file.change_group(IO.chardata_to_string(path), gid)
   end
 
   @doc """
-  Same as `chgrp/2`, but raises an exception in case of failure. Otherwise `:ok`.
+  Same as `chgrp/2`, but raises a `File.Error` exception in case of failure.
+  Otherwise `:ok`.
+
+  ## Examples
+
+    File.chgrp!("hello.txt", 10)
+    #=> :ok
+
+    File.chgrp!("non_existing.txt", 10)
+    ** (File.Error) could not change group for "non_existing.txt": no such file or directory
   """
-  @spec chgrp!(Path.t, integer) :: :ok | no_return
+  @spec chgrp!(Path.t(), non_neg_integer) :: :ok
   def chgrp!(path, gid) do
-    path = IO.chardata_to_string(path)
     case chgrp(path, gid) do
-      :ok -> :ok
+      :ok ->
+        :ok
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "change group for", path: path
+        raise File.Error,
+          reason: reason,
+          action: "change group for",
+          path: IO.chardata_to_string(path)
     end
   end
 
   @doc """
-  Changes the owner given by the user id `uid`
+  Changes the owner given by the user ID `uid`
   for a given `file`. Returns `:ok` on success,
   or `{:error, reason}` on failure.
+
+  ## Examples
+
+      File.chown("hello.txt", 15)
+      #=> :ok
+
+      File.chown("secret.txt", 15)
+      #=> {:error, :eperm}
   """
-  @spec chown(Path.t, integer) :: :ok | {:error, posix}
+  @spec chown(Path.t(), non_neg_integer) :: :ok | {:error, posix | :badarg}
   def chown(path, uid) do
-    F.change_owner(IO.chardata_to_string(path), uid)
+    :file.change_owner(IO.chardata_to_string(path), uid)
   end
 
   @doc """
-  Same as `chown/2`, but raises an exception in case of failure. Otherwise `:ok`.
+  Same as `chown/2`, but raises a `File.Error` exception in case of failure.
+  Otherwise `:ok`.
+
+  ## Examples
+
+      File.chown!("hello.txt", 15)
+      #=> :ok
+
+      File.chown!("secret.txt", 15)
+      ** (File.Error) could not change owner for "secret.txt": not owner
   """
-  @spec chown!(Path.t, integer) :: :ok | no_return
+  @spec chown!(Path.t(), non_neg_integer) :: :ok
   def chown!(path, uid) do
-    path = IO.chardata_to_string(path)
     case chown(path, uid) do
-      :ok -> :ok
+      :ok ->
+        :ok
+
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "change owner for", path: path
+        raise File.Error,
+          reason: reason,
+          action: "change owner for",
+          path: IO.chardata_to_string(path)
     end
   end
 
   ## Helpers
 
-  @read_ahead 64*1024
+  @read_ahead_size 64 * 1024
 
-  defp open_defaults([:char_list|t], _add_binary) do
-    open_defaults(t, false)
+  defp assert_no_null_byte!(binary, operation) do
+    case :binary.match(binary, "\0") do
+      {_, _} ->
+        raise ArgumentError,
+              "cannot execute #{operation} for path with null byte, got: #{inspect(binary)}"
+
+      :nomatch ->
+        binary
+    end
+  end
+
+  defp normalize_modes([:utf8 | rest], binary?) do
+    [encoding: :utf8] ++ normalize_modes(rest, binary?)
   end
 
-  defp open_defaults([:utf8|t], add_binary) do
-    open_defaults([{:encoding, :utf8}|t], add_binary)
+  defp normalize_modes([:read_ahead | rest], binary?) do
+    [read_ahead: @read_ahead_size] ++ normalize_modes(rest, binary?)
   end
 
-  defp open_defaults([:read_ahead|t], add_binary) do
-    open_defaults([{:read_ahead, @read_ahead}|t], add_binary)
+  # TODO: Remove :char_list mode on v2.0
+  defp normalize_modes([mode | rest], _binary?) when mode in [:charlist, :char_list] do
+    if mode == :char_list do
+      IO.warn("the :char_list mode is deprecated, use :charlist")
+    end
+
+    normalize_modes(rest, false)
   end
 
-  defp open_defaults([h|t], add_binary) do
-    [h|open_defaults(t, add_binary)]
+  defp normalize_modes([mode | rest], binary?) do
+    [mode | normalize_modes(rest, binary?)]
   end
 
-  defp open_defaults([], true),  do: [:binary]
-  defp open_defaults([], false), do: []
+  defp normalize_modes([], true), do: [:binary]
+  defp normalize_modes([], false), do: []
+
+  defp normalize_path_or_io_device(path) when is_list(path), do: IO.chardata_to_string(path)
+  defp normalize_path_or_io_device(path) when is_binary(path), do: path
+  defp normalize_path_or_io_device(io_device) when is_pid(io_device), do: io_device
+  defp normalize_path_or_io_device(io_device = {:file_descriptor, _, _}), do: io_device
 end
diff --git a/lib/elixir/lib/file/stat.ex b/lib/elixir/lib/file/stat.ex
index 5a684ff58ca..ec85fc980ec 100644
--- a/lib/elixir/lib/file/stat.ex
+++ b/lib/elixir/lib/file/stat.ex
@@ -1,18 +1,22 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 require Record
 
 defmodule File.Stat do
   @moduledoc """
-  A struct responsible to hold file information.
+  A struct that holds file information.
 
   In Erlang, this struct is represented by a `:file_info` record.
   Therefore this module also provides functions for converting
-  in between the Erlang record and the Elixir struct.
+  between the Erlang record and the Elixir struct.
 
   Its fields are:
 
     * `size` - size of file in bytes.
 
-    * `type` - `:device | :directory | :regular | :other`; the type of the
+    * `type` - `:device | :directory | :regular | :other | :symlink`; the type of the
       file.
 
     * `access` - `:read | :write | :read_write | :none`; the current system
@@ -23,7 +27,7 @@ defmodule File.Stat do
     * `mtime` - the last time the file was written.
 
     * `ctime` - the interpretation of this time field depends on the operating
-      system. On Unix, it is the last time the file or the inode was changed.
+      system. On Unix-like operating systems, it is the last time the file or the inode was changed.
       In Windows, it is the time of creation.
 
     * `mode` - the file permissions.
@@ -32,35 +36,53 @@ defmodule File.Stat do
       systems which have no concept of links.
 
     * `major_device` - identifies the file system where the file is located.
-      In windows, the number indicates a drive as follows: 0 means A:, 1 means
+      In Windows, the number indicates a drive as follows: 0 means A:, 1 means
       B:, and so on.
 
-    * `minor_device` - only valid for character devices on Unix. In all other
+    * `minor_device` - only valid for character devices on Unix-like systems. In all other
       cases, this field is zero.
 
-    * `inode` - gives the inode number. On non-Unix file systems, this field
+    * `inode` - gives the inode number. On non-Unix-like file systems, this field
       will be zero.
 
-    * `uid` - indicates the owner of the file.
+    * `uid` - indicates the owner of the file. Will be zero for non-Unix-like file
+      systems.
 
-    * `gid` - gives the group that the owner of the file belongs to. Will be
-      zero for non-Unix file systems.
+    * `gid` - indicates the group that owns the file. Will be zero for
+      non-Unix-like file systems.
 
   The time type returned in `atime`, `mtime`, and `ctime` is dependent on the
   time type set in options. `{:time, type}` where type can be `:local`,
-  `:universal`, or `:posix`. Default is `:local`.
+  `:universal`, or `:posix`. Default is `:universal`.
   """
 
   record = Record.extract(:file_info, from_lib: "kernel/include/file.hrl")
-  keys   = :lists.map(&elem(&1, 0), record)
-  vals   = :lists.map(&{&1, [], nil}, keys)
-  pairs  = :lists.zip(keys, vals)
+  keys = :lists.map(&elem(&1, 0), record)
+  vals = :lists.map(&{&1, [], nil}, keys)
+  pairs = :lists.zip(keys, vals)
 
   defstruct keys
 
+  @type t :: %__MODULE__{
+          size: non_neg_integer() | :undefined,
+          type: :device | :directory | :regular | :other | :symlink | :undefined,
+          access: :read | :write | :read_write | :none | :undefined,
+          atime: :calendar.datetime() | integer() | :undefined,
+          mtime: :calendar.datetime() | integer() | :undefined,
+          ctime: :calendar.datetime() | integer() | :undefined,
+          mode: non_neg_integer() | :undefined,
+          links: non_neg_integer() | :undefined,
+          major_device: non_neg_integer() | :undefined,
+          minor_device: non_neg_integer() | :undefined,
+          inode: non_neg_integer() | :undefined,
+          uid: non_neg_integer() | :undefined,
+          gid: non_neg_integer() | :undefined
+        }
+
   @doc """
   Converts a `File.Stat` struct to a `:file_info` record.
   """
+  @spec to_record(t()) :: :file.file_info()
   def to_record(%File.Stat{unquote_splicing(pairs)}) do
     {:file_info, unquote_splicing(vals)}
   end
@@ -68,6 +90,9 @@ defmodule File.Stat do
   @doc """
   Converts a `:file_info` record into a `File.Stat`.
   """
+  @spec from_record(:file.file_info()) :: t()
+  def from_record(file_info)
+
   def from_record({:file_info, unquote_splicing(vals)}) do
     %File.Stat{unquote_splicing(pairs)}
   end
diff --git a/lib/elixir/lib/file/stream.ex b/lib/elixir/lib/file/stream.ex
index 3c7ffed9190..94b2ad20b5b 100644
--- a/lib/elixir/lib/file/stream.ex
+++ b/lib/elixir/lib/file/stream.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule File.Stream do
   @moduledoc """
   Defines a `File.Stream` struct returned by `File.stream!/3`.
@@ -7,43 +11,61 @@ defmodule File.Stream do
     * `path`          - the file path
     * `modes`         - the file modes
     * `raw`           - a boolean indicating if bin functions should be used
-    * `line_or_bytes` - if reading should read lines or a given amount of bytes
+    * `line_or_bytes` - if reading should read lines or a given number of bytes
+    * `node`          - the node the file belongs to
 
   """
 
-  defstruct path: nil, modes: [], line_or_bytes: :line, raw: true
+  defstruct path: nil, modes: [], line_or_bytes: :line, raw: true, node: nil
+
+  @type t :: %__MODULE__{}
 
   @doc false
-  def __build__(path, modes, line_or_bytes) do
+  def __build__(path, line_or_bytes, modes) do
+    with {:read_offset, offset} <- :lists.keyfind(:read_offset, 1, modes),
+         false <- is_integer(offset) and offset >= 0 do
+      raise ArgumentError,
+            "expected :read_offset to be a non-negative integer, got: #{inspect(offset)}"
+    end
+
     raw = :lists.keyfind(:encoding, 1, modes) == false
 
     modes =
-      if raw do
-        if :lists.keyfind(:read_ahead, 1, modes) == {:read_ahead, false} do
-          [:raw|modes]
-        else
-          [:raw, :read_ahead|modes]
-        end
-      else
-        modes
+      case raw do
+        true ->
+          case :lists.keyfind(:read_ahead, 1, modes) do
+            {:read_ahead, false} -> [:raw | :lists.keydelete(:read_ahead, 1, modes)]
+            {:read_ahead, _} -> [:raw | modes]
+            false -> [:raw, :read_ahead | modes]
+          end
+
+        false ->
+          modes
       end
 
-    %File.Stream{path: path, modes: modes, raw: raw, line_or_bytes: line_or_bytes}
+    %File.Stream{path: path, modes: modes, raw: raw, line_or_bytes: line_or_bytes, node: node()}
   end
 
-  defimpl Collectable do
-    def empty(stream) do
-      stream
-    end
+  @doc false
+  def __open__(%File.Stream{path: path, node: node}, modes) when node == node() do
+    :file.open(path, modes)
+  end
+
+  @doc false
+  def __open__(%File.Stream{path: path, node: node}, modes) do
+    :erpc.call(node, :file_io_server, :start, [self(), path, List.delete(modes, :raw)])
+  end
 
-    def into(%{path: path, modes: modes, raw: raw} = stream) do
-      modes = for mode <- modes, not mode in [:read], do: mode
+  defimpl Collectable do
+    def into(%{modes: modes, raw: raw} = stream) do
+      modes = for mode <- modes, mode not in [:read], do: mode
 
-      case :file.open(path, [:write|modes]) do
+      case File.Stream.__open__(stream, [:write | modes]) do
         {:ok, device} ->
           {:ok, into(device, stream, raw)}
+
         {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
+          raise File.Error, reason: reason, action: "stream", path: stream.path
       end
     end
 
@@ -51,40 +73,75 @@ defmodule File.Stream do
       fn
         :ok, {:cont, x} ->
           case raw do
-            true  -> IO.binwrite(device, x)
+            true -> IO.binwrite(device, x)
             false -> IO.write(device, x)
           end
+
         :ok, :done ->
-          :file.close(device)
+          # If delayed_write option is used and the last write failed will
+          # MatchError here as {:error, _} is returned.
+          :ok = :file.close(device)
           stream
+
         :ok, :halt ->
-          :file.close(device)
+          # If delayed_write option is used and the last write failed will
+          # MatchError here as {:error, _} is returned.
+          :ok = :file.close(device)
       end
     end
   end
 
   defimpl Enumerable do
-    def reduce(%{path: path, modes: modes, line_or_bytes: line_or_bytes, raw: raw}, acc, fun) do
-      modes = for mode <- modes, not mode in [:write, :append], do: mode
-
-      start_fun =
-        fn ->
-          case :file.open(path, modes) do
-            {:ok, device}    -> device
-            {:error, reason} ->
-              raise File.Error, reason: reason, action: "stream", path: path
-          end
+    @read_ahead_size 64 * 1024
+
+    def reduce(%{modes: modes, line_or_bytes: line_or_bytes, raw: raw} = stream, acc, fun) do
+      start_fun = fn ->
+        case File.Stream.__open__(stream, read_modes(modes)) do
+          {:ok, device} ->
+            skip_bom_and_offset(device, raw, modes)
+
+          {:error, reason} ->
+            raise File.Error, reason: reason, action: "stream", path: stream.path
         end
+      end
 
       next_fun =
         case raw do
-          true  -> &IO.each_binstream(&1, line_or_bytes)
+          true -> &IO.each_binstream(&1, line_or_bytes)
           false -> &IO.each_stream(&1, line_or_bytes)
         end
 
       Stream.resource(start_fun, next_fun, &:file.close/1).(acc, fun)
     end
 
+    def count(%{modes: modes, line_or_bytes: :line, path: path, raw: raw} = stream) do
+      pattern = :binary.compile_pattern("\n")
+
+      counter = fn device ->
+        device = skip_bom_and_offset(device, raw, modes)
+        count_lines(device, path, pattern, read_function(stream), 0)
+      end
+
+      {:ok, open!(stream, modes, counter)}
+    end
+
+    def count(%{path: path, line_or_bytes: bytes, raw: true, modes: modes, node: node} = stream) do
+      case :erpc.call(node, File, :stat, [path]) do
+        {:ok, %{size: 0}} ->
+          {:error, __MODULE__}
+
+        {:ok, %{size: size}} ->
+          bom_offset = count_raw_bom(stream, modes)
+          offset = get_read_offset(modes)
+          size = max(size - bom_offset - offset, 0)
+          remainder = if rem(size, bytes) == 0, do: 0, else: 1
+          {:ok, div(size, bytes) + remainder}
+
+        {:error, reason} ->
+          raise File.Error, reason: reason, action: "stream", path: path
+      end
+    end
+
     def count(_stream) do
       {:error, __MODULE__}
     end
@@ -92,5 +149,102 @@ defmodule File.Stream do
     def member?(_stream, _term) do
       {:error, __MODULE__}
     end
+
+    def slice(_stream) do
+      {:error, __MODULE__}
+    end
+
+    defp open!(stream, modes, fun) do
+      case File.Stream.__open__(stream, read_modes(modes)) do
+        {:ok, device} ->
+          try do
+            fun.(device)
+          after
+            :file.close(device)
+          end
+
+        {:error, reason} ->
+          raise File.Error, reason: reason, action: "stream", path: stream.path
+      end
+    end
+
+    defp count_raw_bom(stream, modes) do
+      if :trim_bom in modes do
+        open!(stream, read_modes(modes), &(&1 |> trim_bom(true) |> elem(1)))
+      else
+        0
+      end
+    end
+
+    defp skip_bom_and_offset(device, raw, modes) do
+      device =
+        if :trim_bom in modes do
+          device |> trim_bom(raw) |> elem(0)
+        else
+          device
+        end
+
+      offset = get_read_offset(modes)
+
+      if offset > 0 do
+        {:ok, _} = :file.position(device, {:cur, offset})
+      end
+
+      device
+    end
+
+    defp trim_bom(device, true) do
+      bom_length = device |> IO.binread(4) |> bom_length()
+      {:ok, new_pos} = :file.position(device, bom_length)
+      {device, new_pos}
+    end
+
+    defp trim_bom(device, false) do
+      # Or we read the bom in the correct amount or it isn't there
+      case bom_length(IO.read(device, 1)) do
+        0 ->
+          {:ok, _} = :file.position(device, 0)
+          {device, 0}
+
+        _ ->
+          {device, 1}
+      end
+    end
+
+    defp bom_length(<<239, 187, 191, _rest::binary>>), do: 3
+    defp bom_length(<<254, 255, _rest::binary>>), do: 2
+    defp bom_length(<<255, 254, _rest::binary>>), do: 2
+    defp bom_length(<<0, 0, 254, 255, _rest::binary>>), do: 4
+    defp bom_length(<<254, 255, 0, 0, _rest::binary>>), do: 4
+    defp bom_length(_binary), do: 0
+
+    def get_read_offset(modes) do
+      case :lists.keyfind(:read_offset, 1, modes) do
+        {:read_offset, offset} -> offset
+        false -> 0
+      end
+    end
+
+    defp read_modes(modes) do
+      for mode <- modes, mode not in [:write, :append, :trim_bom], do: mode
+    end
+
+    defp count_lines(device, path, pattern, read, count) do
+      case read.(device) do
+        data when is_binary(data) ->
+          count_lines(device, path, pattern, read, count + count_lines(data, pattern))
+
+        :eof ->
+          count
+
+        {:error, reason} ->
+          raise File.Error, reason: reason, action: "stream", path: path
+      end
+    end
+
+    defp count_lines(data, pattern), do: length(:binary.matches(data, pattern))
+
+    defp read_function(%{raw: true}), do: &IO.binread(&1, @read_ahead_size)
+    defp read_function(%{raw: false}), do: &IO.read(&1, @read_ahead_size)
   end
 end
diff --git a/lib/elixir/lib/float.ex b/lib/elixir/lib/float.ex
index 720d043958f..6466bd0b54d 100644
--- a/lib/elixir/lib/float.ex
+++ b/lib/elixir/lib/float.ex
@@ -1,254 +1,666 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+import Kernel, except: [round: 1]
+
 defmodule Float do
   @moduledoc """
-  Functions for working with floating point numbers.
+  Functions for working with floating-point numbers.
+
+  For mathematical operations on top of floating-points,
+  see Erlang's [`:math`](`:math`) module.
+
+  ## Kernel functions
+
+  There are functions related to floating-point numbers on the `Kernel` module
+  too. Here is a list of them:
+
+    * `Kernel.round/1`: rounds a number to the nearest integer.
+    * `Kernel.trunc/1`: returns the integer part of a number.
+
+  ## Known issues
+
+  There are some very well known problems with floating-point numbers
+  and arithmetic due to the fact most decimal fractions cannot be
+  represented by a floating-point binary and most operations are not exact,
+  but operate on approximations. Those issues are not specific
+  to Elixir, they are a property of floating point representation itself.
+
+  For example, the numbers 0.1 and 0.01 are two of them, what means the result
+  of squaring 0.1 does not give 0.01 neither the closest representable. Here is
+  what happens in this case:
+
+    * The closest representable number to 0.1 is 0.1000000014
+    * The closest representable number to 0.01 is 0.0099999997
+    * Doing 0.1 * 0.1 should return 0.01, but because 0.1 is actually 0.1000000014,
+      the result is 0.010000000000000002, and because this is not the closest
+      representable number to 0.01, you'll get the wrong result for this operation
+
+  There are also other known problems like flooring or rounding numbers. See
+  `round/2` and `floor/2` for more details about them.
+
+  To learn more about floating-point arithmetic visit:
+
+    * [0.30000000000000004.com](http://0.30000000000000004.com/)
+    * [What Every Programmer Should Know About Floating-Point Arithmetic](https://floating-point-gui.de/)
+
+  """
+
+  import Bitwise
+
+  @power_of_2_to_52 4_503_599_627_370_496
+  @precision_range 0..15
+  @type precision_range :: 0..15
+
+  @min_finite then(<<0xFFEFFFFFFFFFFFFF::64>>, fn <<num::float>> -> num end)
+  @max_finite then(<<0x7FEFFFFFFFFFFFFF::64>>, fn <<num::float>> -> num end)
+
+  @doc """
+  Returns the maximum finite value for a float.
+
+  ## Examples
+
+      iex> Float.max_finite()
+      1.7976931348623157e308
+
+  """
+  @spec max_finite() :: float
+  def max_finite, do: @max_finite
+
+  @doc """
+  Returns the minimum finite value for a float.
+
+  ## Examples
+
+      iex> Float.min_finite()
+      -1.7976931348623157e308
+
+  """
+  @spec min_finite() :: float
+  def min_finite, do: @min_finite
+
+  @doc """
+  Computes `base` raised to power of `exponent`.
+
+  `base` must be a float and `exponent` can be any number.
+  However, if a negative base and a fractional exponent
+  are given, it raises `ArithmeticError`.
+
+  It always returns a float. See `Integer.pow/2` for
+  exponentiation that returns integers.
+
+  ## Examples
+
+      iex> Float.pow(2.0, 0)
+      1.0
+      iex> Float.pow(2.0, 1)
+      2.0
+      iex> Float.pow(2.0, 10)
+      1024.0
+      iex> Float.pow(2.0, -1)
+      0.5
+      iex> Float.pow(2.0, -3)
+      0.125
+
+      iex> Float.pow(3.0, 1.5)
+      5.196152422706632
+
+      iex> Float.pow(-2.0, 3)
+      -8.0
+      iex> Float.pow(-2.0, 4)
+      16.0
+
+      iex> Float.pow(-1.0, 0.5)
+      ** (ArithmeticError) bad argument in arithmetic expression
+
   """
+  @doc since: "1.12.0"
+  @spec pow(float, number) :: float
+  def pow(base, exponent) when is_float(base) and is_number(exponent),
+    do: :math.pow(base, exponent)
 
   @doc """
   Parses a binary into a float.
 
-  If successful, returns a tuple of the form `{float, remainder_of_binary}`.
-  Otherwise `:error`.
+  If successful, returns a tuple in the form of `{float, remainder_of_binary}`;
+  when the binary cannot be coerced into a valid float, the atom `:error` is
+  returned.
+
+  If the size of float exceeds the maximum size of `1.7976931348623157e+308`,
+  `:error` is returned even though the textual representation itself might be
+  well formed.
+
+  If you want to convert a string-formatted float directly to a float,
+  `String.to_float/1` can be used instead.
 
   ## Examples
 
       iex> Float.parse("34")
-      {34.0,""}
-
+      {34.0, ""}
       iex> Float.parse("34.25")
-      {34.25,""}
-
+      {34.25, ""}
       iex> Float.parse("56.5xyz")
-      {56.5,"xyz"}
+      {56.5, "xyz"}
 
+      iex> Float.parse(".12")
+      :error
       iex> Float.parse("pi")
       :error
+      iex> Float.parse("1.7976931348623159e+308")
+      :error
 
   """
   @spec parse(binary) :: {float, binary} | :error
   def parse("-" <> binary) do
-    case parse_unsign(binary) do
+    case parse_unsigned(binary) do
       :error -> :error
       {number, remainder} -> {-number, remainder}
     end
   end
 
-  def parse(binary) do
-    parse_unsign(binary)
+  def parse("+" <> binary) do
+    parse_unsigned(binary)
   end
 
-  defp parse_unsign("-" <> _), do: :error
-  defp parse_unsign(binary) when is_binary(binary) do
-    case Integer.parse binary do
-      :error -> :error
-      {integer_part, after_integer} -> parse_unsign after_integer, integer_part
-    end
+  def parse(binary) do
+    parse_unsigned(binary)
   end
 
-  # Dot followed by digit is required afterwards or we are done
-  defp parse_unsign(<< ?., char, rest :: binary >>, int) when char in ?0..?9 do
-    parse_unsign(rest, char - ?0, 1, int)
+  defp parse_unsigned(<<digit, rest::binary>>) when digit in ?0..?9,
+    do: parse_unsigned(rest, false, false, [digit])
+
+  defp parse_unsigned(binary) when is_binary(binary), do: :error
+
+  defp parse_unsigned(<<digit, rest::binary>>, dot?, e?, acc) when digit in ?0..?9,
+    do: parse_unsigned(rest, dot?, e?, [digit | acc])
+
+  defp parse_unsigned(<<?., digit, rest::binary>>, false, false, acc) when digit in ?0..?9,
+    do: parse_unsigned(rest, true, false, [digit, ?. | acc])
+
+  defp parse_unsigned(<<exp_marker, digit, rest::binary>>, dot?, false, acc)
+       when exp_marker in ~c"eE" and digit in ?0..?9,
+       do: parse_unsigned(rest, true, true, [digit, ?e | add_dot(acc, dot?)])
+
+  defp parse_unsigned(<<exp_marker, sign, digit, rest::binary>>, dot?, false, acc)
+       when exp_marker in ~c"eE" and sign in ~c"-+" and digit in ?0..?9,
+       do: parse_unsigned(rest, true, true, [digit, sign, ?e | add_dot(acc, dot?)])
+
+  # When floats are expressed in scientific notation, :erlang.binary_to_float/1 can raise an
+  # ArgumentError if the e exponent is too big. For example, "1.0e400". Because of this, we
+  # rescue the ArgumentError here and return an error.
+  defp parse_unsigned(rest, dot?, true = _e?, acc) do
+    acc
+    |> add_dot(dot?)
+    |> :lists.reverse()
+    |> :erlang.list_to_float()
+  rescue
+    ArgumentError -> :error
+  else
+    float -> {float, rest}
   end
 
-  defp parse_unsign(rest, int) do
-    {:erlang.float(int), rest}
-  end
+  defp parse_unsigned(rest, dot?, false = _e?, acc) do
+    float =
+      acc
+      |> add_dot(dot?)
+      |> :lists.reverse()
+      |> :erlang.list_to_float()
 
-  # Handle decimal points
-  defp parse_unsign(<< char, rest :: binary >>, float, decimal, int) when char in ?0..?9 do
-    parse_unsign rest, 10 * float + (char - ?0), decimal + 1, int
+    {float, rest}
   end
 
-  defp parse_unsign(<< ?e, after_e :: binary >>, float, decimal, int) do
-    case Integer.parse after_e do
-      :error ->
-        # Note we rebuild the binary here instead of breaking it apart at
-        # the function clause because the current approach copies a binary
-        # just on this branch. If we broke it apart in the function clause,
-        # the copy would happen when calling Integer.parse/1.
-        {floatify(int, float, decimal), << ?e, after_e :: binary >>}
-      {exponential, after_exponential} ->
-        {floatify(int, float, decimal, exponential), after_exponential}
-    end
-  end
+  defp add_dot(acc, true), do: acc
+  defp add_dot(acc, false), do: [?0, ?. | acc]
 
-  defp parse_unsign(bitstring, float, decimal, int) do
-    {floatify(int, float, decimal), bitstring}
-  end
+  @doc """
+  Rounds a float to the largest float less than or equal to `number`.
 
-  defp floatify(int, float, decimal, exponential \\ 0) do
-    multiplier = if int < 0, do: -1.0, else: 1.0
+  `floor/2` also accepts a precision to round a floating-point value down
+  to an arbitrary number of fractional digits (between 0 and 15).
+  The operation is performed on the binary floating point, without a
+  conversion to decimal.
 
-    # Try to ensure the minimum amount of rounding errors
-    result = multiplier * (abs(int) * :math.pow(10, decimal) + float) * :math.pow(10, exponential - decimal)
+  This function always returns a float. `Kernel.trunc/1` may be used instead to
+  truncate the result to an integer afterwards.
 
-    # Try avoiding stuff like this:
-    # iex(1)> 0.0001 * 75
-    # 0.007500000000000001
-    # Due to IEEE 754 floating point standard
-    # http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
+  ## Known issues
 
-    final_decimal_places = decimal - exponential
-    if final_decimal_places > 0 do
-      decimal_power_round = :math.pow(10,  final_decimal_places)
-      trunc(result * decimal_power_round) / decimal_power_round
-    else
-      result
-    end
-  end
+  The behavior of `floor/2` for floats can be surprising. For example:
 
-  @doc """
-  Rounds a float to the largest integer less than or equal to `num`.
+      iex> Float.floor(12.52, 2)
+      12.51
 
-  ## Examples
+  One may have expected it to floor to 12.52. This is not a bug.
+  Most decimal fractions cannot be represented as a binary floating point
+  and therefore the number above is internally represented as 12.51999999,
+  which explains the behavior above.
 
-      iex> Float.floor(34)
-      34
+  ## Examples
 
       iex> Float.floor(34.25)
-      34
-
+      34.0
       iex> Float.floor(-56.5)
-      -57
+      -57.0
+      iex> Float.floor(34.259, 2)
+      34.25
 
   """
-  @spec floor(float | integer) :: integer
-  def floor(num) when is_integer(num), do: num
-  def floor(num) when is_float(num) do
-    truncated = :erlang.trunc(num)
-    case :erlang.abs(num - truncated) do
-      x when x > 0 and num < 0 -> truncated - 1
-      _ -> truncated
-    end
+  @spec floor(float, precision_range) :: float
+  def floor(number, precision \\ 0)
+
+  def floor(number, 0) when is_float(number) do
+    :math.floor(number)
+  end
+
+  def floor(number, precision) when is_float(number) and precision in @precision_range do
+    round(number, precision, :floor)
+  end
+
+  def floor(number, precision) when is_float(number) do
+    raise ArgumentError, invalid_precision_message(precision)
   end
 
   @doc """
-  Rounds a float to the largest integer greater than or equal to `num`.
+  Rounds a float to the smallest float greater than or equal to `number`.
 
-  ## Examples
+  `ceil/2` also accepts a precision to round a floating-point value down
+  to an arbitrary number of fractional digits (between 0 and 15).
 
-      iex> Float.ceil(34)
-      34
+  The operation is performed on the binary floating point, without a
+  conversion to decimal.
 
-      iex> Float.ceil(34.25)
-      35
+  The behavior of `ceil/2` for floats can be surprising. For example:
+
+      iex> Float.ceil(-12.52, 2)
+      -12.51
+
+  One may have expected it to ceil to -12.52. This is not a bug.
+  Most decimal fractions cannot be represented as a binary floating point
+  and therefore the number above is internally represented as -12.51999999,
+  which explains the behavior above.
+
+  This function always returns floats. `Kernel.trunc/1` may be used instead to
+  truncate the result to an integer afterwards.
 
+  ## Examples
+
+      iex> Float.ceil(34.25)
+      35.0
       iex> Float.ceil(-56.5)
-      -56
+      -56.0
+      iex> Float.ceil(34.251, 2)
+      34.26
+      iex> Float.ceil(-0.01)
+      -0.0
 
   """
-  @spec ceil(float | integer) :: integer
-  def ceil(num) when is_integer(num), do: num
-  def ceil(num) when is_float(num) do
-    truncated = :erlang.trunc(num)
-    case :erlang.abs(num - truncated) do
-      x when x > 0 and num > 0 -> truncated + 1
-      _ -> truncated
-    end
+  @spec ceil(float, precision_range) :: float
+  def ceil(number, precision \\ 0)
+
+  def ceil(number, 0) when is_float(number) do
+    :math.ceil(number)
+  end
+
+  def ceil(number, precision) when is_float(number) and precision in @precision_range do
+    round(number, precision, :ceil)
+  end
+
+  def ceil(number, precision) when is_float(number) do
+    raise ArgumentError, invalid_precision_message(precision)
   end
 
   @doc """
-  Rounds a floating point value to an arbitrary number of fractional digits
-  (between 0 and 15).
+  Rounds a floating-point value to an arbitrary number of fractional
+  digits (between 0 and 15).
+
+  The rounding direction always ties to half up. The operation is
+  performed on the binary floating point, without a conversion to decimal.
+
+  This function only accepts floats and always returns a float. Use
+  `Kernel.round/1` if you want a function that accepts both floats
+  and integers and always returns an integer.
+
+  ## Known issues
+
+  The behavior of `round/2` for floats can be surprising. For example:
+
+      iex> Float.round(5.5675, 3)
+      5.567
+
+  One may have expected it to round to the half up 5.568. This is not a bug.
+  Most decimal fractions cannot be represented as a binary floating point
+  and therefore the number above is internally represented as 5.567499999,
+  which explains the behavior above. If you want exact rounding for decimals,
+  you must use a decimal library. The behavior above is also in accordance
+  to reference implementations, such as "Correctly Rounded Binary-Decimal and
+  Decimal-Binary Conversions" by David M. Gay.
 
   ## Examples
 
+      iex> Float.round(12.5)
+      13.0
       iex> Float.round(5.5674, 3)
       5.567
-
       iex> Float.round(5.5675, 3)
-      5.568
-
+      5.567
       iex> Float.round(-5.5674, 3)
       -5.567
-
-      iex> Float.round(-5.5675, 3)
-      -5.568
+      iex> Float.round(-5.5675)
+      -6.0
+      iex> Float.round(12.341444444444441, 15)
+      12.341444444444441
+      iex> Float.round(-0.01)
+      -0.0
 
   """
-  @spec round(float, integer) :: float
-  def round(number, precision) when is_float(number) and is_integer(precision) and precision in 0..15 do
-    Kernel.round(number * :math.pow(10, precision)) / :math.pow(10, precision)
+  @spec round(float, precision_range) :: float
+  # This implementation is slow since it relies on big integers.
+  # Faster implementations are available on more recent papers
+  # and could be implemented in the future.
+  def round(float, precision \\ 0)
+
+  def round(float, 0) when float == 0.0, do: float
+
+  def round(float, 0) when is_float(float) do
+    case float |> :erlang.round() |> :erlang.float() do
+      zero when zero == 0.0 and float < 0.0 -> -0.0
+      rounded -> rounded
+    end
   end
 
-  @doc """
-  Returns a char list which corresponds to the text representation of the given float.
+  def round(float, precision) when is_float(float) and precision in @precision_range do
+    round(float, precision, :half_up)
+  end
 
-  Inlined by the compiler.
+  def round(float, precision) when is_float(float) do
+    raise ArgumentError, invalid_precision_message(precision)
+  end
 
-  ## Examples
+  defp round(num, _precision, _rounding) when is_float(num) and num == 0.0, do: num
+
+  defp round(float, precision, rounding) do
+    <<sign::1, exp::11, significant::52-bitstring>> = <<float::float>>
+    {num, count} = decompose(significant, 1)
+    count = count - exp + 1023
+
+    cond do
+      # Precision beyond 15 digits
+      count >= 104 ->
+        case rounding do
+          :ceil when sign === 0 -> 1 / power_of_10(precision)
+          :floor when sign === 1 -> -1 / power_of_10(precision)
+          :ceil when sign === 1 -> minus_zero()
+          :half_up when sign === 1 -> minus_zero()
+          _ -> 0.0
+        end
+
+      # We are asking more precision than we have
+      count <= precision ->
+        float
+
+      true ->
+        # Difference in precision between float and asked precision
+        # We subtract 1 because we need to calculate the remainder too
+        diff = count - precision - 1
+
+        # Get up to latest so we calculate the remainder
+        power_of_10 = power_of_10(diff)
+
+        # Convert the numerand to decimal base
+        num = num * power_of_5(count)
+
+        # Move to the given precision - 1
+        num = div(num, power_of_10)
+        div = div(num, 10)
+        num = rounding(rounding, sign, num, div)
+
+        # Convert back to float without loss
+        # https://www.exploringbinary.com/correct-decimal-to-floating-point-using-big-integers/
+        den = power_of_10(precision)
+        boundary = den <<< 52
+
+        cond do
+          num == 0 and sign == 1 ->
+            minus_zero()
+
+          num == 0 ->
+            0.0
+
+          num >= boundary ->
+            {den, exp} = scale_down(num, boundary, 52)
+            decimal_to_float(sign, num, den, exp)
+
+          true ->
+            {num, exp} = scale_up(num, boundary, 52)
+            decimal_to_float(sign, num, den, exp)
+        end
+    end
+  end
 
-      iex> Float.to_char_list(7.0)
-      '7.00000000000000000000e+00'
+  # TODO remove once we require Erlang/OTP 27+
+  # This function tricks the compiler to avoid this bug in previous versions:
+  # https://github.com/elixir-lang/elixir/blob/main/lib/elixir/lib/float.ex#L408-L412
+  defp minus_zero, do: -0.0
 
-  """
-  @spec to_char_list(float) :: char_list
-  def to_char_list(number) do
-    :erlang.float_to_list(number)
+  defp decompose(significant, initial) do
+    decompose(significant, 1, 0, initial)
   end
 
-  @doc """
-  Returns a list which corresponds to the text representation
-  of `float`.
+  defp decompose(<<1::1, bits::bitstring>>, count, last_count, acc) do
+    decompose(bits, count + 1, count, (acc <<< (count - last_count)) + 1)
+  end
 
-  ## Options
+  defp decompose(<<0::1, bits::bitstring>>, count, last_count, acc) do
+    decompose(bits, count + 1, last_count, acc)
+  end
 
-    * `:decimals`   — number of decimal points to show
-    * `:scientific` — number of decimal points to show, in scientific format
-    * `:compact`    — when true, use the most compact representation (ignored
-                      with the `scientific` option)
+  defp decompose(<<>>, _count, last_count, acc) do
+    {acc, last_count}
+  end
+
+  defp scale_up(num, boundary, exp) when num >= boundary, do: {num, exp}
+  defp scale_up(num, boundary, exp), do: scale_up(num <<< 1, boundary, exp - 1)
+
+  defp scale_down(num, den, exp) do
+    new_den = den <<< 1
+
+    if num < new_den do
+      {den >>> 52, exp}
+    else
+      scale_down(num, new_den, exp + 1)
+    end
+  end
+
+  defp decimal_to_float(sign, num, den, exp) do
+    quo = div(num, den)
+    rem = num - quo * den
+
+    tmp =
+      case den >>> 1 do
+        den when rem > den -> quo + 1
+        den when rem < den -> quo
+        _ when (quo &&& 1) === 1 -> quo + 1
+        _ -> quo
+      end
+
+    tmp = tmp - @power_of_2_to_52
+    <<tmp::float>> = <<sign::1, exp + 1023::11, tmp::52>>
+    tmp
+  end
+
+  defp rounding(:floor, 1, _num, div), do: div + 1
+  defp rounding(:ceil, 0, _num, div), do: div + 1
+
+  defp rounding(:half_up, _sign, num, div) do
+    case rem(num, 10) do
+      rem when rem < 5 -> div
+      rem when rem >= 5 -> div + 1
+    end
+  end
+
+  defp rounding(_, _, _, div), do: div
+
+  Enum.reduce(0..104, 1, fn x, acc ->
+    defp power_of_10(unquote(x)), do: unquote(acc)
+    acc * 10
+  end)
+
+  Enum.reduce(0..104, 1, fn x, acc ->
+    defp power_of_5(unquote(x)), do: unquote(acc)
+    acc * 5
+  end)
+
+  @doc """
+  Returns a pair of integers whose ratio is exactly equal
+  to the original float and with a positive denominator.
 
   ## Examples
 
-      iex> Float.to_char_list 7.1, [decimals: 2, compact: true]
-      '7.1'
+      iex> Float.ratio(0.0)
+      {0, 1}
+      iex> Float.ratio(3.14)
+      {7070651414971679, 2251799813685248}
+      iex> Float.ratio(-3.14)
+      {-7070651414971679, 2251799813685248}
+      iex> Float.ratio(1.5)
+      {3, 2}
+      iex> Float.ratio(-1.5)
+      {-3, 2}
+      iex> Float.ratio(16.0)
+      {16, 1}
+      iex> Float.ratio(-16.0)
+      {-16, 1}
 
   """
-  @spec to_char_list(float, list) :: char_list
-  def to_char_list(float, options) do
-    :erlang.float_to_list(float, expand_compact(options))
+  @doc since: "1.4.0"
+  @spec ratio(float) :: {integer, pos_integer}
+  def ratio(float) when is_float(float) and float == 0.0, do: {0, 1}
+
+  def ratio(float) when is_float(float) do
+    <<sign::1, exp::11, mantissa::52>> = <<float::float>>
+
+    {num, den_exp} =
+      if exp != 0 do
+        # Floats are expressed like this:
+        # (2**52 + mantissa) * 2**(-52 + exp - 1023)
+        #
+        # We compute the root factors of the mantissa so we have this:
+        # (2**52 + mantissa * 2**count) * 2**(-52 + exp - 1023)
+        {mantissa, count} = root_factors(mantissa, 0)
+
+        # Now we can move the count around so we have this:
+        # (2**(52-count) + mantissa) * 2**(count + -52 + exp - 1023)
+        if mantissa == 0 do
+          {1, exp - 1023}
+        else
+          num = (1 <<< (52 - count)) + mantissa
+          den_exp = count - 52 + exp - 1023
+          {num, den_exp}
+        end
+      else
+        # Subnormals are expressed like this:
+        # (mantissa) * 2**(-52 + 1 - 1023)
+        #
+        # So we compute it to this:
+        # (mantissa * 2**(count)) * 2**(-52 + 1 - 1023)
+        #
+        # Which becomes:
+        # mantissa * 2**(count-1074)
+        root_factors(mantissa, -1074)
+      end
+
+    if den_exp > 0 do
+      {sign(sign, num <<< den_exp), 1}
+    else
+      {sign(sign, num), 1 <<< -den_exp}
+    end
   end
 
+  defp root_factors(mantissa, count) when mantissa != 0 and (mantissa &&& 1) == 0,
+    do: root_factors(mantissa >>> 1, count + 1)
+
+  defp root_factors(mantissa, count),
+    do: {mantissa, count}
+
+  @compile {:inline, sign: 2}
+  defp sign(0, num), do: num
+  defp sign(1, num), do: -num
+
   @doc """
-  Returns a binary which corresponds to the text representation
-  of `some_float`.
+  Returns a charlist which corresponds to the shortest text representation
+  of the given float.
+
+  It uses the algorithm presented in "Ryū: fast float-to-string conversion"
+  in Proceedings of the SIGPLAN '2018 Conference on Programming Language
+  Design and Implementation.
+
+  For a configurable representation, use `:erlang.float_to_list/2`.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> Float.to_string(7.0)
-      "7.00000000000000000000e+00"
+      iex> Float.to_charlist(7.0)
+      ~c"7.0"
 
   """
-  @spec to_string(float) :: String.t
-  def to_string(some_float) do
-    :erlang.float_to_binary(some_float)
+  @spec to_charlist(float) :: charlist
+  def to_charlist(float) do
+    :erlang.float_to_list(float, [:short])
   end
 
   @doc """
-  Returns a binary which corresponds to the text representation
-  of `float`.
+  Returns a binary which corresponds to the shortest text representation
+  of the given float.
+
+  The underlying algorithm changes depending on the Erlang/OTP version:
 
-  ## Options
+    * For OTP >= 24, it uses the algorithm presented in "Ryū: fast
+      float-to-string conversion" in Proceedings of the SIGPLAN '2018
+      Conference on Programming Language Design and Implementation.
 
-    * `:decimals`   — number of decimal points to show
-    * `:scientific` — number of decimal points to show, in scientific format
-    * `:compact`    — when true, use the most compact representation (ignored
-                      with the `scientific` option)
+    * For OTP < 24, it uses the algorithm presented in "Printing Floating-Point
+      Numbers Quickly and Accurately" in Proceedings of the SIGPLAN '1996
+      Conference on Programming Language Design and Implementation.
+
+  For a configurable representation, use `:erlang.float_to_binary/2`.
+
+  Inlined by the compiler.
 
   ## Examples
 
-      iex> Float.to_string 7.1, [decimals: 2, compact: true]
-      "7.1"
+      iex> Float.to_string(7.0)
+      "7.0"
 
   """
-  @spec to_string(float, list) :: String.t
+  @spec to_string(float) :: String.t()
+  def to_string(float) do
+    :erlang.float_to_binary(float, [:short])
+  end
+
+  @doc false
+  @deprecated "Use Float.to_charlist/1 instead"
+  def to_char_list(float), do: Float.to_charlist(float)
+
+  @doc false
+  @deprecated "Use :erlang.float_to_list/2 instead"
+  def to_char_list(float, options) do
+    :erlang.float_to_list(float, expand_compact(options))
+  end
+
+  @doc false
+  @deprecated "Use :erlang.float_to_binary/2 instead"
   def to_string(float, options) do
     :erlang.float_to_binary(float, expand_compact(options))
   end
 
-  defp expand_compact([{:compact, false}|t]), do: expand_compact(t)
-  defp expand_compact([{:compact, true}|t]),  do: [:compact|expand_compact(t)]
-  defp expand_compact([h|t]),                 do: [h|expand_compact(t)]
-  defp expand_compact([]),                    do: []
+  defp invalid_precision_message(precision) do
+    "precision #{precision} is out of valid range of #{inspect(@precision_range)}"
+  end
+
+  defp expand_compact([{:compact, false} | t]), do: expand_compact(t)
+  defp expand_compact([{:compact, true} | t]), do: [:compact | expand_compact(t)]
+  defp expand_compact([h | t]), do: [h | expand_compact(t)]
+  defp expand_compact([]), do: []
 end
diff --git a/lib/elixir/lib/function.ex b/lib/elixir/lib/function.ex
new file mode 100644
index 00000000000..654666a1a89
--- /dev/null
+++ b/lib/elixir/lib/function.ex
@@ -0,0 +1,212 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Function do
+  @moduledoc """
+  A set of functions for working with functions.
+
+  Anonymous functions are typically created by using `fn`:
+
+      iex> add = fn a, b -> a + b end
+      iex> add.(1, 2)
+      3
+
+  Anonymous functions can also have multiple clauses. All clauses
+  should expect the same number of arguments:
+
+      iex> negate = fn
+      ...>   true -> false
+      ...>   false -> true
+      ...> end
+      iex> negate.(false)
+      true
+
+  ## The capture operator
+
+  It is also possible to capture public module functions and pass them
+  around as if they were anonymous functions by using the capture
+  operator `&/1`:
+
+      iex> add = &Kernel.+/2
+      iex> add.(1, 2)
+      3
+
+      iex> length = &String.length/1
+      iex> length.("hello")
+      5
+
+  To capture a definition within the current module, you can skip the
+  module prefix, such as `&my_fun/2`. In those cases, the captured
+  function can be public (`def`) or private (`defp`).
+
+  The capture operator can also be used to create anonymous functions
+  that expect at least one argument:
+
+      iex> add = &(&1 + &2)
+      iex> add.(1, 2)
+      3
+
+  In such cases, using the capture operator is no different than using `fn`.
+
+  ## Internal and external functions
+
+  We say that functions that point to definitions residing in modules, such
+  as `&String.length/1`, are **external** functions. All other functions are
+  **local** and they are always bound to the file or module that defined them.
+
+  Besides the functions in this module to work with functions, `Kernel` also
+  has an `apply/2` function that invokes a function with a dynamic number of
+  arguments, as well as `is_function/1` and `is_function/2`, to check
+  respectively if a given value is a function or a function of a given arity.
+  """
+
+  @type information ::
+          :arity
+          | :env
+          | :index
+          | :module
+          | :name
+          | :new_index
+          | :new_uniq
+          | :pid
+          | :type
+          | :uniq
+
+  @doc """
+  Captures the given function.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Function.capture(String, :length, 1)
+      &String.length/1
+
+  """
+  @doc since: "1.7.0"
+  @spec capture(module, atom, arity) :: fun
+  def capture(module, function_name, arity) do
+    :erlang.make_fun(module, function_name, arity)
+  end
+
+  @doc """
+  Returns a keyword list with information about a function.
+
+  The returned keys (with the corresponding possible values) for
+  all types of functions (local and external) are the following:
+
+    * `:type` - `:local` (for anonymous functions) or `:external` (for
+      named functions).
+
+    * `:module` - an atom which is the module where the function is defined when
+    anonymous or the module which the function refers to when it's a named function.
+
+    * `:arity` - (integer) the number of arguments the function is to be called with.
+
+    * `:name` - (atom) the name of the function.
+
+    * `:env` - a list of the environment or free variables. For named
+      functions, the returned list is always empty.
+
+  When `fun` is an anonymous function (that is, the type is `:local`), the following
+  additional keys are returned:
+
+    * `:pid` - PID of the process that originally created the function.
+
+    * `:index` - (integer) an index into the module function table.
+
+    * `:new_index` - (integer) an index into the module function table.
+
+    * `:new_uniq` - (binary) a unique value for this function. It's
+      calculated from the compiled code for the entire module.
+
+    * `:uniq` - (integer) a unique value for this function. This integer is
+      calculated from the compiled code for the entire module.
+
+  **Note**: this function must be used only for debugging purposes.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> fun = fn x -> x end
+      iex> info = Function.info(fun)
+      iex> Keyword.get(info, :arity)
+      1
+      iex> Keyword.get(info, :type)
+      :local
+
+      iex> fun = &String.length/1
+      iex> info = Function.info(fun)
+      iex> Keyword.get(info, :type)
+      :external
+      iex> Keyword.get(info, :name)
+      :length
+
+  """
+  @doc since: "1.7.0"
+  @spec info(fun) :: [{information, term}]
+  def info(fun), do: :erlang.fun_info(fun)
+
+  @doc """
+  Returns a specific information about the function.
+
+  The returned information is a two-element tuple in the shape of
+  `{info, value}`.
+
+  For any function, the information asked for can be any of the atoms
+  `:module`, `:name`, `:arity`, `:env`, or `:type`.
+
+  For anonymous functions, there is also information about any of the
+  atoms `:index`, `:new_index`, `:new_uniq`, `:uniq`, and `:pid`.
+  For a named function, the value of any of these items is always the
+  atom `:undefined`.
+
+  For more information on each of the possible returned values, see
+  `info/1`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> f = fn x -> x end
+      iex> Function.info(f, :arity)
+      {:arity, 1}
+      iex> Function.info(f, :type)
+      {:type, :local}
+
+      iex> fun = &String.length/1
+      iex> Function.info(fun, :name)
+      {:name, :length}
+      iex> Function.info(fun, :pid)
+      {:pid, :undefined}
+
+  """
+  @doc since: "1.7.0"
+  @spec info(fun, item) :: {item, term} when item: information
+  def info(fun, item), do: :erlang.fun_info(fun, item)
+
+  @doc """
+  Returns its input `value`. This function can be passed as an anonymous function
+  to transformation functions.
+
+  ## Examples
+
+      iex> Function.identity("Hello world!")
+      "Hello world!"
+
+      iex> ~c"abcdaabccc" |> Enum.sort() |> Enum.chunk_by(&Function.identity/1)
+      [~c"aaa", ~c"bb", ~c"cccc", ~c"d"]
+
+      iex> Enum.group_by(~c"abracadabra", &Function.identity/1)
+      %{97 => ~c"aaaaa", 98 => ~c"bb", 99 => ~c"c", 100 => ~c"d", 114 => ~c"rr"}
+
+      iex> Enum.map([1, 2, 3, 4], &Function.identity/1)
+      [1, 2, 3, 4]
+
+  """
+  @doc since: "1.10.0"
+  @spec identity(value) :: value when value: var
+  def identity(value), do: value
+end
diff --git a/lib/elixir/lib/gen_event.ex b/lib/elixir/lib/gen_event.ex
index 99ab1c48388..4763739a8f3 100644
--- a/lib/elixir/lib/gen_event.ex
+++ b/lib/elixir/lib/gen_event.ex
@@ -1,185 +1,102 @@
-defmodule GenEvent do
-  @moduledoc """
-  A behaviour module for implementing event handling functionality.
-
-  The event handling model consists of a generic event manager
-  process with an arbitrary number of event handlers which are
-  added and deleted dynamically.
-
-  An event manager implemented using this module will have a standard
-  set of interface functions and include functionality for tracing and
-  error reporting. It will also fit into an supervision tree.
-
-  ## Example
-
-  There are many use cases for event handlers. For example, a logging
-  system can be built using event handlers where which log message is
-  an event and different event handlers can be plugged to handle the
-  log messages. One handler may print error messages on the terminal,
-  another can write it to a file, while a third one can keep the
-  messages in memory (like a buffer) until they are read.
-
-  As an example, let's have a GenEvent that accumulates messages until
-  they are collected by an explicit call.
-
-      defmodule LoggerHandler do
-        use GenEvent
-
-        # Callbacks
-
-        def handle_event({:log, x}, messages) do
-          {:ok, [x|messages]}
-        end
-
-        def handle_call(:messages, messages) do
-          {:ok, Enum.reverse(messages), []}
-        end
-      end
-
-      {:ok, pid} = GenEvent.start_link()
-
-      GenEvent.add_handler(pid, LoggerHandler, [])
-      #=> :ok
-
-      GenEvent.notify(pid, {:log, 1})
-      #=> :ok
-
-      GenEvent.notify(pid, {:log, 2})
-      #=> :ok
-
-      GenEvent.call(pid, LoggerHandler, :messages)
-      #=> [1, 2]
-
-      GenEvent.call(pid, LoggerHandler, :messages)
-      #=> []
-
-  We start a new event manager by calling `GenEvent.start_link/0`.
-  Notifications can be sent to the event manager which will then
-  invoke `handle_event/0` for each registered handler.
-
-  We can add new handlers with `add_handler/4`. Calls can also
-  be made to specific handlers by using `call/3`.
-
-  ## Callbacks
-
-  There are 6 callbacks required to be implemented in a `GenEvent`. By
-  adding `use GenEvent` to your module, Elixir will automatically define
-  all 6 callbacks for you, leaving it up to you to implement the ones
-  you want to customize. The callbacks are:
-
-    * `init(args)` - invoked when the event handler is added.
-
-      It must return:
-
-      -  `{:ok, state}`
-      -  `{:ok, state, :hibernate}`
-      -  `{:error, reason}`
-
-    * `handle_event(msg, state)` - invoked whenever an event is sent via
-      `notify/2` or `sync_notify/2`.
-
-      It must return:
-
-      -  `{:ok, new_state}`
-      -  `{:ok, new_state, :hibernate}`
-      -  `{:swap_handler, args1, new_state, handler2, args2}`
-      -  `:remove_handler`
-
-    * `handle_call(msg, state)` - invoked when a `call/3` is done to a specific
-      handler.
-
-      It must return:
-
-      -  `{:ok, reply, new_state}`
-      -  `{:ok, reply, new_state, :hibernate}`
-      -  `{:swap_handler, reply, args1, new_state, handler2, args2}`
-      -  `{:remove_handler, reply}`
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-    * `handle_info(msg, state)` - invoked to handle all other messages which
-      are received by the process. Must return the same values as
-      `handle_event/2`.
+defmodule GenEvent do
+  # Functions from this module are deprecated in elixir_dispatch.
 
-      It must return:
+  @moduledoc """
+  An event manager with event handlers behaviour.
 
-      -  `{:noreply, state}`
-      -  `{:noreply, state, timeout}`
-      -  `{:stop, reason, state}`
+  If you are interested in implementing an event manager, please read the
+  "Alternatives" section below. If you have to implement an event handler to
+  integrate with an existing system, such as Elixir's Logger, please use
+  [`:gen_event`](`:gen_event`) instead.
 
-    * `terminate(reason, state)` - called when the event handler is removed or
-      the event manager is terminating. It can return any term.
+  ## Alternatives
 
-    * `code_change(old_vsn, state, extra)` - called when the application
-      code is being upgraded live (hot code swapping).
+  There are a few suitable alternatives to replace GenEvent. Each of them can be
+  the most beneficial based on the use case.
 
-      It must return:
+  ### Supervisor and GenServers
 
-      -  `{:ok, new_state}`
+  One alternative to GenEvent is a very minimal solution consisting of using a
+  supervisor and multiple GenServers started under it. The supervisor acts as
+  the "event manager" and the children GenServers act as the "event handlers".
+  This approach has some shortcomings (it provides no back-pressure for example)
+  but can still replace GenEvent for low-profile usages of it. [This blog post
+  by José
+  Valim](https://dashbit.co/blog/replacing-genevent-by-a-supervisor-plus-genserver)
+  has more detailed information on this approach.
 
-  ## Name Registration
+  ### GenStage
 
-  A GenEvent is bound to the same name registration rules as a `GenServer`.
-  Read more about it in the `GenServer` docs.
+  If the use case where you were using GenEvent requires more complex logic,
+  [GenStage](https://github.com/elixir-lang/gen_stage) provides a great
+  alternative. GenStage is an external Elixir library maintained by the Elixir
+  team; it provides a tool to implement systems that exchange events in a
+  demand-driven way with built-in support for back-pressure. See the [GenStage
+  documentation](https://hexdocs.pm/gen_stage) for more information.
 
-  ## Streaming
+  ### `:gen_event`
 
-  `GenEvent`s can be streamed from and streamed with the help of `stream/2`.
-  Here are some examples:
+  If your use case requires exactly what GenEvent provided, or you have to
+  integrate with an existing `:gen_event`-based system, you can still use the
+  [`:gen_event`](`:gen_event`) Erlang module.
+  """
 
-      stream = GenEvent.stream(pid)
+  @moduledoc deprecated: "Use Erlang/OTP's :gen_event module instead"
 
-      # Take the next 10 events
-      Enum.take(stream, 10)
+  @callback init(args :: term) ::
+              {:ok, state}
+              | {:ok, state, :hibernate}
+              | {:error, reason :: term}
+            when state: term
 
-      # Print all remaining events
-      for event <- stream do
-        IO.inspect event
-      end
+  @callback handle_event(event :: term, state :: term) ::
+              {:ok, new_state}
+              | {:ok, new_state, :hibernate}
+              | :remove_handler
+            when new_state: term
 
-  A stream may also be given an id, which allows all streams with the given
-  id to be cancelled at any moment via `cancel_streams/1`.
+  @callback handle_call(request :: term, state :: term) ::
+              {:ok, reply, new_state}
+              | {:ok, reply, new_state, :hibernate}
+              | {:remove_handler, reply}
+            when reply: term, new_state: term
 
-  ## Learn more
+  @callback handle_info(msg :: term, state :: term) ::
+              {:ok, new_state}
+              | {:ok, new_state, :hibernate}
+              | :remove_handler
+            when new_state: term
 
-  If you wish to find out more about gen events, Elixir getting started
-  guides provide a tutorial-like introduction. The documentation and links
-  in Erlang can also provide extra insight.
+  @callback terminate(reason, state :: term) :: term
+            when reason: :stop | {:stop, term} | :remove_handler | {:error, term} | term
 
-    * http://elixir-lang.org/getting_started/mix/1.html
-    * http://www.erlang.org/doc/man/gen_event.html
-    * http://learnyousomeerlang.com/event-handlers
-  """
+  @callback code_change(old_vsn, state :: term, extra :: term) :: {:ok, new_state :: term}
+            when old_vsn: term | {:down, term}
 
-  @typedoc "Return values of `start*` functions"
   @type on_start :: {:ok, pid} | {:error, {:already_started, pid}}
 
-  @typedoc "The GenEvent manager name"
   @type name :: atom | {:global, term} | {:via, module, term}
 
-  @typedoc "Options used by the `start*` functions"
   @type options :: [name: name]
 
-  @typedoc "The event manager reference"
   @type manager :: pid | name | {atom, node}
 
-  @typedoc "Supported values for new handlers"
-  @type handler :: module | {module, term}
-
-  @doc """
-  Defines a `GenEvent` stream.
+  @type handler :: atom | {atom, term}
 
-  This is a struct returned by `stream/2`. The struct is public and
-  contains the following fields:
-
-    * `:manager`  - the manager reference given to `GenEvent.stream/2`
-    * `:id`       - the event stream id for cancellation
-    * `:timeout`  - the timeout in between events, defaults to `:infinity`
-    * `:duration` - the duration of the subscription, defaults to `:infinity`
-    * `:mode`     - if the subscription mode is sync or async, defaults to `:sync`
-  """
-  defstruct manager: nil, id: nil, timeout: :infinity, duration: :infinity, mode: :sync
+  message = "Use one of the alternatives described in the documentation for the GenEvent module"
 
+  @deprecated message
   @doc false
   defmacro __using__(_) do
+    deprecation_message =
+      "the GenEvent module is deprecated, see its documentation for alternatives"
+
+    IO.warn(deprecation_message, __CALLER__)
+
     quote location: :keep do
       @behaviour :gen_event
 
@@ -194,8 +111,21 @@ defmodule GenEvent do
       end
 
       @doc false
-      def handle_call(_request, state) do
-        {:ok, {:error, :bad_call}, state}
+      def handle_call(msg, state) do
+        proc =
+          case Process.info(self(), :registered_name) do
+            {_, []} -> self()
+            {_, name} -> name
+          end
+
+        # We do this to trick Dialyzer to not complain about non-local returns.
+        case :erlang.phash2(1, 1) do
+          0 ->
+            raise "attempted to call GenEvent #{inspect(proc)} but no handle_call/2 clause was provided"
+
+          1 ->
+            {:remove_handler, {:bad_call, msg}}
+        end
       end
 
       @doc false
@@ -204,7 +134,7 @@ defmodule GenEvent do
       end
 
       @doc false
-      def terminate(reason, state) do
+      def terminate(_reason, _state) do
         :ok
       end
 
@@ -213,452 +143,767 @@ defmodule GenEvent do
         {:ok, state}
       end
 
-      defoverridable [init: 1, handle_event: 2, handle_call: 2,
-                      handle_info: 2, terminate: 2, code_change: 3]
+      defoverridable init: 1,
+                     handle_event: 2,
+                     handle_call: 2,
+                     handle_info: 2,
+                     terminate: 2,
+                     code_change: 3
     end
   end
 
-  @doc """
-  Starts an event manager linked to the current process.
-
-  This is often used to start the `GenEvent` as part of a supervision tree.
-
-  It accepts the `:name` option which is described under the `Name Registration`
-  section in the `GenServer` module docs.
-
-  If the event manager is successfully created and initialized, the function
-  returns `{:ok, pid}`, where pid is the pid of the server. If there already
-  exists a process with the specified server name, the function returns
-  `{:error, {:already_started, pid}}` with the pid of that process.
-
-  Note that a `GenEvent` started with `start_link/1` is linked to the
-  parent process and will exit not only on crashes but also if the parent
-  process exits with `:normal` reason.
-  """
+  @doc false
+  @deprecated message
   @spec start_link(options) :: on_start
   def start_link(options \\ []) when is_list(options) do
     do_start(:link, options)
   end
 
-  @doc """
-  Starts an event manager process without links (outside of a supervision tree).
-
-  See `start_link/1` for more information.
-  """
+  @doc false
+  @deprecated message
   @spec start(options) :: on_start
   def start(options \\ []) when is_list(options) do
     do_start(:nolink, options)
   end
 
+  @no_callback :"no callback module"
+
   defp do_start(mode, options) do
     case Keyword.get(options, :name) do
       nil ->
-        :gen.start(:gen_event, mode, :"no callback module", [], [])
+        :gen.start(GenEvent, mode, @no_callback, [], [])
+
       atom when is_atom(atom) ->
-        :gen.start(:gen_event, mode, {:local, atom}, :"no callback module", [], [])
-      other when is_tuple(other) ->
-        :gen.start(:gen_event, mode, other, :"no callback module", [], [])
+        :gen.start(GenEvent, mode, {:local, atom}, @no_callback, [], [])
+
+      {:global, _term} = tuple ->
+        :gen.start(GenEvent, mode, tuple, @no_callback, [], [])
+
+      {:via, via_module, _term} = tuple when is_atom(via_module) ->
+        :gen.start(GenEvent, mode, tuple, @no_callback, [], [])
+
+      other ->
+        raise ArgumentError, """
+        expected :name option to be one of the following:
+
+          * nil
+          * atom
+          * {:global, term}
+          * {:via, module, term}
+
+        Got: #{inspect(other)}
+        """
+    end
+  end
+
+  @doc false
+  @deprecated message
+  @spec stream(manager, keyword) :: GenEvent.Stream.t()
+  def stream(manager, options \\ []) do
+    %GenEvent.Stream{manager: manager, timeout: Keyword.get(options, :timeout, :infinity)}
+  end
+
+  @doc false
+  @deprecated message
+  @spec add_handler(manager, handler, term) :: :ok | {:error, term}
+  def add_handler(manager, handler, args) do
+    rpc(manager, {:add_handler, handler, args})
+  end
+
+  @doc false
+  @deprecated message
+  @spec add_mon_handler(manager, handler, term) :: :ok | {:error, term}
+  def add_mon_handler(manager, handler, args) do
+    rpc(manager, {:add_mon_handler, handler, args, self()})
+  end
+
+  @doc false
+  @deprecated message
+  @spec notify(manager, term) :: :ok
+  def notify(manager, event)
+
+  def notify({:global, name}, msg) do
+    try do
+      :global.send(name, {:notify, msg})
+      :ok
+    catch
+      _, _ -> :ok
     end
   end
 
-  @doc """
-  Returns a stream that consumes and notifies events to the `manager`.
+  def notify({:via, mod, name}, msg) when is_atom(mod) do
+    try do
+      mod.send(name, {:notify, msg})
+      :ok
+    catch
+      _, _ -> :ok
+    end
+  end
 
-  The stream is a `GenEvent` struct that implements the `Enumerable`
-  protocol. The supported options are:
+  def notify(manager, msg)
+      when is_pid(manager)
+      when is_atom(manager)
+      when tuple_size(manager) == 2 and is_atom(elem(manager, 0)) and is_atom(elem(manager, 1)) do
+    send(manager, {:notify, msg})
+    :ok
+  end
 
-    * `:id` - an id to identify all live stream instances; when an `:id` is
-      given, existing streams can be called with via `cancel_streams`.
+  @doc false
+  @deprecated message
+  @spec sync_notify(manager, term) :: :ok
+  def sync_notify(manager, event) do
+    rpc(manager, {:sync_notify, event})
+  end
 
-    * `:timeout` (Enumerable) - raises if no event arrives in X milliseconds.
+  @doc false
+  @deprecated message
+  @spec ack_notify(manager, term) :: :ok
+  def ack_notify(manager, event) do
+    rpc(manager, {:ack_notify, event})
+  end
 
-    * `:duration` (Enumerable) - only consume events during the X milliseconds
-      from the streaming start.
+  @doc false
+  @deprecated message
+  @spec call(manager, handler, term, timeout) :: term | {:error, term}
+  def call(manager, handler, request, timeout \\ 5000) do
+    try do
+      :gen.call(manager, self(), {:call, handler, request}, timeout)
+    catch
+      :exit, reason ->
+        exit({reason, {__MODULE__, :call, [manager, handler, request, timeout]}})
+    else
+      {:ok, res} -> res
+    end
+  end
 
-    * `:mode` - the mode to consume events, can be `:sync` (default) or
-      `:async`. On sync, the event manager waits for the event to be consumed
-      before moving on to the next event handler.
+  @doc false
+  @deprecated message
+  @spec remove_handler(manager, handler, term) :: term | {:error, term}
+  def remove_handler(manager, handler, args) do
+    rpc(manager, {:delete_handler, handler, args})
+  end
 
-  """
-  def stream(manager, options \\ []) do
-    %GenEvent{manager: manager,
-              id: Keyword.get(options, :id),
-              timeout: Keyword.get(options, :timeout, :infinity),
-              duration: Keyword.get(options, :duration, :infinity),
-              mode: Keyword.get(options, :mode, :sync)}
+  @doc false
+  @deprecated message
+  @spec swap_handler(manager, handler, term, handler, term) :: :ok | {:error, term}
+  def swap_handler(manager, handler1, args1, handler2, args2) do
+    rpc(manager, {:swap_handler, handler1, args1, handler2, args2})
   end
 
-  @doc """
-  Adds a new event handler to the event `manager`.
+  @doc false
+  @deprecated message
+  @spec swap_mon_handler(manager, handler, term, handler, term) :: :ok | {:error, term}
+  def swap_mon_handler(manager, handler1, args1, handler2, args2) do
+    rpc(manager, {:swap_mon_handler, handler1, args1, handler2, args2, self()})
+  end
+
+  @doc false
+  @deprecated message
+  @spec which_handlers(manager) :: [handler]
+  def which_handlers(manager) do
+    rpc(manager, :which_handlers)
+  end
 
-  The event manager will call the `init/1` callback with `args` to
-  initiate the event handler and its internal state.
+  @doc false
+  @deprecated message
+  @spec stop(manager, reason :: term, timeout) :: :ok
+  def stop(manager, reason \\ :normal, timeout \\ :infinity) do
+    :gen.stop(manager, reason, timeout)
+  end
 
-  If `init/1` returns a correct value indicating successful completion,
-  the event manager adds the event handler and this function returns
-  `:ok`. If the callback fails with `reason` or returns `{:error, reason}`,
-  the event handler is ignored and this function returns `{:EXIT, reason}`
-  or `{:error, reason}`, respectively.
+  defp rpc(module, cmd) do
+    {:ok, reply} = :gen.call(module, self(), cmd, :infinity)
+    reply
+  end
 
-  ## Linked handlers
+  ## Init callbacks
 
-  When adding a handler, a `:link` option with value `true` can be given.
-  This means the event handler and the calling process are now linked.
+  require Record
+  Record.defrecordp(:handler, [:module, :id, :state, :pid, :ref])
 
-  If the calling process later terminates with `reason`, the event manager
-  will delete the event handler by calling the `terminate/2` callback with
-  `{:stop, reason}` as argument. If the event handler later is deleted,
-  the event manager sends a message `{:gen_event_EXIT, handler, reason}`
-  to the calling process. Reason is one of the following:
+  @doc false
+  def init_it(starter, :self, name, mod, args, options) do
+    init_it(starter, self(), name, mod, args, options)
+  end
 
-    * `:normal` - if the event handler has been removed due to a call to
-      `remove_handler/3`, or `:remove_handler` has been returned by a callback
-      function
+  def init_it(starter, parent, name, _mod, _args, options) do
+    Process.put(:"$initial_call", {__MODULE__, :init_it, 6})
+    debug = :gen.debug_options(name, options)
+    :proc_lib.init_ack(starter, {:ok, self()})
+    loop(parent, name(name), [], debug, false)
+  end
 
-    * `:shutdown` - if the event handler has been removed because the event
-      manager is terminating
+  @doc false
+  def init_hib(parent, name, handlers, debug) do
+    fetch_msg(parent, name, handlers, debug, true)
+  end
 
-    * `{:swapped, new_handler, pid}` - if the process pid has replaced the
-      event handler by another
+  defp name({:local, name}), do: name
+  defp name({:global, name}), do: name
+  defp name({:via, _, name}), do: name
+  defp name(pid) when is_pid(pid), do: pid
 
-    * a term - if the event handler is removed due to an error. Which term
-      depends on the error
+  ## Loop
 
-  """
-  @spec add_handler(manager, handler, term, [link: boolean]) :: :ok | {:EXIT, term} | {:error, term}
-  def add_handler(manager, handler, args, options \\ []) do
-    case Keyword.get(options, :link, false) do
-      true  -> :gen_event.add_sup_handler(manager, handler, args)
-      false -> :gen_event.add_handler(manager, handler, args)
+  defp loop(parent, name, handlers, debug, true) do
+    :proc_lib.hibernate(__MODULE__, :init_hib, [parent, name, handlers, debug])
+  end
+
+  defp loop(parent, name, handlers, debug, false) do
+    fetch_msg(parent, name, handlers, debug, false)
+  end
+
+  defp fetch_msg(parent, name, handlers, debug, hib) do
+    receive do
+      {:system, from, req} ->
+        :sys.handle_system_msg(req, from, parent, __MODULE__, debug, [name, handlers, hib], hib)
+
+      {:EXIT, ^parent, reason} ->
+        server_terminate(reason, parent, handlers, name)
+
+      msg when debug == [] ->
+        handle_msg(msg, parent, name, handlers, [])
+
+      msg ->
+        debug = :sys.handle_debug(debug, &print_event/3, name, {:in, msg})
+        handle_msg(msg, parent, name, handlers, debug)
     end
   end
 
-  @doc """
-  Sends an event notification to the event `manager`.
+  defp handle_msg(msg, parent, name, handlers, debug) do
+    case msg do
+      {:notify, event} ->
+        {hib, handlers} = server_event(:async, event, handlers, name)
+        loop(parent, name, handlers, debug, hib)
+
+      {_from, _tag, {:notify, event}} ->
+        {hib, handlers} = server_event(:async, event, handlers, name)
+        loop(parent, name, handlers, debug, hib)
+
+      {_from, tag, {:ack_notify, event}} ->
+        reply(tag, :ok)
+        {hib, handlers} = server_event(:ack, event, handlers, name)
+        loop(parent, name, handlers, debug, hib)
+
+      {_from, tag, {:sync_notify, event}} ->
+        {hib, handlers} = server_event(:sync, event, handlers, name)
+        reply(tag, :ok)
+        loop(parent, name, handlers, debug, hib)
+
+      {:DOWN, ref, :process, _pid, reason} = other ->
+        case handle_down(ref, reason, handlers, name) do
+          {:ok, handlers} ->
+            loop(parent, name, handlers, debug, false)
+
+          :error ->
+            {hib, handlers} = server_info(other, handlers, name)
+            loop(parent, name, handlers, debug, hib)
+        end
+
+      {_from, tag, {:call, handler, query}} ->
+        {hib, reply, handlers} = server_call(handler, query, handlers, name)
+        reply(tag, reply)
+        loop(parent, name, handlers, debug, hib)
 
-  The event manager will call `handle_event/2` for each installed event handler.
+      {_from, tag, {:add_handler, handler, args}} ->
+        {hib, reply, handlers} = server_add_handler(handler, args, handlers)
+        reply(tag, reply)
+        loop(parent, name, handlers, debug, hib)
 
-  `notify` is asynchronous and will return immediately after the notification is
-  sent. `notify` will not fail even if the specified event manager does not exist,
-  unless it is specified as `name` (atom).
-  """
-  @spec notify(manager, term) :: :ok
-  defdelegate notify(manager, event), to: :gen_event
+      {_from, tag, {:add_mon_handler, handler, args, notify}} ->
+        {hib, reply, handlers} = server_add_mon_handler(handler, args, handlers, notify)
+        reply(tag, reply)
+        loop(parent, name, handlers, debug, hib)
 
-  @doc """
-  Sends a sync event notification to the event `manager`.
+      {_from, tag, {:add_process_handler, pid, notify}} ->
+        {hib, reply, handlers} = server_add_process_handler(pid, handlers, notify)
+        reply(tag, reply)
+        loop(parent, name, handlers, debug, hib)
 
-  In other words, this function only returns `:ok` after the event manager
-  invokes the `handle_event/2` on each installed event handler.
+      {_from, tag, {:delete_handler, handler, args}} ->
+        {reply, handlers} = server_remove_handler(handler, args, handlers, name)
+        reply(tag, reply)
+        loop(parent, name, handlers, debug, false)
 
-  See `notify/2` for more info.
-  """
-  @spec sync_notify(manager, term) :: :ok
-  defdelegate sync_notify(manager, event), to: :gen_event
+      {_from, tag, {:swap_handler, handler1, args1, handler2, args2}} ->
+        {hib, reply, handlers} =
+          server_swap_handler(handler1, args1, handler2, args2, handlers, nil, name)
 
-  @doc """
-  Makes a synchronous call to the event `handler` installed in `manager`.
+        reply(tag, reply)
+        loop(parent, name, handlers, debug, hib)
 
-  The given `request` is sent and the caller waits until a reply arrives or
-  a timeout occurs. The event manager will call `handle_call/2` to handle
-  the request.
+      {_from, tag, {:swap_mon_handler, handler1, args1, handler2, args2, mon}} ->
+        {hib, reply, handlers} =
+          server_swap_handler(handler1, args1, handler2, args2, handlers, mon, name)
 
-  The return value `reply` is defined in the return value of `handle_call/2`.
-  If the specified event handler is not installed, the function returns
-  `{:error, :bad_module}`.
-  """
-  @spec call(manager, handler, term, timeout) ::  term | {:error, term}
-  def call(manager, handler, request, timeout \\ 5000) do
-    :gen_event.call(manager, handler, request, timeout)
+        reply(tag, reply)
+        loop(parent, name, handlers, debug, hib)
+
+      {_from, tag, :which_handlers} ->
+        reply(tag, server_which_handlers(handlers))
+        loop(parent, name, handlers, debug, false)
+
+      {_from, tag, :get_modules} ->
+        reply(tag, server_get_modules(handlers))
+        loop(parent, name, handlers, debug, false)
+
+      other ->
+        {hib, handlers} = server_info(other, handlers, name)
+        loop(parent, name, handlers, debug, hib)
+    end
   end
 
-  @doc """
-  Cancels all streams currently running with the given `:id`.
+  ## System callbacks
 
-  In order for a stream to be cancelled, an `:id` must be passed
-  when the stream is created via `stream/2`. Passing a stream without
-  an id leads to an argument error.
-  """
-  @spec cancel_streams(t) :: :ok
-  def cancel_streams(%GenEvent{id: nil}) do
-    raise ArgumentError, "cannot cancel streams without an id"
+  @doc false
+  def system_continue(parent, debug, [name, handlers, hib]) do
+    loop(parent, name, handlers, debug, hib)
   end
 
-  def cancel_streams(%GenEvent{manager: manager, id: id}) do
-    handlers = :gen_event.which_handlers(manager)
+  @doc false
+  def system_terminate(reason, parent, _debug, [name, handlers, _hib]) do
+    server_terminate(reason, parent, handlers, name)
+  end
 
-    for {Enumerable.GenEvent, {handler_id, _}} = ref <- handlers,
-        handler_id === id do
-      :gen_event.delete_handler(manager, ref, :remove_handler)
-    end
+  @doc false
+  def system_code_change([name, handlers, hib], module, old_vsn, extra) do
+    handlers =
+      for handler <- handlers do
+        if handler(handler, :module) == module do
+          {:ok, state} = module.code_change(old_vsn, handler(handler, :state), extra)
+          handler(handler, state: state)
+        else
+          handler
+        end
+      end
 
-    :ok
+    {:ok, [name, handlers, hib]}
   end
 
-  @doc """
-  Removes an event handler from the event `manager`.
+  @doc false
+  def system_get_state([_name, handlers, _hib]) do
+    tuples =
+      for handler(module: mod, id: id, state: state) <- handlers do
+        {mod, id, state}
+      end
 
-  The event manager will call `terminate/2` to terminate the event handler
-  and return the callback value. If the specified event handler is not
-  installed, the function returns `{:error, :module_not_found}`.
-  """
-  @spec remove_handler(manager, handler, term) :: term | {:error, term}
-  def remove_handler(manager, handler, args) do
-    :gen_event.delete_handler(manager, handler, args)
+    {:ok, tuples}
   end
 
-  @doc """
-  Replaces an old event handler with a new one in the event `manager`.
+  @doc false
+  def system_replace_state(fun, [name, handlers, hib]) do
+    {handlers, states} =
+      :lists.unzip(
+        for handler <- handlers do
+          handler(module: mod, id: id, state: state) = handler
+          cur = {mod, id, state}
+
+          try do
+            new = {^mod, ^id, new_state} = fun.(cur)
+            {handler(handler, state: new_state), new}
+          catch
+            _, _ ->
+              {handler, cur}
+          end
+        end
+      )
+
+    {:ok, states, [name, handlers, hib]}
+  end
+
+  # Keeping deprecated format_status/2 since the current implementation is not
+  # compatible with format_status/1 and GenEvent is deprecated anyway
+  @doc false
+  def format_status(opt, status_data) do
+    [pdict, sys_state, parent, _debug, [name, handlers, _hib]] = status_data
+    header = :gen.format_status_header(~c"Status for event handler", name)
+
+    formatted =
+      for handler <- handlers do
+        handler(module: module, state: state) = handler
+
+        if function_exported?(module, :format_status, 2) do
+          try do
+            state = module.format_status(opt, [pdict, state])
+            handler(handler, state: state)
+          catch
+            _, _ -> handler
+          end
+        else
+          handler
+        end
+      end
 
-  First, the old event handler is deleted by calling `terminate/2` with
-  the given `args1` and collects the return value. Then the new event handler
-  is added and initiated by calling `init({args2, term}), where term is the
-  return value of calling `terminate/2` in the old handler. This makes it
-  possible to transfer information from one handler to another.
+    [
+      header: header,
+      data: [{~c"Status", sys_state}, {~c"Parent", parent}],
+      items: {~c"Installed handlers", formatted}
+    ]
+  end
 
-  The new handler will be added even if the specified old event handler
-  is not installed in which case `term = :error` or if the handler fails to
-  terminate with a given reason.
+  ## Loop helpers
 
-  If there was a linked connection between handler1 and a process pid, there
-  will be a link connection between handler2 and pid instead. A new link in
-  between the caller process and the new handler can also be set with by
-  giving `link: true` as option. See `add_handler/4` for more information.
+  defp print_event(dev, {:in, msg}, name) do
+    case msg do
+      {:notify, event} ->
+        IO.puts(dev, "*DBG* #{inspect(name)} got event #{inspect(event)}")
 
-  If `init/1` in the second handler returns a correct value, this function
-  returns `:ok`.
-  """
-  @spec swap_handler(manager, handler, term, handler, term, [link: boolean]) :: :ok | {:error, term}
-  def swap_handler(manager, handler1, args1, handler2, args2, options \\ []) do
-    case Keyword.get(options, :link, false) do
-      true  -> :gen_event.swap_sup_handler(manager, {handler1, args1}, {handler2, args2})
-      false -> :gen_event.swap_handler(manager, {handler1, args1}, {handler2, args2})
+      {_, _, {:call, handler, query}} ->
+        IO.puts(
+          dev,
+          "*DBG* #{inspect(name)} (handler #{inspect(handler)}) got call #{inspect(query)}"
+        )
+
+      _ ->
+        IO.puts(dev, "*DBG* #{inspect(name)} got #{inspect(msg)}")
     end
   end
 
-  @doc """
-  Returns a list of all event handlers installed in the `manager`.
-  """
-  @spec which_handlers(manager) :: [handler]
-  defdelegate which_handlers(manager), to: :gen_event
+  defp print_event(dev, dbg, name) do
+    IO.puts(dev, "*DBG* #{inspect(name)}: #{inspect(dbg)}")
+  end
 
-  @doc """
-  Terminates the event `manager`.
+  defp server_add_handler({module, id}, args, handlers) do
+    handler = handler(module: module, id: {module, id})
+    do_add_handler(module, handler, args, handlers, :ok)
+  end
 
-  Before terminating, the event manager will call `terminate(:stop, ...)`
-  for each installed event handler.
-  """
-  @spec stop(manager) :: :ok
-  defdelegate stop(manager), to: :gen_event
-end
+  defp server_add_handler(module, args, handlers) do
+    handler = handler(module: module, id: module)
+    do_add_handler(module, handler, args, handlers, :ok)
+  end
 
-defimpl Enumerable, for: GenEvent do
-  use GenEvent
+  defp server_add_mon_handler({module, id}, args, handlers, notify) do
+    ref = Process.monitor(notify)
+    handler = handler(module: module, id: {module, id}, pid: notify, ref: ref)
+    do_add_handler(module, handler, args, handlers, :ok)
+  end
 
-  @doc false
-  def init({_mode, mon_pid, _pid, ref} = state) do
-    # Tell the mon_pid we are good to go, and send self() so that this handler
-    # can be removed later without using the managers name.
-    send(mon_pid, {:UP, ref, self()})
-    {:ok, state}
+  defp server_add_mon_handler(module, args, handlers, notify) do
+    ref = Process.monitor(notify)
+    handler = handler(module: module, id: module, pid: notify, ref: ref)
+    do_add_handler(module, handler, args, handlers, :ok)
   end
 
-  @doc false
-  def handle_event(event, {:sync, mon_pid, pid, ref} = state) do
-    sync = Process.monitor(mon_pid)
-    send pid, {ref, sync, event}
-    receive do
-      {^sync, :done} ->
-        Process.demonitor(sync, [:flush])
-        :remove_handler
-      {^sync, :next} ->
-        Process.demonitor(sync, [:flush])
-        {:ok, state}
-      {:DOWN, ^sync, _, _, _} ->
-        {:ok, state}
+  defp server_add_process_handler(pid, handlers, notify) do
+    ref = Process.monitor(pid)
+    handler = handler(module: GenEvent.Stream, id: {self(), ref}, pid: notify, ref: ref)
+    do_add_handler(GenEvent.Stream, handler, {pid, ref}, handlers, {self(), ref})
+  end
+
+  defp server_remove_handler(module, args, handlers, name) do
+    do_take_handler(module, args, handlers, name, :remove, :normal)
+  end
+
+  defp server_swap_handler(module1, args1, module2, args2, handlers, sup, name) do
+    {state, handlers} =
+      do_take_handler(module1, args1, handlers, name, :swapped, {:swapped, module2, sup})
+
+    if sup do
+      server_add_mon_handler(module2, {args2, state}, handlers, sup)
+    else
+      server_add_handler(module2, {args2, state}, handlers)
+    end
+  end
+
+  defp server_info(event, handlers, name) do
+    handlers = :lists.reverse(handlers)
+    server_notify(event, :handle_info, handlers, name, handlers, [], false)
+  end
+
+  defp server_event(mode, event, handlers, name) do
+    {handlers, streams} = server_split_process_handlers(mode, event, handlers, [], [])
+    {hib, handlers} = server_notify(event, :handle_event, handlers, name, handlers, [], false)
+    {hib, server_collect_process_handlers(mode, event, streams, handlers, name)}
+  end
+
+  defp server_split_process_handlers(mode, event, [handler | t], handlers, streams) do
+    case handler(handler, :id) do
+      {pid, _ref} when is_pid(pid) ->
+        server_process_notify(mode, event, handler)
+        server_split_process_handlers(mode, event, t, handlers, [handler | streams])
+
+      _ ->
+        server_split_process_handlers(mode, event, t, [handler | handlers], streams)
     end
   end
 
-  def handle_event(event, {:async, _mon_pid, pid, ref} = state) do
-    send pid, {ref, nil, event}
-    {:ok, state}
+  defp server_split_process_handlers(_mode, _event, [], handlers, streams) do
+    {handlers, streams}
   end
 
-  def reduce(stream, acc, fun) do
-    start_fun = fn() -> start(stream) end
-    next_fun = &next(stream, &1)
-    stop_fun = &stop(stream, &1)
-    Stream.resource(start_fun, next_fun, stop_fun).(acc, wrap_reducer(fun))
+  defp server_process_notify(mode, event, handler(state: {pid, ref})) do
+    send(pid, {self(), {self(), ref}, {mode_to_tag(mode), event}})
   end
 
-  def count(_stream) do
-    {:error, __MODULE__}
+  defp mode_to_tag(:ack), do: :ack_notify
+  defp mode_to_tag(:sync), do: :sync_notify
+  defp mode_to_tag(:async), do: :notify
+
+  defp server_notify(event, fun, [handler | t], name, handlers, acc, hib) do
+    case server_update(handler, fun, event, name, handlers) do
+      {new_hib, handler} ->
+        server_notify(event, fun, t, name, handlers, [handler | acc], hib or new_hib)
+
+      :error ->
+        server_notify(event, fun, t, name, handlers, acc, hib)
+    end
   end
 
-  def member?(_stream, _item) do
-    {:error, __MODULE__}
+  defp server_notify(_, _, [], _, _, acc, hib) do
+    {hib, acc}
   end
 
-  defp wrap_reducer(fun) do
-    fn
-      {nil, _manager, event}, acc ->
-        fun.(event, acc)
-      {ref, manager, event}, acc ->
-        try do
-          fun.(event, acc)
-        after
-          send manager, {ref, :next}
+  defp server_update(handler, fun, event, name, _handlers) do
+    handler(module: module, state: state) = handler
+
+    case do_handler(module, fun, [event, state]) do
+      {:ok, res} ->
+        case res do
+          {:ok, state} ->
+            {false, handler(handler, state: state)}
+
+          {:ok, state, :hibernate} ->
+            {true, handler(handler, state: state)}
+
+          :remove_handler ->
+            do_terminate(handler, :remove_handler, event, name, :normal)
+            :error
+
+          other ->
+            reason = {:bad_return_value, other}
+            do_terminate(handler, {:error, reason}, event, name, reason)
+            :error
         end
+
+      {:error, reason} ->
+        do_terminate(handler, {:error, reason}, event, name, reason)
+        :error
     end
   end
 
-  defp start(%{manager: manager, id: id, duration: duration, mode: mode} = stream) do
-    {mon_pid, mon_ref} = add_handler(mode, manager, id, duration)
-    send mon_pid, {:UP, mon_ref, self()}
+  defp server_collect_process_handlers(:async, event, [handler | t], handlers, name) do
+    server_collect_process_handlers(:async, event, t, [handler | handlers], name)
+  end
+
+  defp server_collect_process_handlers(mode, event, [handler | t], handlers, name)
+       when mode in [:sync, :ack] do
+    handler(ref: ref, id: id) = handler
 
     receive do
-      # The subscription process gave us a go.
-      {:UP, ^mon_ref, manager_pid} ->
-        {mon_ref, mon_pid, manager_pid}
-      # The subscription process died due to an abnormal reason.
-      {:DOWN, ^mon_ref, _, _, reason} ->
-        exit({reason, {__MODULE__, :start, [stream]}})
+      {^ref, :ok} ->
+        server_collect_process_handlers(mode, event, t, [handler | handlers], name)
+
+      {_from, tag, {:delete_handler, ^id, args}} ->
+        do_terminate(handler, args, :remove, name, :normal)
+        reply(tag, :ok)
+        server_collect_process_handlers(mode, event, t, handlers, name)
+
+      {:DOWN, ^ref, _, _, reason} ->
+        do_terminate(handler, {:stop, reason}, :DOWN, name, :shutdown)
+        server_collect_process_handlers(mode, event, t, handlers, name)
     end
   end
 
-  defp next(%{timeout: timeout} = stream, {mon_ref, mon_pid, manager_pid} = acc) do
-    # If :DOWN is received must resend it to self so that stop/2 can receive it
-    # and know that the handler has been removed.
-    receive do
-      {:DOWN, ^mon_ref, _, _, :normal} ->
-        send(self(), {:DOWN, mon_ref, :process, mon_pid, :normal})
-        nil
-      {:DOWN, ^mon_ref, _, _, reason} ->
-        send(self(), {:DOWN, mon_ref, :process, mon_pid, :normal})
-        exit({reason, {__MODULE__, :next, [stream, acc]}})
-      {^mon_ref, sync_ref, event} ->
-        {{sync_ref, manager_pid, event}, acc}
-    after
-      timeout ->
-        exit({:timeout, {__MODULE__, :next, [stream, acc]}})
+  defp server_collect_process_handlers(_mode, _event, [], handlers, _name) do
+    handlers
+  end
+
+  defp server_call(module, query, handlers, name) do
+    case :lists.keyfind(module, handler(:id) + 1, handlers) do
+      false ->
+        {false, {:error, :not_found}, handlers}
+
+      handler ->
+        case server_call_update(handler, query, name, handlers) do
+          {{hib, handler}, reply} ->
+            {hib, reply, :lists.keyreplace(module, handler(:id) + 1, handlers, handler)}
+
+          {:error, reply} ->
+            {false, reply, :lists.keydelete(module, handler(:id) + 1, handlers)}
+        end
     end
   end
 
-  defp stop(%{mode: mode} = stream, {mon_ref, mon_pid, manager_pid} = acc) do
-    case remove_handler(mon_ref, mon_pid, manager_pid) do
-      :ok when mode == :async ->
-        flush_events(mon_ref)
-      :ok ->
-        :ok
+  defp server_call_update(handler, query, name, _handlers) do
+    handler(module: module, state: state) = handler
+
+    case do_handler(module, :handle_call, [query, state]) do
+      {:ok, res} ->
+        case res do
+          {:ok, reply, state} ->
+            {{false, handler(handler, state: state)}, reply}
+
+          {:ok, reply, state, :hibernate} ->
+            {{true, handler(handler, state: state)}, reply}
+
+          {:remove_handler, reply} ->
+            do_terminate(handler, :remove_handler, query, name, :normal)
+            {:error, reply}
+
+          other ->
+            reason = {:bad_return_value, other}
+            do_terminate(handler, {:error, reason}, query, name, reason)
+            {:error, {:error, reason}}
+        end
+
       {:error, reason} ->
-        exit({reason, {__MODULE__, :stop, [stream, acc]}})
+        do_terminate(handler, {:error, reason}, query, name, reason)
+        {:error, {:error, reason}}
     end
   end
 
-  defp add_handler(mode, manager, id, duration) do
-    parent = self()
-
-    # The subscription is managed by another process, that dies if
-    # the handler dies, and is killed when there is a need to remove
-    # the subscription.
-    spawn_monitor(fn ->
-      # It is possible that the handler could be removed, and then the GenEvent
-      # could exit before this process has exited normally. Because the removal
-      # does not cause an unlinking this process would exit with the same
-      # reason. Trapping exits ensures that no errors is raised in this case.
-      Process.flag(:trap_exit, true)
-      parent_ref = Process.monitor(parent)
-
-      # Receive the notification from the parent, unless it died.
-      mon_ref = receive do
-        {:UP, ref, ^parent} -> ref
-        {:DOWN, ^parent_ref, _, _, _} -> exit(:normal)
-      end
+  defp server_get_modules(handlers) do
+    for(handler(module: module) <- handlers, do: module)
+    |> :ordsets.from_list()
+    |> :ordsets.to_list()
+  end
 
-      cancel = cancel_ref(id, mon_ref)
-      :ok = :gen_event.add_sup_handler(manager, {__MODULE__, cancel},
-                                       {mode, self(), parent, mon_ref})
-
-      receive do
-        # This message is already in the mailbox if we got this far.
-        {:UP, ^mon_ref, manager_pid} ->
-          send(parent, {:UP, mon_ref, manager_pid})
-          receive do
-            # The stream has finished, remove the handler.
-            {:DONE, ^mon_ref} ->
-              exit_handler(manager_pid, parent_ref, cancel)
-
-            # If the parent died, we can exit normally.
-            {:DOWN, ^parent_ref, _, _, _} ->
-              exit(:normal)
-
-            # reason should be normal unless the handler is swapped.
-            {:gen_event_EXIT, {__MODULE__, ^cancel}, reason} ->
-              exit(reason)
-
-            # Exit if the manager dies, so the streamer is notified.
-            {:EXIT, ^manager_pid, :noconnection} ->
-              exit({:nodedown, node(manager_pid)})
-
-            {:EXIT, ^manager_pid, reason} ->
-              exit(reason)
-          after
-            # Our time is over, notify the parent.
-            duration -> exit(:normal)
-          end
+  defp server_which_handlers(handlers) do
+    for handler(id: id) <- handlers, do: id
+  end
+
+  defp server_terminate(reason, _parent, handlers, name) do
+    _ =
+      for handler <- handlers do
+        do_terminate(handler, :stop, :stop, name, :shutdown)
       end
-    end)
+
+    exit(reason)
   end
 
-  defp cancel_ref(nil, mon_ref), do: mon_ref
-  defp cancel_ref(id, mon_ref),  do: {id, mon_ref}
+  defp reply({from, ref}, msg) do
+    send(from, {ref, msg})
+  end
 
-  defp exit_handler(manager_pid, parent_ref, cancel) do
-    # Send exit signal so manager removes handler.
-    Process.exit(manager_pid, :shutdown)
-    receive do
-      # If the parent died, we can exit normally.
-      {:DOWN, ^parent_ref, _, _, _} ->
-        exit(:normal)
-
-      # Probably the reason is :shutdown, which occurs when the manager receives
-      # an exit signal from a handler supervising process. However whatever the
-      # reason the handler has been removed so it is ok.
-      {:gen_event_EXIT, {__MODULE__, ^cancel}, _} ->
-        exit(:normal)
-
-      # The connection broke, perhaps the handler might try to forward events
-      # before it removes the handler, so must exit abnormally.
-      {:EXIT, ^manager_pid, :noconnection} ->
-        exit({:nodedown, node(manager_pid)})
-
-      # The manager has exited but don't exit abnormally as the handler has died
-      # with the manager and all expected events have been handled. This is ok.
-      {:EXIT, ^manager_pid, _} ->
-        exit(:normal)
+  defp handle_down(ref, reason, handlers, name) do
+    case :lists.keyfind(ref, handler(:ref) + 1, handlers) do
+      false ->
+        :error
+
+      handler ->
+        do_terminate(handler, {:stop, reason}, :DOWN, name, :shutdown)
+        {:ok, :lists.keydelete(ref, handler(:ref) + 1, handlers)}
     end
   end
 
-  defp remove_handler(mon_ref, mon_pid, manager_pid) do
-    send(mon_pid, {:DONE, mon_ref})
-    receive do
-      {^mon_ref, sync, _} when sync != nil ->
-        send(manager_pid, {sync, :done})
-        Process.demonitor(mon_ref, [:flush])
-        :ok
-      {:DOWN, ^mon_ref, _, _, :normal} ->
-        :ok
-      {:DOWN, ^mon_ref, _, _, reason} ->
-        {:error, reason}
+  defp do_add_handler(module, handler, arg, handlers, succ) do
+    case :lists.keyfind(handler(handler, :id), handler(:id) + 1, handlers) do
+      false ->
+        case do_handler(module, :init, [arg]) do
+          {:ok, res} ->
+            case res do
+              {:ok, state} ->
+                {false, succ, [handler(handler, state: state) | handlers]}
+
+              {:ok, state, :hibernate} ->
+                {true, succ, [handler(handler, state: state) | handlers]}
+
+              {:error, _} = error ->
+                {false, error, handlers}
+
+              other ->
+                {false, {:error, {:bad_return_value, other}}, handlers}
+            end
+
+          {:error, _} = error ->
+            {false, error, handlers}
+        end
+
+      _ ->
+        {false, {:error, :already_present}, handlers}
     end
   end
 
-  defp flush_events(mon_ref) do
-    receive do
-      {^mon_ref, _, _} ->
-        flush_events(mon_ref)
-    after
-      0 -> :ok
+  defp do_take_handler(module, args, handlers, name, last_in, reason) do
+    case :lists.keytake(module, handler(:id) + 1, handlers) do
+      {:value, handler, handlers} ->
+        {do_terminate(handler, args, last_in, name, reason), handlers}
+
+      false ->
+        {{:error, :not_found}, handlers}
+    end
+  end
+
+  defp do_terminate(handler, arg, last_in, name, reason) do
+    handler(module: module, state: state) = handler
+
+    res =
+      case do_handler(module, :terminate, [arg, state]) do
+        {:ok, res} -> res
+        {:error, _} = error -> error
+      end
+
+    report_terminate(handler, reason, state, last_in, name)
+    res
+  end
+
+  defp do_handler(mod, fun, args) do
+    try do
+      apply(mod, fun, args)
+    catch
+      :throw, val -> {:ok, val}
+      :error, val -> {:error, {val, __STACKTRACE__}}
+      :exit, val -> {:error, val}
+    else
+      res -> {:ok, res}
+    end
+  end
+
+  defp report_terminate(handler, reason, state, last_in, name) do
+    report_error(handler, reason, state, last_in, name)
+
+    if ref = handler(handler, :ref) do
+      Process.demonitor(ref, [:flush])
+    end
+
+    if pid = handler(handler, :pid) do
+      send(pid, {:gen_event_EXIT, handler(handler, :id), reason})
+    end
+  end
+
+  defp report_error(_handler, :normal, _, _, _), do: :ok
+  defp report_error(_handler, :shutdown, _, _, _), do: :ok
+  defp report_error(_handler, {:swapped, _, _}, _, _, _), do: :ok
+
+  defp report_error(handler, reason, state, last_in, name) do
+    reason =
+      case reason do
+        {:undef, [{m, f, a, _} | _] = mfas} ->
+          cond do
+            :code.is_loaded(m) == false ->
+              {:"module could not be loaded", mfas}
+
+            function_exported?(m, f, length(a)) ->
+              reason
+
+            true ->
+              {:"function not exported", mfas}
+          end
+
+        _ ->
+          reason
+      end
+
+    formatted = report_status(handler, state)
+
+    :error_logger.error_msg(
+      ~c"** gen_event handler ~p crashed.~n" ++
+        ~c"** Was installed in ~p~n" ++
+        ~c"** Last event was: ~p~n" ++ ~c"** When handler state == ~p~n" ++ ~c"** Reason == ~p~n",
+      [handler(handler, :id), name, last_in, formatted, reason]
+    )
+  end
+
+  defp report_status(handler(module: module), state) do
+    if function_exported?(module, :format_status, 2) do
+      try do
+        module.format_status(:terminate, [Process.get(), state])
+      catch
+        _, _ -> state
+      end
+    else
+      state
     end
   end
 end
diff --git a/lib/elixir/lib/gen_event/stream.ex b/lib/elixir/lib/gen_event/stream.ex
new file mode 100644
index 00000000000..2b906bf54cd
--- /dev/null
+++ b/lib/elixir/lib/gen_event/stream.ex
@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule GenEvent.Stream do
+  @moduledoc false
+  @moduledoc deprecated: "This functionality is no longer supported"
+  defstruct manager: nil, timeout: :infinity
+
+  @type t :: %__MODULE__{manager: GenEvent.manager(), timeout: timeout}
+
+  @doc false
+  def init({_pid, _ref} = state) do
+    {:ok, state}
+  end
+
+  @doc false
+  def handle_event(event, _state) do
+    # We do this to trick Dialyzer to not complain about non-local returns.
+    case :erlang.phash2(1, 1) do
+      0 -> exit({:bad_event, event})
+      1 -> :remove_handler
+    end
+  end
+
+  @doc false
+  def handle_call(msg, _state) do
+    # We do this to trick Dialyzer to not complain about non-local returns.
+    reason = {:bad_call, msg}
+
+    case :erlang.phash2(1, 1) do
+      0 -> exit(reason)
+      1 -> {:remove_handler, reason}
+    end
+  end
+
+  @doc false
+  def handle_info(_msg, state) do
+    {:ok, state}
+  end
+
+  @doc false
+  def terminate(_reason, _state) do
+    :ok
+  end
+
+  @doc false
+  def code_change(_old, state, _extra) do
+    {:ok, state}
+  end
+end
+
+defimpl Enumerable, for: GenEvent.Stream do
+  @moduledoc false
+  @moduledoc deprecated: "This functionality is no longer supported"
+
+  def reduce(stream, acc, fun) do
+    start_fun = fn -> start(stream) end
+    next_fun = &next(stream, &1)
+    stop_fun = &stop(stream, &1)
+    Stream.resource(start_fun, next_fun, stop_fun).(acc, wrap_reducer(fun))
+  end
+
+  def count(_stream) do
+    {:error, __MODULE__}
+  end
+
+  def member?(_stream, _item) do
+    {:error, __MODULE__}
+  end
+
+  def slice(_stream) do
+    {:error, __MODULE__}
+  end
+
+  defp wrap_reducer(fun) do
+    fn
+      {:ack, manager, ref, event}, acc ->
+        send(manager, {ref, :ok})
+        fun.(event, acc)
+
+      {:async, _manager, _ref, event}, acc ->
+        fun.(event, acc)
+
+      {:sync, manager, ref, event}, acc ->
+        try do
+          fun.(event, acc)
+        after
+          send(manager, {ref, :ok})
+        end
+    end
+  end
+
+  defp start(%{manager: manager} = stream) do
+    try do
+      {:ok, {pid, ref}} =
+        :gen.call(manager, self(), {:add_process_handler, self(), self()}, :infinity)
+
+      mon_ref = Process.monitor(pid)
+      {pid, ref, mon_ref}
+    catch
+      :exit, reason -> exit({reason, {__MODULE__, :start, [stream]}})
+    end
+  end
+
+  defp next(%{timeout: timeout} = stream, {pid, ref, mon_ref} = acc) do
+    self = self()
+
+    receive do
+      # Got an async event.
+      {_from, {^pid, ^ref}, {:notify, event}} ->
+        {[{:async, pid, ref, event}], acc}
+
+      # Got a sync event.
+      {_from, {^pid, ^ref}, {:sync_notify, event}} ->
+        {[{:sync, pid, ref, event}], acc}
+
+      # Got an ack event.
+      {_from, {^pid, ^ref}, {:ack_notify, event}} ->
+        {[{:ack, pid, ref, event}], acc}
+
+      # The handler was removed. Stop iteration, resolve the
+      # event later. We need to demonitor now, otherwise DOWN
+      # appears with higher priority in the shutdown process.
+      {:gen_event_EXIT, {^pid, ^ref}, _reason} = event ->
+        Process.demonitor(mon_ref, [:flush])
+        send(self, event)
+        {:halt, {:removed, acc}}
+
+      # The manager died. Stop iteration, resolve the event later.
+      {:DOWN, ^mon_ref, _, _, _} = event ->
+        send(self, event)
+        {:halt, {:removed, acc}}
+    after
+      timeout ->
+        exit({:timeout, {__MODULE__, :next, [stream, acc]}})
+    end
+  end
+
+  # If we reach this branch, we know the handler was already
+  # removed, so we don't trigger a request for doing so.
+  defp stop(stream, {:removed, {pid, ref, mon_ref} = acc}) do
+    case wait_for_handler_removal(pid, ref, mon_ref) do
+      :ok ->
+        flush_events(ref)
+
+      {:error, reason} ->
+        exit({reason, {__MODULE__, :stop, [stream, acc]}})
+    end
+  end
+
+  # If we reach this branch, the handler was not removed yet,
+  # so we trigger a request for doing so.
+  defp stop(stream, {pid, ref, _} = acc) do
+    _ = :gen_event.delete_handler(pid, {pid, ref}, :shutdown)
+    stop(stream, {:removed, acc})
+  end
+
+  defp wait_for_handler_removal(pid, ref, mon_ref) do
+    receive do
+      {:gen_event_EXIT, {^pid, ^ref}, _reason} ->
+        Process.demonitor(mon_ref, [:flush])
+        :ok
+
+      {:DOWN, ^mon_ref, _, _, reason} ->
+        {:error, reason}
+    end
+  end
+
+  defp flush_events(ref) do
+    receive do
+      {_from, {_pid, ^ref}, {notify, _event}}
+      when notify in [:notify, :ack_notify, :sync_notify] ->
+        flush_events(ref)
+    after
+      0 -> :ok
+    end
+  end
+end
diff --git a/lib/elixir/lib/gen_server.ex b/lib/elixir/lib/gen_server.ex
index faeb3344aab..7aec82f93ba 100644
--- a/lib/elixir/lib/gen_server.ex
+++ b/lib/elixir/lib/gen_server.ex
@@ -1,207 +1,857 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule GenServer do
   @moduledoc """
   A behaviour module for implementing the server of a client-server relation.
 
-  A GenServer is a process as any other Elixir process and it can be used
+  A GenServer is a process like any other Elixir process and it can be used
   to keep state, execute code asynchronously and so on. The advantage of using
   a generic server process (GenServer) implemented using this module is that it
   will have a standard set of interface functions and include functionality for
   tracing and error reporting. It will also fit into a supervision tree.
 
+  ```mermaid
+  graph BT
+      C(Client #3) ~~~ B(Client #2) ~~~ A(Client #1)
+      A & B & C -->|request| GenServer
+      GenServer -.->|reply| A & B & C
+  ```
+
   ## Example
 
   The GenServer behaviour abstracts the common client-server interaction.
-  Developer are only required to implement the callbacks and functionality they are
-  interested in.
+  Developers are only required to implement the callbacks and functionality
+  they are interested in.
 
   Let's start with a code example and then explore the available callbacks.
-  Imagine we want a GenServer that works like a stack, allowing us to push
-  and pop items:
+  Imagine we want to implement a service with a GenServer that works
+  like a stack, allowing us to push and pop elements. We'll customize a
+  generic GenServer with our own module by implementing three callbacks.
+
+  `c:init/1` transforms our initial argument to the initial state for the
+  GenServer. `c:handle_call/3` fires when the server receives a synchronous
+  `pop` message, popping an element from the stack and returning it to the
+  user. `c:handle_cast/2` will fire when the server receives an asynchronous
+  `push` message, pushing an element onto the stack:
 
       defmodule Stack do
         use GenServer
 
         # Callbacks
 
-        def handle_call(:pop, _from, [h|t]) do
-          {:reply, h, t}
+        @impl true
+        def init(elements) do
+          initial_state = String.split(elements, ",", trim: true)
+          {:ok, initial_state}
+        end
+
+        @impl true
+        def handle_call(:pop, _from, state) do
+          [to_caller | new_state] = state
+          {:reply, to_caller, new_state}
         end
 
-        def handle_cast({:push, item}, state) do
-          {:noreply, [item|state]}
+        @impl true
+        def handle_cast({:push, element}, state) do
+          new_state = [element | state]
+          {:noreply, new_state}
         end
       end
 
+  We leave the process machinery of startup, message passing, and the message
+  loop to the GenServer behaviour and focus only on the stack
+  implementation. We can now use the GenServer API to interact with
+  the service by creating a process and sending it messages:
+
       # Start the server
-      {:ok, pid} = GenServer.start_link(Stack, [:hello])
+      {:ok, pid} = GenServer.start_link(Stack, "hello,world")
 
       # This is the client
       GenServer.call(pid, :pop)
-      #=> :hello
+      #=> "hello"
 
-      GenServer.cast(pid, {:push, :world})
+      GenServer.cast(pid, {:push, "elixir"})
       #=> :ok
 
       GenServer.call(pid, :pop)
-      #=> :world
+      #=> "elixir"
+
+  We start our `Stack` by calling `start_link/2`, passing the module
+  with the server implementation and its initial argument with a
+  comma-separated list of elements. The GenServer behaviour calls the
+  `c:init/1` callback to establish the initial GenServer state. From
+  this point on, the GenServer has control so we interact with it by
+  sending two types of messages on the client. **call** messages expect
+  a reply from the server (and are therefore synchronous) while **cast**
+  messages do not.
+
+  Each call to `GenServer.call/3` results in a message
+  that must be handled by the `c:handle_call/3` callback in the GenServer.
+  A `cast/2` message must be handled by `c:handle_cast/2`. `GenServer`
+  supports 8 callbacks, but only `c:init/1` is required.
+
+  > #### `use GenServer` {: .info}
+  >
+  > When you `use GenServer`, the `GenServer` module will
+  > set `@behaviour GenServer` and define a `child_spec/1`
+  > function, so your module can be used as a child
+  > in a supervision tree.
 
-  We start our `Stack` by calling `start_link/3`, passing the module
-  with the server implementation and its initial argument (a list
-  representing the stack containing the item `:hello`). We can primarily
-  interact with the server by sending two types of messages. **call**
-  messages expect a reply from the server (and are therefore synchronous)
-  while **cast** messages do not.
+  ## Client / Server APIs
 
-  Every time you do a `GenServer.call/3`, the client will send a message
-  that must be handled by the `handle_call/3` callback in the GenServer.
-  A `cast/2` message must be handled by `handle_cast/2`.
+  Although in the example above we have used `GenServer.start_link/3` and
+  friends to directly start and communicate with the server, most of the
+  time we don't call the `GenServer` functions directly. Instead, we wrap
+  the calls in new functions representing the public API of the server.
+  These thin wrappers are called the **client API**.
 
-  ## Callbacks
+  Here is a better implementation of our Stack module:
 
-  There are 6 callbacks required to be implemented in a `GenServer`. By
-  adding `use GenServer` to your module, Elixir will automatically define
-  all 6 callbacks for you, leaving it up to you to implement the ones
-  you want to customize. The callbacks are:
+      defmodule Stack do
+        use GenServer
 
-    * `init(args)` - invoked when the server is started.
+        # Client
 
-      It must return:
+        def start_link(default) when is_binary(default) do
+          GenServer.start_link(__MODULE__, default)
+        end
 
-      -  `{:ok, state}`
-      -  `{:ok, state, timeout}`
-      -  `:ignore`
-      -  `{:stop, reason}`
+        def push(pid, element) do
+          GenServer.cast(pid, {:push, element})
+        end
+
+        def pop(pid) do
+          GenServer.call(pid, :pop)
+        end
+
+        # Server (callbacks)
+
+        @impl true
+        def init(elements) do
+          initial_state = String.split(elements, ",", trim: true)
+          {:ok, initial_state}
+        end
+
+        @impl true
+        def handle_call(:pop, _from, state) do
+          [to_caller | new_state] = state
+          {:reply, to_caller, new_state}
+        end
+
+        @impl true
+        def handle_cast({:push, element}, state) do
+          new_state = [element | state]
+          {:noreply, new_state}
+        end
+      end
+
+  In practice, it is common to have both server and client functions in
+  the same module. If the server and/or client implementations are growing
+  complex, you may want to have them in different modules.
 
-    * `handle_call(msg, {from, ref}, state)` and `handle_cast(msg, state)` -
-      invoked to handle call (sync) and cast (async) messages.
+  The following diagram summarizes the interactions between client and server.
+  Both Client and Server are processes and communication happens via messages
+  (continuous line). The Server <-> Module interaction happens when the
+  GenServer process calls your code (dotted lines):
 
-      It must return:
+  ```mermaid
+  sequenceDiagram
+      participant C as Client (Process)
+      participant S as Server (Process)
+      participant M as Module (Code)
 
-      -  `{:reply, reply, new_state}`
-      -  `{:reply, reply, new_state, timeout}`
-      -  `{:reply, reply, new_state, :hibernate}`
-      -  `{:noreply, new_state}`
-      -  `{:noreply, new_state, timeout}`
-      -  `{:noreply, new_state, :hibernate}`
-      -  `{:stop, reason, new_state}`
-      -  `{:stop, reason, reply, new_state}`
+      note right of C: Typically started by a supervisor
+      C->>+S: GenServer.start_link(module, arg, options)
+      S-->>+M: init(arg)
+      M-->>-S: {:ok, state} | :ignore | {:error, reason}
+      S->>-C: {:ok, pid} | :ignore | {:error, reason}
 
-    * `handle_info(msg, state)` - invoked to handle all other messages which
-      are received by the process.
+      note right of C: call is synchronous
+      C->>+S: GenServer.call(pid, message)
+      S-->>+M: handle_call(message, from, state)
+      M-->>-S: {:reply, reply, state} | {:stop, reason, reply, state}
+      S->>-C: reply
 
-      It must return:
+      note right of C: cast is asynchronous
+      C-)S: GenServer.cast(pid, message)
+      S-->>+M: handle_cast(message, state)
+      M-->>-S: {:noreply, state} | {:stop, reason, state}
 
-      -  `{:noreply, state}`
-      -  `{:noreply, state, timeout}`
-      -  `{:stop, reason, state}`
+      note right of C: send is asynchronous
+      C-)S: Kernel.send(pid, message)
+      S-->>+M: handle_info(message, state)
+      M-->>-S: {:noreply, state} | {:stop, reason, state}
+  ```
 
-    * `terminate(reason, state)` - called when the server is about to
-      terminate, useful for cleaning up. It must return `:ok`.
+  ## How to supervise
 
-    * `code_change(old_vsn, state, extra)` - called when the application
-      code is being upgraded live (hot code swapping).
+  A `GenServer` is most commonly started under a supervision tree.
+  When we invoke `use GenServer`, it automatically defines a `child_spec/1`
+  function that allows us to start the `Stack` directly under a supervisor.
+  To start a default stack of `["hello", "world"]` under a supervisor,
+  we can do:
 
-      It must return:
+      children = [
+        {Stack, "hello,world"}
+      ]
 
-      -  `{:ok, new_state}`
-      -  `{:error, reason}`
+      Supervisor.start_link(children, strategy: :one_for_all)
 
-  ## Name Registration
+  Note that specifying a module `MyServer` would be the same as specifying
+  the  tuple `{MyServer, []}`.
+
+  `use GenServer` also accepts a list of options which configures the
+  child specification and therefore how it runs under a supervisor.
+  The generated `child_spec/1` can be customized with the following options:
+
+    * `:id` - the child specification identifier, defaults to the current module
+    * [`:restart`](`m:Supervisor#module-restart-values-restart`) - when the
+      child should be restarted, defaults to `:permanent`
+    * [`:shutdown`](`m:Supervisor#module-shutdown-values-shutdown`) - how to
+      shut down the child, either immediately or by giving it time to shut down
+
+  For example:
+
+      use GenServer, restart: :transient, shutdown: 10_000
+
+  See the ["Child specification"](`m:Supervisor#module-child_spec-1-function`) section in the `Supervisor` module for more
+  detailed information. The `@doc` annotation immediately preceding
+  `use GenServer` will be attached to the generated `child_spec/1` function.
+
+  When stopping the GenServer, for example by returning a `{:stop, reason, new_state}`
+  tuple from a callback, the exit reason is used by the supervisor to determine
+  whether the GenServer needs to be restarted. See the "Exit reasons and restarts"
+  section in the `Supervisor` module.
+
+  ## Name registration
 
   Both `start_link/3` and `start/3` support the `GenServer` to register
   a name on start via the `:name` option. Registered names are also
   automatically cleaned up on termination. The supported values are:
 
-    * an atom - the GenServer is registered locally with the given name
-      using `Process.register/2`.
+    * an atom - the GenServer is registered locally (to the current node)
+      with the given name using `Process.register/2`.
 
-    * `{:global, term}`- the GenServer is registered globally with the given
-      term using the functions in the `:global` module.
+    * `{:global, term}` - the GenServer is registered globally with the given
+      term using the functions in the [`:global` module](`:global`).
 
     * `{:via, module, term}` - the GenServer is registered with the given
-      mechanism and name. The `:via` option expects a module name to control
-      the registration mechanism alongside a name which can be any term.
+      mechanism and name. The `:via` option expects a module that exports
+      `register_name/2`, `unregister_name/1`, `whereis_name/1` and `send/2`.
+      One such example is the [`:global` module](`:global`) which uses these functions
+      for keeping the list of names of processes and their associated PIDs
+      that are available globally for a network of Elixir nodes. Elixir also
+      ships with a local, decentralized and scalable registry called `Registry`
+      for locally storing names that are generated dynamically.
 
-  For example, we could start and register our Stack server locally as follows:
+  For example, we could start and register our `Stack` server locally as follows:
 
       # Start the server and register it locally with name MyStack
-      {:ok, _} = GenServer.start_link(Stack, [:hello], name: MyStack)
+      {:ok, _} = GenServer.start_link(Stack, "hello", name: MyStack)
 
       # Now messages can be sent directly to MyStack
-      GenServer.call(MyStack, :pop) #=> :hello
+      GenServer.call(MyStack, :pop)
+      #=> "hello"
 
   Once the server is started, the remaining functions in this module (`call/3`,
-  `cast/2`, and friends) will also accept an atom, or any `:global` or `:via`
-  tuples. In general, the following formats are supported:
+  `cast/2`, and friends) will also accept an atom, or any `{:global, ...}` or
+  `{:via, ...}` tuples. In general, the following formats are supported:
 
-    * a `pid`
-    * an `atom` if the server is locally registered
+    * a PID
+    * an atom if the server is locally registered
     * `{atom, node}` if the server is locally registered at another node
     * `{:global, term}` if the server is globally registered
     * `{:via, module, name}` if the server is registered through an alternative
       registry
 
-  ## Client / Server APIs
+  If there is an interest to register dynamic names locally, do not use
+  atoms, as atoms are never garbage-collected and therefore dynamically
+  generated atoms won't be garbage-collected. For such cases, you can
+  set up your own local registry by using the `Registry` module.
 
-  Although in the example above we have used `GenServer.start_link/3` and
-  friends to directly start and communicate with the server, most of the
-  time we don't call the `GenServer` functions directly. Instead, we wrap
-  the calls in new functions representing the public API of the server.
+  For example:
 
-  Here is a better implementation of our Stack module:
+      {:ok, _} = Registry.start_link(keys: :unique, name: :stacks)
+      name = {:via, Registry, {:stacks, "stack 1"}}
+      {:ok, _pid} = GenServer.start_link(Stack, "hello", name: name)
+      GenServer.whereis(name)
+      #=> #PID<0.150.0>
 
-      defmodule Stack do
+  ## Receiving "regular" messages
+
+  The goal of a `GenServer` is to abstract the "receive" loop for developers,
+  automatically handling system messages, supporting code change, synchronous
+  calls and more. Therefore, you should never call your own "receive" inside
+  the GenServer callbacks as doing so will cause the GenServer to misbehave.
+
+  Besides the synchronous and asynchronous communication provided by `call/3`
+  and `cast/2`, "regular" messages sent by functions such as `send/2`,
+  `Process.send_after/4` and similar, can be handled inside the `c:handle_info/2`
+  callback.
+
+  `c:handle_info/2` can be used in many situations, such as handling monitor
+  DOWN messages sent by `Process.monitor/1`. Another use case for `c:handle_info/2`
+  is to perform periodic work, with the help of `Process.send_after/4`:
+
+      defmodule MyApp.Periodically do
         use GenServer
 
-        # Client
+        def start_link(_) do
+          GenServer.start_link(__MODULE__, %{})
+        end
 
-        def start_link(default) do
-          GenServer.start_link(__MODULE__, default)
+        @impl true
+        def init(state) do
+          # Schedule work to be performed on start
+          schedule_work()
+
+          {:ok, state}
         end
 
-        def push(pid, item) do
-          GenServer.cast(pid, {:push, item})
+        @impl true
+        def handle_info(:work, state) do
+          # Do the desired work here
+          # ...
+
+          # Reschedule once more
+          schedule_work()
+
+          {:noreply, state}
         end
 
-        def pop(pid) do
-          GenServer.call(pid, :pop)
+        defp schedule_work do
+          # We schedule the work to happen in 2 hours (written in milliseconds).
+          # Alternatively, one might write :timer.hours(2)
+          Process.send_after(self(), :work, 2 * 60 * 60 * 1000)
         end
+      end
 
-        # Server (callbacks)
+  ## Timeouts
 
-        def handle_call(:pop, _from, [h|t]) do
-          {:reply, h, t}
-        end
+  The return value of `c:init/1` or any of the `handle_*` callbacks may include
+  a timeout value in milliseconds; if not, `:infinity` is assumed.
+  The timeout can be used to detect a lull in incoming messages.
+
+  The `timeout()` value is used as follows:
+
+    * If the process has any message already waiting when the `timeout()` value
+      is returned, the timeout is ignored and the waiting message is handled as
+      usual. This means that even a timeout of `0` milliseconds is not guaranteed
+      to execute (if you want to take another action immediately and unconditionally,
+      use a `:continue` instruction instead).
+
+    * If any message arrives before the specified number of milliseconds
+      elapse, the timeout is cleared and that message is handled as usual.
+
+    * Otherwise, when the specified number of milliseconds have elapsed with no
+      message arriving, `handle_info/2` is called with `:timeout` as the first
+      argument.
 
-        def handle_call(request, from, state) do
-          # Call the default implementation from GenServer
-          super(request, from, state)
+  For example:
+
+      defmodule Counter do
+        use GenServer
+
+        @timeout to_timeout(second: 5)
+
+        @impl true
+        def init(count) do
+          {:ok, count, @timeout}
         end
 
-        def handle_cast({:push, item}, state) do
-          {:noreply, [item|state]}
+        @impl true
+        def handle_call(:increment, _from, count) do
+          new_count = count + 1
+          {:reply, new_count, new_count, @timeout}
         end
 
-        def handle_cast(request, state) do
-          super(request, state)
+        @impl true
+        def handle_info(:timeout, count) do
+          {:stop, :normal, count}
         end
       end
 
-  In practice, it is common to have both server and client functions in
-  the same module. If the server and/or client implementations are growing
-  complex, you may want to have them in different modules.
+  A `Counter` server will exit with `:normal` if there are no messages in 5 seconds
+  after the initialization or after the last `:increment` call:
+
+      {:ok, counter_pid} = GenServer.start(Counter, 50)
+      GenServer.call(counter_pid, :increment)
+      #=> 51
+
+      # After 5 seconds
+      Process.alive?(counter_pid)
+      #=> false
+
+  ## When (not) to use a GenServer
+
+  So far, we have learned that a `GenServer` can be used as a supervised process
+  that handles sync and async calls. It can also handle system messages, such as
+  periodic messages and monitoring events. GenServer processes may also be named.
+
+  A GenServer, or a process in general, must be used to model runtime characteristics
+  of your system. A GenServer must never be used for code organization purposes.
+
+  In Elixir, code organization is done by modules and functions, processes are not
+  necessary. For example, imagine you are implementing a calculator and you decide
+  to put all the calculator operations behind a GenServer:
+
+      def add(a, b) do
+        GenServer.call(__MODULE__, {:add, a, b})
+      end
+
+      def subtract(a, b) do
+        GenServer.call(__MODULE__, {:subtract, a, b})
+      end
+
+      def handle_call({:add, a, b}, _from, state) do
+        {:reply, a + b, state}
+      end
+
+      def handle_call({:subtract, a, b}, _from, state) do
+        {:reply, a - b, state}
+      end
+
+  This is an anti-pattern not only because it convolutes the calculator logic but
+  also because you put the calculator logic behind a single process that will
+  potentially become a bottleneck in your system, especially as the number of
+  calls grow. Instead just define the functions directly:
+
+      def add(a, b) do
+        a + b
+      end
+
+      def subtract(a, b) do
+        a - b
+      end
+
+  If you don't need a process, then you don't need a process. Use processes only to
+  model runtime properties, such as mutable state, concurrency and failures, never
+  for code organization.
+
+  ## Debugging with the :sys module
+
+  GenServers, as [special processes](https://www.erlang.org/doc/design_principles/spec_proc.html),
+  can be debugged using the [`:sys` module](`:sys`).
+  Through various hooks, this module allows developers to introspect the state of
+  the process and trace system events that happen during its execution, such as
+  received messages, sent replies and state changes.
+
+  Let's explore the basic functions from the
+  [`:sys` module](`:sys`) used for debugging:
+
+    * `:sys.get_state/2` - allows retrieval of the state of the process.
+      In the case of a GenServer process, it will be the callback module state,
+      as passed into the callback functions as last argument.
+    * `:sys.get_status/2` - allows retrieval of the status of the process.
+      This status includes the process dictionary, if the process is running
+      or is suspended, the parent PID, the debugger state, and the state of
+      the behaviour module, which includes the callback module state
+      (as returned by `:sys.get_state/2`). It's possible to change how this
+      status is represented by defining the optional `c:GenServer.format_status/1`
+      callback.
+    * `:sys.trace/3` - prints all the system events to `:stdio`.
+    * `:sys.statistics/3` - manages collection of process statistics.
+    * `:sys.no_debug/2` - turns off all debug handlers for the given process.
+      It is very important to switch off debugging once we're done. Excessive
+      debug handlers or those that should be turned off, but weren't, can
+      seriously damage the performance of the system.
+    * `:sys.suspend/2` - allows to suspend a process so that it only
+      replies to system messages but no other messages. A suspended process
+      can be reactivated via `:sys.resume/2`.
+
+  Let's see how we could use those functions for debugging the stack server
+  we defined earlier.
+
+      iex> {:ok, pid} = Stack.start_link("")
+      iex> :sys.statistics(pid, true) # turn on collecting process statistics
+      iex> :sys.trace(pid, true) # turn on event printing
+      iex> Stack.push(pid, 1)
+      *DBG* <0.122.0> got cast {push,1}
+      *DBG* <0.122.0> new state [1]
+      :ok
+
+      iex> :sys.get_state(pid)
+      [1]
+
+      iex> Stack.pop(pid)
+      *DBG* <0.122.0> got call pop from <0.80.0>
+      *DBG* <0.122.0> sent 1 to <0.80.0>, new state []
+      1
+
+      iex> :sys.statistics(pid, :get)
+      {:ok,
+       [
+         start_time: {{2016, 7, 16}, {12, 29, 41}},
+         current_time: {{2016, 7, 16}, {12, 29, 50}},
+         reductions: 117,
+         messages_in: 2,
+         messages_out: 0
+       ]}
+
+      iex> :sys.no_debug(pid) # turn off all debug handlers
+      :ok
+
+      iex> :sys.get_status(pid)
+      {:status, #PID<0.122.0>, {:module, :gen_server},
+       [
+         [
+           "$initial_call": {Stack, :init, 1},            # process dictionary
+           "$ancestors": [#PID<0.80.0>, #PID<0.51.0>]
+         ],
+         :running,                                        # :running | :suspended
+         #PID<0.80.0>,                                    # parent
+         [],                                              # debugger state
+         [
+           header: 'Status for generic server <0.122.0>', # module status
+           data: [
+             {'Status', :running},
+             {'Parent', #PID<0.80.0>},
+             {'Logged events', []}
+           ],
+           data: [{'State', [1]}]
+         ]
+       ]}
 
   ## Learn more
 
-  If you wish to find out more about gen servers, Elixir getting started
-  guides provide a tutorial-like introduction. The documentation and links
+  If you wish to find out more about GenServers, the Elixir Getting Started
+  guide provides a tutorial-like introduction. The documentation and links
   in Erlang can also provide extra insight.
 
-    * http://elixir-lang.org/getting_started/mix/1.html
-    * http://www.erlang.org/doc/man/gen_server.html
-    * http://www.erlang.org/doc/design_principles/gen_server_concepts.html
-    * http://learnyousomeerlang.com/clients-and-servers
+    * [GenServer - Elixir's Getting Started Guide](genservers.md)
+    * [`:gen_server` module documentation](`:gen_server`)
+    * [gen_server Behaviour - OTP Design Principles](https://www.erlang.org/doc/design_principles/gen_server_concepts.html)
+    * [Clients and Servers - Learn You Some Erlang for Great Good!](http://learnyousomeerlang.com/clients-and-servers)
+
+  """
+
+  @doc """
+  Invoked when the server is started. `start_link/3` or `start/3` will
+  block until it returns.
+
+  `init_arg` is the argument term (second argument) passed to `start_link/3`.
+
+  Returning `{:ok, state}` will cause `start_link/3` to return
+  `{:ok, pid}` and the process to enter its loop.
+
+  Returning `{:ok, state, timeout}` is similar to `{:ok, state}`,
+  except that it also sets a timeout. See the "Timeouts" section
+  in the module documentation for more information.
+
+  Returning `{:ok, state, :hibernate}` is similar to `{:ok, state}`
+  except the process is hibernated before entering the loop. See
+  `c:handle_call/3` for more information on hibernation.
+
+  Returning `{:ok, state, {:continue, continue_arg}}` is similar to
+  `{:ok, state}` except that immediately after entering the loop,
+  the `c:handle_continue/2` callback will be invoked with `continue_arg`
+  as the first argument and `state` as the second one.
+
+  Returning `:ignore` will cause `start_link/3` to return `:ignore` and
+  the process will exit normally without entering the loop or calling
+  `c:terminate/2`. If used when part of a supervision tree the parent
+  supervisor will not fail to start nor immediately try to restart the
+  `GenServer`. The remainder of the supervision tree will be started
+  and so the `GenServer` should not be required by other processes.
+  It can be started later with `Supervisor.restart_child/2` as the child
+  specification is saved in the parent supervisor. The main use cases for
+  this are:
+
+    * The `GenServer` is disabled by configuration but might be enabled later.
+    * An error occurred and it will be handled by a different mechanism than the
+     `Supervisor`. Likely this approach involves calling `Supervisor.restart_child/2`
+      after a delay to attempt a restart.
+
+  Returning `{:stop, reason}` will cause `start_link/3` to return
+  `{:error, reason}` and the process to exit with reason `reason` without
+  entering the loop or calling `c:terminate/2`.
+  """
+  @callback init(init_arg :: term) ::
+              {:ok, state}
+              | {:ok, state, timeout | :hibernate | {:continue, continue_arg :: term}}
+              | :ignore
+              | {:stop, reason :: term}
+            when state: term
+
+  @doc """
+  Invoked to handle synchronous `call/3` messages. `call/3` will block until a
+  reply is received (unless the call times out or nodes are disconnected).
+
+  `request` is the request message sent by a `call/3`, `from` is a 2-tuple
+  containing the caller's PID and a term that uniquely identifies the call, and
+  `state` is the current state of the `GenServer`.
+
+  Returning `{:reply, reply, new_state}` sends the response `reply` to the
+  caller and continues the loop with new state `new_state`.
+
+  Returning `{:reply, reply, new_state, timeout}` is similar to
+  `{:reply, reply, new_state}` except that it also sets a timeout.
+  See the "Timeouts" section in the module documentation for more information.
+
+  Returning `{:reply, reply, new_state, :hibernate}` is similar to
+  `{:reply, reply, new_state}` except the process is hibernated and will
+  continue the loop once a message is in its message queue. However, if a message is
+  already in the message queue, the process will continue the loop immediately.
+  Hibernating a `GenServer` causes garbage collection and leaves a continuous
+  heap that minimises the memory used by the process.
+
+  Hibernating should not be used aggressively as too much time could be spent
+  garbage collecting, which would delay the processing of incoming messages.
+  Normally it should only be used when you are not expecting new messages to
+  immediately arrive and minimising the memory of the process is shown to be
+  beneficial.
+
+  Returning `{:reply, reply, new_state, {:continue, continue_arg}}` is similar to
+  `{:reply, reply, new_state}` except that `c:handle_continue/2` will be invoked
+  immediately after with `continue_arg` as the first argument and
+  `state` as the second one.
+
+  Returning `{:noreply, new_state}` does not send a response to the caller and
+  continues the loop with new state `new_state`. The response must be sent with
+  `reply/2`.
+
+  There are three main use cases for not replying using the return value:
+
+    * To reply before returning from the callback because the response is known
+      before calling a slow function.
+    * To reply after returning from the callback because the response is not yet
+      available.
+    * To reply from another process, such as a task.
+
+  When replying from another process the `GenServer` should exit if the other
+  process exits without replying as the caller will be blocking awaiting a
+  reply.
+
+  Returning `{:noreply, new_state, timeout | :hibernate | {:continue, continue_arg}}`
+  is similar to `{:noreply, new_state}` except a timeout, hibernation or continue
+  occurs as with a `:reply` tuple.
+
+  Returning `{:stop, reason, reply, new_state}` stops the loop and `c:terminate/2`
+  is called with reason `reason` and state `new_state`. Then, the `reply` is sent
+  as the response to call and the process exits with reason `reason`.
+
+  Returning `{:stop, reason, new_state}` is similar to
+  `{:stop, reason, reply, new_state}` except a reply is not sent.
+
+  This callback is optional. If one is not implemented, the server will fail
+  if a call is performed against it.
+  """
+  @callback handle_call(request :: term, from, state :: term) ::
+              {:reply, reply, new_state}
+              | {:reply, reply, new_state,
+                 timeout | :hibernate | {:continue, continue_arg :: term}}
+              | {:noreply, new_state}
+              | {:noreply, new_state, timeout | :hibernate | {:continue, continue_arg :: term}}
+              | {:stop, reason, reply, new_state}
+              | {:stop, reason, new_state}
+            when reply: term, new_state: term, reason: term
+
+  @doc """
+  Invoked to handle asynchronous `cast/2` messages.
+
+  `request` is the request message sent by a `cast/2` and `state` is the current
+  state of the `GenServer`.
+
+  Returning `{:noreply, new_state}` continues the loop with new state `new_state`.
+
+  Returning `{:noreply, new_state, timeout}` is similar to `{:noreply, new_state}`
+  except that it also sets a timeout. See the "Timeouts" section in the module
+  documentation for more information.
+
+  Returning `{:noreply, new_state, :hibernate}` is similar to
+  `{:noreply, new_state}` except the process is hibernated before continuing the
+  loop. See `c:handle_call/3` for more information.
+
+  Returning `{:noreply, new_state, {:continue, continue_arg}}` is similar to
+  `{:noreply, new_state}` except `c:handle_continue/2` will be invoked
+  immediately after with `continue_arg` as the first argument and
+  `state` as the second one.
+
+  Returning `{:stop, reason, new_state}` stops the loop and `c:terminate/2` is
+  called with the reason `reason` and state `new_state`. The process exits with
+  reason `reason`.
+
+  This callback is optional. If one is not implemented, the server will fail
+  if a cast is performed against it.
+  """
+  @callback handle_cast(request :: term, state :: term) ::
+              {:noreply, new_state}
+              | {:noreply, new_state, timeout | :hibernate | {:continue, continue_arg :: term}}
+              | {:stop, reason :: term, new_state}
+            when new_state: term
+
+  @doc """
+  Invoked to handle all other messages.
+
+  `msg` is the message and `state` is the current state of the `GenServer`. When
+  a timeout occurs the message is `:timeout`.
+
+  Return values are the same as `c:handle_cast/2`.
+
+  This callback is optional. If one is not implemented, the received message
+  will be logged.
+  """
+  @callback handle_info(msg :: :timeout | term, state :: term) ::
+              {:noreply, new_state}
+              | {:noreply, new_state, timeout | :hibernate | {:continue, continue_arg :: term}}
+              | {:stop, reason :: term, new_state}
+            when new_state: term
+
+  @doc """
+  Invoked to handle continue instructions.
+
+  It is useful for performing work after initialization or for splitting the work
+  in a callback in multiple steps, updating the process state along the way.
+
+  Return values are the same as `c:handle_cast/2`.
+
+  This callback is optional. If one is not implemented, the server will fail
+  if a continue instruction is used.
+  """
+  @callback handle_continue(continue_arg, state :: term) ::
+              {:noreply, new_state}
+              | {:noreply, new_state, timeout | :hibernate | {:continue, continue_arg}}
+              | {:stop, reason :: term, new_state}
+            when new_state: term, continue_arg: term
+
+  @doc """
+  Invoked when the server is about to exit. It should do any cleanup required.
+
+  `reason` is exit reason and `state` is the current state of the `GenServer`.
+  The return value is ignored.
+
+  `c:terminate/2` is useful for cleanup that requires access to the
+  `GenServer`'s state. However, it is **not guaranteed** that `c:terminate/2`
+  is called when a `GenServer` exits. Therefore, important cleanup should be
+  done using process links and/or monitors. A monitoring process will receive the
+  same exit `reason` that would be passed to `c:terminate/2`.
+
+  `c:terminate/2` is called if:
+
+    * the `GenServer` traps exits (using `Process.flag/2`) *and* the parent
+    process (the one which called `start_link/1`) sends an exit signal
+
+    * a callback (except `c:init/1`) does one of the following:
+
+      * returns a `:stop` tuple
+
+      * raises (via `raise/2`) or exits (via `exit/1`)
+
+      * returns an invalid value
+
+  If part of a supervision tree, a `GenServer` will receive an exit signal from
+  its parent process (its supervisor) when the tree is shutting down. The exit
+  signal is based on the shutdown strategy in the child's specification, where
+  this value can be:
+
+    * `:brutal_kill`: the `GenServer` is killed and so `c:terminate/2` is not called.
+
+    * a timeout value, where the supervisor will send the exit signal `:shutdown` and
+      the `GenServer` will have the duration of the timeout to terminate.
+      If after duration of this timeout the process is still alive, it will be killed
+      immediately.
+
+  For a more in-depth explanation, please read the "Shutdown values (:shutdown)"
+  section in the `Supervisor` module.
+
+  If the `GenServer` receives an exit signal (that is not `:normal`) from any
+  process when it is not trapping exits it will exit abruptly with the same
+  reason and so not call `c:terminate/2`. Note that a process does *NOT* trap
+  exits by default and an exit signal is sent when a linked process exits or its
+  node is disconnected.
+
+  `c:terminate/2` is only called after the `GenServer` finishes processing all
+  messages which arrived in its mailbox prior to the exit signal. If it
+  receives a `:kill` signal before it finishes processing those,
+  `c:terminate/2` will not be called. If `c:terminate/2` is called, any
+  messages received after the exit signal will still be in the mailbox.
+
+  There is no cleanup needed when the `GenServer` controls a `port` (for example,
+  `:gen_tcp.socket`) or `t:File.io_device/0`, because these will be closed on
+  receiving a `GenServer`'s exit signal and do not need to be closed manually
+  in `c:terminate/2`.
+
+  If `reason` is neither `:normal`, `:shutdown`, nor `{:shutdown, term}` an error is
+  logged.
+
+  This callback is optional.
   """
+  @callback terminate(reason, state :: term) :: term
+            when reason: :normal | :shutdown | {:shutdown, term} | term
+
+  @doc """
+  Invoked to change the state of the `GenServer` when a different version of a
+  module is loaded (hot code swapping) and the state's term structure should be
+  changed.
+
+  `old_vsn` is the previous version of the module (defined by the `@vsn`
+  attribute) when upgrading. When downgrading the previous version is wrapped in
+  a 2-tuple with first element `:down`. `state` is the current state of the
+  `GenServer` and `extra` is any extra data required to change the state.
+
+  Returning `{:ok, new_state}` changes the state to `new_state` and the code
+  change is successful.
+
+  Returning `{:error, reason}` fails the code change with reason `reason` and
+  the state remains as the previous state.
+
+  If `c:code_change/3` raises the code change fails and the loop will continue
+  with its previous state. Therefore this callback does not usually contain side effects.
+
+  This callback is optional.
+  """
+  @callback code_change(old_vsn, state :: term, extra :: term) ::
+              {:ok, new_state :: term}
+              | {:error, reason :: term}
+            when old_vsn: term | {:down, term}
+
+  @doc """
+  This function is called by a `GenServer` process in the following situations:
+
+    * [`:sys.get_status/1,2`](`:sys.get_status/1`) is invoked to get the `GenServer` status.
+    * The `GenServer` process terminates abnormally and logs an error.
+
+  This callback is used to limit the status of the process returned by
+  [`:sys.get_status/1,2`](`:sys.get_status/1`) or sent to logger.
+
+  The callback gets a map `status` describing the current status and shall return
+  a map `new_status` with the same keys, but it may transform some values.
+
+  Two possible use cases for this callback is to remove sensitive information
+  from the state to prevent it from being printed in log files, or to compact
+  large irrelevant status items that would only clutter the logs.
+
+  ## Example
+
+      @impl GenServer
+      def format_status(status) do
+        Map.new(status, fn
+          {:state, state} -> {:state, Map.delete(state, :private_key)}
+          {:message, {:password, _}} -> {:message, {:password, "redacted"}}
+          key_value -> key_value
+        end)
+      end
+
+  """
+  @doc since: "1.17.0"
+  @callback format_status(status :: :gen_server.format_status()) ::
+              new_status :: :gen_server.format_status()
+
+  # TODO: Remove this on v2.0
+  @doc deprecated: "Use format_status/1 callback instead"
+  @callback format_status(reason, pdict_and_state :: list) :: term
+            when reason: :normal | :terminate
+
+  @optional_callbacks code_change: 3,
+                      terminate: 2,
+                      handle_info: 2,
+                      handle_cast: 2,
+                      handle_call: 3,
+                      format_status: 1,
+                      format_status: 2,
+                      handle_continue: 2
 
   @typedoc "Return values of `start*` functions"
   @type on_start :: {:ok, pid} | :ignore | {:error, {:already_started, pid} | term}
@@ -210,40 +860,123 @@ defmodule GenServer do
   @type name :: atom | {:global, term} | {:via, module, term}
 
   @typedoc "Options used by the `start*` functions"
-  @type options :: [debug: debug,
-                    name: name,
-                    timeout: timeout,
-                    spawn_opt: Process.spawn_opt]
+  @type options :: [option]
 
-  @typedoc "debug options supported by the `start*` functions"
-  @type debug :: [:trace | :log | :statistics | {:log_to_file, Path.t}]
+  @typedoc "Option values used by the `start*` functions"
+  @type option ::
+          {:debug, debug}
+          | {:name, name}
+          | {:timeout, timeout}
+          | {:spawn_opt, [Process.spawn_opt()]}
+          | {:hibernate_after, timeout}
 
-  @typedoc "The server reference"
+  @typedoc "Debug options supported by the `start*` functions"
+  @type debug :: [:trace | :log | :statistics | {:log_to_file, Path.t()}]
+
+  @typedoc """
+  The server reference.
+
+  This is either a plain PID or a value representing a registered name.
+  See the "Name registration" section of this document for more information.
+  """
   @type server :: pid | name | {atom, node}
 
+  @typedoc """
+  Tuple describing the client of a call request.
+
+  `pid` is the PID of the caller and `tag` is a unique term used to identify the
+  call.
+  """
+  @type from :: {pid, tag :: term}
+
   @doc false
-  defmacro __using__(_) do
-    quote location: :keep do
-      @behaviour :gen_server
+  defmacro __using__(opts) do
+    quote location: :keep, bind_quoted: [opts: opts] do
+      @behaviour GenServer
 
-      @doc false
-      def init(args) do
-        {:ok, args}
+      if not Module.has_attribute?(__MODULE__, :doc) do
+        @doc """
+        Returns a specification to start this module under a supervisor.
+
+        See `Supervisor`.
+        """
       end
 
+      def child_spec(init_arg) do
+        default = %{
+          id: __MODULE__,
+          start: {__MODULE__, :start_link, [init_arg]}
+        }
+
+        Supervisor.child_spec(default, unquote(Macro.escape(opts)))
+      end
+
+      defoverridable child_spec: 1
+
+      # TODO: Remove this on v2.0
+      @before_compile GenServer
+
       @doc false
       def handle_call(msg, _from, state) do
-        {:stop, {:bad_call, msg}, state}
+        proc =
+          case Process.info(self(), :registered_name) do
+            {_, []} -> self()
+            {_, name} -> name
+          end
+
+        # We do this to trick Dialyzer to not complain about non-local returns.
+        case :erlang.phash2(1, 1) do
+          0 ->
+            raise "attempted to call GenServer #{inspect(proc)} but no handle_call/3 clause was provided"
+
+          1 ->
+            {:stop, {:bad_call, msg}, state}
+        end
       end
 
       @doc false
-      def handle_info(_msg, state) do
+      def handle_info(msg, state) do
+        proc =
+          case Process.info(self(), :registered_name) do
+            {_, []} -> self()
+            {_, name} -> name
+          end
+
+        :logger.error(
+          %{
+            label: {GenServer, :no_handle_info},
+            report: %{
+              module: __MODULE__,
+              message: msg,
+              name: proc
+            }
+          },
+          %{
+            domain: [:otp, :elixir],
+            error_logger: %{tag: :error_msg},
+            report_cb: &GenServer.format_report/1
+          }
+        )
+
         {:noreply, state}
       end
 
       @doc false
       def handle_cast(msg, state) do
-        {:stop, {:bad_cast, msg}, state}
+        proc =
+          case Process.info(self(), :registered_name) do
+            {_, []} -> self()
+            {_, name} -> name
+          end
+
+        # We do this to trick Dialyzer to not complain about non-local returns.
+        case :erlang.phash2(1, 1) do
+          0 ->
+            raise "attempted to cast GenServer #{inspect(proc)} but no handle_cast/2 clause was provided"
+
+          1 ->
+            {:stop, {:bad_cast, msg}, state}
+        end
       end
 
       @doc false
@@ -256,8 +989,36 @@ defmodule GenServer do
         {:ok, state}
       end
 
-      defoverridable [init: 1, handle_call: 3, handle_info: 2,
-                      handle_cast: 2, terminate: 2, code_change: 3]
+      defoverridable code_change: 3, terminate: 2, handle_info: 2, handle_cast: 2, handle_call: 3
+    end
+  end
+
+  defmacro __before_compile__(env) do
+    if not Module.defines?(env.module, {:init, 1}) do
+      message = """
+      function init/1 required by behaviour GenServer is not implemented \
+      (in module #{inspect(env.module)}).
+
+      We will inject a default implementation for now:
+
+          def init(init_arg) do
+            {:ok, init_arg}
+          end
+
+      You can copy the implementation above or define your own that converts \
+      the arguments given to GenServer.start_link/3 to the server state.
+      """
+
+      IO.warn(message, env)
+
+      quote do
+        @doc false
+        def init(init_arg) do
+          {:ok, init_arg}
+        end
+
+        defoverridable init: 1
+      end
     end
   end
 
@@ -266,43 +1027,49 @@ defmodule GenServer do
 
   This is often used to start the `GenServer` as part of a supervision tree.
 
-  Once the server is started, it calls the `init/1` function in the given `module`
-  passing the given `args` to initialize it. To ensure a synchronized start-up
-  procedure, this function does not return until `init/1` has returned.
+  Once the server is started, the `c:init/1` function of the given `module` is
+  called with `init_arg` as its argument to initialize the server. To ensure a
+  synchronized start-up procedure, this function does not return until `c:init/1`
+  has returned.
 
   Note that a `GenServer` started with `start_link/3` is linked to the
-  parent process and will exit in case of crashes. The GenServer will also
-  exit due to the `:normal` reasons in case it is configured to trap exits
-  in the `init/1` callback.
+  parent process and will exit in case of crashes from the parent. The GenServer
+  will also exit due to the `:normal` reasons in case it is configured to trap
+  exits in the `c:init/1` callback.
 
   ## Options
 
-  The `:name` option is used for name registration as described in the module
-  documentation. If the option `:timeout` option is present, the server is
-  allowed to spend the given milliseconds initializing or it will be
-  terminated and the start function will return `{:error, :timeout}`.
+    * `:name` - used for name registration as described in the "Name
+      registration" section in the documentation for `GenServer`
+
+    * `:timeout` - if present, the server is allowed to spend the given number of
+      milliseconds initializing or it will be terminated and the start function
+      will return `{:error, :timeout}`
 
-  If the `:debug` option is present, the corresponding function in the
-  [`:sys` module](http://www.erlang.org/doc/man/sys.html) will be invoked.
+    * `:debug` - if present, the corresponding function in the [`:sys` module](`:sys`) is invoked
 
-  If the `:spawn_opt` option is present, its value will be passed as options
-  to the underlying process as in `Process.spawn/4`.
+    * `:spawn_opt` - if present, its value is passed as options to the
+      underlying process as in `Process.spawn/4`
+
+    * `:hibernate_after` - if present, the GenServer process awaits any message for
+      the given number of milliseconds and if no message is received, the process goes
+      into hibernation automatically (by calling `:proc_lib.hibernate/3`).
 
   ## Return values
 
-  If the server is successfully created and initialized, the function returns
-  `{:ok, pid}`, where pid is the pid of the server. If there already exists a
-  process with the specified server name, the function returns
-  `{:error, {:already_started, pid}}` with the pid of that process.
+  If the server is successfully created and initialized, this function returns
+  `{:ok, pid}`, where `pid` is the PID of the server. If a process with the
+  specified server name already exists, this function returns
+  `{:error, {:already_started, pid}}` with the PID of that process.
 
-  If the `init/1` callback fails with `reason`, the function returns
+  If the `c:init/1` callback fails with `reason`, this function returns
   `{:error, reason}`. Otherwise, if it returns `{:stop, reason}`
-  or `:ignore`, the process is terminated and the function returns
+  or `:ignore`, the process is terminated and this function returns
   `{:error, reason}` or `:ignore`, respectively.
   """
-  @spec start_link(module, any, options) :: on_start
-  def start_link(module, args, options \\ []) when is_atom(module) and is_list(options) do
-    do_start(:link, module, args, options)
+  @spec start_link(module, term, options) :: on_start
+  def start_link(module, init_arg, options \\ []) when is_atom(module) and is_list(options) do
+    do_start(:link, module, init_arg, options)
   end
 
   @doc """
@@ -310,19 +1077,66 @@ defmodule GenServer do
 
   See `start_link/3` for more information.
   """
-  @spec start(module, any, options) :: on_start
-  def start(module, args, options \\ []) when is_atom(module) and is_list(options) do
-    do_start(:nolink, module, args, options)
+  @spec start(module, term, options) :: on_start
+  def start(module, init_arg, options \\ []) when is_atom(module) and is_list(options) do
+    do_start(:nolink, module, init_arg, options)
   end
 
-  defp do_start(link, module, args, options) do
+  defp do_start(link, module, init_arg, options) do
     case Keyword.pop(options, :name) do
       {nil, opts} ->
-        :gen.start(:gen_server, link, module, args, opts)
+        :gen.start(:gen_server, link, module, init_arg, opts)
+
       {atom, opts} when is_atom(atom) ->
-        :gen.start(:gen_server, link, {:local, atom}, module, args, opts)
-      {other, opts} when is_tuple(other) ->
-        :gen.start(:gen_server, link, other, module, args, opts)
+        :gen.start(:gen_server, link, {:local, atom}, module, init_arg, opts)
+
+      {{:global, _term} = tuple, opts} ->
+        :gen.start(:gen_server, link, tuple, module, init_arg, opts)
+
+      {{:via, via_module, _term} = tuple, opts} when is_atom(via_module) ->
+        :gen.start(:gen_server, link, tuple, module, init_arg, opts)
+
+      {other, _} ->
+        raise ArgumentError, """
+        expected :name option to be one of the following:
+
+          * nil
+          * atom
+          * {:global, term}
+          * {:via, module, term}
+
+        Got: #{inspect(other)}
+        """
+    end
+  end
+
+  @doc """
+  Synchronously stops the server with the given `reason`.
+
+  The `c:terminate/2` callback of the given `server` will be invoked before
+  exiting. This function returns `:ok` if the server terminates with the
+  given reason; if it terminates with another reason, the call exits.
+
+  This function keeps OTP semantics regarding error reporting.
+  If the reason is any other than `:normal`, `:shutdown` or
+  `{:shutdown, _}`, an error report is logged.
+  """
+  @spec stop(server, reason :: term, timeout) :: :ok
+  def stop(server, reason \\ :normal, timeout \\ :infinity) do
+    case whereis(server) do
+      nil ->
+        exit({:noproc, {__MODULE__, :stop, [server, reason, timeout]}})
+
+      pid when pid == self() ->
+        exit({:calling_self, {__MODULE__, :stop, [server, reason, timeout]}})
+
+      pid ->
+        try do
+          :proc_lib.stop(pid, reason, timeout)
+        catch
+          :exit, err ->
+            exit({err, {__MODULE__, :stop, [server, reason, timeout]}})
+        end
     end
   end
 
@@ -330,101 +1144,227 @@ defmodule GenServer do
   Makes a synchronous call to the `server` and waits for its reply.
 
   The client sends the given `request` to the server and waits until a reply
-  arrives or a timeout occurs. `handle_call/3` will be called on the server
+  arrives or a timeout occurs. `c:handle_call/3` will be called on the server
   to handle the request.
 
-  The server can be any of the values described in the `Name Registration`
-  section of the module documentation.
+  `server` can be a PID or any of the other values described in the
+  "Name registration" section of the documentation for this module.
 
   ## Timeouts
 
-  The `timeout` is an integer greater than zero which specifies how many
+  `timeout` is an integer greater than zero which specifies how many
   milliseconds to wait for a reply, or the atom `:infinity` to wait
-  indefinitely. The default value is 5000. If no reply is received within
-  the specified time, the function call fails. If the caller catches the
-  failure and continues running, and the server is just late with the reply,
-  it may arrive at any time later into the caller's message queue. The caller
-  must in this case be prepared for this and discard any such garbage messages
-  that are two element tuples with a reference as the first element.
+  indefinitely. The default value is `5000`. If no reply is received within
+  the specified time, the function call fails and the caller exits. If the
+  caller catches the failure and continues running, and the server is just late
+  with the reply, it may arrive at any time later into the caller's message
+  queue. The caller must in this case be prepared for this and discard any such
+  garbage messages that are two-element tuples with a reference as the first
+  element.
   """
   @spec call(server, term, timeout) :: term
-  def call(server, request, timeout \\ 5000) do
-    :gen_server.call(server, request, timeout)
+  def call(server, request, timeout \\ 5000)
+      when (is_integer(timeout) and timeout >= 0) or timeout == :infinity do
+    case whereis(server) do
+      nil ->
+        exit({:noproc, {__MODULE__, :call, [server, request, timeout]}})
+
+      pid ->
+        try do
+          :gen.call(pid, :"$gen_call", request, timeout)
+        catch
+          :exit, reason ->
+            exit({reason, {__MODULE__, :call, [server, request, timeout]}})
+        else
+          {:ok, res} -> res
+        end
+    end
   end
 
   @doc """
-  Sends an asynchronous request to the `server`.
+  Casts a request to the `server` without waiting for a response.
 
-  This function returns `:ok` immediately, regardless of whether the
-  destination node or server does exists. `handle_cast/2` will be called on the
-  server to handle the request.
+  This function always returns `:ok` regardless of whether
+  the destination `server` (or node) exists. Therefore it
+  is unknown whether the destination `server` successfully
+  handled the request.
+
+  `server` can be any of the values described in the "Name registration"
+  section of the documentation for this module.
   """
   @spec cast(server, term) :: :ok
-  defdelegate cast(server, request), to: :gen_server
+  def cast(server, request)
+
+  def cast({:global, name}, request) do
+    try do
+      :global.send(name, cast_msg(request))
+      :ok
+    catch
+      _, _ -> :ok
+    end
+  end
+
+  def cast({:via, mod, name}, request) do
+    try do
+      mod.send(name, cast_msg(request))
+      :ok
+    catch
+      _, _ -> :ok
+    end
+  end
+
+  def cast({name, node}, request) when is_atom(name) and is_atom(node),
+    do: do_send({name, node}, cast_msg(request))
+
+  def cast(dest, request) when is_atom(dest) or is_pid(dest), do: do_send(dest, cast_msg(request))
 
   @doc """
   Casts all servers locally registered as `name` at the specified nodes.
 
-  The function returns immediately and ignores nodes that do not exist, or where the
+  This function returns immediately and ignores nodes that do not exist, or where the
   server name does not exist.
 
   See `multi_call/4` for more information.
   """
   @spec abcast([node], name :: atom, term) :: :abcast
-  def abcast(nodes \\ nodes(), name, request) do
-    :gen_server.abcast(nodes, name, request)
+  def abcast(nodes \\ [node() | Node.list()], name, request)
+      when is_list(nodes) and is_atom(name) do
+    msg = cast_msg(request)
+    _ = for node <- nodes, do: do_send({name, node}, msg)
+    :abcast
+  end
+
+  defp cast_msg(req) do
+    {:"$gen_cast", req}
+  end
+
+  defp do_send(dest, msg) do
+    try do
+      send(dest, msg)
+      :ok
+    catch
+      _, _ -> :ok
+    end
   end
 
   @doc """
   Calls all servers locally registered as `name` at the specified `nodes`.
 
-  The `request` is first sent to every node and then we wait for the
-  replies. This function returns a tuple containing the node and its reply
-  as first element and all bad nodes as second element. The bad nodes is a
-  list of nodes that either did not exist, or where a server with the given
-  `name` did not exist or did not reply.
+  First, the `request` is sent to every node in `nodes`; then, the caller waits
+  for the replies. This function returns a two-element tuple `{replies,
+  bad_nodes}` where:
+
+    * `replies` - is a list of `{node, reply}` tuples where `node` is the node
+      that replied and `reply` is its reply
+    * `bad_nodes` - is a list of nodes that either did not exist or where a
+      server with the given `name` did not exist or did not reply
+
+  `nodes` is a list of node names to which the request is sent. The default
+  value is the list of all known nodes (including this node).
 
-  Nodes is a list of node names to which the request is sent. The default
-  value is the list of all known nodes.
+  ## Examples
+
+  Assuming the `Stack` GenServer mentioned in the docs for the `GenServer`
+  module is registered as `Stack` in the `:"foo@my-machine"` and
+  `:"bar@my-machine"` nodes:
+
+      GenServer.multi_call(Stack, :pop)
+      #=> {[{:"foo@my-machine", :hello}, {:"bar@my-machine", :world}], []}
 
-  To avoid that late answers (after the timeout) pollute the caller's message
-  queue, a middleman process is used to do the actual calls. Late answers will
-  then be discarded when they arrive to a terminated process.
   """
   @spec multi_call([node], name :: atom, term, timeout) ::
-                  {replies :: [{node, term}], bad_nodes :: [node]}
-  def multi_call(nodes \\ nodes(), name, request, timeout \\ :infinity) do
+          {replies :: [{node, term}], bad_nodes :: [node]}
+  def multi_call(nodes \\ [node() | Node.list()], name, request, timeout \\ :infinity) do
     :gen_server.multi_call(nodes, name, request, timeout)
   end
 
   @doc """
   Replies to a client.
 
-  This function can be used by a server to explicitly send a reply to a
-  client that called `call/3` or `multi_call/4`. When the reply cannot be
-  defined in the return value of `handle_call/3`.
+  This function can be used to explicitly send a reply to a client that called
+  `call/3` or `multi_call/4` when the reply cannot be specified in the return
+  value of `c:handle_call/3`.
+
+  `client` must be the `from` argument (the second argument) accepted by
+  `c:handle_call/3` callbacks. `reply` is an arbitrary term which will be given
+  back to the client as the return value of the call.
 
-  The `client` must be the `from` argument (the second argument) received
-  in `handle_call/3` callbacks. Reply is an arbitrary term which will be
-  given back to the client as the return value of the call.
+  Note that `reply/2` can be called from any process, not just the GenServer
+  that originally received the call (as long as that GenServer communicated the
+  `from` argument somehow).
 
   This function always returns `:ok`.
+
+  ## Examples
+
+      def handle_call(:reply_in_one_second, from, state) do
+        Process.send_after(self(), {:reply, from}, 1_000)
+        {:noreply, state}
+      end
+
+      def handle_info({:reply, from}, state) do
+        GenServer.reply(from, :one_second_has_passed)
+        {:noreply, state}
+      end
+
   """
-  @spec reply({pid, reference}, term) :: :ok
-  def reply(client, reply)
+  @spec reply(from, term) :: :ok
+  def reply(client, reply) do
+    :gen.reply(client, reply)
+  end
 
-  def reply({to, tag}, reply) do
-    try do
-      send(to, {tag, reply})
-      :ok
-    catch
-      _, _ -> :ok
+  @doc """
+  Returns the `pid` or `{name, node}` of a GenServer process, `nil` otherwise.
+
+  To be precise, `nil` is returned whenever a `pid` or `{name, node}` cannot
+  be returned. Note there is no guarantee the returned `pid` or `{name, node}`
+  is alive, as a process could terminate immediately after it is looked up.
+
+  ## Examples
+
+  For example, to lookup a server process, monitor it and send a cast to it:
+
+      process = GenServer.whereis(server)
+      monitor = Process.monitor(process)
+      GenServer.cast(process, :hello)
+
+  """
+  @spec whereis(server) :: pid | {atom, node} | nil
+  def whereis(server)
+
+  def whereis(pid) when is_pid(pid), do: pid
+
+  def whereis(name) when is_atom(name) do
+    Process.whereis(name)
+  end
+
+  def whereis({:global, name}) do
+    case :global.whereis_name(name) do
+      pid when is_pid(pid) -> pid
+      :undefined -> nil
+    end
+  end
+
+  def whereis({:via, mod, name}) do
+    case apply(mod, :whereis_name, [name]) do
+      pid when is_pid(pid) -> pid
+      :undefined -> nil
     end
   end
 
-  @compile {:inline, [nodes: 0]}
+  def whereis({name, local}) when is_atom(name) and local == node() do
+    Process.whereis(name)
+  end
+
+  def whereis({name, node} = server) when is_atom(name) and is_atom(node) do
+    server
+  end
 
-  defp nodes do
-    [node()|:erlang.nodes()]
+  @doc false
+  def format_report(%{
+        label: {GenServer, :no_handle_info},
+        report: %{module: mod, message: msg, name: proc}
+      }) do
+    {~c"~p ~p received unexpected message in handle_info/2: ~p~n", [mod, proc, msg]}
   end
 end
diff --git a/lib/elixir/lib/hash_dict.ex b/lib/elixir/lib/hash_dict.ex
index edcb8e86329..d3d56d7601e 100644
--- a/lib/elixir/lib/hash_dict.ex
+++ b/lib/elixir/lib/hash_dict.ex
@@ -1,19 +1,16 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule HashDict do
   @moduledoc """
-  A key-value store.
-
-  The `HashDict` is represented internally as a struct, therefore
-  `%HashDict{}` can be used whenever there is a need to match
-  on any `HashDict`. Note though the struct fields are private and
-  must not be accessed directly. Instead, use the functions on this
-  or in the `Dict` module.
-
-  Implementation-wise, `HashDict` is implemented using tries, which
-  grows in space as the number of keys grows, working well with both
-  small and large set of keys. For more information about the
-  functions and their APIs, please consult the `Dict` module.
+  Tuple-based HashDict implementation.
+
+  This module is deprecated. Use the `Map` module instead.
   """
 
+  @moduledoc deprecated: "Use Map instead"
+
   use Dict
 
   @node_bitmap 0b111
@@ -21,7 +18,7 @@ defmodule HashDict do
   @node_size 8
   @node_template :erlang.make_tuple(@node_size, [])
 
-  @opaque t :: map
+  @opaque t :: %__MODULE__{size: non_neg_integer, root: term}
   @doc false
   defstruct size: 0, root: @node_template
 
@@ -29,58 +26,70 @@ defmodule HashDict do
   @compile :inline_list_funcs
   @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}
 
+  message = "Use maps and the Map module instead"
+
   @doc """
   Creates a new empty dict.
   """
-  @spec new :: Dict.t
+  @spec new :: Dict.t()
+  @deprecated message
   def new do
     %HashDict{}
   end
 
+  @deprecated message
   def put(%HashDict{root: root, size: size}, key, value) do
     {root, counter} = do_put(root, key, value, key_hash(key))
     %HashDict{root: root, size: size + counter}
   end
 
+  @deprecated message
   def update!(%HashDict{root: root, size: size} = dict, key, fun) when is_function(fun, 1) do
-    {root, counter} = do_update(root, key, fn -> raise KeyError, key: key, term: dict end,
-                                fun, key_hash(key))
+    {root, counter} =
+      do_update(root, key, fn -> raise KeyError, key: key, term: dict end, fun, key_hash(key))
+
     %HashDict{root: root, size: size + counter}
   end
 
-  def update(%HashDict{root: root, size: size}, key, initial, fun) when is_function(fun, 1) do
-    {root, counter} = do_update(root, key, fn -> initial end, fun, key_hash(key))
+  @deprecated message
+  def update(%HashDict{root: root, size: size}, key, default, fun) when is_function(fun, 1) do
+    {root, counter} = do_update(root, key, fn -> default end, fun, key_hash(key))
     %HashDict{root: root, size: size + counter}
   end
 
+  @deprecated message
   def fetch(%HashDict{root: root}, key) do
     do_fetch(root, key, key_hash(key))
   end
 
+  @deprecated message
   def delete(dict, key) do
     case dict_delete(dict, key) do
       {dict, _value} -> dict
-      :error         -> dict
+      :error -> dict
     end
   end
 
+  @deprecated message
   def pop(dict, key, default \\ nil) do
     case dict_delete(dict, key) do
       {dict, value} -> {value, dict}
-      :error        -> {default, dict}
+      :error -> {default, dict}
     end
   end
 
+  @deprecated message
   def size(%HashDict{size: size}) do
     size
   end
 
   @doc false
+  @deprecated message
   def reduce(%HashDict{root: root}, acc, fun) do
     do_reduce(root, acc, fun, @node_size, fn
       {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}
-      {:halt, acc}    -> {:halted, acc}
-      {:cont, acc}    -> {:done, acc}
+      {:halt, acc} -> {:halted, acc}
+      {:cont, acc} -> {:done, acc}
     end)
   end
 
@@ -90,7 +99,7 @@ defmodule HashDict do
   def dict_delete(%HashDict{root: root, size: size}, key) do
     case do_delete(root, key, key_hash(key)) do
       {root, value} -> {%HashDict{root: root, size: size - 1}, value}
-      :error        -> :error
+      :error -> :error
     end
   end
 
@@ -98,86 +107,105 @@ defmodule HashDict do
 
   defp do_fetch(node, key, hash) do
     index = key_mask(hash)
+
     case elem(node, index) do
-      [^key|v]     -> {:ok, v}
+      [^key | v] -> {:ok, v}
       {^key, v, _} -> {:ok, v}
-      {_, _, n}    -> do_fetch(n, key, key_shift(hash))
-      _            -> :error
+      {_, _, n} -> do_fetch(n, key, key_shift(hash))
+      _ -> :error
     end
   end
 
   defp do_put(node, key, value, hash) do
     index = key_mask(hash)
+
     case elem(node, index) do
       [] ->
-        {put_elem(node, index, [key|value]), 1}
-      [^key|_] ->
-        {put_elem(node, index, [key|value]), 0}
-      [k|v] ->
-        n = put_elem(@node_template, key_mask(key_shift(hash)), [key|value])
+        {put_elem(node, index, [key | value]), 1}
+
+      [^key | _] ->
+        {put_elem(node, index, [key | value]), 0}
+
+      [k | v] ->
+        n = put_elem(@node_template, key_mask(key_shift(hash)), [key | value])
         {put_elem(node, index, {k, v, n}), 1}
+
       {^key, _, n} ->
         {put_elem(node, index, {key, value, n}), 0}
+
       {k, v, n} ->
         {n, counter} = do_put(n, key, value, key_shift(hash))
         {put_elem(node, index, {k, v, n}), counter}
     end
   end
 
-  defp do_update(node, key, initial, fun, hash) do
+  defp do_update(node, key, default, fun, hash) do
     index = key_mask(hash)
+
     case elem(node, index) do
       [] ->
-        {put_elem(node, index, [key|initial.()]), 1}
-      [^key|value] ->
-        {put_elem(node, index, [key|fun.(value)]), 0}
-      [k|v] ->
-        n = put_elem(@node_template, key_mask(key_shift(hash)), [key|initial.()])
+        {put_elem(node, index, [key | default.()]), 1}
+
+      [^key | value] ->
+        {put_elem(node, index, [key | fun.(value)]), 0}
+
+      [k | v] ->
+        n = put_elem(@node_template, key_mask(key_shift(hash)), [key | default.()])
         {put_elem(node, index, {k, v, n}), 1}
+
       {^key, value, n} ->
         {put_elem(node, index, {key, fun.(value), n}), 0}
+
       {k, v, n} ->
-        {n, counter} = do_update(n, key, initial, fun, key_shift(hash))
+        {n, counter} = do_update(n, key, default, fun, key_shift(hash))
         {put_elem(node, index, {k, v, n}), counter}
     end
   end
 
   defp do_delete(node, key, hash) do
     index = key_mask(hash)
+
     case elem(node, index) do
       [] ->
         :error
-      [^key|value] ->
+
+      [^key | value] ->
         {put_elem(node, index, []), value}
-      [_|_] ->
+
+      [_ | _] ->
         :error
+
       {^key, value, n} ->
         {put_elem(node, index, do_compact_node(n)), value}
+
       {k, v, n} ->
         case do_delete(n, key, key_shift(hash)) do
           {@node_template, value} ->
-            {put_elem(node, index, [k|v]), value}
+            {put_elem(node, index, [k | v]), value}
+
           {n, value} ->
             {put_elem(node, index, {k, v, n}), value}
+
           :error ->
             :error
         end
     end
   end
 
-  Enum.each 0..(@node_size - 1), fn index ->
+  Enum.each(0..(@node_size - 1), fn index ->
     defp do_compact_node(node) when elem(node, unquote(index)) != [] do
       case elem(node, unquote(index)) do
-        [k|v] ->
+        [k | v] ->
           case put_elem(node, unquote(index), []) do
-            @node_template -> [k|v]
+            @node_template -> [k | v]
             n -> {k, v, n}
           end
+
         {k, v, n} ->
           {k, v, put_elem(node, unquote(index), do_compact_node(n))}
       end
     end
-  end
+  end)
 
   ## Dict reduce
 
@@ -193,8 +221,8 @@ defmodule HashDict do
     next.(acc)
   end
 
-  defp do_reduce_each([k|v], {:cont, acc}, fun, next) do
-    next.(fun.({k,v}, acc))
+  defp do_reduce_each([k | v], {:cont, acc}, fun, next) do
+    next.(fun.({k, v}, acc))
   end
 
   defp do_reduce_each({k, v, n}, {:cont, acc}, fun, next) do
@@ -202,7 +230,12 @@ defmodule HashDict do
   end
 
   defp do_reduce(node, acc, fun, count, next) when count > 0 do
-    do_reduce_each(:erlang.element(count, node), acc, fun, &do_reduce(node, &1, fun, count - 1, next))
+    do_reduce_each(
+      :erlang.element(count, node),
+      acc,
+      fun,
+      &do_reduce(node, &1, fun, count - 1, next)
+    )
   end
 
   defp do_reduce(_node, acc, _fun, 0, next) do
@@ -227,41 +260,62 @@ defmodule HashDict do
 end
 
 defimpl Enumerable, for: HashDict do
-  def reduce(dict, acc, fun),  do: HashDict.reduce(dict, acc, fun)
-  def member?(dict, {k, v}), do: {:ok, match?({:ok, ^v}, HashDict.fetch(dict, k))}
-  def member?(_dict, _),       do: {:ok, false}
-  def count(dict),             do: {:ok, HashDict.size(dict)}
-end
+  @moduledoc false
+  @moduledoc deprecated: "Use Map instead"
+
+  def reduce(dict, acc, fun) do
+    # Avoid warnings about HashDict being deprecated.
+    module = String.to_atom("HashDict")
+    module.reduce(dict, acc, fun)
+  end
+
+  def member?(dict, {key, value}) do
+    # Avoid warnings about HashDict being deprecated.
+    module = String.to_atom("HashDict")
+    {:ok, match?({:ok, ^value}, module.fetch(dict, key))}
+  end
+
+  def member?(_dict, _) do
+    {:ok, false}
+  end
 
-defimpl Access, for: HashDict do
-  def get(dict, key) do
-    HashDict.get(dict, key, nil)
+  def count(dict) do
+    # Avoid warnings about HashDict being deprecated.
+    module = String.to_atom("HashDict")
+    {:ok, module.size(dict)}
   end
 
-  def get_and_update(dict, key, fun) do
-    {get, update} = fun.(HashDict.get(dict, key, nil))
-    {get, HashDict.put(dict, key, update)}
+  def slice(_dict) do
+    {:error, __MODULE__}
   end
 end
 
 defimpl Collectable, for: HashDict do
-  def empty(_dict) do
-    HashDict.new
-  end
+  @moduledoc false
+  @moduledoc deprecated: "Use Map instead"
 
   def into(original) do
-    {original, fn
-      dict, {:cont, {k, v}} -> Dict.put(dict, k, v)
+    # Avoid warnings about HashDict being deprecated.
+    module = String.to_atom("HashDict")
+
+    collector_fun = fn
+      dict, {:cont, {key, value}} -> module.put(dict, key, value)
       dict, :done -> dict
       _, :halt -> :ok
-    end}
+    end
+
+    {original, collector_fun}
   end
 end
 
 defimpl Inspect, for: HashDict do
+  @moduledoc false
+  @moduledoc deprecated: "Use Map instead"
   import Inspect.Algebra
 
   def inspect(dict, opts) do
-    concat ["#HashDict<", Inspect.List.inspect(HashDict.to_list(dict), opts), ">"]
+    # Avoid warnings about HashDict being deprecated.
+    module = String.to_atom("HashDict")
+    concat(["#HashDict<", Inspect.List.inspect(module.to_list(dict), opts), ">"])
   end
 end
diff --git a/lib/elixir/lib/hash_set.ex b/lib/elixir/lib/hash_set.ex
index acbc21ae943..aedd38dd55c 100644
--- a/lib/elixir/lib/hash_set.ex
+++ b/lib/elixir/lib/hash_set.ex
@@ -1,27 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule HashSet do
   @moduledoc """
-  A set store.
-
-  The `HashSet` is represented internally as a struct, therefore
-  `%HashSet{}` can be used whenever there is a need to match
-  on any `HashSet`. Note though the struct fields are private and
-  must not be accessed directly. Instead, use the functions on this
-  or in the `Set` module.
-
-  The `HashSet` is implemented using tries, which grows in
-  space as the number of keys grows, working well with both
-  small and large set of keys. For more information about the
-  functions and their APIs, please consult the `Set` module.
+  Tuple-based HashSet implementation.
+
+  This module is deprecated. Use the `MapSet` module instead.
   """
 
-  @behaviour Set
+  @moduledoc deprecated: "Use MapSet instead"
 
   @node_bitmap 0b111
   @node_shift 3
   @node_size 8
   @node_template :erlang.make_tuple(@node_size, [])
 
-  @opaque t :: map
+  message = "Use the MapSet module instead"
+
+  @opaque t :: %__MODULE__{size: non_neg_integer, root: term}
   @doc false
   defstruct size: 0, root: @node_template
 
@@ -29,74 +26,85 @@ defmodule HashSet do
   @compile :inline_list_funcs
   @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}
 
-  @doc """
-  Creates a new empty set.
-  """
-  @spec new :: Set.t
+  @deprecated message
+  @spec new :: Set.t()
   def new do
     %HashSet{}
   end
 
+  @deprecated message
   def union(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) when size1 <= size2 do
-    set_fold set1, set2, fn v, acc -> put(acc, v) end
+    set_fold(set1, set2, fn v, acc -> put(acc, v) end)
   end
 
+  @deprecated message
   def union(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold set2, set1, fn v, acc -> put(acc, v) end
+    set_fold(set2, set1, fn v, acc -> put(acc, v) end)
   end
 
+  @deprecated message
   def intersection(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold set1, %HashSet{}, fn v, acc ->
+    set_fold(set1, %HashSet{}, fn v, acc ->
       if member?(set2, v), do: put(acc, v), else: acc
-    end
+    end)
   end
 
+  @deprecated message
   def difference(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold set2, set1, fn v, acc -> delete(acc, v) end
+    set_fold(set2, set1, fn v, acc -> delete(acc, v) end)
   end
 
+  @deprecated message
   def to_list(set) do
-    set_fold(set, [], &[&1|&2]) |> :lists.reverse
+    set_fold(set, [], &[&1 | &2]) |> :lists.reverse()
   end
 
+  @deprecated message
   def equal?(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) do
     case size1 do
       ^size2 -> subset?(set1, set2)
-      _      -> false
+      _ -> false
     end
   end
 
+  @deprecated message
   def subset?(%HashSet{} = set1, %HashSet{} = set2) do
     reduce(set1, {:cont, true}, fn member, acc ->
       case member?(set2, member) do
         true -> {:cont, acc}
-        _    -> {:halt, false}
+        _ -> {:halt, false}
       end
-    end) |> elem(1)
+    end)
+    |> elem(1)
   end
 
+  @deprecated message
   def disjoint?(%HashSet{} = set1, %HashSet{} = set2) do
     reduce(set2, {:cont, true}, fn member, acc ->
       case member?(set1, member) do
         false -> {:cont, acc}
-        _     -> {:halt, false}
+        _ -> {:halt, false}
       end
-    end) |> elem(1)
+    end)
+    |> elem(1)
   end
 
+  @deprecated message
   def member?(%HashSet{root: root}, term) do
     do_member?(root, term, key_hash(term))
   end
 
+  @deprecated message
   def put(%HashSet{root: root, size: size}, term) do
     {root, counter} = do_put(root, term, key_hash(term))
     %HashSet{root: root, size: size + counter}
   end
 
+  @deprecated message
   def delete(%HashSet{root: root, size: size} = set, term) do
     case do_delete(root, term, key_hash(term)) do
       {:ok, root} -> %HashSet{root: root, size: size - 1}
-      :error      -> set
+      :error -> set
     end
   end
 
@@ -104,11 +112,12 @@ defmodule HashSet do
   def reduce(%HashSet{root: root}, acc, fun) do
     do_reduce(root, acc, fun, @node_size, fn
       {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}
-      {:halt, acc}    -> {:halted, acc}
-      {:cont, acc}    -> {:done, acc}
+      {:halt, acc} -> {:halted, acc}
+      {:cont, acc} -> {:done, acc}
     end)
   end
 
+  @deprecated message
   def size(%HashSet{size: size}) do
     size
   end
@@ -123,72 +132,85 @@ defmodule HashSet do
 
   defp do_member?(node, term, hash) do
     index = key_mask(hash)
+
     case elem(node, index) do
-      []        -> false
-      [^term|_] -> true
-      [_]       -> false
-      [_|n]     -> do_member?(n, term, key_shift(hash))
+      [] -> false
+      [^term | _] -> true
+      [_] -> false
+      [_ | n] -> do_member?(n, term, key_shift(hash))
     end
   end
 
   defp do_put(node, term, hash) do
     index = key_mask(hash)
+
     case elem(node, index) do
       [] ->
         {put_elem(node, index, [term]), 1}
-      [^term|_] ->
+
+      [^term | _] ->
         {node, 0}
+
       [t] ->
         n = put_elem(@node_template, key_mask(key_shift(hash)), [term])
-        {put_elem(node, index, [t|n]), 1}
-      [t|n] ->
+        {put_elem(node, index, [t | n]), 1}
+
+      [t | n] ->
         {n, counter} = do_put(n, term, key_shift(hash))
-        {put_elem(node, index, [t|n]), counter}
+        {put_elem(node, index, [t | n]), counter}
     end
   end
 
   defp do_delete(node, term, hash) do
     index = key_mask(hash)
+
     case elem(node, index) do
       [] ->
         :error
+
       [^term] ->
         {:ok, put_elem(node, index, [])}
+
       [_] ->
         :error
-      [^term|n] ->
+
+      [^term | n] ->
         {:ok, put_elem(node, index, do_compact_node(n))}
-      [t|n] ->
+
+      [t | n] ->
         case do_delete(n, term, key_shift(hash)) do
           {:ok, @node_template} ->
             {:ok, put_elem(node, index, [t])}
+
           {:ok, n} ->
-            {:ok, put_elem(node, index, [t|n])}
+            {:ok, put_elem(node, index, [t | n])}
+
           :error ->
             :error
         end
     end
   end
 
-  Enum.each 0..(@node_size - 1), fn index ->
+  Enum.each(0..(@node_size - 1), fn index ->
     defp do_compact_node(node) when elem(node, unquote(index)) != [] do
       case elem(node, unquote(index)) do
         [t] ->
           case put_elem(node, unquote(index), []) do
             @node_template -> [t]
-            n -> [t|n]
+            n -> [t | n]
           end
-        [t|n] ->
-          [t|put_elem(node, unquote(index), do_compact_node(n))]
+
+        [t | n] ->
+          [t | put_elem(node, unquote(index), do_compact_node(n))]
       end
     end
-  end
+  end)
 
   ## Set fold
 
-  defp do_fold_each([], acc, _fun),   do: acc
-  defp do_fold_each([t], acc, fun),   do: fun.(t, acc)
-  defp do_fold_each([t|n], acc, fun), do: do_fold(n, fun.(t, acc), fun, @node_size)
+  defp do_fold_each([], acc, _fun), do: acc
+  defp do_fold_each([t], acc, fun), do: fun.(t, acc)
+  defp do_fold_each([t | n], acc, fun), do: do_fold(n, fun.(t, acc), fun, @node_size)
 
   defp do_fold(node, acc, fun, count) when count > 0 do
     acc = do_fold_each(:erlang.element(count, node), acc, fun)
@@ -217,12 +239,17 @@ defmodule HashSet do
     next.(fun.(t, acc))
   end
 
-  defp do_reduce_each([t|n], {:cont, acc}, fun, next) do
+  defp do_reduce_each([t | n], {:cont, acc}, fun, next) do
     do_reduce(n, fun.(t, acc), fun, @node_size, next)
   end
 
   defp do_reduce(node, acc, fun, count, next) when count > 0 do
-    do_reduce_each(:erlang.element(count, node), acc, fun, &do_reduce(node, &1, fun, count - 1, next))
+    do_reduce_each(
+      :erlang.element(count, node),
+      acc,
+      fun,
+      &do_reduce(node, &1, fun, count - 1, next)
+    )
   end
 
   defp do_reduce(_node, acc, _fun, 0, next) do
@@ -247,29 +274,58 @@ defmodule HashSet do
 end
 
 defimpl Enumerable, for: HashSet do
-  def reduce(set, acc, fun), do: HashSet.reduce(set, acc, fun)
-  def member?(set, v),       do: {:ok, HashSet.member?(set, v)}
-  def count(set),            do: {:ok, HashSet.size(set)}
+  @moduledoc false
+  @moduledoc deprecated: "Use MapSet instead"
+
+  def reduce(set, acc, fun) do
+    # Avoid warnings about HashSet being deprecated.
+    module = String.to_atom("HashSet")
+    module.reduce(set, acc, fun)
+  end
+
+  def member?(set, term) do
+    # Avoid warnings about HashSet being deprecated.
+    module = String.to_atom("HashSet")
+    {:ok, module.member?(set, term)}
+  end
+
+  def count(set) do
+    # Avoid warnings about HashSet being deprecated.
+    module = String.to_atom("HashSet")
+    {:ok, module.size(set)}
+  end
+
+  def slice(_set) do
+    {:error, __MODULE__}
+  end
 end
 
 defimpl Collectable, for: HashSet do
-  def empty(_dict) do
-    HashSet.new
-  end
+  @moduledoc false
+  @moduledoc deprecated: "Use MapSet instead"
 
   def into(original) do
-    {original, fn
-      set, {:cont, x} -> HashSet.put(set, x)
+    # Avoid warnings about HashSet being deprecated.
+    module = String.to_atom("HashSet")
+
+    collector_fun = fn
+      set, {:cont, term} -> module.put(set, term)
       set, :done -> set
       _, :halt -> :ok
-    end}
+    end
+
+    {original, collector_fun}
   end
 end
 
 defimpl Inspect, for: HashSet do
+  @moduledoc false
+  @moduledoc deprecated: "Use MapSet instead"
   import Inspect.Algebra
 
   def inspect(set, opts) do
-    concat ["#HashSet<", Inspect.List.inspect(HashSet.to_list(set), opts), ">"]
+    # Avoid warnings about HashSet being deprecated.
+    module = String.to_atom("HashSet")
+    concat(["#HashSet<", Inspect.List.inspect(module.to_list(set), opts), ">"])
   end
 end
diff --git a/lib/elixir/lib/inspect.ex b/lib/elixir/lib/inspect.ex
index 26f1dbd5977..169ddfac73a 100644
--- a/lib/elixir/lib/inspect.ex
+++ b/lib/elixir/lib/inspect.ex
@@ -1,471 +1,624 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 import Kernel, except: [inspect: 1]
 import Inspect.Algebra
 
+alias Code.Identifier
+
 defprotocol Inspect do
   @moduledoc """
-  The `Inspect` protocol is responsible for converting any Elixir
-  data structure into an algebra document. This document is then
-  formatted, either in pretty printing format or a regular one.
+  The `Inspect` protocol converts an Elixir data structure into an
+  algebra document.
+
+  This is typically done when you want to customize how your own
+  structs are inspected in logs and the terminal.
+
+  This documentation refers to implementing the `Inspect` protocol
+  for your own data structures. To learn more about using inspect,
+  see `Kernel.inspect/2` and `IO.inspect/2`.
+
+  ## Inspect representation
+
+  There are typically three choices of inspect representation. In order
+  to understand them, let's imagine we have the following `User` struct:
+
+      defmodule User do
+        defstruct [:id, :name, :address]
+      end
+
+  Our choices are:
+
+    1. Print the struct using Elixir's struct syntax, for example:
+       `%User{address: "Earth", id: 13, name: "Jane"}`. This is the
+       default representation and best choice if all struct fields
+       are public.
+
+    2. Print using the `#User<...>` notation, for example: `#User<id: 13, name: "Jane", ...>`.
+       This notation does not emit valid Elixir code and is typically
+       used when the struct has private fields (for example, you may want
+       to hide the field `:address` to redact person identifiable information).
+
+    3. Print the struct using the expression syntax, for example:
+       `User.new(13, "Jane", "Earth")`. This assumes there is a `User.new/3`
+       function. This option is mostly used as an alternative to option 2
+       for representing custom data structures, such as `MapSet`, `Date.Range`,
+       and others.
+
+  You can implement the Inspect protocol for your own structs while
+  adhering to the conventions above. Option 1 is the default representation
+  and you can quickly achieve option 2 by deriving the `Inspect` protocol.
+  For option 3, you need your custom implementation.
+
+  ## Deriving
+
+  The `Inspect` protocol can be derived to customize the order of fields
+  (the default is alphabetical) and hide certain fields from structs,
+  so they don't show up in logs, inspects and similar. The latter is
+  especially useful for fields containing private information.
+
+  The supported options are:
+
+    * `:only` - only include the given fields when inspecting.
+
+    * `:except` - remove the given fields when inspecting.
+
+    * `:optional` - (since v1.14.0) a list of fields that should not be
+      included when they match their default value. This can be used to
+      simplify the struct representation at the cost of hiding
+      information. Since v1.19.0, the `:all` atom can be passed to
+      mark all fields as optional.
+
+  Whenever `:only` or `:except` are used to restrict fields,
+  the struct will be printed using the `#User<...>` notation,
+  as the struct can no longer be copy and pasted as valid Elixir
+  code. Let's see an example:
+
+      defmodule User do
+        @derive {Inspect, only: [:id, :name]}
+        defstruct [:id, :name, :address]
+      end
+
+      inspect(%User{id: 1, name: "Jane", address: "Earth"})
+      #=> #User<id: 1, name: "Jane", ...>
+
+  If you use only the `:optional` option, the struct will still be
+  printed as a valid struct.
 
-  The `inspect/2` function receives the entity to be inspected
-  followed by the inspecting options, represented by the struct
-  `Inspect.Opts`.
+      defmodule Point do
+        @derive {Inspect, optional: [:z]}
+        defstruct [x: 0, y: 0, z: 0]
+      end
+
+      inspect(%Point{x: 1})
+      %Point{x: 1, y: 0}
 
-  Inspection is done using the functions available in `Inspect.Algebra`.
+  ## Custom implementation
 
-  ## Examples
+  You can also define your custom protocol implementation by
+  defining the `inspect/2` function. The function receives the
+  entity to be inspected followed by the inspecting options,
+  represented by the struct `Inspect.Opts` and it must return
+  an algebra document alongside the updated options (or, optionally,
+  just the algebra document). Building of the algebra document
+  is done with `Inspect.Algebra`.
 
   Many times, inspecting a structure can be implemented in function
-  of existing entities. For example, here is `HashSet`'s `inspect`
+  of existing entities. For example, here is `MapSet`'s `inspect/2`
   implementation:
 
-      defimpl Inspect, for: HashSet do
+      defimpl Inspect, for: MapSet do
         import Inspect.Algebra
 
-        def inspect(dict, opts) do
-          concat ["#HashSet<", to_doc(HashSet.to_list(dict), opts), ">"]
+        def inspect(map_set, opts) do
+          {doc, opts} = to_doc_with_opts(MapSet.to_list(map_set), opts)
+          {concat(["MapSet.new(", doc, ")"]), opts}
         end
       end
 
-  The `concat` function comes from `Inspect.Algebra` and it
-  concatenates algebra documents together. In the example above,
-  it is concatenating the string `"HashSet<"` (all strings are
-  valid algebra documents that keep their formatting when pretty
-  printed), the document returned by `Inspect.Algebra.to_doc/2` and the
-  other string `">"`.
+  First [`to_doc_with_opts/2`](`Inspect.Algebra.to_doc_with_opts/2`) is
+  used to convert another data structure into its algebra document and
+  then [`concat/1`](`Inspect.Algebra.concat/1`) concatenates algebra
+  documents together.
+
+  In the example above it is concatenating the string `"MapSet.new("`,
+  the document returned by `to_doc_with_opts/2`, and the final string `")"`.
+  Therefore, the MapSet with the numbers 1, 2, and 3 will be printed as:
 
-  Since regular strings are valid entities in an algebra document,
-  an implementation of inspect may simply return a string,
-  although that will devoid it of any pretty-printing.
+      iex> MapSet.new([1, 2, 3], fn x -> x * 2 end)
+      MapSet.new([2, 4, 6])
 
-  ## Error handling
+  In other words, `MapSet`'s inspect representation returns an expression
+  that, when evaluated, builds the `MapSet` itself.
+
+  ### Error handling
 
   In case there is an error while your structure is being inspected,
-  Elixir will automatically fall back to a raw representation.
+  Elixir will raise an `ArgumentError` error and will automatically fall back
+  to a raw representation for printing the structure. Furthermore, you
+  must be careful when debugging your own Inspect implementation, as calls
+  to `IO.inspect/2` or `dbg/1` may trigger an infinite loop (as in order to
+  inspect/debug the data structure, you must call `inspect` itself).
+
+  Here are some tips:
+
+    * For debugging, use `IO.inspect/2` with the `structs: false` option,
+      which disables custom printing and avoids calling the Inspect
+      implementation recursively
 
-  You can however access the underlying error by invoking the Inspect
-  implementation directly. For example, to test Inspect.HashSet above,
-  you can invoke it as:
+    * To access the underlying error on your custom `Inspect` implementation,
+      you may invoke the protocol directly. For example, we could invoke the
+      `Inspect.MapSet` implementation above as:
 
-      Inspect.HashSet.inspect(HashSet.new, Inspect.Opts.new)
+          Inspect.MapSet.inspect(MapSet.new(), %Inspect.Opts{})
 
+      Note that, from Elixir v1.19, the inspect protocol was augmented to
+      allow a two-element tuple with the document and the updated options
+      to be returned from the protocol.
   """
 
   # Handle structs in Any
   @fallback_to_any true
 
-  def inspect(thing, opts)
-end
+  @impl true
+  defmacro __deriving__(module, options) do
+    info = Macro.struct_info!(module, __CALLER__)
+    fields = Enum.sort(Enum.map(info, & &1.field) -- [:__exception__, :__struct__])
 
-defimpl Inspect, for: Atom do
-  require Macro
+    only = Keyword.get(options, :only, fields)
+    except = Keyword.get(options, :except, [])
 
-  def inspect(atom, _opts) do
-    inspect(atom)
-  end
-
-  def inspect(false),  do: "false"
-  def inspect(true),   do: "true"
-  def inspect(nil),    do: "nil"
-  def inspect(:""),    do: ":\"\""
-
-  def inspect(atom) do
-    binary = Atom.to_string(atom)
+    :ok = validate_option(:only, only, fields, module)
+    :ok = validate_option(:except, except, fields, module)
 
-    cond do
-      valid_ref_identifier?(binary) ->
-        if only_elixir?(binary) do
-          binary
-        else
-          "Elixir." <> rest = binary
-          rest
-        end
-      valid_atom_identifier?(binary) ->
-        ":" <> binary
-      atom in [:%{}, :{}, :<<>>, :..., :%] ->
-        ":" <> binary
-      atom in Macro.binary_ops or atom in Macro.unary_ops ->
-        ":" <> binary
-      true ->
-        << ?:, ?", Inspect.BitString.escape(binary, ?") :: binary, ?" >>
-    end
-  end
+    optional =
+      case Keyword.get(options, :optional, []) do
+        :all ->
+          fields
 
-  defp only_elixir?("Elixir." <> rest), do: only_elixir?(rest)
-  defp only_elixir?("Elixir"), do: true
-  defp only_elixir?(_), do: false
+        optional ->
+          :ok = validate_option(:optional, optional, fields, module)
+          optional
+      end
 
-  # Detect if atom is an atom alias (Elixir.Foo.Bar.Baz)
+    inspect_module =
+      if fields == Enum.sort(only) and except == [] do
+        Inspect.Map
+      else
+        Inspect.Any
+      end
 
-  defp valid_ref_identifier?("Elixir" <> rest) do
-    valid_ref_piece?(rest)
-  end
+    filtered_fields =
+      fields
+      |> Enum.reject(&(&1 in except))
+      |> Enum.filter(&(&1 in only))
 
-  defp valid_ref_identifier?(_), do: false
+    filtered_guard =
+      quote do
+        var!(field) in unquote(filtered_fields)
+      end
 
-  defp valid_ref_piece?(<<?., h, t :: binary>>) when h in ?A..?Z do
-    valid_ref_piece? valid_identifier?(t)
-  end
+    field_guard =
+      if optional == [] do
+        filtered_guard
+      else
+        optional_map =
+          for field <- optional, into: %{} do
+            default = Enum.find(info, %{}, &(&1.field == field)) |> Map.get(:default, nil)
+            {field, default}
+          end
 
-  defp valid_ref_piece?(<<>>), do: true
-  defp valid_ref_piece?(_),    do: false
+        quote do
+          unquote(filtered_guard) and
+            not case unquote(Macro.escape(optional_map)) do
+              %{^var!(field) => var!(default)} ->
+                var!(default) == Map.get(var!(struct), var!(field))
 
-  # Detect if atom
+              %{} ->
+                false
+            end
+        end
+      end
 
-  defp valid_atom_identifier?(<<h, t :: binary>>) when h in ?a..?z or h in ?A..?Z or h == ?_ do
-    valid_atom_piece?(t)
+    quote do
+      defimpl Inspect, for: unquote(module) do
+        def inspect(var!(struct), var!(opts)) do
+          var!(infos) =
+            for %{field: var!(field)} = var!(info) <- unquote(module).__info__(:struct),
+                unquote(field_guard),
+                do: var!(info)
+
+          var!(name) = Macro.inspect_atom(:literal, unquote(module))
+
+          unquote(inspect_module).inspect_as_struct(
+            var!(struct),
+            var!(name),
+            var!(infos),
+            var!(opts)
+          )
+        end
+      end
+    end
   end
 
-  defp valid_atom_identifier?(_), do: false
+  defp validate_option(option, option_list, fields, module) do
+    if not is_list(option_list) do
+      raise ArgumentError,
+            "invalid value #{Kernel.inspect(option_list)} in #{Kernel.inspect(option)} " <>
+              "when deriving the Inspect protocol for #{Kernel.inspect(module)} " <>
+              "(expected a list)"
+    end
 
-  defp valid_atom_piece?(t) do
-    case valid_identifier?(t) do
-      <<>>              -> true
-      <<??>>            -> true
-      <<?!>>            -> true
-      <<?@, t::binary>> -> valid_atom_piece?(t)
-      _                 -> false
+    case option_list -- fields do
+      [] ->
+        :ok
+
+      unknown_fields ->
+        raise ArgumentError,
+              "unknown fields #{Kernel.inspect(unknown_fields)} in #{Kernel.inspect(option)} " <>
+                "when deriving the Inspect protocol for #{Kernel.inspect(module)}"
     end
   end
 
-  defp valid_identifier?(<<h, t :: binary>>)
-      when h in ?a..?z
-      when h in ?A..?Z
-      when h in ?0..?9
-      when h == ?_ do
-    valid_identifier? t
-  end
+  @doc """
+  Converts `term` into an algebra document.
 
-  defp valid_identifier?(other), do: other
+  This function shouldn't be invoked directly, unless when implementing
+  a custom `inspect_fun` to be given to `Inspect.Opts`. Everywhere else,
+  `Inspect.Algebra.to_doc/2` should be preferred as it handles structs
+  and exceptions.
+  """
+  @spec inspect(t, Inspect.Opts.t()) ::
+          Inspect.Algebra.t() | {Inspect.Algebra.t(), Inspect.Opts.t()}
+  def inspect(term, opts)
 end
 
-defimpl Inspect, for: BitString do
-  def inspect(thing, %Inspect.Opts{binaries: bins} = opts) when is_binary(thing) do
-    if bins == :as_strings or (bins == :infer and String.printable?(thing)) do
-      <<?", escape(thing, ?") :: binary, ?">>
-    else
-      inspect_bitstring(thing, opts)
-    end
-  end
-
-  def inspect(thing, opts) do
-    inspect_bitstring(thing, opts)
+defimpl Inspect, for: Atom do
+  def inspect(atom, opts) do
+    color_doc(Macro.inspect_atom(:literal, atom), color_key(atom), opts)
   end
 
-  ## Escaping
+  defp color_key(atom) when is_boolean(atom), do: :boolean
+  defp color_key(nil), do: nil
+  defp color_key(_), do: :atom
+end
 
-  @doc false
-  def escape(other, char) do
-    escape(other, char, <<>>)
-  end
+defimpl Inspect, for: BitString do
+  def inspect(term, opts) when is_binary(term) do
+    %Inspect.Opts{binaries: bins, base: base, printable_limit: printable_limit} = opts
+
+    if bins == :as_strings or
+         (bins == :infer and String.printable?(term, printable_limit) and base == :decimal) do
+      inspected =
+        case Identifier.escape(term, ?", printable_limit) do
+          {escaped, ""} -> [?", escaped, ?"]
+          {escaped, _} -> [?", escaped, ?", " <> ..."]
+        end
 
-  defp escape(<< char, t :: binary >>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, char >>)
-  end
-  defp escape(<<?#, ?{, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?#, ?{>>)
-  end
-  defp escape(<<?\a, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?a >>)
-  end
-  defp escape(<<?\b, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?b >>)
-  end
-  defp escape(<<?\d, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?d >>)
-  end
-  defp escape(<<?\e, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?e >>)
-  end
-  defp escape(<<?\f, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?f >>)
-  end
-  defp escape(<<?\n, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?n >>)
-  end
-  defp escape(<<?\r, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?r >>)
-  end
-  defp escape(<<?\\, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?\\ >>)
-  end
-  defp escape(<<?\t, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?t >>)
-  end
-  defp escape(<<?\v, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, ?\\, ?v >>)
-  end
-  defp escape(<<h :: utf8, t :: binary>>, char, binary) do
-    head = << h :: utf8 >>
-    if String.printable?(head) do
-      escape(t, char, append(head, binary))
+      color_doc(IO.iodata_to_binary(inspected), :string, opts)
     else
-      << byte :: size(8), h :: binary >> = head
-      t = << h :: binary, t :: binary >>
-      escape(t, char, << binary :: binary, escape_char(byte) :: binary >>)
+      inspect_bitstring(term, opts)
     end
   end
-  defp escape(<<h, t :: binary>>, char, binary) do
-    escape(t, char, << binary :: binary, escape_char(h) :: binary >>)
-  end
-  defp escape(<<>>, _char, binary), do: binary
-
-  @doc false
-  # Also used by Regex
-  def escape_char(char) when char in ?\000..?\377,
-    do: octify(char)
-
-  def escape_char(char), do: hexify(char)
 
-  defp octify(byte) do
-    << hi :: size(2), mi :: size(3), lo :: size(3) >> = << byte >>
-    << ?\\, ?0 + hi, ?0 + mi, ?0 + lo >>
+  def inspect(term, opts) do
+    inspect_bitstring(term, opts)
   end
 
-  defp hexify(char) when char < 0x10000 do
-    <<a::4, b::4, c::4, d::4>> = <<char::size(16)>>
-    <<?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c), to_hex(d), ?}>>
+  defp inspect_bitstring("", opts) do
+    color_doc("<<>>", :binary, opts)
   end
 
-  defp hexify(char) when char < 0x1000000 do
-    <<a::4, b::4, c::4, d::4, e::4, f::4>> = <<char::size(24)>>
-    <<?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c),
-                   to_hex(d), to_hex(e), to_hex(f), ?}>>
+  defp inspect_bitstring(bitstring, %{limit: limit} = opts) do
+    left = color_doc("<<", :binary, opts)
+    right = color_doc(">>", :binary, opts)
+    inner = each_bit(bitstring, limit, opts)
+    doc = group(concat(concat(left, nest(inner, 2)), right))
+    new_limit = if limit == :infinity, do: limit, else: max(0, limit - byte_size(bitstring))
+    {doc, %{opts | limit: new_limit}}
   end
 
-  defp to_hex(c) when c in 0..9, do: ?0+c
-  defp to_hex(c) when c in 10..15, do: ?a+c-10
-
-  defp append(<<h, t :: binary>>, binary), do: append(t, << binary :: binary, h >>)
-  defp append(<<>>, binary), do: binary
-
-  ## Bitstrings
-
-  defp inspect_bitstring(bitstring, opts) do
-    each_bit(bitstring, opts.limit, "<<") <> ">>"
+  defp each_bit(_, 0, _) do
+    "..."
   end
 
-  defp each_bit(_, 0, acc) do
-    acc <> "..."
+  defp each_bit(<<>>, _counter, _opts) do
+    Inspect.Algebra.empty()
   end
 
-  defp each_bit(<<h, t :: bitstring>>, counter, acc) when t != <<>> do
-    each_bit(t, decrement(counter), acc <> Integer.to_string(h) <> ", ")
+  defp each_bit(<<h::8>>, _counter, opts) do
+    Inspect.Integer.inspect(h, opts)
   end
 
-  defp each_bit(<<h :: size(8)>>, _counter, acc) do
-    acc <> Integer.to_string(h)
-  end
-
-  defp each_bit(<<>>, _counter, acc) do
-    acc
+  defp each_bit(<<h, t::bitstring>>, counter, opts) do
+    flex_glue(
+      concat(Inspect.Integer.inspect(h, opts), ","),
+      each_bit(t, decrement(counter), opts)
+    )
   end
 
-  defp each_bit(bitstring, _counter, acc) do
+  defp each_bit(bitstring, _counter, opts) do
     size = bit_size(bitstring)
-    <<h :: size(size)>> = bitstring
-    acc <> Integer.to_string(h) <> "::size(" <> Integer.to_string(size) <> ")"
+    <<h::size(^size)>> = bitstring
+    concat(Inspect.Integer.inspect(h, opts), "::size(" <> Integer.to_string(size) <> ")")
   end
 
+  @compile {:inline, decrement: 1}
   defp decrement(:infinity), do: :infinity
-  defp decrement(counter),   do: counter - 1
+  defp decrement(counter), do: counter - 1
 end
 
 defimpl Inspect, for: List do
-  @doc ~S"""
-  Represents a list, checking if it can be printed or not.
-  If so, a single-quoted representation is returned,
-  otherwise the brackets syntax is used. Keywords are
-  printed in keywords syntax.
-
-  ## Examples
-
-      iex> inspect('bar')
-      "'bar'"
+  def inspect([], opts) do
+    color_doc("[]", :list, opts)
+  end
+
+  # TODO: Remove :char_list and :as_char_lists handling on v2.0
+  def inspect(term, opts) do
+    %Inspect.Opts{
+      charlists: lists,
+      char_lists: lists_deprecated,
+      printable_limit: printable_limit
+    } = opts
+
+    lists =
+      if lists == :infer and lists_deprecated != :infer do
+        case lists_deprecated do
+          :as_char_lists ->
+            IO.warn(
+              "the :char_lists inspect option and its :as_char_lists " <>
+                "value are deprecated, use the :charlists option and its " <>
+                ":as_charlists value instead"
+            )
+
+            :as_charlists
+
+          _ ->
+            IO.warn("the :char_lists inspect option is deprecated, use :charlists instead")
+            lists_deprecated
+        end
+      else
+        lists
+      end
 
-      iex> inspect([0|'bar'])
-      "[0, 98, 97, 114]"
+    open = color_doc("[", :list, opts)
+    sep = color_doc(",", :list, opts)
+    close = color_doc("]", :list, opts)
 
-      iex> inspect([:foo,:bar])
-      "[:foo, :bar]"
+    cond do
+      lists == :as_charlists or (lists == :infer and List.ascii_printable?(term, printable_limit)) ->
+        inspected =
+          case Identifier.escape(IO.chardata_to_string(term), ?", printable_limit) do
+            {escaped, ""} -> [?~, ?c, ?", escaped, ?"]
+            {escaped, _} -> [?~, ?c, ?", escaped, ?", " ++ ..."]
+          end
 
-  """
+        color_doc(IO.iodata_to_binary(inspected), :charlist, opts)
 
-  def inspect([], _opts), do: "[]"
+      keyword?(term) ->
+        container_doc_with_opts(open, term, close, opts, &keyword/2,
+          separator: sep,
+          break: :strict
+        )
 
-  def inspect(thing, %Inspect.Opts{char_lists: lists} = opts) do
-    cond do
-      lists == :as_char_lists or (lists == :infer and printable?(thing)) ->
-        << ?', Inspect.BitString.escape(IO.chardata_to_string(thing), ?') :: binary, ?' >>
-      keyword?(thing) ->
-        surround_many("[", thing, "]", opts.limit, &keyword(&1, opts))
       true ->
-        surround_many("[", thing, "]", opts.limit, &to_doc(&1, opts))
+        container_doc_with_opts(open, term, close, opts, &to_doc_with_opts/2, separator: sep)
     end
   end
 
+  @doc false
   def keyword({key, value}, opts) do
-    concat(
-      key_to_binary(key) <> ": ",
-      to_doc(value, opts)
-    )
+    key = color_doc(Macro.inspect_atom(:key, key), :atom, opts)
+    {doc, opts} = to_doc_with_opts(value, opts)
+    {concat(key, concat(" ", doc)), opts}
   end
 
+  @doc false
   def keyword?([{key, _value} | rest]) when is_atom(key) do
-    case Atom.to_char_list(key) do
-      'Elixir.' ++ _ -> false
+    case Atom.to_charlist(key) do
+      [?E, ?l, ?i, ?x, ?i, ?r, ?.] ++ _ -> false
       _ -> keyword?(rest)
     end
   end
 
-  def keyword?([]),     do: true
+  def keyword?([]), do: true
   def keyword?(_other), do: false
-
-  ## Private
-
-  defp key_to_binary(key) do
-    case Inspect.Atom.inspect(key) do
-      ":" <> right -> right
-      other -> other
-    end
-  end
-
-  defp printable?([c|cs]) when is_integer(c) and c in 32..126, do: printable?(cs)
-  defp printable?([?\n|cs]), do: printable?(cs)
-  defp printable?([?\r|cs]), do: printable?(cs)
-  defp printable?([?\t|cs]), do: printable?(cs)
-  defp printable?([?\v|cs]), do: printable?(cs)
-  defp printable?([?\b|cs]), do: printable?(cs)
-  defp printable?([?\f|cs]), do: printable?(cs)
-  defp printable?([?\e|cs]), do: printable?(cs)
-  defp printable?([?\a|cs]), do: printable?(cs)
-  defp printable?([]), do: true
-  defp printable?(_), do: false
 end
 
 defimpl Inspect, for: Tuple do
-  def inspect({}, _opts), do: "{}"
-
   def inspect(tuple, opts) do
-    surround_many("{", Tuple.to_list(tuple), "}", opts.limit, &to_doc(&1, opts))
+    open = color_doc("{", :tuple, opts)
+    sep = color_doc(",", :tuple, opts)
+    close = color_doc("}", :tuple, opts)
+    container_opts = [separator: sep, break: :flex]
+
+    container_doc_with_opts(
+      open,
+      Tuple.to_list(tuple),
+      close,
+      opts,
+      &to_doc_with_opts/2,
+      container_opts
+    )
   end
 end
 
 defimpl Inspect, for: Map do
   def inspect(map, opts) do
-    nest inspect(map, "", opts), 1
+    inspect_as_map(map, opts)
   end
 
-  def inspect(map, name, opts) do
-    map = :maps.to_list(map)
-    surround_many("%" <> name <> "{", map, "}", opts.limit, traverse_fun(map, opts))
-  end
+  def inspect_as_map(map, opts) do
+    list =
+      if Keyword.get(opts.custom_options, :sort_maps) do
+        map |> Map.to_list() |> :lists.sort()
+      else
+        Map.to_list(map)
+      end
 
-  defp traverse_fun(list, opts) do
-    if Inspect.List.keyword?(list) do
-      &Inspect.List.keyword(&1, opts)
-    else
-      &to_map(&1, opts)
-    end
+    fun =
+      if Inspect.List.keyword?(list) do
+        &Inspect.List.keyword/2
+      else
+        sep = color_doc(" => ", :map, opts)
+        &to_assoc(&1, &2, sep)
+      end
+
+    map_container_doc(list, "", opts, fun)
   end
 
-  defp to_map({key, value}, opts) do
-    concat(
-      concat(to_doc(key, opts), " => "),
-      to_doc(value, opts)
-    )
+  def inspect_as_struct(map, name, infos, opts) do
+    fun = fn %{field: field}, opts -> Inspect.List.keyword({field, Map.get(map, field)}, opts) end
+    map_container_doc(infos, name, opts, fun)
   end
-end
 
-defimpl Inspect, for: Integer do
-  def inspect(thing, _opts) do
-    Integer.to_string(thing)
+  defp to_assoc({key, value}, opts, sep) do
+    {key_doc, opts} = to_doc_with_opts(key, opts)
+    {value_doc, opts} = to_doc_with_opts(value, opts)
+    {concat(concat(key_doc, sep), value_doc), opts}
   end
-end
 
-defimpl Inspect, for: Float do
-  def inspect(thing, _opts) do
-    IO.iodata_to_binary(:io_lib_format.fwrite_g(thing))
+  defp map_container_doc(list, name, opts, fun) do
+    open = color_doc("%" <> name <> "{", :map, opts)
+    sep = color_doc(",", :map, opts)
+    close = color_doc("}", :map, opts)
+    container_doc_with_opts(open, list, close, opts, fun, separator: sep, break: :strict)
   end
 end
 
-defimpl Inspect, for: Regex do
-  def inspect(regex, _opts) do
-    delim = ?/
-    concat ["~r",
-            <<delim, escape(regex.source, delim)::binary, delim>>,
-            regex.opts]
+defimpl Inspect, for: Integer do
+  def inspect(term, %Inspect.Opts{base: base} = opts) do
+    inspected = Integer.to_string(term, base_to_value(base)) |> prepend_prefix(base)
+    color_doc(inspected, :number, opts)
   end
 
-  defp escape(bin, term),
-    do: escape(bin, <<>>, term)
-
-  defp escape(<<?\\, term>> <> rest, buf, term),
-    do: escape(rest, buf <> <<?\\, term>>, term)
-
-  defp escape(<<term>> <> rest, buf, term),
-    do: escape(rest, buf <> <<?\\, term>>, term)
-
-  # the list of characters is from `String.printable?` impl
-  # minus characters treated specially by regex: \s, \d, \b, \e
+  defp base_to_value(base) do
+    case base do
+      :binary -> 2
+      :decimal -> 10
+      :octal -> 8
+      :hex -> 16
+    end
+  end
 
-  defp escape(<<?\n>> <> rest, buf, term),
-    do: escape(rest, <<buf::binary, ?\\, ?n>>, term)
+  defp prepend_prefix(value, :decimal), do: value
 
-  defp escape(<<?\r>> <> rest, buf, term),
-    do: escape(rest, <<buf::binary, ?\\, ?r>>, term)
+  defp prepend_prefix(<<?-, value::binary>>, base) do
+    "-" <> prepend_prefix(value, base)
+  end
 
-  defp escape(<<?\t>> <> rest, buf, term),
-    do: escape(rest, <<buf::binary, ?\\, ?t>>, term)
+  defp prepend_prefix(value, base) do
+    prefix =
+      case base do
+        :binary -> "0b"
+        :octal -> "0o"
+        :hex -> "0x"
+      end
 
-  defp escape(<<?\v>> <> rest, buf, term),
-    do: escape(rest, <<buf::binary, ?\\, ?v>>, term)
+    prefix <> value
+  end
+end
 
-  defp escape(<<?\f>> <> rest, buf, term),
-    do: escape(rest, <<buf::binary, ?\\, ?f>>, term)
+defimpl Inspect, for: Float do
+  def inspect(float, opts) do
+    abs = abs(float)
+
+    formatted =
+      if abs >= 1.0 and abs < 1.0e16 and trunc(float) == float do
+        [Integer.to_string(trunc(float)), ?., ?0]
+      else
+        Float.to_charlist(float)
+      end
 
-  defp escape(<<?\a>> <> rest, buf, term),
-    do: escape(rest, <<buf::binary, ?\\, ?a>>, term)
+    color_doc(IO.iodata_to_binary(formatted), :number, opts)
+  end
+end
 
-  defp escape(<<c::utf8>> <> rest, buf, term) do
-    charstr = <<c::utf8>>
-    if String.printable?(charstr) and not c in [?\d, ?\b, ?\e] do
-      escape(rest, buf <> charstr, term)
-    else
-      escape(rest, buf <> Inspect.BitString.escape_char(c), term)
+defimpl Inspect, for: Regex do
+  def inspect(regex = %{opts: regex_opts}, opts) when is_list(regex_opts) do
+    case translate_options(regex_opts, []) do
+      :error ->
+        concat([
+          "Regex.compile!(",
+          to_doc(regex.source, opts),
+          ", ",
+          to_doc(regex_opts, opts),
+          ")"
+        ])
+
+      translated_opts ->
+        {escaped, _} =
+          regex.source
+          |> normalize(<<>>)
+          |> Identifier.escape(?/, :infinity, &escape_map/1)
+
+        source = IO.iodata_to_binary([?~, ?r, ?/, escaped, ?/, translated_opts])
+        color_doc(source, :regex, opts)
     end
   end
 
-  defp escape(<<c>> <> rest, buf, term),
-    do: escape(rest, <<buf::binary, Inspect.BitString.escape_char(c)>>, term)
-
-  defp escape(<<>>, buf, _), do: buf
+  defp translate_options([:dotall, {:newline, :anycrlf} | t], acc),
+    do: translate_options(t, [?s | acc])
+
+  defp translate_options([:unicode, :ucp | t], acc), do: translate_options(t, [?u | acc])
+  defp translate_options([:caseless | t], acc), do: translate_options(t, [?i | acc])
+  defp translate_options([:extended | t], acc), do: translate_options(t, [?x | acc])
+  defp translate_options([:firstline | t], acc), do: translate_options(t, [?f | acc])
+  defp translate_options([:ungreedy | t], acc), do: translate_options(t, [?U | acc])
+  defp translate_options([:multiline | t], acc), do: translate_options(t, [?m | acc])
+  defp translate_options([:export | t], acc), do: translate_options(t, [?E | acc])
+  defp translate_options([], acc), do: acc
+  defp translate_options(_t, _acc), do: :error
+
+  defp normalize(<<?\\, ?\\, rest::binary>>, acc), do: normalize(rest, <<acc::binary, ?\\, ?\\>>)
+  defp normalize(<<?\\, ?/, rest::binary>>, acc), do: normalize(rest, <<acc::binary, ?/>>)
+  defp normalize(<<?\\, ?#, ?{, rest::binary>>, acc), do: normalize(rest, <<acc::binary, ?#, ?{>>)
+  defp normalize(<<char, rest::binary>>, acc), do: normalize(rest, <<acc::binary, char>>)
+  defp normalize(<<>>, acc), do: acc
+
+  defp escape_map(?\a), do: [?\\, ?a]
+  defp escape_map(?\f), do: [?\\, ?f]
+  defp escape_map(?\n), do: [?\\, ?n]
+  defp escape_map(?\r), do: [?\\, ?r]
+  defp escape_map(?\t), do: [?\\, ?t]
+  defp escape_map(?\v), do: [?\\, ?v]
+  defp escape_map(_), do: false
 end
 
 defimpl Inspect, for: Function do
+  @elixir_compiler :binary.bin_to_list("elixir_compiler_")
+
   def inspect(function, _opts) do
-    fun_info = :erlang.fun_info(function)
+    fun_info = Function.info(function)
     mod = fun_info[:module]
+    name = fun_info[:name]
 
-    if fun_info[:type] == :external and fun_info[:env] == [] do
-      "&#{Inspect.Atom.inspect(mod)}.#{fun_info[:name]}/#{fun_info[:arity]}"
-    else
-      case Atom.to_char_list(mod) do
-        'elixir_compiler_' ++ _ ->
-          if function_exported?(mod, :__RELATIVE__, 0) do
-            "#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__}>"
-          else
-            default_inspect(mod, fun_info)
-          end
-        _ ->
+    cond do
+      not is_atom(mod) ->
+        "#Function<#{uniq(fun_info)}/#{fun_info[:arity]}>"
+
+      fun_info[:type] == :external and fun_info[:env] == [] ->
+        inspected_as_atom = Macro.inspect_atom(:literal, mod)
+        inspected_as_function = Macro.inspect_atom(:remote_call, name)
+        "&#{inspected_as_atom}.#{inspected_as_function}/#{fun_info[:arity]}"
+
+      match?(@elixir_compiler ++ _, Atom.to_charlist(mod)) ->
+        if function_exported?(mod, :__RELATIVE__, 0) do
+          "#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__()}>"
+        else
           default_inspect(mod, fun_info)
-      end
+        end
+
+      true ->
+        default_inspect(mod, fun_info)
     end
   end
 
   defp default_inspect(mod, fun_info) do
-    "#Function<#{uniq(fun_info)}/#{fun_info[:arity]} in " <>
-      "#{Inspect.Atom.inspect(mod)}#{extract_name(fun_info[:name])}>"
+    inspected_as_atom = Macro.inspect_atom(:literal, mod)
+    extracted_name = extract_name(fun_info[:name])
+    "#Function<#{uniq(fun_info)}/#{fun_info[:arity]} in #{inspected_as_atom}#{extracted_name}>"
   end
 
   defp extract_name([]) do
@@ -473,16 +626,17 @@ defimpl Inspect, for: Function do
   end
 
   defp extract_name(name) do
-    name = Atom.to_string(name)
-    case :binary.split(name, "-", [:global]) do
-      ["", name | _] -> "." <> name
-      _ -> "." <> name
+    case Identifier.extract_anonymous_fun_parent(name) do
+      {name, arity} ->
+        "." <> Macro.inspect_atom(:remote_call, name) <> "/" <> arity
+
+      :error ->
+        "." <> Macro.inspect_atom(:remote_call, name)
     end
   end
 
   defp uniq(fun_info) do
-    Integer.to_string(fun_info[:new_index]) <> "." <>
-      Integer.to_string(fun_info[:uniq])
+    Integer.to_string(fun_info[:new_index]) <> "." <> Integer.to_string(fun_info[:uniq])
   end
 end
 
@@ -494,31 +648,77 @@ end
 
 defimpl Inspect, for: Port do
   def inspect(port, _opts) do
-    IO.iodata_to_binary :erlang.port_to_list(port)
+    IO.iodata_to_binary(:erlang.port_to_list(port))
   end
 end
 
 defimpl Inspect, for: Reference do
   def inspect(ref, _opts) do
-    '#Ref' ++ rest = :erlang.ref_to_list(ref)
+    [?#, ?R, ?e, ?f] ++ rest = :erlang.ref_to_list(ref)
     "#Reference" <> IO.iodata_to_binary(rest)
   end
 end
 
 defimpl Inspect, for: Any do
-  def inspect(%{__struct__: struct} = map, opts) do
-    try do
-      struct.__struct__
-    rescue
-      _ -> Inspect.Map.inspect(map, opts)
-    else
-      dunder ->
-        if :maps.keys(dunder) == :maps.keys(map) do
-          pruned = :maps.remove(:__exception__, :maps.remove(:__struct__, map))
-          Inspect.Map.inspect(pruned, Inspect.Atom.inspect(struct, opts), opts)
-        else
-          Inspect.Map.inspect(map, opts)
-        end
+  def inspect(%module{} = struct, opts) do
+    info =
+      for %{field: field} = map <- module.__info__(:struct),
+          field != :__exception__,
+          do: map
+
+    Inspect.Map.inspect_as_struct(struct, Macro.inspect_atom(:literal, module), info, opts)
+  end
+
+  def inspect_as_struct(map, name, infos, opts) do
+    open = color_doc("#" <> name <> "<", :map, opts)
+    sep = color_doc(",", :map, opts)
+    close = color_doc(">", :map, opts)
+
+    fun = fn
+      %{field: field}, opts -> Inspect.List.keyword({field, Map.get(map, field)}, opts)
+      :..., _opts -> "..."
     end
+
+    container_doc(open, infos ++ [:...], close, opts, fun, separator: sep, break: :strict)
+  end
+end
+
+defimpl Inspect, for: Range do
+  import Inspect.Algebra
+  import Kernel, except: [inspect: 2]
+
+  def inspect(first..last//1, opts) when last >= first do
+    concat([to_doc(first, opts), "..", to_doc(last, opts)])
+  end
+
+  def inspect(first..last//step, opts) do
+    concat([to_doc(first, opts), "..", to_doc(last, opts), "//", to_doc(step, opts)])
+  end
+
+  # TODO: Remove me on v2.0
+  def inspect(%{__struct__: Range, first: first, last: last} = range, opts) do
+    step = if first <= last, do: 1, else: -1
+    inspect(Map.put(range, :step, step), opts)
   end
 end
+
+require Protocol
+
+Protocol.derive(
+  Inspect,
+  Macro.Env,
+  only: [
+    :module,
+    :file,
+    :line,
+    :function,
+    :context,
+    :aliases,
+    :requires,
+    :functions,
+    :macros,
+    :macro_aliases,
+    :context_modules,
+    :lexical_tracker
+  ]
+)
diff --git a/lib/elixir/lib/inspect/algebra.ex b/lib/elixir/lib/inspect/algebra.ex
index 3a3b915d786..99b8d5cce55 100644
--- a/lib/elixir/lib/inspect/algebra.ex
+++ b/lib/elixir/lib/inspect/algebra.ex
@@ -1,55 +1,205 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Inspect.Opts do
   @moduledoc """
-  Defines the Inspect.Opts used by the Inspect protocol.
+  Defines the options used by the `Inspect` protocol.
 
   The following fields are available:
 
-    * `:structs` - when false, structs are not formatted by the inspect
-      protocol, they are instead printed as maps, defaults to true.
+    * `:base` - prints integers and binaries as `:binary`, `:octal`, `:decimal`,
+      or `:hex`. Defaults to `:decimal`.
 
-    * `:binaries` - when `:as_strings` all binaries will be printed as strings,
-      non-printable bytes will be escaped.
+    * `:binaries` - when `:as_binaries` all binaries will be printed in bit
+      syntax.
 
-      When `:as_binaries` all binaries will be printed in bit syntax.
+      When `:as_strings` all binaries will be printed as strings, non-printable
+      bytes will be escaped.
 
-      When the default `:infer`, the binary will be printed as a string if it
-      is printable, otherwise in bit syntax.
+      When the default `:infer`, the binary will be printed as a string if `:base`
+      is `:decimal` and if it is printable, otherwise in bit syntax. See
+      `String.printable?/1` to learn when a string is printable.
 
-    * `:char_lists` - when `:as_char_lists` all lists will be printed as char
-      lists, non-printable elements will be escaped.
+    * `:charlists` - when `:as_charlists` all lists will be printed as charlists,
+      non-printable elements will be escaped.
 
       When `:as_lists` all lists will be printed as lists.
 
-      When the default `:infer`, the list will be printed as a char list if it
-      is printable, otherwise as list.
+      When the default `:infer`, the list will be printed as a charlist if it
+      is printable, otherwise as list. See `List.ascii_printable?/1` to learn
+      when a charlist is printable.
+
+    * `:custom_options` (since v1.9.0) - a keyword list storing custom user-defined
+      options. Useful when implementing the `Inspect` protocol for nested structs
+      to pass the custom options through.
+
+      It supports some pre-defined keys:
+
+      - `:sort_maps` (since v1.14.4) - if set to `true`, sorts key-value pairs
+        in maps. This can be helpful to make map inspection deterministic for
+        testing, given maps key order is random.
+
+    * `:inspect_fun` (since v1.9.0) - a function to build algebra documents.
+      Defaults to `Inspect.Opts.default_inspect_fun/0`.
+
+    * `:limit` - limits the number of items that are inspected for tuples,
+      bitstrings, maps, lists and any other collection of items, with the exception of
+      printable strings and printable charlists which use the `:printable_limit` option.
+      It accepts a positive integer or `:infinity`. It defaults to `100` since
+      `Elixir v1.19.0`, as it has better defaults to deal with nested collections.
+
+    * `:pretty` - if set to `true` enables pretty printing. Defaults to `false`.
+
+    * `:printable_limit` - limits the number of characters that are inspected
+      on printable strings and printable charlists. You can use `String.printable?/1`
+      and `List.ascii_printable?/1` to check if a given string or charlist is
+      printable. If you don't want to limit the number of characters to a particular
+      number, use `:infinity`. It accepts a positive integer or `:infinity`.
+      Defaults to `4096`.
+
+    * `:safe` - when `false`, failures while inspecting structs will be raised
+      as errors instead of being wrapped in the `Inspect.Error` exception. This
+      is useful when debugging failures and crashes for custom inspect
+      implementations. Defaults to `true`.
+
+    * `:structs` - when `false`, structs are not formatted by the inspect
+      protocol, they are instead printed as maps. Defaults to `true`.
+
+    * `:syntax_colors` - when set to a keyword list of colors the output is
+      colorized. The keys are types and the values are the colors to use for
+      each type (for example, `[number: :red, atom: :blue]`). Types can include
+      `:atom`, `:binary`, `:boolean`, `:list`, `:map`, `:number`, `:regex`,
+      `:string`, `:tuple`, or some types to represent AST like `:variable`,
+      `:call`, and `:operator`.
+      Custom data types may provide their own options.
+      Colors can be any `t:IO.ANSI.ansidata/0` as accepted by `IO.ANSI.format/1`.
+      A default list of colors can be retrieved from `IO.ANSI.syntax_colors/0`.
+
+    * `:width` - number of characters per line used when pretty is `true` or when
+      printing to IO devices. Set to `0` to force each item to be printed on its
+      own line. If you don't want to limit the number of items to a particular
+      number, use `:infinity`. Defaults to `80`.
 
-    * `:limit` - limits the number of items that are printed for tuples,
-      bitstrings, and lists, does not apply to strings nor char lists, defaults
-      to 50.
+  """
 
-    * `:pretty` - if set to true enables pretty printing, defaults to false.
+  # TODO: Remove :char_lists key on v2.0
+  defstruct base: :decimal,
+            binaries: :infer,
+            char_lists: :infer,
+            charlists: :infer,
+            custom_options: [],
+            inspect_fun: &Inspect.inspect/2,
+            limit: 100,
+            pretty: false,
+            printable_limit: 4096,
+            safe: true,
+            structs: true,
+            syntax_colors: [],
+            width: 80
+
+  @type color_key :: atom
+
+  @type t :: %__MODULE__{
+          base: :decimal | :binary | :hex | :octal,
+          binaries: :infer | :as_binaries | :as_strings,
+          charlists: :infer | :as_lists | :as_charlists,
+          custom_options: keyword,
+          inspect_fun: (any, t -> Inspect.Algebra.t()),
+          limit: non_neg_integer | :infinity,
+          pretty: boolean,
+          printable_limit: non_neg_integer | :infinity,
+          safe: boolean,
+          structs: boolean,
+          syntax_colors: [{color_key, IO.ANSI.ansidata()}],
+          width: non_neg_integer | :infinity
+        }
+
+  @typedoc """
+  Options for building an `Inspect.Opts` struct with `new/1`.
+  """
+  @type new_opt ::
+          {:base, :decimal | :binary | :hex | :octal}
+          | {:binaries, :infer | :as_binaries | :as_strings}
+          | {:charlists, :infer | :as_lists | :as_charlists}
+          | {:custom_options, keyword}
+          | {:inspect_fun, (any, t -> Inspect.Algebra.t())}
+          | {:limit, non_neg_integer | :infinity}
+          | {:pretty, boolean}
+          | {:printable_limit, non_neg_integer | :infinity}
+          | {:safe, boolean}
+          | {:structs, boolean}
+          | {:syntax_colors, [{color_key, IO.ANSI.ansidata()}]}
+          | {:width, non_neg_integer | :infinity}
+
+  @doc """
+  Builds an `Inspect.Opts` struct.
+  """
+  @doc since: "1.13.0"
+  @spec new([new_opt()]) :: t
+  def new(opts) do
+    struct(%Inspect.Opts{inspect_fun: default_inspect_fun()}, opts)
+  end
 
-    * `:width` - defaults to the 80 characters.
+  @doc """
+  Returns the default inspect function.
   """
+  @doc since: "1.13.0"
+  @spec default_inspect_fun() :: (term, t -> Inspect.Algebra.t())
+  def default_inspect_fun do
+    :persistent_term.get({__MODULE__, :inspect_fun}, &Inspect.inspect/2)
+  end
+
+  @doc """
+  Sets the default inspect function.
+
+  Set this option with care as it will change how all values
+  in the system are inspected. The main use of this functionality
+  is to provide an entry point to filter inspected values,
+  in order for entities to comply with rules and legislations
+  on data security and data privacy.
+
+  It is **extremely discouraged** for libraries to set their own
+  function as this must be controlled by applications. Libraries
+  should instead define their own structs with custom inspect
+  implementations. If a library must change the default inspect
+  function, then it is best to ask users of your library to explicitly
+  call `default_inspect_fun/1` with your function of choice.
+
+  The default is `Inspect.inspect/2`.
+
+  ## Examples
+
+      previous_fun = Inspect.Opts.default_inspect_fun()
+
+      Inspect.Opts.default_inspect_fun(fn
+        %{address: _} = map, opts ->
+          previous_fun.(%{map | address: "[REDACTED]"}, opts)
+
+        value, opts ->
+          previous_fun.(value, opts)
+      end)
 
-  defstruct structs: true :: boolean,
-            binaries: :infer :: :infer | :as_binaries | :as_strings,
-            char_lists: :infer :: :infer | :as_lists | :as_char_lists,
-            limit: 50 :: pos_integer,
-            width: 80 :: pos_integer | :infinity,
-            pretty: false :: boolean
+  """
+  @doc since: "1.13.0"
+  @spec default_inspect_fun((term, t -> Inspect.Algebra.t())) :: :ok
+  def default_inspect_fun(fun) when is_function(fun, 2) do
+    :persistent_term.put({__MODULE__, :inspect_fun}, fun)
+  end
 end
 
 defmodule Inspect.Algebra do
   @moduledoc ~S"""
   A set of functions for creating and manipulating algebra
-  documents, as described in ["Strictly Pretty" (2000) by Christian Lindig][0].
+  documents.
 
-  An algebra document is represented by an `Inspect.Algebra` node
-  or a regular string.
+  This module implements the functionality described in
+  ["Strictly Pretty" (2000) by Christian Lindig][0] with small
+  additions, like support for binary nodes and a break mode that
+  maximises use of horizontal space.
 
-      iex> Inspect.Algebra.empty
-      :doc_nil
+      iex> Inspect.Algebra.line()
+      :doc_line
 
       iex> "foo"
       "foo"
@@ -57,445 +207,1191 @@ defmodule Inspect.Algebra do
   With the functions in this module, we can concatenate different
   elements together and render them:
 
-      iex> doc = Inspect.Algebra.concat(Inspect.Algebra.empty, "foo")
-      iex> Inspect.Algebra.pretty(doc, 80)
+      iex> doc = Inspect.Algebra.concat(Inspect.Algebra.empty(), "foo")
+      iex> Inspect.Algebra.format(doc, 80)
       "foo"
 
   The functions `nest/2`, `space/2` and `line/2` help you put the
   document together into a rigid structure. However, the document
-  algebra gets interesting when using functions like `break/2`, which
-  converts the given string into a line break depending on how much space
-  there is to print. Let's glue two docs together with a break and then
-  render it:
+  algebra gets interesting when using functions like `glue/3` and
+  `group/1`. A glue inserts a break between two documents. A group
+  indicates a document that must fit the current line, otherwise
+  breaks are rendered as new lines. Let's glue two docs together
+  with a break, group it and then render it:
 
       iex> doc = Inspect.Algebra.glue("a", " ", "b")
-      iex> Inspect.Algebra.pretty(doc, 80)
+      iex> doc = Inspect.Algebra.group(doc)
+      iex> Inspect.Algebra.format(doc, 80)
       "a b"
 
-  Notice the break was represented as is, because we haven't reached
+  Note that the break was represented as is, because we haven't reached
   a line limit. Once we do, it is replaced by a newline:
 
       iex> doc = Inspect.Algebra.glue(String.duplicate("a", 20), " ", "b")
-      iex> Inspect.Algebra.pretty(doc, 10)
+      iex> doc = Inspect.Algebra.group(doc)
+      iex> Inspect.Algebra.format(doc, 10)
       "aaaaaaaaaaaaaaaaaaaa\nb"
 
+  This module uses the byte size to compute how much space there is
+  left. If your document contains strings, then those need to be
+  wrapped in `string/1`, which then relies on `String.length/1` to
+  precompute the document size.
+
   Finally, this module also contains Elixir related functions, a bit
-  tied to Elixir formatting, namely `surround/3` and `surround_many/5`.
+  tied to Elixir formatting, such as `to_doc/2`.
 
   ## Implementation details
 
-  The original Haskell implementation of the algorithm by [Wadler][1]
-  relies on lazy evaluation to unfold document groups on two alternatives:
-  `:flat` (breaks as spaces) and `:break` (breaks as newlines).
-  Implementing the same logic in a strict language such as Elixir leads
-  to an exponential growth of possible documents, unless document groups
-  are encoded explictly as `:flat` or `:break`. Those groups are then reduced
-  to a simple document, where the layout is already decided, per [Lindig][0].
+  The implementation of `Inspect.Algebra` is based on the Strictly Pretty
+  paper by [Lindig][0] which builds on top of previous pretty printing
+  algorithms but is tailored to strict languages, such as Elixir.
+  The core idea in the paper is the use of explicit document groups which
+  are rendered as flat (breaks as spaces) or as break (breaks as newlines).
 
-  This implementation slightly changes the semantic of Lindig's algorithm
-  to allow elements that belong to the same group to be printed together
-  in the same line, even if they do not fit the line fully. This was achieved
-  by changing `:break` to mean a possible break and `:flat` to force a flat
-  structure. Then deciding if a break works as a newline is just a matter
-  of checking if we have enough space until the next break that is not
-  inside a group (which is still flat).
+  This implementation provides two types of breaks: `:strict` and `:flex`.
+  When a group does not fit, all strict breaks are treated as newlines.
+  Flex breaks, however, are re-evaluated on every occurrence and may still
+  be rendered flat. See `break/1` and `flex_break/1` for more information.
 
-  Custom pretty printers can be implemented using the documents returned
-  by this module and by providing their own rendering functions.
+  This implementation also adds `force_unfit/1` and optimistic/pessimistic
+  groups which give more control over the document fitting.
 
-    [0]: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.34.2200
-    [1]: http://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf
+    [0]: https://lindig.github.io/papers/strictly-pretty-2000.pdf
 
   """
 
-  @surround_separator ","
+  @container_separator ","
   @tail_separator " |"
   @newline "\n"
-  @nesting 1
-  @break " "
 
-  # Functional interface to `doc` records
+  # Functional interface to "doc" records
+
+  @type t ::
+          binary
+          | doc_nil
+          | doc_cons
+          | doc_line
+          | doc_break
+          | doc_collapse
+          | doc_color
+          | doc_fits
+          | doc_force
+          | doc_group
+          | doc_nest
+          | doc_string
+          | doc_limit
+
+  @typep doc_nil :: []
+  defmacrop doc_nil do
+    []
+  end
 
-  @type t :: :doc_nil | :doc_line | doc_cons | doc_nest | doc_break | doc_group | binary
+  @typep doc_line :: :doc_line
+  defmacrop doc_line do
+    :doc_line
+  end
 
-  @typep doc_cons :: {:doc_cons, t, t}
+  @typep doc_cons :: nonempty_improper_list(t, t)
   defmacrop doc_cons(left, right) do
-    quote do: {:doc_cons, unquote(left), unquote(right)}
+    quote do: [unquote(left) | unquote(right)]
   end
 
-  @typep doc_nest :: {:doc_nest, t, non_neg_integer}
-  defmacrop doc_nest(doc, indent) do
-    quote do: {:doc_nest, unquote(doc), unquote(indent) }
+  @typep doc_string :: {:doc_string, binary, non_neg_integer}
+  defmacrop doc_string(string, length) do
+    quote do: {:doc_string, unquote(string), unquote(length)}
   end
 
-  @typep doc_break :: {:doc_break, binary}
-  defmacrop doc_break(break) do
-    quote do: {:doc_break, unquote(break)}
+  @typep doc_limit :: {:doc_limit, t, pos_integer | :infinity}
+  defmacrop doc_limit(doc, limit) do
+    quote do: {:doc_limit, unquote(doc), unquote(limit)}
   end
 
-  @typep doc_group :: {:doc_group, t}
-  defmacrop doc_group(group) do
-    quote do: {:doc_group, unquote(group)}
+  @typep doc_nest :: {:doc_nest, t, :cursor | :reset | non_neg_integer, :always | :break}
+  defmacrop doc_nest(doc, indent, always_or_break) do
+    quote do: {:doc_nest, unquote(doc), unquote(indent), unquote(always_or_break)}
   end
 
-  defmacrop is_doc(doc) do
-    if Macro.Env.in_guard?(__CALLER__) do
-      do_is_doc(doc)
-    else
-      var = quote do: doc
-      quote do
-        unquote(var) = unquote(doc)
-        unquote(do_is_doc(var))
-      end
-    end
+  @typep doc_break :: {:doc_break, binary, :flex | :strict}
+  defmacrop doc_break(break, mode) do
+    quote do: {:doc_break, unquote(break), unquote(mode)}
   end
 
-  defp do_is_doc(doc) do
-    quote do
-      is_binary(unquote(doc)) or
-      unquote(doc) in [:doc_nil, :doc_line] or
-      (is_tuple(unquote(doc)) and
-       elem(unquote(doc), 0) in [:doc_cons, :doc_nest, :doc_break, :doc_group])
-    end
+  @typep doc_group :: {:doc_group, t, :normal | :optimistic | :pessimistic | :inherit}
+  defmacrop doc_group(group, mode) do
+    quote do: {:doc_group, unquote(group), unquote(mode)}
+  end
+
+  @typep doc_fits :: {:doc_fits, t, :enabled | :disabled}
+  defmacrop doc_fits(group, mode) do
+    quote do: {:doc_fits, unquote(group), unquote(mode)}
+  end
+
+  @typep doc_force :: {:doc_force, t}
+  defmacrop doc_force(group) do
+    quote do: {:doc_force, unquote(group)}
+  end
+
+  @typep doc_collapse :: {:doc_collapse, pos_integer()}
+  defmacrop doc_collapse(count) do
+    quote do: {:doc_collapse, unquote(count)}
+  end
+
+  @typep doc_color :: {:doc_color, t, IO.ANSI.ansidata()}
+  defmacrop doc_color(doc, color) do
+    quote do: {:doc_color, unquote(doc), unquote(color)}
+  end
+
+  @typedoc """
+  Options for container documents.
+  """
+  @type container_opts :: [
+          separator: String.t(),
+          break: :strict | :flex | :maybe
+        ]
+
+  @docs [
+    :doc_break,
+    :doc_collapse,
+    :doc_color,
+    :doc_cons,
+    :doc_fits,
+    :doc_force,
+    :doc_group,
+    :doc_nest,
+    :doc_string,
+    :doc_limit
+  ]
+
+  defguard is_doc(doc)
+           when is_list(doc) or is_binary(doc) or doc == doc_line() or
+                  (is_tuple(doc) and elem(doc, 0) in @docs)
+
+  defguardp is_width(width) when width == :infinity or (is_integer(width) and width >= 0)
+
+  # Elixir + Inspect.Opts conveniences
+  # These have the _doc suffix.
+
+  @doc """
+  Converts an Elixir term to an algebra document
+  according to the `Inspect` protocol.
+
+  In practice, one must prefer to use `to_doc_with_opts/2`
+  over this function, as `to_doc_with_opts/2` returns the
+  updated options from inspection.
+  """
+  @spec to_doc(any, Inspect.Opts.t()) :: t
+  def to_doc(term, opts) do
+    to_doc_with_opts(term, opts) |> elem(0)
   end
 
   @doc """
-  Converts an Elixir structure to an algebra document
-  according to the inspect protocol.
+  Converts an Elixir term to an algebra document
+  according to the `Inspect` protocol, alongside the updated options.
+
+  This function is used when implementing the inspect protocol for
+  a given type and you must convert nested terms to documents too.
   """
-  @spec to_doc(any, Inspect.Opts.t) :: t
-  def to_doc(%{__struct__: struct} = map, %Inspect.Opts{} = opts) when is_atom(struct) do
-    if opts.structs do
+  @doc since: "1.19.0"
+  @spec to_doc_with_opts(any, Inspect.Opts.t()) :: {t, Inspect.Opts.t()}
+  def to_doc_with_opts(term, opts)
+
+  def to_doc_with_opts(%_{} = struct, %Inspect.Opts{inspect_fun: fun} = opts) do
+    if opts.structs and valid_struct?(struct) do
       try do
-        Inspect.inspect(map, opts)
+        fun.(struct, opts)
       rescue
-        e ->
-          res = Inspect.Map.inspect(map, opts)
-          raise ArgumentError,
-            "Got #{inspect e.__struct__} with message " <>
-            "\"#{Exception.message(e)}\" while inspecting #{pretty(res, opts.width)}"
+        caught_exception ->
+          # Because we try to raise a nice error message in case
+          # we can't inspect a struct, there is a chance the error
+          # message itself relies on the struct being printed, so
+          # we need to trap the inspected messages to guarantee
+          # we won't try to render any failed instruct when building
+          # the error message.
+          if Process.get(:inspect_trap) do
+            Inspect.Map.inspect_as_map(struct, opts)
+          else
+            try do
+              Process.put(:inspect_trap, true)
+
+              {doc_struct, _opts} =
+                Inspect.Map.inspect_as_map(struct, %{
+                  opts
+                  | syntax_colors: [],
+                    inspect_fun: Inspect.Opts.default_inspect_fun()
+                })
+
+              inspected_struct =
+                doc_struct
+                |> format(opts.width)
+                |> IO.iodata_to_binary()
+
+              inspect_error =
+                Inspect.Error.exception(
+                  exception: caught_exception,
+                  stacktrace: __STACKTRACE__,
+                  inspected_struct: inspected_struct
+                )
+
+              if opts.safe do
+                opts = %{opts | inspect_fun: Inspect.Opts.default_inspect_fun()}
+                Inspect.inspect(inspect_error, opts)
+              else
+                reraise(inspect_error, __STACKTRACE__)
+              end
+            after
+              Process.delete(:inspect_trap)
+            end
+          end
       end
     else
-      Inspect.Map.inspect(map, opts)
+      Inspect.Map.inspect_as_map(struct, opts)
+    end
+    |> pack_opts(opts)
+  end
+
+  def to_doc_with_opts(arg, %Inspect.Opts{inspect_fun: fun} = opts) do
+    fun.(arg, opts) |> pack_opts(opts)
+  end
+
+  defp valid_struct?(%module{} = struct) do
+    try do
+      module.__info__(:struct)
+    rescue
+      _ -> false
+    else
+      info ->
+        valid_struct?(info, struct, map_size(struct) - 1)
+    end
+  end
+
+  defp valid_struct?([%{field: field} | info], struct, count) when is_map_key(struct, field),
+    do: valid_struct?(info, struct, count - 1)
+
+  defp valid_struct?([], _struct, 0),
+    do: true
+
+  defp valid_struct?(_fields, _struct, _count),
+    do: false
+
+  defp pack_opts({_doc, %Inspect.Opts{}} = doc_opts, _opts), do: doc_opts
+  defp pack_opts(doc, opts), do: {doc, opts}
+
+  @doc ~S"""
+  Wraps `collection` in `left` and `right` according to limit and contents
+  and returns only the container document.
+
+  In practice, one must prefer to use `container_doc_with_opts/6`
+  over this function, as `container_doc_with_opts/6` returns the
+  updated options from inspection.
+  """
+  @doc since: "1.6.0"
+  @spec container_doc(
+          t,
+          [term],
+          t,
+          Inspect.Opts.t(),
+          (term, Inspect.Opts.t() -> t),
+          container_opts()
+        ) ::
+          t
+  def container_doc(left, collection, right, inspect_opts, fun, opts \\ []) do
+    container_doc_with_opts(left, collection, right, inspect_opts, fun, opts) |> elem(0)
+  end
+
+  @doc ~S"""
+  Wraps `collection` in `left` and `right` according to limit and contents.
+
+  It uses the given `left` and `right` documents as surrounding and the
+  separator document `separator` to separate items in `docs`. If all entries
+  in the collection are simple documents (texts or strings), then this function
+  attempts to put as much as possible on the same line. If they are not simple,
+  only one entry is shown per line if they do not fit.
+
+  The limit in the given `inspect_opts` is respected and when reached this
+  function stops processing and outputs `"..."` instead.
+
+  It returns a tuple with the algebra document and the updated options.
+
+  ## Options
+
+    * `:separator` - the separator used between each doc
+    * `:break` - If `:strict`, always break between each element. If `:flex`,
+      breaks only when necessary. If `:maybe`, chooses `:flex` only if all
+      elements are text-based, otherwise is `:strict`
+
+  ## Examples
+
+      iex> inspect_opts = %Inspect.Opts{limit: :infinity}
+      iex> fun = fn i, _opts -> to_string(i) end
+      iex> {doc, _opts} = Inspect.Algebra.container_doc_with_opts("[", Enum.to_list(1..5), "]", inspect_opts, fun)
+      iex> Inspect.Algebra.format(doc, 5) |> IO.iodata_to_binary()
+      "[1,\n 2,\n 3,\n 4,\n 5]"
+
+      iex> inspect_opts = %Inspect.Opts{limit: 3}
+      iex> fun = fn i, _opts -> to_string(i) end
+      iex> {doc, _opts} = Inspect.Algebra.container_doc_with_opts("[", Enum.to_list(1..5), "]", inspect_opts, fun)
+      iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary()
+      "[1, 2, 3, ...]"
+
+      iex> inspect_opts = %Inspect.Opts{limit: 3}
+      iex> fun = fn i, _opts -> to_string(i) end
+      iex> opts = [separator: "!"]
+      iex> {doc, _opts} = Inspect.Algebra.container_doc_with_opts("[", Enum.to_list(1..5), "]", inspect_opts, fun, opts)
+      iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary()
+      "[1! 2! 3! ...]"
+
+  """
+  @doc since: "1.19.0"
+  @spec container_doc_with_opts(
+          t,
+          [term],
+          t,
+          Inspect.Opts.t(),
+          (term, Inspect.Opts.t() -> t),
+          container_opts()
+        ) ::
+          {t, Inspect.Opts.t()}
+  def container_doc_with_opts(left, collection, right, inspect_opts, fun, opts \\ [])
+      when is_doc(left) and is_list(collection) and is_doc(right) and is_function(fun, 2) and
+             is_list(opts) do
+    case collection do
+      [] ->
+        {concat(left, right), inspect_opts}
+
+      _ ->
+        break = Keyword.get(opts, :break, :maybe)
+        separator = Keyword.get(opts, :separator, @container_separator)
+
+        {docs, simple?, inspect_opts} =
+          container_each(collection, inspect_opts, fun, [], break == :maybe)
+
+        flex? = simple? or break == :flex
+        docs = fold(docs, &join(&1, &2, flex?, separator))
+
+        group =
+          case flex? do
+            true -> doc_group(concat(concat(left, nest(docs, 1)), right), :normal)
+            false -> doc_group(glue(nest(glue(left, "", docs), 2), "", right), :normal)
+          end
+
+        {group, inspect_opts}
+    end
+  end
+
+  defp container_each([], opts, _fun, acc, simple?) do
+    {:lists.reverse(acc), simple?, opts}
+  end
+
+  defp container_each(_, opts, _fun, acc, simple?) when opts.limit <= 0 do
+    {:lists.reverse(["..." | acc]), simple?, opts}
+  end
+
+  defp container_each([term | terms], opts, fun, acc, simple?) when is_list(terms) do
+    {doc, opts} = call_container_fun(fun, term, opts)
+    container_each(terms, opts, fun, [doc | acc], simple? and simple?(doc))
+  end
+
+  defp container_each([left | right], opts, fun, acc, simple?) do
+    {left, opts} = call_container_fun(fun, left, opts)
+    {right, _opts} = call_container_fun(fun, right, opts)
+    simple? = simple? and simple?(left) and simple?(right)
+    doc = join(left, right, simple?, @tail_separator)
+    {:lists.reverse([doc | acc]), simple?, opts}
+  end
+
+  defp call_container_fun(fun, term, %{limit: bounded} = opts)
+       when bounded <= 0 or bounded == :infinity do
+    case fun.(term, opts) do
+      {doc, %Inspect.Opts{} = opts} -> {doc, opts}
+      doc -> {doc, opts}
+    end
+  end
+
+  defp call_container_fun(fun, term, %{limit: limit} = opts) do
+    changed_opts = %{opts | limit: limit - 1}
+
+    case fun.(term, changed_opts) do
+      {doc, %Inspect.Opts{} = opts} -> {doc, opts}
+      doc_nil() -> {doc_nil(), opts}
+      doc -> {doc, changed_opts}
+    end
+  end
+
+  defp join(doc_nil(), doc_nil(), _, _), do: doc_nil()
+  defp join(left, doc_nil(), _, _), do: left
+  defp join(doc_nil(), right, _, _), do: right
+  defp join(left, right, true, sep), do: flex_glue(concat(left, sep), right)
+  defp join(left, right, false, sep), do: glue(concat(left, sep), right)
+
+  defp simple?(doc_cons(left, right)), do: simple?(left) and simple?(right)
+  defp simple?(doc_color(doc, _)), do: simple?(doc)
+  defp simple?(doc_string(_, _)), do: true
+  defp simple?(doc_nil()), do: true
+  defp simple?(other), do: is_binary(other)
+
+  @doc false
+  @deprecated "Use a combination of concat/2 and nest/2 instead"
+  def surround(left, doc, right) when is_doc(left) and is_doc(doc) and is_doc(right) do
+    concat(concat(left, nest(doc, 1)), right)
+  end
+
+  @doc false
+  @deprecated "Use Inspect.Algebra.container_doc/6 instead"
+  def surround_many(
+        left,
+        docs,
+        right,
+        %Inspect.Opts{} = inspect,
+        fun,
+        separator \\ @container_separator
+      )
+      when is_doc(left) and is_list(docs) and is_doc(right) and is_function(fun, 2) do
+    container_doc(left, docs, right, inspect, fun, separator: separator)
+  end
+
+  # TODO: Deprecate me on Elixir v1.23
+  @doc deprecated: "Use color_doc/3 instead"
+  def color(doc, key, opts) do
+    color_doc(doc, key, opts)
+  end
+
+  @doc ~S"""
+  Colors a document if the `color_key` has a color in the options.
+  """
+  @doc since: "1.18.0"
+  @spec color_doc(t, Inspect.Opts.color_key(), Inspect.Opts.t()) :: t
+  def color_doc(doc, color_key, %Inspect.Opts{syntax_colors: syntax_colors}) when is_doc(doc) do
+    if precolor = Keyword.get(syntax_colors, color_key) do
+      postcolor = Keyword.get(syntax_colors, :reset, :reset)
+      concat(doc_color(doc, ansi(precolor)), doc_color(empty(), ansi(postcolor)))
+    else
+      doc
     end
   end
 
-  def to_doc(arg, %Inspect.Opts{} = opts) do
-    Inspect.inspect(arg, opts)
+  defp ansi(color) do
+    color
+    |> IO.ANSI.format_fragment(true)
+    |> IO.iodata_to_binary()
   end
 
+  # Algebra API
+
+  @compile {:inline,
+            empty: 0,
+            concat: 2,
+            break: 0,
+            break: 1,
+            glue: 2,
+            glue: 3,
+            flex_break: 0,
+            flex_break: 1,
+            flex_glue: 2,
+            flex_glue: 3}
+
   @doc """
   Returns a document entity used to represent nothingness.
 
   ## Examples
 
-      iex> Inspect.Algebra.empty
-      :doc_nil
+      iex> Inspect.Algebra.empty()
+      []
 
   """
-  @spec empty() :: :doc_nil
-  def empty, do: :doc_nil
+  @spec empty() :: doc_nil()
+  def empty, do: doc_nil()
 
-  @doc """
-  Concatenates two document entities.
+  @doc ~S"""
+  Creates a document represented by string.
+
+  While `Inspect.Algebra` accepts binaries as documents,
+  those are counted by binary size. On the other hand,
+  `string` documents are measured in terms of graphemes
+  towards the document size.
 
   ## Examples
 
-      iex> doc = Inspect.Algebra.concat "Tasteless", "Artosis"
-      iex> Inspect.Algebra.pretty(doc, 80)
-      "TastelessArtosis"
+  The following document has 10 bytes and therefore it
+  does not format to width 9 without breaks:
+
+      iex> doc = Inspect.Algebra.glue("olá", " ", "mundo")
+      iex> doc = Inspect.Algebra.group(doc)
+      iex> Inspect.Algebra.format(doc, 9)
+      "olá\nmundo"
+
+  However, if we use `string`, then the string length is
+  used, instead of byte size, correctly fitting:
+
+      iex> string = Inspect.Algebra.string("olá")
+      iex> doc = Inspect.Algebra.glue(string, " ", "mundo")
+      iex> doc = Inspect.Algebra.group(doc)
+      iex> Inspect.Algebra.format(doc, 9)
+      "olá mundo"
 
   """
-  @spec concat(t, t) :: doc_cons
-  def concat(x, y) when is_doc(x) and is_doc(y) do
-    doc_cons(x, y)
+  @doc since: "1.6.0"
+  @spec string(String.t()) :: doc_string
+  def string(string) when is_binary(string) do
+    doc_string(string, String.length(string))
   end
 
-  @doc """
-  Concatenates a list of documents.
+  @doc ~S"""
+  Concatenates two document entities returning a new document.
+
+  ## Examples
+
+      iex> doc = Inspect.Algebra.concat("hello", "world")
+      iex> Inspect.Algebra.format(doc, 80)
+      "helloworld"
+
   """
-  @spec concat([t]) :: doc_cons
-  def concat(docs) do
-    folddoc(docs, &concat(&1, &2))
+  @spec concat(t, t) :: t
+  def concat(doc1, doc2) when is_doc(doc1) and is_doc(doc2) do
+    doc_cons(doc1, doc2)
   end
 
   @doc ~S"""
-  Nests document entity `x` positions deep.
+  Disable any rendering limit while rendering the given document.
+
+  ## Examples
 
-  Nesting will be appended to the line breaks.
+      iex> doc = Inspect.Algebra.glue("hello", "world") |> Inspect.Algebra.group()
+      iex> Inspect.Algebra.format(doc, 10)
+      "hello\nworld"
+      iex> doc = Inspect.Algebra.no_limit(doc)
+      iex> Inspect.Algebra.format(doc, 10)
+      "hello world"
+
+  """
+  @doc since: "1.14.0"
+  @spec no_limit(t) :: t
+  def no_limit(doc) do
+    doc_limit(doc, :infinity)
+  end
+
+  @doc ~S"""
+  Concatenates a list of documents returning a new document.
+
+  ## Examples
+
+      iex> doc = Inspect.Algebra.concat(["a", "b", "c"])
+      iex> Inspect.Algebra.format(doc, 80)
+      "abc"
+
+  """
+  @spec concat([t]) :: t
+  def concat(docs) when is_list(docs) do
+    fold(docs, &concat(&1, &2))
+  end
+
+  @doc ~S"""
+  Colors a document with the given color (preceding the document itself).
+  """
+  @doc since: "1.18.0"
+  @spec color(t, binary) :: t
+  def color(doc, color) when is_doc(doc) and is_binary(color) do
+    doc_color(doc, color)
+  end
+
+  @doc ~S"""
+  Nests the given document at the given `level`.
+
+  If `level` is an integer, that's the indentation appended
+  to line breaks whenever they occur. If the level is `:cursor`,
+  the current position of the "cursor" in the document becomes
+  the nesting. If the level is `:reset`, it is set back to 0.
+
+  `mode` can be `:always`, which means nesting always happen,
+  or `:break`, which means nesting only happens inside a group
+  that has been broken.
 
   ## Examples
 
       iex> doc = Inspect.Algebra.nest(Inspect.Algebra.glue("hello", "world"), 5)
-      iex> Inspect.Algebra.pretty(doc, 5)
+      iex> doc = Inspect.Algebra.group(doc)
+      iex> Inspect.Algebra.format(doc, 5)
       "hello\n     world"
 
   """
-  @spec nest(t, non_neg_integer) :: doc_nest
-  def nest(x, 0) when is_doc(x) do
-    x
+  @spec nest(t, non_neg_integer | :cursor | :reset, :always | :break) :: doc_nest | t
+  def nest(doc, level, mode \\ :always)
+
+  def nest(doc, :cursor, mode) when is_doc(doc) and mode in [:always, :break] do
+    doc_nest(doc, :cursor, mode)
+  end
+
+  def nest(doc, :reset, mode) when is_doc(doc) and mode in [:always, :break] do
+    doc_nest(doc, :reset, mode)
   end
 
-  def nest(x, i) when is_doc(x) and is_integer(i) do
-    doc_nest(x, i)
+  def nest(doc, 0, _mode) when is_doc(doc) do
+    doc
+  end
+
+  def nest(doc, level, mode)
+      when is_doc(doc) and is_integer(level) and level > 0 and mode in [:always, :break] do
+    doc_nest(doc, level, mode)
   end
 
   @doc ~S"""
-  Document entity representing a break.
+  Returns a break document based on the given `string`.
 
-  This break can be rendered as a linebreak or as spaces,
-  depending on the `mode` of the chosen layout or the provided
-  separator.
+  This break can be rendered as a linebreak or as the given `string`,
+  depending on the `mode` of the chosen layout.
 
   ## Examples
 
-  Let's glue two docs together with a break and then render it:
+  Let's create a document by concatenating two strings with a break between
+  them:
 
-      iex> doc = Inspect.Algebra.glue("a", " ", "b")
-      iex> Inspect.Algebra.pretty(doc, 80)
-      "a b"
+      iex> doc = Inspect.Algebra.concat(["a", Inspect.Algebra.break("\t"), "b"])
+      iex> Inspect.Algebra.format(doc, 80)
+      "a\tb"
 
-  Notice the break was represented as is, because we haven't reached
-  a line limit. Once we do, it is replaced by a newline:
+  Note that the break was represented with the given string, because we didn't
+  reach a line limit. Once we do, it is replaced by a newline:
 
-      iex> doc = Inspect.Algebra.glue(String.duplicate("a", 20), " ", "b")
-      iex> Inspect.Algebra.pretty(doc, 10)
+      iex> break = Inspect.Algebra.break("\t")
+      iex> doc = Inspect.Algebra.concat([String.duplicate("a", 20), break, "b"])
+      iex> doc = Inspect.Algebra.group(doc)
+      iex> Inspect.Algebra.format(doc, 10)
       "aaaaaaaaaaaaaaaaaaaa\nb"
 
   """
   @spec break(binary) :: doc_break
-  def break(s) when is_binary(s), do: doc_break(s)
+  def break(string \\ " ") when is_binary(string) do
+    doc_break(string, :strict)
+  end
 
-  @spec break() :: doc_break
-  def break(), do: doc_break(@break)
+  @doc """
+  Collapse any new lines and whitespace following this
+  node, emitting up to `max` new lines.
+  """
+  @doc since: "1.6.0"
+  @spec collapse_lines(pos_integer) :: doc_collapse
+  def collapse_lines(max) when is_integer(max) and max > 0 do
+    doc_collapse(max)
+  end
 
   @doc """
-  Inserts a break between two docs. See `break/1` for more info.
+  Considers the next break as fit.
   """
-  @spec glue(t, t) :: doc_cons
-  def glue(x, y), do: concat(x, concat(break, y))
+  # TODO: Deprecate me on Elixir v1.23
+  @doc deprecated: "Pass the optimistic/pessimistic type to group/2 instead"
+  @spec next_break_fits(t, :enabled | :disabled) :: doc_fits
+  def next_break_fits(doc, mode \\ :enabled)
+      when is_doc(doc) and mode in [:enabled, :disabled] do
+    doc_fits(doc, mode)
+  end
 
   @doc """
-  Inserts a break, passed as the second argument, between two docs,
-  the first and the third arguments.
+  Forces the current group to be unfit.
   """
-  @spec glue(t, binary, t) :: doc_cons
-  def glue(x, g, y) when is_binary(g), do: concat(x, concat(break(g), y))
+  @doc since: "1.6.0"
+  @spec force_unfit(t) :: doc_force
+  def force_unfit(doc) when is_doc(doc) do
+    doc_force(doc)
+  end
+
+  @doc """
+  Returns a flex break document based on the given `string`.
+
+  A flex break still causes a group to break, like `break/1`,
+  but it is re-evaluated when the documented is rendered.
+
+  For example, take a group document represented as `[1, 2, 3]`
+  where the space after every comma is a break. When the document
+  above does not fit a single line, all breaks are enabled,
+  causing the document to be rendered as:
+
+      [1,
+       2,
+       3]
+
+  However, if flex breaks are used, then each break is re-evaluated
+  when rendered, so the document could be possible rendered as:
+
+      [1, 2,
+       3]
+
+  Hence the name "flex". they are more flexible when it comes
+  to the document fitting. On the other hand, they are more expensive
+  since each break needs to be re-evaluated.
+
+  This function is used by `container_doc/6` and friends to the
+  maximum number of entries on the same line.
+  """
+  @doc since: "1.6.0"
+  @spec flex_break(binary) :: doc_break
+  def flex_break(string \\ " ") when is_binary(string) do
+    doc_break(string, :flex)
+  end
+
+  @doc """
+  Glues two documents (`doc1` and `doc2`) inserting a
+  `flex_break/1` given by `break_string` between them.
+
+  This function is used by `container_doc/6` and friends
+  to the maximum number of entries on the same line.
+  """
+  @doc since: "1.6.0"
+  @spec flex_glue(t, binary, t) :: t
+  def flex_glue(doc1, break_string \\ " ", doc2) when is_binary(break_string) do
+    concat(doc1, concat(flex_break(break_string), doc2))
+  end
 
   @doc ~S"""
-  Returns a group containing the specified document.
+  Glues two documents (`doc1` and `doc2`) inserting the given
+  break `break_string` between them.
+
+  For more information on how the break is inserted, see `break/1`.
 
   ## Examples
 
-      iex> doc = Inspect.Algebra.group(
-      ...>   Inspect.Algebra.concat(
-      ...>     Inspect.Algebra.group(
-      ...>       Inspect.Algebra.concat(
-      ...>         "Hello,",
+      iex> doc = Inspect.Algebra.glue("hello", "world")
+      iex> Inspect.Algebra.format(doc, 80)
+      "hello world"
+
+      iex> doc = Inspect.Algebra.glue("hello", "\t", "world")
+      iex> Inspect.Algebra.format(doc, 80)
+      "hello\tworld"
+
+  """
+  @spec glue(t, binary, t) :: t
+  def glue(doc1, break_string \\ " ", doc2) when is_binary(break_string) do
+    concat(doc1, concat(break(break_string), doc2))
+  end
+
+  @doc ~S"""
+  Returns a group containing the specified document `doc`.
+
+  Documents in a group are attempted to be rendered together
+  to the best of the renderer ability. If there are `break/1`s
+  in the group and the group does not fit the given width,
+  the breaks are converted into lines. Otherwise the breaks
+  are rendered as text based on their string contents.
+
+  There are three types of groups, described next.
+
+  ## Group modes
+
+    * `:normal` - the group fits if it fits within the given width
+
+    * `:optimistic` - the group fits if it fits within the given
+      width. However, when nested within another group, the parent
+      group will assume this group fits as long as it has a single
+      break, even if the optimistic group has a `force_unfit/1`
+      document within it. Overall, this has an effect similar
+      to swapping the order groups break. For example, if you have
+      a `parent_group(child_group)` and they do not fit, the parent
+      converts breaks into newlines first, allowing the child to compute
+      if it fits. However, if the child group is optimistic and it
+      has breaks, then the parent assumes it fits, leaving the overall
+      fitting decision to the child
+
+    * `:pessimistic` - the group fits if it fits within the given
+      width. However it disables any optimistic group within it
+
+  ## Examples
+
+      iex> doc =
+      ...>   Inspect.Algebra.group(
+      ...>     Inspect.Algebra.concat(
+      ...>       Inspect.Algebra.group(
       ...>         Inspect.Algebra.concat(
-      ...>           Inspect.Algebra.break,
-      ...>           "A"
+      ...>           "Hello,",
+      ...>           Inspect.Algebra.concat(
+      ...>             Inspect.Algebra.break(),
+      ...>             "A"
+      ...>           )
       ...>         )
+      ...>       ),
+      ...>       Inspect.Algebra.concat(
+      ...>         Inspect.Algebra.break(),
+      ...>         "B"
       ...>       )
-      ...>     ),
-      ...>     Inspect.Algebra.concat(
-      ...>       Inspect.Algebra.break,
-      ...>       "B"
       ...>     )
-      ...> ))
-      iex> Inspect.Algebra.pretty(doc, 80)
+      ...>   )
+      iex> Inspect.Algebra.format(doc, 80)
       "Hello, A B"
-      iex> Inspect.Algebra.pretty(doc, 6)
-      "Hello,\nA B"
+      iex> Inspect.Algebra.format(doc, 6)
+      "Hello,\nA\nB"
+
+  ## Mode examples
+
+  The different groups modes are used by Elixir's code formatter
+  to avoid breaking code at some specific locations. For example,
+  consider this code:
+
+      some_function_call(%{..., key: value, ...})
+
+  Now imagine that this code does not fit its line. The code
+  formatter introduces breaks inside `(` and `)` and inside
+  `%{` and `}`, each within their own group. Therefore the
+  document would break as:
+
+      some_function_call(
+        %{
+          ...,
+          key: value,
+          ...
+        }
+      )
+
+  To address this, the formatter marks the inner group as optimistic.
+  This means the first group, which is `(...)` will consider the document
+  fits and avoids adding breaks around the parens. So overall the code
+  is formatted as:
+
+      some_function_call(%{
+        ...,
+        key: value,
+        ...
+      })
 
   """
-  @spec group(t) :: doc_group
-  def group(d) when is_doc(d) do
-    doc_group(d)
+  @spec group(t, :normal | :optimistic | :pessimistic) :: doc_group
+  def group(doc, mode \\ :normal) when is_doc(doc) do
+    doc_group(
+      doc,
+      case mode do
+        # TODO: Deprecate :self and :inherit on Elixir v1.23
+        :self -> :normal
+        :inherit -> :inherit
+        mode when mode in [:normal, :optimistic, :pessimistic] -> mode
+      end
+    )
   end
 
-  @doc """
-  Inserts a mandatory single space between two document entities.
+  @doc ~S"""
+  Inserts a mandatory single space between two documents.
 
   ## Examples
 
-      iex> doc = Inspect.Algebra.space "Hughes", "Wadler"
-      iex> Inspect.Algebra.pretty(doc, 80)
+      iex> doc = Inspect.Algebra.space("Hughes", "Wadler")
+      iex> Inspect.Algebra.format(doc, 5)
       "Hughes Wadler"
 
   """
-  @spec space(t, t) :: doc_cons
-  def space(x, y), do: concat(x, concat(" ", y))
+  @spec space(t, t) :: t
+  def space(doc1, doc2), do: concat(doc1, concat(" ", doc2))
 
   @doc ~S"""
-  Inserts a mandatory linebreak between two document entities.
+  A mandatory linebreak.
+
+  A group with linebreaks will fit if all lines in the group fit.
 
   ## Examples
 
-      iex> doc = Inspect.Algebra.line "Hughes", "Wadler"
-      iex> Inspect.Algebra.pretty(doc, 80)
+      iex> doc =
+      ...>   Inspect.Algebra.concat(
+      ...>     Inspect.Algebra.concat(
+      ...>       "Hughes",
+      ...>       Inspect.Algebra.line()
+      ...>     ),
+      ...>     "Wadler"
+      ...>   )
+      iex> Inspect.Algebra.format(doc, 80)
       "Hughes\nWadler"
 
   """
-  @spec line(t, t) :: doc_cons
-  def line(x, y), do: concat(x, concat(:doc_line, y))
+  @doc since: "1.6.0"
+  @spec line() :: t
+  def line(), do: doc_line()
 
-  @doc """
-  Folds a list of document entities into a document entity
-  using a function that is passed as the first argument.
+  @doc ~S"""
+  Inserts a mandatory linebreak between two documents.
+
+  See `line/0`.
 
   ## Examples
 
-      iex> doc = ["A", "B"]
-      iex> doc = Inspect.Algebra.folddoc(doc, fn(x,y) ->
-      ...>   Inspect.Algebra.concat [x, "!", y]
-      ...> end)
-      iex> Inspect.Algebra.pretty(doc, 80)
-      "A!B"
+      iex> doc = Inspect.Algebra.line("Hughes", "Wadler")
+      iex> Inspect.Algebra.format(doc, 80)
+      "Hughes\nWadler"
 
   """
-  @spec folddoc([t], ((t, t) -> t)) :: t
-  def folddoc([], _), do: empty
-  def folddoc([doc], _), do: doc
-  def folddoc([d|ds], f), do: f.(d, folddoc(ds, f))
+  @spec line(t, t) :: t
+  def line(doc1, doc2), do: concat(doc1, concat(line(), doc2))
 
-  # Elixir conveniences
+  # TODO: Deprecate me on Elixir v1.23
+  @doc deprecated: "Use fold/2 instead"
+  def fold_doc(docs, folder_fun), do: fold(docs, folder_fun)
 
   @doc ~S"""
-  Surrounds a document with characters.
+  Folds a list of documents into a document using the given folder function.
 
-  Puts the document between left and right enclosing and nesting it.
-  The document is marked as a group, to show the maximum as possible
-  concisely together.
+  The list of documents is folded "from the right"; in that, this function is
+  similar to `List.foldr/3`, except that it doesn't expect an initial
+  accumulator and uses the last element of `docs` as the initial accumulator.
 
   ## Examples
 
-      iex> doc = Inspect.Algebra.surround "[", Inspect.Algebra.glue("a", "b"), "]"
-      iex> Inspect.Algebra.pretty(doc, 3)
-      "[a\n b]"
+      iex> docs = ["A", "B", "C"]
+      iex> docs =
+      ...>   Inspect.Algebra.fold(docs, fn doc, acc ->
+      ...>     Inspect.Algebra.concat([doc, "!", acc])
+      ...>   end)
+      iex> Inspect.Algebra.format(docs, 80)
+      "A!B!C"
 
   """
-  @spec surround(binary, t, binary) :: t
-  def surround(left, doc, right) do
-    group concat left, concat(nest(doc, @nesting), right)
-  end
+  @doc since: "1.18.0"
+  @spec fold([t], (t, t -> t)) :: t
+  def fold(docs, folder_fun)
+
+  def fold([], _folder_fun), do: empty()
+  def fold([doc], _folder_fun), do: doc
+
+  def fold([doc | docs], folder_fun) when is_function(folder_fun, 2),
+    do: folder_fun.(doc, fold(docs, folder_fun))
 
   @doc ~S"""
-  Maps and glues a collection of items together using the given separator
-  and surrounds them. A limit can be passed which, once reached, stops
-  gluing and outputs "..." instead.
+  Formats a given document for a given width.
 
-  ## Examples
+  Takes the maximum width and a document to print as its arguments
+  and returns an IO data representation of the best layout for the
+  document to fit in the given width.
 
-      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]", :infinity, &Integer.to_string(&1))
-      iex> Inspect.Algebra.pretty(doc, 5)
-      "[1,\n 2,\n 3,\n 4,\n 5]"
+  The document starts flat (without breaks) until a group is found.
 
-      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]", 3, &Integer.to_string(&1))
-      iex> Inspect.Algebra.pretty(doc, 20)
-      "[1, 2, 3, ...]"
+  ## Examples
 
-      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]", 3, &Integer.to_string(&1), "!")
-      iex> Inspect.Algebra.pretty(doc, 20)
-      "[1! 2! 3! ...]"
+      iex> doc = Inspect.Algebra.glue("hello", " ", "world")
+      iex> doc = Inspect.Algebra.group(doc)
+      iex> doc |> Inspect.Algebra.format(30) |> IO.iodata_to_binary()
+      "hello world"
+      iex> doc |> Inspect.Algebra.format(10) |> IO.iodata_to_binary()
+      "hello\nworld"
 
   """
-  @spec surround_many(binary, [any], binary, integer | :infinity, (term -> t), binary) :: t
-  def surround_many(left, docs, right, limit, fun, separator \\ @surround_separator)
-
-  def surround_many(left, [], right, _, _fun, _) do
-    concat(left, right)
+  @spec format(t, non_neg_integer | :infinity) :: iodata
+  def format(doc, width) when is_doc(doc) and is_width(width) do
+    format(width, 0, [{0, :flat, doc}], <<>>)
   end
 
-  def surround_many(left, docs, right, limit, fun, sep) do
-    surround(left, surround_many(docs, limit, fun, sep), right)
+  # Type representing the document mode to be rendered:
+  #
+  #   * flat - represents a document with breaks as flats (a break may fit, as it may break)
+  #   * break - represents a document with breaks as breaks (a break always fits, since it breaks)
+  #
+  # These other two modes only affect fitting:
+  #
+  #   * flat_no_break - represents a document with breaks as flat not allowed to enter in break mode
+  #   * break_no_flat - represents a document with breaks as breaks not allowed to enter in flat mode
+  #
+  @typep mode :: :flat | :flat_no_break | :break | :break_no_flat
+
+  @spec fits?(
+          width :: non_neg_integer() | :infinity,
+          column :: non_neg_integer(),
+          break? :: boolean(),
+          entries
+        ) :: boolean()
+        when entries:
+               maybe_improper_list(
+                 {integer(), mode(), t()} | :group_over,
+                 {:tail, boolean(), entries} | []
+               )
+
+  # We need at least a break to consider the document does not fit since a
+  # large document without breaks has no option but fitting its current line.
+  #
+  # In case we have groups and the group fits, we need to consider the group
+  # parent without the child breaks, hence {:tail, b?, t} below.
+  defp fits?(w, k, b?, _) when k > w and b?, do: false
+  defp fits?(_, _, _, []), do: true
+  defp fits?(w, k, _, {:tail, b?, t}), do: fits?(w, k, b?, t)
+
+  ## Group over
+  # If we get to the end of the group and if fits, it is because
+  # something already broke elsewhere, so we can consider the group
+  # fits. This only appears when checking if a flex break and fitting.
+
+  defp fits?(_w, _k, b?, [:group_over | _]),
+    do: b?
+
+  ## Flat no break
+
+  defp fits?(w, k, b?, [{i, _, doc_fits(x, :disabled)} | t]),
+    do: fits?(w, k, b?, [{i, :flat_no_break, x} | t])
+
+  defp fits?(w, k, b?, [{i, :flat_no_break, doc_fits(x, _)} | t]),
+    do: fits?(w, k, b?, [{i, :flat_no_break, x} | t])
+
+  defp fits?(w, k, b?, [{i, _, doc_group(x, :pessimistic)} | t]),
+    do: fits?(w, k, b?, [{i, :flat_no_break, x} | t])
+
+  defp fits?(w, k, b?, [{i, :flat_no_break, doc_group(x, _)} | t]),
+    do: fits?(w, k, b?, [{i, :flat_no_break, x} | t])
+
+  ## Breaks no flat
+
+  defp fits?(w, k, b?, [{i, _, doc_fits(x, :enabled)} | t]),
+    do: fits?(w, k, b?, [{i, :break_no_flat, x} | t])
+
+  defp fits?(w, k, b?, [{i, _, doc_group(x, :optimistic)} | t]),
+    do: fits?(w, k, b?, [{i, :break_no_flat, x} | t])
+
+  defp fits?(w, k, b?, [{i, :break_no_flat, doc_force(x)} | t]),
+    do: fits?(w, k, b?, [{i, :break_no_flat, x} | t])
+
+  defp fits?(_, _, _, [{_, :break_no_flat, doc_break(_, _)} | _]), do: true
+  defp fits?(_, _, _, [{_, :break_no_flat, doc_line()} | _]), do: true
+
+  ## Breaks
+
+  defp fits?(_, _, _, [{_, :break, doc_break(_, _)} | _]), do: true
+  defp fits?(_, _, _, [{_, :break, doc_line()} | _]), do: true
+
+  defp fits?(w, k, b?, [{i, :break, doc_group(x, _)} | t]),
+    do: fits?(w, k, b?, [{i, :flat, x} | {:tail, b?, t}])
+
+  ## Catch all
+
+  defp fits?(w, _, _, [{i, _, doc_line()} | t]), do: fits?(w, i, false, t)
+  defp fits?(w, k, b?, [{_, _, doc_nil()} | t]), do: fits?(w, k, b?, t)
+  defp fits?(w, _, b?, [{i, _, doc_collapse(_)} | t]), do: fits?(w, i, b?, t)
+  defp fits?(w, k, b?, [{i, m, doc_color(x, _)} | t]), do: fits?(w, k, b?, [{i, m, x} | t])
+  defp fits?(w, k, b?, [{_, _, doc_string(_, l)} | t]), do: fits?(w, k + l, b?, t)
+  defp fits?(w, k, b?, [{_, _, s} | t]) when is_binary(s), do: fits?(w, k + byte_size(s), b?, t)
+  defp fits?(_, _, _, [{_, _, doc_force(_)} | _]), do: false
+  defp fits?(w, k, _, [{_, _, doc_break(s, _)} | t]), do: fits?(w, k + byte_size(s), true, t)
+  defp fits?(w, k, b?, [{i, m, doc_nest(x, _, :break)} | t]), do: fits?(w, k, b?, [{i, m, x} | t])
+
+  defp fits?(w, k, b?, [{i, m, doc_nest(x, j, _)} | t]),
+    do: fits?(w, k, b?, [{apply_nesting(i, k, j), m, x} | t])
+
+  defp fits?(w, k, b?, [{i, m, doc_cons(x, y)} | t]),
+    do: fits?(w, k, b?, [{i, m, x}, {i, m, y} | t])
+
+  defp fits?(w, k, b?, [{i, m, doc_group(x, _)} | t]),
+    do: fits?(w, k, b?, [{i, m, x} | {:tail, b?, t}])
+
+  defp fits?(w, k, b?, [{i, m, doc_limit(x, :infinity)} | t]) when w != :infinity,
+    do: fits?(:infinity, k, b?, [{i, :flat, x}, {i, m, doc_limit(empty(), w)} | t])
+
+  defp fits?(_w, k, b?, [{i, m, doc_limit(x, w)} | t]),
+    do: fits?(w, k, b?, [{i, m, x} | t])
+
+  @spec format(
+          width :: non_neg_integer() | :infinity,
+          column :: non_neg_integer(),
+          [{integer, mode, t} | :group_over],
+          binary
+        ) :: iodata
+  defp format(_, _, [], acc), do: acc
+
+  defp format(w, k, [{_, _, doc_nil()} | t], acc),
+    do: format(w, k, t, acc)
+
+  defp format(w, _, [{i, _, doc_line()} | t], acc),
+    do: format(w, i, t, <<acc::binary, indent(i)::binary>>)
+
+  defp format(w, k, [{i, m, doc_cons(x, y)} | t], acc),
+    do: format(w, k, [{i, m, x}, {i, m, y} | t], acc)
+
+  defp format(w, k, [{i, m, doc_color(x, c)} | t], acc),
+    do: format(w, k, [{i, m, x} | t], <<acc::binary, c::binary>>)
+
+  defp format(w, k, [{_, _, doc_string(s, l)} | t], acc),
+    do: format(w, k + l, t, <<acc::binary, s::binary>>)
+
+  defp format(w, k, [{_, _, s} | t], acc) when is_binary(s),
+    do: format(w, k + byte_size(s), t, <<acc::binary, s::binary>>)
+
+  defp format(w, k, [{i, m, doc_force(x)} | t], acc),
+    do: format(w, k, [{i, m, x} | t], acc)
+
+  defp format(w, k, [{i, m, doc_fits(x, _)} | t], acc),
+    do: format(w, k, [{i, m, x} | t], acc)
+
+  defp format(w, _, [{i, _, doc_collapse(max)} | t], acc),
+    do: [acc | collapse(List.wrap(format(w, i, t, <<>>)), max, 0, i)]
+
+  # Flex breaks are conditional to the document and the mode
+  defp format(w, k, [{i, m, doc_break(s, :flex)} | t], acc) do
+    k = k + byte_size(s)
+
+    if w == :infinity or m == :flat or fits?(w, k, true, t) do
+      format(w, k, t, <<acc::binary, s::binary>>)
+    else
+      format(w, i, t, <<acc::binary, indent(i)::binary>>)
+    end
   end
 
-  defp surround_many(_, 0, _fun, _sep) do
-    "..."
+  # Strict breaks are conditional to the mode
+  defp format(w, k, [{i, mode, doc_break(s, :strict)} | t], acc) do
+    if mode == :break do
+      format(w, i, t, <<acc::binary, indent(i)::binary>>)
+    else
+      format(w, k + byte_size(s), t, <<acc::binary, s::binary>>)
+    end
   end
 
-  defp surround_many([h], _limit, fun, _sep) do
-    fun.(h)
+  # Nesting is conditional to the mode.
+  defp format(w, k, [{i, mode, doc_nest(x, j, nest)} | t], acc) do
+    if nest == :always or (nest == :break and mode == :break) do
+      format(w, k, [{apply_nesting(i, k, j), mode, x} | t], acc)
+    else
+      format(w, k, [{i, mode, x} | t], acc)
+    end
   end
 
-  defp surround_many([h|t], limit, fun, sep) when is_list(t) do
-    glue(
-      concat(fun.(h), sep),
-      surround_many(t, decrement(limit), fun, sep)
-    )
+  # Groups must do the fitting decision.
+  defp format(w, k, [:group_over | t], acc) do
+    format(w, k, t, acc)
   end
 
-  defp surround_many([h|t], _limit, fun, _sep) do
-    glue(
-      concat(fun.(h), @tail_separator),
-      fun.(t)
-    )
+  # TODO: Deprecate me in Elixir v1.23
+  defp format(w, k, [{i, :break, doc_group(x, :inherit)} | t], acc) do
+    format(w, k, [{i, :break, x} | t], acc)
   end
 
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter),   do: counter - 1
+  defp format(w, k, [{i, :flat, doc_group(x, :optimistic)} | t], acc) do
+    if w == :infinity or fits?(w, k, false, [{i, :flat, x} | t]) do
+      format(w, k, [{i, :flat, x}, :group_over | t], acc)
+    else
+      format(w, k, [{i, :break, x}, :group_over | t], acc)
+    end
+  end
 
-  @doc """
-  The pretty printing function.
+  defp format(w, k, [{i, _, doc_group(x, _)} | t], acc) do
+    if w == :infinity or fits?(w, k, false, [{i, :flat, x}]) do
+      format(w, k, [{i, :flat, x}, :group_over | t], acc)
+    else
+      format(w, k, [{i, :break, x}, :group_over | t], acc)
+    end
+  end
 
-  Takes the maximum width and a document to print as its arguments
-  and returns the string representation of the best layout for the
-  document to fit in the given width.
-  """
-  @spec pretty(t, non_neg_integer | :infinity) :: binary
-  def pretty(d, w) do
-    sdoc = format w, 0, [{0, default_mode(w), doc_group(d)}]
-    render(sdoc)
+  # Limit is set to infinity and then reverts
+  defp format(w, k, [{i, m, doc_limit(x, :infinity)} | t], acc) when w != :infinity do
+    format(:infinity, k, [{i, :flat, x}, {i, m, doc_limit(empty(), w)} | t], acc)
   end
 
-  defp default_mode(:infinity), do: :flat
-  defp default_mode(_),         do: :break
+  defp format(_w, k, [{i, m, doc_limit(x, w)} | t], acc) do
+    format(w, k, [{i, m, x} | t], acc)
+  end
 
-  # Rendering and internal helpers
+  defp collapse(["\n" <> rest | t], max, count, i) do
+    collapse([strip_whitespace(rest) | t], max, count + 1, i)
+  end
 
-  # Record representing the document mode to be rendered: flat or broken
-  @typep mode :: :flat | :break
+  defp collapse(["" | t], max, count, i) do
+    collapse(t, max, count, i)
+  end
 
-  @doc false
-  @spec fits?(integer, [{integer, mode, t}]) :: boolean
-  def fits?(w, _) when w < 0,                      do: false
-  def fits?(_, []),                                do: true
-  def fits?(_, [{_, _, :doc_line} | _]),           do: true
-  def fits?(w, [{_, _, :doc_nil} | t]),            do: fits?(w, t)
-  def fits?(w, [{i, m, doc_cons(x, y)} | t]),      do: fits?(w, [{i, m, x} | [{i, m, y} | t]])
-  def fits?(w, [{i, m, doc_nest(x, j)} | t]),      do: fits?(w, [{i + j, m, x} | t])
-  def fits?(w, [{i, _, doc_group(x)} | t]),        do: fits?(w, [{i, :flat, x} | t])
-  def fits?(w, [{_, _, s} | t]) when is_binary(s), do: fits?((w - byte_size s), t)
-  def fits?(w, [{_, :flat, doc_break(s)} | t]),    do: fits?((w - byte_size s), t)
-  def fits?(_, [{_, :break, doc_break(_)} | _]),   do: true
+  defp collapse(t, max, count, i) do
+    [:binary.copy("\n", min(max, count)), :binary.copy(" ", i) | t]
+  end
 
-  @doc false
-  @spec format(integer | :infinity, integer, [{integer, mode, t}]) :: [binary]
-  def format(_, _, []),                                do: []
-  def format(w, _, [{i, _, :doc_line} | t]),           do: [indent(i) | format(w, i, t)]
-  def format(w, k, [{_, _, :doc_nil} | t]),            do: format(w, k, t)
-  def format(w, k, [{i, m, doc_cons(x, y)} | t]),      do: format(w, k, [{i, m, x} | [{i, m, y} | t]])
-  def format(w, k, [{i, m, doc_nest(x, j)} | t]),      do: format(w, k, [{i + j, m, x} | t])
-  def format(w, k, [{i, m, doc_group(x)} | t]),        do: format(w, k, [{i, m, x} | t])
-  def format(w, k, [{_, _, s} | t]) when is_binary(s), do: [s | format(w, (k + byte_size s), t)]
-  def format(w, k, [{_, :flat, doc_break(s)} | t]),    do: [s | format(w, (k + byte_size s), t)]
-  def format(w, k, [{i, :break, doc_break(s)} | t]) do
-    k = k + byte_size(s)
+  defp strip_whitespace(" " <> rest), do: strip_whitespace(rest)
+  defp strip_whitespace(rest), do: rest
 
-    if w == :infinity or fits?(w - k, t) do
-      [s | format(w, k, t)]
-    else
-      [indent(i) | format(w, i, t)]
-    end
-  end
+  defp apply_nesting(_, k, :cursor), do: k
+  defp apply_nesting(_, _, :reset), do: 0
+  defp apply_nesting(i, _, j), do: i + j
 
   defp indent(0), do: @newline
   defp indent(i), do: @newline <> :binary.copy(" ", i)
-
-  @doc false
-  @spec render([binary]) :: binary
-  def render(sdoc) do
-    IO.iodata_to_binary sdoc
-  end
 end
diff --git a/lib/elixir/lib/inspect/error.ex b/lib/elixir/lib/inspect/error.ex
new file mode 100644
index 00000000000..47a00213ad0
--- /dev/null
+++ b/lib/elixir/lib/inspect/error.ex
@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Inspect.Error do
+  @moduledoc """
+  Raised when a struct cannot be inspected.
+  """
+  @enforce_keys [:exception_module, :exception_message, :stacktrace, :inspected_struct]
+  defexception @enforce_keys
+
+  @impl true
+  def exception(arguments) when is_list(arguments) do
+    exception = Keyword.fetch!(arguments, :exception)
+    exception_module = exception.__struct__
+    exception_message = Exception.message(exception) |> String.trim_trailing("\n")
+    stacktrace = Keyword.fetch!(arguments, :stacktrace)
+    inspected_struct = Keyword.fetch!(arguments, :inspected_struct)
+
+    %Inspect.Error{
+      exception_module: exception_module,
+      exception_message: exception_message,
+      stacktrace: stacktrace,
+      inspected_struct: inspected_struct
+    }
+  end
+
+  @impl true
+  def message(%__MODULE__{
+        exception_module: exception_module,
+        exception_message: exception_message,
+        inspected_struct: inspected_struct
+      }) do
+    ~s'''
+    got #{inspect(exception_module)} with message:
+
+        """
+    #{pad(exception_message, 4)}
+        """
+
+    while inspecting:
+
+    #{pad(inspected_struct, 4)}
+    '''
+  end
+
+  @doc false
+  def pad(message, padding_length)
+      when is_binary(message) and is_integer(padding_length) and padding_length >= 0 do
+    padding = String.duplicate(" ", padding_length)
+
+    message
+    |> String.split("\n")
+    |> Enum.map(fn
+      "" -> "\n"
+      line -> [padding, line, ?\n]
+    end)
+    |> IO.iodata_to_binary()
+    |> String.trim_trailing("\n")
+  end
+end
+
+defimpl Inspect, for: Inspect.Error do
+  @impl true
+  def inspect(%{stacktrace: stacktrace} = inspect_error, _opts) do
+    message = Exception.message(inspect_error)
+    format_output(message, stacktrace)
+  end
+
+  defp format_output(message, [_ | _] = stacktrace) do
+    stacktrace = Exception.format_stacktrace(stacktrace)
+
+    """
+    #Inspect.Error<
+    #{Inspect.Error.pad(message, 2)}
+
+      Stacktrace:
+
+    #{stacktrace}
+    >\
+    """
+  end
+
+  defp format_output(message, []) do
+    """
+    #Inspect.Error<
+      #{Inspect.Error.pad(message, 2)}
+    >\
+    """
+  end
+end
diff --git a/lib/elixir/lib/integer.ex b/lib/elixir/lib/integer.ex
index 85177480fae..25b658cd546 100644
--- a/lib/elixir/lib/integer.ex
+++ b/lib/elixir/lib/integer.ex
@@ -1,78 +1,359 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Integer do
   @moduledoc """
   Functions for working with integers.
+
+  Some functions that work on integers are found in `Kernel`:
+
+    * `Kernel.abs/1`
+    * `Kernel.div/2`
+    * `Kernel.max/2`
+    * `Kernel.min/2`
+    * `Kernel.rem/2`
+
   """
 
   import Bitwise
 
   @doc """
-  Determines if an integer is odd.
+  Determines if `integer` is odd.
+
+  Returns `true` if the given `integer` is an odd number,
+  otherwise it returns `false`.
+
+  Allowed in guard clauses.
+
+  ## Examples
+
+      iex> Integer.is_odd(5)
+      true
+
+      iex> Integer.is_odd(6)
+      false
+
+      iex> Integer.is_odd(-5)
+      true
+
+      iex> Integer.is_odd(0)
+      false
+
+  """
+  defguard is_odd(integer) when is_integer(integer) and (integer &&& 1) == 1
+
+  @doc """
+  Determines if an `integer` is even.
+
+  Returns `true` if the given `integer` is an even number,
+  otherwise it returns `false`.
+
+  Allowed in guard clauses.
+
+  ## Examples
+
+      iex> Integer.is_even(10)
+      true
+
+      iex> Integer.is_even(5)
+      false
+
+      iex> Integer.is_even(-10)
+      true
+
+      iex> Integer.is_even(0)
+      true
+
+  """
+  defguard is_even(integer) when is_integer(integer) and (integer &&& 1) == 0
+
+  @doc """
+  Computes `base` raised to power of `exponent`.
+
+  Both `base` and `exponent` must be integers.
+  The exponent must be zero or positive.
+
+  See `Float.pow/2` for exponentiation of negative
+  exponents as well as floats.
+
+  ## Examples
+
+      iex> Integer.pow(2, 0)
+      1
+      iex> Integer.pow(2, 1)
+      2
+      iex> Integer.pow(2, 10)
+      1024
+      iex> Integer.pow(2, 11)
+      2048
+      iex> Integer.pow(2, 64)
+      0x10000000000000000
+
+      iex> Integer.pow(3, 4)
+      81
+      iex> Integer.pow(4, 3)
+      64
+
+      iex> Integer.pow(-2, 3)
+      -8
+      iex> Integer.pow(-2, 4)
+      16
+
+      iex> Integer.pow(2, -2)
+      ** (ArithmeticError) bad argument in arithmetic expression
+
+  """
+  @doc since: "1.12.0"
+  @spec pow(integer, non_neg_integer) :: integer
+  def pow(base, exponent) when is_integer(base) and is_integer(exponent) do
+    if exponent < 0, do: :erlang.error(:badarith, [base, exponent])
+    base ** exponent
+  end
+
+  @doc """
+  Computes the modulo remainder of an integer division.
+
+  This function performs a [floored division](`floor_div/2`), which means that
+  the result will always have the sign of the `divisor`.
+
+  Raises an `ArithmeticError` exception if one of the arguments is not an
+  integer, or when the `divisor` is `0`.
+
+  ## Examples
+
+      iex> Integer.mod(5, 2)
+      1
+      iex> Integer.mod(6, -4)
+      -2
+
+  """
+  @doc since: "1.4.0"
+  @spec mod(integer, neg_integer | pos_integer) :: integer
+  def mod(dividend, divisor) do
+    remainder = rem(dividend, divisor)
+
+    if remainder * divisor < 0 do
+      remainder + divisor
+    else
+      remainder
+    end
+  end
+
+  @doc """
+  Performs a floored integer division.
+
+  Raises an `ArithmeticError` exception if one of the arguments is not an
+  integer, or when the `divisor` is `0`.
+
+  This function performs a *floored* integer division, which means that
+  the result will always be rounded towards negative infinity.
+
+  If you want to perform truncated integer division (rounding towards zero),
+  use `Kernel.div/2` instead.
+
+  ## Examples
+
+      iex> Integer.floor_div(5, 2)
+      2
+      iex> Integer.floor_div(6, -4)
+      -2
+      iex> Integer.floor_div(-99, 2)
+      -50
+
+  """
+  @doc since: "1.4.0"
+  @spec floor_div(integer, neg_integer | pos_integer) :: integer
+  def floor_div(dividend, divisor) do
+    if :erlang.xor(dividend < 0, divisor < 0) and rem(dividend, divisor) != 0 do
+      div(dividend, divisor) - 1
+    else
+      div(dividend, divisor)
+    end
+  end
+
+  @doc """
+  Performs a ceiled integer division.
+
+  Raises an `ArithmeticError` exception if one of the arguments is not an
+  integer, or when the `divisor` is `0`.
+
+  This function performs a *ceiled* integer division, which means that
+  the result will always be rounded towards positive infinity.
+
+  ## Examples
+
+      iex> Integer.ceil_div(5, 2)
+      3
+      iex> Integer.ceil_div(6, -4)
+      -1
+      iex> Integer.ceil_div(-99, 2)
+      -49
+
+  """
+  @doc since: "1.20.0"
+  @spec ceil_div(integer, neg_integer | pos_integer) :: integer
+  def ceil_div(dividend, divisor) do
+    if not :erlang.xor(dividend < 0, divisor < 0) and rem(dividend, divisor) != 0 do
+      div(dividend, divisor) + 1
+    else
+      div(dividend, divisor)
+    end
+  end
+
+  @doc """
+  Returns the ordered digits for the given `integer`.
+
+  An optional `base` value may be provided representing the radix for the returned
+  digits. This one must be an integer >= 2.
+
+  ## Examples
+
+      iex> Integer.digits(123)
+      [1, 2, 3]
+
+      iex> Integer.digits(170, 2)
+      [1, 0, 1, 0, 1, 0, 1, 0]
+
+      iex> Integer.digits(-170, 2)
+      [-1, 0, -1, 0, -1, 0, -1, 0]
 
-  Returns `true` if `n` is an odd number, otherwise `false`.
-  Implemented as a macro so it is allowed in guard clauses.
   """
-  defmacro odd?(n) do
-    quote do: (unquote(n) &&& 1) == 1
+  @spec digits(integer, pos_integer) :: [integer, ...]
+  def digits(integer, base \\ 10)
+      when is_integer(integer) and is_integer(base) and base >= 2 do
+    case integer do
+      0 -> [0]
+      _integer -> digits(integer, base, [])
+    end
   end
 
+  defp digits(0, _base, acc), do: acc
+
+  defp digits(integer, base, acc),
+    do: digits(div(integer, base), base, [rem(integer, base) | acc])
+
   @doc """
-  Determines if an integer is even.
+  Returns the integer represented by the ordered `digits`.
+
+  An optional `base` value may be provided representing the radix for the `digits`.
+  Base has to be an integer greater than or equal to `2`.
+
+  ## Examples
+
+      iex> Integer.undigits([1, 2, 3])
+      123
+
+      iex> Integer.undigits([1, 4], 16)
+      20
+
+      iex> Integer.undigits([])
+      0
 
-  Returns `true` if `n` is an even number, otherwise `false`.
-  Implemented as a macro so it is allowed in guard clauses.
   """
-  defmacro even?(n) do
-    quote do: (unquote(n) &&& 1) == 0
+  @spec undigits([integer], pos_integer) :: integer
+  def undigits(digits, base \\ 10) when is_list(digits) and is_integer(base) and base >= 2 do
+    undigits(digits, base, 0)
   end
 
+  defp undigits([], _base, acc), do: acc
+
+  defp undigits([digit | _], base, _) when is_integer(digit) and digit >= base,
+    do: raise(ArgumentError, "invalid digit #{digit} in base #{base}")
+
+  defp undigits([digit | tail], base, acc) when is_integer(digit),
+    do: undigits(tail, base, acc * base + digit)
+
   @doc """
-  Converts a binary to an integer.
+  Parses a text representation of an integer.
 
-  If successful, returns a tuple of the form `{integer, remainder_of_binary}`.
+  An optional `base` to the corresponding integer can be provided.
+  If `base` is not given, 10 will be used.
+
+  If successful, returns a tuple in the form of `{integer, remainder_of_binary}`.
   Otherwise `:error`.
 
+  Raises an error if `base` is less than 2 or more than 36.
+
+  If you want to convert a string-formatted integer directly to an integer,
+  `String.to_integer/1` or `String.to_integer/2` can be used instead.
+
   ## Examples
 
       iex> Integer.parse("34")
-      {34,""}
+      {34, ""}
 
       iex> Integer.parse("34.5")
-      {34,".5"}
+      {34, ".5"}
 
       iex> Integer.parse("three")
       :error
 
+      iex> Integer.parse("34", 10)
+      {34, ""}
+
+      iex> Integer.parse("f4", 16)
+      {244, ""}
+
+      iex> Integer.parse("Awww++", 36)
+      {509216, "++"}
+
+      iex> Integer.parse("fab", 10)
+      :error
+
+      iex> Integer.parse("a2", 38)
+      ** (ArgumentError) invalid base 38
+
   """
-  @spec parse(binary) :: {integer, binary} | :error
-  def parse(<< ?-, bin :: binary >>) do
-    case do_parse(bin) do
-      :error -> :error
-      {number, remainder} -> {-number, remainder}
+  @spec parse(binary, 2..36) :: {integer, remainder_of_binary :: binary} | :error
+  def parse(binary, base \\ 10)
+
+  def parse(_binary, base) when base not in 2..36 do
+    raise ArgumentError, "invalid base #{inspect(base)}"
+  end
+
+  def parse(binary, base) when is_binary(binary) do
+    case count_digits(binary, base) do
+      0 ->
+        :error
+
+      count ->
+        {digits, rem} = :erlang.split_binary(binary, count)
+        {:erlang.binary_to_integer(digits, base), rem}
     end
   end
 
-  def parse(<< ?+, bin :: binary >>) do
-    do_parse(bin)
+  defp count_digits(<<sign, rest::bits>>, base) when sign in ~c"+-" do
+    case count_digits_nosign(rest, base, 1) do
+      1 -> 0
+      count -> count
+    end
   end
 
-  def parse(bin) when is_binary(bin) do
-    do_parse(bin)
+  defp count_digits(<<rest::bits>>, base) do
+    count_digits_nosign(rest, base, 0)
   end
 
-  defp do_parse(<< char, bin :: binary >>) when char in ?0..?9, do: do_parse(bin, char - ?0)
-  defp do_parse(_), do: :error
+  digits = [{?0..?9, -?0}, {?A..?Z, 10 - ?A}, {?a..?z, 10 - ?a}]
 
-  defp do_parse(<< char, rest :: binary >>, acc) when char in ?0..?9 do
-    do_parse rest, 10 * acc + (char - ?0)
-  end
+  for {chars, diff} <- digits,
+      char <- chars do
+    digit = char + diff
 
-  defp do_parse(bitstring, acc) do
-    {acc, bitstring}
+    defp count_digits_nosign(<<unquote(char), rest::bits>>, base, count)
+         when base > unquote(digit) do
+      count_digits_nosign(rest, base, count + 1)
+    end
   end
 
+  defp count_digits_nosign(<<_::bits>>, _, count), do: count
+
   @doc """
   Returns a binary which corresponds to the text representation
-  of `some_integer`.
+  of `integer` in the given `base`.
+
+  `base` can be an integer between 2 and 36. If no `base` is given,
+  it defaults to `10`.
 
   Inlined by the compiler.
 
@@ -81,59 +362,164 @@ defmodule Integer do
       iex> Integer.to_string(123)
       "123"
 
+      iex> Integer.to_string(+456)
+      "456"
+
+      iex> Integer.to_string(-789)
+      "-789"
+
+      iex> Integer.to_string(0123)
+      "123"
+
+      iex> Integer.to_string(100, 16)
+      "64"
+
+      iex> Integer.to_string(-100, 16)
+      "-64"
+
+      iex> Integer.to_string(882_681_651, 36)
+      "ELIXIR"
+
   """
-  @spec to_string(integer) :: String.t
-  def to_string(some_integer) do
-    :erlang.integer_to_binary(some_integer)
+  @spec to_string(integer, 2..36) :: String.t()
+  def to_string(integer, base \\ 10) do
+    :erlang.integer_to_binary(integer, base)
   end
 
   @doc """
-  Returns a binary which corresponds to the text representation
-  of `some_integer` in base `base`.
+  Returns a charlist which corresponds to the text representation
+  of `integer` in the given `base`.
+
+  `base` can be an integer between 2 and 36. If no `base` is given,
+  it defaults to `10`.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> Integer.to_string(100, 16)
-      "64"
+      iex> Integer.to_charlist(123)
+      ~c"123"
+
+      iex> Integer.to_charlist(+456)
+      ~c"456"
+
+      iex> Integer.to_charlist(-789)
+      ~c"-789"
+
+      iex> Integer.to_charlist(0123)
+      ~c"123"
+
+      iex> Integer.to_charlist(100, 16)
+      ~c"64"
+
+      iex> Integer.to_charlist(-100, 16)
+      ~c"-64"
+
+      iex> Integer.to_charlist(882_681_651, 36)
+      ~c"ELIXIR"
 
   """
-  @spec to_string(integer, pos_integer) :: String.t
-  def to_string(some_integer, base) do
-    :erlang.integer_to_binary(some_integer, base)
+  @spec to_charlist(integer, 2..36) :: charlist
+  def to_charlist(integer, base \\ 10) do
+    :erlang.integer_to_list(integer, base)
   end
 
   @doc """
-  Returns a char list which corresponds to the text representation of the given integer.
+  Returns the greatest common divisor of the two given integers.
 
-  Inlined by the compiler.
+  The greatest common divisor (GCD) of `integer1` and `integer2` is the largest positive
+  integer that divides both `integer1` and `integer2` without leaving a remainder.
+
+  By convention, `gcd(0, 0)` returns `0`.
 
   ## Examples
 
-      iex> Integer.to_char_list(7)
-      '7'
+      iex> Integer.gcd(2, 3)
+      1
+
+      iex> Integer.gcd(8, 12)
+      4
+
+      iex> Integer.gcd(8, -12)
+      4
+
+      iex> Integer.gcd(10, 0)
+      10
+
+      iex> Integer.gcd(7, 7)
+      7
+
+      iex> Integer.gcd(0, 0)
+      0
 
   """
-  @spec to_char_list(integer) :: list
-  def to_char_list(number) do
-    :erlang.integer_to_list(number)
+  @doc since: "1.5.0"
+  @spec gcd(integer, integer) :: non_neg_integer
+  def gcd(integer1, integer2) when is_integer(integer1) and is_integer(integer2) do
+    gcd_positive(abs(integer1), abs(integer2))
   end
 
+  defp gcd_positive(0, integer2), do: integer2
+  defp gcd_positive(integer1, 0), do: integer1
+  defp gcd_positive(integer1, integer2), do: gcd_positive(integer2, rem(integer1, integer2))
+
   @doc """
-  Returns a char list which corresponds to the text representation of the
-  given integer in the given case.
+  Returns the extended greatest common divisor of the two given integers.
 
-  Inlined by the compiler.
+  This function uses the extended Euclidean algorithm to return a three-element tuple with the `gcd`
+  and the coefficients `m` and `n` of Bézout's identity such that:
+
+      gcd(a, b) = m*a + n*b
+
+  By convention, `extended_gcd(0, 0)` returns `{0, 0, 0}`.
 
   ## Examples
 
-      iex> Integer.to_char_list(1023, 16)
-      '3FF'
+      iex> Integer.extended_gcd(240, 46)
+      {2, -9, 47}
+      iex> Integer.extended_gcd(46, 240)
+      {2, 47, -9}
+      iex> Integer.extended_gcd(-46, 240)
+      {2, -47, -9}
+      iex> Integer.extended_gcd(-46, -240)
+      {2, -47, 9}
+
+      iex> Integer.extended_gcd(14, 21)
+      {7, -1, 1}
+
+      iex> Integer.extended_gcd(10, 0)
+      {10, 1, 0}
+      iex> Integer.extended_gcd(0, 10)
+      {10, 0, 1}
+      iex> Integer.extended_gcd(0, 0)
+      {0, 0, 0}
 
   """
-  @spec to_char_list(integer, pos_integer) :: list
-  def to_char_list(number, base) do
-    :erlang.integer_to_list(number, base)
+  @doc since: "1.12.0"
+  @spec extended_gcd(integer, integer) :: {non_neg_integer, integer, integer}
+  def extended_gcd(0, 0), do: {0, 0, 0}
+  def extended_gcd(0, b), do: {b, 0, 1}
+  def extended_gcd(a, 0), do: {a, 1, 0}
+
+  def extended_gcd(integer1, integer2) when is_integer(integer1) and is_integer(integer2) do
+    extended_gcd(integer2, integer1, 0, 1, 1, 0)
   end
+
+  defp extended_gcd(r1, r0, s1, s0, t1, t0) do
+    div = div(r0, r1)
+
+    case r0 - div * r1 do
+      0 when r1 > 0 -> {r1, s1, t1}
+      0 when r1 < 0 -> {-r1, -s1, -t1}
+      r2 -> extended_gcd(r2, r1, s0 - div * s1, s1, t0 - div * t1, t1)
+    end
+  end
+
+  @doc false
+  @deprecated "Use Integer.to_charlist/1 instead"
+  def to_char_list(integer), do: Integer.to_charlist(integer)
+
+  @doc false
+  @deprecated "Use Integer.to_charlist/2 instead"
+  def to_char_list(integer, base), do: Integer.to_charlist(integer, base)
 end
diff --git a/lib/elixir/lib/io.ex b/lib/elixir/lib/io.ex
index 947b6ffa61f..24804339c5f 100644
--- a/lib/elixir/lib/io.ex
+++ b/lib/elixir/lib/io.ex
@@ -1,84 +1,247 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule IO do
-  @moduledoc """
-  Functions handling IO.
+  @moduledoc ~S"""
+  Functions handling input/output (IO).
 
-  Many functions in this module expects an IO device as argument.
-  An IO device must be a pid or an atom representing a process.
+  Many functions in this module expect an IO device as an argument.
+  An IO device must be a PID or an atom representing a process.
   For convenience, Elixir provides `:stdio` and `:stderr` as
   shortcuts to Erlang's `:standard_io` and `:standard_error`.
 
-  The majority of the functions expect char data, i.e. strings or
-  lists of characters and strings. In case another type is given,
-  it will do a conversion to string via the `String.Chars` protocol
-  (as shown in typespecs).
+  The majority of the functions expect chardata. In case another type is given,
+  functions will convert those types to string via the `String.Chars` protocol
+  (as shown in typespecs). For more information on chardata, see the
+  "IO data" section below.
 
-  The functions starting with `bin*` expects iodata as argument,
-  i.e. binaries or lists of bytes and binaries.
+  The functions of this module use UNIX-style naming where possible.
 
   ## IO devices
 
-  An IO device may be an atom or a pid. In case it is an atom,
-  the atom must be the name of a registered process. However,
-  there are three exceptions for this rule:
+  An IO device may be an atom or a PID. In case it is an atom,
+  the atom must be the name of a registered process. In addition,
+  Elixir provides two shortcuts:
+
+    * `:stdio` - a shortcut for `:standard_io`, which maps to
+      the current `Process.group_leader/0` in Erlang
+
+    * `:stderr` - a shortcut for the named process `:standard_error`
+      provided in Erlang
+
+  IO devices maintain their position, which means subsequent calls to any
+  reading or writing functions will start from the place where the device
+  was last accessed. The position of files can be changed using the
+  `:file.position/2` function.
+
+  ## IO data
+
+  IO data is a data type that can be used as a more efficient alternative to binaries
+  in certain situations.
+
+  A term of type **IO data** is a binary or a list containing bytes (integers within the `0..255` range)
+  or nested IO data. The type is recursive. Let's see an example of one of
+  the possible IO data representing the binary `"hello"`:
+
+      [?h, "el", ["l", [?o]]]
+
+  The built-in `t:iodata/0` type is defined in terms of `t:iolist/0`. An IO list is
+  the same as IO data but it doesn't allow for a binary at the top level (but binaries
+  are still allowed in the list itself).
+
+  ### Use cases for IO data
+
+  IO data exists because often you need to do many append operations
+  on smaller chunks of binaries in order to create a bigger binary. However, in
+  Erlang and Elixir concatenating binaries will copy the concatenated binaries
+  into a new binary.
+
+      def email(username, domain) do
+        username <> "@" <> domain
+      end
+
+  In this function, creating the email address will copy the `username` and `domain`
+  binaries. Now imagine you want to use the resulting email inside another binary:
+
+      def welcome_message(name, username, domain) do
+        "Welcome #{name}, your email is: #{email(username, domain)}"
+      end
+
+      IO.puts(welcome_message("Meg", "meg", "example.com"))
+      #=> "Welcome Meg, your email is: meg@example.com"
+
+  Every time you concatenate binaries or use interpolation (`#{}`) you are making
+  copies of those binaries. However, in many cases you don't need the complete
+  binary while you create it, but only at the end to print it out or send it
+  somewhere. In such cases, you can construct the binary by creating IO data:
+
+      def email(username, domain) do
+        [username, ?@, domain]
+      end
+
+      def welcome_message(name, username, domain) do
+        ["Welcome ", name, ", your email is: ", email(username, domain)]
+      end
+
+      IO.puts(welcome_message("Meg", "meg", "example.com"))
+      #=> "Welcome Meg, your email is: meg@example.com"
+
+  Building IO data is cheaper than concatenating binaries. Concatenating multiple
+  pieces of IO data just means putting them together inside a list since IO data
+  can be arbitrarily nested, and that's a cheap and efficient operation. Most of
+  the IO-based APIs, such as `:gen_tcp` and `IO`, receive IO data and write it
+  to the socket directly without converting it to binary.
+
+  One drawback of IO data is that you can't do things like pattern match on the
+  first part of a piece of IO data like you can with a binary, because you usually
+  don't know the shape of the IO data. In those cases, you may need to convert it
+  to a binary by calling `iodata_to_binary/1`, which is reasonably efficient
+  since it's implemented natively in C. Other functionality, like computing the
+  length of IO data, can be computed directly on the iodata by calling `iodata_length/1`.
+
+  ### Chardata
+
+  Erlang and Elixir also have the idea of `t:chardata/0`. Chardata is very
+  similar to IO data: the only difference is that integers in IO data represent
+  bytes while integers in chardata represent Unicode code points. Bytes
+  (`t:byte/0`) are integers within the `0..255` range, while Unicode code points
+  (`t:char/0`) are integers within the `0..0x10FFFF` range. The `IO` module provides
+  the `chardata_to_string/1` function for chardata as the "counter-part" of the
+  `iodata_to_binary/1` function for IO data.
+
+  If you try to use `iodata_to_binary/1` on chardata, it will result in an
+  argument error. For example, let's try to put a code point that is not
+  representable with one byte, like `?π`, inside IO data:
 
-    * `:standard_io` - when the `:standard_io` atom is given,
-      it is treated as a shortcut for `Process.group_leader`
+      IO.iodata_to_binary(["The symbol for pi is: ", ?π])
+      #=> ** (ArgumentError) argument error
 
-    * `:stdio` - is a shortcut for `:standard_io`
+  If we use chardata instead, it will work as expected:
 
-    * `:stderr` - is a shortcut for `:standard_error`
+      iex> IO.chardata_to_string(["The symbol for pi is: ", ?π])
+      "The symbol for pi is: π"
 
   """
 
   @type device :: atom | pid
   @type nodata :: {:error, term} | :eof
-  @type chardata() :: :unicode.chardata()
+  @type chardata :: String.t() | maybe_improper_list(char | chardata, String.t() | [])
 
-  import :erlang, only: [group_leader: 0]
+  @type inspect_opts :: [Inspect.Opts.new_opt() | {:label, term}]
 
-  defmacrop is_iodata(data) do
-    quote do
-      is_list(unquote(data)) or is_binary(unquote(data))
-    end
-  end
+  @typedoc """
+  Stacktrace information as keyword options for `warn/2`.
 
-  @doc """
-  Reads `count` characters from the IO device or until
-  the end of the line if `:line` is given. It returns:
+  At least `:file` is required. Other options are optional and used
+  to provide more precise location information.
+  """
+  @type warn_stacktrace_opts :: [
+          file: String.t(),
+          line: pos_integer(),
+          column: pos_integer(),
+          module: module(),
+          function: {atom(), arity()}
+        ]
 
-    * `data` - the input characters
+  defguardp is_device(term) when is_atom(term) or is_pid(term)
+  defguardp is_iodata(data) when is_list(data) or is_binary(data)
+
+  @doc ~S"""
+  Reads from the IO `device`.
+
+  The `device` is iterated as specified by the `line_or_chars` argument:
+
+    * if `line_or_chars` is an integer, it represents a number of bytes. The device is
+      iterated by that number of bytes. This should be the preferred mode for reading
+      non-textual inputs.
+
+    * if `line_or_chars` is `:line`, the device is iterated line by line.
+      CRLF newlines  ("\r\n") are automatically normalized to "\n".
+
+    * if `line_or_chars` is `:eof` (since v1.13), the device is iterated until `:eof`.
+      If the device is already at the end, it returns `:eof` itself.
+
+  It returns:
+
+    * `data` - the output characters
 
     * `:eof` - end of file was encountered
 
     * `{:error, reason}` - other (rare) error condition;
       for instance, `{:error, :estale}` if reading from an
       NFS volume
+
   """
-  @spec read(device, :line | non_neg_integer) :: chardata | nodata
-  def read(device \\ group_leader, chars_or_line)
+  @spec read(device, :eof | :line | non_neg_integer) :: chardata | nodata
+  def read(device \\ :stdio, line_or_chars)
+
+  # TODO: Remove me on v2.0
+  def read(device, :all) do
+    IO.warn("IO.read(device, :all) is deprecated, use IO.read(device, :eof) instead")
+
+    with :eof <- read(device, :eof) do
+      with [_ | _] = opts <- :io.getopts(device),
+           false <- Keyword.get(opts, :binary, true) do
+        ~c""
+      else
+        _ -> ""
+      end
+    end
+  end
+
+  def read(device, :eof) do
+    getn(device, ~c"", :eof)
+  end
 
   def read(device, :line) do
-    :io.get_line(map_dev(device), '')
+    :io.get_line(map_dev(device), ~c"")
   end
 
-  def read(device, count) when count >= 0 do
-    :io.get_chars(map_dev(device), '', count)
+  def read(device, count) when is_integer(count) and count >= 0 do
+    :io.get_chars(map_dev(device), ~c"", count)
   end
 
-  @doc """
-  Reads `count` bytes from the IO device or until
-  the end of the line if `:line` is given. It returns:
+  @doc ~S"""
+  Reads from the IO `device`. The operation is Unicode unsafe.
 
-    * `data` - the input characters
+  The `device` is iterated as specified by the `line_or_chars` argument:
+
+    * if `line_or_chars` is an integer, it represents a number of bytes. The device is
+      iterated by that number of bytes. This should be the preferred mode for reading
+      non-textual inputs.
+
+    * if `line_or_chars` is `:line`, the device is iterated line by line.
+      CRLF newlines  ("\r\n") are automatically normalized to "\n".
+
+    * if `line_or_chars` is `:eof` (since v1.13), the device is iterated until `:eof`.
+      If the device is already at the end, it returns `:eof` itself.
+
+  It returns:
+
+    * `data` - the output bytes
 
     * `:eof` - end of file was encountered
 
     * `{:error, reason}` - other (rare) error condition;
       for instance, `{:error, :estale}` if reading from an
       NFS volume
+
+  Note: do not use this function on IO devices in Unicode mode
+  as it will return the wrong result.
   """
-  @spec binread(device, :line | non_neg_integer) :: iodata | nodata
-  def binread(device \\ group_leader, chars_or_line)
+  @spec binread(device, :eof | :line | non_neg_integer) :: iodata | nodata
+  def binread(device \\ :stdio, line_or_chars)
+
+  # TODO: Remove me on v2.0
+  def binread(device, :all) do
+    IO.warn("IO.binread(device, :all) is deprecated, use IO.binread(device, :eof) instead")
+    with :eof <- binread(device, :eof), do: ""
+  end
+
+  def binread(device, :eof) do
+    binread_eof(map_dev(device), "")
+  end
 
   def binread(device, :line) do
     case :file.read_line(map_dev(device)) do
@@ -87,91 +250,311 @@ defmodule IO do
     end
   end
 
-  def binread(device, count) when count >= 0 do
+  def binread(device, count) when is_integer(count) and count >= 0 do
     case :file.read(map_dev(device), count) do
       {:ok, data} -> data
       other -> other
     end
   end
 
+  @read_all_size 4096
+  defp binread_eof(mapped_dev, acc) do
+    case :file.read(mapped_dev, @read_all_size) do
+      {:ok, data} -> binread_eof(mapped_dev, acc <> data)
+      :eof -> if acc == "", do: :eof, else: acc
+      other -> other
+    end
+  end
+
   @doc """
-  Writes the given argument to the given device.
+  Writes `chardata` to the given `device`.
 
-  By default the device is the standard output.
-  It returns `:ok` if it succeeds.
+  By default, the `device` is the standard output.
+
+  ## Examples
+
+      IO.write("sample")
+      #=> sample
+
+      IO.write(:stderr, "error")
+      #=> error
+
+  """
+  @spec write(device, chardata | String.Chars.t()) :: :ok
+  def write(device \\ :stdio, chardata) do
+    :io.put_chars(map_dev(device), to_chardata(chardata))
+  end
+
+  @doc """
+  Writes `iodata` to the given `device`.
+
+  This operation is meant to be used with "raw" devices
+  that are started without an encoding. The given `iodata`
+  is written as is to the device, without conversion. For
+  more information on IO data, see the "IO data" section in
+  the module documentation.
+
+  Use `write/2` for devices with encoding.
+
+  Important: do **not** use this function on IO devices in
+  Unicode mode as it will write the wrong data. In particular,
+  the standard IO device is set to Unicode by default, so writing
+  to stdio with this function will likely result in the wrong data
+  being sent down the wire.
+  """
+  @spec binwrite(device, iodata) :: :ok
+  def binwrite(device \\ :stdio, iodata) when is_iodata(iodata) do
+    with {:error, reason} <- :file.write(map_dev(device), iodata) do
+      :erlang.error(reason)
+    end
+  end
+
+  @doc """
+  Writes `item` to the given `device`, similar to `write/2`,
+  but adds a newline at the end.
+
+  By default, the `device` is the standard output. It returns `:ok`
+  if it succeeds.
+
+  Trivia: `puts` is shorthand for `put string`.
 
   ## Examples
 
-      IO.write "sample"
-      #=> "sample"
+      IO.puts("Hello World!")
+      #=> Hello World!
 
-      IO.write :stderr, "error"
-      #=> "error"
+      IO.puts(:stderr, "error")
+      #=> error
 
   """
-  @spec write(device, chardata | String.Chars.t) :: :ok
-  def write(device \\ group_leader(), item) do
-    :io.put_chars map_dev(device), to_chardata(item)
+  @spec puts(device, chardata | String.Chars.t()) :: :ok
+  def puts(device \\ :stdio, item) when is_device(device) do
+    :io.put_chars(map_dev(device), [to_chardata(item), ?\n])
   end
 
   @doc """
-  Writes the given argument to the given device
-  as a binary, no unicode conversion happens.
+  Writes a `message` to stderr, along with the given `stacktrace_info`.
+
+  The `stacktrace_info` must be one of:
+
+    * a `__STACKTRACE__`, where all entries in the stacktrace will be
+      included in the error message
+
+    * a `Macro.Env` structure (since v1.14.0), where a single stacktrace
+      entry from the compilation environment will be used
+
+    * a keyword list with at least the `:file` option representing
+      a single stacktrace entry (since v1.14.0). The `:line`, `:column`,
+      `:module`, and `:function` options are also supported
+
+  This function notifies the compiler a warning was printed
+  and emits a compiler diagnostic (`t:Code.diagnostic/1`).
+  The diagnostic will include precise file and location information
+  if a `Macro.Env` is given or those values have been passed as
+  keyword list, but not for stacktraces, as they are often imprecise.
+
+  It returns `:ok` if it succeeds.
+
+  ## Examples
+
+      IO.warn("variable bar is unused", module: MyApp, function: {:main, 1}, line: 4, file: "my_app.ex")
+      #=> warning: variable bar is unused
+      #=>   my_app.ex:4: MyApp.main/1
 
-  Check `write/2` for more information.
   """
-  @spec binwrite(device, iodata) :: :ok | {:error, term}
-  def binwrite(device \\ group_leader(), item) when is_iodata(item) do
-    :file.write map_dev(device), item
+  @spec warn(
+          chardata | String.Chars.t(),
+          Exception.stacktrace() | warn_stacktrace_opts() | Macro.Env.t()
+        ) ::
+          :ok
+  def warn(message, stacktrace_info)
+
+  def warn(message, %Macro.Env{line: line, file: file} = env) do
+    message = to_chardata(message)
+
+    :elixir_errors.emit_diagnostic(:warning, line, file, message, Macro.Env.stacktrace(env),
+      read_snippet: true
+    )
+  end
+
+  def warn(message, [{_, _} | _] = keyword) do
+    if file = keyword[:file] do
+      line = keyword[:line]
+      column = keyword[:column]
+      position = if line && column, do: {line, column}, else: line
+      message = to_chardata(message)
+
+      stacktrace =
+        Macro.Env.stacktrace(%{
+          __ENV__
+          | module: keyword[:module],
+            function: keyword[:function],
+            line: line,
+            file: file
+        })
+
+      :elixir_errors.emit_diagnostic(:warning, position, file, message, stacktrace,
+        read_snippet: true
+      )
+    else
+      warn(message, [])
+    end
+  end
+
+  def warn(message, []) do
+    message = to_chardata(message)
+    :elixir_errors.emit_diagnostic(:warning, 0, nil, message, [], read_snippet: false)
+  end
+
+  def warn(message, [{_, _, _, _} | _] = stacktrace) do
+    message = to_chardata(message)
+    :elixir_errors.emit_diagnostic(:warning, 0, nil, message, stacktrace, read_snippet: false)
+  end
+
+  @doc false
+  def warn_once(key, message, stacktrace_drop_levels) do
+    {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
+    stacktrace = Enum.drop(stacktrace, stacktrace_drop_levels)
+
+    if :elixir_config.warn(key, stacktrace) do
+      warn(message.(), stacktrace)
+    else
+      :ok
+    end
   end
 
   @doc """
-  Writes the argument to the device, similar to `write/2`,
-  but adds a newline at the end. The argument is expected
-  to be a chardata.
+  Writes a `message` to stderr, along with the current stacktrace.
+
+  It returns `:ok` if it succeeds.
+
+  Do not call this function at the tail of another function. Due to tail
+  call optimization, a stacktrace entry would not be added and the
+  stacktrace would be incorrectly trimmed. Therefore make sure at least
+  one expression (or an atom such as `:ok`) follows the `IO.warn/1` call.
+
+  ## Examples
+
+      IO.warn("variable bar is unused")
+      #=> warning: variable bar is unused
+      #=>   (iex) evaluator.ex:108: IEx.Evaluator.eval/4
+
   """
-  @spec puts(device, chardata | String.Chars.t) :: :ok
-  def puts(device \\ group_leader(), item) do
-    erl_dev = map_dev(device)
-    :io.put_chars erl_dev, [to_chardata(item), ?\n]
+  @spec warn(chardata | String.Chars.t()) :: :ok
+  def warn(message) do
+    {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
+    warn(message, Enum.drop(stacktrace, 2))
   end
 
   @doc """
-  Inspects and writes the given argument to the device.
+  Inspects and writes the given `item` to the standard output.
+
+  It's important to note that it returns the given `item` unchanged.
+  This makes it possible to "spy" on values by inserting an
+  `IO.inspect/2` call almost anywhere in your code, for example,
+  in the middle of a pipeline.
 
-  It sets by default pretty printing to true and returns
-  the item itself.
+  It enables pretty printing by default with width of
+  80 characters. The width can be changed by explicitly
+  passing the `:width` option.
 
-  Note this function does not use the IO device width
-  because some IO devices does not implement the
-  appropriate functions. Setting the width must be done
-  explicitly by passing the `:width` option.
+  The output can be decorated with a label, by providing the `:label`
+  option to easily distinguish it from other `IO.inspect/2` calls.
+  The label will be printed before the inspected `item`.
+
+  See `Inspect.Opts` for a full list of remaining formatting options.
+  To print to other IO devices, see `IO.inspect/3`
 
   ## Examples
 
-      IO.inspect Process.list
+  The following code:
+
+      IO.inspect(<<0, 1, 2>>, width: 40)
+
+  Prints:
+
+      <<0, 1, 2>>
+
+  You can use the `:label` option to decorate the output:
+
+      IO.inspect(1..100, label: "a wonderful range")
+
+  Prints:
+
+      a wonderful range: 1..100
+
+  Inspect truncates large inputs by default. The `:printable_limit` controls
+  the limit for strings and other string-like constructs (such as charlists):
+
+      "abc"
+      |> String.duplicate(9001)
+      |> IO.inspect(printable_limit: :infinity)
+
+  For containers such as lists, maps, and tuples, the number of entries
+  is managed by the `:limit` option:
+
+      1..100
+      |> Enum.map(& {&1, &1})
+      |> Enum.into(%{})
+      |> IO.inspect(limit: :infinity)
 
   """
-  @spec inspect(term, Keyword.t) :: term
+  @spec inspect(item, inspect_opts) :: item when item: var
   def inspect(item, opts \\ []) do
-    inspect group_leader(), item, opts
+    inspect(:stdio, item, opts)
   end
 
   @doc """
-  Inspects the item with options using the given device.
+  Inspects `item` according to the given options using the IO `device`.
+
+  See `inspect/2` for a full list of options.
   """
-  @spec inspect(device, term, Keyword.t) :: term
-  def inspect(device, item, opts) when is_list(opts) do
-    opts = Keyword.put_new(opts, :pretty, true)
-    puts device, Kernel.inspect(item, opts)
+  @spec inspect(device, item, inspect_opts) :: item when item: var
+  def inspect(device, item, opts) when is_device(device) and is_list(opts) do
+    {label, opts} = Keyword.pop(opts, :label)
+    label = if label, do: [to_chardata(label), ": "], else: []
+    opts = Inspect.Opts.new(opts)
+    doc = Inspect.Algebra.group(Inspect.Algebra.to_doc(item, opts))
+    chardata = Inspect.Algebra.format(doc, opts.width)
+    puts(device, [label, chardata])
     item
   end
 
   @doc """
-  Gets a number of bytes from the io device. If the
-  io device is a unicode device, `count` implies
-  the number of unicode codepoints to be retrieved.
+  Gets a number of bytes from IO device `:stdio`.
+
+  If `:stdio` is a Unicode device, `count` implies
+  the number of Unicode code points to be retrieved.
   Otherwise, `count` is the number of raw bytes to be retrieved.
+
+  See `IO.getn/3` for a description of return values.
+  """
+  @spec getn(
+          device | chardata | String.Chars.t(),
+          pos_integer | :eof | chardata | String.Chars.t()
+        ) ::
+          chardata | nodata
+  def getn(prompt, count \\ 1)
+
+  def getn(prompt, :eof) do
+    getn(:stdio, prompt, :eof)
+  end
+
+  def getn(prompt, count) when is_integer(count) and count > 0 do
+    getn(:stdio, prompt, count)
+  end
+
+  def getn(device, prompt) when not is_integer(prompt) do
+    getn(device, prompt, 1)
+  end
+
+  @doc """
+  Gets a number of bytes from the IO `device`.
+
+  If the IO `device` is a Unicode device, `count` implies
+  the number of Unicode code points to be retrieved.
+  Otherwise, `count` is the number of raw bytes to be retrieved.
+
   It returns:
 
     * `data` - the input characters
@@ -181,100 +564,161 @@ defmodule IO do
     * `{:error, reason}` - other (rare) error condition;
       for instance, `{:error, :estale}` if reading from an
       NFS volume
-  """
-  @spec getn(chardata | String.Chars.t, pos_integer) :: chardata | nodata
-  @spec getn(device, chardata | String.Chars.t) :: chardata | nodata
-  def getn(prompt, count \\ 1)
 
-  def getn(prompt, count) when is_integer(count) do
-    getn(group_leader, prompt, count)
+  """
+  @spec getn(device, chardata | String.Chars.t(), pos_integer | :eof) :: chardata | nodata
+  def getn(device, prompt, :eof) do
+    getn_eof(map_dev(device), to_chardata(prompt), [])
   end
 
-  def getn(device, prompt) do
-    getn(device, prompt, 1)
+  def getn(device, prompt, count) when is_integer(count) and count > 0 do
+    :io.get_chars(map_dev(device), to_chardata(prompt), count)
   end
 
-  @doc """
-  Gets a number of bytes from the io device. If the
-  io device is a unicode device, `count` implies
-  the number of unicode codepoints to be retrieved.
-  Otherwise, `count` is the number of raw bytes to be retrieved.
-  """
-  @spec getn(device, chardata | String.Chars.t, pos_integer) :: chardata | nodata
-  def getn(device, prompt, count) do
-    :io.get_chars(map_dev(device), to_chardata(prompt), count)
+  defp getn_eof(device, prompt, acc) do
+    case :io.get_line(device, prompt) do
+      line when is_binary(line) or is_list(line) -> getn_eof(device, ~c"", [line | acc])
+      :eof -> wrap_eof(:lists.reverse(acc))
+      other -> other
+    end
   end
 
-  @doc """
-  Reads a line from the IO device. It returns:
+  defp wrap_eof([h | _] = acc) when is_binary(h), do: IO.iodata_to_binary(acc)
+  defp wrap_eof([h | _] = acc) when is_list(h), do: :lists.flatten(acc)
+  defp wrap_eof([]), do: :eof
+
+  @doc ~S"""
+  Reads a line from the IO `device`.
+
+  It returns:
 
     * `data` - the characters in the line terminated
-      by a LF (or end of file)
+      by a line-feed (LF) or end of file (EOF)
 
     * `:eof` - end of file was encountered
 
     * `{:error, reason}` - other (rare) error condition;
       for instance, `{:error, :estale}` if reading from an
       NFS volume
+
+  Trivia: `gets` is shorthand for `get string`.
+
+  ## Examples
+
+  To display "What is your name?" as a prompt and await user input:
+
+      IO.gets("What is your name?\n")
+
   """
-  @spec gets(device, chardata | String.Chars.t) :: chardata | nodata
-  def gets(device \\ group_leader(), prompt) do
+  @spec gets(device, chardata | String.Chars.t()) :: chardata | nodata
+  def gets(device \\ :stdio, prompt) do
     :io.get_line(map_dev(device), to_chardata(prompt))
   end
 
   @doc """
-  Converts the io device into a `IO.Stream`.
+  Returns a line-based `IO.Stream` on `:stdio`.
+
+  This is equivalent to:
+
+      IO.stream(:stdio, :line)
+
+  """
+  @doc since: "1.12.0"
+  @spec stream() :: Enumerable.t(String.t())
+  def stream, do: stream(:stdio, :line)
+
+  @doc ~S"""
+  Converts the IO `device` into an `IO.Stream`.
 
   An `IO.Stream` implements both `Enumerable` and
   `Collectable`, allowing it to be used for both read
   and write.
 
-  The device is iterated line by line if `:line` is given or
-  by a given number of codepoints.
+  The `device` is iterated by the given number of characters
+  or line by line if `:line` is given. In case `:line` is given,
+  "\r\n" is automatically normalized to "\n".
 
-  This reads the IO as utf-8. Check out
+  This reads from the IO as UTF-8. Check out
   `IO.binstream/2` to handle the IO as a raw binary.
 
   Note that an IO stream has side effects and every time
   you go over the stream you may get different results.
 
+  `stream/0` has been introduced in Elixir v1.12.0,
+  while `stream/2` has been available since v1.0.0.
+
   ## Examples
 
   Here is an example on how we mimic an echo server
   from the command line:
 
-      Enum.each IO.stream(:stdio, :line), &IO.write(&1)
+      Enum.each(IO.stream(:stdio, :line), &IO.write(&1))
+
+  Another example where you might want to collect a user input
+  every new line and break on an empty line, followed by removing
+  redundant new line characters (`"\n"`):
+
+      IO.stream(:stdio, :line)
+      |> Enum.take_while(&(&1 != "\n"))
+      |> Enum.map(&String.replace(&1, "\n", ""))
 
   """
-  @spec stream(device, :line | pos_integer) :: Enumerable.t
-  def stream(device, line_or_codepoints) do
+  @spec stream(device, :line | pos_integer) :: Enumerable.t()
+  def stream(device \\ :stdio, line_or_codepoints)
+      when line_or_codepoints == :line
+      when is_integer(line_or_codepoints) and line_or_codepoints > 0 do
     IO.Stream.__build__(map_dev(device), false, line_or_codepoints)
   end
 
   @doc """
-  Converts the IO device into a `IO.Stream`.
+  Returns a raw, line-based `IO.Stream` on `:stdio`. The operation is Unicode unsafe.
+
+  This is equivalent to:
+
+      IO.binstream(:stdio, :line)
+
+  """
+  @doc since: "1.12.0"
+  @spec binstream() :: Enumerable.t(binary)
+  def binstream, do: binstream(:stdio, :line)
+
+  @doc ~S"""
+  Converts the IO `device` into an `IO.Stream`. The operation is Unicode unsafe.
 
   An `IO.Stream` implements both `Enumerable` and
   `Collectable`, allowing it to be used for both read
   and write.
 
-  The device is iterated line by line or by a number of bytes.
-  This reads the IO device as a raw binary.
+  The `device` is iterated by the given number of bytes or line
+  by line if `:line` is given. In case `:line` is given, "\r\n"
+  is automatically normalized to "\n". Passing the number of bytes
+  should be the preferred mode for reading non-textual inputs.
 
   Note that an IO stream has side effects and every time
   you go over the stream you may get different results.
+
+  This reads from the IO device as a raw binary. Therefore,
+  do not use this function on IO devices in Unicode mode as
+  it will return the wrong result.
+
+  `binstream/0` has been introduced in Elixir v1.12.0,
+  while `binstream/2` has been available since v1.0.0.
   """
-  @spec binstream(device, :line | pos_integer) :: Enumerable.t
-  def binstream(device, line_or_bytes) do
+  @spec binstream(device, :line | pos_integer) :: Enumerable.t()
+  def binstream(device \\ :stdio, line_or_bytes)
+      when line_or_bytes == :line
+      when is_integer(line_or_bytes) and line_or_bytes > 0 do
     IO.Stream.__build__(map_dev(device), true, line_or_bytes)
   end
 
   @doc """
-  Converts chardata (a list of integers representing codepoints,
-  lists and strings) into a string.
+  Converts chardata into a string.
+
+  For more information about chardata, see the ["Chardata"](#module-chardata)
+  section in the module documentation.
 
-  In case the conversion fails, it raises a `UnicodeConversionError`.
-  If a string is given, returns the string itself.
+  In case the conversion fails, it raises an `UnicodeConversionError`.
+  If a string is given, it returns the string itself.
 
   ## Examples
 
@@ -284,33 +728,32 @@ defmodule IO do
       iex> IO.chardata_to_string([0x0061, "bc"])
       "abc"
 
+      iex> IO.chardata_to_string("string")
+      "string"
+
   """
-  @spec chardata_to_string(chardata) :: String.t | no_return
+  @spec chardata_to_string(chardata) :: String.t()
+  def chardata_to_string(chardata)
+
   def chardata_to_string(string) when is_binary(string) do
     string
   end
 
   def chardata_to_string(list) when is_list(list) do
-    case :unicode.characters_to_binary(list) do
-      result when is_binary(result) ->
-        result
-
-      {:error, encoded, rest} ->
-        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :invalid
-
-      {:incomplete, encoded, rest} ->
-        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :incomplete
-    end
+    List.to_string(list)
   end
 
   @doc """
-  Converts iodata (a list of integers representing bytes, lists
-  and binaries) into a binary.
+  Converts IO data into a binary
+
+  The operation is Unicode unsafe.
 
-  Notice that this function treats lists of integers as raw bytes
-  and does not perform any kind of encoding conversion. If you want
-  to convert from a char list to a string (UTF-8 encoded), please
-  use `chardata_to_string/1` instead.
+  Note that this function treats integers in the given IO data as
+  raw bytes and does not perform any kind of encoding conversion.
+  If you want to convert from a charlist to a UTF-8-encoded string,
+  use `chardata_to_string/1` instead. For more information about
+  IO data and chardata, see the ["IO data"](#module-io-data) section in the
+  module documentation.
 
   If this function receives a binary, the same binary is returned.
 
@@ -321,63 +764,70 @@ defmodule IO do
       iex> bin1 = <<1, 2, 3>>
       iex> bin2 = <<4, 5>>
       iex> bin3 = <<6>>
-      iex> IO.iodata_to_binary([bin1, 1, [2, 3, bin2], 4|bin3])
-      <<1,2,3,1,2,3,4,5,4,6>>
+      iex> IO.iodata_to_binary([bin1, 1, [2, 3, bin2], 4 | bin3])
+      <<1, 2, 3, 1, 2, 3, 4, 5, 4, 6>>
 
       iex> bin = <<1, 2, 3>>
       iex> IO.iodata_to_binary(bin)
-      <<1,2,3>>
+      <<1, 2, 3>>
 
   """
   @spec iodata_to_binary(iodata) :: binary
-  def iodata_to_binary(item) do
-    :erlang.iolist_to_binary(item)
+  def iodata_to_binary(iodata) do
+    :erlang.iolist_to_binary(iodata)
   end
 
   @doc """
-  Returns the size of an iodata.
+  Returns the size of an IO data.
+
+  For more information about IO data, see the ["IO data"](#module-io-data)
+  section in the module documentation.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> IO.iodata_length([1, 2|<<3, 4>>])
+      iex> IO.iodata_length([1, 2 | <<3, 4>>])
       4
 
   """
   @spec iodata_length(iodata) :: non_neg_integer
-  def iodata_length(item) do
-    :erlang.iolist_size(item)
+  def iodata_length(iodata) do
+    :erlang.iolist_size(iodata)
   end
 
   @doc false
-  def each_stream(device, what) do
-    case read(device, what) do
+  def each_stream(device, line_or_codepoints) do
+    case read(device, line_or_codepoints) do
       :eof ->
-        nil
+        {:halt, device}
+
       {:error, reason} ->
         raise IO.StreamError, reason: reason
+
       data ->
-        {data, device}
+        {[data], device}
     end
   end
 
   @doc false
-  def each_binstream(device, what) do
-    case binread(device, what) do
+  def each_binstream(device, line_or_chars) do
+    case binread(device, line_or_chars) do
       :eof ->
-        nil
+        {:halt, device}
+
       {:error, reason} ->
         raise IO.StreamError, reason: reason
+
       data ->
-        {data, device}
+        {[data], device}
     end
   end
 
   @compile {:inline, map_dev: 1, to_chardata: 1}
 
-  # Map the Elixir names for standard io and error to Erlang names
-  defp map_dev(:stdio),  do: :standard_io
+  # Map the Elixir names for standard IO and error to Erlang names
+  defp map_dev(:stdio), do: :standard_io
   defp map_dev(:stderr), do: :standard_error
   defp map_dev(other) when is_atom(other) or is_pid(other) or is_tuple(other), do: other
 
diff --git a/lib/elixir/lib/io/ansi.ex b/lib/elixir/lib/io/ansi.ex
index bb52036357d..f808760ff49 100644
--- a/lib/elixir/lib/io/ansi.ex
+++ b/lib/elixir/lib/io/ansi.ex
@@ -1,228 +1,341 @@
-defmodule IO.ANSI.Sequence do
-  @moduledoc false
-
-  defmacro defsequence(name, code \\ "", terminator \\ "m") do
-    quote bind_quoted: [name: name, code: code, terminator: terminator] do
-      def unquote(name)() do
-        "\e[#{unquote(code)}#{unquote(terminator)}"
-      end
-
-      defp escape_sequence(unquote(Atom.to_char_list(name))) do
-        unquote(name)()
-      end
-    end
-  end
-end
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
 defmodule IO.ANSI do
   @moduledoc """
-  Functionality to render ANSI escape sequences
-  (http://en.wikipedia.org/wiki/ANSI_escape_code) —  characters embedded
-  in text used to control formatting, color, and other output options
-  on video text terminals.
+  Functionality to render ANSI escape sequences.
+
+  [ANSI escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code)
+  are characters embedded in text used to control formatting, color, and
+  other output options on video text terminals.
+
+  ANSI escapes are typically enabled on all Unix terminals. They are also
+  available on Windows consoles from Windows 10, although it must be
+  explicitly enabled for the current user in the registry by running the
+  following command:
+
+      reg add HKCU\\Console /v VirtualTerminalLevel /t REG_DWORD /d 1
+
+  After running the command above, you must restart your current console.
+
+  ## Examples
+
+  Because the ANSI escape sequences are embedded in text, the normal usage of
+  these functions is to concatenate their output with text.
+
+      formatted_text = IO.ANSI.blue_background() <> "Example" <> IO.ANSI.reset()
+      IO.puts(formatted_text)
+
+  A higher level and more convenient API is also available via `IO.ANSI.format/1`,
+  where you use atoms to represent each ANSI escape sequence and by default
+  checks if ANSI is enabled:
+
+      IO.puts(IO.ANSI.format([:blue_background, "Example"]))
+
+  In case ANSI is disabled, the ANSI escape sequences are simply discarded.
   """
 
-  import IO.ANSI.Sequence
+  @type ansicode :: atom
+  @type ansilist ::
+          maybe_improper_list(char | ansicode | binary | ansilist, binary | ansicode | [])
+  @type ansidata :: ansilist | ansicode | binary
+
+  @doc """
+  Checks if ANSI coloring is supported and enabled on this machine.
+
+  This function simply reads the configuration value for
+  `:ansi_enabled` in the `:elixir` application. The value is by
+  default `false` unless Elixir can detect during startup that
+  both `stdout` and `stderr` are terminals.
+  """
+  @spec enabled? :: boolean
+  def enabled? do
+    Application.get_env(:elixir, :ansi_enabled, false)
+  end
 
   @doc """
-  Checks whether the default I/O device is a terminal or a file.
+  Syntax colors to be used by `Inspect`.
+
+  Those colors are used throughout Elixir's standard library,
+  such as `dbg/2` and `IEx`.
+
+  The colors can be changed by setting the `:ansi_syntax_colors`
+  in the `:elixir` application configuration. Configuration for
+  most built-in data types are supported: `:atom`, `:binary`,
+  `:boolean`, `:charlist`, `:list`, `:map`, `:nil`, `:number`,
+  `:string`, and `:tuple`. The default is:
+
+      [
+        atom: :cyan
+        boolean: :magenta,
+        charlist: :yellow,
+        nil: :magenta,
+        number: :yellow,
+        string: :green
+      ]
+
+  """
+  @doc since: "1.14.0"
+  @spec syntax_colors :: Keyword.t(ansidata)
+  def syntax_colors do
+    Application.fetch_env!(:elixir, :ansi_syntax_colors)
+  end
+
+  @doc "Sets foreground color."
+  @spec color(0..255) :: String.t()
+  def color(code) when code in 0..255, do: "\e[38;5;#{code}m"
+
+  @doc ~S"""
+  Sets the foreground color from individual RGB values.
+
+  Valid values for each color are in the range 0 to 5.
+  """
+  @spec color(0..5, 0..5, 0..5) :: String.t()
+  def color(r, g, b) when r in 0..5 and g in 0..5 and b in 0..5 do
+    color(16 + 36 * r + 6 * g + b)
+  end
+
+  @doc "Sets background color."
+  @spec color_background(0..255) :: String.t()
+  def color_background(code) when code in 0..255, do: "\e[48;5;#{code}m"
+
+  @doc ~S"""
+  Sets the background color from individual RGB values.
 
-  Used to identify whether printing ANSI escape sequences will likely
-  be displayed as intended. This is checked by sending a message to
-  the group leader. In case the group leader does not support the message,
-  it will likely lead to a timeout (and a slow down on execution time).
+  Valid values for each color are in the range 0 to 5.
   """
-  @spec terminal? :: boolean
-  @spec terminal?(:io.device) :: boolean
-  def terminal?(device \\ :erlang.group_leader) do
-    !match?({:win32, _}, :os.type()) and
-      match?({:ok, _}, :io.columns(device))
+  @spec color_background(0..5, 0..5, 0..5) :: String.t()
+  def color_background(r, g, b) when r in 0..5 and g in 0..5 and b in 0..5 do
+    color_background(16 + 36 * r + 6 * g + b)
+  end
+
+  defsequence = fn name, code, terminator ->
+    @spec unquote(name)() :: String.t()
+    def unquote(name)() do
+      "\e[#{unquote(code)}#{unquote(terminator)}"
+    end
+
+    defp format_sequence(unquote(name)) do
+      unquote(name)()
+    end
   end
 
-  @doc "Resets all attributes"
-  defsequence :reset, 0
+  @doc "Resets all attributes."
+  defsequence.(:reset, 0, "m")
 
-  @doc "Bright (increased intensity) or Bold"
-  defsequence :bright, 1
+  @doc "Bright (increased intensity) or bold."
+  defsequence.(:bright, 1, "m")
 
-  @doc "Faint (decreased intensity), not widely supported"
-  defsequence :faint, 2
+  @doc "Faint (decreased intensity). Not widely supported."
+  defsequence.(:faint, 2, "m")
 
   @doc "Italic: on. Not widely supported. Sometimes treated as inverse."
-  defsequence :italic, 3
+  defsequence.(:italic, 3, "m")
 
-  @doc "Underline: Single"
-  defsequence :underline, 4
+  @doc "Underline: single."
+  defsequence.(:underline, 4, "m")
 
-  @doc "Blink: Slow. Less than 150 per minute"
-  defsequence :blink_slow, 5
+  @doc "Blink: slow. Less than 150 per minute."
+  defsequence.(:blink_slow, 5, "m")
 
-  @doc "Blink: Rapid. MS-DOS ANSI.SYS; 150 per minute or more; not widely supported"
-  defsequence :blink_rapid, 6
+  @doc "Blink: rapid. MS-DOS ANSI.SYS; 150 per minute or more; not widely supported."
+  defsequence.(:blink_rapid, 6, "m")
 
-  @doc "Image: Negative. Swap foreground and background"
-  defsequence :inverse, 7
+  @doc "Image: negative. Swap foreground and background."
+  defsequence.(:inverse, 7, "m")
 
-  @doc "Image: Negative. Swap foreground and background"
-  defsequence :reverse, 7
+  @doc "Image: negative. Swap foreground and background."
+  defsequence.(:reverse, 7, "m")
 
-  @doc "Conceal. Not widely supported"
-  defsequence :conceal, 8
+  @doc "Conceal. Not widely supported."
+  defsequence.(:conceal, 8, "m")
 
   @doc "Crossed-out. Characters legible, but marked for deletion. Not widely supported."
-  defsequence :crossed_out, 9
+  defsequence.(:crossed_out, 9, "m")
 
-  @doc "Sets primary (default) font"
-  defsequence :primary_font, 10
+  @doc "Sets primary (default) font."
+  defsequence.(:primary_font, 10, "m")
 
   for font_n <- [1, 2, 3, 4, 5, 6, 7, 8, 9] do
-    @doc "Sets alternative font #{font_n}"
-    defsequence :"font_#{font_n}", font_n + 10
+    @doc "Sets alternative font #{font_n}."
+    defsequence.(:"font_#{font_n}", font_n + 10, "m")
   end
 
-  @doc "Normal color or intensity"
-  defsequence :normal, 22
+  @doc "Normal color or intensity."
+  defsequence.(:normal, 22, "m")
+
+  @doc "Not italic."
+  defsequence.(:not_italic, 23, "m")
+
+  @doc "Underline: none."
+  defsequence.(:no_underline, 24, "m")
 
-  @doc "Not italic"
-  defsequence :not_italic, 23
+  @doc "Blink: off."
+  defsequence.(:blink_off, 25, "m")
 
-  @doc "Underline: None"
-  defsequence :no_underline, 24
+  @doc "Image: positive. Normal foreground and background."
+  defsequence.(:inverse_off, 27, "m")
 
-  @doc "Blink: off"
-  defsequence :blink_off, 25
+  @doc "Image: positive. Normal foreground and background."
+  defsequence.(:reverse_off, 27, "m")
+
+  @doc "Reveal: Not concealed."
+  defsequence.(:reveal, 28, "m")
+
+  @doc "Not crossed-out."
+  defsequence.(:not_crossed_out, 29, "m")
 
   colors = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
-  colors = Enum.zip(0..(length(colors)-1), colors)
 
-  for {code, color} <- colors do
-    @doc "Sets foreground color to #{color}"
-    defsequence color, code + 30
+  for {color, code} <- Enum.with_index(colors) do
+    @doc "Sets foreground color to #{color}."
+    defsequence.(color, code + 30, "m")
+
+    @doc "Sets foreground color to light #{color}."
+    defsequence.(:"light_#{color}", code + 90, "m")
+
+    @doc "Sets background color to #{color}."
+    defsequence.(:"#{color}_background", code + 40, "m")
 
-    @doc "Sets background color to #{color}"
-    defsequence :"#{color}_background", code + 40
+    @doc "Sets background color to light #{color}."
+    defsequence.(:"light_#{color}_background", code + 100, "m")
   end
 
-  @doc "Default text color"
-  defsequence :default_color, 39
+  @doc "Default text color."
+  defsequence.(:default_color, 39, "m")
+
+  @doc "Default background color."
+  defsequence.(:default_background, 49, "m")
+
+  @doc "Framed."
+  defsequence.(:framed, 51, "m")
+
+  @doc "Encircled."
+  defsequence.(:encircled, 52, "m")
 
-  @doc "Default background color"
-  defsequence :default_background, 49
+  @doc "Overlined."
+  defsequence.(:overlined, 53, "m")
 
-  @doc "Framed"
-  defsequence :framed, 51
+  @doc "Not framed or encircled."
+  defsequence.(:not_framed_encircled, 54, "m")
 
-  @doc "Encircled"
-  defsequence :encircled, 52
+  @doc "Not overlined."
+  defsequence.(:not_overlined, 55, "m")
 
-  @doc "Overlined"
-  defsequence :overlined, 53
+  @doc "Clears screen."
+  defsequence.(:clear, "2", "J")
 
-  @doc "Not framed or encircled"
-  defsequence :not_framed_encircled, 54
+  @doc "Clears line."
+  defsequence.(:clear_line, "2", "K")
 
-  @doc "Not overlined"
-  defsequence :not_overlined, 55
+  @doc "Sends cursor home."
+  defsequence.(:home, "", "H")
 
-  @doc "Send cursor home"
-  defsequence :home, "", "H"
+  @doc """
+  Sends cursor to the absolute position specified by `line` and `column`.
+
+  Line `0` and column `0` would mean the top left corner.
+  """
+  @spec cursor(non_neg_integer, non_neg_integer) :: String.t()
+  def cursor(line, column)
+      when is_integer(line) and line >= 0 and is_integer(column) and column >= 0 do
+    "\e[#{line};#{column}H"
+  end
 
-  @doc "Clear screen"
-  defsequence :clear, "2", "J"
+  @doc "Sends cursor `lines` up."
+  @spec cursor_up(pos_integer) :: String.t()
+  def cursor_up(lines \\ 1) when is_integer(lines) and lines >= 1, do: "\e[#{lines}A"
 
-  defp escape_sequence(other) do
-    raise ArgumentError, "invalid ANSI sequence specification: #{other}"
+  @doc "Sends cursor `lines` down."
+  @spec cursor_down(pos_integer) :: String.t()
+  def cursor_down(lines \\ 1) when is_integer(lines) and lines >= 1, do: "\e[#{lines}B"
+
+  @doc "Sends cursor `columns` to the right."
+  @spec cursor_right(pos_integer) :: String.t()
+  def cursor_right(columns \\ 1) when is_integer(columns) and columns >= 1, do: "\e[#{columns}C"
+
+  @doc "Sends cursor `columns` to the left."
+  @spec cursor_left(pos_integer) :: String.t()
+  def cursor_left(columns \\ 1) when is_integer(columns) and columns >= 1, do: "\e[#{columns}D"
+
+  defp format_sequence(other) do
+    raise ArgumentError, "invalid ANSI sequence specification: #{inspect(other)}"
   end
 
   @doc ~S"""
-  Escapes a string by converting named ANSI sequences into actual ANSI codes.
+  Formats a chardata-like argument by converting named ANSI sequences into actual
+  ANSI codes.
 
-  The format for referring to sequences is `%{red}` and `%{red,bright}` (for
-  multiple sequences).
+  The named sequences are represented by atoms.
 
-  It will also append a `%{reset}` to the string. If you don't want this
-  behaviour, use `escape_fragment/2`.
+  It will also append an `IO.ANSI.reset/0` to the chardata when a conversion is
+  performed. If you don't want this behavior, use `format_fragment/2`.
 
   An optional boolean parameter can be passed to enable or disable
-  emitting actual ANSI codes. When `false`, no ANSI codes will emitted.
-  By default, standard output will be checked if it is a terminal capable
-  of handling these sequences (using `terminal?/1` function)
+  emitting actual ANSI codes. When `false`, no ANSI codes will be emitted.
+  By default checks if ANSI is enabled using the `enabled?/0` function.
+
+  An `ArgumentError` will be raised if an invalid ANSI code is provided.
 
   ## Examples
 
-      iex> IO.ANSI.escape("Hello %{red,bright,green}yes", true)
-      "Hello \e[31m\e[1m\e[32myes\e[0m"
+      iex> IO.ANSI.format(["Hello, ", :red, :bright, "world!"], true)
+      [[[[[[], "Hello, "] | "\e[31m"] | "\e[1m"], "world!"] | "\e[0m"]
 
   """
-  @spec escape(String.t, emit :: boolean) :: String.t
-  def escape(string, emit \\ terminal?) when is_binary(string) and is_boolean(emit) do
-    {rendered, emitted} = do_escape(string, emit, false, nil, [])
-    if emitted do
-      rendered <> reset
-    else
-      rendered
-    end
+  @spec format(ansidata, boolean) :: IO.chardata()
+  def format(ansidata, emit? \\ enabled?()) when is_boolean(emit?) do
+    do_format(ansidata, [], [], emit?, :maybe)
   end
 
   @doc ~S"""
-  Escapes a string by converting named ANSI sequences into actual ANSI codes.
+  Formats a chardata-like argument by converting named ANSI sequences into actual
+  ANSI codes.
 
-  The format for referring to sequences is `%{red}` and `%{red,bright}` (for
-  multiple sequences).
+  The named sequences are represented by atoms.
 
   An optional boolean parameter can be passed to enable or disable
-  emitting actual ANSI codes. When `false`, no ANSI codes will emitted.
-  By default, standard output will be checked if it is a terminal capable
-  of handling these sequences (using `terminal?/1` function)
+  emitting actual ANSI codes. When `false`, no ANSI codes will be emitted.
+  By default checks if ANSI is enabled using the `enabled?/0` function.
 
   ## Examples
 
-      iex> IO.ANSI.escape_fragment("Hello %{red,bright,green}yes", true)
-      "Hello \e[31m\e[1m\e[32myes"
-
-      iex> IO.ANSI.escape_fragment("%{reset}bye", true)
-      "\e[0mbye"
+      iex> IO.ANSI.format_fragment([:bright, ~c"Word"], true)
+      [[[[[[] | "\e[1m"], 87], 111], 114], 100]
 
   """
-  @spec escape_fragment(String.t, emit :: boolean) :: String.t
-  def escape_fragment(string, emit \\ terminal?) when is_binary(string) and is_boolean(emit) do
-    {escaped, _emitted} = do_escape(string, emit, false, nil, [])
-    escaped
-  end
-
-  defp do_escape(<<?}, t :: binary>>, emit, emitted, buffer, acc) when is_list(buffer) do
-    sequences =
-      buffer
-      |> Enum.reverse()
-      |> :string.tokens(',')
-      |> Enum.map(&(&1 |> :string.strip |> escape_sequence))
-      |> Enum.reverse()
-
-    if emit and sequences != [] do
-      do_escape(t, emit, true, nil, sequences ++ acc)
-    else
-      do_escape(t, emit, emitted, nil, acc)
-    end
+  @spec format_fragment(ansidata, boolean) :: IO.chardata()
+  def format_fragment(ansidata, emit? \\ enabled?()) when is_boolean(emit?) do
+    do_format(ansidata, [], [], emit?, false)
+  end
+
+  defp do_format([term | rest], rem, acc, emit?, append_reset) do
+    do_format(term, [rest | rem], acc, emit?, append_reset)
+  end
+
+  defp do_format(term, rem, acc, true, append_reset) when is_atom(term) do
+    do_format([], rem, [acc | format_sequence(term)], true, !!append_reset)
   end
 
-  defp do_escape(<<h, t :: binary>>, emit, emitted, buffer, acc) when is_list(buffer) do
-    do_escape(t, emit, emitted, [h|buffer], acc)
+  defp do_format(term, rem, acc, false, append_reset) when is_atom(term) do
+    format_sequence(term)
+    do_format([], rem, acc, false, append_reset)
   end
 
-  defp do_escape(<<>>, _emit, _emitted, buffer, _acc) when is_list(buffer) do
-    buffer = IO.iodata_to_binary Enum.reverse(buffer)
-    raise ArgumentError, "missing } for escape fragment #{buffer}"
+  defp do_format(term, rem, acc, emit?, append_reset) when not is_list(term) do
+    do_format([], rem, [acc, term], emit?, append_reset)
   end
 
-  defp do_escape(<<?%, ?{, t :: binary>>, emit, emitted, nil, acc) do
-    do_escape(t, emit, emitted, [], acc)
+  defp do_format([], [next | rest], acc, emit?, append_reset) do
+    do_format(next, rest, acc, emit?, append_reset)
   end
 
-  defp do_escape(<<h, t :: binary>>, emit, emitted, nil, acc) do
-    do_escape(t, emit, emitted, nil, [h|acc])
+  defp do_format([], [], acc, true, true) do
+    [acc | IO.ANSI.reset()]
   end
 
-  defp do_escape(<<>>, _emit, emitted, nil, acc) do
-    {IO.iodata_to_binary(Enum.reverse(acc)), emitted}
+  defp do_format([], [], acc, _emit?, _append_reset) do
+    acc
   end
 end
diff --git a/lib/elixir/lib/io/ansi/docs.ex b/lib/elixir/lib/io/ansi/docs.ex
index 4dfcfb21ac0..fe3a04bc1e4 100644
--- a/lib/elixir/lib/io/ansi/docs.ex
+++ b/lib/elixir/lib/io/ansi/docs.ex
@@ -1,34 +1,64 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule IO.ANSI.Docs do
   @moduledoc false
 
+  @type print_opts :: [
+          enabled: boolean(),
+          doc_bold: [IO.ANSI.ansicode()],
+          doc_code: [IO.ANSI.ansicode()],
+          doc_headings: [IO.ANSI.ansicode()],
+          doc_metadata: [IO.ANSI.ansicode()],
+          doc_quote: [IO.ANSI.ansicode()],
+          doc_inline_code: [IO.ANSI.ansicode()],
+          doc_table_heading: [IO.ANSI.ansicode()],
+          doc_title: [IO.ANSI.ansicode()],
+          doc_underline: [IO.ANSI.ansicode()],
+          width: pos_integer()
+        ]
+
+  @bullet_text_unicode "• "
+  @bullet_text_ascii "* "
   @bullets [?*, ?-, ?+]
+  @spaces [" ", "\n", "\t"]
 
   @doc """
   The default options used by this module.
 
-  The supported values are:
+  The supported keys are:
 
-    * `:enabled`         - toggles coloring on and off (true)
-    * `:doc_code`        - code blocks (cyan, bright)
-    * `:doc_inline_code` - inline code (cyan)
-    * `:doc_headings`    - h1 and h2 headings (yellow, bright)
-    * `:doc_title`       - top level heading (reverse, yellow, bright)
-    * `:doc_bold`        - bold text (bright)
-    * `:doc_underline`   - underlined text (underline)
-    * `:width`           - the width to format the text (80)
+    * `:enabled`           - toggles coloring on and off (true)
+    * `:doc_bold`          - bold text (bright)
+    * `:doc_code`          - code blocks (cyan)
+    * `:doc_headings`      - h1, h2, h3, h4, h5, h6 headings (yellow)
+    * `:doc_metadata`      - documentation metadata keys (yellow)
+    * `:doc_quote`         - leading quote character `> ` (light black)
+    * `:doc_inline_code`   - inline code (cyan)
+    * `:doc_table_heading` - the style for table headings
+    * `:doc_title`         - top level heading (reverse, yellow)
+    * `:doc_underline`     - underlined text (underline)
+    * `:width`             - the width to format the text (80)
 
   Values for the color settings are strings with
   comma-separated ANSI values.
   """
+  @spec default_options() :: print_opts
   def default_options do
-    [enabled: true,
-     doc_code: "cyan,bright",
-     doc_inline_code: "cyan",
-     doc_headings: "yellow,bright",
-     doc_title: "reverse,yellow,bright",
-     doc_bold: "bright",
-     doc_underline: "underline",
-     width: 80]
+    [
+      enabled: true,
+      doc_bold: [:bright],
+      doc_code: [:cyan],
+      doc_headings: [:yellow],
+      doc_metadata: [:yellow],
+      doc_quote: [:light_black],
+      doc_inline_code: [:cyan],
+      doc_table_heading: [:reverse],
+      doc_title: [:reverse, :yellow],
+      doc_underline: [:underline],
+      width: 80
+    ]
   end
 
   @doc """
@@ -36,215 +66,536 @@ defmodule IO.ANSI.Docs do
 
   See `default_options/0` for docs on the supported options.
   """
-  def print_heading(heading, options \\ []) do
-    IO.puts IO.ANSI.reset
-    options = Keyword.merge(default_options, options)
-    width   = options[:width]
-    padding = div(width + String.length(heading), 2)
-    heading = heading |> String.rjust(padding) |> String.ljust(width)
-    write(:doc_title, heading, options)
+  @spec print_headings([String.t()], print_opts) :: :ok
+  def print_headings(headings, options \\ []) do
+    # It's possible for some of the headings to contain newline characters (`\n`), so in order to prevent it from
+    # breaking the output from `print_headings/2`, as `print_headings/2` tries to pad the whole heading, we first split
+    # any heading containgin newline characters into multiple headings, that way each one is padded on its own.
+    headings = Enum.flat_map(headings, fn heading -> String.split(heading, "\n") end)
+    options = Keyword.merge(default_options(), options)
+    newline_after_block(options)
+    width = options[:width]
+
+    for heading <- headings do
+      padding = div(width + String.length(heading), 2)
+      heading = String.pad_leading(heading, padding)
+      heading = if options[:enabled], do: String.pad_trailing(heading, width), else: heading
+      write(:doc_title, heading, options)
+    end
+
+    newline_after_block(options)
   end
 
   @doc """
-  Prints the documentation body.
+  Prints documentation metadata (only `delegate_to`, `deprecated`, `guard`, and `since` for now).
 
-  In addition to the priting string, takes a set of options
-  defined in `default_options/1`.
+  See `default_options/0` for docs on the supported options.
   """
-  def print(doc, options \\ []) do
-    options = Keyword.merge(default_options, options)
+  @spec print_metadata(map, print_opts) :: :ok
+  def print_metadata(metadata, options \\ []) when is_map(metadata) do
+    options = Keyword.merge(default_options(), options)
+    print_each_metadata(metadata, options) && IO.write("\n")
+  end
+
+  @metadata_filter [:deprecated, :guard, :since]
+
+  defp print_each_metadata(metadata, options) do
+    metadata
+    |> Enum.sort()
+    |> Enum.reduce(false, fn
+      {key, value}, _printed when is_binary(value) and key in @metadata_filter ->
+        label = metadata_label(key, options)
+        indent = String.duplicate(" ", length_without_escape(label, 0) + 1)
+        write_with_wrap([label | String.split(value, @spaces)], options[:width], indent, true, "")
+
+      {key, value}, _printed when is_boolean(value) and key in @metadata_filter ->
+        IO.puts([metadata_label(key, options), ?\s, to_string(value)])
+
+      {:delegate_to, {m, f, a}}, _printed ->
+        label = metadata_label(:delegate_to, options)
+        IO.puts([label, ?\s, Exception.format_mfa(m, f, a)])
+
+      _metadata, printed ->
+        printed
+    end)
+  end
+
+  defp metadata_label(key, options) do
+    "#{color(:doc_metadata, options)}#{key}:#{maybe_reset(options)}"
+  end
+
+  @doc """
+  Prints the documentation body `doc` according to `format`.
+
+  It takes a set of `options` defined in `default_options/0`.
+  """
+  @spec print(term(), String.t(), print_opts) :: :ok
+  def print(doc, format, options \\ [])
+
+  def print(doc, "text/markdown", options) when is_binary(doc) and is_list(options) do
+    print_markdown(doc, options)
+  end
+
+  def print(_doc, format, options) when is_binary(format) and is_list(options) do
+    IO.puts("\nUnknown documentation format #{inspect(format)}\n")
+  end
+
+  ## Markdown
+
+  def print_markdown(doc, options) do
+    options = Keyword.merge(default_options(), options)
+
     doc
-    |> String.split(["\r\n","\n"], trim: false)
-    |> Enum.map(&String.rstrip/1)
-    |> process("", options)
+    |> String.split(["\r\n", "\n"], trim: false)
+    |> Enum.map(&String.trim_trailing/1)
+    |> process([], "", options)
   end
 
-  defp process([], _indent, _options), do: nil
+  defp process([], text, indent, options) do
+    write_text(text, indent, options)
+  end
 
-  defp process(["# " <> heading | rest], _indent, options) do
-    write_h1(String.strip(heading), options)
-    process(rest, "", options)
+  defp process(["# " <> _ = heading | rest], text, indent, options) do
+    write_heading(heading, rest, text, indent, options)
   end
 
-  defp process(["## " <> heading | rest], _indent, options) do
-    write_h2(String.strip(heading), options)
-    process(rest, "", options)
+  defp process(["## " <> _ = heading | rest], text, indent, options) do
+    write_heading(heading, rest, text, indent, options)
   end
 
-  defp process(["### " <> heading | rest], indent, options) do
-    write_h3(String.strip(heading), indent, options)
-    process(rest, indent, options)
+  defp process(["### " <> _ = heading | rest], text, indent, options) do
+    write_heading(heading, rest, text, indent, options)
   end
 
-  defp process(["" | rest], indent, options) do
-    process(rest, indent, options)
+  defp process(["#### " <> _ = heading | rest], text, indent, options) do
+    write_heading(heading, rest, text, indent, options)
   end
 
-  defp process(["    " <> line | rest], indent, options) do
-    process_code(rest, [line], indent, options)
+  defp process(["##### " <> _ = heading | rest], text, indent, options) do
+    write_heading(heading, rest, text, indent, options)
   end
 
-  defp process([line | rest], indent, options) do
-    {stripped, count} = strip_spaces(line, 0)
-    case stripped do
-      <<bullet, ?\s, item :: binary >> when bullet in @bullets ->
-        process_list(item, rest, count, indent, options)
-      _ ->
-        process_text(rest, [line], indent, false, options)
-    end
+  defp process(["###### " <> _ = heading | rest], text, indent, options) do
+    write_heading(heading, rest, text, indent, options)
   end
 
-  defp strip_spaces(" " <> line, acc) do
-    strip_spaces(line, acc + 1)
+  defp process([">" <> line | rest], text, indent, options) do
+    write_text(text, indent, options)
+    process_quote(rest, [line], indent, options)
   end
 
-  defp strip_spaces(rest, acc) do
-    {rest, acc}
+  defp process(["" | rest], text, indent, options) do
+    write_text(text, indent, options)
+    process(rest, [], indent, options)
   end
 
-  ## Headings
+  defp process(["    " <> line | rest], text, indent, options) do
+    write_text(text, indent, options)
+    process_code(rest, [line], indent, options)
+  end
+
+  defp process(["```mermaid" <> _line | rest], text, indent, options) do
+    write_text(text, indent, options)
 
-  defp write_h1(heading, options) do
-    write_h2(String.upcase(heading), options)
+    rest
+    |> Enum.drop_while(&(&1 != "```"))
+    |> Enum.drop(1)
+    |> process([], indent, options)
   end
 
-  defp write_h2(heading, options) do
-    write(:doc_headings, heading, options)
+  defp process(["```" <> _line | rest], text, indent, options) do
+    process_fenced_code_block(rest, text, indent, options, _delimiter = "```")
+  end
+
+  defp process(["<!--" <> line | rest], text, indent, options) do
+    process(drop_comment([line | rest]), text, indent, options)
   end
 
-  defp write_h3(heading, indent, options) do
-    IO.write(indent)
+  defp process(all = [line | rest], text, indent, options) do
+    {stripped, count} = strip_spaces(line, 0, :infinity)
+
+    cond do
+      link_label?(stripped, count) ->
+        write_text([line], indent, options, true)
+        process(rest, text, indent, options)
+
+      table_line?(stripped) and rest != [] and table_line?(hd(rest)) ->
+        write_text(text, indent, options)
+        process_table(all, indent, options)
+
+      true ->
+        process_rest(stripped, rest, count, text, indent, options)
+    end
+  end
+
+  ### Headings
+
+  defp write_heading(heading, rest, text, indent, options) do
+    write_text(text, indent, options)
     write(:doc_headings, heading, options)
+    newline_after_block(options)
+    process(rest, [], "", options)
   end
 
-  ## Lists
+  ### Quotes
 
-  defp process_list(line, rest, count, indent, options) do
-    IO.write indent <> "• "
-    {contents, rest, done} = process_list_next(rest, count, false, [])
-    process_text(contents, [line], indent <> "  ", true, options)
-    if done, do: IO.puts(IO.ANSI.reset)
-    process(rest, indent, options)
+  defp process_quote([">", ">" <> line | rest], lines, indent, options) do
+    write_quote(lines, indent, options, true)
+    write_empty_quote_line(options)
+    process_quote(rest, [line], indent, options)
   end
 
-  # Process the thing after a list item entry. It can be either:
-  #
-  # * Continuation of the list
-  # * A nested list
-  # * The end of the list
-  #
-  defp process_list_next([" " <> _ = line | rest], count, _done, acc) do
-    case list_next(line, count) do
-      :done    -> {Enum.reverse(acc), [line|rest], false}
-      chopped  -> process_list_next(rest, count, false, [chopped|acc])
-    end
+  defp process_quote([">" <> line | rest], lines, indent, options) do
+    process_quote(rest, [line | lines], indent, options)
   end
 
-  defp process_list_next([<<bullet, ?\s, _ :: binary>> | _] = rest, _count, _done, acc) when bullet in @bullets do
-    {Enum.reverse(acc), rest, false}
+  defp process_quote(rest, lines, indent, options) do
+    write_quote(lines, indent, options, false)
+    process(rest, [], indent, options)
   end
 
-  defp process_list_next(["" | rest], count, _done, acc) do
-    process_list_next(rest, count, true, [""|acc])
+  defp write_quote(lines, indent, options, no_wrap) do
+    lines
+    |> Enum.map(&String.trim/1)
+    |> Enum.reverse()
+    |> write_lines(
+      indent,
+      options,
+      no_wrap,
+      quote_prefix(options)
+    )
   end
 
-  defp process_list_next(rest, _count, done, acc) do
-    {Enum.reverse(acc), rest, done}
+  defp write_empty_quote_line(options) do
+    options
+    |> quote_prefix()
+    |> IO.puts()
   end
 
-  defp list_next(<<bullet, ?\s, _ :: binary>>, 0) when bullet in @bullets, do: :done
-  defp list_next(line, 0),          do: chop(line, 2)
-  defp list_next(" " <> line, acc), do: list_next(line, acc - 1)
-  defp list_next(line, _acc),       do: line
+  ### Lists
 
-  defp chop(" " <> line, acc) when acc > 0, do: chop(line, acc - 1)
-  defp chop(line, _acc), do: line
+  defp process_rest(stripped, rest, count, text, indent, options) do
+    case stripped do
+      <<bullet, ?\s, item::binary>> when bullet in @bullets ->
+        write_text(text, indent, options)
+        process_list(bullet_text(options), item, rest, count, indent, options)
+
+      <<d1, ?., ?\s, item::binary>> when d1 in ?0..?9 ->
+        write_text(text, indent, options)
+        process_list(<<d1, ?., ?\s>>, item, rest, count, indent, options)
 
-  ## Text (paragraphs / lists)
+      <<d1, d2, ?., ?\s, item::binary>> when d1 in ?0..?9 and d2 in ?0..?9 ->
+        write_text(text, indent, options)
+        process_list(<<d1, d2, ?., ?\s>>, item, rest, count, indent, options)
 
-  defp process_text(doc=["" | _], para, indent, from_list, options) do
-    write_text(Enum.reverse(para), indent, from_list, options)
-    process(doc, indent, options)
+      _ ->
+        process(rest, [stripped | text], indent, options)
+    end
   end
 
-  defp process_text([], para, indent, from_list, options) do
-    write_text(Enum.reverse(para), indent, from_list, options)
+  defp process_list(entry, line, rest, count, indent, options) do
+    # The first list always win some extra padding
+    entry = if indent == "", do: "  " <> entry, else: entry
+    new_indent = indent <> String.duplicate(" ", String.length(entry))
+
+    {contents, rest, done} =
+      process_list_next(rest, count, byte_size(new_indent) - byte_size(indent), [])
+
+    process(contents, [indent <> entry <> line, :no_wrap], new_indent, options)
+
+    if done, do: newline_after_block(options)
+    process(rest, [], indent, options)
   end
 
-  defp process_text([line | rest], para, indent, true, options) do
-    {stripped, count} = strip_spaces(line, 0)
-    case stripped do
-      <<bullet, ?\s, item :: binary>> when bullet in @bullets ->
-        write_text(Enum.reverse(para), indent, true, options)
-        process_list(item, rest, count, indent, options)
+  defp process_list_next([line | rest], count, max, acc) do
+    {stripped, next_count} = strip_spaces(line, 0, max)
+
+    case process_list_next_kind(stripped, rest, count, next_count) do
+      :next -> process_list_next(rest, count, max, [stripped | acc])
+      :done -> {Enum.reverse(acc), [line | rest], true}
+      :list -> {Enum.reverse(acc), [line | rest], false}
+    end
+  end
+
+  defp process_list_next([], _count, _max, acc) do
+    {Enum.reverse(acc), [], true}
+  end
+
+  defp process_list_next_kind(stripped, rest, count, next_count) do
+    case {stripped, rest} do
+      {<<bullet, ?\s, _::binary>>, _} when bullet in @bullets and next_count <= count ->
+        :list
+
+      {<<d1, ?., ?\s, _::binary>>, _} when d1 in ?0..?9 and next_count <= count ->
+        :list
+
+      {<<d1, d2, ?., ?\s, _::binary>>, _}
+      when d1 in ?0..?9 and d2 in ?0..?9 and next_count <= count ->
+        :list
+
+      {"", [" " <> _ | _]} ->
+        :next
+
+      {"", _} ->
+        :done
+
       _ ->
-        process_text(rest, [line | para], indent, true, options)
+        :next
     end
   end
 
-  defp process_text([line | rest], para, indent, from_list, options) do
-    process_text(rest, [line | para], indent, from_list, options)
+  ### Text
+
+  defp write_text(text, indent, options) do
+    case Enum.reverse(text) do
+      [:no_wrap | rest] -> write_text(rest, indent, options, true)
+      rest -> write_text(rest, indent, options, false)
+    end
+  end
+
+  defp write_text([], _indent, _options, _no_wrap) do
+    :ok
+  end
+
+  defp write_text(lines, indent, options, no_wrap) do
+    write_lines(lines, indent, options, no_wrap, "")
   end
 
-  defp write_text(lines, indent, from_list, options) do
+  defp write_lines(lines, indent, options, no_wrap, prefix) do
     lines
     |> Enum.join(" ")
-    |> handle_links
-    |> handle_inline(nil, [], [], options)
-    |> String.split(~r{\s})
-    |> write_with_wrap(options[:width] - byte_size(indent), indent, from_list)
+    |> format_text(options)
+    |> String.split(@spaces)
+    |> write_with_wrap(options[:width] - byte_size(indent), indent, no_wrap, prefix)
 
-    unless from_list, do: IO.puts(IO.ANSI.reset)
+    if !no_wrap, do: newline_after_block(options)
   end
 
-  ## Code blocks
-
-  defp process_code([], code, indent, options) do
-    write_code(code, indent, options)
+  defp format_text(text, options) do
+    text
+    |> handle_links()
+    |> handle_inline(options)
   end
 
+  ### Code blocks
+
   # Blank line between code blocks
-  defp process_code([ "", "    " <> line | rest ], code, indent, options) do
+  defp process_code(["", "    " <> line | rest], code, indent, options) do
     process_code(rest, [line, "" | code], indent, options)
   end
 
-  defp process_code([ "    " <> line | rest ], code, indent, options) do
-    process_code(rest, [line|code], indent, options)
+  defp process_code(["    " <> line | rest], code, indent, options) do
+    process_code(rest, [line | code], indent, options)
   end
 
   defp process_code(rest, code, indent, options) do
     write_code(code, indent, options)
-    process(rest, indent, options)
+    process(rest, [], indent, options)
+  end
+
+  defp process_fenced_code_block(rest, text, indent, options, delimiter) do
+    write_text(text, indent, options)
+    process_fenced_code(rest, [], indent, options, delimiter)
+  end
+
+  defp process_fenced_code([], code, indent, options, _delimiter) do
+    write_code(code, indent, options)
+  end
+
+  defp process_fenced_code([line | rest], code, indent, options, delimiter) do
+    if line == delimiter do
+      process_code(rest, code, indent, options)
+    else
+      process_fenced_code(rest, [line | code], indent, options, delimiter)
+    end
   end
 
   defp write_code(code, indent, options) do
-    write(:doc_code, "#{indent}┃ #{Enum.join(Enum.reverse(code), "\n#{indent}┃ ")}", options)
+    write(:doc_code, "#{indent}    #{Enum.join(Enum.reverse(code), "\n#{indent}    ")}", options)
+    newline_after_block(options)
+  end
+
+  ### Tables
+
+  defp process_table(lines, indent, options) do
+    {table, rest} = Enum.split_while(lines, &table_line?/1)
+    table_lines(table, options)
+    newline_after_block(options)
+    process(rest, [], indent, options)
+  end
+
+  defp table_lines(lines, options) do
+    lines = Enum.map(lines, &split_into_columns(&1, options))
+    count = Enum.map(lines, &length/1) |> Enum.max()
+    lines = Enum.map(lines, &pad_to_number_of_columns(&1, count))
+
+    widths =
+      for line <- lines do
+        if table_header?(line) do
+          for _ <- line, do: 0
+        else
+          for {_col, length} <- line, do: length
+        end
+      end
+
+    col_widths = Enum.reduce(widths, List.duplicate(0, count), &max_column_widths/2)
+    render_table(lines, col_widths, options)
+  end
+
+  defp split_into_columns(line, options) do
+    line
+    |> String.trim(" ")
+    |> String.trim("|")
+    |> String.split(~r{(?<!\\)\|})
+    |> Enum.map(&render_column(&1, options))
+  end
+
+  defp render_column(col, options) do
+    col =
+      col
+      |> String.trim()
+      |> String.replace("\\\|", "|")
+      |> handle_links()
+      |> handle_inline(options)
+
+    {col, length_without_escape(col, 0)}
+  end
+
+  defp pad_to_number_of_columns(cols, col_count),
+    do: cols ++ List.duplicate({"", 0}, col_count - length(cols))
+
+  defp max_column_widths(cols, widths),
+    do: Enum.zip(cols, widths) |> Enum.map(fn {a, b} -> max(a, b) end)
+
+  # If second line is heading separator, use the heading style on the first
+  defp render_table([first, second | rest], widths, options) do
+    combined = Enum.zip(first, widths)
+
+    if table_header?(second) do
+      alignments = Enum.map(second, &column_alignment/1)
+      options = Keyword.put_new(options, :alignments, alignments)
+      draw_table_row(combined, options, :heading)
+      render_table(rest, widths, options)
+    else
+      draw_table_row(combined, options)
+      render_table([second | rest], widths, options)
+    end
+  end
+
+  defp render_table([first | rest], widths, options) do
+    combined = Enum.zip(first, widths)
+    draw_table_row(combined, options)
+    render_table(rest, widths, options)
+  end
+
+  defp render_table([], _, _), do: nil
+
+  defp column_alignment({line, _}) do
+    cond do
+      String.starts_with?(line, ":") and String.ends_with?(line, ":") -> :center
+      String.ends_with?(line, ":") -> :right
+      true -> :left
+    end
+  end
+
+  defp table_header?(line) do
+    Enum.all?(line, fn {col, _} -> table_header_column?(col) end)
+  end
+
+  defp table_header_column?(":" <> rest), do: table_header_contents?(rest)
+  defp table_header_column?(col), do: table_header_contents?(col)
+
+  defp table_header_contents?("-" <> rest), do: table_header_contents?(rest)
+  defp table_header_contents?(":"), do: true
+  defp table_header_contents?(""), do: true
+  defp table_header_contents?(_), do: false
+
+  defp draw_table_row(cols_and_widths, options, heading \\ false) do
+    default_alignments = List.duplicate(:left, length(cols_and_widths))
+    alignments = Keyword.get(options, :alignments, default_alignments)
+
+    columns =
+      cols_and_widths
+      |> Enum.zip(alignments)
+      |> Enum.map_join(" | ", &generate_table_cell/1)
+
+    if heading do
+      write(:doc_table_heading, columns, options)
+    else
+      IO.puts(columns)
+    end
+  end
+
+  defp generate_table_cell({{{col, length}, width}, :center}) do
+    ansi_diff = byte_size(col) - length
+    width = width + ansi_diff
+
+    col
+    |> String.pad_leading(div(width, 2) - div(length, 2) + length)
+    |> String.pad_trailing(width + 1 - rem(width, 2))
+  end
+
+  defp generate_table_cell({{{col, length}, width}, :right}) do
+    ansi_diff = byte_size(col) - length
+    String.pad_leading(col, width + ansi_diff)
+  end
+
+  defp generate_table_cell({{{col, length}, width}, :left}) do
+    ansi_diff = byte_size(col) - length
+    String.pad_trailing(col, width + ansi_diff)
+  end
+
+  defp table_line?(line) do
+    line =~ ~r/[:\ -]\|[:\ -]/
   end
 
   ## Helpers
 
+  defp link_label?("[" <> rest, count) when count <= 3, do: link_label?(rest)
+  defp link_label?(_, _), do: false
+
+  defp link_label?("]: " <> _), do: true
+  defp link_label?("]" <> _), do: false
+  defp link_label?(""), do: false
+  defp link_label?(<<_>> <> rest), do: link_label?(rest)
+
+  defp strip_spaces(" " <> line, acc, max) when acc < max, do: strip_spaces(line, acc + 1, max)
+  defp strip_spaces(rest, acc, _max), do: {rest, acc}
+
   defp write(style, string, options) do
-    IO.puts color(style, options) <> string <> IO.ANSI.reset
-    IO.puts IO.ANSI.reset
+    IO.puts([color(style, options), string, maybe_reset(options)])
   end
 
-  defp write_with_wrap([], _available, _indent, _first) do
+  defp write_with_wrap([], _available, _indent, _first, _prefix) do
     :ok
   end
 
-  defp write_with_wrap(words, available, indent, first) do
-    {words, rest} = take_words(words, available, [])
-    IO.puts (if first, do: "", else: indent) <> Enum.join(words, " ")
-    write_with_wrap(rest, available, indent, false)
+  defp write_with_wrap(words, available, indent, first, prefix) do
+    words
+    |> wrap_text(available, indent, first, prefix, [])
+    |> tl()
+    |> IO.puts()
   end
 
-  defp take_words([word|words], available, acc) do
+  defp wrap_text([], _available, _indent, _first, _prefix, wrapped_lines) do
+    Enum.reverse(wrapped_lines)
+  end
+
+  defp wrap_text(words, available, indent, first, prefix, wrapped_lines) do
+    prefix_length = length_without_escape(prefix, 0)
+    {words, rest} = take_words(words, available - prefix_length, [])
+    line = [if(first, do: "", else: indent), prefix, Enum.join(words, " ")]
+
+    wrap_text(rest, available, indent, false, prefix, [line, ?\n | wrapped_lines])
+  end
+
+  defp take_words([word | words], available, acc) do
     available = available - length_without_escape(word, 0)
 
     cond do
       # It fits, take one for space and continue decreasing
       available > 0 ->
-        take_words(words, available - 1, [word|acc])
+        take_words(words, available - 1, [word | acc])
 
       # No space but we got no words
       acc == [] ->
@@ -252,7 +603,7 @@ defmodule IO.ANSI.Docs do
 
       # Otherwise
       true ->
-        {Enum.reverse(acc), [word|words]}
+        {Enum.reverse(acc), [word | words]}
     end
   end
 
@@ -260,117 +611,208 @@ defmodule IO.ANSI.Docs do
     {Enum.reverse(acc), []}
   end
 
-  defp length_without_escape(<< ?\e, ?[, _, _, ?m, rest :: binary >>, count) do
+  defp length_without_escape(<<?\e, ?[, _, _, ?m>> <> rest, count) do
     length_without_escape(rest, count)
   end
 
-  defp length_without_escape(<< ?\e, ?[, _, ?m, rest :: binary >>, count) do
+  defp length_without_escape(<<?\e, ?[, _, ?m>> <> rest, count) do
     length_without_escape(rest, count)
   end
 
   defp length_without_escape(rest, count) do
     case String.next_grapheme(rest) do
-      {_, rest}  -> length_without_escape(rest, count + 1)
+      {_, rest} -> length_without_escape(rest, count + 1)
       nil -> count
     end
   end
 
   defp handle_links(text) do
     text
-    |> remove_square_brackets_in_link
-    |> escape_underlines_in_link
+    |> remove_square_brackets_in_link()
+    |> escape_underlines_in_link()
   end
 
   defp escape_underlines_in_link(text) do
-    case Regex.match?(~r{.*(https?\S*)}, text) do
-      true ->
-        Regex.replace(~r{_}, text, "\\\\_")
-      _ ->
-        text
-    end
+    # Regular expression adapted from https://tools.ietf.org/html/rfc3986#appendix-B
+    Regex.replace(~r{[a-z][a-z0-9\+\-\.]*://\S*}i, text, &String.replace(&1, "_", "\\_"))
   end
 
   defp remove_square_brackets_in_link(text) do
-    Regex.replace(~r{\[(.*?)\]\((.*?)\)}, text, "\\1 (\\2)")
+    Regex.replace(~r{\[([^\]]*?)\]\((.*?)\)}, text, "\\1 (\\2)")
+  end
+
+  defp drop_comment(line) when is_binary(line) do
+    [_comment, rest] = :binary.split(line, "-->")
+    rest
+  end
+
+  defp drop_comment([line | rest]) do
+    case :binary.split(line, "-->") do
+      [_] -> drop_comment(rest)
+      [_, line] -> [line | rest]
+    end
+  end
+
+  defp drop_comment([]) do
+    []
+  end
+
+  # We have four entries: **, __, *, _ and `.
+  #
+  # The first four behave the same while the last one is simpler
+  # when it comes to delimiters as it ignores spaces and escape
+  # characters. But, since the first two has two characters,
+  # we need to handle 3 cases:
+  #
+  # 1. __ and **
+  # 2. _ and *
+  # 3. `
+  #
+  # Where the first two should have the same code but match differently.
+  @single [?_, ?*]
+
+  # Characters that can mark the beginning or the end of a word.
+  # Only support the most common ones at this moment.
+  @delimiters [?\s, ?', ?", ?!, ?@, ?#, ?$, ?%, ?^, ?&] ++
+                [?-, ?+, ?(, ?), ?[, ?], ?{, ?}, ?<, ?>, ?.]
+
+  ### Inline start
+
+  defp handle_inline(<<mark, mark, rest::binary>>, options) when mark in @single do
+    handle_inline(rest, [mark | mark], [<<mark, mark>>], [], options)
+  end
+
+  defp handle_inline(<<mark, rest::binary>>, options) when mark in @single do
+    handle_inline(rest, mark, [<<mark>>], [], options)
   end
 
-  # Single inline quotes.
-  @single [?`, ?_, ?*]
+  defp handle_inline(rest, options) do
+    handle_inline(rest, nil, [], [], options)
+  end
+
+  ### Inline delimiters
 
-  # ` does not require space in between
-  @spaced [?_, ?*]
+  defp handle_inline("<!--" <> rest, nil, buffer, acc, options) do
+    rest = drop_comment(rest)
+    handle_inline(rest, [], buffer, acc, options)
+  end
 
-  # Clauses for handling spaces
-  defp handle_inline(<<?*, ?*, ?\s, rest :: binary>>, nil, buffer, acc, options) do
-    handle_inline(rest, nil, [?\s, ?*, ?*|buffer], acc, options)
+  defp handle_inline(<<delimiter, mark, mark, rest::binary>>, nil, buffer, acc, options)
+       when rest != "" and delimiter in @delimiters and mark in @single do
+    acc = [delimiter, Enum.reverse(buffer) | acc]
+    handle_inline(rest, [mark | mark], [<<mark, mark>>], acc, options)
   end
 
-  defp handle_inline(<<mark, ?\s, rest :: binary>>, nil, buffer, acc, options) when mark in @spaced do
-    handle_inline(rest, nil, [?\s, mark|buffer], acc, options)
+  defp handle_inline(<<delimiter, mark, rest::binary>>, nil, buffer, acc, options)
+       when rest != "" and delimiter in @delimiters and mark in @single do
+    handle_inline(rest, mark, [<<mark>>], [delimiter, Enum.reverse(buffer) | acc], options)
   end
 
-  defp handle_inline(<<?\s, ?*, ?*, rest :: binary>>, limit, buffer, acc, options) do
-    handle_inline(rest, limit, [?*, ?*, ?\s|buffer], acc, options)
+  defp handle_inline(<<?`, rest::binary>>, nil, buffer, acc, options)
+       when rest != "" do
+    handle_inline(rest, ?`, ["`"], [Enum.reverse(buffer) | acc], options)
   end
 
-  defp handle_inline(<<?\s, mark, rest :: binary>>, limit, buffer, acc, options) when mark in @spaced do
-    handle_inline(rest, limit, [mark, ?\s|buffer], acc, options)
+  ### Clauses for handling escape
+
+  defp handle_inline(<<?\\, ?\\, mark, mark, rest::binary>>, nil, buffer, acc, options)
+       when rest != "" and mark in @single do
+    acc = [?\\, Enum.reverse(buffer) | acc]
+    handle_inline(rest, [mark | mark], [<<mark, mark>>], acc, options)
   end
 
-  # Clauses for handling escape
-  defp handle_inline(<<?\\, ?\\, rest :: binary>>, limit, buffer, acc, options) do
-    handle_inline(rest, limit, [?\\|buffer], acc, options)
+  defp handle_inline(<<?\\, ?\\, mark, rest::binary>>, nil, buffer, acc, options)
+       when rest != "" and mark in @single do
+    handle_inline(rest, mark, [<<mark>>], [?\\, Enum.reverse(buffer) | acc], options)
   end
 
-  defp handle_inline(<<?\\, ?*, ?*, rest :: binary>>, limit, buffer, acc, options) do
-    handle_inline(rest, limit, [?*, ?*|buffer], acc, options)
+  defp handle_inline(<<?\\, ?\\, rest::binary>>, limit, buffer, acc, options) do
+    handle_inline(rest, limit, [?\\ | buffer], acc, options)
   end
 
-  # A escape is not valid inside `
-  defp handle_inline(<<?\\, mark, rest :: binary>>, limit, buffer, acc, options)
-      when mark in [?_, ?*, ?`] and not(mark == limit and mark == ?`) do
-    handle_inline(rest, limit, [mark|buffer], acc, options)
+  # An escape is not valid inside `
+  defp handle_inline(<<?\\, mark, rest::binary>>, limit, buffer, acc, options) when limit != ?` do
+    handle_inline(rest, limit, [mark | buffer], acc, options)
   end
 
-  # Inline start
-  defp handle_inline(<<?*, ?*, rest :: binary>>, nil, buffer, acc, options) when rest != "" do
-    handle_inline(rest, ?d, ["**"], [Enum.reverse(buffer)|acc], options)
+  ### Inline end
+
+  defp handle_inline(<<mark, mark, delimiter, rest::binary>>, [mark | mark], buffer, acc, options)
+       when delimiter in @delimiters and mark in @single do
+    inline_buffer = inline_buffer(buffer, options)
+    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer | acc], options)
   end
 
-  defp handle_inline(<<mark, rest :: binary>>, nil, buffer, acc, options) when rest != "" and mark in @single do
-    handle_inline(rest, mark, [<<mark>>], [Enum.reverse(buffer)|acc], options)
+  defp handle_inline(<<mark, delimiter, rest::binary>>, mark, buffer, acc, options)
+       when delimiter in @delimiters and mark in @single do
+    inline_buffer = inline_buffer(buffer, options)
+    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer | acc], options)
   end
 
-  # Inline end
-  defp handle_inline(<<?*, ?*, rest :: binary>>, ?d, buffer, acc, options) do
-    handle_inline(rest, nil, [], [inline_buffer(buffer, options)|acc], options)
+  defp handle_inline(<<mark, mark, rest::binary>>, [mark | mark], buffer, acc, options)
+       when rest == "" and mark in @single do
+    handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
-  defp handle_inline(<<mark, rest :: binary>>, mark, buffer, acc, options) when mark in @single do
-    handle_inline(rest, nil, [], [inline_buffer(buffer, options)|acc], options)
+  defp handle_inline(<<mark, rest::binary>>, mark, buffer, acc, options)
+       when rest == "" and mark in @single do
+    handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
-  defp handle_inline(<<char, rest :: binary>>, mark, buffer, acc, options) do
-    handle_inline(rest, mark, [char|buffer], acc, options)
+  defp handle_inline(<<?`, rest::binary>>, ?`, buffer, acc, options) do
+    handle_inline(rest, nil, [], [inline_buffer(buffer, options) | acc], options)
+  end
+
+  ### Catch all
+
+  defp handle_inline(<<char, rest::binary>>, mark, buffer, acc, options) do
+    handle_inline(rest, mark, [char | buffer], acc, options)
   end
 
   defp handle_inline(<<>>, _mark, buffer, acc, _options) do
-    IO.iodata_to_binary Enum.reverse([Enum.reverse(buffer)|acc])
+    IO.iodata_to_binary(Enum.reverse([Enum.reverse(buffer) | acc]))
   end
 
   defp inline_buffer(buffer, options) do
-    [h|t] = Enum.reverse([IO.ANSI.reset|buffer])
-    [color_for(h, options)|t]
+    [mark | t] = Enum.reverse(buffer)
+    inline_text(mark, t, options)
+  end
+
+  ## Helpers
+
+  defp quote_prefix(options), do: "#{color(:doc_quote, options)}> #{maybe_reset(options)}"
+
+  defp inline_text(mark, text, options) do
+    if options[:enabled] do
+      [[color_for(mark, options) | text] | IO.ANSI.reset()]
+    else
+      [[mark | text] | mark]
+    end
   end
 
-  defp color_for("`", colors),  do: color(:doc_inline_code, colors)
-  defp color_for("_", colors),  do: color(:doc_underline, colors)
-  defp color_for("*", colors),  do: color(:doc_bold, colors)
-  defp color_for("**", colors), do: color(:doc_bold, colors)
+  defp color_for(mark, colors) do
+    case mark do
+      "__" -> color(:doc_bold, colors)
+      "**" -> color(:doc_bold, colors)
+      "_" -> color(:doc_underline, colors)
+      "*" -> color(:doc_underline, colors)
+      "`" -> color(:doc_inline_code, colors)
+    end
+  end
+
+  defp bullet_text(options) do
+    if options[:enabled], do: @bullet_text_unicode, else: @bullet_text_ascii
+  end
 
   defp color(style, colors) do
-    color = colors[style]
-    enabled = colors[:enabled]
-    IO.ANSI.escape_fragment("%{#{color}}", enabled)
+    IO.ANSI.format_fragment(colors[style], colors[:enabled])
+  end
+
+  defp newline_after_block(options) do
+    IO.puts(maybe_reset(options))
+  end
+
+  defp maybe_reset(options) do
+    if options[:enabled], do: IO.ANSI.reset(), else: ""
   end
 end
diff --git a/lib/elixir/lib/io/stream.ex b/lib/elixir/lib/io/stream.ex
index d275626226e..4fa8f1c77b3 100644
--- a/lib/elixir/lib/io/stream.ex
+++ b/lib/elixir/lib/io/stream.ex
@@ -1,37 +1,45 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule IO.StreamError do
-  defexception [:reason, :message]
+  defexception [:reason]
 
-  def exception(opts) do
-    reason    = opts[:reason]
-    formatted = IO.iodata_to_binary(:file.format_error(reason))
-    %IO.StreamError{message: "error during streaming: #{formatted}", reason: reason}
+  @impl true
+  def message(%{reason: reason}) do
+    "error during streaming: #{inspect(reason)}"
   end
 end
 
 defmodule IO.Stream do
   @moduledoc """
-  Defines a `IO.Stream` struct returned by `IO.stream/2` and `IO.binstream/2`.
+  Defines an `IO.Stream` struct returned by `IO.stream/2` and `IO.binstream/2`.
 
   The following fields are public:
 
     * `device`        - the IO device
     * `raw`           - a boolean indicating if bin functions should be used
-    * `line_or_bytes` - if reading should read lines or a given amount of bytes
+    * `line_or_bytes` - if reading should read lines or a given number of bytes
+
+  It is worth noting that an IO stream has side effects and every time you go
+  over the stream you may get different results.
 
   """
 
   defstruct device: nil, raw: true, line_or_bytes: :line
 
+  @type t :: %__MODULE__{
+          device: IO.device(),
+          raw: boolean(),
+          line_or_bytes: :line | non_neg_integer()
+        }
+
   @doc false
   def __build__(device, raw, line_or_bytes) do
     %IO.Stream{device: device, raw: raw, line_or_bytes: line_or_bytes}
   end
 
   defimpl Collectable do
-    def empty(stream) do
-      stream
-    end
-
     def into(%{device: device, raw: raw} = stream) do
       {:ok, into(stream, device, raw)}
     end
@@ -40,10 +48,12 @@ defmodule IO.Stream do
       fn
         :ok, {:cont, x} ->
           case raw do
-            true  -> IO.binwrite(device, x)
+            true -> IO.binwrite(device, x)
             false -> IO.write(device, x)
           end
-        :ok, _ -> stream
+
+        :ok, _ ->
+          stream
       end
     end
   end
@@ -52,10 +62,11 @@ defmodule IO.Stream do
     def reduce(%{device: device, raw: raw, line_or_bytes: line_or_bytes}, acc, fun) do
       next_fun =
         case raw do
-          true  -> &IO.each_binstream(&1, line_or_bytes)
+          true -> &IO.each_binstream(&1, line_or_bytes)
           false -> &IO.each_stream(&1, line_or_bytes)
         end
-      Stream.unfold(device, next_fun).(acc, fun)
+
+      Stream.resource(fn -> device end, next_fun, & &1).(acc, fun)
     end
 
     def count(_stream) do
@@ -65,5 +76,9 @@ defmodule IO.Stream do
     def member?(_stream, _term) do
       {:error, __MODULE__}
     end
+
+    def slice(_stream) do
+      {:error, __MODULE__}
+    end
   end
 end
diff --git a/lib/elixir/lib/json.ex b/lib/elixir/lib/json.ex
new file mode 100644
index 00000000000..e2891fa82d5
--- /dev/null
+++ b/lib/elixir/lib/json.ex
@@ -0,0 +1,547 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defprotocol JSON.Encoder do
+  @moduledoc """
+  A protocol for custom JSON encoding of data structures.
+
+  If you have a struct, you can derive the implementation of this protocol
+  by specifying which fields should be encoded to JSON:
+
+      @derive {JSON.Encoder, only: [...]}
+      defstruct ...
+
+  Additionally, you can exclude specific fields using the `:except` option or
+  encode all fields by omitting both options entirely, but these should be used
+  with caution:
+
+      @derive {JSON.Encoder, except: [...]}
+      defstruct ...
+
+      @derive JSON.Encoder
+      defstruct ...
+
+  > #### Leaking Private Information {: .error}
+  >
+  > Prefer using `:only` to avoid accidentally leaking private information when
+  > new fields are added. Other approaches should be used with auction.
+
+  You can also use `Protocol.derive/3` if you don't own the struct that you want
+  to encode to JSON:
+
+      Protocol.derive(JSON.Encoder, NameOfTheStruct, only: [...])
+      Protocol.derive(JSON.Encoder, NameOfTheStruct, except: [...])
+      Protocol.derive(JSON.Encoder, NameOfTheStruct)
+
+  """
+
+  @undefined_impl_description """
+  the protocol must be explicitly implemented.
+
+  If you have a struct, you can derive the implementation specifying \
+  which fields should be encoded to JSON:
+
+      @derive {JSON.Encoder, only: [....]}
+      defstruct ...
+
+  It is also possible to encode all fields, although this should be \
+  used carefully to avoid accidentally leaking private information \
+  when new fields are added:
+
+      @derive JSON.Encoder
+      defstruct ...
+
+  Finally, if you don't own the struct you want to encode to JSON, \
+  you may use Protocol.derive/3 placed outside of any module:
+
+      Protocol.derive(JSON.Encoder, NameOfTheStruct, only: [...])
+      Protocol.derive(JSON.Encoder, NameOfTheStruct)\
+  """
+
+  @impl true
+  defmacro __deriving__(module, opts) do
+    fields = module |> Macro.struct_info!(__CALLER__) |> Enum.map(& &1.field)
+    fields = fields_to_encode(fields, opts)
+    vars = Macro.generate_arguments(length(fields), __MODULE__)
+    kv = Enum.zip(fields, vars)
+
+    {io, _prefix} =
+      Enum.flat_map_reduce(kv, ?{, fn {field, value}, prefix ->
+        key = IO.iodata_to_binary([prefix, :elixir_json.encode_binary(Atom.to_string(field)), ?:])
+        {[key, quote(do: encoder.(unquote(value), encoder))], ?,}
+      end)
+
+    io = if io == [], do: "{}", else: io ++ [?}]
+
+    quote do
+      defimpl JSON.Encoder, for: unquote(module) do
+        def encode(%{unquote_splicing(kv)}, encoder) do
+          unquote(io)
+        end
+      end
+    end
+  end
+
+  defp fields_to_encode(fields, opts) do
+    cond do
+      only = Keyword.get(opts, :only) ->
+        case only -- fields do
+          [] ->
+            only
+
+          error_keys ->
+            raise ArgumentError,
+                  "unknown struct fields #{inspect(error_keys)} specified in :only. Expected one of: " <>
+                    "#{inspect(fields -- [:__struct__])}"
+        end
+
+      except = Keyword.get(opts, :except) ->
+        case except -- fields do
+          [] ->
+            fields -- [:__struct__ | except]
+
+          error_keys ->
+            raise ArgumentError,
+                  "unknown struct fields #{inspect(error_keys)} specified in :except. Expected one of: " <>
+                    "#{inspect(fields -- [:__struct__])}"
+        end
+
+      true ->
+        fields -- [:__struct__]
+    end
+  end
+
+  @doc """
+  A function invoked to encode the given term to `t:iodata/0`.
+  """
+  def encode(term, encoder)
+end
+
+defimpl JSON.Encoder, for: Atom do
+  def encode(value, encoder) do
+    case value do
+      nil -> "null"
+      true -> "true"
+      false -> "false"
+      _ -> encoder.(Atom.to_string(value), encoder)
+    end
+  end
+end
+
+defimpl JSON.Encoder, for: BitString do
+  def encode(value, _encoder) do
+    :elixir_json.encode_binary(value)
+  end
+end
+
+defimpl JSON.Encoder, for: List do
+  def encode(value, encoder) do
+    :elixir_json.encode_list(value, encoder)
+  end
+end
+
+defimpl JSON.Encoder, for: Integer do
+  def encode(value, _encoder) do
+    :elixir_json.encode_integer(value)
+  end
+end
+
+defimpl JSON.Encoder, for: Float do
+  def encode(value, _encoder) do
+    :elixir_json.encode_float(value)
+  end
+end
+
+defimpl JSON.Encoder, for: Map do
+  def encode(value, encoder) do
+    case :maps.next(:maps.iterator(value)) do
+      :none ->
+        "{}"
+
+      {key, value, iterator} ->
+        [?{, key(key, encoder), ?:, encoder.(value, encoder) | next(iterator, encoder)]
+    end
+  end
+
+  defp next(iterator, encoder) do
+    case :maps.next(iterator) do
+      :none ->
+        "}"
+
+      {key, value, iterator} ->
+        [?,, key(key, encoder), ?:, encoder.(value, encoder) | next(iterator, encoder)]
+    end
+  end
+
+  # Erlang supports only numbers, binaries, and atoms as keys,
+  # we support anything that implements the String.Chars protocol.
+  defp key(key, encoder) when is_atom(key), do: encoder.(Atom.to_string(key), encoder)
+  defp key(key, encoder) when is_binary(key), do: encoder.(key, encoder)
+  defp key(key, encoder), do: encoder.(String.Chars.to_string(key), encoder)
+end
+
+defimpl JSON.Encoder, for: Duration do
+  def encode(value, _encoder) do
+    [?", Duration.to_iso8601(value), ?"]
+  end
+end
+
+defimpl JSON.Encoder, for: Date do
+  def encode(%{calendar: Calendar.ISO} = date, _encoder) do
+    %{year: year, month: month, day: day} = date
+    [?", Calendar.ISO.date_to_iodata(year, month, day), ?"]
+  end
+
+  def encode(value, _encoder) do
+    [?", Date.to_iso8601(value), ?"]
+  end
+end
+
+defimpl JSON.Encoder, for: Time do
+  def encode(%{calendar: Calendar.ISO} = time, _encoder) do
+    %{
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    } = time
+
+    [?", Calendar.ISO.time_to_iodata(hour, minute, second, microsecond), ?"]
+  end
+
+  def encode(value, _encoder) do
+    [?", Time.to_iso8601(value), ?"]
+  end
+end
+
+defimpl JSON.Encoder, for: NaiveDateTime do
+  def encode(%{calendar: Calendar.ISO} = naive_datetime, _encoder) do
+    %{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    } = naive_datetime
+
+    [
+      ?",
+      Calendar.ISO.date_to_iodata(year, month, day),
+      ?T,
+      Calendar.ISO.time_to_iodata(hour, minute, second, microsecond),
+      ?"
+    ]
+  end
+
+  def encode(value, _encoder) do
+    [?", NaiveDateTime.to_iso8601(value), ?"]
+  end
+end
+
+defimpl JSON.Encoder, for: DateTime do
+  def encode(%{calendar: Calendar.ISO} = datetime, _encoder) do
+    %{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      time_zone: time_zone,
+      utc_offset: utc_offset,
+      std_offset: std_offset
+    } = datetime
+
+    [
+      ?",
+      Calendar.ISO.date_to_iodata(year, month, day),
+      ?T,
+      Calendar.ISO.time_to_iodata(hour, minute, second, microsecond),
+      Calendar.ISO.offset_to_iodata(utc_offset, std_offset, time_zone, :extended),
+      ?"
+    ]
+  end
+
+  def encode(value, _encoder) do
+    [?", DateTime.to_iso8601(value), ?"]
+  end
+end
+
+defmodule JSON.DecodeError do
+  @moduledoc """
+  The exception raised by `JSON.decode!/1`.
+  """
+  defexception [:message, :offset, :data]
+end
+
+defmodule JSON do
+  @moduledoc ~S"""
+  JSON encoding and decoding.
+
+  Both encoder and decoder fully conform to [RFC 8259](https://tools.ietf.org/html/rfc8259) and
+  [ECMA 404](https://ecma-international.org/publications-and-standards/standards/ecma-404/)
+  standards.
+
+  ## Encoding
+
+  Elixir primitive types are encoded to JSON as follows:
+
+  | **Elixir**                 | **JSON** |
+  |----------------------------|----------|
+  | `integer() \| float()`     | Number   |
+  | `true \| false `           | Boolean  |
+  | `nil`                      | Null     |
+  | `binary()`                 | String   |
+  | `atom()`                   | String   |
+  | `list()`                   | Array    |
+  | `%{String.Chars.t() => _}` | Object   |
+
+  You may also implement the `JSON.Encoder` protocol for custom data structures.
+  Some built-in data-structures already derive the `JSON.Encoder` protocol:
+
+  | **Elixir**             | **JSON**        |
+  |------------------------|-----------------|
+  | `Date.t()`             | ISO 8601 string |
+  | `Time.t()`             | ISO 8601 string |
+  | `DateTime.t()`         | ISO 8601 string |
+  | `NaiveDateTime.t()`    | ISO 8601 string |
+  | `Duration.t()`         | ISO 8601 string |
+
+  ## Decoding
+
+  Elixir types are decoded from JSON as follows:
+
+  | **JSON** | **Elixir**             |
+  |----------|------------------------|
+  | Number   | `integer() \| float()` |
+  | Boolean  | `true \| false`        |
+  | Null     | `nil`                  |
+  | String   | `binary()`             |
+  | Object   | `%{binary() => _}`     |
+
+  """
+
+  @moduledoc since: "1.18.0"
+
+  @type encoder :: (term(), encoder() -> iodata())
+
+  @type decode_error_reason ::
+          {:unexpected_end, non_neg_integer()}
+          | {:invalid_byte, non_neg_integer(), byte()}
+          | {:unexpected_sequence, non_neg_integer(), binary()}
+
+  @typedoc """
+  Decoders for customizing JSON decoding behavior.
+  """
+  @type decoders :: [
+          array_start: (term() -> term()),
+          array_push: (term(), term() -> term()),
+          array_finish: (term(), term() -> {term(), term()}),
+          object_start: (term() -> term()),
+          object_push: (term(), term(), term() -> term()),
+          object_finish: (term(), term() -> {term(), term()}),
+          float: (String.t() -> term()),
+          integer: (String.t() -> term()),
+          string: (String.t() -> term()),
+          null: term()
+        ]
+
+  @doc ~S"""
+  Decodes the given JSON.
+
+  Returns `{:ok, decoded}` or `{:error, reason}`.
+
+  ## Examples
+
+      iex> JSON.decode("[null,123,\"string\",{\"key\":\"value\"}]")
+      {:ok, [nil, 123, "string", %{"key" => "value"}]}
+
+  ## Error reasons
+
+  The error tuple will have one of the following reasons.
+
+    * `{:unexpected_end, offset}` if `binary` contains incomplete JSON value
+    * `{:invalid_byte, offset, byte}` if `binary` contains unexpected byte or invalid UTF-8 byte
+    * `{:unexpected_sequence, offset, bytes}` if `binary` contains invalid UTF-8 escape
+  """
+  @spec decode(binary()) :: {:ok, term()} | {:error, decode_error_reason()}
+  def decode(binary) when is_binary(binary) do
+    with {decoded, :ok, rest} <- decode(binary, :ok, []) do
+      if rest == "" do
+        {:ok, decoded}
+      else
+        {:error, {:invalid_byte, byte_size(binary) - byte_size(rest), :binary.at(rest, 0)}}
+      end
+    end
+  end
+
+  @doc ~S"""
+  Decodes the given JSON with the given decoders.
+
+  Returns `{decoded, acc, rest}` or `{:error, reason}`.
+  See `decode/1` for the error reasons.
+
+  ## Decoders
+
+  All decoders are optional. If not provided, they will fall back to
+  implementations used by the `decode/1` function:
+
+    * for `array_start`: `fn _ -> [] end`
+    * for `array_push`: `fn elem, acc -> [elem | acc] end`
+    * for `array_finish`: `fn acc, old_acc -> {Enum.reverse(acc), old_acc} end`
+    * for `object_start`: `fn _ -> [] end`
+    * for `object_push`: `fn key, value, acc -> [{key, value} | acc] end`
+    * for `object_finish`: `fn acc, old_acc -> {Map.new(acc), old_acc} end`
+    * for `float`: `&String.to_float/1`
+    * for `integer`: `&String.to_integer/1`
+    * for `string`: `&Function.identity/1`
+    * for `null`: the atom `nil`
+
+  For streaming decoding, see Erlang's [`:json`](`:json`) module.
+  """
+  @spec decode(binary(), term(), decoders()) ::
+          {term(), term(), binary()} | {:error, decode_error_reason()}
+  def decode(binary, acc, decoders) when is_binary(binary) and is_list(decoders) do
+    decoders = Keyword.put_new(decoders, :null, nil)
+
+    try do
+      :elixir_json.decode(binary, acc, Map.new(decoders))
+    catch
+      :error, :unexpected_end ->
+        {:error, {:unexpected_end, byte_size(binary)}}
+
+      :error, {:invalid_byte, byte} ->
+        {:error, {:invalid_byte, offset(__STACKTRACE__), byte}}
+
+      :error, {:unexpected_sequence, bytes} ->
+        {:error, {:unexpected_sequence, offset(__STACKTRACE__), bytes}}
+    end
+  end
+
+  defp offset(stacktrace) do
+    with [{_, _, _, opts} | _] <- stacktrace,
+         %{cause: %{position: position}} <- opts[:error_info] do
+      position
+    else
+      _ -> 0
+    end
+  end
+
+  @doc ~S"""
+  Decodes the given JSON but raises an exception in case of errors.
+
+  Returns the decoded content. See `decode/1` for possible errors.
+
+  ## Examples
+
+      iex> JSON.decode!("[null,123,\"string\",{\"key\":\"value\"}]")
+      [nil, 123, "string", %{"key" => "value"}]
+  """
+  @spec decode!(binary()) :: term()
+  def decode!(binary) when is_binary(binary) do
+    case decode(binary) do
+      {:ok, decoded} ->
+        decoded
+
+      {:error, {:unexpected_end, offset}} ->
+        raise JSON.DecodeError,
+          message: "unexpected end of JSON binary at position (byte offset) #{offset}",
+          data: binary,
+          offset: offset
+
+      {:error, {:invalid_byte, offset, byte}} ->
+        raise JSON.DecodeError,
+          message: "invalid byte #{byte} at position (byte offset) #{offset}",
+          data: binary,
+          offset: offset
+
+      {:error, {:unexpected_sequence, offset, bytes}} ->
+        raise JSON.DecodeError,
+          message: "unexpected sequence #{inspect(bytes)} at position (byte offset) #{offset}",
+          data: binary,
+          offset: offset
+    end
+  end
+
+  @doc ~S"""
+  Encodes the given term to JSON as a binary.
+
+  The second argument is a function that is recursively
+  invoked to encode a term.
+
+  > #### IO and performance {: .tip}
+  >
+  > If you need to encode data to be sent over the network
+  > or written to the filesystem, consider using the more
+  > efficient `encode_to_iodata!/2`.
+
+  ## Examples
+
+      iex> JSON.encode!([123, "string", %{key: "value"}])
+      "[123,\"string\",{\"key\":\"value\"}]"
+
+  """
+  @spec encode!(term(), encoder()) :: binary()
+  def encode!(term, encoder \\ &protocol_encode/2) do
+    IO.iodata_to_binary(encoder.(term, encoder))
+  end
+
+  @doc ~S"""
+  Encodes the given term to JSON as an iodata.
+
+  This is the most efficient format if the JSON is going to be
+  used for IO purposes.
+
+  The second argument is a function that is recursively
+  invoked to encode a term.
+
+  ## Examples
+
+      iex> data = JSON.encode_to_iodata!([123, "string", %{key: "value"}])
+      iex> IO.iodata_to_binary(data)
+      "[123,\"string\",{\"key\":\"value\"}]"
+
+  """
+  @spec encode_to_iodata!(term(), encoder()) :: iodata()
+  def encode_to_iodata!(term, encoder \\ &protocol_encode/2) do
+    encoder.(term, encoder)
+  end
+
+  @doc """
+  This is the default encode implementation passed to `encode!/1`.
+
+  This function is most typically passed as second argument to
+  `encode!/2` and `encode_to_iodata!/2`. The default implementation
+  is an optimized dispatch to the `JSON.Encoder` protocol.
+  """
+  @spec protocol_encode(term(), encoder()) :: iodata()
+  def protocol_encode(value, encoder) when is_atom(value) do
+    case value do
+      nil -> "null"
+      true -> "true"
+      false -> "false"
+      _ -> encoder.(Atom.to_string(value), encoder)
+    end
+  end
+
+  def protocol_encode(value, _encoder) when is_binary(value),
+    do: :elixir_json.encode_binary(value)
+
+  def protocol_encode(value, _encoder) when is_integer(value),
+    do: :elixir_json.encode_integer(value)
+
+  def protocol_encode(value, _encoder) when is_float(value),
+    do: :elixir_json.encode_float(value)
+
+  def protocol_encode(value, encoder) when is_list(value),
+    do: :elixir_json.encode_list(value, encoder)
+
+  def protocol_encode(%{} = value, encoder) when not is_map_key(value, :__struct__),
+    do: JSON.Encoder.Map.encode(value, encoder)
+
+  def protocol_encode(value, encoder),
+    do: JSON.Encoder.encode(value, encoder)
+end
diff --git a/lib/elixir/lib/kernel.ex b/lib/elixir/lib/kernel.ex
index a0778bbd4d1..c2476ea290a 100644
--- a/lib/elixir/lib/kernel.ex
+++ b/lib/elixir/lib/kernel.ex
@@ -1,32 +1,296 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 # Use elixir_bootstrap module to be able to bootstrap Kernel.
 # The bootstrap module provides simpler implementations of the
 # functions removed, simple enough to bootstrap.
-import Kernel, except: [@: 1, defmodule: 2, def: 1, def: 2, defp: 2,
-                        defmacro: 1, defmacro: 2, defmacrop: 2]
+import Kernel,
+  except: [@: 1, defmodule: 2, def: 1, def: 2, defp: 2, defmacro: 1, defmacro: 2, defmacrop: 2]
+
 import :elixir_bootstrap
 
 defmodule Kernel do
   @moduledoc """
-  `Kernel` provides the default macros and functions
-  Elixir imports into your environment. These macros and functions
-  can be skipped or cherry-picked via the `import` macro. For
-  instance, if you want to tell Elixir not to import the `if`
-  macro, you can do:
+  `Kernel` is Elixir's default environment.
+
+  It mainly consists of:
+
+    * basic language primitives, such as arithmetic operators, spawning of processes,
+      data type handling, and others
+    * macros for control-flow and defining new functionality (modules, functions, and the like)
+    * guard checks for augmenting pattern matching
+
+  You can invoke `Kernel` functions and macros anywhere in Elixir code
+  without the use of the `Kernel.` prefix since they have all been
+  automatically imported. For example, in IEx, you can call:
+
+      iex> is_number(13)
+      true
+
+  If you don't want to import a function or macro from `Kernel`, use the `:except`
+  option and then list the function/macro by arity:
 
-      import Kernel, except: [if: 2]
+      import Kernel, except: [if: 2, is_number: 1]
+
+  See `import/2` for more information on importing.
 
   Elixir also has special forms that are always imported and
   cannot be skipped. These are described in `Kernel.SpecialForms`.
 
+  ## The standard library
+
+  `Kernel` provides the basic capabilities the Elixir standard library
+  is built on top of. It is recommended to explore the standard library
+  for advanced functionality. Here are the main groups of modules in the
+  standard library (this list is not a complete reference, see the
+  documentation sidebar for all entries).
+
+  ### Built-in types
+
+  The following modules handle Elixir built-in data types:
+
+    * `Atom` - literal constants with a name (`true`, `false`, and `nil` are atoms)
+    * `Float` - numbers with floating point precision
+    * `Function` - a reference to code chunk, created with the `fn/1` special form
+    * `Integer` - whole numbers (not fractions)
+    * `List` - collections of a variable number of elements (linked lists)
+    * `Map` - collections of key-value pairs
+    * `Process` - light-weight threads of execution
+    * `Port` - mechanisms to interact with the external world
+    * `Tuple` - collections of a fixed number of elements
+
+  There are two data types without an accompanying module:
+
+    * Bitstring - a sequence of bits, created with `<<>>/1`.
+      When the number of bits is divisible by 8, they are called binaries and can
+      be manipulated with Erlang's [`:binary`](`:binary`) module
+    * Reference - a unique value in the runtime system, created with `make_ref/0`
+
+  ### Data types
+
+  Elixir also provides other data types that are built on top of the types
+  listed above. Some of them are:
+
+    * `Date` - `year-month-day` structs in a given calendar
+    * `DateTime` - date and time with time zone in a given calendar
+    * `Exception` - data raised from errors and unexpected scenarios
+    * `MapSet` - unordered collections of unique elements
+    * `NaiveDateTime` - date and time without time zone in a given calendar
+    * `Keyword` - lists of two-element tuples, often representing optional values
+    * `Range` - inclusive ranges between two integers
+    * `Regex` - regular expressions
+    * `String` - UTF-8 encoded binaries representing characters
+    * `Time` - `hour:minute:second` structs in a given calendar
+    * `URI` - representation of URIs that identify resources
+    * `Version` - representation of versions and requirements
+
+  ### System modules
+
+  Modules that interface with the underlying system, such as:
+
+    * `IO` - handles input and output
+    * `File` - interacts with the underlying file system
+    * `Path` - manipulates file system paths
+    * `System` - reads and writes system information
+
+  ### Protocols
+
+  Protocols add polymorphic dispatch to Elixir. They are contracts
+  implementable by data types. See `Protocol` for more information on
+  protocols. Elixir provides the following protocols in the standard library:
+
+    * `Collectable` - collects data into a data type
+    * `Enumerable` - handles collections in Elixir. The `Enum` module
+      provides eager functions for working with collections, the `Stream`
+      module provides lazy functions
+    * `Inspect` - converts data types into their programming language
+      representation
+    * `List.Chars` - converts data types to their outside world
+      representation as charlists (non-programming based)
+    * `String.Chars` - converts data types to their outside world
+      representation as strings (non-programming based)
+
+  ### Process-based and application-centric functionality
+
+  The following modules build on top of processes to provide concurrency,
+  fault-tolerance, and more.
+
+    * `Agent` - a process that encapsulates mutable state
+    * `Application` - functions for starting, stopping and configuring
+      applications
+    * `GenServer` - a generic client-server API
+    * `Registry` - a key-value process-based storage
+    * `Supervisor` - a process that is responsible for starting,
+      supervising and shutting down other processes
+    * `Task` - a process that performs computations
+    * `Task.Supervisor` - a supervisor for managing tasks exclusively
+
+  ### Supporting documents
+
+  Under the "Pages" section in sidebar you will find tutorials, guides,
+  and reference documents that outline Elixir semantics and behaviors
+  in more detail. Those are:
+
+    * [Compatibility and deprecations](compatibility-and-deprecations.md) - lists
+      compatibility between every Elixir version and Erlang/OTP, release schema;
+      lists all deprecated functions, when they were deprecated and alternatives
+    * [Library guidelines](library-guidelines.md) - general guidelines, anti-patterns,
+      and rules for those writing libraries
+    * [Naming conventions](naming-conventions.md) - naming conventions for Elixir code
+    * [Operators reference](operators.md) - lists all Elixir operators and their precedences
+    * [Patterns and guards](patterns-and-guards.md) - an introduction to patterns,
+      guards, and extensions
+    * [Syntax reference](syntax-reference.md) - the language syntax reference
+    * [Typespecs reference](typespecs.md)- types and function specifications, including list of types
+    * [Unicode syntax](unicode-syntax.md) - outlines Elixir support for Unicode
+
+  ## Guards
+
+  This module includes the built-in guards used by Elixir developers.
+  They are a predefined set of functions and macros that augment pattern
+  matching, typically invoked after the `when` operator. For example:
+
+      def drive(%User{age: age}) when age >= 16 do
+        ...
+      end
+
+  The clause above will only be invoked if the user's age is more than
+  or equal to 16. Guards also support joining multiple conditions with
+  `and` and `or`. The whole guard is true if all guard expressions will
+  evaluate to `true`. A more complete introduction to guards is available
+  in the [Patterns and guards](patterns-and-guards.md) page.
+
+  ## Truthy and falsy values
+
+  Besides the booleans `true` and `false`, Elixir has the
+  concept of a "truthy" or "falsy" value.
+
+    *  a value is truthy when it is neither `false` nor `nil`
+    *  a value is falsy when it is either `false` or `nil`
+
+  Elixir has functions, like `and/2`, that *only* work with
+  booleans, but also functions that work with these
+  truthy/falsy values, like `&&/2` and `!/1`.
+
+  ## Structural comparison
+
+  The functions in this module perform structural comparison. This allows
+  different data types to be compared using comparison operators:
+
+      1 < :an_atom
+
+  This is possible so Elixir developers can create collections, such as
+  dictionaries and ordered sets, that store a mixture of data types in them.
+  To understand why this matters, let's discuss the two types of comparisons
+  we find in software: _structural_ and _semantic_.
+
+  Structural means we are comparing the underlying data structures and we often
+  want those operations to be as fast as possible, because it is used to power
+  several algorithms and data structures in the language. A semantic comparison
+  worries about what each data type represents. For example, semantically
+  speaking, it doesn't make sense to compare `Time` with `Date`.
+
+  One example that shows the differences between structural and semantic
+  comparisons are strings: "alien" sorts less than "office" (`"alien" < "office"`)
+  but "álien" is greater than "office". This happens because `<` compares the
+  underlying bytes that form the string. If you were doing alphabetical listing,
+  you may want "álien" to also appear before "office".
+
+  This means **comparisons in Elixir are structural**, as it has the goal
+  of comparing data types as efficiently as possible to create flexible
+  and performant data structures. This distinction is specially important
+  for functions that provide ordering, such as `>/2`, `</2`, `>=/2`,
+  `<=/2`, `min/2`, and `max/2`. For example:
+
+      ~D[2017-03-31] > ~D[2017-04-01]
+
+  will return `true` because structural comparison compares the `:day`
+  field before `:month` or `:year`. Luckily, the Elixir compiler will
+  detect whenever comparing structs or whenever comparing code that is
+  either always true or false, and emit a warning accordingly.
+
+  In order to perform semantic comparisons, the relevant data-types
+  provide a `compare/2` function, such as `Date.compare/2`:
+
+      iex> Date.compare(~D[2017-03-31], ~D[2017-04-01])
+      :lt
+
+  Alternatively, you can use the functions in the `Enum` module to
+  sort or compute a maximum/minimum:
+
+      iex> Enum.sort([~D[2017-03-31], ~D[2017-04-01]], Date)
+      [~D[2017-03-31], ~D[2017-04-01]]
+      iex> Enum.max([~D[2017-03-31], ~D[2017-04-01]], Date)
+      ~D[2017-04-01]
+
+  The second argument is precisely the module to be used for semantic
+  comparison. Keeping this distinction is important, because if semantic
+  comparison was used by default for implementing data structures and
+  algorithms, they could become orders of magnitude slower!
+
+  Finally, note there is an overall structural sorting order, called
+  "Term Ordering", defined below. This order is provided for reference
+  purposes, it is not required for Elixir developers to know it by heart.
+
+  ### Term ordering
+
+  ```
+  number < atom < reference < function < port < pid < tuple < map < list < bitstring
+  ```
+
+  When comparing two numbers of different types (a number being either
+  an integer or a float), a conversion to the type with greater precision
+  will always occur, unless the comparison operator used is either `===/2`
+  or `!==/2`. A float will be considered more precise than an integer, unless
+  the float is greater/less than +/-9007199254740992.0 respectively,
+  at which point all the significant figures of the float are to the left
+  of the decimal point. This behavior exists so that the comparison of large
+  numbers remains transitive.
+
+  The collection types are compared using the following rules:
+
+  * Tuples are compared by size, then element by element.
+  * Maps are compared by size, then by key-value pairs.
+  * Lists are compared element by element.
+  * Bitstrings are compared byte by byte, incomplete bytes are compared bit by bit.
+  * Atoms are compared using their string value, codepoint by codepoint.
+
+  ### Examples
+
+  We can check the truthiness of a value by using the `!/1`
+  function twice.
+
+  Truthy values:
+
+      iex> !!true
+      true
+      iex> !!5
+      true
+      iex> !![1,2]
+      true
+      iex> !!"foo"
+      true
+
+  Falsy values (of which there are exactly two):
+
+      iex> !!false
+      false
+      iex> !!nil
+      false
+
+  ## Inlining
+
   Some of the functions described in this module are inlined by
-  the Elixir compiler into their Erlang counterparts in the `:erlang`
-  module. Those functions are called BIFs (builtin internal functions)
-  in Erlang-land and they exhibit interesting properties, as some of
-  them are allowed in guards and others are used for compiler
+  the Elixir compiler into their Erlang counterparts in the
+  [`:erlang`](`:erlang`) module.
+  Those functions are called BIFs (built-in internal functions)
+  in Erlang-land and they exhibit interesting properties, as some
+  of them are allowed in guards and others are used for compiler
   optimizations.
 
-  Most of the inlined functions can be seen in effect when capturing
-  the function:
+  Most of the inlined functions can be seen in effect when
+  capturing the function:
 
       iex> &Kernel.is_atom/1
       &:erlang.is_atom/1
@@ -35,6 +299,17 @@ defmodule Kernel do
   "inlined by the compiler".
   """
 
+  # We need this check only for bootstrap purposes.
+  # Once Kernel is loaded and we recompile, it is a no-op.
+  @compile {:inline, bootstrapped?: 1}
+  case :code.ensure_loaded(Kernel) do
+    {:module, _} ->
+      defp bootstrapped?(module), do: is_atom(module)
+
+    {:error, _} ->
+      defp bootstrapped?(module), do: :code.ensure_loaded(module) == {:module, module}
+  end
+
   ## Delegations to Erlang with inlining (macros)
 
   @doc """
@@ -51,13 +326,19 @@ defmodule Kernel do
       3
 
   """
+  @doc guard: true
   @spec abs(number) :: number
   def abs(number) do
     :erlang.abs(number)
   end
 
   @doc """
-  Invokes the given `fun` with the array of arguments `args`.
+  Invokes the given anonymous function `fun` with the list of
+  arguments `args`.
+
+  If the number of arguments is known at compile time, prefer
+  `fun.(arg_1, arg_2, ..., arg_n)` as it is clearer than
+  `apply(fun, [arg_1, arg_2, ..., arg_n])`.
 
   Inlined by the compiler.
 
@@ -73,27 +354,37 @@ defmodule Kernel do
   end
 
   @doc """
-  Invokes the given `fun` from `module` with the array of arguments `args`.
+  Invokes the given function from `module` with the list of
+  arguments `args`.
+
+  `apply/3` is used to invoke functions where the module, function
+  name or arguments are defined dynamically at runtime. For this
+  reason, you can't invoke macros using `apply/3`, only functions.
+
+  If the number of arguments and the function name are known at compile time,
+  prefer `module.function(arg_1, arg_2, ..., arg_n)` as it is clearer than
+  `apply(module, :function, [arg_1, arg_2, ..., arg_n])`.
+
+  `apply/3` cannot be used to call private functions.
 
   Inlined by the compiler.
 
   ## Examples
 
       iex> apply(Enum, :reverse, [[1, 2, 3]])
-      [3,2,1]
+      [3, 2, 1]
 
   """
-  @spec apply(module, atom, [any]) :: any
-  def apply(module, fun, args) do
-    :erlang.apply(module, fun, args)
+  @spec apply(module, function_name :: atom, [any]) :: any
+  def apply(module, function_name, args) do
+    :erlang.apply(module, function_name, args)
   end
 
   @doc """
-  Extracts the part of the binary starting at `start` with length `length`.
-  Binaries are zero-indexed.
+  Extracts the part of the binary at `start` with `size`.
 
-  If start or length references in any way outside the binary, an
-  `ArgumentError` exception is raised.
+  If `start` or `size` reference in any way outside the binary,
+  an `ArgumentError` exception is raised.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -102,15 +393,22 @@ defmodule Kernel do
       iex> binary_part("foo", 1, 2)
       "oo"
 
-  A negative length can be used to extract bytes at the end of a binary:
+  A negative `size` can be used to extract bytes that come *before* the byte
+  at `start`:
+
+      iex> binary_part("Hello", 5, -3)
+      "llo"
 
-      iex> binary_part("foo", 3, -1)
-      "o"
+  An `ArgumentError` is raised when the `size` is outside of the binary:
+
+      binary_part("Hello", 0, 10)
+      ** (ArgumentError) argument error
 
   """
-  @spec binary_part(binary, pos_integer, integer) :: binary
-  def binary_part(binary, start, length) do
-    :erlang.binary_part(binary, start, length)
+  @doc guard: true
+  @spec binary_part(binary, non_neg_integer, integer) :: binary
+  def binary_part(binary, start, size) do
+    :erlang.binary_part(binary, start, size)
   end
 
   @doc """
@@ -127,6 +425,7 @@ defmodule Kernel do
       24
 
   """
+  @doc guard: true
   @spec bit_size(bitstring) :: non_neg_integer
   def bit_size(bitstring) do
     :erlang.bit_size(bitstring)
@@ -135,8 +434,8 @@ defmodule Kernel do
   @doc """
   Returns the number of bytes needed to contain `bitstring`.
 
-  That is, if the number of bits in `bitstring` is not divisible by 8,
-  the resulting number of bytes will be rounded up. This operation
+  That is, if the number of bits in `bitstring` is not divisible by 8, the
+  resulting number of bytes will be rounded up (by excess). This operation
   happens in constant time.
 
   Allowed in guard tests. Inlined by the compiler.
@@ -150,15 +449,49 @@ defmodule Kernel do
       3
 
   """
+  @doc guard: true
   @spec byte_size(bitstring) :: non_neg_integer
   def byte_size(bitstring) do
     :erlang.byte_size(bitstring)
   end
 
+  @doc """
+  Returns the smallest integer greater than or equal to `number`.
+
+  If you want to perform ceil operation on other decimal places,
+  use `Float.ceil/2` instead.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> ceil(10)
+      10
+
+      iex> ceil(10.1)
+      11
+
+      iex> ceil(-10.1)
+      -10
+
+  """
+  @doc since: "1.8.0", guard: true
+  @spec ceil(number) :: integer
+  def ceil(number) do
+    :erlang.ceil(number)
+  end
+
   @doc """
   Performs an integer division.
 
-  Raises an error if one of the arguments is not an integer.
+  Raises an `ArithmeticError` exception if one of the arguments is not an
+  integer, or when the `divisor` is `0`.
+
+  `div/2` performs *truncated* integer division. This means that
+  the result is always rounded towards zero.
+
+  If you want to perform floored integer division (rounding towards negative infinity),
+  use `Integer.floor_div/2` instead.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -167,10 +500,20 @@ defmodule Kernel do
       iex> div(5, 2)
       2
 
+      iex> div(6, -4)
+      -1
+
+      iex> div(-99, 2)
+      -49
+
+      div(100, 0)
+      ** (ArithmeticError) bad argument in arithmetic expression
+
   """
-  @spec div(integer, integer) :: integer
-  def div(left, right) do
-    :erlang.div(left, right)
+  @doc guard: true
+  @spec div(integer, neg_integer | pos_integer) :: integer
+  def div(dividend, divisor) do
+    :erlang.div(dividend, divisor)
   end
 
   @doc """
@@ -183,9 +526,56 @@ defmodule Kernel do
 
   ## Examples
 
+  When a process reaches its end, by default it exits with
+  reason `:normal`. You can also call `exit/1` explicitly if you
+  want to terminate a process but not signal any failure:
+
       exit(:normal)
+
+  In case something goes wrong, you can also use `exit/1` with
+  a different reason:
+
       exit(:seems_bad)
 
+  If the exit reason is not `:normal`, all the processes linked to the process
+  that exited will crash (unless they are trapping exits).
+
+  ## OTP exits
+
+  Exits are used by the OTP to determine if a process exited abnormally
+  or not. The following exits are considered "normal":
+
+    * `exit(:normal)`
+    * `exit(:shutdown)`
+    * `exit({:shutdown, term})`
+
+  Exiting with any other reason is considered abnormal and treated
+  as a crash. This means the default supervisor behavior kicks in,
+  error reports are emitted, and so forth.
+
+  This behavior is relied on in many different places. For example,
+  `ExUnit` uses `exit(:shutdown)` when exiting the test process to
+  signal linked processes, supervision trees and so on to politely
+  shut down too.
+
+  ## CLI exits
+
+  Building on top of the exit signals mentioned above, if the
+  process started by the command line exits with any of the three
+  reasons above, its exit is considered normal and the Operating
+  System process will exit with status 0.
+
+  It is, however, possible to customize the operating system exit
+  signal by invoking:
+
+      exit({:shutdown, integer})
+
+  This will cause the operating system process to exit with the status given by
+  `integer` while signaling all linked Erlang processes to politely
+  shut down.
+
+  Any other exit reason will cause the operating system process to exit with
+  status `1` and linked Erlang processes to crash.
   """
   @spec exit(term) :: no_return
   def exit(reason) do
@@ -193,73 +583,191 @@ defmodule Kernel do
   end
 
   @doc """
-  Returns the head of a list, raises `badarg` if the list is empty.
+  Returns the largest integer smaller than or equal to `number`.
+
+  If you want to perform floor operation on other decimal places,
+  use `Float.floor/2` instead.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> floor(10)
+      10
+
+      iex> floor(9.7)
+      9
+
+      iex> floor(-9.7)
+      -10
+
+  """
+  @doc since: "1.8.0", guard: true
+  @spec floor(number) :: integer
+  def floor(number) do
+    :erlang.floor(number)
+  end
+
+  @doc """
+  Returns the head of a list. Raises `ArgumentError` if the list is empty.
+
+  The head of a list is its first element.
+
+  It works with improper lists.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> hd([1, 2, 3, 4])
+      1
+
+      iex> hd([1 | 2])
+      1
+
+  Giving it an empty list raises:
+
+      hd([])
+      ** (ArgumentError) argument error
 
-  Inlined by the compiler.
   """
-  @spec hd(list) :: term
+  @doc guard: true
+  @spec hd(nonempty_maybe_improper_list(elem, term)) :: elem when elem: term
   def hd(list) do
     :erlang.hd(list)
   end
 
   @doc """
-  Returns `true` if `term` is an atom; otherwise returns `false`.
+  Returns `true` if `term` is an atom, otherwise returns `false`.
+
+  Note `true`, `false`, and `nil` are atoms in Elixir, as well as
+  module names. Therefore this function will return `true` to all
+  of those values.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_atom(:name)
+      true
+
+      iex> is_atom(false)
+      true
+
+      iex> is_atom(AnAtom)
+      true
+
+      iex> is_atom("string")
+      false
+
   """
+  @doc guard: true
   @spec is_atom(term) :: boolean
   def is_atom(term) do
     :erlang.is_atom(term)
   end
 
   @doc """
-  Returns `true` if `term` is a binary; otherwise returns `false`.
+  Returns `true` if `term` is a binary, otherwise returns `false`.
 
   A binary always contains a complete number of bytes.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_binary("foo")
+      true
+      iex> is_binary(<<1::3>>)
+      false
+
   """
+  @doc guard: true
   @spec is_binary(term) :: boolean
   def is_binary(term) do
     :erlang.is_binary(term)
   end
 
   @doc """
-  Returns `true` if `term` is a bitstring (including a binary); otherwise returns `false`.
+  Returns `true` if `term` is a bitstring (including a binary), otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_bitstring("foo")
+      true
+      iex> is_bitstring(<<1::3>>)
+      true
+
   """
+  @doc guard: true
   @spec is_bitstring(term) :: boolean
   def is_bitstring(term) do
     :erlang.is_bitstring(term)
   end
 
   @doc """
-  Returns `true` if `term` is either the atom `true` or the atom `false` (i.e. a boolean);
-  otherwise returns false.
+  Returns `true` if `term` is either the atom `true` or the atom `false` (i.e.,
+  a boolean), otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_boolean(false)
+      true
+
+      iex> is_boolean(true)
+      true
+
+      iex> is_boolean(:test)
+      false
+
   """
+  @doc guard: true
   @spec is_boolean(term) :: boolean
   def is_boolean(term) do
     :erlang.is_boolean(term)
   end
 
   @doc """
-  Returns `true` if `term` is a floating point number; otherwise returns `false`.
+  Returns `true` if `term` is a floating-point number, otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_float(2.15)
+      true
+
+      iex> is_float(3.45e5)
+      true
+
+      iex> is_float(5)
+      false
   """
+  @doc guard: true
   @spec is_float(term) :: boolean
   def is_float(term) do
     :erlang.is_float(term)
   end
 
   @doc """
-  Returns `true` if `term` is a function; otherwise returns `false`.
+  Returns `true` if `term` is a function, otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_function(fn x -> x + x end)
+      true
+
+      iex> is_function("not a function")
+      false
+
   """
+  @doc guard: true
   @spec is_function(term) :: boolean
   def is_function(term) do
     :erlang.is_function(term)
@@ -270,93 +778,218 @@ defmodule Kernel do
   otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_function(fn x -> x * 2 end, 1)
+      true
+      iex> is_function(fn x -> x * 2 end, 2)
+      false
+
   """
+  @doc guard: true
   @spec is_function(term, non_neg_integer) :: boolean
   def is_function(term, arity) do
     :erlang.is_function(term, arity)
   end
 
   @doc """
-  Returns `true` if `term` is an integer; otherwise returns `false`.
+  Returns `true` if `term` is an integer, otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_integer(5)
+      true
+
+      iex> is_integer(5.0)
+      false
   """
+  @doc guard: true
   @spec is_integer(term) :: boolean
   def is_integer(term) do
     :erlang.is_integer(term)
   end
 
   @doc """
-  Returns `true` if `term` is a list with zero or more elements; otherwise returns `false`.
+  Returns `true` if `term` is a list with zero or more elements, otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_list([1, 2, 3])
+      true
+
+      iex> is_list(key: :sum, value: 3)
+      true
+
+      iex> is_list({1, 2, 3})
+      false
   """
+  @doc guard: true
   @spec is_list(term) :: boolean
   def is_list(term) do
     :erlang.is_list(term)
   end
 
   @doc """
-  Returns `true` if `term` is either an integer or a floating point number;
+  Returns `true` if `term` is either an integer or a floating-point number;
   otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_number(2.15)
+      true
+
+      iex> is_number(5)
+      true
+
+      iex> is_number(:one)
+      false
   """
+  @doc guard: true
   @spec is_number(term) :: boolean
   def is_number(term) do
     :erlang.is_number(term)
   end
 
   @doc """
-  Returns `true` if `term` is a pid (process identifier); otherwise returns `false`.
+  Returns `true` if `term` is a PID (process identifier), otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> {:ok, agent_pid} = Agent.start_link(fn -> 0 end)
+      iex> is_pid(agent_pid)
+      true
+
+      iex> is_pid(self())
+      true
+
+      iex> is_pid(:pid)
+      false
   """
+  @doc guard: true
   @spec is_pid(term) :: boolean
   def is_pid(term) do
     :erlang.is_pid(term)
   end
 
   @doc """
-  Returns `true` if `term` is a port identifier; otherwise returns `false`.
+  Returns `true` if `term` is a port identifier, otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> [port | _] = Port.list()
+      iex> is_port(port)
+      true
+
+      iex> is_port(:port)
+      false
   """
+  @doc guard: true
   @spec is_port(term) :: boolean
   def is_port(term) do
     :erlang.is_port(term)
   end
 
   @doc """
-  Returns `true` if `term` is a reference; otherwise returns `false`.
+  Returns `true` if `term` is a reference, otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> ref = make_ref()
+      iex> is_reference(ref)
+      true
+
+      iex> is_reference(:ref)
+      false
   """
+  @doc guard: true
   @spec is_reference(term) :: boolean
   def is_reference(term) do
     :erlang.is_reference(term)
   end
 
   @doc """
-  Returns `true` if `term` is a tuple; otherwise returns `false`.
+  Returns `true` if `term` is a tuple, otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_tuple({1, 2, 3})
+      true
+
+      iex> is_tuple({})
+      true
+
+      iex> is_tuple(true)
+      false
   """
+  @doc guard: true
   @spec is_tuple(term) :: boolean
   def is_tuple(term) do
     :erlang.is_tuple(term)
   end
 
   @doc """
-  Returns `true` if `term` is a map; otherwise returns `false`.
+  Returns `true` if `term` is a map, otherwise returns `false`.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  > #### Structs are maps {: .info}
+  >
+  > Structs are also maps, and many of Elixir data structures are implemented
+  > using structs: `Range`s, `Regex`es, `Date`s...
+  >
+  >     iex> is_map(1..10)
+  >     true
+  >     iex> is_map(~D[2024-04-18])
+  >     true
+  >
+  > If you mean to specifically check for non-struct maps, use
+  > `is_non_struct_map/1` instead.
+  >
+  >     iex> is_non_struct_map(1..10)
+  >     false
   """
+  @doc guard: true
   @spec is_map(term) :: boolean
   def is_map(term) do
     :erlang.is_map(term)
   end
 
+  @doc """
+  Returns `true` if `key` is a key in `map`, otherwise returns `false`.
+
+  It raises `BadMapError` if the first element is not a map.
+
+  Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> is_map_key(%{a: "foo", b: "bar"}, :a)
+      true
+
+      iex> is_map_key(%{a: "foo", b: "bar"}, :c)
+      false
+  """
+  @doc guard: true, since: "1.10.0"
+  @spec is_map_key(map, term) :: boolean
+  def is_map_key(map, key) do
+    :erlang.is_map_key(key, map)
+  end
+
   @doc """
   Returns the length of `list`.
 
@@ -368,6 +1001,7 @@ defmodule Kernel do
       9
 
   """
+  @doc guard: true
   @spec length(list) :: non_neg_integer
   def length(list) do
     :erlang.length(list)
@@ -383,7 +1017,8 @@ defmodule Kernel do
 
   ## Examples
 
-      make_ref() #=> #Reference<0.0.0.135>
+      make_ref()
+      #=> #Reference<0.0.0.135>
 
   """
   @spec make_ref() :: reference
@@ -394,47 +1029,74 @@ defmodule Kernel do
   @doc """
   Returns the size of a map.
 
+  The size of a map is the number of key-value pairs that the map contains.
+
   This operation happens in constant time.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> map_size(%{a: "foo", b: "bar"})
+      2
+
   """
+  @doc guard: true
   @spec map_size(map) :: non_neg_integer
   def map_size(map) do
     :erlang.map_size(map)
   end
 
   @doc """
-  Return the biggest of the two given terms according to
-  Erlang's term ordering. If the terms compare equal, the
-  first one is returned.
+  Returns the biggest of the two given terms according to
+  their structural comparison.
 
-  Inlined by the compiler.
+  If the terms compare equal, the first one is returned.
+
+  This performs a structural comparison where all Elixir
+  terms can be compared with each other. See the ["Structural
+  comparison"](#module-structural-comparison) section
+  for more information.
+
+  Allowed in guard tests. Inlined by the compiler.
 
   ## Examples
 
       iex> max(1, 2)
       2
+      iex> max("a", "b")
+      "b"
 
   """
-  @spec max(term, term) :: term
+  @doc guard: true
+  @spec max(first, second) :: first | second when first: term, second: term
   def max(first, second) do
     :erlang.max(first, second)
   end
 
   @doc """
-  Return the smallest of the two given terms according to
-  Erlang's term ordering. If the terms compare equal, the
-  first one is returned.
+  Returns the smallest of the two given terms according to
+  their structural comparison.
 
-  Inlined by the compiler.
+  If the terms compare equal, the first one is returned.
+
+  This performs a structural comparison where all Elixir
+  terms can be compared with each other. See the ["Structural
+  comparison"](#module-structural-comparison) section
+  for more information.
+
+  Allowed in guard tests. Inlined by the compiler.
 
   ## Examples
 
       iex> min(1, 2)
       1
+      iex> min("foo", "bar")
+      "bar"
 
   """
-  @spec min(term, term) :: term
+  @doc guard: true
+  @spec min(first, second) :: first | second when first: term, second: term
   def min(first, second) do
     :erlang.min(first, second)
   end
@@ -445,27 +1107,33 @@ defmodule Kernel do
 
   Allowed in guard tests. Inlined by the compiler.
   """
+  @doc guard: true
   @spec node() :: node
   def node do
-    :erlang.node
+    :erlang.node()
   end
 
   @doc """
   Returns the node where the given argument is located.
-  The argument can be a pid, a reference, or a port.
-  If the local node is not alive, `nonode@nohost` is returned.
+  The argument can be a PID, a reference, or a port.
+  If the local node is not alive, `:nonode@nohost` is returned.
 
   Allowed in guard tests. Inlined by the compiler.
   """
-  @spec node(pid|reference|port) :: node
+  @doc guard: true
+  @spec node(pid | reference | port) :: node
   def node(arg) do
     :erlang.node(arg)
   end
 
   @doc """
-  Calculates the remainder of an integer division.
+  Computes the remainder of an integer division.
 
-  Raises an error if one of the arguments is not an integer.
+  `rem/2` uses truncated division, which means that
+  the result will always have the sign of the `dividend`.
+
+  Raises an `ArithmeticError` exception if one of the arguments is not an
+  integer, or when the `divisor` is `0`.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -473,24 +1141,45 @@ defmodule Kernel do
 
       iex> rem(5, 2)
       1
+      iex> rem(6, -4)
+      2
 
   """
-  @spec rem(integer, integer) :: integer
-  def rem(left, right) do
-    :erlang.rem(left, right)
+  @doc guard: true
+  @spec rem(integer, neg_integer | pos_integer) :: integer
+  def rem(dividend, divisor) do
+    :erlang.rem(dividend, divisor)
   end
 
   @doc """
-  Returns an integer by rounding the given number.
+  Rounds a number to the nearest integer.
+
+  If the number is equidistant to the two nearest integers, rounds away from zero.
 
   Allowed in guard tests. Inlined by the compiler.
 
   ## Examples
 
-      iex> round(5.5)
+      iex> round(5.6)
       6
 
+      iex> round(5.2)
+      5
+
+      iex> round(-9.9)
+      -10
+
+      iex> round(-9)
+      -9
+
+      iex> round(2.5)
+      3
+
+      iex> round(-2.5)
+      -3
+
   """
+  @doc guard: true
   @spec round(number) :: integer
   def round(number) do
     :erlang.round(number)
@@ -499,62 +1188,76 @@ defmodule Kernel do
   @doc """
   Sends a message to the given `dest` and returns the message.
 
-  `dest` may be a remote or local pid, a (local) port, a locally
-  registered name, or a tuple `{registered_name, node}` for a registered
-  name at another node.
+  `dest` may be a remote or local PID, a local port, a locally
+  registered name, or a tuple in the form of `{registered_name, node}` for a
+  registered name at another node.
+
+  For additional documentation, see the [`!` operator Erlang
+  documentation](https://www.erlang.org/doc/reference_manual/expressions#send).
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> send self(), :hello
+      iex> send(self(), :hello)
       :hello
 
   """
-  @spec send(dest :: pid | port | atom | {atom, node}, msg) :: msg when msg: any
-  def send(dest, msg) do
-    :erlang.send(dest, msg)
+  @spec send(dest :: Process.dest(), message) :: message when message: any
+  def send(dest, message) do
+    :erlang.send(dest, message)
   end
 
   @doc """
-  Returns the pid (process identifier) of the calling process.
+  Returns the PID (process identifier) of the calling process.
 
   Allowed in guard clauses. Inlined by the compiler.
   """
+  @doc guard: true
   @spec self() :: pid
   def self() do
     :erlang.self()
   end
 
   @doc """
-  Spawns the given function and returns its pid.
+  Spawns the given function and returns its PID.
+
+  Typically developers do not use the `spawn` functions, instead they use
+  abstractions such as `Task`, `GenServer` and `Agent`, built on top of
+  `spawn`, that spawns processes with more conveniences in terms of
+  introspection and debugging.
 
-  Check the modules `Process` and `Node` for other functions
-  to handle processes, including spawning functions in nodes.
+  Check the `Process` module for more process-related functions.
+
+  The anonymous function receives 0 arguments, and may return any value.
 
   Inlined by the compiler.
 
   ## Examples
 
-      current = Kernel.self
-      child   = spawn(fn -> send current, {Kernel.self, 1 + 2} end)
-
-      receive do
-        {^child, 3} -> IO.puts "Received 3 back"
-      end
+      iex> current = self()
+      iex> child = spawn(fn -> send(current, {self(), 1 + 2}) end)
+      iex> receive do
+      ...>   {^child, 3} -> :ok
+      ...> end
+      :ok
 
   """
-  @spec spawn((() -> any)) :: pid
+  @spec spawn((-> any)) :: pid
   def spawn(fun) do
     :erlang.spawn(fun)
   end
 
   @doc """
-  Spawns the given module and function passing the given args
-  and returns its pid.
+  Spawns the given function `fun` from the given `module` passing it the given
+  `args` and returns its PID.
 
-  Check the modules `Process` and `Node` for other functions
-  to handle processes, including spawning functions in nodes.
+  Typically developers do not use the `spawn` functions, instead they use
+  abstractions such as `Task`, `GenServer` and `Agent`, built on top of
+  `spawn`, that spawns processes with more conveniences in terms of
+  introspection and debugging.
+
+  Check the `Process` module for more process-related functions.
 
   Inlined by the compiler.
 
@@ -569,34 +1272,46 @@ defmodule Kernel do
   end
 
   @doc """
-  Spawns the given function, links it to the current process and returns its pid.
+  Spawns the given function, links it to the current process, and returns its PID.
+
+  Typically developers do not use the `spawn` functions, instead they use
+  abstractions such as `Task`, `GenServer` and `Agent`, built on top of
+  `spawn`, that spawns processes with more conveniences in terms of
+  introspection and debugging.
 
-  Check the modules `Process` and `Node` for other functions
-  to handle processes, including spawning functions in nodes.
+  Check the `Process` module for more process-related functions. For more
+  information on linking, check `Process.link/1`.
+
+  The anonymous function receives 0 arguments, and may return any value.
 
   Inlined by the compiler.
 
   ## Examples
 
-      current = Kernel.self
-      child   = spawn_link(fn -> send current, {Kernel.self, 1 + 2} end)
-
-      receive do
-        {^child, 3} -> IO.puts "Received 3 back"
-      end
+      iex> current = self()
+      iex> child = spawn_link(fn -> send(current, {self(), 1 + 2}) end)
+      iex> receive do
+      ...>   {^child, 3} -> :ok
+      ...> end
+      :ok
 
   """
-  @spec spawn_link((() -> any)) :: pid
+  @spec spawn_link((-> any)) :: pid
   def spawn_link(fun) do
     :erlang.spawn_link(fun)
   end
 
   @doc """
-  Spawns the given module and function passing the given args,
-  links it to the current process and returns its pid.
+  Spawns the given function `fun` from the given `module` passing it the given
+  `args`, links it to the current process, and returns its PID.
+
+  Typically developers do not use the `spawn` functions, instead they use
+  abstractions such as `Task`, `GenServer` and `Agent`, built on top of
+  `spawn`, that spawns processes with more conveniences in terms of
+  introspection and debugging.
 
-  Check the modules `Process` and `Node` for other functions
-  to handle processes, including spawning functions in nodes.
+  Check the `Process` module for more process-related functions. For more
+  information on linking, check `Process.link/1`.
 
   Inlined by the compiler.
 
@@ -611,31 +1326,45 @@ defmodule Kernel do
   end
 
   @doc """
-  Spawns the given function, monitors it and returns its pid
+  Spawns the given function, monitors it and returns its PID
   and monitoring reference.
 
-  Check the modules `Process` and `Node` for other functions
-  to handle processes, including spawning functions in nodes.
+  Typically developers do not use the `spawn` functions, instead they use
+  abstractions such as `Task`, `GenServer` and `Agent`, built on top of
+  `spawn`, that spawns processes with more conveniences in terms of
+  introspection and debugging.
+
+  Check the `Process` module for more process-related functions.
+
+  The anonymous function receives 0 arguments, and may return any value.
 
   Inlined by the compiler.
 
   ## Examples
 
-      current = Kernel.self
-      spawn_monitor(fn -> send current, {Kernel.self, 1 + 2} end)
+      iex> current = self()
+      iex> {child, _ref} = spawn_monitor(fn -> send(current, {self(), 1 + 2}) end)
+      iex> receive do
+      ...>   {^child, 3} -> :ok
+      ...> end
+      :ok
 
   """
-  @spec spawn_monitor((() -> any)) :: {pid, reference}
+  @spec spawn_monitor((-> any)) :: {pid, reference}
   def spawn_monitor(fun) do
     :erlang.spawn_monitor(fun)
   end
 
   @doc """
   Spawns the given module and function passing the given args,
-  monitors it and returns its pid and monitoring reference.
+  monitors it and returns its PID and monitoring reference.
+
+  Typically developers do not use the `spawn` functions, instead they use
+  abstractions such as `Task`, `GenServer` and `Agent`, built on top of
+  `spawn`, that spawns processes with more conveniences in terms of
+  introspection and debugging.
 
-  Check the modules `Process` and `Node` for other functions
-  to handle processes, including spawning functions in nodes.
+  Check the `Process` module for more process-related functions.
 
   Inlined by the compiler.
 
@@ -650,7 +1379,41 @@ defmodule Kernel do
   end
 
   @doc """
-  A non-local return from a function. Check `Kernel.SpecialForms.try/1` for more information.
+  Pipes the first argument, `value`, into the second argument, a function `fun`,
+  and returns `value` itself.
+
+  Useful for running synchronous side effects in a pipeline, using the `|>/2` operator.
+
+  ## Examples
+
+      iex> tap(1, fn x -> x + 1 end)
+      1
+
+  Most commonly, this is used in pipelines, using the `|>/2` operator.
+  For example, let's suppose you want to inspect part of a data structure.
+  You could write:
+
+      %{a: 1}
+      |> Map.update!(:a, & &1 + 2)
+      |> tap(&IO.inspect(&1.a))
+      |> Map.update!(:a, & &1 * 2)
+
+  """
+  @doc since: "1.12.0"
+  defmacro tap(value, fun) do
+    quote bind_quoted: [fun: fun, value: value] do
+      _ = fun.(value)
+      value
+    end
+  end
+
+  @doc """
+  A non-local return from a function.
+
+  Using `throw/1` is generally discouraged, as it allows a function
+  to escape from its regular execution flow, which can make the code
+  harder to read. Furthermore, all thrown values must be caught by
+  `try/catch`. See `try/1` for more information.
 
   Inlined by the compiler.
   """
@@ -662,24 +1425,57 @@ defmodule Kernel do
   @doc """
   Returns the tail of a list. Raises `ArgumentError` if the list is empty.
 
+  The tail of a list is the list without its first element.
+
+  It works with improper lists.
+
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> tl([1, 2, 3, :go])
+      [2, 3, :go]
+
+      iex> tl([:one])
+      []
+
+      iex> tl([:a, :b | :improper_end])
+      [:b | :improper_end]
+
+      iex> tl([:a | %{b: 1}])
+      %{b: 1}
+
+  Giving it an empty list raises:
+
+      tl([])
+      ** (ArgumentError) argument error
+
   """
-  @spec tl(maybe_improper_list) :: maybe_improper_list
+  @doc guard: true
+  @spec tl(nonempty_maybe_improper_list(elem, last)) :: maybe_improper_list(elem, last) | last
+        when elem: term, last: term
   def tl(list) do
     :erlang.tl(list)
   end
 
   @doc """
-  Returns an integer by truncating the given number.
+  Returns the integer part of `number`.
 
   Allowed in guard tests. Inlined by the compiler.
 
   ## Examples
 
-      iex> trunc(5.5)
+      iex> trunc(5.4)
       5
 
+      iex> trunc(-5.99)
+      -5
+
+      iex> trunc(-5)
+      -5
+
   """
+  @doc guard: true
   @spec trunc(number) :: integer
   def trunc(number) do
     :erlang.trunc(number)
@@ -691,14 +1487,21 @@ defmodule Kernel do
   This operation happens in constant time.
 
   Allowed in guard tests. Inlined by the compiler.
+
+  ## Examples
+
+      iex> tuple_size({:a, :b, :c})
+      3
+
   """
+  @doc guard: true
   @spec tuple_size(tuple) :: non_neg_integer
   def tuple_size(tuple) do
     :erlang.tuple_size(tuple)
   end
 
   @doc """
-  Arithmetic plus.
+  Arithmetic addition operator.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -708,13 +1511,17 @@ defmodule Kernel do
       3
 
   """
-  @spec (number + number) :: number
+  @doc guard: true
+  @spec integer + integer :: integer
+  @spec float + float :: float
+  @spec integer + float :: float
+  @spec float + integer :: float
   def left + right do
     :erlang.+(left, right)
   end
 
   @doc """
-  Arithmetic minus.
+  Arithmetic subtraction operator.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -724,13 +1531,17 @@ defmodule Kernel do
       -1
 
   """
-  @spec (number - number) :: number
+  @doc guard: true
+  @spec integer - integer :: integer
+  @spec float - float :: float
+  @spec integer - float :: float
+  @spec float - integer :: float
   def left - right do
     :erlang.-(left, right)
   end
 
   @doc """
-  Arithmetic unary plus.
+  Arithmetic positive unary operator.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -740,13 +1551,15 @@ defmodule Kernel do
       1
 
   """
-  @spec (+number) :: number
-  def (+value) do
+  @doc guard: true
+  @spec +integer :: integer
+  @spec +float :: float
+  def +value do
     :erlang.+(value)
   end
 
   @doc """
-  Arithmetic unary minus.
+  Arithmetic negative unary operator.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -756,13 +1569,17 @@ defmodule Kernel do
       -2
 
   """
-  @spec (-number) :: number
-  def (-value) do
+  @doc guard: true
+  @spec -0 :: 0
+  @spec -pos_integer :: neg_integer
+  @spec -neg_integer :: pos_integer
+  @spec -float :: float
+  def -value do
     :erlang.-(value)
   end
 
   @doc """
-  Arithmetic multiplication.
+  Arithmetic multiplication operator.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -772,16 +1589,22 @@ defmodule Kernel do
       2
 
   """
-  @spec (number * number) :: number
+  @doc guard: true
+  @spec integer * integer :: integer
+  @spec float * float :: float
+  @spec integer * float :: float
+  @spec float * integer :: float
   def left * right do
     :erlang.*(left, right)
   end
 
   @doc """
-  Arithmetic division.
+  Arithmetic division operator.
+
+  The result is always a float. Use `div/2` and `rem/2` if you want
+  an integer division or the remainder.
 
-  The result is always a float. Use `div` and `rem` if you want
-  a natural division or the remainder.
+  Raises `ArithmeticError` if `right` is 0 or 0.0.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -790,39 +1613,84 @@ defmodule Kernel do
       iex> 1 / 2
       0.5
 
-      iex> 2 / 1
-      2.0
+      iex> -3.0 / 2.0
+      -1.5
+
+      iex> 5 / 1
+      5.0
+
+      7 / 0
+      ** (ArithmeticError) bad argument in arithmetic expression
 
   """
-  @spec (number / number) :: float
+  @doc guard: true
+  @spec number / number :: float
   def left / right do
     :erlang./(left, right)
   end
 
   @doc """
-  Concatenates two lists.
+  List concatenation operator. Concatenates a proper list and a term, returning a list.
 
-  Allowed in guard tests. Inlined by the compiler.
+  The complexity of `a ++ b` is proportional to `length(a)`, so avoid repeatedly
+  appending to lists of arbitrary length, for example, `list ++ [element]`.
+  Instead, consider prepending via `[element | rest]` and then reversing.
+
+  If the `right` operand is not a proper list, it returns an improper list.
+  If the `left` operand is not a proper list, it raises `ArgumentError`.
+  If the `left` operand is an empty list, it returns the `right` operand.
+
+  Inlined by the compiler.
 
   ## Examples
 
       iex> [1] ++ [2, 3]
-      [1,2,3]
+      [1, 2, 3]
+
+      iex> ~c"foo" ++ ~c"bar"
+      ~c"foobar"
+
+      # a non-list on the right will return an improper list
+      # with said element at the end
+      iex> [1, 2] ++ 3
+      [1, 2 | 3]
+      iex> [1, 2] ++ {3, 4}
+      [1, 2 | {3, 4}]
+
+      # improper list on the right will return an improper list
+      iex> [1] ++ [2 | 3]
+      [1, 2 | 3]
+
+      # empty list on the left will return the right operand
+      iex> [] ++ 1
+      1
+
+  The `++/2` operator is right associative, meaning:
+
+      iex> [1, 2, 3] -- [1] ++ [2]
+      [3]
+
+  As it is equivalent to:
 
-      iex> 'foo' ++ 'bar'
-      'foobar'
+      iex> [1, 2, 3] -- ([1] ++ [2])
+      [3]
 
   """
-  @spec (list ++ term) :: maybe_improper_list
+  @spec [] ++ a :: a when a: term()
+  @spec nonempty_list() ++ term() :: maybe_improper_list()
   def left ++ right do
     :erlang.++(left, right)
   end
 
   @doc """
-  Removes the first occurrence of an item on the left
-  for each item on the right.
+  List subtraction operator. Removes the first occurrence of an element
+  on the left list for each element on the right.
 
-  Allowed in guard tests. Inlined by the compiler.
+  This function is optimized so the complexity of `a -- b` is proportional
+  to `length(a) * log(length(b))`. See also the [Erlang efficiency
+  guide](https://www.erlang.org/doc/system/efficiency_guide.html).
+
+  Inlined by the compiler.
 
   ## Examples
 
@@ -830,21 +1698,28 @@ defmodule Kernel do
       [3]
 
       iex> [1, 2, 3, 2, 1] -- [1, 2, 2]
-      [3,1]
+      [3, 1]
+
+  The `--/2` operator is right associative, meaning:
+
+      iex> [1, 2, 3] -- [2] -- [3]
+      [1, 3]
+
+  As it is equivalent to:
+
+      iex> [1, 2, 3] -- ([2] -- [3])
+      [1, 3]
 
   """
-  @spec (list -- list) :: list
+  @spec list -- list :: list
   def left -- right do
     :erlang.--(left, right)
   end
 
-  @doc false
-  def left xor right do
-    :erlang.xor(left, right)
-  end
-
   @doc """
-  Boolean not. Argument must be a boolean.
+  Strictly boolean "not" operator.
+
+  `value` must be a boolean; if it's not, an `ArgumentError` exception is raised.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -854,15 +1729,22 @@ defmodule Kernel do
       true
 
   """
-  @spec not(boolean) :: boolean
-  def not(arg) do
-    :erlang.not(arg)
+  @doc guard: true
+  @spec not true :: false
+  @spec not false :: true
+  def not value do
+    :erlang.not(value)
   end
 
   @doc """
-  Returns `true` if left is less than right.
+  Less-than operator.
 
-  All terms in Elixir can be compared with each other.
+  Returns `true` if `left` is less than `right`.
+
+  This performs a structural comparison where all Elixir
+  terms can be compared with each other. See the ["Structural
+  comparison"](#module-structural-comparison) section
+  for more information.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -872,15 +1754,21 @@ defmodule Kernel do
       true
 
   """
-  @spec (term < term) :: boolean
+  @doc guard: true
+  @spec term < term :: boolean
   def left < right do
     :erlang.<(left, right)
   end
 
   @doc """
-  Returns `true` if left is more than right.
+  Greater-than operator.
+
+  Returns `true` if `left` is more than `right`.
 
-  All terms in Elixir can be compared with each other.
+  This performs a structural comparison where all Elixir
+  terms can be compared with each other. See the ["Structural
+  comparison"](#module-structural-comparison) section
+  for more information.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -890,15 +1778,21 @@ defmodule Kernel do
       false
 
   """
-  @spec (term > term) :: boolean
+  @doc guard: true
+  @spec term > term :: boolean
   def left > right do
     :erlang.>(left, right)
   end
 
   @doc """
-  Returns `true` if left is less than or equal to right.
+  Less-than or equal to operator.
 
-  All terms in Elixir can be compared with each other.
+  Returns `true` if `left` is less than or equal to `right`.
+
+  This performs a structural comparison where all Elixir
+  terms can be compared with each other. See the ["Structural
+  comparison"](#module-structural-comparison) section
+  for more information.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -908,15 +1802,21 @@ defmodule Kernel do
       true
 
   """
-  @spec (term <= term) :: boolean
+  @doc guard: true
+  @spec term <= term :: boolean
   def left <= right do
     :erlang."=<"(left, right)
   end
 
   @doc """
-  Returns `true` if left is more than or equal to right.
+  Greater-than or equal to operator.
+
+  Returns `true` if `left` is more than or equal to `right`.
 
-  All terms in Elixir can be compared with each other.
+  This performs a structural comparison where all Elixir
+  terms can be compared with each other. See the ["Structural
+  comparison"](#module-structural-comparison) section
+  for more information.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -926,18 +1826,22 @@ defmodule Kernel do
       false
 
   """
-  @spec (term >= term) :: boolean
+  @doc guard: true
+  @spec term >= term :: boolean
   def left >= right do
     :erlang.>=(left, right)
   end
 
   @doc """
-  Returns `true` if the two items are equal.
+  Equal to operator. Returns `true` if the two terms are equal.
 
-  This operator considers 1 and 1.0 to be equal. For match
-  semantics, use `===` instead.
+  This operator considers 1 and 1.0 to be equal. For stricter
+  semantics, use `===/2` instead.
 
-  All terms in Elixir can be compared with each other.
+  This performs a structural comparison where all Elixir
+  terms can be compared with each other. See the ["Structural
+  comparison"](#module-structural-comparison) section
+  for more information.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -950,18 +1854,24 @@ defmodule Kernel do
       true
 
   """
-  @spec (term == term) :: boolean
+  @doc guard: true
+  @spec term == term :: boolean
   def left == right do
     :erlang.==(left, right)
   end
 
   @doc """
-  Returns `true` if the two items are not equal.
+  Not equal to operator.
+
+  Returns `true` if the two terms are not equal.
 
   This operator considers 1 and 1.0 to be equal. For match
-  comparison, use `!==` instead.
+  comparison, use `!==/2` instead.
 
-  All terms in Elixir can be compared with each other.
+  This performs a structural comparison where all Elixir
+  terms can be compared with each other. See the ["Structural
+  comparison"](#module-structural-comparison) section
+  for more information.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -974,19 +1884,26 @@ defmodule Kernel do
       false
 
   """
-  @spec (term != term) :: boolean
+  @doc guard: true
+  @spec term != term :: boolean
   def left != right do
     :erlang."/="(left, right)
   end
 
   @doc """
-  Returns `true` if the two items are match.
+  Strictly equal to operator.
 
-  This operator gives the same semantics as the one existing in
-  pattern matching, i.e., `1` and `1.0` are equal, but they do
-  not match.
+  Returns `true` if the two terms are exactly equal.
 
-  All terms in Elixir can be compared with each other.
+  The terms are only considered to be exactly equal if they
+  have the same value and are of the same type. For example,
+  `1 == 1.0` returns `true`, but since they are of different
+  types, `1 === 1.0` returns `false`.
+
+  This performs a structural comparison where all Elixir
+  terms can be compared with each other. See the ["Structural
+  comparison"](#module-structural-comparison) section
+  for more information.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -999,15 +1916,22 @@ defmodule Kernel do
       false
 
   """
-  @spec (term === term) :: boolean
+  @doc guard: true
+  @spec term === term :: boolean
   def left === right do
     :erlang."=:="(left, right)
   end
 
   @doc """
-  Returns `true` if the two items do not match.
+  Strictly not equal to operator.
+
+  Returns `true` if the two terms are not exactly equal.
+  See `===/2` for a definition of what is considered "exactly equal".
 
-  All terms in Elixir can be compared with each other.
+  This performs a structural comparison where all Elixir
+  terms can be compared with each other. See the ["Structural
+  comparison"](#module-structural-comparison) section
+  for more information.
 
   Allowed in guard tests. Inlined by the compiler.
 
@@ -1020,34 +1944,44 @@ defmodule Kernel do
       true
 
   """
-  @spec (term !== term) :: boolean
+  @doc guard: true
+  @spec term !== term :: boolean
   def left !== right do
     :erlang."=/="(left, right)
   end
 
   @doc """
-  Get the element at the zero-based `index` in `tuple`.
+  Gets the element at the zero-based `index` in `tuple`.
+
+  It raises `ArgumentError` when index is negative or it is out of range of the tuple elements.
 
   Allowed in guard tests. Inlined by the compiler.
 
-  ## Example
+  ## Examples
 
       iex> tuple = {:foo, :bar, 3}
       iex> elem(tuple, 1)
       :bar
 
+      elem({}, 0)
+      ** (ArgumentError) argument error
+
+      elem({:foo, :bar}, 2)
+      ** (ArgumentError) argument error
+
   """
+  @doc guard: true
   @spec elem(tuple, non_neg_integer) :: term
   def elem(tuple, index) do
     :erlang.element(index + 1, tuple)
   end
 
   @doc """
-  Puts the element in `tuple` at the zero-based `index` to the given `value`.
+  Puts `value` at the given zero-based `index` in `tuple`.
 
   Inlined by the compiler.
 
-  ## Example
+  ## Examples
 
       iex> tuple = {:foo, :bar, 3}
       iex> put_elem(tuple, 0, :baz)
@@ -1061,9 +1995,18 @@ defmodule Kernel do
 
   ## Implemented in Elixir
 
+  defp annotate_case(extra, {:case, meta, args}) do
+    {:case, extra ++ meta, args}
+  end
+
   @doc """
-  Boolean or. Requires only the first argument to be a
-  boolean since it short-circuits.
+  Strictly boolean "or" operator.
+
+  If `left` is `true`, returns `true`, otherwise returns `right`.
+
+  Requires only the `left` operand to be a boolean since it short-circuits.
+  If the `left` operand is not a boolean, a `BadBooleanError` exception is
+  raised.
 
   Allowed in guard tests.
 
@@ -1072,14 +2015,29 @@ defmodule Kernel do
       iex> true or false
       true
 
+      iex> false or 42
+      42
+
+      iex> 42 or false
+      ** (BadBooleanError) expected a boolean on left-side of "or", got: 42
+
   """
+  @doc guard: true
   defmacro left or right do
-    quote do: __op__(:orelse, unquote(left), unquote(right))
+    case __CALLER__.context do
+      nil -> build_boolean_check(:or, left, true, right)
+      :match -> invalid_match!(:or)
+      :guard -> quote(do: :erlang.orelse(unquote(left), unquote(right)))
+    end
   end
 
   @doc """
-  Boolean and. Requires only the first argument to be a
-  boolean since it short-circuits.
+  Strictly boolean "and" operator.
+
+  If `left` is `false`, returns `false`, otherwise returns `right`.
+
+  Requires only the `left` operand to be a boolean since it short-circuits. If
+  the `left` operand is not a boolean, a `BadBooleanError` exception is raised.
 
   Allowed in guard tests.
 
@@ -1088,15 +2046,42 @@ defmodule Kernel do
       iex> true and false
       false
 
+      iex> true and "yay!"
+      "yay!"
+
+      iex> "yay!" and true
+      ** (BadBooleanError) expected a boolean on left-side of "and", got: "yay!"
+
   """
+  @doc guard: true
   defmacro left and right do
-    quote do: __op__(:andalso, unquote(left), unquote(right))
+    case __CALLER__.context do
+      nil -> build_boolean_check(:and, left, right, false)
+      :match -> invalid_match!(:and)
+      :guard -> quote(do: :erlang.andalso(unquote(left), unquote(right)))
+    end
+  end
+
+  defp build_boolean_check(operator, check, true_clause, false_clause) do
+    annotate_case(
+      [optimize_boolean: true, type_check: :expr],
+      quote do
+        case unquote(check) do
+          false -> unquote(false_clause)
+          true -> unquote(true_clause)
+          other -> :erlang.error({:badbool, unquote(operator), other})
+        end
+      end
+    )
   end
 
   @doc """
-  Receives any argument and returns `true` if it is `false`
-  or `nil`. Returns `false` otherwise. Not allowed in guard
-  clauses.
+  Boolean "not" operator.
+
+  Receives any value (not just booleans) and returns `true` if `value`
+  is `false` or `nil`; returns `false` otherwise.
+
+  Not allowed in guard clauses.
 
   ## Examples
 
@@ -1107,142 +2092,197 @@ defmodule Kernel do
       true
 
   """
-  defmacro !(arg)
+  defmacro !value
+
+  defmacro !{:!, _, [value]} do
+    assert_no_match_or_guard_scope(__CALLER__.context, "!")
 
-  defmacro !({:!, _, [arg]}) do
-    optimize_boolean(quote do
-      case unquote(arg) do
-        x when x in [false, nil] -> false
-        _ -> true
+    annotate_case(
+      [optimize_boolean: true, type_check: :expr],
+      quote do
+        case unquote(value) do
+          x when :"Elixir.Kernel".in(x, [false, nil]) -> false
+          _ -> true
+        end
       end
-    end)
+    )
   end
 
-  defmacro !(arg) do
-    optimize_boolean(quote do
-      case unquote(arg) do
-        x when x in [false, nil] -> true
-        _ -> false
+  defmacro !value do
+    assert_no_match_or_guard_scope(__CALLER__.context, "!")
+
+    annotate_case(
+      [optimize_boolean: true, type_check: :expr],
+      quote do
+        case unquote(value) do
+          x when :"Elixir.Kernel".in(x, [false, nil]) -> true
+          _ -> false
+        end
       end
-    end)
+    )
   end
 
   @doc """
-  Concatenates two binaries.
+  Binary concatenation operator. Concatenates two binaries.
+
+  Raises an `ArgumentError` if one of the sides aren't binaries.
 
   ## Examples
 
       iex> "foo" <> "bar"
       "foobar"
 
-  The `<>` operator can also be used in guard clauses as
-  long as the first part is a literal binary:
+  The `<>/2` operator can also be used in pattern matching (and guard clauses) as
+  long as the left argument is a literal binary:
 
       iex> "foo" <> x = "foobar"
       iex> x
       "bar"
 
+  `x <> "bar" = "foobar"` would result in an `ArgumentError` exception.
+
   """
   defmacro left <> right do
-    concats = extract_concatenations({:<>, [], [left, right]})
-    quote do: << unquote_splicing(concats) >>
+    concats = extract_concatenations({:<>, [], [left, right]}, __CALLER__)
+    quote(do: <<unquote_splicing(concats)>>)
   end
 
   # Extracts concatenations in order to optimize many
   # concatenations into one single clause.
-  defp extract_concatenations({:<>, _, [left, right]}) do
-    [wrap_concatenation(left)|extract_concatenations(right)]
+  defp extract_concatenations({:<>, _, [left, right]}, caller) do
+    [wrap_concatenation(left, :left, caller) | extract_concatenations(right, caller)]
   end
 
-  defp extract_concatenations(other) do
-    [wrap_concatenation(other)]
+  defp extract_concatenations(other, caller) do
+    [wrap_concatenation(other, :right, caller)]
   end
 
-  defp wrap_concatenation(binary) when is_binary(binary) do
+  defp wrap_concatenation(binary, _side, _caller) when is_binary(binary) do
     binary
   end
 
-  defp wrap_concatenation(other) do
-    {:::, [], [other, {:binary, [], nil}]}
+  defp wrap_concatenation(literal, _side, _caller)
+       when is_list(literal) or is_atom(literal) or is_integer(literal) or is_float(literal) do
+    :erlang.error(
+      ArgumentError.exception(
+        "expected binary argument in <> operator but got: #{Macro.to_string(literal)}"
+      )
+    )
+  end
+
+  defp wrap_concatenation(other, side, caller) do
+    expanded = expand_concat_argument(other, side, caller)
+    {:"::", [], [expanded, {:binary, [], nil}]}
+  end
+
+  defp expand_concat_argument(arg, :left, %{context: :match} = caller) do
+    expanded_arg =
+      case bootstrapped?(Macro) do
+        true -> Macro.expand(arg, caller)
+        false -> arg
+      end
+
+    case expanded_arg do
+      {var, _, nil} when is_atom(var) ->
+        invalid_concat_left_argument_error(Atom.to_string(var))
+
+      _ ->
+        expanded_arg
+    end
+  end
+
+  defp expand_concat_argument(arg, _, _) do
+    arg
+  end
+
+  defp invalid_concat_left_argument_error(arg) do
+    :erlang.error(
+      ArgumentError.exception(
+        "cannot perform prefix match because the left operand of <> has unknown size. " <>
+          "The left operand of <> inside a match should either be a literal binary or " <>
+          "an existing variable with the pin operator (such as ^some_var). Got: #{arg}"
+      )
+    )
   end
 
   @doc """
   Raises an exception.
 
-  If the argument is a binary, it raises `RuntimeError`
-  using the given argument as message.
+  If `message` is a string, it raises a `RuntimeError` exception with it.
+
+  If `message` is an atom, it just calls `raise/2` with the atom as the first
+  argument and `[]` as the second one.
 
-  If an atom, it will become a call to `raise(atom, [])`.
+  If `message` is an exception struct, it is raised as is.
 
-  If anything else, it will just raise the given exception.
+  If `message` is anything else, `raise` will fail with an `ArgumentError`
+  exception.
 
   ## Examples
 
-      raise "Given values do not match"
+      iex> raise "oops"
+      ** (RuntimeError) oops
 
       try do
         1 + :foo
       rescue
         x in [ArithmeticError] ->
-          IO.puts "that was expected"
+          IO.puts("that was expected")
           raise x
       end
 
   """
-  defmacro raise(msg) do
+  defmacro raise(message) do
     # Try to figure out the type at compilation time
-    # to avoid dead code and make dialyzer happy.
-    msg = case not is_binary(msg) and bootstraped?(Macro) do
-      true  -> Macro.expand(msg, __CALLER__)
-      false -> msg
-    end
+    # to avoid dead code and make Dialyzer happy.
+    message =
+      case not is_binary(message) and bootstrapped?(Macro) do
+        true -> Macro.expand(message, __CALLER__)
+        false -> message
+      end
 
-    case msg do
-      msg when is_binary(msg) ->
-        quote do
-          :erlang.error RuntimeError.exception(unquote(msg))
-        end
-      {:<<>>, _, _} = msg ->
+    erlang_error =
+      fn x ->
         quote do
-          :erlang.error RuntimeError.exception(unquote(msg))
+          :erlang.error(unquote(x), :none, error_info: %{module: Exception})
         end
+      end
+
+    case message do
+      message when is_binary(message) ->
+        erlang_error.(quote do: RuntimeError.exception(unquote(message)))
+
+      {:<<>>, _, _} = message ->
+        erlang_error.(quote do: RuntimeError.exception(unquote(message)))
+
       alias when is_atom(alias) ->
-        quote do
-          :erlang.error unquote(alias).exception([])
-        end
+        erlang_error.(quote do: unquote(alias).exception([]))
+
       _ ->
-        quote do
-          case unquote(msg) do
-            msg when is_binary(msg) ->
-              :erlang.error RuntimeError.exception(msg)
-            atom when is_atom(atom) ->
-              :erlang.error atom.exception([])
-            %{__struct__: struct, __exception__: true} = other when is_atom(struct) ->
-              :erlang.error other
-          end
-        end
+        erlang_error.(quote do: Kernel.Utils.raise(unquote(message)))
     end
   end
 
   @doc """
   Raises an exception.
 
-  Calls `.exception` on the given argument passing
-  the attributes in order to retrieve the appropriate exception
-  structure.
+  Calls the `exception/1` function on the given argument (which has to be a
+  module name like `ArgumentError` or `RuntimeError`) passing `attributes`
+  in order to retrieve the exception struct.
 
-  Any module defined via `defexception/1` automatically
-  implements `exception(attrs)` callback expected by `raise/2`.
+  Any module that contains a call to the `defexception/1` macro automatically
+  implements the `c:Exception.exception/1` callback expected by `raise/2`.
+  For more information, see `defexception/1`.
 
   ## Examples
 
-      iex> raise(ArgumentError, message: "Sample")
+      iex> raise(ArgumentError, "Sample")
       ** (ArgumentError) Sample
 
   """
-  defmacro raise(exception, attrs) do
+  defmacro raise(exception, attributes) do
     quote do
-      :erlang.error unquote(exception).exception(unquote(attrs))
+      :erlang.error(unquote(exception).exception(unquote(attributes)))
     end
   end
 
@@ -1251,53 +2291,42 @@ defmodule Kernel do
 
   Works like `raise/1` but does not generate a new stacktrace.
 
-  Notice that `System.stacktrace` returns the stacktrace
-  of the last exception. That said, it is common to assign
-  the stacktrace as the first expression inside a `rescue`
-  clause as any other exception potentially raised (and
-  rescued) in between the rescue clause and the raise call
-  may change the `System.stacktrace` value.
+  Note that `__STACKTRACE__` can be used inside catch/rescue
+  to retrieve the current stacktrace.
 
   ## Examples
 
-      try do
-        raise "Oops"
-      rescue
-        exception ->
-          stacktrace = System.stacktrace
-          if Exception.message(exception) == "Oops" do
-            reraise exception, stacktrace
-          end
-      end
+      iex> try do
+      ...>  raise "oops"
+      ...> rescue
+      ...>  exception ->
+      ...>    reraise exception, __STACKTRACE__
+      ...> end
+      ** (RuntimeError) oops
+
   """
-  defmacro reraise(msg, stacktrace) do
+  defmacro reraise(message, stacktrace) do
     # Try to figure out the type at compilation time
-    # to avoid dead code and make dialyzer happy.
-
-    case Macro.expand(msg, __CALLER__) do
-      msg when is_binary(msg) ->
+    # to avoid dead code and make Dialyzer happy.
+    case Macro.expand(message, __CALLER__) do
+      message when is_binary(message) ->
         quote do
-          :erlang.raise :error, RuntimeError.exception(unquote(msg)), unquote(stacktrace)
+          :erlang.raise(:error, RuntimeError.exception(unquote(message)), unquote(stacktrace))
         end
-      {:<<>>, _, _} = msg ->
+
+      {:<<>>, _, _} = message ->
         quote do
-          :erlang.raise :error, RuntimeError.exception(unquote(msg)), unquote(stacktrace)
+          :erlang.raise(:error, RuntimeError.exception(unquote(message)), unquote(stacktrace))
         end
+
       alias when is_atom(alias) ->
         quote do
-          :erlang.raise :error, unquote(alias).exception([]), unquote(stacktrace)
+          :erlang.raise(:error, unquote(alias).exception([]), unquote(stacktrace))
         end
-      msg ->
+
+      message ->
         quote do
-          stacktrace = unquote(stacktrace)
-          case unquote(msg) do
-            msg when is_binary(msg) ->
-              :erlang.raise :error, RuntimeError.exception(msg), stacktrace
-            atom when is_atom(atom) ->
-              :erlang.raise :error, atom.exception([]), stacktrace
-            %{__struct__: struct, __exception__: true} = other when is_atom(struct) ->
-              :erlang.raise :error, other, stacktrace
-          end
+          :erlang.raise(:error, Kernel.Utils.raise(unquote(message)), unquote(stacktrace))
         end
     end
   end
@@ -1305,30 +2334,36 @@ defmodule Kernel do
   @doc """
   Raises an exception preserving a previous stacktrace.
 
-  Works like `raise/2` but does not generate a new stacktrace.
-
-  See `reraise/2` for more details.
+  `reraise/3` works like `reraise/2`, except it passes arguments to the
+  `exception/1` function as explained in `raise/2`.
 
   ## Examples
 
       try do
-        raise "Oops"
+        raise "oops"
       rescue
         exception ->
-          stacktrace = System.stacktrace
-          reraise WrapperError, [exception: exception], stacktrace
+          reraise WrapperError, [exception: exception], __STACKTRACE__
       end
+
   """
-  defmacro reraise(exception, attrs, stacktrace) do
+  defmacro reraise(exception, attributes, stacktrace) do
     quote do
-      :erlang.raise :error, unquote(exception).exception(unquote(attrs)), unquote(stacktrace)
+      :erlang.raise(
+        :error,
+        unquote(exception).exception(unquote(attributes)),
+        unquote(stacktrace)
+      )
     end
   end
 
   @doc """
-  Matches the term on the left against the regular expression or string on the
-  right. Returns true if `left` matches `right` (if it's a regular expression)
-  or contains `right` (if it's a string).
+  Text-based match operator. Matches the string on the `left`
+  against the regular expression or string on the `right`.
+
+  If `right` is a regular expression, returns `true` if `left` matches right.
+
+  If `right` is a string, returns `true` if `left` contains `right`.
 
   ## Examples
 
@@ -1338,13 +2373,26 @@ defmodule Kernel do
       iex> "abcd" =~ ~r/e/
       false
 
+      iex> "abcd" =~ ~r//
+      true
+
       iex> "abcd" =~ "bc"
       true
 
       iex> "abcd" =~ "ad"
       false
 
+      iex> "abcd" =~ "abcd"
+      true
+
+      iex> "abcd" =~ ""
+      true
+
+  For more information about regular expressions, please check the `Regex` module.
   """
+  @spec String.t() =~ (String.t() | Regex.t()) :: boolean
+  def left =~ "" when is_binary(left), do: true
+
   def left =~ right when is_binary(left) and is_binary(right) do
     :binary.match(left, right) != :nomatch
   end
@@ -1354,8 +2402,8 @@ defmodule Kernel do
   end
 
   @doc ~S"""
-  Inspect the given argument according to the `Inspect` protocol.
-  The second argument is a keywords list with options to control
+  Inspects the given argument according to the `Inspect` protocol.
+  The second argument is a keyword list with options to control
   inspection.
 
   ## Options
@@ -1369,2069 +2417,4500 @@ defmodule Kernel do
       iex> inspect(:foo)
       ":foo"
 
-      iex> inspect [1, 2, 3, 4, 5], limit: 3
+      iex> inspect([1, 2, 3, 4, 5], limit: 3)
       "[1, 2, 3, ...]"
 
-      iex> inspect("josé" <> <<0>>)
-      "<<106, 111, 115, 195, 169, 0>>"
+      iex> inspect([1, 2, 3], pretty: true, width: 0)
+      "[1,\n 2,\n 3]"
+
+      iex> inspect("olá" <> <<0>>)
+      "<<111, 108, 195, 161, 0>>"
+
+      iex> inspect("olá" <> <<0>>, binaries: :as_strings)
+      "\"olá\\0\""
 
-      iex> inspect("josé" <> <<0>>, binaries: :as_strings)
-      "\"josé\\000\""
+      iex> inspect("olá", binaries: :as_binaries)
+      "<<111, 108, 195, 161>>"
 
-      iex> inspect("josé", binaries: :as_binaries)
-      "<<106, 111, 115, 195, 169>>"
+      iex> inspect(~c"bar")
+      "~c\"bar\""
 
-  Note that the inspect protocol does not necessarily return a valid
+      iex> inspect([0 | ~c"bar"])
+      "[0, 98, 97, 114]"
+
+      iex> inspect(100, base: :octal)
+      "0o144"
+
+      iex> inspect(100, base: :hex)
+      "0x64"
+
+  Note that the `Inspect` protocol does not necessarily return a valid
   representation of an Elixir term. In such cases, the inspected result
   must start with `#`. For example, inspecting a function will return:
 
-      inspect fn a, b -> a + b end
+      inspect(fn a, b -> a + b end)
       #=> #Function<...>
 
+  The `Inspect` protocol can be derived to hide certain fields
+  from structs, so they don't show up in logs, inspects and similar.
+  See the "Deriving" section of the documentation of the `Inspect`
+  protocol for more information.
   """
-  @spec inspect(Inspect.t, Keyword.t) :: String.t
-  def inspect(arg, opts \\ []) when is_list(opts) do
-    opts  = struct(Inspect.Opts, opts)
-    limit = case opts.pretty do
-      true  -> opts.width
-      false -> :infinity
-    end
-    Inspect.Algebra.pretty(Inspect.Algebra.to_doc(arg, opts), limit)
+  @spec inspect(Inspect.t(), [Inspect.Opts.new_opt()]) :: String.t()
+  def inspect(term, opts \\ []) when is_list(opts) do
+    opts = Inspect.Opts.new(opts)
+
+    limit =
+      case opts.pretty do
+        true -> opts.width
+        false -> :infinity
+      end
+
+    doc = Inspect.Algebra.group(Inspect.Algebra.to_doc(term, opts))
+    IO.iodata_to_binary(Inspect.Algebra.format(doc, limit))
   end
 
   @doc """
-  Creates and updates structs.
+  Creates and updates a struct.
 
-  The struct argument may be an atom (which defines `defstruct`)
-  or a struct itself. The second argument is any Enumerable that
-  emits two-item tuples (key-value) during enumeration.
+  The `struct` argument may be an atom (which defines `defstruct`)
+  or a `struct` itself. The second argument is any `Enumerable` that
+  emits two-element tuples (key-value pairs) during enumeration.
 
-  If one of the keys in the Enumerable does not exist in the struct,
-  they are automatically discarded.
+  Keys in the `Enumerable` that don't exist in the struct are automatically
+  discarded. Note that keys must be atoms, as only atoms are allowed when
+  defining a struct. If there are duplicate keys in the `Enumerable`, the last
+  entry will be taken (same behavior as `Map.new/1`).
 
-  This function is useful for dynamically creating and updating
-  structs.
+  This function is useful for dynamically creating and updating structs, as
+  well as for converting maps to structs; in the latter case, just inserting
+  the appropriate `:__struct__` field into the map may not be enough and
+  `struct/2` should be used instead.
 
-  ## Example
+  ## Examples
 
       defmodule User do
-        defstruct name: "jose"
+        defstruct name: "john"
       end
 
       struct(User)
-      #=> %User{name: "jose"}
+      #=> %User{name: "john"}
 
-      opts = [name: "eric"]
+      opts = [name: "meg"]
       user = struct(User, opts)
-      #=> %User{name: "eric"}
+      #=> %User{name: "meg"}
 
       struct(user, unknown: "value")
-      #=> %User{name: "eric"}
+      #=> %User{name: "meg"}
 
-  """
-  @spec struct(module | map, Enum.t) :: map
-  def struct(struct, kv \\ [])
-
-  def struct(struct, []) when is_atom(struct) or is_tuple(struct) do
-    apply(struct, :__struct__, [])
-  end
+      struct(User, %{name: "meg"})
+      #=> %User{name: "meg"}
 
-  def struct(struct, kv) when is_atom(struct) or is_tuple(struct) do
-    struct(apply(struct, :__struct__, []), kv)
-  end
+      # String keys are ignored
+      struct(User, %{"name" => "meg"})
+      #=> %User{name: "john"}
 
-  def struct(%{__struct__: _} = struct, kv) do
-    Enum.reduce(kv, struct, fn {k, v}, acc ->
-      case :maps.is_key(k, acc) and k != :__struct__ do
-        true  -> :maps.put(k, v, acc)
-        false -> acc
-      end
+  """
+  @spec struct(module | struct, Enumerable.t()) :: struct
+  def struct(struct, fields \\ []) do
+    struct(struct, fields, fn
+      {:__struct__, _val}, acc ->
+        acc
+
+      {key, val}, acc ->
+        case acc do
+          %{^key => _} -> %{acc | key => val}
+          _ -> acc
+        end
     end)
   end
 
   @doc """
-  Gets a value from a nested structure.
-
-  Uses the `Access` protocol to traverse the structures
-  according to the given `keys`.
-
-  ## Examples
+  Similar to `struct/2` but checks for key validity.
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> get_in(users, ["josé", :age])
-      27
+  The function `struct!/2` emulates the compile time behavior
+  of structs. This means that:
 
-  In case any of entries in the middle returns `nil`, `nil` will be returned
-  as per the Access protocol:
+    * when building a struct, as in `struct!(SomeStruct, key: :value)`,
+      it is equivalent to `%SomeStruct{key: :value}` and therefore this
+      function will check if every given key-value belongs to the struct.
+      If the struct is enforcing any key via `@enforce_keys`, those will
+      be enforced as well;
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> get_in(users, ["unknown", :age])
-      nil
+    * when updating a struct, as in `struct!(%SomeStruct{}, key: :value)`,
+      it is equivalent to `%SomeStruct{struct | key: :value}` and therefore this
+      function will check if every given key-value belongs to the struct.
 
   """
-  @spec get_in(Access.t, nonempty_list(term)) :: term
-  def get_in(data, keys)
-  def get_in(nil, list) when is_list(list), do: nil
-  def get_in(data, [h]),                    do: Access.get(data, h)
-  def get_in(data, [h|t]),                  do: get_in(Access.get(data, h), t)
-
-  @doc """
-  Puts a value in a nested structure.
-
-  Uses the `Access` protocol to traverse the structures
-  according to the given `keys`.
+  @spec struct!(module | struct, Enumerable.t()) :: struct
+  def struct!(struct, fields \\ [])
 
-  ## Examples
+  def struct!(struct, fields) when is_atom(struct) do
+    validate_struct!(struct.__struct__(fields), struct, 1)
+  end
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> put_in(users, ["josé", :age], 28)
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+  def struct!(struct, fields) when is_map(struct) do
+    struct(struct, fields, fn
+      {:__struct__, _}, acc ->
+        acc
 
-  In case any of entries in the middle returns `nil`, a map is dynamically
-  created:
+      {key, val}, acc ->
+        Map.replace!(acc, key, val)
+    end)
+  end
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> put_in(users, ["dave", :age], 13)
-      %{"josé" => %{age: 27}, "eric" => %{age: 23}, "dave" => %{age: 13}}
+  defp struct(struct, [], _fun) when is_atom(struct) do
+    validate_struct!(struct.__struct__(), struct, 0)
+  end
 
-  """
-  @spec put_in(Access.t, nonempty_list(term), term) :: Access.t
-  def put_in(data, keys, value) do
-    elem(get_and_update_in(data, keys, fn _ -> {nil, value} end), 1)
+  defp struct(struct, fields, fun) when is_atom(struct) do
+    struct(validate_struct!(struct.__struct__(), struct, 0), fields, fun)
   end
 
-  @doc """
-  Updates a key in a nested structure.
+  defp struct(%_{} = struct, [], _fun) do
+    struct
+  end
 
-  Uses the `Access` protocol to traverse the structures
-  according to the given `keys`.
+  defp struct(%_{} = struct, fields, fun) do
+    Enum.reduce(fields, struct, fun)
+  end
 
-  ## Examples
+  defp validate_struct!(%{__struct__: module} = struct, module, _arity) do
+    struct
+  end
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> update_in(users, ["josé", :age], &(&1 + 1))
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+  defp validate_struct!(%{__struct__: struct_name}, module, arity) when is_atom(struct_name) do
+    error_message =
+      "expected struct name returned by #{inspect(module)}.__struct__/#{arity} to be " <>
+        "#{inspect(module)}, got: #{inspect(struct_name)}"
 
-  In case any of entries in the middle returns `nil`, a map is dynamically
-  created:
+    :erlang.error(ArgumentError.exception(error_message))
+  end
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> update_in(users, ["dave", :age], &((&1 || 0) + 1))
-      %{"josé" => %{age: 27}, "eric" => %{age: 23}, "dave" => %{age: 1}}
+  defp validate_struct!(expr, module, arity) do
+    error_message =
+      "expected #{inspect(module)}.__struct__/#{arity} to return a map with a :__struct__ " <>
+        "key that holds the name of the struct (atom), got: #{inspect(expr)}"
 
-  """
-  @spec update_in(Access.t, nonempty_list(term), (term -> term)) :: Access.t
-  def update_in(data, keys, fun) do
-    elem(get_and_update_in(data, keys, fn x -> {nil, fun.(x)} end), 1)
+    :erlang.error(ArgumentError.exception(error_message))
   end
 
   @doc """
-  Gets a value and updates a nested structure.
+  Returns `true` if `term` is a struct, otherwise returns `false`.
 
-  It expects a tuple to be returned, containing the value retrieved
-  and the update one. Uses the `Access` protocol to traverse the
-  structures according to the given `keys`.
+  Allowed in guard tests.
 
   ## Examples
 
-  This function is useful when there is a need to retrieve the current
-  value (or something calculated in function of the current value) and
-  update it at the same time. For example, it could be used to increase
-  the age of a user by one and return the previous age in one pass:
-
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> get_and_update_in(users, ["josé", :age], &{&1, &1 + 1})
-      {27, %{"josé" => %{age: 28}, "eric" => %{age: 23}}}
-
-  In case any of entries in the middle returns `nil`, a map is dynamically
-  created:
+      iex> is_struct(URI.parse("/"))
+      true
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> get_and_update_in(users, ["dave", :age], &{&1, 13})
-      {nil, %{"josé" => %{age: 27}, "eric" => %{age: 23}, "dave" => %{age: 13}}}
+      iex> is_struct(%{})
+      false
 
   """
-  @spec get_and_update_in(Access.t, nonempty_list(term),
-                          (term -> {get, term})) :: {get, Access.t} when get: var
-  def get_and_update_in(data, keys, fun)
+  @doc since: "1.10.0", guard: true
+  defmacro is_struct(term) do
+    case __CALLER__.context do
+      nil ->
+        quote do
+          case unquote(term) do
+            %_{} -> true
+            _ -> false
+          end
+        end
+
+      :match ->
+        invalid_match!(:is_struct)
 
-  def get_and_update_in(nil, list, fun), do: get_and_update_in(%{}, list, fun)
-  def get_and_update_in(data, [h], fun), do: Access.get_and_update(data, h, fun)
-  def get_and_update_in(data, [h|t], fun) do
-    Access.get_and_update(data, h, &get_and_update_in(&1, t, fun))
+      :guard ->
+        quote do
+          is_map(unquote(term)) and :erlang.is_map_key(:__struct__, unquote(term)) and
+            is_atom(:erlang.map_get(:__struct__, unquote(term)))
+        end
+    end
   end
 
   @doc """
-  Puts a value in a nested structure via the given `path`.
+  Returns `true` if `term` is a struct of `name`, otherwise returns `false`.
 
-  This is similar to `put_in/3`, except the path is extracted via
-  a macro rather than passing a list. For example:
+  `is_struct/2` does not check that `name` exists and is a valid struct.
+  If you want such validations, you must pattern match on the struct
+  instead, such as `match?(%URI{}, arg)`.
 
-      put_in(opts[:foo][:bar], :baz)
-
-  Is equivalent to:
-
-      put_in(opts, [:foo, :bar], :baz)
-
-  Note that in order for this macro to work, the complete path must always
-  be visible by this macro. For more information about the supported path
-  expressions, please check `get_and_update_in/2` docs.
+  Allowed in guard tests.
 
   ## Examples
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> put_in(users["josé"][:age], 28)
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      iex> is_struct(URI.parse("/"), URI)
+      true
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> put_in(users["josé"].age, 28)
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      iex> is_struct(URI.parse("/"), Macro.Env)
+      false
 
   """
-  defmacro put_in(path, value) do
-    [h|t] = unnest(path, [], "put_in/2")
-    expr  = nest_get_and_update_in(h, t, quote(do: fn _ -> {nil, unquote(value)} end))
-    quote do: :erlang.element(2, unquote(expr))
+  @doc since: "1.11.0", guard: true
+  defmacro is_struct(term, name) do
+    case __CALLER__.context do
+      nil ->
+        quote generated: true do
+          case unquote(name) do
+            name when is_atom(name) ->
+              case unquote(term) do
+                %{__struct__: ^name} -> true
+                _ -> false
+              end
+
+            _ ->
+              raise ArgumentError
+          end
+        end
+
+      :match ->
+        invalid_match!(:is_struct)
+
+      :guard ->
+        quote do
+          is_map(unquote(term)) and
+            (is_atom(unquote(name)) or :fail) and
+            :erlang.is_map_key(:__struct__, unquote(term)) and
+            :erlang.map_get(:__struct__, unquote(term)) == unquote(name)
+        end
+    end
   end
 
   @doc """
-  Updates a nested structure via the given `path`.
-
-  This is similar to `update_in/3`, except the path is extracted via
-  a macro rather than passing a list. For example:
+  Returns `true` if `term` is a map that is not a struct, otherwise
+  returns `false`.
 
-      update_in(opts[:foo][:bar], &(&1 + 1))
+  Allowed in guard tests.
 
-  Is equivalent to:
+  ## Examples
 
-      update_in(opts, [:foo, :bar], &(&1 + 1))
+      iex> is_non_struct_map(%{})
+      true
 
-  Note that in order for this macro to work, the complete path must always
-  be visible by this macro. For more information about the supported path
-  expressions, please check `get_and_update_in/2` docs.
+      iex> is_non_struct_map(URI.parse("/"))
+      false
 
-  ## Examples
+      iex> is_non_struct_map(nil)
+      false
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> update_in(users["josé"][:age], &(&1 + 1))
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+  """
+  @doc since: "1.17.0", guard: true
+  defmacro is_non_struct_map(term) do
+    case __CALLER__.context do
+      nil ->
+        quote do
+          case unquote(term) do
+            %_{} -> false
+            %{} -> true
+            _ -> false
+          end
+        end
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> update_in(users["josé"].age, &(&1 + 1))
-      %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      :match ->
+        invalid_match!(:is_non_struct_map)
 
-  """
-  defmacro update_in(path, fun) do
-    [h|t] = unnest(path, [], "update_in/2")
-    expr = nest_get_and_update_in(h, t, quote(do: fn x -> {nil, unquote(fun).(x)} end))
-    quote do: :erlang.element(2, unquote(expr))
+      :guard ->
+        quote do
+          is_map(unquote(term)) and
+            not (:erlang.is_map_key(:__struct__, unquote(term)) and
+                   is_atom(:erlang.map_get(:__struct__, unquote(term))))
+        end
+    end
   end
 
   @doc """
-  Gets a value and updates a nested data structure via the given `path`.
+  Returns `true` if `term` is an exception, otherwise returns `false`.
 
-  This is similar to `get_and_update_in/3`, except the path is extracted
-  via a macro rather than passing a list. For example:
+  Allowed in guard tests.
 
-      get_and_update_in(opts[:foo][:bar], &{&1, &1 + 1})
+  ## Examples
 
-  Is equivalent to:
+      iex> is_exception(%RuntimeError{})
+      true
 
-      get_and_update_in(opts, [:foo, :bar], &{&1, &1 + 1})
+      iex> is_exception(%{})
+      false
 
-  Note that in order for this macro to work, the complete path must always
-  be visible by this macro. See the Paths section below.
+  """
+  @doc since: "1.11.0", guard: true
+  defmacro is_exception(term) do
+    case __CALLER__.context do
+      nil ->
+        quote do
+          case unquote(term) do
+            %_{__exception__: true} -> true
+            _ -> false
+          end
+        end
+
+      :match ->
+        invalid_match!(:is_exception)
+
+      :guard ->
+        quote do
+          is_map(unquote(term)) and :erlang.is_map_key(:__struct__, unquote(term)) and
+            is_atom(:erlang.map_get(:__struct__, unquote(term))) and
+            :erlang.is_map_key(:__exception__, unquote(term)) and
+            :erlang.map_get(:__exception__, unquote(term)) == true
+        end
+    end
+  end
+
+  @doc """
+  Returns `true` if `term` is an exception of `name`, otherwise returns `false`.
+
+  Allowed in guard tests.
 
   ## Examples
 
-      iex> users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-      iex> get_and_update_in(users["josé"][:age], &{&1, &1 + 1})
-      {27, %{"josé" => %{age: 28}, "eric" => %{age: 23}}}
+      iex> is_exception(%RuntimeError{}, RuntimeError)
+      true
 
-  ## Paths
+      iex> is_exception(%RuntimeError{}, Macro.Env)
+      false
 
-  A path may start with a variable, local or remote call, and must be
-  followed by one or more:
+  """
+  @doc since: "1.11.0", guard: true
+  defmacro is_exception(term, name) do
+    case __CALLER__.context do
+      nil ->
+        quote do
+          case unquote(name) do
+            name when is_atom(name) ->
+              case unquote(term) do
+                %{__struct__: ^name, __exception__: true} -> true
+                _ -> false
+              end
+
+            _ ->
+              raise ArgumentError
+          end
+        end
 
-    * `foo[bar]` - access a field; in case an intermediate field is not
-      present or returns nil, an empty map is used
+      :match ->
+        invalid_match!(:is_exception)
 
-    * `foo.bar` - access a map/struct field; in case the field is not
-      present, an error is raised
+      :guard ->
+        quote do
+          is_map(unquote(term)) and
+            (is_atom(unquote(name)) or :fail) and
+            :erlang.is_map_key(:__struct__, unquote(term)) and
+            :erlang.map_get(:__struct__, unquote(term)) == unquote(name) and
+            :erlang.is_map_key(:__exception__, unquote(term)) and
+            :erlang.map_get(:__exception__, unquote(term)) == true
+        end
+    end
+  end
 
-  Here are some valid paths:
+  @doc """
+  Pipes the first argument, `value`, into the second argument, a function `fun`,
+  and returns the result of calling `fun`.
 
-      users["josé"][:age]
-      users["josé"].age
-      User.all["josé"].age
-      all_users()["josé"].age
+  In other words, it invokes the function `fun` with `value` as argument,
+  and returns its result.
 
-  Here are some invalid ones:
+  This is most commonly used in pipelines, using the `|>/2` operator, allowing you
+  to pipe a value to a function outside of its first argument.
 
-      # Does a remote call after the initial value
-      users["josé"].do_something(arg1, arg2)
+  ## Examples
 
-      # Does not access any field
-      users
+      iex> 1 |> then(fn x -> x * 2 end)
+      2
 
+      iex> 1 |> then(fn x -> Enum.drop(["a", "b", "c"], x) end)
+      ["b", "c"]
   """
-  defmacro get_and_update_in(path, fun) do
-    [h|t] = unnest(path, [], "get_and_update_in/2")
-    nest_get_and_update_in(h, t, fun)
-  end
-
-  defp nest_get_and_update_in([], fun),  do: fun
-  defp nest_get_and_update_in(list, fun) do
+  @doc since: "1.12.0"
+  defmacro then(value, fun) do
     quote do
-      fn x -> unquote(nest_get_and_update_in(quote(do: x), list, fun)) end
+      unquote(fun).(unquote(value))
     end
   end
 
-  defp nest_get_and_update_in(h, [{:access, key}|t], fun) do
-    quote do
-      Access.get_and_update(
-        case(unquote(h), do: (nil -> %{}; o -> o)),
-        unquote(key),
-        unquote(nest_get_and_update_in(t, fun))
-      )
-    end
-  end
+  @doc """
+  Gets a value from a nested structure with nil-safe handling.
 
-  defp nest_get_and_update_in(h, [{:map, key}|t], fun) do
-    quote do
-      Access.Map.get_and_update!(unquote(h), unquote(key), unquote(nest_get_and_update_in(t, fun)))
-    end
-  end
+  Uses the `Access` module to traverse the structures
+  according to the given `keys`, unless the `key` is a
+  function, which is detailed in a later section.
 
-  defp unnest({{:., _, [Access, :get]}, _, [expr, key]}, acc, kind) do
-    unnest(expr, [{:access, key}|acc], kind)
-  end
+  ## Examples
 
-  defp unnest({{:., _, [expr, key]}, _, []}, acc, kind)
-      when is_tuple(expr) and elem(expr, 0) != :__aliases__ and elem(expr, 0) != :__MODULE__ do
-    unnest(expr, [{:map, key}|acc], kind)
-  end
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_in(users, ["john", :age])
+      27
+      iex> # Equivalent to:
+      iex> users["john"][:age]
+      27
 
-  defp unnest(other, [], kind) do
-    raise ArgumentError,
-      "expected expression given to #{kind} to access at least one field, got: #{Macro.to_string other}"
-  end
+  `get_in/2` can also use the accessors in the `Access` module
+  to traverse more complex data structures. For example, here we
+  use `Access.all/0` to traverse a list:
 
-  defp unnest(other, acc, kind) do
-    case proper_start?(other) do
-      true -> [other|acc]
-      false ->
-        raise ArgumentError,
-          "expression given to #{kind} must start with a variable, local or remote call " <>
-          "and be followed by field access, got: #{Macro.to_string other}"
-    end
-  end
+      iex> users = [%{name: "john", age: 27}, %{name: "meg", age: 23}]
+      iex> get_in(users, [Access.all(), :age])
+      [27, 23]
 
-  defp proper_start?({{:., _, [expr, _]}, _, _args})
-    when is_atom(expr)
-    when elem(expr, 0) == :__aliases__
-    when elem(expr, 0) == :__MODULE__, do: true
+  In case any of the components returns `nil`, `nil` will be returned
+  and `get_in/2` won't traverse any further:
 
-  defp proper_start?({atom, _, _args})
-    when is_atom(atom), do: true
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_in(users, ["unknown", :age])
+      nil
+      iex> # Equivalent to:
+      iex> users["unknown"][:age]
+      nil
 
-  defp proper_start?(other),
-    do: not is_tuple(other)
+  ## Functions as keys
 
-  @doc """
-  Converts the argument to a string according to the
-  `String.Chars` protocol.
+  If a key given to `get_in/2` is a function, the function will be invoked
+  passing three arguments:
 
-  This is the function invoked when there is string interpolation.
+    * the operation (`:get`)
+    * the data to be accessed
+    * a function to be invoked next
 
-  ## Examples
+  This means `get_in/2` can be extended to provide custom lookups.
+  That's precisely how the `Access.all/0` key in the previous section
+  behaves. For example, we can manually implement such traversal as
+  follows:
 
-      iex> to_string(:foo)
-      "foo"
+      iex> users = [%{name: "john", age: 27}, %{name: "meg", age: 23}]
+      iex> all = fn :get, data, next -> Enum.map(data, next) end
+      iex> get_in(users, [all, :age])
+      [27, 23]
 
-  """
-  # If it is a binary at compilation time, simply return it.
-  defmacro to_string(arg) when is_binary(arg), do: arg
+  The `Access` module ships with many convenience accessor functions.
+  See `Access.all/0`, `Access.key/2`, and others as examples.
 
-  defmacro to_string(arg) do
-    quote do: String.Chars.to_string(unquote(arg))
-  end
+  ## Working with structs
 
-  @doc """
-  Convert the argument to a list according to the List.Chars protocol.
+  By default, structs do not implement the `Access` behaviour required
+  by this function. Therefore, you can't do this:
 
-  ## Examples
+      get_in(some_struct, [:some_key, :nested_key])
 
-      iex> to_char_list(:foo)
-      'foo'
+  There are two alternatives. Given structs have predefined keys,
+  we can use the `struct.field` notation:
 
-  """
-  defmacro to_char_list(arg) do
-    quote do: List.Chars.to_char_list(unquote(arg))
-  end
+      some_struct.some_key.nested_key
 
-  @doc """
-  Checks if the given argument is nil or not.
-  Allowed in guard clauses.
+  However, the code above will fail if any of the values return `nil`.
+  If you also want to handle nil values, you can use `get_in/1`:
 
-  ## Examples
+      get_in(some_struct.some_key.nested_key)
 
-      iex> nil?(1)
-      false
+  Pattern-matching is another option for handling such cases,
+  which can be especially useful if you want to match on several
+  fields at once or provide custom return values:
 
-      iex> nil?(nil)
-      true
+      case some_struct do
+        %{some_key: %{nested_key: value}} -> value
+        %{} -> nil
+      end
 
   """
-  defmacro nil?(x) do
-    quote do: unquote(x) == nil
-  end
+  @spec get_in(Access.t(), nonempty_list(term)) :: term
+  def get_in(data, keys)
+
+  def get_in(nil, [_ | _]), do: nil
+
+  def get_in(data, [h]) when is_function(h), do: h.(:get, data, & &1)
+  def get_in(data, [h | t]) when is_function(h), do: h.(:get, data, &get_in(&1, t))
+
+  def get_in(data, [h]), do: Access.get(data, h)
+  def get_in(data, [h | t]), do: get_in(Access.get(data, h), t)
 
   @doc """
-  A convenient macro that checks if the right side matches
-  the left side. The left side is allowed to be a match pattern.
+  Puts a value in a nested structure.
 
-  ## Examples
+  Uses the `Access` module to traverse the structures
+  according to the given `keys`, unless the `key` is a
+  function. If the key is a function, it will be invoked
+  as specified in `get_and_update_in/3`.
 
-      iex> match?(1, 1)
-      true
+  ## Examples
 
-      iex> match?(1, 2)
-      false
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> put_in(users, ["john", :age], 28)
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
-      iex> match?({1, _}, {1, 2})
-      true
+  If any of the intermediate values are nil, it will raise:
 
-  Match can also be used to filter or find a value in an enumerable:
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> put_in(users, ["jane", :age], "oops")
+      ** (ArgumentError) could not put/update key :age on a nil value
 
-      list = [{:a, 1}, {:b, 2}, {:a, 3}]
-      Enum.filter list, &match?({:a, _}, &1)
+  """
+  @spec put_in(Access.t(), nonempty_list(term), term) :: Access.t()
+  def put_in(data, [_ | _] = keys, value) do
+    elem(get_and_update_in(data, keys, fn _ -> {nil, value} end), 1)
+  end
 
-  Guard clauses can also be given to the match:
+  @doc """
+  Updates a key in a nested structure.
 
-      list = [{:a, 1}, {:b, 2}, {:a, 3}]
-      Enum.filter list, &match?({:a, x} when x < 2, &1)
+  Uses the `Access` module to traverse the structures
+  according to the given `keys`, unless the `key` is a
+  function. If the key is a function, it will be invoked
+  as specified in `get_and_update_in/3`.
 
-  However, variables assigned in the match will not be available
-  outside of the function call:
+  `data` is a nested structure (that is, a map, keyword
+  list, or struct that implements the `Access` behaviour).
+  The `fun` argument receives the value of `key` (or `nil`
+  if `key` is not present) and the result replaces the value
+  in the structure.
 
-      iex> match?(x, 1)
-      true
+  ## Examples
 
-      iex> binding([:x]) == []
-      true
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> update_in(users, ["john", :age], &(&1 + 1))
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
-  """
-  defmacro match?(pattern, expr)
+  Note the current value given to the anonymous function may be `nil`.
+  If any of the intermediate values are nil, it will raise:
 
-  # Special case underscore since it always matches
-  defmacro match?({:_, _, atom}, _right) when is_atom(atom) do
-    true
-  end
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> update_in(users, ["jane", :age], & &1 + 1)
+      ** (ArgumentError) could not put/update key :age on a nil value
 
-  defmacro match?(left, right) do
-    quote do
-      case unquote(right) do
-        unquote(left) ->
-          true
-        _ ->
-          false
-      end
-    end
+  """
+  @spec update_in(Access.t(), nonempty_list(term), (term -> term)) :: Access.t()
+  def update_in(data, [_ | _] = keys, fun) when is_function(fun) do
+    elem(get_and_update_in(data, keys, fn x -> {nil, fun.(x)} end), 1)
   end
 
   @doc """
-  Read and write attributes of th current module.
-
-  The canonical example for attributes is annotating that a module
-  implements the OTP behaviour called `gen_server`:
+  Gets a value and updates a nested structure.
 
-      defmodule MyServer do
-        @behaviour :gen_server
-        # ... callbacks ...
-      end
+  `data` is a nested structure (that is, a map, keyword
+  list, or struct that implements the `Access` behaviour).
 
-  By default Elixir supports all Erlang module attributes, but any developer
-  can also add custom attributes:
+  The `fun` argument receives the value of `key` (or `nil` if `key`
+  is not present) and must return one of the following values:
 
-      defmodule MyServer do
-        @my_data 13
-        IO.inspect @my_data #=> 13
-      end
+    * a two-element tuple `{current_value, new_value}`. In this case,
+      `current_value` is the retrieved value which can possibly be operated on before
+      being returned. `new_value` is the new value to be stored under `key`.
 
-  Unlike Erlang, such attributes are not stored in the module by
-  default since it is common in Elixir to use such attributes to store
-  temporary data. A developer can configure an attribute to behave closer
-  to Erlang by calling `Module.register_attribute/3`.
+    * `:pop`, which implies that the current value under `key`
+      should be removed from the structure and returned.
 
-  Finally, notice that attributes can also be read inside functions:
+  This function uses the `Access` module to traverse the structures
+  according to the given `keys`, unless the `key` is a function,
+  which is detailed in a later section.
 
-      defmodule MyServer do
-        @my_data 11
-        def first_data, do: @my_data
-        @my_data 13
-        def second_data, do: @my_data
-      end
+  ## Examples
 
-      MyServer.first_data #=> 11
-      MyServer.second_data #=> 13
+  This function is useful when there is a need to retrieve the current
+  value (or something calculated in function of the current value) and
+  update it at the same time. For example, it could be used to read the
+  current age of a user while increasing it by one in one pass:
 
-  It is important to note that reading an attribute takes a snapshot of
-  its current value. In other words, the value is read at compilation
-  time and not at runtime. Check the module `Module` for other functions
-  to manipulate module attributes.
-  """
-  defmacro @(expr)
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_and_update_in(users, ["john", :age], &{&1, &1 + 1})
+      {27, %{"john" => %{age: 28}, "meg" => %{age: 23}}}
 
-  # Typespecs attributes are special cased by the compiler so far
-  defmacro @({name, _, args}) do
-    # Check for Macro as it is compiled later than Module
-    case bootstraped?(Module) do
-      false -> nil
-      true  ->
-        assert_module_scope(__CALLER__, :@, 1)
-        function? = __CALLER__.function != nil
+  Note the current value given to the anonymous function may be `nil`.
+  If any of the intermediate values are nil, it will raise:
 
-        case is_list(args) and length(args) == 1 and typespec(name) do
-          false ->
-            case name == :typedoc and not bootstraped?(Kernel.Typespec) do
-              true  -> nil
-              false -> do_at(args, name, function?, __CALLER__)
-            end
-          macro ->
-            case bootstraped?(Kernel.Typespec) do
-              false -> nil
-              true  -> quote do: Kernel.Typespec.unquote(macro)(unquote(hd(args)))
-            end
-        end
-    end
-  end
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_and_update_in(users, ["jane", :age], &{&1, &1 + 1})
+      ** (ArgumentError) could not put/update key :age on a nil value
 
-  # @attribute value
-  defp do_at([arg], name, function?, env) do
-    case function? do
-      true ->
-        raise ArgumentError, "cannot dynamically set attribute @#{name} inside function"
-      false ->
-        case name do
-          :behavior ->
-            :elixir_errors.warn warn_info(env_stacktrace(env)),
-                                "@behavior attribute is not supported, please use @behaviour instead"
-          _ ->
-            :ok
-        end
+  ## Functions as keys
 
-        quote do: Module.put_attribute(__MODULE__, unquote(name), unquote(arg))
-    end
-  end
+  If a key is a function, the function will be invoked passing three
+  arguments:
 
-  # @attribute or @attribute()
-  defp do_at(args, name, function?, env) when is_atom(args) or args == [] do
-    stack = env_stacktrace(env)
+    * the operation (`:get_and_update`)
+    * the data to be accessed
+    * a function to be invoked next
 
-    case function? do
-      true ->
-        attr = Module.get_attribute(env.module, name, stack)
-        :erlang.element(1, :elixir_quote.escape(attr, false))
-      false ->
-        escaped = case stack do
-          [] -> []
-          _  -> Macro.escape(stack)
-        end
-        quote do: Module.get_attribute(__MODULE__, unquote(name), unquote(escaped))
-    end
-  end
+  This means `get_and_update_in/3` can be extended to provide custom
+  lookups. The downside is that functions cannot be stored as keys
+  in the accessed data structures.
 
-  # All other cases
-  defp do_at(args, name, _function?, _env) do
-    raise ArgumentError, "expected 0 or 1 argument for @#{name}, got: #{length(args)}"
-  end
+  When one of the keys is a function, the function is invoked.
+  In the example below, we use a function to get and increment all
+  ages inside a list:
 
-  defp warn_info([entry|_]) do
-    opts = elem(entry, tuple_size(entry) - 1)
-    Exception.format_file_line(Keyword.get(opts, :file), Keyword.get(opts, :line)) <> " "
-  end
+      iex> users = [%{name: "john", age: 27}, %{name: "meg", age: 23}]
+      iex> all = fn :get_and_update, data, next ->
+      ...>   data |> Enum.map(next) |> Enum.unzip()
+      ...> end
+      iex> get_and_update_in(users, [all, :age], &{&1, &1 + 1})
+      {[27, 23], [%{name: "john", age: 28}, %{name: "meg", age: 24}]}
 
-  defp warn_info([]) do
-    ""
-  end
+  If the previous value before invoking the function is `nil`,
+  the function *will* receive `nil` as a value and must handle it
+  accordingly (be it by failing or providing a sane default).
 
-  defp typespec(:type),     do: :deftype
-  defp typespec(:typep),    do: :deftypep
-  defp typespec(:opaque),   do: :defopaque
-  defp typespec(:spec),     do: :defspec
-  defp typespec(:callback), do: :defcallback
-  defp typespec(_),         do: false
+  The `Access` module ships with many convenience accessor functions,
+  like the `all` anonymous function defined above. See `Access.all/0`,
+  `Access.key/2`, and others as examples.
+  """
+  @spec get_and_update_in(
+          structure,
+          keys,
+          (term | nil -> {current_value, new_value} | :pop)
+        ) :: {current_value, new_structure :: structure}
+        when structure: Access.t(),
+             keys: nonempty_list(term),
+             current_value: Access.value(),
+             new_value: Access.value()
+  def get_and_update_in(data, keys, fun)
 
-  @doc """
-  Returns the binding as a keyword list where the variable name
-  is the key and the variable value is the value.
+  def get_and_update_in(data, [head], fun) when is_function(head, 3),
+    do: head.(:get_and_update, data, fun)
 
-  ## Examples
+  def get_and_update_in(data, [head | tail], fun) when is_function(head, 3),
+    do: head.(:get_and_update, data, &get_and_update_in(&1, tail, fun))
 
-      iex> x = 1
-      iex> binding()
-      [x: 1]
-      iex> x = 2
-      iex> binding()
-      [x: 2]
+  def get_and_update_in(data, [head], fun) when is_function(fun, 1),
+    do: Access.get_and_update(data, head, fun)
 
-  """
-  defmacro binding() do
-    do_binding(nil, nil, __CALLER__.vars, Macro.Env.in_match?(__CALLER__))
-  end
+  def get_and_update_in(data, [head | tail], fun) when is_function(fun, 1),
+    do: Access.get_and_update(data, head, &get_and_update_in(&1, tail, fun))
 
   @doc """
-  Receives a list of atoms at compilation time and returns the
-  binding of the given variables as a keyword list where the
-  variable name is the key and the variable value is the value.
+  Pops a key from the given nested structure.
 
-  In case a variable in the list does not exist in the binding,
-  it is not included in the returned result.
+  Uses the `Access` protocol to traverse the structures
+  according to the given `keys`, unless the `key` is a
+  function. If the key is a function, it will be invoked
+  as specified in `get_and_update_in/3`.
 
   ## Examples
 
-      iex> x = 1
-      iex> binding([:x, :y])
-      [x: 1]
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> pop_in(users, ["john", :age])
+      {27, %{"john" => %{}, "meg" => %{age: 23}}}
+
+  In case any entry returns `nil`, its key will be removed
+  and the deletion will be considered a success.
+
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> pop_in(users, ["jane", :age])
+      {nil, %{"john" => %{age: 27}, "meg" => %{age: 23}}}
 
   """
-  defmacro binding(list) when is_list(list) do
-    do_binding(list, nil, __CALLER__.vars, Macro.Env.in_match?(__CALLER__))
+  @spec pop_in(data, nonempty_list(Access.get_and_update_fun(term, data) | term)) :: {term, data}
+        when data: Access.container()
+  def pop_in(data, keys)
+
+  def pop_in(nil, [key | _]) do
+    raise ArgumentError, "could not pop key #{inspect(key)} on a nil value"
   end
 
-  defmacro binding(context) when is_atom(context) do
-    do_binding(nil, context, __CALLER__.vars, Macro.Env.in_match?(__CALLER__))
+  def pop_in(data, [_ | _] = keys) do
+    pop_in_data(data, keys)
   end
 
-  @doc """
-  Receives a list of atoms at compilation time and returns the
-  binding of the given variables in the given context as a keyword
-  list where the variable name is the key and the variable value
-  is the value.
+  defp pop_in_data(nil, [_ | _]), do: :pop
 
-  In case a variable in the list does not exist in the binding,
-  it is not included in the returned result.
+  defp pop_in_data(data, [fun]) when is_function(fun),
+    do: fun.(:get_and_update, data, fn _ -> :pop end)
 
-  ## Examples
+  defp pop_in_data(data, [fun | tail]) when is_function(fun),
+    do: fun.(:get_and_update, data, &pop_in_data(&1, tail))
 
-      iex> var!(x, :foo) = 1
-      iex> binding([:x, :y])
-      []
-      iex> binding([:x, :y], :foo)
-      [x: 1]
+  defp pop_in_data(data, [key]), do: Access.pop(data, key)
 
-  """
-  defmacro binding(list, context) when is_list(list) and is_atom(context) do
-    do_binding(list, context, __CALLER__.vars, Macro.Env.in_match?(__CALLER__))
-  end
+  defp pop_in_data(data, [key | tail]),
+    do: Access.get_and_update(data, key, &pop_in_data(&1, tail))
 
-  defp do_binding(list, context, vars, in_match) do
-    for {v, c} <- vars, c == context, list == nil or :lists.member(v, list) do
-      {v, wrap_binding(in_match, {v, [], c})}
-    end
-  end
+  @doc """
+  Gets a key from the nested structure via the given `path`, with
+  nil-safe handling.
 
-  defp wrap_binding(true, var) do
-    quote do: ^(unquote(var))
-  end
+  This is similar to `get_in/2`, except the path is extracted via
+  a macro rather than passing a list. For example:
 
-  defp wrap_binding(_, var) do
-    var
-  end
+      get_in(opts[:foo][:bar])
 
-  @doc """
-  Provides an `if` macro. This macro expects the first argument to
-  be a condition and the rest are keyword arguments.
+  Is equivalent to:
 
-  ## One-liner examples
+      get_in(opts, [:foo, :bar])
 
-      if(foo, do: bar)
+  Additionally, this macro can traverse structs:
 
-  In the example above, `bar` will be returned if `foo` evaluates to
-  `true` (i.e. it is neither `false` nor `nil`). Otherwise, `nil` will be returned.
+      get_in(struct.foo.bar)
 
-  An `else` option can be given to specify the opposite:
+  In case any of the keys returns `nil`, then `nil` will be returned
+  and `get_in/1` won't traverse any further.
 
-      if(foo, do: bar, else: baz)
+  Note that in order for this macro to work, the complete path must always
+  be visible by this macro. For more information about the supported path
+  expressions, please check `get_and_update_in/2` docs.
 
-  ## Blocks examples
+  ## Examples
 
-  Elixir also allows you to pass a block to the `if` macro. The first
-  example above would be translated to:
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_in(users["john"].age)
+      27
+      iex> get_in(users["unknown"].age)
+      nil
 
-      if foo do
-        bar
-      end
+  """
+  @doc since: "1.17.0"
+  defmacro get_in(path) do
+    {[h | t], _} = unnest(path, [], true, "get_in/1")
+    nest_get_in(h, quote(do: x), t)
+  end
 
-  Notice that `do/end` becomes delimiters. The second example would
-  then translate to:
+  defp nest_get_in(h, _var, []) do
+    h
+  end
 
-      if foo do
-        bar
-      else
-        baz
+  defp nest_get_in(h, var, [{:map, key} | tail]) do
+    quote generated: true do
+      case unquote(h) do
+        %{unquote(key) => unquote(var)} -> unquote(nest_get_in(var, var, tail))
+        nil -> nil
+        unquote(var) -> :erlang.error({:badkey, unquote(key), unquote(var)})
       end
+    end
+  end
 
-  If you want to compare more than two clauses, you can use the `cond/1`
-  macro.
-  """
-  defmacro if(condition, clauses) do
-    do_clause = Keyword.get(clauses, :do, nil)
-    else_clause = Keyword.get(clauses, :else, nil)
-
-    optimize_boolean(quote do
-      case unquote(condition) do
-        x when x in [false, nil] -> unquote(else_clause)
-        _ -> unquote(do_clause)
-      end
-    end)
+  defp nest_get_in(h, var, [{:access, key} | tail]) do
+    h = quote do: Access.get(unquote(h), unquote(key))
+    nest_get_in(h, var, tail)
   end
 
   @doc """
-  Evaluates and returns the do-block passed in as a second argument
-  unless clause evaluates to true.
-  Returns nil otherwise.
-  See also `if`.
+  Puts a value in a nested structure via the given `path`.
+
+  This is similar to `put_in/3`, except the path is extracted via
+  a macro rather than passing a list. For example:
+
+      put_in(opts[:foo][:bar], :baz)
+
+  Is equivalent to:
+
+      put_in(opts, [:foo, :bar], :baz)
+
+  This also works with nested structs and the `struct.path.to.value` way to specify
+  paths:
+
+      put_in(struct.foo.bar, :baz)
+
+  Note that in order for this macro to work, the complete path must always
+  be visible by this macro. For more information about the supported path
+  expressions, please check `get_and_update_in/2` docs.
 
   ## Examples
 
-      iex> unless(Enum.empty?([]), do: "Hello")
-      nil
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> put_in(users["john"][:age], 28)
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
-      iex> unless(Enum.empty?([1,2,3]), do: "Hello")
-      "Hello"
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> put_in(users["john"].age, 28)
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
   """
-  defmacro unless(clause, options) do
-    do_clause   = Keyword.get(options, :do, nil)
-    else_clause = Keyword.get(options, :else, nil)
-    quote do
-      if(unquote(clause), do: unquote(else_clause), else: unquote(do_clause))
+  defmacro put_in(path, value) do
+    case unnest(path, [], true, "put_in/2") do
+      {[h | t], true} ->
+        nest_map_update_in(h, t, quote(do: fn _ -> unquote(value) end))
+
+      {[h | t], false} ->
+        expr = nest_get_and_update_in(h, t, quote(do: fn _ -> {nil, unquote(value)} end))
+        quote(do: :erlang.element(2, unquote(expr)))
     end
   end
 
   @doc """
-  Allows you to destructure two lists, assigning each term in the right to the
-  matching term in the left. Unlike pattern matching via `=`, if the sizes of
-  the left and right lists don't match, destructuring simply stops instead of
-  raising an error.
+  Pops a key from the nested structure via the given `path`.
 
-  ## Examples
+  This is similar to `pop_in/2`, except the path is extracted via
+  a macro rather than passing a list. For example:
 
-      iex> destructure([x, y, z], [1, 2, 3, 4, 5])
-      iex> {x, y, z}
-      {1, 2, 3}
+      pop_in(opts[:foo][:bar])
+
+  Is equivalent to:
 
-  Notice in the example above, even though the right
-  size has more entries than the left, destructuring works
-  fine. If the right size is smaller, the remaining items
-  are simply assigned to nil:
+      pop_in(opts, [:foo, :bar])
 
-      iex> destructure([x, y, z], [1])
-      iex> {x, y, z}
-      {1, nil, nil}
+  Note that in order for this macro to work, the complete path must always
+  be visible by this macro. For more information about the supported path
+  expressions, please check `get_and_update_in/2` docs.
+
+  ## Examples
 
-  The left side supports any expression you would use
-  on the left side of a match:
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> pop_in(users["john"][:age])
+      {27, %{"john" => %{}, "meg" => %{age: 23}}}
 
-      x = 1
-      destructure([^x, y, z], [1, 2, 3])
+      iex> users = %{john: %{age: 27}, meg: %{age: 23}}
+      iex> pop_in(users.john[:age])
+      {27, %{john: %{}, meg: %{age: 23}}}
 
-  The example above will only work if x matches
-  the first value from the right side. Otherwise,
-  it will raise a CaseClauseError.
+  In case any entry returns `nil`, its key will be removed
+  and the deletion will be considered a success.
   """
-  defmacro destructure(left, right) when is_list(left) do
-    Enum.reduce left, right, fn item, acc ->
-      {:case, meta, args} =
-        quote do
-          case unquote(acc) do
-            [unquote(item)|t] ->
-              t
-            other when other == [] or other == nil ->
-              unquote(item) = nil
-          end
-        end
-      {:case, [{:export_head,true}|meta], args}
-    end
+  defmacro pop_in(path) do
+    {[h | t], _} = unnest(path, [], true, "pop_in/1")
+    nest_pop_in(:map, h, t)
   end
 
   @doc """
-  Returns a range with the specified start and end.
-  Includes both ends.
+  Updates a nested structure via the given `path`.
 
-  ## Examples
+  This is similar to `update_in/3`, except the path is extracted via
+  a macro rather than passing a list. For example:
 
-      iex> 0 in 1..3
-      false
+      update_in(opts[:foo][:bar], &(&1 + 1))
 
-      iex> 1 in 1..3
-      true
+  Is equivalent to:
 
-      iex> 2 in 1..3
-      true
+      update_in(opts, [:foo, :bar], &(&1 + 1))
 
-      iex> 3 in 1..3
-      true
+  This also works with nested structs and the `struct.path.to.value` way to specify
+  paths:
+
+      update_in(struct.foo.bar, &(&1 + 1))
+
+  Note that in order for this macro to work, the complete path must always
+  be visible by this macro. For more information about the supported path
+  expressions, please check `get_and_update_in/2` docs.
+
+  ## Examples
+
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> update_in(users["john"][:age], &(&1 + 1))
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
+
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> update_in(users["john"].age, &(&1 + 1))
+      %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
   """
-  defmacro first .. last do
-    {:%{}, [], [__struct__: Elixir.Range, first: first, last: last]}
+  defmacro update_in(path, fun) do
+    case unnest(path, [], true, "update_in/2") do
+      {[h | t], true} ->
+        nest_map_update_in(h, t, fun)
+
+      {[h | t], false} ->
+        expr = nest_get_and_update_in(h, t, quote(do: fn x -> {nil, unquote(fun).(x)} end))
+        quote(do: :erlang.element(2, unquote(expr)))
+    end
   end
 
   @doc """
-  Provides a short-circuit operator that evaluates and returns
-  the second expression only if the first one evaluates to true
-  (i.e. it is not nil nor false). Returns the first expression
-  otherwise.
+  Gets a value and updates a nested data structure via the given `path`.
+
+  This is similar to `get_and_update_in/3`, except the path is extracted
+  via a macro rather than passing a list. For example:
+
+      get_and_update_in(opts[:foo][:bar], &{&1, &1 + 1})
+
+  Is equivalent to:
+
+      get_and_update_in(opts, [:foo, :bar], &{&1, &1 + 1})
+
+  This also works with nested structs and the `struct.path.to.value` way to specify
+  paths:
+
+      get_and_update_in(struct.foo.bar, &{&1, &1 + 1})
+
+  Note that in order for this macro to work, the complete path must always
+  be visible by this macro. See the "Paths" section below.
 
   ## Examples
 
-      iex> Enum.empty?([]) && Enum.empty?([])
-      true
+      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      iex> get_and_update_in(users["john"].age, &{&1, &1 + 1})
+      {27, %{"john" => %{age: 28}, "meg" => %{age: 23}}}
 
-      iex> List.first([]) && true
-      nil
+  ## Paths
 
-      iex> Enum.empty?([]) && List.first([1])
-      1
+  A path may start with a variable, local or remote call, and must be
+  followed by one or more:
 
-      iex> false && throw(:bad)
-      false
+    * `foo[bar]` - accesses the key `bar` in `foo`; in case `foo` is nil,
+      `nil` is returned
+
+    * `foo.bar` - accesses a map/struct field; in case the field is not
+      present, an error is raised
+
+  Here are some valid paths:
+
+      users["john"][:age]
+      users["john"].age
+      User.all()["john"].age
+      all_users()["john"].age
+
+  Here are some invalid ones:
+
+      # Does a remote call after the initial value
+      users["john"].do_something(arg1, arg2)
+
+      # Does not access any key or field
+      users
 
-  Notice that, unlike Erlang's `and` operator,
-  this operator accepts any expression as an argument,
-  not only booleans, however it is not allowed in guards.
   """
-  defmacro left && right do
-    quote do
-      case unquote(left) do
-        x when x in [false, nil] ->
-          x
-        _ ->
-          unquote(right)
-      end
-    end
+  defmacro get_and_update_in(path, fun) do
+    {[h | t], _} = unnest(path, [], true, "get_and_update_in/2")
+    nest_get_and_update_in(h, t, fun)
   end
 
-  @doc """
-  Provides a short-circuit operator that evaluates and returns the second
-  expression only if the first one does not evaluate to true (i.e. it
-  is either nil or false). Returns the first expression otherwise.
+  defp nest_map_update_in([], fun), do: fun
 
-  ## Examples
+  defp nest_map_update_in(list, fun) do
+    quote do
+      fn x -> unquote(nest_map_update_in(quote(do: x), list, fun)) end
+    end
+  end
 
-      iex> Enum.empty?([1]) || Enum.empty?([1])
-      false
+  defp nest_map_update_in(h, [{:map, key} | t], fun) do
+    quote do
+      Map.update!(unquote(h), unquote(key), unquote(nest_map_update_in(t, fun)))
+    end
+  end
 
-      iex> List.first([]) || true
-      true
+  defp nest_get_and_update_in([], fun), do: fun
 
-      iex> Enum.empty?([1]) || 1
-      1
+  defp nest_get_and_update_in(list, fun) do
+    quote do
+      fn x -> unquote(nest_get_and_update_in(quote(do: x), list, fun)) end
+    end
+  end
 
-      iex> Enum.empty?([]) || throw(:bad)
-      true
+  defp nest_get_and_update_in(h, [{:access, key} | t], fun) do
+    quote do
+      Access.get_and_update(unquote(h), unquote(key), unquote(nest_get_and_update_in(t, fun)))
+    end
+  end
 
-  Notice that, unlike Erlang's `or` operator,
-  this operator accepts any expression as an argument,
-  not only booleans, however it is not allowed in guards.
-  """
-  defmacro left || right do
+  defp nest_get_and_update_in(h, [{:map, key} | t], fun) do
     quote do
-      case unquote(left) do
-        x when x in [false, nil] ->
-          unquote(right)
-        x ->
-          x
-      end
+      Map.get_and_update!(unquote(h), unquote(key), unquote(nest_get_and_update_in(t, fun)))
     end
   end
 
-  @doc """
-  `|>` is the pipe operator.
+  defp nest_pop_in(kind, list) do
+    quote do
+      fn x -> unquote(nest_pop_in(kind, quote(do: x), list)) end
+    end
+  end
 
-  This operator introduces the expression on the left as
-  the first argument to the function call on the right.
+  defp nest_pop_in(:map, h, [{:access, key}]) do
+    quote generated: true do
+      case unquote(h) do
+        nil -> {nil, nil}
+        h -> Access.pop(h, unquote(key))
+      end
+    end
+  end
 
-  ## Examples
+  defp nest_pop_in(_, _, [{:map, key}]) do
+    raise ArgumentError,
+          "cannot use pop_in when the last segment is a map/struct field. " <>
+            "This would effectively remove the field #{inspect(key)} from the map/struct"
+  end
 
-      iex> [1, [2], 3] |> List.flatten()
-      [1, 2, 3]
+  defp nest_pop_in(_, h, [{:map, key} | t]) do
+    quote do
+      Map.get_and_update!(unquote(h), unquote(key), unquote(nest_pop_in(:map, t)))
+    end
+  end
 
-  The example above is the same as calling `List.flatten([1, [2], 3])`,
-  i.e. the argument on the left side of `|>` is introduced as the first
-  argument of the function call on the right side.
+  defp nest_pop_in(_, h, [{:access, key}]) do
+    quote generated: true do
+      case unquote(h) do
+        nil -> :pop
+        h -> Access.pop(h, unquote(key))
+      end
+    end
+  end
 
-  This pattern is mostly useful when there is a desire to execute
-  a bunch of operations, resembling a pipeline:
+  defp nest_pop_in(_, h, [{:access, key} | t]) do
+    quote do
+      Access.get_and_update(unquote(h), unquote(key), unquote(nest_pop_in(:access, t)))
+    end
+  end
 
-      iex> [1, [2], 3] |> List.flatten |> Enum.map(fn x -> x * 2 end)
-      [2, 4, 6]
+  defp unnest({{:., _, [Access, :get]}, _, [expr, key]}, acc, _all_map?, kind) do
+    unnest(expr, [{:access, key} | acc], false, kind)
+  end
 
-  The example above will pass the list to `List.flatten/1`, then get
-  the flattened list and pass to `Enum.map/2`, which will multiply
-  each entry in the list per two.
+  defp unnest({{:., _, [expr, key]}, _, []}, acc, all_map?, kind)
+       when is_tuple(expr) and :erlang.element(1, expr) != :__aliases__ and
+              :erlang.element(1, expr) != :__MODULE__ do
+    unnest(expr, [{:map, key} | acc], all_map?, kind)
+  end
 
-  In other words, the expression above simply translates to:
+  defp unnest(other, [], _all_map?, kind) do
+    raise ArgumentError,
+          "expected expression given to #{kind} to access at least one element, " <>
+            "got: #{Macro.to_string(other)}"
+  end
 
-      Enum.map(List.flatten([1, [2], 3]), fn x -> x * 2 end)
+  defp unnest(other, acc, all_map?, kind) do
+    case proper_start?(other) do
+      true ->
+        {[other | acc], all_map?}
 
-  Beware of operator precedence when using the pipe operator.
-  For example, the following expression:
+      false ->
+        raise ArgumentError,
+              "expression given to #{kind} must start with a variable, local or remote call " <>
+                "and be followed by an element access, got: #{Macro.to_string(other)}"
+    end
+  end
 
-      String.graphemes "Hello" |> Enum.reverse
+  defp proper_start?({{:., _, [expr, _]}, _, _args})
+       when is_atom(expr)
+       when :erlang.element(1, expr) == :__aliases__
+       when :erlang.element(1, expr) == :__MODULE__,
+       do: true
 
-  Translates to:
+  defp proper_start?({atom, _, _args})
+       when is_atom(atom),
+       do: true
 
-      String.graphemes("Hello" |> Enum.reverse)
+  defp proper_start?(other), do: not is_tuple(other)
 
-  Which will result in an error as Enumerable protocol is not defined
-  for binaries. Adding explicit parenthesis resolves the ambiguity:
+  @doc """
+  Converts the argument to a string according to the
+  `String.Chars` protocol.
 
-      String.graphemes("Hello") |> Enum.reverse
+  This is invoked when there is string interpolation.
 
-  Or, even better:
+  ## Examples
 
-      "Hello" |> String.graphemes |> Enum.reverse
+      iex> to_string(:foo)
+      "foo"
 
   """
-  defmacro left |> right do
-    [{h, _}|t] = Macro.unpipe({:|>, [], [left, right]})
-    :lists.foldl fn {x, pos}, acc -> Macro.pipe(acc, x, pos) end, h, t
+  defmacro to_string(term) do
+    quote(do: :"Elixir.String.Chars".to_string(unquote(term)))
   end
 
   @doc """
-  Returns true if the `module` is loaded and contains a
-  public `function` with the given `arity`, otherwise false.
+  Converts the given term to a charlist according to the `List.Chars` protocol.
+
+  ## Examples
+
+      iex> to_charlist(:foo)
+      ~c"foo"
 
-  Notice that this function does not load the module in case
-  it is not loaded. Check `Code.ensure_loaded/1` for more
-  information.
   """
-  @spec function_exported?(atom | tuple, atom, integer) :: boolean
-  def function_exported?(module, function, arity) do
-    :erlang.function_exported(module, function, arity)
+  defmacro to_charlist(term) do
+    quote(do: :"Elixir.List.Chars".to_charlist(unquote(term)))
   end
 
   @doc """
-  Returns true if the `module` is loaded and contains a
-  public `macro` with the given `arity`, otherwise false.
+  Returns `true` if `term` is `nil`, `false` otherwise.
+
+  Allowed in guard clauses.
+
+  ## Examples
+
+      iex> is_nil(1 + 2)
+      false
+
+      iex> is_nil(nil)
+      true
 
-  Notice that this function does not load the module in case
-  it is not loaded. Check `Code.ensure_loaded/1` for more
-  information.
   """
-  @spec macro_exported?(atom, atom, integer) :: boolean
-  def macro_exported?(module, macro, arity) do
-    case :code.is_loaded(module) do
-      {:file, _} -> :lists.member({macro, arity}, module.__info__(:macros))
-      _ -> false
-    end
+  @doc guard: true
+  defmacro is_nil(term) do
+    quote(do: unquote(term) == nil)
   end
 
   @doc """
-  Access the given element using the qualifier according
-  to the `Access` protocol. All calls in the form `foo[bar]`
-  are translated to `access(foo, bar)`.
+  A convenience macro that checks if the result of `expression` matches `pattern`.
 
-  The usage of this protocol is to access a raw value in a
-  keyword list.
+  ## Examples
 
-      iex> sample = [a: 1, b: 2, c: 3]
-      iex> sample[:b]
-      2
+      iex> match?(1, 1)
+      true
+
+      iex> match?({1, _}, {1, 2})
+      true
+
+      iex> map = %{a: 1, b: 2}
+      iex> match?(%{a: _}, map)
+      true
+
+      iex> a = 1
+      iex> match?(^a, 1)
+      true
+
+  `match?/2` is very useful when filtering or finding a value in an enumerable:
+
+      iex> list = [a: 1, b: 2, a: 3]
+      iex> Enum.filter(list, &match?({:a, _}, &1))
+      [a: 1, a: 3]
+
+  Guard clauses can also be given to the match:
+
+      iex> list = [a: 1, b: 2, a: 3]
+      iex> Enum.filter(list, &match?({:a, x} when x < 2, &1))
+      [a: 1]
+
+  Variables assigned in the match will not be available outside of the
+  function call (unlike regular pattern matching with the `=` operator):
+
+      iex> match?(_x, 1)
+      true
+      iex> binding()
+      []
+
+  ## Values vs patterns
+
+  Remember the pin operator matches _values_, not _patterns_.
+  Passing a variable as the pattern will always return `true` and will
+  result in a warning that the variable is unused. Don't do this:
+
+      pattern = %{a: :a}
+      match?(pattern, %{b: :b})
+      #=> true
+
+  Similarly, moving an expression out the pattern may no longer preserve
+  its semantics. For example:
+
+      iex> match?([_ | _], [1, 2, 3])
+      true
+
+      pattern = [_ | _]
+      match?(pattern, [1, 2, 3])
+      ** (CompileError) invalid use of _. _ can only be used inside patterns to ignore values and cannot be used in expressions. Make sure you are inside a pattern or change it accordingly
+
+  Another example is that a map as a pattern performs a subset match, but not
+  once assigned to a variable:
+
+      iex> match?(%{x: 1}, %{x: 1, y: 2})
+      true
+
+      iex> attrs = %{x: 1}
+      iex> match?(^attrs, %{x: 1, y: 2})
+      false
+
+  The pin operator will check if the values are equal, using `===/2`, while
+  patterns have their own rules when matching maps, lists, and so forth.
+  Such behavior is not specific to `match?/2`. The following code also
+  throws an exception:
+
+      attrs = %{x: 1}
+      ^attrs = %{x: 1, y: 2}
+      #=> (MatchError) no match of right hand side value: %{x: 1, y: 2}
 
   """
+  defmacro match?(pattern, expression) do
+    success =
+      quote do
+        unquote(pattern) -> true
+      end
+
+    failure =
+      quote generated: true do
+        _ -> false
+      end
+
+    {:case, [], [expression, [do: success ++ failure]]}
+  end
+
+  @doc """
+  Module attribute unary operator.
+
+  Reads and writes attributes in the current module.
+
+  The canonical example for attributes is annotating that a module
+  implements an OTP behaviour, such as `GenServer`:
+
+      defmodule MyServer do
+        @behaviour GenServer
+        # ... callbacks ...
+      end
+
+  By default Elixir supports all the module attributes supported by Erlang, but
+  custom attributes can be used as well:
+
+      defmodule MyServer do
+        @my_data 13
+        IO.inspect(@my_data)
+        #=> 13
+      end
+
+  Unlike Erlang, such attributes are not stored in the module by default since
+  it is common in Elixir to use custom attributes to store temporary data that
+  will be available at compile-time. Custom attributes may be configured to
+  behave closer to Erlang by using `Module.register_attribute/3`.
+
+  > #### Prefixing module attributes {: .tip}
+  >
+  > Libraries and frameworks should consider prefixing any
+  > module attributes that are private by underscore, such as `@_my_data`,
+  > so code completion tools do not show them on suggestions and prompts.
+
+  Finally, note that attributes can also be read inside functions:
+
+      defmodule MyServer do
+        @my_data 11
+        def first_data, do: @my_data
+        @my_data 13
+        def second_data, do: @my_data
+      end
+
+      MyServer.first_data()
+      #=> 11
+
+      MyServer.second_data()
+      #=> 13
+
+  It is important to note that reading an attribute takes a snapshot of
+  its current value. In other words, the value is read at compilation
+  time and not at runtime. Check the `Module` module for other functions
+  to manipulate module attributes.
+
+  ## Attention! Multiple references of the same attribute
+
+  As mentioned above, every time you read a module attribute, a snapshot
+  of its current value is taken. Therefore, if you are storing large
+  values inside module attributes (for example, embedding external files
+  in module attributes), you should avoid referencing the same attribute
+  multiple times. For example, don't do this:
+
+      @files %{
+        example1: File.read!("lib/example1.data"),
+        example2: File.read!("lib/example2.data")
+      }
+
+      def example1, do: @files[:example1]
+      def example2, do: @files[:example2]
+
+  In the above, each reference to `@files` may end-up with a complete
+  and individual copy of the whole `@files` module attribute. Instead,
+  reference the module attribute once in a private function:
+
+      @files %{
+        example1: File.read!("lib/example1.data"),
+        example2: File.read!("lib/example2.data")
+      }
+
+      defp files(), do: @files
+      def example1, do: files()[:example1]
+      def example2, do: files()[:example2]
+
+  """
+  defmacro @expr
+
+  defmacro @{:__aliases__, _meta, _args} do
+    raise ArgumentError, "module attributes set via @ cannot start with an uppercase letter"
+  end
+
+  defmacro @{name, meta, args} do
+    assert_module_scope(__CALLER__, :@, 1)
+    function? = __CALLER__.function != nil
+
+    cond do
+      # Check for Macro as it is compiled later than Kernel
+      not bootstrapped?(Macro) ->
+        nil
+
+      not function? and (__CALLER__.context == :match or __CALLER__.context == :guard) ->
+        raise ArgumentError,
+              """
+              invalid usage of module attributes. Module attributes cannot be used inside \
+              pattern matching (and guards) outside of a function. If you are trying to \
+              define an attribute, do not do this:
+
+                  @foo = :value
+
+              Instead, do this:
+
+                  @foo :value
+              """
+
+      # Typespecs attributes are currently special cased by the compiler
+      is_list(args) and typespec?(name) ->
+        case bootstrapped?(Kernel.Typespec) do
+          false ->
+            :ok
+
+          true ->
+            pos = :elixir_module.cache_env(__CALLER__)
+            %{line: line, file: file, module: module} = __CALLER__
+
+            quote do
+              Kernel.Typespec.deftypespec(
+                unquote(name),
+                unquote(Macro.escape(hd(args), unquote: true)),
+                unquote(line),
+                unquote(file),
+                unquote(module),
+                unquote(pos)
+              )
+            end
+        end
+
+      true ->
+        do_at(args, meta, name, function?, __CALLER__)
+    end
+  end
+
+  # @attribute(value)
+  defp do_at([arg], meta, name, function?, env) do
+    line =
+      case :lists.keymember(:context, 1, meta) do
+        true -> nil
+        false -> env.line
+      end
+
+    cond do
+      function? ->
+        raise ArgumentError, "cannot set attribute @#{name} inside function/macro"
+
+      name == :behavior ->
+        raise ArgumentError, "@behavior attribute is not supported, please use @behaviour instead"
+
+      :lists.member(name, [:moduledoc, :typedoc, :doc]) ->
+        arg = {env.line, arg}
+
+        quote do
+          Module.__put_attribute__(__MODULE__, unquote(name), unquote(arg), unquote(line), [])
+        end
+
+      true ->
+        {arg, traces} = collect_traces(name, arg, env)
+
+        quote do
+          Module.__put_attribute__(
+            __MODULE__,
+            unquote(name),
+            unquote(arg),
+            unquote(line),
+            unquote(Macro.escape(traces))
+          )
+        end
+    end
+  end
+
+  # @attribute()
+  defp do_at([], meta, name, function?, env) do
+    IO.warn(
+      "the @#{name}() notation (with parentheses) is deprecated, please use @#{name} (without parentheses) instead",
+      env
+    )
+
+    do_at(nil, meta, name, function?, env)
+  end
+
+  # @attribute
+  defp do_at(args, _meta, name, function?, env) when is_atom(args) do
+    line = env.line
+    doc_attr? = :lists.member(name, [:moduledoc, :typedoc, :doc])
+
+    case function? do
+      true ->
+        case Module.__get_attribute__(env.module, name, line, false) do
+          {_, doc} when doc_attr? ->
+            do_at_escape(name, doc)
+
+          value ->
+            do_at_escape(name, value)
+        end
+
+      false when doc_attr? ->
+        quote do
+          case Module.__get_attribute__(__MODULE__, unquote(name), unquote(line), false) do
+            {_, doc} -> doc
+            value -> value
+          end
+        end
+
+      false ->
+        quote do
+          Module.__get_attribute__(__MODULE__, unquote(name), unquote(line), true)
+        end
+    end
+  end
+
+  # Error cases
+  defp do_at([{call, meta, ctx_or_args}, [{:do, _} | _] = kw], _meta, name, _function?, _env) do
+    args =
+      case is_atom(ctx_or_args) do
+        true -> []
+        false -> ctx_or_args
+      end
+
+    code = "\n@#{name} (#{Macro.to_string({call, meta, args ++ [kw]})})"
+
+    raise ArgumentError, """
+    expected 0 or 1 argument for @#{name}, got 2.
+
+    It seems you are trying to use the do-syntax with @module attributes \
+    but the do-block binds to the attribute name. You probably want \
+    to wrap the argument value in parentheses, like this:
+    #{String.replace(code, "\n", "\n    ")}
+    """
+  end
+
+  defp do_at(args, _meta, name, _function?, _env) do
+    raise ArgumentError, "expected 0 or 1 argument for @#{name}, got: #{length(args)}"
+  end
+
+  defp do_at_escape(name, value) do
+    try do
+      # mark module attrs as shallow-generated since the ast for their representation
+      # might contain opaque terms
+      Macro.escape(value, generated: true)
+    rescue
+      ex in [ArgumentError] ->
+        raise ArgumentError,
+              "cannot inject attribute @#{name} into function/macro because " <>
+                Exception.message(ex)
+    end
+  end
+
+  # Those are always compile-time dependencies, so we can skip the trace.
+  defp collect_traces(:before_compile, arg, _env), do: {arg, []}
+  defp collect_traces(:after_compile, arg, _env), do: {arg, []}
+  defp collect_traces(:after_verify, arg, _env), do: {arg, []}
+  defp collect_traces(:on_definition, arg, _env), do: {arg, []}
+
+  defp collect_traces(_name, arg, %{lexical_tracker: pid} = env) when is_pid(pid) do
+    env = %{env | function: {:__info__, 1}}
+
+    {arg, aliases} =
+      Macro.expand_literals(arg, %{}, fn
+        {:__aliases__, _, _} = alias, acc ->
+          case Macro.expand(alias, env) do
+            atom when is_atom(atom) -> {atom, Map.put(acc, atom, [])}
+            _ -> {alias, acc}
+          end
+
+        node, acc ->
+          {Macro.expand(node, env), acc}
+      end)
+
+    case map_size(aliases) do
+      0 -> {arg, []}
+      _ -> {arg, [{env.line, env.lexical_tracker, env.tracers, :maps.keys(aliases)}]}
+    end
+  end
+
+  defp collect_traces(_name, arg, _env) do
+    {arg, []}
+  end
+
+  defp typespec?(:type), do: true
+  defp typespec?(:typep), do: true
+  defp typespec?(:opaque), do: true
+  defp typespec?(:spec), do: true
+  defp typespec?(:callback), do: true
+  defp typespec?(:macrocallback), do: true
+  defp typespec?(_), do: false
+
+  @doc """
+  Returns the binding for the given context as a keyword list.
+
+  In the returned result, keys are variable names and values are the
+  corresponding variable values.
+
+  If the given `context` is `nil` (by default it is), the binding for the
+  current context is returned.
+
+  ## Examples
+
+      iex> x = 1
+      iex> binding()
+      [x: 1]
+      iex> x = 2
+      iex> binding()
+      [x: 2]
+
+      iex> binding(:foo)
+      []
+      iex> var!(x, :foo) = 1
+      1
+      iex> binding(:foo)
+      [x: 1]
+
+  """
+  defmacro binding(context \\ nil) do
+    in_match? = Macro.Env.in_match?(__CALLER__)
+
+    bindings =
+      for {v, c} <- Macro.Env.vars(__CALLER__), c == context do
+        {v, wrap_binding(in_match?, {v, [generated: true], c})}
+      end
+
+    :lists.usort(bindings)
+  end
+
+  defp wrap_binding(true, var) do
+    quote(do: ^unquote(var))
+  end
+
+  defp wrap_binding(_, var) do
+    var
+  end
+
+  @doc """
+  Provides an `if/2` macro.
+
+  This macro expects the first argument to be a condition and the second
+  argument to be a keyword list. Generally speaking, Elixir developers
+  prefer to use pattern matching and guards in function definitions and
+  `case/2`, as they are succinct and precise. However, not all conditions
+  can be expressed through patterns and guards, which makes `if/2` a viable
+  alternative.
+
+  Similar to `case/2`, any assignment in the condition will be available
+  on both clauses, as well as after the `if` expression.
+
+  ## One-liner examples
+
+      iex> if 7 > 5, do: "yes"
+      "yes"
+
+      iex> if "truthy value", do: "yes"
+      "yes"
+
+  In the examples above, the `do` clause is evaluated and `"yes"` will be returned
+  because the condition evaluates to a truthy value (neither `false` nor `nil`).
+  Otherwise, the clause is not evaluated and `nil` will be returned:
+
+      iex> if 3 > 5, do: "yes"
+      nil
+
+      iex> if nil, do: IO.puts("this won't be printed")
+      nil
+
+  An `else` option can be given to specify the opposite:
+
+      iex> if 3 > 5, do: "yes", else: "no"
+      "no"
+
+  ## Blocks examples
+
+  It's also possible to pass a block to the `if/2` macro. The first
+  example above would be translated to:
+
+      iex> if 7 > 5 do
+      ...>   "yes"
+      ...> end
+      "yes"
+
+  Note that `do`-`end` become delimiters. The third example would
+  translate to:
+
+      iex> if 3 > 5 do
+      ...>   "yes"
+      ...> else
+      ...>   "no"
+      ...> end
+      "no"
+
+  If you find yourself nesting conditionals inside conditionals,
+  consider using `cond/1`.
+
+  ## Variables scope
+
+  Variables set within `do`/`else` blocks do not leak to the outer context:
+
+      x = 1
+      if x > 0 do
+        x = x + 1
+        IO.puts(x)  # prints 2
+      end
+      x  # 1
+
+  Variables set in the condition are available in the outer context:
+
+      fruits = %{oranges: 3}
+      if count = fruits[:apples] do
+        # won't be evaluated
+        IO.puts(count + 1)
+      end
+      count  # nil
+
+  """
+  defmacro if(condition, clauses) do
+    build_if(condition, clauses)
+  end
+
+  defp build_if(condition, do: do_clause) do
+    build_if(condition, do: do_clause, else: nil)
+  end
+
+  defp build_if(condition, do: do_clause, else: else_clause) do
+    annotate_case(
+      [optimize_boolean: true, type_check: :expr],
+      quote do
+        case unquote(condition) do
+          x when :"Elixir.Kernel".in(x, [false, nil]) -> unquote(else_clause)
+          _ -> unquote(do_clause)
+        end
+      end
+    )
+  end
+
+  defp build_if(_condition, _arguments) do
+    raise ArgumentError,
+          "invalid or duplicate keys for if, only \"do\" and an optional \"else\" are permitted"
+  end
+
+  @doc """
+  Provides an `unless` macro.
+
+  This macro evaluates and returns the `do` block passed in as the second
+  argument if `condition` evaluates to a falsy value (`false` or `nil`).
+  Otherwise, it returns the value of the `else` block if present or `nil` if not.
+
+  See also `if/2`.
+
+  ## Examples
+
+      iex> unless(Enum.empty?([]), do: "Hello")
+      nil
+
+      iex> unless(Enum.empty?([1, 2, 3]), do: "Hello")
+      "Hello"
+
+      iex> unless Enum.sum([2, 2]) == 5 do
+      ...>   "Math still works"
+      ...> else
+      ...>   "Math is broken"
+      ...> end
+      "Math still works"
+
+  """
+  # TODO: Deprecate this on Elixir v1.22.
+  @doc deprecated: "Use if/2 instead"
+  defmacro unless(condition, clauses) do
+    build_unless(condition, clauses)
+  end
+
+  defp build_unless(condition, do: do_clause) do
+    build_unless(condition, do: do_clause, else: nil)
+  end
+
+  defp build_unless(condition, do: do_clause, else: else_clause) do
+    quote do
+      if(unquote(condition), do: unquote(else_clause), else: unquote(do_clause))
+    end
+  end
+
+  defp build_unless(_condition, _arguments) do
+    raise ArgumentError,
+          "invalid or duplicate keys for unless, " <>
+            "only \"do\" and an optional \"else\" are permitted"
+  end
+
+  @doc """
+  Destructures two lists, assigning each term in the
+  right one to the matching term in the left one.
+
+  Unlike pattern matching via `=`, if the sizes of the left
+  and right lists don't match, destructuring simply stops
+  instead of raising an error.
+
+  ## Examples
+
+      iex> destructure([x, y, z], [1, 2, 3, 4, 5])
+      iex> {x, y, z}
+      {1, 2, 3}
+
+  In the example above, even though the right list has more entries than the
+  left one, destructuring works fine. If the right list is smaller, the
+  remaining elements are simply set to `nil`:
+
+      iex> destructure([x, y, z], [1])
+      iex> {x, y, z}
+      {1, nil, nil}
+
+  The left-hand side supports any expression you would use
+  on the left-hand side of a match:
+
+      iex> x = 1
+      iex> destructure([^x, y, z], [1, 2, 3])
+      iex> {x, y, z}
+      {1, 2, 3}
+
+  The example above will only work if `x` matches the first value in the right
+  list. Otherwise, it will raise a `MatchError` (like the `=` operator would
+  do).
+  """
+  defmacro destructure(left, right) when is_list(left) do
+    quote do
+      unquote(left) = Kernel.Utils.destructure(unquote(right), unquote(length(left)))
+    end
+  end
+
+  @doc """
+  Creates a range from `first` to `last`.
+
+  If first is less than last, the range will be increasing from
+  first to last. If first is equal to last, the range will contain
+  one element, which is the number itself.
+
+  If first is more than last, the range will be decreasing from first
+  to last, albeit this behavior is deprecated. Instead prefer to
+  explicitly list the step with `first..last//-1`.
+
+  See the `Range` module for more information.
+
+  ## Examples
+
+      iex> 0 in 1..3
+      false
+      iex> 2 in 1..3
+      true
+
+      iex> Enum.to_list(1..3)
+      [1, 2, 3]
+
+  """
+  defmacro first..last do
+    case bootstrapped?(Macro) do
+      true ->
+        first = Macro.expand(first, __CALLER__)
+        last = Macro.expand(last, __CALLER__)
+        validate_range!(first, last)
+        stepless_range(__CALLER__.context, first, last, __CALLER__)
+
+      false ->
+        stepless_range(__CALLER__.context, first, last, __CALLER__)
+    end
+  end
+
+  defp stepless_range(_context, first, last, caller)
+       when is_integer(first) and is_integer(last) do
+    step =
+      if first <= last do
+        1
+      else
+        # TODO: Always use 1 as an step in Elixir v2.0
+        IO.warn(
+          "#{first}..#{last} has a default step of -1, please write #{first}..#{last}//-1 instead",
+          Macro.Env.stacktrace(caller)
+        )
+
+        -1
+      end
+
+    {:%, [], [Elixir.Range, {:%{}, [], [first: first, last: last, step: step]}]}
+  end
+
+  defp stepless_range(nil, first, last, _caller) do
+    quote(do: Elixir.Range.new(unquote(first), unquote(last)))
+  end
+
+  defp stepless_range(:guard, first, last, caller) do
+    # We need to compute the step using guards. We don't have conditionals,
+    # but we can emulate them using a map access.
+    step =
+      quote do
+        :erlang.map_get(
+          :erlang.>(unquote(first), unquote(last)),
+          %{false: unquote(1), true: unquote(-1)}
+        )
+      end
+
+    # TODO: Always assume step 1 in Elixir v2.0
+    range = "#{Macro.to_string(first)}..#{Macro.to_string(last)}"
+
+    IO.warn(
+      "#{range} inside guards requires an explicit step, please write #{range}//1 or #{range}//-1 instead",
+      Macro.Env.stacktrace(caller)
+    )
+
+    {:%, [], [Elixir.Range, {:%{}, [], [first: first, last: last, step: step]}]}
+  end
+
+  defp stepless_range(:match, first, last, caller) do
+    # TODO: Make me an error in Elixir v2.0
+    range = "#{Macro.to_string(first)}..#{Macro.to_string(last)}"
+
+    IO.warn(
+      "#{range} inside match is deprecated, " <>
+        "you must always match on the step: #{range}//var or #{range}//_ if you want to ignore it",
+      Macro.Env.stacktrace(caller)
+    )
+
+    {:%, [], [Elixir.Range, {:%{}, [], [first: first, last: last]}]}
+  end
+
+  @doc """
+  Creates a range from `first` to `last` with `step`.
+
+  See the `Range` module for more information.
+
+  ## Examples
+
+      iex> 0 in 1..3//1
+      false
+      iex> 2 in 1..3//1
+      true
+      iex> 2 in 1..3//2
+      false
+
+      iex> Enum.to_list(1..3//1)
+      [1, 2, 3]
+      iex> Enum.to_list(1..3//2)
+      [1, 3]
+      iex> Enum.to_list(3..1//-1)
+      [3, 2, 1]
+      iex> Enum.to_list(1..0//1)
+      []
+
+  """
+  @doc since: "1.12.0"
+  defmacro first..last//step do
+    case bootstrapped?(Macro) do
+      true ->
+        first = Macro.expand(first, __CALLER__)
+        last = Macro.expand(last, __CALLER__)
+        step = Macro.expand(step, __CALLER__)
+        validate_range!(first, last)
+        validate_step!(step)
+        range(__CALLER__.context, first, last, step)
+
+      false ->
+        {:%{}, [], [__struct__: Elixir.Range, first: first, last: last, step: step]}
+    end
+  end
+
+  defp range(context, first, last, step)
+       when is_integer(first) and is_integer(last) and is_integer(step)
+       when context != nil do
+    {:%, [], [Elixir.Range, {:%{}, [], [first: first, last: last, step: step]}]}
+  end
+
+  defp range(nil, first, last, step) do
+    quote(do: Elixir.Range.new(unquote(first), unquote(last), unquote(step)))
+  end
+
+  defp validate_range!(first, last)
+       when is_float(first) or is_float(last) or is_atom(first) or is_atom(last) or
+              is_binary(first) or is_binary(last) or is_list(first) or is_list(last) do
+    raise ArgumentError,
+          "ranges (first..last//step) expect both sides to be integers, " <>
+            "got: #{Macro.to_string({:.., [], [first, last]})}"
+  end
+
+  defp validate_range!(_, _), do: :ok
+
+  defp validate_step!(step)
+       when is_float(step) or is_atom(step) or is_binary(step) or is_list(step) or step == 0 do
+    raise ArgumentError,
+          "ranges (first..last//step) expect the step to be a non-zero integer, " <>
+            "got: #{Macro.to_string(step)}"
+  end
+
+  defp validate_step!(_), do: :ok
+
+  @doc """
+  Creates the full-slice range `0..-1//1`.
+
+  This macro returns a range with the following properties:
+
+    * When enumerated, it is empty
+
+    * When used as a `slice`, it returns the sliced element as is
+
+  See `..///3` and the `Range` module for more information.
+
+  ## Examples
+
+      iex> Enum.to_list(..)
+      []
+
+      iex> String.slice("Hello world!", ..)
+      "Hello world!"
+
+  """
+  @doc since: "1.14.0"
+  defmacro (..) do
+    range(__CALLER__.context, 0, -1, 1)
+  end
+
+  @doc """
+  Boolean "and" operator.
+
+  Provides a short-circuit operator that evaluates and returns
+  the second expression only if the first one evaluates to a truthy value
+  (neither `false` nor `nil`). Returns the first expression
+  otherwise.
+
+  Not allowed in guard clauses.
+
+  ## Examples
+
+      iex> Enum.empty?([]) && Enum.empty?([])
+      true
+
+      iex> List.first([]) && true
+      nil
+
+      iex> Enum.empty?([]) && List.first([1])
+      1
+
+      iex> false && throw(:bad)
+      false
+
+  Note that, unlike `and/2`, this operator accepts any expression
+  as the first argument, not only booleans.
+  """
+  defmacro left && right do
+    assert_no_match_or_guard_scope(__CALLER__.context, "&&")
+
+    annotate_case(
+      [type_check: :expr],
+      quote do
+        case unquote(left) do
+          x when :"Elixir.Kernel".in(x, [false, nil]) ->
+            x
+
+          _ ->
+            unquote(right)
+        end
+      end
+    )
+  end
+
+  @doc """
+  Boolean "or" operator.
+
+  Provides a short-circuit operator that evaluates and returns the second
+  expression only if the first one does not evaluate to a truthy value (that is,
+  it is either `nil` or `false`). Returns the first expression otherwise.
+
+  Not allowed in guard clauses.
+
+  ## Examples
+
+      iex> Enum.empty?([1]) || Enum.empty?([1])
+      false
+
+      iex> List.first([]) || true
+      true
+
+      iex> Enum.empty?([1]) || 1
+      1
+
+      iex> Enum.empty?([]) || throw(:bad)
+      true
+
+  Note that, unlike `or/2`, this operator accepts any expression
+  as the first argument, not only booleans.
+  """
+  defmacro left || right do
+    assert_no_match_or_guard_scope(__CALLER__.context, "||")
+
+    annotate_case(
+      [type_check: :expr],
+      quote do
+        case unquote(left) do
+          x when :"Elixir.Kernel".in(x, [false, nil]) ->
+            unquote(right)
+
+          x ->
+            x
+        end
+      end
+    )
+  end
+
+  @doc """
+  Pipe operator.
+
+  This operator introduces the expression on the left-hand side as
+  the first argument to the function call on the right-hand side.
+
+  ## Examples
+
+      iex> [1, [2], 3] |> List.flatten()
+      [1, 2, 3]
+
+  The example above is the same as calling `List.flatten([1, [2], 3])`.
+
+  The `|>/2` operator is mostly useful when there is a desire to execute a series
+  of operations resembling a pipeline:
+
+      iex> [1, [2], 3] |> List.flatten() |> Enum.map(fn x -> x * 2 end)
+      [2, 4, 6]
+
+  In the example above, the list `[1, [2], 3]` is passed as the first argument
+  to the `List.flatten/1` function, then the flattened list is passed as the
+  first argument to the `Enum.map/2` function which doubles each element of the
+  list.
+
+  In other words, the expression above simply translates to:
+
+      Enum.map(List.flatten([1, [2], 3]), fn x -> x * 2 end)
+
+  ## Pitfalls
+
+  There are two common pitfalls when using the pipe operator.
+
+  The first one is related to operator precedence. For example,
+  the following expression:
+
+      String.graphemes "Hello" |> Enum.reverse
+
+  Translates to:
+
+      String.graphemes("Hello" |> Enum.reverse())
+
+  which results in an error as the `Enumerable` protocol is not defined
+  for binaries. Adding explicit parentheses resolves the ambiguity:
+
+      String.graphemes("Hello") |> Enum.reverse()
+
+  Or, even better:
+
+      "Hello" |> String.graphemes() |> Enum.reverse()
+
+  The second limitation is that Elixir always pipes to a function
+  call. Therefore, to pipe into an anonymous function, you need to
+  invoke it:
+
+      iex> some_fun = &Regex.replace(~r/l/, &1, "L")
+      iex> "Hello" |> some_fun.()
+      "HeLLo"
+
+  Alternatively, you can use `then/2` for the same effect:
+
+      iex> some_fun = &Regex.replace(~r/l/, &1, "L")
+      iex> "Hello" |> then(some_fun)
+      "HeLLo"
+
+  `then/2` is most commonly used when you want to pipe to a function
+  but the value is expected outside of the first argument, such as
+  above. By replacing `some_fun` by its value, we get:
+
+      iex> "Hello" |> then(&Regex.replace(~r/l/, &1, "L"))
+      "HeLLo"
+  """
+  defmacro left |> right do
+    fun = fn {x, pos}, acc ->
+      Macro.pipe(acc, x, pos)
+    end
+
+    :lists.foldl(fun, left, Macro.unpipe(right))
+  end
+
+  @doc """
+  Returns `true` if `module` is loaded and contains a
+  public `function` with the given `arity`, otherwise `false`.
+
+  > ### Unloaded modules {: .warning}
+  >
+  > This function does *not* load the module in case it is not loaded
+  > and Elixir lazily loads modules by default (except on releases).
+  >
+  > This may lead to unexpected behaviour as the result of this function
+  > may depend if another code has happened to load the given module
+  > as argument beforehand. For example, this could manifest in `mix test`
+  > by having tests that fail when running in isolation or depending on the
+  > test seed. For those reasons, it is recommended to always check for
+  > `Code.ensure_loaded?/1` before `function_exported?/3`, unless you are
+  > certain the module has been loaded before.
+  >
+  > See `Code.ensure_loaded/1` for more information.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Code.ensure_loaded?(Enum) and function_exported?(Enum, :map, 2)
+      true
+
+      iex> Code.ensure_loaded?(Enum) and function_exported?(Enum, :map, 10)
+      false
+
+      iex> Code.ensure_loaded?(List) and function_exported?(List, :to_string, 1)
+      true
+  """
+  @spec function_exported?(module, atom, arity) :: boolean
+  def function_exported?(module, function, arity) do
+    :erlang.function_exported(module, function, arity)
+  end
+
+  @doc """
+  Returns `true` if `module` is loaded and contains a
+  public `macro` with the given `arity`, otherwise `false`.
+
+  Note that this function does not load the module in case
+  it is not loaded. See the notes under `function_exported?/3`
+  for more information.
+
+  If `module` is an Erlang module (as opposed to an Elixir module), this
+  function always returns `false`.
+
+  ## Examples
+
+      iex> Code.ensure_loaded?(Kernel) and macro_exported?(Kernel, :use, 2)
+      true
+
+      iex> Code.ensure_loaded?(:erlang) and macro_exported?(:erlang, :abs, 1)
+      false
+
+  """
+  @spec macro_exported?(module, atom, arity) :: boolean
+  def macro_exported?(module, macro, arity)
+      when is_atom(module) and is_atom(macro) and is_integer(arity) and
+             (arity >= 0 and arity <= 255) do
+    function_exported?(module, :__info__, 1) and
+      :lists.member({macro, arity}, module.__info__(:macros))
+  end
+
+  @doc """
+  Power operator.
+
+  It takes two numbers for input. If both are integers and the right-hand
+  side (the `exponent`) is also greater than or equal to 0, then the result
+  will also be an integer. Otherwise it returns a float.
+
+  ## Examples
+
+      iex> 2 ** 2
+      4
+      iex> 2 ** -4
+      0.0625
+
+      iex> 2.0 ** 2
+      4.0
+      iex> 2 ** 2.0
+      4.0
+
+  """
+  @doc since: "1.13.0"
+  @spec integer ** non_neg_integer :: integer
+  @spec integer ** neg_integer :: float
+  @spec float ** float :: float
+  @spec integer ** float :: float
+  @spec float ** integer :: float
+  def base ** exponent when is_integer(base) and is_integer(exponent) and exponent >= 0 do
+    integer_pow(base, 1, exponent)
+  end
+
+  def base ** exponent when is_number(base) and is_number(exponent) do
+    :math.pow(base, exponent)
+  end
+
+  # https://en.wikipedia.org/wiki/Exponentiation_by_squaring
+  defp integer_pow(_, _, 0),
+    do: 1
+
+  defp integer_pow(b, a, 1),
+    do: b * a
+
+  defp integer_pow(b, a, e) when :erlang.band(e, 1) == 0,
+    do: integer_pow(b * b, a, :erlang.bsr(e, 1))
+
+  defp integer_pow(b, a, e),
+    do: integer_pow(b * b, a * b, :erlang.bsr(e, 1))
+
+  @doc """
+  Membership operator.
+
+  Checks if the element on the left-hand side is a member of the
+  collection on the right-hand side.
+
+  ## Examples
+
+      iex> x = 1
+      iex> x in [1, 2, 3]
+      true
+
+  This operator (which is a macro) simply translates to a call to
+  `Enum.member?/2`. The example above would translate to:
+
+      Enum.member?([1, 2, 3], x)
+
+  Elixir also supports `left not in right`, which evaluates to
+  `not(left in right)`:
+
+      iex> x = 1
+      iex> x not in [1, 2, 3]
+      false
+
+  ## Guards
+
+  The `in/2` operator (as well as `not in`) can be used in guard clauses as
+  long as the right-hand side is a range or a list.
+
+  If the right-hand side is a list, Elixir will expand the operator to a valid
+  guard expression which needs to check each value. For example:
+
+      when x in [1, 2, 3]
+
+  translates to:
+
+      when x === 1 or x === 2 or x === 3
+
+  However, this construct will be inefficient for large lists. In such cases, it
+  is best to stop using guards and use a more appropriate data structure, such
+  as `MapSet`.
+
+  If the right-hand side is a range, a more efficient comparison check will be
+  done. For example:
+
+      when x in 1..1000
+
+  translates roughly to:
+
+      when x >= 1 and x <= 1000
+
+  ### AST considerations
+
+  `left not in right` is parsed by the compiler into the AST:
+
+      {:not, _, [{:in, _, [left, right]}]}
+
+  This is the same AST as `not(left in right)`.
+
+  Additionally, `Macro.to_string/2` and `Code.format_string!/2`
+  will translate all occurrences of this AST to `left not in right`.
+  """
+  @doc guard: true
+  defmacro left in right do
+    in_body? = __CALLER__.context == nil
+
+    expand =
+      case bootstrapped?(Macro) do
+        true -> &Macro.expand(&1, __CALLER__)
+        false -> & &1
+      end
+
+    case expand.(right) do
+      [] when not in_body? ->
+        false
+
+      [] ->
+        quote do
+          _ = unquote(left)
+          false
+        end
+
+      [head | tail] = list ->
+        # We only expand lists in the body if they are relatively
+        # short and it is made only of literal expressions.
+        case not in_body? or small_literal_list?(right) do
+          true -> in_var(in_body?, left, &in_list(&1, head, tail, expand, list, in_body?))
+          false -> quote(do: :lists.member(unquote(left), unquote(right)))
+        end
+
+      %{} = right ->
+        raise ArgumentError, "found unescaped value on the right side of in/2: #{inspect(right)}"
+
+      right ->
+        case range_fields(right) do
+          [first: first, last: last, step: step] ->
+            in_var(in_body?, left, &in_range(&1, expand.(first), expand.(last), expand.(step)))
+
+          _ when in_body? ->
+            quote(do: Elixir.Enum.member?(unquote(right), unquote(left)))
+
+          _ ->
+            raise_on_invalid_args_in_2(right)
+        end
+    end
+  end
+
+  defp range_fields({:%, _, [Elixir.Range, {:%{}, _, fields}]}), do: :lists.usort(fields)
+  defp range_fields({:%{}, _, [__struct__: Elixir.Range] ++ fields}), do: :lists.usort(fields)
+  defp range_fields(_), do: []
+
+  defp raise_on_invalid_args_in_2(right) do
+    raise ArgumentError, <<
+      "invalid right argument for operator \"in\", it expects a compile-time proper list ",
+      "or compile-time range on the right side when used in guard expressions, got: ",
+      Macro.to_string(right)::binary
+    >>
+  end
+
+  defp in_var(false, ast, fun), do: fun.(ast)
+
+  defp in_var(true, {atom, _, context} = var, fun) when is_atom(atom) and is_atom(context),
+    do: fun.(var)
+
+  defp in_var(true, var, fun) when is_atom(var) or is_binary(var) or is_number(var),
+    do: fun.(var)
+
+  defp in_var(true, ast, fun) do
+    quote do
+      var = unquote(ast)
+      unquote(fun.(quote(do: var)))
+    end
+  end
+
+  defp small_literal_list?(list) when is_list(list) and length(list) <= 32 do
+    :lists.all(fn x -> is_binary(x) or is_atom(x) or is_number(x) end, list)
+  end
+
+  defp small_literal_list?(_list), do: false
+
+  defp in_range(left, first, last, step) when is_integer(step) do
+    in_range_literal(left, first, last, step)
+  end
+
+  defp in_range(left, first, last, step) do
+    quoted =
+      quote do
+        :erlang.is_integer(unquote(left)) and :erlang.is_integer(unquote(first)) and
+          :erlang.is_integer(unquote(last)) and
+          ((:erlang.>(unquote(step), 0) and
+              unquote(increasing_compare(left, first, last))) or
+             (:erlang.<(unquote(step), 0) and
+                unquote(decreasing_compare(left, first, last))))
+      end
+
+    in_range_step(quoted, left, first, step)
+  end
+
+  defp in_range_literal(left, first, first, _step) when is_integer(first) do
+    quote do: :erlang."=:="(unquote(left), unquote(first))
+  end
+
+  defp in_range_literal(left, first, last, step) when step > 0 do
+    quoted =
+      quote do
+        :erlang.andalso(
+          :erlang.is_integer(unquote(left)),
+          unquote(increasing_compare(left, first, last))
+        )
+      end
+
+    in_range_step(quoted, left, first, step)
+  end
+
+  defp in_range_literal(left, first, last, step) when step < 0 do
+    quoted =
+      quote do
+        :erlang.andalso(
+          :erlang.is_integer(unquote(left)),
+          unquote(decreasing_compare(left, first, last))
+        )
+      end
+
+    in_range_step(quoted, left, first, step)
+  end
+
+  defp in_range_step(quoted, _left, _first, step) when step == 1 or step == -1 do
+    quoted
+  end
+
+  defp in_range_step(quoted, left, first, step) do
+    quote do
+      :erlang.andalso(
+        unquote(quoted),
+        :erlang."=:="(:erlang.rem(unquote(left) - unquote(first), unquote(step)), 0)
+      )
+    end
+  end
+
+  defp in_list(left, head, tail, expand, right, in_body?) do
+    [head | tail] = :lists.map(&comp(left, &1, expand, right, in_body?), [head | tail])
+    :lists.foldl(&quote(do: :erlang.orelse(unquote(&2), unquote(&1))), head, tail)
+  end
+
+  defp comp(left, {:|, _, [head, tail]}, expand, right, in_body?) do
+    case expand.(tail) do
+      [] ->
+        quote(do: :erlang."=:="(unquote(left), unquote(head)))
+
+      [tail_head | tail] ->
+        quote do
+          :erlang.orelse(
+            :erlang."=:="(unquote(left), unquote(head)),
+            unquote(in_list(left, tail_head, tail, expand, right, in_body?))
+          )
+        end
+
+      tail when in_body? ->
+        quote do
+          :erlang.orelse(
+            :erlang."=:="(unquote(left), unquote(head)),
+            :lists.member(unquote(left), unquote(tail))
+          )
+        end
+
+      _ ->
+        raise_on_invalid_args_in_2(right)
+    end
+  end
+
+  defp comp(left, right, _expand, _right, _in_body?) do
+    quote(do: :erlang."=:="(unquote(left), unquote(right)))
+  end
+
+  defp increasing_compare(var, first, last) do
+    quote do
+      :erlang.andalso(
+        :erlang.>=(unquote(var), unquote(first)),
+        :erlang."=<"(unquote(var), unquote(last))
+      )
+    end
+  end
+
+  defp decreasing_compare(var, first, last) do
+    quote do
+      :erlang.andalso(
+        :erlang."=<"(unquote(var), unquote(first)),
+        :erlang.>=(unquote(var), unquote(last))
+      )
+    end
+  end
+
+  @doc """
+  Marks that the given variable should not be hygienized.
+
+  This macro expects a variable and it is typically invoked
+  inside `quote/2` to mark that a variable
+  should not be hygienized. See `quote/2` for more information.
+
+  ## Examples
+
+      iex> Kernel.var!(example) = 1
+      1
+      iex> Kernel.var!(example)
+      1
+
+  """
+  defmacro var!(var, context \\ nil)
+
+  defmacro var!({name, meta, atom}, context) when is_atom(name) and is_atom(atom) do
+    # Remove counter and force them to be vars
+    meta = :lists.keydelete(:counter, 1, meta)
+    meta = :lists.keystore(:if_undefined, 1, meta, {:if_undefined, :raise})
+
+    case Macro.expand(context, __CALLER__) do
+      context when is_atom(context) ->
+        {name, meta, context}
+
+      other ->
+        raise ArgumentError,
+              "expected var! context to expand to an atom, got: #{Macro.to_string(other)}"
+    end
+  end
+
+  defmacro var!(other, _context) do
+    raise ArgumentError, "expected a variable to be given to var!, got: #{Macro.to_string(other)}"
+  end
+
+  @doc """
+  When used inside quoting, marks that the given alias should not
+  be hygienized. This means the alias will be expanded when
+  the macro is expanded.
+
+  Check `quote/2` for more information.
+  """
+  defmacro alias!(alias) when is_atom(alias) do
+    alias
+  end
+
+  defmacro alias!({:__aliases__, meta, args}) do
+    # Simply remove the alias metadata from the node
+    # so it does not affect expansion.
+    {:__aliases__, :lists.keydelete(:alias, 1, meta), args}
+  end
+
+  @doc """
+  Returns a binary starting at the offset `start` and of the given `size`.
+
+  This is similar to `binary_part/3` except that if `start + size`
+  is greater than the binary size, it automatically clips it to
+  the binary size instead of raising. Opposite to `binary_part/3`,
+  this function is not allowed in guards.
+
+  This function works with bytes. For a slicing operation that
+  considers characters, see `String.slice/3`.
+
+  ## Examples
+
+      iex> binary_slice("elixir", 0, 6)
+      "elixir"
+      iex> binary_slice("elixir", 0, 5)
+      "elixi"
+      iex> binary_slice("elixir", 1, 4)
+      "lixi"
+      iex> binary_slice("elixir", 0, 10)
+      "elixir"
+
+  If `start` is negative, it is normalized against the binary
+  size and clamped to 0:
+
+      iex> binary_slice("elixir", -3, 10)
+      "xir"
+      iex> binary_slice("elixir", -10, 10)
+      "elixir"
+
+  If the `size` is zero, an empty binary is returned:
+
+      iex> binary_slice("elixir", 1, 0)
+      ""
+
+  If `start` is greater than or equal to the binary size,
+  an empty binary is returned:
+
+      iex> binary_slice("elixir", 10, 10)
+      ""
+
+  """
+  @doc since: "1.14.0"
+  def binary_slice(binary, start, size)
+      when is_binary(binary) and is_integer(start) and is_integer(size) and size >= 0 do
+    total = byte_size(binary)
+    start = if start < 0, do: max(total + start, 0), else: start
+
+    case start < total do
+      true -> :erlang.binary_part(binary, start, min(size, total - start))
+      false -> ""
+    end
+  end
+
+  @doc """
+  Returns a binary from the offset given by the start of the
+  range to the offset given by the end of the range.
+
+  If the start or end of the range are negative, they are converted
+  into positive indices based on the binary size. For example,
+  `-1` means the last byte of the binary.
+
+  This is similar to `binary_part/3` except that it works with ranges
+  and it is not allowed in guards.
+
+  This function works with bytes. For a slicing operation that
+  considers characters, see `String.slice/2`.
+
+  ## Examples
+
+      iex> binary_slice("elixir", 0..5)
+      "elixir"
+      iex> binary_slice("elixir", 1..3)
+      "lix"
+      iex> binary_slice("elixir", 1..10)
+      "lixir"
+
+      iex> binary_slice("elixir", -4..-1)
+      "ixir"
+      iex> binary_slice("elixir", -4..6)
+      "ixir"
+      iex> binary_slice("elixir", -10..10)
+      "elixir"
+
+  For ranges where `start > stop`, you need to explicitly
+  mark them as increasing:
+
+      iex> binary_slice("elixir", 2..-1//1)
+      "ixir"
+      iex> binary_slice("elixir", 1..-2//1)
+      "lixi"
+
+  You can use `../0` as a shortcut for `0..-1//1`, which returns
+  the whole binary as is:
+
+      iex> binary_slice("elixir", ..)
+      "elixir"
+
+  The step can be any positive number. For example, to
+  get every 2 characters of the binary:
+
+      iex> binary_slice("elixir", 0..-1//2)
+      "eii"
+
+  If the first position is after the string ends or after
+  the last position of the range, it returns an empty string:
+
+      iex> binary_slice("elixir", 10..3//1)
+      ""
+      iex> binary_slice("elixir", -10..-7)
+      ""
+      iex> binary_slice("a", 1..1500)
+      ""
+
+  """
+  @doc since: "1.14.0"
+  def binary_slice(binary, first..last//step)
+      when is_binary(binary) and step > 0 do
+    total = byte_size(binary)
+
+    first = if first < 0, do: max(first + total, 0), else: first
+    last = if last < 0, do: last + total, else: last
+
+    amount = last - first + 1
+
+    if first < total and amount > 0 do
+      part = binary_part(binary, first, min(amount, total - first))
+
+      if step == 1 do
+        part
+      else
+        <<first_byte, rest::binary>> = part
+        for <<_::size(^step - 1)-bytes, byte <- rest>>, into: <<first_byte>>, do: <<byte>>
+      end
+    else
+      ""
+    end
+  end
+
+  def binary_slice(binary, _.._//_ = range) when is_binary(binary) do
+    raise ArgumentError,
+          "binary_slice/2 does not accept ranges with negative steps, got: #{inspect(range)}"
+  end
+
+  ## Definitions implemented in Elixir
+
+  @doc ~S"""
+  Defines a module given by name with the given contents.
+
+  This macro defines a module with the given `alias` as its name and with the
+  given contents. It returns a tuple with four elements:
+
+    * `:module`
+    * the module name
+    * the binary contents of the module
+    * the result of evaluating the contents block
+
+  ## Examples
+
+      defmodule Number do
+        def one, do: 1
+        def two, do: 2
+      end
+      #=> {:module, Number, <<70, 79, 82, ...>>, {:two, 0}}
+
+      Number.one()
+      #=> 1
+
+      Number.two()
+      #=> 2
+
+  ## Module names and aliases
+
+  Module names (and aliases) must start with an ASCII uppercase character which
+  may be followed by any ASCII letter, number, or underscore. Elixir's
+  [Naming Conventions](naming-conventions.md) suggest for module names and aliases
+  to be written in the `CamelCase` format.
+
+  You can also use atoms as the module name, although they must only contain ASCII
+  characters.
+
+  ## Nesting
+
+  Nesting a module inside another module affects the name of the nested module:
+
+      defmodule Foo do
+        defmodule Bar do
+        end
+      end
+
+  In the example above, two modules - `Foo` and `Foo.Bar` - are created.
+  When nesting, Elixir automatically creates an alias to the inner module,
+  allowing the second module `Foo.Bar` to be accessed as `Bar` in the same
+  lexical scope where it's defined (the `Foo` module). This only happens
+  if the nested module is defined via an alias.
+
+  If the `Foo.Bar` module is moved somewhere else, the references to `Bar` in
+  the `Foo` module need to be updated to the fully-qualified name (`Foo.Bar`) or
+  an alias has to be explicitly set in the `Foo` module with the help of
+  `alias/2`.
+
+      defmodule Foo.Bar do
+        # code
+      end
+
+      defmodule Foo do
+        alias Foo.Bar
+        # code here can refer to "Foo.Bar" as just "Bar"
+      end
+
+  ## Dynamic names
+
+  Elixir module names can be dynamically generated. This is very
+  useful when working with macros. For instance, one could write:
+
+      defmodule Module.concat(["Foo", "Bar"]) do
+        # contents ...
+      end
+
+  Elixir will accept any module name as long as the expression passed as the
+  first argument to `defmodule/2` evaluates to an atom.
+  Note that, when a dynamic name is used, Elixir won't nest the name under
+  the current module nor automatically set up an alias.
+
+  ## Reserved module names
+
+  If you attempt to define a module that already exists, you will get a
+  warning saying that a module has been redefined.
+
+  There are some modules that Elixir does not currently implement but it
+  may be implement in the future. Those modules are reserved and defining
+  them will result in a compilation error:
+
+      defmodule Any do
+        # code
+      end
+      ** (CompileError) iex:1: module Any is reserved and cannot be defined
+
+  Elixir reserves the following module names: `Elixir`, `Any`, `BitString`,
+  `PID`, and `Reference`.
+  """
+  defmacro defmodule(alias, do_block)
+
+  defmacro defmodule(alias, do: block) do
+    env = __CALLER__
+    assert_no_match_or_guard_scope(env.context, "defmodule/2")
+    expanded = expand_module_alias(alias, env)
+
+    module_meta = module_meta(alias)
+
+    {expanded, with_alias} =
+      case is_atom(expanded) do
+        true ->
+          {full, old, opts} = alias_defmodule(alias, expanded, env)
+          # Expand the module considering the current environment/nesting
+          meta = [defined: full] ++ module_meta
+          {full, {:require, meta, [old, opts]}}
+
+        false ->
+          {expanded, nil}
+      end
+
+    escaped =
+      case env do
+        %{function: nil, lexical_tracker: pid} when is_pid(pid) ->
+          integer = Kernel.LexicalTracker.write_cache(pid, block)
+          quote(do: Kernel.LexicalTracker.read_cache(unquote(pid), unquote(integer)))
+
+        %{} ->
+          :elixir_quote.escape(block, :escape, false)
+      end
+
+    versioned_vars = env.versioned_vars
+    prune = :erlang.is_map_key({:elixir, :prune_binding}, versioned_vars)
+
+    var_meta =
+      case prune do
+        true -> [generated: true, keep_unused: true]
+        false -> [generated: true]
+      end
+
+    module_vars = :lists.map(&module_var(&1, var_meta), :maps.keys(versioned_vars))
+
+    quote do
+      unquote(with_alias)
+
+      :elixir_module.compile(
+        unquote(module_meta),
+        unquote(expanded),
+        unquote(escaped),
+        unquote(module_vars),
+        unquote(prune),
+        __ENV__
+      )
+    end
+  end
+
+  defp module_meta({_, meta, _}), do: meta
+  defp module_meta(_), do: []
+
+  # We don't want to trace :alias_reference since we are defining the alias
+  defp expand_module_alias({:__aliases__, meta, list} = alias, env) do
+    case :elixir_aliases.expand_or_concat(meta, list, env, true) do
+      receiver when is_atom(receiver) ->
+        receiver
+
+      [head | tail] ->
+        case Macro.expand(head, env) do
+          head when is_atom(head) -> :elixir_aliases.concat([head | tail])
+          _ -> alias
+        end
+    end
+  end
+
+  defp expand_module_alias(other, env), do: Macro.expand(other, env)
+
+  # defmodule Elixir.Alias
+  defp alias_defmodule({:__aliases__, _, [:"Elixir", _ | _]}, module, _env),
+    do: {module, module, []}
+
+  # defmodule Alias in root
+  defp alias_defmodule({:__aliases__, _, _}, module, %{module: nil}), do: {module, module, []}
+
+  # defmodule Alias nested
+  defp alias_defmodule({:__aliases__, _, [h | t]}, _module, env) when is_atom(h) do
+    module = :elixir_aliases.concat([env.module, h])
+    alias = String.to_atom("Elixir." <> Atom.to_string(h))
+    opts = [as: alias, warn: false]
+
+    case t do
+      [] -> {module, module, opts}
+      _ -> {String.to_atom(Enum.join([module | t], ".")), module, opts}
+    end
+  end
+
+  # defmodule _
+  defp alias_defmodule(_raw, module, _env) do
+    {module, module, []}
+  end
+
+  defp module_var({name, kind}, meta) when is_atom(kind), do: {name, meta, kind}
+  defp module_var({name, kind}, meta), do: {name, [counter: kind] ++ meta, nil}
+
+  @doc ~S"""
+  Defines a public function with the given name and body.
+
+  ## Examples
+
+      defmodule Foo do
+        def bar, do: :baz
+      end
+
+      Foo.bar()
+      #=> :baz
+
+  A function that expects arguments can be defined as follows:
+
+      defmodule Foo do
+        def sum(a, b) do
+          a + b
+        end
+      end
+
+  In the example above, a `sum/2` function is defined; this function receives
+  two arguments and returns their sum.
+
+  ## Default arguments
+
+  `\\` is used to specify a default value for a parameter of a function. For
+  example:
+
+      defmodule MyMath do
+        def multiply_by(number, factor \\ 2) do
+          number * factor
+        end
+      end
+
+      MyMath.multiply_by(4, 3)
+      #=> 12
+
+      MyMath.multiply_by(4)
+      #=> 8
+
+  The compiler translates this into multiple functions with different arities,
+  here `MyMath.multiply_by/1` and `MyMath.multiply_by/2`, that represent cases when
+  arguments for parameters with default values are passed or not passed.
+
+  When defining a function with default arguments as well as multiple
+  explicitly declared clauses, you must write a function head that declares the
+  defaults. For example:
+
+      defmodule MyString do
+        def join(string1, string2 \\ nil, separator \\ " ")
+
+        def join(string1, nil, _separator) do
+          string1
+        end
+
+        def join(string1, string2, separator) do
+          string1 <> separator <> string2
+        end
+      end
+
+  Note that `\\` can't be used with anonymous functions because they
+  can only have a sole arity.
+
+  ### Keyword lists with default arguments
+
+  Functions containing many arguments can benefit from using `Keyword`
+  lists to group and pass attributes as a single value.
+
+      defmodule MyConfiguration do
+        @default_opts [storage: "local"]
+
+        def configure(resource, opts \\ []) do
+          opts = Keyword.merge(@default_opts, opts)
+          storage = opts[:storage]
+          # ...
+        end
+      end
+
+  The difference between using `Map` and `Keyword` to store many
+  arguments is `Keyword`'s keys:
+
+    * must be atoms
+    * can be given more than once
+    * ordered, as specified by the developer
+
+  ## Function names
+
+  Function and variable names in Elixir must start with an underscore or a
+  Unicode letter that is not in uppercase or titlecase. They may continue
+  using a sequence of Unicode letters, numbers, and underscores. They may
+  end in `?` or `!`. Elixir's [Naming Conventions](naming-conventions.md)
+  suggest for function and variable names to be written in the `snake_case`
+  format.
+
+  ## `rescue`/`catch`/`after`/`else`
+
+  Function bodies support `rescue`, `catch`, `after`, and `else` as `try/1`
+  does (known as "implicit try"). For example, the following two functions are equivalent:
+
+      def convert(number) do
+        try do
+          String.to_integer(number)
+        rescue
+          e in ArgumentError -> {:error, e.message}
+        end
+      end
+
+      def convert(number) do
+        String.to_integer(number)
+      rescue
+        e in ArgumentError -> {:error, e.message}
+      end
+
+  """
+  defmacro def(call, expr \\ nil) do
+    assert_no_match_or_guard_scope(__CALLER__.context, "def/2")
+    define(:def, call, expr, __CALLER__)
+  end
+
+  @doc """
+  Defines a private function with the given name and body.
+
+  Private functions are only accessible from within the module in which they are
+  defined. Trying to access a private function from outside the module it's
+  defined in results in an `UndefinedFunctionError` exception.
+
+  Check `def/2` for more information.
+
+  ## Examples
+
+      defmodule Foo do
+        def bar do
+          sum(1, 2)
+        end
+
+        defp sum(a, b), do: a + b
+      end
+
+      Foo.bar()
+      #=> 3
+
+      Foo.sum(1, 2)
+      ** (UndefinedFunctionError) undefined function Foo.sum/2
+
+  """
+  defmacro defp(call, expr \\ nil) do
+    assert_no_match_or_guard_scope(__CALLER__.context, "defp/2")
+    define(:defp, call, expr, __CALLER__)
+  end
+
+  @doc """
+  Defines a public macro with the given name and body.
+
+  Macros must be defined before its usage.
+
+  Check `def/2` for rules on naming and default arguments.
+
+  ## Examples
+
+      defmodule MyLogic do
+        defmacro unless(expr, opts) do
+          quote do
+            if !unquote(expr), unquote(opts)
+          end
+        end
+      end
+
+      require MyLogic
+
+      MyLogic.unless false do
+        IO.puts("It works")
+      end
+
+  """
+  defmacro defmacro(call, expr \\ nil) do
+    assert_no_match_or_guard_scope(__CALLER__.context, "defmacro/2")
+    define(:defmacro, call, expr, __CALLER__)
+  end
+
+  @doc """
+  Defines a private macro with the given name and body.
+
+  Private macros are only accessible from the same module in which they are
+  defined.
+
+  Private macros must be defined before its usage.
+
+  Check `defmacro/2` for more information, and check `def/2` for rules on
+  naming and default arguments.
+
+  """
+  defmacro defmacrop(call, expr \\ nil) do
+    assert_no_match_or_guard_scope(__CALLER__.context, "defmacrop/2")
+    define(:defmacrop, call, expr, __CALLER__)
+  end
+
+  defp define(kind, call, expr, env) do
+    module = assert_module_scope(env, kind, 2)
+    assert_no_function_scope(env, kind, 2)
+
+    unquoted_call = :elixir_quote.has_unquotes(call)
+    unquoted_expr = :elixir_quote.has_unquotes(expr)
+
+    store =
+      case unquoted_expr or unquoted_call do
+        true ->
+          :elixir_quote.escape({call, expr}, :escape, true)
+
+        false ->
+          key = :erlang.unique_integer()
+          :elixir_module.write_cache(module, key, {call, expr})
+          key
+      end
+
+    pos = :elixir_module.cache_env(env)
+
+    quote do
+      :elixir_def.store_definition(unquote(kind), unquote(store), unquote(pos))
+    end
+  end
+
+  @doc """
+  Defines a struct.
+
+  A struct is a tagged map that allows developers to provide
+  default values for keys, tags to be used in polymorphic
+  dispatches and compile time assertions.
+
+  It is only possible to define a struct per module, as the
+  struct is tied to the module itself.
+
+  ## Examples
+
+      defmodule User do
+        defstruct name: nil, age: nil
+      end
+
+  Struct fields are evaluated at compile-time, which allows
+  them to be dynamic. In the example below, `10 + 11` is
+  evaluated at compile-time and the age field is stored
+  with value `21`:
+
+      defmodule User do
+        defstruct name: nil, age: 10 + 11
+      end
+
+  The `fields` argument is usually a keyword list with field names
+  as atom keys and default values as corresponding values. `defstruct/1`
+  also supports a list of atoms as its argument: in that case, the atoms
+  in the list will be used as the struct's field names and they will all
+  default to `nil`.
+
+      defmodule Post do
+        defstruct [:title, :content, :author]
+      end
+
+  Add documentation to a struct with the `@doc` attribute, like a function.
+
+      defmodule Post do
+        @doc "A post. The content should be valid Markdown."
+        defstruct [:title, :content, :author]
+      end
+
+  Once a struct is defined, it is possible to create them as follows:
+
+      %Post{title: "Hello world!"}
+
+  For more information on creating, updating, and pattern matching on
+  structs, please check `%/2`.
+
+  ## Deriving
+
+  Although structs are maps, by default structs do not implement
+  any of the protocols implemented for maps. For example, attempting
+  to use a protocol with the `User` struct leads to an error:
+
+      john = %User{name: "John"}
+      MyProtocol.call(john)
+      ** (Protocol.UndefinedError) protocol MyProtocol not implemented for User (a struct)
+
+  `defstruct/1`, however, allows protocol implementations to be
+  *derived*. This can be done by defining a `@derive` attribute as a
+  list before invoking `defstruct/1`:
+
+      defmodule User do
+        @derive MyProtocol
+        defstruct name: nil, age: nil
+      end
+
+      MyProtocol.call(john) # it works!
+
+  A common example is to `@derive` the `Inspect` protocol to hide certain fields
+  when the struct is printed:
+
+      defmodule User do
+        @derive {Inspect, only: :name}
+        defstruct name: nil, age: nil
+      end
+
+  For each protocol in `@derive`, Elixir will verify if the protocol
+  has implemented the `c:Protocol.__deriving__/2` callback. If so,
+  the callback will be invoked and it should define the implementation
+  module. Otherwise an implementation that simply points to the `Any`
+  implementation is automatically derived. For more information, see
+  `Protocol.derive/3`.
+
+  ## Enforcing keys
+
+  When building a struct, Elixir will automatically guarantee all keys
+  belong to the struct:
+
+      %User{name: "john", unknown: :key}
+      ** (KeyError) key :unknown not found in: %User{age: 21, name: nil}
+
+  Elixir also allows developers to enforce that certain keys must always be
+  given when building the struct:
+
+      defmodule User do
+        @enforce_keys [:name]
+        defstruct name: nil, age: 10 + 11
+      end
+
+  Now trying to build a struct without the name key will fail:
+
+      %User{age: 21}
+      ** (ArgumentError) the following keys must also be given when building struct User: [:name]
+
+  Keep in mind `@enforce_keys` is a simple compile-time guarantee
+  to aid developers when building structs. It is not enforced on
+  updates and it does not provide any sort of value-validation.
+
+  ## Types
+
+  It is recommended to define types for structs. By convention, such a type
+  is called `t`. To define a struct inside a type, the struct literal syntax
+  is used:
+
+      defmodule User do
+        defstruct name: "John", age: 25
+        @type t :: %__MODULE__{name: String.t(), age: non_neg_integer}
+      end
+
+  It is recommended to only use the struct syntax when defining the struct's
+  type. When referring to another struct, it's better to use `User.t()` instead of
+  `%User{}`.
+
+  The types of the struct fields that are not included in `%User{}` default to
+  `term()` (see `t:term/0`).
+
+  Structs whose internal structure is private to the local module (pattern
+  matching them or directly accessing their fields should not be allowed) should
+  use the `@opaque` attribute. Structs whose internal structure is public should
+  use `@type`.
+  """
+  defmacro defstruct(fields) do
+    quote bind_quoted: [fields: fields, bootstrapped?: bootstrapped?(Enum)] do
+      {struct, derive, escaped_struct, kv, body} =
+        Kernel.Utils.defstruct(__MODULE__, fields, bootstrapped?, __ENV__)
+
+      case derive do
+        [] -> :ok
+        _ -> Protocol.__derive__(derive, __MODULE__, __ENV__)
+      end
+
+      def __struct__(), do: unquote(escaped_struct)
+      def __struct__(unquote(kv)), do: unquote(body)
+
+      Kernel.Utils.announce_struct(__MODULE__)
+      struct
+    end
+  end
+
+  @doc ~S"""
+  Defines an exception.
+
+  Exceptions are structs backed by a module that implements
+  the `Exception` behaviour. The `Exception` behaviour requires
+  two functions to be implemented:
+
+    * [`exception/1`](`c:Exception.exception/1`) - receives the arguments given to `raise/2`
+      and returns the exception struct. The default implementation
+      accepts either a set of keyword arguments that is merged into
+      the struct or a string to be used as the exception's message.
+
+    * [`message/1`](`c:Exception.message/1`) - receives the exception struct and must return its
+      message. Most commonly exceptions have a message field which
+      by default is accessed by this function. However, if an exception
+      does not have a message field, this function must be explicitly
+      implemented.
+
+  Since exceptions are structs, the API supported by `defstruct/1`
+  is also available in `defexception/1`.
+
+  ## Raising exceptions
+
+  The most common way to raise an exception is via `raise/2`:
+
+      defmodule MyAppError do
+        defexception [:message]
+      end
+
+      value = [:hello]
+
+      raise MyAppError,
+        message: "did not get what was expected, got: #{inspect(value)}"
+
+  In many cases it is more convenient to pass the expected value to
+  `raise/2` and generate the message in the `c:Exception.exception/1` callback:
+
+      defmodule MyAppError do
+        defexception [:message]
+
+        @impl true
+        def exception(value) do
+          msg = "did not get what was expected, got: #{inspect(value)}"
+          %MyAppError{message: msg}
+        end
+      end
+
+      raise MyAppError, value
+
+  The example above shows the preferred strategy for customizing
+  exception messages.
+  """
+  defmacro defexception(fields) do
+    quote bind_quoted: [fields: fields] do
+      Elixir.Kernel.@(behaviour(Exception))
+      struct = defstruct([__exception__: true] ++ fields)
+
+      if Map.has_key?(struct, :message) do
+        Elixir.Kernel.@(impl(true))
+
+        def message(exception) do
+          exception.message
+        end
+
+        defoverridable message: 1
+
+        Elixir.Kernel.@(impl(true))
+
+        def exception(msg) when Kernel.is_binary(msg) do
+          exception(message: msg)
+        end
+      end
+
+      # Calls to Kernel functions must be fully-qualified to ensure
+      # reproducible builds, otherwise, this macro will generate ASTs
+      # with different metadata (:imports, :context) depending on if
+      # it is the bootstrapped version or not.
+      Elixir.Kernel.@(impl(true))
+
+      def exception(args) when Kernel.is_list(args) do
+        struct!(__MODULE__, args)
+      end
+
+      defoverridable exception: 1
+    end
+  end
+
+  @doc """
+  Defines a protocol.
+
+  See the `Protocol` module for more information.
+  """
+  defmacro defprotocol(name, do_block)
+
+  defmacro defprotocol(name, do: block) do
+    Protocol.__protocol__(name, do: block)
+  end
+
+  @doc """
+  Defines an implementation for the given protocol.
+
+  See the `Protocol` module for more information.
+  """
+  defmacro defimpl(name, opts, do_block \\ []) do
+    Protocol.__impl__(name, opts, do_block, __CALLER__)
+  end
+
+  @doc """
+  Makes the given definitions in the current module overridable.
+
+  If the user defines a new function or macro with the same name
+  and arity, then the overridable ones are discarded. Otherwise, the
+  original definitions are used.
+
+  It is possible for the overridden definition to have a different
+  visibility than the original: a public function can be overridden
+  by a private function and vice-versa. Macros cannot be overridden
+  as functions and vice-versa.
+
+  ## Example
+
+      defmodule DefaultMod do
+        defmacro __using__(_opts) do
+          quote do
+            def test(x, y) do
+              x + y
+            end
+
+            defoverridable test: 2
+          end
+        end
+      end
+
+      defmodule ChildMod do
+        use DefaultMod
+
+        def test(x, y) do
+          x * y + super(x, y)
+        end
+      end
+
+  As seen as in the example above, `super` can be used to call the default
+  implementation.
+
+  ## Example with behaviour
+
+  `defoverridable` is commonly used with behaviours. The behaviours use
+  `@callback` definitions to define the general module API and the
+  `__using__` callback is used to define default implementations of
+  functions, which can then be overridable.
+
+  For convenience, you can pass a behaviour to `defoverridable` and it
+  will mark all of the callbacks in the behaviour as overridable:
+
+      defmodule Behaviour do
+        @callback test(number(), number()) :: number()
+      end
+
+      defmodule DefaultMod do
+        defmacro __using__(_opts) do
+          quote do
+            @behaviour Behaviour
+
+            def test(x, y) do
+              x + y
+            end
+
+            defoverridable Behaviour
+          end
+        end
+      end
+
+      defmodule ChildMod do
+        use DefaultMod
+
+        def test(x, y) do
+          x * y + super(x, y)
+        end
+      end
+
+  > #### Narrow behaviours and entry points {: .tip}
+  >
+  > When defining behaviours, a general rule of thumb is to define narrow
+  > behaviours, with the minimum amount of callbacks, to facilitate maintenance
+  > over time. Fewer callbacks minimize the points of contact between different
+  > parts of the system and reduces the risk of breaking changes and of different
+  > implementations having inconsistent behaviour. However, when using `defoverridable`
+  > with behaviours, you may accidentally define broad interfaces as all default
+  > behaviour is provided via `defoverridable`. Furthermore, `defoverridable`
+  > necessarily relies on meta-programming, which complicates debugging. `super` is
+  > also hard to troubleshoot, as it by definition relies on calling an implicitly
+  > defined function.
+  >
+  > A possible alternative to `defoverridable` is to use optional callbacks and
+  > move the default implementation to the caller. Then you can check if a callback
+  > exists via `Code.ensure_loaded?/1` and `function_exported?/3`. For instance,
+  > in the example above, imagine there is a module that calls the `test/2` function.
+  > This module could be defined as such:
+  >
+  >     defmodule CallsTest do
+  >       def receives_module_and_calls_test(module, x, y) do
+  >         if Code.ensure_loaded?(module) and function_exported?(module, :test, 2) do
+  >           module.test(x, y)
+  >         else
+  >           x + y
+  >         end
+  >       end
+  >     end
+  >
+  > The downside of the above code is that it must call `Code.ensure_loaded?/1` and
+  > `function_exported?/3` on every invocation of the behaviour, which may impact
+  > runtime performance. For this reason, this approach works best when the behaviour
+  > has an entry point, such as a `init` callback (as seen in `GenServer`), which you
+  > invoke once to guarantee the module is loaded, and from that moment, you only need
+  > to perform `function_exported?/3` checks.
+  >
+  > To recap:
+  >
+  >   * Prefer narrow behaviours
+  >
+  >   * If your behaviour has an entry point, consider using optional callbacks
+  >     followed by `Code.ensure_loaded?/1` and `function_exported?/3` checks
+  >
+  >   * If using `defoverridable`, avoid relying on `super` to trigger the default
+  >     behaviour, suggesting users to invoke well-defined APIs instead.
+  >
+  """
+  defmacro defoverridable(keywords_or_behaviour) do
+    quote do
+      Module.make_overridable(__MODULE__, unquote(keywords_or_behaviour))
+    end
+  end
 
   @doc """
-  Checks if the element on the left side is member of the
-  collection on the right side.
+  Defines a macro suitable for use in guard expressions.
 
-  ## Examples
+  It raises at compile time if the `guard` uses expressions that aren't
+  allowed in [guard clauses](patterns-and-guards.html#guards),
+  and otherwise creates a macro that can be used both inside or outside guards.
 
-      iex> x = 1
-      iex> x in [1, 2, 3]
-      true
+  When defining your own guards, consider the
+  [naming conventions](naming-conventions.html#is_-prefix-is_foo)
+  around boolean-returning guards.
 
-  This macro simply translates the expression above to:
+  ## Example
 
-      Enum.member?([1,2,3], x)
+      defmodule Integer.Guards do
+        defguard is_even(value) when is_integer(value) and rem(value, 2) == 0
+      end
 
-  ## Guards
+      defmodule Collatz do
+        @moduledoc "Tools for working with the Collatz sequence."
+        import Integer.Guards
 
-  The `in` operator can be used on guard clauses as long as the
-  right side is a range or a list. Elixir will then expand the
-  operator to a valid guard expression. For example:
+        @doc "Determines the number of steps `n` takes to reach `1`."
+        # If this function never converges, please let me know what `n` you used.
+        def converge(n) when n > 0, do: step(n, 0)
 
-      when x in [1,2,3]
+        defp step(1, step_count) do
+          step_count
+        end
 
-  Translates to:
+        defp step(n, step_count) when is_even(n) do
+          step(div(n, 2), step_count + 1)
+        end
 
-      when x === 1 or x === 2 or x === 3
+        defp step(n, step_count) do
+          step(3 * n + 1, step_count + 1)
+        end
+      end
 
-  When using ranges:
+  """
+  @doc since: "1.6.0"
+  @spec defguard(Macro.t()) :: Macro.t()
+  defmacro defguard(guard) do
+    define_guard(:defmacro, guard, __CALLER__)
+  end
 
-      when x in 1..3
+  @doc """
+  Defines a private macro suitable for use in guard expressions.
 
-  Translates to:
+  It raises at compile time if the `guard` uses expressions that aren't
+  allowed in [guard clauses](patterns-and-guards.html#guards),
+  and otherwise creates a private macro that can be used
+  both inside or outside guards in the current module.
 
-      when x >= 1 and x <= 3
+  When defining your own guards, consider the
+  [naming conventions](naming-conventions.html#is_-prefix-is_foo)
+  around boolean-returning guards.
 
+  Similar to `defmacrop/2`, `defguardp/1` must be defined before its use
+  in the current module.
   """
-  defmacro left in right do
-    cache = (__CALLER__.context == nil)
-
-    right = case bootstraped?(Macro) do
-      true  -> Macro.expand(right, __CALLER__)
-      false -> right
-    end
-
-    case right do
-      _ when cache ->
-        quote do: Elixir.Enum.member?(unquote(right), unquote(left))
-      [] ->
-        false
-      [h|t] ->
-        :lists.foldr(fn x, acc ->
-          quote do
-            unquote(comp(left, x)) or unquote(acc)
-          end
-        end, comp(left, h), t)
-      {:%{}, [], [__struct__: Elixir.Range, first: first, last: last]} ->
-        in_range(left, Macro.expand(first, __CALLER__), Macro.expand(last, __CALLER__))
-      _ ->
-        raise ArgumentError, <<"invalid args for operator in, it expects a compile time list ",
-                                        "or range on the right side when used in guard expressions, got: ",
-                                        Macro.to_string(right) :: binary>>
-    end
+  @doc since: "1.6.0"
+  @spec defguardp(Macro.t()) :: Macro.t()
+  defmacro defguardp(guard) do
+    define_guard(:defmacrop, guard, __CALLER__)
   end
 
-  defp in_range(left, first, last) do
-    case opt_in?(first) and opt_in?(last) do
-      true  ->
-        case first <= last do
-          true  -> increasing_compare(left, first, last)
-          false -> decreasing_compare(left, first, last)
-        end
-      false ->
-        quote do
-          (:erlang."=<"(unquote(first), unquote(last)) and
-           unquote(increasing_compare(left, first, last)))
-          or
-          (:erlang."<"(unquote(last), unquote(first)) and
-           unquote(decreasing_compare(left, first, last)))
+  defp define_guard(kind, guard, env) do
+    case :elixir_utils.extract_guards(guard) do
+      {call, [_, _ | _]} ->
+        raise ArgumentError,
+              "invalid syntax in defguard #{Macro.to_string(call)}, " <>
+                "only a single when clause is allowed"
+
+      {call, impls} ->
+        case decompose_args(call) do
+          :error ->
+            raise ArgumentError, "invalid syntax in defguard #{Macro.to_string(call)}"
+
+          args ->
+            validate_variable_only_args!(call, args)
+
+            macro_definition =
+              case impls do
+                [] ->
+                  define(kind, call, nil, env)
+
+                [guard] ->
+                  quoted =
+                    quote do
+                      require Kernel.Utils
+                      Kernel.Utils.defguard(unquote(args), unquote(guard))
+                    end
+
+                  define(kind, call, [do: quoted], env)
+              end
+
+            quote do
+              Elixir.Kernel.@(doc(guard: true))
+              unquote(macro_definition)
+            end
         end
     end
   end
 
-  defp opt_in?(x), do: is_integer(x) or is_float(x) or is_atom(x)
+  defp decompose_args({name, _, args}) when is_atom(name) and is_atom(args), do: []
 
-  defp comp(left, right) do
-    quote(do: :erlang."=:="(unquote(left), unquote(right)))
-  end
-
-  defp increasing_compare(var, first, last) do
-    quote do
-      :erlang.">="(unquote(var), unquote(first)) and
-      :erlang."=<"(unquote(var), unquote(last))
-    end
-  end
-
-  defp decreasing_compare(var, first, last) do
-    quote do
-      :erlang."=<"(unquote(var), unquote(first)) and
-      :erlang.">="(unquote(var), unquote(last))
-    end
-  end
+  defp decompose_args({name, _, args}) when is_atom(name) and is_list(args), do: args
 
-  @doc """
-  When used inside quoting, marks that the variable should
-  not be hygienized. The argument can be either a variable
-  unquoted or in standard tuple form `{name, meta, context}`.
+  defp decompose_args({{:unquote, _, _}, _, args}) when is_atom(args), do: []
 
-  Check `Kernel.SpecialForms.quote/2` for more information.
-  """
-  defmacro var!(var, context \\ nil)
+  defp decompose_args({{:unquote, _, _}, _, args}) when is_list(args), do: args
 
-  defmacro var!({name, meta, atom}, context) when is_atom(name) and is_atom(atom) do
-    do_var!(name, meta, context, __CALLER__)
-  end
+  defp decompose_args(_), do: :error
 
-  defmacro var!(x, _context) do
-    raise ArgumentError, "expected a var to be given to var!, got: #{Macro.to_string(x)}"
-  end
+  defp validate_variable_only_args!(call, args) do
+    Enum.each(args, fn
+      {ref, _meta, context} when is_atom(ref) and is_atom(context) ->
+        :ok
 
-  defp do_var!(name, meta, context, env) do
-    # Remove counter and force them to be vars
-    meta = :lists.keydelete(:counter, 1, meta)
-    meta = :lists.keystore(:var, 1, meta, {:var, true})
+      {:\\, _m1, [{ref, _m2, context}, _default]} when is_atom(ref) and is_atom(context) ->
+        :ok
 
-    case Macro.expand(context, env) do
-      x when is_atom(x) ->
-        {name, meta, x}
-      x ->
-        raise ArgumentError, "expected var! context to expand to an atom, got: #{Macro.to_string(x)}"
-    end
+      _match ->
+        raise ArgumentError, "invalid syntax in defguard #{Macro.to_string(call)}"
+    end)
   end
 
   @doc """
-  When used inside quoting, marks that the alias should not
-  be hygienezed. This means the alias will be expanded when
-  the macro is expanded.
-
-  Check `Kernel.SpecialForms.quote/2` for more information.
-  """
-  defmacro alias!(alias)
-
-  defmacro alias!(alias) when is_atom(alias) do
-    alias
-  end
+  Uses the given module in the current context.
 
-  defmacro alias!({:__aliases__, meta, args}) do
-    # Simply remove the alias metadata from the node
-    # so it does not affect expansion.
-    {:__aliases__, :lists.keydelete(:alias, 1, meta), args}
-  end
+  When calling:
 
-  ## Definitions implemented in Elixir
+      use MyModule, some: :options
 
-  @doc ~S"""
-  Defines a module given by name with the given contents.
+  Elixir will invoke `MyModule.__using__/1` passing the second argument of
+  `use` as its argument. Since `__using__/1` is typically a macro, all
+  the usual macro rules apply, and its return value should be quoted code
+  that is then inserted where `use/2` is called.
 
-  It returns the module name, the module binary and the
-  block contents result.
+  > #### Code injection {: .warning}
+  >
+  > `use MyModule` works as a **code-injection point** in the caller.
+  > Given the caller of `use MyModule` has little control over how the
+  > code is injected, `use/2` should be used with care. If you can,
+  > avoid use in favor of `import/2` or `alias/2` whenever possible.
 
   ## Examples
 
-      iex> defmodule Foo do
-      ...>   def bar, do: :baz
-      ...> end
-      iex> Foo.bar
-      :baz
-
-  ## Nesting
+  For example, to write test cases using the `ExUnit` framework provided
+  with Elixir, a developer should `use` the `ExUnit.Case` module:
 
-  Nesting a module inside another module affects its name:
+      defmodule AssertionTest do
+        use ExUnit.Case, async: true
 
-      defmodule Foo do
-        defmodule Bar do
+        test "always pass" do
+          assert true
         end
       end
 
-  In the example above, two modules `Foo` and `Foo.Bar` are created.
-  When nesting, Elixir automatically creates an alias, allowing the
-  second module `Foo.Bar` to be accessed as `Bar` in the same lexical
-  scope.
+  In this example, Elixir will call the `__using__/1` macro in the
+  `ExUnit.Case` module with the keyword list `[async: true]` as its
+  argument.
 
-  This means that, if the module `Bar` is moved to another file,
-  the references to `Bar` needs to be updated or an alias needs to
-  be explicitly set with the help of `Kernel.SpecialForms.alias/2`.
-
-  ## Dynamic names
+  In other words, `use/2` translates to:
 
-  Elixir module names can be dynamically generated. This is very
-  useful for macros. For instance, one could write:
+      defmodule AssertionTest do
+        require ExUnit.Case
+        ExUnit.Case.__using__(async: true)
 
-      defmodule String.to_atom("Foo#{1}") do
-        # contents ...
+        test "always pass" do
+          assert true
+        end
       end
 
-  Elixir will accept any module name as long as the expression
-  returns an atom. Note that, when a dynamic name is used, Elixir
-  won't nest the name under the current module nor automatically
-  set up an alias.
-  """
-  defmacro defmodule(alias, do: block) do
-    env   = __CALLER__
-    boot? = bootstraped?(Macro)
+  where `ExUnit.Case` defines the `__using__/1` macro:
 
-    expanded =
-      case boot? do
-        true  -> Macro.expand(alias, env)
-        false -> alias
+      defmodule ExUnit.Case do
+        defmacro __using__(opts) do
+          # do something with opts
+          quote do
+            # return some code to inject in the caller
+          end
+        end
       end
 
-    {expanded, with_alias} =
-      case boot? and is_atom(expanded) do
-        true ->
-          # Expand the module considering the current environment/nesting
-          full = expand_module(alias, expanded, env)
+  ## Best practices
 
-          # Generate the alias for this module definition
-          {new, old} = module_nesting(env.module, full)
-          meta = [defined: full, context: true] ++ alias_meta(alias)
+  `__using__/1` is typically used when there is a need to set some state
+  (via module attributes) or callbacks (like `@before_compile`, see the
+  documentation for `Module` for more information) into the caller.
 
-          {full, {:alias, meta, [old, [as: new, warn: false]]}}
-        false ->
-          {expanded, nil}
-      end
+  `__using__/1` may also be used to alias, require, or import functionality
+  from different modules:
 
-    {escaped, _} = :elixir_quote.escape(block, false)
-    module_vars  = module_vars(env.vars, 0)
+      defmodule MyModule do
+        defmacro __using__(_opts) do
+          quote do
+            import MyModule.Foo
+            import MyModule.Bar
+            import MyModule.Baz
 
-    quote do
-      unquote(with_alias)
-      :elixir_module.compile(unquote(expanded), unquote(escaped),
-                             unquote(module_vars), __ENV__)
-    end
-  end
+            alias MyModule.Repo
+          end
+        end
+      end
 
-  defp alias_meta({:__aliases__, meta, _}), do: meta
-  defp alias_meta(_), do: []
+  However, do not provide `__using__/1` if all it does is to import,
+  alias or require the module itself. For example, avoid this:
 
-  # defmodule :foo
-  defp expand_module(raw, _module, _env) when is_atom(raw),
-    do: raw
+      defmodule MyModule do
+        defmacro __using__(_opts) do
+          quote do
+            import MyModule
+          end
+        end
+      end
 
-  # defmodule Elixir.Alias
-  defp expand_module({:__aliases__, _, [:Elixir|t]}, module, _env) when t != [],
-    do: module
+  In such cases, developers should instead import or alias the module
+  directly, so that they can customize those as they wish,
+  without the indirection behind `use/2`. Developers must also avoid
+  defining functions inside `__using__/1`.
+
+  Given `use MyModule` can generate any code, it may not be easy for
+  developers to understand the impact of `use MyModule`.
+
+  For this reason, to provide guidance and clarity, we recommend developers
+  to include an admonition block in their `@moduledoc` that explains how
+  `use MyModule` impacts their code. As an example, the `GenServer` documentation
+  outlines:
+
+  > #### `use GenServer` {: .info}
+  >
+  > When you `use GenServer`, the `GenServer` module will
+  > set `@behaviour GenServer` and define a `child_spec/1`
+  > function, so your module can be used as a child
+  > in a supervision tree.
+
+  This provides a quick summary of how using a module impacts the user code.
+  Keep in mind to only list changes made to the public API of the module.
+  For example, if `use MyModule` sets an internal attribute called
+  `@_my_module_info` and this attribute is never meant to be public,
+  it must not be listed.
+
+  For convenience, the markup notation to generate the admonition block
+  above is:
+
+  ```
+  > #### `use GenServer` {: .info}
+  >
+  > When you `use GenServer`, the GenServer module will
+  > set `@behaviour GenServer` and define a `child_spec/1`
+  > function, so your module can be used as a child
+  > in a supervision tree.
+  ```
+  """
+  defmacro use(module, opts \\ []) do
+    calls =
+      Enum.map(expand_aliases(module, __CALLER__), fn
+        expanded when is_atom(expanded) ->
+          quote do
+            require unquote(expanded)
+            unquote(expanded).__using__(unquote(opts))
+          end
 
-  # defmodule Alias in root
-  defp expand_module({:__aliases__, _, _}, module, %{module: nil}),
-    do: module
+        _otherwise ->
+          raise ArgumentError,
+                "invalid arguments for use, " <>
+                  "expected a compile time atom or alias, got: #{Macro.to_string(module)}"
+      end)
 
-  # defmodule Alias nested
-  defp expand_module({:__aliases__, _, t}, _module, env),
-    do: :elixir_aliases.concat([env.module|t])
+    quote(do: (unquote_splicing(calls)))
+  end
 
-  # defmodule _
-  defp expand_module(_raw, module, env),
-    do: :elixir_aliases.concat([env.module, module])
+  defp expand_aliases({{:., _, [base, :{}]}, _, refs}, env) do
+    base = Macro.expand(base, env)
 
-  # quote vars to be injected into the module definition
-  defp module_vars([{key, kind}|vars], counter) do
-    var =
-      case is_atom(kind) do
-        true  -> {key, [], kind}
-        false -> {key, [counter: kind], nil}
-      end
+    Enum.map(refs, fn
+      {:__aliases__, _, ref} ->
+        Module.concat([base | ref])
 
-    under = String.to_atom(<<"_@", :erlang.integer_to_binary(counter)::binary>>)
-    args  = [key, kind, under, var]
-    [{:{}, [], args}|module_vars(vars, counter+1)]
-  end
+      ref when is_atom(ref) ->
+        Module.concat(base, ref)
 
-  defp module_vars([], _counter) do
-    []
+      other ->
+        other
+    end)
   end
 
-  # Gets two modules names and return an alias
-  # which can be passed down to the alias directive
-  # and it will create a proper shortcut representing
-  # the given nesting.
-  #
-  # Examples:
-  #
-  #     module_nesting('Elixir.Foo.Bar', 'Elixir.Foo.Bar.Baz.Bat')
-  #     {'Elixir.Baz', 'Elixir.Foo.Bar.Baz'}
-  #
-  # In case there is no nesting/no module:
-  #
-  #     module_nesting(nil, 'Elixir.Foo.Bar.Baz.Bat')
-  #     {false, 'Elixir.Foo.Bar.Baz.Bat'}
-  #
-  defp module_nesting(nil, full),
-    do: {false, full}
-
-  defp module_nesting(prefix, full) do
-    case split_module(prefix) do
-      [] -> {false, full}
-      prefix -> module_nesting(prefix, split_module(full), [], full)
-    end
+  defp expand_aliases(module, env) do
+    [Macro.expand(module, env)]
   end
 
-  defp module_nesting([x|t1], [x|t2], acc, full),
-    do: module_nesting(t1, t2, [x|acc], full)
-  defp module_nesting([], [h|_], acc, _full),
-    do: {String.to_atom(<<"Elixir.", h::binary>>),
-          :elixir_aliases.concat(:lists.reverse([h|acc]))}
-  defp module_nesting(_, _, _acc, full),
-    do: {false, full}
+  @doc """
+  Defines a function that delegates to another module.
 
-  defp split_module(atom) do
-    case :binary.split(Atom.to_string(atom), ".", [:global]) do
-      ["Elixir"|t] -> t
-      _ -> []
-    end
-  end
+  Functions defined with `defdelegate/2` are public and can be invoked from
+  outside the module they're defined in, as if they were defined using `def/2`.
+  Therefore, `defdelegate/2` is about extending the current module's public API.
+  If what you want is to invoke a function defined in another module without
+  using its full module name, then use `alias/2` to shorten the module name or use
+  `import/2` to be able to invoke the function without the module name altogether.
 
-  @doc """
-  Defines a function with the given name and contents.
+  Delegation only works with functions; delegating macros is not supported.
 
-  ## Examples
+  Check `def/2` for rules on naming and default arguments.
 
-      defmodule Foo do
-        def bar, do: :baz
-      end
+  ## Options
+
+    * `:to` - the module to dispatch to.
 
-      Foo.bar #=> :baz
+    * `:as` - the function to call on the target given in `:to`.
+      This parameter is optional and defaults to the name being
+      delegated (`funs`).
 
-  A function that expects arguments can be defined as follow:
+  ## Examples
 
-      defmodule Foo do
-        def sum(a, b) do
-          a + b
-        end
+      defmodule MyList do
+        defdelegate reverse(list), to: Enum
+        defdelegate other_reverse(list), to: Enum, as: :reverse
       end
 
-  In the example above, we defined a function `sum` that receives
-  two arguments and sums them.
+      MyList.reverse([1, 2, 3])
+      #=> [3, 2, 1]
 
-  """
-  defmacro def(call, expr \\ nil) do
-    define(:def, call, expr, __CALLER__)
-  end
+      MyList.other_reverse([1, 2, 3])
+      #=> [3, 2, 1]
 
-  @doc """
-  Defines a function that is private. Private functions are
-  only accessible from within the module in which they are defined.
+  """
+  defmacro defdelegate(funs, opts) do
+    funs = Macro.escape(funs, unquote: true)
+    opts = Macro.expand_literals(opts, %{__CALLER__ | function: {:__info__, 1}})
 
-  Check `def/2` for more information
+    quote bind_quoted: [funs: funs, opts: opts] do
+      target = Kernel.Utils.defdelegate_all(funs, opts, __ENV__)
 
-  ## Examples
+      # TODO: Remove List.wrap when multiple funs are no longer supported
+      for fun <- List.wrap(funs) do
+        {name, args, as, as_args} = Kernel.Utils.defdelegate_each(fun, opts)
+        Elixir.Kernel.@(doc(delegate_to: {target, as, :erlang.length(as_args)}))
 
-      defmodule Foo do
-        def bar do
-          sum(1, 2)
+        # Build the call AST by hand so it doesn't get a
+        # context and it warns on things like missing @impl
+        def unquote({name, [line: __ENV__.line], args}) do
+          unquote(target).unquote(as)(unquote_splicing(as_args))
         end
-
-        defp sum(a, b), do: a + b
       end
-
-  In the example above, `sum` is private and accessing it
-  through `Foo.sum` will raise an error.
-  """
-  defmacro defp(call, expr \\ nil) do
-    define(:defp, call, expr, __CALLER__)
+    end
   end
 
   @doc """
-  Defines a macro with the given name and contents.
+  Debugs the given `code`.
+
+  `dbg/2` can be used to debug the given `code` through a configurable debug function.
+  It returns the result of the given code.
 
   ## Examples
 
-      defmodule MyLogic do
-        defmacro unless(expr, opts) do
-          quote do
-            if !unquote(expr), unquote(opts)
-          end
-        end
-      end
+  Let's take this call to `dbg/2`:
 
-      require MyLogic
-      MyLogic.unless false do
-        IO.puts "It works"
-      end
+      dbg(Atom.to_string(:debugging))
+      #=> "debugging"
 
-  """
-  defmacro defmacro(call, expr \\ nil) do
-    define(:defmacro, call, expr, __CALLER__)
-  end
+  It returns the string `"debugging"`, which is the result of the `Atom.to_string/1` call.
+  Additionally, the call above prints:
 
-  @doc """
-  Defines a macro that is private. Private macros are
-  only accessible from the same module in which they are defined.
+      [my_file.ex:10: MyMod.my_fun/0]
+      Atom.to_string(:debugging) #=> "debugging"
 
-  Check `defmacro/2` for more information
-  """
-  defmacro defmacrop(call, expr \\ nil) do
-    define(:defmacrop, call, expr, __CALLER__)
-  end
+  The default debugging function prints additional debugging info when dealing with
+  pipelines. It prints the values at every "step" of the pipeline.
 
-  defp define(kind, call, expr, env) do
-    assert_module_scope(env, kind, 2)
-    assert_no_function_scope(env, kind, 2)
-    line = env.line
+      "Elixir is cool!"
+      |> String.trim_trailing("!")
+      |> String.split()
+      |> List.first()
+      |> dbg()
+      #=> "Elixir"
 
-    {call, uc} = :elixir_quote.escape(call, true)
-    {expr, ue} = :elixir_quote.escape(expr, true)
+  The code above prints:
 
-    # Do not check clauses if any expression was unquoted
-    check_clauses = not(ue or uc)
-    pos = :elixir_locals.cache_env(env)
+      [my_file.ex:10: MyMod.my_fun/0]
+      "Elixir is cool!" #=> "Elixir is cool!"
+      |> String.trim_trailing("!") #=> "Elixir is cool"
+      |> String.split() #=> ["Elixir", "is", "cool"]
+      |> List.first() #=> "Elixir"
 
-    quote do
-      :elixir_def.store_definition(unquote(line), unquote(kind), unquote(check_clauses),
-                                   unquote(call), unquote(expr), unquote(pos))
-    end
-  end
+  With no arguments, `dbg()` debugs information about the current binding. See `binding/1`.
 
-  @doc """
-  Defines a struct for the current module.
+  ## `dbg` inside IEx
 
-  A struct is a tagged map that allows developers to provide
-  default values for keys, tags to be used in polymorphic
-  dispatches and compile time assertions.
+  You can enable IEx to replace `dbg` with its `IEx.pry/0` backend by calling:
 
-  To define a struct, a developer needs to only define
-  a function named `__struct__/0` that returns a map with the
-  structs field. This macro is a convenience for defining such
-  function, with the addition of a type `t` and deriving
-  conveniences.
+      $ iex --dbg pry
 
-  For more information about structs, please check
-  `Kernel.SpecialForms.%/2`.
+  In such cases, `dbg` will start a `pry` session where you can interact with
+  the imports, aliases, and variables of the current environment at the location
+  of the `dbg` call.
 
-  ## Examples
+  If you call `dbg` at the end of a pipeline (using `|>`) within IEx, you are able
+  to go through each step of the pipeline one by one by entering "next" (or "n").
 
-      defmodule User do
-        defstruct name: nil, age: nil
-      end
+  Note `dbg` only supports stepping for pipelines (in other words, it can only
+  step through the code it sees). For general stepping, you can set breakpoints
+  using `IEx.break!/4`.
 
-  Struct fields are evaluated at definition time, which allows
-  them to be dynamic. In the example below, `10 + 11` will be
-  evaluated at compilation time and the age field will be stored
-  with value `21`:
+  For more information, [see IEx documentation](https://hexdocs.pm/iex/IEx.html#module-dbg-and-breakpoints).
 
-      defmodule User do
-        defstruct name: nil, age: 10 + 11
-      end
+  ## Configuring the debug function
 
-  ## Deriving
+  One of the benefits of `dbg/2` is that its debugging logic is configurable,
+  allowing tools to extend `dbg` with enhanced behaviour. This is done, for
+  example, by `IEx` which extends `dbg` with an interactive shell where you
+  can directly inspect and access values.
 
-  Although structs are maps, by default structs do not implement
-  any of the protocols implemented for maps. For example, if you
-  attempt to use the access protocol with the User struct, it
-  will lead to an error:
+  The debug function can be configured at compile time through the `:dbg_callback`
+  key of the `:elixir` application. The debug function must be a
+  `{module, function, args}` tuple. The `function` function in `module` will be
+  invoked with three arguments *prepended* to `args`:
 
-      %User{}[:age]
-      ** (Protocol.UndefinedError) protocol Access not implemented for %User{...}
+    1. The AST of `code`
+    2. The AST of `options`
+    3. The `Macro.Env` environment of where `dbg/2` is invoked
 
-  However, `defstruct/2` allows implementation for protocols to
-  derived by defining a `@derive` attribute as a list before `defstruct/2`
-  is invoked:
+  The debug function is invoked at compile time and it must also return an AST.
+  The AST is expected to ultimately return the result of evaluating the debugged
+  expression.
 
-      defmodule User do
-        @derive [Access]
-        defstruct name: nil, age: 10 + 11
-      end
+  Here's a simple example:
 
-      %User{}[:age] #=> 21
+      defmodule MyMod do
+        def debug_fun(code, options, caller, device) do
+          quote do
+            result = unquote(code)
+            IO.inspect(unquote(device), result, label: unquote(Macro.to_string(code)))
+          end
+        end
+      end
 
-  For each protocol given to `@derive`, Elixir will assert there is an
-  implementation of that protocol for maps and check if the map
-  implementation defines a `__deriving__/3` callback. If so, the callback
-  is invoked, otherwise an implementation that simply points to the map
-  one is automatically derived.
+  To configure the debug function:
 
-  ## Types
+      # In config/config.exs
+      config :elixir, :dbg_callback, {MyMod, :debug_fun, [:stdio]}
 
-  `defstruct` automatically generates a type `t` unless one exists.
-  The following definition:
+  ### Default debug function
 
-      defmodule User do
-        defstruct name: "José" :: String.t,
-                  age: 25 :: integer
-      end
+  By default, the debug function we use is `Macro.dbg/3`. It just prints
+  information about the code to standard output and returns the value
+  returned by evaluating `code`. `options` are used to control how terms
+  are inspected. They are the same options accepted by `inspect/2`.
+  """
+  @doc since: "1.14.0"
+  defmacro dbg(code \\ quote(do: binding()), options \\ []) do
+    {mod, fun, args} = Application.compile_env!(__CALLER__, :elixir, :dbg_callback)
+    Macro.compile_apply(mod, fun, [code, options, __CALLER__ | args], __CALLER__)
+  end
 
-  Generates a type as follows:
+  hour_in_ms = 1000 * 60 * 60
+  day_in_ms = 24 * hour_in_ms
+  week_in_ms = 7 * day_in_ms
 
-      @type t :: %User{name: String.t, age: integer}
+  @doc """
+  Constructs a millisecond timeout from the given components, duration, or timeout.
 
-  In case a struct does not declare a field type, it defaults to `term`.
-  """
-  defmacro defstruct(kv) do
-    {fields, types} = split_fields_and_types(kv)
+  This function is useful for constructing timeouts to use in functions that
+  expect `t:timeout/0` values (such as `Process.send_after/4` and many others).
 
-    fields =
-      quote bind_quoted: [fields: fields] do
-        fields = :lists.map(fn
-          { key, _ } = pair when is_atom(key) -> pair
-          key when is_atom(key) -> { key, nil }
-          other -> raise ArgumentError, "struct field names must be atoms, got: #{inspect other}"
-        end, fields)
+  ## Argument
 
-        @struct :maps.put(:__struct__, __MODULE__, :maps.from_list(fields))
+  The `duration` argument can be one of a `Duration`, a `t:timeout/0`, or a list
+  of components. Each of these is described below.
 
-        case Module.get_attribute(__MODULE__, :derive) do
-          [] ->
-            :ok
-          derive ->
-            Protocol.__derive__(derive, __MODULE__, __ENV__)
-        end
+  ### Passing `Duration`s
 
-        @spec __struct__() :: t
-        def __struct__() do
-          @struct
-        end
-      end
+  `t:Duration.t/0` structs can be converted to timeouts. The given duration must have
+  `year` and `month` fields set to `0`, since those cannot be reliably converted to
+  milliseconds (due to the varying number of days in a month and year).
 
-    types =
-      case bootstraped?(Kernel.Typespec) do
-        true when types == [] ->
-          quote unquote: false do
-            unless Kernel.Typespec.defines_type?(__MODULE__, :t, 0) do
-              types = :lists.map(fn {key, _} ->
-                {key, quote(do: term)}
-              end, fields)
-              @type t :: %{unquote_splicing(types), __struct__: __MODULE__}
-            end
-          end
-        true ->
-          quote do
-            unless Kernel.Typespec.defines_type?(__MODULE__, :t, 0) do
-              @type t :: %{unquote_splicing(types), __struct__: __MODULE__}
-            end
-          end
-        false ->
-          nil
-      end
+  Microseconds in durations are converted to milliseconds (through `System.convert_time_unit/3`).
 
-    quote do
-      unquote(fields)
-      unquote(types)
-      fields
-    end
-  end
+  ### Passing components
 
-  defp split_fields_and_types(kv) do
-    case Keyword.keyword?(kv) do
-      true  -> split_fields_and_types(kv, [], [])
-      false -> {kv, []}
-    end
-  end
+  The `duration` argument can also be keyword list which can contain the following
+  keys, each appearing at most once with a non-negative integer value:
 
-  defp split_fields_and_types([{field, {:::, _, [default, type]}}|t], fields, types) do
-    split_fields_and_types(t, [{field, default}|fields], [{field, type}|types])
-  end
+    * `:week` - the number of weeks (a week is always 7 days)
+    * `:day` - the number of days (a day is always 24 hours)
+    * `:hour` - the number of hours
+    * `:minute` - the number of minutes
+    * `:second` - the number of seconds
+    * `:millisecond` - the number of milliseconds
 
-  defp split_fields_and_types([{field, default}|t], fields, types) do
-    split_fields_and_types(t, [{field, default}|fields], [{field, quote(do: term)}|types])
-  end
+  The timeout is calculated as the sum of the components, each multiplied by
+  the corresponding factor.
 
-  defp split_fields_and_types([field|t], fields, types) do
-    split_fields_and_types(t, [field|fields], [{field, quote(do: term)}|types])
-  end
+  ### Passing timeouts
 
-  defp split_fields_and_types([], fields, types) do
-    {:lists.reverse(fields), :lists.reverse(types)}
-  end
+  You can also pass timeouts directly to this functions, that is, milliseconds or
+  the atom `:infinity`. In this case, this function just returns the given argument.
 
-  @doc ~S"""
-  Defines an exception.
+  ## Examples
 
-  Exceptions are structs backed by a module that implements
-  the Exception behaviour. The Exception behaviour requires
-  two functions to be implemented:
+  With a keyword list:
 
-    * `exception/1` - that receives the arguments given to `raise/2`
-       and returns the exception struct. The default implementation
-       accepts a set of keyword arguments that is merged into the
-       struct.
+      iex> to_timeout(hour: 1, minute: 30)
+      5400000
 
-    * `message/1` - receives the exception struct and must return its
-      message. Most commonly exceptions have a message field which
-      by default is accessed by this function. However, if your exception
-      does not have a message field, this function must be explicitly
-      implemented.
+  With a duration:
 
-  Since exceptions are structs, all the API supported by `defstruct/1`
-  is also available in `defexception/1`.
+      iex> to_timeout(%Duration{hour: 1, minute: 30})
+      5400000
 
-  ## Raising exceptions
+  With a timeout:
 
-  The most common way to raise an exception is via the `raise/2`
-  function:
+      iex> to_timeout(5_400_000)
+      5400000
+      iex> to_timeout(:infinity)
+      :infinity
 
-      defmodule MyAppError do
-        defexception [:message]
-      end
+  """
+  @doc since: "1.17.0"
+  @spec to_timeout([{unit, non_neg_integer()}] | timeout() | Duration.t()) :: timeout()
+        when unit: :week | :day | :hour | :minute | :second | :millisecond
+  def to_timeout(duration)
 
-      raise MyAppError,
-        message: "did not get what was expected, got: #{inspect value}"
+  def to_timeout(:infinity), do: :infinity
+  def to_timeout(timeout) when is_integer(timeout) and timeout >= 0, do: timeout
 
-  In many cases it is more convenient to pass the expected value to
-  `raise` and generate the message in the `exception/1` callback:
+  def to_timeout(%{__struct__: Duration} = duration) do
+    case duration do
+      %{year: year} when year != 0 ->
+        raise ArgumentError,
+              "duration with a non-zero year cannot be reliably converted to timeouts"
 
-      defmodule MyAppError do
-        defexception [:message]
+      %{month: month} when month != 0 ->
+        raise ArgumentError,
+              "duration with a non-zero month cannot be reliably converted to timeouts"
+
+      _other ->
+        {microsecond, _precision} = duration.microsecond
+        millisecond = :erlang.convert_time_unit(microsecond, :microsecond, :millisecond)
+
+        duration.week * unquote(week_in_ms) +
+          duration.day * unquote(day_in_ms) +
+          duration.hour * unquote(hour_in_ms) +
+          duration.minute * 60_000 +
+          duration.second * 1000 +
+          millisecond
+    end
+  end
 
-        def exception(value) do
-          msg = "did not get what was expected, got: #{inspect value}"
-          %MyAppError{message: msg}
+  def to_timeout(components) when is_list(components) do
+    reducer = fn
+      {key, value}, {acc, seen_keys} when is_integer(value) and value >= 0 ->
+        case :lists.member(key, seen_keys) do
+          true ->
+            raise ArgumentError, "timeout component #{inspect(key)} is duplicated"
+
+          false ->
+            :ok
         end
-      end
 
-      raise MyAppError, value
+        factor =
+          case key do
+            :week ->
+              unquote(week_in_ms)
 
-  The example above is the preferred mechanism for customizing
-  exception messages.
-  """
-  defmacro defexception(fields) do
-    fields = case is_list(fields) do
-      true  -> [{:__exception__, true}|fields]
-      false -> quote(do: [{:__exception__, true}] ++ unquote(fields))
-    end
+            :day ->
+              unquote(day_in_ms)
 
-    quote do
-      @behaviour Exception
-      fields = defstruct unquote(fields)
+            :hour ->
+              unquote(hour_in_ms)
 
-      @spec exception(term) :: t
-      def exception(args) when is_list(args) do
-        Kernel.struct(__struct__, args)
-      end
+            :minute ->
+              60_000
 
-      defoverridable exception: 1
+            :second ->
+              1000
 
-      if Keyword.has_key?(fields, :message) do
-        @spec message(t) :: String.t
-        def message(exception) do
-          exception.message
-        end
+            :millisecond ->
+              1
 
-        defoverridable message: 1
-      end
+            other ->
+              raise ArgumentError, """
+              timeout component #{inspect(other)} is not a valid timeout component, valid \
+              values are: :week, :day, :hour, :minute, :second, :millisecond\
+              """
+          end
+
+        {acc + value * factor, [key | seen_keys]}
+
+      {key, value}, {_acc, _seen_keys} ->
+        raise ArgumentError,
+              "timeout component #{inspect(key)} must be a non-negative " <>
+                "integer, got: #{inspect(value)}"
     end
+
+    elem(:lists.foldl(reducer, {0, _seen_keys = []}, components), 0)
   end
 
-  @doc """
-  Defines a protocol.
+  ## Sigils
+
+  @doc ~S"""
+  Handles the sigil `~S` for strings.
 
-  A protocol specifies an API that should be defined by its
-  implementations.
+  It returns a string without interpolations and without escape
+  characters.
 
   ## Examples
 
-  In Elixir, only `false` and `nil` are considered falsy values.
-  Everything else evaluates to true in `if` clauses. Depending
-  on the application, it may be important to specify a `blank?`
-  protocol that returns a boolean for other data types that should
-  be considered `blank?`. For instance, an empty list or an empty
-  binary could be considered blanks.
+      iex> ~S(foo)
+      "foo"
+      iex> ~S(f#{o}o)
+      "f\#{o}o"
+      iex> ~S(\o/)
+      "\\o/"
 
-  We could implement this protocol as follow:
+  """
+  defmacro sigil_S(term, modifiers)
+  defmacro sigil_S({:<<>>, _, [binary]}, []) when is_binary(binary), do: binary
 
-      defprotocol Blank do
-        @doc "Returns true if data is considered blank/empty"
-        def blank?(data)
-      end
+  @doc ~S"""
+  Handles the sigil `~s` for strings.
 
-  Now that the protocol is defined, we can implement it. We need
-  to implement the protocol for each Elixir type. For example:
+  It returns a string as if it was a double quoted string, unescaping characters
+  and replacing interpolations.
 
-      # Integers are never blank
-      defimpl Blank, for: Integer do
-        def blank?(number), do: false
-      end
+  ## Examples
 
-      # Just empty list is blank
-      defimpl Blank, for: List do
-        def blank?([]), do: true
-        def blank?(_),  do: false
-      end
+      iex> ~s(foo)
+      "foo"
 
-      # Just the atoms false and nil are blank
-      defimpl Blank, for: Atom do
-        def blank?(false), do: true
-        def blank?(nil),   do: true
-        def blank?(_),     do: false
-      end
+      iex> ~s(f#{:o}o)
+      "foo"
 
-  And we would have to define the implementation for all types.
-  The supported types available are:
+      iex> ~s(f\#{:o}o)
+      "f\#{:o}o"
 
-    * Structs (see below)
-    * `Tuple`
-    * `Atom`
-    * `List`
-    * `BitString`
-    * `Integer`
-    * `Float`
-    * `Function`
-    * `PID`
-    * `Map`
-    * `Port`
-    * `Reference`
-    * `Any` (see below)
+  """
+  defmacro sigil_s(term, modifiers)
 
-  ## Protocols + Structs
+  defmacro sigil_s({:<<>>, _, [piece]}, []) when is_binary(piece) do
+    :elixir_interpolation.unescape_string(piece)
+  end
 
-  The real benefit of protocols comes when mixed with structs.
-  For instance, Elixir ships with many data types implemented as
-  structs, like `HashDict` and `HashSet`. We can implement the
-  `Blank` protocol for those types as well:
+  defmacro sigil_s({:<<>>, line, pieces}, []) do
+    {:<<>>, line, unescape_tokens(pieces)}
+  end
 
-      defimpl Blank, for: [HashDict, HashSet] do
-        def blank?(enum_like), do: Enum.empty?(enum_like)
-      end
+  @doc ~S"""
+  Handles the sigil `~C` for charlists.
 
-  If a protocol is not found for a given type, it will fallback to
-  `Any`.
+  It returns a charlist without interpolations and without escape
+  characters.
 
-  ## Fallback to any
+  A charlist is a list of integers where all the integers are valid code points.
+  The three expressions below are equivalent:
 
-  In some cases, it may be convenient to provide a default
-  implementation for all types. This can be achieved by
-  setting `@fallback_to_any` to `true` in the protocol
-  definition:
+      ~C"foo\n"
+      [?f, ?o, ?o, ?\\, ?n]
+      [102, 111, 111, 92, 110]
 
-      defprotocol Blank do
-        @fallback_to_any true
-        def blank?(data)
-      end
+  In practice, charlists are mostly used in specific scenarios such as
+  interfacing with older Erlang libraries that do not accept binaries as arguments.
 
-  Which can now be implemented as:
+  ## Examples
 
-      defimpl Blank, for: Any do
-        def blank?(_), do: true
-      end
+      iex> ~C(foo)
+      ~c"foo"
 
-  One may wonder why such fallback is not true by default.
+      iex> ~C(f#{o}o)
+      ~c"f\#{o}o"
 
-  It is two-fold: first, the majority of protocols cannot
-  implement an action in a generic way for all types. In fact,
-  providing a default implementation may be harmful, because users
-  may rely on the default implementation instead of providing a
-  specialized one.
+      iex> ~C(foo\n)
+      ~c"foo\\n"
 
-  Second, falling back to `Any` adds an extra lookup to all types,
-  which is unnecessary overhead unless an implementation for Any is
-  required.
+  """
+  defmacro sigil_C(term, modifiers)
 
-  ## Types
+  defmacro sigil_C({:<<>>, _meta, [string]}, []) when is_binary(string) do
+    String.to_charlist(string)
+  end
 
-  Defining a protocol automatically defines a type named `t`, which
-  can be used as:
+  @doc ~S"""
+  Handles the sigil `~c` for charlists.
 
-      @spec present?(Blank.t) :: boolean
-      def present?(blank) do
-        not Blank.blank?(blank)
-      end
+  It returns a charlist, unescaping characters and replacing interpolations.
 
-  The `@spec` above expresses that all types allowed to implement the
-  given protocol are valid argument types for the given function.
+  A charlist is a list of integers where all the integers are valid code points.
+  The three expressions below are equivalent:
 
-  ## Reflection
+      ~c"foo"
+      [?f, ?o, ?o]
+      [102, 111, 111]
 
-  Any protocol module contains three extra functions:
+  In practice, charlists are mostly used in specific scenarios such as
+  interfacing with older Erlang libraries that do not accept binaries as arguments.
 
+  ## Examples
 
-    * `__protocol__/1` - returns the protocol name when `:name` is given, and a
-      keyword list with the protocol functions when `:functions` is given
+      iex> ~c(foo)
+      ~c"foo"
 
-    * `impl_for/1` - receives a structure and returns the module that
-      implements the protocol for the structure, `nil` otherwise
+      iex> ~c(f#{:o}o)
+      ~c"foo"
 
-    * `impl_for!/1` - same as above but raises an error if an implementation is
-      not found
+      iex> ~c(f\#{:o}o)
+      ~c"f\#{:o}o"
 
-  ## Consolidation
+  The list is only printed as a `~c` sigil if all code points are within the
+  ASCII range:
 
-  In order to cope with code loading in development, protocols in
-  Elixir provide a slow implementation of protocol dispatching specific
-  to development.
+      iex> ~c"hełło"
+      [104, 101, 322, 322, 111]
 
-  In order to speed up dispatching in production environments, where
-  all implementations are known up-front, Elixir provides a feature
-  called protocol consolidation. For this reason, all protocols are
-  compiled with `debug_info` set to true, regardless of the option
-  set by `elixirc` compiler. The debug info though may be removed
-  after consolidation.
+      iex> [104, 101, 108, 108, 111]
+      ~c"hello"
 
-  For more information on how to apply protocol consolidation to
-  a given project, please check the functions in the `Protocol`
-  module or the `mix compile.protocols` task.
+  See `Inspect.Opts` for more information.
   """
-  defmacro defprotocol(name, do: block) do
-    Protocol.__protocol__(name, do: block)
-  end
+  defmacro sigil_c(term, modifiers)
 
-  @doc """
-  Defines an implementation for the given protocol. See
-  `defprotocol/2` for examples.
+  # We can skip the runtime conversion if we are
+  # creating a binary made solely of series of chars.
+  defmacro sigil_c({:<<>>, _meta, [string]}, []) when is_binary(string) do
+    String.to_charlist(:elixir_interpolation.unescape_string(string))
+  end
 
-  Inside an implementation, the name of the protocol can be accessed
-  via `@protocol` and the current target as `@for`.
-  """
-  defmacro defimpl(name, opts, do_block \\ []) do
-    merged = Keyword.merge(opts, do_block)
-    merged = Keyword.put_new(merged, :for, __CALLER__.module)
-    Protocol.__impl__(name, merged)
+  defmacro sigil_c({:<<>>, _meta, pieces}, []) do
+    quote(do: List.to_charlist(unquote(unescape_list_tokens(pieces))))
   end
 
-  @doc """
-  Makes the given functions in the current module overridable. An overridable
-  function is lazily defined, allowing a developer to customize it.
+  @doc ~S"""
+  Handles the sigil `~r` for regular expressions.
 
-  ## Example
+  It returns a regular expression pattern, unescaping characters and replacing
+  interpolations.
 
-      defmodule DefaultMod do
-        defmacro __using__(_opts) do
-          quote do
-            def test(x, y) do
-              x + y
-            end
+  More information on regular expressions can be found in the `Regex` module.
 
-            defoverridable [test: 2]
-          end
-        end
-      end
+  ## Examples
 
-      defmodule InheritMod do
-        use DefaultMod
+      iex> Regex.match?(~r/foo/, "foo")
+      true
 
-        def test(x, y) do
-          x * y + super(x, y)
-        end
-      end
+      iex> Regex.match?(~r/a#{:b}c/, "abc")
+      true
 
-  As seen as in the example `super` can be used to call the default
-  implementation.
+  While the `~r` sigil allows parens and brackets to be used as delimiters,
+  it is preferred to use `"` or `/` to avoid escaping conflicts with reserved
+  regex characters.
   """
-  defmacro defoverridable(tuples) do
-    quote do
-      Module.make_overridable(__MODULE__, unquote(tuples))
-    end
-  end
-
-  @doc """
-  `use` is a simple mechanism for using a given module into
-  the current context.
-
-  ## Examples
-
-  For example, in order to write tests using the ExUnit framework,
-  a developer should use the `ExUnit.Case` module:
+  defmacro sigil_r(term, modifiers)
 
-      defmodule AssertionTest do
-        use ExUnit.Case, async: true
+  defmacro sigil_r({:<<>>, _meta, [binary]}, options) when is_binary(binary) do
+    assert_no_match_or_guard_scope(__CALLER__.context, "the ~r sigil")
+    binary = :elixir_interpolation.unescape_string(binary, &regex_unescape_map/1)
+    compile_regex(binary, options)
+  end
 
-        test "always pass" do
-          assert true
-        end
-      end
+  defmacro sigil_r({:<<>>, meta, pieces}, options) do
+    assert_no_match_or_guard_scope(__CALLER__.context, "the ~r sigil")
+    tuple = {:<<>>, meta, unescape_tokens(pieces, &regex_unescape_map/1)}
+    compile_regex(tuple, options)
+  end
 
-  By calling `use`, a hook called `__using__` will be invoked in
-  `ExUnit.Case` which will then do the proper setup.
+  defp regex_unescape_map(:newline), do: true
+  defp regex_unescape_map(_), do: false
 
-  Simply put, `use` is simply a translation to:
+  @doc false
+  defmacro sigil_R({:<<>>, _meta, [binary]}, options) when is_binary(binary) do
+    IO.warn(
+      "~R/.../ is deprecated, use ~r/.../ instead",
+      Macro.Env.stacktrace(__CALLER__)
+    )
 
-      defmodule AssertionTest do
-        require ExUnit.Case
-        ExUnit.Case.__using__([async: true])
+    compile_regex(binary, options)
+  end
 
-        test "always pass" do
-          assert true
-        end
-      end
+  defp compile_regex(binary_or_tuple, options) do
+    bin_opts = :binary.list_to_bin(options)
 
-  """
-  defmacro use(module, opts \\ []) do
-    expanded = Macro.expand(module, __CALLER__)
+    case is_binary(binary_or_tuple) do
+      true ->
+        Macro.escape(Regex.compile!(binary_or_tuple, bin_opts))
 
-    case is_atom(expanded) do
       false ->
-        raise ArgumentError, "invalid arguments for use, expected an atom or alias as argument"
-      true ->
-        quote do
-          require unquote(expanded)
-          unquote(expanded).__using__(unquote(opts))
-        end
+        quote(do: Regex.compile!(unquote(binary_or_tuple), unquote(bin_opts)))
     end
   end
 
-  @doc """
-  Defines the given functions in the current module that will
-  delegate to the given `target`. Functions defined with
-  `defdelegate` are public and are allowed to be invoked
-  from external. If you find yourself wishing to define a
-  delegation as private, you should likely use import
-  instead.
+  @doc ~S"""
+  Handles the sigil `~D` for dates.
 
-  Delegation only works with functions, delegating to macros
-  is not supported.
+  By default, this sigil uses the built-in `Calendar.ISO`, which
+  requires dates to be written in the ISO8601 format:
 
-  ## Options
+      ~D[yyyy-mm-dd]
 
-    * `:to` - the expression to delegate to. Any expression
-      is allowed and its results will be calculated on runtime.
+  such as:
 
-    * `:as` - the function to call on the target given in `:to`.
-      This parameter is optional and defaults to the name being
-      delegated.
+      ~D[2015-01-13]
 
-    * `:append_first` - if true, when delegated, first argument
-      passed to the delegate will be relocated to the end of the
-      arguments when dispatched to the target.
+  If you are using alternative calendars, any representation can
+  be used as long as you follow the representation by a single space
+  and the calendar name:
 
-      The motivation behind this is because Elixir normalizes
-      the "handle" as a first argument and some Erlang modules
-      expect it as last argument.
+      ~D[SOME-REPRESENTATION My.Alternative.Calendar]
 
-  ## Examples
+  The lower case `~d` variant does not exist as interpolation
+  and escape characters are not useful for date sigils.
 
-      defmodule MyList do
-        defdelegate reverse(list), to: :lists
-        defdelegate [reverse(list), map(callback, list)], to: :lists
-        defdelegate other_reverse(list), to: :lists, as: :reverse
-      end
+  More information on dates can be found in the `Date` module.
 
-      MyList.reverse([1, 2, 3])
-      #=> [3,2,1]
+  ## Examples
 
-      MyList.other_reverse([1, 2, 3])
-      #=> [3,2,1]
+      iex> ~D[2015-01-13]
+      ~D[2015-01-13]
 
   """
-  defmacro defdelegate(funs, opts) do
-    funs = Macro.escape(funs, unquote: true)
-    quote bind_quoted: [funs: funs, opts: opts] do
-      target = Keyword.get(opts, :to) ||
-        raise ArgumentError, "Expected to: to be given as argument"
+  defmacro sigil_D(date_string, modifiers)
 
-      append_first = Keyword.get(opts, :append_first, false)
+  defmacro sigil_D({:<<>>, _, [string]}, []) do
+    {{:ok, {year, month, day}}, calendar} = parse_with_calendar!(string, :parse_date, "Date")
+    to_calendar_struct(Date, calendar: calendar, year: year, month: month, day: day)
+  end
 
-      for fun <- List.wrap(funs) do
-        {name, args} =
-          case Macro.decompose_call(fun) do
-            {_, _} = pair -> pair
-            _ -> raise ArgumentError, "invalid syntax in defdelegate #{Macro.to_string(fun)}"
-          end
+  @doc ~S"""
+  Handles the sigil `~T` for times.
 
-        actual_args =
-          case append_first and args != [] do
-            true  -> tl(args) ++ [hd(args)]
-            false -> args
-          end
+  By default, this sigil uses the built-in `Calendar.ISO`, which
+  requires times to be written in the ISO8601 format:
 
-        fun = Keyword.get(opts, :as, name)
+      ~T[hh:mm:ss]
+      ~T[hh:mm:ss.ssssss]
 
-        def unquote(name)(unquote_splicing(args)) do
-          unquote(target).unquote(fun)(unquote_splicing(actual_args))
-        end
-      end
-    end
-  end
+  such as:
 
-  ## Sigils
+      ~T[13:00:07]
+      ~T[13:00:07.123]
 
-  @doc """
-  Handles the sigil ~S. It simply returns a string
-  without escaping characters and without interpolations.
+  If you are using alternative calendars, any representation can
+  be used as long as you follow the representation by a single space
+  and the calendar name:
 
-  ## Examples
+      ~T[SOME-REPRESENTATION My.Alternative.Calendar]
 
-      iex> ~S(foo)
-      "foo"
+  The lower case `~t` variant does not exist as interpolation
+  and escape characters are not useful for time sigils.
 
-      iex> ~S(f\#{o}o)
-      "f\\\#{o}o"
+  More information on times can be found in the `Time` module.
+
+  ## Examples
+
+      iex> ~T[13:00:07]
+      ~T[13:00:07]
+      iex> ~T[13:00:07.001]
+      ~T[13:00:07.001]
 
   """
-  defmacro sigil_S(string, []) do
-    string
+  defmacro sigil_T(time_string, modifiers)
+
+  defmacro sigil_T({:<<>>, _, [string]}, []) do
+    {{:ok, {hour, minute, second, microsecond}}, calendar} =
+      parse_with_calendar!(string, :parse_time, "Time")
+
+    to_calendar_struct(Time,
+      calendar: calendar,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    )
   end
 
-  @doc """
-  Handles the sigil ~s. It returns a string as if it was double quoted
-  string, unescaping characters and replacing interpolations.
+  @doc ~S"""
+  Handles the sigil `~N` for naive date times.
 
-  ## Examples
+  By default, this sigil uses the built-in `Calendar.ISO`, which
+  requires naive date times to be written in the ISO8601 format:
 
-      iex> ~s(foo)
-      "foo"
+      ~N[yyyy-mm-dd hh:mm:ss]
+      ~N[yyyy-mm-dd hh:mm:ss.ssssss]
+      ~N[yyyy-mm-ddThh:mm:ss.ssssss]
 
-      iex> ~s(f\#{:o}o)
-      "foo"
+  such as:
 
-  """
-  defmacro sigil_s({:<<>>, line, pieces}, []) do
-    {:<<>>, line, Macro.unescape_tokens(pieces)}
-  end
+      ~N[2015-01-13 13:00:07]
+      ~N[2015-01-13T13:00:07.123]
 
-  @doc """
-  Handles the sigil ~C. It simply returns a char list
-  without escaping characters and without interpolations.
+  If you are using alternative calendars, any representation can
+  be used as long as you follow the representation by a single space
+  and the calendar name:
 
-  ## Examples
+      ~N[SOME-REPRESENTATION My.Alternative.Calendar]
 
-      iex> ~C(foo)
-      'foo'
+  The lower case `~n` variant does not exist as interpolation
+  and escape characters are not useful for date time sigils.
+
+  More information on naive date times can be found in the
+  `NaiveDateTime` module.
+
+  ## Examples
 
-      iex> ~C(f\#{o}o)
-      'f\\\#{o}o'
+      iex> ~N[2015-01-13 13:00:07]
+      ~N[2015-01-13 13:00:07]
+      iex> ~N[2015-01-13T13:00:07.001]
+      ~N[2015-01-13 13:00:07.001]
 
   """
-  defmacro sigil_C({:<<>>, _line, [string]}, []) when is_binary(string) do
-    String.to_char_list(string)
+  defmacro sigil_N(naive_datetime_string, modifiers)
+
+  defmacro sigil_N({:<<>>, _, [string]}, []) do
+    {{:ok, {year, month, day, hour, minute, second, microsecond}}, calendar} =
+      parse_with_calendar!(string, :parse_naive_datetime, "NaiveDateTime")
+
+    to_calendar_struct(NaiveDateTime,
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond
+    )
   end
 
-  @doc """
-  Handles the sigil ~c. It returns a char list as if it were a single
-  quoted string, unescaping characters and replacing interpolations.
+  @doc ~S"""
+  Handles the sigil `~U` to create a UTC `DateTime`.
 
-  ## Examples
+  By default, this sigil uses the built-in `Calendar.ISO`, which
+  requires UTC date times to be written in the ISO8601 format:
 
-      iex> ~c(foo)
-      'foo'
+      ~U[yyyy-mm-dd hh:mm:ssZ]
+      ~U[yyyy-mm-dd hh:mm:ss.ssssssZ]
+      ~U[yyyy-mm-ddThh:mm:ss.ssssss+00:00]
 
-      iex> ~c(f\#{:o}o)
-      'foo'
+  such as:
 
-  """
+      ~U[2015-01-13 13:00:07Z]
+      ~U[2015-01-13T13:00:07.123+00:00]
 
-  # We can skip the runtime conversion if we are
-  # creating a binary made solely of series of chars.
-  defmacro sigil_c({:<<>>, _line, [string]}, []) when is_binary(string) do
-    String.to_char_list(Macro.unescape_string(string))
-  end
+  If you are using alternative calendars, any representation can
+  be used as long as you follow the representation by a single space
+  and the calendar name:
 
-  defmacro sigil_c({:<<>>, line, pieces}, []) do
-    binary = {:<<>>, line, Macro.unescape_tokens(pieces)}
-    quote do: String.to_char_list(unquote(binary))
-  end
+      ~U[SOME-REPRESENTATION My.Alternative.Calendar]
 
-  @doc """
-  Handles the sigil ~r. It returns a Regex pattern.
+  The given `datetime_string` must include "Z" or "00:00" offset
+  which marks it as UTC, otherwise an error is raised.
+
+  The lower case `~u` variant does not exist as interpolation
+  and escape characters are not useful for date time sigils.
+
+  More information on date times can be found in the `DateTime` module.
 
   ## Examples
 
-      iex> Regex.match?(~r(foo), "foo")
-      true
+      iex> ~U[2015-01-13 13:00:07Z]
+      ~U[2015-01-13 13:00:07Z]
+      iex> ~U[2015-01-13T13:00:07.001+00:00]
+      ~U[2015-01-13 13:00:07.001Z]
 
   """
-  defmacro sigil_r({:<<>>, _line, [string]}, options) when is_binary(string) do
-    binary = Macro.unescape_string(string, fn(x) -> Regex.unescape_map(x) end)
-    regex  = Regex.compile!(binary, :binary.list_to_bin(options))
-    Macro.escape(regex)
+  @doc since: "1.9.0"
+  defmacro sigil_U(datetime_string, modifiers)
+
+  defmacro sigil_U({:<<>>, _, [string]}, []) do
+    {{:ok, {year, month, day, hour, minute, second, microsecond}, offset}, calendar} =
+      parse_with_calendar!(string, :parse_utc_datetime, "UTC DateTime")
+
+    if offset != 0 do
+      raise ArgumentError,
+            "cannot parse #{inspect(string)} as UTC DateTime for #{inspect(calendar)}, reason: :non_utc_offset"
+    end
+
+    to_calendar_struct(DateTime,
+      calendar: calendar,
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      time_zone: "Etc/UTC",
+      zone_abbr: "UTC",
+      utc_offset: 0,
+      std_offset: 0
+    )
+  end
+
+  defp parse_with_calendar!(string, fun, context) do
+    {calendar, string} = extract_calendar(string)
+    result = apply(calendar, fun, [string])
+    {maybe_raise!(result, calendar, context, string), calendar}
+  end
+
+  defp extract_calendar(string) do
+    case :binary.split(string, " ", [:global]) do
+      [_] -> {Calendar.ISO, string}
+      parts -> maybe_atomize_calendar(List.last(parts), string)
+    end
   end
 
-  defmacro sigil_r({:<<>>, line, pieces}, options) do
-    binary = {:<<>>, line, Macro.unescape_tokens(pieces, fn(x) -> Regex.unescape_map(x) end)}
-    quote do: Regex.compile!(unquote(binary), unquote(:binary.list_to_bin(options)))
+  defp maybe_atomize_calendar(<<alias, _::binary>> = last_part, string)
+       when alias >= ?A and alias <= ?Z do
+    string = binary_part(string, 0, byte_size(string) - byte_size(last_part) - 1)
+    {String.to_atom("Elixir." <> last_part), string}
   end
 
-  @doc """
-  Handles the sigil ~R. It returns a Regex pattern without escaping
-  nor interpreting interpolations.
+  defp maybe_atomize_calendar(_last_part, string) do
+    {Calendar.ISO, string}
+  end
 
-  ## Examples
+  defp maybe_raise!({:error, reason}, calendar, type, string) do
+    raise ArgumentError,
+          "cannot parse #{inspect(string)} as #{type} for #{inspect(calendar)}, " <>
+            "reason: #{inspect(reason)}"
+  end
 
-      iex> Regex.match?(~R(f\#{1,3}o), "f\#o")
-      true
+  defp maybe_raise!(other, _calendar, _type, _string), do: other
 
-  """
-  defmacro sigil_R({:<<>>, _line, [string]}, options) when is_binary(string) do
-    regex = Regex.compile!(string, :binary.list_to_bin(options))
-    Macro.escape(regex)
+  defp to_calendar_struct(type, fields) do
+    quote do
+      %unquote(type){unquote_splicing(fields)}
+    end
   end
 
-  @doc """
-  Handles the sigil ~w. It returns a list of "words" split by whitespace.
+  @doc ~S"""
+  Handles the sigil `~w` for list of words.
+
+  It returns a list of "words" split by whitespace. Character unescaping and
+  interpolation happens for each word.
 
   ## Modifiers
 
-    * `s`: strings (default)
-    * `a`: atoms
-    * `c`: char lists
+    * `s`: words in the list are strings (default)
+    * `a`: words in the list are atoms
+    * `c`: words in the list are charlists
 
   ## Examples
 
-      iex> ~w(foo \#{:bar} baz)
+      iex> ~w(foo #{:bar} baz)
+      ["foo", "bar", "baz"]
+
+      iex> ~w(foo #{" bar baz "})
       ["foo", "bar", "baz"]
 
       iex> ~w(--source test/enum_test.exs)
@@ -3440,96 +6919,168 @@ defmodule Kernel do
       iex> ~w(foo bar baz)a
       [:foo, :bar, :baz]
 
+      iex> ~w(foo bar baz)c
+      [~c"foo", ~c"bar", ~c"baz"]
+
   """
+  defmacro sigil_w(term, modifiers)
 
-  defmacro sigil_w({:<<>>, _line, [string]}, modifiers) when is_binary(string) do
-    split_words(Macro.unescape_string(string), modifiers)
+  defmacro sigil_w({:<<>>, _meta, [string]}, modifiers) when is_binary(string) do
+    split_words(:elixir_interpolation.unescape_string(string), modifiers, __CALLER__)
   end
 
-  defmacro sigil_w({:<<>>, line, pieces}, modifiers) do
-    binary = {:<<>>, line, Macro.unescape_tokens(pieces)}
-    split_words(binary, modifiers)
+  defmacro sigil_w({:<<>>, meta, pieces}, modifiers) do
+    binary = {:<<>>, meta, unescape_tokens(pieces)}
+    split_words(binary, modifiers, __CALLER__)
   end
 
-  @doc """
-  Handles the sigil ~W. It returns a list of "words" split by whitespace
-  without escaping nor interpreting interpolations.
+  @doc ~S"""
+  Handles the sigil `~W` for list of words.
+
+  It returns a list of "words" split by whitespace without interpolations
+  and without escape characters.
 
   ## Modifiers
 
-    * `s`: strings (default)
-    * `a`: atoms
-    * `c`: char lists
+    * `s`: words in the list are strings (default)
+    * `a`: words in the list are atoms
+    * `c`: words in the list are charlists
 
   ## Examples
 
-      iex> ~W(foo \#{bar} baz)
-      ["foo", "\\\#{bar}", "baz"]
+      iex> ~W(foo #{bar} baz)
+      ["foo", "\#{bar}", "baz"]
 
   """
-  defmacro sigil_W({:<<>>, _line, [string]}, modifiers) when is_binary(string) do
-    split_words(string, modifiers)
-  end
+  defmacro sigil_W(term, modifiers)
 
-  defp split_words("", _modifiers), do: []
+  defmacro sigil_W({:<<>>, _meta, [string]}, modifiers) when is_binary(string) do
+    split_words(string, modifiers, __CALLER__)
+  end
 
-  defp split_words(string, modifiers) do
-    mod =
-      case modifiers do
-        [] -> ?s
-        [mod] when mod == ?s or mod == ?a or mod == ?c -> mod
-        _else -> raise ArgumentError, "modifier must be one of: s, a, c"
-      end
+  defp split_words(string, [], caller) do
+    split_words(string, [?s], caller)
+  end
 
+  defp split_words(string, [mod], caller)
+       when mod == ?s or mod == ?a or mod == ?c do
     case is_binary(string) do
       true ->
+        parts = String.split(string)
+
+        parts_with_trailing_comma =
+          :lists.filter(&(byte_size(&1) > 1 and :binary.last(&1) == ?,), parts)
+
+        if parts_with_trailing_comma != [] do
+          stacktrace = Macro.Env.stacktrace(caller)
+
+          IO.warn(
+            "the sigils ~w/~W do not allow trailing commas at the end of each word. " <>
+              "If the comma is necessary, define a regular list with [...], otherwise remove the comma.",
+            stacktrace
+          )
+        end
+
         case mod do
-          ?s -> String.split(string)
-          ?a -> for p <- String.split(string), do: String.to_atom(p)
-          ?c -> for p <- String.split(string), do: String.to_char_list(p)
+          ?s -> parts
+          ?a -> :lists.map(&String.to_atom/1, parts)
+          ?c -> :lists.map(&String.to_charlist/1, parts)
         end
+
       false ->
+        parts = quote(do: String.split(unquote(string)))
+
         case mod do
-          ?s -> quote do: String.split(unquote(string))
-          ?a -> quote do: for(p <- String.split(unquote(string)), do: String.to_atom(p))
-          ?c -> quote do: for(p <- String.split(unquote(string)), do: String.to_char_list(p))
+          ?s -> parts
+          ?a -> quote(do: :lists.map(&String.to_atom/1, unquote(parts)))
+          ?c -> quote(do: :lists.map(&String.to_charlist/1, unquote(parts)))
         end
     end
   end
 
-  ## Shared functions
-
-  defp optimize_boolean({:case, meta, args}) do
-    {:case, [{:optimize_boolean, true}|meta], args}
+  defp split_words(_string, _mods, _caller) do
+    raise ArgumentError, "modifier must be one of: s, a, c"
   end
 
-  # We need this check only for bootstrap purposes.
-  # Once Kernel is loaded and we recompile, it is a no-op.
-  case :code.ensure_loaded(Kernel) do
-    {:module, _} ->
-      defp bootstraped?(_), do: true
-    {:error, _} ->
-      defp bootstraped?(module), do: :code.ensure_loaded(module) == {:module, module}
-  end
+  ## Shared functions
 
   defp assert_module_scope(env, fun, arity) do
     case env.module do
       nil -> raise ArgumentError, "cannot invoke #{fun}/#{arity} outside module"
-      _   -> :ok
+      mod -> mod
     end
   end
 
   defp assert_no_function_scope(env, fun, arity) do
     case env.function do
       nil -> :ok
-      _   -> raise ArgumentError, "cannot invoke #{fun}/#{arity} inside function/macro"
+      _ -> raise ArgumentError, "cannot invoke #{fun}/#{arity} inside function/macro"
+    end
+  end
+
+  defp assert_no_match_or_guard_scope(context, exp) do
+    case context do
+      :match ->
+        invalid_match!(exp)
+
+      :guard ->
+        raise ArgumentError,
+              "invalid expression in guard, #{exp} is not allowed in guards. " <>
+                "To learn more about guards, visit: https://hexdocs.pm/elixir/patterns-and-guards.html"
+
+      _ ->
+        :ok
     end
   end
 
-  defp env_stacktrace(env) do
-    case bootstraped?(Path) do
-      true  -> Macro.Env.stacktrace(env)
-      false -> []
+  defp invalid_match!(exp) do
+    raise ArgumentError,
+          "invalid expression in match, #{exp} is not allowed in patterns " <>
+            "such as function clauses, case clauses or on the left side of the = operator"
+  end
+
+  # Helper to handle the :ok | :error tuple returned from :elixir_interpolation.unescape_tokens
+  # We need to do this for bootstrapping purposes, actual code can use Macro.unescape_string.
+  defp unescape_tokens(tokens) do
+    :lists.map(
+      fn token ->
+        case is_binary(token) do
+          true -> :elixir_interpolation.unescape_string(token)
+          false -> token
+        end
+      end,
+      tokens
+    )
+  end
+
+  defp unescape_tokens(tokens, unescape_map) do
+    :lists.map(
+      fn token ->
+        case is_binary(token) do
+          true -> :elixir_interpolation.unescape_string(token, unescape_map)
+          false -> token
+        end
+      end,
+      tokens
+    )
+  end
+
+  defp unescape_list_tokens(tokens) do
+    escape = fn
+      {:"::", _, [expr, _]} -> expr
+      binary when is_binary(binary) -> :elixir_interpolation.unescape_string(binary)
     end
+
+    :lists.map(escape, tokens)
+  end
+
+  @doc false
+  defmacro to_char_list(arg) do
+    IO.warn(
+      "Kernel.to_char_list/1 is deprecated, use Kernel.to_charlist/1 instead",
+      Macro.Env.stacktrace(__CALLER__)
+    )
+
+    quote(do: Kernel.to_charlist(unquote(arg)))
   end
 end
diff --git a/lib/elixir/lib/kernel/cli.ex b/lib/elixir/lib/kernel/cli.ex
index 1e36a9a176c..9a55f941977 100644
--- a/lib/elixir/lib/kernel/cli.ex
+++ b/lib/elixir/lib/kernel/cli.ex
@@ -1,27 +1,50 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Kernel.CLI do
   @moduledoc false
 
-  @blank_config %{commands: [], output: ".", compile: [],
-                  halt: true, compiler_options: [], errors: [],
-                  verbose_compile: false}
+  @compile {:no_warn_undefined, [Logger, IEx]}
+
+  @blank_config %{
+    commands: [],
+    output: ".",
+    compile: [],
+    no_halt: false,
+    compiler_options: [],
+    warnings_as_errors: false,
+    errors: [],
+    verbose_compile: false,
+    profile: nil,
+    pry: false,
+    mode: :elixir
+  }
+
+  @standalone_opts [~c"-h", ~c"--help", ~c"--short-version"]
 
   @doc """
   This is the API invoked by Elixir boot process.
   """
   def main(argv) do
-    argv = for arg <- argv, do: IO.chardata_to_string(arg)
-
     {config, argv} = parse_argv(argv)
-    System.argv(argv)
+    System.argv(Enum.map(argv, &IO.chardata_to_string/1))
+    System.no_halt(config.no_halt)
 
-    run fn ->
+    if config.pry do
+      Application.put_env(:elixir, :dbg_callback, {IEx.Pry, :dbg, []})
+    end
+
+    fun = fn _ ->
       errors = process_commands(config)
 
       if errors != [] do
         Enum.each(errors, &IO.puts(:stderr, &1))
         System.halt(1)
       end
-    end, config.halt
+    end
+
+    run(fun)
   end
 
   @doc """
@@ -32,383 +55,524 @@ defmodule Kernel.CLI do
   This function is used by Elixir's CLI and also
   by escripts generated by Elixir.
   """
-  def run(fun, halt \\ true) do
-    try do
-      fun.()
-      if halt do
-        at_exit(0)
-        System.halt(0)
+  def run(fun) do
+    {ok_or_shutdown, status} = exec_fun(fun, {:ok, 0})
+
+    if ok_or_shutdown == :shutdown or not System.no_halt() do
+      {_, status} = at_exit({ok_or_shutdown, status})
+
+      # Ensure Logger messages are flushed before halting
+      if Code.loaded?(Logger) do
+        Logger.flush()
       end
-    catch
-      :exit, reason when is_integer(reason) ->
-        at_exit(reason)
-        System.halt(reason)
-      :exit, :normal ->
-        at_exit(0)
-        System.halt(0)
-      kind, reason ->
-        at_exit(1)
-        print_error(kind, reason, System.stacktrace)
-        System.halt(1)
+
+      System.halt(status)
     end
   end
 
   @doc """
-  Parses ARGV returning the CLI config and trailing args.
+  Parses the CLI arguments. Made public for testing.
   """
   def parse_argv(argv) do
     parse_argv(argv, @blank_config)
   end
 
   @doc """
-  Process commands according to the parsed config from `parse_argv/1`.
-  Returns all errors.
+  Process CLI commands. Made public for testing.
   """
   def process_commands(config) do
-    results = Enum.map(Enum.reverse(config.commands), &process_command(&1, config))
-    errors  = for {:error, msg} <- results, do: msg
+    commands =
+      case config do
+        %{mode: :elixirc, compile: compile, commands: commands} ->
+          [{:compile, compile} | commands]
+
+        %{commands: commands} ->
+          commands
+      end
+
+    results = Enum.map(Enum.reverse(commands), &process_command(&1, config))
+    errors = for {:error, msg} <- results, do: msg
     Enum.reverse(config.errors, errors)
   end
 
-  ## Helpers
+  @doc """
+  Shared helper for error formatting on CLI tools.
+  """
+  def format_error(kind, reason, stacktrace) do
+    {blamed, stacktrace} = Exception.blame(kind, reason, stacktrace)
 
-  defp at_exit(status) do
-    hooks = :elixir_code_server.call(:flush_at_exit)
+    iodata =
+      case blamed do
+        %FunctionClauseError{} ->
+          formatted = Exception.format_banner(kind, reason, stacktrace)
+          padded_blame = pad(FunctionClauseError.blame(blamed, &inspect/1, &blame_match/1))
+          [formatted, padded_blame]
 
-    for hook <- hooks do
-      try do
-        hook.(status)
-      catch
-        kind, reason ->
-          print_error(kind, reason, System.stacktrace)
+        _ ->
+          Exception.format_banner(kind, blamed, stacktrace)
       end
+
+    [iodata, ?\n, Exception.format_stacktrace(prune_stacktrace(stacktrace))]
+  end
+
+  @doc """
+  Function invoked across nodes for `--rpc-eval`.
+  """
+  def rpc_eval(expr) do
+    wrapper(fn -> Code.eval_string(expr) end)
+  catch
+    kind, reason -> {kind, reason, __STACKTRACE__}
+  end
+
+  ## Helpers
+
+  defp at_exit(res) do
+    hooks = :elixir_config.get_and_put(:at_exit, [])
+    res = Enum.reduce(hooks, res, &exec_fun/2)
+    if hooks == [], do: res, else: at_exit(res)
+  end
+
+  defp exec_fun(fun, res) when is_function(fun, 1) and is_tuple(res) do
+    parent = self()
+
+    {pid, ref} =
+      spawn_monitor(fn ->
+        try do
+          fun.(elem(res, 1))
+        catch
+          :exit, {:shutdown, int} when is_integer(int) ->
+            send(parent, {self(), {:shutdown, int}})
+            exit({:shutdown, int})
+
+          :exit, reason
+          when reason == :normal
+          when reason == :shutdown
+          when tuple_size(reason) == 2 and elem(reason, 0) == :shutdown ->
+            send(parent, {self(), {:shutdown, 0}})
+            exit(reason)
+
+          kind, reason ->
+            print_error(kind, reason, __STACKTRACE__)
+            send(parent, {self(), {:shutdown, 1}})
+            exit(to_exit(kind, reason, __STACKTRACE__))
+        else
+          _ ->
+            send(parent, {self(), res})
+        end
+      end)
+
+    receive do
+      {^pid, res} ->
+        :erlang.demonitor(ref, [:flush])
+        res
+
+      {:DOWN, ^ref, _, _, other} ->
+        print_error({:EXIT, pid}, other, [])
+        {:shutdown, 1}
     end
+  end
+
+  defp to_exit(:throw, reason, stack), do: {{:nocatch, reason}, stack}
+  defp to_exit(:error, reason, stack), do: {reason, stack}
+  defp to_exit(:exit, reason, _stack), do: reason
 
-    # If an at_exit callback adds a
-    # new hook we need to invoke it.
-    unless hooks == [], do: at_exit(status)
+  ## Error handling
+
+  defp print_error(kind, reason, stacktrace) do
+    IO.write(:stderr, format_error(kind, reason, stacktrace))
   end
 
-  defp shared_option?(list, config, callback) do
-    case parse_shared(list, config) do
-      {[h|hs], _} when h == hd(list) ->
-        new_config = %{config | errors: ["#{h} : Unknown option" | config.errors]}
-        callback.(hs, new_config)
-      {new_list, new_config} ->
-        callback.(new_list, new_config)
+  defp blame_match(%{match?: true, node: node}), do: blame_ansi(:normal, "+", node)
+  defp blame_match(%{match?: false, node: node}), do: blame_ansi(:red, "-", node)
+
+  defp blame_ansi(color, no_ansi, node) do
+    if IO.ANSI.enabled?() do
+      [color | Macro.to_string(node)]
+      |> IO.ANSI.format(true)
+      |> IO.iodata_to_binary()
+    else
+      no_ansi <> Macro.to_string(node) <> no_ansi
     end
   end
 
-  defp print_error(kind, reason, trace) do
-    IO.puts :stderr, Exception.format(kind, reason, prune_stacktrace(trace))
+  defp pad(string) do
+    "    " <> String.replace(string, "\n", "\n    ")
   end
 
-  @elixir_internals [:elixir_compiler, :elixir_module, :elixir_translator, :elixir_expand]
+  @elixir_internals [:elixir, :elixir_aliases, :elixir_clauses, :elixir_compiler, :elixir_def] ++
+                      [:elixir_def, :elixir_dispatch, :elixir_expand, :elixir_lexical] ++
+                      [:elixir_map, :elixir_module] ++
+                      [:elixir_erl, :elixir_erl_clauses, :elixir_erl_compiler, :elixir_erl_pass] ++
+                      [Kernel.ErrorHandler, Module.ParallelChecker]
 
-  defp prune_stacktrace([{mod, _, _, _}|t]) when mod in @elixir_internals do
+  defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
     prune_stacktrace(t)
   end
 
-  defp prune_stacktrace([{__MODULE__, :wrapper, 1, _}|_]) do
+  defp prune_stacktrace([{__MODULE__, :wrapper, 1, _} | _]) do
     []
   end
 
-  defp prune_stacktrace([h|t]) do
-    [h|prune_stacktrace(t)]
+  defp prune_stacktrace([h | t]) do
+    [h | prune_stacktrace(t)]
   end
 
   defp prune_stacktrace([]) do
     []
   end
 
-  # Parse shared options
+  # Process init options
 
-  defp parse_shared([opt|_t], _config) when opt in ["-v", "--version"] do
-    IO.puts "Elixir #{System.version}"
-    System.halt 0
+  defp parse_argv([~c"--" | t], config) do
+    {config, t}
   end
 
-  defp parse_shared(["-pa", h|t], config) do
-    add_code_path(h, &Code.prepend_path/1)
-    parse_shared t, config
+  defp parse_argv([~c"+elixirc" | t], config) do
+    parse_argv(t, %{config | mode: :elixirc})
   end
 
-  defp parse_shared(["-pz", h|t], config) do
-    add_code_path(h, &Code.append_path/1)
-    parse_shared t, config
+  defp parse_argv([~c"+iex" | t], config) do
+    parse_argv(t, %{config | mode: :iex})
   end
 
-  defp parse_shared(["--app", h|t], config) do
-    parse_shared t, %{config | commands: [{:app, h} | config.commands]}
+  defp parse_argv([~c"-S", h | t], config) do
+    {%{config | commands: [{:script, h} | config.commands]}, t}
   end
 
-  defp parse_shared(["--no-halt"|t], config) do
-    parse_shared t, %{config | halt: false}
+  defp parse_argv([opt | _], _config) when opt in @standalone_opts do
+    halt_standalone(opt)
   end
 
-  defp parse_shared(["-e", h|t], config) do
-    parse_shared t, %{config | commands: [{:eval, h} | config.commands]}
-  end
+  defp parse_argv([opt | t], config) when opt in [~c"-v", ~c"--version"] do
+    if config.mode == :iex do
+      IO.puts("IEx " <> System.build_info()[:build])
+    else
+      IO.puts(:erlang.system_info(:system_version))
+      IO.puts("Elixir " <> System.build_info()[:build])
+    end
 
-  defp parse_shared(["-r", h|t], config) do
-    parse_shared t, %{config | commands: [{:require, h} | config.commands]}
+    if t != [] do
+      halt_standalone(opt)
+    else
+      System.halt(0)
+    end
   end
 
-  defp parse_shared(["-pr", h|t], config) do
-    parse_shared t, %{config | commands: [{:parallel_require, h} | config.commands]}
+  defp parse_argv([~c"-pa", h | t], config) do
+    paths = expand_code_path(h)
+    Code.prepend_paths(paths)
+    parse_argv(t, config)
   end
 
-  defp parse_shared([erl, _|t], config) when erl in ["--erl", "--sname", "--name", "--cookie"] do
-    parse_shared t, config
+  defp parse_argv([~c"-pz", h | t], config) do
+    paths = expand_code_path(h)
+    Code.append_paths(paths)
+    parse_argv(t, config)
   end
 
-  defp parse_shared([erl|t], config) when erl in ["--detached", "--hidden"] do
-    parse_shared t, config
+  defp parse_argv([~c"--no-halt" | t], config) do
+    parse_argv(t, %{config | no_halt: true})
   end
 
-  defp parse_shared(list, config) do
-    {list, config}
+  defp parse_argv([~c"-e", h | t], config) do
+    parse_argv(t, %{config | commands: [{:eval, h} | config.commands]})
   end
 
-
-  defp add_code_path(path, fun) do
-    path = Path.expand(path)
-    case Path.wildcard(path) do
-      []   -> fun.(path)
-      list -> Enum.each(list, fun)
-    end
+  defp parse_argv([~c"--eval", h | t], config) do
+    parse_argv(t, %{config | commands: [{:eval, h} | config.commands]})
   end
 
-  # Process init options
-
-  defp parse_argv(["--"|t], config) do
-    {config, t}
+  defp parse_argv([~c"--rpc-eval", node, h | t], config) do
+    node = append_hostname(node)
+    parse_argv(t, %{config | commands: [{:rpc_eval, node, h} | config.commands]})
   end
 
-  defp parse_argv(["+elixirc"|t], config) do
-    parse_compiler t, config
+  defp parse_argv([~c"--rpc-eval" | _], config) do
+    new_config = %{config | errors: ["--rpc-eval : wrong number of arguments" | config.errors]}
+    {new_config, []}
   end
 
-  defp parse_argv(["+iex"|t], config) do
-    parse_iex t, config
+  defp parse_argv([~c"-r", h | t], config) do
+    parse_argv(t, %{config | commands: [{:require, h} | config.commands]})
   end
 
-  defp parse_argv(["-S", h|t], config) do
-    {%{config | commands: [{:script, h} | config.commands]}, t}
+  defp parse_argv([~c"-pr", h | t], config) do
+    parse_argv(t, %{config | commands: [{:parallel_require, h} | config.commands]})
   end
 
-  defp parse_argv([h|t] = list, config) do
-    case h do
-      "-" <> _ ->
-        shared_option? list, config, &parse_argv(&1, &2)
-      _ ->
-        if Keyword.has_key?(config.commands, :eval) do
-          {config, list}
-        else
-          {%{config | commands: [{:file, h} | config.commands]}, t}
-        end
-    end
+  defp parse_argv([~c"--color" | t], config) do
+    Application.put_env(:elixir, :ansi_enabled, true)
+    parse_argv(t, config)
   end
 
-  defp parse_argv([], config) do
-    {config, []}
+  defp parse_argv([~c"--no-color" | t], config) do
+    Application.put_env(:elixir, :ansi_enabled, false)
+    parse_argv(t, config)
   end
 
-  # Parse compiler options
+  ## Compiler
 
-  defp parse_compiler(["--"|t], config) do
-    {config, t}
+  defp parse_argv([~c"-o", h | t], %{mode: :elixirc} = config) do
+    parse_argv(t, %{config | output: h})
   end
 
-  defp parse_compiler(["-o", h|t], config) do
-    parse_compiler t, %{config | output: h}
+  defp parse_argv([~c"--no-docs" | t], %{mode: :elixirc} = config) do
+    parse_argv(t, %{config | compiler_options: [{:docs, false} | config.compiler_options]})
   end
 
-  defp parse_compiler(["--no-docs"|t], config) do
-    parse_compiler t, %{config | compiler_options: [{:docs, false} | config.compiler_options]}
+  defp parse_argv([~c"--no-debug-info" | t], %{mode: :elixirc} = config) do
+    compiler_options = [{:debug_info, false} | config.compiler_options]
+    parse_argv(t, %{config | compiler_options: compiler_options})
   end
 
-  defp parse_compiler(["--no-debug-info"|t], config) do
-    parse_compiler t, %{config | compiler_options: [{:debug_info, false} | config.compiler_options]}
+  defp parse_argv([~c"--ignore-module-conflict" | t], %{mode: :elixirc} = config) do
+    compiler_options = [{:ignore_module_conflict, true} | config.compiler_options]
+    parse_argv(t, %{config | compiler_options: compiler_options})
   end
 
-  defp parse_compiler(["--ignore-module-conflict"|t], config) do
-    parse_compiler t, %{config | compiler_options: [{:ignore_module_conflict, true} | config.compiler_options]}
+  defp parse_argv([~c"--warnings-as-errors" | t], %{mode: :elixirc} = config) do
+    parse_argv(t, %{config | warnings_as_errors: true})
   end
 
-  defp parse_compiler(["--warnings-as-errors"|t], config) do
-    parse_compiler t, %{config | compiler_options: [{:warnings_as_errors, true} | config.compiler_options]}
+  defp parse_argv([~c"--verbose" | t], %{mode: :elixirc} = config) do
+    parse_argv(t, %{config | verbose_compile: true})
   end
 
-  defp parse_compiler(["--verbose"|t], config) do
-    parse_compiler t, %{config | verbose_compile: true}
+  defp parse_argv([~c"--profile", "time" | t], %{mode: :elixirc} = config) do
+    parse_argv(t, %{config | profile: :time})
   end
 
-  defp parse_compiler([h|t] = list, config) do
-    case h do
-      "-" <> _ ->
-        shared_option? list, config, &parse_compiler(&1, &2)
+  ## IEx
+
+  defp parse_argv([~c"--dbg", backend | t], %{mode: :iex} = config) do
+    case backend do
+      ~c"pry" ->
+        parse_argv(t, %{config | pry: true})
+
+      ~c"kernel" ->
+        parse_argv(t, %{config | pry: false})
+
       _ ->
-        pattern = if File.dir?(h), do: "#{h}/**/*.ex", else: h
-        parse_compiler t, %{config | compile: [pattern | config.compile]}
+        error = "--dbg : Unknown dbg backend #{inspect(backend)}"
+        parse_argv(t, %{config | errors: [error | config.errors]})
     end
   end
 
-  defp parse_compiler([], config) do
-    {%{config | commands: [{:compile, config.compile}|config.commands]}, []}
-  end
+  defp parse_argv([~c"--dot-iex", _ | t], %{mode: :iex} = config), do: parse_argv(t, config)
+  defp parse_argv([~c"--remsh", _ | t], %{mode: :iex} = config), do: parse_argv(t, config)
 
-  # Parse iex options
+  ## Erlang flags
 
-  defp parse_iex(["--"|t], config) do
-    {config, t}
+  defp parse_argv([~c"--boot", _ | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--boot-var", _, _ | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--cookie", _ | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--hidden" | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--erl-config", _ | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--logger-otp-reports", _ | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--logger-sasl-reports", _ | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--name", _ | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--sname", _ | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--vm-args", _ | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--erl", _ | t], config), do: parse_argv(t, config)
+  defp parse_argv([~c"--pipe-to", _, _ | t], config), do: parse_argv(t, config)
+
+  ## Fallback
+
+  defp parse_argv([h | t], %{mode: :elixirc} = config) do
+    pattern = if File.dir?(h), do: "#{h}/**/*.ex", else: h
+    parse_argv(t, %{config | compile: [pattern | config.compile]})
   end
 
-  # This clause is here so that Kernel.CLI does not
-  # error out with "unknown option"
-  defp parse_iex(["--dot-iex", _|t], config) do
-    parse_iex t, config
+  defp parse_argv([h | t], config) do
+    if List.keymember?(config.commands, :eval, 0) do
+      {config, [h | t]}
+    else
+      {%{config | commands: [{:file, h} | config.commands]}, t}
+    end
   end
 
-  defp parse_iex([opt, _|t], config) when opt in ["--remsh"] do
-    parse_iex t, config
+  defp parse_argv([], config) do
+    {config, []}
   end
 
-  defp parse_iex(["-S", h|t], config) do
-    {%{config | commands: [{:script, h} | config.commands]}, t}
+  # Parse helpers
+
+  defp halt_standalone(opt) do
+    IO.puts(:stderr, "#{opt} : Standalone options can't be combined with other options")
+    System.halt(1)
   end
 
-  defp parse_iex([h|t] = list, config) do
-    case h do
-      "-" <> _ ->
-        shared_option? list, config, &parse_iex(&1, &2)
-      _ ->
-        {%{config | commands: [{:file, h} | config.commands]}, t}
+  defp append_hostname(node) do
+    with false <- ?@ in node,
+         [_ | _] = suffix <- :string.find(Atom.to_charlist(:net_kernel.nodename()), ~c"@") do
+      node ++ suffix
+    else
+      _ -> node
     end
   end
 
-  defp parse_iex([], config) do
-    {config, []}
+  defp expand_code_path(path) do
+    path = Path.expand(path)
+
+    case Path.wildcard(path) do
+      [] -> [to_charlist(path)]
+      list -> Enum.map(list, &to_charlist/1)
+    end
   end
 
   # Process commands
 
-  defp process_command({:cookie, h}, _config) do
-    if Node.alive? do
-      wrapper fn -> Node.set_cookie(String.to_atom(h)) end
-    else
-      {:error, "--cookie : Cannot set cookie if the node is not alive (set --name or --sname)"}
-    end
+  defp process_command({:eval, expr}, _config) when is_list(expr) do
+    wrapper(fn -> Code.eval_string(expr, []) end)
   end
 
-  defp process_command({:eval, expr}, _config) when is_binary(expr) do
-    wrapper fn -> Code.eval_string(expr, []) end
-  end
+  defp process_command({:rpc_eval, node, expr}, _config) when is_list(expr) do
+    node = List.to_atom(node)
+
+    # Explicitly connect the node in case the rpc node was started with --sname/--name undefined.
+    _ = :net_kernel.connect_node(node)
+
+    try do
+      :erpc.call(node, __MODULE__, :rpc_eval, [expr])
+    catch
+      :error, {:erpc, reason} ->
+        if reason == :noconnection and :net_kernel.nodename() == :ignored do
+          {:error,
+           "--rpc-eval : Cannot run --rpc-eval if the node is not alive (set --name or --sname)"}
+        else
+          {:error, "--rpc-eval : RPC failed with reason #{inspect(reason)}"}
+        end
 
-  defp process_command({:app, app}, _config) when is_binary(app) do
-    case Application.ensure_all_started(String.to_atom(app)) do
-      {:error, {app, reason}} ->
-        {:error, "--app : Could not start application #{app}: " <>
-          Application.format_error(reason)}
-      {:ok, _} ->
-        :ok
+      :exit, {kind, exit} when kind in [:exception, :signal] ->
+        Process.exit(self(), exit)
+    else
+      :ok -> :ok
+      {kind, reason, stack} -> :erlang.raise(kind, reason, stack)
     end
   end
 
-  defp process_command({:script, file}, _config) when is_binary(file) do
+  defp process_command({:script, file}, _config) when is_list(file) do
     if exec = find_elixir_executable(file) do
-      wrapper fn -> Code.require_file(exec) end
+      wrapper(fn -> Code.require_file(IO.chardata_to_string(exec)) end)
     else
       {:error, "-S : Could not find executable #{file}"}
     end
   end
 
-  defp process_command({:file, file}, _config) when is_binary(file) do
+  defp process_command({:file, file}, _config) when is_list(file) do
     if File.regular?(file) do
-      wrapper fn -> Code.require_file(file) end
+      wrapper(fn -> Code.require_file(IO.chardata_to_string(file)) end)
     else
       {:error, "No file named #{file}"}
     end
   end
 
-  defp process_command({:require, pattern}, _config) when is_binary(pattern) do
+  defp process_command({:require, pattern}, _config) when is_list(pattern) do
     files = filter_patterns(pattern)
 
     if files != [] do
-      wrapper fn -> Enum.map files, &Code.require_file(&1) end
+      wrapper(fn -> Enum.map(files, &Code.require_file/1) end)
     else
       {:error, "-r : No files matched pattern #{pattern}"}
     end
   end
 
-  defp process_command({:parallel_require, pattern}, _config) when is_binary(pattern) do
+  defp process_command({:parallel_require, pattern}, _config) when is_list(pattern) do
     files = filter_patterns(pattern)
 
     if files != [] do
-      wrapper fn -> Kernel.ParallelRequire.files(files) end
+      wrapper(fn ->
+        case Kernel.ParallelCompiler.require(files, return_diagnostics: true) do
+          {:ok, _, _} -> :ok
+          {:error, _, _} -> exit({:shutdown, 1})
+        end
+      end)
     else
       {:error, "-pr : No files matched pattern #{pattern}"}
     end
   end
 
   defp process_command({:compile, patterns}, config) do
-    :filelib.ensure_dir(:filename.join(config.output, "."))
+    # If ensuring the dir returns an error no files will be found.
+    _ = :filelib.ensure_path(config.output)
 
     case filter_multiple_patterns(patterns) do
       {:ok, []} ->
         {:error, "No files matched provided patterns"}
+
       {:ok, files} ->
-        wrapper fn ->
+        wrapper(fn ->
           Code.compiler_options(config.compiler_options)
-          Kernel.ParallelCompiler.files_to_path(files, config.output,
-            each_file: fn file -> if config.verbose_compile do IO.puts "Compiled #{file}" end end)
-        end
+
+          verbose_opts =
+            if config.verbose_compile do
+              [each_file: &IO.puts("Compiling #{Path.relative_to_cwd(&1)}")]
+            else
+              [
+                each_long_compilation:
+                  &IO.puts("Compiling #{Path.relative_to_cwd(&1)} (it's taking more than 10s)")
+              ]
+            end
+
+          output = IO.chardata_to_string(config.output)
+
+          opts =
+            verbose_opts ++
+              [
+                profile: config.profile,
+                warnings_as_errors: config.warnings_as_errors,
+                return_diagnostics: true
+              ]
+
+          case Kernel.ParallelCompiler.compile_to_path(files, output, opts) do
+            {:ok, _, _} -> :ok
+            {:error, _, _} -> exit({:shutdown, 1})
+          end
+        end)
+
       {:missing, missing} ->
         {:error, "No files matched pattern(s) #{Enum.join(missing, ",")}"}
     end
   end
 
   defp filter_patterns(pattern) do
-    Enum.filter(Enum.uniq(Path.wildcard(pattern)), &File.regular?(&1))
+    pattern
+    |> Path.expand()
+    |> Path.wildcard()
+    |> :lists.usort()
+    |> Enum.filter(&File.regular?/1)
   end
 
   defp filter_multiple_patterns(patterns) do
-    matched_files = Enum.map patterns, fn(pattern) ->
-      case filter_patterns(pattern) do
-        []    -> {:missing, pattern}
-        files -> {:ok, files}
-      end
-    end
-
-    files = Enum.filter_map matched_files,
-       fn(match) -> elem(match, 0) == :ok end,
-       &elem(&1, 1)
-
-    missing_patterns = Enum.filter_map matched_files,
-       fn(match) -> elem(match, 0) == :missing end,
-       &elem(&1, 1)
+    {files, missing} =
+      Enum.reduce(patterns, {[], []}, fn pattern, {files, missing} ->
+        case filter_patterns(pattern) do
+          [] -> {files, [pattern | missing]}
+          match -> {match ++ files, missing}
+        end
+      end)
 
-    if missing_patterns == [] do
-      {:ok, Enum.uniq(Enum.concat(files))}
-    else
-      {:missing,  Enum.uniq(missing_patterns)}
+    case missing do
+      [] -> {:ok, :lists.usort(files)}
+      _ -> {:missing, :lists.usort(missing)}
     end
   end
 
   defp wrapper(fun) do
-    fun.()
+    _ = fun.()
     :ok
   end
 
   defp find_elixir_executable(file) do
-    if exec = System.find_executable(file) do
+    if exec = :os.find_executable(file) do
       # If we are on Windows, the executable is going to be
       # a .bat file that must be in the same directory as
       # the actual Elixir executable.
       case :os.type() do
         {:win32, _} ->
-          exec = Path.rootname(exec)
-          if File.regular?(exec), do: exec
+          base = :filename.rootname(exec)
+          if File.regular?(base), do: base, else: exec
+
         _ ->
           exec
       end
diff --git a/lib/elixir/lib/kernel/error_handler.ex b/lib/elixir/lib/kernel/error_handler.ex
index dfc1dbb58e8..4771710ac15 100644
--- a/lib/elixir/lib/kernel/error_handler.ex
+++ b/lib/elixir/lib/kernel/error_handler.ex
@@ -1,40 +1,60 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 # Implement error_handler pattern for Erlang
 # which is integrated with Kernel.ParallelCompiler
 defmodule Kernel.ErrorHandler do
   @moduledoc false
 
+  @spec undefined_function(module, atom, list) :: term
   def undefined_function(module, fun, args) do
-    ensure_loaded(module)
+    ensure_loaded(module) or ensure_compiled(module, :module, :raise, nil)
     :error_handler.undefined_function(module, fun, args)
   end
 
+  @spec undefined_lambda(module, fun, list) :: term
   def undefined_lambda(module, fun, args) do
-    ensure_loaded(module)
+    ensure_loaded(module) or ensure_compiled(module, :module, :raise, nil)
     :error_handler.undefined_lambda(module, fun, args)
   end
 
-  def release() do
-    # On release, no further allow elixir_ensure_compiled
-    # directives and revert to the original error handler.
-    # Note we should not delete the elixir_compiler_pid though,
-    # as we still want to send notifications to the compiler.
-    :erlang.erase(:elixir_ensure_compiled)
-    :erlang.process_flag(:error_handler, :error_handler)
-    :ok
+  @spec ensure_loaded(module) :: boolean
+  def ensure_loaded(module) do
+    case :code.ensure_loaded(module) do
+      {:module, _} -> true
+      {:error, _} -> false
+    end
   end
 
-  defp ensure_loaded(module) do
-    case Code.ensure_loaded(module) do
-      {:module, _} -> []
-      {:error, _} ->
-        parent = :erlang.get(:elixir_compiler_pid)
-        ref    = :erlang.make_ref
-        send parent, {:waiting, module, self(), ref, module}
-        :erlang.garbage_collect(self)
+  @spec ensure_compiled(module, atom, atom, nil | integer()) :: :found | :not_found | :deadlock
+  # Never wait on nil because it should never be defined.
+  def ensure_compiled(nil, _kind, _deadlock, _position) do
+    :not_found
+  end
+
+  def ensure_compiled(module, kind, deadlock, position) do
+    {compiler_pid, file_pid} = :erlang.get(:elixir_compiler_info)
+    ref = :erlang.make_ref()
+    modules = :elixir_module.compiler_modules()
+
+    send(
+      compiler_pid,
+      {:waiting, kind, self(), ref, file_pid, position, module, modules, deadlock}
+    )
+
+    :erlang.garbage_collect(self())
+
+    receive do
+      {^ref, {:loading, pid}} ->
+        ref = :erlang.monitor(:process, pid)
+
         receive do
-          {^ref, :ready}   -> :ok
-          {^ref, :release} -> release()
+          {:DOWN, ^ref, _, _, _} -> :found
         end
+
+      {^ref, value} ->
+        value
     end
   end
 end
diff --git a/lib/elixir/lib/kernel/lexical_tracker.ex b/lib/elixir/lib/kernel/lexical_tracker.ex
index 09e205b5214..bb51ed8dbda 100644
--- a/lib/elixir/lib/kernel/lexical_tracker.ex
+++ b/lib/elixir/lib/kernel/lexical_tracker.ex
@@ -1,176 +1,315 @@
-# This is a module Elixir responsible for tracking
-# the usage of aliases, imports and requires in the Elixir scope.
-#
-# The implementation simply stores dispatch information in an
-# ETS table and then consults this table once compilation is done.
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# This is an Elixir module responsible for tracking references
+# to modules, remote dispatches, and the usage of
+# aliases/imports/requires in the Elixir scope.
 #
 # Note that since this is required for bootstrap, we can't use
 # any of the `GenServer.Behaviour` conveniences.
 defmodule Kernel.LexicalTracker do
   @moduledoc false
-  @timeout 30_000
+  @timeout :infinity
   @behaviour :gen_server
+  @warn_key 0
 
-  @import 2
-  @alias  3
+  @doc """
+  Returns all references in this lexical scope.
+  """
+  def references(pid) do
+    :gen_server.call(pid, :references, @timeout)
+  end
 
   @doc """
-  Returns all remotes linked to in this lexical scope.
+  Invoked during module expansion to annotate a require
+  must be warned if unused.
   """
-  def remotes(arg) do
-    # If the module is compiled from a function, its lexical
-    # scope may be long gone, so it has no associated PID.
-    if pid = to_pid(arg) do
-      ets = :gen_server.call(pid, :ets, @timeout)
-      :ets.match(ets, {:"$1", :_, :_}) |> List.flatten
-    else
-      []
-    end
+  def warn_require(pid, meta, module) do
+    :gen_server.cast(pid, {:warn_require, module, meta})
+    module
+  end
+
+  @doc """
+  Invoked during module expansion to annotate an alias
+  must be warned if unused.
+  """
+  def warn_alias(pid, meta, alias, module) do
+    :gen_server.cast(pid, {:warn_alias, alias, meta})
+    module
   end
 
-  defp to_pid(pid) when is_pid(pid),  do: pid
-  defp to_pid(mod) when is_atom(mod) do
-    table = :elixir_module.data_table(mod)
-    [{_, val}] = :ets.lookup(table, :__lexical_tracker)
-    val
+  @doc """
+  Invoked during module expansion to annotate an import
+  must be warned if unused.
+  """
+  def warn_import(pid, module) do
+    :gen_server.cast(pid, {:warn_import, module})
+    module
   end
 
   # Internal API
 
-  # Starts the tracker and returns its pid.
+  # Starts the tracker and returns its PID.
   @doc false
-  def start_link do
-    {:ok, pid} = :gen_server.start_link(__MODULE__, [], [])
-    pid
+  def start_link() do
+    :gen_server.start_link(__MODULE__, :ok, [])
   end
 
   @doc false
   def stop(pid) do
-    :gen_server.cast(pid, :stop)
+    :gen_server.call(pid, :stop)
   end
 
   @doc false
-  def add_import(pid, module, line, warn) do
-    :gen_server.cast(pid, {:add_import, module, line, warn})
+  def add_export(pid, module) when is_atom(module) do
+    :gen_server.cast(pid, {:add_export, module})
   end
 
   @doc false
-  def add_alias(pid, module, line, warn) do
-    :gen_server.cast(pid, {:add_alias, module, line, warn})
+  def add_require(pid, module, meta) when is_atom(module) do
+    :gen_server.cast(pid, {:add_require, module, meta})
   end
 
   @doc false
-  def remote_dispatch(pid, module) do
-    :gen_server.cast(pid, {:remote_dispatch, module})
+  def add_import(pid, module, fas, meta, warn) when is_atom(module) do
+    :gen_server.cast(pid, {:add_import, module, fas, meta, warn})
   end
 
   @doc false
-  def import_dispatch(pid, module) do
-    :gen_server.cast(pid, {:import_dispatch, module})
+  def remote_dispatch(pid, module, mode) when is_atom(module) do
+    :gen_server.cast(pid, {:remote_dispatch, module, mode})
   end
 
   @doc false
-  def alias_dispatch(pid, module) do
+  def import_dispatch(pid, module, fa, mode) when is_atom(module) do
+    :gen_server.cast(pid, {:import_dispatch, module, fa, mode})
+  end
+
+  @doc false
+  def alias_dispatch(pid, module) when is_atom(module) do
     :gen_server.cast(pid, {:alias_dispatch, module})
   end
 
+  @doc false
+  def import_quoted(pid, module, function, arities) when is_atom(module) do
+    :gen_server.cast(pid, {:import_quoted, module, function, arities})
+  end
+
+  @doc false
+  def add_compile_env(pid, app, path, return) do
+    :gen_server.cast(pid, {:compile_env, app, path, return})
+  end
+
+  @doc false
+  def set_file(pid, file) do
+    :gen_server.cast(pid, {:set_file, file})
+  end
+
+  @doc false
+  def reset_file(pid) do
+    :gen_server.cast(pid, :reset_file)
+  end
+
+  @doc false
+  def write_cache(pid, value) do
+    key = :erlang.unique_integer()
+    :gen_server.cast(pid, {:write_cache, key, value})
+    key
+  end
+
+  @doc false
+  def read_cache(pid, key) do
+    :gen_server.call(pid, {:read_cache, key}, @timeout)
+  end
+
   @doc false
   def collect_unused_imports(pid) do
-    unused(pid, @import)
+    :gen_server.call(pid, :unused_imports, @timeout)
   end
 
   @doc false
   def collect_unused_aliases(pid) do
-    unused(pid, @alias)
+    :gen_server.call(pid, :unused_aliases, @timeout)
   end
 
-  defp unused(pid, pos) do
-    ets = :gen_server.call(pid, :ets, @timeout)
-    :ets.foldl(fn
-      {module, _, _} = tuple, acc when is_integer(:erlang.element(pos, tuple)) ->
-        [{module, :erlang.element(pos, tuple)}|acc]
-      _, acc ->
-        acc
-    end, [], ets) |> Enum.sort
+  @doc false
+  def collect_unused_requires(pid) do
+    :gen_server.call(pid, :unused_requires, @timeout)
   end
 
   # Callbacks
 
+  def init(:ok) do
+    state = %{
+      aliases: %{},
+      imports: %{},
+      requires: %{},
+      references: %{},
+      exports: %{},
+      cache: %{},
+      compile_env: :ordsets.new(),
+      file: nil
+    }
+
+    {:ok, state}
+  end
 
-  def init([]) do
-    {:ok, :ets.new(:lexical, [:protected])}
+  @doc false
+  def handle_call(:unused_aliases, _from, state) do
+    aliases = for {alias, meta} when is_list(meta) <- state.aliases, do: {alias, meta}
+    {:reply, Enum.sort(aliases), state}
   end
 
-  def handle_call(:ets, _from, d) do
-    {:reply, d, d}
+  def handle_call(:unused_imports, _from, state) do
+    imports =
+      for {module, %{@warn_key => _} = map} <- state.imports do
+        {module, Map.delete(map, @warn_key)}
+      end
+
+    {:reply, Enum.sort(imports), state}
   end
 
-  def handle_call(request, _from, d) do
-    {:stop, {:bad_call, request}, d}
+  def handle_call(:unused_requires, _from, state) do
+    unused_requires =
+      for {module, meta} <- state.requires, Map.get(state.references, module) != :compile do
+        {module, meta}
+      end
+
+    {:reply, Enum.sort(unused_requires), state}
   end
 
-  def handle_cast({:remote_dispatch, module}, d) do
-    add_module(d, module)
-    {:noreply, d}
+  def handle_call(:references, _from, state) do
+    {compile, runtime} = partition(Map.to_list(state.references), [], [])
+    {:reply, {compile, Map.keys(state.exports), runtime, state.compile_env}, state}
   end
 
-  def handle_cast({:import_dispatch, module}, d) do
-    add_dispatch(d, module, @import)
-    {:noreply, d}
+  def handle_call({:read_cache, key}, _from, %{cache: cache} = state) do
+    {:reply, Map.get(cache, key), state}
   end
 
-  def handle_cast({:alias_dispatch, module}, d) do
-    add_dispatch(d, module, @alias)
-    {:noreply, d}
+  def handle_call(:stop, _from, state) do
+    {:stop, :normal, :ok, state}
   end
 
-  def handle_cast({:add_import, module, line, warn}, d) do
-    add_directive(d, module, line, warn, @import)
-    {:noreply, d}
+  def handle_cast({:write_cache, key, value}, %{cache: cache} = state) do
+    {:noreply, %{state | cache: Map.put(cache, key, value)}}
   end
 
-  def handle_cast({:add_alias, module, line, warn}, d) do
-    add_directive(d, module, line, warn, @alias)
-    {:noreply, d}
+  def handle_cast({:remote_dispatch, module, mode}, state) do
+    references = add_reference(state.references, module, mode)
+    {:noreply, %{state | references: references}}
   end
 
-  def handle_cast(:stop, d) do
-    {:stop, :normal, d}
+  def handle_cast({:import_dispatch, module, {function, arity}, mode}, state) do
+    %{imports: imports, references: references} = state
+
+    imports =
+      case imports do
+        %{^module => modules_and_fas} ->
+          modules_and_fas
+          |> Map.delete(module)
+          |> Map.delete({function, arity})
+          |> then(&Map.put(imports, module, &1))
+
+        %{} ->
+          imports
+      end
+
+    references = add_reference(references, module, mode)
+    {:noreply, %{state | imports: imports, references: references}}
   end
 
-  def handle_cast(msg, d) do
-    {:stop, {:bad_cast, msg}, d}
+  def handle_cast({:alias_dispatch, module}, state) do
+    {:noreply, put_in(state.aliases[module], :used)}
   end
 
-  def handle_info(_msg, d) do
-    {:noreply, d}
+  def handle_cast({:import_quoted, module, function, arities}, state) do
+    %{imports: imports} = state
+
+    imports =
+      case imports do
+        %{^module => modules_and_fas} ->
+          arities
+          |> Enum.reduce(modules_and_fas, &Map.delete(&2, {function, &1}))
+          |> Map.delete(module)
+          |> then(&Map.put(imports, module, &1))
+
+        %{} ->
+          imports
+      end
+
+    {:noreply, %{state | imports: imports}}
   end
 
-  def terminate(_reason, _d) do
-    :ok
+  def handle_cast({:set_file, file}, state) do
+    {:noreply, %{state | file: file}}
   end
 
-  def code_change(_old, d, _extra) do
-    {:ok, d}
+  def handle_cast(:reset_file, state) do
+    {:noreply, %{state | file: nil}}
   end
 
-  # Callbacks helpers
+  def handle_cast({:compile_env, app, path, return}, state) do
+    {:noreply, update_in(state.compile_env, &:ordsets.add_element({app, path, return}, &1))}
+  end
+
+  def handle_cast({:add_export, module}, state) do
+    {:noreply, put_in(state.exports[module], true)}
+  end
+
+  def handle_cast({:add_import, module, fas, meta, warn}, state) do
+    keys = if warn, do: [@warn_key, module | fas], else: [module | fas]
+    {:noreply, put_in(state.imports[module], Map.from_keys(keys, meta))}
+  end
+
+  def handle_cast({:warn_alias, alias, meta}, %{aliases: aliases} = state) do
+    case aliases do
+      %{^alias => :used} -> {:noreply, state}
+      %{} -> {:noreply, %{state | aliases: Map.put(aliases, alias, meta)}}
+    end
+  end
 
-  # In the table we keep imports and aliases.
-  # If the value is false, it was not imported/aliased
-  # If the value is true, it was imported/aliased
-  # If the value is a line, it was imported/aliased and has a pending warning
-  defp add_module(d, module) do
-    :ets.insert_new(d, {module, false, false})
+  def handle_cast({:warn_import, module}, state) do
+    {:noreply, put_in(state.imports[module][@warn_key], true)}
   end
 
-  defp add_dispatch(d, module, pos) do
-    :ets.update_element(d, module, {pos, true})
+  def handle_cast({:warn_require, module, meta}, state) do
+    {:noreply, put_in(state.requires[module], meta)}
   end
 
-  defp add_directive(d, module, line, warn, pos) do
-    add_module(d, module)
-    marker = if warn, do: line, else: true
-    :ets.update_element(d, module, {pos, marker})
+  @doc false
+  def handle_info(_msg, state) do
+    {:noreply, state}
+  end
+
+  @doc false
+  def terminate(_reason, _state) do
+    :ok
+  end
+
+  @doc false
+  def code_change(_old, state, _extra) do
+    {:ok, state}
+  end
+
+  defp partition([{remote, :compile} | t], compile, runtime),
+    do: partition(t, [remote | compile], runtime)
+
+  defp partition([{remote, :runtime} | t], compile, runtime),
+    do: partition(t, compile, [remote | runtime])
+
+  defp partition([], compile, runtime), do: {compile, runtime}
+
+  # Callbacks helpers
+
+  defp add_reference(references, module, :compile) when is_atom(module),
+    do: Map.put(references, module, :compile)
+
+  defp add_reference(references, module, :runtime) when is_atom(module) do
+    case references do
+      %{^module => _} -> references
+      %{} -> Map.put(references, module, :runtime)
+    end
   end
 end
diff --git a/lib/elixir/lib/kernel/parallel_compiler.ex b/lib/elixir/lib/kernel/parallel_compiler.ex
index ee1e58f48df..0139dc7f721 100644
--- a/lib/elixir/lib/kernel/parallel_compiler.ex
+++ b/lib/elixir/lib/kernel/parallel_compiler.ex
@@ -1,7 +1,142 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Kernel.ParallelCompiler do
   @moduledoc """
-  A module responsible for compiling files in parallel.
+  A module responsible for compiling and requiring files in parallel.
+  """
+
+  @type info :: %{
+          runtime_warnings: [Code.diagnostic(:warning)],
+          compile_warnings: [Code.diagnostic(:warning)]
+        }
+
+  # Deprecated types
+  @type warning() :: {file :: Path.t(), Code.position(), message :: String.t()}
+  @type error() :: {file :: Path.t(), Code.position(), message :: String.t()}
+
+  @typedoc """
+  Options for parallel compilation functions.
   """
+  @type compile_opts :: [
+          after_compile: (-> term()),
+          each_file: (Path.t() -> term()),
+          each_long_compilation: (Path.t() -> term()) | (Path.t(), pid() -> term()),
+          each_long_verification: (module() -> term()) | (module(), pid() -> term()),
+          each_module: (Path.t(), module(), binary() -> term()),
+          each_cycle: ([module()], [Code.diagnostic(:warning)] ->
+                         {:compile, [module()], [Code.diagnostic(:warning)]}
+                         | {:runtime, [module()], [Code.diagnostic(:warning)]}),
+          long_compilation_threshold: pos_integer(),
+          long_verification_threshold: pos_integer(),
+          verification: boolean(),
+          profile: :time,
+          dest: Path.t(),
+          beam_timestamp: term(),
+          return_diagnostics: boolean(),
+          max_concurrency: pos_integer()
+        ]
+
+  @typedoc """
+  Options for requiring files in parallel.
+  """
+  @type require_opts :: [
+          each_file: (Path.t() -> term()),
+          each_module: (Path.t(), module(), binary() -> term()),
+          max_concurrency: pos_integer(),
+          return_diagnostics: boolean()
+        ]
+
+  @doc """
+  Starts a task for parallel compilation.
+  """
+  # TODO: Remove me on Elixir 2.0
+  @deprecated "Use `pmap/2` instead"
+  def async(fun) when is_function(fun, 0) do
+    {ref, task} = inner_async(fun)
+    send(task.pid, ref)
+    task
+  end
+
+  defp inner_async(fun) do
+    case :erlang.get(:elixir_compiler_info) do
+      {compiler_pid, file_pid} ->
+        ref = make_ref()
+        file = :erlang.get(:elixir_compiler_file)
+        dest = :erlang.get(:elixir_compiler_dest)
+
+        {:error_handler, error_handler} = :erlang.process_info(self(), :error_handler)
+        {_parent, cache} = Module.ParallelChecker.get()
+
+        task =
+          Task.async(fn ->
+            Module.ParallelChecker.put(compiler_pid, cache)
+            :erlang.put(:elixir_compiler_info, {compiler_pid, file_pid})
+            :erlang.put(:elixir_compiler_file, file)
+            dest != :undefined and :erlang.put(:elixir_compiler_dest, dest)
+            :erlang.process_flag(:error_handler, error_handler)
+
+            receive do
+              ^ref -> fun.()
+            end
+          end)
+
+        send(compiler_pid, {:async, task.pid})
+        {ref, task}
+
+      :undefined ->
+        raise ArgumentError,
+              "cannot spawn parallel compiler task because " <>
+                "the current file is not being compiled/required"
+    end
+  end
+
+  @doc """
+  Perform parallel compilation of `collection` with `fun`.
+
+  If you have a file that needs to compile other modules in parallel,
+  the spawned processes need to be aware of the compiler environment.
+  This function allows a developer to perform such tasks.
+  """
+  @doc since: "1.16.0"
+  def pmap(collection, fun) when is_function(fun, 1) do
+    ref = make_ref()
+
+    # We spawn a series of tasks for parallel processing.
+    # The tasks are waiting until we give the go ahead.
+    refs_tasks =
+      Enum.map(collection, fn item ->
+        inner_async(fn -> fun.(item) end)
+      end)
+
+    # Notify the compiler we are waiting on the tasks.
+    {compiler_pid, file_pid} = :erlang.get(:elixir_compiler_info)
+    defining = :elixir_module.compiler_modules()
+    on = Enum.map(refs_tasks, fn {_ref, %{pid: pid}} -> pid end)
+    send(compiler_pid, {:waiting, :pmap, self(), ref, file_pid, nil, on, defining, :raise})
+
+    # Now we allow the tasks to run. This step is not strictly
+    # necessary but it makes compilation more deterministic by
+    # only allowing tasks to run once we are waiting.
+    tasks =
+      Enum.map(refs_tasks, fn {ref, task} ->
+        send(task.pid, ref)
+        task
+      end)
+
+    # Await tasks and notify the compiler they are done. We could
+    # have the tasks report directly to the compiler, which in turn
+    # would notify us, but that would require reimplementing await_many,
+    # and copying the results across boundaries, so we don't.
+    res = Task.await_many(tasks, :infinity)
+    send(compiler_pid, {:available, :pmap, on})
+
+    # Only run once the compiler lets us, to avoid unbounded parallelism.
+    receive do
+      {^ref, _result} -> res
+    end
+  end
 
   @doc """
   Compiles the given files.
@@ -11,239 +146,1027 @@ defmodule Kernel.ParallelCompiler do
   the current file stops being compiled until the dependency is
   resolved.
 
-  If there is an error during compilation or if `warnings_as_errors`
-  is set to `true` and there is a warning, this function will fail
-  with an exception.
+  It must be invoked with `return_diagnostics: true` as option, so it returns
+  `{:ok, modules, warnings_info}` or `{:error, errors, warnings_info}`,
+  where `warnings_info` has the shape:
+
+      %{
+        runtime_warnings: [warning],
+        compile_warnings: [warning]
+      }
+
+  ## Options
 
-  This function receives a set of callbacks as options:
+    * `:after_compile` - invoked after all modules are compiled, but before
+      they are verified. If the files are being written to disk, such as in
+      `compile_to_path/3`, this will be invoked after the files are written
 
     * `:each_file` - for each file compiled, invokes the callback passing the
       file
 
+    * `:each_long_compilation` - for each file that takes more than a given
+      timeout (see the `:long_compilation_threshold` option) to compile, invoke
+      this callback passing the file as its argument (and optionally the PID
+      of the process compiling the file)
+
+    * `:each_long_verification` (since v1.19.0) - for each file that takes more
+      than a given timeout (see the `:long_verification_threshold` option) to
+      compile, invoke this callback passing the module as its argument (and
+      optionally the PID of the process verifying the module)
+
     * `:each_module` - for each module compiled, invokes the callback passing
       the file, module and the module bytecode
 
-  The compiler doesn't care about the return values of the callbacks.
-  Returns the modules generated by each compiled file.
+    * `:each_cycle` - after the given files are compiled, invokes this function
+      that should return the following values:
+      * `{:compile, modules, warnings}` - to continue compilation with a list of
+        further modules to compile
+      * `{:runtime, modules, warnings}` - to stop compilation and verify the list
+        of modules because dependent modules have changed
+
+    * `:long_compilation_threshold` - the timeout (in seconds) to check for files
+      taking too long to compile. For each file that exceeds the threshold, the
+      `:each_long_compilation` callback is invoked. Defaults to `10` seconds.
+
+    * `:long_verification_threshold` (since v1.19.0) - the timeout (in seconds) to
+      check for modules taking too long to compile. For each module that exceeds the
+      threshold, the `:each_long_verification` callback is invoked. Defaults to
+      `10` seconds.
+
+    * `:verification` (since v1.19.0) - if code verification, such as unused functions,
+      deprecation warnings, and type checking should run. Defaults to `true`.
+      We recommend disabling it only for debugging purposes.
+
+    * `:profile` - if set to `:time` measure the compilation time of each compilation cycle
+       and group pass checker
+
+    * `:dest` - the destination directory for the BEAM files. When using `compile/2`,
+      this information is only used to properly annotate the BEAM files before
+      they are loaded into memory. If you want a file to actually be written to
+      `dest`, use `compile_to_path/3` instead.
+
+    * `:beam_timestamp` - the modification timestamp to give all BEAM files
+
+    * `:return_diagnostics` (since v1.15.0) - returns maps with information instead of
+      a list of warnings and returns diagnostics as maps instead of tuples.
+      This option must be set to true, except for backwards compatibibility reasons.
+
+    * `:max_concurrency` - the maximum number of files to compile in parallel.
+      Setting this option to 1 will compile files sequentially.
+      Defaults to the number of schedulers online, or at least `2`.
+
   """
-  def files(files, callbacks \\ [])
+  @doc since: "1.6.0"
+  @spec compile([Path.t()], compile_opts()) ::
+          {:ok, [atom], [warning] | info()}
+          | {:error, [error] | [Code.diagnostic(:error)], [warning] | info()}
+  def compile(files, options \\ []) when is_list(options) do
+    spawn_workers(files, :compile, options)
+  end
+
+  @doc """
+  Compiles the given files and writes resulting BEAM files into path.
 
-  def files(files, callbacks) when is_list(callbacks) do
-    spawn_compilers(files, nil, callbacks)
+  See `compile/2` for more information.
+  """
+  @doc since: "1.6.0"
+  @spec compile_to_path([Path.t()], Path.t(), compile_opts()) ::
+          {:ok, [atom], [warning] | info()}
+          | {:error, [error] | [Code.diagnostic(:error)], [warning] | info()}
+  def compile_to_path(files, path, options \\ []) when is_binary(path) and is_list(options) do
+    spawn_workers(files, {:compile, path}, Keyword.put(options, :dest, path))
   end
 
   @doc """
-  Compiles the given files to the given path.
-  Read `files/2` for more information.
+  Requires the given files in parallel.
+
+  Opposite to compile, dependencies are not attempted to be
+  automatically solved between files.
+
+  It must be invoked with `return_diagnostics: true` as option, so it returns
+  `{:ok, modules, warnings_info}` or `{:error, errors, warnings_info}`,
+  where `warnings_info` has the shape:
+
+      %{
+        runtime_warnings: [warning],
+        compile_warnings: [warning]
+      }
+
+  ## Options
+
+    * `:each_file` - for each file compiled, invokes the callback passing the
+      file
+
+    * `:each_module` - for each module compiled, invokes the callback passing
+      the file, module and the module bytecode
+
+    * `:max_concurrency` - the maximum number of files to compile in parallel.
+      Setting this option to 1 will compile files sequentially.
+      Defaults to the number of schedulers online, or at least `2`.
+
+    * `:return_diagnostics` (since v1.15.0) - returns maps with information instead of
+      a list of warnings and returns diagnostics as maps instead of tuples.
+      This option must be set to true, except for backwards compatibibility reasons.
+
   """
-  def files_to_path(files, path, callbacks \\ [])
+  @doc since: "1.6.0"
+  @spec require([Path.t()], require_opts()) ::
+          {:ok, [atom], [warning] | info()}
+          | {:error, [error] | [Code.diagnostic(:error)], [warning] | info()}
+  def require(files, options \\ []) when is_list(options) do
+    spawn_workers(files, :require, options)
+  end
+
+  @doc false
+  @deprecated "Use Code.print_diagnostic/2 instead"
+  def print_warning({file, location, warning}) do
+    :elixir_errors.print_warning(location, file, warning)
+  end
+
+  @doc false
+  @deprecated "Use Kernel.ParallelCompiler.compile/2 instead"
+  def files(files, options \\ []) when is_list(options) do
+    case spawn_workers(files, :compile, options) do
+      {:ok, modules, _} -> modules
+      {:error, _, _} -> exit({:shutdown, 1})
+    end
+  end
+
+  @doc false
+  @deprecated "Use Kernel.ParallelCompiler.compile_to_path/2 instead"
+  def files_to_path(files, path, options \\ []) when is_binary(path) and is_list(options) do
+    case spawn_workers(files, {:compile, path}, options) do
+      {:ok, modules, _} -> modules
+      {:error, _, _} -> exit({:shutdown, 1})
+    end
+  end
+
+  defp spawn_workers(files, output, options) do
+    {:module, _} = :code.ensure_loaded(Kernel.ErrorHandler)
+
+    schedulers =
+      Keyword.get_lazy(options, :max_concurrency, fn ->
+        max(:erlang.system_info(:schedulers_online), 2)
+      end)
+
+    {:ok, cache} = Module.ParallelChecker.start_link(options)
+
+    {status, modules_or_errors, info} =
+      try do
+        spawn_workers(schedulers, cache, files, output, options)
+      after
+        Module.ParallelChecker.stop(cache)
+      end
+
+    if Keyword.get(options, :return_diagnostics, false) do
+      {status, modules_or_errors, info}
+    else
+      IO.warn(
+        "you must pass return_diagnostics: true when invoking Kernel.ParallelCompiler functions"
+      )
+
+      to_tuples = &Enum.map(&1, fn diag -> {diag.file, diag.position, diag.message} end)
+
+      modules_or_errors =
+        if status == :ok, do: modules_or_errors, else: to_tuples.(modules_or_errors)
+
+      {status, modules_or_errors, to_tuples.(info.runtime_warnings ++ info.compile_warnings)}
+    end
+  end
+
+  defp spawn_workers(schedulers, checker, files, output, options) do
+    threshold = Keyword.get(options, :long_compilation_threshold, 10) * 1000
+    timer_ref = Process.send_after(self(), :threshold_check, threshold)
+
+    {outcome, state} =
+      spawn_workers(files, %{}, %{}, [], %{}, [], [], %{
+        beam_timestamp: Keyword.get(options, :beam_timestamp),
+        dest: Keyword.get(options, :dest),
+        after_compile: Keyword.get(options, :after_compile, fn -> :ok end),
+        each_cycle: Keyword.get(options, :each_cycle, fn -> {:runtime, [], []} end),
+        each_file: Keyword.get(options, :each_file, fn _, _ -> :ok end) |> each_file(),
+        each_long_compilation: Keyword.get(options, :each_long_compilation, fn _file -> :ok end),
+        each_module: Keyword.get(options, :each_module, fn _file, _module, _binary -> :ok end),
+        profile: profile_init(Keyword.get(options, :profile)),
+        output: output,
+        timer_ref: timer_ref,
+        long_compilation_threshold: threshold,
+        schedulers: schedulers,
+        checker: checker,
+        verification?: Keyword.get(options, :verification, true)
+      })
+
+    Process.cancel_timer(state.timer_ref)
+
+    receive do
+      :threshold_check -> :ok
+    after
+      0 -> :ok
+    end
+
+    outcome
+  end
+
+  defp each_file(fun) when is_function(fun, 1), do: fn file, _ -> fun.(file) end
+  defp each_file(fun) when is_function(fun, 2), do: fun
+
+  defp each_file(file, lexical, parent) do
+    ref = Process.monitor(parent)
+    send(parent, {:file_ok, self(), ref, file, lexical})
+
+    receive do
+      ^ref -> :ok
+      {:DOWN, ^ref, _, _, _} -> :ok
+    end
+  end
+
+  defp write_module_binaries(result, {:compile, path}, state) when map_size(result) > 0 do
+    profile(state, "writing modules to disk", fn ->
+      File.mkdir_p!(path)
+      Code.prepend_path(path)
+      timestamp = state.beam_timestamp
+
+      # We fan-out the writes as that improves performance
+      # when writing hundreds of beam files. This is cheap as
+      # we only transfer atoms and binaries across processes.
+      pool_size = min(map_size(result), state.schedulers)
+
+      pool_list =
+        for _ <- 1..pool_size do
+          spawn_link(fn -> write_loop(path, timestamp) end)
+        end
+
+      pool_tuple = List.to_tuple(pool_list)
+
+      {modules, _} =
+        Enum.flat_map_reduce(result, 0, fn
+          {{:module, module}, {binary, _}}, scheduler when is_binary(binary) ->
+            send(elem(pool_tuple, scheduler), {:write, module, binary})
+            {[module], rem(scheduler + 1, pool_size)}
+
+          _, scheduler ->
+            {[], scheduler}
+        end)
 
-  def files_to_path(files, path, callbacks) when is_binary(path) and is_list(callbacks) do
-    spawn_compilers(files, path, callbacks)
+      pool_refs =
+        for pid <- pool_list do
+          ref = Process.monitor(pid)
+          send(pid, :done)
+          ref
+        end
+
+      for ref <- pool_refs do
+        receive do
+          {:DOWN, ^ref, _, _, _} -> :ok
+        end
+      end
+
+      modules
+    end)
   end
 
-  defp spawn_compilers(files, path, callbacks) do
-    Code.ensure_loaded(Kernel.ErrorHandler)
-    compiler_pid = self()
-    :elixir_code_server.cast({:reset_warnings, compiler_pid})
-    schedulers = max(:erlang.system_info(:schedulers_online), 2)
+  defp write_module_binaries(result, _output, _state) do
+    for {{:module, module}, {binary, _}} when is_binary(binary) <- result, do: module
+  end
 
-    result = spawn_compilers(files, files, path, callbacks, [], [], schedulers, [])
+  defp write_loop(path, timestamp) do
+    receive do
+      {:write, module, binary} ->
+        full_path = Path.join(path, Atom.to_string(module) <> ".beam")
+        File.write!(full_path, binary, [:raw])
+        if timestamp, do: File.touch!(full_path, timestamp)
+        write_loop(path, timestamp)
 
-    # In case --warning-as-errors is enabled and there was a warning,
-    # compilation status will be set to error and we fail with CompileError
-    case :elixir_code_server.call({:compilation_status, compiler_pid}) do
-      :ok    -> result
-      :error -> exit(1)
+      :done ->
+        :ok
     end
   end
 
-  # We already have 4 currently running, don't spawn new ones
-  defp spawn_compilers(entries, original, output, callbacks, waiting, queued, schedulers, result) when
-      length(queued) - length(waiting) >= schedulers do
-    wait_for_messages(entries, original, output, callbacks, waiting, queued, schedulers, result)
+  ## Verification
+
+  defp verify_modules(result, compile_warnings, dependent_modules, state) do
+    modules = write_module_binaries(result, state.output, state)
+    profile(state, "after compile callback", state.after_compile)
+
+    runtime_warnings =
+      if state.verification? do
+        profile(
+          state,
+          fn ->
+            num_modules = length(modules) + length(dependent_modules)
+            "group pass check of #{num_modules} modules"
+          end,
+          fn -> Module.ParallelChecker.verify(state.checker, dependent_modules) end
+        )
+      else
+        []
+      end
+
+    info = %{compile_warnings: Enum.reverse(compile_warnings), runtime_warnings: runtime_warnings}
+    {{:ok, modules, info}, state}
+  end
+
+  defp profile_init(:time), do: {:time, System.monotonic_time(), 0}
+  defp profile_init(nil), do: :none
+
+  defp profile(%{profile: :none}, _what, fun), do: fun.()
+
+  defp profile(%{profile: {:time, _, _}}, what, fun) do
+    {time, result} = :timer.tc(fun)
+    time = div(time, 1000)
+    what = if is_binary(what), do: what, else: what.()
+    IO.puts(:stderr, "[profile] Finished #{what} in #{time}ms")
+    result
+  end
+
+  ## Compiler worker spawning
+
+  # We already have n=schedulers currently running, don't spawn new ones
+  defp spawn_workers(
+         queue,
+         spawned,
+         waiting,
+         files,
+         result,
+         warnings,
+         errors,
+         %{schedulers: schedulers} = state
+       )
+       when map_size(spawned) - map_size(waiting) >= schedulers do
+    wait_for_messages(queue, spawned, waiting, files, result, warnings, errors, state)
   end
 
   # Release waiting processes
-  defp spawn_compilers([h|t], original, output, callbacks, waiting, queued, schedulers, result) when is_pid(h) do
-    {_kind, ^h, ref, _module} = List.keyfind(waiting, h, 1)
-    send h, {ref, :ready}
-    waiting = List.keydelete(waiting, h, 1)
-    spawn_compilers(t, original, output, callbacks, waiting, queued, schedulers, result)
+  defp spawn_workers([{pid, found} | t], spawned, waiting, files, result, warnings, errors, state) do
+    {files, waiting} =
+      case Map.pop(waiting, pid) do
+        {%{kind: kind, ref: ref, file_pid: file_pid, on: on}, waiting} ->
+          send(pid, {ref, found})
+          {update_timing(files, file_pid, {:waiting, kind, on}), waiting}
+
+        {nil, waiting} ->
+          # In case the waiting process died (for example, it was an async process),
+          # it will no longer be on the list. So we need to take it into account here.
+          {files, waiting}
+      end
+
+    spawn_workers(t, spawned, waiting, files, result, warnings, errors, state)
   end
 
-  # Spawn a compiler for each file in the list until we reach the limit
-  defp spawn_compilers([h|t], original, output, callbacks, waiting, queued, schedulers, result) do
+  defp spawn_workers([file | queue], spawned, waiting, files, result, warnings, errors, state) do
+    %{output: output, dest: dest, checker: cache} = state
     parent = self()
+    file = Path.expand(file)
 
     {pid, ref} =
-      :erlang.spawn_monitor fn ->
-        # Notify Code.ensure_compiled/2 that we should
-        # attempt to compile the module by doing a dispatch.
-        :erlang.put(:elixir_ensure_compiled, true)
-
-        # Set the elixir_compiler_pid used by our custom Kernel.ErrorHandler.
-        :erlang.put(:elixir_compiler_pid, parent)
-        :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
-
-        exit(try do
-          if output do
-            :elixir_compiler.file_to_path(h, output)
-          else
-            :elixir_compiler.file(h)
+      :erlang.spawn_monitor(fn ->
+        Module.ParallelChecker.put(parent, cache)
+        :erlang.put(:elixir_compiler_info, {parent, self()})
+        :erlang.put(:elixir_compiler_file, file)
+
+        try do
+          case output do
+            {:compile, _} -> compile_file(file, dest, false, parent)
+            :compile -> compile_file(file, dest, true, parent)
+            :require -> require_file(file, parent)
           end
-          {:compiled, h}
         catch
           kind, reason ->
-            {:failure, kind, reason, System.stacktrace}
-        end)
-      end
+            send(parent, {:file_error, self(), file, {kind, reason, __STACKTRACE__}})
+        end
+
+        exit(:shutdown)
+      end)
+
+    file_data = %{
+      pid: pid,
+      ref: ref,
+      file: file,
+      timestamp: System.monotonic_time(),
+      compiling: 0,
+      waiting: [],
+      warned: false
+    }
 
-    spawn_compilers(t, original, output, callbacks, waiting,
-                    [{pid, ref, h}|queued], schedulers, result)
+    new_files = [file_data | files]
+    new_spawned = Map.put(spawned, ref, pid)
+    spawn_workers(queue, new_spawned, waiting, new_files, result, warnings, errors, state)
   end
 
-  # No more files, nothing waiting, queue is empty, we are done
-  defp spawn_compilers([], _original, _output, _callbacks, [], [], _schedulers, result) do
-    for {:module, mod} <- result, do: mod
+  # No more queue, nothing waiting, this cycle is done
+  defp spawn_workers([], spawned, waiting, files, result, warnings, errors, state)
+       when map_size(spawned) == 0 and map_size(waiting) == 0 do
+    # Print any spurious error that we may have found
+    Enum.map(errors, fn {diagnostic, read_snippet} ->
+      :elixir_errors.print_diagnostic(diagnostic, read_snippet)
+    end)
+
+    [] = files
+
+    cycle_return =
+      profile(state, "cycle resolution", fn -> each_cycle_return(state.each_cycle.()) end)
+
+    state = cycle_timing(result, state)
+
+    case cycle_return do
+      {:runtime, dependent_modules, extra_warnings} ->
+        :elixir_code_server.cast(:purge_compiler_modules)
+        verify_modules(result, extra_warnings ++ warnings, dependent_modules, state)
+
+      {:compile, [], extra_warnings} ->
+        :elixir_code_server.cast(:purge_compiler_modules)
+        verify_modules(result, extra_warnings ++ warnings, [], state)
+
+      {:compile, more, extra_warnings} ->
+        spawn_workers(more, %{}, %{}, [], result, extra_warnings ++ warnings, errors, state)
+    end
+  end
+
+  # spawned 1, waiting for 1: Release it!
+  defp spawn_workers([], spawned, waiting, files, result, warnings, errors, state)
+       when map_size(waiting) == map_size(spawned) and map_size(waiting) == 1 do
+    {pid, _, _iterator} = :maps.next(:maps.iterator(waiting))
+    spawn_workers([{pid, :not_found}], spawned, waiting, files, result, warnings, errors, state)
   end
 
-  # Queued x, waiting for x: POSSIBLE ERROR! Release processes so we get the failures
-  defp spawn_compilers([], original, output, callbacks, waiting, queued, schedulers, result) when length(waiting) == length(queued) do
-    Enum.each queued, fn {child, _, _} ->
-      {_kind, ^child, ref, _module} = List.keyfind(waiting, child, 1)
-      send child, {ref, :release}
+  # spawned x, waiting for x: POSSIBLE ERROR! Release processes so we get the failures
+  defp spawn_workers([], spawned, waiting, files, result, warnings, errors, state)
+       when map_size(waiting) == map_size(spawned) do
+    # There is potentially a deadlock. We will release modules with
+    # the following order:
+    #
+    #   1. Code.ensure_compiled/1 checks without a known definition (deadlock = soft)
+    #   2. Code.ensure_compiled/1 checks with a known definition (deadlock = soft)
+    #   3. Struct/import/require/ensure_compiled! checks without a known definition (deadlock = hard)
+    #   4. Modules without a known definition
+    #   5. Code invocation (deadlock = raise)
+    #
+    # The reason for step 3 and 4 is to not treat typos as deadlocks and
+    # help developers handle those sooner. However, this can have false
+    # positives in case multiple modules are defined in the same file
+    # and the module we are waiting for is defined later on.
+    #
+    # Finally, note there is no difference between hard and raise, the
+    # difference is where the raise is happening, inside the compiler
+    # or in the caller.
+    deadlocked =
+      profile(state, "deadlock resolution", fn ->
+        waiting_list = Map.to_list(waiting)
+
+        deadlocked(waiting_list, :soft, false) ||
+          deadlocked(waiting_list, :soft, true) ||
+          deadlocked(waiting_list, :hard, false) ||
+          without_definition(waiting_list, files)
+      end)
+
+    if deadlocked do
+      spawn_workers(deadlocked, spawned, waiting, files, result, warnings, errors, state)
+    else
+      return_error(warnings, errors, state, fn ->
+        handle_deadlock(waiting, files)
+      end)
     end
-    wait_for_messages([], original, output, callbacks, waiting, queued, schedulers, result)
   end
 
-  # No more files, but queue and waiting are not full or do not match
-  defp spawn_compilers([], original, output, callbacks, waiting, queued, schedulers, result) do
-    wait_for_messages([], original, output, callbacks, waiting, queued, schedulers, result)
+  # No more queue, but spawned and map_size(waiting) do not match
+  defp spawn_workers([], spawned, waiting, files, result, warnings, errors, state) do
+    wait_for_messages([], spawned, waiting, files, result, warnings, errors, state)
+  end
+
+  defp compile_file(file, path, force_load?, parent) do
+    :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
+    :erlang.put(:elixir_compiler_dest, {path, force_load?})
+    :elixir_compiler.file(file, &each_file(&1, &2, parent))
+  end
+
+  defp require_file(file, parent) do
+    case :elixir_code_server.call({:acquire, file}) do
+      :required ->
+        send(parent, {:file_cancel, self()})
+
+      :proceed ->
+        :elixir_compiler.file(file, &each_file(&1, &2, parent))
+        :elixir_code_server.cast({:required, file})
+    end
+  end
+
+  defp cycle_timing(_result, %{profile: :none} = state) do
+    state
+  end
+
+  defp cycle_timing(result, %{profile: {:time, cycle_start, module_counter}} = state) do
+    num_modules = count_modules(result)
+    diff_modules = num_modules - module_counter
+    now = System.monotonic_time()
+    time = System.convert_time_unit(now - cycle_start, :native, :millisecond)
+
+    IO.puts(
+      :stderr,
+      "[profile] Finished compilation cycle of #{diff_modules} modules in #{time}ms"
+    )
+
+    %{state | profile: {:time, now, num_modules}}
+  end
+
+  defp count_modules(result) do
+    Enum.count(result, &match?({{:module, _}, {binary, _}} when is_binary(binary), &1))
+  end
+
+  defp each_cycle_return({kind, modules, warnings}), do: {kind, modules, warnings}
+
+  defp each_cycle_return(other) do
+    IO.warn(
+      "the :each_cycle callback must return a tuple of format {:compile | :runtime, modules, warnings}"
+    )
+
+    case other do
+      {kind, modules} -> {kind, modules, []}
+      modules when is_list(modules) -> {:compile, modules, []}
+    end
+  end
+
+  # The goal of this function is to find leaves in the dependency graph,
+  # i.e. to find code that depends on code that we know is not being defined.
+  # Note that not all files have been compiled yet, so they may not be in waiting.
+  defp without_definition(waiting_list, files) do
+    nilify_empty_or_sort(
+      for %{pid: file_pid} <- files,
+          {pid, %{file_pid: ^file_pid, on: on}} <- waiting_list,
+          is_atom(on) and not defining?(on, waiting_list),
+          do: {pid, :not_found}
+    )
+  end
+
+  defp deadlocked(waiting_list, type, defining?) do
+    nilify_empty_or_sort(
+      for {pid, %{on: on, deadlock: ^type}} <- waiting_list,
+          is_atom(on) and defining?(on, waiting_list) == defining?,
+          do: {pid, :deadlock}
+    )
+  end
+
+  defp defining?(on, waiting_list) do
+    Enum.any?(waiting_list, fn {_, %{defining: defining}} -> on in defining end)
   end
 
+  defp nilify_empty_or_sort([]), do: nil
+  defp nilify_empty_or_sort([_ | _] = list), do: Enum.sort(list)
+
   # Wait for messages from child processes
-  defp wait_for_messages(entries, original, output, callbacks, waiting, queued, schedulers, result) do
+  defp wait_for_messages(queue, spawned, waiting, files, result, warnings, errors, state) do
+    %{output: output} = state
+
     receive do
-      {:struct_available, module} ->
-        available = for {:struct, pid, _, waiting_module} <- waiting,
-                        module == waiting_module,
-                        not pid in entries,
-                        do: pid
-
-        spawn_compilers(available ++ entries, original, output, callbacks,
-                        waiting, queued, schedulers, [{:struct, module}|result])
-
-      {:module_available, child, ref, file, module, binary} ->
-        if callback = Keyword.get(callbacks, :each_module) do
-          callback.(file, module, binary)
-        end
+      {:async, pid} ->
+        ref = Process.monitor(pid)
+        new_spawned = Map.put(spawned, ref, pid)
+        wait_for_messages(queue, new_spawned, waiting, files, result, warnings, errors, state)
+
+      {:available, kind, on} ->
+        {available, result} = update_result(result, kind, on, :done)
+
+        spawn_workers(
+          available ++ queue,
+          spawned,
+          waiting,
+          files,
+          result,
+          warnings,
+          errors,
+          state
+        )
+
+      {{:module_loaded, module}, _ref, _type, _pid, _reason} ->
+        result =
+          Map.update!(result, {:module, module}, fn {binary, _loader} -> {binary, true} end)
+
+        spawn_workers(queue, spawned, waiting, files, result, warnings, errors, state)
+
+      {:module_available, child, ref, file, module, binary, loaded?} ->
+        state.each_module.(file, module, binary)
+        send(child, {ref, :ack})
+
+        {available, load_status} =
+          case Map.get(result, {:module, module}) do
+            [_ | _] = pids when loaded? ->
+              {Enum.map(pids, &{&1, :found}), loaded?}
+
+            # When compiling files to disk, we only load the module
+            # if other modules are waiting for it.
+            [_ | _] = pids ->
+              pid = load_module(module, binary, state.dest)
+              {Enum.map(pids, &{&1, {:loading, pid}}), pid}
+
+            _ ->
+              {[], loaded?}
+          end
+
+        spawn_workers(
+          available ++ queue,
+          spawned,
+          waiting,
+          files,
+          Map.put(result, {:module, module}, {binary, load_status}),
+          warnings,
+          errors,
+          state
+        )
+
+      # If we are simply requiring files, we do not add to waiting.
+      {:waiting, _kind, child, ref, _file_pid, _position, _on, _defining, _deadlock}
+      when output == :require ->
+        send(child, {ref, :not_found})
+        spawn_workers(queue, spawned, waiting, files, result, warnings, errors, state)
 
-        # Release the module loader which is waiting for an ack
-        send child, {ref, :ack}
+      {:waiting, kind, child_pid, ref, file_pid, position, on, defining, deadlock} ->
+        # If we already got what we were waiting for, do not put it on waiting.
+        # If we're waiting on ourselves, send :found so that we can crash with
+        # a better error.
+        available_or_pending = Map.get(result, {kind, on}, [])
 
-        available = for {_kind, pid, _, waiting_module} <- waiting,
-                        module == waiting_module,
-                        not pid in entries,
-                        do: pid
+        {waiting, files, result} =
+          if not is_list(available_or_pending) or on in defining do
+            # If what we are waiting on was defined but not loaded, we do it now.
+            {reply, result} = load_pending(kind, on, result, state)
+            send(child_pid, {ref, reply})
+            {waiting, files, result}
+          else
+            waiting =
+              Map.put(waiting, child_pid, %{
+                kind: kind,
+                ref: ref,
+                file_pid: file_pid,
+                position: position,
+                on: on,
+                defining: defining,
+                deadlock: deadlock
+              })
+
+            files = update_timing(files, file_pid, :compiling)
+            result = Map.put(result, {kind, on}, [child_pid | available_or_pending])
+            {waiting, files, result}
+          end
+
+        spawn_workers(queue, spawned, waiting, files, result, warnings, errors, state)
+
+      :threshold_check ->
+        files =
+          for data <- files do
+            if data.warned or Map.has_key?(waiting, data.pid) do
+              data
+            else
+              data = update_timing(data, :compiling)
+              data = maybe_warn_long_compilation(data, state)
+              data
+            end
+          end
+
+        timer_ref = Process.send_after(self(), :threshold_check, state.long_compilation_threshold)
+        state = %{state | timer_ref: timer_ref}
+        spawn_workers(queue, spawned, waiting, files, result, warnings, errors, state)
+
+      {:diagnostic, %{severity: :warning, file: file} = diagnostic, read_snippet} ->
+        :elixir_errors.print_diagnostic(diagnostic, read_snippet)
+        warnings = [%{diagnostic | file: file && Path.absname(file)} | warnings]
+        wait_for_messages(queue, spawned, waiting, files, result, warnings, errors, state)
+
+      {:diagnostic, %{severity: :error} = diagnostic, read_snippet} ->
+        errors = [{diagnostic, read_snippet} | errors]
+        wait_for_messages(queue, spawned, waiting, files, result, warnings, errors, state)
+
+      {:file_ok, child_pid, ref, file, lexical} ->
+        state.each_file.(file, lexical)
+        send(child_pid, ref)
+
+        {file, new_spawned, new_files} = discard_file_pid(spawned, files, child_pid)
+        file && maybe_log_file_profile(file, state)
+
+        # We may have spurious entries in the waiting list
+        # if someone invoked try/rescue UndefinedFunctionError
+        new_waiting = Map.delete(waiting, child_pid)
+        spawn_workers(queue, new_spawned, new_waiting, new_files, result, warnings, errors, state)
+
+      {:file_cancel, child_pid} ->
+        {_file, new_spawned, new_files} = discard_file_pid(spawned, files, child_pid)
+        spawn_workers(queue, new_spawned, waiting, new_files, result, warnings, errors, state)
+
+      {:file_error, child_pid, file, {kind, reason, stack}} ->
+        {_file, _new_spawned, new_files} = discard_file_pid(spawned, files, child_pid)
+        terminate(new_files)
+
+        return_error(warnings, errors, state, fn ->
+          print_error(file, nil, kind, reason, stack)
+          [to_error(file, kind, reason, stack)]
+        end)
 
-        spawn_compilers(available ++ entries, original, output, callbacks,
-                        waiting, queued, schedulers, [{:module, module}|result])
+      {:DOWN, ref, :process, pid, reason} when is_map_key(spawned, ref) ->
+        # async spawned processes have no file, so we always have to delete the ref directly
+        spawned = Map.delete(spawned, ref)
+        waiting = Map.delete(waiting, pid)
+        {file, spawned, files} = discard_file_pid(spawned, files, pid)
 
-      {:waiting, kind, child, ref, on} ->
-        defined = fn {k, m} -> on == m and k in [kind, :module] end
+        if file do
+          terminate(files)
 
-        # Oops, we already got it, do not put it on waiting.
-        if :lists.any(defined, result) do
-          send child, {ref, :ready}
+          return_error(warnings, errors, state, fn ->
+            print_error(file.file, nil, :exit, reason, [])
+            [to_error(file.file, :exit, reason, [])]
+          end)
         else
-          waiting = [{kind, child, ref, on}|waiting]
+          wait_for_messages(queue, spawned, waiting, files, result, warnings, errors, state)
         end
+    end
+  end
 
-        spawn_compilers(entries, original, output, callbacks, waiting, queued, schedulers, result)
+  defp return_error(warnings, errors, state, fun) do
+    # Also prune compiler modules in case of errors
+    :elixir_code_server.cast(:purge_compiler_modules)
 
-      {:DOWN, _down_ref, :process, down_pid, {:compiled, file}} ->
-        if callback = Keyword.get(callbacks, :each_file) do
-          callback.(file)
-        end
+    errors =
+      Enum.map(errors, fn {%{file: file} = diagnostic, read_snippet} ->
+        :elixir_errors.print_diagnostic(diagnostic, read_snippet)
+        %{diagnostic | file: file && Path.absname(file)}
+      end)
+
+    info = %{compile_warnings: Enum.reverse(warnings), runtime_warnings: []}
+    {{:error, Enum.reverse(errors, fun.()), info}, state}
+  end
 
-        # Sometimes we may have spurious entries in the waiting
-        # list because someone invoked try/rescue UndefinedFunctionError
-        new_entries = List.delete(entries, down_pid)
-        new_queued  = List.keydelete(queued, down_pid, 0)
-        new_waiting = List.keydelete(waiting, down_pid, 1)
-        spawn_compilers(new_entries, original, output, callbacks, new_waiting, new_queued, schedulers, result)
+  defp load_pending(kind, module, result, state) do
+    case result do
+      %{{:module, ^module} => {binary, load_status}}
+      when kind in [:module, :struct] and is_binary(binary) ->
+        case load_status do
+          true ->
+            {:found, result}
 
-      {:DOWN, down_ref, :process, _down_pid, reason} ->
-        handle_failure(down_ref, reason, entries, waiting, queued)
-        wait_for_messages(entries, original, output, callbacks, waiting, queued, schedulers, result)
+          false ->
+            pid = load_module(module, binary, state.dest)
+            result = Map.put(result, {:module, module}, {binary, pid})
+            {{:loading, pid}, result}
+
+          pid when is_pid(pid) ->
+            {{:loading, pid}, result}
+        end
+
+      _ ->
+        {:found, result}
     end
   end
 
-  defp handle_failure(ref, reason, entries, waiting, queued) do
-    if file = find_failure(ref, queued) do
-      print_failure(file, reason)
-      if all_missing?(entries, waiting, queued) do
-        collect_failures(queued, length(queued) - 1)
+  # We load modules in a separate process to avoid blocking
+  # the parallel compiler. We store the PID of this process and
+  # all entries monitor it to know once the module is loaded.
+  defp load_module(module, binary, dest) do
+    {pid, _ref} =
+      :erlang.spawn_opt(
+        fn ->
+          beam_location =
+            case dest do
+              nil ->
+                []
+
+              dest ->
+                :filename.join(
+                  :elixir_utils.characters_to_list(dest),
+                  Atom.to_charlist(module) ++ ~c".beam"
+                )
+            end
+
+          :code.load_binary(module, beam_location, binary)
+        end,
+        monitor: [tag: {:module_loaded, module}]
+      )
+
+    pid
+  end
+
+  defp update_result(result, kind, module, value) do
+    available =
+      case Map.get(result, {kind, module}) do
+        [_ | _] = pids -> Enum.map(pids, &{&1, :found})
+        _ -> []
       end
-      exit(1)
+
+    {available, Map.put(result, {kind, module}, value)}
+  end
+
+  defp update_timing(files, pid, key) do
+    Enum.map(files, fn data ->
+      if data.pid == pid, do: update_timing(data, key), else: data
+    end)
+  end
+
+  defp update_timing(data, :compiling) do
+    time = System.monotonic_time()
+    %{data | compiling: data.compiling + time - data.timestamp, timestamp: time}
+  end
+
+  defp update_timing(data, {:waiting, kind, on}) do
+    time = System.monotonic_time()
+    %{data | waiting: [{kind, on, time - data.timestamp} | data.waiting], timestamp: time}
+  end
+
+  defp maybe_warn_long_compilation(data, state) do
+    compiling = System.convert_time_unit(data.compiling, :native, :millisecond)
+
+    if not data.warned and compiling >= state.long_compilation_threshold do
+      if is_function(state.each_long_compilation, 2) do
+        state.each_long_compilation.(data.file, data.pid)
+      else
+        state.each_long_compilation.(data.file)
+      end
+
+      %{data | warned: true}
+    else
+      data
+    end
+  end
+
+  defp discard_file_pid(spawned, files, pid) do
+    case Enum.split_with(files, &(&1.pid == pid)) do
+      {[file], files} ->
+        Process.demonitor(file.ref, [:flush])
+        {file, Map.delete(spawned, file.ref), files}
+
+      {[], files} ->
+        {nil, spawned, files}
+    end
+  end
+
+  defp maybe_log_file_profile(data, state) do
+    data = update_timing(data, :compiling)
+    data = maybe_warn_long_compilation(data, state)
+
+    if state.profile != :none do
+      compiling = to_padded_ms(data.compiling)
+      relative = Path.relative_to_cwd(data.file)
+
+      messages =
+        case List.pop_at(data.waiting, 0) do
+          {nil, []} ->
+            "[profile] #{compiling}ms compiling +      0ms waiting while compiling #{relative}"
+
+          {{kind, on, time}, rest} ->
+            initial_message = [
+              "[profile] #{compiling}ms compiling + ",
+              format_waiting_message(time, kind, on, relative)
+            ]
+
+            waiting_details =
+              Enum.map(rest, fn {kind, on, time} ->
+                [
+                  "\n[profile]                    | ",
+                  format_waiting_message(time, kind, on, relative)
+                ]
+              end)
+
+            [initial_message | waiting_details]
+        end
+
+      IO.puts(:stderr, messages)
     end
   end
 
-  defp find_failure(ref, queued) do
-    case List.keyfind(queued, ref, 1) do
-      {_child, ^ref, file} -> file
-      _ -> nil
+  defp format_waiting_message(time, kind, on, relative),
+    do: "#{to_padded_ms(time)}ms waiting for #{kind} #{inspect(on)} while compiling #{relative}"
+
+  defp to_padded_ms(time) do
+    time
+    |> System.convert_time_unit(:native, :millisecond)
+    |> Integer.to_string()
+    |> String.pad_leading(6, " ")
+  end
+
+  defp handle_deadlock(waiting, files) do
+    deadlock =
+      for %{pid: pid, file: file} <- files do
+        {:current_stacktrace, stacktrace} = Process.info(pid, :current_stacktrace)
+        Process.exit(pid, :kill)
+
+        %{kind: kind, on: on, position: position} = Map.fetch!(waiting, pid)
+        description = "deadlocked waiting on #{kind} #{inspect(on)}"
+        error = CompileError.exception(description: description, file: nil, line: nil)
+        print_error(file, position, :error, error, stacktrace)
+        {Path.relative_to_cwd(file), position, on, description, stacktrace}
+      end
+
+    IO.puts(:stderr, """
+
+    Compilation failed because of a deadlock between files.
+    The following files depended on the following modules:
+    """)
+
+    max =
+      deadlock
+      |> Enum.map(&(&1 |> elem(0) |> String.length()))
+      |> Enum.max()
+
+    for {file, _, mod, _, _} <- deadlock do
+      IO.puts(:stderr, ["  ", String.pad_leading(file, max), " => " | inspect(mod)])
+    end
+
+    IO.puts(
+      :stderr,
+      "\nEnsure there are no compile-time dependencies between those files " <>
+        "(such as structs or macros) and that the modules they reference exist " <>
+        "and are correctly named\n"
+    )
+
+    for {file, position, _, description, stacktrace} <- deadlock do
+      file = Path.absname(file)
+
+      %{
+        severity: :error,
+        file: file,
+        source: file,
+        position: position,
+        message: description,
+        stacktrace: stacktrace,
+        span: nil
+      }
     end
   end
 
-  defp print_failure(_file, {:compiled, _}) do
+  defp terminate(files) do
+    for %{pid: pid} <- files, do: Process.exit(pid, :kill)
+
+    for %{pid: pid} <- files do
+      receive do
+        {:DOWN, _, :process, ^pid, _} -> :ok
+      end
+    end
+
     :ok
   end
 
-  defp print_failure(file, {:failure, kind, reason, stacktrace}) do
-    IO.puts "\n== Compilation error on file #{Path.relative_to_cwd(file)} =="
-    IO.puts Exception.format(kind, reason, prune_stacktrace(stacktrace))
+  defp print_error(file, position, kind, reason, stack) do
+    position = if is_integer(position), do: ":#{position}", else: ""
+
+    IO.write(:stderr, [
+      "\n== Compilation error in file #{Path.relative_to_cwd(file)}#{position} ==\n",
+      Kernel.CLI.format_error(kind, reason, stack)
+    ])
+  end
+
+  defp to_error(source, kind, reason, stack) do
+    {file, line, span} = get_snippet_info(source, reason, stack)
+    source = Path.absname(source)
+    message = :unicode.characters_to_binary(Kernel.CLI.format_error(kind, reason, stack))
+
+    %{
+      file: file || source,
+      source: source,
+      position: line || 0,
+      message: message,
+      severity: :error,
+      stacktrace: stack,
+      span: span,
+      details: {kind, reason}
+    }
   end
 
-  defp print_failure(file, reason) do
-    IO.puts "\n== Compilation error on file #{Path.relative_to_cwd(file)} =="
-    IO.puts Exception.format(:exit, reason, [])
+  defp get_snippet_info(
+         _file,
+         %{file: file, line: line, column: column, end_line: end_line, end_column: end_column},
+         _stack
+       )
+       when is_integer(line) and line > 0 and is_integer(column) and column >= 0 and
+              is_integer(end_line) and end_line > 0 and is_integer(end_column) and end_column >= 0 do
+    {Path.absname(file), {line, column}, {end_line, end_column}}
   end
 
-  @elixir_internals [:elixir_compiler, :elixir_module, :elixir_translator, :elixir_expand]
+  defp get_snippet_info(_file, %{file: file, line: line, column: column}, _stack)
+       when is_integer(line) and line > 0 and is_integer(column) and column >= 0 do
+    {Path.absname(file), {line, column}, nil}
+  end
 
-  defp prune_stacktrace([{mod, _, _, _}|t]) when mod in @elixir_internals do
-    prune_stacktrace(t)
+  defp get_snippet_info(_file, %{line: line}, _stack) when is_integer(line) and line > 0 do
+    {nil, line, nil}
   end
 
-  defp prune_stacktrace([h|t]) do
-    [h|prune_stacktrace(t)]
+  defp get_snippet_info(file, :undef, [{_, _, _, []}, {_, _, _, info} | _]) do
+    get_snippet_info_from_stacktrace_info(info, file)
   end
 
-  defp prune_stacktrace([]) do
-    []
+  defp get_snippet_info(file, _reason, [{_, _, _, [file: expanding]}, {_, _, _, info} | _])
+       when expanding in [~c"expanding macro", ~c"expanding struct"] do
+    get_snippet_info_from_stacktrace_info(info, file)
   end
 
-  defp all_missing?(entries, waiting, queued) do
-    entries == [] and waiting != [] and
-      length(waiting) == length(queued)
+  defp get_snippet_info(file, _reason, [{_, _, _, info} | _]) do
+    get_snippet_info_from_stacktrace_info(info, file)
   end
 
-  defp collect_failures(_queued, 0), do: :ok
+  defp get_snippet_info(_, _, _) do
+    {nil, nil, nil}
+  end
 
-  defp collect_failures(queued, remaining) do
-    receive do
-      {:DOWN, down_ref, :process, _down_pid, reason} ->
-        if file = find_failure(down_ref, queued) do
-          print_failure(file, reason)
-          collect_failures(queued, remaining - 1)
-        else
-          collect_failures(queued, remaining)
-        end
-    after
-      # Give up if no failure appears in 5 seconds
-      5000 -> :ok
+  defp get_snippet_info_from_stacktrace_info(info, file) do
+    if Keyword.get(info, :file) == to_charlist(Path.relative_to_cwd(file)) do
+      {nil, Keyword.get(info, :line), nil}
+    else
+      {nil, nil, nil}
     end
   end
 end
diff --git a/lib/elixir/lib/kernel/parallel_require.ex b/lib/elixir/lib/kernel/parallel_require.ex
index a9132618b33..412e397a54d 100644
--- a/lib/elixir/lib/kernel/parallel_require.ex
+++ b/lib/elixir/lib/kernel/parallel_require.ex
@@ -1,80 +1,22 @@
-defmodule Kernel.ParallelRequire do
-  @moduledoc """
-  A module responsible for requiring files in parallel.
-  """
-
-  defmacrop default_callback, do: quote(do: fn x -> x end)
-
-  @doc """
-  Requires the given files.
-
-  A callback that is invoked every time a file is required
-  can be optionally given as argument.
-
-  Returns the modules generated by each required file.
-  """
-  def files(files, callback \\ default_callback) do
-    schedulers = max(:erlang.system_info(:schedulers_online), 2)
-    spawn_requires(files, [], callback, schedulers, [])
-  end
-
-  defp spawn_requires([], [], _callback, _schedulers, result), do: result
-
-  defp spawn_requires([], waiting, callback, schedulers, result) do
-    wait_for_messages([], waiting, callback, schedulers, result)
-  end
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-  defp spawn_requires(files, waiting, callback, schedulers, result) when length(waiting) >= schedulers do
-    wait_for_messages(files, waiting, callback, schedulers, result)
-  end
-
-  defp spawn_requires([h|t], waiting, callback, schedulers, result) do
-    parent = self
-
-    compiler_pid    = :erlang.get(:elixir_compiler_pid)
-    ensure_compiled = :erlang.get(:elixir_ensure_compiled)
-    {:error_handler, handler} = :erlang.process_info(parent, :error_handler)
-
-    {pid, ref} = :erlang.spawn_monitor fn ->
-      if compiler_pid != :undefined do
-        :erlang.put(:elixir_compiler_pid, compiler_pid)
-      end
-
-      if ensure_compiled != :undefined do
-        :erlang.put(:elixir_ensure_compiled, ensure_compiled)
-      end
-
-      :erlang.process_flag(:error_handler, handler)
+defmodule Kernel.ParallelRequire do
+  @moduledoc false
+  @moduledoc deprecated: "Use the Kernel.ParallelCompiler module instead"
 
-      exit(try do
-        new = Code.require_file(h) || []
-        {:required, Enum.map(new, &elem(&1, 0)), h}
-      catch
-        kind, reason ->
-          {:failure, kind, reason, System.stacktrace}
-      end)
-    end
+  @deprecated "Use Kernel.ParallelCompiler.require/2 instead"
+  def files(files, callbacks \\ [])
 
-    spawn_requires(t, [{pid, ref}|waiting], callback, schedulers, result)
+  def files(files, callback) when is_function(callback, 1) do
+    files(files, each_file: callback)
   end
 
-  defp wait_for_messages(files, waiting, callback, schedulers, result) do
-    receive do
-      {:DOWN, ref, :process, pid, status} ->
-        tuple = {pid, ref}
-        if tuple in waiting do
-          case status do
-            {:required, mods, file} ->
-              callback.(file)
-              result  = mods ++ result
-              waiting = List.delete(waiting, tuple)
-            {:failure, kind, reason, stacktrace} ->
-              :erlang.raise(kind, reason, stacktrace)
-            other ->
-              :erlang.raise(:exit, other, [])
-          end
-        end
-        spawn_requires(files, waiting, callback, schedulers, result)
+  def files(files, options) when is_list(options) do
+    case Kernel.ParallelCompiler.require(files, options) do
+      {:ok, modules, _} -> modules
+      {:error, _, _} -> exit({:shutdown, 1})
     end
   end
 end
diff --git a/lib/elixir/lib/kernel/special_forms.ex b/lib/elixir/lib/kernel/special_forms.ex
index b3b97bcf8b1..384a087c32d 100644
--- a/lib/elixir/lib/kernel/special_forms.ex
+++ b/lib/elixir/lib/kernel/special_forms.ex
@@ -1,305 +1,373 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Kernel.SpecialForms do
   @moduledoc """
-  In this module we define Elixir special forms. Special forms
-  cannot be overridden by the developer and are the basic
-  building blocks of Elixir code.
+  Special forms are the basic building blocks of Elixir, and therefore
+  cannot be overridden by the developer.
+
+  The `Kernel.SpecialForms` module consists solely of macros that can be
+  invoked anywhere in Elixir code without the use of the
+  `Kernel.SpecialForms.` prefix. This is possible because they all have
+  been automatically imported, in the same fashion as the functions and
+  macros from the `Kernel` module.
 
-  Some of those forms are lexical (like `alias`, `case`, etc).
-  The macros `{}` and `<<>>` are also special forms used to define
-  tuple and binary data structures respectively.
+  These building blocks are defined in this module. Some of these special forms are lexical (such as
+  `alias/2` and `case/2`). The macros `{}/1` and `<<>>/1` are also special
+  forms used to define tuple and binary data structures respectively.
 
-  This module also documents Elixir's pseudo variables (`__ENV__`,
-  `__MODULE__`, `__DIR__` and `__CALLER__`). Pseudo variables return
-  information about Elixir's compilation environment and can only
-  be read, never assigned to.
+  This module also documents macros that return information about Elixir's
+  compilation environment, such as (`__ENV__/0`, `__MODULE__/0`, `__DIR__/0`,
+  `__STACKTRACE__/0`, and `__CALLER__/0`).
 
-  Finally, it also documents 2 special forms, `__block__` and
-  `__aliases__`, which are not intended to be called directly by the
+  Additionally, it documents two special forms, `__block__/1` and
+  `__aliases__/1`, which are not intended to be called directly by the
   developer but they appear in quoted contents since they are essential
   in Elixir's constructs.
   """
 
+  defmacrop error!(args) do
+    quote do
+      _ = unquote(args)
+
+      message =
+        "Elixir's special forms are expanded by the compiler and must not be invoked directly"
+
+      :erlang.error(RuntimeError.exception(message))
+    end
+  end
+
   @doc """
   Creates a tuple.
 
-  Only two item tuples are considered literals in Elixir.
-  Therefore all other tuples are represented in the AST
-  as a call to the special form `:{}`.
+  More information about the tuple data type and about functions to manipulate
+  tuples can be found in the `Tuple` module; some functions for working with
+  tuples are also available in `Kernel` (such as `Kernel.elem/2` or
+  `Kernel.tuple_size/1`).
 
-  Conveniences for manipulating tuples can be found in the
-  `Tuple` module. Some functions for working with tuples are
-  also available in `Kernel`, namely `Kernel.elem/2`,
-  `Kernel.put_elem/3` and `Kernel.tuple_size/1`.
+  ## AST representation
 
-  ## Examples
+  Only two-element tuples are considered literals in Elixir and return themselves
+  when quoted. Therefore, all other tuples are represented in the AST as calls to
+  the `:{}` special form.
 
-      iex> {1, 2, 3}
-      {1, 2, 3}
+      iex> quote do
+      ...>   {1, 2}
+      ...> end
+      {1, 2}
 
-      iex> quote do: {1, 2, 3}
-      {:{}, [], [1,2,3]}
+      iex> quote do
+      ...>   {1, 2, 3}
+      ...> end
+      {:{}, [], [1, 2, 3]}
 
   """
-  defmacro unquote(:{})(args)
+  defmacro unquote(:{})(args), do: error!([args])
 
   @doc """
   Creates a map.
 
-  Maps are key-value stores where keys are compared
-  using the match operator (`===`). Maps can be created with
-  the `%{}` special form where keys are associated via `=>`:
-
-      %{1 => 2}
-
-  Maps also support the keyword notation, as other special forms,
-  as long as they are at the end of the argument list:
-
-      %{hello: :world, with: :keywords}
-      %{:hello => :world, with: :keywords}
-
-  If a map has duplicated keys, the last key will always have
-  higher precedence:
-
-      iex> %{a: :b, a: :c}
-      %{a: :c}
-
-  Conveniences for manipulating maps can be found in the
-  `Map` module.
-
-  ## Access syntax
-
-  Besides the access functions available in the `Map` module,
-  like `Map.get/3` and `Map.fetch/2`, a map can be accessed using the
-  `.` operator:
-
-      iex> map = %{a: :b}
-      iex> map.a
-      :b
-
-  Note that the `.` operator expects the field to exist in the map.
-  If not, an `ArgumentError` is raised.
-
-  ## Update syntax
-
-  Maps also support an update syntax:
-
-      iex> map = %{:a => :b}
-      iex> %{map | :a => :c}
-      %{:a => :c}
-
-  Notice the update syntax requires the given keys to exist.
-  Trying to update a key that does not exist will raise an `ArgumentError`.
+  See the `Map` module for more information about maps, their syntax, and ways to
+  access and manipulate them.
 
   ## AST representation
 
-  Regardless if `=>` or the keywords syntax is used, Maps are
-  always represented internally as a list of two-items tuples
-  for simplicity:
+  Regardless of whether `=>` or the keyword syntax is used, key-value pairs in
+  maps are always represented internally as a list of two-element tuples for
+  simplicity:
 
-      iex> quote do: %{:a => :b, c: :d}
-      {:%{}, [], [{:a, :b}, {:c, :d}]}
+      iex> quote do
+      ...>   %{"a" => :b, c: :d}
+      ...> end
+      {:%{}, [], [{"a", :b}, {:c, :d}]}
 
   """
-  defmacro unquote(:%{})(args)
+  defmacro unquote(:%{})(args), do: error!([args])
 
   @doc """
-  Creates a struct.
+  Matches on or builds a struct.
 
   A struct is a tagged map that allows developers to provide
   default values for keys, tags to be used in polymorphic
   dispatches and compile time assertions.
 
-  To define a struct, you just need to implement the `__struct__/0`
-  function in a module:
+  Structs are usually defined with the `Kernel.defstruct/1` macro:
 
       defmodule User do
-        def __struct__ do
-          %{name: "josé", age: 27}
-        end
-      end
-
-  In practice though, structs are usually defined with the
-  `Kernel.defstruct/1` macro:
-
-      defmodule User do
-        defstruct name: "josé", age: 27
+        defstruct name: "john", age: 27
       end
 
   Now a struct can be created as follows:
 
       %User{}
 
-  Underneath a struct is just a map with a `__struct__` field
-  pointing to the `User` module:
+  Underneath a struct is a map with a `:__struct__` key pointing
+  to the `User` module, where the keys are validated at compile-time:
+
+      %User{} == %{__struct__: User, name: "john", age: 27}
+
+  The struct fields can be given when building the struct:
+
+      %User{age: 31}
+      #=> %{__struct__: User, name: "john", age: 31}
 
-      %User{} == %{__struct__: User, name: "josé", age: 27}
+  Or also on pattern matching to extract values out:
 
-  A struct also validates that the given keys are part of the defined
-  struct. The example below will fail because there is no key
-  `:full_name` in the `User` struct:
+      %User{age: age} = user
 
-      %User{full_name: "José Valim"}
+  The advantage of structs is that they validate that the given
+  keys are part of the defined struct. The example below will fail
+  because there is no key `:full_name` in the `User` struct:
 
-  Note that a struct specifies a minimum set of keys required
-  for operations. Other keys can be added to structs via the
-  regular map operations:
+      %User{full_name: "john doe"}
 
-      user = %User{}
-      Map.put(user, :a_non_struct_key, :value)
+  The map update syntax can also be used for updating structs:
 
-  An update operation specific for structs is also available:
+      %{user | age: 28}
 
-      %User{user | age: 28}
+  ## Pattern matching on struct names
 
-  The syntax above will guarantee the given keys are valid at
-  compilation time and it will guarantee at runtime the given
-  argument is a struct, failing with `BadStructError` otherwise.
+  Besides allowing pattern matching on struct fields, such as:
+
+      %User{age: age} = user
+
+  Structs also allow pattern matching on the struct name:
+
+      %struct_name{} = user
+      struct_name #=> User
+
+  You can also assign the struct name to `_` when you want to
+  check if something is a struct but you are not interested in
+  its name:
+
+      %_{} = user
 
-  Although structs are maps, by default structs do not implement
-  any of the protocols implemented for maps. Check
-  `Kernel.defprotocol/2` for more information on how structs
-  can be used with protocols for polymorphic dispatch. Also
-  see `Kernel.struct/2` for examples on how to create and update
-  structs dynamically.
   """
-  defmacro unquote(:%)(struct, map)
+  defmacro unquote(:%)(struct, map), do: error!([struct, map])
 
   @doc """
   Defines a new bitstring.
 
   ## Examples
 
-      iex> << 1, 2, 3 >>
-      << 1, 2, 3 >>
+      iex> <<1, 2, 3>>
+      <<1, 2, 3>>
+
+  ## Types
+
+  A bitstring is made of many segments and each segment has a
+  type. There are 9 types used in bitstrings:
 
-  ## Bitstring types
+  - `integer`
+  - `float`
+  - `bits` (alias for `bitstring`)
+  - `bitstring`
+  - `binary`
+  - `bytes` (alias for `binary`)
+  - `utf8`
+  - `utf16`
+  - `utf32`
 
-  A bitstring is made of many segments. Each segment has a
-  type, which defaults to integer:
+  When no type is specified, the default is `integer`:
 
       iex> <<1, 2, 3>>
       <<1, 2, 3>>
 
   Elixir also accepts by default the segment to be a literal
-  string or a literal char list, which are by expanded to integers:
+  string which expands to integers:
 
       iex> <<0, "foo">>
       <<0, 102, 111, 111>>
 
-  Any other type needs to be explicitly tagged. For example,
-  in order to store a float type in the binary, one has to do:
+  You can use one of `utf8` (the default), `utf16`, and `utf32` to
+  control how the string is encoded:
 
-      iex> <<3.14 :: float>>
-      <<64, 9, 30, 184, 81, 235, 133, 31>>
+      iex> <<"foo"::utf16>>
+      <<0, 102, 0, 111, 0, 111>>
 
-  This also means that variables need to be explicitly tagged,
-  otherwise Elixir defaults to integer:
+  Which is equivalent to writing:
+
+      iex> <<?f::utf16, ?o::utf16, ?o::utf16>>
+      <<0, 102, 0, 111, 0, 111>>
+
+  At runtime, binaries need to be explicitly tagged as `binary`:
 
       iex> rest = "oo"
-      iex> <<102, rest>>
+      iex> <<102, rest::binary>>
+      "foo"
+
+  Otherwise we get an `ArgumentError` when constructing the binary:
+
+      rest = "oo"
+      <<102, rest>>
       ** (ArgumentError) argument error
 
-  We can solve this by explicitly tagging it as a binary:
+  ## Options
 
-      <<102, rest :: binary>>
+  Many options can be given by using `-` as separator. Order is
+  arbitrary, so the following are all equivalent:
 
-  The type can be integer, float, bitstring/bits, binary/bytes,
-  utf8, utf16 or utf32, e.g.:
+      <<102::integer-native, rest::binary>>
+      <<102::native-integer, rest::binary>>
+      <<102::unsigned-big-integer, rest::binary>>
+      <<102::unsigned-big-integer-size(8), rest::binary>>
+      <<102::unsigned-big-integer-8, rest::binary>>
+      <<102::8-integer-big-unsigned, rest::binary>>
+      <<102, rest::binary>>
 
-      <<102 :: float, rest :: binary>>
+  ### Unit and Size
 
-  An integer can be any arbitrary precision integer. A float is an
-  IEEE 754 binary32 or binary64 floating point number. A bitstring
-  is an arbitrary series of bits. A binary is a special case of
-  bitstring that has a total size divisible by 8.
+  The length of the match is equal to the `unit` (a number of bits) times the
+  `size` (the number of repeated segments of length `unit`).
 
-  The utf8, utf16, and utf32 types are for unicode codepoints. They
-  can also be applied to literal strings and char lists:
+  Type      | Default Unit
+  --------- | ------------
+  `integer` | 1 bit
+  `float`   | 1 bit
+  `binary`  | 8 bits
 
-      iex> <<"foo" :: utf16>>
-      <<0,102,0,111,0,111>>
+  Sizes for types are a bit more nuanced. The default size for integers is 8.
 
-  The bits type is an alias for bitstring. The bytes type is an
-  alias for binary.
+  For floats, it is 64. For floats, `size * unit` must result in 16, 32, or 64,
+  corresponding to [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point)
+  binary16, binary32, and binary64, respectively.
 
-  The signedness can also be given as signed or unsigned. The
-  signedness only matters for matching and relevant only for
-  integers. If unspecified, it defaults to unsigned. Example:
+  For binaries, the default is the size of the binary. Only the last binary in a
+  match can use the default size. All others must have their size specified
+  explicitly, even if the match is unambiguous. For example:
 
-      iex> <<-100 :: signed, _rest :: binary>> = <<-100, "foo">>
-      <<156,102,111,111>>
+      iex> <<name::binary-size(5), " the ", species::binary>> = <<"Frank the Walrus">>
+      "Frank the Walrus"
+      iex> {name, species}
+      {"Frank", "Walrus"}
 
-  This match would have failed if we did not specify that the
-  value -100 is signed. If we're matching into a variable instead
-  of a value, the signedness won't be checked; rather, the number
-  will simply be interpreted as having the given (or implied)
-  signedness, e.g.:
+  The size can be a variable or any valid guard expression:
 
-      iex> <<val, _rest :: binary>> = <<-100, "foo">>
-      iex> val
-      156
+      iex> name_size = 5
+      iex> <<name::binary-size(^name_size), " the ", species::binary>> = <<"Frank the Walrus">>
+      iex> {name, species}
+      {"Frank", "Walrus"}
 
-  Here, `val` is interpreted as unsigned.
+  The size can access prior variables defined in the binary itself:
 
-  The endianness of a segment can be big, little or native (the
-  latter meaning it will be resolved at VM load time). Passing
-  many options can be done by giving a list:
+      iex> <<name_size::size(8), name::binary-size(name_size), " the ", species::binary>> = <<5, "Frank the Walrus">>
+      iex> {name, species}
+      {"Frank", "Walrus"}
 
-      <<102 :: [integer, native], rest :: binary>>
+  However, it cannot access variables defined in the match outside of the binary/bitstring:
 
-  Or:
+      {name_size, <<name::binary-size(name_size), _rest::binary>>} = {5, <<"Frank the Walrus">>}
+      ** (CompileError): undefined variable "name_size" in bitstring segment
 
-      <<102 :: [unsigned, big, integer], rest :: binary>>
+  Failing to specify the size for the non-last causes compilation to fail:
 
-  And so on.
+      <<name::binary, " the ", species::binary>> = <<"Frank the Walrus">>
+      ** (CompileError): a binary field without size is only allowed at the end of a binary pattern
 
-  Endianness only makes sense for integers and some UTF code
-  point types (utf16 and utf32).
+  #### Shortcut Syntax
 
-  Finally, we can also specify size and unit for each segment. The
-  unit is multiplied by the size to give the effective size of
-  the segment in bits. The default unit for integers, floats,
-  and bitstrings is 1. For binaries, it is 8.
+  Size and unit can also be specified using a syntax shortcut
+  when passing integer values:
 
-  Since integers are default, the default unit is 1. The example below
-  matches because the string "foo" takes 24 bits and we match it
-  against a segment of 24 bits, 8 of which are taken by the integer
-  102 and the remaining 16 bits are specified on the rest.
+      iex> x = 1
+      iex> <<x::8>> == <<x::size(8)>>
+      true
+      iex> <<x::8*4>> == <<x::size(8)-unit(4)>>
+      true
 
-      iex> <<102, _rest :: size(16)>> = "foo"
-      "foo"
+  This syntax reflects the fact the effective size is given by
+  multiplying the size by the unit.
 
-  We can also match by specifying size and unit explicitly:
+  ### Modifiers
 
-      iex> <<102, _rest :: [size(2), unit(8)]>> = "foo"
-      "foo"
+  Some types have associated modifiers to clear up ambiguity in byte
+  representation.
 
-  However, if we expect a size of 32, it won't match:
+  Modifier             | Relevant Type(s)
+  -------------------- | ----------------
+  `signed`             | `integer`
+  `unsigned` (default) | `integer`
+  `little`             | `integer`, `float`, `utf16`, `utf32`
+  `big` (default)      | `integer`, `float`, `utf16`, `utf32`
+  `native`             | `integer`, `float`, `utf16`, `utf32`
 
-      iex> <<102, _rest :: size(32)>> = "foo"
-      ** (MatchError) no match of right hand side value: "foo"
+  ### Sign
 
-  Size and unit are not applicable to utf8, utf16, and utf32.
+  Integers can be `signed` or `unsigned`, defaulting to `unsigned`.
 
-  The default size for integers is 8. For floats, it is 64. For
-  binaries, it is the size of the binary. Only the last binary
-  in a binary match can use the default size (all others must
-  have their size specified explicitly).
+      iex> <<int::integer>> = <<-100>>
+      <<156>>
+      iex> int
+      156
+      iex> <<int::integer-signed>> = <<-100>>
+      <<156>>
+      iex> int
+      -100
 
-  Size can also be specified using a syntax shortcut. Instead of
-  writing `size(8)`, one can write just `8` and it will be interpreted
-  as `size(8)`
+  `signed` and `unsigned` are only used for matching binaries (see below) and
+  are only used for integers.
 
-      iex> << 1 :: 3 >> == << 1 :: size(3) >>
-      true
+      iex> <<-100::signed, _rest::binary>> = <<-100, "foo">>
+      <<156, 102, 111, 111>>
+
+  ### Endianness
+
+  Elixir has three options for endianness: `big`, `little`, and `native`.
+  The default is `big`:
+
+      iex> <<number::little-integer-size(16)>> = <<0, 1>>
+      <<0, 1>>
+      iex> number
+      256
+      iex> <<number::big-integer-size(16)>> = <<0, 1>>
+      <<0, 1>>
+      iex> number
+      1
+
+  `native` is determined by the VM at startup and will depend on the
+  host operating system.
+
+  ## Binary/Bitstring Matching
+
+  Binary matching is a powerful feature in Elixir that is useful for extracting
+  information from binaries as well as pattern matching.
+
+  Binary matching can be used by itself to extract information from binaries:
 
-  For floats, `size * unit` must result in 32 or 64, corresponding
-  to binary32 and binary64, respectively.
+      iex> <<"Hello, ", place::binary>> = "Hello, World"
+      "Hello, World"
+      iex> place
+      "World"
+
+  Or as a part of function definitions to pattern match:
+
+      defmodule ImageType do
+        @png_signature <<137::size(8), 80::size(8), 78::size(8), 71::size(8),
+                         13::size(8), 10::size(8), 26::size(8), 10::size(8)>>
+        @jpg_signature <<255::size(8), 216::size(8)>>
+
+        def type(<<@png_signature, _rest::binary>>), do: :png
+        def type(<<@jpg_signature, _rest::binary>>), do: :jpg
+        def type(_), do: :unknown
+      end
+
+  ### Performance & Optimizations
+
+  The Erlang compiler can provide a number of optimizations on binary creation
+  and matching. To see optimization output, set the `bin_opt_info` compiler
+  option:
+
+      ERL_COMPILER_OPTIONS=bin_opt_info mix compile
+
+  To learn more about specific optimizations and performance considerations,
+  check out the
+  ["Constructing and matching binaries" chapter of the Erlang's Efficiency Guide](https://www.erlang.org/doc/efficiency_guide/binaryhandling.html).
   """
-  defmacro unquote(:<<>>)(args)
+  defmacro unquote(:<<>>)(args), do: error!([args])
 
   @doc """
-  Defines a remote call or an alias.
+  Dot operator. Defines a remote call, a call to an anonymous function, or an alias.
 
   The dot (`.`) in Elixir can be used for remote calls:
 
@@ -307,8 +375,16 @@ defmodule Kernel.SpecialForms do
       "foo"
 
   In this example above, we have used `.` to invoke `downcase` in the
-  `String` alias, passing "FOO" as argument. We can also use the dot
-  for creating aliases:
+  `String` module, passing `"FOO"` as argument.
+
+  The dot may be used to invoke anonymous functions too:
+
+      iex> (fn n -> n end).(7)
+      7
+
+  in which case there is a function on the left hand side.
+
+  We can also use the dot for creating aliases:
 
       iex> Hello.World
       Hello.World
@@ -318,7 +394,7 @@ defmodule Kernel.SpecialForms do
 
   ## Syntax
 
-  The right side of `.` may be a word starting in upcase, which represents
+  The right side of `.` may be a word starting with an uppercase letter, which represents
   an alias, a word starting with lowercase or underscore, any valid language
   operator or any name wrapped in single- or double-quotes. Those are all valid
   examples:
@@ -326,41 +402,26 @@ defmodule Kernel.SpecialForms do
       iex> Kernel.Sample
       Kernel.Sample
 
-      iex> Kernel.length([1,2,3])
+      iex> Kernel.length([1, 2, 3])
       3
 
       iex> Kernel.+(1, 2)
       3
 
-      iex> Kernel."length"([1,2,3])
+      iex> Kernel."+"(1, 2)
       3
 
-      iex> Kernel.'+'(1, 2)
-      3
-
-  Note that `Kernel."HELLO"` will be treated as a remote call and not an alias.
-  This choice was done so every time single- or double-quotes are used, we have
-  a remote call irregardless of the quote contents. This decision is also reflected
-  in the quoted expressions discussed below.
+  Wrapping the function name in single- or double-quotes is always a
+  remote call. Therefore `Kernel."Foo"` will attempt to call the function "Foo"
+  and not return the alias `Kernel.Foo`. This is done by design as module names
+  are more strict than function names.
 
-  ## Runtime (dynamic) behaviour
+  When the dot is used to invoke an anonymous function there is only one
+  operand, but it is still written using a postfix notation:
 
-  The result returned by `.` is always specified by the right-side:
-
-      iex> x = String
-      iex> x.downcase("FOO")
-      "foo"
-      iex> x.Sample
-      String.Sample
-
-  In case the right-side is also dynamic, `.`'s behaviour can be reproduced
-  at runtime via `apply/3` and `Module.concat/2`:
-
-      iex> apply(:erlang, :+, [1,2])
-      3
-
-      iex> Module.concat(Kernel, Sample)
-      Kernel.Sample
+      iex> negate = fn n -> -n end
+      iex> negate.(7)
+      -7
 
   ## Quoted expression
 
@@ -368,32 +429,39 @@ defmodule Kernel.SpecialForms do
   forms. When the right side starts with a lowercase letter (or
   underscore):
 
-      iex> quote do: String.downcase("FOO")
+      iex> quote do
+      ...>   String.downcase("FOO")
+      ...> end
       {{:., [], [{:__aliases__, [alias: false], [:String]}, :downcase]}, [], ["FOO"]}
 
-  Notice we have an inner tuple, containing the atom `:.` representing
+  Note that we have an inner tuple, containing the atom `:.` representing
   the dot as first element:
 
       {:., [], [{:__aliases__, [alias: false], [:String]}, :downcase]}
 
   This tuple follows the general quoted expression structure in Elixir,
   with the name as first argument, some keyword list as metadata as second,
-  and the number of arguments as third. In this case, the arguments is the
-  alias `String` and the atom `:downcase`. The second argument is **always**
-  an atom:
+  and the list of arguments as third. In this case, the arguments are the
+  alias `String` and the atom `:downcase`. The second argument in a remote call
+  is **always** an atom.
 
-      iex> quote do: String."downcase"("FOO")
-      {{:., [], [{:__aliases__, [alias: false], [:String]}, :downcase]}, [], ["FOO"]}
+  In the case of calls to anonymous functions, the inner tuple with the dot
+  special form has only one argument, reflecting the fact that the operator is
+  unary:
 
-  The tuple containing `:.` is wrapped in another tuple, which actually
-  represents the function call, and has `"FOO"` as argument.
+      iex> quote do
+      ...>   negate.(0)
+      ...> end
+      {{:., [], [{:negate, [], __MODULE__}]}, [], [0]}
 
   When the right side is an alias (i.e. starts with uppercase), we get instead:
 
-      iex> quote do: Hello.World
+      iex> quote do
+      ...>   Hello.World
+      ...> end
       {:__aliases__, [alias: false], [:Hello, :World]}
 
-  We got into more details about aliases in the `__aliases__` special form
+  We go into more details about aliases in the `__aliases__/1` special form
   documentation.
 
   ## Unquoting
@@ -401,27 +469,31 @@ defmodule Kernel.SpecialForms do
   We can also use unquote to generate a remote call in a quoted expression:
 
       iex> x = :downcase
-      iex> quote do: String.unquote(x)("FOO")
+      iex> quote do
+      ...>   String.unquote(x)("FOO")
+      ...> end
       {{:., [], [{:__aliases__, [alias: false], [:String]}, :downcase]}, [], ["FOO"]}
 
-  Similar to `Kernel."HELLO"`, `unquote(x)` will always generate a remote call,
+  Similar to `Kernel."FUNCTION_NAME"`, `unquote(x)` will always generate a remote call,
   independent of the value of `x`. To generate an alias via the quoted expression,
   one needs to rely on `Module.concat/2`:
 
       iex> x = Sample
-      iex> quote do: Module.concat(String, unquote(x))
+      iex> quote do
+      ...>   Module.concat(String, unquote(x))
+      ...> end
       {{:., [], [{:__aliases__, [alias: false], [:Module]}, :concat]}, [],
        [{:__aliases__, [alias: false], [:String]}, Sample]}
 
   """
-  defmacro unquote(:.)(left, right)
+  defmacro unquote(:.)(left, right), do: error!([left, right])
 
   @doc """
-  `alias` is used to setup aliases, often useful with modules names.
+  `alias/2` is used to set up aliases, often useful with modules' names.
 
   ## Examples
 
-  `alias` can be used to setup an alias for any module:
+  `alias/2` can be used to set up an alias for any module:
 
       defmodule Math do
         alias MyKeyword, as: Keyword
@@ -434,10 +506,10 @@ defmodule Kernel.SpecialForms do
   In case one wants to access the original `Keyword`, it can be done
   by accessing `Elixir`:
 
-      Keyword.values   #=> uses MyKeyword.values
+      Keyword.values #=> uses MyKeyword.values
       Elixir.Keyword.values #=> uses Keyword.values
 
-  Notice that calling `alias` without the `as:` option automatically
+  Note that calling `alias` without the `:as` option automatically
   sets an alias based on the last part of the module. For example:
 
       alias Foo.Bar.Baz
@@ -446,9 +518,19 @@ defmodule Kernel.SpecialForms do
 
       alias Foo.Bar.Baz, as: Baz
 
+  We can also alias multiple modules in one line:
+
+      alias Foo.{Bar, Baz, Biz}
+
+  Is the same as:
+
+      alias Foo.Bar
+      alias Foo.Baz
+      alias Foo.Biz
+
   ## Lexical scope
 
-  `import`, `require` and `alias` are called directives and all
+  `import/2`, `require/2` and `alias/2` are called directives and all
   have lexical scope. This means you can set up aliases inside
   specific functions and it won't affect the overall scope.
 
@@ -461,21 +543,21 @@ defmodule Kernel.SpecialForms do
   Elixir won't emit any warnings though, since the alias
   was not explicitly defined.
 
-  Both warning behaviours could be changed by explicitly
-  setting the `:warn` option to true or false.
+  Both warning behaviors could be changed by explicitly
+  setting the `:warn` option to `true` or `false`.
+
   """
-  defmacro alias(module, opts)
+  defmacro alias(module, opts), do: error!([module, opts])
 
   @doc """
-  Requires a given module to be compiled and loaded.
+  Requires a module in order to use its macros.
 
   ## Examples
 
-  Notice that usually modules should not be required before usage,
-  the only exception is if you want to use the macros from a module.
-  In such cases, you need to explicitly require them.
+  Public functions in modules are globally available, but in order to use
+  macros, you need to opt-in by requiring the module they are defined in.
 
-  Let's suppose you created your own `if` implementation in the module
+  Let's suppose you created your own `if/2` implementation in the module
   `MyMacros`. If you want to invoke it, you need to first explicitly
   require the `MyMacros`:
 
@@ -488,17 +570,17 @@ defmodule Kernel.SpecialForms do
 
   ## Alias shortcut
 
-  `require` also accepts `as:` as an option so it automatically sets
-  up an alias. Please check `alias` for more information.
+  `require/2` also accepts `:as` as an option so it automatically sets
+  up an alias. Please check `alias/2` for more information.
 
   """
-  defmacro require(module, opts)
+  defmacro require(module, opts), do: error!([module, opts])
 
   @doc """
-  Imports function and macros from other modules.
+  Imports functions and macros from other modules.
 
-  `import` allows one to easily access functions or macros from
-  others modules without using the qualified name.
+  `import/2` allows one to easily access functions or macros from
+  other modules without using the qualified name.
 
   ## Examples
 
@@ -508,21 +590,22 @@ defmodule Kernel.SpecialForms do
 
       iex> import List
       iex> flatten([1, [2], 3])
-      [1,2,3]
+      [1, 2, 3]
 
   ## Selector
 
   By default, Elixir imports functions and macros from the given
-  module, except the ones starting with underscore (which are
+  module, except the ones starting with an underscore (which are
   usually callbacks):
 
       import List
 
-  A developer can filter to import only macros or functions via
-  the only option:
+  A developer can filter to import only functions, macros, or sigils
+  (which can be functions or macros) via the `:only` option:
 
       import List, only: :functions
       import List, only: :macros
+      import Kernel, only: :sigils
 
   Alternatively, Elixir allows a developer to pass pairs of
   name/arities to `:only` or `:except` as a fine grained control
@@ -531,26 +614,37 @@ defmodule Kernel.SpecialForms do
       import List, only: [flatten: 1]
       import String, except: [split: 2]
 
-  Notice that calling `except` for a previously declared `import`
-  simply filters the previously imported elements. For example:
+  Importing the same module again will erase the previous imports,
+  except when the `except` option is used, which is always exclusive
+  on a previously declared `import/2`. If there is no previous import,
+  then it applies to all functions and macros in the module. For
+  example:
 
-      import List, only: [flatten: 1, keyfind: 3]
+      import List, only: [flatten: 1, keyfind: 4]
       import List, except: [flatten: 1]
 
-  After the two import calls above, only `List.keyfind/3` will be
+  After the two import calls above, only `List.keyfind/4` will be
   imported.
 
+  ## Underscore functions
+
+  By default functions starting with `_` are not imported. If you really want
+  to import a function starting with `_` you must explicitly include it in the
+  `:only` selector.
+
+      import File.Stream, only: [__build__: 3]
+
   ## Lexical scope
 
-  It is important to notice that `import` is lexical. This means you
+  It is important to note that `import/2` is lexical. This means you
   can import specific macros inside specific functions:
 
       defmodule Math do
         def some_function do
-          # 1) Disable `if/2` from Kernel
+          # 1) Disable "if/2" from Kernel
           import Kernel, except: [if: 2]
 
-          # 2) Require the new `if` macro from MyMacros
+          # 2) Require the new "if/2" macro from MyMacros
           import MyMacros
 
           # 3) Use the new macro
@@ -573,8 +667,8 @@ defmodule Kernel.SpecialForms do
   Elixir won't emit any warnings though, since the import
   was not explicitly defined.
 
-  Both warning behaviours could be changed by explicitly
-  setting the `:warn` option to true or false.
+  Both warning behaviors could be changed by explicitly
+  setting the `:warn` option to `true` or `false`.
 
   ## Ambiguous function/macro names
 
@@ -583,7 +677,7 @@ defmodule Kernel.SpecialForms do
   if an ambiguous call to `foo/1` is actually made; that is, the
   errors are emitted lazily, not eagerly.
   """
-  defmacro import(module, opts)
+  defmacro import(module, opts), do: error!([module, opts])
 
   @doc """
   Returns the current environment information as a `Macro.Env` struct.
@@ -591,23 +685,23 @@ defmodule Kernel.SpecialForms do
   In the environment you can access the current filename,
   line numbers, set up aliases, the current function and others.
   """
-  defmacro __ENV__
+  defmacro __ENV__, do: error!([])
 
   @doc """
   Returns the current module name as an atom or `nil` otherwise.
 
-  Although the module can be accessed in the `__ENV__`, this macro
+  Although the module can be accessed in the `__ENV__/0`, this macro
   is a convenient shortcut.
   """
-  defmacro __MODULE__
+  defmacro __MODULE__, do: error!([])
 
   @doc """
-  Returns the current directory as a binary.
+  Returns the absolute path of the directory of the current file as a binary.
 
   Although the directory can be accessed as `Path.dirname(__ENV__.file)`,
   this macro is a convenient shortcut.
   """
-  defmacro __DIR__
+  defmacro __DIR__, do: error!([])
 
   @doc """
   Returns the current calling environment as a `Macro.Env` struct.
@@ -615,29 +709,43 @@ defmodule Kernel.SpecialForms do
   In the environment you can access the filename, line numbers,
   set up aliases, the function and others.
   """
-  defmacro __CALLER__
+  defmacro __CALLER__, do: error!([])
+
+  @doc """
+  Returns the stacktrace for the currently handled exception.
+
+  It is available only in the `catch` and `rescue` clauses of `try/1`
+  expressions and function definitions.
+
+  To retrieve the stacktrace of the current process, use
+  `Process.info(self(), :current_stacktrace)` instead.
+  """
+  @doc since: "1.7.0"
+  defmacro __STACKTRACE__, do: error!([])
 
   @doc """
-  Accesses an already bound variable in match clauses.
+  Pin operator. Accesses an already bound variable in match clauses.
 
   ## Examples
 
   Elixir allows variables to be rebound via static single assignment:
 
       iex> x = 1
-      iex> x = 2
+      iex> x = x + 1
       iex> x
       2
 
   However, in some situations, it is useful to match against an existing
-  value, instead of rebinding. This can be done with the `^` special form:
+  value, instead of rebinding. This can be done with the `^` special form,
+  colloquially known as the pin operator:
 
       iex> x = 1
       iex> ^x = List.first([1])
       iex> ^x = List.first([2])
-      ** (MatchError) no match of right hand side value: 2
+      ** (MatchError) no match of right hand side value:
+      ...
 
-  Note that `^` always refers to the value of x prior to the match. The
+  Note that `^x` always refers to the value of `x` prior to the match. The
   following example will match:
 
       iex> x = 0
@@ -646,17 +754,45 @@ defmodule Kernel.SpecialForms do
       1
 
   """
-  defmacro ^(var)
+  defmacro ^var, do: error!([var])
+
+  @doc """
+  Match operator. Matches the value on the right against the pattern on the left.
+  """
+  defmacro left = right, do: error!([left, right])
+
+  @doc """
+  Type operator. Used by types and bitstrings to specify types.
+
+  This operator is used in two distinct occasions in Elixir.
+  It is used in typespecs to specify the type of a variable,
+  function or of a type itself:
+
+      @type number :: integer | float
+      @spec add(number, number) :: number
+
+  It may also be used in bit strings to specify the type
+  of a given bit segment:
+
+      <<int::integer-little, rest::bits>> = bits
+
+  Read the documentation on the [Typespecs page](typespecs.md) and
+  `<<>>/1` for more information on typespecs and
+  bitstrings respectively.
+  """
+  defmacro left :: right, do: error!([left, right])
 
   @doc ~S"""
   Gets the representation of any expression.
 
   ## Examples
 
-      quote do: sum(1, 2, 3)
-      #=> {:sum, [], [1, 2, 3]}
+      iex> quote do
+      ...>   sum(1, 2, 3)
+      ...> end
+      {:sum, [], [1, 2, 3]}
 
-  ## Explanation
+  ## Elixir's AST (Abstract Syntax Tree)
 
   Any Elixir code can be represented using Elixir data structures.
   The building block of Elixir macros is a tuple with three elements,
@@ -670,30 +806,15 @@ defmodule Kernel.SpecialForms do
     * The first element of the tuple is always an atom or
       another tuple in the same representation.
 
-    * The second element of the tuple represents metadata.
+    * The second element of the tuple represents [metadata](`t:Macro.metadata/0`).
 
     * The third element of the tuple are the arguments for the
       function call. The third argument may be an atom, which is
       usually a variable (or a local call).
 
-  ## Options
-
-    * `:unquote` - when false, disables unquoting. Useful when you have a quote
-      inside another quote and want to control what quote is able to unquote.
-
-    * `:location` - when set to `:keep`, keeps the current line and file from
-      quote. Read the Stacktrace information section below for more
-      information.
-
-    * `:context` - sets the resolution context.
-
-    * `:bind_quoted` - passes a binding to the macro. Whenever a binding is
-      given, `unquote` is automatically disabled.
-
-  ## Quote literals
-
   Besides the tuple described above, Elixir has a few literals that
-  when quoted return themselves. They are:
+  are also part of its AST. Those literals return themselves when
+  quoted. They are:
 
       :sum         #=> Atoms
       1            #=> Integers
@@ -702,11 +823,46 @@ defmodule Kernel.SpecialForms do
       "strings"    #=> Strings
       {key, value} #=> Tuples with two elements
 
+  Any other value, such as a map or a four-element tuple, must be escaped
+  (`Macro.escape/1`) before being introduced into an AST.
+
+  ## Options
+
+    * `:bind_quoted` - passes a binding to the macro. Whenever a binding is
+      given, `unquote/1` is automatically disabled.
+
+    * `:context` - sets the resolution context.
+
+    * `:generated` - marks the given chunk as generated so it does not emit warnings.
+      It is also useful to prevent the type system or dialyzer from reporting errors
+      when macros generate unused clauses.
+
+    * `:file` - sets the quoted expressions to have the given file.
+
+    * `:line` - sets the quoted expressions to have the given line.
+
+    * `:location` - when set to `:keep`, keeps the current line and file from
+      quote. Read the "Stacktrace information" section below for more information.
+
+    * `:unquote` - when `false`, disables unquoting. This means any `unquote`
+      call will be kept as is in the AST, instead of replaced by the `unquote`
+      arguments. For example:
+
+          iex> quote do
+          ...>   unquote("hello")
+          ...> end
+          "hello"
+
+          iex> quote unquote: false do
+          ...>   unquote("hello")
+          ...> end
+          {:unquote, [], ["hello"]}
+
   ## Quote and macros
 
-  `quote` is commonly used with macros for code generation. As an exercise,
-  let's define a macro that multiplies a number by itself (squared). Note
-  there is no reason to define such as a macro (and it would actually be
+  `quote/2` is commonly used with macros for code generation. As an exercise,
+  let's define a macro that multiplies a number by itself (squared). In practice,
+  there is no reason to define such a macro (and it would actually be
   seen as a bad practice), but it is simple enough that it allows us to focus
   on the important aspects of quotes and macros:
 
@@ -721,26 +877,26 @@ defmodule Kernel.SpecialForms do
   We can invoke it as:
 
       import Math
-      IO.puts "Got #{squared(5)}"
+      IO.puts("Got #{squared(5)}")
 
   At first, there is nothing in this example that actually reveals it is a
   macro. But what is happening is that, at compilation time, `squared(5)`
   becomes `5 * 5`. The argument `5` is duplicated in the produced code, we
-  can see this behaviour in practice though because our macro actually has
+  can see this behavior in practice though because our macro actually has
   a bug:
 
       import Math
       my_number = fn ->
-        IO.puts "Returning 5"
+        IO.puts("Returning 5")
         5
       end
-      IO.puts "Got #{squared(my_number.())}"
+      IO.puts("Got #{squared(my_number.())}")
 
   The example above will print:
 
       Returning 5
       Returning 5
-      25
+      Got 25
 
   Notice how "Returning 5" was printed twice, instead of just once. This is
   because a macro receives an expression and not a value (which is what we
@@ -753,7 +909,7 @@ defmodule Kernel.SpecialForms do
       my_number.() * my_number.()
 
   Which invokes the function twice, explaining why we get the printed value
-  twice! In the majority of the cases, this is actually unexpected behaviour,
+  twice! In the majority of the cases, this is actually unexpected behavior,
   and that's why one of the first things you need to keep in mind when it
   comes to macros is to **not unquote the same value more than once**.
 
@@ -768,11 +924,11 @@ defmodule Kernel.SpecialForms do
         end
       end
 
-  Now invoking `square(my_number.())` as before will print the value just
+  Now invoking `squared(my_number.())` as before will print the value just
   once.
 
   In fact, this pattern is so common that most of the times you will want
-  to use the `bind_quoted` option with `quote`:
+  to use the `bind_quoted` option with `quote/2`:
 
       defmodule Math do
         defmacro squared(x) do
@@ -784,7 +940,7 @@ defmodule Kernel.SpecialForms do
 
   `:bind_quoted` will translate to the same code as the example above.
   `:bind_quoted` can be used in many cases and is seen as good practice,
-  not only because it helps us from running into common mistakes but also
+  not only because it helps prevent us from running into common mistakes, but also
   because it allows us to leverage other tools exposed by macros, such as
   unquote fragments discussed in some sections below.
 
@@ -800,7 +956,8 @@ defmodule Kernel.SpecialForms do
 
       import Math
       squared(5)
-      x #=> ** (RuntimeError) undefined function or variable: x
+      x
+      ** (CompileError) undefined variable "x"
 
   We can see that `x` did not leak to the user context. This happens
   because Elixir macros are hygienic, a topic we will discuss at length
@@ -812,36 +969,42 @@ defmodule Kernel.SpecialForms do
 
       defmodule Hygiene do
         defmacro no_interference do
-          quote do: a = 1
+          quote do
+            a = 1
+          end
         end
       end
 
       require Hygiene
 
       a = 10
-      Hygiene.no_interference
-      a #=> 10
+      Hygiene.no_interference()
+      a
+      #=> 10
 
   In the example above, `a` returns 10 even if the macro
   is apparently setting it to 1 because variables defined
-  in the macro does not affect the context the macro is executed in.
+  in the macro do not affect the context the macro is executed in.
   If you want to set or get a variable in the caller's context, you
   can do it with the help of the `var!` macro:
 
       defmodule NoHygiene do
         defmacro interference do
-          quote do: var!(a) = 1
+          quote do
+            var!(a) = 1
+          end
         end
       end
 
       require NoHygiene
 
       a = 10
-      NoHygiene.interference
-      a #=> 1
+      NoHygiene.interference()
+      a
+      #=> 1
 
-  Note that you cannot even access variables defined in the same
-  module unless you explicitly give it a context:
+  You cannot even access variables defined in the same module unless
+  you explicitly give it a context:
 
       defmodule Hygiene do
         defmacro write do
@@ -857,9 +1020,10 @@ defmodule Kernel.SpecialForms do
         end
       end
 
-      Hygiene.write
-      Hygiene.read
-      #=> ** (RuntimeError) undefined function or variable: a
+      require Hygiene
+      Hygiene.write()
+      Hygiene.read()
+      ** (CompileError) undefined variable "a" (context Hygiene)
 
   For such, you can explicitly pass the current module scope as
   argument:
@@ -878,58 +1042,80 @@ defmodule Kernel.SpecialForms do
         end
       end
 
-      ContextHygiene.write
-      ContextHygiene.read
+      require ContextHygiene
+      ContextHygiene.write()
+      ContextHygiene.read()
       #=> 1
 
+  The contexts of a variable is identified by the third element of the tuple.
+  The default context is `nil` and `quote` assigns another context to all
+  variables within:
+
+      quote(do: var)
+      #=> {:var, [], Elixir}
+
+  In case of variables returned by macros, there may also be a `:counter` key
+  in the metadata, which is used to further refine its contexts and guarantee
+  isolation between macro invocations as seen in the previous example.
+
   ## Hygiene in aliases
 
   Aliases inside quote are hygienic by default.
   Consider the following example:
 
       defmodule Hygiene do
-        alias HashDict, as: D
+        alias Map, as: M
 
         defmacro no_interference do
-          quote do: D.new
+          quote do
+            M.new()
+          end
         end
       end
 
       require Hygiene
-      Hygiene.no_interference #=> #HashDict<[]>
+      Hygiene.no_interference()
+      #=> %{}
 
-  Notice that, even though the alias `D` is not available
+  Note that, even though the alias `M` is not available
   in the context the macro is expanded, the code above works
-  because `D` still expands to `HashDict`.
+  because `M` still expands to `Map`.
 
   Similarly, even if we defined an alias with the same name
   before invoking a macro, it won't affect the macro's result:
 
       defmodule Hygiene do
-        alias HashDict, as: D
+        alias Map, as: M
 
         defmacro no_interference do
-          quote do: D.new
+          quote do
+            M.new()
+          end
         end
       end
 
       require Hygiene
-      alias SomethingElse, as: D
-      Hygiene.no_interference #=> #HashDict<[]>
+      alias SomethingElse, as: M
+      Hygiene.no_interference()
+      #=> %{}
 
   In some cases, you want to access an alias or a module defined
   in the caller. For such, you can use the `alias!` macro:
 
       defmodule Hygiene do
-        # This will expand to Elixir.Nested.hello
+        # This will expand to Elixir.Nested.hello()
         defmacro no_interference do
-          quote do: Nested.hello
+          quote do
+            Nested.hello()
+          end
         end
 
-        # This will expand to Nested.hello for
+        # This will expand to Nested.hello() for
         # whatever is Nested in the caller
         defmacro interference do
-          quote do: alias!(Nested).hello
+          quote do
+            alias!(Nested).hello()
+          end
         end
       end
 
@@ -939,10 +1125,10 @@ defmodule Kernel.SpecialForms do
         end
 
         require Hygiene
-        Hygiene.no_interference
-        #=> ** (UndefinedFunctionError) ...
+        Hygiene.no_interference()
+        ** (UndefinedFunctionError) ...
 
-        Hygiene.interference
+        Hygiene.interference()
         #=> "world"
       end
 
@@ -952,54 +1138,56 @@ defmodule Kernel.SpecialForms do
   following code:
 
       defmodule Hygiene do
-        defmacrop get_size do
+        defmacrop get_length do
           quote do
-            size("hello")
+            length([1, 2, 3])
           end
         end
 
-        def return_size do
-          import Kernel, except: [size: 1]
-          get_size
+        def return_length do
+          import Kernel, except: [length: 1]
+          get_length
         end
       end
 
-      Hygiene.return_size #=> 5
+      Hygiene.return_length()
+      #=> 3
 
-  Notice how `return_size` returns 5 even though the `size/1`
-  function is not imported. In fact, even if `return_size` imported
-  a function from another module, it wouldn't affect the function
-  result:
+  Notice how `Hygiene.return_length/0` returns `3` even though the `Kernel.length/1`
+  function is not imported. In fact, even if `return_length/0`
+  imported a function with the same name and arity from another
+  module, it wouldn't affect the function result:
 
-      def return_size do
-        import Dict, only: [size: 1]
-        get_size
+      def return_length do
+        import String, only: [length: 1]
+        get_length
       end
 
-  Calling this new `return_size` will still return 5 as result.
+  Calling this new `return_length/0` will still return `3` as result.
 
   Elixir is smart enough to delay the resolution to the latest
-  moment possible. So, if you call `size("hello")` inside quote,
-  but no `size/1` function is available, it is then expanded in
+  possible moment. So, if you call `length([1, 2, 3])` inside quote,
+  but no `length/1` function is available, it is then expanded in
   the caller:
 
       defmodule Lazy do
-        defmacrop get_size do
-          import Kernel, except: [size: 1]
+        defmacrop get_length do
+          import Kernel, except: [length: 1]
 
           quote do
-            size([a: 1, b: 2])
+            length("hello")
           end
         end
 
-        def return_size do
-          import Kernel, except: [size: 1]
-          import Dict, only: [size: 1]
-          get_size
+        def return_length do
+          import Kernel, except: [length: 1]
+          import String, only: [length: 1]
+          get_length
         end
       end
 
-      Lazy.return_size #=> 2
+      Lazy.return_length()
+      #=> 5
 
   ## Stacktrace information
 
@@ -1023,33 +1211,49 @@ defmodule Kernel.SpecialForms do
         defadd
       end
 
+      require Sample
+      Sample.add(:one, :two)
+      ** (ArithmeticError) bad argument in arithmetic expression
+          adder.ex:5: Sample.add/2
+
   When using `location: :keep` and invalid arguments are given to
   `Sample.add/2`, the stacktrace information will point to the file
   and line inside the quote. Without `location: :keep`, the error is
-  reported to where `defadd` was invoked. Note `location: :keep` affects
+  reported to where `defadd` was invoked. `location: :keep` affects
   only definitions inside the quote.
 
+  > #### `location: :keep` and unquote {: .warning}
+  >
+  > Do not use `location: :keep` if the function definition
+  > also `unquote`s some of the macro arguments. If you do so, Elixir
+  > will store the file definition of the current location but the
+  > unquoted arguments may contain line information of the macro caller,
+  > leading to erroneous stacktraces.
+
   ## Binding and unquote fragments
 
-  Elixir quote/unquote mechanisms provides a functionality called
+  Elixir quote/unquote mechanisms provide a functionality called
   unquote fragments. Unquote fragments provide an easy way to generate
   functions on the fly. Consider this example:
 
       kv = [foo: 1, bar: 2]
-      Enum.each kv, fn {k, v} ->
+      Enum.each(kv, fn {k, v} ->
         def unquote(k)(), do: unquote(v)
-      end
+      end)
 
   In the example above, we have generated the functions `foo/0` and
-  `bar/0` dynamically. Now, imagine that, we want to convert this
-  functionality into a macro:
+  `bar/0` dynamically. Note the parentheses in `unquote(k)()` are important,
+  otherwise we would try to define a function as `def :foo` instead of
+  `def foo()`.
+
+  Now, imagine that we want to convert this functionality into a macro:
 
       defmacro defkv(kv) do
-        Enum.map kv, fn {k, v} ->
+        Enum.map(kv, fn {k, v} ->
           quote do
             def unquote(k)(), do: unquote(v)
           end
-        end
+        end)
       end
 
   We can invoke this macro as:
@@ -1067,22 +1271,24 @@ defmodule Kernel.SpecialForms do
   code fails.
 
   This is actually a common pitfall when developing macros. We are
-  assuming a particular shape in the macro. We can work around it
-  by unquoting the variable inside the quoted expression:
+  assuming a particular shape at compilation time, within the macro
+  implementation. One may try to work around it by unquoting the
+  variable inside the quoted expression:
 
       defmacro defkv(kv) do
         quote do
-          Enum.each unquote(kv), fn {k, v} ->
+          Enum.each(unquote(kv), fn {k, v} ->
             def unquote(k)(), do: unquote(v)
-          end
+          end)
         end
       end
 
   If you try to run our new macro, you will notice it won't
   even compile, complaining that the variables `k` and `v`
-  does not exist. This is because of the ambiguity: `unquote(k)`
-  can either be an unquote fragment, as previously, or a regular
-  unquote as in `unquote(kv)`.
+  do not exist. This is because the two `unquote`s in the call
+  above are meant to run at distinct moments: `unquote(kv)`
+  applies to the immediate quote, `unquote(k)` is an unquote
+  fragment.
 
   One solution to this problem is to disable unquoting in the
   macro, however, doing that would make it impossible to inject the
@@ -1093,54 +1299,98 @@ defmodule Kernel.SpecialForms do
 
       defmacro defkv(kv) do
         quote bind_quoted: [kv: kv] do
-          Enum.each kv, fn {k, v} ->
+          Enum.each(kv, fn {k, v} ->
             def unquote(k)(), do: unquote(v)
-          end
+          end)
         end
       end
 
   In fact, the `:bind_quoted` option is recommended every time
   one desires to inject a value into the quote.
   """
-  defmacro quote(opts, block)
+  defmacro quote(opts, block), do: error!([opts, block])
 
   @doc """
-  Unquotes the given expression from inside a macro.
+  Unquotes the given expression inside a quoted expression.
+
+  This function expects a valid Elixir AST, also known as
+  quoted expression, as argument. If you would like to `unquote`
+  any value, such as a map or a four-element tuple, you should
+  call `Macro.escape/1` before unquoting.
 
   ## Examples
 
-  Imagine the situation you have a variable `name` and
+  Imagine the situation you have a quoted expression and
   you want to inject it inside some quote. The first attempt
   would be:
 
-      value = 13
-      quote do: sum(1, value, 3)
+      value =
+        quote do
+          13
+        end
+
+      quote do
+        sum(1, value, 3)
+      end
+
+
+  Which the argument for the `:sum` function call is not the
+  expected result:
 
-  Which would then return:
+      {:sum, [], [1, {:value, [], Elixir}, 3]}
 
-      {:sum, [], [1, {:value, [], quoted}, 3]}
+  For this, we use `unquote`:
 
-  Which is not the expected result. For this, we use unquote:
+      iex> value =
+      ...>   quote do
+      ...>     13
+      ...>   end
+      iex> quote do
+      ...>   sum(1, unquote(value), 3)
+      ...> end
+      {:sum, [], [1, 13, 3]}
+
+  If you want to unquote a value that is not a quoted expression,
+  such as a map, you need to call `Macro.escape/1` before:
 
-      value = 13
-      quote do: sum(1, unquote(value), 3)
-      #=> {:sum, [], [1, 13, 3]}
+      iex> value = %{foo: :bar}
+      iex> quote do
+      ...>   process_map(unquote(Macro.escape(value)))
+      ...> end
+      {:process_map, [], [{:%{}, [], [foo: :bar]}]}
 
+  If you forget to escape it, Elixir will raise an error
+  when compiling the code.
   """
-  defmacro unquote(:unquote)(expr)
+  defmacro unquote(:unquote)(expr), do: error!([expr])
 
   @doc """
-  Unquotes the given list expanding its arguments. Similar
-  to unquote.
+  Unquotes the given list expanding its arguments.
+
+  Similar to `unquote/1`.
 
   ## Examples
 
-      values = [2, 3, 4]
-      quote do: sum(1, unquote_splicing(values), 5)
-      #=> {:sum, [], [1, 2, 3, 4, 5]}
+      iex> values = [2, 3, 4]
+      iex> quote do
+      ...>   sum(1, unquote_splicing(values), 5)
+      ...> end
+      {:sum, [], [1, 2, 3, 4, 5]}
+
+  Also can be used in block context, outside of function arguments.
+  Though, it is still required to be wrapped into parentheses.
+
+      iex> requires = for module <- [Integer, Logger] do
+      ...>   quote do
+      ...>     require unquote(module)
+      ...>   end
+      ...> end
+      iex> block = quote do: (unquote_splicing(requires))
+      iex> Macro.to_string(block)
+      "require Integer\\nrequire Logger"
 
   """
-  defmacro unquote(:unquote_splicing)(expr)
+  defmacro unquote(:unquote_splicing)(expr), do: error!([expr])
 
   @doc ~S"""
   Comprehensions allow you to quickly build a data structure from
@@ -1151,15 +1401,17 @@ defmodule Kernel.SpecialForms do
       iex> for n <- [1, 2, 3, 4], do: n * 2
       [2, 4, 6, 8]
 
-  A comprehension accepts many generators and filters. Enumerable
-  generators are defined using `<-`:
+  A comprehension accepts many generators and filters. `for` uses
+  the `<-` operator to extract values from the enumerable on its
+  right side and match them against the pattern on the left.
+  We call them generators:
 
       # A list generator:
       iex> for n <- [1, 2, 3, 4], do: n * 2
       [2, 4, 6, 8]
 
       # A comprehension with two generators
-      iex> for x <- [1, 2], y <- [2, 3], do: x*y
+      iex> for x <- [1, 2], y <- [2, 3], do: x * y
       [2, 3, 4, 6]
 
   Filters can also be given:
@@ -1168,26 +1420,60 @@ defmodule Kernel.SpecialForms do
       iex> for n <- [1, 2, 3, 4, 5, 6], rem(n, 2) == 0, do: n
       [2, 4, 6]
 
-  Note generators can also be used to filter as it removes any value
-  that doesn't match the left side of `<-`:
+  Filters must evaluate to truthy values (everything but `nil`
+  and `false`). If a filter is falsy, then the current value is
+  discarded.
+
+  Generators can also be used to filter as it removes any value
+  that doesn't match the pattern on the left side of `<-`:
 
-      iex> for {:user, name} <- [user: "jose", admin: "john", user: "eric"] do
+      iex> users = [user: "john", admin: "meg", guest: "barbara"]
+      iex> for {type, name} when type != :guest <- users do
       ...>   String.upcase(name)
       ...> end
-      ["JOSE", "ERIC"]
+      ["JOHN", "MEG"]
 
   Bitstring generators are also supported and are very useful when you
   need to organize bitstring streams:
 
       iex> pixels = <<213, 45, 132, 64, 76, 32, 76, 0, 0, 234, 32, 15>>
-      iex> for <<r::8, g::8, b::8 <- pixels >>, do: {r, g, b}
-      [{213,45,132},{64,76,32},{76,0,0},{234,32,15}]
+      iex> for <<r::8, g::8, b::8 <- pixels>>, do: {r, g, b}
+      [{213, 45, 132}, {64, 76, 32}, {76, 0, 0}, {234, 32, 15}]
 
   Variable assignments inside the comprehension, be it in generators,
   filters or inside the block, are not reflected outside of the
   comprehension.
 
-  ## Into
+  Variable assignments inside filters must still return a truthy value,
+  otherwise values are discarded. Let's see an example. Imagine you have
+  a keyword list where the key is a programming language and the value
+  is its direct parent. Then let's try to compute the grandparent of each
+  language. You could try this:
+
+      iex> languages = [elixir: :erlang, erlang: :prolog, prolog: nil]
+      iex> for {language, parent} <- languages, grandparent = languages[parent], do: {language, grandparent}
+      [elixir: :prolog]
+
+  Given the grandparents of Erlang and Prolog were nil, those values were
+  filtered out. If you don't want this behavior, a simple option is to
+  move the filter inside the do-block:
+
+      iex> languages = [elixir: :erlang, erlang: :prolog, prolog: nil]
+      iex> for {language, parent} <- languages do
+      ...>   grandparent = languages[parent]
+      ...>   {language, grandparent}
+      ...> end
+      [elixir: :prolog, erlang: nil, prolog: nil]
+
+  However, such option is not always available, as you may have further
+  filters. An alternative is to convert the filter into a generator by
+  wrapping the right side of `=` in a list:
+
+      iex> languages = [elixir: :erlang, erlang: :prolog, prolog: nil]
+      iex> for {language, parent} <- languages, grandparent <- [languages[parent]], do: {language, grandparent}
+      [elixir: :prolog, erlang: nil, prolog: nil]
+
+  ## The `:into` and `:uniq` options
 
   In the examples above, the result returned by the comprehension was
   always a list. The returned result can be configured by passing an
@@ -1203,24 +1489,266 @@ defmodule Kernel.SpecialForms do
   The `IO` module provides streams, that are both `Enumerable` and
   `Collectable`, here is an upcase echo server using comprehensions:
 
-      for line <- IO.stream(:stdio, :line), into: IO.stream(:stdio, :line) do
+      for line <- IO.stream(), into: IO.stream() do
         String.upcase(line)
       end
 
+  Similarly, `uniq: true` can also be given to comprehensions to guarantee
+  the results are only added to the collection if they were not returned
+  before. For example:
+
+      iex> for x <- [1, 1, 2, 3], uniq: true, do: x * 2
+      [2, 4, 6]
+
+      iex> for <<x <- "abcabc">>, uniq: true, into: "", do: <<x - 32>>
+      "ABC"
+
+  ## The `:reduce` option
+
+  *Available since Elixir v1.8*.
+
+  While the `:into` option allows us to customize the comprehension behavior
+  to a given data type, such as putting all of the values inside a map or inside
+  a binary, it is not always enough.
+
+  For example, imagine that you have a binary with letters where you want to
+  count how many times each lowercase letter happens, ignoring all uppercase
+  ones. For instance, for the string `"AbCabCABc"`, we want to return the map
+  `%{"a" => 1, "b" => 2, "c" => 1}`.
+
+  If we were to use `:into`, we would need a data type that computes the
+  frequency of each element it holds. While there is no such data type in
+  Elixir, you could implement one yourself.
+
+  A simpler option would be to use comprehensions for the mapping and
+  filtering of letters, and then we invoke `Enum.reduce/3` to build a map,
+  for example:
+
+      iex> letters = for <<x <- "AbCabCABc">>, x in ?a..?z, do: <<x>>
+      iex> Enum.reduce(letters, %{}, fn x, acc -> Map.update(acc, x, 1, & &1 + 1) end)
+      %{"a" => 1, "b" => 2, "c" => 1}
+
+  While the above is straight-forward, it has the downside of traversing the
+  data at least twice. If you are expecting long strings as inputs, this can
+  be quite expensive.
+
+  Luckily, comprehensions also support the `:reduce` option, which would allow
+  us to fuse both steps above into a single step:
+
+      iex> for <<x <- "AbCabCABc">>, x in ?a..?z, reduce: %{} do
+      ...>   acc -> Map.update(acc, <<x>>, 1, & &1 + 1)
+      ...> end
+      %{"a" => 1, "b" => 2, "c" => 1}
+
+  When the `:reduce` key is given, its value is used as the initial accumulator
+  and the `do` block must be changed to use `->` clauses, where the left side
+  of `->` receives the accumulated value of the previous iteration and the
+  expression on the right side must return the new accumulator value. Once there are no more
+  elements, the final accumulated value is returned. If there are no elements
+  at all, then the initial accumulator value is returned.
   """
-  defmacro for(args)
+  defmacro for(args), do: error!([args])
+
+  @doc """
+  Combine matching clauses.
+
+  One of the ways to understand `with` is to show which code
+  patterns it improves. Imagine you have a map where the fields
+  `width` and `height` are optional and you want to compute its
+  area, as `{:ok, area}` or return `:error`. We could implement
+  this function as:
+
+      def area(opts) do
+        case Map.fetch(opts, :width) do
+          {:ok, width} ->
+            case Map.fetch(opts, :height) do
+              {:ok, height} -> {:ok, width * height}
+              :error -> :error
+            end
+
+          :error ->
+            :error
+        end
+      end
+
+  when called as `area(%{width: 10, height: 15})`, it should return
+  `{:ok, 150}`. If any of the fields are missing, it returns `:error`.
+
+  While the code above works, it is quite verbose. Using `with`,
+  we could rewrite it as:
+
+      def area(opts) do
+        with {:ok, width} <- Map.fetch(opts, :width),
+             {:ok, height} <- Map.fetch(opts, :height) do
+          {:ok, width * height}
+        end
+      end
+
+  Instead of defining nested `case`s with clauses, we use `with`
+  alongside the `PATTERN <- EXPRESSION` operator to match
+  expressions on its right side against the pattern on the left.
+  Consider `<-` as a sibling to `=`, except that, while `=` raises
+  in case of not matches, `<-` will simply abort the `with` chain
+  and return the non-matched value.
+
+  Let's give it a try on IEx:
+
+      iex> opts = %{width: 10, height: 15}
+      iex> with {:ok, width} <- Map.fetch(opts, :width),
+      ...>      {:ok, height} <- Map.fetch(opts, :height) do
+      ...>   {:ok, width * height}
+      ...> end
+      {:ok, 150}
+
+  If all clauses match, the `do` block is executed, returning its result.
+  Otherwise the chain is aborted and the non-matched value is returned:
+
+      iex> opts = %{width: 10}
+      iex> with {:ok, width} <- Map.fetch(opts, :width),
+      ...>      {:ok, height} <- Map.fetch(opts, :height) do
+      ...>   {:ok, width * height}
+      ...> end
+      :error
+
+  Guards can be used in patterns as well:
+
+      iex> users = %{"melany" => "guest", "bob" => :admin}
+      iex> with {:ok, role} when not is_binary(role) <- Map.fetch(users, "bob") do
+      ...>   {:ok, to_string(role)}
+      ...> end
+      {:ok, "admin"}
+
+  As in `for/1`, variables bound inside `with/1` won't be accessible
+  outside of `with/1`.
+
+  Expressions without `<-` may also be used in clauses. For instance,
+  you can perform regular matches with the `=` operator:
+
+      iex> width = nil
+      iex> opts = %{width: 10, height: 15}
+      iex> with {:ok, width} <- Map.fetch(opts, :width),
+      ...>      double_width = width * 2,
+      ...>      {:ok, height} <- Map.fetch(opts, :height) do
+      ...>   {:ok, double_width * height}
+      ...> end
+      {:ok, 300}
+      iex> width
+      nil
+
+  The behavior of any expression in a clause is the same as if it was
+  written outside of `with`. For example, `=` will raise a `MatchError`
+  instead of returning the non-matched value:
+
+      with :foo = :bar, do: :ok
+      ** (MatchError) no match of right hand side value: :bar
+
+  As with any other function or macro call in Elixir, explicit parens can
+  also be used around the arguments before the `do`-`end` block:
+
+      iex> opts = %{width: 10, height: 15}
+      iex> with(
+      ...>   {:ok, width} <- Map.fetch(opts, :width),
+      ...>   {:ok, height} <- Map.fetch(opts, :height)
+      ...> ) do
+      ...>   {:ok, width * height}
+      ...> end
+      {:ok, 150}
+
+  The choice between parens and no parens is a matter of preference.
+
+  ## Else clauses
+
+  An `else` option can be given to modify what is being returned from
+  `with` in the case of a failed match:
+
+      iex> opts = %{width: 10}
+      iex> with {:ok, width} <- Map.fetch(opts, :width),
+      ...>      {:ok, height} <- Map.fetch(opts, :height) do
+      ...>   {:ok, width * height}
+      ...> else
+      ...>   :error ->
+      ...>     {:error, :wrong_data}
+      ...>
+      ...>   _other_error ->
+      ...>     :unexpected_error
+      ...> end
+      {:error, :wrong_data}
+
+  The `else` block works like a `case`: it can have multiple clauses,
+  and the first match will be used. Variables bound inside `with` (such as
+  `width` in this example) are not available in the `else` block.
+
+  If an `else` block is used and there are no matching clauses, a `WithClauseError`
+  exception is raised.
+
+  ### Beware!
+
+  Keep in mind that, one of potential drawback of `with` is that all
+  failure clauses are flattened into a single `else` block. For example,
+  take this code that checks if a given path points to an Elixir file
+  and that it exists before creating a backup copy:
+
+      with ".ex" <- Path.extname(path),
+           true <- File.exists?(path) do
+        backup_path = path <> ".backup"
+        File.cp!(path, backup_path)
+        {:ok, backup_path}
+      else
+        binary when is_binary(binary) ->
+          {:error, :invalid_extension}
+
+        false ->
+          {:error, :missing_file}
+      end
+
+  Note how we are having to reconstruct the result types of `Path.extname/1`
+  and `File.exists?/1` to build error messages. In this case, it is better
+  to refactor the code so each `<-` already return the desired format in case
+  of errors, like this:
+
+      with :ok <- validate_extension(path),
+           :ok <- validate_exists(path) do
+        backup_path = path <> ".backup"
+        File.cp!(path, backup_path)
+        {:ok, backup_path}
+      end
+
+      defp validate_extension(path) do
+        if Path.extname(path) == ".ex", do: :ok, else: {:error, :invalid_extension}
+      end
+
+      defp validate_exists(path) do
+        if File.exists?(path), do: :ok, else: {:error, :missing_file}
+      end
+
+  Note how the code above is better organized and clearer once we
+  make sure each `<-` in `with` returns a normalized format.
+  """
+  defmacro with(args), do: error!([args])
 
   @doc """
   Defines an anonymous function.
 
+  See `Function` for more information.
+
   ## Examples
 
       iex> add = fn a, b -> a + b end
       iex> add.(1, 2)
       3
 
+  Anonymous functions can also have multiple clauses. All clauses
+  should expect the same number of arguments:
+
+      iex> negate = fn
+      ...>   true -> false
+      ...>   false -> true
+      ...> end
+      iex> negate.(false)
+      true
+
   """
-  defmacro unquote(:fn)(clauses)
+  defmacro unquote(:fn)(clauses), do: error!([clauses])
 
   @doc """
   Internal special form for block expressions.
@@ -1229,14 +1757,27 @@ defmodule Kernel.SpecialForms do
   of expressions in Elixir. This special form is private
   and should not be invoked directly:
 
-      iex> quote do: (1; 2; 3)
+      iex> quote do
+      ...>   1
+      ...>   2
+      ...>   3
+      ...> end
       {:__block__, [], [1, 2, 3]}
 
   """
-  defmacro __block__(args)
+  defmacro unquote(:__block__)(args), do: error!([args])
 
   @doc """
-  Captures or creates an anonymous function.
+  Internal special form for cursor position.
+
+  This is the special form used whenever we need to represent
+  the cursor position in Elixir's AST. See `Code.Fragment` for
+  more information.
+  """
+  defmacro unquote(:__cursor__)(args), do: error!([args])
+
+  @doc """
+  Capture operator. Captures or creates an anonymous function.
 
   ## Capture
 
@@ -1258,6 +1799,17 @@ defmodule Kernel.SpecialForms do
 
       &local_function/1
 
+  Note that `&local_function/1` creates a local capture, but
+  `&__MODULE__.local_function/1` or `&imported_function/1` create a remote
+  capture. For more information, refer to the ["Functions" section in the Erlang Reference Manual](https://www.erlang.org/doc/system/eff_guide_functions.html#function-calls).
+
+  Whether a capture is local or remote has implications when using hot code
+  reloading: local captures dispatch to the version of the module that existed
+  at the time they were created, while remote captures dispatch to the current
+  version of the module.
+
+  See also `Function.capture/3`.
+
   ## Anonymous functions
 
   The capture operator can also be used to partially apply
@@ -1269,11 +1821,18 @@ defmodule Kernel.SpecialForms do
       4
 
   In other words, `&(&1 * 2)` is equivalent to `fn x -> x * 2 end`.
-  Another example using a local function:
 
-      iex> fun = &is_atom(&1)
-      iex> fun.(:atom)
-      true
+  We can partially apply a remote function with placeholder:
+
+      iex> take_five = &Enum.take(&1, 5)
+      iex> take_five.(1..10)
+      [1, 2, 3, 4, 5]
+
+  Another example while using an imported or local function:
+
+      iex> first_elem = &elem(&1, 0)
+      iex> first_elem.({0, 1})
+      0
 
   The `&` operator can be used with more complex expressions:
 
@@ -1287,137 +1846,190 @@ defmodule Kernel.SpecialForms do
       iex> fun.(1, 2)
       {1, 2}
 
-      iex> fun = &[&1|&2]
-      iex> fun.(1, 2)
-      [1|2]
+      iex> fun = &[&1 | &2]
+      iex> fun.(1, [2, 3])
+      [1, 2, 3]
 
   The only restrictions when creating anonymous functions is that at
   least one placeholder must be present, i.e. it must contain at least
-  `&1`:
+  `&1`, and that block expressions are not supported:
 
-      # No placeholder fails to compile
-      &var
+      # No placeholder, fails to compile.
+      &(:foo)
 
-      # Block expressions are also not supported
-      &(foo(&1, &2); &3 + &4)
+      # Block expression, fails to compile.
+      &(&1; &2)
 
   """
-  defmacro unquote(:&)(expr)
+  defmacro unquote(:&)(expr), do: error!([expr])
 
   @doc """
   Internal special form to hold aliases information.
 
   It is usually compiled to an atom:
 
-      iex> quote do: Foo.Bar
+      iex> quote do
+      ...>   Foo.Bar
+      ...> end
       {:__aliases__, [alias: false], [:Foo, :Bar]}
 
   Elixir represents `Foo.Bar` as `__aliases__` so calls can be
   unambiguously identified by the operator `:.`. For example:
 
-      iex> quote do: Foo.bar
+      iex> quote do
+      ...>   Foo.bar()
+      ...> end
       {{:., [], [{:__aliases__, [alias: false], [:Foo]}, :bar]}, [], []}
 
   Whenever an expression iterator sees a `:.` as the tuple key,
   it can be sure that it represents a call and the second argument
   in the list is an atom.
 
-  On the other hand, aliases holds some properties:
+  On the other hand, aliases hold some properties:
 
-    1. The head element of aliases can be any term.
+    1. The head element of aliases can be any term that must expand to
+       an atom at compilation time.
 
     2. The tail elements of aliases are guaranteed to always be atoms.
 
-    3. When the head element of aliases is the atom `:Elixir`, no expansion happen.
-
-    4. When the head element of aliases is not an atom, it is expanded at runtime:
-
-           quote do: some_var.Foo
-           {:__aliases__, [], [{:some_var, [], Elixir}, :Foo]}
-
-       Since `some_var` is not available at compilation time, the compiler
-       expands such expression to:
-
-           Module.concat [some_var, Foo]
+    3. When the head element of aliases is the atom `:Elixir`, no expansion happens.
 
   """
-  defmacro __aliases__(args)
+  defmacro unquote(:__aliases__)(args), do: error!([args])
 
   @doc """
-  Calls the overriden function when overriding it with `defoverridable`.
-  See `Kernel.defoverridable` for more information and documentation.
+  Calls the overridden function when overriding it with `Kernel.defoverridable/1`.
+
+  See `Kernel.defoverridable/1` for more information and documentation.
   """
-  defmacro super(args)
+  defmacro super(args), do: error!([args])
 
-  @doc """
+  @doc ~S"""
   Matches the given expression against the given clauses.
 
+  `case/2` relies on pattern matching and guards to choose
+  which clause to execute. If your logic cannot be expressed
+  within patterns and guards, consider using `if/2` or `cond/1`
+  instead.
+
   ## Examples
 
-      case thing do
-        {:selector, i, value} when is_integer(i) ->
-          value
-        value ->
-          value
-      end
+      iex> string_date = "2015-01-23"
+      iex> case Date.from_iso8601(string_date) do
+      ...>   {:ok, date} -> date
+      ...>   {:error, _reason} -> Date.utc_today()
+      ...> end
+      ~D[2015-01-23]
+
+  In the example above, we match the result of `Date.from_iso8601/1`
+  against each clause "head" and execute the clause "body"
+  corresponding to the first clause that matches. In our case
+  `string_date` contains a string with a valid ISO 8601 representation
+  of date. The function returns `{:ok, ~D[2015-01-23]}`, so the
+  `{:ok, date}` clause is matched.
+
+  If no clause matches, an error is raised. For this reason,
+  it may be necessary to add a final catch-all clause (like `_`)
+  which will always match.
+
+      iex> x = 10
+      iex> case x do
+      ...>   0 -> "This clause won't match"
+      ...>   _ -> "This clause would match any value (x = #{x})"
+      ...> end
+      "This clause would match any value (x = 10)"
 
-  In the example above, we match `thing` against each clause "head"
-  and execute the clause "body" corresponding to the first clause
-  that matches. If no clause matches, an error is raised.
+  If you find yourself nesting `case` expressions inside
+  `case` expressions, consider using `with/1`.
 
-  ## Variables handling
+  ## Variable handling
 
-  Notice that variables bound in a clause "head" do not leak to the
-  outer context:
+  Note that variables bound in a clause do not leak to the outer context:
 
-      case data do
-        {:ok, value} -> value
-        :error -> nil
-      end
+      iex> case {:ok, 7} do
+      ...>   {:ok, value} -> value
+      ...>   :error -> nil
+      ...> end
 
-      value #=> unbound variable value
+      ...> value
+      ** (CompileError) undefined variable "value"
 
-  However, variables explicitly bound in the clause "body" are
-  accessible from the outer context:
+  Variables in the outer context cannot be overridden either:
 
-      value = 7
+      iex> value = 7
+      iex> case 3 > 5 do
+      ...>   false ->
+      ...>     value = 3
+      ...>     value + 2
+      ...>   true ->
+      ...>     3
+      ...> end
+      iex> value
+      7
 
-      case lucky? do
-        false -> value = 13
-        true  -> true
-      end
+  In the example above, `value` is going to be `7` regardless of
+  which clause matched. The variable `value` bound in the clause
+  and the variable `value` bound in the outer context are two
+  entirely separate variables.
+
+  If you want to pattern match against an existing variable,
+  you need to use the `^/1` operator:
+
+      iex> x = 1
+      iex> case 10 do
+      ...>   ^x -> "Won't match"
+      ...>   _ -> "Will match"
+      ...> end
+      "Will match"
+
+  ## Using guards to match against multiple values
 
-      value #=> 7 or 13
+  While it is not possible to match against multiple patterns in a single
+  clause, it's possible to match against multiple values by using guards:
 
-  In the example above, value is going to be `7` or `13` depending on
-  the value of `lucky?`. In case `value` has no previous value before
-  case, clauses that do not explicitly bind a value have the variable
-  bound to nil.
+      iex> case :two do
+      ...>   value when value in [:one, :two] ->
+      ...>     "#{value} has been matched"
+      ...>   :three ->
+      ...>     "three has been matched"
+      ...> end
+      "two has been matched"
   """
-  defmacro case(condition, clauses)
+  defmacro case(condition, clauses), do: error!([condition, clauses])
 
   @doc """
   Evaluates the expression corresponding to the first clause that
-  evaluates to truth value.
-
-  Raises an error if all conditions evaluate to to nil or false.
+  evaluates to a truthy value.
 
   ## Examples
 
-      cond do
-        1 + 1 == 1 ->
-          "This will never match"
-        2 * 2 != 4 ->
-          "Nor this"
-        true ->
-          "This will"
-      end
+  The following example has a single clause that always evaluates
+  to true:
+
+      iex> cond do
+      ...>   hd([1, 2, 3]) -> "1 is considered as true"
+      ...> end
+      "1 is considered as true"
+
+  If all clauses evaluate to `nil` or `false`, `cond` raises an error.
+  For this reason, it may be necessary to add a final always-truthy condition
+  (anything non-`false` and non-`nil`), which will always match:
 
+      iex> cond do
+      ...>   1 + 1 == 1 -> "This will never match"
+      ...>   2 * 2 != 4 -> "Nor this"
+      ...>   true -> "This will"
+      ...> end
+      "This will"
+
+
+  If your `cond` has two clauses, and the last one falls back to
+  `true`, you may consider using `if/2` instead.
   """
-  defmacro cond(clauses)
+  defmacro cond(clauses), do: error!([clauses])
 
   @doc ~S"""
-  Evaluate the given expressions and handle any error, exit
+  Evaluates the given expressions and handles any error, exit,
   or throw that may have happened.
 
   ## Examples
@@ -1426,184 +2038,288 @@ defmodule Kernel.SpecialForms do
         do_something_that_may_fail(some_arg)
       rescue
         ArgumentError ->
-          IO.puts "Invalid argument given"
+          IO.puts("Invalid argument given")
       catch
         value ->
-          IO.puts "caught #{value}"
+          IO.puts("Caught #{inspect(value)}")
       else
         value ->
-          IO.puts "Success! The result was #{value}"
+          IO.puts("Success! The result was #{inspect(value)}")
       after
-        IO.puts "This is printed regardless if it failed or succeed"
+        IO.puts("This is printed regardless if it failed or succeeded")
       end
 
-  The rescue clause is used to handle exceptions, while the catch
-  clause can be used to catch thrown values. The else clause can
-  be used to control flow based on the result of the expression.
-  Catch, rescue and else clauses work based on pattern matching.
+  The `rescue` clause is used to handle exceptions while the `catch`
+  clause can be used to catch thrown values and exits.
+  The `else` clause can be used to control flow based on the result of
+  the expression. `catch`, `rescue`, and `else` clauses work based on
+  pattern matching (similar to the `case` special form).
 
-  Note that calls inside `try` are not tail recursive since the VM
-  needs to keep the stacktrace in case an exception happens.
+  Calls inside `try/1` are not tail recursive since the VM needs to keep
+  the stacktrace in case an exception happens. To retrieve the stacktrace,
+  access `__STACKTRACE__/0` inside the `rescue` or `catch` clause.
 
-  ## Rescue clauses
+  ## `rescue` clauses
 
-  Besides relying on pattern matching, rescue clauses provides some
-  conveniences around exceptions that allows one to rescue an
-  exception by its name. All the following formats are valid rescue
-  expressions:
+  Besides relying on pattern matching, `rescue` clauses provide some
+  conveniences around exceptions that allow one to rescue an
+  exception by its name. All the following formats are valid patterns
+  in `rescue` clauses:
 
-      try do
-        UndefinedModule.undefined_function
-      rescue
-        UndefinedFunctionError -> nil
-      end
+  Rescue a single exception without binding the exception to a variable:
 
-      try do
-        UndefinedModule.undefined_function
-      rescue
-        [UndefinedFunctionError] -> nil
-      end
+      iex> try do
+      ...>   1 / 0
+      ...> rescue
+      ...>   ArithmeticError -> :rescued
+      ...> end
+      :rescued
 
-      # rescue and bind to x
-      try do
-        UndefinedModule.undefined_function
-      rescue
-        x in [UndefinedFunctionError] -> nil
-      end
+  Rescue any of the given exception without binding:
 
-      # rescue all and bind to x
-      try do
-        UndefinedModule.undefined_function
-      rescue
-        x -> nil
-      end
+      iex> try do
+      ...>   1 / 0
+      ...> rescue
+      ...>   [ArithmeticError, ArgumentError] -> :rescued
+      ...> end
+      :rescued
 
-  ## Erlang errors
+  Rescue and bind the exception to the variable `x`:
 
-  Erlang errors are transformed into Elixir ones during rescue:
+      iex> try do
+      ...>   1 / 0
+      ...> rescue
+      ...>   x in [ArithmeticError] -> [:rescued, is_exception(x)]
+      ...> end
+      [:rescued, true]
 
-      try do
-        :erlang.error(:badarg)
-      rescue
-        ArgumentError -> :ok
-      end
+  Rescue different errors with separate clauses:
+
+      iex> try do
+      ...>   1 / 0
+      ...> rescue
+      ...>   ArgumentError -> :rescued_argument_error
+      ...>   ArithmeticError -> :rescued_arithmetic_error
+      ...> end
+      :rescued_arithmetic_error
+
+  Rescue all kinds of exceptions and bind the rescued exception
+  to the variable `x`:
+
+      iex> try do
+      ...>   1 / 0
+      ...> rescue
+      ...>   x -> [:rescued, is_exception(x)]
+      ...> end
+      [:rescued, true]
+
+
+  ### Erlang errors
+
+  Erlang errors are transformed into Elixir ones when rescuing:
+
+      iex> try do
+      ...>   :erlang.error(:badarg)
+      ...> rescue
+      ...>   ArgumentError -> :rescued
+      ...> end
+      :rescued
 
   The most common Erlang errors will be transformed into their
-  Elixir counter-part. Those which are not will be transformed
-  into `ErlangError`:
+  Elixir counterpart. Those which are not will be transformed
+  into the more generic `ErlangError`:
 
-      try do
-        :erlang.error(:unknown)
-      rescue
-        ErlangError -> :ok
-      end
+      iex> try do
+      ...>   :erlang.error(:unknown)
+      ...> rescue
+      ...>   ErlangError -> :rescued
+      ...> end
+      :rescued
 
-  In fact, ErlangError can be used to rescue any error that is
-  not an Elixir error proper. For example, it can be used to rescue
+  In fact, `ErlangError` can be used to rescue any error that is
+  not a proper Elixir error. For example, it can be used to rescue
   the earlier `:badarg` error too, prior to transformation:
 
-      try do
-        :erlang.error(:badarg)
-      rescue
-        ErlangError -> :ok
-      end
+      iex> try do
+      ...>   :erlang.error(:badarg)
+      ...> rescue
+      ...>   ErlangError -> :rescued
+      ...> end
+      :rescued
+
+  ## `catch` clauses
+
+  The `catch` clause can be used to catch thrown values, exits, and errors.
+
+  ### Catching thrown values
+
+  `catch` can be used to catch values thrown by `Kernel.throw/1`:
+
+      iex> try do
+      ...>   throw(:some_value)
+      ...> catch
+      ...>   thrown_value ->
+      ...>     "Thrown value: #{inspect(thrown_value)}"
+      ...> end
+      "Thrown value: :some_value"
+
+  ### Catching values of any kind
+
+  The `catch` clause also supports catching exits and errors. To do that, it
+  allows matching on both the *kind* of the caught value as well as the value
+  itself:
+
+      iex> try do
+      ...>   exit(:shutdown)
+      ...> catch
+      ...>   :exit, value ->
+      ...>     "Exited with value #{inspect(value)}"
+      ...> end
+      "Exited with value :shutdown"
+
+      iex> try do
+      ...>   exit(:shutdown)
+      ...> catch
+      ...>   kind, value when kind in [:exit, :throw] ->
+      ...>     "Caught exit or throw with value #{inspect(value)}"
+      ...> end
+      "Caught exit or throw with value :shutdown"
+
+  The `catch` clause also supports `:error` alongside `:exit` and `:throw` as
+  in Erlang, although this is commonly avoided in favor of `raise`/`rescue` control
+  mechanisms. One reason for this is that when catching `:error`, the error is
+  not automatically transformed into an Elixir error:
+
+      iex> try do
+      ...>   :erlang.error(:badarg)
+      ...> catch
+      ...>   :error, :badarg -> :rescued
+      ...> end
+      :rescued
 
-  ## Catching throws and exits
+  ## `after` clauses
 
-  The catch clause can be used to catch throws values and exits.
+  An `after` clause allows you to define cleanup logic that will be invoked both
+  when the block of code passed to `try/1` succeeds and also when an error is raised. Note
+  that the process will exit as usual when receiving an exit signal that causes
+  it to exit abruptly and so the `after` clause is not guaranteed to be executed.
+  Luckily, most resources in Elixir (such as open files, ETS tables, ports, sockets,
+  and so on) are linked to or monitor the owning process and will automatically clean
+  themselves up if that process exits.
 
+      File.write!("tmp/story.txt", "Hello, World")
       try do
-        exit(1)
-      catch
-        :exit, 1 -> IO.puts "Exited with 1"
+        do_something_with("tmp/story.txt")
+      after
+        File.rm("tmp/story.txt")
       end
 
+  Although `after` clauses are invoked whether or not there was an error, they do not
+  modify the return value. Both of the following examples print a message to STDOUT
+  and return `:returned`:
+
       try do
-        throw(:sample)
-      catch
-        :throw, :sample ->
-          IO.puts "sample thrown"
+        :returned
+      after
+        IO.puts("This message will be printed")
+        :not_returned
       end
+      #=> :returned
 
-  catch values also support `:error`, as in Erlang, although it is
-  commonly avoided in favor of raise/rescue control mechanisms.
+      try do
+        raise "boom"
+      rescue
+        _ -> :returned
+      after
+        IO.puts("This message will be printed")
+        :not_returned
+      end
+      #=> :returned
 
-  ## Else clauses
+  ## `else` clauses
 
-  Else clauses allow the result of the expression to be pattern
+  `else` clauses allow the result of the body passed to `try/1` to be pattern
   matched on:
 
-      x = 2
-      try do
-        1 / x
-      rescue
-        ArithmeticError ->
-          :infinity
-      else
-        y when y < 1 and y > -1 ->
-          :small
-        _ ->
-          :large
-      end
+      iex> x = 2
+      ...> try do
+      ...>   1 / x
+      ...> rescue
+      ...>   ArithmeticError -> :infinity
+      ...> else
+      ...>   y when y < 1 and y > -1 -> :small
+      ...>   _ -> :large
+      ...> end
+      :small
 
-  If an else clause is not present the result of the expression will
-  be return, if no exceptions are raised:
+  If an `else` clause is not present and no exceptions are raised,
+  the result of the expression will be returned:
 
-      x = 1
-      ^x =
-        try do
-          1 / x
-        rescue
-          ArithmeticError ->
-            :infinity
-        end
+      iex> x = 5
+      iex> try do
+      ...>   1 / x
+      ...> rescue
+      ...>   ArithmeticError -> :infinity
+      ...> end
+      0.2
 
-  However when an else clause is present but the result of the expression
-  does not match any of the patterns an exception will be raised. This
-  exception will not be caught by a catch or rescue in the same try:
+  However, when an `else` clause is present but the result of the expression
+  does not match any of the patterns then an exception will be raised. This
+  exception will not be caught by a `catch` or `rescue` in the same `try`:
 
-      x = 1
-      try do
-        try do
-          1 / x
-        rescue
-          # The TryClauseError can not be rescued here:
-          TryClauseError ->
-            :error_a
-        else
-          0 ->
-            :small
-        end
-      rescue
-        # The TryClauseError is rescued here:
-        TryClauseError ->
-          :error_b
-      end
+      iex> x = 1
+      iex> try do
+      ...>   try do
+      ...>     1 / x
+      ...>   rescue
+      ...>     # The TryClauseError cannot be rescued here:
+      ...>     TryClauseError -> :error_a
+      ...>   else
+      ...>      0.5 -> :small
+      ...>   end
+      ...> rescue
+      ...>   # The TryClauseError is rescued here:
+      ...>   TryClauseError -> :error_b
+      ...> end
+      :error_b
 
-  Similarly an exception inside an else clause is not caught or rescued
-  inside the same try:
+  Similarly, an exception inside an `else` clause is not caught or rescued
+  inside the same `try`:
 
-      try do
-        try do
-          nil
-        catch
-          # The exit(1) call below can not be caught here:
-          :exit, _ ->
-            :exit_a
-        else
-          _ ->
-            exit(1)
-        end
-      catch
-        # The exit is caught here:
-        :exit, _ ->
-          :exit_b
-      end
+      iex> x = 1
+      iex> try do
+      ...>   try do
+      ...>     1 / x
+      ...>   catch
+      ...>     # The exit(1) call below can not be caught here:
+      ...>     :exit, _ -> :exit_a
+      ...>   else
+      ...>     _ -> exit(1)
+      ...>   end
+      ...> catch
+      ...>   # The exit is caught here:
+      ...>   :exit, _ -> :exit_b
+      ...> end
+      :exit_b
 
   This means the VM no longer needs to keep the stacktrace once inside
-  an else clause and so tail recursion is possible when using a `try`
-  with a tail call as the final call inside an else clause. The same
-  is true for rescue and catch clauses.
+  an `else` clause and so tail recursion is possible when using a `try`
+  with a tail call as the final call inside an `else` clause. The same
+  is true for `rescue` and `catch` clauses.
+
+  Only the result of the tried expression falls down to the `else` clause.
+  If the `try` ends up in the `rescue` or `catch` clauses, their result
+  will not fall down to `else`:
+
+      iex> try do
+      ...>   throw(:catch_this)
+      ...> catch
+      ...>   :throw, :catch_this -> :it_was_caught
+      ...> else
+      ...>   # :it_was_caught will not fall down to this "else" clause.
+      ...>   other -> {:else, other}
+      ...> end
+      :it_was_caught
 
   ## Variable handling
 
@@ -1619,7 +2335,8 @@ defmodule Kernel.SpecialForms do
         _, _ -> :failed
       end
 
-      x #=> unbound variable `x`
+      x
+      #=> unbound variable "x"
 
   In the example above, `x` cannot be accessed since it was defined
   inside the `try` clause. A common practice to address this issue
@@ -1635,54 +2352,63 @@ defmodule Kernel.SpecialForms do
         end
 
   """
-  defmacro try(args)
+  defmacro try(args), do: error!([args])
 
   @doc """
-  Checks if there is a message matching the given clauses
-  in the current process mailbox.
-
-  In case there is no such message, the current process hangs
-  until a message arrives or waits until a given timeout value.
-
-  ## Examples
+  Consumes the first message matching any of the given clauses in the current
+  process mailbox.
 
-      receive do
-        {:selector, i, value} when is_integer(i) ->
-          value
-        value when is_atom(value) ->
-          value
-        _ ->
-          IO.puts :stderr, "Unexpected message received"
-      end
+  If there is no matching message, the current process waits until a matching
+  message arrives or until after a given timeout value.
 
-  An optional after clause can be given in case the message was not
-  received after the specified period of time:
+  Any new and existing messages that do not match will remain in the mailbox.
 
-      receive do
-        {:selector, i, value} when is_integer(i) ->
-          value
-        value when is_atom(value) ->
-          value
-        _ ->
-          IO.puts :stderr, "Unexpected message received"
-      after
-        5000 ->
-          IO.puts :stderr, "No message in 5 seconds"
-      end
+  ## Examples
+      iex> send(self(), {:selector, 5, :quantity})
+      iex> receive do
+      ...>   {:selector, number, name} when is_integer(number) ->
+      ...>     name
+      ...>   name when is_atom(name) ->
+      ...>     name
+      ...>   _ ->
+      ...>     IO.puts(:stderr, "Unexpected message received")
+      ...> end
+      :quantity
+
+  An optional `after` clause can be given in case no matching message is
+  received during the given timeout period, specified in milliseconds:
+
+      iex> receive do
+      ...>   {:selector, number, name} when is_integer(number) ->
+      ...>     name
+      ...>   name when is_atom(name) ->
+      ...>     name
+      ...>   _ ->
+      ...>     IO.puts(:stderr, "Unexpected message received")
+      ...> after
+      ...>   10 ->
+      ...>     "No message in 10 milliseconds"
+      ...> end
+      "No message in 10 milliseconds"
 
   The `after` clause can be specified even if there are no match clauses.
-  There are two special cases for the timeout value given to `after`
+  The timeout value given to `after` can be any expression evaluating to
+  one of the allowed values:
 
     * `:infinity` - the process should wait indefinitely for a matching
-      message, this is the same as not using a timeout
+      message, this is the same as not using the after clause
 
-    * 0 - if there is no matching message in the mailbox, the timeout
+    * `0` - if there is no matching message in the mailbox, the timeout
       will occur immediately
 
-  ## Variables handling
+    * positive integer smaller than or equal to `4_294_967_295` (`0xFFFFFFFF`
+      in hexadecimal notation) - it should be possible to represent the timeout
+      value as an unsigned 32-bit integer.
+
+  ## Variable handling
 
-  The `receive` special form handles variables exactly as the `case`
+  The `receive/1` special form handles variables exactly as the `case/2`
   special macro. For more information, check the docs for `case/2`.
   """
-  defmacro receive(args)
+  defmacro receive(args), do: error!([args])
 end
diff --git a/lib/elixir/lib/kernel/typespec.ex b/lib/elixir/lib/kernel/typespec.ex
index f75870c323d..1f3539bcf93 100644
--- a/lib/elixir/lib/kernel/typespec.ex
+++ b/lib/elixir/lib/kernel/typespec.ex
@@ -1,968 +1,1095 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Kernel.Typespec do
-  @moduledoc """
-  Provides macros and functions for working with typespecs.
+  @moduledoc false
 
-  Elixir comes with a notation for declaring types and specifications. Elixir is
-  dynamically typed, as such typespecs are never used by the compiler to
-  optimize or modify code. Still, using typespecs is useful as documentation and
-  tools such as [Dialyzer](http://www.erlang.org/doc/man/dialyzer.html) can
-  analyze the code with typespecs to find bugs.
+  ## Deprecated API moved to Code.Typespec
 
-  The attributes `@type`, `@opaque`, `@typep`, `@spec` and `@callback` available
-  in modules are handled by the equivalent macros defined by this module. See
-  sub-sections "Defining a type" and "Defining a specification" below.
+  @doc false
+  @deprecated "Use Code.Typespec.spec_to_quoted/2 instead"
+  def spec_to_ast(name, spec) do
+    Code.Typespec.spec_to_quoted(name, spec)
+  end
 
-  ## Types and their syntax
+  @doc false
+  @deprecated "Use Code.Typespec.type_to_quoted/1 instead"
+  def type_to_ast(type) do
+    Code.Typespec.type_to_quoted(type)
+  end
 
-  The type syntax provided by Elixir is fairly similar to the one in
-  [Erlang](http://www.erlang.org/doc/reference_manual/typespec.html).
+  @doc false
+  @deprecated "Use Code.fetch_docs/1 instead"
+  def beam_typedocs(module) when is_atom(module) or is_binary(module) do
+    case Code.fetch_docs(module) do
+      {:docs_v1, _, _, _, _, _, docs} ->
+        for {{:type, name, arity}, _, _, doc, _} <- docs do
+          case doc do
+            %{"en" => doc_string} -> {{name, arity}, doc_string}
+            :hidden -> {{name, arity}, false}
+            _ -> {{name, arity}, nil}
+          end
+        end
 
-  Most of the built-in types provided in Erlang (for example, `pid()`) are
-  expressed the same way: `pid()` or simply `pid`. Parametrized types are also
-  supported (`list(integer)`) and so are remote types (`Enum.t`).
+      {:error, _} ->
+        nil
+    end
+  end
 
-  Integers and atom literals are allowed as types (ex. `1`, `:atom` or
-  `false`). All other types are built of unions of predefined types. Certain
-  shorthands are allowed, such as `[...]`, `<<>>` and `{...}`.
-
-  ### Predefined types
-
-      Type :: any         # the top type, the set of all terms
-            | none        # the bottom type, contains no terms
-            | pid
-            | port
-            | reference
-            | Atom
-            | Bitstring
-            | float
-            | Fun
-            | Integer
-            | List
-            | Tuple
-            | Union
-            | UserDefined # Described in section "Defining a type"
+  @doc false
+  @deprecated "Use Code.Typespec.fetch_types/1 instead"
+  def beam_types(module) when is_atom(module) or is_binary(module) do
+    case Code.Typespec.fetch_types(module) do
+      {:ok, types} -> types
+      :error -> nil
+    end
+  end
 
-      Atom :: atom
-            | ElixirAtom # `:foo`, `:bar`, ...
+  @doc false
+  @deprecated "Use Code.Typespec.fetch_specs/1 instead"
+  def beam_specs(module) when is_atom(module) or is_binary(module) do
+    case Code.Typespec.fetch_specs(module) do
+      {:ok, specs} -> specs
+      :error -> nil
+    end
+  end
 
-      Bitstring :: <<>>
-                 | << _ :: M >>             # M is a positive integer
-                 | << _ :: _ * N >>         # N is a positive integer
-                 | << _ :: M, _ :: _ * N >>
+  @doc false
+  @deprecated "Use Code.Typespec.fetch_callbacks/1 instead"
+  def beam_callbacks(module) when is_atom(module) or is_binary(module) do
+    case Code.Typespec.fetch_callbacks(module) do
+      {:ok, callbacks} -> callbacks
+      :error -> nil
+    end
+  end
 
-      Fun :: (... -> any)    # any function
-           | (... -> Type)   # any arity, returning Type
-           | (() -> Type))
-           | (TList -> Type)
+  ## Hooks for Module functions
 
-      Integer :: integer
-               | ElixirInteger                # ..., -1, 0, 1, ... 42 ...
-               | ElixirInteger..ElixirInteger # an integer range
+  def defines_type?(module, {name, arity} = signature)
+      when is_atom(module) and is_atom(name) and arity in 0..255 do
+    {_set, bag} = :elixir_module.data_tables(module)
 
-      List :: list(Type)                        # proper list ([]-terminated)
-            | improper_list(Type1, Type2)       # Type1=contents, Type2=termination
-            | maybe_improper_list(Type1, Type2) # Type1 and Type2 as above
-            | nonempty_list(Type)               # proper non-empty list
-            | []                                # empty list
-            | [Type]                            # shorthand for list(Type)
-            | [Type, ...]                       # shorthand for nonempty_list(Type)
+    finder = fn {_kind, expr, _caller} ->
+      type_to_signature(expr) == signature
+    end
 
-      Tuple :: tuple     # a tuple of any size
-             | {}        # empty tuple
-             | {TList}
+    :lists.any(finder, get_typespecs(bag, [:type, :opaque, :typep]))
+  end
 
-      TList :: Type
-             | Type, TList
+  def spec_to_callback(module, {name, arity} = signature)
+      when is_atom(module) and is_atom(name) and arity in 0..255 do
+    {set, bag} = :elixir_module.data_tables(module)
 
-      Union :: Type1 | Type2
+    filter = fn {:spec, expr, pos} ->
+      if spec_to_signature(expr) == signature do
+        kind = :callback
+        store_typespec(bag, kind, expr, pos)
 
-  ### Bit strings
+        case :ets.lookup(set, {:function, name, arity}) do
+          [{{:function, ^name, ^arity}, _, line, _, doc, doc_meta}] ->
+            store_doc(set, kind, name, arity, line, :doc, doc, doc_meta)
 
-  Bit string with a base size of 3:
+          _ ->
+            nil
+        end
 
-      << _ :: 3 >>
+        true
+      else
+        false
+      end
+    end
 
-  Bit string with a unit size of 8:
+    :lists.filter(filter, get_typespecs(bag, :spec)) != []
+  end
 
-      << _ :: _ * 8 >>
+  ## Typespec definition and storage
 
-  ### Anonymous functions
+  @doc """
+  Defines a typespec.
 
-  Any anonymous function:
+  Invoked by `@/1` expansion.
+  """
+  def deftypespec(:spec, expr, _line, _file, module, pos) do
+    {_set, bag} = :elixir_module.data_tables(module)
+    store_typespec(bag, :spec, expr, pos)
+  end
 
-      ((...) -> any)
-      (... -> any)
+  def deftypespec(kind, expr, line, _file, module, pos)
+      when kind in [:callback, :macrocallback] do
+    {set, bag} = :elixir_module.data_tables(module)
 
-  Anonymous function with arity of zero:
+    case spec_to_signature(expr) do
+      {name, arity} ->
+        # store doc only once in case callback has multiple clauses
+        if not :ets.member(set, {kind, name, arity}) do
+          {line, doc} = get_doc_info(set, :doc, line)
+          store_doc(set, kind, name, arity, line, :doc, doc, %{})
+        end
 
-      (() -> type)
+      :error ->
+        :error
+    end
 
-  Anonymous function with some arity:
+    store_typespec(bag, kind, expr, pos)
+  end
 
-      ((type, type) -> type)
-      (type, type -> type)
+  @reserved_signatures [required: 1, optional: 1]
+  def deftypespec(kind, expr, line, file, module, pos)
+      when kind in [:type, :typep, :opaque] do
+    {set, bag} = :elixir_module.data_tables(module)
 
-  ## Built-in types
+    case type_to_signature(expr) do
+      {name, arity} = signature when signature in @reserved_signatures ->
+        compile_error(
+          :elixir_module.get_cached_env(pos),
+          "type #{name}/#{arity} is a reserved type and it cannot be defined"
+        )
 
-      Built-in type         | Defined as
-      :-------------------- | :---------
-      `term`                | `any`
-      `binary`              | `<< _ :: _ * 8 >>`
-      `bitstring`           | `<< _ :: _ * 1 >>`
-      `boolean`             | `false` &#124; `true`
-      `byte`                | `0..255`
-      `char`                | `0..0xffff`
-      `number`              | `integer` &#124; `float`
-      `list`                | `[any]`
-      `maybe_improper_list` | `maybe_improper_list(any, any)`
-      `nonempty_list`       | `nonempty_list(any)`
-      `iodata`              | `iolist` &#124; `binary`
-      `iolist`              | `maybe_improper_list(byte` &#124; `binary` &#124; `iolist, binary` &#124; `[])`
-      `module`              | `atom`
-      `mfa`                 | `{atom, atom, arity}`
-      `arity`               | `0..255`
-      `node`                | `atom`
-      `timeout`             | `:infinity` &#124; `non_neg_integer`
-      `no_return`           | `none`
-      `fun`                 | `(... -> any)`
+      {name, arity} when kind == :typep ->
+        {line, doc} = get_doc_info(set, :typedoc, line)
 
-  Some built-in types cannot be expressed with valid syntax according to the
-  language defined above.
+        if doc do
+          warning =
+            "type #{name}/#{arity} is private, @typedoc's are always discarded for private types"
 
-      Built-in type     | Can be interpreted as
-      :---------------- | :--------------------
-      `non_neg_integer` | `0..`
-      `pos_integer`     | `1..`
-      `neg_integer`     | `..-1`
+          IO.warn(warning, file: file, line: line)
+        end
 
-  Types defined in other modules are referred to as "remote types", they are
-  referenced as `Module.type_name` (ex. `Enum.t` or `String.t`).
+      {name, arity} ->
+        {line, doc} = get_doc_info(set, :typedoc, line)
+        spec_meta = if kind == :opaque, do: %{opaque: true}, else: %{}
+        store_doc(set, :type, name, arity, line, :typedoc, doc, spec_meta)
 
-  ## Defining a type
+      :error ->
+        :error
+    end
 
-      @type type_name :: type
-      @typep type_name :: type
-      @opaque type_name :: type
+    store_typespec(bag, kind, expr, pos)
+  end
 
-  A type defined with `@typep` is private. An opaque type, defined with
-  `@opaque` is a type where the internal structure of the type will not be
-  visible, but the type is still public.
+  defp get_typespecs(bag, keys) when is_list(keys) do
+    :lists.flatmap(&get_typespecs(bag, &1), keys)
+  end
 
-  Types can be parametrised by defining variables as parameters, these variables
-  can then be used to define the type.
+  defp get_typespecs(bag, key) do
+    :ets.lookup_element(bag, {:accumulate, key}, 2)
+  catch
+    :error, :badarg -> []
+  end
 
-      @type dict(key, value) :: [{key, value}]
+  defp take_typespecs(bag, keys) when is_list(keys) do
+    :lists.flatmap(&take_typespecs(bag, &1), keys)
+  end
 
-  ## Defining a specification
+  defp take_typespecs(bag, key) do
+    :lists.map(&elem(&1, 1), :ets.take(bag, {:accumulate, key}))
+  end
 
-      @spec function_name(type1, type2) :: return_type
-      @callback function_name(type1, type2) :: return_type
+  defp store_typespec(bag, key, expr, pos) do
+    :ets.insert(bag, {{:accumulate, key}, {key, expr, pos}})
+    :ok
+  end
 
-  Callbacks are used to define the callbacks functions of behaviours (see
-  `Behaviour`).
+  defp store_doc(set, kind, name, arity, line, doc_kind, doc, spec_meta) do
+    doc_meta = get_doc_meta(spec_meta, doc_kind, set)
+    :ets.insert(set, {{kind, name, arity}, line, doc, doc_meta})
+  end
 
-  Guards can be used to restrict type variables given as arguments to the
-  function.
+  defp get_doc_info(set, attr, line) do
+    case :ets.take(set, attr) do
+      [{^attr, {line, doc}, _, _}] -> {line, doc}
+      [] -> {line, nil}
+    end
+  end
 
-      @spec function(arg) :: [arg] when arg: atom
+  defp get_doc_meta(spec_meta, doc_kind, set) do
+    case :ets.take(set, {doc_kind, :meta}) do
+      [{{^doc_kind, :meta}, metadata}] -> Map.merge(metadata, spec_meta)
+      [] -> spec_meta
+    end
+  end
 
-  Type variables with no restriction can also be defined.
+  defp spec_to_signature({:when, _, [spec, _]}), do: type_to_signature(spec)
+  defp spec_to_signature(other), do: type_to_signature(other)
 
-      @spec function(arg) :: [arg] when arg: var
+  defp type_to_signature({:"::", _, [{name, _, context}, _]})
+       when is_atom(name) and name != :"::" and is_atom(context),
+       do: {name, 0}
 
-  Specifications can be overloaded just like ordinary functions.
+  defp type_to_signature({:"::", _, [{name, _, args}, _]}) when is_atom(name) and name != :"::",
+    do: {name, length(args)}
 
-      @spec function(integer) :: atom
-      @spec function(atom)    :: integer
+  defp type_to_signature(_), do: :error
 
-  ## Notes
+  ## Translation from Elixir AST to typespec AST
 
-  Elixir discourages the use of type `string` as it might be confused with
-  binaries which are referred to as "strings" in Elixir (as opposed to character
-  lists). In order to use the type that is called `string` in Erlang, one has to
-  use the `char_list` type which is a synonym for `string`. If you use `string`,
-  you'll get a warning from the compiler.
+  @doc false
+  def translate_typespecs_for_module(_set, bag) do
+    type_typespecs = take_typespecs(bag, [:type, :opaque, :typep])
+    defined_type_pairs = collect_defined_type_pairs(type_typespecs)
 
-  If you want to refer to the "string" type (the one operated on by functions in
-  the `String` module), use `String.t` type instead.
-  """
+    state = %{
+      defined_type_pairs: defined_type_pairs,
+      used_type_pairs: [],
+      local_vars: %{},
+      undefined_type_error_enabled?: true
+    }
 
-  @doc """
-  Defines a type.
-  This macro is responsible for handling the attribute `@type`.
+    {types, state} = :lists.mapfoldl(&translate_type/2, state, type_typespecs)
+    {specs, state} = :lists.mapfoldl(&translate_spec/2, state, take_typespecs(bag, :spec))
+    {callbacks, state} = :lists.mapfoldl(&translate_spec/2, state, take_typespecs(bag, :callback))
 
-  ## Examples
+    {macrocallbacks, state} =
+      :lists.mapfoldl(&translate_spec/2, state, take_typespecs(bag, :macrocallback))
 
-      @type my_type :: atom
+    optional_callbacks = :lists.flatten(get_typespecs(bag, :optional_callbacks))
+    used_types = filter_used_types(types, state)
 
-  """
-  defmacro deftype(type) do
-    quote do
-      Kernel.Typespec.deftype(:type, unquote(Macro.escape(type, unquote: true)), __ENV__)
-    end
+    {used_types, specs, callbacks, macrocallbacks, optional_callbacks}
   end
 
-  @doc """
-  Defines an opaque type.
-  This macro is responsible for handling the attribute `@opaque`.
-
-  ## Examples
-
-      @opaque my_type :: atom
+  defp collect_defined_type_pairs(type_typespecs) do
+    fun = fn {_kind, expr, pos}, type_pairs ->
+      %{file: file, line: line} = env = :elixir_module.get_cached_env(pos)
 
-  """
-  defmacro defopaque(type) do
-    quote do
-      Kernel.Typespec.deftype(:opaque, unquote(Macro.escape(type, unquote: true)), __ENV__)
-    end
-  end
+      case type_to_signature(expr) do
+        {name, arity} = type_pair ->
+          if built_in_type?(name, arity) do
+            message = "type #{name}/#{arity} is a built-in type and it cannot be redefined"
+            compile_error(env, message)
+          end
 
-  @doc """
-  Defines a private type.
-  This macro is responsible for handling the attribute `@typep`.
+          if Map.has_key?(type_pairs, type_pair) do
+            {error_full_path, error_line} = type_pairs[type_pair]
+            error_relative_path = Path.relative_to_cwd(error_full_path)
 
-  ## Examples
+            compile_error(
+              env,
+              "type #{name}/#{arity} is already defined in #{error_relative_path}:#{error_line}"
+            )
+          end
 
-      @typep my_type :: atom
+          Map.put(type_pairs, type_pair, {file, line})
 
-  """
-  defmacro deftypep(type) do
-    quote do
-      Kernel.Typespec.deftype(:typep, unquote(Macro.escape(type, unquote: true)), __ENV__)
+        :error ->
+          compile_error(env, "invalid type specification: #{Macro.to_string(expr)}")
+      end
     end
-  end
-
-  @doc """
-  Defines a spec.
-  This macro is responsible for handling the attribute `@spec`.
 
-  ## Examples
-
-      @spec add(number, number) :: number
+    :lists.foldl(fun, %{}, type_typespecs)
+  end
 
-  """
-  defmacro defspec(spec) do
-    quote do
-      Kernel.Typespec.defspec(:spec, unquote(Macro.escape(spec, unquote: true)), __ENV__)
+  defp filter_used_types(types, state) do
+    fun = fn {_kind, {name, arity} = type_pair, _line, _type, export} ->
+      if not export and not :lists.member(type_pair, state.used_type_pairs) do
+        %{^type_pair => {file, line}} = state.defined_type_pairs
+        IO.warn("type #{name}/#{arity} is unused", file: file, line: line)
+        false
+      else
+        true
+      end
     end
+
+    :lists.filter(fun, types)
   end
 
-  @doc """
-  Defines a callback.
-  This macro is responsible for handling the attribute `@callback`.
+  defp translate_type({kind, {:"::", _, [{name, meta, args}, definition]}, pos}, state)
+       when is_list(meta) do
+    caller = :elixir_module.get_cached_env(pos)
+    state = clean_local_state(state)
 
-  ## Examples
+    args =
+      if is_atom(args) do
+        []
+      else
+        :lists.map(&variable/1, args)
+      end
 
-      @callback add(number, number) :: number
+    vars = :lists.filter(&match?({:var, _, _}, &1), args)
+    var_names = :lists.map(&elem(&1, 2), vars)
+    state = :lists.foldl(&update_local_vars(&2, &1), state, var_names)
+    {spec, state} = typespec(definition, var_names, caller, state)
+    type = {name, spec, vars}
+    arity = length(args)
 
-  """
-  defmacro defcallback(spec) do
-    quote do
-      Kernel.Typespec.defspec(:callback, unquote(Macro.escape(spec, unquote: true)), __ENV__)
-    end
-  end
+    ensure_no_underscore_local_vars!(caller, var_names)
+    ensure_no_unused_local_vars!(caller, state.local_vars)
 
-  @doc """
-  Defines a `type`, `typep` or `opaque` by receiving a typespec expression.
-  """
-  def define_type(kind, expr, doc \\ nil, env) do
-    Module.store_typespec(env.module, kind, {kind, expr, doc, env})
-  end
+    {kind, export} =
+      case kind do
+        :type -> {:type, true}
+        :typep -> {:type, false}
+        :opaque -> {:opaque, true}
+      end
 
-  @doc """
-  Defines a `spec` by receiving a typespec expression.
-  """
-  def define_spec(kind, expr, env) do
-    Module.store_typespec(env.module, kind, {kind, expr, env})
-  end
+    invalid_args = :lists.filter(&(not valid_variable_ast?(&1)), args)
 
-  @doc """
-  Returns `true` if the current module defines a given type
-  (private, opaque or not). This function is only available
-  for modules being compiled.
-  """
-  def defines_type?(module, name, arity) do
-    finder = fn {_kind, expr, _doc, _caller} ->
-      type_to_signature(expr) == {name, arity}
-    end
+    if invalid_args != [] do
+      invalid_args = :lists.join(", ", :lists.map(&Macro.to_string/1, invalid_args))
 
-    :lists.any(finder, Module.get_attribute(module, :type)) or
-    :lists.any(finder, Module.get_attribute(module, :opaque))
-  end
+      message =
+        "@type definitions expect all arguments to be variables. The type " <>
+          "#{name}/#{arity} has an invalid argument(s): #{invalid_args}"
 
-  @doc """
-  Returns `true` if the current module defines a given spec.
-  This function is only available for modules being compiled.
-  """
-  def defines_spec?(module, name, arity) do
-    finder = fn {_kind, expr, _caller} ->
-      spec_to_signature(expr) == {name, arity}
+      compile_error(caller, message)
     end
-    :lists.any(finder, Module.get_attribute(module, :spec))
-  end
 
-  @doc """
-  Returns `true` if the current module defines a callback.
-  This function is only available for modules being compiled.
-  """
-  def defines_callback?(module, name, arity) do
-    finder = fn {_kind, expr, _caller} ->
-      spec_to_signature(expr) == {name, arity}
+    if underspecified?(kind, arity, spec) do
+      message = "@#{kind} type #{name}/#{arity} is underspecified and therefore meaningless"
+      IO.warn(message, caller)
     end
-    :lists.any(finder, Module.get_attribute(module, :callback))
+
+    {{kind, {name, arity}, meta, type, export}, state}
   end
 
-  @doc """
-  Converts a spec clause back to Elixir AST.
-  """
-  def spec_to_ast(name, {:type, line, :fun, [{:type, _, :product, args}, result]}) do
-    meta = [line: line]
-    body = {name, meta, Enum.map(args, &typespec_to_ast/1)}
+  defp valid_variable_ast?({variable_name, _, context})
+       when is_atom(variable_name) and is_atom(context),
+       do: true
 
-    vars = args ++ [result]
-      |> Enum.flat_map(&collect_vars/1)
-      |> Enum.uniq
-      |> Enum.map(&{&1, {:var, meta, nil}})
+  defp valid_variable_ast?(_), do: false
 
-    spec = {:::, meta, [body, typespec_to_ast(result)]}
+  defp underspecified?(:opaque, 0, {:type, _, type, []}) when type in [:any, :term], do: true
+  defp underspecified?(_kind, _arity, _spec), do: false
 
-    if vars == [] do
-      spec
-    else
-      {:when, meta, [spec, vars]}
-    end
+  defp translate_spec({kind, {:when, _meta, [spec, guard]}, pos}, state) do
+    caller = :elixir_module.get_cached_env(pos)
+    translate_spec(kind, spec, guard, caller, state)
   end
 
-  def spec_to_ast(name, {:type, line, :fun, []}) do
-    {:::, [line: line], [{name, [line: line], []}, quote(do: term)]}
+  defp translate_spec({kind, spec, pos}, state) do
+    caller = :elixir_module.get_cached_env(pos)
+    translate_spec(kind, spec, [], caller, state)
   end
 
-  def spec_to_ast(name, {:type, line, :bounded_fun, [{:type, _, :fun, [{:type, _, :product, args}, result]}, constraints]}) do
-    guards =
-      for {:type, _, :constraint, [{:atom, _, :is_subtype}, [{:var, _, var}, type]]} <- constraints do
-        {var, typespec_to_ast(type)}
-      end
-
-    meta = [line: line]
-
-    vars = args ++ [result]
-           |> Enum.flat_map(&collect_vars/1)
-           |> Enum.uniq
-           |> Kernel.--(Keyword.keys(guards))
-           |> Enum.map(&{&1, {:var, meta, nil}})
-
-    args = for arg <- args, do: typespec_to_ast(arg)
-
-    {:when, meta, [
-      {:::, meta, [{name, [line: line], args}, typespec_to_ast(result)]},
-      guards ++ vars
-    ]}
+  defp translate_spec(kind, {:"::", _, [{name, meta, args}, return]}, guard, caller, state)
+       when is_atom(name) and name != :"::" and is_list(meta) and (is_list(args) or is_atom(args)) do
+    translate_spec(kind, meta, name, args, return, guard, caller, state)
   end
 
-  @doc """
-  Converts a type clause back to Elixir AST.
-  """
-  def type_to_ast({{:record, record}, fields, args}) when is_atom(record) do
-    fields = for field <- fields, do: typespec_to_ast(field)
-    args = for arg <- args, do: typespec_to_ast(arg)
-    type = {:{}, [], [record|fields]}
-    quote do: unquote(record)(unquote_splicing(args)) :: unquote(type)
+  defp translate_spec(_kind, {name, _meta, _args} = spec, _guard, caller, _state)
+       when is_atom(name) and name != :"::" do
+    spec = Macro.to_string(spec)
+    compile_error(caller, "type specification missing return type: #{spec}")
   end
 
-  def type_to_ast({name, type, args}) do
-    args = for arg <- args, do: typespec_to_ast(arg)
-    quote do: unquote(name)(unquote_splicing(args)) :: unquote(typespec_to_ast(type))
+  defp translate_spec(_kind, spec, _guard, caller, _state) do
+    spec = Macro.to_string(spec)
+    compile_error(caller, "invalid type specification: #{spec}")
   end
 
-  @doc """
-  Returns all type docs available from the module's beam code.
+  defp translate_spec(kind, meta, name, args, return, guard, caller, state) when is_atom(args),
+    do: translate_spec(kind, meta, name, [], return, guard, caller, state)
 
-  The result is returned as a list of tuples where the first element is the pair of type
-  name and arity and the second element is the documentation.
+  defp translate_spec(kind, meta, name, args, return, guard, caller, state) do
+    ensure_no_defaults!(args)
+    state = clean_local_state(state)
 
-  The module must have a corresponding beam file which can be
-  located by the runtime system.
-  """
-  @spec beam_typedocs(module | binary) :: [tuple] | nil
-  def beam_typedocs(module) when is_atom(module) or is_binary(module) do
-    case abstract_code(module) do
-      {:ok, abstract_code} ->
-        type_docs = for {:attribute, _, :typedoc, tup} <- abstract_code, do: tup
-        :lists.flatten(type_docs)
-      _ ->
-        nil
+    if not Keyword.keyword?(guard) do
+      error = "expected keywords as guard in type specification, got: #{Macro.to_string(guard)}"
+      compile_error(caller, error)
     end
-  end
 
-  @doc """
-  Returns all types available from the module's beam code.
+    location = location(meta)
+    vars = Keyword.keys(guard)
 
-  The result is returned as a list of tuples where the first
-  element is the type (`:typep`, `:type` and `:opaque`).
+    {args, state} = :lists.mapfoldl(&typespec(&1, vars, caller, &2), state, args)
+    {return, state} = typespec(return, vars, caller, state)
+    spec = {:type, location, :fun, [{:type, location, :product, args}, return]}
 
-  The module must have a corresponding beam file which can be
-  located by the runtime system.
-  """
-  @spec beam_types(module | binary) :: [tuple] | nil
-  def beam_types(module) when is_atom(module) or is_binary(module) do
-    case abstract_code(module) do
-      {:ok, abstract_code} ->
-        exported_types = for {:attribute, _, :export_type, types} <- abstract_code, do: types
-        exported_types = :lists.flatten(exported_types)
-
-        for {:attribute, _, kind, {name, _, args} = type} <- abstract_code, kind in [:opaque, :type] do
-          cond do
-            kind == :opaque -> {:opaque, type}
-            {name, length(args)} in exported_types -> {:type, type}
-            true -> {:typep, type}
-          end
-        end
-      _ ->
-        nil
-    end
-  end
+    {spec, state} =
+      case guard_to_constraints(guard, vars, meta, caller, state) do
+        {[], state} -> {spec, state}
+        {constraints, state} -> {{:type, location, :bounded_fun, [spec, constraints]}, state}
+      end
 
-  @doc """
-  Returns all specs available from the module's beam code.
+    ensure_no_unused_local_vars!(caller, state.local_vars)
 
-  The result is returned as a list of tuples where the first
-  element is spec name and arity and the second is the spec.
+    arity = length(args)
+    {{kind, {name, arity}, meta, spec}, state}
+  end
+
+  # TODO: Remove char_list type by v2.0
+  defp built_in_type?(:char_list, 0), do: true
+  defp built_in_type?(:charlist, 0), do: true
+  defp built_in_type?(:as_boolean, 1), do: true
+  defp built_in_type?(:struct, 0), do: true
+  defp built_in_type?(:nonempty_charlist, 0), do: true
+  defp built_in_type?(:keyword, 0), do: true
+  defp built_in_type?(:keyword, 1), do: true
+  defp built_in_type?(:var, 0), do: true
+  defp built_in_type?(name, arity), do: :erl_internal.is_type(name, arity)
+
+  defp ensure_no_defaults!(args) do
+    fun = fn
+      {:"::", _, [left, right]} ->
+        ensure_not_default(left)
+        ensure_not_default(right)
+        left
+
+      other ->
+        ensure_not_default(other)
+        other
+    end
 
-  The module must have a corresponding beam file which can be
-  located by the runtime system.
-  """
-  @spec beam_specs(module | binary) :: [tuple] | nil
-  def beam_specs(module) when is_atom(module) or is_binary(module) do
-    from_abstract_code(module, :spec)
+    :lists.foreach(fun, args)
   end
 
-  @doc """
-  Returns all callbacks available from the module's beam code.
-
-  The result is returned as a list of tuples where the first
-  element is spec name and arity and the second is the spec.
-
-  The module must have a corresponding beam file
-  which can be located by the runtime system.
-  """
-  @spec beam_callbacks(module | binary) :: [tuple] | nil
-  def beam_callbacks(module) when is_atom(module) or is_binary(module) do
-    from_abstract_code(module, :callback)
+  defp ensure_not_default({:\\, _, [_, _]}) do
+    raise ArgumentError, "default arguments \\\\ not supported in typespecs"
   end
 
-  defp from_abstract_code(module, kind) do
-    case abstract_code(module) do
-      {:ok, abstract_code} ->
-        for {:attribute, _, abs_kind, value} <- abstract_code, kind == abs_kind, do: value
-      :error ->
-        nil
-    end
-  end
+  defp ensure_not_default(_), do: :ok
 
-  defp abstract_code(module) do
-    case :beam_lib.chunks(abstract_code_beam(module), [:abstract_code]) do
-      {:ok, {_, [{:abstract_code, {_raw_abstract_v1, abstract_code}}]}} ->
-        {:ok, abstract_code}
-      _ ->
-        :error
-    end
-  end
+  defp guard_to_constraints(guard, vars, meta, caller, state) do
+    location = location(meta)
+
+    fun = fn
+      {_name, {:var, _, context}}, {constraints, state} when is_atom(context) ->
+        {constraints, state}
 
-  defp abstract_code_beam(module) when is_atom(module) do
-    case :code.get_object_code(module) do
-      {^module, beam, _filename} -> beam
-      :error -> module
+      {name, type}, {constraints, state} ->
+        {spec, state} = typespec(type, vars, caller, state)
+        constraint = [{:atom, location, :is_subtype}, [{:var, location, name}, spec]]
+        state = update_local_vars(state, name)
+        {[{:type, location, :constraint, constraint} | constraints], state}
     end
-  end
 
-  defp abstract_code_beam(binary) when is_binary(binary) do
-    binary
+    {constraints, state} = :lists.foldl(fun, {[], state}, guard)
+    {:lists.reverse(constraints), state}
   end
 
-  ## Helpers
-
-  @doc false
-  def spec_to_signature({:when, _, [spec, _]}),
-    do: type_to_signature(spec)
-  def spec_to_signature(other),
-    do: type_to_signature(other)
+  ## To typespec conversion
 
-  @doc false
-  def type_to_signature({:::, _, [{name, _, nil}, _]}),
-    do: {name, 0}
-  def type_to_signature({:::, _, [{name, _, args}, _]}),
-    do: {name, length(args)}
+  defp location(meta) do
+    line = Keyword.get(meta, :line, 0)
 
-  ## Macro callbacks
+    if column = Keyword.get(meta, :column) do
+      {line, column}
+    else
+      line
+    end
+  end
 
-  @doc false
-  def defspec(kind, expr, caller) do
-    Module.store_typespec(caller.module, kind, {kind, expr, caller})
+  # Handle unions
+  defp typespec({:|, meta, [_, _]} = exprs, vars, caller, state) do
+    exprs = collect_union(exprs)
+    {union, state} = :lists.mapfoldl(&typespec(&1, vars, caller, &2), state, exprs)
+    {{:type, location(meta), :union, union}, state}
   end
 
-  @doc false
-  def deftype(kind, expr, caller) do
-    module = caller.module
-    doc    = Module.get_attribute(module, :typedoc)
+  # Handle binaries
+  defp typespec({:<<>>, meta, []}, _, _, state) do
+    location = location(meta)
+    {{:type, location, :binary, [{:integer, location, 0}, {:integer, location, 0}]}, state}
+  end
+
+  defp typespec(
+         {:<<>>, meta, [{:"::", unit_meta, [{:_, _, ctx1}, {:*, _, [{:_, _, ctx2}, unit]}]}]},
+         _,
+         _,
+         state
+       )
+       when is_atom(ctx1) and is_atom(ctx2) and unit in 1..256 do
+    location = location(meta)
+
+    {{:type, location, :binary, [{:integer, location, 0}, {:integer, location(unit_meta), unit}]},
+     state}
+  end
+
+  defp typespec(
+         {:<<>>, meta, [{:"::", _, [{:_, _, ctx1}, {:*, prod_meta, [size, unit]}]}]},
+         _,
+         _,
+         state
+       )
+       when is_atom(ctx1) and is_integer(size) and size >= 0 and unit in 1..256 do
+    location = location(meta)
+    prod_location = location(prod_meta)
+
+    {{:type, location, :binary,
+      [
+        {:op, prod_location, :*, {:integer, prod_location, size},
+         {:integer, prod_location, unit}},
+        {:integer, location, 0}
+      ]}, state}
+  end
+
+  defp typespec({:<<>>, meta, [{:"::", size_meta, [{:_, _, ctx}, size]}]}, _, _, state)
+       when is_atom(ctx) and is_integer(size) and size >= 0 do
+    location = location(meta)
+
+    {{:type, location, :binary, [{:integer, location(size_meta), size}, {:integer, location, 0}]},
+     state}
+  end
+
+  defp typespec(
+         {
+           :<<>>,
+           meta,
+           [
+             {:"::", size_meta, [{:_, _, ctx1}, size]},
+             {:"::", unit_meta, [{:_, _, ctx2}, {:*, _, [{:_, _, ctx3}, unit]}]}
+           ]
+         },
+         _,
+         _,
+         state
+       )
+       when is_atom(ctx1) and is_atom(ctx2) and is_atom(ctx3) and is_integer(size) and
+              size >= 0 and unit in 1..256 do
+    args = [{:integer, location(size_meta), size}, {:integer, location(unit_meta), unit}]
+    {{:type, location(meta), :binary, args}, state}
+  end
+
+  defp typespec({:<<>>, _meta, _args}, _vars, caller, _state) do
+    message =
+      "invalid binary specification, expected <<_::size>>, <<_::_*unit>>, " <>
+        "or <<_::size, _::_*unit>> with size being non-negative integers, and unit being an integer between 1 and 256"
+
+    compile_error(caller, message)
+  end
 
-    Module.delete_attribute(module, :typedoc)
-    Module.store_typespec(module, kind, {kind, expr, doc, caller})
+  ## Handle maps and structs
+  defp typespec({:map, meta, args}, _vars, _caller, state) when args == [] or is_atom(args) do
+    {{:type, location(meta), :map, :any}, state}
   end
 
-  ## Translation from Elixir AST to typespec AST
+  defp typespec({:%{}, meta, fields} = map, vars, caller, state) do
+    fun = fn
+      {{:required, meta2, [k]}, v}, state ->
+        {arg1, state} = typespec(k, vars, caller, state)
+        {arg2, state} = typespec(v, vars, caller, state)
+        {{:type, location(meta2), :map_field_exact, [arg1, arg2]}, state}
 
-  @doc false
-  def translate_type(kind, {:::, _, [{name, _, args}, definition]}, doc, caller) when is_atom(name) and name != ::: do
-    args =
-      if is_atom(args) do
-        []
-      else
-        for(arg <- args, do: variable(arg))
-      end
+      {{:optional, meta2, [k]}, v}, state ->
+        {arg1, state} = typespec(k, vars, caller, state)
+        {arg2, state} = typespec(v, vars, caller, state)
+        {{:type, location(meta2), :map_field_assoc, [arg1, arg2]}, state}
 
-    vars   = for {:var, _, var} <- args, do: var
-    spec   = typespec(definition, vars, caller)
+      {k, v}, state ->
+        {arg1, state} = typespec(k, vars, caller, state)
+        {arg2, state} = typespec(v, vars, caller, state)
+        {{:type, location(meta), :map_field_exact, [arg1, arg2]}, state}
 
-    vars   = for {:var, _, _} = var <- args, do: var
-    type   = {name, spec, vars}
-    arity  = length(vars)
+      {:|, _, [_, _]}, _state ->
+        error =
+          "invalid map specification. When using the | operator in the map key, " <>
+            "make sure to wrap the key type in parentheses: #{Macro.to_string(map)}"
 
-    {kind, export} =
-      case kind do
-        :type   -> {:type, true}
-        :typep  -> {:type, false}
-        :opaque -> {:opaque, true}
-      end
+        compile_error(caller, error)
 
-    if not export and doc do
-      :elixir_errors.warn(caller.line, caller.file, "type #{name}/#{arity} is private, " <>
-                          "@typedoc's are always discarded for private types\n")
+      _, _state ->
+        compile_error(caller, "invalid map specification: #{Macro.to_string(map)}")
     end
 
-    {{kind, {name, arity}, type}, caller.line, export, doc}
+    {fields, state} = :lists.mapfoldl(fun, state, fields)
+    {{:type, location(meta), :map, fields}, state}
   end
 
-  def translate_type(_kind, other, _doc, caller) do
-    type_spec = Macro.to_string(other)
-    compile_error caller, "invalid type specification: #{type_spec}"
-  end
+  defp typespec({:%, _, [name, {:%{}, meta, fields}]} = node, vars, caller, state) do
+    case Macro.expand(name, %{caller | function: {:__info__, 1}}) do
+      module when is_atom(module) ->
+        struct_info = Macro.struct_info!(module, caller)
 
-  @doc false
-  def translate_spec(kind, {:when, _meta, [spec, guard]}, caller) do
-    translate_spec(kind, spec, guard, caller)
-  end
+        if not Keyword.keyword?(fields) do
+          compile_error(caller, "expected key-value pairs in struct #{Macro.to_string(name)}")
+        end
 
-  def translate_spec(kind, spec, caller) do
-    translate_spec(kind, spec, [], caller)
-  end
+        types =
+          :lists.map(
+            fn %{field: field} ->
+              default_type = if field == :__exception__, do: true, else: quote(do: term())
+              {field, Keyword.get(fields, field, default_type)}
+            end,
+            struct_info
+          )
+
+        fun = fn {field, _} ->
+          if not Enum.any?(struct_info, &(&1.field == field)) do
+            compile_error(
+              caller,
+              "undefined field #{inspect(field)} on struct #{inspect(module)}"
+            )
+          end
+        end
 
-  defp translate_spec(kind, {:::, meta, [{name, _, args}, return]}, guard, caller) when is_atom(name) and name != ::: do
-    if is_atom(args), do: args = []
+        :lists.foreach(fun, fields)
+        typespec({:%{}, meta, [__struct__: module] ++ :lists.usort(types)}, vars, caller, state)
 
-    unless Keyword.keyword?(guard) do
-      guard = Macro.to_string(guard)
-      compile_error caller, "expected keywords as guard in function type specification, got: #{guard}"
+      _ ->
+        compile_error(
+          caller,
+          "unexpected expression in typespec: #{Macro.to_string(node)}"
+        )
     end
+  end
 
-    vars = Keyword.keys(guard)
-    constraints = guard_to_constraints(guard, vars, meta, caller)
+  # Handle records
+  defp typespec({:record, meta, [atom]}, vars, caller, state) do
+    typespec({:record, meta, [atom, []]}, vars, caller, state)
+  end
+
+  defp typespec({:record, meta, [name, field_specs]}, vars, caller, state)
+       when is_atom(name) and is_list(field_specs) do
+    # We cannot set a function name to avoid tracking
+    # as a compile time dependency because for records it actually is one.
+    case Macro.expand({name, [], [{:{}, [], []}]}, caller) do
+      {_, _, [tag, fields | _]} when is_list(fields) ->
+        types =
+          :lists.map(
+            fn {field, _} ->
+              {:"::", [],
+               [
+                 {field, [], nil},
+                 Keyword.get(field_specs, field, quote(do: term()))
+               ]}
+            end,
+            fields
+          )
+
+        fun = fn {field, _} ->
+          if not Keyword.has_key?(fields, field) do
+            compile_error(caller, "undefined field #{field} on record #{inspect(name)}")
+          end
+        end
 
-    spec = {:type, line(meta), :fun, fn_args(meta, args, return, vars, caller)}
-    if constraints != [] do
-      spec = {:type, line(meta), :bounded_fun, [spec, constraints]}
-    end
+        :lists.foreach(fun, field_specs)
+        typespec({:{}, meta, [tag | types]}, vars, caller, state)
 
-    arity = length(args)
-    {{kind, {name, arity}, spec}, caller.line}
+      _ ->
+        compile_error(caller, "unknown record #{inspect(name)}")
+    end
   end
 
-  defp translate_spec(_kind, spec, _guard, caller) do
-    spec = Macro.to_string(spec)
-    compile_error caller, "invalid function type specification: #{spec}"
+  defp typespec({:record, _meta, [_name, _field_specs]}, _vars, caller, _state) do
+    message = "invalid record specification, expected the record name to be an atom literal"
+    compile_error(caller, message)
   end
 
-  defp guard_to_constraints(guard, vars, meta, caller) do
-    line = line(meta)
+  # Handle ranges
+  defp typespec({:.., meta, [left, right]}, vars, caller, state) do
+    {left, state} = typespec(left, vars, caller, state)
+    {right, state} = typespec(right, vars, caller, state)
+    :ok = validate_range(left, right, caller)
 
-    :lists.foldl(fn
-      {_name, {:var, _, context}}, acc when is_atom(context) ->
-        acc
-      {name, type}, acc ->
-        constraint = [{:atom, line, :is_subtype}, [{:var, line, name}, typespec(type, vars, caller)]]
-        type = {:type, line, :constraint, constraint}
-        [type|acc]
-    end, [], guard) |> :lists.reverse
+    {{:type, location(meta), :range, [left, right]}, state}
   end
 
-  ## To AST conversion
-
-  defp collect_vars({:ann_type, _line, args}) when is_list(args) do
-    []
+  # Handle special forms
+  defp typespec({:__MODULE__, _, atom}, vars, caller, state) when is_atom(atom) do
+    typespec(caller.module, vars, caller, state)
   end
 
-  defp collect_vars({:type, _line, _kind, args}) when is_list(args) do
-    Enum.flat_map(args, &collect_vars/1)
+  defp typespec({:__aliases__, _, _} = alias, vars, caller, state) do
+    typespec(expand_remote(alias, caller), vars, caller, state)
   end
 
-  defp collect_vars({:remote_type, _line, args}) when is_list(args) do
-    Enum.flat_map(args, &collect_vars/1)
+  # Handle funs
+  defp typespec([{:->, meta, [args, return]}], vars, caller, state)
+       when is_list(args) do
+    {args, state} = fn_args(meta, args, vars, caller, state)
+    {spec, state} = typespec(return, vars, caller, state)
+    {{:type, location(meta), :fun, [args, spec]}, state}
   end
 
-  defp collect_vars({:typed_record_field, _line, type}) do
-    collect_vars(type)
+  # Handle type operator
+  defp typespec(
+         {:"::", meta, [{var_name, var_meta, context}, expr]} = ann_type,
+         vars,
+         caller,
+         state
+       )
+       when is_atom(var_name) and is_atom(context) do
+    case typespec(expr, vars, caller, state) do
+      {{:ann_type, _, _}, _state} ->
+        message =
+          "invalid type annotation. Type annotations cannot be nested: " <>
+            "#{Macro.to_string(ann_type)}"
+
+        # TODO: Make this an error on v2.0 and remove the code below
+        IO.warn(message, caller)
+
+        # This may be generating an invalid typespec but we need to generate it
+        # to avoid breaking existing code that was valid but only broke Dialyzer
+        {right, state} = typespec(expr, vars, caller, state)
+        {{:ann_type, location(meta), [{:var, location(var_meta), var_name}, right]}, state}
+
+      {right, state} ->
+        {{:ann_type, location(meta), [{:var, location(var_meta), var_name}, right]}, state}
+    end
   end
 
-  defp collect_vars({:paren_type, _line, [type]}) do
-    collect_vars(type)
-  end
+  defp typespec({:"::", meta, [left, right]}, vars, caller, state) do
+    message =
+      "invalid type annotation. The left side of :: must be a variable, got: #{Macro.to_string(left)}"
 
-  defp collect_vars({:var, _line, var}) do
-    [erl_to_ex_var(var)]
-  end
+    message =
+      case left do
+        {:|, _, _} ->
+          message <>
+            ". Note \"left | right :: ann\" is the same as \"(left | right) :: ann\". " <>
+            "To solve this, use parentheses around the union operands: \"left | (right :: ann)\""
 
-  defp collect_vars(_) do
-    []
-  end
+        _ ->
+          message
+      end
 
-  defp typespec_to_ast({:type, line, :tuple, :any}) do
-    {:tuple, [line: line], []}
-  end
+    # TODO: Make this an error on v2.0, and remove the code below and
+    # the :undefined_type_error_enabled? key from the state
+    IO.warn(message, caller)
 
-  defp typespec_to_ast({:type, line, :tuple, args}) do
-    args = for arg <- args, do: typespec_to_ast(arg)
-    {:{}, [line: line], args}
+    # This may be generating an invalid typespec but we need to generate it
+    # to avoid breaking existing code that was valid but only broke Dialyzer
+    state = %{state | undefined_type_error_enabled?: false}
+    {left, state} = typespec(left, vars, caller, state)
+    state = %{state | undefined_type_error_enabled?: true}
+    {right, state} = typespec(right, vars, caller, state)
+    {{:ann_type, location(meta), [left, right]}, state}
   end
 
-  defp typespec_to_ast({:type, _line, :list, [{:type, _, :union, unions} = arg]}) do
-    case unpack_typespec_kw(unions, []) do
-      {:ok, ast} -> ast
-      :error -> [typespec_to_ast(arg)]
+  # Handle unary ops
+  defp typespec({op, meta, [integer]}, _, _, state) when op in [:+, :-] and is_integer(integer) do
+    location = location(meta)
+    {{:op, location, op, {:integer, location, integer}}, state}
+  end
+
+  # Handle remote calls in the form of @module_attribute.type.
+  # These are not handled by the general remote type clause as calling
+  # Macro.expand/2 on the remote does not expand module attributes (but expands
+  # things like __MODULE__).
+  defp typespec(
+         {{:., meta, [{:@, _, [{attr, _, _}]}, name]}, _, args} = orig,
+         vars,
+         caller,
+         state
+       ) do
+    remote = Module.get_attribute(caller.module, attr)
+
+    if not (is_atom(remote) and remote != nil) do
+      message =
+        "invalid remote in typespec: #{Macro.to_string(orig)} (@#{attr} is #{inspect(remote)})"
+
+      compile_error(caller, message)
     end
-  end
 
-  defp typespec_to_ast({:type, _line, :list, args}) do
-    for arg <- args, do: typespec_to_ast(arg)
+    {remote_spec, state} = typespec(remote, vars, caller, state)
+    {name_spec, state} = typespec(name, vars, caller, state)
+    type = {remote_spec, meta, name_spec, args}
+    remote_type(type, vars, caller, state)
   end
 
-  defp typespec_to_ast({:type, line, :map, fields}) do
-    fields = Enum.map fields, fn {:type, _, :map_field_assoc, k, v} ->
-      {typespec_to_ast(k), typespec_to_ast(v)}
-    end
+  # Handle remote calls
+  defp typespec({{:., meta, [remote, name]}, _, args} = orig, vars, caller, state) do
+    remote = expand_remote(remote, caller)
 
-    {struct, fields} = Keyword.pop(fields, :__struct__)
-    map = {:%{}, [line: line], fields}
+    cond do
+      not is_atom(remote) ->
+        compile_error(caller, "invalid remote in typespec: #{Macro.to_string(orig)}")
 
-    if struct do
-      {:%, [line: line], [struct, map]}
-    else
-      map
-    end
-  end
+      remote == caller.module ->
+        typespec({name, meta, args}, vars, caller, state)
 
-  defp typespec_to_ast({:type, line, :binary, [arg1, arg2]}) do
-    [arg1, arg2] = for arg <- [arg1, arg2], do: typespec_to_ast(arg)
-    cond do
-      arg2 == 0 ->
-        quote line: line, do: <<_ :: unquote(arg1)>>
-      arg1 == 0 ->
-        quote line: line, do: <<_ :: _ * unquote(arg2)>>
       true ->
-        quote line: line, do: <<_ :: unquote(arg1) * unquote(arg2)>>
+        {remote_spec, state} = typespec(remote, vars, caller, state)
+        {name_spec, state} = typespec(name, vars, caller, state)
+        type = {remote_spec, meta, name_spec, args}
+        remote_type(type, vars, caller, state)
     end
   end
 
-  defp typespec_to_ast({:type, line, :union, args}) do
-    args = for arg <- args, do: typespec_to_ast(arg)
-    Enum.reduce Enum.reverse(args), fn(arg, expr) -> {:|, [line: line], [arg, expr]} end
+  # Handle tuples
+  defp typespec({:tuple, meta, []}, _vars, _caller, state) do
+    {{:type, location(meta), :tuple, :any}, state}
   end
 
-  defp typespec_to_ast({:type, line, :fun, [{:type, _, :product, args}, result]}) do
-    args = for arg <- args, do: typespec_to_ast(arg)
-    [{:->, [line: line], [args, typespec_to_ast(result)]}]
+  defp typespec({:{}, meta, t}, vars, caller, state) when is_list(t) do
+    {args, state} = :lists.mapfoldl(&typespec(&1, vars, caller, &2), state, t)
+    {{:type, location(meta), :tuple, args}, state}
   end
 
-  defp typespec_to_ast({:type, line, :fun, [args, result]}) do
-    [{:->, [line: line], [[typespec_to_ast(args)], typespec_to_ast(result)]}]
+  defp typespec({left, right}, vars, caller, state) do
+    typespec({:{}, [], [left, right]}, vars, caller, state)
   end
 
-  defp typespec_to_ast({:type, line, :fun, []}) do
-    typespec_to_ast({:type, line, :fun, [{:type, line, :any}, {:type, line, :any, []} ]})
+  # Handle blocks
+  defp typespec({:__block__, _meta, [arg]}, vars, caller, state) do
+    typespec(arg, vars, caller, state)
   end
 
-  defp typespec_to_ast({:type, line, :range, [left, right]}) do
-    {:"..", [line: line], [typespec_to_ast(left), typespec_to_ast(right)]}
+  # Handle variables or local calls
+  defp typespec({name, meta, atom}, vars, caller, state) when is_atom(atom) do
+    if :lists.member(name, vars) do
+      state = update_local_vars(state, name)
+      {{:var, location(meta), name}, state}
+    else
+      typespec({name, meta, []}, vars, caller, state)
+    end
   end
 
-  defp typespec_to_ast({:type, line, name, args}) do
-    args = for arg <- args, do: typespec_to_ast(arg)
-    {name, [line: line], args}
-  end
+  # Handle local calls
+  defp typespec({:string, meta, args}, vars, caller, state) do
+    warning =
+      "string() type use is discouraged. " <>
+        "For character lists, use charlist() type, for strings, String.t()\n" <>
+        Exception.format_stacktrace(Macro.Env.stacktrace(caller))
 
-  defp typespec_to_ast({:var, line, var}) do
-    {erl_to_ex_var(var), line, nil}
+    IO.warn(warning, caller)
+    {args, state} = :lists.mapfoldl(&typespec(&1, vars, caller, &2), state, args)
+    {{:type, location(meta), :string, args}, state}
   end
 
-  defp typespec_to_ast({:op, line, op, arg}) do
-    {op, [line: line], [typespec_to_ast(arg)]}
-  end
+  defp typespec({:nonempty_string, meta, args}, vars, caller, state) do
+    warning =
+      "nonempty_string() type use is discouraged. " <>
+        "For non-empty character lists, use nonempty_charlist() type, for strings, String.t()\n" <>
+        Exception.format_stacktrace(Macro.Env.stacktrace(caller))
 
-  # Special shortcut(s)
-  defp typespec_to_ast({:remote_type, line, [{:atom, _, :elixir}, {:atom, _, :char_list}, []]}) do
-    typespec_to_ast({:type, line, :char_list, []})
+    IO.warn(warning, caller)
+    {args, state} = :lists.mapfoldl(&typespec(&1, vars, caller, &2), state, args)
+    {{:type, location(meta), :nonempty_string, args}, state}
   end
 
-  defp typespec_to_ast({:remote_type, line, [{:atom, _, :elixir}, {:atom, _, :as_boolean}, [arg]]}) do
-    typespec_to_ast({:type, line, :as_boolean, [arg]})
+  defp typespec({type, _meta, []}, vars, caller, state) when type in [:charlist, :char_list] do
+    if type == :char_list do
+      warning = "the char_list() type is deprecated, use charlist()"
+      IO.warn(warning, caller)
+    end
+
+    typespec(quote(do: :elixir.charlist()), vars, caller, state)
   end
 
-  defp typespec_to_ast({:remote_type, line, [mod, name, args]}) do
-    args = for arg <- args, do: typespec_to_ast(arg)
-    dot  = {:., [line: line], [typespec_to_ast(mod), typespec_to_ast(name)]}
-    {dot, [line: line], args}
+  defp typespec({:nonempty_charlist, _meta, []}, vars, caller, state) do
+    typespec(quote(do: :elixir.nonempty_charlist()), vars, caller, state)
   end
 
-  defp typespec_to_ast({:ann_type, line, [var, type]}) do
-    {:::, [line: line], [typespec_to_ast(var), typespec_to_ast(type)]}
+  defp typespec({:struct, _meta, []}, vars, caller, state) do
+    typespec(quote(do: :elixir.struct()), vars, caller, state)
   end
 
-  defp typespec_to_ast({:typed_record_field,
-                         {:record_field, line, {:atom, line1, name}},
-                         type}) do
-    typespec_to_ast({:ann_type, line, [{:var, line1, name}, type]})
+  defp typespec({:as_boolean, _meta, [arg]}, vars, caller, state) do
+    typespec(quote(do: :elixir.as_boolean(unquote(arg))), vars, caller, state)
   end
 
-  defp typespec_to_ast({:type, _, :any}) do
-    quote do: ...
+  defp typespec({:keyword, _meta, args}, vars, caller, state) when length(args) <= 1 do
+    typespec(quote(do: :elixir.keyword(unquote_splicing(args))), vars, caller, state)
   end
 
-  defp typespec_to_ast({:paren_type, _, [type]}) do
-    typespec_to_ast(type)
+  defp typespec({:fun, meta, args}, vars, caller, state) do
+    {args, state} = :lists.mapfoldl(&typespec(&1, vars, caller, &2), state, args)
+
+    if args != [] do
+      IO.warn(
+        "fun/#{length(args)} is not valid in typespecs. Either specify fun() or use (... -> return) instead",
+        caller
+      )
+    end
+
+    {{:type, location(meta), :fun, []}, state}
   end
 
-  defp typespec_to_ast({t, _line, atom}) when is_atom(t) do
-    atom
+  defp typespec({:..., _meta, _args}, _vars, caller, _state) do
+    compile_error(
+      caller,
+      "... in typespecs is only allowed inside lists, as in [term(), ...], " <>
+        "or inside functions, as in (... -> term())"
+    )
   end
 
-  defp typespec_to_ast(other), do: other
+  defp typespec({name, meta, args}, vars, caller, state) when is_atom(name) do
+    {args, state} = :lists.mapfoldl(&typespec(&1, vars, caller, &2), state, args)
+    arity = length(args)
 
-  defp erl_to_ex_var(var) do
-    case Atom.to_string(var) do
-      <<"_", c :: [binary, size(1)], rest :: binary>> ->
-        String.to_atom("_#{String.downcase(c)}#{rest}")
-      <<c :: [binary, size(1)], rest :: binary>> ->
-        String.to_atom("#{String.downcase(c)}#{rest}")
-    end
-  end
+    case :erl_internal.is_type(name, arity) do
+      true ->
+        {{:type, location(meta), name, args}, state}
+
+      false ->
+        if state.undefined_type_error_enabled? and
+             not Map.has_key?(state.defined_type_pairs, {name, arity}) do
+          compile_error(
+            caller,
+            "type #{name}/#{arity} undefined (no such type in #{inspect(caller.module)})"
+          )
+        end
 
-  ## To typespec conversion
+        state =
+          if :lists.member({name, arity}, state.used_type_pairs) do
+            state
+          else
+            %{state | used_type_pairs: [{name, arity} | state.used_type_pairs]}
+          end
 
-  defp line(meta) do
-    case :lists.keyfind(:line, 1, meta) do
-      {:line, line} -> line
-      false -> 0
+        {{:user_type, location(meta), name, args}, state}
     end
   end
 
-  # Handle unions
-  defp typespec({:|, meta, [_, _]} = exprs, vars, caller) do
-    exprs = collect_union(exprs)
-    union = for e <- exprs, do: typespec(e, vars, caller)
-    {:type, line(meta), :union, union}
+  # Handle literals
+  defp typespec(atom, _, _, state) when is_atom(atom) do
+    {{:atom, 0, atom}, state}
   end
 
-  # Handle binaries
-  defp typespec({:<<>>, meta, []}, _, _) do
-    {:type, line(meta), :binary, [{:integer, line(meta), 0}, {:integer, line(meta), 0}]}
+  defp typespec(integer, _, _, state) when is_integer(integer) do
+    {{:integer, 0, integer}, state}
   end
 
-  defp typespec({:<<>>, meta, [{:::, _, [{:_, meta1, atom}, {:*, _, [{:_, meta2, atom}, unit]}]}]}, _, _) when is_atom(atom) do
-    {:type, line(meta), :binary, [{:integer, line(meta1), 0}, {:integer, line(meta2), unit}]}
+  defp typespec([], vars, caller, state) do
+    typespec({nil, [], []}, vars, caller, state)
   end
 
-  defp typespec({:<<>>, meta, [{:::, meta1, [{:_, meta2, atom}, base]}]}, _, _) when is_atom(atom) do
-    {:type, line(meta), :binary, [{:integer, line(meta1), base}, {:integer, line(meta2), 0}]}
+  defp typespec([{:..., _, _}], vars, caller, state) do
+    typespec({:nonempty_list, [], []}, vars, caller, state)
   end
 
-  ## Handle maps and structs
-  defp typespec({:%{}, meta, fields}, vars, caller) do
-    fields = :lists.map(fn {k, v} ->
-      {:type, line(meta), :map_field_assoc, typespec(k, vars, caller), typespec(v, vars, caller)}
-    end, fields)
-    {:type, line(meta), :map, fields}
+  defp typespec([spec, {:..., _, _}], vars, caller, state) do
+    typespec({:nonempty_list, [], [spec]}, vars, caller, state)
   end
 
-  defp typespec({:%, _, [name, {:%{}, meta, fields}]}, vars, caller) do
-    typespec({:%{}, meta, [{:__struct__, name}|fields]}, vars, caller)
+  defp typespec([spec], vars, caller, state) do
+    typespec({:list, [], [spec]}, vars, caller, state)
   end
 
-  # Handle ranges
-  defp typespec({:.., meta, args}, vars, caller) do
-    typespec({:range, meta, args}, vars, caller)
-  end
+  defp typespec(list, vars, caller, state) when is_list(list) do
+    [head | tail] = :lists.reverse(list)
 
-  # Handle special forms
-  defp typespec({:__MODULE__, _, atom}, vars, caller) when is_atom(atom) do
-    typespec(caller.module, vars, caller)
-  end
+    union =
+      :lists.foldl(
+        fn elem, acc -> {:|, [], [validate_kw(elem, list, caller), acc]} end,
+        validate_kw(head, list, caller),
+        tail
+      )
 
-  defp typespec({:__aliases__, _, _} = alias, vars, caller) do
-    atom = Macro.expand alias, caller
-    typespec(atom, vars, caller)
+    typespec({:list, [], [union]}, vars, caller, state)
   end
 
-  # Handle funs
-  defp typespec([{:->, meta, [arguments, return]}], vars, caller) when is_list(arguments) do
-    args = fn_args(meta, arguments, return, vars, caller)
-    {:type, line(meta), :fun, args}
+  defp typespec(other, _vars, caller, _state) do
+    compile_error(caller, "unexpected expression in typespec: #{Macro.to_string(other)}")
   end
 
-  # Handle type operator
-  defp typespec({:::, meta, [var, expr]}, vars, caller) do
-    left  = typespec(var, [elem(var, 0)|vars], caller)
-    right = typespec(expr, vars, caller)
-    {:ann_type, line(meta), [left, right]}
-  end
+  ## Helpers
 
-  # Handle unary ops
-  defp typespec({op, meta, [integer]}, _, _) when op in [:+, :-] and is_integer(integer) do
-    {:op, line(meta), op, {:integer, line(meta), integer}}
-  end
+  # This is a modified backport of Macro.expand/2 because we want to expand
+  # aliases but we don't them to become compile-time references.
+  defp expand_remote({:__aliases__, meta, list} = alias, env) do
+    case :elixir_aliases.expand_or_concat(meta, list, env, true) do
+      receiver when is_atom(receiver) ->
+        receiver
 
-  # Handle remote calls
-  defp typespec({{:., meta, [remote, name]}, _, args} = orig, vars, caller) do
-    remote = Macro.expand remote, caller
-    unless is_atom(remote) do
-      compile_error(caller, "invalid remote in typespec: #{Macro.to_string(orig)}")
+      [head | tail] ->
+        case Macro.expand(head, env) do
+          head when is_atom(head) ->
+            :elixir_aliases.concat([head | tail])
+
+          _ ->
+            compile_error(env, "unexpected expression in typespec: #{Macro.to_string(alias)}")
+        end
     end
-    remote_type({typespec(remote, vars, caller), meta, typespec(name, vars, caller), args}, vars, caller)
   end
 
-  # Handle tuples
-  defp typespec({:tuple, meta, args}, _vars, _caller) when args == [] or is_atom(args) do
-    {:type, line(meta), :tuple, :any}
-  end
+  defp expand_remote(other, env), do: Macro.expand(other, env)
 
-  defp typespec({:{}, meta, t}, vars, caller) when is_list(t) do
-    args = for e <- t, do: typespec(e, vars, caller)
-    {:type, line(meta), :tuple, args}
+  defp compile_error(caller, desc) do
+    raise Kernel.TypespecError, file: caller.file, line: caller.line, description: desc
   end
 
-  defp typespec({left, right}, vars, caller) do
-    typespec({:{}, [], [left, right]}, vars, caller)
+  defp remote_type({remote, meta, name, args}, vars, caller, state) do
+    {args, state} = :lists.mapfoldl(&typespec(&1, vars, caller, &2), state, args)
+    {{:remote_type, location(meta), [remote, name, args]}, state}
   end
 
-  # Handle blocks
-  defp typespec({:__block__, _meta, [arg]}, vars, caller) do
-    typespec(arg, vars, caller)
-  end
+  defp collect_union({:|, _, [a, b]}), do: [a | collect_union(b)]
+  defp collect_union(v), do: [v]
 
-  # Handle variables or local calls
-  defp typespec({name, meta, atom}, vars, caller) when is_atom(atom) do
-    if :lists.member(name, vars) do
-      {:var, line(meta), name}
-    else
-      typespec({name, meta, []}, vars, caller)
-    end
-  end
+  defp validate_kw({key, _} = t, _, _caller) when is_atom(key), do: t
 
-  # Handle local calls
-  defp typespec({:string, meta, arguments}, vars, caller) do
-    :elixir_errors.warn caller.line, caller.file, "string() type use is discouraged. For character lists, use " <>
-      "char_list() type, for strings, String.t()\n#{Exception.format_stacktrace(Macro.Env.stacktrace(caller))}"
-    arguments = for arg <- arguments, do: typespec(arg, vars, caller)
-    {:type, line(meta), :string, arguments}
+  defp validate_kw(_, original, caller) do
+    compile_error(caller, "unexpected list in typespec: #{Macro.to_string(original)}")
   end
 
-  defp typespec({:char_list, _meta, []}, vars, caller) do
-    typespec((quote do: :elixir.char_list()), vars, caller)
+  defp validate_range({:op, _, :-, {:integer, meta, first}}, last, caller) do
+    validate_range({:integer, meta, -first}, last, caller)
   end
 
-  defp typespec({:as_boolean, _meta, [arg]}, vars, caller) do
-    typespec((quote do: :elixir.as_boolean(unquote(arg))), vars, caller)
+  defp validate_range(first, {:op, _, :-, {:integer, meta, last}}, caller) do
+    validate_range(first, {:integer, meta, -last}, caller)
   end
 
-  defp typespec({name, meta, arguments}, vars, caller) do
-    arguments = for arg <- arguments, do: typespec(arg, vars, caller)
-    {:type, line(meta), name, arguments}
+  defp validate_range({:integer, _, first}, {:integer, _, last}, _caller) when first < last do
+    :ok
   end
 
-  # Handle literals
-  defp typespec(atom, _, _) when is_atom(atom) do
-    {:atom, 0, atom}
-  end
+  defp validate_range(_, _, caller) do
+    message =
+      "invalid range specification, expected both sides to be integers, " <>
+        "with the left side lower than the right side"
 
-  defp typespec(integer, _, _) when is_integer(integer) do
-    {:integer, 0, integer}
+    compile_error(caller, message)
   end
 
-  defp typespec([], vars, caller) do
-    typespec({nil, [], []}, vars, caller)
+  defp fn_args(meta, [{:..., _, _}], _vars, _caller, state) do
+    {{:type, location(meta), :any}, state}
   end
 
-  defp typespec([spec], vars, caller) do
-    typespec({:list, [], [spec]}, vars, caller)
+  defp fn_args(meta, args, vars, caller, state) do
+    {args, state} = :lists.mapfoldl(&typespec(&1, vars, caller, &2), state, args)
+    {{:type, location(meta), :product, args}, state}
   end
 
-  defp typespec([spec, {:"...", _, quoted}], vars, caller) when is_atom(quoted) do
-    typespec({:nonempty_list, [], [spec]}, vars, caller)
+  defp variable({name, meta, args}) when is_atom(name) and is_atom(args) do
+    {:var, location(meta), name}
   end
 
-  defp typespec(list, vars, caller) do
-    [h|t] = :lists.reverse(list)
-    union = :lists.foldl(fn(x, acc) ->
-      {:|, [], [validate_kw(x, list, caller), acc]}
-    end, validate_kw(h, list, caller), t)
-    typespec({:list, [], [union]}, vars, caller)
-  end
-
-  ## Helpers
+  defp variable(expr), do: expr
 
-  defp compile_error(caller, desc) do
-    raise CompileError, file: caller.file, line: caller.line, description: desc
+  defp clean_local_state(state) do
+    %{state | local_vars: %{}}
   end
 
-  defp remote_type({remote, meta, name, arguments}, vars, caller) do
-    arguments = for arg <- arguments, do: typespec(arg, vars, caller)
-    {:remote_type, line(meta), [ remote, name, arguments ]}
+  defp update_local_vars(%{local_vars: local_vars} = state, var_name) do
+    case Map.fetch(local_vars, var_name) do
+      {:ok, :used_once} -> %{state | local_vars: Map.put(local_vars, var_name, :used_multiple)}
+      {:ok, :used_multiple} -> state
+      :error -> %{state | local_vars: Map.put(local_vars, var_name, :used_once)}
+    end
   end
 
-  defp collect_union({:|, _, [a, b]}), do: [a|collect_union(b)]
-  defp collect_union(v), do: [v]
-
-  defp validate_kw({key, _} = t, _, _caller) when is_atom(key), do: t
-  defp validate_kw(_, original, caller) do
-    compile_error(caller, "unexpected list in typespec: #{Macro.to_string original}")
-  end
+  defp ensure_no_underscore_local_vars!(caller, var_names) do
+    case :lists.member(:_, var_names) do
+      true ->
+        compile_error(caller, "type variable '_' is invalid")
 
-  defp fn_args(meta, args, return, vars, caller) do
-    case [fn_args(meta, args, vars, caller), typespec(return, vars, caller)] do
-      [{:type, _, :any}, {:type, _, :any, []}] -> []
-      x -> x
+      false ->
+        :ok
     end
   end
 
-  defp fn_args(meta, [{:"...", _, _}], _vars, _caller) do
-    {:type, line(meta), :any}
-  end
+  defp ensure_no_unused_local_vars!(caller, local_vars) do
+    fun = fn {name, used_times} ->
+      case {:erlang.atom_to_list(name), used_times} do
+        {[?_ | _], :used_once} ->
+          :ok
 
-  defp fn_args(meta, args, vars, caller) do
-    args = for arg <- args, do: typespec(arg, vars, caller)
-    {:type, line(meta), :product, args}
-  end
+        {[?_ | _], :used_multiple} ->
+          warning =
+            "the underscored type variable \"#{name}\" is used more than once in the " <>
+              "type specification. A leading underscore indicates that the value of the " <>
+              "variable should be ignored. If this is intended please rename the variable to " <>
+              "remove the underscore"
 
-  defp variable({name, meta, _}) do
-    {:var, line(meta), name}
-  end
+          IO.warn(warning, caller)
 
-  defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]}|t], acc) do
-    unpack_typespec_kw(t, [{atom, typespec_to_ast(type)}|acc])
-  end
+        {_, :used_once} ->
+          compile_error(
+            caller,
+            "type variable #{name} is used only once. Type variables in typespecs " <>
+              "must be referenced at least twice, otherwise it is equivalent to term()"
+          )
 
-  defp unpack_typespec_kw([], acc) do
-    {:ok, :lists.reverse(acc)}
-  end
+        _ ->
+          :ok
+      end
+    end
 
-  defp unpack_typespec_kw(_, _acc) do
-    :error
+    :lists.foreach(fun, :maps.to_list(local_vars))
   end
 end
diff --git a/lib/elixir/lib/kernel/utils.ex b/lib/elixir/lib/kernel/utils.ex
new file mode 100644
index 00000000000..2989a0daae5
--- /dev/null
+++ b/lib/elixir/lib/kernel/utils.ex
@@ -0,0 +1,421 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+import Kernel, except: [destructure: 2, defdelegate: 2, defstruct: 2]
+
+defmodule Kernel.Utils do
+  @moduledoc false
+
+  @doc """
+  Callback for destructure.
+  """
+  def destructure(list, count)
+      when is_list(list) and is_integer(count) and count >= 0,
+      do: destructure_list(list, count)
+
+  def destructure(nil, count)
+      when is_integer(count) and count >= 0,
+      do: destructure_nil(count)
+
+  defp destructure_list(_, 0), do: []
+  defp destructure_list([], count), do: destructure_nil(count)
+  defp destructure_list([h | t], count), do: [h | destructure_list(t, count - 1)]
+
+  defp destructure_nil(0), do: []
+  defp destructure_nil(count), do: [nil | destructure_nil(count - 1)]
+
+  @doc """
+  Callback for defdelegate entry point.
+  """
+  def defdelegate_all(funs, opts, env) do
+    to = Keyword.get(opts, :to) || raise ArgumentError, "expected to: to be given as argument"
+    as = Keyword.get(opts, :as)
+
+    if to == env.module and is_nil(as) do
+      raise ArgumentError,
+            "defdelegate function is calling itself, which will lead to an infinite loop. You should either change the value of the :to option or specify the :as option"
+    end
+
+    if is_list(funs) do
+      IO.warn(
+        "passing a list to Kernel.defdelegate/2 is deprecated, please define each delegate separately",
+        env
+      )
+    end
+
+    if Keyword.has_key?(opts, :append_first) do
+      IO.warn(
+        "Kernel.defdelegate/2 :append_first option is deprecated",
+        env
+      )
+    end
+
+    to
+  end
+
+  @doc """
+  Callback for each function in defdelegate.
+  """
+  def defdelegate_each(fun, opts) when is_list(opts) do
+    # TODO: Remove on v2.0
+    append_first? = Keyword.get(opts, :append_first, false)
+
+    {name, args} =
+      case fun do
+        {:when, _, [_left, right]} ->
+          raise ArgumentError,
+                "guards are not allowed in defdelegate/2, got: when #{Macro.to_string(right)}"
+
+        _ ->
+          case Macro.decompose_call(fun) do
+            {_, _} = pair -> pair
+            _ -> raise ArgumentError, "invalid syntax in defdelegate #{Macro.to_string(fun)}"
+          end
+      end
+
+    as = Keyword.get(opts, :as, name)
+    as_args = build_as_args(args, append_first?)
+
+    {name, args, as, as_args}
+  end
+
+  defp build_as_args(args, append_first?) do
+    as_args = :lists.map(&build_as_arg/1, args)
+
+    case append_first? do
+      true -> tl(as_args) ++ [hd(as_args)]
+      false -> as_args
+    end
+  end
+
+  defp build_as_arg({:\\, _, [arg, _default_arg]}), do: validate_arg(arg)
+  defp build_as_arg(arg), do: validate_arg(arg)
+
+  defp validate_arg({name, _, mod} = arg) when is_atom(name) and is_atom(mod) do
+    arg
+  end
+
+  defp validate_arg(ast) do
+    raise ArgumentError,
+          "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(ast)}"
+  end
+
+  @doc """
+  Callback for defstruct.
+  """
+  def defstruct(module, fields, bootstrapped?, env) do
+    {set, bag} = :elixir_module.data_tables(module)
+
+    if :ets.member(set, {:elixir, :struct}) do
+      raise ArgumentError,
+            "defstruct has already been called for " <>
+              "#{Kernel.inspect(module)}, defstruct can only be called once per module"
+    end
+
+    case fields do
+      fs when is_list(fs) ->
+        :ok
+
+      other ->
+        raise ArgumentError, "struct fields definition must be list, got: #{inspect(other)}"
+    end
+
+    mapper = fn
+      {key, val} when is_atom(key) ->
+        key == :__struct__ and raise(ArgumentError, "cannot set :__struct__ in struct definition")
+
+        try do
+          :elixir_quote.escape(val, {:struct, module}, false)
+        rescue
+          e in [ArgumentError] ->
+            raise ArgumentError,
+                  "invalid default value for struct field #{key}, " <> Exception.message(e)
+        else
+          _ -> {key, val}
+        end
+
+      key when is_atom(key) ->
+        key == :__struct__ and raise(ArgumentError, "cannot set :__struct__ in struct definition")
+        {key, nil}
+
+      other ->
+        raise ArgumentError, "struct field names must be atoms, got: #{inspect(other)}"
+    end
+
+    fields = :lists.map(mapper, fields)
+
+    enforce_keys =
+      case :ets.lookup(set, :enforce_keys) do
+        [{_, enforce_keys, _, _}] when is_list(enforce_keys) ->
+          :ets.update_element(set, :enforce_keys, {3, :used})
+          enforce_keys
+
+        [{_, enforce_key, _, _}] ->
+          :ets.update_element(set, :enforce_keys, {3, :used})
+          [enforce_key]
+
+        [] ->
+          []
+      end
+
+    # TODO: Make it raise on v2.0
+    warn_on_duplicate_struct_key(:lists.keysort(1, fields), env)
+
+    foreach = fn
+      key when is_atom(key) ->
+        :ok
+
+      key ->
+        raise ArgumentError, "keys given to @enforce_keys must be atoms, got: #{inspect(key)}"
+    end
+
+    :lists.foreach(foreach, enforce_keys)
+    struct = :maps.from_list([__struct__: module] ++ fields)
+    escaped_struct = :elixir_quote.escape(struct, {:struct, module}, false)
+
+    body =
+      case bootstrapped? do
+        true ->
+          case enforce_keys do
+            [] ->
+              quote line: 0, generated: true do
+                Enum.reduce(kv, unquote(escaped_struct), fn {key, val}, map ->
+                  %{map | key => val}
+                end)
+              end
+
+            _ ->
+              quote line: 0, generated: true do
+                {map, keys} =
+                  Enum.reduce(kv, {unquote(escaped_struct), unquote(enforce_keys)}, fn
+                    {key, val}, {map, keys} ->
+                      {%{map | key => val}, List.delete(keys, key)}
+                  end)
+
+                case keys do
+                  [] ->
+                    map
+
+                  _ ->
+                    raise ArgumentError,
+                          "the following keys must also be given when building " <>
+                            "struct #{inspect(__MODULE__)}: #{inspect(keys)}"
+                end
+              end
+          end
+
+        false ->
+          quote line: 0, generated: true do
+            :lists.foldl(
+              fn {key, val}, acc -> %{acc | key => val} end,
+              unquote(escaped_struct),
+              kv
+            )
+          end
+      end
+
+    case enforce_keys -- :maps.keys(struct) do
+      [] ->
+        mapper = fn {key, val} ->
+          %{field: key, default: val, required: :lists.member(key, enforce_keys)}
+        end
+
+        :ets.insert(set, {{:elixir, :struct}, :lists.map(mapper, fields)})
+        derive = :lists.map(fn {_, value} -> value end, :ets.take(bag, {:accumulate, :derive}))
+        {struct, :lists.reverse(derive), escaped_struct, quote(do: kv), body}
+
+      error_keys ->
+        raise ArgumentError,
+              "@enforce_keys required keys (#{inspect(error_keys)}) that are not defined in defstruct: " <>
+                "#{inspect(fields)}"
+    end
+  end
+
+  defp warn_on_duplicate_struct_key([], _) do
+    :ok
+  end
+
+  defp warn_on_duplicate_struct_key([{key, _} | [{key, _} | _] = rest], env) do
+    IO.warn("duplicate key #{inspect(key)} found in struct", env)
+    warn_on_duplicate_struct_key(rest, env)
+  end
+
+  defp warn_on_duplicate_struct_key([_ | rest], env) do
+    warn_on_duplicate_struct_key(rest, env)
+  end
+
+  @doc """
+  Announcing callback for defstruct.
+  """
+  def announce_struct(module) do
+    case :erlang.get(:elixir_compiler_info) do
+      :undefined -> :ok
+      {pid, _} -> send(pid, {:available, :struct, module})
+    end
+  end
+
+  @doc """
+  Callback for raise.
+  """
+  def raise(msg) when is_binary(msg) do
+    RuntimeError.exception(msg)
+  end
+
+  def raise(module) when is_atom(module) do
+    module.exception([])
+  end
+
+  def raise(%_{__exception__: true} = exception) do
+    exception
+  end
+
+  def raise(other) do
+    ArgumentError.exception(
+      "raise/1 and reraise/2 expect a module name, string or exception " <>
+        "as the first argument, got: #{inspect(other)}"
+    )
+  end
+
+  @doc """
+  Callback for defguard.
+
+  Rewrites an expression so it can be used both inside and outside a guard.
+
+  Take, for example, the expression:
+
+      is_integer(value) and rem(value, 2) == 0
+
+  If we wanted to create a macro, `is_even`, from this expression, that could be
+  used in guards, we'd have to take several things into account.
+
+  First, if this expression is being used inside a guard, `value` needs to be
+  unquoted each place it occurs, since it has not yet been at that point in our
+  macro.
+
+  Secondly, if the expression is being used outside of a guard, we want to unquote
+  `value`, but only once, and then reuse the unquoted form throughout the expression.
+
+  This helper does exactly that: takes the AST for an expression and a list of
+  variable references it should be aware of, and rewrites it into a new expression
+  that checks for its presence in a guard, then unquotes the variable references as
+  appropriate.
+
+  The following code
+
+      expression = quote do: is_integer(value) and rem(value, 2) == 0
+      variable_references = [value: Elixir]
+      Kernel.Utils.defguard(expression, variable_references) |> Macro.to_string() |> IO.puts()
+
+  would print a code similar to:
+
+      case Macro.Env.in_guard?(__CALLER__) do
+        true ->
+          quote do
+            is_integer(unquote(value)) and rem(unquote(value), 2) == 0
+          end
+
+        false ->
+          quote do
+            value = unquote(value)
+            is_integer(value) and rem(value, 2) == 0
+          end
+      end
+
+  """
+  defmacro defguard(args, expr) do
+    defguard(args, expr, __CALLER__)
+  end
+
+  @spec defguard([Macro.t()], Macro.t(), Macro.Env.t()) :: Macro.t()
+  def defguard(args, expr, env) do
+    {^args, vars} = extract_refs_from_args(args)
+    env = :elixir_env.with_vars(%{env | context: :guard}, vars)
+    {expr, _, _} = :elixir_expand.expand(expr, :elixir_env.env_to_ex(env), env)
+
+    quote do
+      case Macro.Env.in_guard?(__CALLER__) do
+        true ->
+          unquote(literal_quote(unquote_every_ref(expr, vars), []))
+
+        false ->
+          unquote(literal_quote(unquote_refs_once(expr, vars, env.module), generated: true))
+      end
+    end
+  end
+
+  defp extract_refs_from_args(args) do
+    Macro.postwalk(args, [], fn
+      {ref, meta, context} = var, acc when is_atom(ref) and is_atom(context) ->
+        {var, [{ref, var_context(meta, context)} | acc]}
+
+      node, acc ->
+        {node, acc}
+    end)
+  end
+
+  # Finds every reference to `refs` in `guard` and wraps them in an unquote.
+  defp unquote_every_ref(guard, refs) do
+    Macro.postwalk(guard, fn
+      {ref, meta, context} = var when is_atom(ref) and is_atom(context) ->
+        case {ref, var_context(meta, context)} in refs do
+          true -> literal_unquote(var)
+          false -> var
+        end
+
+      node ->
+        node
+    end)
+  end
+
+  # Prefaces `guard` with unquoted versions of `refs`.
+  defp unquote_refs_once(guard, refs, module) do
+    {guard, used_refs} =
+      Macro.postwalk(guard, %{}, fn
+        {ref, meta, context} = var, acc when is_atom(ref) and is_atom(context) ->
+          pair = {ref, var_context(meta, context)}
+
+          case pair in refs do
+            true ->
+              case acc do
+                %{^pair => {new_var, _}} ->
+                  {new_var, acc}
+
+                %{} ->
+                  generated = String.to_atom("arg" <> Integer.to_string(map_size(acc) + 1))
+                  new_var = Macro.unique_var(generated, module)
+                  {new_var, Map.put(acc, pair, {new_var, var})}
+              end
+
+            false ->
+              {var, acc}
+          end
+
+        node, acc ->
+          {node, acc}
+      end)
+
+    all_used = for ref <- :lists.reverse(refs), used = :maps.get(ref, used_refs, nil), do: used
+    {vars, exprs} = :lists.unzip(all_used)
+
+    quote do
+      {unquote_splicing(vars)} = {unquote_splicing(Enum.map(exprs, &literal_unquote/1))}
+      unquote(guard)
+    end
+  end
+
+  defp literal_quote(ast, args) do
+    {:quote, [], [args, [do: ast]]}
+  end
+
+  defp literal_unquote(ast) do
+    {:unquote, [], List.wrap(ast)}
+  end
+
+  defp var_context(meta, kind) do
+    case :lists.keyfind(:counter, 1, meta) do
+      {:counter, counter} -> counter
+      false -> kind
+    end
+  end
+end
diff --git a/lib/elixir/lib/keyword.ex b/lib/elixir/lib/keyword.ex
index a991c6a4ccb..418273e9efe 100644
--- a/lib/elixir/lib/keyword.ex
+++ b/lib/elixir/lib/keyword.ex
@@ -1,120 +1,401 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Keyword do
   @moduledoc """
-  A keyword is a list of tuples where the first element
-  of the tuple is an atom and the second element can be
-  any value.
+  A keyword list is a list that consists exclusively of two-element tuples.
+
+  The first element of these tuples is known as the *key*, and it must be an atom.
+  The second element, known as the *value*, can be any term.
+
+  Keywords are mostly used to work with optional values. For a general introduction
+  to keywords and how they compare with maps, see our [Keyword and Maps](keywords-and-maps.md)
+  guide.
+
+  ## Examples
+
+  For example, the following is a keyword list:
+
+      [{:exit_on_close, true}, {:active, :once}, {:packet_size, 1024}]
+
+  Elixir provides a special and more concise syntax for keyword lists:
+
+      [exit_on_close: true, active: :once, packet_size: 1024]
+
+  The two syntaxes return the exact same value.
+
+  A *key* can be any atom, consisting of Unicode letters, numbers,
+  an underscore or the `@` sign. If the *key* should have any other
+  characters, such as spaces, you can wrap it in quotes:
+
+      iex> ["exit on close": true]
+      ["exit on close": true]
+
+  Wrapping an atom in quotes does not make it a string. Keyword list
+  *keys* are always atoms. Quotes should only be used when necessary
+  or Elixir will issue a warning.
+
+  ## Duplicate keys and ordering
+
+  A keyword may have duplicate keys so it is not strictly a key-value
+  data type. However, most of the functions in this module work on a
+  key-value structure and behave similar to the functions you would
+  find in the `Map` module. For example, `Keyword.get/3` will get the first
+  entry matching the given key, regardless if duplicate entries exist.
+  Similarly, `Keyword.put/3` and `Keyword.delete/2` ensure all duplicate
+  entries for a given key are removed when invoked. Note, however, that
+  keyword list operations need to traverse the whole list in order to find
+  keys, so these operations are slower than their map counterparts.
+
+  A handful of functions exist to handle duplicate keys, for example,
+  `get_values/2` returns all values for a given key and `delete_first/2`
+  deletes just the first entry of the existing ones.
+
+  Even though lists preserve the existing order, the functions in
+  `Keyword` do not guarantee any ordering. For example, if you invoke
+  `Keyword.put(opts, new_key, new_value)`, there is no guarantee for
+  where `new_key` will be added to (the front, the end or anywhere else).
+
+  Given ordering is not guaranteed, it is not recommended to pattern
+  match on keyword lists either. For example, a function such as:
+
+      def my_function([some_key: value, another_key: another_value])
+
+  will match
+
+      my_function([some_key: :foo, another_key: :bar])
+
+  but it won't match
+
+      my_function([another_key: :bar, some_key: :foo])
+
+  Most of the functions in this module work in linear time. This means
+  that the time it takes to perform an operation grows at the same
+  rate as the length of the list.
+
+  ## Call syntax
+
+  When keyword lists are passed as the last argument to a function,
+  the square brackets around the keyword list can be omitted. For
+  example, the keyword list syntax:
+
+      String.split("1-0", "-", [trim: true, parts: 2])
 
-  A keyword may have duplicated keys so it is not strictly
-  a dictionary. However most of the functions in this module
-  behave exactly as a dictionary and mimic the API defined
-  by the `Dict` behaviour.
+  can be written without the enclosing brackets whenever it is the last
+  argument of a function call:
 
-  For example, `Keyword.get` will get the first entry matching
-  the given key, regardless if duplicated entries exist.
-  Similarly, `Keyword.put` and `Keyword.delete` ensure all
-  duplicated entries for a given key are removed when invoked.
+      String.split("1-0", "-", trim: true, parts: 2)
 
-  A handful of functions exist to handle duplicated keys, in
-  particular, `from_enum` allows creating a new keywords without
-  removing duplicated keys, `get_values` returns all values for
-  a given key and `delete_first` deletes just one of the existing
-  entries.
+  Since tuples, lists and maps are treated similarly to function
+  arguments in Elixir syntax, this property is also available to them:
+
+      iex> {1, 2, foo: :bar}
+      {1, 2, [{:foo, :bar}]}
+
+      iex> [1, 2, foo: :bar]
+      [1, 2, {:foo, :bar}]
+
+      iex> %{1 => 2, foo: :bar}
+      %{1 => 2, :foo => :bar}
 
-  Since a keyword list is simply a list, all the operations defined
-  in `Enum` and `List` can also be applied.
   """
 
   @compile :inline_list_funcs
-  @behaviour Dict
 
   @type key :: atom
   @type value :: any
 
+  @typedoc since: "1.17.0"
+  @type default :: any
+
   @type t :: [{key, value}]
   @type t(value) :: [{key, value}]
 
   @doc """
-  Checks if the given argument is a keywords list or not.
+  Builds a keyword from the given `keys` and the fixed `value`.
+
+  ## Examples
+
+      iex> Keyword.from_keys([:foo, :bar, :baz], :atom)
+      [foo: :atom, bar: :atom, baz: :atom]
+      iex> Keyword.from_keys([], :atom)
+      []
+
   """
-  @spec keyword?(term) :: boolean
-  def keyword?([{key, _value} | rest]) when is_atom(key) do
-    keyword?(rest)
+  @doc since: "1.14.0"
+  @spec from_keys([key], value) :: t(value)
+  def from_keys(keys, value) when is_list(keys) do
+    :lists.map(&{&1, value}, keys)
   end
 
-  def keyword?([]),     do: true
+  @doc """
+  Returns `true` if `term` is a keyword list, otherwise `false`.
+
+  When `term` is a list it is traversed to the end.
+
+  ## Examples
+
+      iex> Keyword.keyword?([])
+      true
+      iex> Keyword.keyword?(a: 1)
+      true
+      iex> Keyword.keyword?([{Foo, 1}])
+      true
+      iex> Keyword.keyword?([{}])
+      false
+      iex> Keyword.keyword?([:key])
+      false
+      iex> Keyword.keyword?(%{})
+      false
+
+  """
+  @spec keyword?(term) :: boolean
+  def keyword?(term)
+
+  def keyword?([{key, _value} | rest]) when is_atom(key), do: keyword?(rest)
+  def keyword?([]), do: true
   def keyword?(_other), do: false
 
   @doc """
   Returns an empty keyword list, i.e. an empty list.
+
+  ## Examples
+
+      iex> Keyword.new()
+      []
+
   """
-  @spec new :: t
-  def new do
-    []
-  end
+  @spec new :: []
+  def new, do: []
 
   @doc """
-  Creates a keyword from an enumerable.
+  Creates a keyword list from an enumerable.
 
-  Duplicated entries are removed, the latest one prevails.
-  I.e. differently from `Enum.into(enumerable, [])`,
-  `Keyword.new(enumerable)` guarantees the keys are unique.
+  Removes duplicate entries and the last one prevails.
+  Unlike `Enum.into(enumerable, [])`, `Keyword.new(enumerable)`
+  guarantees the keys are unique.
 
   ## Examples
 
       iex> Keyword.new([{:b, 1}, {:a, 2}])
-      [a: 2, b: 1]
+      [b: 1, a: 2]
+
+      iex> Keyword.new([{:a, 1}, {:a, 2}, {:a, 3}])
+      [a: 3]
 
   """
-  @spec new(Enum.t) :: t
+  @spec new(Enumerable.t()) :: t
   def new(pairs) do
-    Enum.reduce pairs, [], fn {k, v}, keywords ->
-      put(keywords, k, v)
-    end
+    new(pairs, fn pair -> pair end)
   end
 
   @doc """
-  Creates a keyword from an enumerable via the transformation function.
+  Creates a keyword list from an enumerable via the transformation function.
 
-  Duplicated entries are removed, the latest one prevails.
-  I.e. differently from `Enum.into(enumerable, [], fun)`,
+  Removes duplicate entries and the last one prevails.
+  Unlike `Enum.into(enumerable, [], fun)`,
   `Keyword.new(enumerable, fun)` guarantees the keys are unique.
 
   ## Examples
 
-      iex> Keyword.new([:a, :b], fn (x) -> {x, x} end) |> Enum.sort
+      iex> Keyword.new([:a, :b], fn x -> {x, x} end)
       [a: :a, b: :b]
 
   """
-  @spec new(Enum.t, ({key, value} -> {key, value})) :: t
-  def new(pairs, transform) do
-    Enum.reduce pairs, [], fn i, keywords ->
-      {k, v} = transform.(i)
-      put(keywords, k, v)
+  @spec new(Enumerable.t(), (term -> {key, value})) :: t
+  def new(pairs, transform) when is_function(transform, 1) do
+    fun = fn el, acc ->
+      {k, v} = transform.(el)
+      put_new(acc, k, v)
+    end
+
+    :lists.foldl(fun, [], Enum.reverse(pairs))
+  end
+
+  @doc """
+  Ensures the given `keyword` has only the keys given in `values`.
+
+  The second argument must be a list of atoms, specifying
+  a given key, or tuples specifying a key and a default value.
+
+  If the keyword list has only the given keys, it returns
+  `{:ok, keyword}` with default values applied. Otherwise it
+  returns `{:error, invalid_keys}` with invalid keys.
+
+  See also: `validate!/2`.
+
+  ## Examples
+
+      iex> {:ok, result} = Keyword.validate([], [one: 1, two: 2])
+      iex> Enum.sort(result)
+      [one: 1, two: 2]
+
+      iex> {:ok, result} = Keyword.validate([two: 3], [one: 1, two: 2])
+      iex> Enum.sort(result)
+      [one: 1, two: 3]
+
+  If atoms are given, they are supported as keys but do not
+  provide a default value:
+
+      iex> {:ok, result} = Keyword.validate([], [:one, two: 2])
+      iex> Enum.sort(result)
+      [two: 2]
+
+      iex> {:ok, result} = Keyword.validate([one: 1], [:one, two: 2])
+      iex> Enum.sort(result)
+      [one: 1, two: 2]
+
+  Passing unknown keys returns an error:
+
+      iex> Keyword.validate([three: 3, four: 4], [one: 1, two: 2])
+      {:error, [:four, :three]}
+
+  Passing the same key multiple times also errors:
+
+      iex> Keyword.validate([one: 1, two: 2, one: 1], [:one, :two])
+      {:error, [:one]}
+
+  """
+  @doc since: "1.13.0"
+  @spec validate(keyword(), values :: [atom() | {atom(), term()}]) ::
+          {:ok, keyword()} | {:error, [atom]}
+  def validate(keyword, values) when is_list(keyword) and is_list(values) do
+    validate(keyword, values, [], [], [])
+  end
+
+  defp validate([{key, _} = pair | keyword], values1, values2, acc, bad_keys) when is_atom(key) do
+    case find_key!(key, values1, values2) do
+      {values1, values2} ->
+        validate(keyword, values1, values2, [pair | acc], bad_keys)
+
+      :error ->
+        case find_key!(key, values2, values1) do
+          {values1, values2} ->
+            validate(keyword, values1, values2, [pair | acc], bad_keys)
+
+          :error ->
+            validate(keyword, values1, values2, acc, [key | bad_keys])
+        end
+    end
+  end
+
+  defp validate([], values1, values2, acc, []) do
+    {:ok, move_pairs!(values1, move_pairs!(values2, acc))}
+  end
+
+  defp validate([], _values1, _values2, _acc, bad_keys) do
+    {:error, bad_keys}
+  end
+
+  defp validate([pair | _], _values1, _values2, _acc, []) do
+    raise ArgumentError,
+          "expected a keyword list as first argument, got invalid entry: #{inspect(pair)}"
+  end
+
+  defp find_key!(key, [key | rest], acc), do: {rest, acc}
+  defp find_key!(key, [{key, _} | rest], acc), do: {rest, acc}
+  defp find_key!(key, [head | tail], acc), do: find_key!(key, tail, [head | acc])
+  defp find_key!(_key, [], _acc), do: :error
+
+  defp move_pairs!([key | rest], acc) when is_atom(key),
+    do: move_pairs!(rest, acc)
+
+  defp move_pairs!([{key, _} = pair | rest], acc) when is_atom(key),
+    do: move_pairs!(rest, [pair | acc])
+
+  defp move_pairs!([], acc),
+    do: acc
+
+  defp move_pairs!([other | _], _) do
+    raise ArgumentError,
+          "expected the second argument to be a list of atoms or tuples, got: #{inspect(other)}"
+  end
+
+  @doc """
+  Similar to `validate/2` but returns the keyword or raises an error.
+
+  ## Examples
+
+      iex> Keyword.validate!([], [one: 1, two: 2]) |> Enum.sort()
+      [one: 1, two: 2]
+      iex> Keyword.validate!([two: 3], [one: 1, two: 2]) |> Enum.sort()
+      [one: 1, two: 3]
+
+  If atoms are given, they are supported as keys but do not
+  provide a default value:
+
+      iex> Keyword.validate!([], [:one, two: 2]) |> Enum.sort()
+      [two: 2]
+      iex> Keyword.validate!([one: 1], [:one, two: 2]) |> Enum.sort()
+      [one: 1, two: 2]
+
+  Passing unknown keys raises an error:
+
+      iex> Keyword.validate!([three: 3], [one: 1, two: 2])
+      ** (ArgumentError) unknown keys [:three] in [three: 3], the allowed keys are: [:one, :two]
+
+  Passing the same key multiple times also errors:
+
+      iex> Keyword.validate!([one: 1, two: 2, one: 1], [:one, :two])
+      ** (ArgumentError) duplicate keys [:one] in [one: 1, two: 2, one: 1]
+
+  """
+  @doc since: "1.13.0"
+  @spec validate!(keyword(), values :: [atom() | {atom(), term()}]) :: keyword()
+  def validate!(keyword, values) do
+    case validate(keyword, values) do
+      {:ok, kw} ->
+        kw
+
+      {:error, invalid_keys} ->
+        keys =
+          for value <- values,
+              do: if(is_atom(value), do: value, else: elem(value, 0))
+
+        message =
+          case Enum.split_with(invalid_keys, &(&1 in keys)) do
+            {_, [_ | _] = unknown} ->
+              "unknown keys #{inspect(unknown)} in #{inspect(keyword)}, " <>
+                "the allowed keys are: #{inspect(keys)}"
+
+            {[_ | _] = known, _} ->
+              "duplicate keys #{inspect(known)} in #{inspect(keyword)}"
+          end
+
+        raise ArgumentError, message
     end
   end
 
   @doc """
-  Gets the value for a specific `key`.
+  Gets the value under the given `key`.
 
-  If `key` does not exist, return default value (`nil` if no default value).
+  Returns the default value if `key` does not exist
+  (`nil` if no default value is provided).
 
-  If duplicated entries exist, the first one is returned.
+  If duplicate entries exist, it returns the first one.
   Use `get_values/2` to retrieve all entries.
 
   ## Examples
 
+      iex> Keyword.get([], :a)
+      nil
       iex> Keyword.get([a: 1], :a)
       1
-
       iex> Keyword.get([a: 1], :b)
       nil
-
       iex> Keyword.get([a: 1], :b, 3)
       3
 
+  With duplicate keys:
+
+      iex> Keyword.get([a: 1, a: 2], :a, 3)
+      1
+      iex> Keyword.get([a: 1, a: 2], :b, 3)
+      3
+
   """
-  @spec get(t, key) :: value
-  @spec get(t, key, value) :: value
+  @spec get(t, key, default) :: value | default
   def get(keywords, key, default \\ nil) when is_list(keywords) and is_atom(key) do
     case :lists.keyfind(key, 1, keywords) do
       {^key, value} -> value
@@ -122,20 +403,184 @@ defmodule Keyword do
     end
   end
 
+  @doc """
+  Gets the value under the given `key`.
+
+  If `key` does not exist, lazily evaluates `fun` and returns its result.
+
+  This is useful if the default value is very expensive to calculate or
+  generally difficult to set up and tear down again.
+
+  If duplicate entries exist, it returns the first one.
+  Use `get_values/2` to retrieve all entries.
+
+  ## Examples
+
+      iex> keyword = [a: 1]
+      iex> fun = fn ->
+      ...>   # some expensive operation here
+      ...>   13
+      ...> end
+      iex> Keyword.get_lazy(keyword, :a, fun)
+      1
+      iex> Keyword.get_lazy(keyword, :b, fun)
+      13
+
+  """
+  @spec get_lazy(t, key, (-> value)) :: value
+  def get_lazy(keywords, key, fun)
+      when is_list(keywords) and is_atom(key) and is_function(fun, 0) do
+    case :lists.keyfind(key, 1, keywords) do
+      {^key, value} -> value
+      false -> fun.()
+    end
+  end
+
+  @doc """
+  Gets the value for `key` and updates it in one pass, deleting duplicate keys.
+
+  The `fun` argument receives the value of `key` (or `nil` if `key`
+  is not present) and must return a two-element tuple: the current value
+  (the retrieved value, which can be operated on before being returned)
+  and the new value to be stored under `key`. The `fun` may also
+  return `:pop`, implying the current value shall be removed from the
+  keyword list and returned.
+
+  Returns a tuple that contains the current value returned by
+  `fun` and a new keyword list with the updated value under `key`.
+
+  ## Examples
+
+      iex> Keyword.get_and_update([a: 1], :a, fn current_value ->
+      ...>   {current_value, "new value!"}
+      ...> end)
+      {1, [a: "new value!"]}
+
+      iex> Keyword.get_and_update([a: 1], :b, fn current_value ->
+      ...>   {current_value, "new value!"}
+      ...> end)
+      {nil, [b: "new value!", a: 1]}
+
+      iex> Keyword.get_and_update([a: 2], :a, fn number ->
+      ...>   {2 * number, 3 * number}
+      ...> end)
+      {4, [a: 6]}
+
+      iex> Keyword.get_and_update([a: 1], :a, fn _ -> :pop end)
+      {1, []}
+
+      iex> Keyword.get_and_update([a: 1], :b, fn _ -> :pop end)
+      {nil, [a: 1]}
+
+  """
+  @spec get_and_update(t, key, (value | nil -> {current_value, new_value :: value} | :pop)) ::
+          {current_value, new_keywords :: t}
+        when current_value: value
+  def get_and_update(keywords, key, fun)
+      when is_list(keywords) and is_atom(key),
+      do: get_and_update(keywords, [], key, fun)
+
+  defp get_and_update([{key, current} | t], acc, key, fun) do
+    case fun.(current) do
+      {get, value} ->
+        {get, :lists.reverse(acc, [{key, value} | delete(t, key)])}
+
+      :pop ->
+        {current, :lists.reverse(acc, t)}
+
+      other ->
+        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+    end
+  end
+
+  defp get_and_update([{_, _} = h | t], acc, key, fun), do: get_and_update(t, [h | acc], key, fun)
+
+  defp get_and_update([], acc, key, fun) do
+    case fun.(nil) do
+      {get, update} ->
+        {get, [{key, update} | :lists.reverse(acc)]}
+
+      :pop ->
+        {nil, :lists.reverse(acc)}
+
+      other ->
+        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+    end
+  end
+
+  @doc """
+  Gets the value for `key` and updates it in one pass, deleting duplicate keys,
+  raising if `key` can't be found in `keywords`.
+
+  The `fun` argument receives the value under `key` and must return a
+  two-element tuple: the current value (the retrieved value, which can be
+  operated on before being returned) and the new value to be stored under
+  `key`.
+
+  Returns a tuple that contains the current value returned by
+  `fun` and a new keyword list with the updated value under `key`.
+
+  ## Examples
+
+      iex> Keyword.get_and_update!([a: 1], :a, fn current_value ->
+      ...>   {current_value, "new value!"}
+      ...> end)
+      {1, [a: "new value!"]}
+
+      iex> Keyword.get_and_update!([a: 1], :b, fn current_value ->
+      ...>   {current_value, "new value!"}
+      ...> end)
+      ** (KeyError) key :b not found in:
+      ...
+
+      iex> Keyword.get_and_update!([a: 1], :a, fn _ ->
+      ...>   :pop
+      ...> end)
+      {1, []}
+
+  """
+  @spec get_and_update!(t, key, (value -> {current_value, new_value :: value} | :pop)) ::
+          {current_value, new_keywords :: t}
+        when current_value: value
+  def get_and_update!(keywords, key, fun) do
+    get_and_update!(keywords, key, fun, [])
+  end
+
+  defp get_and_update!([{key, value} | t], key, fun, acc) do
+    case fun.(value) do
+      {get, value} ->
+        {get, :lists.reverse(acc, [{key, value} | delete(t, key)])}
+
+      :pop ->
+        {value, :lists.reverse(acc, t)}
+
+      other ->
+        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+    end
+  end
+
+  defp get_and_update!([{_, _} = h | t], key, fun, acc) do
+    get_and_update!(t, key, fun, [h | acc])
+  end
+
+  defp get_and_update!([], key, _fun, acc) when is_atom(key) do
+    raise KeyError, key: key, term: acc
+  end
+
   @doc """
   Fetches the value for a specific `key` and returns it in a tuple.
-  If the `key` does not exist, returns `:error`.
+
+  If the `key` does not exist, it returns `:error`.
 
   ## Examples
 
       iex> Keyword.fetch([a: 1], :a)
       {:ok, 1}
-
       iex> Keyword.fetch([a: 1], :b)
       :error
 
   """
-  @spec fetch(t, key) :: {:ok, value}
+  @spec fetch(t, key) :: {:ok, value} | :error
   def fetch(keywords, key) when is_list(keywords) and is_atom(key) do
     case :lists.keyfind(key, 1, keywords) do
       {^key, value} -> {:ok, value}
@@ -144,70 +589,93 @@ defmodule Keyword do
   end
 
   @doc """
-  Fetches the value for specific `key`. If `key` does not exist,
-  a `KeyError` is raised.
+  Fetches the value for specific `key`.
+
+  If the `key` does not exist, it raises a `KeyError`.
 
   ## Examples
 
       iex> Keyword.fetch!([a: 1], :a)
       1
-
       iex> Keyword.fetch!([a: 1], :b)
-      ** (KeyError) key :b not found in: [a: 1]
+      ** (KeyError) key :b not found in:
+      ...
 
   """
-  @spec fetch!(t, key) :: value | no_return
+  @spec fetch!(t, key) :: value
   def fetch!(keywords, key) when is_list(keywords) and is_atom(key) do
     case :lists.keyfind(key, 1, keywords) do
       {^key, value} -> value
-      false -> raise(KeyError, key: key, term: keywords)
+      false -> raise KeyError, key: key, term: keywords
     end
   end
 
   @doc """
-  Gets all values for a specific `key`.
+  Gets all values under a specific `key`.
 
   ## Examples
 
+      iex> Keyword.get_values([], :a)
+      []
+      iex> Keyword.get_values([a: 1], :a)
+      [1]
       iex> Keyword.get_values([a: 1, a: 2], :a)
-      [1,2]
+      [1, 2]
 
   """
   @spec get_values(t, key) :: [value]
   def get_values(keywords, key) when is_list(keywords) and is_atom(key) do
-    fun = fn
-      {k, v} when k === key -> {true, v}
-      {_, _} -> false
-    end
-
-    :lists.filtermap(fun, keywords)
+    get_values(keywords, key, [])
   end
 
+  defp get_values([{key, value} | tail], key, values), do: get_values(tail, key, [value | values])
+  defp get_values([{_, _} | tail], key, values), do: get_values(tail, key, values)
+  defp get_values([], _key, values), do: :lists.reverse(values)
+
   @doc """
-  Returns all keys from the keyword list. Duplicated
-  keys appear duplicated in the final list of keys.
+  Returns all keys from the keyword list.
+
+  Keeps duplicate keys in the resulting list of keys.
 
   ## Examples
 
-      iex> Keyword.keys([a: 1, b: 2])
-      [:a,:b]
+      iex> Keyword.keys(a: 1, b: 2)
+      [:a, :b]
+
+      iex> Keyword.keys(a: 1, b: 2, a: 3)
+      [:a, :b, :a]
 
-      iex> Keyword.keys([a: 1, b: 2, a: 3])
-      [:a,:b,:a]
+      iex> Keyword.keys([{:a, 1}, {"b", 2}, {:c, 3}])
+      ** (ArgumentError) expected a keyword list, but an entry in the list is not a two-element tuple with an atom as its first element, got: {"b", 2}
 
   """
   @spec keys(t) :: [key]
   def keys(keywords) when is_list(keywords) do
-    :lists.map(fn {k, _} -> k end, keywords)
+    :lists.map(
+      fn
+        {key, _} when is_atom(key) -> key
+        element -> throw(element)
+      end,
+      keywords
+    )
+  catch
+    element ->
+      raise ArgumentError,
+            "expected a keyword list, but an entry in the list is not a two-element tuple " <>
+              "with an atom as its first element, got: #{inspect(element)}"
   end
 
   @doc """
   Returns all values from the keyword list.
 
+  Keeps values from duplicate keys in the resulting list of values.
+
   ## Examples
 
-      iex> Keyword.values([a: 1, b: 2])
-      [1,2]
+      iex> Keyword.values(a: 1, b: 2)
+      [1, 2]
+      iex> Keyword.values(a: 1, b: 2, a: 3)
+      [1, 2, 3]
 
   """
   @spec values(t) :: [value]
@@ -215,97 +683,147 @@ defmodule Keyword do
     :lists.map(fn {_, v} -> v end, keywords)
   end
 
-  @doc """
-  Deletes the entries in the keyword list for a `key` with `value`.
-  If no `key` with `value` exists, returns the keyword list unchanged.
-
-  ## Examples
-
-      iex> Keyword.delete([a: 1, b: 2], :a, 1)
-      [b: 2]
+  @doc false
+  @deprecated "Use Keyword.fetch/2 + Keyword.delete/2 instead"
+  def delete(keywords, key, value) when is_list(keywords) and is_atom(key) do
+    case :lists.keymember(key, 1, keywords) do
+      true -> delete_key_value(keywords, key, value)
+      _ -> keywords
+    end
+  end
 
-      iex> Keyword.delete([a: 1, b: 2, a: 3], :a, 3)
-      [a: 1, b: 2]
+  defp delete_key_value([{key, value} | tail], key, value) do
+    delete_key_value(tail, key, value)
+  end
 
-      iex> Keyword.delete([b: 2], :a, 5)
-      [b: 2]
+  defp delete_key_value([{_, _} = pair | tail], key, value) do
+    [pair | delete_key_value(tail, key, value)]
+  end
 
-  """
-  @spec delete(t, key, value) :: t
-  def delete(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    :lists.filter(fn {k, v} -> k != key or v != value end, keywords)
+  defp delete_key_value([], _key, _value) do
+    []
   end
 
   @doc """
-  Deletes the entries in the keyword list for a specific `key`.
-  If the `key` does not exist, returns the keyword list unchanged.
-  Use `delete_first` to delete just the first entry in case of
-  duplicated keys.
+  Deletes the entries in the keyword list under a specific `key`.
+
+  If the `key` does not exist, it returns the keyword list unchanged.
+  Use `delete_first/2` to delete just the first entry in case of
+  duplicate keys.
 
   ## Examples
 
       iex> Keyword.delete([a: 1, b: 2], :a)
       [b: 2]
-
       iex> Keyword.delete([a: 1, b: 2, a: 3], :a)
       [b: 2]
-
       iex> Keyword.delete([b: 2], :a)
       [b: 2]
 
   """
   @spec delete(t, key) :: t
+  @compile {:inline, delete: 2}
   def delete(keywords, key) when is_list(keywords) and is_atom(key) do
-    :lists.filter(fn {k, _} -> k != key end, keywords)
+    case :lists.keymember(key, 1, keywords) do
+      true -> delete_key(keywords, key)
+      _ -> keywords
+    end
   end
 
+  defp delete_key([{key, _} | tail], key), do: delete_key(tail, key)
+  defp delete_key([{_, _} = pair | tail], key), do: [pair | delete_key(tail, key)]
+  defp delete_key([], _key), do: []
+
   @doc """
-  Deletes the first entry in the keyword list for a specific `key`.
-  If the `key` does not exist, returns the keyword list unchanged.
+  Deletes the first entry in the keyword list under a specific `key`.
+
+  If the `key` does not exist, it returns the keyword list unchanged.
 
   ## Examples
 
       iex> Keyword.delete_first([a: 1, b: 2, a: 3], :a)
       [b: 2, a: 3]
 
+      iex> Keyword.delete_first([a: 1, b: 2, b: 3], :b)
+      [a: 1, b: 3]
+
       iex> Keyword.delete_first([b: 2], :a)
       [b: 2]
 
   """
   @spec delete_first(t, key) :: t
   def delete_first(keywords, key) when is_list(keywords) and is_atom(key) do
-    :lists.keydelete(key, 1, keywords)
+    case :lists.keymember(key, 1, keywords) do
+      true -> delete_first_key(keywords, key)
+      _ -> keywords
+    end
+  end
+
+  defp delete_first_key([{key, _} | tail], key) do
+    tail
+  end
+
+  defp delete_first_key([{_, _} = pair | tail], key) do
+    [pair | delete_first_key(tail, key)]
   end
 
   @doc """
-  Puts the given `value` under `key`.
+  Puts the given `value` under the specified `key`.
 
-  If a previous value is already stored, all entries are
-  removed and the value is overridden.
+  If a value under `key` already exists, it overrides the value
+  and removes all duplicate entries.
 
   ## Examples
 
+      iex> Keyword.put([a: 1], :b, 2)
+      [b: 2, a: 1]
       iex> Keyword.put([a: 1, b: 2], :a, 3)
       [a: 3, b: 2]
-
       iex> Keyword.put([a: 1, b: 2, a: 4], :a, 3)
       [a: 3, b: 2]
 
   """
   @spec put(t, key, value) :: t
   def put(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    [{key, value}|delete(keywords, key)]
+    [{key, value} | delete(keywords, key)]
   end
 
   @doc """
-  Puts the given `value` under `key` unless the entry `key`
-  already exists.
+  Evaluates `fun` and puts the result under `key`
+  in keyword list unless `key` is already present.
+
+  This is useful if the value is very expensive to calculate or
+  generally difficult to set up and tear down again.
+
+  ## Examples
+
+      iex> keyword = [a: 1]
+      iex> fun = fn ->
+      ...>   # some expensive operation here
+      ...>   13
+      ...> end
+      iex> Keyword.put_new_lazy(keyword, :a, fun)
+      [a: 1]
+      iex> Keyword.put_new_lazy(keyword, :b, fun)
+      [b: 13, a: 1]
+
+  """
+  @spec put_new_lazy(t, key, (-> value)) :: t
+  def put_new_lazy(keywords, key, fun)
+      when is_list(keywords) and is_atom(key) and is_function(fun, 0) do
+    case :lists.keyfind(key, 1, keywords) do
+      {^key, _} -> keywords
+      false -> [{key, fun.()} | keywords]
+    end
+  end
+
+  @doc """
+  Puts the given `value` under `key`, unless the entry `key` already exists.
 
   ## Examples
 
       iex> Keyword.put_new([a: 1], :b, 2)
       [b: 2, a: 1]
-
       iex> Keyword.put_new([a: 1, b: 2], :a, 3)
       [a: 1, b: 2]
 
@@ -314,64 +832,280 @@ defmodule Keyword do
   def put_new(keywords, key, value) when is_list(keywords) and is_atom(key) do
     case :lists.keyfind(key, 1, keywords) do
       {^key, _} -> keywords
-      false -> [{key, value}|keywords]
+      false -> [{key, value} | keywords]
     end
   end
 
   @doc """
-  Checks if two keywords are equal. I.e. they contain
+  Puts a value under `key` only if the `key` already exists in `keywords`.
+
+  In case a key exists multiple times in the keyword list,
+  it removes later occurrences.
+
+  ## Examples
+
+      iex> Keyword.replace([a: 1, b: 2, a: 4], :a, 3)
+      [a: 3, b: 2]
+
+      iex> Keyword.replace([a: 1], :b, 2)
+      [a: 1]
+
+  """
+  @doc since: "1.11.0"
+  @spec replace(t, key, value) :: t
+  def replace(keywords, key, value) when is_list(keywords) and is_atom(key) do
+    do_replace(keywords, key, value)
+  end
+
+  defp do_replace([{key, _} | keywords], key, value) do
+    [{key, value} | delete(keywords, key)]
+  end
+
+  defp do_replace([{_, _} = e | keywords], key, value) do
+    [e | do_replace(keywords, key, value)]
+  end
+
+  defp do_replace([], _key, _value) do
+    []
+  end
+
+  @doc """
+  Puts a value under `key` only if the `key` already exists in `keywords`.
+
+  If `key` is not present in `keywords`, it raises a `KeyError`.
+
+  ## Examples
+
+      iex> Keyword.replace!([a: 1, b: 2, a: 3], :a, :new)
+      [a: :new, b: 2]
+      iex> Keyword.replace!([a: 1, b: 2, c: 3, b: 4], :b, :new)
+      [a: 1, b: :new, c: 3]
+
+      iex> Keyword.replace!([a: 1], :b, 2)
+      ** (KeyError) key :b not found in:
+      ...
+
+  """
+  @doc since: "1.5.0"
+  @spec replace!(t, key, value) :: t
+  def replace!(keywords, key, value) when is_list(keywords) and is_atom(key) do
+    replace!(keywords, key, value, keywords)
+  end
+
+  defp replace!([{key, _} | keywords], key, value, _original) do
+    [{key, value} | delete(keywords, key)]
+  end
+
+  defp replace!([{_, _} = e | keywords], key, value, original) do
+    [e | replace!(keywords, key, value, original)]
+  end
+
+  defp replace!([], key, _value, original) do
+    raise KeyError, key: key, term: original
+  end
+
+  @doc """
+  Replaces the value under `key` using the given function only if
+  `key` already exists in `keywords`.
+
+  In comparison to `replace/3`, this can be useful when it's expensive to calculate the value.
+
+  If `key` does not exist, the original keyword list is returned unchanged.
+
+  ## Examples
+
+      iex> Keyword.replace_lazy([a: 1, b: 2], :a, fn v -> v * 4 end)
+      [a: 4, b: 2]
+
+      iex> Keyword.replace_lazy([a: 2, b: 2, a: 1], :a, fn v -> v * 4 end)
+      [a: 8, b: 2]
+
+      iex> Keyword.replace_lazy([a: 1, b: 2], :c, fn v -> v * 4 end)
+      [a: 1, b: 2]
+
+  """
+  @doc since: "1.14.0"
+  @spec replace_lazy(t, key, (existing_value :: value -> new_value :: value)) :: t
+  def replace_lazy(keywords, key, fun)
+      when is_list(keywords) and is_atom(key) and is_function(fun, 1) do
+    do_replace_lazy(keywords, key, fun)
+  end
+
+  defp do_replace_lazy([{key, value} | keywords], key, fun) do
+    [{key, fun.(value)} | delete(keywords, key)]
+  end
+
+  defp do_replace_lazy([{_, _} = e | keywords], key, fun) do
+    [e | do_replace_lazy(keywords, key, fun)]
+  end
+
+  defp do_replace_lazy([], _key, _value), do: []
+
+  @doc """
+  Checks if two keywords are equal.
+
+  Considers two keywords to be equal if they contain
   the same keys and those keys contain the same values.
 
   ## Examples
 
       iex> Keyword.equal?([a: 1, b: 2], [b: 2, a: 1])
       true
+      iex> Keyword.equal?([a: 1, b: 2], [b: 1, a: 2])
+      false
+      iex> Keyword.equal?([a: 1, b: 2, a: 3], [b: 2, a: 3, a: 1])
+      true
+
+  Comparison between values is done with `===/3`,
+  which means integers are not equivalent to floats:
+
+      iex> Keyword.equal?([a: 1.0], [a: 1])
+      false
 
   """
   @spec equal?(t, t) :: boolean
   def equal?(left, right) when is_list(left) and is_list(right) do
-    :lists.sort(left) == :lists.sort(right)
+    :lists.sort(left) === :lists.sort(right)
+  end
+
+  @doc """
+  Intersects two keyword lists, returning a keyword with the common keys.
+
+  By default, it returns the values of the intersected keys in `keyword2`.
+  The keys are returned in the order found in `keyword1`.
+
+  ## Examples
+
+      iex> Keyword.intersect([a: 1, b: 2], [b: "b", c: "c"])
+      [b: "b"]
+
+      iex> Keyword.intersect([a: 1, b: 2], [b: 2, c: 3], fn _k, v1, v2 ->
+      ...>   v1 + v2
+      ...> end)
+      [b: 4]
+
+  """
+  @doc since: "1.17.0"
+  @spec intersect(keyword, keyword, (key, value, value -> value)) :: keyword
+  def intersect(keyword1, keyword2, fun \\ fn _key, _v1, v2 -> v2 end)
+
+  def intersect([{k, v1} | keyword1], keyword2, fun) do
+    case :lists.keyfind(k, 1, keyword2) do
+      {_, v2} -> [{k, fun.(k, v1, v2)} | intersect(keyword1, keyword2, fun)]
+      false -> intersect(keyword1, keyword2, fun)
+    end
   end
 
+  def intersect([], _keyword2, _fun), do: []
+
   @doc """
-  Merges two keyword lists into one. If they have duplicated
-  entries, the one given as second argument wins.
+  Merges two keyword lists into one.
+
+  Adds all keys, including duplicate keys, given in `keywords2`
+  to `keywords1`, overriding any existing ones.
+
+  There are no guarantees about the order of the keys in the returned keyword.
 
   ## Examples
 
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4]) |> Enum.sort
-      [a: 3, b: 2, d: 4]
+      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4])
+      [b: 2, a: 3, d: 4]
+
+      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5])
+      [b: 2, a: 3, d: 4, a: 5]
+
+      iex> Keyword.merge([a: 1], [2, 3])
+      ** (ArgumentError) expected a keyword list as the second argument, got: [2, 3]
 
   """
   @spec merge(t, t) :: t
-  def merge(d1, d2) when is_list(d1) and is_list(d2) do
-    fun = fn {k, _v} -> not has_key?(d2, k) end
-    d2 ++ :lists.filter(fun, d1)
+  def merge(keywords1, keywords2)
+
+  def merge(keywords1, []) when is_list(keywords1), do: keywords1
+  def merge([], keywords2) when is_list(keywords2), do: keywords2
+
+  def merge(keywords1, keywords2) when is_list(keywords1) and is_list(keywords2) do
+    if keyword?(keywords2) do
+      fun = fn
+        {key, _value} when is_atom(key) ->
+          not has_key?(keywords2, key)
+
+        _ ->
+          raise ArgumentError,
+                "expected a keyword list as the first argument, got: #{inspect(keywords1)}"
+      end
+
+      :lists.filter(fun, keywords1) ++ keywords2
+    else
+      raise ArgumentError,
+            "expected a keyword list as the second argument, got: #{inspect(keywords2)}"
+    end
   end
 
   @doc """
-  Merges two keyword lists into one. If they have duplicated
-  entries, the given function is invoked to solve conflicts.
+  Merges two keyword lists into one.
+
+  Adds all keys, including duplicate keys, given in `keywords2`
+  to `keywords1`. Invokes the given function to solve conflicts.
+
+  If `keywords2` has duplicate keys, it invokes the given function
+  for each matching pair in `keywords1`.
+
+  There are no guarantees about the order of the keys in the returned keyword.
 
   ## Examples
 
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4], fn (_k, v1, v2) ->
-      ...>  v1 + v2
+      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4], fn _k, v1, v2 ->
+      ...>   v1 + v2
       ...> end)
-      [a: 4, b: 2, d: 4]
+      [b: 2, a: 4, d: 4]
+
+      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
+      ...>   v1 + v2
+      ...> end)
+      [b: 2, a: 4, d: 4, a: 5]
+
+      iex> Keyword.merge([a: 1, b: 2, a: 3], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
+      ...>   v1 + v2
+      ...> end)
+      [b: 2, a: 4, d: 4, a: 8]
+
+      iex> Keyword.merge([a: 1, b: 2], [:a, :b], fn :a, v1, v2 ->
+      ...>   v1 + v2
+      ...> end)
+      ** (ArgumentError) expected a keyword list as the second argument, got: [:a, :b]
 
   """
   @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(d1, d2, fun) when is_list(d1) and is_list(d2) do
-    do_merge(d2, d1, fun)
+  def merge(keywords1, keywords2, fun)
+      when is_list(keywords1) and is_list(keywords2) and is_function(fun, 3) do
+    if keyword?(keywords1) do
+      do_merge(keywords2, [], keywords1, keywords1, fun, keywords2)
+    else
+      raise ArgumentError,
+            "expected a keyword list as the first argument, got: #{inspect(keywords1)}"
+    end
+  end
+
+  defp do_merge([{key, value2} | tail], acc, rest, original, fun, keywords2) when is_atom(key) do
+    case :lists.keyfind(key, 1, original) do
+      {^key, value1} ->
+        acc = [{key, fun.(key, value1, value2)} | acc]
+        original = :lists.keydelete(key, 1, original)
+        do_merge(tail, acc, delete(rest, key), original, fun, keywords2)
+
+      false ->
+        do_merge(tail, [{key, value2} | acc], rest, original, fun, keywords2)
+    end
   end
 
-  defp do_merge([{k, v2}|t], acc, fun) do
-    do_merge t, update(acc, k, v2, fn(v1) -> fun.(k, v1, v2) end), fun
+  defp do_merge([], acc, rest, _original, _fun, _keywords2) do
+    rest ++ :lists.reverse(acc)
   end
 
-  defp do_merge([], acc, _fun) do
-    acc
+  defp do_merge(_other, _acc, _rest, _original, _fun, keywords2) do
+    raise ArgumentError,
+          "expected a keyword list as the second argument, got: #{inspect(keywords2)}"
   end
 
   @doc """
@@ -381,7 +1115,6 @@ defmodule Keyword do
 
       iex> Keyword.has_key?([a: 1], :a)
       true
-
       iex> Keyword.has_key?([a: 1], :b)
       false
 
@@ -392,92 +1125,104 @@ defmodule Keyword do
   end
 
   @doc """
-  Updates the `key` with the given function. If the `key` does
-  not exist, raises `KeyError`.
+  Updates the value under `key` using the given function.
+
+  Raises `KeyError` if the `key` does not exist.
 
-  If there are duplicated entries, they are all removed and only the first one
-  is updated.
+  Removes all duplicate keys and only updates the first one.
 
   ## Examples
 
-      iex> Keyword.update!([a: 1], :a, &(&1 * 2))
-      [a: 2]
+      iex> Keyword.update!([a: 1, b: 2, a: 3], :a, &(&1 * 2))
+      [a: 2, b: 2]
+      iex> Keyword.update!([a: 1, b: 2, c: 3], :b, &(&1 * 2))
+      [a: 1, b: 4, c: 3]
 
       iex> Keyword.update!([a: 1], :b, &(&1 * 2))
-      ** (KeyError) key :b not found in: [a: 1]
+      ** (KeyError) key :b not found in:
+      ...
 
   """
-  @spec update!(t, key, (value -> value)) :: t | no_return
-  def update!(keywords, key, fun) do
+  @spec update!(t, key, (current_value :: value -> new_value :: value)) :: t
+  def update!(keywords, key, fun)
+      when is_list(keywords) and is_atom(key) and is_function(fun, 1) do
     update!(keywords, key, fun, keywords)
   end
 
-  defp update!([{key, value}|keywords], key, fun, _dict) do
-    [{key, fun.(value)}|delete(keywords, key)]
+  defp update!([{key, value} | keywords], key, fun, _original) do
+    [{key, fun.(value)} | delete(keywords, key)]
   end
 
-  defp update!([{_, _} = e|keywords], key, fun, dict) do
-    [e|update!(keywords, key, fun, dict)]
+  defp update!([{_, _} = pair | keywords], key, fun, original) do
+    [pair | update!(keywords, key, fun, original)]
   end
 
-  defp update!([], key, _fun, dict) when is_atom(key) do
-    raise(KeyError, key: key, term: dict)
+  defp update!([], key, _fun, original) do
+    raise KeyError, key: key, term: original
   end
 
   @doc """
-  Updates the `key` with the given function. If the `key` does
-  not exist, inserts the given `initial` value.
+  Updates the value under `key` in `keywords` using the given function.
+
+  If the `key` does not exist, it inserts the given `default` value.
+  Does not pass the `default` value through the update function.
 
-  If there are duplicated entries, they are all removed and only the first one
-  is updated.
+  Removes all duplicate keys and only updates the first one.
 
   ## Examples
 
-      iex> Keyword.update([a: 1], :a, 13, &(&1 * 2))
+      iex> Keyword.update([a: 1], :a, 13, fn existing_value -> existing_value * 2 end)
       [a: 2]
 
-      iex> Keyword.update([a: 1], :b, 11, &(&1 * 2))
+      iex> Keyword.update([a: 1, a: 2], :a, 13, fn existing_value -> existing_value * 2 end)
+      [a: 2]
+
+      iex> Keyword.update([a: 1], :b, 11, fn existing_value -> existing_value * 2 end)
       [a: 1, b: 11]
 
   """
-  @spec update(t, key, value, (value -> value)) :: t
-  def update([{key, value}|keywords], key, _initial, fun) do
-    [{key, fun.(value)}|delete(keywords, key)]
+  @spec update(t, key, default :: value, (existing_value :: value -> new_value :: value)) :: t
+  def update(keywords, key, default, fun)
+      when is_list(keywords) and is_atom(key) and is_function(fun, 1) do
+    update_guarded(keywords, key, default, fun)
+  end
+
+  defp update_guarded([{key, value} | keywords], key, _default, fun) do
+    [{key, fun.(value)} | delete(keywords, key)]
   end
 
-  def update([{_, _} = e|keywords], key, initial, fun) do
-    [e|update(keywords, key, initial, fun)]
+  defp update_guarded([{_, _} = pair | keywords], key, default, fun) do
+    [pair | update_guarded(keywords, key, default, fun)]
   end
 
-  def update([], key, initial, _fun) when is_atom(key) do
-    [{key, initial}]
+  defp update_guarded([], key, default, _fun) do
+    [{key, default}]
   end
 
   @doc """
-  Takes all entries corresponding to the given keys and extracts them into a
-  separate keyword list. Returns a tuple with the new list and the old list
-  with removed keys.
+  Takes all entries corresponding to the given `keys` and extracts them into a
+  separate keyword list.
 
-  Keys for which there are no entires in the keyword list are ignored.
+  Returns a tuple with the new list and the old list with removed keys.
 
-  Entries with duplicated keys end up in the same keyword list.
+  Ignores keys for which there are no entries in the keyword list.
 
-  ## Examples
+  Entries with duplicate keys end up in the same keyword list.
 
-      iex> d = [a: 1, b: 2, c: 3, d: 4]
-      iex> Keyword.split(d, [:a, :c, :e])
-      {[a: 1, c: 3], [b: 2, d: 4]}
+  ## Examples
 
-      iex> d = [a: 1, b: 2, c: 3, d: 4, a: 5]
-      iex> Keyword.split(d, [:a, :c, :e])
-      {[a: 1, c: 3, a: 5], [b: 2, d: 4]}
+      iex> Keyword.split([a: 1, b: 2, c: 3], [:a, :c, :e])
+      {[a: 1, c: 3], [b: 2]}
+      iex> Keyword.split([a: 1, b: 2, c: 3, a: 4], [:a, :c, :e])
+      {[a: 1, c: 3, a: 4], [b: 2]}
 
   """
-  def split(keywords, keys) when is_list(keywords) do
+  @spec split(t, [key]) :: {t, t}
+  def split(keywords, keys) when is_list(keywords) and is_list(keys) do
     fun = fn {k, v}, {take, drop} ->
       case k in keys do
-        true  -> {[{k, v}|take], drop}
-        false -> {take, [{k, v}|drop]}
+        true -> {[{k, v} | take], drop}
+        false -> {take, [{k, v} | drop]}
       end
     end
 
@@ -487,113 +1232,310 @@ defmodule Keyword do
   end
 
   @doc """
-  Takes all entries corresponding to the given keys and returns them in a new
+  Splits the `keywords` into two keyword lists according to the given function
+  `fun`.
+
+  The provided `fun` receives each `{key, value}` pair in the `keywords` as its only
+  argument. Returns a tuple with the first keyword list containing all the
+  elements in `keywords` for which applying `fun` returned a truthy value, and
+  a second keyword list with all the elements for which applying `fun` returned
+  a falsy value (`false` or `nil`).
+
+  ## Examples
+
+      iex> Keyword.split_with([a: 1, b: 2, c: 3], fn {_k, v} -> rem(v, 2) == 0 end)
+      {[b: 2], [a: 1, c: 3]}
+
+      iex> Keyword.split_with([a: 1, b: 2, c: 3, b: 4], fn {_k, v} -> rem(v, 2) == 0 end)
+      {[b: 2, b: 4], [a: 1, c: 3]}
+
+      iex> Keyword.split_with([a: 1, b: 2, c: 3, b: 4], fn {k, v} -> k in [:a, :c] and rem(v, 2) == 0 end)
+      {[], [a: 1, b: 2, c: 3, b: 4]}
+
+      iex> Keyword.split_with([], fn {_k, v} -> rem(v, 2) == 0 end)
+      {[], []}
+
+  """
+  @doc since: "1.15.0"
+  @spec split_with(t, ({key, value} -> as_boolean(term))) :: {t, t}
+  def split_with(keywords, fun) when is_list(keywords) and is_function(fun, 1) do
+    fun = fn key_value_pair, {while_true, while_false} ->
+      if fun.(key_value_pair) do
+        {[key_value_pair | while_true], while_false}
+      else
+        {while_true, [key_value_pair | while_false]}
+      end
+    end
+
+    :lists.foldr(fun, {[], []}, keywords)
+  end
+
+  @doc """
+  Takes all entries corresponding to the given `keys` and returns them as a new
   keyword list.
 
-  Duplicated keys are preserved in the new keyword list.
+  Preserves duplicate keys in the new keyword list.
 
   ## Examples
 
-      iex> d = [a: 1, b: 2, c: 3, d: 4]
-      iex> Keyword.take(d, [:a, :c, :e])
+      iex> Keyword.take([a: 1, b: 2, c: 3], [:a, :c, :e])
       [a: 1, c: 3]
-
-      iex> d = [a: 1, b: 2, c: 3, d: 4, a: 5]
-      iex> Keyword.take(d, [:a, :c, :e])
+      iex> Keyword.take([a: 1, b: 2, c: 3, a: 5], [:a, :c, :e])
       [a: 1, c: 3, a: 5]
 
   """
-  def take(keywords, keys) when is_list(keywords) do
-    :lists.filter(fn {k, _} -> k in keys end, keywords)
+  @spec take(t, [key]) :: t
+  def take(keywords, keys) when is_list(keywords) and is_list(keys) do
+    :lists.filter(fn {k, _} -> :lists.member(k, keys) end, keywords)
   end
 
   @doc """
-  Drops the given keys from the dict.
+  Drops the given `keys` from the keyword list.
 
-  Duplicated keys are preserved in the new keyword list.
+  Removes duplicate keys from the new keyword list.
 
   ## Examples
 
-      iex> d = [a: 1, b: 2, c: 3, d: 4]
-      iex> Keyword.drop(d, [:b, :d])
+      iex> Keyword.drop([a: 1, a: 2], [:a])
+      []
+      iex> Keyword.drop([a: 1, b: 2, c: 3], [:b, :d])
       [a: 1, c: 3]
-
-      iex> d = [a: 1, b: 2, b: 3, c: 3, d: 4, a: 5]
-      iex> Keyword.drop(d, [:b, :d])
+      iex> Keyword.drop([a: 1, b: 2, b: 3, c: 3, a: 5], [:b, :d])
       [a: 1, c: 3, a: 5]
 
   """
-  def drop(keywords, keys) when is_list(keywords) do
-    :lists.filter(fn {k, _} -> not k in keys end, keywords)
+  @spec drop(t, [key]) :: t
+  def drop(keywords, keys) when is_list(keywords) and is_list(keys) do
+    :lists.filter(fn {k, _} -> k not in keys end, keywords)
+  end
+
+  @doc """
+  Returns the first value for `key` and removes all associated entries in the keyword list.
+
+  It returns a tuple where the first element is the first value for `key` and the
+  second element is a keyword list with all entries associated with `key` removed.
+  If the `key` is not present in the keyword list, it returns `{default, keyword_list}`.
+
+  If you don't want to remove all the entries associated with `key` use `pop_first/3`
+  instead, which will remove only the first entry.
+
+  ## Examples
+
+      iex> Keyword.pop([a: 1], :a)
+      {1, []}
+      iex> Keyword.pop([a: 1], :b)
+      {nil, [a: 1]}
+      iex> Keyword.pop([a: 1], :b, 3)
+      {3, [a: 1]}
+      iex> Keyword.pop([a: 1, a: 2], :a)
+      {1, []}
+
+  """
+  @spec pop(t, key, default) :: {value | default, t}
+  def pop(keywords, key, default \\ nil) when is_list(keywords) and is_atom(key) do
+    case fetch(keywords, key) do
+      {:ok, value} -> {value, delete(keywords, key)}
+      :error -> {default, keywords}
+    end
   end
 
   @doc """
-  Returns the first value associated with `key` in the keyword
-  list as well as the keyword list without `key`.
+  Returns the first value for `key` and removes all associated entries in the keyword list,
+  raising if `key` is not present.
 
-  All duplicated entries are removed. See `pop_first/3` for
-  removing only the first entry.
+  This function behaves like `pop/3`, but raises in case the `key` is not present in the
+  given `keywords`.
 
   ## Examples
 
-      iex> Keyword.pop [a: 1], :a
-      {1,[]}
+      iex> Keyword.pop!([a: 1], :a)
+      {1, []}
+      iex> Keyword.pop!([a: 1, a: 2], :a)
+      {1, []}
+      iex> Keyword.pop!([a: 1], :b)
+      ** (KeyError) key :b not found in:
+      ...
 
-      iex> Keyword.pop [a: 1], :b
-      {nil,[a: 1]}
+  """
+  @doc since: "1.10.0"
+  @spec pop!(t, key) :: {value, t}
+  def pop!(keywords, key) when is_list(keywords) and is_atom(key) do
+    case fetch(keywords, key) do
+      {:ok, value} -> {value, delete(keywords, key)}
+      :error -> raise KeyError, key: key, term: keywords
+    end
+  end
 
-      iex> Keyword.pop [a: 1], :b, 3
-      {3,[a: 1]}
+  @doc """
+  Returns all values for `key` and removes all associated entries in the keyword list.
+
+  It returns a tuple where the first element is a list of values for `key` and the
+  second element is a keyword list with all entries associated with `key` removed.
+  If the `key` is not present in the keyword list, it returns `{[], keyword_list}`.
 
-      iex> Keyword.pop [a: 1], :b, 3
-      {3,[a: 1]}
+  If you don't want to remove all the entries associated with `key` use `pop_first/3`
+  instead, which will remove only the first entry.
 
-      iex> Keyword.pop [a: 1, a: 2], :a
-      {1,[]}
+  ## Examples
+
+      iex> Keyword.pop_values([a: 1], :a)
+      {[1], []}
+      iex> Keyword.pop_values([a: 1], :b)
+      {[], [a: 1]}
+      iex> Keyword.pop_values([a: 1, a: 2], :a)
+      {[1, 2], []}
 
   """
-  def pop(keywords, key, default \\ nil) when is_list(keywords) do
-    {get(keywords, key, default), delete(keywords, key)}
+  @doc since: "1.10.0"
+  @spec pop_values(t, key) :: {[value], t}
+  def pop_values(keywords, key) when is_list(keywords) and is_atom(key) do
+    pop_values(:lists.reverse(keywords), key, [], [])
   end
 
+  defp pop_values([{key, value} | tail], key, values, acc),
+    do: pop_values(tail, key, [value | values], acc)
+
+  defp pop_values([{_, _} = pair | tail], key, values, acc),
+    do: pop_values(tail, key, values, [pair | acc])
+
+  defp pop_values([], _key, values, acc),
+    do: {values, acc}
+
   @doc """
-  Returns the first value associated with `key` in the keyword
-  list as well as the keyword list without that particular ocurrence
-  of `key`.
+  Lazily returns and removes all values associated with `key` in the keyword list.
+
+  This is useful if the default value is very expensive to calculate or
+  generally difficult to set up and tear down again.
 
-  Duplicated entries are not removed.
+  Removes all duplicate keys. See `pop_first/3` for removing only the first entry.
 
   ## Examples
 
-      iex> Keyword.pop_first [a: 1], :a
-      {1,[]}
+      iex> keyword = [a: 1]
+      iex> fun = fn ->
+      ...>   # some expensive operation here
+      ...>   13
+      ...> end
+      iex> Keyword.pop_lazy(keyword, :a, fun)
+      {1, []}
+      iex> Keyword.pop_lazy(keyword, :b, fun)
+      {13, [a: 1]}
+
+  """
+  @spec pop_lazy(t, key, (-> value)) :: {value, t}
+  def pop_lazy(keywords, key, fun)
+      when is_list(keywords) and is_atom(key) and is_function(fun, 0) do
+    case fetch(keywords, key) do
+      {:ok, value} -> {value, delete(keywords, key)}
+      :error -> {fun.(), keywords}
+    end
+  end
 
-      iex> Keyword.pop_first [a: 1], :b
-      {nil,[a: 1]}
+  @doc """
+  Returns and removes the first value associated with `key` in the keyword list.
 
-      iex> Keyword.pop_first [a: 1], :b, 3
-      {3,[a: 1]}
+  Keeps duplicate keys in the resulting keyword list.
 
-      iex> Keyword.pop_first [a: 1], :b, 3
-      {3,[a: 1]}
+  ## Examples
 
-      iex> Keyword.pop_first [a: 1, a: 2], :a
-      {1,[a: 2]}
+      iex> Keyword.pop_first([a: 1], :a)
+      {1, []}
+      iex> Keyword.pop_first([a: 1], :b)
+      {nil, [a: 1]}
+      iex> Keyword.pop_first([a: 1], :b, 3)
+      {3, [a: 1]}
+      iex> Keyword.pop_first([a: 1, a: 2], :a)
+      {1, [a: 2]}
 
   """
-  def pop_first(keywords, key, default \\ nil) when is_list(keywords) do
-    {get(keywords, key, default), delete_first(keywords, key)}
+  @spec pop_first(t, key, default) :: {value | default, t}
+  def pop_first(keywords, key, default \\ nil) when is_list(keywords) and is_atom(key) do
+    case :lists.keytake(key, 1, keywords) do
+      {:value, {^key, value}, rest} -> {value, rest}
+      false -> {default, keywords}
+    end
   end
 
-  # Dict callbacks
+  @doc """
+  Returns the keyword list itself.
+
+  ## Examples
+
+      iex> Keyword.to_list(a: 1)
+      [a: 1]
+
+  """
+  @spec to_list(t) :: t
+  def to_list(keywords) when is_list(keywords) do
+    keywords
+  end
 
   @doc false
-  def size(keyword) do
-    length(keyword)
+  @deprecated "Use Kernel.length/1 instead"
+  def size(keywords) do
+    length(keywords)
+  end
+
+  @doc """
+  Returns a keyword list containing only the entries from `keywords`
+  for which the function `fun` returns a truthy value.
+
+  See also `reject/2` which discards all entries where the function
+  returns a truthy value.
+
+  ## Examples
+
+      iex> Keyword.filter([one: 1, two: 2, three: 3], fn {_key, val} -> rem(val, 2) == 1 end)
+      [one: 1, three: 3]
+
+  """
+  @doc since: "1.13.0"
+  @spec filter(t, ({key, value} -> as_boolean(term))) :: t
+  def filter(keywords, fun) when is_list(keywords) and is_function(fun, 1) do
+    do_filter(keywords, fun)
+  end
+
+  defp do_filter([], _fun), do: []
+
+  defp do_filter([{_, _} = entry | entries], fun) do
+    if fun.(entry) do
+      [entry | do_filter(entries, fun)]
+    else
+      do_filter(entries, fun)
+    end
+  end
+
+  @doc """
+  Returns a keyword list excluding the entries from `keywords`
+  for which the function `fun` returns a truthy value.
+
+  See also `filter/2`.
+
+  ## Examples
+
+      iex> Keyword.reject([one: 1, two: 2, three: 3], fn {_key, val} -> rem(val, 2) == 1 end)
+      [two: 2]
+
+  """
+  @doc since: "1.13.0"
+  @spec reject(t, ({key, value} -> as_boolean(term))) :: t
+  def reject(keywords, fun) when is_list(keywords) and is_function(fun, 1) do
+    do_reject(keywords, fun)
+  end
+
+  defp do_reject([], _fun), do: []
+
+  defp do_reject([{_, _} = entry | entries], fun) do
+    if fun.(entry) do
+      do_reject(entries, fun)
+    else
+      [entry | do_reject(entries, fun)]
+    end
   end
 
   @doc false
-  def to_list(keyword) do
-    keyword
+  @deprecated "Use Keyword.new/2 instead"
+  def map(keywords, fun) when is_list(keywords) do
+    Enum.map(keywords, fn {k, v} -> {k, fun.({k, v})} end)
   end
 end
diff --git a/lib/elixir/lib/list.ex b/lib/elixir/lib/list.ex
index f4990bdc337..e964099fd63 100644
--- a/lib/elixir/lib/list.ex
+++ b/lib/elixir/lib/list.ex
@@ -1,55 +1,192 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule List do
   @moduledoc """
-  Implements functions that only make sense for lists
-  and cannot be part of the Enum protocol. In general,
-  favor using the Enum API instead of List.
+  Linked lists hold zero, one, or more elements in the chosen order.
+
+  Lists in Elixir are specified between square brackets:
+
+      iex> [1, "two", 3, :four]
+      [1, "two", 3, :four]
+
+  Two lists can be concatenated and subtracted using the
+  `++/2` and `--/2` operators:
+
+      iex> [1, 2, 3] ++ [4, 5, 6]
+      [1, 2, 3, 4, 5, 6]
+      iex> [1, true, 2, false, 3, true] -- [true, false]
+      [1, 2, 3, true]
+
+  An element can be prepended to a list using `|`:
+
+      iex> new = 0
+      iex> list = [1, 2, 3]
+      iex> [new | list]
+      [0, 1, 2, 3]
+
+  Lists in Elixir are effectively linked lists, which means
+  they are internally represented in pairs containing the
+  head and the tail of a list:
+
+      iex> [head | tail] = [1, 2, 3]
+      iex> head
+      1
+      iex> tail
+      [2, 3]
+
+  Similarly, we could write the list `[1, 2, 3]` using only
+  such pairs (called cons cells):
+
+      iex> [1 | [2 | [3 | []]]]
+      [1, 2, 3]
 
-  Some functions in this module expect an index. Index
-  access for list is linear. Negative indexes are also
-  supported but they imply the list will be iterated twice,
-  one to calculate the proper index and another to the
-  operation.
+  Some lists, called improper lists, do not have an empty list as
+  the second element in the last cons cell:
 
-  A decision was taken to delegate most functions to
-  Erlang's standard library but follow Elixir's convention
-  of receiving the target (in this case, a list) as the
-  first argument.
+      iex> [1 | [2 | [3 | 4]]]
+      [1, 2, 3 | 4]
+
+  Although improper lists are generally avoided, they are used in some
+  special circumstances like iodata and chardata entities (see the `IO` module).
+
+  Due to their cons cell based representation, prepending an element
+  to a list is always fast (constant time), while appending becomes
+  slower as the list grows in size (linear time):
+
+      iex> list = [1, 2, 3]
+      iex> [0 | list] # fast
+      [0, 1, 2, 3]
+      iex> list ++ [4] # slow
+      [1, 2, 3, 4]
+
+  Most of the functions in this module work in linear time. This means that
+  the time it takes to perform an operation grows at the same rate as the
+  length of the list. For example `length/1` and `last/1` will run in linear
+  time because they need to iterate through every element of the list, but
+  `first/1` will run in constant time because it only needs the first element.
+
+  Lists also implement the `Enumerable` protocol, so many functions to work with
+  lists are found in the `Enum` module. Additionally, the following functions and
+  operators for lists are found in `Kernel`:
+
+    * `++/2`
+    * `--/2`
+    * `hd/1`
+    * `tl/1`
+    * `in/2`
+    * `length/1`
+
+  ## Charlists
+
+  If a list is made of non-negative integers, where each integer represents a
+  Unicode code point, the list can also be called a charlist. These integers
+  must:
+
+    * be within the range `0..0x10FFFF` (`0..1_114_111`);
+    * and be out of the range `0xD800..0xDFFF` (`55_296..57_343`), which is
+      reserved in Unicode for UTF-16 surrogate pairs.
+
+  Elixir uses the [`~c` sigil](`sigil_c/2`) to define charlists:
+
+      iex> ~c"héllo"
+      [104, 233, 108, 108, 111]
+
+  In particular, charlists will be printed back by default with the `~c`
+  sigil if they contain only printable ASCII characters:
+
+      iex> ~c"abc"
+      ~c"abc"
+
+  Even though the representation changed, the raw data does remain a list of
+  integers, which can be handled as such:
+
+      iex> inspect(~c"abc", charlists: :as_list)
+      "[97, 98, 99]"
+      iex> Enum.map(~c"abc", fn num -> 1000 + num end)
+      [1097, 1098, 1099]
+
+  You can use the `IEx.Helpers.i/1` helper to get a condensed rundown on
+  charlists in IEx when you encounter them, which shows you the type, description
+  and also the raw representation in one single summary.
+
+  The rationale behind this behavior is to better support
+  Erlang libraries which may return text as charlists
+  instead of Elixir strings. In Erlang, charlists are the default
+  way of handling strings, while in Elixir it's binaries. One
+  example of such functions is `Application.loaded_applications/0`:
+
+      Application.loaded_applications()
+      #=>  [
+      #=>    {:stdlib, ~c"ERTS  CXC 138 10", ~c"2.6"},
+      #=>    {:compiler, ~c"ERTS  CXC 138 10", ~c"6.0.1"},
+      #=>    {:elixir, ~c"elixir", ~c"1.0.0"},
+      #=>    {:kernel, ~c"ERTS  CXC 138 10", ~c"4.1"},
+      #=>    {:logger, ~c"logger", ~c"1.0.0"}
+      #=>  ]
+
+  A list can be checked if it is made of only printable ASCII
+  characters with `ascii_printable?/2`.
+
+  Improper lists are never deemed as charlists.
   """
 
   @compile :inline_list_funcs
 
   @doc """
-  Deletes the given item from the list. Returns a list without
-  the item. If the item occurs more than once in the list, just
+  Deletes the given `element` from the `list`. Returns a new list without
+  the element.
+
+  If the `element` occurs more than once in the `list`, just
   the first occurrence is removed.
 
   ## Examples
 
-      iex> List.delete([1, 2, 3], 1)
-      [2,3]
+      iex> List.delete([:a, :b, :c], :a)
+      [:b, :c]
 
-      iex> List.delete([1, 2, 2, 3], 2)
-      [1, 2, 3]
+      iex> List.delete([:a, :b, :c], :d)
+      [:a, :b, :c]
+
+      iex> List.delete([:a, :b, :b, :c], :b)
+      [:a, :b, :c]
+
+      iex> List.delete([], :b)
+      []
 
   """
-  @spec delete(list, any) :: list
-  def delete(list, item) do
-    :lists.delete(item, list)
-  end
+  @spec delete([], any) :: []
+  @spec delete([...], any) :: list
+  def delete(list, element)
+  def delete([element | list], element), do: list
+  def delete([other | list], element), do: [other | delete(list, element)]
+  def delete([], _element), do: []
 
   @doc """
   Duplicates the given element `n` times in a list.
 
+  `n` is an integer greater than or equal to `0`.
+
+  If `n` is `0`, an empty list is returned.
+
   ## Examples
 
-      iex> List.duplicate("hello", 3)
-      ["hello","hello","hello"]
+      iex> List.duplicate("hello", 0)
+      []
+
+      iex> List.duplicate("hi", 1)
+      ["hi"]
+
+      iex> List.duplicate("bye", 2)
+      ["bye", "bye"]
 
-      iex> List.duplicate([1, 2], 2)
-      [[1,2],[1,2]]
+      iex> List.duplicate([1, 2], 3)
+      [[1, 2], [1, 2], [1, 2]]
 
   """
-  @spec duplicate(elem, non_neg_integer) :: [elem] when elem: var
+  @spec duplicate(any, 0) :: []
+  @spec duplicate(elem, pos_integer) :: [elem, ...] when elem: var
   def duplicate(elem, n) do
     :lists.duplicate(n, elem)
   end
@@ -57,10 +194,15 @@ defmodule List do
   @doc """
   Flattens the given `list` of nested lists.
 
+  Empty list elements are discarded.
+
   ## Examples
 
       iex> List.flatten([1, [[2], 3]])
-      [1,2,3]
+      [1, 2, 3]
+
+      iex> List.flatten([[], [[], []]])
+      []
 
   """
   @spec flatten(deep_list) :: list when deep_list: [any | deep_list]
@@ -73,10 +215,16 @@ defmodule List do
   The list `tail` will be added at the end of
   the flattened list.
 
+  Empty list elements from `list` are discarded,
+  but not the ones from `tail`.
+
   ## Examples
 
       iex> List.flatten([1, [[2], 3]], [4, 5])
-      [1,2,3,4,5]
+      [1, 2, 3, 4, 5]
+
+      iex> List.flatten([1, [], 2], [3, [], 4])
+      [1, 2, 3, [], 4]
 
   """
   @spec flatten(deep_list, [elem]) :: [elem] when elem: var, deep_list: [elem | deep_list]
@@ -85,46 +233,57 @@ defmodule List do
   end
 
   @doc """
-  Folds (reduces) the given list to the left with
-  a function. Requires an accumulator.
+  Folds (reduces) the given list from the left with
+  a function. Requires an accumulator, which can be any value.
 
   ## Examples
 
-      iex> List.foldl([5, 5], 10, fn (x, acc) -> x + acc end)
+      iex> List.foldl([5, 5], 10, fn x, acc -> x + acc end)
       20
 
-      iex> List.foldl([1, 2, 3, 4], 0, fn (x, acc) -> x - acc end)
+      iex> List.foldl([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
       2
 
+      iex> List.foldl([1, 2, 3], {0, 0}, fn x, {a1, a2} -> {a1 + x, a2 - x} end)
+      {6, -6}
+
   """
   @spec foldl([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
-  def foldl(list, acc, function) when is_list(list) and is_function(function) do
-    :lists.foldl(function, acc, list)
+  def foldl(list, acc, fun) when is_list(list) and is_function(fun) do
+    :lists.foldl(fun, acc, list)
   end
 
   @doc """
-  Folds (reduces) the given list to the right with
-  a function. Requires an accumulator.
+  Folds (reduces) the given list from the right with
+  a function. Requires an accumulator, which can be any value.
 
   ## Examples
 
-      iex> List.foldr([1, 2, 3, 4], 0, fn (x, acc) -> x - acc end)
+      iex> List.foldr([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
       -2
 
+      iex> List.foldr([1, 2, 3, 4], %{sum: 0, product: 1}, fn x, %{sum: a1, product: a2} -> %{sum: a1 + x, product: a2 * x} end)
+      %{product: 24, sum: 10}
+
   """
   @spec foldr([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
-  def foldr(list, acc, function) when is_list(list) and is_function(function) do
-    :lists.foldr(function, acc, list)
+  def foldr(list, acc, fun) when is_list(list) and is_function(fun) do
+    :lists.foldr(fun, acc, list)
   end
 
   @doc """
-  Returns the first element in `list` or `nil` if `list` is empty.
+  Returns the first element in `list` or `default` if `list` is empty.
+
+  `first/2` has been introduced in Elixir v1.12.0, while `first/1` has been available since v1.0.0.
 
   ## Examples
 
       iex> List.first([])
       nil
 
+      iex> List.first([], 1)
+      1
+
       iex> List.first([1])
       1
 
@@ -132,18 +291,25 @@ defmodule List do
       1
 
   """
-  @spec first([elem]) :: nil | elem when elem: var
-  def first([]),    do: nil
-  def first([h|_]), do: h
+  @spec first([], any) :: any
+  @spec first([elem, ...], any) :: elem when elem: var
+  def first(list, default \\ nil)
+  def first([], default), do: default
+  def first([head | _], _default), do: head
 
   @doc """
-  Returns the last element in `list` or `nil` if `list` is empty.
+  Returns the last element in `list` or `default` if `list` is empty.
+
+  `last/2` has been introduced in Elixir v1.12.0, while `last/1` has been available since v1.0.0.
 
   ## Examples
 
       iex> List.last([])
       nil
 
+      iex> List.last([], 1)
+      1
+
       iex> List.last([1])
       1
 
@@ -151,15 +317,20 @@ defmodule List do
       3
 
   """
-  @spec last([elem]) :: nil | elem when elem: var
-  def last([]),    do: nil
-  def last([h]),   do: h
-  def last([_|t]), do: last(t)
+  @spec last([], any) :: any
+  @spec last([elem, ...], any) :: elem when elem: var
+  @compile {:inline, last: 2}
+  def last(list, default \\ nil)
+  def last([], default), do: default
+  def last([head], _default), do: head
+  def last([_ | tail], default), do: last(tail, default)
 
   @doc """
   Receives a list of tuples and returns the first tuple
-  where the item at `position` in the tuple matches the
-  given `item`.
+  where the element at `position` in the tuple matches the
+  given `key`.
+
+  If no matching tuple is found, `default` is returned.
 
   ## Examples
 
@@ -172,16 +343,56 @@ defmodule List do
       iex> List.keyfind([a: 1, b: 2], :c, 0)
       nil
 
+  This function works for any list of tuples:
+
+      iex> List.keyfind([{22, "SSH"}, {80, "HTTP"}], 22, 0)
+      {22, "SSH"}
+
   """
   @spec keyfind([tuple], any, non_neg_integer, any) :: any
-  def keyfind(list, key, position, default \\ nil) do
+  def keyfind(list, key, position, default \\ nil) when is_integer(position) do
     :lists.keyfind(key, position + 1, list) || default
   end
 
+  @doc """
+  Receives a list of tuples and returns the first tuple
+  where the element at `position` in the tuple matches the
+  given `key`.
+
+  If no matching tuple is found, an error is raised.
+
+  ## Examples
+
+      iex> List.keyfind!([a: 1, b: 2], :a, 0)
+      {:a, 1}
+
+      iex> List.keyfind!([a: 1, b: 2], 2, 1)
+      {:b, 2}
+
+      iex> List.keyfind!([a: 1, b: 2], :c, 0)
+      ** (KeyError) key :c at position 0 not found in: [a: 1, b: 2]
+
+  This function works for any list of tuples:
+
+      iex> List.keyfind!([{22, "SSH"}, {80, "HTTP"}], 22, 0)
+      {22, "SSH"}
+
+  """
+  @doc since: "1.13.0"
+  @spec keyfind!([tuple], any, non_neg_integer) :: any
+  def keyfind!(list, key, position) when is_integer(position) do
+    :lists.keyfind(key, position + 1, list) ||
+      raise KeyError,
+        key: key,
+        term: list,
+        message:
+          "key #{inspect(key)} at position #{inspect(position)} not found in: #{inspect(list)}"
+  end
+
   @doc """
   Receives a list of tuples and returns `true` if there is
-  a tuple where the item at `position` in the tuple matches
-  the given `item`.
+  a tuple where the element at `position` in the tuple matches
+  the given `key`.
 
   ## Examples
 
@@ -194,30 +405,49 @@ defmodule List do
       iex> List.keymember?([a: 1, b: 2], :c, 0)
       false
 
+  This function works for any list of tuples:
+
+      iex> List.keymember?([{22, "SSH"}, {80, "HTTP"}], 22, 0)
+      true
+
   """
-  @spec keymember?([tuple], any, non_neg_integer) :: any
-  def keymember?(list, key, position) do
+  @spec keymember?([tuple], any, non_neg_integer) :: boolean
+  def keymember?(list, key, position) when is_integer(position) do
     :lists.keymember(key, position + 1, list)
   end
 
   @doc """
-  Receives a list of tuples and replaces the item
-  identified by `key` at `position` if it exists.
+  Receives a list of tuples and if the identified element by `key` at `position`
+  exists, it is replaced with `new_tuple`.
 
   ## Examples
 
       iex> List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3})
       [a: 3, b: 2]
 
+      iex> List.keyreplace([a: 1, b: 2], :a, 1, {:a, 3})
+      [a: 1, b: 2]
+
+  This function works for any list of tuples:
+
+      iex> List.keyreplace([{22, "SSH"}, {80, "HTTP"}], 22, 0, {22, "Secure Shell"})
+      [{22, "Secure Shell"}, {80, "HTTP"}]
+
   """
   @spec keyreplace([tuple], any, non_neg_integer, tuple) :: [tuple]
-  def keyreplace(list, key, position, new_tuple) do
+  def keyreplace(list, key, position, new_tuple) when is_integer(position) do
     :lists.keyreplace(key, position + 1, list, new_tuple)
   end
 
   @doc """
-  Receives a list of tuples and sorts the items
-  at `position` of the tuples. The sort is stable.
+  Receives a list of tuples and sorts the elements
+  at `position` of the tuples.
+
+  The sort is stable.
+
+  A `sorter` argument is available since Elixir v1.14.0. Similar to
+  `Enum.sort/2`, the sorter can be an anonymous function, the atoms
+  `:asc` or `:desc`, or module that implements a compare function.
 
   ## Examples
 
@@ -227,16 +457,74 @@ defmodule List do
       iex> List.keysort([a: 5, c: 1, b: 3], 0)
       [a: 5, b: 3, c: 1]
 
+  To sort in descending order:
+
+      iex> List.keysort([a: 5, c: 1, b: 3], 0, :desc)
+      [c: 1, b: 3, a: 5]
+
+  As in `Enum.sort/2`, avoid using the default sorting function to sort
+  structs, as by default it performs structural comparison instead of a
+  semantic one. In such cases, you shall pass a sorting function as third
+  element or any module that implements a `compare/2` function. For example,
+  if you have tuples with user names and their birthday, and you want to
+  sort on their birthday, in both ascending and descending order, you should
+  do:
+
+      iex> users = [
+      ...>   {"Ellis", ~D[1943-05-11]},
+      ...>   {"Lovelace", ~D[1815-12-10]},
+      ...>   {"Turing", ~D[1912-06-23]}
+      ...> ]
+      iex> List.keysort(users, 1, Date)
+      [
+        {"Lovelace", ~D[1815-12-10]},
+        {"Turing", ~D[1912-06-23]},
+        {"Ellis", ~D[1943-05-11]}
+      ]
+      iex> List.keysort(users, 1, {:desc, Date})
+      [
+        {"Ellis", ~D[1943-05-11]},
+        {"Turing", ~D[1912-06-23]},
+        {"Lovelace", ~D[1815-12-10]}
+      ]
+
   """
-  @spec keysort([tuple], non_neg_integer) :: [tuple]
-  def keysort(list, position) do
+  @doc since: "1.14.0"
+  @spec keysort(
+          [tuple],
+          non_neg_integer,
+          (any, any -> boolean) | :asc | :desc | module() | {:asc | :desc, module()}
+        ) :: [tuple]
+  def keysort(list, position, sorter \\ :asc)
+
+  def keysort(list, position, :asc) when is_list(list) and is_integer(position) do
     :lists.keysort(position + 1, list)
   end
 
+  def keysort(list, position, sorter) when is_list(list) and is_integer(position) do
+    :lists.sort(keysort_fun(sorter, position + 1), list)
+  end
+
+  defp keysort_fun(sorter, position) when is_function(sorter, 2),
+    do: &sorter.(:erlang.element(position, &1), :erlang.element(position, &2))
+
+  defp keysort_fun(:desc, position),
+    do: &(:erlang.element(position, &1) >= :erlang.element(position, &2))
+
+  defp keysort_fun(module, position) when is_atom(module),
+    do: &(module.compare(:erlang.element(position, &1), :erlang.element(position, &2)) != :gt)
+
+  defp keysort_fun({:asc, module}, position) when is_atom(module),
+    do: &(module.compare(:erlang.element(position, &1), :erlang.element(position, &2)) != :gt)
+
+  defp keysort_fun({:desc, module}, position) when is_atom(module),
+    do: &(module.compare(:erlang.element(position, &1), :erlang.element(position, &2)) != :lt)
+
   @doc """
-  Receives a list of tuples and replaces the item
-  identified by `key` at `position`. If the item
-  does not exist, it is added to the end of the list.
+  Receives a `list` of tuples and replaces the element
+  identified by `key` at `position` with `new_tuple`.
+
+  If the element does not exist, it is added to the end of the `list`.
 
   ## Examples
 
@@ -246,16 +534,21 @@ defmodule List do
       iex> List.keystore([a: 1, b: 2], :c, 0, {:c, 3})
       [a: 1, b: 2, c: 3]
 
+  This function works for any list of tuples:
+
+      iex> List.keystore([{22, "SSH"}], 80, 0, {80, "HTTP"})
+      [{22, "SSH"}, {80, "HTTP"}]
+
   """
-  @spec keystore([tuple], any, non_neg_integer, tuple) :: [tuple]
-  def keystore(list, key, position, new_tuple) do
+  @spec keystore([tuple], any, non_neg_integer, tuple) :: [tuple, ...]
+  def keystore(list, key, position, new_tuple) when is_integer(position) do
     :lists.keystore(key, position + 1, list, new_tuple)
   end
 
   @doc """
-  Receives a list of tuples and deletes the first tuple
-  where the item at `position` matches the
-  given `item`. Returns the new list.
+  Receives a `list` of tuples and deletes the first tuple
+  where the element at `position` matches the
+  given `key`. Returns the new list.
 
   ## Examples
 
@@ -268,16 +561,54 @@ defmodule List do
       iex> List.keydelete([a: 1, b: 2], :c, 0)
       [a: 1, b: 2]
 
+  This function works for any list of tuples:
+
+      iex> List.keydelete([{22, "SSH"}, {80, "HTTP"}], 80, 0)
+      [{22, "SSH"}]
+
   """
   @spec keydelete([tuple], any, non_neg_integer) :: [tuple]
-  def keydelete(list, key, position) do
+  def keydelete(list, key, position) when is_integer(position) do
     :lists.keydelete(key, position + 1, list)
   end
 
   @doc """
-  Wraps the argument in a list.
-  If the argument is already a list, returns the list.
-  If the argument is `nil`, returns an empty list.
+  Receives a `list` of tuples and returns the first tuple
+  where the element at `position` in the tuple matches the
+  given `key`, as well as the `list` without found tuple.
+
+  If such a tuple is not found, `nil` will be returned.
+
+  ## Examples
+
+      iex> List.keytake([a: 1, b: 2], :a, 0)
+      {{:a, 1}, [b: 2]}
+
+      iex> List.keytake([a: 1, b: 2], 2, 1)
+      {{:b, 2}, [a: 1]}
+
+      iex> List.keytake([a: 1, b: 2], :c, 0)
+      nil
+
+  This function works for any list of tuples:
+
+      iex> List.keytake([{22, "SSH"}, {80, "HTTP"}], 80, 0)
+      {{80, "HTTP"}, [{22, "SSH"}]}
+
+  """
+  @spec keytake([tuple], any, non_neg_integer) :: {tuple, [tuple]} | nil
+  def keytake(list, key, position) when is_integer(position) do
+    case :lists.keytake(key, position + 1, list) do
+      {:value, element, list} -> {element, list}
+      false -> nil
+    end
+  end
+
+  @doc """
+  Wraps `term` in a list if this is not list.
+
+  If `term` is already a list, it returns the list.
+  If `term` is `nil`, it returns an empty list.
 
   ## Examples
 
@@ -285,13 +616,15 @@ defmodule List do
       ["hello"]
 
       iex> List.wrap([1, 2, 3])
-      [1,2,3]
+      [1, 2, 3]
 
       iex> List.wrap(nil)
       []
 
   """
-  @spec wrap(list | any) :: list
+  @spec wrap(term) :: maybe_improper_list()
+  def wrap(term)
+
   def wrap(list) when is_list(list) do
     list
   end
@@ -304,46 +637,129 @@ defmodule List do
     [other]
   end
 
-  @doc """
-  Zips corresponding elements from each list in `list_of_lists`.
+  @deprecated "Use Enum.zip/1 instead"
+  # We keep the old implementation because it also supported lists
+  # of tuples, even though this was not included in its @spec.
+  def zip([]), do: []
+  def zip(list_of_lists) when is_list(list_of_lists), do: do_zip(list_of_lists, [])
+
+  defp do_zip(list, acc) do
+    converter = fn x, acc -> do_zip_each(to_list(x), acc) end
+
+    case :lists.mapfoldl(converter, [], list) do
+      {_, nil} ->
+        :lists.reverse(acc)
+
+      {mlist, heads} ->
+        do_zip(mlist, [to_tuple(:lists.reverse(heads)) | acc])
+    end
+  end
+
+  defp do_zip_each(_, nil) do
+    {nil, nil}
+  end
+
+  defp do_zip_each([head | tail], acc) do
+    {tail, [head | acc]}
+  end
+
+  defp do_zip_each([], _) do
+    {nil, nil}
+  end
+
+  defp to_list(tuple) when is_tuple(tuple), do: Tuple.to_list(tuple)
+  defp to_list(list) when is_list(list), do: list
+
+  @doc ~S"""
+  Checks if `list` is a charlist made only of printable ASCII characters.
+
+  Takes an optional `limit` as a second argument. `ascii_printable?/2` only
+  checks the printability of the list up to the `limit`.
+
+  A printable charlist in Elixir contains only the printable characters in the
+  standard seven-bit ASCII character encoding, which are characters ranging from
+  32 to 126 in decimal notation, plus the following control characters:
+
+    * `?\a` - Bell
+    * `?\b` - Backspace
+    * `?\t` - Horizontal tab
+    * `?\n` - Line feed
+    * `?\v` - Vertical tab
+    * `?\f` - Form feed
+    * `?\r` - Carriage return
+    * `?\e` - Escape
+
+  For more information read the [Character groups](https://en.wikipedia.org/wiki/ASCII#Character_groups)
+  section in the Wikipedia article of the [ASCII](https://en.wikipedia.org/wiki/ASCII) standard.
 
   ## Examples
 
-      iex> List.zip([[1, 2], [3, 4], [5, 6]])
-      [{1, 3, 5}, {2, 4, 6}]
+      iex> List.ascii_printable?(~c"abc")
+      true
+
+      iex> List.ascii_printable?(~c"abc" ++ [0])
+      false
+
+      iex> List.ascii_printable?(~c"abc" ++ [0], 2)
+      true
+
+  Improper lists are not printable, even if made only of ASCII characters:
 
-      iex> List.zip([[1, 2], [3], [5, 6]])
-      [{1, 3, 5}]
+      iex> List.ascii_printable?(~c"abc" ++ ?d)
+      false
 
   """
-  @spec zip([list]) :: [tuple]
-  def zip([]), do: []
-  def zip(list_of_lists) when is_list(list_of_lists) do
-    do_zip(list_of_lists, [])
+  @doc since: "1.6.0"
+  @spec ascii_printable?(list, 0) :: true
+  @spec ascii_printable?([], limit) :: true
+        when limit: :infinity | pos_integer
+  @spec ascii_printable?([...], limit) :: boolean
+        when limit: :infinity | pos_integer
+  def ascii_printable?(list, limit \\ :infinity)
+      when is_list(list) and (limit == :infinity or (is_integer(limit) and limit >= 0)) do
+    ascii_printable_guarded?(list, limit)
   end
 
+  defp ascii_printable_guarded?(_, 0) do
+    true
+  end
+
+  defp ascii_printable_guarded?([char | rest], counter)
+       # 7..13 is the range '\a\b\t\n\v\f\r'. 32..126 are ASCII printables.
+       when is_integer(char) and
+              ((char >= 7 and char <= 13) or char == ?\e or (char >= 32 and char <= 126)) do
+    ascii_printable_guarded?(rest, decrement(counter))
+  end
+
+  defp ascii_printable_guarded?([], _counter), do: true
+  defp ascii_printable_guarded?(_, _counter), do: false
+
+  @compile {:inline, decrement: 1}
+  defp decrement(:infinity), do: :infinity
+  defp decrement(counter), do: counter - 1
+
   @doc """
-  Unzips the given list of lists or tuples into separate lists and returns a
-  list of lists.
+  Returns `true` if `list` is an improper list. Otherwise returns `false`.
 
   ## Examples
 
-      iex> List.unzip([{1, 2}, {3, 4}])
-      [[1, 3], [2, 4]]
+      iex> List.improper?([1, 2 | 3])
+      true
 
-      iex> List.unzip([{1, :a, "apple"}, {2, :b, "banana"}, {3, :c}])
-      [[1, 2, 3], [:a, :b, :c]]
+      iex> List.improper?([1, 2, 3])
+      false
 
   """
-  @spec unzip([tuple]) :: [list]
-  def unzip(list) when is_list(list) do
-    :lists.map &Tuple.to_list/1, zip(list)
-  end
+  @doc since: "1.8.0"
+  @spec improper?(maybe_improper_list) :: boolean
+  def improper?(list) when is_list(list) and length(list) >= 0, do: false
+  def improper?(list) when is_list(list), do: true
 
   @doc """
   Returns a list with `value` inserted at the specified `index`.
+
   Note that `index` is capped at the list length. Negative indices
-  indicate an offset from the end of the list.
+  indicate an offset from the end of the `list`.
 
   ## Examples
 
@@ -361,17 +777,26 @@ defmodule List do
 
   """
   @spec insert_at(list, integer, any) :: list
-  def insert_at(list, index, value) do
-    if index < 0 do
-      do_insert_at(list, length(list) + index + 1, value)
-    else
-      do_insert_at(list, index, value)
+  def insert_at(list, index, value) when is_list(list) and is_integer(index) do
+    case index do
+      -1 ->
+        list ++ [value]
+
+      _ when index < 0 ->
+        case length(list) + index + 1 do
+          index when index < 0 -> [value | list]
+          index -> do_insert_at(list, index, value)
+        end
+
+      _ ->
+        do_insert_at(list, index, value)
     end
   end
 
   @doc """
   Returns a list with a replaced value at the specified `index`.
-  Negative indices indicate an offset from the end of the list.
+
+  Negative indices indicate an offset from the end of the `list`.
   If `index` is out of bounds, the original `list` is returned.
 
   ## Examples
@@ -390,9 +815,12 @@ defmodule List do
 
   """
   @spec replace_at(list, integer, any) :: list
-  def replace_at(list, index, value) do
+  def replace_at(list, index, value) when is_list(list) and is_integer(index) do
     if index < 0 do
-      do_replace_at(list, length(list) + index, value)
+      case length(list) + index do
+        index when index < 0 -> list
+        index -> do_replace_at(list, index, value)
+      end
     else
       do_replace_at(list, index, value)
     end
@@ -400,7 +828,8 @@ defmodule List do
 
   @doc """
   Returns a list with an updated value at the specified `index`.
-  Negative indices indicate an offset from the end of the list.
+
+  Negative indices indicate an offset from the end of the `list`.
   If `index` is out of bounds, the original `list` is returned.
 
   ## Examples
@@ -419,9 +848,12 @@ defmodule List do
 
   """
   @spec update_at([elem], integer, (elem -> any)) :: list when elem: var
-  def update_at(list, index, fun) do
+  def update_at(list, index, fun) when is_list(list) and is_function(fun) and is_integer(index) do
     if index < 0 do
-      do_update_at(list, length(list) + index, fun)
+      case length(list) + index do
+        index when index < 0 -> list
+        index -> do_update_at(list, index, fun)
+      end
     else
       do_update_at(list, index, fun)
     end
@@ -429,7 +861,8 @@ defmodule List do
 
   @doc """
   Produces a new list by removing the value at the specified `index`.
-  Negative indices indicate an offset from the end of the list.
+
+  Negative indices indicate an offset from the end of the `list`.
   If `index` is out of bounds, the original `list` is returned.
 
   ## Examples
@@ -437,7 +870,7 @@ defmodule List do
       iex> List.delete_at([1, 2, 3], 0)
       [2, 3]
 
-      iex List.delete_at([1, 2, 3], 10)
+      iex> List.delete_at([1, 2, 3], 10)
       [1, 2, 3]
 
       iex> List.delete_at([1, 2, 3], -1)
@@ -445,92 +878,199 @@ defmodule List do
 
   """
   @spec delete_at(list, integer) :: list
-  def delete_at(list, index) do
+  def delete_at(list, index) when is_integer(index) do
+    elem(pop_at(list, index), 1)
+  end
+
+  @doc """
+  Returns and removes the value at the specified `index` in the `list`.
+
+  Negative indices indicate an offset from the end of the `list`.
+  If `index` is out of bounds, the original `list` is returned.
+
+  ## Examples
+
+      iex> List.pop_at([1, 2, 3], 0)
+      {1, [2, 3]}
+      iex> List.pop_at([1, 2, 3], 5)
+      {nil, [1, 2, 3]}
+      iex> List.pop_at([1, 2, 3], 5, 10)
+      {10, [1, 2, 3]}
+      iex> List.pop_at([1, 2, 3], -1)
+      {3, [1, 2]}
+
+  """
+  @doc since: "1.4.0"
+  @spec pop_at(list, integer, any) :: {any, list}
+  def pop_at(list, index, default \\ nil) when is_integer(index) do
     if index < 0 do
-      do_delete_at(list, length(list) + index)
+      do_pop_at(list, length(list) + index, default, [])
     else
-      do_delete_at(list, index)
+      do_pop_at(list, index, default, [])
     end
   end
 
   @doc """
-  Converts a char list to an atom.
+  Returns `true` if `list` starts with the given `prefix` list, otherwise returns `false`.
+
+  If `prefix` is an empty list, it returns `true`.
+
+  ## Examples
+
+      iex> List.starts_with?([1, 2, 3], [1, 2])
+      true
 
-  Currently Elixir does not support conversions from char lists
-  which contains Unicode codepoints greater than 0xFF.
+      iex> List.starts_with?([1, 2], [1, 2, 3])
+      false
+
+      iex> List.starts_with?([:alpha], [])
+      true
+
+      iex> List.starts_with?([], [:alpha])
+      false
+
+  """
+  @doc since: "1.5.0"
+  @spec starts_with?(nonempty_list, nonempty_list) :: boolean
+  @spec starts_with?(list, []) :: true
+  @spec starts_with?([], nonempty_list) :: false
+  def starts_with?(list, prefix)
+
+  def starts_with?([head | tail], [head | prefix_tail]), do: starts_with?(tail, prefix_tail)
+  def starts_with?(list, []) when is_list(list), do: true
+  def starts_with?(list, [_ | _]) when is_list(list), do: false
+
+  @doc """
+  Returns `true` if `list` ends with the given `suffix` list, otherwise returns `false`.
+
+  If `suffix` is an empty list, it returns `true`.
+
+  ## Examples
+
+      iex> List.ends_with?([1, 2, 3], [2, 3])
+      true
+
+      iex> List.ends_with?([1, 2], [1, 2, 3])
+      false
+
+      iex> List.ends_with?([:alpha], [])
+      true
+
+      iex> List.ends_with?([], [:alpha])
+      false
+
+  """
+  @doc since: "1.18.0"
+  @spec ends_with?(nonempty_list, nonempty_list) :: boolean
+  @spec ends_with?(list, []) :: true
+  @spec ends_with?([], nonempty_list) :: false
+  def ends_with?(list, suffix) do
+    :lists.suffix(suffix, list)
+  end
+
+  @doc """
+  Converts a charlist to an atom.
+
+  Elixir supports conversions from charlists which contain any Unicode
+  code point.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> List.to_atom('elixir')
-      :elixir
+      iex> List.to_atom(~c"Elixir")
+      :Elixir
+
+      iex> List.to_atom(~c"🌢 Elixir")
+      :"🌢 Elixir"
 
   """
-  @spec to_atom(char_list) :: atom
-  def to_atom(char_list) do
-    :erlang.list_to_atom(char_list)
+  @spec to_atom(charlist) :: atom
+  def to_atom(charlist) do
+    :erlang.list_to_atom(charlist)
   end
 
   @doc """
-  Converts a char list to an existing atom.
+  Converts a charlist to an existing atom.
 
-  Currently Elixir does not support conversions from char lists
-  which contains Unicode codepoints greater than 0xFF.
+  Elixir supports conversions from charlists which contain any Unicode
+  code point. Raises an `ArgumentError` if the atom does not exist.
 
   Inlined by the compiler.
+
+  > #### Atoms and modules {: .info}
+  >
+  > Since Elixir is a compiled language, the atoms defined in a module
+  > will only exist after said module is loaded, which typically happens
+  > whenever a function in the module is executed. Therefore, it is
+  > generally recommended to call `List.to_existing_atom/1` only to
+  > convert atoms defined within the module making the function call
+  > to `to_existing_atom/1`.
+
+  ## Examples
+
+      iex> _ = :my_atom
+      iex> List.to_existing_atom(~c"my_atom")
+      :my_atom
+
+      iex> _ = :"🌢 Elixir"
+      iex> List.to_existing_atom(~c"🌢 Elixir")
+      :"🌢 Elixir"
+
   """
-  @spec to_existing_atom(char_list) :: atom
-  def to_existing_atom(char_list) do
-    :erlang.list_to_existing_atom(char_list)
+  @spec to_existing_atom(charlist) :: atom
+  def to_existing_atom(charlist) do
+    :erlang.list_to_existing_atom(charlist)
   end
 
   @doc """
-  Returns the float whose text representation is `char_list`.
+  Returns the float whose text representation is `charlist`.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> List.to_float('2.2017764e+0')
+      iex> List.to_float(~c"2.2017764e+0")
       2.2017764
 
   """
-  @spec to_float(char_list) :: float
-  def to_float(char_list) do
-    :erlang.list_to_float(char_list)
+  @spec to_float(charlist) :: float
+  def to_float(charlist) do
+    :erlang.list_to_float(charlist)
   end
 
   @doc """
-  Returns an integer whose text representation is `char_list`.
+  Returns an integer whose text representation is `charlist`.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> List.to_integer('123')
+      iex> List.to_integer(~c"123")
       123
 
   """
-  @spec to_integer(char_list) :: integer
-  def to_integer(char_list) do
-    :erlang.list_to_integer(char_list)
+  @spec to_integer(charlist) :: integer
+  def to_integer(charlist) do
+    :erlang.list_to_integer(charlist)
   end
 
   @doc """
-  Returns an integer whose text representation is `char_list` in base `base`.
+  Returns an integer whose text representation is `charlist` in base `base`.
 
   Inlined by the compiler.
 
+  The base needs to be between `2` and `36`.
+
   ## Examples
 
-      iex> List.to_integer('3FF', 16)
+      iex> List.to_integer(~c"3FF", 16)
       1023
 
   """
-  @spec to_integer(char_list, non_neg_integer) :: integer
-  def to_integer(char_list, base) do
-    :erlang.list_to_integer(char_list, base)
+  @spec to_integer(charlist, 2..36) :: integer
+  def to_integer(charlist, base) do
+    :erlang.list_to_integer(charlist, base)
   end
 
   @doc """
@@ -550,12 +1090,19 @@ defmodule List do
   end
 
   @doc """
-  Converts a list of integers representing codepoints, lists or
+  Converts a list of integers representing code points, lists or
   strings into a string.
 
-  Notice that this function expect a list of integer representing
-  UTF-8 codepoints. If you have a list of bytes, you must instead use
-  [the `:binary` module](http://erlang.org/doc/man/binary.html).
+  To be converted to a string, a list must either be empty or only
+  contain the following elements:
+
+    * strings
+    * integers representing Unicode code points
+    * a list containing one of these three elements
+
+  Note that this function expects a list of integers representing
+  Unicode code points. If you have a list of bytes, you must instead use
+  the [`:binary` module](`:binary`).
 
   ## Examples
 
@@ -565,10 +1112,34 @@ defmodule List do
       iex> List.to_string([0x0061, "bc"])
       "abc"
 
+      iex> List.to_string([0x0064, "ee", [~c"p"]])
+      "deep"
+
+      iex> List.to_string([])
+      ""
+
   """
-  @spec to_string(:unicode.char_list) :: String.t
+  @spec to_string(:unicode.charlist()) :: String.t()
   def to_string(list) when is_list(list) do
-    case :unicode.characters_to_binary(list) do
+    try do
+      :unicode.characters_to_binary(list)
+    rescue
+      ArgumentError ->
+        raise ArgumentError, """
+        cannot convert the given list to a string.
+
+        To be converted to a string, a list must either be empty or only
+        contain the following elements:
+
+          * strings
+          * integers representing Unicode code points
+          * a list containing one of these three elements
+
+        Please check the given list or call inspect/1 to get the list representation, got:
+
+        #{inspect(list)}
+        """
+    else
       result when is_binary(result) ->
         result
 
@@ -580,100 +1151,269 @@ defmodule List do
     end
   end
 
-  ## Helpers
+  @doc """
+  Converts a list of integers representing Unicode code points, lists or
+  strings into a charlist.
 
-  # replace_at
+  Note that this function expects a list of integers representing
+  Unicode code points. If you have a list of bytes, you must instead use
+  the [`:binary` module](`:binary`).
 
-  defp do_replace_at([], _index, _value) do
-    []
+  ## Examples
+
+      iex> ~c"æß" = List.to_charlist([0x00E6, 0x00DF])
+      [230, 223]
+
+      iex> List.to_charlist([0x0061, "bc"])
+      ~c"abc"
+
+      iex> List.to_charlist([0x0064, "ee", [~c"p"]])
+      ~c"deep"
+
+  """
+  @doc since: "1.8.0"
+  @spec to_charlist(:unicode.charlist()) :: charlist()
+  def to_charlist(list) when is_list(list) do
+    try do
+      :unicode.characters_to_list(list)
+    rescue
+      ArgumentError ->
+        raise ArgumentError, """
+        cannot convert the given list to a charlist.
+
+        To be converted to a charlist, a list must contain only:
+
+          * strings
+          * integers representing Unicode code points
+          * or a list containing one of these three elements
+
+        Please check the given list or call inspect/1 to get the list representation, got:
+
+        #{inspect(list)}
+        """
+    else
+      result when is_list(result) ->
+        result
+
+      {:error, encoded, rest} ->
+        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :invalid
+
+      {:incomplete, encoded, rest} ->
+        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :incomplete
+    end
   end
 
-  defp do_replace_at(list, index, _value) when index < 0 do
-    list
+  @doc """
+  Returns a keyword list that represents an *edit script*.
+
+  The algorithm is outlined in the
+  "An O(ND) Difference Algorithm and Its Variations" paper by E. Myers.
+
+  An *edit script* is a keyword list. Each key describes the "editing action" to
+  take in order to bring `list1` closer to being equal to `list2`; a key can be
+  `:eq`, `:ins`, or `:del`. Each value is a sublist of either `list1` or `list2`
+  that should be inserted (if the corresponding key is `:ins`), deleted (if the
+  corresponding key is `:del`), or left alone (if the corresponding key is
+  `:eq`) in `list1` in order to be closer to `list2`.
+
+  See `myers_difference/3` if you want to handle nesting in the diff scripts.
+
+  ## Examples
+
+      iex> List.myers_difference([1, 4, 2, 3], [1, 2, 3, 4])
+      [eq: [1], del: [4], eq: [2, 3], ins: [4]]
+
+  """
+  @doc since: "1.4.0"
+  @spec myers_difference(list, list) :: [{:eq | :ins | :del, list}]
+  def myers_difference(list1, list2) when is_list(list1) and is_list(list2) do
+    myers_difference_with_diff_script(list1, list2, nil)
+  end
+
+  @doc """
+  Returns a keyword list that represents an *edit script* with nested diffs.
+
+  This is an extension of `myers_difference/2` where a `diff_script` function
+  can be given in case it is desired to compute nested differences. The function
+  may return a list with the inner edit script or `nil` in case there is no
+  such script. The returned inner edit script will be under the `:diff` key.
+
+  ## Examples
+
+      iex> List.myers_difference(["a", "db", "c"], ["a", "bc"], &String.myers_difference/2)
+      [eq: ["a"], diff: [del: "d", eq: "b", ins: "c"], del: ["c"]]
+
+  """
+  @doc since: "1.8.0"
+  @spec myers_difference(list, list, (term, term -> script | nil)) :: script
+        when script: [{:eq | :ins | :del | :diff, list}]
+  def myers_difference(list1, list2, diff_script)
+      when is_list(list1) and is_list(list2) and is_function(diff_script) do
+    myers_difference_with_diff_script(list1, list2, diff_script)
   end
 
-  defp do_replace_at([_old|rest], 0, value) do
-    [ value | rest ]
+  defp myers_difference_with_diff_script(list1, list2, diff_script) do
+    path = {0, list1, list2, []}
+    find_script(0, length(list1) + length(list2), [path], diff_script)
   end
 
-  defp do_replace_at([h|t], index, value) do
-    [ h | do_replace_at(t, index - 1, value) ]
+  defp find_script(envelope, max, paths, diff_script) do
+    case each_diagonal(-envelope, envelope, paths, [], diff_script) do
+      {:done, edits} -> compact_reverse(edits, [])
+      {:next, paths} -> find_script(envelope + 1, max, paths, diff_script)
+    end
   end
 
-  # insert_at
+  defp compact_reverse([], acc), do: acc
 
-  defp do_insert_at([], _index, value) do
-    [ value ]
+  defp compact_reverse([{:diff, _} = fragment | rest], acc) do
+    compact_reverse(rest, [fragment | acc])
   end
 
-  defp do_insert_at(list, index, value) when index <= 0 do
-    [ value | list ]
+  defp compact_reverse([{kind, elem} | rest], [{kind, result} | acc]) do
+    compact_reverse(rest, [{kind, [elem | result]} | acc])
   end
 
-  defp do_insert_at([h|t], index, value) do
-    [ h | do_insert_at(t, index - 1, value) ]
+  defp compact_reverse(rest, [{:eq, elem}, {:ins, elem}, {:eq, other} | acc]) do
+    compact_reverse(rest, [{:ins, elem}, {:eq, elem ++ other} | acc])
   end
 
-  # update_at
+  defp compact_reverse([{kind, elem} | rest], acc) do
+    compact_reverse(rest, [{kind, [elem]} | acc])
+  end
 
-  defp do_update_at([value|list], 0, fun) do
-    [ fun.(value) | list ]
+  defp each_diagonal(diag, limit, _paths, next_paths, _diff_script) when diag > limit do
+    {:next, :lists.reverse(next_paths)}
   end
 
-  defp do_update_at(list, index, _fun) when index < 0 do
-    list
+  defp each_diagonal(diag, limit, paths, next_paths, diff_script) do
+    {path, rest} = proceed_path(diag, limit, paths, diff_script)
+
+    case follow_snake(path) do
+      {:cont, path} -> each_diagonal(diag + 2, limit, rest, [path | next_paths], diff_script)
+      {:done, edits} -> {:done, edits}
+    end
   end
 
-  defp do_update_at([h|t], index, fun) do
-    [ h | do_update_at(t, index - 1, fun) ]
+  defp proceed_path(0, 0, [path], _diff_script), do: {path, []}
+
+  defp proceed_path(diag, limit, [path | _] = paths, diff_script) when diag == -limit do
+    {move_down(path, diff_script), paths}
   end
 
-  defp do_update_at([], _index, _fun) do
-    []
+  defp proceed_path(diag, limit, [path], diff_script) when diag == limit do
+    {move_right(path, diff_script), []}
+  end
+
+  defp proceed_path(_diag, _limit, [path1, path2 | rest], diff_script) do
+    if elem(path1, 0) > elem(path2, 0) do
+      {move_right(path1, diff_script), [path2 | rest]}
+    else
+      {move_down(path2, diff_script), [path2 | rest]}
+    end
+  end
+
+  defp move_right({y, [elem1 | rest1] = list1, [elem2 | rest2], edits}, diff_script)
+       when diff_script != nil do
+    if diff = diff_script.(elem1, elem2) do
+      {y + 1, rest1, rest2, [{:diff, diff} | edits]}
+    else
+      {y, list1, rest2, [{:ins, elem2} | edits]}
+    end
+  end
+
+  defp move_right({y, list1, [elem | rest], edits}, _diff_script) do
+    {y, list1, rest, [{:ins, elem} | edits]}
+  end
+
+  defp move_right({y, list1, [], edits}, _diff_script) do
+    {y, list1, [], edits}
+  end
+
+  defp move_down({y, [elem1 | rest1], [elem2 | rest2] = list2, edits}, diff_script)
+       when diff_script != nil do
+    if diff = diff_script.(elem1, elem2) do
+      {y + 1, rest1, rest2, [{:diff, diff} | edits]}
+    else
+      {y + 1, rest1, list2, [{:del, elem1} | edits]}
+    end
+  end
+
+  defp move_down({y, [elem | rest], list2, edits}, _diff_script) do
+    {y + 1, rest, list2, [{:del, elem} | edits]}
+  end
+
+  defp move_down({y, [], list2, edits}, _diff_script) do
+    {y + 1, [], list2, edits}
+  end
+
+  defp follow_snake({y, [elem | rest1], [elem | rest2], edits}) do
+    follow_snake({y + 1, rest1, rest2, [{:eq, elem} | edits]})
+  end
+
+  defp follow_snake({_y, [], [], edits}) do
+    {:done, edits}
+  end
+
+  defp follow_snake(path) do
+    {:cont, path}
   end
 
-  # delete_at
+  ## Helpers
+
+  # replace_at
 
-  defp do_delete_at([], _index) do
+  defp do_replace_at([], _index, _value) do
     []
   end
 
-  defp do_delete_at([_|t], 0) do
-    t
+  defp do_replace_at([_old | rest], 0, value) do
+    [value | rest]
   end
 
-  defp do_delete_at(list, index) when index < 0 do
-    list
+  defp do_replace_at([head | tail], index, value) do
+    [head | do_replace_at(tail, index - 1, value)]
   end
 
-  defp do_delete_at([h|t], index) do
-    [h | do_delete_at(t, index-1)]
+  # insert_at
+
+  defp do_insert_at([], _index, value) do
+    [value]
   end
 
-  # zip
+  defp do_insert_at(list, 0, value) do
+    [value | list]
+  end
 
-  defp do_zip(list, acc) do
-    converter = fn x, acc -> do_zip_each(to_list(x), acc) end
-    {mlist, heads} = :lists.mapfoldl converter, [], list
+  defp do_insert_at([head | tail], index, value) do
+    [head | do_insert_at(tail, index - 1, value)]
+  end
 
-    case heads do
-      nil -> :lists.reverse acc
-      _   -> do_zip mlist, [:erlang.list_to_tuple(:lists.reverse(heads))|acc]
-    end
+  # update_at
+
+  defp do_update_at([value | list], 0, fun) do
+    [fun.(value) | list]
   end
 
-  defp do_zip_each(_, nil) do
-    {nil, nil}
+  defp do_update_at([head | tail], index, fun) do
+    [head | do_update_at(tail, index - 1, fun)]
   end
 
-  defp do_zip_each([h|t], acc) do
-    {t, [h|acc]}
+  defp do_update_at([], _index, _fun) do
+    []
   end
 
-  defp do_zip_each([], _) do
-    {nil, nil}
+  # pop_at
+
+  defp do_pop_at([], _index, default, acc) do
+    {default, :lists.reverse(acc)}
   end
 
-  defp to_list(tuple) when is_tuple(tuple), do: Tuple.to_list(tuple)
-  defp to_list(list)  when is_list(list),   do: list
+  defp do_pop_at([head | tail], 0, _default, acc) do
+    {head, :lists.reverse(acc, tail)}
+  end
+
+  defp do_pop_at([head | tail], index, default, acc) do
+    do_pop_at(tail, index - 1, default, [head | acc])
+  end
 end
diff --git a/lib/elixir/lib/list/chars.ex b/lib/elixir/lib/list/chars.ex
index cfd42f42ddb..560b70a63c5 100644
--- a/lib/elixir/lib/list/chars.ex
+++ b/lib/elixir/lib/list/chars.ex
@@ -1,56 +1,61 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defprotocol List.Chars do
   @moduledoc ~S"""
-  The List.Chars protocol is responsible for
-  converting a structure to a list (only if applicable).
-  The only function required to be implemented is
-  `to_char_list` which does the conversion.
+  The `List.Chars` protocol is responsible for
+  converting a structure to a charlist (only if applicable).
+
+  The only function that must be implemented is
+  `to_charlist/1` which does the conversion.
 
-  The `to_char_list` function automatically imported
-  by Kernel invokes this protocol.
+  The `to_charlist/1` function automatically imported
+  by `Kernel` invokes this protocol.
   """
 
-  def to_char_list(thing)
+  @doc """
+  Converts `term` to a charlist.
+  """
+  @spec to_charlist(t) :: charlist
+  def to_charlist(term)
 end
 
 defimpl List.Chars, for: Atom do
-  def to_char_list(atom), do: Atom.to_char_list(atom)
+  def to_charlist(nil), do: ~c""
+
+  def to_charlist(atom), do: Atom.to_charlist(atom)
 end
 
 defimpl List.Chars, for: BitString do
   @doc """
-  Returns the given binary converted to a char list.
+  Returns the given binary `term` converted to a charlist.
   """
-  def to_char_list(thing) when is_binary(thing) do
-    String.to_char_list(thing)
+  def to_charlist(term) when is_binary(term) do
+    String.to_charlist(term)
   end
 
-  def to_char_list(thing) do
+  def to_charlist(term) do
     raise Protocol.UndefinedError,
-             protocol: @protocol,
-                value: thing,
-          description: "cannot convert a bitstring to a char list"
+      protocol: @protocol,
+      value: term,
+      description: "cannot convert a bitstring to a charlist"
   end
 end
 
 defimpl List.Chars, for: List do
-  def to_char_list(list), do: list
+  # Note that same inlining is used for the rewrite rule.
+  def to_charlist(list), do: list
 end
 
 defimpl List.Chars, for: Integer do
-  def to_char_list(thing) do
-    Integer.to_char_list(thing)
+  def to_charlist(term) do
+    Integer.to_charlist(term)
   end
 end
 
 defimpl List.Chars, for: Float do
-  @digits 20
-  @limit  :math.pow(10, @digits)
-
-  def to_char_list(thing) when thing > @limit do
-    Float.to_char_list(thing, scientific: @digits)
-  end
-
-  def to_char_list(thing) do
-    Float.to_char_list(thing, compact: true, decimals: @digits)
+  def to_charlist(term) do
+    Float.to_charlist(term)
   end
 end
diff --git a/lib/elixir/lib/macro.ex b/lib/elixir/lib/macro.ex
index 6e75221c54e..81b1ce0ad9a 100644
--- a/lib/elixir/lib/macro.ex
+++ b/lib/elixir/lib/macro.ex
@@ -1,60 +1,241 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 import Kernel, except: [to_string: 1]
 
 defmodule Macro do
-  @moduledoc """
-  Conveniences for working with macros.
+  @moduledoc ~S"""
+  Functions for manipulating AST and implementing macros.
+
+  Macros are compile-time constructs that receive Elixir's AST as input
+  and return Elixir's AST as output.
+
+  Many of the functions in this module exist precisely to work with Elixir
+  AST, to traverse, query, and transform it.
+
+  Let's see a simple example that shows the difference between functions
+  and macros:
+
+      defmodule Example do
+        defmacro macro_inspect(value) do
+          IO.inspect(value)
+          value
+        end
+
+        def fun_inspect(value) do
+          IO.inspect(value)
+          value
+        end
+      end
+
+  Now let's give it a try:
+
+      import Example
+
+      macro_inspect(1)
+      #=> 1
+      #=> 1
+
+      fun_inspect(1)
+      #=> 1
+      #=> 1
+
+  So far they behave the same, as we are passing an integer as argument.
+  But let's see what happens when we pass an expression:
+
+      macro_inspect(1 + 2)
+      #=> {:+, [line: 3], [1, 2]}
+      #=> 3
+
+      fun_inspect(1 + 2)
+      #=> 3
+      #=> 3
+
+  The macro receives the representation of the code given as argument,
+  while a function receives the result of the code given as argument.
+  A macro must return a superset of the code representation. See
+  `t:input/0` and `t:output/0` for more information.
+
+  To learn more about Elixir's AST and how to build them programmatically,
+  see `quote/2`.
+
+  > #### Evaluating code {: .tip}
+  >
+  > The functions in this module do not evaluate code. In fact,
+  > evaluating code from macros is often an anti-pattern. For code
+  > evaluation, see the `Code` module.
   """
 
+  alias Code.Identifier
+
   @typedoc "Abstract Syntax Tree (AST)"
-  @type t :: expr | {t, t} | atom | number | binary | pid | fun | [t]
+  @type t :: input
 
-  @typedoc "Expr node (remaining ones are literals)"
-  @type expr :: {expr | atom, Keyword.t, atom | [t]}
+  @typedoc "The inputs of a macro"
+  @type input ::
+          input_expr
+          | {input, input}
+          | [input]
+          | atom
+          | number
+          | binary
 
-  @binary_ops [:===, :!==,
-    :==, :!=, :<=, :>=,
-    :&&, :||, :<>, :++, :--, :\\, :::, :<-, :.., :|>, :=~,
-    :<, :>, :->,
-    :+, :-, :*, :/, :=, :|, :.,
-    :and, :or, :xor, :when, :in,
-    :<<<, :>>>, :|||, :&&&, :^^^, :~~~]
+  @typep input_expr :: {input_expr | atom, metadata, atom | [input]}
 
-  @doc false
-  defmacro binary_ops, do: @binary_ops
+  @typedoc "The output of a macro"
+  @type output ::
+          output_expr
+          | {output, output}
+          | [output]
+          | atom
+          | number
+          | binary
+          | captured_remote_function
+          | pid
 
-  @unary_ops [:!, :@, :^, :not, :+, :-, :~~~, :&]
+  @typep output_expr :: {output_expr | atom, metadata, atom | [output]}
 
-  @doc false
-  defmacro unary_ops, do: @unary_ops
-
-  @spec binary_op_props(atom) :: {:left | :right, precedence :: integer}
-  defp binary_op_props(o) do
-    case o do
-      o when o in [:<-, :\\]                  -> {:left,  40}
-      :when                                   -> {:right, 50}
-      :::                                     -> {:right, 60}
-      :|                                      -> {:right, 70}
-      :=                                      -> {:right, 90}
-      o when o in [:||, :|||, :or, :xor]      -> {:left, 130}
-      o when o in [:&&, :&&&, :and]           -> {:left, 140}
-      o when o in [:==, :!=, :=~, :===, :!==] -> {:left, 150}
-      o when o in [:<, :<=, :>=, :>]          -> {:left, 160}
-      o when o in [:|>, :<<<, :>>>]           -> {:left, 170}
-      :in                                     -> {:left, 180}
-      o when o in [:++, :--, :.., :<>]        -> {:right, 200}
-      o when o in [:+, :-]                    -> {:left, 210}
-      o when o in [:*, :/]                    -> {:left, 220}
-      :^^^                                    -> {:left, 250}
-      :.                                      -> {:left, 310}
-    end
-  end
+  @typedoc """
+  A keyword list of AST metadata.
+
+  The metadata in Elixir AST is a keyword list of values. Any key can be used
+  and different parts of the compiler may use different keys. For example,
+  the AST received by a macro will always include the `:line` annotation,
+  while the AST emitted by `quote/2` will only have the `:line` annotation if
+  the `:line` option is provided.
+
+  The following metadata keys are public:
+
+    * `:context` - Defines the context in which the AST was generated.
+      For example, `quote/2` will include the module calling `quote/2`
+      as the context. This is often used to distinguish regular code from code
+      generated by a macro or by `quote/2`.
+
+    * `:counter` - The variable counter used for variable hygiene. In terms of
+      the compiler, each variable is identified by the combination of either
+      `name` and `metadata[:counter]`, or `name` and `context`.
+
+    * `:from_brackets` - Used to determine whether a call to `Access.get/3` is from
+      bracket syntax.
+
+    * `:from_interpolation` - Used to determine whether a call to `Kernel.to_string/1` is
+      from interpolation.
+
+    * `:generated` - Whether the code should be considered as generated by
+      the compiler or not. This means the compiler and tools like Dialyzer may not
+      emit certain warnings.
+
+    * `:if_undefined` - How to expand a variable that is undefined. Set it to
+      `:apply` if you want a variable to become a nullary call without warning
+      or `:raise`
+
+    * `:keep` - Used by `quote/2` with the option `location: :keep` to annotate
+      the file and the line number of the quoted source.
+
+    * `:line` - The line number of the AST node. Note line information is discarded
+      from quoted code but can be enabled back via the `:line` option.
+
+  The following metadata keys are enabled by `Code.string_to_quoted/2`:
+
+    * `:assoc` - contains metadata about the `=>` operator location in a
+      map key-value AST node (when `:token_metadata` is true). This entry
+      appears on map key nodes only
+
+    * `:closing` - contains metadata about the closing pair, such as a `}`
+      in a tuple or in a map, or such as the closing `)` in a function call
+      with parens (when `:token_metadata` is true). If the function call
+      has a do-end block attached to it, its metadata is found under the
+      `:do` and `:end` metadata
+
+    * `:column` - the column number of the AST node (when `:columns` is true).
+      Note column information is always discarded from quoted code.
+
+    * `:delimiter` - contains the opening delimiter for sigils, strings,
+      and charlists as a string (such as `"{"`, `"/"`, `"'"`, and the like)
+
+    * `:do` - contains metadata about the `do` location in a function call with
+      `do`-`end` blocks (when `:token_metadata` is true)
+
+    * `:end` - contains metadata about the `end` location in a function call with
+      `do`-`end` blocks (when `:token_metadata` is true)
+
+    * `:end_of_expression` - denotes when the end of expression effectively
+      happens (when `:token_metadata` is true). This is only available for
+      expressions inside "blocks of code", which are either direct children
+      of a `__block__` or the right side of `->`. The last expression of the
+      block does not have metadata if it is not followed by an end of line
+      character (either a newline or `;`). This entry may appear multiple times
+      in the same metadata if the expression is surround by parens
+
+    * `:format` - set to `:keyword` when an atom is defined as a keyword.
+      It may also be set to `:atom` to distinguish `nil`, `false`, and `true`
+
+    * `:indentation` - indentation of a sigil heredoc
+
+    * `:parens` - denotes a node was surrounded by parens for grouping.
+      This entry may appear multiple times in the same metadata if
+      multiple pairs are used for grouping
+
+  The following metadata keys are private:
+
+    * `:alias` - Used for alias hygiene.
+    * `:ambiguous_op` - Used for improved error messages in the compiler.
+    * `:imports` - Used for import hygiene.
+    * `:var` - Used for improved error messages on undefined variables.
+
+  Do not rely on them as they may change or be fully removed in future versions
+  of the language. They are often used by `quote/2` and the compiler to provide
+  features like hygiene, better error messages, and so forth.
+
+  If you introduce custom keys into the AST metadata, please make sure to prefix
+  them with the name of your library or application, so that they will not conflict
+  with keys that could potentially be introduced by the compiler in the future.
+  """
+  @type metadata :: keyword
+
+  @typedoc "A captured remote function in the format of &Mod.fun/arity"
+  @type captured_remote_function :: fun
+
+  @type escape_opts :: [
+          unquote: boolean(),
+          prune_metadata: boolean(),
+          generated: boolean()
+        ]
+
+  @type inspect_atom_opts :: [
+          escape: (binary(), char() -> binary())
+        ]
 
   @doc """
   Breaks a pipeline expression into a list.
 
-  Raises if the pipeline is ill-formed.
+  The AST for a pipeline (a sequence of applications of `|>/2`) is similar to the
+  AST of a sequence of binary operators or function applications: the top-level
+  expression is the right-most `:|>` (which is the last one to be executed), and
+  its left-hand and right-hand sides are its arguments:
+
+      quote do: 100 |> div(5) |> div(2)
+      #=> {:|>, _, [arg1, arg2]}
+
+  In the example above, the `|>/2` pipe is the right-most pipe; `arg1` is the AST
+  for `100 |> div(5)`, and `arg2` is the AST for `div(2)`.
+
+  It's often useful to have the AST for such a pipeline as a list of function
+  applications. This function does exactly that:
+
+      Macro.unpipe(quote do: 100 |> div(5) |> div(2))
+      #=> [{100, 0}, {{:div, [], [5]}, 0}, {{:div, [], [2]}, 0}]
+
+  We get a list that follows the pipeline directly: first the `100`, then the
+  `div(5)` (more precisely, its AST), then `div(2)`. The `0` as the second
+  element of the tuples is the position of the previous element in the pipeline
+  inside the current function application: `{{:div, [], [5]}, 0}` means that the
+  previous element (`100`) will be inserted as the 0th (first) argument to the
+  `div/2` function, so that the AST for that function will become `{:div, [],
+  [100, 5]}` (`div(100, 5)`).
   """
-  @spec unpipe(Macro.t) :: [Macro.t]
+  @spec unpipe(t()) :: [t()]
   def unpipe(expr) do
     :lists.reverse(unpipe(expr, []))
   end
@@ -64,35 +245,127 @@ defmodule Macro do
   end
 
   defp unpipe(other, acc) do
-    [{other, 0}|acc]
+    [{other, 0} | acc]
   end
 
   @doc """
   Pipes `expr` into the `call_args` at the given `position`.
+
+  This function can be used to implement `|>` like functionality. For example,
+  `|>` itself is implemented as:
+
+      defmacro left |> right do
+        Macro.pipe(left, right, 0)
+      end
+
+  `expr` is the AST of an expression. `call_args` must be the AST *of a call*,
+  otherwise this function will raise an error. As an example, consider the pipe
+  operator `|>/2`, which uses this function to build pipelines.
+
+  Even if the expression is piped into the AST, it doesn't necessarily mean that
+  the AST is valid. For example, you could pipe an argument to `div/2`, effectively
+  turning it into a call to `div/3`, which is a function that doesn't exist by
+  default. The code will raise unless a `div/3` function is locally defined.
   """
-  @spec pipe(Macro.t, Macro.t, integer) :: Macro.t | no_return
+  @spec pipe(t(), t(), integer) :: t()
   def pipe(expr, call_args, position)
 
   def pipe(expr, {:&, _, _} = call_args, _integer) do
-    raise ArgumentError, "cannot pipe #{to_string expr} into #{to_string call_args}"
+    raise ArgumentError, bad_pipe(expr, call_args)
+  end
+
+  def pipe(expr, {tuple_or_map, _, _} = call_args, _integer) when tuple_or_map in [:{}, :%{}] do
+    raise ArgumentError, bad_pipe(expr, call_args)
+  end
+
+  # Without this, `Macro |> Env == Macro.Env`.
+  def pipe(expr, {:__aliases__, _, _} = call_args, _integer) do
+    raise ArgumentError, bad_pipe(expr, call_args)
+  end
+
+  def pipe(expr, {:<<>>, _, _} = call_args, _integer) do
+    raise ArgumentError, bad_pipe(expr, call_args)
+  end
+
+  def pipe(expr, {unquote, _, []}, _integer) when unquote in [:unquote, :unquote_splicing] do
+    raise ArgumentError,
+          "cannot pipe #{to_string(expr)} into the special form #{unquote}/1 " <>
+            "since #{unquote}/1 is used to build the Elixir AST itself"
+  end
+
+  # {:fn, _, _} is what we get when we pipe into an anonymous function without
+  # calling it, for example, `:foo |> (fn x -> x end)`.
+  def pipe(expr, {:fn, _, _}, _integer) do
+    raise ArgumentError,
+          "cannot pipe #{to_string(expr)} into an anonymous function without" <>
+            " calling the function; use Kernel.then/2 instead or" <>
+            " define the anonymous function as a regular private function"
   end
 
   def pipe(expr, {call, line, atom}, integer) when is_atom(atom) do
     {call, line, List.insert_at([], integer, expr)}
   end
 
-  def pipe(expr, {call, line, args}, integer) when is_list(args) do
-    {call, line, List.insert_at(args, integer, expr)}
+  def pipe(_expr, {op, _line, [arg]}, _integer) when op == :+ or op == :- do
+    raise ArgumentError,
+          "piping into a unary operator is not supported, please use the qualified name: " <>
+            "Kernel.#{op}(#{to_string(arg)}), instead of #{op}#{to_string(arg)}"
+  end
+
+  # Piping to an Access.get/2,3 call in the form of brackets
+  # (foo |> bar[]) raises a nice error.
+  def pipe(
+        expr,
+        {{_, meta, [Access, :get] = op}, _meta, [first, second]} = _op_args,
+        integer
+      ) do
+    if {:from_brackets, true} in meta do
+      raise ArgumentError, """
+      wrong operator precedence when piping into bracket-based access
+
+       Instead of:
+
+           #{to_string(expr)} |> #{to_string(first)}[#{to_string(second)}]
+
+       You should write:
+
+           (#{to_string(expr)} |> #{to_string(first)})[#{to_string(second)}]
+      """
+    else
+      {op, meta, List.insert_at([first, second], integer, expr)}
+    end
+  end
+
+  def pipe(expr, {op, line, args} = op_args, integer) when is_list(args) do
+    cond do
+      is_atom(op) and operator?(op, 1) ->
+        raise ArgumentError,
+              "cannot pipe #{to_string(expr)} into #{to_string(op_args)}, " <>
+                "the #{to_string(op)} operator can only take one argument"
+
+      is_atom(op) and operator?(op, 2) ->
+        raise ArgumentError,
+              "cannot pipe #{to_string(expr)} into #{to_string(op_args)}, " <>
+                "the #{to_string(op)} operator can only take two arguments"
+
+      true ->
+        {op, line, List.insert_at(args, integer, expr)}
+    end
   end
 
   def pipe(expr, call_args, _integer) do
-    raise ArgumentError, "cannot pipe #{to_string expr} into #{to_string call_args}"
+    raise ArgumentError, bad_pipe(expr, call_args)
+  end
+
+  defp bad_pipe(expr, call_args) do
+    "cannot pipe #{to_string(expr)} into #{to_string(call_args)}, " <>
+      "can only pipe into local calls foo(), remote calls Foo.bar() or anonymous function calls foo.()"
   end
 
   @doc """
   Applies the given function to the node metadata if it contains one.
 
-  This is often useful when used with `Macro.prewalk/1` to remove
+  This is often useful when used with `Macro.prewalk/2` to remove
   information like lines and hygienic counters from the expression
   for either storage or comparison.
 
@@ -104,7 +377,7 @@ defmodule Macro do
       {:sample, [], []}
 
   """
-  @spec update_meta(t, (Keyword.t -> Keyword.t)) :: t
+  @spec update_meta(t, (keyword -> keyword)) :: t
   def update_meta(quoted, fun)
 
   def update_meta({left, meta, right}, fun) when is_list(meta) do
@@ -116,14 +389,161 @@ defmodule Macro do
   end
 
   @doc """
-  Genrates a AST node representing the variable given
+  Generates AST nodes for a given number of required argument
+  variables using `Macro.var/2`.
+
+  Note the arguments are not unique. If you later on want
+  to access the same variables, you can invoke this function
+  with the same inputs. Use `generate_unique_arguments/2` to
+  generate unique arguments that can't be overridden.
+
+  ## Examples
+
+      iex> Macro.generate_arguments(2, __MODULE__)
+      [{:arg1, [], __MODULE__}, {:arg2, [], __MODULE__}]
+
+  """
+  @doc since: "1.5.0"
+  @spec generate_arguments(0, context :: atom) :: []
+  @spec generate_arguments(pos_integer, context) :: [{atom, [], context}, ...] when context: atom
+  def generate_arguments(amount, context), do: generate_arguments(amount, context, &var/2)
+
+  @doc """
+  Returns the path to the node in `ast` for which `fun` returns a truthy value.
+
+  The path is a list, starting with the node in which `fun` returns
+  a truthy value, followed by all of its parents.
+
+  Returns `nil` if `fun` returns only falsy values.
+
+  Computing the path can be an efficient operation when you want
+  to find a particular node in the AST within its context and then
+  assert something about it.
+
+  ## Examples
+
+      iex> Macro.path(quote(do: [1, 2, 3]), & &1 == 3)
+      [3, [1, 2, 3]]
+
+      iex> Macro.path(quote(do: [1, 2]), & &1 == 5)
+      nil
+
+      iex> Macro.path(quote(do: Foo.bar(3)), & &1 == 3)
+      [3, quote(do: Foo.bar(3))]
+
+      iex> Macro.path(quote(do: %{foo: [bar: :baz]}), & &1 == :baz)
+      [
+        :baz,
+        {:bar, :baz},
+        [bar: :baz],
+        {:foo, [bar: :baz]},
+        {:%{}, [], [foo: [bar: :baz]]}
+      ]
+
+  """
+  @doc since: "1.14.0"
+  @spec path(t, (t -> as_boolean(term))) :: [t] | nil
+  def path(ast, fun) when is_function(fun, 1) do
+    path(ast, [], fun)
+  end
+
+  defp path({form, _, args} = ast, acc, fun) when is_atom(form) do
+    acc = [ast | acc]
+
+    if fun.(ast) do
+      acc
+    else
+      path_args(args, acc, fun)
+    end
+  end
+
+  defp path({form, _meta, args} = ast, acc, fun) do
+    acc = [ast | acc]
+
+    if fun.(ast) do
+      acc
+    else
+      path(form, acc, fun) || path_args(args, acc, fun)
+    end
+  end
+
+  defp path({left, right} = ast, acc, fun) do
+    acc = [ast | acc]
+
+    if fun.(ast) do
+      acc
+    else
+      path(left, acc, fun) || path(right, acc, fun)
+    end
+  end
+
+  defp path(list, acc, fun) when is_list(list) do
+    acc = [list | acc]
+
+    if fun.(list) do
+      acc
+    else
+      path_list(list, acc, fun)
+    end
+  end
+
+  defp path(ast, acc, fun) do
+    if fun.(ast) do
+      [ast | acc]
+    end
+  end
+
+  defp path_args(atom, _acc, _fun) when is_atom(atom), do: nil
+  defp path_args(list, acc, fun) when is_list(list), do: path_list(list, acc, fun)
+
+  defp path_list([], _acc, _fun) do
+    nil
+  end
+
+  defp path_list([arg | args], acc, fun) do
+    path(arg, acc, fun) || path_list(args, acc, fun)
+  end
+
+  @doc """
+  Generates AST nodes for a given number of required argument
+  variables using `Macro.unique_var/2`.
+
+  The second argument is generally the macro caller's module.
+
+  ## Examples
+
+      [var1, var2] = Macro.generate_unique_arguments(2, __CALLER__.module)
+
+  """
+  @doc since: "1.11.3"
+  @spec generate_unique_arguments(0, context :: atom) :: []
+  @spec generate_unique_arguments(pos_integer, context) ::
+          [{atom, [counter: integer], context}, ...]
+        when context: atom
+  def generate_unique_arguments(amount, context),
+    do: generate_arguments(amount, context, &unique_var/2)
+
+  defp generate_arguments(0, context, _fun) when is_atom(context), do: []
+
+  defp generate_arguments(amount, context, fun)
+       when is_integer(amount) and amount > 0 and is_atom(context) do
+    for id <- 1..amount, do: fun.(String.to_atom("arg" <> Integer.to_string(id)), context)
+  end
+
+  @doc """
+  Generates an AST node representing the variable given
   by the atoms `var` and `context`.
 
+  Note this variable is not unique. If you later on want
+  to access this same variable, you can invoke `var/2`
+  again with the same arguments. Use `unique_var/2` to
+  generate a unique variable that can't be overridden.
+
   ## Examples
 
   In order to build a variable, a context is expected.
   Most of the times, in order to preserve hygiene, the
-  context must be `__MODULE__`:
+  context must be `__MODULE__/0`:
 
       iex> Macro.var(:foo, __MODULE__)
       {:foo, [], __MODULE__}
@@ -141,100 +561,183 @@ defmodule Macro do
   end
 
   @doc """
-  Performs a depth-first, pre-order traversal of quoted expressions.
+  Generates an AST node representing a unique variable
+  given by the atoms `var` and `context`.
+
+  Calling this function with the same arguments will
+  generate another variable, with its own unique counter.
+  See `var/2` for an alternative.
+
+  The second argument is generally the macro caller's module.
+
+  ## Examples
+
+      var = Macro.unique_var(:foo, __CALLER__.module)
+
   """
-  @spec prewalk(t, (t -> t)) :: t
-  def prewalk(ast, fun) when is_function(fun, 1) do
-    elem(prewalk(ast, nil, fn x, nil -> {fun.(x), nil} end), 0)
+  @doc since: "1.11.3"
+  @spec unique_var(var, context) :: {var, [counter: integer], context}
+        when var: atom, context: atom
+  def unique_var(var, context) when is_atom(var) and is_atom(context) do
+    {var, [counter: :elixir_module.next_counter(context)], context}
   end
 
   @doc """
-  Performs a depth-first, pre-order traversal of quoted expressions
+  Performs a depth-first traversal of quoted expressions
   using an accumulator.
+
+  Returns a tuple where the first element is a new AST and the second one is
+  the final accumulator. The new AST is the result of invoking `pre` on each
+  node of `ast` during the pre-order phase and `post` during the post-order
+  phase.
+
+  ## Examples
+
+      iex> ast = quote do: 5 + 3 * 7
+      iex> {:+, _, [5, {:*, _, [3, 7]}]} = ast
+      iex> {new_ast, acc} =
+      ...>  Macro.traverse(
+      ...>    ast,
+      ...>    [],
+      ...>    fn
+      ...>      {:+, meta, children}, acc -> {{:-, meta, children}, [:- | acc]}
+      ...>      {:*, meta, children}, acc -> {{:/, meta, children}, [:/ | acc]}
+      ...>      other, acc -> {other, acc}
+      ...>    end,
+      ...>    fn
+      ...>      {:-, meta, children}, acc -> {{:min, meta, children}, [:min | acc]}
+      ...>      {:/, meta, children}, acc -> {{:max, meta, children}, [:max | acc]}
+      ...>      other, acc -> {other, acc}
+      ...>    end
+      ...>  )
+      iex> {:min, _, [5, {:max, _, [3, 7]}]} = new_ast
+      iex> [:min, :max, :/, :-] = acc
+      iex> Code.eval_quoted(new_ast)
+      {5, []}
+
   """
-  @spec prewalk(t, any, (t, any -> {t, any})) :: {t, any}
-  def prewalk(ast, acc, fun) when is_function(fun, 2) do
-    {ast, acc} = fun.(ast, acc)
-    do_prewalk(ast, acc, fun)
+  @spec traverse(t, any, (t, any -> {t, any}), (t, any -> {t, any})) :: {t, any}
+  def traverse(ast, acc, pre, post) when is_function(pre, 2) and is_function(post, 2) do
+    {ast, acc} = pre.(ast, acc)
+    do_traverse(ast, acc, pre, post)
   end
 
-  defp do_prewalk({form, meta, args}, acc, fun) do
-    unless is_atom(form) do
-      {form, acc} = fun.(form, acc)
-      {form, acc} = do_prewalk(form, acc, fun)
-    end
+  defp do_traverse({form, meta, args}, acc, pre, post) when is_atom(form) do
+    {args, acc} = do_traverse_args(args, acc, pre, post)
+    post.({form, meta, args}, acc)
+  end
 
-    unless is_atom(args) do
-      {args, acc} = Enum.map_reduce(args, acc, fn x, acc ->
-        {x, acc} = fun.(x, acc)
-        do_prewalk(x, acc, fun)
-      end)
-    end
+  defp do_traverse({form, meta, args}, acc, pre, post) do
+    {form, acc} = pre.(form, acc)
+    {form, acc} = do_traverse(form, acc, pre, post)
+    {args, acc} = do_traverse_args(args, acc, pre, post)
+    post.({form, meta, args}, acc)
+  end
 
-    {{form, meta, args}, acc}
+  defp do_traverse({left, right}, acc, pre, post) do
+    {left, acc} = pre.(left, acc)
+    {left, acc} = do_traverse(left, acc, pre, post)
+    {right, acc} = pre.(right, acc)
+    {right, acc} = do_traverse(right, acc, pre, post)
+    post.({left, right}, acc)
   end
 
-  defp do_prewalk({left, right}, acc, fun) do
-    {left, acc} = fun.(left, acc)
-    {left, acc} = do_prewalk(left, acc, fun)
-    {right, acc} = fun.(right, acc)
-    {right, acc} = do_prewalk(right, acc, fun)
-    {{left, right}, acc}
+  defp do_traverse(list, acc, pre, post) when is_list(list) do
+    {list, acc} = do_traverse_args(list, acc, pre, post)
+    post.(list, acc)
   end
 
-  defp do_prewalk(list, acc, fun) when is_list(list) do
-    Enum.map_reduce(list, acc, fn x, acc ->
-      {x, acc} = fun.(x, acc)
-      do_prewalk(x, acc, fun)
-    end)
+  defp do_traverse(x, acc, _pre, post) do
+    post.(x, acc)
+  end
+
+  defp do_traverse_args(args, acc, _pre, _post) when is_atom(args) do
+    {args, acc}
   end
 
-  defp do_prewalk(x, acc, _fun) do
-    {x, acc}
+  defp do_traverse_args(args, acc, pre, post) when is_list(args) do
+    :lists.mapfoldl(
+      fn x, acc ->
+        {x, acc} = pre.(x, acc)
+        do_traverse(x, acc, pre, post)
+      end,
+      acc,
+      args
+    )
   end
 
   @doc """
-  Performs a depth-first, post-order traversal of quoted expressions.
+  Performs a depth-first, pre-order traversal of quoted expressions.
+
+  Returns a new AST where each node is the result of invoking `fun` on each
+  corresponding node of `ast`.
+
+  ## Examples
+
+      iex> ast = quote do: 5 + 3 * 7
+      iex> {:+, _, [5, {:*, _, [3, 7]}]} = ast
+      iex> new_ast = Macro.prewalk(ast, fn
+      ...>   {:+, meta, children} -> {:*, meta, children}
+      ...>   {:*, meta, children} -> {:+, meta, children}
+      ...>   other -> other
+      ...> end)
+      iex> {:*, _, [5, {:+, _, [3, 7]}]} = new_ast
+      iex> Code.eval_quoted(ast)
+      {26, []}
+      iex> Code.eval_quoted(new_ast)
+      {50, []}
+
   """
-  @spec postwalk(t, (t -> t)) :: t
-  def postwalk(ast, fun) when is_function(fun, 1) do
-    elem(postwalk(ast, nil, fn x, nil -> {fun.(x), nil} end), 0)
+  @spec prewalk(t, (t -> t)) :: t
+  def prewalk(ast, fun) when is_function(fun, 1) do
+    elem(prewalk(ast, nil, fn x, nil -> {fun.(x), nil} end), 0)
   end
 
   @doc """
-  Performs a depth-first, post-order traversal of quoted expressions
+  Performs a depth-first, pre-order traversal of quoted expressions
   using an accumulator.
-  """
-  @spec postwalk(t, any, (t, any -> {t, any})) :: {t, any}
-  def postwalk(ast, acc, fun) when is_function(fun, 2) do
-    do_postwalk(ast, acc, fun)
-  end
 
-  defp do_postwalk({form, meta, args}, acc, fun) do
-    unless is_atom(form) do
-      {form, acc} = do_postwalk(form, acc, fun)
-    end
+  Returns a tuple where the first element is a new AST where each node is the
+  result of invoking `fun` on each corresponding node and the second one is the
+  final accumulator.
 
-    unless is_atom(args) do
-      {args, acc} = Enum.map_reduce(args, acc, &do_postwalk(&1, &2, fun))
-    end
+  ## Examples
 
-    fun.({form, meta, args}, acc)
-  end
+      iex> ast = quote do: 5 + 3 * 7
+      iex> {:+, _, [5, {:*, _, [3, 7]}]} = ast
+      iex> {new_ast, acc} = Macro.prewalk(ast, [], fn
+      ...>   {:+, meta, children}, acc -> {{:*, meta, children}, [:+ | acc]}
+      ...>   {:*, meta, children}, acc -> {{:+, meta, children}, [:* | acc]}
+      ...>   other, acc -> {other, acc}
+      ...> end)
+      iex> {{:*, _, [5, {:+, _, [3, 7]}]}, [:*, :+]} = {new_ast, acc}
+      iex> Code.eval_quoted(ast)
+      {26, []}
+      iex> Code.eval_quoted(new_ast)
+      {50, []}
 
-  defp do_postwalk({left, right}, acc, fun) do
-    {left, acc} = do_postwalk(left, acc, fun)
-    {right, acc} = do_postwalk(right, acc, fun)
-    fun.({left, right}, acc)
+  """
+  @spec prewalk(t, any, (t, any -> {t, any})) :: {t, any}
+  def prewalk(ast, acc, fun) when is_function(fun, 2) do
+    traverse(ast, acc, fun, fn x, a -> {x, a} end)
   end
 
-  defp do_postwalk(list, acc, fun) when is_list(list) do
-    {list, acc} = Enum.map_reduce(list, acc, &do_postwalk(&1, &2, fun))
-    fun.(list, acc)
+  @doc """
+  This function behaves like `prewalk/2`, but performs a depth-first,
+  post-order traversal of quoted expressions.
+  """
+  @spec postwalk(t, (t -> t)) :: t
+  def postwalk(ast, fun) when is_function(fun, 1) do
+    elem(postwalk(ast, nil, fn x, nil -> {fun.(x), nil} end), 0)
   end
 
-  defp do_postwalk(x, acc, fun) do
-    fun.(x, acc)
+  @doc """
+  This functions behaves like `prewalk/3`, but performs a depth-first,
+  post-order traversal of quoted expressions using an accumulator.
+  """
+  @spec postwalk(t, any, (t, any -> {t, any})) :: {t, any}
+  def postwalk(ast, acc, fun) when is_function(fun, 2) do
+    traverse(ast, acc, fn x, a -> {x, a} end, fun)
   end
 
   @doc """
@@ -245,42 +748,42 @@ defmodule Macro do
 
   ## Examples
 
-      iex> Macro.decompose_call(quote do: foo)
+      iex> Macro.decompose_call(quote(do: foo))
       {:foo, []}
 
-      iex> Macro.decompose_call(quote do: foo())
+      iex> Macro.decompose_call(quote(do: foo()))
       {:foo, []}
 
-      iex> Macro.decompose_call(quote do: foo(1, 2, 3))
+      iex> Macro.decompose_call(quote(do: foo(1, 2, 3)))
       {:foo, [1, 2, 3]}
 
-      iex> Macro.decompose_call(quote do: Elixir.M.foo(1, 2, 3))
+      iex> Macro.decompose_call(quote(do: Elixir.M.foo(1, 2, 3)))
       {{:__aliases__, [], [:Elixir, :M]}, :foo, [1, 2, 3]}
 
-      iex> Macro.decompose_call(quote do: 42)
+      iex> Macro.decompose_call(quote(do: 42))
+      :error
+
+      iex> Macro.decompose_call(quote(do: {:foo, [], []}))
       :error
 
   """
-  @spec decompose_call(Macro.t) :: {atom, [Macro.t]} | {Macro.t, atom, [Macro.t]} | :error
-  def decompose_call({{:., _, [remote, function]}, _, args}) when is_tuple(remote) or is_atom(remote),
-    do: {remote, function, args}
+  @spec decompose_call(t()) :: {atom, [t()]} | {t(), atom, [t()]} | :error
+  def decompose_call(ast)
 
-  def decompose_call({name, _, args}) when is_atom(name) and is_atom(args),
-    do: {name, []}
+  def decompose_call({:{}, _, args}) when is_list(args), do: :error
 
-  def decompose_call({name, _, args}) when is_atom(name) and is_list(args),
-    do: {name, args}
+  def decompose_call({{:., _, [remote, function]}, _, args})
+      when is_tuple(remote) or is_atom(remote),
+      do: {remote, function, args}
 
-  def decompose_call(_),
-    do: :error
+  def decompose_call({name, _, args}) when is_atom(name) and is_atom(args), do: {name, []}
 
-  @doc """
-  Recursively escapes a value so it can be inserted
-  into a syntax tree.
+  def decompose_call({name, _, args}) when is_atom(name) and is_list(args), do: {name, args}
+
+  def decompose_call(_), do: :error
 
-  One may pass `unquote: true` to `escape/2`
-  which leaves `unquote` statements unescaped, effectively
-  unquoting the contents on escape.
+  @doc """
+  Recursively escapes a value so it can be inserted into a syntax tree.
 
   ## Examples
 
@@ -293,131 +796,503 @@ defmodule Macro do
       iex> Macro.escape({:unquote, [], [1]}, unquote: true)
       1
 
-  """
-  @spec escape(term) :: Macro.t
-  @spec escape(term, Keyword.t) :: Macro.t
-  def escape(expr, opts \\ []) do
-    elem(:elixir_quote.escape(expr, Keyword.get(opts, :unquote, false)), 0)
-  end
+  ## Options
 
-  @doc ~S"""
-  Unescape the given chars.
+    * `:unquote` - when `true`, this function leaves `unquote/1` and
+      `unquote_splicing/1` expressions unescaped, effectively unquoting
+      the contents on escape. This option is useful only when escaping
+      ASTs which may have quoted fragments in them. Note this option
+      will give a special meaning to `quote`/`unquote` nodes, which need
+      to be valid AST before escaping. Defaults to `false`.
 
-  This is the unescaping behaviour used by default in Elixir
-  single- and double-quoted strings. Check `unescape_string/2`
-  for information on how to customize the escaping map.
+    * `:prune_metadata` - when `true`, removes most metadata from escaped AST
+      nodes. Note this option changes the semantics of escaped code and
+      it should only be used when escaping ASTs. Defaults to `false`.
 
-  In this setup, Elixir will escape the following: `\a`, `\b`,
-  `\d`, `\e`, `\f`, `\n`, `\r`, `\s`, `\t` and `\v`. Octals are
-  also escaped according to the latin1 set they represent.
+    * `:generated` - (since v1.19.0) Whether the AST should be considered as generated
+      by the compiler or not. This means the compiler and tools like Dialyzer may not
+      emit certain warnings.
 
-  This function is commonly used on sigil implementations
-  (like `~r`, `~s` and others) which receive a raw, unescaped
-  string.
+      As an example for `:prune_metadata`, `ExUnit` stores the AST of every
+      assertion, so when an assertion fails we can show code snippets to users.
+      Without this option, each time the test module is compiled, we would get a
+      different MD5 of the module bytecode, because the AST contains metadata,
+      such as counters, specific to the compilation environment. By pruning
+      the metadata, we ensure that the module is deterministic and reduce
+      the amount of data `ExUnit` needs to keep around. Only the minimal
+      amount of metadata is kept, such as `:line`, `:no_parens` and `:delimiter`.
 
-  ## Examples
+  ## Comparison to `quote/2`
 
-      iex> Macro.unescape_string("example\\n")
-      "example\n"
+  The `escape/2` function is sometimes confused with `quote/2`,
+  because the above examples behave the same with both. The key difference is
+  best illustrated when the value to escape is stored in a variable.
 
-  In the example above, we pass a string with `\n` escaped
-  and return a version with it unescaped.
-  """
-  @spec unescape_string(String.t) :: String.t
-  def unescape_string(chars) do
-    :elixir_interpolation.unescape_chars(chars)
-  end
+      iex> Macro.escape({:a, :b, :c})
+      {:{}, [], [:a, :b, :c]}
+      iex> quote do: {:a, :b, :c}
+      {:{}, [], [:a, :b, :c]}
 
-  @doc ~S"""
-  Unescape the given chars according to the map given.
+      iex> value = {:a, :b, :c}
+      iex> Macro.escape(value)
+      {:{}, [], [:a, :b, :c]}
 
-  Check `unescape_string/1` if you want to use the same map
-  as Elixir single- and double-quoted strings.
+      iex> quote do: value
+      {:value, [], __MODULE__}
 
-  ## Map
+      iex> value = {:a, :b, :c}
+      iex> quote do: unquote(value)
+      ** (ArgumentError) tried to unquote invalid AST: {:a, :b, :c}
+      Did you forget to escape term using Macro.escape/1?
 
-  The map must be a function. The function receives an integer
-  representing the codepoint of the character it wants to unescape.
-  Here is the default mapping function implemented by Elixir:
+  `escape/2` is used to escape *values* (either directly passed or variable
+  bound), while `quote/2` produces syntax trees for
+  expressions.
 
-      def unescape_map(?a), do: ?\a
-      def unescape_map(?b), do: ?\b
-      def unescape_map(?d), do: ?\d
-      def unescape_map(?e), do: ?\e
-      def unescape_map(?f), do: ?\f
-      def unescape_map(?n), do: ?\n
-      def unescape_map(?r), do: ?\r
-      def unescape_map(?s), do: ?\s
-      def unescape_map(?t), do: ?\t
-      def unescape_map(?v), do: ?\v
-      def unescape_map(e),  do: e
+  ## Dealing with references and other runtime values
 
-  If the `unescape_map` function returns `false`. The char is
-  not escaped and `\` is kept in the char list.
+  Macros work at compile-time and therefore `Macro.escape/1` can only escape values
+  that are valid during compilation, such as numbers, atoms, tuples, maps, binaries,
+  etc.
 
-  ## Octals
+  However, you may have values at compile-time which cannot be escaped, such as
+  `reference`s and `pid`s, since the process or memory address they point to will
+  no longer exist once compilation completes. Attempting to escape said values will
+  raise an exception. This is a common issue when working with NIFs.
 
-  Octals will by default be escaped unless the map function
-  returns `false` for `?0`.
+  Luckily, Elixir v1.19 introduces a mechanism that allows those values to be escaped,
+  as long as they are encapsulated by a struct within a module that defines the
+  `__escape__/1` function. This is possible as long as the reference has a natural
+  text or binary representation that can be serialized during compilation.
 
-  ## Hex
+  Let's imagine we have the following struct:
 
-  Hexadecimals will by default be escaped unless the map function
-  returns `false` for `?x`.
+      defmodule WrapperStruct do
+        defstruct [:ref]
 
-  ## Examples
+        def new(...), do: %WrapperStruct{ref: ...}
 
-  Using the `unescape_map` function defined above is easy:
+        # efficiently dump to / load from binaries
+        def dump_to_binary(%WrapperStruct{ref: ref}), do: ...
+        def load_from_binary(binary), do: %WrapperStruct{ref: ...}
+      end
 
-      Macro.unescape_string "example\\n", &unescape_map(&1)
+  Such a struct could not be used in module attributes or escaped with `Macro.escape/2`:
 
-  """
-  @spec unescape_string(String.t, (non_neg_integer -> non_neg_integer | false)) :: String.t
-  def unescape_string(chars, map) do
-    :elixir_interpolation.unescape_chars(chars, map)
-  end
+      defmodule Foo do
+        @my_struct WrapperStruct.new(...)
+        def my_struct, do: @my_struct
+      end
 
-  @doc """
-  Unescape the given tokens according to the default map.
+      ** (ArgumentError) cannot inject attribute @my_struct into function/macro because cannot escape #Reference<...>
 
-  Check `unescape_string/1` and `unescape_string/2` for more
-  information about unescaping.
+  To address this, structs can re-define how they should be escaped by defining a custom
+  `__escape__/1` function which returns the AST. In our example:
 
-  Only tokens that are binaries are unescaped, all others are
-  ignored. This function is useful when implementing your own
-  sigils. Check the implementation of `Kernel.sigil_s/2`
-  for examples.
-  """
-  @spec unescape_tokens([Macro.t]) :: [Macro.t]
-  def unescape_tokens(tokens) do
-    :elixir_interpolation.unescape_tokens(tokens)
+      defmodule WrapperStruct do
+        # ...
+
+        def __escape__(struct) do
+          # dump to a binary representation at compile-time
+          binary = dump_to_binary(struct)
+          quote do
+            # load from the binary representation at runtime
+            WrapperStruct.load_from_binary(unquote(Macro.escape(binary)))
+          end
+        end
+      end
+
+  Now, our example above will be expanded as:
+
+      def my_struct, do: WrapperStruct.load_from_binary(<<...>>)
+
+  When implementing `__escape__/1`, you must ensure that the quoted expression
+  will evaluate to a struct that represents the one given as argument.
+  """
+  @spec escape(term, escape_opts) :: t()
+  def escape(expr, opts \\ []) do
+    unquote = Keyword.get(opts, :unquote, false)
+    kind = if Keyword.get(opts, :prune_metadata, false), do: :escape_and_prune, else: :escape
+    generated = Keyword.get(opts, :generated, false)
+
+    case :elixir_quote.escape(expr, kind, unquote) do
+      # mark module attrs as shallow-generated since the ast for their representation
+      # might contain opaque terms
+      {caller, meta, args} when generated and is_list(meta) ->
+        {caller, [generated: true] ++ meta, args}
+
+      ast ->
+        ast
+    end
+  end
+
+  # TODO: Deprecate me on Elixir v1.22
+  @doc deprecated: "Use Macro.struct_info!/2 instead"
+  def struct!(module, env) when is_atom(module) do
+    pairs =
+      for %{field: field, default: default} <- struct_info!(module, env), do: {field, default}
+
+    :maps.from_list([__struct__: module] ++ pairs)
+  end
+
+  @doc """
+  Extracts the struct information.
+
+  This is useful when a struct needs to be expanded at
+  compilation time and the struct being expanded may or may
+  not have been compiled (including structs in the defined
+  under the module being compiled). For compiled modules,
+  it will invoke `module.__info__(:struct)`.
+
+  Calling this function also adds an export dependency on the
+  given struct.
+
+  It will raise `ArgumentError` if the struct is not available.
+
+  ## Compatibility considerations
+
+  This function currently returns both `:required` and `:default`
+  entries for each field. While this naming is inconsistent
+  (a required field should not have a default), this is done for
+  backwards compatibility purposes.
+
+  In future releases, Elixir may introduce truly required struct
+  fields, the required field will be removed and default will be
+  present only if the field is optional. Your code should prepare
+  for such scenario accordingly.
+  """
+  @doc since: "1.18.0"
+  @spec struct_info!(module(), Macro.Env.t()) ::
+          [
+            %{
+              required(:field) => atom(),
+              optional(:required) => boolean(),
+              optional(:default) => term()
+            }
+          ]
+  def struct_info!(module, env) when is_atom(module) do
+    case :elixir_map.maybe_load_struct_info([line: env.line], module, [], true, env) do
+      {:ok, info} -> info
+      {:error, desc} -> raise ArgumentError, List.to_string(:elixir_map.format_error(desc))
+    end
+  end
+
+  @doc """
+  Validates the given expressions are valid quoted expressions.
+
+  Check the type `t:Macro.t/0` for a complete specification of a
+  valid quoted expression.
+
+  It returns `:ok` if the expression is valid. Otherwise it returns
+  a tuple in the form of `{:error, remainder}` where `remainder` is
+  the invalid part of the quoted expression.
+
+  ## Examples
+
+      iex> Macro.validate({:two_element, :tuple})
+      :ok
+      iex> Macro.validate({:three, :element, :tuple})
+      {:error, {:three, :element, :tuple}}
+
+      iex> Macro.validate([1, 2, 3])
+      :ok
+      iex> Macro.validate([1, 2, 3, {4}])
+      {:error, {4}}
+
+  """
+  @spec validate(term) :: :ok | {:error, term}
+  def validate(expr) do
+    find_invalid(expr) || :ok
+  end
+
+  defp find_invalid({left, right}), do: find_invalid(left) || find_invalid(right)
+
+  defp find_invalid({left, meta, right})
+       when is_list(meta) and (is_atom(right) or is_list(right)),
+       do: find_invalid(left) || find_invalid(right)
+
+  defp find_invalid(list) when is_list(list), do: Enum.find_value(list, &find_invalid/1)
+
+  defp find_invalid(pid) when is_pid(pid), do: nil
+  defp find_invalid(atom) when is_atom(atom), do: nil
+  defp find_invalid(num) when is_number(num), do: nil
+  defp find_invalid(bin) when is_binary(bin), do: nil
+
+  defp find_invalid(fun) when is_function(fun) do
+    if Function.info(fun, :env) != {:env, []} or
+         Function.info(fun, :type) != {:type, :external} do
+      {:error, fun}
+    end
+  end
+
+  defp find_invalid(other), do: {:error, other}
+
+  @doc """
+  Returns an enumerable that traverses the  `ast` in depth-first,
+  pre-order traversal.
+
+  ## Examples
+
+      iex> ast = quote do: foo(1, "abc")
+      iex> Enum.map(Macro.prewalker(ast), & &1)
+      [{:foo, [], [1, "abc"]}, 1, "abc"]
+
+  """
+  @doc since: "1.13.0"
+  @spec prewalker(t()) :: Enumerable.t()
+  def prewalker(ast) do
+    &prewalker([ast], &1, &2)
+  end
+
+  defp prewalker(_buffer, {:halt, acc}, _fun) do
+    {:halted, acc}
+  end
+
+  defp prewalker(buffer, {:suspend, acc}, fun) do
+    {:suspended, acc, &prewalker(buffer, &1, fun)}
+  end
+
+  defp prewalker([], {:cont, acc}, _fun) do
+    {:done, acc}
+  end
+
+  defp prewalker([{left, right} = node | tail], {:cont, acc}, fun) do
+    prewalker([left, right | tail], fun.(node, acc), fun)
+  end
+
+  defp prewalker([{left, meta, right} = node | tail], {:cont, acc}, fun)
+       when is_atom(left) and is_list(meta) do
+    if is_atom(right) do
+      prewalker(tail, fun.(node, acc), fun)
+    else
+      prewalker(right ++ tail, fun.(node, acc), fun)
+    end
+  end
+
+  defp prewalker([{left, meta, right} = node | tail], {:cont, acc}, fun) when is_list(meta) do
+    if is_atom(right) do
+      prewalker([left | tail], fun.(node, acc), fun)
+    else
+      prewalker([left | right] ++ tail, fun.(node, acc), fun)
+    end
+  end
+
+  defp prewalker([list | tail], {:cont, acc}, fun) when is_list(list) do
+    prewalker(list ++ tail, fun.(list, acc), fun)
+  end
+
+  defp prewalker([head | tail], {:cont, acc}, fun) do
+    prewalker(tail, fun.(head, acc), fun)
   end
 
   @doc """
-  Unescape the given tokens according to the given map.
+  Returns an enumerable that traverses the  `ast` in depth-first,
+  post-order traversal.
+
+  ## Examples
+
+      iex> ast = quote do: foo(1, "abc")
+      iex> Enum.map(Macro.postwalker(ast), & &1)
+      [1, "abc", {:foo, [], [1, "abc"]}]
+
+  """
+  @doc since: "1.13.0"
+  @spec postwalker(t()) :: Enumerable.t()
+  def postwalker(ast) do
+    &postwalker([ast], make_ref(), &1, &2)
+  end
+
+  defp postwalker(_buffer, _ref, {:halt, acc}, _fun) do
+    {:halted, acc}
+  end
+
+  defp postwalker(buffer, ref, {:suspend, acc}, fun) do
+    {:suspended, acc, &postwalker(buffer, ref, &1, fun)}
+  end
+
+  defp postwalker([], _ref, {:cont, acc}, _fun) do
+    {:done, acc}
+  end
+
+  defp postwalker([{ref, head} | tail], ref, {:cont, acc}, fun) do
+    postwalker(tail, ref, fun.(head, acc), fun)
+  end
+
+  defp postwalker([{left, right} = node | tail], ref, {:cont, acc}, fun) do
+    postwalker([right, {ref, node} | tail], ref, fun.(left, acc), fun)
+  end
+
+  defp postwalker([{left, meta, right} = node | tail], ref, {:cont, acc}, fun)
+       when is_atom(left) and is_list(meta) do
+    if is_atom(right) do
+      postwalker(tail, ref, fun.(node, acc), fun)
+    else
+      postwalker(right ++ [{ref, node} | tail], ref, {:cont, acc}, fun)
+    end
+  end
+
+  defp postwalker([{left, meta, right} = node | tail], ref, cont_acc, fun)
+       when is_list(meta) do
+    if is_atom(right) do
+      postwalker([left, {ref, node} | tail], ref, cont_acc, fun)
+    else
+      postwalker([left | right] ++ [{ref, node} | tail], ref, cont_acc, fun)
+    end
+  end
+
+  defp postwalker([list | tail], ref, cont_acc, fun) when is_list(list) do
+    postwalker(list ++ [{ref, list} | tail], ref, cont_acc, fun)
+  end
+
+  defp postwalker([head | tail], ref, {:cont, acc}, fun) do
+    postwalker(tail, ref, fun.(head, acc), fun)
+  end
+
+  @doc ~S"""
+  Unescapes characters in a string.
+
+  This is the unescaping behaviour used by default in Elixir
+  single- and double-quoted strings. Check `unescape_string/2`
+  for information on how to customize the escaping map.
+
+  In this setup, Elixir will escape the following: `\0`, `\a`, `\b`,
+  `\d`, `\e`, `\f`, `\n`, `\r`, `\s`, `\t` and `\v`. Bytes can be
+  given as hexadecimals via `\xNN` and Unicode code points as
+  `\uNNNN` escapes.
+
+  This function is commonly used on sigil implementations
+  (like `~r`, `~s` and others), which receive a raw, unescaped
+  string, and it can be used anywhere that needs to mimic how
+  Elixir parses strings.
+
+  ## Examples
+
+      iex> Macro.unescape_string("example\\n")
+      "example\n"
+
+  In the example above, we pass a string with `\n` escaped
+  and return a version with it unescaped.
+  """
+  @spec unescape_string(String.t()) :: String.t()
+  def unescape_string(string) do
+    :elixir_interpolation.unescape_string(string)
+  end
+
+  @doc ~S"""
+  Unescapes characters in a string according to the given mapping.
+
+  Check `unescape_string/1` if you want to use the same mapping
+  as Elixir single- and double-quoted strings.
+
+  ## Mapping function
+
+  The mapping function receives an integer representing the code point
+  of the character it wants to unescape. There are also the special atoms
+  `:newline`, `:unicode`, and `:hex`, which control newline, unicode,
+  and escaping respectively.
+
+  Here is the default mapping function implemented by Elixir:
+
+      def unescape_map(:newline), do: true
+      def unescape_map(:unicode), do: true
+      def unescape_map(:hex), do: true
+      def unescape_map(?0), do: ?0
+      def unescape_map(?a), do: ?\a
+      def unescape_map(?b), do: ?\b
+      def unescape_map(?d), do: ?\d
+      def unescape_map(?e), do: ?\e
+      def unescape_map(?f), do: ?\f
+      def unescape_map(?n), do: ?\n
+      def unescape_map(?r), do: ?\r
+      def unescape_map(?s), do: ?\s
+      def unescape_map(?t), do: ?\t
+      def unescape_map(?v), do: ?\v
+      def unescape_map(e), do: e
+
+  If the `unescape_map/1` function returns `false`, the char is
+  not escaped and the backslash is kept in the string.
+
+  ## Examples
+
+  Using the `unescape_map/1` function defined above is easy:
+
+      Macro.unescape_string("example\\n", &unescape_map(&1))
 
-  Check `unescape_tokens/1` and `unescape_string/2` for more information.
   """
-  @spec unescape_tokens([Macro.t], (non_neg_integer -> non_neg_integer | false)) :: [Macro.t]
+  @spec unescape_string(String.t(), (non_neg_integer -> non_neg_integer | false)) :: String.t()
+  def unescape_string(string, map) do
+    :elixir_interpolation.unescape_string(string, map)
+  end
+
+  @doc false
+  @deprecated "Traverse over the arguments using Enum.map/2 instead"
+  def unescape_tokens(tokens) do
+    for token <- tokens do
+      if is_binary(token), do: unescape_string(token), else: token
+    end
+  end
+
+  @doc false
+  @deprecated "Traverse over the arguments using Enum.map/2 instead"
   def unescape_tokens(tokens, map) do
-    :elixir_interpolation.unescape_tokens(tokens, map)
+    for token <- tokens do
+      if is_binary(token), do: unescape_string(token, map), else: token
+    end
   end
 
   @doc """
-  Converts the given expression to a binary.
+  Converts the given expression AST to a string.
+
+  This is a convenience function for converting AST into
+  a string, which discards all formatting of the original
+  code and wraps newlines around 98 characters. See
+  `Code.quoted_to_algebra/2` as a lower level function
+  with more control around formatting.
+
+  If the AST contains invalid nodes, this function will
+  attempt to inspect them, to aid debugging, although
+  the elements won't be formatted accordingly.
 
   ## Examples
 
-      iex> Macro.to_string(quote do: foo.bar(1, 2, 3))
+      iex> Macro.to_string(quote(do: foo.bar(1, 2, 3)))
       "foo.bar(1, 2, 3)"
 
   """
-  @spec to_string(Macro.t) :: String.t
-  @spec to_string(Macro.t, (Macro.t, String.t -> String.t)) :: String.t
-  def to_string(tree, fun \\ fn(_ast, string) -> string end)
+  @spec to_string(t()) :: String.t()
+  def to_string(tree) do
+    doc =
+      Inspect.Algebra.format(Code.quoted_to_algebra(tree, migrate_charlists_as_sigils: true), 98)
+
+    IO.iodata_to_binary(doc)
+  end
+
+  @doc """
+  Converts the given expression AST to a string.
+
+  The given `fun` is called for every node in the AST with two arguments: the
+  AST of the node being printed and the string representation of that same
+  node. The return value of this function is used as the final string
+  representation for that AST node.
+
+  This function discards all formatting of the original code.
+
+  ## Examples
+
+      Macro.to_string(quote(do: 1 + 2), fn
+        1, _string -> "one"
+        2, _string -> "two"
+        _ast, string -> string
+      end)
+      #=> "one + two"
+
+  """
+  @deprecated "Use Macro.to_string/1 instead"
+  @spec to_string(t(), (t(), String.t() -> String.t())) :: String.t()
+  def to_string(tree, fun)
 
   # Variables
-  def to_string({var, _, atom} = ast, fun) when is_atom(atom) do
+  def to_string({var, _, context} = ast, fun) when is_atom(var) and is_atom(context) do
     fun.(ast, Atom.to_string(var))
   end
 
@@ -432,16 +1307,28 @@ defmodule Macro do
   end
 
   def to_string({:__block__, _, _} = ast, fun) do
-    block = adjust_new_lines block_to_string(ast, fun), "\n  "
+    block = adjust_new_lines(block_to_string(ast, fun), "\n  ")
     fun.(ast, "(\n  " <> block <> "\n)")
   end
 
   # Bits containers
-  def to_string({:<<>>, _, args} = ast, fun) do
-    fun.(ast, case Enum.map_join(args, ", ", &to_string(&1, fun)) do
-      "<" <> rest -> "<< <" <> rest  <> " >>"
-      rest -> "<<" <> rest <> ">>"
-    end)
+  def to_string({:<<>>, _, parts} = ast, fun) do
+    if interpolated?(ast) do
+      fun.(ast, interpolate(ast, fun))
+    else
+      result =
+        Enum.map_join(parts, ", ", fn part ->
+          str = bitpart_to_string(part, fun)
+
+          if :binary.first(str) == ?< or :binary.last(str) == ?> do
+            "(" <> str <> ")"
+          else
+            str
+          end
+        end)
+
+      fun.(ast, "<<" <> result <> ">>")
+    end
   end
 
   # Tuple containers
@@ -456,9 +1343,9 @@ defmodule Macro do
     fun.(ast, map)
   end
 
-  def to_string({:%, _, [structname, map]} = ast, fun) do
+  def to_string({:%, _, [struct_name, map]} = ast, fun) do
     {:%{}, _, args} = map
-    struct = "%" <> to_string(structname, fun) <> "{" <> map_to_string(args, fun) <> "}"
+    struct = "%" <> to_string(struct_name, fun) <> "{" <> map_to_string(args, fun) <> "}"
     fun.(ast, struct)
   end
 
@@ -473,220 +1360,501 @@ defmodule Macro do
   end
 
   def to_string({:fn, _, block} = ast, fun) do
-    block = adjust_new_lines block_to_string(block, fun), "\n  "
+    block = adjust_new_lines(block_to_string(block, fun), "\n  ")
     fun.(ast, "fn\n  " <> block <> "\nend")
   end
 
   # left -> right
-  def to_string([{:->, _, _}|_] = ast, fun) do
+  def to_string([{:->, _, _} | _] = ast, fun) do
     fun.(ast, "(" <> arrow_to_string(ast, fun, true) <> ")")
   end
 
   # left when right
   def to_string({:when, _, [left, right]} = ast, fun) do
-    if right != [] and Keyword.keyword?(right) do
-      right = kw_list_to_string(right, fun)
-    else
-      right = fun.(ast, op_to_string(right, fun, :when, :right))
-    end
+    right =
+      if right != [] and Keyword.keyword?(right) do
+        kw_list_to_string(right, fun)
+      else
+        fun.(ast, op_to_string(right, fun, :when, :right))
+      end
 
     fun.(ast, op_to_string(left, fun, :when, :left) <> " when " <> right)
   end
 
-  # Binary ops
-  def to_string({op, _, [left, right]} = ast, fun) when op in unquote(@binary_ops) do
-    fun.(ast, op_to_string(left, fun, op, :left) <> " #{op} " <> op_to_string(right, fun, op, :right))
-  end
-
   # Splat when
   def to_string({:when, _, args} = ast, fun) do
-    {left, right} = :elixir_utils.split_last(args)
-    fun.(ast, "(" <> Enum.map_join(left, ", ", &to_string(&1, fun)) <> ") when " <> to_string(right, fun))
+    {left, right} = split_last(args)
+
+    result =
+      "(" <> Enum.map_join(left, ", ", &to_string(&1, fun)) <> ") when " <> to_string(right, fun)
+
+    fun.(ast, result)
+  end
+
+  # Capture
+  def to_string({:&, _, [{:/, _, [{name, _, ctx}, arity]}]} = ast, fun)
+      when is_atom(name) and is_atom(ctx) and is_integer(arity) do
+    result = "&" <> Atom.to_string(name) <> "/" <> to_string(arity, fun)
+    fun.(ast, result)
   end
 
-  # Unary ops
-  def to_string({unary, _, [{binary, _, [_, _]} = arg]} = ast, fun)
-      when unary in unquote(@unary_ops) and binary in unquote(@binary_ops) do
-    fun.(ast, Atom.to_string(unary) <> "(" <> to_string(arg, fun) <> ")")
+  def to_string({:&, _, [{:/, _, [{{:., _, [mod, name]}, _, []}, arity]}]} = ast, fun)
+      when is_atom(name) and is_integer(arity) do
+    result =
+      "&" <> to_string(mod, fun) <> "." <> Atom.to_string(name) <> "/" <> to_string(arity, fun)
+
+    fun.(ast, result)
   end
 
-  def to_string({:not, _, [arg]} = ast, fun)  do
-    fun.(ast, "not " <> to_string(arg, fun))
+  def to_string({:&, _, [arg]} = ast, fun) when not is_integer(arg) do
+    fun.(ast, "&(" <> to_string(arg, fun) <> ")")
   end
 
-  def to_string({op, _, [arg]} = ast, fun) when op in unquote(@unary_ops) do
-    fun.(ast, Atom.to_string(op) <> to_string(arg, fun))
+  # left not in right
+  def to_string({:not, _, [{:in, _, [left, right]}]} = ast, fun) do
+    fun.(ast, to_string(left, fun) <> " not in " <> to_string(right, fun))
   end
 
   # Access
   def to_string({{:., _, [Access, :get]}, _, [left, right]} = ast, fun) do
-    fun.(ast, to_string(left, fun) <> to_string([right], fun))
+    if op_expr?(left) do
+      fun.(ast, "(" <> to_string(left, fun) <> ")" <> to_string([right], fun))
+    else
+      fun.(ast, to_string(left, fun) <> to_string([right], fun))
+    end
+  end
+
+  # foo.{bar, baz}
+  def to_string({{:., _, [left, :{}]}, _, args} = ast, fun) do
+    fun.(ast, to_string(left, fun) <> ".{" <> args_to_string(args, fun) <> "}")
   end
 
   # All other calls
+  def to_string({{:., _, [left, _]} = target, meta, []} = ast, fun) do
+    to_string = call_to_string(target, fun)
+
+    if is_tuple(left) && meta[:no_parens] do
+      fun.(ast, to_string)
+    else
+      fun.(ast, to_string <> "()")
+    end
+  end
+
   def to_string({target, _, args} = ast, fun) when is_list(args) do
-    {list, last} = :elixir_utils.split_last(args)
-    fun.(ast, case kw_blocks?(last) do
-      true  -> call_to_string_with_args(target, list, fun) <> kw_blocks_to_string(last, fun)
-      false -> call_to_string_with_args(target, args, fun)
-    end)
+    with :error <- unary_call(ast, fun),
+         :error <- op_call(ast, fun),
+         :error <- sigil_call(ast, fun) do
+      {list, last} = split_last(args)
+
+      result =
+        if kw_blocks?(last) do
+          case list do
+            [] -> call_to_string(target, fun) <> kw_blocks_to_string(last, fun)
+            _ -> call_to_string_with_args(target, list, fun) <> kw_blocks_to_string(last, fun)
+          end
+        else
+          call_to_string_with_args(target, args, fun)
+        end
+
+      fun.(ast, result)
+    else
+      {:ok, value} -> value
+    end
   end
 
-  # Two-item tuples
+  # Two-element tuples
   def to_string({left, right}, fun) do
     to_string({:{}, [], [left, right]}, fun)
   end
 
   # Lists
   def to_string(list, fun) when is_list(list) do
-    fun.(list, cond do
-      list == [] ->
-        "[]"
-      :io_lib.printable_list(list) ->
-        "'" <> Inspect.BitString.escape(IO.chardata_to_string(list), ?') <> "'"
-      Keyword.keyword?(list) ->
-        "[" <> kw_list_to_string(list, fun) <> "]"
-      true ->
-        "[" <> Enum.map_join(list, ", ", &to_string(&1, fun)) <> "]"
-    end)
+    result =
+      cond do
+        list == [] ->
+          "[]"
+
+        :io_lib.printable_list(list) ->
+          {escaped, _} = Identifier.escape(IO.chardata_to_string(list), ?")
+          IO.iodata_to_binary([?~, ?c, ?", escaped, ?"])
+
+        Inspect.List.keyword?(list) ->
+          "[" <> kw_list_to_string(list, fun) <> "]"
+
+        true ->
+          "[" <> Enum.map_join(list, ", ", &to_string(&1, fun)) <> "]"
+      end
+
+    fun.(list, result)
   end
 
   # All other structures
-  def to_string(other, fun), do: fun.(other, inspect(other, []))
-
-  # Block keywords
-  @kw_keywords [:do, :catch, :rescue, :after, :else]
+  def to_string(other, fun) do
+    fun.(other, inspect_no_limit(other))
+  end
 
-  defp kw_blocks?([_|_] = kw) do
-    Enum.all?(kw, &match?({x, _} when x in unquote(@kw_keywords), &1))
+  defp inspect_no_limit(value) do
+    Kernel.inspect(value, limit: :infinity, printable_limit: :infinity)
   end
-  defp kw_blocks?(_), do: false
 
-  defp module_to_string(atom, _fun) when is_atom(atom), do: inspect(atom, [])
-  defp module_to_string(other, fun), do: call_to_string(other, fun)
+  defp bitpart_to_string({:"::", meta, [left, right]} = ast, fun) do
+    result =
+      if meta[:inferred_bitstring_spec] do
+        to_string(left, fun)
+      else
+        op_to_string(left, fun, :"::", :left) <>
+          "::" <> bitmods_to_string(right, fun, :"::", :right)
+      end
 
-  defp call_to_string(atom, _fun) when is_atom(atom), do: Atom.to_string(atom)
-  defp call_to_string({:., _, [arg]}, fun),           do: module_to_string(arg, fun) <> "."
-  defp call_to_string({:., _, [left, right]}, fun),   do: module_to_string(left, fun) <> "." <> call_to_string(right, fun)
-  defp call_to_string(other, fun),                    do: to_string(other, fun)
+    fun.(ast, result)
+  end
 
-  defp call_to_string_with_args(target, args, fun) do
-    target = call_to_string(target, fun)
-    args = args_to_string(args, fun)
-    target <> "(" <> args <> ")"
+  defp bitpart_to_string(ast, fun) do
+    to_string(ast, fun)
   end
 
-  defp args_to_string(args, fun) do
-    {list, last} = :elixir_utils.split_last(args)
+  defp bitmods_to_string({op, _, [left, right]} = ast, fun, _, _) when op in [:*, :-] do
+    result =
+      bitmods_to_string(left, fun, op, :left) <>
+        Atom.to_string(op) <> bitmods_to_string(right, fun, op, :right)
 
-    if last != [] and Keyword.keyword?(last) do
-      args = Enum.map_join(list, ", ", &to_string(&1, fun))
-      if list != [], do: args = args <> ", "
-      args <> kw_list_to_string(last, fun)
-    else
-      Enum.map_join(args, ", ", &to_string(&1, fun))
-    end
+    fun.(ast, result)
   end
 
-  defp kw_blocks_to_string(kw, fun) do
-    Enum.reduce(@kw_keywords, " ", fn(x, acc) ->
-      case Keyword.has_key?(kw, x) do
-        true  -> acc <> kw_block_to_string(x, Keyword.get(kw, x), fun)
-        false -> acc
-      end
-    end) <> "end"
+  defp bitmods_to_string(other, fun, parent_op, side) do
+    op_to_string(other, fun, parent_op, side)
   end
 
-  defp kw_block_to_string(key, value, fun) do
-    block = adjust_new_lines block_to_string(value, fun), "\n  "
-    Atom.to_string(key) <> "\n  " <> block <> "\n"
+  # Block keywords
+  kw_keywords = [:do, :rescue, :catch, :else, :after]
+
+  defp kw_blocks?([{:do, _} | _] = kw) do
+    Enum.all?(kw, &match?({x, _} when x in unquote(kw_keywords), &1))
   end
 
-  defp block_to_string([{:->, _, _}|_] = block, fun) do
-    Enum.map_join(block, "\n", fn({:->, _, [left, right]}) ->
-      left = comma_join_or_empty_paren(left, fun, false)
-      left <> "->\n  " <> adjust_new_lines block_to_string(right, fun), "\n  "
+  defp kw_blocks?(_), do: false
+
+  # Check if we have an interpolated string.
+  defp interpolated?({:<<>>, _, [_ | _] = parts}) do
+    Enum.all?(parts, fn
+      {:"::", _, [{{:., _, [Kernel, :to_string]}, _, [_]}, {:binary, _, _}]} -> true
+      binary when is_binary(binary) -> true
+      _ -> false
     end)
   end
 
-  defp block_to_string({:__block__, _, exprs}, fun) do
-    Enum.map_join(exprs, "\n", &to_string(&1, fun))
+  defp interpolated?(_) do
+    false
   end
 
-  defp block_to_string(other, fun), do: to_string(other, fun)
+  defp interpolate(ast, fun), do: interpolate(ast, "\"", "\"", fun)
 
-  defp map_to_string([{:|, _, [update_map, update_args]}], fun) do
-    to_string(update_map, fun) <> " | " <> map_to_string(update_args, fun)
+  defp interpolate({:<<>>, _, [parts]}, left, right, _) when left in [~s["""\n], ~s['''\n]] do
+    <<left::binary, parts::binary, right::binary>>
   end
 
-  defp map_to_string(list, fun) do
-    cond do
-      Keyword.keyword?(list) -> kw_list_to_string(list, fun)
-      true -> map_list_to_string(list, fun)
-    end
+  defp interpolate({:<<>>, _, parts}, left, right, fun) do
+    parts =
+      Enum.map_join(parts, "", fn
+        {:"::", _, [{{:., _, [Kernel, :to_string]}, _, [arg]}, {:binary, _, _}]} ->
+          "\#{" <> to_string(arg, fun) <> "}"
+
+        binary when is_binary(binary) ->
+          escape_sigil(binary, left)
+      end)
+
+    <<left::binary, parts::binary, right::binary>>
   end
 
-  defp kw_list_to_string(list, fun) do
-    Enum.map_join(list, ", ", fn {key, value} ->
-      atom_name = case Inspect.Atom.inspect(key) do
-        ":" <> rest -> rest
-        other       -> other
-      end
-      atom_name <> ": " <> to_string(value, fun)
-    end)
+  defp escape_sigil(parts, "("), do: String.replace(parts, ")", ~S"\)")
+  defp escape_sigil(parts, "{"), do: String.replace(parts, "}", ~S"\}")
+  defp escape_sigil(parts, "["), do: String.replace(parts, "]", ~S"\]")
+  defp escape_sigil(parts, "<"), do: String.replace(parts, ">", ~S"\>")
+  defp escape_sigil(parts, delimiter), do: String.replace(parts, delimiter, "\\#{delimiter}")
+
+  defp module_to_string(atom, _fun) when is_atom(atom) do
+    inspect_no_limit(atom)
   end
 
-  defp map_list_to_string(list, fun) do
-    Enum.map_join(list, ", ", fn {key, value} ->
-      to_string(key, fun) <> " => " <> to_string(value, fun)
-    end)
+  defp module_to_string({:&, _, [val]} = expr, fun) when not is_integer(val) do
+    "(" <> to_string(expr, fun) <> ")"
   end
 
-  defp parenthise(expr, fun) do
+  defp module_to_string({:fn, _, _} = expr, fun) do
     "(" <> to_string(expr, fun) <> ")"
   end
 
-  defp op_to_string({op, _, [_, _]} = expr, fun, parent_op, side) when op in unquote(@binary_ops) do
-    {parent_assoc, parent_prec} = binary_op_props(parent_op)
-    {_, prec}                   = binary_op_props(op)
-    cond do
-      parent_prec < prec -> to_string(expr, fun)
-      parent_prec > prec -> parenthise(expr, fun)
-      true ->
-        # parent_prec == prec, so look at associativity.
-        if parent_assoc == side do
-          to_string(expr, fun)
+  defp module_to_string({_, _, [_ | _] = args} = expr, fun) do
+    if kw_blocks?(List.last(args)) do
+      "(" <> to_string(expr, fun) <> ")"
+    else
+      to_string(expr, fun)
+    end
+  end
+
+  defp module_to_string(expr, fun) do
+    to_string(expr, fun)
+  end
+
+  defp unary_call({op, _, [arg]} = ast, fun) when is_atom(op) do
+    if operator?(op, 1) do
+      if op == :not or op_expr?(arg) do
+        {:ok, fun.(ast, Atom.to_string(op) <> "(" <> to_string(arg, fun) <> ")")}
+      else
+        {:ok, fun.(ast, Atom.to_string(op) <> to_string(arg, fun))}
+      end
+    else
+      :error
+    end
+  end
+
+  defp unary_call(_, _) do
+    :error
+  end
+
+  defp op_call({:..//, _, [left, middle, right]} = ast, fun) do
+    left = op_to_string(left, fun, :.., :left)
+    middle = op_to_string(middle, fun, :.., :right)
+    right = op_to_string(right, fun, :"//", :right)
+    {:ok, fun.(ast, left <> ".." <> middle <> "//" <> right)}
+  end
+
+  defp op_call({op, _, [left, right]} = ast, fun) when is_atom(op) do
+    if operator?(op, 2) do
+      left = op_to_string(left, fun, op, :left)
+      right = op_to_string(right, fun, op, :right)
+      op = if op in [:..], do: "#{op}", else: " #{op} "
+      {:ok, fun.(ast, left <> op <> right)}
+    else
+      :error
+    end
+  end
+
+  defp op_call(_, _) do
+    :error
+  end
+
+  defp sigil_call({sigil, meta, [{:<<>>, _, _} = parts, args]} = ast, fun)
+       when is_atom(sigil) and is_list(args) do
+    delimiter = Keyword.get(meta, :delimiter, "\"")
+    {left, right} = delimiter_pair(delimiter)
+
+    case Atom.to_string(sigil) do
+      <<"sigil_", first, rest::binary>> when first >= ?A and first <= ?Z ->
+        if upcase_letters?(rest) do
+          args = sigil_args(args, fun)
+          {:<<>>, _, [binary]} = parts
+
+          formatted =
+            <<?~, first, rest::binary, left::binary, binary::binary, right::binary, args::binary>>
+
+          {:ok, fun.(ast, formatted)}
         else
-          parenthise(expr, fun)
+          :error
         end
+
+      <<"sigil_", name>> when name >= ?a and name <= ?z ->
+        args = sigil_args(args, fun)
+        formatted = "~" <> <<name>> <> interpolate(parts, left, right, fun) <> args
+        {:ok, fun.(ast, formatted)}
+
+      _ ->
+        :error
+    end
+  end
+
+  defp sigil_call(_other, _fun) do
+    :error
+  end
+
+  defp upcase_letters?(<<letter, rest::binary>>) when letter >= ?A and letter <= ?Z,
+    do: upcase_letters?(rest)
+
+  defp upcase_letters?(<<_>>),
+    do: false
+
+  defp upcase_letters?(<<>>),
+    do: true
+
+  defp delimiter_pair("["), do: {"[", "]"}
+  defp delimiter_pair("{"), do: {"{", "}"}
+  defp delimiter_pair("("), do: {"(", ")"}
+  defp delimiter_pair("<"), do: {"<", ">"}
+  defp delimiter_pair("\"\"\""), do: {"\"\"\"\n", "\"\"\""}
+  defp delimiter_pair("'''"), do: {"'''\n", "'''"}
+  defp delimiter_pair(str), do: {str, str}
+
+  defp sigil_args([], _fun), do: ""
+  defp sigil_args(args, fun), do: fun.(args, List.to_string(args))
+
+  defp op_expr?(expr) do
+    case expr do
+      {op, _, [_, _]} -> operator?(op, 2)
+      {op, _, [_]} -> operator?(op, 1)
+      _ -> false
+    end
+  end
+
+  defp call_to_string(atom, _fun) when is_atom(atom), do: Atom.to_string(atom)
+  defp call_to_string({:., _, [arg]}, fun), do: module_to_string(arg, fun) <> "."
+
+  defp call_to_string({:., _, [left, right]}, fun) when is_atom(right),
+    do: module_to_string(left, fun) <> "." <> call_to_string_for_atom(right)
+
+  defp call_to_string({:., _, [left, right]}, fun),
+    do: module_to_string(left, fun) <> "." <> call_to_string(right, fun)
+
+  defp call_to_string(other, fun), do: to_string(other, fun)
+
+  defp call_to_string_with_args(target, args, fun) do
+    target = call_to_string(target, fun)
+    args = args_to_string(args, fun)
+    target <> "(" <> args <> ")"
+  end
+
+  defp call_to_string_for_atom(atom) do
+    Macro.inspect_atom(:remote_call, atom)
+  end
+
+  defp args_to_string(args, fun) do
+    {list, last} = split_last(args)
+
+    if last != [] and Inspect.List.keyword?(last) do
+      prefix =
+        case list do
+          [] -> ""
+          _ -> Enum.map_join(list, ", ", &to_string(&1, fun)) <> ", "
+        end
+
+      prefix <> kw_list_to_string(last, fun)
+    else
+      Enum.map_join(args, ", ", &to_string(&1, fun))
+    end
+  end
+
+  defp kw_blocks_to_string(kw, fun) do
+    Enum.reduce(unquote(kw_keywords), " ", fn x, acc ->
+      case Keyword.has_key?(kw, x) do
+        true -> acc <> kw_block_to_string(x, Keyword.get(kw, x), fun)
+        false -> acc
+      end
+    end) <> "end"
+  end
+
+  defp kw_block_to_string(key, value, fun) do
+    block = adjust_new_lines(block_to_string(value, fun), "\n  ")
+    Atom.to_string(key) <> "\n  " <> block <> "\n"
+  end
+
+  defp block_to_string([{:->, _, _} | _] = block, fun) do
+    Enum.map_join(block, "\n", fn {:->, _, [left, right]} ->
+      left = comma_join_or_empty_paren(left, fun, false)
+      left <> "->\n  " <> adjust_new_lines(block_to_string(right, fun), "\n  ")
+    end)
+  end
+
+  defp block_to_string({:__block__, _, exprs}, fun) do
+    Enum.map_join(exprs, "\n", &to_string(&1, fun))
+  end
+
+  defp block_to_string(other, fun), do: to_string(other, fun)
+
+  defp map_to_string([{:|, _, [update_map, update_args]}], fun) do
+    to_string(update_map, fun) <> " | " <> map_to_string(update_args, fun)
+  end
+
+  defp map_to_string(list, fun) do
+    cond do
+      Inspect.List.keyword?(list) -> kw_list_to_string(list, fun)
+      true -> map_list_to_string(list, fun)
+    end
+  end
+
+  defp kw_list_to_string(list, fun) do
+    Enum.map_join(list, ", ", fn {key, value} ->
+      Macro.inspect_atom(:key, key) <> " " <> to_string(value, fun)
+    end)
+  end
+
+  defp map_list_to_string(list, fun) do
+    Enum.map_join(list, ", ", fn
+      {key, value} -> to_string(key, fun) <> " => " <> to_string(value, fun)
+      other -> to_string(other, fun)
+    end)
+  end
+
+  defp wrap_in_parenthesis(expr, fun) do
+    "(" <> to_string(expr, fun) <> ")"
+  end
+
+  defp op_to_string({op, _, [_, _]} = expr, fun, parent_op, side) when is_atom(op) do
+    case Identifier.binary_op(op) do
+      {_, prec} ->
+        {parent_assoc, parent_prec} = Identifier.binary_op(parent_op)
+
+        cond do
+          parent_prec < prec -> to_string(expr, fun)
+          parent_prec > prec -> wrap_in_parenthesis(expr, fun)
+          parent_assoc == side -> to_string(expr, fun)
+          true -> wrap_in_parenthesis(expr, fun)
+        end
+
+      :error ->
+        to_string(expr, fun)
     end
   end
 
   defp op_to_string(expr, fun, _, _), do: to_string(expr, fun)
 
   defp arrow_to_string(pairs, fun, paren \\ false) do
-    Enum.map_join(pairs, "; ", fn({:->, _, [left, right]}) ->
+    Enum.map_join(pairs, "; ", fn {:->, _, [left, right]} ->
       left = comma_join_or_empty_paren(left, fun, paren)
       left <> "-> " <> to_string(right, fun)
     end)
   end
 
-  defp comma_join_or_empty_paren([], _fun, true),  do: "() "
+  defp comma_join_or_empty_paren([], _fun, true), do: "() "
   defp comma_join_or_empty_paren([], _fun, false), do: ""
 
   defp comma_join_or_empty_paren(left, fun, _) do
     Enum.map_join(left, ", ", &to_string(&1, fun)) <> " "
   end
 
+  defp split_last([]) do
+    {[], []}
+  end
+
+  defp split_last(args) do
+    {left, [right]} = Enum.split(args, -1)
+    {left, right}
+  end
+
   defp adjust_new_lines(block, replacement) do
     for <<x <- block>>, into: "" do
       case x == ?\n do
-        true  -> replacement
+        true -> replacement
         false -> <<x>>
       end
     end
   end
 
+  @doc """
+  Applies a `mod`, `function`, and `args` at compile-time in `caller`.
+
+  This is used when you want to dynamically invoke a function at
+  compile-time and force it to be tracked as a compile-time dependency.
+  For example, this is used by `dbg/1` to force the `dbg_callback`
+  configuration to be a compile-time dependency.
+
+  If you want to "invoke" a macro instead, remember macros are by
+  definition compile-time, and you can use `Macro.expand/2`.
+  """
+  @doc since: "1.16.0"
+  def compile_apply(mod, fun, args, caller) do
+    :elixir_env.trace({:remote_function, [], mod, fun, length(args)}, %{caller | function: nil})
+    Kernel.apply(mod, fun, args)
+  end
+
   @doc """
   Receives an AST node and expands it once.
 
@@ -694,13 +1862,17 @@ defmodule Macro do
 
     * Macros (local or remote)
     * Aliases are expanded (if possible) and return atoms
-    * Pseudo-variables (`__ENV__`, `__MODULE__` and `__DIR__`)
+    * Compilation environment macros (`__CALLER__/0`, `__DIR__/0`, `__ENV__/0` and `__MODULE__/0`)
     * Module attributes reader (`@foo`)
 
   If the expression cannot be expanded, it returns the expression
-  itself. Notice that `expand_once/2` performs the expansion just
-  once and it is not recursive. Check `expand/2` for expansion
-  until the node can no longer be expanded.
+  itself. This function does not traverse the AST, only the root
+  node is expanded. The expansion happens as if it was expanded by
+  the Elixir compiler and therefore compilation tracers will be invoked
+  and deprecation warnings will be emitted during the expansion.
+
+  `expand_once/2` performs the expansion just once. Check `expand/2`
+  to perform expansion until the node can no longer be expanded.
 
   ## Examples
 
@@ -712,7 +1884,7 @@ defmodule Macro do
   Consider the implementation below:
 
       defmacro defmodule_with_length(name, do: block) do
-        length = length(Atom.to_char_list(name))
+        length = length(Atom.to_charlist(name))
 
         quote do
           defmodule unquote(name) do
@@ -729,13 +1901,13 @@ defmodule Macro do
       end
 
   The compilation will fail because `My.Module` when quoted
-  is not an atom, but a syntax tree as follow:
+  is not an atom, but a syntax tree as follows:
 
       {:__aliases__, [], [:My, :Module]}
 
   That said, we need to expand the aliases node above to an
   atom, so we can retrieve its length. Expanding the node is
-  not straight-forward because we also need to expand the
+  not straightforward because we also need to expand the
   caller aliases. For example:
 
       alias MyHelpers, as: My
@@ -752,7 +1924,7 @@ defmodule Macro do
 
       defmacro defmodule_with_length(name, do: block) do
         expanded = Macro.expand(name, __CALLER__)
-        length   = length(Atom.to_char_list(expanded))
+        length = length(Atom.to_charlist(expanded))
 
         quote do
           defmodule unquote(name) do
@@ -763,108 +1935,97 @@ defmodule Macro do
       end
 
   """
+  @spec expand_once(input(), Macro.Env.t()) :: output()
   def expand_once(ast, env) do
     elem(do_expand_once(ast, env), 0)
   end
 
-  defp do_expand_once({:__aliases__, _, _} = original, env) do
-    case :elixir_aliases.expand(original, env.aliases, env.macro_aliases, env.lexical_tracker) do
+  defp do_expand_once({:__aliases__, meta, list} = alias, env) do
+    case :elixir_aliases.expand_or_concat(meta, list, env, true) do
       receiver when is_atom(receiver) ->
-        :elixir_lexical.record_remote(receiver, env.lexical_tracker)
+        :elixir_env.trace({:alias_reference, meta, receiver}, env)
         {receiver, true}
-      aliases ->
-        aliases = for alias <- aliases, do: elem(do_expand_once(alias, env), 0)
 
-        case :lists.all(&is_atom/1, aliases) do
+      [head | tail] ->
+        {head, _} = do_expand_once(head, env)
+
+        case is_atom(head) do
           true ->
-            receiver = :elixir_aliases.concat(aliases)
-            :elixir_lexical.record_remote(receiver, env.lexical_tracker)
+            receiver = :elixir_aliases.concat([head | tail])
+            :elixir_env.trace({:alias_reference, meta, receiver}, env)
             {receiver, true}
+
           false ->
-            {original, false}
+            {alias, false}
         end
     end
   end
 
-  # Expand @ calls
-  defp do_expand_once({:@, _, [{name, _, args}]} = original, env) when is_atom(args) or args == [] do
-    case (module = env.module) && Module.open?(module) do
-      true  -> {escape(Module.get_attribute(module, name)), true}
-      false -> {original, false}
-    end
-  end
+  # Expand compilation environment macros
+  defp do_expand_once({:__MODULE__, _, atom}, env) when is_atom(atom), do: {env.module, true}
 
-  # Expand pseudo-variables
-  defp do_expand_once({:__MODULE__, _, atom}, env) when is_atom(atom),
-    do: {env.module, true}
   defp do_expand_once({:__DIR__, _, atom}, env) when is_atom(atom),
     do: {:filename.dirname(env.file), true}
-  defp do_expand_once({:__ENV__, _, atom}, env) when is_atom(atom),
-    do: {{:%{}, [], Map.to_list(env)}, true}
-  defp do_expand_once({{:., _, [{:__ENV__, _, atom}, field]}, _, []} = original, env) when
-      is_atom(atom) and is_atom(field) do
+
+  defp do_expand_once({:__ENV__, _, atom}, env) when is_atom(atom) and env.context != :match do
+    env = update_in(env.versioned_vars, &maybe_escape_map/1)
+    {maybe_escape_map(env), true}
+  end
+
+  defp do_expand_once({{:., _, [{:__ENV__, _, atom}, field]}, _, []} = original, env)
+       when is_atom(atom) and is_atom(field) and env.context != :match do
     if Map.has_key?(env, field) do
-      {Map.get(env, field), true}
+      {maybe_escape_map(Map.get(env, field)), true}
     else
       {original, false}
     end
   end
 
-  # Expand possible macro import invocation
-  defp do_expand_once({atom, meta, context} = original, env)
-      when is_atom(atom) and is_list(meta) and is_atom(context) do
-    if :lists.member({atom, Keyword.get(meta, :counter, context)}, env.vars) do
-      {original, false}
-    else
-      case do_expand_once({atom, meta, []}, env) do
-        {_, true} = exp -> exp
-        {_, false}      -> {original, false}
-      end
-    end
+  defp do_expand_once({name, meta, context} = original, _env)
+       when is_atom(name) and is_list(meta) and is_atom(context) do
+    {original, false}
   end
 
-  defp do_expand_once({atom, meta, args} = original, env)
-      when is_atom(atom) and is_list(args) and is_list(meta) do
+  defp do_expand_once({name, meta, args} = original, env)
+       when is_atom(name) and is_list(args) and is_list(meta) do
     arity = length(args)
 
-    if :elixir_import.special_form(atom, arity) do
-      {original, false}
-    else
-      module = env.module
-      extra  = if function_exported?(module, :__info__, 1) do
-        [{module, module.__info__(:macros)}]
-      else
-        []
-      end
+    case Macro.Env.expand_import(env, meta, name, arity) do
+      {:macro, _receiver, expander} ->
+        # We don't want the line to propagate yet, but generated might!
+        {expander.(Keyword.take(meta, [:generated]), args), true}
 
-      expand = :elixir_dispatch.expand_import(meta, {atom, length(args)}, args,
-                                              env, extra)
-
-      case expand do
-        {:ok, receiver, quoted} ->
-          next = :elixir_counter.next
-          {:elixir_quote.linify_with_context_counter(0, {receiver, next}, quoted), true}
-        {:ok, _receiver, _name, _args} ->
-          {original, false}
-        :error ->
-          {original, false}
-      end
+      {:function, Kernel, op} when op in [:+, :-] and arity == 1 ->
+        case expand_once(hd(args), env) do
+          integer when is_integer(integer) -> {apply(Kernel, op, [integer]), true}
+          _ -> {original, false}
+        end
+
+      {:function, _receiver, _name} ->
+        {original, false}
+
+      {:error, :not_found} ->
+        {original, false}
+
+      {:error, other} ->
+        :elixir_errors.file_error(meta, env, :elixir_dispatch, {:import, other, name, arity})
     end
   end
 
   # Expand possible macro require invocation
-  defp do_expand_once({{:., _, [left, right]}, meta, args} = original, env) when is_atom(right) do
+  defp do_expand_once({{:., _, [left, name]}, meta, args} = original, env) when is_atom(name) do
     {receiver, _} = do_expand_once(left, env)
 
     case is_atom(receiver) do
-      false -> {original, false}
-      true  ->
-        expand = :elixir_dispatch.expand_require(meta, receiver, {right, length(args)}, args, env)
-
-        case expand do
-          {:ok, receiver, quoted} ->
-            next = :elixir_counter.next
-            {:elixir_quote.linify_with_context_counter(0, {receiver, next}, quoted), true}
+      false ->
+        {original, false}
+
+      true ->
+        case Macro.Env.expand_require(env, meta, receiver, name, length(args)) do
+          {:macro, _receiver, expander} ->
+            # We don't want the line to propagate yet, but generated might!
+            {expander.(Keyword.take(meta, [:generated]), args), true}
+
           :error ->
             {original, false}
         end
@@ -874,22 +2035,1062 @@ defmodule Macro do
   # Anything else is just returned
   defp do_expand_once(other, _env), do: {other, false}
 
+  defp maybe_escape_map(map) when is_map(map), do: {:%{}, [], Map.to_list(map)}
+  defp maybe_escape_map(other), do: other
+
+  @doc """
+  Returns `true` if the given name and arity is a special form.
+  """
+  @doc since: "1.7.0"
+  @spec special_form?(name :: atom(), arity()) :: boolean()
+  def special_form?(name, arity) when is_atom(name) and is_integer(arity) do
+    :elixir_import.special_form(name, arity)
+  end
+
+  @doc """
+  Returns `true` if the given name and arity is an operator.
+
+  ## Examples
+
+      iex> Macro.operator?(:not_an_operator, 3)
+      false
+      iex> Macro.operator?(:.., 0)
+      true
+      iex> Macro.operator?(:+, 1)
+      true
+      iex> Macro.operator?(:++, 2)
+      true
+      iex> Macro.operator?(:..//, 3)
+      true
+
+  """
+  @doc since: "1.7.0"
+  @spec operator?(name :: atom(), arity()) :: boolean()
+  def operator?(name, arity)
+
+  def operator?(:..//, 3),
+    do: true
+
+  # Code.Identifier treats :// as a binary operator for precedence
+  # purposes but it isn't really one, so we explicitly skip it.
+  def operator?(name, 2) when is_atom(name),
+    do: Identifier.binary_op(name) != :error and name != :"//"
+
+  def operator?(name, 1) when is_atom(name),
+    do: Identifier.unary_op(name) != :error
+
+  def operator?(:.., 0), do: true
+  def operator?(:..., 0), do: true
+
+  def operator?(name, arity) when is_atom(name) and is_integer(arity), do: false
+
+  @doc """
+  Returns `true` if the given quoted expression represents a quoted literal.
+
+  Atoms and numbers are always literals. Binaries, lists, tuples,
+  maps, and structs are only literals if all of their terms are also literals.
+
+  ## Examples
+
+      iex> Macro.quoted_literal?(quote(do: "foo"))
+      true
+      iex> Macro.quoted_literal?(quote(do: {"foo", 1}))
+      true
+      iex> Macro.quoted_literal?(quote(do: {"foo", 1, :baz}))
+      true
+      iex> Macro.quoted_literal?(quote(do: %{foo: "bar"}))
+      true
+      iex> Macro.quoted_literal?(quote(do: %URI{path: "/"}))
+      true
+      iex> Macro.quoted_literal?(quote(do: URI.parse("/")))
+      false
+      iex> Macro.quoted_literal?(quote(do: {foo, var}))
+      false
+
+  """
+  @doc since: "1.7.0"
+  @spec quoted_literal?(t) :: boolean
+  def quoted_literal?(term)
+
+  def quoted_literal?({:__aliases__, _, args}),
+    do: quoted_literal?(args)
+
+  def quoted_literal?({:%, _, [left, right]}),
+    do: quoted_literal?(left) and quoted_literal?(right)
+
+  def quoted_literal?({:%{}, _, args}), do: quoted_literal?(args)
+  def quoted_literal?({:{}, _, args}), do: quoted_literal?(args)
+  def quoted_literal?({:__MODULE__, _, ctx}) when is_atom(ctx), do: true
+  def quoted_literal?({:<<>>, _, segments}), do: Enum.all?(segments, &quoted_bitstring_segment?/1)
+  def quoted_literal?({left, right}), do: quoted_literal?(left) and quoted_literal?(right)
+  def quoted_literal?(list) when is_list(list), do: :lists.all(&quoted_literal?/1, list)
+  def quoted_literal?(term), do: is_atom(term) or is_number(term) or is_binary(term)
+
+  defp quoted_bitstring_segment?(term) when is_integer(term) or is_binary(term), do: true
+
+  defp quoted_bitstring_segment?({:"::", _, [term, modifier]})
+       when is_integer(term) or is_binary(term),
+       do: quoted_bitstring_modifier?(modifier)
+
+  defp quoted_bitstring_segment?(_other), do: false
+
+  defp quoted_bitstring_modifier?({:-, _, [left, right]}),
+    do: quoted_bitstring_modifier?(left) and quoted_bitstring_modifier?(right)
+
+  defp quoted_bitstring_modifier?({atom, _, [size]})
+       when atom in [:size, :unit] and is_integer(size),
+       do: true
+
+  defp quoted_bitstring_modifier?({:*, _, [left, right]})
+       when is_integer(left) and is_integer(right),
+       do: true
+
+  defp quoted_bitstring_modifier?({modifier, _, ctx}) when is_atom(ctx) or ctx == [],
+    do: :elixir_bitstring.validate_spec(modifier, nil) != :none
+
+  defp quoted_bitstring_modifier?(_other), do: false
+
+  @doc false
+  @deprecated "Use Macro.expand_literals/2 instead"
+  def expand_literal(ast, env) do
+    expand_literals(ast, env)
+  end
+
+  @doc """
+  Expands all literals in `ast` with the given `env`.
+
+  This function is mostly used to remove compile-time dependencies
+  from AST nodes. In such cases, the given environment is usually
+  manipulated to represent a function:
+
+      Macro.expand_literals(ast, %{env | function: {:my_code, 1}})
+
+  At the moment, the only expandable literal nodes in an AST are
+  aliases, so this function only expands aliases (and it does so
+  anywhere in a literal).
+
+  However, be careful when removing compile-time dependencies between
+  modules. If you remove them but you still invoke the module at
+  compile-time, Elixir will be unable to properly recompile modules
+  when they change.
+  """
+  @doc since: "1.14.1"
+  @spec expand_literals(input(), Macro.Env.t()) :: output()
+  def expand_literals(ast, env) do
+    {ast, :ok} = expand_literals(ast, :ok, fn node, :ok -> {expand(node, env), :ok} end)
+    ast
+  end
+
+  @doc """
+  Expands all literals in `ast` with the given `acc` and `fun`.
+
+  `fun` will be invoked with an expandable AST node and `acc` and
+  must return a new node with `acc`. This is a general version of
+  `expand_literals/2` which supports a custom expansion function.
+  Please check `expand_literals/2` for use cases and pitfalls.
+  """
+  @doc since: "1.14.1"
+  @spec expand_literals(t(), acc, (t(), acc -> {t(), acc})) :: t() when acc: term()
+  def expand_literals(ast, acc, fun)
+
+  def expand_literals({:__aliases__, meta, args}, acc, fun) do
+    {args, acc} = expand_literals(args, acc, fun)
+
+    if :lists.all(&is_atom/1, args) do
+      fun.({:__aliases__, meta, args}, acc)
+    else
+      {{:__aliases__, meta, args}, acc}
+    end
+  end
+
+  def expand_literals({:__MODULE__, _meta, ctx} = node, acc, fun) when is_atom(ctx) do
+    fun.(node, acc)
+  end
+
+  def expand_literals({:%, meta, [left, right]}, acc, fun) do
+    {left, acc} = expand_literals(left, acc, fun)
+    {right, acc} = expand_literals(right, acc, fun)
+    {{:%, meta, [left, right]}, acc}
+  end
+
+  def expand_literals({:%{}, meta, args}, acc, fun) do
+    {args, acc} = expand_literals(args, acc, fun)
+    {{:%{}, meta, args}, acc}
+  end
+
+  def expand_literals({:{}, meta, args}, acc, fun) do
+    {args, acc} = expand_literals(args, acc, fun)
+    {{:{}, meta, args}, acc}
+  end
+
+  def expand_literals({left, right}, acc, fun) do
+    {left, acc} = expand_literals(left, acc, fun)
+    {right, acc} = expand_literals(right, acc, fun)
+    {{left, right}, acc}
+  end
+
+  def expand_literals(list, acc, fun) when is_list(list) do
+    :lists.mapfoldl(&expand_literals(&1, &2, fun), acc, list)
+  end
+
+  def expand_literals(
+        {{:., _, [{:__aliases__, _, [:Application]}, :compile_env]} = node, meta,
+         [app, key, default]},
+        acc,
+        fun
+      ) do
+    {default, acc} = expand_literals(default, acc, fun)
+    {{node, meta, [app, key, default]}, acc}
+  end
+
+  def expand_literals(term, acc, _fun), do: {term, acc}
+
   @doc """
   Receives an AST node and expands it until it can no longer
   be expanded.
 
+  Note this function does not traverse the AST, only the root
+  node is expanded.
+
   This function uses `expand_once/2` under the hood. Check
-  `expand_once/2` for more information and exmaples.
+  it out for more information and examples.
+  """
+  @spec expand(input(), Macro.Env.t()) :: output()
+  def expand(ast, env) do
+    expand_until({ast, true}, env)
+  end
+
+  defp expand_until({ast, true}, env) do
+    expand_until(do_expand_once(ast, env), env)
+  end
+
+  defp expand_until({ast, false}, _env) do
+    ast
+  end
+
+  @doc """
+  Converts the given argument to a string with the underscore-slash format.
+
+  The argument must either be an atom, representing an Elixir module,
+  or a string representing a module without the `Elixir.` prefix.
+
+  This function was designed to format language identifiers/tokens with the underscore-slash format,
+  that's why it belongs to the `Macro` module. Do not use it as a general
+  mechanism for underscoring strings as it does not support Unicode or
+  characters that are not valid in Elixir identifiers.
+
+  ## Examples
+
+      iex> Macro.underscore("FooBar")
+      "foo_bar"
+
+      iex> Macro.underscore("Foo.Bar")
+      "foo/bar"
+
+      iex> Macro.underscore(Foo.Bar)
+      "foo/bar"
+
+  In general, `underscore` can be thought of as the reverse of
+  `camelize`, however, in some cases formatting may be lost:
+
+      iex> Macro.underscore("SAPExample")
+      "sap_example"
+
+      iex> Macro.camelize("sap_example")
+      "SapExample"
+
+      iex> Macro.camelize("hello_10")
+      "Hello10"
+
+      iex> Macro.camelize("foo/bar")
+      "Foo.Bar"
+
+  """
+  @spec underscore(atom() | String.t()) :: String.t()
+  def underscore(atom_or_string)
+
+  def underscore(atom) when is_atom(atom) do
+    "Elixir." <> rest = Atom.to_string(atom)
+    underscore(rest)
+  end
+
+  def underscore(<<h, t::binary>>) do
+    <<to_lower_char(h)>> <> do_underscore(t, h)
+  end
+
+  def underscore("") do
+    ""
+  end
+
+  defp do_underscore(<<h, t, rest::binary>>, _)
+       when h >= ?A and h <= ?Z and not (t >= ?A and t <= ?Z) and not (t >= ?0 and t <= ?9) and
+              t != ?. and t != ?_ do
+    <<?_, to_lower_char(h), t>> <> do_underscore(rest, t)
+  end
+
+  defp do_underscore(<<h, t::binary>>, prev)
+       when h >= ?A and h <= ?Z and not (prev >= ?A and prev <= ?Z) and prev != ?_ do
+    <<?_, to_lower_char(h)>> <> do_underscore(t, h)
+  end
+
+  defp do_underscore(<<?., t::binary>>, _) do
+    <<?/>> <> underscore(t)
+  end
+
+  defp do_underscore(<<h, t::binary>>, _) do
+    <<to_lower_char(h)>> <> do_underscore(t, h)
+  end
+
+  defp do_underscore(<<>>, _) do
+    <<>>
+  end
+
+  @doc """
+  Converts the given string to CamelCase format.
+
+  This function was designed to camelize language identifiers/tokens,
+  that's why it belongs to the `Macro` module. Do not use it as a general
+  mechanism for camelizing strings as it does not support Unicode or
+  characters that are not valid in Elixir identifiers.
+
+  ## Examples
+
+      iex> Macro.camelize("foo_bar")
+      "FooBar"
+
+      iex> Macro.camelize("foo/bar")
+      "Foo.Bar"
+
+  If uppercase characters are present, they are not modified in any way
+  as a mechanism to preserve acronyms:
+
+      iex> Macro.camelize("API.V1")
+      "API.V1"
+      iex> Macro.camelize("API_SPEC")
+      "API_SPEC"
+
+  """
+  @spec camelize(String.t()) :: String.t()
+  def camelize(string)
+
+  def camelize(""), do: ""
+  def camelize(<<?_, t::binary>>), do: camelize(t)
+  def camelize(<<h, t::binary>>), do: <<to_upper_char(h)>> <> do_camelize(t)
+
+  defp do_camelize(<<?_, ?_, t::binary>>), do: do_camelize(<<?_, t::binary>>)
+
+  defp do_camelize(<<?_, h, t::binary>>) when h >= ?a and h <= ?z,
+    do: <<to_upper_char(h)>> <> do_camelize(t)
+
+  defp do_camelize(<<?_, h, t::binary>>) when h >= ?0 and h <= ?9, do: <<h>> <> do_camelize(t)
+  defp do_camelize(<<?_>>), do: <<>>
+  defp do_camelize(<<?/, t::binary>>), do: <<?.>> <> camelize(t)
+  defp do_camelize(<<h, t::binary>>), do: <<h>> <> do_camelize(t)
+  defp do_camelize(<<>>), do: <<>>
+
+  defp to_upper_char(char) when char >= ?a and char <= ?z, do: char - 32
+  defp to_upper_char(char), do: char
+
+  defp to_lower_char(char) when char >= ?A and char <= ?Z, do: char + 32
+  defp to_lower_char(char), do: char
+
+  ## Atom handling
+
+  @doc """
+  Classifies an `atom` based on its possible AST placement.
+
+  It returns one of the following atoms:
+
+    * `:alias` - the atom represents an alias
+
+    * `:identifier` - the atom can be used as a variable or local function
+      call (as well as be an unquoted atom)
+
+    * `:unquoted` - the atom can be used in its unquoted form,
+      includes operators and atoms with `@` in them
+
+    * `:quoted` - all other atoms which can only be used in their quoted form
+
+  Most operators are going to be `:unquoted`, such as `:+`, with
+  some exceptions returning `:quoted` due to ambiguity, such as
+  `:"::"`. Use `operator?/2` to check if a given atom is an operator.
+
+  ## Examples
+
+      iex> Macro.classify_atom(:foo)
+      :identifier
+      iex> Macro.classify_atom(Foo)
+      :alias
+      iex> Macro.classify_atom(:foo@bar)
+      :unquoted
+      iex> Macro.classify_atom(:+)
+      :unquoted
+      iex> Macro.classify_atom(:Foo)
+      :unquoted
+      iex> Macro.classify_atom(:"with spaces")
+      :quoted
+
+  """
+  @doc since: "1.14.0"
+  @spec classify_atom(atom) :: :alias | :identifier | :quoted | :unquoted
+  def classify_atom(atom) do
+    case inner_classify(atom) do
+      :alias -> :alias
+      :identifier -> :identifier
+      type when type in [:unquoted_operator, :not_callable] -> :unquoted
+      _ -> :quoted
+    end
+  end
+
+  @doc ~S"""
+  Inspects `atom` according to different source formats.
+
+  The atom can be inspected according to the three different
+  formats it appears in the AST: as a literal (`:literal`),
+  as a key (`:key`), or as the function name of a remote call
+  (`:remote_call`).
+
+  ## Options
+
+    * `:escape` - a two-arity function used to escape a quoted
+      atom content, if necessary. The function receives the atom
+      content as string and a quote delimiter character, which
+      should always be escaped. By default the content is escaped
+      such that the inspected sequence would be parsed as the
+      given atom.
+
+  ## Examples
+
+  ### As a literal
+
+  Literals include regular atoms, quoted atoms, operators,
+  aliases, and the special `nil`, `true`, and `false` atoms.
+
+      iex> Macro.inspect_atom(:literal, nil)
+      "nil"
+      iex> Macro.inspect_atom(:literal, :foo)
+      ":foo"
+      iex> Macro.inspect_atom(:literal, :<>)
+      ":<>"
+      iex> Macro.inspect_atom(:literal, :Foo)
+      ":Foo"
+      iex> Macro.inspect_atom(:literal, Foo.Bar)
+      "Foo.Bar"
+      iex> Macro.inspect_atom(:literal, :"with spaces")
+      ":\"with spaces\""
+
+  ### As a key
+
+  Inspect an atom as a key of a keyword list or a map.
+
+      iex> Macro.inspect_atom(:key, :foo)
+      "foo:"
+      iex> Macro.inspect_atom(:key, :<>)
+      "<>:"
+      iex> Macro.inspect_atom(:key, :Foo)
+      "Foo:"
+      iex> Macro.inspect_atom(:key, :"with spaces")
+      "\"with spaces\":"
+
+  ### As a remote call
+
+  Inspect an atom the function name of a remote call.
+
+      iex> Macro.inspect_atom(:remote_call, :foo)
+      "foo"
+      iex> Macro.inspect_atom(:remote_call, :<>)
+      "<>"
+      iex> Macro.inspect_atom(:remote_call, :Foo)
+      "\"Foo\""
+      iex> Macro.inspect_atom(:remote_call, :"with spaces")
+      "\"with spaces\""
+
   """
-  def expand(tree, env) do
-    expand_until({tree, true}, env)
+  @doc since: "1.14.0"
+  @spec inspect_atom(:literal | :key | :remote_call, atom, inspect_atom_opts) :: binary
+  def inspect_atom(source_format, atom, opts \\ [])
+
+  def inspect_atom(:literal, atom, _opts) when is_nil(atom) or is_boolean(atom) do
+    Atom.to_string(atom)
+  end
+
+  def inspect_atom(:literal, atom, opts) when is_atom(atom) do
+    binary = Atom.to_string(atom)
+
+    case classify_atom(atom) do
+      :alias ->
+        case binary do
+          binary when binary in ["Elixir", "Elixir.Elixir"] -> binary
+          "Elixir.Elixir." <> _rest -> binary
+          "Elixir." <> rest -> rest
+        end
+
+      :quoted ->
+        escaped = inspect_atom_escape(opts, binary, ?")
+        IO.iodata_to_binary([?:, ?", escaped, ?"])
+
+      _ ->
+        ":" <> binary
+    end
+  end
+
+  def inspect_atom(:key, atom, opts) when is_atom(atom) do
+    binary = Atom.to_string(atom)
+
+    case classify_atom(atom) do
+      :alias ->
+        IO.iodata_to_binary([?", binary, ?", ?:])
+
+      :quoted ->
+        escaped = inspect_atom_escape(opts, binary, ?")
+        IO.iodata_to_binary([?", escaped, ?", ?:])
+
+      _ ->
+        IO.iodata_to_binary([binary, ?:])
+    end
+  end
+
+  def inspect_atom(:remote_call, atom, opts) when is_atom(atom) do
+    binary = Atom.to_string(atom)
+
+    case inner_classify(atom) do
+      type when type in [:identifier, :unquoted_operator, :quoted_operator] ->
+        binary
+
+      type ->
+        escaped =
+          if type in [:not_callable, :alias] do
+            binary
+          else
+            inspect_atom_escape(opts, binary, ?")
+          end
+
+        IO.iodata_to_binary([?", escaped, ?"])
+    end
+  end
+
+  defp inspect_atom_escape(opts, string, char) do
+    if escape = opts[:escape] do
+      escape.(string, char)
+    else
+      {escaped, _} = Code.Identifier.escape(string, char)
+      escaped
+    end
+  end
+
+  # Classifies the given atom into one of the following categories:
+  #
+  #   * `:alias` - a valid Elixir alias, like `Foo`, `Foo.Bar` and so on
+  #
+  #   * `:identifier` - an atom that can be used as a variable/local call;
+  #     this category includes identifiers like `:foo`
+  #
+  #   * `:unquoted_operator` - all callable operators, such as `:<>`. Note
+  #     operators such as `:..` are not callable because of ambiguity
+  #
+  #   * `:quoted_operator` - callable operators that must be wrapped in quotes when
+  #     defined as an atom. For example, `::` must be written as `:"::"` to avoid
+  #     the ambiguity between the atom and the keyword identifier
+  #
+  #   * `:not_callable` - an atom that cannot be used as a function call after the
+  #     `.` operator. Those are typically AST nodes that are special forms (such as
+  #     `:%{}` and `:<<>>>`) as well as nodes that are ambiguous in calls (such as
+  #     `:..` and `:...`). This category also includes atoms like `:Foo`, since
+  #     they are valid identifiers but they need quotes to be used in function
+  #     calls (`Foo."Bar"`)
+  #
+  #   * `:other` - any other atom (these are usually escaped when inspected, like
+  #     `:"foo and bar"`)
+  #
+  defp inner_classify(atom) when is_atom(atom) do
+    cond do
+      atom in [:%, :%{}, :{}, :<<>>, :..., :.., :., :..//, :->] ->
+        :not_callable
+
+      # <|>, ^^^, and ~~~ are deprecated
+      atom in [:"::", :"^^^", :"~~~", :"<|>"] ->
+        :quoted_operator
+
+      operator?(atom, 1) or operator?(atom, 2) ->
+        :unquoted_operator
+
+      true ->
+        charlist = Atom.to_charlist(atom)
+
+        if valid_alias?(charlist) do
+          :alias
+        else
+          case :elixir_config.identifier_tokenizer().tokenize(charlist) do
+            {kind, _acc, [], _, _, special} ->
+              cond do
+                kind != :identifier or :lists.member(:at, special) ->
+                  :not_callable
+
+                # identifier_tokenizer used to return errors for non-nfc, but
+                # now it nfc-normalizes everything. However, lack of nfc is
+                # still a good reason to quote an atom when printing.
+                :lists.member(:nfkc, special) ->
+                  :other
+
+                true ->
+                  :identifier
+              end
+
+            _ ->
+              :other
+          end
+        end
+    end
+  end
+
+  defp valid_alias?([?E, ?l, ?i, ?x, ?i, ?r] ++ rest), do: valid_alias_piece?(rest)
+  defp valid_alias?(_other), do: false
+
+  defp valid_alias_piece?([?., char | rest]) when char >= ?A and char <= ?Z,
+    do: valid_alias_piece?(trim_leading_while_valid_identifier(rest))
+
+  defp valid_alias_piece?([]), do: true
+  defp valid_alias_piece?(_other), do: false
+
+  defp trim_leading_while_valid_identifier([char | rest])
+       when char >= ?a and char <= ?z
+       when char >= ?A and char <= ?Z
+       when char >= ?0 and char <= ?9
+       when char == ?_ do
+    trim_leading_while_valid_identifier(rest)
+  end
+
+  defp trim_leading_while_valid_identifier(other) do
+    other
+  end
+
+  @doc """
+  Default backend for `Kernel.dbg/2`.
+
+  This function provides a default backend for `Kernel.dbg/2`. See the
+  `Kernel.dbg/2` documentation for more information.
+
+  This function:
+
+    * prints information about the given `env`
+    * prints information about `code` and its returned value (using `opts` to inspect terms)
+    * returns the value returned by evaluating `code`
+
+  You can call this function directly to build `Kernel.dbg/2` backends that fall back
+  to this function.
+
+  This function raises if the context of the given `env` is `:match` or `:guard`.
+  """
+  @doc since: "1.14.0"
+  @spec dbg(t, t, Macro.Env.t()) :: t
+  def dbg(code, options, %Macro.Env{} = env) do
+    case env.context do
+      :match ->
+        raise ArgumentError,
+              "invalid expression in match, dbg is not allowed in patterns " <>
+                "such as function clauses, case clauses or on the left side of the = operator"
+
+      :guard ->
+        raise ArgumentError,
+              "invalid expression in guard, dbg is not allowed in guards. " <>
+                "To learn more about guards, visit: https://hexdocs.pm/elixir/patterns-and-guards.html"
+
+      _ ->
+        :ok
+    end
+
+    prelude = quote do: options = unquote(options)
+    acc = {prelude, dbg_format_header(env)}
+
+    {acc, nil} =
+      Enum.reduce(dbg_ast_to_debuggable(code, env), acc, fn entry, {acc, header} ->
+        acc =
+          quote do
+            unquote(acc)
+            to_debug = unquote(entry)
+            unquote(__MODULE__).__dbg__(to_debug, unquote(header), options)
+          end
+
+        {acc, nil}
+      end)
+
+    acc
+  end
+
+  # Pipelines.
+  defp dbg_ast_to_debuggable({:|>, _meta, _args} = pipe_ast, _env) do
+    value_var = unique_var(:value, __MODULE__)
+
+    [start_ast | rest_asts] = for {ast, 0} <- unpipe(pipe_ast), do: ast
+    piped_rest_asts = Enum.map(rest_asts, &{&1, pipe(value_var, &1, 0)})
+
+    first_entry =
+      quote do
+        unquote(value_var) = unquote(start_ast)
+        {:multi_value, unquote(escape(start_ast)), unquote(value_var)}
+      end
+
+    len = length(piped_rest_asts)
+
+    pipe_entries =
+      Enum.with_index(piped_rest_asts, fn {original_ast, step_ast}, i ->
+        tag = if i + 1 == len, do: :pipe_end, else: :pipe
+
+        quote do
+          unquote(value_var) = unquote(step_ast)
+          {unquote(tag), unquote(escape(original_ast)), unquote(value_var)}
+        end
+      end)
+
+    [first_entry | pipe_entries]
+  end
+
+  dbg_decomposed_binary_operators = [:&&, :||, :and, :or]
+
+  # Logic operators.
+  defp dbg_ast_to_debuggable({op, _meta, [_left, _right]} = ast, _env)
+       when op in unquote(dbg_decomposed_binary_operators) do
+    result_var = unique_var(:result, __MODULE__)
+    dbg_boolean_tree(ast, result_var, [])
+  end
+
+  defp dbg_ast_to_debuggable({:__block__, _meta, exprs}, _env) when exprs != [] do
+    result_var = unique_var(:result, __MODULE__)
+    count = length(exprs)
+
+    Enum.with_index(exprs, fn expr, i ->
+      tag = if i + 1 == count, do: :value, else: :multi_value
+
+      quote do
+        unquote(result_var) = unquote(expr)
+        {unquote(tag), unquote(Macro.escape(expr)), unquote(result_var)}
+      end
+    end)
+  end
+
+  defp dbg_ast_to_debuggable({:case, _meta, [expr, [do: clauses]]} = ast, _env) do
+    clauses_returning_index =
+      Enum.with_index(clauses, fn {:->, meta, [left, right]}, index ->
+        {:->, meta, [left, {right, index}]}
+      end)
+
+    [
+      quote do
+        expr = unquote(expr)
+        {:case_argument, unquote(escape(expr)), expr}
+      end,
+      quote do
+        {result, clause_index} =
+          case expr do
+            unquote(clauses_returning_index)
+          end
+
+        {:case_expression, unquote(escape(ast)), clause_index, result}
+      end
+    ]
   end
 
-  defp expand_until({tree, true}, env) do
-    expand_until(do_expand_once(tree, env), env)
+  defp dbg_ast_to_debuggable({:cond, _meta, [[do: clauses]]} = ast, _env) do
+    modified_clauses =
+      Enum.with_index(clauses, fn {:->, _meta, [[left], right]}, index ->
+        hd(
+          quote do
+            clause_value = unquote(left) ->
+              {unquote(escape(left)), clause_value, unquote(index), unquote(right)}
+          end
+        )
+      end)
+
+    [
+      quote do
+        {clause_ast, clause_value, clause_index, value} =
+          cond do
+            unquote(modified_clauses)
+          end
+
+        {:cond, unquote(escape(ast)), clause_ast, clause_value, clause_index, value}
+      end
+    ]
+  end
+
+  defp dbg_ast_to_debuggable({:if, meta, [condition_ast, clauses]} = ast, env) do
+    case Macro.Env.lookup_import(env, {:if, 2}) do
+      [macro: Kernel] ->
+        condition_result_var = unique_var(:condition_result, __MODULE__)
+
+        [
+          quote do
+            unquote(condition_result_var) = unquote(condition_ast)
+            {:if_condition, unquote(escape(condition_ast)), unquote(condition_result_var)}
+          end,
+          quote do
+            result = unquote({:if, meta, [condition_result_var, clauses]})
+            {:if_result, unquote(escape(ast)), result}
+          end
+        ]
+
+      _ ->
+        [quote(do: {:value, unquote(escape(ast)), unquote(ast)})]
+    end
+  end
+
+  defp dbg_ast_to_debuggable({:with, meta, args} = ast, _env) do
+    {opts, clauses} = List.pop_at(args, -1)
+
+    acc_var = unique_var(:acc, __MODULE__)
+
+    modified_clauses =
+      Enum.flat_map(clauses, fn
+        # We only detail assignments and pattern-matching clauses that
+        # can be helpful to understand how the result is constructed.
+        {:<-, _meta, [left, right]} ->
+          modified_left =
+            case left do
+              {:when, meta, [pattern, guard]} -> {:when, meta, [{pattern, quote(do: _)}, guard]}
+              pattern -> {pattern, quote(do: _)}
+            end
+
+          quote do
+            [
+              value = unquote(right),
+              unquote(acc_var) = [{unquote(escape(right)), value} | unquote(acc_var)],
+              unquote(modified_left) <- {value, unquote(acc_var)}
+            ]
+          end
+
+        {:=, _meta, [left, right]} ->
+          quote do
+            [
+              value = unquote(right),
+              unquote(acc_var) = [{unquote(escape(right)), value} | unquote(acc_var)],
+              unquote(left) = value
+            ]
+          end
+
+        # Other expressions like side effects are omitted.
+        expr ->
+          [expr]
+      end)
+
+    modified_opts =
+      Enum.map(opts, fn
+        {:do, do_block} ->
+          {:do, {do_block, acc_var}}
+
+        {:else, else_block} ->
+          clauses =
+            Enum.map(else_block, fn
+              {:->, meta, [[{:when, meta2, [pattern, guard]}], right]} ->
+                {:->, meta, [[{:when, meta2, [{pattern, acc_var}, guard]}], {right, acc_var}]}
+
+              {:->, meta, [[left], right]} ->
+                {:->, meta, [[{left, acc_var}], {right, acc_var}]}
+
+              invalid ->
+                invalid
+            end)
+
+          error_clause =
+            quote generated: true do
+              {other, _acc} -> raise WithClauseError, term: other
+            end
+
+          {:else, clauses ++ error_clause}
+
+        invalid ->
+          invalid
+      end)
+
+    modified_with_ast = {:with, meta, modified_clauses ++ [modified_opts]}
+
+    [
+      quote do
+        unquote(acc_var) = []
+
+        {value, acc} = unquote(modified_with_ast)
+
+        {:with, unquote(escape(ast)), Enum.reverse(acc), value}
+      end
+    ]
+  end
+
+  # Any other AST.
+  defp dbg_ast_to_debuggable(ast, _env) do
+    [quote(do: {:value, unquote(escape(ast)), unquote(ast)})]
+  end
+
+  # This is a binary operator. We replace the left side with a recursive call to
+  # this function to decompose it
+  defp dbg_boolean_tree({op, _meta, [left, right]} = ast, result_var, nodes)
+       when op in unquote(dbg_decomposed_binary_operators) do
+    tag = if nodes == [], do: :value, else: :multi_value
+
+    node =
+      quote do
+        unquote(result_var) = unquote(op)(unquote(result_var), unquote(right))
+        {unquote(tag), unquote(escape(ast)), unquote(result_var)}
+      end
+
+    dbg_boolean_tree(left, result_var, [node | nodes])
+  end
+
+  defp dbg_boolean_tree(ast, result_var, nodes) do
+    node =
+      quote do
+        {:multi_value, unquote(escape(ast)), unquote(result_var) = unquote(ast)}
+      end
+
+    [node | nodes]
+  end
+
+  # Made public to be called from Macro.dbg/3, so that we generate as little code
+  # as possible and call out into a function as soon as we can.
+  @doc false
+  def __dbg__(to_debug, header, options) do
+    {print_location?, options} = Keyword.pop(options, :print_location, true)
+    ansi_enabled? = options[:syntax_colors] != []
+
+    if print_location? and is_binary(header) do
+      formatted = [:cyan, :italic, header, :reset, "\n"]
+      :ok = IO.write(IO.ANSI.format(formatted, ansi_enabled?))
+    end
+
+    syntax_colors = if IO.ANSI.enabled?(), do: IO.ANSI.syntax_colors(), else: []
+    options = Keyword.merge([width: 80, pretty: true, syntax_colors: syntax_colors], options)
+    {formatted, result} = dbg_format_ast_to_debug(to_debug, options)
+    :ok = IO.write(IO.ANSI.format([formatted, ?\n], ansi_enabled?))
+    result
+  end
+
+  defp dbg_format_ast_to_debug({:pipe, code_ast, value}, options) do
+    formatted = [
+      [:faint, "|> ", :reset],
+      dbg_format_ast_with_value_no_newline(code_ast, value, options)
+    ]
+
+    {formatted, value}
+  end
+
+  defp dbg_format_ast_to_debug({:pipe_end, code_ast, value}, options) do
+    {formatted, value} = dbg_format_ast_to_debug({:pipe, code_ast, value}, options)
+
+    {[formatted, ?\n], value}
+  end
+
+  defp dbg_format_ast_to_debug({:case_argument, expr_ast, expr_value}, options) do
+    formatted = [
+      dbg_maybe_underline("Case argument", options),
+      ":\n",
+      dbg_format_ast_with_value(expr_ast, expr_value, options)
+    ]
+
+    {formatted, expr_value}
+  end
+
+  defp dbg_format_ast_to_debug({:case_expression, ast, clause_index, value}, options) do
+    formatted = [
+      dbg_maybe_underline("Case expression", options),
+      " (clause ##{clause_index + 1} matched):\n",
+      dbg_format_ast_with_value(ast, value, options)
+    ]
+
+    {formatted, value}
+  end
+
+  defp dbg_format_ast_to_debug(
+         {:cond, ast, clause_ast, clause_value, clause_index, value},
+         options
+       ) do
+    formatted = [
+      dbg_maybe_underline("Cond clause", options),
+      " (clause ##{clause_index + 1} matched):\n",
+      dbg_format_ast_with_value(clause_ast, clause_value, options),
+      ?\n,
+      dbg_maybe_underline("Cond expression", options),
+      ":\n",
+      dbg_format_ast_with_value(ast, value, options)
+    ]
+
+    {formatted, value}
+  end
+
+  defp dbg_format_ast_to_debug({:if_condition, condition_ast, condition_result}, options) do
+    formatted = [
+      dbg_maybe_underline("If condition", options),
+      ":\n",
+      dbg_format_ast_with_value(condition_ast, condition_result, options)
+    ]
+
+    {formatted, condition_result}
+  end
+
+  defp dbg_format_ast_to_debug({:if_result, ast, result}, options) do
+    formatted = [
+      dbg_maybe_underline("If expression", options),
+      ":\n",
+      dbg_format_ast_with_value(ast, result, options)
+    ]
+
+    {formatted, result}
+  end
+
+  defp dbg_format_ast_to_debug({:with, ast, clauses, result}, options) do
+    formatted_clauses =
+      Enum.map(clauses, fn {clause_ast, clause_result} ->
+        dbg_format_ast_with_value(clause_ast, clause_result, options)
+      end)
+
+    formatted = [
+      dbg_maybe_underline("With clauses", options),
+      ":\n",
+      formatted_clauses,
+      ?\n,
+      dbg_maybe_underline("With expression", options),
+      ":\n",
+      dbg_format_ast_with_value(ast, result, options)
+    ]
+
+    {formatted, result}
+  end
+
+  defp dbg_format_ast_to_debug({:multi_value, code_ast, value}, options) do
+    {dbg_format_ast_with_value_no_newline(code_ast, value, options), value}
+  end
+
+  defp dbg_format_ast_to_debug({:value, code_ast, value}, options) do
+    {dbg_format_ast_with_value(code_ast, value, options), value}
+  end
+
+  defp dbg_format_ast_with_value_no_newline(ast, value, options) do
+    [dbg_format_ast(to_string_with_colors(ast, options)), " ", inspect(value, options)]
+  end
+
+  defp dbg_format_ast_with_value(ast, value, options) do
+    [dbg_format_ast_with_value_no_newline(ast, value, options), ?\n]
+  end
+
+  defp to_string_with_colors(ast, options) do
+    options = Keyword.take(options, [:syntax_colors])
+
+    algebra = Code.quoted_to_algebra(ast, options)
+    IO.iodata_to_binary(Inspect.Algebra.format(algebra, 98))
+  end
+
+  defp dbg_format_header(env) do
+    env = Map.update!(env, :file, &(&1 && Path.relative_to_cwd(&1)))
+    [stacktrace_entry] = Macro.Env.stacktrace(env)
+    "[" <> Exception.format_stacktrace_entry(stacktrace_entry) <> "]"
+  end
+
+  defp dbg_maybe_underline(string, options) do
+    if options[:syntax_colors] != [] do
+      IO.ANSI.format([:underline, string, :reset])
+    else
+      string
+    end
   end
 
-  defp expand_until({tree, false}, _env) do
-    tree
+  defp dbg_format_ast(ast) do
+    [ast, :faint, " #=>", :reset]
   end
 end
diff --git a/lib/elixir/lib/macro/env.ex b/lib/elixir/lib/macro/env.ex
index 98c5ed341c4..64bab116008 100644
--- a/lib/elixir/lib/macro/env.ex
+++ b/lib/elixir/lib/macro/env.ex
@@ -1,114 +1,713 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Macro.Env do
   @moduledoc """
   A struct that holds compile time environment information.
 
   The current environment can be accessed at any time as
-  `__ENV__`. Inside macros, the caller environment can be
-  accessed as `__CALLER__`. It contains the following fields:
+  `__ENV__/0`. Inside macros, the caller environment can be
+  accessed as `__CALLER__/0`.
+
+  The majority of the functions in this module are provided
+  for low-level tools, which need to integrate with the Elixir
+  compiler, such as language servers and embedded languages.
+  For regular usage in Elixir code and macros, you must use
+  the `Macro` module instead. In particular, avoid modifying
+  the `Macro.Env` struct directly and prefer to use high-level
+  constructs, such as a `import`, `aliases`, and so forth to
+  build your own environment. For example, to build a custom
+  environment, you can define a function such as:
+
+      def make_custom_env do
+        import SomeModule, only: [some_function: 2], warn: false
+        alias A.B.C, warn: false
+        __ENV__
+      end
+
+  ## Struct fields
+
+  The `Macro.Env` struct contains the following fields:
 
-    * `module` - the current module name
-    * `file` - the current file name as a binary
-    * `line` - the current line as an integer
-    * `function` - a tuple as `{atom, integer`}, where the first
-      element is the function name and the seconds its arity; returns
-      `nil` if not inside a function
     * `context` - the context of the environment; it can be `nil`
-      (default context), inside a guard or inside an assign
-    * `aliases` -  a list of two item tuples, where the first
-      item is the aliased name and the second the actual name
-    * `requires` - the list of required modules
-    * `functions` - a list of functions imported from each module
-    * `macros` - a list of macros imported from each module
-    * `macro_aliases` - a list of aliases defined inside the current macro
+      (default context), `:guard` (inside a guard) or `:match` (inside a match)
     * `context_modules` - a list of modules defined in the current context
-    * `vars` - a list keeping all defined variables as `{var, context}`
-    * `export_vars` - a list keeping all variables to be exported in a
-      construct (may be `nil`)
-    * `lexical_tracker` - PID of the lexical tracker which is responsible to
-      keep user info
-    * `local` - the module to expand local functions to
+    * `file` - the current absolute file name as a binary
+    * `function` - a tuple as `{atom, integer}`, where the first
+      element is the function name and the second its arity; returns
+      `nil` if not inside a function
+    * `line` - the current line as an integer
+    * `module` - the current module name
+
+  The following fields are private to Elixir's macro expansion mechanism and
+  must not be accessed directly:
+
+    * `aliases`
+    * `functions`
+    * `macro_aliases`
+    * `macros`
+    * `lexical_tracker`
+    * `requires`
+    * `tracers`
+    * `versioned_vars`
+
   """
 
-  @type name_arity :: {atom, non_neg_integer}
-  @type file :: binary
-  @type line :: non_neg_integer
-  @type aliases :: [{module, module}]
-  @type macro_aliases :: [{module, {integer, module}}]
   @type context :: :match | :guard | nil
-  @type requires :: [module]
-  @type functions :: [{module, [name_arity]}]
-  @type macros :: [{module, [name_arity]}]
   @type context_modules :: [module]
-  @type vars :: [{atom, atom | non_neg_integer}]
-  @type export_vars :: vars | nil
-  @type lexical_tracker :: pid
-  @type local :: module | nil
-
-  @type t :: %{__struct__: __MODULE__,
-               module: module,
-               file: file,
-               line: line,
-               function: name_arity | nil,
-               context: context,
-               requires: requires,
-               aliases: aliases,
-               functions: functions,
-               macros: macros,
-               macro_aliases: aliases,
-               context_modules: context_modules,
-               vars: vars,
-               export_vars: export_vars,
-               lexical_tracker: lexical_tracker,
-               local: local}
-
-  def __struct__ do
-    %{__struct__: __MODULE__,
-      module: nil,
-      file: "nofile",
-      line: 0,
-      function: nil,
-      context: nil,
-      requires: [],
-      aliases: [],
-      functions: [],
-      macros: [],
-      macro_aliases: [],
-      context_modules: [],
-      vars: [],
-      export_vars: nil,
-      lexical_tracker: nil,
-      local: nil}
+  @type file :: binary
+  @type line :: non_neg_integer
+  @type name_arity :: {atom, arity}
+  @type variable :: {atom, atom | term}
+
+  @typep aliases :: [{module, module}]
+  @typep functions :: [{module, [name_arity]}]
+  @typep lexical_tracker :: pid | nil
+  @typep macro_aliases :: [{module, {term, module}}]
+  @typep macros :: [{module, [name_arity]}]
+  @typep requires :: [module]
+  @typep tracers :: [module]
+  @typep versioned_vars :: %{optional(variable) => var_version :: non_neg_integer}
+
+  @type define_import_opts :: [
+          trace: boolean(),
+          emit_warnings: boolean(),
+          info_callback: (atom() -> [{atom(), arity()}]),
+          only: :functions | :macros | [{atom(), arity()}],
+          except: [{atom(), arity()}],
+          warn: boolean()
+        ]
+
+  @type define_alias_opts :: [
+          trace: boolean(),
+          as: atom(),
+          warn: boolean()
+        ]
+
+  @type define_require_opts :: [
+          trace: boolean(),
+          as: atom(),
+          warn: boolean()
+        ]
+
+  @type expand_alias_opts :: [
+          trace: boolean()
+        ]
+
+  @type expand_import_opts :: [
+          allow_locals: boolean() | (-> function() | false),
+          check_deprecations: boolean(),
+          trace: boolean()
+        ]
+
+  @type expand_require_opts :: [
+          check_deprecations: boolean(),
+          trace: boolean()
+        ]
+
+  @type t :: %{
+          __struct__: __MODULE__,
+          aliases: aliases,
+          context: context,
+          context_modules: context_modules,
+          file: file,
+          function: name_arity | nil,
+          functions: functions,
+          lexical_tracker: lexical_tracker,
+          line: line,
+          macro_aliases: macro_aliases,
+          macros: macros,
+          module: module,
+          requires: requires,
+          tracers: tracers,
+          versioned_vars: versioned_vars
+        }
+
+  fields = [
+    aliases: [],
+    context: nil,
+    context_modules: [],
+    file: "nofile",
+    function: nil,
+    functions: [],
+    lexical_tracker: nil,
+    line: 0,
+    macro_aliases: [],
+    macros: [],
+    module: nil,
+    requires: [],
+    tracers: [],
+    versioned_vars: %{}
+  ]
+
+  # Define the __struct__ callbacks by hand for bootstrap reasons.
+  {_struct, [], escaped_struct, kv, body} =
+    Kernel.Utils.defstruct(__MODULE__, fields, false, __ENV__)
+
+  def __struct__(), do: unquote(escaped_struct)
+  def __struct__(unquote(kv)), do: unquote(body)
+
+  @doc """
+  Prunes compile information from the environment.
+
+  This happens when the environment is captured at compilation
+  time, for example, in the module body, and then used to
+  evaluate code after the module has been defined.
+  """
+  @doc since: "1.14.0"
+  @spec prune_compile_info(t) :: t
+  def prune_compile_info(env) do
+    %{env | lexical_tracker: nil, tracers: []}
+  end
+
+  @doc """
+  Returns a list of variables in the current environment.
+
+  Each variable is identified by a tuple of two elements,
+  where the first element is the variable name as an atom
+  and the second element is its context, which may be an
+  atom or an integer.
+  """
+  @doc since: "1.7.0"
+  @spec vars(t) :: [variable]
+  def vars(env)
+
+  def vars(%{__struct__: Macro.Env, versioned_vars: vars}) do
+    Map.keys(vars)
+  end
+
+  @doc """
+  Checks if a variable belongs to the environment.
+
+  ## Examples
+
+      iex> x = 13
+      iex> x
+      13
+      iex> Macro.Env.has_var?(__ENV__, {:x, nil})
+      true
+      iex> Macro.Env.has_var?(__ENV__, {:unknown, nil})
+      false
+
+  """
+  @doc since: "1.7.0"
+  @spec has_var?(t, variable) :: boolean()
+  def has_var?(env, var)
+
+  def has_var?(%{__struct__: Macro.Env, versioned_vars: vars}, var) do
+    Map.has_key?(vars, var)
   end
 
   @doc """
   Returns a keyword list containing the file and line
   information as keys.
   """
+  @spec location(t) :: keyword
+  def location(env)
+
   def location(%{__struct__: Macro.Env, file: file, line: line}) do
     [file: file, line: line]
   end
 
+  # TODO: Deprecate on Elixir 1.21 in favor of expand_alias/4
+  @doc false
+  def fetch_alias(%{__struct__: Macro.Env, aliases: aliases}, atom) when is_atom(atom),
+    do: Keyword.fetch(aliases, :"Elixir.#{atom}")
+
+  # TODO: Deprecate on Elixir 1.21 in favor of expand_alias/4
+  @doc false
+  def fetch_macro_alias(%{__struct__: Macro.Env, macro_aliases: aliases}, atom)
+      when is_atom(atom),
+      do: Keyword.fetch(aliases, :"Elixir.#{atom}")
+
+  @doc """
+  Returns the modules from which the given `{name, arity}` was
+  imported.
+
+  It returns a list of two element tuples in the shape of
+  `{:function | :macro, module}`. The elements in the list
+  are in no particular order and the order is not guaranteed.
+
+  > #### Use only for introspection {: .warning}
+  >
+  > This function does not emit compiler tracing events,
+  > which may block the compiler from correctly tracking
+  > dependencies. Use this function for reflection purposes
+  > but to do not use it to expand imports into qualified
+  > calls. Instead, use `expand_import/5`.
+
+  ## Examples
+
+      iex> Macro.Env.lookup_import(__ENV__, {:duplicate, 2})
+      []
+      iex> import Tuple, only: [duplicate: 2], warn: false
+      iex> Macro.Env.lookup_import(__ENV__, {:duplicate, 2})
+      [{:function, Tuple}]
+      iex> import List, only: [duplicate: 2], warn: false
+      iex> Macro.Env.lookup_import(__ENV__, {:duplicate, 2})
+      [{:function, List}, {:function, Tuple}]
+
+      iex> Macro.Env.lookup_import(__ENV__, {:def, 1})
+      [{:macro, Kernel}]
+
+  """
+  @doc since: "1.13.0"
+  @spec lookup_import(t, name_arity) :: [{:function | :macro, module}]
+  def lookup_import(env, name_arity)
+
+  def lookup_import(
+        %{__struct__: Macro.Env, functions: functions, macros: macros},
+        {name, arity} = pair
+      )
+      when is_atom(name) and is_integer(arity) do
+    f = for {mod, pairs} <- functions, :ordsets.is_element(pair, pairs), do: {:function, mod}
+    m = for {mod, pairs} <- macros, :ordsets.is_element(pair, pairs), do: {:macro, mod}
+    f ++ m
+  end
+
+  @doc """
+  Returns the names of any aliases for the given module or atom.
+
+  ## Examples
+
+      iex> alias Foo.Bar
+      iex> Bar
+      Foo.Bar
+      iex> Macro.Env.lookup_alias_as(__ENV__, Foo.Bar)
+      [Elixir.Bar]
+      iex> alias Foo.Bar, as: Baz
+      iex> Baz
+      Foo.Bar
+      iex> Macro.Env.lookup_alias_as(__ENV__, Foo.Bar)
+      [Elixir.Bar, Elixir.Baz]
+      iex> Macro.Env.lookup_alias_as(__ENV__, Unknown)
+      []
+
+  """
+  @doc since: "1.15.0"
+  @spec lookup_alias_as(t, atom) :: [atom]
+  def lookup_alias_as(env, atom)
+
+  def lookup_alias_as(%{__struct__: Macro.Env, aliases: aliases}, atom) when is_atom(atom) do
+    for {name, ^atom} <- aliases, do: name
+  end
+
+  @doc """
+  Returns `true` if the given module has been required.
+
+  ## Examples
+
+      iex> Macro.Env.required?(__ENV__, Integer)
+      false
+      iex> require Integer, warn: false
+      iex> Macro.Env.required?(__ENV__, Integer)
+      true
+
+      iex> Macro.Env.required?(__ENV__, Kernel)
+      true
+  """
+  @doc since: "1.13.0"
+  @spec required?(t, module) :: boolean
+  def required?(env, module)
+
+  def required?(%{__struct__: Macro.Env, requires: requires}, mod) when is_atom(mod),
+    do: mod in requires
+
+  @doc """
+  Prepend a tracer to the list of tracers in the environment.
+
+  ## Examples
+
+      Macro.Env.prepend_tracer(__ENV__, MyCustomTracer)
+
+  """
+  @doc since: "1.13.0"
+  @spec prepend_tracer(t, module) :: t
+  def prepend_tracer(%{__struct__: Macro.Env, tracers: tracers} = env, tracer) do
+    %{env | tracers: [tracer | tracers]}
+  end
+
+  trace_option = """
+  `:trace` - when set to `false`, it disables compilation tracers and
+  lexical tracker. This option must only be used by language servers and
+  other tools that need to introspect code without affecting how it is compiled.
+  Disabling tracer inside macros or regular code expansion is extremely
+  discouraged as it blocks the compiler from accurately tracking dependencies\
+  """
+
+  @doc """
+  Defines the given `module` as required in the environment.
+
+  It does not check or assert the module is available.
+  This is used by tools which need to mimic the Elixir compiler.
+  The appropriate `:require` compiler tracing event will be emitted.
+
+  ## Additional options
+
+  It accepts the same options as `Kernel.SpecialForm.require/2` plus:
+
+    * #{trace_option}
+
+  ## Examples
+
+      iex> env = __ENV__
+      iex> Macro.Env.required?(env, Integer)
+      false
+      iex> {:ok, env} = Macro.Env.define_require(env, [line: 10], Integer)
+      iex> Macro.Env.required?(env, Integer)
+      true
+
+  If the `:as` option is given, it will also define an alias:
+
+      iex> env = __ENV__
+      iex> {:ok, env} = Macro.Env.define_require(env, [line: 10], Foo.Bar, as: Baz)
+      iex> Macro.Env.expand_alias(env, [], [:Baz])
+      {:alias, Foo.Bar}
+
+  """
+  @doc since: "1.17.0"
+  @spec define_require(t, Macro.metadata(), module, define_require_opts) :: {:ok, t}
+  def define_require(env, meta, module, opts \\ [])
+      when is_list(meta) and is_atom(module) and is_list(opts) do
+    {trace, opts} = Keyword.pop(opts, :trace, true)
+    env = :elixir_aliases.require(meta, module, opts, env, trace)
+    result = :elixir_aliases.alias(meta, module, false, opts, env, trace)
+    maybe_define_error(result, :elixir_aliases)
+  end
+
+  @doc """
+  Defines the given `module` as imported in the environment.
+
+  It assumes `module` is available. This is used by tools which
+  need to mimic the Elixir compiler. The appropriate `:import`
+  compiler tracing event will be emitted.
+
+  ## Additional options
+
+  It accepts the same options as `Kernel.SpecialForm.import/2` plus:
+
+    * `:emit_warnings` - emit warnings found when defining imports
+
+    * #{trace_option}
+
+    * `:info_callback` - a function to use instead of `c:Module.__info__/1`.
+      The function will be invoked with `:functions` or `:macros` argument.
+      It has to return a list of `{function, arity}` key value pairs.
+      If it fails, it defaults to using module metadata based on `module_info/1`.
+
+  ## Examples
+
+      iex> env = __ENV__
+      iex> Macro.Env.lookup_import(env, {:flatten, 1})
+      []
+      iex> {:ok, env} = Macro.Env.define_import(env, [line: 10], List)
+      iex> Macro.Env.lookup_import(env, {:flatten, 1})
+      [{:function, List}]
+
+  It accepts the same options as `Kernel.SpecialForm.import/2`:
+
+      iex> env = __ENV__
+      iex> Macro.Env.lookup_import(env, {:is_odd, 1})
+      []
+      iex> {:ok, env} = Macro.Env.define_import(env, [line: 10], Integer, only: :macros)
+      iex> Macro.Env.lookup_import(env, {:is_odd, 1})
+      [{:macro, Integer}]
+
+  ## Info callback override
+
+      iex> env = __ENV__
+      iex> Macro.Env.lookup_import(env, {:flatten, 1})
+      []
+      iex> {:ok, env} = Macro.Env.define_import(env, [line: 10], SomeModule, [info_callback: fn :functions -> [{:flatten, 1}]; :macros -> [{:some, 2}]; end])
+      iex> Macro.Env.lookup_import(env, {:flatten, 1})
+      [{:function, SomeModule}]
+      iex> Macro.Env.lookup_import(env, {:some, 2})
+      [{:macro, SomeModule}]
+
+  """
+  @doc since: "1.17.0"
+  @spec define_import(t, Macro.metadata(), module, define_import_opts) ::
+          {:ok, t} | {:error, String.t()}
+  def define_import(env, meta, module, opts \\ [])
+      when is_list(meta) and is_atom(module) and is_list(opts) do
+    {trace, opts} = Keyword.pop(opts, :trace, true)
+    {warnings, opts} = Keyword.pop(opts, :emit_warnings, true)
+    {info_callback, opts} = Keyword.pop(opts, :info_callback, &module.__info__/1)
+
+    result = :elixir_import.import(meta, module, opts, env, warnings, trace, info_callback)
+    maybe_define_error(result, :elixir_import)
+  end
+
+  @doc """
+  Defines the given `as` an alias to `module` in the environment.
+
+  This is used by tools which need to mimic the Elixir compiler.
+  The appropriate `:alias` compiler tracing event will be emitted.
+
+  ## Additional options
+
+  It accepts the same options as `Kernel.SpecialForm.alias/2` plus:
+
+    * #{trace_option}
+
+  ## Examples
+
+      iex> env = __ENV__
+      iex> Macro.Env.expand_alias(env, [], [:Baz])
+      :error
+      iex> {:ok, env} = Macro.Env.define_alias(env, [line: 10], Foo.Bar, as: Baz)
+      iex> Macro.Env.expand_alias(env, [], [:Baz])
+      {:alias, Foo.Bar}
+      iex> Macro.Env.expand_alias(env, [], [:Baz, :Bat])
+      {:alias, Foo.Bar.Bat}
+
+  If no `:as` option is given, the alias will be inferred from the module:
+
+      iex> env = __ENV__
+      iex> {:ok, env} = Macro.Env.define_alias(env, [line: 10], Foo.Bar)
+      iex> Macro.Env.expand_alias(env, [], [:Bar])
+      {:alias, Foo.Bar}
+
+  If it is not possible to infer one, an error is returned:
+
+      iex> Macro.Env.define_alias(__ENV__, [line: 10], :an_atom)
+      {:error,
+       "alias cannot be inferred automatically for module: :an_atom, " <>
+         "please use the :as option. Implicit aliasing is only supported with Elixir modules"}
+
+  """
+  @doc since: "1.17.0"
+  @spec define_alias(t, Macro.metadata(), module, define_alias_opts) ::
+          {:ok, t} | {:error, String.t()}
+  def define_alias(env, meta, module, opts \\ [])
+      when is_list(meta) and is_atom(module) and is_list(opts) do
+    {trace, opts} = Keyword.pop(opts, :trace, true)
+    result = :elixir_aliases.alias(meta, module, true, opts, env, trace)
+    maybe_define_error(result, :elixir_aliases)
+  end
+
+  defp maybe_define_error({:ok, _info, env}, _mod),
+    do: {:ok, env}
+
+  defp maybe_define_error({:error, reason}, mod),
+    do: {:error, Kernel.to_string(mod.format_error(reason))}
+
+  @doc """
+  Expands an alias given by the alias segments.
+
+  It returns `{:alias, alias}` if the segments is a list
+  of atoms and an alias was found. Returns `:error` otherwise.
+
+  This expansion may emit the `:alias_expansion` trace event
+  but it does not emit the `:alias_reference` one.
+
+  ## Options
+
+    * #{trace_option}
+
+  ## Examples
+
+      iex> alias List, as: MyList
+      iex> Macro.Env.expand_alias(__ENV__, [], [:MyList])
+      {:alias, List}
+      iex> Macro.Env.expand_alias(__ENV__, [], [:MyList, :Nested])
+      {:alias, List.Nested}
+
+  If there is no alias or the alias starts with `Elixir.`
+  (which disables aliasing), then `:error` is returned:
+
+      iex> alias List, as: MyList
+      iex> Macro.Env.expand_alias(__ENV__, [], [:Elixir, MyList])
+      :error
+      iex> Macro.Env.expand_alias(__ENV__, [], [:AnotherList])
+      :error
+
+  """
+  @doc since: "1.17.0"
+  @spec expand_alias(t, keyword, [atom()], expand_alias_opts) ::
+          {:alias, atom()} | :error
+  def expand_alias(env, meta, list, opts \\ [])
+      when is_list(meta) and is_list(list) and is_list(opts) do
+    trace = Keyword.get(opts, :trace, true)
+
+    case :elixir_aliases.expand(meta, list, env, trace) do
+      atom when is_atom(atom) -> {:alias, atom}
+      [_ | _] -> :error
+    end
+  end
+
+  @doc """
+  Expands an import given by `name` and `arity`.
+
+  If the import points to a macro, it returns a tuple
+  with the module and a function that expands the macro.
+  The function expects the metadata to be attached to the
+  expansion and the arguments of the macro.
+
+  If the import points to a function, it returns a tuple
+  with the module and the function name.
+
+  If any import is found, the appropriate compiler tracing
+  event will be emitted.
+
+  Otherwise returns `{:error, reason}`.
+
+  ## Options
+
+    * `:allow_locals` - controls how local macros are resolved.
+      Defaults to `true`.
+
+      - When `false`, does not attempt to capture local macros defined in the
+        current module in `env`
+      - When `true`, uses a default resolver that looks for public macros in
+        the current module
+      - When a function, it will be invoked to lazily compute a local function
+        (or return false). It has signature `(-> function() | false)`
+
+    * `:check_deprecations` - when set to `false`, does not check for deprecations
+      when expanding macros
+
+    * #{trace_option}
+
+  """
+  @doc since: "1.17.0"
+  @spec expand_import(t, keyword, atom(), arity(), expand_import_opts) ::
+          {:macro, module(), (Macro.metadata(), args :: [Macro.t()] -> Macro.t())}
+          | {:function, module(), atom()}
+          | {:error, :not_found | {:conflict, module()} | {:ambiguous, [module()]}}
+  def expand_import(env, meta, name, arity, opts \\ [])
+      when is_list(meta) and is_atom(name) and is_integer(arity) and is_list(opts) do
+    case :elixir_import.special_form(name, arity) do
+      true ->
+        {:error, :not_found}
+
+      false ->
+        allow_locals = Keyword.get(opts, :allow_locals, true)
+        trace = Keyword.get(opts, :trace, true)
+        module = env.module
+
+        # When allow_locals is a callback, we don't need to pass module macros as extra
+        # because the callback will handle local macro resolution
+        extra =
+          if is_function(allow_locals, 0) do
+            []
+          else
+            case allow_locals and function_exported?(module, :__info__, 1) do
+              true -> [{module, module.__info__(:macros)}]
+              false -> []
+            end
+          end
+
+        case :elixir_dispatch.expand_import(meta, name, arity, env, extra, allow_locals, trace) do
+          {:macro, receiver, expander} ->
+            {:macro, receiver, wrap_expansion(receiver, expander, meta, name, arity, env, opts)}
+
+          {:function, receiver, name} ->
+            {:function, receiver, name}
+
+          error ->
+            {:error, error}
+        end
+    end
+  end
+
+  @doc """
+  Expands a require given by `module`, `name`, and `arity`.
+
+  If the require points to a macro and the module has been
+  required, it returns a tuple with the module and a function
+  that expands the macro. The function expects the metadata
+  to be attached to the expansion and the arguments of the macro.
+  The appropriate `:remote_macro` compiler tracing event will
+  be emitted if a macro is found (note a `:remote_function`
+  event is not emitted in `:error` cases).
+
+  Otherwise returns `:error`.
+
+  ## Options
+
+    * `:check_deprecations` - when set to `false`, does not check for deprecations
+      when expanding macros
+
+    * #{trace_option}
+
+  """
+  @doc since: "1.17.0"
+  @spec expand_require(t, keyword, module(), atom(), arity(), expand_require_opts) ::
+          {:macro, module(), (Macro.metadata(), args :: [Macro.t()] -> Macro.t())}
+          | :error
+  def expand_require(env, meta, module, name, arity, opts \\ [])
+      when is_list(meta) and is_atom(module) and is_atom(name) and is_integer(arity) and
+             is_list(opts) do
+    trace = Keyword.get(opts, :trace, true)
+
+    case :elixir_dispatch.expand_require(meta, module, name, arity, env, trace) do
+      {:macro, receiver, expander} ->
+        {:macro, receiver, wrap_expansion(receiver, expander, meta, name, arity, env, opts)}
+
+      :error ->
+        :error
+    end
+  end
+
+  defp wrap_expansion(receiver, expander, meta, name, arity, env, opts) do
+    fn expansion_meta, args ->
+      if Keyword.get(opts, :check_deprecations, true) do
+        :elixir_dispatch.check_deprecated(:macro, meta, receiver, name, arity, env)
+      end
+
+      quoted = expander.(:elixir_dispatch.stop_generated(args), env)
+      next = :elixir_module.next_counter(env.module)
+      :elixir_quote.linify_with_context_counter(expansion_meta, {receiver, next}, quoted)
+    end
+  end
+
+  @doc """
+  Returns an environment in the guard context.
+  """
+  @doc since: "1.17.0"
+  @spec to_guard(t) :: t
+  def to_guard(%{__struct__: Macro.Env} = env) do
+    %{env | context: :guard}
+  end
+
+  @doc """
+  Returns an environment in the match context.
+  """
+  @spec to_match(t) :: t
+  def to_match(%{__struct__: Macro.Env} = env) do
+    %{env | context: :match}
+  end
+
   @doc """
   Returns whether the compilation environment is currently
   inside a guard.
   """
+  @spec in_guard?(t) :: boolean
+  def in_guard?(env)
   def in_guard?(%{__struct__: Macro.Env, context: context}), do: context == :guard
 
   @doc """
   Returns whether the compilation environment is currently
   inside a match clause.
   """
+  @spec in_match?(t) :: boolean
+  def in_match?(env)
   def in_match?(%{__struct__: Macro.Env, context: context}), do: context == :match
 
   @doc """
   Returns the environment stacktrace.
   """
+  @spec stacktrace(t) :: list
   def stacktrace(%{__struct__: Macro.Env} = env) do
     cond do
-      nil?(env.module) ->
+      is_nil(env.module) ->
         [{:elixir_compiler, :__FILE__, 1, relative_location(env)}]
-      nil?(env.function) ->
+
+      is_nil(env.function) ->
         [{env.module, :__MODULE__, 0, relative_location(env)}]
+
       true ->
         {name, arity} = env.function
         [{env.module, name, arity, relative_location(env)}]
@@ -116,6 +715,6 @@ defmodule Macro.Env do
   end
 
   defp relative_location(env) do
-    [file: Path.relative_to_cwd(env.file), line: env.line]
+    [file: String.to_charlist(Path.relative_to_cwd(env.file)), line: env.line]
   end
 end
diff --git a/lib/elixir/lib/map.ex b/lib/elixir/lib/map.ex
index d93e88f194b..31c7d7adc15 100644
--- a/lib/elixir/lib/map.ex
+++ b/lib/elixir/lib/map.ex
@@ -1,42 +1,1203 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Map do
   @moduledoc """
-  A Dict implementation that works on maps.
+  Maps are the "go to" key-value data structure in Elixir.
+
+  Maps can be created with the `%{}` syntax, and key-value pairs can be
+  expressed as `key => value`:
+
+      iex> %{}
+      %{}
+      iex> %{"one" => :two, 3 => "four"}
+      %{3 => "four", "one" => :two}
+
+  Key-value pairs in a map do not follow any order (that's why the printed map
+  in the example above has a different order than the map that was created).
+
+  Maps do not impose any restriction on the key type: anything can be a key in a
+  map. As a key-value structure, maps do not allow duplicate keys. Keys are
+  compared using the exact-equality operator (`===/2`). If colliding keys are defined
+  in a map literal, the last one prevails.
+
+  When the key in a key-value pair is an atom, the `key: value` shorthand syntax
+  can be used (as in many other special forms):
+
+      iex> %{a: 1, b: 2}
+      %{a: 1, b: 2}
+
+  If you want to mix the shorthand syntax with `=>`, the shorthand syntax must come
+  at the end:
+
+      iex> %{"hello" => "world", a: 1, b: 2}
+      %{:a => 1, :b => 2, "hello" => "world"}
+
+  Keys in maps can be accessed through some of the functions in this module
+  (such as `Map.get/3` or `Map.fetch/2`) or through the `map[]` syntax provided
+  by the `Access` module:
+
+      iex> map = %{a: 1, b: 2}
+      iex> Map.fetch(map, :a)
+      {:ok, 1}
+      iex> map[:b]
+      2
+      iex> map["non_existing_key"]
+      nil
+
+  To access atom keys, one may also use the `map.key` notation. Note that `map.key`
+  will raise a `KeyError` if the `map` doesn't contain the key `:key`, compared to
+  `map[:key]`, that would return `nil`.
+
+      map = %{foo: "bar", baz: "bong"}
+      map.foo
+      #=> "bar"
+      map.non_existing_key
+      ** (KeyError) key :non_existing_key not found in:
+      ...
+
+  > #### Avoid parentheses {: .warning}
+  >
+  > Do not add parentheses when accessing fields, such as in `data.key()`.
+  > If parentheses are used, Elixir will expect `data` to be an atom representing
+  > a module and attempt to call the *function* `key/0` in it.
+
+  The two syntaxes for accessing keys reveal the dual nature of maps. The `map[key]`
+  syntax is used for dynamically created maps that may have any key, of any type.
+  `map.key` is used with maps that hold a predetermined set of atoms keys, which are
+  expected to always be present. Structs, defined via `defstruct/1`, are one example
+  of such "static maps", where the keys can also be checked during compile time.
+
+  Maps can be pattern matched on. When a map is on the left-hand side of a
+  pattern match, it will match if the map on the right-hand side contains the
+  keys on the left-hand side and their values match the ones on the left-hand
+  side. This means that an empty map matches every map.
+
+      iex> %{} = %{foo: "bar"}
+      %{foo: "bar"}
+      iex> %{a: a} = %{:a => 1, "b" => 2, [:c, :e, :e] => 3}
+      iex> a
+      1
+
+  But this will raise a `MatchError` exception:
+
+      %{:c => 3} = %{:a => 1, 2 => :b}
+
+  Variables can be used as map keys both when writing map literals as well as
+  when matching:
+
+      iex> n = 1
+      1
+      iex> %{n => :one}
+      %{1 => :one}
+      iex> %{^n => :one} = %{1 => :one, 2 => :two, 3 => :three}
+      %{1 => :one, 2 => :two, 3 => :three}
+
+  Maps also support a specific update syntax to update the value stored under
+  *existing* keys. You can update using the atom keys syntax:
+
+      iex> map = %{one: 1, two: 2}
+      iex> %{map | one: "one"}
+      %{one: "one", two: 2}
+
+  Or any other keys:
+
+      iex> other_map = %{"three" => 3, "four" => 4, "five" => 5}
+      iex> %{other_map | "three" => "three", "four" => "four"}
+      %{"five" => 5, "four" => "four", "three" => "three"}
+
+  When a key that does not exist in the map is updated a `KeyError` exception will be raised:
 
-  Maps are key-value stores where keys are compared using
-  the match operator (`===`). Maps can be created with
-  the `%{}` special form defined in the `Kernel.SpecialForms`
-  module.
+      %{map | three: 3}
+
+  The functions in this module that need to find a specific key work in logarithmic time.
+  This means that the time it takes to find keys grows as the map grows, but it's not
+  directly proportional to the map size. In comparison to finding an element in a list,
+  it performs better because lists have a linear time complexity. Some functions,
+  such as `keys/1` and `values/1`, run in linear time because they need to get to every
+  element in the map.
+
+  Maps also implement the `Enumerable` protocol, so many functions to work with maps
+  are found in the `Enum` module. Additionally, the following functions for maps are
+  found in `Kernel`:
+
+    * `map_size/1`
+
+  """
+
+  @type key :: any
+  @type value :: any
+  @compile {:inline, fetch: 2, fetch!: 2, get: 2, put: 3, delete: 2, has_key?: 2, replace!: 3}
+
+  @doc """
+  Builds a map from the given `keys` and the fixed `value`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Map.from_keys([1, 2, 3], :number)
+      %{1 => :number, 2 => :number, 3 => :number}
+
+  """
+  @doc since: "1.14.0"
+  @spec from_keys([key], value) :: map
+  defdelegate from_keys(keys, value), to: :maps
+
+  @doc """
+  Returns all keys from `map`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      Map.keys(%{a: 1, b: 2})
+      [:a, :b]
 
-  For more information about the functions in this module and
-  their APIs, please consult the `Dict` module.
   """
+  @spec keys(map) :: [key]
+  defdelegate keys(map), to: :maps
+
+  @doc """
+  Returns all values from `map`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      Map.values(%{a: 1, b: 2})
+      [1, 2]
+
+  """
+  @spec values(map) :: [value]
+  defdelegate values(map), to: :maps
+
+  @doc """
+  Converts `map` to a list.
+
+  Each key-value pair in the map is converted to a two-element tuple `{key,
+  value}` in the resulting list.
 
-  use Dict
+  Inlined by the compiler.
 
-  defdelegate [keys(map), values(map), size(map), merge(map1, map2), to_list(map)], to: :maps
+  ## Examples
 
-  @compile {:inline, fetch: 2, put: 3, delete: 2, has_key?: 2}
+      iex> Map.to_list(%{a: 1})
+      [a: 1]
+      iex> Map.to_list(%{1 => 2})
+      [{1, 2}]
+
+  """
+  @spec to_list(map) :: [{term, term}]
+  defdelegate to_list(map), to: :maps
 
   @doc """
   Returns a new empty map.
+
+  ## Examples
+
+      iex> Map.new()
+      %{}
+
   """
+  @spec new :: map
   def new, do: %{}
 
+  @doc """
+  Creates a map from an `enumerable`.
+
+  Duplicated keys are removed; the latest one prevails.
+
+  ## Examples
+
+      iex> Map.new([{:b, 1}, {:a, 2}])
+      %{a: 2, b: 1}
+      iex> Map.new(a: 1, a: 2, a: 3)
+      %{a: 3}
+
+  """
+  @spec new(Enumerable.t()) :: map
+  def new(enumerable)
+  def new(list) when is_list(list), do: :maps.from_list(list)
+  def new(%_{} = struct), do: new_from_enum(struct)
+  def new(%{} = map), do: map
+  def new(enum), do: new_from_enum(enum)
+
+  defp new_from_enum(enumerable) do
+    enumerable
+    |> Enum.to_list()
+    |> :maps.from_list()
+  end
+
+  @doc """
+  Creates a map from an `enumerable` via the given transformation function.
+
+  Duplicated keys are removed; the latest one prevails.
+
+  ## Examples
+
+      iex> Map.new([:a, :b], fn x -> {x, x} end)
+      %{a: :a, b: :b}
+
+      iex> Map.new(%{a: 2, b: 3, c: 4}, fn {key, val} -> {key, val * 2} end)
+      %{a: 4, b: 6, c: 8}
+
+  """
+  @spec new(Enumerable.t(), (term -> {key, value})) :: map
+  def new(enumerable, transform)
+  def new(%_{} = enumerable, transform), do: new_from_enum(enumerable, transform)
+  def new(%{} = map, transform), do: new_from_map(map, transform)
+  def new(enumerable, transform), do: new_from_enum(enumerable, transform)
+
+  defp new_from_map(map, transform) when is_function(transform, 1) do
+    iter = :maps.iterator(map)
+    next = :maps.next(iter)
+    :maps.from_list(do_map(next, transform))
+  end
+
+  defp do_map(:none, _fun), do: []
+
+  defp do_map({key, value, iter}, transform) do
+    [transform.({key, value}) | do_map(:maps.next(iter), transform)]
+  end
+
+  defp new_from_enum(enumerable, transform) when is_function(transform, 1) do
+    enumerable
+    |> Enum.map(transform)
+    |> :maps.from_list()
+  end
+
+  @doc """
+  Returns whether the given `key` exists in the given `map`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Map.has_key?(%{a: 1}, :a)
+      true
+      iex> Map.has_key?(%{a: 1}, :b)
+      false
+
+  """
+  @spec has_key?(map, key) :: boolean
   def has_key?(map, key), do: :maps.is_key(key, map)
 
+  @doc """
+  Fetches the value for a specific `key` in the given `map`.
+
+  If `map` contains the given `key` then its value is returned in the shape of `{:ok, value}`.
+  If `map` doesn't contain `key`, `:error` is returned.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Map.fetch(%{a: 1}, :a)
+      {:ok, 1}
+      iex> Map.fetch(%{a: 1}, :b)
+      :error
+
+  """
+  @spec fetch(map, key) :: {:ok, value} | :error
   def fetch(map, key), do: :maps.find(key, map)
 
-  def put(map, key, val) do
-    :maps.put(key, val, map)
+  @doc """
+  Fetches the value for a specific `key` in the given `map`, erroring out if
+  `map` doesn't contain `key`.
+
+  If `map` contains `key`, the corresponding value is returned. If
+  `map` doesn't contain `key`, a `KeyError` exception is raised.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Map.fetch!(%{a: 1}, :a)
+      1
+
+  When the key is missing, an exception is raised:
+      
+      Map.fetch!(%{a: 1}, :b)
+      ** (KeyError) key :b not found in: %{a: 1}
+
+  """
+  @spec fetch!(map, key) :: value
+  def fetch!(map, key) do
+    :maps.get(key, map)
   end
 
+  @doc """
+  Puts the given `value` under `key` unless the entry `key`
+  already exists in `map`.
+
+  ## Examples
+
+      iex> Map.put_new(%{a: 1}, :b, 2)
+      %{a: 1, b: 2}
+      iex> Map.put_new(%{a: 1, b: 2}, :a, 3)
+      %{a: 1, b: 2}
+
+  """
+  @spec put_new(map, key, value) :: map
+  def put_new(map, key, value) do
+    case map do
+      %{^key => _value} ->
+        map
+
+      %{} ->
+        put(map, key, value)
+
+      other ->
+        :erlang.error({:badmap, other})
+    end
+  end
+
+  @doc """
+  Puts a value under `key` only if the `key` already exists in `map`.
+
+  ## Examples
+
+      iex> Map.replace(%{a: 1, b: 2}, :a, 3)
+      %{a: 3, b: 2}
+
+      iex> Map.replace(%{a: 1}, :b, 2)
+      %{a: 1}
+
+  """
+  @doc since: "1.11.0"
+  @spec replace(map, key, value) :: map
+  def replace(map, key, value) do
+    case map do
+      %{^key => _value} ->
+        %{map | key => value}
+
+      %{} ->
+        map
+
+      other ->
+        :erlang.error({:badmap, other})
+    end
+  end
+
+  @doc """
+  Puts a value under `key` only if the `key` already exists in `map`.
+
+  If `key` is not present in `map`, a `KeyError` exception is raised.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Map.replace!(%{a: 1, b: 2}, :a, 3)
+      %{a: 3, b: 2}
+
+      iex> Map.replace!(%{a: 1}, :b, 2)
+      ** (KeyError) key :b not found in:
+      ...
+
+  """
+  @doc since: "1.5.0"
+  @spec replace!(map, key, value) :: map
+  def replace!(map, key, value) do
+    :maps.update(key, value, map)
+  end
+
+  @doc """
+  Replaces the value under `key` using the given function only if
+  `key` already exists in `map`.
+
+  In comparison to `replace/3`, this can be useful when it's expensive to calculate the value.
+
+  If `key` does not exist, the original map is returned unchanged.
+
+  ## Examples
+
+      iex> Map.replace_lazy(%{a: 1, b: 2}, :a, fn v -> v * 4 end)
+      %{a: 4, b: 2}
+
+      iex> Map.replace_lazy(%{a: 1, b: 2}, :c, fn v -> v * 4 end)
+      %{a: 1, b: 2}
+
+  """
+  @doc since: "1.14.0"
+  @spec replace_lazy(map, key, (existing_value :: value -> new_value :: value)) :: map
+  def replace_lazy(map, key, fun) when is_map(map) and is_function(fun, 1) do
+    case map do
+      %{^key => val} -> %{map | key => fun.(val)}
+      %{} -> map
+    end
+  end
+
+  @doc """
+  Evaluates `fun` and puts the result under `key`
+  in `map` unless `key` is already present.
+
+  This function is useful in case you want to compute the value to put under
+  `key` only if `key` is not already present, as for example, when the value is expensive to
+  calculate or generally difficult to setup and teardown again.
+
+  ## Examples
+
+      iex> map = %{a: 1}
+      iex> fun = fn ->
+      ...>   # some expensive operation here
+      ...>   3
+      ...> end
+      iex> Map.put_new_lazy(map, :a, fun)
+      %{a: 1}
+      iex> Map.put_new_lazy(map, :b, fun)
+      %{a: 1, b: 3}
+
+  """
+  @spec put_new_lazy(map, key, (-> value)) :: map
+  def put_new_lazy(map, key, fun) when is_function(fun, 0) do
+    case map do
+      %{^key => _value} ->
+        map
+
+      %{} ->
+        put(map, key, fun.())
+
+      other ->
+        :erlang.error({:badmap, other})
+    end
+  end
+
+  @doc """
+  Returns a new map with all the key-value pairs in `map` where the key
+  is in `keys`.
+
+  If `keys` contains keys that are not in `map`, they're simply ignored.
+
+  ## Examples
+
+      iex> Map.take(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
+      %{a: 1, c: 3}
+
+  """
+  @spec take(map, [key]) :: map
+  def take(map, keys)
+
+  def take(map, keys) when is_map(map) and is_list(keys) do
+    take(keys, map, _acc = [])
+  end
+
+  def take(map, keys) when is_map(map) do
+    IO.warn(
+      "Map.take/2 with an Enumerable of keys that is not a list is deprecated. " <>
+        " Use a list of keys instead."
+    )
+
+    take(map, Enum.to_list(keys))
+  end
+
+  def take(non_map, _keys) do
+    :erlang.error({:badmap, non_map})
+  end
+
+  defp take([], _map, acc) do
+    :maps.from_list(acc)
+  end
+
+  defp take([key | rest], map, acc) do
+    acc =
+      case map do
+        %{^key => value} -> [{key, value} | acc]
+        %{} -> acc
+      end
+
+    take(rest, map, acc)
+  end
+
+  @doc """
+  Gets the value for a specific `key` in `map`.
+
+  If `key` is present in `map` then its value `value` is
+  returned. Otherwise, `default` is returned.
+
+  If `default` is not provided, `nil` is used.
+
+  ## Examples
+
+      iex> Map.get(%{}, :a)
+      nil
+      iex> Map.get(%{a: 1}, :a)
+      1
+      iex> Map.get(%{a: 1}, :b)
+      nil
+      iex> Map.get(%{a: 1}, :b, 3)
+      3
+      iex> Map.get(%{a: nil}, :a, 1)
+      nil
+
+  """
+  @spec get(map, key, value) :: value
+  def get(map, key, default \\ nil) do
+    case map do
+      %{^key => value} ->
+        value
+
+      %{} ->
+        default
+
+      other ->
+        :erlang.error({:badmap, other}, [map, key, default])
+    end
+  end
+
+  @doc """
+  Gets the value for a specific `key` in `map`.
+
+  If `key` is present in `map` then its value `value` is
+  returned. Otherwise, `fun` is evaluated and its result is returned.
+
+  This is useful if the default value is very expensive to calculate or
+  generally difficult to setup and teardown again.
+
+  ## Examples
+
+      iex> map = %{a: 1}
+      iex> fun = fn ->
+      ...>   # some expensive operation here
+      ...>   13
+      ...> end
+      iex> Map.get_lazy(map, :a, fun)
+      1
+      iex> Map.get_lazy(map, :b, fun)
+      13
+
+  """
+  @spec get_lazy(map, key, (-> value)) :: value
+  def get_lazy(map, key, fun) when is_function(fun, 0) do
+    case map do
+      %{^key => value} ->
+        value
+
+      %{} ->
+        fun.()
+
+      other ->
+        :erlang.error({:badmap, other}, [map, key, fun])
+    end
+  end
+
+  @doc """
+  Puts the given `value` under `key` in `map`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Map.put(%{a: 1}, :b, 2)
+      %{a: 1, b: 2}
+      iex> Map.put(%{a: 1, b: 2}, :a, 3)
+      %{a: 3, b: 2}
+
+  """
+  @spec put(map, key, value) :: map
+  def put(map, key, value) do
+    :maps.put(key, value, map)
+  end
+
+  @doc """
+  Deletes the entry in `map` for a specific `key`.
+
+  If the `key` does not exist, returns `map` unchanged.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Map.delete(%{a: 1, b: 2}, :a)
+      %{b: 2}
+      iex> Map.delete(%{b: 2}, :a)
+      %{b: 2}
+
+  """
+  @spec delete(map, key) :: map
   def delete(map, key), do: :maps.remove(key, map)
 
-  def merge(map1, map2, callback) do
-    :maps.fold fn k, v2, acc ->
-      update(acc, k, v2, fn(v1) -> callback.(k, v1, v2) end)
-    end, map1, map2
+  @doc """
+  Merges two maps into one.
+
+  All keys in `map2` will be added to `map1`, overriding any existing one
+  (i.e., the keys in `map2` "have precedence" over the ones in `map1`).
+
+  If you have a struct and you would like to merge a set of keys into the
+  struct, do not use this function, as it would merge all keys on the right
+  side into the struct, even if the key is not part of the struct. Instead,
+  use `struct/2`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4})
+      %{a: 3, b: 2, d: 4}
+
+  """
+  @spec merge(map, map) :: map
+  defdelegate merge(map1, map2), to: :maps
+
+  @doc """
+  Merges two maps into one, resolving conflicts through the given `fun`.
+
+  All keys in `map2` will be added to `map1`. The given function will be invoked
+  when there are duplicate keys; its arguments are `key` (the duplicate key),
+  `value1` (the value of `key` in `map1`), and `value2` (the value of `key` in
+  `map2`). The value returned by `fun` is used as the value under `key` in
+  the resulting map.
+
+  ## Examples
+
+      iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4}, fn _k, v1, v2 ->
+      ...>   v1 + v2
+      ...> end)
+      %{a: 4, b: 2, d: 4}
+
+  """
+  @spec merge(map, map, (key, value, value -> value)) :: map
+  def merge(map1, map2, fun) when is_function(fun, 3) do
+    :maps.merge_with(fun, map1, map2)
+  end
+
+  @doc """
+  Updates the `key` in `map` with the given function.
+
+  If `key` is present in `map` then the existing value is passed to `fun` and its result is
+  used as the updated value of `key`. If `key` is
+  not present in `map`, `default` is inserted as the value of `key`. The default
+  value will not be passed through the update function.
+
+  ## Examples
+
+      iex> Map.update(%{a: 1}, :a, 13, fn existing_value -> existing_value * 2 end)
+      %{a: 2}
+      iex> Map.update(%{a: 1}, :b, 11, fn existing_value -> existing_value * 2 end)
+      %{a: 1, b: 11}
+
+  """
+  @spec update(map, key, default :: value, (existing_value :: value -> new_value :: value)) ::
+          map
+  def update(map, key, default, fun) when is_function(fun, 1) do
+    case map do
+      %{^key => value} ->
+        %{map | key => fun.(value)}
+
+      %{} ->
+        put(map, key, default)
+
+      other ->
+        :erlang.error({:badmap, other}, [map, key, default, fun])
+    end
+  end
+
+  @doc """
+  Removes the value associated with `key` in `map` and returns the value and the updated map.
+
+  If `key` is present in `map`, it returns `{value, updated_map}` where `value` is the value of
+  the key and `updated_map` is the result of removing `key` from `map`. If `key`
+  is not present in `map`, `{default, map}` is returned.
+
+  ## Examples
+
+      iex> Map.pop(%{a: 1}, :a)
+      {1, %{}}
+      iex> Map.pop(%{a: 1}, :b)
+      {nil, %{a: 1}}
+      iex> Map.pop(%{a: 1}, :b, 3)
+      {3, %{a: 1}}
+
+  """
+  @spec pop(map, key, default) :: {value, updated_map :: map} | {default, map} when default: value
+  def pop(map, key, default \\ nil) do
+    case :maps.take(key, map) do
+      {_, _} = tuple -> tuple
+      :error -> {default, map}
+    end
+  end
+
+  @doc """
+  Removes and returns the value associated with `key` in `map` alongside
+  the updated map, or raises if `key` is not present.
+
+  Behaves the same as `pop/3` but raises a `KeyError` exception if `key` is not present in `map`.
+
+  ## Examples
+
+      iex> Map.pop!(%{a: 1}, :a)
+      {1, %{}}
+      iex> Map.pop!(%{a: 1, b: 2}, :a)
+      {1, %{b: 2}}
+      iex> Map.pop!(%{a: 1}, :b)
+      ** (KeyError) key :b not found in:
+      ...
+
+  """
+  @doc since: "1.10.0"
+  @spec pop!(map, key) :: {value, updated_map :: map}
+  def pop!(map, key) do
+    case :maps.take(key, map) do
+      {_, _} = tuple -> tuple
+      :error -> raise KeyError, key: key, term: map
+    end
+  end
+
+  @doc """
+  Lazily returns and removes the value associated with `key` in `map`.
+
+  If `key` is present in `map`, it returns `{value, new_map}` where `value` is the value of
+  the key and `new_map` is the result of removing `key` from `map`. If `key`
+  is not present in `map`, `{fun_result, map}` is returned, where `fun_result`
+  is the result of applying `fun`.
+
+  This is useful if the default value is very expensive to calculate or
+  generally difficult to setup and teardown again.
+
+  ## Examples
+
+      iex> map = %{a: 1}
+      iex> fun = fn ->
+      ...>   # some expensive operation here
+      ...>   13
+      ...> end
+      iex> Map.pop_lazy(map, :a, fun)
+      {1, %{}}
+      iex> Map.pop_lazy(map, :b, fun)
+      {13, %{a: 1}}
+
+  """
+  @spec pop_lazy(map, key, (-> value)) :: {value, map}
+  def pop_lazy(map, key, fun) when is_function(fun, 0) do
+    case :maps.take(key, map) do
+      {_, _} = tuple -> tuple
+      :error -> {fun.(), map}
+    end
+  end
+
+  @doc """
+  Drops the given `keys` from `map`.
+
+  If `keys` contains keys that are not in `map`, they're simply ignored.
+
+  ## Examples
+
+      iex> Map.drop(%{a: 1, b: 2, c: 3}, [:b, :d])
+      %{a: 1, c: 3}
+
+  """
+  @spec drop(map, [key]) :: map
+  def drop(map, keys)
+
+  def drop(map, keys) when is_map(map) and is_list(keys) do
+    drop_keys(keys, map)
+  end
+
+  def drop(map, keys) when is_map(map) do
+    IO.warn(
+      "Map.drop/2 with an Enumerable of keys that is not a list is deprecated. " <>
+        " Use a list of keys instead."
+    )
+
+    drop(map, Enum.to_list(keys))
+  end
+
+  def drop(non_map, keys) do
+    :erlang.error({:badmap, non_map}, [non_map, keys])
+  end
+
+  defp drop_keys([], acc), do: acc
+
+  defp drop_keys([key | rest], acc) do
+    drop_keys(rest, delete(acc, key))
+  end
+
+  @doc """
+  Takes all entries corresponding to the given `keys` in `map` and extracts
+  them into a separate map.
+
+  Returns a tuple with the new map and the old map with removed keys.
+
+  Keys for which there are no entries in `map` are ignored.
+
+  ## Examples
+
+      iex> Map.split(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
+      {%{a: 1, c: 3}, %{b: 2}}
+
+  """
+  @spec split(map, [key]) :: {map, map}
+  def split(map, keys)
+
+  def split(map, keys) when is_map(map) and is_list(keys) do
+    split(keys, [], map)
+  end
+
+  def split(map, keys) when is_map(map) do
+    IO.warn(
+      "Map.split/2 with an Enumerable of keys that is not a list is deprecated. " <>
+        " Use a list of keys instead."
+    )
+
+    split(map, Enum.to_list(keys))
+  end
+
+  def split(non_map, keys) do
+    :erlang.error({:badmap, non_map}, [non_map, keys])
+  end
+
+  defp split([], included, excluded) do
+    {:maps.from_list(included), excluded}
+  end
+
+  defp split([key | rest], included, excluded) do
+    case excluded do
+      %{^key => value} ->
+        split(rest, [{key, value} | included], delete(excluded, key))
+
+      _other ->
+        split(rest, included, excluded)
+    end
+  end
+
+  @doc """
+  Splits the `map` into two maps according to the given function `fun`.
+
+  `fun` receives each `{key, value}` pair in the `map` as its only argument. Returns
+  a tuple with the first map containing all the elements in `map` for which
+  applying `fun` returned a truthy value, and a second map with all the elements
+  for which applying `fun` returned a falsy value (`false` or `nil`).
+
+  ## Examples
+
+      iex> Map.split_with(%{a: 1, b: 2, c: 3, d: 4}, fn {_k, v} -> rem(v, 2) == 0 end)
+      {%{b: 2, d: 4}, %{a: 1, c: 3}}
+
+      iex> Map.split_with(%{a: 1, b: -2, c: 1, d: -3}, fn {k, _v} -> k in [:b, :d] end)
+      {%{b: -2, d: -3}, %{a: 1, c: 1}}
+
+      iex> Map.split_with(%{a: 1, b: -2, c: 1, d: -3}, fn {_k, v} -> v > 50 end)
+      {%{}, %{a: 1, b: -2, c: 1, d: -3}}
+
+      iex> Map.split_with(%{}, fn {_k, v} -> v > 50 end)
+      {%{}, %{}}
+
+  """
+  @doc since: "1.15.0"
+  @spec split_with(map, ({key, value} -> as_boolean(term))) :: {map, map}
+  def split_with(map, fun) when is_map(map) and is_function(fun, 1) do
+    iter = :maps.iterator(map)
+    next = :maps.next(iter)
+
+    do_split_with(next, [], [], fun)
+  end
+
+  defp do_split_with(:none, while_true, while_false, _fun) do
+    {:maps.from_list(while_true), :maps.from_list(while_false)}
   end
 
+  defp do_split_with({key, value, iter}, while_true, while_false, fun) do
+    if fun.({key, value}) do
+      do_split_with(:maps.next(iter), [{key, value} | while_true], while_false, fun)
+    else
+      do_split_with(:maps.next(iter), while_true, [{key, value} | while_false], fun)
+    end
+  end
+
+  @doc """
+  Updates `key` with the given function.
+
+  If `key` is present in `map` then the existing value is passed to `fun` and its result is
+  used as the updated value of `key`. If `key` is
+  not present in `map`, a `KeyError` exception is raised.
+
+  ## Examples
+
+      iex> Map.update!(%{a: 1}, :a, &(&1 * 2))
+      %{a: 2}
+
+      iex> Map.update!(%{a: 1}, :b, &(&1 * 2))
+      ** (KeyError) key :b not found in:
+      ...
+
+  """
+  @spec update!(map, key, (existing_value :: value -> new_value :: value)) :: map
+  def update!(map, key, fun) when is_function(fun, 1) do
+    value = fetch!(map, key)
+    %{map | key => fun.(value)}
+  end
+
+  @doc """
+  Gets the value from `key` and updates it, all in one pass.
+
+  `fun` is called with the current value under `key` in `map` (or `nil` if `key`
+  is not present in `map`) and must return a two-element tuple: the current value
+  (the retrieved value, which can be operated on before being returned) and the
+  new value to be stored under `key` in the resulting new map. `fun` may also
+  return `:pop`, which means the current value shall be removed from `map` and
+  returned (making this function behave like `Map.pop(map, key)`).
+
+  The returned value is a two-element tuple with the current value returned by
+  `fun` and a new map with the updated value under `key`.
+
+  ## Examples
+
+      iex> Map.get_and_update(%{a: 1}, :a, fn current_value ->
+      ...>   {current_value, "new value!"}
+      ...> end)
+      {1, %{a: "new value!"}}
+
+      iex> Map.get_and_update(%{a: 1}, :b, fn current_value ->
+      ...>   {current_value, "new value!"}
+      ...> end)
+      {nil, %{a: 1, b: "new value!"}}
+
+      iex> Map.get_and_update(%{a: 1}, :a, fn _ -> :pop end)
+      {1, %{}}
+
+      iex> Map.get_and_update(%{a: 1}, :b, fn _ -> :pop end)
+      {nil, %{a: 1}}
+
+  """
+  @spec get_and_update(map, key, (value | nil -> {current_value, new_value :: value} | :pop)) ::
+          {current_value, new_map :: map}
+        when current_value: value
+  def get_and_update(map, key, fun) when is_function(fun, 1) do
+    current = get(map, key)
+
+    case fun.(current) do
+      {get, update} ->
+        {get, put(map, key, update)}
+
+      :pop ->
+        {current, delete(map, key)}
+
+      other ->
+        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+    end
+  end
+
+  @doc """
+  Gets the value from `key` and updates it, all in one pass. Raises if there is no `key`.
+
+  Behaves exactly like `get_and_update/3`, but raises a `KeyError` exception if
+  `key` is not present in `map`.
+
+  ## Examples
+
+      iex> Map.get_and_update!(%{a: 1}, :a, fn current_value ->
+      ...>   {current_value, "new value!"}
+      ...> end)
+      {1, %{a: "new value!"}}
+
+      iex> Map.get_and_update!(%{a: 1}, :b, fn current_value ->
+      ...>   {current_value, "new value!"}
+      ...> end)
+      ** (KeyError) key :b not found in:
+      ...
+
+      iex> Map.get_and_update!(%{a: 1}, :a, fn _ ->
+      ...>   :pop
+      ...> end)
+      {1, %{}}
+
+  """
+  @spec get_and_update!(map, key, (value -> {current_value, new_value :: value} | :pop)) ::
+          {current_value, map}
+        when current_value: value
+  def get_and_update!(map, key, fun) when is_function(fun, 1) do
+    value = fetch!(map, key)
+
+    case fun.(value) do
+      {get, update} ->
+        {get, %{map | key => update}}
+
+      :pop ->
+        {value, delete(map, key)}
+
+      other ->
+        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+    end
+  end
+
+  @doc """
+  Converts a `struct` to map.
+
+  It accepts a struct and simply removes the `__struct__` field
+  from the given struct.
+
+  ## Example
+
+      defmodule User do
+        defstruct [:name]
+      end
+
+      Map.from_struct(%User{name: "john"})
+      #=> %{name: "john"}
+
+  """
+  @spec from_struct(atom | struct) :: map
+  def from_struct(struct) when is_atom(struct) do
+    IO.warn("Map.from_struct/1 with a module is deprecated, please pass a struct instead")
+    delete(struct.__struct__(), :__struct__)
+  end
+
+  def from_struct(%_{} = struct) do
+    delete(struct, :__struct__)
+  end
+
+  @doc """
+  Checks if two maps are equal.
+
+  Two maps are considered to be equal if they contain
+  the same keys and those keys contain the same values.
+
+  Note this function exists for completeness so the `Map`
+  and `Keyword` modules provide similar APIs. In practice,
+  developers often compare maps using `==/2` or `===/2`
+  directly.
+
+  ## Examples
+
+      iex> Map.equal?(%{a: 1, b: 2}, %{b: 2, a: 1})
+      true
+      iex> Map.equal?(%{a: 1, b: 2}, %{b: 1, a: 2})
+      false
+
+  Comparison between keys and values is done with `===/3`,
+  which means integers are not equivalent to floats:
+
+      iex> Map.equal?(%{a: 1.0}, %{a: 1})
+      false
+
+  """
+  @spec equal?(map, map) :: boolean
+  def equal?(map1, map2)
+
   def equal?(%{} = map1, %{} = map2), do: map1 === map2
+  def equal?(%{} = map1, map2), do: :erlang.error({:badmap, map2}, [map1, map2])
+  def equal?(term, other), do: :erlang.error({:badmap, term}, [term, other])
+
+  @doc false
+  @deprecated "Use Kernel.map_size/1 instead"
+  def size(map) do
+    map_size(map)
+  end
+
+  @doc """
+  Returns a map containing only those pairs from `map`
+  for which `fun` returns a truthy value.
+
+  `fun` receives the key and value of each of the
+  elements in the map as a key-value pair.
+
+  See also `reject/2` which discards all elements where the
+  function returns a truthy value.
+
+  > #### Performance considerations {: .tip}
+  >
+  > If you find yourself doing multiple calls to `Map.filter/2`
+  > and `Map.reject/2` in a pipeline, it is likely more efficient
+  > to use `Enum.map/2` and `Enum.filter/2` instead and convert to
+  > a map at the end using `Map.new/1`.
+
+  ## Examples
+
+      iex> Map.filter(%{one: 1, two: 2, three: 3}, fn {_key, val} -> rem(val, 2) == 1 end)
+      %{one: 1, three: 3}
+
+  """
+  @doc since: "1.13.0"
+  @spec filter(map, ({key, value} -> as_boolean(term))) :: map
+  def filter(map, fun) when is_map(map) and is_function(fun, 1) do
+    iter = :maps.iterator(map)
+    next = :maps.next(iter)
+    :maps.from_list(do_filter(next, fun))
+  end
+
+  defp do_filter(:none, _fun), do: []
+
+  defp do_filter({key, value, iter}, fun) do
+    if fun.({key, value}) do
+      [{key, value} | do_filter(:maps.next(iter), fun)]
+    else
+      do_filter(:maps.next(iter), fun)
+    end
+  end
+
+  @doc """
+  Returns map excluding the pairs from `map` for which `fun` returns
+  a truthy value.
+
+  See also `filter/2`.
+
+  ## Examples
+
+      iex> Map.reject(%{one: 1, two: 2, three: 3}, fn {_key, val} -> rem(val, 2) == 1 end)
+      %{two: 2}
+
+  """
+  @doc since: "1.13.0"
+  @spec reject(map, ({key, value} -> as_boolean(term))) :: map
+  def reject(map, fun) when is_map(map) and is_function(fun, 1) do
+    iter = :maps.iterator(map)
+    next = :maps.next(iter)
+    :maps.from_list(do_reject(next, fun))
+  end
+
+  defp do_reject(:none, _fun), do: []
+
+  defp do_reject({key, value, iter}, fun) do
+    if fun.({key, value}) do
+      do_reject(:maps.next(iter), fun)
+    else
+      [{key, value} | do_reject(:maps.next(iter), fun)]
+    end
+  end
+
+  @doc """
+  Intersects two maps, returning a map with the common keys.
+
+  The values in the returned map are the values of the intersected keys in `map2`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Map.intersect(%{a: 1, b: 2}, %{b: "b", c: "c"})
+      %{b: "b"}
+
+  """
+  @doc since: "1.15.0"
+  @spec intersect(map, map) :: map
+  defdelegate intersect(map1, map2), to: :maps
+
+  @doc """
+  Intersects two maps, returning a map with the common keys and resolving conflicts through a function.
+
+  The given function will be invoked when there are duplicate keys; its
+  arguments are `key` (the duplicate key), `value1` (the value of `key` in
+  `map1`), and `value2` (the value of `key` in `map2`). The value returned by
+  `fun` is used as the value under `key` in the resulting map.
+
+  ## Examples
+
+      iex> Map.intersect(%{a: 1, b: 2}, %{b: 2, c: 3}, fn _k, v1, v2 ->
+      ...>   v1 + v2
+      ...> end)
+      %{b: 4}
+  """
+  @doc since: "1.15.0"
+  @spec intersect(map, map, (key, value, value -> value)) :: map
+  def intersect(map1, map2, fun) when is_function(fun, 3) do
+    :maps.intersect_with(fun, map1, map2)
+  end
+
+  @doc false
+  @deprecated "Use Map.new/2 instead (invoke Map.from_struct/1 before if you have a struct)"
+  def map(map, fun) when is_map(map) do
+    :maps.map(fn k, v -> fun.({k, v}) end, map)
+  end
 end
diff --git a/lib/elixir/lib/map_set.ex b/lib/elixir/lib/map_set.ex
new file mode 100644
index 00000000000..6e687954ba5
--- /dev/null
+++ b/lib/elixir/lib/map_set.ex
@@ -0,0 +1,456 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule MapSet do
+  @moduledoc """
+  Functions that work on sets.
+
+  A set is a data structure that can contain unique elements of any kind,
+  without any particular order. `MapSet` is the "go to" set data structure in Elixir.
+
+  A set can be constructed using `MapSet.new/0`:
+
+      iex> MapSet.new()
+      MapSet.new([])
+
+  Elements in a set don't have to be of the same type and they can be
+  populated from an [enumerable](`t:Enumerable.t/0`) using `MapSet.new/1`:
+
+      iex> MapSet.new([1, :two, {"three"}])
+      MapSet.new([1, :two, {"three"}])
+
+  Elements can be inserted using `MapSet.put/2`:
+
+      iex> MapSet.new([2]) |> MapSet.put(4) |> MapSet.put(0)
+      MapSet.new([0, 2, 4])
+
+  By definition, sets can't contain duplicate elements: when
+  inserting an element in a set where it's already present, the insertion is
+  simply a no-op.
+
+      iex> map_set = MapSet.new()
+      iex> MapSet.put(map_set, "foo")
+      MapSet.new(["foo"])
+      iex> map_set |> MapSet.put("foo") |> MapSet.put("foo")
+      MapSet.new(["foo"])
+
+  A `MapSet` is represented internally using the `%MapSet{}` struct. This struct
+  can be used whenever there's a need to pattern match on something being a `MapSet`:
+
+      iex> match?(%MapSet{}, MapSet.new())
+      true
+
+  Note that, however, the struct fields are private and must not be accessed
+  directly; use the functions in this module to perform operations on sets.
+
+  `MapSet`s can also be constructed starting from other collection-type data
+  structures: for example, see `MapSet.new/1` or `Enum.into/2`.
+
+  `MapSet` is built on top of Erlang's [`:sets`](`:sets`) (version 2). This means
+  that they share many properties, including logarithmic time complexity. Erlang
+  `:sets` (version 2) are implemented on top of maps, so see the documentation
+  for `Map` for more information on its execution time complexity.
+  """
+
+  @type value :: term
+
+  @opaque internal(value) :: :sets.set(value)
+  @type t(value) :: %__MODULE__{map: internal(value)}
+  @type t :: t(term)
+
+  # The key name is :map because the MapSet implementation used to be based on top of maps before
+  # Elixir 1.15 (and Erlang/OTP 24, which introduced :sets version 2). :sets v2's internal
+  # representation is, anyways, exactly the same as MapSet's previous implementation. We cannot
+  # change the :map key name here because we'd break backwards compatibility with code compiled
+  # with Elixir 1.14 and earlier and executed on Elixir 1.15+.
+  defstruct map: :sets.new(version: 2)
+
+  @doc """
+  Returns a new set.
+
+  ## Examples
+
+      iex> MapSet.new()
+      MapSet.new([])
+
+  """
+  @spec new :: t
+  def new(), do: %MapSet{}
+
+  @doc """
+  Creates a set from an enumerable.
+
+  ## Examples
+
+      iex> MapSet.new([:b, :a, 3])
+      MapSet.new([3, :a, :b])
+      iex> MapSet.new([3, 3, 3, 2, 2, 1])
+      MapSet.new([1, 2, 3])
+
+  """
+  @spec new(Enumerable.t()) :: t
+  def new(enumerable)
+
+  def new(%__MODULE__{} = map_set), do: map_set
+
+  def new(enumerable) do
+    set =
+      enumerable
+      |> Enum.to_list()
+      |> :sets.from_list(version: 2)
+
+    %MapSet{map: set}
+  end
+
+  @doc """
+  Creates a set from an enumerable via the transformation function.
+
+  ## Examples
+
+      iex> MapSet.new([1, 2, 1], fn x -> 2 * x end)
+      MapSet.new([2, 4])
+
+  """
+  @spec new(Enumerable.t(), (term -> val)) :: t(val) when val: value
+  def new(enumerable, transform) when is_function(transform, 1) do
+    set =
+      enumerable
+      |> Enum.map(transform)
+      |> :sets.from_list(version: 2)
+
+    %MapSet{map: set}
+  end
+
+  @doc """
+  Deletes `value` from `map_set`.
+
+  Returns a new set which is a copy of `map_set` but without `value`.
+
+  ## Examples
+
+      iex> map_set = MapSet.new([1, 2, 3])
+      iex> MapSet.delete(map_set, 4)
+      MapSet.new([1, 2, 3])
+      iex> MapSet.delete(map_set, 2)
+      MapSet.new([1, 3])
+
+  """
+  @spec delete(t(val1), val2) :: t(val1) when val1: value, val2: value
+  def delete(%MapSet{map: set} = map_set, value) do
+    %{map_set | map: :sets.del_element(value, set)}
+  end
+
+  @doc """
+  Returns a set that is `map_set1` without the members of `map_set2`.
+
+  ## Examples
+
+      iex> MapSet.difference(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
+      MapSet.new([1])
+
+  """
+  @spec difference(t(val1), t(val2)) :: t(val1) when val1: value, val2: value
+  def difference(%MapSet{map: set1} = map_set1, %MapSet{map: set2} = _map_set2) do
+    %{map_set1 | map: :sets.subtract(set1, set2)}
+  end
+
+  @doc """
+  Returns a set with elements that are present in only one but not both sets.
+
+  ## Examples
+
+      iex> MapSet.symmetric_difference(MapSet.new([1, 2, 3]), MapSet.new([2, 3, 4]))
+      MapSet.new([1, 4])
+
+  """
+  @doc since: "1.14.0"
+  @spec symmetric_difference(t(val1), t(val2)) :: t(val1 | val2) when val1: value, val2: value
+  def symmetric_difference(%MapSet{map: set1} = map_set1, %MapSet{map: set2} = _map_set2) do
+    {small, large} = if :sets.size(set1) <= :sets.size(set2), do: {set1, set2}, else: {set2, set1}
+
+    disjointer_fun = fn elem, {small, acc} ->
+      if :sets.is_element(elem, small) do
+        {:sets.del_element(elem, small), acc}
+      else
+        {small, [elem | acc]}
+      end
+    end
+
+    {new_small, list} = :sets.fold(disjointer_fun, {small, []}, large)
+    %{map_set1 | map: :sets.union(new_small, :sets.from_list(list, version: 2))}
+  end
+
+  @doc """
+  Checks if `map_set1` and `map_set2` have no members in common.
+
+  ## Examples
+
+      iex> MapSet.disjoint?(MapSet.new([1, 2]), MapSet.new([3, 4]))
+      true
+      iex> MapSet.disjoint?(MapSet.new([1, 2]), MapSet.new([2, 3]))
+      false
+
+  """
+  @spec disjoint?(t, t) :: boolean
+  def disjoint?(%MapSet{map: set1}, %MapSet{map: set2}) do
+    :sets.is_disjoint(set1, set2)
+  end
+
+  @doc """
+  Checks if two sets are equal.
+
+  The comparison between elements is done using `===/2`,
+  which a set with `1` is not equivalent to a set with
+  `1.0`.
+
+  ## Examples
+
+      iex> MapSet.equal?(MapSet.new([1, 2]), MapSet.new([2, 1, 1]))
+      true
+      iex> MapSet.equal?(MapSet.new([1, 2]), MapSet.new([3, 4]))
+      false
+      iex> MapSet.equal?(MapSet.new([1]), MapSet.new([1.0]))
+      false
+
+  """
+  @spec equal?(t, t) :: boolean
+  def equal?(%MapSet{map: set1}, %MapSet{map: set2}) do
+    set1 === set2
+  end
+
+  @doc """
+  Returns a set containing only members that `map_set1` and `map_set2` have in common.
+
+  ## Examples
+
+      iex> MapSet.intersection(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
+      MapSet.new([2])
+
+      iex> MapSet.intersection(MapSet.new([1, 2]), MapSet.new([3, 4]))
+      MapSet.new([])
+
+  """
+  @spec intersection(t(val), t(val)) :: t(val) when val: value
+  def intersection(%MapSet{map: set1} = map_set1, %MapSet{map: set2} = _map_set2) do
+    %{map_set1 | map: :sets.intersection(set1, set2)}
+  end
+
+  @doc """
+  Checks if `map_set` contains `value`.
+
+  ## Examples
+
+      iex> MapSet.member?(MapSet.new([1, 2, 3]), 2)
+      true
+      iex> MapSet.member?(MapSet.new([1, 2, 3]), 4)
+      false
+
+  """
+  @spec member?(t, value) :: boolean
+  def member?(%MapSet{map: set}, value) do
+    :sets.is_element(value, set)
+  end
+
+  @doc """
+  Inserts `value` into `map_set` if `map_set` doesn't already contain it.
+
+  ## Examples
+
+      iex> MapSet.put(MapSet.new([1, 2, 3]), 3)
+      MapSet.new([1, 2, 3])
+      iex> MapSet.put(MapSet.new([1, 2, 3]), 4)
+      MapSet.new([1, 2, 3, 4])
+
+  """
+  @spec put(t(val), new_val) :: t(val | new_val) when val: value, new_val: value
+  def put(%MapSet{map: set} = map_set, value) do
+    %{map_set | map: :sets.add_element(value, set)}
+  end
+
+  @doc """
+  Returns the number of elements in `map_set`.
+
+  ## Examples
+
+      iex> MapSet.size(MapSet.new([1, 2, 3]))
+      3
+
+  """
+  @spec size(t) :: non_neg_integer
+  def size(%MapSet{map: set}) do
+    :sets.size(set)
+  end
+
+  @doc """
+  Checks if `map_set1`'s members are all contained in `map_set2`.
+
+  This function checks if `map_set1` is a subset of `map_set2`.
+
+  ## Examples
+
+      iex> MapSet.subset?(MapSet.new([1, 2]), MapSet.new([1, 2, 3]))
+      true
+      iex> MapSet.subset?(MapSet.new([1, 2, 3]), MapSet.new([1, 2]))
+      false
+
+  """
+  @spec subset?(t, t) :: boolean
+  def subset?(%MapSet{map: set1}, %MapSet{map: set2}) do
+    :sets.is_subset(set1, set2)
+  end
+
+  @doc """
+  Converts `map_set` to a list.
+
+  ## Examples
+
+      iex> MapSet.to_list(MapSet.new([1, 2, 3]))
+      [1, 2, 3]
+
+  """
+  @spec to_list(t(val)) :: [val] when val: value
+  def to_list(%MapSet{map: set}) do
+    :sets.to_list(set)
+  end
+
+  @doc """
+  Returns a set containing all members of `map_set1` and `map_set2`.
+
+  ## Examples
+
+      iex> MapSet.union(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
+      MapSet.new([1, 2, 3, 4])
+
+  """
+  @spec union(t(val1), t(val2)) :: t(val1 | val2) when val1: value, val2: value
+  def union(%MapSet{map: set1} = map_set1, %MapSet{map: set2} = _map_set2) do
+    %{map_set1 | map: :sets.union(set1, set2)}
+  end
+
+  @doc """
+  Filters the set by returning only the elements from `map_set` for which invoking
+  `fun` returns a truthy value.
+
+  Also see `reject/2` which discards all elements where the function returns
+  a truthy value.
+
+  > #### Performance considerations {: .tip}
+  >
+  > If you find yourself doing multiple calls to `MapSet.filter/2`
+  > and `MapSet.reject/2` in a pipeline, it is likely more efficient
+  > to use `Enum.map/2` and `Enum.filter/2` instead and convert to
+  > a map at the end using `MapSet.new/1`.
+
+  ## Examples
+
+      iex> MapSet.filter(MapSet.new(1..5), fn x -> x > 3 end)
+      MapSet.new([4, 5])
+
+      iex> MapSet.filter(MapSet.new(["a", :b, "c"]), &is_atom/1)
+      MapSet.new([:b])
+
+  """
+  @doc since: "1.14.0"
+  @spec filter(t(a), (a -> as_boolean(term))) :: t(a) when a: value
+  def filter(%MapSet{map: set} = map_set, fun) when is_function(fun) do
+    pred = fn element -> !!fun.(element) end
+    %{map_set | map: :sets.filter(pred, set)}
+  end
+
+  @doc """
+  Returns a set by excluding the elements from `map_set` for which invoking `fun`
+  returns a truthy value.
+
+  See also `filter/2`.
+
+  ## Examples
+
+      iex> MapSet.reject(MapSet.new(1..5), fn x -> rem(x, 2) != 0 end)
+      MapSet.new([2, 4])
+
+      iex> MapSet.reject(MapSet.new(["a", :b, "c"]), &is_atom/1)
+      MapSet.new(["a", "c"])
+
+  """
+  @doc since: "1.14.0"
+  @spec reject(t(a), (a -> as_boolean(term))) :: t(a) when a: value
+  def reject(%MapSet{map: set} = map_set, fun) when is_function(fun) do
+    pred = fn element -> !fun.(element) end
+    %{map_set | map: :sets.filter(pred, set)}
+  end
+
+  @doc """
+  Splits the `map_set` into two `MapSet`s according to the given function `fun`.
+
+  `fun` receives each element in the `map_set` as its only argument. Returns
+  a tuple with the first `MapSet` containing all the elements in `map_set` for which
+  applying `fun` returned a truthy value, and a second `MapSet` with all the elements
+  for which applying `fun` returned a falsy value (`false` or `nil`).
+
+  ## Examples
+
+      iex> {while_true, while_false} = MapSet.split_with(MapSet.new([1, 2, 3, 4]), fn v -> rem(v, 2) == 0 end)
+      iex> while_true
+      MapSet.new([2, 4])
+      iex> while_false
+      MapSet.new([1, 3])
+
+      iex> {while_true, while_false} = MapSet.split_with(MapSet.new(), fn {_k, v} -> v > 50 end)
+      iex> while_true
+      MapSet.new([])
+      iex> while_false
+      MapSet.new([])
+
+  """
+  @doc since: "1.15.0"
+  @spec split_with(MapSet.t(), (term() -> as_boolean(term))) :: {MapSet.t(), MapSet.t()}
+  def split_with(%MapSet{map: map}, fun) when is_function(fun, 1) do
+    {while_true, while_false} = Map.split_with(map, fn {key, _} -> fun.(key) end)
+    {%MapSet{map: while_true}, %MapSet{map: while_false}}
+  end
+
+  defimpl Enumerable do
+    def count(map_set) do
+      {:ok, MapSet.size(map_set)}
+    end
+
+    def member?(map_set, val) do
+      {:ok, MapSet.member?(map_set, val)}
+    end
+
+    def slice(map_set) do
+      size = MapSet.size(map_set)
+      {:ok, size, &MapSet.to_list/1}
+    end
+
+    def reduce(map_set, acc, fun) do
+      Enumerable.List.reduce(MapSet.to_list(map_set), acc, fun)
+    end
+  end
+
+  defimpl Collectable do
+    def into(%@for{map: set} = map_set) do
+      fun = fn
+        list, {:cont, x} -> [x | list]
+        list, :done -> %{map_set | map: :sets.union(set, :sets.from_list(list, version: 2))}
+        _, :halt -> :ok
+      end
+
+      {[], fun}
+    end
+  end
+
+  defimpl Inspect do
+    import Inspect.Algebra
+
+    def inspect(map_set, %Inspect.Opts{} = opts) do
+      {doc, %{limit: limit}} =
+        map_set
+        |> MapSet.to_list()
+        |> to_doc_with_opts(%{opts | charlists: :as_lists})
+
+      {concat(["MapSet.new(", doc, ")"]), %{opts | limit: limit}}
+    end
+  end
+end
diff --git a/lib/elixir/lib/module.ex b/lib/elixir/lib/module.ex
index 3853bfeac8c..9f0d4b043fd 100644
--- a/lib/elixir/lib/module.ex
+++ b/lib/elixir/lib/module.ex
@@ -1,360 +1,891 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Module do
   @moduledoc ~S'''
-  This module provides many functions to deal with modules during
-  compilation time. It allows a developer to dynamically attach
-  documentation, add, delete and register attributes and so forth.
+  Provides functions to deal with modules during compilation time.
+
+  It allows a developer to dynamically add, delete and register
+  attributes, attach documentation and so forth.
 
   After a module is compiled, using many of the functions in
   this module will raise errors, since it is out of their scope
   to inspect runtime data. Most of the runtime data can be inspected
-  via the `__info__(attr)` function attached to each compiled module.
+  via the [`__info__/1`](`c:Module.__info__/1`) function attached to
+  each compiled module.
 
   ## Module attributes
 
   Each module can be decorated with one or more attributes. The following ones
   are currently defined by Elixir:
 
-    * `@after_compile`
+  ### `@after_compile`
 
-      A hook that will be invoked right after the current module is compiled.
+  A hook that will be invoked right after the current module is compiled.
+  Accepts a module or a `{module, function_name}`. See the ["Compile callbacks"](#module-compile-callbacks)
+  section below.
 
-      Accepts a module or a tuple `{<module>, <function atom>}`. The function
-      must take two arguments: the module environment and its bytecode.
-      When just a module is provided, the function is assumed to be
-      `__after_compile__/2`.
+  ### `@after_verify` (since v1.14.0)
 
-      ### Example
+  A hook that will be invoked right after the current module is verified for
+  undefined functions, deprecations, etc. Accepts a module or a `{module, function_name}`.
+  See the ["Compile callbacks"](#module-compile-callbacks) section below.
 
-          defmodule M do
-            @after_compile __MODULE__
+  ### `@before_compile`
 
-            def __after_compile__(env, _bytecode) do
-              IO.inspect env
-            end
-          end
+  A hook that will be invoked before the module is compiled.
+  Accepts a module or a `{module, function_or_macro_name}` tuple.
+  See the ["Compile callbacks"](#module-compile-callbacks) section below.
 
-    * `@before_compile`
+  ### `@behaviour`
 
-      A hook that will be invoked before the module is compiled.
+  Note the British spelling!
 
-      Accepts a module or a tuple `{<module>, <function/macro atom>}`. The
-      function/macro must take one argument: the module environment. If it's a
-      macro, its returned value will be injected at the end of the module definition
-      before the compilation starts.
+  Behaviours can be referenced by modules to ensure they implement
+  required specific function signatures defined by `@callback`.
 
-      When just a module is provided, the function/macro is assumed to be
-      `__before_compile__/1`.
+  For example, you could specify a `URI.Parser` behaviour as follows:
 
-      Note: unlike `@after_compile`, the callback function/macro must
-      be placed in a separate module (because when the callback is invoked,
-      the current module does not yet exist).
+      defmodule URI.Parser do
+        @doc "Defines a default port"
+        @callback default_port() :: integer
 
-      ### Example
+        @doc "Parses the given URL"
+        @callback parse(uri_info :: URI.t()) :: URI.t()
+      end
 
-          defmodule A do
-            defmacro __before_compile__(_env) do
-              quote do
-                def hello, do: "world"
-              end
-            end
-          end
+  And then a module may use it as:
 
-          defmodule B do
-            @before_compile A
-          end
+      defmodule URI.HTTP do
+        @behaviour URI.Parser
+        def default_port(), do: 80
+        def parse(info), do: info
+      end
 
-    * `@behaviour`   (notice the British spelling)
+  If the behaviour changes or `URI.HTTP` does not implement
+  one of the callbacks, a warning will be raised.
 
-      Specify an OTP or user-defined behaviour.
+  For detailed documentation, see the
+  [behaviour typespec documentation](typespecs.md#behaviours).
 
-      ### Example
+  ### `@impl` (since v1.5.0)
 
-          defmodule M do
-            @behaviour gen_event
+  To aid in the correct implementation of behaviours, you may optionally declare
+  `@impl` for implemented callbacks of a behaviour. This makes callbacks
+  explicit and can help you to catch errors in your code. The compiler will warn
+  in these cases:
 
-            # ...
-          end
+    * if you mark a function with `@impl` when that function is not a callback.
 
-    * `@compile`
+    * if you don't mark a function with `@impl` when other functions are marked
+      with `@impl`. If you mark one function with `@impl`, you must mark all
+      other callbacks for that behaviour as `@impl`.
 
-      Define options for module compilation that are passed to the Erlang
-      compiler.
+  `@impl` works on a per-context basis. If you generate a function through a macro
+  and mark it with `@impl`, that won't affect the module where that function is
+  generated in.
 
-      Accepts an atom, a tuple, or a list of atoms and tuples.
+  `@impl` also helps with maintainability by making it clear to other developers
+  that the function is implementing a callback.
 
-      See http://www.erlang.org/doc/man/compile.html for the list of supported
-      options.
+  Using `@impl`, the example above can be rewritten as:
 
-      ### Example
+      defmodule URI.HTTP do
+        @behaviour URI.Parser
 
-            defmodule M do
-              @compile {:inline, myfun: 1}
+        @impl true
+        def default_port(), do: 80
 
-              def myfun(arg) do
-                to_string(arg)
-              end
-            end
+        @impl true
+        def parse(info), do: info
+      end
 
-    * `@doc`
+  You may pass either `false`, `true`, or a specific behaviour to `@impl`.
 
-      Provide documentation for the function or macro that follows the
-      attribute.
+      defmodule Foo do
+        @behaviour Bar
+        @behaviour Baz
 
-      Accepts a string (often a heredoc) or `false` where `@doc false` will
-      make the function/macro invisible to the documentation extraction tools
-      like ExDoc.
+        # Will warn if neither Bar nor Baz specify a callback named bar/0.
+        @impl true
+        def bar(), do: :ok
 
-      Can be invoked more than once.
+        # Will warn if Baz does not specify a callback named baz/0.
+        @impl Baz
+        def baz(), do: :ok
+      end
 
-      ### Example
+  The code is now more readable, as it is now clear which functions are
+  part of your API and which ones are callback implementations. To reinforce this
+  idea, `@impl true` automatically marks the function as `@doc false`, disabling
+  documentation unless `@doc` is explicitly set.
 
-            defmodule M do
-              @doc "Hello world"
-              def hello do
-                "world"
-              end
+  ### `@compile`
 
-              @doc """
-              Sum.
-              """
-              def sum(a, b) do
-                a + b
-              end
-            end
+  Defines options for module compilation. This is used to configure
+  both Elixir and Erlang compilers, as well as any other compilation pass
+  added by external tools. For example:
+
+      defmodule MyModule do
+        @compile {:inline, my_fun: 1}
+
+        def my_fun(arg) do
+          to_string(arg)
+        end
+      end
 
-    * `@file`
+  Multiple uses of `@compile` will accumulate instead of overriding
+  previous ones. See the ["Compile options"](#module-compile-options) section below.
 
-      Change the filename used in stacktraces for the function or macro that
-      follows the attribute.
+  ### `@deprecated` (since v1.6.0)
 
-      Accepts a string. Can be used more than once.
+  Provides the deprecation reason for a function. For example:
 
-      ### Example
+      defmodule Keyword do
+        @deprecated "Use Kernel.length/1 instead"
+        def size(keyword) do
+          length(keyword)
+        end
+      end
 
-            defmodule M do
-              @doc "Hello world"
-              @file "hello.ex"
-              def hello do
-                "world"
-              end
-            end
+  The Mix compiler automatically looks for calls to deprecated modules
+  and emit warnings during compilation.
 
-    * `@moduledoc`
+  Using the `@deprecated` attribute will also be reflected in the
+  documentation of the given function and macro. You can choose between
+  the `@deprecated` attribute and the documentation metadata to provide
+  hard-deprecations (with warnings) and soft-deprecations (without warnings):
 
-      Provide documentation for the current module.
+  This is a soft-deprecation as it simply annotates the documentation
+  as deprecated:
 
-      Accepts a string (which is often a heredoc) or `false` where
-      `@moduledoc false` will make the module invisible to the
-      documentation extraction tools like ExDoc.
+      @doc deprecated: "Use Kernel.length/1 instead"
+      def size(keyword)
 
-      ### Example
+  This is a hard-deprecation as it emits warnings and annotates the
+  documentation as deprecated:
 
-            defmodule M do
-              @moduledoc """
-              A very useful module
-              """
-            end
+      @deprecated "Use Kernel.length/1 instead"
+      def size(keyword)
 
+  Currently `@deprecated` only supports functions and macros. However
+  you can use the `:deprecated` key in the annotation metadata to
+  annotate the docs of modules, types and callbacks too.
 
-    * `@on_definition`
+  We recommend using this feature with care, especially library authors.
+  Deprecating code always pushes the burden towards library users. We
+  also recommend for deprecated functionality to be maintained for long
+  periods of time, even after deprecation, giving developers plenty of
+  time to update (except for cases where keeping the deprecated API is
+  undesired, such as in the presence of security issues).
 
-      A hook that will be invoked when each function or macro in the current
-      module is defined. Useful when annotating functions.
+  ### `@doc` and `@typedoc`
 
-      Accepts a module or a tuple `{<module>, <function atom>}`. The function
-      must take 6 arguments:
+  Provides documentation for the entity that follows the attribute.
+  `@doc` is to be used with a function, macro, callback, or
+  macrocallback, while `@typedoc` with a type (public or opaque).
 
-        - the module environment
-        - kind: `:def`, `:defp`, `:defmacro`, or `:defmacrop`
-        - function/macro name
-        - list of expanded arguments
-        - list of expanded guards
-        - expanded function body
+  Accepts one of these:
 
-      Note the hook receives the expanded arguments and it is invoked before
-      the function is stored in the module. So `Module.defines?/2` will return
-      false for the first clause of every function.
+    * a string (often a heredoc)
+    * `false`, which will make the entity invisible to documentation-extraction
+      tools like [`ExDoc`](https://hexdocs.pm/ex_doc/)
+    * a keyword list, since Elixir 1.7.0
 
-      If the function/macro being defined has multiple clauses, the hook will
-      be called for each clause.
+  For example:
 
-      Unlike other hooks, `@on_definition` will only invoke functions
-      and never macros. This is because the hook is invoked inside the context
-      of the function (and nested function definitions are not allowed in
-      Elixir).
+      defmodule MyModule do
+        @typedoc "This type"
+        @typedoc since: "1.1.0"
+        @type t :: term
+
+        @doc "Hello world"
+        @doc since: "1.1.0"
+        def hello do
+          "world"
+        end
 
-      When just a module is provided, the function is assumed to be
-      `__on_definition__/6`.
+        @doc """
+        Sums `a` to `b`.
+        """
+        def sum(a, b) do
+          a + b
+        end
+      end
 
-      ### Example
+  As can be seen in the example above, since Elixir 1.7.0 `@doc` and `@typedoc`
+  also accept a keyword list that serves as a way to provide arbitrary metadata
+  about the entity. Tools like [`ExDoc`](https://hexdocs.pm/ex_doc/) and
+  `IEx` may use this information to display annotations. A common use
+  case is the `:since` key, which may be used to annotate in which version the
+  function was introduced.
 
-            defmodule H do
-              def on_def(_env, kind, name, args, guards, body) do
-                IO.puts "Defining #{kind} named #{name} with args:"
-                IO.inspect args
-                IO.puts "and guards"
-                IO.inspect guards
-                IO.puts "and body"
-                IO.puts Macro.to_string(body)
-              end
-            end
+  As illustrated in the example, it is possible to use these attributes
+  more than once before an entity. However, the compiler will warn if
+  used twice with binaries as that replaces the documentation text from
+  the preceding use. Multiple uses with keyword lists will merge the
+  lists into one.
 
-            defmodule M do
-              @on_definition {H, :on_def}
+  Note that since the compiler also defines some additional metadata,
+  there are a few reserved keys that will be ignored and warned if used.
+  Currently these are: `:opaque` and `:defaults`.
 
-              def hello(arg) when is_binary(arg) or is_list(arg) do
-                "Hello" <> to_string(arg)
-              end
+  Once this module is compiled, this information becomes available via
+  the `Code.fetch_docs/1` function.
 
-              def hello(_) do
-                :ok
-              end
-            end
+  ### `@dialyzer`
 
-    * `@on_load`
+  Defines warnings to request or suppress when using `:dialyzer`.
 
-      A hook that will be invoked whenever the module is loaded.
+  Accepts an atom, a tuple, or a list of atoms and tuples. For example:
 
-      Accepts a function atom of a function in the current module. The function
-      must have arity 0 (no arguments) and has to return `:ok`, otherwise the
-      loading of the module will be aborted.
+      defmodule MyModule do
+        @dialyzer {:nowarn_function, [my_fun: 1]}
 
-      ### Example
+        def my_fun(arg) do
+          M.not_a_function(arg)
+        end
+      end
 
-            defmodule M do
-              @on_load :load_check
+  For the list of supported warnings, see [`:dialyzer` module](`:dialyzer`).
 
-              def load_check do
-                if some_condition() do
-                  :ok
-                else
-                  nil
-                end
-              end
+  Multiple uses of `@dialyzer` will accumulate instead of overriding
+  previous ones.
 
-              def some_condition do
-                false
-              end
-            end
+  ### `@external_resource`
 
-    * `@vsn`
+  Specifies an external resource for the current module.
 
-      Specify the module version. Accepts any valid Elixir value.
+  Sometimes a module embeds information from an external file. This
+  attribute allows the module to annotate which external resources
+  have been used.
 
-      ### Example
+  Tools may use this information to ensure the module is recompiled
+  in case any of the external resources change, see for example:
+  [`mix compile.elixir`](https://hexdocs.pm/mix/Mix.Tasks.Compile.Elixir.html).
 
-            defmodule M do
-              @vsn "1.0"
-            end
+  The specified file path provided is interpreted as relative to
+  the folder containing the project's `mix.exs`, which is the
+  current working directory, not the file where `@external_resource`
+  is declared.
 
-    * `@external_resource`
+  If the external resource does not exist, the module still has
+  a dependency on it, causing the module to be recompiled as soon
+  as the file is added.
 
-      Specify an external resource to the current module.
+  For more control over when a module is recompiled, see
+  [`__mix_recompile__?/0`](`m:Mix.Tasks.Compile.Elixir#module-__mix_recompile__-0`).
 
-      Many times a module embeds information from an external file. This
-      attribute allows the module to annotate which external resources
-      have been used.
+  ### `@file`
 
-      Tools like Mix may use this information to ensure the module is
-      recompiled in case any of the external resources change.
+  Changes the filename used in stacktraces for the function or macro that
+  follows the attribute, such as:
 
-  The following attributes are part of typespecs and are also reserved by
-  Elixir (see `Kernel.Typespec` for more information about typespecs):
+      defmodule MyModule do
+        @doc "Hello world"
+        @file "hello.ex"
+        def hello do
+          "world"
+        end
+      end
 
-    * `@type`        - defines a type to be used in `@spec`
-    * `@typep`       - defines a private type to be used in `@spec`
-    * `@opaque`      - defines an opaque type to be used in `@spec`
-    * `@spec`        - provides a specification for a function
-    * `@callback`    - provides a specification for the behaviour callback
+  Note that this is only valid for exceptions/diagnostics that come from the
+  definition inner scope (which includes its patterns and guards). For example:
 
-  In addition to the built-in attributes outlined above, custom attributes may
-  also be added. A custom attribute is any valid identifier prefixed with an
-  `@` and followed by a valid Elixir value:
+      defmodule MyModule do # <---- module definition
+        @file "hello.ex"
+        defp unused(a) do # <---- function definition
+          "world" # <---- function scope
+        end
+
+        @file "bye.ex"
+        def unused(_), do: true
+      end
+
+  If you run this code with the second "unused" definition commented, you will
+  see that `hello.ex` is used as the stacktrace when reporting warnings, but if
+  you uncomment it you'll see that the error will not mention `bye.ex`, because
+  it's a module-level error rather than an expression-level error.
+
+  ### `@moduledoc`
+
+  Provides documentation for the current module.
+
+      defmodule MyModule do
+        @moduledoc """
+        A very useful module.
+        """
+        @moduledoc authors: ["Alice", "Bob"]
+      end
+
+  Accepts a string (often a heredoc) or `false` where `@moduledoc false`
+  will make the module invisible to documentation extraction tools like
+  [`ExDoc`](https://hexdocs.pm/ex_doc/).
+
+  Similarly to `@doc` also accepts a keyword list to provide metadata
+  about the module. For more details, see the documentation of `@doc`
+  above.
+
+  Once this module is compiled, this information becomes available via
+  the `Code.fetch_docs/1` function.
+
+  ### `@nifs` (since v1.16.0)
+
+  A list of functions and their arities which will be overridden
+  by a native implementation (NIF).
+
+      defmodule MyLibrary.MyModule do
+        @nifs [foo: 1, bar: 2]
+
+        def foo(arg1), do: :erlang.nif_error(:not_loaded)
+        def bar(arg1, arg2), do: :erlang.nif_error(:not_loaded)
+      end
+
+  See the Erlang documentation for more information:
+  https://www.erlang.org/doc/man/erl_nif
+
+  ### `@on_definition`
+
+  A hook that will be invoked when each function or macro in the current
+  module is defined. Useful when annotating functions.
+
+  Accepts a module or a `{module, function_name}` tuple. The function
+  must take 6 arguments:
+
+    * the module environment
+    * the kind of the function/macro: `:def`, `:defp`, `:defmacro`, or `:defmacrop`
+    * the function/macro name
+    * the list of quoted arguments
+    * the list of quoted guards
+    * the quoted function body
+
+  If the function/macro being defined has multiple clauses, the hook will
+  be called for each clause.
+
+  Unlike other hooks, `@on_definition` will only invoke functions and
+  never macros. This is to avoid `@on_definition` callbacks from
+  redefining functions that have just been defined in favor of more
+  explicit approaches.
+
+  When just a module is provided, the function is assumed to be
+  `__on_definition__/6`.
+
+  #### Example
+
+      defmodule Hooks do
+        def on_def(_env, kind, name, args, guards, body) do
+          IO.puts("Defining #{kind} named #{name} with args:")
+          IO.inspect(args)
+          IO.puts("and guards")
+          IO.inspect(guards)
+          IO.puts("and body")
+          IO.puts(Macro.to_string(body))
+        end
+      end
+
+      defmodule MyModule do
+        @on_definition {Hooks, :on_def}
+
+        def hello(arg) when is_binary(arg) or is_list(arg) do
+          "Hello" <> to_string(arg)
+        end
+
+        def hello(_) do
+          :ok
+        end
+      end
+
+  ### `@on_load`
+
+  A hook that will be invoked whenever the module is loaded.
+
+  Accepts the function name (as an atom) of a function in the current module.
+  The function must have an arity of 0 (no arguments). If the function does
+  not return `:ok`, the loading of the module will be aborted. Its primary
+  use case is to load [NIFs](https://www.erlang.org/doc/man/erl_nif):
+
+      defmodule MyModule do
+        @on_load :load_external_code
 
-        defmodule M do
-          @custom_attr [some: "stuff"]
+        def load_external_code do
+          :erlang.load_nif(~c"path/to/extension.so_or_dll")
         end
+      end
+
+  The function given to `on_load` should avoid calling functions from
+  other modules. This is because, when running a `mix release`,
+  `on_load` runs extremely early, before any application starts running,
+  and therefore even systems like the `Logger` and `IO` are not yet available.
+
+  ### `@vsn`
+
+  Specify the module version. Accepts any valid Elixir value, for example:
+
+      defmodule MyModule do
+        @vsn "1.0"
+      end
+
+  ### Struct attributes
+
+    * `@derive` - derives an implementation for the given protocol for the
+      struct defined in the current module
+
+    * `@enforce_keys` - ensures the given keys are always set when building
+      the struct defined in the current module
+
+  See `defstruct/1` for more information on building and using structs.
+
+  ### Typespec attributes
+
+  The following attributes are part of typespecs and are also built-in in
+  Elixir:
+
+    * `@type` - defines a type to be used in `@spec`
+    * `@typep` - defines a private type to be used in `@spec`
+    * `@opaque` - defines an opaque type to be used in `@spec`
+    * `@spec` - provides a specification for a function
+    * `@callback` - provides a specification for a behaviour callback (and generates
+      a `behaviour_info/1` function in the module, see below)
+    * `@macrocallback` - provides a specification for a macro behaviour callback
+    * `@optional_callbacks` - specifies which behaviour callbacks and macro
+      behaviour callbacks are optional
+    * `@impl` - declares an implementation of a callback function or macro
+
+  For detailed documentation, see the [typespec documentation](typespecs.md).
+
+  ### Custom attributes
+
+  In addition to the built-in attributes outlined above, custom attributes may
+  also be added. Custom attributes are expressed using the `@/1` operator followed
+  by a valid variable name. The value given to the custom attribute must be a valid
+  Elixir value:
+
+      defmodule MyModule do
+        @custom_attr [some: "stuff"]
+      end
 
   For more advanced options available when defining custom attributes, see
   `register_attribute/3`.
 
-  ## Runtime information about a module
+  ## Compile callbacks
+
+  There are three compilation callbacks, invoked in this order:
+  `@before_compile`, `@after_compile`, and `@after_verify`.
+  They are described next.
+
+  ### `@before_compile`
+
+  A hook that will be invoked before the module is compiled. This is
+  often used to change how the current module is being compiled.
+
+  Accepts a module or a `{module, function_or_macro_name}` tuple. The
+  function/macro must take one argument: the module environment. If
+  it's a macro, its returned value will be injected at the end of the
+  module definition before the compilation starts.
+
+  When just a module is provided, the function/macro is assumed to be
+  `__before_compile__/1`.
+
+  Callbacks will run in the order they are registered. Any overridable
+  definition will be made concrete before the first callback runs.
+  A definition may be made overridable again in another before compile
+  callback and it will be made concrete one last time after all callbacks
+  run.
+
+  *Note*: the callback function/macro must be placed in a separate module
+  (because when the callback is invoked, the current module does not yet exist).
+
+  #### Example
+
+      defmodule A do
+        defmacro __before_compile__(_env) do
+          quote do
+            def hello, do: "world"
+          end
+        end
+      end
+
+      defmodule B do
+        @before_compile A
+      end
+
+      B.hello()
+      #=> "world"
+
+  ### `@after_compile`
+
+  A hook that will be invoked with the bytecode of the current module.
+  Although the module has already been compiled, its bytecode may not have
+  been loaded to memory nor written to disk. For those reasons, prefer to
+  use `@after_verify` callbacks or use `Code.ensure_compiled!/1` to wait
+  until the module is fully available for introspection/invocation.
+
+  Accepts a module or a `{module, function_name}` tuple. The function
+  must take two arguments: the module environment and its bytecode.
+  When just a module is provided, the function is assumed to be
+  `__after_compile__/2`.
+
+  Callbacks will run in the order they are registered.
+
+  `Module` functions expecting not yet compiled modules (such as `definitions_in/1`)
+  are still available at the time `@after_compile` is invoked.
+
+  #### Example
+
+      defmodule MyModule do
+        @after_compile __MODULE__
+
+        def __after_compile__(env, _bytecode) do
+          IO.inspect(env)
+        end
+      end
+
+  ### `@after_verify`
+
+  A hook that will be invoked right after the current module is verified for
+  undefined functions, deprecations, etc. A module is always verified after
+  it is compiled. In Mix projects, a module is also verified when any of its
+  runtime dependencies change. Therefore this is useful to perform verification
+  of the current module while avoiding compile-time dependencies. Given the
+  callback is invoked under different scenarios, Elixir provides no guarantees
+  of when in the compilation cycle nor in which process the callback runs.
+
+  Furthermore, after verification callbacks are not expected to raise.
+  Given they run after the code is compiled, artifacts have already been
+  written to disk, and therefore raising does not effectively halt compilation
+  and may leave unused artifacts on disk. If you must raise, use `@after_compile`
+  or other callback. Given modules have already been compiled, functions in
+  this module, such as `get_attribute/2`, which expect modules to not have been
+  yet compiled, do not work on `@after_verify` callback.
+
+  Accepts a module or a `{module, function_name}` tuple. The function
+  must take one argument: the module name. When just a module is provided,
+  the function is assumed to be `__after_verify__/1`.
+
+  Callbacks will run in the order they are registered.
+
+  #### Example
+
+      defmodule MyModule do
+        @after_verify __MODULE__
+
+        def __after_verify__(module) do
+          IO.inspect(module)
+          :ok
+        end
+      end
+
+  ## Compile options
+
+  The `@compile` attribute accepts different options that are used by both
+  Elixir and Erlang compilers. Some of the common use cases are documented
+  below:
+
+    * `@compile :debug_info` - includes `:debug_info` regardless of the
+      corresponding setting in `Code.get_compiler_option/1`
+
+    * `@compile {:debug_info, false}` - disables `:debug_info` regardless
+      of the corresponding setting in `Code.get_compiler_option/1`. Note
+      disabling `:debug_info` is not recommended as it removes the ability
+      of the Elixir compiler and other tools to static analyse the code.
+      If you want to remove the `:debug_info` while deploying, tools like
+      `mix release` already do such by default.
+
+    * `@compile {:inline, some_fun: 2, other_fun: 3}` - inlines the given
+      name/arity pairs. Inlining is applied locally, calls from another
+      module are not affected by this option
+
+    * `@compile {:autoload, true}` - configures if modules are automatically
+      loaded after definition. It defaults to `false` when compiling modules
+      to `.beam` files in disk (as the modules are then lazily loaded from
+      disk). If modules are not compiled to disk, then they are always loaded,
+      regardless of this flag
+
+    * `@compile {:no_warn_undefined, Mod}` or
+      `@compile {:no_warn_undefined, {Mod, fun, arity}}` - does not warn if
+      the given module or the given `Mod.fun/arity` are not defined
+
+  ## Generated functions
+
+  Sometimes the compiler will generate public functions within modules. These
+  are documented below.
+
+  ### `behaviour_info/1`
+
+  This function is generated for modules that define a behaviour, that is,
+  that have one or more `@callback` definitions. The signature for this function,
+  expressed as a spec, is:
+
+      @spec behaviour_info(:callbacks) :: [function_info]
+        when function_info: {function_name :: atom(), arity :: non_neg_integer()}
+
+      @spec behaviour_info(:optional_callbacks) :: [function_info]
+        when function_info: {function_name :: atom(), arity :: non_neg_integer()}
 
-  It is possible to query a module at runtime to find out which functions and
-  macros it defines, extract its docstrings, etc. See `__info__/1`.
+  `behaviour_info(:callbacks)` includes optional callbacks.
+
+  For example:
+
+      iex> Enum.sort(GenServer.behaviour_info(:callbacks))
+      [
+        code_change: 3,
+        format_status: 1,
+        format_status: 2,
+        handle_call: 3,
+        handle_cast: 2,
+        handle_continue: 2,
+        handle_info: 2,
+        init: 1,
+        terminate: 2
+      ]
+
+  ### `module_info/0`
+
+  This function is generated for all modules. It returns all the attributes
+  returned by `module_info/1` (see below), but as a single keyword list. See also the
+  [Erlang documentation](https://www.erlang.org/doc/system/modules.html#module_info-0).
+
+  ### `module_info/1`
+
+  This function is generated for all modules and returns
+  information about the module. The signature for this function,
+  expressed as a spec, is:
+
+      @spec module_info(:module) :: module() # Returns the module itself
+      @spec module_info(:attributes) :: keyword()
+      @spec module_info(:compile) :: keyword()
+      @spec module_info(:md5) :: binary()
+      @spec module_info(:nifs) :: module()
+      @spec module_info(:exports) :: [function_info]
+        when function_info: {function_name :: atom(), arity :: non_neg_integer()}
+      @spec module_info(:functions) :: [function_info]
+        when function_info: {function_name :: atom(), arity :: non_neg_integer()}
+
+  For example:
+
+      iex> URI.module_info(:module)
+      URI
+      iex> {:decode_www_form, 1} in URI.module_info(:exports)
+      true
+
+  For more information about `module_info/1`, also check out the [Erlang
+  documentation](https://www.erlang.org/doc/system/modules.html#module_info-1).
+
+  ### `__info__/1`
+
+  This function is generated for all modules. It's similar to `module_info/1` but
+  includes some additional Elixir-specific information, such as struct and macro
+  information. For documentation, see `c:Module.__info__/1`.
   '''
 
+  @type definition :: {atom, arity}
+  @type def_kind :: :def | :defp | :defmacro | :defmacrop
+
+  @type create_opts :: [
+          file: binary(),
+          line: pos_integer(),
+          generated: boolean()
+        ]
+
+  @type get_definition_opts :: [
+          skip_clauses: boolean()
+        ]
+
+  @extra_error_msg_defines? "Use Kernel.function_exported?/3 and Kernel.macro_exported?/3 " <>
+                              "to check for public functions and macros instead"
+
+  @extra_error_msg_definitions_in "Use the Module.__info__/1 callback to get public functions and macros instead"
+
   @doc """
-  Provides runtime information about functions and macros defined by the
-  module, enables docstring extraction, etc.
+  Provides runtime information about functions, macros, and other information
+  defined by the module.
 
   Each module gets an `__info__/1` function when it's compiled. The function
-  takes one of the following atoms:
+  takes one of the following items:
 
-    * `:functions`  - keyword list of public functions along with their arities
+    * `:attributes` - a keyword list with all persisted attributes
 
-    * `:macros`     - keyword list of public macros along with their arities
+    * `:compile` - a list with compiler metadata
 
-    * `:module`     - module name (`Module == Module.__info__(:module)`)
+    * `:functions` - a keyword list of public functions and their arities
 
-  In addition to the above, you may also pass to `__info__/1` any atom supported
-  by Erlang's `module_info` function which also gets defined for each compiled
-  module. See http://erlang.org/doc/reference_manual/modules.html#id69430 for
-  more information.
-  """
-  def __info__(kind)
+    * `:macros` - a keyword list of public macros and their arities
+
+    * `:md5` - the MD5 of the module
+
+    * `:module` - the module atom name
+
+    * `:struct` - (since v1.14.0) if the module defines a struct and if so each field in order.
+      See `Macro.struct_info!/2` for more information
 
-  @doc """
-  Check if a module is open, i.e. it is currently being defined
-  and its attributes and functions can be modified.
   """
-  def open?(module) do
-    :elixir_module.is_open(module)
-  end
+  @callback __info__(:attributes) :: keyword()
+  @callback __info__(:compile) :: [term()]
+  @callback __info__(:functions) :: keyword()
+  @callback __info__(:macros) :: keyword()
+  @callback __info__(:md5) :: binary()
+  @callback __info__(:module) :: module()
+  @callback __info__(:struct) ::
+              [
+                %{
+                  required(:field) => atom(),
+                  optional(:required) => boolean(),
+                  optional(:default) => term()
+                }
+              ]
+              | nil
 
   @doc """
-  Evaluates the quoted contents in the given module's context.
-
-  A list of environment options can also be given as argument.
-  See `Code.eval_string/3` for more information.
+  Returns information about module attributes used by Elixir.
 
-  Raises an error if the module was already compiled.
+  See the ["Module attributes"](#module-module-attributes) section in the module documentation for more
+  information on each attribute.
 
   ## Examples
 
-      defmodule Foo do
-        contents = quote do: (def sum(a, b), do: a + b)
-        Module.eval_quoted __MODULE__, contents
-      end
+      iex> map = Module.reserved_attributes()
+      iex> Map.has_key?(map, :moduledoc)
+      true
+      iex> Map.has_key?(map, :doc)
+      true
 
-      Foo.sum(1, 2) #=> 3
+  """
+  @doc since: "1.12.0"
+  @spec reserved_attributes() :: map
+  def reserved_attributes() do
+    %{
+      after_compile: %{
+        doc: "A hook that will be invoked right after the current module is compiled."
+      },
+      after_verify: %{
+        doc: "A hook that will be invoked right after the current module is verified."
+      },
+      before_compile: %{
+        doc: "A hook that will be invoked before the module is compiled."
+      },
+      behaviour: %{
+        doc: "Specifies that the current module implements a given behaviour."
+      },
+      enforce_keys: %{
+        doc:
+          "Ensures the given keys are always set when building the struct defined in the current module."
+      },
+      fallback_to_any: %{
+        doc:
+          "If set to `true` generates a default protocol implementation for all types (inside `defprotocol`)."
+      },
+      undefined_impl_description: %{
+        doc:
+          "A string with additional description to be used on `Protocol.UndefinedError` when looking up the implementation fails."
+      },
+      for: %{
+        doc:
+          "The current module/type a protocol implementation is being defined for (inside `defimpl`)."
+      },
+      protocol: %{
+        doc: "The current protocol being implemented (inside `defimpl`)."
+      },
+      on_definition: %{
+        doc:
+          "A hook that will be invoked when each function or macro in the current module is defined."
+      },
+      impl: %{
+        doc: "Declares an implementation of a callback function or macro."
+      },
+      compile: %{
+        doc: "Defines options for module compilation."
+      },
+      deprecated: %{
+        doc: "Provides the deprecation reason for a function."
+      },
+      moduledoc: %{
+        doc: "Provides documentation for the current module."
+      },
+      doc: %{
+        doc: "Provides documentation for a function/macro/callback."
+      },
+      typedoc: %{
+        doc: "Provides documentation for a type."
+      },
+      dialyzer: %{
+        doc: "Defines Dialyzer warnings to request or suppress."
+      },
+      external_resource: %{
+        doc: "Specifies an external resource for the current module."
+      },
+      file: %{
+        doc:
+          "Changes the filename used in stacktraces for the function or macro that follows the attribute."
+      },
+      on_load: %{
+        doc: "A hook that will be invoked whenever the module is loaded."
+      },
+      vsn: %{
+        doc: "Specify the module version."
+      },
+      type: %{
+        doc: "Defines a type to be used in `@spec`."
+      },
+      typep: %{
+        doc: "Defines a private type to be used in `@spec`."
+      },
+      opaque: %{
+        doc: "Defines an opaque type to be used in `@spec`."
+      },
+      spec: %{
+        doc: "Provides a specification for a function."
+      },
+      callback: %{
+        doc: "Provides a specification for a behaviour callback."
+      },
+      macrocallback: %{
+        doc: "Provides a specification for a macro behaviour callback."
+      },
+      optional_callbacks: %{
+        doc: "Specifies which behaviour callbacks and macro behaviour callbacks are optional."
+      },
+      derive: %{
+        doc:
+          "Derives an implementation for the given protocol for the struct defined in the current module."
+      }
+    }
+  end
 
-  For convenience, you can my pass `__ENV__` as argument and
-  all options will be automatically extracted from the environment:
+  @doc """
+  Checks if a module is open.
 
-      defmodule Foo do
-        contents = quote do: (def sum(a, b), do: a + b)
-        Module.eval_quoted __MODULE__, contents, [], __ENV__
-      end
+  A module is "open" if it is currently being defined and its attributes and
+  functions can be modified.
+  """
+  @spec open?(module) :: boolean
+  def open?(module) when is_atom(module) do
+    :elixir_module.is_open(module)
+  end
 
-      Foo.sum(1, 2) #=> 3
+  @deprecated "Use Code.eval_quoted/3 instead"
+  def eval_quoted(module_or_env, quoted, binding \\ [], opts \\ [])
 
-  """
-  def eval_quoted(module, quoted, binding \\ [], opts \\ [])
+  def eval_quoted(%Macro.Env{} = env, quoted, binding, opts)
+      when is_list(binding) and is_list(opts) do
+    validated_eval_quoted(env.module, quoted, binding, struct!(env, opts))
+  end
 
-  def eval_quoted(%Macro.Env{} = env, quoted, binding, opts) do
-    eval_quoted(env.module, quoted, binding, Keyword.merge(Map.to_list(env), opts))
+  def eval_quoted(module, quoted, binding, %Macro.Env{} = env)
+      when is_atom(module) and is_list(binding) do
+    validated_eval_quoted(module, quoted, binding, env)
   end
 
-  def eval_quoted(module, quoted, binding, %Macro.Env{} = env) do
-    eval_quoted(module, quoted, binding, Map.to_list(env))
+  def eval_quoted(module, quoted, binding, opts)
+      when is_atom(module) and is_list(binding) and is_list(opts) do
+    validated_eval_quoted(module, quoted, binding, opts)
   end
 
-  def eval_quoted(module, quoted, binding, opts) do
-    assert_not_compiled!(:eval_quoted, module)
+  defp validated_eval_quoted(module, quoted, binding, env_or_opts) do
+    assert_not_compiled!({:eval_quoted, 4}, module, :all)
     :elixir_def.reset_last(module)
-    {value, binding, _env, _scope} =
-      :elixir.eval_quoted quoted, binding, Keyword.put(opts, :module, module)
+    env = :elixir.env_for_eval(env_or_opts)
+    {value, binding, _env} = :elixir.eval_quoted(quoted, binding, %{env | module: module})
     {value, binding}
   end
 
@@ -363,7 +894,17 @@ defmodule Module do
   the given quoted expressions.
 
   The line where the module is defined and its file **must**
-  be passed as options.
+  be passed as options. See `Code.env_for_eval/1` for a complete
+  list of options.
+
+  It returns a tuple of shape `{:module, module, binary, term}`
+  where `module` is the module name, `binary` is the module
+  bytecode and `term` is the result of the last expression in
+  `quoted`.
+
+  Similar to `Kernel.defmodule/2`, the binary will only be
+  written to disk as a `.beam` file if `Module.create/3` is
+  invoked in a file that is currently being compiled.
 
   ## Examples
 
@@ -374,37 +915,55 @@ defmodule Module do
 
       Module.create(Hello, contents, Macro.Env.location(__ENV__))
 
-      Hello.world #=> true
+      Hello.world()
+      #=> true
 
   ## Differences from `defmodule`
 
-  `Module.create` works similarly to `defmodule` and
-  return the same results. While one could also use
-  `defmodule` to define modules dynamically, this
-  function is preferred when the module body is given
-  by a quoted expression.
+  `Module.create/3` works similarly to `Kernel.defmodule/2`
+  and return the same results. While one could also use
+  `Kernel.defmodule/2` to define modules dynamically, this function
+  is preferred when the module body is given by a quoted
+  expression.
 
-  Another important distinction is that `Module.create`
+  Another important distinction is that `Module.create/3`
   allows you to control the environment variables used
-  when defining the module, while `defmodule` automatically
-  shares the same environment.
+  when defining the module, while `Kernel.defmodule/2`
+  automatically uses the environment it is invoked at.
   """
+  @spec create(module, Macro.t(), Macro.Env.t() | create_opts) :: {:module, module, binary, term}
   def create(module, quoted, opts)
 
-  def create(module, quoted, %Macro.Env{} = env) do
-    create(module, quoted, Map.to_list(env))
+  def create(module, quoted, %Macro.Env{} = env) when is_atom(module) do
+    create([line: env.line], module, quoted, env)
   end
 
   def create(module, quoted, opts) when is_atom(module) and is_list(opts) do
-    unless Keyword.has_key?(opts, :file) do
+    if not Keyword.has_key?(opts, :file) do
       raise ArgumentError, "expected :file to be given as option"
     end
-    :elixir_module.compile(module, quoted, [], :elixir.env_for_eval(opts))
+
+    meta = Keyword.take(opts, [:line, :generated])
+    create(meta, module, quoted, :elixir.env_for_eval(opts))
+  end
+
+  defp create(meta, module, quoted, env_or_opts) do
+    next = :elixir_module.next_counter(nil)
+    quoted = :elixir_quote.linify_with_context_counter(meta, {module, next}, quoted)
+    :elixir_module.compile(meta, module, quoted, [], false, :elixir.env_for_eval(env_or_opts))
   end
 
   @doc """
   Concatenates a list of aliases and returns a new alias.
 
+  It handles binaries and atoms.
+
+  > #### Untracked compile-time dependencies {. :warning}
+  >
+  > Use this function with care, as dynamically defining
+  > module names at compilation time may lead to
+  > [untracked compile-time dependencies](macro-anti-patterns.md#untracked-compile-time-dependencies).
+
   ## Examples
 
       iex> Module.concat([Foo, Bar])
@@ -422,6 +981,15 @@ defmodule Module do
   @doc """
   Concatenates two aliases and returns a new alias.
 
+  It handles binaries and atoms. If one of the aliases
+  is nil, it is discarded.
+
+  > #### Untracked compile-time dependencies {. :warning}
+  >
+  > Use this function with care, as dynamically defining
+  > module names at compilation time may lead to
+  > [untracked compile-time dependencies](macro-anti-patterns.md#untracked-compile-time-dependencies).
+
   ## Examples
 
       iex> Module.concat(Foo, Bar)
@@ -430,167 +998,217 @@ defmodule Module do
       iex> Module.concat(Foo, "Bar")
       Foo.Bar
 
+      iex> Module.concat(Foo, nil)
+      Foo
+
   """
   @spec concat(binary | atom, binary | atom) :: atom
-  def concat(left, right) do
+  def concat(left, right)
+      when (is_binary(left) or is_atom(left)) and (is_binary(right) or is_atom(right)) do
     :elixir_aliases.concat([left, right])
   end
 
   @doc """
-  Concatenates a list of aliases and returns a new alias only
-  if the alias was already referenced. If the alias was not
-  referenced yet, fails with `ArgumentError`.
-  It handles char lists, binaries and atoms.
+  Concatenates a list of aliases and returns a new alias only if the alias
+  was already referenced.
 
-  ## Examples
+  If the alias was not referenced yet, fails with `ArgumentError`.
+  It handles binaries and atoms.
+
+  > #### Untracked compile-time dependencies {. :warning}
+  >
+  > Use this function with care, as dynamically defining
+  > module names at compilation time may lead to
+  > [untracked compile-time dependencies](macro-anti-patterns.md#untracked-compile-time-dependencies).
 
-      iex> Module.safe_concat([Unknown, Module])
-      ** (ArgumentError) argument error
+  ## Examples
 
       iex> Module.safe_concat([List, Chars])
       List.Chars
 
   """
-  @spec safe_concat([binary | atom]) :: atom | no_return
+  @spec safe_concat([binary | atom]) :: atom
   def safe_concat(list) when is_list(list) do
     :elixir_aliases.safe_concat(list)
   end
 
   @doc """
-  Concatenates two aliases and returns a new alias only
-  if the alias was already referenced. If the alias was not
-  referenced yet, fails with `ArgumentError`.
-  It handles char lists, binaries and atoms.
+  Concatenates two aliases and returns a new alias only if the alias was
+  already referenced.
 
-  ## Examples
+  If the alias was not referenced yet, fails with `ArgumentError`.
+  It handles binaries and atoms.
 
-      iex> Module.safe_concat(Unknown, Module)
-      ** (ArgumentError) argument error
+  > #### Untracked compile-time dependencies {. :warning}
+  >
+  > Use this function with care, as dynamically defining
+  > module names at compilation time may lead to
+  > [untracked compile-time dependencies](macro-anti-patterns.md#untracked-compile-time-dependencies).
+
+  ## Examples
 
       iex> Module.safe_concat(List, Chars)
       List.Chars
 
   """
-  @spec safe_concat(binary | atom, binary | atom) :: atom | no_return
-  def safe_concat(left, right) do
+  @spec safe_concat(binary | atom, binary | atom) :: atom
+  def safe_concat(left, right)
+      when (is_binary(left) or is_atom(left)) and (is_binary(right) or is_atom(right)) do
     :elixir_aliases.safe_concat([left, right])
   end
 
-  @doc """
-  Gets an anonymous function from the given module, function
-  and arity. The module and function are not verified to exist.
+  # Build signatures to be stored in docs
 
-      iex> fun = Module.function(Kernel, :is_atom, 1)
-      iex> fun.(:hello)
-      true
+  defp build_signature(args, env) do
+    {reverse_args, counters} = simplify_args(args, %{}, [], env)
+    expand_keys(reverse_args, counters, [])
+  end
 
-  """
-  def function(mod, fun, arity) do
-    :erlang.make_fun(mod, fun, arity)
+  defp simplify_args([arg | args], counters, acc, env) do
+    {arg, counters} = simplify_arg(arg, counters, env)
+    simplify_args(args, counters, [arg | acc], env)
   end
 
-  @doc """
-  Attaches documentation to a given function or type. It expects
-  the module the function/type belongs to, the line (a non negative
-  integer), the kind (`def` or `defmacro`), a tuple representing
-  the function and its arity, the function signature (the signature
-  should be omitted for types) and the documentation, which should
-  be either a binary or a boolean.
+  defp simplify_args([], counters, reverse_args, _env) do
+    {reverse_args, counters}
+  end
 
-  ## Examples
+  defp simplify_arg({:\\, _, [left, right]}, counters, env) do
+    {left, counters} = simplify_arg(left, counters, env)
 
-      defmodule MyModule do
-        Module.add_doc(__MODULE__, __ENV__.line + 1, :def, {:version, 0}, [], "Manually added docs")
-        def version, do: 1
-      end
+    right =
+      Macro.prewalk(right, fn
+        {:@, _, _} = attr -> Macro.expand_once(attr, env)
+        other -> other
+      end)
 
-  """
-  def add_doc(module, line, kind, tuple, signature \\ [], doc)
+    {{:\\, [], [left, right]}, counters}
+  end
 
-  def add_doc(_module, _line, kind, _tuple, _signature, doc) when kind in [:defp, :defmacrop, :typep] do
-    if doc, do: {:error, :private_doc}, else: :ok
+  # If the variable is being used explicitly for naming,
+  # we always give it a higher priority (nil) even if it
+  # starts with underscore.
+  defp simplify_arg({:=, _, [{var, _, atom}, _]}, counters, _env) when is_atom(atom) do
+    {simplify_var(var, nil), counters}
   end
 
-  def add_doc(module, line, kind, tuple, signature, doc) when
-      kind in [:def, :defmacro, :type, :opaque] and (is_binary(doc) or is_boolean(doc) or doc == nil) do
-    assert_not_compiled!(:add_doc, module)
-    table = docs_table_for(module)
+  defp simplify_arg({:=, _, [_, {var, _, atom}]}, counters, _env) when is_atom(atom) do
+    {simplify_var(var, nil), counters}
+  end
 
-    {signature, _} = :lists.mapfoldl fn(x, acc) ->
-      {simplify_signature(x, acc), acc + 1}
-    end, 1, signature
+  # If we have only the variable as argument, it also gets
+  # higher priority. However, if the variable starts with an
+  # underscore, we give it a secondary context (Elixir) with
+  # lower priority.
+  defp simplify_arg({var, _, atom}, counters, _env) when is_atom(atom) do
+    {simplify_var(var, Elixir), counters}
+  end
 
-    case :ets.lookup(table, tuple) do
-      [] ->
-        :ets.insert(table, {tuple, line, kind, signature, doc})
-        :ok
-      [{tuple, line, _old_kind, old_sign, old_doc}] ->
-        :ets.insert(table, {
-          tuple,
-          line,
-          kind,
-          merge_signatures(old_sign, signature, 1),
-          if(nil?(doc), do: old_doc, else: doc)
-       })
-        :ok
+  defp simplify_arg({:%, _, [left, _]}, counters, env) do
+    case Macro.expand_once(left, env) do
+      module when is_atom(module) -> autogenerated_key(counters, simplify_module_name(module))
+      _ -> autogenerated_key(counters, :struct)
     end
   end
 
-  # Simplify signatures to be stored in docs
-
-  defp simplify_signature({:\\, _, [left, right ]}, i) do
-    {:\\, [], [simplify_signature(left, i), right]}
+  defp simplify_arg({:%{}, _, _}, counters, _env) do
+    autogenerated_key(counters, :map)
   end
 
-  defp simplify_signature({:%, _, [left, _]}, _i) when is_atom(left) do
-    last = List.last(String.split(Atom.to_string(left), "."))
-    atom = String.to_atom(downcase(last))
-    {atom, [], nil}
+  defp simplify_arg({:@, _, _} = attr, counters, env) do
+    simplify_arg(Macro.expand_once(attr, env), counters, env)
   end
 
-  defp simplify_signature({:=, _, [_, right]}, i) do
-    simplify_signature(right, i)
+  defp simplify_arg({:var!, _, [{var, _, atom} | _]}, counters, _env) when is_atom(atom) do
+    {simplify_var(var, Elixir), counters}
   end
 
-  defp simplify_signature({var, _, atom}, _i) when is_atom(atom) do
+  defp simplify_arg(other, counters, _env) when is_integer(other),
+    do: autogenerated_key(counters, :int)
+
+  defp simplify_arg(other, counters, _env) when is_boolean(other),
+    do: autogenerated_key(counters, :bool)
+
+  defp simplify_arg(other, counters, _env) when is_atom(other),
+    do: autogenerated_key(counters, :atom)
+
+  defp simplify_arg(other, counters, _env) when is_list(other),
+    do: autogenerated_key(counters, :list)
+
+  defp simplify_arg(other, counters, _env) when is_float(other),
+    do: autogenerated_key(counters, :float)
+
+  defp simplify_arg(other, counters, _env) when is_binary(other),
+    do: autogenerated_key(counters, :binary)
+
+  defp simplify_arg(_, counters, _env), do: autogenerated_key(counters, :arg)
+
+  defp simplify_var(var, guess_priority) do
     case Atom.to_string(var) do
-      "_" <> rest -> {String.to_atom(rest), [], Elixir}
-      _           -> {var, [], nil}
+      "_" -> {:_, [], guess_priority}
+      "_" <> rest -> {String.to_atom(rest), [], guess_priority}
+      _ -> {var, [], nil}
+    end
+  end
+
+  defp simplify_module_name(module) when is_atom(module) do
+    try do
+      split(module)
+    rescue
+      ArgumentError -> module
+    else
+      module_name -> String.to_atom(Macro.underscore(List.last(module_name)))
     end
   end
 
-  defp simplify_signature(other, i) when is_integer(other), do: {:"int#{i}", [], Elixir}
-  defp simplify_signature(other, i) when is_boolean(other), do: {:"bool#{i}", [], Elixir}
-  defp simplify_signature(other, i) when is_atom(other),    do: {:"atom#{i}", [], Elixir}
-  defp simplify_signature(other, i) when is_list(other),    do: {:"list#{i}", [], Elixir}
-  defp simplify_signature(other, i) when is_float(other),   do: {:"float#{i}", [], Elixir}
-  defp simplify_signature(other, i) when is_binary(other),  do: {:"binary#{i}", [], Elixir}
-  defp simplify_signature(_, i), do: {:"arg#{i}", [], Elixir}
+  defp autogenerated_key(counters, key) do
+    case counters do
+      %{^key => :once} -> {key, %{counters | key => 2}}
+      %{^key => value} -> {key, %{counters | key => value + 1}}
+      %{} -> {key, Map.put(counters, key, :once)}
+    end
+  end
+
+  defp expand_keys([{:\\, meta, [key, default]} | keys], counters, acc) when is_atom(key) do
+    {var, counters} = expand_key(key, counters)
+    expand_keys(keys, counters, [{:\\, meta, [var, default]} | acc])
+  end
+
+  defp expand_keys([key | keys], counters, acc) when is_atom(key) do
+    {var, counters} = expand_key(key, counters)
+    expand_keys(keys, counters, [var | acc])
+  end
 
-  defp downcase(<<c :: utf8, rest :: binary>>) when c >= ?A and c <= ?Z do
-    <<c + 32 :: utf8, downcase(rest) :: binary>>
+  defp expand_keys([arg | args], counters, acc) do
+    expand_keys(args, counters, [arg | acc])
   end
 
-  defp downcase(<<c, rest :: binary>>) do
-    <<c, downcase(rest) :: binary>>
+  defp expand_keys([], _counters, acc) do
+    acc
   end
 
-  defp downcase(<<>>) do
-    <<>>
+  defp expand_key(key, counters) do
+    case counters do
+      %{^key => count} when is_integer(count) and count >= 1 ->
+        {{:"#{key}#{count}", [], Elixir}, Map.put(counters, key, count - 1)}
+
+      _ ->
+        {{key, [], Elixir}, counters}
+    end
   end
 
   # Merge
 
-  defp merge_signatures([h1|t1], [h2|t2], i) do
-    [merge_signature(h1, h2, i)|merge_signatures(t1, t2, i + 1)]
+  defp merge_signatures([h1 | t1], [h2 | t2], i) do
+    [merge_signature(h1, h2, i) | merge_signatures(t1, t2, i + 1)]
   end
 
   defp merge_signatures([], [], _) do
     []
   end
 
-  defp merge_signature({:\\, line, [left, right]}, newer, i) do
-    {:\\, line, [merge_signature(left, newer, i), right]}
+  defp merge_signature({:\\, meta, [left, right]}, newer, i) do
+    {:\\, meta, [merge_signature(left, newer, i), right]}
   end
 
   defp merge_signature(older, {:\\, _, [left, _]}, i) do
@@ -598,270 +1216,551 @@ defmodule Module do
   end
 
   # The older signature, when given, always have higher precedence
-  defp merge_signature({_, _, nil} = older, _newer, _),        do: older
-  defp merge_signature(_older, {_, _, nil} = newer, _),        do: newer
+  defp merge_signature({_, _, nil} = older, _newer, _), do: older
+  defp merge_signature(_older, {_, _, nil} = newer, _), do: newer
 
   # Both are a guess, so check if they are the same guess
   defp merge_signature({var, _, _} = older, {var, _, _}, _), do: older
 
   # Otherwise, returns a generic guess
-  defp merge_signature({_, line, _}, _newer, i), do: {:"arg#{i}", line, Elixir}
+  defp merge_signature({_, meta, _}, _newer, i), do: {:"arg#{i}", meta, Elixir}
 
   @doc """
   Checks if the module defines the given function or macro.
+
   Use `defines?/3` to assert for a specific type.
 
+  This function can only be used on modules that have not yet been compiled.
+  Use `Kernel.function_exported?/3` and `Kernel.macro_exported?/3` to check for
+  public functions and macros respectively in compiled modules.
+
+  Note that `defines?` returns `false` for functions and macros that have
+  been defined but then marked as overridable and no other implementation
+  has been provided. You can check the overridable status by calling
+  `overridable?/2`.
+
   ## Examples
 
       defmodule Example do
-        Module.defines? __MODULE__, {:version, 0} #=> false
+        Module.defines?(__MODULE__, {:version, 0}) #=> false
         def version, do: 1
-        Module.defines? __MODULE__, {:version, 0} #=> true
+        Module.defines?(__MODULE__, {:version, 0}) #=> true
       end
 
   """
-  def defines?(module, tuple) when is_tuple(tuple) do
-    assert_not_compiled!(:defines?, module)
-    table = function_table_for(module)
-    :ets.lookup(table, tuple) != []
+  @spec defines?(module, definition) :: boolean
+  def defines?(module, {name, arity} = tuple)
+      when is_atom(module) and is_atom(name) and is_integer(arity) and arity >= 0 and arity <= 255 do
+    {set, _bag} = data_tables_for!(module, __ENV__.function, @extra_error_msg_defines?)
+    :ets.member(set, {:def, tuple})
   end
 
   @doc """
   Checks if the module defines a function or macro of the
-  given `kind`. `kind` can be any of `:def`, `:defp`,
-  `:defmacro` or `:defmacrop`.
+  given `kind`.
+
+  `kind` can be any of `:def`, `:defp`, `:defmacro`, or `:defmacrop`.
+
+  This function can only be used on modules that have not yet been compiled.
+  Use `Kernel.function_exported?/3` and `Kernel.macro_exported?/3` to check for
+  public functions and macros respectively in compiled modules.
 
   ## Examples
 
       defmodule Example do
-        Module.defines? __MODULE__, {:version, 0}, :defp #=> false
+        Module.defines?(__MODULE__, {:version, 0}, :def) #=> false
         def version, do: 1
-        Module.defines? __MODULE__, {:version, 0}, :defp #=> false
+        Module.defines?(__MODULE__, {:version, 0}, :def) #=> true
       end
 
   """
-  def defines?(module, tuple, kind) do
-    assert_not_compiled!(:defines?, module)
-    table = function_table_for(module)
-    case :ets.lookup(table, tuple) do
-      [{_, ^kind, _, _, _, _, _}] -> true
+  @spec defines?(module, definition, def_kind) :: boolean
+  def defines?(module, {name, arity} = tuple, def_kind)
+      when is_atom(module) and is_atom(name) and is_integer(arity) and arity >= 0 and arity <= 255 and
+             def_kind in [:def, :defp, :defmacro, :defmacrop] do
+    {set, _bag} = data_tables_for!(module, __ENV__.function, @extra_error_msg_defines?)
+
+    case :ets.lookup(set, {:def, tuple}) do
+      [{_, ^def_kind, _, _, _, _}] -> true
       _ -> false
     end
   end
 
   @doc """
-  Return all functions defined in `module`.
+  Checks if the current module defines the given type (private, opaque or not).
 
-  ## Examples
+  This function is only available for modules being compiled.
+  """
+  @doc since: "1.7.0"
+  @spec defines_type?(module, definition) :: boolean
+  def defines_type?(module, definition) when is_atom(module) do
+    Kernel.Typespec.defines_type?(module, definition)
+  end
 
-      defmodule Example do
-        def version, do: 1
-        Module.definitions_in __MODULE__ #=> [{:version,0}]
-      end
+  @doc """
+  Copies the given spec as a callback.
 
+  Returns `true` if there is such a spec and it was copied as a callback.
+  If the function associated to the spec has documentation defined prior to
+  invoking this function, the docs are copied too.
   """
-  def definitions_in(module) do
-    assert_not_compiled!(:definitions_in, module)
-    table = function_table_for(module)
-    for {tuple, _, _, _, _, _, _} <- :ets.tab2list(table), do: tuple
+  @doc since: "1.7.0"
+  @spec spec_to_callback(module, definition) :: boolean
+  def spec_to_callback(module, definition) do
+    Kernel.Typespec.spec_to_callback(module, definition)
   end
 
   @doc """
-  Returns all functions defined in `module`, according
-  to its kind.
+  Returns all module attributes names defined in `module`.
+
+  This function can only be used on modules that have not yet been compiled.
 
   ## Examples
 
       defmodule Example do
-        def version, do: 1
-        Module.definitions_in __MODULE__, :def  #=> [{:version,0}]
-        Module.definitions_in __MODULE__, :defp #=> []
+        @foo 1
+        Module.register_attribute(__MODULE__, :bar, accumulate: true)
+
+        :foo in Module.attributes_in(__MODULE__)
+        #=> true
+
+        :bar in Module.attributes_in(__MODULE__)
+        #=> true
       end
 
   """
-  def definitions_in(module, kind) do
-    assert_not_compiled!(:definitions_in, module)
-    table = function_table_for(module)
-    for {tuple, stored_kind, _, _, _, _, _} <- :ets.tab2list(table), stored_kind == kind, do: tuple
+  @doc since: "1.13.0"
+  @spec attributes_in(module) :: [atom]
+  def attributes_in(module) when is_atom(module) do
+    {set, _} = data_tables_for!(module, __ENV__.function, "")
+    :ets.select(set, [{{:"$1", :_, :_, :_}, [{:is_atom, :"$1"}], [:"$1"]}])
   end
 
   @doc """
-  Makes the given functions in `module` overridable.
-  An overridable function is lazily defined, allowing a
+  Returns all overridable definitions in `module`.
+
+  Note a definition is included even if it was was already overridden.
+  You can use `defines?/2` to see if a definition exists or one is pending.
+
+  This function can only be used on modules that have not yet been compiled.
+
+  ## Examples
+
+      defmodule Example do
+        def foo, do: 1
+        def bar, do: 2
+
+        defoverridable foo: 0, bar: 0
+        def foo, do: 3
+
+        [bar: 0, foo: 0] = Module.overridables_in(__MODULE__) |> Enum.sort()
+      end
+
+  """
+  @doc since: "1.13.0"
+  @spec overridables_in(module) :: [atom]
+  def overridables_in(module) when is_atom(module) do
+    assert_not_compiled!(__ENV__.function, module, :all)
+    :elixir_overridable.overridables_for(module)
+  end
+
+  @doc """
+  Returns all functions and macros defined in `module`.
+
+  It returns a list with all defined functions and macros, public and private,
+  in the shape of `[{name, arity}, ...]`.
+
+  This function can only be used on modules that have not yet been compiled.
+  Use the `c:Module.__info__/1` callback to get the public functions and macros in
+  compiled modules.
+
+  ## Examples
+
+      defmodule Example do
+        def version, do: 1
+        defmacrop test(arg), do: arg
+        Module.definitions_in(__MODULE__) #=> [{:version, 0}, {:test, 1}]
+      end
+
+  """
+  @spec definitions_in(module) :: [definition]
+  def definitions_in(module) when is_atom(module) do
+    {_, bag} = data_tables_for!(module, __ENV__.function, @extra_error_msg_definitions_in)
+    bag_lookup_element(bag, :defs, 2)
+  end
+
+  @doc """
+  Returns all functions defined in `module`, according
+  to its kind.
+
+  This function can only be used on modules that have not yet been compiled.
+  Use the `c:Module.__info__/1` callback to get the public functions and macros in
+  compiled modules.
+
+  ## Examples
+
+      defmodule Example do
+        def version, do: 1
+        Module.definitions_in(__MODULE__, :def)  #=> [{:version, 0}]
+        Module.definitions_in(__MODULE__, :defp) #=> []
+      end
+
+  """
+  @spec definitions_in(module, def_kind) :: [definition]
+  def definitions_in(module, kind)
+      when is_atom(module) and kind in [:def, :defp, :defmacro, :defmacrop] do
+    {set, _} = data_tables_for!(module, __ENV__.function, @extra_error_msg_definitions_in)
+    :ets.select(set, [{{{:def, :"$1"}, kind, :_, :_, :_, :_}, [], [:"$1"]}])
+  end
+
+  @doc """
+  Returns the definition for the given name-arity pair.
+
+  It returns a tuple with the `version`, the `kind`,
+  the definition `metadata`, and a list with each clause.
+  Each clause is a four-element tuple with metadata,
+  the arguments, the guards, and the clause AST.
+
+  The clauses are returned in the Elixir AST but a subset
+  that has already been expanded and normalized. This makes
+  it useful for analyzing code but it cannot be reinjected
+  into the module as it will have lost some of its original
+  context. Given this AST representation is mostly internal,
+  it is versioned and it may change at any time. Therefore,
+  **use this API with caution**.
+
+  ## Options
+
+    * `:skip_clauses` (since v1.14.0) - returns `[]` instead
+      of returning the clauses. This is useful when there is
+      only an interest in fetching the kind and the metadata
+
+  """
+  @spec get_definition(module, definition, get_definition_opts) ::
+          {:v1, def_kind, meta :: keyword,
+           [{meta :: keyword, arguments :: [Macro.t()], guards :: [Macro.t()], Macro.t()}]}
+          | nil
+  @doc since: "1.12.0"
+  def get_definition(module, {name, arity}, options \\ [])
+      when is_atom(module) and is_atom(name) and is_integer(arity) and is_list(options) do
+    {set, bag} = data_tables_for!(module, __ENV__.function, "")
+
+    case :ets.lookup(set, {:def, {name, arity}}) do
+      [{_key, kind, meta, _, _, _}] ->
+        clauses =
+          if options[:skip_clauses],
+            do: [],
+            else: bag_lookup_element(bag, {:clauses, {name, arity}}, 2)
+
+        {:v1, kind, meta, clauses}
+
+      [] ->
+        nil
+    end
+  end
+
+  @doc """
+  Deletes a definition from a module.
+
+  It returns `true` if the definition exists and it was removed,
+  otherwise it returns `false`.
+  """
+  @doc since: "1.12.0"
+  @spec delete_definition(module, definition) :: boolean()
+  def delete_definition(module, {name, arity})
+      when is_atom(module) and is_atom(name) and is_integer(arity) do
+    assert_not_compiled!(__ENV__.function, module, :writeable)
+    :elixir_def.take_definition(module, {name, arity}) != false
+  end
+
+  @doc """
+  Makes the given functions in `module` overridable.
+
+  An overridable function is lazily defined, allowing a
   developer to customize it. See `Kernel.defoverridable/1` for
   more information and documentation.
+
+  Once a function or a macro is marked as overridable, it will
+  no longer be listed under `definitions_in/1` or return true
+  when given to `defines?/2` until another implementation is
+  given.
   """
-  def make_overridable(module, tuples) do
-    assert_not_compiled!(:make_overridable, module)
-
-    for tuple <- tuples do
-      case :elixir_def.lookup_definition(module, tuple) do
-        false ->
-          {name, arity} = tuple
-          raise "Cannot make function #{name}/#{arity} overridable because it was not defined"
-        clause ->
-          :elixir_def.delete_definition(module, tuple)
-
-          neighbours = if loaded?(Module.LocalsTracker) do
-            Module.LocalsTracker.yank(module, tuple)
-          else
-            []
-          end
+  @spec make_overridable(module, [definition]) :: :ok
+  def make_overridable(module, tuples) when is_atom(module) and is_list(tuples) do
+    assert_not_compiled!(__ENV__.function, module, :writeable)
+
+    func = fn
+      {function_name, arity} = tuple
+      when is_atom(function_name) and is_integer(arity) and arity >= 0 and arity <= 255 ->
+        case :elixir_def.take_definition(module, tuple) do
+          false ->
+            raise ArgumentError,
+                  "cannot make function #{function_name}/#{arity} " <>
+                    "overridable because it was not defined"
+
+          clause ->
+            :elixir_overridable.record_overridable(module, tuple, clause)
+        end
 
-          old    = get_attribute(module, :__overridable)
-          merged = :orddict.update(tuple, fn({count, _, _, _}) ->
-            {count + 1, clause, neighbours, false}
-          end, {1, clause, neighbours, false}, old)
+      other ->
+        raise ArgumentError,
+              "each element in tuple list has to be a " <>
+                "{function_name :: atom, arity :: 0..255} tuple, got: #{inspect(other)}"
+    end
 
-          put_attribute(module, :__overridable, merged)
-      end
+    :lists.foreach(func, tuples)
+  end
+
+  @spec make_overridable(module, module) :: :ok
+  def make_overridable(module, behaviour) when is_atom(module) and is_atom(behaviour) do
+    {_, bag} = data_tables_for!(module, __ENV__.function, "")
+
+    case check_module_for_overridable(bag, behaviour) do
+      :ok ->
+        :ok
+
+      {:error, error_explanation} ->
+        raise ArgumentError,
+              "cannot pass module #{inspect(behaviour)} as argument " <>
+                "to defoverridable/1 because #{error_explanation}"
+    end
+
+    behaviour_callbacks = Module.Behaviour.callbacks(behaviour)
+
+    tuples =
+      for definition <- definitions_in(module),
+          definition in behaviour_callbacks,
+          do: definition
+
+    make_overridable(module, tuples)
+  end
+
+  defp check_module_for_overridable(bag, behaviour) do
+    behaviour_definitions = bag_lookup_element(bag, {:accumulate, :behaviour}, 2)
+
+    cond do
+      not Code.ensure_loaded?(behaviour) ->
+        {:error, "it was not defined"}
+
+      not function_exported?(behaviour, :behaviour_info, 1) ->
+        {:error, "it does not define any callbacks"}
+
+      behaviour not in behaviour_definitions ->
+        error_message =
+          "its corresponding behaviour is missing. Did you forget to " <>
+            "add @behaviour #{inspect(behaviour)}?"
+
+        {:error, error_message}
+
+      true ->
+        :ok
     end
   end
 
   @doc """
-  Returns `true` if `tuple` in `module` is marked as overridable.
+  Returns `true` if `tuple` in `module` was marked as overridable
+  at some point.
+
+  Note `overridable?/2` returns `true` even if the definition was
+  already overridden. You can use `defines?/2` to see if a definition
+  exists or one is pending.
   """
-  def overridable?(module, tuple) do
-    !!List.keyfind(get_attribute(module, :__overridable), tuple, 0)
+  @spec overridable?(module, definition) :: boolean
+  def overridable?(module, {function_name, arity} = tuple)
+      when is_atom(function_name) and is_integer(arity) and arity >= 0 and arity <= 255 do
+    :elixir_overridable.overridable_for(module, tuple) != :not_overridable
   end
 
   @doc """
-  Puts an Erlang attribute to the given module with the given
-  key and value. The semantics of putting the attribute depends
-  if the attribute was registered or not via `register_attribute/3`.
+  Puts a module attribute with `key` and `value` in the given `module`.
 
   ## Examples
 
       defmodule MyModule do
-        Module.put_attribute __MODULE__, :custom_threshold_for_lib, 10
+        Module.put_attribute(__MODULE__, :custom_threshold_for_lib, 10)
       end
 
   """
-  def put_attribute(module, key, value) when is_atom(key) do
-    assert_not_compiled!(:put_attribute, module)
-    table = data_table_for(module)
-    value = normalize_attribute(key, value)
-    acc   = :ets.lookup_element(table, :__acc_attributes, 2)
-
-    new =
-      if :lists.member(key, acc) do
-        case :ets.lookup(table, key) do
-          [{^key, old}] -> [value|old]
-          [] -> [value]
-        end
-      else
-        value
-      end
-
-    :ets.insert(table, {key, new})
+  @spec put_attribute(module, atom, term) :: :ok
+  def put_attribute(module, key, value) when is_atom(module) and is_atom(key) do
+    __put_attribute__(module, key, value, nil, [])
   end
 
   @doc """
-  Gets the given attribute from a module. If the attribute
-  was marked with `accumulate` with `Module.register_attribute/3`,
-  a list is always returned.
+  Gets the given attribute from a module.
+
+  If the attribute was marked with `accumulate` with
+  `Module.register_attribute/3`, a list is always returned.
+  `nil` is returned if the attribute has not been marked with
+  `accumulate` and has not been set to any value.
 
   The `@` macro compiles to a call to this function. For example,
   the following code:
 
       @foo
 
-  Expands to:
+  Expands to something akin to:
 
-      Module.get_attribute(__MODULE__, :foo, true)
+      Module.get_attribute(__MODULE__, :foo)
 
-  Notice the third argument may be given to indicate a stacktrace
-  to be emitted when the attribute was not previously defined.
-  The default value for `warn` is nil for direct calls but the `@foo`
-  macro sets it to the proper stacktrace automatically, warning
-  every time `@foo` is used but not set previously.
+  This function can only be used on modules that have not yet been compiled.
+  Use the `c:Module.__info__/1` callback to get all persisted attributes, or
+  `Code.fetch_docs/1` to retrieve all documentation related attributes in
+  compiled modules.
 
   ## Examples
 
       defmodule Foo do
-        Module.put_attribute __MODULE__, :value, 1
-        Module.get_attribute __MODULE__, :value #=> 1
+        Module.put_attribute(__MODULE__, :value, 1)
+        Module.get_attribute(__MODULE__, :value) #=> 1
+
+        Module.get_attribute(__MODULE__, :value, :default) #=> 1
+        Module.get_attribute(__MODULE__, :not_found, :default) #=> :default
 
-        Module.register_attribute __MODULE__, :value, accumulate: true
-        Module.put_attribute __MODULE__, :value, 1
-        Module.get_attribute __MODULE__, :value #=> [1]
+        Module.register_attribute(__MODULE__, :value, accumulate: true)
+        Module.put_attribute(__MODULE__, :value, 1)
+        Module.get_attribute(__MODULE__, :value) #=> [1]
       end
 
   """
-  @spec get_attribute(module, atom, warn :: nil | [tuple]) :: term
-  def get_attribute(module, key, warn \\ nil) when
-      is_atom(key) and (is_list(warn) or nil?(warn)) do
-    assert_not_compiled!(:get_attribute, module)
-    table = data_table_for(module)
-
-    case :ets.lookup(table, key) do
-      [{^key, val}] -> val
-      [] ->
-        acc = :ets.lookup_element(table, :__acc_attributes, 2)
-
-        cond do
-          :lists.member(key, acc) ->
-            []
-          is_list(warn) ->
-            :elixir_errors.warn warn_info(warn), "undefined module attribute @#{key}, " <>
-              "please remove access to @#{key} or explicitly set it to nil before access\n"
-            nil
-          true ->
-            nil
-        end
-    end
+  @spec get_attribute(module, atom, term) :: term
+  def get_attribute(module, key, default \\ nil) when is_atom(module) and is_atom(key) do
+    get_attribute(module, key, nil, true, false, default, {:get_attribute, 2})
   end
 
-  defp warn_info([entry|_]) do
-    opts = elem(entry, tuple_size(entry) - 1)
-    Exception.format_file_line(Keyword.get(opts, :file), Keyword.get(opts, :line)) <> " "
+  @doc """
+  Gets the last set value of a given attribute from a module.
+
+  If the attribute was marked with `accumulate` with
+  `Module.register_attribute/3`, the previous value to have been set will be
+  returned. If the attribute does not accumulate, this call is the same as
+  calling `Module.get_attribute/3`.
+
+  This function can only be used on modules that have not yet been compiled.
+  Use the `c:Module.__info__/1` callback to get all persisted attributes, or
+  `Code.fetch_docs/1` to retrieve all documentation related attributes in
+  compiled modules.
+
+  ## Examples
+
+      defmodule Foo do
+        Module.put_attribute(__MODULE__, :value, 1)
+        Module.get_last_attribute(__MODULE__, :value) #=> 1
+
+        Module.get_last_attribute(__MODULE__, :not_found, :default) #=> :default
+
+        Module.register_attribute(__MODULE__, :acc, accumulate: true)
+        Module.put_attribute(__MODULE__, :acc, 1)
+        Module.get_last_attribute(__MODULE__, :acc) #=> 1
+        Module.put_attribute(__MODULE__, :acc, 2)
+        Module.get_last_attribute(__MODULE__, :acc) #=> 2
+      end
+
+  """
+  @doc since: "1.15.0"
+  @spec get_last_attribute(module, atom, term) :: term
+  def get_last_attribute(module, key, default \\ nil) when is_atom(module) and is_atom(key) do
+    get_attribute(module, key, nil, true, true, default, {:get_last_attribute, 2})
   end
 
-  defp warn_info([]) do
-    ""
+  @doc """
+  Checks if the given attribute has been defined.
+
+  An attribute is defined if it has been registered with `register_attribute/3`
+  or assigned a value. If an attribute has been deleted with `delete_attribute/2`
+  it is no longer considered defined.
+
+  This function can only be used on modules that have not yet been compiled.
+
+  ## Examples
+
+      defmodule MyModule do
+        @value 1
+        Module.register_attribute(__MODULE__, :other_value)
+        Module.put_attribute(__MODULE__, :another_value, 1)
+
+        Module.has_attribute?(__MODULE__, :value) #=> true
+        Module.has_attribute?(__MODULE__, :other_value) #=> true
+        Module.has_attribute?(__MODULE__, :another_value) #=> true
+
+        Module.has_attribute?(__MODULE__, :undefined) #=> false
+
+        Module.delete_attribute(__MODULE__, :value)
+        Module.has_attribute?(__MODULE__, :value) #=> false
+      end
+
+  """
+  @doc since: "1.10.0"
+  @spec has_attribute?(module, atom) :: boolean
+  def has_attribute?(module, key) when is_atom(module) and is_atom(key) do
+    {set, _bag} = data_tables_for!(module, __ENV__.function, "")
+    :ets.member(set, key)
   end
 
   @doc """
-  Deletes all attributes that match the given key.
+  Deletes the entry (or entries) for the given module attribute.
+
+  It returns the deleted attribute value. If the attribute has not
+  been set nor configured to accumulate, it returns `nil`.
+
+  If the attribute is set to accumulate, then this function always
+  returns a list. Deleting the attribute removes existing entries
+  but the attribute will still accumulate.
 
   ## Examples
 
       defmodule MyModule do
-        Module.put_attribute __MODULE__, :custom_threshold_for_lib, 10
-        Module.delete_attribute __MODULE__, :custom_threshold_for_lib
+        Module.put_attribute(__MODULE__, :custom_threshold_for_lib, 10)
+        Module.delete_attribute(__MODULE__, :custom_threshold_for_lib)
       end
 
   """
-  def delete_attribute(module, key) when is_atom(key) do
-    assert_not_compiled!(:delete_attribute, module)
-    table = data_table_for(module)
-    :ets.delete(table, key)
+  @spec delete_attribute(module, atom) :: term
+  def delete_attribute(module, key) when is_atom(module) and is_atom(key) do
+    {set, bag} = data_tables_for!(module, __ENV__.function, "")
+
+    case :ets.lookup(set, key) do
+      [{_, _, :accumulate, traces}] ->
+        trace_attribute(true, module, traces, set, key, nil, [])
+        reverse_values(:ets.take(bag, {:accumulate, key}), [])
+
+      [{_, value, _, traces}] ->
+        trace_attribute(module, key, nil, traces)
+        :ets.delete(set, key)
+        value
+
+      [] ->
+        nil
+    end
   end
 
+  defp reverse_values([{_, value} | tail], acc), do: reverse_values(tail, [value | acc])
+  defp reverse_values([], acc), do: acc
+
   @doc """
-  Registers an attribute. By registering an attribute, a developer
-  is able to customize how Elixir will store and accumulate the
-  attribute values.
+  Registers an attribute.
+
+  By registering an attribute, a developer is able to customize
+  how Elixir will store and accumulate the attribute values.
 
   ## Options
 
   When registering an attribute, two options can be given:
 
     * `:accumulate` - several calls to the same attribute will
-      accumulate instead of override the previous one. New attributes
+      accumulate instead of overriding the previous one. New attributes
       are always added to the top of the accumulated list.
 
     * `:persist` - the attribute will be persisted in the Erlang
       Abstract Format. Useful when interfacing with Erlang libraries.
 
-  By default, both options are `false`.
+  By default, both options are `false`. Once an attribute has been
+  set to accumulate or persist, the behaviour cannot be reverted.
 
   ## Examples
 
       defmodule MyModule do
-        Module.register_attribute __MODULE__,
-          :custom_threshold_for_lib,
-          accumulate: true, persist: false
+        Module.register_attribute(__MODULE__, :custom_threshold_for_lib, accumulate: true)
 
         @custom_threshold_for_lib 10
         @custom_threshold_for_lib 20
@@ -869,116 +1768,691 @@ defmodule Module do
       end
 
   """
-  def register_attribute(module, new, opts) when is_atom(new) do
-    assert_not_compiled!(:register_attribute, module)
-    table = data_table_for(module)
+  @spec register_attribute(module, atom, [{:accumulate, boolean}, {:persist, boolean}]) :: :ok
+  def register_attribute(module, attribute, options)
+      when is_atom(module) and is_atom(attribute) and is_list(options) do
+    {set, bag} = data_tables_for!(module, __ENV__.function, "")
 
-    if Keyword.get(opts, :persist) do
-      old = :ets.lookup_element(table, :__persisted_attributes, 2)
-      :ets.insert(table, {:__persisted_attributes,  [new|old]})
+    if Keyword.get(options, :persist) do
+      :ets.insert(bag, {:persisted_attributes, attribute})
     end
 
-    if Keyword.get(opts, :accumulate) do
-      old = :ets.lookup_element(table, :__acc_attributes, 2)
-      :ets.insert(table, {:__acc_attributes,  [new|old]})
+    if Keyword.get(options, :accumulate) do
+      :ets.insert_new(set, {attribute, [], :accumulate, []}) ||
+        :ets.update_element(set, attribute, {3, :accumulate})
+    else
+      :ets.insert_new(bag, {:warn_attributes, attribute})
+      :ets.insert_new(set, {attribute, nil, :unset, []})
     end
+
+    :ok
   end
 
   @doc """
-  Split the given module name into binary parts.
+  Splits the given module name into binary parts.
+
+  `module` has to be an Elixir module, as `split/1` won't work with Erlang-style
+  modules (for example, `split(:lists)` raises an error).
+
+  `split/1` also supports splitting the string representation of Elixir modules
+  (that is, the result of calling `Atom.to_string/1` with the module name).
 
   ## Examples
 
-      Module.split Very.Long.Module.Name.And.Even.Longer
-      #=> ["Very", "Long", "Module", "Name", "And", "Even", "Longer"]
+      iex> Module.split(Very.Long.Module.Name.And.Even.Longer)
+      ["Very", "Long", "Module", "Name", "And", "Even", "Longer"]
+      iex> Module.split("Elixir.String.Chars")
+      ["String", "Chars"]
 
   """
-  def split(module) do
-    tl(String.split(String.Chars.to_string(module), "."))
+  @spec split(module | String.t()) :: [String.t(), ...]
+  def split(module)
+
+  def split(module) when is_atom(module) do
+    split(Atom.to_string(module), _original = module)
+  end
+
+  def split(module) when is_binary(module) do
+    split(module, _original = module)
+  end
+
+  defp split("Elixir." <> name, _original) do
+    String.split(name, ".")
+  end
+
+  defp split(_module, original) do
+    raise ArgumentError, "expected an Elixir module, got: #{inspect(original)}"
   end
 
   @doc false
-  # Used internally to compile documentation. This function
-  # is private and must be used only internally.
-  def compile_doc(env, kind, name, args, _guards, _body) do
-    module = env.module
-    line   = env.line
-    arity  = length(args)
-    pair   = {name, arity}
-    doc    = get_attribute(module, :doc)
-
-    case add_doc(module, line, kind, pair, args, doc) do
-      :ok ->
+  @deprecated "Use @doc instead"
+  def add_doc(module, line, kind, {name, arity}, signature \\ [], doc) do
+    if kind in [:defp, :defmacrop, :typep] do
+      if doc, do: {:error, :private_doc}, else: :ok
+    else
+      {set, _bag} = data_tables_for!(module, __ENV__.function, "")
+      compile_doc(set, nil, line, kind, name, arity, signature, nil, doc, %{}, __ENV__, false)
+      :ok
+    end
+  end
+
+  @doc false
+  # Used internally to compile documentation.
+  # This function is private and must be used only internally.
+  def compile_definition_attributes(env, kind, name, args, _guards, body) do
+    %{module: module} = env
+    {set, bag} = data_tables_for!(module, __ENV__.function, "")
+    {arity, defaults} = args_count(args, 0, 0)
+
+    context = Keyword.get(:ets.lookup_element(set, {:def, {name, arity}}, 3), :context)
+    impl = compile_impl(set, bag, context, name, env, kind, arity, defaults)
+    doc_meta = compile_doc_meta(set, bag, name, arity, defaults)
+
+    {line, doc} = get_doc_info(set, env)
+    compile_doc(set, context, line, kind, name, arity, args, body, doc, doc_meta, env, impl)
+
+    :ok
+  end
+
+  defp compile_doc(_table, _ctx, line, kind, name, arity, _args, _body, doc, _meta, env, _impl)
+       when kind in [:defp, :defmacrop] do
+    if doc do
+      message =
+        "#{kind} #{name}/#{arity} is private, " <>
+          "@doc attribute is always discarded for private functions/macros/types"
+
+      IO.warn(message, %{env | line: line})
+    end
+  end
+
+  defp compile_doc(table, ctx, line, kind, name, arity, args, body, doc, doc_meta, env, impl) do
+    key = {doc_key(kind), name, arity}
+    signature = build_signature(args, env)
+
+    case :ets.lookup(table, key) do
+      [] ->
+        doc = if is_nil(doc) && impl, do: false, else: doc
+        :ets.insert(table, {key, ctx, line, signature, doc, doc_meta})
+
+      [{_, current_ctx, current_line, current_sign, current_doc, current_doc_meta}] ->
+        if is_binary(current_doc) and is_binary(doc) and body != nil and is_nil(current_ctx) do
+          message = ~s'''
+          redefining @doc attribute previously set at line #{current_line}.
+
+          Please remove the duplicate docs. If instead you want to override a \
+          previously defined @doc, attach the @doc attribute to a function head \
+          (the function signature not followed by any do-block). For example:
+
+              @doc """
+              new docs
+              """
+              def #{name}(...)
+          '''
+
+          IO.warn(message, %{env | line: line})
+        end
+
+        signature = merge_signatures(current_sign, signature, 1)
+        doc = if is_nil(doc), do: current_doc, else: doc
+        doc = if is_nil(doc) && impl, do: false, else: doc
+        doc_meta = Map.merge(current_doc_meta, doc_meta)
+        :ets.insert(table, {key, ctx, current_line, signature, doc, doc_meta})
+    end
+  end
+
+  defp doc_key(:def), do: :function
+  defp doc_key(:defmacro), do: :macro
+
+  defp compile_doc_meta(set, bag, name, arity, defaults) do
+    doc_meta = compile_deprecated(%{}, set, bag, name, arity, defaults)
+    doc_meta = get_doc_meta(doc_meta, set)
+    add_defaults_count(doc_meta, defaults)
+  end
+
+  defp get_doc_meta(existing_meta, set) do
+    case :ets.take(set, {:doc, :meta}) do
+      [{{:doc, :meta}, metadata}] -> Map.merge(existing_meta, metadata)
+      [] -> existing_meta
+    end
+  end
+
+  defp compile_deprecated(doc_meta, set, bag, name, arity, defaults) do
+    case :ets.take(set, :deprecated) do
+      [{:deprecated, reason, _, _}] when is_binary(reason) ->
+        :ets.insert(bag, deprecated_reasons(defaults, name, arity, reason))
+        Map.put(doc_meta, :deprecated, reason)
+
+      _ ->
+        doc_meta
+    end
+  end
+
+  defp add_defaults_count(doc_meta, 0), do: doc_meta
+  defp add_defaults_count(doc_meta, n), do: Map.put(doc_meta, :defaults, n)
+
+  defp deprecated_reasons(0, name, arity, reason) do
+    [deprecated_reason(name, arity, reason)]
+  end
+
+  defp deprecated_reasons(defaults, name, arity, reason) do
+    [
+      deprecated_reason(name, arity - defaults, reason)
+      | deprecated_reasons(defaults - 1, name, arity, reason)
+    ]
+  end
+
+  defp deprecated_reason(name, arity, reason),
+    do: {:deprecated, {{name, arity}, reason}}
+
+  defp compile_impl(set, bag, context, name, env, kind, arity, defaults) do
+    %{line: line, file: file} = env
+
+    case :ets.take(set, :impl) do
+      [{:impl, value, _, _}] ->
+        impl = {{name, arity}, context, defaults, kind, line, file, value}
+        :ets.insert(bag, {:impls, impl})
+        value
+
+      [] ->
+        false
+    end
+  end
+
+  defp args_count([{:\\, _, _} | tail], total, defaults) do
+    args_count(tail, total + 1, defaults + 1)
+  end
+
+  defp args_count([_head | tail], total, defaults) do
+    args_count(tail, total + 1, defaults)
+  end
+
+  defp args_count([], total, defaults), do: {total, defaults}
+
+  @doc false
+  def __check_attributes__(env, set, bag) do
+    check_derive(env, set, bag)
+
+    behaviours = bag_lookup_element(bag, {:accumulate, :behaviour}, 2)
+    force_behaviour_dependencies(behaviours, env)
+
+    :ok
+  end
+
+  defp check_derive(env, set, bag) do
+    case bag_lookup_element(bag, {:accumulate, :derive}, 2) do
+      [] ->
         :ok
-      {:error, :private_doc} ->
-        :elixir_errors.warn line, env.file, "function #{name}/#{arity} is private, @doc's are always discarded for private functions\n"
+
+      _ ->
+        message =
+          case :ets.lookup(set, {:elixir, :struct}) do
+            [] ->
+              "warning: module attribute @derive was set but never used (it must come before defstruct)"
+
+            _ ->
+              "warning: module attribute @derive was set after defstruct, all @derive calls must come before defstruct"
+          end
+
+        IO.warn(message, env)
+    end
+  end
+
+  # While `@behaviour MyBehaviour` will naturally introduce a runtime dependency,
+  # `@behaviour :"Elixir.MyBehaviour"` or similar would not.
+  # We force this dependency by adding the call to `MyBehaviour.behaviour_info/1`
+  defp force_behaviour_dependencies(behaviours, env) do
+    info_env = %{env | function: {:__info__, 1}}
+
+    for behaviour <- behaviours do
+      :elixir_env.trace({:remote_function, [], behaviour, :behaviour_info, 1}, info_env)
     end
 
-    delete_attribute(module, :doc)
+    :ok
   end
 
   @doc false
-  # Used internally to compile types. This function
-  # is private and must be used only internally.
-  def store_typespec(module, key, value) when is_atom(key) do
-    assert_not_compiled!(:put_attribute, module)
-    table = data_table_for(module)
+  # Used internally by Kernel's @.
+  # This function is private and must be used only internally.
+  def __get_attribute__(module, key, caller_line, trace?) when is_atom(key) do
+    get_attribute(module, key, caller_line, trace?, false, nil, {:get_attribute, 2})
+  end
+
+  defp get_attribute(
+         module,
+         key,
+         caller_line,
+         trace?,
+         last_accumulated?,
+         default,
+         function_name_arity
+       ) do
+    {set, bag} =
+      data_tables_for!(
+        module,
+        function_name_arity,
+        "Use the Module.__info__/1 callback or Code.fetch_docs/1 instead"
+      )
+
+    case :ets.lookup(set, key) do
+      [{_, _, :unset, _}] ->
+        default
+
+      [{_, _, :accumulate, traces}] ->
+        trace_attribute(trace?, module, traces, set, key, caller_line, [])
+        lookup_accumulate_attribute(bag, key, default, last_accumulated?)
+
+      [{_, value, warn_line, traces}] when is_integer(warn_line) ->
+        trace_attribute(trace?, module, traces, set, key, caller_line, [{3, :used}])
+        value
+
+      [{_, value, _, traces}] ->
+        trace_attribute(trace?, module, traces, set, key, caller_line, [])
+        value
 
-    new =
-      case :ets.lookup(table, key) do
-        [{^key, old}] -> [value|old]
-        [] -> [value]
+      [] when is_integer(caller_line) ->
+        # TODO: Consider raising instead of warning on v2.0 as it usually cascades
+        error_message =
+          "undefined module attribute @#{key}, " <>
+            "please remove access to @#{key} or explicitly set it before access"
+
+        IO.warn(error_message, attribute_stack(module, caller_line))
+        default
+
+      [] ->
+        default
+    end
+  end
+
+  defp lookup_accumulate_attribute(bag, key, _default, false) do
+    :lists.reverse(bag_lookup_element(bag, {:accumulate, key}, 2))
+  end
+
+  defp lookup_accumulate_attribute(bag, key, default, true) do
+    case :ets.select(bag, [{{{:accumulate, key}, :"$1"}, [], [:"$1"]}], 1) do
+      {[value], _} -> value
+      _ -> default
+    end
+  end
+
+  defp trace_attribute(module, key, caller_line, traces) do
+    :lists.foreach(
+      fn {line, lexical_tracker, tracers, aliases} ->
+        line = caller_line || line
+
+        env = %{
+          Macro.Env.__struct__()
+          | line: line,
+            file: "@#{key}",
+            lexical_tracker: lexical_tracker,
+            module: module,
+            tracers: tracers
+        }
+
+        :lists.foreach(
+          fn alias ->
+            :elixir_env.trace({:alias_reference, [line: line], alias}, env)
+          end,
+          aliases
+        )
+      end,
+      traces
+    )
+  end
+
+  defp trace_attribute(trace?, module, traces, set, key, caller_line, updates) do
+    updates =
+      if trace? and traces != [] do
+        trace_attribute(module, key, caller_line, traces)
+        updates ++ [{4, []}]
+      else
+        updates
+      end
+
+    case updates do
+      [] -> :ok
+      _ -> :ets.update_element(set, key, updates)
+    end
+
+    :ok
+  end
+
+  @doc false
+  # Used internally by Kernel's @.
+  # This function is private and must be used only internally.
+  def __put_attribute__(module, key, value, warn_line, traces) when is_atom(key) do
+    assert_not_compiled!({:put_attribute, 3}, module, :writeable)
+    {set, bag} = data_tables_for!(module, {:put_attribute, 3}, "")
+    put_attribute(module, key, value, warn_line, traces, set, bag)
+    :ok
+  end
+
+  defp put_attribute(_module, :on_load, value, warn_line, traces, set, bag) do
+    value =
+      case value do
+        _ when is_atom(value) ->
+          {value, 0}
+
+        {atom, 0} = tuple when is_atom(atom) ->
+          tuple
+
+        _ ->
+          raise ArgumentError,
+                "@on_load is a built-in module attribute that annotates a function to be invoked " <>
+                  "when the module is loaded. It should be an atom or an {atom, 0} tuple, " <>
+                  "got: #{inspect(value)}"
       end
 
-    :ets.insert(table, {key, new})
+    try do
+      :ets.lookup_element(set, :on_load, 3)
+    catch
+      :error, :badarg ->
+        :ets.insert(set, {:on_load, value, warn_line, traces})
+        :ets.insert(bag, {:warn_attributes, :on_load})
+    else
+      _ -> raise ArgumentError, "the @on_load attribute can only be set once per module"
+    end
+  end
+
+  # If any of the doc attributes are called with a keyword list that
+  # will become documentation metadata. Multiple calls will be merged
+  # into the same map overriding duplicate keys.
+  defp put_attribute(module, key, {_, metadata}, warn_line, _traces, set, _bag)
+       when key in [:doc, :typedoc, :moduledoc] and is_list(metadata) do
+    metadata_map = preprocess_doc_meta(metadata, module, warn_line, %{})
+
+    case :ets.insert_new(set, {{key, :meta}, metadata_map}) do
+      true ->
+        :ok
+
+      false ->
+        current_metadata = :ets.lookup_element(set, {key, :meta}, 2)
+        :ets.update_element(set, {key, :meta}, {2, Map.merge(current_metadata, metadata_map)})
+    end
+  end
+
+  # Optimize some attributes by avoiding writing to the attributes key
+  # in the bag table since we handle them internally.
+  defp put_attribute(module, key, value, warn_line, traces, set, _bag)
+       when key in [:doc, :typedoc, :moduledoc, :impl, :deprecated] do
+    value = preprocess_attribute(key, value)
+
+    try do
+      :ets.lookup_element(set, key, 3)
+    catch
+      :error, :badarg -> :ok
+    else
+      unread_line when is_integer(warn_line) and is_integer(unread_line) ->
+        message = "redefining @#{key} attribute previously set at line #{unread_line}"
+        IO.warn(message, attribute_stack(module, warn_line))
+
+      _ ->
+        :ok
+    end
+
+    :ets.insert(set, {key, value, warn_line, traces})
+  end
+
+  defp put_attribute(_module, key, value, warn_line, traces, set, bag) do
+    value = preprocess_attribute(key, value)
+
+    try do
+      :ets.lookup_element(set, key, 3)
+    catch
+      :error, :badarg ->
+        :ets.insert(set, {key, value, warn_line, traces})
+        :ets.insert(bag, {:warn_attributes, key})
+    else
+      :accumulate ->
+        if traces != [] do
+          :ets.update_element(set, key, {4, traces ++ :ets.lookup_element(set, key, 4)})
+        end
+
+        :ets.insert(bag, {{:accumulate, key}, value})
+
+      _ ->
+        :ets.insert(set, {key, value, warn_line, traces})
+    end
+  end
+
+  defp attribute_stack(module, line) do
+    struct!(Macro.Env, module: module, file: :elixir_module.file(module), line: line)
   end
 
   ## Helpers
 
-  defp normalize_attribute(:on_load, atom) when is_atom(atom) do
-    {atom, 0}
+  defp preprocess_attribute(key, value) when key in [:moduledoc, :typedoc, :doc] do
+    case value do
+      {line, doc} when is_integer(line) and (is_binary(doc) or doc == false or is_nil(doc)) ->
+        value
+
+      {line, doc} when is_integer(line) ->
+        raise ArgumentError,
+              "@#{key} is a built-in module attribute for documentation. It should be either " <>
+                "false, nil, a string, or a keyword list, got: #{inspect(doc)}"
+
+      _other ->
+        raise ArgumentError,
+              "@#{key} is a built-in module attribute for documentation. When set dynamically, " <>
+                "it should be {line, doc} (where \"doc\" is either false, nil, a string, or a keyword list), " <>
+                "got: #{inspect(value)}"
+    end
   end
 
-  defp normalize_attribute(:behaviour, atom) when is_atom(atom) do
-    Code.ensure_compiled(atom)
-    atom
+  defp preprocess_attribute(:behaviour, value) do
+    if is_atom(value) do
+      Code.ensure_compiled(value)
+      value
+    else
+      raise ArgumentError, "@behaviour expects a module, got: #{inspect(value)}"
+    end
   end
 
-  defp normalize_attribute(:file, file) when is_binary(file) do
-    file
+  defp preprocess_attribute(:impl, value) do
+    if is_boolean(value) or (is_atom(value) and value != nil) do
+      value
+    else
+      raise ArgumentError,
+            "@impl is a built-in module attribute that marks the next definition " <>
+              "as a callback implementation. It should be a module or a boolean, " <>
+              "got: #{inspect(value)}"
+    end
+  end
+
+  defp preprocess_attribute(:before_compile, atom) when is_atom(atom),
+    do: {atom, :__before_compile__}
+
+  defp preprocess_attribute(:after_compile, atom) when is_atom(atom),
+    do: {atom, :__after_compile__}
+
+  defp preprocess_attribute(:after_verify, atom) when is_atom(atom),
+    do: {atom, :__after_verify__}
+
+  defp preprocess_attribute(:on_definition, atom) when is_atom(atom),
+    do: {atom, :__on_definition__}
+
+  defp preprocess_attribute(key, _value)
+       when key in [:type, :typep, :opaque, :spec, :callback, :macrocallback] do
+    raise ArgumentError,
+          "attributes type, typep, opaque, spec, callback, and macrocallback " <>
+            "must be set directly via the @ notation"
   end
 
-  defp normalize_attribute(key, atom) when is_atom(atom) and
-      key in [:before_compile, :after_compile, :on_definition] do
-    {atom, :"__#{key}__"}
+  defp preprocess_attribute(:external_resource, value) when not is_binary(value) do
+    raise ArgumentError,
+          "@external_resource is a built-in module attribute used for specifying file " <>
+            "dependencies. It should be a string path to a file, got: #{inspect(value)}"
   end
 
-  defp normalize_attribute(key, _value) when key in [:type, :typep, :export_type, :opaque, :callback] do
-    raise ArgumentError, "attributes type, typep, export_type, opaque and callback " <>
-      "must be set via Kernel.Typespec"
+  defp preprocess_attribute(:deprecated, value) when not is_binary(value) do
+    raise ArgumentError,
+          "@deprecated is a built-in module attribute that annotates a definition as deprecated. " <>
+            "It should be a string with the reason for the deprecation, got: #{inspect(value)}"
+  end
+
+  defp preprocess_attribute(:file, value) do
+    case value do
+      _ when is_binary(value) ->
+        value
+
+      {file, line} when is_binary(file) and is_integer(line) ->
+        value
+
+      _ ->
+        raise ArgumentError,
+              "@file is a built-in module attribute that annotates the file and line the next " <>
+                "definition comes from. It should be a string or {string, line} tuple as value, " <>
+                "got: #{inspect(value)}"
+    end
   end
 
-  defp normalize_attribute(_key, value) do
+  defp preprocess_attribute(:nifs, value) do
+    if not function_arity_list?(value) do
+      raise ArgumentError,
+            "@nifs is a built-in module attribute for specifying a list " <>
+              "of functions and their arities that are NIFs, got: #{inspect(value)}"
+    end
+
     value
   end
 
-  defp data_table_for(module) do
-    module
+  defp preprocess_attribute(:dialyzer, value) do
+    # From https://github.com/erlang/otp/blob/master/lib/stdlib/src/erl_lint.erl
+    :lists.foreach(
+      fn attr ->
+        if not valid_dialyzer_attribute?(attr) do
+          raise ArgumentError, "invalid value for @dialyzer attribute: #{inspect(attr)}"
+        end
+      end,
+      List.wrap(value)
+    )
+
+    value
   end
 
-  defp function_table_for(module) do
-    :elixir_def.table(module)
+  defp preprocess_attribute(_key, value) do
+    value
   end
 
-  defp docs_table_for(module) do
-    :elixir_module.docs_table(module)
+  defp function_arity_list?(fun_arities) do
+    is_list(fun_arities) and
+      :lists.all(
+        fn
+          {fun, arity} when is_atom(fun) and is_integer(arity) -> true
+          _ -> false
+        end,
+        fun_arities
+      )
   end
 
-  defp assert_not_compiled!(fun, module) do
-    open?(module) ||
-      raise ArgumentError,
-        "could not call #{fun} on module #{inspect module} because it was already compiled"
+  defp valid_dialyzer_attribute?({key, fun_arities}) when is_atom(key) do
+    (key == :nowarn_function or valid_dialyzer_attribute?(key)) and
+      function_arity_list?(List.wrap(fun_arities))
+  end
+
+  defp valid_dialyzer_attribute?(attr) do
+    :lists.member(
+      attr,
+      [:no_return, :no_unused, :no_improper_lists, :no_fun_app] ++
+        [:no_match, :no_opaque, :no_fail_call, :no_contracts] ++
+        [:no_behaviours, :no_undefined_callbacks, :unmatched_returns] ++
+        [:error_handling, :race_conditions, :no_missing_calls] ++
+        [:specdiffs, :overspecs, :underspecs, :unknown, :no_underspecs] ++
+        [:extra_return, :no_extra_return, :no_missing_return] ++
+        [:missing_return, :no_unknown]
+    )
+  end
+
+  defp preprocess_doc_meta([], _module, _line, map), do: map
+
+  defp preprocess_doc_meta([{key, _} | tail], module, line, map)
+       when key in [:opaque, :defaults] do
+    message = "ignoring reserved documentation metadata key: #{inspect(key)}"
+    IO.warn(message, attribute_stack(module, line))
+    preprocess_doc_meta(tail, module, line, map)
+  end
+
+  defp preprocess_doc_meta([{key, value} | tail], module, line, map) when is_atom(key) do
+    validate_doc_meta(key, value)
+    preprocess_doc_meta(tail, module, line, Map.put(map, key, value))
+  end
+
+  defp validate_doc_meta(:since, value) when not is_binary(value) do
+    raise ArgumentError,
+          ":since is a built-in documentation metadata key. It should be a string representing " <>
+            "the version in which the documented entity was added, got: #{inspect(value)}"
+  end
+
+  defp validate_doc_meta(:deprecated, value) when not is_binary(value) do
+    raise ArgumentError,
+          ":deprecated is a built-in documentation metadata key. It should be a string " <>
+            "representing the replacement for the deprecated entity, got: #{inspect(value)}"
+  end
+
+  defp validate_doc_meta(:delegate_to, value) do
+    case value do
+      {m, f, a} when is_atom(m) and is_atom(f) and is_integer(a) and a >= 0 ->
+        :ok
+
+      _ ->
+        raise ArgumentError,
+              ":delegate_to is a built-in documentation metadata key. It should be a three-element " <>
+                "tuple in the form of {module, function, arity}, got: #{inspect(value)}"
+    end
+  end
+
+  defp validate_doc_meta(_, _), do: :ok
+
+  defp get_doc_info(table, env) do
+    case :ets.take(table, :doc) do
+      [{:doc, {_, _} = pair, _, _}] ->
+        pair
+
+      [] ->
+        {env.line, nil}
+    end
+  end
+
+  defp data_tables_for!(module, function_name_arity, message) do
+    try do
+      :elixir_module.data_tables(module)
+    catch
+      :error, :badarg ->
+        raise ArgumentError, assert_not_compiled_message(function_name_arity, module, message)
+    end
+  end
+
+  defp bag_lookup_element(table, key, pos) do
+    :ets.lookup_element(table, key, pos)
+  catch
+    :error, :badarg -> []
+  end
+
+  defp assert_not_compiled!({function_name, arity}, module, mode) do
+    case :elixir_module.mode(module) do
+      :all ->
+        :ok
+
+      :readonly when mode == :all ->
+        :ok
+
+      :readonly when mode == :writeable ->
+        raise ArgumentError,
+              "could not call Module.#{function_name}/#{arity} because the module " <>
+                "#{inspect(module)} is in read-only mode (@after_compile)"
+
+      :closed ->
+        raise ArgumentError,
+              assert_not_compiled_message({function_name, arity}, module, "")
+    end
   end
 
-  defp loaded?(module), do: is_tuple :code.is_loaded(module)
+  defp assert_not_compiled_message({function_name, arity}, module, extra_msg) do
+    mfa = "Module.#{function_name}/#{arity}"
+
+    "could not call #{mfa} because the module #{inspect(module)} is already compiled" <>
+      case extra_msg do
+        "" -> ""
+        _ -> ". " <> extra_msg
+      end
+  end
 end
diff --git a/lib/elixir/lib/module/behaviour.ex b/lib/elixir/lib/module/behaviour.ex
new file mode 100644
index 00000000000..42e76baf22a
--- /dev/null
+++ b/lib/elixir/lib/module/behaviour.ex
@@ -0,0 +1,439 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Module.Behaviour do
+  # Checking functionality for @behaviours and @impl
+  @moduledoc false
+
+  @doc false
+  def callbacks(behaviour) do
+    for callback <- behaviour.behaviour_info(:callbacks) do
+      {pair, _kind} = normalize_macro_or_function_callback(callback)
+      pair
+    end
+  end
+
+  @doc false
+  def check_behaviours_and_impls(module, file, line, behaviours, impls, all_definitions) do
+    context = check_behaviours(context(module, file, line), behaviours)
+
+    context =
+      if impls != [] do
+        {context, impl_contexts} = check_impls(context, behaviours, impls)
+
+        warn_missing_impls(context, impl_contexts, all_definitions)
+      else
+        context
+      end
+
+    context = check_callbacks(context, all_definitions)
+
+    context.warnings
+  end
+
+  defp context(module, file, line) do
+    %{
+      module: module,
+      file: file,
+      line: line,
+      callbacks: %{},
+      warnings: []
+    }
+  end
+
+  defp warn(context, warning, meta \\ []) do
+    meta = Keyword.put_new(meta, :line, context.line)
+    location = {meta[:file] || context.file, meta, context.module}
+
+    update_in(context.warnings, &[{__MODULE__, warning, location} | &1])
+  end
+
+  defp check_behaviours(context, behaviours) do
+    Enum.reduce(behaviours, context, fn behaviour, context ->
+      cond do
+        not Code.ensure_loaded?(behaviour) ->
+          warn(context, {:undefined_behaviour, context.module, behaviour})
+
+        not function_exported?(behaviour, :behaviour_info, 1) ->
+          warn(context, {:module_does_not_define_behaviour, context.module, behaviour})
+
+        true ->
+          optional_callbacks = behaviour.behaviour_info(:optional_callbacks)
+          callbacks = behaviour.behaviour_info(:callbacks)
+          Enum.reduce(callbacks, context, &add_callback(&2, &1, behaviour, optional_callbacks))
+      end
+    end)
+  end
+
+  defp add_callback(context, original, behaviour, optional_callbacks) do
+    {callback, kind} = normalize_macro_or_function_callback(original)
+
+    context =
+      case context.callbacks do
+        %{^callback => [{_kind, conflict, _optional?} | _]} ->
+          warn(
+            context,
+            {:duplicate_behaviour, context.module, behaviour, conflict, kind, callback}
+          )
+
+        %{} ->
+          context
+      end
+
+    new_callback = {kind, behaviour, original in optional_callbacks}
+    callbacks = context.callbacks[callback] || []
+
+    put_in(context.callbacks[callback], [new_callback | callbacks])
+  end
+
+  defp check_callbacks(context, all_definitions) do
+    for {callback, callbacks} <- context.callbacks,
+        {kind, behaviour, optional?} <- callbacks,
+        reduce: context do
+      context ->
+        case :lists.keyfind(callback, 1, all_definitions) do
+          false when not optional? ->
+            warn(context, {:missing_callback, context.module, callback, kind, behaviour})
+
+          {_, wrong_kind, _, _} when kind != wrong_kind ->
+            warn(
+              context,
+              {:callback_mismatch, context.module, callback, kind, wrong_kind, behaviour}
+            )
+
+          _ ->
+            context
+        end
+    end
+  end
+
+  defp format_callback(callback, kind, module) do
+    protocol_or_behaviour = if protocol?(module), do: "protocol ", else: "behaviour "
+
+    format_definition(kind, callback) <>
+      " required by " <> protocol_or_behaviour <> inspect(module)
+  end
+
+  defp protocol?(module) do
+    Code.ensure_loaded?(module) and function_exported?(module, :__protocol__, 1) and
+      module.__protocol__(:module) == module
+  end
+
+  defp check_impls(context, behaviours, impls) do
+    all_callbacks = context.callbacks
+    acc = {context, %{}}
+
+    Enum.reduce(impls, acc, fn {fa, impl_context, defaults, kind, line, file, value},
+                               {context, impl_contexts} = acc ->
+      case impl_behaviours(fa, defaults, kind, value, behaviours, all_callbacks) do
+        {:ok, impl_behaviours} ->
+          Enum.reduce(impl_behaviours, acc, fn {fa, behaviour}, {context, impl_contexts} ->
+            {_, context} = pop_in(context.callbacks[fa])
+
+            impl_contexts =
+              Map.update(impl_contexts, behaviour, [impl_context], &[impl_context | &1])
+
+            {context, impl_contexts}
+          end)
+
+        {:error, message} ->
+          warning = message |> Tuple.insert_at(1, kind) |> Tuple.insert_at(1, fa)
+          context = warn(context, warning, line: line, file: file)
+          {context, impl_contexts}
+      end
+    end)
+  end
+
+  defp impl_behaviours({function, arity}, defaults, kind, value, behaviours, callbacks) do
+    impls = for n <- (arity - defaults)..arity, do: {function, n}
+    impl_behaviours(impls, kind, value, behaviours, callbacks)
+  end
+
+  defp impl_behaviours(_, kind, _, _, _) when kind in [:defp, :defmacrop] do
+    {:error, {:private_function}}
+  end
+
+  defp impl_behaviours(_, _, value, [], _) do
+    {:error, {:no_behaviours, value}}
+  end
+
+  defp impl_behaviours(impls, _, false, _, callbacks) do
+    case callbacks_for_impls(impls, callbacks) do
+      [] -> {:ok, []}
+      [impl | _] -> {:error, {:impl_not_defined, impl}}
+    end
+  end
+
+  defp impl_behaviours(impls, _, true, _, callbacks) do
+    case callbacks_for_impls(impls, callbacks) do
+      [] -> {:error, {:impl_defined, callbacks}}
+      impls -> {:ok, impls}
+    end
+  end
+
+  defp impl_behaviours(impls, _, behaviour, behaviours, callbacks) do
+    filtered = behaviour_callbacks_for_impls(impls, behaviour, callbacks)
+
+    cond do
+      filtered != [] ->
+        {:ok, filtered}
+
+      behaviour not in behaviours ->
+        {:error, {:behaviour_not_declared, behaviour}}
+
+      not Code.ensure_loaded?(behaviour) ->
+        # Module does not exist, but we have already warned about it.
+        {:ok, []}
+
+      not behaviour_defined?(callbacks, behaviour) ->
+        # Module does not define behaviour, but we have already warned about it.
+        {:ok, []}
+
+      true ->
+        {:error, {:callback_not_defined, behaviour, callbacks}}
+    end
+  end
+
+  defp behaviour_callbacks_for_impls([], _behaviour, _callbacks) do
+    []
+  end
+
+  defp behaviour_callbacks_for_impls([fa | tail], behaviour, callbacks) do
+    with list when is_list(list) <- callbacks[fa],
+         true <- Enum.any?(list, &match?({_, ^behaviour, _}, &1)) do
+      [{fa, behaviour} | behaviour_callbacks_for_impls(tail, behaviour, callbacks)]
+    else
+      _ ->
+        behaviour_callbacks_for_impls(tail, behaviour, callbacks)
+    end
+  end
+
+  defp callbacks_for_impls([], _) do
+    []
+  end
+
+  defp callbacks_for_impls([fa | tail], callbacks) do
+    case callbacks[fa] do
+      list when is_list(list) ->
+        Enum.map(list, fn {_, behaviour, _} -> {fa, behaviour} end) ++
+          callbacks_for_impls(tail, callbacks)
+
+      nil ->
+        callbacks_for_impls(tail, callbacks)
+    end
+  end
+
+  # Determines whether there is at least one callback defined for the given behaviour.
+  # If not, that means that the behaviour has not been defined.
+  defp behaviour_defined?(callbacks, behaviour) do
+    callbacks
+    |> Map.values()
+    |> List.flatten()
+    |> Enum.any?(fn
+      {_kind, ^behaviour, _optional?} -> true
+      {_kind, _behaviour, _optional?} -> false
+    end)
+  end
+
+  defp warn_missing_impls(%{callbacks: callbacks} = context, _impl_contexts, _defs)
+       when map_size(callbacks) == 0 do
+    context
+  end
+
+  defp warn_missing_impls(context, impl_contexts, defs) do
+    for {pair, kind, meta, _clauses} <- defs, kind in [:def, :defmacro], reduce: context do
+      context ->
+        with {:ok, callbacks} <- Map.fetch(context.callbacks, pair),
+             {_, behaviour, _} <-
+               Enum.find(callbacks, fn {_, behaviour, _} ->
+                 missing_impl_in_context?(meta, behaviour, impl_contexts)
+               end) do
+          warn(context, {:missing_impl, pair, kind, behaviour},
+            line: :elixir_utils.get_line(meta)
+          )
+        else
+          _ -> context
+        end
+    end
+  end
+
+  defp missing_impl_in_context?(meta, behaviour, impl_contexts) do
+    case impl_contexts do
+      %{^behaviour => known} -> Keyword.get(meta, :context) in known
+      %{} -> not Keyword.has_key?(meta, :context)
+    end
+  end
+
+  defp format_definition(kind, {name, arity}) do
+    format_definition(kind) <> " #{name}/#{arity}"
+  end
+
+  defp format_definition(:defmacro), do: "macro"
+  defp format_definition(:defmacrop), do: "macro"
+  defp format_definition(:def), do: "function"
+  defp format_definition(:defp), do: "function"
+
+  defp known_callbacks(callbacks) when map_size(callbacks) == 0 do
+    ". There are no known callbacks, please specify the proper @behaviour " <>
+      "and make sure it defines callbacks"
+  end
+
+  defp known_callbacks(callbacks) do
+    formatted_callbacks =
+      for {{name, arity}, list} <- callbacks, {kind, module, _} <- list do
+        "\n  * " <> Exception.format_mfa(module, name, arity) <> " (#{format_definition(kind)})"
+      end
+
+    ". The known callbacks are:\n#{formatted_callbacks}\n"
+  end
+
+  defp normalize_macro_or_function_callback({function_name, arity}) do
+    case :erlang.atom_to_list(function_name) do
+      # Macros are always provided one extra argument in behaviour_info/1
+      [?M, ?A, ?C, ?R, ?O, ?-] ++ tail ->
+        {{:erlang.list_to_atom(tail), arity - 1}, :defmacro}
+
+      _ ->
+        {{function_name, arity}, :def}
+    end
+  end
+
+  def format_diagnostic(warning) do
+    %{message: IO.iodata_to_binary(format_warning(warning))}
+  end
+
+  defp format_warning({:undefined_behaviour, module, behaviour}) do
+    [
+      "@behaviour ",
+      inspect(behaviour),
+      " does not exist (in module ",
+      inspect(module),
+      ")"
+    ]
+  end
+
+  defp format_warning({:module_does_not_define_behaviour, module, behaviour}) do
+    ["module ", inspect(behaviour), " is not a behaviour (in module ", inspect(module), ")"]
+  end
+
+  defp format_warning({:duplicate_behaviour, module, behaviour, conflict, kind, callback})
+       when conflict == behaviour do
+    [
+      "the behaviour ",
+      inspect(behaviour),
+      " has been declared twice (conflict in ",
+      format_definition(kind, callback),
+      " in module ",
+      inspect(module),
+      ")"
+    ]
+  end
+
+  defp format_warning({:duplicate_behaviour, module, behaviour, conflict, kind, callback}) do
+    [
+      "conflicting behaviours found. Callback ",
+      format_definition(kind, callback),
+      " is defined by both ",
+      inspect(conflict),
+      " and ",
+      inspect(behaviour),
+      " (in module ",
+      inspect(module),
+      ")"
+    ]
+  end
+
+  defp format_warning({:missing_callback, module, callback, kind, behaviour}) do
+    [
+      format_callback(callback, kind, behaviour),
+      " is not implemented (in module ",
+      inspect(module),
+      ")"
+    ]
+  end
+
+  defp format_warning({:callback_mismatch, module, callback, kind, wrong_kind, behaviour}) do
+    [
+      format_callback(callback, kind, behaviour),
+      " was implemented as \"",
+      to_string(wrong_kind),
+      "\" but should have been \"",
+      to_string(kind),
+      "\" (in module ",
+      inspect(module),
+      ")"
+    ]
+  end
+
+  defp format_warning({:private_function, callback, kind}) do
+    [
+      format_definition(kind, callback),
+      " is private, @impl attribute is always discarded for private functions/macros"
+    ]
+  end
+
+  defp format_warning({:no_behaviours, callback, kind, value}) do
+    [
+      "got \"@impl ",
+      inspect(value),
+      "\" for ",
+      format_definition(kind, callback),
+      " but no behaviour was declared"
+    ]
+  end
+
+  defp format_warning({:impl_not_defined, callback, kind, {_fa, behaviour}}) do
+    [
+      "got \"@impl false\" for ",
+      format_definition(kind, callback),
+      " but it is a callback specified in ",
+      inspect(behaviour)
+    ]
+  end
+
+  defp format_warning({:impl_defined, callback, kind, callbacks}) do
+    [
+      "got \"@impl true\" for ",
+      format_definition(kind, callback),
+      " but no behaviour specifies such callback",
+      known_callbacks(callbacks)
+    ]
+  end
+
+  defp format_warning({:behaviour_not_declared, callback, kind, behaviour}) do
+    [
+      "got \"@impl ",
+      inspect(behaviour),
+      "\" for ",
+      format_definition(kind, callback),
+      " but this behaviour was not declared with @behaviour"
+    ]
+  end
+
+  defp format_warning({:callback_not_defined, callback, kind, behaviour, callbacks}) do
+    behaviour_string = inspect(behaviour)
+
+    [
+      "got \"@impl ",
+      behaviour_string,
+      "\" for ",
+      format_definition(kind, callback),
+      " but ",
+      behaviour_string,
+      " does not specify such callback",
+      known_callbacks(callbacks)
+    ]
+  end
+
+  defp format_warning({:missing_impl, callback, kind, behaviour}) do
+    [
+      "module attribute @impl was not set for ",
+      format_definition(kind, callback),
+      " callback (specified in ",
+      inspect(behaviour),
+      "). " <>
+        "This either means you forgot to add the \"@impl true\" annotation before the " <>
+        "definition or that you are accidentally overriding this callback"
+    ]
+  end
+end
diff --git a/lib/elixir/lib/module/locals_tracker.ex b/lib/elixir/lib/module/locals_tracker.ex
deleted file mode 100644
index 2a2da62ad8c..00000000000
--- a/lib/elixir/lib/module/locals_tracker.ex
+++ /dev/null
@@ -1,330 +0,0 @@
-# This is a module Elixir responsible for tracking
-# calls in order to extract Elixir modules' behaviour
-# during compilation time.
-#
-# ## Implementation
-#
-# The implementation uses the digraph module to track
-# all dependencies. The graph starts with one main vertice:
-#
-# * `:local` - points to local functions
-#
-# We also have can the following vertices:
-#
-# * `Module` - a module that was invoked via an import
-# * `{name, arity}` - a local function/arity pair
-# * `{:import, name, arity}` - an invoked function/arity import
-#
-# Each of those vertices can associate to other vertices
-# as described below:
-#
-# * `Module`
-#   * in neighbours:  `{:import, name, arity}`
-#
-# * `{name, arity}`
-#   * in neighbours: `:local`, `{name, arity}`
-#   * out neighbours: `{:import, name, arity}`
-#
-# * `{:import, name, arity}`
-#   * in neighbours: `{name, arity}`
-#   * out neighbours: `Module`
-#
-# Note that since this is required for bootstrap, we can't use
-# any of the `GenServer.Behaviour` conveniences.
-defmodule Module.LocalsTracker do
-  @moduledoc false
-
-  @timeout   30_000
-  @behaviour :gen_server
-
-  @type ref :: pid | module
-  @type name :: atom
-  @type name_arity :: {name, arity}
-
-  @type local :: {name, arity}
-  @type import :: {:import, name, arity}
-
-  # Public API
-
-  @doc """
-  Returns all imported modules that had the given
-  `{name, arity}` invoked.
-  """
-  @spec imports_with_dispatch(ref, name_arity) :: [module]
-  def imports_with_dispatch(ref, {name, arity}) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    :digraph.out_neighbours(d, {:import, name, arity})
-  end
-
-  @doc """
-  Returns all locals that are reachable.
-
-  By default, all public functions are reachable.
-  A private function is only reachable if it has
-  a public function that it invokes directly.
-  """
-  @spec reachable(ref) :: [local]
-  def reachable(ref) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    reduce_reachable(d, :local, [])
-  end
-
-  defp reduce_reachable(d, vertex, vertices) do
-    neighbours = :digraph.out_neighbours(d, vertex)
-    neighbours = (for {_, _} = t <- neighbours, do: t) |> :ordsets.from_list
-    remaining  = :ordsets.subtract(neighbours, vertices)
-    vertices   = :ordsets.union(neighbours, vertices)
-    :lists.foldl(&reduce_reachable(d, &1, &2), vertices, remaining)
-  end
-
-  defp to_pid(pid) when is_pid(pid),  do: pid
-  defp to_pid(mod) when is_atom(mod) do
-    table = :elixir_module.data_table(mod)
-    [{_, val}] = :ets.lookup(table, :__locals_tracker)
-    val
-  end
-
-  # Internal API
-
-  # Starts the tracker and returns its pid.
-  @doc false
-  def start_link do
-    {:ok, pid} = :gen_server.start_link(__MODULE__, [], [])
-    pid
-  end
-
-  # Adds a definition into the tracker. A public
-  # definition is connected with the :local node
-  # while a private one is left unreachable until
-  # a call is made to.
-  @doc false
-  def add_definition(pid, kind, tuple) when kind in [:def, :defp, :defmacro, :defmacrop] do
-    :gen_server.cast(pid, {:add_definition, kind, tuple})
-  end
-
-  # Adds and tracks defaults for a definition into the tracker.
-  @doc false
-  def add_defaults(pid, kind, tuple, defaults) when kind in [:def, :defp, :defmacro, :defmacrop] do
-    :gen_server.cast(pid, {:add_defaults, kind, tuple, defaults})
-  end
-
-  # Adds a local dispatch to the given target.
-  def add_local(pid, to) when is_tuple(to) do
-    :gen_server.cast(pid, {:add_local, :local, to})
-  end
-
-  # Adds a local dispatch from-to the given target.
-  @doc false
-  def add_local(pid, from, to) when is_tuple(from) and is_tuple(to) do
-    :gen_server.cast(pid, {:add_local, from, to})
-  end
-
-  # Adds a import dispatch to the given target.
-  @doc false
-  def add_import(pid, function, module, target) when is_atom(module) and is_tuple(target) do
-    :gen_server.cast(pid, {:add_import, function, module, target})
-  end
-
-  # Yanks a local node. Returns its in and out vertices in a tuple.
-  @doc false
-  def yank(pid, local) do
-    :gen_server.call(to_pid(pid), {:yank, local}, @timeout)
-  end
-
-  # Reattach a previously yanked node
-  @doc false
-  def reattach(pid, kind, tuple, neighbours) do
-    pid = to_pid(pid)
-    add_definition(pid, kind, tuple)
-    :gen_server.cast(pid, {:reattach, tuple, neighbours})
-  end
-
-  # Collecting all conflicting imports with the given functions
-  @doc false
-  def collect_imports_conflicts(pid, all_defined) do
-    d = :gen_server.call(pid, :digraph, @timeout)
-
-    for {name, arity} <- all_defined,
-        :digraph.in_neighbours(d, {:import, name, arity}) != [],
-        n = :digraph.out_neighbours(d, {:import, name, arity}),
-        n != [] do
-      {n, name, arity}
-    end
-  end
-
-  # Collect all unused definitions based on the private
-  # given also accounting the expected amount of default
-  # clauses a private function have.
-  @doc false
-  def collect_unused_locals(pid, private) do
-    reachable = reachable(pid)
-    :lists.foldl(&collect_unused_locals(&1, &2, reachable), [], private)
-  end
-
-  defp collect_unused_locals({tuple, kind, 0}, acc, reachable) do
-    if :lists.member(tuple, reachable) do
-      acc
-    else
-      [{:unused_def, tuple, kind}|acc]
-    end
-  end
-
-  defp collect_unused_locals({tuple, kind, default}, acc, reachable) when default > 0 do
-    {name, arity} = tuple
-    min = arity - default
-    max = arity
-
-    invoked = for {n, a} <- reachable, n == name, a in min..max, do: a
-
-    if invoked == [] do
-      [{:unused_def, tuple, kind}|acc]
-    else
-      case :lists.min(invoked) - min do
-        0 -> acc
-        ^default -> [{:unused_args, tuple}|acc]
-        unused_args -> [{:unused_args, tuple, unused_args}|acc]
-      end
-    end
-  end
-
-  @doc false
-  def cache_env(pid, env) do
-    :gen_server.call(pid, {:cache_env, env}, @timeout)
-  end
-
-  @doc false
-  def get_cached_env(pid, ref) do
-    :gen_server.call(pid, {:get_cached_env, ref}, @timeout)
-  end
-
-  # Stops the gen server
-  @doc false
-  def stop(pid) do
-    :gen_server.cast(pid, :stop)
-  end
-
-  # Callbacks
-
-  def init([]) do
-    d = :digraph.new([:protected])
-    :digraph.add_vertex(d, :local)
-    {:ok, {d, []}}
-  end
-
-  def handle_call({:cache_env, env}, _from, {d, cache}) do
-    case cache do
-      [{i,^env}|_] ->
-        {:reply, i, {d, cache}}
-      t ->
-        i = length(t)
-        {:reply, i, {d, [{i,env}|t]}}
-    end
-  end
-
-  def handle_call({:get_cached_env, ref}, _from, {_, cache} = state) do
-    {^ref, env} = :lists.keyfind(ref, 1, cache)
-    {:reply, env, state}
-  end
-
-  def handle_call({:yank, local}, _from, {d, _} = state) do
-    in_vertices  = :digraph.in_neighbours(d, local)
-    out_vertices = :digraph.out_neighbours(d, local)
-    :digraph.del_vertex(d, local)
-    {:reply, {in_vertices, out_vertices}, state}
-  end
-
-  def handle_call(:digraph, _from, {d, _} = state) do
-    {:reply, d, state}
-  end
-
-  def handle_call(request, _from, state) do
-    {:stop, {:bad_call, request}, state}
-  end
-
-  def handle_info(_msg, state) do
-    {:noreply, state}
-  end
-
-  def handle_cast({:add_local, from, to}, {d, _} = state) do
-    handle_add_local(d, from, to)
-    {:noreply, state}
-  end
-
-  def handle_cast({:add_import, function, module, {name, arity}}, {d, _} = state) do
-    handle_import(d, function, module, name, arity)
-    {:noreply, state}
-  end
-
-  def handle_cast({:add_definition, kind, tuple}, {d, _} = state) do
-    handle_add_definition(d, kind, tuple)
-    {:noreply, state}
-  end
-
-  def handle_cast({:add_defaults, kind, {name, arity}, defaults}, {d, _} = state) do
-    for i <- :lists.seq(arity - defaults, arity - 1) do
-      handle_add_definition(d, kind, {name, i})
-      handle_add_local(d, {name, i}, {name, i + 1})
-    end
-    {:noreply, state}
-  end
-
-  def handle_cast({:reattach, tuple, {in_neigh, out_neigh}}, {d, _} = state) do
-    for from <- in_neigh, do: replace_edge(d, from, tuple)
-    for to <- out_neigh, do: replace_edge(d, tuple, to)
-    {:noreply, state}
-  end
-
-  def handle_cast(:stop, state) do
-    {:stop, :normal, state}
-  end
-
-  def handle_cast(msg, state) do
-    {:stop, {:bad_cast, msg}, state}
-  end
-
-  def terminate(_reason, _state) do
-    :ok
-  end
-
-  def code_change(_old, state, _extra) do
-    {:ok, state}
-  end
-
-  defp handle_import(d, function, module, name, arity) do
-    :digraph.add_vertex(d, module)
-
-    tuple = {:import, name, arity}
-    :digraph.add_vertex(d, tuple)
-    replace_edge!(d, tuple, module)
-
-    if function != nil do
-      replace_edge!(d, function, tuple)
-    end
-  end
-
-  defp handle_add_local(d, from, to) do
-    :digraph.add_vertex(d, to)
-    replace_edge!(d, from, to)
-  end
-
-  defp handle_add_definition(d, public, tuple) when public in [:def, :defmacro] do
-    :digraph.add_vertex(d, tuple)
-    replace_edge!(d, :local, tuple)
-  end
-
-  defp handle_add_definition(d, private, tuple) when private in [:defp, :defmacrop] do
-    :digraph.add_vertex(d, tuple)
-  end
-
-  defp replace_edge!(d, from, to) do
-    unless :lists.member(to, :digraph.out_neighbours(d, from)) do
-      [:"$e"|_] = :digraph.add_edge(d, from, to)
-    end
-  end
-
-  defp replace_edge(d, from, to) do
-    unless :lists.member(to, :digraph.out_neighbours(d, from)) do
-      :digraph.add_edge(d, from, to)
-    end
-  end
-end
diff --git a/lib/elixir/lib/module/parallel_checker.ex b/lib/elixir/lib/module/parallel_checker.ex
new file mode 100644
index 00000000000..e70edf3689f
--- /dev/null
+++ b/lib/elixir/lib/module/parallel_checker.ex
@@ -0,0 +1,662 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Module.ParallelChecker do
+  @moduledoc false
+  @elixir_checker_version :elixir_erl.checker_version()
+
+  import Kernel, except: [spawn: 3]
+
+  @type cache() :: {pid(), :ets.tid()}
+  @type warning() :: term()
+  @type mode() :: :erlang | :elixir | :protocol
+
+  @typedoc """
+  Options for `start_link/1`.
+  """
+  @type start_link_opts :: [
+          {:max_concurrency, pos_integer()}
+          | {:long_verification_threshold, pos_integer()}
+          | {:each_long_verification, (module() -> term()) | (module(), pid() -> term())}
+          | {atom(), term()}
+        ]
+
+  @doc """
+  Initializes the parallel checker process.
+  """
+  @spec start_link(start_link_opts()) :: {:ok, cache()}
+  def start_link(opts \\ []) do
+    :proc_lib.start_link(__MODULE__, :init, [opts])
+  end
+
+  @doc """
+  Stops the parallel checker process.
+  """
+  def stop({checker, _table}) do
+    send(checker, {__MODULE__, :stop})
+    :ok
+  end
+
+  @doc """
+  Gets the parallel checker data from pdict.
+  """
+  def get do
+    case :erlang.get(:elixir_checker_info) do
+      {parent, nil} ->
+        {:ok, cache} = start_link()
+        put(parent, cache)
+        {parent, cache}
+
+      {parent, cache} ->
+        {parent, cache}
+    end
+  end
+
+  @doc """
+  Stores the parallel checker information.
+  """
+  def put(pid, {checker, table}) when is_pid(pid) do
+    :erlang.put(:elixir_checker_info, {pid, {checker, table}})
+  end
+
+  @doc """
+  Spawns a process that runs the parallel checker.
+  """
+  def spawn({pid, {checker, table}}, module, module_map, signatures, beam_location, log?) do
+    # Protocols may have been consolidated. So if we know their beam location,
+    # we discard their module map on purpose and start from file.
+    info =
+      if beam_location != [] and Keyword.has_key?(module_map.attributes, :__protocol__) do
+        List.to_string(beam_location)
+      else
+        cache_from_module_map(table, module_map, signatures)
+      end
+
+    inner_spawn(pid, checker, table, module, info, log?)
+  end
+
+  defp inner_spawn(pid, checker, table, module, info, log?) do
+    ref = make_ref()
+
+    spawned =
+      spawn(fn ->
+        mon_ref = Process.monitor(pid)
+
+        receive do
+          {^ref, :cache} ->
+            Process.link(pid)
+
+            {mode, module_tuple} =
+              cond do
+                is_binary(info) ->
+                  location =
+                    case :code.which(module) do
+                      [_ | _] = path -> path
+                      _ -> info
+                    end
+
+                  with {:ok, binary} <- File.read(location),
+                       {:ok,
+                        {_, [{:debug_info, {:debug_info_v1, backend, data}}, {~c"ExCk", checker}]}} <-
+                         :beam_lib.chunks(binary, [:debug_info, ~c"ExCk"]),
+                       {:ok, module_map} <- backend.debug_info(:elixir_v1, module, data, []),
+                       {@elixir_checker_version, contents} <- :erlang.binary_to_term(checker) do
+                    {cache_chunk(table, module, contents), module_map_to_module_tuple(module_map)}
+                  else
+                    _ -> {:not_found, nil}
+                  end
+
+                is_tuple(info) ->
+                  info
+              end
+
+            # We only make the module available now, so they are not visible during inference
+            :ets.insert(table, {module, mode})
+            send(checker, {ref, :cached})
+
+            receive do
+              {^ref, :check} ->
+                # Set the compiler info so we can collect warnings
+                :erlang.put(:elixir_compiler_info, {pid, self()})
+
+                warnings =
+                  if module_tuple do
+                    check_module(module_tuple, {checker, table}, log?)
+                  else
+                    []
+                  end
+
+                send(pid, {__MODULE__, module, warnings})
+                send(checker, {__MODULE__, :done, module})
+            end
+
+          {:DOWN, ^mon_ref, _, _, _} ->
+            :ok
+        end
+      end)
+
+    register(checker, module, spawned, ref)
+    :ok
+  end
+
+  @doc """
+  Verifies the given compilation function
+  by starting a checker if one does not exist.
+
+  See `verify/3`.
+  """
+  def verify(fun) do
+    case :erlang.get(:elixir_compiler_info) do
+      :undefined ->
+        previous = :erlang.put(:elixir_checker_info, {self(), nil})
+
+        try do
+          result = fun.()
+
+          case :erlang.get(:elixir_checker_info) do
+            {_, nil} -> :ok
+            {_, cache} -> verify(cache, [])
+          end
+
+          result
+        after
+          {_, cache} = :erlang.get(:elixir_checker_info)
+
+          if previous != :undefined do
+            :erlang.put(:elixir_checker_info, previous)
+          else
+            :erlang.erase(:elixir_checker_info)
+          end
+
+          cache && stop(cache)
+        end
+
+      _ ->
+        # If we are during compilation, then they will be
+        # reported to the compiler, which will validate them.
+        fun.()
+    end
+  end
+
+  @doc """
+  Receives pairs of module maps and BEAM binaries.
+
+  Returns the updated list of warnings from the verification.
+  """
+  @spec verify(cache(), [{module(), Path.t()}]) :: [warning()]
+  def verify({checker, table}, runtime_files) do
+    value = :erlang.get(:elixir_code_diagnostics)
+    log? = not match?({_, false}, value)
+
+    for {module, file} <- runtime_files do
+      inner_spawn(self(), checker, table, module, file, log?)
+    end
+
+    count = :gen_server.call(checker, :start, :infinity)
+    diagnostics = collect_results(count, [])
+
+    case :erlang.get(:elixir_code_diagnostics) do
+      :undefined -> :ok
+      {tail, log?} -> :erlang.put(:elixir_code_diagnostics, {diagnostics ++ tail, log?})
+    end
+
+    diagnostics
+  end
+
+  defp collect_results(0, diagnostics) do
+    diagnostics
+  end
+
+  defp collect_results(count, diagnostics) do
+    receive do
+      {:diagnostic, %{file: file} = diagnostic, read_snippet} ->
+        :elixir_errors.print_diagnostic(diagnostic, read_snippet)
+        diagnostic = %{diagnostic | file: file && Path.absname(file)}
+        collect_results(count, [diagnostic | diagnostics])
+
+      {__MODULE__, _module, new_diagnostics} ->
+        collect_results(count - 1, new_diagnostics ++ diagnostics)
+    end
+  end
+
+  @doc """
+  Test cache.
+  """
+  def test_cache do
+    {:ok, cache} = start_link()
+    cache
+  end
+
+  @doc """
+  Returns the export kind and deprecation reason for the given MFA from
+  the cache. If the module does not exist return `:badmodule`,
+  or if the function does not exist return `{:badfunction, mode}`.
+  """
+  @spec fetch_export(cache(), module(), atom(), arity(), boolean()) ::
+          {:ok, mode(), binary() | nil, {:infer, [term()] | nil, [term()]} | :none}
+          | :badmodule
+          | {:badfunction, mode()}
+  def fetch_export({checker, table}, module, fun, arity, force?) do
+    case :ets.lookup(table, module) do
+      [] ->
+        if force? do
+          cache_module({checker, table}, module)
+          fetch_export({checker, table}, module, fun, arity, false)
+        else
+          :badmodule
+        end
+
+      [{_key, :uncached}] ->
+        cache_module({checker, table}, module)
+        fetch_export({checker, table}, module, fun, arity, false)
+
+      [{_key, :not_found}] ->
+        :badmodule
+
+      [{_key, mode}] ->
+        case :ets.lookup(table, {module, {fun, arity}}) do
+          [{_key, reason, signature}] -> {:ok, mode, reason, signature}
+          [] -> {:badfunction, mode}
+        end
+    end
+  end
+
+  ## Module checking
+
+  defp check_module(module_tuple, cache, log?) do
+    {module, file, line, definitions, no_warn_undefined, behaviours, impls, attrs, after_verify} =
+      module_tuple
+
+    behaviour_warnings =
+      Module.Behaviour.check_behaviours_and_impls(
+        module,
+        file,
+        line,
+        behaviours,
+        impls,
+        definitions
+      )
+
+    diagnostics =
+      module
+      |> Module.Types.warnings(file, attrs, definitions, no_warn_undefined, cache)
+      |> Kernel.++(behaviour_warnings)
+      |> group_warnings()
+      |> emit_warnings(file, log?)
+
+    Enum.each(after_verify, fn {verify_mod, verify_fun} ->
+      apply(verify_mod, verify_fun, [module])
+    end)
+
+    diagnostics
+  end
+
+  defp module_map_to_module_tuple(module_map) do
+    %{
+      module: module,
+      file: file,
+      compile_opts: compile_opts,
+      definitions: definitions,
+      attributes: attributes,
+      impls: impls,
+      after_verify: after_verify
+    } = module_map
+
+    # TODO: Match on anno directly in Elixir v1.22+
+    line =
+      case module_map do
+        %{anno: anno} -> :erl_anno.line(anno)
+        %{line: line} -> line
+      end
+
+    behaviours = for {:behaviour, module} <- attributes, do: module
+
+    no_warn_undefined =
+      compile_opts
+      |> extract_no_warn_undefined()
+      |> merge_compiler_no_warn_undefined()
+
+    attributes = Keyword.take(attributes, [:__protocol__, :__impl__])
+
+    {module, file, line, definitions, no_warn_undefined, behaviours, impls, attributes,
+     after_verify}
+  end
+
+  defp extract_no_warn_undefined(compile_opts) do
+    for(
+      {:no_warn_undefined, values} <- compile_opts,
+      value <- List.wrap(values),
+      do: value
+    )
+  end
+
+  defp merge_compiler_no_warn_undefined(no_warn_undefined) do
+    case Code.get_compiler_option(:no_warn_undefined) do
+      :all -> :all
+      list when is_list(list) -> no_warn_undefined ++ list
+    end
+  end
+
+  ## Warning helpers
+
+  defp group_warnings(warnings) do
+    {ungrouped, grouped} =
+      Enum.reduce(warnings, {[], %{}}, fn {module, warning, location}, {ungrouped, grouped} ->
+        %{message: _} = diagnostic = module.format_diagnostic(warning)
+
+        if Map.get(diagnostic, :group, false) do
+          locations = MapSet.new([location])
+
+          grouped =
+            Map.update(grouped, warning, {locations, diagnostic}, fn
+              {locations, diagnostic} -> {MapSet.put(locations, location), diagnostic}
+            end)
+
+          {ungrouped, grouped}
+        else
+          {[{[location], diagnostic} | ungrouped], grouped}
+        end
+      end)
+
+    grouped =
+      Enum.map(grouped, fn {_warning, {locations, diagnostic}} ->
+        {Enum.sort(locations), diagnostic}
+      end)
+
+    Enum.sort(ungrouped ++ grouped)
+  end
+
+  defp emit_warnings(warnings, file, log?) do
+    Enum.flat_map(warnings, fn {locations, diagnostic} ->
+      diagnostics = Enum.map(locations, &to_diagnostic(diagnostic, file, &1))
+      log? and print_diagnostics(diagnostics)
+      diagnostics
+    end)
+  end
+
+  defp print_diagnostics([diagnostic]) do
+    :elixir_errors.print_diagnostic(diagnostic, true)
+  end
+
+  defp print_diagnostics(diagnostics) do
+    :elixir_errors.print_diagnostics(diagnostics)
+  end
+
+  defp to_diagnostic(diagnostic, source, {file, position, mfa}) when is_list(position) do
+    file = Path.absname(file)
+
+    %{
+      severity: :warning,
+      source: source,
+      file: file,
+      position: position_to_tuple(position),
+      stacktrace: [to_stacktrace(file, position, mfa)],
+      span: nil
+    }
+    |> Map.merge(diagnostic)
+  end
+
+  defp position_to_tuple(position) do
+    case position[:column] do
+      nil -> position[:line] || 0
+      col -> {position[:line], col}
+    end
+  end
+
+  defp to_stacktrace(file, pos, {module, fun, arity}),
+    do: {module, fun, arity, location(file, pos)}
+
+  defp to_stacktrace(file, pos, nil),
+    do: {:elixir_compiler, :__FILE__, 1, location(file, pos)}
+
+  defp to_stacktrace(file, pos, module),
+    do: {module, :__MODULE__, 0, location(file, pos)}
+
+  defp location(file, position) do
+    [{:file, String.to_charlist(Path.relative_to_cwd(file))} | position]
+  end
+
+  ## Cache
+
+  defp cache_module({checker, table}, module) do
+    if lock(checker, module) do
+      object_code = :code.get_object_code(module)
+
+      mode =
+        with {^module, binary, _filename} <- object_code,
+             {:ok, {^module, [{~c"ExCk", chunk}]}} <- :beam_lib.chunks(binary, [~c"ExCk"]),
+             {@elixir_checker_version, contents} <- :erlang.binary_to_term(chunk) do
+          # The chunk has more information, so that's our preference
+          cache_chunk(table, module, contents)
+        else
+          _ ->
+            # Otherwise, if the module is loaded, use its info
+            case :erlang.module_loaded(module) do
+              true ->
+                {mode, exports} = info_exports(module)
+                deprecated = info_deprecated(module)
+                cache_info(table, module, exports, deprecated, %{})
+                mode
+
+              false ->
+                # Or load exports from chunk
+                with {^module, binary, _filename} <- object_code,
+                     {:ok, {^module, [exports: exports]}} <- :beam_lib.chunks(binary, [:exports]) do
+                  cache_info(table, module, exports, %{}, %{})
+                  :erlang
+                else
+                  _ -> :not_found
+                end
+            end
+        end
+
+      :ets.insert(table, {module, mode})
+      unlock(checker, module, mode)
+    end
+  end
+
+  defp info_exports(module) do
+    try do
+      module.__info__(:functions)
+    rescue
+      _ -> {:erlang, module.module_info(:exports)}
+    else
+      functions ->
+        {elixir_mode(module.module_info(:attributes)), behaviour_exports(module) ++ functions}
+    end
+  end
+
+  defp info_deprecated(module) do
+    Map.new(module.__info__(:deprecated))
+  rescue
+    _ -> %{}
+  end
+
+  defp elixir_mode(attributes) do
+    if Keyword.has_key?(attributes, :__protocol__), do: :protocol, else: :elixir
+  end
+
+  defp cache_from_module_map(table, map, signatures) do
+    exports =
+      behaviour_exports(map) ++
+        for({function, :def, _meta, _clauses} <- map.definitions, do: function)
+
+    cache_info(table, map.module, exports, Map.new(map.deprecated), signatures)
+    {elixir_mode(map.attributes), module_map_to_module_tuple(map)}
+  end
+
+  defp cache_info(table, module, exports, deprecated, sigs) do
+    Enum.each(exports, fn fa ->
+      reason = Map.get(deprecated, fa)
+      :ets.insert(table, {{module, fa}, reason, Map.get(sigs, fa, :none)})
+    end)
+  end
+
+  defp cache_chunk(table, module, contents) do
+    Enum.each(contents.exports, fn {{fun, arity}, info} ->
+      sig =
+        case info do
+          %{sig: {key, _, _} = sig} when key in [:infer, :strong] -> sig
+          _ -> :none
+        end
+
+      :ets.insert(
+        table,
+        {{module, {fun, arity}}, Map.get(info, :deprecated), sig}
+      )
+    end)
+
+    Map.get(contents, :mode, :elixir)
+  end
+
+  defp behaviour_exports(%{defines_behaviour: true}), do: [{:behaviour_info, 1}]
+  defp behaviour_exports(%{defines_behaviour: false}), do: []
+
+  defp behaviour_exports(module) when is_atom(module) do
+    if function_exported?(module, :behaviour_info, 1) do
+      [{:behaviour_info, 1}]
+    else
+      []
+    end
+  end
+
+  defp lock(server, module) do
+    :gen_server.call(server, {:lock, module}, :infinity)
+  end
+
+  defp unlock(server, module, mode) do
+    :gen_server.call(server, {:unlock, module, mode}, :infinity)
+  end
+
+  defp register(server, module, pid, ref) do
+    :gen_server.cast(server, {:register, module, pid, ref})
+  end
+
+  ## Server callbacks
+
+  def init(options) do
+    table = :ets.new(__MODULE__, [:set, :public, {:read_concurrency, true}])
+    :proc_lib.init_ack({:ok, {self(), table}})
+
+    case :elixir_config.get(:infer_signatures) do
+      false ->
+        false
+
+      applications ->
+        for application <- applications do
+          case :application.get_key(application, :modules) do
+            {:ok, modules} ->
+              :ets.insert(table, Enum.map(modules, &{&1, :uncached}))
+
+            :undefined ->
+              IO.warn(
+                "cannot infer signatures from #{inspect(application)} because it is not loaded",
+                []
+              )
+          end
+        end
+    end
+
+    schedulers =
+      Keyword.get_lazy(options, :max_concurrency, fn ->
+        max(:erlang.system_info(:schedulers_online), 2)
+      end)
+
+    threshold = Keyword.get(options, :long_verification_threshold, 10) * 1000
+
+    callback =
+      case Keyword.get(options, :each_long_verification, fn _module, _pid -> :ok end) do
+        fun when is_function(fun, 1) -> fn module, _pid -> fun.(module) end
+        fun when is_function(fun, 2) -> fun
+      end
+
+    state = %{
+      waiting: %{},
+      modules: [],
+      spawned: %{},
+      schedulers: schedulers,
+      threshold: threshold,
+      callback: callback,
+      protocols: [],
+      table: table
+    }
+
+    :gen_server.enter_loop(__MODULE__, [], state)
+  end
+
+  def handle_call(:start, _from, %{modules: modules, protocols: protocols, table: table} = state) do
+    :ets.insert(table, Enum.map(protocols, &{&1, :uncached}))
+
+    for {_module, pid, ref} <- modules do
+      send(pid, {ref, :cache})
+    end
+
+    for {_module, _pid, ref} <- modules do
+      receive do
+        {^ref, :cached} -> :ok
+      end
+    end
+
+    {:reply, length(modules), run_checkers(%{state | protocols: []})}
+  end
+
+  def handle_call({:lock, module}, from, %{waiting: waiting} = state) do
+    case waiting do
+      %{^module => from_list} ->
+        waiting = Map.put(state.waiting, module, [from | from_list])
+        {:noreply, %{state | waiting: waiting}}
+
+      %{} ->
+        waiting = Map.put(state.waiting, module, [])
+        {:reply, true, %{state | waiting: waiting}}
+    end
+  end
+
+  def handle_call({:unlock, module, mode}, _from, state) do
+    %{waiting: waiting, protocols: protocols} = state
+    from_list = Map.fetch!(waiting, module)
+    Enum.each(from_list, &:gen_server.reply(&1, false))
+
+    waiting = Map.delete(waiting, module)
+    protocols = if mode == :protocol, do: [module | protocols], else: protocols
+    {:reply, :ok, %{state | waiting: waiting, protocols: protocols}}
+  end
+
+  def handle_info({__MODULE__, :timeout, module, pid}, state) do
+    state.callback.(module, pid)
+    {:noreply, state}
+  end
+
+  def handle_info({__MODULE__, :done, module}, state) do
+    # Unfortunately we cannot assume uniqueness because the same module
+    # may be defined by mistake several times
+    {timer, spawned} = Map.pop(state.spawned, module)
+    timer && Process.cancel_timer(timer)
+    {:noreply, run_checkers(%{state | spawned: spawned})}
+  end
+
+  def handle_info({__MODULE__, :stop}, state) do
+    {:stop, :normal, state}
+  end
+
+  def handle_cast({:register, module, pid, ref}, %{modules: modules} = state) do
+    {:noreply, %{state | modules: [{module, pid, ref} | modules]}}
+  end
+
+  defp run_checkers(%{modules: []} = state) do
+    state
+  end
+
+  defp run_checkers(%{spawned: spawned, schedulers: schedulers} = state)
+       when map_size(spawned) >= schedulers do
+    state
+  end
+
+  defp run_checkers(%{modules: [{module, pid, ref} | modules]} = state) do
+    send(pid, {ref, :check})
+    timer = Process.send_after(self(), {__MODULE__, :timeout, module, pid}, state.threshold)
+    spawned = Map.put(state.spawned, module, timer)
+    run_checkers(%{state | modules: modules, spawned: spawned})
+  end
+end
diff --git a/lib/elixir/lib/module/types.ex b/lib/elixir/lib/module/types.ex
new file mode 100644
index 00000000000..bcd32fbba5d
--- /dev/null
+++ b/lib/elixir/lib/module/types.ex
@@ -0,0 +1,507 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Module.Types do
+  @moduledoc false
+  alias Module.Types.{Descr, Expr, Pattern, Helpers}
+
+  # The mode controls what happens on function application when
+  # there are gradual arguments. Non-gradual arguments always
+  # perform subtyping and return its output (OUT).
+  #
+  #   * :strict - Requires types signatures (not implemented).
+  #     * Strong arrows with gradual performs subtyping and returns OUT
+  #     * Weak arrows with gradual performs subtyping and returns OUT
+  #
+  #   * :static - Type signatures have been given.
+  #     * Strong arrows with gradual performs compatibility and returns OUT
+  #     * Weak arrows with gradual performs compatibility and returns dynamic()
+  #
+  #   * :dynamic - Type signatures have not been given.
+  #     * Strong arrows with gradual performs compatibility and returns dynamic(OUT)
+  #     * Weak arrows with gradual performs compatibility and returns dynamic()
+  #
+  #   * :infer - Same as :dynamic but skips remote calls.
+  #
+  #   * :traversal - Focused mostly on traversing AST, skips most type system
+  #     operations. Used by macros and when skipping inference.
+  #
+  # The mode may also control exhaustiveness checks in the future (to be decided).
+  # We may also want for applications with subtyping in dynamic mode to always
+  # intersect with dynamic, but this mode may be too lax (to be decided based on
+  # feedback).
+  @modes [:static, :dynamic, :infer, :traversal]
+
+  # These functions are not inferred because they are added/managed by the compiler
+  @no_infer [behaviour_info: 1]
+
+  @doc false
+  def infer(module, file, attrs, defs, private, used_private, env, {_, cache}) do
+    # We don't care about inferring signatures for protocols,
+    # those will be replaced anyway. There is also nothing to
+    # infer if there is no cache system, we only do traversals.
+    infer_signatures? =
+      :elixir_config.get(:infer_signatures) != false and cache != nil and not protocol?(attrs)
+
+    impl = impl_for(attrs)
+
+    finder =
+      fn fun_arity ->
+        case :lists.keyfind(fun_arity, 1, defs) do
+          {_, kind, _, _} = def ->
+            default_domain(infer_mode(kind, infer_signatures?), def, fun_arity, impl)
+
+          false ->
+            false
+        end
+      end
+
+    handler = fn meta, fun_arity, stack, context ->
+      case local_handler(meta, fun_arity, stack, context, finder) do
+        false ->
+          undefined_function!(:undefined_function, meta, fun_arity, stack, env)
+          false
+
+        {kind, _, _} = triplet ->
+          if (kind == :defmacro or kind == :defmacrop) and not Keyword.has_key?(meta, :super) do
+            undefined_function!(:incorrect_dispatch, meta, fun_arity, stack, env)
+            false
+          else
+            triplet
+          end
+      end
+    end
+
+    stack = stack(:infer, file, module, {:__info__, 1}, env, cache, handler)
+
+    {types, %{local_sigs: reachable_sigs} = context} =
+      for {fun_arity, kind, meta, _clauses} = def <- defs,
+          kind in [:def, :defmacro],
+          reduce: {[], context()} do
+        {types, context} ->
+          # Optimized version of finder, since we already have the definition
+          finder = fn _ ->
+            default_domain(infer_mode(kind, infer_signatures?), def, fun_arity, impl)
+          end
+
+          {_kind, inferred, context} = local_handler(meta, fun_arity, stack, context, finder)
+
+          if infer_signatures? and kind == :def and fun_arity not in @no_infer do
+            {[{fun_arity, inferred} | types], context}
+          else
+            {types, context}
+          end
+      end
+
+    # Now traverse all used privates to find any other private that have been used by them.
+    context =
+      %{local_sigs: used_sigs} =
+      for fun_arity <- used_private, reduce: context do
+        context ->
+          {_kind, _inferred, context} = local_handler([], fun_arity, stack, context, finder)
+          context
+      end
+
+    {unreachable, _context} =
+      Enum.reduce(private, {[], context}, fn
+        {fun_arity, kind, _meta, _defaults} = info, {unreachable, context} ->
+          warn_unused_def(info, used_sigs, env)
+
+          # Find anything undefined within unused functions
+          {_kind, _inferred, context} = local_handler([], fun_arity, stack, context, finder)
+
+          # defp is reachable if used, defmacrop only if directly invoked
+          private_sigs = if kind == :defp, do: used_sigs, else: reachable_sigs
+
+          if is_map_key(private_sigs, fun_arity) do
+            {unreachable, context}
+          else
+            {[fun_arity | unreachable], context}
+          end
+      end)
+
+    {Map.new(types), unreachable}
+  end
+
+  defp infer_mode(kind, infer_signatures?) do
+    if infer_signatures? and kind in [:def, :defp], do: :infer, else: :traversal
+  end
+
+  defp protocol?(attrs) do
+    List.keymember?(attrs, :__protocol__, 0)
+  end
+
+  defp impl_for(attrs) do
+    case List.keyfind(attrs, :__impl__, 0) do
+      {:__impl__, [protocol: protocol, for: for]} ->
+        if Code.ensure_loaded?(protocol) and function_exported?(protocol, :behaviour_info, 1) do
+          {for, protocol.behaviour_info(:callbacks)}
+        else
+          nil
+        end
+
+      _ ->
+        nil
+    end
+  end
+
+  defp default_domain(mode, def, {_, arity} = fun_arity, impl) do
+    with {for, callbacks} <- impl,
+         true <- fun_arity in callbacks do
+      args = [
+        Descr.dynamic(Module.Types.Of.impl(for))
+        | List.duplicate(Descr.dynamic(), arity - 1)
+      ]
+
+      {fun_arity, kind, meta, clauses} = def
+
+      clauses =
+        for {meta, args, guards, body} <- clauses do
+          {[type_check: {:impl, for}] ++ meta, args, guards, body}
+        end
+
+      {mode, {fun_arity, kind, meta, clauses}, args}
+    else
+      _ -> {mode, def, List.duplicate(Descr.dynamic(), arity)}
+    end
+  end
+
+  defp undefined_function!(reason, meta, {fun, arity}, stack, env) do
+    env = %{env | function: stack.function, file: stack.file}
+    tuple = {reason, {fun, arity}, stack.module}
+    :elixir_errors.module_error(Helpers.with_span(meta, fun), env, __MODULE__, tuple)
+  end
+
+  defp warn_unused_def({_fun_arity, _kind, false, _}, _used, _env) do
+    :ok
+  end
+
+  defp warn_unused_def({fun_arity, kind, meta, 0}, used, env) do
+    case is_map_key(used, fun_arity) do
+      true -> :ok
+      false -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_def, fun_arity, kind})
+    end
+
+    :ok
+  end
+
+  defp warn_unused_def({tuple, kind, meta, default}, used, env) when default > 0 do
+    {name, arity} = tuple
+    min = arity - default
+    max = arity
+
+    case min_reachable_default(max, min, :none, name, used) do
+      :none -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_def, tuple, kind})
+      ^min -> :ok
+      ^max -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_args, tuple})
+      diff -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_args, tuple, diff})
+    end
+
+    :ok
+  end
+
+  defp min_reachable_default(max, min, last, name, used) when max >= min do
+    fun_arity = {name, max}
+
+    case is_map_key(used, fun_arity) do
+      true -> min_reachable_default(max - 1, min, max, name, used)
+      false -> min_reachable_default(max - 1, min, last, name, used)
+    end
+  end
+
+  defp min_reachable_default(_max, _min, last, _name, _used) do
+    last
+  end
+
+  @doc false
+  def warnings(module, file, attrs, defs, no_warn_undefined, cache) do
+    impl = impl_for(attrs)
+
+    finder = fn fun_arity ->
+      case :lists.keyfind(fun_arity, 1, defs) do
+        {_, _, _, _} = def -> default_domain(:dynamic, def, fun_arity, impl)
+        false -> false
+      end
+    end
+
+    handler = &local_handler(&1, &2, &3, &4, finder)
+    stack = stack(:dynamic, file, module, {:__info__, 1}, no_warn_undefined, cache, handler)
+
+    context =
+      Enum.reduce(defs, context(), fn {fun_arity, _kind, meta, _clauses} = def, context ->
+        # Optimized version of finder, since we already the definition
+        finder = fn _ -> default_domain(:dynamic, def, fun_arity, impl) end
+        {_kind, _inferred, context} = local_handler(meta, fun_arity, stack, context, finder)
+        context
+      end)
+
+    context = warn_unused_clauses(defs, stack, context)
+    context.warnings
+  end
+
+  defp warn_unused_clauses(defs, stack, context) do
+    for {fun_arity, pending} <- context.local_used,
+        pending != [],
+        {_fun_arity, kind, meta, clauses} = List.keyfind(defs, fun_arity, 0),
+        not Keyword.get(meta, :from_super, false),
+        reduce: context do
+      context ->
+        {_kind, info, mapping} = Map.fetch!(context.local_sigs, fun_arity)
+
+        clauses_indexes =
+          for type_index <- pending,
+              not skip_unused_clause?(info, type_index),
+              {clause_index, ^type_index} <- mapping,
+              do: clause_index
+
+        Enum.reduce(clauses_indexes, context, fn clause_index, context ->
+          {meta, _args, _guards, _body} = Enum.fetch!(clauses, clause_index)
+          stack = %{stack | function: fun_arity}
+          Helpers.warn(__MODULE__, {:unused_clause, kind, fun_arity}, meta, stack, context)
+        end)
+    end
+  end
+
+  defp skip_unused_clause?(info, type_index) do
+    case info do
+      # If an inferred clause returns an empty type, then the reverse arrow
+      # will never propagate its domain up, which may lead to the clause never
+      # being invoked.
+      {:infer, _, inferred} ->
+        {_args_types, return} = Enum.fetch!(inferred, type_index)
+        Descr.empty?(return)
+
+      _ ->
+        false
+    end
+  end
+
+  defp local_handler(_meta, fun_arity, stack, context, finder) do
+    case context.local_sigs do
+      %{^fun_arity => {kind, inferred, _mapping}} ->
+        {kind, inferred, context}
+
+      %{^fun_arity => kind} when is_atom(kind) ->
+        {kind, :none, context}
+
+      local_sigs ->
+        case finder.(fun_arity) do
+          {mode, {fun_arity, kind, meta, clauses}, expected} ->
+            context = put_in(context.local_sigs, Map.put(local_sigs, fun_arity, kind))
+
+            {inferred, mapping, context} =
+              local_handler(fun_arity, kind, meta, clauses, expected, mode, stack, context)
+
+            context =
+              update_in(context.local_sigs, &Map.put(&1, fun_arity, {kind, inferred, mapping}))
+
+            {kind, inferred, context}
+
+          false ->
+            false
+        end
+    end
+  end
+
+  defp local_handler(fun_arity, kind, meta, clauses, expected, mode, stack, context) do
+    {fun, _arity} = fun_arity
+    stack = stack |> fresh_stack(mode, fun_arity) |> with_file_meta(meta)
+
+    {_, _, mapping, clauses_types, clauses_context} =
+      Enum.reduce(clauses, {0, 0, [], [], context}, fn
+        {meta, args, guards, body}, {index, total, mapping, inferred, context} ->
+          context = fresh_context(context)
+
+          try do
+            {trees, context} =
+              Pattern.of_head(args, guards, expected, {:infer, expected}, meta, stack, context)
+
+            {return_type, context} =
+              Expr.of_expr(body, Descr.term(), body, stack, context)
+
+            args_types =
+              if stack.mode == :traversal do
+                expected
+              else
+                Pattern.of_domain(trees, expected, context)
+              end
+
+            {type_index, inferred} =
+              add_inferred(inferred, args_types, return_type, total - 1, [])
+
+            if type_index == -1 do
+              {index + 1, total + 1, [{index, total} | mapping], inferred, context}
+            else
+              {index + 1, total, [{index, type_index} | mapping], inferred, context}
+            end
+          rescue
+            e ->
+              internal_error!(e, __STACKTRACE__, kind, meta, fun, args, guards, body, stack)
+          end
+      end)
+
+    domain =
+      case clauses_types do
+        [_] ->
+          nil
+
+        _ ->
+          clauses_types
+          |> Enum.map(fn {args, _} -> args end)
+          |> Enum.zip_with(fn types -> Enum.reduce(types, &Descr.union/2) end)
+      end
+
+    inferred = {:infer, domain, Enum.reverse(clauses_types)}
+    {inferred, mapping, restore_context(clauses_context, context)}
+  end
+
+  # We check for term equality of types as an optimization
+  # to reduce the amount of check we do at runtime.
+  defp add_inferred([{args, existing_return} | tail], args, return, index, acc),
+    do: {index, Enum.reverse(acc, [{args, Descr.union(existing_return, return)} | tail])}
+
+  defp add_inferred([head | tail], args, return, index, acc),
+    do: add_inferred(tail, args, return, index - 1, [head | acc])
+
+  defp add_inferred([], args, return, -1, acc),
+    do: {-1, [{args, return} | Enum.reverse(acc)]}
+
+  defp with_file_meta(stack, meta) do
+    case Keyword.fetch(meta, :file) do
+      {:ok, {meta_file, _}} -> %{stack | file: meta_file}
+      :error -> stack
+    end
+  end
+
+  defp internal_error!(e, trace, kind, meta, fun, args, guards, body, stack) do
+    def_expr = {kind, meta, [guards_to_expr(guards, {fun, [], args}), [do: body]]}
+
+    exception =
+      RuntimeError.exception("""
+      found error while checking types for #{Exception.format_mfa(stack.module, fun, length(args))}:
+
+      #{Exception.format_banner(:error, e, trace)}\
+
+      The exception happened while checking this code:
+
+      #{Macro.to_string(def_expr)}
+
+      Please report this bug at: https://github.com/elixir-lang/elixir/issues
+      """)
+
+    reraise exception, trace
+  end
+
+  defp guards_to_expr([], left) do
+    left
+  end
+
+  defp guards_to_expr([guard | guards], left) do
+    guards_to_expr(guards, {:when, [], [left, guard]})
+  end
+
+  @doc false
+  def stack(mode, file, module, function, no_warn_undefined, cache, handler)
+      when mode in @modes do
+    %{
+      # The fallback meta used for literals in patterns and guards
+      meta: [],
+      # File of module
+      file: file,
+      # Module of definitions
+      module: module,
+      # Current function
+      function: function,
+      # Handling of undefined remote calls. May be one of:
+      #
+      # * List of calls to not warn on as undefined
+      #
+      # * The atom `:all` to not mark anything as undefined
+      #
+      # * A Macro.Env struct to not mark anything as undefined
+      #   also used to extract structs from
+      #
+      no_warn_undefined: no_warn_undefined,
+      # A tuple with cache information (may be nil)
+      cache: cache,
+      # The mode to be used, see the @modes attribute
+      mode: mode,
+      # The function for handling local calls
+      local_handler: handler,
+      # Control if variable refinement is enabled.
+      # It is disabled only on dynamic dispatches.
+      refine_vars: true
+    }
+  end
+
+  @doc false
+  def context() do
+    %{
+      # A list of all warnings found so far
+      warnings: [],
+      # All vars and their types
+      vars: %{},
+      # Variables and arguments from patterns
+      pattern_info: nil,
+      # If type checking has found an error/failure
+      failed: false,
+      # Local signatures used by local handler
+      local_sigs: %{},
+      # Track which clauses have been used across private local calls
+      local_used: %{}
+    }
+  end
+
+  defp fresh_stack(stack, mode, function) when mode in @modes do
+    %{stack | mode: mode, function: function}
+  end
+
+  defp fresh_context(context) do
+    %{context | vars: %{}, failed: false}
+  end
+
+  defp restore_context(later_context, %{vars: vars, failed: failed}) do
+    %{later_context | vars: vars, failed: failed}
+  end
+
+  ## Diagnostics
+
+  def format_diagnostic({:unused_clause, kind, {fun, arity}}) do
+    %{
+      message: "this clause of #{kind} #{fun}/#{arity} is never used"
+    }
+  end
+
+  ## Module errors
+
+  def format_error({:unused_args, {name, arity}}),
+    do:
+      "default values for the optional arguments in the private function #{name}/#{arity} are never used"
+
+  def format_error({:unused_args, {name, arity}, count}) when arity - count == 1,
+    do:
+      "the default value for the last optional argument in the private function #{name}/#{arity} is never used"
+
+  def format_error({:unused_args, {name, arity}, count}),
+    do:
+      "the default values for the last #{arity - count} optional arguments in the private function #{name}/#{arity} are never used"
+
+  def format_error({:unused_def, {name, arity}, :defp}),
+    do: "function #{name}/#{arity} is unused"
+
+  def format_error({:unused_def, {name, arity}, :defmacrop}),
+    do: "macro #{name}/#{arity} is unused"
+
+  def format_error({:undefined_function, {f, a}, _})
+      when {f, a} in [__info__: 1, behaviour_info: 1, module_info: 1, module_info: 0],
+      do:
+        "undefined function #{f}/#{a} (this function is auto-generated by the compiler and must always be called as a remote, as in __MODULE__.#{f}/#{a})"
+
+  def format_error({:undefined_function, {f, a}, module}),
+    do:
+      "undefined function #{f}/#{a} (expected #{inspect(module)} to define such a function or for it to be imported, but none are available)"
+
+  def format_error({:incorrect_dispatch, {f, a}, _module}),
+    do: "cannot invoke macro #{f}/#{a} before its definition"
+end
diff --git a/lib/elixir/lib/module/types/apply.ex b/lib/elixir/lib/module/types/apply.ex
new file mode 100644
index 00000000000..2caf904786a
--- /dev/null
+++ b/lib/elixir/lib/module/types/apply.ex
@@ -0,0 +1,1366 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Module.Types.Apply do
+  # Typing functionality shared between Expr and Pattern.
+  # Generic AST and Enum helpers go to Module.Types.Helpers.
+  @moduledoc false
+
+  # We limit the size of the union for two reasons:
+  # To avoid really large outputs in reports and to
+  # reduce the computation cost of inferred code.
+  @max_clauses 16
+
+  alias Module.ParallelChecker
+  import Module.Types.{Helpers, Descr}
+
+  ## Signatures
+
+  # Define strong arrows found in the standard library.
+  # A strong arrow means that, if a type outside of its
+  # domain is given, an error is raised. We are also
+  # ensuring that domains for the same function have
+  # no overlaps.
+
+  # Remote for callback info functions
+
+  kw = fn kw ->
+    kw
+    |> Enum.map(fn {key, type} when is_atom(key) ->
+      tuple([atom([key]), type])
+    end)
+    |> Enum.reduce(&union/2)
+    |> list()
+  end
+
+  fas = list(tuple([atom(), integer()]))
+  struct_info = list(closed_map(default: if_set(term()), field: atom()))
+
+  shared_info = [
+    attributes: list(tuple([atom(), list(term())])),
+    compile: kw.(version: list(integer()), source: list(integer()), options: list(term())),
+    exports: fas,
+    md5: binary(),
+    module: atom()
+  ]
+
+  module_info = [functions: fas, nifs: fas] ++ shared_info
+
+  elixir_info =
+    [
+      deprecated: list(tuple([tuple([atom(), integer()]), binary()])),
+      exports_md5: binary(),
+      functions: fas,
+      macros: fas,
+      struct: struct_info |> union(atom([nil]))
+    ] ++ shared_info
+
+  infos =
+    [
+      # We have a special key that tracks if something is a struct or not
+      {{:__info__, true}, Keyword.put(elixir_info, :struct, struct_info)},
+      {{:__info__, false}, Keyword.put(elixir_info, :struct, atom([nil]))},
+      {:__info__, elixir_info},
+      {:behaviour_info, callbacks: fas, optional_callbacks: fas},
+      {:module_info, module_info},
+      # TODO: Move this to a type signature declared by `defprotocol` (or perhaps part of the behaviour)
+      {:__protocol__,
+       module: atom(),
+       functions: fas,
+       consolidated?: boolean(),
+       impls: union(atom([:not_consolidated]), tuple([atom([:consolidated]), list(atom())]))}
+    ]
+
+  for {name, clauses} <- infos do
+    domain = atom(Keyword.keys(clauses))
+    clauses = Enum.map(clauses, fn {key, return} -> {[atom([key])], return} end)
+
+    def signature(unquote(name), 1) do
+      {:strong, [unquote(Macro.escape(domain))], unquote(Macro.escape(clauses))}
+    end
+  end
+
+  def signature(:module_info, 0) do
+    {:strong, nil, [{[], unquote(Macro.escape(kw.(module_info)))}]}
+  end
+
+  def signature(_, _), do: :none
+
+  # Remote for compiler functions
+
+  mfargs = [atom(), atom(), list(term())]
+
+  send_destination =
+    pid()
+    |> union(reference())
+    |> union(port())
+    |> union(atom())
+    |> union(tuple([atom(), atom()]))
+
+  basic_arith_2_args_clauses = [
+    {[integer(), integer()], integer()},
+    {[integer(), float()], float()},
+    {[float(), integer()], float()},
+    {[float(), float()], float()}
+  ]
+
+  is_clauses = [{[term()], boolean()}]
+
+  args_or_arity = union(list(term()), integer())
+  args_or_none = union(list(term()), atom([:none]))
+  extra_info = kw.(file: list(integer()), line: integer(), error_info: open_map())
+
+  raise_stacktrace =
+    list(
+      tuple([atom(), atom(), args_or_arity, extra_info])
+      |> union(tuple([atom(), atom(), args_or_arity]))
+      |> union(tuple([fun(), args_or_arity, extra_info]))
+      |> union(tuple([fun(), args_or_arity]))
+    )
+
+  and_signature =
+    for left <- [true, false], right <- [true, false] do
+      {[atom([left]), atom([right])], atom([left and right])}
+    end
+
+  or_signature =
+    for left <- [true, false], right <- [true, false] do
+      {[atom([left]), atom([right])], atom([left or right])}
+    end
+
+  for {mod, fun, clauses} <- [
+        # :binary
+        {:binary, :copy, [{[binary(), integer()], binary()}]},
+
+        # :erlang
+        {:erlang, :+, [{[integer()], integer()}, {[float()], float()}]},
+        {:erlang, :+, basic_arith_2_args_clauses},
+        {:erlang, :-, [{[integer()], integer()}, {[float()], float()}]},
+        {:erlang, :-, basic_arith_2_args_clauses},
+        {:erlang, :*, basic_arith_2_args_clauses},
+        {:erlang, :/, [{[union(integer(), float()), union(integer(), float())], float()}]},
+        {:erlang, :"/=", [{[term(), term()], boolean()}]},
+        {:erlang, :"=/=", [{[term(), term()], boolean()}]},
+        {:erlang, :<, [{[term(), term()], boolean()}]},
+        {:erlang, :"=<", [{[term(), term()], boolean()}]},
+        {:erlang, :==, [{[term(), term()], boolean()}]},
+        {:erlang, :"=:=", [{[term(), term()], boolean()}]},
+        {:erlang, :>, [{[term(), term()], boolean()}]},
+        {:erlang, :>=, [{[term(), term()], boolean()}]},
+        {:erlang, :abs, [{[integer()], integer()}, {[float()], float()}]},
+        # TODO: Decide if it returns dynamic() or term()
+        {:erlang, :apply, [{[fun(), list(term())], dynamic()}]},
+        {:erlang, :apply, [{[atom(), atom(), list(term())], dynamic()}]},
+        {:erlang, :and, and_signature},
+        {:erlang, :atom_to_binary, [{[atom()], binary()}]},
+        {:erlang, :atom_to_list, [{[atom()], list(integer())}]},
+        {:erlang, :band, [{[integer(), integer()], integer()}]},
+        {:erlang, :binary_part, [{[binary(), integer(), integer()], binary()}]},
+        {:erlang, :binary_to_atom, [{[binary()], atom()}]},
+        {:erlang, :binary_to_existing_atom, [{[binary()], atom()}]},
+        {:erlang, :binary_to_integer, [{[binary()], integer()}]},
+        {:erlang, :binary_to_integer, [{[binary(), integer()], integer()}]},
+        {:erlang, :binary_to_float, [{[binary()], float()}]},
+        {:erlang, :bit_size, [{[binary()], integer()}]},
+        {:erlang, :bnot, [{[integer()], integer()}]},
+        {:erlang, :bor, [{[integer(), integer()], integer()}]},
+        {:erlang, :bsl, [{[integer(), integer()], integer()}]},
+        {:erlang, :bsr, [{[integer(), integer()], integer()}]},
+        {:erlang, :bxor, [{[integer(), integer()], integer()}]},
+        {:erlang, :byte_size, [{[binary()], integer()}]},
+        {:erlang, :ceil, [{[union(integer(), float())], integer()}]},
+        {:erlang, :div, [{[integer(), integer()], integer()}]},
+        {:erlang, :error, [{[term()], none()}]},
+        {:erlang, :error, [{[term(), args_or_none], none()}]},
+        {:erlang, :error, [{[term(), args_or_none, kw.(error_info: open_map())], none()}]},
+        {:erlang, :floor, [{[union(integer(), float())], integer()}]},
+        {:erlang, :function_exported, [{[atom(), atom(), integer()], boolean()}]},
+        {:erlang, :integer_to_binary, [{[integer()], binary()}]},
+        {:erlang, :integer_to_binary, [{[integer(), integer()], binary()}]},
+        {:erlang, :integer_to_list, [{[integer()], non_empty_list(integer())}]},
+        {:erlang, :integer_to_list, [{[integer(), integer()], non_empty_list(integer())}]},
+        {:erlang, :is_atom, is_clauses},
+        {:erlang, :is_binary, is_clauses},
+        {:erlang, :is_bitstring, is_clauses},
+        {:erlang, :is_boolean, is_clauses},
+        {:erlang, :is_float, is_clauses},
+        {:erlang, :is_function, is_clauses},
+        {:erlang, :is_function, [{[term(), integer()], boolean()}]},
+        {:erlang, :is_integer, is_clauses},
+        {:erlang, :is_list, is_clauses},
+        {:erlang, :is_map, is_clauses},
+        {:erlang, :is_map_key, [{[term(), open_map()], boolean()}]},
+        {:erlang, :is_number, is_clauses},
+        {:erlang, :is_pid, is_clauses},
+        {:erlang, :is_port, is_clauses},
+        {:erlang, :is_reference, is_clauses},
+        {:erlang, :is_tuple, is_clauses},
+        {:erlang, :length, [{[list(term())], integer()}]},
+        {:erlang, :list_to_atom, [{[list(integer())], atom()}]},
+        {:erlang, :list_to_existing_atom, [{[list(integer())], atom()}]},
+        {:erlang, :list_to_float, [{[non_empty_list(integer())], float()}]},
+        {:erlang, :list_to_integer, [{[non_empty_list(integer())], integer()}]},
+        {:erlang, :list_to_integer, [{[non_empty_list(integer()), integer()], integer()}]},
+        {:erlang, :make_ref, [{[], reference()}]},
+        {:erlang, :map_size, [{[open_map()], integer()}]},
+        {:erlang, :node, [{[], atom()}]},
+        {:erlang, :node, [{[pid() |> union(reference()) |> union(port())], atom()}]},
+        {:erlang, :not, [{[atom([false])], atom([true])}, {[atom([true])], atom([false])}]},
+        {:erlang, :or, or_signature},
+        {:erlang, :raise, [{[atom([:error, :exit, :throw]), term(), raise_stacktrace], none()}]},
+        {:erlang, :rem, [{[integer(), integer()], integer()}]},
+        {:erlang, :round, [{[union(integer(), float())], integer()}]},
+        {:erlang, :self, [{[], pid()}]},
+        {:erlang, :spawn, [{[fun(0)], pid()}]},
+        {:erlang, :spawn, [{mfargs, pid()}]},
+        {:erlang, :spawn_link, [{[fun(0)], pid()}]},
+        {:erlang, :spawn_link, [{mfargs, pid()}]},
+        {:erlang, :spawn_monitor, [{[fun(0)], tuple([reference(), pid()])}]},
+        {:erlang, :spawn_monitor, [{mfargs, tuple([reference(), pid()])}]},
+        {:erlang, :tuple_size, [{[open_tuple([])], integer()}]},
+        {:erlang, :trunc, [{[union(integer(), float())], integer()}]},
+
+        # TODO: Replace term()/dynamic() by parametric types
+        {:erlang, :++,
+         [
+           {[empty_list(), term()], dynamic(term())},
+           {[non_empty_list(term()), term()], dynamic(non_empty_list(term(), term()))}
+         ]},
+        {:erlang, :--, [{[list(term()), list(term())], dynamic(list(term()))}]},
+        {:erlang, :andalso, [{[boolean(), term()], dynamic()}]},
+        {:erlang, :delete_element, [{[integer(), open_tuple([])], dynamic(open_tuple([]))}]},
+        {:erlang, :hd, [{[non_empty_list(term(), term())], dynamic()}]},
+        {:erlang, :element, [{[integer(), open_tuple([])], dynamic()}]},
+        {:erlang, :insert_element,
+         [{[integer(), open_tuple([]), term()], dynamic(open_tuple([]))}]},
+        {:erlang, :list_to_tuple, [{[list(term())], dynamic(open_tuple([]))}]},
+        {:erlang, :max, [{[term(), term()], dynamic()}]},
+        {:erlang, :min, [{[term(), term()], dynamic()}]},
+        {:erlang, :orelse, [{[boolean(), term()], dynamic()}]},
+        {:erlang, :send, [{[send_destination, term()], dynamic()}]},
+        {:erlang, :setelement, [{[integer(), open_tuple([]), term()], dynamic(open_tuple([]))}]},
+        {:erlang, :tl, [{[non_empty_list(term(), term())], dynamic()}]},
+        {:erlang, :tuple_to_list, [{[open_tuple([])], dynamic(list(term()))}]},
+
+        ## Map
+        {:maps, :keys, [{[open_map()], dynamic(list(term()))}]},
+        {:maps, :to_list, [{[open_map()], dynamic(list(tuple([term(), term()])))}]},
+        {:maps, :values, [{[open_map()], dynamic(list(term()))}]}
+      ] do
+    [arity] = Enum.map(clauses, fn {args, _return} -> length(args) end) |> Enum.uniq()
+
+    true =
+      Code.ensure_loaded?(mod) and
+        (function_exported?(mod, fun, arity) or fun in [:orelse, :andalso])
+
+    domain_clauses =
+      case clauses do
+        [_] ->
+          {:strong, nil, clauses}
+
+        _ ->
+          domain =
+            clauses
+            |> Enum.map(fn {args, _} -> args end)
+            |> Enum.zip_with(fn types -> Enum.reduce(types, &union/2) end)
+
+          {:strong, domain, clauses}
+      end
+
+    def signature(unquote(mod), unquote(fun), unquote(arity)),
+      do: unquote(Macro.escape(domain_clauses))
+  end
+
+  def signature(_mod, _fun, _arity), do: :none
+
+  @doc """
+  Returns the domain of an unknown module.
+
+  Used only by info functions.
+  """
+  def remote_domain(_fun, args, _expected, %{mode: :traversal}) do
+    {:none, Enum.map(args, fn _ -> term() end)}
+  end
+
+  def remote_domain(fun, args, expected, _stack) do
+    arity = length(args)
+    info = signature(fun, arity)
+    {info, filter_domain(info, expected, arity)}
+  end
+
+  @doc """
+  Returns the domain of a remote function with info to apply it.
+  """
+  def remote_domain(_module, _fun, args, _expected, _meta, %{mode: :traversal}, context) do
+    {:none, Enum.map(args, fn _ -> term() end), context}
+  end
+
+  def remote_domain(:erlang, :element, [index, _], expected, _meta, _stack, context)
+      when is_integer(index) do
+    tuple = open_tuple(List.duplicate(term(), max(index - 1, 0)) ++ [expected])
+    {{:element, index}, [integer(), tuple], context}
+  end
+
+  def remote_domain(:erlang, :insert_element, [index, _, _], _expected, _meta, _stack, context)
+      when is_integer(index) do
+    tuple = open_tuple(List.duplicate(term(), max(index - 1, 0)))
+    {{:insert_element, index}, [integer(), tuple, term()], context}
+  end
+
+  def remote_domain(:erlang, :delete_element, [index, _], _expected, _meta, _stack, context)
+      when is_integer(index) do
+    tuple = open_tuple(List.duplicate(term(), max(index, 1)))
+    {{:delete_element, index}, [integer(), tuple], context}
+  end
+
+  def remote_domain(:erlang, :make_tuple, [size, _elem], _expected, _meta, _stack, context)
+      when is_integer(size) and size >= 0 do
+    {{:make_tuple, size}, [integer(), term()], context}
+  end
+
+  def remote_domain(:erlang, name, [_left, _right], _expected, _meta, stack, context)
+      when name in [:>=, :"=<", :>, :<, :min, :max] do
+    {{:ordered_compare, name, is_warning(stack)}, [term(), term()], context}
+  end
+
+  def remote_domain(:erlang, name, [_left, _right] = args, _expected, _meta, stack, context)
+      when name in [:==, :"/=", :"=:=", :"=/="] do
+    check? = is_warning(stack) and not Macro.quoted_literal?(args)
+    {{:compare, name, check?}, [term(), term()], context}
+  end
+
+  def remote_domain(mod, fun, args, expected, meta, stack, context) do
+    arity = length(args)
+
+    case :elixir_rewrite.inline(mod, fun, arity) do
+      {new_mod, new_fun} ->
+        remote_domain(new_mod, new_fun, args, expected, meta, stack, context)
+
+      false ->
+        {info, context} = signature(mod, fun, arity, meta, stack, context)
+        {info, filter_domain(info, expected, arity), context}
+    end
+  end
+
+  @doc """
+  Applies a previously collected domain from `remote_domain/7`.
+  """
+  def remote_apply(info, mod, fun, args_types, expr, stack, context) do
+    case remote_apply(mod, fun, info, args_types, stack) do
+      {:ok, type} ->
+        {type, context}
+
+      {:error, error} ->
+        mfac = mfac(expr, mod, fun, length(args_types))
+        error = {error, args_types, mfac, expr, context}
+        {error_type(), error(error, elem(expr, 1), stack, context)}
+    end
+  end
+
+  defp remote_apply(:erlang, :hd, _info, [list], stack) do
+    case list_hd(list) do
+      {:ok, value_type} -> {:ok, return(value_type, [list], stack)}
+      :badnonemptylist -> {:error, badremote(:erlang, :hd, 1)}
+    end
+  end
+
+  defp remote_apply(:erlang, :tl, _info, [list], stack) do
+    case list_tl(list) do
+      {:ok, value_type} -> {:ok, return(value_type, [list], stack)}
+      :badnonemptylist -> {:error, badremote(:erlang, :tl, 1)}
+    end
+  end
+
+  defp remote_apply(:maps, :keys, _info, [map], stack) do
+    case map_to_list(map, fn key, _value -> key end) do
+      {:ok, list_type} -> {:ok, return(list_type, [map], stack)}
+      :badmap -> {:error, badremote(:maps, :keys, 1)}
+    end
+  end
+
+  defp remote_apply(:maps, :values, _info, [map], stack) do
+    case map_to_list(map, fn _key, value -> value end) do
+      {:ok, list_type} -> {:ok, return(list_type, [map], stack)}
+      :badmap -> {:error, badremote(:maps, :keys, 1)}
+    end
+  end
+
+  defp remote_apply(:maps, :to_list, _info, [map], stack) do
+    case map_to_list(map) do
+      {:ok, list_type} -> {:ok, return(list_type, [map], stack)}
+      :badmap -> {:error, badremote(:maps, :to_list, 1)}
+    end
+  end
+
+  defp remote_apply(_mod, _fun, info, args_types, stack) do
+    remote_apply(info, args_types, stack)
+  end
+
+  defp remote_apply(:none, _args_types, _stack) do
+    {:ok, dynamic()}
+  end
+
+  defp remote_apply({:infer, _domain, clauses} = sig, args_types, _stack) do
+    case apply_infer(clauses, args_types) do
+      {_used, type} -> {:ok, type}
+      :error -> {:error, {:badremote, sig}}
+    end
+  end
+
+  defp remote_apply({:strong, domain, clauses} = sig, args_types, stack) do
+    case apply_strong(domain, clauses, args_types, stack) do
+      {_used, type} -> {:ok, type}
+      :error -> {:error, {:badremote, sig}}
+    end
+  end
+
+  defp remote_apply({:element, index}, [_, tuple] = args_types, stack) do
+    case tuple_fetch(tuple, index - 1) do
+      {_optional?, value_type} -> {:ok, return(value_type, args_types, stack)}
+      :badtuple -> {:error, badremote(:erlang, :element, 2)}
+      :badindex -> {:error, {:badindex, index, tuple}}
+    end
+  end
+
+  defp remote_apply({:insert_element, index}, [_, tuple, value] = args_types, stack) do
+    case tuple_insert_at(tuple, index - 1, value) do
+      value_type when is_descr(value_type) -> {:ok, return(value_type, args_types, stack)}
+      :badtuple -> {:error, badremote(:erlang, :insert_element, 3)}
+      :badindex -> {:error, {:badindex, index - 1, tuple}}
+    end
+  end
+
+  defp remote_apply({:delete_element, index}, [_, tuple] = args_types, stack) do
+    case tuple_delete_at(tuple, index - 1) do
+      value_type when is_descr(value_type) -> {:ok, return(value_type, args_types, stack)}
+      :badtuple -> {:error, badremote(:erlang, :delete_element, 2)}
+      :badindex -> {:error, {:badindex, index, tuple}}
+    end
+  end
+
+  defp remote_apply({:make_tuple, size}, [_, elem] = args_types, stack) do
+    {:ok, return(tuple(List.duplicate(elem, size)), args_types, stack)}
+  end
+
+  defp remote_apply({:ordered_compare, name, check?}, [left, right], stack) do
+    result =
+      if name in [:min, :max] do
+        union(left, right)
+      else
+        return(boolean(), [left, right], stack)
+      end
+
+    if not check? do
+      {:ok, result}
+    else
+      common = intersection(left, right)
+
+      cond do
+        empty?(common) and not (number_type?(left) and number_type?(right)) ->
+          {:error, :mismatched_comparison}
+
+        match?({false, _}, map_fetch_key(dynamic(common), :__struct__)) ->
+          {:error, :struct_comparison}
+
+        true ->
+          {:ok, result}
+      end
+    end
+  end
+
+  defp remote_apply({:compare, name, check?}, [left, right], stack) do
+    result = return(boolean(), [left, right], stack)
+
+    cond do
+      not check? ->
+        {:ok, result}
+
+      name in [:==, :"/="] and number_type?(left) and number_type?(right) ->
+        {:ok, result}
+
+      disjoint?(left, right) ->
+        {:error, :mismatched_comparison}
+
+      true ->
+        {:ok, result}
+    end
+  end
+
+  defp badremote(mod, fun, arity) do
+    {:badremote, signature(mod, fun, arity)}
+  end
+
+  @doc """
+  Returns the type of a remote capture.
+  """
+  def remote_capture(modules, fun, arity, meta, stack, context) do
+    cond do
+      stack.mode == :traversal ->
+        {dynamic(), context}
+
+      modules == [] ->
+        {dynamic(fun(arity)), context}
+
+      true ->
+        {type, fallback?, context} =
+          Enum.reduce(modules, {none(), false, context}, fn module, {type, fallback?, context} ->
+            case signature(module, fun, arity, meta, stack, context) do
+              {{:strong, _, clauses}, context} ->
+                {union(type, fun_from_non_overlapping_clauses(clauses)), fallback?, context}
+
+              {{:infer, _, clauses}, context} when length(clauses) <= @max_clauses ->
+                {union(type, fun_from_inferred_clauses(clauses)), fallback?, context}
+
+              {_, context} ->
+                {type, true, context}
+            end
+          end)
+
+        if fallback? do
+          {dynamic(fun(arity)), context}
+        else
+          {type, context}
+        end
+    end
+  end
+
+  @doc """
+  Gets a mfa signature.
+
+  It returns either a tuple with the remote information and the context.
+  The remote information may be one of:
+
+    * `:none` - no typing information found.
+
+    * `{:infer, domain or nil, clauses}` - clauses from inferences.
+      You must check all clauses and return the union between them.
+      They are dynamic and they can only be converted into arrows by
+      computing the union of all arguments.
+
+    * `{:strong, domain or nil, clauses}` - clauses from signatures. So far
+      these are strong arrows with non-overlapping domains
+
+  """
+  def signature(module, fun, arity, meta, stack, context) when is_atom(module) do
+    if Keyword.get(meta, :runtime_module, false) do
+      {:none, context}
+    else
+      case signature(module, fun, arity) do
+        :none -> export(module, fun, arity, meta, stack, context)
+        clauses -> {clauses, context}
+      end
+    end
+  end
+
+  defp export(_module, :module_info, arity, _meta, _stack, context) when arity in [0, 1] do
+    {signature(:module_info, arity), context}
+  end
+
+  defp export(module, fun, arity, meta, %{cache: cache} = stack, context) do
+    cond do
+      cache == nil or stack.mode == :traversal ->
+        {:none, context}
+
+      stack.mode == :infer ->
+        case ParallelChecker.fetch_export(stack.cache, module, fun, arity, false) do
+          {:ok, mode, _, info} when info == :none or mode == :protocol ->
+            {signature(fun, arity), context}
+
+          {:ok, _mode, _, info} ->
+            {info, context}
+
+          _ ->
+            {:none, context}
+        end
+
+      true ->
+        case ParallelChecker.fetch_export(stack.cache, module, fun, arity, true) do
+          {:ok, mode, reason, info} ->
+            info = if info == :none, do: signature(fun, arity), else: info
+            {info, check_deprecated(mode, module, fun, arity, reason, meta, stack, context)}
+
+          {:badfunction, mode} when mode != :erlang and fun == :__info__ and arity == 1 ->
+            key =
+              cond do
+                not Code.ensure_loaded?(module) -> :__info__
+                module.__info__(:struct) != nil -> {:__info__, true}
+                true -> {:__info__, false}
+              end
+
+            {signature(key, arity), context}
+
+          error ->
+            context =
+              if warn_undefined?(module, fun, arity, stack) do
+                warn(__MODULE__, {:undefined, error, module, fun, arity}, meta, stack, context)
+              else
+                context
+              end
+
+            {:none, context}
+        end
+    end
+  end
+
+  defp check_deprecated(:erlang, module, fun, arity, _reason, meta, stack, context) do
+    case :otp_internal.obsolete(module, fun, arity) do
+      {:deprecated, string} when is_list(string) ->
+        reason = string |> List.to_string() |> :string.titlecase()
+        warn(__MODULE__, {:deprecated, module, fun, arity, reason}, meta, stack, context)
+
+      {:deprecated, string, removal} when is_list(string) and is_list(removal) ->
+        reason = string |> List.to_string() |> :string.titlecase()
+        reason = "It will be removed in #{removal}. #{reason}"
+        warn(__MODULE__, {:deprecated, module, fun, arity, reason}, meta, stack, context)
+
+      _ ->
+        context
+    end
+  end
+
+  defp check_deprecated(_elixir_or_protocol, module, fun, arity, reason, meta, stack, context) do
+    if reason do
+      warn(__MODULE__, {:deprecated, module, fun, arity, reason}, meta, stack, context)
+    else
+      context
+    end
+  end
+
+  defp warn_undefined?(_, _, _, %{no_warn_undefined: %Macro.Env{}}) do
+    false
+  end
+
+  defp warn_undefined?(_, _, _, %{no_warn_undefined: :all}) do
+    false
+  end
+
+  defp warn_undefined?(module, fun, arity, stack) do
+    not Enum.any?(stack.no_warn_undefined, &(&1 == module or &1 == {module, fun, arity}))
+  end
+
+  ## Funs
+
+  def fun_apply(fun_type, args_types, call, stack, context) do
+    case fun_apply(fun_type, args_types) do
+      {:ok, res} ->
+        {res, context}
+
+      reason ->
+        error = {{:badapply, reason}, args_types, fun_type, call, context}
+        {error_type(), error(__MODULE__, error, elem(call, 1), stack, context)}
+    end
+  end
+
+  ## Local
+
+  def local_domain(fun, args, expected, meta, stack, context) do
+    arity = length(args)
+
+    case stack.local_handler.(meta, {fun, arity}, stack, context) do
+      false ->
+        {{false, :none}, List.duplicate(term(), arity), context}
+
+      {kind, info, context} ->
+        update_used? = is_warning(stack) and kind == :defp
+
+        if stack.mode == :traversal or info == :none do
+          {{update_used?, :none}, List.duplicate(term(), arity), context}
+        else
+          {{update_used?, info}, filter_domain(info, expected, arity), context}
+        end
+    end
+  end
+
+  def local_apply({update_used?, :none}, fun, args_types, _expr, _stack, context) do
+    if update_used? do
+      {dynamic(), put_in(context.local_used[{fun, length(args_types)}], [])}
+    else
+      {dynamic(), context}
+    end
+  end
+
+  def local_apply({update_used?, info}, fun, args_types, expr, stack, context) do
+    case local_apply(info, args_types, stack) do
+      {indexes, type} ->
+        context =
+          if update_used? do
+            update_in(context.local_used[{fun, length(args_types)}], fn current ->
+              (current || used_from_clauses(info)) -- indexes
+            end)
+          else
+            context
+          end
+
+        {type, context}
+
+      :error ->
+        error = {:badlocal, info, args_types, expr, context}
+        {error_type(), error(error, with_span(elem(expr, 1), fun), stack, context)}
+    end
+  end
+
+  defp local_apply({:infer, _domain, clauses}, args_types, _stack) do
+    apply_infer(clauses, args_types)
+  end
+
+  defp local_apply({:strong, domain, clauses}, args_types, stack) do
+    apply_strong(domain, clauses, args_types, stack)
+  end
+
+  defp used_from_clauses({_strong_or_infer, _domain, clauses}),
+    do: Enum.with_index(clauses, fn _, i -> i end)
+
+  @doc """
+  Deal with local captures.
+  """
+  def local_capture(fun, arity, meta, stack, context) do
+    fun_arity = {fun, arity}
+
+    case stack.local_handler.(meta, fun_arity, stack, context) do
+      false ->
+        {dynamic(fun(arity)), context}
+
+      {_kind, _info, context} when stack.mode == :traversal ->
+        {dynamic(fun(arity)), context}
+
+      {kind, info, context} ->
+        result =
+          case info do
+            {:infer, _, clauses} when length(clauses) <= @max_clauses ->
+              fun_from_inferred_clauses(clauses)
+
+            _ ->
+              dynamic(fun(arity))
+          end
+
+        context =
+          if stack.mode != :infer and kind == :defp do
+            # Mark all clauses as used, as the function is being exported.
+            put_in(context.local_used[fun_arity], [])
+          else
+            context
+          end
+
+        {result, context}
+    end
+  end
+
+  ## Application helpers
+
+  defp return(type, args_types, stack) do
+    cond do
+      stack.mode == :static -> type
+      Enum.any?(args_types, &gradual?/1) -> dynamic(type)
+      true -> type
+    end
+  end
+
+  defp domain(nil, [{domain, _}]), do: domain
+  defp domain(domain, _clauses), do: domain
+
+  @term_or_dynamic [term(), dynamic()]
+
+  defp filter_domain(:none, _expected, arity) do
+    List.duplicate(term(), arity)
+  end
+
+  defp filter_domain({_, domain, clauses}, expected, _arity) when expected in @term_or_dynamic do
+    domain(domain, clauses)
+  end
+
+  defp filter_domain({_type, domain, clauses}, expected, arity) do
+    case filter_domain(clauses, expected, [], true) do
+      :none -> List.duplicate(term(), arity)
+      :all -> domain(domain, clauses)
+      args -> Enum.zip_with(args, fn types -> Enum.reduce(types, &union/2) end)
+    end
+  end
+
+  defp filter_domain([{args, return} | clauses], expected, acc, all_compatible?) do
+    case compatible?(return, expected) do
+      true -> filter_domain(clauses, expected, [args | acc], all_compatible?)
+      false -> filter_domain(clauses, expected, acc, false)
+    end
+  end
+
+  defp filter_domain([], _expected, [], _all_compatible?), do: :none
+  defp filter_domain([], _expected, _acc, true), do: :all
+  defp filter_domain([], _expected, acc, false), do: acc
+
+  defp apply_infer(clauses, args_types) do
+    case apply_clauses(clauses, args_types, 0, 0, [], []) do
+      {0, [], []} ->
+        :error
+
+      {count, used, _returns} when count > @max_clauses ->
+        {used, dynamic()}
+
+      {_count, used, returns} ->
+        {used, returns |> Enum.reduce(&union/2) |> dynamic()}
+    end
+  end
+
+  defp apply_strong(_domain, [{expected, return}], args_types, stack) do
+    # Optimize single clauses as the domain is the single clause args.
+    case zip_compatible?(args_types, expected) do
+      true -> {[0], return(return, args_types, stack)}
+      false -> :error
+    end
+  end
+
+  defp apply_strong(domain, clauses, args_types, stack) do
+    # If the type is only gradual, the compatibility check is the same
+    # as a non disjoint check. So we skip checking compatibility twice.
+    with true <- zip_compatible_or_only_gradual?(args_types, domain),
+         {count, used, returns} when count > 0 <- apply_clauses(clauses, args_types, 0, 0, [], []) do
+      {used, returns |> Enum.reduce(&union/2) |> return(args_types, stack)}
+    else
+      _ -> :error
+    end
+  end
+
+  defp apply_clauses([{expected, return} | clauses], args_types, index, count, used, returns) do
+    if zip_not_disjoint?(args_types, expected) do
+      apply_clauses(clauses, args_types, index + 1, count + 1, [index | used], [return | returns])
+    else
+      apply_clauses(clauses, args_types, index + 1, count, used, returns)
+    end
+  end
+
+  defp apply_clauses([], _args_types, _index, count, used, returns) do
+    {count, used, returns}
+  end
+
+  defp zip_compatible_or_only_gradual?([actual | actuals], [expected | expecteds]) do
+    (only_gradual?(actual) or compatible?(actual, expected)) and
+      zip_compatible_or_only_gradual?(actuals, expecteds)
+  end
+
+  defp zip_compatible_or_only_gradual?([], []), do: true
+
+  defp zip_compatible?([actual | actuals], [expected | expecteds]) do
+    compatible?(actual, expected) and zip_compatible?(actuals, expecteds)
+  end
+
+  defp zip_compatible?([], []), do: true
+
+  defp zip_not_disjoint?([actual | actuals], [expected | expecteds]) do
+    not disjoint?(actual, expected) and zip_not_disjoint?(actuals, expecteds)
+  end
+
+  defp zip_not_disjoint?([], []), do: true
+
+  ## Error handling
+
+  defp error(warning, meta, stack, context) do
+    error(__MODULE__, warning, meta, stack, context)
+  end
+
+  ## Diagnostics
+
+  def format_diagnostic({{:badapply, reason}, args_types, fun_type, expr, context}) do
+    {message, to_trace, hints} =
+      case reason do
+        {:badarg, domain} ->
+          message = """
+          incompatible types given on function application:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          given types:
+
+              #{args_to_quoted_string(args_types, domain, &Function.identity/1) |> indent(4)}
+
+          but function has type:
+
+              #{to_quoted_string(fun_type) |> indent(4)}
+          """
+
+          hints =
+            cond do
+              not empty?(args_to_domain(domain)) -> []
+              match?({:or, _, _}, to_quoted(fun_type)) -> [:empty_union_domain]
+              true -> [:empty_domain]
+            end
+
+          # When there is an argument error, we trace the arguments
+          {message, elem(expr, 2), hints}
+
+        {:badarity, arities} ->
+          info =
+            case arities do
+              [arity] -> "function with arity #{arity}"
+              _ -> "function with arities #{Enum.join(arities, ",")}"
+            end
+
+          message = """
+          expected a #{length(args_types)}-arity function on call:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got #{info}:
+
+              #{to_quoted_string(fun_type) |> indent(4)}
+          """
+
+          {message, elem(expr, 0), []}
+
+        :badfun ->
+          message = """
+          expected a #{length(args_types)}-arity function on call:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(fun_type) |> indent(4)}
+          """
+
+          {message, elem(expr, 0), []}
+      end
+
+    traces = collect_traces(to_trace, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message: IO.iodata_to_binary([message, format_traces(traces), format_hints(hints)])
+    }
+  end
+
+  def format_diagnostic({:badlocal, {_, domain, clauses}, args_types, expr, context}) do
+    domain = domain(domain, clauses)
+    traces = collect_traces(expr, context)
+    converter = &Function.identity/1
+    {fun, meta, _} = expr
+
+    explanation =
+      empty_arg_reason(args_types) ||
+        """
+        but expected one of:
+        #{clauses_args_to_quoted_string(clauses, converter, [])}
+        """
+
+    banner =
+      case fun == :super && meta[:default] && meta[:super] do
+        {_kind, fun} ->
+          """
+          incompatible types given as default arguments to #{fun}/#{length(args_types)}:
+          """
+
+        _ ->
+          """
+          incompatible types given to #{fun}/#{length(args_types)}:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          given types:
+          """
+      end
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          banner,
+          """
+
+              #{args_to_quoted_string(args_types, domain, converter) |> indent(4)}
+
+          """,
+          explanation,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  def format_diagnostic({{:badindex, index, type}, _args_types, mfac, expr, context}) do
+    traces = collect_traces(expr, context)
+    {mod, fun, arity, _converter} = mfac
+    mfa = Exception.format_mfa(mod, fun, arity)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected a tuple with at least #{pluralize(index, "element", "elements")} in #{mfa}:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          the given type does not have the given index:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  def format_diagnostic({{:badremote, {_, domain, clauses}}, args_types, mfac, expr, context}) do
+    domain = domain(domain, clauses)
+    {mod, fun, arity, converter} = mfac
+    meta = elem(expr, 1)
+
+    {banner, traces} =
+      case Keyword.get(meta, :type_check) do
+        :interpolation ->
+          {_, _, [arg]} = expr
+
+          {"""
+           incompatible value given to string interpolation:
+
+               #{expr_to_string(arg) |> indent(4)}
+
+           it has type:
+           """, collect_traces(expr, context)}
+
+        :generator ->
+          {:<-, _, [_, arg]} = expr
+
+          {"""
+           incompatible value given to for-comprehension:
+
+               #{expr_to_string(expr) |> indent(4)}
+
+           it has type:
+           """, collect_traces(arg, context)}
+
+        :into ->
+          {"""
+           incompatible value given to :into option in for-comprehension:
+
+               into: #{expr_to_string(expr) |> indent(4)}
+
+           it has type:
+           """, collect_traces(expr, context)}
+
+        _ ->
+          mfa_or_fa = if mod, do: Exception.format_mfa(mod, fun, arity), else: "#{fun}/#{arity}"
+
+          {"""
+           incompatible types given to #{mfa_or_fa}:
+
+               #{expr_to_string(expr) |> indent(4)}
+
+           given types:
+           """, collect_traces(expr, context)}
+      end
+
+    {explanation, impls} =
+      cond do
+        reason = empty_arg_reason(converter.(args_types)) ->
+          {reason, ""}
+
+        Code.ensure_loaded?(mod) and
+            Keyword.has_key?(mod.module_info(:attributes), :__protocol__) ->
+          if function_exported?(mod, :__protocol__, 1) and
+               mod.__protocol__(:impls) == {:consolidated, []} do
+            {"""
+             but the #{inspect(mod)} protocol was not yet implemented \
+             for any type and therefore will always fail.
+
+             This warning will disappear once you define a implementation. \
+             If the protocol is part of a library, you may define a dummy \
+             implementation for development/test.
+             """, ""}
+          else
+            fix =
+              case mod do
+                String.Chars ->
+                  """
+                  You either passed the wrong value or you must:
+
+                  1. convert the given value to a string explicitly
+                     (use inspect/1 if you want to convert any data structure to a string)
+                  2. implement the String.Chars protocol
+                  """
+
+                Enumerable ->
+                  """
+                  You either passed the wrong value or you must:
+
+                  1. convert the given value to an Enumerable explicitly
+                  2. implement the Enumerable protocol
+                  """
+
+                _ ->
+                  """
+                  You either passed the wrong value or you forgot to implement the protocol.
+                  """
+              end
+
+            {"""
+             but expected a type that implements the #{inspect(mod)} protocol.
+             #{fix}\
+             """,
+             """
+
+             #{hint()} the #{inspect(mod)} protocol is implemented for the following types:
+             #{clauses_args_to_quoted_string(clauses, converter, collapse_structs: true)}
+             """}
+          end
+
+        true ->
+          {"""
+           but expected one of:
+           #{clauses_args_to_quoted_string(clauses, converter, [])}
+           """, ""}
+      end
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          banner,
+          """
+
+              #{args_to_quoted_string(args_types, domain, converter) |> indent(4)}
+
+          """,
+          explanation,
+          format_traces(traces),
+          impls
+        ])
+    }
+  end
+
+  def format_diagnostic({:mismatched_comparison, [left, right], mfac, expr, context}) do
+    {_, name, _, _} = mfac
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          comparison between distinct types found:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          given types:
+
+              #{type_comparison_to_string(name, left, right) |> indent(4)}
+          """,
+          format_traces(traces),
+          """
+
+          While Elixir can compare across all types, you are comparing \
+          across types which are always disjoint, and the result is either \
+          always true or always false
+          """
+        ])
+    }
+  end
+
+  def format_diagnostic({:struct_comparison, [left, right], mfac, expr, context}) do
+    {_, name, _, _} = mfac
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          comparison with structs found:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          given types:
+
+              #{type_comparison_to_string(name, left, right) |> indent(4)}
+          """,
+          format_traces(traces),
+          """
+
+          Comparison operators (>, <, >=, <=, min, and max) perform structural \
+          and not semantic comparison. Comparing with a struct won't give meaningful \
+          results. Structs that can be compared typically define a compare/2 function \
+          within their modules that can be used for semantic comparison.
+          """
+        ])
+    }
+  end
+
+  def format_diagnostic({:undefined, :badmodule, module, fun, arity}) do
+    top =
+      if fun == :__struct__ and arity == 0 do
+        "struct #{inspect(module)}"
+      else
+        Exception.format_mfa(module, fun, arity)
+      end
+
+    %{
+      message:
+        IO.iodata_to_binary([
+          top,
+          " is undefined (module ",
+          inspect(module),
+          " is not available or is yet to be defined)",
+          UndefinedFunctionError.hint_for_missing_module(module, fun, arity)
+        ]),
+      group: true
+    }
+  end
+
+  def format_diagnostic({:undefined, {:badfunction, _}, module, :__struct__, 0}) do
+    %{
+      message:
+        "struct #{inspect(module)} is undefined (there is such module but it does not define a struct)",
+      group: true
+    }
+  end
+
+  def format_diagnostic({:undefined, {:badfunction, _}, module, fun, arity}) do
+    _ = Code.ensure_loaded(module)
+
+    %{
+      message:
+        IO.iodata_to_binary([
+          Exception.format_mfa(module, fun, arity),
+          " is undefined or private",
+          UndefinedFunctionError.hint_for_loaded_module(module, fun, arity)
+        ]),
+      group: true
+    }
+  end
+
+  def format_diagnostic({:deprecated, module, fun, arity, reason}) do
+    %{
+      message:
+        IO.iodata_to_binary([
+          Exception.format_mfa(module, fun, arity),
+          " is deprecated. ",
+          reason
+        ]),
+      group: true
+    }
+  end
+
+  defp empty_arg_reason(args_types) do
+    if i = Enum.find_index(args_types, &empty?/1) do
+      """
+      the #{integer_to_ordinal(i + 1)} argument is empty (often represented as none()), \
+      most likely because it is the result of an expression that always fails, such as \
+      a `raise` or a previous invalid call. This causes any function called with this \
+      value to fail
+      """
+    end
+  end
+
+  defp pluralize(1, singular, _), do: "1 #{singular}"
+  defp pluralize(i, _, plural), do: "#{i} #{plural}"
+
+  defp mfac({{:., _, [mod, fun]}, _, args}, _mod, _fun, _arity)
+       when is_atom(mod) and is_atom(fun) do
+    {mod, fun, args, converter} = :elixir_rewrite.erl_to_ex(mod, fun, args)
+    {mod, fun, length(args), converter}
+  end
+
+  defp mfac(_, mod, fun, arity)
+       when is_atom(mod) and is_atom(fun) and is_integer(arity) do
+    {mod, fun, arity, & &1}
+  end
+
+  ## Algebra helpers
+
+  alias Inspect.Algebra, as: IA
+
+  defp type_comparison_to_string(fun, left, right) do
+    {_, fun, _, _} = :elixir_rewrite.erl_to_ex(:erlang, fun, [left, right])
+
+    {fun, [], [to_quoted(left, collapse_structs: true), to_quoted(right, collapse_structs: true)]}
+    |> Code.Formatter.to_algebra()
+    |> Inspect.Algebra.format(98)
+    |> IO.iodata_to_binary()
+  end
+
+  defp clauses_args_to_quoted_string([{args, _return}], converter, opts) do
+    "\n    " <> (clause_args_to_quoted_string(args, converter, opts) |> indent(4))
+  end
+
+  defp clauses_args_to_quoted_string(clauses, converter, opts) do
+    clauses
+    |> Enum.with_index(fn {args, _return}, index ->
+      """
+
+      ##{index + 1}
+      #{clause_args_to_quoted_string(args, converter, opts)}\
+      """
+      |> indent(4)
+    end)
+    |> Enum.join("\n")
+  end
+
+  defp clause_args_to_quoted_string(args, converter, opts) do
+    docs = Enum.map(args, &(&1 |> to_quoted(opts) |> Code.Formatter.to_algebra()))
+    args_docs_to_quoted_string(converter.(docs))
+  end
+
+  defp args_to_quoted_string(args_types, domain, converter) do
+    docs =
+      Enum.zip_with(args_types, domain, fn actual, expected ->
+        if compatible?(actual, expected) or not has_simple_difference?(actual, expected) do
+          actual |> to_quoted() |> Code.Formatter.to_algebra()
+        else
+          common = intersection(actual, expected)
+
+          uncommon_doc =
+            difference(actual, expected)
+            |> to_quoted()
+            |> Code.Formatter.to_algebra()
+            |> ansi_red()
+
+          if empty?(common) do
+            uncommon_doc
+          else
+            common_doc = common |> to_quoted() |> Code.Formatter.to_algebra()
+            IA.glue(IA.concat(uncommon_doc, " or"), IA.nest(common_doc, 2))
+          end
+        end
+      end)
+
+    args_docs_to_quoted_string(converter.(docs))
+  end
+
+  @composite_types non_empty_list(term(), term())
+                   |> union(tuple())
+                   |> union(open_map())
+                   |> union(fun())
+
+  # If actual/expected have a composite type, computing the
+  # `intersection(actual, expected) or difference(actual, expected)`
+  # can lead to an explosion of terms that actually make debugging
+  # harder. So we check that at least one of the two operations
+  # return none() (i.e. actual is a subtype or they are disjoint).
+  defp has_simple_difference?(actual, expected) do
+    composite_types = intersection(actual, @composite_types)
+    subtype?(composite_types, expected) or disjoint?(composite_types, expected)
+  end
+
+  defp ansi_red(doc) do
+    if IO.ANSI.enabled?() do
+      IA.concat(IA.color(doc, IO.ANSI.red()), IA.color(IA.empty(), IO.ANSI.reset()))
+    else
+      IA.concat(["-", doc, "-"])
+    end
+  end
+
+  defp args_docs_to_quoted_string(docs) do
+    doc = IA.fold(docs, fn doc, acc -> IA.glue(IA.concat(doc, ","), acc) end)
+
+    wrapped_docs =
+      case docs do
+        [_] -> IA.concat("(", IA.concat(doc, ")"))
+        _ -> IA.group(IA.glue(IA.nest(IA.glue("(", "", doc), 2), "", ")"))
+      end
+
+    wrapped_docs
+    |> IA.format(98)
+    |> IO.iodata_to_binary()
+    |> case do
+      "(\n" <> _ = multiple_lines -> multiple_lines
+      single_line -> binary_slice(single_line, 1..-2//1)
+    end
+  end
+end
diff --git a/lib/elixir/lib/module/types/descr.ex b/lib/elixir/lib/module/types/descr.ex
new file mode 100644
index 00000000000..185e60dee20
--- /dev/null
+++ b/lib/elixir/lib/module/types/descr.ex
@@ -0,0 +1,5123 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Module.Types.Descr do
+  @moduledoc false
+
+  # The descr contains a set-theoretic implementation of types.
+  # Types are represented as maps of non-overlapping unions.
+  # A bitmap is used to represent non-divisible types. All other
+  # types require specific data structures.
+
+  # Vocabulary:
+  #
+  # * DNF - disjunctive normal form which is a pair of unions and negations
+  # * BDD - binary decision diagram which is a set-theoretic representation of types as a tree
+
+  import Bitwise
+
+  @bit_binary 1 <<< 0
+  @bit_empty_list 1 <<< 1
+  @bit_integer 1 <<< 2
+  @bit_float 1 <<< 3
+  @bit_pid 1 <<< 4
+  @bit_port 1 <<< 5
+  @bit_reference 1 <<< 6
+  @bit_top (1 <<< 7) - 1
+  @bit_number @bit_integer ||| @bit_float
+
+  defmacro bdd_leaf(arg1, arg2), do: {arg1, arg2}
+
+  @domain_key_types [:binary, :integer, :float, :pid, :port, :reference] ++
+                      [:fun, :atom, :tuple, :map, :list]
+
+  # Remark: those are explicit BDD constructors. The functional constructors are `bdd_new/1` and `bdd_new/3`.
+  @fun_top {:negation, %{}}
+  @atom_top {:negation, :sets.new(version: 2)}
+  @map_top {:open, %{}}
+  @non_empty_list_top {:term, :term}
+  @tuple_top {:open, []}
+  @map_empty {:closed, %{}}
+
+  # The top BDD for each arity.
+  @fun_bdd_top :bdd_top
+
+  @none %{}
+  @term %{
+    bitmap: @bit_top,
+    atom: @atom_top,
+    tuple: @tuple_top,
+    map: @map_top,
+    list: @non_empty_list_top,
+    fun: @fun_top
+  }
+  @list_top %{bitmap: @bit_empty_list, list: @non_empty_list_top}
+  @empty_list %{bitmap: @bit_empty_list}
+  @not_non_empty_list Map.delete(@term, :list)
+
+  @not_set %{optional: 1}
+  @term_or_optional Map.put(@term, :optional, 1)
+  @term_or_dynamic_optional Map.put(@term, :dynamic, %{optional: 1})
+  @not_atom_or_optional Map.delete(@term_or_optional, :atom)
+
+  @empty_intersection [0, :bdd_bot]
+  @empty_difference [0, :bdd_bot]
+
+  defguard is_descr(descr) when is_map(descr) or descr == :term
+
+  defp descr_key?(:term, _key), do: true
+  defp descr_key?(descr, key), do: is_map_key(descr, key)
+
+  def dynamic(), do: %{dynamic: :term}
+  def none(), do: @none
+  def term(), do: :term
+
+  @compile {:inline, unfold: 1}
+  defp unfold(:term), do: unfolded_term()
+  defp unfold(other), do: other
+  defp unfolded_term, do: @term
+
+  def atom(as), do: %{atom: atom_new(as)}
+  def atom(), do: %{atom: @atom_top}
+  def binary(), do: %{bitmap: @bit_binary}
+  def closed_map(pairs), do: map_descr(:closed, pairs, term_or_optional(), false)
+  def empty_list(), do: %{bitmap: @bit_empty_list}
+  def empty_map(), do: %{map: @map_empty}
+  def integer(), do: %{bitmap: @bit_integer}
+  def float(), do: %{bitmap: @bit_float}
+  def list(type), do: list_descr(type, @empty_list, true)
+  def non_empty_list(type, tail \\ @empty_list), do: list_descr(type, tail, false)
+  def open_map(), do: %{map: @map_top}
+  def open_map(pairs), do: map_descr(:open, pairs, term_or_optional(), false)
+  def open_map(pairs, default), do: map_descr(:open, pairs, if_set(default), true)
+  def open_tuple(elements, _fallback \\ term()), do: tuple_descr(:open, elements)
+  def pid(), do: %{bitmap: @bit_pid}
+  def port(), do: %{bitmap: @bit_port}
+  def reference(), do: %{bitmap: @bit_reference}
+  def tuple(), do: %{tuple: @tuple_top}
+  def tuple(elements), do: tuple_descr(:closed, elements)
+
+  @boolset :sets.from_list([true, false], version: 2)
+  def boolean(), do: %{atom: {:union, @boolset}}
+
+  ## Function constructors
+
+  @doc """
+  The top function type.
+  """
+  def fun(), do: %{fun: @fun_top}
+
+  @doc """
+  Creates a function type with the given arguments and return type.
+
+  ## Examples
+
+      fun([integer()], atom())
+      #=> (integer -> atom)
+
+      fun([integer(), float()], boolean())
+      #=> (integer, float -> boolean)
+  """
+  def fun(args, return) when is_list(args), do: fun_descr(args, return)
+
+  @doc """
+  Creates the top function type for the given arity,
+  where all arguments are none() and return is term().
+
+  This function cannot be applied to, unless it is made dynamic.
+
+  ## Examples
+
+      fun(1)
+      #=> (none -> term)
+
+      fun(2)
+      #=> Creates (none, none -> term)
+  """
+  def fun(arity) when is_integer(arity) and arity >= 0 do
+    %{fun: {:union, %{arity => @fun_bdd_top}}}
+  end
+
+  @doc """
+  Creates a function from non-overlapping function clauses.
+  """
+  def fun_from_non_overlapping_clauses([{args, return} | clauses]) do
+    Enum.reduce(clauses, fun(args, return), fn {args, return}, acc ->
+      intersection(acc, fun(args, return))
+    end)
+  end
+
+  @doc """
+  Creates a function from overlapping function clauses.
+  """
+  def fun_from_inferred_clauses(args_clauses) do
+    domain_clauses =
+      Enum.reduce(args_clauses, [], fn {args, return}, acc ->
+        domain = args |> Enum.map(&upper_bound/1) |> args_to_domain()
+        return = upper_bound(return)
+        pivot_overlapping_clause(domain, return, return, acc)
+      end)
+
+    funs =
+      for {domain, _return, union} <- domain_clauses,
+          args <- domain_to_args(domain),
+          do: fun(args, dynamic(union))
+
+    Enum.reduce(funs, &intersection/2)
+  end
+
+  # If you have a function with multiple clauses, they may overlap,
+  # and we need to find the correct return type. This can be done
+  # in two different algorithms: a precise and a fast one.
+  # Consider the inferred clauses:
+  #
+  #     (integer() or atom() -> :foo) and (integer() or float() -> :bar)
+  #
+  # The precise algorithm works by finding the intersections between
+  # domains, assigning it the union, and then computing the leftovers
+  # on each side. The trouble of this approach is that it builds
+  # differences, which can be expensive, and can lead to several new
+  # clauses. For example, the clause above would emit:
+  #
+  #     (integer() -> :foo or :bar) and (atom() -> :foo) and (float() -> :bar)
+  #
+  # Due to performance constraints, we chose the fast approach, which
+  # leads to broad return types, but this is acceptable because we mark
+  # all return types as dynamic anyway. Therefore we infer the type:
+  #
+  #     (integer() or atom() -> :foo or :bar) and (integer() or float() -> :foo or :bar)
+  #
+  defp pivot_overlapping_clause(domain, return, union, [{acc_domain, acc_return, acc_union} | acc]) do
+    if disjoint?(domain, acc_domain) do
+      [
+        {acc_domain, acc_return, acc_union}
+        | pivot_overlapping_clause(domain, return, union, acc)
+      ]
+    else
+      [
+        {acc_domain, acc_return, union(return, acc_union)}
+        | pivot_overlapping_clause(domain, return, union(acc_return, union), acc)
+      ]
+    end
+  end
+
+  defp pivot_overlapping_clause(domain, return, union, []) do
+    [{domain, return, union}]
+  end
+
+  @doc """
+  Converts a list of arguments into a domain.
+
+  Tuples represent function domains, using unions to combine parameters.
+
+  Example: for functions (integer(), float() -> :ok) and (float(), integer() -> :error)
+  domain isn't `{integer() or float(), integer() or float()}` as that would incorrectly
+  accept `{float(), float()}`, instead it is `{integer(), float()} or {float(), integer()}`.
+  """
+  def args_to_domain(types) when is_list(types), do: tuple(types)
+
+  @doc """
+  Converts the domain to a list of arguments.
+
+  The domain is expected to be closed tuples. They may have complex negations
+  which are then simplified to a union of positive tuple literals only.
+
+  * For static tuple types: eliminates all negations from the DNF representation.
+
+  * For gradual tuple types: processes both dynamic and static components separately,
+    then combines them.
+
+  The list of arguments can be flattened into a broad domain by calling:
+
+      |> Enum.zip_with(fn types -> Enum.reduce(types, &union/2) end)
+  """
+  def domain_to_args(descr) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        unwrap_domain_tuple(descr, fn {:closed, elems} -> elems end)
+
+      {dynamic, static} ->
+        unwrap_domain_tuple(static, fn {:closed, elems} -> elems end) ++
+          unwrap_domain_tuple(dynamic, fn {:closed, elems} -> Enum.map(elems, &dynamic/1) end)
+    end
+  end
+
+  defp unwrap_domain_tuple(%{tuple: bdd} = descr, transform) when map_size(descr) == 1 do
+    tuple_normalize(bdd) |> Enum.map(transform)
+  end
+
+  defp unwrap_domain_tuple(descr, _transform) when descr == %{}, do: []
+
+  defp domain_to_flat_args(domain, arity) do
+    case domain_to_args(domain) do
+      [] -> List.duplicate(none(), arity)
+      args -> Enum.zip_with(args, fn types -> Enum.reduce(types, &union/2) end)
+    end
+  end
+
+  ## Optional
+
+  # `not_set()` is a special base type that represents an not_set field in a map.
+  # E.g., `%{a: integer(), b: not_set(), ...}` represents a map with an integer
+  # field `a` and an not_set field `b`, and possibly other fields.
+  #
+  # The `if_set()` modifier is syntactic sugar for specifying the key as a union
+  # of the key type and `not_set()`. For example, `%{:foo => if_set(integer())}`
+  # is equivalent to `%{:foo => integer() or not_set()}`.
+  #
+  # `not_set()` has no meaning outside of map types.
+  def not_set(), do: @not_set
+
+  def if_set(:term), do: term_or_optional()
+
+  # If type contains a :dynamic part, :optional gets added there.
+  def if_set(type) do
+    case type do
+      %{dynamic: dyn} -> Map.put(%{type | dynamic: Map.put(dyn, :optional, 1)}, :optional, 1)
+      _ -> Map.put(type, :optional, 1)
+    end
+  end
+
+  defp term_or_optional(), do: @term_or_optional
+
+  @compile {:inline,
+            keep_optional: 1, remove_optional: 1, remove_optional_static: 1, optional_to_term: 1}
+  defp keep_optional(descr) do
+    case descr do
+      %{dynamic: %{optional: 1}} -> %{dynamic: %{optional: 1}}
+      %{optional: 1} -> %{optional: 1}
+      _ -> @none
+    end
+  end
+
+  defp remove_optional(descr) do
+    case descr do
+      %{dynamic: %{optional: _} = dynamic} when map_size(dynamic) == 1 ->
+        Map.delete(descr, :dynamic)
+
+      %{dynamic: %{optional: _} = dynamic} ->
+        %{descr | dynamic: Map.delete(dynamic, :optional)}
+
+      _ ->
+        remove_optional_static(descr)
+    end
+  end
+
+  defp remove_optional_static(%{} = descr), do: Map.delete(descr, :optional)
+  defp remove_optional_static(descr), do: descr
+
+  defp optional_to_term(descr) do
+    case descr do
+      %{dynamic: %{optional: _}} -> @term_or_dynamic_optional
+      %{optional: _} -> term_or_optional()
+      _ -> :term
+    end
+  end
+
+  defp optional_static?(%{optional: 1}), do: true
+  defp optional_static?(%{}), do: false
+
+  defp pop_optional_static(:term), do: {false, :term}
+
+  defp pop_optional_static(type) do
+    case :maps.take(:optional, type) do
+      :error -> {false, type}
+      {1, type} -> {true, type}
+    end
+  end
+
+  ## Set operations
+
+  @doc """
+  Returns true if the type has a gradual part.
+  """
+  def gradual?(:term), do: false
+  def gradual?(descr), do: is_map_key(descr, :dynamic)
+
+  @doc """
+  Returns true if the type only has a gradual part.
+  """
+  def only_gradual?(%{dynamic: _} = descr), do: map_size(descr) == 1
+  def only_gradual?(_), do: false
+
+  @doc """
+  Make a whole type dynamic.
+
+  It is an optimized version of `intersection(dynamic(), type)`.
+  """
+  @compile {:inline, dynamic: 1}
+  def dynamic(descr) do
+    case descr do
+      %{dynamic: dynamic} -> %{dynamic: dynamic}
+      _ -> %{dynamic: descr}
+    end
+  end
+
+  @compile {:inline, maybe_union: 2}
+  defp maybe_union(nil, _fun), do: nil
+  defp maybe_union(descr, fun), do: union(descr, fun.())
+
+  @doc """
+  Computes the union of two descrs.
+  """
+  def union(:term, other), do: optional_to_term(other)
+  def union(other, :term), do: optional_to_term(other)
+  def union(none, other) when none == @none, do: other
+  def union(other, none) when none == @none, do: other
+
+  def union(left, right) do
+    left = unfold(left)
+    right = unfold(right)
+    is_gradual_left = gradual?(left)
+    is_gradual_right = gradual?(right)
+
+    cond do
+      is_gradual_left and not is_gradual_right ->
+        right_with_dynamic = Map.put(right, :dynamic, right)
+        union_static(left, right_with_dynamic)
+
+      is_gradual_right and not is_gradual_left ->
+        left_with_dynamic = Map.put(left, :dynamic, left)
+        union_static(left_with_dynamic, right)
+
+      true ->
+        union_static(left, right)
+    end
+  end
+
+  @compile {:inline, union_static: 2}
+  defp union_static(left, right) do
+    symmetrical_merge(left, right, &union/3)
+  end
+
+  defp union(:atom, v1, v2), do: atom_union(v1, v2)
+  defp union(:bitmap, v1, v2), do: v1 ||| v2
+  defp union(:dynamic, v1, v2), do: dynamic_union(v1, v2)
+  defp union(:list, v1, v2), do: list_union(v1, v2)
+  defp union(:map, v1, v2), do: map_union(v1, v2)
+  defp union(:optional, 1, 1), do: 1
+  defp union(:tuple, v1, v2), do: tuple_union(v1, v2)
+  defp union(:fun, v1, v2), do: fun_union(v1, v2)
+
+  @doc """
+  Computes the intersection of two descrs.
+  """
+  def intersection(:term, other), do: remove_optional(other)
+  def intersection(other, :term), do: remove_optional(other)
+  def intersection(%{dynamic: :term}, other), do: dynamic(remove_optional(other))
+  def intersection(other, %{dynamic: :term}), do: dynamic(remove_optional(other))
+
+  def intersection(left, right) do
+    left = unfold(left)
+    right = unfold(right)
+    is_gradual_left = gradual?(left)
+    is_gradual_right = gradual?(right)
+
+    cond do
+      is_gradual_left and not is_gradual_right ->
+        right_with_dynamic = Map.put(right, :dynamic, right)
+        intersection_static(left, right_with_dynamic)
+
+      is_gradual_right and not is_gradual_left ->
+        left_with_dynamic = Map.put(left, :dynamic, left)
+        intersection_static(left_with_dynamic, right)
+
+      true ->
+        intersection_static(left, right)
+    end
+  end
+
+  @compile {:inline, intersection_static: 2}
+  defp intersection_static(left, right) do
+    symmetrical_intersection(left, right, &intersection/3)
+  end
+
+  # Returning 0 from the callback is taken as none() for that subtype.
+  defp intersection(:atom, v1, v2), do: atom_intersection(v1, v2)
+  defp intersection(:bitmap, v1, v2), do: v1 &&& v2
+  defp intersection(:list, v1, v2), do: list_intersection(v1, v2)
+  defp intersection(:map, v1, v2), do: map_intersection(v1, v2)
+  defp intersection(:optional, 1, 1), do: 1
+  defp intersection(:tuple, v1, v2), do: tuple_intersection(v1, v2)
+  defp intersection(:fun, v1, v2), do: fun_intersection(v1, v2)
+
+  defp intersection(:dynamic, v1, v2) do
+    descr = dynamic_intersection(v1, v2)
+    if descr == @none, do: 0, else: descr
+  end
+
+  @doc """
+  Computes the difference between two types.
+  """
+  def difference(left, :term), do: keep_optional(left)
+
+  def difference(left, right) do
+    left = unfold(left)
+    right = unfold(right)
+
+    if gradual?(left) or gradual?(right) do
+      {left_dynamic, left_static} = Map.pop(left, :dynamic, left)
+      {right_dynamic, right_static} = Map.pop(right, :dynamic, right)
+      dynamic_part = difference_static(left_dynamic, right_static)
+
+      Map.put(difference_static(left_static, right_dynamic), :dynamic, dynamic_part)
+    else
+      difference_static(left, right)
+    end
+  end
+
+  # For static types, the difference is component-wise.
+  defp difference_static(left, :term), do: keep_optional(left)
+
+  defp difference_static(left, right) do
+    iterator_difference_static(:maps.next(:maps.iterator(unfold(right))), unfold(left))
+  end
+
+  defp iterator_difference_static({key, v2, iterator}, map) do
+    acc =
+      case map do
+        %{^key => v1} ->
+          value = difference(key, v1, v2)
+
+          if value in @empty_difference do
+            Map.delete(map, key)
+          else
+            %{map | key => value}
+          end
+
+        %{} ->
+          map
+      end
+
+    iterator_difference_static(:maps.next(iterator), acc)
+  end
+
+  defp iterator_difference_static(:none, map), do: map
+
+  # This function is designed to compute the difference during subtyping efficiently.
+  # Do not use it for anything else.
+  defp empty_difference_subtype?(%{dynamic: dyn_left} = left, %{dynamic: dyn_right} = right) do
+    # Dynamic will either exist on both sides or on none
+    empty_difference_subtype?(dyn_left, dyn_right) and
+      empty_difference_subtype?(Map.delete(left, :dynamic), Map.delete(right, :dynamic))
+  end
+
+  defp empty_difference_subtype?(left, :term), do: keep_optional(left) == @none
+
+  defp empty_difference_subtype?(left, right) do
+    iterator_empty_difference_subtype?(:maps.next(:maps.iterator(unfold(left))), unfold(right))
+  end
+
+  defp iterator_empty_difference_subtype?({key, v1, iterator}, map) do
+    case map do
+      %{^key => v2} ->
+        value = difference(key, v1, v2)
+        value in @empty_difference or empty_key?(key, value)
+
+      %{} ->
+        empty_key?(key, v1)
+    end and
+      iterator_empty_difference_subtype?(:maps.next(iterator), map)
+  end
+
+  defp iterator_empty_difference_subtype?(:none, _map), do: true
+
+  # Returning 0 from the callback is taken as none() for that subtype.
+  defp difference(:atom, v1, v2), do: atom_difference(v1, v2)
+  defp difference(:bitmap, v1, v2), do: v1 - (v1 &&& v2)
+  defp difference(:list, v1, v2), do: list_difference(v1, v2)
+  defp difference(:map, v1, v2), do: map_difference(v1, v2)
+  defp difference(:optional, 1, 1), do: 0
+  defp difference(:tuple, v1, v2), do: tuple_difference(v1, v2)
+  defp difference(:fun, v1, v2), do: fun_difference(v1, v2)
+
+  @doc """
+  Compute the negation of a type.
+  """
+  def negation(:term), do: none()
+  def negation(%{} = descr), do: difference(unfolded_term(), descr)
+
+  @doc """
+  Check if a type is empty.
+
+  For gradual types, check that the upper bound (the dynamic part) is empty.
+  Stop as soon as one non-empty component is found. Simpler components
+  (bitmap, atom) are checked first for speed since, if they are present,
+  the type is non-empty as we normalize then during construction.
+  """
+  def empty?(:term), do: false
+
+  def empty?(%{} = descr) do
+    case :maps.get(:dynamic, descr, descr) do
+      :term ->
+        false
+
+      value when value == @none ->
+        true
+
+      descr ->
+        not Map.has_key?(descr, :atom) and
+          not Map.has_key?(descr, :bitmap) and
+          not Map.has_key?(descr, :optional) and
+          (not Map.has_key?(descr, :tuple) or tuple_empty?(descr.tuple)) and
+          (not Map.has_key?(descr, :map) or map_empty?(descr.map)) and
+          (not Map.has_key?(descr, :list) or list_empty?(descr.list)) and
+          (not Map.has_key?(descr, :fun) or fun_empty?(descr.fun))
+    end
+  end
+
+  defp empty_or_optional?(type), do: empty?(remove_optional(type))
+
+  # For atom, bitmap, tuple, and optional, if the key is present,
+  # then they are not empty,
+  defp empty_key?(:fun, value), do: fun_empty?(value)
+  defp empty_key?(:map, value), do: map_empty?(value)
+  defp empty_key?(:list, value), do: list_empty?(value)
+  defp empty_key?(:tuple, value), do: tuple_empty?(value)
+  defp empty_key?(_, _value), do: false
+
+  @doc """
+  Converts a descr to its quoted representation.
+
+  ## Options
+
+    * `:collapse_structs` - do not show struct fields that match
+      their default type
+  """
+  def to_quoted(descr, opts \\ []) do
+    if term_type?(descr) do
+      {:term, [], []}
+    else
+      non_term_type_to_quoted(descr, opts)
+    end
+  end
+
+  defp non_term_type_to_quoted(descr, opts) do
+    {dynamic, static, extra} =
+      case :maps.take(:dynamic, descr) do
+        :error ->
+          {%{}, descr, []}
+
+        {:term, static} ->
+          {:term, static, []}
+
+        {dynamic, static} ->
+          # Computing term_type?(difference(dynamic, static)) can be
+          # expensive, so we check for term type before hand and check
+          # for :term exclusively in dynamic_to_quoted/2.
+          if term_type?(dynamic) do
+            {:term, static, []}
+          else
+            # Denormalize functions before we do the difference
+            {static, dynamic, extra} = fun_denormalize(static, dynamic, opts)
+            {difference(dynamic, static), static, extra}
+          end
+      end
+
+    # Merge empty list and list together if they both exist
+    {extra, static} =
+      case static do
+        %{list: list, bitmap: bitmap} when (bitmap &&& @bit_empty_list) != 0 ->
+          static =
+            static
+            |> Map.delete(:list)
+            |> Map.replace!(:bitmap, bitmap - @bit_empty_list)
+
+          {list_to_quoted(list, true, opts) ++ extra, static}
+
+        %{} ->
+          {extra, static}
+      end
+
+    # Dynamic always come first for visibility
+    unions =
+      to_quoted(:dynamic, dynamic, opts) ++
+        Enum.sort(
+          extra ++ Enum.flat_map(static, fn {key, value} -> to_quoted(key, value, opts) end)
+        )
+
+    case unions do
+      [] -> {:none, [], []}
+      unions -> Enum.reduce(unions, &{:or, [], [&2, &1]})
+    end
+  end
+
+  defp to_quoted(:atom, val, _opts), do: atom_to_quoted(val)
+  defp to_quoted(:bitmap, val, _opts), do: bitmap_to_quoted(val)
+  defp to_quoted(:dynamic, descr, opts), do: dynamic_to_quoted(descr, opts)
+  defp to_quoted(:map, bdd, opts), do: map_to_quoted(bdd, opts)
+  defp to_quoted(:list, bdd, opts), do: list_to_quoted(bdd, false, opts)
+  defp to_quoted(:tuple, bdd, opts), do: tuple_to_quoted(bdd, opts)
+  defp to_quoted(:fun, bdd, opts), do: fun_to_quoted(bdd, opts)
+
+  @doc """
+  Converts a descr to its quoted string representation.
+
+  ## Options
+
+    * `:collapse_structs` - do not show struct fields that match
+      their default type
+  """
+  def to_quoted_string(descr, opts \\ []) do
+    descr
+    |> to_quoted(opts)
+    |> Code.Formatter.to_algebra()
+    |> Inspect.Algebra.format(98)
+    |> IO.iodata_to_binary()
+  end
+
+  ## Type relations
+
+  @doc """
+  Check if a type is a subtype of another.
+
+  If     `left  = (left_dyn  and dynamic()) or left_static`
+  and    `right = (right_dyn and dynamic()) or right_static`
+
+  then the gradual subtyping relation defined in Definition 6.5 page 125 of
+  the thesis https://vlanvin.fr/papers/thesis.pdf is:
+
+  `left <= right` if and only if
+    - `left_static <= right_static`
+    - `left_dyn <= right_dyn`
+
+  Because of the dynamic/static invariant in the `descr`, subtyping can be
+  simplified in several cases according to which type is gradual or not.
+  """
+  def subtype?(left, right) do
+    left = unfold(left)
+    right = unfold(right)
+    is_grad_left = gradual?(left)
+    is_grad_right = gradual?(right)
+
+    cond do
+      is_grad_left and not is_grad_right ->
+        left_dynamic = Map.get(left, :dynamic)
+        subtype_static?(left_dynamic, right)
+
+      is_grad_right and not is_grad_left ->
+        right_static = Map.delete(right, :dynamic)
+        subtype_static?(left, right_static)
+
+      true ->
+        subtype_static?(left, right)
+    end
+  end
+
+  defp subtype_static?(same, same), do: true
+  defp subtype_static?(left, right), do: empty_difference_subtype?(left, right)
+
+  @doc """
+  Check if a type is equal to another.
+
+  It is currently not optimized. Only to be used in tests.
+  """
+  def equal?(left, right) do
+    left == right or (subtype?(left, right) and subtype?(right, left))
+  end
+
+  @doc """
+  Check if two types are disjoint.
+
+  This reimplements intersection/2 but aborts as it finds a disjoint part.
+  """
+  def disjoint?(:term, other), do: empty?(remove_optional(other))
+  def disjoint?(other, :term), do: empty?(remove_optional(other))
+  def disjoint?(%{dynamic: :term}, other), do: empty?(remove_optional(other))
+  def disjoint?(other, %{dynamic: :term}), do: empty?(remove_optional(other))
+
+  # Two gradual types are disjoint if their upper bounds are disjoint.
+  def disjoint?(left, right) do
+    left_upper = unfold(left) |> Map.get(:dynamic, left)
+    right_upper = unfold(right) |> Map.get(:dynamic, right)
+
+    not non_disjoint_intersection?(left_upper, right_upper)
+  end
+
+  @doc """
+  Checks if a type is a compatible subtype of another.
+
+  If `input_type` has a static part (i.e., values that are known to appear and
+  need to be handled), then to be compatible it should be a subtype of the
+  the dynamic part of `expected_type` (that is, the largest allowed type at
+  runtime).
+
+  If `input_type` is a dynamic type, then we check that the two can intersect
+  at runtime, i.e. it is possible to get valid inputs at runtime.
+
+  The function is used, in gradual mode, to type an operator that expects a given
+  type. For instance, `+` expects `integer() or float()` inputs. Compatible inputs
+  include `dynamic()`, `integer()`, but also `dynamic() and (integer() or atom())`.
+  Incompatible subtypes include `integer() or list()`, `dynamic() and atom()`.
+  """
+  def compatible?(left, right) do
+    {left_dynamic, left_static} =
+      case left do
+        :term -> {:term, :term}
+        _ -> Map.pop(left, :dynamic, left)
+      end
+
+    right_dynamic =
+      case right do
+        %{dynamic: dynamic} -> dynamic
+        _ -> right
+      end
+
+    if empty?(left_static) do
+      not disjoint?(left_dynamic, right_dynamic)
+    else
+      subtype_static?(left_static, right_dynamic)
+    end
+  end
+
+  @doc """
+  Returns the intersection between two types
+  only if they are compatible. Otherwise returns `:error`.
+
+  This finds the intersection between the arguments and the
+  domain of a function. It is used to refine dynamic types
+  as we traverse the program.
+  """
+  def compatible_intersection(left, right) do
+    {left_dynamic, left_static} =
+      case left do
+        :term -> {:term, :term}
+        _ -> Map.pop(left, :dynamic, left)
+      end
+
+    right_dynamic =
+      case right do
+        %{dynamic: dynamic} -> dynamic
+        _ -> right
+      end
+
+    cond do
+      empty?(left_static) ->
+        dynamic = intersection_static(unfold(left_dynamic), unfold(right_dynamic))
+        if empty?(dynamic), do: {:error, left}, else: {:ok, dynamic(dynamic)}
+
+      subtype_static?(left_static, right_dynamic) ->
+        dynamic = intersection_static(unfold(left_dynamic), unfold(right_dynamic))
+        {:ok, union(dynamic(dynamic), left_static)}
+
+      true ->
+        {:error, left}
+    end
+  end
+
+  @doc """
+  Optimized version of `not empty?(term(), type)`.
+  """
+  def term_type?(:term), do: true
+  def term_type?(descr), do: subtype_static?(unfolded_term(), Map.delete(descr, :dynamic))
+
+  @doc """
+  Optimized version of `not empty?(intersection(empty_list(), type))`.
+  """
+  def empty_list_type?(:term), do: true
+  def empty_list_type?(%{dynamic: :term}), do: true
+
+  def empty_list_type?(%{dynamic: %{bitmap: bitmap}}) when (bitmap &&& @bit_empty_list) != 0,
+    do: true
+
+  def empty_list_type?(%{bitmap: bitmap}) when (bitmap &&& @bit_empty_list) != 0, do: true
+  def empty_list_type?(_), do: false
+
+  @doc """
+  Optimized version of `not empty?(intersection(binary(), type))`.
+  """
+  def binary_type?(:term), do: true
+  def binary_type?(%{dynamic: :term}), do: true
+  def binary_type?(%{dynamic: %{bitmap: bitmap}}) when (bitmap &&& @bit_binary) != 0, do: true
+  def binary_type?(%{bitmap: bitmap}) when (bitmap &&& @bit_binary) != 0, do: true
+  def binary_type?(_), do: false
+
+  @doc """
+  Optimized version of `not empty?(intersection(integer(), type))`.
+  """
+  def integer_type?(:term), do: true
+  def integer_type?(%{dynamic: :term}), do: true
+  def integer_type?(%{dynamic: %{bitmap: bitmap}}) when (bitmap &&& @bit_integer) != 0, do: true
+  def integer_type?(%{bitmap: bitmap}) when (bitmap &&& @bit_integer) != 0, do: true
+  def integer_type?(_), do: false
+
+  @doc """
+  Optimized version of `not empty?(intersection(float(), type))`.
+  """
+  def float_type?(:term), do: true
+  def float_type?(%{dynamic: :term}), do: true
+  def float_type?(%{dynamic: %{bitmap: bitmap}}) when (bitmap &&& @bit_float) != 0, do: true
+  def float_type?(%{bitmap: bitmap}) when (bitmap &&& @bit_float) != 0, do: true
+  def float_type?(_), do: false
+
+  @doc """
+  Optimized version of `not empty?(intersection(integer() or float(), type))`.
+  """
+  def number_type?(:term), do: true
+  def number_type?(%{dynamic: :term}), do: true
+  def number_type?(%{dynamic: %{bitmap: bitmap}}) when (bitmap &&& @bit_number) != 0, do: true
+  def number_type?(%{bitmap: bitmap}) when (bitmap &&& @bit_number) != 0, do: true
+  def number_type?(_), do: false
+
+  ## Bitmaps
+
+  defp bitmap_to_quoted(val) do
+    pairs =
+      [
+        binary: @bit_binary,
+        empty_list: @bit_empty_list,
+        integer: @bit_integer,
+        float: @bit_float,
+        pid: @bit_pid,
+        port: @bit_port,
+        reference: @bit_reference
+      ]
+
+    for {type, mask} <- pairs,
+        (mask &&& val) !== 0,
+        do: {type, [], []}
+  end
+
+  ## Atoms
+
+  # The atom component of a type consists of pairs `{tag, set}` where `set` is a
+  # set of atoms.
+  # If `tag = :union` the pair represents the union of the atoms in `set`.
+  # Else, if `tag = :negation`, it represents every atom except those in `set`.
+  #
+  # Example:
+  #   - `{:union, :sets.from_list([:a, :b])}` represents type `:a or :b`
+  #   - `{:negation, :sets.from_list([:c, :d])}` represents type `atom() \ (:c or :d)
+  #
+  # `{:negation, :sets.new()}` is the `atom()` top type, as it is the difference
+  # of `atom()` with an empty list.
+  #
+  # `{:union, :sets.new()}` is the empty type for atoms, as it is the union of
+  # an empty list of atoms. It is simplified to `0` in set operations, and the key
+  # is removed from the map.
+
+  @false_or_nil_atoms [
+    :sets.from_list([false, nil], version: 2),
+    :sets.from_list([nil], version: 2),
+    :sets.from_list([false], version: 2)
+  ]
+
+  @doc """
+  Compute the truthiness of an element.
+
+  It is either :undefined, :always_true, or :always_false.
+  """
+  def truthiness(:term), do: :undefined
+
+  def truthiness(%{} = descr) do
+    descr = Map.get(descr, :dynamic, descr)
+
+    case descr do
+      :term ->
+        :undefined
+
+      %{atom: {:union, set}}
+      when map_size(descr) == 1 and set in @false_or_nil_atoms ->
+        :always_false
+
+      %{atom: {:union, set}}
+      when map_size(descr) == 1 and not is_map_key(set, false) and not is_map_key(set, nil) ->
+        :always_true
+
+      %{atom: {:negation, %{nil => _, false => _}}} ->
+        :always_true
+
+      %{atom: _} ->
+        :undefined
+
+      _ when map_size(descr) == 0 ->
+        :undefined
+
+      _ ->
+        :always_true
+    end
+  end
+
+  @doc """
+  Returns a set of all known atoms.
+
+  Returns `{:finite or :infinite, known_set}` if it is an atom,
+  `:error` otherwise. Notice `known_set` may be empty in infinite
+  cases, due to negations.
+  """
+  def atom_fetch(:term), do: :error
+
+  def atom_fetch(%{} = descr) do
+    {static_or_dynamic, static} = Map.pop(descr, :dynamic, descr)
+
+    if atom_only?(static) do
+      case static_or_dynamic do
+        :term -> {:infinite, []}
+        %{atom: {:union, set}} -> {:finite, :sets.to_list(set)}
+        %{atom: {:negation, set}} -> {:infinite, :sets.to_list(set)}
+        %{} -> :error
+      end
+    else
+      :error
+    end
+  end
+
+  defp atom_only?(descr), do: empty?(Map.delete(descr, :atom))
+  defp atom_new(as) when is_list(as), do: {:union, :sets.from_list(as, version: 2)}
+
+  defp infinite_atoms?(:term), do: true
+  defp infinite_atoms?(%{dynamic: dynamic}), do: infinite_atoms?(dynamic)
+  defp infinite_atoms?(%{atom: {:negation, _}}), do: true
+  defp infinite_atoms?(%{}), do: false
+
+  defp atom_intersection({tag1, s1}, {tag2, s2}) do
+    {tag, s} =
+      case {tag1, tag2} do
+        {:union, :union} -> {:union, :sets.intersection(s1, s2)}
+        {:negation, :negation} -> {:negation, :sets.union(s1, s2)}
+        {:union, :negation} -> {:union, :sets.subtract(s1, s2)}
+        {:negation, :union} -> {:union, :sets.subtract(s2, s1)}
+      end
+
+    if tag == :union and :sets.size(s) == 0, do: 0, else: {tag, s}
+  end
+
+  defp atom_union({:union, s1}, {:union, s2}), do: {:union, :sets.union(s1, s2)}
+  defp atom_union({:negation, s1}, {:negation, s2}), do: {:negation, :sets.intersection(s1, s2)}
+  defp atom_union({:union, s1}, {:negation, s2}), do: {:negation, :sets.subtract(s2, s1)}
+  defp atom_union({:negation, s1}, {:union, s2}), do: {:negation, :sets.subtract(s1, s2)}
+
+  defp atom_difference({tag1, s1}, {tag2, s2}) do
+    {tag, s} =
+      case {tag1, tag2} do
+        {:union, :union} -> {:union, :sets.subtract(s1, s2)}
+        {:negation, :negation} -> {:union, :sets.subtract(s2, s1)}
+        {:union, :negation} -> {:union, :sets.intersection(s1, s2)}
+        {:negation, :union} -> {:negation, :sets.union(s1, s2)}
+      end
+
+    if tag == :union and :sets.size(s) == 0, do: 0, else: {tag, s}
+  end
+
+  defp literal_to_quoted(lit) do
+    if is_atom(lit) and Macro.classify_atom(lit) == :alias do
+      segments =
+        case Atom.to_string(lit) do
+          "Elixir" ->
+            [:"Elixir"]
+
+          "Elixir." <> segments ->
+            segments
+            |> String.split(".")
+            |> Enum.map(&String.to_atom/1)
+        end
+
+      {:__aliases__, [], segments}
+    else
+      {:__block__, [], [lit]}
+    end
+  end
+
+  defp atom_to_quoted({:union, a}) do
+    if :sets.is_subset(@boolset, a) do
+      entries =
+        :sets.subtract(a, @boolset)
+        |> :sets.to_list()
+        |> Enum.map(&literal_to_quoted/1)
+
+      [{:boolean, [], []} | entries]
+    else
+      :sets.to_list(a)
+      |> Enum.map(&literal_to_quoted/1)
+    end
+  end
+
+  defp atom_to_quoted({:negation, a}) do
+    if :sets.size(a) == 0 do
+      {:atom, [], []}
+    else
+      atom_to_quoted({:union, a})
+      |> Kernel.then(&{:and, [], [{:atom, [], []}, {:not, [], &1}]})
+    end
+    |> List.wrap()
+  end
+
+  ## Functions
+
+  # Function types are represented using Binary Decision Diagrams (BDDs) for efficient
+  # handling of unions, intersections, and negations.
+  #
+  # Currently, they only represent weak types. It is yet to be decided how all of the
+  # types will be encoded in the descr.
+
+  ### Key concepts:
+
+  # * BDD structure: A tree with function nodes and :bdd_top/:bdd_bot leaves.
+  #   Paths to :bdd_top represent valid function types. Nodes are positive when
+  #   following a left branch (e.g. (int, float -> bool) and negative otherwise.
+
+  # * Function variance:
+  #   - Contravariance in arguments: If s <: t, then (t → r) <: (s → r)
+  #   - Covariance in returns: If s <: t, then (u → s) <: (u → t)
+
+  # * Representation:
+  #   - fun(): Top function type (leaf 1)
+  #   - Function literals: {[t1, ..., tn], t} where [t1, ..., tn] are argument types and t is return type
+  #   - Normalized form for function applications: {domain, arrows} is produced by `fun_normalize/2`
+
+  # * Examples:
+  #   - fun([integer()], atom()): A function from integer to atom
+  #   - intersection(fun([integer()], atom()), fun([float()], boolean())): A function handling both signatures
+
+  # Note: Function domains are expressed as tuple types. We use separate representations
+  # rather than unary functions with tuple domains to handle special cases like representing
+  # functions of a specific arity (e.g., (none,none->term) for arity 2).
+  defp fun_new(arity, inputs, output), do: {:union, %{arity => bdd_leaf(inputs, output)}}
+
+  # Creates a function type from a list of inputs and an output
+  # where the inputs and/or output may be dynamic.
+  #
+  # For function (t → s) with dynamic components:
+  # - Static part: (upper_bound(t) → lower_bound(s))
+  # - Dynamic part: dynamic(lower_bound(t) → upper_bound(s))
+  #
+  # When handling dynamic types:
+  # - `upper_bound(t)` extracts the upper bound (most general type) of a gradual type.
+  #   For `dynamic(integer())`, it is `integer()`.
+  # - `lower_bound(t)` extracts the lower bound (most specific type) of a gradual type.
+  defp fun_descr(args, output) when is_list(args) do
+    arity = length(args)
+    dynamic_arguments? = Enum.any?(args, &gradual?/1)
+    dynamic_output? = gradual?(output)
+
+    if dynamic_arguments? or dynamic_output? do
+      input_static = if dynamic_arguments?, do: Enum.map(args, &upper_bound/1), else: args
+      input_dynamic = if dynamic_arguments?, do: Enum.map(args, &lower_bound/1), else: args
+
+      output_static = if dynamic_output?, do: lower_bound(output), else: output
+      output_dynamic = if dynamic_output?, do: upper_bound(output), else: output
+
+      %{
+        fun: fun_new(arity, input_static, output_static),
+        dynamic: %{fun: fun_new(arity, input_dynamic, output_dynamic)}
+      }
+    else
+      # No dynamic components, use standard function type
+      %{fun: fun_new(arity, args, output)}
+    end
+  end
+
+  # Gets the upper bound of a gradual type.
+  defp upper_bound(%{dynamic: dynamic}), do: dynamic
+  defp upper_bound(static), do: static
+
+  # Gets the lower bound of a gradual type.
+  defp lower_bound(:term), do: :term
+  defp lower_bound(type), do: Map.delete(type, :dynamic)
+
+  @doc """
+  Applies a function type to a list of argument types.
+
+  Returns `{:ok, result}` if the application is valid
+  or one `{:badarg, to_succeed_domain}`, `:badfun`,
+  `{:badarity, arities}` if not.
+
+  Note the domain returned by `:badarg` is not the strong
+  domain, but the domain that must be satisfied for the
+  function application to succeed.
+
+  Handles both static and dynamic function types:
+
+  1. For static functions: checks exact argument types
+  2. For dynamic functions: computes result based on both static and dynamic parts
+  3. For mixed static/dynamic: computes all valid combinations
+
+  ## Function application formula for dynamic types
+
+      τ◦τ′ = (lower_bound(τ) ◦ upper_bound(τ′)) ∨ (dynamic(upper_bound(τ) ◦ lower_bound(τ′)))
+
+  Where:
+
+  - τ is a dynamic function type
+  - τ′ are the arguments
+  - ◦ is function application
+
+  For more details, see Definition 6.15 in https://vlanvin.fr/papers/thesis.pdf
+
+  ## Examples
+
+      iex> fun_apply(fun([integer()], atom()), [integer()])
+      {:ok, atom()}
+
+      iex> fun_apply(fun([integer()], atom()), [float()])
+      :badarg
+
+      iex> fun_apply(fun([dynamic()], atom()), [dynamic()])
+      {:ok, atom()}
+  """
+  def fun_apply(:term, _arguments), do: :badfun
+
+  def fun_apply(fun, arguments) do
+    case :maps.take(:dynamic, fun) do
+      :error ->
+        if fun_only?(fun) do
+          fun_apply_with_strategy(fun, nil, arguments)
+        else
+          :badfun
+        end
+
+      {fun_dynamic, fun_static} ->
+        cond do
+          fun_static == %{} and dynamic_fun_top?(fun_dynamic) ->
+            {:ok, dynamic()}
+
+          fun_only?(fun_static) ->
+            fun_apply_with_strategy(fun_static, fun_dynamic, arguments)
+
+          true ->
+            :badfun
+        end
+    end
+  end
+
+  defp fun_only?(descr), do: empty?(Map.delete(descr, :fun))
+  defp dynamic_fun_top?(:term), do: true
+  defp dynamic_fun_top?(%{fun: {:negation, map}}), do: map == %{}
+  defp dynamic_fun_top?(_), do: false
+
+  defp fun_apply_with_strategy(fun_static, fun_dynamic, arguments) do
+    args_domain = args_to_domain(arguments)
+    static? = fun_dynamic == nil and Enum.all?(arguments, fn arg -> not gradual?(arg) end)
+    arity = length(arguments)
+
+    with {:ok, domain, static_arrows, dynamic_arrows} <-
+           fun_normalize_both(fun_static, fun_dynamic, arity) do
+      cond do
+        Enum.any?(arguments, &empty?/1) ->
+          {:badarg, domain_to_flat_args(domain, arity)}
+
+        not subtype?(args_domain, domain) ->
+          if static? or not compatible?(args_domain, domain),
+            do: {:badarg, domain_to_flat_args(domain, arity)},
+            else: {:ok, dynamic()}
+
+        static? ->
+          {:ok, fun_apply_static(arguments, static_arrows)}
+
+        static_arrows == [] ->
+          # TODO: We need to validate this within the theory
+          arguments = Enum.map(arguments, &upper_bound/1)
+          {:ok, dynamic(fun_apply_static(arguments, dynamic_arrows))}
+
+        true ->
+          # For dynamic cases, combine static and dynamic results
+          arguments = Enum.map(arguments, &upper_bound/1)
+
+          {:ok,
+           union(
+             fun_apply_static(arguments, static_arrows),
+             dynamic(fun_apply_static(arguments, dynamic_arrows))
+           )}
+      end
+    end
+  end
+
+  defp fun_normalize_both(fun_static, fun_dynamic, arity) do
+    case fun_normalize(fun_static, arity) do
+      {:ok, static_domain, static_arrows} when fun_dynamic == nil ->
+        {:ok, static_domain, static_arrows, static_arrows}
+
+      {:ok, static_domain, static_arrows} when fun_dynamic != nil ->
+        case fun_normalize(fun_dynamic, arity) do
+          {:ok, dynamic_domain, dynamic_arrows} ->
+            domain = union(dynamic_domain, dynamic(static_domain))
+            {:ok, domain, static_arrows, dynamic_arrows}
+
+          _ ->
+            {:ok, static_domain, static_arrows, static_arrows}
+        end
+
+      :badfun ->
+        case fun_normalize(fun_dynamic, arity) do
+          {:ok, dynamic_domain, dynamic_arrows} ->
+            {:ok, union(dynamic_domain, dynamic()), [], dynamic_arrows}
+
+          error ->
+            error
+        end
+
+      error ->
+        error
+    end
+  end
+
+  # Transforms a binary decision diagram (BDD) into the canonical `domain-arrows` pair:
+  #
+  # 1. **domain**: The union of all domains from positive functions in the BDD
+  # 2. **arrows**: List of lists, where each inner list contains an intersection of function arrows
+  #
+  # ## Return Values
+  #
+  # - `{:ok, domain, arrows}` for valid function BDDs
+  # - `{:badarity, supported_arities}` if the given arity is not supported
+  # - `:badfun` if the BDD represents an empty function type
+  #
+  # ## Internal Use
+  #
+  # This function is used internally by `fun_apply_*`, and others to
+  # ensure consistent handling of function types in all operations.
+  defp fun_normalize(:term, arity), do: fun_normalize(fun(arity), arity)
+
+  # In that case, we transform the {:negation, _} into a single union
+  # where we add the previous negatives into the specified arity.
+  defp fun_normalize(%{fun: {:negation, _}} = neg_fun, arity) do
+    fun_normalize(intersection(fun(arity), neg_fun), arity)
+  end
+
+  defp fun_normalize(%{fun: {:union, bdds}}, arity) do
+    case :maps.take(arity, bdds) do
+      {bdd, _rest} ->
+        {domain, arrows} =
+          Enum.reduce(fun_bdd_to_pos_dnf(arity, bdd), {term(), []}, fn pos_funs,
+                                                                       {domain, arrows} ->
+            {intersection(domain, fetch_domain(pos_funs)), [pos_funs | arrows]}
+          end)
+
+        if arrows == [] do
+          {:badarity, :maps.keys(bdds)}
+        else
+          {:ok, domain, arrows}
+        end
+
+      :error ->
+        {:badarity, :maps.keys(bdds)}
+    end
+  end
+
+  defp fun_normalize(%{}, _arity), do: :badfun
+
+  defp fun_apply_static(arguments, arrows) do
+    type_args = args_to_domain(arguments)
+
+    Enum.reduce(arrows, none(), fn intersection_of_arrows, acc ->
+      aux_apply(acc, type_args, term(), intersection_of_arrows)
+    end)
+  end
+
+  # A fast way to do function application when the arguments of the function are disjoint.
+  # Just build the union of all the return types of arrows that match the input.
+  defp apply_disjoint(input_arguments, arrows) do
+    type_input = args_to_domain(input_arguments)
+
+    Enum.reduce(arrows, none(), fn {args, ret}, acc_return ->
+      if empty?(intersection(args_to_domain(args), type_input)),
+        do: acc_return,
+        else: union(acc_return, ret)
+    end)
+  end
+
+  # Helper function for function application that handles the application of
+  # function arrows to input types.
+
+  # This function recursively processes a list of function arrows (an intersection),
+  # applying each arrow to the input type and accumulating the result.
+
+  # ## Parameters
+
+  # - result: The accumulated result type so far
+  # - input: The input type being applied to the function
+  # - rets_reached: The intersection of return types reached so far
+  # - arrow_intersections: The list of function arrows to process
+
+  # For more details, see Definitions 2.20 or 6.11 in https://vlanvin.fr/papers/thesis.pdf
+  defp aux_apply(result, _input, rets_reached, []) do
+    if subtype?(rets_reached, result), do: result, else: union(result, rets_reached)
+  end
+
+  defp aux_apply(result, input, returns_reached, [{args, ret} | arrow_intersections]) do
+    # Calculate the part of the input not covered by this arrow's domain
+    dom_subtract = difference(input, args_to_domain(args))
+
+    # Refine the return type by intersecting with this arrow's return type
+    ret_refine = intersection(returns_reached, ret)
+
+    # Phase 1: Domain partitioning
+    # If the input is not fully covered by the arrow's domain, then the result type should be
+    # _augmented_ with the outputs obtained by applying the remaining arrows to the non-covered
+    # parts of the domain.
+    #
+    # e.g. (integer()->atom()) and (float()->pid()) when applied to number() should unite
+    # both atoms and pids in the result.
+    result =
+      if empty?(dom_subtract),
+        do: result,
+        else: aux_apply(result, dom_subtract, returns_reached, arrow_intersections)
+
+    # 2. Return type refinement
+    # The result type is also refined (intersected) in the sense that, if several arrows match
+    # the same part of the input, then the result type is an intersection of the return types of
+    # those arrows.
+
+    # e.g. (integer()->atom()) and (integer()->pid()) when applied to integer()
+    # should result in (atom() ∩ pid()), which is none().
+    aux_apply(result, input, ret_refine, arrow_intersections)
+  end
+
+  # Takes all the paths from the root to the leaves finishing with a 1,
+  # and compile into tuples of positive and negative nodes. Positive nodes are
+  # those followed by a left path, negative nodes are those followed by a right path.
+  defp fun_bdd_to_dnf(bdd),
+    do: bdd_to_dnf(bdd) |> Enum.filter(fn {pos, neg} -> not fun_line_empty?(pos, neg) end)
+
+  # Check if all functions types for all arities are empty.
+  defp fun_empty?({:negation, _}), do: false
+
+  defp fun_empty?({:union, repr}) do
+    Enum.all?(repr, fn {_ar, bdd} ->
+      Enum.all?(bdd_to_dnf(bdd), fn {pos, neg} -> fun_line_empty?(pos, neg) end)
+    end)
+  end
+
+  # A function type {positives, negatives} is empty if there exists a negative
+  # function that negates the whole positive intersection
+  #
+  ## Examples
+  #
+  # - `{[fun(1)], []}` is not empty
+  # - `{[fun(integer() -> atom())], [fun(none() -> term())]}` is empty
+  defp fun_line_empty?([], _), do: false
+
+  defp fun_line_empty?(positives, negatives) do
+    # Check if any negative function negates the whole positive intersection
+    # e.g. (integer() -> atom()) is negated by:
+    #
+    # * (none() -> term())
+    # * (none() -> atom())
+    # * (integer() -> term())
+    # * (integer() -> atom())
+    Enum.any?(negatives, fn {neg_arguments, neg_return} ->
+      # Check if the negative function's domain is a supertype of the positive
+      # domain and if the phi function determines emptiness.
+      subtype?(args_to_domain(neg_arguments), fetch_domain(positives)) and
+        phi_starter(neg_arguments, neg_return, positives)
+    end)
+  end
+
+  # Returns the union of all domains of the arrows in the intersection of positives.
+  defp fetch_domain(positives) do
+    Enum.reduce(positives, none(), fn {args, _}, acc -> union(acc, args_to_domain(args)) end)
+  end
+
+  # Implements the Φ (phi) function for determining function subtyping relationships.
+  #
+  # ## Algorithm
+  #
+  # For inputs t₁...tₙ, booleans b₁...bₙ, negated return type t, and set of arrow types P:
+  #
+  # Φ((b₁,t₁)...(bₙ,tₙ), (b,t), ∅) = (∃j ∈ [1,n]. bⱼ and tⱼ ≤ ∅) ∨ (b and t ≤ ∅)
+  #
+  # Φ((b₁,t₁)...(bₙ,tₙ), t, {(t'₁...t'ₙ) → t'} ∪ P) =
+  #       Φ((b₁,t₁)...(bₙ,tₙ), (true,t ∧ t'), P) ∧
+  #         ∀j ∈ [1,n]. Φ((b₁,t₁)...(true,tⱼ∖t'ⱼ)...(bₙ,tₙ), (b,t), P)
+  #
+  # Returns true if the intersection of the positives is a subtype of (t1,...,tn)->(not t).
+  #
+  # See [Castagna and Lanvin (2024)](https://arxiv.org/abs/2408.14345), Theorem 4.2.
+  defp phi_starter(arguments, return, positives) do
+    # Optimization: When all positive functions have non-empty domains,
+    # we can simplify the phi function check to a direct subtyping test.
+    # This avoids the expensive recursive phi computation by checking only that applying the
+    # input to the positive intersection yields a subtype of the return
+    case disjoint_non_empty_domains?({arguments, return}, positives) do
+      :disjoint_non_empty ->
+        apply_disjoint(arguments, positives) |> subtype?(return)
+
+      :non_empty ->
+        fun_apply_static(arguments, [positives]) |> subtype?(return)
+
+      _ ->
+        # Initialize memoization cache for the recursive phi computation
+        arguments = Enum.map(arguments, &{false, &1})
+        {result, _cache} = phi(arguments, {false, negation(return)}, positives, %{})
+        result
+    end
+  end
+
+  defp phi(args, {b, t}, [], cache) do
+    result = Enum.any?(args, fn {bool, typ} -> bool and empty?(typ) end) or (b and empty?(t))
+    {result, Map.put(cache, {args, {b, t}, []}, result)}
+  end
+
+  defp phi(args, {b, ret}, [{arguments, return} | rest_positive], cache) do
+    # Create cache key from function arguments
+    cache_key = {args, {b, ret}, [{arguments, return} | rest_positive]}
+
+    case cache do
+      %{^cache_key => value} ->
+        {value, cache}
+
+      %{} ->
+        # Compute result and cache it
+        {result1, cache} = phi(args, {true, intersection(ret, return)}, rest_positive, cache)
+
+        if not result1 do
+          cache = Map.put(cache, cache_key, false)
+          {false, cache}
+        else
+          {_index, result2, cache} =
+            Enum.reduce_while(arguments, {0, true, cache}, fn
+              type, {index, acc_result, acc_cache} ->
+                {new_result, new_cache} =
+                  args
+                  |> List.update_at(index, fn {_, arg} -> {true, difference(arg, type)} end)
+                  |> phi({b, ret}, rest_positive, acc_cache)
+
+                if new_result do
+                  {:cont, {index + 1, acc_result and new_result, new_cache}}
+                else
+                  {:halt, {index + 1, false, new_cache}}
+                end
+            end)
+
+          result = result1 and result2
+          cache = Map.put(cache, cache_key, result)
+          {result, cache}
+        end
+    end
+  end
+
+  defp disjoint_non_empty_domains?({arguments, return}, positives) do
+    b1 = all_disjoint_arguments?(positives)
+    b2 = all_non_empty_arguments?([{arguments, return} | positives])
+
+    cond do
+      b1 and b2 -> :disjoint_non_empty
+      b2 -> :non_empty
+      true -> nil
+    end
+  end
+
+  defp all_non_empty_arguments?(positives) do
+    Enum.all?(positives, fn {args, _ret} ->
+      Enum.all?(args, fn arg -> not empty?(arg) end)
+    end)
+  end
+
+  # For two arguments to be disjoint, one of their types must be disjoint.
+  defp disjoint_arguments?(args1, args2) do
+    Enum.any?(Enum.zip(args1, args2), fn {t1, t2} -> disjoint?(t1, t2) end)
+  end
+
+  defp all_disjoint_arguments?([]), do: true
+
+  defp all_disjoint_arguments?([{args, _} | rest]) do
+    Enum.all?(rest, fn {args_rest, _} -> disjoint_arguments?(args, args_rest) end) and
+      all_disjoint_arguments?(rest)
+  end
+
+  # For all integers keys in fun_repr1, fun_repr2, call fun_bdd_union on the values that are in
+  # both, else return the single value.
+  defp fun_union({tag1, repr1}, {tag2, repr2}) do
+    case {tag1, tag2} do
+      {:union, :union} -> {:union, fun_repr_union(repr1, repr2)}
+      {:negation, :negation} -> {:negation, fun_repr_intersection(repr1, repr2)}
+      {:union, :negation} -> {:negation, fun_repr_difference(repr2, repr1)}
+      {:negation, :union} -> {:negation, fun_repr_difference(repr1, repr2)}
+    end
+  end
+
+  # For all integer keys that are both in fun_repr1 and fun_repr2, call fun_bdd_intersection
+  # on the values that are in both, else discard.
+  defp fun_intersection({tag1, repr1}, {tag2, repr2}) do
+    {tag, repr} =
+      case {tag1, tag2} do
+        {:union, :union} -> {:union, fun_repr_intersection(repr1, repr2)}
+        {:negation, :negation} -> {:negation, fun_repr_union(repr1, repr2)}
+        {:union, :negation} -> {:union, fun_repr_difference(repr1, repr2)}
+        {:negation, :union} -> {:union, fun_repr_difference(repr2, repr1)}
+      end
+
+    if tag == :union and map_size(repr) == 0, do: 0, else: {tag, repr}
+  end
+
+  defp fun_difference({tag1, repr1}, {tag2, repr2}) do
+    {tag, repr} =
+      case {tag1, tag2} do
+        {:union, :union} -> {:union, fun_repr_difference(repr1, repr2)}
+        {:negation, :negation} -> {:union, fun_repr_difference(repr2, repr1)}
+        {:union, :negation} -> {:union, fun_repr_intersection(repr1, repr2)}
+        {:negation, :union} -> {:negation, fun_repr_union(repr1, repr2)}
+      end
+
+    if tag == :union and map_size(repr) == 0, do: 0, else: {tag, repr}
+  end
+
+  defp fun_repr_union(repr1, repr2) do
+    symmetrical_merge(repr1, repr2, fn _arity, v1, v2 -> bdd_union(v1, v2) end)
+  end
+
+  defp fun_repr_intersection(repr1, repr2) do
+    symmetrical_intersection(repr1, repr2, fn _arity, v1, v2 -> bdd_intersection(v1, v2) end)
+  end
+
+  defp fun_repr_difference(repr1, repr2) do
+    :maps.fold(
+      fn arity, bdd2, acc ->
+        case acc do
+          %{^arity => bdd1} ->
+            diff = bdd_difference(bdd1, bdd2)
+            if diff in @empty_difference, do: Map.delete(acc, arity), else: %{acc | arity => diff}
+
+          %{} ->
+            acc
+        end
+      end,
+      repr1,
+      repr2
+    )
+  end
+
+  # Converts the static and dynamic parts of descr to its quoted
+  # representation. The goal here is to the opposite of fun_descr
+  # and put static and dynamic parts back together to improve
+  # pretty printing.
+  defp fun_denormalize(%{fun: {:union, static_repr}}, %{fun: {:union, dynamic_repr}}, opts) do
+    # Denormalize each arity
+    for {arity, static_bdd} <- static_repr,
+        {^arity, dynamic_bdd} <- dynamic_repr,
+        reduce: {static_repr, dynamic_repr, []} do
+      {statics, dynamics, acc} ->
+        with {:ok, quoted} <- fun_denormalize_arity(arity, static_bdd, dynamic_bdd, opts) do
+          {Map.delete(statics, arity), Map.delete(dynamics, arity), [quoted | acc]}
+        else
+          _ -> {statics, dynamics, acc}
+        end
+    end
+  end
+
+  # If not unions of functions, do not try to denormalize.
+  defp fun_denormalize(static_repr, dynamic_repr, _opts) do
+    {static_repr, dynamic_repr, []}
+  end
+
+  defp fun_denormalize_arity(arity, static_bdd, dynamic_bdd, opts) do
+    static_pos = fun_bdd_to_pos_dnf(arity, static_bdd)
+    dynamic_pos = fun_bdd_to_pos_dnf(arity, dynamic_bdd)
+
+    cond do
+      static_pos == [] or dynamic_pos == [] ->
+        :error
+
+      true ->
+        {static_pos, dynamic_pos} = fun_denormalize_pos(static_pos, dynamic_pos)
+
+        quoted =
+          case dynamic_pos do
+            [] ->
+              fun_pos_to_quoted(static_pos, opts)
+
+            _ ->
+              {:or, [],
+               [
+                 {:dynamic, [], [fun_pos_to_quoted(dynamic_pos, opts)]},
+                 fun_pos_to_quoted(static_pos, opts)
+               ]}
+          end
+
+        {:ok, quoted}
+    end
+  end
+
+  defp fun_denormalize_pos(static_unions, dynamic_unions) do
+    Enum.map_reduce(static_unions, dynamic_unions, fn
+      # Handle fun() types accordingly
+      [], dynamic_unions ->
+        {[], List.delete(dynamic_unions, [])}
+
+      static_intersections, dynamic_unions ->
+        case pivot(dynamic_unions, [], &fun_denormalize_intersections(static_intersections, &1)) do
+          {match, dynamic_unions} -> {match, dynamic_unions}
+          :error -> {static_intersections, dynamic_unions}
+        end
+    end)
+  end
+
+  defp fun_denormalize_intersections(statics, dynamics) do
+    if length(statics) == length(dynamics) do
+      fun_denormalize_intersections(statics, dynamics, [])
+    else
+      :error
+    end
+  end
+
+  defp fun_denormalize_intersections([{static_args, static_return} | statics], dynamics, acc) do
+    dynamics
+    |> Enum.split_while(fn {dynamic_args, dynamic_return} ->
+      not arrow_subtype?(static_args, static_return, dynamic_args, dynamic_return)
+    end)
+    |> case do
+      {_dynamics, []} ->
+        :error
+
+      {pre, [{dynamic_args, dynamic_return} | post]} ->
+        args =
+          Enum.zip_with(static_args, dynamic_args, fn static_arg, dynamic_arg ->
+            union(dynamic(static_arg), dynamic_arg)
+          end)
+
+        return = union(dynamic(dynamic_return), static_return)
+        fun_denormalize_intersections(statics, pre ++ post, [{args, return} | acc])
+    end
+  end
+
+  defp fun_denormalize_intersections([], [], acc), do: {:ok, acc}
+
+  defp arrow_subtype?(left_args, left_return, right_args, right_return) do
+    subtype?(left_return, right_return) and args_subtype?(right_args, left_args)
+  end
+
+  defp args_subtype?(left_args, right_args) do
+    Enum.zip_reduce(left_args, right_args, true, fn left, right, acc ->
+      acc and subtype?(left, right)
+    end)
+  end
+
+  defp pivot([head | tail], acc, fun) do
+    case fun.(head) do
+      {:ok, value} -> {value, acc ++ tail}
+      :error -> pivot(tail, [head | acc], fun)
+    end
+  end
+
+  defp pivot([], _acc, _fun), do: :error
+
+  # Converts a function BDD (Binary Decision Diagram) to its quoted representation
+  defp fun_to_quoted({:negation, _bdds}, _opts), do: [{:fun, [], []}]
+
+  defp fun_to_quoted({:union, bdds}, opts) do
+    for {arity, bdd} <- bdds,
+        pos = fun_bdd_to_pos_dnf(arity, bdd),
+        pos != [],
+        do: fun_pos_to_quoted(pos, opts)
+  end
+
+  defp fun_bdd_to_pos_dnf(arity, :bdd_top) do
+    args = List.duplicate(none(), arity)
+    ret = term()
+    [[{args, ret}]]
+  end
+
+  defp fun_bdd_to_pos_dnf(_arity, bdd) do
+    fun_bdd_to_dnf(bdd)
+    |> Enum.map(fn {pos, _negs} -> pos end)
+    |> fun_eliminate_unions([])
+  end
+
+  defp fun_eliminate_unions([], acc), do: acc
+
+  defp fun_eliminate_unions([[{args, return}] | tail], acc) do
+    # If another arrow is a superset of the current one, we skip it
+    superset = fn
+      [{other_args, other_return}] ->
+        arrow_subtype?(args, return, other_args, other_return)
+
+      _ ->
+        false
+    end
+
+    if Enum.any?(tail, superset) or Enum.any?(acc, superset) do
+      fun_eliminate_unions(tail, acc)
+    else
+      fun_eliminate_unions(tail, [[{args, return}] | acc])
+    end
+  end
+
+  defp fun_eliminate_unions([head | tail], acc) do
+    fun_eliminate_unions(tail, [head | acc])
+  end
+
+  defp fun_pos_to_quoted([_ | _] = pos, opts) do
+    opts = Keyword.put(opts, :skip_dynamic_for_indivisible, false)
+
+    pos
+    |> Enum.sort()
+    |> Enum.map(&fun_intersection_to_quoted(&1, opts))
+    |> Enum.reduce(&{:or, [], [&2, &1]})
+  end
+
+  defp fun_intersection_to_quoted(intersection, opts) do
+    intersection
+    |> Enum.sort()
+    |> Enum.map(fn {args, ret} ->
+      {:__block__, [],
+       [[{:->, [], [Enum.map(args, &to_quoted(&1, opts)), to_quoted(ret, opts)]}]]}
+    end)
+    |> case do
+      [] -> {:fun, [], []}
+      multiple -> Enum.reduce(multiple, &{:and, [], [&2, &1]})
+    end
+  end
+
+  ## List
+
+  # Represents list and improper list simultaneously as a BDD with nodes of the form
+  # `{list_type, last_type}`, where `list_type` is the type of elements in the list,
+  # and `last_type` is the type of the last element (so `[]` if the list is proper,
+  # and anything else but a list if the list is improper).
+
+  # The last_type may be stored as `:term` for optimization purposes. This is ok
+  # because operations like `tl` effectively return the list itself plus the union of
+  # the tail (and if the tail includes the list itself, they are equivalent). And, for other
+  # operations like difference, we expand the tail_type back into
+  # `not non_empty_list()` via `list_tail_unfold/1`. Overall, this simplifies
+  # the code because we don't need to special case `not non_empty_list()`.
+  #
+  # none() types can be given and, while stored, it means the list type is empty.
+  defp list_descr(list_type, last_type, empty?) do
+    {list_dynamic?, list_type} = list_pop_dynamic(list_type)
+    {last_dynamic?, last_type} = list_pop_dynamic(last_type)
+
+    list_part =
+      if last_type == :term do
+        list_new(:term, :term)
+      else
+        case :maps.take(:list, last_type) do
+          :error ->
+            list_new(list_type, last_type)
+
+          {bdd, last_type_no_list} ->
+            # `last_type` may itself represent one or more list types.
+            # Our goal is to fold those list types into `list_type` while retaining the
+            # possible type of the final element (which can be `[]` or any non-list value).
+            #
+            # The list types inside `last_type` are stored in a BDD that includes possible
+            # negations, so we must evaluate each node with its sign taken into account.
+            #
+            # A negation only matters when the negated list type is a supertype of the
+            # corresponding positive list type; in that case we subtract the negated
+            # variant from the positive one.
+            {list_type, last_type} =
+              list_bdd_to_pos_dnf(bdd)
+              |> Enum.reduce({list_type, last_type_no_list}, fn
+                {head, tail}, {acc_head, acc_tail} ->
+                  tail = list_tail_unfold(tail)
+                  {union(head, acc_head), union(tail, acc_tail)}
+              end)
+
+            list_new(list_type, last_type)
+        end
+      end
+
+    list_descr =
+      if empty?, do: %{list: list_part, bitmap: @bit_empty_list}, else: %{list: list_part}
+
+    case list_dynamic? or last_dynamic? do
+      true -> %{dynamic: list_descr}
+      false -> list_descr
+    end
+  end
+
+  defp list_new(list_type, last_type), do: bdd_leaf(list_type, last_type)
+
+  defp non_empty_list_literals_intersection(list_literals) do
+    try do
+      Enum.reduce(list_literals, {:term, :term}, fn {next_list, next_last}, {list, last} ->
+        {non_empty_intersection!(list, next_list), non_empty_intersection!(last, next_last)}
+      end)
+    catch
+      :empty -> :empty
+    end
+  end
+
+  # Takes all the lines from the root to the leaves finishing with a 1,
+  # and compile into tuples of positive and negative nodes. Positive nodes are
+  # those followed by a left path, negative nodes are those followed by a right path.
+  defp list_bdd_to_dnf(bdd) do
+    bdd_to_dnf(bdd)
+    |> Enum.reduce([], fn {pos_list, neg_list}, acc ->
+      case non_empty_list_literals_intersection(pos_list) do
+        :empty ->
+          acc
+
+        {list, last} ->
+          if list_line_empty?(list, last, neg_list),
+            do: acc,
+            else: [{{list, last}, neg_list} | acc]
+      end
+    end)
+  end
+
+  # Takes all the lines from the root to the leaves finishing with a 1,
+  # and compile into tuples of positive and negative nodes. Keep only the non-empty positives,
+  # and include the impact of negations on the last type.
+  # To see if a negation changes the last type or the list type, we just need to check
+  # if the negative list type is a supertype of the positive list type. In that case,
+  # we can remove the negative last type from the positive one.
+  # (If this subtracted type was empty, the whole type would be empty)
+  defp list_bdd_to_pos_dnf(bdd) do
+    bdd_to_dnf(bdd)
+    |> Enum.reduce([], fn {pos_list, neg_list}, acc ->
+      case non_empty_list_literals_intersection(pos_list) do
+        :empty ->
+          acc
+
+        {list, last} ->
+          if list_line_empty?(list, last, neg_list), do: acc, else: [{list, last} | acc]
+      end
+    end)
+  end
+
+  defp list_pop_dynamic(:term), do: {false, :term}
+
+  defp list_pop_dynamic(descr) do
+    case :maps.take(:dynamic, descr) do
+      :error -> {false, descr}
+      {dynamic, _} -> {true, dynamic}
+    end
+  end
+
+  defp list_tail_unfold(:term), do: @not_non_empty_list
+  defp list_tail_unfold(other), do: Map.delete(other, :list)
+
+  @compile {:inline, list_union: 2}
+  defp list_union(bdd1, bdd2), do: bdd_union(bdd1, bdd2)
+
+  defp list_top?(bdd_leaf(:term, :term)), do: true
+  defp list_top?(_), do: false
+
+  defp list_intersection(bdd_leaf(list1, last1), bdd_leaf(list2, last2)) do
+    try do
+      list = non_empty_intersection!(list1, list2)
+      last = non_empty_intersection!(last1, last2)
+      bdd_leaf(list, last)
+    catch
+      :empty -> :bdd_bot
+    end
+  end
+
+  defp list_intersection(bdd1, bdd2) do
+    cond do
+      list_top?(bdd1) and is_tuple(bdd2) -> bdd2
+      list_top?(bdd2) and is_tuple(bdd1) -> bdd1
+      true -> bdd_intersection(bdd1, bdd2)
+    end
+  end
+
+  # Computes the difference between two BDD (Binary Decision Diagram) list types.
+  # It progressively subtracts each type in bdd2 from all types in bdd1.
+  # The algorithm handles three cases:
+  # 1. Disjoint types: keeps the original type from bdd1
+  # 2. Subtype relationship:
+  #    a) If bdd2 type is a supertype, keeps only the negations
+  #    b) If only the last type differs, subtracts it
+  # 3. Base case: adds bdd2 type to negations of bdd1 type
+  # The result may be larger than the initial bdd1, which is maintained in the accumulator.
+  defp list_difference(bdd_leaf(list1, last1) = bdd1, bdd_leaf(list2, last2) = bdd2) do
+    cond do
+      disjoint?(list1, list2) or disjoint?(last1, last2) -> bdd_leaf(list1, last1)
+      subtype?(list1, list2) and subtype?(last1, last2) -> :bdd_bot
+      equal?(list1, list2) -> bdd_leaf(list1, difference(last1, last2))
+      true -> bdd_difference(bdd1, bdd2)
+    end
+  end
+
+  defp list_difference(bdd1, bdd2), do: bdd_difference(bdd1, bdd2)
+
+  defp list_empty?(@non_empty_list_top), do: false
+
+  defp list_empty?(bdd) do
+    bdd_to_dnf(bdd)
+    |> Enum.all?(fn {pos, negs} ->
+      case non_empty_list_literals_intersection(pos) do
+        :empty -> true
+        {list, last} -> list_line_empty?(list, last, negs)
+      end
+    end)
+  end
+
+  defp list_line_empty?(list_type, last_type, negs) do
+    last_type = list_tail_unfold(last_type)
+    # To make a list {list, last} empty with some negative lists:
+    # 1. Ignore negative lists which do not have a list type that is a supertype of the positive one.
+    # 2. Each of the list supertypes:
+    #     a. either completely covers the type, if its last type is a supertype of the positive one,
+    #     b. or it removes part of the last type.
+    empty?(list_type) or empty?(last_type) or
+      Enum.reduce_while(negs, last_type, fn {neg_type, neg_last}, acc_last_type ->
+        if subtype?(list_type, neg_type) do
+          d = difference(acc_last_type, neg_last)
+          if empty?(d), do: {:halt, nil}, else: {:cont, d}
+        else
+          {:cont, acc_last_type}
+        end
+      end)
+      |> is_nil()
+  end
+
+  defp non_empty_list_only?(descr), do: empty?(Map.delete(descr, :list))
+
+  @doc """
+  Returns the head of a list.
+
+  Errors on an empty list.
+  On a non empty list of integers, it returns the first integer.
+  On a non empty list of integers, with an atom head element, it returns the atom.
+  """
+  def list_hd(:term), do: :badnonemptylist
+
+  def list_hd(%{} = descr) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        static_value = list_hd_static(descr)
+
+        if non_empty_list_only?(descr) and not empty?(static_value) do
+          {:ok, static_value}
+        else
+          :badnonemptylist
+        end
+
+      {dynamic, static} ->
+        dynamic_value = list_hd_static(dynamic)
+
+        if non_empty_list_only?(static) and not empty?(dynamic_value) do
+          {:ok, union(dynamic(dynamic_value), list_hd_static(static))}
+        else
+          :badnonemptylist
+        end
+    end
+  end
+
+  defp list_hd_static(:term), do: :term
+
+  defp list_hd_static(%{list: bdd}) do
+    list_bdd_to_pos_dnf(bdd)
+    |> Enum.reduce(none(), fn {list, _}, acc ->
+      union(list, acc)
+    end)
+  end
+
+  defp list_hd_static(%{}), do: none()
+
+  @doc """
+  Returns the tail of a list.
+
+  Errors on a possibly empty list.
+  On a non empty list of integers, it returns a (possibly empty) list of integers.
+  On a non empty list of integers, with an atom tail element, it returns either an atom,
+  or a (possibly empty) list of integers with an atom tail element.
+  """
+  def list_tl(:term), do: :badnonemptylist
+
+  def list_tl(descr) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        static_value = list_tl_static(descr)
+
+        if non_empty_list_only?(descr) and not empty?(static_value) do
+          {:ok, static_value}
+        else
+          :badnonemptylist
+        end
+
+      {dynamic, static} ->
+        dynamic_value = list_tl_static(dynamic)
+
+        if non_empty_list_only?(static) and not empty?(dynamic_value) do
+          {:ok, union(dynamic(dynamic_value), list_tl_static(static))}
+        else
+          :badnonemptylist
+        end
+    end
+  end
+
+  defp list_tl_static(:term), do: :term
+
+  defp list_tl_static(%{list: bdd} = descr) do
+    initial =
+      case descr do
+        %{bitmap: bitmap} when (bitmap &&& @bit_empty_list) != 0 ->
+          %{list: bdd, bitmap: @bit_empty_list}
+
+        %{} ->
+          %{list: bdd}
+      end
+
+    list_bdd_to_pos_dnf(bdd) |> Enum.reduce(initial, fn {_, tail}, acc -> union(tail, acc) end)
+  end
+
+  defp list_tl_static(%{}), do: none()
+
+  defp list_to_quoted(bdd, empty?, opts) do
+    dnf = list_normalize(bdd)
+
+    {unions, list_rendered?} =
+      dnf
+      |> Enum.reduce({[], false}, fn {list_type, last_type, negs}, {acc, list_rendered?} ->
+        {name, arguments, list_rendered?} =
+          if subtype?(last_type, @empty_list) do
+            name = if empty?, do: :list, else: :non_empty_list
+            {name, [to_quoted(list_type, opts)], empty?}
+          else
+            args = [to_quoted(list_type, opts), to_quoted(last_type, opts)]
+            {:non_empty_list, args, list_rendered?}
+          end
+
+        acc =
+          if negs == [] do
+            [{name, [], arguments} | acc]
+          else
+            negs
+            |> non_empty_map_or(fn {ty, lst} ->
+              args =
+                if subtype?(lst, @empty_list) do
+                  [to_quoted(ty, opts)]
+                else
+                  [to_quoted(ty, opts), to_quoted(lst, opts)]
+                end
+
+              {name, [], args}
+            end)
+            |> Kernel.then(
+              &[
+                {:and, [], [{name, [], arguments}, {:not, [], [&1]}]}
+                | acc
+              ]
+            )
+          end
+
+        {acc, list_rendered?}
+      end)
+
+    if empty? and not list_rendered? do
+      [{:empty_list, [], []} | unions]
+    else
+      unions
+    end
+  end
+
+  # Eliminate empty lists from the union, and redundant types (that are subtypes of others,
+  # or that can be merged with others).
+  defp list_normalize(bdd) do
+    list_bdd_to_dnf(bdd)
+    |> Enum.reduce([], fn {{list, last}, negs}, acc ->
+      # First, try to eliminate the negations from the existing type.
+      {list, last, negs} =
+        Enum.uniq(negs)
+        |> Enum.reduce({list, last, []}, fn {nlist, nlast}, {acc_list, acc_last, acc_negs} ->
+          last = list_tail_unfold(last)
+          new_list = intersection(list, nlist)
+          new_last = intersection(last, nlast)
+
+          cond do
+            # No intersection between the list and the negative
+            empty?(new_list) or empty?(new_last) -> {acc_list, acc_last, acc_negs}
+            subtype?(list, nlist) -> {acc_list, difference(acc_last, nlast), acc_negs}
+            true -> {acc_list, acc_last, [{nlist, nlast} | acc_negs]}
+          end
+        end)
+
+      add_to_list_normalize(acc, list, last, negs |> Enum.reverse())
+    end)
+  end
+
+  # List of possible union merges:
+  # Case 1: when a list is a subtype of another
+  # Case 2: when two lists have the same list type, then the last types are united
+  defp add_to_list_normalize([{t, l, []} = cur | rest], list, last, []) do
+    cond do
+      subtype?(list, t) and subtype?(last, l) -> [cur | rest]
+      subtype?(t, list) and subtype?(l, last) -> [{list, last, []} | rest]
+      equal?(t, list) -> [{t, union(l, last), []} | rest]
+      true -> [cur | add_to_list_normalize(rest, list, last, [])]
+    end
+  end
+
+  # Case 3: when a list with negations is united with one of its negations
+  defp add_to_list_normalize([{t, l, n} = cur | rest], list, last, []) do
+    case pop_elem(n, {list, last}, []) do
+      {true, n1} -> [{t, l, n1} | rest]
+      {false, _} -> [cur | add_to_list_normalize(rest, list, last, n)]
+    end
+  end
+
+  defp add_to_list_normalize(rest, list, last, negs), do: [{list, last, negs} | rest]
+
+  defp pop_elem([key | t], key, acc), do: {true, :lists.reverse(acc, t)}
+  defp pop_elem([h | t], key, acc), do: pop_elem(t, key, [h | acc])
+  defp pop_elem([], _key, acc), do: {false, :lists.reverse(acc)}
+
+  ## Dynamic
+  #
+  # A type with a dynamic component is a gradual type; without, it is a static
+  # type. The dynamic component itself is a static type; hence, any gradual type
+  # can be written using a pair of static types as the union:
+  #
+  # `type = (dynamic_component and dynamic()) or static_component`
+  #
+  # where the `static_component` is simply the rest of the `descr`, and `dynamic()`
+  # is the base type that can represent any value at runtime. The dynamic and
+  # static parts can be considered separately for a mixed-typed analysis. For
+  # example, the type
+  #
+  # `type = (dynamic() and integer()) or boolean()`
+  #
+  # denotes an expression that evaluates to booleans or integers; however, there is
+  # uncertainty about the source of these integers. In static mode, the
+  # type-checker refuses to apply a function of type `boolean() -> boolean()` to
+  # this argument (since the argument may turn out to be an integer()), but in
+  # dynamic mode, it considers the type obtained by replacing `dynamic()` with
+  # `none()` (that is, `boolean()`), accepts the application, but types it with a
+  # type that contains `dynamic()`.
+  #
+  # When pattern matching on an expression of type `type`, the static part (here,
+  # booleans) has to be handled exhaustively. In contrast, the dynamic part can
+  # produce potential warnings in specific user-induced conditions, such as asking
+  # for stronger enforcement of static types.
+  #
+  # During construction and through set operations, we maintain the invariant that
+  # the dynamic component is a supertype of the static one, formally
+  # `dynamic_component >= static_component`
+  #
+  # With this invariant, the dynamic component always represents every value that
+  # a given gradual type can take at runtime, allowing us to simplify set operations,
+  # compared, for example, to keeping only the extra dynamic type that can obtained
+  # on top of the static type. Though, the latter may be used for printing purposes.
+  #
+  # There are two ways for a descr to represent a static type: either the
+  # `:dynamic` field is not_set, or it contains a type equal to the static component
+  # (that is, there are no extra dynamic values).
+
+  defp dynamic_union(:term, other), do: optional_to_term(other)
+  defp dynamic_union(other, :term), do: optional_to_term(other)
+
+  defp dynamic_union(left, right),
+    do: symmetrical_merge(unfold(left), unfold(right), &union/3)
+
+  defp dynamic_intersection(:term, other), do: remove_optional_static(other)
+  defp dynamic_intersection(other, :term), do: remove_optional_static(other)
+
+  defp dynamic_intersection(left, right),
+    do: symmetrical_intersection(unfold(left), unfold(right), &intersection/3)
+
+  defp dynamic_to_quoted(descr, opts) do
+    cond do
+      # We check for :term literally instead of using term_type?
+      # because we check for term_type? in to_quoted before we
+      # compute the difference(dynamic, static).
+      descr == :term ->
+        [{:dynamic, [], []}]
+
+      single = indivisible_bitmap(descr, opts) ->
+        [single]
+
+      empty?(descr) ->
+        []
+
+      true ->
+        case non_term_type_to_quoted(descr, opts) do
+          {:none, _meta, []} = none -> [none]
+          descr -> [{:dynamic, [], [descr]}]
+        end
+    end
+  end
+
+  defp indivisible_bitmap(descr, opts) do
+    with true <- Keyword.get(opts, :skip_dynamic_for_indivisible, true),
+         %{bitmap: bitmap} when map_size(descr) == 1 <- descr,
+         [single] <- bitmap_to_quoted(bitmap) do
+      single
+    else
+      _ -> nil
+    end
+  end
+
+  ## Map
+  #
+  # Maps are represented as BDDs, that is, a tree of pairs `{tag_or_domain, fields}`
+  # where `tag_or_domain` is either :closed or :open, or a map from domain keys
+  # (@domain_key_types) to types, and `fields` is a map of atom keys (:foo, :bar, ...)
+  # to types.
+  #
+  # For instance, the type `%{atom() => if_set(integer())}` is the type of maps where atom keys
+  # map to integers, without any non-atom keys. It is represented using the map literal
+  # `{%{atom: if_set(integer())}, %{}}`, with no defined keys.
+  #
+  # The type `%{..., atom() => integer()}` represents maps with atom keys bound to integers,
+  # and other keys bound to any type. It will be represented using a map domain that maps
+  # atom to `if_set(integer())`, and every other domain key to `term_or_optional()`.
+
+  @doc """
+  Converts a type into domain keys.
+  """
+  def to_domain_keys(:term), do: @domain_key_types
+
+  def to_domain_keys(%{dynamic: dynamic}), do: to_domain_keys(dynamic)
+
+  def to_domain_keys(key_descr) do
+    for {type_kind, type} <- key_descr, reduce: [] do
+      acc ->
+        cond do
+          type_kind == :list and
+              match?(%{bitmap: bitmap} when (bitmap &&& @bit_empty_list) != 0, key_descr) ->
+            acc
+
+          type_kind == :atom and match?({:union, _}, type) ->
+            acc
+
+          type_kind == :bitmap ->
+            bitmap_to_domain_keys(type, acc)
+
+          not empty?(%{type_kind => type}) ->
+            [type_kind | acc]
+
+          true ->
+            acc
+        end
+    end
+  end
+
+  defp bitmap_to_domain_keys(bitmap, acc) do
+    acc = if (bitmap &&& @bit_binary) != 0, do: [:binary | acc], else: acc
+    acc = if (bitmap &&& @bit_empty_list) != 0, do: [:list | acc], else: acc
+    acc = if (bitmap &&& @bit_integer) != 0, do: [:integer | acc], else: acc
+    acc = if (bitmap &&& @bit_float) != 0, do: [:float | acc], else: acc
+    acc = if (bitmap &&& @bit_pid) != 0, do: [:pid | acc], else: acc
+    acc = if (bitmap &&& @bit_port) != 0, do: [:port | acc], else: acc
+    acc = if (bitmap &&& @bit_reference) != 0, do: [:reference | acc], else: acc
+    acc
+  end
+
+  defp domain_key_to_descr(:atom), do: atom()
+  defp domain_key_to_descr(:binary), do: binary()
+  defp domain_key_to_descr(:integer), do: integer()
+  defp domain_key_to_descr(:float), do: float()
+  defp domain_key_to_descr(:pid), do: pid()
+  defp domain_key_to_descr(:port), do: port()
+  defp domain_key_to_descr(:reference), do: reference()
+  defp domain_key_to_descr(:fun), do: fun()
+  defp domain_key_to_descr(:tuple), do: tuple()
+  defp domain_key_to_descr(:map), do: open_map()
+  defp domain_key_to_descr(:list), do: @list_top
+
+  defp map_descr(tag, pairs, default, force_domains?) do
+    {fields, domains, dynamic?} = map_descr_pairs(pairs, [], %{}, false)
+
+    map_new =
+      if domains != %{} or force_domains? do
+        domains =
+          if tag == :open do
+            Enum.reduce(@domain_key_types, domains, &Map.put_new(&2, &1, default))
+          else
+            domains
+          end
+
+        map_new(domains, fields)
+      else
+        map_new(tag, fields)
+      end
+
+    case dynamic? do
+      true -> %{dynamic: %{map: map_new}}
+      false -> %{map: map_new}
+    end
+  end
+
+  defp map_put_domain(domain, domain_keys, value) when is_list(domain_keys) do
+    Enum.reduce(domain_keys, domain, fn key, acc when is_atom(key) ->
+      Map.update(acc, key, if_set(value), &union(&1, value))
+    end)
+  end
+
+  defp map_descr_pairs([{key, :term} | rest], fields, domain, dynamic?) do
+    case is_atom(key) do
+      true -> map_descr_pairs(rest, [{key, :term} | fields], domain, dynamic?)
+      false -> map_descr_pairs(rest, fields, map_put_domain(domain, key, :term), dynamic?)
+    end
+  end
+
+  defp map_descr_pairs([{key, value} | rest], fields, domain, dynamic?) do
+    {value, dynamic?} =
+      case :maps.take(:dynamic, value) do
+        :error -> {value, dynamic?}
+        {dynamic, _static} -> {dynamic, true}
+      end
+
+    case is_atom(key) do
+      true -> map_descr_pairs(rest, [{key, value} | fields], domain, dynamic?)
+      false -> map_descr_pairs(rest, fields, map_put_domain(domain, key, value), dynamic?)
+    end
+  end
+
+  defp map_descr_pairs([], fields, domain, dynamic?) do
+    {fields |> Enum.reverse() |> :maps.from_list(), domain, dynamic?}
+  end
+
+  defp tuple_tag_to_type(:open), do: term_or_optional()
+  defp tuple_tag_to_type(:closed), do: not_set()
+
+  # Gets the default type associated to atom keys in a map.
+  defp map_key_tag_to_type(:open), do: term_or_optional()
+  defp map_key_tag_to_type(:closed), do: not_set()
+  defp map_key_tag_to_type(domains = %{}), do: Map.get(domains, :atom, not_set())
+
+  defguardp is_optional_static(map)
+            when is_map(map) and is_map_key(map, :optional)
+
+  defp map_new(tag, fields = %{}), do: bdd_leaf(tag, fields)
+
+  defp map_only?(descr), do: empty?(Map.delete(descr, :map))
+
+  defp non_empty_map_only?(descr) do
+    case :maps.take(:map, descr) do
+      :error -> false
+      {map_bdd, rest} -> empty?(rest) and not map_empty?(map_bdd)
+    end
+  end
+
+  defp map_union(bdd_leaf(tag1, fields1), bdd_leaf(tag2, fields2)) do
+    case maybe_optimize_map_union({tag1, fields1, []}, {tag2, fields2, []}) do
+      {tag, fields, []} -> bdd_leaf(tag, fields)
+      nil -> bdd_union(bdd_leaf(tag1, fields1), bdd_leaf(tag2, fields2))
+    end
+  end
+
+  @compile {:inline, map_union: 2}
+  defp map_union(bdd1, bdd2), do: bdd_union(bdd1, bdd2)
+
+  defp maybe_optimize_map_union({tag1, pos1, []} = map1, {tag2, pos2, []} = map2) do
+    case map_union_optimization_strategy(tag1, pos1, tag2, pos2) do
+      :all_equal ->
+        map1
+
+      :any_map ->
+        {:open, %{}, []}
+
+      {:one_key_difference, key, v1, v2} ->
+        new_pos = Map.put(pos1, key, union(v1, v2))
+        {tag1, new_pos, []}
+
+      :left_subtype_of_right ->
+        map2
+
+      :right_subtype_of_left ->
+        map1
+
+      nil ->
+        nil
+    end
+  end
+
+  defp map_union_optimization_strategy(tag1, pos1, tag2, pos2)
+  defp map_union_optimization_strategy(tag, pos, tag, pos), do: :all_equal
+  defp map_union_optimization_strategy(:open, empty, _, _) when empty == %{}, do: :any_map
+  defp map_union_optimization_strategy(_, _, :open, empty) when empty == %{}, do: :any_map
+
+  defp map_union_optimization_strategy(tag, pos1, tag, pos2)
+       when map_size(pos1) == map_size(pos2) do
+    :maps.iterator(pos1)
+    |> :maps.next()
+    |> do_map_union_optimization_strategy(pos2, :all_equal)
+  end
+
+  defp map_union_optimization_strategy(:open, pos1, _, pos2)
+       when map_size(pos1) <= map_size(pos2) do
+    :maps.iterator(pos1)
+    |> :maps.next()
+    |> do_map_union_optimization_strategy(pos2, :right_subtype_of_left)
+  end
+
+  defp map_union_optimization_strategy(_, pos1, :open, pos2)
+       when map_size(pos1) >= map_size(pos2) do
+    :maps.iterator(pos2)
+    |> :maps.next()
+    |> do_map_union_optimization_strategy(pos1, :right_subtype_of_left)
+    |> case do
+      :right_subtype_of_left -> :left_subtype_of_right
+      nil -> nil
+    end
+  end
+
+  defp map_union_optimization_strategy(_, _, _, _), do: nil
+
+  defp do_map_union_optimization_strategy(:none, _, status), do: status
+
+  defp do_map_union_optimization_strategy({key, v1, iterator}, pos2, status) do
+    with %{^key => v2} <- pos2,
+         next_status when next_status != nil <- map_union_next_strategy(key, v1, v2, status) do
+      do_map_union_optimization_strategy(:maps.next(iterator), pos2, next_status)
+    else
+      _ -> nil
+    end
+  end
+
+  defp map_union_next_strategy(key, v1, v2, status)
+
+  # structurally equal values do not impact the ongoing strategy
+  defp map_union_next_strategy(_key, same, same, status), do: status
+
+  defp map_union_next_strategy(key, v1, v2, :all_equal) do
+    if key != :__struct__, do: {:one_key_difference, key, v1, v2}
+  end
+
+  defp map_union_next_strategy(_key, v1, v2, {:one_key_difference, _, d1, d2}) do
+    # we have at least two key differences now, we switch strategy
+    # if both are subtypes in one direction, keep checking
+    cond do
+      subtype?(d1, d2) and subtype?(v1, v2) -> :left_subtype_of_right
+      subtype?(d2, d1) and subtype?(v2, v1) -> :right_subtype_of_left
+      true -> nil
+    end
+  end
+
+  defp map_union_next_strategy(_key, v1, v2, :left_subtype_of_right) do
+    if subtype?(v1, v2), do: :left_subtype_of_right
+  end
+
+  defp map_union_next_strategy(_key, v1, v2, :right_subtype_of_left) do
+    if subtype?(v2, v1), do: :right_subtype_of_left
+  end
+
+  defp map_top?(bdd_leaf(:open, fields)) when map_size(fields) == 0, do: true
+  defp map_top?(_), do: false
+
+  defp map_intersection(bdd_leaf(tag1, fields1), bdd_leaf(tag2, fields2)) do
+    try do
+      {tag, fields} = map_literal_intersection(tag1, fields1, tag2, fields2)
+      bdd_leaf(tag, fields)
+    catch
+      :empty -> :bdd_bot
+    end
+  end
+
+  defp map_intersection(bdd1, bdd2) do
+    # If intersecting with the top map type, no-op
+    cond do
+      map_top?(bdd1) and is_tuple(bdd2) -> bdd2
+      map_top?(bdd2) and is_tuple(bdd1) -> bdd1
+      true -> bdd_intersection(bdd1, bdd2)
+    end
+  end
+
+  # Optimizations on single maps.
+  defp map_difference(bdd_leaf(tag, fields) = map1, bdd_leaf(neg_tag, neg_fields) = map2) do
+    # Case 1: we are removing an open map with one field. Just do the difference of that field.
+    if neg_tag == :open and map_size(neg_fields) == 1 do
+      [{key, value}] = Map.to_list(neg_fields)
+      t_diff = difference(Map.get(fields, key, map_key_tag_to_type(tag)), value)
+
+      if empty?(t_diff) do
+        :bdd_bot
+      else
+        bdd_leaf(tag, Map.put(fields, key, t_diff))
+      end
+    else
+      # Case 2: the maps have all but one key in common. Do the difference of that key.
+      case map_all_but_one(tag, fields, neg_tag, neg_fields) do
+        {:one, diff_key} ->
+          bdd_leaf(tag, Map.update!(fields, diff_key, &difference(&1, neg_fields[diff_key])))
+
+        _ ->
+          bdd_difference(map1, map2)
+      end
+    end
+  end
+
+  defp map_difference(bdd1, bdd2), do: bdd_difference(bdd1, bdd2)
+
+  # Intersects two map literals; throws if their intersection is empty.
+  # Both open: the result is open.
+  defp map_literal_intersection(:open, map1, :open, map2) do
+    new_fields =
+      symmetrical_merge(map1, map2, fn _, type1, type2 ->
+        non_empty_intersection!(type1, type2)
+      end)
+
+    {:open, new_fields}
+  end
+
+  # Both closed: the result is closed.
+  defp map_literal_intersection(:closed, map1, :closed, map2) do
+    new_fields =
+      symmetrical_intersection(map1, map2, fn _, type1, type2 ->
+        non_empty_intersection!(type1, type2)
+      end)
+
+    if map_size(new_fields) < map_size(map1) or map_size(new_fields) < map_size(map2) do
+      throw(:empty)
+    end
+
+    {:closed, new_fields}
+  end
+
+  # Open and closed: result is closed, all fields from open should be in closed, except not_set ones.
+  defp map_literal_intersection(:open, open, :closed, closed) do
+    :maps.iterator(open) |> :maps.next() |> map_literal_intersection_loop(closed)
+  end
+
+  defp map_literal_intersection(:closed, closed, :open, open) do
+    :maps.iterator(open) |> :maps.next() |> map_literal_intersection_loop(closed)
+  end
+
+  # At least one tag is a tag-domain pair.
+  defp map_literal_intersection(tag_or_domains1, map1, tag_or_domains2, map2) do
+    # For a closed map with domains intersected with an open map with domains:
+    # 1. The result is closed (more restrictive)
+    # 2. We need to check each domain in the open map against the closed map
+    default1 = map_key_tag_to_type(tag_or_domains1)
+    default2 = map_key_tag_to_type(tag_or_domains2)
+
+    # Compute the new domain
+    tag_or_domains = map_domain_intersection(tag_or_domains1, tag_or_domains2)
+
+    # Go over all fields in map1 and map2 with default atom types atom1 and atom2
+    # 1. If key is in both maps, compute non empty intersection (:error if it is none)
+    # 2. If key is only in map1, compute non empty intersection with atom2
+    # 3. If key is only in map2, compute non empty intersection with atom1
+    # We do that by computing intersection on all key labels in both map1 and map2,
+    # using default values when a key is not present.
+    {tag_or_domains,
+     symmetrical_merge(map1, default1, map2, default2, fn _key, v1, v2 ->
+       non_empty_intersection!(v1, v2)
+     end)}
+  end
+
+  # Compute the intersection of two tags or tag-domain pairs.
+  defp map_domain_intersection(:closed, _), do: :closed
+  defp map_domain_intersection(_, :closed), do: :closed
+  defp map_domain_intersection(:open, tag_or_domains), do: tag_or_domains
+  defp map_domain_intersection(tag_or_domains, :open), do: tag_or_domains
+
+  defp map_domain_intersection(domains1 = %{}, domains2 = %{}) do
+    new_domains =
+      for {domain_key, type1} <- domains1, reduce: %{} do
+        acc_domains ->
+          case domains2 do
+            %{^domain_key => type2} ->
+              inter = intersection(type1, type2)
+
+              if empty_or_optional?(inter) do
+                acc_domains
+              else
+                Map.put(acc_domains, domain_key, inter)
+              end
+
+            _ ->
+              acc_domains
+          end
+      end
+
+    # If the explicit domains are empty, use simple atom tags
+    if map_size(new_domains) == 0, do: :closed, else: new_domains
+  end
+
+  defp map_literal_intersection_loop(:none, acc), do: {:closed, acc}
+
+  defp map_literal_intersection_loop({key, type1, iterator}, acc) do
+    case acc do
+      %{^key => type2} ->
+        acc = %{acc | key => non_empty_intersection!(type1, type2)}
+        :maps.next(iterator) |> map_literal_intersection_loop(acc)
+
+      _ ->
+        # If the key is optional in the open map, we can ignore it
+        case type1 do
+          %{optional: 1} -> :maps.next(iterator) |> map_literal_intersection_loop(acc)
+          _ -> throw(:empty)
+        end
+    end
+  end
+
+  defp non_empty_intersection!(type1, type2) do
+    type = intersection(type1, type2)
+    if empty?(type), do: throw(:empty), else: type
+  end
+
+  # Takes all the lines from the root to the leaves finishing with a 1,
+  # and compile into tuples of positive and negative nodes. Positive nodes are
+  # those followed by a left path, negative nodes are those followed by a right path.
+  defp map_bdd_to_dnf(bdd) do
+    bdd_to_dnf(bdd)
+    |> Enum.reduce([], fn {pos, negs}, acc ->
+      case non_empty_map_literals_intersection(pos) do
+        :empty ->
+          acc
+
+        {tag, fields} ->
+          if init_map_line_empty?(tag, fields, negs) do
+            acc
+          else
+            [{tag, fields, negs} | acc]
+          end
+      end
+    end)
+  end
+
+  ## Map key functions
+
+  @doc """
+  Fetches the type of the value returned by accessing `key` on `map`
+  with the assumption that the descr is exclusively a map (or dynamic).
+
+  It returns a two element tuple or `:error`. The first element says
+  if the type is dynamically optional or not, the second element is
+  the type. In static mode, optional keys are not allowed.
+  """
+  def map_fetch_key(:term, _key), do: :badmap
+
+  def map_fetch_key(%{} = descr, key) when is_atom(key) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        if descr_key?(descr, :map) and non_empty_map_only?(descr) do
+          {static_optional?, static_type} = map_fetch_key_static(descr, key)
+
+          if static_optional? or empty?(static_type) do
+            :badkey
+          else
+            {false, static_type}
+          end
+        else
+          :badmap
+        end
+
+      {dynamic, static} ->
+        if descr_key?(dynamic, :map) and map_only?(static) do
+          {dynamic_optional?, dynamic_type} = map_fetch_key_static(dynamic, key)
+          {static_optional?, static_type} = map_fetch_key_static(static, key)
+
+          if static_optional? or empty?(dynamic_type) do
+            :badkey
+          else
+            {dynamic_optional?, union(dynamic(dynamic_type), static_type)}
+          end
+        else
+          :badmap
+        end
+    end
+  end
+
+  # Optimization: if the key does not exist in the map, avoid building
+  # if_set/not_set pairs and return the popped value directly.
+  defp map_fetch_key_static(%{map: bdd_leaf(tag_or_domains, fields)}, key)
+       when not is_map_key(fields, key) do
+    map_key_tag_to_type(tag_or_domains) |> pop_optional_static()
+  end
+
+  defp map_fetch_key_static(%{map: bdd}, key) do
+    map_bdd_to_dnf(bdd) |> map_dnf_fetch_static(key) |> pop_optional_static()
+  end
+
+  defp map_fetch_key_static(%{}, _key), do: {false, none()}
+  defp map_fetch_key_static(:term, _key), do: {true, term()}
+
+  # Takes a map DNF and returns the union of types it can take for a given key.
+  # If the key may be undefined, it will contain the `not_set()` type.
+  defp map_dnf_fetch_static(dnf, key) do
+    Enum.reduce(dnf, none(), fn
+      # Optimization: if there are no negatives and key exists, return its value
+      {_tag, %{^key => value}, []}, acc ->
+        value |> union(acc)
+
+      # Optimization: if there are no negatives and the key does not exist, return the default one.
+      {tag, %{}, []}, acc ->
+        map_key_tag_to_type(tag) |> union(acc)
+
+      {tag, fields, negs}, acc ->
+        {fst, snd} = map_pop_key(tag, fields, key)
+
+        case map_split_negative_key(negs, key) do
+          :empty ->
+            acc
+
+          negative ->
+            negative
+            |> pair_make_disjoint()
+            |> pair_eliminate_negations_fst(fst, snd)
+            |> union(acc)
+        end
+    end)
+  end
+
+  @doc """
+  Returns the map converted into a list.
+  """
+  def map_to_list(descr, fun \\ &tuple([&1, &2]))
+
+  def map_to_list(:term, _fun), do: :badmap
+
+  def map_to_list(descr, fun) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        if map_only?(descr) do
+          map_to_list_static(descr, fun)
+        else
+          :badmap
+        end
+
+      {dynamic, static} ->
+        if map_only?(static) do
+          with {:ok, dynamic_type} <- map_to_list_static(dynamic, fun) do
+            if descr_key?(static, :map) do
+              with {:ok, static_type} <- map_to_list_static(static, fun) do
+                {:ok, union(static_type, dynamic(dynamic_type))}
+              end
+            else
+              {:ok, dynamic(dynamic_type)}
+            end
+          end
+        else
+          :badmap
+        end
+    end
+  end
+
+  defp map_to_list_static(%{map: bdd}, fun) do
+    case map_bdd_to_dnf(bdd) do
+      [] ->
+        :badmap
+
+      dnf ->
+        case map_to_list_static(bdd, dnf, fun) do
+          value when value == @none ->
+            {:ok, empty_list()}
+
+          inner ->
+            if has_empty_map?(dnf) do
+              {:ok, list(inner)}
+            else
+              {:ok, non_empty_list(inner)}
+            end
+        end
+    end
+  end
+
+  defp map_to_list_static(%{}, _fun) do
+    :badmap
+  end
+
+  defp map_to_list_static(:term, fun) do
+    {:ok, list(fun.(term(), term()))}
+  end
+
+  defp has_empty_map?(dnf) do
+    Enum.any?(dnf, fn {_, fields, negs} ->
+      Enum.all?(fields, fn {_key, value} -> optional_static?(value) end) and
+        Enum.all?(negs, fn {_, fields} ->
+          not Enum.all?(fields, fn {_key, value} -> optional_static?(value) end)
+        end)
+    end)
+  end
+
+  defp map_to_list_static(bdd, dnf, fun) do
+    try do
+      # Check if any line in the DNF represents an open map or compute the union of domain keys types
+      Enum.reduce(dnf, none(), fn
+        {tag_or_domains, _fields, _negs}, acc ->
+          case tag_or_domains do
+            :open ->
+              # A negation cannot make an open map closed without cancelling it completely,
+              # which is filtered by `map_bdd_to_dnf/1`.
+              throw(:open)
+
+            domains = %{} ->
+              Enum.reduce(domains, acc, fn {domain_key, value}, acc ->
+                value = remove_optional(value)
+
+                if empty?(value) do
+                  acc
+                else
+                  union(acc, fun.(domain_key_to_descr(domain_key), value))
+                end
+              end)
+
+            _ ->
+              acc
+          end
+      end)
+    catch
+      :open -> fun.(term(), term())
+    else
+      domain_keys_type ->
+        {_seen, acc} =
+          bdd_reduce(bdd, {%{}, domain_keys_type}, fn {_tag, fields}, seen_acc ->
+            Enum.reduce(fields, seen_acc, fn {key, _type}, {seen, acc} ->
+              if Map.has_key?(seen, key) do
+                {seen, acc}
+              else
+                value = dnf |> map_dnf_fetch_static(key) |> remove_optional_static()
+                seen = Map.put(seen, key, [])
+
+                if empty?(value) do
+                  {seen, acc}
+                else
+                  {seen, union(acc, fun.(atom([key]), value))}
+                end
+              end
+            end)
+          end)
+
+        acc
+    end
+  end
+
+  @doc """
+  Updates `key_descr` in `descr` with `type`.
+
+  `key_descr` is split into optional and required keys and tracked accordingly.
+  The gradual aspect of `key_descr` does not impact the return type.
+
+  It returns `{type, descr, errors}`, `:badmap`, `{:error, errors}`.
+  The list of `errors` may be empty, which implies the a bad domain.
+  The `return_type?` flag is used for optimizations purposes. If set to false,
+  the returned `type` should not be used, as it will be imprecise.
+  """
+  def map_update(descr, key_descr, type, return_type? \\ true)
+
+  def map_update(:term, _key_descr, _type, _return_type?), do: :badmap
+
+  def map_update(descr, key_descr, :term, return_type?),
+    do: map_update_static_value(descr, key_descr, :term, return_type?)
+
+  def map_update(descr, key_descr, type, return_type?) do
+    case :maps.take(:dynamic, type) do
+      :error ->
+        map_update_static_value(descr, key_descr, type, return_type?)
+
+      {dynamic, _static} ->
+        map_update_static_value(dynamic(descr), key_descr, dynamic, return_type?)
+    end
+  end
+
+  defp map_update_static_value(descr, key_descr, type, return_type?) do
+    split_keys = map_split_keys_and_domains(key_descr)
+
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        if descr_key?(descr, :map) and map_only?(descr) do
+          {type, descr, errors} =
+            map_update_static(descr, split_keys, type, return_type?, fn optional?, type ->
+              optional? or empty?(type)
+            end)
+
+          if descr == none() do
+            {:error, errors}
+          else
+            {type, descr, errors}
+          end
+        else
+          :badmap
+        end
+
+      {dynamic, static} ->
+        if descr_key?(dynamic, :map) and map_only?(static) do
+          {static_value, static_descr, static_errors} =
+            map_update_static(static, split_keys, type, return_type?, fn optional?, _ ->
+              optional?
+            end)
+
+          {dynamic_value, dynamic_descr, dynamic_errors} =
+            map_update_static(dynamic, split_keys, type, return_type?, fn _, type ->
+              empty?(type)
+            end)
+
+          if dynamic_descr == none() do
+            {:error, static_errors ++ dynamic_errors}
+          else
+            {union(static_value, dynamic(dynamic_value)),
+             union(static_descr, dynamic(dynamic_descr)), static_errors ++ dynamic_errors}
+          end
+        else
+          :badmap
+        end
+    end
+  end
+
+  defp map_update_static(%{map: bdd}, split_keys, type, return_type?, missing_fun) do
+    {required_keys, optional_keys, maybe_negated_set, required_domains, optional_domains} =
+      split_keys
+
+    dnf = map_bdd_to_dnf(bdd)
+
+    callback =
+      if return_type? do
+        fn -> map_update_merge_atom_key(bdd, dnf) end
+      else
+        fn ->
+          # If we have required keys, we can assume domain_atom always work
+          if required_keys != [] or map_update_any_atom_key?(bdd, dnf) do
+            term()
+          else
+            none()
+          end
+        end
+      end
+
+    # Required domains must be found
+    {found_required?, required_domains, missing_domains, value} =
+      map_update_get_domains(dnf, required_domains, none(), return_type?, callback)
+
+    # Optional domains can be missing
+    {found_optional?, optional_domains, _, value} =
+      map_update_get_domains(dnf, optional_domains, value, return_type?, callback)
+
+    bdd = map_update_put_negated(bdd, maybe_negated_set, type)
+    errors = Enum.map(missing_domains, &{:baddomain, domain_key_to_descr(&1)})
+
+    acc =
+      if found_optional? or found_required? do
+        # If any of required or optional domains are satisfied, then we compute the
+        # initial return type. `map_update_keys_static` will then union into the
+        # computed type below, using the original bdd/dnf, not the one with updated domains.
+        descr = map_update_put_domains(bdd, required_domains ++ optional_domains, type)
+        {remove_optional(value), descr, errors}
+      else
+        {remove_optional(value), none(), errors}
+      end
+
+    map_update_keys_static(dnf, required_keys, optional_keys, type, missing_fun, acc)
+  end
+
+  defp map_update_static(%{}, _split_keys, _type, _return_type?, _missing_fun) do
+    {none(), none(), []}
+  end
+
+  defp map_update_static(:term, split_keys, type, _return_type?, missing_fun) do
+    # Since it is an open map, we don't need to check the domains.
+    # The negated set will also be empty, because there are no fields.
+    # Finally, merged required_keys into optional_keys.
+    {required_keys, optional_keys, _maybe_negated_set, required_domains, optional_domains} =
+      split_keys
+
+    if required_domains != [] or optional_domains != [] do
+      {term(), open_map(), []}
+    else
+      acc = {none(), none(), []}
+      dnf = map_bdd_to_dnf(@map_top)
+      map_update_keys_static(dnf, required_keys, optional_keys, type, missing_fun, acc)
+    end
+  end
+
+  defp map_update_keys_static(dnf, required, optional, type, missing_fun, acc) do
+    acc = map_update_keys(dnf, required, type, :required, missing_fun, acc)
+    acc = map_update_keys(dnf, optional, type, :optional, missing_fun, acc)
+    acc
+  end
+
+  defp map_update_keys(dnf, keys, type, required_or_optional, missing_fun, acc) do
+    Enum.reduce(keys, acc, fn key, {acc_value, acc_descr, acc_errors} ->
+      {value, descr} = map_dnf_pop_key_static(dnf, key, none())
+      {optional?, value} = pop_optional_static(value)
+
+      cond do
+        not missing_fun.(optional?, value) ->
+          acc_value = union(value, acc_value)
+          acc_descr = union(map_put_key_static(descr, key, type), acc_descr)
+          {acc_value, acc_descr, acc_errors}
+
+        required_or_optional == :required ->
+          {acc_value, acc_descr, [{:badkey, key} | acc_errors]}
+
+        true ->
+          {acc_value, acc_descr, acc_errors}
+      end
+    end)
+  end
+
+  # Directly inserts a key of a given type into every positive and negative map.
+  defp map_put_key_static(%{map: bdd} = descr, key, type) do
+    bdd = bdd_map(bdd, fn {tag, fields} -> {tag, Map.put(fields, key, type)} end)
+    %{descr | map: bdd}
+  end
+
+  defp map_put_key_static(descr, _key, _type), do: descr
+
+  # Removes a key from a map type and return its type.
+  #
+  # ## Algorithm
+  #
+  # 1. Split the map type based on the presence of the key.
+  # 2. Take the second part of the split, which represents the union of all
+  #    record types where the key has been explicitly removed.
+  # 3. Intersect this with an open record type where the key is explicitly absent.
+  #    This step eliminates the key from open record types where it was implicitly present.
+  #
+  # Note: if initial is nil, it means the value is not required.
+  # So we don't compute it for performance.
+  defp map_dnf_pop_key_static(dnf, key, initial) do
+    {value, descr} =
+      Enum.reduce(dnf, {initial, none()}, fn
+        # Optimization: if there are no negatives, we can directly remove the key.
+        {tag, fields, []}, {value, map} ->
+          {fst, snd} = map_pop_key(tag, fields, key)
+          {maybe_union(value, fn -> fst end), union(map, snd)}
+
+        {tag, fields, negs}, {value, map} ->
+          {fst, snd} = map_pop_key(tag, fields, key)
+
+          case map_split_negative_key(negs, key) do
+            :empty ->
+              {value, map}
+
+            negative ->
+              disjoint = pair_make_disjoint(negative)
+
+              {maybe_union(value, fn -> pair_eliminate_negations_fst(disjoint, fst, snd) end),
+               disjoint |> pair_eliminate_negations_snd(fst, snd) |> union(map)}
+          end
+      end)
+
+    {value, descr}
+  end
+
+  # For keys with `not :foo`, we generate an approximation
+  # by adding the type to all keys, except `:foo`.
+  defp map_update_put_negated(bdd, nil, _type), do: bdd
+
+  defp map_update_put_negated(bdd, negated, type) do
+    bdd_map(bdd, fn {tag, fields} ->
+      fields =
+        Map.new(fields, fn {key, value} ->
+          if :sets.is_element(key, negated) do
+            {key, value}
+          else
+            {key, union(value, type)}
+          end
+        end)
+
+      {tag, fields}
+    end)
+  end
+
+  defp map_update_merge_atom_key(bdd, dnf) do
+    {_seen, acc} =
+      bdd_reduce(bdd, {%{}, none()}, fn {_tag, fields}, seen_acc ->
+        Enum.reduce(fields, seen_acc, fn {key, _type}, {seen, acc} ->
+          if Map.has_key?(seen, key) do
+            {seen, acc}
+          else
+            value = dnf |> map_dnf_fetch_static(key) |> remove_optional_static()
+            {Map.put(seen, key, []), union(acc, value)}
+          end
+        end)
+      end)
+
+    acc
+  end
+
+  defp map_update_any_atom_key?(bdd, dnf) do
+    bdd_reduce(bdd, %{}, fn {_tag, fields}, acc ->
+      Enum.reduce(fields, acc, fn {key, _type}, acc ->
+        if Map.has_key?(acc, key) do
+          acc
+        else
+          value = map_dnf_fetch_static(dnf, key)
+          not empty_or_optional?(value) and throw(:found_key)
+          Map.put(acc, key, [])
+        end
+      end)
+    end)
+  catch
+    :found_key -> true
+  end
+
+  defp map_update_get_domains(dnf, domain_keys, acc, require_type?, any_atom_key) do
+    Enum.reduce(domain_keys, {false, [], [], acc}, fn domain_key, {found?, valid, invalid, acc} ->
+      value = map_get_domain(dnf, domain_key, none())
+
+      cond do
+        domain_key == :atom ->
+          atom_acc = any_atom_key.()
+
+          cond do
+            not empty_or_optional?(value) ->
+              acc = if require_type?, do: union(union(atom_acc, acc), value), else: acc
+              {true, [:atom | valid], invalid, acc}
+
+            not empty_or_optional?(atom_acc) ->
+              acc = if require_type?, do: union(atom_acc, acc), else: acc
+              {true, valid, [:atom | invalid], acc}
+
+            true ->
+              {found?, valid, [:atom | invalid], acc}
+          end
+
+        not empty_or_optional?(value) ->
+          acc = if require_type?, do: union(acc, value), else: acc
+          {true, [domain_key | valid], invalid, acc}
+
+        true ->
+          {found?, valid, [domain_key | invalid], acc}
+      end
+    end)
+  end
+
+  # For negations, we count on the idea that a negation will not remove any
+  # type from a domain unless it completely cancels out the type.
+  #
+  # So for any non-empty map bdd, we just update the domain with the new type,
+  # as well as its negations to keep them accurate.
+  #
+  # Note we store all domain_keys at once. Therefore, this operation:
+  #
+  #    map = %{integer() => if_set(:foo), float() => if_set(:bar)}
+  #    Map.put(map, integer() or float(), pid())
+  #
+  # will return:
+  #
+  #    %{integer() => if_set(:foo or pid()), float() => if_set(:bar or pid())}
+  #
+  # We could instead have returned:
+  #
+  #    %{integer() => if_set(:foo or pid()), float() => if_set(:bar)} or
+  #      %{integer() => if_set(:foo), float() => if_set(:bar or pid())}
+  #
+  # But that would not be helpful, as we can't distinguish between these two
+  # in Elixir code. It only makes sense to build the union for domain keys
+  # that do not exist.
+  defp map_update_put_domains(bdd, [], _type), do: %{map: bdd}
+
+  defp map_update_put_domains(bdd, domain_keys, type) do
+    bdd =
+      bdd_map(bdd, fn {tag, fields} ->
+        {map_update_put_domain(tag, domain_keys, type), fields}
+      end)
+
+    %{map: bdd}
+  end
+
+  defp map_update_put_domain(tag_or_domains, domain_keys, type) do
+    case tag_or_domains do
+      :open ->
+        :open
+
+      :closed ->
+        Map.from_keys(domain_keys, if_set(type))
+
+      domains = %{} ->
+        Enum.reduce(domain_keys, domains, fn domain_key, acc ->
+          Map.update(acc, domain_key, if_set(type), &union(&1, type))
+        end)
+    end
+  end
+
+  @doc """
+  Puts a static key into `descr`.
+
+  Shortcut around `map_put/3`.
+  """
+  def map_put_key(:term, key, _) when is_atom(key),
+    do: :badmap
+
+  def map_put_key(descr, key, type) when is_atom(key),
+    do: map_put_shared(descr, {[key], [], nil, [], []}, type)
+
+  @doc """
+  Puts the `key_descr` with `type`.
+
+  `key_descr` is split into optional and required keys and tracked accordingly.
+
+  Returns `{:ok, descr}` or `:badmap`.
+  """
+  def map_put(:term, _, _), do: :badmap
+
+  def map_put(descr, key_descr, type) do
+    if key_descr in [:term, %{dynamic: :term}] and type in [:term, %{dynamic: :term}] do
+      {:ok, if(gradual?(type) or gradual?(descr), do: dynamic(open_map()), else: open_map())}
+    else
+      map_put_shared(descr, map_split_keys_and_domains(key_descr), type)
+    end
+  end
+
+  defp map_put_shared(%{} = descr, split_keys, :term),
+    do: map_put_static_value(descr, split_keys, :term)
+
+  defp map_put_shared(%{} = descr, split_keys, type) do
+    case :maps.take(:dynamic, type) do
+      :error -> map_put_static_value(descr, split_keys, type)
+      {dynamic, _static} -> map_put_static_value(dynamic(descr), split_keys, dynamic)
+    end
+  end
+
+  defp map_put_static_value(descr, split_keys, type) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        if descr_key?(descr, :map) and map_only?(descr) do
+          {:ok, map_put_static(descr, split_keys, type)}
+        else
+          :badmap
+        end
+
+      {dynamic, static} ->
+        if descr_key?(dynamic, :map) and map_only?(static) do
+          static_descr = map_put_static(static, split_keys, type)
+          dynamic_descr = map_put_static(dynamic, split_keys, type)
+          {:ok, union(static_descr, dynamic(dynamic_descr))}
+        else
+          :badmap
+        end
+    end
+  end
+
+  defp map_put_static(%{map: bdd}, split_keys, type) do
+    {required_keys, optional_keys, maybe_negated_set, required_domains, optional_domains} =
+      split_keys
+
+    bdd = map_update_put_negated(bdd, maybe_negated_set, type)
+
+    descr =
+      case required_domains ++ optional_domains do
+        [] -> none()
+        domains -> map_update_put_domains(bdd, domains, type)
+      end
+
+    dnf = map_bdd_to_dnf(bdd)
+    map_put_keys_static(dnf, required_keys ++ optional_keys, type, descr)
+  end
+
+  defp map_put_static(%{}, _split_keys, _type) do
+    none()
+  end
+
+  defp map_put_static(:term, split_keys, type) do
+    # Since it is an open map, we don't need to check the domains.
+    # The negated set will also be empty, because there are no fields.
+    # Finally, merged required_keys into optional_keys.
+    {required_keys, optional_keys, _maybe_negated_set, required_domains, optional_domains} =
+      split_keys
+
+    if required_domains != [] or optional_domains != [] do
+      open_map()
+    else
+      dnf = map_bdd_to_dnf(@map_top)
+      map_put_keys_static(dnf, required_keys ++ optional_keys, type, none())
+    end
+  end
+
+  defp map_put_keys_static(dnf, keys, type, acc) do
+    Enum.reduce(keys, acc, fn key, acc ->
+      {nil, descr} = map_dnf_pop_key_static(dnf, key, nil)
+      union(map_put_key_static(descr, key, type), acc)
+    end)
+  end
+
+  @doc """
+  Computes the union of types for keys matching `key_type` within the `map_type`.
+
+  Returns `{optional?, descr}`, `:error` (if no value across the whole domain is found),
+  or `:badmap`.
+
+  This is called `map_get/2` but it can be used to power `Map.fetch`, `Map.fetch!`,
+  `Map.get`, etc. except `map.key`.
+  """
+  def map_get(:term, _key_descr), do: :badmap
+
+  def map_get(%{} = descr, key_descr) do
+    split_keys = map_split_keys_and_domains(key_descr)
+
+    # If we are looking for infinite atoms, then either there are required/optional
+    # keys which may be selected, so we use not_set().
+    #
+    # In case, there are no keys, which will fail unless there are domain keys,
+    # so `not_set()` is still correct.
+    acc =
+      if infinite_atoms?(key_descr) do
+        not_set()
+      else
+        none()
+      end
+
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        if descr_key?(descr, :map) and map_only?(descr) do
+          {optional?, type_selected} =
+            map_get_static(descr, split_keys, acc) |> pop_optional_static()
+
+          if empty?(type_selected) do
+            :error
+          else
+            {optional?, type_selected}
+          end
+        else
+          :badmap
+        end
+
+      {dynamic, static} ->
+        if descr_key?(dynamic, :map) and map_only?(static) do
+          {optional_dynamic?, dynamic_type} =
+            map_get_static(dynamic, split_keys, acc) |> pop_optional_static()
+
+          {optional_static?, static_type} =
+            map_get_static(static, split_keys, acc) |> pop_optional_static()
+
+          if empty?(dynamic_type) do
+            :error
+          else
+            {optional_dynamic? or optional_static?, union(dynamic(dynamic_type), static_type)}
+          end
+        else
+          :badmap
+        end
+    end
+  end
+
+  defp map_get_static(%{map: bdd}, split_keys, acc) do
+    {required_keys, optional_keys, maybe_negated_set, required_domains, optional_domains} =
+      split_keys
+
+    dnf = map_bdd_to_dnf(bdd)
+
+    acc = map_get_keys(dnf, required_keys, acc)
+    acc = map_get_keys(dnf, optional_keys, acc)
+    acc = map_get_keys(dnf, map_materialize_negated_set(maybe_negated_set, bdd), acc)
+    acc = Enum.reduce(required_domains, acc, &map_get_domain(dnf, &1, &2))
+    acc = Enum.reduce(optional_domains, acc, &map_get_domain(dnf, &1, &2))
+    acc
+  end
+
+  defp map_get_static(%{}, _split_keys, acc), do: acc
+  defp map_get_static(:term, _split_keys, _acc), do: term_or_optional()
+
+  defp map_get_keys(dnf, keys, acc) do
+    Enum.reduce(keys, acc, fn atom, acc ->
+      union(map_dnf_fetch_static(dnf, atom), acc)
+    end)
+  end
+
+  # Take a map bdd and return the union of types for the given key domain.
+  defp map_get_domain(dnf, domain_key, acc) when is_atom(domain_key) do
+    Enum.reduce(dnf, acc, fn
+      {:open, _fields, []}, acc ->
+        union(term_or_optional(), acc)
+
+      {:closed, _fields, []}, acc ->
+        acc
+
+      # Optimization: if there are no negatives and domains exists, return its value
+      {%{^domain_key => value}, _fields, []}, acc ->
+        value |> union(acc)
+
+      # Optimization: if there are no negatives and the key does not exist, skip it
+      {_domains, _fields, []}, acc ->
+        acc
+
+      {tag_or_domains, fields, negs}, acc ->
+        {fst, snd} = map_pop_domain(tag_or_domains, fields, domain_key)
+
+        case map_split_negative_domain(negs, domain_key) do
+          :empty ->
+            acc
+
+          negative ->
+            negative
+            |> pair_make_disjoint()
+            |> pair_eliminate_negations_fst(fst, snd)
+            |> union(acc)
+        end
+    end)
+  end
+
+  defp map_materialize_negated_set(nil, _bdd), do: []
+
+  defp map_materialize_negated_set(set, bdd) do
+    all_fields = bdd_reduce(bdd, %{}, fn {_, fields}, acc -> Map.merge(fields, acc) end)
+    for {atom, _} <- all_fields, not :sets.is_element(atom, set), do: atom
+  end
+
+  # Compute which keys are optional, which ones are required, as well as domain keys
+  defp map_split_keys_and_domains(%{dynamic: dynamic} = static) do
+    {required_keys, optional_keys, maybe_negated_set} =
+      case {static, unfold(dynamic)} do
+        {%{atom: {:union, static_union}}, %{atom: {:union, dynamic_union}}} ->
+          # The static union is required, extract them from optional
+          {:sets.to_list(static_union),
+           :sets.to_list(:sets.subtract(dynamic_union, static_union)), nil}
+
+        {%{atom: {:union, static_union}}, %{atom: {:negation, dynamic_negation}}} ->
+          # The static union will already be checked, merge them into the negation
+          {:sets.to_list(static_union), [], :sets.union(dynamic_negation, static_union)}
+
+        {%{atom: {:union, static_union}}, _} ->
+          {:sets.to_list(static_union), [], nil}
+
+        {%{atom: {:negation, static_negation}}, %{atom: {:union, dynamic_union}}} ->
+          # The dynamic union will already be checked, merge them into the negation
+          {[], :sets.to_list(dynamic_union), :sets.union(static_negation, dynamic_union)}
+
+        {%{atom: {:negation, static_negation}}, %{atom: {:negation, dynamic_negation}}} ->
+          {[], [], :sets.union(dynamic_negation, static_negation)}
+
+        {%{}, %{atom: {:union, dynamic_union}}} ->
+          {[], :sets.to_list(dynamic_union), nil}
+
+        {%{}, %{atom: {:negation, dynamic_negation}}} ->
+          {[], [], dynamic_negation}
+
+        {%{}, %{}} ->
+          {[], [], nil}
+      end
+
+    required_domains = to_domain_keys(Map.delete(static, :dynamic))
+    optional_domains = to_domain_keys(dynamic) -- required_domains
+    {required_keys, optional_keys, maybe_negated_set, required_domains, optional_domains}
+  end
+
+  defp map_split_keys_and_domains(%{atom: {:union, atoms}} = key_descr) do
+    {:sets.to_list(atoms), [], nil, to_domain_keys(key_descr), []}
+  end
+
+  defp map_split_keys_and_domains(%{atom: {:negation, atoms}} = key_descr) do
+    {[], [], atoms, to_domain_keys(key_descr), []}
+  end
+
+  defp map_split_keys_and_domains(key_descr) do
+    {[], [], nil, to_domain_keys(key_descr), []}
+  end
+
+  defp non_empty_map_literals_intersection(maps) do
+    try do
+      Enum.reduce(maps, {:open, %{}}, fn {next_tag, next_fields}, {tag, fields} ->
+        map_literal_intersection(tag, fields, next_tag, next_fields)
+      end)
+    catch
+      :empty -> :empty
+    end
+  end
+
+  # Short-circuits if it finds a non-empty map literal in the union.
+  # Since the algorithm is recursive, we implement the short-circuiting
+  # as throw/catch.
+  defp map_empty?(bdd) do
+    bdd_to_dnf(bdd)
+    |> Enum.all?(fn {pos, negs} ->
+      case non_empty_map_literals_intersection(pos) do
+        :empty ->
+          true
+
+        {tag, fields} when is_map(fields) ->
+          # We check the emptiness of the fields because non_empty_map_literal_intersection
+          # will not return :empty on fields that are set to none() and that exist
+          # just in one map, but not the other.
+          init_map_line_empty?(tag, fields, negs)
+      end
+    end)
+  end
+
+  defp init_map_line_empty?(tag, fields, negs) do
+    Enum.any?(Map.to_list(fields), fn {_key, type} -> empty?(type) end) or
+      map_line_empty?(tag, fields, negs)
+  end
+
+  # These positives get checked once when calling init_map_line_empty?, and then every time
+  # an intersection or difference is computed, its emptiness is checked again.
+  # So they are all necessarily non-empty.
+  defp map_line_empty?(_, _pos, []), do: false
+  defp map_line_empty?(_, _, [{:open, neg_fields} | _]) when neg_fields == %{}, do: true
+  defp map_line_empty?(:open, fs, [{:closed, _} | negs]), do: map_line_empty?(:open, fs, negs)
+
+  defp map_line_empty?(tag, fields, [{neg_tag, neg_fields} | negs]) do
+    if map_check_domain_keys(tag, neg_tag) do
+      atom_default = map_key_tag_to_type(tag)
+      neg_atom_default = map_key_tag_to_type(neg_tag)
+
+      Enum.all?(Map.to_list(neg_fields), fn {neg_key, neg_type} ->
+        cond do
+          # Ignore keys present in both maps; will be handled below
+          is_map_key(fields, neg_key) ->
+            true
+
+          # The keys is only in the negative map, and the positive map is closed
+          # in that case, this field is not_set(), and its difference with the
+          # negative map type is empty iff the negative type is optional.
+          tag == :closed ->
+            is_optional_static(neg_type) or throw(:closed)
+
+          # There may be value in common
+          tag == :open ->
+            diff = difference(term_or_optional(), neg_type)
+            empty?(diff) or map_line_empty?(tag, Map.put(fields, neg_key, diff), negs)
+
+          true ->
+            diff = difference(atom_default, neg_type)
+            empty?(diff) or map_line_empty?(tag, Map.put(fields, neg_key, diff), negs)
+        end
+      end) and
+        Enum.all?(Map.to_list(fields), fn {key, type} ->
+          case neg_fields do
+            %{^key => neg_type} ->
+              diff = difference(type, neg_type)
+              empty?(diff) or map_line_empty?(tag, Map.put(fields, key, diff), negs)
+
+            %{} ->
+              cond do
+                # The key is only in the positive map, while the negative map is open
+                # so this key is absorbed (e.g. %{a: integer} and not %{...})
+                neg_tag == :open ->
+                  true
+
+                neg_tag == :closed and not is_optional_static(type) ->
+                  throw(:closed)
+
+                true ->
+                  # an absent key in a open negative map can be ignored
+                  diff = difference(type, neg_atom_default)
+                  empty?(diff) or map_line_empty?(tag, Map.put(fields, key, diff), negs)
+              end
+          end
+        end)
+    else
+      map_line_empty?(tag, fields, negs)
+    end
+  catch
+    :closed -> map_line_empty?(tag, fields, negs)
+  end
+
+  # Verify the domain condition from equation (22) in paper ICFP'23 https://www.irif.fr/~gc/papers/icfp23.pdf
+  # which is that every domain key type in the positive map is a subtype
+  # of the corresponding domain key type in the negative map.
+  defp map_check_domain_keys(:closed, _), do: true
+  defp map_check_domain_keys(_, :open), do: true
+
+  # An open map is a subtype iff the negative domains are all present as term_or_optional()
+  defp map_check_domain_keys(:open, neg_domains) do
+    map_size(neg_domains) == length(@domain_key_types) and
+      Enum.all?(neg_domains, fn {_domain_key, type} -> subtype?(term_or_optional(), type) end)
+  end
+
+  # A positive domains is smaller than a closed map iff all its keys are empty or optional
+  defp map_check_domain_keys(pos_domains, :closed) do
+    Enum.all?(pos_domains, fn {_domain_key, type} -> empty_or_optional?(type) end)
+  end
+
+  # Component-wise comparison of domains
+  defp map_check_domain_keys(pos_domains, neg_domains) do
+    Enum.all?(pos_domains, fn {domain_key, type} ->
+      subtype?(type, Map.get(neg_domains, domain_key, not_set()))
+    end)
+  end
+
+  defp map_pop_key(tag, fields, key) do
+    case :maps.take(key, fields) do
+      {value, fields} -> {value, %{map: map_new(tag, fields)}}
+      :error -> {map_key_tag_to_type(tag), %{map: map_new(tag, fields)}}
+    end
+  end
+
+  # Pop a domain type, e.g. popping integers from %{integer() => binary()}
+  # returns {if_set(binary()), %{integer() => if_set(binary()}}
+  # If the domain is not present, use the tag to type as default.
+  defp map_pop_domain(domains = %{}, fields, domain_key) do
+    case :maps.take(domain_key, domains) do
+      {value, domains} -> {if_set(value), %{map: map_new(domains, fields)}}
+      :error -> {map_key_tag_to_type(domains), %{map: map_new(domains, fields)}}
+    end
+  end
+
+  # Open/close key
+  defp map_pop_domain(tag, fields, _domain_key),
+    do: {map_key_tag_to_type(tag), %{map: map_new(tag, fields)}}
+
+  defp map_split_negative_key(negs, key) do
+    Enum.reduce_while(negs, [], fn
+      # A negation with an open map means the whole thing is empty.
+      {:open, fields}, _acc when map_size(fields) == 0 -> {:halt, :empty}
+      {tag, fields}, neg_acc -> {:cont, [map_pop_key(tag, fields, key) | neg_acc]}
+    end)
+  end
+
+  defp map_split_negative_domain(negs, domain_key) do
+    Enum.reduce_while(negs, [], fn
+      {:open, fields}, _acc when map_size(fields) == 0 -> {:halt, :empty}
+      {tag, fields}, neg_acc -> {:cont, [map_pop_domain(tag, fields, domain_key) | neg_acc]}
+    end)
+  end
+
+  # Use heuristics to normalize a map bdd for pretty printing.
+  defp map_normalize(bdd) do
+    map_bdd_to_dnf(bdd)
+    |> Enum.map(fn {tag, fields, negs} ->
+      map_eliminate_while_negs_decrease(tag, fields, negs)
+    end)
+    |> map_fusion()
+  end
+
+  # Continue to eliminate negations while length of list of negs decreases
+  defp map_eliminate_while_negs_decrease(tag, fields, []), do: {tag, fields, []}
+
+  defp map_eliminate_while_negs_decrease(tag, fields, negs) do
+    n = length(negs)
+    {fields, negs} = maybe_eliminate_map_negations(tag, fields, negs)
+
+    if length(negs) < n do
+      map_eliminate_while_negs_decrease(tag, fields, negs)
+    else
+      {tag, fields, negs}
+    end
+  end
+
+  defp maybe_eliminate_map_negations(tag, fields, negs) do
+    Enum.reduce(negs, {fields, []}, fn neg = {neg_tag, neg_fields}, {acc_fields, acc_negs} ->
+      # If the intersection with the negative is empty, we can remove the negative.
+      empty_intersection? =
+        try do
+          _ = map_literal_intersection(tag, acc_fields, neg_tag, neg_fields)
+          false
+        catch
+          :empty -> true
+        end
+
+      if empty_intersection? do
+        {acc_fields, acc_negs}
+      else
+        case map_all_but_one(tag, acc_fields, neg_tag, neg_fields) do
+          {:one, diff_key} ->
+            {Map.update!(acc_fields, diff_key, &difference(&1, neg_fields[diff_key])), acc_negs}
+
+          _ ->
+            {acc_fields, [neg | acc_negs]}
+        end
+      end
+    end)
+  end
+
+  # Given a dnf, fuse maps when possible
+  # e.g. %{a: integer(), b: atom()} or %{a: float(), b: atom()} into %{a: number(), b: atom()}
+  defp map_fusion(dnf) do
+    # Steps:
+    # 1. Group maps by tags and keys
+    # 2. Try fusions for each group until no fusion is found
+    # 3. Merge the groups back into a dnf
+    {without_negs, with_negs} = Enum.split_with(dnf, fn {_tag, _fields, negs} -> negs == [] end)
+
+    without_negs =
+      without_negs
+      |> Enum.group_by(fn {tag, fields, _} -> {tag, Map.keys(fields)} end)
+      |> Enum.flat_map(fn {_, maps} -> map_non_negated_fuse(maps) end)
+
+    without_negs ++ with_negs
+  end
+
+  defp map_non_negated_fuse(maps) do
+    Enum.reduce(maps, [], fn map, acc ->
+      map_fuse_with_first_fusible(map, acc)
+    end)
+  end
+
+  defp map_fuse_with_first_fusible(map, []), do: [map]
+
+  defp map_fuse_with_first_fusible(map, [candidate | rest]) do
+    case maybe_optimize_map_union(map, candidate) do
+      nil -> [candidate | map_fuse_with_first_fusible(map, rest)]
+      # we found a fusible candidate, we're done
+      fused -> [fused | rest]
+    end
+  end
+
+  # If all fields are the same except one, we can optimize map difference.
+  defp map_all_but_one(tag1, fields1, tag2, fields2) do
+    with true <- {tag1, tag2} != {:open, :closed},
+         true <- map_size(fields1) == map_size(fields2),
+         keys = :maps.keys(fields1),
+         true <- Enum.all?(keys, fn key -> is_map_key(fields2, key) end),
+         1 <-
+           Enum.count_until(
+             keys,
+             fn key -> Map.fetch!(fields1, key) != Map.fetch!(fields2, key) end,
+             _limit = 2
+           ) do
+      {:one, Enum.find(keys, &(Map.fetch!(fields1, &1) != Map.fetch!(fields2, &1)))}
+    else
+      _ -> :no
+    end
+  end
+
+  defp map_to_quoted(bdd, opts) do
+    map_normalize(bdd)
+    |> Enum.map(&map_each_to_quoted(&1, opts))
+  end
+
+  defp map_each_to_quoted({tag, positive_map, negative_maps}, opts) do
+    case negative_maps do
+      [] ->
+        map_literal_to_quoted({tag, positive_map}, opts)
+
+      _ ->
+        negative_maps
+        |> non_empty_map_or(&map_literal_to_quoted(&1, opts))
+        |> Kernel.then(
+          &{:and, [], [map_literal_to_quoted({tag, positive_map}, opts), {:not, [], [&1]}]}
+        )
+    end
+  end
+
+  def map_literal_to_quoted({:closed, fields}, _opts) when map_size(fields) == 0 do
+    {:empty_map, [], []}
+  end
+
+  def map_literal_to_quoted({:open, fields}, _opts) when map_size(fields) == 0 do
+    {:map, [], []}
+  end
+
+  def map_literal_to_quoted({domains = %{}, fields}, _opts)
+      when map_size(domains) == 0 and map_size(fields) == 0 do
+    {:empty_map, [], []}
+  end
+
+  def map_literal_to_quoted({:open, %{__struct__: @not_atom_or_optional} = fields}, _opts)
+      when map_size(fields) == 1 do
+    {:non_struct_map, [], []}
+  end
+
+  def map_literal_to_quoted({domains = %{}, fields}, opts) do
+    domain_fields =
+      for {domain_key, value_type} <- domains do
+        non_optional = remove_optional_static(value_type)
+
+        value_quoted =
+          if empty?(non_optional) do
+            {:not_set, [], []}
+          else
+            map_value_to_quoted(non_optional, opts)
+          end
+
+        {{domain_key, [], []}, value_quoted}
+      end
+
+    regular_fields_quoted = map_fields_to_quoted(:closed, Enum.sort(fields), opts)
+    {:%{}, [], domain_fields ++ regular_fields_quoted}
+  end
+
+  def map_literal_to_quoted({tag, fields}, opts) do
+    case tag do
+      :closed ->
+        with %{__struct__: struct_descr} <- fields,
+             {:finite, [struct]} <- atom_fetch(struct_descr),
+             info when is_list(info) <- maybe_struct(struct),
+             true <- map_size(fields) == length(info) + 1,
+             true <- Enum.all?(info, &is_map_key(fields, &1.field)) do
+          collapse? = Keyword.get(opts, :collapse_structs, true)
+
+          fields =
+            for %{field: field} <- info,
+                type = Map.fetch!(fields, field),
+                # TODO: This should consider the struct default type
+                not collapse? or type != term(),
+                do: {field, type}
+
+          {:%, [],
+           [
+             literal_to_quoted(struct),
+             {:%{}, [], map_fields_to_quoted(tag, fields, opts)}
+           ]}
+        else
+          _ ->
+            {:%{}, [], map_fields_to_quoted(tag, Enum.sort(fields), opts)}
+        end
+
+      :open ->
+        fields = Map.to_list(fields)
+        {:%{}, [], [{:..., [], nil} | map_fields_to_quoted(tag, Enum.sort(fields), opts)]}
+    end
+  end
+
+  defp maybe_struct(struct) do
+    try do
+      struct.__info__(:struct)
+    rescue
+      _ -> nil
+    end
+  end
+
+  defp map_fields_to_quoted(tag, sorted, opts) do
+    keyword? = Inspect.List.keyword?(sorted)
+
+    for {key, type} <- sorted,
+        not (tag == :open and is_optional_static(type) and term_type?(type)) do
+      key =
+        if keyword? do
+          {:__block__, [format: :keyword], [key]}
+        else
+          literal_to_quoted(key)
+        end
+
+      {key, map_value_to_quoted(type, opts)}
+    end
+  end
+
+  defp map_value_to_quoted(type, opts) do
+    {optional?, type} = pop_optional_static(type)
+
+    cond do
+      not optional? -> to_quoted(type, opts)
+      empty?(type) -> {:not_set, [], []}
+      true -> {:if_set, [], [to_quoted(type, opts)]}
+    end
+  end
+
+  ## Tuple
+
+  # Represents tuple types as a BDD with nodes of the following forms:
+  # 1. Closed tuples: Fixed-length tuples with specific element types
+  #    Example: {integer(), atom()}
+  # 2. Open tuples: Variable-length tuples with a minimum set of element types
+  #    Example: {atom(), boolean(), ...}
+  #
+  # Internal representation:
+  # - Closed tuple: {:closed, [element_type, ...]}
+  # - Open tuple:   {:open, [element_type, ...]}
+  #
+  # Examples:
+  # - {integer(), atom()} is encoded as {:closed, [integer(), atom()]}
+  # - {atom(), boolean(), ...} is encoded as {:open, [atom(), boolean()]}
+
+  defp tuple_descr(tag, fields) do
+    case tuple_descr(fields, [], false) do
+      :empty -> %{}
+      {fields, true} -> %{dynamic: %{tuple: tuple_new(tag, Enum.reverse(fields))}}
+      {_, false} -> %{tuple: tuple_new(tag, fields)}
+    end
+  end
+
+  defp tuple_descr([:term | rest], acc, dynamic?) do
+    tuple_descr(rest, [:term | acc], dynamic?)
+  end
+
+  defp tuple_descr([value | rest], acc, dynamic?) do
+    # Check if the static part is empty
+    static_empty? =
+      case value do
+        # Has dynamic component, check static separately
+        %{dynamic: _} -> false
+        _ -> empty?(value)
+      end
+
+    if static_empty? do
+      :empty
+    else
+      case :maps.take(:dynamic, value) do
+        :error ->
+          tuple_descr(rest, [value | acc], dynamic?)
+
+        {dynamic, _static} ->
+          # Check if dynamic component is empty
+          if empty?(dynamic) do
+            :empty
+          else
+            tuple_descr(rest, [dynamic | acc], true)
+          end
+      end
+    end
+  end
+
+  defp tuple_descr([], acc, dynamic?) do
+    {acc, dynamic?}
+  end
+
+  defp tuple_new(tag, elements), do: bdd_leaf(tag, elements)
+
+  defp tuple_intersection(bdd_leaf(tag1, elements1), bdd_leaf(tag2, elements2)) do
+    case tuple_literal_intersection(tag1, elements1, tag2, elements2) do
+      {tag, elements} -> bdd_leaf(tag, elements)
+      :empty -> :bdd_bot
+    end
+  end
+
+  defp tuple_intersection(bdd1, bdd2), do: bdd_intersection(bdd1, bdd2)
+
+  defp tuple_literal_intersection(:open, [], tag, elements), do: {tag, elements}
+
+  defp tuple_literal_intersection(tag1, elements1, tag2, elements2) do
+    n = length(elements1)
+    m = length(elements2)
+
+    if (tag1 == :closed and n < m) or (tag2 == :closed and n > m) do
+      :empty
+    else
+      try do
+        zip_non_empty_intersection!(elements1, elements2, [])
+      catch
+        :empty -> :empty
+      else
+        elements when tag1 == :open and tag2 == :open -> {:open, elements}
+        elements -> {:closed, elements}
+      end
+    end
+  end
+
+  # Intersects two lists of types, and _appends_ the extra elements to the result.
+  defp zip_non_empty_intersection!([], types2, acc), do: Enum.reverse(acc, types2)
+  defp zip_non_empty_intersection!(types1, [], acc), do: Enum.reverse(acc, types1)
+
+  defp zip_non_empty_intersection!([type1 | rest1], [type2 | rest2], acc) do
+    zip_non_empty_intersection!(rest1, rest2, [non_empty_intersection!(type1, type2) | acc])
+  end
+
+  defp zip_empty_intersection?([], _types2), do: false
+  defp zip_empty_intersection?(_types1, []), do: false
+
+  defp zip_empty_intersection?([type1 | rest1], [type2 | rest2]) do
+    case empty?(intersection(type1, type2)) do
+      true -> true
+      false -> zip_empty_intersection?(rest1, rest2)
+    end
+  end
+
+  defp tuple_difference(bdd1, bdd2), do: bdd_difference(bdd1, bdd2)
+
+  defp non_empty_tuple_literals_intersection(tuples) do
+    try do
+      Enum.reduce(tuples, {:open, []}, fn {next_tag, next_elements}, {tag, elements} ->
+        case tuple_literal_intersection(tag, elements, next_tag, next_elements) do
+          :empty -> throw(:empty)
+          next -> next
+        end
+      end)
+    catch
+      :empty -> :empty
+    end
+  end
+
+  defp tuple_empty?(bdd) do
+    bdd_to_dnf(bdd)
+    |> Enum.all?(fn {pos, negs} ->
+      case non_empty_tuple_literals_intersection(pos) do
+        :empty -> true
+        {tag, fields} -> tuple_line_empty?(tag, fields, negs)
+      end
+    end)
+  end
+
+  # No negations, so not empty unless there's an empty type
+  # Note: since the extraction from the BDD is done in a way that guarantees that
+  # the elements are non-empty, we can avoid checking for empty types there.
+  # Otherwise, tuple_empty?(_, elements, []) would be Enum.any?(elements, &empty?/1)
+  defp tuple_line_empty?(_, _, []), do: false
+  # Open empty negation makes it empty
+  defp tuple_line_empty?(_, _, [{:open, []} | _]), do: true
+  # Open positive can't be emptied by a single closed negative
+  defp tuple_line_empty?(:open, _pos, [{:closed, _}]), do: false
+
+  defp tuple_line_empty?(tag, elements, [{neg_tag, neg_elements} | negs]) do
+    n = length(elements)
+    m = length(neg_elements)
+
+    # Scenarios where the difference is guaranteed to be empty:
+    # 1. When removing larger tuples from a fixed-size positive tuple
+    # 2. When removing smaller tuples from larger tuples
+    if (tag == :closed and n < m) or (neg_tag == :closed and n > m) do
+      tuple_line_empty?(tag, elements, negs)
+    else
+      tuple_elements_empty?([], tag, elements, neg_elements, negs) and
+        tuple_empty_arity?(n, m, tag, elements, neg_tag, negs)
+    end
+  end
+
+  # Recursively check elements for emptiness
+  defp tuple_elements_empty?(_, _, _, [], _), do: true
+
+  defp tuple_elements_empty?(acc_meet, tag, elements, [neg_type | neg_elements], negs) do
+    # Handles the case where {tag, elements} is an open tuple, like {:open, []}
+    {ty, elements} = List.pop_at(elements, 0, term())
+    diff = difference(ty, neg_type)
+    meet = intersection(ty, neg_type)
+
+    # In this case, there is no intersection between the positive and this negative.
+    # So we should just "go next"
+    (empty?(diff) or tuple_line_empty?(tag, Enum.reverse(acc_meet, [diff | elements]), negs)) and
+      (empty?(meet) or tuple_elements_empty?([meet | acc_meet], tag, elements, neg_elements, negs))
+  end
+
+  # Determines if the set difference is empty when:
+  # - Positive tuple: {tag, elements} of size n
+  # - Negative tuple: open or closed tuples of size m
+  defp tuple_empty_arity?(n, m, tag, elements, neg_tag, negs) do
+    # The tuples to consider are all those of size n to m - 1, and if the negative tuple is
+    # closed, we also need to consider tuples of size greater than m + 1.
+    tag == :closed or
+      (Enum.all?(n..(m - 1)//1, &tuple_line_empty?(:closed, tuple_fill(elements, &1), negs)) and
+         (neg_tag == :open or tuple_line_empty?(:open, tuple_fill(elements, m + 1), negs)))
+  end
+
+  defp tuple_eliminate_negations(tag, elements, negs) do
+    Enum.reduce(negs, [{tag, elements}], fn {neg_tag, neg_elements}, acc ->
+      Enum.flat_map(acc, fn {tag, elements} ->
+        tuple_eliminate_single_negation(tag, elements, {neg_tag, neg_elements})
+      end)
+    end)
+  end
+
+  # Important: this generates DISJOINT tuples.
+  defp tuple_eliminate_single_negation(tag, elements, {neg_tag, neg_elements}) do
+    n = length(elements)
+    m = length(neg_elements)
+
+    # Scenarios where the difference is guaranteed to be empty:
+    # 1. When removing larger tuples from a fixed-size positive tuple
+    # 2. When removing smaller tuples from larger tuples
+    # 3. When there is no intersection between the elements of the two tuples
+    if (tag == :closed and n < m) or (neg_tag == :closed and n > m) or
+         zip_empty_intersection?(elements, neg_elements) do
+      [{tag, elements}]
+    else
+      tuple_dnf_union(
+        tuple_elim_content([], tag, elements, neg_elements),
+        tuple_elim_size(n, m, tag, elements, neg_tag)
+      )
+    end
+  end
+
+  # Build a disjoint disjunction for {t1,...,tn} /\ not {u1,...,un}
+  # by splitting on the *earliest* index where they differ.
+  #
+  # Invariant:
+  # - `acc` holds the prefix we've already forced to *match* the negative tuple,
+  #   stored in reverse order (so we can `Enum.reverse/2` at the end when we emit).
+  # - `elements` are the yet-unprocessed positive tuple element types.
+  # - `neg_elements` are the corresponding negative tuple element types.
+  #
+  # For position i:
+  #   - One branch mismatches here:  (ti \ ui), with earlier positions fixed to intersection(tj, uj).
+  #   - The other recursive path forces match here: intersection(ti, ui) and continues to i+1.
+  #
+  # This yields disjoint branches like:
+  #   {t1 /\ not u1, t2, t3, ...} OR {t1 /\ u1, t2 /\ not u2, t3, ...} OR {t1/\u1, t2/\u2, t3/\ not u3, ...} ...
+  defp tuple_elim_content(acc, tag, elements, [neg_type | neg_elements]) do
+    # If `elements` is shorter, default to top type `term()` (as in your example).
+    {ty, rest} = List.pop_at(elements, 0, term())
+
+    # ti \ ui  (i.e., ti and not ui)
+    diff = difference(ty, neg_type)
+    # ti /\ ui
+    meet = intersection(ty, neg_type)
+
+    # Branch where the earliest difference is *here*.
+    # Earlier positions are the accumulated matches in `acc`;
+    # later positions remain unconstrained (`rest` as-is).
+    here_branch =
+      if empty?(diff) do
+        []
+      else
+        [{tag, Enum.reverse(acc, [diff | rest])}]
+      end
+
+    # Branches where we force equality here and defer the first difference to later positions.
+    later_branches =
+      if empty?(meet) do
+        []
+      else
+        tuple_elim_content([meet | acc], tag, rest, neg_elements)
+      end
+
+    here_branch ++ later_branches
+  end
+
+  # No more negative elements to process: there is no "all-equal" branch to add,
+  # because we're constructing {t} ant not {u}, which must differ somewhere.
+  defp tuple_elim_content(_acc, _tag, _elements, []) do
+    []
+  end
+
+  # Eliminates negations according to size
+  # Example: {integer(), ...} and not {term(), term(), ...} contains {integer()}
+  # The tuples to consider are all those of size n to m - 1, and if the negative tuple is
+  # closed, we also need to consider tuples of size greater than m + 1.
+  defp tuple_elim_size(_, _, :closed, _, _), do: []
+
+  defp tuple_elim_size(n, m, :open, elements, neg_tag) do
+    n..(m - 1)//1
+    |> Enum.reduce([], fn i, acc ->
+      [{:closed, tuple_fill(elements, i)} | acc]
+    end)
+    |> Kernel.++(
+      if neg_tag == :open do
+        []
+      else
+        [{:open, tuple_fill(elements, m + 1)}]
+      end
+    )
+  end
+
+  defp tuple_dnf_union(dnf1, dnf2) do
+    # Union of tuple DNFs is just concatenation, but we rely on some optimization strategies to
+    # avoid the list to grow when possible
+
+    # first pass trying to identify patterns where two maps can be fused as one
+    with [tuple1] <- dnf1,
+         [tuple2] <- dnf2,
+         optimized when optimized != nil <- maybe_optimize_tuple_union(tuple1, tuple2) do
+      [optimized]
+    else
+      # otherwise we just concatenate and remove structural duplicates
+      _ -> dnf1 ++ (dnf2 -- dnf1)
+    end
+  end
+
+  defp tuple_union(
+         bdd_leaf(tag1, elements1) = tuple1,
+         bdd_leaf(tag2, elements2) = tuple2
+       ) do
+    case maybe_optimize_tuple_union({tag1, elements1}, {tag2, elements2}) do
+      {tag, elements} -> bdd_leaf(tag, elements)
+      nil -> bdd_union(tuple1, tuple2)
+    end
+  end
+
+  @compile {:inline, tuple_union: 2}
+  defp tuple_union(bdd1, bdd2), do: bdd_union(bdd1, bdd2)
+
+  defp maybe_optimize_tuple_union({tag1, pos1} = tuple1, {tag2, pos2} = tuple2) do
+    case tuple_union_optimization_strategy(tag1, pos1, tag2, pos2) do
+      :all_equal ->
+        tuple1
+
+      {:one_index_difference, index, v1, v2} ->
+        new_pos = List.replace_at(pos1, index, union(v1, v2))
+        {tag1, new_pos}
+
+      :left_subtype_of_right ->
+        tuple2
+
+      :right_subtype_of_left ->
+        tuple1
+
+      nil ->
+        nil
+    end
+  end
+
+  defp maybe_optimize_tuple_union(_, _), do: nil
+
+  defp tuple_union_optimization_strategy(tag1, pos1, tag2, pos2)
+  defp tuple_union_optimization_strategy(tag, pos, tag, pos), do: :all_equal
+
+  # might be one extra loop but cheap and avoids doing deep subtype comparisons
+  defp tuple_union_optimization_strategy(:closed, pos1, :closed, pos2)
+       when length(pos1) != length(pos2),
+       do: nil
+
+  defp tuple_union_optimization_strategy(tag1, pos1, tag2, pos2) do
+    status =
+      case {tag1, tag2} do
+        {:open, :closed} -> :right_subtype_of_left
+        {:closed, :open} -> :left_subtype_of_right
+        {same, same} -> :all_equal
+      end
+
+    do_tuple_union_optimization_strategy(tag1, pos1, tag2, pos2, 0, status)
+  end
+
+  defp do_tuple_union_optimization_strategy(_tag1, [], _tag2, [], _i, status), do: status
+
+  defp do_tuple_union_optimization_strategy(:open, [], _tag2, _pos2, _i, status)
+       when status in [:all_equal, :right_subtype_of_left],
+       do: :right_subtype_of_left
+
+  defp do_tuple_union_optimization_strategy(_tag1, _pos1, :open, [], _i, status)
+       when status in [:all_equal, :left_subtype_of_right],
+       do: :left_subtype_of_right
+
+  defp do_tuple_union_optimization_strategy(tag1, [v1 | pos1], tag2, [v2 | pos2], i, status) do
+    if next_status = tuple_union_next_strategy(i, v1, v2, status) do
+      do_tuple_union_optimization_strategy(tag1, pos1, tag2, pos2, i + 1, next_status)
+    end
+  end
+
+  defp do_tuple_union_optimization_strategy(_tag1, _pos1, _tag2, _pos2, _i, _status), do: nil
+
+  defp tuple_union_next_strategy(index, v1, v2, status)
+
+  # structurally equal values do not impact the ongoing strategy
+  defp tuple_union_next_strategy(_index, same, same, status), do: status
+
+  defp tuple_union_next_strategy(index, v1, v2, :all_equal) do
+    {:one_index_difference, index, v1, v2}
+  end
+
+  defp tuple_union_next_strategy(_index, v1, v2, {:one_index_difference, _, d1, d2}) do
+    # we have at least two differences now, we switch strategy
+    # if both are subtypes in one direction, keep checking
+    cond do
+      subtype?(d1, d2) and subtype?(v1, v2) -> :left_subtype_of_right
+      subtype?(d2, d1) and subtype?(v2, v1) -> :right_subtype_of_left
+      true -> nil
+    end
+  end
+
+  defp tuple_union_next_strategy(_index, v1, v2, :left_subtype_of_right) do
+    if subtype?(v1, v2), do: :left_subtype_of_right
+  end
+
+  defp tuple_union_next_strategy(_index, v1, v2, :right_subtype_of_left) do
+    if subtype?(v2, v1), do: :right_subtype_of_left
+  end
+
+  defp tuple_to_quoted(bdd, opts) do
+    tuple_normalize(bdd)
+    |> tuple_fusion()
+    |> Enum.map(&tuple_literal_to_quoted(&1, opts))
+  end
+
+  # Transforms a bdd into a union of tuples with no negations.
+  # Note: it is important to compose the results with tuple_dnf_union/2 to avoid duplicates
+  defp tuple_normalize(bdd) do
+    bdd_to_dnf(bdd)
+    |> Enum.reduce([], fn {positive_tuples, negative_tuples}, acc ->
+      case non_empty_tuple_literals_intersection(positive_tuples) do
+        :empty ->
+          acc
+
+        {tag, elements} ->
+          if tuple_line_empty?(tag, elements, negative_tuples) do
+            acc
+          else
+            tuple_eliminate_negations(tag, elements, negative_tuples) |> tuple_dnf_union(acc)
+          end
+      end
+    end)
+  end
+
+  # Given a union of tuples, fuses the tuple unions when possible,
+  # e.g. {integer(), atom()} or {float(), atom()} into {number(), atom()}
+  # The negations of two fused tuples are just concatenated.
+  defp tuple_fusion(dnf_no_negations) do
+    # Steps:
+    # 1. Consider tuples without negations apart from those with
+    # 2. Group tuples by size and tag
+    # 3. Try fusions for each group until no fusion is found
+    # 4. Merge the groups back into a dnf
+    dnf_no_negations
+    |> Enum.group_by(fn {tag, elems} -> {tag, length(elems)} end)
+    |> Enum.flat_map(fn {_, tuples} -> tuple_non_negated_fuse(tuples) end)
+  end
+
+  defp tuple_non_negated_fuse(tuples) do
+    Enum.reduce(tuples, [], fn tuple, acc ->
+      tuple_fuse_with_first_fusible(tuple, acc)
+    end)
+  end
+
+  defp tuple_fuse_with_first_fusible(tuple, []), do: [tuple]
+
+  defp tuple_fuse_with_first_fusible(tuple, [candidate | rest]) do
+    if fused = maybe_optimize_tuple_union(tuple, candidate) do
+      # we found a fusible candidate, we're done
+      [fused | rest]
+    else
+      [candidate | tuple_fuse_with_first_fusible(tuple, rest)]
+    end
+  end
+
+  defp tuple_literal_to_quoted({:closed, []}, _opts), do: {:{}, [], []}
+
+  defp tuple_literal_to_quoted({tag, elements}, opts) do
+    case tag do
+      :closed -> {:{}, [], Enum.map(elements, &to_quoted(&1, opts))}
+      :open -> {:{}, [], Enum.map(elements, &to_quoted(&1, opts)) ++ [{:..., [], nil}]}
+    end
+  end
+
+  # Pads a list of elements with term().
+  defp tuple_fill(elements, desired_length) do
+    pad_length = desired_length - length(elements)
+
+    if pad_length < 0 do
+      raise ArgumentError, "tuple_fill: elements are longer than the desired length"
+    else
+      elements ++ List.duplicate(term(), pad_length)
+    end
+  end
+
+  @doc """
+  Fetches the type of the value returned by accessing `index` on `tuple`
+  with the assumption that the descr is exclusively a tuple (or dynamic).
+
+  Returns one of:
+
+  - `{false, type}` if the element is always accessible and has the given `type`.
+  - `{true, type}` if the element is dynamically optional and has the given `type`.
+  - `:badindex` if the index is never accessible in the tuple type.
+  - `:badtuple` if the descr is not a tuple type.
+
+  ## Examples
+
+      iex> tuple_fetch(tuple([integer(), atom()]), 0)
+      {false, integer()}
+
+      iex> tuple_fetch(union(tuple([integer()]), tuple([integer(), atom()])), 1)
+      {true, atom()}
+
+      iex> tuple_fetch(dynamic(), 0)
+      {true, dynamic()}
+
+      iex> tuple_fetch(integer(), 0)
+      :badtuple
+
+  """
+  def tuple_fetch(_, index) when index < 0, do: :badindex
+  def tuple_fetch(:term, _key), do: :badtuple
+
+  def tuple_fetch(%{} = descr, key) when is_integer(key) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        if descr_key?(descr, :tuple) and non_empty_tuple_only?(descr) do
+          {static_optional?, static_type} = tuple_fetch_static(descr, key)
+
+          # If I access a static tuple at a "open position", we have two options:
+          #
+          # 1. Do not allow the access and return :badindex,
+          #    you must use dynamic for these cases (this is what we chose for maps)
+          #
+          # 2. Allow the access and return the static type
+          #
+          # The trouble with allowing the access is that it is a potential runtime
+          # error not being caught by the type system.
+          #
+          # Furthermore, our choice here, needs to be consistent with elem/put_elem
+          # when the index is the `integer()` type. If we choose to return `:badindex`,
+          # then all elem/put_elem with an `integer()` and the tuple is not dynamic
+          # should also be a static typing error. We chose to go with 1.
+          if static_optional? or empty?(static_type) do
+            :badindex
+          else
+            {false, static_type}
+          end
+        else
+          :badtuple
+        end
+
+      {dynamic, static} ->
+        if descr_key?(dynamic, :tuple) and tuple_only?(static) do
+          {dynamic_optional?, dynamic_type} = tuple_fetch_static(dynamic, key)
+          {static_optional?, static_type} = tuple_fetch_static(static, key)
+
+          if empty?(dynamic_type) do
+            :badindex
+          else
+            {static_optional? or dynamic_optional?, union(dynamic(dynamic_type), static_type)}
+          end
+        else
+          :badtuple
+        end
+    end
+  end
+
+  defp tuple_only?(descr), do: empty?(Map.delete(descr, :tuple))
+
+  defp non_empty_tuple_only?(descr) do
+    case :maps.take(:tuple, descr) do
+      :error -> false
+      {tuple_bdd, rest} -> empty?(rest) and not tuple_empty?(tuple_bdd)
+    end
+  end
+
+  defp tuple_fetch_static(descr, index) when is_integer(index) do
+    case descr do
+      :term -> {true, term()}
+      %{tuple: tuple} -> tuple_get(tuple, index) |> pop_optional_static()
+      %{} -> {false, none()}
+    end
+  end
+
+  defp tuple_get(bdd, index) do
+    tuple_normalize(bdd)
+    |> Enum.reduce(none(), fn
+      {tag, elements}, acc -> Enum.at(elements, index, tuple_tag_to_type(tag)) |> union(acc)
+    end)
+  end
+
+  @doc """
+  Returns all of the values that are part of a tuple.
+  """
+  def tuple_values(descr) when descr == %{}, do: :badtuple
+
+  def tuple_values(descr) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        if tuple_only?(descr) do
+          process_tuples_values(Map.get(descr, :tuple, :bdd_bot))
+        else
+          :badtuple
+        end
+
+      {dynamic, static} ->
+        if tuple_only?(static) and descr_key?(dynamic, :tuple) do
+          dynamic(process_tuples_values(Map.get(dynamic, :tuple, :bdd_bot)))
+          |> union(process_tuples_values(Map.get(static, :tuple, :bdd_bot)))
+        else
+          :badtuple
+        end
+    end
+  end
+
+  defp process_tuples_values(bdd) do
+    tuple_normalize(bdd)
+    |> Enum.reduce(none(), fn {tag, elements}, acc ->
+      cond do
+        Enum.any?(elements, &empty?/1) -> none()
+        tag == :open -> term()
+        tag == :closed -> Enum.reduce(elements, none(), &union/2)
+      end
+      |> union(acc)
+    end)
+  end
+
+  @doc """
+  Delete an element from the tuple.
+
+  It returns the same as `tuple_fetch/2`.
+  """
+  # Same as tuple_delete but checks if the index is out of range.
+  def tuple_delete_at(:term, _key), do: :badtuple
+
+  def tuple_delete_at(descr, index) when is_integer(index) and index >= 0 do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        # Note: the empty type is not a valid input
+        is_proper_tuple? = descr_key?(descr, :tuple) and tuple_only?(descr)
+        is_proper_size? = tuple_of_size_at_least_static?(descr, index + 1)
+
+        cond do
+          is_proper_tuple? and is_proper_size? -> tuple_delete_static(descr, index)
+          is_proper_tuple? -> :badindex
+          true -> :badtuple
+        end
+
+      {dynamic, static} ->
+        is_proper_tuple? = descr_key?(dynamic, :tuple) and tuple_only?(static)
+        is_proper_size? = tuple_of_size_at_least_static?(static, index + 1)
+
+        cond do
+          is_proper_tuple? and is_proper_size? ->
+            static_result = tuple_delete_static(static, index)
+
+            # Prune for dynamic values make the intersection succeed
+            dynamic_result =
+              intersection(dynamic, tuple_of_size_at_least(index))
+              |> tuple_delete_static(index)
+
+            union(dynamic(dynamic_result), static_result)
+
+          # Highlight the case where the issue is an index out of range from the tuple
+          is_proper_tuple? ->
+            :badindex
+
+          true ->
+            :badtuple
+        end
+    end
+  end
+
+  def tuple_delete_at(_, _), do: :badindex
+
+  # Takes a static map type and removes an index from it.
+  defp tuple_delete_static(%{tuple: bdd}, index) do
+    %{tuple: bdd_map(bdd, fn {tag, elements} -> {tag, List.delete_at(elements, index)} end)}
+  end
+
+  # If there is no map part to this static type, there is nothing to delete.
+  defp tuple_delete_static(_type, _key), do: none()
+
+  @doc """
+  Insert an element at the tuple.
+
+  It returns the same as `tuple_fetch/2`. Notice, however, the range for indexes is inclusive.
+  """
+  def tuple_insert_at(:term, _key, _type), do: :badtuple
+
+  def tuple_insert_at(descr, index, type) when is_integer(index) and index >= 0 do
+    case :maps.take(:dynamic, unfold(type)) do
+      :error -> tuple_insert_at_checked(descr, index, type)
+      {dynamic, _static} -> dynamic(tuple_insert_at_checked(descr, index, dynamic))
+    end
+  end
+
+  def tuple_insert_at(_, _, _), do: :badindex
+
+  defp tuple_insert_at_checked(descr, index, type) do
+    case :maps.take(:dynamic, descr) do
+      :error ->
+        # Note: the empty type is not a valid input
+        is_proper_tuple? = descr_key?(descr, :tuple) and tuple_only?(descr)
+        is_proper_size? = index == 0 or tuple_of_size_at_least_static?(descr, index)
+
+        cond do
+          is_proper_tuple? and is_proper_size? -> tuple_insert_static(descr, index, type)
+          is_proper_tuple? -> :badindex
+          true -> :badtuple
+        end
+
+      {dynamic, static} ->
+        is_proper_tuple? = descr_key?(dynamic, :tuple) and tuple_only?(static)
+        is_proper_size? = index == 0 or tuple_of_size_at_least_static?(static, index)
+
+        cond do
+          is_proper_tuple? and is_proper_size? ->
+            static_result = tuple_insert_static(static, index, type)
+
+            # Prune for dynamic values that make the intersection succeed
+            dynamic_result =
+              intersection(dynamic, tuple_of_size_at_least(index))
+              |> tuple_insert_static(index, type)
+
+            union(dynamic(dynamic_result), static_result)
+
+          # Highlight the case where the issue is an index out of range from the tuple
+          is_proper_tuple? ->
+            :badindex
+
+          true ->
+            :badtuple
+        end
+    end
+  end
+
+  defp tuple_insert_static(descr, _, _) when descr == @none, do: none()
+
+  defp tuple_insert_static(descr, index, type) do
+    Map.update!(descr, :tuple, fn bdd ->
+      bdd_map(bdd, fn {tag, elements} ->
+        {tag, List.insert_at(elements, index, type)}
+      end)
+    end)
+  end
+
+  defp tuple_of_size_at_least(n) when is_integer(n) and n >= 0 do
+    %{tuple: tuple_new(:open, List.duplicate(term(), n))}
+  end
+
+  defp tuple_of_size_at_least_static?(descr, index) do
+    case descr do
+      %{tuple: bdd} ->
+        tuple_normalize(bdd)
+        |> Enum.all?(fn {_, elements} -> length(elements) >= index end)
+
+      %{} ->
+        true
+    end
+  end
+
+  ## BDD helpers
+
+  def bdd_union(bdd1, bdd2) do
+    case {bdd1, bdd2} do
+      {:bdd_top, _bdd} ->
+        :bdd_top
+
+      {_bdd, :bdd_top} ->
+        :bdd_top
+
+      {:bdd_bot, bdd} ->
+        bdd
+
+      {bdd, :bdd_bot} ->
+        bdd
+
+      _ ->
+        case bdd_compare(bdd1, bdd2) do
+          {:lt, {lit1, c1, u1, d1}, bdd2} ->
+            {lit1, c1, bdd_union(u1, bdd2), d1}
+
+          {:gt, bdd1, {lit2, c2, u2, d2}} ->
+            {lit2, c2, bdd_union(bdd1, u2), d2}
+
+          {:eq, {lit, c1, u1, d1}, {_, c2, u2, d2}} ->
+            {lit, bdd_union(c1, c2), bdd_union(u1, u2), bdd_union(d1, d2)}
+
+          {:eq, {lit, _, u1, d1}, _} ->
+            {lit, :bdd_top, u1, d1}
+
+          {:eq, _, {lit, _, u2, d2}} ->
+            {lit, :bdd_top, u2, d2}
+
+          {:eq, _, _} ->
+            bdd1
+        end
+        |> case do
+          {_, :bdd_top, _, :bdd_top} -> :bdd_top
+          other -> other
+        end
+    end
+  end
+
+  def bdd_difference(bdd1, bdd2) do
+    case {bdd1, bdd2} do
+      {_bdd, :bdd_top} ->
+        :bdd_bot
+
+      {:bdd_bot, _bdd} ->
+        :bdd_bot
+
+      {bdd, :bdd_bot} ->
+        bdd
+
+      {:bdd_top, bdd} ->
+        bdd_negation(bdd)
+
+      _ ->
+        case bdd_compare(bdd1, bdd2) do
+          {:lt, {lit1, c1, u1, d1}, bdd2} ->
+            {lit1, bdd_difference(c1, bdd2), bdd_difference(u1, bdd2), bdd_difference(d1, bdd2)}
+
+          {:gt, bdd1, {lit2, c2, u2, d2}} ->
+            # The proper formula is:
+            #
+            #     b1 and not (c2 or u2) : bdd_bot : b1 and not (d2 or u2)
+            #
+            # Both extremes have (b1 and not u2),
+            # so we compute it first and only once.
+            bdd1_minus_u2 = bdd_difference(bdd1, u2)
+            {lit2, bdd_difference(bdd1_minus_u2, c2), :bdd_bot, bdd_difference(bdd1_minus_u2, d2)}
+
+          {:eq, {lit, c1, u1, d1}, {_, c2, u2, d2}} ->
+            cond do
+              c2 == :bdd_bot and d2 == :bdd_bot ->
+                {lit, bdd_difference(c1, u2), bdd_difference(u1, u2), bdd_difference(d1, u2)}
+
+              u2 == :bdd_bot ->
+                cond do
+                  d2 == :bdd_bot ->
+                    {lit, bdd_difference(c1, c2), bdd_difference(u1, c2), bdd_union(u1, d1)}
+
+                  c2 == :bdd_bot ->
+                    {lit, bdd_union(u1, c1), bdd_difference(u1, d2), bdd_difference(c1, c2)}
+
+                  true ->
+                    # If d2 or c2 are bottom, we can remove one union.
+                    #
+                    # For example, if d2 is bottom, we have this BDD:
+                    #
+                    #   {l, (C1 or U1) and not C2, U1 and not C2, D1 or U1}
+                    #
+                    # Where the constrained part is:
+                    #
+                    #   (l and (C1 or U1) and not C2)
+                    #
+                    # Which expands to:
+                    #
+                    #   (l and C1 and not C2) or (l and U1 and not C2)
+                    #
+                    # Given (U1 and not C2) is already part of the uncertain/union,
+                    # we can skip (l and U1 and not C2), and we end up with:
+                    #
+                    #   {l, C1 and not C2, U1 and not C2, D1 or U1}
+                    #
+                    # Which are the formulas used above.
+                    {lit, bdd_difference(bdd_union(u1, c1), c2),
+                     bdd_difference(bdd_difference(u1, c2), d2),
+                     bdd_difference(bdd_union(u1, d1), d2)}
+                end
+
+              u1 == :bdd_bot or u1 == u2 ->
+                {lit, bdd_difference_union(c1, c2, u2), :bdd_bot,
+                 bdd_difference_union(d1, d2, u2)}
+
+              true ->
+                {lit, bdd_difference(bdd_union(c1, u1), bdd_union(c2, u2)), :bdd_bot,
+                 bdd_difference(bdd_union(d1, u1), bdd_union(d2, u2))}
+            end
+
+          {:eq, _, {lit, c2, u2, _d2}} ->
+            {lit, bdd_negation(bdd_union(c2, u2)), :bdd_bot, :bdd_bot}
+
+          {:eq, {lit, _c1, u1, d1}, _} ->
+            {lit, :bdd_bot, :bdd_bot, bdd_union(d1, u1)}
+
+          {:eq, _, _} ->
+            :bdd_bot
+        end
+        |> case do
+          {_, :bdd_bot, u, :bdd_bot} -> u
+          other -> other
+        end
+    end
+  end
+
+  # Version of i \ (u1 v u2) that only computes the union if i is not bottom
+  defp bdd_difference_union(:bdd_bot, _u1, _u2),
+    do: :bdd_bot
+
+  defp bdd_difference_union(i, u1, u2),
+    do: bdd_difference(i, bdd_union(u1, u2))
+
+  def bdd_intersection(bdd1, bdd2) do
+    case {bdd1, bdd2} do
+      {:bdd_top, bdd} ->
+        bdd
+
+      {bdd, :bdd_top} ->
+        bdd
+
+      {:bdd_bot, _bdd} ->
+        :bdd_bot
+
+      {_, :bdd_bot} ->
+        :bdd_bot
+
+      _ ->
+        case bdd_compare(bdd1, bdd2) do
+          {:lt, {lit1, c1, u1, d1}, bdd2} ->
+            {lit1, bdd_intersection(c1, bdd2), bdd_intersection(u1, bdd2),
+             bdd_intersection(d1, bdd2)}
+
+          {:gt, bdd1, {lit2, c2, u2, d2}} ->
+            {lit2, bdd_intersection(bdd1, c2), bdd_intersection(bdd1, u2),
+             bdd_intersection(bdd1, d2)}
+
+          # Notice that (l ? c1, u1, d1) and (l ? c2, u2, d2) is, on paper, equivalent to
+          # [(l and c1) or u1 or (not l and d1)] and [(l and c2) or u2 or (not l and d2)].
+          #
+          # which is equivalent, by distributivity of intersection over union, to
+          #
+          # l and [(c1 and c2) or (c1 and u2) or (u1 and c2)]
+          #      or (u1 and u2)
+          #      or [(not l) and ((d1 and u2) or (d1 and d2) or (u1 and d2))]
+          #
+          # which is equivalent, by factoring out c1 in the first disjunct, and d1 in the third, to
+          #
+          # l and [c1 and (c2 or u2)] or (u1 and c2)
+          #     or (u1 and u2)
+          #     or (not l) and [d1 and (u2 or d2) or (u1 and d2)]
+          #
+          # This last expression gives the following implementation:
+          {:eq, {lit, c1, u1, d1}, {_, c2, u2, d2}} ->
+            {lit, bdd_union(bdd_intersection_union(c1, c2, u2), bdd_intersection(u1, c2)),
+             bdd_intersection(u1, u2),
+             bdd_union(bdd_intersection_union(d1, u2, d2), bdd_intersection(u1, d2))}
+
+          {:eq, {lit, c1, u1, _}, _} ->
+            {lit, bdd_union(c1, u1), :bdd_bot, :bdd_bot}
+
+          {:eq, _, {lit, c2, u2, _}} ->
+            {lit, bdd_union(c2, u2), :bdd_bot, :bdd_bot}
+
+          {:eq, bdd, _} ->
+            bdd
+        end
+        |> case do
+          {_, :bdd_bot, u, :bdd_bot} -> u
+          other -> other
+        end
+    end
+  end
+
+  # Version of i ^ (u1 v u2) that only computes the union if i is not bottom
+  defp bdd_intersection_union(:bdd_bot, _u1, _u2),
+    do: :bdd_bot
+
+  defp bdd_intersection_union(i, u1, u2),
+    do: bdd_intersection(i, bdd_union(u1, u2))
+
+  # Lazy negation: eliminate the union, then perform normal negation (switching leaves)
+  def bdd_negation(:bdd_top), do: :bdd_bot
+  def bdd_negation(:bdd_bot), do: :bdd_top
+  def bdd_negation({_, _} = pair), do: {pair, :bdd_bot, :bdd_bot, :bdd_top}
+
+  def bdd_negation({lit, c, u, d}) do
+    {lit, bdd_negation(bdd_union(c, u)), :bdd_bot, bdd_negation(bdd_union(d, u))}
+  end
+
+  def bdd_to_dnf(bdd), do: bdd_to_dnf([], [], [], bdd)
+
+  defp bdd_to_dnf(acc, _pos, _neg, :bdd_bot), do: acc
+  defp bdd_to_dnf(acc, pos, neg, :bdd_top), do: [{pos, neg} | acc]
+
+  defp bdd_to_dnf(acc, pos, neg, {_, _} = lit) do
+    [{[lit | pos], neg} | acc]
+  end
+
+  # Lazy node: {lit, C, U, D}  ≡  (lit ∧ C) ∪ U ∪ (¬lit ∧ D)
+  defp bdd_to_dnf(acc, pos, neg, {lit, c, u, d}) do
+    # U is a bdd in itself, we accumulate its lines first
+    bdd_to_dnf(acc, pos, neg, u)
+    # C-part
+    |> bdd_to_dnf([lit | pos], neg, c)
+    # D-part
+    |> bdd_to_dnf(pos, [lit | neg], d)
+  end
+
+  defp bdd_compare(bdd1, bdd2) do
+    case {bdd_head(bdd1), bdd_head(bdd2)} do
+      {lit1, lit2} when lit1 < lit2 -> {:lt, bdd_expand(bdd1), bdd2}
+      {lit1, lit2} when lit1 > lit2 -> {:gt, bdd1, bdd_expand(bdd2)}
+      _ -> {:eq, bdd1, bdd2}
+    end
+  end
+
+  defp bdd_map(bdd, fun) do
+    case bdd do
+      :bdd_bot ->
+        :bdd_bot
+
+      :bdd_top ->
+        :bdd_top
+
+      {_, _} ->
+        fun.(bdd)
+
+      {literal, left, union, right} ->
+        {fun.(literal), bdd_map(left, fun), bdd_map(union, fun), bdd_map(right, fun)}
+    end
+  end
+
+  defp bdd_reduce(bdd, acc, fun) do
+    case bdd do
+      :bdd_bot ->
+        acc
+
+      :bdd_top ->
+        acc
+
+      {_, _} ->
+        fun.(bdd, acc)
+
+      {literal, left, union, right} ->
+        acc = fun.(literal, acc)
+        acc = bdd_reduce(left, acc, fun)
+        acc = bdd_reduce(union, acc, fun)
+        acc = bdd_reduce(right, acc, fun)
+        acc
+    end
+  end
+
+  @compile {:inline, bdd_expand: 1, bdd_head: 1}
+  defp bdd_expand({_, _} = pair), do: {pair, :bdd_top, :bdd_bot, :bdd_bot}
+  defp bdd_expand(bdd), do: bdd
+
+  defp bdd_head({lit, _, _, _}), do: lit
+  defp bdd_head(pair), do: pair
+
+  ## Pairs
+
+  # To simplify disjunctive normal forms of e.g., map types, it is useful to
+  # convert them into disjunctive normal forms of pairs of types, and define
+  # normalization algorithms on pairs.
+  #
+  # The algorithms take a line, a list of pairs `{positive, negative}` where
+  # `positive` is a list of literals and `negative` is a list of negated literals.
+  # Positive pairs can all be intersected component-wise. Negative ones are
+  # eliminated iteratively.
+
+  # Eliminates negations from `{t, s} and not negative` where `negative` is a
+  # union of pairs disjoint on their first component.
+  #
+  # Formula:
+  #   {t, s} and not (union<i=1..n> {t_i, s_i})
+  #       = union<i=1..n> {t and t_i, s and not s_i}
+  #            or {t and not (union{i=1..n} t_i), s}
+  #
+  # This eliminates all top-level negations and produces a union of pairs that
+  # are disjoint on their first component. The function `pair_eliminate_negations_fst`
+  # is optimized to only keep the first component out of those pairs.
+  defp pair_eliminate_negations_fst(negative, t, s) do
+    {pair_union, diff_of_t_i} =
+      Enum.reduce(negative, {none(), t}, fn {t_i, s_i}, {accu, diff_of_t_i} ->
+        i = intersection(t, t_i)
+
+        if empty?(i) do
+          {accu, diff_of_t_i}
+        else
+          diff_of_t_i = difference(diff_of_t_i, t_i)
+          s_diff = difference(s, s_i)
+
+          if empty?(s_diff),
+            do: {accu, diff_of_t_i},
+            else: {union(i, accu), diff_of_t_i}
+        end
+      end)
+
+    union(pair_union, diff_of_t_i)
+  end
+
+  # The formula above is symmetric with respect to the first and second components.
+  # Hence the following also holds true:
+  #
+  #    {t, s} and not (union<i=1..n> {t_i, s_i})
+  #           = union<i=1..n> {t and not t_i, s and s_i}
+  #            or {t, s and not (union{i=1..n} s_i)}
+  #
+  # which is used to in the following function, optimized to keep the second component.
+  defp pair_eliminate_negations_snd(negative, t, s) do
+    {pair_union, diff_of_s_i} =
+      Enum.reduce(negative, {none(), s}, fn {t_i, s_i}, {accu, diff_of_s_i} ->
+        i = intersection(s, s_i)
+
+        if empty?(i) do
+          {accu, diff_of_s_i}
+        else
+          diff_of_s_i = difference(diff_of_s_i, s_i)
+          t_diff = difference(t, t_i)
+
+          if empty?(t_diff),
+            do: {accu, diff_of_s_i},
+            else: {union(i, accu), diff_of_s_i}
+        end
+      end)
+
+    union(diff_of_s_i, pair_union)
+  end
+
+  # Makes a union of pairs into an equivalent union of disjoint pairs.
+  #
+  # Inserts a pair of types {fst, snd} into a list of pairs that are disjoint
+  # on their first component. The invariant on `acc` is that its elements are
+  # two-to-two disjoint with the first argument's `pairs`.
+  #
+  # To insert {fst, snd} into a disjoint pairs list, we go through the list to find
+  # each pair whose first element has a non-empty intersection with `fst`. Then
+  # we decompose {fst, snd} over each such pair to produce disjoint ones, and add
+  # the decompositions into the accumulator.
+  defp pair_make_disjoint(pairs) do
+    Enum.reduce(pairs, [], fn {t1, t2}, acc -> add_pair_to_disjoint_list(acc, t1, t2, []) end)
+  end
+
+  defp add_pair_to_disjoint_list([], fst, snd, acc), do: [{fst, snd} | acc]
+
+  defp add_pair_to_disjoint_list([{s1, s2} | pairs], fst, snd, acc) do
+    x = intersection(fst, s1)
+
+    if empty?(x) do
+      add_pair_to_disjoint_list(pairs, fst, snd, [{s1, s2} | acc])
+    else
+      fst_diff = difference(fst, s1)
+      s1_diff = difference(s1, fst)
+      empty_fst_diff = empty?(fst_diff)
+      empty_s1_diff = empty?(s1_diff)
+
+      cond do
+        # if fst is a subtype of s1, the disjointedness invariant ensures we can
+        # add those two pairs and end the recursion
+        empty_fst_diff and empty_s1_diff ->
+          [{x, union(snd, s2)} | pairs ++ acc]
+
+        empty_fst_diff ->
+          [{s1_diff, s2}, {x, union(snd, s2)} | pairs ++ acc]
+
+        empty_s1_diff ->
+          add_pair_to_disjoint_list(pairs, fst_diff, snd, [{x, union(snd, s2)} | acc])
+
+        true ->
+          # case where, when comparing {fst, snd} and {s1, s2}, both (fst and not s1)
+          # and (s1 and not fst) are non empty. that is, there is something in fst
+          # that is not in s1, and something in s1 that is not in fst
+          add_pair_to_disjoint_list(pairs, fst_diff, snd, [
+            {s1_diff, s2},
+            {x, union(snd, s2)} | acc
+          ])
+      end
+    end
+  end
+
+  ## Map helpers
+
+  # Erlang maps:merge_with/3 has to preserve the order in combiner.
+  # We don't care about the order, so we have a faster implementation.
+  defp symmetrical_merge(left, right, fun) do
+    if map_size(left) > map_size(right) do
+      iterator_merge(:maps.next(:maps.iterator(right)), left, fun)
+    else
+      iterator_merge(:maps.next(:maps.iterator(left)), right, fun)
+    end
+  end
+
+  defp iterator_merge({key, v1, iterator}, map, fun) do
+    acc =
+      case map do
+        %{^key => v2} -> %{map | key => fun.(key, v1, v2)}
+        %{} -> Map.put(map, key, v1)
+      end
+
+    iterator_merge(:maps.next(iterator), acc, fun)
+  end
+
+  defp iterator_merge(:none, map, _fun), do: map
+
+  # Perform a symmetrical merge with default values
+  defp symmetrical_merge(left, left_default, right, right_default, fun) do
+    iterator = :maps.next(:maps.iterator(left))
+    iterator_merge_left(iterator, left_default, right, right_default, %{}, fun)
+  end
+
+  defp iterator_merge_left({key, v1, iterator}, v1_default, map, v2_default, acc, fun) do
+    value =
+      case map do
+        %{^key => v2} -> fun.(key, v1, v2)
+        %{} -> fun.(key, v1, v2_default)
+      end
+
+    acc = Map.put(acc, key, value)
+    iterator_merge_left(:maps.next(iterator), v1_default, map, v2_default, acc, fun)
+  end
+
+  defp iterator_merge_left(:none, v1_default, map, _v2_default, acc, fun) do
+    iterator_merge_right(:maps.next(:maps.iterator(map)), v1_default, acc, fun)
+  end
+
+  defp iterator_merge_right({key, v2, iterator}, v1_default, acc, fun) do
+    acc =
+      case acc do
+        %{^key => _} -> acc
+        %{} -> Map.put(acc, key, fun.(key, v1_default, v2))
+      end
+
+    iterator_merge_right(:maps.next(iterator), v1_default, acc, fun)
+  end
+
+  defp iterator_merge_right(:none, _v1_default, acc, _fun) do
+    acc
+  end
+
+  # Erlang maps:intersect_with/3 has to preserve the order in combiner.
+  # We don't care about the order, so we have a faster implementation.
+  defp symmetrical_intersection(left, right, fun) do
+    if map_size(left) > map_size(right) do
+      iterator_intersection(:maps.next(:maps.iterator(right)), left, [], fun)
+    else
+      iterator_intersection(:maps.next(:maps.iterator(left)), right, [], fun)
+    end
+  end
+
+  defp iterator_intersection({key, v1, iterator}, map, acc, fun) do
+    acc =
+      case map do
+        %{^key => v2} ->
+          value = fun.(key, v1, v2)
+
+          if value in @empty_intersection do
+            acc
+          else
+            [{key, value} | acc]
+          end
+
+        %{} ->
+          acc
+      end
+
+    iterator_intersection(:maps.next(iterator), map, acc, fun)
+  end
+
+  defp iterator_intersection(:none, _map, acc, _fun), do: :maps.from_list(acc)
+
+  defp non_disjoint_intersection?(left, right) do
+    # Erlang maps:intersect_with/3 has to preserve the order in combiner.
+    # We don't care about the order, so we have a faster implementation.
+    if map_size(left) > map_size(right) do
+      iterator_non_disjoint_intersection?(:maps.next(:maps.iterator(right)), left)
+    else
+      iterator_non_disjoint_intersection?(:maps.next(:maps.iterator(left)), right)
+    end
+  end
+
+  defp iterator_non_disjoint_intersection?({key, v1, iterator}, map) do
+    with %{^key => v2} <- map,
+         value when value not in @empty_intersection <- intersection(key, v1, v2),
+         false <- empty_key?(key, value) do
+      true
+    else
+      _ -> iterator_non_disjoint_intersection?(:maps.next(iterator), map)
+    end
+  end
+
+  defp iterator_non_disjoint_intersection?(:none, _map), do: false
+
+  defp non_empty_map_or([head | tail], fun) do
+    Enum.reduce(tail, fun.(head), &{:or, [], [&2, fun.(&1)]})
+  end
+end
diff --git a/lib/elixir/lib/module/types/expr.ex b/lib/elixir/lib/module/types/expr.ex
new file mode 100644
index 00000000000..7a9de17f062
--- /dev/null
+++ b/lib/elixir/lib/module/types/expr.ex
@@ -0,0 +1,985 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Module.Types.Expr do
+  @moduledoc false
+
+  alias Module.Types.{Apply, Of, Pattern}
+  import Module.Types.{Helpers, Descr}
+
+  14 = length(Macro.Env.__info__(:struct))
+
+  aliases = list(tuple([atom(), atom()]))
+  functions_and_macros = list(tuple([atom(), list(tuple([atom(), integer()]))]))
+  list_of_modules = list(atom())
+
+  @try_catch atom([:error, :exit, :throw])
+  @atom_true atom([true])
+
+  @caller closed_map(
+            __struct__: atom([Macro.Env]),
+            aliases: aliases,
+            context: atom([:match, :guard, nil]),
+            context_modules: list_of_modules,
+            file: binary(),
+            function: union(tuple([atom(), integer()]), atom([nil])),
+            functions: functions_and_macros,
+            lexical_tracker: union(pid(), atom([nil])),
+            line: integer(),
+            macro_aliases: aliases,
+            macros: functions_and_macros,
+            module: atom(),
+            requires: list_of_modules,
+            tracers: list_of_modules,
+            versioned_vars: open_map()
+          )
+
+  # An annotation for terms where the reverse arrow is not yet fully defined.
+  # Also revisit all users of dynamic() in this module in a later date.
+  @pending term()
+
+  # We do not make exception dynamic on purpose. If you do a blank rescue,
+  # then we will assume you need to statically handle all possible exceptions.
+  @exception open_map(__struct__: atom(), __exception__: @atom_true)
+
+  args_or_arity = union(list(term()), integer())
+
+  extra_info =
+    list(
+      tuple([atom([:file]), list(integer())])
+      |> union(tuple([atom([:line]), integer()]))
+      |> union(tuple([atom([:error_info]), open_map()]))
+    )
+
+  @stacktrace list(
+                union(
+                  tuple([atom(), atom(), args_or_arity, extra_info]),
+                  tuple([fun(), args_or_arity, extra_info])
+                )
+              )
+
+  # :atom
+  def of_expr(atom, _expected, _expr, _stack, context) when is_atom(atom),
+    do: {atom([atom]), context}
+
+  # 12
+  def of_expr(literal, _expected, _expr, _stack, context) when is_integer(literal),
+    do: {integer(), context}
+
+  # 1.2
+  def of_expr(literal, _expected, _expr, _stack, context) when is_float(literal),
+    do: {float(), context}
+
+  # "..."
+  def of_expr(literal, _expected, _expr, _stack, context) when is_binary(literal),
+    do: {binary(), context}
+
+  # #PID<...>
+  def of_expr(literal, _expected, _expr, _stack, context) when is_pid(literal),
+    do: {pid(), context}
+
+  # []
+  def of_expr([], _expected, _expr, _stack, context),
+    do: {empty_list(), context}
+
+  # [expr, ...]
+  def of_expr(list, expected, expr, stack, context) when is_list(list) do
+    {prefix, suffix} = unpack_list(list, [])
+
+    if stack.mode == :traversal do
+      {_, context} = Enum.map_reduce(prefix, context, &of_expr(&1, term(), expr, stack, &2))
+      {_, context} = of_expr(suffix, term(), expr, stack, context)
+      {dynamic(), context}
+    else
+      hd_type =
+        case list_hd(expected) do
+          {:ok, type} -> type
+          _ -> term()
+        end
+
+      {prefix, context} = Enum.map_reduce(prefix, context, &of_expr(&1, hd_type, expr, stack, &2))
+
+      {suffix, context} =
+        if suffix == [] do
+          {empty_list(), context}
+        else
+          tl_type =
+            case list_tl(expected) do
+              {:ok, type} -> type
+              :badnonemptylist -> term()
+            end
+
+          of_expr(suffix, tl_type, expr, stack, context)
+        end
+
+      {non_empty_list(Enum.reduce(prefix, &union/2), suffix), context}
+    end
+  end
+
+  # {left, right}
+  def of_expr({left, right}, expected, expr, stack, context) do
+    of_tuple([left, right], expected, expr, stack, context)
+  end
+
+  # {...}
+  def of_expr({:{}, _meta, exprs}, expected, expr, stack, context) do
+    of_tuple(exprs, expected, expr, stack, context)
+  end
+
+  # <<...>>>
+  def of_expr({:<<>>, _meta, args}, _expected, _expr, stack, context) do
+    context = Of.binary(args, :expr, stack, context)
+    {binary(), context}
+  end
+
+  def of_expr({:__CALLER__, _meta, var_context}, _expected, _expr, _stack, context)
+      when is_atom(var_context) do
+    {@caller, context}
+  end
+
+  def of_expr({:__STACKTRACE__, _meta, var_context}, _expected, _expr, _stack, context)
+      when is_atom(var_context) do
+    {@stacktrace, context}
+  end
+
+  # left = right
+  def of_expr({:=, _, [left_expr, right_expr]} = match, expected, expr, stack, context) do
+    {left_expr, right_expr} = repack_match(left_expr, right_expr)
+
+    case left_expr do
+      # We do not raise on underscore in case someone writes _ = raise "omg"
+      {:_, _, ctx} when is_atom(ctx) ->
+        of_expr(right_expr, expected, expr, stack, context)
+
+      _ ->
+        type_fun = fn pattern_type, context ->
+          # See if we can use the expected type to further refine the pattern type,
+          # if we cannot, use the pattern type as that will fail later on.
+          {_ok_or_error, type} = compatible_intersection(dynamic(pattern_type), expected)
+          of_expr(right_expr, type, expr, stack, context)
+        end
+
+        Pattern.of_match(left_expr, type_fun, match, stack, context)
+    end
+  end
+
+  # %{map | ...}
+  # TODO: Once we support typed structs, we need to type check them here.
+  def of_expr({:%{}, meta, [{:|, _, [map, args]}]} = update, expected, expr, stack, context) do
+    # Theoretically we cannot process entries out of order but,
+    # because all variables are versioned, and Elixir does not
+    # allow variables defined on the left side of | to be available
+    # on the right side, this is safe.
+    {pairs_types, context} =
+      Enum.map_reduce(args, context, fn {key, value}, context ->
+        {key_type, context} = of_expr(key, term(), expr, stack, context)
+        {value_type, context} = of_expr(value, term(), expr, stack, context)
+        {{key_type, value_type}, context}
+      end)
+
+    expected =
+      if stack.mode == :traversal do
+        expected
+      else
+        # The only information we can attach to the expected types is that
+        # certain keys are expected.
+        expected_pairs =
+          Enum.flat_map(pairs_types, fn {key_type, _value_type} ->
+            case atom_fetch(key_type) do
+              {:finite, [key]} -> [{key, term()}]
+              _ -> []
+            end
+          end)
+
+        intersection(expected, open_map(expected_pairs))
+      end
+
+    {map_type, context} = of_expr(map, expected, expr, stack, context)
+
+    try do
+      Enum.reduce(pairs_types, map_type, fn {key_type, value_type}, acc ->
+        case literal_map_update(acc, key_type, value_type) do
+          {:ok, descr} -> descr
+          {:badkey, key} -> throw({:badkey, map_type, key, update, context})
+          {:baddomain, domain} -> throw({:baddomain, map_type, domain, update, context})
+          :badmap -> throw({:badmap, map_type, update, context})
+        end
+      end)
+    catch
+      error -> {error_type(), error(__MODULE__, error, meta, stack, context)}
+    else
+      map -> {map, context}
+    end
+  end
+
+  # %Struct{map | ...}
+  def of_expr(
+        {:%, meta, [module, {:%{}, _, [{:|, _, [map, pairs]}]}]} = struct,
+        _expected,
+        expr,
+        stack,
+        context
+      ) do
+    # We pass the expected type as `term()` because the struct update
+    # operator already expects it to be a map at this point.
+    {map_type, context} = of_expr(map, term(), struct, stack, context)
+
+    context =
+      if stack.mode == :traversal do
+        context
+      else
+        with {false, struct_key_type} <- map_fetch_key(map_type, :__struct__),
+             {:finite, [^module]} <- atom_fetch(struct_key_type) do
+          context
+        else
+          _ ->
+            error(__MODULE__, {:badupdate, map_type, struct, context}, meta, stack, context)
+        end
+      end
+
+    Enum.reduce(pairs, {map_type, context}, fn {key, value}, {acc, context} ->
+      # TODO: Once we support typed structs, we need to type check them here
+      {type, context} = of_expr(value, term(), expr, stack, context)
+
+      case map_put_key(acc, key, type) do
+        {:ok, acc} -> {acc, context}
+        _ -> {acc, context}
+      end
+    end)
+  end
+
+  # %{...}
+  def of_expr({:%{}, _meta, args}, expected, expr, stack, context) do
+    Of.closed_map(args, expected, stack, context, &of_expr(&1, &2, expr, &3, &4))
+  end
+
+  # %Struct{}
+  def of_expr({:%, meta, [module, {:%{}, _, args}]}, expected, expr, stack, context) do
+    fun = &of_expr(&1, &2, expr, &3, &4)
+    Of.struct_instance(module, args, expected, meta, stack, context, fun)
+  end
+
+  # ()
+  def of_expr({:__block__, _meta, []}, _expected, _expr, _stack, context) do
+    {atom([nil]), context}
+  end
+
+  # (expr; expr)
+  def of_expr({:__block__, _meta, exprs}, expected, _expr, stack, context) do
+    {pre, [post]} = Enum.split(exprs, -1)
+
+    context =
+      Enum.reduce(pre, context, fn expr, context ->
+        {_, context} = of_expr(expr, term(), expr, stack, context)
+        context
+      end)
+
+    of_expr(post, expected, post, stack, context)
+  end
+
+  def of_expr({:cond, _meta, [[{:do, clauses}]]}, expected, expr, stack, original) do
+    clauses
+    |> reduce_non_empty({none(), original}, fn
+      {:->, meta, [[head], body]}, {acc, context}, last? ->
+        {head_type, context} = of_expr(head, @pending, head, stack, context)
+
+        context =
+          if is_warning(stack) do
+            case truthiness(head_type) do
+              :always_true when not last? ->
+                warning = {:badcond, "always match", head_type, head, context}
+                warn(__MODULE__, warning, meta, stack, context)
+
+              :always_false ->
+                warning = {:badcond, "never match", head_type, head, context}
+                warn(__MODULE__, warning, meta, stack, context)
+
+              _ ->
+                context
+            end
+          else
+            context
+          end
+
+        {body_type, context} = of_expr(body, expected, expr, stack, context)
+        {union(body_type, acc), reset_vars(context, original)}
+    end)
+    |> dynamic_unless_static(stack)
+  end
+
+  def of_expr({:case, meta, [case_expr, [{:do, clauses}]]}, expected, expr, stack, context) do
+    {case_type, context} = of_expr(case_expr, @pending, case_expr, stack, context)
+    info = {:case, meta, case_type, case_expr}
+
+    # If we are only type checking the expression and the expression is a literal,
+    # let's mark it as generated, as it is most likely a macro code. However, if
+    # no clause is matched, we should still check for that.
+    if Macro.quoted_literal?(case_expr) do
+      for {:->, meta, args} <- clauses, do: {:->, [generated: true] ++ meta, args}
+    else
+      clauses
+    end
+    |> of_clauses([case_type], expected, expr, info, stack, context, none())
+    |> dynamic_unless_static(stack)
+  end
+
+  # TODO: fn pat -> expr end
+  def of_expr({:fn, _meta, clauses}, _expected, _expr, stack, context) do
+    [{:->, _, [head, _]} | _] = clauses
+    {patterns, _guards} = extract_head(head)
+    domain = Enum.map(patterns, fn _ -> dynamic() end)
+
+    if stack.mode == :traversal do
+      {_acc, context} = of_clauses(clauses, domain, @pending, nil, :fn, stack, context, none())
+      {dynamic(), context}
+    else
+      {acc, context} =
+        of_clauses_fun(clauses, domain, @pending, nil, :fn, stack, context, [], fn
+          trees, body, context, acc ->
+            args = Pattern.of_domain(trees, domain, context)
+            add_inferred(acc, args, body)
+        end)
+
+      {fun_from_inferred_clauses(acc), context}
+    end
+  end
+
+  def of_expr({:try, _meta, [[do: body] ++ blocks]}, expected, expr, stack, original) do
+    {after_block, blocks} = Keyword.pop(blocks, :after)
+    {else_block, blocks} = Keyword.pop(blocks, :else)
+
+    {type, context} =
+      if else_block do
+        {type, context} = of_expr(body, @pending, body, stack, original)
+        info = {:try_else, type}
+        of_clauses(else_block, [type], expected, expr, info, stack, context, none())
+      else
+        of_expr(body, expected, expr, stack, original)
+      end
+
+    {type, context} =
+      blocks
+      |> Enum.reduce({type, reset_vars(context, original)}, fn
+        {:rescue, clauses}, acc_context ->
+          Enum.reduce(clauses, acc_context, fn
+            {:->, _, [[{:in, meta, [var, exceptions]} = expr], body]}, {acc, context} ->
+              {type, context} =
+                of_rescue(var, exceptions, body, expr, :rescue, meta, stack, context)
+
+              {union(type, acc), context}
+
+            {:->, meta, [[var], body]}, {acc, context} ->
+              {type, context} =
+                of_rescue(var, [], body, var, :anonymous_rescue, meta, stack, context)
+
+              {union(type, acc), context}
+          end)
+
+        {:catch, clauses}, {acc, context} ->
+          args = [@try_catch, dynamic()]
+          of_clauses(clauses, args, expected, expr, :try_catch, stack, context, acc)
+      end)
+      |> dynamic_unless_static(stack)
+
+    if after_block do
+      {_type, context} = of_expr(after_block, term(), after_block, stack, context)
+      {type, context}
+    else
+      {type, context}
+    end
+  end
+
+  @timeout_type union(integer(), atom([:infinity]))
+
+  def of_expr({:receive, _meta, [blocks]}, expected, expr, stack, original) do
+    blocks
+    |> Enum.reduce({none(), original}, fn
+      {:do, {:__block__, _, []}}, acc_context ->
+        acc_context
+
+      {:do, clauses}, {acc, context} ->
+        of_clauses(clauses, [dynamic()], expected, expr, :receive, stack, context, acc)
+
+      {:after, [{:->, meta, [[timeout], body]}] = after_expr}, {acc, context} ->
+        {timeout_type, context} = of_expr(timeout, @timeout_type, after_expr, stack, context)
+        {body_type, context} = of_expr(body, expected, expr, stack, context)
+
+        if compatible?(timeout_type, @timeout_type) do
+          {union(body_type, acc), reset_vars(context, original)}
+        else
+          error = {:badtimeout, timeout_type, timeout, context}
+          {union(body_type, acc), error(__MODULE__, error, meta, stack, context)}
+        end
+    end)
+    |> dynamic_unless_static(stack)
+  end
+
+  def of_expr({:for, meta, [_ | _] = args}, expected, expr, stack, context) do
+    {clauses, [[{:do, block} | opts]]} = Enum.split(args, -1)
+    context = Enum.reduce(clauses, context, &for_clause(&1, stack, &2))
+
+    # We don't need to type check uniq, as it is a compile-time boolean.
+    # We handle reduce and into accordingly instead.
+    if Keyword.has_key?(opts, :reduce) do
+      reduce = Keyword.fetch!(opts, :reduce)
+      {reduce_type, context} = of_expr(reduce, expected, expr, stack, context)
+      # TODO: We need to type check against dynamic() instead of using reduce_type
+      # because this is recursive. We need to infer the block type first.
+      of_clauses(block, [dynamic()], expected, expr, :for_reduce, stack, context, reduce_type)
+    else
+      # TODO: Use the collectable protocol for the output
+      into = Keyword.get(opts, :into, [])
+      {into_wrapper, gradual?, context} = for_into(into, meta, stack, context)
+      {block_type, context} = of_expr(block, @pending, block, stack, context)
+
+      for_type =
+        for type <- into_wrapper do
+          case type do
+            :binary -> binary()
+            :list -> list(block_type)
+            :term -> term()
+          end
+        end
+        |> Enum.reduce(&union/2)
+
+      {if(gradual?, do: dynamic(for_type), else: for_type), context}
+    end
+  end
+
+  # TODO: with pat <- expr do expr end
+  def of_expr({:with, _meta, [_ | _] = clauses}, _expected, _expr, stack, original) do
+    {clauses, [options]} = Enum.split(clauses, -1)
+    context = Enum.reduce(clauses, original, &with_clause(&1, stack, &2))
+    context = Enum.reduce(options, context, &with_option(&1, stack, &2, original))
+    {dynamic(), context}
+  end
+
+  def of_expr({{:., _, [fun]}, _, args} = call, _expected, _expr, stack, context) do
+    {fun_type, context} = of_expr(fun, dynamic(fun(length(args))), call, stack, context)
+
+    # TODO: Perform inference based on the strong domain of a function
+    {args_types, context} =
+      Enum.map_reduce(args, context, &of_expr(&1, @pending, &1, stack, &2))
+
+    if stack.mode == :traversal do
+      {dynamic(), context}
+    else
+      Apply.fun_apply(fun_type, args_types, call, stack, context)
+    end
+  end
+
+  def of_expr({{:., _, [callee, key_or_fun]}, meta, []} = call, expected, expr, stack, context)
+      when not is_atom(callee) and is_atom(key_or_fun) do
+    if Keyword.get(meta, :no_parens, false) do
+      {type, context} = of_expr(callee, open_map([{key_or_fun, expected}]), expr, stack, context)
+      Of.map_fetch(call, type, key_or_fun, stack, context)
+    else
+      {type, context} = of_expr(callee, atom(), call, stack, context)
+      {mods, context} = Of.modules(type, key_or_fun, 0, [:dot], call, meta, stack, context)
+      apply_many(mods, key_or_fun, [], expected, call, stack, context)
+    end
+  end
+
+  def of_expr({{:., _, [remote, name]}, meta, args} = call, expected, _expr, stack, context) do
+    {remote_type, context} = of_expr(remote, atom(), call, stack, context)
+    {mods, context} = Of.modules(remote_type, name, length(args), call, meta, stack, context)
+    apply_many(mods, name, args, expected, call, stack, context)
+  end
+
+  # TODO: &Foo.bar/1
+  def of_expr(
+        {:&, _, [{:/, _, [{{:., _, [remote, name]}, meta, []}, arity]}]} = call,
+        _expected,
+        _expr,
+        stack,
+        context
+      )
+      when is_atom(name) and is_integer(arity) do
+    {remote_type, context} = of_expr(remote, atom(), call, stack, context)
+    {mods, context} = Of.modules(remote_type, name, arity, call, meta, stack, context)
+    Apply.remote_capture(mods, name, arity, meta, stack, context)
+  end
+
+  # TODO: &foo/1
+  def of_expr({:&, _meta, [{:/, _, [{fun, meta, _}, arity]}]}, _expected, _expr, stack, context) do
+    Apply.local_capture(fun, arity, meta, stack, context)
+  end
+
+  # Super
+  def of_expr({:super, meta, args} = call, expected, _expr, stack, context) when is_list(args) do
+    {_kind, fun} = Keyword.fetch!(meta, :super)
+    apply_local(fun, args, expected, call, stack, context)
+  end
+
+  # Local calls
+  def of_expr({fun, _meta, args} = call, expected, _expr, stack, context)
+      when is_atom(fun) and is_list(args) do
+    apply_local(fun, args, expected, call, stack, context)
+  end
+
+  # var
+  def of_expr(var, expected, expr, stack, context) when is_var(var) do
+    case stack do
+      %{mode: :traversal} -> {dynamic(), context}
+      %{refine_vars: false} -> {Of.var(var, context), context}
+      %{} -> Of.refine_body_var(var, expected, expr, stack, context)
+    end
+  end
+
+  ## Tuples
+
+  defp of_tuple(elems, _expected, expr, %{mode: :traversal} = stack, context) do
+    {_types, context} = Enum.map_reduce(elems, context, &of_expr(&1, term(), expr, stack, &2))
+    {dynamic(), context}
+  end
+
+  defp of_tuple(elems, expected, expr, stack, context) do
+    of_tuple(elems, 0, [], expected, expr, stack, context)
+  end
+
+  defp of_tuple([elem | elems], index, acc, expected, expr, stack, context) do
+    expr_expected =
+      case tuple_fetch(expected, index) do
+        {_, type} -> type
+        _ -> term()
+      end
+
+    {type, context} = of_expr(elem, expr_expected, expr, stack, context)
+    of_tuple(elems, index + 1, [type | acc], expected, expr, stack, context)
+  end
+
+  defp of_tuple([], _index, acc, _expected, _expr, _stack, context) do
+    {tuple(Enum.reverse(acc)), context}
+  end
+
+  ## Try
+
+  defp of_rescue(var, exceptions, body, expr, info, meta, stack, original) do
+    args = [__exception__: @atom_true]
+
+    {structs, context} =
+      Enum.map_reduce(exceptions, original, fn exception, context ->
+        # Exceptions are not validated in the compiler,
+        # to avoid export dependencies. So we do it here.
+        if Code.ensure_loaded?(exception) and function_exported?(exception, :__struct__, 0) do
+          {info, context} = Of.struct_info(exception, meta, stack, context)
+          {Of.struct_type(exception, info, args), context}
+        else
+          # If the exception cannot be found or is invalid, fetch the signature to emit warnings.
+          {_, context} = Apply.signature(exception, :__struct__, 0, meta, stack, context)
+          {error_type(), context}
+        end
+      end)
+
+    context =
+      case var do
+        {:_, _, _} ->
+          context
+
+        _ ->
+          expected = if structs == [], do: @exception, else: Enum.reduce(structs, &union/2)
+          expr = {:__block__, [type_check: info], [expr]}
+          {_ok?, _type, context} = Of.refine_head_var(var, expected, expr, stack, context)
+          context
+      end
+
+    {type, context} = of_expr(body, @pending, body, stack, context)
+    {type, reset_vars(context, original)}
+  end
+
+  ## Comprehensions
+
+  defp for_clause({:<-, meta, [left, right]}, stack, context) do
+    expr = {:<-, [type_check: :generator] ++ meta, [left, right]}
+    {pattern, guards} = extract_head([left])
+
+    {_type, context} =
+      apply_one(Enumerable, :count, [right], dynamic(), expr, stack, context)
+
+    Pattern.of_generator(pattern, guards, dynamic(), :for, expr, stack, context)
+  end
+
+  defp for_clause({:<<>>, _, [{:<-, meta, [left, right]}]} = expr, stack, context) do
+    {right_type, context} = of_expr(right, binary(), expr, stack, context)
+    context = Pattern.of_generator(left, [], binary(), :for, expr, stack, context)
+
+    if compatible?(right_type, binary()) do
+      context
+    else
+      error = {:badbinary, right_type, right, context}
+      error(__MODULE__, error, meta, stack, context)
+    end
+  end
+
+  defp for_clause(expr, stack, context) do
+    {_type, context} = of_expr(expr, term(), expr, stack, context)
+    context
+  end
+
+  @into_compile union(binary(), empty_list())
+
+  defp for_into([], _meta, _stack, context),
+    do: {[:list], false, context}
+
+  defp for_into(binary, _meta, _stack, context) when is_binary(binary),
+    do: {[:binary], false, context}
+
+  defp for_into(into, meta, stack, context) do
+    meta =
+      case into do
+        {_, meta, _} -> meta
+        _ -> meta
+      end
+
+    expr = {:__block__, [type_check: :into] ++ meta, [into]}
+
+    {info, [domain], context} =
+      Apply.remote_domain(Collectable, :into, [into], term(), meta, stack, context)
+
+    {type, context} = of_expr(into, domain, expr, stack, context)
+
+    # We use subtype? instead of compatible because we want to handle
+    # only binary/list, even if a dynamic with something else is given.
+    if subtype?(type, @into_compile) do
+      case {binary_type?(type), empty_list_type?(type)} do
+        {false, true} -> {[:list], gradual?(type), context}
+        {true, false} -> {[:binary], gradual?(type), context}
+        {_, _} -> {[:binary, :list], gradual?(type), context}
+      end
+    else
+      {_type, context} =
+        Apply.remote_apply(info, Collectable, :into, [type], expr, stack, context)
+
+      {[:term], true, context}
+    end
+  end
+
+  ## With
+
+  defp with_clause({:<-, _meta, [left, right]} = expr, stack, context) do
+    {pattern, guards} = extract_head([left])
+    {_type, context} = of_expr(right, @pending, right, stack, context)
+    Pattern.of_generator(pattern, guards, dynamic(), :with, expr, stack, context)
+  end
+
+  defp with_clause(expr, stack, context) do
+    {_type, context} = of_expr(expr, @pending, expr, stack, context)
+    context
+  end
+
+  defp with_option({:do, body}, stack, context, original) do
+    {_type, context} = of_expr(body, @pending, body, stack, context)
+    reset_vars(context, original)
+  end
+
+  defp with_option({:else, clauses}, stack, context, _original) do
+    {_, context} =
+      of_clauses(clauses, [dynamic()], @pending, nil, :with_else, stack, context, none())
+
+    context
+  end
+
+  ## General helpers
+
+  defp apply_local(fun, args, expected, {_, meta, _} = expr, stack, context) do
+    {local_info, domain, context} = Apply.local_domain(fun, args, expected, meta, stack, context)
+
+    {args_types, context} =
+      zip_map_reduce(args, domain, context, &of_expr(&1, &2, expr, stack, &3))
+
+    Apply.local_apply(local_info, fun, args_types, expr, stack, context)
+  end
+
+  defp apply_one(mod, fun, args, expected, expr, stack, context) do
+    {info, domain, context} =
+      Apply.remote_domain(mod, fun, args, expected, elem(expr, 1), stack, context)
+
+    {args_types, context} =
+      zip_map_reduce(args, domain, context, &of_expr(&1, &2, expr, stack, &3))
+
+    Apply.remote_apply(info, mod, fun, args_types, expr, stack, context)
+  end
+
+  defp apply_many([], fun, args, expected, expr, stack, context) do
+    {info, domain} = Apply.remote_domain(fun, args, expected, stack)
+
+    {args_types, context} =
+      zip_map_reduce(args, domain, context, &of_expr(&1, &2, expr, stack, &3))
+
+    Apply.remote_apply(info, nil, fun, args_types, expr, stack, context)
+  end
+
+  defp apply_many([mod], fun, args, expected, expr, stack, context) do
+    apply_one(mod, fun, args, expected, expr, stack, context)
+  end
+
+  defp apply_many(mods, fun, args, expected, {remote, meta, args}, stack, context) do
+    {returns, context} =
+      Enum.map_reduce(mods, context, fn mod, context ->
+        expr = {remote, [type_check: {:invoked_as, mod, fun, length(args)}] ++ meta, args}
+        apply_one(mod, fun, args, expected, expr, %{stack | refine_vars: false}, context)
+      end)
+
+    {Enum.reduce(returns, &union/2), context}
+  end
+
+  defp reduce_non_empty([last], acc, fun),
+    do: fun.(last, acc, true)
+
+  defp reduce_non_empty([head | tail], acc, fun),
+    do: reduce_non_empty(tail, fun.(head, acc, false), fun)
+
+  defp dynamic_unless_static({_, _} = output, %{mode: :static}), do: output
+  defp dynamic_unless_static({type, context}, %{mode: _}), do: {dynamic(type), context}
+
+  defp of_clauses(clauses, domain, expected, expr, info, %{mode: mode} = stack, context, acc) do
+    fun =
+      if mode == :traversal do
+        fn _, _, _, _ -> dynamic() end
+      else
+        fn _trees, result, _context, acc -> union(result, acc) end
+      end
+
+    of_clauses_fun(clauses, domain, expected, expr, info, stack, context, acc, fun)
+  end
+
+  defp of_clauses_fun(clauses, domain, expected, expr, info, stack, original, acc, fun) do
+    %{failed: failed?} = original
+
+    Enum.reduce(clauses, {acc, original}, fn {:->, meta, [head, body]}, {acc, context} ->
+      {failed?, context} = reset_failed(context, failed?)
+      {patterns, guards} = extract_head(head)
+      {trees, context} = Pattern.of_head(patterns, guards, domain, info, meta, stack, context)
+
+      {result, context} = of_expr(body, expected, expr || body, stack, context)
+      {fun.(trees, result, context, acc), context |> set_failed(failed?) |> reset_vars(original)}
+    end)
+  end
+
+  defp reset_failed(%{failed: true} = context, false), do: {true, %{context | failed: false}}
+  defp reset_failed(context, _), do: {false, context}
+
+  defp set_failed(%{failed: false} = context, true), do: %{context | failed: true}
+  defp set_failed(context, _bool), do: context
+
+  defp reset_vars(context, %{vars: vars}), do: %{context | vars: vars}
+
+  defp extract_head([{:when, _meta, args}]) do
+    case Enum.split(args, -1) do
+      {patterns, [guards]} -> {patterns, flatten_when(guards)}
+      {patterns, []} -> {patterns, []}
+    end
+  end
+
+  defp extract_head(other) do
+    {other, []}
+  end
+
+  defp flatten_when({:when, _meta, [left, right]}), do: [left | flatten_when(right)]
+  defp flatten_when(other), do: [other]
+
+  defp repack_match(left_expr, {:=, meta, [new_left, new_right]}),
+    do: repack_match({:=, meta, [left_expr, new_left]}, new_right)
+
+  defp repack_match(left_expr, right_expr),
+    do: {left_expr, right_expr}
+
+  defp add_inferred([{args, existing_return} | tail], args, return),
+    do: [{args, union(existing_return, return)} | tail]
+
+  defp add_inferred([head | tail], args, return),
+    do: [head | add_inferred(tail, args, return)]
+
+  defp add_inferred([], args, return),
+    do: [{args, return}]
+
+  defp literal_map_update(descr, key_descr, value_descr) do
+    case map_update(descr, key_descr, value_descr, false) do
+      {_type, descr, []} -> {:ok, descr}
+      {_, _, [error | _]} -> error
+      :badmap -> :badmap
+      {:error, [error | _]} -> error
+      {:error, []} -> {:baddomain, key_descr}
+    end
+  end
+
+  ## Warning formatting
+
+  def format_diagnostic({:badupdate, type, expr, context}) do
+    {:%, _, [module, {:%{}, _, [{:|, _, [map, _]}]}]} = expr
+    traces = collect_traces(map, context)
+
+    fix =
+      case map do
+        {var, meta, context} when is_atom(var) and is_atom(context) ->
+          if capture = meta[:capture] do
+            "instead of using &#{capture}, you must define an anonymous function, define a variable and pattern match on \"%#{inspect(module)}{}\""
+          else
+            "when defining the variable \"#{Macro.to_string(map)}\", you must also pattern match on \"%#{inspect(module)}{}\""
+          end
+
+        _ ->
+          "you must assign \"#{Macro.to_string(map)}\" to variable and pattern match on \"%#{inspect(module)}{}\""
+      end
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          a struct for #{inspect(module)} is expected on struct update:
+
+              #{expr_to_string(expr, collapse_structs: false) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces),
+          """
+
+          #{fix}.
+
+          #{hint()} given pattern matching is enough to catch typing errors, \
+          you may optionally convert the struct update into a map update. For \
+          example, instead of:
+
+              user = some_function()
+              %User{user | name: "John Doe"}
+
+          it is enough to write:
+
+              %User{} = user = some_function()
+              %{user | name: "John Doe"}
+          """
+        ])
+    }
+  end
+
+  def format_diagnostic({:badmap, type, expr, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected a map within map update syntax:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  def format_diagnostic({:badkey, type, key, expr, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected a map with key #{inspect(key)} in map update syntax:
+
+              #{expr_to_string(expr, collapse_structs: false) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(type, collapse_structs: false) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  def format_diagnostic({:baddomain, type, key_type, expr, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected a map with key of type #{to_quoted_string(key_type)} in map update syntax:
+
+              #{expr_to_string(expr, collapse_structs: false) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(type, collapse_structs: false) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  def format_diagnostic({:badbinary, type, expr, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected the right side of <- in a binary generator to be a binary:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  def format_diagnostic({:badtimeout, type, expr, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected "after" timeout given to receive to be an integer:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  def format_diagnostic({:badcond, explain, type, expr, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          this clause in cond will #{explain}:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          since it has type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+end
diff --git a/lib/elixir/lib/module/types/helpers.ex b/lib/elixir/lib/module/types/helpers.ex
new file mode 100644
index 00000000000..d090d8e7c0a
--- /dev/null
+++ b/lib/elixir/lib/module/types/helpers.ex
@@ -0,0 +1,489 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Module.Types.Helpers do
+  # AST and enumeration helpers.
+  @moduledoc false
+
+  ## AST helpers
+
+  @doc """
+  Returns true if the mode cares about warnings.
+  """
+  defguard is_warning(stack) when stack.mode not in [:traversal, :infer]
+
+  @doc """
+  Guard function to check if an AST node is a variable.
+  """
+  defmacro is_var(expr) do
+    quote do
+      is_tuple(unquote(expr)) and
+        tuple_size(unquote(expr)) == 3 and
+        is_atom(elem(unquote(expr), 0)) and
+        is_atom(elem(unquote(expr), 2))
+    end
+  end
+
+  @doc """
+  Unpacks a list into head elements and tail.
+  """
+  def unpack_list([{:|, _, [head, tail]}], acc), do: {Enum.reverse([head | acc]), tail}
+  def unpack_list([head], acc), do: {Enum.reverse([head | acc]), []}
+  def unpack_list([head | tail], acc), do: unpack_list(tail, [head | acc])
+
+  @doc """
+  Unpacks a match into several matches.
+  """
+  def unpack_match({:=, _, [left, right]}, acc),
+    do: unpack_match(left, unpack_match(right, acc))
+
+  def unpack_match(node, acc),
+    do: [node | acc]
+
+  @doc """
+  Returns the AST metadata.
+  """
+  def get_meta({_, meta, _}), do: meta
+  def get_meta(_other), do: []
+
+  @doc """
+  Attaches span information.
+  """
+  def with_span(meta, name) do
+    :elixir_env.calculate_span(meta, name)
+  end
+
+  ## Warnings
+
+  @doc """
+  Converts an itneger into ordinal.
+  """
+  def integer_to_ordinal(i) do
+    case rem(i, 10) do
+      1 when rem(i, 100) != 11 -> "#{i}st"
+      2 when rem(i, 100) != 12 -> "#{i}nd"
+      3 when rem(i, 100) != 13 -> "#{i}rd"
+      _ -> "#{i}th"
+    end
+  end
+
+  @doc """
+  Formatted hints in typing errors.
+  """
+  def format_hints(hints) do
+    hints
+    |> Enum.uniq()
+    |> Enum.map(fn
+      :inferred_bitstring_spec ->
+        """
+
+        #{hint()} all expressions given to binaries are assumed to be of type \
+        integer() unless said otherwise. For example, <<expr>> assumes "expr" \
+        is an integer. Pass a modifier, such as <<expr::float>> or <<expr::binary>>, \
+        to change the default behavior.
+        """
+
+      :dot ->
+        """
+
+        #{hint()} "var.field" (without parentheses) means "var" is a map() while \
+        "var.fun()" (with parentheses) means "var" is an atom()
+        """
+
+      :anonymous_rescue ->
+        """
+
+        #{hint()} when you rescue without specifying exception names, \
+        the variable is assigned a type of a struct but all of its fields are unknown. \
+        If you are trying to access an exception's :message key, either specify the \
+        exception names or use `Exception.message/1`.
+        """
+
+      :empty_union_domain ->
+        """
+
+        #{hint()} the function has an empty domain and therefore cannot be applied to \
+        any argument. This may happen when you have a union of functions, which means \
+        the only valid argument to said function are types that satisfy all sides of \
+        the union (which may be none)
+        """
+
+      {:impl, for} ->
+        # Get the type without dynamic for better pretty printing
+        type =
+          for
+          |> Module.Types.Of.impl()
+          |> Module.Types.Descr.dynamic()
+          |> Map.fetch!(:dynamic)
+          |> Module.Types.Descr.to_quoted_string(collapse_structs: true)
+
+        """
+
+        #{hint()} defimpl for #{inspect(for)} requires its callbacks to match exclusively on #{type}
+        """
+
+      :empty_domain ->
+        """
+
+        #{hint()} the function has an empty domain and therefore cannot be applied to \
+        any argument
+        """
+    end)
+  end
+
+  @doc "The hint prefix"
+  def hint, do: :elixir_errors.prefix(:hint)
+
+  @doc """
+  Collect traces from variables in expression.
+
+  This information is exposed to language servers and
+  therefore must remain backwards compatible.
+  """
+  def collect_traces(expr, %{vars: vars}) do
+    {_, versions} =
+      Macro.prewalk(expr, %{}, fn
+        {var_name, meta, var_context}, versions when is_atom(var_name) and is_atom(var_context) ->
+          version = meta[:version]
+
+          case vars do
+            %{^version => %{off_traces: off_traces, name: name, context: context}} ->
+              {:ok,
+               Map.put(versions, version, %{
+                 type: :variable,
+                 name: name,
+                 context: context,
+                 traces: collect_var_traces(expr, off_traces)
+               })}
+
+            _ ->
+              {:ok, versions}
+          end
+
+        node, versions ->
+          {node, versions}
+      end)
+
+    versions
+    |> Map.values()
+    |> Enum.sort_by(& &1.name)
+  end
+
+  defp collect_var_traces(parent_expr, traces) do
+    traces
+    |> Enum.reject(fn {expr, _file, type} ->
+      # As an optimization do not care about dynamic terms
+      type == %{dynamic: :term} or expr == parent_expr
+    end)
+    |> case do
+      [] -> traces
+      filtered -> filtered
+    end
+    |> Enum.reverse()
+    |> Enum.map(fn {expr, file, type} ->
+      meta = get_meta(expr)
+
+      # This information is exposed to language servers and
+      # therefore must remain backwards compatible.
+      %{
+        file: file,
+        meta: meta,
+        formatted_expr: expr_to_string(expr),
+        formatted_hints: format_hints(expr_hints(expr)),
+        formatted_type: Module.Types.Descr.to_quoted_string(type, collapse_structs: true)
+      }
+    end)
+    |> Enum.sort_by(&{&1.meta[:line], &1.meta[:column]})
+    |> Enum.dedup()
+  end
+
+  defp expr_hints(expr) do
+    case expr do
+      {:<<>>, [inferred_bitstring_spec: true] ++ _meta, _} ->
+        [:inferred_bitstring_spec]
+
+      {_, meta, _} ->
+        case meta[:type_check] do
+          :anonymous_rescue -> [:anonymous_rescue]
+          _ -> []
+        end
+
+      _ ->
+        []
+    end
+  end
+
+  @doc """
+  Format previously collected traces.
+  """
+  def format_traces(traces) do
+    Enum.map(traces, &format_trace/1)
+  end
+
+  defp format_trace(%{type: :variable, name: name, context: context, traces: traces}) do
+    traces =
+      for trace <- traces do
+        location =
+          trace.file
+          |> Path.relative_to_cwd()
+          |> Exception.format_file_line(trace.meta[:line], trace.meta[:column])
+          |> String.replace_suffix(":", "")
+
+        [
+          """
+
+              # type: #{indent(trace.formatted_type, 4)}
+              # from: #{location}
+              \
+          """,
+          indent(trace.formatted_expr, 4),
+          ?\n,
+          trace.formatted_hints
+        ]
+      end
+
+    type_or_types = pluralize(traces, "type", "types")
+    ["\nwhere #{format_var(name, context)} was given the #{type_or_types}:\n" | traces]
+  end
+
+  @doc """
+  Formats a var for pretty printing.
+  """
+  def format_var({var, _, context}), do: format_var(var, context)
+  def format_var(var, nil), do: "\"#{var}\""
+  def format_var(var, context), do: "\"#{var}\" (context #{inspect(context)})"
+
+  defp pluralize([_], singular, _plural), do: singular
+  defp pluralize(_, _singular, plural), do: plural
+
+  @doc """
+  Converts the given expression to a string,
+  translating inlined Erlang calls back to Elixir.
+
+  We also undo some macro expressions done by the Kernel module.
+
+  ## Options
+
+    * `:collapse_structs` - when false, show structs full representation
+  """
+  def expr_to_string(expr, opts \\ []) do
+    string = prewalk_expr_to_string(expr, opts)
+
+    case expr do
+      {_, meta, _} ->
+        case meta[:type_check] do
+          :anonymous_rescue ->
+            "rescue " <> string
+
+          :rescue ->
+            "rescue " <> string
+
+          {:invoked_as, mod, fun, arity} ->
+            string <> "\n#=> invoked as " <> Exception.format_mfa(mod, fun, arity)
+
+          _ ->
+            string
+        end
+
+      _ ->
+        string
+    end
+  end
+
+  defp prewalk_expr_to_string(expr, opts) do
+    collapse_structs? = Keyword.get(opts, :collapse_structs, true)
+
+    expr
+    |> Macro.prewalk(fn
+      {:%, _, [Range, {:%{}, _, fields}]} = node ->
+        case :lists.usort(fields) do
+          [first: first, last: last, step: step] ->
+            quote do
+              unquote(first)..unquote(last)//unquote(step)
+            end
+
+          _ ->
+            node
+        end
+
+      {:%, struct_meta, [struct, {:%{}, map_meta, fields}]} = node
+      when collapse_structs? ->
+        try do
+          struct.__info__(:struct)
+        rescue
+          _ -> node
+        else
+          infos ->
+            filtered =
+              for {field, value} <- fields, not matches_default?(infos, field, value) do
+                {field, value}
+              end
+
+            if length(fields) != length(filtered) do
+              {:%, struct_meta, [struct, {:%{}, map_meta, [{:..., [], []} | filtered]}]}
+            else
+              node
+            end
+        end
+
+      {{:., _, [Elixir.String.Chars, :to_string]}, meta, [arg]} ->
+        {:to_string, meta, [arg]}
+
+      {{:., _, [Elixir.List.Chars, :to_charlist]}, meta, [arg]} ->
+        {:to_charlist, meta, [arg]}
+
+      {{:., _, [mod, fun]}, meta, args} ->
+        erl_to_ex(mod, fun, args, meta)
+
+      {:fn, meta, [{:->, _, [_args, return]}]} = expr ->
+        if meta[:capture] do
+          {:&, meta, [return]}
+        else
+          expr
+        end
+
+      {:&, amp_meta, [{:/, slash_meta, [{{:., dot_meta, [mod, fun]}, call_meta, []}, arity]}]} ->
+        {mod, fun} =
+          case :elixir_rewrite.erl_to_ex(mod, fun, arity) do
+            {mod, fun} -> {mod, fun}
+            false -> {mod, fun}
+          end
+
+        {:&, amp_meta, [{:/, slash_meta, [{{:., dot_meta, [mod, fun]}, call_meta, []}, arity]}]}
+
+      {:case, meta, [expr, [do: clauses]]} = case ->
+        if meta[:type_check] == :expr do
+          case clauses do
+            [
+              {:->, _,
+               [
+                 [
+                   {:when, _,
+                    [
+                      {var, _, Kernel},
+                      {{:., _, [:erlang, :orelse]}, _,
+                       [
+                         {{:., _, [:erlang, :"=:="]}, _, [{var, _, Kernel}, false]},
+                         {{:., _, [:erlang, :"=:="]}, _, [{var, _, Kernel}, nil]}
+                       ]}
+                    ]}
+                 ],
+                 else_block
+               ]},
+              {:->, _, [[{:_, _, Kernel}], do_block]}
+            ] ->
+              {:if, meta, [expr, [do: do_block, else: else_block]]}
+
+            [
+              {:->, _, [[false], else_block]},
+              {:->, _, [[true], do_block]}
+            ] ->
+              {:if, meta, [expr, [do: do_block, else: else_block]]}
+
+            _ ->
+              case
+          end
+        else
+          case
+        end
+
+      {var, meta, context} = expr when is_atom(var) and is_atom(context) ->
+        if is_integer(meta[:capture]) do
+          {:&, meta, [meta[:capture]]}
+        else
+          expr
+        end
+
+      other ->
+        other
+    end)
+    |> Macro.to_string()
+  end
+
+  defp matches_default?(infos, field, value) do
+    case Enum.find(infos, &(&1.field == field)) do
+      %{default: default} -> Macro.escape(default) == value
+      _ -> false
+    end
+  end
+
+  defp erl_to_ex(
+         :erlang,
+         :error,
+         [expr, :none, [error_info: {:%{}, _, [module: Exception]}]],
+         meta
+       ) do
+    {:raise, meta, [expr]}
+  end
+
+  defp erl_to_ex(mod, fun, args, meta) do
+    case :elixir_rewrite.erl_to_ex(mod, fun, args) do
+      {Kernel, fun, args, _} -> {fun, meta, args}
+      {mod, fun, args, _} -> {{:., [], [mod, fun]}, meta, args}
+    end
+  end
+
+  @doc """
+  Indents new lines.
+  """
+  def indent(content, count) do
+    String.replace(content, "\n", "\n" <> String.duplicate(" ", count))
+  end
+
+  @doc """
+  Emits a warning.
+  """
+  def warn(module, warning, meta, stack, context) do
+    if Keyword.get(meta, :generated, false) do
+      context
+    else
+      effectively_warn(module, warning, meta, stack, context)
+    end
+  end
+
+  defp effectively_warn(module, warning, meta, stack, context) do
+    {fun, arity} = stack.function
+    location = {stack.file, meta, {stack.module, fun, arity}}
+    %{context | warnings: [{module, warning, location} | context.warnings]}
+  end
+
+  @doc """
+  Emits an error.
+
+  In practice an error is a warning that halts other errors from being collected.
+  """
+  def error(module, warning, meta, stack, context) do
+    case context do
+      %{failed: true} ->
+        context
+
+      %{failed: false} ->
+        if Keyword.get(meta, :generated, false) do
+          context
+        else
+          effectively_warn(module, warning, meta, stack, %{context | failed: true})
+        end
+    end
+  end
+
+  @doc """
+  The type to return when there is an error.
+  """
+  def error_type, do: Module.Types.Descr.dynamic()
+
+  ## Enum helpers
+
+  def zip_map_reduce(args1, args2, acc, fun) do
+    zip_map_reduce(args1, args2, [], acc, fun)
+  end
+
+  defp zip_map_reduce([arg1 | args1], [arg2 | args2], list, acc, fun) do
+    {item, acc} = fun.(arg1, arg2, acc)
+    zip_map_reduce(args1, args2, [item | list], acc, fun)
+  end
+
+  defp zip_map_reduce([], [], list, acc, _fun) do
+    {Enum.reverse(list), acc}
+  end
+end
diff --git a/lib/elixir/lib/module/types/of.ex b/lib/elixir/lib/module/types/of.ex
new file mode 100644
index 00000000000..23399b34b74
--- /dev/null
+++ b/lib/elixir/lib/module/types/of.ex
@@ -0,0 +1,683 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Module.Types.Of do
+  # Typing functionality shared between Expr and Pattern.
+  # Generic AST and Enum helpers go to Module.Types.Helpers.
+  @moduledoc false
+  import Module.Types.{Helpers, Descr}
+
+  @prefix quote(do: ...)
+  @suffix quote(do: ...)
+
+  @integer_or_float union(integer(), float())
+  @integer_or_binary union(integer(), binary())
+  @integer integer()
+  @float float()
+  @binary binary()
+
+  ## Variables
+
+  @doc """
+  Fetches the type of a defined variable.
+  """
+  def var({_name, meta, _context}, context) do
+    version = Keyword.fetch!(meta, :version)
+    %{vars: %{^version => %{type: type}}} = context
+    type
+  end
+
+  @doc """
+  Marks a variable with error.
+  """
+  def error_var(var, context) do
+    {var_name, meta, var_context} = var
+    version = Keyword.fetch!(meta, :version)
+
+    data = %{
+      type: error_type(),
+      name: var_name,
+      context: var_context,
+      off_traces: []
+    }
+
+    put_in(context.vars[version], data)
+  end
+
+  @doc """
+  Refines a variable that already exists (in a body).
+
+  This only happens if the var contains a gradual type,
+  or if we are doing a guard analysis or occurrence typing.
+  Returns `true` if there was a refinement, `false` otherwise.
+  """
+  def refine_body_var({_, meta, _}, type, expr, stack, context) do
+    version = Keyword.fetch!(meta, :version)
+    %{vars: %{^version => %{type: old_type, off_traces: off_traces} = data} = vars} = context
+
+    if gradual?(old_type) and type not in [term(), dynamic()] do
+      case compatible_intersection(old_type, type) do
+        {:ok, new_type} when new_type != old_type ->
+          data = %{
+            data
+            | type: new_type,
+              off_traces: new_trace(expr, new_type, stack, off_traces)
+          }
+
+          {new_type, %{context | vars: %{vars | version => data}}}
+
+        _ ->
+          {old_type, context}
+      end
+    else
+      {old_type, context}
+    end
+  end
+
+  @doc """
+  Refines the type of a variable.
+
+  Since this happens in a head, we use intersection
+  because we want to refine types. Otherwise we should
+  use compatibility.
+  """
+  def refine_head_var(var, type, expr, stack, context) do
+    {var_name, meta, var_context} = var
+    version = Keyword.fetch!(meta, :version)
+
+    case context.vars do
+      %{^version => %{type: old_type, off_traces: off_traces} = data} = vars ->
+        new_type = intersection(type, old_type)
+
+        data = %{
+          data
+          | type: new_type,
+            off_traces: new_trace(expr, type, stack, off_traces)
+        }
+
+        context = %{context | vars: %{vars | version => data}}
+
+        # We need to return error otherwise it leads to cascading errors
+        if empty?(new_type) do
+          {:error, error_type(),
+           error({:refine_head_var, old_type, type, var, context}, meta, stack, context)}
+        else
+          {:ok, new_type, context}
+        end
+
+      %{} = vars ->
+        data = %{
+          type: type,
+          name: var_name,
+          context: var_context,
+          off_traces: new_trace(expr, type, stack, [])
+        }
+
+        context = %{context | vars: Map.put(vars, version, data)}
+        {:ok, type, context}
+    end
+  end
+
+  defp new_trace(nil, _type, _stack, traces),
+    do: traces
+
+  defp new_trace(expr, type, stack, traces),
+    do: [{expr, stack.file, type} | traces]
+
+  ## Implementations
+
+  impls = [
+    {Atom, atom()},
+    {BitString, binary()},
+    {Float, float()},
+    {Function, fun()},
+    {Integer, integer()},
+    {List, union(empty_list(), non_empty_list(term(), term()))},
+    {Map, open_map(__struct__: if_set(negation(atom())))},
+    {Port, port()},
+    {PID, pid()},
+    {Reference, reference()},
+    {Tuple, tuple()},
+    {Any, term()}
+  ]
+
+  for {for, type} <- impls do
+    def impl(unquote(for)), do: unquote(Macro.escape(type))
+  end
+
+  def impl(struct) do
+    # Elixir did not strictly require the implementation to be available,
+    # so we need to deal with such cases accordingly.
+    # TODO: Assume implementation is available on Elixir v2.0.
+    # A warning is emitted since v1.19+.
+    if info = Code.ensure_loaded?(struct) && struct.__info__(:struct) do
+      struct_type(struct, info)
+    else
+      open_map(__struct__: atom([struct]))
+    end
+  end
+
+  ## Map/structs
+
+  @doc """
+  Handles fetching a map key.
+  """
+  def map_fetch(expr, type, field, stack, context) when is_atom(field) do
+    case map_fetch_key(type, field) do
+      {_optional?, value_type} ->
+        {value_type, context}
+
+      reason ->
+        {error_type(), error({reason, expr, type, field, context}, elem(expr, 1), stack, context)}
+    end
+  end
+
+  @doc """
+  Builds a closed map.
+  """
+  def closed_map(pairs, _expected, %{mode: :traversal} = stack, context, of_fun) do
+    context =
+      Enum.reduce(pairs, context, fn {key, value}, context ->
+        {_key_type, context} = of_fun.(key, term(), stack, context)
+        {_, context} = of_fun.(value, term(), stack, context)
+        context
+      end)
+
+    {dynamic(), context}
+  end
+
+  def closed_map(pairs, expected, stack, context, of_fun) do
+    {pairs_types, context} = pairs(pairs, expected, stack, context, of_fun)
+
+    {dynamic?, domain, single, multiple} =
+      Enum.reduce(pairs_types, {false, [], [], []}, fn
+        {pos_neg_domain, dynamic_pair?, value_type}, {dynamic?, domain, single, multiple} ->
+          dynamic? = dynamic? or dynamic_pair?
+
+          case pos_neg_domain do
+            # If atom is included in domain keys, it unions all previous
+            # single and multiple, except the ones negated:
+            #
+            #     %{foo: :bar, term() => :baz}
+            #     #=> %{foo: :bar or :baz, term() => :baz}
+            #
+            #     %{foo: :bar, not :foo => :baz}
+            #     #=> %{foo: :bar, term() => :baz}
+            #
+            # In case the negated term does not appear, we set it to none():
+            #
+            #     %{foo: :bar, term() => :baz}
+            #     #=> %{term() => :baz, foo: :bar or :baz}
+            #
+            #     %{not :foo => :baz}
+            #     #=> %{term() => :baz, foo: none()}
+            #
+            # In case we are dealing with multiple keys, we always merge the
+            # domain. A more precise approach would be to postpone doing so
+            # until the cartesian map is distributed but those should be very
+            # uncommon.
+            {[], negs, domain_keys} ->
+              if :atom in domain_keys do
+                {single, multiple} = union_negated(negs, value_type, single, multiple)
+                {dynamic?, [{domain_keys, value_type} | domain], single, multiple}
+              else
+                {dynamic?, [{domain_keys, value_type} | domain], single, multiple}
+              end
+
+            {pos, [], domain_keys} ->
+              domain =
+                case domain_keys do
+                  [] -> domain
+                  _ -> [{domain_keys, value_type} | domain]
+                end
+
+              case pos do
+                # Because a multiple key may override single keys, we can only
+                # collect single keys while there are no multiples.
+                [key] when multiple == [] ->
+                  {dynamic?, domain, [{key, value_type} | single], multiple}
+
+                _ ->
+                  {dynamic?, domain, single, [{pos, value_type} | multiple]}
+              end
+          end
+      end)
+
+    non_multiple = Enum.reverse(single, domain)
+
+    map =
+      case Enum.reverse(multiple) do
+        [] ->
+          closed_map(non_multiple)
+
+        [{keys, type} | tail] ->
+          for key <- keys, t <- cartesian_map(tail) do
+            closed_map(non_multiple ++ [{key, type} | t])
+          end
+          |> Enum.reduce(&union/2)
+      end
+
+    {if(dynamic?, do: dynamic(map), else: map), context}
+  end
+
+  defp union_negated([], new_type, single, multiple) do
+    single = Enum.map(single, fn {key, old_type} -> {key, union(old_type, new_type)} end)
+    multiple = Enum.map(multiple, fn {keys, old_type} -> {keys, union(old_type, new_type)} end)
+    {single, multiple}
+  end
+
+  defp union_negated(negated, new_type, single, multiple) do
+    {single, matched} =
+      Enum.map_reduce(single, [], fn {key, old_type}, matched ->
+        if key in negated do
+          {{key, old_type}, [key | matched]}
+        else
+          {{key, union(old_type, new_type)}, matched}
+        end
+      end)
+
+    multiple =
+      Enum.map(multiple, fn {keys, old_type} ->
+        {keys, union(old_type, new_type)}
+      end)
+
+    {Enum.map(negated -- matched, fn key -> {key, not_set()} end) ++ single, multiple}
+  end
+
+  defp pairs(pairs, expected, stack, context, of_fun) do
+    Enum.map_reduce(pairs, context, fn {key, value}, context ->
+      {pos_neg_domain, dynamic_key?, context} = map_key_type(key, stack, context, of_fun)
+
+      expected_value_type =
+        with {[key], [], []} <- pos_neg_domain,
+             {_, expected_value_type} <- map_fetch_key(expected, key) do
+          expected_value_type
+        else
+          _ -> term()
+        end
+
+      {value_type, context} = of_fun.(value, expected_value_type, stack, context)
+      {{pos_neg_domain, dynamic_key? or gradual?(value_type), value_type}, context}
+    end)
+  end
+
+  defp map_key_type(key, _stack, context, _of_fun) when is_atom(key) do
+    {{[key], [], []}, false, context}
+  end
+
+  defp map_key_type(key, stack, context, of_fun) do
+    {key_type, context} = of_fun.(key, term(), stack, context)
+    domain_keys = to_domain_keys(key_type)
+
+    pos_neg_domain =
+      case atom_fetch(key_type) do
+        {:finite, list} -> {list, [], List.delete(domain_keys, :atom)}
+        {:infinite, list} -> {[], list, domain_keys}
+        :error -> {[], [], domain_keys}
+      end
+
+    {pos_neg_domain, gradual?(key_type), context}
+  end
+
+  defp cartesian_map(lists) do
+    case lists do
+      [] ->
+        [[]]
+
+      [{keys, type} | tail] ->
+        for key <- keys, t <- cartesian_map(tail), do: [{key, type} | t]
+    end
+  end
+
+  @doc """
+  Handles instantiation of a new struct.
+  """
+  # TODO: Type check the fields match the struct
+  def struct_instance(struct, args, expected, meta, %{mode: mode} = stack, context, of_fun)
+      when is_atom(struct) do
+    {_info, context} = struct_info(struct, meta, stack, context)
+
+    # The compiler has already checked the keys are atoms and which ones are required.
+    {args_types, context} =
+      Enum.map_reduce(args, context, fn {key, value}, context when is_atom(key) ->
+        value_type =
+          with true <- mode != :traversal,
+               {_, expected_value_type} <- map_fetch_key(expected, key) do
+            expected_value_type
+          else
+            _ -> term()
+          end
+
+        {type, context} = of_fun.(value, value_type, stack, context)
+        {{key, type}, context}
+      end)
+
+    {closed_map([{:__struct__, atom([struct])} | args_types]), context}
+  end
+
+  @doc """
+  Returns `__info__(:struct)` information about a struct.
+  """
+  def struct_info(struct, meta, stack, context) do
+    case stack.no_warn_undefined do
+      %Macro.Env{} = env ->
+        case :elixir_map.maybe_load_struct_info(meta, struct, [], false, env) do
+          {:ok, info} -> {info, context}
+          {:error, desc} -> raise ArgumentError, List.to_string(:elixir_map.format_error(desc))
+        end
+
+      _ ->
+        # Fetch the signature to validate for warnings.
+        {_, context} = Module.Types.Apply.signature(struct, :__struct__, 0, meta, stack, context)
+
+        info =
+          struct.__info__(:struct) ||
+            raise "expected #{inspect(struct)} to return struct metadata, but got none"
+
+        {info, context}
+    end
+  end
+
+  @doc """
+  Builds a type from the struct info.
+  """
+  # TODO: This function should not receive args_types once
+  # we introduce typed structs. They are only used by exceptions.
+  def struct_type(struct, info, args_types \\ []) do
+    term = dynamic()
+    pairs = for %{field: field} <- info, do: {field, term}
+    pairs = [{:__struct__, atom([struct])} | pairs]
+    pairs = if args_types == [], do: pairs, else: pairs ++ args_types
+    closed_map(pairs)
+  end
+
+  ## Binary
+
+  @doc """
+  Handles binaries.
+
+  In the stack, we add nodes such as <<expr>>, <<..., expr>>, etc,
+  based on the position of the expression within the binary.
+  """
+  def binary([], _kind, _stack, context) do
+    context
+  end
+
+  def binary([head], kind, stack, context) do
+    binary_segment(head, kind, [head], stack, context)
+  end
+
+  def binary([head | tail], kind, stack, context) do
+    context = binary_segment(head, kind, [head, @suffix], stack, context)
+    binary_many(tail, kind, stack, context)
+  end
+
+  defp binary_many([last], kind, stack, context) do
+    binary_segment(last, kind, [@prefix, last], stack, context)
+  end
+
+  defp binary_many([head | tail], kind, stack, context) do
+    context = binary_segment(head, kind, [@prefix, head, @suffix], stack, context)
+    binary_many(tail, kind, stack, context)
+  end
+
+  # If the segment is a literal, the compiler has already checked its validity,
+  # so we just skip it.
+  defp binary_segment({:"::", _meta, [left, _right]}, _kind, _args, _stack, context)
+       when is_binary(left) or is_number(left) do
+    context
+  end
+
+  defp binary_segment({:"::", meta, [left, right]}, kind, args, stack, context) do
+    type = specifier_type(kind, right)
+    expr = {:<<>>, meta, args}
+
+    {actual, context} =
+      case kind do
+        :match ->
+          Module.Types.Pattern.of_match_var(left, type, expr, stack, context)
+
+        :guard ->
+          Module.Types.Pattern.of_guard(left, type, expr, stack, context)
+
+        :expr ->
+          left = annotate_interpolation(left, right)
+          Module.Types.Expr.of_expr(left, type, expr, stack, context)
+      end
+
+    if compatible?(actual, type) do
+      specifier_size(kind, right, stack, context)
+    else
+      error = {:badbinary, kind, meta, expr, type, actual, context}
+      error(error, meta, stack, context)
+    end
+  end
+
+  defp annotate_interpolation(
+         {{:., _, [String.Chars, :to_string]} = dot, meta, [arg]},
+         {:binary, _, nil}
+       ) do
+    {dot, [type_check: :interpolation] ++ meta, [arg]}
+  end
+
+  defp annotate_interpolation(left, _right) do
+    left
+  end
+
+  defp specifier_type(kind, {:-, _, [left, _right]}), do: specifier_type(kind, left)
+  defp specifier_type(:match, {:utf8, _, _}), do: @integer
+  defp specifier_type(:match, {:utf16, _, _}), do: @integer
+  defp specifier_type(:match, {:utf32, _, _}), do: @integer
+  defp specifier_type(:match, {:float, _, _}), do: @float
+  defp specifier_type(_kind, {:float, _, _}), do: @integer_or_float
+  defp specifier_type(_kind, {:utf8, _, _}), do: @integer_or_binary
+  defp specifier_type(_kind, {:utf16, _, _}), do: @integer_or_binary
+  defp specifier_type(_kind, {:utf32, _, _}), do: @integer_or_binary
+  defp specifier_type(_kind, {:integer, _, _}), do: @integer
+  defp specifier_type(_kind, {:bits, _, _}), do: @binary
+  defp specifier_type(_kind, {:bitstring, _, _}), do: @binary
+  defp specifier_type(_kind, {:bytes, _, _}), do: @binary
+  defp specifier_type(_kind, {:binary, _, _}), do: @binary
+  defp specifier_type(_kind, _specifier), do: @integer
+
+  defp specifier_size(kind, {:-, _, [left, right]}, stack, context) do
+    specifier_size(kind, right, stack, specifier_size(kind, left, stack, context))
+  end
+
+  defp specifier_size(:expr, {:size, _, [arg]} = expr, stack, context)
+       when not is_integer(arg) do
+    {actual, context} = Module.Types.Expr.of_expr(arg, integer(), expr, stack, context)
+    compatible_size(actual, expr, stack, context)
+  end
+
+  defp specifier_size(_pattern_or_guard, {:size, _, [arg]} = expr, stack, context)
+       when not is_integer(arg) do
+    {actual, context} = Module.Types.Pattern.of_guard(arg, integer(), expr, stack, context)
+    compatible_size(actual, expr, stack, context)
+  end
+
+  defp specifier_size(_kind, _specifier, _stack, context) do
+    context
+  end
+
+  defp compatible_size(actual, expr, stack, context) do
+    if compatible?(actual, integer()) do
+      context
+    else
+      error = {:badsize, expr, actual, context}
+      error(error, elem(expr, 1), stack, context)
+    end
+  end
+
+  ## Modules
+
+  @doc """
+  Returns modules in a type.
+
+  The call information is used on report reporting.
+  """
+  def modules(type, fun, arity, hints \\ [], expr, meta, stack, context) do
+    case atom_fetch(type) do
+      {:finite, mods} ->
+        {mods, context}
+
+      {:infinite, _} ->
+        {[], context}
+
+      :error ->
+        warning = {:badmodule, expr, type, fun, arity, hints, context}
+        {[], error(warning, meta, stack, context)}
+    end
+  end
+
+  ## Warning
+
+  defp error(warning, meta, stack, context) do
+    error(__MODULE__, warning, meta, stack, context)
+  end
+
+  def format_diagnostic({:refine_head_var, old_type, new_type, var, context}) do
+    traces = collect_traces(var, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          incompatible types assigned to #{format_var(var)}:
+
+              #{to_quoted_string(old_type)} !~ #{to_quoted_string(new_type)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  def format_diagnostic({:badbinary, kind, meta, expr, expected_type, actual_type, context}) do
+    type = if kind == :match, do: "matching", else: "construction"
+    hints = if meta[:inferred_bitstring_spec], do: [:inferred_bitstring_spec], else: []
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          incompatible types in binary #{type}:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          got type:
+
+              #{to_quoted_string(actual_type) |> indent(4)}
+
+          but expected type:
+
+              #{to_quoted_string(expected_type) |> indent(4)}
+          """,
+          format_traces(traces),
+          format_hints(hints)
+        ])
+    }
+  end
+
+  def format_diagnostic({:badsize, expr, type, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected an integer in binary size:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  def format_diagnostic({:badmodule, expr, type, fun, arity, hints, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected a module (an atom) when invoking #{fun}/#{arity} in expression:
+
+              #{expr_to_string(expr) |> indent(4)}
+          """,
+          empty_if(dot_var?(expr), """
+
+          but got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """),
+          format_traces(traces),
+          format_hints(hints)
+        ])
+    }
+  end
+
+  def format_diagnostic({:badmap, expr, type, key, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected a map or struct when accessing .#{key} in expression:
+
+              #{expr_to_string(expr) |> indent(4)}
+          """,
+          empty_if(dot_var?(expr), """
+
+          but got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """),
+          format_traces(traces),
+          format_hints([:dot])
+        ])
+    }
+  end
+
+  def format_diagnostic({:badkey, expr, type, key, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      span: expr |> get_meta() |> :elixir_env.calculate_span(key) |> Keyword.get(:span),
+      message:
+        IO.iodata_to_binary([
+          """
+          unknown key .#{key} in expression:
+
+              #{expr_to_string(expr, collapse_structs: false) |> indent(4)}
+
+          the given type does not have the given key:
+
+              #{to_quoted_string(type, collapse_structs: false) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  defp dot_var?(expr) do
+    match?({{:., _, [var, _fun]}, _, _args} when is_var(var), expr)
+  end
+
+  defp empty_if(condition, content) do
+    if condition, do: "", else: content
+  end
+end
diff --git a/lib/elixir/lib/module/types/pattern.ex b/lib/elixir/lib/module/types/pattern.ex
new file mode 100644
index 00000000000..ecfca9fd642
--- /dev/null
+++ b/lib/elixir/lib/module/types/pattern.ex
@@ -0,0 +1,907 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Module.Types.Pattern do
+  @moduledoc false
+
+  alias Module.Types.{Apply, Of}
+  import Module.Types.{Helpers, Descr}
+
+  @guard atom([true, false, :fail])
+
+  @doc """
+  Handles patterns and guards at once.
+
+  The algorithm works as follows:
+
+  1. First we traverse the patterns and build a pattern tree
+     (which tells how to compute the type of a pattern) alongside
+     the variable trees (which tells us how to compute the type
+     of a variable).
+
+  2. Then we traverse the pattern tree and compute the intersection
+     between the pattern and the expected types (which is currently dynamic).
+
+  3. Then we compute the values for each variable.
+
+  4. Then we refine the variables inside guards. If any variable
+     is refined, we restart at step 2.
+
+  """
+  def of_head(patterns, _guards, _expected, _tag, _meta, %{mode: :traversal}, context) do
+    term = term()
+    {Enum.map(patterns, &{&1, term}), context}
+  end
+
+  def of_head(patterns, guards, expected, tag, meta, stack, context) do
+    stack = %{stack | meta: meta}
+
+    {trees, context} = of_pattern_args(patterns, expected, tag, stack, context)
+    {_, context} = Enum.map_reduce(guards, context, &of_guard(&1, @guard, &1, stack, &2))
+    {trees, context}
+  end
+
+  @doc """
+  Computes the domain from the pattern tree and expected types.
+  """
+  def of_domain([{_pattern, tree} | trees], [type | expected], context) do
+    [intersection(of_pattern_tree(tree, context), type) | of_domain(trees, expected, context)]
+  end
+
+  def of_domain([], [], _context) do
+    []
+  end
+
+  defp of_pattern_args([], [], _tag, _stack, context) do
+    {[], context}
+  end
+
+  defp of_pattern_args(patterns, expected, tag, stack, context) do
+    context = init_pattern_info(context)
+    {trees, context} = of_pattern_args_index(patterns, 0, [], stack, context)
+    {pattern_info, context} = pop_pattern_info(context)
+
+    {_, context} =
+      of_pattern_recur(expected, tag, pattern_info, stack, context, fn types, changed, context ->
+        of_pattern_args_tree(trees, types, changed, 0, [], tag, stack, context)
+      end)
+
+    {trees, context}
+  end
+
+  defp of_pattern_args_index([pattern | tail], index, acc, stack, context) do
+    {tree, context} = of_pattern(pattern, [{:arg, index, pattern}], stack, context)
+    acc = [{pattern, tree} | acc]
+    of_pattern_args_index(tail, index + 1, acc, stack, context)
+  end
+
+  defp of_pattern_args_index([], _index, acc, _stack, context),
+    do: {Enum.reverse(acc), context}
+
+  defp of_pattern_args_tree(
+         [{pattern, tree} | tail],
+         [type | expected_types],
+         [index | changed],
+         index,
+         acc,
+         tag,
+         stack,
+         context
+       ) do
+    with {:ok, type, context} <-
+           of_pattern_intersect(tree, type, pattern, index, tag, stack, context) do
+      acc = [type | acc]
+      of_pattern_args_tree(tail, expected_types, changed, index + 1, acc, tag, stack, context)
+    end
+  end
+
+  defp of_pattern_args_tree(
+         [_ | tail],
+         [type | expected_types],
+         changed,
+         index,
+         acc,
+         tag,
+         stack,
+         context
+       ) do
+    acc = [type | acc]
+    of_pattern_args_tree(tail, expected_types, changed, index + 1, acc, tag, stack, context)
+  end
+
+  defp of_pattern_args_tree([], [], [], _index, acc, _tag, _stack, context) do
+    {:ok, Enum.reverse(acc), context}
+  end
+
+  @doc """
+  Handles the match operator.
+  """
+  def of_match(pattern, expected_fun, expr, stack, context)
+
+  def of_match(_pattern, expected_fun, _expr, %{mode: :traversal}, context) do
+    expected_fun.(dynamic(), context)
+  end
+
+  def of_match(pattern, expected_fun, expr, stack, context) do
+    context = init_pattern_info(context)
+    {tree, context} = of_pattern(pattern, [{:arg, 0, expr}], stack, context)
+    {pattern_info, context} = pop_pattern_info(context)
+    {expected, context} = expected_fun.(of_pattern_tree(tree, context), context)
+    tag = {:match, expected}
+
+    {[type], context} =
+      of_single_pattern_recur(expected, tag, tree, pattern_info, expr, stack, context)
+
+    {type, context}
+  end
+
+  @doc """
+  Handles matches in generators.
+  """
+  def of_generator(pattern, guards, expected, tag, expr, stack, context)
+
+  def of_generator(_pattern, _guards, _expected, _tag, _expr, %{mode: :traversal}, context) do
+    context
+  end
+
+  def of_generator(pattern, guards, expected, tag, expr, stack, context) do
+    context = init_pattern_info(context)
+    {tree, context} = of_pattern(pattern, [{:arg, 0, expr}], stack, context)
+    {pattern_info, context} = pop_pattern_info(context)
+
+    {_, context} =
+      of_single_pattern_recur(expected, tag, tree, pattern_info, expr, stack, context)
+
+    {_, context} = Enum.map_reduce(guards, context, &of_guard(&1, @guard, &1, stack, &2))
+    context
+  end
+
+  defp of_single_pattern_recur(expected, tag, tree, pattern_info, expr, stack, context) do
+    of_pattern_recur([expected], tag, pattern_info, stack, context, fn [type], [0], context ->
+      with {:ok, type, context} <-
+             of_pattern_intersect(tree, type, expr, 0, tag, stack, context) do
+        {:ok, [type], context}
+      end
+    end)
+  end
+
+  defp all_single_path?(vars, info, index) do
+    info
+    |> Map.get(index, [])
+    |> Enum.all?(fn version -> match?([_], Map.fetch!(vars, version)) end)
+  end
+
+  defp of_pattern_recur(types, tag, pattern_info, stack, context, callback) do
+    {vars, info, _counter} = pattern_info
+    changed = :lists.seq(0, length(types) - 1)
+
+    # If all variables in a given index have a single path,
+    # then there are no changes to propagate
+    unchangeable = for index <- changed, all_single_path?(vars, info, index), do: index
+    vars = Map.to_list(vars)
+
+    try do
+      case callback.(types, changed, context) do
+        {:ok, types, context} ->
+          of_pattern_recur(types, unchangeable, vars, info, tag, stack, context, callback)
+
+        {:error, context} ->
+          {types, error_vars(vars, context)}
+      end
+    catch
+      {types, context} -> {types, error_vars(vars, context)}
+    end
+  end
+
+  defp of_pattern_recur(types, unchangeable, vars, info, tag, stack, context, callback) do
+    {changed, context} =
+      Enum.reduce(vars, {[], context}, fn {version, paths}, {changed, context} ->
+        {var_changed?, context} =
+          Enum.reduce(paths, {false, context}, fn
+            [var, {:arg, index, expr} | path], {var_changed?, context} ->
+              actual = Enum.fetch!(types, index)
+
+              case of_pattern_var(path, actual, true, info, context) do
+                {type, reachable_var?} ->
+                  # Optimization: if current type is already a subtype, there is nothing to refine.
+                  with %{^version => %{type: current_type}} <- context.vars,
+                       true <- subtype?(current_type, type) do
+                    {var_changed?, context}
+                  else
+                    _ ->
+                      case Of.refine_head_var(var, type, expr, stack, context) do
+                        {:ok, _type, context} -> {var_changed? or reachable_var?, context}
+                        {:error, _type, context} -> throw({types, context})
+                      end
+                  end
+
+                :error ->
+                  throw({types, badpattern_error(expr, index, tag, stack, context)})
+              end
+          end)
+
+        case var_changed? do
+          false ->
+            {changed, context}
+
+          true ->
+            var_changed = Enum.map(paths, fn [_var, {:arg, index, _} | _] -> index end)
+            {var_changed ++ changed, context}
+        end
+      end)
+
+    case :lists.usort(changed) -- unchangeable do
+      [] ->
+        {types, context}
+
+      changed ->
+        case callback.(types, changed, context) do
+          # A simple structural comparison for optimization
+          {:ok, ^types, context} ->
+            {types, context}
+
+          {:ok, types, context} ->
+            of_pattern_recur(types, unchangeable, vars, info, tag, stack, context, callback)
+
+          {:error, context} ->
+            {types, error_vars(vars, context)}
+        end
+    end
+  end
+
+  defp error_vars(vars, context) do
+    Enum.reduce(vars, context, fn {_version, [[var | _path] | _paths]}, context ->
+      Of.error_var(var, context)
+    end)
+  end
+
+  defp badpattern_error(expr, index, tag, stack, context) do
+    meta =
+      if meta = get_meta(expr) do
+        meta ++ Keyword.take(stack.meta, [:generated, :line, :type_check])
+      else
+        stack.meta
+      end
+
+    error(__MODULE__, {:badpattern, meta, expr, index, tag, context}, meta, stack, context)
+  end
+
+  defp of_pattern_intersect(tree, expected, expr, index, tag, stack, context) do
+    actual = of_pattern_tree(tree, context)
+    type = intersection(actual, expected)
+
+    if empty?(type) do
+      {:error, badpattern_error(expr, index, tag, stack, context)}
+    else
+      {:ok, type, context}
+    end
+  end
+
+  defp of_pattern_var([], type, reachable_var?, _info, _context) do
+    {type, reachable_var?}
+  end
+
+  defp of_pattern_var([{:elem, index} | rest], type, reachable_var?, info, context)
+       when is_integer(index) do
+    case tuple_fetch(type, index) do
+      {_optional?, type} -> of_pattern_var(rest, type, reachable_var?, info, context)
+      _reason -> :error
+    end
+  end
+
+  defp of_pattern_var([{:key, field} | rest], type, reachable_var?, info, context)
+       when is_atom(field) do
+    case map_fetch_key(type, field) do
+      {_optional?, type} -> of_pattern_var(rest, type, reachable_var?, info, context)
+      _reason -> :error
+    end
+  end
+
+  # TODO: Implement domain key types
+  defp of_pattern_var([{:key, _key} | rest], _type, _reachable_var?, info, context) do
+    of_pattern_var(rest, dynamic(), false, info, context)
+  end
+
+  defp of_pattern_var([{:head, counter} | rest], type, _reachable_var?, info, context) do
+    case list_hd(type) do
+      {:ok, head} ->
+        tree = Map.fetch!(info, -counter)
+        type = intersection(of_pattern_tree(tree, context), head)
+        of_pattern_var(rest, type, false, info, context)
+
+      _ ->
+        :error
+    end
+  end
+
+  defp of_pattern_var([:tail | rest], type, reachable_var?, info, context) do
+    case list_tl(type) do
+      {:ok, tail} -> of_pattern_var(rest, tail, reachable_var?, info, context)
+      :badnonemptylist -> :error
+    end
+  end
+
+  @doc """
+  Receives the pattern tree and the context and returns a concrete type.
+  """
+  def of_pattern_tree(descr, _context) when is_descr(descr),
+    do: descr
+
+  def of_pattern_tree({:tuple, entries}, context) do
+    tuple(Enum.map(entries, &of_pattern_tree(&1, context)))
+  end
+
+  def of_pattern_tree({:open_map, static, dynamic}, context) do
+    dynamic = Enum.map(dynamic, fn {key, value} -> {key, of_pattern_tree(value, context)} end)
+    open_map(static ++ dynamic)
+  end
+
+  def of_pattern_tree({:closed_map, static, dynamic}, context) do
+    dynamic = Enum.map(dynamic, fn {key, value} -> {key, of_pattern_tree(value, context)} end)
+    closed_map(static ++ dynamic)
+  end
+
+  def of_pattern_tree({:non_empty_list, [head | tail], suffix}, context) do
+    tail
+    |> Enum.reduce(of_pattern_tree(head, context), &union(of_pattern_tree(&1, context), &2))
+    |> non_empty_list(of_pattern_tree(suffix, context))
+  end
+
+  def of_pattern_tree({:intersection, entries}, context) do
+    entries
+    |> Enum.map(&of_pattern_tree(&1, context))
+    |> Enum.reduce(&intersection/2)
+  end
+
+  def of_pattern_tree({:var, version}, context) do
+    case context do
+      %{vars: %{^version => %{type: type}}} -> type
+      _ -> term()
+    end
+  end
+
+  @doc """
+  Function used to assign a type to a variable. Used by %struct{}
+  and binary patterns.
+
+  Given those values are actually checked at compile-time,
+  except for the variables, that's the only scenario we need to handle.
+  """
+  def of_match_var({:_, _, _}, expected, _expr, _stack, context) do
+    {expected, context}
+  end
+
+  def of_match_var(var, expected, expr, stack, context) when is_var(var) do
+    {_ok?, type, context} = Of.refine_head_var(var, expected, expr, stack, context)
+    {type, context}
+  end
+
+  def of_match_var({:<<>>, _meta, args}, _expected, _expr, stack, context) do
+    {binary(), Of.binary(args, :match, stack, context)}
+  end
+
+  def of_match_var(ast, expected, expr, stack, context) do
+    of_guard(ast, expected, expr, stack, context)
+  end
+
+  ## Patterns
+
+  # :atom
+  defp of_pattern(atom, _path, _stack, context) when is_atom(atom),
+    do: {atom([atom]), context}
+
+  # 12
+  defp of_pattern(literal, _path, _stack, context) when is_integer(literal),
+    do: {integer(), context}
+
+  # 1.2
+  defp of_pattern(literal, _path, _stack, context) when is_float(literal),
+    do: {float(), context}
+
+  # "..."
+  defp of_pattern(literal, _path, _stack, context) when is_binary(literal),
+    do: {binary(), context}
+
+  # []
+  defp of_pattern([], _path, _stack, context),
+    do: {empty_list(), context}
+
+  # [expr, ...]
+  defp of_pattern(list, path, stack, context) when is_list(list) do
+    {prefix, suffix} = unpack_list(list, [])
+    of_list(prefix, suffix, path, stack, context)
+  end
+
+  # {left, right}
+  defp of_pattern({left, right}, path, stack, context) do
+    of_tuple([left, right], path, stack, context)
+  end
+
+  # left = right
+  defp of_pattern({:=, _meta, [_, _]} = match, path, stack, context) do
+    result =
+      match
+      |> unpack_match([])
+      |> Enum.reduce({[], [], context}, fn pattern, {static, dynamic, context} ->
+        {type, context} = of_pattern(pattern, path, stack, context)
+
+        if is_descr(type) do
+          {[type | static], dynamic, context}
+        else
+          {static, [type | dynamic], context}
+        end
+      end)
+
+    case result do
+      {[], dynamic, context} ->
+        {{:intersection, dynamic}, context}
+
+      {static, [], context} ->
+        {Enum.reduce(static, &intersection/2), context}
+
+      {static, dynamic, context} ->
+        {{:intersection, [Enum.reduce(static, &intersection/2) | dynamic]}, context}
+    end
+  end
+
+  # %Struct{...}
+  # TODO: Once we support typed structs, we need to type check them here.
+  defp of_pattern({:%, meta, [struct, {:%{}, _, args}]}, path, stack, context)
+       when is_atom(struct) do
+    {info, context} = Of.struct_info(struct, meta, stack, context)
+
+    {pairs, context} =
+      Enum.map_reduce(args, context, fn {key, value}, context ->
+        {value_type, context} = of_pattern(value, [{:key, key} | path], stack, context)
+        # TODO: We need to assume that these are dynamic until we have typed structs.
+        {{key, value_type}, context}
+      end)
+
+    pairs = Map.new(pairs)
+    term = term()
+    static = [__struct__: atom([struct])]
+    dynamic = []
+
+    {static, dynamic} =
+      Enum.reduce(info, {static, dynamic}, fn %{field: field}, {static, dynamic} ->
+        case pairs do
+          %{^field => value_type} when is_descr(value_type) ->
+            {[{field, value_type} | static], dynamic}
+
+          %{^field => value_type} ->
+            {static, [{field, value_type} | dynamic]}
+
+          _ ->
+            {[{field, term} | static], dynamic}
+        end
+      end)
+
+    if dynamic == [] do
+      {closed_map(static), context}
+    else
+      {{:closed_map, static, dynamic}, context}
+    end
+  end
+
+  # %var{...}
+  defp of_pattern({:%, _, [{name, _, ctx} = var, {:%{}, _, args}]}, path, stack, context)
+       when is_atom(name) and is_atom(ctx) and name != :_ do
+    {var, context} = of_pattern(var, [{:key, :__struct__} | path], stack, context)
+    dynamic = [__struct__: {:intersection, [atom(), var]}]
+    of_open_map(args, [], dynamic, path, stack, context)
+  end
+
+  # %^var{...} and %_{...}
+  defp of_pattern(
+         {:%, meta, [var, {:%{}, _meta2, args}]} = expr,
+         path,
+         stack,
+         context
+       ) do
+    {refined, context} = of_match_var(var, atom(), expr, stack, context)
+
+    if compatible?(refined, atom()) do
+      of_open_map(args, [__struct__: refined], [], path, stack, context)
+    else
+      error = {:badstruct, refined, expr, context}
+      {error_type(), error(__MODULE__, error, meta, stack, context)}
+    end
+  end
+
+  # %{...}
+  defp of_pattern({:%{}, _meta, args}, path, stack, context) do
+    of_open_map(args, [], [], path, stack, context)
+  end
+
+  # <<...>>>
+  defp of_pattern({:<<>>, _meta, args}, _path, stack, context) do
+    context = Of.binary(args, :match, stack, context)
+    {binary(), context}
+  end
+
+  # left ++ right
+  defp of_pattern({{:., _meta1, [:erlang, :++]}, _meta2, [left, right]}, path, stack, context) do
+    of_list(left, right, path, stack, context)
+  end
+
+  # {...}
+  defp of_pattern({:{}, _meta, args}, path, stack, context) do
+    of_tuple(args, path, stack, context)
+  end
+
+  # ^var
+  defp of_pattern({:^, _meta, [var]}, _path, _stack, context) do
+    {Of.var(var, context), context}
+  end
+
+  # _
+  defp of_pattern({:_, _meta, _var_context}, _path, _stack, context) do
+    {term(), context}
+  end
+
+  # var
+  defp of_pattern({name, meta, ctx} = var, reverse_path, _stack, context)
+       when is_atom(name) and is_atom(ctx) do
+    version = Keyword.fetch!(meta, :version)
+    [{:arg, arg, _pattern} | _] = path = Enum.reverse(reverse_path)
+    {vars, info, counter} = context.pattern_info
+
+    paths = [[var | path] | Map.get(vars, version, [])]
+    vars = Map.put(vars, version, paths)
+
+    # Stores all variables used at any given argument
+    info = Map.update(info, arg, [version], &[version | &1])
+    {{:var, version}, %{context | pattern_info: {vars, info, counter}}}
+  end
+
+  # TODO: Properly traverse domain keys
+  # TODO: Properly handle pin operator in keys
+  defp of_open_map(args, static, dynamic, path, stack, context) do
+    {static, dynamic, context} =
+      Enum.reduce(args, {static, dynamic, context}, fn {key, value}, {static, dynamic, context} ->
+        {value_type, context} = of_pattern(value, [{:key, key} | path], stack, context)
+
+        cond do
+          # Only atom keys become part of the type because the other keys are divisible
+          not is_atom(key) ->
+            {static, dynamic, context}
+
+          is_descr(value_type) ->
+            {[{key, value_type} | static], dynamic, context}
+
+          true ->
+            {static, [{key, value_type} | dynamic], context}
+        end
+      end)
+
+    case dynamic do
+      [] -> {open_map(static), context}
+      _ -> {{:open_map, static, dynamic}, context}
+    end
+  end
+
+  defp of_tuple(args, path, stack, context) do
+    {_index, static?, entries, context} =
+      Enum.reduce(args, {0, true, [], context}, fn arg, {index, static?, acc, context} ->
+        {type, context} = of_pattern(arg, [{:elem, index} | path], stack, context)
+        {index + 1, static? and is_descr(type), [type | acc], context}
+      end)
+
+    case static? do
+      true -> {tuple(Enum.reverse(entries)), context}
+      false -> {{:tuple, Enum.reverse(entries)}, context}
+    end
+  end
+
+  # [] ++ []
+  defp of_list([], [], _path, _stack, context) do
+    {empty_list(), context}
+  end
+
+  # [] ++ suffix
+  defp of_list([], suffix, path, stack, context) do
+    of_pattern(suffix, path, stack, context)
+  end
+
+  # [prefix1, prefix2, prefix3], [prefix1, prefix2 | suffix]
+  defp of_list(prefix, suffix, path, stack, context) do
+    {suffix, context} = of_pattern(suffix, [:tail | path], stack, context)
+    {vars, info, counter} = context.pattern_info
+    context = %{context | pattern_info: {vars, info, counter + length(prefix)}}
+
+    {static, dynamic, info, context} =
+      Enum.reduce(prefix, {[], [], %{}, context}, fn
+        arg, {static, dynamic, info, context}
+        when is_number(arg) or is_atom(arg) or is_binary(arg) or arg == [] ->
+          {type, context} = of_pattern(arg, [], stack, context)
+          {[type | static], dynamic, info, context}
+
+        arg, {static, dynamic, info, context} ->
+          counter = map_size(info) + counter
+          {type, context} = of_pattern(arg, [{:head, counter} | path], stack, context)
+          info = Map.put(info, -counter, type)
+
+          if is_descr(type) do
+            {[type | static], dynamic, info, context}
+          else
+            {static, [type | dynamic], info, context}
+          end
+      end)
+
+    context =
+      if info != %{} do
+        update_in(context.pattern_info, fn {acc_vars, acc_info, acc_counter} ->
+          {acc_vars, Map.merge(acc_info, info), acc_counter}
+        end)
+      else
+        context
+      end
+
+    case {static, dynamic} do
+      {static, []} when is_descr(suffix) ->
+        {non_empty_list(Enum.reduce(static, &union/2), suffix), context}
+
+      {[], dynamic} ->
+        {{:non_empty_list, dynamic, suffix}, context}
+
+      {static, dynamic} ->
+        {{:non_empty_list, [Enum.reduce(static, &union/2) | dynamic], suffix}, context}
+    end
+  end
+
+  ## Guards
+  # This function is public as it is invoked from Of.binary/4.
+
+  # :atom
+  def of_guard(atom, _expected, _expr, _stack, context) when is_atom(atom) do
+    {atom([atom]), context}
+  end
+
+  # 12
+  def of_guard(literal, _expected, _expr, _stack, context) when is_integer(literal) do
+    {integer(), context}
+  end
+
+  # 1.2
+  def of_guard(literal, _expected, _expr, _stack, context) when is_float(literal) do
+    {float(), context}
+  end
+
+  # "..."
+  def of_guard(literal, _expected, _expr, _stack, context) when is_binary(literal) do
+    {binary(), context}
+  end
+
+  # []
+  def of_guard([], _expected, _expr, _stack, context) do
+    {empty_list(), context}
+  end
+
+  # [expr, ...]
+  def of_guard(list, _expected, expr, stack, context) when is_list(list) do
+    {prefix, suffix} = unpack_list(list, [])
+
+    {prefix, context} =
+      Enum.map_reduce(prefix, context, &of_guard(&1, term(), expr, stack, &2))
+
+    {suffix, context} = of_guard(suffix, term(), expr, stack, context)
+    {non_empty_list(Enum.reduce(prefix, &union/2), suffix), context}
+  end
+
+  # {left, right}
+  def of_guard({left, right}, expected, expr, stack, context) do
+    of_guard({:{}, [], [left, right]}, expected, expr, stack, context)
+  end
+
+  # %Struct{...}
+  def of_guard({:%, meta, [module, {:%{}, _, args}]} = struct, expected, _expr, stack, context)
+      when is_atom(module) do
+    fun = &of_guard(&1, &2, struct, &3, &4)
+    Of.struct_instance(module, args, expected, meta, stack, context, fun)
+  end
+
+  # %{...}
+  def of_guard({:%{}, _meta, args}, expected, expr, stack, context) do
+    Of.closed_map(args, expected, stack, context, &of_guard(&1, &2, expr, &3, &4))
+  end
+
+  # <<>>
+  def of_guard({:<<>>, _meta, args}, _expected, _expr, stack, context) do
+    context = Of.binary(args, :guard, stack, context)
+    {binary(), context}
+  end
+
+  # ^var
+  def of_guard({:^, _meta, [var]}, expected, expr, stack, context) do
+    # This is used by binary size, which behaves as a mixture of match and guard
+    Of.refine_body_var(var, expected, expr, stack, context)
+  end
+
+  # {...}
+  def of_guard({:{}, _meta, args}, _expected, expr, stack, context) do
+    {types, context} = Enum.map_reduce(args, context, &of_guard(&1, term(), expr, stack, &2))
+    {tuple(types), context}
+  end
+
+  # var.field
+  def of_guard({{:., _, [callee, key]}, _, []} = map_fetch, _expected, expr, stack, context)
+      when not is_atom(callee) do
+    {type, context} = of_guard(callee, term(), expr, stack, context)
+    Of.map_fetch(map_fetch, type, key, stack, context)
+  end
+
+  # Comparison operators
+  def of_guard({{:., _, [:erlang, function]}, _, args}, _expected, expr, stack, context)
+      when function in [:==, :"/=", :"=:=", :"=/="] do
+    {_args_type, context} =
+      Enum.map_reduce(args, context, &of_guard(&1, term(), expr, stack, &2))
+
+    {boolean(), context}
+  end
+
+  # Remote
+  def of_guard({{:., _, [:erlang, fun]}, meta, args} = call, expected, _expr, stack, context)
+      when is_atom(fun) do
+    {info, domain, context} =
+      Apply.remote_domain(:erlang, fun, args, expected, meta, stack, context)
+
+    {args_types, context} =
+      zip_map_reduce(args, domain, context, &of_guard(&1, &2, call, stack, &3))
+
+    Apply.remote_apply(info, :erlang, fun, args_types, call, stack, context)
+  end
+
+  # var
+  def of_guard(var, _expected, _expr, _stack, context) when is_var(var) do
+    {Of.var(var, context), context}
+  end
+
+  ## Helpers
+
+  # pattern_info stores the variables defined in patterns,
+  # additional information about the number of variables in
+  # arguments and list heads, and a counter used to compute
+  # the number of list heads.
+  defp init_pattern_info(context) do
+    %{context | pattern_info: {%{}, %{}, 1}}
+  end
+
+  defp pop_pattern_info(%{pattern_info: pattern_info} = context) do
+    {pattern_info, %{context | pattern_info: nil}}
+  end
+
+  def format_diagnostic({:badstruct, type, expr, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected an atom as struct name:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  # $ type tag = head_pattern() or match_pattern()
+  #
+  # $ typep head_pattern =
+  #     :for_reduce or :with_else or :receive or :try_catch or :fn or :default or
+  #       {:try_else, type} or {:case, meta, type, expr}
+  #
+  # $ typep match_pattern =
+  #     :with or :for or {:match, type}
+  #
+  # The match pattern ones have the whole expression instead
+  # of a single pattern.
+  def format_diagnostic({:badpattern, meta, pattern_or_expr, index, tag, context}) do
+    {to_trace, message} = badpattern(tag, pattern_or_expr, index)
+    traces = collect_traces(to_trace, context)
+
+    hints =
+      case Keyword.get(meta, :type_check) do
+        {:impl, _} = impl -> [impl]
+        _ -> []
+      end
+
+    %{
+      details: %{typing_traces: traces},
+      message: IO.iodata_to_binary([message, format_traces(traces), format_hints(hints)])
+    }
+  end
+
+  defp badpattern({:try_else, type}, pattern, _) do
+    {pattern,
+     """
+     the following clause will never match:
+
+         #{expr_to_string(pattern) |> indent(4)}
+
+     it attempts to match on the result of the try do-block which has incompatible type:
+
+         #{to_quoted_string(type) |> indent(4)}
+     """}
+  end
+
+  defp badpattern({:case, meta, type, expr}, pattern, _) do
+    if meta[:type_check] == :expr do
+      {expr,
+       """
+       the following conditional expression will always evaluate to #{to_quoted_string(type)}:
+
+           #{expr_to_string(expr) |> indent(4)}
+       """}
+    else
+      {pattern,
+       """
+       the following clause will never match:
+
+           #{expr_to_string(pattern) |> indent(4)}
+
+       because it attempts to match on the result of:
+
+           #{expr_to_string(expr) |> indent(4)}
+
+       which has type:
+
+           #{to_quoted_string(type) |> indent(4)}
+       """}
+    end
+  end
+
+  defp badpattern({:match, type}, expr, _) do
+    {expr,
+     """
+     the following pattern will never match:
+
+         #{expr_to_string(expr) |> indent(4)}
+
+     because the right-hand side has type:
+
+         #{to_quoted_string(type) |> indent(4)}
+     """}
+  end
+
+  defp badpattern({:infer, types}, pattern_or_expr, index) do
+    type = Enum.fetch!(types, index)
+
+    if type == dynamic() do
+      {pattern_or_expr,
+       """
+       the #{integer_to_ordinal(index + 1)} pattern in clause will never match:
+
+           #{expr_to_string(pattern_or_expr) |> indent(4)}
+       """}
+    else
+      # This can only happen in protocol implementations
+      {pattern_or_expr,
+       """
+       the #{integer_to_ordinal(index + 1)} pattern in clause will never match:
+
+           #{expr_to_string(pattern_or_expr) |> indent(4)}
+
+       because it is expected to receive type:
+
+           #{to_quoted_string(type) |> indent(4)}
+       """}
+    end
+  end
+
+  defp badpattern(_, pattern_or_expr, _) do
+    {pattern_or_expr,
+     """
+     the following pattern will never match:
+
+         #{expr_to_string(pattern_or_expr) |> indent(4)}
+     """}
+  end
+end
diff --git a/lib/elixir/lib/node.ex b/lib/elixir/lib/node.ex
index 9b52e451f0c..f2b6c0401fa 100644
--- a/lib/elixir/lib/node.ex
+++ b/lib/elixir/lib/node.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Node do
   @moduledoc """
   Functions related to VM nodes.
@@ -13,12 +17,74 @@ defmodule Node do
   @doc """
   Turns a non-distributed node into a distributed node.
 
-  This functionality starts the `:net_kernel` and other
-  related processes.
+  This functionality starts the `:net_kernel` and other related
+  processes.
+
+  This function is rarely invoked in practice. Instead, nodes are
+  named and started via the command line by using the `--sname` and
+  `--name` flags. If you need to use this function to dynamically
+  name a node, please make sure the `epmd` operating system process
+  is running by calling `epmd -daemon`, such as `System.cmd("epmd", ["-daemon"])`.
+
+  Invoking this function when the distribution has already been started,
+  either via the command line interface or dynamically, will return an
+  error.
+
+  ## Examples
+
+      {:ok, pid} = Node.start(:example, name_domain: :shortnames, hidden: true)
+
+  ## Options
+
+  Currently supported options are:
+
+  * `:name_domain` - determines the host name part of the node name. If `:longnames`,
+    fully qualified domain names will be   used which also is the default.
+    If `:shortnames`, only the short name of the host will be used.
+
+  * `:net_ticktime` - The tick time to use in seconds. Defaults to the value of the
+    `net_ticktime` configuration under Erlang's `kernel` application.
+    See [the `kernel` documentation](https://www.erlang.org/doc/apps/kernel/kernel_app.html)
+    for more information.
+
+  * `net_tickintensity` - The tick intensity to use. Defaults to the value of the
+    `net_tickintensity` configuration under Erlang's `kernel` application.
+    See [the `kernel` documentation](https://www.erlang.org/doc/apps/kernel/kernel_app.html)
+    for more information.
+
+  * `:dist_listen` - Enable or disable listening for incoming connections.
+    Defaults to the value given to the `--erl` flag, otherwise it defaults to `true`.
+    Note that `dist_listen: false` implies `hidden: true`.
+
+  * `:hidden` - Enable or disable hidden node. Defaults to `true` if the `--hidden`
+    flag is given to `elixir`'s CLI (or via the `--erl` flag), otherwise it
+    defaults to `false`.
+
+  If `name` is set to `:undefined`, the distribution will be started to request a
+  dynamic node name from the first node it connects to. Setting `name` to
+  `:undefined` also implies options `dist_listen: false, hidden: true`.
   """
-  @spec start(node, :longnames | :shortnames, non_neg_integer) ::
-             {:ok, pid} | {:error, term}
-  def start(name, type \\ :longnames, tick_time \\ 15000) do
+  @spec start(node,
+          name_domain: :shortnames | :longnames,
+          net_ticktime: pos_integer(),
+          net_tickintensity: 4..1000,
+          dist_listen: boolean(),
+          hidden: boolean()
+        ) :: {:ok, pid} | {:error, term}
+  def start(name, opts \\ [])
+
+  def start(name, opts) when is_list(opts) do
+    :net_kernel.start(name, Map.new(opts))
+  end
+
+  # TODO: Deprecate me on Elixir v1.23
+  def start(name, type) when is_atom(type) do
+    :net_kernel.start([name, type, 15_000])
+  end
+
+  # TODO: Deprecate me on Elixir v1.23
+  @doc false
+  def start(name, type, tick_time) do
     :net_kernel.start([name, type, tick_time])
   end
 
@@ -26,11 +92,11 @@ defmodule Node do
   Turns a distributed node into a non-distributed node.
 
   For other nodes in the network, this is the same as the node going down.
-  Only possible when the node was started with `Node.start/3`, otherwise
+  Only possible when the node was started with `Node.start/2`, otherwise
   returns `{:error, :not_allowed}`. Returns `{:error, :not_found}` if the
   local node is not alive.
   """
-  @spec stop() :: :ok | {:error, term}
+  @spec stop() :: :ok | {:error, :not_allowed | :not_found}
   def stop() do
     :net_kernel.stop()
   end
@@ -60,6 +126,8 @@ defmodule Node do
   the local node.
 
   Same as `list(:visible)`.
+
+  Inlined by the compiler.
   """
   @spec list :: [t]
   def list do
@@ -72,9 +140,11 @@ defmodule Node do
   The result returned when the argument is a list, is the list of nodes
   satisfying the disjunction(s) of the list elements.
 
-  See http://www.erlang.org/doc/man/erlang.html#nodes-1 for more info.
+  For more information, see `:erlang.nodes/1`.
+
+  Inlined by the compiler.
   """
-  @typep state :: :visible | :hidden | :connected | :this | :known
+  @type state :: :visible | :hidden | :connected | :this | :known
   @spec list(state | [state]) :: [t]
   def list(args) do
     :erlang.nodes(args)
@@ -86,7 +156,9 @@ defmodule Node do
   If `flag` is `true`, monitoring is turned on.
   If `flag` is `false`, monitoring is turned off.
 
-  See http://www.erlang.org/doc/man/erlang.html#monitor_node-2 for more info.
+  For more information, see `:erlang.monitor_node/2`.
+
+  For monitoring status changes of all nodes, see `:net_kernel.monitor_nodes/2`.
   """
   @spec monitor(t, boolean) :: true
   def monitor(node, flag) do
@@ -97,7 +169,9 @@ defmodule Node do
   Behaves as `monitor/2` except that it allows an extra
   option to be given, namely `:allow_passive_connect`.
 
-  See http://www.erlang.org/doc/man/erlang.html#monitor_node-3 for more info.
+  For more information, see `:erlang.monitor_node/3`.
+
+  For monitoring status changes of all nodes, see `:net_kernel.monitor_nodes/2`.
   """
   @spec monitor(t, boolean, [:allow_passive_connect]) :: true
   def monitor(node, flag, options) do
@@ -128,7 +202,7 @@ defmodule Node do
   protocols. Returns `true` if disconnection succeeds, otherwise `false`.
   If the local node is not alive, the function returns `:ignored`.
 
-  See http://www.erlang.org/doc/man/erlang.html#disconnect_node-1 for more info.
+  For more information, see `:erlang.disconnect_node/1`.
   """
   @spec disconnect(t) :: boolean | :ignored
   def disconnect(node) do
@@ -141,7 +215,7 @@ defmodule Node do
   Returns `true` if successful, `false` if not, and the atom
   `:ignored` if the local node is not alive.
 
-  See http://erlang.org/doc/man/net_kernel.html#connect_node-1 for more info.
+  For more information, see `:net_kernel.connect_node/1`.
   """
   @spec connect(t) :: boolean | :ignored
   def connect(node) do
@@ -149,41 +223,40 @@ defmodule Node do
   end
 
   @doc """
-  Returns the pid of a new process started by the application of `fun`
-  on `node`. If `node` does not exist, a useless pid is returned.
+  Returns the PID of a new process started by the application of `fun`
+  on `node`. If `node` does not exist, a useless PID is returned.
 
-  Check http://www.erlang.org/doc/man/erlang.html#spawn-2 for
-  the list of available options.
+  For the list of available options, see `:erlang.spawn/2`.
 
   Inlined by the compiler.
   """
-  @spec spawn(t, (() -> any)) :: pid
+  @spec spawn(t, (-> any)) :: pid
   def spawn(node, fun) do
     :erlang.spawn(node, fun)
   end
 
   @doc """
-  Returns the pid of a new process started by the application of `fun`
+  Returns the PID of a new process started by the application of `fun`
   on `node`.
 
-  If `node` does not exist, a useless pid is returned. Check
-  http://www.erlang.org/doc/man/erlang.html#spawn_opt-3 for the list of
-  available options.
+  If `node` does not exist, a useless PID is returned.
+
+  For the list of available options, see `:erlang.spawn_opt/3`.
 
   Inlined by the compiler.
   """
-  @spec spawn(t, (() -> any), Process.spawn_opts) :: pid | {pid, reference}
+  @spec spawn(t, (-> any), Process.spawn_opts()) :: pid | {pid, reference}
   def spawn(node, fun, opts) do
     :erlang.spawn_opt(node, fun, opts)
   end
 
   @doc """
-  Returns the pid of a new process started by the application of
+  Returns the PID of a new process started by the application of
   `module.function(args)` on `node`.
 
-  If `node` does not exist, a useless pid is returned. Check
-  http://www.erlang.org/doc/man/erlang.html#spawn-4 for the list of
-  available options.
+  If `node` does not exist, a useless PID is returned.
+
+  For the list of available options, see `:erlang.spawn/4`.
 
   Inlined by the compiler.
   """
@@ -193,40 +266,40 @@ defmodule Node do
   end
 
   @doc """
-  Returns the pid of a new process started by the application of
+  Returns the PID of a new process started by the application of
   `module.function(args)` on `node`.
 
-  If `node` does not exist, a useless pid is returned. Check
-  http://www.erlang.org/doc/man/erlang.html#spawn_opt-5 for the list of
-  available options.
+  If `node` does not exist, a useless PID is returned.
+
+  For the list of available options, see `:erlang.spawn_opt/5`.
 
   Inlined by the compiler.
   """
-  @spec spawn(t, module, atom, [any], Process.spawn_opts) :: pid | {pid, reference}
+  @spec spawn(t, module, atom, [any], Process.spawn_opts()) :: pid | {pid, reference}
   def spawn(node, module, fun, args, opts) do
     :erlang.spawn_opt(node, module, fun, args, opts)
   end
 
   @doc """
-  Returns the pid of a new linked process started by the application of `fun` on `node`.
+  Returns the PID of a new linked process started by the application of `fun` on `node`.
 
   A link is created between the calling process and the new process, atomically.
-  If `node` does not exist, a useless pid is returned (and due to the link, an exit
+  If `node` does not exist, a useless PID is returned (and due to the link, an exit
   signal with exit reason `:noconnection` will be received).
 
   Inlined by the compiler.
   """
-  @spec spawn_link(t, (() -> any)) :: pid
+  @spec spawn_link(t, (-> any)) :: pid
   def spawn_link(node, fun) do
     :erlang.spawn_link(node, fun)
   end
 
   @doc """
-  Returns the pid of a new linked process started by the application of
+  Returns the PID of a new linked process started by the application of
   `module.function(args)` on `node`.
 
   A link is created between the calling process and the new process, atomically.
-  If `node` does not exist, a useless pid is returned (and due to the link, an exit
+  If `node` does not exist, a useless PID is returned (and due to the link, an exit
   signal with exit reason `:noconnection` will be received).
 
   Inlined by the compiler.
@@ -236,15 +309,40 @@ defmodule Node do
     :erlang.spawn_link(node, module, fun, args)
   end
 
+  @doc """
+  Spawns the given function on a node, monitors it and returns its PID
+  and monitoring reference.
+
+  Inlined by the compiler.
+  """
+  @doc since: "1.14.0"
+  @spec spawn_monitor(t, (-> any)) :: {pid, reference}
+  def spawn_monitor(node, fun) do
+    :erlang.spawn_monitor(node, fun)
+  end
+
+  @doc """
+  Spawns the given module and function passing the given args on a node,
+  monitors it and returns its PID and monitoring reference.
+
+  Inlined by the compiler.
+  """
+  @doc since: "1.14.0"
+  @spec spawn_monitor(t, module, atom, [any]) :: {pid, reference}
+  def spawn_monitor(node, module, fun, args) do
+    :erlang.spawn_monitor(node, module, fun, args)
+  end
+
   @doc """
   Sets the magic cookie of `node` to the atom `cookie`.
 
-  The default node is `Node.self`, the local node. If `node` is the local node,
+  The default node is `Node.self/0`, the local node. If `node` is the local node,
   the function also sets the cookie of all other unknown nodes to `cookie`.
 
   This function will raise `FunctionClauseError` if the given `node` is not alive.
   """
-  def set_cookie(node \\ Node.self, cookie) when is_atom(cookie) do
+  @spec set_cookie(t, atom) :: true
+  def set_cookie(node \\ Node.self(), cookie) when is_atom(cookie) do
     :erlang.set_cookie(node, cookie)
   end
 
@@ -253,6 +351,7 @@ defmodule Node do
 
   Returns the cookie if the node is alive, otherwise `:nocookie`.
   """
+  @spec get_cookie() :: atom
   def get_cookie() do
     :erlang.get_cookie()
   end
diff --git a/lib/elixir/lib/option_parser.ex b/lib/elixir/lib/option_parser.ex
index ebfa6e752dc..6c832cb3c63 100644
--- a/lib/elixir/lib/option_parser.ex
+++ b/lib/elixir/lib/option_parser.ex
@@ -1,79 +1,222 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule OptionParser do
   @moduledoc """
-  This module contains functions to parse command line arguments.
+  Functions for parsing command line arguments.
+
+  When calling a command, it's possible to pass command line options
+  to modify what the command does. In this documentation, those are
+  called "switches", in other situations they may be called "flags"
+  or simply "options". A switch can be given a value, also called an
+  "argument".
+
+  The main function in this module is `parse/2`, which parses a list
+  of command line options and arguments into a keyword list:
+
+      iex> OptionParser.parse(["--debug"], strict: [debug: :boolean])
+      {[debug: true], [], []}
+
+  `OptionParser` provides some conveniences out of the box,
+  such as aliases and automatic handling of negation switches.
+
+  The `parse_head/2` function is an alternative to `parse/2`
+  which stops parsing as soon as it finds a value that is not
+  a switch nor a value for a previous switch.
+
+  This module also provides low-level functions, such as `next/2`,
+  for parsing switches manually, as well as `split/1` and `to_argv/1`
+  for parsing from and converting switches to strings.
   """
 
-  @type argv    :: [String.t]
-  @type parsed  :: Keyword.t
-  @type errors  :: [{String.t, String.t | nil}]
-  @type options :: [switches: Keyword.t, strict: Keyword.t, aliases: Keyword.t]
+  @type argv :: [String.t()]
+  @type parsed :: keyword
+  @type errors :: [{String.t(), String.t() | nil}]
+  @type options :: [
+          switches: keyword,
+          strict: keyword,
+          aliases: keyword,
+          allow_nonexistent_atoms: boolean,
+          return_separator: boolean
+        ]
+
+  defmodule ParseError do
+    @moduledoc """
+    An exception raised when parsing option fails.
+
+    For example, see `OptionParser.parse!/2`.
+    """
+
+    defexception [:message]
+  end
 
   @doc """
-  Parses `argv` into a keywords list.
+  Parses `argv` into a keyword list.
 
-  It returns the parsed values, remaining arguments and the
-  invalid options.
+  It returns a three-element tuple with the form `{parsed, args, invalid}`, where:
 
-  ## Examples
+    * `parsed` is a keyword list of parsed switches with `{switch_name, value}`
+      tuples in it; `switch_name` is the atom representing the switch name while
+      `value` is the value for that switch parsed according to `opts` (see the
+      "Examples" section for more information)
+    * `args` is a list of the remaining arguments in `argv` as strings
+    * `invalid` is a list of invalid options as `{option_name, value}` where
+      `option_name` is the raw option and `value` is `nil` if the option wasn't
+      expected or the string value if the value didn't have the expected type for
+      the corresponding option
+
+  Elixir converts switches to underscored atoms, so `--source-path` becomes
+  `:source_path`. This is done to better suit Elixir conventions. However, this
+  means that switches can't contain underscores and switches that do contain
+  underscores are always returned in the list of invalid switches.
+
+  When parsing, it is common to list switches and their expected types:
 
-      iex> OptionParser.parse(["--debug"])
+      iex> OptionParser.parse(["--debug"], strict: [debug: :boolean])
       {[debug: true], [], []}
 
-      iex> OptionParser.parse(["--source", "lib"])
+      iex> OptionParser.parse(["--source", "lib"], strict: [source: :string])
       {[source: "lib"], [], []}
 
-      iex> OptionParser.parse(["--source-path", "lib", "test/enum_test.exs", "--verbose"])
+      iex> OptionParser.parse(
+      ...>   ["--source-path", "lib", "test/enum_test.exs", "--verbose"],
+      ...>   strict: [source_path: :string, verbose: :boolean]
+      ...> )
       {[source_path: "lib", verbose: true], ["test/enum_test.exs"], []}
 
-  By default, Elixir will try to automatically parse switches.
-  Switches without an argument, like `--debug` will automatically
-  be set to true. Switches followed by a value will be assigned
-  to the value, always as strings.
+  We will explore the valid switches and operation modes of option parser below.
+
+  ## Options
+
+  The following options are supported:
+
+    * `:switches` or `:strict` - see the "Switch definitions" section below
+    * `:allow_nonexistent_atoms` - see the "Parsing unknown switches" section below
+    * `:aliases` - see the "Aliases" section below
+    * `:return_separator` - see the "Return separator" section below
 
-  Note Elixir also converts the switches to underscore atoms, as
-  `--source-path` becomes `:source_path`, to better suit Elixir
-  conventions. This means that option names on the command line cannot contain
-  underscores; such options will be reported as `:undefined` (in strict mode)
-  or `:invalid` (in basic mode).
+  ## Switch definitions
 
-  ## Switches
+  Switches can be specified via one of two options:
 
-  Many times though, it is better to explicitly list the available
-  switches and their formats. The switches can be specified via two
-  different options:
+    * `:strict` - defines strict switches and their types. Any switch
+      in `argv` that is not specified in the list is returned in the
+      invalid options list. This is the preferred way to parse options.
 
-    * `:strict` - the switches are strict. Any switch that does not
-      exist in the switch list is treated as an error.
+    * `:switches` - defines switches and their types. This function
+      still attempts to parse switches that are not in this list.
 
-    * `:switches` - configure some switches. Switches that does not
-      exist in the switch list are still attempted to be parsed.
+  Both these options accept a keyword list where the key is an atom
+  defining the name of the switch and value is the `type` of the
+  switch (see the "Types" section below for more information).
 
-  Note only `:strict` or `:switches` may be given at once.
+  Note that you should only supply the `:switches` or the `:strict` option.
+  If you supply both, an `ArgumentError` exception will be raised.
 
-  For each switch, the following types are supported:
+  ### Types
 
-    * `:boolean` - marks the given switch as a boolean. Boolean switches
-                   never consume the following value unless it is `true` or
-                   `false`.
-    * `:integer` - parses the switch as an integer.
-    * `:float`   - parses the switch as a float.
-    * `:string`  - returns the switch as a string.
+  Switches parsed by `OptionParser` may take zero or one arguments.
 
-  If a switch can't be parsed or is not specfied in the strict case,
-  the option is returned in the invalid options list (third element
-  of the returned tuple).
+  The following switches types take no arguments:
 
-  The following extra "types" are supported:
+    * `:boolean` - sets the value to `true` when given (see also the
+      "Negation switches" section below)
+    * `:count` - counts the number of times the switch is given
 
-    * `:keep` - keeps duplicated items in the list instead of overriding
+  The following switches take one argument:
 
-  Examples:
+    * `:integer` - parses the value as an integer
+    * `:float` - parses the value as a float
+    * `:string` - parses the value as a string
+    * `:regex` - parses the value as a regular expression with Unicode support
+
+  If a switch can't be parsed according to the given type, it is
+  returned in the invalid options list.
+
+  ### Modifiers
+
+  Switches can be specified with modifiers, which change how
+  they behave. The following modifiers are supported:
+
+    * `:keep` - keeps duplicate elements instead of overriding them;
+      works with all types except `:count`. Specifying `switch_name: :keep`
+      assumes the type of `:switch_name` will be `:string`.
+
+  To use `:keep` with a type other than `:string`, use a list as the type
+  for the switch. For example: `[foo: [:integer, :keep]]`.
+
+  ### Negation switches
+
+  In case a switch `SWITCH` is specified to have type `:boolean`, it may be
+  passed as `--no-SWITCH` as well which will set the option to `false`:
+
+      iex> OptionParser.parse(["--no-op", "path/to/file"], switches: [op: :boolean])
+      {[op: false], ["path/to/file"], []}
+
+  ### Parsing unknown switches
+
+  When the `:switches` option is given, `OptionParser` will attempt to parse
+  unknown switches.
+
+  Switches without an argument will be set to `true`:
+
+      iex> OptionParser.parse(["--debug"], switches: [key: :string])
+      {[debug: true], [], []}
+
+  Even though we haven't specified `--debug` in the list of switches, it is part
+  of the returned options. The same happens for switches followed by another switch:
+
+      iex> OptionParser.parse(["--debug", "--ok"], switches: [])
+      {[debug: true, ok: true], [], []}
+
+  Switches followed by a value will be assigned the value, as a string:
+
+      iex> OptionParser.parse(["--debug", "value"], switches: [key: :string])
+      {[debug: "value"], [], []}
+
+  Since we cannot assert the type of the switch value, it is preferred to use the
+  `:strict` option that accepts only known switches and always verify their types.
+
+  If you do want to parse unknown switches, remember that Elixir converts switches
+  to atoms. Since atoms are not garbage-collected, to avoid creating new ones,
+  OptionParser by default only parses switches that translate to existing atoms.
+  The code below discards the `--option-parser-example` switch because the
+  `:option_parser_example` atom is never used anywhere:
+
+      iex> OptionParser.parse(["--option-parser-example"], switches: [])
+      {[], [], []}
+
+  If a switch corresponds to an existing Elixir atom, whether from your
+  code, a dependency or from Elixir itself, it will be accepted. However,
+  it is best to not rely on external code, and always define the atoms
+  you want to parse in the same module that calls `OptionParser` itself,
+  as direct arguments to the `:switches` or `:strict` options.
+
+  If you would like to parse all switches, regardless if they exist or not,
+  you can force creation of atoms by passing `allow_nonexistent_atoms: true`
+  as option. Use this option with care. It is only useful when you are building
+  command-line applications that receive dynamically-named arguments and must
+  be avoided in long-running systems.
+
+  ## Aliases
+
+  A set of aliases can be specified in the `:aliases` option:
+
+      iex> OptionParser.parse(["-d"], aliases: [d: :debug], strict: [debug: :boolean])
+      {[debug: true], [], []}
+
+  ## Examples
+
+  Here are some examples of working with different types and modifiers:
 
       iex> OptionParser.parse(["--unlock", "path/to/file"], strict: [unlock: :boolean])
       {[unlock: true], ["path/to/file"], []}
 
-      iex> OptionParser.parse(["--unlock", "--limit", "0", "path/to/file"],
-      ...>                    strict: [unlock: :boolean, limit: :integer])
+      iex> OptionParser.parse(
+      ...>   ["--unlock", "--limit", "0", "path/to/file"],
+      ...>   strict: [unlock: :boolean, limit: :integer]
+      ...> )
       {[unlock: true, limit: 0], ["path/to/file"], []}
 
       iex> OptionParser.parse(["--limit", "3"], strict: [limit: :integer])
@@ -82,39 +225,86 @@ defmodule OptionParser do
       iex> OptionParser.parse(["--limit", "xyz"], strict: [limit: :integer])
       {[], [], [{"--limit", "xyz"}]}
 
+      iex> OptionParser.parse(["--verbose"], switches: [verbose: :count])
+      {[verbose: 1], [], []}
+
+      iex> OptionParser.parse(["-v", "-v"], aliases: [v: :verbose], strict: [verbose: :count])
+      {[verbose: 2], [], []}
+
       iex> OptionParser.parse(["--unknown", "xyz"], strict: [])
       {[], ["xyz"], [{"--unknown", nil}]}
 
-      iex> OptionParser.parse(["--limit", "3", "--unknown", "xyz"],
-      ...>                    switches: [limit: :integer])
+      iex> OptionParser.parse(
+      ...>   ["--limit", "3", "--unknown", "xyz"],
+      ...>   switches: [limit: :integer]
+      ...> )
       {[limit: 3, unknown: "xyz"], [], []}
 
-  ## Negation switches
-
-  All switches starting with `--no-` are considered to be booleans and never
-  parse the next value:
+      iex> OptionParser.parse(
+      ...>   ["--unlock", "path/to/file", "--unlock", "path/to/another/file"],
+      ...>   strict: [unlock: :keep]
+      ...> )
+      {[unlock: "path/to/file", unlock: "path/to/another/file"], [], []}
 
-      iex> OptionParser.parse(["--no-op", "path/to/file"])
-      {[no_op: true], ["path/to/file"], []}
+  ## Return separator
 
-  However, in case the base switch exists, it sets that particular switch to
-  false:
+  The separator `--` implies options should no longer be processed.
+  By default, the separator is not returned as parts of the arguments,
+  but that can be changed via the `:return_separator` option:
 
-      iex> OptionParser.parse(["--no-op", "path/to/file"], switches: [op: :boolean])
-      {[op: false], ["path/to/file"], []}
+      iex> OptionParser.parse(["--", "lib"], return_separator: true, strict: [])
+      {[], ["--", "lib"], []}
 
-  ## Aliases
+      iex> OptionParser.parse(["--no-halt", "--", "lib"], return_separator: true, switches: [halt: :boolean])
+      {[halt: false], ["--", "lib"], []}
 
-  A set of aliases can be given as options too:
-
-      iex> OptionParser.parse(["-d"], aliases: [d: :debug])
-      {[debug: true], [], []}
+      iex> OptionParser.parse(["script.exs", "--no-halt", "--", "foo"], return_separator: true, switches: [halt: :boolean])
+      {[{:halt, false}], ["script.exs", "--", "foo"], []}
 
   """
   @spec parse(argv, options) :: {parsed, argv, errors}
   def parse(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    config = compile_config(opts, true)
-    do_parse(argv, config, [], [], [])
+    do_parse(argv, build_config(opts), [], [], [], true)
+  end
+
+  @doc """
+  The same as `parse/2` but raises an `OptionParser.ParseError`
+  exception if any invalid options are given.
+
+  If there are no errors, returns a `{parsed, rest}` tuple where:
+
+    * `parsed` is the list of parsed switches (same as in `parse/2`)
+    * `rest` is the list of arguments (same as in `parse/2`)
+
+  ## Examples
+
+      iex> OptionParser.parse!(["--debug", "path/to/file"], strict: [debug: :boolean])
+      {[debug: true], ["path/to/file"]}
+
+      iex> OptionParser.parse!(["--limit", "xyz"], strict: [limit: :integer])
+      ** (OptionParser.ParseError) 1 error found!
+      --limit : Expected type integer, got "xyz"...
+
+      iex> OptionParser.parse!(["--unknown", "xyz"], strict: [])
+      ** (OptionParser.ParseError) 1 error found!
+      --unknown : Unknown option...
+
+      iex> OptionParser.parse!(
+      ...>   ["-l", "xyz", "-f", "bar"],
+      ...>   switches: [limit: :integer, foo: :integer],
+      ...>   aliases: [l: :limit, f: :foo]
+      ...> )
+      ** (OptionParser.ParseError) 2 errors found!
+      -l : Expected type integer, got "xyz"
+      -f : Expected type integer, got "bar"...
+
+  """
+  @spec parse!(argv, options) :: {parsed, argv}
+  def parse!(argv, opts \\ []) when is_list(argv) and is_list(opts) do
+    case parse(argv, opts) do
+      {parsed, args, []} -> {parsed, args}
+      {_, _, errors} -> raise ParseError, format_errors(errors, opts)
+    end
   end
 
   @doc """
@@ -125,46 +315,99 @@ defmodule OptionParser do
 
   ## Example
 
-      iex> OptionParser.parse_head(["--source", "lib", "test/enum_test.exs", "--verbose"])
+      iex> OptionParser.parse_head(
+      ...>   ["--source", "lib", "test/enum_test.exs", "--verbose"],
+      ...>   switches: [source: :string, verbose: :boolean]
+      ...> )
       {[source: "lib"], ["test/enum_test.exs", "--verbose"], []}
 
-      iex> OptionParser.parse_head(["--verbose", "--source", "lib", "test/enum_test.exs", "--unlock"])
+      iex> OptionParser.parse_head(
+      ...>   ["--verbose", "--source", "lib", "test/enum_test.exs", "--unlock"],
+      ...>   switches: [source: :string, verbose: :boolean, unlock: :boolean]
+      ...> )
       {[verbose: true, source: "lib"], ["test/enum_test.exs", "--unlock"], []}
 
   """
   @spec parse_head(argv, options) :: {parsed, argv, errors}
   def parse_head(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    config = compile_config(opts, false)
-    do_parse(argv, config, [], [], [])
+    do_parse(argv, build_config(opts), [], [], [], false)
   end
 
-  defp do_parse([], _config, opts, args, invalid) do
+  @doc """
+  The same as `parse_head/2` but raises an `OptionParser.ParseError`
+  exception if any invalid options are given.
+
+  If there are no errors, returns a `{parsed, rest}` tuple where:
+
+    * `parsed` is the list of parsed switches (same as in `parse_head/2`)
+    * `rest` is the list of arguments (same as in `parse_head/2`)
+
+  ## Examples
+
+      iex> OptionParser.parse_head!(
+      ...>   ["--source", "lib", "path/to/file", "--verbose"],
+      ...>   switches: [source: :string, verbose: :boolean]
+      ...> )
+      {[source: "lib"], ["path/to/file", "--verbose"]}
+
+      iex> OptionParser.parse_head!(
+      ...>   ["--number", "lib", "test/enum_test.exs", "--verbose"],
+      ...>   strict: [number: :integer]
+      ...> )
+      ** (OptionParser.ParseError) 1 error found!
+      --number : Expected type integer, got "lib"...
+
+      iex> OptionParser.parse_head!(
+      ...>   ["--verbose", "--source", "lib", "test/enum_test.exs", "--unlock"],
+      ...>   strict: [verbose: :integer, source: :integer]
+      ...> )
+      ** (OptionParser.ParseError) 2 errors found!
+      --verbose : Missing argument of type integer
+      --source : Expected type integer, got "lib"...
+
+  """
+  @spec parse_head!(argv, options) :: {parsed, argv}
+  def parse_head!(argv, opts \\ []) when is_list(argv) and is_list(opts) do
+    case parse_head(argv, opts) do
+      {parsed, args, []} -> {parsed, args}
+      {_, _, errors} -> raise ParseError, format_errors(errors, opts)
+    end
+  end
+
+  defp do_parse([], _config, opts, args, invalid, _all?) do
     {Enum.reverse(opts), Enum.reverse(args), Enum.reverse(invalid)}
   end
 
-  defp do_parse(argv, {aliases, switches, strict, all}=config, opts, args, invalid) do
-    case next(argv, aliases, switches, strict) do
+  defp do_parse(argv, %{switches: switches} = config, opts, args, invalid, all?) do
+    case next_with_config(argv, config) do
       {:ok, option, value, rest} ->
-        # the option exist and it was successfully parsed
-        kinds = List.wrap Keyword.get(switches, option)
-        new_opts = do_store_option(opts, option, value, kinds)
-        do_parse(rest, config, new_opts, args, invalid)
+        # the option exists and it was successfully parsed
+        kinds = List.wrap(Keyword.get(switches, option))
+        new_opts = store_option(opts, option, value, kinds)
+        do_parse(rest, config, new_opts, args, invalid, all?)
 
       {:invalid, option, value, rest} ->
         # the option exist but it has wrong value
-        do_parse(rest, config, opts, args, [{option, value}|invalid])
+        do_parse(rest, config, opts, args, [{option, value} | invalid], all?)
 
       {:undefined, option, _value, rest} ->
-        # the option does not exist (for strict cases)
-        do_parse(rest, config, opts, args, [{option, nil}|invalid])
+        invalid = if config.strict?, do: [{option, nil} | invalid], else: invalid
+        do_parse(rest, config, opts, args, invalid, all?)
+
+      {:error, ["--" | rest] = remaining_args} ->
+        args =
+          if config.return_separator? do
+            Enum.reverse(args, remaining_args)
+          else
+            Enum.reverse(args, rest)
+          end
 
-      {:error, ["--"|rest]} ->
-        {Enum.reverse(opts), Enum.reverse(args, rest), Enum.reverse(invalid)}
+        {Enum.reverse(opts), args, Enum.reverse(invalid)}
 
-      {:error, [arg|rest]=remaining_args} ->
+      {:error, [arg | rest] = remaining_args} ->
         # there is no option
-        if all do
-          do_parse(rest, config, opts, [arg|args], invalid)
+        if all? do
+          do_parse(rest, config, opts, [arg | args], invalid, all?)
         else
           {Enum.reverse(opts), Enum.reverse(args, remaining_args), Enum.reverse(invalid)}
         end
@@ -175,249 +418,574 @@ defmodule OptionParser do
   Low-level function that parses one option.
 
   It accepts the same options as `parse/2` and `parse_head/2`
-  as both functions are built on top of next. This function
+  as both functions are built on top of this function. This function
   may return:
 
     * `{:ok, key, value, rest}` - the option `key` with `value` was
       successfully parsed
 
     * `{:invalid, key, value, rest}` - the option `key` is invalid with `value`
-      (returned when the switch type does not match the one given via the
-      command line)
+      (returned when the value cannot be parsed according to the switch type)
 
     * `{:undefined, key, value, rest}` - the option `key` is undefined
-      (returned on strict cases and the switch is unknown)
+      (returned in strict mode when the switch is unknown or on nonexistent atoms)
 
-    * `{:error, rest}` - there are no switches at the top of the given argv
-  """
+    * `{:error, rest}` - there are no switches at the head of the given `argv`
 
+  """
   @spec next(argv, options) ::
-        {:ok, key :: atom, value :: term, argv} |
-        {:invalid, key :: atom, value :: term, argv} |
-        {:undefined, key :: atom, value :: term, argv} |
-        {:error, argv}
+          {:ok, key :: atom, value :: term, argv}
+          | {:invalid, String.t(), String.t() | nil, argv}
+          | {:undefined, String.t(), String.t() | nil, argv}
+          | {:error, argv}
 
   def next(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    {aliases, switches, strict, _} = compile_config(opts, true)
-    next(argv, aliases, switches, strict)
+    next_with_config(argv, build_config(opts))
   end
 
-  defp next([], _aliases, _switches, _strict) do
+  defp next_with_config([], _config) do
     {:error, []}
   end
 
-  defp next(["--"|_]=argv, _aliases, _switches, _strict) do
+  defp next_with_config(["--" | _] = argv, _config) do
     {:error, argv}
   end
 
-  defp next(["-"|_]=argv, _aliases, _switches, _strict) do
+  defp next_with_config(["-" | _] = argv, _config) do
     {:error, argv}
   end
 
-  defp next(["- " <> _|_]=argv, _aliases, _switches, _strict) do
+  defp next_with_config(["- " <> _ | _] = argv, _config) do
     {:error, argv}
   end
 
-  defp next(["-" <> option|rest], aliases, switches, strict) do
+  # Handles --foo or --foo=bar
+  defp next_with_config(["--" <> option | rest], config) do
     {option, value} = split_option(option)
-    opt_name_bin = "-" <> option
-    tagged = tag_option(option, value, switches, aliases)
 
-    if strict and not option_defined?(tagged, switches) do
-      {:undefined, opt_name_bin, value, rest}
+    if String.contains?(option, ["_"]) do
+      {:undefined, "--" <> option, value, rest}
     else
-      {opt_name, kinds, value} = normalize_option(tagged, value, switches)
-      {value, kinds, rest} = normalize_value(value, kinds, rest, strict)
+      tagged = tag_option(option, config)
+      next_tagged(tagged, value, "--" <> option, rest, config)
+    end
+  end
+
+  # Handles -a, -abc, -abc=something, -n2
+  defp next_with_config(["-" <> option | rest] = argv, config) do
+    {option, value} = split_option(option)
+    original = "-" <> option
+
+    cond do
+      is_nil(value) and starts_with_number?(option) ->
+        {:error, argv}
+
+      String.contains?(option, ["-", "_"]) ->
+        {:undefined, original, value, rest}
+
+      String.length(option) == 1 ->
+        # We have a regular one-letter alias here
+        tagged = tag_oneletter_alias(option, config)
+        next_tagged(tagged, value, original, rest, config)
+
+      true ->
+        key = get_option_key(option, config.allow_nonexistent_atoms?)
+        option_key = config.aliases[key]
+
+        if key && option_key do
+          IO.warn("multi-letter aliases are deprecated, got: #{inspect(key)}")
+          next_tagged({:default, option_key}, value, original, rest, config)
+        else
+          next_with_config(expand_multiletter_alias(option, value) ++ rest, config)
+        end
+    end
+  end
+
+  defp next_with_config(argv, _config) do
+    {:error, argv}
+  end
+
+  defp next_tagged(:unknown, value, original, rest, _) do
+    {value, _kinds, rest} = normalize_value(value, [], rest)
+    {:undefined, original, value, rest}
+  end
+
+  defp next_tagged({tag, option}, value, original, rest, %{switches: switches, strict?: strict?}) do
+    if strict? and not Keyword.has_key?(switches, option) do
+      {:undefined, original, value, rest}
+    else
+      {kinds, value} = normalize_tag(tag, option, value, switches)
+      {value, kinds, rest} = normalize_value(value, kinds, rest)
+
       case validate_option(value, kinds) do
-        {:ok, new_value} -> {:ok, opt_name, new_value, rest}
-        :invalid         -> {:invalid, opt_name_bin, value, rest}
+        {:ok, new_value} -> {:ok, option, new_value, rest}
+        :invalid -> {:invalid, original, value, rest}
       end
     end
   end
 
-  defp next(argv, _aliases, _switches, _strict) do
-    {:error, argv}
+  @doc """
+  Receives a key-value enumerable and converts it to `t:argv/0`.
+
+  Keys must be atoms. Keys with `nil` value are discarded,
+  boolean values are converted to `--key` or `--no-key`
+  (if the value is `true` or `false`, respectively),
+  and all other values are converted using `to_string/1`.
+
+  It is advised to pass to `to_argv/2` the same set of `options`
+  given to `parse/2`. Some switches can only be reconstructed
+  correctly with the `:switches` information in hand.
+
+  ## Examples
+
+      iex> OptionParser.to_argv(foo_bar: "baz")
+      ["--foo-bar", "baz"]
+      iex> OptionParser.to_argv(bool: true, bool: false, discarded: nil)
+      ["--bool", "--no-bool"]
+
+  Some switches will output different values based on the switches
+  types:
+
+      iex> OptionParser.to_argv([number: 2], switches: [])
+      ["--number", "2"]
+      iex> OptionParser.to_argv([number: 2], switches: [number: :count])
+      ["--number", "--number"]
+
+  """
+  @spec to_argv(Enumerable.t(), options) :: argv
+  def to_argv(enum, options \\ []) do
+    switches = Keyword.get(options, :switches, [])
+
+    Enum.flat_map(enum, fn
+      {_key, nil} -> []
+      {key, true} -> [to_switch(key)]
+      {key, false} -> [to_switch(key, "--no-")]
+      {key, value} -> to_argv(key, value, switches)
+    end)
+  end
+
+  defp to_argv(key, value, switches) do
+    if switches[key] == :count do
+      List.duplicate(to_switch(key), value)
+    else
+      [to_switch(key), to_string(value)]
+    end
+  end
+
+  defp to_switch(key, prefix \\ "--") when is_atom(key) do
+    prefix <> String.replace(Atom.to_string(key), "_", "-")
+  end
+
+  @doc ~S"""
+  Splits a string into `t:argv/0` chunks.
+
+  This function splits the given `string` into a list of strings in a similar
+  way to many shells.
+
+  ## Examples
+
+      iex> OptionParser.split("foo bar")
+      ["foo", "bar"]
+
+      iex> OptionParser.split("foo \"bar baz\"")
+      ["foo", "bar baz"]
+
+  """
+  @spec split(String.t()) :: argv
+  def split(string) when is_binary(string) do
+    do_split(String.trim_leading(string, " "), "", [], nil)
+  end
+
+  # If we have an escaped quote, simply remove the escape
+  defp do_split(<<?\\, quote, t::binary>>, buffer, acc, quote),
+    do: do_split(t, <<buffer::binary, quote>>, acc, quote)
+
+  # If we have a quote and we were not in a quote, start one
+  defp do_split(<<quote, t::binary>>, buffer, acc, nil) when quote in [?", ?'],
+    do: do_split(t, buffer, acc, quote)
+
+  # If we have a quote and we were inside it, close it
+  defp do_split(<<quote, t::binary>>, buffer, acc, quote), do: do_split(t, buffer, acc, nil)
+
+  # If we have an escaped quote/space, simply remove the escape as long as we are not inside a quote
+  defp do_split(<<?\\, h, t::binary>>, buffer, acc, nil) when h in [?\s, ?', ?"],
+    do: do_split(t, <<buffer::binary, h>>, acc, nil)
+
+  # If we have space and we are outside of a quote, start new segment
+  defp do_split(<<?\s, t::binary>>, buffer, acc, nil),
+    do: do_split(String.trim_leading(t, " "), "", [buffer | acc], nil)
+
+  # All other characters are moved to buffer
+  defp do_split(<<h, t::binary>>, buffer, acc, quote) do
+    do_split(t, <<buffer::binary, h>>, acc, quote)
+  end
+
+  # Finish the string expecting a nil marker
+  defp do_split(<<>>, "", acc, nil), do: Enum.reverse(acc)
+
+  defp do_split(<<>>, buffer, acc, nil), do: Enum.reverse([buffer | acc])
+
+  # Otherwise raise
+  defp do_split(<<>>, _, _acc, marker) do
+    raise "argv string did not terminate properly, a #{<<marker>>} was opened but never closed"
   end
 
   ## Helpers
 
-  defp compile_config(opts, all) do
-    aliases = opts[:aliases] || []
+  defp build_config(opts) do
+    {switches, strict?} =
+      cond do
+        opts[:switches] && opts[:strict] ->
+          raise ArgumentError, ":switches and :strict cannot be given together"
 
-    {switches, strict} = cond do
-      s = opts[:switches] ->
-        {s, false}
-      s = opts[:strict] ->
-        {s, true}
-      true ->
-        {[], false}
-    end
+        switches = opts[:switches] ->
+          validate_switches(switches)
+          {switches, false}
+
+        strict = opts[:strict] ->
+          validate_switches(strict)
+          {strict, true}
+
+        true ->
+          IO.warn("not passing the :switches or :strict option to OptionParser is deprecated")
+          {[], false}
+      end
 
-    {aliases, switches, strict, all}
+    %{
+      aliases: opts[:aliases] || [],
+      allow_nonexistent_atoms?: opts[:allow_nonexistent_atoms] || false,
+      return_separator?: opts[:return_separator] || false,
+      strict?: strict?,
+      switches: switches
+    }
   end
 
-  defp validate_option(value, kinds) do
-    {is_invalid, value} = cond do
-      :invalid in kinds ->
-        {true, value}
-      :boolean in kinds ->
-        case value do
-          t when t in [true, "true"] -> {nil, true}
-          f when f in [false, "false"] -> {nil, false}
-          _ -> {true, value}
-        end
-      :integer in kinds ->
-        case Integer.parse(value) do
-          {value, ""} -> {nil, value}
-          _ -> {true, value}
-        end
-      :float in kinds ->
-        case Float.parse(value) do
-          {value, ""} -> {nil, value}
-          _ -> {true, value}
-        end
-      true ->
-        {nil, value}
+  defp validate_switches(switches) do
+    Enum.map(switches, &validate_switch/1)
+  end
+
+  defp validate_switch({_name, type_or_type_and_modifiers}) do
+    valid = [:boolean, :count, :integer, :float, :string, :regex, :keep]
+    invalid = List.wrap(type_or_type_and_modifiers) -- valid
+
+    if invalid != [] do
+      raise ArgumentError,
+            "invalid switch types/modifiers: " <> Enum.map_join(invalid, ", ", &inspect/1)
     end
+  end
 
-    if is_invalid do
+  defp validate_option(value, kinds) do
+    {invalid?, value} =
+      cond do
+        :invalid in kinds ->
+          {true, value}
+
+        :boolean in kinds ->
+          case value do
+            t when t in [true, "true"] -> {false, true}
+            f when f in [false, "false"] -> {false, false}
+            _ -> {true, value}
+          end
+
+        :count in kinds ->
+          case value do
+            nil -> {false, 1}
+            _ -> {true, value}
+          end
+
+        :integer in kinds ->
+          case Integer.parse(value) do
+            {value, ""} -> {false, value}
+            _ -> {true, value}
+          end
+
+        :float in kinds ->
+          case Float.parse(value) do
+            {value, ""} -> {false, value}
+            _ -> {true, value}
+          end
+
+        :regex in kinds ->
+          case Regex.compile(value, "u") do
+            {:ok, regex} -> {false, regex}
+            {:error, _} -> {true, value}
+          end
+
+        true ->
+          {false, value}
+      end
+
+    if invalid? do
       :invalid
     else
       {:ok, value}
     end
   end
 
-  defp do_store_option(dict, option, value, kinds) do
+  defp store_option(dict, option, value, kinds) do
     cond do
+      :count in kinds ->
+        Keyword.update(dict, option, value, &(&1 + 1))
+
       :keep in kinds ->
-        [{option, value}|dict]
+        [{option, value} | dict]
+
       true ->
-        [{option, value}|Keyword.delete(dict, option)]
+        [{option, value} | Keyword.delete(dict, option)]
     end
   end
 
-  defp tag_option(<<?-, option :: binary>>, value, switches, _aliases) do
-    get_negated(option, value, switches)
+  defp tag_option("no-" <> option = original, config) do
+    %{switches: switches, allow_nonexistent_atoms?: allow_nonexistent_atoms?} = config
+
+    cond do
+      (negated = get_option_key(option, allow_nonexistent_atoms?)) &&
+          :boolean in List.wrap(switches[negated]) ->
+        {:negated, negated}
+
+      option_key = get_option_key(original, allow_nonexistent_atoms?) ->
+        {:default, option_key}
+
+      true ->
+        :unknown
+    end
   end
 
-  defp tag_option(option, _value, _switches, aliases) when is_binary(option) do
-    opt = get_option(option)
-    if alias = aliases[opt] do
-      {:default, alias}
+  defp tag_option(option, config) do
+    %{allow_nonexistent_atoms?: allow_nonexistent_atoms?} = config
+
+    if option_key = get_option_key(option, allow_nonexistent_atoms?) do
+      {:default, option_key}
     else
       :unknown
     end
   end
 
-  defp option_defined?(:unknown, _switches) do
-    false
-  end
-
-  defp option_defined?({:negated, option}, switches) do
-    Keyword.has_key?(switches, option)
-  end
+  defp tag_oneletter_alias(alias, config) when is_binary(alias) do
+    %{aliases: aliases, allow_nonexistent_atoms?: allow_nonexistent_atoms?} = config
 
-  defp option_defined?({:default, option}, switches) do
-    Keyword.has_key?(switches, option)
+    if option_key = aliases[to_existing_key(alias, allow_nonexistent_atoms?)] do
+      {:default, option_key}
+    else
+      :unknown
+    end
   end
 
-  defp normalize_option(:unknown, value, _switches) do
-    {nil, [:invalid], value}
+  defp expand_multiletter_alias(options, value) do
+    {options, maybe_integer} =
+      options
+      |> String.to_charlist()
+      |> Enum.split_while(&(&1 not in ?0..?9))
+
+    {last, expanded} =
+      options
+      |> List.to_string()
+      |> String.graphemes()
+      |> Enum.map(&("-" <> &1))
+      |> List.pop_at(-1)
+
+    expanded ++
+      [
+        last <>
+          if(maybe_integer != [], do: "=#{maybe_integer}", else: "") <>
+          if(value, do: "=#{value}", else: "")
+      ]
   end
 
-  defp normalize_option({:negated, option}, nil, switches) do
-    kinds = List.wrap(switches[option])
-
-    cond do
-      :boolean in kinds ->
-        {option, kinds, false}
-      kinds == [] ->
-        {option, kinds, true}
-      true ->
-        {reverse_negated(option), [:invalid], nil}
+  defp normalize_tag(:negated, option, value, switches) do
+    if value do
+      {[:invalid], value}
+    else
+      {List.wrap(switches[option]), false}
     end
   end
 
-  defp normalize_option({:negated, option}, value, _switches) do
-    {option, [:invalid], value}
-  end
-
-  defp normalize_option({:default, option}, value, switches) do
-    {option, List.wrap(switches[option]), value}
+  defp normalize_tag(:default, option, value, switches) do
+    {List.wrap(switches[option]), value}
   end
 
-  defp normalize_value(nil, kinds, t, strict) do
-    nil_or_true = if strict, do: nil, else: true
+  defp normalize_value(nil, kinds, t) do
     cond do
       :boolean in kinds ->
         {true, kinds, t}
+
+      :count in kinds ->
+        {nil, kinds, t}
+
       value_in_tail?(t) ->
-        [h|t] = t
+        [h | t] = t
         {h, kinds, t}
+
       kinds == [] ->
-        {nil_or_true, kinds, t}
+        {true, kinds, t}
+
       true ->
         {nil, [:invalid], t}
     end
   end
 
-  defp normalize_value(value, kinds, t, _) do
+  defp normalize_value(value, kinds, t) do
     {value, kinds, t}
   end
 
-  defp value_in_tail?(["-"|_]),       do: true
-  defp value_in_tail?(["- " <> _|_]), do: true
-  defp value_in_tail?(["-" <> _|_]),  do: false
-  defp value_in_tail?([]),            do: false
-  defp value_in_tail?(_),             do: true
+  defp value_in_tail?(["-" | _]), do: true
+  defp value_in_tail?(["- " <> _ | _]), do: true
+  defp value_in_tail?(["-" <> arg | _]), do: starts_with_number?(arg)
+  defp value_in_tail?([]), do: false
+  defp value_in_tail?(_), do: true
 
   defp split_option(option) do
     case :binary.split(option, "=") do
-      [h]    -> {h, nil}
+      [h] -> {h, nil}
       [h, t] -> {h, t}
     end
   end
 
   defp to_underscore(option), do: to_underscore(option, <<>>)
+  defp to_underscore("-" <> rest, acc), do: to_underscore(rest, acc <> "_")
+  defp to_underscore(<<c>> <> rest, acc), do: to_underscore(rest, <<acc::binary, c>>)
+  defp to_underscore(<<>>, acc), do: acc
 
-  defp to_underscore("_" <> _rest, _acc), do: nil
-
-  defp to_underscore("-" <> rest, acc),
-    do: to_underscore(rest, acc <> "_")
-
-  defp to_underscore(<<c>> <> rest, acc),
-    do: to_underscore(rest, <<acc::binary, c>>)
+  defp get_option_key(option, allow_nonexistent_atoms?) do
+    option
+    |> to_underscore()
+    |> to_existing_key(allow_nonexistent_atoms?)
+  end
 
-  defp to_underscore(<<>>, acc), do: acc
+  defp to_existing_key(option, true), do: String.to_atom(option)
 
-  defp get_option(option) do
-    if str = to_underscore(option) do
-      String.to_atom(str)
+  defp to_existing_key(option, false) do
+    try do
+      String.to_existing_atom(option)
+    rescue
+      ArgumentError -> nil
     end
   end
 
-  defp reverse_negated(negated) do
-    String.to_atom("no_" <> Atom.to_string(negated))
+  defp starts_with_number?(<<char, _::binary>>) when char in ?0..?9, do: true
+  defp starts_with_number?(_), do: false
+
+  defp format_errors([_ | _] = errors, opts) do
+    types = opts[:switches] || opts[:strict]
+    error_count = length(errors)
+    error = if error_count == 1, do: "error", else: "errors"
+
+    slogan =
+      "#{error_count} #{error} found!\n" <>
+        Enum.map_join(errors, "\n", &format_error(&1, opts, types))
+
+    case format_available_options(opts, types) do
+      "" -> slogan
+      available_options -> slogan <> "\n\n#{available_options}"
+    end
   end
 
-  defp get_negated("no-" <> rest = option, value, switches) do
-    if negated = get_option(rest) do
-      option = if Keyword.has_key?(switches, negated) and value == nil do
-        negated
+  defp format_error({option, nil}, opts, types) do
+    if type = get_type(option, opts, types) do
+      if String.contains?(option, "_") do
+        msg = "#{option} : Unknown option"
+        msg <> ". Did you mean #{String.replace(option, "_", "-")}?"
       else
-        get_option(option)
+        "#{option} : Missing argument of type #{type}"
       end
-      {:negated, option}
     else
-      :unknown
+      msg = "#{option} : Unknown option"
+
+      case did_you_mean(option, types) do
+        {similar, score} when score > 0.8 ->
+          msg <> ". Did you mean --#{similar}?"
+
+        _ ->
+          msg
+      end
     end
   end
 
-  defp get_negated(rest, _value, _switches) do
-    if option = get_option(rest) do
-      {:default, option}
+  defp format_error({option, value}, opts, types) do
+    type = get_type(option, opts, types)
+
+    with :regex <- type,
+         {:error, {reason, position}} <- Regex.compile(value, "u") do
+      "#{option} : Invalid regular expression #{inspect(value)}: #{reason} at position #{position}"
     else
-      :unknown
+      _ -> "#{option} : Expected type #{type}, got #{inspect(value)}"
+    end
+  end
+
+  defp get_type(option, opts, types) do
+    allow_nonexistent_atoms? = opts[:allow_nonexistent_atoms] || false
+    key = option |> String.trim_leading("-") |> get_option_key(allow_nonexistent_atoms?)
+
+    if option_key = opts[:aliases][key] do
+      types[option_key]
+    else
+      types[key]
+    end
+  end
+
+  defp did_you_mean(option, types) do
+    key = option |> String.trim_leading("-") |> String.replace("-", "_")
+    Enum.reduce(types, {nil, 0}, &max_similar(&1, key, &2))
+  end
+
+  defp max_similar({source, _}, target, {_, current} = best) do
+    source = Atom.to_string(source)
+
+    score = String.jaro_distance(source, target)
+    option = String.replace(source, "_", "-")
+    if score < current, do: best, else: {option, score}
+  end
+
+  defp format_available_options(opts, switches) do
+    reverse_aliases =
+      opts
+      |> Keyword.get(:aliases, [])
+      |> Enum.reduce(%{}, fn {alias, target}, acc ->
+        Map.update(acc, target, [alias], &[alias | &1])
+      end)
+
+    formatted_options =
+      switches
+      |> Enum.sort()
+      |> Enum.map(fn {name, types} ->
+        types = List.wrap(types)
+
+        case types |> List.delete(:keep) |> List.first(:string) do
+          :boolean ->
+            base = "#{to_switch(name)}, #{to_switch(name, "--no-")}"
+            add_aliases(base, name, reverse_aliases)
+
+          type ->
+            base = "#{to_switch(name)} #{String.upcase(Atom.to_string(type))}"
+            base = add_aliases(base, name, reverse_aliases)
+
+            if :keep in types do
+              base <> " (may be given more than once)"
+            else
+              base
+            end
+        end
+      end)
+
+    if formatted_options == [] do
+      ""
+    else
+      "Supported options:\n" <> Enum.map_join(formatted_options, "\n", &("  " <> &1))
+    end
+  end
+
+  defp add_aliases(base, name, reverse_aliases) do
+    case Map.get(reverse_aliases, name, []) do
+      [] ->
+        base
+
+      alias_list ->
+        alias_str =
+          alias_list
+          |> Enum.sort()
+          |> Enum.map_join(", ", &("-" <> Atom.to_string(&1)))
+
+        base <> " (alias: #{alias_str})"
     end
   end
 end
diff --git a/lib/elixir/lib/partition_supervisor.ex b/lib/elixir/lib/partition_supervisor.ex
new file mode 100644
index 00000000000..401936e31e0
--- /dev/null
+++ b/lib/elixir/lib/partition_supervisor.ex
@@ -0,0 +1,552 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule PartitionSupervisor do
+  @moduledoc """
+  A supervisor that starts multiple partitions of the same child.
+
+  Certain processes may become bottlenecks in large systems.
+  If those processes can have their state trivially partitioned,
+  in a way there is no dependency between them, then they can use
+  the `PartitionSupervisor` to create multiple isolated and
+  independent partitions.
+
+  Once the `PartitionSupervisor` starts, you can dispatch to its
+  children using `{:via, PartitionSupervisor, {name, key}}`, where
+  `name` is the name of the `PartitionSupervisor` and key is used
+  for routing.
+
+  This module was introduced in Elixir v1.14.0.
+
+  ## Simple Example
+
+  Let's start with an example which is not useful per se, but shows how the
+  partitions are started and how messages are routed to them.
+
+  Here's a toy GenServer that simply collects the messages it's given.
+  It prints them for easy illustration.
+
+      defmodule Collector do
+        use GenServer
+
+        def start_link(args) do
+          GenServer.start_link(__MODULE__, args)
+        end
+
+        def init(args) do
+          IO.inspect([__MODULE__, " got args ", args, " in ", self()])
+          {:ok, _initial_state = []}
+        end
+
+        def collect(server, msg) do
+          GenServer.call(server, {:collect, msg})
+        end
+
+        def handle_call({:collect, msg}, _from, state) do
+          new_state = [msg | state]
+          IO.inspect(["current messages:", new_state, " in process", self()])
+          {:reply, :ok, new_state}
+        end
+      end
+
+  To run multiple of these, we can start them under a `PartitionSupervisor` by placing
+  this in our supervision tree:
+
+      {PartitionSupervisor,
+        child_spec: Collector.child_spec([some: :arg]),
+        name: MyApp.PartitionSupervisor
+      }
+
+  We can send messages to them using a "via tuple":
+
+      # The key is used to route our message to a particular instance.
+      key = 1
+      Collector.collect({:via, PartitionSupervisor, {MyApp.PartitionSupervisor, key}}, :hi)
+      # ["current messages:", [:hi], " in process", #PID<0.602.0>]
+      :ok
+      Collector.collect({:via, PartitionSupervisor, {MyApp.PartitionSupervisor, key}}, :ho)
+      # ["current messages:", [:ho, :hi], " in process", #PID<0.602.0>]
+      :ok
+
+      # With a different key, the message will be routed to a different instance.
+      key = 2
+      Collector.collect({:via, PartitionSupervisor, {MyApp.PartitionSupervisor, key}}, :a)
+      # ["current messages:", [:a], " in process", #PID<0.603.0>]
+      :ok
+      Collector.collect({:via, PartitionSupervisor, {MyApp.PartitionSupervisor, key}}, :b)
+      # ["current messages:", [:b, :a], " in process", #PID<0.603.0>]
+      :ok
+
+  Now let's move on to a useful example.
+
+  ## `DynamicSupervisor` Example
+
+  The `DynamicSupervisor` is a single process responsible for starting
+  other processes. In some applications, the `DynamicSupervisor` may
+  become a bottleneck. To address this, you can start multiple instances
+  of the `DynamicSupervisor` through a `PartitionSupervisor`, and then
+  pick a "random" instance to start the child on.
+
+  Instead of starting a single `DynamicSupervisor`:
+
+      children = [
+        {DynamicSupervisor, name: MyApp.DynamicSupervisor}
+      ]
+
+      Supervisor.start_link(children, strategy: :one_for_one)
+
+  and starting children on that dynamic supervisor directly:
+
+      DynamicSupervisor.start_child(MyApp.DynamicSupervisor, {Agent, fn -> %{} end})
+
+  You can start the dynamic supervisors under a `PartitionSupervisor`:
+
+      children = [
+        {PartitionSupervisor,
+         child_spec: DynamicSupervisor,
+         name: MyApp.DynamicSupervisors}
+      ]
+
+      Supervisor.start_link(children, strategy: :one_for_one)
+
+  and then:
+
+      DynamicSupervisor.start_child(
+        {:via, PartitionSupervisor, {MyApp.DynamicSupervisors, self()}},
+        {Agent, fn -> %{} end}
+      )
+
+  In the code above, we start a partition supervisor that will by default
+  start a dynamic supervisor for each core in your machine. Then, instead
+  of calling the `DynamicSupervisor` by name, you call it through the
+  partition supervisor using the `{:via, PartitionSupervisor, {name, key}}`
+  format. We picked `self()` as the routing key, which means each process
+  will be assigned one of the existing dynamic supervisors. See `start_link/1`
+  to see all options supported by the `PartitionSupervisor`.
+
+  ## Implementation notes
+
+  The `PartitionSupervisor` uses either an ETS table or a `Registry` to
+  manage all of the partitions. Under the hood, the `PartitionSupervisor`
+  generates a child spec for each partition and then acts as a regular
+  supervisor. The ID of each child spec is the partition number.
+
+  For routing, two strategies are used. If `key` is an integer, it is routed
+  using `rem(abs(key), partitions)` where `partitions` is the number of
+  partitions. Otherwise it uses `:erlang.phash2(key, partitions)`.
+  The particular routing may change in the future, and therefore must not
+  be relied on. If you want to retrieve a particular PID for a certain key,
+  you can use `GenServer.whereis({:via, PartitionSupervisor, {name, key}})`.
+  """
+
+  @moduledoc since: "1.14.0"
+
+  @behaviour Supervisor
+
+  @registry PartitionSupervisor.Registry
+
+  @typedoc """
+  The name of the `PartitionSupervisor`.
+  """
+  @typedoc since: "1.14.0"
+  @type name :: atom() | {:via, module(), term()}
+
+  @typedoc """
+  The "identifier" of a partition.
+  """
+  @typedoc since: "1.19.0"
+  @type partition() :: non_neg_integer()
+
+  @typedoc """
+  The possible options to give to `start_link/0`.
+  """
+  @typedoc since: "1.19.0"
+  @type start_link_option ::
+          {:name, name}
+          | {:child_spec, Supervisor.child_spec() | Supervisor.module_spec()}
+          | {:partitions, pos_integer()}
+          | {:strategy, Supervisor.strategy()}
+          | {:max_restarts, non_neg_integer()}
+          | {:max_seconds, non_neg_integer()}
+          | {:with_arguments, (args :: [term()], partition() -> updated_args :: [term()])}
+
+  @doc false
+  def child_spec(opts) when is_list(opts) do
+    id =
+      case Keyword.get(opts, :name, PartitionSupervisor) do
+        name when is_atom(name) -> name
+        {:via, _module, name} -> name
+      end
+
+    %{
+      id: id,
+      start: {PartitionSupervisor, :start_link, [opts]},
+      type: :supervisor
+    }
+  end
+
+  @doc """
+  Starts a partition supervisor with the given options.
+
+  This function is typically not invoked directly, instead it is invoked
+  when using a `PartitionSupervisor` as a child of another supervisor:
+
+      children = [
+        {PartitionSupervisor, child_spec: SomeChild, name: MyPartitionSupervisor}
+      ]
+
+  If the supervisor is successfully spawned, this function returns
+  `{:ok, pid}`, where `pid` is the PID of the supervisor. If the given name
+  for the partition supervisor is already assigned to a process,
+  the function returns `{:error, {:already_started, pid}}`, where `pid`
+  is the PID of that process.
+
+  Note that a supervisor started with this function is linked to the parent
+  process and exits not only on crashes but also if the parent process exits
+  with `:normal` reason.
+
+  ## Options
+
+  See `t:start_link_option/0` for the type of each option.
+
+    * `:name` - an atom or via tuple representing the name of the partition
+      supervisor. *Required*.
+
+    * `:child_spec` - the child spec to be used when starting the partitions. *Required*.
+
+    * `:partitions` - the number of partitions.
+      Defaults to `System.schedulers_online/0` (typically the number of cores).
+
+    * `:strategy` - the restart strategy option.
+      You can learn more about strategies in the `Supervisor` module docs.
+      Defaults to `:one_for_one`.
+
+    * `:max_restarts` - the maximum number of restarts allowed in
+      a time frame. Defaults to `3`.
+
+    * `:max_seconds` - the time frame in which `:max_restarts` applies.
+      Defaults to `5`.
+
+    * `:with_arguments` - a two-argument anonymous function that allows
+      the partition to be given to the child starting function. It takes the list of arguments
+      passed to the child start function and the partition itself, and must return
+      possibly-updated arguments to give to the child start function. See the
+      `:with_arguments` section below.
+
+  ## `:with_arguments`
+
+  Sometimes you want each partition to know their partition assigned number.
+  This can be done with the `:with_arguments` option. This function receives
+  the value of the `:child_spec` option and an integer for the partition
+  number. It must return a new list of arguments that will be used to start the
+  partition process.
+
+  For example, most processes are started by calling `start_link(opts)`,
+  where `opts` is a keyword list. You could inject the partition into the
+  options given to the child:
+
+      with_arguments: fn [opts], partition ->
+        [Keyword.put(opts, :partition, partition)]
+      end
+
+  """
+  @doc since: "1.14.0"
+  @spec start_link([start_link_option()]) :: Supervisor.on_start()
+  def start_link(opts) when is_list(opts) do
+    name = opts[:name]
+
+    if !name do
+      raise ArgumentError, "the :name option must be given to PartitionSupervisor"
+    end
+
+    {child_spec, opts} = Keyword.pop(opts, :child_spec)
+
+    if !child_spec do
+      raise ArgumentError, "the :child_spec option must be given to PartitionSupervisor"
+    end
+
+    {partitions, opts} = Keyword.pop(opts, :partitions, System.schedulers_online())
+
+    if not (is_integer(partitions) and partitions >= 1) do
+      raise ArgumentError,
+            "the :partitions option must be a positive integer, got: #{inspect(partitions)}"
+    end
+
+    {with_arguments, opts} = Keyword.pop(opts, :with_arguments, fn args, _partition -> args end)
+
+    if not is_function(with_arguments, 2) do
+      raise ArgumentError,
+            "the :with_arguments option must be a function that receives two arguments, " <>
+              "the current call arguments and the partition, got: #{inspect(with_arguments)}"
+    end
+
+    %{start: {mod, fun, args}} = map = Supervisor.child_spec(child_spec, [])
+    modules = map[:modules] || [mod]
+
+    children =
+      for partition <- 0..(partitions - 1) do
+        args = with_arguments.(args, partition)
+
+        if not is_list(args) do
+          raise "the call to the function in :with_arguments must return a list, got: #{inspect(args)}"
+        end
+
+        start = {__MODULE__, :start_child, [mod, fun, args, partition]}
+        Map.merge(map, %{id: partition, start: start, modules: modules})
+      end
+
+    auto_shutdown = Keyword.get(opts, :auto_shutdown, :never)
+
+    if auto_shutdown != :never do
+      raise ArgumentError,
+            "the :auto_shutdown option must be :never, got: #{inspect(auto_shutdown)}"
+    end
+
+    {init_opts, start_opts} =
+      Keyword.split(opts, [:strategy, :max_seconds, :max_restarts, :auto_shutdown])
+
+    Supervisor.start_link(__MODULE__, {name, partitions, children, init_opts}, start_opts)
+  end
+
+  @doc false
+  def start_child(mod, fun, args, partition) do
+    case apply(mod, fun, args) do
+      {:ok, pid} ->
+        register_child(partition, pid)
+        {:ok, pid}
+
+      {:ok, pid, info} ->
+        register_child(partition, pid)
+        {:ok, pid, info}
+
+      other ->
+        other
+    end
+  end
+
+  defp register_child(partition, pid) do
+    :ets.insert(Process.get(:ets_table), {partition, pid})
+  end
+
+  @impl true
+  def init({name, partitions, children, init_opts}) do
+    table = init_table(name)
+    :ets.insert(table, {:partitions, partitions, partitions})
+    Process.put(:ets_table, table)
+    Supervisor.init(children, Keyword.put_new(init_opts, :strategy, :one_for_one))
+  end
+
+  defp init_table(name) when is_atom(name) do
+    :ets.new(name, [:set, :named_table, :public, read_concurrency: true])
+  end
+
+  defp init_table({:via, _, _}) do
+    table = :ets.new(__MODULE__, [:set, :public, read_concurrency: true])
+    ensure_registry()
+    Registry.register(@registry, self(), table)
+    table
+  end
+
+  defp ensure_registry do
+    if Process.whereis(@registry) == nil do
+      Supervisor.start_child(:elixir_sup, {Registry, keys: :unique, name: @registry})
+    end
+  end
+
+  @doc """
+  Resizes the number of partitions in the PartitionSupervisor.
+
+  This is done by starting or stopping a given number of
+  partitions in the supervisor. All of the child specifications
+  are kept in the `PartitionSupervisor` itself.
+
+  The final number of partitions cannot be less than zero and
+  cannot be more than the number of partitions the supervisor
+  started with.
+  """
+  @doc since: "1.18.0"
+  @spec resize!(name(), non_neg_integer()) :: non_neg_integer()
+  def resize!(name, partitions) when is_integer(partitions) do
+    supervisor =
+      GenServer.whereis(name) || exit({:noproc, {__MODULE__, :resize!, [name, partitions]}})
+
+    table = table(name)
+    ensure_registry()
+
+    Registry.lock(@registry, supervisor, fn ->
+      case :ets.lookup(table, :partitions) do
+        [{:partitions, _current, max}] when partitions not in 0..max//1 ->
+          raise ArgumentError,
+                "the number of partitions to resize to must be a number between 0 and #{max}, got: #{partitions}"
+
+        [{:partitions, current, max}] when partitions > current ->
+          for id <- current..(partitions - 1) do
+            case Supervisor.restart_child(supervisor, id) do
+              {:ok, _} ->
+                :ok
+
+              {:ok, _, _} ->
+                :ok
+
+              {:error, reason} ->
+                raise "cannot restart partition #{id} of PartitionSupervisor #{inspect(name)} due to reason #{inspect(reason)}"
+            end
+          end
+
+          :ets.insert(table, {:partitions, partitions, max})
+          current
+
+        [{:partitions, current, max}] when partitions < current ->
+          :ets.insert(table, {:partitions, partitions, max})
+
+          for id <- partitions..(current - 1) do
+            case Supervisor.terminate_child(supervisor, id) do
+              :ok ->
+                :ok
+
+              {:error, reason} ->
+                raise "cannot terminate partition #{id} of PartitionSupervisor #{inspect(name)} due to reason #{inspect(reason)}"
+            end
+          end
+
+          current
+
+        [{:partitions, current, _max}] ->
+          current
+      end
+    end)
+  end
+
+  @doc """
+  Returns the number of partitions for the partition supervisor.
+  """
+  @doc since: "1.14.0"
+  @spec partitions(name()) :: pos_integer()
+  def partitions(name) do
+    name |> table() |> partitions(name)
+  end
+
+  defp partitions(table, name) do
+    try do
+      :ets.lookup_element(table, :partitions, 2)
+    rescue
+      _ -> exit({:noproc, {__MODULE__, :partitions, [name]}})
+    end
+  end
+
+  defp table(name) when is_atom(name) do
+    name
+  end
+
+  # For whereis_name, we want to lookup on GenServer.whereis/1
+  # just once, so we lookup the name and partitions together.
+  defp table(name) when is_tuple(name) do
+    with pid when is_pid(pid) <- GenServer.whereis(name),
+         [{_, table}] <- Registry.lookup(@registry, pid) do
+      table
+    else
+      _ -> exit({:noproc, {__MODULE__, :partitions, [name]}})
+    end
+  end
+
+  @doc """
+  Returns a list with information about all children of the given supervisor.
+
+  This function returns a list of tuples containing:
+
+    * `id` - the partition number
+
+    * `child` - the PID of the corresponding child process or the
+      atom `:restarting` if the process is about to be restarted
+
+    * `type` - `:worker` or `:supervisor` as defined in the child
+      specification
+
+    * `modules` - as defined in the child specification
+
+  """
+  @doc since: "1.14.0"
+  @spec which_children(name()) :: [
+          # Inlining [module()] | :dynamic here because :supervisor.modules() is not exported
+          {integer(), pid | :restarting, :worker | :supervisor, [module()] | :dynamic}
+        ]
+  def which_children(name) when is_atom(name) or elem(name, 0) == :via do
+    Supervisor.which_children(name)
+  end
+
+  @doc """
+  Returns a map containing count values for the supervisor.
+
+  The map contains the following keys:
+
+    * `:specs` - the number of partitions (children processes)
+
+    * `:active` - the count of all actively running child processes managed by
+      this supervisor
+
+    * `:supervisors` - the count of all supervisors whether or not the child
+      process is still alive
+
+    * `:workers` - the count of all workers, whether or not the child process
+      is still alive
+
+  """
+  @doc since: "1.14.0"
+  @spec count_children(name()) :: %{
+          specs: non_neg_integer,
+          active: non_neg_integer,
+          supervisors: non_neg_integer,
+          workers: non_neg_integer
+        }
+  def count_children(supervisor) when is_atom(supervisor) do
+    Supervisor.count_children(supervisor)
+  end
+
+  @doc """
+  Synchronously stops the given partition supervisor with the given `reason`.
+
+  It returns `:ok` if the supervisor terminates with the given
+  reason. If it terminates with another reason, the call exits.
+
+  This function keeps OTP semantics regarding error reporting.
+  If the reason is any other than `:normal`, `:shutdown` or
+  `{:shutdown, _}`, an error report is logged.
+  """
+  @doc since: "1.14.0"
+  @spec stop(name(), reason :: term, timeout) :: :ok
+  def stop(supervisor, reason \\ :normal, timeout \\ :infinity) when is_atom(supervisor) do
+    Supervisor.stop(supervisor, reason, timeout)
+  end
+
+  ## Via callbacks
+
+  @doc false
+  def whereis_name({name, key}) when is_atom(name) or is_tuple(name) do
+    table = table(name)
+    partitions = partitions(table, name)
+
+    if partitions == 0 do
+      raise ArgumentError, "PartitionSupervisor #{inspect(name)} has zero partitions"
+    end
+
+    partition =
+      if is_integer(key), do: rem(abs(key), partitions), else: :erlang.phash2(key, partitions)
+
+    :ets.lookup_element(table, partition, 2)
+  end
+
+  @doc false
+  def send(name_key, msg) do
+    Kernel.send(whereis_name(name_key), msg)
+  end
+
+  @doc false
+  def register_name(_, _) do
+    raise "{:via, PartitionSupervisor, _} cannot be given on registration"
+  end
+
+  @doc false
+  def unregister_name(_) do
+    raise "{:via, PartitionSupervisor, _} cannot be given on unregistration"
+  end
+end
diff --git a/lib/elixir/lib/path.ex b/lib/elixir/lib/path.ex
index 1dd4068a18b..46461f116c2 100644
--- a/lib/elixir/lib/path.ex
+++ b/lib/elixir/lib/path.ex
@@ -1,25 +1,37 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Path do
   @moduledoc """
   This module provides conveniences for manipulating or
   retrieving file system paths.
 
-  The functions in this module may receive a char data as
-  argument (i.e. a string or a list of characters / string)
-  and will always return a string (encoded in UTF-8).
+  The functions in this module may receive chardata as
+  arguments and will always return a string encoded in UTF-8. Chardata
+  is a string or a list of characters and strings, see `t:IO.chardata/0`.
+  If a binary is given, in whatever encoding, its encoding will be kept.
 
   The majority of the functions in this module do not
   interact with the file system, except for a few functions
-  that require it (like `wildcard/1` and `expand/1`).
+  that require it (like `wildcard/2` and `expand/1`).
+  """
+
+  @typedoc """
+  A path.
   """
+  @type t :: IO.chardata()
 
-  alias :filename, as: FN
-  @type t :: :unicode.chardata()
+  @type relative_to_opts :: [force: boolean()]
 
   @doc """
-  Converts the given path to an absolute one. Unlike
-  `expand/1`, no attempt is made to resolve `..`, `.` or `~`.
+  Converts the given path to an absolute one.
+
+  Unlike `expand/1`, no attempt is made to resolve `..`, `.`, or `~`.
+
+  ## Examples
 
-  ## Unix examples
+  ### Unix-like operating systems
 
       Path.absname("foo")
       #=> "/usr/local/foo"
@@ -27,25 +39,28 @@ defmodule Path do
       Path.absname("../x")
       #=> "/usr/local/../x"
 
-  ## Windows
+  ### Windows
 
-      Path.absname("foo").
-      "D:/usr/local/foo"
-      Path.absname("../x").
-      "D:/usr/local/../x"
+      Path.absname("foo")
+      #=> "D:/usr/local/foo"
+
+      Path.absname("../x")
+      #=> "D:/usr/local/../x"
 
   """
   @spec absname(t) :: binary
   def absname(path) do
-    absname(path, System.cwd!)
+    absname(path, &File.cwd!/0)
   end
 
   @doc """
-  Builds a path from `relative_to` to `path`. If `path` is already
-  an absolute path, `relative_to` is ignored. See also `relative_to/2`.
+  Builds a path from `relative_to` to `path`.
 
-  Unlike `expand/2`, no attempt is made to
-  resolve `..`, `.` or `~`.
+  If `path` is already an absolute path, `relative_to` is ignored. See also
+  `relative_to/3`. `relative_to` is either a path or an anonymous function,
+  which is invoked only when necessary, that returns a path.
+
+  Unlike `expand/2`, no attempt is made to resolve `..`, `.` or `~`.
 
   ## Examples
 
@@ -55,66 +70,138 @@ defmodule Path do
       iex> Path.absname("../x", "bar")
       "bar/../x"
 
+      iex> Path.absname("foo", fn -> "lazy" end)
+      "lazy/foo"
+
   """
-  @spec absname(t, t) :: binary
+  @spec absname(t, t | (-> t)) :: binary
   def absname(path, relative_to) do
     path = IO.chardata_to_string(path)
+
     case type(path) do
-      :relative -> join(relative_to, path)
+      :relative ->
+        relative_to =
+          if is_function(relative_to, 0) do
+            relative_to.()
+          else
+            relative_to
+          end
+
+        absname_join([relative_to, path])
+
       :absolute ->
-        cond do
-          path == "/" ->
-            path
-          :binary.last(path) == ?/ ->
-            binary_part(path, 0, byte_size(path) - 1)
-          true ->
-            path
-        end
+        absname_join([path])
+
       :volumerelative ->
-        relative_to = IO.chardata_to_string(relative_to)
+        relative_to =
+          if is_function(relative_to, 0) do
+            relative_to.()
+          else
+            relative_to
+          end
+          |> IO.chardata_to_string()
+
         absname_vr(split(path), split(relative_to), relative_to)
     end
   end
 
-  ## Absolute path on current drive
-  defp absname_vr(["/"|rest], [volume|_], _relative),
-    do: join([volume|rest])
+  # Absolute path on current drive
+  defp absname_vr(["/" | rest], [volume | _], _relative), do: absname_join([volume | rest])
 
-  ## Relative to current directory on current drive.
-  defp absname_vr([<<x, ?:>>|rest], [<<x, _ :: binary>>|_], relative),
-    do: absname(join(rest), relative)
+  # Relative to current directory on current drive
+  defp absname_vr([<<x, ?:>> | rest], [<<x, _::binary>> | _], relative),
+    do: absname(absname_join(rest), relative)
 
-  ## Relative to current directory on another drive.
-  defp absname_vr([<<x, ?:>>|name], _, _relative) do
+  # Relative to current directory on another drive
+  defp absname_vr([<<x, ?:>> | name], _, _relative) do
     cwd =
       case :file.get_cwd([x, ?:]) do
-        {:ok, dir}  -> IO.chardata_to_string(dir)
+        {:ok, dir} -> IO.chardata_to_string(dir)
         {:error, _} -> <<x, ?:, ?/>>
       end
-    absname(join(name), cwd)
+
+    absname(absname_join(name), cwd)
+  end
+
+  @slash [?/, ?\\]
+
+  defp absname_join([]), do: ""
+  defp absname_join(list), do: absname_join(list, major_os_type())
+
+  defp absname_join([name1, name2 | rest], os_type) do
+    joined = do_absname_join(IO.chardata_to_string(name1), relative(name2), [], os_type)
+    absname_join([joined | rest], os_type)
+  end
+
+  defp absname_join([name], os_type) do
+    do_absname_join(IO.chardata_to_string(name), <<>>, [], os_type)
   end
 
+  defp do_absname_join(<<uc_letter, ?:, rest::binary>>, relativename, [], :win32)
+       when uc_letter in ?A..?Z,
+       do: do_absname_join(rest, relativename, [?:, uc_letter + ?a - ?A], :win32)
+
+  defp do_absname_join(<<c1, c2, rest::binary>>, relativename, [], :win32)
+       when c1 in @slash and c2 in @slash,
+       do: do_absname_join(rest, relativename, ~c"//", :win32)
+
+  defp do_absname_join(<<?\\, rest::binary>>, relativename, result, :win32),
+    do: do_absname_join(<<?/, rest::binary>>, relativename, result, :win32)
+
+  defp do_absname_join(<<?/, rest::binary>>, relativename, [?., ?/ | result], os_type),
+    do: do_absname_join(rest, relativename, [?/ | result], os_type)
+
+  defp do_absname_join(<<?/, rest::binary>>, relativename, [?/ | result], os_type),
+    do: do_absname_join(rest, relativename, [?/ | result], os_type)
+
+  defp do_absname_join(<<>>, <<>>, result, os_type),
+    do: IO.iodata_to_binary(reverse_maybe_remove_dir_sep(result, os_type))
+
+  defp do_absname_join(<<>>, relativename, [?: | rest], :win32),
+    do: do_absname_join(relativename, <<>>, [?: | rest], :win32)
+
+  defp do_absname_join(<<>>, relativename, [?/ | result], os_type),
+    do: do_absname_join(relativename, <<>>, [?/ | result], os_type)
+
+  defp do_absname_join(<<>>, relativename, result, os_type),
+    do: do_absname_join(relativename, <<>>, [?/ | result], os_type)
+
+  defp do_absname_join(<<char, rest::binary>>, relativename, result, os_type),
+    do: do_absname_join(rest, relativename, [char | result], os_type)
+
+  defp reverse_maybe_remove_dir_sep([?/, ?:, letter], :win32), do: [letter, ?:, ?/]
+  defp reverse_maybe_remove_dir_sep([?/], _), do: [?/]
+  defp reverse_maybe_remove_dir_sep([?/ | name], _), do: :lists.reverse(name)
+  defp reverse_maybe_remove_dir_sep(name, _), do: :lists.reverse(name)
+
   @doc """
-  Converts the path to an absolute one and expands
-  any `.` and `..` characters and a leading `~`.
+  Converts the path to an absolute one, expanding
+  any `.` and `..` components and a leading `~`.
+
+  If a relative path is provided it is expanded relatively to
+  the current working directory.
 
   ## Examples
 
-      Path.expand("/foo/bar/../bar")
-      "/foo/bar"
+      Path.expand("/foo/bar/../baz")
+      #=> "/foo/baz"
+
+      Path.expand("foo/bar/../baz")
+      #=> "$PWD/foo/baz"
 
   """
   @spec expand(t) :: binary
   def expand(path) do
-    normalize absname(expand_home(path), System.cwd!)
+    expand_dot(absname(expand_home(path), &File.cwd!/0))
   end
 
   @doc """
   Expands the path relative to the path given as the second argument
-  expanding any `.` and `..` characters. If the path is already an
-  absolute path, `relative_to` is ignored.
+  expanding any `.` and `..` characters.
+
+  If the path is already an absolute path, `relative_to` is ignored.
 
-  Note, that this function treats `path` with a leading `~` as
+  Note that this function treats a `path` with a leading `~` as
   an absolute one.
 
   The second argument is first expanded to an absolute path.
@@ -126,20 +213,23 @@ defmodule Path do
       #=> "/quux/baz/foo/bar"
 
       Path.expand("foo/bar/../bar", "/baz")
-      "/baz/foo/bar"
+      #=> "/baz/foo/bar"
+
       Path.expand("/foo/bar/../bar", "/baz")
-      "/foo/bar"
+      #=> "/foo/bar"
 
   """
   @spec expand(t, t) :: binary
   def expand(path, relative_to) do
-    normalize absname(absname(expand_home(path), expand_home(relative_to)), System.cwd!)
+    expand_dot(absname(absname(expand_home(path), expand_home(relative_to)), &File.cwd!/0))
   end
 
   @doc """
   Returns the path type.
 
-  ## Unix examples
+  ## Examples
+
+  ### Unix-like operating systems
 
       Path.type("/")                #=> :absolute
       Path.type("/usr/local/bin")   #=> :absolute
@@ -147,7 +237,7 @@ defmodule Path do
       Path.type("../usr/local/bin") #=> :relative
       Path.type("~/file")           #=> :relative
 
-  ## Windows examples
+  ### Windows
 
       Path.type("D:/usr/local/bin") #=> :absolute
       Path.type("usr/local/bin")    #=> :relative
@@ -156,23 +246,26 @@ defmodule Path do
 
   """
   @spec type(t) :: :absolute | :relative | :volumerelative
-  def type(name) when is_list(name) or is_binary(name) do
-    case :os.type() do
-      {:win32, _} -> win32_pathtype(name)
-      _             -> unix_pathtype(name)
-    end |> elem(0)
+  def type(name)
+      when is_list(name)
+      when is_binary(name) do
+    pathtype(name, major_os_type()) |> elem(0)
   end
 
   @doc """
   Forces the path to be a relative path.
 
-  ## Unix examples
+  If an absolute path is given, it is stripped from its root component.
+
+  ## Examples
+
+  ### Unix-like operating systems
 
       Path.relative("/usr/local/bin")   #=> "usr/local/bin"
       Path.relative("usr/local/bin")    #=> "usr/local/bin"
       Path.relative("../usr/local/bin") #=> "../usr/local/bin"
 
-  ## Windows examples
+  ### Windows
 
       Path.relative("D:/usr/local/bin") #=> "usr/local/bin"
       Path.relative("usr/local/bin")    #=> "usr/local/bin"
@@ -180,100 +273,218 @@ defmodule Path do
       Path.relative("/bar/foo.ex")      #=> "bar/foo.ex"
 
   """
+  # Note this function does not expand paths because the behavior
+  # is ambiguous. If we expand it before converting to relative, then
+  # "/usr/../../foo" means "/foo". If we expand it after, it means "../foo".
+  # We could expand only relative paths but it is best to say it never
+  # expands and then provide a `Path.expand_relative` function (or an
+  # option) if desired.
   @spec relative(t) :: binary
   def relative(name) do
-    case :os.type() do
-      {:win32, _} -> win32_pathtype(name)
-      _           -> unix_pathtype(name)
-    end |> elem(1) |> IO.chardata_to_string
+    relative(name, major_os_type())
   end
 
-  defp unix_pathtype(<<?/, relative :: binary>>), do:
-    {:absolute, relative}
-  defp unix_pathtype([?/|relative]), do:
-    {:absolute, relative}
-  defp unix_pathtype([list|rest]) when is_list(list), do:
-    unix_pathtype(list ++ rest)
-  defp unix_pathtype(relative), do:
-    {:relative, relative}
+  defp relative(name, os_type) do
+    pathtype(name, os_type)
+    |> elem(1)
+    |> IO.chardata_to_string()
+  end
 
-  @slash [?/, ?\\]
+  defp pathtype(name, os_type) do
+    case os_type do
+      :win32 -> win32_pathtype(name)
+      _ -> unix_pathtype(name)
+    end
+  end
+
+  defp unix_pathtype(path) when path in ["/", ~c"/"], do: {:absolute, "."}
+  defp unix_pathtype(<<?/, relative::binary>>), do: {:absolute, relative}
+  defp unix_pathtype([?/ | relative]), do: {:absolute, relative}
+  defp unix_pathtype([list | rest]) when is_list(list), do: unix_pathtype(list ++ rest)
+  defp unix_pathtype(relative), do: {:relative, relative}
+
+  defp win32_pathtype([list | rest]) when is_list(list), do: win32_pathtype(list ++ rest)
+
+  defp win32_pathtype([char, list | rest]) when is_list(list),
+    do: win32_pathtype([char | list ++ rest])
+
+  defp win32_pathtype(<<c1, c2, relative::binary>>) when c1 in @slash and c2 in @slash,
+    do: {:absolute, relative}
+
+  defp win32_pathtype(<<char, relative::binary>>) when char in @slash,
+    do: {:volumerelative, relative}
+
+  defp win32_pathtype(<<_letter, ?:, char, relative::binary>>) when char in @slash,
+    do: {:absolute, relative}
+
+  defp win32_pathtype(<<_letter, ?:, relative::binary>>), do: {:volumerelative, relative}
+
+  defp win32_pathtype([c1, c2 | relative]) when c1 in @slash and c2 in @slash,
+    do: {:absolute, relative}
+
+  defp win32_pathtype([char | relative]) when char in @slash, do: {:volumerelative, relative}
+
+  defp win32_pathtype([c1, c2, list | rest]) when is_list(list),
+    do: win32_pathtype([c1, c2 | list ++ rest])
+
+  defp win32_pathtype([_letter, ?:, char | relative]) when char in @slash,
+    do: {:absolute, relative}
 
-  defp win32_pathtype([list|rest]) when is_list(list), do:
-    win32_pathtype(list++rest)
-  defp win32_pathtype([char, list|rest]) when is_list(list), do:
-    win32_pathtype([char|list++rest])
-  defp win32_pathtype(<<c1, c2, relative :: binary>>) when c1 in @slash and c2 in @slash, do:
-    {:absolute, relative}
-  defp win32_pathtype(<<c, relative :: binary>>) when c in @slash, do:
-    {:volumerelative, relative}
-  defp win32_pathtype(<<_letter, ?:, c, relative :: binary>>) when c in @slash, do:
-    {:absolute, relative}
-  defp win32_pathtype(<<_letter, ?:, relative :: binary>>), do:
-    {:volumerelative, relative}
-
-  defp win32_pathtype([c1, c2 | relative]) when c1 in @slash and c2 in @slash, do:
-    {:absolute, relative}
-  defp win32_pathtype([c | relative]) when c in @slash, do:
-    {:volumerelative, relative}
-  defp win32_pathtype([c1, c2, list|rest]) when is_list(list), do:
-    win32_pathtype([c1, c2|list++rest])
-  defp win32_pathtype([_letter, ?:, c | relative]) when c in @slash, do:
-    {:absolute, relative}
-  defp win32_pathtype([_letter, ?: | relative]), do:
-    {:volumerelative, relative}
-  defp win32_pathtype(relative), do:
-    {:relative, relative}
+  defp win32_pathtype([_letter, ?: | relative]), do: {:volumerelative, relative}
+  defp win32_pathtype(relative), do: {:relative, relative}
 
   @doc """
-  Returns the given `path` relative to the given `from` path.
-  In other words, it tries to strip the `from` prefix from `path`.
+  Returns the direct relative path from `path` in relation to `cwd`.
 
-  This function does not query the file system, so it assumes
-  no symlinks in between the paths.
+  In other words, this function attempts to return a path such that
+  `Path.expand(result, cwd)` points to `path`. This function aims
+  to return a relative path whenever possible, but that's not guaranteed:
 
-  In case a direct relative path cannot be found, it returns
-  the original path.
+    * If both paths are relative, a relative path is always returned
+
+    * If both paths are absolute, a relative path may be returned if
+      they share a common prefix. You can pass the `:force` option to
+      force this function to traverse up, but even then a relative
+      path is not guaranteed (for example, if the absolute paths
+      belong to different drives on Windows)
+
+    * If a mixture of paths are given, the result will always match
+      the given `path` (the first argument)
+
+  This function expands `.` and `..` entries without traversing the
+  file system, so it assumes no symlinks between the paths. See
+  `safe_relative_to/2` for a safer alternative.
+
+  ## Options
+
+    * `:force` - (boolean since v1.16.0) if `true` forces a relative
+    path to be returned by traversing the path up. Except if the paths
+    are in different volumes on Windows. Defaults to `false`.
 
   ## Examples
 
-      iex> Path.relative_to("/usr/local/foo", "/usr/local")
-      "foo"
+  ### With relative `cwd`
+
+  If both paths are relative, a minimum path is computed:
+
+      Path.relative_to("tmp/foo/bar", "tmp")      #=> "foo/bar"
+      Path.relative_to("tmp/foo/bar", "tmp/foo")  #=> "bar"
+      Path.relative_to("tmp/foo/bar", "tmp/bat")  #=> "../foo/bar"
+
+  If an absolute path is given with relative `cwd`, it is returned as:
+
+      Path.relative_to("/usr/foo/bar", "tmp/bat")  #=> "/usr/foo/bar"
 
-      iex> Path.relative_to("/usr/local/foo", "/")
-      "usr/local/foo"
+  ### With absolute `cwd`
 
-      iex> Path.relative_to("/usr/local/foo", "/etc")
-      "/usr/local/foo"
+  If both paths are absolute, a relative is computed if possible,
+  without traversing up:
+
+      Path.relative_to("/usr/local/foo", "/usr/local")      #=> "foo"
+      Path.relative_to("/usr/local/foo", "/")               #=> "usr/local/foo"
+      Path.relative_to("/usr/local/foo", "/etc")            #=> "/usr/local/foo"
+      Path.relative_to("/usr/local/foo", "/usr/local/foo")  #=> "."
+      Path.relative_to("/usr/local/../foo", "/usr/foo")     #=> "."
+      Path.relative_to("/usr/local/../foo/bar", "/usr/foo") #=> "bar"
+
+  If `:force` is set to `true` paths are traversed up:
+
+      Path.relative_to("/usr", "/usr/local", force: true)          #=> ".."
+      Path.relative_to("/usr/foo", "/usr/local", force: true)      #=> "../foo"
+      Path.relative_to("/usr/../foo/bar", "/etc/foo", force: true) #=> "../../foo/bar"
+
+  If a relative path is given, it is assumed to be relative to the
+  given path, so the path is returned with "." and ".." expanded:
+
+      Path.relative_to(".", "/usr/local")          #=> "."
+      Path.relative_to("foo", "/usr/local")        #=> "foo"
+      Path.relative_to("foo/../bar", "/usr/local") #=> "bar"
+      Path.relative_to("foo/..", "/usr/local")     #=> "."
+      Path.relative_to("../foo", "/usr/local")     #=> "../foo"
 
   """
-  @spec relative_to(t, t) :: binary
-  def relative_to(path, from) do
-    path = IO.chardata_to_string(path)
-    relative_to(split(path), split(from), path)
-  end
+  @spec relative_to(t, t, relative_to_opts) :: binary
+  def relative_to(path, cwd, opts \\ []) when is_list(opts) do
+    os_type = major_os_type()
+    split_path = split(path)
+    split_cwd = split(cwd)
+    force = Keyword.get(opts, :force, false)
+
+    case {split_absolute?(split_path, os_type), split_absolute?(split_cwd, os_type)} do
+      {true, true} ->
+        split_path = expand_split(split_path)
+        split_cwd = expand_split(split_cwd)
+
+        case force do
+          true -> relative_to_forced(split_path, split_cwd, split_path)
+          false -> relative_to_unforced(split_path, split_cwd, split_path)
+        end
 
-  defp relative_to([h|t1], [h|t2], original) do
-    relative_to(t1, t2, original)
-  end
+      {false, false} ->
+        split_path = expand_relative(split_path, [], [])
+        split_cwd = expand_relative(split_cwd, [], [])
+        relative_to_forced(split_path, split_cwd, [])
 
-  defp relative_to([_|_] = l1, [], _original) do
-    join(l1)
+      {_, _} ->
+        join(expand_relative(split_path, [], []))
+    end
   end
 
-  defp relative_to(_, _, original) do
-    original
+  defp relative_to_unforced(path, path, _original), do: "."
+
+  defp relative_to_unforced([h | t1], [h | t2], original),
+    do: relative_to_unforced(t1, t2, original)
+
+  defp relative_to_unforced([_ | _] = l1, [], _original), do: join(l1)
+  defp relative_to_unforced(_, _, original), do: join(original)
+
+  defp relative_to_forced(path, path, _original), do: "."
+  defp relative_to_forced(["."], _path, _original), do: "."
+  defp relative_to_forced(path, ["."], _original), do: join(path)
+  defp relative_to_forced([h | t1], [h | t2], original), do: relative_to_forced(t1, t2, original)
+
+  # this should only happen if we have two paths on different drives on windows
+  defp relative_to_forced(original, _, original), do: join(original)
+
+  defp relative_to_forced(l1, l2, _original) do
+    base = List.duplicate("..", length(l2))
+    join(base ++ l1)
   end
 
+  defp expand_relative([".." | t], [_ | acc], up), do: expand_relative(t, acc, up)
+  defp expand_relative([".." | t], acc, up), do: expand_relative(t, acc, [".." | up])
+  defp expand_relative(["." | t], acc, up), do: expand_relative(t, acc, up)
+  defp expand_relative([h | t], acc, up), do: expand_relative(t, [h | acc], up)
+  defp expand_relative([], [], []), do: ["."]
+  defp expand_relative([], acc, up), do: up ++ :lists.reverse(acc)
+
+  defp expand_split([head | tail]), do: expand_split(tail, [head])
+  defp expand_split([".." | t], [_, last | acc]), do: expand_split(t, [last | acc])
+  defp expand_split([".." | t], acc), do: expand_split(t, acc)
+  defp expand_split(["." | t], acc), do: expand_split(t, acc)
+  defp expand_split([h | t], acc), do: expand_split(t, [h | acc])
+  defp expand_split([], acc), do: :lists.reverse(acc)
+
+  defp split_absolute?(split, :win32), do: win32_split_absolute?(split)
+  defp split_absolute?(split, _), do: match?(["/" | _], split)
+
+  defp win32_split_absolute?(["//" | _]), do: true
+  defp win32_split_absolute?([<<_, ":/">> | _]), do: true
+  defp win32_split_absolute?(_), do: false
+
   @doc """
   Convenience to get the path relative to the current working
-  directory. If, for some reason, the current working directory
-  cannot be retrieved, returns the full path.
+  directory.
+
+  If, for some reason, the current working directory
+  cannot be retrieved, this function returns the given `path`.
+
+  Check `relative_to/3` for the supported options.
   """
-  @spec relative_to_cwd(t) :: binary
-  def relative_to_cwd(path) do
-    case :file.get_cwd do
-      {:ok, base} -> relative_to(path, IO.chardata_to_string(base))
+  @spec relative_to_cwd(t, relative_to_opts) :: binary
+  def relative_to_cwd(path, opts \\ []) when is_list(opts) do
+    case :file.get_cwd() do
+      {:ok, base} -> relative_to(path, IO.chardata_to_string(base), opts)
       _ -> path
     end
   end
@@ -290,19 +501,24 @@ defmodule Path do
       iex> Path.basename("foo/bar")
       "bar"
 
+      iex> Path.basename("lib/module/submodule.ex")
+      "submodule.ex"
+
       iex> Path.basename("/")
       ""
 
   """
   @spec basename(t) :: binary
   def basename(path) do
-    FN.basename(IO.chardata_to_string(path))
+    :filename.basename(IO.chardata_to_string(path))
   end
 
   @doc """
   Returns the last component of `path` with the `extension`
-  stripped. This function should be used to remove a specific
-  extension which may, or may not, be there.
+  stripped.
+
+  This function should be used to remove a specific
+  extension which may or may not be there.
 
   ## Examples
 
@@ -318,7 +534,7 @@ defmodule Path do
   """
   @spec basename(t, t) :: binary
   def basename(path, extension) do
-    FN.basename(IO.chardata_to_string(path), IO.chardata_to_string(extension))
+    :filename.basename(IO.chardata_to_string(path), IO.chardata_to_string(extension))
   end
 
   @doc """
@@ -326,20 +542,33 @@ defmodule Path do
 
   ## Examples
 
-      Path.dirname("/foo/bar.ex")
-      #=> "/foo"
-      Path.dirname("/foo/bar/baz.ex")
-      #=> "/foo/bar"
+      iex> Path.dirname("/foo/bar.ex")
+      "/foo"
+
+      iex> Path.dirname("/foo/bar/baz.ex")
+      "/foo/bar"
+
+      iex> Path.dirname("/foo/bar/")
+      "/foo/bar"
+
+      iex> Path.dirname("bar.ex")
+      "."
 
   """
   @spec dirname(t) :: binary
   def dirname(path) do
-    FN.dirname(IO.chardata_to_string(path))
+    :filename.dirname(IO.chardata_to_string(path))
   end
 
   @doc """
   Returns the extension of the last component of `path`.
 
+  For filenames starting with a dot and without an extension, it returns
+  an empty string.
+
+  See `basename/1` and `rootname/1` for related functions to extract
+  information from paths.
+
   ## Examples
 
       iex> Path.extname("foo.erl")
@@ -348,10 +577,13 @@ defmodule Path do
       iex> Path.extname("~/foo/bar")
       ""
 
+      iex> Path.extname(".gitignore")
+      ""
+
   """
   @spec extname(t) :: binary
   def extname(path) do
-    FN.extension(IO.chardata_to_string(path))
+    :filename.extension(IO.chardata_to_string(path))
   end
 
   @doc """
@@ -368,12 +600,14 @@ defmodule Path do
   """
   @spec rootname(t) :: binary
   def rootname(path) do
-    FN.rootname(IO.chardata_to_string(path))
+    :filename.rootname(IO.chardata_to_string(path))
   end
 
   @doc """
-  Returns the `path` with the `extension` stripped. This function should be used to
-  remove a specific extension which might, or might not, be there.
+  Returns the `path` with the `extension` stripped.
+
+  This function should be used to remove a specific extension which may
+  or may not be there.
 
   ## Examples
 
@@ -386,14 +620,16 @@ defmodule Path do
   """
   @spec rootname(t, t) :: binary
   def rootname(path, extension) do
-    FN.rootname(IO.chardata_to_string(path), IO.chardata_to_string(extension))
+    :filename.rootname(IO.chardata_to_string(path), IO.chardata_to_string(extension))
   end
 
   @doc """
-  Returns a string with one or more path components joined by the path separator.
+  Joins a list of paths.
+
+  This function should be used to convert a list of paths to a path.
+  Note that any trailing slash is removed when joining.
 
-  This function should be used to convert a list of strings to a path.
-  Note that any trailing slash is removed on join.
+  Raises an error if the given list of paths is empty.
 
   ## Examples
 
@@ -407,139 +643,157 @@ defmodule Path do
       "/foo/bar"
 
   """
-  @spec join([t]) :: binary
-  def join([name1, name2|rest]), do:
-    join([join(name1, name2)|rest])
-  def join([name]), do:
-    do_join(IO.chardata_to_string(name), <<>>, [], major_os_type())
+  @spec join(nonempty_list(t)) :: binary
+  def join([name1, name2 | rest]), do: join([join(name1, name2) | rest])
+  def join([name]), do: IO.chardata_to_string(name)
 
   @doc """
   Joins two paths.
 
+  The right path will always be expanded to its relative format
+  and any trailing slash will be removed when joining.
+
   ## Examples
 
       iex> Path.join("foo", "bar")
       "foo/bar"
 
+      iex> Path.join("/foo", "/bar/")
+      "/foo/bar"
+
+  The functions in this module support chardata, so giving a list will
+  treat it as a single entity:
+
+      iex> Path.join("foo", ["bar", "fiz"])
+      "foo/barfiz"
+
+      iex> Path.join(["foo", "bar"], "fiz")
+      "foobar/fiz"
+
+  Use `join/1` if you need to join a list of paths instead.
   """
   @spec join(t, t) :: binary
-  def join(left, right),
-    do: do_join(IO.chardata_to_string(left), relative(right), [], major_os_type())
+  def join(left, right) do
+    left = IO.chardata_to_string(left)
+    os_type = major_os_type()
+    do_join(left, right, os_type) |> remove_dir_sep(os_type)
+  end
 
-  defp major_os_type do
-    :os.type |> elem(0)
-  end
-
-  defp do_join(<<uc_letter, ?:, rest :: binary>>, relativename, [], :win32) when uc_letter in ?A..?Z, do:
-    do_join(rest, relativename, [?:, uc_letter+?a-?A], :win32)
-  defp do_join(<<?\\, rest :: binary>>, relativename, result, :win32), do:
-    do_join(<<?/, rest :: binary>>, relativename, result, :win32)
-  defp do_join(<<?/, rest :: binary>>, relativename, [?., ?/|result], os_type), do:
-    do_join(rest, relativename, [?/|result], os_type)
-  defp do_join(<<?/, rest :: binary>>, relativename, [?/|result], os_type), do:
-    do_join(rest, relativename, [?/|result], os_type)
-  defp do_join(<<>>, <<>>, result, os_type), do:
-    IO.iodata_to_binary(maybe_remove_dirsep(result, os_type))
-  defp do_join(<<>>, relativename, [?:|rest], :win32), do:
-    do_join(relativename, <<>>, [?:|rest], :win32)
-  defp do_join(<<>>, relativename, [?/|result], os_type), do:
-    do_join(relativename, <<>>, [?/|result], os_type)
-  defp do_join(<<>>, relativename, result, os_type), do:
-    do_join(relativename, <<>>, [?/|result], os_type)
-  defp do_join(<<char, rest :: binary>>, relativename, result, os_type), do:
-    do_join(rest, relativename, [char|result], os_type)
-
-  defp maybe_remove_dirsep([?/, ?:, letter], :win32), do:
-    [letter, ?:, ?/]
-  defp maybe_remove_dirsep([?/], _), do:
-    [?/]
-  defp maybe_remove_dirsep([?/|name], _), do:
-    :lists.reverse(name)
-  defp maybe_remove_dirsep(name, _), do:
-    :lists.reverse(name)
+  defp do_join(left, "/", os_type), do: remove_dir_sep(left, os_type)
+  defp do_join("", right, os_type), do: relative(right, os_type)
+  defp do_join("/", right, os_type), do: "/" <> relative(right, os_type)
 
-  @doc """
-  Returns a list with the path split by the path separator.
-  If an empty string is given, returns the root path.
+  defp do_join(left, right, os_type),
+    do: remove_dir_sep(left, os_type) <> "/" <> relative(right, os_type)
+
+  defp remove_dir_sep("", _os_type), do: ""
+  defp remove_dir_sep("/", _os_type), do: "/"
+
+  defp remove_dir_sep(bin, os_type) do
+    last = :binary.last(bin)
+
+    if last == ?/ or (last == ?\\ and os_type == :win32) do
+      binary_part(bin, 0, byte_size(bin) - 1)
+    else
+      bin
+    end
+  end
+
+  @doc ~S"""
+  Splits the path into a list at the path separator.
+
+  If an empty string is given, returns an empty list.
+
+  On Windows, path is split on both `"\"` and `"/"` separators
+  and the driver letter, if there is one, is always returned
+  in lowercase.
 
   ## Examples
 
-       iex> Path.split("")
-       []
+      iex> Path.split("")
+      []
 
-       iex> Path.split("foo")
-       ["foo"]
+      iex> Path.split("foo")
+      ["foo"]
 
-       iex> Path.split("/foo/bar")
-       ["/", "foo", "bar"]
+      iex> Path.split("/foo/bar")
+      ["/", "foo", "bar"]
 
   """
   @spec split(t) :: [binary]
-
-  # Work around a bug in Erlang on UNIX
-  def split(""), do: []
-
   def split(path) do
-    FN.split(IO.chardata_to_string(path))
+    :filename.split(IO.chardata_to_string(path))
   end
 
   defmodule Wildcard do
     @moduledoc false
 
+    def read_link_info(file) do
+      :file.read_link_info(file)
+    end
+
     def read_file_info(file) do
-      call({:read_link_info, file})
+      :file.read_file_info(file)
     end
 
     def list_dir(dir) do
-      case call({:list_dir, dir})  do
-        {:ok, files} ->
-          {:ok, for(file <- files, hd(file) != ?., do: file)}
-        other ->
-          other
+      case :file.list_dir(dir) do
+        {:ok, files} -> {:ok, for(file <- files, hd(file) != ?., do: file)}
+        other -> other
       end
     end
-
-    @compile {:inline, call: 1}
-
-    defp call(tuple) do
-      x = :erlang.dt_spread_tag(true)
-      y = :gen_server.call(:file_server_2, tuple)
-      :erlang.dt_restore_tag(x)
-      y
-    end
   end
 
-  @doc """
-  Traverses paths according to the given `glob` expression.
+  @doc ~S"""
+  Traverses paths according to the given `glob` expression and returns a
+  list of matches.
 
-  The wildcard looks like an ordinary path, except that certain
-  "wildcard characters" are interpreted in a special way. The
-  following characters are special:
+  The wildcard looks like an ordinary path, except that the following
+  "wildcard characters" are interpreted in a special way:
 
-    * `?` - matches one character
+    * `?` - matches one character.
 
     * `*` - matches any number of characters up to the end of the filename, the
-      next dot, or the next slash
+      next dot, or the next slash.
 
     * `**` - two adjacent `*`'s used as a single pattern will match all
-      files and zero or more directories and subdirectories
+      files and zero or more directories and subdirectories.
 
     * `[char1,char2,...]` - matches any of the characters listed; two
-      characters separated by a hyphen will match a range of characters
+      characters separated by a hyphen will match a range of characters.
+      Do not add spaces before and after the comma as it would then match
+      paths containing the space character itself.
 
-    * `{item1,item2,...}` - matches one of the alternatives
+    * `{item1,item2,...}` - matches one of the alternatives.
+      Do not add spaces before and after the comma as it would then match
+      paths containing the space character itself.
 
   Other characters represent themselves. Only paths that have
   exactly the same character in the same position will match. Note
-  that matching is case-sensitive; i.e. "a" will not match "A".
+  that matching is case-sensitive: `"a"` will not match `"A"`.
+
+  Directory separators must always be written as `/`, even on Windows.
+  You may call `Path.expand/1` to normalize the path before invoking
+  this function.
+
+  A character preceded by `\\` loses its special meaning.
+  Note that `\\` must be written as `\\\\` in a string literal.
+  For example, `"\\\\?*"` will match any filename starting with `?.`.
 
   By default, the patterns `*` and `?` do not match files starting
-  with a dot `.` unless `match_dot: true` is given.
+  with a dot `.`. See the `:match_dot` option in the "Options" section
+  below.
+
+  ## Options
+
+    * `:match_dot` - (boolean) if `false`, the special wildcard characters `*` and `?`
+      will not match files starting with a dot (`.`). If `true`, files starting with
+      a `.` will not be treated specially. Defaults to `false`.
 
   ## Examples
 
   Imagine you have a directory called `projects` with three Elixir projects
-  inside of it: `elixir`, `ex_doc` and `dynamo`. You can find all `.beam` files
+  inside of it: `elixir`, `ex_doc`, and `plug`. You can find all `.beam` files
   inside the `ebin` directory of each project as follows:
 
       Path.wildcard("projects/*/ebin/**/*.beam")
@@ -549,21 +803,25 @@ defmodule Path do
       Path.wildcard("projects/*/ebin/**/*.{beam,app}")
 
   """
-  @spec wildcard(t) :: [binary]
-  def wildcard(glob, opts \\ []) do
+  @spec wildcard(t, match_dot: boolean()) :: [binary]
+  def wildcard(glob, opts \\ []) when is_list(opts) do
     mod = if Keyword.get(opts, :match_dot), do: :file, else: Path.Wildcard
+
     glob
-    |> chardata_to_list()
+    |> chardata_to_list!()
     |> :filelib.wildcard(mod)
     |> Enum.map(&IO.chardata_to_string/1)
   end
 
-  # Normalize the given path by expanding "..", "." and "~".
-
-  defp chardata_to_list(chardata) do
+  defp chardata_to_list!(chardata) do
     case :unicode.characters_to_list(chardata) do
       result when is_list(result) ->
-        result
+        if 0 in result do
+          raise ArgumentError,
+                "cannot execute Path.wildcard/2 for path with null byte, got: #{inspect(chardata)}"
+        else
+          result
+        end
 
       {:error, encoded, rest} ->
         raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :invalid
@@ -575,34 +833,91 @@ defmodule Path do
 
   defp expand_home(type) do
     case IO.chardata_to_string(type) do
-      "~" <> rest -> System.user_home! <> rest
-      rest        -> rest
+      "~" <> rest -> resolve_home(rest)
+      rest -> rest
     end
   end
 
-  defp normalize(path), do: normalize(split(path), [])
+  defp resolve_home(""), do: System.user_home!()
 
-  defp normalize([".."|t], ["/"|_] = acc) do
-    normalize t, acc
+  defp resolve_home(rest) do
+    case {rest, major_os_type()} do
+      {"\\" <> _, :win32} -> System.user_home!() <> rest
+      {"/" <> _, _} -> System.user_home!() <> rest
+      _ -> "~" <> rest
+    end
   end
 
-  defp normalize([".."|t], [<<letter, ?:, ?/>>|_] = acc) when letter in ?a..?z do
-    normalize t, acc
+  # expands dots in an absolute path represented as a string
+  defp expand_dot(path) do
+    [head | tail] = :binary.split(path, "/", [:global])
+    IO.iodata_to_binary(expand_dot(tail, [head <> "/"]))
   end
 
-  defp normalize([".."|t], [_|acc]) do
-    normalize t, acc
-  end
+  defp expand_dot([".." | t], [_, _ | acc]), do: expand_dot(t, acc)
+  defp expand_dot([".." | t], acc), do: expand_dot(t, acc)
+  defp expand_dot(["." | t], acc), do: expand_dot(t, acc)
+  defp expand_dot([h | t], acc), do: expand_dot(t, ["/", h | acc])
+  defp expand_dot([], ["/", head | acc]), do: :lists.reverse([head | acc])
+  defp expand_dot([], acc), do: :lists.reverse(acc)
 
-  defp normalize(["."|t], acc) do
-    normalize t, acc
+  defp major_os_type do
+    :os.type() |> elem(0)
   end
 
-  defp normalize([h|t], acc) do
-    normalize t, [h|acc]
+  @doc """
+  Returns a relative path that is protected from directory-traversal attacks.
+
+  See `safe_relative/2` for a non-deprecated version of this API.
+  """
+  # TODO: Deprecate me on Elixir v1.19
+  @doc since: "1.14.0", deprecated: "Use safe_relative/2 instead"
+  @spec safe_relative_to(t, t) :: {:ok, binary} | :error
+  def safe_relative_to(path, cwd) do
+    safe_relative(path, cwd)
   end
 
-  defp normalize([], acc) do
-    join :lists.reverse(acc)
+  @doc """
+  Returns a relative path that is protected from directory-traversal attacks.
+
+  The given relative path is sanitized by eliminating `..` and `.` components.
+
+  This function checks that, after expanding those components, the path is still "safe".
+  Paths are considered unsafe if either of these is true:
+
+    * The path is not relative, such as `"/foo/bar"`.
+
+    * A `..` component would make it so that the path would traverse up above
+      the root of `relative_to`.
+
+    * A symbolic link in the path points to something above the root of `relative_to`.
+
+  ## Examples
+
+      iex> Path.safe_relative("foo")
+      {:ok, "foo"}
+
+      iex> Path.safe_relative("deps/my_dep/app.beam")
+      {:ok, "deps/my_dep/app.beam"}
+
+      iex> Path.safe_relative("deps/my_dep/./build/../app.beam", File.cwd!())
+      {:ok, "deps/my_dep/app.beam"}
+
+      iex> Path.safe_relative("my_dep/../..")
+      :error
+
+      iex> Path.safe_relative("/usr/local", File.cwd!())
+      :error
+
+  """
+  @doc since: "1.14.0"
+  @spec safe_relative(t, t) :: {:ok, binary} | :error
+  def safe_relative(path, relative_to \\ File.cwd!()) do
+    path = IO.chardata_to_string(path)
+
+    case :filelib.safe_relative_path(path, relative_to) do
+      :unsafe -> :error
+      relative_path -> {:ok, IO.chardata_to_string(relative_path)}
+    end
   end
 end
diff --git a/lib/elixir/lib/port.ex b/lib/elixir/lib/port.ex
index e7f465a26bb..6d1df7196b1 100644
--- a/lib/elixir/lib/port.ex
+++ b/lib/elixir/lib/port.ex
@@ -1,68 +1,355 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Port do
-  @moduledoc """
-  Functions related to Erlang ports.
+  @moduledoc ~S"""
+  Functions for interacting with the external world through ports.
+
+  Ports provide a mechanism to start operating system processes external
+  to the Erlang VM and communicate with them via message passing.
+
+  ## Example
+
+      iex> port = Port.open({:spawn, "cat"}, [:binary])
+      iex> send(port, {self(), {:command, "hello"}})
+      iex> send(port, {self(), {:command, "world"}})
+      iex> flush()
+      {#Port<0.1444>, {:data, "hello"}}
+      {#Port<0.1444>, {:data, "world"}}
+      iex> send(port, {self(), :close})
+      :ok
+      iex> flush()
+      {#Port<0.1444>, :closed}
+      :ok
+
+  In the example above, we have created a new port that executes the
+  program `cat`. `cat` is a program available on Unix-like operating systems that
+  receives data from multiple inputs and concatenates them in the output.
+
+  After the port was created, we sent it two commands in the form of
+  messages using `send/2`. The first command has the binary payload
+  of "hello" and the second has "world".
+
+  After sending those two messages, we invoked the IEx helper `flush()`,
+  which printed all messages received from the port, in this case we got
+  "hello" and "world" back. Note that the messages are in binary because we
+  passed the `:binary` option when opening the port in `Port.open/2`. Without
+  such option, it would have yielded a list of bytes.
+
+  Once everything was done, we closed the port.
+
+  Elixir provides many conveniences for working with ports and some drawbacks.
+  We will explore those below.
+
+  ## Message and function APIs
+
+  There are two APIs for working with ports. It can be either asynchronous via
+  message passing, as in the example above, or by calling the functions on this
+  module.
+
+  The messages supported by ports and their counterpart function APIs are
+  listed below:
+
+    * `{pid, {:command, binary}}` - sends the given data to the port.
+      See `command/3`.
+
+    * `{pid, :close}` - closes the port. Unless the port is already closed,
+      the port will reply with `{port, :closed}` message once it has flushed
+      its buffers and effectively closed. See `close/1`.
+
+    * `{pid, {:connect, new_pid}}` - sets the `new_pid` as the new owner of
+      the port. Once a port is opened, the port is linked and connected to the
+      caller process and communication to the port only happens through the
+      connected process. This message makes `new_pid` the new connected processes.
+      Unless the port is dead, the port will reply to the old owner with
+      `{port, :connected}`. See `connect/2`.
+
+  On its turn, the port will send the connected process the following messages:
+
+    * `{port, {:data, data}}` - data sent by the port
+    * `{port, :closed}` - reply to the `{pid, :close}` message
+    * `{port, :connected}` - reply to the `{pid, {:connect, new_pid}}` message
+    * `{:EXIT, port, reason}` - exit signals in case the port crashes. If reason
+      is not `:normal`, this message will only be received if the owner process
+      is trapping exits
+
+  ## Open mechanisms
+
+  The port can be opened through four main mechanisms.
+
+  As a short summary, prefer to use the `:spawn` and `:spawn_executable`
+  options mentioned below. The other two options, `:spawn_driver` and `:fd`
+  are for advanced usage within the VM. Also consider using `System.cmd/3`
+  if all you want is to execute a program and retrieve its return value.
+
+  > #### Windows argument splitting and untrusted arguments {: .warning}
+  >
+  > On Unix systems, arguments are passed to a new operating system
+  > process as an array of strings but on Windows it is up to the child
+  > process to parse them and some Windows programs may apply their own
+  > rules, which are inconsistent with the standard C runtime `argv` parsing
+  >
+  > This is particularly troublesome when invoking `.bat` or `.com` files
+  > as these run implicitly through `cmd.exe`, whose argument parsing is
+  > vulnerable to malicious input and can be used to run arbitrary shell
+  > commands.
+  >
+  > Therefore, if you are running on Windows and you execute batch
+  > files or `.com` applications, you must not pass untrusted input as
+  > arguments to the program. You may avoid accidentally executing them
+  > by explicitly passing the extension of the program you want to run,
+  > such as `.exe`, and double check the program is indeed not a batch
+  > file or `.com` application.
+  >
+  > This affects both `spawn` and `spawn_executable`.
+
+  ### spawn
+
+  The `:spawn` tuple receives a binary that is going to be executed as a
+  full invocation. For example, we can use it to invoke "echo hello" directly:
+
+      iex> port = Port.open({:spawn, "echo hello"}, [:binary])
+      iex> flush()
+      {#Port<0.1444>, {:data, "hello\n"}}
+
+  `:spawn` will retrieve the program name from the argument and traverse your
+  operating system `$PATH` environment variable looking for a matching program.
+
+  Although the above is handy, it means it is impossible to invoke an executable
+  that has whitespaces on its name or in any of its arguments. For those reasons,
+  most times it is preferable to execute `:spawn_executable`.
+
+  ### spawn_executable
+
+  Spawn executable is a more restricted and explicit version of spawn. It expects
+  full file paths to the executable you want to execute. If they are in your `$PATH`,
+  they can be retrieved by calling `System.find_executable/1`:
+
+      iex> path = System.find_executable("echo")
+      iex> port = Port.open({:spawn_executable, path}, [:binary, args: ["hello world"]])
+      iex> flush()
+      {#Port<0.1380>, {:data, "hello world\n"}}
+
+  When using `:spawn_executable`, the list of arguments can be passed via
+  the `:args` option as done above. For the full list of options, see the
+  documentation for the Erlang function `:erlang.open_port/2`.
+
+  ### fd
+
+  The `:fd` name option allows developers to access `in` and `out` file
+  descriptors used by the Erlang VM. You would use those only if you are
+  reimplementing core part of the Runtime System, such as the `:user` and
+  `:shell` processes.
+
+  ## Orphan operating system processes
+
+  A port can be closed via the `close/1` function or by sending a `{pid, :close}`
+  message. However, if the VM crashes, a long-running program started by the port
+  will have its stdin and stdout channels closed but **it won't be automatically
+  terminated**.
+
+  While some Unix command line tools will exit once its parent process
+  terminates, not all command line applications will do so. You can easily check
+  this by starting the port and then shutting down the VM and inspecting your
+  operating system to see if the port process is still running.
+
+  We do not always have control over how third-party software terminates.
+  If necessary, one workaround is to wrap the child application in a script that
+  checks whether stdin has been closed.  Here is such a script that has been
+  verified to work on bash shells:
+
+      #!/usr/bin/env bash
+
+      # Start the program in the background
+      exec "$@" &
+      pid1=$!
+
+      # Silence warnings from here on
+      exec >/dev/null 2>&1
+
+      # Read from stdin in the background and
+      # kill running program when stdin closes
+      exec 0<&0 $(
+        while read; do :; done
+        kill -KILL $pid1
+      ) &
+      pid2=$!
+
+      # Clean up
+      wait $pid1
+      ret=$?
+      kill -KILL $pid2
+      exit $ret
+
+  Note the program above hijacks stdin, so you won't be able to communicate
+  with the underlying software via stdin (on the positive side, software that
+  reads from stdin typically terminates when stdin closes).
+
+  Now instead of:
+
+      Port.open(
+        {:spawn_executable, "/path/to/program"},
+        args: ["a", "b", "c"]
+      )
+
+  You may invoke:
+
+      Port.open(
+        {:spawn_executable, "/path/to/wrapper"},
+        args: ["/path/to/program", "a", "b", "c"]
+      )
+
   """
 
+  @type name ::
+          {:spawn, charlist | binary}
+          | {:spawn_driver, charlist | binary}
+          | {:spawn_executable, :file.name_all()}
+          | {:fd, non_neg_integer, non_neg_integer}
+
   @doc """
-  See http://www.erlang.org/doc/man/erlang.html#open_port-2.
+  Opens a port given a tuple `name` and a list of `options`.
+
+  The module documentation above contains documentation and examples
+  for the supported `name` values, summarized below:
+
+    * `{:spawn, command}` - runs an external program. `command` must contain
+      the program name and optionally a list of arguments separated by space.
+      If passing programs or arguments with space in their name, use the next option.
+    * `{:spawn_executable, filename}` - runs the executable given by the absolute
+      file name `filename`. Arguments can be passed via the `:args` option.
+    * `{:spawn_driver, command}` - spawns so-called port drivers.
+    * `{:fd, fd_in, fd_out}` - accesses file descriptors, `fd_in` and `fd_out`
+      opened by the VM.
+
+  For more information and the list of options, see `:erlang.open_port/2`.
+
+  Inlined by the compiler.
   """
-  def open(name, settings) do
-    :erlang.open_port(name, settings)
+  @spec open(name, list) :: port
+  def open(name, options) do
+    :erlang.open_port(name, options)
   end
 
   @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_close-1.
+  Closes the `port`.
+
+  For more information, see `:erlang.port_close/1`.
+
+  Inlined by the compiler.
   """
+  @spec close(port) :: true
   def close(port) do
     :erlang.port_close(port)
   end
 
   @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_command-2.
+  Sends `data` to the port driver `port`.
+
+  For more information, see `:erlang.port_command/3`.
+
+  Inlined by the compiler.
   """
+  @spec command(port, iodata, [:force | :nosuspend]) :: boolean
   def command(port, data, options \\ []) do
     :erlang.port_command(port, data, options)
   end
 
   @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_connect-2.
+  Associates the `port` identifier with a `pid`.
+
+  For more information, see `:erlang.port_connect/2`.
+
+  Inlined by the compiler.
   """
+  @spec connect(port, pid) :: true
   def connect(port, pid) do
     :erlang.port_connect(port, pid)
   end
 
   @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_control-3.
+  Returns information about the `port` (or `nil` if the port is closed).
+
+  For more information, see `:erlang.port_info/1`.
   """
-  def control(port, operation, data) do
-    :erlang.port_control(port, operation, data)
+  @spec info(port) :: keyword | nil
+  def info(port) do
+    nilify(:erlang.port_info(port))
   end
 
   @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_call-3.
+  Returns information about a specific field within
+  the `port` (or `nil` if the port is closed).
+
+  For more information, see `:erlang.port_info/2`.
   """
-  def call(port, operation, data) do
-    :erlang.port_call(port, operation, data)
+  @spec info(port, atom) :: {atom, term} | nil
+  def info(port, spec)
+
+  def info(port, :registered_name) do
+    case :erlang.port_info(port, :registered_name) do
+      :undefined -> nil
+      [] -> {:registered_name, []}
+      other -> other
+    end
+  end
+
+  def info(port, item) do
+    nilify(:erlang.port_info(port, item))
   end
 
   @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_info-1.
+  Starts monitoring the given `port` from the calling process.
+
+  Once the monitored port process dies, a message is delivered to the
+  monitoring process in the shape of:
+
+      {:DOWN, ref, :port, object, reason}
+
+  where:
+
+    * `ref` is a monitor reference returned by this function;
+    * `object` is either the `port` being monitored (when monitoring by port ID)
+    or `{name, node}` (when monitoring by a port name);
+    * `reason` is the exit reason.
+
+  See `:erlang.monitor/2` for more information.
+
+  Inlined by the compiler.
   """
-  def info(port) do
-    :erlang.port_info(port)
+  @doc since: "1.6.0"
+  @spec monitor(port | {name, node} | name) :: reference when name: atom
+  def monitor(port) do
+    :erlang.monitor(:port, port)
   end
 
   @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_info-2.
+  Demonitors the monitor identified by the given `reference`.
+
+  If `monitor_ref` is a reference which the calling process
+  obtained by calling `monitor/1`, that monitoring is turned off.
+  If the monitoring is already turned off, nothing happens.
+
+  See `:erlang.demonitor/2` for more information.
+
+  Inlined by the compiler.
   """
-  def info(port, item) do
-    :erlang.port_info(port, item)
-  end
+  @doc since: "1.6.0"
+  @spec demonitor(reference, options :: [:flush | :info]) :: boolean
+  defdelegate demonitor(monitor_ref, options \\ []), to: :erlang
 
   @doc """
-  See http://www.erlang.org/doc/man/erlang.html#ports-0.
+  Returns a list of all ports in the current node.
+
+  Inlined by the compiler.
   """
+  @spec list :: [port]
   def list do
-    :erlang.ports
+    :erlang.ports()
   end
-end
\ No newline at end of file
+
+  @compile {:inline, nilify: 1}
+  defp nilify(:undefined), do: nil
+  defp nilify(other), do: other
+end
diff --git a/lib/elixir/lib/process.ex b/lib/elixir/lib/process.ex
index ce73ca7bb16..ffb6ff2275d 100644
--- a/lib/elixir/lib/process.ex
+++ b/lib/elixir/lib/process.ex
@@ -1,10 +1,14 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Process do
   @moduledoc """
   Conveniences for working with processes and the process dictionary.
 
   Besides the functions available in this module, the `Kernel` module
   exposes and auto-imports some basic functionality related to processes
-  available through the functions:
+  available through the following functions:
 
     * `Kernel.spawn/1` and `Kernel.spawn/3`
     * `Kernel.spawn_link/1` and `Kernel.spawn_link/3`
@@ -12,304 +16,786 @@ defmodule Process do
     * `Kernel.self/0`
     * `Kernel.send/2`
 
+  While this module provides low-level conveniences to work with processes,
+  developers typically use abstractions such as `Agent`, `GenServer`,
+  `Registry`, `Supervisor` and `Task` for building their systems and
+  resort to this module for gathering information, trapping exits, links
+  and monitoring.
+
+  ## Aliases
+
+  Aliases are a feature introduced in Erlang/OTP 24. An alias is a way
+  to refer to a PID in order to send messages to it. The advantage of using
+  aliases is that they can be deactivated even if the aliased process is still
+  running. If you send a message to a deactivated alias, nothing will happen.
+  This makes request/response scenarios easier to implement.
+
+  You can use `alias/0` or `alias/1` to set an alias, and then you can send
+  messages to that alias like you do with PIDs using `send/2`. To deactivate
+  an alias, you can use `unalias/1`. If you send a message to a deactivated alias,
+  nothing will happen.
+
+  For example, you could have a process that listens for `:ping` messages:
+
+      def server do
+        receive do
+          {:ping, source_alias} ->
+            send(source_alias, :pong)
+            server()
+        end
+      end
+
+  Now, another process might ping this process:
+
+      server = spawn(&server/0)
+
+      source_alias = Process.alias()
+      send(server, {:ping, source_alias})
+
+      receive do
+        :pong -> :pong
+      end
+      #=> :pong
+
+  If now you deactivate the `source_alias` and ping the server again, you
+  won't receive any response since the server will `send/2` the `:pong` response
+  to a deactivated alias.
+
+      Process.unalias(source_alias)
+      send(server, {:ping, source_alias})
+
+      receive do
+        :pong -> :pong
+      after
+        1000 -> :timeout
+      end
+      #=> :timeout
+
+  See also the [Process Aliases
+  section](https://www.erlang.org/doc/reference_manual/processes.html#process-aliases)
+  of the *Erlang reference manual*.
+  """
+
+  @typedoc """
+  A process destination.
+
+  A remote or local PID, a local port, a locally registered name, or a tuple in
+  the form of `{registered_name, node}` for a registered name at another node.
   """
+  @type dest :: pid | port | (registered_name :: atom) | {registered_name :: atom, node}
 
   @doc """
-  Returns true if the process exists and is alive, that is,
-  is not exiting and has not exited. Otherwise, returns false.
+  Tells whether the given process is alive on the local node.
 
-  `pid` must refer to a process at the local node.
+  If the process identified by `pid` is alive (that is, it's not exiting and has
+  not exited yet) then this function returns `true`. Otherwise, it returns
+  `false`.
+
+  `pid` must refer to a process running on the local node or `ArgumentError` is raised.
+  To check whether a process on any node is alive you can use the [`:erpc`](`:erpc`) module.
+
+      :erpc.call(node(pid), Process, :alive?, [pid])
+
+  Inlined by the compiler.
   """
   @spec alive?(pid) :: boolean
-  def alive?(pid) do
-    :erlang.is_process_alive(pid)
-  end
+  defdelegate alive?(pid), to: :erlang, as: :is_process_alive
 
   @doc """
-  Returns all key-values in the dictionary.
+  Returns all key-value pairs in the process dictionary.
+
+  Inlined by the compiler.
   """
-  @spec get :: [{term, term}]
-  def get do
-    :erlang.get()
-  end
+  @spec get() :: [{term, term}]
+  defdelegate get(), to: :erlang
 
   @doc """
-  Returns the value for the given key.
+  Returns the value for the given `key` in the process dictionary,
+  or `default` if `key` is not set.
+
+  ## Examples
+
+      # Assuming :locale was not set
+      iex> Process.get(:locale, "pt")
+      "pt"
+      iex> Process.put(:locale, "fr")
+      nil
+      iex> Process.get(:locale, "pt")
+      "fr"
+
   """
-  @spec get(term) :: term
   @spec get(term, default :: term) :: term
   def get(key, default \\ nil) do
     case :erlang.get(key) do
-      :undefined ->
-        default
-      value ->
-        value
+      :undefined -> default
+      value -> value
     end
   end
 
   @doc """
-  Returns all keys that have the given `value`.
+  Returns all keys in the process dictionary.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      # Assuming :locale was not set
+      iex> :locale in Process.get_keys()
+      false
+      iex> Process.put(:locale, "pt")
+      nil
+      iex> :locale in Process.get_keys()
+      true
+
+  """
+  @spec get_keys() :: [term]
+  defdelegate get_keys(), to: :erlang
+
+  @doc """
+  Returns all keys in the process dictionary that have the given `value`.
+
+  Inlined by the compiler.
   """
   @spec get_keys(term) :: [term]
-  def get_keys(value) do
-    :erlang.get_keys(value)
-  end
+  defdelegate get_keys(value), to: :erlang
 
   @doc """
-  Stores the given key-value in the process dictionary.
+  Stores the given `key`-`value` pair in the process dictionary.
+
+  The return value of this function is the value that was previously stored
+  under `key`, or `nil` in case no value was stored under it.
+
+  ## Examples
+
+      # Assuming :locale was not set
+      iex> Process.put(:locale, "en")
+      nil
+      iex> Process.put(:locale, "fr")
+      "en"
+
   """
   @spec put(term, term) :: term | nil
   def put(key, value) do
-    nillify :erlang.put(key, value)
+    nilify(:erlang.put(key, value))
   end
 
   @doc """
-  Deletes the given key from the dictionary.
+  Deletes the given `key` from the process dictionary.
+
+  Returns the value that was under `key` in the process dictionary,
+  or `nil` if `key` was not stored in the process dictionary.
+
+  ## Examples
+
+      iex> Process.put(:comments, ["comment", "other comment"])
+      iex> Process.delete(:comments)
+      ["comment", "other comment"]
+      iex> Process.delete(:comments)
+      nil
+
   """
   @spec delete(term) :: term | nil
   def delete(key) do
-    nillify :erlang.erase(key)
+    nilify(:erlang.erase(key))
   end
 
   @doc """
-  Sends an exit signal with the given reason to the pid.
+  Sends an exit signal with the given `reason` to `pid`.
 
-  The following behaviour applies if reason is any term except `:normal` or `:kill`:
+  Exit behavior differs based on the value of `reason`:
 
-    1. If pid is not trapping exits, pid will exit with the given reason.
+    - If `:normal`, `pid` will not exit unless it is the calling process, in
+      which case it will exit with the reason `:normal`. If it is trapping exits,
+      the exit signal is transformed into a message `{:EXIT, from, :normal}` and
+      delivered to its message queue.
 
-    2. If pid is trapping exits, the exit signal is transformed into a message
-       {:EXIT, from, reason} and delivered to the message queue of pid.
+    - If `:kill`, which occurs when `Process.exit(pid, :kill)` is called, an
+      untrappable exit signal is sent to `pid` which will unconditionally exit
+      with reason `:killed`.
 
-    3. If reason is the atom `:normal`, pid will not exit. If it is trapping
-       exits, the exit signal is transformed into a message {:EXIT, from,
-       :normal} and delivered to its message queue.
+    - If any other term and `pid` is not trapping exits, `pid` will exit with
+      the given `reason`.
 
-    4. If reason is the atom `:kill`, that is if `exit(pid, :kill)` is called,
-       an untrappable exit signal is sent to pid which will unconditionally
-       exit with exit reason `:killed`.
+    - If any other term and `pid` is trapping exits, the exit signal is
+      transformed into a message `{:EXIT, from, reason}` and delivered to its
+      message queue.
 
   Inlined by the compiler.
 
+  > #### Differences to `Kernel.exit/1` {: .info }
+  >
+  > The functions `Kernel.exit/1` and `Process.exit/2` are
+  > named similarly but provide very different functionalities. The
+  > `Kernel:exit/1` function should be used when the intent is to stop the current
+  > process while `Process.exit/2` should be used when the intent is to send an
+  > exit signal to another process. Note also that `Kernel.exit/1` can be caught
+  > with `try/1` while `Process.exit/2` can only be handled by trapping exits and
+  > when the signal is different than `:kill`.
+
   ## Examples
 
       Process.exit(pid, :kill)
+      #=> true
 
   """
   @spec exit(pid, term) :: true
-  def exit(pid, reason) do
-    :erlang.exit(pid, reason)
+  defdelegate exit(pid, reason), to: :erlang
+
+  @doc """
+  Sleeps the current process for the given `timeout`.
+
+  `timeout` is either the number of milliseconds to sleep as an
+  integer or the atom `:infinity`. When `:infinity` is given,
+  the current process will sleep forever, and not
+  consume or reply to messages.
+
+  > #### Sleeping limit {: .info }
+  >
+  > Before Elixir v1.18, `sleep/1` did not accept integer timeout values greater
+  > than `16#ffffffff`, that is, `2^32-1`. Since Elixir v1.18, arbitrarily-high integer
+  > values are accepted.
+
+  **Use this function with extreme care**. For almost all situations
+  where you would use `sleep/1` in Elixir, there is likely a
+  more correct, faster and precise way of achieving the same with
+  message passing.
+
+  For example, if you are waiting for a process to perform some
+  action, it is better to communicate the progress of such action
+  with messages.
+
+  In other words, **do not**:
+
+      Task.start_link(fn ->
+        do_something()
+        ...
+      end)
+
+      # Wait until work is done
+      Process.sleep(2000)
+
+  But **do**:
+
+      parent = self()
+
+      Task.start_link(fn ->
+        do_something()
+        send(parent, :work_is_done)
+        ...
+      end)
+
+      receive do
+        :work_is_done -> :ok
+      after
+        # Optional timeout
+        30_000 -> :timeout
+      end
+
+  For cases like the one above, `Task.async/1` and `Task.await/2` are
+  preferred.
+
+  Similarly, if you are waiting for a process to terminate,
+  monitor that process instead of sleeping. **Do not**:
+
+      Task.start_link(fn ->
+        ...
+      end)
+
+      # Wait until task terminates
+      Process.sleep(2000)
+
+  Instead **do**:
+
+      {:ok, pid} =
+        Task.start_link(fn ->
+          ...
+        end)
+
+      ref = Process.monitor(pid)
+
+      receive do
+        {:DOWN, ^ref, _, _, _} -> :task_is_down
+      after
+        # Optional timeout
+        30_000 -> :timeout
+      end
+
+  """
+
+  # Max value for a receive's after clause
+  @max_receive_after 0xFFFFFFFF
+
+  @spec sleep(timeout) :: :ok
+  def sleep(timeout) when is_integer(timeout) and timeout > @max_receive_after do
+    receive after: (@max_receive_after -> sleep(timeout - @max_receive_after))
+  end
+
+  def sleep(timeout)
+      when is_integer(timeout) and timeout >= 0
+      when timeout == :infinity do
+    receive after: (timeout -> :ok)
   end
 
   @doc """
-  Sends a message to the given process.
+  Sends a message to the given `dest`.
+
+  `dest` may be a remote or local PID, a local port, a locally
+  registered name, or a tuple in the form of `{registered_name, node}` for a
+  registered name at another node.
 
-  If the option `:noconnect` is used and sending the message would require an
-  auto-connection to another node the message is not sent and `:noconnect` is
-  returned.
+  Inlined by the compiler.
+
+  ## Options
 
-  If the option `:nosuspend` is used and sending the message would cause the
-  sender to be suspended the message is not sent and `:nosuspend` is returned.
+    * `:noconnect` - when used, if sending the message would require an
+      auto-connection to another node the message is not sent and `:noconnect` is
+      returned.
+
+    * `:nosuspend` - when used, if sending the message would cause the sender to
+      be suspended the message is not sent and `:nosuspend` is returned.
 
   Otherwise the message is sent and `:ok` is returned.
 
   ## Examples
 
-      iex> Process.send({:name, :node_does_not_exist}, :hi, [:noconnect])
+      iex> Process.send({:name, :node_that_does_not_exist}, :hi, [:noconnect])
       :noconnect
 
   """
-  @spec send(dest, msg, [option]) ::  result when
-        dest: pid | port | atom | {atom, node},
-        msg: any,
-        option: :noconnect | :nosuspend,
-        result: :ok | :noconnect | :nosuspend
-  def send(dest, msg, options) do
-    :erlang.send(dest, msg, options)
-  end
+  @spec send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend
+        when dest: dest(),
+             msg: any,
+             option: :noconnect | :nosuspend
+  defdelegate send(dest, msg, options), to: :erlang
 
   @doc """
-  Sends `msg` to `dest` after `time` millisecons.
+  Sends `msg` to `dest` after `time` milliseconds.
 
-  If `dest` is a pid, it has to be a pid of a local process, dead or alive.
-  If `dest` is an atom, it is supposed to be the name of a registered process
-  which is looked up at the time of delivery. No error is given if the name does
+  If `dest` is a PID, it must be the PID of a local process, dead or alive.
+  If `dest` is an atom, it must be the name of a registered process
+  which is looked up at the time of delivery. No error is produced if the name does
   not refer to a process.
 
-  This function returns a timer reference, which can be read or canceled with
-  `:erlang.read_timer/1`, `:erlang.start_timer/3` and `:erlang.cancel_timer/1`.
-  Note `time` cannot be greater than `4294967295`.
+  The message is not sent immediately. Therefore, `dest` can receive other messages
+  in-between even when `time` is `0`.
 
-  Finally, the timer will be automatically canceled if the given `dest` is a pid
-  which is not alive or when the given pid exits. Note that timers will not be
+  This function returns a timer reference, which can be read with `read_timer/1`
+  or canceled with `cancel_timer/1`.
+
+  The timer will be automatically canceled if the given `dest` is a PID
+  which is not alive or when the given PID exits. Note that timers will not be
   automatically canceled when `dest` is an atom (as the atom resolution is done
   on delivery).
+
+  Inlined by the compiler.
+
+  ## Options
+
+    * `:abs` - (boolean) when `false`, `time` is treated as relative to the
+    current monotonic time. When `true`, `time` is the absolute value of the
+    Erlang monotonic time at which `msg` should be delivered to `dest`.
+    To read more about Erlang monotonic time and other time-related concepts,
+    look at the documentation for the `System` module. Defaults to `false`.
+
+  ## Examples
+
+      timer_ref = Process.send_after(pid, :hi, 1000)
+
   """
-  @spec send_after(pid | atom, term, non_neg_integer) :: reference
-  def send_after(dest, msg, time) do
-    :erlang.send_after(time, dest, msg)
+  @spec send_after(pid | atom, term, non_neg_integer, [option]) :: reference
+        when option: {:abs, boolean}
+  def send_after(dest, msg, time, opts \\ []) do
+    :erlang.send_after(time, dest, msg, opts)
   end
 
-  @type spawn_opt  :: :link | :monitor | {:priority, :low | :normal | :high} |
-                      {:fullsweep_after, non_neg_integer} |
-                      {:min_heap_size, non_neg_integer} |
-                      {:min_bin_vheap_size, non_neg_integer}
+  @doc """
+  Cancels a timer returned by `send_after/3`.
+
+  When the result is an integer, it represents the time in milliseconds
+  left until the timer would have expired.
+
+  When the result is `false`, a timer corresponding to `timer_ref` could not be
+  found. This can happen either because the timer expired, because it has
+  already been canceled, or because `timer_ref` never corresponded to a timer.
+
+  Even if the timer had expired and the message was sent, this function does not
+  tell you if the timeout message has arrived at its destination yet.
+
+  Inlined by the compiler.
+
+  ## Options
+
+    * `:async` - (boolean) when `false`, the request for cancellation is
+      synchronous. When `true`, the request for cancellation is asynchronous,
+      meaning that the request to cancel the timer is issued and `:ok` is
+      returned right away. Defaults to `false`.
+
+    * `:info` - (boolean) whether to return information about the timer being
+      cancelled. When the `:async` option is `false` and `:info` is `true`, then
+      either an integer or `false` (like described above) is returned. If
+      `:async` is `false` and `:info` is `false`, `:ok` is returned. If `:async`
+      is `true` and `:info` is `true`, a message in the form `{:cancel_timer,
+      timer_ref, result}` (where `result` is an integer or `false` like
+      described above) is sent to the caller of this function when the
+      cancellation has been performed. If `:async` is `true` and `:info` is
+      `false`, no message is sent. Defaults to `true`.
+
+  """
+  @spec cancel_timer(reference, options) :: non_neg_integer | false | :ok
+        when options: [async: boolean, info: boolean]
+  defdelegate cancel_timer(timer_ref, options \\ []), to: :erlang
+
+  @doc """
+  Reads a timer created by `send_after/3`.
+
+  When the result is an integer, it represents the time in milliseconds
+  left until the timer will expire.
+
+  When the result is `false`, a timer corresponding to `timer_ref` could not be
+  found. This can be either because the timer expired, because it has already
+  been canceled, or because `timer_ref` never corresponded to a timer.
+
+  Even if the timer had expired and the message was sent, this function does not
+  tell you if the timeout message has arrived at its destination yet.
+
+  Inlined by the compiler.
+  """
+  @spec read_timer(reference) :: non_neg_integer | false
+  defdelegate read_timer(timer_ref), to: :erlang
+
+  @type spawn_opt ::
+          :link
+          | :monitor
+          | {:monitor, :erlang.monitor_option()}
+          | {:priority, :low | :normal | :high}
+          | {:fullsweep_after, non_neg_integer}
+          | {:min_heap_size, non_neg_integer}
+          | {:min_bin_vheap_size, non_neg_integer}
+          | {:max_heap_size, heap_size}
+          | {:message_queue_data, :off_heap | :on_heap}
   @type spawn_opts :: [spawn_opt]
 
   @doc """
-  Spawns the given module and function passing the given args
-  according to the given options.
+  Spawns the given function according to the given options.
 
   The result depends on the given options. In particular,
   if `:monitor` is given as an option, it will return a tuple
-  containing the pid and the monitoring reference, otherwise
-  just the spawned process pid.
+  containing the PID and the monitoring reference, otherwise
+  just the spawned process PID.
 
-  It also accepts extra options, for the list of available options
-  check http://www.erlang.org/doc/man/erlang.html#spawn_opt-4
+  More options are available; for the comprehensive list of available options
+  check `:erlang.spawn_opt/4`.
 
   Inlined by the compiler.
+
+  ## Examples
+
+      Process.spawn(fn -> 1 + 2 end, [:monitor])
+      #=> {#PID<0.93.0>, #Reference<0.18808174.1939079169.202418>}
+      Process.spawn(fn -> 1 + 2 end, [:link])
+      #=> #PID<0.95.0>
+
   """
-  @spec spawn((() -> any), spawn_opts) :: pid | {pid, reference}
-  def spawn(fun, opts) do
-    :erlang.spawn_opt(fun, opts)
-  end
+  @spec spawn((-> any), spawn_opts) :: pid | {pid, reference}
+  defdelegate spawn(fun, opts), to: :erlang, as: :spawn_opt
 
   @doc """
-  Spawns the given module and function passing the given args
+  Spawns the given function `fun` from module `mod`, passing the given `args`
   according to the given options.
 
   The result depends on the given options. In particular,
   if `:monitor` is given as an option, it will return a tuple
-  containing the pid and the monitoring reference, otherwise
-  just the spawned process pid.
+  containing the PID and the monitoring reference, otherwise
+  just the spawned process PID.
 
   It also accepts extra options, for the list of available options
-  check http://www.erlang.org/doc/man/erlang.html#spawn_opt-4
+  check `:erlang.spawn_opt/4`.
 
   Inlined by the compiler.
   """
   @spec spawn(module, atom, list, spawn_opts) :: pid | {pid, reference}
-  def spawn(mod, fun, args, opts) do
-    :erlang.spawn_opt(mod, fun, args, opts)
-  end
+  defdelegate spawn(mod, fun, args, opts), to: :erlang, as: :spawn_opt
 
   @doc """
-  The calling process starts monitoring the item given.
-  It returns the monitor reference.
+  Starts monitoring the given `item` from the calling process.
+
+  Once the monitored process dies, a message is delivered to the
+  monitoring process in the shape of:
+
+      {:DOWN, ref, :process, object, reason}
 
-  See http://www.erlang.org/doc/man/erlang.html#monitor-2 for more info.
+  where:
+
+    * `ref` is a monitor reference returned by this function;
+    * `object` is either a `pid` of the monitored process (if monitoring
+      a PID) or `{name, node}` (if monitoring a remote or local name);
+    * `reason` is the exit reason.
+
+  If the process is already dead when calling `Process.monitor/1`, a
+  `:DOWN` message is delivered immediately.
+
+  See ["The need for monitoring"](genservers.md#the-need-for-monitoring)
+  for an example. See `:erlang.monitor/2` for more information.
 
   Inlined by the compiler.
+
+  ## Examples
+
+      pid = spawn(fn -> 1 + 2 end)
+      #=> #PID<0.118.0>
+      Process.monitor(pid)
+      #=> #Reference<0.906660723.3006791681.40191>
+      Process.exit(pid, :kill)
+      #=> true
+      receive do
+        msg -> msg
+      end
+      #=> {:DOWN, #Reference<0.906660723.3006791681.40191>, :process, #PID<0.118.0>, :noproc}
+
   """
-  @spec monitor(pid | {reg_name :: atom, node :: atom} | reg_name :: atom) :: reference
+  @spec monitor(pid | {name, node} | name) :: reference when name: atom
   def monitor(item) do
     :erlang.monitor(:process, item)
   end
 
   @doc """
-  If monitor_ref is a reference which the calling process
-  obtained by calling monitor/1, this monitoring is turned off.
+  Starts monitoring the given `item` from the calling process.
+
+  This function is similar to `monitor/1`, but accepts options to customize how
+  `item` is monitored. See `:erlang.monitor/3` for documentation on those
+  options.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      pid =
+        spawn(fn ->
+          receive do
+            {:ping, source_alias} -> send(source_alias, :pong)
+          end
+        end)
+      #=> #PID<0.118.0>
+
+      ref_and_alias = Process.monitor(pid, alias: :reply_demonitor)
+      #=> #Reference<0.906660723.3006791681.40191>
+
+      send(pid, {:ping, ref_and_alias})
+
+      receive do: (msg -> msg)
+      #=> :pong
+
+      ref_and_alias = Process.monitor(pid, alias: :reply_demonitor)
+      #=> #Reference<0.906660723.3006791681.40191>
+
+      send(pid, {:ping, ref_and_alias})
+
+      receive do: (msg -> msg)
+      #=> {:DOWN, #Reference<0.906660723.3006791681.40191>, :process, #PID<0.118.0>, :noproc}
+
+  """
+  @doc since: "1.15.0"
+  @spec monitor(pid | {name, node} | name, [:erlang.monitor_option()]) :: reference
+        when name: atom
+  def monitor(item, options) do
+    :erlang.monitor(:process, item, options)
+  end
+
+  @doc """
+  Demonitors the monitor identified by the given `reference`.
+
+  If `monitor_ref` is a reference which the calling process
+  obtained by calling `monitor/1`, that monitoring is turned off.
   If the monitoring is already turned off, nothing happens.
 
-  See http://www.erlang.org/doc/man/erlang.html#demonitor-2 for more info.
+  See `:erlang.demonitor/2` for more information.
 
   Inlined by the compiler.
+
+  ## Examples
+
+      pid = spawn(fn -> 1 + 2 end)
+      ref = Process.monitor(pid)
+      Process.demonitor(ref)
+      #=> true
+
   """
-  @spec demonitor(reference) :: true
   @spec demonitor(reference, options :: [:flush | :info]) :: boolean
-  def demonitor(monitor_ref, options \\ []) do
-    :erlang.demonitor(monitor_ref, options)
-  end
+  defdelegate demonitor(monitor_ref, options \\ []), to: :erlang
 
   @doc """
-  Returns a list of process identifiers corresponding to all the
+  Returns a list of PIDs corresponding to all the
   processes currently existing on the local node.
 
-  Note that a process that is exiting, exists but is not alive, i.e.,
-  alive?/1 will return false for a process that is exiting,
-  but its process identifier will be part of the result returned.
+  Note that if a process is exiting, it is considered to exist but not be
+  alive. This means that for such process, `alive?/1` will return `false` but
+  its PID will be part of the list of PIDs returned by this function.
+
+  See `:erlang.processes/0` for more information.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      Process.list()
+      #=> [#PID<0.0.0>, #PID<0.1.0>, #PID<0.2.0>, #PID<0.3.0>, ...]
 
-  See http://www.erlang.org/doc/man/erlang.html#processes-0 for more info.
   """
-  @spec list :: [pid]
-  def list do
-    :erlang.processes()
-  end
+  @spec list() :: [pid]
+  defdelegate list(), to: :erlang, as: :processes
 
   @doc """
-  Creates a link between the calling process and another process
-  (or port) `pid`, if there is not such a link already.
+  Creates a link between the calling process and the given item (process or
+  port).
 
-  See http://www.erlang.org/doc/man/erlang.html#link-1 for more info.
+  Links are bidirectional. Linked processes can be unlinked by using `unlink/1`.
+
+  If such a link exists already, this function does nothing since there can only
+  be one link between two given processes. If a process tries to create a link
+  to itself, nothing will happen.
+
+  When two processes are linked, each one receives exit signals from the other
+  (see also `exit/2`). Let's assume `pid1` and `pid2` are linked. If `pid2`
+  exits with a reason other than `:normal` (which is also the exit reason used
+  when a process finishes its job) and `pid1` is not trapping exits (see
+  `flag/2`), then `pid1` will exit with the same reason as `pid2` and in turn
+  emit an exit signal to all its other linked processes. The behavior when
+  `pid1` is trapping exits is described in `exit/2`.
+
+  See `:erlang.link/1` for more information.
 
   Inlined by the compiler.
   """
   @spec link(pid | port) :: true
-  def link(pid) do
-    :erlang.link(pid)
-  end
+  defdelegate link(pid_or_port), to: :erlang
 
   @doc """
-  Removes the link, if there is one, between the calling process and
-  the process or port referred to by `pid`. Returns true and does not
-  fail, even if there is no link or `id` does not exist
+  Removes the link between the calling process and the given item (process or
+  port).
 
-  See http://www.erlang.org/doc/man/erlang.html#unlink-1 for more info.
+  If there is no such link, this function does nothing. If `pid_or_port` does
+  not exist, this function does not produce any errors and simply does nothing.
+
+  The return value of this function is always `true`.
+
+  See `:erlang.unlink/1` for more information.
 
   Inlined by the compiler.
   """
   @spec unlink(pid | port) :: true
-  def unlink(pid) do
-    :erlang.unlink(pid)
-  end
+  defdelegate unlink(pid_or_port), to: :erlang
 
   @doc """
-  Associates the name with a pid or a port identifier. name, which must
-  be an atom, can be used instead of the pid / port identifier with the
-  `Kernel.send/2` function.
+  Registers the given `pid_or_port` under the given `name` on the local node.
+
+  `name` must be an atom and can then be used instead of the
+  PID/port identifier when sending messages with `Kernel.send/2`.
+
+  `register/2` will fail with `ArgumentError` in any of the following cases:
+
+    * the PID/Port is not existing locally and alive
+    * the name is already registered
+    * the `pid_or_port` is already registered under a different `name`
+
+  The following names are reserved and cannot be assigned to
+  processes nor ports:
+
+    * `nil`
+    * `false`
+    * `true`
+    * `:undefined`
+
+  ## Examples
+
+      Process.register(self(), :test)
+      #=> true
+      send(:test, :hello)
+      #=> :hello
+      send(:wrong_name, :hello)
+      ** (ArgumentError) argument error
 
-  `Process.register/2` will fail with `ArgumentError` if the pid supplied
-  is no longer alive, (check with `alive?/1`) or if the name is
-  already registered (check with `registered?/1`).
   """
   @spec register(pid | port, atom) :: true
-  def register(pid, name) when not name in [nil, false, true] do
-    :erlang.register(name, pid)
+  def register(pid_or_port, name)
+      when is_atom(name) and name not in [nil, false, true, :undefined] do
+    :erlang.register(name, pid_or_port)
+  catch
+    :error, :badarg when node(pid_or_port) != node() ->
+      message = "could not register #{inspect(pid_or_port)} because it belongs to another node"
+      :erlang.error(ArgumentError.exception(message), [pid_or_port, name])
+
+    :error, :badarg ->
+      message =
+        "could not register #{inspect(pid_or_port)} with " <>
+          "name #{inspect(name)} because it is not alive, the name is already " <>
+          "taken, or it has already been given another name"
+
+      :erlang.error(ArgumentError.exception(message), [pid_or_port, name])
   end
 
   @doc """
-  Removes the registered name, associated with a pid or a port identifier.
+  Removes the registered `name`, associated with a PID
+  or a port identifier.
+
+  Fails with `ArgumentError` if the name is not registered
+  to any PID or port.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      Process.register(self(), :test)
+      #=> true
+      Process.unregister(:test)
+      #=> true
+      Process.unregister(:wrong_name)
+      ** (ArgumentError) argument error
 
-  See http://www.erlang.org/doc/man/erlang.html#unregister-1 for more info.
   """
   @spec unregister(atom) :: true
-  def unregister(name) do
-    :erlang.unregister(name)
-  end
+  defdelegate unregister(name), to: :erlang
 
   @doc """
-  Returns the pid or port identifier with the registered name.
-  Returns nil if the name is not registered.
+  Returns the PID or port identifier registered under `name` or `nil` if the
+  name is not registered.
+
+  See `:erlang.whereis/1` for more information.
+
+  ## Examples
+
+      Process.register(self(), :test)
+      Process.whereis(:test)
+      #=> #PID<0.84.0>
+      Process.whereis(:wrong_name)
+      #=> nil
 
-  See http://www.erlang.org/doc/man/erlang.html#whereis-1 for more info.
   """
   @spec whereis(atom) :: pid | port | nil
   def whereis(name) do
-    nillify :erlang.whereis(name)
+    nilify(:erlang.whereis(name))
   end
 
   @doc """
-  Returns the pid of the group leader for the process which evaluates the function.
+  Returns the PID of the group leader for the calling process.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      Process.group_leader()
+      #=> #PID<0.53.0>
+
   """
-  @spec group_leader :: pid
-  def group_leader do
-    :erlang.group_leader
-  end
+  @spec group_leader() :: pid
+  defdelegate group_leader(), to: :erlang
 
   @doc """
-  Sets the group leader of `pid` to `leader`. Typically, this is used when a processes
-  started from a certain shell should have another group leader than `:init`.
+  Sets the group leader of the given `pid` to `leader`.
+
+  Typically, this is used when a process started from a certain shell should
+  have a group leader other than `:init`.
+
+  Inlined by the compiler.
   """
   @spec group_leader(pid, leader :: pid) :: true
   def group_leader(pid, leader) do
@@ -317,58 +803,88 @@ defmodule Process do
   end
 
   @doc """
-  Returns a list of names which have been registered using register/2.
+  Returns a list of names which have been registered using `register/2`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      Process.register(self(), :test)
+      Process.registered()
+      #=> [:test, :elixir_config, :inet_db, ...]
+
   """
-  @spec registered :: [atom]
-  def registered do
-    :erlang.registered()
-  end
+  @spec registered() :: [atom]
+  defdelegate registered(), to: :erlang
+
+  @typep heap_size ::
+           non_neg_integer
+           | %{size: non_neg_integer, kill: boolean, error_logger: boolean}
+
+  @typep priority_level :: :low | :normal | :high | :max
 
-  @typep process_flag :: :trap_exit | :error_handler | :min_heap_size |
-                         :min_bin_vheap_size | :priority | :save_calls |
-                         :sensitive
   @doc """
-  Sets certain flags for the process which calls this function.
-  Returns the old value of the flag.
+  Sets the given `flag` to `value` for the calling process.
+
+  Returns the old value of `flag`.
 
-  See http://www.erlang.org/doc/man/erlang.html#process_flag-2 for more info.
+  See `:erlang.process_flag/2` for more information.
+
+  Inlined by the compiler.
   """
-  @spec flag(process_flag, term) :: term
-  def flag(flag, value) do
-    :erlang.process_flag(flag, value)
-  end
+  @spec flag(:error_handler, module) :: module
+  @spec flag(:max_heap_size, heap_size) :: heap_size
+  # :off_heap | :on_heap twice because :erlang.message_queue_data() is not exported
+  @spec flag(:message_queue_data, :off_heap | :on_heap) :: :off_heap | :on_heap
+  @spec flag(:min_bin_vheap_size, non_neg_integer) :: non_neg_integer
+  @spec flag(:min_heap_size, non_neg_integer) :: non_neg_integer
+  @spec flag(:priority, priority_level) :: priority_level
+  @spec flag(:save_calls, 0..10_000) :: 0..10_000
+  @spec flag(:sensitive, boolean) :: boolean
+  @spec flag(:trap_exit, boolean) :: boolean
+  defdelegate flag(flag, value), to: :erlang, as: :process_flag
 
   @doc """
-  Sets certain flags for the process Pid, in the same manner as flag/2.
-  Returns the old value of the flag. The allowed values for Flag are
-  only a subset of those allowed in flag/2, namely: save_calls.
+  Sets the given `flag` to `value` for the given process `pid`.
+
+  Returns the old value of `flag`.
 
-  See http://www.erlang.org/doc/man/erlang.html#process_flag-3 for more info.
+  It raises `ArgumentError` if `pid` is not a local process.
+
+  The allowed values for `flag` are only a subset of those allowed in `flag/2`,
+  namely `:save_calls`.
+
+  See `:erlang.process_flag/3` for more information.
+
+  Inlined by the compiler.
   """
-  @spec flag(pid, process_flag, term) :: term
-  def flag(pid, flag, value) do
-    :erlang.process_flag(pid, flag, value)
-  end
+  @spec flag(pid, :save_calls, 0..10_000) :: 0..10_000
+  defdelegate flag(pid, flag, value), to: :erlang, as: :process_flag
 
   @doc """
-  Returns information about the process identified by pid or nil if the process
+  Returns information about the process identified by `pid`, or returns `nil` if the process
   is not alive.
+
   Use this only for debugging information.
 
-  See http://www.erlang.org/doc/man/erlang.html#process_info-1 for more info.
+  See `:erlang.process_info/1` for more information.
   """
-  @spec info(pid) :: Keyword.t
+  @spec info(pid) :: keyword | nil
   def info(pid) do
-    nillify :erlang.process_info(pid)
+    nilify(:erlang.process_info(pid))
   end
 
+  @type process_info_item :: atom | {:dictionary, term}
+  @type process_info_result_item :: {process_info_item, term}
+
   @doc """
-  Returns information about the process identified by pid
-  or nil if the process is not alive.
+  Returns information about the process identified by `pid`,
+  or returns `nil` if the process is not alive.
 
-  See http://www.erlang.org/doc/man/erlang.html#process_info-2 for more info.
+  See `:erlang.process_info/2` for more information.
   """
-  @spec info(pid, atom) :: {atom, term} | nil
+  @spec info(pid, process_info_item) :: process_info_result_item | nil
+  @spec info(pid, [process_info_item]) :: [process_info_result_item] | nil
   def info(pid, spec)
 
   def info(pid, :registered_name) do
@@ -379,11 +895,116 @@ defmodule Process do
     end
   end
 
-  def info(pid, spec) when is_atom(spec) do
-    nillify :erlang.process_info(pid, spec)
+  def info(pid, spec) do
+    nilify(:erlang.process_info(pid, spec))
+  end
+
+  @doc """
+  Puts the calling process into a "hibernation" state.
+
+  The calling process is put into a waiting state
+  where its memory allocation has been reduced as much as possible,
+  which is useful if the process does not expect to receive any messages
+  in the near future.
+
+  See `:erlang.hibernate/3` for more information.
+
+  Inlined by the compiler.
+  """
+  @spec hibernate(module, atom, list) :: no_return
+  defdelegate hibernate(mod, fun_name, args), to: :erlang
+
+  @type alias_opt :: :explicit_unalias | :reply
+
+  @typedoc """
+  An alias returned by `alias/0` or `alias/1`.
+
+  See [the module documentation](#module-aliases) for more information about aliases.
+  """
+  @type alias :: reference
+
+  @doc """
+  Creates a process alias.
+
+  This is the same as calling `alias/1` as `alias([:explicit_unalias])`. See
+  also `:erlang.alias/0`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      alias = Process.alias()
+
+  """
+  @doc since: "1.15.0"
+  @spec alias() :: alias
+  defdelegate alias(), to: :erlang
+
+  @doc """
+  Creates a process alias.
+
+  See [the module documentation](#module-aliases) for more information about aliases.
+  See also `:erlang.alias/1`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      alias = Process.alias([:reply])
+
+  """
+  @doc since: "1.15.0"
+  @spec alias([alias_opt]) :: alias
+  defdelegate alias(options), to: :erlang
+
+  @doc """
+  Explicitly deactivates a process alias.
+
+  Returns `true` if `alias` was a currently-active alias for current processes,
+  or `false` otherwise.
+
+  See [the module documentation](#module-aliases) for more information about aliases.
+  See also `:erlang.unalias/1`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      alias = Process.alias()
+      Process.unalias(alias)
+      #=> true
+
+  """
+  @doc since: "1.15.0"
+  @spec unalias(alias) :: boolean
+  defdelegate unalias(alias), to: :erlang
+
+  @doc """
+  Add a descriptive term to the current process.
+
+  The term does not need to be unique, and in Erlang/OTP 27+ will be shown in
+  Observer and in crash logs.
+  This label may be useful for identifying a process as one of multiple in a
+  given role, such as `:queue_worker` or `{:live_chat, user_id}`.
+
+  ## Examples
+
+      Process.set_label(:worker)
+      #=> :ok
+
+      Process.set_label({:any, "term"})
+      #=> :ok
+  """
+  @doc since: "1.17.0"
+  @spec set_label(term()) :: :ok
+  def set_label(label) do
+    # TODO: switch to `:proc_lib.set_label/2` when we require Erlang/OTP 27+
+    Process.put(:"$process_label", label)
+    # mimic return value of `:proc_lib.set_label/2`
+    :ok
   end
 
-  @compile {:inline, nillify: 1}
-  defp nillify(:undefined), do: nil
-  defp nillify(other),      do: other
+  @compile {:inline, nilify: 1}
+  defp nilify(:undefined), do: nil
+  defp nilify(other), do: other
 end
diff --git a/lib/elixir/lib/protocol.ex b/lib/elixir/lib/protocol.ex
index e29f31e1517..1aeaf1cce74 100644
--- a/lib/elixir/lib/protocol.ex
+++ b/lib/elixir/lib/protocol.ex
@@ -1,15 +1,275 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Protocol do
-  @moduledoc """
-  Functions for working with protocols.
+  @moduledoc ~S"""
+  Reference and functions for working with protocols.
+
+  A protocol specifies an API that should be defined by its
+  implementations. A protocol is defined with `Kernel.defprotocol/2`
+  and its implementations with `Kernel.defimpl/3`.
+
+  ## Example
+
+  In Elixir, we have two nouns for checking how many items there
+  are in a data structure: `length` and `size`.  `length` means the
+  information must be computed. For example, `length(list)` needs to
+  traverse the whole list to calculate its length. On the other hand,
+  `tuple_size(tuple)` and `byte_size(binary)` do not depend on the
+  tuple and binary size as the size information is precomputed in
+  the data structure.
+
+  Although Elixir includes specific functions such as `tuple_size`,
+  `binary_size` and `map_size`, sometimes we want to be able to
+  retrieve the size of a data structure regardless of its type.
+  In Elixir we can write polymorphic code, i.e. code that works
+  with different shapes/types, by using protocols. A size protocol
+  could be implemented as follows:
+
+      defprotocol Size do
+        @doc "Calculates the size (and not the length!) of a data structure"
+        def size(data)
+      end
+
+  Now that the protocol can be implemented for every data structure
+  the protocol may have a compliant implementation for:
+
+      defimpl Size, for: BitString do
+        def size(binary), do: byte_size(binary)
+      end
+
+      defimpl Size, for: Map do
+        def size(map), do: map_size(map)
+      end
+
+      defimpl Size, for: Tuple do
+        def size(tuple), do: tuple_size(tuple)
+      end
+
+  Finally, we can use the `Size` protocol to call the correct implementation:
+
+      Size.size({1, 2})
+      # => 2
+      Size.size(%{key: :value})
+      # => 1
+
+  Note that we didn't implement it for lists as we don't have the
+  `size` information on lists, rather its value needs to be
+  computed with `length`.
+
+  The data structure you are implementing the protocol for
+  must be the first argument to all functions defined in the
+  protocol.
+
+  It is possible to implement protocols for all Elixir types:
+
+    * Structs (see the "Protocols and Structs" section below)
+    * `Tuple`
+    * `Atom`
+    * `List`
+    * `BitString`
+    * `Integer`
+    * `Float`
+    * `Function`
+    * `PID`
+    * `Map`
+    * `Port`
+    * `Reference`
+    * `Any` (see the "Fallback to `Any`" section below)
+
+  ## Protocols and Structs
+
+  The real benefit of protocols comes when mixed with structs.
+  For instance, Elixir ships with many data types implemented as
+  structs, like `MapSet`. We can implement the `Size` protocol
+  for those types as well:
+
+      defimpl Size, for: MapSet do
+        def size(map_set), do: MapSet.size(map_set)
+      end
+
+  When implementing a protocol for a struct, the `:for` option can
+  be omitted if the `defimpl/3` call is inside the module that defines
+  the struct:
+
+      defmodule User do
+        defstruct [:email, :name]
+
+        defimpl Size do
+          # two fields
+          def size(%User{}), do: 2
+        end
+      end
+
+  If a protocol implementation is not found for a given type,
+  invoking the protocol will raise unless it is configured to
+  fall back to `Any`. Conveniences for building implementations
+  on top of existing ones are also available, look at `defstruct/1`
+  for more information about deriving protocols.
+
+  ## Fallback to `Any`
+
+  In some cases, it may be convenient to provide a default
+  implementation for all types. This can be achieved by setting
+  the `@fallback_to_any` attribute to `true` in the protocol
+  definition:
+
+      defprotocol Size do
+        @fallback_to_any true
+        def size(data)
+      end
+
+  The `Size` protocol can now be implemented for `Any`:
+
+      defimpl Size, for: Any do
+        def size(_), do: 0
+      end
+
+  Although the implementation above is arguably not a reasonable
+  one. For example, it makes no sense to say a PID or an integer
+  have a size of `0`. That's one of the reasons why `@fallback_to_any`
+  is an opt-in behavior. For the majority of protocols, raising
+  an error when a protocol is not implemented is the proper behavior.
+
+  ## Multiple implementations
+
+  Protocols can also be implemented for multiple types at once:
+
+      defprotocol Reversible do
+        def reverse(term)
+      end
+
+      defimpl Reversible, for: [Map, List] do
+        def reverse(term), do: Enum.reverse(term)
+      end
+
+  Inside `defimpl/3`, you can use `@protocol` to access the protocol
+  being implemented and `@for` to access the module it is being
+  defined for.
+
+  ## Types
+
+  Defining a protocol automatically defines a zero-arity type named `t`, which
+  can be used as follows:
+
+      @spec print_size(Size.t()) :: :ok
+      def print_size(data) do
+        result =
+          case Size.size(data) do
+            0 -> "data has no items"
+            1 -> "data has one item"
+            n -> "data has #{n} items"
+          end
+
+        IO.puts(result)
+      end
+
+  The `@spec` above expresses that all types allowed to implement the
+  given protocol are valid argument types for the given function.
+
+  ## Configuration
+
+  The following module attributes are available to configure a protocol:
+
+    * `@fallback_to_any` - when true, enables protocol dispatch to
+      fallback to any
+
+    * `@undefined_impl_description` - a string with additional description
+      to be used on `Protocol.UndefinedError` when looking up the implementation
+      fails. This option is only applied if `@fallback_to_any` is not set to true
+
+  ## Consolidation
+
+  In order to speed up protocol dispatching, whenever all protocol implementations
+  are known up-front, typically after all Elixir code in a project is compiled,
+  Elixir provides a feature called *protocol consolidation*. Consolidation directly
+  links protocols to their implementations in a way that invoking a function from a
+  consolidated protocol is equivalent to invoking two remote functions - one to
+  identify the correct implementation, and another to call the implementation.
+
+  Protocol consolidation is applied by default to all Mix projects during compilation.
+  This may be an issue during test. For instance, if you want to implement a protocol
+  during test, the implementation will have no effect, as the protocol has already been
+  consolidated. One possible solution is to include compilation directories that are
+  specific to your test environment in your mix.exs:
+
+      def project do
+        ...
+        elixirc_paths: elixirc_paths(Mix.env())
+        ...
+      end
+
+      defp elixirc_paths(:test), do: ["lib", "test/support"]
+      defp elixirc_paths(_), do: ["lib"]
+
+  And then you can define the implementations specific to the test environment
+  inside `test/support/some_file.ex`.
+
+  Another approach is to disable protocol consolidation during tests in your
+  mix.exs:
+
+      def project do
+        ...
+        consolidate_protocols: Mix.env() != :test
+        ...
+      end
+
+  If you are using `Mix.install/2`, you can do by passing the `consolidate_protocols`
+  option:
+
+      Mix.install(
+        deps,
+        consolidate_protocols: false
+      )
+
+  Although doing so is not recommended as it may affect the performance of
+  your code.
+
+  Finally, note all protocols are compiled with `debug_info` set to `true`,
+  regardless of the option set by the `elixirc` compiler. The debug info is
+  used for consolidation and it is removed after consolidation unless
+  globally set.
+  """
+
+  @doc """
+  A function available in all protocol definitions that returns protocol metadata.
+  """
+  @callback __protocol__(:consolidated?) :: boolean()
+  @callback __protocol__(:functions) :: [{atom(), arity()}]
+  @callback __protocol__(:impls) :: {:consolidated, [module()]} | :not_consolidated
+  @callback __protocol__(:module) :: module()
+
+  @doc """
+  A function available in all protocol definitions that returns the implementation
+  for the given `term` or nil.
+
+  If `@fallback_to_any` is true, `nil` is never returned.
+  """
+  @callback impl_for(term) :: module() | nil
+
+  @doc """
+  A function available in all protocol definitions that returns the implementation
+  for the given `term` or raises.
+
+  If `@fallback_to_any` is true, it never raises.
   """
+  @callback impl_for!(term) :: module()
 
   @doc """
-  Defines a new protocol function.
+  An optional callback to be implemented by protocol authors for custom deriving.
 
-  Protocols do not allow functions to be defined directly, instead, the
-  regular `Kernel.def/*` macros are replaced by this macro which
-  defines the protocol functions with the appropriate callbacks.
+  It must return a quoted expression that implements the protocol for the given module.
+
+  See `Protocol.derive/3` for an example.
   """
+  @macrocallback __deriving__(module(), term()) :: Macro.t()
+
+  @optional_callbacks __deriving__: 2
+
+  @elixir_checker_version :elixir_erl.checker_version()
+
+  @doc false
   defmacro def(signature)
 
   defmacro def({_, _, args}) when args == [] or is_atom(args) do
@@ -19,60 +279,63 @@ defmodule Protocol do
   defmacro def({name, _, args}) when is_atom(name) and is_list(args) do
     arity = length(args)
 
-    type_args = for _ <- :lists.seq(2, arity), do: quote(do: term)
+    type_args = :lists.map(fn _ -> quote(do: term) end, :lists.seq(2, arity))
     type_args = [quote(do: t) | type_args]
 
-    call_args = for i <- :lists.seq(2, arity),
-                  do: {String.to_atom(<<?x, i + 64>>), [], __MODULE__}
-    call_args = [quote(do: t) | call_args]
+    to_var = fn pos -> Macro.var(String.to_atom("arg" <> Integer.to_string(pos)), __MODULE__) end
 
-    quote do
-      name  = unquote(name)
+    call_args = :lists.map(to_var, :lists.seq(2, arity))
+    call_args = [quote(do: term) | call_args]
+
+    quote generated: true do
+      name = unquote(name)
       arity = unquote(arity)
 
-      @functions [{name, arity}|@functions]
+      @__functions__ [{name, arity} | @__functions__]
 
       # Generate a fake definition with the user
       # signature that will be used by docs
-      Kernel.def unquote(name)(unquote_splicing(args))
+      Kernel.def(unquote(name)(unquote_splicing(args)))
 
       # Generate the actual implementation
       Kernel.def unquote(name)(unquote_splicing(call_args)) do
-        impl_for!(t).unquote(name)(unquote_splicing(call_args))
+        impl_for!(term).unquote(name)(unquote_splicing(call_args))
       end
 
-      # Convert the spec to callback if possible,
+      # Copy spec as callback if possible,
       # otherwise generate a dummy callback
-      Protocol.__spec__?(__MODULE__, name, arity) ||
+      Module.spec_to_callback(__MODULE__, {name, arity}) ||
         @callback unquote(name)(unquote_splicing(type_args)) :: term
     end
   end
 
   defmacro def(_) do
-    raise ArgumentError, "invalid args for def inside defprotocol"
+    raise ArgumentError, "invalid arguments for def inside defprotocol"
   end
 
   @doc """
   Checks if the given module is loaded and is protocol.
 
-  Returns `:ok` if so, otherwise raises ArgumentError.
+  Returns `:ok` if so, otherwise raises `ArgumentError`.
   """
-  @spec assert_protocol!(module) :: :ok | no_return
+  @spec assert_protocol!(module) :: :ok
   def assert_protocol!(module) do
     assert_protocol!(module, "")
   end
 
   defp assert_protocol!(module, extra) do
-    case Code.ensure_compiled(module) do
-      {:module, ^module} -> :ok
-      _ -> raise ArgumentError, "#{inspect module} is not available" <> extra
+    try do
+      Code.ensure_compiled!(module)
+    rescue
+      e in ArgumentError ->
+        raise ArgumentError, e.message <> extra
     end
 
     try do
-      module.__protocol__(:name)
+      module.__protocol__(:module)
     rescue
       UndefinedFunctionError ->
-        raise ArgumentError, "#{inspect module} is not a protocol" <> extra
+        raise ArgumentError, "#{inspect(module)} is not a protocol" <> extra
     end
 
     :ok
@@ -82,112 +345,162 @@ defmodule Protocol do
   Checks if the given module is loaded and is an implementation
   of the given protocol.
 
-  Returns `:ok` if so, otherwise raises ArgumentError.
+  Returns `:ok` if so, otherwise raises `ArgumentError`.
   """
-  @spec assert_impl!(module, module) :: :ok | no_return
-  def assert_impl!(protocol, impl) do
-    assert_impl!(protocol, impl, "")
+  @spec assert_impl!(module, module) :: :ok
+  def assert_impl!(protocol, base) do
+    assert_impl!(protocol, base, "")
   end
 
-  defp assert_impl!(protocol, impl, extra) do
-    case Code.ensure_compiled(impl) do
-      {:module, ^impl} -> :ok
-      _ -> raise ArgumentError,
-             "#{inspect impl} is not available" <> extra
+  defp assert_impl!(protocol, base, extra) do
+    impl = __concat__(protocol, base)
+
+    try do
+      Code.ensure_compiled!(impl)
+    rescue
+      e in ArgumentError ->
+        raise ArgumentError, e.message <> extra
     end
 
     try do
       impl.__impl__(:protocol)
     rescue
       UndefinedFunctionError ->
-        raise ArgumentError,
-          "#{inspect impl} is not an implementation of a protocol" <> extra
+        raise ArgumentError, "#{inspect(impl)} is not an implementation of a protocol" <> extra
     else
       ^protocol ->
         :ok
+
       other ->
         raise ArgumentError,
-          "expected #{inspect impl} to be an implementation of #{inspect protocol}, got: #{inspect other}" <> extra
+              "expected #{inspect(impl)} to be an implementation of #{inspect(protocol)}" <>
+                ", got: #{inspect(other)}" <> extra
     end
   end
 
   @doc """
-  Derive the `protocol` for `module` with the given options.
+  Derives the `protocol` for `module` with the given options.
+
+  Every time you derive a protocol, Elixir will verify if the protocol
+  has implemented the `c:Protocol.__deriving__/2` callback. If so,
+  the callback will be invoked and it should define the implementation
+  module. Otherwise an implementation that simply points to the `Any`
+  implementation is automatically derived.
+
+  ## Examples
+
+      defprotocol Derivable do
+        @impl true
+        defmacro __deriving__(module, options) do
+          # If you need to load struct metadata, you may call:
+          # struct_info = Macro.struct_info!(module, __CALLER__)
+
+          quote do
+            defimpl Derivable, for: unquote(module) do
+              def ok(arg) do
+                {:ok, arg, unquote(options)}
+              end
+            end
+          end
+        end
+
+        def ok(arg)
+      end
+
+  Once the protocol is defined, there are two ways it can be
+  derived. The first is by using the `@derive` module attribute
+  by the time you define the struct:
+
+      defmodule ImplStruct do
+        @derive [Derivable]
+        defstruct a: 0, b: 0
+      end
+
+      Derivable.ok(%ImplStruct{})
+      #=> {:ok, %ImplStruct{a: 0, b: 0}, []}
+
+  If the struct has already been defined, you can call this macro:
+
+      require Protocol
+      Protocol.derive(Derivable, ImplStruct, :oops)
+      Derivable.ok(%ImplStruct{a: 1, b: 1})
+      #=> {:ok, %ImplStruct{a: 1, b: 1}, :oops}
+
   """
   defmacro derive(protocol, module, options \\ []) do
     quote do
-      module = unquote(module)
-      Protocol.__derive__([{unquote(protocol), unquote(options)}], module, __ENV__)
+      Protocol.__derive__([{unquote(protocol), unquote(options)}], unquote(module), __ENV__)
     end
   end
 
   ## Consolidation
 
   @doc """
-  Extract all protocols from the given paths.
+  Extracts all protocols from the given paths.
 
-  The paths can be either a char list or a string. Internally
-  they are worked on as char lists, so passing them as lists
+  The paths can be either a charlist or a string. Internally
+  they are worked on as charlists, so passing them as lists
   avoid extra conversion.
 
   Does not load any of the protocols.
 
   ## Examples
 
-      # Get Elixir's ebin and retrieve all protocols
-      iex> path = :code.lib_dir(:elixir, :ebin)
+      # Get Elixir's ebin directory path and retrieve all protocols
+      iex> path = Application.app_dir(:elixir, "ebin")
       iex> mods = Protocol.extract_protocols([path])
       iex> Enumerable in mods
       true
 
   """
-  @spec extract_protocols([char_list | String.t]) :: [atom]
+  @spec extract_protocols([charlist | String.t()]) :: [atom]
   def extract_protocols(paths) do
-    extract_matching_by_attribute paths, 'Elixir.',
-      fn module, attributes ->
-        case attributes[:protocol] do
-          [fallback_to_any: _, consolidated: _] -> module
-          _ -> nil
-        end
+    extract_matching_by_attribute(paths, [?E, ?l, ?i, ?x, ?i, ?r, ?.], fn module, attributes ->
+      case attributes[:__protocol__] do
+        [fallback_to_any: _] -> module
+        _ -> nil
       end
+    end)
   end
 
   @doc """
-  Extract all types implemented for the given protocol from
+  Extracts all types implemented for the given protocol from
   the given paths.
 
-  The paths can be either a char list or a string. Internally
-  they are worked on as char lists, so passing them as lists
+  The paths can be either a charlist or a string. Internally
+  they are worked on as charlists, so passing them as lists
   avoid extra conversion.
 
   Does not load any of the implementations.
 
   ## Examples
 
-      # Get Elixir's ebin and retrieve all protocols
-      iex> path = :code.lib_dir(:elixir, :ebin)
+      # Get Elixir's ebin directory path and retrieve all protocols
+      iex> path = Application.app_dir(:elixir, "ebin")
       iex> mods = Protocol.extract_impls(Enumerable, [path])
       iex> List in mods
       true
 
   """
-  @spec extract_impls(module, [char_list | String.t]) :: [atom]
+  @spec extract_impls(module, [charlist | String.t()]) :: [atom]
   def extract_impls(protocol, paths) when is_atom(protocol) do
-    prefix = Atom.to_char_list(protocol) ++ '.'
-    extract_matching_by_attribute paths, prefix, fn
-      _mod, attributes ->
-        case attributes[:impl] do
-          [protocol: ^protocol, for: for] -> for
-          _ -> nil
-        end
-    end
+    prefix = Atom.to_charlist(protocol) ++ [?.]
+
+    extract_matching_by_attribute(paths, prefix, fn _mod, attributes ->
+      case attributes[:__impl__] do
+        [protocol: ^protocol, for: for] -> for
+        _ -> nil
+      end
+    end)
   end
 
   defp extract_matching_by_attribute(paths, prefix, callback) do
     for path <- paths,
-       file <- list_dir(path),
-       mod = extract_from_file(path, file, prefix, callback),
-       do: mod
+        # Do not use protocols as they may be consolidating
+        path = if(is_list(path), do: path, else: String.to_charlist(path)),
+        file <- list_dir(path),
+        mod = extract_from_file(path, file, prefix, callback),
+        do: mod
   end
 
   defp list_dir(path) when is_list(path) do
@@ -197,10 +510,8 @@ defmodule Protocol do
     end
   end
 
-  defp list_dir(path), do: list_dir(to_char_list(path))
-
   defp extract_from_file(path, file, prefix, callback) do
-    if :lists.prefix(prefix, file) and :filename.extension(file) == '.beam' do
+    if :lists.prefix(prefix, file) and :filename.extension(file) == [?., ?b, ?e, ?a, ?m] do
       extract_from_beam(:filename.join(path, file), callback)
     end
   end
@@ -209,26 +520,18 @@ defmodule Protocol do
     case :beam_lib.chunks(file, [:attributes]) do
       {:ok, {module, [attributes: attributes]}} ->
         callback.(module, attributes)
-       _ ->
-         nil
-    end
-  end
 
-  defmacrop if_ok(expr, call) do
-    quote do
-      case unquote(expr) do
-        {:ok, var} -> unquote(Macro.pipe(quote(do: var), call, 0))
-        other -> other
-      end
+      _ ->
+        nil
     end
   end
 
   @doc """
-  Returns true if the protocol was consolidated.
+  Returns `true` if the protocol was consolidated.
   """
   @spec consolidated?(module) :: boolean
   def consolidated?(protocol) do
-    protocol.__info__(:attributes)[:protocol][:consolidated]
+    protocol.__protocol__(:consolidated?)
   end
 
   @doc """
@@ -241,45 +544,61 @@ defmodule Protocol do
   are retrieved with the help of `extract_impls/2`.
 
   It returns the updated version of the protocol bytecode.
+  If the first element of the tuple is `:ok`, it means
+  the protocol was consolidated.
+
   A given bytecode or protocol implementation can be checked
   to be consolidated or not by analyzing the protocol
   attribute:
 
       Protocol.consolidated?(Enumerable)
 
-  If the first element of the tuple is true, it means
-  the protocol was consolidated.
-
   This function does not load the protocol at any point
   nor loads the new bytecode for the compiled module.
-  However each implementation must be available and
+  However, each implementation must be available and
   it will be loaded.
   """
   @spec consolidate(module, [module]) ::
-    {:ok, binary} |
-    {:error, :not_a_protocol} |
-    {:error, :no_beam_info}
+          {:ok, binary}
+          | {:error, :not_a_protocol}
+          | {:error, :no_beam_info}
   def consolidate(protocol, types) when is_atom(protocol) do
-    beam_protocol(protocol)
-    |> if_ok(change_debug_info types)
-    |> if_ok(compile)
-  end
+    # Ensure the types are sorted so the compiled beam is deterministic
+    types = Enum.sort(types)
 
-  @docs_chunk 'ExDc'
+    with {:ok, any, definitions, checker, compile_info} <- beam_protocol(protocol),
+         {:ok, definitions, checker} <-
+           consolidate(protocol, any, definitions, checker, types),
+         do: compile(definitions, checker, compile_info)
+  end
 
   defp beam_protocol(protocol) do
-    chunk_ids = [:abstract_code, :attributes, @docs_chunk]
+    chunk_ids = [:debug_info, [?E, ?x, ?C, ?k], [?D, ?o, ?c, ?s]]
     opts = [:allow_missing_chunks]
+
     case :beam_lib.chunks(beam_file(protocol), chunk_ids, opts) do
-      {:ok, {^protocol, [{:abstract_code, {_raw, abstract_code}},
-                         {:attributes, attributes},
-                         {@docs_chunk, docs}]}} ->
-        case attributes[:protocol] do
-          [fallback_to_any: any, consolidated: _] ->
-            {:ok, {protocol, any, abstract_code, docs}}
+      {:ok, {^protocol, [{:debug_info, debug_info}, {_, checker} | chunks]}} ->
+        {:debug_info_v1, _backend, {:elixir_v1, module_map, specs}} = debug_info
+        %{attributes: attributes, definitions: definitions} = module_map
+
+        case attributes[:__protocol__] do
+          [fallback_to_any: any] ->
+            checker =
+              with true <- is_binary(checker),
+                   {@elixir_checker_version, contents} <- :erlang.binary_to_term(checker) do
+                contents
+              else
+                _ -> nil
+              end
+
+            chunks = :lists.filter(fn {_name, value} -> value != :missing_chunk end, chunks)
+            chunks = :lists.map(fn {name, value} -> {List.to_string(name), value} end, chunks)
+            {:ok, any, definitions, checker, {module_map, specs, chunks}}
+
           _ ->
             {:error, :not_a_protocol}
         end
+
       _ ->
         {:error, :no_beam_info}
     end
@@ -287,332 +606,605 @@ defmodule Protocol do
 
   defp beam_file(module) when is_atom(module) do
     case :code.which(module) do
-      :non_existing -> module
-      file -> file
+      [_ | _] = file -> file
+      _ -> module
     end
   end
 
-  # Change the debug information to the optimized
-  # impl_for/1 dispatch version.
-  defp change_debug_info({protocol, any, code, docs}, types) do
-    types   = if any, do: types, else: List.delete(types, Any)
-    all     = [Any] ++ for {_guard, mod} <- builtin, do: mod
-    structs = types -- all
-    case change_impl_for(code, protocol, types, structs, false, []) do
-      {:ok, ret} -> {:ok, {ret, docs}}
-      other      -> other
+  # Consolidate the protocol for faster implementations and fine-grained type information.
+  defp consolidate(protocol, fallback_to_any?, definitions, checker, types) do
+    case List.keytake(definitions, {:__protocol__, 1}, 0) do
+      {protocol_def, definitions} ->
+        types = if fallback_to_any?, do: types, else: List.delete(types, Any)
+        built_in_plus_any = [Any] ++ for {mod, _guard} <- built_in(), do: mod
+        structs = types -- built_in_plus_any
+
+        {impl_for, definitions} = List.keytake(definitions, {:impl_for, 1}, 0)
+        {impl_for!, definitions} = List.keytake(definitions, {:impl_for!, 1}, 0)
+        {struct_impl_for, definitions} = List.keytake(definitions, {:struct_impl_for, 1}, 0)
+
+        protocol_funs = get_protocol_functions(protocol_def)
+
+        protocol_def = change_protocol(protocol_def, types)
+        impl_for = change_impl_for(impl_for, protocol, types)
+        struct_impl_for = change_struct_impl_for(struct_impl_for, protocol, types, structs)
+        definitions = [protocol_def, impl_for, impl_for!, struct_impl_for] ++ definitions
+
+        checker =
+          if checker do
+            update_in(checker.exports, fn exports ->
+              signatures = new_signatures(definitions, protocol_funs, protocol, types)
+
+              for {fun, info} <- exports do
+                if sig = Map.get(signatures, fun) do
+                  {fun, %{info | sig: sig}}
+                else
+                  {fun, info}
+                end
+              end
+            end)
+          end
+
+        {:ok, definitions, checker}
+
+      nil ->
+        {:error, :not_a_protocol}
     end
   end
 
-  defp change_impl_for([{:attribute, line, :protocol, opts}|t], protocol, types, structs, _, acc) do
-    opts = [fallback_to_any: opts[:fallback_to_any], consolidated: true]
-    change_impl_for(t, protocol, types, structs, true,
-                    [{:attribute, line, :protocol, opts}|acc])
-  end
+  defp new_signatures(definitions, protocol_funs, protocol, types) do
+    alias Module.Types.Descr
+
+    clauses =
+      types
+      |> List.delete(Any)
+      |> Enum.map(fn impl ->
+        {[Module.Types.Of.impl(impl)], Descr.atom([__concat__(protocol, impl)])}
+      end)
+
+    {domain, impl_for, impl_for!} =
+      case clauses do
+        [] ->
+          if Any in types do
+            clauses = [{[Descr.term()], Descr.atom([__concat__(protocol, Any)])}]
+            {Descr.term(), clauses, clauses}
+          else
+            {Descr.none(), [{[Descr.term()], Descr.atom([nil])}],
+             [{[Descr.none()], Descr.none()}]}
+          end
 
-  defp change_impl_for([{:function, line, :impl_for, 1, _}|t], protocol, types, structs, is_protocol, acc) do
-    fallback = if Any in types, do: load_impl(protocol, Any), else: nil
+        _ ->
+          domain =
+            clauses
+            |> Enum.map(fn {[domain], _} -> domain end)
+            |> Enum.reduce(&Descr.union/2)
 
-    clauses = for {guard, mod} <- builtin,
-                  mod in types,
-                  do: builtin_clause_for(mod, guard, protocol, line)
+          not_domain = Descr.negation(domain)
 
-    clauses = [struct_clause_for(line)|clauses] ++
-              [fallback_clause_for(fallback, protocol, line)]
+          if Any in types do
+            clauses =
+              clauses ++ [{[not_domain], Descr.atom([__concat__(protocol, Any)])}]
 
-    change_impl_for(t, protocol, types, structs, is_protocol,
-                    [{:function, line, :impl_for, 1, clauses}|acc])
-  end
+            {Descr.term(), clauses, clauses}
+          else
+            {domain, clauses ++ [{[not_domain], Descr.atom([nil])}], clauses}
+          end
+      end
 
-  defp change_impl_for([{:function, line, :struct_impl_for, 1, _}|t], protocol, types, structs, is_protocol, acc) do
-    fallback = if Any in types, do: load_impl(protocol, Any), else: nil
-    clauses = for struct <- structs, do: each_struct_clause_for(struct, protocol, line)
-    clauses = clauses ++ [fallback_clause_for(fallback, protocol, line)]
+    new_signatures =
+      for {{_fun, arity} = fun_arity, :def, _, _} <- definitions,
+          fun_arity in protocol_funs do
+        rest = List.duplicate(Descr.term(), arity - 1)
+        {fun_arity, {:strong, nil, [{[domain | rest], Descr.dynamic()}]}}
+      end
 
-    change_impl_for(t, protocol, types, structs, is_protocol,
-                    [{:function, line, :struct_impl_for, 1, clauses}|acc])
+    Map.new(
+      [
+        {{:impl_for, 1}, {:strong, [Descr.term()], impl_for}},
+        {{:impl_for!, 1}, {:strong, [domain], impl_for!}}
+      ] ++ new_signatures
+    )
   end
 
-  defp change_impl_for([h|t], protocol, info, types, is_protocol, acc) do
-    change_impl_for(t, protocol, info, types, is_protocol, [h|acc])
+  defp get_protocol_functions({_name, _kind, _meta, clauses}) do
+    Enum.find_value(clauses, fn
+      {_meta, [:functions], [], clauses} -> clauses
+      _ -> nil
+    end) || raise "could not find protocol functions"
   end
 
-  defp change_impl_for([], protocol, _info, _types, is_protocol, acc) do
-    if is_protocol do
-      {:ok, {protocol, Enum.reverse(acc)}}
-    else
-      {:error, :not_a_protocol}
-    end
+  defp change_protocol({_name, _kind, meta, clauses}, types) do
+    clauses =
+      Enum.map(clauses, fn
+        {meta, [:consolidated?], [], _} -> {meta, [:consolidated?], [], true}
+        {meta, [:impls], [], _} -> {meta, [:impls], [], {:consolidated, types}}
+        clause -> clause
+      end)
+
+    {{:__protocol__, 1}, :def, meta, clauses}
   end
 
-  defp builtin_clause_for(mod, guard, protocol, line) do
-    {:clause, line,
-      [{:var, line, :x}],
-      [[{:call, line,
-          {:remote, line, {:atom, line, :erlang}, {:atom, line, guard}},
-          [{:var, line, :x}],
-     }]],
-      [{:atom, line, load_impl(protocol, mod)}]}
+  defp change_impl_for({_name, _kind, meta, _clauses}, protocol, types) do
+    fallback = if Any in types, do: __concat__(protocol, Any)
+    line = meta[:line]
+
+    clauses =
+      for {mod, guard} <- built_in(),
+          mod in types,
+          do: built_in_clause_for(mod, guard, protocol, meta, line)
+
+    struct_clause = struct_clause_for(meta, line)
+    fallback_clause = fallback_clause_for(fallback, protocol, meta)
+    clauses = [struct_clause] ++ clauses ++ [fallback_clause]
+
+    {{:impl_for, 1}, :def, meta, clauses}
+  end
+
+  defp change_struct_impl_for({_name, _kind, meta, _clauses}, protocol, types, structs) do
+    fallback = if Any in types, do: __concat__(protocol, Any)
+    clauses = for struct <- structs, do: each_struct_clause_for(struct, protocol, meta)
+    clauses = clauses ++ [fallback_clause_for(fallback, protocol, meta)]
+
+    {{:struct_impl_for, 1}, :defp, meta, clauses}
   end
 
-  defp struct_clause_for(line) do
-    {:clause, line,
-      [{:map, line, [
-        {:map_field_exact, line, {:atom, line, :__struct__}, {:var, line, :x}}
-      ]}],
-      [[{:call, line,
-          {:remote, line, {:atom, line, :erlang}, {:atom, line, :is_atom}},
-          [{:var, line, :x}],
-     }]],
-      [{:call, line,
-          {:atom, line, :struct_impl_for},
-          [{:var, line, :x}]}]}
+  defp built_in_clause_for(mod, guard, protocol, meta, line) do
+    x = {:x, [line: line, version: -1], __MODULE__}
+    guard = quote(line: line, do: :erlang.unquote(guard)(unquote(x)))
+    body = __concat__(protocol, mod)
+    {meta, [x], [guard], body}
   end
 
-  defp each_struct_clause_for(other, protocol, line) do
-    {:clause, line, [{:atom, line, other}], [],
-      [{:atom, line, load_impl(protocol, other)}]}
+  defp struct_clause_for(meta, line) do
+    x = {:x, [line: line, version: -1], __MODULE__}
+    head = quote(line: line, do: %{__struct__: unquote(x)})
+    guard = quote(line: line, do: :erlang.is_atom(unquote(x)))
+    body = quote(line: line, do: struct_impl_for(unquote(x)))
+    {meta, [head], [guard], body}
   end
 
-  defp fallback_clause_for(value, _protocol, line) do
-    {:clause, line, [{:var, line, :_}], [],
-      [{:atom, line, value}]}
+  defp each_struct_clause_for(struct, protocol, meta) do
+    {meta, [struct], [], __concat__(protocol, struct)}
   end
 
-  defp load_impl(protocol, for) do
-    Module.concat(protocol, for).__impl__(:target)
+  defp fallback_clause_for(value, _protocol, meta) do
+    {meta, [quote(do: _)], [], value}
   end
 
   # Finally compile the module and emit its bytecode.
-  defp compile({{protocol, code}, docs}) do
-    opts = if Code.compiler_options[:debug_info], do: [:debug_info], else: []
-    {:ok, ^protocol, binary, _warnings} = :compile.forms(code, [:return|opts])
-    unless docs == :missing_chunk do
-      binary = :elixir_module.add_beam_chunk(binary, @docs_chunk, docs)
-    end
-    {:ok, binary}
+  defp compile(definitions, checker, {module_map, specs, docs_chunk}) do
+    module_map = %{module_map | definitions: definitions}
+    {:ok, :elixir_erl.consolidate(module_map, checker, specs, docs_chunk)}
   end
 
   ## Definition callbacks
 
   @doc false
-  def __protocol__(name, [do: block]) do
+  def __protocol__(name, do: block) do
     quote do
       defmodule unquote(name) do
+        @behaviour Protocol
+        @before_compile Protocol
+
         # We don't allow function definition inside protocols
-        import Kernel, except: [
-          defmacrop: 1, defmacrop: 2, defmacro: 1, defmacro: 2,
-          defp: 1, defp: 2, def: 1, def: 2
-        ]
+        import Kernel, except: [def: 1, def: 2]
 
-        # Import the new dsl that holds the new def
+        # Import the new `def` that is used by protocols
         import Protocol, only: [def: 1]
 
         # Compile with debug info for consolidation
         @compile :debug_info
 
         # Set up a clear slate to store defined functions
-        @functions []
+        @__functions__ []
         @fallback_to_any false
 
         # Invoke the user given block
-        unquote(block)
+        _ = unquote(block)
 
         # Finalize expansion
-        unquote(after_defprotocol)
+        unquote(after_defprotocol())
       end
     end
   end
 
+  defp callback_ast_to_fa({_kind, {:"::", meta, [{name, _, args}, _return]}, _pos}) do
+    [{{name, length(List.wrap(args))}, meta}]
+  end
+
+  defp callback_ast_to_fa(
+         {_kind, {:when, _, [{:"::", meta, [{name, _, args}, _return]}, _vars]}, _pos}
+       ) do
+    [{{name, length(List.wrap(args))}, meta}]
+  end
+
+  defp callback_ast_to_fa({_kind, _clause, _pos}) do
+    []
+  end
+
+  defp callback_metas(module, kind)
+       when kind in [:callback, :macrocallback] do
+    :lists.flatmap(&callback_ast_to_fa/1, Module.get_attribute(module, kind))
+    |> :maps.from_list()
+  end
+
+  defp get_callback_line(fa, metas),
+    do: :maps.get(fa, metas, [])[:line]
+
+  defp warn(message, env, nil) do
+    IO.warn(message, env)
+  end
+
+  defp warn(message, env, line) when is_integer(line) do
+    IO.warn(message, %{env | line: line})
+  end
+
+  def __before_compile__(env) do
+    functions = Module.get_attribute(env.module, :__functions__)
+
+    if functions == [] do
+      warn(
+        "protocols must define at least one function, but none was defined",
+        env,
+        nil
+      )
+    end
+
+    extra =
+      ((Module.definitions_in(env.module, :def) ++ Module.definitions_in(env.module, :defmacro)) --
+         functions) --
+        [impl_for: 1, impl_for!: 1, __protocol__: 1, __deriving__: 2, __deriving__: 3]
+
+    # TODO: Make an error on Elixir v2.0
+    if extra != [] do
+      warn(
+        "protocols can only define functions without implementation via def/1, found: " <>
+          Enum.map_join(extra, ", ", fn {name, arity} -> "#{name}/#{arity}" end),
+        env,
+        nil
+      )
+    end
+
+    callback_metas = callback_metas(env.module, :callback)
+    callbacks = :maps.keys(callback_metas)
+
+    # TODO: Make an error on Elixir v2.0
+    :lists.foreach(
+      fn {name, arity} = fa ->
+        warn(
+          "cannot define @callback #{name}/#{arity} inside protocol, use def/1 to outline your protocol definition",
+          env,
+          get_callback_line(fa, callback_metas)
+        )
+      end,
+      callbacks -- functions
+    )
+
+    # Macro Callbacks
+    macrocallback_metas = callback_metas(env.module, :macrocallback)
+    macrocallbacks = :maps.keys(macrocallback_metas)
+
+    # TODO: Make an error on Elixir v2.0
+    :lists.foreach(
+      fn {name, arity} = fa ->
+        warn(
+          "cannot define @macrocallback #{name}/#{arity} inside protocol, use def/1 to outline your protocol definition",
+          env,
+          get_callback_line(fa, macrocallback_metas)
+        )
+      end,
+      macrocallbacks
+    )
+
+    # Optional Callbacks
+    optional_callbacks = Module.get_attribute(env.module, :optional_callbacks)
+
+    if optional_callbacks != [] do
+      warn(
+        "cannot define @optional_callbacks inside protocol, all of the protocol definitions are required",
+        env,
+        nil
+      )
+    end
+  end
+
   defp after_defprotocol do
-    quote bind_quoted: [builtin: builtin] do
-      @spec impl_for(term) :: module | nil
-      Kernel.def impl_for(data)
+    quote bind_quoted: [built_in: built_in()] do
+      any_impl_for =
+        if @fallback_to_any do
+          __MODULE__.Any
+        else
+          nil
+        end
+
+      # Disable Dialyzer checks - before and after consolidation
+      # the types could be more strict
+      @dialyzer {:nowarn_function, __protocol__: 1, impl_for: 1, impl_for!: 1}
+
+      @doc false
+      @spec impl_for(term) :: atom | nil
+      Kernel.def(impl_for(data))
 
       # Define the implementation for structs.
       #
       # It simply delegates to struct_impl_for which is then
       # optimized during protocol consolidation.
-      Kernel.def impl_for(%{__struct__: struct}) when :erlang.is_atom(struct) do
+      Kernel.def impl_for(%struct{}) do
         struct_impl_for(struct)
       end
 
-      # Define the implementation for builtins.
-      for {guard, mod} <- builtin do
-        target = Module.concat(__MODULE__, mod)
+      # Define the implementation for built-ins
+      :lists.foreach(
+        fn {mod, guard} ->
+          target = Protocol.__concat__(__MODULE__, mod)
 
-        Kernel.def impl_for(data) when :erlang.unquote(guard)(data) do
-          case impl_for?(unquote(target)) do
-            true  -> unquote(target).__impl__(:target)
-            false -> any_impl_for
+          Kernel.def impl_for(data) when :erlang.unquote(guard)(data) do
+            case Code.ensure_compiled(unquote(target)) do
+              {:module, module} -> module
+              {:error, _} -> unquote(any_impl_for)
+            end
           end
-        end
+        end,
+        built_in
+      )
+
+      # Define a catch-all impl_for/1 clause to pacify Dialyzer (since
+      # destructuring opaque types is illegal, Dialyzer will think none of the
+      # previous clauses matches opaque types, and without this clause, will
+      # conclude that impl_for can't handle an opaque argument). This is a hack
+      # since it relies on Dialyzer not being smart enough to conclude that all
+      # opaque types will get the any_impl_for/0 implementation.
+      Kernel.def impl_for(_) do
+        unquote(any_impl_for)
       end
 
-      @spec impl_for!(term) :: module | no_return
-      Kernel.def impl_for!(data) do
-        impl_for(data) || raise(Protocol.UndefinedError, protocol: __MODULE__, value: data)
-      end
+      undefined_impl_description =
+        Module.get_attribute(__MODULE__, :undefined_impl_description, "")
 
-      # Internal handler for Any
-      if @fallback_to_any do
-        Kernel.defp any_impl_for do
-          case impl_for?(__MODULE__.Any) do
-            true  -> __MODULE__.Any.__impl__(:target)
-            false -> nil
-          end
+      @doc false
+      @spec impl_for!(term) :: atom
+      if any_impl_for do
+        Kernel.def impl_for!(data) do
+          impl_for(data)
         end
       else
-        Kernel.defp any_impl_for, do: nil
+        Kernel.def impl_for!(data) do
+          impl_for(data) ||
+            raise(Protocol.UndefinedError,
+              protocol: __MODULE__,
+              value: data,
+              description: unquote(undefined_impl_description)
+            )
+        end
       end
 
       # Internal handler for Structs
       Kernel.defp struct_impl_for(struct) do
-        target = Module.concat(__MODULE__, struct)
-        case impl_for?(target) do
-          true  -> target.__impl__(:target)
-          false -> any_impl_for
+        case Code.ensure_compiled(Protocol.__concat__(__MODULE__, struct)) do
+          {:module, module} -> module
+          {:error, _} -> unquote(any_impl_for)
         end
       end
 
-      # Check if compilation is available internally
-      Kernel.defp impl_for?(target) do
-        Code.ensure_compiled?(target) and
-          function_exported?(target, :__impl__, 1)
-      end
-
-      # Inline any and struct implementations
-      @compile {:inline, any_impl_for: 0, struct_impl_for: 1, impl_for?: 1}
+      # Inline struct implementation for performance
+      @compile {:inline, struct_impl_for: 1}
 
-      unless Kernel.Typespec.defines_type?(__MODULE__, :t, 0) do
+      if not Module.defines_type?(__MODULE__, {:t, 0}) do
+        @typedoc """
+        All the types that implement this protocol.
+        """
         @type t :: term
       end
 
       # Store information as an attribute so it
       # can be read without loading the module.
-      Module.register_attribute(__MODULE__, :protocol, persist: true)
-      @protocol [fallback_to_any: !!@fallback_to_any, consolidated: false]
+      Module.register_attribute(__MODULE__, :__protocol__, persist: true)
+      @__protocol__ [fallback_to_any: !!@fallback_to_any]
 
       @doc false
-      @spec __protocol__(atom) :: term
-      Kernel.def __protocol__(:name),      do: __MODULE__
-      Kernel.def __protocol__(:functions), do: unquote(:lists.sort(@functions))
+      @spec __protocol__(:module) :: __MODULE__
+      @spec __protocol__(:functions) :: [{atom(), arity()}]
+      @spec __protocol__(:consolidated?) :: boolean()
+      @spec __protocol__(:impls) :: :not_consolidated | {:consolidated, [module()]}
+      Kernel.def(__protocol__(:module), do: __MODULE__)
+      Kernel.def(__protocol__(:functions), do: unquote(:lists.sort(@__functions__)))
+      Kernel.def(__protocol__(:consolidated?), do: false)
+      Kernel.def(__protocol__(:impls), do: :not_consolidated)
     end
   end
 
   @doc false
-  def __impl__(protocol, opts) do
-    do_defimpl(protocol, :lists.keysort(1, opts))
+  def __impl__(protocol, opts, do_block, env) do
+    opts = Keyword.merge(opts, do_block)
+
+    {for, opts} =
+      Keyword.pop_lazy(opts, :for, fn ->
+        env.module ||
+          raise ArgumentError, "defimpl/3 expects a :for option when declared outside a module"
+      end)
+
+    expansion_env = %{env | module: env.module || Elixir, function: {:__impl__, 1}}
+    protocol = Macro.expand_literals(protocol, expansion_env)
+    for = Macro.expand_literals(for, expansion_env)
+
+    case opts do
+      [] -> raise ArgumentError, "defimpl expects a do-end block"
+      [do: block] -> __impl__(protocol, for, block)
+      _ -> raise ArgumentError, "unknown options given to defimpl, got: #{Macro.to_string(opts)}"
+    end
   end
 
-  defp do_defimpl(protocol, [do: block, for: for]) when is_list(for) do
-    for f <- for, do: do_defimpl(protocol, [do: block, for: f])
+  defp __impl__(protocol, for, block) when is_list(for) do
+    for f <- for, do: __impl__(protocol, f, block)
   end
 
-  defp do_defimpl(protocol, [do: block, for: for]) do
+  defp __impl__(protocol, for, block) do
+    # Unquote the implementation just later
+    # when all variables will already be injected
+    # into the module body.
+    impl =
+      quote unquote: false do
+        @doc false
+        @spec __impl__(:for) :: unquote(for)
+        @spec __impl__(:protocol) :: unquote(protocol)
+        def __impl__(:for), do: unquote(for)
+        def __impl__(:protocol), do: unquote(protocol)
+      end
+
+    # If the protocol is an atom, we will add an export dependency,
+    # since it was expanded before-hand. Otherwise it is a dynamic
+    # expression (and therefore most likely a compile-time one).
+    behaviour =
+      if is_atom(protocol) do
+        quote(do: require(unquote(protocol)))
+      else
+        quote(do: protocol)
+      end
+
     quote do
       protocol = unquote(protocol)
-      for      = unquote(for)
-      name     = Module.concat(protocol, for)
+      for = unquote(for)
+      name = Protocol.__concat__(protocol, for)
 
       Protocol.assert_protocol!(protocol)
+      Protocol.__impl__!(protocol, for, __ENV__)
 
       defmodule name do
-        @behaviour protocol
-        @protocol  protocol
-        @for       for
+        @moduledoc false
+        @behaviour unquote(behaviour)
+        @protocol protocol
+        @for for
 
-        unquote(block)
+        res = unquote(block)
+        Module.register_attribute(__MODULE__, :__impl__, persist: true)
+        @__impl__ [protocol: @protocol, for: @for]
 
-        Module.register_attribute(__MODULE__, :impl, persist: true)
-        @impl [protocol: @protocol, for: @for]
-
-        @doc false
-        @spec __impl__(atom) :: term
-        def __impl__(:target),   do: __MODULE__
-        def __impl__(:protocol), do: @protocol
-        def __impl__(:for),      do: @for
+        unquote(impl)
+        res
       end
     end
   end
 
   @doc false
   def __derive__(derives, for, %Macro.Env{} = env) when is_atom(for) do
-    struct =
-      if for == env.module do
-        Module.get_attribute(for, :struct) ||
-          raise "struct is not defined for #{inspect for}"
-      else
-        for.__struct__
-      end
-
-    :lists.foreach(fn
+    foreach = fn
       proto when is_atom(proto) ->
-        derive(proto, for, struct, [], env)
+        derive(proto, for, [], env)
+
       {proto, opts} when is_atom(proto) ->
-        derive(proto, for, struct, opts, env)
-    end, :lists.flatten(derives))
+        derive(proto, for, opts, env)
+    end
+
+    :lists.foreach(foreach, :lists.flatten(derives))
 
     :ok
   end
 
-  defp derive(protocol, for, struct, opts, env) do
-    impl  = Module.concat(protocol, Map)
-    extra = ", cannot derive #{inspect protocol} for #{inspect for}"
+  defp derive(protocol, for, opts, env) do
+    extra = ", cannot derive #{inspect(protocol)} for #{inspect(for)}"
     assert_protocol!(protocol, extra)
-    assert_impl!(protocol, impl, extra)
+
+    {mod, args} =
+      if macro_exported?(protocol, :__deriving__, 2) do
+        {protocol, [for, opts]}
+      else
+        # TODO: Deprecate this on Elixir v1.22+
+        assert_impl!(protocol, Any, extra)
+        {__concat__(protocol, Any), [for, Macro.struct!(for, env), opts]}
+      end
 
     # Clean up variables from eval context
-    env  = %{env | vars: [], export_vars: nil}
-    args = [for, struct, opts]
+    env = :elixir_env.reset_vars(env)
 
-    :elixir_module.expand_callback(env.line, impl, :__deriving__, args, env, fn
-      mod, fun, args ->
-        if function_exported?(mod, fun, length(args)) do
-          apply(mod, fun, args)
-        else
-          Module.create(Module.concat(protocol, for), quote do
-            Module.register_attribute(__MODULE__, :impl, persist: true)
-            @impl [protocol: unquote(protocol), for: unquote(for)]
+    :elixir_module.expand_callback(env.line, mod, :__deriving__, args, env, fn mod, fun, args ->
+      if function_exported?(mod, fun, length(args)) do
+        apply(mod, fun, args)
+      else
+        __impl__!(protocol, for, env)
+        assert_impl!(protocol, Any, extra)
+        impl = __concat__(protocol, Any)
+
+        funs =
+          for {fun, arity} <- protocol.__protocol__(:functions) do
+            args = Macro.generate_arguments(arity, nil)
+
+            quote do
+              def unquote(fun)(unquote_splicing(args)),
+                do: unquote(impl).unquote(fun)(unquote_splicing(args))
+            end
+          end
+
+        quoted =
+          quote do
+            @behaviour unquote(protocol)
+            Module.register_attribute(__MODULE__, :__impl__, persist: true)
+            @__impl__ [protocol: unquote(protocol), for: unquote(for)]
 
             @doc false
-            @spec __impl__(atom) :: term
-            def __impl__(:target),   do: unquote(impl)
+            @spec __impl__(:protocol) :: unquote(protocol)
+            @spec __impl__(:for) :: unquote(for)
             def __impl__(:protocol), do: unquote(protocol)
-            def __impl__(:for),      do: unquote(for)
-          end, Macro.Env.location(env))
-        end
+            def __impl__(:for), do: unquote(for)
+          end
+
+        Module.create(__concat__(protocol, for), [quoted | funs], Macro.Env.location(env))
+      end
     end)
   end
 
   @doc false
-  def __spec__?(module, name, arity) do
-    signature = {name, arity}
-    specs     = Module.get_attribute(module, :spec)
-
-    found =
-      for {:spec, expr, caller} <- specs,
-          Kernel.Typespec.spec_to_signature(expr) == signature do
-          Kernel.Typespec.define_spec(:callback, expr, caller)
-          true
-        end
+  def __impl__!(protocol, for, env) do
+    if not Code.get_compiler_option(:ignore_already_consolidated) and
+         Protocol.consolidated?(protocol) do
+      message =
+        "the #{inspect(protocol)} protocol has already been consolidated, an " <>
+          "implementation for #{inspect(for)} has no effect. If you want to " <>
+          "implement protocols after compilation or during tests, check the " <>
+          "\"Consolidation\" section in the Protocol module documentation"
+
+      IO.warn(message, env)
+    end
+
+    # TODO: Make this an error on Elixir v2.0
+    if for != Any and not Keyword.has_key?(built_in(), for) and for != env.module and
+         for not in env.context_modules and Code.ensure_compiled(for) != {:module, for} do
+      IO.warn(
+        "you are implementing a protocol for #{inspect(for)} but said module is not available. " <>
+          "Make sure the module name is correct. If #{inspect(for)} is an optional dependency, " <>
+          "please wrap the protocol implementation in a Code.ensure_loaded?(#{inspect(for)}) check",
+        env
+      )
+    end
 
-    found != []
+    :ok
   end
 
-  ## Helpers
+  defp built_in do
+    [
+      {Tuple, :is_tuple},
+      {Atom, :is_atom},
+      {List, :is_list},
+      {Map, :is_map},
+      {BitString, :is_bitstring},
+      {Integer, :is_integer},
+      {Float, :is_float},
+      {Function, :is_function},
+      {PID, :is_pid},
+      {Port, :is_port},
+      {Reference, :is_reference}
+    ]
+  end
 
-  defp builtin do
-    [is_tuple: Tuple,
-     is_atom: Atom,
-     is_list: List,
-     is_map: Map,
-     is_bitstring: BitString,
-     is_integer: Integer,
-     is_float: Float,
-     is_function: Function,
-     is_pid: PID,
-     is_port: Port,
-     is_reference: Reference]
+  @doc false
+  def __concat__(left, right) do
+    String.to_atom(
+      ensure_prefix(Atom.to_string(left)) <> "." <> remove_prefix(Atom.to_string(right))
+    )
   end
+
+  defp ensure_prefix("Elixir." <> _ = left), do: left
+  defp ensure_prefix(left), do: "Elixir." <> left
+
+  defp remove_prefix("Elixir." <> right), do: right
+  defp remove_prefix(right), do: right
 end
diff --git a/lib/elixir/lib/range.ex b/lib/elixir/lib/range.ex
index 55c09855305..dd068b7e547 100644
--- a/lib/elixir/lib/range.ex
+++ b/lib/elixir/lib/range.ex
@@ -1,124 +1,535 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Range do
   @moduledoc """
-  Defines a Range.
+  Ranges represent a sequence of zero, one or many, ascending
+  or descending integers with a common difference called step.
+
+  The most common form of creating and matching on ranges is
+  via the [`first..last`](`../2`) and [`first..last//step`](`..///3`)
+  notations, auto-imported from `Kernel`:
+
+      iex> 1 in 1..10
+      true
+      iex> 5 in 1..10
+      true
+      iex> 10 in 1..10
+      true
+
+  Ranges are always inclusive in Elixir. When a step is defined,
+  integers will only belong to the range if they match the step:
+
+      iex> 5 in 1..10//2
+      true
+      iex> 4 in 1..10//2
+      false
+
+  When defining a range without a step, the step will be
+  defined based on the first and last position of the
+  range, If `last >= first`, it will be an increasing range
+  with a step of 1. Otherwise, it is a decreasing range.
+  Note, however, implicit decreasing ranges are deprecated.
+  Therefore, if you need a decreasing range from `3` to `1`,
+  prefer to write `3..1//-1` instead.
+
+  `../0` can also be used as a shortcut to create the range `0..-1//1`,
+  also known as the full-slice range:
+
+      iex> ..
+      0..-1//1
+
+  ## Use cases
+
+  Ranges typically have two uses in Elixir: as a collection or
+  to represent a slice of another data structure.
+
+  ### Ranges as collections
+
+  Ranges in Elixir are enumerables and therefore can be used
+  with the `Enum` module:
+
+      iex> Enum.to_list(1..3)
+      [1, 2, 3]
+      iex> Enum.to_list(3..1//-1)
+      [3, 2, 1]
+      iex> Enum.to_list(1..5//2)
+      [1, 3, 5]
+
+  Ranges may also have a single element:
+
+      iex> Enum.to_list(1..1)
+      [1]
+      iex> Enum.to_list(1..1//2)
+      [1]
 
-  A Range are represented internally as a struct. However,
-  the most common form of creating and matching on ranges
-  is via the `../2` macro, auto-imported from Kernel:
+  Or even no elements at all:
 
-      iex> range = 1..3
-      1..3
-      iex> first .. last = range
+      iex> Enum.to_list(10..0//1)
+      []
+      iex> Enum.to_list(0..10//-1)
+      []
+
+  The full-slice range, returned by `../0`, is an empty collection:
+
+      iex> Enum.to_list(..)
+      []
+
+  ### Ranges as slices
+
+  Ranges are also frequently used to slice collections.
+  You can slice strings or any enumerable:
+
+      iex> String.slice("elixir", 1..4)
+      "lixi"
+      iex> Enum.slice([0, 1, 2, 3, 4, 5], 1..4)
+      [1, 2, 3, 4]
+
+  In those cases, the first and last values of the range
+  are mapped to positions in the collections.
+
+  If a negative number is given, it maps to a position
+  from the back:
+
+      iex> String.slice("elixir", 1..-2//1)
+      "lixi"
+      iex> Enum.slice([0, 1, 2, 3, 4, 5], 1..-2//1)
+      [1, 2, 3, 4]
+
+  The range `0..-1//1`, returned by `../0`, returns the
+  collection as is, which is why it is called the full-slice
+  range:
+
+      iex> String.slice("elixir", ..)
+      "elixir"
+      iex> Enum.slice([0, 1, 2, 3, 4, 5], ..)
+      [0, 1, 2, 3, 4, 5]
+
+  ## Definition
+
+  An increasing range `first..last//step` is a range from `first`
+  to `last` increasing by `step` where  `step` must be a positive
+  integer and all values `v` must be `first <= v and v <= last`.
+  Therefore, a range `10..0//1` is an empty range because there
+  is no value `v` that is `10 <= v and v <= 0`.
+
+  Similarly, a decreasing range `first..last//step` is a range
+  from `first` to `last` decreasing by `step` where `step` must
+  be a negative integer and  values `v` must be `first >= v and v >= last`.
+  Therefore, a range `0..10//-1` is an empty range because there
+  is no value `v` that is `0 >= v and v >= 10`.
+
+  ## Representation
+
+  Internally, ranges are represented as structs:
+
+      iex> range = 1..9//2
+      1..9//2
+      iex> first..last//step = range
       iex> first
       1
       iex> last
-      3
+      9
+      iex> step
+      2
+      iex> range.step
+      2
+
+  You can access the range fields (`first`, `last`, and `step`)
+  directly but you should not modify nor create ranges by hand.
+  Instead use the proper operators or `new/2` and `new/3`.
+
+  Ranges implement the `Enumerable` protocol with memory
+  efficient versions of all `Enumerable` callbacks:
+
+      iex> range = 1..10
+      1..10
+      iex> Enum.reduce(range, 0, fn i, acc -> i * i + acc end)
+      385
+      iex> Enum.count(range)
+      10
+      iex> Enum.member?(range, 11)
+      false
+      iex> Enum.member?(range, 8)
+      true
 
+  Such function calls are efficient memory-wise no matter the
+  size of the range. The implementation of the `Enumerable`
+  protocol uses logic based solely on the endpoints and does
+  not materialize the whole list of integers.
   """
 
-  defstruct first: nil, last: nil
+  @enforce_keys [:first, :last, :step]
+  defstruct first: nil, last: nil, step: nil
 
-  @type t(first, last) :: %{__struct__: Range, first: first, last: last}
+  @type limit :: integer
+  @type step :: pos_integer | neg_integer
+  @type t :: %__MODULE__{first: limit, last: limit, step: step}
+  @type t(first, last) :: %__MODULE__{first: first, last: last, step: step}
 
   @doc """
   Creates a new range.
+
+  If `first` is less than `last`, the range will be increasing from
+  `first` to `last`. If `first` is equal to `last`, the range will contain
+  one element, which is the number itself.
+
+  If `first` is greater than `last`, the range will be decreasing from `first`
+  to `last`, albeit this behavior is deprecated. Therefore, it is advised to
+  explicitly list the step with `new/3`.
+
+  ## Examples
+
+      iex> Range.new(-100, 100)
+      -100..100
+
   """
+
+  @spec new(limit, limit) :: t
+  def new(first, last) when is_integer(first) and is_integer(last) do
+    step =
+      if first <= last do
+        1
+      else
+        # TODO: Remove me on v2.0
+        IO.warn_once(
+          {__MODULE__, :new},
+          fn ->
+            "Range.new/2 and first..last default to a step of -1 when last < first. Use Range.new(first, last, -1) or first..last//-1, or pass 1 if that was your intention"
+          end,
+          3
+        )
+
+        -1
+      end
+
+    %Range{first: first, last: last, step: step}
+  end
+
   def new(first, last) do
-    %Range{first: first, last: last}
+    raise ArgumentError,
+          "ranges (first..last) expect both sides to be integers, " <>
+            "got: #{inspect(first)}..#{inspect(last)}"
   end
 
   @doc """
-  Returns true if the given argument is a range.
+  Creates a new range with `step`.
 
   ## Examples
 
-      iex> Range.range?(1..3)
-      true
-
-      iex> Range.range?(0)
-      false
+      iex> Range.new(-100, 100, 2)
+      -100..100//2
 
   """
-  def range?(%Range{}), do: true
-  def range?(_), do: false
-end
+  @doc since: "1.12.0"
+  @spec new(limit, limit, step) :: t
+  def new(first, last, step)
+      when is_integer(first) and is_integer(last) and is_integer(step) and step != 0 do
+    %Range{first: first, last: last, step: step}
+  end
 
-defprotocol Range.Iterator do
-  @moduledoc """
-  A protocol used for iterating range elements.
-  """
+  def new(first, last, step) do
+    raise ArgumentError,
+          "ranges (first..last//step) expect both sides to be integers and the step to be a " <>
+            "non-zero integer, got: #{inspect(first)}..#{inspect(last)}//#{inspect(step)}"
+  end
 
   @doc """
-  Returns the function that calculates the next item.
+  Returns the size of `range`.
+
+  ## Examples
+
+      iex> Range.size(1..10)
+      10
+      iex> Range.size(1..10//2)
+      5
+      iex> Range.size(1..10//3)
+      4
+      iex> Range.size(1..10//-1)
+      0
+
+      iex> Range.size(10..1//-1)
+      10
+      iex> Range.size(10..1//-2)
+      5
+      iex> Range.size(10..1//-3)
+      4
+      iex> Range.size(10..1//1)
+      0
+
   """
-  def next(first, range)
+  @doc since: "1.12.0"
+  @spec size(t) :: non_neg_integer
+  def size(range)
+  def size(first..last//step) when step > 0 and first > last, do: 0
+  def size(first..last//step) when step < 0 and first < last, do: 0
+  def size(first..last//step), do: abs(div(last - first, step)) + 1
+
+  # TODO: Remove me on v2.0
+  def size(%{__struct__: Range, first: first, last: last} = range) do
+    step = if first <= last, do: 1, else: -1
+    size(Map.put(range, :step, step))
+  end
 
   @doc """
-  Count how many items are in the range.
+  Shifts a range by the given number of steps.
+
+  ## Examples
+
+      iex> Range.shift(0..10, 1)
+      1..11
+      iex> Range.shift(0..10, 2)
+      2..12
+
+      iex> Range.shift(0..10//2, 2)
+      4..14//2
+      iex> Range.shift(10..0//-2, 2)
+      6..-4//-2
+
   """
-  def count(first, range)
-end
+  @doc since: "1.14.0"
+  @spec shift(t, integer) :: t
+  def shift(%Range{} = range, 0), do: range
 
-defimpl Enumerable, for: Range do
-  def reduce(first .. last = range, acc, fun) do
-    reduce(first, last, acc, fun, Range.Iterator.next(first, range), last >= first)
-  end
+  def shift(first..last//step, steps_to_shift) when is_integer(steps_to_shift) do
+    shift = steps_to_shift * step
 
-  defp reduce(_x, _y, {:halt, acc}, _fun, _next, _up) do
-    {:halted, acc}
+    new(first + shift, last + shift, step)
   end
 
-  defp reduce(x, y, {:suspend, acc}, fun, next, up) do
-    {:suspended, acc, &reduce(x, y, &1, fun, next, up)}
-  end
+  @doc """
+  Splits a range in two.
 
-  defp reduce(x, y, {:cont, acc}, fun, next, true) when x <= y do
-    reduce(next.(x), y, fun.(x, acc), fun, next, true)
-  end
+  It returns a tuple of two elements.
 
-  defp reduce(x, y, {:cont, acc}, fun, next, false) when x >= y do
-    reduce(next.(x), y, fun.(x, acc), fun, next, false)
-  end
+  If `split` is less than the number of elements in the range, the first
+  element in the range will have `split` entries and the second will have
+  all remaining entries.
 
-  defp reduce(_, _, {:cont, acc}, _fun, _next, _up) do
-    {:done, acc}
-  end
+  If `split` is more than the number of elements in the range, the second
+  range in the tuple will emit zero elements.
+
+  ## Examples
+
+  Increasing ranges:
+
+      iex> Range.split(1..5, 2)
+      {1..2, 3..5}
+
+      iex> Range.split(1..5//2, 2)
+      {1..3//2, 5..5//2}
+
+      iex> Range.split(1..5//2, 0)
+      {1..-1//2, 1..5//2}
+
+      iex> Range.split(1..5//2, 10)
+      {1..5//2, 7..5//2}
+
+  Decreasing ranges can also be split:
+
+      iex> Range.split(5..1//-1, 2)
+      {5..4//-1, 3..1//-1}
+
+      iex> Range.split(5..1//-2, 2)
+      {5..3//-2, 1..1//-2}
+
+      iex> Range.split(5..1//-2, 0)
+      {5..7//-2, 5..1//-2}
+
+      iex> Range.split(5..1//-2, 10)
+      {5..1//-2, -1..1//-2}
+
+  Empty ranges preserve their property but still return empty ranges:
+
+      iex> Range.split(2..5//-1, 2)
+      {2..3//-1, 4..5//-1}
+
+      iex> Range.split(2..5//-1, 10)
+      {2..3//-1, 4..5//-1}
+
+      iex> Range.split(5..2//1, 2)
+      {5..4//1, 3..2//1}
+
+      iex> Range.split(5..2//1, 10)
+      {5..4//1, 3..2//1}
+
+  If the number to split is negative, it splits from the back:
 
-  def member?(first .. last, value) do
-    if first <= last do
-      {:ok, first <= value and value <= last}
+      iex> Range.split(1..5, -2)
+      {1..3, 4..5}
+
+      iex> Range.split(5..1//-1, -2)
+      {5..3//-1, 2..1//-1}
+
+  If it is negative and greater than the elements in the range,
+  the first element of the tuple will be an empty range:
+
+      iex> Range.split(1..5, -10)
+      {1..0//1, 1..5}
+
+      iex> Range.split(5..1//-1, -10)
+      {5..6//-1, 5..1//-1}
+
+  ## Properties
+
+  When a range is split, the following properties are observed.
+  Given `split(input)` returns `{left, right}`, we have:
+
+      assert input.first == left.first
+      assert input.last == right.last
+      assert input.step == left.step
+      assert input.step == right.step
+      assert Range.size(input) == Range.size(left) + Range.size(right)
+
+  """
+  @doc since: "1.15.0"
+  @spec split(t, integer) :: {t, t}
+  def split(first..last//step = range, split) when is_integer(split) do
+    if split >= 0 do
+      split(first, last, step, split)
     else
-      {:ok, last <= value and value <= first}
+      split(first, last, step, size(range) + split)
     end
   end
 
-  def count(first .. _ = range) do
-    {:ok, Range.Iterator.count(first, range)}
+  defp split(first, last, step, split) when first < last or (first == last and step > 0) do
+    if step > 0 do
+      mid = max(min(first + step * (split - 1), last), first - step)
+      {first..mid//step, (mid + step)..last//step}
+    else
+      {first..(first - step)//step, (last + step)..last//step}
+    end
   end
-end
 
-defimpl Range.Iterator, for: Integer do
-  def next(first, _ .. last) when is_integer(last) do
-    if last >= first do
-      &(&1 + 1)
+  defp split(last, first, step, split) do
+    if step < 0 do
+      mid = min(max(last + step * (split - 1), first), last - step)
+      {last..mid//step, (mid + step)..first//step}
     else
-      &(&1 - 1)
+      {last..(last - step)//step, (first + step)..first//step}
     end
   end
 
-  def count(first, _ .. last) when is_integer(last) do
-    if last >= first do
-      last - first + 1
+  @doc """
+  Converts a range to a list.
+
+  ## Examples
+
+      iex> Range.to_list(0..5)
+      [0, 1, 2, 3, 4, 5]
+      iex> Range.to_list(-3..0)
+      [-3, -2, -1, 0]
+
+  """
+  @doc since: "1.15.0"
+  @spec to_list(t) :: list(integer)
+  def to_list(first..last//step)
+      when step > 0 and first <= last
+      when step < 0 and first >= last do
+    :lists.seq(first, last, step)
+  end
+
+  def to_list(_first.._last//_step) do
+    []
+  end
+
+  # TODO: Remove me on v2.0
+  def to_list(%{__struct__: Range, first: first, last: last}) do
+    step = if first <= last, do: 1, else: -1
+    :lists.seq(first, last, step)
+  end
+
+  @doc """
+  Checks if two ranges are disjoint.
+
+  ## Examples
+
+      iex> Range.disjoint?(1..5, 6..9)
+      true
+      iex> Range.disjoint?(5..1//-1, 6..9)
+      true
+      iex> Range.disjoint?(1..5, 5..9)
+      false
+      iex> Range.disjoint?(1..5, 2..7)
+      false
+
+  Steps are also considered when computing the ranges to be disjoint:
+
+      iex> Range.disjoint?(1..10//2, 2..10//2)
+      true
+
+      # First element in common is 29
+      iex> Range.disjoint?(1..100//14, 8..100//21)
+      false
+      iex> Range.disjoint?(57..-1//-14, 8..100//21)
+      false
+      iex> Range.disjoint?(1..100//14, 50..8//-21)
+      false
+      iex> Range.disjoint?(1..28//14, 8..28//21)
+      true
+
+      # First element in common is 14
+      iex> Range.disjoint?(2..28//3, 9..28//5)
+      false
+      iex> Range.disjoint?(26..2//-3, 29..9//-5)
+      false
+
+      # Starting from the back without alignment
+      iex> Range.disjoint?(27..11//-3, 30..0//-7)
+      true
+
+  """
+  @doc since: "1.8.0"
+  @spec disjoint?(t, t) :: boolean
+  def disjoint?(first1..last1//step1 = range1, first2..last2//step2 = range2) do
+    if size(range1) == 0 or size(range2) == 0 do
+      true
     else
-      first - last + 1
+      {first1, last1, step1} = normalize(first1, last1, step1)
+      {first2, last2, step2} = normalize(first2, last2, step2)
+
+      cond do
+        last2 < first1 or last1 < first2 ->
+          true
+
+        abs(step1) == 1 and abs(step2) == 1 ->
+          false
+
+        true ->
+          # We need to find the first intersection of two arithmetic
+          # progressions and see if they belong within the ranges
+          # https://math.stackexchange.com/questions/1656120/formula-to-find-the-first-intersection-of-two-arithmetic-progressions
+          {gcd, u, v} = Integer.extended_gcd(-step1, step2)
+
+          if rem(first2 - first1, gcd) == 0 do
+            c = first1 - first2 + step2 - step1
+            t1 = -c / step2 * u
+            t2 = -c / step1 * v
+            t = max(floor(t1) + 1, floor(t2) + 1)
+            x = div(c * u + t * step2, gcd) - 1
+            y = div(c * v + t * step1, gcd) - 1
+
+            x < 0 or first1 + x * step1 > last1 or
+              y < 0 or first2 + y * step2 > last2
+          else
+            true
+          end
+      end
     end
   end
-end
 
-defimpl Inspect, for: Range do
-  import Inspect.Algebra
+  @compile inline: [normalize: 3]
+  defp normalize(first, last, step) when first > last,
+    do: {first - abs(div(first - last, step) * step), first, -step}
 
-  def inspect(first .. last, opts) do
-    concat [to_doc(first, opts), "..", to_doc(last, opts)]
-  end
+  defp normalize(first, last, step), do: {first, last, step}
+
+  @doc false
+  @deprecated "Pattern match on first..last//step instead"
+  def range?(%{__struct__: Range, first: first, last: last})
+      when is_integer(first) and is_integer(last),
+      do: true
+
+  def range?(_), do: false
 end
diff --git a/lib/elixir/lib/record.ex b/lib/elixir/lib/record.ex
index c58081870f9..b9cac07eb08 100644
--- a/lib/elixir/lib/record.ex
+++ b/lib/elixir/lib/record.ex
@@ -1,74 +1,152 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Record do
   @moduledoc """
-  Module to work, define and import records.
+  Module to work with, define, and import records.
 
   Records are simply tuples where the first element is an atom:
 
-      iex> Record.record? {User, "jose", 27}
+      iex> Record.is_record({User, "john", 27})
       true
 
   This module provides conveniences for working with records at
   compilation time, where compile-time field names are used to
   manipulate the tuples, providing fast operations on top of
-  the tuples compact structure.
+  the tuples' compact structure.
 
   In Elixir, records are used mostly in two situations:
 
     1. to work with short, internal data
     2. to interface with Erlang records
 
-  The macros `defrecord/3` and `defrecordp/3` can be used to create
-  records while `extract/2` can be used to extract records from Erlang
-  files.
+  The macros `defrecord/3` and `defrecordp/3` can be used to create records
+  while `extract/2` and `extract_all/1` can be used to extract records from
+  Erlang files.
+
+  ## Types
+
+  Types can be defined for tuples with the `record/2` construct (which is only
+  available in typespecs), with the record name as an atom and a keyword list
+  of fields and their types as argument:
+
+      defmodule MyModule do
+        require Record
+        Record.defrecord(:user, name: "john", age: 25)
+
+        @type user :: record(:user, name: String.t(), age: integer)
+        # expands to: "@type user :: {:user, String.t(), integer}"
+      end
+
+  ## Reflection
+
+  The record tag and its fields are stored as metadata in the "Docs" chunk
+  of the record definition macro. You can retrieve the documentation for
+  a module by calling `Code.fetch_docs/1`.
   """
 
+  @type extract_opts :: [
+          from: binary(),
+          from_lib: binary(),
+          includes: [binary()],
+          macros: keyword()
+        ]
+
   @doc """
   Extracts record information from an Erlang file.
 
   Returns a quoted expression containing the fields as a list
-  of tuples. It expects the record name to be an atom and the
-  library path to be a string at expansion time.
+  of tuples.
+
+  `name`, which is the name of the extracted record, is expected to be an atom
+  *at compile time*.
+
+  ## Options
+
+  This function requires one of the following options, which are exclusive to each
+  other (i.e., only one of them can be used in the same call):
+
+    * `:from` - (binary representing a path to a file) path to the Erlang file
+      that contains the record definition to extract; with this option, this
+      function uses the same path lookup used by the `-include` attribute used in
+      Erlang modules.
+
+    * `:from_lib` - (binary representing a path to a file) path to the Erlang
+      file that contains the record definition to extract; with this option,
+      this function uses the same path lookup used by the `-include_lib`
+      attribute used in Erlang modules.
+
+  It additionally accepts the following optional, non-exclusive options:
+
+    * `:includes` - (a list of directories as binaries) if the record being
+      extracted depends on relative includes, this option allows developers
+      to specify the directory where those relative includes exist.
+
+    * `:macros` - (keyword list of macro names and values) if the record
+      being extracted depends on the values of macros, this option allows
+      the value of those macros to be set.
+
+  These options are expected to be literals (including the binary values) at
+  compile time.
 
   ## Examples
 
       iex> Record.extract(:file_info, from_lib: "kernel/include/file.hrl")
-      [size: :undefined, type: :undefined, access: :undefined, atime: :undefined,
-       mtime: :undefined, ctime: :undefined, mode: :undefined, links: :undefined,
-       major_device: :undefined, minor_device: :undefined, inode: :undefined,
-       uid: :undefined, gid: :undefined]
+      [
+        size: :undefined,
+        type: :undefined,
+        access: :undefined,
+        atime: :undefined,
+        mtime: :undefined,
+        ctime: :undefined,
+        mode: :undefined,
+        links: :undefined,
+        major_device: :undefined,
+        minor_device: :undefined,
+        inode: :undefined,
+        uid: :undefined,
+        gid: :undefined
+      ]
 
   """
-  defmacro extract(name, opts) when is_atom(name) and is_list(opts) do
-    Macro.escape Record.Extractor.extract(name, opts)
+  @spec extract(name :: atom, extract_opts) :: keyword
+  def extract(name, opts) when is_atom(name) and is_list(opts) do
+    Record.Extractor.extract(name, opts)
   end
 
   @doc """
-  Checks if the given `data` is a record of `kind`.
+  Extracts all records information from an Erlang file.
+
+  Returns a keyword list of `{record_name, fields}` tuples where `record_name`
+  is the name of an extracted record and `fields` is a list of `{field, value}`
+  tuples representing the fields for that record.
+
+  ## Options
+
+  Accepts the same options as listed for `Record.extract/2`.
+
+  """
+  @spec extract_all(extract_opts) :: [{name :: atom, keyword}]
+  def extract_all(opts) when is_list(opts) do
+    Record.Extractor.extract_all(opts)
+  end
+
+  @doc """
+  Checks if the given `data` is a record of kind `kind`.
 
   This is implemented as a macro so it can be used in guard clauses.
 
   ## Examples
 
-      iex> record = {User, "jose", 27}
-      iex> Record.record?(record, User)
+      iex> record = {User, "john", 27}
+      iex> Record.is_record(record, User)
       true
 
   """
-  defmacro record?(data, kind) do
-    case Macro.Env.in_guard?(__CALLER__) do
-      true ->
-        quote do
-          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0
-            and :erlang.element(1, unquote(data)) == unquote(kind)
-        end
-      false ->
-        quote do
-          result = unquote(data)
-          is_tuple(result) and tuple_size(result) > 0
-            and :erlang.element(1, result) == unquote(kind)
-        end
-    end
-  end
+  defguard is_record(data, kind)
+           when is_atom(kind) and is_tuple(data) and tuple_size(data) > 0 and
+                  elem(data, 0) == kind
 
   @doc """
   Checks if the given `data` is a record.
@@ -77,77 +155,121 @@ defmodule Record do
 
   ## Examples
 
-      iex> record = {User, "jose", 27}
-      iex> Record.record?(record)
-      true
-      iex> tuple = {}
-      iex> Record.record?(tuple)
-      false
+      Record.is_record({User, "john", 27})
+      #=> true
+
+      Record.is_record({})
+      #=> false
 
   """
-  defmacro record?(data) do
-    case Macro.Env.in_guard?(__CALLER__) do
-      true ->
-        quote do
-          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0
-            and is_atom(:erlang.element(1, unquote(data)))
-        end
-      false ->
-        quote do
-          result = unquote(data)
-          is_tuple(result) and tuple_size(result) > 0
-            and is_atom(:erlang.element(1, result))
-        end
-    end
-  end
+  defguard is_record(data)
+           when is_tuple(data) and tuple_size(data) > 0 and is_atom(elem(data, 0))
 
   @doc """
-  Defines a set of macros to create and access a record.
+  Defines a set of macros to create, access, and pattern match
+  on a record.
 
-  The macros are going to have `name`, a tag (which defaults)
-  to the name if none is given, and a set of fields given by
-  `kv`.
+  The name of the generated macros will be `name` (which has to be an
+  atom). `tag` is also an atom and is used as the "tag" for the record (i.e.,
+  the first element of the record tuple); by default (if `nil`), it's the same
+  as `name`. `kv` is a keyword list of `name: default_value` fields for the
+  new record.
+
+  The following macros are generated:
+
+    * `name/0` to create a new record with default values for all fields
+    * `name/1` to create a new record with the given fields and values,
+      to get the zero-based index of the given field in a record or to
+      convert the given record to a keyword list
+    * `name/2` to update an existing record with the given fields and values
+      or to access a given field in a given record
+
+  All these macros are public macros (as defined by `defmacro`).
+
+  See the "Examples" section for examples on how to use these macros.
 
   ## Examples
 
       defmodule User do
-        Record.defrecord :user, [name: "José", age: "25"]
+        require Record
+        Record.defrecord(:user, name: "meg", age: "25")
       end
 
   In the example above, a set of macros named `user` but with different
-  arities will be defined to manipulate the underlying record:
+  arities will be defined to manipulate the underlying record.
+
+      # Import the module to make the user macros locally available
+      import User
 
       # To create records
-      user()        #=> {:user, "José", 25}
-      user(age: 26) #=> {:user, "José", 26}
+      record = user()        #=> {:user, "meg", 25}
+      record = user(age: 26) #=> {:user, "meg", 26}
 
       # To get a field from the record
-      user(record, :name) #=> "José"
+      user(record, :name) #=> "meg"
 
       # To update the record
-      user(record, age: 26) #=> {:user, "José", 26}
+      user(record, age: 26) #=> {:user, "meg", 26}
+
+      # To get the zero-based index of the field in record tuple
+      # (index 0 is occupied by the record "tag")
+      user(:name) #=> 1
+
+      # Convert a record to a keyword list
+      user(record) #=> [name: "meg", age: 26]
 
-  By default, Elixir uses the record name as the first element of
-  the tuple (the tag). But it can be changed to something else:
+  The generated macros can also be used in order to pattern match on records and
+  to bind variables during the match:
+
+      record = user() #=> {:user, "meg", 25}
+
+      user(name: name) = record
+      name #=> "meg"
+
+  By default, Elixir uses the record name as the first element of the tuple (the "tag").
+  However, a different tag can be specified when defining a record,
+  as in the following example, in which we use `Customer` as the second argument of `defrecord/3`:
 
       defmodule User do
-        Record.defrecord :user, User, name: nil
+        require Record
+        Record.defrecord(:user, Customer, name: nil)
       end
 
       require User
-      User.user() #=> {User, nil}
+      User.user() #=> {Customer, nil}
+
+  ## Defining extracted records with anonymous functions in the values
+
+  If a record defines an anonymous function in the default values, an
+  `ArgumentError` will be raised. This can happen unintentionally when defining
+  a record after extracting it from an Erlang library that uses anonymous
+  functions for defaults.
+
+      Record.defrecord(:my_rec, Record.extract(...))
+      ** (ArgumentError) invalid value for record field fun_field,
+          cannot escape #Function<12.90072148/2 in :erl_eval.expr/5>.
+
+  To work around this error, redefine the field with your own &M.f/a function,
+  like so:
+
+      defmodule MyRec do
+        require Record
+        Record.defrecord(:my_rec, Record.extract(...) |> Keyword.merge(fun_field: &__MODULE__.foo/2))
+        def foo(bar, baz), do: IO.inspect({bar, baz})
+      end
 
   """
   defmacro defrecord(name, tag \\ nil, kv) do
     quote bind_quoted: [name: name, tag: tag, kv: kv] do
       tag = tag || name
-      fields = Macro.escape Record.__fields__(:defrecord, kv)
+      fields = Record.__record__(__MODULE__, :defrecord, name, tag, kv)
 
-      defmacro(unquote(name)(args \\ [])) do
+      @doc record: {tag, fields}
+      defmacro unquote(name)(args \\ []) do
         Record.__access__(unquote(tag), unquote(fields), args, __CALLER__)
       end
 
-      defmacro(unquote(name)(record, args)) do
+      defmacro unquote(name)(record, args) do
         Record.__access__(unquote(tag), unquote(fields), record, args, __CALLER__)
       end
     end
@@ -159,124 +281,260 @@ defmodule Record do
   defmacro defrecordp(name, tag \\ nil, kv) do
     quote bind_quoted: [name: name, tag: tag, kv: kv] do
       tag = tag || name
-      fields = Macro.escape Record.__fields__(:defrecordp, kv)
+      fields = Record.__record__(__MODULE__, :defrecordp, name, tag, kv)
 
-      defmacrop(unquote(name)(args \\ [])) do
+      defmacrop unquote(name)(args \\ []) do
         Record.__access__(unquote(tag), unquote(fields), args, __CALLER__)
       end
 
-      defmacrop(unquote(name)(record, args)) do
+      defmacrop unquote(name)(record, args) do
         Record.__access__(unquote(tag), unquote(fields), record, args, __CALLER__)
       end
     end
   end
 
-  # Normalizes of record fields to have default values.
+  defp error_on_duplicate_record(module, name) do
+    defined_arity =
+      Enum.find(0..2, fn arity ->
+        Module.defines?(module, {name, arity})
+      end)
+
+    if defined_arity do
+      raise ArgumentError,
+            "cannot define record #{inspect(name)} because a definition #{name}/#{defined_arity} already exists"
+    end
+  end
+
+  defp warn_on_duplicate_key([]) do
+    :ok
+  end
+
+  defp warn_on_duplicate_key([{key, _} | [{key, _} | _] = rest]) do
+    IO.warn("duplicate key #{inspect(key)} found in record")
+    warn_on_duplicate_key(rest)
+  end
+
+  defp warn_on_duplicate_key([_ | rest]) do
+    warn_on_duplicate_key(rest)
+  end
+
+  # Callback invoked from the record/2 macro.
   @doc false
-  def __fields__(type, fields) do
-    :lists.map(fn
-      { key, _ } = pair when is_atom(key) -> pair
-      key when is_atom(key) -> { key, nil }
-      other -> raise ArgumentError, "#{type} fields must be atoms, got: #{inspect other}"
-    end, fields)
+  def __record__(module, kind, name, tag, kv) do
+    error_on_duplicate_record(module, name)
+
+    fields = fields(kind, kv)
+
+    # TODO: Remove me on Elixir v2.0
+    Module.register_attribute(module, :__records__, accumulate: true)
+
+    Module.put_attribute(module, :__records__, %{
+      kind: kind,
+      name: name,
+      tag: tag,
+      fields: :lists.map(&elem(&1, 0), fields)
+    })
+
+    # TODO: Make it raise on v2.0
+    warn_on_duplicate_key(:lists.keysort(1, fields))
+    fields
+  end
+
+  # Normalizes of record fields to have default values.
+  defp fields(kind, fields) do
+    normalizer_fun = fn
+      {key, value} when is_atom(key) ->
+        try do
+          Macro.escape(value)
+        rescue
+          e in [ArgumentError] ->
+            raise ArgumentError, "invalid value for record field #{key}, " <> Exception.message(e)
+        else
+          value -> {key, value}
+        end
+
+      key when is_atom(key) ->
+        {key, nil}
+
+      other ->
+        raise ArgumentError, "#{kind} fields must be atoms, got: #{inspect(other)}"
+    end
+
+    :lists.map(normalizer_fun, fields)
   end
 
   # Callback invoked from record/0 and record/1 macros.
   @doc false
-  def __access__(atom, fields, args, caller) do
+  def __access__(tag, fields, args, caller) do
     cond do
       is_atom(args) ->
-        index(atom, fields, args)
+        index(tag, fields, args)
+
       Keyword.keyword?(args) ->
-        create(atom, fields, args, caller)
+        create(tag, fields, args, caller)
+
       true ->
-        msg = "expected arguments to be a compile time atom or keywords, got: #{Macro.to_string args}"
-        raise ArgumentError, msg
+        fields = Macro.escape(fields)
+
+        case Macro.expand(args, caller) do
+          {:{}, _, [^tag | list]} when length(list) == length(fields) ->
+            record = List.to_tuple([tag | list])
+            Record.__keyword__(tag, fields, record)
+
+          {^tag, arg} when length(fields) == 1 ->
+            Record.__keyword__(tag, fields, {tag, arg})
+
+          _ ->
+            quote(do: Record.__keyword__(unquote(tag), unquote(fields), unquote(args)))
+        end
     end
   end
 
   # Callback invoked from the record/2 macro.
   @doc false
-  def __access__(atom, fields, record, args, caller) do
+  def __access__(tag, fields, record, args, caller) do
     cond do
       is_atom(args) ->
-        get(atom, fields, record, args)
+        get(tag, fields, record, args)
+
       Keyword.keyword?(args) ->
-        update(atom, fields, record, args, caller)
+        update(tag, fields, record, args, caller)
+
       true ->
-        msg = "expected arguments to be a compile time atom or keywords, got: #{Macro.to_string args}"
-        raise ArgumentError, msg
+        raise ArgumentError,
+              "expected arguments to be a compile time atom or a keyword list, got: " <>
+                Macro.to_string(args)
     end
   end
 
   # Gets the index of field.
-  defp index(atom, fields, field) do
-    if index = find_index(fields, field, 0) do
-      index - 1 # Convert to Elixir index
-    else
-      raise ArgumentError, "record #{inspect atom} does not have the key: #{inspect field}"
-    end
+  defp index(tag, fields, field) do
+    find_index(fields, field, 1) ||
+      raise ArgumentError, "record #{inspect(tag)} does not have the key: #{inspect(field)}"
   end
 
   # Creates a new record with the given default fields and keyword values.
-  defp create(atom, fields, keyword, caller) do
-    in_match = Macro.Env.in_match?(caller)
-
-    {match, remaining} =
-      Enum.map_reduce(fields, keyword, fn({field, default}, each_keyword) ->
-        new_fields =
-          case Keyword.has_key?(each_keyword, field) do
-            true  -> Keyword.get(each_keyword, field)
-            false ->
-              case in_match do
-                true  -> {:_, [], nil}
-                false -> Macro.escape(default)
-              end
-          end
-
-        {new_fields, Keyword.delete(each_keyword, field)}
+  defp create(tag, fields, keyword, caller) do
+    # Using {} here is safe, since it's not valid AST
+    default = if Macro.Env.in_match?(caller), do: {:_, [], nil}, else: {}
+    {default, keyword} = Keyword.pop(keyword, :_, default)
+    {keyword, exprs} = hoist_expressions(keyword, caller)
+
+    {elements, remaining} =
+      Enum.map_reduce(fields, keyword, fn {key, field_default}, remaining ->
+        case Keyword.pop(remaining, key, default) do
+          {{}, remaining} -> {Macro.escape(field_default), remaining}
+          {default, remaining} -> {default, remaining}
+        end
       end)
 
     case remaining do
       [] ->
-        {:{}, [], [atom|match]}
-      _  ->
-        keys = for {key, _} <- remaining, do: key
-        raise ArgumentError, "record #{inspect atom} does not have the key: #{inspect hd(keys)}"
+        quote(do: {unquote(tag), unquote_splicing(elements)})
+        |> maybe_prepend_reversed_exprs(exprs)
+
+      [{key, _} | _] ->
+        raise ArgumentError, "record #{inspect(tag)} does not have the key: #{inspect(key)}"
     end
   end
 
   # Updates a record given by var with the given keyword.
-  defp update(atom, fields, var, keyword, caller) do
+  defp update(tag, fields, var, keyword, caller) do
     if Macro.Env.in_match?(caller) do
       raise ArgumentError, "cannot invoke update style macro inside match"
     end
 
-    Enum.reduce keyword, var, fn({key, value}, acc) ->
-      index = find_index(fields, key, 0)
-      if index do
-        quote do
-          :erlang.setelement(unquote(index), unquote(acc), unquote(value))
-        end
+    {keyword, exprs} = hoist_expressions(keyword, caller)
+
+    if Keyword.has_key?(keyword, :_) do
+      message = "updating a record with a default (:_) is equivalent to creating a new record"
+      IO.warn(message, caller)
+      create(tag, fields, keyword, caller)
+    else
+      updates =
+        Enum.map(keyword, fn {key, value} ->
+          if index = find_index(fields, key, 2) do
+            {index, value}
+          else
+            raise ArgumentError, "record #{inspect(tag)} does not have the key: #{inspect(key)}"
+          end
+        end)
+
+      build_update(updates, var) |> maybe_prepend_reversed_exprs(exprs)
+    end
+  end
+
+  defp hoist_expressions(keyword, %{context: nil, module: module}) do
+    Enum.map_reduce(keyword, [], fn {key, expr}, acc ->
+      if simple_argument?(expr) do
+        {{key, expr}, acc}
       else
-        raise ArgumentError, "record #{inspect atom} does not have the key: #{inspect key}"
+        var = Macro.unique_var(key, module)
+        {{key, var}, [{:=, [], [var, expr]} | acc]}
       end
-    end
+    end)
   end
 
+  defp hoist_expressions(keyword, _), do: {keyword, []}
+
+  defp maybe_prepend_reversed_exprs(expr, []),
+    do: expr
+
+  defp maybe_prepend_reversed_exprs(expr, exprs),
+    do: {:__block__, [], :lists.reverse([expr | exprs])}
+
+  defp build_update(updates, initial) do
+    updates
+    |> Enum.sort(fn {left, _}, {right, _} -> right <= left end)
+    |> Enum.reduce(initial, fn {key, value}, acc ->
+      quote(do: :erlang.setelement(unquote(key), unquote(acc), unquote(value)))
+    end)
+  end
+
+  defp simple_argument?({name, _, ctx}) when is_atom(name) and is_atom(ctx), do: true
+  defp simple_argument?(other), do: Macro.quoted_literal?(other)
+
   # Gets a record key from the given var.
-  defp get(atom, fields, var, key) do
-    index = find_index(fields, key, 0)
-    if index do
-      quote do
-        :erlang.element(unquote(index), unquote(var))
+  defp get(tag, fields, var, key) do
+    index =
+      find_index(fields, key, 2) ||
+        raise ArgumentError, "record #{inspect(tag)} does not have the key: #{inspect(key)}"
+
+    quote do
+      :erlang.element(unquote(index), unquote(var))
+    end
+  end
+
+  defp find_index([{k, _} | _], k, i), do: i
+  defp find_index([{_, _} | t], k, i), do: find_index(t, k, i + 1)
+  defp find_index([], _k, _i), do: nil
+
+  # Returns a keyword list of the record
+  @doc false
+  def __keyword__(tag, fields, record) do
+    if is_record(record, tag) do
+      [_tag | values] = Tuple.to_list(record)
+
+      case join_keyword(fields, values, []) do
+        kv when is_list(kv) ->
+          kv
+
+        expected_fields ->
+          raise ArgumentError,
+                "expected argument to be a #{inspect(tag)} record with " <>
+                  "#{expected_fields} fields, got: " <> inspect(record)
       end
     else
-      raise ArgumentError, "record #{inspect atom} does not have the key: #{inspect key}"
+      raise ArgumentError,
+            "expected argument to be a literal atom, literal keyword or " <>
+              "a #{inspect(tag)} record, got runtime: " <> inspect(record)
     end
   end
 
-  defp find_index([{k, _}|_], k, i), do: i + 2
-  defp find_index([{_, _}|t], k, i), do: find_index(t, k, i + 1)
-  defp find_index([], _k, _i), do: nil
+  # Returns a keyword list, or expected number of fields on size mismatch
+  defp join_keyword([{field, _default} | fields], [value | values], acc),
+    do: join_keyword(fields, values, [{field, value} | acc])
+
+  defp join_keyword([], [], acc), do: :lists.reverse(acc)
+  defp join_keyword(rest_fields, _rest_values, acc), do: length(acc) + length(rest_fields)
 end
diff --git a/lib/elixir/lib/record/extractor.ex b/lib/elixir/lib/record/extractor.ex
index 9de1ad4f0dd..05559927d0b 100644
--- a/lib/elixir/lib/record/extractor.ex
+++ b/lib/elixir/lib/record/extractor.ex
@@ -1,56 +1,89 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Record.Extractor do
   @moduledoc false
 
-  # Retrieve a record definition from an Erlang file using
-  # the same lookup as the *include* attribute from Erlang modules.
-  def extract(name, from: file) when is_binary(file) do
-    file = String.to_char_list(file)
+  def extract(name, opts) do
+    extract_record(name, from_or_from_lib_file(opts))
+  end
+
+  def extract_all(opts) do
+    extract_all_records(from_or_from_lib_file(opts))
+  end
+
+  defp from_or_from_lib_file(opts) do
+    cond do
+      file = opts[:from] ->
+        {from_file(file), Keyword.delete(opts, :from)}
 
-    realfile =
-      case :code.where_is_file(file) do
-        :non_existing -> file
-        realfile -> realfile
-      end
+      file = opts[:from_lib] ->
+        {from_lib_file(file), Keyword.delete(opts, :from_lib)}
 
-    extract_record(name, realfile)
+      true ->
+        raise ArgumentError, "expected :from or :from_lib to be given as option"
+    end
   end
 
-  # Retrieve a record definition from an Erlang file using
-  # the same lookup as the *include_lib* attribute from Erlang modules.
-  def extract(name, from_lib: file) when is_binary(file) do
-    [app|path] = :filename.split(String.to_char_list(file))
+  # Find file using the same lookup as the *include* attribute from Erlang modules.
+  defp from_file(file) do
+    file = String.to_charlist(file)
+
+    case :code.where_is_file(file) do
+      :non_existing -> file
+      realfile -> realfile
+    end
+  end
+
+  # Find file using the same lookup as the *include_lib* attribute from Erlang modules.
+  defp from_lib_file(file) do
+    [app | path] = :filename.split(String.to_charlist(file))
 
     case :code.lib_dir(List.to_atom(app)) do
       {:error, _} ->
         raise ArgumentError, "lib file #{file} could not be found"
+
       libpath ->
-        extract_record name, :filename.join([libpath|path])
+        :filename.join([libpath | path])
     end
   end
 
   # Retrieve the record with the given name from the given file
-  defp extract_record(name, file) do
-    form = read_file(file)
+  defp extract_record(name, {file, opts}) do
+    form = read_file(file, opts)
     records = extract_records(form)
+
     if record = List.keyfind(records, name, 0) do
       parse_record(record, form)
     else
-      raise ArgumentError, "no record #{name} found at #{file}"
+      raise ArgumentError,
+            "no record #{name} found at #{file}. Or the record does not exist or " <>
+              "its entry is malformed or depends on other include files"
     end
   end
 
+  # Retrieve all records from the given file
+  defp extract_all_records({file, opts}) do
+    form = read_file(file, opts)
+    records = extract_records(form)
+    for rec = {name, _fields} <- records, do: {name, parse_record(rec, form)}
+  end
+
   # Parse the given file and extract all existent records.
   defp extract_records(form) do
     for {:attribute, _, :record, record} <- form, do: record
   end
 
   # Read a file and return its abstract syntax form that also
-  # includes record and other preprocessor modules. This is done
-  # by using Erlang's epp_dodger.
-  defp read_file(file) do
-    case :epp_dodger.quick_parse_file(file) do
+  # includes record but with macros and other attributes expanded,
+  # such as "-include(...)" and "-include_lib(...)". This is done
+  # by using Erlang's epp.
+  defp read_file(file, opts) do
+    case :epp.parse_file(file, opts) do
       {:ok, form} ->
         form
+
       other ->
         raise "error parsing file #{file}, got: #{inspect(other)}"
     end
@@ -60,9 +93,7 @@ defmodule Record.Extractor do
   # list of tuples where the first element is the field
   # and the second is its default value.
   defp parse_record({_name, fields}, form) do
-    cons = List.foldr fields, {nil, 0}, fn f, acc ->
-      {:cons, 0, parse_field(f), acc}
-    end
+    cons = List.foldr(fields, {nil, 0}, fn f, acc -> {:cons, 0, parse_field(f), acc} end)
     eval_record(cons, form)
   end
 
@@ -79,12 +110,10 @@ defmodule Record.Extractor do
   end
 
   defp eval_record(cons, form) do
-    form = form ++
-      [ {:function, 0, :hello, 0, [
-          {:clause, 0, [], [], [ cons ]} ]} ]
+    form = form ++ [{:function, 0, :hello, 0, [{:clause, 0, [], [], [cons]}]}]
 
-    {:function, 0, :hello, 0, [
-      {:clause, 0, [], [], [ record_ast ]} ]} = :erl_expand_records.module(form, []) |> List.last
+    {:function, 0, :hello, 0, [{:clause, 0, [], [], [record_ast]}]} =
+      :erl_expand_records.module(form, []) |> List.last()
 
     {:value, record, _} = :erl_eval.expr(record_ast, [])
     record
diff --git a/lib/elixir/lib/regex.ex b/lib/elixir/lib/regex.ex
index b6591de723e..8490a773629 100644
--- a/lib/elixir/lib/regex.ex
+++ b/lib/elixir/lib/regex.ex
@@ -1,59 +1,116 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Regex do
+  # TODO: Remove the "Starting from Erlang/OTP 28" part in the Modifiers'
+  #       section once Erlang/OTP 28+ is exclusively supported.
   @moduledoc ~S"""
-  Regular expressions for Elixir built on top of Erlang's `re` module.
+  Provides regular expressions for Elixir.
 
-  As the `re` module, Regex is based on PCRE
-  (Perl Compatible Regular Expressions). More information can be
-  found in the [`re` documentation](http://www.erlang.org/doc/man/re.html).
+  Regex is based on PCRE (Perl Compatible Regular Expressions) and
+  built on top of Erlang's `:re` module. More information can be found
+  in the [`:re` module documentation](`:re`).
 
-  Regular expressions in Elixir can be created using `Regex.compile!/2`
-  or using the special form with [`~r`](Kernel.html#sigil_r/2):
+  Regular expressions in Elixir can be created using the sigils
+  `~r` (see `sigil_r/2`):
 
-      # A simple regular expressions that matches foo anywhere in the string
+      # A simple regular expression that matches foo anywhere in the string
       ~r/foo/
 
-      # A regular expression with case insensitive and unicode options
+      # A regular expression with case insensitive and Unicode options
       ~r/foo/iu
 
   A Regex is represented internally as the `Regex` struct. Therefore,
   `%Regex{}` can be used whenever there is a need to match on them.
+  Keep in mind that all of the structs fields are private. And since
+  regexes are compiled, there is no guarantee two regular expressions
+  from the same source are equal, for example:
 
-  ## Modifiers
+      ~r/(?<foo>.)(?<bar>.)/ == ~r/(?<foo>.)(?<bar>.)/
 
-  The modifiers available when creating a Regex are:
+  may return `true` or `false` depending on your machine, endianness,
+  available optimizations and others. You can, however, retrieve the source
+  of a compiled regular expression by accessing the `source` field, and then
+  compare those directly:
+
+      ~r/(?<foo>.)(?<bar>.)/.source == ~r/(?<foo>.)(?<bar>.)/.source
+
+  ## Escapes
+
+  Escape sequences are split into two categories.
+
+  ### Non-printing characters
 
-    * `unicode` (u) - enables unicode specific patterns like `\p`; it expects
-      valid unicode strings to be given on match
+    * `\a` - Alarm, that is, the BEL character (hex 07)
+    * `\e` - Escape (hex 1B)
+    * `\f` - Form feed (hex 0C)
+    * `\n` - Line feed (hex 0A)
+    * `\r` - Carriage return (hex 0D)
+    * `\t` - Tab (hex 09)
+    * `\xhh` - Character with hex code hh
+    * `\x{hhh..}` - Character with hex code hhh..
 
-    * `caseless` (i) - add case insensitivity
+  `\u` and `\U` are not supported. Other escape sequences, such as `\ddd`
+  for octals, are supported but discouraged.
 
-    * `dotall` (s) - causes dot to match newlines and also set newline to
-      anycrlf; the new line setting can be overridden by setting `(*CR)` or
-      `(*LF)` or `(*CRLF)` or `(*ANY)` according to re documentation
+  ### Generic character types
 
-    * `multiline` (m) - causes `^` and `$` to mark the beginning and end of
+    * `\d` - Any decimal digit
+    * `\D` - Any character that is not a decimal digit
+    * `\h` - Any horizontal whitespace character
+    * `\H` - Any character that is not a horizontal whitespace character
+    * `\s` - Any whitespace character
+    * `\S` - Any character that is not a whitespace character
+    * `\v` - Any vertical whitespace character
+    * `\V` - Any character that is not a vertical whitespace character
+    * `\w` - Any "word" character
+    * `\W` - Any "non-word" character
+
+  ## Modifiers
+
+  The modifiers available when creating a Regex are:
+
+    * `:unicode` (u) - enables Unicode specific patterns like `\p` and causes
+      character classes like `\w`, `\W`, `\s`, and the like to also match on Unicode
+      (see examples below in "Character classes"). It expects valid Unicode
+      strings to be given on match
+
+    * `:caseless` (i) - adds case insensitivity
+
+    * `:dotall` (s) - causes dot to match newlines and also sets newline to
+      `(*ANYCRLF)`.\
+      The new line setting, as described in the [`:re` documentation](`:re`),
+      can be overridden by starting the regular expression pattern with:
+      * `(*CR)` - carriage return
+      * `(*LF)` - line feed
+      * `(*CRLF)` - carriage return, followed by line feed
+      * `(*ANYCRLF)` - any of the three above
+      * `(*ANY)` - all Unicode newline sequences
+      * _Starting from Erlang/OTP 28, `(*NUL)` - the NUL character (binary zero)_
+
+    * `:multiline` (m) - causes `^` and `$` to mark the beginning and end of
       each line; use `\A` and `\z` to match the end or beginning of the string
 
-    * `extended` (x) - whitespace characters are ignored except when escaped
-      and allow `#` to delimit comments
+    * `:extended` (x) - whitespace characters are ignored except when escaped
+      or within `[..]`, and allow `#` to delimit comments
 
-    * `firstline` (f) - forces the unanchored pattern to match before or at the
+    * `:firstline` (f) - forces the unanchored pattern to match before or at the
       first newline, though the matched text may continue over the newline
 
-    * `ungreedy` (r) - inverts the "greediness" of the regexp
-
-  The options not available are:
+    * `:ungreedy` (U) - inverts the "greediness" of the regexp
+      (the previous `r` option is deprecated in favor of `U`)
 
-    * `anchored` - not available, use `^` or `\A` instead
-    * `dollar_endonly` - not available, use `\z` instead
-    * `no_auto_capture` - not available, use `?:` instead
-    * `newline` - not available, use `(*CR)` or `(*LF)` or `(*CRLF)` or
-      `(*ANYCRLF)` or `(*ANY)` at the beginning of the regexp according to the
-      re documentation
+    * `:export` (E) (since Elixir 1.19.3) - uses an exported pattern
+      which can be shared across nodes or passed through config, at the cost of a runtime
+      overhead to re-import it every time it is executed.
+      This modifier only has an effect starting on Erlang/OTP 28, and it is ignored
+      on older versions (i.e. `~r/foo/E == ~r/foo/`). This is because patterns cannot
+      and do not need to be exported in order to be shared in these versions.
 
   ## Captures
 
-  Many functions in this module allows what to capture in a regex
+  Many functions in this module handle what to capture in a regex
   match via the `:capture` option. The supported values are:
 
     * `:all` - all captured subpatterns including the complete matching string
@@ -63,21 +120,76 @@ defmodule Regex do
       complete matching part of the string; all explicitly captured subpatterns
       are discarded
 
-    * `:all_but_first`- all but the first matching subpattern, i.e. all
+    * `:all_but_first` - all but the first matching subpattern, i.e. all
       explicitly captured subpatterns, but not the complete matching part of
       the string
 
-    * `:none` - do not return matching subpatterns at all
+    * `:none` - does not return matching subpatterns at all
+
+    * `:all_names` - captures all named subpattern matches in the Regex as a list
+      ordered **alphabetically** by the names of the subpatterns
 
-    * `:all_names` - captures all names in the Regex
+    * `list(binary | atom)` - a list of named captures to capture
 
-    * `list(binary)` - a list of named captures to capture
+  ## Character classes
+
+  Regex supports several built in named character classes. These are used by
+  enclosing the class name in `[: :]` inside a group. For example:
+
+      iex> String.match?("123", ~r/^[[:alnum:]]+$/)
+      true
+      iex> String.match?("123 456", ~r/^[[:alnum:][:blank:]]+$/)
+      true
+
+  The supported class names are:
+
+    * alnum - Letters and digits
+    * alpha - Letters
+    * blank - Space or tab only
+    * cntrl - Control characters
+    * digit - Decimal digits (same as \\d)
+    * graph - Printing characters, excluding space
+    * lower - Lowercase letters
+    * print - Printing characters, including space
+    * punct - Printing characters, excluding letters, digits, and space
+    * space - Whitespace (the same as \s from PCRE 8.34)
+    * upper - Uppercase letters
+    * word  - "Word" characters (same as \w)
+    * xdigit - Hexadecimal digits
+
+  There is another character class, `ascii`, that erroneously matches
+  Latin-1 characters instead of the 0-127 range specified by POSIX. This
+  cannot be fixed without altering the behavior of other classes, so we
+  recommend matching the range with `[\\0-\x7f]` instead.
+
+  Note the behavior of those classes may change according to the Unicode
+  and other modifiers:
+
+      iex> String.match?("josé", ~r/^[[:lower:]]+$/)
+      false
+      iex> String.match?("josé", ~r/^[[:lower:]]+$/u)
+      true
+      iex> Regex.replace(~r/\s/, "Unicode\u00A0spaces", "-")
+      "Unicode spaces"
+      iex> Regex.replace(~r/\s/u, "Unicode\u00A0spaces", "-")
+      "Unicode-spaces"
 
   """
 
-  defstruct re_pattern: nil :: term, source: "" :: binary, opts: "" :: binary
+  defstruct re_pattern: nil, source: "", opts: []
+
+  @type t :: %__MODULE__{re_pattern: term, source: binary, opts: [term]}
+
+  @type named_captures_opts :: [
+          return: :binary | :index,
+          offset: non_neg_integer()
+        ]
 
   defmodule CompileError do
+    @moduledoc """
+    An exception raised when a regular expression could not be compiled.
+    """
+
     defexception message: "regex could not be compiled"
   end
 
@@ -85,86 +197,146 @@ defmodule Regex do
   Compiles the regular expression.
 
   The given options can either be a binary with the characters
-  representing the same regex options given to the `~r` sigil,
-  or a list of options, as expected by the [Erlang `re` docs](http://www.erlang.org/doc/man/re.html).
+  representing the same regex options given to the
+  `~r` (see `sigil_r/2`) sigil, or a list of options, as
+  expected by the Erlang's [`:re`](`:re`) module.
 
   It returns `{:ok, regex}` in case of success,
   `{:error, reason}` otherwise.
 
   ## Examples
 
-      iex> Regex.compile("foo")
-      {:ok, ~r"foo"}
+      Regex.compile("foo")
+      #=> {:ok, ~r/foo/}
 
-      iex> Regex.compile("*foo")
-      {:error, {'nothing to repeat', 0}}
+      Regex.compile("foo", "i")
+      #=> {:ok, ~r/foo/i}
+
+      Regex.compile("*foo")
+      #=> {:error, {~c"quantifier does not follow a repeatable item", 0}}
 
   """
-  @spec compile(binary, binary | [term]) :: {:ok, t} | {:error, any}
-  def compile(source, options \\ "")
+  @spec compile(binary, binary | [term]) :: {:ok, t} | {:error, term}
+  def compile(source, opts \\ "") when is_binary(source) do
+    do_compile(source, opts)
+  end
 
-  def compile(source, options) when is_binary(options) do
-    case translate_options(options) do
+  defp do_compile(source, opts) when is_binary(opts) do
+    case translate_options(opts, []) do
       {:error, rest} ->
         {:error, {:invalid_option, rest}}
 
-      translated_options ->
-        compile(source, translated_options, options)
+      translated_opts ->
+        do_compile(source, translated_opts)
     end
   end
 
-  def compile(source, options) when is_list(options) do
-    compile(source, options, "")
-  end
-
-  defp compile(source, opts, doc_opts) when is_binary(source) do
+  defp do_compile(source, opts) when is_list(opts) do
     case :re.compile(source, opts) do
       {:ok, re_pattern} ->
-        {:ok, %Regex{re_pattern: re_pattern, source: source, opts: doc_opts}}
+        {:ok, %Regex{re_pattern: re_pattern, source: source, opts: opts}}
+
       error ->
         error
     end
   end
 
   @doc """
-  Compiles the regular expression according to the given options.
-  Fails with `Regex.CompileError` if the regex cannot be compiled.
+  Compiles the regular expression and raises `Regex.CompileError` in case of errors.
   """
-  def compile!(source, options \\ "") do
+  @spec compile!(binary, binary | [term]) :: t
+  def compile!(source, options \\ "") when is_binary(source) do
     case compile(source, options) do
       {:ok, regex} -> regex
-      {:error, {reason, at}} -> raise Regex.CompileError, message: "#{reason} at position #{at}"
+      {:error, {reason, at}} -> raise Regex.CompileError, "#{reason} at position #{at}"
     end
   end
 
   @doc """
-  Returns a boolean indicating whether there was a match or not.
+  Recompiles the existing regular expression if necessary.
+
+  This checks the version stored in the regular expression
+  and recompiles the regex in case of version mismatch.
+  """
+  # TODO: Deprecate on Elixir v1.22
+  @doc deprecated: "It can be removed and it has no effect"
+  @doc since: "1.4.0"
+  def recompile(%Regex{} = regex) do
+    {:ok, regex}
+  end
+
+  @doc """
+  Recompiles the existing regular expression and raises `Regex.CompileError` in case of errors.
+  """
+  # TODO: Deprecate on Elixir v1.22
+  @doc deprecated: "It can be removed and it has no effect"
+  @doc since: "1.4.0"
+  def recompile!(regex) do
+    regex
+  end
+
+  @doc """
+  Imports a `regex` that has been exported, otherwise returns the `regex` unchanged.
+
+  This means it will lose the ability to be sent across nodes or passed through config,
+  but will be faster since it won't need to be imported on the fly every time it is executed.
+
+  Exported regexes only exist on OTP 28, so this has no effect on older versions.
 
   ## Examples
 
-      iex> Regex.match?(~r/foo/, "foo")
-      true
+      Regex.import(~r/foo/E)
+      ~r/foo/
 
-      iex> Regex.match?(~r/foo/, "bar")
-      false
+      Regex.import(~r/foo/)
+      ~r/foo/
 
   """
-  def match?(%Regex{re_pattern: compiled}, string) when is_binary(string) do
-    :re.run(string, compiled, [{:capture, :none}]) == :match
+  @doc since: "1.20.0"
+  @spec import(t) :: t
+  def import(%Regex{re_pattern: re_pattern} = regex) do
+    case re_pattern do
+      {:re_exported_pattern, _, _, _, _} ->
+        %{regex | re_pattern: :re.import(re_pattern), opts: regex.opts -- [:export]}
+
+      _ ->
+        regex
+    end
   end
 
   @doc """
-  Returns true if the given argument is a regex.
+  Returns the version of the underlying Regex engine.
+  """
+  # TODO: Deprecate on Elixir v1.22
+  @doc deprecated: "Use :re.version() instead"
+  @doc since: "1.4.0"
+  def version do
+    {:re.version(), :erlang.system_info(:endian)}
+  end
+
+  @doc """
+  Returns a boolean indicating whether there was a match or not.
 
   ## Examples
 
-      iex> Regex.regex?(~r/foo/)
+      iex> Regex.match?(~r/foo/, "foo")
       true
 
-      iex> Regex.regex?(0)
+      iex> Regex.match?(~r/foo/, "bar")
       false
 
+  Elixir also provides text-based match operator `=~/2` and function `String.match?/2` as
+  an alternative to test strings against regular expressions and
+  strings.
   """
+  @spec match?(t, String.t()) :: boolean
+  def match?(%Regex{} = regex, string) when is_binary(string) do
+    safe_run(regex, string, [{:capture, :none}]) == :match
+  end
+
+  @doc false
+  @deprecated "Use Kernel.is_struct(term, Regex) or pattern match on %Regex{} instead"
+  def regex?(term)
   def regex?(%Regex{}), do: true
   def regex?(_), do: false
 
@@ -174,9 +346,12 @@ defmodule Regex do
 
   ## Options
 
-    * `:return`  - set to `:index` to return indexes. Defaults to `:binary`.
-    * `:capture` - what to capture in the result. Check the moduledoc for `Regex`
-                   to see the possible capture values.
+    * `:return` - when set to `:index`, returns byte index and match length.
+      Defaults to `:binary`.
+    * `:capture` - what to capture in the result. See the ["Captures" section](#module-captures)
+      to see the possible capture values.
+    * `:offset` - (since v1.12.0) specifies the starting offset to match in the given string.
+      Defaults to `0`.
 
   ## Examples
 
@@ -187,26 +362,39 @@ defmodule Regex do
       nil
 
       iex> Regex.run(~r/c(d)/, "abcd", return: :index)
-      [{2,2},{3,1}]
+      [{2, 2}, {3, 1}]
+
+      iex> Regex.run(~r/c(d)/, "abcd", capture: :first)
+      ["cd"]
+
+      iex> Regex.run(~r/c(?<foo>d)/, "abcd", capture: ["foo", "bar"])
+      ["d", ""]
 
   """
+  @spec run(t, binary, capture_opts) :: nil | [binary] | [{integer, integer}]
   def run(regex, string, options \\ [])
 
-  def run(%Regex{re_pattern: compiled}, string, options) when is_binary(string) do
-    return   = Keyword.get(options, :return, :binary)
+  def run(%Regex{} = regex, string, options) when is_binary(string) do
+    return = Keyword.get(options, :return, :binary)
     captures = Keyword.get(options, :capture, :all)
+    offset = Keyword.get(options, :offset, 0)
 
-    case :re.run(string, compiled, [{:capture, captures, return}]) do
+    case safe_run(regex, string, [{:capture, captures, return}, {:offset, offset}]) do
       :nomatch -> nil
-      :match   -> []
+      :match -> []
       {:match, results} -> results
     end
   end
 
   @doc """
-  Returns the given captures as a map or `nil` if no captures are
-  found. The option `:return` can be set to `:index` to get indexes
-  back.
+  Returns the given captures as a map or `nil` if no captures are found.
+
+  ## Options
+
+    * `:return` - when set to `:index`, returns byte index and match length.
+      Defaults to `:binary`.
+    * `:offset` - (since v1.12.0) specifies the starting offset to match in the given string.
+      Defaults to `0`.
 
   ## Examples
 
@@ -219,7 +407,15 @@ defmodule Regex do
       iex> Regex.named_captures(~r/a(?<foo>b)c(?<bar>d)/, "efgh")
       nil
 
+  You can also retrieve indexes from the named captures. This is particularly
+  useful if you want to know if a named capture matched or not:
+
+      iex> Regex.named_captures(~r/a(?<foo>b)c(?<bar>d)?/, "abc", return: :index)
+      %{"bar" => {-1, 0}, "foo" => {1, 1}}
+
+  You can then use `binary_part/3` to fetch the relevant part from the given string.
   """
+  @spec named_captures(t, String.t(), named_captures_opts) :: map | nil
   def named_captures(regex, string, options \\ []) when is_binary(string) do
     names = names(regex)
     options = Keyword.put(options, :capture, names)
@@ -230,6 +426,7 @@ defmodule Regex do
   @doc """
   Returns the underlying `re_pattern` in the regular expression.
   """
+  @spec re_pattern(t) :: term
   def re_pattern(%Regex{re_pattern: compiled}) do
     compiled
   end
@@ -239,27 +436,110 @@ defmodule Regex do
 
   ## Examples
 
-      iex> Regex.source(~r(foo))
+      iex> Regex.source(~r/foo/)
       "foo"
 
   """
+  @spec source(t) :: String.t()
   def source(%Regex{source: source}) do
     source
   end
 
   @doc """
-  Returns the regex options as a string.
+  Returns the regex options.
+
+  See the documentation of `Regex.compile/2` for more information.
 
   ## Examples
 
-      iex> Regex.opts(~r(foo)m)
-      "m"
+      iex> Regex.opts(~r/foo/m)
+      [:multiline]
+
+      iex> Regex.opts(Regex.compile!("foo", [:caseless]))
+      [:caseless]
 
   """
+  @spec opts(t) :: [term]
   def opts(%Regex{opts: opts}) do
     opts
   end
 
+  @doc """
+  Returns the pattern as an embeddable string.
+
+  If the pattern was compiled with an option which cannot be represented
+  as an embeddable modifier in the current version of PCRE and strict is true
+  (the default) then an ArgumentError exception will be raised.
+
+  When the `:strict` option is false the pattern will be returned as though
+  any offending options had not be used and the function will not raise any
+  exceptions.
+
+  Embeddable modifiers/options are currently:
+
+    * 'i' - `:caseless`
+    * 'm' - `:multiline`
+    * 's' - `:dotall, {:newline, :anycrlf}`
+    * 'x' - `:extended`
+
+  Unembeddable modifiers are:
+
+    * 'f' - `:firstline`
+    * 'U' - `:ungreedy`
+    * 'u' - `:unicode, :ucp`
+
+  Any other regex compilation option not listed here is considered unembeddable
+  and will raise an exception unless the `:strict` option is false.
+
+  ## Examples
+      iex> Regex.to_embed(~r/foo/)
+      "(?-imsx:foo)"
+
+      iex> Regex.to_embed(~r/^foo/m)
+      "(?m-isx:^foo)"
+
+      iex> Regex.to_embed(~r/foo # comment/ix)
+      "(?ix-ms:foo # comment\\n)"
+
+      iex> Regex.to_embed(~r/foo/iu)
+      ** (ArgumentError) regex compiled with options [:ucp, :unicode] which cannot be represented as an embedded pattern in this version of PCRE
+
+      iex> Regex.to_embed(~r/foo/imsxu, strict: false)
+      "(?imsx:foo\\n)"
+
+  """
+  @doc since: "1.19.0"
+  @spec to_embed(t, strict: boolean()) :: String.t()
+  def to_embed(%Regex{source: source, opts: regex_opts}, embed_opts \\ []) do
+    strict = Keyword.get(embed_opts, :strict, true)
+
+    modifiers =
+      case embeddable_modifiers(regex_opts) do
+        {:ok, modifiers} ->
+          modifiers
+
+        {:error, modifiers, untranslatable} ->
+          if strict do
+            raise ArgumentError,
+                  "regex compiled with options #{inspect(untranslatable)} which cannot be " <>
+                    "represented as an embedded pattern in this version of PCRE"
+          else
+            modifiers
+          end
+      end
+
+    disabled = [?i, ?m, ?s, ?x] -- modifiers
+
+    disabled = if disabled != [], do: "-#{disabled}", else: ""
+
+    # Future proof option ordering consistency by sorting
+    modifiers = Enum.sort(modifiers)
+
+    nl = if Enum.member?(regex_opts, :extended), do: "\n", else: ""
+
+    "(?#{modifiers}#{disabled}:#{source}#{nl})"
+  end
+
   @doc """
   Returns a list of names in the regex.
 
@@ -269,22 +549,26 @@ defmodule Regex do
       ["foo"]
 
   """
+  @spec names(t) :: [String.t()]
   def names(%Regex{re_pattern: re_pattern}) do
-    {:namelist, names} = :re.inspect(re_pattern, :namelist)
+    {:namelist, names} = :re.inspect(maybe_import_pattern(re_pattern), :namelist)
     names
   end
 
-  @doc """
-  Same as `run/3`, but scans the target several times collecting all
-  matches of the regular expression. A list of lists is returned,
-  where each entry in the primary list represents a match and each
-  entry in the secondary list represents the captured contents.
+  @doc ~S"""
+  Same as `run/3` but returns all non-overlapping matches of the regular expression.
+
+  A list of lists is returned, where each entry in the primary list represents a
+  match and each entry in the secondary list represents the captured contents.
 
   ## Options
 
-    * `:return`  - set to `:index` to return indexes. Defaults to `:binary`.
-    * `:capture` - what to capture in the result. Check the moduledoc for `Regex`
-                   to see the possible capture values.
+    * `:return` - when set to `:index`, returns byte index and match length.
+      Defaults to `:binary`.
+    * `:capture` - what to capture in the result. See the ["Captures" section](#module-captures)
+      to see the possible capture values.
+    * `:offset` - (since v1.12.0) specifies the starting offset to match in the given string.
+      Defaults to `0`.
 
   ## Examples
 
@@ -297,87 +581,234 @@ defmodule Regex do
       iex> Regex.scan(~r/e/, "abcd")
       []
 
+      iex> Regex.scan(~r/ab|bc|cd/, "abcd")
+      [["ab"], ["cd"]]
+
+      iex> Regex.scan(~r/ab|bc|cd/, "abbccd")
+      [["ab"], ["bc"], ["cd"]]
+
+      iex> Regex.scan(~r/\p{Sc}/u, "$, £, and €")
+      [["$"], ["£"], ["€"]]
+
+      iex> Regex.scan(~r/=+/, "=ü†ƒ8===", return: :index)
+      [[{0, 1}], [{9, 3}]]
+
+      iex> Regex.scan(~r/c(d|e)/, "abcd abce", capture: :first)
+      [["cd"], ["ce"]]
+
   """
+  @spec scan(t(), String.t(), capture_opts) :: [[String.t()]] | [[{integer(), integer()}]]
   def scan(regex, string, options \\ [])
 
-  def scan(%Regex{re_pattern: compiled}, string, options) when is_binary(string) do
-    return   = Keyword.get(options, :return, :binary)
+  def scan(%Regex{} = regex, string, options) when is_binary(string) do
+    return = Keyword.get(options, :return, :binary)
     captures = Keyword.get(options, :capture, :all)
-    options  = [{:capture, captures, return}, :global]
+    offset = Keyword.get(options, :offset, 0)
+    options = [{:capture, captures, return}, :global, {:offset, offset}]
 
-    case :re.run(string, compiled, options) do
+    case safe_run(regex, string, options) do
       :match -> []
       :nomatch -> []
       {:match, results} -> results
     end
   end
 
+  defp safe_run(%Regex{re_pattern: re_pattern} = regex, string, options) do
+    # TODO: Remove me when Erlang/OTP 28+ is required
+    # This allows regexes precompiled on Erlang/OTP 27- to work on Erlang/OTP 28+
+    with true <- :erlang.system_info(:otp_release) >= [?2, ?8],
+         {:re_pattern, _, _, _, <<_::bitstring>>} <- re_pattern do
+      %Regex{source: source, opts: compile_opts} = regex
+      :re.run(string, source, compile_opts ++ options)
+    else
+      _ -> :re.run(string, maybe_import_pattern(re_pattern), options)
+    end
+  end
+
+  @compile {:inline, maybe_import_pattern: 1}
+  @compile {:no_warn_undefined, {:re, :import, 1}}
+  defp maybe_import_pattern({:re_exported_pattern, _, _, _, _} = exported),
+    do: :re.import(exported)
+
+  defp maybe_import_pattern(pattern), do: pattern
+
+  @typedoc """
+  Options for regex functions that capture matches.
+  """
+  @type capture_opts :: [
+          return: :binary | :index,
+          capture: :all | :first | :all_but_first | :none | :all_names | [binary() | atom()],
+          offset: non_neg_integer()
+        ]
+
+  @typedoc """
+  Options for `split/3`.
+  """
+  @type split_opts :: [
+          parts: pos_integer() | :infinity,
+          trim: boolean(),
+          on: :first | :all | :all_but_first | :none | :all_names | [atom() | integer()],
+          include_captures: boolean()
+        ]
+
   @doc """
-  Splits the given target into the number of parts specified.
+  Splits the given target based on the given pattern and in the given number of
+  parts.
 
   ## Options
 
     * `:parts` - when specified, splits the string into the given number of
-      parts. If not specified, `:parts` is defaulted to `:infinity`, which will
+      parts. If not specified, `:parts` defaults to `:infinity`, which will
       split the string into the maximum number of parts possible based on the
       given pattern.
 
-    * `:trim` - when true, remove blank strings from the result.
+    * `:trim` - when `true`, removes empty strings (`""`) from the result.
+      Defaults to `false`.
+
+    * `:on` - specifies which captures to split the string on, and in what
+      order. Defaults to `:first` which means captures inside the regex do not
+      affect the splitting process. See the ["Captures" section](#module-captures)
+      to see the possible capture values.
+
+    * `:include_captures` - when `true`, includes in the result the matches of
+      the regular expression. The matches are not counted towards the maximum
+      number of parts if combined with the `:parts` option. Defaults to `false`.
 
   ## Examples
 
       iex> Regex.split(~r/-/, "a-b-c")
-      ["a","b","c"]
+      ["a", "b", "c"]
 
-      iex> Regex.split(~r/-/, "a-b-c", [parts: 2])
-      ["a","b-c"]
+      iex> Regex.split(~r/-/, "a-b-c", parts: 2)
+      ["a", "b-c"]
 
       iex> Regex.split(~r/-/, "abc")
       ["abc"]
 
       iex> Regex.split(~r//, "abc")
-      ["a", "b", "c", ""]
+      ["", "a", "b", "c", ""]
+
+      iex> Regex.split(~r/a(?<second>b)c/, "abc")
+      ["", ""]
 
-      iex> Regex.split(~r//, "abc", trim: true)
+      iex> Regex.split(~r/a(?<second>b)c/, "abc", on: [:second])
+      ["a", "c"]
+
+      iex> Regex.split(~r/(x)/, "Elixir", include_captures: true)
+      ["Eli", "x", "ir"]
+
+      iex> Regex.split(~r/a(?<second>b)c/, "abc", on: [:second], include_captures: true)
       ["a", "b", "c"]
 
-  """
+      iex> Regex.split(~r/-/, "-a-b--c", trim: true)
+      ["a", "b", "c"]
 
+  """
+  @spec split(t, String.t(), split_opts) :: [String.t()]
   def split(regex, string, options \\ [])
 
-  def split(%Regex{re_pattern: compiled}, string, options) when is_binary(string) do
-    parts  = Keyword.get(options, :parts, :infinity)
-    opts   = [return: :binary, parts: zero_to_infinity(parts)]
-    splits = :re.split(string, compiled, opts)
-
-    if Keyword.get(options, :trim, false) do
-      for split <- splits, split != "", do: split
+  def split(%Regex{}, "", opts) do
+    if Keyword.get(opts, :trim, false) do
+      []
     else
-      splits
+      [""]
+    end
+  end
+
+  def split(%Regex{} = regex, string, opts)
+      when is_binary(string) and is_list(opts) do
+    on = Keyword.get(opts, :on, :first)
+
+    case safe_run(regex, string, [:global, capture: on]) do
+      {:match, matches} ->
+        index = parts_to_index(Keyword.get(opts, :parts, :infinity))
+        trim = Keyword.get(opts, :trim, false)
+        include_captures = Keyword.get(opts, :include_captures, false)
+        do_split(matches, string, 0, index, trim, include_captures)
+
+      :match ->
+        [string]
+
+      :nomatch ->
+        [string]
+    end
+  end
+
+  defp parts_to_index(:infinity), do: 0
+  defp parts_to_index(n) when is_integer(n) and n > 0, do: n
+
+  defp do_split(_, string, offset, _counter, true, _with_captures)
+       when byte_size(string) <= offset do
+    []
+  end
+
+  defp do_split(_, string, offset, 1, _trim, _with_captures),
+    do: [binary_part(string, offset, byte_size(string) - offset)]
+
+  defp do_split([], string, offset, _counter, _trim, _with_captures),
+    do: [binary_part(string, offset, byte_size(string) - offset)]
+
+  defp do_split([[{pos, _} | h] | t], string, offset, counter, trim, with_captures)
+       when pos - offset < 0 do
+    do_split([h | t], string, offset, counter, trim, with_captures)
+  end
+
+  defp do_split([[] | t], string, offset, counter, trim, with_captures),
+    do: do_split(t, string, offset, counter, trim, with_captures)
+
+  defp do_split([[{pos, length} | h] | t], string, offset, counter, trim, true) do
+    new_offset = pos + length
+    keep = pos - offset
+
+    <<_::binary-size(^offset), part::binary-size(^keep), match::binary-size(^length), _::binary>> =
+      string
+
+    cond do
+      keep == 0 and (offset != 0 and length == 0) ->
+        do_split([h | t], string, new_offset, counter - 1, trim, true)
+
+      keep == 0 and trim ->
+        [match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
+
+      true ->
+        [part, match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
     end
   end
 
-  defp zero_to_infinity(0), do: :infinity
-  defp zero_to_infinity(n), do: n
+  defp do_split([[{pos, length} | h] | t], string, offset, counter, trim, false) do
+    new_offset = pos + length
+    keep = pos - offset
+
+    if keep == 0 and (trim or (offset != 0 and length == 0)) do
+      do_split([h | t], string, new_offset, counter, trim, false)
+    else
+      <<_::binary-size(^offset), part::binary-size(^keep), _::binary>> = string
+      [part | do_split([h | t], string, new_offset, counter - 1, trim, false)]
+    end
+  end
 
   @doc ~S"""
   Receives a regex, a binary and a replacement, returns a new
-  binary where the all matches are replaced by replacement.
+  binary where all matches are replaced by the replacement.
 
-  The replacement can be either a string or a function. The string
-  is used as a replacement for every match and it allows specific
-  captures to be accessed via `\N`, where `N` is the capture. In
-  case `\0` is used, the whole match is inserted.
+  The replacement can be either a string or a function that returns a string.
+  The resulting string is used as a replacement for every match.
 
-  When the replacement is a function, the function may have arity
-  N where each argument maps to a capture, with the first argument
-  being the whole match. If the function expects more arguments
-  than captures found, the remaining arguments will receive `""`.
+  When the replacement is a string, it allows specific captures of the match
+  using brackets at the regex expression and accessing them in the replacement
+  via `\N` or `\g{N}`, where `N` is the number of the capture. In case `\0` is
+  used, the whole match is inserted. Note that in regexes the backslash needs
+  to be escaped, hence in practice you'll need to use `\\N` and `\\g{N}`.
+
+  When the replacement is a function, it allows specific captures too.
+  The function may have arity N where each argument maps to a capture,
+  with the first argument being the whole match. If the function expects more
+  arguments than captures found, the remaining arguments will receive `""`.
 
   ## Options
 
     * `:global` - when `false`, replaces only the first occurrence
-      (defaults to true)
+      (defaults to `true`)
 
   ## Examples
 
@@ -393,64 +824,74 @@ defmodule Regex do
       iex> Regex.replace(~r/a(b|d)c/, "abcadc", "[\\1]")
       "[b][d]"
 
+      iex> Regex.replace(~r/\.(\d)$/, "500.5", ".\\g{1}0")
+      "500.50"
+
       iex> Regex.replace(~r/a(b|d)c/, "abcadc", fn _, x -> "[#{x}]" end)
       "[b][d]"
 
-  """
-  def replace(regex, string, replacement, options \\ [])
+      iex> Regex.replace(~r/(\w+)@(\w+).(\w+)/, "abc@def.com", fn _full, _c1, _c2, c3 -> "TLD: #{c3}" end)
+      "TLD: com"
 
-  def replace(regex, string, replacement, options) when is_binary(replacement) do
-    do_replace(regex, string, precompile_replacement(replacement), options)
-  end
+      iex> Regex.replace(~r/a/, "abcadc", "A", global: false)
+      "Abcadc"
 
-  def replace(regex, string, replacement, options) when is_function(replacement) do
-    {:arity, arity} = :erlang.fun_info(replacement, :arity)
-    do_replace(regex, string, {replacement, arity}, options)
-  end
-
-  defp do_replace(%Regex{re_pattern: compiled}, string, replacement, options) do
+  """
+  @spec replace(t, String.t(), String.t() | (... -> String.t()), global: boolean()) ::
+          String.t()
+  def replace(%Regex{} = regex, string, replacement, options \\ [])
+      when is_binary(string) and is_list(options) do
     opts = if Keyword.get(options, :global) != false, do: [:global], else: []
-    opts = [{:capture, :all, :index}|opts]
+    opts = [{:capture, :all, :index} | opts]
 
-    case :re.run(string, compiled, opts) do
+    case safe_run(regex, string, opts) do
       :nomatch ->
         string
-      {:match, [mlist|t]} when is_list(mlist) ->
-        apply_list(string, replacement, [mlist|t]) |> IO.iodata_to_binary
+
+      {:match, [mlist | t]} when is_list(mlist) ->
+        apply_list(string, precompile_replacement(replacement), [mlist | t])
+        |> IO.iodata_to_binary()
+
       {:match, slist} ->
-        apply_list(string, replacement, [slist]) |> IO.iodata_to_binary
+        apply_list(string, precompile_replacement(replacement), [slist])
+        |> IO.iodata_to_binary()
     end
   end
 
-  defp precompile_replacement(""),
-    do: []
+  defp precompile_replacement(replacement) when is_function(replacement) do
+    {:arity, arity} = Function.info(replacement, :arity)
+    {replacement, arity}
+  end
 
-  defp precompile_replacement(<<?\\, x, rest :: binary>>) when x < ?0 or x > ?9 do
-    case precompile_replacement(rest) do
-      [head | t] when is_binary(head) ->
-        [<<x, head :: binary>> | t]
-      other ->
-        [<<x>> | other]
-    end
+  defp precompile_replacement(""), do: []
+
+  defp precompile_replacement(<<?\\, ?g, ?{, rest::binary>>) when byte_size(rest) > 0 do
+    {ns, <<?}, rest::binary>>} = pick_int(rest)
+    [List.to_integer(ns) | precompile_replacement(rest)]
   end
 
-  defp precompile_replacement(<<?\\, rest :: binary>>) when byte_size(rest) > 0 do
+  defp precompile_replacement(<<?\\, ?\\, rest::binary>>) do
+    [<<?\\>> | precompile_replacement(rest)]
+  end
+
+  defp precompile_replacement(<<?\\, x, rest::binary>>) when x in ?0..?9 do
     {ns, rest} = pick_int(rest)
-    [List.to_integer(ns) | precompile_replacement(rest)]
+    [List.to_integer([x | ns]) | precompile_replacement(rest)]
   end
 
-  defp precompile_replacement(<<x, rest :: binary>>) do
+  defp precompile_replacement(<<x, rest::binary>>) do
     case precompile_replacement(rest) do
       [head | t] when is_binary(head) ->
-        [<<x, head :: binary>> | t]
+        [<<x, head::binary>> | t]
+
       other ->
         [<<x>> | other]
     end
   end
 
-  defp pick_int(<<x, rest :: binary>>) when x in ?0..?9 do
+  defp pick_int(<<x, rest::binary>>) when x in ?0..?9 do
     {found, rest} = pick_int(rest)
-    {[x|found], rest}
+    {[x | found], rest}
   end
 
   defp pick_int(bin) do
@@ -469,14 +910,15 @@ defmodule Regex do
     string
   end
 
-  defp apply_list(whole, string, pos, replacement, [[{mpos, _} | _] | _] = list) when mpos > pos do
+  defp apply_list(whole, string, pos, replacement, [[{mpos, _} | _] | _] = list)
+       when mpos > pos do
     length = mpos - pos
-    <<untouched :: [size(length), binary], rest :: binary>> = string
+    <<untouched::binary-size(^length), rest::binary>> = string
     [untouched | apply_list(whole, rest, mpos, replacement, list)]
   end
 
-  defp apply_list(whole, string, pos, replacement, [[{mpos, length} | _] = head | tail]) when mpos == pos do
-    <<_ :: [size(length), binary], rest :: binary>> = string
+  defp apply_list(whole, string, pos, replacement, [[{pos, length} | _] = head | tail]) do
+    <<_::size(^length)-binary, rest::binary>> = string
     new_data = apply_replace(whole, replacement, head)
     [new_data | apply_list(whole, rest, pos + length, replacement, tail)]
   end
@@ -496,20 +938,22 @@ defmodule Regex do
       cond do
         is_binary(part) ->
           part
-        part > tuple_size(indexes) ->
+
+        part >= tuple_size(indexes) ->
           ""
+
         true ->
           get_index(string, elem(indexes, part))
       end
     end
   end
 
-  defp get_index(_string, {pos, _len}) when pos < 0 do
+  defp get_index(_string, {pos, _length}) when pos < 0 do
     ""
   end
 
-  defp get_index(string, {pos, len}) do
-    <<_ :: [size(pos), binary], res :: [size(len), binary], _ :: binary>> = string
+  defp get_index(string, {pos, length}) do
+    <<_::size(^pos)-binary, res::size(^length)-binary, _::binary>> = string
     res
   end
 
@@ -518,16 +962,13 @@ defmodule Regex do
   end
 
   defp get_indexes(string, [], arity) do
-    [""|get_indexes(string, [], arity - 1)]
+    ["" | get_indexes(string, [], arity - 1)]
   end
 
-  defp get_indexes(string, [h|t], arity) do
-    [get_index(string, h)|get_indexes(string, t, arity - 1)]
+  defp get_indexes(string, [h | t], arity) do
+    [get_index(string, h) | get_indexes(string, t, arity - 1)]
   end
 
-  {:ok, pattern} = :re.compile(~S"[.^$*+?()[{\\\|\s#]", [:unicode])
-  @escape_pattern pattern
-
   @doc ~S"""
   Escapes a string to be literally matched in a regex.
 
@@ -540,37 +981,142 @@ defmodule Regex do
       "\\\\what\\ if"
 
   """
-  @spec escape(String.t) :: String.t
+  @spec escape(String.t()) :: String.t()
   def escape(string) when is_binary(string) do
-    :re.replace(string, @escape_pattern, "\\\\&", [:global, {:return, :binary}])
+    string
+    |> escape(_length = 0, string)
+    |> IO.iodata_to_binary()
+  end
+
+  @escapable :binary.bin_to_list(".^$*+?()[]{}|#-\\\t\n\v\f\r\s")
+
+  defp escape(<<char, rest::binary>>, length, original) when char in @escapable do
+    escape_char(rest, length, original, char)
+  end
+
+  defp escape(<<_, rest::binary>>, length, original) do
+    escape(rest, length + 1, original)
+  end
+
+  defp escape(<<>>, _length, original) do
+    original
+  end
+
+  defp escape_char(<<rest::binary>>, 0, _original, char) do
+    [?\\, char | escape(rest, 0, rest)]
+  end
+
+  defp escape_char(<<rest::binary>>, length, original, char) do
+    [binary_part(original, 0, length), ?\\, char | escape(rest, 0, rest)]
   end
 
   # Helpers
 
+  # translate options to modifiers as required for emedding
+  defp embeddable_modifiers(list), do: embeddable_modifiers(list, [], [])
+
+  defp embeddable_modifiers([:dotall, {:newline, :anycrlf} | t], acc, err),
+    do: embeddable_modifiers(t, [?s | acc], err)
+
+  defp embeddable_modifiers([:caseless | t], acc, err),
+    do: embeddable_modifiers(t, [?i | acc], err)
+
+  defp embeddable_modifiers([:extended | t], acc, err),
+    do: embeddable_modifiers(t, [?x | acc], err)
+
+  defp embeddable_modifiers([:multiline | t], acc, err),
+    do: embeddable_modifiers(t, [?m | acc], err)
+
+  defp embeddable_modifiers([option | t], acc, err),
+    do: embeddable_modifiers(t, acc, [option | err])
+
+  defp embeddable_modifiers([], acc, []), do: {:ok, acc}
+  defp embeddable_modifiers([], acc, err), do: {:error, acc, err}
+
+  # translate modifiers to options
+
+  defp translate_options(<<?s, t::binary>>, acc),
+    do: translate_options(t, [:dotall, {:newline, :anycrlf} | acc])
+
+  defp translate_options(<<?u, t::binary>>, acc), do: translate_options(t, [:unicode, :ucp | acc])
+  defp translate_options(<<?i, t::binary>>, acc), do: translate_options(t, [:caseless | acc])
+  defp translate_options(<<?x, t::binary>>, acc), do: translate_options(t, [:extended | acc])
+  defp translate_options(<<?f, t::binary>>, acc), do: translate_options(t, [:firstline | acc])
+  defp translate_options(<<?U, t::binary>>, acc), do: translate_options(t, [:ungreedy | acc])
+  defp translate_options(<<?m, t::binary>>, acc), do: translate_options(t, [:multiline | acc])
+
+  defp translate_options(<<?r, t::binary>>, acc) do
+    IO.warn("the /r modifier in regular expressions is deprecated, please use /U instead")
+    translate_options(t, [:ungreedy | acc])
+  end
+
+  defp translate_options(<<?E, t::binary>>, acc) do
+    # on OTP 27-, the E modifier is a no-op since the feature doesn't exist but isn't needed
+    # (regexes aren't using references and can be shared across nodes or stored in config)
+    # TODO: remove this check on Erlang/OTP 28+ and update docs
+    case Code.ensure_loaded?(:re) and function_exported?(:re, :import, 1) do
+      true -> translate_options(t, [:export | acc])
+      false -> translate_options(t, acc)
+    end
+  end
+
+  defp translate_options(<<>>, acc), do: acc
+  defp translate_options(t, _acc), do: {:error, t}
+
+  @doc false
+  def __escape__(%{__struct__: Regex} = regex) do
+    # OTP 28.0 introduced refs in patterns, which can't be used in AST anymore
+    # OTP 28.1 introduced :re.import/1 which allows us to work with pre-compiled binaries again
+
+    pattern_ast =
+      cond do
+        # TODO: Remove this when we require Erlang/OTP 28+
+        # Before OTP 28.0, patterns did not contain any refs and could be safely be escaped
+        :erlang.system_info(:otp_release) < [?2, ?8] ->
+          Macro.escape(regex.re_pattern)
+
+        :lists.member(:export, regex.opts) ->
+          Macro.escape(regex.re_pattern)
+
+        # OTP 28.1+ introduced the ability to export and import regexes from compiled binaries
+        Code.ensure_loaded?(:re) and function_exported?(:re, :import, 1) ->
+          {:ok, exported} = :re.compile(regex.source, [:export] ++ regex.opts)
+
+          quote do
+            Regex.__import_pattern__(unquote(Macro.escape(exported)))
+          end
+          # we now that the Regex module is defined at this stage, so this macro can be safely called
+          |> Macro.update_meta(&([required: true] ++ &1))
+
+        # TODO: Remove this when we require Erlang/OTP 28.1+
+        # OTP 28.0 works in degraded mode performance-wise, we need to recompile from the source
+        true ->
+          quote do
+            {:ok, pattern} =
+              :re.compile(unquote(Macro.escape(regex.source)), unquote(Macro.escape(regex.opts)))
+
+            pattern
+          end
+      end
+
+    quote do
+      %{
+        __struct__: unquote(Regex),
+        re_pattern: unquote(pattern_ast),
+        source: unquote(Macro.escape(regex.source)),
+        opts: unquote(Macro.escape(regex.opts))
+      }
+    end
+  end
+
   @doc false
-  # Unescape map function used by Macro.unescape_string.
-  def unescape_map(?f), do: ?\f
-  def unescape_map(?n), do: ?\n
-  def unescape_map(?r), do: ?\r
-  def unescape_map(?t), do: ?\t
-  def unescape_map(?v), do: ?\v
-  def unescape_map(?a), do: ?\a
-  def unescape_map(_),  do: false
-
-  # Private Helpers
-
-  defp translate_options(<<?g, t :: binary>>) do
-    IO.write :stderr, "The /g flag for regular expressions is no longer needed\n#{Exception.format_stacktrace}"
-    translate_options(t)
-  end
-
-  defp translate_options(<<?u, t :: binary>>), do: [:unicode|translate_options(t)]
-  defp translate_options(<<?i, t :: binary>>), do: [:caseless|translate_options(t)]
-  defp translate_options(<<?x, t :: binary>>), do: [:extended|translate_options(t)]
-  defp translate_options(<<?f, t :: binary>>), do: [:firstline|translate_options(t)]
-  defp translate_options(<<?r, t :: binary>>), do: [:ungreedy|translate_options(t)]
-  defp translate_options(<<?s, t :: binary>>), do: [:dotall, {:newline, :anycrlf}|translate_options(t)]
-  defp translate_options(<<?m, t :: binary>>), do: [:multiline|translate_options(t)]
-  defp translate_options(<<>>), do: []
-  defp translate_options(rest), do: {:error, rest}
+  defmacro __import_pattern__(pattern) do
+    if __CALLER__.context in [:match, :guard] do
+      raise ArgumentError, "escaped Regex structs are not allowed in match or guards"
+    end
+
+    quote do
+      :re.import(unquote(pattern))
+    end
+  end
 end
diff --git a/lib/elixir/lib/registry.ex b/lib/elixir/lib/registry.ex
new file mode 100644
index 00000000000..7b6e09f2c0d
--- /dev/null
+++ b/lib/elixir/lib/registry.ex
@@ -0,0 +1,1848 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Registry do
+  @moduledoc ~S"""
+  A local, decentralized and scalable key-value process storage.
+
+  It allows developers to lookup one or more processes with a given key.
+  If the registry has `:unique` keys, a key points to 0 or 1 process.
+  If the registry allows `:duplicate` keys, a single key may point to any
+  number of processes. In both cases, different keys could identify the
+  same process.
+
+  Each entry in the registry is associated to the process that has
+  registered the key. If the process crashes, the keys associated to that
+  process are automatically removed. All key comparisons in the registry
+  are done using the match operation (`===/2`).
+
+  The registry can be used for different purposes, such as name lookups (using
+  the `:via` option), storing properties, custom dispatching rules, or a pubsub
+  implementation. We explore some of those use cases below.
+
+  The registry may also be transparently partitioned, which provides
+  more scalable behavior for running registries on highly concurrent
+  environments with thousands or millions of entries.
+
+  ## Using in `:via`
+
+  Once the registry is started with a given name using
+  `Registry.start_link/1`, it can be used to register and access named
+  processes using the `{:via, Registry, {registry, key}}` tuple:
+
+      {:ok, _} = Registry.start_link(keys: :unique, name: MyApp.Registry)
+      name = {:via, Registry, {MyApp.Registry, "agent"}}
+      {:ok, _} = Agent.start_link(fn -> 0 end, name: name)
+      Agent.get(name, & &1)
+      #=> 0
+      Agent.update(name, &(&1 + 1))
+      Agent.get(name, & &1)
+      #=> 1
+
+  In the previous example, we were not interested in associating a value to the
+  process:
+
+      Registry.lookup(MyApp.Registry, "agent")
+      #=> [{self(), nil}]
+
+  However, in some cases it may be desired to associate a value to the process
+  using the alternate `{:via, Registry, {registry, key, value}}` tuple:
+
+      {:ok, _} = Registry.start_link(keys: :unique, name: MyApp.Registry)
+      name = {:via, Registry, {MyApp.Registry, "agent", :hello}}
+      {:ok, agent_pid} = Agent.start_link(fn -> 0 end, name: name)
+
+      Registry.lookup(MyApp.Registry, "agent")
+      #=> [{agent_pid, :hello}]
+
+      name_without_meta = {:via, Registry, {MyApp.Registry, "agent"}}
+      Agent.update(name_without_meta, fn x -> x + 1 end)
+      Agent.get(name_without_meta, & &1)
+      #=> 1
+
+  > #### With *and* without metadata {: .tip}
+  >
+  > When using the version of `:via` tuples with *metadata*, you can still use the version
+  > **without** metadata to look up the process.
+
+  To this point, we have been starting `Registry` using `start_link/1`.
+  Typically the registry is started as part of a supervision tree though:
+
+      {Registry, keys: :unique, name: MyApp.Registry}
+
+  Only registries with unique keys can be used in `:via`. If the name is
+  already taken, the case-specific `start_link` function (`Agent.start_link/2`
+  in the example above) will return `{:error, {:already_started, current_pid}}`.
+
+  ## Using as a dispatcher
+
+  `Registry` has a dispatch mechanism that allows developers to implement custom
+  dispatch logic triggered from the caller. For example, let's say we have a
+  duplicate registry started as so:
+
+      {:ok, _} = Registry.start_link(keys: :duplicate, name: Registry.DispatcherTest)
+
+  By calling `register/3`, different processes can register under a given key
+  and associate any value under that key. In this case, let's register the
+  current process under the key `"hello"` and attach the `{IO, :inspect}` tuple
+  to it:
+
+      {:ok, _} = Registry.register(Registry.DispatcherTest, "hello", {IO, :inspect})
+
+  Now, an entity interested in dispatching events for a given key may call
+  `dispatch/3` passing in the key and a callback. This callback will be invoked
+  with a list of all the values registered under the requested key, alongside
+  the PID of the process that registered each value, in the form of `{pid,
+  value}` tuples. In our example, `value` will be the `{module, function}` tuple
+  in the code above:
+
+      Registry.dispatch(Registry.DispatcherTest, "hello", fn entries ->
+        for {pid, {module, function}} <- entries, do: apply(module, function, [pid])
+      end)
+      # Prints #PID<...> where the PID is for the process that called register/3 above
+      #=> :ok
+
+  Dispatching happens in the process that calls `dispatch/3` either serially or
+  concurrently in case of multiple partitions (via spawned tasks). The
+  registered processes are not involved in dispatching unless involving them is
+  done explicitly (for example, by sending them a message in the callback).
+
+  Furthermore, if there is a failure when dispatching, due to a bad
+  registration, dispatching will always fail and the registered process will not
+  be notified. Therefore let's make sure we at least wrap and report those
+  errors:
+
+      require Logger
+
+      Registry.dispatch(Registry.DispatcherTest, "hello", fn entries ->
+        for {pid, {module, function}} <- entries do
+          try do
+            apply(module, function, [pid])
+          catch
+            kind, reason ->
+              formatted = Exception.format(kind, reason, __STACKTRACE__)
+              Logger.error("Registry.dispatch/3 failed with #{formatted}")
+          end
+        end
+      end)
+      # Prints #PID<...>
+      #=> :ok
+
+  You could also replace the whole `apply` system by explicitly sending
+  messages. That's the example we will see next.
+
+  ## Using as a PubSub
+
+  Registries can also be used to implement a local, non-distributed, scalable
+  PubSub by relying on the `dispatch/3` function, similarly to the previous
+  section: in this case, however, we will send messages to each associated
+  process, instead of invoking a given module-function.
+
+  In this example, we will also set the number of partitions to the number of
+  schedulers online, which will make the registry more performant on highly
+  concurrent environments:
+
+      {:ok, _} =
+        Registry.start_link(
+          keys: :duplicate,
+          name: Registry.PubSubTest,
+          partitions: System.schedulers_online()
+        )
+
+      {:ok, _} = Registry.register(Registry.PubSubTest, "hello", [])
+
+      Registry.dispatch(Registry.PubSubTest, "hello", fn entries ->
+        for {pid, _} <- entries, do: send(pid, {:broadcast, "world"})
+      end)
+      #=> :ok
+
+  The example above broadcasted the message `{:broadcast, "world"}` to all
+  processes registered under the "topic" (or "key" as we called it until now)
+  `"hello"`.
+
+  The third argument given to `register/3` is a value associated to the
+  current process. While in the previous section we used it when dispatching,
+  in this particular example we are not interested in it, so we have set it
+  to an empty list. You could store a more meaningful value if necessary.
+
+  ## Registrations
+
+  Looking up, dispatching and registering are efficient and immediate at
+  the cost of delayed unsubscription. For example, if a process crashes,
+  its keys are automatically removed from the registry but the change may
+  not propagate immediately. This means certain operations may return processes
+  that are already dead. When such may happen, it will be explicitly stated
+  in the function documentation.
+
+  However, keep in mind those cases are typically not an issue. After all, a
+  process referenced by a PID may crash at any time, including between getting
+  the value from the registry and sending it a message. Many parts of the standard
+  library are designed to cope with that, such as `Process.monitor/1` which will
+  deliver the `:DOWN` message immediately if the monitored process is already dead
+  and `send/2` which acts as a no-op for dead processes.
+
+  ## ETS
+
+  Note that the registry uses one ETS table plus two ETS tables per partition.
+  """
+
+  @keys [:unique, :duplicate, {:duplicate, :key}, {:duplicate, :pid}]
+  @all_info -1
+  @key_info -2
+
+  @typedoc "The registry identifier"
+  @type registry :: atom
+
+  @typedoc "The type of the registry"
+  @type keys :: :unique | :duplicate | {:duplicate, :key} | {:duplicate, :pid}
+
+  @typedoc "The type of keys allowed on registration"
+  @type key :: term
+
+  @typedoc "The type of values allowed on registration"
+  @type value :: term
+
+  @typedoc "The type of registry metadata keys"
+  @type meta_key :: atom | tuple
+
+  @typedoc "The type of registry metadata values"
+  @type meta_value :: term
+
+  @typedoc "A pattern to match on objects in a registry"
+  @type match_pattern :: atom | term
+
+  @typedoc "A guard to be evaluated when matching on objects in a registry"
+  @type guard :: atom | tuple
+
+  @typedoc "A list of guards to be evaluated when matching on objects in a registry"
+  @type guards :: [guard]
+
+  @typedoc "A pattern used to representing the output format part of a match spec"
+  @type body :: [term]
+
+  @typedoc "A full match spec used when selecting objects in the registry"
+  @type spec :: [{match_pattern, guards, body}]
+
+  @typedoc "Options used for `child_spec/1` and `start_link/1`"
+  @type start_option ::
+          {:keys, keys}
+          | {:name, registry}
+          | {:partitions, pos_integer}
+          | {:listeners, [atom]}
+          | {:meta, [{meta_key, meta_value}]}
+
+  @typedoc """
+  The message that the registry sends to listeners when a process registers or unregisters.
+
+  See the `:listeners` option in `start_link/1`.
+  """
+  @typedoc since: "1.15.0"
+  @type listener_message ::
+          {:register, registry, key, registry_partition :: pid, value}
+          | {:unregister, registry, key, registry_partition :: pid}
+
+  @typedoc """
+  Options used for `dispatch/4`.
+  """
+  @type dispatch_opts :: [parallel: boolean()]
+
+  ## Via callbacks
+
+  @doc false
+  def whereis_name({registry, key}), do: whereis_name(registry, key)
+  def whereis_name({registry, key, _value}), do: whereis_name(registry, key)
+
+  defp whereis_name(registry, key) do
+    case key_info!(registry) do
+      {:unique, partitions, key_ets} ->
+        key_ets = key_ets || key_ets!(registry, key, partitions)
+
+        case safe_lookup_second(key_ets, key) do
+          {pid, _} ->
+            if Process.alive?(pid), do: pid, else: :undefined
+
+          _ ->
+            :undefined
+        end
+
+      {{:duplicate, _}, _, _} ->
+        raise ArgumentError, ":via is not supported for duplicate registries"
+    end
+  end
+
+  @doc false
+  def register_name({registry, key}, pid), do: register_name(registry, key, nil, pid)
+  def register_name({registry, key, value}, pid), do: register_name(registry, key, value, pid)
+
+  defp register_name(registry, key, value, pid) when pid == self() do
+    case register(registry, key, value) do
+      {:ok, _} -> :yes
+      {:error, _} -> :no
+    end
+  end
+
+  @doc false
+  def send({registry, key}, msg) do
+    case lookup(registry, key) do
+      [{pid, _}] -> Kernel.send(pid, msg)
+      [] -> :erlang.error(:badarg, [{registry, key}, msg])
+    end
+  end
+
+  def send({registry, key, _value}, msg) do
+    Registry.send({registry, key}, msg)
+  end
+
+  @doc false
+  def unregister_name({registry, key}), do: unregister(registry, key)
+  def unregister_name({registry, key, _value}), do: unregister(registry, key)
+
+  ## Registry API
+
+  @doc """
+  Starts the registry as a supervisor process.
+
+  Manually it can be started as:
+
+      Registry.start_link(keys: :unique, name: MyApp.Registry)
+
+  In your supervisor tree, you would write:
+
+      Supervisor.start_link([
+        {Registry, keys: :unique, name: MyApp.Registry}
+      ], strategy: :one_for_one)
+
+  For intensive workloads, the registry may also be partitioned (by specifying
+  the `:partitions` option). If partitioning is required then a good default is to
+  set the number of partitions to the number of schedulers available:
+
+      Registry.start_link(
+        keys: :unique,
+        name: MyApp.Registry,
+        partitions: System.schedulers_online()
+      )
+
+  or:
+
+      Supervisor.start_link([
+        {Registry, keys: :unique, name: MyApp.Registry, partitions: System.schedulers_online()}
+      ], strategy: :one_for_one)
+
+  For `:duplicate` registries with many different keys (e.g., many topics with
+  few subscribers each), you can optimize key-based lookups by partitioning by key:
+
+      Registry.start_link(
+        keys: {:duplicate, :key},
+        name: MyApp.TopicRegistry,
+        partitions: System.schedulers_online()
+      )
+
+  This allows key-based lookups to check only a single partition instead of
+  searching all partitions. Use the default `:pid` partitioning when you have
+  fewer keys with many entries each (e.g., one topic with many subscribers).
+
+  ## Options
+
+  The registry requires the following keys:
+
+    * `:keys` - chooses if keys are `:unique`, `:duplicate`, `{:duplicate, :key}`, or `{:duplicate, :pid}`
+    * `:name` - the name of the registry and its tables
+
+  The following keys are optional:
+
+    * `:partitions` - the number of partitions in the registry. Defaults to `1`.
+    * `:listeners` - a list of named processes which are notified of register
+      and unregister events. The registered process must be monitored by the
+      listener if the listener wants to be notified if the registered process
+      crashes. Messages sent to listeners are of type `t:listener_message/0`.
+    * `:meta` - a keyword list of metadata to be attached to the registry.
+
+      For `:duplicate` registries, you can specify the partitioning strategy
+      directly in the `:keys` option:
+
+      * `:duplicate` or `{:duplicate, :pid}` - Use `:pid` partitioning (default)
+        when you have keys with many entries (e.g., one topic with many subscribers).
+        This is the traditional behavior and groups all entries from the same process together.
+
+      * `{:duplicate, :key}` - Use `:key` partitioning when entries are spread across
+        many different keys (e.g., many topics with few subscribers each). This makes
+        key-based lookups more efficient as they only need to check a single partition
+        instead of all partitions.
+
+  """
+  @doc since: "1.5.0"
+  @spec start_link([start_option]) :: {:ok, pid} | {:error, term}
+  def start_link(options) do
+    keys = Keyword.get(options, :keys)
+
+    # Validate and normalize keys format
+    kind =
+      case keys do
+        {:duplicate, partition_strategy} when partition_strategy in [:key, :pid] ->
+          {:duplicate, partition_strategy}
+
+        :unique ->
+          :unique
+
+        :duplicate ->
+          {:duplicate, :pid}
+
+        _ ->
+          raise ArgumentError,
+                "expected :keys to be given and be one of :unique, :duplicate, {:duplicate, :key}, or {:duplicate, :pid}, got: #{inspect(keys)}"
+      end
+
+    name =
+      case Keyword.fetch(options, :name) do
+        {:ok, name} when is_atom(name) ->
+          name
+
+        {:ok, other} ->
+          raise ArgumentError, "expected :name to be an atom, got: #{inspect(other)}"
+
+        :error ->
+          raise ArgumentError, "expected :name option to be present"
+      end
+
+    meta = Keyword.get(options, :meta, [])
+
+    if not Keyword.keyword?(meta) do
+      raise ArgumentError, "expected :meta to be a keyword list, got: #{inspect(meta)}"
+    end
+
+    partitions = Keyword.get(options, :partitions, 1)
+
+    if not (is_integer(partitions) and partitions >= 1) do
+      raise ArgumentError,
+            "expected :partitions to be a positive integer, got: #{inspect(partitions)}"
+    end
+
+    listeners = Keyword.get(options, :listeners, [])
+
+    if not (is_list(listeners) and Enum.all?(listeners, &is_atom/1)) do
+      raise ArgumentError,
+            "expected :listeners to be a list of named processes, got: #{inspect(listeners)}"
+    end
+
+    compressed = Keyword.get(options, :compressed, false)
+
+    if not is_boolean(compressed) do
+      raise ArgumentError,
+            "expected :compressed to be a boolean, got: #{inspect(compressed)}"
+    end
+
+    # The @info format must be kept in sync with Registry.Partition optimization.
+    entries = [
+      {@all_info, {kind, partitions, nil, nil, listeners}},
+      {@key_info, {kind, partitions, nil}} | meta
+    ]
+
+    Registry.Supervisor.start_link(
+      kind,
+      name,
+      partitions,
+      listeners,
+      entries,
+      compressed
+    )
+  end
+
+  @doc false
+  @deprecated "Use Registry.start_link/1 instead"
+  def start_link(keys, name, options \\ []) when keys in @keys and is_atom(name) do
+    start_link([keys: keys, name: name] ++ options)
+  end
+
+  @doc """
+  Returns a specification to start a registry under a supervisor.
+
+  See `Supervisor`.
+  """
+  @doc since: "1.5.0"
+  @spec child_spec([start_option]) :: Supervisor.child_spec()
+  def child_spec(options) do
+    %{
+      id: Keyword.get(options, :name, Registry),
+      start: {Registry, :start_link, [options]},
+      type: :supervisor
+    }
+  end
+
+  @doc """
+  Updates the value for `key` for the current process in the unique `registry`.
+
+  Returns a `{new_value, old_value}` tuple or `:error` if there
+  is no such key assigned to the current process.
+
+  If a non-unique registry is given, an error is raised.
+
+  ## Examples
+
+      iex> Registry.start_link(keys: :unique, name: Registry.UpdateTest)
+      iex> {:ok, _} = Registry.register(Registry.UpdateTest, "hello", 1)
+      iex> Registry.lookup(Registry.UpdateTest, "hello")
+      [{self(), 1}]
+      iex> Registry.update_value(Registry.UpdateTest, "hello", &(&1 + 1))
+      {2, 1}
+      iex> Registry.lookup(Registry.UpdateTest, "hello")
+      [{self(), 2}]
+
+  """
+  @doc since: "1.4.0"
+  @spec update_value(registry, key, (value -> value)) ::
+          {new_value :: term, old_value :: term} | :error
+  def update_value(registry, key, callback) when is_atom(registry) and is_function(callback, 1) do
+    case key_info!(registry) do
+      {:unique, partitions, key_ets} ->
+        key_ets = key_ets || key_ets!(registry, key, partitions)
+
+        try do
+          :ets.lookup_element(key_ets, key, 2)
+        catch
+          :error, :badarg -> :error
+        else
+          {pid, old_value} when pid == self() ->
+            new_value = callback.(old_value)
+            :ets.insert(key_ets, {key, {pid, new_value}})
+            {new_value, old_value}
+
+          {_, _} ->
+            :error
+        end
+
+      {kind, _, _} ->
+        raise ArgumentError,
+              "Registry.update_value/3 is not supported for #{inspect(kind)} registries"
+    end
+  end
+
+  @doc """
+  Invokes the callback with all entries under `key` in each partition
+  for the given `registry`.
+
+  The list of `entries` is a non-empty list of two-element tuples where
+  the first element is the PID and the second element is the value
+  associated to the PID. If there are no entries for the given key,
+  the callback is never invoked.
+
+  If the registry is partitioned, the callback is invoked multiple times
+  per partition. If the registry is partitioned and `parallel: true` is
+  given as an option, the dispatching happens in parallel. In both cases,
+  the callback is only invoked if there are entries for that partition.
+
+  See the module documentation for examples of using the `dispatch/3`
+  function for building custom dispatching or a pubsub system.
+
+  ## Options
+
+    * `:parallel` - if `true`, the dispatching is done in parallel
+      across all partitions. Defaults to `false`.
+
+  """
+  @doc since: "1.4.0"
+  @spec dispatch(registry, key, dispatcher, dispatch_opts) :: :ok
+        when dispatcher: (entries :: [{pid, value}] -> term) | {module(), atom(), [term()]}
+  def dispatch(registry, key, mfa_or_fun, opts \\ [])
+      when is_atom(registry) and is_function(mfa_or_fun, 1)
+      when is_atom(registry) and tuple_size(mfa_or_fun) == 3 do
+    case key_info!(registry) do
+      {:unique, partitions, key_ets} ->
+        (key_ets || key_ets!(registry, key, partitions))
+        |> safe_lookup_second(key)
+        |> List.wrap()
+        |> apply_non_empty_to_mfa_or_fun(mfa_or_fun)
+
+      {{:duplicate, _}, 1, key_ets} ->
+        key_ets
+        |> safe_lookup_second(key)
+        |> apply_non_empty_to_mfa_or_fun(mfa_or_fun)
+
+      {{:duplicate, _}, partitions, _} ->
+        if Keyword.get(opts, :parallel, false) do
+          registry
+          |> dispatch_parallel(key, mfa_or_fun, partitions)
+          |> Enum.each(&Task.await(&1, :infinity))
+        else
+          dispatch_serial(registry, key, mfa_or_fun, partitions)
+        end
+    end
+
+    :ok
+  end
+
+  defp dispatch_serial(_registry, _key, _mfa_or_fun, 0) do
+    :ok
+  end
+
+  defp dispatch_serial(registry, key, mfa_or_fun, partition) do
+    partition = partition - 1
+
+    registry
+    |> key_ets!(partition)
+    |> safe_lookup_second(key)
+    |> apply_non_empty_to_mfa_or_fun(mfa_or_fun)
+
+    dispatch_serial(registry, key, mfa_or_fun, partition)
+  end
+
+  defp dispatch_parallel(_registry, _key, _mfa_or_fun, 0) do
+    []
+  end
+
+  defp dispatch_parallel(registry, key, mfa_or_fun, partition) do
+    partition = partition - 1
+    parent = self()
+
+    task =
+      Task.async(fn ->
+        registry
+        |> key_ets!(partition)
+        |> safe_lookup_second(key)
+        |> apply_non_empty_to_mfa_or_fun(mfa_or_fun)
+
+        Process.unlink(parent)
+        :ok
+      end)
+
+    [task | dispatch_parallel(registry, key, mfa_or_fun, partition)]
+  end
+
+  defp apply_non_empty_to_mfa_or_fun([], _mfa_or_fun) do
+    :ok
+  end
+
+  defp apply_non_empty_to_mfa_or_fun(entries, {module, function, args}) do
+    apply(module, function, [entries | args])
+  end
+
+  defp apply_non_empty_to_mfa_or_fun(entries, fun) do
+    fun.(entries)
+  end
+
+  @doc """
+  Finds the `{pid, value}` pair for the given `key` in `registry` in no particular order.
+
+  An empty list if there is no match.
+
+  For unique registries, a single partition lookup is necessary. For
+  duplicate registries, all partitions must be looked up.
+
+  ## Examples
+
+  In the example below we register the current process and look it up
+  both from itself and other processes:
+
+      iex> Registry.start_link(keys: :unique, name: Registry.UniqueLookupTest)
+      iex> Registry.lookup(Registry.UniqueLookupTest, "hello")
+      []
+      iex> {:ok, _} = Registry.register(Registry.UniqueLookupTest, "hello", :world)
+      iex> Registry.lookup(Registry.UniqueLookupTest, "hello")
+      [{self(), :world}]
+      iex> Task.async(fn -> Registry.lookup(Registry.UniqueLookupTest, "hello") end) |> Task.await()
+      [{self(), :world}]
+
+  The same applies to duplicate registries:
+
+      iex> Registry.start_link(keys: :duplicate, name: Registry.DuplicateLookupTest)
+      iex> Registry.lookup(Registry.DuplicateLookupTest, "hello")
+      []
+      iex> {:ok, _} = Registry.register(Registry.DuplicateLookupTest, "hello", :world)
+      iex> Registry.lookup(Registry.DuplicateLookupTest, "hello")
+      [{self(), :world}]
+      iex> {:ok, _} = Registry.register(Registry.DuplicateLookupTest, "hello", :another)
+      iex> Enum.sort(Registry.lookup(Registry.DuplicateLookupTest, "hello"))
+      [{self(), :another}, {self(), :world}]
+
+  """
+  @doc since: "1.4.0"
+  @spec lookup(registry, key) :: [{pid, value}]
+  def lookup(registry, key) when is_atom(registry) do
+    case key_info!(registry) do
+      {:unique, partitions, key_ets} ->
+        key_ets = key_ets || key_ets!(registry, key, partitions)
+
+        case safe_lookup_second(key_ets, key) do
+          {_, _} = pair ->
+            [pair]
+
+          _ ->
+            []
+        end
+
+      {{:duplicate, _}, 1, key_ets} ->
+        safe_lookup_second(key_ets, key)
+
+      {{:duplicate, :key}, partitions, _key_ets} ->
+        partition = hash(key, partitions)
+        safe_lookup_second(key_ets!(registry, partition), key)
+
+      {{:duplicate, :pid}, partitions, _key_ets} ->
+        for partition <- 0..(partitions - 1),
+            pair <- safe_lookup_second(key_ets!(registry, partition), key),
+            do: pair
+    end
+  end
+
+  @doc """
+  Out-of-band locking of the given `lock_key` for the duration of `function`.
+
+  Only one function can execute under the same `lock_key` at a given
+  time. The given function always runs in the caller process.
+
+  The `lock_key` has its own namespace and therefore does not clash or
+  overlap with the regular registry keys. In other words, locking works
+  out-of-band from the regular Registry operations. See the "Use cases"
+  section below.
+
+  Locking behaves the same regardless of the registry type.
+
+  ## Use cases
+
+  The Registry is safe and concurrent out-of-the-box. You are not required
+  to use this function when interacting with the Registry. Furthermore,
+  `Registry` with `:unique` keys can already act as a process-lock for any
+  given key. For example, you can ensure only one process runs at a given
+  time for a given `:key` by doing:
+
+      name = {:via, Registry, {MyApp.Registry, :key, :value}}
+
+      # Do not attempt to start if we are already running
+      if pid = GenServer.whereis(name) do
+        pid
+      else
+        case GenServer.start_link(__MODULE__, :ok, name: name) do
+          {:ok, pid} -> pid
+          {:error, {:already_started, pid}} -> pid
+        end
+      end
+
+  Process locking gives you plenty of flexibility and fault isolation and
+  is enough for most cases.
+
+  This function is useful only when spawning processes is not an option,
+  for example, when copying the data to another process could be too
+  expensive. Or when the work must be done within the current process
+  for other reasons. In such cases, this function provides a scalable
+  mechanism for managing locks on top of the registry's infrastructure.
+
+  ## Examples
+
+      iex> Registry.start_link(keys: :unique, name: Registry.LockTest)
+      iex> Registry.lock(Registry.LockTest, :hello, fn -> :ok end)
+      :ok
+      iex> Registry.lock(Registry.LockTest, :world, fn -> self() end)
+      self()
+
+  """
+  @doc since: "1.18.0"
+  def lock(registry, lock_key, function)
+      when is_atom(registry) and is_function(function, 0) do
+    {_kind, partitions, _, pid_ets, _} = info!(registry)
+    {pid_server, _pid_ets} = pid_ets || pid_ets!(registry, lock_key, partitions)
+    Registry.Partition.lock(pid_server, lock_key, function)
+  end
+
+  @doc """
+  Returns `{pid, value}` pairs under the given `key` in `registry` that match `pattern`.
+
+  Pattern must be an atom or a tuple that will match the structure of the
+  value stored in the registry. The atom `:_` can be used to ignore a given
+  value or tuple element, while the atom `:"$1"` can be used to temporarily assign part
+  of pattern to a variable for a subsequent comparison.
+
+  Optionally, it is possible to pass a list of guard conditions for more precise matching.
+  Each guard is a tuple, which describes checks that should be passed by assigned part of pattern.
+  For example the `$1 > 1` guard condition would be expressed as the `{:>, :"$1", 1}` tuple.
+  Please note that guard conditions will work only for assigned
+  variables like `:"$1"`, `:"$2"`, and so forth.
+  Avoid usage of special match variables `:"$_"` and `:"$$"`, because it might not work as expected.
+
+  An empty list will be returned if there is no match.
+
+  For unique registries, a single partition lookup is necessary. For
+  duplicate registries, all partitions must be looked up.
+
+  ## Examples
+
+  In the example below we register the current process under the same
+  key in a duplicate registry but with different values:
+
+      iex> Registry.start_link(keys: :duplicate, name: Registry.MatchTest)
+      iex> {:ok, _} = Registry.register(Registry.MatchTest, "hello", {1, :atom, 1})
+      iex> {:ok, _} = Registry.register(Registry.MatchTest, "hello", {2, :atom, 2})
+      iex> Registry.match(Registry.MatchTest, "hello", {1, :_, :_})
+      [{self(), {1, :atom, 1}}]
+      iex> Registry.match(Registry.MatchTest, "hello", {2, :_, :_})
+      [{self(), {2, :atom, 2}}]
+      iex> Registry.match(Registry.MatchTest, "hello", {:_, :atom, :_}) |> Enum.sort()
+      [{self(), {1, :atom, 1}}, {self(), {2, :atom, 2}}]
+      iex> Registry.match(Registry.MatchTest, "hello", {:"$1", :_, :"$1"}) |> Enum.sort()
+      [{self(), {1, :atom, 1}}, {self(), {2, :atom, 2}}]
+      iex> guards = [{:>, :"$1", 1}]
+      iex> Registry.match(Registry.MatchTest, "hello", {:_, :_, :"$1"}, guards)
+      [{self(), {2, :atom, 2}}]
+      iex> guards = [{:is_atom, :"$1"}]
+      iex> Registry.match(Registry.MatchTest, "hello", {:_, :"$1", :_}, guards) |> Enum.sort()
+      [{self(), {1, :atom, 1}}, {self(), {2, :atom, 2}}]
+
+  """
+  @doc since: "1.4.0"
+  @spec match(registry, key, match_pattern, guards) :: [{pid, term}]
+  def match(registry, key, pattern, guards \\ []) when is_atom(registry) and is_list(guards) do
+    guards = [{:"=:=", {:element, 1, :"$_"}, {:const, key}} | guards]
+    spec = [{{:_, {:_, pattern}}, guards, [{:element, 2, :"$_"}]}]
+
+    case key_info!(registry) do
+      {:unique, partitions, key_ets} ->
+        key_ets = key_ets || key_ets!(registry, key, partitions)
+        :ets.select(key_ets, spec)
+
+      {{:duplicate, _}, 1, key_ets} ->
+        :ets.select(key_ets, spec)
+
+      {{:duplicate, _}, partitions, _key_ets} ->
+        for partition <- 0..(partitions - 1),
+            pair <- :ets.select(key_ets!(registry, partition), spec),
+            do: pair
+    end
+  end
+
+  @doc """
+  Returns the known keys for the given `pid` in `registry` in no particular order.
+
+  If the registry is unique, the keys are unique. Otherwise
+  they may contain duplicates if the process was registered
+  under the same key multiple times. The list will be empty
+  if the process is dead or it has no keys in this registry.
+
+  ## Examples
+
+  Registering under a unique registry does not allow multiple entries:
+
+      iex> Registry.start_link(keys: :unique, name: Registry.UniqueKeysTest)
+      iex> Registry.keys(Registry.UniqueKeysTest, self())
+      []
+      iex> {:ok, _} = Registry.register(Registry.UniqueKeysTest, "hello", :world)
+      iex> Registry.register(Registry.UniqueKeysTest, "hello", :later) # registry is :unique
+      {:error, {:already_registered, self()}}
+      iex> Registry.keys(Registry.UniqueKeysTest, self())
+      ["hello"]
+
+  Such is possible for duplicate registries though:
+
+      iex> Registry.start_link(keys: :duplicate, name: Registry.DuplicateKeysTest)
+      iex> Registry.keys(Registry.DuplicateKeysTest, self())
+      []
+      iex> {:ok, _} = Registry.register(Registry.DuplicateKeysTest, "hello", :world)
+      iex> {:ok, _} = Registry.register(Registry.DuplicateKeysTest, "hello", :world)
+      iex> Registry.keys(Registry.DuplicateKeysTest, self())
+      ["hello", "hello"]
+
+  """
+  @doc since: "1.4.0"
+  @spec keys(registry, pid) :: [key]
+  def keys(registry, pid) when is_atom(registry) and is_pid(pid) do
+    {kind, partitions, _, pid_ets, _} = info!(registry)
+
+    pid_etses =
+      if pid_ets do
+        {_, pid_ets} = pid_ets
+        [pid_ets]
+      else
+        case kind do
+          {:duplicate, :key} ->
+            for partition <- 0..(partitions - 1) do
+              {_, pid_ets} = pid_ets!(registry, partition)
+              pid_ets
+            end
+
+          _ ->
+            {_, pid_ets} = pid_ets!(registry, pid, partitions)
+            [pid_ets]
+        end
+      end
+
+    keys =
+      Enum.flat_map(pid_etses, fn pid_ets ->
+        try do
+          spec = [{{pid, :"$1", :"$2", :_}, [], [{{:"$1", :"$2"}}]}]
+          :ets.select(pid_ets, spec)
+        catch
+          :error, :badarg -> []
+        end
+      end)
+
+    # Handle the possibility of fake keys
+    keys = gather_keys(keys, [], false)
+
+    cond do
+      kind == :unique -> Enum.uniq(keys)
+      true -> keys
+    end
+  end
+
+  defp gather_keys([{key, {_, remaining}} | rest], acc, _fake) do
+    gather_keys(rest, [key | acc], {key, remaining})
+  end
+
+  defp gather_keys([{key, _} | rest], acc, fake) do
+    gather_keys(rest, [key | acc], fake)
+  end
+
+  defp gather_keys([], acc, {key, remaining}) do
+    List.duplicate(key, remaining) ++ Enum.reject(acc, &(&1 === key))
+  end
+
+  defp gather_keys([], acc, false) do
+    acc
+  end
+
+  @doc """
+  Reads the values for the given `key` for `pid` in `registry`.
+
+  For unique registries, it is either an empty list or a list
+  with a single element. For duplicate registries, it is a list
+  with zero, one, or multiple elements.
+
+  ## Examples
+
+  In the example below we register the current process and look it up
+  both from itself and other processes:
+
+      iex> Registry.start_link(keys: :unique, name: Registry.UniqueValuesTest)
+      iex> Registry.values(Registry.UniqueValuesTest, "hello", self())
+      []
+      iex> {:ok, _} = Registry.register(Registry.UniqueValuesTest, "hello", :world)
+      iex> Registry.values(Registry.UniqueValuesTest, "hello", self())
+      [:world]
+      iex> Task.async(fn -> Registry.values(Registry.UniqueValuesTest, "hello", self()) end) |> Task.await()
+      []
+      iex> parent = self()
+      iex> Task.async(fn -> Registry.values(Registry.UniqueValuesTest, "hello", parent) end) |> Task.await()
+      [:world]
+
+  The same applies to duplicate registries:
+
+      iex> Registry.start_link(keys: :duplicate, name: Registry.DuplicateValuesTest)
+      iex> Registry.values(Registry.DuplicateValuesTest, "hello", self())
+      []
+      iex> {:ok, _} = Registry.register(Registry.DuplicateValuesTest, "hello", :world)
+      iex> Registry.values(Registry.DuplicateValuesTest, "hello", self())
+      [:world]
+      iex> {:ok, _} = Registry.register(Registry.DuplicateValuesTest, "hello", :another)
+      iex> Enum.sort(Registry.values(Registry.DuplicateValuesTest, "hello", self()))
+      [:another, :world]
+
+  """
+  @doc since: "1.12.0"
+  @spec values(registry, key, pid) :: [value]
+  def values(registry, key, pid) when is_atom(registry) do
+    case key_info!(registry) do
+      {:unique, partitions, key_ets} ->
+        key_ets = key_ets || key_ets!(registry, key, partitions)
+
+        case safe_lookup_second(key_ets, key) do
+          {^pid, value} ->
+            [value]
+
+          _ ->
+            []
+        end
+
+      {{:duplicate, _}, 1, key_ets} ->
+        for {^pid, value} <- safe_lookup_second(key_ets, key), do: value
+
+      {{:duplicate, :key}, partitions, _key_ets} ->
+        partition = hash(key, partitions)
+        key_ets = key_ets!(registry, partition)
+        for {^pid, value} <- safe_lookup_second(key_ets, key), do: value
+
+      {{:duplicate, :pid}, partitions, _key_ets} ->
+        partition = hash(pid, partitions)
+        key_ets = key_ets!(registry, partition)
+        for {^pid, value} <- safe_lookup_second(key_ets, key), do: value
+    end
+  end
+
+  @doc """
+  Unregisters all entries for the given `key` associated to the current
+  process in `registry`.
+
+  Always returns `:ok` and automatically unlinks the current process from
+  the owner if there are no more keys associated to the current process. See
+  also `register/3` to read more about the "owner".
+
+  If the registry has listeners specified via the `:listeners` option in `start_link/1`,
+  those listeners will be notified of the unregistration and will receive a
+  message of type `t:listener_message/0`.
+
+  ## Examples
+
+  For unique registries:
+
+      iex> Registry.start_link(keys: :unique, name: Registry.UniqueUnregisterTest)
+      iex> Registry.register(Registry.UniqueUnregisterTest, "hello", :world)
+      iex> Registry.keys(Registry.UniqueUnregisterTest, self())
+      ["hello"]
+      iex> Registry.unregister(Registry.UniqueUnregisterTest, "hello")
+      :ok
+      iex> Registry.keys(Registry.UniqueUnregisterTest, self())
+      []
+
+  For duplicate registries:
+
+      iex> Registry.start_link(keys: :duplicate, name: Registry.DuplicateUnregisterTest)
+      iex> Registry.register(Registry.DuplicateUnregisterTest, "hello", :world)
+      iex> Registry.register(Registry.DuplicateUnregisterTest, "hello", :world)
+      iex> Registry.keys(Registry.DuplicateUnregisterTest, self())
+      ["hello", "hello"]
+      iex> Registry.unregister(Registry.DuplicateUnregisterTest, "hello")
+      :ok
+      iex> Registry.keys(Registry.DuplicateUnregisterTest, self())
+      []
+
+  """
+  @doc since: "1.4.0"
+  @spec unregister(registry, key) :: :ok
+  def unregister(registry, key) when is_atom(registry) do
+    self = self()
+    {kind, partitions, key_ets, pid_ets, listeners} = info!(registry)
+    {key_partition, pid_partition} = partitions(kind, key, self, partitions)
+    key_ets = key_ets || key_ets!(registry, key_partition)
+    {pid_server, pid_ets} = pid_ets || pid_ets!(registry, pid_partition)
+
+    # Remove first from the key_ets because in case of crashes
+    # the pid_ets will still be able to clean up. The last step is
+    # to clean if we have no more entries.
+    true = __unregister__(key_ets, {key, {self, :_}}, 1)
+    true = __unregister__(pid_ets, {self, key, key_ets, :_}, 2)
+
+    unlink_if_unregistered(pid_server, pid_ets, self)
+
+    for listener <- listeners do
+      Kernel.send(listener, {:unregister, registry, key, self})
+    end
+
+    :ok
+  end
+
+  @doc """
+  Unregisters entries for keys matching a pattern associated to the current
+  process in `registry`.
+
+  ## Examples
+
+  For unique registries it can be used to conditionally unregister a key on
+  the basis of whether or not it matches a particular value.
+
+      iex> Registry.start_link(keys: :unique, name: Registry.UniqueUnregisterMatchTest)
+      iex> Registry.register(Registry.UniqueUnregisterMatchTest, "hello", :world)
+      iex> Registry.keys(Registry.UniqueUnregisterMatchTest, self())
+      ["hello"]
+      iex> Registry.unregister_match(Registry.UniqueUnregisterMatchTest, "hello", :foo)
+      :ok
+      iex> Registry.keys(Registry.UniqueUnregisterMatchTest, self())
+      ["hello"]
+      iex> Registry.unregister_match(Registry.UniqueUnregisterMatchTest, "hello", :world)
+      :ok
+      iex> Registry.keys(Registry.UniqueUnregisterMatchTest, self())
+      []
+
+  For duplicate registries:
+
+      iex> Registry.start_link(keys: :duplicate, name: Registry.DuplicateUnregisterMatchTest)
+      iex> Registry.register(Registry.DuplicateUnregisterMatchTest, "hello", :world_a)
+      iex> Registry.register(Registry.DuplicateUnregisterMatchTest, "hello", :world_b)
+      iex> Registry.register(Registry.DuplicateUnregisterMatchTest, "hello", :world_c)
+      iex> Registry.keys(Registry.DuplicateUnregisterMatchTest, self())
+      ["hello", "hello", "hello"]
+      iex> Registry.unregister_match(Registry.DuplicateUnregisterMatchTest, "hello", :world_a)
+      :ok
+      iex> Registry.keys(Registry.DuplicateUnregisterMatchTest, self())
+      ["hello", "hello"]
+      iex> Registry.lookup(Registry.DuplicateUnregisterMatchTest, "hello")
+      [{self(), :world_b}, {self(), :world_c}]
+
+  """
+  @doc since: "1.5.0"
+  @spec unregister_match(registry, key, match_pattern, guards) :: :ok
+  def unregister_match(registry, key, pattern, guards \\ []) when is_list(guards) do
+    self = self()
+
+    {kind, partitions, key_ets, pid_ets, listeners} = info!(registry)
+    {key_partition, pid_partition} = partitions(kind, key, self, partitions)
+    key_ets = key_ets || key_ets!(registry, key_partition)
+    {pid_server, pid_ets} = pid_ets || pid_ets!(registry, pid_partition)
+
+    # Remove first from the key_ets because in case of crashes
+    # the pid_ets will still be able to clean up. The last step is
+    # to clean if we have no more entries.
+
+    # Here we want to count all entries for this pid under this key, regardless of pattern.
+    underscore_guard = {:"=:=", {:element, 1, :"$_"}, {:const, key}}
+    total_spec = [{{:_, {self, :_}}, [underscore_guard], [true]}]
+    total = :ets.select_count(key_ets, total_spec)
+
+    # We only want to delete things that match the pattern
+    delete_spec = [{{:_, {self, pattern}}, [underscore_guard | guards], [true]}]
+
+    case :ets.select_delete(key_ets, delete_spec) do
+      # We deleted everything, we can just delete the object
+      ^total ->
+        true = __unregister__(pid_ets, {self, key, key_ets, :_}, 2)
+        unlink_if_unregistered(pid_server, pid_ets, self)
+
+        for listener <- listeners do
+          Kernel.send(listener, {:unregister, registry, key, self})
+        end
+
+      0 ->
+        :ok
+
+      deleted ->
+        # There are still entries remaining for this pid. delete_object/2 with
+        # duplicate_bag tables will remove every entry, but we only want to
+        # remove those we have deleted. The solution is to introduce a temp_entry
+        # that indicates how many keys WILL be remaining after the delete operation.
+        counter = System.unique_integer()
+        remaining = total - deleted
+        temp_entry = {self, key, {key_ets, remaining}, counter}
+        true = :ets.insert(pid_ets, temp_entry)
+        true = __unregister__(pid_ets, {self, key, key_ets, :_}, 2)
+        real_keys = List.duplicate({self, key, key_ets, counter}, remaining)
+        true = :ets.insert(pid_ets, real_keys)
+        # We've recreated the real remaining key entries, so we can now delete
+        # our temporary entry.
+        true = :ets.delete_object(pid_ets, temp_entry)
+    end
+
+    :ok
+  end
+
+  @doc """
+  Registers the current process under the given `key` in `registry`.
+
+  A value to be associated with this registration must also be given.
+  This value will be retrieved whenever dispatching or doing a key
+  lookup.
+
+  This function returns `{:ok, owner}` or `{:error, reason}`.
+  The `owner` is the PID in the registry partition responsible for
+  the PID. The owner is automatically linked to the caller.
+
+  If the registry has unique keys, it will return `{:ok, owner}` unless
+  the key is already associated to a PID, in which case it returns
+  `{:error, {:already_registered, pid}}`.
+
+  If the registry has duplicate keys, multiple registrations from the
+  current process under the same key are allowed.
+
+  If the registry has listeners specified via the `:listeners` option in `start_link/1`,
+  those listeners will be notified of the registration and will receive a
+  message of type `t:listener_message/0`.
+
+  ## Examples
+
+  Registering under a unique registry does not allow multiple entries:
+
+      iex> Registry.start_link(keys: :unique, name: Registry.UniqueRegisterTest)
+      iex> {:ok, _} = Registry.register(Registry.UniqueRegisterTest, "hello", :world)
+      iex> Registry.register(Registry.UniqueRegisterTest, "hello", :later)
+      {:error, {:already_registered, self()}}
+      iex> Registry.keys(Registry.UniqueRegisterTest, self())
+      ["hello"]
+
+  Such is possible for duplicate registries though:
+
+      iex> Registry.start_link(keys: :duplicate, name: Registry.DuplicateRegisterTest)
+      iex> {:ok, _} = Registry.register(Registry.DuplicateRegisterTest, "hello", :world)
+      iex> {:ok, _} = Registry.register(Registry.DuplicateRegisterTest, "hello", :world)
+      iex> Registry.keys(Registry.DuplicateRegisterTest, self())
+      ["hello", "hello"]
+
+  """
+  @doc since: "1.4.0"
+  @spec register(registry, key, value) :: {:ok, pid} | {:error, {:already_registered, pid}}
+  def register(registry, key, value) when is_atom(registry) do
+    self = self()
+    {kind, partitions, key_ets, pid_ets, listeners} = info!(registry)
+    {key_partition, pid_partition} = partitions(kind, key, self, partitions)
+    key_ets = key_ets || key_ets!(registry, key_partition)
+    {pid_server, pid_ets} = pid_ets || pid_ets!(registry, pid_partition)
+
+    # Note that we write first to the pid_ets table because it will
+    # always be able to do the cleanup. If we register first to the
+    # key one and the process crashes, the key will stay there forever.
+    Process.link(pid_server)
+
+    counter = System.unique_integer()
+    true = :ets.insert(pid_ets, {self, key, key_ets, counter})
+
+    case register_key(kind, key_ets, key, {key, {self, value}}) do
+      :ok ->
+        for listener <- listeners do
+          Kernel.send(listener, {:register, registry, key, self, value})
+        end
+
+        {:ok, pid_server}
+
+      {:error, {:already_registered, ^self}} = error ->
+        true = :ets.delete_object(pid_ets, {self, key, key_ets, counter})
+        error
+
+      {:error, _} = error ->
+        true = :ets.delete_object(pid_ets, {self, key, key_ets, counter})
+        unlink_if_unregistered(pid_server, pid_ets, self)
+        error
+    end
+  end
+
+  defp register_key({:duplicate, _}, key_ets, _key, entry) do
+    true = :ets.insert(key_ets, entry)
+    :ok
+  end
+
+  defp register_key(:unique, key_ets, key, entry) do
+    if :ets.insert_new(key_ets, entry) do
+      :ok
+    else
+      # Note that we have to call register_key recursively
+      # because we are always at odds of a race condition.
+      case :ets.lookup(key_ets, key) do
+        [{^key, {pid, _}} = current] ->
+          if Process.alive?(pid) do
+            {:error, {:already_registered, pid}}
+          else
+            :ets.delete_object(key_ets, current)
+            register_key(:unique, key_ets, key, entry)
+          end
+
+        [] ->
+          register_key(:unique, key_ets, key, entry)
+      end
+    end
+  end
+
+  @doc """
+  Reads registry metadata given on `start_link/1`.
+
+  Atoms and tuples are allowed as keys.
+
+  ## Examples
+
+      iex> Registry.start_link(keys: :unique, name: Registry.MetaTest, meta: [custom_key: "custom_value"])
+      iex> Registry.meta(Registry.MetaTest, :custom_key)
+      {:ok, "custom_value"}
+      iex> Registry.meta(Registry.MetaTest, :unknown_key)
+      :error
+
+  """
+  @doc since: "1.4.0"
+  @spec meta(registry, meta_key) :: {:ok, meta_value} | :error
+  def meta(registry, key) when is_atom(registry) and (is_atom(key) or is_tuple(key)) do
+    try do
+      :ets.lookup(registry, key)
+    catch
+      :error, :badarg ->
+        raise ArgumentError,
+              "unknown registry: #{inspect(registry)}. Either the registry name is invalid or " <>
+                "the registry is not running, possibly because its application isn't started"
+    else
+      [{^key, value}] -> {:ok, value}
+      _ -> :error
+    end
+  end
+
+  @doc """
+  Stores registry metadata.
+
+  Atoms and tuples are allowed as keys.
+
+  ## Examples
+
+      iex> Registry.start_link(keys: :unique, name: Registry.PutMetaTest)
+      iex> Registry.put_meta(Registry.PutMetaTest, :custom_key, "custom_value")
+      :ok
+      iex> Registry.meta(Registry.PutMetaTest, :custom_key)
+      {:ok, "custom_value"}
+      iex> Registry.put_meta(Registry.PutMetaTest, {:tuple, :key}, "tuple_value")
+      :ok
+      iex> Registry.meta(Registry.PutMetaTest, {:tuple, :key})
+      {:ok, "tuple_value"}
+
+  """
+  @doc since: "1.4.0"
+  @spec put_meta(registry, meta_key, meta_value) :: :ok
+  def put_meta(registry, key, value) when is_atom(registry) and (is_atom(key) or is_tuple(key)) do
+    try do
+      :ets.insert(registry, {key, value})
+      :ok
+    catch
+      :error, :badarg ->
+        raise ArgumentError, "unknown registry: #{inspect(registry)}"
+    end
+  end
+
+  @doc """
+  Deletes registry metadata for the given `key` in `registry`.
+
+  ## Examples
+
+      iex> Registry.start_link(keys: :unique, name: Registry.DeleteMetaTest)
+      iex> Registry.put_meta(Registry.DeleteMetaTest, :custom_key, "custom_value")
+      :ok
+      iex> Registry.meta(Registry.DeleteMetaTest, :custom_key)
+      {:ok, "custom_value"}
+      iex> Registry.delete_meta(Registry.DeleteMetaTest, :custom_key)
+      :ok
+      iex> Registry.meta(Registry.DeleteMetaTest, :custom_key)
+      :error
+
+  """
+  @doc since: "1.11.0"
+  @spec delete_meta(registry, meta_key) :: :ok
+  def delete_meta(registry, key) when is_atom(registry) and (is_atom(key) or is_tuple(key)) do
+    try do
+      :ets.delete(registry, key)
+      :ok
+    catch
+      :error, :badarg ->
+        raise ArgumentError, "unknown registry: #{inspect(registry)}"
+    end
+  end
+
+  @doc """
+  Returns the number of registered keys in a registry.
+  It runs in constant time.
+
+  ## Examples
+  In the example below we register the current process and ask for the
+  number of keys in the registry:
+
+      iex> Registry.start_link(keys: :unique, name: Registry.UniqueCountTest)
+      iex> Registry.count(Registry.UniqueCountTest)
+      0
+      iex> {:ok, _} = Registry.register(Registry.UniqueCountTest, "hello", :world)
+      iex> {:ok, _} = Registry.register(Registry.UniqueCountTest, "world", :world)
+      iex> Registry.count(Registry.UniqueCountTest)
+      2
+
+  The same applies to duplicate registries:
+
+      iex> Registry.start_link(keys: :duplicate, name: Registry.DuplicateCountTest)
+      iex> Registry.count(Registry.DuplicateCountTest)
+      0
+      iex> {:ok, _} = Registry.register(Registry.DuplicateCountTest, "hello", :world)
+      iex> {:ok, _} = Registry.register(Registry.DuplicateCountTest, "hello", :world)
+      iex> Registry.count(Registry.DuplicateCountTest)
+      2
+
+  """
+  @doc since: "1.7.0"
+  @spec count(registry) :: non_neg_integer()
+  def count(registry) when is_atom(registry) do
+    case key_info!(registry) do
+      {_kind, partitions, nil} ->
+        Enum.sum_by(0..(partitions - 1), fn partition_index ->
+          safe_size(key_ets!(registry, partition_index))
+        end)
+
+      {_kind, 1, key_ets} ->
+        safe_size(key_ets)
+    end
+  end
+
+  defp safe_size(ets) do
+    try do
+      :ets.info(ets, :size)
+    catch
+      :error, :badarg -> 0
+    end
+  end
+
+  @doc """
+  Returns the number of `{pid, value}` pairs under the given `key` in `registry`
+  that match `pattern`.
+
+  Pattern must be an atom or a tuple that will match the structure of the
+  value stored in the registry. The atom `:_` can be used to ignore a given
+  value or tuple element, while the atom `:"$1"` can be used to temporarily assign part
+  of pattern to a variable for a subsequent comparison.
+
+  Optionally, it is possible to pass a list of guard conditions for more precise matching.
+  Each guard is a tuple, which describes checks that should be passed by assigned part of pattern.
+  For example the `$1 > 1` guard condition would be expressed as the `{:>, :"$1", 1}` tuple.
+  Please note that guard conditions will work only for assigned
+  variables like `:"$1"`, `:"$2"`, and so forth.
+  Avoid usage of special match variables `:"$_"` and `:"$$"`, because it might not work as expected.
+
+  Zero will be returned if there is no match.
+
+  For unique registries, a single partition lookup is necessary. For
+  duplicate registries, all partitions must be looked up.
+
+  ## Examples
+
+  In the example below we register the current process under the same
+  key in a duplicate registry but with different values:
+
+      iex> Registry.start_link(keys: :duplicate, name: Registry.CountMatchTest)
+      iex> {:ok, _} = Registry.register(Registry.CountMatchTest, "hello", {1, :atom, 1})
+      iex> {:ok, _} = Registry.register(Registry.CountMatchTest, "hello", {2, :atom, 2})
+      iex> Registry.count_match(Registry.CountMatchTest, "hello", {1, :_, :_})
+      1
+      iex> Registry.count_match(Registry.CountMatchTest, "hello", {2, :_, :_})
+      1
+      iex> Registry.count_match(Registry.CountMatchTest, "hello", {:_, :atom, :_})
+      2
+      iex> Registry.count_match(Registry.CountMatchTest, "hello", {:"$1", :_, :"$1"})
+      2
+      iex> Registry.count_match(Registry.CountMatchTest, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 1}])
+      1
+      iex> Registry.count_match(Registry.CountMatchTest, "hello", {:_, :"$1", :_}, [{:is_atom, :"$1"}])
+      2
+
+  """
+  @doc since: "1.7.0"
+  @spec count_match(registry, key, match_pattern, guards) :: non_neg_integer()
+  def count_match(registry, key, pattern, guards \\ [])
+      when is_atom(registry) and is_list(guards) do
+    guards = [{:"=:=", {:element, 1, :"$_"}, {:const, key}} | guards]
+    spec = [{{:_, {:_, pattern}}, guards, [true]}]
+
+    case key_info!(registry) do
+      {:unique, partitions, key_ets} ->
+        key_ets = key_ets || key_ets!(registry, key, partitions)
+        :ets.select_count(key_ets, spec)
+
+      {{:duplicate, _}, 1, key_ets} ->
+        :ets.select_count(key_ets, spec)
+
+      {{:duplicate, _}, partitions, _key_ets} ->
+        Enum.sum_by(0..(partitions - 1), fn partition_index ->
+          :ets.select_count(key_ets!(registry, partition_index), spec)
+        end)
+    end
+  end
+
+  @doc """
+  Select key, pid, and values registered using full match specs.
+
+  The `spec` consists of a list of three part tuples, in the shape of `[{match_pattern, guards, body}]`.
+
+  The first part, the match pattern, must be a tuple that will match the structure of the
+  the data stored in the registry, which is `{key, pid, value}`. The atom `:_` can be used to
+  ignore a given value or tuple element, while the atom `:"$1"` can be used to temporarily
+  assign part of pattern to a variable for a subsequent comparison. This can be combined
+  like `{:"$1", :_, :_}`.
+
+  The second part, the guards, is a list of conditions that allow filtering the results.
+  Each guard is a tuple, which describes checks that should be passed by assigned part of pattern.
+  For example the `$1 > 1` guard condition would be expressed as the `{:>, :"$1", 1}` tuple.
+  Please note that guard conditions will work only for assigned
+  variables like `:"$1"`, `:"$2"`, and so forth.
+
+  The third part, the body, is a list of shapes of the returned entries. Like guards, you have access to
+  assigned variables like `:"$1"`, which you can combine with hard-coded values to freely shape entries
+  Note that tuples have to be wrapped in an additional tuple. To get a result format like
+  `%{key: key, pid: pid, value: value}`, assuming you bound those variables in order in the match part,
+  you would provide a body like `[%{key: :"$1", pid: :"$2", value: :"$3"}]`. Like guards, you can use
+  some operations like `:element` to modify the output format.
+
+  Do not use special match variables `:"$_"` and `:"$$"`, because they might not work as expected.
+
+  Note that for large registries with many partitions this will be costly as it builds the result by
+  concatenating all the partitions.
+
+  ## Examples
+
+  This example shows how to get everything from the registry:
+
+      iex> Registry.start_link(keys: :unique, name: Registry.SelectAllTest)
+      iex> {:ok, _} = Registry.register(Registry.SelectAllTest, "hello", :value)
+      iex> {:ok, _} = Registry.register(Registry.SelectAllTest, "world", :value)
+      iex> Registry.select(Registry.SelectAllTest, [{{:"$1", :"$2", :"$3"}, [], [{{:"$1", :"$2", :"$3"}}]}]) |> Enum.sort()
+      [{"hello", self(), :value}, {"world", self(), :value}]
+
+  If you want to get keys, you can pass a separate selector:
+
+      iex> Registry.start_link(keys: :unique, name: Registry.SelectKeysTest)
+      iex> {:ok, _} = Registry.register(Registry.SelectKeysTest, "hello", :value)
+      iex> {:ok, _} = Registry.register(Registry.SelectKeysTest, "world", :value)
+      iex> Registry.select(Registry.SelectKeysTest, [{{:"$1", :_, :_}, [], [:"$1"]}]) |> Enum.sort()
+      ["hello", "world"]
+
+  """
+  @doc since: "1.9.0"
+  @spec select(registry, spec) :: [term]
+  def select(registry, spec)
+      when is_atom(registry) and is_list(spec) do
+    spec = group_match_headers(spec, __ENV__.function)
+
+    case key_info!(registry) do
+      {_kind, partitions, nil} ->
+        Enum.flat_map(0..(partitions - 1), fn partition_index ->
+          :ets.select(key_ets!(registry, partition_index), spec)
+        end)
+
+      {_kind, 1, key_ets} ->
+        :ets.select(key_ets, spec)
+    end
+  end
+
+  @doc """
+  Works like `select/2`, but only returns the number of matching records.
+
+  ## Examples
+
+  In the example below we register the current process under different
+  keys in a unique registry but with the same value:
+
+      iex> Registry.start_link(keys: :unique, name: Registry.CountSelectTest)
+      iex> {:ok, _} = Registry.register(Registry.CountSelectTest, "hello", :value)
+      iex> {:ok, _} = Registry.register(Registry.CountSelectTest, "world", :value)
+      iex> Registry.count_select(Registry.CountSelectTest, [{{:_, :_, :value}, [], [true]}])
+      2
+  """
+  @doc since: "1.14.0"
+  @spec count_select(registry, spec) :: non_neg_integer()
+  def count_select(registry, spec)
+      when is_atom(registry) and is_list(spec) do
+    spec = group_match_headers(spec, __ENV__.function)
+
+    case key_info!(registry) do
+      {_kind, partitions, nil} ->
+        Enum.sum_by(0..(partitions - 1), fn partition_index ->
+          :ets.select_count(key_ets!(registry, partition_index), spec)
+        end)
+
+      {_kind, 1, key_ets} ->
+        :ets.select_count(key_ets, spec)
+    end
+  end
+
+  defp group_match_headers(spec, {fun, arity}) do
+    for part <- spec do
+      case part do
+        {{key, pid, value}, guards, select} ->
+          {{key, {pid, value}}, guards, select}
+
+        _ ->
+          raise ArgumentError,
+                "invalid match specification in Registry.#{fun}/#{arity}: #{inspect(spec)}"
+      end
+    end
+  end
+
+  ## Helpers
+
+  @compile {:inline, hash: 2}
+
+  defp hash(term, limit) do
+    :erlang.phash2(term, limit)
+  end
+
+  defp info!(registry) do
+    try do
+      :ets.lookup_element(registry, @all_info, 2)
+    catch
+      :error, :badarg ->
+        raise ArgumentError, "unknown registry: #{inspect(registry)}"
+    end
+  end
+
+  defp key_info!(registry) do
+    try do
+      :ets.lookup_element(registry, @key_info, 2)
+    catch
+      :error, :badarg ->
+        raise ArgumentError, "unknown registry: #{inspect(registry)}"
+    end
+  end
+
+  defp key_ets!(registry, key, partitions) do
+    :ets.lookup_element(registry, hash(key, partitions), 2)
+  end
+
+  defp key_ets!(registry, partition) do
+    :ets.lookup_element(registry, partition, 2)
+  end
+
+  defp pid_ets!(registry, key, partitions) do
+    :ets.lookup_element(registry, hash(key, partitions), 3)
+  end
+
+  defp pid_ets!(registry, partition) do
+    :ets.lookup_element(registry, partition, 3)
+  end
+
+  defp safe_lookup_second(ets, key) do
+    try do
+      :ets.lookup_element(ets, key, 2)
+    catch
+      :error, :badarg -> []
+    end
+  end
+
+  defp partitions(:unique, key, pid, partitions) do
+    {hash(key, partitions), hash(pid, partitions)}
+  end
+
+  defp partitions({:duplicate, :key}, key, _pid, partitions) do
+    partition = hash(key, partitions)
+    {partition, partition}
+  end
+
+  defp partitions({:duplicate, :pid}, _key, pid, partitions) do
+    partition = hash(pid, partitions)
+    {partition, partition}
+  end
+
+  defp unlink_if_unregistered(pid_server, pid_ets, self) do
+    if not :ets.member(pid_ets, self) do
+      Process.unlink(pid_server)
+    end
+  end
+
+  @doc false
+  def __unregister__(table, match, pos) do
+    key = :erlang.element(pos, match)
+
+    # We need to perform an element comparison if we have an special atom key.
+    if is_atom(key) and reserved_atom?(Atom.to_string(key)) do
+      match = :erlang.setelement(pos, match, :_)
+      guard = {:"=:=", {:element, pos, :"$_"}, {:const, key}}
+      :ets.select_delete(table, [{match, [guard], [true]}]) >= 0
+    else
+      :ets.match_delete(table, match)
+    end
+  end
+
+  defp reserved_atom?("_"), do: true
+  defp reserved_atom?("$" <> _), do: true
+  defp reserved_atom?(_), do: false
+end
+
+defmodule Registry.Supervisor do
+  @moduledoc false
+  use Supervisor
+
+  def start_link(kind, registry, partitions, listeners, entries, compressed) do
+    arg = {kind, registry, partitions, listeners, entries, compressed}
+    Supervisor.start_link(__MODULE__, arg, name: registry)
+  end
+
+  def init({kind, registry, partitions, listeners, entries, compressed}) do
+    ^registry = :ets.new(registry, [:set, :public, :named_table, read_concurrency: true])
+    true = :ets.insert(registry, entries)
+
+    children =
+      for i <- 0..(partitions - 1) do
+        key_partition = Registry.Partition.key_name(registry, i)
+        pid_partition = Registry.Partition.pid_name(registry, i)
+        arg = {kind, registry, i, partitions, key_partition, pid_partition, listeners, compressed}
+
+        %{
+          id: pid_partition,
+          start: {Registry.Partition, :start_link, [pid_partition, arg]}
+        }
+      end
+
+    Supervisor.init(children, strategy: strategy_for_kind(kind))
+  end
+
+  # Unique registries have their key partition hashed by key.
+  # This means that, if a PID partition crashes, it may have
+  # entries from all key partitions, so we need to crash all.
+  defp strategy_for_kind(:unique), do: :one_for_all
+
+  # Duplicate registries have both key and pid partitions hashed
+  # by key ({:duplicate, :key}) or pid ({:duplicate, :pid}).
+  # This means that, if a PID or key partition crashes, all of
+  # its associated entries are in its sibling table, so we crash one.
+  defp strategy_for_kind({:duplicate, _}), do: :one_for_one
+end
+
+defmodule Registry.Partition do
+  @moduledoc false
+
+  # This process owns the equivalent key and pid ETS tables
+  # and is responsible for linking to processes that map to
+  # its own pid table.
+  use GenServer
+  @all_info -1
+  @key_info -2
+
+  @doc """
+  Returns the name of key partition table.
+  """
+  @spec key_name(atom, non_neg_integer) :: atom
+  def key_name(registry, partition) do
+    Module.concat(registry, "KeyPartition" <> Integer.to_string(partition))
+  end
+
+  @doc """
+  Returns the name of pid partition table.
+  """
+  @spec pid_name(atom, non_neg_integer) :: atom
+  def pid_name(name, partition) do
+    Module.concat(name, "PIDPartition" <> Integer.to_string(partition))
+  end
+
+  @doc """
+  Starts the registry partition.
+
+  The process is only responsible for linking and cleaning up when processes crash.
+  """
+  def start_link(registry, arg) do
+    GenServer.start_link(__MODULE__, arg, name: registry)
+  end
+
+  @doc """
+  Runs function with a lock.
+  """
+  def lock(pid, key, lock) do
+    ref = GenServer.call(pid, {:lock, key})
+
+    try do
+      lock.()
+    after
+      send(pid, {:unlock, key, ref})
+    end
+  end
+
+  ## Callbacks
+
+  def init({kind, registry, i, partitions, key_partition, pid_partition, listeners, compressed}) do
+    Process.flag(:trap_exit, true)
+
+    key_ets = init_key_ets(kind, key_partition, compressed)
+    pid_ets = init_pid_ets(kind, pid_partition)
+
+    # If we have only one partition, we do an optimization which
+    # is to write the table information alongside the registry info.
+    if partitions == 1 do
+      entries = [
+        {@key_info, {kind, partitions, key_ets}},
+        {@all_info, {kind, partitions, key_ets, {self(), pid_ets}, listeners}}
+      ]
+
+      true = :ets.insert(registry, entries)
+    else
+      true = :ets.insert(registry, {i, key_ets, {self(), pid_ets}})
+    end
+
+    {:ok, {pid_ets, %{}}}
+  end
+
+  # The key partition is a set for unique keys,
+  # duplicate bag for duplicate ones.
+  defp init_key_ets(:unique, key_partition, compressed) do
+    opts = [:set, :public, read_concurrency: true, write_concurrency: true]
+    :ets.new(key_partition, compression_opt(opts, compressed))
+  end
+
+  defp init_key_ets({:duplicate, _}, key_partition, compressed) do
+    opts = [:duplicate_bag, :public, read_concurrency: true, write_concurrency: true]
+    :ets.new(key_partition, compression_opt(opts, compressed))
+  end
+
+  defp compression_opt(opts, compressed) do
+    if compressed, do: [:compressed] ++ opts, else: opts
+  end
+
+  # A process can always have multiple keys, so the
+  # pid partition is always a duplicate bag.
+  defp init_pid_ets(_, pid_partition) do
+    :ets.new(pid_partition, [
+      :duplicate_bag,
+      :public,
+      read_concurrency: true,
+      write_concurrency: true
+    ])
+  end
+
+  def handle_call(:sync, _, state) do
+    {:reply, :ok, state}
+  end
+
+  def handle_call({:lock, key}, from, {ets, lock}) do
+    lock =
+      case lock do
+        %{^key => queue} ->
+          Map.put(lock, key, :queue.in(from, queue))
+
+        %{} ->
+          go(from, key)
+          Map.put(lock, key, :queue.new())
+      end
+
+    {:noreply, {ets, lock}}
+  end
+
+  def handle_info({:EXIT, pid, _reason}, {ets, lock}) do
+    entries = :ets.take(ets, pid)
+
+    for {_pid, key, key_ets, _counter} <- entries do
+      key_ets =
+        case key_ets do
+          # In case the fake key_ets is being used. See unregister_match/2.
+          {key_ets, _} ->
+            key_ets
+
+          _ ->
+            key_ets
+        end
+
+      try do
+        Registry.__unregister__(key_ets, {key, {pid, :_}}, 1)
+      catch
+        :error, :badarg -> :badarg
+      end
+    end
+
+    {:noreply, {ets, lock}}
+  end
+
+  def handle_info({{:unlock, key}, _ref, :process, _pid, _reason}, state) do
+    unlock(key, state)
+  end
+
+  def handle_info({:unlock, key, ref}, state) do
+    Process.demonitor(ref, [:flush])
+    unlock(key, state)
+  end
+
+  defp unlock(key, {ets, lock}) do
+    %{^key => queue} = lock
+
+    lock =
+      case dequeue(queue, key) do
+        :empty -> Map.delete(lock, key)
+        {:not_empty, queue} -> Map.put(lock, key, queue)
+      end
+
+    {:noreply, {ets, lock}}
+  end
+
+  defp dequeue(queue, key) do
+    case :queue.out(queue) do
+      {:empty, _} ->
+        :empty
+
+      {{:value, {pid, _tag} = from}, queue} ->
+        if node(pid) != node() or Process.alive?(pid) do
+          go(from, key)
+          {:not_empty, queue}
+        else
+          dequeue(queue, key)
+        end
+    end
+  end
+
+  defp go({pid, _tag} = from, key) do
+    ref = Process.monitor(pid, tag: {:unlock, key})
+    GenServer.reply(from, ref)
+  end
+end
diff --git a/lib/elixir/lib/set.ex b/lib/elixir/lib/set.ex
index 97d4aa4a160..4bd37464303 100644
--- a/lib/elixir/lib/set.ex
+++ b/lib/elixir/lib/set.ex
@@ -1,94 +1,37 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Set do
   @moduledoc ~S"""
-  This module specifies the Set API expected to be
-  implemented by different representations.
-
-  It also provides functions that redirect to the
-  underlying Set, allowing a developer to work with
-  different Set implementations using one API.
-
-  To create a new set, use the `new` functions defined
-  by each set type:
-
-      HashSet.new  #=> creates an empty HashSet
-
-  In the examples below, `set_impl` means a specific
-  `Set` implementation, for example `HashSet`.
+  Generic API for sets.
 
-  ## Protocols
-
-  Sets are required to implement both `Enumerable` and `Collectable`
-  protocols.
-
-  ## Match
-
-  Sets are required to implement all operations using the match (`===`)
-  operator.
+  This module is deprecated, use the `MapSet` module instead.
   """
 
-  use Behaviour
+  @moduledoc deprecated: "Use MapSet instead"
 
   @type value :: any
-  @type values :: [ value ]
+  @type values :: [value]
   @type t :: map
 
-  defcallback new :: t
-  defcallback delete(t, value) :: t
-  defcallback difference(t, t) :: t
-  defcallback disjoint?(t, t) :: boolean
-  defcallback equal?(t, t) :: boolean
-  defcallback intersection(t, t) :: t
-  defcallback member?(t, value) :: boolean
-  defcallback put(t, value) :: t
-  defcallback size(t) :: non_neg_integer
-  defcallback subset?(t, t) :: boolean
-  defcallback to_list(t) :: list()
-  defcallback union(t, t) :: t
+  message = "Use the MapSet module for working with sets"
 
   defmacrop target(set) do
     quote do
       case unquote(set) do
-        %{__struct__: x} when is_atom(x) ->
-          x
-        x ->
-          unsupported_set(x)
+        %module{} -> module
+        set -> unsupported_set(set)
       end
     end
   end
 
-  @doc """
-  Deletes `value` from `set`.
-
-  ## Examples
-
-      iex> s = Enum.into([1, 2, 3], set_impl.new)
-      iex> Set.delete(s, 4) |> Enum.sort
-      [1, 2, 3]
-
-      iex> s = Enum.into([1, 2, 3], set_impl.new)
-      iex> Set.delete(s, 2) |> Enum.sort
-      [1, 3]
-
-  """
-  @spec delete(t, value) :: t
+  @deprecated message
   def delete(set, value) do
     target(set).delete(set, value)
   end
 
-  @doc """
-  Returns a set that is `set1` without the members of `set2`.
-
-  Notice this function is polymorphic as it calculates the difference
-  for of any type. Each set implementation also provides a `difference`
-  function, but they can only work with sets of the same type.
-
-  ## Examples
-
-      iex> Set.difference(Enum.into([1,2], set_impl.new), Enum.into([2,3,4], set_impl.new)) |> Enum.sort
-      [1]
-
-  """
-  @spec difference(t, t) :: t
+  @deprecated message
   def difference(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -96,29 +39,14 @@ defmodule Set do
     if target1 == target2 do
       target1.difference(set1, set2)
     else
-      target2.reduce(set2, {:cont, set1}, fn v, acc ->
+      Enumerable.reduce(set2, {:cont, set1}, fn v, acc ->
         {:cont, target1.delete(acc, v)}
-      end) |> elem(1)
+      end)
+      |> elem(1)
     end
   end
 
-  @doc """
-  Checks if `set1` and `set2` have no members in common.
-
-  Notice this function is polymorphic as it checks for disjoint sets of
-  any type. Each set implementation also provides a `disjoint?` function,
-  but they can only work with sets of the same type.
-
-  ## Examples
-
-      iex> Set.disjoint?(Enum.into([1, 2], set_impl.new), Enum.into([3, 4], set_impl.new))
-      true
-
-      iex> Set.disjoint?(Enum.into([1, 2], set_impl.new), Enum.into([2, 3], set_impl.new))
-      false
-
-  """
-  @spec disjoint?(t, t) :: boolean
+  @deprecated message
   def disjoint?(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -126,38 +54,22 @@ defmodule Set do
     if target1 == target2 do
       target1.disjoint?(set1, set2)
     else
-      target2.reduce(set2, {:cont, true}, fn member, acc ->
+      Enumerable.reduce(set2, {:cont, true}, fn member, acc ->
         case target1.member?(set1, member) do
           false -> {:cont, acc}
-          _     -> {:halt, false}
+          _ -> {:halt, false}
         end
-      end) |> elem(1)
+      end)
+      |> elem(1)
     end
   end
 
-  @doc false
-  @spec empty(t) :: t
+  @deprecated message
   def empty(set) do
     target(set).empty(set)
   end
 
-  @doc """
-  Check if two sets are equal using `===`.
-
-  Notice this function is polymorphic as it compares sets of
-  any type. Each set implementation also provides an `equal?`
-  function, but they can only work with sets of the same type.
-
-  ## Examples
-
-      iex> Set.equal?(Enum.into([1, 2], set_impl.new), Enum.into([2, 1, 1], set_impl.new))
-      true
-
-      iex> Set.equal?(Enum.into([1, 2], set_impl.new), Enum.into([3, 4], set_impl.new))
-      false
-
-  """
-  @spec equal?(t, t) :: boolean
+  @deprecated message
   def equal?(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -174,23 +86,7 @@ defmodule Set do
     end
   end
 
-  @doc """
-  Returns a set containing only members in common between `set1` and `set2`.
-
-  Notice this function is polymorphic as it calculates the intersection of
-  any type. Each set implementation also provides a `intersection` function,
-  but they can only work with sets of the same type.
-
-  ## Examples
-
-      iex> Set.intersection(Enum.into([1,2], set_impl.new), Enum.into([2,3,4], set_impl.new)) |> Enum.sort
-      [2]
-
-      iex> Set.intersection(Enum.into([1,2], set_impl.new), Enum.into([3,4], set_impl.new)) |> Enum.sort
-      []
-
-  """
-  @spec intersection(t, t) :: t
+  @deprecated message
   def intersection(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -198,77 +94,29 @@ defmodule Set do
     if target1 == target2 do
       target1.intersection(set1, set2)
     else
-      target1.reduce(set1, {:cont, Collectable.empty(set1)}, fn v, acc ->
+      Enumerable.reduce(set1, {:cont, target1.new()}, fn v, acc ->
         {:cont, if(target2.member?(set2, v), do: target1.put(acc, v), else: acc)}
-      end) |> elem(1)
+      end)
+      |> elem(1)
     end
   end
 
-  @doc """
-  Checks if `set` contains `value`.
-
-  ## Examples
-
-      iex> Set.member?(Enum.into([1, 2, 3], set_impl.new), 2)
-      true
-
-      iex> Set.member?(Enum.into([1, 2, 3], set_impl.new), 4)
-      false
-
-  """
-  @spec member?(t, value) :: boolean
+  @deprecated message
   def member?(set, value) do
     target(set).member?(set, value)
   end
 
-  @doc """
-  Inserts `value` into `set` if it does not already contain it.
-
-  ## Examples
-
-      iex> Set.put(Enum.into([1, 2, 3], set_impl.new), 3) |> Enum.sort
-      [1, 2, 3]
-
-      iex> Set.put(Enum.into([1, 2, 3], set_impl.new), 4) |> Enum.sort
-      [1, 2, 3, 4]
-
-  """
-  @spec put(t, value) :: t
+  @deprecated message
   def put(set, value) do
     target(set).put(set, value)
   end
 
-  @doc """
-  Returns the number of elements in `set`.
-
-  ## Examples
-
-      iex> Set.size(Enum.into([1, 2, 3], set_impl.new))
-      3
-
-  """
-  @spec size(t) :: non_neg_integer
+  @deprecated message
   def size(set) do
     target(set).size(set)
   end
 
-  @doc """
-  Checks if `set1`'s members are all contained in `set2`.
-
-  Notice this function is polymorphic as it checks the subset for
-  any type. Each set implementation also provides a `subset?` function,
-  but they can only work with sets of the same type.
-
-  ## Examples
-
-      iex> Set.subset?(Enum.into([1, 2], set_impl.new), Enum.into([1, 2, 3], set_impl.new))
-      true
-
-      iex> Set.subset?(Enum.into([1, 2, 3], set_impl.new), Enum.into([1, 2], set_impl.new))
-      false
-
-  """
-  @spec subset?(t, t) :: boolean
+  @deprecated message
   def subset?(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -280,34 +128,12 @@ defmodule Set do
     end
   end
 
-  @doc """
-  Converts `set` to a list.
-
-  ## Examples
-
-      iex> set_impl.to_list(Enum.into([1, 2, 3], set_impl.new)) |> Enum.sort
-      [1,2,3]
-
-  """
-  @spec to_list(t) :: list
+  @deprecated message
   def to_list(set) do
     target(set).to_list(set)
   end
 
-  @doc """
-  Returns a set containing all members of `set1` and `set2`.
-
-  Notice this function is polymorphic as it calculates the union of
-  any type. Each set implementation also provides a `union` function,
-  but they can only work with sets of the same type.
-
-  ## Examples
-
-      iex> Set.union(Enum.into([1,2], set_impl.new), Enum.into([2,3,4], set_impl.new)) |> Enum.sort
-      [1,2,3,4]
-
-  """
-  @spec union(t, t) :: t
+  @deprecated message
   def union(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -315,22 +141,24 @@ defmodule Set do
     if target1 == target2 do
       target1.union(set1, set2)
     else
-      target2.reduce(set2, {:cont, set1}, fn v, acc ->
+      Enumerable.reduce(set2, {:cont, set1}, fn v, acc ->
         {:cont, target1.put(acc, v)}
-      end) |> elem(1)
+      end)
+      |> elem(1)
     end
   end
 
-  defp do_subset?(target1, target2, set1, set2) do
-    target1.reduce(set1, {:cont, true}, fn member, acc ->
+  defp do_subset?(_target1, target2, set1, set2) do
+    Enumerable.reduce(set1, {:cont, true}, fn member, acc ->
       case target2.member?(set2, member) do
         true -> {:cont, acc}
-        _    -> {:halt, false}
+        _ -> {:halt, false}
       end
-    end) |> elem(1)
+    end)
+    |> elem(1)
   end
 
   defp unsupported_set(set) do
-    raise ArgumentError, "unsupported set: #{inspect set}"
+    raise ArgumentError, "unsupported set: #{inspect(set)}"
   end
 end
diff --git a/lib/elixir/lib/stream.ex b/lib/elixir/lib/stream.ex
index d61de10063b..1780738efd4 100644
--- a/lib/elixir/lib/stream.ex
+++ b/lib/elixir/lib/stream.ex
@@ -1,15 +1,20 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Stream do
   @moduledoc """
-  Module for creating and composing streams.
+  Functions for creating and composing streams.
 
-  Streams are composable, lazy enumerables. Any enumerable that generates
-  items one by one during enumeration is called a stream. For example,
+  Streams are composable, lazy enumerables (for an introduction on
+  enumerables, see the `Enum` module). Any enumerable that generates
+  elements one by one during enumeration is called a stream. For example,
   Elixir's `Range` is a stream:
 
       iex> range = 1..5
       1..5
-      iex> Enum.map range, &(&1 * 2)
-      [2,4,6,8,10]
+      iex> Enum.map(range, &(&1 * 2))
+      [2, 4, 6, 8, 10]
 
   In the example above, as we mapped over the range, the elements being
   enumerated were created one by one, during enumeration. The `Stream`
@@ -18,41 +23,44 @@ defmodule Stream do
       iex> range = 1..3
       iex> stream = Stream.map(range, &(&1 * 2))
       iex> Enum.map(stream, &(&1 + 1))
-      [3,5,7]
+      [3, 5, 7]
 
-  Notice we started with a range and then we created a stream that is
-  meant to multiply each item in the range by 2. At this point, no
-  computation was done yet. Just when `Enum.map/2` is called we
-  enumerate over each item in the range, multiplying it by 2 and adding 1.
+  Note that we started with a range and then we created a stream that is
+  meant to multiply each element in the range by 2. At this point, no
+  computation was done. Only when `Enum.map/2` is called we actually
+  enumerate over each element in the range, multiplying it by 2 and adding 1.
   We say the functions in `Stream` are *lazy* and the functions in `Enum`
   are *eager*.
 
   Due to their laziness, streams are useful when working with large
   (or even infinite) collections. When chaining many operations with `Enum`,
   intermediate lists are created, while `Stream` creates a recipe of
-  computations that are executed at a later moment. Let's see another
-  example:
+  computations that are executed at a later moment. Then when the
+  stream is consumed later on, most commonly by using a function in
+  the `Enum` module, the stream will emit its elements one by one.
+
+  Let's see another example:
 
-      1..3 |>
-        Enum.map(&IO.inspect(&1)) |>
-        Enum.map(&(&1 * 2)) |>
-        Enum.map(&IO.inspect(&1))
+      1..3
+      |> Enum.map(&IO.inspect(&1))
+      |> Enum.map(&(&1 * 2))
+      |> Enum.map(&IO.inspect(&1))
       1
       2
       3
       2
       4
       6
-      #=> [2,4,6]
+      #=> [2, 4, 6]
 
-  Notice that we first printed each item in the list, then multiplied each
+  Note that we first printed each element in the list, then multiplied each
   element by 2 and finally printed each new value. In this example, the list
   was enumerated three times. Let's see an example with streams:
 
-      stream = 1..3 |>
-        Stream.map(&IO.inspect(&1)) |>
-        Stream.map(&(&1 * 2)) |>
-        Stream.map(&IO.inspect(&1))
+      stream = 1..3
+      |> Stream.map(&IO.inspect(&1))
+      |> Stream.map(&(&1 * 2))
+      |> Stream.map(&IO.inspect(&1))
       Enum.to_list(stream)
       1
       2
@@ -60,16 +68,23 @@ defmodule Stream do
       4
       3
       6
-      #=> [2,4,6]
+      #=> [2, 4, 6]
 
-  Although the end result is the same, the order in which the items were
-  printed changed! With streams, we print the first item and then print
+  Although the end result is the same, the order in which the elements were
+  printed changed! With streams, we print the first element and then print
   its double. In this example, the list was enumerated just once!
 
-  That's what we meant when we first said that streams are composable,
-  lazy enumerables. Notice we could call `Stream.map/2` multiple times,
-  effectively composing the streams and they are lazy. The computations
-  are performed only when you call a function from the `Enum` module.
+  That's what we meant when we said earlier that streams are composable,
+  lazy enumerables. Note that we could call `Stream.map/2` multiple times,
+  effectively composing the streams and keeping them lazy. The computations
+  are only performed when you call a function from the `Enum` module.
+
+  Like with `Enum`, the functions in this module work in linear time. This
+  means that, the time it takes to perform an operation grows at the same
+  rate as the length of the list. This is expected on operations such as
+  `Stream.map/2`. After all, if we want to traverse every element on a
+  stream, the longer the stream, the more elements we need to traverse,
+  and the longer it will take.
 
   ## Creating Streams
 
@@ -82,96 +97,129 @@ defmodule Stream do
   This module also provides many convenience functions for creating streams,
   like `Stream.cycle/1`, `Stream.unfold/2`, `Stream.resource/3` and more.
 
-  Note the functions in this module are guaranteed to return enumerables.
-  Since enumerables can have different shapes (structs, anonymous functions,
-  and so on), the functions in this module may return any of those shapes
-  and that it may change at any time. For example, a function that today
-  returns an anonymous function may return a struct in future releases.
+  > #### Do not check for `Stream` structs
+  >
+  > While some functions in this module may return the `Stream` struct,
+  > you must never explicitly check for the `Stream` struct, as streams
+  > may come in several shapes, such as `IO.Stream`, `File.Stream`, or
+  > even `Range`s.
+  >
+  > The functions in this module only guarantee to return enumerables
+  > and their implementation (structs, anonymous functions, etc) may
+  > change at any time. For example, a function that returns an anonymous
+  > function today may return a struct in future releases.
+  >
+  > Instead of checking for a particular type, you must instead write
+  > assertive code that assumes you have an enumerable, using the functions
+  > in the `Enum` or `Stream` module accordingly.
   """
 
+  @doc false
   defstruct enum: nil, funs: [], accs: [], done: nil
 
   @type acc :: any
   @type element :: any
+
+  @typedoc "Zero-based index."
   @type index :: non_neg_integer
+
   @type default :: any
+  @type timer :: non_neg_integer | :infinity
 
   # Require Stream.Reducers and its callbacks
   require Stream.Reducers, as: R
 
-  defmacrop cont(f, entry, acc) do
-    quote do: unquote(f).(unquote(entry), unquote(acc))
+  defmacrop skip(acc) do
+    {:cont, acc}
+  end
+
+  defmacrop next(fun, entry, acc) do
+    quote(do: unquote(fun).(unquote(entry), unquote(acc)))
   end
 
-  defmacrop acc(h, n, t) do
-    quote do: [unquote(h),unquote(n)|unquote(t)]
+  defmacrop acc(head, state, tail) do
+    quote(do: [unquote(head), unquote(state) | unquote(tail)])
   end
 
-  defmacrop cont_with_acc(f, entry, h, n, t) do
+  defmacrop next_with_acc(fun, entry, head, state, tail) do
     quote do
-      {reason, [h|t]} = unquote(f).(unquote(entry), [unquote(h)|unquote(t)])
-      {reason, [h,unquote(n)|t]}
+      {reason, [head | tail]} = unquote(fun).(unquote(entry), [unquote(head) | unquote(tail)])
+      {reason, [head, unquote(state) | tail]}
     end
   end
 
   ## Transformers
 
+  @doc false
+  @deprecated "Use Stream.chunk_every/2 instead"
+  def chunk(enum, n), do: chunk(enum, n, n, nil)
+
+  @doc false
+  @deprecated "Use Stream.chunk_every/3 instead"
+  def chunk(enum, n, step) do
+    chunk_every(enum, n, step, nil)
+  end
+
+  @doc false
+  @deprecated "Use Stream.chunk_every/4 instead"
+  def chunk(enum, n, step, leftover)
+      when is_integer(n) and n > 0 and is_integer(step) and step > 0 do
+    chunk_every(enum, n, step, leftover || :discard)
+  end
+
   @doc """
-  Shortcut to `chunk(enum, n, n)`.
+  Shortcut to `chunk_every(enum, count, count)`.
   """
-  @spec chunk(Enumerable.t, non_neg_integer) :: Enumerable.t
-  def chunk(enum, n), do: chunk(enum, n, n, nil)
+  @doc since: "1.5.0"
+  @spec chunk_every(Enumerable.t(), pos_integer) :: Enumerable.t()
+  def chunk_every(enum, count), do: chunk_every(enum, count, count, [])
 
   @doc """
-  Streams the enumerable in chunks, containing `n` items each, where
-  each new chunk starts `step` elements into the enumerable.
-
-  `step` is optional and, if not passed, defaults to `n`, i.e.
-  chunks do not overlap. If the final chunk does not have `n`
-  elements to fill the chunk, elements are taken as necessary
-  from `pad` if it was passed. If `pad` is passed and does not
-  have enough elements to fill the chunk, then the chunk is
-  returned anyway with less than `n` elements. If `pad` is not
-  passed at all or is `nil`, then the partial chunk is discarded
-  from the result.
+  Streams the enumerable in chunks, containing `count` elements each,
+  where each new chunk starts `step` elements into the enumerable.
+
+  `step` is optional and, if not passed, defaults to `count`, i.e.
+  chunks do not overlap. Chunking will stop as soon as the collection
+  ends or when we emit an incomplete chunk.
+
+  If the last chunk does not have `count` elements to fill the chunk,
+  elements are taken from `leftover` to fill in the chunk. If `leftover`
+  does not have enough elements to fill the chunk, then a partial chunk
+  is returned with less than `count` elements.
+
+  If `:discard` is given in `leftover`, the last chunk is discarded
+  unless it has exactly `count` elements.
 
   ## Examples
 
-      iex> Stream.chunk([1, 2, 3, 4, 5, 6], 2) |> Enum.to_list
+      iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 2) |> Enum.to_list()
       [[1, 2], [3, 4], [5, 6]]
 
-      iex> Stream.chunk([1, 2, 3, 4, 5, 6], 3, 2) |> Enum.to_list
+      iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard) |> Enum.to_list()
       [[1, 2, 3], [3, 4, 5]]
 
-      iex> Stream.chunk([1, 2, 3, 4, 5, 6], 3, 2, [7]) |> Enum.to_list
+      iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, [7]) |> Enum.to_list()
       [[1, 2, 3], [3, 4, 5], [5, 6, 7]]
 
-      iex> Stream.chunk([1, 2, 3, 4, 5, 6], 3, 3, []) |> Enum.to_list
+      iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 3, []) |> Enum.to_list()
       [[1, 2, 3], [4, 5, 6]]
 
+      iex> Stream.chunk_every([1, 2, 3, 4], 3, 3, Stream.cycle([0])) |> Enum.to_list()
+      [[1, 2, 3], [4, 0, 0]]
+
   """
-  @spec chunk(Enumerable.t, non_neg_integer, non_neg_integer) :: Enumerable.t
-  @spec chunk(Enumerable.t, non_neg_integer, non_neg_integer, Enumerable.t | nil) :: Enumerable.t
-  def chunk(enum, n, step, pad \\ nil) when n > 0 and step > 0 do
-    limit = :erlang.max(n, step)
-    lazy enum, {[], 0},
-         fn(f1) -> R.chunk(n, step, limit, f1) end,
-         fn(f1) -> &do_chunk(&1, n, pad, f1) end
-  end
-
-  defp do_chunk(acc(h, {buffer, count} = old, t) = acc, n, pad, f1) do
-    if nil?(pad) || count == 0 do
-      {:cont, acc}
-    else
-      buffer = :lists.reverse(buffer) ++ Enum.take(pad, n - count)
-      cont_with_acc(f1, buffer, h, old, t)
-    end
+  @doc since: "1.5.0"
+  @spec chunk_every(Enumerable.t(), pos_integer, pos_integer, Enumerable.t() | :discard) ::
+          Enumerable.t()
+  def chunk_every(enum, count, step, leftover \\ [])
+      when is_integer(count) and count > 0 and is_integer(step) and step > 0 do
+    R.chunk_every(&chunk_while/4, enum, count, step, leftover)
   end
 
   @doc """
-  Chunks the `enum` by buffering elements for which `fun` returns
-  the same value and only emit them when `fun` returns a new value
-  or the `enum` finishes.
+  Chunks the `enum` by buffering elements for which `fun` returns the same value.
+
+  Elements are only emitted when `fun` returns a new value or the `enum` finishes.
 
   ## Examples
 
@@ -180,93 +228,261 @@ defmodule Stream do
       [[1], [2, 2], [3], [4, 4, 6], [7, 7]]
 
   """
-  @spec chunk_by(Enumerable.t, (element -> any)) :: Enumerable.t
-  def chunk_by(enum, fun) do
-    lazy enum, nil,
-         fn(f1) -> R.chunk_by(fun, f1) end,
-         fn(f1) -> &do_chunk_by(&1, f1) end
+  @spec chunk_by(Enumerable.t(), (element -> any)) :: Enumerable.t()
+  def chunk_by(enum, fun) when is_function(fun, 1) do
+    R.chunk_by(&chunk_while/4, enum, fun)
   end
 
-  defp do_chunk_by(acc(_, nil, _) = acc, _f1) do
-    {:cont, acc}
+  @doc """
+  Chunks the `enum` with fine grained control when every chunk is emitted.
+
+  `chunk_fun` receives the current element and the accumulator and
+  must return `{:cont, element, acc}` to emit the given chunk and
+  continue with accumulator or `{:cont, acc}` to not emit any chunk
+  and continue with the return accumulator.
+
+  `after_fun` is invoked when iteration is done and must also return
+  `{:cont, element, acc}` or `{:cont, acc}`.
+
+  ## Examples
+
+      iex> chunk_fun = fn element, acc ->
+      ...>   if rem(element, 2) == 0 do
+      ...>     {:cont, Enum.reverse([element | acc]), []}
+      ...>   else
+      ...>     {:cont, [element | acc]}
+      ...>   end
+      ...> end
+      iex> after_fun = fn
+      ...>   [] -> {:cont, []}
+      ...>   acc -> {:cont, Enum.reverse(acc), []}
+      ...> end
+      iex> stream = Stream.chunk_while(1..10, [], chunk_fun, after_fun)
+      iex> Enum.to_list(stream)
+      [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
+
+  """
+  @doc since: "1.5.0"
+  @spec chunk_while(
+          Enumerable.t(),
+          acc,
+          (element, acc -> {:cont, chunk, acc} | {:cont, acc} | {:halt, acc}),
+          (acc -> {:cont, chunk, acc} | {:cont, acc})
+        ) :: Enumerable.t()
+        when chunk: any
+  def chunk_while(enum, acc, chunk_fun, after_fun)
+      when is_function(chunk_fun, 2) and is_function(after_fun, 1) do
+    lazy(
+      enum,
+      [acc | after_fun],
+      fn f1 -> chunk_while_fun(chunk_fun, f1) end,
+      &after_chunk_while/2
+    )
+  end
+
+  defp chunk_while_fun(callback, fun) do
+    fn entry, acc(head, [acc | after_fun], tail) ->
+      case callback.(entry, acc) do
+        {:cont, emit, acc} ->
+          # If we emit an element and then we have to halt,
+          # we need to disable the after_fun callback to
+          # avoid emitting even more elements.
+          case next(fun, emit, [head | tail]) do
+            {:halt, [head | tail]} -> {:halt, acc(head, [acc | &{:cont, &1}], tail)}
+            {command, [head | tail]} -> {command, acc(head, [acc | after_fun], tail)}
+          end
+
+        {:cont, acc} ->
+          skip(acc(head, [acc | after_fun], tail))
+
+        {:halt, acc} ->
+          {:halt, acc(head, [acc | after_fun], tail)}
+      end
+    end
+  end
+
+  defp after_chunk_while(acc(h, [acc | after_fun], t), f1) do
+    case after_fun.(acc) do
+      {:cont, emit, acc} -> next_with_acc(f1, emit, h, [acc | after_fun], t)
+      {:cont, acc} -> {:cont, acc(h, [acc | after_fun], t)}
+    end
   end
 
-  defp do_chunk_by(acc(h, {buffer, _}, t), f1) do
-    cont_with_acc(f1, :lists.reverse(buffer), h, nil, t)
+  @doc """
+  Creates a stream that only emits elements if they are different from the last emitted element.
+
+  This function only ever needs to store the last emitted element.
+
+  Elements are compared using `===/2`.
+
+  ## Examples
+
+      iex> Stream.dedup([1, 2, 3, 3, 2, 1]) |> Enum.to_list()
+      [1, 2, 3, 2, 1]
+
+  """
+  @spec dedup(Enumerable.t()) :: Enumerable.t()
+  def dedup(enum) do
+    dedup_by(enum, fn x -> x end)
   end
 
   @doc """
-  Lazily drops the next `n` items from the enumerable.
+  Creates a stream that only emits elements if the result of calling `fun` on the element is
+  different from the (stored) result of calling `fun` on the last emitted element.
 
-  If a negative `n` is given, it will drop the last `n` items from
+  ## Examples
+
+      iex> Stream.dedup_by([{1, :x}, {2, :y}, {2, :z}, {1, :x}], fn {x, _} -> x end) |> Enum.to_list()
+      [{1, :x}, {2, :y}, {1, :x}]
+
+  """
+  @spec dedup_by(Enumerable.t(), (element -> term)) :: Enumerable.t()
+  def dedup_by(enum, fun) when is_function(fun, 1) do
+    lazy(enum, nil, fn f1 -> R.dedup(fun, f1) end)
+  end
+
+  @doc """
+  Lazily drops the next `n` elements from the enumerable.
+
+  If a negative `n` is given, it will drop the last `n` elements from
   the collection. Note that the mechanism by which this is implemented
-  will delay the emission of any item until `n` additional items have
+  will delay the emission of any element until `n` additional elements have
   been emitted by the enum.
 
   ## Examples
 
       iex> stream = Stream.drop(1..10, 5)
       iex> Enum.to_list(stream)
-      [6,7,8,9,10]
+      [6, 7, 8, 9, 10]
 
       iex> stream = Stream.drop(1..10, -5)
       iex> Enum.to_list(stream)
-      [1,2,3,4,5]
+      [1, 2, 3, 4, 5]
 
   """
-  @spec drop(Enumerable.t, non_neg_integer) :: Enumerable.t
-  def drop(enum, n) when n >= 0 do
-    lazy enum, n, fn(f1) -> R.drop(f1) end
+  @spec drop(Enumerable.t(), integer) :: Enumerable.t()
+  def drop(enum, n) when is_integer(n) and n >= 0 do
+    lazy(enum, n, fn f1 -> R.drop(f1) end)
   end
 
-  def drop(enum, n) when n < 0 do
+  def drop(enum, n) when is_integer(n) and n < 0 do
     n = abs(n)
 
-    lazy enum, {0, [], []}, fn(f1) ->
+    lazy(enum, {0, [], []}, fn f1 ->
       fn
         entry, [h, {count, buf1, []} | t] ->
           do_drop(:cont, n, entry, h, count, buf1, [], t)
-        entry, [h, {count, buf1, [next|buf2]} | t] ->
-          {reason, [h|t]} = f1.(next, [h|t])
+
+        entry, [h, {count, buf1, [next | buf2]} | t] ->
+          {reason, [h | t]} = f1.(next, [h | t])
           do_drop(reason, n, entry, h, count, buf1, buf2, t)
       end
-    end
+    end)
   end
 
   defp do_drop(reason, n, entry, h, count, buf1, buf2, t) do
-    buf1  = [entry|buf1]
+    buf1 = [entry | buf1]
     count = count + 1
+
     if count == n do
-      {reason, [h, {0, [], :lists.reverse(buf1)}|t]}
+      {reason, [h, {0, [], :lists.reverse(buf1)} | t]}
     else
-      {reason, [h, {count, buf1, buf2}|t]}
+      {reason, [h, {count, buf1, buf2} | t]}
     end
   end
 
+  @doc """
+  Creates a stream that drops every `nth` element from the enumerable.
+
+  The first element is always dropped, unless `nth` is 0.
+
+  `nth` must be a non-negative integer.
+
+  ## Examples
+
+      iex> stream = Stream.drop_every(1..10, 2)
+      iex> Enum.to_list(stream)
+      [2, 4, 6, 8, 10]
+
+      iex> stream = Stream.drop_every(1..1000, 1)
+      iex> Enum.to_list(stream)
+      []
+
+      iex> stream = Stream.drop_every([1, 2, 3, 4, 5], 0)
+      iex> Enum.to_list(stream)
+      [1, 2, 3, 4, 5]
+
+  """
+  @spec drop_every(Enumerable.t(), non_neg_integer) :: Enumerable.t()
+  def drop_every(enum, nth)
+  def drop_every(enum, 0), do: %Stream{enum: enum}
+  def drop_every([], _nth), do: %Stream{enum: []}
+
+  def drop_every(enum, nth) when is_integer(nth) and nth > 0 do
+    lazy(enum, nth, fn f1 -> R.drop_every(nth, f1) end)
+  end
+
   @doc """
   Lazily drops elements of the enumerable while the given
-  function returns `true`.
+  function returns a truthy value.
 
   ## Examples
 
       iex> stream = Stream.drop_while(1..10, &(&1 <= 5))
       iex> Enum.to_list(stream)
-      [6,7,8,9,10]
+      [6, 7, 8, 9, 10]
 
   """
-  @spec drop_while(Enumerable.t, (element -> as_boolean(term))) :: Enumerable.t
-  def drop_while(enum, fun) do
-    lazy enum, true, fn(f1) -> R.drop_while(fun, f1) end
+  @spec drop_while(Enumerable.t(), (element -> as_boolean(term))) :: Enumerable.t()
+  def drop_while(enum, fun) when is_function(fun, 1) do
+    lazy(enum, true, fn f1 -> R.drop_while(fun, f1) end)
   end
 
   @doc """
-  Execute the given function for each item.
+  Duplicates the given element `n` times in a stream.
+
+  `n` is an integer greater than or equal to `0`.
 
-  Useful for adding side effects (like printing) to a stream.
+  If `n` is `0`, an empty stream is returned.
 
   ## Examples
 
-      iex> stream = Stream.each([1, 2, 3], fn(x) -> send self, x end)
+      iex> stream = Stream.duplicate("hello", 0)
+      iex> Enum.to_list(stream)
+      []
+
+      iex> stream = Stream.duplicate("hi", 1)
+      iex> Enum.to_list(stream)
+      ["hi"]
+
+      iex> stream = Stream.duplicate("bye", 2)
+      iex> Enum.to_list(stream)
+      ["bye", "bye"]
+
+      iex> stream = Stream.duplicate([1, 2], 3)
+      iex> Enum.to_list(stream)
+      [[1, 2], [1, 2], [1, 2]]
+  """
+  @doc since: "1.14.0"
+  @spec duplicate(any, non_neg_integer) :: Enumerable.t()
+  def duplicate(value, n) when is_integer(n) and n >= 0 do
+    unfold(n, fn
+      0 -> nil
+      remaining -> {value, remaining - 1}
+    end)
+  end
+
+  @doc """
+  Executes the given function for each element.
+
+  The values in the stream do not change, therefore this
+  function is useful for adding side effects (like printing)
+  to a stream. See `map/2` if producing a different stream
+  is desired.
+
+  ## Examples
+
+      iex> stream = Stream.each([1, 2, 3], fn x -> send(self(), x) end)
       iex> Enum.to_list(stream)
       iex> receive do: (x when is_integer(x) -> x)
       1
@@ -276,29 +492,35 @@ defmodule Stream do
       3
 
   """
-  @spec each(Enumerable.t, (element -> term)) :: Enumerable.t
-  def each(enum, fun) do
-    lazy enum, fn(f1) ->
-      fn(x, acc) ->
+  @spec each(Enumerable.t(), (element -> term)) :: Enumerable.t()
+  def each(enum, fun) when is_function(fun, 1) do
+    lazy(enum, fn f1 ->
+      fn x, acc ->
         fun.(x)
         f1.(x, acc)
       end
-    end
+    end)
   end
 
   @doc """
-  Creates a stream that will apply the given function on enumeration and
-  flatten the result.
+  Maps the given `fun` over `enumerable` and flattens the result.
+
+  This function returns a new stream built by appending the result of invoking `fun`
+  on each element of `enumerable` together.
 
   ## Examples
 
-      iex> stream = Stream.flat_map([1, 2, 3], fn(x) -> [x, x * 2] end)
+      iex> stream = Stream.flat_map([1, 2, 3], fn x -> [x, x * 2] end)
       iex> Enum.to_list(stream)
       [1, 2, 2, 4, 3, 6]
 
+      iex> stream = Stream.flat_map([1, 2, 3], fn x -> [[x]] end)
+      iex> Enum.to_list(stream)
+      [[1], [2], [3]]
+
   """
-  @spec flat_map(Enumerable.t, (element -> Enumerable.t)) :: Enumerable.t
-  def flat_map(enum, mapper) do
+  @spec flat_map(Enumerable.t(), (element -> Enumerable.t())) :: Enumerable.t()
+  def flat_map(enum, mapper) when is_function(mapper, 1) do
     transform(enum, nil, fn val, nil -> {mapper.(val), nil} end)
   end
 
@@ -308,32 +530,48 @@ defmodule Stream do
 
   ## Examples
 
-      iex> stream = Stream.filter([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
+      iex> stream = Stream.filter([1, 2, 3], fn x -> rem(x, 2) == 0 end)
       iex> Enum.to_list(stream)
       [2]
 
   """
-  @spec filter(Enumerable.t, (element -> as_boolean(term))) :: Enumerable.t
-  def filter(enum, fun) do
-    lazy enum, fn(f1) -> R.filter(fun, f1) end
+  @spec filter(Enumerable.t(), (element -> as_boolean(term))) :: Enumerable.t()
+  def filter(enum, fun) when is_function(fun, 1) do
+    lazy(enum, fn f1 -> R.filter(fun, f1) end)
+  end
+
+  @doc false
+  @deprecated "Use Stream.filter/2 + Stream.map/2 instead"
+  def filter_map(enum, filter, mapper) do
+    lazy(enum, fn f1 -> R.filter_map(filter, mapper, f1) end)
   end
 
   @doc """
-  Creates a stream that filters and then maps elements according
-  to given functions.
+  Creates a stream that emits a value after the given period `n`
+  in milliseconds.
 
-  Exists for symmetry with `Enum.filter_map/3`.
+  The values emitted are an increasing counter starting at `0`.
+  This operation will block the caller by the given interval
+  every time a new element is streamed.
+
+  Do not use this function to generate a sequence of numbers.
+  If blocking the caller process is not necessary, use
+  `Stream.iterate(0, & &1 + 1)` instead.
 
   ## Examples
 
-      iex> stream = Stream.filter_map(1..6, fn(x) -> rem(x, 2) == 0 end, &(&1 * 2))
-      iex> Enum.to_list(stream)
-      [4,8,12]
+      iex> Stream.interval(10) |> Enum.take(10)
+      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
   """
-  @spec filter_map(Enumerable.t, (element -> as_boolean(term)), (element -> any)) :: Enumerable.t
-  def filter_map(enum, filter, mapper) do
-    lazy enum, fn(f1) -> R.filter_map(filter, mapper, f1) end
+  @spec interval(timer()) :: Enumerable.t()
+  def interval(n)
+      when is_integer(n) and n >= 0
+      when n == :infinity do
+    unfold(0, fn count ->
+      Process.sleep(n)
+      {count, count + 1}
+    end)
   end
 
   @doc """
@@ -342,33 +580,35 @@ defmodule Stream do
   This function is often used with `run/1` since any evaluation
   is delayed until the stream is executed. See `run/1` for an example.
   """
-  @spec into(Enumerable.t, Collectable.t) :: Enumerable.t
-  def into(enum, collectable, transform \\ fn x -> x end) do
+  @spec into(Enumerable.t(), Collectable.t(), (term -> term)) :: Enumerable.t()
+  def into(enum, collectable, transform \\ fn x -> x end) when is_function(transform, 1) do
     &do_into(enum, collectable, transform, &1, &2)
   end
 
   defp do_into(enum, collectable, transform, acc, fun) do
     {initial, into} = Collectable.into(collectable)
-    composed = fn x, [acc|collectable] ->
+
+    composed = fn x, [acc | collectable] ->
       collectable = into.(collectable, {:cont, transform.(x)})
       {reason, acc} = fun.(x, acc)
-      {reason, [acc|collectable]}
+      {reason, [acc | collectable]}
     end
+
     do_into(&Enumerable.reduce(enum, &1, composed), initial, into, acc)
   end
 
   defp do_into(reduce, collectable, into, {command, acc}) do
     try do
-      reduce.({command, [acc|collectable]})
+      reduce.({command, [acc | collectable]})
     catch
       kind, reason ->
-        stacktrace = System.stacktrace
         into.(collectable, :halt)
-        :erlang.raise(kind, reason, stacktrace)
+        :erlang.raise(kind, reason, __STACKTRACE__)
     else
-      {:suspended, [acc|collectable], continuation} ->
+      {:suspended, [acc | collectable], continuation} ->
         {:suspended, acc, &do_into(continuation, collectable, into, &1)}
-      {reason, [acc|collectable]} ->
+
+      {reason, [acc | collectable]} ->
         into.(collectable, :done)
         {reason, acc}
     end
@@ -380,14 +620,51 @@ defmodule Stream do
 
   ## Examples
 
-      iex> stream = Stream.map([1, 2, 3], fn(x) -> x * 2 end)
+      iex> stream = Stream.map([1, 2, 3], fn x -> x * 2 end)
+      iex> Enum.to_list(stream)
+      [2, 4, 6]
+
+  """
+  @spec map(Enumerable.t(), (element -> any)) :: Enumerable.t()
+  def map(enum, fun) when is_function(fun, 1) do
+    lazy(enum, fn f1 -> R.map(fun, f1) end)
+  end
+
+  @doc """
+  Creates a stream that will apply the given function on
+  every `nth` element from the enumerable.
+
+  The first element is always passed to the given function.
+
+  `nth` must be a non-negative integer.
+
+  ## Examples
+
+      iex> stream = Stream.map_every(1..10, 2, fn x -> x * 2 end)
+      iex> Enum.to_list(stream)
+      [2, 2, 6, 4, 10, 6, 14, 8, 18, 10]
+
+      iex> stream = Stream.map_every([1, 2, 3, 4, 5], 1, fn x -> x * 2 end)
       iex> Enum.to_list(stream)
-      [2,4,6]
+      [2, 4, 6, 8, 10]
+
+      iex> stream = Stream.map_every(1..5, 0, fn x -> x * 2 end)
+      iex> Enum.to_list(stream)
+      [1, 2, 3, 4, 5]
 
   """
-  @spec map(Enumerable.t, (element -> any)) :: Enumerable.t
-  def map(enum, fun) do
-    lazy enum, fn(f1) -> R.map(fun, f1) end
+  @doc since: "1.4.0"
+  @spec map_every(Enumerable.t(), non_neg_integer, (element -> any)) :: Enumerable.t()
+  def map_every(enum, nth, fun) when is_integer(nth) and nth >= 0 and is_function(fun, 1) do
+    map_every_after_guards(enum, nth, fun)
+  end
+
+  defp map_every_after_guards(enum, 1, fun), do: map(enum, fun)
+  defp map_every_after_guards(enum, 0, _fun), do: %Stream{enum: enum}
+  defp map_every_after_guards([], _nth, _fun), do: %Stream{enum: []}
+
+  defp map_every_after_guards(enum, nth, fun) do
+    lazy(enum, nth, fn f1 -> R.map_every(nth, fun, f1) end)
   end
 
   @doc """
@@ -396,14 +673,14 @@ defmodule Stream do
 
   ## Examples
 
-      iex> stream = Stream.reject([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
+      iex> stream = Stream.reject([1, 2, 3], fn x -> rem(x, 2) == 0 end)
       iex> Enum.to_list(stream)
-      [1,3]
+      [1, 3]
 
   """
-  @spec reject(Enumerable.t, (element -> as_boolean(term))) :: Enumerable.t
-  def reject(enum, fun) do
-    lazy enum, fn(f1) -> R.reject(fun, f1) end
+  @spec reject(Enumerable.t(), (element -> as_boolean(term))) :: Enumerable.t()
+  def reject(enum, fun) when is_function(fun, 1) do
+    lazy(enum, fn f1 -> R.reject(fun, f1) end)
   end
 
   @doc """
@@ -417,35 +694,36 @@ defmodule Stream do
   Open up a file, replace all `#` by `%` and stream to another file
   without loading the whole file in memory:
 
-      stream = File.stream!("code")
+      File.stream!("/path/to/file")
       |> Stream.map(&String.replace(&1, "#", "%"))
-      |> Stream.into(File.stream!("new"))
-      |> Stream.run
+      |> Stream.into(File.stream!("/path/to/other/file"))
+      |> Stream.run()
 
-  No computation will be done until we call one of the Enum functions
-  or `Stream.run/1`.
+  No computation will be done until we call one of the `Enum` functions
+  or `run/1`.
   """
-  @spec run(Enumerable.t) :: :ok
+  @spec run(Enumerable.t()) :: :ok
   def run(stream) do
-    Enumerable.reduce(stream, {:cont, nil}, fn(_, _) -> {:cont, nil} end)
+    _ = Enumerable.reduce(stream, {:cont, nil}, fn _, _ -> {:cont, nil} end)
     :ok
   end
 
   @doc """
   Creates a stream that applies the given function to each
   element, emits the result and uses the same result as the accumulator
-  for the next computation.
+  for the next computation. Uses the first element in the enumerable
+  as the starting value.
 
   ## Examples
 
       iex> stream = Stream.scan(1..5, &(&1 + &2))
       iex> Enum.to_list(stream)
-      [1,3,6,10,15]
+      [1, 3, 6, 10, 15]
 
   """
-  @spec scan(Enumerable.t, (element, acc -> any)) :: Enumerable.t
-  def scan(enum, fun) do
-    lazy enum, :first, fn(f1) -> R.scan_2(fun, f1) end
+  @spec scan(Enumerable.t(), (element, acc -> any)) :: Enumerable.t()
+  def scan(enum, fun) when is_function(fun, 2) do
+    lazy(enum, :first, fn f1 -> R.scan2(fun, f1) end)
   end
 
   @doc """
@@ -457,223 +735,373 @@ defmodule Stream do
 
       iex> stream = Stream.scan(1..5, 0, &(&1 + &2))
       iex> Enum.to_list(stream)
-      [1,3,6,10,15]
+      [1, 3, 6, 10, 15]
 
   """
-  @spec scan(Enumerable.t, acc, (element, acc -> any)) :: Enumerable.t
-  def scan(enum, acc, fun) do
-    lazy enum, acc, fn(f1) -> R.scan_3(fun, f1) end
+  @spec scan(Enumerable.t(), acc, (element, acc -> any)) :: Enumerable.t()
+  def scan(enum, acc, fun) when is_function(fun, 2) do
+    lazy(enum, acc, fn f1 -> R.scan3(fun, f1) end)
   end
 
   @doc """
-  Lazily takes the next `n` items from the enumerable and stops
+  Lazily takes the next `count` elements from the enumerable and stops
   enumeration.
 
-  If a negative `n` is given, the last `n` values will be taken.
-  For such, the collection is fully enumerated keeping up to `2 * n`
+  If a negative `count` is given, the last `count` values will be taken.
+  For such, the collection is fully enumerated keeping up to `2 * count`
   elements in memory. Once the end of the collection is reached,
   the last `count` elements will be executed. Therefore, using
-  a negative `n` on an infinite collection will never return.
+  a negative `count` on an infinite collection will never return.
 
   ## Examples
 
       iex> stream = Stream.take(1..100, 5)
       iex> Enum.to_list(stream)
-      [1,2,3,4,5]
+      [1, 2, 3, 4, 5]
 
       iex> stream = Stream.take(1..100, -5)
       iex> Enum.to_list(stream)
-      [96,97,98,99,100]
+      [96, 97, 98, 99, 100]
 
       iex> stream = Stream.cycle([1, 2, 3]) |> Stream.take(5)
       iex> Enum.to_list(stream)
-      [1,2,3,1,2]
+      [1, 2, 3, 1, 2]
 
   """
-  @spec take(Enumerable.t, non_neg_integer) :: Enumerable.t
-  def take(_enum, 0), do: %Stream{enum: []}
-
-  def take(enum, n) when n > 0 do
-    lazy enum, n, fn(f1) -> R.take(f1) end
+  @spec take(Enumerable.t(), integer) :: Enumerable.t()
+  def take(enum, count) when is_integer(count) do
+    take_after_guards(enum, count)
   end
 
-  def take(enum, n) when n < 0 do
-    &do_take(enum, abs(n), &1, &2)
-  end
+  defp take_after_guards(_enum, 0), do: %Stream{enum: []}
 
-  defp do_take(enum, n, acc, f) do
-    {_, {_count, buf1, buf2}} =
-      Enumerable.reduce(enum, {:cont, {0, [], []}}, fn
-        entry, {count, buf1, buf2} ->
-          buf1  = [entry|buf1]
-          count = count + 1
-          if count == n do
-            {:cont, {0, [], buf1}}
-          else
-            {:cont, {count, buf1, buf2}}
-          end
-      end)
+  defp take_after_guards([], _count), do: %Stream{enum: []}
 
-    Enumerable.reduce(do_take_last(buf1, buf2, n, []), acc, f)
+  defp take_after_guards(enum, count) when count > 0 do
+    lazy(enum, count, fn f1 -> R.take(f1) end)
   end
 
-  defp do_take_last(_buf1, _buf2, 0, acc),
-    do: acc
-  defp do_take_last([], [], _, acc),
-    do: acc
-  defp do_take_last([], [h|t], n, acc),
-    do: do_take_last([], t, n-1, [h|acc])
-  defp do_take_last([h|t], buf2, n, acc),
-    do: do_take_last(t, buf2, n-1, [h|acc])
+  defp take_after_guards(enum, count) when count < 0 do
+    &Enumerable.reduce(Enum.take(enum, count), &1, &2)
+  end
 
   @doc """
-  Creates a stream that takes every `n` item from the enumerable.
+  Creates a stream that takes every `nth` element from the enumerable.
 
-  The first item is always included, unless `n` is 0.
+  The first element is always included, unless `nth` is 0.
+
+  `nth` must be a non-negative integer.
 
   ## Examples
 
       iex> stream = Stream.take_every(1..10, 2)
       iex> Enum.to_list(stream)
-      [1,3,5,7,9]
+      [1, 3, 5, 7, 9]
+
+      iex> stream = Stream.take_every([1, 2, 3, 4, 5], 1)
+      iex> Enum.to_list(stream)
+      [1, 2, 3, 4, 5]
+
+      iex> stream = Stream.take_every(1..1000, 0)
+      iex> Enum.to_list(stream)
+      []
 
   """
-  @spec take_every(Enumerable.t, non_neg_integer) :: Enumerable.t
-  def take_every(enum, n) when n > 0 do
-    lazy enum, n, fn(f1) -> R.take_every(n, f1) end
+  @spec take_every(Enumerable.t(), non_neg_integer) :: Enumerable.t()
+  def take_every(enum, nth) when is_integer(nth) and nth >= 0 do
+    take_every_after_guards(enum, nth)
   end
 
-  def take_every(_enum, 0), do: %Stream{enum: []}
+  defp take_every_after_guards(_enum, 0), do: %Stream{enum: []}
+
+  defp take_every_after_guards([], _nth), do: %Stream{enum: []}
+
+  defp take_every_after_guards(enum, nth) do
+    lazy(enum, nth, fn f1 -> R.take_every(nth, f1) end)
+  end
 
   @doc """
   Lazily takes elements of the enumerable while the given
-  function returns `true`.
+  function returns a truthy value.
 
   ## Examples
 
       iex> stream = Stream.take_while(1..100, &(&1 <= 5))
       iex> Enum.to_list(stream)
-      [1,2,3,4,5]
+      [1, 2, 3, 4, 5]
 
   """
-  @spec take_while(Enumerable.t, (element -> as_boolean(term))) :: Enumerable.t
-  def take_while(enum, fun) do
-    lazy enum, fn(f1) -> R.take_while(fun, f1) end
+  @spec take_while(Enumerable.t(), (element -> as_boolean(term))) :: Enumerable.t()
+  def take_while(enum, fun) when is_function(fun, 1) do
+    lazy(enum, fn f1 -> R.take_while(fun, f1) end)
+  end
+
+  @doc """
+  Creates a stream that emits a single value after `n` milliseconds.
+
+  The value emitted is `0`. This operation will block the caller by
+  the given time until the element is streamed.
+
+  ## Examples
+
+      iex> Stream.timer(10) |> Enum.to_list()
+      [0]
+
+  """
+  @spec timer(timer()) :: Enumerable.t()
+  def timer(n)
+      when is_integer(n) and n >= 0
+      when n == :infinity do
+    take(interval(n), 1)
   end
 
   @doc """
   Transforms an existing stream.
 
-  It expects an accumulator and a function that receives each stream item
-  and an accumulator, and must return a tuple containing a new stream
-  (often a list) with the new accumulator or a tuple with `:halt` as first
-  element and the accumulator as second.
+  It expects an accumulator and a function that receives two arguments,
+  the stream element and the updated accumulator. It must return a tuple,
+  where the first element is a new stream (often a list) or the atom `:halt`,
+  and the second element is the accumulator to be used by the next element.
 
-  Note: this function is similar to `Enum.flat_map_reduce/3` except the
-  latter returns both the flat list and accumulator, while this one returns
-  only the stream.
+  Note: this function is equivalent to `Enum.flat_map_reduce/3`, except this
+  function does not return the accumulator once the stream is processed.
 
   ## Examples
 
-  `Stream.transform/3` is a useful as it can be used as basis to implement
+  `Stream.transform/3` is useful as it can be used as the basis to implement
   many of the functions defined in this module. For example, we can implement
   `Stream.take(enum, n)` as follows:
 
-      iex> enum = 1..100
+      iex> enum = 1001..9999
       iex> n = 3
       iex> stream = Stream.transform(enum, 0, fn i, acc ->
       ...>   if acc < n, do: {[i], acc + 1}, else: {:halt, acc}
       ...> end)
       iex> Enum.to_list(stream)
-      [1,2,3]
+      [1001, 1002, 1003]
+
+  `Stream.transform/5` further generalizes this function to allow wrapping
+  around resources.
+  """
+  @spec transform(Enumerable.t(), acc, fun) :: Enumerable.t()
+        when fun: (element, acc -> {Enumerable.t(), acc} | {:halt, acc}),
+             acc: term
+  def transform(enum, acc, reducer) when is_function(reducer, 2) do
+    &do_transform(enum, fn -> acc end, reducer, &1, &2, nil, fn acc -> acc end)
+  end
+
+  @doc """
+  Similar to `Stream.transform/5`, except `last_fun` is not supplied.
 
+  This function can be seen as a combination of `Stream.resource/3` with
+  `Stream.transform/3`.
   """
-  @spec transform(Enumerable.t, acc, fun) :: Enumerable.t when
-        fun: (element, acc -> {Enumerable.t, acc} | {:halt, acc}),
-        acc: any
-  def transform(enum, acc, reducer) do
-    &do_transform(enum, acc, reducer, &1, &2)
+  @spec transform(Enumerable.t(), start_fun, reducer, after_fun) :: Enumerable.t()
+        when start_fun: (-> acc),
+             reducer: (element, acc -> {Enumerable.t(), acc} | {:halt, acc}),
+             after_fun: (acc -> term),
+             acc: term
+  def transform(enum, start_fun, reducer, after_fun)
+      when is_function(start_fun, 0) and is_function(reducer, 2) and is_function(after_fun, 1) do
+    &do_transform(enum, start_fun, reducer, &1, &2, nil, after_fun)
   end
 
-  defp do_transform(enumerables, user_acc, user, inner_acc, fun) do
+  @doc """
+  Transforms an existing stream with function-based start, last, and after
+  callbacks.
+
+  Once transformation starts, `start_fun` is invoked to compute the initial
+  accumulator. Then, for each element in the enumerable, the `reducer` function
+  is invoked with the element and the accumulator, returning new elements and a
+  new accumulator, as in `transform/3`.
+
+  Once the collection is done, `last_fun` is invoked with the accumulator to
+  emit any remaining items. Then `after_fun` is invoked, to close any resource,
+  but not emitting any new items. `last_fun` is only invoked if the given
+  enumerable terminates successfully (either because it is done or it halted
+  itself). `after_fun` is always invoked, therefore `after_fun` must be the
+  one used for closing resources.
+  """
+  @doc since: "1.14.0"
+  @spec transform(Enumerable.t(), start_fun, reducer, last_fun, after_fun) :: Enumerable.t()
+        when start_fun: (-> acc),
+             reducer: (element, acc -> {Enumerable.t(), acc} | {:halt, acc}),
+             last_fun: (acc -> {Enumerable.t(), acc} | {:halt, acc}),
+             after_fun: (acc -> term),
+             acc: term
+  def transform(enum, start_fun, reducer, last_fun, after_fun)
+      when is_function(start_fun, 0) and is_function(reducer, 2) and is_function(last_fun, 1) and
+             is_function(after_fun, 1) do
+    &do_transform(enum, start_fun, reducer, &1, &2, last_fun, after_fun)
+  end
+
+  defp do_transform(enumerables, user_acc, user, inner_acc, fun, last_fun, after_fun) do
     inner = &do_transform_each(&1, &2, fun)
-    step  = &do_transform_step(&1, &2)
-    next  = &Enumerable.reduce(enumerables, &1, step)
-    do_transform(user_acc, user, fun, [], next, inner_acc, inner)
-  end
-
-  defp do_transform(user_acc, user, fun, next_acc, next, inner_acc, inner) do
-    case next.({:cont, next_acc}) do
-      {:suspended, [val|next_acc], next} ->
-        try do
-          user.(val, user_acc)
-        catch
-          kind, reason ->
-            stacktrace = System.stacktrace
-            next.({:halt, next_acc})
-            :erlang.raise(kind, reason, stacktrace)
-        else
-          {[], user_acc} ->
-            do_transform(user_acc, user, fun, next_acc, next, inner_acc, inner)
-          {list, user_acc} when is_list(list) ->
-            do_list_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, &Enumerable.List.reduce(list, &1, fun))
-          {:halt, _user_acc} ->
-            next.({:halt, next_acc})
-            {:halted, elem(inner_acc, 1)}
-          {other, user_acc} ->
-            do_other_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, &Enumerable.reduce(other, &1, inner))
-        end
-      {reason, _} ->
-        {reason, elem(inner_acc, 1)}
+    step = &do_transform_step(&1, &2)
+    next = &Enumerable.reduce(enumerables, &1, step)
+    funs = {user, fun, inner, last_fun, after_fun}
+    do_transform(user_acc.(), :cont, next, inner_acc, funs)
+  end
+
+  defp do_transform(user_acc, _next_op, next, {:halt, inner_acc}, funs) do
+    {_, _, _, _, after_fun} = funs
+    next.({:halt, []})
+    after_fun.(user_acc)
+    {:halted, inner_acc}
+  end
+
+  defp do_transform(user_acc, next_op, next, {:suspend, inner_acc}, funs) do
+    {:suspended, inner_acc, &do_transform(user_acc, next_op, next, &1, funs)}
+  end
+
+  defp do_transform(user_acc, :cont, next, inner_acc, funs) do
+    {_, _, _, _, after_fun} = funs
+
+    try do
+      next.({:cont, []})
+    catch
+      kind, reason ->
+        after_fun.(user_acc)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      {:suspended, vals, next} ->
+        do_transform_user(:lists.reverse(vals), user_acc, :cont, next, inner_acc, funs)
+
+      {_, vals} ->
+        # Do not attempt to call the resource again, it has either done or halted
+        next = fn _ -> {:done, []} end
+        do_transform_user(:lists.reverse(vals), user_acc, :last, next, inner_acc, funs)
+    end
+  end
+
+  defp do_transform(user_acc, :last, next, inner_acc, funs) do
+    {_, _, _, last_fun, after_fun} = funs
+
+    if last_fun do
+      try do
+        last_fun.(user_acc)
+      catch
+        kind, reason ->
+          after_fun.(user_acc)
+          :erlang.raise(kind, reason, __STACKTRACE__)
+      else
+        result -> do_transform_result(result, [], :halt, next, inner_acc, funs)
+      end
+    else
+      do_transform(user_acc, :halt, next, inner_acc, funs)
+    end
+  end
+
+  defp do_transform(user_acc, :halt, _next, inner_acc, funs) do
+    {_, _, _, _, after_fun} = funs
+    after_fun.(user_acc)
+    {:halted, elem(inner_acc, 1)}
+  end
+
+  defp do_transform_user([], user_acc, next_op, next, inner_acc, funs) do
+    do_transform(user_acc, next_op, next, inner_acc, funs)
+  end
+
+  defp do_transform_user([val | vals], user_acc, next_op, next, inner_acc, funs) do
+    {user, _, _, _, after_fun} = funs
+
+    try do
+      user.(val, user_acc)
+    catch
+      kind, reason ->
+        next.({:halt, []})
+        after_fun.(user_acc)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      result -> do_transform_result(result, vals, next_op, next, inner_acc, funs)
+    end
+  end
+
+  defp do_transform_result(result, vals, next_op, next, inner_acc, funs) do
+    {_, fun, inner, _, after_fun} = funs
+
+    case result do
+      {[], user_acc} ->
+        do_transform_user(vals, user_acc, next_op, next, inner_acc, funs)
+
+      {list, user_acc} when is_list(list) ->
+        reduce = &Enumerable.List.reduce(list, &1, fun)
+        do_transform_inner_list(vals, user_acc, next_op, next, inner_acc, reduce, funs)
+
+      {:halt, user_acc} ->
+        next.({:halt, []})
+        after_fun.(user_acc)
+        {:halted, elem(inner_acc, 1)}
+
+      {other, user_acc} ->
+        reduce = &Enumerable.reduce(other, &1, inner)
+        do_transform_inner_enum(vals, user_acc, next_op, next, inner_acc, reduce, funs)
     end
   end
 
-  defp do_list_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, reduce) do
+  defp do_transform_inner_list(vals, user_acc, next_op, next, inner_acc, reduce, funs) do
+    {_, _, _, _, after_fun} = funs
+
     try do
       reduce.(inner_acc)
     catch
       kind, reason ->
-        next.({:halt, next_acc})
-        :erlang.raise(kind, reason, :erlang.get_stacktrace)
+        next.({:halt, []})
+        after_fun.(user_acc)
+        :erlang.raise(kind, reason, __STACKTRACE__)
     else
       {:done, acc} ->
-        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner)
+        do_transform_user(vals, user_acc, next_op, next, {:cont, acc}, funs)
+
       {:halted, acc} ->
-        next.({:halt, next_acc})
+        next.({:halt, []})
+        after_fun.(user_acc)
         {:halted, acc}
-      {:suspended, acc, c} ->
-        {:suspended, acc, &do_list_transform(user_acc, user, fun, next_acc, next, &1, inner, c)}
+
+      {:suspended, acc, continuation} ->
+        resume = &do_transform_inner_list(vals, user_acc, next_op, next, &1, continuation, funs)
+        {:suspended, acc, resume}
     end
   end
 
-  defp do_other_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, reduce) do
+  defp do_transform_inner_enum(vals, user_acc, next_op, next, {op, inner_acc}, reduce, funs) do
+    {_, _, _, _, after_fun} = funs
+
     try do
-      reduce.(inner_acc)
+      reduce.({op, [:cont | inner_acc]})
     catch
-      {:stream_transform, h} ->
-        next.({:halt, next_acc})
-        {:halted, h}
       kind, reason ->
-        stacktrace = System.stacktrace
-        next.({:halt, next_acc})
-        :erlang.raise(kind, reason, stacktrace)
+        next.({:halt, []})
+        after_fun.(user_acc)
+        :erlang.raise(kind, reason, __STACKTRACE__)
     else
-      {_, acc} ->
-        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner)
-      {:suspended, acc, c} ->
-        {:suspended, acc, &do_other_transform(user_acc, user, fun, next_acc, next, &1, inner, c)}
+      # The user wanted to cont/suspend but the stream halted,
+      # so we continue with the user intention.
+      {:halted, [inner_op | acc]} when op != :halt and inner_op != :halt ->
+        do_transform_user(vals, user_acc, next_op, next, {inner_op, acc}, funs)
+
+      {:halted, [_ | acc]} ->
+        next.({:halt, []})
+        after_fun.(user_acc)
+        {:halted, acc}
+
+      {:done, [_ | acc]} ->
+        do_transform_user(vals, user_acc, next_op, next, {:cont, acc}, funs)
+
+      {:suspended, [_ | acc], continuation} ->
+        resume = &do_transform_inner_enum(vals, user_acc, next_op, next, &1, continuation, funs)
+        {:suspended, acc, resume}
     end
   end
 
-  defp do_transform_each(x, acc, f) do
+  defp do_transform_each(x, [:cont | acc], f) do
     case f.(x, acc) do
-      {:halt, h} -> throw({:stream_transform, h})
-      {_, _} = o -> o
+      {op, res} -> {op, [op | res]}
     end
   end
 
   defp do_transform_step(x, acc) do
-    {:suspend, [x|acc]}
+    {:suspend, [x | acc]}
   end
 
   @doc """
@@ -682,37 +1110,125 @@ defmodule Stream do
   Keep in mind that, in order to know if an element is unique
   or not, this function needs to store all unique values emitted
   by the stream. Therefore, if the stream is infinite, the number
-  of items stored will grow infinitely, never being garbage collected.
+  of elements stored will grow infinitely, never being garbage-collected.
+
+  ## Examples
+
+      iex> Stream.uniq([1, 2, 3, 3, 2, 1]) |> Enum.to_list()
+      [1, 2, 3]
+
+  """
+  @spec uniq(Enumerable.t()) :: Enumerable.t()
+  def uniq(enum) do
+    uniq_by(enum, fn x -> x end)
+  end
+
+  @doc false
+  @deprecated "Use Stream.uniq_by/2 instead"
+  def uniq(enum, fun) do
+    uniq_by(enum, fun)
+  end
+
+  @doc """
+  Creates a stream that only emits elements if they are unique, by removing the
+  elements for which function `fun` returned duplicate elements.
+
+  The function `fun` maps every element to a term which is used to
+  determine if two elements are duplicates.
+
+  Keep in mind that, in order to know if an element is unique
+  or not, this function needs to store all unique values emitted
+  by the stream. Therefore, if the stream is infinite, the number
+  of elements stored will grow infinitely, never being garbage-collected.
+
+  ## Example
+
+      iex> Stream.uniq_by([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end) |> Enum.to_list()
+      [{1, :x}, {2, :y}]
+
+      iex> Stream.uniq_by([a: {:tea, 2}, b: {:tea, 2}, c: {:coffee, 1}], fn {_, y} -> y end) |> Enum.to_list()
+      [a: {:tea, 2}, c: {:coffee, 1}]
+
+  """
+  @spec uniq_by(Enumerable.t(), (element -> term)) :: Enumerable.t()
+  def uniq_by(enum, fun) when is_function(fun, 1) do
+    lazy(enum, %{}, fn f1 -> R.uniq_by(fun, f1) end)
+  end
+
+  @doc """
+  Builds a stream from an index, either starting from offset, or given by function.
+
+  May receive a function or an integer offset.
+
+  If an `offset` is given, it will emit elements from offset.
+
+  If a `function` is given, it will invoke the function with
+  elements from offset.
 
   ## Examples
 
-      iex> Stream.uniq([1, 2, 3, 2, 1]) |> Enum.to_list
+      iex> Stream.from_index() |> Enum.take(3)
+      [0, 1, 2]
+
+      iex> Stream.from_index(1) |> Enum.take(3)
       [1, 2, 3]
 
-      iex> Stream.uniq([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end) |> Enum.to_list
-      [{1,:x}, {2,:y}]
+      iex> Stream.from_index(fn x -> x * 10 end) |> Enum.take(3)
+      [0, 10, 20]
 
   """
-  @spec uniq(Enumerable.t) :: Enumerable.t
-  @spec uniq(Enumerable.t, (element -> term)) :: Enumerable.t
-  def uniq(enum, fun \\ fn x -> x end) do
-    lazy enum, [], fn f1 -> R.uniq(fun, f1) end
+  @doc since: "1.17.0"
+  @spec from_index(integer) :: Enumerable.t(integer)
+  @spec from_index((integer -> return_value)) :: Enumerable.t(return_value)
+        when return_value: term
+  def from_index(fun_or_offset \\ 0)
+
+  def from_index(offset) when is_integer(offset) do
+    unfold(offset, &{&1, &1 + 1})
+  end
+
+  def from_index(fun) when is_function(fun) do
+    unfold(0, &{fun.(&1), &1 + 1})
   end
 
   @doc """
-  Creates a stream where each item in the enumerable will
-  be wrapped in a tuple alongside its index.
+  Creates a stream where each element in the enumerable will
+  be wrapped in a tuple alongside its index or according to a given function.
+
+  May receive a function or an integer offset.
+
+  If an `offset` is given, it will index from the given offset instead of from
+  zero.
+
+  If a `function` is given, it will index by invoking the function for each
+  element and index (zero-based) of the enumerable.
 
   ## Examples
 
       iex> stream = Stream.with_index([1, 2, 3])
       iex> Enum.to_list(stream)
-      [{1,0},{2,1},{3,2}]
+      [{1, 0}, {2, 1}, {3, 2}]
+
+      iex> stream = Stream.with_index([1, 2, 3], 3)
+      iex> Enum.to_list(stream)
+      [{1, 3}, {2, 4}, {3, 5}]
+
+      iex> stream = Stream.with_index([1, 2, 3], fn x, index -> x + index end)
+      iex> Enum.to_list(stream)
+      [1, 3, 5]
 
   """
-  @spec with_index(Enumerable.t) :: Enumerable.t
-  def with_index(enum) do
-    lazy enum, 0, fn(f1) -> R.with_index(f1) end
+  @spec with_index(Enumerable.t(), integer) :: Enumerable.t({element, integer})
+  @spec with_index(Enumerable.t(), (element, index -> return_value)) :: Enumerable.t(return_value)
+        when return_value: term
+  def with_index(enum, fun_or_offset \\ 0)
+
+  def with_index(enum, offset) when is_integer(offset) do
+    lazy(enum, offset, fn f1 -> R.with_index(f1) end)
+  end
+
+  def with_index(enum, fun) when is_function(fun, 2) do
+    lazy(enum, 0, fn f1 -> R.with_index(fun, f1) end)
   end
 
   ## Combiners
@@ -724,12 +1240,12 @@ defmodule Stream do
 
       iex> stream = Stream.concat([1..3, 4..6, 7..9])
       iex> Enum.to_list(stream)
-      [1,2,3,4,5,6,7,8,9]
+      [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
   """
-  @spec concat(Enumerable.t) :: Enumerable.t
+  @spec concat(Enumerable.t()) :: Enumerable.t()
   def concat(enumerables) do
-    flat_map(enumerables, &(&1))
+    flat_map(enumerables, & &1)
   end
 
   @doc """
@@ -739,91 +1255,132 @@ defmodule Stream do
 
       iex> stream = Stream.concat(1..3, 4..6)
       iex> Enum.to_list(stream)
-      [1,2,3,4,5,6]
+      [1, 2, 3, 4, 5, 6]
 
       iex> stream1 = Stream.cycle([1, 2, 3])
       iex> stream2 = Stream.cycle([4, 5, 6])
       iex> stream = Stream.concat(stream1, stream2)
       iex> Enum.take(stream, 6)
-      [1,2,3,1,2,3]
+      [1, 2, 3, 1, 2, 3]
 
   """
-  @spec concat(Enumerable.t, Enumerable.t) :: Enumerable.t
+  @spec concat(Enumerable.t(), Enumerable.t()) :: Enumerable.t()
   def concat(first, second) do
-    flat_map([first, second], &(&1))
+    flat_map([first, second], & &1)
   end
 
   @doc """
-  Zips two collections together, lazily.
+  Zips two enumerables together, lazily.
 
-  The zipping finishes as soon as any enumerable completes.
+  Because a list of two-element tuples with atoms as the first
+  tuple element is a keyword list (`Keyword`), zipping a first `Stream`
+  of atoms with a second `Stream` of any kind creates a `Stream`
+  that generates a keyword list.
+
+  The zipping finishes as soon as either enumerable completes.
 
   ## Examples
 
       iex> concat = Stream.concat(1..3, 4..6)
-      iex> cycle  = Stream.cycle([:a, :b, :c])
-      iex> Stream.zip(concat, cycle) |> Enum.to_list
-      [{1,:a},{2,:b},{3,:c},{4,:a},{5,:b},{6,:c}]
+      iex> cycle = Stream.cycle([:a, :b, :c])
+      iex> Stream.zip(concat, cycle) |> Enum.to_list()
+      [{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]
+      iex> Stream.zip(cycle, concat) |> Enum.to_list()
+      [a: 1, b: 2, c: 3, a: 4, b: 5, c: 6]
 
   """
-  @spec zip(Enumerable.t, Enumerable.t) :: Enumerable.t
-  def zip(left, right) do
-    step      = &do_zip_step(&1, &2)
-    left_fun  = &Enumerable.reduce(left, &1, step)
-    right_fun = &Enumerable.reduce(right, &1, step)
-
-    # Return a function as a lazy enumerator.
-    &do_zip([{left_fun, []}, {right_fun, []}], &1, &2)
+  @spec zip(Enumerable.t(), Enumerable.t()) :: Enumerable.t()
+  def zip(enumerable1, enumerable2) do
+    zip_with(enumerable1, enumerable2, fn left, right -> {left, right} end)
   end
 
-  defp do_zip(zips, {:halt, acc}, _fun) do
-    do_zip_close(zips)
-    {:halted, acc}
+  @doc """
+  Zips corresponding elements from a finite collection of enumerables
+  into one stream of tuples.
+
+  The zipping finishes as soon as any enumerable in the given collection completes.
+
+  ## Examples
+
+      iex> concat = Stream.concat(1..3, 4..6)
+      iex> cycle = Stream.cycle(["foo", "bar", "baz"])
+      iex> Stream.zip([concat, [:a, :b, :c], cycle]) |> Enum.to_list()
+      [{1, :a, "foo"}, {2, :b, "bar"}, {3, :c, "baz"}]
+
+  """
+  @doc since: "1.4.0"
+  @spec zip(enumerables) :: Enumerable.t() when enumerables: [Enumerable.t()] | Enumerable.t()
+  def zip(enumerables) do
+    zip_with(enumerables, &List.to_tuple(&1))
   end
 
-  defp do_zip(zips, {:suspend, acc}, fun) do
-    {:suspended, acc, &do_zip(zips, &1, fun)}
+  @doc """
+  Lazily zips corresponding elements from two enumerables into a new one, transforming them with
+  the `zip_fun` function as it goes.
+
+  The `zip_fun` will be called with the first element from `enumerable1` and the first
+  element from `enumerable2`, then with the second element from each, and so on until
+  either one of the enumerables completes.
+
+  ## Examples
+
+      iex> concat = Stream.concat(1..3, 4..6)
+      iex> Stream.zip_with(concat, concat, fn a, b -> a + b end) |> Enum.to_list()
+      [2, 4, 6, 8, 10, 12]
+
+  """
+  @doc since: "1.12.0"
+  @spec zip_with(Enumerable.t(), Enumerable.t(), (term, term -> term)) :: Enumerable.t()
+  def zip_with(enumerable1, enumerable2, zip_fun)
+      when is_list(enumerable1) and is_list(enumerable2) and is_function(zip_fun, 2) do
+    &zip_pair(enumerable1, enumerable2, &1, &2, zip_fun)
   end
 
-  defp do_zip(zips, {:cont, acc}, callback) do
-    try do
-      do_zip(zips, acc, callback, [], [])
-    catch
-      kind, reason ->
-        stacktrace = System.stacktrace
-        do_zip_close(zips)
-        :erlang.raise(kind, reason, stacktrace)
-    else
-      {:next, buffer, acc} ->
-        do_zip(buffer, acc, callback)
-      {:done, _} = o ->
-        o
-    end
+  def zip_with(enumerable1, enumerable2, zip_fun) when is_function(zip_fun, 2) do
+    zip_with([enumerable1, enumerable2], fn [left, right] -> zip_fun.(left, right) end)
   end
 
-  defp do_zip([{fun, fun_acc}|t], acc, callback, list, buffer) do
-    case fun.({:cont, fun_acc}) do
-      {:suspended, [i|fun_acc], fun} ->
-        do_zip(t, acc, callback, [i|list], [{fun, fun_acc}|buffer])
-      {_, _} ->
-        do_zip_close(:lists.reverse(buffer) ++ t)
-        {:done, acc}
-    end
+  defp zip_pair(_list1, _list2, {:halt, acc}, _fun, _zip_fun) do
+    {:halted, acc}
   end
 
-  defp do_zip([], acc, callback, list, buffer) do
-    zipped = List.to_tuple(:lists.reverse(list))
-    {:next, :lists.reverse(buffer), callback.(zipped, acc)}
+  defp zip_pair(list1, list2, {:suspend, acc}, fun, zip_fun) do
+    {:suspended, acc, &zip_pair(list1, list2, &1, fun, zip_fun)}
   end
 
-  defp do_zip_close([]), do: :ok
-  defp do_zip_close([{fun, acc}|t]) do
-    fun.({:halt, acc})
-    do_zip_close(t)
+  defp zip_pair([], _list2, {:cont, acc}, _fun, _zip_fun), do: {:done, acc}
+  defp zip_pair(_list1, [], {:cont, acc}, _fun, _zip_fun), do: {:done, acc}
+
+  defp zip_pair([head1 | tail1], [head2 | tail2], {:cont, acc}, fun, zip_fun) do
+    zip_pair(tail1, tail2, fun.(zip_fun.(head1, head2), acc), fun, zip_fun)
   end
 
-  defp do_zip_step(x, acc) do
-    {:suspend, [x|acc]}
+  @doc """
+  Lazily zips corresponding elements from a finite collection of enumerables into a new
+  enumerable, transforming them with the `zip_fun` function as it goes.
+
+  The first element from each of the enums in `enumerables` will be put into a list which is then passed to
+  the one-arity `zip_fun` function. Then, the second elements from each of the enums are put into a list and passed to
+  `zip_fun`, and so on until any one of the enums in `enumerables` completes.
+
+  Returns a new enumerable with the results of calling `zip_fun`.
+
+  ## Examples
+
+      iex> concat = Stream.concat(1..3, 4..6)
+      iex> Stream.zip_with([concat, concat], fn [a, b] -> a + b end) |> Enum.to_list()
+      [2, 4, 6, 8, 10, 12]
+
+      iex> concat = Stream.concat(1..3, 4..6)
+      iex> Stream.zip_with([concat, concat, 1..3], fn [a, b, c] -> a + b + c end) |> Enum.to_list()
+      [3, 6, 9]
+
+  """
+  @doc since: "1.12.0"
+  @spec zip_with(enumerables, (Enumerable.t() -> term)) :: Enumerable.t()
+        when enumerables: [Enumerable.t()] | Enumerable.t()
+  def zip_with(enumerables, zip_fun) do
+    R.zip_with(enumerables, zip_fun)
   end
 
   ## Sources
@@ -834,64 +1391,90 @@ defmodule Stream do
 
   ## Examples
 
-      iex> stream = Stream.cycle([1,2,3])
+      iex> stream = Stream.cycle([1, 2, 3])
       iex> Enum.take(stream, 5)
-      [1,2,3,1,2]
+      [1, 2, 3, 1, 2]
 
   """
-  @spec cycle(Enumerable.t) :: Enumerable.t
+  @spec cycle(Enumerable.t()) :: Enumerable.t()
+  def cycle(enumerable)
+
+  def cycle([]) do
+    raise ArgumentError, "cannot cycle over an empty enumerable"
+  end
+
+  def cycle(enumerable) when is_list(enumerable) do
+    unfold({enumerable, enumerable}, fn
+      {source, [h | t]} -> {h, {source, t}}
+      {source = [h | t], []} -> {h, {source, t}}
+    end)
+  end
+
   def cycle(enumerable) do
     fn acc, fun ->
-      inner = &do_cycle_each(&1, &2, fun)
-      outer = &Enumerable.reduce(enumerable, &1, inner)
-      do_cycle(outer, outer, acc)
+      step = &do_cycle_step(&1, &2)
+      cycle = &Enumerable.reduce(enumerable, &1, step)
+      reduce = check_cycle_first_element(cycle)
+      do_cycle(reduce, [], cycle, acc, fun)
     end
   end
 
-  defp do_cycle(_reduce, _cycle, {:halt, acc}) do
+  defp do_cycle(reduce, inner_acc, _cycle, {:halt, acc}, _fun) do
+    reduce.({:halt, inner_acc})
     {:halted, acc}
   end
 
-  defp do_cycle(reduce, cycle, {:suspend, acc}) do
-    {:suspended, acc, &do_cycle(reduce, cycle, &1)}
+  defp do_cycle(reduce, inner_acc, cycle, {:suspend, acc}, fun) do
+    {:suspended, acc, &do_cycle(reduce, inner_acc, cycle, &1, fun)}
   end
 
-  defp do_cycle(reduce, cycle, acc) do
-    try do
-      reduce.(acc)
-    catch
-      {:stream_cycle, acc} ->
-        {:halted, acc}
-    else
-      {state, acc} when state in [:done, :halted] ->
-        do_cycle(cycle, cycle, {:cont, acc})
-      {:suspended, acc, continuation} ->
-        {:suspended, acc, &do_cycle(continuation, cycle, &1)}
+  defp do_cycle(reduce, inner_acc, cycle, {:cont, acc}, fun) do
+    case reduce.({:cont, inner_acc}) do
+      {:suspended, [element], new_reduce} ->
+        do_cycle(new_reduce, inner_acc, cycle, fun.(element, acc), fun)
+
+      {_, [element]} ->
+        do_cycle(cycle, [], cycle, fun.(element, acc), fun)
+
+      {_, []} ->
+        do_cycle(cycle, [], cycle, {:cont, acc}, fun)
     end
   end
 
-  defp do_cycle_each(x, acc, f) do
-    case f.(x, acc) do
-      {:halt, h} -> throw({:stream_cycle, h})
-      {_, _} = o -> o
+  defp do_cycle_step(x, acc) do
+    {:suspend, [x | acc]}
+  end
+
+  defp check_cycle_first_element(reduce) do
+    fn acc ->
+      case reduce.(acc) do
+        {state, []} when state in [:done, :halted] and elem(acc, 0) != :halt ->
+          raise ArgumentError, "cannot cycle over an empty enumerable"
+
+        other ->
+          other
+      end
     end
   end
 
   @doc """
-  Emit a sequence of values, starting with `start_value`. Successive
-  values are generated by calling `next_fun` on the previous value.
+  Emits a sequence of values, starting with `start_value`.
+
+  Successive values are generated by calling `next_fun`
+  on the previous value.
 
   ## Examples
 
-      iex> Stream.iterate(0, &(&1+1)) |> Enum.take(5)
-      [0,1,2,3,4]
+      iex> Stream.iterate(1, &(&1 * 2)) |> Enum.take(5)
+      [1, 2, 4, 8, 16]
 
   """
-  @spec iterate(element, (element -> element)) :: Enumerable.t
-  def iterate(start_value, next_fun) do
+  @spec iterate(element, (element -> element)) :: Enumerable.t()
+  def iterate(start_value, next_fun) when is_function(next_fun, 1) do
     unfold({:ok, start_value}, fn
       {:ok, value} ->
         {value, {:next, value}}
+
       {:next, value} ->
         next = next_fun.(value)
         {next, {:next, next}}
@@ -903,11 +1486,13 @@ defmodule Stream do
 
   ## Examples
 
-      iex> Stream.repeatedly(&:random.uniform/0) |> Enum.take(3)
-      [0.4435846174457203, 0.7230402056221108, 0.94581636451987]
+      # Although not necessary, let's seed the random algorithm
+      iex> :rand.seed(:exsss, {1, 2, 3})
+      iex> Stream.repeatedly(&:rand.uniform/0) |> Enum.take(3)
+      [0.5455598952593053, 0.6039309974353404, 0.6684893034823949]
 
   """
-  @spec repeatedly((() -> element)) :: Enumerable.t
+  @spec repeatedly((-> element)) :: Enumerable.t()
   def repeatedly(generator_fun) when is_function(generator_fun, 0) do
     &do_repeatedly(generator_fun, &1, &2)
   end
@@ -927,32 +1512,52 @@ defmodule Stream do
   @doc """
   Emits a sequence of values for the given resource.
 
-  Similar to `unfold/2` but the initial value is computed lazily via
-  `start_fun` and executes an `after_fun` at the end of enumeration
-  (both in cases of success and failure).
+  Similar to `transform/3` but the initial accumulated value is
+  computed lazily via `start_fun` and executes an `after_fun` at
+  the end of enumeration (both in cases of success and failure).
 
   Successive values are generated by calling `next_fun` with the
   previous accumulator (the initial value being the result returned
-  by `start_fun`) and it must return a tuple with the current and
-  next accumulator. The enumeration finishes if it returns `nil`.
+  by `start_fun`) and it must return a tuple containing a list
+  of elements to be emitted and the next accumulator. The enumeration
+  finishes if it returns `{:halt, acc}`.
 
-  As the name says, this function is useful to stream values from
+  As the function name suggests, this function is useful to stream values from
   resources.
 
   ## Examples
 
-      Stream.resource(fn -> File.open!("sample") end,
-                      fn file ->
-                        case IO.read(file, :line) do
-                          data when is_binary(data) -> {data, file}
-                          _ -> nil
-                        end
-                      end,
-                      fn file -> File.close(file) end)
+      Stream.resource(
+        fn -> File.open!("sample") end,
+        fn file ->
+          case IO.read(file, :line) do
+            data when is_binary(data) -> {[data], file}
+            _ -> {:halt, file}
+          end
+        end,
+        fn file -> File.close(file) end
+      )
+
+      iex> Stream.resource(
+      ...>  fn ->
+      ...>    {:ok, pid} = StringIO.open("string")
+      ...>    pid
+      ...>  end,
+      ...>  fn pid ->
+      ...>    case IO.getn(pid, "", 1) do
+      ...>      :eof -> {:halt, pid}
+      ...>      char -> {[char], pid}
+      ...>    end
+      ...>  end,
+      ...>  fn pid -> StringIO.close(pid) end
+      ...> ) |> Enum.to_list()
+      ["s", "t", "r", "i", "n", "g"]
 
   """
-  @spec resource((() -> acc), (acc -> {element, acc} | nil), (acc -> term)) :: Enumerable.t
-  def resource(start_fun, next_fun, after_fun) do
+  @spec resource((-> acc), (acc -> {[element], acc} | {:halt, acc}), (acc -> term)) ::
+          Enumerable.t()
+  def resource(start_fun, next_fun, after_fun)
+      when is_function(start_fun, 0) and is_function(next_fun, 1) and is_function(after_fun, 1) do
     &do_resource(start_fun.(), next_fun, &1, &2, after_fun)
   end
 
@@ -967,24 +1572,89 @@ defmodule Stream do
 
   defp do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun) do
     try do
-      case next_fun.(next_acc) do
-        nil -> nil
-        {v, next_acc} -> {fun.(v, acc), next_acc}
-      end
+      next_fun.(next_acc)
     catch
       kind, reason ->
-        stacktrace = System.stacktrace
         after_fun.(next_acc)
-        :erlang.raise(kind, reason, stacktrace)
+        :erlang.raise(kind, reason, __STACKTRACE__)
     else
-      nil ->
+      {:halt, next_acc} ->
+        do_resource(next_acc, next_fun, {:halt, acc}, fun, after_fun)
+
+      {[], next_acc} ->
+        do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun)
+
+      {[v], next_acc} ->
+        do_element_resource(next_acc, next_fun, acc, fun, after_fun, v)
+
+      {list, next_acc} when is_list(list) ->
+        reduce = &Enumerable.List.reduce(list, &1, fun)
+        do_list_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun, reduce)
+
+      {enum, next_acc} ->
+        inner = &do_resource_each(&1, &2, fun)
+        reduce = &Enumerable.reduce(enum, &1, inner)
+        do_enum_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun, reduce)
+    end
+  end
+
+  defp do_element_resource(next_acc, next_fun, acc, fun, after_fun, v) do
+    try do
+      fun.(v, acc)
+    catch
+      kind, reason ->
         after_fun.(next_acc)
-        {:done, acc}
-      {acc, next_acc} ->
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      acc ->
         do_resource(next_acc, next_fun, acc, fun, after_fun)
     end
   end
 
+  defp do_list_resource(next_acc, next_fun, acc, fun, after_fun, reduce) do
+    try do
+      reduce.(acc)
+    catch
+      kind, reason ->
+        after_fun.(next_acc)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      {:done, acc} ->
+        do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun)
+
+      {:halted, acc} ->
+        do_resource(next_acc, next_fun, {:halt, acc}, fun, after_fun)
+
+      {:suspended, acc, c} ->
+        {:suspended, acc, &do_list_resource(next_acc, next_fun, &1, fun, after_fun, c)}
+    end
+  end
+
+  defp do_enum_resource(next_acc, next_fun, {op, acc}, fun, after_fun, reduce) do
+    try do
+      reduce.({op, [:cont | acc]})
+    catch
+      kind, reason ->
+        after_fun.(next_acc)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      {:halted, [inner_op | acc]} ->
+        do_resource(next_acc, next_fun, {inner_op, acc}, fun, after_fun)
+
+      {:done, [_ | acc]} ->
+        do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun)
+
+      {:suspended, [_ | acc], c} ->
+        {:suspended, acc, &do_enum_resource(next_acc, next_fun, &1, fun, after_fun, c)}
+    end
+  end
+
+  defp do_resource_each(x, [:cont | acc], f) do
+    case f.(x, acc) do
+      {op, res} -> {op, [op | res]}
+    end
+  end
+
   @doc """
   Emits a sequence of values for the given accumulator.
 
@@ -994,12 +1664,29 @@ defmodule Stream do
 
   ## Examples
 
-      iex> Stream.unfold(5, fn 0 -> nil; n -> {n, n-1} end) |> Enum.to_list()
+  To create a stream that counts down and stops before zero:
+
+      iex> Stream.unfold(5, fn
+      ...>   0 -> nil
+      ...>   n -> {n, n - 1}
+      ...> end) |> Enum.to_list()
       [5, 4, 3, 2, 1]
 
+  If `next_fun` never returns `nil`, the returned stream is *infinite*:
+
+      iex> Stream.unfold(0, fn
+      ...>   n -> {n, n + 1}
+      ...> end) |> Enum.take(10)
+      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      iex> Stream.unfold(1, fn
+      ...>   n -> {n, n * 2}
+      ...> end) |> Enum.take(10)
+      [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+
   """
-  @spec unfold(acc, (acc -> {element, acc} | nil)) :: Enumerable.t
-  def unfold(next_acc, next_fun) do
+  @spec unfold(acc, (acc -> {element, acc} | nil)) :: Enumerable.t()
+  def unfold(next_acc, next_fun) when is_function(next_fun, 1) do
     &do_unfold(next_acc, next_fun, &1, &2)
   end
 
@@ -1013,33 +1700,61 @@ defmodule Stream do
 
   defp do_unfold(next_acc, next_fun, {:cont, acc}, fun) do
     case next_fun.(next_acc) do
-      nil           -> {:done, acc}
+      nil -> {:done, acc}
       {v, next_acc} -> do_unfold(next_acc, next_fun, fun.(v, acc), fun)
     end
   end
 
+  @doc """
+  Lazily intersperses `intersperse_element` between each element of the enumeration.
+
+  ## Examples
+
+      iex> Stream.intersperse([1, 2, 3], 0) |> Enum.to_list()
+      [1, 0, 2, 0, 3]
+
+      iex> Stream.intersperse([1], 0) |> Enum.to_list()
+      [1]
+
+      iex> Stream.intersperse([], 0) |> Enum.to_list()
+      []
+
+  """
+  @doc since: "1.6.0"
+  @spec intersperse(Enumerable.t(), any) :: Enumerable.t()
+  def intersperse(enumerable, intersperse_element) do
+    Stream.transform(enumerable, false, fn
+      element, true -> {[intersperse_element, element], true}
+      element, false -> {[element], true}
+    end)
+  end
+
   ## Helpers
 
   @compile {:inline, lazy: 2, lazy: 3, lazy: 4}
 
-  defp lazy(%Stream{funs: funs} = lazy, fun),
-    do: %{lazy | funs: [fun|funs] }
-  defp lazy(enum, fun),
-    do: %Stream{enum: enum, funs: [fun]}
+  defp lazy(%Stream{done: nil, funs: funs} = lazy, fun), do: %{lazy | funs: [fun | funs]}
+  defp lazy(enum, fun), do: %Stream{enum: enum, funs: [fun]}
+
+  defp lazy(%Stream{done: nil, funs: funs, accs: accs} = lazy, acc, fun),
+    do: %{lazy | funs: [fun | funs], accs: [acc | accs]}
 
-  defp lazy(%Stream{funs: funs, accs: accs} = lazy, acc, fun),
-    do: %{lazy | funs: [fun|funs], accs: [acc|accs] }
-  defp lazy(enum, acc, fun),
-    do: %Stream{enum: enum, funs: [fun], accs: [acc]}
+  defp lazy(enum, acc, fun), do: %Stream{enum: enum, funs: [fun], accs: [acc]}
 
   defp lazy(%Stream{done: nil, funs: funs, accs: accs} = lazy, acc, fun, done),
-    do: %{lazy | funs: [fun|funs], accs: [acc|accs], done: done}
-  defp lazy(enum, acc, fun, done),
-    do: %Stream{enum: enum, funs: [fun], accs: [acc], done: done}
+    do: %{lazy | funs: [fun | funs], accs: [acc | accs], done: done}
+
+  defp lazy(enum, acc, fun, done), do: %Stream{enum: enum, funs: [fun], accs: [acc], done: done}
 end
 
 defimpl Enumerable, for: Stream do
-  @compile :inline_list_funs
+  @compile :inline_list_funcs
+
+  def count(_lazy), do: {:error, __MODULE__}
+
+  def member?(_lazy, _value), do: {:error, __MODULE__}
+
+  def slice(_lazy), do: {:error, __MODULE__}
 
   def reduce(lazy, acc, fun) do
     do_reduce(lazy, acc, fn x, [acc] ->
@@ -1048,37 +1763,44 @@ defimpl Enumerable, for: Stream do
     end)
   end
 
-  def count(_lazy) do
-    {:error, __MODULE__}
-  end
-
-  def member?(_lazy, _value) do
-    {:error, __MODULE__}
-  end
-
   defp do_reduce(%Stream{enum: enum, funs: funs, accs: accs, done: done}, acc, fun) do
-    composed = :lists.foldl(fn fun, acc -> fun.(acc) end, fun, funs)
-    do_each(&Enumerable.reduce(enum, &1, composed),
-            done && {done, fun}, :lists.reverse(accs), acc)
+    composed = :lists.foldl(fn entry_fun, acc -> entry_fun.(acc) end, fun, funs)
+    reduce = &Enumerable.reduce(enum, &1, composed)
+    do_each(reduce, done && {done, fun}, :lists.reverse(accs), acc)
   end
 
   defp do_each(reduce, done, accs, {command, acc}) do
-    case reduce.({command, [acc|accs]}) do
-      {:suspended, [acc|accs], continuation} ->
+    case reduce.({command, [acc | accs]}) do
+      {:suspended, [acc | accs], continuation} ->
         {:suspended, acc, &do_each(continuation, done, accs, &1)}
-      {:halted, [acc|_]} ->
-        {:halted, acc}
-      {:done, [acc|_] = accs} ->
-        case done do
-          nil ->
-            {:done, acc}
-          {done, fun} ->
-            case done.(fun).(accs) do
-              {:cont, [acc|_]}    -> {:done, acc}
-              {:halt, [acc|_]}    -> {:halted, acc}
-              {:suspend, [acc|_]} -> {:suspended, acc, &({:done, elem(&1, 1)})}
-            end
-        end
+
+      {:halted, accs} ->
+        do_done({:halted, accs}, done)
+
+      {:done, accs} ->
+        do_done({:done, accs}, done)
     end
   end
+
+  defp do_done({reason, [acc | _]}, nil), do: {reason, acc}
+
+  defp do_done({reason, [acc | t]}, {done, fun}) do
+    [h | _] = :lists.reverse(t)
+
+    case done.([acc, h], fun) do
+      {:cont, [acc | _]} -> {reason, acc}
+      {:halt, [acc | _]} -> {:halted, acc}
+      {:suspend, [acc | _]} -> {:suspended, acc, &{:done, elem(&1, 1)}}
+    end
+  end
+end
+
+defimpl Inspect, for: Stream do
+  import Inspect.Algebra
+
+  def inspect(%{enum: enum, funs: funs}, opts) do
+    inner = [enum: enum, funs: :lists.reverse(funs)]
+    {doc, opts} = to_doc_with_opts(inner, opts)
+    {concat(["#Stream<", doc, ">"]), opts}
+  end
 end
diff --git a/lib/elixir/lib/stream/reducers.ex b/lib/elixir/lib/stream/reducers.ex
index 18659600fd5..28ae03a17f0 100644
--- a/lib/elixir/lib/stream/reducers.ex
+++ b/lib/elixir/lib/stream/reducers.ex
@@ -1,163 +1,362 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Stream.Reducers do
-  # Collection of reducers shared by Enum and Stream.
+  # Collection of reducers and utilities shared by Enum and Stream.
   @moduledoc false
 
-  defmacro chunk(n, step, limit, f \\ nil) do
-    quote do
-      fn entry, acc(h, {buffer, count}, t) ->
-        buffer = [entry|buffer]
-        count  = count + 1
+  def zip_with(enumerables, zip_fun) when is_function(zip_fun, 1) do
+    if is_list(enumerables) and :lists.all(&is_list/1, enumerables) do
+      &zip_list(enumerables, &1, &2, zip_fun)
+    else
+      &zip_enum(enumerables, &1, &2, zip_fun)
+    end
+  end
+
+  defp zip_list(_enumerables, {:halt, acc}, _fun, _zip_fun) do
+    {:halted, acc}
+  end
+
+  defp zip_list(enumerables, {:suspend, acc}, fun, zip_fun) do
+    {:suspended, acc, &zip_list(enumerables, &1, fun, zip_fun)}
+  end
+
+  defp zip_list([], {:cont, acc}, _fun, _zip_fun), do: {:done, acc}
+
+  defp zip_list(enumerables, {:cont, acc}, fun, zip_fun) do
+    case zip_list_heads_tails(enumerables, [], []) do
+      {heads, tails} -> zip_list(tails, fun.(zip_fun.(heads), acc), fun, zip_fun)
+      :error -> {:done, acc}
+    end
+  end
+
+  defp zip_list_heads_tails([[head | tail] | rest], heads, tails) do
+    zip_list_heads_tails(rest, [head | heads], [tail | tails])
+  end
+
+  defp zip_list_heads_tails([[] | _rest], _heads, _tails) do
+    :error
+  end
+
+  defp zip_list_heads_tails([], heads, tails) do
+    {:lists.reverse(heads), :lists.reverse(tails)}
+  end
+
+  defp zip_enum(enumerables, acc, fun, zip_fun) do
+    step = fn x, acc ->
+      {:suspend, :lists.reverse([x | acc])}
+    end
+
+    enum_funs =
+      Enum.map(enumerables, fn enum ->
+        {&Enumerable.reduce(enum, &1, step), [], :cont}
+      end)
+
+    do_zip_enum(enum_funs, acc, fun, zip_fun)
+  end
 
-        new =
-          if count >= unquote(limit) do
-            left = count - unquote(step)
-            {Enum.take(buffer, left), left}
-          else
-            {buffer, count}
-          end
+  # This implementation of do_zip_enum/4 works for any number of streams to zip
+  defp do_zip_enum(zips, {:halt, acc}, _fun, _zip_fun) do
+    do_zip_close(zips)
+    {:halted, acc}
+  end
+
+  defp do_zip_enum(zips, {:suspend, acc}, fun, zip_fun) do
+    {:suspended, acc, &do_zip_enum(zips, &1, fun, zip_fun)}
+  end
+
+  defp do_zip_enum([], {:cont, acc}, _callback, _zip_fun) do
+    {:done, acc}
+  end
+
+  defp do_zip_enum(zips, {:cont, acc}, callback, zip_fun) do
+    try do
+      do_zip_next(zips, acc, callback, [], [], zip_fun)
+    catch
+      kind, reason ->
+        do_zip_close(zips)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      {:next, buffer, acc} ->
+        do_zip_enum(buffer, acc, callback, zip_fun)
+
+      {:done, _acc} = other ->
+        other
+    end
+  end
+
+  # do_zip_next/6 computes the next tuple formed by
+  # the next element of each zipped stream.
+  defp do_zip_next(
+         [{_, [], :halt} | zips],
+         acc,
+         _callback,
+         _yielded_elems,
+         buffer,
+         _zip_fun
+       ) do
+    do_zip_close(:lists.reverse(buffer, zips))
+    {:done, acc}
+  end
+
+  defp do_zip_next([{fun, [], :cont} | zips], acc, callback, yielded_elems, buffer, zip_fun) do
+    case fun.({:cont, []}) do
+      {:suspended, [elem | next_acc], fun} ->
+        next_buffer = [{fun, next_acc, :cont} | buffer]
+        do_zip_next(zips, acc, callback, [elem | yielded_elems], next_buffer, zip_fun)
+
+      {_, [elem | next_acc]} ->
+        next_buffer = [{fun, next_acc, :halt} | buffer]
+        do_zip_next(zips, acc, callback, [elem | yielded_elems], next_buffer, zip_fun)
+
+      {_, []} ->
+        # The current zipped stream terminated, so we close all the streams
+        # and return {:halted, acc} (which is returned as is by do_zip/3).
+        do_zip_close(:lists.reverse(buffer, zips))
+        {:done, acc}
+    end
+  end
+
+  defp do_zip_next(
+         [{fun, zip_acc, zip_op} | zips],
+         acc,
+         callback,
+         yielded_elems,
+         buffer,
+         zip_fun
+       ) do
+    [elem | rest] = zip_acc
+    next_buffer = [{fun, rest, zip_op} | buffer]
+    do_zip_next(zips, acc, callback, [elem | yielded_elems], next_buffer, zip_fun)
+  end
+
+  defp do_zip_next([] = _zips, acc, callback, yielded_elems, buffer, zip_fun) do
+    # "yielded_elems" is a reversed list of results for the current iteration of
+    # zipping. That is to say, the nth element from each of the enums being zipped.
+    # It needs to be reversed and passed to the zipping function so it can do it's thing.
+    {:next, :lists.reverse(buffer), callback.(zip_fun.(:lists.reverse(yielded_elems)), acc)}
+  end
+
+  defp do_zip_close(zips) do
+    :lists.foreach(fn {fun, _, _} -> fun.({:halt, []}) end, zips)
+  end
 
-        if count == unquote(n) do
-          cont_with_acc(unquote(f), :lists.reverse(buffer), h, new, t)
+  def chunk_every(chunk_by, enumerable, count, step, leftover) do
+    limit = :erlang.max(count, step)
+
+    chunk_fun = fn entry, {acc_buffer, acc_count} ->
+      acc_buffer = [entry | acc_buffer]
+      acc_count = acc_count + 1
+
+      new_state =
+        if acc_count >= limit do
+          remaining = acc_count - step
+          {Enum.take(acc_buffer, remaining), remaining}
         else
-          {:cont, acc(h, new, t)}
+          {acc_buffer, acc_count}
+        end
+
+      if acc_count == count do
+        {:cont, :lists.reverse(acc_buffer), new_state}
+      else
+        {:cont, new_state}
+      end
+    end
+
+    after_fun = fn {acc_buffer, acc_count} ->
+      if leftover == :discard or acc_count == 0 or acc_count >= count do
+        {:cont, []}
+      else
+        {:cont, :lists.reverse(acc_buffer, Enum.take(leftover, count - acc_count)), []}
+      end
+    end
+
+    chunk_by.(enumerable, {[], 0}, chunk_fun, after_fun)
+  end
+
+  def chunk_by(chunk_by, enumerable, fun) do
+    chunk_fun = fn
+      entry, nil ->
+        {:cont, {[entry], fun.(entry)}}
+
+      entry, {acc, value} ->
+        case fun.(entry) do
+          ^value -> {:cont, {[entry | acc], value}}
+          new_value -> {:cont, :lists.reverse(acc), {[entry], new_value}}
+        end
+    end
+
+    after_fun = fn
+      nil -> {:cont, :done}
+      {acc, _value} -> {:cont, :lists.reverse(acc), :done}
+    end
+
+    chunk_by.(enumerable, nil, chunk_fun, after_fun)
+  end
+
+  defmacro dedup(callback, fun \\ nil) do
+    quote do
+      fn entry, acc(head, prev, tail) = acc ->
+        value = unquote(callback).(entry)
+
+        case prev do
+          {:value, ^value} -> skip(acc)
+          _ -> next_with_acc(unquote(fun), entry, head, {:value, value}, tail)
         end
       end
     end
   end
 
-  defmacro chunk_by(callback, f \\ nil) do
+  defmacro drop(fun \\ nil) do
     quote do
       fn
-        entry, acc(h, {buffer, value}, t) ->
-          new_value = unquote(callback).(entry)
-          if new_value == value do
-            {:cont, acc(h, {[entry|buffer], value}, t)}
-          else
-            cont_with_acc(unquote(f), :lists.reverse(buffer), h, {[entry], new_value}, t)
-          end
-        entry, acc(h, nil, t) ->
-          {:cont, acc(h, {[entry], unquote(callback).(entry)}, t)}
+        _entry, acc(head, amount, tail) when amount > 0 ->
+          skip(acc(head, amount - 1, tail))
+
+        entry, acc(head, amount, tail) ->
+          next_with_acc(unquote(fun), entry, head, amount, tail)
       end
     end
   end
 
-  defmacro drop(f \\ nil) do
+  defmacro drop_every(nth, fun \\ nil) do
     quote do
       fn
-        _entry, acc(h, n, t) when n > 0 ->
-          {:cont, acc(h, n-1, t)}
-        entry, acc(h, n, t) ->
-          cont_with_acc(unquote(f), entry, h, n, t)
+        entry, acc(head, curr, tail) when curr in [unquote(nth), :first] ->
+          skip(acc(head, 1, tail))
+
+        entry, acc(head, curr, tail) ->
+          next_with_acc(unquote(fun), entry, head, curr + 1, tail)
       end
     end
   end
 
-  defmacro drop_while(callback, f \\ nil) do
+  defmacro drop_while(callback, fun \\ nil) do
     quote do
-      fn entry, acc(h, bool, t) = orig ->
+      fn entry, acc(head, bool, tail) = original ->
         if bool and unquote(callback).(entry) do
-          {:cont, orig}
+          skip(original)
         else
-          cont_with_acc(unquote(f), entry, h, false, t)
+          next_with_acc(unquote(fun), entry, head, false, tail)
         end
       end
     end
   end
 
-  defmacro filter(callback, f \\ nil) do
+  defmacro filter(callback, fun \\ nil) do
     quote do
-      fn(entry, acc) ->
+      fn entry, acc ->
         if unquote(callback).(entry) do
-          cont(unquote(f), entry, acc)
+          next(unquote(fun), entry, acc)
         else
-          {:cont, acc}
+          skip(acc)
         end
       end
     end
   end
 
-  defmacro filter_map(filter, mapper, f \\ nil) do
+  defmacro filter_map(filter, mapper, fun \\ nil) do
     quote do
-      fn(entry, acc) ->
+      fn entry, acc ->
         if unquote(filter).(entry) do
-          cont(unquote(f), unquote(mapper).(entry), acc)
+          next(unquote(fun), unquote(mapper).(entry), acc)
         else
-          {:cont, acc}
+          skip(acc)
         end
       end
     end
   end
 
-  defmacro map(callback, f \\ nil) do
+  defmacro map(callback, fun \\ nil) do
     quote do
-      fn(entry, acc) ->
-        cont(unquote(f), unquote(callback).(entry), acc)
+      fn entry, acc ->
+        next(unquote(fun), unquote(callback).(entry), acc)
       end
     end
   end
 
-  defmacro reject(callback, f \\ nil) do
+  defmacro map_every(nth, mapper, fun \\ nil) do
     quote do
-      fn(entry, acc) ->
-        unless unquote(callback).(entry) do
-          cont(unquote(f), entry, acc)
+      fn
+        entry, acc(head, curr, tail) when curr in [unquote(nth), :first] ->
+          next_with_acc(unquote(fun), unquote(mapper).(entry), head, 1, tail)
+
+        entry, acc(head, curr, tail) ->
+          next_with_acc(unquote(fun), entry, head, curr + 1, tail)
+      end
+    end
+  end
+
+  defmacro reject(callback, fun \\ nil) do
+    quote do
+      fn entry, acc ->
+        if unquote(callback).(entry) do
+          skip(acc)
         else
-          {:cont, acc}
+          next(unquote(fun), entry, acc)
         end
       end
     end
   end
 
-  defmacro scan_2(callback, f \\ nil) do
+  defmacro scan2(callback, fun \\ nil) do
     quote do
       fn
-        entry, acc(h, :first, t) ->
-          cont_with_acc(unquote(f), entry, h, {:ok, entry}, t)
-        entry, acc(h, {:ok, acc}, t) ->
+        entry, acc(head, :first, tail) ->
+          next_with_acc(unquote(fun), entry, head, {:ok, entry}, tail)
+
+        entry, acc(head, {:ok, acc}, tail) ->
           value = unquote(callback).(entry, acc)
-          cont_with_acc(unquote(f), value, h, {:ok, value}, t)
+          next_with_acc(unquote(fun), value, head, {:ok, value}, tail)
       end
     end
   end
 
-  defmacro scan_3(callback, f \\ nil) do
+  defmacro scan3(callback, fun \\ nil) do
     quote do
-      fn(entry, acc(h, acc, t)) ->
+      fn entry, acc(head, acc, tail) ->
         value = unquote(callback).(entry, acc)
-        cont_with_acc(unquote(f), value, h, value, t)
+        next_with_acc(unquote(fun), value, head, value, tail)
       end
     end
   end
 
-  defmacro take(f \\ nil) do
+  defmacro take(fun \\ nil) do
     quote do
-      fn(entry, acc(h, n, t) = orig) ->
-        if n >= 1 do
-          cont_with_acc(unquote(f), entry, h, n-1, t)
-        else
-          {:halt, orig}
+      fn entry, acc(head, curr, tail) = original ->
+        case curr do
+          0 ->
+            {:halt, original}
+
+          1 ->
+            {_, acc} = next_with_acc(unquote(fun), entry, head, 0, tail)
+            {:halt, acc}
+
+          _ ->
+            next_with_acc(unquote(fun), entry, head, curr - 1, tail)
         end
       end
     end
   end
 
-  defmacro take_every(nth, f \\ nil) do
+  defmacro take_every(nth, fun \\ nil) do
     quote do
       fn
-        entry, acc(h, n, t) when n === :first
-                            when n === unquote(nth) ->
-          cont_with_acc(unquote(f), entry, h, 1, t)
-        entry, acc(h, n, t) ->
-          {:cont, acc(h, n+1, t)}
+        entry, acc(head, curr, tail) when curr in [unquote(nth), :first] ->
+          next_with_acc(unquote(fun), entry, head, 1, tail)
+
+        entry, acc(head, curr, tail) ->
+          skip(acc(head, curr + 1, tail))
       end
     end
   end
 
-  defmacro take_while(callback, f \\ nil) do
+  defmacro take_while(callback, fun \\ nil) do
     quote do
-      fn(entry, acc) ->
+      fn entry, acc ->
         if unquote(callback).(entry) do
-          cont(unquote(f), entry, acc)
+          next(unquote(fun), entry, acc)
         else
           {:halt, acc}
         end
@@ -165,23 +364,32 @@ defmodule Stream.Reducers do
     end
   end
 
-  defmacro uniq(callback, f \\ nil) do
+  defmacro uniq_by(callback, fun \\ nil) do
     quote do
-      fn(entry, acc(h, prev, t) = acc) ->
+      fn entry, acc(head, prev, tail) = original ->
         value = unquote(callback).(entry)
-        if :lists.member(value, prev) do
-          {:cont, acc}
+
+        if Map.has_key?(prev, value) do
+          skip(original)
         else
-          cont_with_acc(unquote(f), entry, h, [value|prev], t)
+          next_with_acc(unquote(fun), entry, head, Map.put(prev, value, true), tail)
         end
       end
     end
   end
 
-  defmacro with_index(f \\ nil) do
+  defmacro with_index(fun) do
+    quote do
+      fn entry, acc(head, counter, tail) ->
+        next_with_acc(unquote(fun), {entry, counter}, head, counter + 1, tail)
+      end
+    end
+  end
+
+  defmacro with_index(callback, fun) do
     quote do
-      fn(entry, acc(h, counter, t)) ->
-        cont_with_acc(unquote(f), {entry, counter}, h, counter + 1, t)
+      fn entry, acc(head, counter, tail) ->
+        next_with_acc(unquote(fun), unquote(callback).(entry, counter), head, counter + 1, tail)
       end
     end
   end
diff --git a/lib/elixir/lib/string.ex b/lib/elixir/lib/string.ex
index b0895253346..44aaffe088c 100644
--- a/lib/elixir/lib/string.ex
+++ b/lib/elixir/lib/string.ex
@@ -1,158 +1,380 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 import Kernel, except: [length: 1]
 
 defmodule String do
   @moduledoc ~S"""
-  A String in Elixir is a UTF-8 encoded binary.
-
-  ## String and binary operations
+  Strings in Elixir are UTF-8 encoded binaries.
+
+  Strings in Elixir are a sequence of Unicode characters,
+  typically written between double quoted strings, such
+  as `"hello"` and `"héllò"`.
+
+  In case a string must have a double-quote in itself,
+  the double quotes must be escaped with a backslash,
+  for example: `"this is a string with \"double quotes\""`.
+
+  You can concatenate two strings with the `<>/2` operator:
+
+      iex> "hello" <> " " <> "world"
+      "hello world"
+
+  The functions in this module act according to
+  [The Unicode Standard, Version 17.0.0](http://www.unicode.org/versions/Unicode17.0.0/).
+
+  ## Interpolation
+
+  Strings in Elixir also support interpolation. This allows
+  you to place some value in the middle of a string by using
+  the `#{}` syntax:
+
+      iex> name = "joe"
+      iex> "hello #{name}"
+      "hello joe"
+
+  Any Elixir expression is valid inside the interpolation.
+  If a string is given, the string is interpolated as is.
+  If any other value is given, Elixir will attempt to convert
+  it to a string using the `String.Chars` protocol. This
+  allows, for example, to output an integer from the interpolation:
+
+      iex> "2 + 2 = #{2 + 2}"
+      "2 + 2 = 4"
+
+  In case the value you want to interpolate cannot be
+  converted to a string, because it doesn't have a human
+  textual representation, a protocol error will be raised.
+
+  ## Escape characters
+
+  Besides allowing double-quotes to be escaped with a backslash,
+  strings also support the following escape characters:
+
+    * `\0` - Null byte
+    * `\a` - Bell
+    * `\b` - Backspace
+    * `\t` - Horizontal tab
+    * `\n` - Line feed (New lines)
+    * `\v` - Vertical tab
+    * `\f` - Form feed
+    * `\r` - Carriage return
+    * `\e` - Command Escape
+    * `\s` - Space
+    * `\#` - Returns the `#` character itself, skipping interpolation
+    * `\\` - Single backslash
+    * `\xNN` - A byte represented by the hexadecimal `NN`
+    * `\uNNNN` - A Unicode code point represented by `NNNN`
+    * `\u{NNNNNN}` - A Unicode code point represented by `NNNNNN`
+
+  Note it is generally not advised to use `\xNN` in Elixir
+  strings, as introducing an invalid byte sequence would
+  make the string invalid. If you have to introduce a
+  character by its hexadecimal representation, it is best
+  to work with Unicode code points, such as `\uNNNN`. In fact,
+  understanding Unicode code points can be essential when doing
+  low-level manipulations of string, so let's explore them in
+  detail next.
+
+  ## Unicode and code points
+
+  In order to facilitate meaningful communication between computers
+  across multiple languages, a standard is required so that the ones
+  and zeros on one machine mean the same thing when they are transmitted
+  to another. The Unicode Standard acts as an official registry of
+  virtually all the characters we know: this includes characters from
+  classical and historical texts, emoji, and formatting and control
+  characters as well.
+
+  Unicode organizes all of the characters in its repertoire into code
+  charts, and each character is given a unique numerical index. This
+  numerical index is known as a Code Point.
+
+  In Elixir you can use a `?` in front of a character literal to reveal
+  its code point:
+
+      iex> ?a
+      97
+      iex> ?ł
+      322
+
+  Note that most Unicode code charts will refer to a code point by its
+  hexadecimal (hex) representation, e.g. `97` translates to `0061` in hex,
+  and we can represent any Unicode character in an Elixir string by
+  using the `\u` escape character followed by its code point number:
+
+      iex> "\u0061" === "a"
+      true
+      iex> 0x0061 = 97 = ?a
+      97
 
-  The functions in this module act according to the
-  Unicode Standard, version 6.3.0. For example,
-  `capitalize/1`, `downcase/1`, `strip/1` are provided by this
-  module.
+  The hex representation will also help you look up information about a
+  code point, e.g. [https://codepoints.net/U+0061](https://codepoints.net/U+0061)
+  has a data sheet all about the lower case `a`, a.k.a. code point 97.
+  Remember you can get the hex presentation of a number by calling
+  `Integer.to_string/2`:
 
-  In addition to this module, Elixir provides more low-level
-  operations that work directly with binaries. Some
-  of those can be found in the `Kernel` module, as:
+      iex> Integer.to_string(?a, 16)
+      "61"
 
-    * `Kernel.binary_part/3` - retrieves part of the binary
-    * `Kernel.bit_size/1` and `Kernel.byte_size/1` - size related functions
-    * `Kernel.is_bitstring/1` and `Kernel.is_binary/1` - type checking function
-    * Plus a number of functions for working with binaries (bytes)
-      [in the `:binary` module](http://erlang.org/doc/man/binary.html)
+  ## UTF-8 encoded and encodings
 
-  ## Codepoints and graphemes
+  Now that we understand what the Unicode standard is and what code points
+  are, we can finally talk about encodings. Whereas the code point is **what**
+  we store, an encoding deals with **how** we store it: encoding is an
+  implementation. In other words, we need a mechanism to convert the code
+  point numbers into bytes so they can be stored in memory, written to disk, and such.
 
-  As per the Unicode Standard, a codepoint is an Unicode
-  Character, which may be represented by one or more bytes.
-  For example, the character "é" is represented with two
-  bytes:
+  Elixir uses UTF-8 to encode its strings, which means that code points are
+  encoded as a series of 8-bit bytes. UTF-8 is a **variable width** character
+  encoding that uses one to four bytes to store each code point. It is capable
+  of encoding all valid Unicode code points. Let's see an example:
 
-      iex> byte_size("é")
-      2
+      iex> string = "héllo"
+      "héllo"
+      iex> String.length(string)
+      5
+      iex> byte_size(string)
+      6
 
-  However, this module returns the proper length:
+  Although the string above has 5 characters, it uses 6 bytes, as two bytes
+  are used to represent the character `é`.
 
-      iex> String.length("é")
-      1
+  ## Grapheme clusters
 
-  Furthermore, this module also presents the concept of
-  graphemes, which are multiple characters that may be
-  "perceived as a single character" by readers. For example,
-  the same "é" character written above could be represented
-  by the letter "e" followed by the accent ́:
+  This module also works with the concept of grapheme cluster
+  (from now on referenced as graphemes). Graphemes can consist
+  of multiple code points that may be perceived as a single character
+  by readers. For example, "é" can be represented either as a single
+  "e with acute" code point, as seen above in the string `"héllo"`,
+  or as the letter "e" followed by a "combining acute accent"
+  (two code points):
 
-      iex> string = "\x{0065}\x{0301}"
+      iex> string = "\u0065\u0301"
+      "é"
       iex> byte_size(string)
       3
       iex> String.length(string)
       1
+      iex> String.codepoints(string)
+      ["e", "́"]
+      iex> String.graphemes(string)
+      ["é"]
 
-  Although the example above is made of two characters, it is
-  perceived by users as one.
+  Although it looks visually the same as before, the example above
+  is made of two characters, it is perceived by users as one.
 
-  Graphemes can also be two characters that are interpreted
-  as one by some languages. For example, some languages may
-  consider "ch" as a grapheme. However, since this information
-  depends on the locale, it is not taken into account by this
-  module.
+  Graphemes can also be two characters that are interpreted as one
+  by some languages. For example, some languages may consider "ch"
+  as a single character. However, since this information depends on
+  the locale, it is not taken into account by this module.
 
   In general, the functions in this module rely on the Unicode
-  Standard, but does not contain any of the locale specific
-  behaviour.
-
+  Standard, but do not contain any of the locale specific behavior.
   More information about graphemes can be found in the [Unicode
-  Standard Annex #29](http://www.unicode.org/reports/tr29/).
-  This current Elixir version implements Extended Grapheme Cluster
-  algorithm.
+  Standard Annex #29](https://www.unicode.org/reports/tr29/).
 
-  ## Integer codepoints
+  For converting a binary to a different encoding and for Unicode
+  normalization mechanisms, see Erlang's [`:unicode`](`:unicode`) module.
 
-  Although codepoints could be represented as integers, this
-  module represents all codepoints as strings. For example:
+  ## String and binary operations
 
-      iex> String.codepoints("josé")
-      ["j", "o", "s", "é"]
+  To act according to the Unicode Standard, many functions
+  in this module run in linear time, as they need to traverse
+  the whole string considering the proper Unicode code points.
 
-  There are a couple of ways to retrieve a character integer
-  codepoint. One may use the `?` special macro:
+  For example, `String.length/1` will take longer as
+  the input grows. On the other hand, `Kernel.byte_size/1` always runs
+  in constant time (i.e. regardless of the input size).
 
-      iex> ?j
-      106
+  This means often there are performance costs in using the
+  functions in this module, compared to the more low-level
+  operations that work directly with binaries:
 
-      iex> ?é
-      233
+    * `Kernel.binary_part/3` - retrieves part of the binary
+    * `Kernel.bit_size/1` and `Kernel.byte_size/1` - size related functions
+    * `Kernel.is_bitstring/1` and `Kernel.is_binary/1` - type-check function
+    * Plus a number of functions for working with binaries (bytes)
+      in the [`:binary` module](`:binary`)
 
-  Or also via pattern matching:
+  A `utf8` modifier is also available inside the binary syntax `<<>>`.
+  It can be used to match code points out of a binary/string:
 
-      iex> << eacute :: utf8 >> = "é"
+      iex> <<eacute::utf8>> = "é"
       iex> eacute
       233
 
-  As we have seen above, codepoints can be inserted into
-  a string by their hexadecimal code:
+  See the [*Patterns and Guards* guide](patterns-and-guards.md) and the documentation for
+  [`<<>>`](`<<>>/1`) for more information on binary pattern matching.
+
+  You can also fully convert a string into a list of integer code points,
+  known as "charlists" in Elixir, by calling `String.to_charlist/1`:
+
+      iex> String.to_charlist("héllo")
+      [104, 233, 108, 108, 111]
+
+  If you would rather see the underlying bytes of a string, instead of
+  its codepoints, a common trick is to concatenate the null byte `<<0>>`
+  to it:
+
+      iex> "héllo" <> <<0>>
+      <<104, 195, 169, 108, 108, 111, 0>>
+
+  Alternatively, you can view a string's binary representation by
+  passing an option to `IO.inspect/2`:
 
-      "jos\x{0065}\x{0301}" #=>
-      "josé"
+      IO.inspect("héllo", binaries: :as_binaries)
+      #=> <<104, 195, 169, 108, 108, 111>>
 
   ## Self-synchronization
 
   The UTF-8 encoding is self-synchronizing. This means that
   if malformed data (i.e., data that is not possible according
   to the definition of the encoding) is encountered, only one
-  codepoint needs to be rejected.
+  code point needs to be rejected.
 
-  This module relies on this behaviour to ignore such invalid
-  characters. For example, `length/1` is going to return
-  a correct result even if an invalid codepoint is fed into it.
+  This module relies on this behavior to ignore such invalid
+  characters. For example, `length/1` will return
+  a correct result even if an invalid code point is fed into it.
 
   In other words, this module expects invalid data to be detected
-  when retrieving data from the external source. For example, a
-  driver that reads strings from a database will be the one
-  responsible to check the validity of the encoding.
+  elsewhere, usually when retrieving data from the external source.
+  For example, a driver that reads strings from a database will be
+  responsible to check the validity of the encoding. `String.chunk/2`
+  can be used for breaking a string into valid and invalid parts.
+
+  ## Compile binary patterns
+
+  Many functions in this module work with patterns. For example,
+  `String.split/3` can split a string into multiple strings given
+  a pattern. This pattern can be a string, a list of strings or
+  a compiled pattern:
+
+      iex> String.split("foo bar", " ")
+      ["foo", "bar"]
+
+      iex> String.split("foo bar!", [" ", "!"])
+      ["foo", "bar", ""]
+
+      iex> pattern = :binary.compile_pattern([" ", "!"])
+      iex> String.split("foo bar!", pattern)
+      ["foo", "bar", ""]
+
+  The compiled pattern is useful when the same match will
+  be done over and over again. Note though that the compiled
+  pattern cannot be stored in a module attribute as the pattern
+  is generated at runtime and does not survive compile time.
   """
 
+  @typedoc """
+  A UTF-8 encoded binary.
+
+  The types `String.t()` and `binary()` are equivalent to analysis tools.
+  Although, for those reading the documentation, `String.t()` implies
+  it is a UTF-8 encoded binary.
+  """
   @type t :: binary
+
+  @typedoc "A single Unicode code point encoded in UTF-8. It may be one or more bytes."
   @type codepoint :: t
+
+  @typedoc "Multiple code points that may be perceived as a single character by readers"
   @type grapheme :: t
 
+  @typedoc """
+  Pattern used in functions like `replace/4` and `split/3`.
+
+  It must be one of:
+
+    * a string
+    * an empty list
+    * a list containing non-empty strings
+    * a compiled search pattern created by `:binary.compile_pattern/1`
+
+  """
+  @type pattern ::
+          t()
+          | [nonempty_binary]
+          | (compiled_search_pattern :: :binary.cp())
+
+  @type split_opts :: [
+          parts: pos_integer() | :infinity,
+          trim: boolean()
+        ]
+
+  @type splitter_opts :: [trim: boolean()]
+
+  @type replace_opts :: [global: boolean()]
+
+  @conditional_mappings [:greek, :turkic]
+
   @doc """
-  Checks if a string is printable considering it is encoded
-  as UTF-8. Returns `true` if so, `false` otherwise.
+  Checks if a string contains only printable characters up to `character_limit`.
+
+  Takes an optional `character_limit` as a second argument. If `character_limit` is `0`, this
+  function will return `true`.
 
   ## Examples
 
       iex> String.printable?("abc")
       true
 
+      iex> String.printable?("abc" <> <<0>>)
+      false
+
+      iex> String.printable?("abc" <> <<0>>, 2)
+      true
+
+      iex> String.printable?("abc" <> <<0>>, 0)
+      true
+
   """
-  @spec printable?(t) :: boolean
+  @spec printable?(t, 0) :: true
+  @spec printable?(t, pos_integer | :infinity) :: boolean
+  def printable?(string, character_limit \\ :infinity)
+      when is_binary(string) and
+             (character_limit == :infinity or
+                (is_integer(character_limit) and character_limit >= 0)) do
+    recur_printable?(string, character_limit)
+  end
 
-  def printable?(<< h :: utf8, t :: binary >>)
-      when h in ?\040..?\176
-      when h in 0xA0..0xD7FF
-      when h in 0xE000..0xFFFD
-      when h in 0x10000..0x10FFFF do
-    printable?(t)
+  defp recur_printable?(<<_::binary>>, 0), do: true
+  defp recur_printable?(<<>>, _character_limit), do: true
+
+  for char <- 0x20..0x7E do
+    defp recur_printable?(<<unquote(char), rest::binary>>, character_limit) do
+      recur_printable?(rest, decrement(character_limit))
+    end
   end
 
-  def printable?(<<?\n, t :: binary>>), do: printable?(t)
-  def printable?(<<?\r, t :: binary>>), do: printable?(t)
-  def printable?(<<?\t, t :: binary>>), do: printable?(t)
-  def printable?(<<?\v, t :: binary>>), do: printable?(t)
-  def printable?(<<?\b, t :: binary>>), do: printable?(t)
-  def printable?(<<?\f, t :: binary>>), do: printable?(t)
-  def printable?(<<?\e, t :: binary>>), do: printable?(t)
-  def printable?(<<?\d, t :: binary>>), do: printable?(t)
-  def printable?(<<?\a, t :: binary>>), do: printable?(t)
+  for char <- [?\n, ?\r, ?\t, ?\v, ?\b, ?\f, ?\e, ?\d, ?\a] do
+    defp recur_printable?(<<unquote(char), rest::binary>>, character_limit) do
+      recur_printable?(rest, decrement(character_limit))
+    end
+  end
 
-  def printable?(<<>>), do: true
-  def printable?(b) when is_binary(b), do: false
+  defp recur_printable?(<<char::utf8, rest::binary>>, character_limit)
+       when char in 0xA0..0xD7FF
+       when char in 0xE000..0xFFFD
+       when char in 0x10000..0x10FFFF do
+    recur_printable?(rest, decrement(character_limit))
+  end
 
-  @doc """
+  defp recur_printable?(_string, _character_limit) do
+    false
+  end
+
+  defp decrement(:infinity), do: :infinity
+  defp decrement(character_limit), do: character_limit - 1
+
+  @doc ~S"""
   Divides a string into substrings at each Unicode whitespace
   occurrence with leading and trailing whitespace ignored.
 
+  Groups of whitespace are treated as a single occurrence.
+  Divisions do not occur on non-breaking whitespace.
+
   ## Examples
 
       iex> String.split("foo bar")
@@ -161,25 +383,53 @@ defmodule String do
       iex> String.split("foo" <> <<194, 133>> <> "bar")
       ["foo", "bar"]
 
-      iex> String.split(" foo bar ")
+      iex> String.split(" foo   bar ")
       ["foo", "bar"]
 
+      iex> String.split("no\u00a0break")
+      ["no\u00a0break"]
+
+  Removes empty strings, like when using `trim: true` in `String.split/3`.
+
+      iex> String.split(" ")
+      []
+
   """
   @spec split(t) :: [t]
-  defdelegate split(binary), to: String.Unicode
+  defdelegate split(binary), to: String.Break
 
   @doc ~S"""
-  Divides a string into substrings based on a pattern.
+  Divides a string into parts based on a pattern.
+
+  Returns a list of these parts.
 
-  Returns a list of these substrings. The pattern can
-  be a string, a list of strings or a regular expression.
+  The `pattern` may be a string, a list of strings, a regular expression, or a
+  compiled pattern.
 
   The string is split into as many parts as possible by
-  default, but can be controlled via the `parts: num` option.
-  If you pass `parts: :infinity`, it will return all possible parts.
+  default, but can be controlled via the `:parts` option.
 
   Empty strings are only removed from the result if the
-  `trim` option is set to `true`.
+  `:trim` option is set to `true`.
+
+  When the pattern used is a regular expression, the string is
+  split using `Regex.split/3`.
+
+  If the pattern cannot be found, a list containing the original
+  string will be returned.
+
+  ## Options
+
+    * `:parts` (positive integer or `:infinity`) - the string
+      is split into at most as many parts as this option specifies.
+      If `:infinity`, the string will be split into all possible
+      parts. Defaults to `:infinity`.
+
+    * `:trim` (boolean) - if `true`, empty strings are removed from
+      the resulting list.
+
+  This function also accepts all options accepted by `Regex.split/3`
+  if `pattern` is a regular expression.
 
   ## Examples
 
@@ -210,109 +460,430 @@ defmodule String do
       iex> String.split(" a b c ", ~r{\s}, trim: true)
       ["a", "b", "c"]
 
-  Splitting on empty patterns returns codepoints:
+      iex> String.split("abc", ~r{b}, include_captures: true)
+      ["a", "b", "c"]
+
+  A compiled pattern:
+
+      iex> pattern = :binary.compile_pattern([" ", ","])
+      iex> String.split("1,2 3,4", pattern)
+      ["1", "2", "3", "4"]
 
-      iex> String.split("abc", ~r{})
-      ["a", "b", "c", ""]
+  Splitting on empty string returns graphemes:
 
       iex> String.split("abc", "")
-      ["a", "b", "c", ""]
+      ["", "a", "b", "c", ""]
 
       iex> String.split("abc", "", trim: true)
       ["a", "b", "c"]
 
-      iex> String.split("abc", "", parts: 2)
-      ["a", "bc"]
+      iex> String.split("abc", "", parts: 1)
+      ["abc"]
+
+      iex> String.split("abc", "", parts: 3)
+      ["", "a", "bc"]
+
+  Splitting on an non-existing pattern returns the original string:
+
+      iex> String.split("abc", ",")
+      ["abc"]
+
+  Be aware that this function can split within or across grapheme boundaries.
+  For example, take the grapheme "é" which is made of the characters
+  "e" and the acute accent. The following will split the string into two parts:
+
+      iex> String.split(String.normalize("é", :nfd), "e")
+      ["", "́"]
+
+  However, if "é" is represented by the single character "e with acute"
+  accent, then it will split the string into just one part:
+
+      iex> String.split(String.normalize("é", :nfc), "e")
+      ["é"]
+
+  When using both the `:trim` and the `:parts` option, the empty values
+  are removed as the parts are computed (if any). No trimming happens
+  after all parts are computed:
+
+      iex> String.split(" a  b  c  ", " ", trim: true, parts: 2)
+      ["a", " b  c  "]
+      iex> String.split(" a  b  c  ", " ", trim: true, parts: 3)
+      ["a", "b", " c  "]
 
   """
-  @spec split(t, t | [t] | Regex.t) :: [t]
-  @spec split(t, t | [t] | Regex.t, Keyword.t) :: [t]
-  def split(binary, pattern, options \\ [])
+  @spec split(t, pattern, split_opts()) :: [t]
+  @spec split(t, Regex.t(), Regex.split_opts()) :: [t]
+  def split(string, pattern, options \\ [])
 
-  def split("", _pattern, _options), do: [""]
+  def split(string, %Regex{} = pattern, options) when is_binary(string) and is_list(options) do
+    Regex.split(pattern, string, options)
+  end
 
-  def split(binary, "", options), do: split(binary, ~r""u, options)
+  def split(string, "", options) when is_binary(string) and is_list(options) do
+    parts = Keyword.get(options, :parts, :infinity)
+    index = parts_to_index(parts)
+    trim = Keyword.get(options, :trim, false)
 
-  def split(binary, pattern, options) do
-    if Regex.regex?(pattern) do
-      Regex.split(pattern, binary, options)
+    if trim == false and index != 1 do
+      ["" | split_empty(string, trim, index - 1)]
     else
-      splits =
-        case Keyword.get(options, :parts, :infinity) do
-          num when is_number(num) and num > 0 ->
-            split_parts(binary, pattern, num - 1)
-          _ ->
-            :binary.split(binary, pattern, [:global])
-        end
+      split_empty(string, trim, index)
+    end
+  end
 
-      if Keyword.get(options, :trim, false) do
-        for split <- splits, split != "", do: split
-      else
-        splits
-      end
+  def split(string, [], options) when is_binary(string) and is_list(options) do
+    if string == "" and Keyword.get(options, :trim, false) do
+      []
+    else
+      [string]
+    end
+  end
+
+  def split(string, pattern, options) when is_binary(string) and is_list(options) do
+    parts = Keyword.get(options, :parts, :infinity)
+    trim = Keyword.get(options, :trim, false)
+
+    case {parts, trim} do
+      {:infinity, false} ->
+        :binary.split(string, pattern, [:global])
+
+      {:infinity, true} ->
+        :binary.split(string, pattern, [:global, :trim_all])
+
+      {2, false} ->
+        :binary.split(string, pattern)
+
+      _ ->
+        pattern = maybe_compile_pattern(pattern)
+        split_each(string, pattern, trim, parts_to_index(parts))
+    end
+  end
+
+  defp parts_to_index(:infinity), do: 0
+  defp parts_to_index(n) when is_integer(n) and n > 0, do: n
+
+  defp split_empty("", true, 1), do: []
+  defp split_empty(string, _, 1), do: [IO.iodata_to_binary(string)]
+
+  defp split_empty(string, trim, count) do
+    case :unicode_util.gc(string) do
+      [gc] -> [grapheme_to_binary(gc) | split_empty("", trim, 1)]
+      [gc | rest] -> [grapheme_to_binary(gc) | split_empty(rest, trim, count - 1)]
+      [] -> split_empty("", trim, 1)
+      {:error, <<byte, rest::bits>>} -> [<<byte>> | split_empty(rest, trim, count - 1)]
+    end
+  end
+
+  defp split_each("", _pattern, true, 1), do: []
+  defp split_each(string, _pattern, _trim, 1) when is_binary(string), do: [string]
+
+  defp split_each(string, pattern, trim, count) do
+    case do_splitter(string, pattern, trim) do
+      {h, t} -> [h | split_each(t, pattern, trim, count - 1)]
+      nil -> []
+    end
+  end
+
+  @doc """
+  Returns an enumerable that splits a string on demand.
+
+  This is in contrast to `split/3` which splits the
+  entire string upfront.
+
+  This function does not support regular expressions
+  by design. When using regular expressions, it is often
+  more efficient to have the regular expressions traverse
+  the string at once than in parts, like this function does.
+
+  ## Options
+
+    * :trim - when `true`, does not emit empty patterns
+
+  ## Examples
+
+      iex> String.splitter("1,2 3,4 5,6 7,8,...,99999", [" ", ","]) |> Enum.take(4)
+      ["1", "2", "3", "4"]
+
+      iex> String.splitter("abcd", "") |> Enum.take(10)
+      ["", "a", "b", "c", "d", ""]
+
+      iex> String.splitter("abcd", "", trim: true) |> Enum.take(10)
+      ["a", "b", "c", "d"]
+
+  A compiled pattern can also be given:
+
+      iex> pattern = :binary.compile_pattern([" ", ","])
+      iex> String.splitter("1,2 3,4 5,6 7,8,...,99999", pattern) |> Enum.take(4)
+      ["1", "2", "3", "4"]
+
+  """
+  @spec splitter(t, pattern, splitter_opts) :: Enumerable.t()
+  def splitter(string, pattern, options \\ [])
+
+  def splitter(string, "", options) when is_binary(string) and is_list(options) do
+    if Keyword.get(options, :trim, false) do
+      Stream.unfold(string, &next_grapheme/1)
+    else
+      Stream.unfold(:match, &do_empty_splitter(&1, string))
     end
   end
 
-  defp split_parts("", _pattern, _num),         do: [""]
-  defp split_parts(binary, pattern, num),       do: split_parts(binary, pattern, num, [])
-  defp split_parts("", _pattern, _num, parts),  do: Enum.reverse([""|parts])
-  defp split_parts(binary, _pattern, 0, parts), do: Enum.reverse([binary|parts])
-  defp split_parts(binary, pattern, num, parts) do
-    case :binary.split(binary, pattern) do
-      [head]       -> Enum.reverse([head|parts])
-      [head, rest] -> split_parts(rest, pattern, num - 1, [head|parts])
+  def splitter(string, [], options) when is_binary(string) and is_list(options) do
+    if string == "" and Keyword.get(options, :trim, false) do
+      Stream.duplicate(string, 0)
+    else
+      Stream.duplicate(string, 1)
     end
   end
 
+  def splitter(string, pattern, options) when is_binary(string) and is_list(options) do
+    pattern = maybe_compile_pattern(pattern)
+    trim = Keyword.get(options, :trim, false)
+    Stream.unfold(string, &do_splitter(&1, pattern, trim))
+  end
+
+  defp do_empty_splitter(:match, string), do: {"", string}
+  defp do_empty_splitter(:nomatch, _string), do: nil
+  defp do_empty_splitter("", _), do: {"", :nomatch}
+  defp do_empty_splitter(string, _), do: next_grapheme(string)
+
+  defp do_splitter(:nomatch, _pattern, _), do: nil
+  defp do_splitter("", _pattern, false), do: {"", :nomatch}
+  defp do_splitter("", _pattern, true), do: nil
+
+  defp do_splitter(bin, pattern, trim) do
+    case :binary.split(bin, pattern) do
+      ["", second] when trim -> do_splitter(second, pattern, trim)
+      [first, second] -> {first, second}
+      [first] -> {first, :nomatch}
+    end
+  end
+
+  defp maybe_compile_pattern(pattern) when is_tuple(pattern), do: pattern
+  defp maybe_compile_pattern(pattern), do: :binary.compile_pattern(pattern)
+
   @doc """
   Splits a string into two at the specified offset. When the offset given is
   negative, location is counted from the end of the string.
 
-  The offset is capped to the length of the string.
+  The offset is capped to the length of the string. Returns a tuple with
+  two elements.
 
-  Returns a tuple with two elements.
+  > #### Linear Access {: .warning}
+  >
+  > This function splits on graphemes and for such it has to linearly traverse
+  > the string.
+  > If you want to split a string or a binary based on the number of bytes,
+  > use `Kernel.binary_part/3` instead.
 
   ## Examples
 
-      iex> String.split_at "sweetelixir", 5
+      iex> String.split_at("sweetelixir", 5)
       {"sweet", "elixir"}
 
-      iex> String.split_at "sweetelixir", -6
+      iex> String.split_at("sweetelixir", -6)
       {"sweet", "elixir"}
 
-      iex> String.split_at "abc", 0
+      iex> String.split_at("abc", 0)
       {"", "abc"}
 
-      iex> String.split_at "abc", 1000
+      iex> String.split_at("abc", 1000)
       {"abc", ""}
 
-      iex> String.split_at "abc", -1000
+      iex> String.split_at("abc", -1000)
       {"", "abc"}
 
   """
   @spec split_at(t, integer) :: {t, t}
-  def split_at(string, offset)
+  def split_at(string, position)
+
+  def split_at(string, position)
+      when is_binary(string) and is_integer(position) and position >= 0 do
+    do_split_at(string, position)
+  end
 
-  def split_at(binary, index) when index == 0, do:
-    {"", binary}
+  def split_at(string, position)
+      when is_binary(string) and is_integer(position) and position < 0 do
+    position = length(string) + position
 
-  def split_at(binary, index) when index > 0, do:
-    do_split_at(next_grapheme(binary), 0, index, "")
+    case position >= 0 do
+      true -> do_split_at(string, position)
+      false -> {"", string}
+    end
+  end
 
-  def split_at(binary, index) when index < 0, do:
-    do_split_at(next_grapheme(binary), 0, max(0, byte_size(binary)+index), "")
+  defp do_split_at(string, position) do
+    remaining = byte_size_remaining_at(string, position)
+    start = byte_size(string) - remaining
+    <<left::size(^start)-binary, right::size(^remaining)-binary>> = string
+    {left, right}
+  end
 
-  defp do_split_at(nil, _, _, acc), do:
-    {acc, ""}
+  @doc ~S"""
+  Counts the number of non-overlapping occurrences of a `pattern` in a `string`.
+
+  In case the pattern is an empty string, the function returns 1 + the number of graphemes
+  in the string.
+
+  ## Examples
+
+      iex> String.count("hello world", "o")
+      2
+
+      iex> String.count("hello world", "l")
+      3
 
-  defp do_split_at({grapheme, rest}, current_pos, target_pos, acc) when current_pos < target_pos, do:
-    do_split_at(next_grapheme(rest), current_pos+1, target_pos, acc <> grapheme)
+      iex> String.count("hello world", "x")
+      0
 
-  defp do_split_at({grapheme, rest}, pos, pos, acc), do:
-    {acc, grapheme <> rest}
+      iex> String.count("hello world", ~r/o/)
+      2
+
+      iex> String.count("Hellooo", "oo")
+      1
+
+      iex> String.count("hello world", "")
+      12
+
+  The `pattern` can also be a compiled pattern:
+
+      iex> pattern = :binary.compile_pattern([" ", "!"])
+      iex> String.count("foo bar baz!!", pattern)
+      4
+
+  """
+  @spec count(t, pattern | Regex.t()) :: non_neg_integer
+  @doc since: "1.19.0"
+  def count(string, <<>>), do: length(string) + 1
+
+  def count(string, pattern) when is_struct(pattern, Regex) do
+    Kernel.length(Regex.scan(pattern, string, return: :index))
+  end
+
+  def count(string, pattern) do
+    Kernel.length(:binary.matches(string, pattern))
+  end
+
+  @doc ~S"""
+  Returns `true` if `string1` is canonically equivalent to `string2`.
+
+  It performs Normalization Form Canonical Decomposition (NFD) on the
+  strings before comparing them. This function is equivalent to:
+
+      String.normalize(string1, :nfd) == String.normalize(string2, :nfd)
+
+  If you plan to compare multiple strings, multiple times in a row, you
+  may normalize them upfront and compare them directly to avoid multiple
+  normalization passes.
+
+  ## Examples
+
+      iex> String.equivalent?("abc", "abc")
+      true
+
+      iex> String.equivalent?("man\u0303ana", "mañana")
+      true
+
+      iex> String.equivalent?("abc", "ABC")
+      false
+
+      iex> String.equivalent?("nø", "nó")
+      false
+
+  """
+  @spec equivalent?(t, t) :: boolean
+  def equivalent?(string1, string2) when is_binary(string1) and is_binary(string2) do
+    normalize(string1, :nfd) == normalize(string2, :nfd)
+  end
 
   @doc """
-  Convert all characters on the given string to uppercase.
+  Converts all characters in `string` to Unicode normalization
+  form identified by `form`.
+
+  Invalid Unicode codepoints are skipped and the remaining of
+  the string is converted. If you want the algorithm to stop
+  and return on invalid codepoint, use `:unicode.characters_to_nfd_binary/1`,
+  `:unicode.characters_to_nfc_binary/1`, `:unicode.characters_to_nfkd_binary/1`,
+  and `:unicode.characters_to_nfkc_binary/1` instead.
+
+  Normalization forms `:nfkc` and `:nfkd` should not be blindly applied
+  to arbitrary text. Because they erase many formatting distinctions,
+  they will prevent round-trip conversion to and from many legacy
+  character sets.
+
+  ## Forms
+
+  The supported forms are:
+
+    * `:nfd` - Normalization Form Canonical Decomposition.
+      Characters are decomposed by canonical equivalence, and
+      multiple combining characters are arranged in a specific
+      order.
+
+    * `:nfc` - Normalization Form Canonical Composition.
+      Characters are decomposed and then recomposed by canonical equivalence.
+
+    * `:nfkd` - Normalization Form Compatibility Decomposition.
+      Characters are decomposed by compatibility equivalence, and
+      multiple combining characters are arranged in a specific
+      order.
+
+    * `:nfkc` - Normalization Form Compatibility Composition.
+      Characters are decomposed and then recomposed by compatibility equivalence.
+
+  ## Examples
+
+      iex> String.normalize("yêṩ", :nfd)
+      "yêṩ"
+
+      iex> String.normalize("leña", :nfc)
+      "leña"
+
+      iex> String.normalize("fi", :nfkd)
+      "fi"
+
+      iex> String.normalize("fi", :nfkc)
+      "fi"
+
+  """
+  @spec normalize(t, :nfd | :nfc | :nfkd | :nfkc) :: t
+  def normalize(string, form)
+
+  def normalize(string, :nfd) when is_binary(string) do
+    case :unicode.characters_to_nfd_binary(string) do
+      string when is_binary(string) -> string
+      {:error, good, <<head, rest::binary>>} -> good <> <<head>> <> normalize(rest, :nfd)
+    end
+  end
+
+  def normalize(string, :nfc) when is_binary(string) do
+    case :unicode.characters_to_nfc_binary(string) do
+      string when is_binary(string) -> string
+      {:error, good, <<head, rest::binary>>} -> good <> <<head>> <> normalize(rest, :nfc)
+    end
+  end
+
+  def normalize(string, :nfkd) when is_binary(string) do
+    case :unicode.characters_to_nfkd_binary(string) do
+      string when is_binary(string) -> string
+      {:error, good, <<head, rest::binary>>} -> good <> <<head>> <> normalize(rest, :nfkd)
+    end
+  end
+
+  def normalize(string, :nfkc) when is_binary(string) do
+    case :unicode.characters_to_nfkc_binary(string) do
+      string when is_binary(string) -> string
+      {:error, good, <<head, rest::binary>>} -> good <> <<head>> <> normalize(rest, :nfkc)
+    end
+  end
+
+  @doc """
+  Converts all characters in the given string to uppercase according to `mode`.
+
+  `mode` may be `:default`, `:ascii`, `:greek` or `:turkic`. The `:default` mode considers
+  all non-conditional transformations outlined in the Unicode standard. `:ascii`
+  uppercases only the letters a to z. `:greek` includes the context sensitive
+  mappings found in Greek. `:turkic` properly handles the letter i with the dotless variant.
 
   ## Examples
 
@@ -322,15 +893,60 @@ defmodule String do
       iex> String.upcase("ab 123 xpto")
       "AB 123 XPTO"
 
-      iex> String.upcase("josé")
-      "JOSÉ"
+      iex> String.upcase("olá")
+      "OLÁ"
+
+  The `:ascii` mode ignores Unicode characters and provides a more
+  performant implementation when you know the string contains only
+  ASCII characters:
+
+      iex> String.upcase("olá", :ascii)
+      "OLá"
+
+  And `:turkic` properly handles the letter i with the dotless variant:
 
+      iex> String.upcase("ıi")
+      "II"
+
+      iex> String.upcase("ıi", :turkic)
+      "Iİ"
+
+  Also see `downcase/2` and `capitalize/2` for other conversions.
   """
-  @spec upcase(t) :: t
-  defdelegate upcase(binary), to: String.Unicode
+  @spec upcase(t, :default | :ascii | :greek | :turkic) :: t
+  def upcase(string, mode \\ :default)
+
+  def upcase("", _mode) do
+    ""
+  end
+
+  def upcase(string, :default) when is_binary(string) do
+    String.Unicode.upcase(string, [], :default)
+  end
+
+  def upcase(string, :ascii) when is_binary(string) do
+    IO.iodata_to_binary(upcase_ascii(string))
+  end
+
+  def upcase(string, mode) when is_binary(string) and mode in @conditional_mappings do
+    String.Unicode.upcase(string, [], mode)
+  end
+
+  defp upcase_ascii(<<char, rest::bits>>) when char >= ?a and char <= ?z,
+    do: [char - 32 | upcase_ascii(rest)]
+
+  defp upcase_ascii(<<char, rest::bits>>), do: [char | upcase_ascii(rest)]
+  defp upcase_ascii(<<>>), do: []
 
   @doc """
-  Convert all characters on the given string to lowercase.
+  Converts all characters in the given string to lowercase according to `mode`.
+
+  `mode` may be `:default`, `:ascii`, `:greek` or `:turkic`. The `:default` mode considers
+  all non-conditional transformations outlined in the Unicode standard. `:ascii`
+  lowercases only the letters A to Z. `:greek` includes the context sensitive
+  mappings found in Greek. `:turkic` properly handles the letter i with the dotless variant.
+
+  Also see `upcase/2` and `capitalize/2` for other conversions.
 
   ## Examples
 
@@ -340,234 +956,618 @@ defmodule String do
       iex> String.downcase("AB 123 XPTO")
       "ab 123 xpto"
 
-      iex> String.downcase("JOSÉ")
-      "josé"
+      iex> String.downcase("OLÁ")
+      "olá"
+
+  The `:ascii` mode ignores Unicode characters and provides a more
+  performant implementation when you know the string contains only
+  ASCII characters:
+
+      iex> String.downcase("OLÁ", :ascii)
+      "olÁ"
+
+  The `:greek` mode properly handles the context sensitive sigma in Greek:
+
+      iex> String.downcase("ΣΣ")
+      "σσ"
+
+      iex> String.downcase("ΣΣ", :greek)
+      "σς"
+
+  And `:turkic` properly handles the letter i with the dotless variant:
+
+      iex> String.downcase("Iİ")
+      "ii̇"
+
+      iex> String.downcase("Iİ", :turkic)
+      "ıi"
 
   """
-  @spec downcase(t) :: t
-  defdelegate downcase(binary), to: String.Unicode
+  @spec downcase(t, :default | :ascii | :greek | :turkic) :: t
+  def downcase(string, mode \\ :default)
+
+  def downcase("", _mode) do
+    ""
+  end
+
+  def downcase(string, :default) when is_binary(string) do
+    String.Unicode.downcase(string, [], :default)
+  end
+
+  def downcase(string, :ascii) when is_binary(string) do
+    IO.iodata_to_binary(downcase_ascii(string))
+  end
+
+  def downcase(string, mode) when is_binary(string) and mode in @conditional_mappings do
+    String.Unicode.downcase(string, [], mode)
+  end
+
+  defp downcase_ascii(<<char, rest::bits>>) when char >= ?A and char <= ?Z,
+    do: [char + 32 | downcase_ascii(rest)]
+
+  defp downcase_ascii(<<char, rest::bits>>), do: [char | downcase_ascii(rest)]
+  defp downcase_ascii(<<>>), do: []
 
   @doc """
   Converts the first character in the given string to
-  uppercase and the remaining to lowercase.
+  uppercase and the remainder to lowercase according to `mode`.
 
-  This relies on the titlecase information provided
-  by the Unicode Standard. Note this function makes
-  no attempt to capitalize all words in the string
-  (usually known as titlecase).
+  `mode` may be `:default`, `:ascii`, `:greek` or `:turkic`. The `:default` mode
+  considers all non-conditional transformations outlined in the Unicode standard.
+  `:ascii` capitalizes only the letters A to Z. `:greek` includes the context
+  sensitive mappings found in Greek. `:turkic` properly handles the letter `i`
+  with the dotless variant.
+
+  Also see `upcase/2` and `capitalize/2` for other conversions. If you want
+  a variation of this function that does not lowercase the rest of string,
+  see Erlang's `:string.titlecase/1`.
 
   ## Examples
 
       iex> String.capitalize("abcd")
       "Abcd"
+      iex> String.capitalize("ABCD")
+      "Abcd"
 
       iex> String.capitalize("fin")
       "Fin"
-
-      iex> String.capitalize("josé")
-      "José"
+      iex> String.capitalize("olá")
+      "Olá"
 
   """
-  @spec capitalize(t) :: t
-  def capitalize(string) when is_binary(string) do
-    {char, rest} = String.Unicode.titlecase_once(string)
-    char <> downcase(rest)
+  @spec capitalize(t, :default | :ascii | :greek | :turkic) :: t
+  def capitalize(string, mode \\ :default)
+
+  def capitalize(<<char, rest::binary>>, :ascii) do
+    char = if char >= ?a and char <= ?z, do: char - 32, else: char
+    <<char>> <> downcase(rest, :ascii)
+  end
+
+  @letter_I <<0x0049::utf8>>
+  @letter_i <<0x0069::utf8>>
+  @letter_I_dot_above <<0x0130::utf8>>
+
+  def capitalize(<<@letter_i, right::binary>>, mode) do
+    if(mode == :turkic, do: @letter_I_dot_above, else: @letter_I) <> downcase(right, mode)
+  end
+
+  def capitalize(string, mode) when is_binary(string) do
+    case :unicode_util.gc(string) do
+      [gc] -> grapheme_to_binary(:string.titlecase([gc]))
+      [gc, rest] -> grapheme_to_binary(:string.titlecase([gc])) <> downcase(rest, mode)
+      [gc | rest] -> grapheme_to_binary(:string.titlecase([gc])) <> downcase(rest, mode)
+      [] -> ""
+      {:error, <<byte, rest::bits>>} -> <<byte>> <> downcase(rest, mode)
+    end
+  end
+
+  @doc false
+  @deprecated "Use String.trim_trailing/1 instead"
+  defdelegate rstrip(binary), to: String.Break, as: :trim_trailing
+
+  @doc false
+  @deprecated "Use String.trim_trailing/2 with a binary as second argument instead"
+  def rstrip(string, char) when is_integer(char) do
+    replace_trailing(string, <<char::utf8>>, "")
   end
 
   @doc """
-  Returns a string where trailing Unicode whitespace
-  has been removed.
+  Replaces all leading occurrences of `match` by `replacement` of `match` in `string`.
+
+  Returns the string untouched if there are no occurrences.
+
+  If `match` is `""`, this function raises an `ArgumentError` exception: this
+  happens because this function replaces **all** the occurrences of `match` at
+  the beginning of `string`, and it's impossible to replace "multiple"
+  occurrences of `""`.
 
   ## Examples
 
-      iex> String.rstrip("   abc  ")
-      "   abc"
+      iex> String.replace_leading("hello world", "hello ", "")
+      "world"
+      iex> String.replace_leading("hello hello world", "hello ", "")
+      "world"
+
+      iex> String.replace_leading("hello world", "hello ", "ola ")
+      "ola world"
+      iex> String.replace_leading("hello hello world", "hello ", "ola ")
+      "ola ola world"
 
+  This function can replace across grapheme boundaries. See `replace/3`
+  for more information and examples.
   """
-  @spec rstrip(t) :: t
-  defdelegate rstrip(binary), to: String.Unicode
+  @spec replace_leading(t, t, t) :: t
+  def replace_leading(string, match, replacement)
+      when is_binary(string) and is_binary(match) and is_binary(replacement) do
+    if match == "" do
+      raise ArgumentError, "cannot use an empty string as the match to replace"
+    end
+
+    prefix_size = byte_size(match)
+    suffix_size = byte_size(string) - prefix_size
+    replace_leading(string, match, replacement, prefix_size, suffix_size, 0)
+  end
+
+  defp replace_leading(string, match, replacement, prefix_size, suffix_size, acc)
+       when suffix_size >= 0 do
+    case string do
+      <<prefix::size(^prefix_size)-binary, suffix::binary>> when prefix == match ->
+        replace_leading(
+          suffix,
+          match,
+          replacement,
+          prefix_size,
+          suffix_size - prefix_size,
+          acc + 1
+        )
+
+      _ ->
+        prepend_unless_empty(duplicate(replacement, acc), string)
+    end
+  end
+
+  defp replace_leading(string, _match, replacement, _prefix_size, _suffix_size, acc) do
+    prepend_unless_empty(duplicate(replacement, acc), string)
+  end
 
   @doc """
-  Returns a string where trailing `char` have been removed.
+  Replaces all trailing occurrences of `match` by `replacement` in `string`.
+
+  Returns the string untouched if there are no occurrences.
+
+  If `match` is `""`, this function raises an `ArgumentError` exception: this
+  happens because this function replaces **all** the occurrences of `match` at
+  the end of `string`, and it's impossible to replace "multiple" occurrences of
+  `""`.
 
   ## Examples
 
-      iex> String.rstrip("   abc _", ?_)
-      "   abc "
+      iex> String.replace_trailing("hello world", " world", "")
+      "hello"
+      iex> String.replace_trailing("hello world world", " world", "")
+      "hello"
+
+      iex> String.replace_trailing("hello world", " world", " mundo")
+      "hello mundo"
+      iex> String.replace_trailing("hello world world", " world", " mundo")
+      "hello mundo mundo"
 
+  This function can replace across grapheme boundaries. See `replace/3`
+  for more information and examples.
   """
-  @spec rstrip(t, char) :: t
+  @spec replace_trailing(t, t, t) :: t
+  def replace_trailing(string, match, replacement)
+      when is_binary(string) and is_binary(match) and is_binary(replacement) do
+    if match == "" do
+      raise ArgumentError, "cannot use an empty string as the match to replace"
+    end
 
-  def rstrip("", _char), do: ""
+    suffix_size = byte_size(match)
+    prefix_size = byte_size(string) - suffix_size
+    replace_trailing(string, match, replacement, prefix_size, suffix_size, 0)
+  end
+
+  defp replace_trailing(string, match, replacement, prefix_size, suffix_size, acc)
+       when prefix_size >= 0 do
+    case string do
+      <<prefix::size(^prefix_size)-binary, suffix::binary>> when suffix == match ->
+        replace_trailing(
+          prefix,
+          match,
+          replacement,
+          prefix_size - suffix_size,
+          suffix_size,
+          acc + 1
+        )
+
+      _ ->
+        append_unless_empty(string, duplicate(replacement, acc))
+    end
+  end
 
-  # Do a quick check before we traverse the whole
-  # binary. :binary.last is a fast operation (it
-  # does not traverse the whole binary).
-  def rstrip(string, char) when char in 0..127 do
-    if :binary.last(string) == char do
-      do_rstrip(string, "", char)
-    else
-      string
+  defp replace_trailing(string, _match, replacement, _prefix_size, _suffix_size, acc) do
+    append_unless_empty(string, duplicate(replacement, acc))
+  end
+
+  @doc """
+  Replaces prefix in `string` by `replacement` if it matches `match`.
+
+  Returns the string untouched if there is no match. If `match` is an empty
+  string (`""`), `replacement` is just prepended to `string`.
+
+  ## Examples
+
+      iex> String.replace_prefix("world", "hello ", "")
+      "world"
+      iex> String.replace_prefix("hello world", "hello ", "")
+      "world"
+      iex> String.replace_prefix("hello hello world", "hello ", "")
+      "hello world"
+
+      iex> String.replace_prefix("world", "hello ", "ola ")
+      "world"
+      iex> String.replace_prefix("hello world", "hello ", "ola ")
+      "ola world"
+      iex> String.replace_prefix("hello hello world", "hello ", "ola ")
+      "ola hello world"
+
+      iex> String.replace_prefix("world", "", "hello ")
+      "hello world"
+
+  This function can replace across grapheme boundaries. See `replace/3`
+  for more information and examples.
+  """
+  @spec replace_prefix(t, t, t) :: t
+  def replace_prefix(string, match, replacement)
+      when is_binary(string) and is_binary(match) and is_binary(replacement) do
+    prefix_size = byte_size(match)
+
+    case string do
+      <<prefix::size(^prefix_size)-binary, suffix::binary>> when prefix == match ->
+        prepend_unless_empty(replacement, suffix)
+
+      _ ->
+        string
     end
   end
 
-  def rstrip(string, char) when is_integer(char) do
-    do_rstrip(string, "", char)
+  @doc """
+  Replaces suffix in `string` by `replacement` if it matches `match`.
+
+  Returns the string untouched if there is no match. If `match` is an empty
+  string (`""`), `replacement` is just appended to `string`.
+
+  ## Examples
+
+      iex> String.replace_suffix("hello", " world", "")
+      "hello"
+      iex> String.replace_suffix("hello world", " world", "")
+      "hello"
+      iex> String.replace_suffix("hello world world", " world", "")
+      "hello world"
+
+      iex> String.replace_suffix("hello", " world", " mundo")
+      "hello"
+      iex> String.replace_suffix("hello world", " world", " mundo")
+      "hello mundo"
+      iex> String.replace_suffix("hello world world", " world", " mundo")
+      "hello world mundo"
+
+      iex> String.replace_suffix("hello", "", " world")
+      "hello world"
+
+  This function can replace across grapheme boundaries. See `replace/3`
+  for more information and examples.
+  """
+  @spec replace_suffix(t, t, t) :: t
+  def replace_suffix(string, match, replacement)
+      when is_binary(string) and is_binary(match) and is_binary(replacement) do
+    suffix_size = byte_size(match)
+    prefix_size = byte_size(string) - suffix_size
+
+    case string do
+      <<prefix::size(^prefix_size)-binary, suffix::binary>> when suffix == match ->
+        append_unless_empty(prefix, replacement)
+
+      _ ->
+        string
+    end
   end
 
-  defp do_rstrip(<<char :: utf8, string :: binary>>, buffer, char) do
-    <<do_rstrip(string, <<char :: utf8, buffer :: binary>>, char) :: binary>>
+  @compile {:inline, prepend_unless_empty: 2, append_unless_empty: 2}
+
+  defp prepend_unless_empty("", suffix), do: suffix
+  defp prepend_unless_empty(prefix, suffix), do: prefix <> suffix
+
+  defp append_unless_empty(prefix, ""), do: prefix
+  defp append_unless_empty(prefix, suffix), do: prefix <> suffix
+
+  @doc false
+  @deprecated "Use String.trim_leading/1 instead"
+  defdelegate lstrip(binary), to: String.Break, as: :trim_leading
+
+  @doc false
+  @deprecated "Use String.trim_leading/2 with a binary as second argument instead"
+  def lstrip(string, char) when is_integer(char) do
+    replace_leading(string, <<char::utf8>>, "")
   end
 
-  defp do_rstrip(<<char :: utf8, string :: binary>>, buffer, another_char) do
-    <<buffer :: binary, char :: utf8, do_rstrip(string, "", another_char) :: binary>>
+  @doc false
+  @deprecated "Use String.trim/1 instead"
+  def strip(string) do
+    trim(string)
   end
 
-  defp do_rstrip(<<>>, _, _) do
-    <<>>
+  @doc false
+  @deprecated "Use String.trim/2 with a binary second argument instead"
+  def strip(string, char) do
+    trim(string, <<char::utf8>>)
   end
 
-  @doc """
-  Returns a string where leading Unicode whitespace
-  has been removed.
+  @doc ~S"""
+  Returns a string where all leading Unicode whitespaces
+  have been removed.
 
   ## Examples
 
-      iex> String.lstrip("   abc  ")
-      "abc  "
+      iex> String.trim_leading("\n  abc   ")
+      "abc   "
 
   """
-  defdelegate lstrip(binary), to: String.Unicode
+  @spec trim_leading(t) :: t
+  defdelegate trim_leading(string), to: String.Break
 
   @doc """
-  Returns a string where leading `char` have been removed.
+  Returns a string where all leading `to_trim` characters have been removed.
 
   ## Examples
 
-      iex> String.lstrip("_  abc  _", ?_)
-      "  abc  _"
+      iex> String.trim_leading("__ abc _", "_")
+      " abc _"
+
+      iex> String.trim_leading("1 abc", "11")
+      "1 abc"
 
   """
+  @spec trim_leading(t, t) :: t
+  def trim_leading(string, to_trim)
+      when is_binary(string) and is_binary(to_trim) do
+    replace_leading(string, to_trim, "")
+  end
 
-  @spec lstrip(t, char) :: t
+  @doc ~S"""
+  Returns a string where all trailing Unicode whitespaces
+  have been removed.
 
-  def lstrip(<<char :: utf8, rest :: binary>>, char) when is_integer(char) do
-    <<lstrip(rest, char) :: binary>>
-  end
+  ## Examples
 
-  def lstrip(other, char) when is_integer(char) do
-    other
-  end
+      iex> String.trim_trailing("   abc\n  ")
+      "   abc"
+
+  """
+  @spec trim_trailing(t) :: t
+  defdelegate trim_trailing(string), to: String.Break
 
   @doc """
-  Returns a string where leading/trailing Unicode whitespace
-  has been removed.
+  Returns a string where all trailing `to_trim` characters have been removed.
 
   ## Examples
 
-      iex> String.strip("   abc  ")
-      "abc"
+      iex> String.trim_trailing("_ abc __", "_")
+      "_ abc "
+
+      iex> String.trim_trailing("abc 1", "11")
+      "abc 1"
 
   """
-  @spec strip(t) :: t
+  @spec trim_trailing(t, t) :: t
+  def trim_trailing(string, to_trim)
+      when is_binary(string) and is_binary(to_trim) do
+    replace_trailing(string, to_trim, "")
+  end
 
-  def strip(string) do
-    rstrip(lstrip(string))
+  @doc ~S"""
+  Returns a string where all leading and trailing Unicode whitespaces
+  have been removed.
+
+  ## Examples
+
+      iex> String.trim("\n  abc\n  ")
+      "abc"
+
+  """
+  @spec trim(t) :: t
+  def trim(string) when is_binary(string) do
+    string
+    |> trim_leading()
+    |> trim_trailing()
   end
 
   @doc """
-  Returns a string where leading/trailing `char` have been
+  Returns a string where all leading and trailing `to_trim` characters have been
   removed.
 
   ## Examples
 
-      iex> String.strip("a  abc  a", ?a)
+      iex> String.trim("a  abc  a", "a")
       "  abc  "
 
   """
-  @spec strip(t, char) :: t
-
-  def strip(string, char) do
-    rstrip(lstrip(string, char), char)
+  @spec trim(t, t) :: t
+  def trim(string, to_trim) when is_binary(string) and is_binary(to_trim) do
+    string
+    |> trim_leading(to_trim)
+    |> trim_trailing(to_trim)
   end
 
   @doc ~S"""
-  Returns a new string of length `len` with `subject` right justified and
-  padded with `padding`. If `padding` is not present, it defaults to
-  whitespace. When `len` is less than the length of `subject`, `subject` is
-  returned.
+  Returns a new string padded with a leading filler
+  which is made of elements from the `padding`.
+
+  Passing a list of strings as `padding` will take one element of the list
+  for every missing entry. If the list is shorter than the number of inserts,
+  the filling will start again from the beginning of the list.
+  Passing a string `padding` is equivalent to passing the list of graphemes in it.
+  If no `padding` is given, it defaults to whitespace.
+
+  When `count` is less than or equal to the length of `string`,
+  given `string` is returned.
+
+  Raises `ArgumentError` if the given `padding` contains a non-string element.
 
   ## Examples
 
-      iex> String.rjust("abc", 5)
+      iex> String.pad_leading("abc", 5)
       "  abc"
 
-      iex> String.rjust("abc", 5, ?-)
-      "--abc"
+      iex> String.pad_leading("abc", 4, "12")
+      "1abc"
+
+      iex> String.pad_leading("abc", 6, "12")
+      "121abc"
+
+      iex> String.pad_leading("abc", 5, ["1", "23"])
+      "123abc"
 
   """
-  @spec rjust(t, pos_integer) :: t
-  @spec rjust(t, pos_integer, char) :: t
+  @spec pad_leading(t, non_neg_integer, t | [t]) :: t
+  def pad_leading(string, count, padding \\ [" "])
 
-  def rjust(subject, len) do
-    rjust(subject, len, ?\s)
+  def pad_leading(string, count, padding) when is_binary(padding) do
+    pad_leading(string, count, graphemes(padding))
   end
 
-  def rjust(subject, len, padding) when is_integer(padding) do
-    do_justify(subject, len, padding, :right)
+  def pad_leading(string, count, [_ | _] = padding)
+      when is_binary(string) and is_integer(count) and count >= 0 do
+    pad(:leading, string, count, padding)
   end
 
   @doc ~S"""
-  Returns a new string of length `len` with `subject` left justified and padded
-  with `padding`. If `padding` is not present, it defaults to whitespace. When
-  `len` is less than the length of `subject`, `subject` is returned.
+  Returns a new string padded with a trailing filler
+  which is made of elements from the `padding`.
+
+  Passing a list of strings as `padding` will take one element of the list
+  for every missing entry. If the list is shorter than the number of inserts,
+  the filling will start again from the beginning of the list.
+  Passing a string `padding` is equivalent to passing the list of graphemes in it.
+  If no `padding` is given, it defaults to whitespace.
+
+  When `count` is less than or equal to the length of `string`,
+  given `string` is returned.
+
+  Raises `ArgumentError` if the given `padding` contains a non-string element.
 
   ## Examples
 
-      iex> String.ljust("abc", 5)
+      iex> String.pad_trailing("abc", 5)
       "abc  "
 
-      iex> String.ljust("abc", 5, ?-)
-      "abc--"
+      iex> String.pad_trailing("abc", 4, "12")
+      "abc1"
+
+      iex> String.pad_trailing("abc", 6, "12")
+      "abc121"
+
+      iex> String.pad_trailing("abc", 5, ["1", "23"])
+      "abc123"
 
   """
-  @spec ljust(t, pos_integer) :: t
-  @spec ljust(t, pos_integer, char) :: t
+  @spec pad_trailing(t, non_neg_integer, t | [t]) :: t
+  def pad_trailing(string, count, padding \\ [" "])
 
-  def ljust(subject, len) do
-    ljust(subject, len, ?\s)
+  def pad_trailing(string, count, padding) when is_binary(padding) do
+    pad_trailing(string, count, graphemes(padding))
   end
 
-  def ljust(subject, len, padding) when is_integer(padding) do
-    do_justify(subject, len, padding, :left)
+  def pad_trailing(string, count, [_ | _] = padding)
+      when is_binary(string) and is_integer(count) and count >= 0 do
+    pad(:trailing, string, count, padding)
   end
 
-  defp do_justify(subject, 0, _padding, _type) do
-    subject
-  end
+  defp pad(kind, string, count, padding) do
+    string_length = length(string)
 
-  defp do_justify(subject, len, padding, type) when is_integer(padding) do
-    subject_len = length(subject)
+    if string_length >= count do
+      string
+    else
+      filler = build_filler(count - string_length, padding, padding, 0, [])
 
-    cond do
-      subject_len >= len ->
-        subject
-      subject_len < len ->
-        fill = duplicate(<<padding :: utf8>>, len - subject_len)
-
-        case type do
-          :left  -> subject <> fill
-          :right -> fill <> subject
-        end
+      case kind do
+        :leading -> [filler | string]
+        :trailing -> [string | filler]
+      end
+      |> IO.iodata_to_binary()
     end
   end
 
+  defp build_filler(0, _source, _padding, _size, filler), do: filler
+
+  defp build_filler(count, source, [], size, filler) do
+    rem_filler =
+      rem(count, size)
+      |> build_filler(source, source, 0, [])
+
+    filler =
+      filler
+      |> IO.iodata_to_binary()
+      |> duplicate(div(count, size) + 1)
+
+    [filler | rem_filler]
+  end
+
+  defp build_filler(count, source, [elem | rest], size, filler)
+       when is_binary(elem) do
+    build_filler(count - 1, source, rest, size + 1, [filler | elem])
+  end
+
+  defp build_filler(_count, _source, [elem | _rest], _size, _filler) do
+    raise ArgumentError, "expected a string padding element, got: #{inspect(elem)}"
+  end
+
+  @doc false
+  @deprecated "Use String.pad_leading/2 instead"
+  def rjust(subject, length) do
+    rjust(subject, length, ?\s)
+  end
+
+  @doc false
+  @deprecated "Use String.pad_leading/3 with a binary padding instead"
+  def rjust(subject, length, pad) when is_integer(pad) and is_integer(length) and length >= 0 do
+    pad(:leading, subject, length, [<<pad::utf8>>])
+  end
+
+  @doc false
+  @deprecated "Use String.pad_trailing/2 instead"
+  def ljust(subject, length) do
+    ljust(subject, length, ?\s)
+  end
+
+  @doc false
+  @deprecated "Use String.pad_trailing/3 with a binary padding instead"
+  def ljust(subject, length, pad) when is_integer(pad) and is_integer(length) and length >= 0 do
+    pad(:trailing, subject, length, [<<pad::utf8>>])
+  end
+
   @doc ~S"""
-  Returns a new binary based on `subject` by replacing the parts
-  matching `pattern` by `replacement`. By default, it replaces
-  all entries, except if the `global` option is set to `false`.
+  Returns a new string created by replacing occurrences of `pattern` in
+  `subject` with `replacement`.
+
+  The `subject` is always a string.
+
+  The `pattern` may be a string, a list of strings, a regular expression, or a
+  compiled pattern.
 
-  A `pattern` may be a string or a regex.
+  The `replacement` may be a string or a function that receives the matched
+  pattern and must return the replacement as a string or iodata.
+
+  By default it replaces all occurrences but this behavior can be controlled
+  through the `:global` option; see the "Options" section below.
+
+  ## Options
+
+    * `:global` - (boolean) if `true`, all occurrences of `pattern` are replaced
+      with `replacement`, otherwise only the first occurrence is
+      replaced. Defaults to `true`
 
   ## Examples
 
@@ -577,52 +1577,163 @@ defmodule String do
       iex> String.replace("a,b,c", ",", "-", global: false)
       "a-b,c"
 
-  The pattern can also be a regex. In those cases, one can give `\N`
-  in the `replacement` string to access a specific capture in the regex:
+  The pattern may also be a list of strings and the replacement may also
+  be a function that receives the matches:
+
+      iex> String.replace("a,b,c", ["a", "c"], fn <<char>> -> <<char + 1>> end)
+      "b,b,d"
 
-      iex> String.replace("a,b,c", ~r/,(.)/, ",\\1\\1")
+  When the pattern is a regular expression, one can give `\N` or
+  `\g{N}` in the `replacement` string to access a specific capture in the
+  regular expression:
+
+      iex> String.replace("a,b,c", ~r/,(.)/, ",\\1\\g{1}")
       "a,bb,cc"
 
-  Notice we had to escape the escape character `\`. By giving `&`,
-  one can inject the whole matched pattern in the replacement string.
+  Note that we had to escape the backslash escape character (i.e., we used `\\N`
+  instead of just `\N` to escape the backslash; same thing for `\\g{N}`). By
+  giving `\0`, one can inject the whole match in the replacement string.
+
+  A compiled pattern can also be given:
+
+      iex> pattern = :binary.compile_pattern(",")
+      iex> String.replace("a,b,c", pattern, "[]")
+      "a[]b[]c"
+
+  When an empty string is provided as a `pattern`, the function will treat it as
+  an implicit empty string between each grapheme and the string will be
+  interspersed. If an empty string is provided as `replacement` the `subject`
+  will be returned:
 
-  When strings are used as a pattern, a developer can also use the
-  replaced part inside the `replacement` via the `:insert_replaced` option:
+      iex> String.replace("ELIXIR", "", ".")
+      ".E.L.I.X.I.R."
 
-      iex> String.replace("a,b,c", "b", "[]", insert_replaced: 1)
-      "a,[b],c"
+      iex> String.replace("ELIXIR", "", "")
+      "ELIXIR"
 
-      iex> String.replace("a,b,c", ",", "[]", insert_replaced: 2)
-      "a[],b[],c"
+  Be aware that this function can replace within or across grapheme boundaries.
+  For example, take the grapheme "é" which is made of the characters
+  "e" and the acute accent. The following will replace only the letter "e",
+  moving the accent to the letter "o":
 
-      iex> String.replace("a,b,c", ",", "[]", insert_replaced: [1, 1])
-      "a[,,]b[,,]c"
+      iex> String.replace(String.normalize("é", :nfd), "e", "o")
+      "ó"
+
+  However, if "é" is represented by the single character "e with acute"
+  accent, then it won't be replaced at all:
+
+      iex> String.replace(String.normalize("é", :nfc), "e", "o")
+      "é"
 
   """
-  @spec replace(t, t, t) :: t
-  @spec replace(t, t, t, Keyword.t) :: t
+  @spec replace(t, pattern | Regex.t(), t | (t -> t | iodata), replace_opts) :: t
+  def replace(subject, pattern, replacement, options \\ [])
+      when is_binary(subject) and
+             (is_binary(replacement) or is_function(replacement, 1)) and
+             is_list(options) do
+    replace_guarded(subject, pattern, replacement, options)
+  end
 
-  def replace(subject, pattern, replacement, options \\ []) when is_binary(replacement) do
-    if Regex.regex?(pattern) do
-      Regex.replace(pattern, subject, replacement, global: options[:global])
+  defp replace_guarded(subject, %{__struct__: Regex} = regex, replacement, options) do
+    Regex.replace(regex, subject, replacement, options)
+  end
+
+  defp replace_guarded(subject, "", "", _) do
+    subject
+  end
+
+  defp replace_guarded(subject, [], _, _) do
+    subject
+  end
+
+  defp replace_guarded(subject, "", replacement_binary, options)
+       when is_binary(replacement_binary) do
+    if Keyword.get(options, :global, true) do
+      intersperse_bin(subject, replacement_binary, [replacement_binary])
     else
-      opts = translate_replace_options(options)
-      :binary.replace(subject, pattern, replacement, opts)
+      replacement_binary <> subject
     end
   end
 
-  defp translate_replace_options(options) do
-    opts = if Keyword.get(options, :global) != false, do: [:global], else: []
+  defp replace_guarded(subject, "", replacement_fun, options) do
+    if Keyword.get(options, :global, true) do
+      intersperse_fun(subject, replacement_fun, [replacement_fun.("")])
+    else
+      IO.iodata_to_binary([replacement_fun.("") | subject])
+    end
+  end
 
+  defp replace_guarded(subject, pattern, replacement, options) do
     if insert = Keyword.get(options, :insert_replaced) do
-      opts = [{:insert_replaced, insert}|opts]
+      IO.warn(
+        "String.replace/4 with :insert_replaced option is deprecated. " <>
+          "Please use :binary.replace/4 instead or pass an anonymous function as replacement"
+      )
+
+      binary_options = if Keyword.get(options, :global) != false, do: [:global], else: []
+      :binary.replace(subject, pattern, replacement, [insert_replaced: insert] ++ binary_options)
+    else
+      matches =
+        if Keyword.get(options, :global, true) do
+          :binary.matches(subject, pattern)
+        else
+          case :binary.match(subject, pattern) do
+            :nomatch -> []
+            match -> [match]
+          end
+        end
+
+      IO.iodata_to_binary(do_replace(subject, matches, replacement, 0))
     end
+  end
+
+  defp intersperse_bin(subject, replacement, acc) do
+    case :unicode_util.gc(subject) do
+      [current | rest] ->
+        intersperse_bin(rest, replacement, [replacement, current | acc])
 
-    opts
+      [] ->
+        reverse_characters_to_binary(acc)
+
+      {:error, <<byte, rest::bits>>} ->
+        reverse_characters_to_binary(acc) <>
+          <<byte>> <> intersperse_bin(rest, replacement, [replacement])
+    end
   end
 
-  @doc """
-  Reverses the given string. Works on graphemes.
+  defp intersperse_fun(subject, replacement, acc) do
+    case :unicode_util.gc(subject) do
+      [current | rest] ->
+        intersperse_fun(rest, replacement, [replacement.(""), current | acc])
+
+      [] ->
+        reverse_characters_to_binary(acc)
+
+      {:error, <<byte, rest::bits>>} ->
+        reverse_characters_to_binary(acc) <>
+          <<byte>> <> intersperse_fun(rest, replacement, [replacement.("")])
+    end
+  end
+
+  defp do_replace(subject, [], _, n) do
+    [binary_part(subject, n, byte_size(subject) - n)]
+  end
+
+  defp do_replace(subject, [{start, length} | matches], replacement, n) do
+    prefix = binary_part(subject, n, start - n)
+
+    middle =
+      if is_binary(replacement) do
+        replacement
+      else
+        replacement.(binary_part(subject, start, length))
+      end
+
+    [prefix, middle | do_replace(subject, matches, replacement, start + length)]
+  end
+
+  @doc ~S"""
+  Reverses the graphemes in given string.
 
   ## Examples
 
@@ -635,20 +1746,40 @@ defmodule String do
       iex> String.reverse("hello ∂og")
       "go∂ olleh"
 
+  Keep in mind reversing the same string twice does
+  not necessarily yield the original string:
+
+      iex> "̀e"
+      "̀e"
+      iex> String.reverse("̀e")
+      "è"
+      iex> String.reverse(String.reverse("̀e"))
+      "è"
+
+  In the first example the accent is before the vowel, so
+  it is considered two graphemes. However, when you reverse
+  it once, you have the vowel followed by the accent, which
+  becomes one grapheme. Reversing it again will keep it as
+  one single grapheme.
   """
   @spec reverse(t) :: t
-  def reverse(string) do
-    do_reverse(next_grapheme(string), [])
+  def reverse(string) when is_binary(string) do
+    do_reverse(:unicode_util.gc(string), [])
   end
 
-  defp do_reverse({grapheme, rest}, acc) do
-    do_reverse(next_grapheme(rest), [grapheme|acc])
-  end
+  defp do_reverse([grapheme | rest], acc),
+    do: do_reverse(:unicode_util.gc(rest), [grapheme | acc])
+
+  defp do_reverse([], acc),
+    do: :unicode.characters_to_binary(acc)
 
-  defp do_reverse(nil, acc), do: IO.iodata_to_binary(acc)
+  defp do_reverse({:error, <<byte, rest::bits>>}, acc),
+    do: :unicode.characters_to_binary(acc) <> <<byte>> <> do_reverse(:unicode_util.gc(rest), [])
 
   @doc """
-  Returns a binary `subject` duplicated `n` times.
+  Returns a string `subject` repeated `n` times.
+
+  Inlined by the compiler.
 
   ## Examples
 
@@ -662,53 +1793,122 @@ defmodule String do
       "abcabc"
 
   """
-  @spec duplicate(t, pos_integer) :: t
-  def duplicate(subject, n) when is_integer(n) and n >= 0 do
+  @compile {:inline, duplicate: 2}
+  @spec duplicate(t, non_neg_integer) :: t
+  def duplicate(subject, n) when is_binary(subject) and is_integer(n) and n >= 0 do
     :binary.copy(subject, n)
   end
 
-  @doc """
-  Returns all codepoints in the string.
+  @doc ~S"""
+  Returns a list of code points encoded as strings.
+
+  To retrieve code points in their natural integer
+  representation, see `to_charlist/1`. For details about
+  code points and graphemes, see the `String` module
+  documentation.
 
   ## Examples
 
-      iex> String.codepoints("josé")
-      ["j", "o", "s", "é"]
+      iex> String.codepoints("olá")
+      ["o", "l", "á"]
 
-      iex> String.codepoints("оптими зации")
-      ["о","п","т","и","м","и"," ","з","а","ц","и","и"]
+      iex> String.codepoints("оптимі зації")
+      ["о", "п", "т", "и", "м", "і", " ", "з", "а", "ц", "і", "ї"]
 
       iex> String.codepoints("ἅἪῼ")
-      ["ἅ","Ἢ","ῼ"]
+      ["ἅ", "Ἢ", "ῼ"]
+
+      iex> String.codepoints("\u00e9")
+      ["é"]
+
+      iex> String.codepoints("\u0065\u0301")
+      ["e", "́"]
 
   """
   @spec codepoints(t) :: [codepoint]
-  defdelegate codepoints(string), to: String.Unicode
+  def codepoints(string) when is_binary(string) do
+    do_codepoints(string)
+  end
 
-  @doc """
-  Returns the next codepoint in a String.
+  defp do_codepoints(<<codepoint::utf8, rest::bits>>) do
+    [<<codepoint::utf8>> | do_codepoints(rest)]
+  end
+
+  defp do_codepoints(<<byte, rest::bits>>) do
+    [<<byte>> | do_codepoints(rest)]
+  end
+
+  defp do_codepoints(<<>>), do: []
 
-  The result is a tuple with the codepoint and the
-  remaining of the string or `nil` in case
+  @doc ~S"""
+  Returns the next code point in a string.
+
+  The result is a tuple with the code point and the
+  remainder of the string or `nil` in case
   the string reached its end.
 
-  As with other functions in the String module, this
-  function does not check for the validity of the codepoint.
-  That said, if an invalid codepoint is found, it will
-  be returned by this function.
+  As with other functions in the `String` module, `next_codepoint/1`
+  works with binaries that are invalid UTF-8. If the string starts
+  with a sequence of bytes that is not valid in UTF-8 encoding, the
+  first element of the returned tuple is a binary with the first byte.
 
   ## Examples
 
-      iex> String.next_codepoint("josé")
-      {"j", "osé"}
+      iex> String.next_codepoint("olá")
+      {"o", "lá"}
+
+      iex> invalid = "\x80\x80OK" # first two bytes are invalid in UTF-8
+      iex> {_, rest} = String.next_codepoint(invalid)
+      {<<128>>, <<128, 79, 75>>}
+      iex> String.next_codepoint(rest)
+      {<<128>>, "OK"}
+
+  ## Comparison with binary pattern matching
 
+  Binary pattern matching provides a similar way to decompose
+  a string:
+
+      iex> <<codepoint::utf8, rest::binary>> = "Elixir"
+      "Elixir"
+      iex> codepoint
+      69
+      iex> rest
+      "lixir"
+
+  though not entirely equivalent because `codepoint` comes as
+  an integer, and the pattern won't match invalid UTF-8.
+
+  Binary pattern matching, however, is simpler and more efficient,
+  so pick the option that better suits your use case.
   """
-  @compile {:inline, next_codepoint: 1}
   @spec next_codepoint(t) :: {codepoint, t} | nil
-  defdelegate next_codepoint(string), to: String.Unicode
+  def next_codepoint(<<cp::utf8, rest::binary>>), do: {<<cp::utf8>>, rest}
+  def next_codepoint(<<byte, rest::binary>>), do: {<<byte>>, rest}
+  def next_codepoint(<<>>), do: nil
 
   @doc ~S"""
-  Checks whether `str` contains only valid characters.
+  Checks whether `string` contains only valid characters.
+
+  `algorithm` may be `:default` or `:fast_ascii`. Both algorithms are equivalent
+  from a validation perspective (they will always produce the same output), but
+  `:fast_ascii` can yield significant performance benefits in specific scenarios.
+
+  If anything else but a string is given as argument, it raises.
+
+  ## Fast ASCII
+
+  If all of the following conditions are true, you may want to experiment with
+  the `:fast_ascii` algorithm to see if it yields performance benefits in your
+  specific scenario:
+
+  * You expect most of your strings to be longer than ~64 bytes
+  * You expect most of your strings to contain mostly ASCII codepoints
+
+  Note that the `:fast_ascii` algorithm does not affect correctness, you can
+  expect the output of `String.valid?/2` to be the same regardless of algorithm.
+  The only difference to be expected is one of performance, which can be
+  expected to improve roughly linearly in string length compared to the
+  `:default` algorithm.
 
   ## Examples
 
@@ -718,64 +1918,159 @@ defmodule String do
       iex> String.valid?("ø")
       true
 
-      iex> String.valid?(<<0xffff :: 16>>)
+      iex> String.valid?(<<0xFFFF::16>>)
       false
 
-      iex> String.valid?("asd" <> <<0xffff :: 16>>)
+      iex> String.valid?(<<0xEF, 0xB7, 0x90>>)
+      true
+
+      iex> String.valid?("asd" <> <<0xFFFF::16>>)
       false
 
+      iex> String.valid?("a", :fast_ascii)
+      true
+
   """
-  @spec valid?(t) :: boolean
+  @spec valid?(t, :default | :fast_ascii) :: boolean
+  def valid?(string, algorithm \\ :default)
+
+  def valid?(<<string::binary>>, :default), do: valid_utf8?(string)
+  def valid?(<<string::binary>>, :fast_ascii), do: valid_utf8_fast_ascii?(string)
 
-  noncharacters = Enum.to_list(?\x{FDD0}..?\x{FDEF}) ++
-    [ ?\x{0FFFE}, ?\x{0FFFF}, ?\x{1FFFE}, ?\x{1FFFF}, ?\x{2FFFE}, ?\x{2FFFF},
-      ?\x{3FFFE}, ?\x{3FFFF}, ?\x{4FFFE}, ?\x{4FFFF}, ?\x{5FFFE}, ?\x{5FFFF},
-      ?\x{6FFFE}, ?\x{6FFFF}, ?\x{7FFFE}, ?\x{7FFFF}, ?\x{8FFFE}, ?\x{8FFFF},
-      ?\x{9FFFE}, ?\x{9FFFF}, ?\x{10FFFE}, ?\x{10FFFF} ]
+  defp valid_utf8?(<<_::utf8, rest::bits>>), do: valid_utf8?(rest)
+  defp valid_utf8?(<<>>), do: true
+  defp valid_utf8?(_), do: false
 
-  for noncharacter <- noncharacters do
-    def valid?(<< unquote(noncharacter) :: utf8, _ :: binary >>), do: false
+  defp valid_utf8_fast_ascii?(<<a::56, rest::bits>>)
+       when Bitwise.band(0x80808080808080, a) == 0 do
+    valid_utf8_fast_ascii?(rest)
   end
 
-  def valid?(<<_ :: utf8, t :: binary>>), do: valid?(t)
-  def valid?(<<>>), do: true
-  def valid?(_), do: false
+  defp valid_utf8_fast_ascii?(<<_::utf8, rest::bits>>), do: valid_utf8_fast_ascii?(rest)
+  defp valid_utf8_fast_ascii?(<<>>), do: true
+  defp valid_utf8_fast_ascii?(_), do: false
 
-  @doc ~S"""
-  Checks whether `str` is a valid character.
+  @doc false
+  @deprecated "Use String.valid?/1 instead"
+  def valid_character?(string) do
+    case string do
+      <<_::utf8>> -> valid?(string)
+      _ -> false
+    end
+  end
+
+  defguardp replace_invalid_ii_of_iii(i, ii)
+            when Bitwise.bor(Bitwise.bsl(i, 6), ii) in 32..863 or
+                   Bitwise.bor(Bitwise.bsl(i, 6), ii) in 896..1023
 
-  All characters are codepoints, but some codepoints
-  are not valid characters. They may be reserved, private,
-  or other.
+  defguardp replace_invalid_ii_of_iv(i, ii)
+            when Bitwise.bor(Bitwise.bsl(i, 6), ii) in 16..271
 
-  More info at: http://en.wikipedia.org/wiki/Mapping_of_Unicode_characters#Noncharacters
+  defguardp replace_invalid_iii_of_iv(i, ii, iii)
+            when Bitwise.bor(Bitwise.bor(Bitwise.bsl(i, 12), Bitwise.bsl(ii, 6)), iii) in 1024..17407
+
+  defguardp replace_invalid_is_next(next) when Bitwise.bsr(next, 6) !== 0b10
+
+  @doc ~S"""
+  Returns a new string created by replacing all invalid bytes with `replacement` (`"�"` by default).
 
   ## Examples
 
-      iex> String.valid_character?("a")
-      true
+      iex> String.replace_invalid("asd" <> <<0xFF::8>>)
+      "asd�"
 
-      iex> String.valid_character?("ø")
-      true
+      iex> String.replace_invalid("nem rán bề bề")
+      "nem rán bề bề"
 
-      iex> String.valid_character?("\x{ffff}")
-      false
+      iex> String.replace_invalid("nem rán b" <> <<225, 187>> <> " bề")
+      "nem rán b� bề"
 
+      iex> String.replace_invalid("nem rán b" <> <<225, 187>> <> " bề", "ERROR!")
+      "nem rán bERROR! bề"
   """
-  @spec valid_character?(t) :: boolean
+  @doc since: "1.16.0"
+  @spec replace_invalid(binary, t) :: t
+  def replace_invalid(bytes, replacement \\ "�")
+      when is_binary(bytes) and is_binary(replacement) do
+    do_replace_invalid(bytes, replacement, <<>>)
+  end
+
+  # Valid ASCII (for better average speed)
+  defp do_replace_invalid(<<ascii::8, next::8, _::binary>> = rest, rep, acc)
+       when ascii in 0..127 and replace_invalid_is_next(next) do
+    <<_::8, rest::binary>> = rest
+    do_replace_invalid(rest, rep, acc <> <<ascii::8>>)
+  end
+
+  # Valid UTF-8
+  defp do_replace_invalid(<<grapheme::utf8, rest::binary>>, rep, acc) do
+    do_replace_invalid(rest, rep, acc <> <<grapheme::utf8>>)
+  end
+
+  # 2/3 truncated sequence
+  defp do_replace_invalid(<<0b1110::4, i::4, 0b10::2, ii::6>>, rep, acc)
+       when replace_invalid_ii_of_iii(i, ii) do
+    acc <> rep
+  end
+
+  defp do_replace_invalid(
+         <<0b1110::4, i::4, 0b10::2, ii::6, next::8, _::binary>> = rest,
+         rep,
+         acc
+       )
+       when replace_invalid_ii_of_iii(i, ii) and replace_invalid_is_next(next) do
+    <<_::16, rest::binary>> = rest
+    do_replace_invalid(rest, rep, acc <> rep)
+  end
+
+  # 2/4
+  defp do_replace_invalid(<<0b11110::5, i::3, 0b10::2, ii::6>>, rep, acc)
+       when replace_invalid_ii_of_iv(i, ii) do
+    acc <> rep
+  end
+
+  defp do_replace_invalid(
+         <<0b11110::5, i::3, 0b10::2, ii::6, next::8, _::binary>> = rest,
+         rep,
+         acc
+       )
+       when replace_invalid_ii_of_iv(i, ii) and replace_invalid_is_next(next) do
+    <<_::16, rest::binary>> = rest
+    do_replace_invalid(rest, rep, acc <> rep)
+  end
+
+  # 3/4
+  defp do_replace_invalid(<<0b11110::5, i::3, 0b10::2, ii::6, 0b10::2, iii::6>>, rep, acc)
+       when replace_invalid_iii_of_iv(i, ii, iii) do
+    acc <> rep
+  end
+
+  defp do_replace_invalid(
+         <<0b11110::5, i::3, 0b10::2, ii::6, 0b10::2, iii::6, next::8, _::binary>> = rest,
+         rep,
+         acc
+       )
+       when replace_invalid_iii_of_iv(i, ii, iii) and replace_invalid_is_next(next) do
+    <<_::24, rest::binary>> = rest
+    do_replace_invalid(rest, rep, acc <> rep)
+  end
+
+  # Everything else
+  defp do_replace_invalid(<<_, rest::binary>>, rep, acc),
+    do: do_replace_invalid(rest, rep, acc <> rep)
 
-  def valid_character?(<<_ :: utf8>> = codepoint), do: valid?(codepoint)
-  def valid_character?(_), do: false
+  # Final
+  defp do_replace_invalid(<<>>, _, acc), do: acc
 
   @doc ~S"""
   Splits the string into chunks of characters that share a common trait.
 
   The trait can be one of two options:
 
-    * `:valid` – the string is split into chunks of valid and invalid character
-      sequences
+    * `:valid` - the string is split into chunks of valid and invalid
+      character sequences
 
-    * `:printable` – the string is split into chunks of printable and
+    * `:printable` - the string is split into chunks of printable and
       non-printable character sequences
 
   Returns a list of binaries each of which contains only one kind of
@@ -786,13 +2081,13 @@ defmodule String do
   ## Examples
 
       iex> String.chunk(<<?a, ?b, ?c, 0>>, :valid)
-      ["abc\000"]
+      [<<97, 98, 99, 0>>]
 
-      iex> String.chunk(<<?a, ?b, ?c, 0, 0x0ffff::utf8>>, :valid)
-      ["abc\000", <<0x0ffff::utf8>>]
+      iex> String.chunk(<<?a, ?b, ?c, 0, 0xFFFF::utf16>>, :valid)
+      [<<97, 98, 99, 0>>, <<255, 255>>]
 
-      iex> String.chunk(<<?a, ?b, ?c, 0, 0x0ffff::utf8>>, :printable)
-      ["abc", <<0, 0x0ffff::utf8>>]
+      iex> String.chunk(<<?a, ?b, ?c, 0, 0x0FFFF::utf8>>, :printable)
+      ["abc", <<0, 239, 191, 191>>]
 
   """
   @spec chunk(t, :valid | :printable) :: [t]
@@ -801,23 +2096,23 @@ defmodule String do
 
   def chunk("", _), do: []
 
-  def chunk(str, trait) when trait in [:valid, :printable] do
-    {cp, _} = next_codepoint(str)
+  def chunk(string, trait) when is_binary(string) and trait in [:valid, :printable] do
+    {cp, _} = next_codepoint(string)
     pred_fn = make_chunk_pred(trait)
-    do_chunk(str, pred_fn.(cp), pred_fn)
+    do_chunk(string, pred_fn.(cp), pred_fn)
   end
 
-
-  defp do_chunk(str, flag, pred_fn), do: do_chunk(str, [], <<>>, flag, pred_fn)
+  defp do_chunk(string, flag, pred_fn), do: do_chunk(string, [], <<>>, flag, pred_fn)
 
   defp do_chunk(<<>>, acc, <<>>, _, _), do: Enum.reverse(acc)
 
   defp do_chunk(<<>>, acc, chunk, _, _), do: Enum.reverse(acc, [chunk])
 
-  defp do_chunk(str, acc, chunk, flag, pred_fn) do
-    {cp, rest} = next_codepoint(str)
+  defp do_chunk(string, acc, chunk, flag, pred_fn) do
+    {cp, rest} = next_codepoint(string)
+
     if pred_fn.(cp) != flag do
-      do_chunk(rest, [chunk|acc], cp, not flag, pred_fn)
+      do_chunk(rest, [chunk | acc], cp, not flag, pred_fn)
     else
       do_chunk(rest, acc, chunk <> cp, flag, pred_fn)
     end
@@ -826,40 +2121,97 @@ defmodule String do
   defp make_chunk_pred(:valid), do: &valid?/1
   defp make_chunk_pred(:printable), do: &printable?/1
 
-  @doc """
-  Returns unicode graphemes in the string as per Extended Grapheme
-  Cluster algorithm outlined in the [Unicode Standard Annex #29,
-  Unicode Text Segmentation](http://www.unicode.org/reports/tr29/).
+  @doc ~S"""
+  Returns Unicode graphemes in the string as per Extended Grapheme
+  Cluster algorithm.
+
+  The algorithm is outlined in the [Unicode Standard Annex #29,
+  Unicode Text Segmentation](https://www.unicode.org/reports/tr29/).
+
+  For details about code points and graphemes, see the `String` module documentation.
+
+  ## Examples
+
+      iex> String.graphemes("Ńaïve")
+      ["Ń", "a", "ï", "v", "e"]
 
-  ## Examples
+      iex> String.graphemes("\u00e9")
+      ["é"]
 
-      iex> String.graphemes("Ā̀stute")
-      ["Ā̀","s","t","u","t","e"]
+      iex> String.graphemes("\u0065\u0301")
+      ["é"]
 
   """
+  @compile {:inline, graphemes: 1}
   @spec graphemes(t) :: [grapheme]
-  defdelegate graphemes(string), to: String.Graphemes
+  def graphemes(string) when is_binary(string), do: do_graphemes(string)
+
+  defp do_graphemes(gcs) do
+    case :unicode_util.gc(gcs) do
+      [gc | rest] -> [grapheme_to_binary(gc) | do_graphemes(rest)]
+      [] -> []
+      {:error, <<byte, rest::bits>>} -> [<<byte>> | do_graphemes(rest)]
+    end
+  end
 
   @doc """
-  Returns the next grapheme in a String.
+  Returns the next grapheme in a string.
 
   The result is a tuple with the grapheme and the
-  remaining of the string or `nil` in case
+  remainder of the string or `nil` in case
   the String reached its end.
 
   ## Examples
 
-      iex> String.next_grapheme("josé")
-      {"j", "osé"}
+      iex> String.next_grapheme("olá")
+      {"o", "lá"}
+
+      iex> String.next_grapheme("")
+      nil
 
   """
   @compile {:inline, next_grapheme: 1}
   @spec next_grapheme(t) :: {grapheme, t} | nil
-  defdelegate next_grapheme(string), to: String.Graphemes
+  def next_grapheme(string) when is_binary(string) do
+    case :unicode_util.gc(string) do
+      [gc] -> {grapheme_to_binary(gc), <<>>}
+      [gc, rest] -> {grapheme_to_binary(gc), rest}
+      [gc | rest] -> {grapheme_to_binary(gc), rest}
+      [] -> nil
+      {:error, <<byte, rest::bits>>} -> {<<byte>>, rest}
+    end
+  end
+
+  @doc """
+  Returns the size (in bytes) of the next grapheme.
+
+  The result is a tuple with the next grapheme size in bytes and
+  the remainder of the string or `nil` in case the string
+  reached its end.
+
+  ## Examples
+
+      iex> String.next_grapheme_size("olá")
+      {1, "lá"}
+
+      iex> String.next_grapheme_size("")
+      nil
+
+  """
+  @spec next_grapheme_size(t) :: {pos_integer, t} | nil
+  def next_grapheme_size(string) when is_binary(string) do
+    case :unicode_util.gc(string) do
+      [gc] -> {grapheme_byte_size(gc), <<>>}
+      [gc, rest] -> {grapheme_byte_size(gc), rest}
+      [gc | rest] -> {grapheme_byte_size(gc), rest}
+      [] -> nil
+      {:error, <<_, rest::bits>>} -> {1, rest}
+    end
+  end
 
   @doc """
-  Returns the first grapheme from an utf8 string,
-  nil if the string is empty.
+  Returns the first grapheme from a UTF-8 string,
+  `nil` if the string is empty.
 
   ## Examples
 
@@ -869,21 +2221,30 @@ defmodule String do
       iex> String.first("եոգլի")
       "ե"
 
+      iex> String.first("")
+      nil
+
   """
   @spec first(t) :: grapheme | nil
-  def first(string) do
-    case next_grapheme(string) do
-      {char, _} -> char
-      nil -> nil
+  def first(string) when is_binary(string) do
+    case :unicode_util.gc(string) do
+      [gc | _] -> grapheme_to_binary(gc)
+      [] -> nil
+      {:error, <<byte, _::bits>>} -> <<byte>>
     end
   end
 
   @doc """
-  Returns the last grapheme from an utf8 string,
+  Returns the last grapheme from a UTF-8 string,
   `nil` if the string is empty.
 
+  It traverses the whole string to find its last grapheme.
+
   ## Examples
 
+      iex> String.last("")
+      nil
+
       iex> String.last("elixir")
       "r"
 
@@ -892,18 +2253,16 @@ defmodule String do
 
   """
   @spec last(t) :: grapheme | nil
-  def last(string) do
-    do_last(next_grapheme(string), nil)
-  end
-
-  defp do_last({char, rest}, _) do
-    do_last(next_grapheme(rest), char)
-  end
+  def last(""), do: nil
+  def last(string) when is_binary(string), do: do_last(:unicode_util.gc(string), nil)
 
-  defp do_last(nil, last_char), do: last_char
+  defp do_last([gc | rest], _), do: do_last(:unicode_util.gc(rest), gc)
+  defp do_last([], acc) when is_binary(acc), do: acc
+  defp do_last([], acc), do: :unicode.characters_to_binary([acc])
+  defp do_last({:error, <<byte, rest::bits>>}, _), do: do_last(:unicode_util.gc(rest), <<byte>>)
 
   @doc """
-  Returns the number of unicode graphemes in an utf8 string.
+  Returns the number of Unicode graphemes in a UTF-8 string.
 
   ## Examples
 
@@ -915,20 +2274,39 @@ defmodule String do
 
   """
   @spec length(t) :: non_neg_integer
-  def length(string) do
-    do_length(next_grapheme(string))
+  def length(string) when is_binary(string), do: length(string, 0)
+
+  defp length(<<byte1, byte2, rest::binary>> = binary, acc)
+       when byte1 <= 127 and byte1 != ?\r and byte2 <= 127 and byte2 != ?\r do
+    skip = skip_length(rest, 1)
+    length(binary_part(binary, skip, byte_size(binary) - skip), acc + skip)
   end
 
-  defp do_length({_, rest}) do
-    1 + do_length(next_grapheme(rest))
+  defp length(gcs, acc) do
+    case :unicode_util.gc(gcs) do
+      [_ | rest] -> length(rest, acc + 1)
+      [] -> acc
+      {:error, <<_, rest::bits>>} -> length(rest, acc + 1)
+    end
   end
 
-  defp do_length(nil), do: 0
+  defp skip_length(<<byte, rest::binary>>, acc)
+       when byte <= 127 and byte != ?\r,
+       do: skip_length(rest, acc + 1)
+
+  defp skip_length(_binary, acc),
+    do: acc
 
   @doc """
-  Returns the grapheme in the `position` of the given utf8 `string`.
+  Returns the grapheme at the `position` of the given UTF-8 `string`.
   If `position` is greater than `string` length, then it returns `nil`.
 
+  > #### Linear Access {: .warning}
+  >
+  > This function has to linearly traverse the string.
+  > If you want to access a string or a binary in constant time based on the
+  > number of bytes, use `Kernel.binary_slice/3` or `:binary.at/2` instead.
+
   ## Examples
 
       iex> String.at("elixir", 0)
@@ -949,31 +2327,37 @@ defmodule String do
   """
   @spec at(t, integer) :: grapheme | nil
 
-  def at(string, position) when position >= 0 do
-    do_at(next_grapheme(string), position, 0)
+  def at(string, position) when is_binary(string) and is_integer(position) and position >= 0 do
+    do_at(string, position)
   end
 
-  def at(string, position) when position < 0 do
-    real_pos = length(string) - abs(position)
-    case real_pos >= 0 do
-      true  -> do_at(next_grapheme(string), real_pos, 0)
+  def at(string, position) when is_binary(string) and is_integer(position) and position < 0 do
+    position = length(string) + position
+
+    case position >= 0 do
+      true -> do_at(string, position)
       false -> nil
     end
   end
 
-  defp do_at({_ , rest}, desired_pos, current_pos) when desired_pos > current_pos do
-    do_at(next_grapheme(rest), desired_pos, current_pos + 1)
-  end
+  defp do_at(string, position) do
+    left = byte_size_remaining_at(string, position)
 
-  defp do_at({char, _}, desired_pos, current_pos) when desired_pos == current_pos do
-    char
+    string
+    |> binary_part(byte_size(string) - left, left)
+    |> first()
   end
 
-  defp do_at(nil, _, _), do: nil
-
   @doc """
-  Returns a substring starting at the offset given by the first, and
-  a length given by the second.
+  Returns a substring starting at the offset `start`, and of the given `length`.
+
+  This function works on Unicode graphemes. For example, slicing the first
+  three characters of the string "héllo" will return "hél", which internally
+  is represented by more than three bytes. Use `String.byte_slice/3` if you
+  want to slice by a given number of bytes, while respecting the codepoint
+  boundaries. If you want to work on raw bytes, check `Kernel.binary_part/3`
+  or `Kernel.binary_slice/3` instead.
+
   If the offset is greater than string length, then it returns `""`.
 
   ## Examples
@@ -987,202 +2371,446 @@ defmodule String do
       iex> String.slice("elixir", 10, 3)
       ""
 
+  If the start position is negative, it is normalized
+  against the string length and clamped to 0:
+
       iex> String.slice("elixir", -4, 4)
       "ixir"
 
       iex> String.slice("elixir", -10, 3)
-      ""
+      "eli"
 
-      iex> String.slice("a", 0, 1500)
-      "a"
+  If start is more than the string length, an empty
+  string is returned:
 
-      iex> String.slice("a", 1, 1500)
-      ""
-
-      iex> String.slice("a", 2, 1500)
+      iex> String.slice("elixir", 10, 1500)
       ""
 
   """
-  @spec slice(t, integer, integer) :: grapheme
+  @spec slice(t, integer, non_neg_integer) :: grapheme
 
   def slice(_, _, 0) do
     ""
   end
 
-  def slice(string, start, len) when start >= 0 and len >= 0 do
-    do_slice(next_grapheme(string), start, start + len - 1, 0, "")
+  def slice(string, start, length)
+      when is_binary(string) and is_integer(start) and is_integer(length) and start >= 0 and
+             length >= 0 do
+    do_slice(string, start, length)
   end
 
-  def slice(string, start, len) when start < 0 and len >= 0 do
-    real_start_pos = length(string) - abs(start)
-    case real_start_pos >= 0 do
-      true -> do_slice(next_grapheme(string), real_start_pos, real_start_pos + len - 1, 0, "")
-      false -> ""
-    end
+  def slice(string, start, length)
+      when is_binary(string) and is_integer(start) and is_integer(length) and start < 0 and
+             length >= 0 do
+    start = max(length(string) + start, 0)
+    do_slice(string, start, length)
+  end
+
+  defp do_slice(string, start, length) do
+    from_start = byte_size_remaining_at(string, start)
+    rest = binary_part(string, byte_size(string) - from_start, from_start)
+
+    from_end = byte_size_remaining_at(rest, length)
+    binary_part(rest, 0, from_start - from_end)
   end
 
   @doc """
   Returns a substring from the offset given by the start of the
   range to the offset given by the end of the range.
 
+  This function works on Unicode graphemes. For example, slicing the first
+  three characters of the string "héllo" will return "hél", which internally
+  is represented by more than three bytes. Use `String.byte_slice/3` if you
+  want to slice by a given number of bytes, while respecting the codepoint
+  boundaries. If you want to work on raw bytes, check `Kernel.binary_part/3`
+  or `Kernel.binary_slice/3` instead.
+
   If the start of the range is not a valid offset for the given
   string or if the range is in reverse order, returns `""`.
 
+  If the start or end of the range is negative, the whole string
+  is traversed first in order to convert the negative indices into
+  positive ones.
+
   ## Examples
 
       iex> String.slice("elixir", 1..3)
       "lix"
-
       iex> String.slice("elixir", 1..10)
       "lixir"
 
-      iex> String.slice("elixir", 10..3)
-      ""
-
       iex> String.slice("elixir", -4..-1)
       "ixir"
-
-      iex> String.slice("elixir", 2..-1)
+      iex> String.slice("elixir", -4..6)
       "ixir"
+      iex> String.slice("elixir", -100..100)
+      "elixir"
 
-      iex> String.slice("elixir", -4..6)
+  For ranges where `start > stop`, you need to explicitly
+  mark them as increasing:
+
+      iex> String.slice("elixir", 2..-1//1)
       "ixir"
+      iex> String.slice("elixir", 1..-2//1)
+      "lixi"
 
-      iex> String.slice("elixir", -1..-4)
-      ""
+  You can use `../0` as a shortcut for `0..-1//1`, which returns
+  the whole string as is:
 
-      iex> String.slice("elixir", -10..-7)
-      ""
+      iex> String.slice("elixir", ..)
+      "elixir"
 
-      iex> String.slice("a", 0..1500)
-      "a"
+  The step can be any positive number. For example, to
+  get every 2 characters of the string:
 
-      iex> String.slice("a", 1..1500)
-      ""
+      iex> String.slice("elixir", 0..-1//2)
+      "eii"
+
+  If the first position is after the string ends or after
+  the last position of the range, it returns an empty string:
 
-      iex> String.slice("a", 2..1500)
+      iex> String.slice("elixir", 10..3//1)
+      ""
+      iex> String.slice("a", 1..1500)
       ""
 
   """
-  @spec slice(t, Range.t) :: t
+  @spec slice(t, Range.t()) :: t
+  def slice(string, first..last//step = range) when is_binary(string) do
+    # TODO: Support negative steps as a reverse on Elixir v2.0.
+    cond do
+      step > 0 ->
+        slice_range(string, first, last, step)
+
+      step == -1 and first > last ->
+        IO.warn(
+          "negative steps are not supported in String.slice/2, pass #{first}..#{last}//1 instead"
+        )
 
-  def slice(string, range)
+        slice_range(string, first, last, 1)
 
-  def slice(string, first..last) when first >= 0 and last >= 0 do
-    do_slice(next_grapheme(string), first, last, 0, "")
+      true ->
+        raise ArgumentError,
+              "String.slice/2 does not accept ranges with negative steps, got: #{inspect(range)}"
+    end
+  end
+
+  # TODO: Remove me on v2.0
+  def slice(string, %{__struct__: Range, first: first, last: last} = range)
+      when is_binary(string) do
+    step = if first <= last, do: 1, else: -1
+    slice(string, Map.put(range, :step, step))
   end
 
-  def slice(string, first..last) do
-    total = length(string)
+  defp slice_range("", _, _, _), do: ""
 
-    if first < 0 do
-      first = total + first
-    end
+  defp slice_range(_string, first, last, _step) when first >= 0 and last >= 0 and first > last do
+    ""
+  end
+
+  defp slice_range(string, first, last, step) when first >= 0 do
+    from_start = byte_size_remaining_at(string, first)
+    rest = binary_part(string, byte_size(string) - from_start, from_start)
+
+    cond do
+      last == -1 ->
+        slice_every(rest, byte_size(rest), step)
+
+      last >= 0 and step == 1 ->
+        from_end = byte_size_remaining_at(rest, last - first + 1)
+        binary_part(rest, 0, from_start - from_end)
 
-    if last < 0 do
-      last = total + last
+      last >= 0 ->
+        slice_every(rest, last - first + 1, step)
+
+      true ->
+        rest
+        |> slice_range_negative(0, last)
+        |> slice_every(byte_size(string), step)
     end
+  end
 
-    if first >= 0 do
-      do_slice(next_grapheme(string), first, last, 0, "")
-    else
+  defp slice_range(string, first, last, step) do
+    string
+    |> slice_range_negative(first, last)
+    |> slice_every(byte_size(string), step)
+  end
+
+  defp slice_range_negative(string, first, last) do
+    {reversed_bytes, length} = acc_bytes(string, [], 0)
+    first = add_if_negative(first, length) |> max(0)
+    last = add_if_negative(last, length)
+
+    if first > last or first > length do
       ""
+    else
+      last = min(last + 1, length)
+      reversed_bytes = Enum.drop(reversed_bytes, length - last)
+      {length_bytes, start_bytes} = split_bytes(reversed_bytes, 0, last - first)
+      binary_part(string, start_bytes, length_bytes)
     end
   end
 
-  defp do_slice(_, start_pos, last_pos, _, _) when start_pos > last_pos do
-    ""
+  defp slice_every(string, _count, 1), do: string
+  defp slice_every(string, count, step), do: slice_every(string, count, step, [])
+
+  defp slice_every(string, count, to_drop, acc) when count > 0 do
+    case :unicode_util.gc(string) do
+      [current | rest] ->
+        rest
+        |> drop(to_drop)
+        |> slice_every(count - to_drop, to_drop, [current | acc])
+
+      [] ->
+        reverse_characters_to_binary(acc)
+
+      {:error, <<byte, rest::bits>>} ->
+        reverse_characters_to_binary(acc) <>
+          <<byte>> <> slice_every(drop(rest, to_drop), count - to_drop, to_drop, [])
+    end
+  end
+
+  defp slice_every(_string, _count, _to_drop, acc) do
+    reverse_characters_to_binary(acc)
   end
 
-  defp do_slice({_, rest}, start_pos, last_pos, current_pos, acc) when current_pos < start_pos do
-    do_slice(next_grapheme(rest), start_pos, last_pos, current_pos + 1, acc)
+  defp drop(string, 1), do: string
+
+  defp drop(string, count) do
+    case :unicode_util.gc(string) do
+      [_ | rest] -> drop(rest, count - 1)
+      [] -> ""
+      {:error, <<_, rest::bits>>} -> drop(rest, count - 1)
+    end
+  end
+
+  defp acc_bytes(string, bytes, length) do
+    case :unicode_util.gc(string) do
+      [gc | rest] -> acc_bytes(rest, [grapheme_byte_size(gc) | bytes], length + 1)
+      [] -> {bytes, length}
+      {:error, <<_, rest::bits>>} -> acc_bytes(rest, [1 | bytes], length + 1)
+    end
   end
 
-  defp do_slice({char, rest}, start_pos, last_pos, current_pos, acc) when current_pos >= start_pos and current_pos < last_pos do
-    do_slice(next_grapheme(rest), start_pos, last_pos, current_pos + 1, acc <> char)
+  defp add_if_negative(value, to_add) when value < 0, do: value + to_add
+  defp add_if_negative(value, _to_add), do: value
+
+  defp split_bytes(rest, acc, 0), do: {acc, Enum.sum(rest)}
+  defp split_bytes([], acc, _), do: {acc, 0}
+  defp split_bytes([head | tail], acc, count), do: split_bytes(tail, head + acc, count - 1)
+
+  @doc """
+  Returns a substring starting at (or after) `start_bytes` and of at most
+  the given `size_bytes`.
+
+  This function works on bytes and then adjusts the string to eliminate
+  truncated codepoints. This is useful when you have a string and you need
+  to guarantee it does not exceed a certain amount of bytes.
+
+  If the offset is greater than the number of bytes in the string, then it
+  returns `""`. Similar to `String.slice/2`, a negative `start_bytes`
+  will be adjusted to the end of the string (but in bytes).
+
+  This function does not guarantee the string won't have invalid codepoints,
+  it only guarantees to remove truncated codepoints immediately at the beginning
+  or the end of the slice.
+
+  ## Examples
+
+  Consider the string "héllo". Let's see its representation:
+
+      iex> inspect("héllo", binaries: :as_binaries)
+      "<<104, 195, 169, 108, 108, 111>>"
+
+  Although the string has 5 characters, it is made of 6 bytes. Now imagine
+  we want to get only the first two bytes. To do so, let's use `binary_slice/3`,
+  which is unaware of codepoints:
+
+      iex> binary_slice("héllo", 0, 2)
+      <<104, 195>>
+
+  As you can see, this operation is unsafe and returns an invalid string.
+  That's because we cut the string in the middle of the bytes representing
+  "é". On the other hand, we could use `String.slice/3`:
+
+      iex> String.slice("héllo", 0, 2)
+      "hé"
+
+  While the above is correct, it has 3 bytes. If you have a requirement where
+  you need *at most* 2 bytes, the result would also be invalid. In such scenarios,
+  you can use this function, which will slice the given bytes, but clean up
+  the truncated codepoints:
+
+      iex> String.byte_slice("héllo", 0, 2)
+      "h"
+
+  Truncated codepoints at the beginning are also cleaned up:
+
+      iex> String.byte_slice("héllo", 2, 3)
+      "llo"
+
+  Note that, if you want to work on raw bytes, then you must use `binary_slice/3`
+  instead.
+  """
+  @doc since: "1.17.0"
+  @spec byte_slice(t, integer, non_neg_integer) :: t
+  def byte_slice(string, start_bytes, size_bytes)
+      when is_binary(string) and is_integer(start_bytes) and is_integer(size_bytes) and
+             size_bytes >= 0 do
+    total = byte_size(string)
+    start_bytes = if start_bytes < 0, do: max(total + start_bytes, 0), else: start_bytes
+
+    if start_bytes < total do
+      :erlang.binary_part(string, start_bytes, total - start_bytes)
+      |> invalid_prefix()
+      |> invalid_suffix(size_bytes)
+    else
+      ""
+    end
   end
 
-  defp do_slice({char, _}, start_pos, last_pos, current_pos, acc) when current_pos >= start_pos and current_pos == last_pos do
-    acc <> char
+  defp invalid_prefix(<<0b10::2, _::6, rest::binary>>), do: invalid_prefix(rest)
+  defp invalid_prefix(rest), do: rest
+
+  defp invalid_suffix(string, size) do
+    last = invalid_suffix(string, min(size, byte_size(string)) - 1, 0)
+    :erlang.binary_part(string, 0, last)
   end
-  
-  defp do_slice(nil, _, _, _, acc) do
-    acc
+
+  defp invalid_suffix(string, last, truncated) when last >= 0 do
+    byte = :binary.at(string, last)
+
+    cond do
+      # ASCII byte, discard all truncated entries
+      byte <= 127 ->
+        last + 1
+
+      # In the middle of a codepoint
+      byte <= 191 ->
+        invalid_suffix(string, last - 1, truncated + 1)
+
+      # 2 bytes codepoint start
+      byte <= 223 ->
+        if truncated == 1, do: last + truncated + 1, else: last
+
+      # 3 bytes codepoint start
+      byte <= 239 ->
+        if truncated == 2, do: last + truncated + 1, else: last
+
+      # 4 bytes codepoint start
+      byte <= 247 ->
+        if truncated == 3, do: last + truncated + 1, else: last
+
+      # Invalid codepoint, discard it, stop checking
+      true ->
+        last + 1
+    end
   end
 
+  defp invalid_suffix(_string, _last, _truncated), do: 0
+
   @doc """
-  Returns `true` if `string` starts with any of the prefixes given, otherwise
-  `false`. `prefixes` can be either a single prefix or a list of prefixes.
+  Returns `true` if `string` starts with any of the prefixes given.
+
+  `prefix` can be either a string, a list of strings, or a compiled
+  pattern.
 
   ## Examples
 
-      iex> String.starts_with? "elixir", "eli"
+      iex> String.starts_with?("elixir", "eli")
       true
+      iex> String.starts_with?("elixir", ["erlang", "elixir"])
+      true
+      iex> String.starts_with?("elixir", ["erlang", "ruby"])
+      false
 
-      iex> String.starts_with? "elixir", ["erlang", "elixir"]
+  An empty string will always match:
+
+      iex> String.starts_with?("elixir", "")
+      true
+      iex> String.starts_with?("elixir", ["", "other"])
       true
 
-      iex> String.starts_with? "elixir", ["erlang", "ruby"]
+  An empty list will never match:
+
+      iex> String.starts_with?("elixir", [])
+      false
+
+      iex> String.starts_with?("", [])
       false
 
   """
   @spec starts_with?(t, t | [t]) :: boolean
-
-  def starts_with?(string, prefixes) when is_list(prefixes) do
-    Enum.any?(prefixes, &do_starts_with(string, &1))
+  def starts_with?(string, prefix) when is_binary(string) and is_binary(prefix) do
+    starts_with_string?(string, byte_size(string), prefix)
   end
 
-  def starts_with?(string, prefix) do
-    do_starts_with(string, prefix)
+  def starts_with?(string, prefix) when is_binary(string) and is_list(prefix) do
+    string_size = byte_size(string)
+    Enum.any?(prefix, &starts_with_string?(string, string_size, &1))
   end
 
-  defp do_starts_with(string, "") when is_binary(string) do
-    true
+  def starts_with?(string, prefix) when is_binary(string) do
+    IO.warn("compiled patterns are deprecated in starts_with?")
+    Kernel.match?({0, _}, :binary.match(string, prefix))
   end
 
-  defp do_starts_with(string, prefix) when is_binary(prefix) do
-    Kernel.match?({0, _}, :binary.match(string, prefix))
+  @compile {:inline, starts_with_string?: 3}
+  defp starts_with_string?(string, string_size, prefix) when is_binary(prefix) do
+    prefix_size = byte_size(prefix)
+
+    if prefix_size <= string_size do
+      prefix == binary_part(string, 0, prefix_size)
+    else
+      false
+    end
   end
 
   @doc """
-  Returns `true` if `string` ends with any of the suffixes given, otherwise
-  `false`. `suffixes` can be either a single suffix or a list of suffixes.
+  Returns `true` if `string` ends with any of the suffixes given.
+
+  `suffixes` can be either a single suffix or a list of suffixes.
 
   ## Examples
 
-      iex> String.ends_with? "language", "age"
+      iex> String.ends_with?("language", "age")
       true
-
-      iex> String.ends_with? "language", ["youth", "age"]
+      iex> String.ends_with?("language", ["youth", "age"])
       true
-
-      iex> String.ends_with? "language", ["youth", "elixir"]
+      iex> String.ends_with?("language", ["youth", "elixir"])
       false
 
-  """
-  @spec ends_with?(t, t | [t]) :: boolean
+  An empty suffix will always match:
 
-  def ends_with?(string, suffixes) when is_list(suffixes) do
-    Enum.any?(suffixes, &do_ends_with(string, &1))
-  end
+      iex> String.ends_with?("language", "")
+      true
+      iex> String.ends_with?("language", ["", "other"])
+      true
 
-  def ends_with?(string, suffix) do
-    do_ends_with(string, suffix)
+  """
+  @spec ends_with?(t, t | [t]) :: boolean
+  def ends_with?(string, suffix) when is_binary(string) and is_binary(suffix) do
+    ends_with_string?(string, byte_size(string), suffix)
   end
 
-  defp do_ends_with(string, "") when is_binary(string) do
-    true
+  def ends_with?(string, suffix) when is_binary(string) and is_list(suffix) do
+    string_size = byte_size(string)
+    Enum.any?(suffix, &ends_with_string?(string, string_size, &1))
   end
 
-  defp do_ends_with(string, suffix) when is_binary(suffix) do
-    string_size = byte_size(string)
+  @compile {:inline, ends_with_string?: 3}
+  defp ends_with_string?(string, string_size, suffix) when is_binary(suffix) do
     suffix_size = byte_size(suffix)
-    scope = {string_size - suffix_size, suffix_size}
-    (suffix_size <= string_size) and (:nomatch != :binary.match(string, suffix, [scope: scope]))
+
+    if suffix_size <= string_size do
+      suffix == binary_part(string, string_size - suffix_size, suffix_size)
+    else
+      false
+    end
   end
 
   @doc """
-  Check if `string` matches the given regular expression.
+  Checks if `string` matches the given regular expression.
 
   ## Examples
 
@@ -1192,61 +2820,113 @@ defmodule String do
       iex> String.match?("bar", ~r/foo/)
       false
 
+  Elixir also provides text-based match operator `=~/2` and function `Regex.match?/2` as
+  alternatives to test strings against regular expressions.
   """
-  @spec match?(t, Regex.t) :: boolean
-  def match?(string, regex) do
+  @spec match?(t, Regex.t()) :: boolean
+  def match?(string, regex) when is_binary(string) do
     Regex.match?(regex, string)
   end
 
   @doc """
-  Check if `string` contains any of the given `contents`.
+  Searches if `string` contains any of the given `contents`.
+
+  `contents` can be either a string, a list of strings,
+  or a compiled pattern. If `contents` is a list, this
+  function will search if any of the strings in `contents`
+  are part of `string`.
 
-  `matches` can be either a single string or a list of strings.
+  > #### Searching for a string in a list {: .tip}
+  >
+  > If you want to check if `string` is listed in `contents`,
+  > where `contents` is a list, use `Enum.member?(contents, string)`
+  > instead.
 
   ## Examples
 
-      iex> String.contains? "elixir of life", "of"
+      iex> String.contains?("elixir of life", "of")
       true
+      iex> String.contains?("elixir of life", ["life", "death"])
+      true
+      iex> String.contains?("elixir of life", ["death", "mercury"])
+      false
+
+  The argument can also be a compiled pattern:
+
+      iex> pattern = :binary.compile_pattern(["life", "death"])
+      iex> String.contains?("elixir of life", pattern)
+      true
+
+  An empty string will always match:
 
-      iex> String.contains? "elixir of life", ["life", "death"]
+      iex> String.contains?("elixir of life", "")
       true
+      iex> String.contains?("elixir of life", ["", "other"])
+      true
+
+  An empty list will never match:
 
-      iex> String.contains? "elixir of life", ["death", "mercury"]
+      iex> String.contains?("elixir of life", [])
       false
 
-  """
-  @spec contains?(t, t | [t]) :: boolean
+      iex> String.contains?("", [])
+      false
 
-  def contains?(string, contents) when is_list(contents) do
-    Enum.any?(contents, &do_contains(string, &1))
-  end
+  Be aware that this function can match within or across grapheme boundaries.
+  For example, take the grapheme "é" which is made of the characters
+  "e" and the acute accent. The following returns `true`:
+
+      iex> String.contains?(String.normalize("é", :nfd), "e")
+      true
+
+  However, if "é" is represented by the single character "e with acute"
+  accent, then it will return `false`:
+
+      iex> String.contains?(String.normalize("é", :nfc), "e")
+      false
 
-  def contains?(string, content) do
-    do_contains(string, content)
+  """
+  @spec contains?(t, [t] | pattern) :: boolean
+  def contains?(string, contents) when is_binary(string) and is_list(contents) do
+    list_contains?(string, byte_size(string), contents, [])
   end
 
-  defp do_contains(string, "") when is_binary(string) do
-    true
+  def contains?(string, contents) when is_binary(string) do
+    "" == contents or :binary.match(string, contents) != :nomatch
   end
 
-  defp do_contains(string, match) when is_binary(match) do
-    :nomatch != :binary.match(string, match)
+  defp list_contains?(string, size, [head | tail], acc) do
+    case byte_size(head) do
+      0 -> true
+      head_size when head_size > size -> list_contains?(string, size, tail, acc)
+      _ -> list_contains?(string, size, tail, [head | acc])
+    end
   end
 
+  defp list_contains?(_string, _size, [], []),
+    do: false
+
+  defp list_contains?(string, _size, [], contents),
+    do: :binary.match(string, contents) != :nomatch
+
   @doc """
-  Converts a string into a char list.
+  Converts a string into a charlist.
+
+  Specifically, this function takes a UTF-8 encoded binary and returns a list of its integer
+  code points. It is similar to `codepoints/1` except that the latter returns a list of code points as
+  strings.
+
+  In case you need to work with bytes, take a look at the
+  [`:binary` module](`:binary`).
 
   ## Examples
 
-      iex> String.to_char_list("æß")
-      'æß'
+      iex> String.to_charlist("foo")
+      ~c"foo"
 
-  Notice that this function expect a list of integer representing
-  UTF-8 codepoints. If you have a raw binary, you must instead use
-  [the `:binary` module](http://erlang.org/doc/man/binary.html).
   """
-  @spec to_char_list(t) :: char_list
-  def to_char_list(string) when is_binary(string) do
+  @spec to_charlist(t) :: charlist
+  def to_charlist(string) when is_binary(string) do
     case :unicode.characters_to_list(string) do
       result when is_list(result) ->
         result
@@ -1260,10 +2940,17 @@ defmodule String do
   end
 
   @doc """
-  Converts a string to an atom.
+  Converts a string to an existing atom or creates a new one.
+
+  Warning: this function creates atoms dynamically and atoms are
+  not garbage-collected. Therefore, `string` should not be an
+  untrusted value, such as input received from a socket or during
+  a web request. Consider using `to_existing_atom/1` instead.
+
+  By default, the maximum number of atoms is `1_048_576`. This limit
+  can be raised or lowered using the VM option `+t`.
 
-  Currently Elixir does not support conversions from strings
-  which contains Unicode codepoints greater than 0xFF.
+  The maximum atom size is of 255 Unicode code points.
 
   Inlined by the compiler.
 
@@ -1273,36 +2960,51 @@ defmodule String do
       :my_atom
 
   """
-  @spec to_atom(String.t) :: atom
-  def to_atom(string) do
+  @spec to_atom(String.t()) :: atom
+  def to_atom(string) when is_binary(string) do
     :erlang.binary_to_atom(string, :utf8)
   end
 
   @doc """
-  Converts a string to an existing atom.
+  Converts a string to an existing atom or raises if
+  the atom does not exist.
 
-  Currently Elixir does not support conversions from strings
-  which contains Unicode codepoints greater than 0xFF.
+  The maximum atom size is of 255 Unicode code points.
+  Raises an `ArgumentError` if the atom does not exist.
 
   Inlined by the compiler.
 
+  > #### Atoms and modules {: .info}
+  >
+  > Since Elixir is a compiled language, the atoms defined in a module
+  > will only exist after said module is loaded, which typically happens
+  > whenever a function in the module is executed. Therefore, it is
+  > generally recommended to call `String.to_existing_atom/1` only to
+  > convert atoms defined within the module making the function call
+  > to `to_existing_atom/1`.
+  >
+  > To create a module name itself from a string safely,
+  > it is recommended to use `Module.safe_concat/1`.
+
   ## Examples
 
-      iex> :my_atom
+      iex> _ = :my_atom
       iex> String.to_existing_atom("my_atom")
       :my_atom
 
-      iex> String.to_existing_atom("this_atom_will_never_exist")
-      ** (ArgumentError) argument error
-
   """
-  @spec to_existing_atom(String.t) :: atom
-  def to_existing_atom(string) do
+  @spec to_existing_atom(String.t()) :: atom
+  def to_existing_atom(string) when is_binary(string) do
     :erlang.binary_to_existing_atom(string, :utf8)
   end
 
   @doc """
-  Returns a integer whose text representation is `string`.
+  Returns an integer whose text representation is `string`.
+
+  `string` must be the string representation of an integer.
+  Otherwise, an `ArgumentError` will be raised. If you want
+  to parse a string that may contain an ill-formatted integer,
+  use `Integer.parse/1`.
 
   Inlined by the compiler.
 
@@ -1311,9 +3013,14 @@ defmodule String do
       iex> String.to_integer("123")
       123
 
+  Passing a string that does not represent an integer leads to an error:
+
+      String.to_integer("invalid data")
+      ** (ArgumentError) argument error
+
   """
-  @spec to_integer(String.t) :: integer
-  def to_integer(string) do
+  @spec to_integer(String.t()) :: integer
+  def to_integer(string) when is_binary(string) do
     :erlang.binary_to_integer(string)
   end
 
@@ -1328,14 +3035,18 @@ defmodule String do
       1023
 
   """
-  @spec to_integer(String.t, pos_integer) :: integer
-  def to_integer(string, base) do
+  @spec to_integer(String.t(), 2..36) :: integer
+  def to_integer(string, base) when is_binary(string) and is_integer(base) do
     :erlang.binary_to_integer(string, base)
   end
 
   @doc """
   Returns a float whose text representation is `string`.
 
+  `string` must be the string representation of a float including leading digits and a decimal
+  point. To parse a string without decimal point as a float, refer to `Float.parse/1`. Otherwise,
+  an `ArgumentError` will be raised.
+
   Inlined by the compiler.
 
   ## Examples
@@ -1343,9 +3054,192 @@ defmodule String do
       iex> String.to_float("2.2017764e+0")
       2.2017764
 
+      iex> String.to_float("3.0")
+      3.0
+
+      String.to_float("3")
+      ** (ArgumentError) argument error
+
+      String.to_float(".3")
+      ** (ArgumentError) argument error
+
   """
-  @spec to_float(String.t) :: float
-  def to_float(string) do
+  @spec to_float(String.t()) :: float
+  def to_float(string) when is_binary(string) do
     :erlang.binary_to_float(string)
   end
+
+  @doc """
+  Computes the bag distance between two strings.
+
+  Returns a float value between 0 and 1 representing the bag
+  distance between `string1` and `string2`.
+
+  The bag distance is meant to be an efficient approximation
+  of the distance between two strings to quickly rule out strings
+  that are largely different.
+
+  The algorithm is outlined in the "String Matching with Metric
+  Trees Using an Approximate Distance" paper by Ilaria Bartolini,
+  Paolo Ciaccia, and Marco Patella.
+
+  ## Examples
+
+      iex> String.bag_distance("abc", "")
+      0.0
+      iex> String.bag_distance("abcd", "a")
+      0.25
+      iex> String.bag_distance("abcd", "ab")
+      0.5
+      iex> String.bag_distance("abcd", "abc")
+      0.75
+      iex> String.bag_distance("abcd", "abcd")
+      1.0
+
+  """
+  @spec bag_distance(t, t) :: float
+  @doc since: "1.8.0"
+  def bag_distance(_string, ""), do: 0.0
+  def bag_distance("", _string), do: 0.0
+
+  def bag_distance(string1, string2) when is_binary(string1) and is_binary(string2) do
+    {bag1, length1} = string_to_bag(string1, %{}, 0)
+    {bag2, length2} = string_to_bag(string2, %{}, 0)
+
+    diff1 = bag_difference(bag1, bag2)
+    diff2 = bag_difference(bag2, bag1)
+
+    1 - max(diff1, diff2) / max(length1, length2)
+  end
+
+  defp string_to_bag(string, bag, length) do
+    case :unicode_util.gc(string) do
+      [gc | rest] -> string_to_bag(rest, bag_store(bag, gc), length + 1)
+      [] -> {bag, length}
+      {:error, <<byte, rest::bits>>} -> string_to_bag(rest, bag_store(bag, <<byte>>), length + 1)
+    end
+  end
+
+  defp bag_store(bag, gc) do
+    case bag do
+      %{^gc => current} -> %{bag | gc => current + 1}
+      %{} -> Map.put(bag, gc, 1)
+    end
+  end
+
+  defp bag_difference(bag1, bag2) do
+    Enum.sum_by(bag1, fn {char, count1} ->
+      case bag2 do
+        %{^char => count2} -> max(count1 - count2, 0)
+        %{} -> count1
+      end
+    end)
+  end
+
+  @doc """
+  Computes the Jaro distance (similarity) between two strings.
+
+  Returns a float value between `0.0` (equates to no similarity) and `1.0`
+  (is an exact match) representing [Jaro](https://en.wikipedia.org/wiki/Jaro-Winkler_distance)
+  distance between `string1` and `string2`.
+
+  The Jaro distance metric is designed and best suited for short
+  strings such as person names. Elixir itself uses this function
+  to provide the "did you mean?" functionality. For instance, when you
+  are calling a function in a module and you have a typo in the
+  function name, we attempt to suggest the most similar function
+  name available, if any, based on the `jaro_distance/2` score.
+
+  ## Examples
+
+      iex> String.jaro_distance("Dwayne", "Duane")
+      0.8222222222222223
+      iex> String.jaro_distance("even", "odd")
+      0.0
+      iex> String.jaro_distance("same", "same")
+      1.0
+
+  """
+  @spec jaro_distance(t, t) :: float
+  def jaro_distance(string1, string2)
+
+  def jaro_distance(string, string) when is_binary(string), do: 1.0
+  def jaro_distance(_string, ""), do: 0.0
+  def jaro_distance("", _string), do: 0.0
+
+  def jaro_distance(string1, string2) when is_binary(string1) and is_binary(string2) do
+    # TODO: Replace by :string.jaro_similarity/2 when we require Erlang/OTP 27+
+    :elixir_utils.jaro_similarity(string1, string2)
+  end
+
+  @doc """
+  Returns a keyword list that represents an edit script.
+
+  Check `List.myers_difference/2` for more information.
+
+  ## Examples
+
+      iex> string1 = "fox hops over the dog"
+      iex> string2 = "fox jumps over the lazy cat"
+      iex> String.myers_difference(string1, string2)
+      [eq: "fox ", del: "ho", ins: "jum", eq: "ps over the ", del: "dog", ins: "lazy cat"]
+
+  """
+  @doc since: "1.3.0"
+  @spec myers_difference(t, t) :: [{:eq | :ins | :del, t}]
+  def myers_difference(string1, string2) when is_binary(string1) and is_binary(string2) do
+    graphemes(string1)
+    |> List.myers_difference(graphemes(string2))
+    |> Enum.map(fn {kind, chars} -> {kind, IO.iodata_to_binary(chars)} end)
+  end
+
+  @doc false
+  @deprecated "Use String.to_charlist/1 instead"
+  @spec to_char_list(t) :: charlist
+  def to_char_list(string), do: String.to_charlist(string)
+
+  ## Helpers
+
+  @compile {:inline,
+            codepoint_byte_size: 1,
+            grapheme_byte_size: 1,
+            grapheme_to_binary: 1,
+            reverse_characters_to_binary: 1}
+
+  defp byte_size_unicode(binary) when is_binary(binary), do: byte_size(binary)
+  defp byte_size_unicode([head]), do: byte_size_unicode(head)
+  defp byte_size_unicode([head | tail]), do: byte_size_unicode(head) + byte_size_unicode(tail)
+
+  defp byte_size_remaining_at(unicode, 0) do
+    byte_size_unicode(unicode)
+  end
+
+  defp byte_size_remaining_at(unicode, n) do
+    case :unicode_util.gc(unicode) do
+      [_] -> 0
+      [_ | rest] -> byte_size_remaining_at(rest, n - 1)
+      [] -> 0
+      {:error, <<_, bin::bits>>} -> byte_size_remaining_at(bin, n - 1)
+    end
+  end
+
+  defp codepoint_byte_size(cp) when cp <= 0x007F, do: 1
+  defp codepoint_byte_size(cp) when cp <= 0x07FF, do: 2
+  defp codepoint_byte_size(cp) when cp <= 0xFFFF, do: 3
+  defp codepoint_byte_size(_), do: 4
+
+  defp grapheme_to_binary(cp) when is_integer(cp), do: <<cp::utf8>>
+  defp grapheme_to_binary(gc) when is_list(gc), do: for(cp <- gc, do: <<cp::utf8>>, into: "")
+
+  defp grapheme_byte_size(cp) when is_integer(cp), do: codepoint_byte_size(cp)
+  defp grapheme_byte_size(cps), do: grapheme_byte_size(cps, 0)
+
+  defp grapheme_byte_size([cp | cps], acc),
+    do: grapheme_byte_size(cps, acc + codepoint_byte_size(cp))
+
+  defp grapheme_byte_size([], acc),
+    do: acc
+
+  defp reverse_characters_to_binary(acc),
+    do: acc |> :lists.reverse() |> :unicode.characters_to_binary()
 end
diff --git a/lib/elixir/lib/string/chars.ex b/lib/elixir/lib/string/chars.ex
index 0d02f457602..9679dded594 100644
--- a/lib/elixir/lib/string/chars.ex
+++ b/lib/elixir/lib/string/chars.ex
@@ -1,20 +1,29 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 import Kernel, except: [to_string: 1]
 
 defprotocol String.Chars do
   @moduledoc ~S"""
-  The String.Chars protocol is responsible for
-  converting a structure to a Binary (only if applicable).
+  The `String.Chars` protocol is responsible for
+  converting a structure to a binary (only if applicable).
+
   The only function required to be implemented is
-  `to_string` which does the conversion.
+  `to_string/1`, which does the conversion.
 
-  The `to_string` function automatically imported
-  by Kernel invokes this protocol. String
-  interpolation also invokes to_string in its
+  The `to_string/1` function automatically imported
+  by `Kernel` invokes this protocol. String
+  interpolation also invokes `to_string/1` in its
   arguments. For example, `"foo#{bar}"` is the same
   as `"foo" <> to_string(bar)`.
   """
 
-  def to_string(thing)
+  @doc """
+  Converts `term` to a string.
+  """
+  @spec to_string(t) :: String.t()
+  def to_string(term)
 end
 
 defimpl String.Chars, for: Atom do
@@ -28,30 +37,30 @@ defimpl String.Chars, for: Atom do
 end
 
 defimpl String.Chars, for: BitString do
-  def to_string(thing) when is_binary(thing) do
-    thing
+  def to_string(term) when is_binary(term) do
+    term
   end
 
-  def to_string(thing) do
+  def to_string(term) do
     raise Protocol.UndefinedError,
-             protocol: @protocol,
-                value: thing,
-          description: "cannot convert a bitstring to a string"
+      protocol: @protocol,
+      value: term,
+      description: "cannot convert a bitstring to a string"
   end
 end
 
 defimpl String.Chars, for: List do
-  def to_string(char_list), do: List.to_string(char_list)
+  def to_string(charlist), do: List.to_string(charlist)
 end
 
 defimpl String.Chars, for: Integer do
-  def to_string(thing) do
-    Integer.to_string(thing)
+  def to_string(term) do
+    Integer.to_string(term)
   end
 end
 
 defimpl String.Chars, for: Float do
-  def to_string(thing) do
-    IO.iodata_to_binary(:io_lib_format.fwrite_g(thing))
+  def to_string(term) do
+    Float.to_string(term)
   end
 end
diff --git a/lib/elixir/lib/string_io.ex b/lib/elixir/lib/string_io.ex
index 8728e75d248..d52ff1c238b 100644
--- a/lib/elixir/lib/string_io.ex
+++ b/lib/elixir/lib/string_io.ex
@@ -1,6 +1,13 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule StringIO do
   @moduledoc """
-  This module provides an IO device that wraps a string.
+  Controls an IO device process that wraps a string.
+
+  A `StringIO` IO device can be passed as a "device" to
+  most of the functions in the `IO` module.
 
   ## Examples
 
@@ -10,14 +17,83 @@ defmodule StringIO do
 
   """
 
-  use GenServer
+  @type open_opts :: [
+          capture_prompt: boolean(),
+          encoding: :unicode | :latin1
+        ]
 
-  @doc """
+  # We're implementing the GenServer behaviour instead of using the
+  # `use GenServer` macro, because we don't want the `child_spec/1`
+  # function as it doesn't make sense to be started under a supervisor.
+  @behaviour GenServer
+
+  @doc ~S"""
+  Creates an IO device.
+
+  `string` will be the initial input of the newly created
+  device.
+
+  The device will be created and sent to the function given.
+  When the function returns, the device will be closed. The final
+  result will be a tuple with `:ok` and the result of the function.
+
+  ## Options
+
+    * `:capture_prompt` - if set to `true`, prompts (specified as
+      arguments to `IO.get*` functions) are captured in the output.
+      Defaults to `false`.
+
+    * `:encoding` (since v1.10.0) - encoding of the IO device. Allowed
+      values are `:unicode` (default) and `:latin1`.
+
+  ## Examples
+
+      iex> StringIO.open("foo", [], fn pid ->
+      ...>   input = IO.gets(pid, ">")
+      ...>   IO.write(pid, "The input was #{input}")
+      ...>   StringIO.contents(pid)
+      ...> end)
+      {:ok, {"", "The input was foo"}}
+
+      iex> StringIO.open("foo", [capture_prompt: true], fn pid ->
+      ...>   input = IO.gets(pid, ">")
+      ...>   IO.write(pid, "The input was #{input}")
+      ...>   StringIO.contents(pid)
+      ...> end)
+      {:ok, {"", ">The input was foo"}}
+
+  """
+  @doc since: "1.7.0"
+  @spec open(binary, open_opts, (pid -> res)) :: {:ok, res} when res: var
+  def open(string, options, function)
+      when is_binary(string) and is_list(options) and is_function(function, 1) do
+    {:ok, pid} = GenServer.start(__MODULE__, {self(), string, options}, [])
+
+    try do
+      {:ok, function.(pid)}
+    after
+      {:ok, {_input, _output}} = close(pid)
+    end
+  end
+
+  @doc ~S"""
   Creates an IO device.
 
-  If the `:capture_prompt` option is set to `true`,
-  prompts (specified as arguments to `IO.get*` functions)
-  are captured.
+  `string` will be the initial input of the newly created
+  device.
+
+  `options_or_function` can be a keyword list of options or
+  a function.
+
+  If options are provided, the result will be `{:ok, pid}`, returning the
+  IO device created. The option `:capture_prompt`, when set to `true`, causes
+  prompts (which are specified as arguments to `IO.get*` functions) to be
+  included in the device's output. See `options/3` for the list of supported
+  options.
+
+  If a function is provided, the device will be created and sent to the
+  function. When the function returns, the device will be closed. The final
+  result will be a tuple with `:ok` and the result of the function.
 
   ## Examples
 
@@ -33,14 +109,30 @@ defmodule StringIO do
       iex> StringIO.contents(pid)
       {"", ">"}
 
+      iex> StringIO.open("foo", fn pid ->
+      ...>   input = IO.gets(pid, ">")
+      ...>   IO.write(pid, "The input was #{input}")
+      ...>   StringIO.contents(pid)
+      ...> end)
+      {:ok, {"", "The input was foo"}}
+
   """
-  @spec open(binary, Keyword.t) :: {:ok, pid}
-  def open(string, options \\ []) when is_binary(string) do
-    :gen_server.start_link(__MODULE__, {string, options}, [])
+  @spec open(binary, open_opts) :: {:ok, pid}
+  @spec open(binary, (pid -> res)) :: {:ok, res} when res: var
+  def open(string, options_or_function \\ [])
+
+  def open(string, options_or_function) when is_binary(string) and is_list(options_or_function) do
+    GenServer.start(__MODULE__, {self(), string, options_or_function}, [])
+  end
+
+  def open(string, options_or_function)
+      when is_binary(string) and is_function(options_or_function, 1) do
+    open(string, [], options_or_function)
   end
 
   @doc """
-  Returns current buffers.
+  Returns the current input/output buffers for the given IO
+  device.
 
   ## Examples
 
@@ -52,11 +144,30 @@ defmodule StringIO do
   """
   @spec contents(pid) :: {binary, binary}
   def contents(pid) when is_pid(pid) do
-    :gen_server.call(pid, :contents)
+    GenServer.call(pid, :contents)
+  end
+
+  @doc """
+  Flushes the output buffer and returns its current contents.
+
+  ## Examples
+
+      iex> {:ok, pid} = StringIO.open("in")
+      iex> IO.write(pid, "out")
+      iex> StringIO.flush(pid)
+      "out"
+      iex> StringIO.contents(pid)
+      {"in", ""}
+
+  """
+  @spec flush(pid) :: binary
+  def flush(pid) when is_pid(pid) do
+    GenServer.call(pid, :flush)
   end
 
   @doc """
-  Stops the IO device and returns remaining buffers.
+  Stops the IO device and returns the remaining input/output
+  buffers.
 
   ## Examples
 
@@ -68,241 +179,275 @@ defmodule StringIO do
   """
   @spec close(pid) :: {:ok, {binary, binary}}
   def close(pid) when is_pid(pid) do
-    :gen_server.call(pid, :close)
+    GenServer.call(pid, :close)
   end
 
   ## callbacks
 
-  def init({string, options}) do
+  @impl true
+  def init({pid, string, options}) do
+    _ = Process.monitor(pid)
     capture_prompt = options[:capture_prompt] || false
-    {:ok, %{input: string, output: "", capture_prompt: capture_prompt}}
+    encoding = options[:encoding] || :unicode
+    {:ok, %{encoding: encoding, input: string, output: "", capture_prompt: capture_prompt}}
+  end
+
+  @impl true
+  def handle_info({:io_request, from, reply_as, req}, state) do
+    state = io_request(from, reply_as, req, state)
+    {:noreply, state}
+  end
+
+  # Fail fast if someone tries to use it with a File API
+  def handle_info({:file_request, from, reply_as, _req}, state) do
+    send(from, {:file_reply, reply_as, {:error, :enotsup}})
+    {:noreply, state}
+  end
+
+  def handle_info({:DOWN, _, _, _, _}, state) do
+    {:stop, :shutdown, state}
   end
 
-  def handle_info({:io_request, from, reply_as, req}, s) do
-    s = io_request(from, reply_as, req, s)
-    {:noreply, s}
+  def handle_info(_message, state) do
+    {:noreply, state}
   end
 
-  def handle_info(msg, s) do
-    super(msg, s)
+  @impl true
+  def handle_call(:contents, _from, %{input: input, output: output} = state) do
+    {:reply, {input, output}, state}
   end
 
-  def handle_call(:contents, _from, %{input: input, output: output} = s) do
-    {:reply, {input, output}, s}
+  def handle_call(:flush, _from, %{output: output} = state) do
+    {:reply, output, %{state | output: ""}}
   end
 
-  def handle_call(:close, _from, %{input: input, output: output} = s) do
-    {:stop, :normal, {:ok, {input, output}}, s}
+  def handle_call(:close, _from, %{input: input, output: output} = state) do
+    {:stop, :normal, {:ok, {input, output}}, state}
   end
 
-  def handle_call(request, from, s) do
-    super(request, from, s)
+  defp io_request(from, reply_as, req, state) do
+    {reply, state} = io_request(req, state)
+    io_reply(from, reply_as, reply)
+    state
   end
 
-  defp io_request(from, reply_as, req, s) do
-    {reply, s} = io_request(req, s)
-    io_reply(from, reply_as, to_reply(reply))
-    s
+  defp io_request({:put_chars, chars} = req, state) do
+    put_chars(:latin1, chars, req, state)
   end
 
-  defp io_request({:put_chars, chars}, %{output: output} = s) do
-    {:ok, %{s | output: << output :: binary, IO.chardata_to_string(chars) :: binary >>}}
+  defp io_request({:put_chars, mod, fun, args} = req, state) do
+    put_chars(:latin1, apply(mod, fun, args), req, state)
   end
 
-  defp io_request({:put_chars, m, f, as}, %{output: output} = s) do
-    chars = apply(m, f, as)
-    {:ok, %{s | output: << output :: binary, IO.chardata_to_string(chars) :: binary >>}}
+  defp io_request({:put_chars, encoding, chars} = req, state) do
+    put_chars(encoding, chars, req, state)
   end
 
-  defp io_request({:put_chars, _encoding, chars}, s) do
-    io_request({:put_chars, chars}, s)
+  defp io_request({:put_chars, encoding, mod, fun, args} = req, state) do
+    put_chars(encoding, apply(mod, fun, args), req, state)
   end
 
-  defp io_request({:put_chars, _encoding, mod, func, args}, s) do
-    io_request({:put_chars, mod, func, args}, s)
+  defp io_request({:get_chars, prompt, count}, state) when count >= 0 do
+    io_request({:get_chars, :latin1, prompt, count}, state)
   end
 
-  defp io_request({:get_chars, prompt, n}, s) when n >= 0 do
-    io_request({:get_chars, :latin1, prompt, n}, s)
+  defp io_request({:get_chars, encoding, prompt, count}, state) when count >= 0 do
+    get_chars(encoding, prompt, count, state)
   end
 
-  defp io_request({:get_chars, encoding, prompt, n}, s) when n >= 0 do
-    get_chars(encoding, prompt, n, s)
+  defp io_request({:get_line, prompt}, state) do
+    io_request({:get_line, :latin1, prompt}, state)
   end
 
-  defp io_request({:get_line, prompt}, s) do
-    io_request({:get_line, :latin1, prompt}, s)
+  defp io_request({:get_line, encoding, prompt}, state) do
+    get_line(encoding, prompt, state)
   end
 
-  defp io_request({:get_line, encoding, prompt}, s) do
-    get_line(encoding, prompt, s)
+  defp io_request({:get_until, prompt, mod, fun, args}, state) do
+    io_request({:get_until, :latin1, prompt, mod, fun, args}, state)
   end
 
-  defp io_request({:get_until, prompt, mod, fun, args}, s) do
-    io_request({:get_until, :latin1, prompt, mod, fun, args}, s)
+  defp io_request({:get_until, encoding, prompt, mod, fun, args}, state) do
+    get_until(encoding, prompt, mod, fun, args, state)
   end
 
-  defp io_request({:get_until, encoding, prompt, mod, fun, args}, s) do
-    get_until(encoding, prompt, mod, fun, args, s)
+  defp io_request({:get_password, encoding}, state) do
+    get_line(encoding, "", state)
   end
 
-  defp io_request({:get_password, encoding}, s) do
-    get_line(encoding, "", s)
+  defp io_request({:setopts, [encoding: encoding]}, state) when encoding in [:latin1, :unicode] do
+    {:ok, %{state | encoding: encoding}}
   end
 
-  defp io_request({:setopts, _opts}, s) do
-    {{:error, :enotsup}, s}
+  defp io_request({:setopts, _opts}, state) do
+    {{:error, :enotsup}, state}
   end
 
-  defp io_request(:getopts, s) do
-    {{:ok, [binary: true, encoding: :unicode]}, s}
+  defp io_request(:getopts, state) do
+    {[binary: true, encoding: state.encoding], state}
   end
 
-  defp io_request({:get_geometry, :columns}, s) do
-    {{:error, :enotsup}, s}
+  defp io_request({:get_geometry, :columns}, state) do
+    {{:error, :enotsup}, state}
   end
 
-  defp io_request({:get_geometry, :rows}, s) do
-    {{:error, :enotsup}, s}
+  defp io_request({:get_geometry, :rows}, state) do
+    {{:error, :enotsup}, state}
   end
 
-  defp io_request({:requests, reqs}, s) do
-    io_requests(reqs, {:ok, s})
+  defp io_request({:requests, reqs}, state) do
+    io_requests(reqs, {:ok, state})
   end
 
-  defp io_request(_, s) do
-    {{:error, :request}, s}
+  defp io_request(_, state) do
+    {{:error, :request}, state}
+  end
+
+  ## put_chars
+
+  defp put_chars(encoding, chars, req, state) do
+    case :unicode.characters_to_binary(chars, encoding, state.encoding) do
+      string when is_binary(string) ->
+        {:ok, %{state | output: state.output <> string}}
+
+      {_, _, _} ->
+        {{:error, {:no_translation, encoding, state.encoding}}, state}
+    end
+  rescue
+    ArgumentError -> {{:error, req}, state}
   end
 
   ## get_chars
 
-  defp get_chars(encoding, prompt, n,
-                 %{input: input, output: output, capture_prompt: capture_prompt} = s) do
-    case do_get_chars(input, encoding, n) do
+  defp get_chars(encoding, prompt, count, %{input: input} = state) do
+    case get_chars(input, encoding, count) do
       {:error, _} = error ->
-        {error, s}
-      {result, input} ->
-        if capture_prompt do
-          output = << output :: binary, IO.chardata_to_string(prompt) :: binary >>
-        end
+        {error, state}
 
-        {result, %{s | input: input, output: output}}
+      {result, input} ->
+        {result, state_after_read(state, input, prompt, 1)}
     end
   end
 
-  defp do_get_chars("", _encoding, _n) do
+  defp get_chars("", _encoding, _count) do
     {:eof, ""}
   end
 
-  defp do_get_chars(input, :latin1, n) when byte_size(input) < n do
+  defp get_chars(input, :latin1, count) when byte_size(input) < count do
     {input, ""}
   end
 
-  defp do_get_chars(input, :latin1, n) do
-    <<chars :: [binary, size(n)], rest :: binary>> = input
+  defp get_chars(input, :latin1, count) do
+    <<chars::binary-size(^count), rest::binary>> = input
     {chars, rest}
   end
 
-  defp do_get_chars(input, encoding, n) do
-    try do
-      case :file_io_server.count_and_find(input, n, encoding) do
-        {buf_count, split_pos} when buf_count < n or split_pos == :none ->
-          {input, ""}
-        {_buf_count, split_pos} ->
-          <<chars :: [binary, size(split_pos)], rest :: binary>> = input
-          {chars, rest}
-      end
-    catch
-      :exit, :invalid_unicode ->
-        {:error, :invalid_unicode}
+  defp get_chars(input, :unicode, count) do
+    with {:ok, count} <- split_at(input, count, 0) do
+      <<chars::binary-size(^count), rest::binary>> = input
+      {chars, rest}
     end
   end
 
+  defp split_at(_, 0, acc),
+    do: {:ok, acc}
+
+  defp split_at(<<h::utf8, t::binary>>, count, acc),
+    do: split_at(t, count - 1, acc + byte_size(<<h::utf8>>))
+
+  defp split_at(<<_, _::binary>>, _count, _acc),
+    do: {:error, :invalid_unicode}
+
+  defp split_at(<<>>, _count, acc),
+    do: {:ok, acc}
+
   ## get_line
 
-  defp get_line(encoding, prompt,
-                %{input: input, output: output, capture_prompt: capture_prompt} = s) do
-    case :unicode.characters_to_list(input, encoding) do
-      {:error, _, _} ->
-        {{:error, :collect_line}, s}
-      {:incomplete, _, _} ->
-        {{:error, :collect_line}, s}
-      chars ->
-        {result, input} = do_get_line(chars, encoding)
-
-        if capture_prompt do
-          output = << output :: binary, IO.chardata_to_string(prompt) :: binary >>
-        end
+  defp get_line(encoding, prompt, %{input: input} = state) do
+    case bytes_until_eol(input, encoding, 0) do
+      {:split, 0} ->
+        {:eof, state_after_read(state, "", prompt, 1)}
 
-        {result, %{s | input: input, output: output}}
-    end
-  end
+      {:split, count} ->
+        {result, remainder} = :erlang.split_binary(input, count)
+        {result, state_after_read(state, remainder, prompt, 1)}
 
-  defp do_get_line('', _encoding) do
-    {:eof, ""}
-  end
+      {:replace_split, count} ->
+        {result, remainder} = :erlang.split_binary(input, count)
+        result = binary_part(result, 0, byte_size(result) - 2) <> "\n"
+        {result, state_after_read(state, remainder, prompt, 1)}
 
-  defp do_get_line(chars, encoding) do
-    {line, rest} = collect_line(chars)
-    {:unicode.characters_to_binary(line, encoding),
-      :unicode.characters_to_binary(rest, encoding)}
+      :error ->
+        {{:error, :collect_line}, state}
+    end
   end
 
   ## get_until
 
-  defp get_until(encoding, prompt, mod, fun, args,
-                 %{input: input, output: output, capture_prompt: capture_prompt} = s) do
-    case :unicode.characters_to_list(input, encoding) do
-      {:error, _, _} ->
-        {:error, s}
-      {:incomplete, _, _} ->
-        {:error, s}
-      chars ->
-        {result, input, count} = do_get_until(chars, encoding, mod, fun, args)
-
-        if capture_prompt do
-          output = << output :: binary, :binary.copy(IO.chardata_to_string(prompt), count) :: binary >>
-        end
-
+  defp get_until(encoding, prompt, mod, fun, args, %{input: input} = state) do
+    case get_until(input, encoding, mod, fun, args, [], 0) do
+      {result, input, count} ->
+        # Convert :eof to "" as they are both treated the same
         input =
           case input do
             :eof -> ""
-            _ -> :unicode.characters_to_binary(input, encoding)
+            _ -> list_to_binary(input, encoding)
           end
 
-        {result, %{s | input: input, output: output}}
+        {get_until_result(result, encoding), state_after_read(state, input, prompt, count)}
+
+      :error ->
+        {:error, state}
     end
   end
 
-  defp do_get_until(chars, encoding, mod, fun, args, continuation \\ [], count \\ 0)
-
-  defp do_get_until('', encoding, mod, fun, args, continuation, count) do
+  defp get_until("", encoding, mod, fun, args, continuation, count) do
     case apply(mod, fun, [continuation, :eof | args]) do
       {:done, result, rest} ->
         {result, rest, count + 1}
+
       {:more, next_continuation} ->
-        do_get_until('', encoding, mod, fun, args, next_continuation, count + 1)
+        get_until("", encoding, mod, fun, args, next_continuation, count + 1)
     end
   end
 
-  defp do_get_until(chars, encoding, mod, fun, args, continuation, count) do
-    {line, rest} = collect_line(chars)
+  defp get_until(chars, encoding, mod, fun, args, continuation, count) do
+    case bytes_until_eol(chars, encoding, 0) do
+      {kind, size} when kind in [:split, :replace_split] ->
+        <<line::binary-size(^size), rest::binary>> = chars
+
+        case apply(mod, fun, [continuation, binary_to_list(line, encoding) | args]) do
+          {:done, result, :eof} ->
+            {result, rest, count + 1}
 
-    case apply(mod, fun, [continuation, line | args]) do
-      {:done, result, rest1} ->
-        unless rest1 == :eof do
-          rest = rest1 ++ rest
+          {:done, result, extra} ->
+            {result, extra ++ binary_to_list(rest, encoding), count + 1}
+
+          {:more, next_continuation} ->
+            get_until(rest, encoding, mod, fun, args, next_continuation, count + 1)
         end
-        {result, rest, count + 1}
-      {:more, next_continuation} ->
-        do_get_until(rest, encoding, mod, fun, args, next_continuation, count + 1)
+
+      :error ->
+        :error
     end
   end
 
+  defp binary_to_list(data, :unicode) when is_binary(data), do: String.to_charlist(data)
+  defp binary_to_list(data, :latin1) when is_binary(data), do: :erlang.binary_to_list(data)
+
+  defp list_to_binary(data, _) when is_binary(data), do: data
+  defp list_to_binary(data, :unicode) when is_list(data), do: List.to_string(data)
+  defp list_to_binary(data, :latin1) when is_list(data), do: :erlang.list_to_binary(data)
+
+  # From https://www.erlang.org/doc/apps/stdlib/io_protocol.html: result can be any
+  # Erlang term, but if it is a list(), the I/O server can convert it to a binary().
+  defp get_until_result(data, encoding) when is_list(data), do: list_to_binary(data, encoding)
+  defp get_until_result(data, _), do: data
+
   ## io_requests
 
-  defp io_requests([r|rs], {:ok, s}) do
-    io_requests(rs, io_request(r, s))
+  defp io_requests([req | rest], {:ok, state}) do
+    io_requests(rest, io_request(req, state))
   end
 
   defp io_requests(_, result) do
@@ -311,30 +456,30 @@ defmodule StringIO do
 
   ## helpers
 
-  defp collect_line(chars) do
-    collect_line(chars, [])
+  defp state_after_read(%{capture_prompt: false} = state, remainder, _prompt, _count) do
+    %{state | input: remainder}
   end
 
-  defp collect_line([], stack) do
-    {:lists.reverse(stack), []}
+  defp state_after_read(%{capture_prompt: true, output: output} = state, remainder, prompt, count) do
+    output = <<output::binary, :binary.copy(IO.chardata_to_string(prompt), count)::binary>>
+    %{state | input: remainder, output: output}
   end
 
-  defp collect_line([?\r, ?\n | rest], stack) do
-    {:lists.reverse([?\n|stack]), rest}
-  end
+  defp bytes_until_eol("", _, count), do: {:split, count}
+  defp bytes_until_eol(<<"\r\n"::binary, _::binary>>, _, count), do: {:replace_split, count + 2}
+  defp bytes_until_eol(<<"\n"::binary, _::binary>>, _, count), do: {:split, count + 1}
 
-  defp collect_line([?\n | rest], stack) do
-    {:lists.reverse([?\n|stack]), rest}
+  defp bytes_until_eol(<<head::utf8, tail::binary>>, :unicode, count) do
+    bytes_until_eol(tail, :unicode, count + byte_size(<<head::utf8>>))
   end
 
-  defp collect_line([h|t], stack) do
-    collect_line(t, [h|stack])
+  defp bytes_until_eol(<<_, tail::binary>>, :latin1, count) do
+    bytes_until_eol(tail, :latin1, count + 1)
   end
 
+  defp bytes_until_eol(<<_::binary>>, _, _), do: :error
+
   defp io_reply(from, reply_as, reply) do
-    send from, {:io_reply, reply_as, reply}
+    send(from, {:io_reply, reply_as, reply})
   end
-
-  defp to_reply(list) when is_list(list), do: IO.chardata_to_string(list)
-  defp to_reply(other), do: other
 end
diff --git a/lib/elixir/lib/supervisor.ex b/lib/elixir/lib/supervisor.ex
index 9945e2ce5c9..3c75ff4b87a 100644
--- a/lib/elixir/lib/supervisor.ex
+++ b/lib/elixir/lib/supervisor.ex
@@ -1,122 +1,352 @@
-defmodule Supervisor do
-  @moduledoc """
-  A behaviour module for implementing supervision functionality.
-
-  A supervisor is a process which supervises other processes called
-  child processes. Supervisors are used to build an hierarchical process
-  structure called a supervision tree, a nice way to structure fault-tolerant
-  applications.
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-  A supervisor implemented using this module will have a standard set
-  of interface functions and include functionality for tracing and error
-  reporting. It will also fit into an supervision tree.
-
-  ## Example
+defmodule Supervisor do
+  @moduledoc ~S"""
+  A behaviour module for implementing supervisors.
+
+  A supervisor is a process which supervises other processes, which we
+  refer to as *child processes*. Supervisors are used to build a hierarchical
+  process structure called a *supervision tree*. Supervision trees provide
+  fault-tolerance and encapsulate how our applications start and shutdown.
+
+  A supervisor may be started directly with a list of child specifications via
+  `start_link/2` or you may define a module-based supervisor that implements
+  the required callbacks. The sections below use `start_link/2` to start
+  supervisors in most examples, but it also includes a specific section
+  on module-based ones.
+
+  ## Examples
+
+  In order to start a supervisor, we need to first define a child process
+  that will be supervised. As an example, we will define a `GenServer`,
+  a generic server, that keeps a counter. Other processes can then send
+  messages to this process to read the counter and bump its value.
+
+  > #### Disclaimer {: .neutral}
+  >
+  > In practice you would not define a counter as a GenServer. Instead,
+  > if you need a counter, you would pass it around as inputs and outputs to
+  > the functions that need it. The reason we picked a counter in this example
+  > is due to its simplicity, as it allows us to focus on how supervisors work.
+
+      defmodule Counter do
+        use GenServer
 
-  In order to define a supervisor, we need to first define a child process
-  that is going to be supervised. In order to do so, we will define a GenServer
-  that represents a stack:
+        def start_link(arg) when is_integer(arg) do
+          GenServer.start_link(__MODULE__, arg, name: __MODULE__)
+        end
 
-      defmodule Stack do
-        use GenServer
+        ## Callbacks
 
-        def start_link(state) do
-          GenServer.start_link(__MODULE__, state, [name: :sup_stack])
+        @impl true
+        def init(counter) do
+          {:ok, counter}
         end
 
-        def handle_call(:pop, _from, [h|t]) do
-          {:reply, h, t}
+        @impl true
+        def handle_call(:get, _from, counter) do
+          {:reply, counter, counter}
         end
 
-        def handle_cast({:push, h}, _from, t) do
-          {:noreply, [h|t]}
+        def handle_call({:bump, value}, _from, counter) do
+          {:reply, counter, counter + value}
         end
       end
 
-  We can now define our supervisor and start it as follows:
+  The `Counter` receives an argument on `start_link`. This argument
+  is passed to the `init/1` callback which becomes the initial value
+  of the counter. Our counter handles two operations (known as calls):
+  `:get`, to get the current counter value, and `:bump`, that bumps
+  the counter by the given `value` and returns the old counter.
 
-      # Import helpers for defining supervisors
-      import Supervisor.Spec
+  We can now start a supervisor that will start and supervise our
+  counter process. The first step is to define a list of **child
+  specifications** that control how each child behaves. Each child
+  specification is a map, as shown below:
 
-      # We are going to supervise the Stack server which will
-      # be started with a single argument [:hello]
       children = [
-        worker(Stack, [[:hello]])
+        # The Counter is a child started via Counter.start_link(0)
+        %{
+          id: Counter,
+          start: {Counter, :start_link, [0]}
+        }
       ]
 
-      # Start the supervisor with our one child
+      # Now we start the supervisor with the children and a strategy
       {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one)
 
-  Notice that when starting the GenServer, we have registered it
-  with name `:sup_stack`, which allows us to call it directly and
-  get what is on the stack:
+      # After started, we can query the supervisor for information
+      Supervisor.count_children(pid)
+      #=> %{active: 1, specs: 1, supervisors: 0, workers: 1}
 
-      GenServer.call(:sup_stack, :pop)
-      #=> :hello
+  Note that when starting the GenServer, we are registering it
+  with name `Counter` via the `name: __MODULE__` option. This allows
+  us to call it directly and get its value:
 
-      GenServer.cast(:sup_stack, {:push, :world})
-      #=> :ok
+      GenServer.call(Counter, :get)
+      #=> 0
 
-      GenServer.call(:sup_stack, :pop)
-      #=> :world
+      GenServer.call(Counter, {:bump, 3})
+      #=> 0
 
-  However, there is a bug in our stack server. If we call `:pop` and
-  the stack is empty, it is going to crash because no clause matches.
-  Let's try it:
+      GenServer.call(Counter, :get)
+      #=> 3
 
-      GenServer.call(:sup_stack, :pop)
-      =ERROR REPORT====
+  However, there is a bug in our counter server. If we call `:bump` with
+  a non-numeric value, it is going to crash:
+
+      GenServer.call(Counter, {:bump, "oops"})
+      ** (exit) exited in: GenServer.call(Counter, {:bump, "oops"}, 5000)
 
   Luckily, since the server is being supervised by a supervisor, the
-  supervisor will automatically start a new one, with the default stack
-  of `[:hello]` like before:
+  supervisor will automatically start a new one, reset back to its initial
+  value of `0`:
 
-      GenServer.call(:sup_stack, :pop) == :hello
+      GenServer.call(Counter, :get)
+      #=> 0
 
   Supervisors support different strategies; in the example above, we
   have chosen `:one_for_one`. Furthermore, each supervisor can have many
-  workers and supervisors as children, each of them with their specific
-  configuration, shutdown values, and restart strategies.
+  workers and/or supervisors as children, with each one having its own
+  configuration (as outlined in the "Child specification" section).
 
-  Continue reading this moduledoc to learn more about supervision strategies
-  and then follow to the `Supervisor.Spec` module documentation to learn
-  about the specification for workers and supervisors.
+  The rest of this document will cover how child processes are specified,
+  how they can be started and stopped, different supervision strategies
+  and more.
 
-  ## Module-based supervisors
+  ## Child specification
 
-  In the example above, a supervisor was dynamically created by passing
-  the supervision structure to `start_link/2`. However, supervisors
-  can also be created by explicitly defining a supervision module:
+  The child specification describes how the supervisor starts, shuts down,
+  and restarts child processes.
 
-      defmodule MyApp.Supervisor do
-        use Supervisor
+  The child specification is a map containing up to 6 elements. The first two keys
+  in the following list are required, and the remaining ones are optional:
 
-        def start_link do
-          Supervisor.start_link(__MODULE__, [])
-        end
+    * `:id` - any term used to identify the child specification internally by
+      the supervisor; defaults to the given module. This key is required.
+      For supervisors, in the case of conflicting `:id` values, the supervisor
+      will refuse to initialize and require explicit IDs. This is not the case
+      for [dynamic supervisors](`DynamicSupervisor`) though.
 
-        def init([]) do
-          children = [
-            worker(Stack, [[:hello]])
-          ]
+    * `:start` - a tuple with the module-function-args to be invoked
+      to start the child process. This key is required.
 
-          supervise(children, strategy: :one_for_one)
-        end
+    * `:restart` - an atom that defines when a terminated child process
+       should be restarted (see the ["Restart values"](#module-restart-values-restart) section below).
+       This key is optional and defaults to `:permanent`.
+
+    * `:shutdown` - an integer or atom that defines how a child process should
+      be terminated (see the ["Shutdown values"](#module-shutdown-values-shutdown) section below). This key
+      is optional and defaults to `5_000` if the type is `:worker` or
+      `:infinity` if the type is `:supervisor`.
+
+    * `:type` - specifies that the child process is a `:worker` or a
+      `:supervisor`. This key is optional and defaults to `:worker`.
+
+    * `:modules` - a list of modules used by hot code upgrade mechanisms
+      to determine which processes are using certain modules. It is typically
+      set to the callback module of behaviours like `GenServer`, `Supervisor`,
+      and such. It is set automatically based on the `:start` value and it is rarely
+      changed in practice.
+
+    * `:significant` - a boolean indicating if the child process should be
+      considered significant with regard to automatic shutdown.  Only `:transient`
+      and `:temporary` child processes can be marked as significant. This key is
+      optional and defaults to `false`. See section "Automatic shutdown" below
+      for more details.
+
+  Let's understand what the `:shutdown` and `:restart` options control.
+
+  ### Shutdown values (:shutdown)
+
+  The following shutdown values are supported in the `:shutdown` option:
+
+    * `:brutal_kill` - the child process is unconditionally and immediately
+      terminated using `Process.exit(child, :kill)`.
+
+    * any integer >= 0 - the amount of time in milliseconds that the
+      supervisor will wait for its children to terminate after emitting a
+      `Process.exit(child, :shutdown)` signal. If the child process is
+      not trapping exits, the initial `:shutdown` signal will terminate
+      the child process immediately. If the child process is trapping
+      exits, it has the given amount of time to terminate.
+      If it doesn't terminate within the specified time, the child process
+      is unconditionally terminated by the supervisor via
+      `Process.exit(child, :kill)`.
+
+    * `:infinity` - works as an integer except the supervisor will wait
+      indefinitely for the child to terminate. If the child process is a
+      supervisor, the recommended value is `:infinity` to give the supervisor
+      and its children enough time to shut down. This option can be used with
+      regular workers but doing so is discouraged and requires extreme care.
+      If not used carefully, the child process will never terminate,
+      preventing your application from terminating as well.
+
+  ### Restart values (:restart)
+
+  The `:restart` option controls what the supervisor should consider to
+  be a successful termination or not. If the termination is successful,
+  the supervisor won't restart the child. If the child process crashed,
+  the supervisor will start a new one.
+
+  The following restart values are supported in the `:restart` option:
+
+    * `:permanent` - the child process is always restarted.
+
+    * `:temporary` - the child process is never restarted, regardless
+      of the supervision strategy: any termination (even abnormal) is
+      considered successful.
+
+    * `:transient` - the child process is restarted only if it
+      terminates abnormally, i.e., with an exit reason other than
+      `:normal`, `:shutdown`, or `{:shutdown, term}`.
+
+  For a more complete understanding of the exit reasons and their
+  impact, see the "Exit reasons and restarts" section.
+
+  ## `child_spec/1` function
+
+  When starting a supervisor, we may pass a list of child specifications. Those
+  specifications are maps that tell how the supervisor should start, stop and
+  restart each of its children:
+
+      %{
+        id: Counter,
+        start: {Counter, :start_link, [0]}
+      }
+
+  The map above defines a child with `:id` of `Counter` that is started
+  by calling `Counter.start_link(0)`.
+
+  However, defining the child specification for each child as a map can be
+  quite error prone, as we may change the `Counter` implementation and forget
+  to update its specification. That's why Elixir allows you to pass a tuple with
+  the module name and the `start_link` argument instead of the specification:
+
+      children = [
+        {Counter, 0}
+      ]
+
+  The supervisor will then invoke `Counter.child_spec(0)` to retrieve a child
+  specification. Now the `Counter` module is responsible for building its own
+  specification, for example, we could write:
+
+      def child_spec(arg) do
+        %{
+          id: Counter,
+          start: {Counter, :start_link, [arg]}
+        }
       end
 
-  You may want to use a module-based supervisor if:
+  Then the supervisor will call `Counter.start_link(arg)` to start the child
+  process. This flow is summarized in the diagram below. Caller is a process
+  which spawns the Supervisor process. The Supervisor then proceeds to call
+  your code (Module) to spawn its child process:
+
+  ```mermaid
+  sequenceDiagram
+      participant C as Caller (Process)
+      participant S as Supervisor (Process)
+      participant M as Module (Code)
+
+      note right of C: child is a {module, arg} specification
+      C->>+S: Supervisor.start_link([child])
+      S-->>+M: module.child_spec(arg)
+      M-->>-S: %{id: term, start: {module, :start_link, [arg]}}
+      S-->>+M: module.start_link(arg)
+      M->>M: Spawns child process (child_pid)
+      M-->>-S: {:ok, child_pid} | :ignore | {:error, reason}
+      S->>-C: {:ok, supervisor_pid} | {:error, reason}
+  ```
+
+  Luckily for us, `use GenServer` already defines a `Counter.child_spec/1`
+  exactly like above, so you don't need to write the definition above yourself.
+  If you want to customize the automatically generated `child_spec/1` function,
+  you can pass the options directly to `use GenServer`:
+
+      use GenServer, restart: :transient
+
+  Finally, note it is also possible to simply pass the `Counter` module as
+  a child:
 
-    * You need to do some particular action on supervisor
-      initialization, like setting up a ETS table.
+      children = [
+        Counter
+      ]
+
+  When only the module name is given, it is equivalent to `{Counter, []}`,
+  which in our case would be invalid, which is why we always pass the initial
+  counter explicitly.
+
+  By replacing the child specification with `{Counter, 0}`, we keep it
+  encapsulated in the `Counter` module. We could now share our
+  `Counter` implementation with other developers and they can add it directly
+  to their supervision tree without worrying about the low-level details of
+  the counter.
+
+  Overall, a child specification can be one of the following:
+
+    * a map representing the child specification itself - as outlined in the
+      "Child specification" section
+
+    * a tuple with a module as first element and the start argument as second -
+      such as `{Counter, 0}`. In this case, `Counter.child_spec(0)` is called
+      to retrieve the child specification
 
-    * You want to perform partial hot-code swapping of the
-      tree. For example, if you add or remove a children,
-      the module-based supervision will add and remove the
-      new children directly, while the dynamic supervision
-      requires the whole tree to be restarted in order to
-      perform such swaps.
+    * a module - such as `Counter`. In this case, `Counter.child_spec([])`
+      would be called, which is invalid for the counter, but it is useful in
+      many other cases, especially when you want to pass a list of options
+      to the child process
 
-  ## Strategies
+  If you need to convert a `{module, arg}` tuple or a module child specification to a
+  [child specification](`t:child_spec/0`) or modify a child specification itself,
+  you can use the `Supervisor.child_spec/2` function.
+  For example, to run the counter with a different `:id` and a `:shutdown` value of
+  10 seconds (10_000 milliseconds):
+
+      children = [
+        Supervisor.child_spec({Counter, 0}, id: MyCounter, shutdown: 10_000)
+      ]
+
+  ## Supervisor strategies and options
+
+  So far we have started the supervisor passing a single child as a tuple
+  as well as a strategy called `:one_for_one`:
+
+      children = [
+        {Counter, 0}
+      ]
+
+      Supervisor.start_link(children, strategy: :one_for_one)
+
+  The first argument given to `start_link/2` is a list of child
+  specifications as defined in the "child_spec/1" section above.
+
+  The second argument is a keyword list of options:
+
+    * `:strategy` - the supervision strategy option. It can be either
+      `:one_for_one`, `:rest_for_one` or `:one_for_all`. Required.
+      See the "Strategies" section.
+
+    * `:max_restarts` - the maximum number of restarts allowed in
+      a time frame. Defaults to `3`.
+
+    * `:max_seconds` - the time frame in which `:max_restarts` applies.
+      Defaults to `5`.
+
+    * `:auto_shutdown` - the automatic shutdown option. It can be
+      `:never`, `:any_significant`, or `:all_significant`. Optional.
+      See the "Automatic shutdown" section.
+
+    * `:name` - a name to register the supervisor process. Supported values are
+      explained in the "Name registration" section in the documentation for
+      `GenServer`. Optional.
+
+  ### Strategies
+
+  Supervisors support different supervision strategies (through the
+  `:strategy` option, as seen above):
 
     * `:one_for_one` - if a child process terminates, only that
       process is restarted.
@@ -125,188 +355,729 @@ defmodule Supervisor do
       processes are terminated and then all child processes (including
       the terminated one) are restarted.
 
-    * `:rest_for_one` - if a child process terminates, the "rest" of
-      the child processes, i.e. the child processes after the terminated
-      one in start order, are terminated. Then the terminated child
-      process and the rest of the child processes are restarted.
+    * `:rest_for_one` - if a child process terminates, the terminated child
+      process and the rest of the children started after it, are terminated and
+      restarted.
+
+  In the above, process termination refers to unsuccessful termination, which
+  is determined by the `:restart` option.
+
+  To efficiently supervise children started dynamically, see `DynamicSupervisor`.
+
+  ### Automatic shutdown
 
-    * `:simple_one_for_one` - similar to `:one_for_one` but suits better
-      when dynamically attaching children. This strategy requires the
-      supervisor specification to contain only one children. Many functions
-      in this module behave slightly differently when this strategy is
-      used.
+  Supervisors have the ability to automatically shut themselves down when child
+  processes marked as `:significant` exit.
 
-  ## Name Registration
+  Supervisors support different automatic shutdown options (through
+  the `:auto_shutdown` option, as seen above):
+
+    * `:never` - this is the default, automatic shutdown is disabled.
+
+    * `:any_significant` - if any significant child process exits, the supervisor
+    will automatically shut down its children, then itself.
+
+    * `:all_significant` - when all significant child processes have exited,
+    the supervisor will automatically shut down its children, then itself.
+
+  Only `:transient` and `:temporary` child processes can be marked as significant,
+  and this configuration affects the behavior. Significant `:transient` child
+  processes must exit normally for automatic shutdown to be considered, where
+  `:temporary` child processes may exit for any reason.
+
+  ### Name registration
 
   A supervisor is bound to the same name registration rules as a `GenServer`.
-  Read more about it in the `GenServer` docs.
+  Read more about these rules in the documentation for `GenServer`.
+
+  ## Module-based supervisors
+
+  In the example so far, the supervisor was started by passing the supervision
+  structure to `start_link/2`. However, supervisors can also be created by
+  explicitly defining a supervision module:
+
+      defmodule MyApp.Supervisor do
+        # Automatically defines child_spec/1
+        use Supervisor
+
+        def start_link(init_arg) do
+          Supervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
+        end
+
+        @impl true
+        def init(_init_arg) do
+          children = [
+            {Counter, 0}
+          ]
+
+          Supervisor.init(children, strategy: :one_for_one)
+        end
+      end
+
+  The difference between the two approaches is that a module-based
+  supervisor gives you more direct control over how the supervisor
+  is initialized. Instead of calling `Supervisor.start_link/2` with
+  a list of child specifications that are implicitly initialized for us,
+  we must explicitly initialize the children by calling `Supervisor.init/2`
+  inside its `c:init/1` callback. `Supervisor.init/2` accepts the same
+  `:strategy`, `:max_restarts`, and `:max_seconds` options as `start_link/2`.
+
+  > #### `use Supervisor` {: .info}
+  >
+  > When you `use Supervisor`, the `Supervisor` module will
+  > set `@behaviour Supervisor` and define a `child_spec/1`
+  > function, so your module can be used as a child
+  > in a supervision tree.
+
+  `use Supervisor` also defines a `child_spec/1` function which allows
+  us to run `MyApp.Supervisor` as a child of another supervisor or
+  at the top of your supervision tree as:
+
+      children = [
+        MyApp.Supervisor
+      ]
+
+      Supervisor.start_link(children, strategy: :one_for_one)
+
+  A general guideline is to use the supervisor without a callback
+  module only at the top of your supervision tree, generally in the
+  `c:Application.start/2` callback. We recommend using module-based
+  supervisors for any other supervisor in your application, so they
+  can run as a child of another supervisor in the tree. The `child_spec/1`
+  generated automatically by `Supervisor` can be customized with the
+  following options:
+
+    * `:id` - the child specification identifier, defaults to the current module
+    * `:restart` - when the supervisor should be restarted, defaults to `:permanent`
+
+  The `@doc` annotation immediately preceding `use Supervisor` will be
+  attached to the generated `child_spec/1` function.
+
+  ## Start and shutdown
+
+  When the supervisor starts, it traverses all child specifications and
+  then starts each child in the order they are defined. This is done by
+  calling the function defined under the `:start` key in the child
+  specification and typically defaults to `start_link/1`.
+
+  The `start_link/1` (or a custom) is then called for each child process.
+  The `start_link/1` function must return `{:ok, pid}` where `pid` is the
+  process identifier of a new process that is linked to the supervisor.
+  The child process usually starts its work by executing the `c:init/1`
+  callback. Generally speaking, the `init` callback is where we initialize
+  and configure the child process.
+
+  The shutdown process happens in reverse order.
+
+  When a supervisor shuts down, it terminates all children in the opposite
+  order they are listed. The termination happens by sending a shutdown exit
+  signal, via `Process.exit(child_pid, :shutdown)`, to the child process and
+  then awaiting for a time interval for the child process to terminate. This
+  interval defaults to 5000 milliseconds. If the child process does not
+  terminate in this interval, the supervisor abruptly terminates the child
+  with reason `:kill`. The shutdown time can be configured in the child
+  specification which is fully detailed in the next section.
+
+  If the child process is not trapping exits, it will shutdown immediately
+  when it receives the first exit signal. If the child process is trapping
+  exits, then the `terminate` callback is invoked, and the child process
+  must terminate in a reasonable time interval before being abruptly
+  terminated by the supervisor.
+
+  In other words, if it is important that a process cleans after itself
+  when your application or the supervision tree is shutting down, then
+  this process must trap exits and its child specification should specify
+  the proper `:shutdown` value, ensuring it terminates within a reasonable
+  interval.
+
+  ## Exit reasons and restarts
+
+  A supervisor restarts a child process depending on its `:restart` configuration.
+  For example, when `:restart` is set to `:transient`, the supervisor does not
+  restart the child in case it exits with reason `:normal`, `:shutdown` or
+  `{:shutdown, term}`.
+
+  Those exits also impact logging. By default, behaviours such as GenServers
+  do not emit error logs when the exit reason is `:normal`, `:shutdown` or
+  `{:shutdown, term}`.
+
+  So one may ask: which exit reason should I choose? There are three options:
+
+    * `:normal` - in such cases, the exit won't be logged, there is no restart
+      in transient mode, and linked processes do not exit
+
+    * `:shutdown` or `{:shutdown, term}` - in such cases, the exit won't be
+      logged, there is no restart in transient mode, and linked processes exit
+      with the same reason unless they're trapping exits
+
+    * any other term - in such cases, the exit will be logged, there are
+      restarts in transient mode, and linked processes exit with the same
+      reason unless they're trapping exits
+
+  Generally speaking, if you are exiting for expected reasons, you want to use
+  `:shutdown` or `{:shutdown, term}`.
+
+  Note that the supervisor that reaches maximum restart intensity will exit with
+  `:shutdown` reason. In this case the supervisor will only be restarted if its
+  child specification was defined with the `:restart` option set to `:permanent`
+  (the default).
   """
 
   @doc false
-  defmacro __using__(_) do
-    quote location: :keep do
-      @behaviour :supervisor
+  defmacro __using__(opts) do
+    quote location: :keep, bind_quoted: [opts: opts] do
       import Supervisor.Spec
+      @behaviour Supervisor
+
+      if not Module.has_attribute?(__MODULE__, :doc) do
+        @doc """
+        Returns a specification to start this module under a supervisor.
+
+        See `Supervisor`.
+        """
+      end
+
+      def child_spec(init_arg) do
+        default = %{
+          id: __MODULE__,
+          start: {__MODULE__, :start_link, [init_arg]},
+          type: :supervisor
+        }
+
+        Supervisor.child_spec(default, unquote(Macro.escape(opts)))
+      end
+
+      defoverridable child_spec: 1
     end
   end
 
-  @typedoc "Return values of `start_link` functions"
-  @type on_start :: {:ok, pid} | :ignore |
-                    {:error, {:already_started, pid} | {:shutdown, term} | term}
-
-  @typedoc "Return values of `start_child` functions"
-  @type on_start_child :: {:ok, child} | {:ok, child, info :: term} |
-                          {:error, {:already_started, child} | :already_present | term}
+  @doc """
+  Callback invoked to start the supervisor and during hot code upgrades.
 
+  Developers typically invoke `Supervisor.init/2` at the end of their
+  init callback to return the proper supervision flags.
+  """
+  @callback init(init_arg :: term) ::
+              {:ok,
+               {sup_flags(), [child_spec() | (old_erlang_child_spec :: :supervisor.child_spec())]}}
+              | :ignore
+
+  @typedoc "Return values of `start_link/2` and `start_link/3`."
+  @type on_start ::
+          {:ok, pid}
+          | :ignore
+          | {:error, {:already_started, pid} | {:shutdown, term} | term}
+
+  @typedoc "Return values of `start_child/2`."
+  @type on_start_child ::
+          {:ok, child}
+          | {:ok, child, info :: term}
+          | {:error, {:already_started, child} | :already_present | term}
+
+  @typedoc """
+  A child process.
+
+  It can be a PID when the child process was started, or `:undefined` when
+  the child was created by a [dynamic supervisor](`DynamicSupervisor`).
+  """
   @type child :: pid | :undefined
 
-  @typedoc "The Supervisor name"
+  @typedoc "The supervisor name."
   @type name :: atom | {:global, term} | {:via, module, term}
 
-  @typedoc "Options used by the `start*` functions"
-  @type options :: [name: name,
-                    strategy: Supervisor.Spec.strategy,
-                    max_restarts: non_neg_integer,
-                    max_seconds: non_neg_integer]
+  @typedoc "Option values used by the `start_link/2` and `start_link/3` functions."
+  @type option :: {:name, name}
 
-  @typedoc "The supervisor reference"
+  @typedoc "The supervisor flags returned on init."
+  @type sup_flags() :: %{
+          strategy: strategy(),
+          intensity: non_neg_integer(),
+          period: pos_integer(),
+          auto_shutdown: auto_shutdown()
+        }
+
+  @typedoc "The supervisor reference."
   @type supervisor :: pid | name | {atom, node}
 
+  @typedoc "Options given to `start_link/2` and `init/2`."
+  @type init_option ::
+          {:strategy, strategy}
+          | {:max_restarts, non_neg_integer}
+          | {:max_seconds, pos_integer}
+          | {:auto_shutdown, auto_shutdown}
+
+  @typedoc "Supported restart options."
+  @type restart :: :permanent | :transient | :temporary
+
+  @typedoc "Supported shutdown options."
+  @type shutdown :: timeout() | :brutal_kill
+
+  @typedoc "Supported strategies."
+  @type strategy :: :one_for_one | :one_for_all | :rest_for_one
+
+  @typedoc "Supported automatic shutdown options."
+  @type auto_shutdown :: :never | :any_significant | :all_significant
+
+  @typedoc """
+  Type of a supervised child.
+
+  Whether the supervised child is a worker or a supervisor.
+  """
+  @type type :: :worker | :supervisor
+
+  # Note we have inlined all types for readability
+  @typedoc """
+  The supervisor child specification.
+
+  It defines how the supervisor should start, stop and restart each of its children.
+  """
+  @type child_spec :: %{
+          required(:id) => atom() | term(),
+          required(:start) => {module(), function_name :: atom(), args :: [term()]},
+          optional(:restart) => restart(),
+          optional(:shutdown) => shutdown(),
+          optional(:type) => type(),
+          optional(:modules) => [module()] | :dynamic,
+          optional(:significant) => boolean()
+        }
+
+  @typedoc """
+  A module-based child spec.
+
+  This is a form of child spec that you can pass to functions such as `child_spec/2`,
+  `start_child/2`, and `start_link/2`, in addition to the normalized `t:child_spec/0`.
+
+  A module-based child spec can be:
+
+    * a **module** — the supervisor calls `module.child_spec([])` to retrieve the
+      child specification
+
+    * a **two-element tuple** in the shape of `{module, arg}` — the supervisor
+      calls `module.child_spec(arg)` to retrieve the child specification
+
+  """
+  @typedoc since: "1.16.0"
+  @type module_spec :: {module(), args :: term()} | module()
+
+  @typedoc """
+  Options for overriding child specification fields.
+  """
+  @type child_spec_overrides :: [
+          id: atom() | term(),
+          start: {module(), atom(), [term()]},
+          restart: restart(),
+          shutdown: shutdown(),
+          type: type(),
+          modules: [module()] | :dynamic,
+          significant: boolean()
+        ]
+
   @doc """
   Starts a supervisor with the given children.
 
-  A strategy is required to be given as an option. Furthermore,
-  the `:max_restarts` and `:max_seconds` value can be configured
-  as described in `Supervisor.Spec.supervise/2` docs.
+  `children` is a list of the following forms:
+
+    * a child specification (see `t:child_spec/0`)
+
+    * a module, where the supervisor calls `module.child_spec([])`
+      to retrieve the child specification (see `t:module_spec/0`)
+
+    * a `{module, arg}` tuple, where the supervisor calls `module.child_spec(arg)`
+      to retrieve the child specification (see `t:module_spec/0`)
+
+    * a (old) Erlang-style child specification (see
+      [`:supervisor.child_spec()`](`t::supervisor.child_spec/0`))
+
+  A strategy is required to be provided through the `:strategy` option. See
+  "Supervisor strategies and options" for examples and other options.
 
   The options can also be used to register a supervisor name.
-  the supported values are described under the `Name Registration`
+  The supported values are described under the "Name registration"
   section in the `GenServer` module docs.
 
-  If the supervisor and its child processes are successfully created
-  (i.e. if the start function of all child processes returns `{:ok, child}`,
-  `{:ok, child, info}`, or `:ignore`) the function returns
-  `{:ok, pid}`, where `pid` is the pid of the supervisor. If there
-  already exists a process with the specified name, the function returns
-  `{:error, {:already_started, pid}}`, where pid is the pid of that
-  process.
-
-  If any of the child process start functions fail or return an error tuple or
-  an erroneous value, the supervisor will first terminate all already
-  started child processes with reason `:shutdown` and then terminate
-  itself and return `{:error, {:shutdown, reason}}`.
-
-  Note that the `Supervisor` is linked to the parent process
-  and will exit not only on crashes but also if the parent process
-  exits with `:normal` reason.
+  If the supervisor and all child processes are successfully spawned
+  (if the start function of each child process returns `{:ok, child}`,
+  `{:ok, child, info}`, or `:ignore`), this function returns
+  `{:ok, pid}`, where `pid` is the PID of the supervisor. If the supervisor
+  is given a name and a process with the specified name already exists,
+  the function returns `{:error, {:already_started, pid}}`, where `pid`
+  is the PID of that process.
+
+  If the start function of any of the child processes fails or returns an error
+  tuple or an erroneous value, the supervisor first terminates with reason
+  `:shutdown` all the child processes that have already been started, and then
+  terminates itself and returns `{:error, {:shutdown, reason}}`.
+
+  Note that a supervisor started with this function is linked to the parent
+  process and exits not only on crashes but also if the parent process exits
+  with `:normal` reason.
   """
-  @spec start_link([tuple], options) :: on_start
+  @spec start_link(
+          [child_spec | module_spec | (old_erlang_child_spec :: :supervisor.child_spec())],
+          [option | init_option]
+        ) ::
+          {:ok, pid} | {:error, {:already_started, pid} | {:shutdown, term} | term}
   def start_link(children, options) when is_list(children) do
-    spec = Supervisor.Spec.supervise(children, options)
-    start_link(Supervisor.Default, spec, options)
+    {sup_opts, start_opts} =
+      Keyword.split(options, [:strategy, :max_seconds, :max_restarts, :auto_shutdown])
+
+    start_link(Supervisor.Default, init(children, sup_opts), start_opts)
+  end
+
+  @doc """
+  Receives a list of child specifications to initialize and a set of `options`.
+
+  This is typically invoked at the end of the `c:init/1` callback of
+  module-based supervisors. See the sections "Supervisor strategies and options" and
+  "Module-based supervisors" in the module documentation for more information.
+
+  This function returns a tuple containing the supervisor
+  flags and child specifications.
+
+  ## Examples
+
+      def init(_init_arg) do
+        children = [
+          {Counter, 0}
+        ]
+
+        Supervisor.init(children, strategy: :one_for_one)
+      end
+
+  ## Options
+
+    * `:strategy` - the supervision strategy option. It can be either
+      `:one_for_one`, `:rest_for_one`, or `:one_for_all`
+
+    * `:max_restarts` - the maximum number of restarts allowed in
+      a time frame. Defaults to `3`.
+
+    * `:max_seconds` - the time frame in seconds in which `:max_restarts`
+      applies. Defaults to `5`.
+
+    * `:auto_shutdown` - the automatic shutdown option. It can be either
+      `:never`, `:any_significant`, or `:all_significant`
+
+  The `:strategy` option is required and by default a maximum of 3 restarts
+  is allowed within 5 seconds. Check the `Supervisor` module for a detailed
+  description of the available strategies.
+  """
+  @doc since: "1.5.0"
+  @spec init(
+          [child_spec | module_spec | (old_erlang_child_spec :: :supervisor.child_spec())],
+          [init_option]
+        ) ::
+          {:ok,
+           {sup_flags(), [child_spec() | (old_erlang_child_spec :: :supervisor.child_spec())]}}
+  def init(children, options) when is_list(children) and is_list(options) do
+    strategy =
+      case options[:strategy] do
+        nil ->
+          raise ArgumentError, "expected :strategy option to be given"
+
+        :simple_one_for_one ->
+          IO.warn(
+            ":simple_one_for_one strategy is deprecated, please use DynamicSupervisor instead"
+          )
+
+          :simple_one_for_one
+
+        other ->
+          other
+      end
+
+    intensity = Keyword.get(options, :max_restarts, 3)
+    period = Keyword.get(options, :max_seconds, 5)
+    auto_shutdown = Keyword.get(options, :auto_shutdown, :never)
+
+    flags = %{
+      strategy: strategy,
+      intensity: intensity,
+      period: period,
+      auto_shutdown: auto_shutdown
+    }
+
+    {:ok, {flags, Enum.map(children, &init_child/1)}}
+  end
+
+  defp init_child(module) when is_atom(module) do
+    init_child({module, []})
+  end
+
+  defp init_child({module, arg}) when is_atom(module) do
+    try do
+      module.child_spec(arg)
+    rescue
+      e in UndefinedFunctionError ->
+        case __STACKTRACE__ do
+          [{^module, :child_spec, [^arg], _} | _] ->
+            raise ArgumentError, child_spec_error(module)
+
+          stack ->
+            reraise e, stack
+        end
+    end
+  end
+
+  defp init_child(map) when is_map(map) do
+    map
+  end
+
+  defp init_child({_, _, _, _, _, _} = tuple) do
+    tuple
+  end
+
+  defp init_child(other) do
+    raise ArgumentError, """
+    supervisors expect each child to be one of the following:
+
+      * a module
+      * a {module, arg} tuple
+      * a child specification as a map with at least the :id and :start fields
+      * or a tuple with 6 elements generated by Supervisor.Spec (deprecated)
+
+    Got: #{inspect(other)}
+    """
+  end
+
+  defp child_spec_error(module) do
+    if Code.ensure_loaded?(module) do
+      """
+      The module #{inspect(module)} was given as a child to a supervisor
+      but it does not implement child_spec/1.
+
+      If you own the given module, please define a child_spec/1 function
+      that receives an argument and returns a child specification as a map.
+      For example:
+
+          def child_spec(opts) do
+            %{
+              id: __MODULE__,
+              start: {__MODULE__, :start_link, [opts]},
+              type: :worker,
+              restart: :permanent,
+              shutdown: 500
+            }
+          end
+
+      Note that "use Agent", "use GenServer" and so on automatically define
+      this function for you.
+
+      However, if you don't own the given module and it doesn't implement
+      child_spec/1, instead of passing the module name directly as a supervisor
+      child, you will have to pass a child specification as a map:
+
+          %{
+            id: #{inspect(module)},
+            start: {#{inspect(module)}, :start_link, [arg1, arg2]}
+          }
+
+      See the Supervisor documentation for more information
+      """
+    else
+      "The module #{inspect(module)} was given as a child to a supervisor but it does not exist"
+    end
+  end
+
+  @doc """
+  Builds and overrides a child specification.
+
+  Similar to `start_link/2` and `init/2`, it expects a module, `{module, arg}`,
+  or a [child specification](`t:child_spec/0`).
+
+  If a two-element tuple in the shape of `{module, arg}` is given,
+  the child specification is retrieved by calling `module.child_spec(arg)`.
+
+  If a module is given, the child specification is retrieved by calling
+  `module.child_spec([])`.
+
+  After the child specification is retrieved, the fields on `overrides`
+  are directly applied to the child spec. If `overrides` has keys that
+  do not map to any child specification field, an error is raised.
+
+  See the "Child specification" section in the module documentation
+  for all of the available keys for overriding.
+
+  ## Examples
+
+  This function is often used to set an `:id` option when
+  the same module needs to be started multiple times in the
+  supervision tree:
+
+      Supervisor.child_spec({Agent, fn -> :ok end}, id: {Agent, 1})
+      #=> %{id: {Agent, 1},
+      #=>   start: {Agent, :start_link, [fn -> :ok end]}}
+
+  """
+  @spec child_spec(child_spec() | module_spec(), child_spec_overrides()) :: child_spec()
+  def child_spec(module_or_map, overrides)
+
+  def child_spec({_, _, _, _, _, _} = tuple, _overrides) do
+    raise ArgumentError,
+          "old tuple-based child specification #{inspect(tuple)} " <>
+            "is not supported in Supervisor.child_spec/2"
+  end
+
+  def child_spec(module_or_map, overrides) do
+    Enum.reduce(overrides, init_child(module_or_map), fn
+      {key, value}, acc
+      when key in [:id, :start, :restart, :shutdown, :type, :modules, :significant] ->
+        Map.put(acc, key, value)
+
+      {key, _value}, _acc ->
+        raise ArgumentError, "unknown key #{inspect(key)} in child specification override"
+    end)
   end
 
   @doc """
-  Starts a supervisor module with the given `arg`.
+  Starts a module-based supervisor process with the given `module` and `init_arg`.
 
-  To start the supervisor, the `init/1` callback will be invoked
-  in the given module. The `init/1` callback must return a
-  supervision specification which can be created with the help
-  of `Supervisor.Spec` module.
+  To start the supervisor, the `c:init/1` callback will be invoked in the given
+  `module`, with `init_arg` as its argument. The `c:init/1` callback must return a
+  supervisor specification which can be created with the help of the `init/2`
+  function.
 
-  If the `init/1` callback returns `:ignore`, this function returns
+  If the `c:init/1` callback returns `:ignore`, this function returns
   `:ignore` as well and the supervisor terminates with reason `:normal`.
   If it fails or returns an incorrect value, this function returns
   `{:error, term}` where `term` is a term with information about the
   error, and the supervisor terminates with reason `term`.
 
   The `:name` option can also be given in order to register a supervisor
-  name, the supported values are described under the `Name Registration`
+  name, the supported values are described in the "Name registration"
   section in the `GenServer` module docs.
-
-  Other failure conditions are specified in `start_link/2` docs.
   """
-  @spec start_link(module, term, options) :: on_start
-  def start_link(module, arg, options \\ []) when is_list(options) do
+
+  # It is important to keep the two-arity spec because it is a catch-all
+  # to start_link(children, options).
+  @spec start_link(module, term) :: on_start
+  @spec start_link(module, term, [option]) :: on_start
+  def start_link(module, init_arg, options \\ []) when is_list(options) do
     case Keyword.get(options, :name) do
       nil ->
-        :supervisor.start_link(module, arg)
+        :supervisor.start_link(module, init_arg)
+
       atom when is_atom(atom) ->
-        :supervisor.start_link({:local, atom}, module, arg)
-      other when is_tuple(other) ->
-        :supervisor.start_link(other, module, arg)
+        :supervisor.start_link({:local, atom}, module, init_arg)
+
+      {:global, _term} = tuple ->
+        :supervisor.start_link(tuple, module, init_arg)
+
+      {:via, via_module, _term} = tuple when is_atom(via_module) ->
+        :supervisor.start_link(tuple, module, init_arg)
+
+      other ->
+        raise ArgumentError, """
+        expected :name option to be one of the following:
+
+          * nil
+          * atom
+          * {:global, term}
+          * {:via, module, term}
+
+        Got: #{inspect(other)}
+        """
     end
   end
 
   @doc """
-  Dynamically adds and starts a child specification to the supervisor.
+  Adds a child specification to `supervisor` and starts that child.
 
-  `child_spec` should be a valid child specification (unless the supervisor
-  is a `:simple_one_for_one` supervisor, see below). The child process will
+  `child_spec` should be a valid child specification. The child process will
   be started as defined in the child specification.
 
-  In the case of `:simple_one_for_one`, the child specification defined in
-  the supervisor will be used and instead of a `child_spec`, an arbitrary list
-  of terms is expected. The child process will then be started by appending
-  the given list to the existing function arguments in the child specification.
-
-  If there already exists a child specification with the specified id,
-  `child_spec` is discarded and the function returns an error with `:already_started`
-  or `:already_present` if the corresponding child process is running or not.
+  If a child specification with the specified ID already exists, `child_spec` is
+  discarded and this function returns an error with `:already_started` or
+  `:already_present` if the corresponding child process is running or not,
+  respectively.
+
+  If the child process start function returns `{:ok, child}` or `{:ok, child,
+  info}`, then child specification and PID are added to the supervisor and
+  this function returns the same value.
+
+  If the child process start function returns `:ignore`, the child specification
+  is added to the supervisor, the PID is set to `:undefined` and this function
+  returns `{:ok, :undefined}`.
+
+  If the child process start function returns an error tuple or an erroneous
+  value, or if it fails, the child specification is discarded and this function
+  returns `{:error, error}` where `error` is a term containing information about
+  the error and child specification.
+
+  > #### Order Among Children {: .tip}
+  >
+  > The child specification is **appended** to the children of `supervisor`.
+  > This guarantees that semantics of things such as the `:rest_for_one` strategy
+  > are preserved correctly.
+  """
+  @spec start_child(
+          supervisor,
+          child_spec | module_spec | (old_erlang_child_spec :: :supervisor.child_spec())
+        ) :: on_start_child
+  def start_child(supervisor, {_, _, _, _, _, _} = child_spec) do
+    call(supervisor, {:start_child, child_spec})
+  end
 
-  If the child process start function returns `{:ok, child}` or `{:ok, child, info}`,
-  the child specification and pid is added to the supervisor and the function returns
-  the same value.
+  def start_child(supervisor, args) when is_list(args) do
+    IO.warn_once(
+      {__MODULE__, :start_child},
+      fn ->
+        "Supervisor.start_child/2 with a list of args is deprecated, please use DynamicSupervisor instead"
+      end,
+      _stacktrace_drop_levels = 2
+    )
 
-  If the child process start function returns `:ignore, the child specification is
-  added to the supervisor, the pid is set to undefined and the function returns
-  `{:ok, :undefined}`.
+    call(supervisor, {:start_child, args})
+  end
 
-  If the child process start function returns an error tuple or an erroneous value,
-  or if it fails, the child specification is discarded and the function returns
-  `{:error, error}` where `error` is a term containing information about the error
-  and child specification.
-  """
-  @spec start_child(supervisor, Supervisor.Spec.spec | [term]) :: on_start_child
-  defdelegate start_child(supervisor, child_spec_or_args), to: :supervisor
+  def start_child(supervisor, child_spec) do
+    call(supervisor, {:start_child, Supervisor.child_spec(child_spec, [])})
+  end
 
   @doc """
-  Terminates the given pid or child id.
+  Terminates the given child identified by `child_id`.
 
-  If the supervisor is not a `simple_one_for_one`, the child id is expected
-  and the process, if there is one, is terminated; the child specification is
+  The process is terminated, if there's one. The child specification is
   kept unless the child is temporary.
 
-  In case of a `simple_one_for_one` supervisor, a pid is expected. If the child
-  specification identifier is given instead of a `pid`, the function will
-  return `{:error, :simple_one_for_one}`.
-
-  A non-temporary child process may later be restarted by the supervisor. The child
-  process can also be restarted explicitly by calling `restart_child/2`. Use
-  `delete_child/2` to remove the child specification.
+  A non-temporary child process may later be restarted by the supervisor.
+  The child process can also be restarted explicitly by calling `restart_child/2`.
+  Use `delete_child/2` to remove the child specification.
 
-  If successful, the function returns `:ok`. If there is no child specification or
-  pid, the function returns `{:error, :not_found}`.
+  If successful, this function returns `:ok`. If there is no child
+  specification for the given child ID, this function returns
+  `{:error, :not_found}`.
   """
-  @spec terminate_child(supervisor, pid | Supervisor.Spec.child_id) :: :ok | {:error, error}
-        when error: :not_found | :simple_one_for_one
-  defdelegate terminate_child(supervisor, pid_or_child_id), to: :supervisor
+  @spec terminate_child(supervisor, term()) :: :ok | {:error, :not_found}
+  def terminate_child(supervisor, child_id)
+
+  def terminate_child(supervisor, pid) when is_pid(pid) do
+    IO.warn(
+      "Supervisor.terminate_child/2 with a PID is deprecated, please use DynamicSupervisor instead"
+    )
+
+    call(supervisor, {:terminate_child, pid})
+  end
+
+  def terminate_child(supervisor, child_id) do
+    call(supervisor, {:terminate_child, child_id})
+  end
 
   @doc """
   Deletes the child specification identified by `child_id`.
 
-  The corresponding child process must not be running, use `terminate_child/2`
-  to terminate it.
-
-  If successful, the function returns `:ok`. This function may error with an
-  appropriate error tuple if the `child_id` is not found, or if the current
-  process is running or being restarted.
+  The corresponding child process must not be running; use `terminate_child/2`
+  to terminate it if it's running.
 
-  This operation is not supported by `simple_one_for_one` supervisors.
+  If successful, this function returns `:ok`. This function may return an error
+  with an appropriate error tuple if the `child_id` is not found, or if the
+  current process is running or being restarted.
   """
-  @spec delete_child(supervisor, Supervisor.Spec.child_id) :: :ok | {:error, error}
-        when error: :not_found | :simple_one_for_one | :running | :restarting
-  defdelegate delete_child(supervisor, child_id), to: :supervisor
+  @spec delete_child(supervisor, term()) :: :ok | {:error, error}
+        when error: :not_found | :running | :restarting
+  def delete_child(supervisor, child_id) do
+    call(supervisor, {:delete_child, child_id})
+  end
 
   @doc """
   Restarts a child process identified by `child_id`.
@@ -317,54 +1088,55 @@ defmodule Supervisor do
   Note that for temporary children, the child specification is automatically deleted
   when the child terminates, and thus it is not possible to restart such children.
 
-  If the child process start function returns `{:ok, child}` or
-  `{:ok, child, info}`, the pid is added to the supervisor and the function returns
-  the same value.
+  If the child process start function returns `{:ok, child}` or `{:ok, child, info}`,
+  the PID is added to the supervisor and this function returns the same value.
 
-  If the child process start function returns `:ignore`, the pid remains set to
-  `:undefined` and the function returns `{:ok, :undefined}`.
+  If the child process start function returns `:ignore`, the PID remains set to
+  `:undefined` and this function returns `{:ok, :undefined}`.
 
-  This function may error with an appropriate error tuple if the `child_id` is not
-  found, or if the current process is running or being restarted.
+  This function may return an error with an appropriate error tuple if the
+  `child_id` is not found, or if the current process is running or being
+  restarted.
 
   If the child process start function returns an error tuple or an erroneous value,
-  or if it fails, the function returns `{:error, error}`.
-
-  This operation is not supported by `simple_one_for_one` supervisors.
+  or if it fails, this function returns `{:error, error}`.
   """
-  @spec restart_child(supervisor, Supervisor.Spec.child_id) ::
-        {:ok, child} | {:ok, child, term} | {:error, error}
-        when error: :not_found | :simple_one_for_one | :running | :restarting | term
-  defdelegate restart_child(supervisor, child_id), to: :supervisor
+  @spec restart_child(supervisor, term()) :: {:ok, child} | {:ok, child, term} | {:error, error}
+        when error: :not_found | :running | :restarting | term
+  def restart_child(supervisor, child_id) do
+    call(supervisor, {:restart_child, child_id})
+  end
 
   @doc """
-  Returns a list with information about all children.
+  Returns a list with information about all children of the given supervisor.
 
   Note that calling this function when supervising a large number of children
-  under low memory conditions can cause an out of memory exception.
+  under low memory conditions can bring the system down due to an out of memory
+  error.
+
+  This function returns a list of `{id, child, type, modules}` tuples, where:
 
-  This function returns a list of tuples containing:
+    * `id` - as defined in the child specification
 
-    * `id` - as defined in the child specification or `:undefined` in the case
-      of a `simple_one_for_one` supervisor
+    * `child` - the PID of the corresponding child process, `:restarting` if the
+      process is about to be restarted, or `:undefined` if there is no such
+      process
 
-    * `child` - the pid of the corresponding child process, the atom
-      `:restarting` if the process is about to be restarted, or `:undefined` if
-      there is no such process
+    * `type` - `:worker` or `:supervisor`, as specified by the child specification
 
-    * `type` - `:worker` or `:supervisor` as defined in the child specification
+    * `modules` - as specified by the child specification
 
-    * `modules` – as defined in the child specification
   """
-  @spec which_children(supervisor) ::
-        [{Supervisor.Spec.child_id | :undefined,
-           child | :restarting,
-           Supervisor.Spec.worker,
-           Supervisor.Spec.modules}]
-  defdelegate which_children(supervisor), to: :supervisor
+  @spec which_children(supervisor) :: [
+          # inlining module() | :dynamic here because :supervisor.modules() is not exported
+          {term() | :undefined, child | :restarting, :worker | :supervisor, [module()] | :dynamic}
+        ]
+  def which_children(supervisor) do
+    call(supervisor, :which_children)
+  end
 
   @doc """
-  Returns a map containing count values for the supervisor.
+  Returns a map containing count values for the given supervisor.
 
   The map contains the following keys:
 
@@ -373,17 +1145,41 @@ defmodule Supervisor do
     * `:active` - the count of all actively running child processes managed by
       this supervisor
 
-    * `:supervisors` - the count of all supervisors whether or not the child
-      process is still alive
+    * `:supervisors` - the count of all supervisors whether or not these
+      child supervisors are still alive
 
-    * `:workers` - the count of all workers, whether or not the child process
-      is still alive
+    * `:workers` - the count of all workers, whether or not these child workers
+      are still alive
 
   """
-  @spec count_children(supervisor) ::
-        [specs: non_neg_integer, active: non_neg_integer,
-         supervisors: non_neg_integer, workers: non_neg_integer]
+  @spec count_children(supervisor) :: %{
+          specs: non_neg_integer,
+          active: non_neg_integer,
+          supervisors: non_neg_integer,
+          workers: non_neg_integer
+        }
   def count_children(supervisor) do
-    :supervisor.count_children(supervisor) |> :maps.from_list
+    call(supervisor, :count_children) |> :maps.from_list()
+  end
+
+  @doc """
+  Synchronously stops the given supervisor with the given `reason`.
+
+  It returns `:ok` if the supervisor terminates with the given
+  reason. If it terminates with another reason, the call exits.
+
+  This function keeps OTP semantics regarding error reporting.
+  If the reason is any other than `:normal`, `:shutdown` or
+  `{:shutdown, _}`, an error report is logged.
+  """
+  @spec stop(supervisor, reason :: term, timeout) :: :ok
+  def stop(supervisor, reason \\ :normal, timeout \\ :infinity) do
+    GenServer.stop(supervisor, reason, timeout)
+  end
+
+  @compile {:inline, call: 2}
+
+  defp call(supervisor, req) do
+    GenServer.call(supervisor, req, :infinity)
   end
 end
diff --git a/lib/elixir/lib/supervisor/default.ex b/lib/elixir/lib/supervisor/default.ex
index 863bce65907..10bac507a7a 100644
--- a/lib/elixir/lib/supervisor/default.ex
+++ b/lib/elixir/lib/supervisor/default.ex
@@ -1,13 +1,11 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Supervisor.Default do
   @moduledoc false
-  @behaviour :supervisor
-
-  @doc """
-  Supevisor callback that simply returns the given args.
 
-  This is the supervisor used by `Supervisor.start_link/2`.
-  """
   def init(args) do
     args
   end
-end
\ No newline at end of file
+end
diff --git a/lib/elixir/lib/supervisor/spec.ex b/lib/elixir/lib/supervisor/spec.ex
index df9f2625b22..454d01877ab 100644
--- a/lib/elixir/lib/supervisor/spec.ex
+++ b/lib/elixir/lib/supervisor/spec.ex
@@ -1,11 +1,21 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Supervisor.Spec do
   @moduledoc """
-  Convenience functions for defining a supervision specification.
+  Outdated functions for building child specifications.
+
+  The functions in this module are deprecated and they do not work
+  with the module-based child specs introduced in Elixir v1.5.
+  Please see the `Supervisor` documentation instead.
+
+  Convenience functions for defining supervisor specifications.
 
   ## Example
 
-  By using the functions in this module one can define a supervisor
-  and start it with `Supervisor.start_link/2`:
+  By using the functions in this module one can specify the children
+  to be used under a supervisor, started with `Supervisor.start_link/2`:
 
       import Supervisor.Spec
 
@@ -16,7 +26,7 @@ defmodule Supervisor.Spec do
 
       Supervisor.start_link(children, strategy: :one_for_one)
 
-  In many situations, it may be handy to define supervisors backed
+  Sometimes, it may be handy to define supervisors backed
   by a module:
 
       defmodule MySupervisor do
@@ -35,44 +45,37 @@ defmodule Supervisor.Spec do
         end
       end
 
-  Notice in this case we don't have to explicitly import
-  `Supervisor.Spec` as `use Supervisor` automatically does so.
-
-  Explicit supervisors as above are required when there is a need to:
-
-    1. Partialy change the supervision tree during hot-code swaps.
-
-    2. Define supervisors inside other supervisors.
-
-    3. Perform actions inside the supervision `init/1` callback.
-
-       For example, you may want to start an ETS table that is linked to
-       the supervisor (i.e. if the supervision tree needs to be restarted,
-       the ETS table must be restarted too).
+  Note that in this case we don't have to explicitly import
+  `Supervisor.Spec` since `use Supervisor` automatically does so.
+  Defining a module-based supervisor can be useful, for example,
+  to perform initialization tasks in the `c:Supervisor.init/1` callback.
 
   ## Supervisor and worker options
 
-  In the example above, we have defined workers and supervisors
-  and each accepts the following options:
+  In the example above, we defined specs for workers and supervisors.
+  These specs (both for workers as well as supervisors) accept the
+  following options:
 
     * `:id` - a name used to identify the child specification
       internally by the supervisor; defaults to the given module
-      name
+      name for the child worker/supervisor
 
     * `:function` - the function to invoke on the child to start it
 
-    * `:restart` - defines when the child process should restart
+    * `:restart` - an atom that defines when a terminated child process should
+      be restarted (see the "Restart values" section below)
 
-    * `:shutdown` - defines how a child process should be terminated
+    * `:shutdown` - an atom that defines how a child process should be
+      terminated (see the "Shutdown values" section below)
 
     * `:modules` - it should be a list with one element `[module]`,
       where module is the name of the callback module only if the
       child process is a `Supervisor` or `GenServer`; if the child
-      process is a `GenEvent`, modules should be `:dynamic`
+      process is a `GenEvent`, `:modules` should be `:dynamic`
 
-  ### Restart values
+  ### Restart values (:restart)
 
-  The following restart values are supported:
+  The following restart values are supported in the `:restart` option:
 
     * `:permanent` - the child process is always restarted
 
@@ -80,27 +83,36 @@ defmodule Supervisor.Spec do
       when the supervisor's strategy is `:rest_for_one` or `:one_for_all`)
 
     * `:transient` - the child process is restarted only if it
-      terminates abnormally, i.e. with another exit reason than
+      terminates abnormally, i.e., with an exit reason other than
       `:normal`, `:shutdown` or `{:shutdown, term}`
 
-  ### Shutdown values
+  Note that supervisor that reached maximum restart intensity will exit with `:shutdown` reason.
+  In this case the supervisor will only restart if its child specification was defined with
+  the `:restart` option set to `:permanent` (the default).
+
+  ### Shutdown values (`:shutdown`)
 
-  The following shutdown values are supported:
+  The following shutdown values are supported in the `:shutdown` option:
 
     * `:brutal_kill` - the child process is unconditionally terminated
-      using `exit(child, :kill)`.
+      using `Process.exit(child, :kill)`
 
-    * `:infinity` - if the child process is a supervisor, it is a mechanism
-      to give the subtree enough time to shutdown. It can also be used with
-      workers with care.
+    * `:infinity` - if the child process is a supervisor, this is a mechanism
+      to give the subtree enough time to shut down; it can also be used with
+      workers with care
+
+    * a non-negative integer - the amount of time in milliseconds
+      that the supervisor tells the child process to terminate by calling
+      `Process.exit(child, :shutdown)` and then waits for an exit signal back.
+      If no exit signal is received within the specified time,
+      the child process is unconditionally terminated
+      using `Process.exit(child, :kill)`
 
-    * Finally, it can also be any integer meaning that the supervisor tells
-      the child process to terminate by calling `Process.exit(child, :shutdown)`
-      and then waits for an exit signal back. If no exit signal is received
-      within the specified time (in miliseconds), the child process is
-      unconditionally terminated using `Process.exit(child, :kill)`.
   """
 
+  @moduledoc deprecated:
+               "Use the new child specifications outlined in the Supervisor module instead"
+
   @typedoc "Supported strategies"
   @type strategy :: :simple_one_for_one | :one_for_one | :one_for_all | :rest_for_one
 
@@ -108,7 +120,7 @@ defmodule Supervisor.Spec do
   @type restart :: :permanent | :transient | :temporary
 
   @typedoc "Supported shutdown values"
-  @type shutdown :: :brutal_kill | :infinity | non_neg_integer
+  @type shutdown :: timeout | :brutal_kill
 
   @typedoc "Supported worker values"
   @type worker :: :worker | :supervisor
@@ -116,26 +128,24 @@ defmodule Supervisor.Spec do
   @typedoc "Supported module values"
   @type modules :: :dynamic | [module]
 
-  @typedoc "Supported id values"
+  @typedoc "Supported ID values"
   @type child_id :: term
 
   @typedoc "The supervisor specification"
-  @type spec :: {child_id,
-                  start_fun :: {module, atom, [term]},
-                  restart,
-                  shutdown,
-                  worker,
-                  modules}
+  @type spec ::
+          {child_id, start_fun :: {module, atom, [term]}, restart, shutdown, worker, modules}
 
   @doc """
-  Receives a list of children (workers or supervisors) to
-  supervise and a set of options.
+  Receives a list of `children` (workers or supervisors) to
+  supervise and a set of `options`.
 
-  Returns a tuple containing the supervisor specification.
+  Returns a tuple containing the supervisor specification. This tuple can be
+  used as the return value of the `c:Supervisor.init/1` callback when implementing a
+  module-based supervisor.
 
   ## Examples
 
-      supervise children, strategy: :one_for_one
+      supervise(children, strategy: :one_for_one)
 
   ## Options
 
@@ -144,36 +154,52 @@ defmodule Supervisor.Spec do
       `:simple_one_for_one`. You can learn more about strategies
       in the `Supervisor` module docs.
 
-    * `:max_restarts` - the maximum amount of restarts allowed in
-      a time frame. Defaults to 5.
+    * `:max_restarts` - the maximum number of restarts allowed in
+      a time frame. Defaults to `3`.
 
     * `:max_seconds` - the time frame in which `:max_restarts` applies.
-      Defaults to 5.
+      Defaults to `5`.
 
-  The `:strategy` option is required and by default maximum 5 restarts
-  are allowed within 5 seconds. Please check the `Supervisor` module for
-  a complete description of the available strategies.
+  The `:strategy` option is required and by default a maximum of 3 restarts is
+  allowed within 5 seconds. Check the `Supervisor` module for a detailed
+  description of the available strategies.
   """
-  @spec supervise([spec], strategy: strategy,
-                          max_restarts: non_neg_integer,
-                          max_seconds: non_neg_integer) :: {:ok, tuple}
+  @spec supervise(
+          [spec],
+          strategy: strategy,
+          max_restarts: non_neg_integer,
+          max_seconds: pos_integer
+        ) :: {:ok, tuple}
+  @deprecated "Use the new child specifications outlined in the Supervisor module instead"
   def supervise(children, options) do
-    unless strategy = options[:strategy] do
+    if !(strategy = options[:strategy]) do
       raise ArgumentError, "expected :strategy option to be given"
     end
 
-    maxR = Keyword.get(options, :max_restarts, 5)
+    maxR = Keyword.get(options, :max_restarts, 3)
     maxS = Keyword.get(options, :max_seconds, 5)
 
-    assert_unique_ids(Enum.map(children, &elem(&1, 0)))
+    assert_unique_ids(Enum.map(children, &get_id/1))
     {:ok, {{strategy, maxR, maxS}, children}}
   end
 
-  defp assert_unique_ids([id|rest]) do
+  defp get_id({id, _, _, _, _, _}) do
+    id
+  end
+
+  defp get_id(other) do
+    raise ArgumentError,
+          "invalid tuple specification given to supervise/2. If you are trying to use " <>
+            "the map child specification that is part of the Elixir v1.5, use Supervisor.init/2 " <>
+            "instead of Supervisor.Spec.supervise/2. See the Supervisor module for more information. " <>
+            "Got: #{inspect(other)}"
+  end
+
+  defp assert_unique_ids([id | rest]) do
     if id in rest do
       raise ArgumentError,
-        "duplicated id #{inspect id} found in the supervisor specification, " <>
-        "please explicitly pass the :id option when defining this worker/supervisor"
+            "duplicate ID #{inspect(id)} found in the supervisor specification, " <>
+              "please explicitly pass the :id option when defining this worker/supervisor"
     else
       assert_unique_ids(rest)
     end
@@ -187,22 +213,32 @@ defmodule Supervisor.Spec do
   Defines the given `module` as a worker which will be started
   with the given arguments.
 
-      worker ExUnit.Runner, [], restart: :permanent
+      worker(ExUnit.Runner, [], restart: :permanent)
 
   By default, the function `start_link` is invoked on the given
   module. Overall, the default values for the options are:
 
-      [id: module,
-       function: :start_link,
-       restart: :permanent,
-       shutdown: 5000,
-       modules: [module]]
+      [
+        id: module,
+        function: :start_link,
+        restart: :permanent,
+        shutdown: 5000,
+        modules: [module]
+      ]
 
-  Check `Supervisor.Spec` module docs for more information on
-  the options.
+  See the "Supervisor and worker options" section in the `Supervisor.Spec` module for more
+  information on the available options.
   """
-  @spec worker(module, [term], [restart: restart, shutdown: shutdown,
-                                id: term, function: atom, modules: modules]) :: spec
+  @spec worker(
+          module,
+          [term],
+          restart: restart,
+          shutdown: shutdown,
+          id: term,
+          function: atom,
+          modules: modules
+        ) :: spec
+  @deprecated "Use the new child specifications outlined in the Supervisor module instead"
   def worker(module, args, options \\ []) do
     child(:worker, module, args, options)
   end
@@ -211,38 +247,47 @@ defmodule Supervisor.Spec do
   Defines the given `module` as a supervisor which will be started
   with the given arguments.
 
-      supervisor ExUnit.Runner, [], restart: :permanent
+      supervisor(module, [], restart: :permanent)
 
   By default, the function `start_link` is invoked on the given
   module. Overall, the default values for the options are:
 
-      [id: module,
-       function: :start_link,
-       restart: :permanent,
-       shutdown: :infinity,
-       modules: [module]]
+      [
+        id: module,
+        function: :start_link,
+        restart: :permanent,
+        shutdown: :infinity,
+        modules: [module]
+      ]
 
-  Check `Supervisor.Spec` module docs for more information on
-  the options.
+  See the "Supervisor and worker options" section in the `Supervisor.Spec` module for more
+  information on the available options.
   """
-  @spec supervisor(module, [term], [restart: restart, shutdown: shutdown,
-                                    id: term, function: atom, modules: modules]) :: spec
+  @spec supervisor(
+          module,
+          [term],
+          restart: restart,
+          shutdown: shutdown,
+          id: term,
+          function: atom,
+          modules: modules
+        ) :: spec
+  @deprecated "Use the new child specifications outlined in the Supervisor module instead"
   def supervisor(module, args, options \\ []) do
     options = Keyword.put_new(options, :shutdown, :infinity)
     child(:supervisor, module, args, options)
   end
 
   defp child(type, module, args, options) do
-    id       = Keyword.get(options, :id, module)
-    modules  = Keyword.get(options, :modules, modules(module))
+    id = Keyword.get(options, :id, module)
+    modules = Keyword.get(options, :modules, modules(module))
     function = Keyword.get(options, :function, :start_link)
-    restart  = Keyword.get(options, :restart, :permanent)
+    restart = Keyword.get(options, :restart, :permanent)
     shutdown = Keyword.get(options, :shutdown, 5000)
 
-    {id, {module, function, args},
-      restart, shutdown, type, modules}
+    {id, {module, function, args}, restart, shutdown, type, modules}
   end
 
   defp modules(GenEvent), do: :dynamic
-  defp modules(module),   do: [module]
+  defp modules(module), do: [module]
 end
diff --git a/lib/elixir/lib/system.ex b/lib/elixir/lib/system.ex
index 6b35d7abf32..36094065872 100644
--- a/lib/elixir/lib/system.ex
+++ b/lib/elixir/lib/system.ex
@@ -1,50 +1,228 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule System do
   @moduledoc """
-  The System module provides access to variables used or
-  maintained by the VM and to functions that interact directly
+  The `System` module provides functions that interact directly
   with the VM or the host system.
+
+  ## Time
+
+  The `System` module also provides functions that work with time,
+  returning different times kept by the system with support for
+  different time units.
+
+  One of the complexities in relying on system times is that they
+  may be adjusted. For example, when you enter and leave daylight
+  saving time, the system clock will be adjusted, often adding
+  or removing one hour. We call such changes "time warps". In
+  order to understand how such changes may be harmful, imagine
+  the following code:
+
+      ## DO NOT DO THIS
+      prev = System.os_time()
+      # ... execute some code ...
+      next = System.os_time()
+      diff = next - prev
+
+  If, while the code is executing, the system clock changes,
+  some code that executed in 1 second may be reported as taking
+  over 1 hour! To address such concerns, the VM provides a
+  monotonic time via `System.monotonic_time/0` which never
+  decreases and does not leap:
+
+      ## DO THIS
+      prev = System.monotonic_time()
+      # ... execute some code ...
+      next = System.monotonic_time()
+      diff = next - prev
+
+  Generally speaking, the VM provides three time measurements:
+
+    * `os_time/0` - the time reported by the operating system (OS). This time may be
+      adjusted forwards or backwards in time with no limitation;
+
+    * `system_time/0` - the VM view of the `os_time/0`. The system time and operating
+      system time may not match in case of time warps although the VM works towards
+      aligning them. This time is not monotonic (i.e., it may decrease)
+      as its behavior is configured [by the VM time warp
+      mode](https://www.erlang.org/doc/apps/erts/time_correction.html#Time_Warp_Modes);
+
+    * `monotonic_time/0` - a monotonically increasing time provided
+      by the Erlang VM. This is not strictly monotonically increasing. Multiple
+      sequential calls of the function may return the same value.
+
+  The time functions in this module work in the `:native` unit
+  (unless specified otherwise), which is operating system dependent. Most of
+  the time, all calculations are done in the `:native` unit, to
+  avoid loss of precision, with `convert_time_unit/3` being
+  invoked at the end to convert to a specific time unit like
+  `:millisecond` or `:microsecond`. See the `t:time_unit/0` type for
+  more information.
+
+  For a more complete rundown on the VM support for different
+  times, see the [chapter on time and time
+  correction](https://www.erlang.org/doc/apps/erts/time_correction.html)
+  in the Erlang docs.
   """
 
-  defp strip_re(iodata, pattern) do
-    :re.replace(iodata, pattern, "", [return: :binary])
+  defmodule EnvError do
+    @moduledoc """
+    An exception raised when a system environment variable is not set.
+
+    For example, see `System.fetch_env!/1`.
+    """
+
+    defexception [:env]
+
+    @impl true
+    def message(%{env: env}) do
+      "could not fetch environment variable #{inspect(env)} because it is not set"
+    end
+  end
+
+  @typedoc """
+  The time unit to be passed to functions like `monotonic_time/1` and others.
+
+  The `:second`, `:millisecond`, `:microsecond` and `:nanosecond` time
+  units controls the return value of the functions that accept a time unit.
+
+  A time unit can also be a strictly positive integer. In this case, it
+  represents the "parts per second": the time will be returned in `1 /
+  parts_per_second` seconds. For example, using the `:millisecond` time unit
+  is equivalent to using `1000` as the time unit (as the time will be returned
+  in 1/1000 seconds - milliseconds).
+  """
+  @type time_unit ::
+          :second
+          | :millisecond
+          | :microsecond
+          | :nanosecond
+          | pos_integer
+
+  @type signal ::
+          :sigabrt
+          | :sigalrm
+          | :sigchld
+          | :sighup
+          | :sigquit
+          | :sigstop
+          | :sigterm
+          | :sigtstp
+          | :sigusr1
+          | :sigusr2
+
+  @type cmd_opts :: [
+          into: Collectable.t(),
+          lines: pos_integer(),
+          cd: Path.t(),
+          env: [{binary(), binary() | nil}],
+          arg0: binary(),
+          stderr_to_stdout: boolean(),
+          use_stdio: boolean(),
+          parallelism: boolean()
+        ]
+
+  @type shell_opts :: [
+          into: Collectable.t(),
+          lines: pos_integer(),
+          cd: Path.t(),
+          env: [{binary(), binary() | nil}],
+          stderr_to_stdout: boolean(),
+          use_stdio: boolean(),
+          parallelism: boolean(),
+          close_stdin: boolean()
+        ]
+
+  @vm_signals [:sigquit, :sigterm, :sigusr1]
+  @os_signals [:sighup, :sigabrt, :sigalrm, :sigusr2, :sigchld, :sigstop, :sigtstp]
+  @signals @vm_signals ++ @os_signals
+
+  @base_dir :filename.join(__DIR__, "../../..")
+  @version_file :filename.join(@base_dir, "VERSION")
+
+  defp strip(iodata) do
+    :re.replace(iodata, "^[\s\r\n\t]+|[\s\r\n\t]+$", "", [:global, return: :binary])
   end
 
   defp read_stripped(path) do
     case :file.read_file(path) do
       {:ok, binary} ->
-        strip_re(binary, "^\s+|\s+$")
-      _ -> ""
+        strip(binary)
+
+      _ ->
+        ""
     end
   end
 
-  # Read and strip the version from the `VERSION` file.
+  # Read and strip the version from the VERSION file.
   defmacrop get_version do
-    case read_stripped(:filename.join(__DIR__, "../../../VERSION")) do
-      ""   -> raise RuntimeError, message: "could not read the version number from VERSION"
+    case read_stripped(@version_file) do
+      "" -> raise "could not read the version number from VERSION"
       data -> data
     end
   end
 
-  # Tries to run `git describe --always --tags`. In the case of success returns
-  # the most recent tag. If that is not available, tries to read the commit hash
-  # from .git/HEAD. If that fails, returns an empty string.
-  defmacrop get_describe do
-    dirpath = :filename.join(__DIR__, "../../../.git")
-    case :file.read_file_info(dirpath) do
-      {:ok, _} ->
-        if :os.find_executable('git') do
-          data = :os.cmd('git describe --always --tags')
-          strip_re(data, "\n")
-        else
-          read_stripped(:filename.join(".git", "HEAD"))
-        end
-      _ -> ""
-    end
+  # Returns OTP version that Elixir was compiled with.
+  defmacrop get_otp_release do
+    :erlang.list_to_binary(:erlang.system_info(:otp_release))
+  end
+
+  # Tries to run "git rev-parse --short=7 HEAD". In the case of success returns
+  # the short revision hash. If that fails, returns an empty string.
+  defmacrop get_revision do
+    null =
+      case :os.type() do
+        {:win32, _} -> ~c"NUL"
+        _ -> ~c"/dev/null"
+      end
+
+    ~c"git rev-parse --short=7 HEAD 2> "
+    |> Kernel.++(null)
+    |> :os.cmd()
+    |> strip()
   end
 
+  defp revision, do: get_revision()
+
   # Get the date at compilation time.
+  # Follows https://reproducible-builds.org/specs/source-date-epoch/
   defmacrop get_date do
-    IO.iodata_to_binary :httpd_util.rfc1123_date
+    unix_epoch =
+      if source_date_epoch = :os.getenv(~c"SOURCE_DATE_EPOCH") do
+        try do
+          List.to_integer(source_date_epoch)
+        rescue
+          _ -> nil
+        end
+      end
+
+    unix_epoch = unix_epoch || :os.system_time(:second)
+
+    {{year, month, day}, {hour, minute, second}} =
+      :calendar.gregorian_seconds_to_datetime(unix_epoch + 62_167_219_200)
+
+    "~4..0b-~2..0b-~2..0bT~2..0b:~2..0b:~2..0bZ"
+    |> :io_lib.format([year, month, day, hour, minute, second])
+    |> :erlang.iolist_to_binary()
+  end
+
+  @doc """
+  Returns the endianness.
+  """
+  @spec endianness() :: :little | :big
+  def endianness do
+    :erlang.system_info(:endian)
+  end
+
+  @doc """
+  Returns the endianness the system was compiled with.
+  """
+  @endianness :erlang.system_info(:endian)
+  @spec compiled_endianness() :: :little | :big
+  def compiled_endianness do
+    @endianness
   end
 
   @doc """
@@ -52,38 +230,105 @@ defmodule System do
 
   Returns Elixir's version as binary.
   """
-  @spec version() :: String.t
-  def version, do: get_version
+  @spec version() :: String.t()
+  def version, do: get_version()
 
   @doc """
   Elixir build information.
 
-  Returns a keyword list with Elixir version, git tag info and compilation date.
+  Returns a map with the Elixir version, the Erlang/OTP release it was compiled
+  with, a short Git revision hash and the date and time it was built.
+
+  Every value in the map is a string, and these are:
+
+    * `:build` - the Elixir version, short Git revision hash and
+      Erlang/OTP release it was compiled with
+    * `:date` - a string representation of the ISO8601 date and time it was built
+    * `:otp_release` - OTP release it was compiled with
+    * `:revision` - short Git revision hash. If Git was not available at building
+      time, it is set to `""`
+    * `:version` - the Elixir version
+
+  One should not rely on the specific formats returned by each of those fields.
+  Instead one should use specialized functions, such as `version/0` to retrieve
+  the Elixir version and `otp_release/0` to retrieve the Erlang/OTP release.
+
+  ## Examples
+
+      iex> System.build_info()
+      %{
+        build: "1.9.0-dev (772a00a0c) (compiled with Erlang/OTP 21)",
+        date: "2018-12-24T01:09:21Z",
+        otp_release: "21",
+        revision: "772a00a0c",
+        version: "1.9.0-dev"
+      }
+
   """
-  @spec build_info() :: map
+  @spec build_info() :: %{
+          build: String.t(),
+          date: String.t(),
+          revision: String.t(),
+          version: String.t(),
+          otp_release: String.t()
+        }
   def build_info do
-    %{version: version, tag: get_describe, date: get_date}
+    %{
+      build: build(),
+      date: get_date(),
+      revision: revision(),
+      version: version(),
+      otp_release: get_otp_release()
+    }
+  end
+
+  # Returns a string of the build info
+  defp build do
+    {:ok, v} = Version.parse(version())
+
+    revision_string = if v.pre != [] and revision() != "", do: " (#{revision()})", else: ""
+    otp_version_string = " (compiled with Erlang/OTP #{get_otp_release()})"
+
+    version() <> revision_string <> otp_version_string
   end
 
   @doc """
-  List command line arguments.
+  Lists command line arguments.
 
   Returns the list of command line arguments passed to the program.
   """
-  @spec argv() :: [String.t]
+  @spec argv() :: [String.t()]
   def argv do
-    :elixir_code_server.call :argv
+    :elixir_config.get(:argv)
   end
 
   @doc """
-  Modify command line arguments.
+  Modifies command line arguments.
 
   Changes the list of command line arguments. Use it with caution,
   as it destroys any previous argv information.
   """
-  @spec argv([String.t]) :: :ok
+  @spec argv([String.t()]) :: :ok
   def argv(args) do
-    :elixir_code_server.cast({:argv, args})
+    :elixir_config.put(:argv, args)
+  end
+
+  @doc """
+  Marks if the system should halt or not at the end of ARGV processing.
+  """
+  @doc since: "1.9.0"
+  @spec no_halt(boolean) :: :ok
+  def no_halt(boolean) when is_boolean(boolean) do
+    :elixir_config.put(:no_halt, boolean)
+  end
+
+  @doc """
+  Checks if the system will halt or not at the end of ARGV processing.
+  """
+  @doc since: "1.9.0"
+  @spec no_halt() :: boolean
+  def no_halt() do
+    :elixir_config.get(:no_halt)
   end
 
   @doc """
@@ -92,9 +337,11 @@ defmodule System do
   Returns the current working directory or `nil` if one
   is not available.
   """
+  @deprecated "Use File.cwd/0 instead"
+  @spec cwd() :: String.t() | nil
   def cwd do
-    case :file.get_cwd do
-      {:ok, base} -> IO.chardata_to_string(base)
+    case File.cwd() do
+      {:ok, cwd} -> cwd
       _ -> nil
     end
   end
@@ -104,21 +351,32 @@ defmodule System do
 
   Returns the current working directory or raises `RuntimeError`.
   """
+  @deprecated "Use File.cwd!/0 instead"
+  @spec cwd!() :: String.t()
   def cwd! do
-    cwd ||
-      raise RuntimeError, message: "could not get a current working directory, the current location is not accessible"
+    case File.cwd() do
+      {:ok, cwd} ->
+        cwd
+
+      _ ->
+        raise "could not get a current working directory, the current location is not accessible"
+    end
   end
 
   @doc """
   User home directory.
 
   Returns the user home directory (platform independent).
-  Returns `nil` if no user home is set.
   """
+  @spec user_home() :: String.t() | nil
   def user_home do
-    case :os.type() do
-      {:win32, _} -> get_windows_home
-      _             -> get_unix_home
+    case :init.get_argument(:home) do
+      {:ok, [[home] | _]} ->
+        encoding = :file.native_name_encoding()
+        :unicode.characters_to_binary(home, encoding, encoding)
+
+      _ ->
+        nil
     end
   end
 
@@ -128,23 +386,9 @@ defmodule System do
   Same as `user_home/0` but raises `RuntimeError`
   instead of returning `nil` if no user home is set.
   """
+  @spec user_home!() :: String.t()
   def user_home! do
-    user_home ||
-      raise RuntimeError, message: "could not find the user home, please set the HOME environment variable"
-  end
-
-  defp get_unix_home do
-    get_env("HOME")
-  end
-
-  defp get_windows_home do
-    :filename.absname(
-      get_env("USERPROFILE") || (
-        hd = get_env("HOMEDRIVE")
-        hp = get_env("HOMEPATH")
-        hd && hp && hd <> hp
-      )
-    )
+    user_home() || raise "could not find the user home, please set the HOME environment variable"
   end
 
   @doc ~S"""
@@ -156,17 +400,22 @@ defmodule System do
     1. the directory named by the TMPDIR environment variable
     2. the directory named by the TEMP environment variable
     3. the directory named by the TMP environment variable
-    4. `C:\TMP` on Windows or `/tmp` on Unix
+    4. `C:\TMP` on Windows or `/tmp` on Unix-like operating systems
     5. as a last resort, the current working directory
 
   Returns `nil` if none of the above are writable.
   """
+  @spec tmp_dir() :: String.t() | nil
   def tmp_dir do
-    write_env_tmp_dir('TMPDIR') ||
-      write_env_tmp_dir('TEMP') ||
-      write_env_tmp_dir('TMP')  ||
-      write_tmp_dir('/tmp')     ||
-      ((cwd = cwd()) && write_tmp_dir(cwd))
+    write_env_tmp_dir(~c"TMPDIR") || write_env_tmp_dir(~c"TEMP") || write_env_tmp_dir(~c"TMP") ||
+      write_tmp_dir(~c"/tmp") || write_cwd_tmp_dir()
+  end
+
+  defp write_cwd_tmp_dir do
+    case File.cwd() do
+      {:ok, cwd} -> write_tmp_dir(cwd)
+      _ -> nil
+    end
   end
 
   @doc """
@@ -175,16 +424,16 @@ defmodule System do
   Same as `tmp_dir/0` but raises `RuntimeError`
   instead of returning `nil` if no temp dir is set.
   """
+  @spec tmp_dir!() :: String.t()
   def tmp_dir! do
-    tmp_dir ||
-      raise RuntimeError, message: "could not get a writable temporary directory, " <>
-                                   "please set the TMPDIR environment variable"
+    tmp_dir() ||
+      raise "could not get a writable temporary directory, please set the TMPDIR environment variable"
   end
 
   defp write_env_tmp_dir(env) do
     case :os.getenv(env) do
       false -> nil
-      tmp   -> write_tmp_dir(tmp)
+      tmp -> write_tmp_dir(tmp)
     end
   end
 
@@ -194,135 +443,353 @@ defmodule System do
         case {stat.type, stat.access} do
           {:directory, access} when access in [:read_write, :write] ->
             IO.chardata_to_string(dir)
+
           _ ->
             nil
         end
-      {:error, _} -> nil
+
+      {:error, _} ->
+        nil
     end
   end
 
   @doc """
-  Register a program exit handler function.
+  Registers a program exit handler function.
+
+  Registers a function that will be invoked at the end of an Elixir script.
+  A script is typically started via the command line via the `elixir` and
+  `mix` executables.
 
-  Registers a function that will be invoked
-  at the end of program execution. Useful for
-  invoking a hook in "script" mode.
+  The handler always executes in a different process from the one it was
+  registered in. As a consequence, any resources managed by the calling process
+  (ETS tables, open files, and others) won't be available by the time the handler
+  function is invoked.
 
-  The function must receive the exit status code
-  as an argument.
+  The function must receive the exit status code as an argument.
+
+  If the VM terminates programmatically, via `System.stop/1`, `System.halt/1`,
+  or exit signals, the `at_exit/1` callbacks are not guaranteed to be executed.
   """
+  @spec at_exit((non_neg_integer -> any)) :: :ok
   def at_exit(fun) when is_function(fun, 1) do
-    :elixir_code_server.cast {:at_exit, fun}
+    :elixir_config.update(:at_exit, &[fun | &1])
+    :ok
+  end
+
+  defmodule SignalHandler do
+    @moduledoc false
+    @behaviour :gen_event
+
+    @impl true
+    def init({event, fun}) do
+      {:ok, {event, fun}}
+    end
+
+    @impl true
+    def handle_call(_message, state) do
+      {:ok, :ok, state}
+    end
+
+    @impl true
+    def handle_event(signal, {event, fun}) do
+      if signal == event, do: :ok = fun.()
+      {:ok, {event, fun}}
+    end
+
+    @impl true
+    def handle_info(_, {event, fun}) do
+      {:ok, {event, fun}}
+    end
   end
 
   @doc """
-  Execute a system command.
+  Traps the given `signal` to execute the `fun`.
+
+  > #### Avoid setting traps in libraries {: .warning}
+  >
+  > Trapping signals may have strong implications
+  > on how a system shuts down and behaves in production and
+  > therefore it is extremely discouraged for libraries to
+  > set their own traps. Instead, they should redirect users
+  > to configure them themselves. The only cases where it is
+  > acceptable for libraries to set their own traps is when
+  > using Elixir in script mode, such as in `.exs` files and
+  > via Mix tasks.
+
+  An optional `id` that uniquely identifies the function
+  can be given, otherwise a unique one is automatically
+  generated. If a previously registered `id` is given,
+  this function returns an error tuple. The `id` can be
+  used to remove a registered signal by calling
+  `untrap_signal/2`.
+
+  The given `fun` receives no arguments and it must return
+  `:ok`.
+
+  It returns `{:ok, id}` in case of success,
+  `{:error, :already_registered}` in case the id has already
+  been registered for the given signal, or `{:error, :not_sup}`
+  in case trapping exists is not supported by the current OS.
+
+  The first time a signal is trapped, it will override the
+  default behavior from the operating system. If the same
+  signal is trapped multiple times, subsequent functions
+  given to `trap_signal` will execute *first*. In other
+  words, you can consider each function is prepended to
+  the signal handler.
+
+  By default, the Erlang VM register traps to the three
+  signals:
+
+    * `:sigstop` - gracefully shuts down the VM with `stop/0`
+    * `:sigquit` - halts the VM via `halt/0`
+    * `:sigusr1` - halts the VM via status code of 1
+
+  Therefore, if you add traps to the signals above, the
+  default behavior above will be executed after all user
+  signals.
+
+  ## Implementation notes
+
+  All signals run from a single process. Therefore, blocking the
+  `fun` will block subsequent traps. It is also not possible to add
+  or remove traps from within a trap itself.
+
+  Internally, this functionality is built on top of `:os.set_signal/2`.
+  When you register a trap, Elixir automatically sets it to `:handle`
+  and it reverts it back to `:default` once all traps are removed
+  (except for `:sigquit`, `:sigterm`, and `:sigusr1` which are always
+  handled). If you or a library call `:os.set_signal/2` directly,
+  it may disable Elixir traps (or Elixir may override your configuration).
+  """
+  @doc since: "1.12.0"
+  @spec trap_signal(signal, (-> :ok)) :: {:ok, reference()} | {:error, :not_sup}
+  @spec trap_signal(signal, id, (-> :ok)) ::
+          {:ok, id} | {:error, :already_registered} | {:error, :not_sup}
+        when id: term()
+  def trap_signal(signal, id \\ make_ref(), fun)
+      when signal in @signals and is_function(fun, 0) do
+    :elixir_config.serial(fn ->
+      gen_id = {signal, id}
+
+      if {SignalHandler, gen_id} in signal_handlers() do
+        {:error, :already_registered}
+      else
+        try do
+          :os.set_signal(signal, :handle)
+        rescue
+          _ -> {:error, :not_sup}
+        else
+          :ok ->
+            :ok =
+              :gen_event.add_handler(:erl_signal_server, {SignalHandler, gen_id}, {signal, fun})
 
-  Executes `command` in a command shell of the target OS,
-  captures the standard output of the command and returns
-  the result as a binary.
+            {:ok, id}
+        end
+      end
+    end)
+  end
 
-  If `command` is a char list, a char list is returned.
-  Otherwise a string, correctly encoded in UTF-8, is expected.
+  @doc """
+  Removes a previously registered `signal` with `id`.
   """
-  @spec cmd(String.t)  :: String.t
-  @spec cmd(char_list) :: char_list
+  @doc since: "1.12.0"
+  @spec untrap_signal(signal, id) :: :ok | {:error, :not_found} when id: term
+  def untrap_signal(signal, id) when signal in @signals do
+    :elixir_config.serial(fn ->
+      gen_id = {signal, id}
+
+      case :gen_event.delete_handler(:erl_signal_server, {SignalHandler, gen_id}, :delete) do
+        :ok ->
+          if not trapping?(signal) do
+            :os.set_signal(signal, :default)
+          end
+
+          :ok
+
+        {:error, :module_not_found} ->
+          {:error, :not_found}
+      end
+    end)
+  end
 
-  def cmd(command) when is_list(command) do
-    :os.cmd(command)
+  defp trapping?(signal) do
+    signal in @vm_signals or
+      Enum.any?(signal_handlers(), &match?({_, {^signal, _}}, &1))
   end
 
-  def cmd(command) when is_binary(command) do
-    List.to_string :os.cmd(String.to_char_list(command))
+  defp signal_handlers do
+    :gen_event.which_handlers(:erl_signal_server)
   end
 
   @doc """
-  Locate an executable on the system.
+  Locates an executable on the system.
 
   This function looks up an executable program given
-  its name using the environment variable PATH on Unix
-  and Windows. It also considers the proper executable
-  extension for each OS, so for Windows it will try to
+  its name using the environment variable PATH on Windows and Unix-like
+  operating systems. It also considers the proper executable
+  extension for each operating system, so for Windows it will try to
   lookup files with `.com`, `.cmd` or similar extensions.
-
-  If `program` is a char list, a char list is returned.
-  Returns a binary otherwise.
   """
   @spec find_executable(binary) :: binary | nil
-  @spec find_executable(char_list) :: char_list | nil
-
-  def find_executable(program) when is_list(program) do
-    :os.find_executable(program) || nil
-  end
-
   def find_executable(program) when is_binary(program) do
-    case :os.find_executable(String.to_char_list(program)) do
+    assert_no_null_byte!(program, "System.find_executable/1")
+
+    case :os.find_executable(String.to_charlist(program)) do
       false -> nil
       other -> List.to_string(other)
     end
   end
 
   @doc """
-  System environment variables.
+  Returns all system environment variables.
 
-  Returns a list of all environment variables. Each variable is given as a
-  `{name, value}` tuple where both `name` and `value` are strings.
+  The returned value is a map containing name-value pairs.
+  Variable names and their values are strings.
   """
-  @spec get_env() :: %{String.t => String.t}
+  @spec get_env() :: %{optional(String.t()) => String.t()}
   def get_env do
-    Enum.into(:os.getenv, %{}, fn var ->
-      var = IO.chardata_to_string var
-      [k, v] = String.split var, "=", parts: 2
-      {k, v}
+    Map.new(:os.env(), fn {k, v} ->
+      {IO.chardata_to_string(k), IO.chardata_to_string(v)}
     end)
   end
 
   @doc """
-  Environment variable value.
+  Returns the value of the given environment variable.
+
+  The returned value of the environment variable
+  `varname` is a string. If the environment variable
+  is not set, returns the string specified in `default` or
+  `nil` if none is specified.
+
+  ## Examples
+
+      iex> System.get_env("PORT")
+      "4000"
+
+      iex> System.get_env("NOT_SET")
+      nil
+
+      iex> System.get_env("NOT_SET", "4001")
+      "4001"
 
-  Returns the value of the environment variable
-  `varname` as a binary, or `nil` if the environment
-  variable is undefined.
   """
-  @spec get_env(binary) :: binary | nil
-  def get_env(varname) when is_binary(varname) do
-    case :os.getenv(String.to_char_list(varname)) do
-      false -> nil
+  @doc since: "1.9.0"
+  @spec get_env(String.t(), String.t()) :: String.t()
+  @spec get_env(String.t(), nil) :: String.t() | nil
+  def get_env(varname, default \\ nil)
+      when is_binary(varname) and
+             (is_binary(default) or is_nil(default)) do
+    case :os.getenv(String.to_charlist(varname)) do
+      false -> default
       other -> List.to_string(other)
     end
   end
 
+  @doc """
+  Returns the value of the given environment variable or `:error` if not found.
+
+  If the environment variable `varname` is set, then `{:ok, value}` is returned
+  where `value` is a string. If `varname` is not set, `:error` is returned.
+
+  ## Examples
+
+      iex> System.fetch_env("PORT")
+      {:ok, "4000"}
+
+      iex> System.fetch_env("NOT_SET")
+      :error
+
+  """
+  @doc since: "1.9.0"
+  @spec fetch_env(String.t()) :: {:ok, String.t()} | :error
+  def fetch_env(varname) when is_binary(varname) do
+    case :os.getenv(String.to_charlist(varname)) do
+      false -> :error
+      other -> {:ok, List.to_string(other)}
+    end
+  end
+
+  @doc """
+  Returns the value of the given environment variable or raises if not found.
+
+  Same as `get_env/1` but raises instead of returning `nil` when the variable is
+  not set.
+
+  ## Examples
+
+      iex> System.fetch_env!("PORT")
+      "4000"
+
+      iex> System.fetch_env!("NOT_SET")
+      ** (System.EnvError) could not fetch environment variable "NOT_SET" because it is not set
+
+  """
+  @doc since: "1.9.0"
+  @spec fetch_env!(String.t()) :: String.t()
+  def fetch_env!(varname) when is_binary(varname) do
+    get_env(varname) || raise(EnvError, env: varname)
+  end
+
   @doc """
   Erlang VM process identifier.
 
   Returns the process identifier of the current Erlang emulator
   in the format most commonly used by the operating system environment.
 
-  See http://www.erlang.org/doc/man/os.html#getpid-0 for more info.
+  For more information, see `:os.getpid/0`.
   """
+  @deprecated "Use System.pid/0 instead"
   @spec get_pid() :: binary
-  def get_pid, do: IO.iodata_to_binary(:os.getpid)
+  def get_pid, do: IO.iodata_to_binary(:os.getpid())
 
   @doc """
-  Set an environment variable value.
+  Sets an environment variable value.
 
   Sets a new `value` for the environment variable `varname`.
   """
   @spec put_env(binary, binary) :: :ok
   def put_env(varname, value) when is_binary(varname) and is_binary(value) do
-   :os.putenv String.to_char_list(varname), String.to_char_list(value)
-   :ok
+    case :binary.match(varname, "=") do
+      {_, _} ->
+        raise ArgumentError,
+              "cannot execute System.put_env/2 for key with \"=\", got: #{inspect(varname)}"
+
+      :nomatch ->
+        :os.putenv(String.to_charlist(varname), String.to_charlist(value))
+        :ok
+    end
   end
 
   @doc """
-  Set multiple environment variables.
+  Sets multiple environment variables.
 
   Sets a new value for each environment variable corresponding
-  to each key in `dict`.
+  to each `{key, value}` pair in `enum`. Keys and non-nil values
+  are automatically converted to charlists. `nil` values erase
+  the given keys.
+
+  Overall, this is a convenience wrapper around `put_env/2` and
+  `delete_env/2` with support for different key and value formats.
   """
-  @spec put_env(Dict.t) :: :ok
-  def put_env(dict) do
-    Enum.each dict, fn {key, val} -> put_env key, val end
+  @spec put_env(Enumerable.t()) :: :ok
+  def put_env(enum) do
+    Enum.each(enum, fn
+      {key, nil} ->
+        :os.unsetenv(to_charlist(key))
+
+      {key, val} ->
+        key = to_charlist(key)
+
+        case :string.find(key, "=") do
+          :nomatch ->
+            :os.putenv(key, to_charlist(val))
+
+          _ ->
+            raise ArgumentError,
+                  "cannot execute System.put_env/1 for key with \"=\", got: #{inspect(key)}"
+        end
+    end)
   end
 
   @doc """
@@ -330,30 +797,30 @@ defmodule System do
 
   Removes the variable `varname` from the environment.
   """
-  @spec delete_env(String.t) :: :ok
+  @spec delete_env(String.t()) :: :ok
   def delete_env(varname) do
-    :os.unsetenv(String.to_char_list(varname))
+    :os.unsetenv(String.to_charlist(varname))
     :ok
   end
 
   @doc """
-  Last exception stacktrace.
-
-  Note that the Erlang VM (and therefore this function) does not
-  return the current stacktrace but rather the stacktrace of the
-  latest exception.
+  Deprecated mechanism to retrieve the last exception stacktrace.
 
-  Inlined by the compiler into `:erlang.get_stacktrace/0`.
+  It always return an empty list.
   """
+  @deprecated "Use __STACKTRACE__ instead"
   def stacktrace do
-    :erlang.get_stacktrace
+    []
   end
 
   @doc """
-  Halt the Erlang runtime system.
+  Immediately halts the Erlang runtime system.
 
-  Halts the Erlang runtime system where the argument `status` must be a
-  non-negative integer, the atom `:abort` or a binary.
+  Terminates the Erlang runtime system without properly shutting down
+  applications and ports. Please see `stop/1` for a careful shutdown of the
+  system.
+
+  `status` must be a non-negative integer, the atom `:abort` or a binary.
 
     * If an integer, the runtime system exits with the integer value which
       is returned to the operating system.
@@ -361,13 +828,13 @@ defmodule System do
     * If `:abort`, the runtime system aborts producing a core dump, if that is
       enabled in the operating system.
 
-    * If a string, an erlang crash dump is produced with status as slogan,
+    * If a string, an Erlang crash dump is produced with status as slogan,
       and then the runtime system exits with status code 1.
 
   Note that on many platforms, only the status codes 0-255 are supported
   by the operating system.
 
-  For more information, check: http://www.erlang.org/doc/man/erlang.html#halt-1
+  For more information, see `:erlang.halt/1`.
 
   ## Examples
 
@@ -385,6 +852,630 @@ defmodule System do
   end
 
   def halt(status) when is_binary(status) do
-    :erlang.halt(String.to_char_list(status))
+    :erlang.halt(String.to_charlist(status))
+  end
+
+  @doc """
+  Returns the operating system PID for the current Erlang runtime system instance.
+
+  Returns a string containing the (usually) numerical identifier for a process.
+  On Unix-like operating systems, this is typically the return value of the `getpid()` system call.
+  On Windows, the process ID as returned by the `GetCurrentProcessId()` system
+  call is used.
+
+  ## Examples
+
+      System.pid()
+
+  """
+  @doc since: "1.9.0"
+  @spec pid :: String.t()
+  def pid do
+    List.to_string(:os.getpid())
+  end
+
+  @doc """
+  Restarts all applications in the Erlang runtime system.
+
+  All applications are taken down smoothly, all code is unloaded, and all ports
+  are closed before the system starts all applications once again.
+
+  ## Examples
+
+      System.restart()
+
+  """
+  @doc since: "1.9.0"
+  @spec restart :: :ok
+  defdelegate restart(), to: :init
+
+  @doc """
+  Asynchronously and carefully stops the Erlang runtime system.
+
+  All applications are taken down smoothly, all code is unloaded, and all ports
+  are closed before the system terminates by calling `halt/1`.
+
+  `status` must be a non-negative integer or a binary.
+
+    * If an integer, the runtime system exits with the integer value which is
+      returned to the operating system. On many platforms, only the status codes
+      0-255 are supported by the operating system.
+
+    * If a binary, an Erlang crash dump is produced with status as slogan, and
+      then the runtime system exits with status code 1.
+
+  Note this function is asynchronous and the current process will continue
+  executing after this function is invoked. In case you want to block the
+  current process until the system effectively shuts down, you can invoke
+  `Process.sleep(:infinity)`.
+
+  ## Examples
+
+      System.stop(0)
+      System.stop(1)
+
+  """
+  @doc since: "1.5.0"
+  @spec stop(non_neg_integer | binary) :: :ok
+  def stop(status \\ 0)
+
+  def stop(status) when is_integer(status) do
+    at_exit(fn _ -> Process.sleep(:infinity) end)
+    :init.stop(status)
+  end
+
+  def stop(status) when is_binary(status) do
+    at_exit(fn _ -> Process.sleep(:infinity) end)
+    :init.stop(String.to_charlist(status))
+  end
+
+  @doc ~S"""
+  Executes the given `command` in the OS shell.
+
+  It uses `sh` for Unix-like systems and `cmd` for Windows.
+
+  > #### Watch out {: .warning}
+  >
+  > Use this function with care. In particular, **never
+  > pass untrusted user input to this function**, as the user would be
+  > able to perform "command injection attacks" by executing any code
+  > directly on the machine. Generally speaking, prefer to use `cmd/3`
+  > over this function.
+
+  ## Examples
+
+      iex> System.shell("echo hello")
+      {"hello\n", 0}
+
+  If you want to stream the output to Standard IO as it arrives:
+
+      iex> System.shell("echo hello", into: IO.stream())
+      hello
+      {%IO.Stream{}, 0}
+
+  ## Options
+
+  It accepts the same options as `cmd/3` (except for `arg0`).
+  It also accepts the following exclusive options:
+
+    * `:close_stdin` (since v1.14.1) - if the stdin should be closed
+      on Unix systems, forcing any command that waits on stdin to
+      immediately terminate. Defaults to `false`.
+  """
+  @doc since: "1.12.0"
+  @spec shell(binary, shell_opts) :: {Collectable.t(), exit_status :: non_neg_integer}
+  def shell(command, opts \\ []) when is_binary(command) do
+    command |> String.trim() |> do_shell(opts)
+  end
+
+  defp do_shell("", _opts), do: {"", 0}
+
+  defp do_shell(command, opts) do
+    assert_no_null_byte!(command, "System.shell/2")
+    {close_stdin?, opts} = Keyword.pop(opts, :close_stdin, false)
+
+    # Finding shell command logic from :os.cmd in OTP
+    # https://github.com/erlang/otp/blob/8deb96fb1d017307e22d2ab88968b9ef9f1b71d0/lib/kernel/src/os.erl#L184
+    case :os.type() do
+      {:unix, _} ->
+        shell_path = :os.find_executable(~c"sh") || :erlang.error(:enoent, [command, opts])
+        close_stdin = if close_stdin?, do: " </dev/null", else: ""
+        command = IO.iodata_to_binary(["(", command, "\n)", close_stdin])
+        do_cmd({:spawn_executable, shell_path}, [args: ["-c", command]], opts)
+
+      {:win32, osname} ->
+        command = String.to_charlist(command)
+
+        command =
+          case {System.get_env("COMSPEC"), osname} do
+            {nil, :windows} -> ~c"command.com /s /c " ++ command
+            {nil, _} -> ~c"cmd /s /c " ++ command
+            {cmd, _} -> ~c"#{cmd} /s /c " ++ command
+          end
+
+        do_cmd({:spawn, command}, [], opts)
+    end
+  end
+
+  @doc ~S"""
+  Executes the given `command` with `args`.
+
+  `command` is expected to be an executable available in PATH
+  unless an absolute path is given.
+
+  `args` must be a list of binaries which the executable will receive
+  as its arguments as is. This means that:
+
+    * environment variables will not be interpolated
+    * wildcard expansion will not happen (unless `Path.wildcard/2` is used
+      explicitly)
+    * arguments do not need to be escaped or quoted for shell safety
+
+  This function returns a tuple containing the collected result
+  and the command exit status.
+
+  Internally, this function uses a `Port` for interacting with the
+  outside world. However, if you plan to run a long-running program,
+  ports guarantee stdin/stdout devices will be closed but it does not
+  automatically terminate the program. The documentation for the
+  `Port` module describes this problem and possible solutions under
+  the "Orphan operating system processes" section.
+
+  > #### Windows argument splitting and untrusted arguments {: .warning}
+  >
+  > On Unix systems, arguments are passed to a new operating system
+  > process as an array of strings but on Windows it is up to the child
+  > process to parse them and some Windows programs may apply their own
+  > rules, which are inconsistent with the standard C runtime `argv` parsing
+  >
+  > This is particularly troublesome when invoking `.bat` or `.com` files
+  > as these run implicitly through `cmd.exe`, whose argument parsing is
+  > vulnerable to malicious input and can be used to run arbitrary shell
+  > commands.
+  >
+  > Therefore, if you are running on Windows and you execute batch
+  > files or `.com` applications, you must not pass untrusted input as
+  > arguments to the program. You may avoid accidentally executing them
+  > by explicitly passing the extension of the program you want to run,
+  > such as `.exe`, and double check the program is indeed not a batch
+  > file or `.com` application.
+
+  ## Options
+
+    * `:into` - injects the result into the given collectable, defaults to `""`
+
+    * `:lines` - (since v1.15.0) reads the output by lines instead of in bytes. It expects a
+      number of maximum bytes to buffer internally (1024 is a reasonable default).
+      The collectable will be called with each finished line (regardless of buffer
+      size) and without the EOL character
+
+    * `:cd` - the directory to run the command in
+
+    * `:env` - an enumerable of tuples containing environment key-value as
+      binary. The child process inherits all environment variables from its
+      parent process, the Elixir application, except those overwritten or
+      cleared using this option. Specify a value of `nil` to clear (unset) an
+      environment variable, which is useful for preventing credentials passed
+      to the application from leaking into child processes
+
+    * `:arg0` - sets the command arg0
+
+    * `:stderr_to_stdout` - redirects stderr to stdout when `true`, no effect
+      if `use_stdio` is `false`.
+
+    * `:use_stdio` - `true` by default, setting it to false allows direct
+      interaction with the terminal from the callee
+
+    * `:parallelism` - when `true`, the VM will schedule port tasks to improve
+      parallelism in the system. If set to `false`, the VM will try to perform
+      commands immediately, improving latency at the expense of parallelism.
+      The default is `false`, and can be set on system startup by passing the
+      [`+spp`](https://www.erlang.org/doc/man/erl.html#+spp) flag to `--erl`.
+      Use `:erlang.system_info(:port_parallelism)` to check if enabled.
+
+  ## Error reasons
+
+  If invalid arguments are given, `ArgumentError` is raised by
+  `System.cmd/3`. `System.cmd/3` also expects a strict set of
+  options and will raise if unknown or invalid options are given.
+
+  Furthermore, `System.cmd/3` may fail with one of the POSIX reasons
+  detailed below:
+
+    * `:system_limit` - all available ports in the Erlang emulator are in use
+
+    * `:enomem` - there was not enough memory to create the port
+
+    * `:eagain` - there are no more available operating system processes
+
+    * `:enametoolong` - the external command given was too long
+
+    * `:emfile` - there are no more available file descriptors
+      (for the operating system process that the Erlang emulator runs in)
+
+    * `:enfile` - the file table is full (for the entire operating system)
+
+    * `:eacces` - the command does not point to an executable file
+
+    * `:enoent` - the command does not point to an existing file
+
+  ## Shell commands
+
+  If you desire to execute a trusted command inside a shell, with pipes,
+  redirecting and so on, please check `shell/2`.
+
+  ## Examples
+
+      iex> System.cmd("echo", ["hello"])
+      {"hello\n", 0}
+
+      iex> System.cmd("echo", ["hello"], env: [{"MIX_ENV", "test"}])
+      {"hello\n", 0}
+
+  If you want to stream the output to Standard IO as it arrives:
+
+      iex> System.cmd("echo", ["hello"], into: IO.stream())
+      hello
+      {%IO.Stream{}, 0}
+
+  If you want to read lines:
+
+      iex> System.cmd("echo", ["hello\nworld"], into: [], lines: 1024)
+      {["hello", "world"], 0}
+
+  """
+  @spec cmd(binary, [binary], cmd_opts) :: {Collectable.t(), exit_status :: non_neg_integer}
+  def cmd(command, args, opts \\ []) when is_binary(command) and is_list(args) do
+    assert_no_null_byte!(command, "System.cmd/3")
+
+    if not Enum.all?(args, &is_binary/1) do
+      raise ArgumentError, "all arguments for System.cmd/3 must be binaries"
+    end
+
+    cmd = String.to_charlist(command)
+
+    cmd =
+      if Path.type(cmd) == :absolute do
+        cmd
+      else
+        :os.find_executable(cmd) || :erlang.error(:enoent, [command, args, opts])
+      end
+
+    do_cmd({:spawn_executable, cmd}, [args: args], opts)
+  end
+
+  defp do_cmd(port_init, base_opts, opts) do
+    {use_stdio?, opts} = Keyword.pop(opts, :use_stdio, true)
+
+    {into, line, opts} =
+      cmd_opts(opts, [:exit_status, :binary, :hide] ++ base_opts, "", false, use_stdio?)
+
+    {initial, fun} = Collectable.into(into)
+
+    try do
+      case line do
+        true -> do_port_line(Port.open(port_init, opts), initial, fun, [])
+        false -> do_port_byte(Port.open(port_init, opts), initial, fun)
+      end
+    catch
+      kind, reason ->
+        fun.(initial, :halt)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      {acc, status} -> {fun.(acc, :done), status}
+    end
+  end
+
+  defp do_port_byte(port, acc, fun) do
+    receive do
+      {^port, {:data, data}} ->
+        do_port_byte(port, fun.(acc, {:cont, data}), fun)
+
+      {^port, {:exit_status, status}} ->
+        {acc, status}
+    end
+  end
+
+  defp do_port_line(port, acc, fun, buffer) do
+    receive do
+      {^port, {:data, {:noeol, data}}} ->
+        do_port_line(port, acc, fun, [data | buffer])
+
+      {^port, {:data, {:eol, data}}} ->
+        data = [data | buffer] |> Enum.reverse() |> IO.iodata_to_binary()
+        do_port_line(port, fun.(acc, {:cont, data}), fun, [])
+
+      {^port, {:exit_status, status}} ->
+        # Data may arrive after exit status on line mode
+        receive do
+          {^port, {:data, {_, data}}} ->
+            data = [data | buffer] |> Enum.reverse() |> IO.iodata_to_binary()
+            {fun.(acc, {:cont, data}), status}
+        after
+          0 -> {acc, status}
+        end
+    end
+  end
+
+  defp cmd_opts([{:into, any} | t], opts, _into, line, stdio?),
+    do: cmd_opts(t, opts, any, line, stdio?)
+
+  defp cmd_opts([{:cd, bin} | t], opts, into, line, stdio?) when is_binary(bin),
+    do: cmd_opts(t, [{:cd, bin} | opts], into, line, stdio?)
+
+  defp cmd_opts([{:arg0, bin} | t], opts, into, line, stdio?) when is_binary(bin),
+    do: cmd_opts(t, [{:arg0, bin} | opts], into, line, stdio?)
+
+  defp cmd_opts([{:stderr_to_stdout, true} | t], opts, into, line, true),
+    do: cmd_opts(t, [:stderr_to_stdout | opts], into, line, true)
+
+  defp cmd_opts([{:stderr_to_stdout, true} | _], _opts, _into, _line, false),
+    do: raise(ArgumentError, "cannot use \"stderr_to_stdout: true\" and \"use_stdio: false\"")
+
+  defp cmd_opts([{:stderr_to_stdout, false} | t], opts, into, line, stdio?),
+    do: cmd_opts(t, opts, into, line, stdio?)
+
+  defp cmd_opts([{:parallelism, bool} | t], opts, into, line, stdio?) when is_boolean(bool),
+    do: cmd_opts(t, [{:parallelism, bool} | opts], into, line, stdio?)
+
+  defp cmd_opts([{:env, enum} | t], opts, into, line, stdio?),
+    do: cmd_opts(t, [{:env, validate_env(enum)} | opts], into, line, stdio?)
+
+  defp cmd_opts([{:lines, max_line_length} | t], opts, into, _line, stdio?)
+       when is_integer(max_line_length) and max_line_length > 0,
+       do: cmd_opts(t, [{:line, max_line_length} | opts], into, true, stdio?)
+
+  defp cmd_opts([{key, val} | _], _opts, _into, _line, _stdio?),
+    do: raise(ArgumentError, "invalid option #{inspect(key)} with value #{inspect(val)}")
+
+  defp cmd_opts([], opts, into, line, stdio?) do
+    opt = if stdio?, do: :use_stdio, else: :nouse_stdio
+    {into, line, [opt | opts]}
+  end
+
+  defp validate_env(enum) do
+    Enum.map(enum, fn
+      {k, nil} ->
+        {String.to_charlist(k), false}
+
+      {k, v} ->
+        {String.to_charlist(k), String.to_charlist(v)}
+
+      other ->
+        raise ArgumentError, "invalid environment key-value #{inspect(other)}"
+    end)
+  end
+
+  @doc """
+  Returns the current monotonic time in the `:native` time unit.
+
+  This time is monotonically increasing and starts in an unspecified
+  point in time. This is not strictly monotonically increasing. Multiple
+  sequential calls of the function may return the same value.
+
+  Inlined by the compiler.
+  """
+  @spec monotonic_time() :: integer
+  def monotonic_time do
+    :erlang.monotonic_time()
+  end
+
+  @doc """
+  Returns the current monotonic time in the given time unit.
+
+  This time is monotonically increasing and starts in an unspecified
+  point in time.
+  """
+  @spec monotonic_time(time_unit | :native) :: integer
+  def monotonic_time(unit) do
+    :erlang.monotonic_time(normalize_time_unit(unit))
+  end
+
+  @doc """
+  Returns the current system time in the `:native` time unit.
+
+  It is the VM view of the `os_time/0`. They may not match in
+  case of time warps although the VM works towards aligning
+  them. This time is not monotonic.
+
+  Inlined by the compiler.
+  """
+  @spec system_time() :: integer
+  def system_time do
+    :erlang.system_time()
+  end
+
+  @doc """
+  Returns the current system time in the given time unit.
+
+  It is the VM view of the `os_time/0`. They may not match in
+  case of time warps although the VM works towards aligning
+  them. This time is not monotonic.
+  """
+  @spec system_time(time_unit | :native) :: integer
+  def system_time(unit) do
+    :erlang.system_time(normalize_time_unit(unit))
+  end
+
+  @doc """
+  Converts `time` from time unit `from_unit` to time unit `to_unit`.
+
+  The result is rounded via the floor function.
+
+  `convert_time_unit/3` accepts an additional time unit (other than the
+  ones in the `t:time_unit/0` type) called `:native`. `:native` is the time
+  unit used by the Erlang runtime system. It's determined when the runtime
+  starts and stays the same until the runtime is stopped, but could differ
+  the next time the runtime is started on the same machine. For this reason,
+  you should use this function to convert `:native` time units to a predictable
+  unit before you display them to humans.
+
+  To determine how many seconds the `:native` unit represents in your current
+  runtime, you can call this function to convert 1 second to the `:native`
+  time unit: `System.convert_time_unit(1, :second, :native)`.
+  """
+  @spec convert_time_unit(integer, time_unit | :native, time_unit | :native) :: integer
+  def convert_time_unit(time, from_unit, to_unit) do
+    :erlang.convert_time_unit(time, normalize_time_unit(from_unit), normalize_time_unit(to_unit))
+  end
+
+  @doc """
+  Returns the current time offset between the Erlang VM monotonic
+  time and the Erlang VM system time.
+
+  The result is returned in the `:native` time unit.
+
+  See `time_offset/1` for more information.
+
+  Inlined by the compiler.
+  """
+  @spec time_offset() :: integer
+  def time_offset do
+    :erlang.time_offset()
+  end
+
+  @doc """
+  Returns the current time offset between the Erlang VM monotonic
+  time and the Erlang VM system time.
+
+  The result is returned in the given time unit `unit`. The returned
+  offset, added to an Erlang monotonic time (for instance, one obtained with
+  `monotonic_time/1`), gives the Erlang system time that corresponds
+  to that monotonic time.
+  """
+  @spec time_offset(time_unit | :native) :: integer
+  def time_offset(unit) do
+    :erlang.time_offset(normalize_time_unit(unit))
+  end
+
+  @doc """
+  Returns the current operating system (OS) time.
+
+  The result is returned in the `:native` time unit.
+
+  This time may be adjusted forwards or backwards in time
+  with no limitation and is not monotonic.
+
+  Inlined by the compiler.
+  """
+  @spec os_time() :: integer
+  @doc since: "1.3.0"
+  def os_time do
+    :os.system_time()
+  end
+
+  @doc """
+  Returns the current operating system (OS) time in the given time `unit`.
+
+  This time may be adjusted forwards or backwards in time
+  with no limitation and is not monotonic.
+  """
+  @spec os_time(time_unit | :native) :: integer
+  @doc since: "1.3.0"
+  def os_time(unit) do
+    :os.system_time(normalize_time_unit(unit))
+  end
+
+  @doc """
+  Returns the Erlang/OTP release number.
+  """
+  @spec otp_release :: String.t()
+  @doc since: "1.3.0"
+  def otp_release do
+    :erlang.list_to_binary(:erlang.system_info(:otp_release))
+  end
+
+  @doc """
+  Returns the number of schedulers in the VM.
+  """
+  @spec schedulers :: pos_integer
+  @doc since: "1.3.0"
+  def schedulers do
+    :erlang.system_info(:schedulers)
+  end
+
+  @doc """
+  Returns the number of schedulers online in the VM.
+  """
+  @spec schedulers_online :: pos_integer
+  @doc since: "1.3.0"
+  def schedulers_online do
+    :erlang.system_info(:schedulers_online)
+  end
+
+  @doc """
+  Generates and returns an integer that is unique in the current runtime
+  instance.
+
+  "Unique" means that this function, called with the same list of `modifiers`,
+  will never return the same integer more than once on the current runtime
+  instance.
+
+  If `modifiers` is `[]`, then a unique integer (that can be positive or negative) is returned.
+  Other modifiers can be passed to change the properties of the returned integer:
+
+    * `:positive` - the returned integer is guaranteed to be positive.
+    * `:monotonic` - the returned integer is monotonically increasing. This
+      means that, on the same runtime instance (but even on different
+      processes), integers returned using the `:monotonic` modifier will always
+      be strictly less than integers returned by successive calls with the
+      `:monotonic` modifier.
+
+  All modifiers listed above can be combined; repeated modifiers in `modifiers`
+  will be ignored.
+
+  Inlined by the compiler.
+  """
+  @spec unique_integer([:positive | :monotonic]) :: integer
+  def unique_integer(modifiers \\ []) do
+    :erlang.unique_integer(modifiers)
+  end
+
+  defp assert_no_null_byte!(binary, operation) do
+    case :binary.match(binary, "\0") do
+      {_, _} ->
+        raise ArgumentError,
+              "cannot execute #{operation} for program with null byte, got: #{inspect(binary)}"
+
+      :nomatch ->
+        binary
+    end
+  end
+
+  defp normalize_time_unit(:native), do: :native
+
+  defp normalize_time_unit(:second), do: :second
+  defp normalize_time_unit(:millisecond), do: :millisecond
+  defp normalize_time_unit(:microsecond), do: :microsecond
+  defp normalize_time_unit(:nanosecond), do: :nanosecond
+
+  defp normalize_time_unit(:seconds), do: warn(:seconds, :second)
+  defp normalize_time_unit(:milliseconds), do: warn(:milliseconds, :millisecond)
+  defp normalize_time_unit(:microseconds), do: warn(:microseconds, :microsecond)
+  defp normalize_time_unit(:nanoseconds), do: warn(:nanoseconds, :nanosecond)
+
+  defp normalize_time_unit(:milli_seconds), do: warn(:milli_seconds, :millisecond)
+  defp normalize_time_unit(:micro_seconds), do: warn(:micro_seconds, :microsecond)
+  defp normalize_time_unit(:nano_seconds), do: warn(:nano_seconds, :nanosecond)
+
+  defp normalize_time_unit(unit) when is_integer(unit) and unit > 0, do: unit
+
+  defp normalize_time_unit(other) do
+    raise ArgumentError,
+          "unsupported time unit. Expected :second, :millisecond, " <>
+            ":microsecond, :nanosecond, or a positive integer, " <> "got #{inspect(other)}"
+  end
+
+  defp warn(unit, replacement_unit) do
+    IO.warn_once(
+      {__MODULE__, unit},
+      fn ->
+        "deprecated time unit: #{inspect(unit)}. A time unit should be " <>
+          ":second, :millisecond, :microsecond, :nanosecond, or a positive integer"
+      end,
+      _stacktrace_drop_levels = 4
+    )
+
+    replacement_unit
   end
 end
diff --git a/lib/elixir/lib/task.ex b/lib/elixir/lib/task.ex
index 0ba6df0cf89..43d7e2e66c8 100644
--- a/lib/elixir/lib/task.ex
+++ b/lib/elixir/lib/task.ex
@@ -1,220 +1,1499 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Task do
   @moduledoc """
-  Conveniences for spawning and awaiting for tasks.
+  Conveniences for spawning and awaiting tasks.
 
   Tasks are processes meant to execute one particular
-  action throughout their life-cycle, often with little or no
+  action throughout their lifetime, often with little or no
   communication with other processes. The most common use case
-  for tasks is to compute a value asynchronously:
+  for tasks is to convert sequential code into concurrent code
+  by computing a value asynchronously:
 
       task = Task.async(fn -> do_some_work() end)
-      res  = do_some_other_work()
+      res = do_some_other_work()
       res + Task.await(task)
 
-  Tasks spawned with `async` can be awaited on by its caller
-  process (and only its caller) as shown in the example above.
+  Tasks spawned with `async` can be awaited on by their caller
+  process (and only their caller) as shown in the example above.
   They are implemented by spawning a process that sends a message
   to the caller once the given computation is performed.
 
-  Besides `async/1` and `await/2`, tasks can also be 
-  started as part of supervision trees and dynamically spawned
-  in remote nodes. We will explore all three scenarios next.
+  Compared to plain processes, started with `spawn/1`, tasks
+  include monitoring metadata and logging in case of errors.
+
+  Besides `async/1` and `await/2`, tasks can also be
+  started as part of a supervision tree and dynamically spawned
+  on remote nodes. We will explore these scenarios next.
 
   ## async and await
 
-  The most common way to spawn a task is with `Task.async/1`. A new
-  process will be created, linked and monitored by the caller. Once
-  the task action finishes, a message will be sent to the caller
-  with the result.
+  One of the common uses of tasks is to convert sequential code
+  into concurrent code with `Task.async/1` while keeping its semantics.
+  When invoked, a new process will be created, linked and monitored
+  by the caller. Once the task action finishes, a message will be sent
+  to the caller with the result.
 
-  `Task.await/2` is used to read the message sent by the task. On
-  `await`, Elixir will also setup a monitor to verify if the process
-  exited for any abnormal reason (or in case exits are being
-  trapped by the caller).
+  `Task.await/2` is used to read the message sent by the task.
 
-  ## Supervised tasks
+  There are two important things to consider when using `async`:
 
-  It is also possible to spawn a task inside a supervision tree
-  with `start_link/1` and `start_link/3`:
+    1. If you are using async tasks, you **must await** a reply
+       as they are *always* sent. If you are not expecting a reply,
+       consider using `Task.start_link/1` as detailed below.
 
-      Task.start_link(fn -> IO.puts "ok" end)
+    2. Async tasks link the caller and the spawned process. This
+       means that, if the caller crashes, the task will crash
+       too and vice-versa. This is on purpose: if the process
+       meant to receive the result no longer exists, there is
+       no purpose in completing the computation. If this is not
+       desired, you will want to use supervised tasks, described
+       in a subsequent section.
 
-  Such tasks can be mounted in your supervision tree as:
+  ## Tasks are processes
 
-      import Supervisor.Spec
+  Tasks are processes and so data will need to be completely copied
+  to them. Take the following code as an example:
 
-      children = [
-        worker(Task, [fn -> IO.puts "ok" end])
-      ]
+      large_data = fetch_large_data()
+      task = Task.async(fn -> do_some_work(large_data) end)
+      res = do_some_other_work()
+      res + Task.await(task)
+
+  The code above copies over all of `large_data`, which can be
+  resource intensive depending on the size of the data.
+  There are two ways to address this.
 
-  Since these tasks are supervised and not directly linked to
-  the caller, they cannot be awaited on. Note `start_link/1`,
-  unlike `async/1`, returns `{:ok, pid}` (which is
-  the result expected by supervision trees).
+  First, if you need to access only part of `large_data`,
+  consider extracting it before the task:
 
-  ## Supervision trees
+      large_data = fetch_large_data()
+      subset_data = large_data.some_field
+      task = Task.async(fn -> do_some_work(subset_data) end)
 
-  The `Task.Supervisor` module allows developers to start supervisors
-  that dynamically supervise tasks:
+  Alternatively, if you can move the data loading altogether
+  to the task, it may be even better:
+
+      task = Task.async(fn ->
+        large_data = fetch_large_data()
+        do_some_work(large_data)
+      end)
+
+  ## Dynamically supervised tasks
+
+  The `Task.Supervisor` module allows developers to dynamically
+  create multiple supervised tasks.
+
+  A short example is:
 
       {:ok, pid} = Task.Supervisor.start_link()
-      Task.Supervisor.async(pid, fn -> do_work() end)
 
-  `Task.Supervisor` also makes it possible to spawn tasks in remote nodes as
-  long as the supervisor is registered locally or globally:
+      task =
+        Task.Supervisor.async(pid, fn ->
+          # Do something
+        end)
 
-      # In the remote node
-      Task.Supervisor.start_link(name: :tasks_sup)
+      Task.await(task)
 
-      # In the client
-      Task.Supervisor.async({:tasks_sup, :remote@local}, fn -> do_work() end)
+  However, in the majority of cases, you want to add the task supervisor
+  to your supervision tree:
 
-  `Task.Supervisor` is more often started in your supervision tree as:
+      Supervisor.start_link([
+        {Task.Supervisor, name: MyApp.TaskSupervisor}
+      ], strategy: :one_for_one)
 
-      import Supervisor.Spec
+  And now you can use async/await by passing the name of
+  the supervisor instead of the pid:
 
-      children = [
-        supervisor(Task.Supervisor, [[name: :tasks_sup]])
-      ]
+      Task.Supervisor.async(MyApp.TaskSupervisor, fn ->
+        # Do something
+      end)
+      |> Task.await()
+
+  We encourage developers to rely on supervised tasks as much as possible.
+  Supervised tasks improve the visibility of how many tasks are running
+  at a given moment and enable a variety of patterns that give you
+  explicit control on how to handle the results, errors, and timeouts.
+  Here is a summary:
+
+    * Using `Task.Supervisor.start_child/2` allows you to start a fire-and-forget
+      task when you don't care about its results or if it completes successfully or not.
+
+    * Using `Task.Supervisor.async/2` + `Task.await/2` allows you to execute
+      tasks concurrently and retrieve its result. If the task fails,
+      the caller will also fail.
+
+    * Using `Task.Supervisor.async_nolink/2` + `Task.yield/2` + `Task.shutdown/2`
+      allows you to execute tasks concurrently and retrieve their results
+      or the reason they failed within a given time frame. If the task fails,
+      the caller won't fail. You will receive the error reason either on
+      `yield` or `shutdown`.
+
+  Furthermore, the supervisor guarantees all tasks terminate within a
+  configurable shutdown period when your application shuts down. See the
+  `Task.Supervisor` module for details on the supported operations.
+
+  ### Distributed tasks
+
+  With `Task.Supervisor`, it is easy to dynamically start tasks across nodes:
+
+      # First on the remote node named :remote@local
+      Task.Supervisor.start_link(name: MyApp.DistSupervisor)
+
+      # Then on the local client node
+      supervisor = {MyApp.DistSupervisor, :remote@local}
+      Task.Supervisor.async(supervisor, MyMod, :my_fun, [arg1, arg2, arg3])
+
+  Note that, as above, when working with distributed tasks, one should use the
+  `Task.Supervisor.async/5` function that expects explicit module, function,
+  and arguments, instead of `Task.Supervisor.async/3` that works with anonymous
+  functions. That's because anonymous functions expect the same module version
+  to exist on all involved nodes. Check the `Agent` module documentation for
+  more information on distributed processes as the limitations described there
+  apply to the whole ecosystem.
+
+  ## Statically supervised tasks
+
+  The `Task` module implements the `child_spec/1` function, which
+  allows it to be started directly under a regular `Supervisor` -
+  instead of a `Task.Supervisor` - by passing a tuple with a function
+  to run:
+
+      Supervisor.start_link([
+        {Task, fn -> :some_work end}
+      ], strategy: :one_for_one)
+
+  This is often useful when you need to execute some steps while
+  setting up your supervision tree. For example: to warm up caches,
+  log the initialization status, and such.
+
+  If you don't want to put the Task code directly under the `Supervisor`,
+  you can wrap the `Task` in its own module, similar to how you would
+  do with a `GenServer` or an `Agent`:
+
+      defmodule MyTask do
+        use Task
+
+        def start_link(arg) do
+          Task.start_link(__MODULE__, :run, [arg])
+        end
+
+        def run(arg) do
+          # ...
+        end
+      end
+
+  And then passing it to the supervisor:
+
+      Supervisor.start_link([
+        {MyTask, arg}
+      ], strategy: :one_for_one)
+
+  Since these tasks are supervised and not directly linked to the caller,
+  they cannot be awaited on. By default, the functions `Task.start/1`
+  and `Task.start_link/1` are for fire-and-forget tasks, where you don't
+  care about the results or if it completes successfully or not.
+
+  > #### `use Task` {: .info}
+  >
+  > When you `use Task`, the `Task` module will define a
+  > `child_spec/1` function, so your module can be used
+  > as a child in a supervision tree.
+
+  `use Task` defines a `child_spec/1` function, allowing the
+  defined module to be put under a supervision tree. The generated
+  `child_spec/1` can be customized with the following options:
+
+    * `:id` - the child specification identifier, defaults to the current module
+    * `:restart` - when the child should be restarted, defaults to `:temporary`
+    * `:shutdown` - how to shut down the child, either immediately or by giving it time to shut down
+
+  Opposite to `GenServer`, `Agent` and `Supervisor`, a Task has
+  a default `:restart` of `:temporary`. This means the task will
+  not be restarted even if it crashes. If you desire the task to
+  be restarted for non-successful exits, do:
+
+      use Task, restart: :transient
+
+  If you want the task to always be restarted:
+
+      use Task, restart: :permanent
+
+  See the "Child specification" section in the `Supervisor` module
+  for more detailed information. The `@doc` annotation immediately
+  preceding `use Task` will be attached to the generated `child_spec/1`
+  function.
+
+  ## Ancestor and Caller Tracking
+
+  Whenever you start a new process, Elixir annotates the process with the parent
+  through the `$ancestors` key in the process dictionary. This is often used to
+  track the hierarchy inside a supervision tree.
+
+  For example, we recommend developers to always start tasks under a supervisor.
+  This provides more visibility and allows you to control how those tasks are
+  terminated when a node shuts down. That might look something like
+  `Task.Supervisor.start_child(MySupervisor, task_function)`. This means
+  that, although your code is the one invoking the task, the actual ancestor of
+  the task is the supervisor, as the supervisor is the one effectively starting it.
+
+  To track the relationship between your code and the task, we use the `$callers`
+  key in the process dictionary. Therefore, assuming the `Task.Supervisor` call
+  above, we have:
+
+      [your code] -- calls --> [supervisor] ---- spawns --> [task]
+
+  Which means we store the following relationships:
+
+      [your code]              [supervisor] <-- ancestor -- [task]
+          ^                                                  |
+          |--------------------- caller ---------------------|
 
-  Check `Task.Supervisor` for other operations supported by the Task supervisor.
+  The list of callers of the current process can be retrieved from the Process
+  dictionary with `Process.get(:"$callers")`. This will return either `nil` or
+  a list `[pid_n, ..., pid2, pid1]` with at least one entry where `pid_n` is
+  the PID that called the current process, `pid2` called `pid_n`, and `pid2` was
+  called by `pid1`.
+
+  If a task crashes, the callers field is included as part of the log message
+  metadata under the `:callers` key.
   """
 
   @doc """
   The Task struct.
 
-  It contains two fields:
+  It contains these fields:
+
+    * `:mfa` - a three-element tuple containing the module, function name,
+      and arity invoked to start the task in `async/1` and `async/3`
+
+    * `:owner` - the PID of the process that started the task
+
+    * `:pid` - the PID of the task process; `nil` if there is no process
+      specifically assigned for the task
+
+    * `:ref` - an opaque term used as the task monitor reference
+
+  """
+  @enforce_keys [:mfa, :owner, :pid, :ref]
+  defstruct @enforce_keys
+
+  @typedoc """
+  The Task type.
+
+  See [`%Task{}`](`__struct__/0`) for information about each field of the structure.
+  """
+  @type t :: %__MODULE__{
+          mfa: mfa(),
+          owner: pid(),
+          pid: pid() | nil,
+          ref: ref()
+        }
+
+  @typedoc """
+  The task opaque reference.
+  """
+  @opaque ref :: reference()
+
+  @typedoc """
+  Options given to `async_stream` functions.
+  """
+  @typedoc since: "1.17.0"
+  @type async_stream_option ::
+          {:max_concurrency, pos_integer()}
+          | {:ordered, boolean()}
+          | {:timeout, timeout()}
+          | {:on_timeout, :exit | :kill_task}
+          | {:zip_input_on_exit, boolean()}
+
+  defguardp is_timeout(timeout)
+            when timeout == :infinity or (is_integer(timeout) and timeout >= 0)
 
-    * `:pid` - the process reference of the task process; it may be a pid
-      or a tuple containing the process and node names
+  @doc """
+  Returns a specification to start a task under a supervisor.
 
-    * `:ref` - the task monitor reference
+  `arg` is passed as the argument to `Task.start_link/1` in the `:start` field
+  of the spec.
 
+  For more information, see the `Supervisor` module,
+  the `Supervisor.child_spec/2` function and the `t:Supervisor.child_spec/0` type.
   """
-  defstruct pid: nil, ref: nil
+  @doc since: "1.5.0"
+  @spec child_spec(term) :: Supervisor.child_spec()
+  def child_spec(arg) do
+    %{
+      id: Task,
+      start: {Task, :start_link, [arg]},
+      restart: :temporary
+    }
+  end
+
+  @doc false
+  defmacro __using__(opts) do
+    quote location: :keep, bind_quoted: [opts: opts] do
+      if not Module.has_attribute?(__MODULE__, :doc) do
+        @doc """
+        Returns a specification to start this module under a supervisor.
+
+        `arg` is passed as the argument to `Task.start_link/1` in the `:start` field
+        of the spec.
+
+        For more information, see the `Supervisor` module,
+        the `Supervisor.child_spec/2` function and the `t:Supervisor.child_spec/0` type.
+        """
+      end
+
+      def child_spec(arg) do
+        default = %{
+          id: __MODULE__,
+          start: {__MODULE__, :start_link, [arg]},
+          restart: :temporary
+        }
+
+        Supervisor.child_spec(default, unquote(Macro.escape(opts)))
+      end
+
+      defoverridable child_spec: 1
+    end
+  end
 
   @doc """
-  Starts a task as part of a supervision tree.
+  Starts a task as part of a supervision tree with the given `fun`.
+
+  `fun` must be a zero-arity anonymous function.
+
+  This is used to start a statically supervised task under a supervision tree.
   """
-  @spec start_link(fun) :: {:ok, pid}
-  def start_link(fun) do
+  @spec start_link((-> any)) :: {:ok, pid}
+  def start_link(fun) when is_function(fun, 0) do
     start_link(:erlang, :apply, [fun, []])
   end
 
   @doc """
-  Starts a task as part of a supervision tree.
+  Starts a task as part of a supervision tree with the given
+  `module`, `function`, and `args`.
+
+  This is used to start a statically supervised task under a supervision tree.
   """
   @spec start_link(module, atom, [term]) :: {:ok, pid}
-  def start_link(mod, fun, args) do
-    Task.Supervised.start_link(get_info(self), {mod, fun, args})
+  def start_link(module, function, args)
+      when is_atom(module) and is_atom(function) and is_list(args) do
+    mfa = {module, function, args}
+    Task.Supervised.start_link(get_owner(self()), get_callers(self()), mfa)
+  end
+
+  @doc """
+  Starts a task.
+
+  `fun` must be a zero-arity anonymous function.
+
+  This should only used when the task is used for side-effects
+  (like I/O) and you have no interest on its results nor if it
+  completes successfully.
+
+  If the current node is shutdown, the node will terminate even
+  if the task was not completed. For this reason, we recommend
+  to use `Task.Supervisor.start_child/2` instead, which allows
+  you to control the shutdown time via the `:shutdown` option.
+  """
+  @spec start((-> any)) :: {:ok, pid}
+  def start(fun) when is_function(fun, 0) do
+    start(:erlang, :apply, [fun, []])
+  end
+
+  @doc """
+  Starts a task.
+
+  This should only used when the task is used for side-effects
+  (like I/O) and you have no interest on its results nor if it
+  completes successfully.
+
+  If the current node is shutdown, the node will terminate even
+  if the task was not completed. For this reason, we recommend
+  to use `Task.Supervisor.start_child/2` instead, which allows
+  you to control the shutdown time via the `:shutdown` option.
+  """
+  @spec start(module, atom, [term]) :: {:ok, pid}
+  def start(module, function_name, args)
+      when is_atom(module) and is_atom(function_name) and is_list(args) do
+    mfa = {module, function_name, args}
+    Task.Supervised.start(get_owner(self()), get_callers(self()), mfa)
   end
 
   @doc """
-  Starts a task that can be awaited on.
+  Starts a task that must be awaited on.
+
+  `fun` must be a zero-arity anonymous function. This function
+  spawns a process that is linked to and monitored by the caller
+  process. A `Task` struct is returned containing the relevant
+  information.
+
+  If you start an `async`, you **must await**. This is either done
+  by calling `Task.await/2` or `Task.yield/2` followed by
+  `Task.shutdown/2` on the returned task. Alternatively, if you
+  spawn a task inside a `GenServer`, then the `GenServer` will
+  automatically await for you and call `c:GenServer.handle_info/2`
+  with the task response and associated `:DOWN` message.
+
+  Read the `Task` module documentation for more information about
+  the general usage of async tasks.
+
+  ## Linking
 
   This function spawns a process that is linked to and monitored
-  by the caller process. A `Task` struct is returned containing
-  the relevant information.
+  by the caller process. The linking part is important because it
+  aborts the task if the parent process dies. It also guarantees
+  the code before async/await has the same properties after you
+  add the async call. For example, imagine you have this:
+
+      x = heavy_function()
+      y = some_function()
+      x + y
+
+  Now you want to make the `heavy_function()` async:
+
+      x = Task.async(&heavy_function/0)
+      y = some_function()
+      Task.await(x) + y
 
-  ## Task's message format
+  As before, if `heavy_function/0` fails, the whole computation will
+  fail, including the caller process. If you don't want the task
+  to fail then you must change the `heavy_fun/0` code in the
+  same way you would achieve it if you didn't have the async call.
+  For example, to either return `{:ok, val} | :error` results or,
+  in more extreme cases, by using `try/rescue`. In other words,
+  an asynchronous task should be thought of as an extension of the
+  caller process rather than a mechanism to isolate it from all errors.
 
-  The reply sent by the task will be in the format `{ref, msg}`,
-  where `ref` is the monitoring reference held by the task.
+  If you don't want to link the caller to the task, then you
+  must use a supervised task with `Task.Supervisor` and call
+  `Task.Supervisor.async_nolink/2`.
+
+  In any case, avoid any of the following:
+
+    * Setting `:trap_exit` to `true` - trapping exits should be
+      used only in special circumstances as it would make your
+      process immune to not only exits from the task but from
+      any other processes.
+
+      Moreover, even when trapping exits, calling `await` will
+      still exit if the task has terminated without sending its
+      result back.
+
+    * Unlinking the task process started with `async`/`await`.
+      If you unlink the processes and the task does not belong
+      to any supervisor, you may leave dangling tasks in case
+      the caller process dies.
+
+  ## Metadata
+
+  The task created with this function stores `:erlang.apply/2` in
+  its `:mfa` metadata field, which is used internally to apply
+  the anonymous function. Use `async/3` if you want another function
+  to be used as metadata.
   """
-  @spec async(fun) :: t
-  def async(fun) do
+  @spec async((-> any)) :: t
+  def async(fun) when is_function(fun, 0) do
     async(:erlang, :apply, [fun, []])
   end
 
   @doc """
-  Starts a task that can be awaited on.
+  Starts a task that must be awaited on.
 
-  Similar to `async/1`, but the task is specified by the given
-  module, function and arguments.
+  Similar to `async/1` except the function to be started is
+  specified by the given `module`, `function_name`, and `args`.
+  The `module`, `function_name`, and its arity are stored as
+  a tuple in the `:mfa` field for reflection purposes.
   """
   @spec async(module, atom, [term]) :: t
-  def async(mod, fun, args) do
-    mfa = {mod, fun, args}
-    pid = :proc_lib.spawn_link(Task.Supervised, :async, [self, get_info(self), mfa])
-    ref = Process.monitor(pid)
-    send(pid, {self(), ref})
-    %Task{pid: pid, ref: ref}
+  def async(module, function_name, args)
+      when is_atom(module) and is_atom(function_name) and is_list(args) do
+    mfargs = {module, function_name, args}
+    owner = self()
+    # No need to monitor because the processes are linked
+    {:ok, pid} = Task.Supervised.start_link(get_owner(owner), :nomonitor)
+
+    alias = build_alias(pid)
+    send(pid, {owner, alias, alias, get_callers(owner), mfargs})
+    %Task{pid: pid, ref: alias, owner: owner, mfa: {module, function_name, length(args)}}
+  end
+
+  @doc """
+  Starts a task that immediately completes with the given `result`.
+
+  Unlike `async/1`, this task does not spawn a linked process. It can
+  be awaited or yielded like any other task.
+
+  ## Usage
+
+  In some cases, it is useful to create a "completed" task that represents
+  a task that has already run and generated a result. For example, when
+  processing data you may be able to determine that certain inputs are
+  invalid before dispatching them for further processing:
+
+      def process(data) do
+        tasks =
+          for entry <- data do
+            if invalid_input?(entry) do
+              Task.completed({:error, :invalid_input})
+            else
+              Task.async(fn -> further_process(entry) end)
+            end
+          end
+
+        Task.await_many(tasks)
+      end
+
+  In many cases, `Task.completed/1` may be avoided in favor of returning the
+  result directly.  You should generally only require this variant when working
+  with mixed asynchrony, when a group of inputs will be handled partially
+  synchronously and partially asynchronously.
+  """
+  @doc since: "1.13.0"
+  @spec completed(any) :: t
+  def completed(result) do
+    ref = make_ref()
+    owner = self()
+
+    # "complete" the task immediately
+    send(owner, {ref, result})
+
+    %Task{pid: nil, ref: ref, owner: owner, mfa: {Task, :completed, 1}}
   end
 
-  defp get_info(self) do
-    {node(),
-     case Process.info(self, :registered_name) do
-       {:registered_name, []} -> self()
-       {:registered_name, name} -> name
-     end}
+  @doc """
+  Returns a stream where the given function (`module` and `function_name`)
+  is mapped concurrently on each element in `enumerable`.
+
+  Each element of `enumerable` will be prepended to the given `args` and
+  processed by its own task. Those tasks will be linked to an intermediate
+  process that is then linked to the caller process. This means a failure
+  in a task terminates the caller process and a failure in the caller
+  process terminates all tasks.
+
+  When streamed, each task will emit `{:ok, value}` upon successful
+  completion or `{:exit, reason}` if the caller is trapping exits.
+  It's possible to have `{:exit, {element, reason}}` for exits
+  using the `:zip_input_on_exit` option. The order of results depends
+  on the value of the `:ordered` option.
+
+  The level of concurrency and the time tasks are allowed to run can
+  be controlled via options (see the "Options" section below).
+
+  Consider using `Task.Supervisor.async_stream/6` to start tasks
+  under a supervisor. If you find yourself trapping exits to ensure
+  errors in the tasks do not terminate the caller process, consider
+  using `Task.Supervisor.async_stream_nolink/6` to start tasks that
+  are not linked to the caller process.
+
+  ## Options
+
+    * `:max_concurrency` - sets the maximum number of tasks to run
+      at the same time. Defaults to `System.schedulers_online/0`.
+
+    * `:ordered` - whether the results should be returned in the same order
+      as the input stream. When the output is ordered, Elixir may need to
+      buffer results to emit them in the original order. Setting this option
+      to false disables the need to buffer at the cost of removing ordering.
+      This is also useful when you're using the tasks only for the side effects.
+      Note that regardless of what `:ordered` is set to, the tasks will
+      process asynchronously. If you need to process elements in order,
+      consider using `Enum.map/2` or `Enum.each/2` instead. Defaults to `true`.
+
+    * `:timeout` - the maximum amount of time (in milliseconds or `:infinity`)
+      each task is allowed to execute for. Defaults to `5000`.
+
+    * `:on_timeout` - what to do when a task times out. The possible
+      values are:
+      * `:exit` (default) - the caller (the process that spawned the tasks) exits.
+      * `:kill_task` - the task that timed out is killed. The value
+        emitted for that task is `{:exit, :timeout}`.
+
+    * `:zip_input_on_exit` - (since v1.14.0) adds the original
+      input to `:exit` tuples. The value emitted for that task is
+      `{:exit, {input, reason}}`, where `input` is the collection element
+      that caused an exit during processing. Defaults to `false`.
+
+  ## Example
+
+  Let's build a stream and then enumerate it:
+
+      stream = Task.async_stream(collection, Mod, :expensive_fun, [])
+      Enum.to_list(stream)
+
+  The concurrency can be increased or decreased using the `:max_concurrency`
+  option. For example, if the tasks are IO heavy, the value can be increased:
+
+      max_concurrency = System.schedulers_online() * 2
+      stream = Task.async_stream(collection, Mod, :expensive_fun, [], max_concurrency: max_concurrency)
+      Enum.to_list(stream)
+
+  If you do not care about the results of the computation, you can run
+  the stream with `Stream.run/1`. Also set `ordered: false`, as you don't
+  care about the order of the results either:
+
+      stream = Task.async_stream(collection, Mod, :expensive_fun, [], ordered: false)
+      Stream.run(stream)
+
+  ## First async tasks to complete
+
+  You can also use `async_stream/3` to execute M tasks and find the N tasks
+  to complete. For example:
+
+      [
+        &heavy_call_1/0,
+        &heavy_call_2/0,
+        &heavy_call_3/0
+      ]
+      |> Task.async_stream(fn fun -> fun.() end, ordered: false, max_concurrency: 3)
+      |> Stream.filter(&match?({:ok, _}, &1))
+      |> Enum.take(2)
+
+  In the example above, we are executing three tasks and waiting for the
+  first 2 to complete. We use `Stream.filter/2` to restrict ourselves only
+  to successfully completed tasks, and then use `Enum.take/2` to retrieve
+  N items. Note it is important to set both `ordered: false` and
+  `max_concurrency: M`, where M is the number of tasks, to make sure all
+  calls execute concurrently.
+
+  ### Attention: unbound async + take
+
+  If you want to potentially process a high number of items and keep only
+  part of the results, you may end-up processing more items than desired.
+  Let's see an example:
+
+      1..100
+      |> Task.async_stream(fn i ->
+        Process.sleep(100)
+        IO.puts(to_string(i))
+      end)
+      |> Enum.take(10)
+
+  Running the example above in a machine with 8 cores will process 16 items,
+  even though you want only 10 elements, since `async_stream/3` process items
+  concurrently. That's because it will process 8 elements at once. Then all 8
+  elements complete at roughly the same time, causing 8 elements to be kicked
+  off for processing. Out of these extra 8, only 2 will be used, and the rest
+  will be terminated.
+
+  Depending on the problem, you can filter or limit the number of elements
+  upfront:
+
+      1..100
+      |> Stream.take(10)
+      |> Task.async_stream(fn i ->
+        Process.sleep(100)
+        IO.puts(to_string(i))
+      end)
+      |> Enum.to_list()
+
+  In other cases, you likely want to tweak `:max_concurrency` to limit how
+  many elements may be over processed at the cost of reducing concurrency.
+  You can also set the number of elements to take to be a multiple of
+  `:max_concurrency`. For instance, setting `max_concurrency: 5` in the
+  example above.
+  """
+  @doc since: "1.4.0"
+  @spec async_stream(Enumerable.t(), module, atom, [term], [async_stream_option]) ::
+          Enumerable.t()
+  def async_stream(enumerable, module, function_name, args, options \\ [])
+      when is_atom(module) and is_atom(function_name) and is_list(args) do
+    build_stream(enumerable, {module, function_name, args}, options)
   end
 
   @doc """
-  Awaits for a task reply.
+  Returns a stream that runs the given function `fun` concurrently
+  on each element in `enumerable`.
+
+  Works the same as `async_stream/5` but with an anonymous function instead of a
+  module-function-arguments tuple. `fun` must be a one-arity anonymous function.
+
+  Each `enumerable` element is passed as argument to the given function `fun` and
+  processed by its own task. The tasks will be linked to the caller process, similarly
+  to `async/1`.
+
+  ## Example
+
+  Count the code points in each string asynchronously, then add the counts together using reduce.
+
+      iex> strings = ["long string", "longer string", "there are many of these"]
+      iex> stream = Task.async_stream(strings, fn text -> text |> String.codepoints() |> Enum.count() end)
+      iex> Enum.sum_by(stream, fn {:ok, num} -> num end)
+      47
+
+  See `async_stream/5` for discussion, options, and more examples.
+  """
+  @doc since: "1.4.0"
+  @spec async_stream(Enumerable.t(), (term -> term), [async_stream_option]) :: Enumerable.t()
+  def async_stream(enumerable, fun, options \\ [])
+      when is_function(fun, 1) and is_list(options) do
+    build_stream(enumerable, fun, options)
+  end
+
+  defp build_stream(enumerable, fun, options) do
+    options = Task.Supervised.validate_stream_options(options)
+
+    fn acc, acc_fun ->
+      owner = get_owner(self())
+
+      Task.Supervised.stream(enumerable, acc, acc_fun, get_callers(self()), fun, options, fn ->
+        # No need to monitor because the processes are linked
+        {:ok, pid} = Task.Supervised.start_link(owner, :nomonitor)
+        {:ok, :link, pid}
+      end)
+    end
+  end
+
+  # Returns a tuple with the node where this is executed and either the
+  # registered name of the given PID or the PID of where this is executed. Used
+  # when exiting from tasks to print out from where the task was started.
+  defp get_owner(pid) do
+    self_or_name =
+      case Process.info(pid, :registered_name) do
+        {:registered_name, name} when is_atom(name) -> name
+        _ -> pid
+      end
+
+    {node(), self_or_name, pid}
+  end
+
+  defp get_callers(owner) do
+    case :erlang.get(:"$callers") do
+      [_ | _] = list -> [owner | list]
+      _ -> [owner]
+    end
+  end
+
+  @doc ~S"""
+  Awaits a task reply and returns it.
+
+  In case the task process dies, the caller process will exit with the same
+  reason as the task.
+
+  A timeout, in milliseconds or `:infinity`, can be given with a default value
+  of `5000`. If the timeout is exceeded, then the caller process will exit.
+  If the task process is linked to the caller process which is the case when
+  a task is started with `async`, then the task process will also exit. If the
+  task process is trapping exits or not linked to the caller process, then it
+  will continue to run.
+
+  This function assumes the task's monitor is still active or the monitor's
+  `:DOWN` message is in the message queue. If it has been demonitored, or the
+  message already received, this function will wait for the duration of the
+  timeout awaiting the message.
+
+  This function can only be called once for any given task. If you want
+  to be able to check multiple times if a long-running task has finished
+  its computation, use `yield/2` instead.
+
+  ## Examples
+
+      iex> task = Task.async(fn -> 1 + 1 end)
+      iex> Task.await(task)
+      2
+
+  ## Compatibility with OTP behaviours
+
+  It is not recommended to `await` a long-running task inside an OTP
+  behaviour such as `GenServer`. Instead, you should match on the message
+  coming from a task inside your `c:GenServer.handle_info/2` callback.
+
+  A GenServer will receive two messages on `handle_info/2`:
+
+    * `{ref, result}` - the reply message where `ref` is the monitor
+      reference returned by the `task.ref` and `result` is the task
+      result
+
+    * `{:DOWN, ref, :process, pid, reason}` - since all tasks are also
+      monitored, you will also receive the `:DOWN` message delivered by
+      `Process.monitor/1`. If you receive the `:DOWN` message without a
+      a reply, it means the task crashed
+
+  Another consideration to have in mind is that tasks started by `Task.async/1`
+  are always linked to their callers and you may not want the GenServer to
+  crash if the task crashes. Therefore, it is preferable to instead use
+  `Task.Supervisor.async_nolink/3` inside OTP behaviours. For completeness, here
+  is an example of a GenServer that start tasks and handles their results:
+
+      defmodule GenServerTaskExample do
+        use GenServer
+
+        def start_link(opts) do
+          GenServer.start_link(__MODULE__, :ok, opts)
+        end
+
+        def init(_opts) do
+          # We will keep all running tasks in a map
+          {:ok, %{tasks: %{}}}
+        end
+
+        # Imagine we invoke a task from the GenServer to access a URL...
+        def handle_call(:some_message, _from, state) do
+          url = ...
+          task = Task.Supervisor.async_nolink(MyApp.TaskSupervisor, fn -> fetch_url(url) end)
+
+          # After we start the task, we store its reference and the url it is fetching
+          state = put_in(state.tasks[task.ref], url)
+
+          {:reply, :ok, state}
+        end
+
+        # If the task succeeds...
+        def handle_info({ref, result}, state) do
+          # The task succeed so we can demonitor its reference
+          Process.demonitor(ref, [:flush])
+
+          {url, state} = pop_in(state.tasks[ref])
+          IO.puts("Got #{inspect(result)} for URL #{inspect url}")
+          {:noreply, state}
+        end
+
+        # If the task fails...
+        def handle_info({:DOWN, ref, _, _, reason}, state) do
+          {url, state} = pop_in(state.tasks[ref])
+          IO.puts("URL #{inspect url} failed with reason #{inspect(reason)}")
+          {:noreply, state}
+        end
+      end
+
+  With the server defined, you will want to start the task supervisor
+  above and the GenServer in your supervision tree:
+
+      children = [
+        {Task.Supervisor, name: MyApp.TaskSupervisor},
+        {GenServerTaskExample, name: MyApp.GenServerTaskExample}
+      ]
+
+      Supervisor.start_link(children, strategy: :one_for_one)
 
-  A timeout, in milliseconds, can be given with default value
-  of `5000`. In case the task process dies, this function will
-  exit with the same reason as the task.
   """
-  @spec await(t, timeout) :: term | no_return
-  def await(%Task{ref: ref}=task, timeout \\ 5000) do
+  @spec await(t, timeout) :: term
+  def await(%Task{ref: ref, owner: owner} = task, timeout \\ 5000) when is_timeout(timeout) do
+    if owner != self() do
+      raise ArgumentError, invalid_owner_error(task)
+    end
+
+    await_receive(ref, task, timeout)
+  end
+
+  defp await_receive(ref, task, timeout) do
     receive do
       {^ref, reply} ->
-        Process.demonitor(ref, [:flush])
+        demonitor(ref)
         reply
-      {:DOWN, ^ref, _, _, :noconnection} ->
-        mfa = {__MODULE__, :await, [task, timeout]}
-        exit({{:nodedown, node(task.pid)}, mfa})
-      {:DOWN, ^ref, _, _, reason} ->
-        exit({reason, {__MODULE__, :await, [task, timeout]}})
+
+      {:DOWN, ^ref, _, proc, reason} ->
+        exit({reason(reason, proc), {__MODULE__, :await, [task, timeout]}})
     after
       timeout ->
-        Process.demonitor(ref, [:flush])
+        demonitor(ref)
         exit({:timeout, {__MODULE__, :await, [task, timeout]}})
     end
   end
 
   @doc """
-  Receives a group of tasks and a message and finds
-  a task that matches the given message.
+  Ignores an existing task.
 
-  This function returns a tuple with the task and the
-  returned value in case the message matches a task that
-  exited with success, it raises in case the found task
-  failed or `nil` if no task was found.
+  This means the task will continue running, but it will be unlinked
+  and you can no longer yield, await or shut it down.
 
-  This function is useful in situations where multiple
-  tasks are spawned and their results are collected
-  later on. For example, a `GenServer` can spawn tasks,
-  store the tasks in a list and later use `Task.find/2`
-  to see if incoming messages are from any of the tasks.
+  Returns `{:ok, reply}` if the reply is received before ignoring the task,
+  `{:exit, reason}` if the task died before ignoring it, otherwise `nil`.
+
+  Important: avoid using [`Task.async/1,3`](`async/1`) and then immediately ignoring
+  the task. If you want to start tasks you don't care about their
+  results, use `Task.Supervisor.start_child/2` instead.
   """
-  @spec find([t], any) :: {term, t} | nil | no_return
-  def find(tasks, msg)
+  @doc since: "1.13.0"
+  @spec ignore(t) :: {:ok, term} | {:exit, term} | nil
+  def ignore(%Task{ref: ref, pid: pid, owner: owner} = task) do
+    if owner != self() do
+      raise ArgumentError, invalid_owner_error(task)
+    end
 
-  def find(tasks, {ref, reply}) when is_reference(ref) do
-    Enum.find_value tasks, fn
-      %Task{ref: task_ref} = t when ref == task_ref ->
-        Process.demonitor(ref, [:flush])
-        {reply, t}
-      %Task{} ->
+    ignore_receive(ref, pid, task)
+  end
+
+  defp ignore_receive(ref, pid, task) do
+    receive do
+      {^ref, reply} ->
+        pid && Process.unlink(pid)
+        demonitor(ref)
+        {:ok, reply}
+
+      {:DOWN, ^ref, _, proc, :noconnection} ->
+        exit({reason(:noconnection, proc), {__MODULE__, :ignore, [task]}})
+
+      {:DOWN, ^ref, _, _, reason} ->
+        {:exit, reason}
+    after
+      0 ->
+        pid && Process.unlink(pid)
+        demonitor(ref)
         nil
     end
   end
 
-  def find(tasks, {:DOWN, ref, _, _, reason} = msg) when is_reference(ref) do
-    find = fn(%Task{ref: task_ref}) -> task_ref == ref end
-    case Enum.find(tasks, find) do
-      %Task{pid: pid} when reason == :noconnection ->
-        exit({{:nodedown, node(pid)}, {__MODULE__, :find, [tasks, msg]}})
+  @doc """
+  Awaits replies from multiple tasks and returns them.
+
+  This function receives a list of tasks and waits for their replies in the
+  given time interval. It returns a list of the results, in the same order as
+  the tasks supplied in the `tasks` input argument.
+
+  If any of the task processes dies, the caller process will exit with the same
+  reason as that task.
+
+  A timeout, in milliseconds or `:infinity`, can be given with a default value
+  of `5000`. If the timeout is exceeded, then the caller process will exit.
+  Any task processes that are linked to the caller process (which is the case
+  when a task is started with `async`) will also exit. Any task processes that
+  are trapping exits or not linked to the caller process will continue to run.
+
+  This function assumes the tasks' monitors are still active or the monitor's
+  `:DOWN` message is in the message queue. If any tasks have been demonitored,
+  or the message already received, this function will wait for the duration of
+  the timeout.
+
+  This function can only be called once for any given task. If you want to be
+  able to check multiple times if a long-running task has finished its
+  computation, use `yield_many/2` instead.
+
+  ## Compatibility with OTP behaviours
+
+  It is not recommended to `await` long-running tasks inside an OTP behaviour
+  such as `GenServer`. See `await/2` for more information.
+
+  ## Examples
+
+      iex> tasks = [
+      ...>   Task.async(fn -> 1 + 1 end),
+      ...>   Task.async(fn -> 2 + 3 end)
+      ...> ]
+      iex> Task.await_many(tasks)
+      [2, 5]
+
+  """
+  @doc since: "1.11.0"
+  @spec await_many([t], timeout) :: [term]
+  def await_many(tasks, timeout \\ 5000) when is_timeout(timeout) do
+    awaiting =
+      Map.new(tasks, fn %Task{ref: ref, owner: owner} = task ->
+        if owner != self() do
+          raise ArgumentError, invalid_owner_error(task)
+        end
+
+        {ref, true}
+      end)
+
+    timeout_ref = make_ref()
+
+    timer_ref =
+      if timeout != :infinity do
+        Process.send_after(self(), timeout_ref, timeout)
+      end
+
+    try do
+      await_many(tasks, timeout, awaiting, %{}, timeout_ref)
+    after
+      timer_ref && Process.cancel_timer(timer_ref)
+      receive do: (^timeout_ref -> :ok), after: (0 -> :ok)
+    end
+  end
+
+  defp await_many(tasks, _timeout, awaiting, replies, _timeout_ref)
+       when map_size(awaiting) == 0 do
+    for %{ref: ref} <- tasks, do: Map.fetch!(replies, ref)
+  end
+
+  defp await_many(tasks, timeout, awaiting, replies, timeout_ref) do
+    receive do
+      ^timeout_ref ->
+        demonitor_pending_tasks(awaiting)
+        exit({:timeout, {__MODULE__, :await_many, [tasks, timeout]}})
+
+      {:DOWN, ref, _, proc, reason} when is_map_key(awaiting, ref) ->
+        demonitor_pending_tasks(awaiting)
+        exit({reason(reason, proc), {__MODULE__, :await_many, [tasks, timeout]}})
+
+      {ref, reply} when is_map_key(awaiting, ref) ->
+        demonitor(ref)
+
+        await_many(
+          tasks,
+          timeout,
+          Map.delete(awaiting, ref),
+          Map.put(replies, ref, reply),
+          timeout_ref
+        )
+    end
+  end
+
+  defp demonitor_pending_tasks(awaiting) do
+    Enum.each(awaiting, fn {ref, _} ->
+      demonitor(ref)
+    end)
+  end
+
+  @doc false
+  @deprecated "Pattern match directly on the message instead"
+  def find(tasks, {ref, reply}) when is_reference(ref) do
+    Enum.find_value(tasks, fn
+      %Task{ref: ^ref} = task ->
+        demonitor(ref)
+        {reply, task}
+
       %Task{} ->
-        exit({reason, {__MODULE__, :find, [tasks, msg]}})
-      nil ->
         nil
+    end)
+  end
+
+  def find(tasks, {:DOWN, ref, _, proc, reason} = msg) when is_reference(ref) do
+    find = fn %Task{ref: task_ref} -> task_ref == ref end
+
+    if Enum.find(tasks, find) do
+      exit({reason(reason, proc), {__MODULE__, :find, [tasks, msg]}})
     end
   end
 
   def find(_tasks, _msg) do
     nil
   end
+
+  @doc ~S"""
+  Temporarily blocks the caller process waiting for a task reply.
+
+  Returns `{:ok, reply}` if the reply is received, `nil` if
+  no reply has arrived, or `{:exit, reason}` if the task has already
+  exited. Keep in mind that normally a task failure also causes
+  the process owning the task to exit. Therefore this function can
+  return `{:exit, reason}` if at least one of the conditions below apply:
+
+    * the task process exited with the reason `:normal`
+    * the task isn't linked to the caller (the task was started
+      with `Task.Supervisor.async_nolink/2` or `Task.Supervisor.async_nolink/4`)
+    * the caller is trapping exits
+
+  A timeout, in milliseconds or `:infinity`, can be given with a default value
+  of `5000`. If the time runs out before a message from the task is received,
+  this function will return `nil` and the monitor will remain active. Therefore
+  `yield/2` can be called multiple times on the same task.
+
+  This function assumes the task's monitor is still active or the
+  monitor's `:DOWN` message is in the message queue. If it has been
+  demonitored or the message already received, this function will wait
+  for the duration of the timeout awaiting the message.
+
+  If you intend to shut the task down if it has not responded within `timeout`
+  milliseconds, you should chain this together with `shutdown/1`, like so:
+
+      case Task.yield(task, timeout) || Task.shutdown(task) do
+        {:ok, result} ->
+          result
+
+        nil ->
+          Logger.warning("Failed to get a result in #{timeout}ms")
+          nil
+      end
+
+  If you intend to check on the task but leave it running after the timeout,
+  you can chain this together with `ignore/1`, like so:
+
+      case Task.yield(task, timeout) || Task.ignore(task) do
+        {:ok, result} ->
+          result
+
+        nil ->
+          Logger.warning("Failed to get a result in #{timeout}ms")
+          nil
+      end
+
+  That ensures that if the task completes after the `timeout` but before `shutdown/1`
+  has been called, you will still get the result, since `shutdown/1` is designed to
+  handle this case and return the result.
+  """
+  @spec yield(t, timeout) :: {:ok, term} | {:exit, term} | nil
+  def yield(%Task{ref: ref, owner: owner} = task, timeout \\ 5000) when is_timeout(timeout) do
+    if owner != self() do
+      raise ArgumentError, invalid_owner_error(task)
+    end
+
+    yield_receive(ref, task, timeout)
+  end
+
+  defp yield_receive(ref, task, timeout) do
+    receive do
+      {^ref, reply} ->
+        demonitor(ref)
+        {:ok, reply}
+
+      {:DOWN, ^ref, _, proc, :noconnection} ->
+        exit({reason(:noconnection, proc), {__MODULE__, :yield, [task, timeout]}})
+
+      {:DOWN, ^ref, _, _, reason} ->
+        {:exit, reason}
+    after
+      timeout ->
+        nil
+    end
+  end
+
+  @doc """
+  Yields to multiple tasks in the given time interval.
+
+  This function receives a list of tasks and waits for their
+  replies in the given time interval. It returns a list
+  of two-element tuples, with the task as the first element
+  and the yielded result as the second. The tasks in the returned
+  list will be in the same order as the tasks supplied in the `tasks`
+  input argument.
+
+  Similarly to `yield/2`, each task's result will be
+
+    * `{:ok, term}` if the task has successfully reported its
+      result back in the given time interval
+    * `{:exit, reason}` if the task has died
+    * `nil` if the task keeps running, either because a limit
+      has been reached or past the timeout
+
+  Check `yield/2` for more information.
+
+  ## Example
+
+  `Task.yield_many/2` allows developers to spawn multiple tasks
+  and retrieve the results received in a given time frame.
+  If we combine it with `Task.shutdown/2` (or `Task.ignore/1`),
+  it allows us to gather those results and cancel (or ignore)
+  the tasks that have not replied in time.
+
+  Let's see an example.
+
+      tasks =
+        for i <- 1..10 do
+          Task.async(fn ->
+            Process.sleep(i * 1000)
+            i
+          end)
+        end
+
+      tasks_with_results = Task.yield_many(tasks, timeout: 5000)
+
+      results =
+        Enum.map(tasks_with_results, fn {task, res} ->
+          # Shut down the tasks that did not reply nor exit
+          res || Task.shutdown(task, :brutal_kill)
+        end)
+
+      # Here we are matching only on {:ok, value} and
+      # ignoring {:exit, _} (crashed tasks) and `nil` (no replies)
+      for {:ok, value} <- results do
+        IO.inspect(value)
+      end
+
+  In the example above, we create tasks that sleep from 1
+  up to 10 seconds and return the number of seconds they slept for.
+  If you execute the code all at once, you should see 1 up to 5
+  printed, as those were the tasks that have replied in the
+  given time. All other tasks will have been shut down using
+  the `Task.shutdown/2` call.
+
+  As a convenience, you can achieve a similar behavior to above
+  by specifying the `:on_timeout` option to be `:kill_task` (or
+  `:ignore`). See `Task.await_many/2` if you would rather exit
+  the caller process on timeout.
+
+  ## Options
+
+  The second argument is either a timeout or options, which defaults
+  to this:
+
+    * `:limit` - the maximum amount of tasks to wait for.
+      If the limit is reached before the timeout, this function
+      returns immediately without triggering the `:on_timeout` behaviour
+
+    * `:timeout` - the maximum amount of time (in milliseconds or `:infinity`)
+      each task is allowed to execute for. Defaults to `5000`.
+
+    * `:on_timeout` - what to do when a task times out. The possible
+      values are:
+      * `:nothing` - do nothing (default). The tasks can still be
+        awaited on, yielded on, ignored, or shut down later.
+      * `:ignore` - the results of the task will be ignored.
+      * `:kill_task` - the task that timed out is killed.
+  """
+  @spec yield_many([t], timeout) :: [{t, {:ok, term} | {:exit, term} | nil}]
+  @spec yield_many([t],
+          limit: pos_integer(),
+          timeout: timeout,
+          on_timeout: :nothing | :ignore | :kill_task
+        ) ::
+          [{t, {:ok, term} | {:exit, term} | nil}]
+  def yield_many(tasks, opts \\ [])
+
+  def yield_many(tasks, timeout) when is_timeout(timeout) do
+    yield_many(tasks, timeout: timeout)
+  end
+
+  def yield_many(tasks, opts) when is_list(opts) do
+    refs =
+      Map.new(tasks, fn %Task{ref: ref, owner: owner} = task ->
+        if owner != self() do
+          raise ArgumentError, invalid_owner_error(task)
+        end
+
+        {ref, nil}
+      end)
+
+    on_timeout = Keyword.get(opts, :on_timeout, :nothing)
+    timeout = Keyword.get(opts, :timeout, 5_000)
+    limit = Keyword.get(opts, :limit, map_size(refs))
+    timeout_ref = make_ref()
+
+    timer_ref =
+      if timeout != :infinity do
+        Process.send_after(self(), timeout_ref, timeout)
+      end
+
+    try do
+      yield_many(limit, refs, timeout_ref, timer_ref)
+    catch
+      {:noconnection, reason} ->
+        exit({reason, {__MODULE__, :yield_many, [tasks, timeout]}})
+    else
+      {timed_out?, refs} ->
+        for task <- tasks do
+          value =
+            with nil <- Map.fetch!(refs, task.ref) do
+              case on_timeout do
+                _ when not timed_out? -> nil
+                :nothing -> nil
+                :kill_task -> shutdown(task, :brutal_kill)
+                :ignore -> ignore(task)
+              end
+            end
+
+          {task, value}
+        end
+    end
+  end
+
+  defp yield_many(0, refs, timeout_ref, timer_ref) do
+    timer_ref && Process.cancel_timer(timer_ref)
+    receive do: (^timeout_ref -> :ok), after: (0 -> :ok)
+    {false, refs}
+  end
+
+  defp yield_many(limit, refs, timeout_ref, timer_ref) do
+    receive do
+      {ref, reply} when is_map_key(refs, ref) ->
+        demonitor(ref)
+        yield_many(limit - 1, %{refs | ref => {:ok, reply}}, timeout_ref, timer_ref)
+
+      {:DOWN, ref, _, proc, reason} when is_map_key(refs, ref) ->
+        if reason == :noconnection do
+          throw({:noconnection, reason(:noconnection, proc)})
+        else
+          yield_many(limit - 1, %{refs | ref => {:exit, reason}}, timeout_ref, timer_ref)
+        end
+
+      ^timeout_ref ->
+        {true, refs}
+    end
+  end
+
+  @doc """
+  Unlinks and shuts down the task, and then checks for a reply.
+
+  Returns `{:ok, reply}` if the reply is received while shutting down the task,
+  `{:exit, reason}` if the task died, otherwise `nil`. Once shut down,
+  you can no longer await or yield it.
+
+  The second argument is either a timeout or `:brutal_kill`. In case
+  of a timeout, a `:shutdown` exit signal is sent to the task process
+  and if it does not exit within the timeout, it is killed. With `:brutal_kill`
+  the task is killed straight away. In case the task terminates abnormally
+  (possibly killed by another process), this function will exit with the same reason.
+
+  It is not required to call this function when terminating the caller, unless
+  exiting with reason `:normal` or if the task is trapping exits. If the caller is
+  exiting with a reason other than `:normal` and the task is not trapping exits, the
+  caller's exit signal will stop the task. The caller can exit with reason
+  `:shutdown` to shut down all of its linked processes, including tasks, that
+  are not trapping exits without generating any log messages.
+
+  If there is no process linked to the task, such as tasks started by
+  `Task.completed/1`, we check for a response or error accordingly, but without
+  shutting a process down.
+
+  If a task's monitor has already been demonitored or received and there is not
+  a response waiting in the message queue this function will return
+  `{:exit, :noproc}` as the result or exit reason can not be determined.
+  """
+  @spec shutdown(t, timeout | :brutal_kill) :: {:ok, term} | {:exit, term} | nil
+  def shutdown(task, shutdown \\ 5000)
+
+  def shutdown(%Task{pid: nil} = task, _) do
+    ignore(task)
+  end
+
+  def shutdown(%Task{owner: owner} = task, _) when owner != self() do
+    raise ArgumentError, invalid_owner_error(task)
+  end
+
+  def shutdown(%Task{pid: pid, ref: ref} = task, :brutal_kill) do
+    mon = build_monitor(pid)
+    shutdown_send(pid, :kill)
+
+    case shutdown_receive(ref, mon, task, :brutal_kill, :infinity) do
+      {:down, proc, :noconnection} ->
+        exit({reason(:noconnection, proc), {__MODULE__, :shutdown, [task, :brutal_kill]}})
+
+      {:down, _, reason} ->
+        {:exit, reason}
+
+      result ->
+        result
+    end
+  end
+
+  def shutdown(%Task{pid: pid, ref: ref} = task, timeout) when is_timeout(timeout) do
+    mon = build_monitor(pid)
+    shutdown_send(pid, :shutdown)
+
+    case shutdown_receive(ref, mon, task, :shutdown, timeout) do
+      {:down, proc, :noconnection} ->
+        exit({reason(:noconnection, proc), {__MODULE__, :shutdown, [task, timeout]}})
+
+      {:down, _, reason} ->
+        {:exit, reason}
+
+      result ->
+        result
+    end
+  end
+
+  # Spawn a process to ensure task gets exit signal
+  # if process dies from exit signal between unlink and exit.
+  defp shutdown_send(pid, reason) do
+    caller = self()
+    ref = make_ref()
+    enforcer = spawn(fn -> shutdown_send(pid, reason, caller, ref) end)
+    Process.unlink(pid)
+    Process.exit(pid, reason)
+    send(enforcer, {:done, ref})
+    :ok
+  end
+
+  defp shutdown_send(pid, reason, caller, ref) do
+    mon = Process.monitor(caller)
+
+    receive do
+      {:done, ^ref} -> :ok
+      {:DOWN, ^mon, _, _, _} -> Process.exit(pid, reason)
+    end
+  end
+
+  defp shutdown_receive(ref, mon, task, type, timeout) do
+    receive do
+      {:DOWN, ^mon, _, _, :shutdown} when type in [:shutdown, :timeout_kill] ->
+        demonitor(ref)
+        flush_reply(ref)
+
+      {:DOWN, ^mon, _, _, :killed} when type == :brutal_kill ->
+        demonitor(ref)
+        flush_reply(ref)
+
+      {:DOWN, ^mon, _, proc, :noproc} ->
+        reason = flush_noproc(ref, proc, type)
+        flush_reply(ref) || reason
+
+      {:DOWN, ^mon, _, proc, reason} ->
+        demonitor(ref)
+        flush_reply(ref) || {:down, proc, reason}
+    after
+      timeout ->
+        Process.exit(task.pid, :kill)
+        shutdown_receive(ref, mon, task, :timeout_kill, :infinity)
+    end
+  end
+
+  defp flush_reply(ref) do
+    receive do
+      {^ref, reply} -> {:ok, reply}
+    after
+      0 -> nil
+    end
+  end
+
+  defp flush_noproc(ref, proc, type) do
+    receive do
+      {:DOWN, ^ref, _, _, :shutdown} when type in [:shutdown, :timeout_kill] ->
+        nil
+
+      {:DOWN, ^ref, _, _, :killed} when type == :brutal_kill ->
+        nil
+
+      {:DOWN, ^ref, _, _, reason} ->
+        {:down, proc, reason}
+    after
+      0 ->
+        demonitor(ref)
+        {:down, proc, :noproc}
+    end
+  end
+
+  # exported only to avoid dialyzer opaqueness check in internal Task modules
+  @doc false
+  @spec __alias__(pid()) :: Task.ref()
+  def __alias__(pid) do
+    build_alias(pid)
+  end
+
+  ## Optimizations
+
+  defp build_monitor(pid) do
+    :erlang.monitor(:process, pid)
+  end
+
+  defp build_alias(pid) do
+    :erlang.monitor(:process, pid, alias: :demonitor)
+  end
+
+  @doc false
+  # This instructs the Erlang compiler to apply selective
+  # receive optimizations to several functions in this module.
+  # This function is never invoked directly, it is only here
+  # for compiler optimization purposes.
+  #
+  # To verify which functions have been optimized, run the
+  # following command after Elixir is compiled from the project
+  # root:
+  #
+  #     ERL_COMPILER_OPTIONS=recv_opt_info elixir lib/elixir/lib/task.ex
+  #
+  def __recv_opt_info__(pid, task) do
+    await_receive(build_alias(pid), task, :infinity)
+    shutdown_receive(build_alias(pid), build_monitor(pid), task, :shutdown, :infinity)
+    yield_receive(build_alias(pid), task, :infinity)
+    ignore_receive(build_alias(pid), pid, task)
+  end
+
+  ## Helpers
+
+  defp demonitor(ref) when is_reference(ref) do
+    Process.demonitor(ref, [:flush])
+    :ok
+  end
+
+  defp reason(:noconnection, proc), do: {:nodedown, monitor_node(proc)}
+  defp reason(reason, _), do: reason
+
+  defp monitor_node(pid) when is_pid(pid), do: node(pid)
+  defp monitor_node({_, node}), do: node
+
+  defp invalid_owner_error(task) do
+    "task #{inspect(task)} must be queried from the owner but was queried from #{inspect(self())}"
+  end
 end
diff --git a/lib/elixir/lib/task/supervised.ex b/lib/elixir/lib/task/supervised.ex
index 921e8432e8c..54149a45fe6 100644
--- a/lib/elixir/lib/task/supervised.ex
+++ b/lib/elixir/lib/task/supervised.ex
@@ -1,28 +1,49 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Task.Supervised do
   @moduledoc false
+  @ref_timeout 5000
+
+  def start(owner, callers, fun) do
+    {:ok, spawn(__MODULE__, :noreply, [owner, get_ancestors(), callers, fun])}
+  end
 
-  def start_link(info, fun) do
-    {:ok, :proc_lib.spawn_link(__MODULE__, :noreply, [info, fun])}
+  def start_link(owner, callers, fun) do
+    {:ok, spawn_link(__MODULE__, :noreply, [owner, get_ancestors(), callers, fun])}
   end
 
-  def start_link(caller, info, fun) do
-    :proc_lib.start_link(__MODULE__, :reply, [caller, info, fun])
+  def start_link(owner, monitor) do
+    {:ok, spawn_link(__MODULE__, :reply, [owner, get_ancestors(), monitor])}
   end
 
-  def async(caller, info, mfa) do
-    initial_call(mfa)
-    ref = receive do: ({^caller, ref} -> ref)
-    send caller, {ref, do_apply(info, mfa)}
+  def reply({_, _, owner_pid} = owner, ancestors, monitor) do
+    put_ancestors(ancestors)
+
+    case monitor do
+      :monitor ->
+        mref = Process.monitor(owner_pid)
+        reply(owner, owner_pid, mref, @ref_timeout)
+
+      :nomonitor ->
+        reply(owner, owner_pid, nil, :infinity)
+    end
   end
 
-  def reply(caller, info, mfa) do
-    initial_call(mfa)
-    :erlang.link(caller)
-    :proc_lib.init_ack({:ok, self()})
+  defp reply(owner, owner_pid, mref, timeout) do
+    receive do
+      {^owner_pid, ref, reply_to, callers, mfa} ->
+        put_initial_call(mfa)
+        put_callers(callers)
+        _ = is_reference(mref) && Process.demonitor(mref, [:flush])
+        send(reply_to, {ref, invoke_mfa(owner, mfa)})
 
-    ref =
-      # There is a race condition on this operation when working accross
-      # node that manifests if a `Task.Supervisor.async/1` call is made
+      {:DOWN, ^mref, _, _, reason} ->
+        exit({:shutdown, reason})
+    after
+      # There is a race condition on this operation when working across
+      # node that manifests if a "Task.Supervisor.async/2" call is made
       # while the supervisor is busy spawning previous tasks.
       #
       # Imagine the following workflow:
@@ -33,75 +54,634 @@ defmodule Task.Supervised do
       # 4. The calling process has not exited and so does not send its monitor reference
       # 5. The spawned task waits forever for the monitor reference so it can begin
       #
-      # We have solved this by specifying a timeout of 5000 seconds.
-      # Given no work is done in the client in between the task start and
+      # We have solved this by specifying a timeout of 5000 milliseconds.
+      # Given no work is done in the client between the task start and
       # sending the reference, 5000 should be enough to not raise false
       # negatives unless the nodes are indeed not available.
-      receive do
-        {^caller, ref} -> ref
-      after
-        5000 -> exit(:timeout)
-      end
+      #
+      # The same situation could occur with "Task.Supervisor.async_nolink/2",
+      # except a monitor is used instead of a link.
+      timeout ->
+        exit(:timeout)
+    end
+  end
+
+  def noreply(owner, ancestors, callers, mfa) do
+    put_initial_call(mfa)
+    put_ancestors(ancestors)
+    put_callers(callers)
+    invoke_mfa(owner, mfa)
+  end
+
+  defp get_ancestors() do
+    case :erlang.get(:"$ancestors") do
+      ancestors when is_list(ancestors) -> [self() | ancestors]
+      _ -> [self()]
+    end
+  end
 
-    send caller, {ref, do_apply(info, mfa)}
+  defp put_ancestors(ancestors) do
+    Process.put(:"$ancestors", ancestors)
   end
 
-  def noreply(info, mfa) do
-    initial_call(mfa)
-    do_apply(info, mfa)
+  defp put_callers(callers) do
+    Process.put(:"$callers", callers)
   end
 
-  defp initial_call(mfa) do
+  defp put_initial_call(mfa) do
     Process.put(:"$initial_call", get_initial_call(mfa))
   end
 
   defp get_initial_call({:erlang, :apply, [fun, []]}) when is_function(fun, 0) do
-    {:module, module} = :erlang.fun_info(fun, :module)
-    {:name, name} = :erlang.fun_info(fun, :name)
-    {module, name, 0}
+    :erlang.fun_info_mfa(fun)
   end
 
   defp get_initial_call({mod, fun, args}) do
     {mod, fun, length(args)}
   end
 
-  defp do_apply(info, {module, fun, args} = mfa) do
+  defp invoke_mfa(owner, {module, fun, args} = mfa) do
     try do
       apply(module, fun, args)
     catch
-      :error, value ->
-        exit(info, mfa, {value, System.stacktrace()})
-      :throw, value ->
-        exit(info, mfa, {{:nocatch, value}, System.stacktrace()})
-      :exit, value ->
-        exit(info, mfa, value)
+      :exit, value
+      when value == :normal
+      when value == :shutdown
+      when tuple_size(value) == 2 and elem(value, 0) == :shutdown ->
+        :erlang.raise(:exit, value, __STACKTRACE__)
+
+      kind, value ->
+        {fun, args} = get_running(mfa)
+
+        :logger.error(
+          %{
+            label: {Task.Supervisor, :terminating},
+            report: %{
+              name: self(),
+              starter: get_from(owner),
+              function: fun,
+              args: args,
+              reason: {log_value(kind, value), __STACKTRACE__},
+              # TODO use Process.get_label/0 when we require Erlang/OTP 27+
+              process_label: Process.get(:"$process_label", :undefined)
+            }
+          },
+          %{
+            domain: [:otp, :elixir],
+            error_logger: %{tag: :error_msg},
+            report_cb: &__MODULE__.format_report/1,
+            callers: Process.get(:"$callers")
+          }
+        )
+
+        :erlang.raise(:exit, exit_reason(kind, value, __STACKTRACE__), __STACKTRACE__)
     end
   end
 
-  defp exit(_info, _mfa, reason)
-      when reason == :normal
-      when reason == :shutdown
-      when tuple_size(reason) == 2 and elem(reason, 0) == :shutdown do
-    exit(reason)
+  defp exit_reason(:error, reason, stacktrace), do: {reason, stacktrace}
+  defp exit_reason(:exit, reason, _stacktrace), do: reason
+  defp exit_reason(:throw, reason, stacktrace), do: {{:nocatch, reason}, stacktrace}
+
+  defp log_value(:throw, value), do: {:nocatch, value}
+  defp log_value(_, value), do: value
+
+  @doc false
+  def format_report(%{
+        label: {Task.Supervisor, :terminating},
+        report: %{
+          name: name,
+          starter: starter,
+          function: fun,
+          args: args,
+          reason: reason,
+          process_label: process_label
+        }
+      }) do
+    message =
+      ~c"** Started from ~p~n" ++
+        ~c"** When function  == ~p~n" ++
+        ~c"**      arguments == ~p~n" ++ ~c"** Reason for termination == ~n" ++ ~c"** ~p~n"
+
+    terms = [starter, fun, args, get_reason(reason)]
+
+    {message, terms} =
+      case process_label do
+        :undefined -> {message, terms}
+        _ -> {~c"** Process Label == ~p~n" ++ message, [process_label | terms]}
+      end
+
+    message =
+      ~c"** Task ~p terminating~n" ++ message
+
+    {message, [name | terms]}
+  end
+
+  defp get_from({node, pid_or_name, _pid}) when node == node(), do: pid_or_name
+  defp get_from({node, name, _pid}) when is_atom(name), do: {node, name}
+  defp get_from({_node, _name, pid}), do: pid
+
+  defp get_running({:erlang, :apply, [fun, []]}) when is_function(fun, 0), do: {fun, []}
+  defp get_running({mod, fun, args}), do: {Function.capture(mod, fun, length(args)), args}
+
+  defp get_reason({:undef, [{mod, fun, args, _info} | _] = stacktrace} = reason)
+       when is_atom(mod) and is_atom(fun) do
+    cond do
+      not Code.loaded?(mod) ->
+        {:"module could not be loaded", stacktrace}
+
+      is_list(args) and not function_exported?(mod, fun, length(args)) ->
+        {:"function not exported", stacktrace}
+
+      is_integer(args) and not function_exported?(mod, fun, args) ->
+        {:"function not exported", stacktrace}
+
+      true ->
+        reason
+    end
+  end
+
+  defp get_reason(reason) do
+    reason
+  end
+
+  ## Stream
+
+  def validate_stream_options(options) do
+    max_concurrency = Keyword.get_lazy(options, :max_concurrency, &System.schedulers_online/0)
+    on_timeout = Keyword.get(options, :on_timeout, :exit)
+    timeout = Keyword.get(options, :timeout, 5000)
+    ordered = Keyword.get(options, :ordered, true)
+    zip_input_on_exit = Keyword.get(options, :zip_input_on_exit, false)
+
+    if not (is_integer(max_concurrency) and max_concurrency > 0) do
+      raise ArgumentError, ":max_concurrency must be an integer greater than zero"
+    end
+
+    if on_timeout not in [:exit, :kill_task] do
+      raise ArgumentError, ":on_timeout must be either :exit or :kill_task"
+    end
+
+    if not ((is_integer(timeout) and timeout >= 0) or timeout == :infinity) do
+      raise ArgumentError, ":timeout must be either a positive integer or :infinity"
+    end
+
+    %{
+      max_concurrency: max_concurrency,
+      on_timeout: on_timeout,
+      timeout: timeout,
+      ordered: ordered,
+      zip_input_on_exit: zip_input_on_exit
+    }
+  end
+
+  def stream(enumerable, acc, reducer, callers, mfa, options, spawn) when is_map(options) do
+    next = &Enumerable.reduce(enumerable, &1, fn x, acc -> {:suspend, [x | acc]} end)
+    parent = self()
+
+    {:trap_exit, trap_exit?} = Process.info(self(), :trap_exit)
+
+    # Start a process responsible for spawning processes and translating "down"
+    # messages. This process will trap exits if the current process is trapping
+    # exit, or it won't trap exits otherwise.
+    spawn_opts = [:link, :monitor]
+
+    {monitor_pid, monitor_ref} =
+      Process.spawn(
+        fn -> stream_monitor(parent, spawn, trap_exit?, options.timeout) end,
+        spawn_opts
+      )
+
+    # Now that we have the pid of the "monitor" process and the reference of the
+    # monitor we use to monitor such process, we can inform the monitor process
+    # about our reference to it.
+    send(monitor_pid, {parent, monitor_ref})
+
+    config =
+      Map.merge(
+        options,
+        %{
+          reducer: reducer,
+          monitor_pid: monitor_pid,
+          monitor_ref: monitor_ref,
+          callers: callers,
+          mfa: mfa
+        }
+      )
+
+    stream_reduce(
+      acc,
+      options.max_concurrency,
+      _spawned = 0,
+      _delivered = 0,
+      _waiting = %{},
+      next,
+      config
+    )
+  end
+
+  defp stream_reduce({:halt, acc}, _max, _spawned, _delivered, _waiting, next, config) do
+    stream_close(config)
+    is_function(next) && next.({:halt, []})
+    {:halted, acc}
+  end
+
+  defp stream_reduce({:suspend, acc}, max, spawned, delivered, waiting, next, config) do
+    continuation = &stream_reduce(&1, max, spawned, delivered, waiting, next, config)
+    {:suspended, acc, continuation}
+  end
+
+  # All spawned, all delivered, next is :done.
+  defp stream_reduce({:cont, acc}, _max, spawned, delivered, _waiting, next, config)
+       when spawned == delivered and next == :done do
+    stream_close(config)
+    {:done, acc}
+  end
+
+  # No more tasks to spawn because max == 0 or next is :done. We wait for task
+  # responses or tasks going down.
+  defp stream_reduce({:cont, acc}, max, spawned, delivered, waiting, next, config)
+       when max == 0
+       when next == :done do
+    %{
+      monitor_pid: monitor_pid,
+      monitor_ref: monitor_ref,
+      timeout: timeout,
+      on_timeout: on_timeout,
+      zip_input_on_exit: zip_input_on_exit?,
+      ordered: ordered?
+    } = config
+
+    receive do
+      # The task at position "position" replied with "value". We put the
+      # response in the "waiting" map and do nothing, since we'll only act on
+      # this response when the replying task dies (we'll see this in the :down
+      # message).
+      {{^monitor_ref, position}, reply} ->
+        %{^position => {pid, :running, _element}} = waiting
+        waiting = Map.put(waiting, position, {pid, {:ok, reply}})
+        stream_reduce({:cont, acc}, max, spawned, delivered, waiting, next, config)
+
+      # The task at position "position" died for some reason. We check if it
+      # replied already (then the death is peaceful) or if it's still running
+      # (then the reply from this task will be {:exit, reason}). This message is
+      # sent to us by the monitor process, not by the dying task directly.
+      {kind, {^monitor_ref, position}, reason}
+      when kind in [:down, :timed_out] ->
+        result =
+          case waiting do
+            # If the task replied, we don't care whether it went down for timeout
+            # or for normal reasons.
+            %{^position => {_, {:ok, _} = ok}} ->
+              ok
+
+            # If the task exited by itself before replying, we emit {:exit, reason}.
+            %{^position => {_, :running, element}}
+            when kind == :down ->
+              if zip_input_on_exit?, do: {:exit, {element, reason}}, else: {:exit, reason}
+
+            # If the task timed out before replying, we either exit (on_timeout: :exit)
+            # or emit {:exit, :timeout} (on_timeout: :kill_task) (note the task is already
+            # dead at this point).
+            %{^position => {_, :running, element}}
+            when kind == :timed_out ->
+              if on_timeout == :exit do
+                stream_cleanup_inbox(monitor_pid, monitor_ref)
+                exit({:timeout, {__MODULE__, :stream, [timeout]}})
+              else
+                if zip_input_on_exit?, do: {:exit, {element, :timeout}}, else: {:exit, :timeout}
+              end
+          end
+
+        if ordered? do
+          waiting = Map.put(waiting, position, {:done, result})
+          stream_deliver({:cont, acc}, max + 1, spawned, delivered, waiting, next, config)
+        else
+          pair = deliver_now(result, acc, next, config)
+          waiting = Map.delete(waiting, position)
+          stream_reduce(pair, max + 1, spawned, delivered + 1, waiting, next, config)
+        end
+
+      # The monitor process died. We just cleanup the messages from the monitor
+      # process and exit.
+      {:DOWN, ^monitor_ref, _, _, reason} ->
+        stream_cleanup_inbox(monitor_pid, monitor_ref)
+        exit({reason, {__MODULE__, :stream, [timeout]}})
+    end
+  end
+
+  defp stream_reduce({:cont, acc}, max, spawned, delivered, waiting, next, config) do
+    try do
+      next.({:cont, []})
+    catch
+      kind, reason ->
+        stream_close(config)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      {:suspended, [value], next} ->
+        waiting = stream_spawn(value, spawned, waiting, config)
+        stream_reduce({:cont, acc}, max - 1, spawned + 1, delivered, waiting, next, config)
+
+      {_, [value]} ->
+        waiting = stream_spawn(value, spawned, waiting, config)
+        stream_reduce({:cont, acc}, max - 1, spawned + 1, delivered, waiting, :done, config)
+
+      {_, []} ->
+        stream_reduce({:cont, acc}, max, spawned, delivered, waiting, :done, config)
+    end
+  end
+
+  defp deliver_now(reply, acc, next, config) do
+    %{reducer: reducer} = config
+
+    try do
+      reducer.(reply, acc)
+    catch
+      kind, reason ->
+        is_function(next) && next.({:halt, []})
+        stream_close(config)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    end
+  end
+
+  defp stream_deliver({:suspend, acc}, max, spawned, delivered, waiting, next, config) do
+    continuation = &stream_deliver(&1, max, spawned, delivered, waiting, next, config)
+    {:suspended, acc, continuation}
+  end
+
+  defp stream_deliver({:halt, acc}, max, spawned, delivered, waiting, next, config) do
+    stream_reduce({:halt, acc}, max, spawned, delivered, waiting, next, config)
+  end
+
+  defp stream_deliver({:cont, acc}, max, spawned, delivered, waiting, next, config) do
+    %{reducer: reducer} = config
+
+    case waiting do
+      %{^delivered => {:done, reply}} ->
+        try do
+          reducer.(reply, acc)
+        catch
+          kind, reason ->
+            is_function(next) && next.({:halt, []})
+            stream_close(config)
+            :erlang.raise(kind, reason, __STACKTRACE__)
+        else
+          pair ->
+            waiting = Map.delete(waiting, delivered)
+            stream_deliver(pair, max, spawned, delivered + 1, waiting, next, config)
+        end
+
+      %{} ->
+        stream_reduce({:cont, acc}, max, spawned, delivered, waiting, next, config)
+    end
   end
 
-  defp exit(info, mfa, reason) do
-    {fun, args} = get_running(mfa)
+  defp stream_close(%{monitor_pid: monitor_pid, monitor_ref: monitor_ref, timeout: timeout}) do
+    send(monitor_pid, {:stop, monitor_ref})
 
-    :error_logger.format(
-      "** Task ~p terminating~n" <>
-      "** Started from ~p~n" <>
-      "** When function  == ~p~n" <>
-      "**      arguments == ~p~n" <>
-      "** Reason for termination == ~n" <>
-      "** ~p~n", [self, get_from(info), fun, args, reason])
+    receive do
+      {:DOWN, ^monitor_ref, _, _, :normal} ->
+        stream_cleanup_inbox(monitor_pid, monitor_ref)
+        :ok
+
+      {:DOWN, ^monitor_ref, _, _, reason} ->
+        stream_cleanup_inbox(monitor_pid, monitor_ref)
+        exit({reason, {__MODULE__, :stream, [timeout]}})
+    end
+  end
+
+  defp stream_cleanup_inbox(monitor_pid, monitor_ref) do
+    receive do
+      {:EXIT, ^monitor_pid, _} -> stream_cleanup_inbox(monitor_ref)
+    after
+      0 -> stream_cleanup_inbox(monitor_ref)
+    end
+  end
+
+  defp stream_cleanup_inbox(monitor_ref) do
+    receive do
+      {{^monitor_ref, _}, _} ->
+        stream_cleanup_inbox(monitor_ref)
+
+      {kind, {^monitor_ref, _}, _} when kind in [:down, :timed_out] ->
+        stream_cleanup_inbox(monitor_ref)
+    after
+      0 ->
+        :ok
+    end
+  end
+
+  # This function spawns a task for the given "value", and puts the pid of this
+  # new task in the map of "waiting" tasks, which is returned.
+  defp stream_spawn(value, spawned, waiting, config) do
+    %{
+      monitor_pid: monitor_pid,
+      monitor_ref: monitor_ref,
+      timeout: timeout,
+      callers: callers,
+      mfa: mfa,
+      zip_input_on_exit: zip_input_on_exit?
+    } = config
+
+    send(monitor_pid, {:spawn, spawned})
+
+    receive do
+      {:spawned, {^monitor_ref, ^spawned}, pid} ->
+        mfa_with_value = normalize_mfa_with_arg(mfa, value)
+        send(pid, {self(), {monitor_ref, spawned}, self(), callers, mfa_with_value})
+        stored_value = if zip_input_on_exit?, do: value, else: nil
+        Map.put(waiting, spawned, {pid, :running, stored_value})
+
+      {:max_children, ^monitor_ref} ->
+        stream_close(config)
+
+        raise """
+        reached the maximum number of tasks for this task supervisor. The maximum number \
+        of tasks that are allowed to run at the same time under this supervisor can be \
+        configured with the :max_children option passed to Task.Supervisor.start_link/1. When \
+        using async_stream or async_stream_nolink, make sure to configure :max_concurrency to \
+        be lower or equal to :max_children and pay attention to whether other tasks are also \
+        spawned under the same task supervisor.\
+        """
+
+      {:DOWN, ^monitor_ref, _, ^monitor_pid, reason} ->
+        stream_cleanup_inbox(monitor_pid, monitor_ref)
+        exit({reason, {__MODULE__, :stream, [timeout]}})
+    end
+  end
+
+  defp stream_monitor(parent_pid, spawn, trap_exit?, timeout) do
+    Process.flag(:trap_exit, trap_exit?)
+    parent_ref = Process.monitor(parent_pid)
+
+    # Let's wait for the parent process to tell this process the monitor ref
+    # it's using to monitor this process. If the parent process dies while this
+    # process waits, this process dies with the same reason.
+    receive do
+      {^parent_pid, monitor_ref} ->
+        config = %{
+          parent_pid: parent_pid,
+          parent_ref: parent_ref,
+          spawn: spawn,
+          monitor_ref: monitor_ref,
+          timeout: timeout
+        }
+
+        stream_monitor_loop(_running_tasks = %{}, config)
+
+      {:DOWN, ^parent_ref, _, _, reason} ->
+        exit(reason)
+    end
+  end
+
+  defp stream_monitor_loop(running_tasks, config) do
+    %{
+      spawn: spawn,
+      parent_pid: parent_pid,
+      monitor_ref: monitor_ref,
+      timeout: timeout
+    } = config
+
+    receive do
+      # The parent process is telling us to spawn a new task to process
+      # "value". We spawn it and notify the parent about its pid.
+      {:spawn, position} ->
+        case spawn.() do
+          {:ok, type, pid} ->
+            ref = Process.monitor(pid)
+
+            # Schedule a timeout message to ourselves, unless the timeout was set to :infinity
+            timer_ref =
+              case timeout do
+                :infinity -> nil
+                timeout -> Process.send_after(self(), {:timeout, {monitor_ref, ref}}, timeout)
+              end
+
+            send(parent_pid, {:spawned, {monitor_ref, position}, pid})
+
+            running_tasks =
+              Map.put(running_tasks, ref, %{
+                position: position,
+                type: type,
+                pid: pid,
+                timer_ref: timer_ref,
+                timed_out?: false
+              })
+
+            stream_monitor_loop(running_tasks, config)
+
+          {:error, :max_children} ->
+            send(parent_pid, {:max_children, monitor_ref})
+            stream_waiting_for_stop_loop(running_tasks, config)
+        end
+
+      # One of the spawned processes went down. We inform the parent process of
+      # this and keep going.
+      {:DOWN, ref, _, _, reason} when is_map_key(running_tasks, ref) ->
+        {task, running_tasks} = Map.pop(running_tasks, ref)
+        %{position: position, timer_ref: timer_ref, timed_out?: timed_out?} = task
+
+        if timer_ref != nil do
+          :ok = Process.cancel_timer(timer_ref, async: true, info: false)
+        end
+
+        message_kind = if(timed_out?, do: :timed_out, else: :down)
+        send(parent_pid, {message_kind, {monitor_ref, position}, reason})
+        stream_monitor_loop(running_tasks, config)
+
+      # One of the spawned processes timed out. We kill that process here
+      # regardless of the value of :on_timeout. We then send a message to the
+      # parent process informing it that a task timed out, and the parent
+      # process decides what to do.
+      {:timeout, {^monitor_ref, ref}} ->
+        running_tasks =
+          case running_tasks do
+            %{^ref => %{pid: pid, timed_out?: false} = task_info} ->
+              unlink_and_kill(pid)
+              Map.put(running_tasks, ref, %{task_info | timed_out?: true})
+
+            _other ->
+              running_tasks
+          end
+
+        stream_monitor_loop(running_tasks, config)
+
+      {:EXIT, _, _} ->
+        stream_monitor_loop(running_tasks, config)
+
+      other ->
+        handle_stop_or_parent_down(other, running_tasks, config)
+        stream_monitor_loop(running_tasks, config)
+    end
+  end
+
+  defp stream_waiting_for_stop_loop(running_tasks, config) do
+    receive do
+      message ->
+        handle_stop_or_parent_down(message, running_tasks, config)
+        stream_waiting_for_stop_loop(running_tasks, config)
+    end
+  end
+
+  # The parent process is telling us to stop because the stream is being
+  # closed. In this case, we forcibly kill all spawned processes and then
+  # exit gracefully ourselves.
+  defp handle_stop_or_parent_down(
+         {:stop, monitor_ref},
+         running_tasks,
+         %{monitor_ref: monitor_ref}
+       ) do
+    Process.flag(:trap_exit, true)
+
+    for {_ref, %{pid: pid}} <- running_tasks, do: Process.exit(pid, :kill)
+
+    for {ref, _task} <- running_tasks do
+      receive do
+        {:DOWN, ^ref, _, _, _} -> :ok
+      end
+    end
+
+    exit(:normal)
+  end
+
+  # The parent process went down with a given reason. We kill all the
+  # spawned processes (that are also linked) with the same reason, and then
+  # exit ourselves with the same reason.
+  defp handle_stop_or_parent_down(
+         {:DOWN, parent_ref, _, _, reason},
+         running_tasks,
+         %{parent_ref: parent_ref}
+       ) do
+    for {_ref, %{type: :link, pid: pid}} <- running_tasks do
+      Process.exit(pid, reason)
+    end
 
     exit(reason)
   end
 
-  defp get_from({node, pid_or_name}) when node == node(), do: pid_or_name
-  defp get_from(other), do: other
+  # We ignore all other messages.
+  defp handle_stop_or_parent_down(_other, _running_tasks, _config) do
+    :ok
+  end
 
-  defp get_running({:erlang, :apply, [fun, []]}) when is_function(fun, 0), do: {fun, []}
-  defp get_running({mod, fun, args}), do: {:erlang.make_fun(mod, fun, length(args)), args}
+  defp unlink_and_kill(pid) do
+    caller = self()
+    ref = make_ref()
+
+    enforcer =
+      spawn(fn ->
+        mon = Process.monitor(caller)
+
+        receive do
+          {:done, ^ref} -> :ok
+          {:DOWN, ^mon, _, _, _} -> Process.exit(pid, :kill)
+        end
+      end)
+
+    Process.unlink(pid)
+    Process.exit(pid, :kill)
+    send(enforcer, {:done, ref})
+  end
+
+  defp normalize_mfa_with_arg({mod, fun, args}, arg), do: {mod, fun, [arg | args]}
+  defp normalize_mfa_with_arg(fun, arg), do: {:erlang, :apply, [fun, [arg]]}
 end
diff --git a/lib/elixir/lib/task/supervisor.ex b/lib/elixir/lib/task/supervisor.ex
index 8366ba7c3bc..0164e9b8111 100644
--- a/lib/elixir/lib/task/supervisor.ex
+++ b/lib/elixir/lib/task/supervisor.ex
@@ -1,112 +1,656 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Task.Supervisor do
   @moduledoc """
-  A tasks supervisor.
+  A task supervisor.
 
   This module defines a supervisor which can be used to dynamically
-  supervise tasks. Behind the scenes, this module is implemented as a
-  `:simple_one_for_one` supervisor where the workers are temporary
-  (i.e. they are not restarted after they die).
+  supervise tasks.
+
+  A task supervisor is started with no children, often under a
+  supervisor and a name:
+
+      children = [
+        {Task.Supervisor, name: MyApp.TaskSupervisor}
+      ]
+
+      Supervisor.start_link(children, strategy: :one_for_one)
+
+  The options given in the child specification are documented in `start_link/1`.
+
+  Once started, you can start tasks directly under the supervisor, for example:
+
+      task = Task.Supervisor.async(MyApp.TaskSupervisor, fn ->
+        :do_some_work
+      end)
+
+  See the `Task` module for more examples.
+
+  ## Scalability and partitioning
+
+  The `Task.Supervisor` is a single process responsible for starting
+  other processes. In some applications, the `Task.Supervisor` may
+  become a bottleneck. To address this, you can start multiple instances
+  of the `Task.Supervisor` and then pick a random instance to start
+  the task on.
 
-  The functions in this module allow tasks to be spawned and awaited
-  from a supervisor, similar to the functions defined in the `Task` module.
+  Instead of:
 
-  ## Name Registration
+      children = [
+        {Task.Supervisor, name: MyApp.TaskSupervisor}
+      ]
+
+  and:
+
+      Task.Supervisor.async(MyApp.TaskSupervisor, fn -> :do_some_work end)
+
+  You can do this:
+
+      children = [
+        {PartitionSupervisor,
+         child_spec: Task.Supervisor,
+         name: MyApp.TaskSupervisors}
+      ]
+
+  and then:
+
+      Task.Supervisor.async(
+        {:via, PartitionSupervisor, {MyApp.TaskSupervisors, self()}},
+        fn -> :do_some_work end
+      )
+
+  In the code above, we start a partition supervisor that will by default
+  start a dynamic supervisor for each core in your machine. Then, instead
+  of calling the `Task.Supervisor` by name, you call it through the
+  partition supervisor using the `{:via, PartitionSupervisor, {name, key}}`
+  format, where `name` is the name of the partition supervisor and `key`
+  is the routing key. We picked `self()` as the routing key, which means
+  each process will be assigned one of the existing task supervisors.
+  Read the `PartitionSupervisor` docs for more information.
+
+  ## Name registration
 
   A `Task.Supervisor` is bound to the same name registration rules as a
-  `GenServer`. Read more about it in the `GenServer` docs.
+  `GenServer`. Read more about them in the `GenServer` docs.
   """
 
+  @typedoc "Option values used by `start_link`"
+  @type option ::
+          GenServer.option()
+          | DynamicSupervisor.init_option()
+
+  @typedoc """
+  Options given to `async_stream` and `async_stream_nolink` functions.
+  """
+  @typedoc since: "1.17.0"
+  @type async_stream_option :: Task.async_stream_option() | {:shutdown, Supervisor.shutdown()}
+
+  @typedoc """
+  Options for `async/3`, `async/5`, `async_nolink/3`, and `async_nolink/5` functions.
+  """
+  @type async_opts :: [
+          shutdown: :brutal_kill | timeout()
+        ]
+
+  @type start_child_opts :: [
+          restart: :temporary | :transient | :permanent,
+          shutdown: :brutal_kill | timeout()
+        ]
+
+  @doc false
+  def child_spec(opts) when is_list(opts) do
+    id =
+      case Keyword.get(opts, :name, Task.Supervisor) do
+        name when is_atom(name) -> name
+        {:global, name} -> name
+        {:via, _module, name} -> name
+      end
+
+    %{
+      id: id,
+      start: {Task.Supervisor, :start_link, [opts]},
+      type: :supervisor
+    }
+  end
+
   @doc """
   Starts a new supervisor.
 
-  The supported options are:
+  ## Examples
+
+  A task supervisor is typically started under a supervision tree using
+  the tuple format:
+
+      {Task.Supervisor, name: MyApp.TaskSupervisor}
+
+  You can also start it by calling `start_link/1` directly:
 
-  * `:name` - used to register a supervisor name, the supported values are
-    described under the `Name Registration` section in the `GenServer` module
-    docs;
+      Task.Supervisor.start_link(name: MyApp.TaskSupervisor)
 
-  * `:shutdown` - `:brutal_kill` if the tasks must be killed directly on shutdown
-    or an integer indicating the timeout value, defaults to 5000 milliseconds;
+  But this is recommended only for scripting and should be avoided in
+  production code. Generally speaking, processes should always be started
+  inside supervision trees.
+
+  ## Options
+
+    * `:name` - used to register a supervisor name, the supported values are
+      described under the `Name Registration` section in the `GenServer` module
+      docs;
+
+    * `:max_restarts`, `:max_seconds`, and `:max_children` - as specified in
+      `DynamicSupervisor`;
+
+  This function could also receive `:restart` and `:shutdown` as options
+  but those two options have been deprecated and it is now preferred to
+  give them directly to `start_child`.
   """
-  @spec start_link(Supervisor.options) :: Supervisor.on_start
-  def start_link(opts \\ []) do
-    import Supervisor.Spec
-    {shutdown, opts} = Keyword.pop(opts, :shutdown, 5000)
-    children = [worker(Task.Supervised, [], restart: :temporary, shutdown: shutdown)]
-    Supervisor.start_link(children, [strategy: :simple_one_for_one] ++ opts)
+  @spec start_link([option]) :: Supervisor.on_start()
+  def start_link(options \\ []) do
+    {restart, options} = Keyword.pop(options, :restart)
+    {shutdown, options} = Keyword.pop(options, :shutdown)
+
+    if restart || shutdown do
+      IO.warn(
+        ":restart and :shutdown options in Task.Supervisor.start_link/1 " <>
+          "are deprecated. Please pass those options on start_child/3 instead"
+      )
+    end
+
+    keys = [:max_children, :max_seconds, :max_restarts]
+    {sup_opts, start_opts} = Keyword.split(options, keys)
+    restart_and_shutdown = {restart || :temporary, shutdown || 5000}
+    DynamicSupervisor.start_link(__MODULE__, {restart_and_shutdown, sup_opts}, start_opts)
+  end
+
+  @doc false
+  def init({{_restart, _shutdown} = arg, options}) do
+    Process.put(__MODULE__, arg)
+    DynamicSupervisor.init([strategy: :one_for_one] ++ options)
   end
 
   @doc """
   Starts a task that can be awaited on.
 
-  The `supervisor` must be a reference as defined in `Task.Supervisor`.
-  For more information on tasks, check the `Task` module.
+  The `supervisor` must be a reference as defined in `Supervisor`.
+  The task will still be linked to the caller, see `Task.async/1` for
+  more information and `async_nolink/3` for a non-linked variant.
+
+  Raises an error if `supervisor` has reached the maximum number of
+  children.
+
+  ## Options
+
+    * `:shutdown` - `:brutal_kill` if the tasks must be killed directly on shutdown
+      or an integer indicating the timeout value, defaults to 5000 milliseconds.
+      The tasks must trap exits for the timeout to have an effect.
+
+  """
+  @spec async(Supervisor.supervisor(), (-> any), async_opts) :: Task.t()
+  def async(supervisor, fun, options \\ []) do
+    async(supervisor, :erlang, :apply, [fun, []], options)
+  end
+
+  @doc """
+  Starts a task that can be awaited on.
+
+  The `supervisor` must be a reference as defined in `Supervisor`.
+  The task will still be linked to the caller, see `Task.async/1` for
+  more information and `async_nolink/3` for a non-linked variant.
+
+  Raises an error if `supervisor` has reached the maximum number of
+  children.
+
+  ## Options
+
+    * `:shutdown` - `:brutal_kill` if the tasks must be killed directly on shutdown
+      or an integer indicating the timeout value, defaults to 5000 milliseconds.
+      The tasks must trap exits for the timeout to have an effect.
+
+  """
+  @spec async(Supervisor.supervisor(), module, atom, [term], async_opts) :: Task.t()
+  def async(supervisor, module, fun, args, options \\ []) do
+    async(supervisor, :link, module, fun, args, options)
+  end
+
+  @doc """
+  Starts a task that can be awaited on.
+
+  The `supervisor` must be a reference as defined in `Supervisor`.
+  The task won't be linked to the caller, see `Task.async/1` for
+  more information.
+
+  Raises an error if `supervisor` has reached the maximum number of
+  children.
+
+  Note this function requires the task supervisor to have `:temporary`
+  as the `:restart` option (the default), as `async_nolink/3` keeps a
+  direct reference to the task which is lost if the task is restarted.
+
+  ## Options
+
+    * `:shutdown` - `:brutal_kill` if the tasks must be killed directly on shutdown
+      or an integer indicating the timeout value, defaults to 5000 milliseconds.
+      The tasks must trap exits for the timeout to have an effect.
+
+  ## Compatibility with OTP behaviours
+
+  If you create a task using `async_nolink` inside an OTP behaviour
+  like `GenServer`, you should match on the message coming from the
+  task inside your `c:GenServer.handle_info/2` callback.
+
+  The reply sent by the task will be in the format `{ref, result}`,
+  where `ref` is the monitor reference held by the task struct
+  and `result` is the return value of the task function.
+
+  Keep in mind that, regardless of how the task created with `async_nolink`
+  terminates, the caller's process will always receive a `:DOWN` message
+  with the same `ref` value that is held by the task struct. If the task
+  terminates normally, the reason in the `:DOWN` message will be `:normal`.
+
+  ## Examples
+
+  Typically, you use `async_nolink/3` when there is a reasonable expectation that
+  the task may fail, and you don't want it to take down the caller. Let's see an
+  example where a `GenServer` is meant to run a single task and track its status:
+
+      defmodule MyApp.Server do
+        use GenServer
+
+        # ...
+
+        def start_task do
+          GenServer.call(__MODULE__, :start_task)
+        end
+
+        # In this case the task is already running, so we just return :ok.
+        def handle_call(:start_task, _from, %{ref: ref} = state) when is_reference(ref) do
+          {:reply, :ok, state}
+        end
+
+        # The task is not running yet, so let's start it.
+        def handle_call(:start_task, _from, %{ref: nil} = state) do
+          task =
+            Task.Supervisor.async_nolink(MyApp.TaskSupervisor, fn ->
+              ...
+            end)
+
+          # We return :ok and the server will continue running
+          {:reply, :ok, %{state | ref: task.ref}}
+        end
+
+        # The task completed successfully
+        def handle_info({ref, answer}, %{ref: ref} = state) do
+          # We don't care about the DOWN message now, so let's demonitor and flush it
+          Process.demonitor(ref, [:flush])
+          # Do something with the result and then return
+          {:noreply, %{state | ref: nil}}
+        end
+
+        # The task failed
+        def handle_info({:DOWN, ref, :process, _pid, _reason}, %{ref: ref} = state) do
+          # Log and possibly restart the task...
+          {:noreply, %{state | ref: nil}}
+        end
+      end
+
   """
-  @spec async(Supervisor.supervisor, fun) :: Task.t
-  def async(supervisor, fun) do
-    async(supervisor, :erlang, :apply, [fun, []])
+  @spec async_nolink(Supervisor.supervisor(), (-> any), async_opts) :: Task.t()
+  def async_nolink(supervisor, fun, options \\ []) do
+    async_nolink(supervisor, :erlang, :apply, [fun, []], options)
   end
 
   @doc """
   Starts a task that can be awaited on.
 
-  The `supervisor` must be a reference as defined in `Task.Supervisor`.
-  For more information on tasks, check the `Task` module.
+  The `supervisor` must be a reference as defined in `Supervisor`.
+  The task won't be linked to the caller, see `Task.async/1` for
+  more information.
+
+  Raises an error if `supervisor` has reached the maximum number of
+  children.
+
+  Note this function requires the task supervisor to have `:temporary`
+  as the `:restart` option (the default), as `async_nolink/5` keeps a
+  direct reference to the task which is lost if the task is restarted.
   """
-  @spec async(Supervisor.supervisor, module, atom, [term]) :: Task.t
-  def async(supervisor, module, fun, args) do
-    args = [self, get_info(self), {module, fun, args}]
-    {:ok, pid} = Supervisor.start_child(supervisor, args)
-    ref = Process.monitor(pid)
-    send pid, {self(), ref}
-    %Task{pid: pid, ref: ref}
+  @spec async_nolink(Supervisor.supervisor(), module, atom, [term], async_opts) :: Task.t()
+  def async_nolink(supervisor, module, fun, args, options \\ []) do
+    async(supervisor, :nolink, module, fun, args, options)
+  end
+
+  @doc """
+  Returns a stream where the given function (`module` and `function`)
+  is mapped concurrently on each element in `enumerable`.
+
+  Each element will be prepended to the given `args` and processed by its
+  own task. The tasks will be spawned under the given `supervisor` and
+  linked to the caller process, similarly to `async/5`.
+
+  When streamed, each task will emit `{:ok, value}` upon successful
+  completion or `{:exit, reason}` if the caller is trapping exits.
+  The order of results depends on the value of the `:ordered` option.
+
+  The level of concurrency and the time tasks are allowed to run can
+  be controlled via options (see the "Options" section below).
+
+  If you find yourself trapping exits to handle exits inside
+  the async stream, consider using `async_stream_nolink/6` to start tasks
+  that are not linked to the calling process.
+
+  ## Options
+
+    * `:max_concurrency` - sets the maximum number of tasks to run
+      at the same time. Defaults to `System.schedulers_online/0`.
+
+    * `:ordered` - whether the results should be returned in the same order
+      as the input stream. This option is useful when you have large
+      streams and don't want to buffer results before they are delivered.
+      This is also useful when you're using the tasks for side effects.
+      Defaults to `true`.
+
+    * `:timeout` - the maximum amount of time to wait (in milliseconds)
+      without receiving a task reply (across all running tasks).
+      Defaults to `5000`.
+
+    * `:on_timeout` - what do to when a task times out. The possible
+      values are:
+      * `:exit` (default) - the process that spawned the tasks exits.
+      * `:kill_task` - the task that timed out is killed. The value
+        emitted for that task is `{:exit, :timeout}`.
+
+    * `:zip_input_on_exit` - (since v1.14.0) adds the original
+      input to `:exit` tuples. The value emitted for that task is
+      `{:exit, {input, reason}}`, where `input` is the collection element
+      that caused an exited during processing. Defaults to `false`.
+
+    * `:shutdown` - `:brutal_kill` if the tasks must be killed directly on shutdown
+      or an integer indicating the timeout value. Defaults to `5000` milliseconds.
+      The tasks must trap exits for the timeout to have an effect.
+
+  ## Examples
+
+  Let's build a stream and then enumerate it:
+
+      stream = Task.Supervisor.async_stream(MySupervisor, collection, Mod, :expensive_fun, [])
+      Enum.to_list(stream)
+
+  """
+  @doc since: "1.4.0"
+  @spec async_stream(
+          Supervisor.supervisor(),
+          Enumerable.t(),
+          module,
+          atom,
+          [term],
+          [async_stream_option]
+        ) :: Enumerable.t()
+  def async_stream(supervisor, enumerable, module, function, args, options \\ [])
+      when is_atom(module) and is_atom(function) and is_list(args) do
+    build_stream(supervisor, :link, enumerable, {module, function, args}, options)
+  end
+
+  @doc """
+  Returns a stream that runs the given function `fun` concurrently
+  on each element in `enumerable`.
+
+  Each element in `enumerable` is passed as argument to the given function `fun`
+  and processed by its own task. The tasks will be spawned under the given
+  `supervisor` and linked to the caller process, similarly to `async/3`.
+
+  See `async_stream/6` for discussion, options, and examples.
+  """
+  @doc since: "1.4.0"
+  @spec async_stream(
+          Supervisor.supervisor(),
+          Enumerable.t(),
+          (term -> term),
+          [async_stream_option]
+        ) :: Enumerable.t()
+  def async_stream(supervisor, enumerable, fun, options \\ []) when is_function(fun, 1) do
+    build_stream(supervisor, :link, enumerable, fun, options)
+  end
+
+  @doc """
+  Returns a stream where the given function (`module` and `function`)
+  is mapped concurrently on each element in `enumerable`.
+
+  Each element in `enumerable` will be prepended to the given `args` and processed
+  by its own task. The tasks will be spawned under the given `supervisor` and
+  will not be linked to the caller process, similarly to `async_nolink/5`.
+
+  See `async_stream/6` for discussion, options, and examples.
+  """
+  @doc since: "1.4.0"
+  @spec async_stream_nolink(
+          Supervisor.supervisor(),
+          Enumerable.t(),
+          module,
+          atom,
+          [term],
+          [async_stream_option]
+        ) :: Enumerable.t()
+  def async_stream_nolink(supervisor, enumerable, module, function, args, options \\ [])
+      when is_atom(module) and is_atom(function) and is_list(args) do
+    build_stream(supervisor, :nolink, enumerable, {module, function, args}, options)
+  end
+
+  @doc ~S"""
+  Returns a stream that runs the given `function` concurrently on each
+  element in `enumerable`.
+
+  Each element in `enumerable` is passed as argument to the given function `fun`
+  and processed by its own task. The tasks will be spawned under the given
+  `supervisor` and will not be linked to the caller process, similarly
+  to `async_nolink/3`.
+
+  See `async_stream/6` for discussion and examples.
+
+  ## Error handling and cleanup
+
+  Even if tasks are not linked to the caller, there is no risk of leaving dangling tasks
+  running after the stream halts.
+
+  Consider the following example:
+
+      Task.Supervisor.async_stream_nolink(MySupervisor, collection, fun, on_timeout: :kill_task, ordered: false)
+      |> Enum.each(fn
+        {:ok, _} -> :ok
+        {:exit, reason} -> raise "Task exited: #{Exception.format_exit(reason)}"
+      end)
+
+  If one task raises or times out:
+
+    1. the second clause gets called
+    2. an exception is raised
+    3. the stream halts
+    4. all ongoing tasks will be shut down
+
+  Here is another example:
+
+      Task.Supervisor.async_stream_nolink(MySupervisor, collection, fun, on_timeout: :kill_task, ordered: false)
+      |> Stream.filter(&match?({:ok, _}, &1))
+      |> Enum.take(3)
+
+  This will return the three first tasks to succeed, ignoring timeouts and errors, and shut down
+  every ongoing task.
+
+  Just running the stream with `Stream.run/1` on the other hand would ignore errors and process the whole stream.
+
+  """
+  @doc since: "1.4.0"
+  @spec async_stream_nolink(
+          Supervisor.supervisor(),
+          Enumerable.t(),
+          (term -> term),
+          [async_stream_option]
+        ) :: Enumerable.t()
+  def async_stream_nolink(supervisor, enumerable, fun, options \\ []) when is_function(fun, 1) do
+    build_stream(supervisor, :nolink, enumerable, fun, options)
   end
 
   @doc """
   Terminates the child with the given `pid`.
   """
-  @spec terminate_child(Supervisor.supervisor, pid) :: :ok
+  @spec terminate_child(Supervisor.supervisor(), pid) :: :ok | {:error, :not_found}
   def terminate_child(supervisor, pid) when is_pid(pid) do
-    :supervisor.terminate_child(supervisor, pid)
+    DynamicSupervisor.terminate_child(supervisor, pid)
   end
 
   @doc """
-  Returns all children pids.
+  Returns all children PIDs except those that are restarting.
+
+  Note that calling this function when supervising a large number
+  of children under low memory conditions can bring the system down due to an
+  out of memory error.
   """
-  @spec children(Supervisor.supervisor) :: [pid]
+  @spec children(Supervisor.supervisor()) :: [pid]
   def children(supervisor) do
-    :supervisor.which_children(supervisor) |> Enum.map(&elem(&1, 1))
+    for {_, pid, _, _} <- DynamicSupervisor.which_children(supervisor), is_pid(pid), do: pid
   end
 
   @doc """
-  Starts a task as child of the given `supervisor`.
+  Starts a task as a child of the given `supervisor`.
+
+      Task.Supervisor.start_child(MyTaskSupervisor, fn ->
+        IO.puts("I am running in a task")
+      end)
 
   Note that the spawned process is not linked to the caller, but
   only to the supervisor. This command is useful in case the
-  task needs to perform side-effects (like I/O) and does not need
-  to report back to the caller.
+  task needs to perform side-effects (like I/O) and you have no
+  interest in its results nor if it completes successfully.
+
+  ## Options
+
+    * `:restart` - the restart strategy, may be `:temporary` (the default),
+      `:transient` or `:permanent`. `:temporary` means the task is never
+      restarted, `:transient` means it is restarted if the exit is not
+      `:normal`, `:shutdown` or `{:shutdown, reason}`. A `:permanent` restart
+      strategy means it is always restarted.
+
+    * `:shutdown` - `:brutal_kill` if the task must be killed directly on shutdown
+      or an integer indicating the timeout value, defaults to 5000 milliseconds.
+      The task must trap exits for the timeout to have an effect.
+
   """
-  @spec start_child(Supervisor.supervisor, fun) :: {:ok, pid}
-  def start_child(supervisor, fun) do
-    start_child(supervisor, :erlang, :apply, [fun, []])
+  @spec start_child(Supervisor.supervisor(), (-> any), start_child_opts) ::
+          DynamicSupervisor.on_start_child()
+  def start_child(supervisor, fun, options \\ []) do
+    restart = options[:restart]
+    shutdown = options[:shutdown]
+    args = [get_owner(self()), get_callers(self()), {:erlang, :apply, [fun, []]}]
+    start_child_with_spec(supervisor, args, restart, shutdown)
   end
 
   @doc """
-  Starts a task as child of the given `supervisor`.
+  Starts a task as a child of the given `supervisor`.
 
-  Similar to `start_child/2` except the task is specified
+  Similar to `start_child/3` except the task is specified
   by the given `module`, `fun` and `args`.
   """
-  @spec start_child(Supervisor.supervisor, module, atom, [term]) :: {:ok, pid}
-  def start_child(supervisor, module, fun, args) do
-    Supervisor.start_child(supervisor, [get_info(self), {module, fun, args}])
+  @spec start_child(Supervisor.supervisor(), module, atom, [term], start_child_opts) ::
+          DynamicSupervisor.on_start_child()
+  def start_child(supervisor, module, fun, args, options \\ [])
+      when is_atom(fun) and is_list(args) do
+    restart = options[:restart]
+    shutdown = options[:shutdown]
+    mfa = {module, fun, args}
+    owner = get_owner(self())
+    callers = get_callers(self())
+
+    if restart == :temporary or restart == nil do
+      start_child_maybe_temporary(supervisor, owner, callers, restart, shutdown, mfa)
+    else
+      start_child_with_spec(supervisor, [owner, callers, mfa], restart, shutdown)
+    end
+  end
+
+  defp start_child_maybe_temporary(supervisor, owner, callers, restart, shutdown, mfa) do
+    case start_child_with_spec(supervisor, [owner, :monitor], restart, shutdown) do
+      # TODO: This only exists because we need to support reading restart/shutdown
+      # from two different places. Remove this, the init function and the associated
+      # clause in DynamicSupervisor on Elixir v2.0
+      {:restart, restart} ->
+        start_child_with_spec(supervisor, [owner, callers, mfa], restart, shutdown)
+
+      {:ok, pid} ->
+        # We mimic async but there is nothing to reply to
+        alias = make_ref()
+        send(pid, {self(), alias, alias, callers, mfa})
+        {:ok, pid}
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  defp start_child_with_spec(supervisor, args, restart, shutdown) do
+    GenServer.call(supervisor, {:start_task, args, restart, shutdown}, :infinity)
+  end
+
+  defp get_owner(pid) do
+    self_or_name =
+      case Process.info(pid, :registered_name) do
+        {:registered_name, name} when is_atom(name) -> name
+        _ -> pid
+      end
+
+    {node(), self_or_name, pid}
   end
 
-  defp get_info(self) do
-    {node(),
-     case Process.info(self, :registered_name) do
-       {:registered_name, []} -> self()
-       {:registered_name, name} -> name
-     end}
+  defp get_callers(owner) do
+    case :erlang.get(:"$callers") do
+      [_ | _] = list -> [owner | list]
+      _ -> [owner]
+    end
+  end
+
+  defp async(supervisor, link_type, module, fun, args, options) do
+    owner = self()
+    shutdown = options[:shutdown]
+
+    case start_child_with_spec(supervisor, [get_owner(owner), :monitor], :temporary, shutdown) do
+      {:ok, pid} ->
+        if link_type == :link, do: Process.link(pid)
+        alias = Task.__alias__(pid)
+        send(pid, {owner, alias, alias, get_callers(owner), {module, fun, args}})
+        %Task{pid: pid, ref: alias, owner: owner, mfa: {module, fun, length(args)}}
+
+      {:error, :max_children} ->
+        raise """
+        reached the maximum number of tasks for this task supervisor. The maximum number \
+        of tasks that are allowed to run at the same time under this supervisor can be \
+        configured with the :max_children option passed to Task.Supervisor.start_link/1\
+        """
+    end
+  end
+
+  defp build_stream(supervisor, link_type, enumerable, fun, options) do
+    shutdown = Keyword.get(options, :shutdown, 5000)
+
+    if not ((is_integer(shutdown) and shutdown >= 0) or shutdown == :brutal_kill) do
+      raise ArgumentError, ":shutdown must be either a positive integer or :brutal_kill"
+    end
+
+    options = Task.Supervised.validate_stream_options(options)
+
+    fn acc, acc_fun ->
+      owner = get_owner(self())
+
+      Task.Supervised.stream(enumerable, acc, acc_fun, get_callers(self()), fun, options, fn ->
+        args = [owner, :monitor]
+
+        case start_child_with_spec(supervisor, args, :temporary, shutdown) do
+          {:ok, pid} ->
+            if link_type == :link, do: Process.link(pid)
+            {:ok, link_type, pid}
+
+          {:error, :max_children} ->
+            {:error, :max_children}
+        end
+      end)
+    end
   end
 end
diff --git a/lib/elixir/lib/tuple.ex b/lib/elixir/lib/tuple.ex
index b20256aa547..f2da15d6c40 100644
--- a/lib/elixir/lib/tuple.ex
+++ b/lib/elixir/lib/tuple.ex
@@ -1,12 +1,58 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Tuple do
   @moduledoc """
   Functions for working with tuples.
+
+  Please note the following functions for tuples are found in `Kernel`:
+
+    * `elem/2` - accesses a tuple by index
+    * `put_elem/3` - inserts a value into a tuple by index
+    * `tuple_size/1` - gets the number of elements in a tuple
+
+  Tuples are intended as fixed-size containers for multiple elements.
+  To manipulate a collection of elements, use a list instead. `Enum`
+  functions do not work on tuples.
+
+  Tuples are denoted with curly braces:
+
+      iex> {}
+      {}
+      iex> {1, :two, "three"}
+      {1, :two, "three"}
+
+  A tuple may contain elements of different types, which are stored
+  contiguously in memory. Accessing any element takes constant time,
+  but modifying a tuple, which produces a shallow copy, takes linear time.
+  Tuples are good for reading data while lists are better for traversals.
+
+  Tuples are typically used either when a function has multiple return values
+  or for error handling. `File.read/1` returns `{:ok, contents}` if reading
+  the given file is successful, or else `{:error, reason}` such as when
+  the file does not exist.
+
+  The functions in this module that add and remove elements from tuples are
+  rarely used in practice, as they typically imply tuples are being used as
+  collections. To append to a tuple, it is preferable to extract the elements
+  from the old tuple with pattern matching, and then create a new tuple:
+
+      tuple = {:ok, :example}
+
+      # Avoid
+      result = Tuple.insert_at(tuple, 2, %{})
+
+      # Prefer
+      {:ok, atom} = tuple
+      result = {:ok, atom, %{}}
+
   """
 
   @doc """
   Creates a new tuple.
 
-  Creates a tuple of size `size` containing the
+  Creates a tuple of `size` containing the
   given `data` at every position.
 
   Inlined by the compiler.
@@ -18,16 +64,16 @@ defmodule Tuple do
 
   """
   @spec duplicate(term, non_neg_integer) :: tuple
-  def duplicate(data, size) do
+  def duplicate(data, size) when is_integer(size) and size >= 0 do
     :erlang.make_tuple(size, data)
   end
 
   @doc """
   Inserts an element into a tuple.
 
-  Inserts `value` into `tuple` at the given zero-based `index`.
-  Raises an `ArgumentError` if `index` is greater than the
-  length of `tuple`.
+  Inserts `value` into `tuple` at the given `index`.
+  Raises an `ArgumentError` if `index` is negative or greater than the
+  length of `tuple`. Index is zero-based.
 
   Inlined by the compiler.
 
@@ -36,19 +82,27 @@ defmodule Tuple do
       iex> tuple = {:bar, :baz}
       iex> Tuple.insert_at(tuple, 0, :foo)
       {:foo, :bar, :baz}
+      iex> Tuple.insert_at(tuple, 2, :bong)
+      {:bar, :baz, :bong}
 
   """
   @spec insert_at(tuple, non_neg_integer, term) :: tuple
-  def insert_at(tuple, index, term) do
-    :erlang.insert_element(index + 1, tuple, term)
+  def insert_at(tuple, index, value) when is_integer(index) and index >= 0 do
+    :erlang.insert_element(index + 1, tuple, value)
+  end
+
+  @doc false
+  @deprecated "Use insert_at instead"
+  def append(tuple, value) do
+    :erlang.append_element(tuple, value)
   end
 
   @doc """
   Removes an element from a tuple.
 
-  Deletes the element at the zero-based `index` from `tuple`.
-  Raises an `ArgumentError` if `index` is greater than
-  or equal to the length of `tuple`.
+  Deletes the element at the given `index` from `tuple`.
+  Raises an `ArgumentError` if `index` is negative or greater than
+  or equal to the length of `tuple`. Index is zero-based.
 
   Inlined by the compiler.
 
@@ -60,14 +114,61 @@ defmodule Tuple do
 
   """
   @spec delete_at(tuple, non_neg_integer) :: tuple
-  def delete_at(tuple, index) do
+  def delete_at(tuple, index) when is_integer(index) and index >= 0 do
     :erlang.delete_element(index + 1, tuple)
   end
 
+  @doc """
+  Computes a sum of tuple elements.
+
+  ## Examples
+
+      iex> Tuple.sum({255, 255})
+      510
+      iex> Tuple.sum({255, 0.0})
+      255.0
+      iex> Tuple.sum({})
+      0
+  """
+  @doc since: "1.12.0"
+  @spec sum(tuple) :: number()
+  def sum(tuple), do: sum(tuple, tuple_size(tuple))
+
+  defp sum(_tuple, 0), do: 0
+  defp sum(tuple, index), do: :erlang.element(index, tuple) + sum(tuple, index - 1)
+
+  @doc """
+  Computes a product of tuple elements.
+
+  ## Examples
+
+      iex> Tuple.product({255, 255})
+      65025
+      iex> Tuple.product({255, 1.0})
+      255.0
+      iex> Tuple.product({})
+      1
+  """
+  @doc since: "1.12.0"
+  @spec product(tuple) :: number()
+  def product(tuple), do: product(tuple, tuple_size(tuple))
+
+  defp product(_tuple, 0), do: 1
+  defp product(tuple, index), do: :erlang.element(index, tuple) * product(tuple, index - 1)
+
   @doc """
   Converts a tuple to a list.
 
+  Returns a new list with all the tuple elements.
+
   Inlined by the compiler.
+
+  ## Examples
+
+      iex> tuple = {:foo, :bar, :baz}
+      iex> Tuple.to_list(tuple)
+      [:foo, :bar, :baz]
+
   """
   @spec to_list(tuple) :: list
   def to_list(tuple) do
diff --git a/lib/elixir/lib/uri.ex b/lib/elixir/lib/uri.ex
index 9b918874d63..3561cc68892 100644
--- a/lib/elixir/lib/uri.ex
+++ b/lib/elixir/lib/uri.ex
@@ -1,39 +1,77 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule URI do
   @moduledoc """
-  Utilities for working with and creating URIs.
+  Utilities for working with URIs.
+
+  This module provides functions for working with URIs (for example, parsing
+  URIs or encoding query strings). The functions in this module are implemented
+  according to [RFC 3986](https://tools.ietf.org/html/rfc3986) and it also
+  provides additional functionality for handling "application/x-www-form-urlencoded"
+  segments.
+
+  Additionally, the Erlang [`:uri_string` module](`:uri_string`) provides additional
+  functionality such as RFC 3986 compliant URI normalization.
   """
 
-  defstruct scheme: nil, path: nil, query: nil,
-            fragment: nil, authority: nil,
-            userinfo: nil, host: nil, port: nil
+  @doc """
+  The URI struct.
 
-  import Bitwise
+  The fields are defined to match the following URI representation
+  (with field names between brackets):
 
-  @ports %{
-    "ftp"   => 21,
-    "http"  => 80,
-    "https" => 443,
-    "ldap"  => 389,
-    "sftp"  => 22,
-    "tftp"  => 69,
-  }
+      [scheme]://[userinfo]@[host]:[port][path]?[query]#[fragment]
 
-  Enum.each @ports, fn {scheme, port} ->
-    def normalize_scheme(unquote(scheme)), do: unquote(scheme)
-    def default_port(unquote(scheme)),     do: unquote(port)
-  end
 
-  @doc """
-  Normalizes the scheme according to the spec by downcasing it.
+  Note the `authority` field is deprecated. `parse/1` will still
+  populate it for backwards compatibility but you should generally
+  avoid setting or getting it.
   """
-  def normalize_scheme(nil),     do: nil
-  def normalize_scheme(scheme),  do: String.downcase(scheme)
+  @derive {Inspect, optional: [:authority]}
+  defstruct [:scheme, :authority, :userinfo, :host, :port, :path, :query, :fragment]
+
+  @type t :: %__MODULE__{
+          scheme: nil | binary,
+          authority: authority,
+          userinfo: nil | binary,
+          host: nil | binary,
+          port: nil | :inet.port_number(),
+          path: nil | binary,
+          query: nil | binary,
+          fragment: nil | binary
+        }
+
+  @typedoc deprecated: "The authority field is deprecated"
+  @opaque authority :: nil | binary
+
+  defmodule Error do
+    @moduledoc """
+    An exception raised when an error occurs when a `URI` is invalid.
+
+    For example, see `URI.new!/1`.
+    """
+
+    defexception [:action, :reason, :part]
+
+    @doc false
+    def message(%Error{action: action, reason: reason, part: part}) do
+      "cannot #{action} due to reason #{reason}: #{inspect(part)}"
+    end
+  end
+
+  import Bitwise
+
+  @reserved_characters ~c":/?#[]@!$&'()*+,;="
+  @formatted_reserved_characters Enum.map_join(@reserved_characters, ", ", &<<?`, &1, ?`>>)
 
   @doc """
-  Returns the default port for a given scheme.
+  Returns the default port for a given `scheme`.
 
-  If the scheme is unknown to URI, returns `nil`.
-  Any scheme may be registered via `default_port/2`.
+  If the scheme is unknown to the `URI` module, this function returns
+  `nil`. The default port for any scheme can be configured globally
+  via `default_port/2`.
 
   ## Examples
 
@@ -44,48 +82,111 @@ defmodule URI do
       nil
 
   """
+  @spec default_port(binary) :: nil | non_neg_integer
   def default_port(scheme) when is_binary(scheme) do
-    {:ok, dict} = Application.fetch_env(:elixir, :uri)
-    Map.get(dict, scheme)
+    :elixir_config.get({:uri, scheme}, nil)
   end
 
   @doc """
-  Registers a scheme with a default port.
+  Registers the default `port` for the given `scheme`.
+
+  After this function is called, `port` will be returned by
+  `default_port/1` for the given scheme `scheme`. Note that this function
+  changes the default port for the given `scheme` *globally*, meaning for
+  every application.
 
   It is recommended for this function to be invoked in your
-  application start callback in case you want to register
+  application's start callback in case you want to register
   new URIs.
   """
-  def default_port(scheme, port) when is_binary(scheme) and port > 0 do
-    {:ok, dict} = Application.fetch_env(:elixir, :uri)
-    Application.put_env(:elixir, :uri, Map.put(dict, scheme, port), persistent: true)
+  @spec default_port(binary, non_neg_integer) :: :ok
+  def default_port(scheme, port) when is_binary(scheme) and is_integer(port) and port >= 0 do
+    :elixir_config.put({:uri, scheme}, port)
   end
 
   @doc """
-  Encodes an enumerable into a query string.
+  Encodes `enumerable` into a query string using `encoding`.
 
-  Takes an enumerable (containing a sequence of two-item tuples)
-  and returns a string of the form "key1=value1&key2=value2..." where
-  keys and values are URL encoded as per `encode/1`.
+  Takes an enumerable that enumerates as a list of two-element
+  tuples (for instance, a map or a keyword list) and returns a string
+  in the form of `key1=value1&key2=value2...`.
 
   Keys and values can be any term that implements the `String.Chars`
-  protocol, except lists which are explicitly forbidden.
+  protocol with the exception of lists, which are explicitly forbidden.
+
+  You can specify one of the following `encoding` strategies:
+
+    * `:www_form` - (default, since v1.12.0) keys and values are URL encoded as
+      per `encode_www_form/1`. This is the format typically used by browsers on
+      query strings and form data. It encodes " " as "+".
+
+    * `:rfc3986` - (since v1.12.0) the same as `:www_form` except it encodes
+      " " as "%20" according [RFC 3986](https://tools.ietf.org/html/rfc3986).
+      This is the best option if you are encoding in a non-browser situation,
+      since encoding spaces as "+" can be ambiguous to URI parsers. This can
+      inadvertently lead to spaces being interpreted as literal plus signs.
+
+  Encoding defaults to `:www_form` for backward compatibility.
 
   ## Examples
 
-      iex> hd = %{"foo" => 1, "bar" => 2}
-      iex> URI.encode_query(hd)
+      iex> query = %{"foo" => 1, "bar" => 2}
+      iex> URI.encode_query(query)
       "bar=2&foo=1"
 
+      iex> query = %{"key" => "value with spaces"}
+      iex> URI.encode_query(query)
+      "key=value+with+spaces"
+
+      iex> query = %{"key" => "value with spaces"}
+      iex> URI.encode_query(query, :rfc3986)
+      "key=value%20with%20spaces"
+
+      iex> URI.encode_query(%{key: [:a, :list]})
+      ** (ArgumentError) encode_query/2 values cannot be lists, got: [:a, :list]
+
   """
-  def encode_query(l), do: Enum.map_join(l, "&", &pair/1)
+  @spec encode_query(Enumerable.t(), :rfc3986 | :www_form) :: binary
+  def encode_query(enumerable, encoding \\ :www_form) do
+    Enum.map_join(enumerable, "&", &encode_kv_pair(&1, encoding))
+  end
+
+  defp encode_kv_pair({key, _}, _encoding) when is_list(key) do
+    raise ArgumentError, "encode_query/2 keys cannot be lists, got: #{inspect(key)}"
+  end
+
+  defp encode_kv_pair({_, value}, _encoding) when is_list(value) do
+    raise ArgumentError, "encode_query/2 values cannot be lists, got: #{inspect(value)}"
+  end
+
+  defp encode_kv_pair({key, value}, :rfc3986) do
+    encode(Kernel.to_string(key), &char_unreserved?/1) <>
+      "=" <> encode(Kernel.to_string(value), &char_unreserved?/1)
+  end
+
+  defp encode_kv_pair({key, value}, :www_form) do
+    encode_www_form(Kernel.to_string(key)) <> "=" <> encode_www_form(Kernel.to_string(value))
+  end
 
   @doc """
-  Decodes a query string into a dictionary (by default uses a map).
+  Decodes `query` into a map.
+
+  Given a query string in the form of `key1=value1&key2=value2...`, this
+  function inserts each key-value pair in the query string as one entry in the
+  given `map`. Keys and values in the resulting map will be binaries. Keys and
+  values will be percent-unescaped.
+
+  You can specify one of the following `encoding` options:
+
+    * `:www_form` - (default, since v1.12.0) keys and values are decoded as per
+      `decode_www_form/1`. This is the format typically used by browsers on
+      query strings and form data. It decodes "+" as " ".
 
-  Given a query string of the form "key1=value1&key2=value2...", produces a
-  map with one entry for each key-value pair. Each key and value will be a
-  binary. Keys and values will be percent-unescaped.
+    * `:rfc3986` - (since v1.12.0) keys and values are decoded as per
+      `decode/1`. The result is the same as `:www_form` except for leaving "+"
+      as is in line with [RFC 3986](https://tools.ietf.org/html/rfc3986).
+
+  Encoding defaults to `:www_form` for backward compatibility.
 
   Use `query_decoder/1` if you want to iterate over each value manually.
 
@@ -94,107 +195,227 @@ defmodule URI do
       iex> URI.decode_query("foo=1&bar=2")
       %{"bar" => "2", "foo" => "1"}
 
+      iex> URI.decode_query("percent=oh+yes%21", %{"starting" => "map"})
+      %{"percent" => "oh yes!", "starting" => "map"}
+
+      iex> URI.decode_query("percent=oh+yes%21", %{}, :rfc3986)
+      %{"percent" => "oh+yes!"}
+
   """
-  def decode_query(q, dict \\ %{}) when is_binary(q) do
-    Enum.reduce query_decoder(q), dict, fn({k, v}, acc) -> Dict.put(acc, k, v) end
+  @spec decode_query(binary, %{optional(binary) => binary}, :rfc3986 | :www_form) :: %{
+          optional(binary) => binary
+        }
+  def decode_query(query, map \\ %{}, encoding \\ :www_form)
+
+  def decode_query(query, %_{} = dict, encoding) when is_binary(query) do
+    IO.warn(
+      "URI.decode_query/3 expects the second argument to be a map, other usage is deprecated"
+    )
+
+    decode_query_into_dict(query, dict, encoding)
+  end
+
+  def decode_query(query, map, encoding) when is_binary(query) and is_map(map) do
+    decode_query_into_map(query, map, encoding)
+  end
+
+  def decode_query(query, dict, encoding) when is_binary(query) do
+    IO.warn(
+      "URI.decode_query/3 expects the second argument to be a map, other usage is deprecated"
+    )
+
+    decode_query_into_dict(query, dict, encoding)
+  end
+
+  defp decode_query_into_map(query, map, encoding) do
+    case decode_next_query_pair(query, encoding) do
+      nil ->
+        map
+
+      {{key, value}, rest} ->
+        decode_query_into_map(rest, Map.put(map, key, value), encoding)
+    end
+  end
+
+  defp decode_query_into_dict(query, dict, encoding) do
+    case decode_next_query_pair(query, encoding) do
+      nil ->
+        dict
+
+      {{key, value}, rest} ->
+        # Avoid warnings about Dict being deprecated
+        dict_module = String.to_atom("Dict")
+        decode_query_into_dict(rest, dict_module.put(dict, key, value), encoding)
+    end
   end
 
   @doc """
-  Returns an iterator function over the query string that decodes
-  the query string in steps.
+  Returns a stream of two-element tuples representing key-value pairs in the
+  given `query`.
+
+  Key and value in each tuple will be binaries and will be percent-unescaped.
+
+  You can specify one of the following `encoding` options:
+
+    * `:www_form` - (default, since v1.12.0) keys and values are decoded as per
+      `decode_www_form/1`. This is the format typically used by browsers on
+      query strings and form data. It decodes "+" as " ".
+
+    * `:rfc3986` - (since v1.12.0) keys and values are decoded as per
+      `decode/1`. The result is the same as `:www_form` except for leaving "+"
+      as is in line with [RFC 3986](https://tools.ietf.org/html/rfc3986).
+
+  Encoding defaults to `:www_form` for backward compatibility.
 
   ## Examples
 
-      iex> URI.query_decoder("foo=1&bar=2") |> Enum.map &(&1)
+      iex> URI.query_decoder("foo=1&bar=2") |> Enum.to_list()
       [{"foo", "1"}, {"bar", "2"}]
 
+      iex> URI.query_decoder("food=bread%26butter&drinks=tap%20water+please") |> Enum.to_list()
+      [{"food", "bread&butter"}, {"drinks", "tap water please"}]
+
+      iex> URI.query_decoder("food=bread%26butter&drinks=tap%20water+please", :rfc3986) |> Enum.to_list()
+      [{"food", "bread&butter"}, {"drinks", "tap water+please"}]
+
   """
-  def query_decoder(q) when is_binary(q) do
-    Stream.unfold(q, &do_decoder/1)
+  @spec query_decoder(binary, :rfc3986 | :www_form) :: Enumerable.t()
+  def query_decoder(query, encoding \\ :www_form) when is_binary(query) do
+    Stream.unfold(query, &decode_next_query_pair(&1, encoding))
   end
 
-  defp do_decoder("") do
+  defp decode_next_query_pair("", _encoding) do
     nil
   end
 
-  defp do_decoder(q) do
-    {first, next} =
-      case :binary.split(q, "&") do
-        [first, rest] -> {first, rest}
-        [first]       -> {first, ""}
+  defp decode_next_query_pair(query, encoding) do
+    {undecoded_next_pair, rest} =
+      case :binary.split(query, "&") do
+        [next_pair, rest] -> {next_pair, rest}
+        [next_pair] -> {next_pair, ""}
       end
 
-    current =
-      case :binary.split(first, "=") do
+    next_pair =
+      case :binary.split(undecoded_next_pair, "=") do
         [key, value] ->
-          {decode_www_form(key), decode_www_form(value)}
+          {decode_with_encoding(key, encoding), decode_with_encoding(value, encoding)}
+
         [key] ->
-          {decode_www_form(key), nil}
+          {decode_with_encoding(key, encoding), ""}
       end
 
-    {current, next}
+    {next_pair, rest}
   end
 
-  defp pair({k, _}) when is_list(k) do
-    raise ArgumentError, "encode_query/1 keys cannot be lists, got: #{inspect k}"
+  defp decode_with_encoding(string, :www_form) do
+    decode_www_form(string)
   end
 
-  defp pair({_, v}) when is_list(v) do
-    raise ArgumentError, "encode_query/1 values cannot be lists, got: #{inspect v}"
+  defp decode_with_encoding(string, :rfc3986) do
+    decode(string)
   end
 
-  defp pair({k, v}) do
-    encode_www_form(to_string(k)) <>
-    "=" <> encode_www_form(to_string(v))
-  end
+  @doc ~s"""
+  Checks if `character` is a reserved one in a URI.
 
-  @doc """
-  Checks if the character is a "reserved" character in a URI.
+  As specified in [RFC 3986, section 2.2](https://tools.ietf.org/html/rfc3986#section-2.2),
+  the following characters are reserved: #{@formatted_reserved_characters}
+
+  ## Examples
+
+      iex> URI.char_reserved?(?+)
+      true
 
-  Reserved characters are specified in RFC3986, section 2.2.
   """
-  def char_reserved?(c) do
-    c in ':/?#[]@!$&\'()*+,;='
+  @spec char_reserved?(byte) :: boolean
+  def char_reserved?(character) do
+    character in @reserved_characters
   end
 
   @doc """
-  Checks if the character is a "unreserved" character in a URI.
+  Checks if `character` is an unreserved one in a URI.
+
+  As specified in [RFC 3986, section 2.3](https://tools.ietf.org/html/rfc3986#section-2.3),
+  the following characters are unreserved:
+
+    * Alphanumeric characters: `A-Z`, `a-z`, `0-9`
+    * `~`, `_`, `-`, `.`
+
+  ## Examples
+
+      iex> URI.char_unreserved?(?_)
+      true
 
-  Unreserved characters are specified in RFC3986, section 2.3.
   """
-  def char_unreserved?(c) do
-    c in ?0..?9 or
-    c in ?a..?z or
-    c in ?A..?Z or
-    c in '~_-.'
+  @spec char_unreserved?(byte) :: boolean
+  def char_unreserved?(character) do
+    character in ?0..?9 or character in ?a..?z or character in ?A..?Z or character in ~c"~_-."
   end
 
   @doc """
-  Checks if the character is allowed unescaped in a URI.
+  Checks if `character` is allowed unescaped in a URI.
 
   This is the default used by `URI.encode/2` where both
-  reserved and unreserved characters are kept unescaped.
+  [reserved](`char_reserved?/1`) and [unreserved characters](`char_unreserved?/1`)
+  are kept unescaped.
+
+  ## Examples
+
+      iex> URI.char_unescaped?(?{)
+      false
+
   """
-  def char_unescaped?(c) do
-    char_reserved?(c) or char_unreserved?(c)
+  @spec char_unescaped?(byte) :: boolean
+  def char_unescaped?(character) do
+    char_reserved?(character) or char_unreserved?(character)
   end
 
   @doc """
-  Percent-escape a URI.
-  Accepts `predicate` function as an argument to specify if char can be left as is.
+  Percent-encodes all characters that require escaping in `string`.
 
-  ## Example
+  The optional `predicate` argument specifies a function used to detect whether
+  a byte in the `string` should be escaped:
+
+    * if the function returns a truthy value, the byte should be kept as-is.
+    * if the function returns a falsy value, the byte should be escaped.
+
+  The `predicate` argument can use some built-in functions:
+
+    * `URI.char_unescaped?/1` (default) - reserved characters (such as `:`
+      and `/`) or unreserved (such as letters and numbers) are kept as-is.
+      It's typically used to encode the whole URI.
+    * `URI.char_unreserved?/1` - unreserved characters (such as letters and
+      numbers) are kept as-is. It's typically used to encode components in
+      a URI, such as query or fragment.
+    * `URI.char_reserved?/1` - Reserved characters (such as `:` and `/`) are
+      kept as-is.
+
+  And, you can also use custom functions.
+
+  See `encode_www_form/1` if you are interested in encoding `string` as
+  "x-www-form-urlencoded".
+
+  ## Examples
 
       iex> URI.encode("ftp://s-ite.tld/?value=put it+й")
       "ftp://s-ite.tld/?value=put%20it+%D0%B9"
 
+      iex> URI.encode("a string", &(&1 != ?i))
+      "a str%69ng"
+
   """
-  def encode(str, predicate \\ &char_unescaped?/1) when is_binary(str) do
-    for <<c <- str>>, into: "", do: percent(c, predicate)
+  @spec encode(binary, (byte -> as_boolean(term))) :: binary
+  def encode(string, predicate \\ &char_unescaped?/1)
+      when is_binary(string) and is_function(predicate, 1) do
+    for <<byte <- string>>, into: "", do: percent(byte, predicate)
   end
 
   @doc """
-  Encode a string as "x-www-urlencoded".
+  Encodes `string` as "x-www-form-urlencoded".
+
+  Note "x-www-form-urlencoded" is not specified as part of
+  RFC 3986. However, it is a commonly used format to encode
+  query strings and form data by browsers.
 
   ## Example
 
@@ -202,44 +423,47 @@ defmodule URI do
       "put%3A+it%2B%D0%B9"
 
   """
-  def encode_www_form(str) when is_binary(str) do
-    for <<c <- str>>, into: "" do
-      case percent(c, &char_unreserved?/1) do
+  @spec encode_www_form(binary) :: binary
+  def encode_www_form(string) when is_binary(string) do
+    for <<byte <- string>>, into: "" do
+      case percent(byte, &char_unreserved?/1) do
         "%20" -> "+"
-        pct   -> pct
+        percent -> percent
       end
     end
   end
 
-  defp percent(c, predicate) do
-    if predicate.(c) do
-      <<c>>
+  defp percent(char, predicate) do
+    if predicate.(char) do
+      <<char>>
     else
-      "%" <> hex(bsr(c, 4)) <> hex(band(c, 15))
+      <<"%", hex(bsr(char, 4)), hex(band(char, 15))>>
     end
   end
 
-  defp hex(n) when n <= 9, do: <<n + ?0>>
-  defp hex(n), do: <<n + ?A - 10>>
+  defp hex(n) when n <= 9, do: n + ?0
+  defp hex(n), do: n + ?A - 10
 
   @doc """
-  Percent-unescape a URI.
+  Percent-unescapes a URI.
 
   ## Examples
 
-      iex> URI.decode("http%3A%2F%2Felixir-lang.org")
-      "http://elixir-lang.org"
+      iex> URI.decode("https%3A%2F%2Felixir-lang.org")
+      "https://elixir-lang.org"
 
   """
+  @spec decode(binary) :: binary
   def decode(uri) do
-    unpercent(uri)
-  catch
-    :malformed_uri ->
-      raise ArgumentError, "malformed URI #{inspect uri}"
+    unpercent(uri, "", false)
   end
 
   @doc """
-  Decode a string as "x-www-urlencoded".
+  Decodes `string` as "x-www-form-urlencoded".
+
+  Note "x-www-form-urlencoded" is not specified as part of
+  RFC 3986. However, it is a commonly used format to encode
+  query strings and form data by browsers.
 
   ## Examples
 
@@ -247,116 +471,623 @@ defmodule URI do
       "<all in/"
 
   """
-  def decode_www_form(str) do
-    String.split(str, "+") |> Enum.map_join(" ", &unpercent/1)
-  catch
-    :malformed_uri ->
-      raise ArgumentError, "malformed URI #{inspect str}"
+  @spec decode_www_form(binary) :: binary
+  def decode_www_form(string) when is_binary(string) do
+    unpercent(string, "", true)
+  end
+
+  defp unpercent(<<?+, tail::binary>>, acc, spaces = true) do
+    unpercent(tail, <<acc::binary, ?\s>>, spaces)
   end
 
-  defp unpercent(<<?%, hex_1, hex_2, tail :: binary>>) do
-    <<bsl(hex_to_dec(hex_1), 4) + hex_to_dec(hex_2)>> <> unpercent(tail)
+  defp unpercent(<<?%, tail::binary>>, acc, spaces) do
+    with <<hex1, hex2, tail::binary>> <- tail,
+         dec1 when is_integer(dec1) <- hex_to_dec(hex1),
+         dec2 when is_integer(dec2) <- hex_to_dec(hex2) do
+      unpercent(tail, <<acc::binary, bsl(dec1, 4) + dec2>>, spaces)
+    else
+      _ -> unpercent(tail, <<acc::binary, ?%>>, spaces)
+    end
   end
-  defp unpercent(<<?%, _>>), do: throw(:malformed_uri)
-  defp unpercent(<<?%>>),    do: throw(:malformed_uri)
 
-  defp unpercent(<<head, tail :: binary>>) do
-    <<head>> <> unpercent(tail)
+  defp unpercent(<<head, tail::binary>>, acc, spaces) do
+    unpercent(tail, <<acc::binary, head>>, spaces)
   end
 
-  defp unpercent(<<>>), do: <<>>
+  defp unpercent(<<>>, acc, _spaces), do: acc
 
+  @compile {:inline, hex_to_dec: 1}
   defp hex_to_dec(n) when n in ?A..?F, do: n - ?A + 10
   defp hex_to_dec(n) when n in ?a..?f, do: n - ?a + 10
   defp hex_to_dec(n) when n in ?0..?9, do: n - ?0
-  defp hex_to_dec(_n), do: throw(:malformed_uri)
+  defp hex_to_dec(_n), do: nil
 
   @doc """
-  Parses a URI into components.
+  Creates a new URI struct by parsing and validating a string or from an existing URI.
 
-  URIs have portions that are handled specially for the particular
-  scheme of the URI. For example, http and https have different
-  default ports. Such values can be accessed and registered via
-  `URI.default_port/1` and `URI.default_port/2`.
+  If a `%URI{}` struct is given, it returns `{:ok, uri}` as is. If a string is
+  given, it will parse and validate it. If the string is valid, it returns
+  `{:ok, uri}`, otherwise it returns `{:error, part}` with the invalid part
+  of the URI. For parsing URIs without further validation, see `parse/1`.
 
-  ## Examples
+  This function can parse both absolute and relative URLs. You can check
+  if a URI is absolute or relative by checking if the `scheme` field is
+  `nil` or not.
+
+  When a URI is given without a port, the value returned by `URI.default_port/1`
+  for the URI's scheme is used for the `:port` field. The scheme is also
+  normalized to lowercase.
 
-      iex> URI.parse("http://elixir-lang.org/")
-      %URI{scheme: "http", path: "/", query: nil, fragment: nil,
-           authority: "elixir-lang.org", userinfo: nil,
-           host: "elixir-lang.org", port: 80}
+  ## Examples
 
+      iex> URI.new("https://elixir-lang.org/")
+      {:ok, %URI{
+        fragment: nil,
+        host: "elixir-lang.org",
+        path: "/",
+        port: 443,
+        query: nil,
+        scheme: "https",
+        userinfo: nil
+      }}
+
+      iex> URI.new("//elixir-lang.org/")
+      {:ok, %URI{
+        fragment: nil,
+        host: "elixir-lang.org",
+        path: "/",
+        port: nil,
+        query: nil,
+        scheme: nil,
+        userinfo: nil
+      }}
+
+      iex> URI.new("/foo/bar")
+      {:ok, %URI{
+        fragment: nil,
+        host: nil,
+        path: "/foo/bar",
+        port: nil,
+        query: nil,
+        scheme: nil,
+        userinfo: nil
+      }}
+
+      iex> URI.new("foo/bar")
+      {:ok, %URI{
+        fragment: nil,
+        host: nil,
+        path: "foo/bar",
+        port: nil,
+        query: nil,
+        scheme: nil,
+        userinfo: nil
+      }}
+
+      iex> URI.new("//[fe80::]/")
+      {:ok, %URI{
+        fragment: nil,
+        host: "fe80::",
+        path: "/",
+        port: nil,
+        query: nil,
+        scheme: nil,
+        userinfo: nil
+      }}
+
+      iex> URI.new("https:?query")
+      {:ok, %URI{
+        fragment: nil,
+        host: nil,
+        path: nil,
+        port: 443,
+        query: "query",
+        scheme: "https",
+        userinfo: nil
+      }}
+
+      iex> URI.new("/invalid_greater_than_in_path/>")
+      {:error, ">"}
+
+  Giving an existing URI simply returns it wrapped in a tuple:
+
+      iex> {:ok, uri} = URI.new("https://elixir-lang.org/")
+      iex> URI.new(uri)
+      {:ok, %URI{
+        fragment: nil,
+        host: "elixir-lang.org",
+        path: "/",
+        port: 443,
+        query: nil,
+        scheme: "https",
+        userinfo: nil
+      }}
   """
-  def parse(%URI{} = uri), do: uri
+  @doc since: "1.13.0"
+  @spec new(t() | String.t()) :: {:ok, t()} | {:error, String.t()}
+  def new(%URI{} = uri), do: {:ok, uri}
+
+  def new(binary) when is_binary(binary) do
+    case :uri_string.parse(binary) do
+      %{} = map -> {:ok, uri_from_map(map)}
+      {:error, :invalid_uri, term} -> {:error, Kernel.to_string(term)}
+    end
+  end
 
-  def parse(s) when is_binary(s) do
-    # From http://tools.ietf.org/html/rfc3986#appendix-B
-    regex = ~r/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/
-    parts = nillify(Regex.run(regex, s))
+  @doc """
+  Similar to `new/1` but raises `URI.Error` if an invalid string is given.
+
+  ## Examples
 
-    destructure [_, _, scheme, _, authority, path, _, query, _, fragment], parts
-    {userinfo, host, port} = split_authority(authority)
+      iex> URI.new!("https://elixir-lang.org/")
+      %URI{
+        fragment: nil,
+        host: "elixir-lang.org",
+        path: "/",
+        port: 443,
+        query: nil,
+        scheme: "https",
+        userinfo: nil
+      }
+
+      iex> URI.new!("/invalid_greater_than_in_path/>")
+      ** (URI.Error) cannot parse due to reason invalid_uri: ">"
+
+  Giving an existing URI simply returns it:
+
+      iex> uri = URI.new!("https://elixir-lang.org/")
+      iex> URI.new!(uri)
+      %URI{
+        fragment: nil,
+        host: "elixir-lang.org",
+        path: "/",
+        port: 443,
+        query: nil,
+        scheme: "https",
+        userinfo: nil
+      }
+  """
+  @doc since: "1.13.0"
+  @spec new!(t() | String.t()) :: t()
+  def new!(%URI{} = uri), do: uri
 
-    if authority do
-      authority = ""
+  def new!(binary) when is_binary(binary) do
+    case :uri_string.parse(binary) do
+      %{} = map ->
+        uri_from_map(map)
 
-      if userinfo, do: authority = authority <> userinfo <> "@"
-      if host, do: authority = authority <> host
-      if port, do: authority = authority <> ":" <> Integer.to_string(port)
+      {:error, reason, part} ->
+        raise Error, action: :parse, reason: reason, part: Kernel.to_string(part)
     end
+  end
+
+  defp uri_from_map(%{path: ""} = map), do: uri_from_map(%{map | path: nil})
 
-    scheme = normalize_scheme(scheme)
+  defp uri_from_map(map) do
+    uri = Map.merge(%URI{}, map)
 
-    if nil?(port) and not nil?(scheme) do
-      port = default_port(scheme)
+    case map do
+      %{scheme: scheme} ->
+        scheme = String.downcase(scheme, :ascii)
+
+        case map do
+          %{port: port} when is_integer(port) ->
+            %{uri | scheme: scheme}
+
+          %{} ->
+            %{uri | scheme: scheme, port: default_port(scheme)}
+        end
+
+      %{port: :undefined} ->
+        %{uri | port: nil}
+
+      %{} ->
+        uri
     end
+  end
+
+  @doc """
+  Parses a URI into its components, without further validation.
+
+  This function can parse both absolute and relative URLs. You can check
+  if a URI is absolute or relative by checking if the `scheme` field is
+  nil or not. Furthermore, this function expects both absolute and
+  relative URIs to be well-formed and does not perform any validation.
+  See the "Examples" section below. Use `new/1` if you want to validate
+  the URI fields after parsing.
+
+  When a URI is given without a port, the value returned by `URI.default_port/1`
+  for the URI's scheme is used for the `:port` field. The scheme is also
+  normalized to lowercase.
+
+  If a `%URI{}` struct is given to this function, this function returns it
+  unmodified.
+
+  > #### `:authority` field {: .info}
+  >
+  > This function sets the deprecated field `:authority` for backwards-compatibility reasons.
+
+  ## Examples
+
+      iex> URI.parse("https://elixir-lang.org/")
+      %URI{
+        authority: "elixir-lang.org",
+        fragment: nil,
+        host: "elixir-lang.org",
+        path: "/",
+        port: 443,
+        query: nil,
+        scheme: "https",
+        userinfo: nil
+      }
+
+      iex> URI.parse("//elixir-lang.org/")
+      %URI{
+        authority: "elixir-lang.org",
+        fragment: nil,
+        host: "elixir-lang.org",
+        path: "/",
+        port: nil,
+        query: nil,
+        scheme: nil,
+        userinfo: nil
+      }
+
+      iex> URI.parse("/foo/bar")
+      %URI{
+        fragment: nil,
+        host: nil,
+        path: "/foo/bar",
+        port: nil,
+        query: nil,
+        scheme: nil,
+        userinfo: nil
+      }
+
+      iex> URI.parse("foo/bar")
+      %URI{
+        fragment: nil,
+        host: nil,
+        path: "foo/bar",
+        port: nil,
+        query: nil,
+        scheme: nil,
+        userinfo: nil
+      }
+
+  In contrast to `URI.new/1`, this function will parse poorly-formed
+  URIs, for example:
+
+      iex> URI.parse("/invalid_greater_than_in_path/>")
+      %URI{
+        fragment: nil,
+        host: nil,
+        path: "/invalid_greater_than_in_path/>",
+        port: nil,
+        query: nil,
+        scheme: nil,
+        userinfo: nil
+      }
+
+  Another example is a URI with brackets in query strings. It is accepted
+  by `parse/1`, it is commonly accepted by browsers, but it will be refused
+  by `new/1`:
+
+      iex> URI.parse("/?foo[bar]=baz")
+      %URI{
+        fragment: nil,
+        host: nil,
+        path: "/",
+        port: nil,
+        query: "foo[bar]=baz",
+        scheme: nil,
+        userinfo: nil
+      }
+
+  """
+  @spec parse(t | binary) :: t
+  def parse(%URI{} = uri), do: uri
+
+  def parse(string) when is_binary(string) do
+    # From https://tools.ietf.org/html/rfc3986#appendix-B
+    # Parts:    12                        3  4          5       6  7        8 9
+    regex = ~r{^(([a-z][a-z0-9\+\-\.]*):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?}i
+
+    parts = Regex.run(regex, string)
+
+    destructure [
+                  _full,
+                  # 1
+                  _scheme_with_colon,
+                  # 2
+                  scheme,
+                  # 3
+                  authority_with_slashes,
+                  # 4
+                  _authority,
+                  # 5
+                  path,
+                  # 6
+                  query_with_question_mark,
+                  # 7
+                  _query,
+                  # 8
+                  _fragment_with_hash,
+                  # 9
+                  fragment
+                ],
+                parts
+
+    path = nilify(path)
+    scheme = nilify(scheme)
+    query = nilify_query(query_with_question_mark)
+    {authority, userinfo, host, port} = split_authority(authority_with_slashes)
+
+    scheme = scheme && String.downcase(scheme)
+    port = port || (scheme && default_port(scheme))
 
     %URI{
-      scheme: scheme, path: path, query: query,
-      fragment: fragment, authority: authority,
-      userinfo: userinfo, host: host, port: port
+      scheme: scheme,
+      path: path,
+      query: query,
+      fragment: fragment,
+      authority: authority,
+      userinfo: userinfo,
+      host: host,
+      port: port
     }
   end
 
+  defp nilify_query("?" <> query), do: query
+  defp nilify_query(_other), do: nil
+
   # Split an authority into its userinfo, host and port parts.
-  defp split_authority(s) do
-    s = s || ""
-    components = Regex.run ~r/(^(.*)@)?(\[[a-zA-Z0-9:.]*\]|[^:]*)(:(\d*))?/, s
+  #
+  # Note that the host field is returned *without* [] even if, according to
+  # RFC3986 grammar, a native IPv6 address requires them.
+  defp split_authority("") do
+    {nil, nil, nil, nil}
+  end
+
+  defp split_authority("//") do
+    {"", nil, "", nil}
+  end
 
-    destructure [_, _, userinfo, host, _, port], nillify(components)
-    port = if port, do: String.to_integer(port)
-    host = if host, do: host |> String.lstrip(?[) |> String.rstrip(?])
+  defp split_authority("//" <> authority) do
+    regex = ~r/(^(.*)@)?(\[[a-zA-Z0-9:.]*\]|[^:]*)(:(\d*))?/
+    components = Regex.run(regex, authority)
 
-    {userinfo, host, port}
+    destructure [_, _, userinfo, host, _, port], components
+    userinfo = nilify(userinfo)
+    host = if nilify(host), do: host |> String.trim_leading("[") |> String.trim_trailing("]")
+    port = if nilify(port), do: String.to_integer(port)
+
+    {authority, userinfo, host, port}
   end
 
   # Regex.run returns empty strings sometimes. We want
   # to replace those with nil for consistency.
-  defp nillify(l) do
-    for s <- l do
-      if byte_size(s) > 0, do: s, else: nil
+  defp nilify(""), do: nil
+  defp nilify(other), do: other
+
+  @doc """
+  Returns the string representation of the given [URI struct](`t:t/0`).
+
+  ## Examples
+
+      iex> uri = URI.parse("http://google.com")
+      iex> URI.to_string(uri)
+      "http://google.com"
+
+      iex> uri = URI.parse("foo://bar.baz")
+      iex> URI.to_string(uri)
+      "foo://bar.baz"
+
+  """
+  @spec to_string(t) :: binary
+  defdelegate to_string(uri), to: String.Chars.URI
+
+  @doc ~S"""
+  Merges two URIs.
+
+  This function merges two URIs as per
+  [RFC 3986, section 5.2](https://tools.ietf.org/html/rfc3986#section-5.2).
+
+  ## Examples
+
+      iex> URI.merge(URI.parse("http://google.com"), "/query") |> to_string()
+      "http://google.com/query"
+
+      iex> URI.merge("http://example.com", "http://google.com") |> to_string()
+      "http://google.com"
+
+  """
+  @spec merge(t | binary, t | binary) :: t
+  def merge(uri, rel)
+
+  def merge(%URI{scheme: nil}, _rel) do
+    raise ArgumentError, "you must merge onto an absolute URI"
+  end
+
+  def merge(_base, %URI{scheme: rel_scheme} = rel) when rel_scheme != nil do
+    %{rel | path: remove_dot_segments_from_path(rel.path)}
+  end
+
+  def merge(%URI{} = base, %URI{host: host} = rel) when host != nil do
+    %{rel | scheme: base.scheme, path: remove_dot_segments_from_path(rel.path)}
+  end
+
+  def merge(%URI{} = base, %URI{path: nil} = rel) do
+    %{base | query: rel.query || base.query, fragment: rel.fragment}
+  end
+
+  def merge(%URI{host: nil, path: nil} = base, %URI{} = rel) do
+    %{
+      base
+      | path: remove_dot_segments_from_path(rel.path),
+        query: rel.query,
+        fragment: rel.fragment
+    }
+  end
+
+  def merge(%URI{} = base, %URI{} = rel) do
+    new_path = merge_paths(base.path, rel.path)
+    %{base | path: new_path, query: rel.query, fragment: rel.fragment}
+  end
+
+  def merge(base, rel) do
+    merge(parse(base), parse(rel))
+  end
+
+  defp merge_paths(nil, rel_path), do: merge_paths("/", rel_path)
+  defp merge_paths(_, "/" <> _ = rel_path), do: remove_dot_segments_from_path(rel_path)
+
+  defp merge_paths(base_path, rel_path) do
+    (path_to_segments(base_path) ++ [:+] ++ path_to_segments(rel_path))
+    |> remove_dot_segments([])
+    |> join_reversed_segments()
+  end
+
+  defp remove_dot_segments_from_path(nil), do: nil
+
+  defp remove_dot_segments_from_path(path) do
+    path_to_segments(path)
+    |> remove_dot_segments([])
+    |> join_reversed_segments()
+  end
+
+  defp path_to_segments(path) do
+    case String.split(path, "/") do
+      ["" | tail] -> [:/ | tail]
+      segments -> segments
     end
   end
+
+  defp remove_dot_segments([], acc), do: acc
+  defp remove_dot_segments([:/ | tail], acc), do: remove_dot_segments(tail, [:/ | acc])
+  defp remove_dot_segments([_, :+ | tail], acc), do: remove_dot_segments(tail, acc)
+  defp remove_dot_segments(["."], acc), do: remove_dot_segments([], ["" | acc])
+  defp remove_dot_segments(["." | tail], acc), do: remove_dot_segments(tail, acc)
+  defp remove_dot_segments([".." | tail], [:/]), do: remove_dot_segments(tail, [:/])
+  defp remove_dot_segments([".."], [_ | acc]), do: remove_dot_segments([], ["" | acc])
+  defp remove_dot_segments([".." | tail], [_ | acc]), do: remove_dot_segments(tail, acc)
+  defp remove_dot_segments([head | tail], acc), do: remove_dot_segments(tail, [head | acc])
+
+  defp join_reversed_segments([:/]), do: "/"
+
+  defp join_reversed_segments(segments) do
+    case Enum.reverse(segments) do
+      [:/ | tail] -> ["" | tail]
+      list -> list
+    end
+    |> Enum.join("/")
+  end
+
+  @doc """
+  Appends `query` to the given `uri`.
+
+  The given `query` is not automatically encoded, use `encode/2` or `encode_www_form/1`.
+
+  ## Examples
+
+      iex> URI.append_query(URI.parse("http://example.com/"), "x=1") |> URI.to_string()
+      "http://example.com/?x=1"
+
+      iex> URI.append_query(URI.parse("http://example.com/?x=1"), "y=2") |> URI.to_string()
+      "http://example.com/?x=1&y=2"
+
+      iex> URI.append_query(URI.parse("http://example.com/?x=1"), "x=2") |> URI.to_string()
+      "http://example.com/?x=1&x=2"
+  """
+  @doc since: "1.14.0"
+  @spec append_query(t(), binary()) :: t()
+  def append_query(%URI{} = uri, query) when is_binary(query) and uri.query in [nil, ""] do
+    %{uri | query: query}
+  end
+
+  def append_query(%URI{} = uri, query) when is_binary(query) do
+    if String.ends_with?(uri.query, "&") do
+      %{uri | query: uri.query <> query}
+    else
+      %{uri | query: uri.query <> "&" <> query}
+    end
+  end
+
+  @doc """
+  Appends `path` to the given `uri`.
+
+  Path must start with `/` and cannot contain additional URL components like
+  fragments or query strings. This function further assumes the path is valid and
+  it does not contain a query string or fragment parts.
+
+  ## Examples
+
+      iex> URI.append_path(URI.parse("http://example.com/foo/?x=1"), "/my-path") |> URI.to_string()
+      "http://example.com/foo/my-path?x=1"
+
+      iex> URI.append_path(URI.parse("http://example.com"), "my-path")
+      ** (ArgumentError) path must start with "/", got: "my-path"
+
+  """
+  @doc since: "1.15.0"
+  @spec append_path(t(), String.t()) :: t()
+  def append_path(%URI{}, "//" <> _ = path) do
+    raise ArgumentError, ~s|path cannot start with "//", got: #{inspect(path)}|
+  end
+
+  def append_path(%URI{path: path} = uri, "/" <> rest = all) do
+    cond do
+      path == nil -> %{uri | path: all}
+      path != "" and :binary.last(path) == ?/ -> %{uri | path: path <> rest}
+      true -> %{uri | path: path <> all}
+    end
+  end
+
+  def append_path(%URI{}, path) when is_binary(path) do
+    raise ArgumentError, ~s|path must start with "/", got: #{inspect(path)}|
+  end
 end
 
 defimpl String.Chars, for: URI do
-  def to_string(uri) do
-    scheme = uri.scheme
+  def to_string(%{host: host, path: path} = uri)
+      when host != nil and is_binary(path) and
+             path != "" and binary_part(path, 0, 1) != "/" do
+    raise ArgumentError,
+          ":path in URI must be empty or an absolute path if URL has a :host, got: #{inspect(uri)}"
+  end
 
-    if scheme && (port = URI.default_port(scheme)) do
-      if uri.port == port, do: uri = %{uri | port: nil}
-    end
+  def to_string(%{scheme: scheme, port: port, path: path, query: query, fragment: fragment} = uri) do
+    uri =
+      case scheme && URI.default_port(scheme) do
+        ^port -> %{uri | port: nil}
+        _ -> uri
+      end
 
-    result = ""
+    # Based on https://tools.ietf.org/html/rfc3986#section-5.3
+    authority = extract_authority(uri)
 
-    if uri.scheme,   do: result = result <> uri.scheme <> "://"
-    if uri.userinfo, do: result = result <> uri.userinfo <> "@"
-    if uri.host,     do: result = result <> uri.host
-    if uri.port,     do: result = result <> ":" <> Integer.to_string(uri.port)
-    if uri.path,     do: result = result <> uri.path
-    if uri.query,    do: result = result <> "?" <> uri.query
-    if uri.fragment, do: result = result <> "#" <> uri.fragment
+    IO.iodata_to_binary([
+      if(scheme, do: [scheme, ?:], else: []),
+      if(authority, do: ["//" | authority], else: []),
+      if(path, do: path, else: []),
+      if(query, do: ["?" | query], else: []),
+      if(fragment, do: ["#" | fragment], else: [])
+    ])
+  end
+
+  defp extract_authority(%{host: nil, authority: authority}) do
+    authority
+  end
 
-    result
+  defp extract_authority(%{host: host, userinfo: userinfo, port: port}) do
+    # According to the grammar at
+    # https://tools.ietf.org/html/rfc3986#appendix-A, a "host" can have a colon
+    # in it only if it's an IPv6 or "IPvFuture" address, so if there's a colon
+    # in the host we can safely surround it with [].
+    [
+      if(userinfo, do: [userinfo | "@"], else: []),
+      if(String.contains?(host, ":"), do: ["[", host | "]"], else: host),
+      if(port, do: [":" | Integer.to_string(port)], else: [])
+    ]
   end
 end
diff --git a/lib/elixir/lib/version.ex b/lib/elixir/lib/version.ex
index 19289de4c8f..2749aed0225 100644
--- a/lib/elixir/lib/version.ex
+++ b/lib/elixir/lib/version.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Version do
   @moduledoc ~S"""
   Functions for parsing and matching versions against requirements.
@@ -5,35 +9,34 @@ defmodule Version do
   A version is a string in a specific format or a `Version`
   generated after parsing via `Version.parse/1`.
 
-  `Version` parsing and requirements follow
-  [SemVer 2.0 schema](http://semver.org/).
+  Although Elixir projects are not required to follow SemVer,
+  they must follow the format outlined on [SemVer 2.0 schema](https://semver.org/).
 
   ## Versions
 
-  In a nutshell, a version is given by three numbers:
+  In a nutshell, a version is represented by three numbers:
 
       MAJOR.MINOR.PATCH
 
-  Pre-releases are supported by appending `-[0-9A-Za-z-\.]`:
+  Pre-releases are supported by optionally appending a hyphen and a series of
+  period-separated identifiers immediately following the patch version.
+  Identifiers consist of only ASCII alphanumeric characters and hyphens (`[0-9A-Za-z-]`):
 
       "1.0.0-alpha.3"
 
-  Build information can be added by appending `+[0-9A-Za-z-\.]`:
-
-      "1.0.0-alpha.3+20130417140000"
-
-  ## Struct
+  Build information can be added by appending a plus sign and a series of
+  dot-separated identifiers immediately following the patch or pre-release version.
+  Identifiers consist of only ASCII alphanumeric characters and hyphens (`[0-9A-Za-z-]`):
 
-  The version is represented by the Version struct and it has its
-  fields named according to Semver: `:major`, `:minor`, `:patch`,
-  `:pre` and `:build`.
+      "1.0.0-alpha.3+20130417140000.amd64"
 
   ## Requirements
 
   Requirements allow you to specify which versions of a given
-  dependency you are willing to work against. It supports common
-  operators like `>=`, `<=`, `>`, `==` and friends that
-  work as one would expect:
+  dependency you are willing to work against. Requirements support the common
+  comparison operators such as `>`, `>=`, `<`, `<=`, and `==` that work as one
+  would expect, and additionally the special operator `~>` described in detail
+  further below.
 
       # Only version 2.0.0
       "== 2.0.0"
@@ -41,6 +44,11 @@ defmodule Version do
       # Anything later than 2.0.0
       "> 2.0.0"
 
+  You can skip the operator, which is equivalent to `==`:
+
+      # Only version 2.0.0
+      "2.0.0"
+
   Requirements also support `and` and `or` for complex conditions:
 
       # 2.0.0 and later until 2.1.0
@@ -51,99 +59,313 @@ defmodule Version do
 
       "~> 2.0.0"
 
+  `~>` will never include pre-release versions of its upper bound,
+  regardless of the usage of the `:allow_pre` option, or whether the operand
+  is a pre-release version. It can also be used to set an upper bound on only the major
+  version part. See the table below for `~>` requirements and
+  their corresponding translations.
+
+  `~>`           | Translation
+  :------------- | :---------------------
+  `~> 2.0.0`     | `>= 2.0.0 and < 2.1.0`
+  `~> 2.1.2`     | `>= 2.1.2 and < 2.2.0`
+  `~> 2.1.3-dev` | `>= 2.1.3-dev and < 2.2.0`
+  `~> 2.0`       | `>= 2.0.0 and < 3.0.0`
+  `~> 2.1`       | `>= 2.1.0 and < 3.0.0`
+
+  The requirement operand after the `~>` is allowed to omit the patch version,
+  allowing us to express `~> 2.1` or `~> 2.1-dev`, something that wouldn't be allowed
+  when using the common comparison operators.
+
+  When the `:allow_pre` option is set `false` in `Version.match?/3`, the requirement
+  will not match a pre-release version unless the operand is a pre-release version.
+  The default is to always allow pre-releases but note that in
+  Hex `:allow_pre` is set to `false`. See the table below for examples.
+
+  Requirement    | Version     | `:allow_pre`      | Matches
+  :------------- | :---------- | :---------------- | :------
+  `~> 2.0`       | `2.1.0`     | `true` or `false` | `true`
+  `~> 2.0`       | `3.0.0`     | `true` or `false` | `false`
+  `~> 2.0.0`     | `2.0.5`     | `true` or `false` | `true`
+  `~> 2.0.0`     | `2.1.0`     | `true` or `false` | `false`
+  `~> 2.1.2`     | `2.1.6-dev` | `true`            | `true`
+  `~> 2.1.2`     | `2.1.6-dev` | `false`           | `false`
+  `~> 2.1-dev`   | `2.2.0-dev` | `true` or `false` | `true`
+  `~> 2.1.2-dev` | `2.1.6-dev` | `true` or `false` | `true`
+  `>= 2.1.0`     | `2.2.0-dev` | `true`            | `true`
+  `>= 2.1.0`     | `2.2.0-dev` | `false`           | `false`
+  `>= 2.1.0-dev` | `2.2.6-dev` | `true` or `false` | `true`
+
   """
 
   import Kernel, except: [match?: 2]
-  defstruct [:major, :minor, :patch, :pre, :build]
 
-  @type version     :: String.t | t
-  @type requirement :: String.t | Version.Requirement.t
-  @type matchable   :: {major :: String.t | non_neg_integer,
-                        minor :: non_neg_integer | nil,
-                        patch :: non_neg_integer | nil,
-                        pre   :: [String.t]}
+  @doc """
+  The Version struct.
+
+  It contains the fields `:major`, `:minor`, `:patch`, `:pre`, and
+  `:build` according to SemVer 2.0, where `:pre` is a list.
+
+  You can read those fields but you should not create a new `Version`
+  directly via the struct syntax. Instead use the functions in this
+  module.
+  """
+  @enforce_keys [:major, :minor, :patch]
+  @derive {Inspect, optional: [:pre, :build]}
+  defstruct [:major, :minor, :patch, pre: [], build: nil]
+
+  @type version :: String.t() | t
+  @type requirement :: String.t() | Version.Requirement.t()
+  @type major :: non_neg_integer
+  @type minor :: non_neg_integer
+  @type patch :: non_neg_integer
+  @type pre :: [String.t() | non_neg_integer]
+  @type build :: String.t() | nil
+  @type t :: %__MODULE__{major: major, minor: minor, patch: patch, pre: pre, build: build}
+
+  @type match_opts :: [allow_pre: boolean()]
 
   defmodule Requirement do
-    @moduledoc false
-    defstruct [:source, :matchspec]
+    @moduledoc """
+    A struct that holds version requirement information.
+
+    The struct fields are private and should not be accessed.
+
+    See the "Requirements" section in the `Version` module
+    for more information.
+    """
+
+    defstruct [:source, :lexed]
+
+    @opaque t :: %__MODULE__{
+              source: String.t(),
+              lexed: [atom | matchable]
+            }
+
+    @typep matchable ::
+             {Version.major(), Version.minor(), Version.patch(), Version.pre(), Version.build()}
+
+    @compile inline: [compare: 2]
+
+    @doc false
+    @spec new(String.t(), [atom | matchable]) :: t
+    def new(source, lexed) do
+      %__MODULE__{source: source, lexed: lexed}
+    end
+
+    @doc false
+    @spec compile_requirement(t) :: t
+    def compile_requirement(%Requirement{} = requirement) do
+      requirement
+    end
+
+    @doc false
+    @spec match?(t, tuple) :: boolean
+    def match?(%__MODULE__{lexed: [operator, req | rest]}, version) do
+      match_lexed?(rest, version, match_op?(operator, req, version))
+    end
+
+    defp match_lexed?([:and, operator, req | rest], version, acc),
+      do: match_lexed?(rest, version, acc and match_op?(operator, req, version))
+
+    defp match_lexed?([:or, operator, req | rest], version, acc),
+      do: acc or match_lexed?(rest, version, match_op?(operator, req, version))
+
+    defp match_lexed?([], _version, acc),
+      do: acc
+
+    defp match_op?(:==, req, version) do
+      compare(version, req) == :eq
+    end
+
+    defp match_op?(:!=, req, version) do
+      compare(version, req) != :eq
+    end
+
+    defp match_op?(:~>, {major, minor, nil, req_pre, _}, {_, _, _, pre, allow_pre} = version) do
+      compare(version, {major, minor, 0, req_pre, nil}) in [:eq, :gt] and
+        compare(version, {major + 1, 0, 0, [0], nil}) == :lt and
+        (allow_pre or req_pre != [] or pre == [])
+    end
+
+    defp match_op?(:~>, {major, minor, _, req_pre, _} = req, {_, _, _, pre, allow_pre} = version) do
+      compare(version, req) in [:eq, :gt] and
+        compare(version, {major, minor + 1, 0, [0], nil}) == :lt and
+        (allow_pre or req_pre != [] or pre == [])
+    end
+
+    defp match_op?(:>, {_, _, _, req_pre, _} = req, {_, _, _, pre, allow_pre} = version) do
+      compare(version, req) == :gt and (allow_pre or req_pre != [] or pre == [])
+    end
+
+    defp match_op?(:>=, {_, _, _, req_pre, _} = req, {_, _, _, pre, allow_pre} = version) do
+      compare(version, req) in [:eq, :gt] and (allow_pre or req_pre != [] or pre == [])
+    end
+
+    defp match_op?(:<, req, version) do
+      compare(version, req) == :lt
+    end
+
+    defp match_op?(:<=, req, version) do
+      compare(version, req) in [:eq, :lt]
+    end
+
+    defp compare({major1, minor1, patch1, pre1, _}, {major2, minor2, patch2, pre2, _}) do
+      cond do
+        major1 > major2 -> :gt
+        major1 < major2 -> :lt
+        minor1 > minor2 -> :gt
+        minor1 < minor2 -> :lt
+        patch1 > patch2 -> :gt
+        patch1 < patch2 -> :lt
+        pre1 == [] and pre2 != [] -> :gt
+        pre1 != [] and pre2 == [] -> :lt
+        pre1 > pre2 -> :gt
+        pre1 < pre2 -> :lt
+        true -> :eq
+      end
+    end
   end
 
   defmodule InvalidRequirementError do
-    defexception [:message]
+    @moduledoc """
+    An exception raised when a version requirement is invalid.
+
+    For example, see `Version.parse_requirement!/1`.
+    """
+
+    defexception [:requirement]
+
+    @impl true
+    def exception(requirement) when is_binary(requirement) do
+      %__MODULE__{requirement: requirement}
+    end
+
+    @impl true
+    def message(%{requirement: requirement}) do
+      "invalid requirement: #{inspect(requirement)}"
+    end
   end
 
   defmodule InvalidVersionError do
-    defexception [:message]
+    @moduledoc """
+    An exception raised when a version is invalid.
+
+    For example, see `Version.parse!/1`.
+    """
+
+    defexception [:version]
+
+    @impl true
+    def exception(version) when is_binary(version) do
+      %__MODULE__{version: version}
+    end
+
+    @impl true
+    def message(%{version: version}) do
+      "invalid version: #{inspect(version)}"
+    end
   end
 
   @doc """
-  Check if the given version matches the specification.
+  Checks if the given version matches the specification.
 
   Returns `true` if `version` satisfies `requirement`, `false` otherwise.
   Raises a `Version.InvalidRequirementError` exception if `requirement` is not
-  parseable, or `Version.InvalidVersionError` if `version` is not parseable.
+  parsable, or a `Version.InvalidVersionError` exception if `version` is not parsable.
   If given an already parsed version and requirement this function won't
   raise.
 
+  ## Options
+
+    * `:allow_pre` (boolean) - when `false`, pre-release versions will not match
+      unless the operand is a pre-release version. Defaults to `true`.
+      For examples, please refer to the table above under the "Requirements" section.
+
   ## Examples
 
-      iex> Version.match?("2.0.0", ">1.0.0")
+      iex> Version.match?("2.0.0", "> 1.0.0")
+      true
+
+      iex> Version.match?("2.0.0", "== 1.0.0")
+      false
+
+      iex> Version.match?("2.1.6-dev", "~> 2.1.2")
       true
 
-      iex> Version.match?("2.0.0", "==1.0.0")
+      iex> Version.match?("2.1.6-dev", "~> 2.1.2", allow_pre: false)
       false
 
-      iex> Version.match?("foo", "==1.0.0")
-      ** (Version.InvalidVersionError) foo
+      iex> Version.match?("foo", "== 1.0.0")
+      ** (Version.InvalidVersionError) invalid version: "foo"
 
-      iex> Version.match?("2.0.0", "== ==1.0.0")
-      ** (Version.InvalidRequirementError) == ==1.0.0
+      iex> Version.match?("2.0.0", "== == 1.0.0")
+      ** (Version.InvalidRequirementError) invalid requirement: "== == 1.0.0"
 
   """
-  @spec match?(version, requirement) :: boolean
-  def match?(vsn, req) when is_binary(req) do
-    case parse_requirement(req) do
-      {:ok, req} ->
-        match?(vsn, req)
-      :error ->
-        raise InvalidRequirementError, message: req
-    end
+  @spec match?(version, requirement, match_opts) :: boolean
+  def match?(version, requirement, opts \\ [])
+
+  def match?(version, requirement, opts) when is_binary(requirement) do
+    match?(version, parse_requirement!(requirement), opts)
   end
 
-  def match?(version, %Requirement{matchspec: spec}) do
-    {:ok, result} = :ets.test_ms(to_matchable(version), spec)
-    result != false
+  def match?(version, requirement, opts) do
+    allow_pre = Keyword.get(opts, :allow_pre, true)
+    matchable_pattern = to_matchable(version, allow_pre)
+
+    Requirement.match?(requirement, matchable_pattern)
   end
 
   @doc """
-  Compares two versions. Returns `:gt` if first version is greater than
-  the second and `:lt` for vice versa. If the two versions are equal `:eq`
-  is returned
+  Compares two versions.
+
+  Returns `:gt` if the first version is greater than the second one, and `:lt`
+  for vice versa. If the two versions are equal, `:eq` is returned.
 
-  Raises a `Version.InvalidVersionError` exception if `version` is not parseable.
-  If given an already parsed version this function won't raise.
+  Pre-releases are strictly less than their corresponding release versions.
+
+  Patch segments are compared lexicographically if they are alphanumeric, and
+  numerically otherwise.
+
+  Build segments are ignored: if two versions differ only in their build segment
+  they are considered to be equal.
+
+  Raises a `Version.InvalidVersionError` exception if any of the two given
+  versions are not parsable. If given an already parsed version this function
+  won't raise.
 
   ## Examples
 
       iex> Version.compare("2.0.1-alpha1", "2.0.0")
       :gt
 
+      iex> Version.compare("1.0.0-beta", "1.0.0-rc1")
+      :lt
+
+      iex> Version.compare("1.0.0-10", "1.0.0-2")
+      :gt
+
       iex> Version.compare("2.0.1+build0", "2.0.1")
       :eq
 
       iex> Version.compare("invalid", "2.0.1")
-      ** (Version.InvalidVersionError) invalid
+      ** (Version.InvalidVersionError) invalid version: "invalid"
 
   """
   @spec compare(version, version) :: :gt | :eq | :lt
-  def compare(vsn1, vsn2) do
-    do_compare(to_matchable(vsn1), to_matchable(vsn2))
+  def compare(version1, version2) do
+    do_compare(to_matchable(version1, true), to_matchable(version2, true))
   end
 
-  defp do_compare({major1, minor1, patch1, pre1}, {major2, minor2, patch2, pre2}) do
+  defp do_compare({major1, minor1, patch1, pre1, _}, {major2, minor2, patch2, pre2, _}) do
     cond do
-      {major1, minor1, patch1} > {major2, minor2, patch2} -> :gt
-      {major1, minor1, patch1} < {major2, minor2, patch2} -> :lt
+      major1 > major2 -> :gt
+      major1 < major2 -> :lt
+      minor1 > minor2 -> :gt
+      minor1 < minor2 -> :lt
+      patch1 > patch2 -> :gt
+      patch1 < patch2 -> :lt
       pre1 == [] and pre2 != [] -> :gt
       pre1 != [] and pre2 == [] -> :lt
       pre1 > pre2 -> :gt
@@ -153,355 +375,318 @@ defmodule Version do
   end
 
   @doc """
-  Parse a version string into a `Version`.
+  Parses a version string into a `Version` struct.
 
   ## Examples
 
-      iex> Version.parse("2.0.1-alpha1") |> elem(1)
-      #Version<2.0.1-alpha1>
+      iex> Version.parse("2.0.1-alpha1")
+      {:ok, %Version{major: 2, minor: 0, patch: 1, pre: ["alpha1"]}}
 
       iex> Version.parse("2.0-alpha1")
       :error
 
   """
-  @spec parse(String.t) :: {:ok, t} | :error
+  @spec parse(String.t()) :: {:ok, t} | :error
   def parse(string) when is_binary(string) do
     case Version.Parser.parse_version(string) do
-      {:ok, {major, minor, patch, pre}} ->
-        vsn = %Version{major: major, minor: minor, patch: patch,
-                       pre: pre, build: get_build(string)}
-        {:ok, vsn}
-     :error ->
-       :error
+      {:ok, {major, minor, patch, pre, build_parts}} ->
+        build = if build_parts == [], do: nil, else: Enum.join(build_parts, ".")
+        version = %Version{major: major, minor: minor, patch: patch, pre: pre, build: build}
+        {:ok, version}
+
+      :error ->
+        :error
+    end
+  end
+
+  @doc """
+  Parses a version string into a `Version`.
+
+  If `string` is an invalid version, a `Version.InvalidVersionError` is raised.
+
+  ## Examples
+
+      iex> Version.parse!("2.0.1-alpha1")
+      %Version{major: 2, minor: 0, patch: 1, pre: ["alpha1"]}
+
+      iex> Version.parse!("2.0-alpha1")
+      ** (Version.InvalidVersionError) invalid version: "2.0-alpha1"
+
+  """
+  @spec parse!(String.t()) :: t
+  def parse!(string) when is_binary(string) do
+    case parse(string) do
+      {:ok, version} -> version
+      :error -> raise InvalidVersionError, string
     end
   end
 
   @doc """
-  Parse a version requirement string into a `Version.Requirement`.
+  Parses a version requirement string into a `Version.Requirement` struct.
 
   ## Examples
 
-      iex> Version.parse_requirement("== 2.0.1") |> elem(1)
-      #Version.Requirement<== 2.0.1>
+      iex> {:ok, requirement} = Version.parse_requirement("== 2.0.1")
+      iex> requirement
+      Version.parse_requirement!("== 2.0.1")
 
       iex> Version.parse_requirement("== == 2.0.1")
       :error
 
   """
-  @spec parse_requirement(String.t) :: {:ok, Requirement.t} | :error
+  @spec parse_requirement(String.t()) :: {:ok, Requirement.t()} | :error
   def parse_requirement(string) when is_binary(string) do
     case Version.Parser.parse_requirement(string) do
-      {:ok, spec} ->
-        {:ok, %Requirement{source: string, matchspec: spec}}
-      :error ->
-        :error
+      {:ok, lexed} -> {:ok, Requirement.new(string, lexed)}
+      :error -> :error
     end
   end
 
-  defp to_matchable(%Version{major: major, minor: minor, patch: patch, pre: pre}) do
-    {major, minor, patch, pre}
-  end
+  @doc """
+  Parses a version requirement string into a `Version.Requirement` struct.
 
-  defp to_matchable(string) do
-    case Version.Parser.parse_version(string) do
-      {:ok, vsn} -> vsn
-      :error -> raise InvalidVersionError, message: string
-    end
-  end
+  If `string` is an invalid requirement, a `Version.InvalidRequirementError` is raised.
 
-  defp get_build(string) do
-    case Regex.run(~r/\+([^\s]+)$/, string) do
-      nil ->
-        nil
+  ## Examples
 
-      [_, build] ->
-        build
-    end
-  end
+      iex> Version.parse_requirement!("== 2.0.1")
+      Version.parse_requirement!("== 2.0.1")
 
-  defmodule Parser.DSL do
-    @moduledoc false
+      iex> Version.parse_requirement!("== == 2.0.1")
+      ** (Version.InvalidRequirementError) invalid requirement: "== == 2.0.1"
 
-    defmacro deflexer(match, do: body) when is_binary(match) do
-      quote do
-        def lexer(unquote(match) <> rest, acc) do
-          lexer(rest, [unquote(body) | acc])
-        end
-      end
+  """
+  @doc since: "1.8.0"
+  @spec parse_requirement!(String.t()) :: Requirement.t()
+  def parse_requirement!(string) when is_binary(string) do
+    case parse_requirement(string) do
+      {:ok, requirement} -> requirement
+      :error -> raise InvalidRequirementError, string
     end
+  end
 
-    defmacro deflexer(acc, do: body) do
-      quote do
-        def lexer("", unquote(acc)) do
-          unquote(body)
-        end
-      end
-    end
+  @doc """
+  Compiles a requirement to an internal representation that may optimize matching.
 
-    defmacro deflexer(char, acc, do: body) do
-      quote do
-        def lexer(<< unquote(char) :: utf8, rest :: binary >>, unquote(acc)) do
-          unquote(char) = << unquote(char) :: utf8 >>
+  The internal representation is opaque.
+  """
+  @spec compile_requirement(Requirement.t()) :: Requirement.t()
+  defdelegate compile_requirement(requirement), to: Requirement
 
-          lexer(rest, unquote(body))
-        end
-      end
-    end
+  defp to_matchable(%Version{major: major, minor: minor, patch: patch, pre: pre}, allow_pre?) do
+    {major, minor, patch, pre, allow_pre?}
   end
 
-  defmodule Parser do
-    @moduledoc false
-    import Parser.DSL
-
-    deflexer ">=",    do: :'>='
-    deflexer "<=",    do: :'<='
-    deflexer "~>",    do: :'~>'
-    deflexer ">",     do: :'>'
-    deflexer "<",     do: :'<'
-    deflexer "==",    do: :'=='
-    deflexer "!=",    do: :'!='
-    deflexer "!",     do: :'!='
-    deflexer " or ",  do: :'||'
-    deflexer " and ", do: :'&&'
-    deflexer " ",     do: :' '
+  defp to_matchable(string, allow_pre?) do
+    case Version.Parser.parse_version(string) do
+      {:ok, {major, minor, patch, pre, _build_parts}} ->
+        {major, minor, patch, pre, allow_pre?}
 
-    deflexer x, [] do
-      [x, :'==']
+      :error ->
+        raise InvalidVersionError, string
     end
+  end
 
-    deflexer x, [h | acc] do
-      cond do
-        is_binary h ->
-          [h <> x | acc]
+  @doc """
+  Converts the given version to a string.
 
-        h in [:'||', :'&&'] ->
-          [x, :'==', h | acc]
+  ## Examples
 
-        true ->
-          [x, h | acc]
-      end
-    end
+      iex> Version.to_string(%Version{major: 1, minor: 2, patch: 3})
+      "1.2.3"
+      iex> Version.to_string(Version.parse!("1.14.0-rc.0+build0"))
+      "1.14.0-rc.0+build0"
+  """
+  @doc since: "1.14.0"
+  @spec to_string(Version.t()) :: String.t()
+  def to_string(%Version{} = version) do
+    pre = pre_to_string(version.pre)
+    build = if build = version.build, do: "+#{build}"
+    "#{version.major}.#{version.minor}.#{version.patch}#{pre}#{build}"
+  end
 
-    deflexer acc do
-      Enum.filter(Enum.reverse(acc), &(&1 != :' '))
-    end
+  defp pre_to_string([]) do
+    ""
+  end
 
-    @version_regex ~r/^
-      (\d+)                 # major
-      (?:\.(\d+))?          # minor
-      (?:\.(\d+))?          # patch
-      (?:\-([\d\w\.\-]+))?  # pre
-      (?:\+([\d\w\-]+))?    # build
-      $/x
+  defp pre_to_string(pre) do
+    "-" <>
+      Enum.map_join(pre, ".", fn
+        int when is_integer(int) -> Integer.to_string(int)
+        string when is_binary(string) -> string
+      end)
+  end
 
-    @spec parse_requirement(String.t) :: {:ok, Version.Requirement.t} | :error
-    def parse_requirement(source) do
-      lexed = lexer(source, [])
-      to_matchspec(lexed)
-    end
+  defmodule Parser do
+    @moduledoc false
 
-    defp nillify(""), do: nil
-    defp nillify(o),  do: o
+    operators = [
+      {">=", :>=},
+      {"<=", :<=},
+      {"~>", :~>},
+      {">", :>},
+      {"<", :<},
+      {"==", :==},
+      {" or ", :or},
+      {" and ", :and}
+    ]
 
-    @spec parse_version(String.t) :: {:ok, Version.matchable} | :error
-    def parse_version(string, approximate? \\ false) when is_binary(string) do
-      if parsed = Regex.run(@version_regex, string) do
-        destructure [_, major, minor, patch, pre], parsed
-        patch = nillify(patch)
-        pre   = nillify(pre)
-
-        if nil?(minor) or (nil?(patch) and not approximate?) do
-          :error
-        else
-          major = String.to_integer(major)
-          minor = String.to_integer(minor)
-          patch = patch && String.to_integer(patch)
-
-          case parse_pre(pre) do
-            {:ok, pre} ->
-              {:ok, {major, minor, patch, pre}}
-            :error ->
-              :error
-          end
-        end
-      else
-        :error
-      end
+    def lexer(string) do
+      lexer(string, "", [])
     end
 
-    defp parse_pre(nil), do: {:ok, []}
-    defp parse_pre(pre), do: parse_pre(String.split(pre, "."), [])
-
-    defp parse_pre([piece|t], acc) do
-      cond do
-        piece =~ ~r/^(0|[1-9][0-9]*)$/ ->
-          parse_pre(t, [String.to_integer(piece)|acc])
-        piece =~ ~r/^[0-9]*$/ ->
-          :error
-        true ->
-          parse_pre(t, [piece|acc])
+    for {string_op, atom_op} <- operators do
+      defp lexer(unquote(string_op) <> rest, buffer, acc) do
+        lexer(rest, "", [unquote(atom_op) | maybe_prepend_buffer(buffer, acc)])
       end
     end
 
-    defp parse_pre([], acc) do
-      {:ok, Enum.reverse(acc)}
+    defp lexer("!=" <> rest, buffer, acc) do
+      IO.warn("!= inside Version requirements is deprecated, use ~> or >= instead")
+      lexer(rest, "", [:!= | maybe_prepend_buffer(buffer, acc)])
     end
 
-    defp valid_requirement?([]), do: false
-    defp valid_requirement?([a | next]), do: valid_requirement?(a, next)
-
-    # it must finish with a version
-    defp valid_requirement?(a, []) when is_binary(a) do
-      true
+    defp lexer("!" <> rest, buffer, acc) do
+      IO.warn("! inside Version requirements is deprecated, use ~> or >= instead")
+      lexer(rest, "", [:!= | maybe_prepend_buffer(buffer, acc)])
     end
 
-    # or <op> | and <op>
-    defp valid_requirement?(a, [b | next]) when is_atom(a) and is_atom(b) and a in [:'||', :'&&'] do
-      valid_requirement?(b, next)
+    defp lexer(" " <> rest, buffer, acc) do
+      lexer(rest, "", maybe_prepend_buffer(buffer, acc))
     end
 
-    # <version> or | <version> and
-    defp valid_requirement?(a, [b | next]) when is_binary(a) and is_atom(b) and b in [:'||', :'&&'] do
-      valid_requirement?(b, next)
+    defp lexer(<<char::utf8, rest::binary>>, buffer, acc) do
+      lexer(rest, <<buffer::binary, char::utf8>>, acc)
     end
 
-    # or <version> | and <version>
-    defp valid_requirement?(a, [b | next]) when is_atom(a) and is_binary(b) and a in [:'||', :'&&'] do
-      valid_requirement?(b, next)
+    defp lexer(<<>>, buffer, acc) do
+      maybe_prepend_buffer(buffer, acc)
     end
 
-    # <op> <version>
-    defp valid_requirement?(a, [b | next]) when is_atom(a) and is_binary(b) do
-      valid_requirement?(b, next)
-    end
+    defp maybe_prepend_buffer("", acc), do: acc
 
-    defp valid_requirement?(_, _) do
-      false
-    end
+    defp maybe_prepend_buffer(buffer, [head | _] = acc)
+         when is_atom(head) and head not in [:and, :or],
+         do: [buffer | acc]
 
-    defp approximate_upper(version) do
-      case version do
-        {major, _minor, nil, _} ->
-          {major + 1, 0, 0, [0]}
+    defp maybe_prepend_buffer(buffer, acc),
+      do: [buffer, :== | acc]
 
-        {major, minor, _patch, _} ->
-          {major, minor + 1, 0, [0]}
+    defp revert_lexed([version, op, cond | rest], acc)
+         when is_binary(version) and is_atom(op) and cond in [:or, :and] do
+      with {:ok, version} <- validate_requirement(op, version) do
+        revert_lexed(rest, [cond, op, version | acc])
       end
     end
 
-    defp to_matchspec(lexed) do
-      if valid_requirement?(lexed) do
-        first = to_condition(lexed)
-        rest  = Enum.drop(lexed, 2)
-        {:ok, [{{:'$1', :'$2', :'$3', :'$4'}, [to_condition(first, rest)], [:'$_']}]}
-      else
-        :error
+    defp revert_lexed([version, op], acc) when is_binary(version) and is_atom(op) do
+      with {:ok, version} <- validate_requirement(op, version) do
+        {:ok, [op, version | acc]}
       end
-    catch
-      :invalid_matchspec -> :error
     end
 
-    defp to_condition([:'==', version | _]) do
-      version = parse_condition(version)
-      {:'==', :'$_', {:const, version}}
-    end
+    defp revert_lexed(_rest, _acc), do: :error
 
-    defp to_condition([:'!=', version | _]) do
-      version = parse_condition(version)
-      {:'/=', :'$_', {:const, version}}
+    defp validate_requirement(op, version) do
+      case parse_version(version, true) do
+        {:ok, version} when op == :~> -> {:ok, version}
+        {:ok, {_, _, patch, _, _} = version} when is_integer(patch) -> {:ok, version}
+        _ -> :error
+      end
     end
 
-    defp to_condition([:'~>', version | _]) do
-      from = parse_condition(version, true)
-      to   = approximate_upper(from)
+    @spec parse_requirement(String.t()) :: {:ok, term} | :error
+    def parse_requirement(source) do
+      revert_lexed(lexer(source), [])
+    end
 
-      {:andalso, to_condition([:'>=', matchable_to_string(from)]),
-                 to_condition([:'<', matchable_to_string(to)])}
+    def parse_version(string, approximate? \\ false) when is_binary(string) do
+      destructure [version_with_pre, build], String.split(string, "+", parts: 2)
+      destructure [version, pre], String.split(version_with_pre, "-", parts: 2)
+      destructure [major, minor, patch, next], String.split(version, ".")
+
+      with nil <- next,
+           {:ok, major} <- require_digits(major),
+           {:ok, minor} <- require_digits(minor),
+           {:ok, patch} <- maybe_patch(patch, approximate?),
+           {:ok, pre_parts} <- optional_dot_separated(pre),
+           {:ok, pre_parts} <- convert_parts_to_integer(pre_parts, []),
+           {:ok, build_parts} <- optional_dot_separated(build) do
+        {:ok, {major, minor, patch, pre_parts, build_parts}}
+      else
+        _other -> :error
+      end
     end
 
-    defp to_condition([:'>', version | _]) do
-      {major, minor, patch, pre} = parse_condition(version)
+    defp require_digits(nil), do: :error
 
-      {:orelse, {:'>', {{:'$1', :'$2', :'$3'}},
-                       {:const, {major, minor, patch}}},
-                {:andalso, {:'==', {{:'$1', :'$2', :'$3'}},
-                                        {:const, {major, minor, patch}}},
-                {:orelse, {:andalso, {:'==', {:length, :'$4'}, 0},
-                                     {:'/=', length(pre), 0}},
-                          {:andalso, {:'/=', length(pre), 0},
-                                     {:orelse, {:'>', {:length, :'$4'}, length(pre)},
-                                     {:andalso, {:'==', {:length, :'$4'}, length(pre)},
-                                                {:'>', :'$4', {:const, pre}}}}}}}}
+    defp require_digits(string) do
+      if leading_zero?(string), do: :error, else: parse_digits(string, "")
     end
 
-    defp to_condition([:'>=', version | _]) do
-      matchable = parse_condition(version)
+    defp leading_zero?(<<?0, _, _::binary>>), do: true
+    defp leading_zero?(_), do: false
 
-      {:orelse, {:'==', :'$_', {:const, matchable}},
-                to_condition([:'>', version])}
-    end
+    defp parse_digits(<<char, rest::binary>>, acc) when char in ?0..?9,
+      do: parse_digits(rest, <<acc::binary, char>>)
 
-    defp to_condition([:'<', version | _]) do
-      {major, minor, patch, pre} = parse_condition(version)
+    defp parse_digits(<<>>, acc) when byte_size(acc) > 0, do: {:ok, String.to_integer(acc)}
+    defp parse_digits(_, _acc), do: :error
 
-      {:orelse, {:'<', {{:'$1', :'$2', :'$3'}},
-                       {:const, {major, minor, patch}}},
-                {:andalso, {:'==', {{:'$1', :'$2', :'$3'}},
-                                   {:const, {major, minor, patch}}},
-                {:orelse, {:andalso, {:'/=', {:length, :'$4'}, 0},
-                                     {:'==', length(pre), 0}},
-                          {:andalso, {:'/=', {:length, :'$4'}, 0},
-                          {:orelse, {:'<', {:length, :'$4'}, length(pre)},
-                                    {:andalso, {:'==', {:length, :'$4'}, length(pre)},
-                                               {:'<', :'$4', {:const, pre}}}}}}}}
-    end
+    defp maybe_patch(patch, approximate?)
+    defp maybe_patch(nil, true), do: {:ok, nil}
+    defp maybe_patch(patch, _), do: require_digits(patch)
+
+    defp optional_dot_separated(nil), do: {:ok, []}
 
-    defp to_condition([:'<=', version | _]) do
-      matchable = parse_condition(version)
+    defp optional_dot_separated(string) do
+      parts = String.split(string, ".")
 
-      {:orelse, {:'==', :'$_', {:const, matchable}},
-                to_condition([:'<', version])}
+      if Enum.all?(parts, &(&1 != "" and valid_identifier?(&1))) do
+        {:ok, parts}
+      else
+        :error
+      end
     end
 
-    defp to_condition(current, []) do
-      current
+    defp convert_parts_to_integer([part | rest], acc) do
+      case parse_digits(part, "") do
+        {:ok, integer} ->
+          if leading_zero?(part) do
+            :error
+          else
+            convert_parts_to_integer(rest, [integer | acc])
+          end
+
+        :error ->
+          convert_parts_to_integer(rest, [part | acc])
+      end
     end
 
-    defp to_condition(current, [:'&&', operator, version | rest]) do
-      to_condition({:andalso, current, to_condition([operator, version])}, rest)
+    defp convert_parts_to_integer([], acc) do
+      {:ok, Enum.reverse(acc)}
     end
 
-    defp to_condition(current, [:'||', operator, version | rest]) do
-      to_condition({:orelse, current, to_condition([operator, version])}, rest)
+    defp valid_identifier?(<<char, rest::binary>>)
+         when char in ?0..?9
+         when char in ?a..?z
+         when char in ?A..?Z
+         when char == ?- do
+      valid_identifier?(rest)
     end
 
-    defp parse_condition(version, approximate? \\ false) do
-      case parse_version(version, approximate?) do
-        {:ok, version} -> version
-        :error -> throw :invalid_matchspec
-      end
+    defp valid_identifier?(<<>>) do
+      true
     end
 
-    defp matchable_to_string({major, minor, patch, pre}) do
-      patch = if patch, do: "#{patch}", else: "0"
-      pre   = if pre != [], do: "-#{Enum.join(pre, ".")}"
-      "#{major}.#{minor}.#{patch}#{pre}"
+    defp valid_identifier?(_other) do
+      false
     end
   end
 end
 
 defimpl String.Chars, for: Version do
-  def to_string(version) do
-    pre = unless Enum.empty?(pre = version.pre), do: "-#{pre}"
-    build = if build = version.build, do: "+#{build}"
-    "#{version.major}.#{version.minor}.#{version.patch}#{pre}#{build}"
-  end
-end
-
-defimpl Inspect, for: Version do
-  def inspect(self, _opts) do
-    "#Version<" <> to_string(self) <> ">"
-  end
+  defdelegate to_string(version), to: Version
 end
 
 defimpl String.Chars, for: Version.Requirement do
@@ -511,7 +696,9 @@ defimpl String.Chars, for: Version.Requirement do
 end
 
 defimpl Inspect, for: Version.Requirement do
-  def inspect(%Version.Requirement{source: source}, _opts) do
-    "#Version.Requirement<" <> source <> ">"
+  def inspect(%Version.Requirement{source: source}, opts) do
+    colorized = Inspect.Algebra.color_doc("\"" <> source <> "\"", :string, opts)
+
+    Inspect.Algebra.concat(["Version.parse_requirement!(", colorized, ")"])
   end
 end
diff --git a/lib/elixir/mix.exs b/lib/elixir/mix.exs
index 4b39a746602..e94a0c0140b 100644
--- a/lib/elixir/mix.exs
+++ b/lib/elixir/mix.exs
@@ -1,12 +1,15 @@
-defmodule Elixir.Mixfile do
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Elixir.MixProject do
   use Mix.Project
 
   def project do
-    [app: :elixir,
-     version: System.version,
-     build_per_environment: false,
-     escript_embed_elixir: false,
-     escript_main_module: :elixir,
-     escript_emu_args: "%%! -noshell\n"]
+    [
+      app: :elixir,
+      version: System.version(),
+      build_per_environment: false
+    ]
   end
 end
diff --git a/lib/elixir/pages/anti-patterns/code-anti-patterns.md b/lib/elixir/pages/anti-patterns/code-anti-patterns.md
new file mode 100644
index 00000000000..d4bfebc0fed
--- /dev/null
+++ b/lib/elixir/pages/anti-patterns/code-anti-patterns.md
@@ -0,0 +1,636 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Code-related anti-patterns
+
+This document outlines potential anti-patterns related to your code and particular Elixir idioms and features.
+
+## Comments overuse
+
+#### Problem
+
+When you overuse comments or comment self-explanatory code, it can have the effect of making code *less readable*.
+
+#### Example
+
+```elixir
+# Returns the Unix timestamp of 5 minutes from the current time
+defp unix_five_min_from_now do
+  # Get the current time
+  now = DateTime.utc_now()
+
+  # Convert it to a Unix timestamp
+  unix_now = DateTime.to_unix(now, :second)
+
+  # Add five minutes in seconds
+  unix_now + (60 * 5)
+end
+```
+
+#### Refactoring
+
+Prefer clear and self-explanatory function names, module names, and variable names when possible. In the example above, the function name explains well what the function does, so you likely won't need the comment before it. The code also explains the operations well through variable names and clear function calls.
+
+You could refactor the code above like this:
+
+```elixir
+@five_min_in_seconds 60 * 5
+
+defp unix_five_min_from_now do
+  now = DateTime.utc_now()
+  unix_now = DateTime.to_unix(now, :second)
+  unix_now + @five_min_in_seconds
+end
+```
+
+We removed the unnecessary comments. We also added a `@five_min_in_seconds` module attribute, which serves the additional purpose of giving a name to the "magic" number `60 * 5`, making the code clearer and more expressive.
+
+#### Additional remarks
+
+Elixir makes a clear distinction between **documentation** and code comments. The language has built-in first-class support for documentation through `@doc`, `@moduledoc`, and more. See the ["Writing documentation"](../getting-started/writing-documentation.md) guide for more information.
+
+## Complex `else` clauses in `with`
+
+#### Problem
+
+This anti-pattern refers to `with` expressions that flatten all its error clauses into a single complex `else` block. This situation is harmful to the code readability and maintainability because it's difficult to know from which clause the error value came.
+
+#### Example
+
+An example of this anti-pattern, as shown below, is a function `open_decoded_file/1` that reads a Base64-encoded string content from a file and returns a decoded binary string. This function uses a `with` expression that needs to handle two possible errors, all of which are concentrated in a single complex `else` block.
+
+```elixir
+def open_decoded_file(path) do
+  with {:ok, encoded} <- File.read(path),
+       {:ok, decoded} <- Base.decode64(encoded) do
+    {:ok, String.trim(decoded)}
+  else
+    {:error, _} -> {:error, :badfile}
+    :error -> {:error, :badencoding}
+  end
+end
+```
+
+In the code above, it is unclear how each pattern on the left side of `<-` relates to their error at the end. The more patterns in a `with`, the less clear the code gets, and the more likely it is that unrelated failures will overlap each other.
+
+#### Refactoring
+
+In this situation, instead of concentrating all error handling within a single complex `else` block, it is better to normalize the return types in specific private functions. In this way, `with` can focus on the success case and the errors are normalized closer to where they happen, leading to better organized and maintainable code.
+
+```elixir
+def open_decoded_file(path) do
+  with {:ok, encoded} <- file_read(path),
+       {:ok, decoded} <- base_decode64(encoded) do
+    {:ok, String.trim(decoded)}
+  end
+end
+
+defp file_read(path) do
+  case File.read(path) do
+    {:ok, contents} -> {:ok, contents}
+    {:error, _} -> {:error, :badfile}
+  end
+end
+
+defp base_decode64(contents) do
+  case Base.decode64(contents) do
+    {:ok, decoded} -> {:ok, decoded}
+    :error -> {:error, :badencoding}
+  end
+end
+```
+
+## Complex extractions in clauses
+
+#### Problem
+
+When we use multi-clause functions, it is possible to extract values in the clauses for further usage and for pattern matching/guard checking. This extraction itself does not represent an anti-pattern, but when you have *extractions made across several clauses and several arguments of the same function*, it becomes hard to know which extracted parts are used for pattern/guards and what is used only inside the function body. This anti-pattern is related to [Unrelated multi-clause function](design-anti-patterns.md#unrelated-multi-clause-function), but with implications of its own. It impairs the code readability in a different way.
+
+#### Example
+
+The multi-clause function `drive/1` is extracting fields of an `%User{}` struct for usage in the clause expression (`age`) and for usage in the function body (`name`):
+
+```elixir
+def drive(%User{name: name, age: age}) when age >= 18 do
+  "#{name} can drive"
+end
+
+def drive(%User{name: name, age: age}) when age < 18 do
+  "#{name} cannot drive"
+end
+```
+
+While the example above is small and does not constitute an anti-pattern, it is an example of mixed extraction and pattern matching. A situation where `drive/1` was more complex, having many more clauses, arguments, and extractions, would make it hard to know at a glance which variables are used for pattern/guards and which ones are not.
+
+#### Refactoring
+
+As shown below, a possible solution to this anti-pattern is to extract only pattern/guard related variables in the signature once you have many arguments or multiple clauses:
+
+```elixir
+def drive(%User{age: age} = user) when age >= 18 do
+  %User{name: name} = user
+  "#{name} can drive"
+end
+
+def drive(%User{age: age} = user) when age < 18 do
+  %User{name: name} = user
+  "#{name} cannot drive"
+end
+```
+
+## Dynamic atom creation
+
+#### Problem
+
+An `Atom` is an Elixir basic type whose value is its own name. Atoms are often useful to identify resources or express the state, or result, of an operation. Creating atoms dynamically is not an anti-pattern by itself. However, atoms are not garbage collected by the Erlang Virtual Machine, so values of this type live in memory during a software's entire execution lifetime. The Erlang VM limits the number of atoms that can exist in an application by default to *1 048 576*, which is more than enough to cover all atoms defined in a program, but attempts to serve as an early limit for applications which are "leaking atoms" through dynamic creation.
+
+For these reasons, creating atoms dynamically can be considered an anti-pattern when the developer has no control over how many atoms will be created during the software execution. This unpredictable scenario can expose the software to unexpected behavior caused by excessive memory usage, or even by reaching the maximum number of *atoms* possible.
+
+#### Example
+
+Picture yourself implementing code that converts string values into atoms. These strings could have been received from an external system, either as part of a request into our application, or as part of a response to your application. This dynamic and unpredictable scenario poses a security risk, as these uncontrolled conversions can potentially trigger out-of-memory errors.
+
+```elixir
+defmodule MyRequestHandler do
+  def parse(%{"status" => status, "message" => message} = _payload) do
+    %{status: String.to_atom(status), message: message}
+  end
+end
+```
+
+```elixir
+iex> MyRequestHandler.parse(%{"status" => "ok", "message" => "all good"})
+%{status: :ok, message: "all good"}
+```
+
+When we use the `String.to_atom/1` function to dynamically create an atom, it essentially gains potential access to create arbitrary atoms in our system, causing us to lose control over adhering to the limits established by the BEAM. This issue could be exploited by someone to create enough atoms to shut down a system.
+
+#### Refactoring
+
+To eliminate this anti-pattern, developers must either perform explicit conversions by mapping strings to atoms or replace the use of `String.to_atom/1` with `String.to_existing_atom/1`. An explicit conversion could be done as follows:
+
+```elixir
+defmodule MyRequestHandler do
+  def parse(%{"status" => status, "message" => message} = _payload) do
+    %{status: convert_status(status), message: message}
+  end
+
+  defp convert_status("ok"), do: :ok
+  defp convert_status("error"), do: :error
+  defp convert_status("redirect"), do: :redirect
+end
+```
+
+```elixir
+iex> MyRequestHandler.parse(%{"status" => "status_not_seen_anywhere", "message" => "all good"})
+** (FunctionClauseError) no function clause matching in MyRequestHandler.convert_status/1
+```
+
+By explicitly listing all supported statuses, you guarantee only a limited number of conversions may happen. Passing an invalid status will lead to a function clause error.
+
+An alternative is to use `String.to_existing_atom/1`, which will only convert a string to atom if the atom already exists in the system:
+
+```elixir
+defmodule MyRequestHandler do
+  def parse(%{"status" => status, "message" => message} = _payload) do
+    %{status: String.to_existing_atom(status), message: message}
+  end
+end
+```
+
+```elixir
+iex> MyRequestHandler.parse(%{"status" => "status_not_seen_anywhere", "message" => "all good"})
+** (ArgumentError) errors were found at the given arguments:
+
+  * 1st argument: not an already existing atom
+```
+
+In such cases, passing an unknown status will raise as long as the status was not defined anywhere as an atom in the system. However, assuming `status` can be either `:ok`, `:error`, or `:redirect`, how can you guarantee those atoms exist? You must ensure those atoms exist somewhere **in the same module** where `String.to_existing_atom/1` is called. For example, if you had this code:
+
+```elixir
+defmodule MyRequestHandler do
+  def parse(%{"status" => status, "message" => message} = _payload) do
+    %{status: String.to_existing_atom(status), message: message}
+  end
+
+  def handle(%{status: status}) do
+    case status do
+      :ok -> ...
+      :error -> ...
+      :redirect -> ...
+    end
+  end
+end
+```
+
+All valid statuses are defined as atoms within the same module, and that's enough. If you want to be explicit, you could also have a function that lists them:
+
+```elixir
+def valid_statuses do
+  [:ok, :error, :redirect]
+end
+```
+
+However, keep in mind using a module attribute or defining the atoms in the module body, outside of a function, are not sufficient, as the module body is only executed during compilation and it is not necessarily part of the compiled module loaded at runtime.
+
+## Long parameter list
+
+#### Problem
+
+In a functional language like Elixir, functions tend to explicitly receive all inputs and return all relevant outputs, instead of relying on mutations or side-effects. As functions grow in complexity, the amount of arguments (parameters) they need to work with may grow, to a point where the function's interface becomes confusing and prone to errors during use.
+
+#### Example
+
+In the following example, the `loan/6` functions takes too many arguments, causing its interface to be confusing and potentially leading developers to introduce errors during calls to this function.
+
+```elixir
+defmodule Library do
+  # Too many parameters that can be grouped!
+  def loan(user_name, email, password, user_alias, book_title, book_ed) do
+    ...
+  end
+end
+```
+
+#### Refactoring
+
+To address this anti-pattern, related arguments can be grouped using key-value data structures, such as maps, structs, or even keyword lists in the case of optional arguments. This effectively reduces the number of arguments and the key-value data structures adds clarity to the caller.
+
+For this particular example, the arguments to `loan/6` can be grouped into two different maps, thereby reducing its arity to `loan/2`:
+
+```elixir
+defmodule Library do
+  def loan(%{name: name, email: email, password: password, alias: alias} = user, %{title: title, ed: ed} = book) do
+    ...
+  end
+end
+```
+
+In some cases, the function with too many arguments may be a private function, which gives us more flexibility over how to separate the function arguments. One possible suggestion for such scenarios is to split the arguments in two maps (or tuples): one map keeps the data that may change, and the other keeps the data that won't change (read-only). This gives us a mechanical option to refactor the code.
+
+Other times, a function may legitimately take half a dozen or more completely unrelated arguments. This may suggest the function is trying to do too much and would be better broken into multiple functions, each responsible for a smaller piece of the overall responsibility.
+
+## Namespace trespassing
+
+#### Problem
+
+This anti-pattern manifests when a package author or a library defines modules outside of its "namespace". A library should use its name as a "prefix" for all of its modules. For example, a package named `:my_lib` should define all of its modules within the `MyLib` namespace, such as `MyLib.User`, `MyLib.SubModule`, `MyLib.Application`, and `MyLib` itself.
+
+This is important because the Erlang VM can only load one instance of a module at a time. So if there are multiple libraries that define the same module, then they are incompatible with each other due to this limitation. By always using the library name as a prefix, it avoids module name clashes due to the unique prefix.
+
+#### Example
+
+This problem commonly manifests when writing an extension of another library. For example, imagine you are writing a package that adds authentication to [Plug](https://github.com/elixir-plug/plug) called `:plug_auth`. You must avoid defining modules within the `Plug` namespace:
+
+```elixir
+defmodule Plug.Auth do
+  # ...
+end
+```
+
+Even if `Plug` does not currently define a `Plug.Auth` module, it may add such a module in the future, which would ultimately conflict with `plug_auth`'s definition.
+
+#### Refactoring
+
+Given the package is named `:plug_auth`, it must define modules inside the `PlugAuth` namespace:
+
+```elixir
+defmodule PlugAuth do
+  # ...
+end
+```
+
+#### Additional remarks
+
+There are few known exceptions to this anti-pattern:
+
+  * [Protocol implementations](`Kernel.defimpl/2`) are, by design, defined under the protocol namespace
+
+  * In some scenarios, the namespace owner may allow exceptions to this rule. For example, in Elixir itself, you defined [custom Mix tasks](`Mix.Task`) by placing them under the `Mix.Tasks` namespace, such as `Mix.Tasks.PlugAuth`
+
+  * If you are the maintainer for both `plug` and `plug_auth`, then you may allow `plug_auth` to define modules with the `Plug` namespace, such as `Plug.Auth`. However, you are responsible for avoiding or managing any conflicts that may arise in the future
+
+## Non-assertive map access
+
+#### Problem
+
+In Elixir, it is possible to access values from `Map`s, which are key-value data structures, either statically or dynamically.
+
+When a key is expected to exist in a map, it must be accessed using the `map.key` notation, making it clear to developers (and the compiler) that the key must exist. If the key does not exist, an exception is raised (and in some cases also compiler warnings). This is also known as the static notation, as the key is known at the time of writing the code.
+
+When a key is optional, the `map[:key]` notation must be used instead. This way, if the informed key does not exist, `nil` is returned. This is the dynamic notation, as it also supports dynamic key access, such as `map[some_var]`.
+
+When you use `map[:key]` to access a key that always exists in the map, you are making the code less clear for developers and for the compiler, as they now need to work with the assumption the key may not be there. This mismatch may also make it harder to track certain bugs. If the key is unexpectedly missing, you will have a `nil` value propagate through the system, instead of raising on map access.
+
+##### Table: Comparison of map access notations
+
+| Access notation | Key exists | Key doesn't exist | Use case |
+| --------------- | ---------- | ----------------- | -------- |
+| `map.key` | Returns the value | Raises `KeyError` | Structs and maps with known atom keys |
+| `map[:key]` | Returns the value | Returns `nil` | Any `Access`-based data structure, optional keys |
+
+#### Example
+
+The function `plot/1` tries to draw a graphic to represent the position of a point in a Cartesian plane. This function receives a parameter of `Map` type with the point attributes, which can be a point of a 2D or 3D Cartesian coordinate system. This function uses dynamic access to retrieve values for the map keys:
+
+```elixir
+defmodule Graphics do
+  def plot(point) do
+    # Some other code...
+    {point[:x], point[:y], point[:z]}
+  end
+end
+```
+
+```elixir
+iex> point_2d = %{x: 2, y: 3}
+%{x: 2, y: 3}
+iex> point_3d = %{x: 5, y: 6, z: 7}
+%{x: 5, y: 6, z: 7}
+iex> Graphics.plot(point_2d)
+{2, 3, nil}
+iex> Graphics.plot(point_3d)
+{5, 6, 7}
+```
+
+Given we want to plot both 2D and 3D points, the behavior above is expected. But what happens if we forget to pass a point with either `:x` or `:y`?
+
+```elixir
+iex> bad_point = %{y: 3, z: 4}
+%{y: 3, z: 4}
+iex> Graphics.plot(bad_point)
+{nil, 3, 4}
+```
+
+The behavior above is unexpected because our function should not work with points without a `:x` key. This leads to subtle bugs, as we may now pass `nil` to another function, instead of raising early on, as shown next:
+
+```iex
+iex> point_without_x = %{y: 10}
+%{y: 10}
+iex> {x, y, _} = Graphics.plot(point_without_x)
+{nil, 10, nil}
+iex> distance_from_origin = :math.sqrt(x * x + y * y)
+** (ArithmeticError) bad argument in arithmetic expression
+    :erlang.*(nil, nil)
+```
+
+The error above occurs later in the code because `nil` (from missing `:x`) is invalid for arithmetic operations, making it harder to identify the original issue.
+
+#### Refactoring
+
+To remove this anti-pattern, we must use the dynamic `map[:key]` syntax and the static `map.key` notation according to our requirements. We expect `:x` and `:y` to always exist, but not `:z`. The next code illustrates the refactoring of `plot/1`, removing this anti-pattern:
+
+```elixir
+defmodule Graphics do
+  def plot(point) do
+    # Some other code...
+    {point.x, point.y, point[:z]}
+  end
+end
+```
+
+```elixir
+iex> Graphics.plot(point_2d)
+{2, 3, nil}
+iex> Graphics.plot(bad_point)
+** (KeyError) key :x not found in: %{y: 3, z: 4}
+  graphic.ex:4: Graphics.plot/1
+```
+
+This is beneficial because:
+
+1. It makes your expectations clear to others reading the code
+2. It fails fast when required data is missing
+3. It allows the compiler to provide warnings when accessing non-existent fields, particularly in compile-time structures like structs
+
+Overall, the usage of `map.key` and `map[:key]` encode important information about your data structure, allowing developers to be clear about their intent. The `Access` module documentation also provides useful reference on this topic. You can also consider the `Map` module when working with maps of any keys, which contains functions for fetching keys (with or without default values), updating and removing keys, traversals, and more.
+
+An alternative to refactor this anti-pattern is to use pattern matching, defining explicit clauses for 2D vs 3D points:
+
+```elixir
+defmodule Graphics do
+  # 3d
+  def plot(%{x: x, y: y, z: z}) do
+    # Some other code...
+    {x, y, z}
+  end
+
+  # 2d
+  def plot(%{x: x, y: y}) do
+    # Some other code...
+    {x, y}
+  end
+end
+```
+
+Pattern-matching is specially useful when matching over multiple keys as well as on the values themselves at once. In the example above, the code will not only extract the values but also verify that the required keys exist. If we try to call `plot/1` with a map that doesn't have the required keys, we'll get a `FunctionClauseError`:
+
+```elixir
+iex> incomplete_point = %{x: 5}
+%{x: 5}
+iex> Graphics.plot(incomplete_point)
+** (FunctionClauseError) no function clause matching in Graphics.plot/1
+
+    The following arguments were given to Graphics.plot/1:
+
+        # 1
+        %{x: 5}
+```
+
+Another option is to use structs. By default, structs only support static access to its fields. In such scenarios, you may consider defining structs for both 2D and 3D points:
+
+```elixir
+defmodule Point2D do
+  @enforce_keys [:x, :y]
+  defstruct [x: nil, y: nil]
+end
+```
+
+Generally speaking, structs are useful when sharing data structures across modules, at the cost of adding a compile time dependency between these modules. If module `A` uses a struct defined in module `B`, `A` must be recompiled if the fields in the struct `B` change.
+
+In summary, Elixir provides several ways to access map values, each with different behaviors:
+
+1. **Static access** (`map.key`): Fails fast when keys are missing, ideal for structs and maps with known atom keys
+2. **Dynamic access** (`map[:key]`): Works with any `Access` data structure, suitable for optional fields, returns nil for missing keys
+3. **Pattern matching**: Provides a powerful way to both extract values and ensure required map/struct keys exist in one operation
+
+Choosing the right approach depends if the keys are known upfront or not. Static access and pattern matching are mostly equivalent (although pattern matching allows you to match on multiple keys at once, including matching on the struct name).
+
+#### Additional remarks
+
+This anti-pattern was formerly known as [Accessing non-existent map/struct fields](https://github.com/lucasvegi/Elixir-Code-Smells#accessing-non-existent-mapstruct-fields).
+
+## Non-assertive pattern matching
+
+#### Problem
+
+Overall, Elixir systems are composed of many supervised processes, so the effects of an error are localized to a single process, and don't propagate to the entire application. A supervisor detects the failing process, reports it, and possibly restarts it. This anti-pattern arises when developers write defensive or imprecise code, capable of returning incorrect values which were not planned for, instead of programming in an assertive style through pattern matching and guards.
+
+#### Example
+
+The function `get_value/2` tries to extract a value from a specific key of a URL query string. As it is not implemented using pattern matching, `get_value/2` always returns a value, regardless of the format of the URL query string passed as a parameter in the call. Sometimes the returned value will be valid. However, if a URL query string with an unexpected format is used in the call, `get_value/2` will extract incorrect values from it:
+
+```elixir
+defmodule Extract do
+  def get_value(string, desired_key) do
+    parts = String.split(string, "&")
+
+    Enum.find_value(parts, fn pair ->
+      key_value = String.split(pair, "=")
+      Enum.at(key_value, 0) == desired_key && Enum.at(key_value, 1)
+    end)
+  end
+end
+```
+
+```elixir
+# URL query string with the planned format - OK!
+iex> Extract.get_value("name=Lucas&university=UFMG&lab=ASERG", "lab")
+"ASERG"
+iex> Extract.get_value("name=Lucas&university=UFMG&lab=ASERG", "university")
+"UFMG"
+# Unplanned URL query string format - Unplanned value extraction!
+iex> Extract.get_value("name=Lucas&university=institution=UFMG&lab=ASERG", "university")
+"institution"   # <= why not "institution=UFMG"? or only "UFMG"?
+```
+
+#### Refactoring
+
+To remove this anti-pattern, `get_value/2` can be refactored through the use of pattern matching. So, if an unexpected URL query string format is used, the function will crash instead of returning an invalid value. This behavior, shown below, allows clients to decide how to handle these errors and doesn't give a false impression that the code is working correctly when unexpected values are extracted:
+
+```elixir
+defmodule Extract do
+  def get_value(string, desired_key) do
+    parts = String.split(string, "&")
+
+    Enum.find_value(parts, fn pair ->
+      [key, value] = String.split(pair, "=") # <= pattern matching
+      key == desired_key && value
+    end)
+  end
+end
+```
+
+```elixir
+# URL query string with the planned format - OK!
+iex> Extract.get_value("name=Lucas&university=UFMG&lab=ASERG", "name")
+"Lucas"
+# Unplanned URL query string format - Crash explaining the problem to the client!
+iex> Extract.get_value("name=Lucas&university=institution=UFMG&lab=ASERG", "university")
+** (MatchError) no match of right hand side value: ["university", "institution", "UFMG"]
+  extract.ex:7: anonymous fn/2 in Extract.get_value/2 # <= left hand: [key, value] pair
+iex> Extract.get_value("name=Lucas&university&lab=ASERG", "university")
+** (MatchError) no match of right hand side value: ["university"]
+  extract.ex:7: anonymous fn/2 in Extract.get_value/2 # <= left hand: [key, value] pair
+```
+
+Elixir and pattern matching promote an assertive style of programming where you handle the known cases. Once an unexpected scenario arises, you can decide to address it accordingly based on practical examples, or conclude the scenario is indeed invalid and the exception is the desired choice.
+
+`case/2` is another important construct in Elixir that help us write assertive code, by matching on specific patterns. For example, if a function returns `{:ok, ...}` or `{:error, ...}`, prefer to explicitly match on both patterns:
+
+```elixir
+case some_function(arg) do
+  {:ok, value} -> # ...
+  {:error, _} -> # ...
+end
+```
+
+In particular, avoid matching solely on `_`, as shown below:
+
+```elixir
+case some_function(arg) do
+  {:ok, value} -> # ...
+  _ -> # ...
+end
+```
+
+ Matching on `_` is less clear in intent and it may hide bugs if `some_function/1` adds new return values in the future.
+
+#### Additional remarks
+
+This anti-pattern was formerly known as [Speculative assumptions](https://github.com/lucasvegi/Elixir-Code-Smells#speculative-assumptions).
+
+## Non-assertive truthiness
+
+#### Problem
+
+Elixir provides the concept of truthiness: `nil` and `false` are considered "falsy" and all other values are "truthy". Many constructs in the language, such as `&&/2`, `||/2`, and `!/1` handle truthy and falsy values. Using those operators is not an anti-pattern. However, using those operators when all operands are expected to be booleans, may be an anti-pattern.
+
+#### Example
+
+The simplest scenario where this anti-pattern manifests is in conditionals, such as:
+
+```elixir
+if is_binary(name) && is_integer(age) do
+  # ...
+else
+  # ...
+end
+```
+
+Given both operands of `&&/2` are booleans, the code is more generic than necessary, and potentially unclear.
+
+#### Refactoring
+
+To remove this anti-pattern, we can replace `&&/2`, `||/2`, and `!/1` by `and/2`, `or/2`, and `not/1` respectively. These operators assert at least their first argument is a boolean:
+
+```elixir
+if is_binary(name) and is_integer(age) do
+  # ...
+else
+  # ...
+end
+```
+
+This technique may be particularly important when working with Erlang code. Erlang does not have the concept of truthiness. It never returns `nil`, instead its functions may return `:error` or `:undefined` in places an Elixir developer would return `nil`. Therefore, to avoid accidentally interpreting `:undefined` or `:error` as a truthy value, you may prefer to use `and/2`, `or/2`, and `not/1` exclusively when interfacing with Erlang APIs.
+
+## Structs with 32 fields or more
+
+#### Problem
+
+Structs in Elixir are implemented as compile-time maps, which have a predefined amount of fields. When structs have 32 or more fields, their internal representation in the Erlang Virtual Machines changes, potentially leading to bloating and higher memory usage.
+
+#### Example
+
+Any struct with 32 or more fields will be problematic:
+
+```elixir
+defmodule MyExample do
+  defstruct [
+    :field1,
+    :field2,
+    ...,
+    :field35
+  ]
+end
+```
+
+The Erlang VM has two internal representations for maps: a flat map and a hash map. A flat map is represented internally as two tuples: one tuple containing the keys and another tuple holding the values. Whenever you update a flat map, the tuple keys are shared, reducing the amount of memory used by the update. A hash map has a more complex structure, which is efficient for a large amount of keys, but it does not share the key space.
+
+Maps of up to 32 keys are represented as flat maps. All others are hash map. Structs *are* maps (with a metadata field called `__struct__`) and so any struct with fewer than 32 fields is represented as a flat map. This allows us to optimize several struct operations, as we never add or remove fields to structs, we simply update them.
+
+Furthermore, structs of the same name "instantiated" in the same module will share the same "tuple keys" at compilation times, as long as they have fewer than 32 fields. For example, in the following code:
+
+```elixir
+defmodule Example do
+  def users do
+    [%User{name: "John"}, %User{name: "Meg"}, ...]
+  end
+end
+```
+
+All user structs will point to the same tuple keys at compile-time, also reducing the memory cost of instantiating structs with `%MyStruct{...}` notation. This optimization is also not available if the struct has 32 keys or more.
+
+#### Refactoring
+
+Removing this anti-pattern, in a nutshell, requires ensuring your struct has fewer than 32 fields. There are a few techniques you could apply:
+
+  * If the struct has "optional" fields, for example, fields which are initialized with nil, you could nest all optional fields into other field, called `:metadata`, `:optionals`, or similar. This could lead to benefits such as being able to use pattern matching to check if a field exists or not, instead of relying on `nil` values
+
+  * You could nest structs, by storing structs within other fields. Fields that are rarely read or written to are good candidates to be moved to a nested struct
+
+  * You could nest fields as tuples. For example, if two fields are always read or updated together, they could be moved to a tuple (or another composite data structure)
+
+The challenge is to balance the changes above with API ergonomics, in particular, when fields may be frequently read and written to.
diff --git a/lib/elixir/pages/anti-patterns/design-anti-patterns.md b/lib/elixir/pages/anti-patterns/design-anti-patterns.md
new file mode 100644
index 00000000000..6e0d6dfa30e
--- /dev/null
+++ b/lib/elixir/pages/anti-patterns/design-anti-patterns.md
@@ -0,0 +1,486 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Design-related anti-patterns
+
+This document outlines potential anti-patterns related to your modules, functions, and the role they play within a codebase.
+
+## Alternative return types
+
+#### Problem
+
+This anti-pattern refers to functions that receive options (typically as a *keyword list* parameter) that drastically change their return type. Because options are optional and sometimes set dynamically, if they also change the return type, it may be hard to understand what the function actually returns.
+
+#### Example
+
+An example of this anti-pattern, as shown below, is when a function has many alternative return types, depending on the options received as a parameter.
+
+```elixir
+defmodule AlternativeInteger do
+  @spec parse(String.t(), keyword()) :: integer() | {integer(), String.t()} | :error
+  def parse(string, options \\ []) when is_list(options) do
+    if Keyword.get(options, :discard_rest, false) do
+      case Integer.parse(string) do
+        {int, _rest} -> int
+        :error -> :error
+      end
+    else
+      Integer.parse(string)
+    end
+  end
+end
+```
+
+```elixir
+iex> AlternativeInteger.parse("13")
+{13, ""}
+iex> AlternativeInteger.parse("13", discard_rest: false)
+{13, ""}
+iex> AlternativeInteger.parse("13", discard_rest: true)
+13
+```
+
+#### Refactoring
+
+To refactor this anti-pattern, as shown next, add a specific function for each return type (for example, `parse_discard_rest/1`), no longer delegating this to options passed as arguments.
+
+```elixir
+defmodule AlternativeInteger do
+  @spec parse(String.t()) :: {integer(), String.t()} | :error
+  def parse(string) do
+    Integer.parse(string)
+  end
+
+  @spec parse_discard_rest(String.t()) :: integer() | :error
+  def parse_discard_rest(string) do
+    case Integer.parse(string) do
+      {int, _rest} -> int
+      :error -> :error
+    end
+  end
+end
+```
+
+```elixir
+iex> AlternativeInteger.parse("13")
+{13, ""}
+iex> AlternativeInteger.parse_discard_rest("13")
+13
+```
+
+## Boolean obsession
+
+#### Problem
+
+This anti-pattern happens when booleans are used instead of atoms to encode information. The usage of booleans themselves is not an anti-pattern, but whenever multiple booleans are used with overlapping states, replacing the booleans by atoms (or composite data types such as *tuples*) may lead to clearer code.
+
+This is a special case of [*Primitive obsession*](#primitive-obsession), specific to boolean values.
+
+#### Example
+
+An example of this anti-pattern is a function that receives two or more options, such as `editor: true` and `admin: true`, to configure its behavior in overlapping ways. In the code below, the `:editor` option has no effect if `:admin` is set, meaning that the `:admin` option has higher priority than `:editor`, and they are ultimately related.
+
+```elixir
+defmodule MyApp do
+  def process(invoice, options \\ []) do
+    cond do
+      options[:admin] ->  # Is an admin
+      options[:editor] -> # Is an editor
+      true ->          # Is none
+    end
+  end
+end
+```
+
+#### Refactoring
+
+Instead of using multiple options, the code above could be refactored to receive a single option, called `:role`, that can be either `:admin`, `:editor`, or `:default`:
+
+```elixir
+defmodule MyApp do
+  def process(invoice, options \\ []) do
+    case Keyword.get(options, :role, :default) do
+      :admin ->   # Is an admin
+      :editor ->  # Is an editor
+      :default -> # Is none
+    end
+  end
+end
+```
+
+This anti-pattern may also happen in our own data structures. For example, we may define a `User` struct with two boolean fields, `:editor` and `:admin`, while a single field named `:role` may be preferred.
+
+Finally, it is worth noting that using atoms may be preferred even when we have a single boolean argument/option. For example, consider an invoice which may be set as approved/unapproved. One option is to provide a function that expects a boolean:
+
+```elixir
+MyApp.update(invoice, approved: true)
+```
+
+However, using atoms may read better and make it simpler to add further states (such as pending) in the future:
+
+```elixir
+MyApp.update(invoice, status: :approved)
+```
+
+Remember booleans are internally represented as atoms. Therefore there is no performance penalty in one approach over the other.
+
+## Exceptions for control-flow
+
+#### Problem
+
+This anti-pattern refers to code that uses `Exception`s for control flow. Exception handling itself does not represent an anti-pattern, but developers must prefer to use `case` and pattern matching to change the flow of their code, instead of `try/rescue`. In turn, library authors should provide developers with APIs to handle errors without relying on exception handling. When developers have no freedom to decide if an error is exceptional or not, this is considered an anti-pattern.
+
+#### Example
+
+An example of this anti-pattern, as shown below, is using `try/rescue` to deal with file operations:
+
+```elixir
+defmodule MyModule do
+  def print_file(file) do
+    try do
+      IO.puts(File.read!(file))
+    rescue
+      e -> IO.puts(:stderr, Exception.message(e))
+    end
+  end
+end
+```
+
+```elixir
+iex> MyModule.print_file("valid_file")
+This is a valid file!
+:ok
+iex> MyModule.print_file("invalid_file")
+could not read file "invalid_file": no such file or directory
+:ok
+```
+
+#### Refactoring
+
+To refactor this anti-pattern, as shown next, use `File.read/1`, which returns tuples instead of raising when a file cannot be read:
+
+```elixir
+defmodule MyModule do
+  def print_file(file) do
+    case File.read(file) do
+      {:ok, binary} -> IO.puts(binary)
+      {:error, reason} -> IO.puts(:stderr, "could not read file #{file}: #{reason}")
+    end
+  end
+end
+```
+
+This is only possible because the `File` module provides APIs for reading files with tuples as results (`File.read/1`), as well as a version that raises an exception (`File.read!/1`). The bang (exclamation point) is effectively part of [Elixir's naming conventions](naming-conventions.md#trailing-bang-foo).
+
+Library authors are encouraged to follow the same practices. In practice, the bang variant is implemented on top of the non-raising version of the code. For example, `File.read!/1` is implemented as:
+
+```elixir
+def read!(path) do
+  case read(path) do
+    {:ok, binary} ->
+      binary
+
+    {:error, reason} ->
+      raise File.Error, reason: reason, action: "read file", path: IO.chardata_to_string(path)
+  end
+end
+```
+
+A common practice followed by the community is to make the non-raising version return `{:ok, result}` or `{:error, Exception.t}`. For example, an HTTP client may return `{:ok, %HTTP.Response{}}` on success cases and `{:error, %HTTP.Error{}}` for failures, where `HTTP.Error` is [implemented as an exception](`Kernel.defexception/1`). This makes it convenient for anyone to raise an exception by simply calling `Kernel.raise/1`.
+
+#### Additional remarks
+
+This anti-pattern is of special importance to library authors and whenever writing functions that will be invoked by other developers and third-party code. Nevertheless, there are still scenarios where developers can afford to raise exceptions directly, for example:
+
+  * invalid arguments: it is expected that functions will raise for invalid arguments, as those are structural error and not semantic errors. For example, `File.read(123)` will always raise, because `123` is never a valid filename
+
+  * during tests, scripts, etc: those are common scenarios where you want your code to fail as soon as possible in case of errors. Using `!` functions, such as `File.read!/1`, allows you to do so quickly and with clear error messages
+
+  * some frameworks, such as [Phoenix](https://phoenixframework.org), allow developers to raise exceptions in their code and uses a protocol to convert these exceptions into semantic HTTP responses
+
+This anti-pattern was formerly known as [Using exceptions for control-flow](https://github.com/lucasvegi/Elixir-Code-Smells#using-exceptions-for-control-flow).
+
+## Primitive obsession
+
+#### Problem
+
+This anti-pattern happens when Elixir basic types (for example, *integer*, *float*, and *string*) are excessively used to carry structured information, rather than creating specific composite data types (for example, *tuples*, *maps*, and *structs*) that can better represent a domain.
+
+#### Example
+
+An example of this anti-pattern is the use of a single *string* to represent an `Address`. An `Address` is a more complex structure than a simple basic (aka, primitive) value.
+
+```elixir
+defmodule MyApp do
+  def extract_postal_code(address) when is_binary(address) do
+    # Extract postal code with address...
+  end
+
+  def fill_in_country(address) when is_binary(address) do
+    # Fill in missing country...
+  end
+end
+```
+
+While you may receive the `address` as a string from a database, web request, or a third-party, if you find yourself frequently manipulating or extracting information from the string, it is a good indicator you should convert the address into structured data:
+
+Another example of this anti-pattern is using floating numbers to model money and currency, when [richer data structures should be preferred](https://hexdocs.pm/ex_money/).
+
+#### Refactoring
+
+Possible solutions to this anti-pattern is to use maps or structs to model our address. The example below creates an `Address` struct, better representing this domain through a composite type. Additionally, we introduce a `parse/1` function, that converts the string into an `Address`, which will simplify the logic of remaining functions. With this modification, we can extract each field of this composite type individually when needed.
+
+```elixir
+defmodule Address do
+  defstruct [:street, :city, :state, :postal_code, :country]
+end
+```
+
+```elixir
+defmodule MyApp do
+  def parse(address) when is_binary(address) do
+    # Returns %Address{}
+  end
+
+  def extract_postal_code(%Address{} = address) do
+    # Extract postal code with address...
+  end
+
+  def fill_in_country(%Address{} = address) do
+    # Fill in missing country...
+  end
+end
+```
+
+## Unrelated multi-clause function
+
+#### Problem
+
+Using multi-clause functions is a powerful Elixir feature. However, some developers may abuse this feature to group *unrelated* functionality, which is an anti-pattern.
+
+#### Example
+
+A frequent example of this usage of multi-clause functions occurs when developers mix unrelated business logic into the same function definition, in a way that the behavior of each clause becomes completely distinct from the others. Such functions often have too broad specifications, making it difficult for other developers to understand and maintain them.
+
+Some developers may use documentation mechanisms such as `@doc` annotations to compensate for poor code readability, however the documentation itself may end-up full of conditionals to describe how the function behaves for each different argument combination. This is a good indicator that the clauses are ultimately unrelated.
+
+```elixir
+@doc """
+Updates a struct.
+
+If given a product, it will...
+
+If given an animal, it will...
+"""
+def update(%Product{count: count, material: material})  do
+  # ...
+end
+
+def update(%Animal{count: count, skin: skin})  do
+  # ...
+end
+```
+
+If updating an animal is completely different from updating a product and requires a different set of rules, it may be worth splitting those over different functions or even different modules.
+
+#### Refactoring
+
+As shown below, a possible solution to this anti-pattern is to break the business rules that are mixed up in a single unrelated multi-clause function in simple functions. Each function can have a specific name and `@doc`, describing its behavior and parameters received. While this refactoring sounds simple, it can impact the function's callers, so be careful!
+
+```elixir
+@doc """
+Updates a product.
+
+It will...
+"""
+def update_product(%Product{count: count, material: material}) do
+  # ...
+end
+
+@doc """
+Updates an animal.
+
+It will...
+"""
+def update_animal(%Animal{count: count, skin: skin}) do
+  # ...
+end
+```
+
+These functions may still be implemented with multiple clauses, as long as the clauses group related functionality. For example, `update_product` could be in practice implemented as follows:
+
+```elixir
+def update_product(%Product{count: 0}) do
+  # ...
+end
+
+def update_product(%Product{material: material})
+    when material in ["metal", "glass"] do
+  # ...
+end
+
+def update_product(%Product{material: material})
+    when material not in ["metal", "glass"] do
+  # ...
+end
+```
+
+You can see this pattern in practice within Elixir itself. The `+/2` operator can add `Integer`s and `Float`s together, but not `String`s, which instead use the `<>/2` operator. In this sense, it is reasonable to handle integers and floats in the same operation, but strings are unrelated enough to deserve their own function.
+
+You will also find examples in Elixir of functions that work with any struct, which would seemingly be an occurrence of this anti-pattern, such as `struct/2`:
+
+```elixir
+iex> struct(URI.parse("/foo/bar"), path: "/bar/baz")
+%URI{
+  scheme: nil,
+  userinfo: nil,
+  host: nil,
+  port: nil,
+  path: "/bar/baz",
+  query: nil,
+  fragment: nil
+}
+```
+
+The difference here is that the `struct/2` function behaves precisely the same for any struct given, therefore there is no question of how the function handles different inputs. If the behavior is clear and consistent for all inputs, then the anti-pattern does not take place.
+
+## Using application configuration for libraries
+
+#### Problem
+
+The [*application environment*](https://hexdocs.pm/elixir/Application.html#module-the-application-environment) can be used to parameterize global values that can be used in an Elixir system. This mechanism can be very useful and therefore is not considered an anti-pattern by itself. However, library authors should avoid using the application environment to configure their library. The reason is exactly that the application environment is a **global** state, so there can only be a single value for each key in the environment for an application. This makes it impossible for multiple applications depending on the same library to configure the same aspect of the library in different ways.
+
+#### Example
+
+The `DashSplitter` module represents a library that configures the behavior of its functions through the global application environment. These configurations are concentrated in the *config/config.exs* file, shown below:
+
+```elixir
+import Config
+
+config :app_config,
+  parts: 3
+
+import_config "#{config_env()}.exs"
+```
+
+One of the functions implemented by the `DashSplitter` library is `split/1`. This function aims to separate a string received via a parameter into a certain number of parts. The character used as a separator in `split/1` is always `"-"` and the number of parts the string is split into is defined globally by the application environment. This value is retrieved by the `split/1` function by calling `Application.fetch_env!/2`, as shown next:
+
+```elixir
+defmodule DashSplitter do
+  def split(string) when is_binary(string) do
+    parts = Application.fetch_env!(:app_config, :parts) # <= retrieve parameterized value
+    String.split(string, "-", parts: parts)             # <= parts: 3
+  end
+end
+```
+
+Due to this parameterized value used by the `DashSplitter` library, all applications dependent on it can only use the `split/1` function with identical behavior about the number of parts generated by string separation. Currently, this value is equal to 3, as we can see in the use examples shown below:
+
+```elixir
+iex> DashSplitter.split("Lucas-Francisco-Vegi")
+["Lucas", "Francisco", "Vegi"]
+iex> DashSplitter.split("Lucas-Francisco-da-Matta-Vegi")
+["Lucas", "Francisco", "da-Matta-Vegi"]
+```
+
+#### Refactoring
+
+To remove this anti-pattern, this type of configuration should be performed using a parameter passed to the function. The code shown below performs the refactoring of the `split/1` function by accepting [keyword lists](`Keyword`) as a new optional parameter. With this new parameter, it is possible to modify the default behavior of the function at the time of its call, allowing multiple different ways of using `split/2` within the same application:
+
+```elixir
+defmodule DashSplitter do
+  def split(string, opts \\ []) when is_binary(string) and is_list(opts) do
+    parts = Keyword.get(opts, :parts, 2) # <= default config of parts == 2
+    String.split(string, "-", parts: parts)
+  end
+end
+```
+
+```elixir
+iex> DashSplitter.split("Lucas-Francisco-da-Matta-Vegi", [parts: 5])
+["Lucas", "Francisco", "da", "Matta", "Vegi"]
+iex> DashSplitter.split("Lucas-Francisco-da-Matta-Vegi") #<= default config is used!
+["Lucas", "Francisco-da-Matta-Vegi"]
+```
+
+Of course, not all uses of the application environment by libraries are incorrect. One example is using configuration to replace a component (or dependency) of a library by another that must behave the exact same. Consider a library that needs to parse CSV files. The library author may pick one package to use as default parser but allow its users to swap to different implementations via the application environment. At the end of the day, choosing a different CSV parser should not change the outcome, and library authors can even enforce this by [defining behaviours](../references/typespecs.md#behaviours) with the exact semantics they expect.
+
+#### Additional remarks: Supervision trees
+
+In practice, libraries may require additional configuration beyond keyword lists. For example, if a library needs to start a supervision tree, how can the user of said library customize its supervision tree? Given the supervision tree itself is global (as it belongs to the library), library authors may be tempted to use the application configuration once more.
+
+One solution is for the library to provide its own child specification, instead of starting the supervision tree itself. This allows the user to start all necessary processes under its own supervision tree, potentially passing custom configuration options during initialization.
+
+You can see this pattern in practice in projects like [Nx](https://github.com/elixir-nx/nx) and [DNS Cluster](https://github.com/phoenixframework/dns_cluster). These libraries require that you list processes under your own supervision tree:
+
+```elixir
+children = [
+  {DNSCluster, query: "my.subdomain"}
+]
+```
+
+In such cases, if the users of `DNSCluster` need to configure DNSCluster per environment, they can be the ones reading from the application environment, without the library forcing them to:
+
+```elixir
+children = [
+  {DNSCluster, query: Application.get_env(:my_app, :dns_cluster_query) || :ignore}
+]
+```
+
+Some libraries, such as [Ecto](https://github.com/elixir-ecto/ecto), allow you to pass your application name as an option (called `:otp_app` or similar) and then automatically read the environment from *your* application. While this addresses the issue with the application environment being global, as they read from each individual application, it comes at the cost of some indirection, compared to the example above where users explicitly read their application environment from their own code, whenever desired.
+
+#### Additional remarks: Compile-time configuration
+
+A similar discussion entails compile-time configuration. What if a library author requires some configuration to be provided at compilation time?
+
+Once again, instead of forcing users of your library to provide compile-time configuration, you may want to allow users of your library to generate the code themselves. That's the approach taken by libraries such as [Ecto](https://github.com/elixir-ecto/ecto):
+
+```elixir
+defmodule MyApp.Repo do
+  use Ecto.Repo, adapter: Ecto.Adapters.Postgres
+end
+```
+
+Instead of forcing developers to share a single repository, Ecto allows its users to define as many repositories as they want. Given the `:adapter` configuration is required at compile-time, it is a required value on `use Ecto.Repo`. If developers want to configure the adapter per environment, then it is their choice:
+
+```elixir
+defmodule MyApp.Repo do
+  use Ecto.Repo, adapter: Application.compile_env(:my_app, :repo_adapter)
+end
+```
+
+On the other hand, [code generation comes with its own anti-patterns](macro-anti-patterns.md), and must be considered carefully. That's to say: while using the application environment for libraries is discouraged, especially compile-time configuration, in some cases they may be the best option. For example, consider a library needs to parse CSV or JSON files to generate code based on data files. In such cases, it is best to provide reasonable defaults and make them customizable via the application environment, instead of asking each user of your library to generate the exact same code.
+
+#### Additional remarks: Mix tasks
+
+For Mix tasks and related tools, it may be necessary to provide per-project configuration. For example, imagine you have a `:linter` project, which supports setting the output file and the verbosity level. You may choose to configure it through application environment:
+
+```elixir
+config :linter,
+  output_file: "/path/to/output.json",
+  verbosity: 3
+```
+
+However, `Mix` allows tasks to read per-project configuration via `Mix.Project.config/0`. In this case, you can configure the `:linter` directly in the `mix.exs` file:
+
+```elixir
+def project do
+  [
+    app: :my_app,
+    version: "1.0.0",
+    linter: [
+      output_file: "/path/to/output.json",
+      verbosity: 3
+    ],
+    ...
+  ]
+end
+```
+
+Additionally, if a Mix task is available, you can also accept these options as command line arguments (see `OptionParser`):
+
+```bash
+mix linter --output-file /path/to/output.json --verbosity 3
+```
diff --git a/lib/elixir/pages/anti-patterns/macro-anti-patterns.md b/lib/elixir/pages/anti-patterns/macro-anti-patterns.md
new file mode 100644
index 00000000000..9ccb413642e
--- /dev/null
+++ b/lib/elixir/pages/anti-patterns/macro-anti-patterns.md
@@ -0,0 +1,397 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Meta-programming anti-patterns
+
+This document outlines potential anti-patterns related to meta-programming.
+
+## Compile-time dependencies
+
+#### Problem
+
+This anti-pattern is related to dependencies between files in Elixir. Because macros are used at compile-time, the use of any macro in Elixir adds a compile-time dependency to the module that defines the macro.
+
+However, when macros are used in the body of a module, the arguments to the macro themselves may become compile-time dependencies. These dependencies may lead to dependency graphs where changing a single file causes several files to be recompiled.
+
+#### Example
+
+Let's take the [`Plug`](https://github.com/elixir-plug/plug) library as an example. The `Plug` project allows you to specify several modules, also known as plugs, which will be invoked whenever there is a request. As a user of `Plug`, you would use it as follows:
+
+```elixir
+defmodule MyApp do
+  use Plug.Builder
+
+  plug MyApp.Authentication
+end
+```
+
+And imagine `Plug` has the following definitions of the macros above (simplified):
+
+```elixir
+defmodule Plug.Builder do
+  defmacro __using__(_opts) do
+    quote do
+      Module.register_attribute(__MODULE__, :plugs, accumulate: true)
+      @before_compile Plug.Builder
+    end
+  end
+
+  defmacro plug(mod) do
+    quote do
+      @plugs unquote(mod)
+    end
+  end
+
+  ...
+end
+```
+
+The implementation accumulates all modules inside the `@plugs` module attribute. Right before the module is compiled, `Plug.Builder` will reads all modules stored in `@plugs` and compile them into a function, like this:
+
+```elixir
+def call(conn, _opts) do
+  MyApp.Authentication.call(conn)
+end
+```
+
+The trouble with the code above is that, because the `plug MyApp.Authentication` was invoked at compile-time, the module `MyApp.Authentication` is now a compile-time dependency of `MyApp`, even though `MyApp.Authentication` is never used at compile-time. If `MyApp.Authentication` depends on other modules, even at runtime, this can now lead to a large recompilation graph in case of changes.
+
+#### Refactoring
+
+To address this anti-pattern, a macro can expand literals within the context they are meant to be used, as follows:
+
+```elixir
+  defmacro plug(mod) do
+    mod = Macro.expand_literals(mod, %{__CALLER__ | function: {:call, 2}})
+
+    quote do
+      @plugs unquote(mod)
+    end
+  end
+```
+
+In the example above, since `mod` is used only within the `call/2` function, we prematurely expand module reference as if it was inside the `call/2` function. Now `MyApp.Authentication` is only a runtime dependency of `MyApp`, no longer a compile-time one.
+
+Note, however, the above must only be done if your macros do not attempt to invoke any function, access any struct, or any other metadata of the module at compile-time. If you interact with the module given to a macro anywhere outside of definition of a function, then you effectively have a compile-time dependency. And, even though you generally want to avoid them, it is not always possible.
+
+In actual projects, developers may use `mix xref trace path/to/file.ex` to execute a file and have it print information about which modules it depends on, and if those modules are compile-time, runtime, or export dependencies. See `mix xref` for more information.
+
+## Large code generation
+
+#### Problem
+
+This anti-pattern is related to macros that generate too much code. When a macro generates a large amount of code, it impacts how the compiler and/or the runtime work. The reason for this is that Elixir may have to expand, compile, and execute the code multiple times, which will make compilation slower and the resulting compiled artifacts larger.
+
+#### Example
+
+Imagine you are defining a router for a web application, where you could have macros like `get/2`. On every invocation of the macro (which could be hundreds), the code inside `get/2` will be expanded and compiled, which can generate a large volume of code overall.
+
+```elixir
+defmodule Routes do
+  defmacro get(route, handler) do
+    quote do
+      route = unquote(route)
+      handler = unquote(handler)
+
+      if not is_binary(route) do
+        raise ArgumentError, "route must be a binary"
+      end
+
+      if not is_atom(handler) do
+        raise ArgumentError, "handler must be a module"
+      end
+
+      @store_route_for_compilation {route, handler}
+    end
+  end
+end
+```
+
+#### Refactoring
+
+To remove this anti-pattern, the developer should simplify the macro, delegating part of its work to other functions. As shown below, by encapsulating the code inside `quote/1` inside the function `__define__/3` instead, we reduce the code that is expanded and compiled on every invocation of the macro, and instead we dispatch to a function to do the bulk of the work.
+
+```elixir
+defmodule Routes do
+  defmacro get(route, handler) do
+    quote do
+      Routes.__define__(__MODULE__, unquote(route), unquote(handler))
+    end
+  end
+
+  def __define__(module, route, handler) do
+    if not is_binary(route) do
+      raise ArgumentError, "route must be a binary"
+    end
+
+    if not is_atom(handler) do
+      raise ArgumentError, "handler must be a module"
+    end
+
+    Module.put_attribute(module, :store_route_for_compilation, {route, handler})
+  end
+end
+```
+
+## Unnecessary macros
+
+#### Problem
+
+*Macros* are powerful meta-programming mechanisms that can be used in Elixir to extend the language. While using macros is not an anti-pattern in itself, this meta-programming mechanism should only be used when absolutely necessary. Whenever a macro is used, but it would have been possible to solve the same problem using functions or other existing Elixir structures, the code becomes unnecessarily more complex and less readable. Because macros are more difficult to implement and reason about, their indiscriminate use can compromise the evolution of a system, reducing its maintainability.
+
+#### Example
+
+The `MyMath` module implements the `sum/2` macro to perform the sum of two numbers received as parameters. While this code has no syntax errors and can be executed correctly to get the desired result, it is unnecessarily more complex. By implementing this functionality as a macro rather than a conventional function, the code became less clear:
+
+```elixir
+defmodule MyMath do
+  defmacro sum(v1, v2) do
+    quote do
+      unquote(v1) + unquote(v2)
+    end
+  end
+end
+```
+
+```elixir
+iex> require MyMath
+MyMath
+iex> MyMath.sum(3, 5)
+8
+iex> MyMath.sum(3 + 1, 5 + 6)
+15
+```
+
+#### Refactoring
+
+To remove this anti-pattern, the developer must replace the unnecessary macro with structures that are simpler to write and understand, such as named functions. The code shown below is the result of the refactoring of the previous example. Basically, the `sum/2` macro has been transformed into a conventional named function. Note that the `require/2` call is no longer needed:
+
+```elixir
+defmodule MyMath do
+  def sum(v1, v2) do # <= The macro became a named function
+    v1 + v2
+  end
+end
+```
+
+```elixir
+iex> MyMath.sum(3, 5)
+8
+iex> MyMath.sum(3+1, 5+6)
+15
+```
+
+## `use` instead of `import`
+
+#### Problem
+
+Elixir has mechanisms such as `import/1`, `alias/1`, and `use/1` to establish dependencies between modules. Code implemented with these mechanisms does not characterize a smell by itself. However, while the `import/1` and `alias/1` directives have lexical scope and only facilitate a module calling functions of another, the `use/1` directive has a *broader scope*, which can be problematic.
+
+The `use/1` directive allows a module to inject any type of code into another, including propagating dependencies. In this way, using the `use/1` directive makes code harder to read, because to understand exactly what will happen when it references a module, it is necessary to have knowledge of the internal details of the referenced module.
+
+#### Example
+
+The code shown below is an example of this anti-pattern. It defines three modules -- `ModuleA`, `Library`, and `ClientApp`. `ClientApp` is reusing code from the `Library` via the `use/1` directive, but is unaware of its internal details. This makes it harder for the author of `ClientApp` to visualize which modules and functionality are now available within its module. To make matters worse, `Library` also imports `ModuleA`, which defines a `foo/0` function that conflicts with a local function defined in `ClientApp`:
+
+```elixir
+defmodule ModuleA do
+  def foo do
+    "From Module A"
+  end
+end
+```
+
+```elixir
+defmodule Library do
+  defmacro __using__(_opts) do
+    quote do
+      import Library
+      import ModuleA  # <= propagating dependencies!
+    end
+  end
+
+  def from_lib do
+    "From Library"
+  end
+end
+```
+
+```elixir
+defmodule ClientApp do
+  use Library
+
+  def foo do
+    "Local function from client app"
+  end
+
+  def from_client_app do
+    from_lib() <> " - " <> foo()
+  end
+end
+```
+
+When we try to compile `ClientApp`, Elixir detects the conflict and throws the following error:
+
+```text
+error: imported ModuleA.foo/0 conflicts with local function
+  └ client_app.ex:4:
+```
+
+#### Refactoring
+
+To remove this anti-pattern, we recommend library authors avoid providing `__using__/1` callbacks whenever it can be replaced by `alias/1` or `import/1` directives. In the following code, we assume `use Library` is no longer available and `ClientApp` was refactored in this way, and with that, the code is clearer and the conflict as previously shown no longer exists:
+
+```elixir
+defmodule ClientApp do
+  import Library
+
+  def foo do
+    "Local function from client app"
+  end
+
+  def from_client_app do
+    from_lib() <> " - " <> foo()
+  end
+end
+```
+
+```elixir
+iex> ClientApp.from_client_app()
+"From Library - Local function from client app"
+```
+
+#### Additional remarks
+
+In situations where you need to do more than importing and aliasing modules, providing `use MyModule` may be necessary, as it provides a common extension point within the Elixir ecosystem.
+
+Therefore, to provide guidance and clarity, we recommend library authors to include an admonition block in their `@moduledoc` that explains how `use MyModule` impacts the developer's code. As an example, the `GenServer` documentation outlines:
+
+> #### `use GenServer` {: .info}
+>
+> When you `use GenServer`, the `GenServer` module will
+> set `@behaviour GenServer` and define a `child_spec/1`
+> function, so your module can be used as a child
+> in a supervision tree.
+
+Think of this summary as a ["Nutrition facts label"](https://en.wikipedia.org/wiki/Nutrition_facts_label) for code generation. Make sure to only list changes made to the public API of the module. For example, if `use Library` sets an internal attribute called `@_some_module_info` and this attribute is never meant to be public, avoid documenting it in the nutrition facts.
+
+For convenience, the markup notation to generate the admonition block above is this:
+
+```markdown
+> #### `use GenServer` {: .info}
+>
+> When you `use GenServer`, the `GenServer` module will
+> set `@behaviour GenServer` and define a `child_spec/1`
+> function, so your module can be used as a child
+> in a supervision tree.
+```
+
+## Untracked compile-time dependencies
+
+#### Problem
+
+This anti-pattern is the opposite of ["Compile-time dependencies"](#compile-time-dependencies) and it happens when a compile-time dependency is accidentally bypassed, making the Elixir compiler unable to track dependencies and recompile files correctly. This happens when building aliases (in other words, module names) dynamically, either within a module or within a macro.
+
+#### Example
+
+For example, imagine you invoke a module at compile-time, you could write it as such:
+
+```elixir
+defmodule MyModule do
+  SomeOtherModule.example()
+end
+```
+
+In this case, Elixir knows `MyModule` is invoked `SomeOtherModule.example/0` outside of a function, and therefore at compile-time.
+
+Elixir can also track module names even during dynamic calls:
+
+```elixir
+defmodule MyModule do
+  mods = [OtherModule.Foo, OtherModule.Bar]
+
+  for mod <- mods do
+    mod.example()
+  end
+end
+```
+
+In the previous example, even though Elixir does not know which modules the function `example/0` was invoked on, it knows the modules `OtherModule.Foo` and `OtherModule.Bar` are referred outside of a function and therefore they become compile-time dependencies. If any of them change, Elixir will recompile `MyModule` itself.
+
+However, you should not programmatically generate the module names themselves, as that would make it impossible for Elixir to track them. More precisely, do not do this:
+
+```elixir
+defmodule MyModule do
+  parts = [:Foo, :Bar]
+
+  for part <- parts do
+    Module.concat(OtherModule, part).example()
+  end
+end
+```
+
+In this case, because the whole module was generated, Elixir sees a dependency only to `OtherModule`, never to `OtherModule.Foo` and `OtherModule.Bar`, potentially leading to inconsistencies when recompiling projects.
+
+A similar bug can happen when abusing the property that aliases are simply atoms, defining the atoms directly. In the case below, Elixir never sees the aliases, leading to untracked compile-time dependencies:
+
+```elixir
+defmodule MyModule do
+  mods = [:"Elixir.OtherModule.Foo", :"Elixir.OtherModule.Bar"]
+
+  for mod <- mods do
+    mod.example()
+  end
+end
+```
+
+#### Refactoring
+
+To address this anti-pattern, you should avoid defining module names programmatically. For example, if you need to dispatch to multiple modules, do so by using full module names.
+
+Instead of:
+
+```elixir
+defmodule MyModule do
+  parts = [:Foo, :Bar]
+
+  for part <- parts do
+    Module.concat(OtherModule, part).example()
+  end
+end
+```
+
+Do:
+
+```elixir
+defmodule MyModule do
+  mods = [OtherModule.Foo, OtherModule.Bar]
+
+  for mod <- mods do
+    mod.example()
+  end
+end
+```
+
+If you really need to define modules dynamically, you can do so via meta-programming, building the whole module name at compile-time:
+
+```elixir
+defmodule MyMacro do
+  defmacro call_examples(parts) do
+    for part <- parts do
+      quote do
+        # This builds OtherModule.Foo at compile-time
+        OtherModule.unquote(part).example()
+      end
+    end
+  end
+end
+
+defmodule MyModule do
+  import MyMacro
+  call_examples [:Foo, :Bar]
+end
+```
+
+In actual projects, developers may use `mix xref trace path/to/file.ex` to execute a file and have it print information about which modules it depends on, and if those modules are compile-time, runtime, or export dependencies. This can help you debug if the dependencies are being properly tracked in relation to external modules. See `mix xref` for more information.
diff --git a/lib/elixir/pages/anti-patterns/process-anti-patterns.md b/lib/elixir/pages/anti-patterns/process-anti-patterns.md
new file mode 100644
index 00000000000..07e27eb268b
--- /dev/null
+++ b/lib/elixir/pages/anti-patterns/process-anti-patterns.md
@@ -0,0 +1,329 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Process-related anti-patterns
+
+This document outlines potential anti-patterns related to processes and process-based abstractions.
+
+## Code organization by process
+
+#### Problem
+
+This anti-pattern refers to code that is unnecessarily organized by processes. A process itself does not represent an anti-pattern, but it should only be used to model runtime properties (such as concurrency, access to shared resources, error isolation, etc). When you use a process for code organization, it can create bottlenecks in the system.
+
+#### Example
+
+An example of this anti-pattern, as shown below, is a module that implements arithmetic operations (like `add` and `subtract`) by means of a `GenServer` process. If the number of calls to this single process grows, this code organization can compromise the system performance, therefore becoming a bottleneck.
+
+```elixir
+defmodule Calculator do
+  @moduledoc """
+  Calculator that performs basic arithmetic operations.
+
+  This code is unnecessarily organized in a GenServer process.
+  """
+
+  use GenServer
+
+  def add(a, b, pid) do
+    GenServer.call(pid, {:add, a, b})
+  end
+
+  def subtract(a, b, pid) do
+    GenServer.call(pid, {:subtract, a, b})
+  end
+
+  @impl GenServer
+  def init(init_arg) do
+    {:ok, init_arg}
+  end
+
+  @impl GenServer
+  def handle_call({:add, a, b}, _from, state) do
+    {:reply, a + b, state}
+  end
+
+  def handle_call({:subtract, a, b}, _from, state) do
+    {:reply, a - b, state}
+  end
+end
+```
+
+```elixir
+iex> {:ok, pid} = GenServer.start_link(Calculator, :init)
+{:ok, #PID<0.132.0>}
+iex> Calculator.add(1, 5, pid)
+6
+iex> Calculator.subtract(2, 3, pid)
+-1
+```
+
+#### Refactoring
+
+In Elixir, as shown next, code organization must be done only through modules and functions. Whenever possible, a library should not impose specific behavior (such as parallelization) on its users. It is better to delegate this behavioral decision to the developers of clients, thus increasing the potential for code reuse of a library.
+
+```elixir
+defmodule Calculator do
+  def add(a, b) do
+    a + b
+  end
+
+  def subtract(a, b) do
+    a - b
+  end
+end
+```
+
+```elixir
+iex> Calculator.add(1, 5)
+6
+iex> Calculator.subtract(2, 3)
+-1
+```
+
+## Scattered process interfaces
+
+#### Problem
+
+In Elixir, the use of an `Agent`, a `GenServer`, or any other process abstraction is not an anti-pattern in itself. However, when the responsibility for direct interaction with a process is spread throughout the entire system, it can become problematic. This bad practice can increase the difficulty of code maintenance and make the code more prone to bugs.
+
+#### Example
+
+The following code seeks to illustrate this anti-pattern. The responsibility for interacting directly with the `Agent` is spread across four different modules (`A`, `B`, `C`, and `D`).
+
+```elixir
+defmodule A do
+  def update(process) do
+    # Some other code...
+    Agent.update(process, fn _list -> 123 end)
+  end
+end
+```
+
+```elixir
+defmodule B do
+  def update(process) do
+    # Some other code...
+    Agent.update(process, fn content -> %{a: content} end)
+  end
+end
+```
+
+```elixir
+defmodule C do
+  def update(process) do
+    # Some other code...
+    Agent.update(process, fn content -> [:atom_value | content] end)
+  end
+end
+```
+
+```elixir
+defmodule D do
+  def get(process) do
+    # Some other code...
+    Agent.get(process, fn content -> content end)
+  end
+end
+```
+
+This spreading of responsibility can generate duplicated code and make code maintenance more difficult. Also, due to the lack of control over the format of the shared data, complex composed data can be shared. This freedom to use any format of data is dangerous and can induce developers to introduce bugs.
+
+```elixir
+# start an agent with initial state of an empty list
+iex> {:ok, agent} = Agent.start_link(fn -> [] end)
+{:ok, #PID<0.135.0>}
+
+# many data formats (for example, List, Map, Integer, Atom) are
+# combined through direct access spread across the entire system
+iex> A.update(agent)
+iex> B.update(agent)
+iex> C.update(agent)
+
+# state of shared information
+iex> D.get(agent)
+[:atom_value, %{a: 123}]
+```
+
+For a `GenServer` and other behaviours, this anti-pattern will manifest when scattering calls to `GenServer.call/3` and `GenServer.cast/2` throughout multiple modules, instead of encapsulating all the interaction with the `GenServer` in a single place.
+
+#### Refactoring
+
+Instead of spreading direct access to a process abstraction, such as `Agent`, over many places in the code, it is better to refactor this code by centralizing the responsibility for interacting with a process in a single module. This refactoring improves maintainability by removing duplicated code; it also allows you to limit the accepted format for shared data, reducing bug-proneness. As shown below, the module `Foo.Bucket` is centralizing the responsibility for interacting with the `Agent`. Any other place in the code that needs to access shared data must now delegate this action to `Foo.Bucket`. Also, `Foo.Bucket` now only allows data to be shared in `Map` format.
+
+```elixir
+defmodule Foo.Bucket do
+  use Agent
+
+  def start_link(_opts) do
+    Agent.start_link(fn -> %{} end)
+  end
+
+  def get(bucket, key) do
+    Agent.get(bucket, &Map.get(&1, key))
+  end
+
+  def put(bucket, key, value) do
+    Agent.update(bucket, &Map.put(&1, key, value))
+  end
+end
+```
+
+The following are examples of how to delegate access to shared data (provided by an `Agent`) to `Foo.Bucket`.
+
+```elixir
+# start an agent through `Foo.Bucket`
+iex> {:ok, bucket} = Foo.Bucket.start_link(%{})
+{:ok, #PID<0.114.0>}
+
+# add shared values to the keys `milk` and `beer`
+iex> Foo.Bucket.put(bucket, "milk", 3)
+iex> Foo.Bucket.put(bucket, "beer", 7)
+
+# access shared data of specific keys
+iex> Foo.Bucket.get(bucket, "beer")
+7
+iex> Foo.Bucket.get(bucket, "milk")
+3
+```
+
+#### Additional remarks
+
+This anti-pattern was formerly known as [Agent obsession](https://github.com/lucasvegi/Elixir-Code-Smells/tree/main#agent-obsession).
+
+## Sending unnecessary data
+
+#### Problem
+
+Sending a message to a process can be an expensive operation if the message is big enough. That's because that message will be fully copied to the receiving process, which may be CPU and memory intensive. This is due to Erlang's "share nothing" architecture, where each process has its own memory, which simplifies and speeds up garbage collection.
+
+This is more obvious when using `send/2`, `GenServer.call/3`, or the initial data in `GenServer.start_link/3`. Notably this also happens when using `spawn/1`, `Task.async/1`, `Task.async_stream/3`, and so on. It is more subtle here as the anonymous function passed to these functions captures the variables it references, and all captured variables will be copied over. By doing this, you can accidentally send way more data to a process than you actually need.
+
+#### Example
+
+Imagine you were to implement some simple reporting of IP addresses that made requests against your application. You want to do this asynchronously and not block processing, so you decide to use `spawn/1`. It may seem like a good idea to hand over the whole connection because we might need more data later. However passing the connection results in copying a lot of unnecessary data like the request body, params, etc.
+
+```elixir
+# log_request_ip send the ip to some external service
+spawn(fn -> log_request_ip(conn) end)
+```
+
+This problem also occurs when accessing only the relevant parts:
+
+```elixir
+spawn(fn -> log_request_ip(conn.remote_ip) end)
+```
+
+This will still copy over all of `conn`, because the `conn` variable is being captured inside the spawned function. The function then extracts the `remote_ip` field, but only after the whole `conn` has been copied over.
+
+`send/2` and the `GenServer` APIs also rely on message passing. In the example below, the `conn` is once again copied to the underlying `GenServer`:
+
+```elixir
+GenServer.cast(pid, {:report_ip_address, conn})
+```
+
+#### Refactoring
+
+This anti-pattern has many potential remedies:
+
+  * Limit the data you send to the absolute necessary minimum instead of sending an entire struct. For example, don't send an entire `conn` struct if all you need is a couple of fields.
+
+  * If the only process that needs data is the one you are sending to, consider making the process fetch that data instead of passing it.
+
+  * Some abstractions, such as [`:persistent_term`](`:persistent_term`), allows you to share data between processes, as long as such data changes infrequently.
+
+In our case, limiting the input data is a reasonable strategy. If all we need *right now* is the IP address, then let's only work with that and make sure we're only passing the IP address into the closure, like so:
+
+```elixir
+ip_address = conn.remote_ip
+spawn(fn -> log_request_ip(ip_address) end)
+```
+
+Or in the `GenServer` case:
+
+```elixir
+GenServer.cast(pid, {:report_ip_address, conn.remote_ip})
+```
+
+## Unsupervised processes
+
+#### Problem
+
+In Elixir, creating a process outside a supervision tree is not an anti-pattern in itself. However, when you spawn many long-running processes outside of supervision trees, this can make visibility and monitoring of these processes difficult, preventing developers from fully controlling their lifecycle.
+
+#### Example
+
+The following code example seeks to illustrate a library responsible for maintaining a numerical `Counter` through a `Agent` process *outside a supervision tree*.
+
+```elixir
+defmodule Counter do
+  @moduledoc """
+  Global counter implemented as an Agent.
+  """
+
+  use Agent
+
+  @doc "Starts a counter process."
+  def start_link(opts \\ []) do
+    initial_state = Keyword.get(opts, :initial_value, 0)
+    name = Keyword.get(opts, :name, __MODULE__)
+    Agent.start_link(fn -> initial_state end, name: name)
+  end
+
+  @doc "Gets the current value of the given counter."
+  def get(name \\ __MODULE__) do
+    Agent.get(name, fn state -> state end)
+  end
+
+  @doc "Bumps the value of the given counter."
+  def bump(name \\ __MODULE__, value) do
+    Agent.get_and_update(fn state -> {state, value + state} end)
+  end
+end
+```
+
+While it is possible to start the process outside of a supervision tree:
+
+```elixir
+iex> Counter.start_link()
+{:ok, #PID<0.115.0>}
+iex> Counter.bump(13)
+0
+iex> Counter.get()
+13
+```
+
+Such processes are harder to observe and control their lifecycle. For example, if you have other processes that depend on the `Counter` above, you will need ad-hoc mechanisms to make sure they are initialized in order. Furthermore, when your application is shutting down, there is no guarantee when they are terminated.
+
+#### Refactoring
+
+To ensure that clients of a library have full control over their systems, regardless of the number of processes used and the lifetime of each one, all processes must be started inside a supervision tree. As shown below, this code uses a `Supervisor` as a supervision tree.
+
+```elixir
+defmodule SupervisedProcess.Application do
+  use Application
+
+  @impl true
+  def start(_type, _args) do
+    children = [
+      # With the default values for counter and name
+      Counter,
+      # With custom values for counter, name, and a custom ID
+      Supervisor.child_spec(
+        {Counter, name: :other_counter, initial_value: 15},
+        id: :other_counter
+      )
+    ]
+
+    Supervisor.start_link(children, strategy: :one_for_one, name: App.Supervisor)
+  end
+end
+```
+
+Besides having a deterministic order in which processes are started, supervision trees also guarantee they are terminated in reverse order, allowing you to perform any necessary clean up during shut down. Furthermore, supervision strategies allows us to configure exactly how process should act in case of unexpected failures.
+
+Finally, applications and supervision trees can be introspected through applications like the [Phoenix.LiveDashboard](http://github.com/phoenixframework/phoenix_live_dashboard) and [Erlang's built-in observer](https://www.erlang.org/doc/apps/observer/observer_ug):
+
+<img src="assets/kv-observer.png" alt="Observer GUI screenshot" />
diff --git a/lib/elixir/pages/anti-patterns/what-anti-patterns.md b/lib/elixir/pages/anti-patterns/what-anti-patterns.md
new file mode 100644
index 00000000000..b22678a5c61
--- /dev/null
+++ b/lib/elixir/pages/anti-patterns/what-anti-patterns.md
@@ -0,0 +1,48 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# What are anti-patterns?
+
+Anti-patterns describe common mistakes or indicators of problems in code.
+They are also known as "code smells".
+
+The goal of these guides is to document potential anti-patterns found in Elixir software
+and teach developers how to identify them and their pitfalls. If an existing piece
+of code matches an anti-pattern, it does not mean your code must be rewritten.
+Sometimes, even if a snippet matches a potential anti-pattern and its limitations,
+it may be the best approach to the problem at hand. No codebase is free of anti-patterns
+and one should not aim to remove all of them.
+
+The anti-patterns in these guides are broken into 4 main categories:
+
+  * **Code-related anti-patterns:** related to your code and particular
+    language idioms and features;
+
+  * **Design-related anti-patterns:** related to your modules, functions,
+    and the role they play within a codebase;
+
+  * **Process-related anti-patterns:** related to processes and process-based
+    abstractions;
+
+  * **Meta-programming anti-patterns:** related to meta-programming.
+
+Each anti-pattern is documented using the following structure:
+
+  * **Name:** Unique identifier of the anti-pattern. This name is important to facilitate
+    communication between developers;
+
+  * **Problem:** How the anti-pattern can harm code quality and what impacts this can have
+    for developers;
+
+  * **Example:** Code and textual descriptions to illustrate the occurrence of the anti-pattern;
+
+  * **Refactoring:** Ways to change your code to improve its qualities. Examples of refactored
+    code are presented to illustrate these changes.
+
+An additional section with "Additional Remarks" may be provided. Those may include known scenarios where the anti-pattern does not apply.
+
+The initial catalog of anti-patterns was proposed by Lucas Vegi and Marco Tulio Valente, from [ASERG/DCC/UFMG](http://aserg.labsoft.dcc.ufmg.br/). For more info, see [Understanding Code Smells in Elixir Functional Language](https://github.com/lucasvegi/Elixir-Code-Smells/blob/main/etc/2023-emse-code-smells-elixir.pdf) and [the associated code repository](https://github.com/lucasvegi/Elixir-Code-Smells).
+
+Additionally, the Security Working Group of the [Erlang Ecosystem Foundation](https://security.erlef.org) publishes [documents with security resources and best-practices of both Erlang and Elixir, including detailed guides for web applications](https://security.erlef.org).
diff --git a/lib/elixir/pages/cheatsheets/enum-cheat.cheatmd b/lib/elixir/pages/cheatsheets/enum-cheat.cheatmd
new file mode 100644
index 00000000000..1dfaa6cd8ce
--- /dev/null
+++ b/lib/elixir/pages/cheatsheets/enum-cheat.cheatmd
@@ -0,0 +1,1058 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Enum cheatsheet
+
+A quick reference into the `Enum` module, a module for working with collections (known as enumerables). Most of the examples below use the following data structure:
+
+```elixir
+cart = [
+  %{fruit: "apple", count: 3},
+  %{fruit: "banana", count: 1},
+  %{fruit: "orange", count: 6}
+]
+```
+
+Some examples use the [`string =~ part`](`=~/2`) operator, which checks the string on the left contains the part on the right.
+
+## Predicates
+{: .col-2}
+
+### [`any?(enum, fun)`](`Enum.any?/2`)
+
+```elixir
+iex> Enum.any?(cart, & &1.fruit == "orange")
+true
+iex> Enum.any?(cart, & &1.fruit == "pear")
+false
+```
+
+`any?` with an empty collection is always false:
+
+```elixir
+iex> Enum.any?([], & &1.fruit == "orange")
+false
+```
+
+### [`all?(enum, fun)`](`Enum.all?/2`)
+
+```elixir
+iex> Enum.all?(cart, & &1.count > 0)
+true
+iex> Enum.all?(cart, & &1.count > 1)
+false
+```
+
+`all?` with an empty collection is always true:
+
+```elixir
+iex> Enum.all?([], & &1.count > 0)
+true
+```
+
+### [`member?(enum, value)`](`Enum.member?/2`)
+
+```elixir
+iex> Enum.member?(cart, %{fruit: "apple", count: 3})
+true
+iex> Enum.member?(cart, :something_else)
+false
+```
+
+`item in enum` is equivalent to `Enum.member?(enum, item)`:
+
+```elixir
+iex> %{fruit: "apple", count: 3} in cart
+true
+iex> :something_else in cart
+false
+```
+
+### [`empty?(enum)`](`Enum.empty?/1`)
+
+```elixir
+iex> Enum.empty?(cart)
+false
+iex> Enum.empty?([])
+true
+```
+
+## Filtering
+{: .col-2}
+
+### [`filter(enum, fun)`](`Enum.filter/2`)
+
+```elixir
+iex> Enum.filter(cart, &(&1.fruit =~ "o"))
+[%{fruit: "orange", count: 6}]
+iex> Enum.filter(cart, &(&1.fruit =~ "e"))
+[
+  %{fruit: "apple", count: 3},
+  %{fruit: "orange", count: 6}
+]
+```
+
+### [`reject(enum, fun)`](`Enum.reject/2`)
+
+```elixir
+iex> Enum.reject(cart, &(&1.fruit =~ "o"))
+[
+  %{fruit: "apple", count: 3},
+  %{fruit: "banana", count: 1}
+]
+```
+
+### [`flat_map(enum, fun)`](`Enum.flat_map/2`)
+
+This function (also listed [below](#concatenating-flattening)) can
+be used to transform and filter in one pass, returning empty lists
+to exclude results:
+
+```elixir
+iex> Enum.flat_map(cart, fn item ->
+...>   if item.count > 1, do: [item.fruit], else: []
+...> end)
+["apple", "orange"]
+```
+
+### [`Comprehension`](`for/1`)
+
+Filtering can also be done with comprehensions:
+
+```elixir
+iex> for item <- cart, item.fruit =~ "e" do
+...>   item
+...> end
+[
+  %{fruit: "apple", count: 3},
+  %{fruit: "orange", count: 6}
+]
+```
+
+Pattern-matching in comprehensions acts as a filter as well:
+
+```elixir
+iex> for %{count: 1, fruit: fruit} <- cart do
+...>   fruit
+...> end
+["banana"]
+```
+
+## Mapping
+{: .col-2}
+
+### [`map(enum, fun)`](`Enum.map/2`)
+
+```elixir
+iex> Enum.map(cart, & &1.fruit)
+["apple", "banana", "orange"]
+iex> Enum.map(cart, fn item ->
+...>   %{item | count: item.count + 10}
+...> end)
+[
+  %{fruit: "apple", count: 13},
+  %{fruit: "banana", count: 11},
+  %{fruit: "orange", count: 16}
+]
+```
+
+### [`map_every(enum, nth, fun)`](`Enum.map_every/3`)
+
+```elixir
+iex> Enum.map_every(cart, 2, fn item ->
+...>   %{item | count: item.count + 10}
+...> end)
+[
+  %{fruit: "apple", count: 13},
+  %{fruit: "banana", count: 1},
+  %{fruit: "orange", count: 16}
+]
+```
+
+### [`Comprehension`](`for/1`)
+
+Mapping can also be done with comprehensions:
+
+```elixir
+iex> for item <- cart do
+...>   item.fruit
+...> end
+["apple", "banana", "orange"]
+```
+
+You can also filter and map at once:
+
+```elixir
+iex> for item <- cart, item.fruit =~ "e" do
+...>   item.fruit
+...> end
+["apple", "orange"]
+```
+
+## Side-effects
+{: .col-2}
+
+### [`each(enum, fun)`](`Enum.each/2`)
+
+```elixir
+iex> Enum.each(cart, &IO.puts(&1.fruit))
+apple
+banana
+orange
+:ok
+```
+
+`Enum.each/2` is used exclusively for side-effects.
+
+## Accumulating
+{: .col-2}
+
+### [`reduce(enum, acc, fun)`](`Enum.reduce/3`)
+
+```elixir
+iex> Enum.reduce(cart, 0, fn item, acc ->
+...>   item.count + acc
+...> end)
+10
+```
+
+### [`map_reduce(enum, acc, fun)`](`Enum.map_reduce/3`)
+
+```elixir
+iex> Enum.map_reduce(cart, 0, fn item, acc ->
+...>   {item.fruit, item.count + acc}
+...> end)
+{["apple", "banana", "orange"], 10}
+```
+
+### [`scan(enum, acc, fun)`](`Enum.scan/3`)
+
+```elixir
+iex> Enum.scan(cart, 0, fn item, acc ->
+...>   item.count + acc
+...> end)
+[3, 4, 10]
+```
+
+### [`reduce_while(enum, acc, fun)`](`Enum.reduce_while/3`)
+
+```elixir
+iex> Enum.reduce_while(cart, 0, fn item, acc ->
+...>   if item.fruit == "orange" do
+...>     {:halt, acc}
+...>   else
+...>     {:cont, item.count + acc}
+...>   end
+...> end)
+4
+```
+
+### [`Comprehension`](`for/1`)
+
+Reducing can also be done with comprehensions:
+
+```elixir
+iex> for item <- cart, reduce: 0 do
+...>   acc -> item.count + acc
+...> end
+10
+```
+
+You can also filter and reduce at once:
+
+```elixir
+iex> for item <- cart, item.fruit =~ "e", reduce: 0 do
+...>   acc -> item.count + acc
+...> end
+9
+```
+
+## Aggregations
+{: .col-2}
+
+### [`count(enum)`](`Enum.count/1`)
+
+```elixir
+iex> Enum.count(cart)
+3
+```
+
+See `Enum.count_until/2` to count until a limit.
+
+### [`frequencies(enum)`](`Enum.frequencies/1`)
+
+```elixir
+iex> Enum.frequencies(["apple", "banana", "orange", "apple"])
+%{"apple" => 2, "banana" => 1, "orange" => 1}
+```
+
+### [`frequencies_by(enum, key_fun)`](`Enum.frequencies_by/2`)
+
+Frequencies of the last letter of the fruit:
+
+```elixir
+iex> Enum.frequencies_by(cart, &String.last(&1.fruit))
+%{"a" => 1, "e" => 2}
+```
+
+### [`count(enum, fun)`](`Enum.count/2`)
+
+```elixir
+iex> Enum.count(cart, &(&1.fruit =~ "e"))
+2
+iex> Enum.count(cart, &(&1.fruit =~ "y"))
+0
+```
+
+See `Enum.count_until/3` to count until a limit with a function.
+
+### [`sum(enum)`](`Enum.sum/1`)
+
+```elixir
+iex> cart |> Enum.map(& &1.count) |> Enum.sum()
+10
+```
+
+Note: this should typically be done in one pass using `Enum.sum_by/2`.
+
+### [`sum_by(enum, mapper)`](`Enum.sum_by/2`)
+
+```elixir
+iex> Enum.sum_by(cart, & &1.count)
+10
+```
+
+### [`product(enum)`](`Enum.product/1`)
+
+```elixir
+iex> cart |> Enum.map(& &1.count) |> Enum.product()
+18
+```
+
+Note: this should typically be done in one pass using `Enum.product_by/2`.
+
+### [`product_by(enum, mapper)`](`Enum.product_by/2`)
+
+```elixir
+iex> Enum.product_by(cart, & &1.count)
+18
+```
+
+## Sorting
+{: .col-2}
+
+### [`sort(enum, sorter \\ :asc)`](`Enum.sort/2`)
+
+```elixir
+iex> cart |> Enum.map(& &1.fruit) |> Enum.sort()
+["apple", "banana", "orange"]
+iex> cart |> Enum.map(& &1.fruit) |> Enum.sort(:desc)
+["orange", "banana", "apple"]
+```
+
+When sorting structs, use `Enum.sort/2` with a module as sorter.
+
+### [`sort_by(enum, mapper, sorter \\ :asc)`](`Enum.sort_by/2`)
+
+```elixir
+iex> Enum.sort_by(cart, & &1.count)
+[
+  %{fruit: "banana", count: 1},
+  %{fruit: "apple", count: 3},
+  %{fruit: "orange", count: 6}
+]
+iex> Enum.sort_by(cart, & &1.count, :desc)
+[
+  %{fruit: "orange", count: 6},
+  %{fruit: "apple", count: 3},
+  %{fruit: "banana", count: 1}
+]
+```
+
+When the sorted by value is a struct, use `Enum.sort_by/3` with a module as sorter.
+
+### [`min(enum)`](`Enum.min/1`)
+
+```elixir
+iex> cart |> Enum.map(& &1.count) |> Enum.min()
+1
+```
+
+When comparing structs, use `Enum.min/2` with a module as sorter.
+
+### [`min_by(enum, mapper)`](`Enum.min_by/2`)
+
+```elixir
+iex> Enum.min_by(cart, & &1.count)
+%{fruit: "banana", count: 1}
+```
+
+When comparing structs, use `Enum.min_by/3` with a module as sorter.
+
+### [`max(enum)`](`Enum.max/1`)
+
+```elixir
+iex> cart |> Enum.map(& &1.count) |> Enum.max()
+6
+```
+
+When comparing structs, use `Enum.max/2` with a module as sorter.
+
+### [`max_by(enum, mapper)`](`Enum.max_by/2`)
+
+```elixir
+iex> Enum.max_by(cart, & &1.count)
+%{fruit: "orange", count: 6}
+```
+
+When comparing structs, use `Enum.max_by/3` with a module as sorter.
+
+## Concatenating & flattening
+{: .col-2}
+
+### [`concat(enums)`](`Enum.concat/1`)
+
+```elixir
+iex> Enum.concat([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+[1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+### [`concat(left, right)`](`Enum.concat/2`)
+
+```elixir
+iex> Enum.concat([1, 2, 3], [4, 5, 6])
+[1, 2, 3, 4, 5, 6]
+```
+
+### [`flat_map(enum, fun)`](`Enum.flat_map/2`)
+
+```elixir
+iex> Enum.flat_map(cart, fn item ->
+...>   List.duplicate(item.fruit, item.count)
+...> end)
+["apple", "apple", "apple", "banana", "orange",
+ "orange", "orange", "orange", "orange", "orange"]
+```
+
+### [`flat_map_reduce(enum, acc, fun)`](`Enum.flat_map_reduce/3`)
+
+```elixir
+iex> Enum.flat_map_reduce(cart, 0, fn item, acc ->
+...>   list = List.duplicate(item.fruit, item.count)
+...>   acc = acc + item.count
+...>   {list, acc}
+...> end)
+{["apple", "apple", "apple", "banana", "orange",
+  "orange", "orange", "orange", "orange", "orange"], 10}
+```
+
+### [`Comprehension`](`for/1`)
+
+Flattening can also be done with comprehensions:
+
+```elixir
+iex> for item <- cart,
+...>     fruit <- List.duplicate(item.fruit, item.count) do
+...>   fruit
+...> end
+["apple", "apple", "apple", "banana", "orange",
+ "orange", "orange", "orange", "orange", "orange"]
+```
+
+## Conversion
+{: .col-2}
+
+### [`into(enum, collectable)`](`Enum.into/2`)
+
+```elixir
+iex> pairs = [{"apple", 3}, {"banana", 1}, {"orange", 6}]
+iex> Enum.into(pairs, %{})
+%{"apple" => 3, "banana" => 1, "orange" => 6}
+```
+
+### [`into(enum, collectable, transform)`](`Enum.into/3`)
+
+```elixir
+iex> Enum.into(cart, %{}, fn item ->
+...>   {item.fruit, item.count}
+...> end)
+%{"apple" => 3, "banana" => 1, "orange" => 6}
+```
+
+### [`to_list(enum)`](`Enum.to_list/1`)
+
+```elixir
+iex> Enum.to_list(1..5)
+[1, 2, 3, 4, 5]
+```
+
+### [`Comprehension`](`for/1`)
+
+Conversion can also be done with comprehensions:
+
+```elixir
+iex> for item <- cart, into: %{} do
+...>   {item.fruit, item.count}
+...> end
+%{"apple" => 3, "banana" => 1, "orange" => 6}
+```
+
+## Duplicates & uniques
+{: .col-2}
+
+### [`dedup(enum)`](`Enum.dedup/1`)
+
+`dedup` only removes contiguous duplicates:
+
+```elixir
+iex> Enum.dedup([1, 2, 2, 3, 3, 3, 1, 2, 3])
+[1, 2, 3, 1, 2, 3]
+```
+
+### [`dedup_by(enum, fun)`](`Enum.dedup_by/2`)
+
+Remove contiguous entries given a property:
+
+```elixir
+iex> Enum.dedup_by(cart, & &1.fruit =~ "a")
+[%{fruit: "apple", count: 3}]
+iex> Enum.dedup_by(cart, & &1.count < 5)
+[
+  %{fruit: "apple", count: 3},
+  %{fruit: "orange", count: 6}
+]
+```
+
+### [`uniq(enum)`](`Enum.uniq/1`)
+
+`uniq` applies to the whole collection:
+
+```elixir
+iex> Enum.uniq([1, 2, 2, 3, 3, 3, 1, 2, 3])
+[1, 2, 3]
+```
+
+Comprehensions also support the `uniq: true` option.
+
+### [`uniq_by(enum, fun)`](`Enum.uniq_by/2`)
+
+Get entries which are unique by the last letter of the fruit:
+
+```elixir
+iex> Enum.uniq_by(cart, &String.last(&1.fruit))
+[
+  %{fruit: "apple", count: 3},
+  %{fruit: "banana", count: 1}
+]
+```
+
+## Indexing
+{: .col-2}
+
+### [`at(enum, index, default \\ nil)`](`Enum.at/2`)
+
+```elixir
+iex> Enum.at(cart, 0)
+%{fruit: "apple", count: 3}
+iex> Enum.at(cart, 10)
+nil
+iex> Enum.at(cart, 10, :none)
+:none
+```
+
+Accessing a list by index in a loop is discouraged.
+
+### [`fetch(enum, index)`](`Enum.fetch/2`)
+
+```elixir
+iex> Enum.fetch(cart, 0)
+{:ok, %{fruit: "apple", count: 3}}
+iex> Enum.fetch(cart, 10)
+:error
+```
+
+### [`fetch!(enum, index)`](`Enum.fetch!/2`)
+
+```elixir
+iex> Enum.fetch!(cart, 0)
+%{fruit: "apple", count: 3}
+iex> Enum.fetch!(cart, 10)
+** (Enum.OutOfBoundsError) out of bounds error
+```
+
+### [`with_index(enum)`](`Enum.with_index/1`)
+
+```elixir
+iex> Enum.with_index(cart)
+[
+  {%{fruit: "apple", count: 3}, 0},
+  {%{fruit: "banana", count: 1}, 1},
+  {%{fruit: "orange", count: 6}, 2}
+]
+```
+
+### [`with_index(enum, fun)`](`Enum.with_index/2`)
+
+```elixir
+iex> Enum.with_index(cart, fn item, index ->
+...>   {item.fruit, index}
+...> end)
+[
+  {"apple", 0},
+  {"banana", 1},
+  {"orange", 2}
+]
+```
+
+## Finding
+{: .col-2}
+
+### [`find(enum, default \\ nil, fun)`](`Enum.find/2`)
+
+```elixir
+iex> Enum.find(cart, &(&1.fruit =~ "o"))
+%{fruit: "orange", count: 6}
+iex> Enum.find(cart, &(&1.fruit =~ "y"))
+nil
+iex> Enum.find(cart, :none, &(&1.fruit =~ "y"))
+:none
+```
+
+### [`find_index(enum, fun)`](`Enum.find_index/2`)
+
+```elixir
+iex> Enum.find_index(cart, &(&1.fruit =~ "o"))
+2
+iex> Enum.find_index(cart, &(&1.fruit =~ "y"))
+nil
+```
+
+### [`find_value(enum, default \\ nil, fun)`](`Enum.find_value/2`)
+
+```elixir
+iex> Enum.find_value(cart, fn item ->
+...>   if item.count == 1, do: item.fruit, else: nil
+...> end)
+"banana"
+iex> Enum.find_value(cart, :none, fn item ->
+...>   if item.count == 100, do: item.fruit, else: nil
+...> end)
+:none
+```
+
+## Grouping
+{: .col-2}
+
+### [`group_by(enum, key_fun)`](`Enum.group_by/2`)
+
+Group by the last letter of the fruit:
+
+```elixir
+iex> Enum.group_by(cart, &String.last(&1.fruit))
+%{
+  "a" => [%{fruit: "banana", count: 1}],
+  "e" => [
+    %{fruit: "apple", count: 3},
+    %{fruit: "orange", count: 6}
+  ]
+}
+```
+
+### [`group_by(enum, key_fun, value_fun)`](`Enum.group_by/3`)
+
+Group by the last letter of the fruit with custom value:
+
+```elixir
+iex> Enum.group_by(cart, &String.last(&1.fruit), & &1.fruit)
+%{
+  "a" => ["banana"],
+  "e" => ["apple", "orange"]
+}
+```
+
+## Joining & interspersing
+{: .col-2}
+
+### [`join(enum, joiner \\ "")`](`Enum.join/2`)
+
+```elixir
+iex> Enum.join(["apple", "banana", "orange"], ", ")
+"apple, banana, orange"
+```
+
+### [`map_join(enum, joiner \\ "", mapper)`](`Enum.map_join/3`)
+
+```elixir
+iex> Enum.map_join(cart, ", ", & &1.fruit)
+"apple, banana, orange"
+```
+
+### [`intersperse(enum, separator \\ "")`](`Enum.intersperse/2`)
+
+```elixir
+iex> Enum.intersperse(["apple", "banana", "orange"], ", ")
+["apple", ", ", "banana", ", ", "orange"]
+```
+
+### [`map_intersperse(enum, separator \\ "", mapper)`](`Enum.map_intersperse/3`)
+
+```elixir
+iex> Enum.map_intersperse(cart, ", ", & &1.fruit)
+["apple", ", ", "banana", ", ", "orange"]
+```
+
+## Slicing
+{: .col-2}
+
+### [`slice(enum, index_range)`](`Enum.slice/2`)
+
+```elixir
+iex> Enum.slice(cart, 0..1)
+[
+  %{fruit: "apple", count: 3},
+  %{fruit: "banana", count: 1}
+]
+```
+
+Negative ranges count from the back:
+
+```elixir
+iex> Enum.slice(cart, -2..-1)
+[
+  %{fruit: "banana", count: 1},
+  %{fruit: "orange", count: 6}
+]
+```
+
+### [`slice(enum, start_index, amount)`](`Enum.slice/3`)
+
+```elixir
+iex> Enum.slice(cart, 1, 2)
+[
+  %{fruit: "banana", count: 1},
+  %{fruit: "orange", count: 6}
+]
+```
+
+### [`slide(enum, range_or_single_index, insertion_index)`](`Enum.slide/3`)
+
+```elixir
+fruits = ["apple", "banana", "grape", "orange", "pear"]
+iex> Enum.slide(fruits, 2, 0)
+["grape", "apple", "banana", "orange", "pear"]
+iex> Enum.slide(fruits, 2, 4)
+["apple", "banana", "orange", "pear", "grape"]
+iex> Enum.slide(fruits, 1..3, 0)
+["banana", "grape", "orange", "apple", "pear"]
+iex> Enum.slide(fruits, 1..3, 4)
+["apple", "pear", "banana", "grape", "orange"]
+```
+
+## Reversing
+{: .col-2}
+
+### [`reverse(enum)`](`Enum.reverse/1`)
+
+```elixir
+iex> Enum.reverse(cart)
+[
+  %{fruit: "orange", count: 6},
+  %{fruit: "banana", count: 1},
+  %{fruit: "apple", count: 3}
+]
+```
+
+### [`reverse(enum, tail)`](`Enum.reverse/2`)
+
+```elixir
+iex> Enum.reverse(cart, [:this_will_be, :the_tail])
+[
+  %{fruit: "orange", count: 6},
+  %{fruit: "banana", count: 1},
+  %{fruit: "apple", count: 3},
+  :this_will_be,
+  :the_tail
+]
+```
+
+### [`reverse_slice(enum, start_index, count)`](`Enum.reverse_slice/3`)
+
+```elixir
+iex> Enum.reverse_slice(cart, 1, 2)
+[
+  %{fruit: "apple", count: 3},
+  %{fruit: "orange", count: 6},
+  %{fruit: "banana", count: 1}
+]
+```
+
+## Splitting
+{: .col-2}
+
+### [`split(enum, amount)`](`Enum.split/2`)
+
+```elixir
+iex> Enum.split(cart, 1)
+{[%{fruit: "apple", count: 3}],
+ [
+   %{fruit: "banana", count: 1},
+   %{fruit: "orange", count: 6}
+ ]}
+```
+
+Negative indexes count from the back:
+
+```elixir
+iex> Enum.split(cart, -1)
+{[
+  %{fruit: "apple", count: 3},
+  %{fruit: "banana", count: 1}
+ ],
+ [%{fruit: "orange", count: 6}]}
+```
+
+### [`split_while(enum, fun)`](`Enum.split_while/2`)
+
+Stops splitting as soon as it is false:
+
+```elixir
+iex> Enum.split_while(cart, &(&1.fruit =~ "e"))
+{[%{fruit: "apple", count: 3}],
+ [
+   %{fruit: "banana", count: 1},
+   %{fruit: "orange", count: 6}
+ ]}
+```
+
+### [`split_with(enum, fun)`](`Enum.split_with/2`)
+
+Splits the whole collection:
+
+```elixir
+iex> Enum.split_with(cart, &(&1.fruit =~ "e"))
+{[
+  %{fruit: "apple", count: 3},
+  %{fruit: "orange", count: 6}
+ ],
+ [%{fruit: "banana", count: 1}]}
+```
+
+## Splitting (drop and take)
+{: .col-2}
+
+### [`drop(enum, amount)`](`Enum.drop/2`)
+
+```elixir
+iex> Enum.drop(cart, 1)
+[
+  %{fruit: "banana", count: 1},
+  %{fruit: "orange", count: 6}
+]
+```
+
+Negative indexes count from the back:
+
+```elixir
+iex> Enum.drop(cart, -1)
+[
+  %{fruit: "apple", count: 3},
+  %{fruit: "banana", count: 1}
+]
+```
+
+### [`drop_every(enum, nth)`](`Enum.drop_every/2`)
+
+```elixir
+iex> Enum.drop_every(cart, 2)
+[%{fruit: "banana", count: 1}]
+```
+
+### [`drop_while(enum, fun)`](`Enum.drop_while/2`)
+
+```elixir
+iex> Enum.drop_while(cart, &(&1.fruit =~ "e"))
+[
+  %{fruit: "banana", count: 1},
+  %{fruit: "orange", count: 6}
+]
+```
+
+### [`take(enum, amount)`](`Enum.take/2`)
+
+```elixir
+iex> Enum.take(cart, 1)
+[%{fruit: "apple", count: 3}]
+```
+
+Negative indexes count from the back:
+
+```elixir
+iex> Enum.take(cart, -1)
+[%{fruit: "orange", count: 6}]
+```
+
+### [`take_every(enum, nth)`](`Enum.take_every/2`)
+
+```elixir
+iex> Enum.take_every(cart, 2)
+[
+  %{fruit: "apple", count: 3},
+  %{fruit: "orange", count: 6}
+]
+```
+
+### [`take_while(enum, fun)`](`Enum.take_while/2`)
+
+```elixir
+iex> Enum.take_while(cart, &(&1.fruit =~ "e"))
+[%{fruit: "apple", count: 3}]
+```
+
+## Random
+{: .col-2}
+
+### [`random(enum)`](`Enum.random/1`)
+
+Results will vary on every call:
+
+```elixir
+iex> Enum.random(cart)
+%{fruit: "orange", count: 6}
+```
+
+### [`take_random(enum, count)`](`Enum.take_random/2`)
+
+Results will vary on every call:
+
+```elixir
+iex> Enum.take_random(cart, 2)
+[
+  %{fruit: "orange", count: 6},
+  %{fruit: "apple", count: 3}
+]
+```
+
+### [`shuffle(enum)`](`Enum.shuffle/1`)
+
+Results will vary on every call:
+
+```elixir
+iex> Enum.shuffle(cart)
+[
+  %{fruit: "orange", count: 6},
+  %{fruit: "apple", count: 3},
+  %{fruit: "banana", count: 1}
+]
+```
+
+## Chunking
+{: .col-2}
+
+### [`chunk_by(enum, fun)`](`Enum.chunk_by/2`)
+
+```elixir
+iex> Enum.chunk_by(cart, &String.length(&1.fruit))
+[
+  [%{fruit: "apple", count: 3}],
+  [
+    %{fruit: "banana", count: 1},
+    %{fruit: "orange", count: 6}
+  ]
+]
+```
+
+### [`chunk_every(enum, count)`](`Enum.chunk_every/2`)
+
+```elixir
+iex> Enum.chunk_every(cart, 2)
+[
+  [
+    %{fruit: "apple", count: 3},
+    %{fruit: "banana", count: 1}
+  ],
+  [%{fruit: "orange", count: 6}]
+]
+```
+
+### [`chunk_every(enum, count, step, leftover \\ [])`](`Enum.chunk_every/2`)
+
+```elixir
+iex> Enum.chunk_every(cart, 2, 2, [:elements, :to_complete])
+[
+  [
+    %{fruit: "apple", count: 3},
+    %{fruit: "banana", count: 1}
+  ],
+  [
+    %{fruit: "orange", count: 6},
+    :elements
+  ]
+]
+iex> Enum.chunk_every(cart, 2, 1, :discard)
+[
+  [
+    %{fruit: "apple", count: 3},
+    %{fruit: "banana", count: 1}
+  ],
+  [
+    %{fruit: "banana", count: 1},
+    %{fruit: "orange", count: 6}
+  ]
+]
+```
+
+See `Enum.chunk_while/4` for custom chunking.
+
+## Zipping
+{: .col-2}
+
+### [`zip(enum1, enum2)`](`Enum.zip/2`)
+
+```elixir
+iex> fruits = ["apple", "banana", "orange"]
+iex> counts = [3, 1, 6]
+iex> Enum.zip(fruits, counts)
+[{"apple", 3}, {"banana", 1}, {"orange", 6}]
+```
+
+See `Enum.zip/1` for zipping many collections at once.
+
+### [`zip_with(enum1, enum2, fun)`](`Enum.zip_with/2`)
+
+```elixir
+iex> fruits = ["apple", "banana", "orange"]
+iex> counts = [3, 1, 6]
+iex> Enum.zip_with(fruits, counts, fn fruit, count ->
+...>   %{fruit: fruit, count: count}
+...> end)
+[
+  %{fruit: "apple", count: 3},
+  %{fruit: "banana", count: 1},
+  %{fruit: "orange", count: 6}
+]
+```
+
+See `Enum.zip_with/2` for zipping many collections at once.
+
+### [`zip_reduce(left, right, acc, fun)`](`Enum.zip_reduce/4`)
+
+```elixir
+iex> fruits = ["apple", "banana", "orange"]
+iex> counts = [3, 1, 6]
+iex> Enum.zip_reduce(fruits, counts, 0, fn fruit, count, acc ->
+...>   price = if fruit =~ "e", do: count * 2, else: count
+...>   acc + price
+...> end)
+19
+```
+
+See `Enum.zip_reduce/3` for zipping many collections at once.
+
+### [`unzip(list)`](`Enum.unzip/1`)
+
+```elixir
+iex> cart |> Enum.map(&{&1.fruit, &1.count}) |> Enum.unzip()
+{["apple", "banana", "orange"], [3, 1, 6]}
+```
diff --git a/lib/elixir/pages/cheatsheets/types-cheat.cheatmd b/lib/elixir/pages/cheatsheets/types-cheat.cheatmd
new file mode 100644
index 00000000000..0b60cd1808b
--- /dev/null
+++ b/lib/elixir/pages/cheatsheets/types-cheat.cheatmd
@@ -0,0 +1,188 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2025 The Elixir Team
+-->
+
+# Set-theoretic types cheatsheet
+
+## Set operators
+
+#### Union
+
+```elixir
+type1 or type2
+```
+
+#### Intersection
+
+```elixir
+type1 and type2
+```
+
+#### Difference
+
+```elixir
+type1 and not type2
+```
+
+#### Negation
+
+```elixir
+not type
+```
+
+## Data types
+
+### Indivisible types
+
+```elixir
+binary()
+empty_list()
+integer()
+float()
+pid()
+port()
+reference()
+```
+
+### Atoms
+
+#### All atoms
+
+```elixir
+atom()
+```
+
+#### Individual atoms
+
+```elixir
+:ok
+:error
+SomeModule
+```
+
+### Functions
+
+#### All functions
+
+```elixir
+function()
+```
+
+#### `n`-arity functions
+
+```elixir
+(-> :ok)
+(integer() -> boolean())
+(binary(), binary() -> binary())
+```
+
+#### Multiple clauses
+
+```elixir
+(integer() -> binary()) and (binary() -> atom())
+```
+
+### Maps
+
+#### All maps
+
+```elixir
+map()
+```
+
+#### Empty map
+
+```elixir
+empty_map()
+```
+
+#### Maps with atom keys
+
+```elixir
+# Only has the keys name and age
+%{name: binary(), age: integer()}
+
+# Has the name key and age is optional
+%{name: binary(), age: if_set(integer())}
+
+# Has the keys name and age and may have other keys (open map)
+%{..., name: binary(), age: integer()}
+
+# Has the key name, may have other keys, but age is not set
+%{..., name: binary(), age: not_set()}
+```
+
+#### Maps with domain keys (domain keys are always treated as optional)
+
+```elixir
+# Has atom and binary keys
+%{atom() => binary(), binary() => binary()}
+
+# Has atom and binary keys and may have other keys (open map)
+%{..., atom() => binary(), binary() => binary()}
+```
+
+#### Maps with mixed keys
+
+```elixir
+# Has atom keys with binary values but a `:root` key of type integer
+%{atom() => binary(), root: integer()}
+
+# Has atom keys with binary values but a `:root` key of type integer, and may have other keys
+%{..., atom() => binary(), root: integer()}
+```
+
+#### Domain keys are `atom()`, `binary()`, `integer()`, `float()`, `fun()`, `list()`, `map()`, `pid()`, `port()`, `reference()`, `tuple()`
+
+### Non-empty lists
+
+#### Proper lists
+
+```elixir
+non_empty_list(elem_type)
+```
+
+#### Improper lists (as long as `tail_type` does not include lists)
+
+```elixir
+non_empty_list(elem_type, tail_type)
+```
+
+### Tuples
+
+#### All tuples
+
+```elixir
+tuple()
+```
+
+#### n-element tuples
+
+```elixir
+{:ok, binary()}
+{:error, binary(), term()}
+{pid(), reference()}
+```
+
+#### At least n-element tuples
+
+```
+{binary(), binary(), ...}
+```
+
+## Additional types for convenience
+
+#### Booleans
+
+```elixir
+boolean() = true or false
+```
+
+#### Lists
+
+```elixir
+list() = empty_list() or non_empty_list(term())
+list(a) = empty_list() or non_empty_list(a)
+list(a, b) = empty_list() or non_empty_list(a, b)
+```
\ No newline at end of file
diff --git a/lib/elixir/pages/getting-started/alias-require-and-import.md b/lib/elixir/pages/getting-started/alias-require-and-import.md
new file mode 100644
index 00000000000..31d1564960e
--- /dev/null
+++ b/lib/elixir/pages/getting-started/alias-require-and-import.md
@@ -0,0 +1,167 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# alias, require, import, and use
+
+In order to facilitate software reuse, Elixir provides three directives (`alias`, `require`, and `import`) plus a macro called `use` summarized below:
+
+```elixir
+# Alias the module so it can be called as Bar instead of Foo.Bar
+alias Foo.Bar, as: Bar
+
+# Require the module in order to use its macros
+require Foo
+
+# Import functions from Foo so they can be called without the `Foo.` prefix
+import Foo
+
+# Invokes the custom code defined in Foo as an extension point
+use Foo
+```
+
+We are going to explore them in detail now. Keep in mind the first three are called directives because they have *lexical scope*, while `use` is a common extension point that allows the used module to inject code.
+
+## alias
+
+`alias` allows you to set up aliases for any given module name.
+
+Imagine a module uses a specialized list implemented in `Math.List`. The `alias` directive allows referring to `Math.List` just as `List` within the module definition:
+
+```elixir
+defmodule Stats do
+  alias Math.List, as: List
+  # In the remaining module definition List expands to Math.List.
+end
+```
+
+The original `List` can still be accessed within `Stats` by the fully-qualified name `Elixir.List`.
+
+> All modules defined in Elixir are defined inside the main `Elixir` namespace, such as `Elixir.String`. However, for convenience, you can omit "Elixir." when referencing them.
+
+Aliases are frequently used to define shortcuts. In fact, calling `alias` without an `:as` option sets the alias automatically to the last part of the module name, for example:
+
+```elixir
+alias Math.List
+```
+
+Is the same as:
+
+```elixir
+alias Math.List, as: List
+```
+
+Note that `alias` is *lexically scoped*, which allows you to set aliases inside specific functions:
+
+```elixir
+defmodule Math do
+  def plus(a, b) do
+    alias Math.List
+    # ...
+  end
+
+  def minus(a, b) do
+    # ...
+  end
+end
+```
+
+In the example above, since we are invoking `alias` inside the function `plus/2`, the alias will be valid only inside the function `plus/2`. `minus/2` won't be affected at all.
+
+## require
+
+Elixir provides macros as a mechanism for meta-programming (writing code that generates code). Macros are expanded at compile time.
+
+Public functions in modules are globally available, but in order to use macros, you need to opt-in by requiring the module they are defined in.
+
+```elixir
+iex> Integer.is_odd(3)
+** (UndefinedFunctionError) function Integer.is_odd/1 is undefined or private. However, there is a macro with the same name and arity. Be sure to require Integer if you intend to invoke this macro
+    (elixir) Integer.is_odd(3)
+iex> require Integer
+Integer
+iex> Integer.is_odd(3)
+true
+```
+
+In Elixir, `Integer.is_odd/1` is defined as a macro so that it can be used as a guard. This means that, in order to invoke `Integer.is_odd/1`, we need to first require the `Integer` module.
+
+Note that like the `alias` directive, `require` is also lexically scoped. We will talk more about macros in a later chapter.
+
+## import
+
+We use `import` whenever we want to access functions or macros from other modules without using the fully-qualified name. Note we can only import public functions, as private functions are never accessible externally.
+
+For example, if we want to use the `duplicate/2` function from the `List` module several times, we can import it:
+
+```elixir
+iex> import List, only: [duplicate: 2]
+List
+iex> duplicate(:ok, 3)
+[:ok, :ok, :ok]
+```
+
+We imported only the function `duplicate` (with arity 2) from `List`. Although `:only` is optional, its usage is recommended in order to avoid importing all the functions of a given module inside the current scope. `:except` could also be given as an option in order to import everything in a module except a list of functions.
+
+Note that `import` is *lexically scoped* too. This means that we can import specific macros or functions inside function definitions:
+
+```elixir
+defmodule Math do
+  def some_function do
+    import List, only: [duplicate: 2]
+    duplicate(:ok, 10)
+  end
+end
+```
+
+In the example above, the imported `List.duplicate/2` is only visible within that specific function. `duplicate/2` won't be available in any other function in that module (or any other module for that matter).
+
+While `import`s can be useful for frameworks and libraries to build abstractions, developers should generally prefer `alias` to `import` on their own codebases, as aliases make the origin of the function being invoked clearer.
+
+## use
+
+The `use` macro is frequently used as an extension point. This means that, when you `use` a module `FooBar`, you allow that module to inject *any* code in the current module, such as importing itself or other modules, defining new functions, setting a module state, etc.
+
+For example, in order to write tests using the ExUnit framework, a developer should use the `ExUnit.Case` module:
+
+```elixir
+defmodule AssertionTest do
+  use ExUnit.Case, async: true
+
+  test "always pass" do
+    assert true
+  end
+end
+```
+
+Behind the scenes, `use` requires the given module and then calls the `__using__/1` callback on it allowing the module to inject some code into the current context. Some modules (for example, the above `ExUnit.Case`, but also `Supervisor` and `GenServer`) use this mechanism to populate your module with some basic behaviour, which your module is intended to override or complete.
+
+Generally speaking, the following module:
+
+```elixir
+defmodule Example do
+  use Feature, option: :value
+end
+```
+
+is compiled into
+
+```elixir
+defmodule Example do
+  require Feature
+  Feature.__using__(option: :value)
+end
+```
+
+Since `use` allows any code to run, we can't really know the side-effects of using a module without reading its documentation. Therefore use this function with care and only if strictly required. Don't use `use` where an `import` or `alias` would do.
+
+## Multi alias/import/require/use
+
+It is possible to `alias`, `import`, `require`, or `use` multiple modules at once. This is particularly useful once we start nesting modules, which is very common when building Elixir applications. For example, imagine you have an application where all modules are nested under `MyApp`, you can alias the modules `MyApp.Foo`, `MyApp.Bar` and `MyApp.Baz` at once as follows:
+
+```elixir
+alias MyApp.{Foo, Bar, Baz}
+```
+
+With this, we have finished our tour of Elixir modules.
diff --git a/lib/elixir/pages/getting-started/anonymous-functions.md b/lib/elixir/pages/getting-started/anonymous-functions.md
new file mode 100644
index 00000000000..3192b4b7ee5
--- /dev/null
+++ b/lib/elixir/pages/getting-started/anonymous-functions.md
@@ -0,0 +1,186 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Anonymous functions
+
+Anonymous functions allow us to store and pass executable code around as if it was an integer or a string. Let's learn more.
+
+## Identifying functions and documentation
+
+Before we move on to discuss anonymous functions, let's talk about how Elixir identifies named functions – the functions defined in [modules](modules-and-functions.md).
+
+Functions in Elixir are identified by both their name and their arity. The arity of a function describes the number of arguments that the function takes. From this point on we will use both the function name and its arity to describe functions throughout the documentation. `trunc/1` identifies the function which is named `trunc` and takes `1` argument, whereas `trunc/2` identifies a different (nonexistent) function with the same name but with an arity of `2`.
+
+We can also use this syntax to access documentation. The Elixir shell defines the [`h`](`IEx.Helpers.h/1`) function, which you can use to access documentation for any function. For example, typing `h trunc/1` is going to print the documentation for the `trunc/1` function:
+
+```elixir
+iex> h trunc/1
+                             def trunc(number)
+
+Returns the integer part of number.
+```
+
+`h trunc/1` works because it is defined in the `Kernel` module. All functions in the `Kernel` module are automatically imported into our namespace. Most often you will also include the module name when looking up the documentation for a given function:
+
+```elixir
+iex> h Kernel.trunc/1
+                             def trunc(number)
+
+Returns the integer part of number.
+```
+
+You can use the module+function identifiers to lookup documentation for anything, including operators (try `h Kernel.+/2`). Invoking [`h`](`IEx.Helpers.h/1`) without arguments displays the documentation for `IEx.Helpers`, which is where `h` and other functionalities are defined.
+
+## Defining anonymous functions
+
+Anonymous functions in Elixir are delimited by the keywords `fn` and `end`:
+
+```elixir
+iex> add = fn a, b -> a + b end
+#Function<12.71889879/2 in :erl_eval.expr/5>
+```
+
+In the example above, we defined an anonymous function that receives two arguments, `a` and `b`, and returns the result of `a + b`. The arguments are always on the left-hand side of `->` and the code to be executed on the right-hand side. The anonymous function is stored in the variable `add`. You can see it returns a value represented by `#Function<...>`. While its representation is opaque, the `:erl_eval.expr` bit tells us the function was defined in the shell (during evaluation).
+
+We can invoke anonymous functions by passing arguments to it, using a dot (`.`) between the variable and the opening parenthesis:
+
+```elixir
+iex> add.(1, 2)
+3
+```
+
+The dot makes it clear when you are calling an anonymous function, stored in the variable `add`, opposed to a function named `add/2`. For example, if you have an anonymous function stored in the variable `is_atom`, there is no ambiguity between `is_atom.(:foo)` and `is_atom(:foo)`. If both used the same `is_atom(:foo)` syntax, the only way to know the actual behavior of `is_atom(:foo)` would be by scanning all code thus far for a possible definition of the `is_atom` variable. This scanning hurts maintainability as it requires developers to track additional context in their head when reading and writing code.
+
+Anonymous functions in Elixir are also identified by the number of arguments they receive. We can check if a value is a function using `is_function/1` and also check its arity by using `is_function/2`:
+
+```elixir
+iex> is_function(add)
+true
+# check if add is a function that expects exactly 2 arguments
+iex> is_function(add, 2)
+true
+# check if add is a function that expects exactly 1 argument
+iex> is_function(add, 1)
+false
+```
+
+## Closures
+
+Anonymous functions can also access variables that are in scope when the function is defined. This is typically referred to as closures, as they close over their scope. Let's define a new anonymous function that uses the `add` anonymous function we have previously defined:
+
+```elixir
+iex> double = fn a -> add.(a, a) end
+#Function<6.71889879/1 in :erl_eval.expr/5>
+iex> double.(2)
+4
+```
+
+A variable assigned inside a function does not affect its surrounding environment:
+
+```elixir
+iex> x = 42
+42
+iex> (fn -> x = 0 end).()
+0
+iex> x
+42
+```
+
+## Clauses and guards
+
+Similar to `case/2`, we can pattern match on the arguments of anonymous functions as well as define multiple clauses and guards:
+
+```elixir
+iex> f = fn
+...>   x, y when x > 0 -> x + y
+...>   x, y -> x * y
+...> end
+#Function<12.71889879/2 in :erl_eval.expr/5>
+iex> f.(1, 3)
+4
+iex> f.(-1, 3)
+-3
+```
+
+The number of arguments in each anonymous function clause needs to be the same, otherwise an error is raised.
+
+```elixir
+iex> f2 = fn
+...>   x, y when x > 0 -> x + y
+...>   x, y, z -> x * y + z
+...> end
+** (CompileError) iex:1: cannot mix clauses with different arities in anonymous functions
+```
+
+## The capture operator
+
+Throughout this guide, we have been using the notation `name/arity` to refer to functions. It happens that this notation can actually be used to capture an existing function into a data-type we can pass around, similar to how anonymous functions behave.
+
+```elixir
+iex> fun = &is_atom/1
+&:erlang.is_atom/1
+iex> is_function(fun)
+true
+iex> fun.(:hello)
+true
+iex> fun.(123)
+false
+```
+
+As you can see, once a function is captured, we can pass it as argument or invoke it using the anonymous function notation. The returned value above also hints we can capture functions defined in modules:
+
+```elixir
+iex> fun = &String.length/1
+&String.length/1
+iex> fun.("hello")
+5
+```
+
+Since operators are functions in Elixir, you can also capture operators:
+
+```elixir
+iex> add = &+/2
+&:erlang.+/2
+iex> add.(1, 2)
+3
+```
+
+The capture syntax can also be used as a shortcut for creating functions that wrap existing functions. For example, imagine you want to create an anonymous function that checks if a given function has arity 2. You could write it as:
+
+```elixir
+iex> is_arity_2 = fn fun -> is_function(fun, 2) end
+#Function<8.71889879/1 in :erl_eval.expr/5>
+iex> is_arity_2.(add)
+true
+```
+
+But using the capture syntax, you can write it as:
+
+```elixir
+iex> is_arity_2 = &is_function(&1, 2)
+#Function<8.71889879/1 in :erl_eval.expr/5>
+iex> is_arity_2.(add)
+true
+```
+
+The `&1` represents the first argument passed into the function. Therefore both `is_arity_2` anonymous functions defined above are equivalent.
+
+Once again, given operators are function calls, the capture syntax shorthand also works with operators, or even string interpolation:
+
+```elixir
+iex> fun = &(&1 + 1)
+#Function<6.71889879/1 in :erl_eval.expr/5>
+iex> fun.(1)
+2
+
+iex> fun2 = &"Good #{&1}"
+#Function<6.127694169/1 in :erl_eval.expr/5>
+iex> fun2.("morning")
+"Good morning"
+```
+
+`&(&1 + 1)` above is exactly the same as `fn x -> x + 1 end`. You can read more about the capture operator `&` in [its documentation](`&/1`).
+
+Next let's revisit some of the data-types we learned in the past and dig deeper into how they work.
diff --git a/lib/elixir/pages/getting-started/basic-types.md b/lib/elixir/pages/getting-started/basic-types.md
new file mode 100644
index 00000000000..b446b3bd65e
--- /dev/null
+++ b/lib/elixir/pages/getting-started/basic-types.md
@@ -0,0 +1,313 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Basic types
+
+In this chapter we will learn more about Elixir basic types: integers, floats, booleans, atoms, and strings. Other data types, such as lists and tuples, will be explored in the next chapter.
+
+```elixir
+iex> 1          # integer
+iex> 0x1F       # integer
+iex> 1.0        # float
+iex> true       # boolean
+iex> :atom      # atom / symbol
+iex> "elixir"   # string
+iex> [1, 2, 3]  # list
+iex> {1, 2, 3}  # tuple
+```
+
+## Basic arithmetic
+
+Open up `iex` and type the following expressions:
+
+```elixir
+iex> 1 + 2
+3
+iex> 5 * 5
+25
+iex> 10 / 2
+5.0
+```
+
+Notice that `10 / 2` returned a float `5.0` instead of an integer `5`. This is expected. In Elixir, the operator [`/`](`//2`) always returns a float. If you want to do integer division or get the division remainder, you can invoke the [`div`](`div/2`) and [`rem`](`rem/2`) functions:
+
+```elixir
+iex> div(10, 2)
+5
+iex> div 10, 2
+5
+iex> rem 10, 3
+1
+```
+
+Notice that Elixir allows you to drop the parentheses when invoking functions that expect one or more arguments. This feature gives a cleaner syntax when writing declarations and control-flow constructs. However, Elixir developers generally prefer to use parentheses.
+
+Elixir also supports shortcut notations for entering binary, octal, and hexadecimal numbers:
+
+```elixir
+iex> 0b1010
+10
+iex> 0o777
+511
+iex> 0x1F
+31
+```
+
+Float numbers require a dot followed by at least one digit and also support `e` for scientific notation:
+
+```elixir
+iex> 1.0
+1.0
+iex> 1.0e-10
+1.0e-10
+```
+
+Floats in Elixir are 64-bit precision.
+
+You can invoke the [`round`](`round/1`) function to get the closest integer to a given float, or the [`trunc`](`trunc/1`) function to get the integer part of a float.
+
+```elixir
+iex> round(3.58)
+4
+iex> trunc(3.58)
+3
+```
+
+Finally, we work with different data types, we will learn Elixir provides several predicate functions to check for the type of a value. For example, [`is_integer`](`is_integer/1`) can be used to check if a value is an integer or not:
+
+```elixir
+iex> is_integer(1)
+true
+iex> is_integer(2.0)
+false
+```
+
+You can also use [`is_float`](`is_float/1`) or [`is_number`](`is_number/1`) to check, respectively, if an argument is a float, or either an integer or float.
+
+## Booleans and `nil`
+
+Elixir supports `true` and `false` as booleans:
+
+```elixir
+iex> true
+true
+iex> true == false
+false
+```
+
+Elixir also provides three boolean operators: [`or`](`or/2`), [`and`](`and/2`), and [`not`](`not/1`). These operators are strict in the sense that they expect something that evaluates to a boolean (`true` or `false`) as their first argument:
+
+```elixir
+iex> true and true
+true
+iex> false or is_boolean(true)
+true
+```
+
+Providing a non-boolean will raise an exception:
+
+```elixir
+iex> 1 and true
+** (BadBooleanError) expected a boolean on left-side of "and", got: 1
+```
+
+`or` and `and` are short-circuit operators. They only execute the right side if the left side is not enough to determine the result:
+
+```elixir
+iex> false and raise("This error will never be raised")
+false
+iex> true or raise("This error will never be raised")
+true
+```
+
+Elixir also provides the concept of `nil`, to indicate the absence of a value, and a set of logical operators that also manipulate `nil`: `||/2`, `&&/2`, and `!/1`. For these operators, `false` and `nil` are considered "falsy", all other values are considered "truthy":
+
+```elixir
+# or
+iex> 1 || true
+1
+iex> false || 11
+11
+
+# and
+iex> nil && 13
+nil
+iex> true && 17
+17
+
+# not
+iex> !true
+false
+iex> !1
+false
+iex> !nil
+true
+```
+
+Similarly, values like `0` and `""`, which some other programming languages consider to be "falsy", are also "truthy" in Elixir.
+
+As a rule of thumb, use `and`, `or` and `not` when you are expecting booleans. If any of the arguments are non-boolean, use `&&`, `||` and `!`.
+
+## Atoms
+
+An atom is a constant whose value is its own name. Some other languages call these symbols. They are often useful to enumerate over distinct values, such as:
+
+```elixir
+iex> :apple
+:apple
+iex> :orange
+:orange
+iex> :watermelon
+:watermelon
+```
+
+Atoms are equal if their names are equal.
+
+```elixir
+iex> :apple == :apple
+true
+iex> :apple == :orange
+false
+```
+
+Often they are used to express the state of an operation, by using values such as `:ok` and `:error`.
+
+The booleans `true` and `false` are also atoms:
+
+```elixir
+iex> true == :true
+true
+iex> is_atom(false)
+true
+iex> is_boolean(:false)
+true
+```
+
+Elixir allows you to skip the leading `:` for the atoms `false`, `true` and `nil`.
+
+## Strings
+
+Strings in Elixir are delimited by double quotes, and they are encoded in UTF-8:
+
+```elixir
+iex> "hellö"
+"hellö"
+```
+
+> Note: if you are running on Windows, there is a chance your terminal does not use UTF-8 by default. You can change the encoding of your current session by running `chcp 65001` before entering IEx.
+
+You can concatenate two strings with the [`<>`](`<>/2`) operator:
+
+```elixir
+iex> "hello " <> "world!"
+"hello world!"
+```
+
+Elixir also supports string interpolation:
+
+```elixir
+iex> string = "world"
+iex> "hello #{string}!"
+"hello world!"
+```
+
+String concatenation requires both sides to be strings but interpolation supports any data type that may be converted to a string:
+
+```elixir
+iex> number = 42
+iex> "i am #{number} years old!"
+"i am 42 years old!"
+```
+
+Strings can have line breaks in them. You can introduce them using escape sequences:
+
+```elixir
+iex> "hello
+...> world"
+"hello\nworld"
+iex> "hello\nworld"
+"hello\nworld"
+```
+
+You can print a string using the [`IO.puts`](`IO.puts/1`) function from the `IO` module:
+
+```elixir
+iex> IO.puts("hello\nworld")
+hello
+world
+:ok
+```
+
+Notice that the [`IO.puts`](`IO.puts/1`) function returns the atom `:ok` after printing.
+
+Strings in Elixir are represented internally by contiguous sequences of bytes known as binaries:
+
+```elixir
+iex> is_binary("hellö")
+true
+```
+
+We can also get the number of bytes in a string:
+
+```elixir
+iex> byte_size("hellö")
+6
+```
+
+Notice that the number of bytes in that string is 6, even though it has 5 graphemes. That's because the grapheme "ö" takes 2 bytes to be represented in UTF-8. We can get the actual length of the string, based on the number of graphemes, by using the [`String.length`](`String.length/1`) function:
+
+```elixir
+iex> String.length("hellö")
+5
+```
+
+The `String` module contains a bunch of functions that operate on strings as defined in the Unicode standard:
+
+```elixir
+iex> String.upcase("hellö")
+"HELLÖ"
+```
+
+## Structural comparison
+
+Elixir also provides [`==`](`==/2`), [`!=`](`!=/2`), [`<=`](`<=/2`), [`>=`](`>=/2`), [`<`](`</2`) and [`>`](`>/2`) as comparison operators. We can compare numbers:
+
+```elixir
+iex> 1 == 1
+true
+iex> 1 != 2
+true
+iex> 1 < 2
+true
+```
+
+But also atoms, strings, booleans, etc:
+
+```elixir
+iex> "foo" == "foo"
+true
+iex> "foo" == "bar"
+false
+```
+
+Integers and floats compare the same if they have the same value:
+
+```elixir
+iex> 1 == 1.0
+true
+iex> 1 == 2.0
+false
+```
+
+However, you can use the strict comparison operator [`===`](`===/2`) and [`!==`](`!==/2`) if you want to distinguish between integers and floats:
+
+```elixir
+iex> 1 === 1.0
+false
+```
+
+The comparison operators in Elixir can compare across any data type. We say these operators perform _structural comparison_. For more information, you can read our documentation on [Structural vs Semantic comparisons](`Kernel#module-structural-comparison`).
+
+Elixir also provides data-types for expressing collections, such as lists and tuples, which we learn next. When we talk about concurrency and fault-tolerance via processes, we will also discuss ports, pids, and references, but that will come on later chapters. Let's move forward.
diff --git a/lib/elixir/pages/getting-started/binaries-strings-and-charlists.md b/lib/elixir/pages/getting-started/binaries-strings-and-charlists.md
new file mode 100644
index 00000000000..c6ab4919973
--- /dev/null
+++ b/lib/elixir/pages/getting-started/binaries-strings-and-charlists.md
@@ -0,0 +1,309 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Binaries, strings, and charlists
+
+In ["Basic types"](basic-types.md), we learned a bit about strings and we used the `is_binary/1` function for checks:
+
+```elixir
+iex> string = "hello"
+"hello"
+iex> is_binary(string)
+true
+```
+
+In this chapter, we will gain clarity on what exactly binaries are and how they relate to strings. We will also learn about charlists, `~c"like this"`, which are often used for interoperability with Erlang.
+
+Although strings are one of the most common data types in computer languages, they are subtly complex and are often misunderstood. To understand strings in Elixir, let's first discuss [Unicode](https://en.wikipedia.org/wiki/Unicode) and character encodings, specifically the [UTF-8](https://en.wikipedia.org/wiki/UTF-8) encoding.
+
+## Unicode and Code Points
+
+In order to facilitate meaningful communication between computers across multiple languages, a standard is required so that the ones and zeros on one machine mean the same thing when they are transmitted to another. The [Unicode Standard](https://unicode.org/standard/standard.html) acts as an official registry of virtually all the characters we know: this includes characters from classical and historical texts, emoji, and formatting and control characters as well.
+
+Unicode organizes all of the characters in its repertoire into code charts, and each character is given a unique numerical index. This numerical index is known as a [Code Point](https://en.wikipedia.org/wiki/Code_point).
+
+In Elixir you can use a `?` in front of a character literal to reveal its code point:
+
+```elixir
+iex> ?a
+97
+iex> ?ł
+322
+```
+
+Note that most Unicode code charts will refer to a code point by its hexadecimal (hex) representation, e.g. `97` translates to `0061` in hex, and we can represent any Unicode character in an Elixir string by using the `\uXXXX` notation and the hex representation of its code point number:
+
+```elixir
+iex> "\u0061" == "a"
+true
+iex> 0x0061 = 97 = ?a
+97
+```
+
+The hex representation will also help you look up information about a code point, e.g. [https://codepoints.net/U+0061](https://codepoints.net/U+0061) has a data sheet all about the lower case `a`, a.k.a. code point 97.
+
+## UTF-8 and Encodings
+
+Now that we understand what the Unicode standard is and what code points are, we can finally talk about encodings. Whereas the code point is **what** we store, an encoding deals with **how** we store it: encoding is an implementation. In other words, we need a mechanism to convert the code point numbers into bytes so they can be stored in memory, written to disk, etc.
+
+Elixir uses UTF-8 to encode its strings, which means that code points are encoded as a series of 8-bit bytes. UTF-8 is a **variable width** character encoding that uses one to four bytes to store each code point. It is capable of encoding all valid Unicode code points. Let's see an example:
+
+```elixir
+iex> string = "héllo"
+"héllo"
+iex> String.length(string)
+5
+iex> byte_size(string)
+6
+```
+
+Although the string above has 5 characters, it uses 6 bytes, as two bytes are used to represent the character `é`.
+
+> Note: if you are running on Windows, there is a chance your terminal does not use UTF-8 by default. You can change the encoding of your current session by running `chcp 65001` before entering `iex` (`iex.bat`).
+
+Besides defining characters, UTF-8 also provides a notion of graphemes. Graphemes may consist of multiple characters that are often perceived as one. For example, the [woman firefighter emoji](https://emojipedia.org/woman-firefighter/) is represented as the combination of three characters: the woman emoji (👩), a hidden zero-width joiner, and the fire engine emoji (🚒):
+
+```elixir
+iex> String.codepoints("👩‍🚒")
+["👩", "‍", "🚒"]
+iex> String.graphemes("👩‍🚒")
+["👩‍🚒"]
+```
+
+However, Elixir is smart enough to know they are seen as a single character, and therefore the length is still one:
+
+```elixir
+iex> String.length("👩‍🚒")
+1
+```
+
+> Note: if you can't see the emoji above in your terminal, you need to make sure your terminal supports emoji and that you are using a font that can render them.
+
+Although these rules may sound complicated, UTF-8 encoded documents are everywhere. This page itself is encoded in UTF-8. The encoding information is given to your browser which then knows how to render all of the bytes, characters, and graphemes accordingly.
+
+If you want to see the exact bytes that a string would be stored in a file, a common trick is to concatenate the null byte `<<0>>` to it:
+
+```elixir
+iex> "hełło" <> <<0>>
+<<104, 101, 197, 130, 197, 130, 111, 0>>
+```
+
+Alternatively, you can view a string's binary representation by using `IO.inspect/2`:
+
+```elixir
+iex> IO.inspect("hełło", binaries: :as_binaries)
+<<104, 101, 197, 130, 197, 130, 111>>
+```
+
+We are getting a little bit ahead of ourselves. Let's talk about bitstrings to learn about what exactly the `<<>>` constructor means.
+
+## Bitstrings
+
+Although we have covered code points and UTF-8 encoding, we still need to go a bit deeper into how exactly we store the encoded bytes, and this is where we introduce the **bitstring**. A bitstring is a fundamental data type in Elixir, denoted with the [`<<>>`](`<<>>/1`) syntax. **A bitstring is a contiguous sequence of bits in memory.**
+
+By default, 8 bits (i.e. 1 byte) is used to store each number in a bitstring, but you can manually specify the number of bits via a `::n` modifier to denote the size in `n` bits, or you can use the more verbose declaration `::size(n)`:
+
+```elixir
+iex> <<42>> == <<42::8>>
+true
+iex> <<3::4>>
+<<3::size(4)>>
+```
+
+For example, the decimal number `3` when represented with 4 bits in base 2 would be `0011`, which is equivalent to the values `0`, `0`, `1`, `1`, each stored using 1 bit:
+
+```elixir
+iex> <<0::1, 0::1, 1::1, 1::1>> == <<3::4>>
+true
+```
+
+Any value that exceeds what can be stored by the number of bits provisioned is truncated:
+
+```elixir
+iex> <<1>> == <<257>>
+true
+```
+
+Here, 257 in base 2 would be represented as `100000001`, but since we have reserved only 8 bits for its representation (by default), the left-most bit is ignored and the value becomes truncated to `00000001`, or simply `1` in decimal.
+
+A complete reference for the bitstring constructor can be found in [`<<>>`](`<<>>/1`)'s documentation.
+
+## Binaries
+
+**A binary is a bitstring where the number of bits is divisible by 8.** That means that every binary is a bitstring, but not every bitstring is a binary. We can use the `is_bitstring/1` and `is_binary/1` functions to demonstrate this.
+
+```elixir
+iex> is_bitstring(<<3::4>>)
+true
+iex> is_binary(<<3::4>>)
+false
+iex> is_bitstring(<<0, 255, 42>>)
+true
+iex> is_binary(<<0, 255, 42>>)
+true
+iex> is_binary(<<42::16>>)
+true
+```
+
+We can pattern match on binaries / bitstrings:
+
+```elixir
+iex> <<0, 1, x>> = <<0, 1, 2>>
+<<0, 1, 2>>
+iex> x
+2
+iex> <<0, 1, x>> = <<0, 1, 2, 3>>
+** (MatchError) no match of right hand side value: <<0, 1, 2, 3>>
+```
+
+Note that unless you explicitly use `::` modifiers, each entry in the binary pattern is expected to match a single byte (exactly 8 bits). If we want to match on a binary of unknown size, we can use the `binary` modifier at the end of the pattern:
+
+```elixir
+iex> <<0, 1, x::binary>> = <<0, 1, 2, 3>>
+<<0, 1, 2, 3>>
+iex> x
+<<2, 3>>
+```
+
+There are a couple other modifiers that can be useful when doing pattern matches on binaries. The `binary-size(n)` modifier will match `n` bytes in a binary:
+
+```elixir
+iex> <<head::binary-size(2), rest::binary>> = <<0, 1, 2, 3>>
+<<0, 1, 2, 3>>
+iex> head
+<<0, 1>>
+iex> rest
+<<2, 3>>
+```
+
+**A string is a UTF-8 encoded binary**, where the code point for each character is encoded using 1 to 4 bytes. Thus every string is a binary, but due to the UTF-8 standard encoding rules, not every binary is a valid string.
+
+```elixir
+iex> is_binary("hello")
+true
+iex> is_binary(<<239, 191, 19>>)
+true
+iex> String.valid?(<<239, 191, 19>>)
+false
+```
+
+The string concatenation operator [`<>`](`<>/2`) is actually a binary concatenation operator:
+
+```elixir
+iex> "a" <> "ha"
+"aha"
+iex> <<0, 1>> <> <<2, 3>>
+<<0, 1, 2, 3>>
+```
+
+Given that strings are binaries, we can also pattern match on strings:
+
+```elixir
+iex> <<head, rest::binary>> = "banana"
+"banana"
+iex> head == ?b
+true
+iex> rest
+"anana"
+```
+
+However, remember that binary pattern matching works on *bytes*, so matching on the string like "über" with multibyte characters won't match on the *character*, it will match on the *first byte of that character*:
+
+```elixir
+iex> "ü" <> <<0>>
+<<195, 188, 0>>
+iex> <<x, rest::binary>> = "über"
+"über"
+iex> x == ?ü
+false
+iex> rest
+<<188, 98, 101, 114>>
+```
+
+Above, `x` matched on only the first byte of the multibyte `ü` character.
+
+Therefore, when pattern matching on strings, it is important to use the `utf8` modifier:
+
+```elixir
+iex> <<x::utf8, rest::binary>> = "über"
+"über"
+iex> x == ?ü
+true
+iex> rest
+"ber"
+```
+
+## Charlists
+
+Our tour of our bitstrings, binaries, and strings is nearly complete, but we have one more data type to explain: the charlist.
+
+**A charlist is a list of integers where all the integers are valid code points.** In practice, you will not come across them often, only in specific scenarios such as interfacing with older Erlang libraries that do not accept binaries as arguments.
+
+```elixir
+iex> ~c"hello"
+~c"hello"
+iex> [?h, ?e, ?l, ?l, ?o]
+~c"hello"
+```
+
+The [`~c`](`Kernel.sigil_c/2`) sigil (we'll cover sigils later in the ["Sigils"](sigils.md) chapter) indicates the fact that we are dealing with a charlist and not a regular string.
+
+Instead of containing bytes, a charlist contains integer code points. However, the list is only printed as a sigil if all code points are within the ASCII range:
+
+```elixir
+iex> ~c"hełło"
+[104, 101, 322, 322, 111]
+iex> is_list(~c"hełło")
+true
+```
+
+This is done to ease interoperability with Erlang, even though it may lead to some surprising behavior. For example, if you are storing a list of integers that happen to range between 0 and 127, by default IEx will interpret this as a charlist and it will display the corresponding ASCII characters.
+
+```elixir
+iex> heartbeats_per_minute = [99, 97, 116]
+~c"cat"
+```
+
+You can always force charlists to be printed in their list representation by calling the `inspect/2` function:
+
+```elixir
+iex> inspect(heartbeats_per_minute, charlists: :as_list)
+"[99, 97, 116]"
+```
+
+Furthermore, you can convert a charlist to a string and back by using the `to_string/1` and `to_charlist/1`:
+
+```elixir
+iex> to_charlist("hełło")
+[104, 101, 322, 322, 111]
+iex> to_string(~c"hełło")
+"hełło"
+iex> to_string(:hello)
+"hello"
+iex> to_string(1)
+"1"
+```
+
+The functions above are polymorphic, in other words, they accept many shapes: not only do they convert charlists to strings (and vice-versa), they can also convert integers, atoms, and so on.
+
+String (binary) concatenation uses the [`<>`](`<>/2`) operator but charlists, being lists, use the list concatenation operator [`++`](`++/2`):
+
+```elixir
+iex> ~c"this " <> ~c"fails"
+** (ArgumentError) expected binary argument in <> operator but got: ~c"this "
+    (elixir) lib/kernel.ex:1821: Kernel.wrap_concatenation/3
+    (elixir) lib/kernel.ex:1808: Kernel.extract_concatenations/2
+    (elixir) expanding macro: Kernel.<>/2
+    iex:1: (file)
+iex> ~c"this " ++ ~c"works"
+~c"this works"
+iex> "he" ++ "llo"
+** (ArgumentError) argument error
+    :erlang.++("he", "llo")
+iex> "he" <> "llo"
+"hello"
+```
+
+With binaries, strings, and charlists out of the way, it is time to talk about key-value data structures.
diff --git a/lib/elixir/pages/getting-started/case-cond-and-if.md b/lib/elixir/pages/getting-started/case-cond-and-if.md
new file mode 100644
index 00000000000..9c354105e5c
--- /dev/null
+++ b/lib/elixir/pages/getting-started/case-cond-and-if.md
@@ -0,0 +1,186 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# case, cond, and if
+
+In this chapter, we will learn about the [`case`](`case/2`), [`cond`](`cond/1`), and [`if`](`if/2`) control flow structures.
+
+## case
+
+[`case`](`case/2`) allows us to compare a value against many patterns until we find a matching one:
+
+```elixir
+iex> case {1, 2, 3} do
+...>   {4, 5, 6} ->
+...>     "This clause won't match"
+...>   {1, x, 3} ->
+...>     "This clause will match and bind x to 2 in this clause"
+...>   _ ->
+...>     "This clause would match any value"
+...> end
+"This clause will match and bind x to 2 in this clause"
+```
+
+If you want to pattern match against an existing variable, you need to use the [`^`](`^/1`) operator:
+
+```elixir
+iex> x = 1
+1
+iex> case 10 do
+...>   ^x -> "Won't match"
+...>   _ -> "Will match"
+...> end
+"Will match"
+```
+
+Clauses also allow extra conditions to be specified via guards:
+
+```elixir
+iex> case {1, 2, 3} do
+...>   {1, x, 3} when x > 0 ->
+...>     "Will match"
+...>   _ ->
+...>     "Would match, if guard condition were not satisfied"
+...> end
+"Will match"
+```
+
+The first clause above will only match when `x` is positive.
+
+Keep in mind errors in guards do not leak but simply make the guard fail:
+
+```elixir
+iex> hd(1)
+** (ArgumentError) argument error
+iex> case 1 do
+...>   x when hd(x) -> "Won't match"
+...>   x -> "Got #{x}"
+...> end
+"Got 1"
+```
+
+If none of the clauses match, an error is raised:
+
+```elixir
+iex> case :ok do
+...>   :error -> "Won't match"
+...> end
+** (CaseClauseError) no case clause matching: :ok
+```
+
+The documentation for the `Kernel` module lists all available guards in its sidebar. You can also consult the complete [Patterns and Guards](../references/patterns-and-guards.md#guards) reference for in-depth documentation.
+
+## if
+
+[`case`](`case/2`) builds on pattern matching and guards to destructure and match on certain conditions. However, patterns and guards are limited only to certain expressions which are optimized by the compiler. In many situations, you need to write conditions that go beyond what can be expressed with [`case`](`case/2`). For those, [`if`](`if/2`) is a useful alternative:
+
+```elixir
+iex> if true do
+...>   "This works!"
+...> end
+"This works!"
+iex> if false do
+...>   "This will never be seen"
+...> end
+nil
+```
+
+If the condition given to [`if`](`if/2`) returns `false` or `nil`, the body given between `do`-`end` is not executed and instead it returns `nil`.
+
+[`if`](`if/2`) also supports `else` blocks:
+
+```elixir
+iex> if nil do
+...>   "This won't be seen"
+...> else
+...>   "This will"
+...> end
+"This will"
+```
+
+### Expressions
+
+Some programming languages make a distinction about expressions (code that returns a value) and statements (code that returns no value). In Elixir, there are only expressions, no statements. Everything you write in Elixir language returns some value.
+
+This property allows variables to be scoped to individual blocks of code such as [`if`](`if/2`), [`case`](`case/2`), where declarations or changes are only visible inside the block. A change can't leak to outer blocks, which makes code easier to follow and understand. For example:
+
+```elixir
+iex> x = 1
+1
+iex> if true do
+...>   x = x + 1
+...> end
+2
+iex> x
+1
+```
+
+You see the return value of the [`if`](`if/2`) expression as the resulting `2` here. To retain changes made within the [`if`](`if/2`) expression on the outer block you need to assign the returned value to a variable in the outer block.
+
+```elixir
+iex> x = 1
+1
+iex> x =
+...>   if true do
+...>     x + 1
+...>   else
+...>     x
+...>   end
+2
+```
+
+With all expressions returning a value there's also no need for alternative constructs, such as ternary operators posing as an alternative to [`if`](`if/2`). Elixir does include an inline notation for [`if`](`if/2`) and, as we will [learn later](keywords-and-maps.md#do-blocks-and-keywords), it is a syntactic variation on `if`'s arguments.
+
+> #### `if` is a macro {: .info}
+>
+> An interesting note regarding [`if`](`if/2`) is that it is implemented as a macro in the language: it isn't a special language construct as it would be in many languages. You can check the documentation and its source for more information.
+
+If you find yourself nesting several [`if`](`if/2`) blocks, you may want to consider using [`cond`](`cond/1`) instead. Let's check it out.
+
+## cond
+
+We have used `case` to find a matching clause from many patterns. We have used `if` to check for a single condition. If you need to check across several conditions and find the first one that does not evaluate to `nil` or `false`, [`cond`](`cond/1`) is a useful construct:
+
+```elixir
+iex> cond do
+...>   2 + 2 == 5 ->
+...>     "This will not be true"
+...>   2 * 2 == 3 ->
+...>     "Nor this"
+...>   1 + 1 == 2 ->
+...>     "But this will"
+...> end
+"But this will"
+```
+
+This is equivalent to `else if` clauses in many imperative languages - although used less frequently in Elixir.
+
+If all of the conditions return `nil` or `false`, an error (`CondClauseError`) is raised. For this reason, it may be necessary to add a final condition, equal to `true`, which will always match:
+
+```elixir
+iex> cond do
+...>   2 + 2 == 5 ->
+...>     "This is never true"
+...>   2 * 2 == 3 ->
+...>     "Nor this"
+...>   true ->
+...>     "This is always true (equivalent to else)"
+...> end
+"This is always true (equivalent to else)"
+```
+
+Similar to [`if`](`if/2`), [`cond`](`cond/1`) considers any value besides `nil` and `false` to be true:
+
+```elixir
+iex> cond do
+...>   hd([1, 2, 3]) ->
+...>     "1 is considered as true"
+...> end
+"1 is considered as true"
+```
+
+## Summing up
+
+We have concluded the introduction to the most fundamental control-flow constructs in Elixir. Generally speaking, Elixir developers prefer pattern matching and guards, using [`case`](`case/2`) and function definitions (which we will explore in future chapters), as they are succinct and precise. When your logic cannot be outlined within patterns and guards, you may consider [`if`](`if/2`), falling back to [`cond`](`cond/1`) when there are several conditions to check.
diff --git a/lib/elixir/pages/getting-started/comprehensions.md b/lib/elixir/pages/getting-started/comprehensions.md
new file mode 100644
index 00000000000..ff775ee14f3
--- /dev/null
+++ b/lib/elixir/pages/getting-started/comprehensions.md
@@ -0,0 +1,115 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Comprehensions
+
+In Elixir, it is common to loop over an `Enumerable`, often filtering out some results and mapping values into another list. Comprehensions are syntactic sugar for such constructs: they group those common tasks into the `for` special form.
+
+For example, we can map a list of integers into their squared values:
+
+```elixir
+iex> for n <- [1, 2, 3, 4], do: n * n
+[1, 4, 9, 16]
+```
+
+A comprehension is made of three parts: generators, filters, and collectables.
+
+## Generators and filters
+
+In the expression above, `n <- [1, 2, 3, 4]` is the **generator**. It is literally generating values to be used in the comprehension. Any enumerable can be passed on the right-hand side of the generator expression:
+
+```elixir
+iex> for n <- 1..4, do: n * n
+[1, 4, 9, 16]
+```
+
+Generator expressions also support pattern matching on their left-hand side; all non-matching patterns are *ignored*. Imagine that, instead of a range, we have a keyword list where the key is the atom `:good` or `:bad` and we only want to compute the square of the `:good` values:
+
+```elixir
+iex> values = [good: 1, good: 2, bad: 3, good: 4]
+iex> for {:good, n} <- values, do: n * n
+[1, 4, 16]
+```
+
+Alternatively to pattern matching, filters can be used to select some particular elements. For example, we can select the multiples of 3 and discard all others:
+
+```elixir
+iex> for n <- 0..5, rem(n, 3) == 0, do: n * n
+[0, 9]
+```
+
+Comprehensions discard all elements for which the filter expression returns `false` or `nil`; all other values are selected.
+
+Comprehensions generally provide a much more concise representation than using the equivalent functions from the `Enum` and `Stream` modules. Furthermore, comprehensions also allow multiple generators and filters to be given. Here is an example that receives a list of directories and gets the size of each file in those directories:
+
+```elixir
+dirs = ["/home/mikey", "/home/james"]
+
+for dir <- dirs,
+    file <- File.ls!(dir),
+    path = Path.join(dir, file),
+    File.regular?(path) do
+  File.stat!(path).size
+end
+```
+
+Multiple generators can also be used to calculate the Cartesian product of two lists:
+
+```elixir
+iex> for i <- [:a, :b, :c], j <- [1, 2], do:  {i, j}
+[a: 1, a: 2, b: 1, b: 2, c: 1, c: 2]
+```
+
+Finally, keep in mind that variable assignments inside the comprehension, be it in generators, filters or inside the block, are not reflected outside of the comprehension.
+
+## Bitstring generators
+
+Bitstring generators are also supported and are very useful when you need to comprehend over bitstring streams. The example below receives a list of pixels from a binary with their respective red, green and blue values and converts them into tuples of three elements each:
+
+```elixir
+iex> pixels = <<213, 45, 132, 64, 76, 32, 76, 0, 0, 234, 32, 15>>
+iex> for <<r::8, g::8, b::8 <- pixels>>, do: {r, g, b}
+[{213, 45, 132}, {64, 76, 32}, {76, 0, 0}, {234, 32, 15}]
+```
+
+A bitstring generator can be mixed with "regular" enumerable generators, and supports filters as well.
+
+## The `:into` option
+
+In the examples above, all the comprehensions returned lists as their result. However, the result of a comprehension can be inserted into different data structures by passing the `:into` option to the comprehension.
+
+For example, a bitstring generator can be used with the `:into` option in order to easily remove all spaces in a string:
+
+```elixir
+iex> for <<c <- " hello world ">>, c != ?\s, into: "", do: <<c>>
+"helloworld"
+```
+
+Sets, maps, and other dictionaries can also be given to the `:into` option. In general, `:into` accepts any structure that implements the `Collectable` protocol.
+
+A common use case of `:into` can be transforming values in a map:
+
+```elixir
+iex> for {key, val} <- %{"a" => 1, "b" => 2}, into: %{}, do: {key, val * val}
+%{"a" => 1, "b" => 4}
+```
+
+Let's make another example using streams. Since the `IO` module provides streams (that are both `Enumerable`s and `Collectable`s), an echo terminal that echoes back the upcased version of whatever is typed can be implemented using comprehensions:
+
+```elixir
+iex> stream = IO.stream(:stdio, :line)
+iex> for line <- stream, into: stream do
+...>   String.upcase(line) <> "\n"
+...> end
+```
+
+Now type any string into the terminal and you will see that the same value will be printed in upper-case. Unfortunately, this example also got your IEx shell stuck in the comprehension, so you will need to hit `Ctrl+C` twice to get out of it. :)
+
+## Other options
+
+Comprehensions support other options, such as `:reduce` and `:uniq`. Here are additional resources to learn more about comprehensions:
+
+  * [`for` official reference in Elixir documentation](`for/1`)
+  * [Mitchell Hanberg's comprehensive guide to Elixir's comprehensions](https://www.mitchellhanberg.com/the-comprehensive-guide-to-elixirs-for-comprehension/)
diff --git a/lib/elixir/pages/getting-started/debugging.md b/lib/elixir/pages/getting-started/debugging.md
new file mode 100644
index 00000000000..fbb32c65f9f
--- /dev/null
+++ b/lib/elixir/pages/getting-started/debugging.md
@@ -0,0 +1,193 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Debugging
+
+There are a number of ways to debug code in Elixir. In this chapter we will cover some of the more common ways of doing so.
+
+## IO.inspect/2
+
+What makes `IO.inspect(item, opts \\ [])` really useful in debugging is that it returns the `item` argument passed to it without affecting the behavior of the original code. Let's see an example.
+
+```elixir
+(1..10)
+|> IO.inspect()
+|> Enum.map(fn x -> x * 2 end)
+|> IO.inspect()
+|> Enum.sum()
+|> IO.inspect()
+```
+
+Prints:
+
+```elixir
+1..10
+[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
+110
+```
+
+As you can see `IO.inspect/2` makes it possible to "spy" on values almost anywhere in your code without altering the result, making it very helpful inside of a pipeline like in the above case.
+
+`IO.inspect/2` also provides the ability to decorate the output with a `label` option. The label will be printed before the inspected `item`:
+
+```elixir
+[1, 2, 3]
+|> IO.inspect(label: "before")
+|> Enum.map(&(&1 * 2))
+|> IO.inspect(label: "after")
+|> Enum.sum
+```
+
+Prints:
+
+```elixir
+before: [1, 2, 3]
+after: [2, 4, 6]
+```
+
+It is also very common to use `IO.inspect/2` with `binding/0`, which returns all variable names and their values:
+
+```elixir
+def some_function(a, b, c) do
+  IO.inspect(binding())
+  ...
+end
+```
+
+When `some_function/3` is invoked with `:foo`, `"bar"`, `:baz` it prints:
+
+```elixir
+[a: :foo, b: "bar", c: :baz]
+```
+
+See `IO.inspect/2` and `Inspect.Opts` respectively to learn more about the function and read about all supported options.
+
+## dbg/2
+
+Elixir v1.14 introduced `dbg/2`. `dbg` is similar to `IO.inspect/2` but specifically tailored for debugging. It prints the value passed to it and returns it (just like `IO.inspect/2`), but it also prints the code and location.
+
+```elixir
+# In my_file.exs
+feature = %{name: :dbg, inspiration: "Rust"}
+dbg(feature)
+dbg(Map.put(feature, :in_version, "1.14.0"))
+```
+
+The code above prints this:
+
+```text
+[my_file.exs:2: (file)]
+feature #=> %{inspiration: "Rust", name: :dbg}
+[my_file.exs:3: (file)]
+Map.put(feature, :in_version, "1.14.0") #=> %{in_version: "1.14.0", inspiration: "Rust", name: :dbg}
+```
+
+When talking about `IO.inspect/2`, we mentioned its usefulness when placed between steps of `|>` pipelines. `dbg` does it better: it understands Elixir code, so it will print values at _every step of the pipeline_.
+
+```elixir
+# In dbg_pipes.exs
+__ENV__.file
+|> String.split("/", trim: true)
+|> List.last()
+|> File.exists?()
+|> dbg()
+```
+
+This code prints:
+
+```text
+[dbg_pipes.exs:5: (file)]
+__ENV__.file #=> "/home/myuser/dbg_pipes.exs"
+|> String.split("/", trim: true) #=> ["home", "myuser", "dbg_pipes.exs"]
+|> List.last() #=> "dbg_pipes.exs"
+|> File.exists?() #=> true
+```
+
+While `dbg` provides conveniences around Elixir constructs, you will need `IEx` if you want to execute code and set breakpoints while debugging.
+
+## Pry
+
+When using `IEx`, you may pass `--dbg pry` as an option to "stop" the code execution where the `dbg` call is:
+
+```console
+$ iex --dbg pry
+```
+
+Or to debug inside of a project:
+
+```console
+$ iex --dbg pry -S mix
+```
+
+Now any call to `dbg` will ask if you want to pry the existing code. If you accept, you'll be able to access all variables, as well as imports and aliases from the code, directly from IEx. This is called "prying". While the pry session is running, the code execution stops, until `continue` (or `c`) or `next` (or `n`) are called. Remember you can always run `iex` in the context of a project with `iex -S mix TASK`.
+
+<script id="asciicast-509509" src="https://asciinema.org/a/509509.js" async></script><noscript><p><a href="https://asciinema.org/a/509509">See the example in asciinema</a></p></noscript>
+
+## Breakpoints
+
+`dbg` calls require us to change the code we intend to debug and has limited stepping functionality. Luckily IEx also provides a `IEx.break!/2` function which allows you to set and manage breakpoints on any Elixir code without modifying its source:
+
+<script type="text/javascript" src="https://asciinema.org/a/0h3po0AmTcBAorc5GBNU97nrs.js" id="asciicast-0h3po0AmTcBAorc5GBNU97nrs" async></script><noscript><p><a href="https://asciinema.org/a/0h3po0AmTcBAorc5GBNU97nrs">See the example in asciinema</a></p></noscript>
+
+Similar to `dbg`, once a breakpoint is reached, code execution stops until `continue` (or `c`) or `next` (or `n`) are invoked. Breakpoints can navigate line-by-line by default, however, they do not have access to aliases and imports when breakpoints are set on compiled modules.
+
+The `mix test` task direct integration with breakpoints via the `-b`/`--breakpoints` flag. When the flag is used, a breakpoint is set at the beginning of every test that will run:
+
+<script async id="asciicast-XTZ15jFKFAlr8ZxIZMzaHgL5n" src="https://asciinema.org/a/XTZ15jFKFAlr8ZxIZMzaHgL5n.js"></script><noscript><p><a href="https://asciinema.org/a/XTZ15jFKFAlr8ZxIZMzaHgL5n">See the example in asciinema</a></p></noscript>
+
+Here are some commands you can use in practice:
+
+```console
+# Debug all failed tests
+$ iex -S mix test --breakpoints --failed
+# Debug the test at the given file:line
+$ iex -S mix test -b path/to/file:line
+```
+
+## Observer
+
+For debugging complex systems, jumping at the code is not enough. It is necessary to have an understanding of the whole virtual machine, processes, applications, as well as set up tracing mechanisms. Luckily this can be achieved in Erlang with `:observer`. In your application:
+
+```elixir
+$ iex
+iex> :observer.start()
+```
+
+> #### Missing dependencies {: .warning}
+>
+> When running `iex` inside a project with `iex -S mix`, `observer` won't be available as a dependency. To do so, you will need to call the following functions before:
+>
+> ```elixir
+> iex> Mix.ensure_application!(:wx)             # Not necessary on Erlang/OTP 27+
+> iex> Mix.ensure_application!(:runtime_tools)  # Not necessary on Erlang/OTP 27+
+> iex> Mix.ensure_application!(:observer)
+> iex> :observer.start()
+> ```
+>
+> If any of the calls above fail, here is what may have happened: some package managers default to installing a minimized Erlang without WX bindings for GUI support. In some package managers, you may be able to replace the headless Erlang with a more complete package (look for packages named `erlang` vs `erlang-nox` on Debian/Ubuntu/Arch). In others managers, you may need to install a separate `erlang-wx` (or similarly named) package.
+
+The above will open another Graphical User Interface that provides many panes to fully understand and navigate the runtime and your project.
+
+We explore the Observer in the context of an actual project [in the Dynamic Supervisor chapter of the Mix & OTP guide](../mix-and-otp/dynamic-supervisor.md). This is one of the debugging techniques [the Phoenix framework used to achieve 2 million connections on a single machine](https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections).
+
+If you are using the Phoenix web framework, it ships with the [Phoenix LiveDashboard](https://github.com/phoenixframework/phoenix_live_dashboard), a web dashboard for production nodes which provides similar features to Observer.
+
+Finally, remember you can also get a mini-overview of the runtime info by calling `runtime_info/0` directly in IEx.
+
+## Other tools and community
+
+We have just scratched the surface of what the Erlang VM has to offer, for example:
+
+  * Alongside the observer application, Erlang also includes a [`:crashdump_viewer`](`:crashdump_viewer`) to view crash dumps
+
+  * Integration with OS level tracers, such as [Linux Trace Toolkit](https://www.erlang.org/doc/apps/runtime_tools/lttng), [DTRACE](https://www.erlang.org/doc/apps/runtime_tools/dtrace), and [SystemTap](https://www.erlang.org/doc/apps/runtime_tools/systemtap)
+
+  * [Microstate accounting](`:msacc`) measures how much time the runtime spends in several low-level tasks in a short time interval
+
+  * Mix ships with many tasks under the `profile` namespace, such as `mix profile.cprof` and `mix profile.fprof`
+
+  * For more advanced use cases, we recommend the excellent [Erlang in Anger](https://www.erlang-in-anger.com/), which is available as a free ebook
+
+Happy debugging!
diff --git a/lib/elixir/pages/getting-started/enumerable-and-streams.md b/lib/elixir/pages/getting-started/enumerable-and-streams.md
new file mode 100644
index 00000000000..b544b973ddb
--- /dev/null
+++ b/lib/elixir/pages/getting-started/enumerable-and-streams.md
@@ -0,0 +1,113 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Enumerables and Streams
+
+While Elixir allows us to write recursive code, most operations we perform on collections is done with the help of the `Enum` and `Stream` modules. Let's learn how.
+
+## Enumerables
+
+Elixir provides the concept of enumerables and the `Enum` module to work with them. We have already learned two enumerables: lists and maps.
+
+```elixir
+iex> Enum.map([1, 2, 3], fn x -> x * 2 end)
+[2, 4, 6]
+iex> Enum.map(%{1 => 2, 3 => 4}, fn {k, v} -> k * v end)
+[2, 12]
+```
+
+The `Enum` module provides a huge range of functions to transform, sort, group, filter and retrieve items from enumerables. It is one of the modules developers use frequently in their Elixir code. For a general overview of all functions in the `Enum` module, see [the `Enum` cheatsheet](enum-cheat.cheatmd).
+
+Elixir also provides ranges (see `Range`), which are also enumerable:
+
+```elixir
+iex> Enum.map(1..3, fn x -> x * 2 end)
+[2, 4, 6]
+iex> Enum.reduce(1..3, 0, &+/2)
+6
+```
+
+The functions in the `Enum` module are limited to, as the name says, enumerating values in data structures. For specific operations, like inserting and updating particular elements, you may need to reach for modules specific to the data type. For example, if you want to insert an element at a given position in a list, you should use the `List.insert_at/3` function, as it would make little sense to insert a value into, for example, a range.
+
+We say the functions in the `Enum` module are polymorphic because they can work with diverse data types. In particular, the functions in the `Enum` module can work with any data type that implements the `Enumerable` protocol. We are going to discuss Protocols in a later chapter, for now we are going to move on to a specific kind of enumerable called a stream.
+
+## Eager vs Lazy
+
+All the functions in the `Enum` module are eager. Many functions expect an enumerable and return a list back:
+
+```elixir
+iex> odd? = fn x -> rem(x, 2) != 0 end
+#Function<6.80484245/1 in :erl_eval.expr/5>
+iex> Enum.filter(1..3, odd?)
+[1, 3]
+```
+
+This means that when performing multiple operations with `Enum`, each operation is going to generate an intermediate list until we reach the result:
+
+```elixir
+iex> 1..100_000 |> Enum.map(&(&1 * 3)) |> Enum.filter(odd?) |> Enum.sum()
+7500000000
+```
+
+The example above has a pipeline of operations. We start with a range and then multiply each element in the range by 3. This first operation will now create and return a list with `100_000` items. Then we keep all odd elements from the list, generating a new list, now with `50_000` items, and then we sum all entries.
+
+## The pipe operator
+
+The `|>` symbol used in the snippet above is the **pipe operator**: it takes the output from the expression on its left side and passes it as the first argument to the function call on its right side. Its purpose is to highlight the data being transformed by a series of functions. To see how it can make the code cleaner, have a look at the example above rewritten without using the `|>` operator:
+
+```elixir
+iex> Enum.sum(Enum.filter(Enum.map(1..100_000, &(&1 * 3)), odd?))
+7500000000
+```
+
+Find more about the pipe operator [by reading its documentation](`|>/2`).
+
+## Streams
+
+As an alternative to `Enum`, Elixir provides the `Stream` module which supports lazy operations:
+
+```elixir
+iex> 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?) |> Enum.sum()
+7500000000
+```
+
+Streams are lazy, composable enumerables.
+
+In the example above, `1..100_000 |> Stream.map(&(&1 * 3))` returns a data type, an actual stream, that represents the `map` computation over the range `1..100_000`:
+
+```elixir
+iex> 1..100_000 |> Stream.map(&(&1 * 3))
+#Stream<[enum: 1..100000, funs: [#Function<34.16982430/1 in Stream.map/2>]]>
+```
+
+Furthermore, they are composable because we can pipe many stream operations:
+
+```elixir
+iex> 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?)
+#Stream<[enum: 1..100000, funs: [...]]>
+```
+
+Instead of generating intermediate lists, streams build a series of computations that are invoked only when we pass the underlying stream to the `Enum` module. Streams are useful when working with large, *possibly infinite*, collections.
+
+Many functions in the `Stream` module accept any enumerable as an argument and return a stream as a result. It also provides functions for creating streams. For example, `Stream.cycle/1` can be used to create a stream that cycles a given enumerable infinitely. Be careful to not call a function like `Enum.map/2` on such streams, as they would cycle forever:
+
+```elixir
+iex> stream = Stream.cycle([1, 2, 3])
+#Function<15.16982430/2 in Stream.unfold/2>
+iex> Enum.take(stream, 10)
+[1, 2, 3, 1, 2, 3, 1, 2, 3, 1]
+```
+
+Another interesting function is `Stream.resource/3` which can be used to wrap around resources, guaranteeing they are opened right before enumeration and closed afterwards, even in the case of failures. For example, `File.stream!/1` builds on top of `Stream.resource/3` to stream files:
+
+```elixir
+iex> "path/to/file" |> File.stream!() |> Enum.take(10)
+```
+
+The example above will fetch the first 10 lines of the file you have selected. This means streams can be very useful for handling large files or even slow resources like network resources.
+
+The `Enum` and `Stream` modules provide a wide range of functions, but you don't have to know all of them by heart. Familiarize yourself with `Enum.map/2`, `Enum.reduce/3` and other functions with either `map` or `reduce` in their names, and you will naturally build an intuition around the most important use cases. You may also focus on the `Enum` module first and only move to `Stream` for the particular scenarios where laziness is required, to either deal with slow resources or large, possibly infinite, collections.
+
+Next, we'll look at a feature central to Elixir, Processes, which allows us to write concurrent, parallel and distributed programs in an easy and understandable way.
diff --git a/lib/elixir/pages/getting-started/erlang-libraries.md b/lib/elixir/pages/getting-started/erlang-libraries.md
new file mode 100644
index 00000000000..08c6db79d6d
--- /dev/null
+++ b/lib/elixir/pages/getting-started/erlang-libraries.md
@@ -0,0 +1,193 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Erlang libraries
+
+Elixir provides excellent interoperability with Erlang libraries. In fact, Elixir discourages simply wrapping Erlang libraries in favor of directly interfacing with Erlang code. In this section, we will present some of the most common and useful Erlang functionality that is not found in Elixir.
+
+Erlang modules have a different naming convention than in Elixir and start in lowercase. In both cases, module names are atoms and we invoke functions by dispatching to the module name:
+
+```elixir
+iex> is_atom(String)
+true
+iex> String.first("hello")
+"h"
+iex> is_atom(:binary)
+true
+iex> :binary.first("hello")
+104
+```
+
+As you grow more proficient in Elixir, you may want to explore the Erlang [STDLIB Reference Manual](http://www.erlang.org/doc/apps/stdlib/index.html) in more detail.
+
+## The binary module
+
+The built-in Elixir String module handles binaries that are UTF-8 encoded. [The `:binary` module](`:binary`) is useful when you are dealing with binary data that is not necessarily UTF-8 encoded.
+
+```elixir
+iex> String.to_charlist("Ø")
+[216]
+iex> :binary.bin_to_list("Ø")
+[195, 152]
+```
+
+The above example shows the difference; the `String` module returns Unicode codepoints, while `:binary` deals with raw data bytes.
+
+## Formatted text output
+
+Elixir does not contain a function similar to `printf` found in C and other languages. Luckily, the Erlang standard library functions `:io.format/2` and `:io_lib.format/2` may be used. The first formats to terminal output, while the second formats to an iolist. The format specifiers differ from `printf`, [refer to the Erlang documentation for details](`:io.format/2`).
+
+```elixir
+iex> :io.format("Pi is approximately given by:~10.3f~n", [:math.pi])
+Pi is approximately given by:     3.142
+:ok
+iex> to_string(:io_lib.format("Pi is approximately given by:~10.3f~n", [:math.pi]))
+"Pi is approximately given by:     3.142\n"
+```
+
+## The crypto module
+
+[The `:crypto` module](`:crypto`) contains hashing functions, digital signatures, encryption and more:
+
+```elixir
+iex> Base.encode16(:crypto.hash(:sha256, "Elixir"))
+"3315715A7A3AD57428298676C5AE465DADA38D951BDFAC9348A8A31E9C7401CB"
+```
+
+The `:crypto` module is part of the `:crypto` application that ships with Erlang. This means you must list the `:crypto` application as an additional application in your project configuration. To do this, edit your `mix.exs` file to include:
+
+```elixir
+def application do
+  [extra_applications: [:crypto]]
+end
+```
+
+Any module that is not part of the `:kernel` or `:stdlib` Erlang applications must have their application explicitly listed in your `mix.exs`. You can find the application name of any Erlang module in the Erlang documentation, immediately below the Erlang logo in the sidebar.
+
+## The digraph module
+
+The [`:digraph`](`:digraph`) and [`:digraph_utils`](`:digraph_utils`) modules contain functions for dealing with directed graphs built of vertices and edges. After constructing the graph, the algorithms in there will help find, for instance, the shortest path between two vertices, or loops in the graph.
+
+Given three vertices, find the shortest path from the first to the last.
+
+```elixir
+iex> digraph = :digraph.new()
+iex> coords = [{0.0, 0.0}, {1.0, 0.0}, {1.0, 1.0}]
+iex> [v0, v1, v2] = (for c <- coords, do: :digraph.add_vertex(digraph, c))
+iex> :digraph.add_edge(digraph, v0, v1)
+iex> :digraph.add_edge(digraph, v1, v2)
+iex> :digraph.get_short_path(digraph, v0, v2)
+[{0.0, 0.0}, {1.0, 0.0}, {1.0, 1.0}]
+```
+
+Note that the functions in `:digraph` alter the graph structure in-place, this
+is possible because they are implemented as ETS tables, explained next.
+
+## Erlang Term Storage (ETS)
+
+The modules [`:ets`](`:ets`) and [`:dets`](`:dets`) handle storage of large data structures in memory or on disk respectively.
+
+ETS lets you create a table containing tuples. By default, ETS tables are protected, which means only the owner process may write to the table but any other process can read. ETS has some functionality to allow a table to be used as a simple database, a key-value store or as a cache mechanism.
+
+The functions in the `ets` module will modify the state of the table as a side-effect.
+
+```elixir
+iex> table = :ets.new(:ets_test, [])
+# Store as tuples with {name, population}
+iex> :ets.insert(table, {"China", 1_374_000_000})
+iex> :ets.insert(table, {"India", 1_284_000_000})
+iex> :ets.insert(table, {"USA", 322_000_000})
+iex> :ets.i(table)
+<1   > {<<"India">>,1284000000}
+<2   > {<<"USA">>,322000000}
+<3   > {<<"China">>,1374000000}
+```
+
+## The math module
+
+The [`:math`](`:math`) module contains common mathematical operations covering trigonometry, exponential, and logarithmic functions.
+
+```elixir
+iex> angle_45_deg = :math.pi() * 45.0 / 180.0
+iex> :math.sin(angle_45_deg)
+0.7071067811865475
+iex> :math.exp(55.0)
+7.694785265142018e23
+iex> :math.log(7.694785265142018e23)
+55.0
+```
+
+## The queue module
+
+The [`:queue`](`:queue`) module provides a data structure that implements (double-ended) FIFO (first-in first-out) queues efficiently:
+
+```elixir
+iex> q = :queue.new
+iex> q = :queue.in("A", q)
+iex> q = :queue.in("B", q)
+iex> {value, q} = :queue.out(q)
+iex> value
+{:value, "A"}
+iex> {value, q} = :queue.out(q)
+iex> value
+{:value, "B"}
+iex> {value, q} = :queue.out(q)
+iex> value
+:empty
+```
+
+## The rand module
+
+The [`:rand`](`:rand`) has functions for returning random values and setting the random seed.
+
+```elixir
+iex> :rand.uniform()
+0.8175669086010815
+iex> _ = :rand.seed(:exs1024, {123, 123_534, 345_345})
+iex> :rand.uniform()
+0.5820506340260994
+iex> :rand.uniform(6)
+6
+```
+
+## The zip and zlib modules
+
+The [`:zip`](`:zip`) module lets you read and write ZIP files to and from disk or memory, as well as extracting file information.
+
+This code counts the number of files in a ZIP file:
+
+```elixir
+iex> :zip.foldl(fn _, _, _, acc -> acc + 1 end, 0, :binary.bin_to_list("file.zip"))
+{:ok, 633}
+```
+
+The [`:zlib`](`:zlib`) module deals with data compression in zlib format, as found in the `gzip` command line utility found in Unix systems.
+
+```elixir
+iex> song = "
+...> Mary had a little lamb,
+...> His fleece was white as snow,
+...> And everywhere that Mary went,
+...> The lamb was sure to go."
+iex> compressed = :zlib.compress(song)
+iex> byte_size(song)
+110
+iex> byte_size(compressed)
+99
+iex> :zlib.uncompress(compressed)
+"\nMary had a little lamb,\nHis fleece was white as snow,\nAnd everywhere that Mary went,\nThe lamb was sure to go."
+```
+
+## Learning Erlang
+
+If you want to get deeper into Erlang, here's a list of online resources that cover Erlang's fundamentals and its more advanced features:
+
+  * This [Erlang Syntax: A Crash Course](https://elixir-lang.org/crash-course.html) provides a concise intro to Erlang's syntax. Each code snippet is accompanied by equivalent code in Elixir. This is an opportunity for you to not only get some exposure to Erlang's syntax but also review what you learned about Elixir.
+
+  * Erlang's official website has a short [tutorial](https://www.erlang.org/course). There is a chapter with pictures briefly describing Erlang's primitives for [concurrent programming](https://www.erlang.org/course/concurrent_programming.html).
+
+  * [Learn You Some Erlang for Great Good!](http://learnyousomeerlang.com/) is an excellent introduction to Erlang, its design principles, standard library, best practices, and much more. Once you have read through the crash course mentioned above, you'll be able to safely skip the first couple of chapters in the book that mostly deal with the syntax. When you reach [The Hitchhiker's Guide to Concurrency](http://learnyousomeerlang.com/the-hitchhikers-guide-to-concurrency) chapter, that's where the real fun starts.
+
+Our last step is to take a look at existing Elixir (and Erlang) libraries you might use while debugging.
diff --git a/lib/elixir/pages/getting-started/introduction.md b/lib/elixir/pages/getting-started/introduction.md
new file mode 100644
index 00000000000..c642addcdce
--- /dev/null
+++ b/lib/elixir/pages/getting-started/introduction.md
@@ -0,0 +1,60 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Introduction
+
+Welcome!
+
+This guide will teach you about Elixir fundamentals - the language syntax, how to define modules, the common data structures in the language, and more. This chapter will focus on ensuring that Elixir is installed and that you can successfully run Elixir's Interactive Shell, called IEx.
+
+Let's get started.
+
+## Installation
+
+If you haven't yet installed Elixir, visit our [installation page](https://elixir-lang.org/install.html). Once you are done, you can run `elixir --version` to get the current Elixir version. The requirements for this guide are:
+
+  * Elixir 1.15.0 onwards
+  * Erlang/OTP 26 onwards
+
+If you are looking for other resources for learning Elixir, you can also consult the [learning page](https://elixir-lang.org/learning.html) of the official website.
+
+## Interactive mode
+
+When you install Elixir, you will have three new command line executables: `iex`, `elixir` and `elixirc`.
+
+For now, let's start by running `iex` (or `iex.bat` if you are on Windows PowerShell, where `iex` is a PowerShell command) which stands for Interactive Elixir. In interactive mode, we can type any Elixir expression and get its result. Let's warm up with some basic expressions.
+
+Open up `iex` and type the following expressions:
+
+```elixir
+Erlang/OTP 26 [64-bit] [smp:2:2] [...]
+
+Interactive Elixir - press Ctrl+C to exit
+iex(1)> 40 + 2
+42
+iex(2)> "hello" <> " world"
+"hello world"
+```
+
+Please note that some details like version numbers may differ a bit in your session, that's not important. By executing the code above, you should evaluate expressions and see their results. To exit `iex` press `Ctrl+C` twice.
+
+It seems we are ready to go! We will use the interactive shell quite a lot in the next chapters to get a bit more familiar with the language constructs and basic types, starting in the next chapter.
+
+## Running scripts
+
+After getting familiar with the basics of the language you may want to try writing simple programs. This can be accomplished by putting the following Elixir code into a file:
+
+```elixir
+IO.puts("Hello world from Elixir")
+```
+
+Save it as `simple.exs` and execute it with `elixir`:
+
+```console
+$ elixir simple.exs
+Hello world from Elixir
+```
+
+`iex` and `elixir` are all we need to learn the main language concepts. There is a separate guide named ["Mix and OTP guide"](../mix-and-otp/introduction-to-mix.md) that explores how to actually create, manage, and test full-blown Elixir projects. For now, let's move on to learn the basic data types in the language.
diff --git a/lib/elixir/pages/getting-started/io-and-the-file-system.md b/lib/elixir/pages/getting-started/io-and-the-file-system.md
new file mode 100644
index 00000000000..3ffff5d8375
--- /dev/null
+++ b/lib/elixir/pages/getting-started/io-and-the-file-system.md
@@ -0,0 +1,208 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# IO and the file system
+
+This chapter introduces the input/output mechanisms, file-system-related tasks, and related modules such as `IO`, `File`, and `Path`. The IO system provides a great opportunity to shed some light on some philosophies and curiosities of Elixir and the Erlang VM.
+
+## The `IO` module
+
+The `IO` module is the main mechanism in Elixir for reading and writing to standard input/output (`:stdio`), standard error (`:stderr`), files, and other IO devices. Usage of the module is pretty straightforward:
+
+```elixir
+iex> IO.puts("hello world")
+hello world
+:ok
+iex> IO.gets("yes or no? ")
+yes or no? yes
+"yes\n"
+```
+
+By default, functions in the `IO` module read from the standard input and write to the standard output. We can change that by passing, for example, `:stderr` as an argument (in order to write to the standard error device):
+
+```elixir
+iex> IO.puts(:stderr, "hello world")
+hello world
+:ok
+```
+
+## The `File` module
+
+The `File` module contains functions that allow us to open files as IO devices. By default, files are opened in binary mode, which requires developers to use the specific `IO.binread/2` and `IO.binwrite/2` functions from the `IO` module:
+
+> #### Potential data loss warning {: .warning}
+>
+> The following code opens a file for writing. If an existing file is available at the given path, its contents will be deleted.
+
+```elixir
+iex> {:ok, file} = File.open("path/to/file/hello", [:write])
+{:ok, #PID<0.47.0>}
+iex> IO.binwrite(file, "world")
+:ok
+iex> File.close(file)
+:ok
+iex> File.read("path/to/file/hello")
+{:ok, "world"}
+```
+
+The file could be opened with the `:append` option, instead of `:write`, to preserve its contents. You may also pass the `:utf8` option, which tells the `File` module to interpret the bytes read from the file as UTF-8-encoded bytes.
+
+Besides functions for opening, reading and writing files, the `File` module has many functions to work with the file system. Those functions are named after their UNIX equivalents. For example, `File.rm/1` can be used to remove files, `File.mkdir/1` to create directories, `File.mkdir_p/1` to create directories and all their parent chain. There are even `File.cp_r/2` and `File.rm_rf/1` to respectively copy and remove files and directories recursively (i.e., copying and removing the contents of the directories too).
+
+You will also notice that functions in the `File` module have two variants: one "regular" variant and another variant with a trailing bang (`!`). For example, when we read the `"hello"` file in the example above, we use `File.read/1`. Alternatively, we can use `File.read!/1`:
+
+```elixir
+iex> File.read("path/to/file/hello")
+{:ok, "world"}
+iex> File.read!("path/to/file/hello")
+"world"
+iex> File.read("path/to/file/unknown")
+{:error, :enoent}
+iex> File.read!("path/to/file/unknown")
+** (File.Error) could not read file "path/to/file/unknown": no such file or directory
+```
+
+Notice that the version with `!` returns the contents of the file instead of a tuple, and if anything goes wrong the function raises an error.
+
+The version without `!` is preferred when you want to handle different outcomes using pattern matching:
+
+```elixir
+case File.read("path/to/file/hello") do
+  {:ok, body} -> # do something with the `body`
+  {:error, reason} -> # handle the error caused by `reason`
+end
+```
+
+However, if you expect the file to be there, the bang variation is more useful as it raises a meaningful error message. Avoid writing:
+
+```elixir
+{:ok, body} = File.read("path/to/file/unknown")
+```
+
+as, in case of an error, `File.read/1` will return `{:error, reason}` and the pattern matching will fail. You will still get the desired result (a raised error), but the message will be about the pattern which doesn't match (thus being cryptic in respect to what the error actually is about).
+
+Therefore, if you don't want to handle the error outcomes, prefer to use the functions ending with an exclamation mark, such as `File.read!/1`.
+
+## The `Path` module
+
+The majority of the functions in the `File` module expect paths as arguments. Most commonly, those paths will be regular binaries. The `Path` module provides facilities for working with such paths:
+
+```elixir
+iex> Path.join("foo", "bar")
+"foo/bar"
+iex> Path.expand("~/hello")
+"/Users/jose/hello"
+```
+
+Using functions from the `Path` module as opposed to directly manipulating strings is preferred since the `Path` module takes care of different operating systems transparently. Finally, keep in mind that Elixir will automatically convert slashes (`/`) into backslashes (`\`) on Windows when performing file operations.
+
+With this, we have covered the main modules that Elixir provides for dealing with IO and interacting with the file system. In the next section, we will peek a bit under the covers and learn how the IO system is implemented in the VM.
+
+## Processes
+
+You may have noticed that `File.open/2` returns a tuple like `{:ok, pid}`:
+
+```elixir
+iex> {:ok, file} = File.open("hello")
+{:ok, #PID<0.47.0>}
+```
+
+This happens because the `IO` module actually works with processes (see [the previous chapter](processes.md)). Given a file is a process, when you write to a file that has been closed, you are actually sending a message to a process which has been terminated:
+
+```elixir
+iex> File.close(file)
+:ok
+iex> IO.write(file, "is anybody out there")
+** (ErlangError) Erlang error: :terminated:
+
+  * 1st argument: the device has terminated
+
+    (stdlib 5.0) io.erl:94: :io.put_chars(#PID<0.114.0>, "is anybody out there")
+    iex:4: (file)
+```
+
+Let's see in more detail what happens when you request `IO.write(pid, binary)`. The `IO` module sends a message to the process identified by `pid` with the desired operation. A small ad-hoc process can help us see it:
+
+```elixir
+iex> pid = spawn(fn ->
+...>   receive do
+...>     msg -> IO.inspect(msg)
+...>   end
+...> end)
+#PID<0.57.0>
+iex> IO.write(pid, "hello")
+{:io_request, #PID<0.41.0>, #Reference<0.0.8.91>,
+ {:put_chars, :unicode, "hello"}}
+** (ErlangError) erlang error: :terminated
+```
+
+After `IO.write/2`, we can see the request sent by the `IO` module printed out (a four-elements tuple). Soon after that, we see that it fails since the `IO` module expected some kind of result, which we did not supply.
+
+By modeling IO devices with processes, the Erlang VM allows us to even read and write to files across nodes. Neat!
+
+## `iodata` and `chardata`
+
+In all of the examples above, we used binaries when writing to files. However, most of the IO functions in Elixir also accept either "iodata" or "chardata".
+
+One of the main reasons for using "iodata" and "chardata" is for performance. For example,
+imagine you need to greet someone in your application:
+
+```elixir
+name = "Mary"
+IO.puts("Hello " <> name <> "!")
+```
+
+Given strings in Elixir are immutable, as most data structures, the example above will copy the string "Mary" into the new "Hello Mary!" string. While this is unlikely to matter for the short string as above, copying can be quite expensive for large strings! For this reason, the IO functions in Elixir allow you to pass instead a list of strings:
+
+```elixir
+name = "Mary"
+IO.puts(["Hello ", name, "!"])
+```
+
+In the example above, there is no copying. Instead we create a list that contains the original name. We call such lists either "iodata" or "chardata" and we will learn the precise difference between them soon.
+
+Those lists are very useful because it can actually simplify the processing strings in several scenarios. For example, imagine you have a list of values, such as `["apple", "banana", "lemon"]` that you want to write to disk separated by commas. How can you achieve this?
+
+One option is to use `Enum.join/2` and convert the values to a string:
+
+```elixir
+iex> Enum.join(["apple", "banana", "lemon"], ",")
+"apple,banana,lemon"
+```
+
+The above returns a new string by copying each value into the new string. However, with the knowledge in this section, we know that we can pass a list of strings to the IO/File functions. So instead we can do:
+
+```elixir
+iex> Enum.intersperse(["apple", "banana", "lemon"], ",")
+["apple", ",", "banana", ",", "lemon"]
+```
+
+"iodata" and "chardata" do not only contain strings, but they may contain arbitrary nested lists of strings too:
+
+```elixir
+iex> IO.puts(["apple", [",", "banana", [",", "lemon"]]])
+```
+
+"iodata" and "chardata" may also contain integers. For example, we could print our comma separated list of values by using `?,` as separator, which is the integer representing a comma (`44`):
+
+```elixir
+iex> IO.puts(["apple", ?,, "banana", ?,, "lemon"])
+```
+
+The difference between "iodata" and "chardata" is precisely what said integer represents. For iodata, the integers represent bytes. For chardata, the integers represent Unicode codepoints. For ASCII characters, the byte representation is the same as the codepoint representation, so it fits both classifications. However, the default IO device works with chardata, which means we can do:
+
+```elixir
+iex> IO.puts([?O, ?l, ?á, ?\s, "Mary", ?!])
+```
+
+Charlists, such as `~c"hello world"`, are lists of integers, and therefore are chardata.
+
+We packed a lot into this small section, so let's break it down:
+
+  * iodata and chardata are lists of binaries and integers. Those binaries and integers can be arbitrarily nested inside lists. Their goal is to give flexibility and performance when working with IO devices and files;
+
+  * the choice between iodata and chardata depends on the encoding of the IO device. If the file is opened without encoding, the file expects iodata, and the functions in the `IO` module starting with `bin*` must be used. The default IO device (`:stdio`) and files opened with `:utf8` encoding expect chardata and work with the remaining functions in the `IO` module;
+
+This finishes our tour of IO devices and IO related functionality. We have learned about three Elixir modules - `IO`, `File`, and `Path` - as well as how the VM uses processes for the underlying IO mechanisms and how to use `chardata` and `iodata` for IO operations.
diff --git a/lib/elixir/pages/getting-started/keywords-and-maps.md b/lib/elixir/pages/getting-started/keywords-and-maps.md
new file mode 100644
index 00000000000..656e84c96ca
--- /dev/null
+++ b/lib/elixir/pages/getting-started/keywords-and-maps.md
@@ -0,0 +1,286 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Keyword lists and maps
+
+Now let's talk about associative data structures. Associative data structures are able to associate a key to a certain value. Different languages call these different names like dictionaries, hashes, associative arrays, etc.
+
+In Elixir, we have two main associative data structures: keyword lists and maps.
+
+## Keyword lists
+
+Keyword lists are a data-structure used to pass options to functions. Let's see a scenario where they may be useful.
+
+Imagine you want to split a string of numbers. Initially, we can invoke `String.split/2` passing two strings as arguments:
+
+```elixir
+iex> String.split("1 2 3 4", " ")
+["1", "2", "3", "4"]
+```
+
+What if you only want to split at most 2 times? The `String.split/3` function allows the `parts` option to be set to the maximum number of entries in the result:
+
+```elixir
+iex> String.split("1 2 3 4", " ", [parts: 3])
+["1", "2", "3 4"]
+```
+
+As you can see, we got 3 parts, the last one containing the remaining of the input without splitting it.
+
+Now imagine that some of the inputs you must split on contains additional spaces between the numbers:
+
+```elixir
+iex> String.split("1  2  3  4", " ", [parts: 3])
+["1", "", "2  3  4"]
+```
+
+As you can see, the additional spaces lead to empty entries in the output. Luckily, we can also set the `trim` option to `true` to remove them:
+
+```elixir
+iex> String.split("1  2  3  4", " ", [parts: 3, trim: true])
+["1", "2", " 3  4"]
+```
+
+Once again we got 3 parts, with the last one containing the leftovers.
+
+`[parts: 3]` and `[parts: 3, trim: true]` are keyword lists. When a keyword list is the last argument of a function, we can skip the brackets and write:
+
+```elixir
+iex> String.split("1  2  3  4", " ", parts: 3, trim: true)
+["1", "2", " 3  4"]
+```
+
+As shown in the example above, keyword lists are mostly used as optional arguments to functions.
+
+As the name implies, keyword lists are simply lists. In particular, they are lists consisting of 2-item tuples where the first element (the key) is an atom and the second element can be any value. Both representations are the same:
+
+```elixir
+iex> [{:parts, 3}, {:trim, true}] == [parts: 3, trim: true]
+true
+```
+
+Keyword lists are important because they have three special characteristics:
+
+  * Keys must be atoms.
+  * Keys are ordered, as specified by the developer.
+  * Keys can be given more than once.
+
+For example, we use the fact that keys can be repeated when [importing functions](../getting-started/alias-require-and-import.md) in Elixir:
+
+```elixir
+iex> import String, only: [split: 1, split: 2]
+String
+iex> split("hello world")
+["hello", "world"]
+```
+
+In the example above, we imported both `split/1` and `split/2` from the `String` module, allowing us to invoke them without typing the module name. We used a keyword list to list the functions to import.
+
+Since keyword lists are lists, we can use all operations available to lists. For example, we can use `++` to add new values to a keyword list:
+
+```elixir
+iex> list = [a: 1, b: 2]
+[a: 1, b: 2]
+iex> list ++ [c: 3]
+[a: 1, b: 2, c: 3]
+iex> [a: 0] ++ list
+[a: 0, a: 1, b: 2]
+```
+
+You can read the value of a keyword list using the brackets syntax, which will return the value of the first matching key. This is also known as the access syntax, as it is defined by the `Access` module:
+
+```elixir
+iex> list[:a]
+1
+iex> list[:b]
+2
+```
+
+Although we can pattern match on keyword lists, it is not done in practice since pattern matching on lists requires the number of items and their order to match:
+
+```elixir
+iex> [a: a] = [a: 1]
+[a: 1]
+iex> a
+1
+iex> [a: a] = [a: 1, b: 2]
+** (MatchError) no match of right hand side value: [a: 1, b: 2]
+iex> [b: b, a: a] = [a: 1, b: 2]
+** (MatchError) no match of right hand side value: [a: 1, b: 2]
+```
+
+Furthermore, given keyword lists are often used as optional arguments, they are used in situations where not all keys may be present, which would make it impossible to match on them. In a nutshell, do not pattern match on keyword lists.
+
+In order to manipulate keyword lists, Elixir provides the `Keyword` module. Remember, though, keyword lists are simply lists, and as such they provide the same linear performance characteristics: the longer the list, the longer it will take to find a key, to count the number of items, and so on. If you need to store a large amount of keys in a key-value data structure, Elixir offers maps, which we will soon learn.
+
+### `do`-blocks and keywords
+
+As we have seen, keywords are mostly used in the language to pass optional values. In fact, we have used keywords in earlier chapters. Let's look at the `if/2` macro:
+
+```elixir
+iex> if true do
+...>   "This will be seen"
+...> else
+...>   "This won't"
+...> end
+"This will be seen"
+```
+
+In the example above, the `do` and `else` blocks make up a keyword list. They are nothing more than a syntax convenience on top of keyword lists. We can rewrite the above to:
+
+```elixir
+iex> if(true, do: "This will be seen", else: "This won't")
+"This will be seen"
+```
+
+Pay close attention to both syntaxes. The second example uses keyword lists, exactly as in the `String.split/3` example, so we separate each key-value pair with commas and each key is followed by `:`. In the `do`-blocks, we use bare words, such as `do`, `else`, and `end`, and separate them by a newline. They are useful precisely when writing blocks of code. Most of the time, you will use the block syntax, but it is good to know they are equivalent.
+
+The fact the block syntax is equivalent to keywords means we only need few data structures to represent the language, keeping it simple overall. We will come back to this topic when discussing [optional syntax](optional-syntax.md) and [meta-programming](../meta-programming/quote-and-unquote.md).
+
+With this out of the way, let's talk about maps.
+
+## Maps as key-value pairs
+
+Whenever you need to store key-value pairs, maps are the "go to" data structure in Elixir. A map is created using the `%{}` syntax:
+
+```elixir
+iex> map = %{:a => 1, 2 => :b}
+%{2 => :b, :a => 1}
+iex> map[:a]
+1
+iex> map[2]
+:b
+iex> map[:c]
+nil
+```
+
+Compared to keyword lists, we can already see two differences:
+
+  * Maps allow any value as a key.
+  * Maps have their own internal ordering, which is not guaranteed to be the same across different maps, even if they have the same keys
+
+In contrast to keyword lists, maps are very useful with pattern matching. When a map is used in a pattern, it will always match on a subset of the given value:
+
+```elixir
+iex> %{} = %{:a => 1, 2 => :b}
+%{2 => :b, :a => 1}
+iex> %{:a => a} = %{:a => 1, 2 => :b}
+%{2 => :b, :a => 1}
+iex> a
+1
+iex> %{:c => c} = %{:a => 1, 2 => :b}
+** (MatchError) no match of right hand side value: %{2 => :b, :a => 1}
+```
+
+As shown above, a map matches as long as the keys in the pattern exist in the given map. Therefore, an empty map matches all maps.
+
+The `Map` module provides a very similar API to the `Keyword` module with convenience functions to add, remove, and update maps keys:
+
+```elixir
+iex> Map.get(%{:a => 1, 2 => :b}, :a)
+1
+iex> Map.put(%{:a => 1, 2 => :b}, :c, 3)
+%{2 => :b, :a => 1, :c => 3}
+iex> Map.to_list(%{:a => 1, 2 => :b})
+[{2, :b}, {:a, 1}]
+```
+
+## Maps of predefined keys
+
+In the previous section, we have used maps as a key-value data structure where keys can be added or removed at any time. However, it is also common to create maps with a predefined set of keys. Their values may be updated, but new keys are never added nor removed. This is useful when we know the shape of the data we are working with and, if we get a different key, it likely means a mistake was done elsewhere. In such cases, the keys are most often atoms:
+
+```elixir
+iex> map = %{:name => "John", :age => 23}
+%{name: "John", age: 23}
+```
+
+As you can see from the printed result above, Elixir also allows you to write maps of atom keys using the same `key: value` syntax as keyword lists:
+
+```elixir
+iex> map = %{name: "John", age: 23}
+%{name: "John", age: 23}
+```
+
+When a key is an atom, we can also access them using the `map.key` syntax:
+
+```elixir
+iex> map.name
+"John"
+iex> map.agee
+** (KeyError) key :agee not found in: %{name: "John", age: 23}
+```
+
+There is also syntax for updating keys, which also raises if the key has not yet been defined:
+
+```elixir
+iex> %{map | name: "Mary"}
+%{name: "Mary", age: 23}
+iex> %{map | agee: 27}
+** (KeyError) key :agee not found in: %{name: "John", age: 23}
+```
+
+These operations have one large benefit in that they raise if the key does not exist in the map and the compiler may even detect and warn when possible. This makes them useful to get quick feedback and spot bugs and typos early on. This is also the syntax used to power another Elixir feature called "Structs", which we will learn later on.
+
+Elixir developers typically prefer to use the `map.key` syntax and pattern matching instead of the functions in the `Map` module when working with maps because they lead to an assertive style of programming. [This blog post by José Valim](https://dashbit.co/blog/writing-assertive-code-with-elixir) provides insight and examples on how you get more concise and faster software by writing assertive code in Elixir.
+
+In a further chapter you'll learn about ["Structs"](structs.md), which further enforce the idea of a map with predefined keys.
+
+## Nested data structures
+
+Often we will have maps inside maps, or even keywords lists inside maps, and so forth. Elixir provides conveniences for manipulating nested data structures via the `get_in/1`, `put_in/2`, `update_in/2`, and other macros giving the same conveniences you would find in imperative languages while keeping the immutable properties of the language.
+
+Imagine you have the following structure:
+
+```elixir
+iex> users = [
+  john: %{name: "John", age: 27, languages: ["Erlang", "Ruby", "Elixir"]},
+  mary: %{name: "Mary", age: 29, languages: ["Elixir", "F#", "Clojure"]}
+]
+[
+  john: %{age: 27, languages: ["Erlang", "Ruby", "Elixir"], name: "John"},
+  mary: %{age: 29, languages: ["Elixir", "F#", "Clojure"], name: "Mary"}
+]
+```
+
+We have a keyword list of users where each value is a map containing the name, age and a list of programming languages each user likes. If we wanted to access the age for john, we could write:
+
+```elixir
+iex> users[:john].age
+27
+```
+
+It happens we can also use this same syntax for updating the value:
+
+```elixir
+iex> users = put_in(users[:john].age, 31)
+[
+  john: %{age: 31, languages: ["Erlang", "Ruby", "Elixir"], name: "John"},
+  mary: %{age: 29, languages: ["Elixir", "F#", "Clojure"], name: "Mary"}
+]
+```
+
+The `update_in/2` macro is similar but allows us to pass a function that controls how the value changes. For example, let's remove "Clojure" from Mary's list of languages:
+
+```elixir
+iex> users = update_in(users[:mary].languages, fn languages -> List.delete(languages, "Clojure") end)
+[
+  john: %{age: 31, languages: ["Erlang", "Ruby", "Elixir"], name: "John"},
+  mary: %{age: 29, languages: ["Elixir", "F#"], name: "Mary"}
+]
+```
+
+## Summary
+
+There are two different data structures for working with key-value stores in Elixir. Alongside the `Access` module and pattern matching, they provide a rich set of tools for manipulating complex, potentially nested, data structures.
+
+As we conclude this chapter, remember that you should:
+
+  * Use keyword lists for passing optional values to functions
+
+  * Use maps for general key-value data structures
+
+  * Use maps when working with data that has a predefined set of keys
+
+Now let's talk about modules and functions.
diff --git a/lib/elixir/pages/getting-started/lists-and-tuples.md b/lib/elixir/pages/getting-started/lists-and-tuples.md
new file mode 100644
index 00000000000..9a7e06a124b
--- /dev/null
+++ b/lib/elixir/pages/getting-started/lists-and-tuples.md
@@ -0,0 +1,197 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Lists and tuples
+
+In this chapter we will learn two of the most used collection data-types in Elixir: lists and tuples.
+
+## (Linked) Lists
+
+Elixir uses square brackets to specify a list of values. Values can be of any type:
+
+```elixir
+iex> [1, 2, true, 3]
+[1, 2, true, 3]
+iex> length([1, 2, 3])
+3
+```
+
+Two lists can be concatenated or subtracted using the [`++`](`++/2`) and [`--`](`--/2`) operators respectively:
+
+```elixir
+iex> [1, 2, 3] ++ [4, 5, 6]
+[1, 2, 3, 4, 5, 6]
+iex> [1, true, 2, false, 3, true] -- [true, false]
+[1, 2, 3, true]
+```
+
+List operators never modify the existing list. Concatenating to or removing elements from a list returns a new list. We say that Elixir data structures are *immutable*. One advantage of immutability is that it leads to clearer code. You can freely pass the data around with the guarantee no one will mutate it in memory - only transform it.
+
+Throughout the tutorial, we will talk a lot about the head and tail of a list. The head is the first element of a list and the tail is the remainder of the list. They can be retrieved with the functions [`hd`](`hd/1`) and [`tl`](`tl/1`). Let's assign a list to a variable and retrieve its head and tail:
+
+```elixir
+iex> list = [1, 2, 3]
+iex> hd(list)
+1
+iex> tl(list)
+[2, 3]
+```
+
+Getting the head or the tail of an empty list throws an error:
+
+```elixir
+iex> hd([])
+** (ArgumentError) argument error
+```
+
+Sometimes you will create a list and it will return a quoted value preceded by `~c`. For example:
+
+```elixir
+iex> [11, 12, 13]
+~c"\v\f\r"
+iex> [104, 101, 108, 108, 111]
+~c"hello"
+```
+
+When Elixir sees a list of printable ASCII numbers, Elixir will print that as a charlist (literally a list of characters). Charlists are quite common when interfacing with existing Erlang code. Whenever you see a value in IEx and you are not quite sure what it is, you can use [`i`](`IEx.Helpers.i/1`) to retrieve information about it:
+
+```elixir
+iex> i ~c"hello"
+Term
+  i ~c"hello"
+Data type
+  List
+Description
+  ...
+Raw representation
+  [104, 101, 108, 108, 111]
+Reference modules
+  List
+Implemented protocols
+  ...
+```
+
+We will talk more about charlists in the ["Binaries, strings, and charlists"](binaries-strings-and-charlists.md) chapter.
+
+> #### Single-quoted strings {: .info}
+>
+> In Elixir, you can also use `'hello'` to build charlists, but this notation has been soft-deprecated in Elixir v1.15 and will emit warnings in future versions. Prefer to write `~c"hello"` instead.
+
+## Tuples
+
+Elixir uses curly brackets to define tuples. Like lists, tuples can hold any value:
+
+```elixir
+iex> {:ok, "hello"}
+{:ok, "hello"}
+iex> tuple_size({:ok, "hello"})
+2
+```
+
+Tuples store elements contiguously in memory. This means accessing a tuple element by index or getting the tuple size is a fast operation. Indexes start from zero:
+
+```elixir
+iex> tuple = {:ok, "hello"}
+{:ok, "hello"}
+iex> elem(tuple, 1)
+"hello"
+iex> tuple_size(tuple)
+2
+```
+
+It is also possible to put an element at a particular index in a tuple with [`put_elem`](`put_elem/3`):
+
+```elixir
+iex> tuple = {:ok, "hello"}
+{:ok, "hello"}
+iex> put_elem(tuple, 1, "world")
+{:ok, "world"}
+iex> tuple
+{:ok, "hello"}
+```
+
+Notice that [`put_elem`](`put_elem/3`) returned a new tuple. The original tuple stored in the `tuple` variable was not modified. Like lists, tuples are also immutable. Every operation on a tuple returns a new tuple, it never changes the given one.
+
+## Lists or tuples?
+
+What is the difference between lists and tuples?
+
+Lists are stored in memory as linked lists, meaning that each element in a list holds its value and points to the following element until the end of the list is reached. This means accessing the length of a list is a linear operation: we need to traverse the whole list in order to figure out its size.
+
+Similarly, the performance of list concatenation depends on the length of the left-hand list:
+
+```elixir
+iex> list = [1, 2, 3]
+[1, 2, 3]
+
+# This is fast as we only need to traverse `[0]` to prepend to `list`
+iex> [0] ++ list
+[0, 1, 2, 3]
+
+# This is slow as we need to traverse `list` to append 4
+iex> list ++ [4]
+[1, 2, 3, 4]
+```
+
+Tuples, on the other hand, are stored contiguously in memory. This means getting the tuple size or accessing an element by index is fast. On the other hand, updating or adding elements to tuples is expensive because it requires creating a new tuple in memory:
+
+```elixir
+iex> tuple = {:a, :b, :c, :d}
+{:a, :b, :c, :d}
+iex> put_elem(tuple, 2, :e)
+{:a, :b, :e, :d}
+```
+
+Note, however, the elements themselves are not copied. When you update a tuple, all entries are shared between the old and the new tuple, except for the entry that has been replaced. This rule applies to most data structures in Elixir. This reduces the amount of memory allocation the language needs to perform and is only possible thanks to the immutable semantics of the language.
+
+Those performance characteristics dictate the usage of those data structures. In a nutshell, lists are used when the number of elements returned may vary. Tuples have a fixed size. Let's see two examples from the `String` module:
+
+```elixir
+iex> String.split("hello world")
+["hello", "world"]
+iex> String.split("hello beautiful world")
+["hello", "beautiful", "world"]
+```
+
+The [`String.split`](`String.split/1`) function breaks a string into a list of strings on every whitespace character. Since the amount of elements returned depends on the input, we use a list.
+
+On the other hand, [`String.split_at`](`String.split_at/2`) splits a string in two parts at a given position. Since it always returns two entries, regardless of the input size, it returns tuples:
+
+```elixir
+iex> String.split_at("hello world", 3)
+{"hel", "lo world"}
+iex> String.split_at("hello world", -4)
+{"hello w", "orld"}
+```
+
+It is also very common to use tuples and atoms to create "tagged tuples", which is a handy return value when an operation may succeed or fail. For example, [`File.read`](`File.read/1`) reads the contents of a file at a given path, which may or may not exist. It returns tagged tuples:
+
+```elixir
+iex> File.read("path/to/existing/file")
+{:ok, "... contents ..."}
+iex> File.read("path/to/unknown/file")
+{:error, :enoent}
+```
+
+If the path given to [`File.read`](`File.read/1`) exists, it returns a tuple with the atom `:ok` as the first element and the file contents as the second. Otherwise, it returns a tuple with `:error` and the error description. As we will soon learn, Elixir allows us to *pattern match* on tagged tuples and effortlessly handle both success and failure cases.
+
+Given Elixir consistently follows those rules, the choice between lists and tuples get clearer as you learn and use the language. Elixir often guides you to do the right thing. For example, there is an [`elem`](`elem/2`) function to access a tuple item:
+
+```elixir
+iex> tuple = {:ok, "hello"}
+{:ok, "hello"}
+iex> elem(tuple, 1)
+"hello"
+```
+
+However, given you often don't know the number of elements in a list, there is no built-in equivalent for accessing arbitrary entries in a lists, apart from its head.
+
+## Size or length?
+
+When counting the elements in a data structure, Elixir also abides by a simple rule: the function is named `size` if the operation is in constant time (the value is pre-calculated) or `length` if the operation is linear (calculating the length gets slower as the input grows). As a mnemonic, both "length" and "linear" start with "l".
+
+For example, we have used 4 counting functions so far: [`byte_size`](`byte_size/1`) (for the number of bytes in a string), [`tuple_size`](`tuple_size/1`) (for tuple size), [`length`](`length/1`) (for list length) and [`String.length`](`String.length/1`) (for the number of graphemes in a string). We use [`byte_size`](`byte_size/1`) to get the number of bytes in a string, which is a cheap operation. Retrieving the number of Unicode graphemes, on the other hand, uses [`String.length`](`String.length/1`), and may be expensive as it relies on a traversal of the entire string.
+
+Now that we are familiar with the basic data-types in the language, let's learn important constructs for writing code, before we discuss more complex data structures.
diff --git a/lib/elixir/pages/getting-started/module-attributes.md b/lib/elixir/pages/getting-started/module-attributes.md
new file mode 100644
index 00000000000..e1d824b8231
--- /dev/null
+++ b/lib/elixir/pages/getting-started/module-attributes.md
@@ -0,0 +1,205 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Module attributes
+
+Module attributes in Elixir serve three purposes:
+
+1. as module and function annotations
+2. as temporary module storage to be used during compilation
+3. as compile-time constants
+
+Let's check these examples.
+
+## As annotations
+
+Elixir brings the concept of module attributes from Erlang. For example:
+
+```elixir
+defmodule MyServer do
+  @moduledoc "My server code."
+end
+```
+
+In the example above, we are defining the module documentation by using the module attribute syntax. Elixir has a handful of reserved attributes. Here are a few of them, the most commonly used ones:
+
+  * `@moduledoc` — provides documentation for the current module.
+  * `@doc` — provides documentation for the function or macro that follows the attribute.
+  * `@spec` — provides a typespec for the function that follows the attribute.
+  * `@behaviour` — (notice the British spelling) used for specifying an OTP or user-defined behaviour.
+
+`@moduledoc` and `@doc` are by far the most used attributes, and we expect you to use them a lot. Elixir treats documentation as first-class and provides many functions to access documentation. We will cover them [in their own chapter](writing-documentation.md).
+
+Documentation is only accessible from compiled modules. So in order to give it a try, let's once again define the `Math` module, but this time within a file named `math.ex`:
+
+```elixir
+defmodule Math do
+  @moduledoc """
+  Provides math-related functions.
+
+  ## Examples
+
+      iex> Math.sum(1, 2)
+      3
+
+  """
+
+  @doc """
+  Calculates the sum of two numbers.
+  """
+  def sum(a, b), do: a + b
+end
+```
+
+Elixir promotes the use of Markdown with heredocs to write readable documentation. Heredocs are multi-line strings, they start and end with triple double-quotes, keeping the formatting of the inner text.
+
+Now let's compile it. Start `iex` and then invoke [the `c/2` helper](`IEx.Helpers.c/2`):
+
+```elixir
+iex> c("math.ex", ".")
+[Math]
+```
+
+And now we can access them:
+
+```elixir
+iex> h Math # Docs for module Math
+...
+iex> h Math.sum # Docs for the sum function
+...
+```
+
+When we compiled the module, you may have noticed Elixir created a `Elixir.Math.beam` file. That's the bytecode for the module and that's where the documentation is stored.
+
+In our day to day, Elixir developers use the `Mix` build tool to compile code and projects like [ExDoc](https://github.com/elixir-lang/ex_doc) to generate HTML and EPUB pages from the documentation.
+
+Take a look at the docs for `Module` for a complete list of supported attributes.
+
+## As temporary storage
+
+So far, we have seen how to define attributes, but how can we read them? Let's see an example:
+
+```elixir
+defmodule MyServer do
+  @service URI.parse("https://example.com")
+  IO.inspect(@service)
+end
+```
+
+> #### Newlines {: .warning}
+>
+> Do not add a newline between the attribute and its value, otherwise Elixir will assume you are reading the value, rather than setting it.
+
+Trying to access an attribute that was not defined will print a warning:
+
+```elixir
+defmodule MyServer do
+  @unknown
+end
+warning: undefined module attribute @unknown, please remove access to @unknown or explicitly set it before access
+```
+
+Attributes can also be read inside functions:
+
+```elixir
+defmodule MyApp.Status do
+  @service URI.parse("https://example.com")
+  def status(email) do
+    SomeHttpClient.get(@service)
+  end
+end
+```
+
+The module attribute is defined at compilation time and its *return value*, not the function call itself, is what will be substituted in for the attribute. So the above will effectively compile to this:
+
+```elixir
+defmodule MyApp.Status do
+  def status(email) do
+    SomeHttpClient.get(%URI{
+      authority: "example.com",
+      host: "example.com",
+      port: 443,
+      scheme: "https"
+    })
+  end
+end
+```
+
+This can be useful for pre-computing values and then injecting its results into the module. This is what we mean by temporary storage: after the module is compiled, the module attribute is discarded, except for the functions that have read the attribute. Note you cannot invoke functions defined in the same module as part of the attribute itself, as those functions have not yet been defined.
+
+Every time we read an attribute inside a function, Elixir takes a snapshot of its current value. Therefore if you read the same attribute multiple times inside multiple functions, you end-up increasing compilation times as Elixir now has to compile every snapshot. Generally speaking, you want to avoid reading the same attribute multiple times and instead move it to function. For example, instead of this:
+
+```elixir
+def some_function, do: do_something_with(@example)
+def another_function, do: do_something_else_with(@example)
+```
+
+Prefer this:
+
+```elixir
+def some_function, do: do_something_with(example())
+def another_function, do: do_something_else_with(example())
+defp example, do: @example
+```
+
+## As compile-time constants
+
+Module attributes may also be useful as compile-time constants. Generally speaking, functions themselves are sufficient for the role of constants in a codebase. For example, instead of defining:
+
+```elixir
+@hours_in_a_day 24
+```
+
+You should prefer:
+
+```elixir
+defp hours_in_a_day(), do: 24
+```
+
+You may even define a public function if it needs to be shared across modules. It is common in many projects to have a module called `MyApp.Constants` that defines all constants used throughout the codebase.
+
+You can even have composite data structures as constants, as long as they are made exclusively of other data types (no function calls, no operators, and no other expressions). For example, you may specify a system configuration constant as follows:
+
+```elixir
+defp system_config(), do: %{timezone: "Etc/UTC", locale: "pt-BR"}
+```
+
+Given data structures in Elixir are immutable, only a single instance of the data structure above is allocated and shared across all functions calls, as long as it doesn't have any executable expression.
+
+The use case for module attributes arise when you need to do some work at compile-time and then inject its results inside a function. A common scenario is module attributes inside patterns and guards (as an alternative to `defguard/1`), since they only support a limited set of expressions:
+
+```elixir
+# Inside pattern
+@default_timezone "Etc/UTC"
+def shift(@default_timezone), do: ...
+
+# Inside guards
+@time_periods [:am, :pm]
+def shift(time, period) when period in @time_periods, do: ...
+```
+
+Module attributes as constants and as temporary storage are most often used together: the module attribute is used to compute and store an expensive value, and then exposed as constant from that module.
+
+## Going further
+
+Libraries and frameworks can leverage module attributes to provide custom annotations. To see an example, look no further than Elixir's unit test framework called `ExUnit`. `ExUnit` uses module attributes for multiple different purposes:
+
+```elixir
+defmodule MyTest do
+  use ExUnit.Case, async: true
+
+  @tag :external
+  @tag os: :unix
+  test "contacts external service" do
+    # ...
+  end
+end
+```
+
+In the example above, `ExUnit` stores the value of `async: true` in a module attribute to change how the module is compiled. Tags also work as annotations and they can be supplied multiple times, thanks to Elixir's ability to [accumulate attributes](`Module.register_attribute/3`). Then you can use tags to setup and filter tests, such as avoiding executing Unix specific tests while running your test suite on Windows.
+
+To fully understand how `ExUnit` works, we'd need macros, so we will revisit this pattern in the Meta-programming guide and learn how to use module attributes as storage for custom annotations.
+
+In the next chapters, we'll explore structs and protocols before moving to exception handling and other constructs like sigils and comprehensions.
diff --git a/lib/elixir/pages/getting-started/modules-and-functions.md b/lib/elixir/pages/getting-started/modules-and-functions.md
new file mode 100644
index 00000000000..93785c8e418
--- /dev/null
+++ b/lib/elixir/pages/getting-started/modules-and-functions.md
@@ -0,0 +1,244 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Modules and functions
+
+In Elixir we group several functions into modules. We've already used many different modules in the previous chapters, such as the `String` module:
+
+```elixir
+iex> String.length("hello")
+5
+```
+
+In order to create our own modules in Elixir, we use the [`defmodule`](`defmodule/2`) macro. The first letter of a module name (an alias, as described further down) must be in uppercase. We use the [`def`](`def/2`) macro to define functions in that module. The first letter of every function must be in lowercase (or underscore):
+
+```elixir
+iex> defmodule Math do
+...>   def sum(a, b) do
+...>     a + b
+...>   end
+...> end
+
+iex> Math.sum(1, 2)
+3
+```
+
+In this chapter we will define our own modules, with different levels of complexity. As our examples get longer in size, it can be tricky to type them all in the shell, so we will resort more frequently to scripting.
+
+## Scripting
+
+Elixir has two file extensions `.ex` (Elixir) and `.exs` (Elixir scripts). Elixir treats both files exactly the same way, the only difference is in intention. `.ex` files are meant to be compiled while `.exs` files are used for scripting.
+
+Let's create a file named `math.exs`:
+
+```elixir
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+end
+
+IO.puts Math.sum(1, 2)
+```
+
+And execute it as:
+
+```console
+$ elixir math.exs
+```
+
+You can also load the file within `iex` by running:
+
+```console
+$ iex math.exs
+```
+
+And then have direct access to the `Math` module.
+
+## Function definition
+
+Inside a module, we can define functions with `def/2` and private functions with `defp/2`. A function defined with `def/2` can be invoked from other modules while a private function can only be invoked locally.
+
+```elixir
+defmodule Math do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+IO.puts Math.sum(1, 2)    #=> 3
+IO.puts Math.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+```
+
+Function declarations also support guards and multiple clauses. If a function has several clauses, Elixir will try each clause until it finds one that matches. Here is an implementation of a function that checks if the given number is zero or not:
+
+```elixir
+defmodule Math do
+  def zero?(0) do
+    true
+  end
+
+  def zero?(x) when is_integer(x) do
+    false
+  end
+end
+
+IO.puts Math.zero?(0)         #=> true
+IO.puts Math.zero?(1)         #=> false
+IO.puts Math.zero?([1, 2, 3]) #=> ** (FunctionClauseError)
+IO.puts Math.zero?(0.0)       #=> ** (FunctionClauseError)
+```
+
+The trailing question mark in `zero?` means that this function returns a boolean. To learn more about the naming conventions for modules, function names, variables and more in Elixir, see [Naming Conventions](../references/naming-conventions.md).
+
+Giving an argument that does not match any of the clauses raises an error.
+
+Similar to constructs like `if`, function definitions support both `do:` and `do`-block syntax, as [we learned in the previous chapter](keywords-and-maps.md#do-blocks-and-keywords). For example, we can edit `math.exs` to look like this:
+
+```elixir
+defmodule Math do
+  def zero?(0), do: true
+  def zero?(x) when is_integer(x), do: false
+end
+```
+
+And it will provide the same behavior. You may use `do:` for one-liners but always use `do`-blocks for functions spanning multiple lines. If you prefer to be consistent, you can use `do`-blocks throughout your codebase.
+
+## Default arguments
+
+Function definitions in Elixir also support default arguments:
+
+```elixir
+defmodule Concat do
+  def join(a, b, sep \\ " ") do
+    a <> sep <> b
+  end
+end
+
+IO.puts(Concat.join("Hello", "world"))      #=> Hello world
+IO.puts(Concat.join("Hello", "world", "_")) #=> Hello_world
+```
+
+Any expression is allowed to serve as a default value, but it won't be evaluated during the function definition. Every time the function is invoked and any of its default values have to be used, the expression for that default value will be evaluated:
+
+```elixir
+defmodule DefaultTest do
+  def dowork(x \\ "hello") do
+    x
+  end
+end
+```
+
+```elixir
+iex> DefaultTest.dowork()
+"hello"
+iex> DefaultTest.dowork(123)
+123
+iex> DefaultTest.dowork()
+"hello"
+```
+
+If a function with default values has multiple clauses, it is required to create a function head (a function definition without a body) for declaring defaults:
+
+```elixir
+defmodule Concat do
+  # A function head declaring defaults
+  def join(a, b, sep \\ " ")
+
+  def join(a, b, _sep) when b == "" do
+    a
+  end
+
+  def join(a, b, sep) do
+    a <> sep <> b
+  end
+end
+
+IO.puts(Concat.join("Hello", ""))           #=> Hello
+IO.puts(Concat.join("Hello", "world"))      #=> Hello world
+IO.puts(Concat.join("Hello", "world", "_")) #=> Hello_world
+```
+
+When a variable is not used by a function or a clause, we add a leading underscore (`_`) to its name to signal this intent. This rule is also covered in our [Naming Conventions](../references/naming-conventions.md#underscore-_foo) document.
+
+## Understanding Aliases
+
+An alias in Elixir is a capitalized identifier (like `String`, `Keyword`, etc) which is converted to an atom during compilation. For instance, the `String` alias translates by default to the atom `:"Elixir.String"`:
+
+```elixir
+iex> is_atom(String)
+true
+iex> to_string(String)
+"Elixir.String"
+iex> :"Elixir.String" == String
+true
+```
+
+By using the `alias/2` directive, we are changing the atom the alias expands to.
+
+Aliases expand to atoms because in the Erlang Virtual Machine (and consequently Elixir) modules are always represented by atoms. By namespacing
+those atoms elixir modules avoid conflicting with existing erlang modules.
+
+```elixir
+iex> List.flatten([1, [2], 3])
+[1, 2, 3]
+iex> :"Elixir.List".flatten([1, [2], 3])
+[1, 2, 3]
+```
+
+That's the mechanism we use to call Erlang modules:
+
+```elixir
+iex> :lists.flatten([1, [2], 3])
+[1, 2, 3]
+```
+
+## Module nesting
+
+Now that we have talked about aliases, we can talk about nesting and how it works in Elixir. Consider the following example:
+
+```elixir
+defmodule Foo do
+  defmodule Bar do
+  end
+end
+```
+
+The example above will define two modules: `Foo` and `Foo.Bar`. The second can be accessed as `Bar` inside `Foo` as long as they are in the same lexical scope.
+
+If, later, the `Bar` module is moved outside the `Foo` module definition, it must be referenced by its full name (`Foo.Bar`) or an alias must be set using the `alias` directive discussed above.
+
+**Note**: in Elixir, you don't have to define the `Foo` module before being able to define the `Foo.Bar` module, as they are effectively independent. The above could also be written as:
+
+```elixir
+defmodule Foo.Bar do
+end
+
+defmodule Foo do
+  alias Foo.Bar
+  # Can still access it as `Bar`
+end
+```
+
+Aliasing a nested module does not bring parent modules into scope. Consider the following example:
+
+```elixir
+defmodule Foo do
+  defmodule Bar do
+    defmodule Baz do
+    end
+  end
+end
+
+alias Foo.Bar.Baz
+# The module `Foo.Bar.Baz` is now available as `Baz`
+# However, the module `Foo.Bar` is *not* available as `Bar`
+```
+
+As we will see in later chapters, aliases also play a crucial role in macros, to guarantee they are hygienic.
diff --git a/lib/elixir/pages/getting-started/optional-syntax.md b/lib/elixir/pages/getting-started/optional-syntax.md
new file mode 100644
index 00000000000..c00d1d7da38
--- /dev/null
+++ b/lib/elixir/pages/getting-started/optional-syntax.md
@@ -0,0 +1,99 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Optional syntax sheet
+
+In the previous chapters, we learned that the Elixir syntax allows developers to omit delimiters in a few occasions to make code more readable. For example, we learned that parentheses are optional:
+
+```elixir
+iex> length([1, 2, 3]) == length [1, 2, 3]
+true
+```
+
+and that `do`-`end` blocks are equivalent to keyword lists:
+
+```elixir
+# do-end blocks
+iex> if true do
+...>   :this
+...> else
+...>   :that
+...> end
+:this
+
+# keyword lists
+iex> if true, do: :this, else: :that
+:this
+```
+
+Keyword lists use Elixir's regular notation for separating arguments, where we separate each key-value pair with commas, and each key is followed by `:`. In the `do`-blocks, we get rid of the colons, the commas, and separate each keyword by a newline. They are useful exactly because they remove the verbosity when writing blocks of code. Most of the time, we use the block syntax, but it is good to know they are equivalent.
+
+Those conveniences, which we call here "optional syntax", allow the language syntax core to be small, without sacrificing the readability and expressiveness of your code.  In this brief chapter, we will review the four rules provided by the language, using a short snippet as playground.
+
+## Walk-through
+
+Take the following code:
+
+```elixir
+if variable? do
+  Call.this()
+else
+  Call.that()
+end
+```
+
+Now let's remove the conveniences one by one:
+
+1. `do`-`end` blocks are equivalent to keywords:
+
+   ```elixir
+   if variable?, do: Call.this(), else: Call.that()
+   ```
+
+2. Keyword lists as last argument do not require square brackets, but let's add them:
+
+   ```elixir
+   if variable?, [do: Call.this(), else: Call.that()]
+   ```
+
+3. Keyword lists are the same as lists of two-element tuples:
+
+   ```elixir
+   if variable?, [{:do, Call.this()}, {:else, Call.that()}]
+   ```
+
+4. Finally, parentheses are optional on function calls, but let's add them:
+
+   ```elixir
+   if(variable?, [{:do, Call.this()}, {:else, Call.that()}])
+   ```
+
+That's it! Those four rules outline the optional syntax available in Elixir.
+
+To understand why these rules matter, we can briefly compare Elixir with many other programming languages. Most programming languages have several keywords for defining methods, functions, conditionals, loops, and so forth. Each of those keywords have their own syntax rules attached to them.
+
+However, in Elixir, none of these language features require special "keywords", instead they all build from this small set of rules. The other benefit is that developers can also extend the language in a way that is consistent with the language itself, since the constructs for designing and extending the language are the same. We further explore this topic in [the "Meta-programming" guide](../meta-programming/quote-and-unquote.md).
+
+At the end of the day, those rules are what enables us to write:
+
+```elixir
+defmodule Math do
+  def add(a, b) do
+    a + b
+  end
+end
+```
+
+instead of:
+
+```elixir
+defmodule(Math, [
+  {:do, def(add(a, b), [{:do, a + b}])}
+])
+```
+
+Whenever you have any questions, this quick walk-through has you covered.
+
+Finally, if you are concerned about when to apply these rules, it's worth noting that the Elixir formatter handles those concerns for you. Most Elixir developers use the `mix format` task to format their codebases according to a well-defined set of rules defined by the Elixir team and the community. For instance, `mix format` will always add parentheses to function calls unless explicitly configured not to do so. This helps to maintain consistency across all codebases within organizations and the wider community.
diff --git a/lib/elixir/pages/getting-started/pattern-matching.md b/lib/elixir/pages/getting-started/pattern-matching.md
new file mode 100644
index 00000000000..c819d73db85
--- /dev/null
+++ b/lib/elixir/pages/getting-started/pattern-matching.md
@@ -0,0 +1,203 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Pattern matching
+
+In this chapter, we will learn why the [`=`](`=/2`) operator in Elixir is called the match operator and how to use it to pattern match inside data structures. We will learn about the pin operator [`^`](`^/1`) used to access previously bound values.
+
+## The match operator
+
+We have used the [`=`](`=/2`) operator a couple times to assign variables in Elixir:
+
+```elixir
+iex> x = 1
+1
+iex> x
+1
+```
+
+In Elixir, the [`=`](`=/2`) operator is actually called *the match operator*. Let's see why:
+
+```elixir
+iex> x = 1
+1
+iex> 1 = x
+1
+iex> 2 = x
+** (MatchError) no match of right hand side value: 1
+```
+
+Notice that `1 = x` is a valid expression, and it matched because both the left and right side are equal to `1`. When the sides do not match, a `MatchError` is raised.
+
+A variable can only be assigned on the left side of [`=`](`=/2`):
+
+```elixir
+iex> 1 = unknown
+** (CompileError) iex:1: undefined variable "unknown"
+```
+
+## Pattern matching
+
+The match operator is not only used to match against simple values, but it is also useful for destructuring more complex data types. For example, we can pattern match on tuples:
+
+```elixir
+iex> {a, b, c} = {:hello, "world", 42}
+{:hello, "world", 42}
+iex> a
+:hello
+iex> b
+"world"
+```
+
+A pattern match error will occur if the sides can't be matched, for example if the tuples have different sizes:
+
+```elixir
+iex> {a, b, c} = {:hello, "world"}
+** (MatchError) no match of right hand side value: {:hello, "world"}
+```
+
+And also when comparing different types, for example if matching a tuple on the left side with a list on the right side:
+
+```elixir
+iex> {a, b, c} = [:hello, "world", 42]
+** (MatchError) no match of right hand side value: [:hello, "world", 42]
+```
+
+More interestingly, we can match on specific values. The example below asserts that the left side will only match the right side when the right side is a tuple that starts with the atom `:ok`:
+
+```elixir
+iex> {:ok, result} = {:ok, 13}
+{:ok, 13}
+iex> result
+13
+
+iex> {:ok, result} = {:error, :oops}
+** (MatchError) no match of right hand side value: {:error, :oops}
+```
+
+We can pattern match on lists:
+
+```elixir
+iex> [a, b, c] = [1, 2, 3]
+[1, 2, 3]
+iex> a
+1
+```
+
+A list also supports matching on its own head and tail:
+
+```elixir
+iex> [head | tail] = [1, 2, 3]
+[1, 2, 3]
+iex> head
+1
+iex> tail
+[2, 3]
+```
+
+Similar to the [`hd`](`hd/1`) and [`tl`](`tl/1`) functions, we can't match an empty list with a head and tail pattern:
+
+```elixir
+iex> [head | tail] = []
+** (MatchError) no match of right hand side value: []
+```
+
+The `[head | tail]` format is not only used on pattern matching but also for prepending items to a list:
+
+```elixir
+iex> list = [1, 2, 3]
+[1, 2, 3]
+iex> [0 | list]
+[0, 1, 2, 3]
+```
+
+In some cases, you don't care about a particular value in a pattern. It is a common practice to bind those values to the underscore, `_`. For example, if only the head of the list matters to us, we can assign the tail to underscore:
+
+```elixir
+iex> [head | _] = [1, 2, 3]
+[1, 2, 3]
+iex> head
+1
+```
+
+The variable `_` is special in that it can never be read from. Trying to read from it gives a compile error:
+
+```elixir
+iex> _
+** (CompileError) iex:1: invalid use of _. "_" represents a value to be ignored in a pattern and cannot be used in expressions
+```
+
+If a variable is mentioned more than once in a pattern, all references must bind to the same value:
+
+```elixir
+iex> {x, x} = {1, 1}
+{1, 1}
+iex> {x, x} = {1, 2}
+** (MatchError) no match of right hand side value: {1, 2}
+```
+
+Although pattern matching allows us to build powerful constructs, its usage is limited. For instance, you cannot make function calls on the left side of a match. The following example is invalid:
+
+```elixir
+iex> length([1, [2], 3]) = 3
+** (CompileError) iex:1: cannot invoke remote function :erlang.length/1 inside match
+```
+
+Pattern matching allows developers to easily destructure data types such as tuples and lists. As we will see in the following chapters, it is one of the foundations of recursion in Elixir and applies to other types as well, like maps and binaries.
+
+## The pin operator
+
+Variables in Elixir can be rebound:
+
+```elixir
+iex> x = 1
+1
+iex> x = 2
+2
+```
+
+However, there are times when we don't want variables to be rebound.
+
+Use the pin operator [`^`](`^/1`) when you want to pattern match against a variable's *existing value* rather than rebinding the variable.
+
+```elixir
+iex> x = 1
+1
+iex> ^x = 2
+** (MatchError) no match of right hand side value: 2
+```
+
+Because we have pinned `x` when it was bound to the value of `1`, it is equivalent to the following:
+
+```elixir
+iex> 1 = 2
+** (MatchError) no match of right hand side value: 2
+```
+
+Notice that we even see the exact same error message.
+
+We can use the pin operator inside other pattern matches, such as tuples or lists:
+
+```elixir
+iex> x = 1
+1
+iex> [^x, 2, 3] = [1, 2, 3]
+[1, 2, 3]
+iex> {y, ^x} = {2, 1}
+{2, 1}
+iex> y
+2
+iex> {y, ^x} = {2, 2}
+** (MatchError) no match of right hand side value: {2, 2}
+```
+
+Because `x` was bound to the value of `1` when it was pinned, this last example could have been written as:
+
+```elixir
+iex> {y, 1} = {2, 2}
+** (MatchError) no match of right hand side value: {2, 2}
+```
+
+This finishes our introduction to pattern matching. As we will see in the next chapter, pattern matching is very common in many language constructs and they can be further augmented with guards.
diff --git a/lib/elixir/pages/getting-started/processes.md b/lib/elixir/pages/getting-started/processes.md
new file mode 100644
index 00000000000..e0c7b326515
--- /dev/null
+++ b/lib/elixir/pages/getting-started/processes.md
@@ -0,0 +1,240 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Processes
+
+In Elixir, all code runs inside processes. Processes are isolated from each other, run concurrent to one another and communicate via message passing. Processes are not only the basis for concurrency in Elixir, but they also provide the means for building distributed and fault-tolerant programs.
+
+Elixir's processes should not be confused with operating system processes. Processes in Elixir are extremely lightweight in terms of memory and CPU (even compared to threads as used in many other programming languages). Because of this, it is not uncommon to have tens or even hundreds of thousands of processes running simultaneously.
+
+In this chapter, we will learn about the basic constructs for spawning new processes, as well as sending and receiving messages between processes.
+
+## Spawning processes
+
+The basic mechanism for spawning new processes is the auto-imported `spawn/1` function:
+
+```elixir
+iex> spawn(fn -> 1 + 2 end)
+#PID<0.43.0>
+```
+
+`spawn/1` takes a function which it will execute in another process.
+
+Notice `spawn/1` returns a PID (process identifier). At this point, the process you spawned is very likely dead. The spawned process will execute the given function and exit after the function is done:
+
+```elixir
+iex> pid = spawn(fn -> 1 + 2 end)
+#PID<0.44.0>
+iex> Process.alive?(pid)
+false
+```
+
+> Note: you will likely get different process identifiers than the ones we are showing in our snippets.
+
+We can retrieve the PID of the current process by calling `self/0`:
+
+```elixir
+iex> self()
+#PID<0.41.0>
+iex> Process.alive?(self())
+true
+```
+
+Processes get much more interesting when we are able to send and receive messages.
+
+## Sending and receiving messages
+
+We can send messages to a process with `send/2` and receive them with `receive/1`:
+
+```elixir
+iex> send(self(), {:hello, "world"})
+{:hello, "world"}
+iex> receive do
+...>   {:hello, msg} -> msg
+...>   {:world, _msg} -> "won't match"
+...> end
+"world"
+```
+
+When a message is sent to a process, the message is stored in the process mailbox. The `receive/1` block goes through the current process mailbox searching for a message that matches any of the given patterns. `receive/1` supports guards and many clauses, exactly as `case/2`.
+
+The process that sends the message does not block on `send/2`, it puts the message in the recipient's mailbox and continues. In particular, a process can send messages to itself.
+
+If there is no message in the mailbox matching any of the patterns, the current process will wait until a matching message arrives. A timeout can also be specified:
+
+```elixir
+iex> receive do
+...>   {:hello, msg}  -> msg
+...> after
+...>   1_000 -> "nothing after 1s"
+...> end
+"nothing after 1s"
+```
+
+A timeout of 0 can be given when you already expect the message to be in the mailbox.
+
+Let's put it all together and send messages between processes:
+
+```elixir
+iex> parent = self()
+#PID<0.41.0>
+iex> spawn(fn -> send(parent, {:hello, self()}) end)
+#PID<0.48.0>
+iex> receive do
+...>   {:hello, pid} -> "Got hello from #{inspect pid}"
+...> end
+"Got hello from #PID<0.48.0>"
+```
+
+The `inspect/1` function is used to convert a data structure's internal representation into a string, typically for printing. Notice that when the `receive` block gets executed the sender process we have spawned may already be dead, as its only instruction was to send a message.
+
+While in the shell, you may find the helper `flush/0` quite useful. It flushes and prints all the messages in the mailbox.
+
+```elixir
+iex> send(self(), :hello)
+:hello
+iex> flush()
+:hello
+:ok
+```
+
+## Links
+
+The majority of times we spawn processes in Elixir, we spawn them as linked processes. Before we show an example with `spawn_link/1`, let's see what happens when a process started with `spawn/1` fails:
+
+```elixir
+iex> spawn(fn -> raise "oops" end)
+#PID<0.58.0>
+
+[error] Process #PID<0.58.00> raised an exception
+** (RuntimeError) oops
+    (stdlib) erl_eval.erl:668: :erl_eval.do_apply/6
+```
+
+It merely logged an error but the parent process is still running. That's because processes are isolated. If we want the failure in one process to propagate to another one, we should link them. This can be done with `spawn_link/1`:
+
+```elixir
+iex> self()
+#PID<0.41.0>
+iex> spawn_link(fn -> raise "oops" end)
+
+** (EXIT from #PID<0.41.0>) evaluator process exited with reason: an exception was raised:
+    ** (RuntimeError) oops
+        (stdlib) erl_eval.erl:668: :erl_eval.do_apply/6
+
+[error] Process #PID<0.289.0> raised an exception
+** (RuntimeError) oops
+    (stdlib) erl_eval.erl:668: :erl_eval.do_apply/6
+```
+
+Because processes are linked, we now see a message saying the parent process, which is the shell process, has received an EXIT signal from another process causing the shell to terminate. IEx detects this situation and starts a new shell session.
+
+Linking can also be done manually by calling `Process.link/1`. We recommend that you take a look at the `Process` module for other functionality provided by processes.
+
+Processes and links play an important role when building fault-tolerant systems. Elixir processes are isolated and don't share anything by default. Therefore, a failure in a process will never crash or corrupt the state of another process. Links, however, allow processes to establish a relationship in case of failure. We often link our processes to supervisors which will detect when a process dies and start a new process in its place.
+
+While other languages would require us to catch/handle exceptions, in Elixir we are actually fine with letting processes fail because we expect supervisors to properly restart our systems. "Failing fast" (sometimes referred as "let it crash") is a common philosophy when writing Elixir software!
+
+`spawn/1` and `spawn_link/1` are the basic primitives for creating processes in Elixir. Although we have used them exclusively so far, most of the time we are going to use abstractions that build on top of them. Let's see the most common one, called tasks.
+
+## Tasks
+
+Tasks build on top of the spawn functions to provide better error reports and introspection:
+
+```elixir
+iex> Task.start(fn -> raise "oops" end)
+{:ok, #PID<0.55.0>}
+
+15:22:33.046 [error] Task #PID<0.55.0> started from #PID<0.53.0> terminating
+** (RuntimeError) oops
+    (stdlib) erl_eval.erl:668: :erl_eval.do_apply/6
+    (elixir) lib/task/supervised.ex:85: Task.Supervised.do_apply/2
+    (stdlib) proc_lib.erl:247: :proc_lib.init_p_do_apply/3
+Function: #Function<20.99386804/0 in :erl_eval.expr/5>
+    Args: []
+```
+
+Instead of `spawn/1` and `spawn_link/1`, we use `Task.start/1` and `Task.start_link/1` which return `{:ok, pid}` rather than just the PID. This is what enables tasks to be used in supervision trees. Furthermore, `Task` provides convenience functions, like `Task.async/1` and `Task.await/1`, and functionality to ease distribution.
+
+We will explore tasks and other abstractions around processes in the ["Mix and OTP guide"](../mix-and-otp/introduction-to-mix.md).
+
+## State
+
+We haven't talked about state so far. If you are building an application that requires state, for example, to keep your application configuration, or you need to parse a file and keep it in memory, where would you store it?
+
+Processes are the most common answer to this question. We can write processes that loop infinitely, maintain state, and send and receive messages. As an example, let's write a module that starts new processes that work as a key-value store in a file named `kv.exs`:
+
+```elixir
+defmodule KV do
+  def start_link do
+    Task.start_link(fn -> loop(%{}) end)
+  end
+
+  defp loop(map) do
+    receive do
+      {:get, key, caller} ->
+        send(caller, Map.get(map, key))
+        loop(map)
+      {:put, key, value} ->
+        loop(Map.put(map, key, value))
+    end
+  end
+end
+```
+
+Note that the `start_link` function starts a new process that runs the `loop/1` function, starting with an empty map. The `loop/1` (private) function then waits for messages and performs the appropriate action for each message. We made `loop/1` private by using `defp` instead of `def`. In the case of a `:get` message, it sends a message back to the caller and calls `loop/1` again, to wait for a new message. While the `:put` message actually invokes `loop/1` with a new version of the map, with the given `key` and `value` stored.
+
+Let's give it a try by running `iex kv.exs`:
+
+```elixir
+iex> {:ok, pid} = KV.start_link()
+{:ok, #PID<0.62.0>}
+iex> send(pid, {:get, :hello, self()})
+{:get, :hello, #PID<0.41.0>}
+iex> flush()
+nil
+:ok
+```
+
+At first, the process map has no keys, so sending a `:get` message and then flushing the current process inbox returns `nil`. Let's send a `:put` message and try it again:
+
+```elixir
+iex> send(pid, {:put, :hello, :world})
+{:put, :hello, :world}
+iex> send(pid, {:get, :hello, self()})
+{:get, :hello, #PID<0.41.0>}
+iex> flush()
+:world
+:ok
+```
+
+Notice how the process is keeping a state and we can get and update this state by sending the process messages. In fact, any process that knows the `pid` above will be able to send it messages and manipulate the state.
+
+It is also possible to register the `pid`, giving it a name, and allowing everyone that knows the name to send it messages:
+
+```elixir
+iex> Process.register(pid, :kv)
+true
+iex> send(:kv, {:get, :hello, self()})
+{:get, :hello, #PID<0.41.0>}
+iex> flush()
+:world
+:ok
+```
+
+Using processes to maintain state and name registration are very common patterns in Elixir applications. However, most of the time, we won't implement those patterns manually as above, but by using one of the many abstractions that ship with Elixir. For example, Elixir provides `Agent`s, which are simple abstractions around state. Our code above could be directly written as:
+
+```elixir
+iex> {:ok, pid} = Agent.start_link(fn -> %{} end)
+{:ok, #PID<0.72.0>}
+iex> Agent.update(pid, fn map -> Map.put(map, :hello, :world) end)
+:ok
+iex> Agent.get(pid, fn map -> Map.get(map, :hello) end)
+:world
+```
+
+A `:name` option could also be given to `Agent.start_link/2` and it would be automatically registered. Besides agents, Elixir provides an API for building generic servers (called `GenServer`), registries, and more, all powered by processes underneath. Those, along with supervision trees, will be explored with more detail in the ["Mix and OTP guide"](../mix-and-otp/introduction-to-mix.md), which will build a complete Elixir application from start to finish.
+
+For now, let's move on and explore the world of I/O in Elixir.
diff --git a/lib/elixir/pages/getting-started/protocols.md b/lib/elixir/pages/getting-started/protocols.md
new file mode 100644
index 00000000000..b644004d524
--- /dev/null
+++ b/lib/elixir/pages/getting-started/protocols.md
@@ -0,0 +1,261 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Protocols
+
+Protocols are a mechanism to achieve polymorphism in Elixir where you want the behavior to vary depending on the data type. We are already familiar with one way of solving this type of problem: via pattern matching and guard clauses. Consider a simple utility module that would tell us the type of input variable:
+
+```elixir
+defmodule Utility do
+  def type(value) when is_binary(value), do: "string"
+  def type(value) when is_integer(value), do: "integer"
+  # ... other implementations ...
+end
+```
+
+If the use of this module were confined to your own project, you would be able to keep defining new `type/1` functions for each new data type. However, this code could be problematic if it was shared as a dependency by multiple apps because there would be no easy way to extend its functionality.
+
+This is where protocols can help us: protocols allow us to extend the original behavior for as many data types as we need. That's because **dispatching on a protocol is available to any data type that has implemented the protocol** and a protocol can be implemented by anyone, at any time.
+
+Here's how we could write the same `Utility.type/1` functionality as a protocol:
+
+```elixir
+defprotocol Utility do
+  @spec type(t) :: String.t()
+  def type(value)
+end
+
+defimpl Utility, for: BitString do
+  def type(_value), do: "string"
+end
+
+defimpl Utility, for: Integer do
+  def type(_value), do: "integer"
+end
+```
+
+We define the protocol using `defprotocol/2` - its functions and specs may look similar to interfaces or abstract base classes in other languages. We can add as many implementations as we like using `defimpl/2`. The output is exactly the same as if we had a single module with multiple functions:
+
+```elixir
+iex> Utility.type("foo")
+"string"
+iex> Utility.type(123)
+"integer"
+```
+
+With protocols, however, we are no longer stuck having to continuously modify the same module to support more and more data types. For example, we could spread the `defimpl` calls above over multiple files and Elixir will dispatch the execution to the appropriate implementation based on the data type. Functions defined in a protocol may have more than one input, but the **dispatching will always be based on the data type of the first input**.
+
+One of the most common protocols you may encounter is the `String.Chars` protocol: implementing its `to_string/1` function for your custom structs will tell the Elixir kernel how to represent them as strings. We will explore all the built-in protocols later. For now, let's implement our own.
+
+## Example
+
+Now that you have seen an example of the type of problem protocols help solve and how they solve them, let's look at a more in-depth example.
+
+In Elixir, we have two idioms for checking how many items there are in a data structure: `length` and `size`. `length` means the information must be computed. For example, `length(list)` needs to traverse the whole list to calculate its length. On the other hand, `tuple_size(tuple)` and `byte_size(binary)` do not depend on the tuple and binary size as the size information is pre-computed in the data structure.
+
+Even if we have type-specific functions for getting the size built into Elixir (such as `tuple_size/1`), we could implement a generic `Size` protocol that all data structures for which size is pre-computed would implement.
+
+The protocol definition would look like this:
+
+```elixir
+defprotocol Size do
+  @doc "Calculates the size (and not the length!) of a data structure"
+  def size(data)
+end
+```
+
+The `Size` protocol expects a function called `size` that receives one argument (the data structure we want to know the size of) to be implemented. We can now implement this protocol for the data structures that would have a compliant implementation:
+
+```elixir
+defimpl Size, for: BitString do
+  def size(string), do: byte_size(string)
+end
+
+defimpl Size, for: Map do
+  def size(map), do: map_size(map)
+end
+
+defimpl Size, for: Tuple do
+  def size(tuple), do: tuple_size(tuple)
+end
+```
+
+We didn't implement the `Size` protocol for lists as there is no "size" information pre-computed for lists, and the length of a list has to be computed (with `length/1`).
+
+Now with the protocol defined and implementations in hand, we can start using it:
+
+```elixir
+iex> Size.size("foo")
+3
+iex> Size.size({:ok, "hello"})
+2
+iex> Size.size(%{label: "some label"})
+1
+```
+
+Passing a data type that doesn't implement the protocol raises an error:
+
+```elixir
+iex> Size.size([1, 2, 3])
+** (Protocol.UndefinedError) protocol Size not implemented for [1, 2, 3] of type List
+```
+
+It's possible to implement protocols for all Elixir data types:
+
+  * `Atom`
+  * `BitString`
+  * `Float`
+  * `Function`
+  * `Integer`
+  * `List`
+  * `Map`
+  * `PID`
+  * `Port`
+  * `Reference`
+  * `Tuple`
+
+## Protocols and structs
+
+The power of Elixir's extensibility comes when protocols and structs are used together.
+
+In the [previous chapter](structs.md), we have learned that although structs are maps, they do not share protocol implementations with maps. For example, `MapSet`s (sets based on maps) are implemented as structs. Let's try to use the `Size` protocol with a `MapSet`:
+
+```elixir
+iex> Size.size(%{})
+0
+iex> set = %MapSet{} = MapSet.new
+MapSet.new([])
+iex> Size.size(set)
+** (Protocol.UndefinedError) protocol Size not implemented for MapSet.new([]) of type MapSet (a struct)
+```
+
+Instead of sharing protocol implementation with maps, structs require their own protocol implementation. Since a `MapSet` has its size precomputed and accessible through `MapSet.size/1`, we can define a `Size` implementation for it:
+
+```elixir
+defimpl Size, for: MapSet do
+  def size(set), do: MapSet.size(set)
+end
+```
+
+If desired, you could come up with your own semantics for the size of your struct. Not only that, you could use structs to build more robust data types, like queues, and implement all relevant protocols, such as `Enumerable` and possibly `Size`, for this data type.
+
+```elixir
+defmodule User do
+  defstruct [:name, :age]
+end
+
+defimpl Size, for: User do
+  def size(_user), do: 2
+end
+```
+
+## Implementing `Any`
+
+Manually implementing protocols for all types can quickly become repetitive and tedious. In such cases, Elixir provides two options: we can explicitly derive the protocol implementation for our types or automatically implement the protocol for all types. In both cases, we need to implement the protocol for `Any`.
+
+### Deriving
+
+Elixir allows us to derive a protocol implementation based on the `Any` implementation. Let's first implement `Any` as follows:
+
+```elixir
+defimpl Size, for: Any do
+  def size(_), do: 0
+end
+```
+
+The implementation above is arguably not a reasonable one. For example, it makes no sense to say that the size of a `PID` or an `Integer` is `0`.
+
+However, should we be fine with the implementation for `Any`, in order to use such implementation we would need to tell our struct to explicitly derive the `Size` protocol:
+
+```elixir
+defmodule OtherUser do
+  @derive [Size]
+  defstruct [:name, :age]
+end
+```
+
+When deriving, Elixir will implement the `Size` protocol for `OtherUser` based on the implementation provided for `Any`.
+
+### Fallback to `Any`
+
+Another alternative to `@derive` is to explicitly tell the protocol to fallback to `Any` when an implementation cannot be found. This can be achieved by setting `@fallback_to_any` to `true` in the protocol definition:
+
+```elixir
+defprotocol Size do
+  @fallback_to_any true
+  def size(data)
+end
+```
+
+As we said in the previous section, the implementation of `Size` for `Any` is not one that can apply to any data type. That's one of the reasons why `@fallback_to_any` is an opt-in behavior. For the majority of protocols, raising an error when a protocol is not implemented is the proper behavior. That said, assuming we have implemented `Any` as in the previous section:
+
+```elixir
+defimpl Size, for: Any do
+  def size(_), do: 0
+end
+```
+
+Now all data types (including structs) that have not implemented the `Size` protocol will be considered to have a size of `0`.
+
+Which technique is best between deriving and falling back to `Any` depends on the use case but, given Elixir developers prefer explicit over implicit, you may see many libraries pushing towards the `@derive` approach.
+
+## Built-in protocols
+
+Elixir ships with some built-in protocols. In previous chapters, we have discussed the `Enum` module which provides many functions that work with any data structure that implements the `Enumerable` protocol:
+
+```elixir
+iex> Enum.map([1, 2, 3], fn x -> x * 2 end)
+[2, 4, 6]
+iex> Enum.reduce(1..3, 0, fn x, acc -> x + acc end)
+6
+```
+
+Another useful example is the `String.Chars` protocol, which specifies how to convert a data structure to its human representation as a string. It's exposed via the `to_string` function:
+
+```elixir
+iex> to_string(:hello)
+"hello"
+```
+
+Notice that string interpolation in Elixir calls the `to_string` function:
+
+```elixir
+iex> "age: #{25}"
+"age: 25"
+```
+
+The snippet above only works because numbers implement the `String.Chars` protocol. Passing a tuple, for example, will lead to an error:
+
+```elixir
+iex> tuple = {1, 2, 3}
+{1, 2, 3}
+iex> "tuple: #{tuple}"
+** (Protocol.UndefinedError) protocol String.Chars not implemented for {1, 2, 3} of type Tuple
+```
+
+When there is a need to "print" a more complex data structure, one can use the `inspect` function, based on the `Inspect` protocol:
+
+```elixir
+iex> "tuple: #{inspect(tuple)}"
+"tuple: {1, 2, 3}"
+```
+
+The `Inspect` protocol is the protocol used to transform any data structure into a readable textual representation. This is what tools like IEx use to print results:
+
+```elixir
+iex> {1, 2, 3}
+{1, 2, 3}
+iex> %User{}
+%User{name: "john", age: 27}
+```
+
+Keep in mind that, by convention, whenever the inspected value starts with `#`, it is representing a data structure in non-valid Elixir syntax. This means the inspect protocol is not reversible as information may be lost along the way:
+
+```elixir
+iex> inspect &(&1+2)
+"#Function<6.71889879/1 in :erl_eval.expr/5>"
+```
+
+There are other protocols in Elixir, but this covers the most common ones. You can learn more about protocols and implementations in the `Protocol` module.
diff --git a/lib/elixir/pages/getting-started/recursion.md b/lib/elixir/pages/getting-started/recursion.md
new file mode 100644
index 00000000000..d1f0b0f6276
--- /dev/null
+++ b/lib/elixir/pages/getting-started/recursion.md
@@ -0,0 +1,139 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Recursion
+
+Elixir does not provide loop constructs. Instead we leverage recursion and high-level functions for working with collections. This chapter will explore the former.
+
+## Loops through recursion
+
+Due to immutability, loops in Elixir (as in any functional programming language) are written differently from imperative languages. For example, in an imperative language like C, one would write:
+
+```c
+for(i = 0; i < sizeof(array); i++) {
+  array[i] = array[i] * 2;
+}
+```
+
+In the example above, we are mutating both the array and the variable `i`. However, data structures in Elixir are immutable. For this reason, functional languages rely on recursion: a function is called recursively until a condition is reached that stops the recursive action from continuing. No data is mutated in this process. Consider the example below that prints a string an arbitrary number of times:
+
+```elixir
+defmodule Recursion do
+  def print_multiple_times(msg, n) when n > 0 do
+    IO.puts(msg)
+    print_multiple_times(msg, n - 1)
+  end
+
+  def print_multiple_times(_msg, 0) do
+    :ok
+  end
+end
+
+Recursion.print_multiple_times("Hello!", 3)
+# Hello!
+# Hello!
+# Hello!
+:ok
+```
+
+Similar to `case`, a function may have many clauses. A particular clause is executed when the arguments passed to the function match the clause's argument patterns and its guards evaluate to `true`.
+
+When `print_multiple_times/2` is initially called in the example above, the argument `n` is equal to `3`.
+
+The first clause has a guard which says "use this definition if and only if `n` is more than `0`". Since this is the case, it prints the `msg` and then calls itself passing `n - 1` (`2`) as the second argument.
+
+Now we execute the same function again, starting from the first clause. Given the second argument, `n`, is still more than 0, we print the message and call ourselves once more, now with the second argument set to `1`. Then we print the message one last time and call `print_multiple_times("Hello!", 0)`, starting from the top once again.
+
+When the second argument is zero, the guard `n > 0` evaluates to false, and the first function clause won't execute. Elixir then proceeds to try the next function clause, which explicitly matches on the case where `n` is `0`. This clause, also known as the termination clause, ignores the message argument by assigning it to the `_msg` variable and returns the atom `:ok`.
+
+Finally, if you pass an argument that does not match any clause, Elixir raises a `FunctionClauseError`:
+
+```elixir
+iex> Recursion.print_multiple_times("Hello!", -1)
+** (FunctionClauseError) no function clause matching in Recursion.print_multiple_times/2
+
+    The following arguments were given to Recursion.print_multiple_times/2:
+
+        # 1
+        "Hello!"
+
+        # 2
+        -1
+
+    iex:1: Recursion.print_multiple_times/2
+```
+
+## Reduce and map algorithms
+
+Let's now see how we can use the power of recursion to sum a list of numbers:
+
+```elixir
+defmodule Math do
+  def sum_list([head | tail], accumulator) do
+    sum_list(tail, head + accumulator)
+  end
+
+  def sum_list([], accumulator) do
+    accumulator
+  end
+end
+
+IO.puts Math.sum_list([1, 2, 3], 0) #=> 6
+```
+
+We invoke `sum_list` with the list `[1, 2, 3]` and the initial value `0` as arguments. We will try each clause until we find one that matches according to the pattern matching rules. In this case, the list `[1, 2, 3]` matches against `[head | tail]` which binds `head` to `1` and `tail` to `[2, 3]`; `accumulator` is set to `0`.
+
+Then, we add the head of the list to the accumulator `head + accumulator` and call `sum_list` again, recursively, passing the tail of the list as its first argument. The tail will once again match `[head | tail]` until the list is empty, as seen below:
+
+```elixir
+sum_list([1, 2, 3], 0)
+sum_list([2, 3], 1)
+sum_list([3], 3)
+sum_list([], 6)
+```
+
+When the list is empty, it will match the final clause which returns the final result of `6`.
+
+The process of taking a list and _reducing_ it down to one value is known as a _reduce algorithm_ and is central to functional programming.
+
+What if we instead want to double all of the values in our list?
+
+```elixir
+defmodule Math do
+  def double_each([head | tail]) do
+    [head * 2 | double_each(tail)]
+  end
+
+  def double_each([]) do
+    []
+  end
+end
+
+Math.double_each([1, 2, 3]) #=> [2, 4, 6]
+```
+
+Here we have used recursion to traverse a list, doubling each element and returning a new list. The process of taking a list and _mapping_ over it is known as a _map algorithm_.
+
+Recursion and [tail call](https://en.wikipedia.org/wiki/Tail_call) optimization are an important part of Elixir and are commonly used to create loops. However, when programming in Elixir you will rarely use recursion as above to manipulate lists.
+
+The `Enum` module, which we're going to see in the next chapter already provides many conveniences for working with lists. For instance, the examples above could be written as:
+
+```elixir
+iex> Enum.reduce([1, 2, 3], 0, fn x, acc -> x + acc end)
+6
+iex> Enum.map([1, 2, 3], fn x -> x * 2 end)
+[2, 4, 6]
+```
+
+Or, using the [capture syntax](`Kernel.SpecialForms.&/1`):
+
+```elixir
+iex> Enum.reduce([1, 2, 3], 0, &+/2)
+6
+iex> Enum.map([1, 2, 3], &(&1 * 2))
+[2, 4, 6]
+```
+
+Let's take a deeper look at `Enumerable` and, while we're at it, its lazy counterpart, `Stream`.
diff --git a/lib/elixir/pages/getting-started/sigils.md b/lib/elixir/pages/getting-started/sigils.md
new file mode 100644
index 00000000000..6ac0d2004a9
--- /dev/null
+++ b/lib/elixir/pages/getting-started/sigils.md
@@ -0,0 +1,245 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Sigils
+
+Elixir provides double-quoted strings as well as a concept called charlists, which are defined using the `~c"hello world"` sigil syntax. In this chapter, we will learn more about sigils and how to define our own.
+
+One of Elixir's goals is extensibility: developers should be able to extend the language to fit any particular domain. Sigils provide the foundation for extending the language with custom textual representations. Sigils start with the tilde (`~`) character which is followed by either a single lower-case letter or one or more upper-case letters, and then a delimiter. Optional modifiers are added after the final delimiter.
+
+## Regular expressions
+
+The most common sigil in Elixir is `~r`, which is used to create [regular expressions](https://en.wikipedia.org/wiki/Regular_Expressions):
+
+```elixir
+# A regular expression that matches strings which contain "foo" or "bar":
+iex> regex = ~r/foo|bar/
+~r/foo|bar/
+iex> "foo" =~ regex
+true
+iex> "bat" =~ regex
+false
+```
+
+Elixir provides Perl-compatible regular expressions (regexes), as implemented by the [PCRE](http://www.pcre.org/) library. Regexes also support modifiers. For example, the `i` modifier makes a regular expression case insensitive:
+
+```elixir
+iex> "HELLO" =~ ~r/hello/
+false
+iex> "HELLO" =~ ~r/hello/i
+true
+```
+
+Check out the `Regex` module for more information on other modifiers and the supported operations with regular expressions.
+
+So far, all examples have used `/` to delimit a regular expression. However, sigils support 8 different delimiters:
+
+```elixir
+~r/hello/
+~r|hello|
+~r"hello"
+~r'hello'
+~r(hello)
+~r[hello]
+~r{hello}
+~r<hello>
+```
+
+The reason behind supporting different delimiters is to provide a way to write literals without escaped delimiters. For example, a regular expression with forward slashes like `~r(^https?://)` reads arguably better than `~r/^https?:\/\//`. Similarly, if the regular expression has forward slashes and capturing groups (that use `()`), you may then choose double quotes instead of parentheses.
+
+## Strings, charlists, and word lists sigils
+
+Elixir ships with three sigils for building textual data structures. These allow you to choose an appropriate delimiter for your literal text such that you do not have to worry about escaping.
+
+### Strings
+
+The `~s` sigil is used to generate strings, like double quotes are. The `~s` sigil is useful when a string contains double quotes:
+
+```elixir
+iex> ~s(this is a string with "double" quotes, not 'single' ones)
+"this is a string with \"double\" quotes, not 'single' ones"
+```
+
+### Charlists
+
+The `~c` sigil is the regular way to represent charlists.
+
+```elixir
+iex> [?c, ?a, ?t]
+~c"cat"
+iex> ~c(this is a char list containing "double quotes")
+~c"this is a char list containing \"double quotes\""
+```
+
+### Word lists
+
+The `~w` sigil is used to generate lists of words (*words* are just regular strings). Inside the `~w` sigil, words are separated by whitespace.
+
+```elixir
+iex> ~w(foo bar bat)
+["foo", "bar", "bat"]
+```
+
+The `~w` sigil also accepts the `c`, `s` and `a` modifiers (for charlists, strings, and atoms, respectively), which specify the data type of the elements of the resulting list:
+
+```elixir
+iex> ~w(foo bar bat)a
+[:foo, :bar, :bat]
+```
+
+## Interpolation and escaping in textual sigils
+
+Elixir supports some sigil variants to deal with escaping characters and interpolation. In particular, uppercase-letter textual sigils do not perform interpolation nor escaping. For example, although both `~s` and `~S` will return strings, the former allows escape codes and interpolation while the latter does not:
+
+```elixir
+iex> ~s(String with escape codes \x26 #{"inter" <> "polation"})
+"String with escape codes & interpolation"
+iex> ~S(String without escape codes \x26 without #{interpolation})
+"String without escape codes \\x26 without \#{interpolation}"
+```
+
+The following escape codes can be used in textual sigils:
+
+  * `\\` – single backslash
+  * `\a` – bell/alert
+  * `\b` – backspace
+  * `\d` - delete
+  * `\e` - escape
+  * `\f` - form feed
+  * `\n` – newline
+  * `\r` – carriage return
+  * `\s` – space
+  * `\t` – tab
+  * `\v` – vertical tab
+  * `\0` - null byte
+  * `\xDD` - represents a single byte in hexadecimal (such as `\x13`)
+  * `\uDDDD` and `\u{D...}` - represents a Unicode codepoint in hexadecimal (such as `\u{1F600}`)
+
+In addition to those, a double quote inside a double-quoted string needs to be escaped as `\"`, and, analogously, a single quote inside a single-quoted char list needs to be escaped as `\'`. Nevertheless, it is better style to change delimiters as seen above than to escape them.
+
+Sigils also support heredocs, that is, three double-quotes or single-quotes as separators:
+
+```elixir
+iex> ~s"""
+...> this is
+...> a heredoc string
+...> """
+```
+
+The most common use case for heredoc sigils is when writing documentation. For example, writing escape characters in the documentation would soon become error prone because of the need to double-escape some characters:
+
+```elixir
+@doc """
+Converts double-quotes to single-quotes.
+
+## Examples
+
+    iex> convert("\\\"foo\\\"")
+    "'foo'"
+
+"""
+def convert(...)
+```
+
+By using `~S`, this problem can be avoided altogether:
+
+```elixir
+@doc ~S"""
+Converts double-quotes to single-quotes.
+
+## Examples
+
+    iex> convert("\"foo\"")
+    "'foo'"
+
+"""
+def convert(...)
+```
+
+## Calendar sigils
+
+Elixir offers several sigils to deal with various flavors of times and dates.
+
+### Date
+
+A [%Date{}](`Date`) struct contains the fields `year`, `month`, `day`, and `calendar`. You can create one using the `~D` sigil:
+
+```elixir
+iex> d = ~D[2019-10-31]
+~D[2019-10-31]
+iex> d.day
+31
+```
+
+### Time
+
+The [%Time{}](`Time`) struct contains the fields `hour`, `minute`, `second`, `microsecond`, and `calendar`. You can create one using the `~T` sigil:
+
+```elixir
+iex> t = ~T[23:00:07.0]
+~T[23:00:07.0]
+iex> t.second
+7
+```
+
+### NaiveDateTime
+
+The [%NaiveDateTime{}](`NaiveDateTime`) struct contains fields from both `Date` and `Time`. You can create one using the `~N` sigil:
+
+```elixir
+iex> ndt = ~N[2019-10-31 23:00:07]
+~N[2019-10-31 23:00:07]
+```
+
+Why is it called naive? Because it does not contain timezone information. Therefore, the given datetime may not exist at all or it may exist twice in certain timezones - for example, when we move the clock back and forward for daylight saving time.
+
+### UTC DateTime
+
+A [%DateTime{}](`DateTime`) struct contains the same fields as a `NaiveDateTime` with the addition of fields to track timezones. The `~U` sigil allows developers to create a DateTime in the UTC timezone:
+
+```elixir
+iex> dt = ~U[2019-10-31 19:59:03Z]
+~U[2019-10-31 19:59:03Z]
+iex> %DateTime{minute: minute, time_zone: time_zone} = dt
+~U[2019-10-31 19:59:03Z]
+iex> minute
+59
+iex> time_zone
+"Etc/UTC"
+```
+
+## Custom sigils
+
+As hinted at the beginning of this chapter, sigils in Elixir are extensible. In fact, using the sigil `~r/foo/i` is equivalent to calling `sigil_r` with a binary and a char list as the argument:
+
+```elixir
+iex> sigil_r(<<"foo">>, [?i])
+~r"foo"i
+```
+
+We can access the documentation for the `~r` sigil via `sigil_r`:
+
+```elixir
+iex> h sigil_r
+...
+```
+
+We can also provide our own sigils by implementing functions that follow the `sigil_{character}` pattern. For example, let's implement the `~i` sigil that returns an integer (with the optional `n` modifier to make it negative):
+
+```elixir
+iex> defmodule MySigils do
+...>   def sigil_i(string, []), do: String.to_integer(string)
+...>   def sigil_i(string, [?n]), do: -String.to_integer(string)
+...> end
+iex> import MySigils
+iex> ~i(13)
+13
+iex> ~i(42)n
+-42
+```
+
+Custom sigils may be either a single lowercase character, or an uppercase character followed by more uppercase characters and digits.
+
+Sigils can also be used to do compile-time work with the help of macros. For example, regular expressions in Elixir are compiled into an efficient representation during compilation of the source code, therefore skipping this step at runtime. If you're interested in the subject, you can learn more about macros and check out how sigils are implemented in the `Kernel` module (where the `sigil_*` functions are defined).
diff --git a/lib/elixir/pages/getting-started/structs.md b/lib/elixir/pages/getting-started/structs.md
new file mode 100644
index 00000000000..ac71fa8503a
--- /dev/null
+++ b/lib/elixir/pages/getting-started/structs.md
@@ -0,0 +1,169 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Structs
+
+We learned about maps [in earlier chapters](keywords-and-maps.md):
+
+```elixir
+iex> map = %{a: 1, b: 2}
+%{a: 1, b: 2}
+iex> map[:a]
+1
+iex> %{map | a: 3}
+%{a: 3, b: 2}
+```
+
+Structs are extensions built on top of maps that provide compile-time checks and default values.
+
+## Defining structs
+
+To define a struct, the `defstruct/1` construct is used:
+
+```elixir
+iex> defmodule User do
+...>   defstruct name: "John", age: 27
+...> end
+```
+
+The keyword list used with `defstruct` defines what fields the struct will have along with their default values. Structs take the name of the module they're defined in. In the example above, we defined a struct named `User`.
+
+We can now create `User` structs by using a syntax similar to the one used to create maps:
+
+```elixir
+iex> %User{}
+%User{age: 27, name: "John"}
+iex> %User{name: "Jane"}
+%User{age: 27, name: "Jane"}
+```
+
+Structs provide *compile-time* guarantees that only the fields defined through `defstruct` will be allowed to exist in a struct:
+
+```elixir
+iex> %User{oops: :field}
+** (KeyError) key :oops not found expanding struct: User.__struct__/1
+```
+
+## Accessing and updating structs
+
+Structs share the same syntax for accessing and updating fields as maps of fixed keys:
+
+```elixir
+iex> john = %User{}
+%User{age: 27, name: "John"}
+iex> john.name
+"John"
+iex> jane = %{john | name: "Jane"}
+%User{age: 27, name: "Jane"}
+iex> %{jane | oops: :field}
+** (KeyError) key :oops not found in: %User{age: 27, name: "Jane"}
+```
+
+When using the update syntax (`|`), Elixir is aware that no new keys will be added to the struct, allowing the maps underneath to share their structure in memory. In the example above, both `john` and `jane` share the same key structure in memory.
+
+Structs can also be used in pattern matching, both for matching on the value of specific keys as well as for ensuring that the matching value is a struct of the same type as the matched value.
+
+```elixir
+iex> %User{name: name} = john
+%User{age: 27, name: "John"}
+iex> name
+"John"
+iex> %User{} = %{}
+** (MatchError) no match of right hand side value: %{}
+```
+
+For more details on creating, updating, and pattern matching structs, see the documentation for `%/2`.
+
+## Dynamic struct updates
+
+When you need to update structs with data from keyword lists or maps, use `Kernel.struct!/2`:
+
+```elixir
+iex> john = %User{name: "John", age: 27}
+%User{age: 27, name: "John"}
+iex> updates = [name: "Jane", age: 30]
+[name: "Jane", age: 30]
+iex> struct!(john, updates)
+%User{age: 30, name: "Jane"}
+```
+
+`struct!/2` will raise an error if you try to set invalid fields:
+
+```elixir
+iex> struct!(john, invalid: "field")
+** (KeyError) key :invalid not found in: %User{age: 27, name: "John"}
+```
+
+Use the map update syntax (`%{john | name: "Jane"}`) when you know the exact fields at compile time. Always use `struct!/2` instead of `Map` functions to preserve struct integrity.
+
+## Structs are bare maps underneath
+
+Structs are simply maps with a "special" field named `__struct__` that holds the name of the struct:
+
+```elixir
+iex> is_map(john)
+true
+iex> john.__struct__
+User
+```
+
+However, structs do not inherit any of the protocols that maps do. For example, you can neither enumerate nor access a struct:
+
+```elixir
+iex> john = %User{}
+%User{age: 27, name: "John"}
+iex> john[:name]
+** (UndefinedFunctionError) function User.fetch/2 is undefined (User does not implement the Access behaviour)
+             User.fetch(%User{age: 27, name: "John"}, :name)
+iex> Enum.each(john, fn {field, value} -> IO.puts(value) end)
+** (Protocol.UndefinedError) protocol Enumerable not implemented for %User{age: 27, name: "John"} of type User (a struct)
+```
+
+Structs alongside protocols provide one of the most important features for Elixir developers: data polymorphism. That's what we will explore in the next chapter.
+
+## Default values and required keys
+
+If you don't specify a default key value when defining a struct, `nil` will be assumed:
+
+```elixir
+iex> defmodule Product do
+...>   defstruct [:name]
+...> end
+iex> %Product{}
+%Product{name: nil}
+```
+
+You can define a structure combining both fields with explicit default values, and implicit `nil` values. In this case you must first specify the fields which implicitly default to `nil`:
+
+```elixir
+iex> defmodule User do
+...>   defstruct [:email, name: "John", age: 27]
+...> end
+iex> %User{}
+%User{age: 27, email: nil, name: "John"}
+```
+
+Doing it in reverse order will raise a syntax error:
+
+```elixir
+iex> defmodule User do
+...>   defstruct [name: "John", age: 27, :email]
+...> end
+** (SyntaxError) iex:107: unexpected expression after keyword list. Keyword lists must always come last in lists and maps.
+```
+
+You can also enforce that certain keys have to be specified when creating the struct via the `@enforce_keys` module attribute:
+
+```elixir
+iex> defmodule Car do
+...>   @enforce_keys [:make]
+...>   defstruct [:model, :make]
+...> end
+iex> %Car{}
+** (ArgumentError) the following keys must also be given when building struct Car: [:make]
+    expanding struct: Car.__struct__/1
+```
+
+Enforcing keys provides a simple compile-time guarantee to aid developers when building structs. It is not enforced on updates and it does not provide any sort of value-validation.
diff --git a/lib/elixir/pages/getting-started/try-catch-and-rescue.md b/lib/elixir/pages/getting-started/try-catch-and-rescue.md
new file mode 100644
index 00000000000..09b3c636aad
--- /dev/null
+++ b/lib/elixir/pages/getting-started/try-catch-and-rescue.md
@@ -0,0 +1,306 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# try, catch, and rescue
+
+Elixir has three error mechanisms: errors, throws, and exits. In this chapter, we will explore each of them and include remarks about when each should be used.
+
+## Errors
+
+Errors (or *exceptions*) are used when exceptional things happen in the code. A sample error can be retrieved by trying to add a number to an atom:
+
+```elixir
+iex> :foo + 1
+** (ArithmeticError) bad argument in arithmetic expression
+     :erlang.+(:foo, 1)
+```
+
+A runtime error can be raised any time by using `raise/1`:
+
+```elixir
+iex> raise "oops"
+** (RuntimeError) oops
+```
+
+Other errors can be raised with `raise/2` passing the error name and a list of keyword arguments:
+
+```elixir
+iex> raise ArgumentError, message: "invalid argument foo"
+** (ArgumentError) invalid argument foo
+```
+
+You can also define your own errors by creating a module and using the `defexception/1` construct inside it. This way, you'll create an error with the same name as the module it's defined in. The most common case is to define a custom exception with a message field:
+
+```elixir
+iex> defmodule MyError do
+iex>   defexception message: "default message"
+iex> end
+iex> raise MyError
+** (MyError) default message
+iex> raise MyError, message: "custom message"
+** (MyError) custom message
+```
+
+Errors can be **rescued** using the `try/rescue` construct:
+
+```elixir
+iex> try do
+...>   raise "oops"
+...> rescue
+...>   e in RuntimeError -> e
+...> end
+%RuntimeError{message: "oops"}
+```
+
+The example above rescues the runtime error and returns the exception itself, which is then printed in the `iex` session.
+
+If you don't have any use for the exception, you don't have to pass a variable to `rescue`:
+
+```elixir
+iex> try do
+...>   raise "oops"
+...> rescue
+...>   RuntimeError -> "Error!"
+...> end
+"Error!"
+```
+
+In practice, Elixir developers rarely use the `try/rescue` construct. For example, many languages would force you to rescue an error when a file cannot be opened successfully. Elixir instead provides a `File.read/1` function which returns a tuple containing information about whether the file was opened successfully:
+
+```elixir
+iex> File.read("hello")
+{:error, :enoent}
+iex> File.write("hello", "world")
+:ok
+iex> File.read("hello")
+{:ok, "world"}
+```
+
+There is no `try/rescue` here. In case you want to handle multiple outcomes of opening a file, you can use pattern matching using the `case` construct:
+
+```elixir
+iex> case File.read("hello") do
+...>   {:ok, body} -> IO.puts("Success: #{body}")
+...>   {:error, reason} -> IO.puts("Error: #{reason}")
+...> end
+```
+
+For the cases where you do expect a file to exist (and the lack of that file is truly an *error*) you may use `File.read!/1`:
+
+```elixir
+iex> File.read!("unknown")
+** (File.Error) could not read file "unknown": no such file or directory
+    (elixir) lib/file.ex:272: File.read!/1
+```
+
+At the end of the day, it's up to your application to decide if an error while opening a file is exceptional or not. That's why Elixir doesn't impose exceptions on `File.read/1` and many other functions. Instead, it leaves it up to the developer to choose the best way to proceed.
+
+Many functions in the standard library follow the pattern of having a counterpart that raises an exception instead of returning tuples to match against. The convention is to create a function (`foo`) which returns `{:ok, result}` or `{:error, reason}` tuples and another function (`foo!`, same name but with a trailing `!`) that takes the same arguments as `foo` but which raises an exception if there's an error. `foo!` should return the result (not wrapped in a tuple) if everything goes fine. The `File` module is a good example of this convention.
+
+### Fail fast / Let it crash
+
+One saying that is common in the Erlang community, as well as Elixir's, is "fail fast" / "let it crash". The idea behind let it crash is that, in case something *unexpected* happens, it is best to let the exception happen, without rescuing it.
+
+It is important to emphasize the word *unexpected*. For example, imagine you are building a script to process files. Your script receives filenames as inputs. It is expected that users may make mistakes and provide unknown filenames. In this scenario, while you could use `File.read!/1` to read files and let it crash in case of invalid filenames, it probably makes more sense to use `File.read/1` and provide users of your script with a clear and precise feedback of what went wrong.
+
+Other times, you may fully expect a certain file to exist, and in case it does not, it means something terribly wrong has happened elsewhere. In such cases, `File.read!/1` is all you need.
+
+The second approach also works because, as discussed in the [Processes](processes.md) chapter, all Elixir code runs inside processes that are isolated and don't share anything by default. Therefore, an unhandled exception in a process will never crash or corrupt the state of another process. This allows us to define supervisor processes, which are meant to observe when a process terminates unexpectedly, and start a new one in its place.
+
+At the end of the day, "fail fast" / "let it crash" is a way of saying that, when *something unexpected* happens, it is best to start from scratch within a new process, freshly started by a supervisor, rather than blindly trying to rescue all possible error cases without the full context of when and how they can happen.
+
+### Reraise
+
+While we generally avoid using `try/rescue` in Elixir, one situation where we may want to use such constructs is for observability/monitoring. Imagine you want to log that something went wrong, you could do:
+
+```elixir
+try do
+  ... some code ...
+rescue
+  e ->
+    Logger.error(Exception.format(:error, e, __STACKTRACE__))
+    reraise e, __STACKTRACE__
+end
+```
+
+In the example above, we rescued the exception, logged it, and then re-raised it. We use the `__STACKTRACE__` construct both when formatting the exception and when re-raising. This ensures we reraise the exception as is, without changing value or its origin.
+
+Generally speaking, we take errors in Elixir literally: they are reserved for unexpected and/or exceptional situations, never for controlling the flow of our code. In case you actually need flow control constructs, *throws* should be used. That's what we are going to see next.
+
+## Throws
+
+In Elixir, a value can be thrown and later be caught. `throw` and `catch` are reserved for situations where it is not possible to retrieve a value unless by using `throw` and `catch`.
+
+Those situations are quite uncommon in practice except when interfacing with libraries that do not provide a proper API. For example, let's imagine the `Enum` module did not provide any API for finding a value and that we needed to find the first multiple of 13 in a list of numbers:
+
+```elixir
+iex> try do
+...>   Enum.each(-50..50, fn x ->
+...>     if rem(x, 13) == 0, do: throw(x)
+...>   end)
+...>   "Got nothing"
+...> catch
+...>   x -> "Got #{x}"
+...> end
+"Got -39"
+```
+
+Since `Enum` *does* provide a proper API, in practice `Enum.find/2` is the way to go:
+
+```elixir
+iex> Enum.find(-50..50, &(rem(&1, 13) == 0))
+-39
+```
+
+## Exits
+
+All Elixir code runs inside processes that communicate with each other. When a process dies of "natural causes" (e.g., unhandled exceptions), it sends an `exit` signal. A process can also die by explicitly sending an `exit` signal:
+
+```elixir
+iex> spawn_link(fn -> exit(1) end)
+** (EXIT from #PID<0.56.0>) shell process exited with reason: 1
+```
+
+In the example above, the linked process died by sending an `exit` signal with a value of 1. The Elixir shell automatically handles those messages and prints them to the terminal.
+
+`exit` can also be "caught" using `try/catch`:
+
+```elixir
+iex> try do
+...>   exit("I am exiting")
+...> catch
+...>   :exit, _ -> "not really"
+...> end
+"not really"
+```
+
+`catch` can also be used within a function body without a matching `try`.
+
+```elixir
+defmodule Example do
+  def matched_catch do
+    exit(:timeout)
+  catch
+    :exit, :timeout ->
+      {:error, :timeout}
+  end
+
+  def mismatched_catch do
+    exit(:timeout)
+  catch
+    # Since no clause matches, this catch will have no effect
+    :exit, :explosion ->
+      {:error, :explosion}
+  end
+end
+```
+
+However, using `try/catch` is already uncommon and using it to catch exits is even rarer.
+
+`exit` signals are an important part of the fault tolerant system provided by the Erlang VM. Processes usually run under supervision trees which are themselves processes that listen to `exit` signals from the supervised processes. Once an `exit` signal is received, the supervision strategy kicks in and the supervised process is restarted.
+
+It is exactly this supervision system that makes constructs like `try/catch` and `try/rescue` so uncommon in Elixir. Instead of rescuing an error, we'd rather "fail fast" since the supervision tree will guarantee our application will go back to a known initial state after the error.
+
+## After
+
+Sometimes it's necessary to ensure that a resource is cleaned up after some action that could potentially raise an error. The `try/after` construct allows you to do that. For example, we can open a file and use an `after` clause to close it—even if something goes wrong:
+
+```elixir
+iex> {:ok, file} = File.open("sample", [:utf8, :write])
+iex> try do
+...>   IO.write(file, "olá")
+...>   raise "oops, something went wrong"
+...> after
+...>   File.close(file)
+...> end
+** (RuntimeError) oops, something went wrong
+```
+
+The `after` clause will be executed regardless of whether or not the tried block succeeds. Note, however, that if a linked process exits,
+this process will exit and the `after` clause will not get run. Thus `after` provides only a soft guarantee. Luckily, files in Elixir are also linked to the current processes and therefore they will always get closed if the current process crashes, independent of the
+`after` clause. You will find the same to be true for other resources like ETS tables, sockets, ports and more.
+
+Sometimes you may want to wrap the entire body of a function in a `try` construct, often to guarantee some code will be executed afterwards. In such cases, Elixir allows you to omit the `try` line:
+
+```elixir
+iex> defmodule RunAfter do
+...>   def without_even_trying do
+...>     raise "oops"
+...>   after
+...>     IO.puts("cleaning up!")
+...>   end
+...> end
+iex> RunAfter.without_even_trying
+cleaning up!
+** (RuntimeError) oops
+```
+
+Elixir will automatically wrap the function body in a `try` whenever one of `after`, `rescue` or `catch` is specified. The `after` block handles side effects and does not change the return value from the clauses above it.
+
+## Else
+
+If an `else` block is present, it will match on the results of the `try` block whenever the `try` block finishes without a throw or an error.
+
+```elixir
+iex> x = 2
+2
+iex> try do
+...>   1 / x
+...> rescue
+...>   ArithmeticError ->
+...>     :infinity
+...> else
+...>   y when y < 1 and y > -1 ->
+...>     :small
+...>   _ ->
+...>     :large
+...> end
+:small
+```
+
+Exceptions in the `else` block are not caught. If no pattern inside the `else` block matches, an exception will be raised; this exception is not caught by the current `try/catch/rescue/after` block.
+
+## Variables scope
+
+Similar to `case`, `cond`, `if` and other constructs in Elixir, variables defined inside `try/catch/rescue/after` blocks do not leak to the outer context. In other words, this code is invalid:
+
+```elixir
+iex> try do
+...>   raise "fail"
+...>   what_happened = :did_not_raise
+...> rescue
+...>   _ -> what_happened = :rescued
+...> end
+iex> what_happened
+** (CompileError) undefined variable "what_happened"
+```
+
+Instead, you should return the value of the `try` expression:
+
+```elixir
+iex> what_happened =
+...>   try do
+...>     raise "fail"
+...>     :did_not_raise
+...>   rescue
+...>     _ -> :rescued
+...>   end
+iex> what_happened
+:rescued
+```
+
+Furthermore, variables defined in the do-block of `try` are not available inside `rescue/after/else` either. This is because the `try` block may fail at any moment and therefore the variables may have never been bound in the first place. So this also isn't valid:
+
+```elixir
+iex> try do
+...>   raise "fail"
+...>   another_what_happened = :did_not_raise
+...> rescue
+...>   _ -> another_what_happened
+...> end
+** (CompileError) undefined variable "another_what_happened"
+```
+
+This finishes our introduction on `try`, `catch`, and `rescue`. You will find they are used less frequently in Elixir than in other languages. Next we will talk about a very important subject to Elixir developers: writing documentation.
diff --git a/lib/elixir/pages/getting-started/writing-documentation.md b/lib/elixir/pages/getting-started/writing-documentation.md
new file mode 100644
index 00000000000..2f47c44dab0
--- /dev/null
+++ b/lib/elixir/pages/getting-started/writing-documentation.md
@@ -0,0 +1,181 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
+# Writing documentation
+
+Elixir treats documentation as a first-class citizen. Documentation must be easy to write and easy to read. In this guide you will learn how to write documentation in Elixir, covering constructs like module attributes, style practices, and doctests.
+
+## Markdown
+
+Elixir documentation is written using Markdown. There are plenty of guides on Markdown online, we recommend the one from GitHub as a getting started point:
+
+  * [Basic writing and formatting syntax](https://help.github.com/articles/basic-writing-and-formatting-syntax/)
+
+## Module Attributes
+
+Documentation in Elixir is usually attached to module attributes. Let's see an example:
+
+```elixir
+defmodule MyApp.Hello do
+  @moduledoc """
+  This is the Hello module.
+  """
+  @moduledoc since: "1.0.0"
+
+  @doc """
+  Says hello to the given `name`.
+
+  Returns `:ok`.
+
+  ## Examples
+
+      iex> MyApp.Hello.world(:john)
+      :ok
+
+  """
+  @doc since: "1.3.0"
+  def world(name) do
+    IO.puts("hello #{name}")
+  end
+end
+```
+
+The `@moduledoc` attribute is used to add documentation to the module. `@doc` is used before a function to provide documentation for it. Besides the attributes above, `@typedoc` can also be used to attach documentation to types defined as part of typespecs.
+
+## Function arguments
+
+When documenting a function, argument names are inferred by the compiler. For example:
+
+```elixir
+def size(%{size: size}) do
+  size
+end
+```
+
+The compiler will infer this argument as `map`. Sometimes the inference will be suboptimal, especially if the function contains multiple clauses with the argument matching on different values each time. You can specify the proper names for documentation by declaring only the function head at any moment before the implementation:
+
+```elixir
+def size(map_with_size)
+
+def size(%{size: size}) do
+  size
+end
+```
+
+## Documentation metadata
+
+Elixir allows developers to attach arbitrary metadata to the documentation. This is done by passing a keyword list to the relevant attribute (such as `@moduledoc`, `@typedoc`, and `@doc`).
+
+Metadata can have any key. Documentation tools often use metadata to provide more data to readers and to enrich the user experience. The following keys already have a predefined meaning used by tooling:
+
+### `:deprecated`
+
+Another common metadata is `:deprecated`, which emits a warning in the documentation, explaining that its usage is discouraged:
+
+```elixir
+@doc deprecated: "Use Foo.bar/2 instead"
+```
+
+Note that the `:deprecated` key does not warn when a developer invokes the functions. If you want the code to also emit a warning, you can use the `@deprecated` attribute:
+
+```elixir
+@deprecated "Use Foo.bar/2 instead"
+```
+
+### `:group`
+
+The group a function, callback or type belongs to. This is used in `iex` for autocompleting and also to automatically by [ExDoc](https://github.com/elixir-lang/ex_doc/) to group items in the sidebar:
+
+```elixir
+@doc group: "Query"
+def all(query)
+
+@doc group: "Schema"
+def insert(schema)
+```
+
+### `:since`
+
+It annotates in which version that particular module, function, type, or callback was added:
+
+```elixir
+@doc since: "1.3.0"
+def world(name) do
+  IO.puts("hello #{name}")
+end
+```
+
+## Recommendations
+
+When writing documentation:
+
+  * Keep the first paragraph of the documentation concise and simple, typically one-line. Tools like [ExDoc](https://github.com/elixir-lang/ex_doc/) use the first line to generate a summary.
+
+  * Reference modules by their full name. Markdown uses backticks (`` ` ``) to quote code. Elixir builds on top of that to automatically generate links when module or function names are referenced. For this reason, always use full module names. If you have a module called `MyApp.Hello`, always reference it as `` `MyApp.Hello` `` and never as `` `Hello` ``.
+
+  * Reference functions by name and arity if they are local, as in `` `world/1` ``, or by module, name and arity if pointing to an external module: `` `MyApp.Hello.world/1` ``.
+
+  * Reference a `@callback` by prepending `c:`, as in `` `c:world/1` ``.
+
+  * Reference a `@type` by prepending `t:`, as in `` `t:values/0` ``.
+
+  * Start new sections with second level Markdown headers `##`. First level headers are reserved for module and function names.
+
+  * Place documentation before the first clause of multi-clause functions. Documentation is always per function and arity and not per clause.
+
+  * Use the `:since` key in the documentation metadata to annotate whenever new functions or modules are added to your API.
+
+## Doctests
+
+We advise developers to include examples in their documentation, often under their own `## Examples` heading. To ensure examples do not get out of date, Elixir's test framework (ExUnit) provides a feature called doctests that allows developers to test the examples in their documentation. Doctests work by parsing out code samples starting with `iex>` from the documentation. You can read more about them at `ExUnit.DocTest`.
+
+## Documentation != Code comments
+
+Elixir treats documentation and code comments as different concepts. Documentation is an explicit contract between you and users of your Application Programming Interface (API), be they third-party developers, co-workers, or your future self. Modules and functions must always be documented if they are part of your API.
+
+Code comments are aimed at developers reading the code. They are useful for marking improvements, leaving notes (for example, why you had to resort to a workaround due to a bug in a library), and so forth. They are tied to the source code: you can completely rewrite a function and remove all existing code comments, and it will continue to behave the same, with no change to either its behavior or its documentation.
+
+Because private functions cannot be accessed externally, Elixir will warn if a private function has a `@doc` attribute and will discard its content. However, you can add code comments to private functions, as with any other piece of code, and we recommend developers to do so whenever they believe it will add relevant information to the readers and maintainers of such code.
+
+In summary, documentation is a contract with users of your API, who may not necessarily have access to the source code, whereas code comments are for those who interact directly with the source. You can learn and express different guarantees about your software by separating those two concepts.
+
+## Hiding internal modules and functions
+
+Besides the modules and functions libraries provide as part of their public interface, libraries may also implement important functionality that is not part of their API. While these modules and functions can be accessed, they are meant to be internal to the library and thus should not have documentation for end users.
+
+Conveniently, Elixir allows developers to hide modules and functions from the documentation, by setting `@doc false` to hide a particular function, or `@moduledoc false` to hide the whole module. If a module is hidden, you may even document the functions in the module, but the module itself won't be listed in the documentation:
+
+```elixir
+defmodule MyApp.Hidden do
+  @moduledoc false
+
+  @doc """
+  This function won't be listed in docs.
+  """
+  def function_that_wont_be_listed_in_docs do
+    # ...
+  end
+end
+```
+
+In case you don't want to hide a whole module, you can hide functions individually:
+
+```elixir
+defmodule MyApp.Sample do
+  @doc false
+  def add(a, b), do: a + b
+end
+```
+
+However, keep in mind `@moduledoc false` or `@doc false` do not make a function private. The function above can still be invoked as `MyApp.Sample.add(1, 2)`. Not only that, if `MyApp.Sample` is imported, the `add/2` function will also be imported into the caller. For those reasons, be cautious when adding `@doc false` to functions, instead use one of these two options:
+
+  * Move the undocumented function to a module with `@moduledoc false`, like `MyApp.Hidden`, ensuring the function won't be accidentally exposed or imported. Remember that you can use `@moduledoc false` to hide a whole module and still document each function with `@doc`. Tools will still ignore the module.
+
+  * Start the function name with one or two underscores, for example, `__add__/2`. Functions starting with underscore are automatically treated as hidden, although you can also be explicit and add `@doc false`. The compiler does not import functions with leading underscores and they hint to anyone reading the code of their intended private usage.
+
+## `Code.fetch_docs/1`
+
+Elixir stores documentation inside pre-defined chunks in the bytecode. Documentation is not loaded into memory when modules are loaded, instead, it can be read from the bytecode in disk using the `Code.fetch_docs/1` function. The downside is that modules defined in-memory, like the ones defined in IEx, cannot have their documentation accessed as they do not write their bytecode to disk.
diff --git a/lib/elixir/pages/images/kv-observer.png b/lib/elixir/pages/images/kv-observer.png
new file mode 100644
index 00000000000..7527d7e5c80
Binary files /dev/null and b/lib/elixir/pages/images/kv-observer.png differ
diff --git a/lib/elixir/pages/images/logo.png b/lib/elixir/pages/images/logo.png
new file mode 100644
index 00000000000..fcb34f09d60
Binary files /dev/null and b/lib/elixir/pages/images/logo.png differ
diff --git a/lib/elixir/pages/meta-programming/domain-specific-languages.md b/lib/elixir/pages/meta-programming/domain-specific-languages.md
new file mode 100644
index 00000000000..6fc91f77809
--- /dev/null
+++ b/lib/elixir/pages/meta-programming/domain-specific-languages.md
@@ -0,0 +1,203 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Domain-Specific Languages (DSLs)
+
+[Domain-specific Languages (DSLs)](https://en.wikipedia.org/wiki/Domain-specific_language) are languages tailored to a specific application domain. You don't need macros in order to have a DSL: every data structure and every function you define in your module is part of your domain-specific language.
+
+For example, imagine we want to implement a `Validator` module which provides a data validation domain-specific language. We could implement it using data structures, functions, or macros. Let's see what those different DSLs would look like:
+
+```elixir
+# 1. Data structures
+import Validator
+validate user, name: [length: 1..100], email: [matches: ~r/@/]
+
+# 2. Functions
+import Validator
+user
+|> validate_length(:name, 1..100)
+|> validate_matches(:email, ~r/@/)
+
+# 3. Macros + modules
+defmodule MyValidator do
+  use Validator
+  validate_length :name, 1..100
+  validate_matches :email, ~r/@/
+end
+
+MyValidator.validate(user)
+```
+
+Of all the approaches above, the first is definitely the most flexible. If our domain rules can be encoded with data structures, they are by far the easiest to compose and implement, as Elixir's standard library is filled with functions for manipulating different data types.
+
+The second approach uses function calls which better suits more complex APIs (for example, if you need to pass many options) and reads nicely in Elixir thanks to the pipe operator.
+
+The third approach uses macros, and is by far the most complex. It will take more lines of code to implement, it is hard and expensive to test (compared to testing simple functions), and it limits how the user may use the library since all validations need to be defined inside a module.
+
+To drive the point home, imagine you want to validate a certain attribute only if a given condition is met. We could easily achieve it with the first solution, by manipulating the data structure accordingly, or with the second solution by using conditionals (if/else) before invoking the function. However, it is impossible to do so with the macros approach unless its DSL is augmented.
+
+In other words:
+
+```text
+data > functions > macros
+```
+
+That said, there are still cases where using macros and modules to build domain-specific languages is useful. Since we have explored data structures and function definitions in the Getting Started guide, this chapter will explore how to use macros and module attributes to tackle more complex DSLs.
+
+## Building our own test case
+
+The goal in this chapter is to build a module named `TestCase` that allows us to write the following:
+
+```elixir
+defmodule MyTest do
+  use TestCase
+
+  test "arithmetic operations" do
+    4 = 2 + 2
+  end
+
+  test "list operations" do
+    [1, 2, 3] = [1, 2] ++ [3]
+  end
+end
+
+MyTest.run()
+```
+
+In the example above, by using `TestCase`, we can write tests using the `test` macro, which defines a function named `run` to automatically run all tests for us. Our prototype will rely on the match operator (`=`) as a mechanism to do assertions.
+
+## The `test` macro
+
+Let's start by creating a module that defines and imports the `test` macro when used:
+
+```elixir
+defmodule TestCase do
+  # Callback invoked by `use`.
+  #
+  # For now it returns a quoted expression that
+  # imports the module itself into the user code.
+  @doc false
+  defmacro __using__(_opts) do
+    quote do
+      import TestCase
+    end
+  end
+
+  @doc """
+  Defines a test case with the given description.
+
+  ## Examples
+
+      test "arithmetic operations" do
+        4 = 2 + 2
+      end
+
+  """
+  defmacro test(description, do: block) do
+    function_name = String.to_atom("test " <> description)
+    quote do
+      def unquote(function_name)(), do: unquote(block)
+    end
+  end
+end
+```
+
+Assuming we defined `TestCase` in a file named `tests.exs`, we can open it up by running `iex tests.exs` and define our first tests:
+
+```elixir
+iex> defmodule MyTest do
+...>   use TestCase
+...>
+...>   test "hello" do
+...>     "hello" = "world"
+...>   end
+...> end
+```
+
+For now, we don't have a mechanism to run tests, but we know that a function named `test hello` was defined behind the scenes. When we invoke it, it should fail:
+
+```elixir
+iex> MyTest."test hello"()
+** (MatchError) no match of right hand side value: "world"
+```
+
+## Storing information with attributes
+
+In order to finish our `TestCase` implementation, we need to be able to access all defined test cases. One way of doing this is by retrieving the tests at runtime via `__MODULE__.__info__(:functions)`, which returns a list of all functions in a given module. However, considering that we may want to store more information about each test besides the test name, a more flexible approach is required.
+
+When discussing module attributes in earlier chapters, we mentioned how they can be used as temporary storage. That's exactly the property we will apply in this section.
+
+In the `__using__/1` implementation, we will initialize a module attribute named `@tests` to an empty list, then store the name of each defined test in this attribute so the tests can be invoked from the `run` function.
+
+Here is the updated code for the `TestCase` module:
+
+```elixir
+defmodule TestCase do
+  @doc false
+  defmacro __using__(_opts) do
+    quote do
+      import TestCase
+
+      # Initialize @tests to an empty list
+      @tests []
+
+      # Invoke TestCase.__before_compile__/1 before the module is compiled
+      @before_compile TestCase
+    end
+  end
+
+  @doc """
+  Defines a test case with the given description.
+
+  ## Examples
+
+      test "arithmetic operations" do
+        4 = 2 + 2
+      end
+
+  """
+  defmacro test(description, do: block) do
+    function_name = String.to_atom("test " <> description)
+    quote do
+      # Prepend the newly defined test to the list of tests
+      @tests [unquote(function_name) | @tests]
+      def unquote(function_name)(), do: unquote(block)
+    end
+  end
+
+  # This will be invoked right before the target module is compiled
+  # giving us the perfect opportunity to inject the `run/0` function
+  @doc false
+  defmacro __before_compile__(_env) do
+    quote do
+      def run do
+        Enum.each(@tests, fn name ->
+          IO.puts("Running #{name}")
+          apply(__MODULE__, name, [])
+        end)
+      end
+    end
+  end
+end
+```
+
+By starting a new IEx session, we can now define our tests and run them:
+
+```elixir
+iex> defmodule MyTest do
+...>   use TestCase
+...>
+...>   test "hello" do
+...>     "hello" = "world"
+...>   end
+...> end
+iex> MyTest.run()
+Running test hello
+** (MatchError) no match of right hand side value: "world"
+```
+
+Although we have overlooked some details, this is the main idea behind creating domain-specific languages in Elixir via modules and macros. Macros enable us to return quoted expressions that are executed in the caller, which we can then use to transform code and store relevant information in the target module via module attributes. Finally, callbacks such as `@before_compile` allow us to inject code into the module when its definition is complete.
+
+Besides `@before_compile`, there are other useful module attributes like `@on_definition` and `@after_compile`, which you can read more about in the docs for `Module`. You can also find useful information about macros and the compilation environment in the documentation for the `Macro` and `Macro.Env`.
diff --git a/lib/elixir/pages/meta-programming/macros.md b/lib/elixir/pages/meta-programming/macros.md
new file mode 100644
index 00000000000..0fbf55db5af
--- /dev/null
+++ b/lib/elixir/pages/meta-programming/macros.md
@@ -0,0 +1,292 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Macros
+
+Even though Elixir attempts its best to provide a safe environment for macros, most of the responsibility of writing clean code with macros falls on developers. Macros are harder to write than ordinary Elixir functions, and it's considered to be bad style to use them when they're not necessary. Write macros responsibly.
+
+Elixir already provides mechanisms to write your everyday code in a simple and readable fashion by using its data structures and functions. Macros should only be used as a last resort. Remember that **explicit is better than implicit**. **Clear code is better than concise code.**
+
+## Our first macro
+
+Macros in Elixir are defined via `defmacro/2`.
+
+> For this guide, we will be using files instead of running code samples in IEx. That's because the code samples will span multiple lines of code and typing them all in IEx can be counter-productive. You should be able to run the code samples by saving them into a `macros.exs` file and running it with `elixir macros.exs` or `iex macros.exs`.
+
+In order to better understand how macros work, let's create a new module where we are going to implement `unless` (which does the opposite of `if/2`), as a macro and as a function:
+
+```elixir
+defmodule Unless do
+  def fun_unless(clause, do: expression) do
+    if(!clause, do: expression)
+  end
+
+  defmacro macro_unless(clause, do: expression) do
+    quote do
+      if(!unquote(clause), do: unquote(expression))
+    end
+  end
+end
+```
+
+The function receives the arguments and passes them to `if/2`. However, as we learned in the [previous guide](quote-and-unquote.md), the macro will receive quoted expressions, inject them into the quote, and finally return another quoted expression.
+
+Let's start `iex` with the module above:
+
+```console
+$ iex macros.exs
+```
+
+and play with those definitions:
+
+```elixir
+iex> require Unless
+iex> Unless.macro_unless(true, do: IO.puts("this should never be printed"))
+nil
+iex> Unless.fun_unless(true, do: IO.puts("this should never be printed"))
+"this should never be printed"
+nil
+```
+
+In our *macro* implementation, the sentence was not printed, although it was printed in our *function* implementation. That's because the arguments to a function call are evaluated before calling the function. However, macros do not evaluate their arguments. Instead, they receive the arguments as quoted expressions which are then transformed into other quoted expressions. In this case, we have rewritten our `unless` macro to become an `if/2` behind the scenes.
+
+In other words, when invoked as:
+
+```elixir
+Unless.macro_unless(true, do: IO.puts("this should never be printed"))
+```
+
+Our `macro_unless` macro received the following:
+
+```elixir
+macro_unless(true, [do: {{:., [], [{:__aliases__, [alias: false], [:IO]}, :puts]}, [], ["this should never be printed"]}])
+```
+
+and it then returned a quoted expression as follows:
+
+```elixir
+{:if, [],
+ [{:!, [], [true]},
+  [do: {{:., [],
+     [{:__aliases__,
+       [], [:IO]},
+      :puts]}, [], ["this should never be printed"]}]]}
+```
+
+We can actually verify that this is the case by using `Macro.expand_once/2`:
+
+```elixir
+iex> expr = quote do: Unless.macro_unless(true, do: IO.puts("this should never be printed"))
+iex> res  = Macro.expand_once(expr, __ENV__)
+iex> IO.puts(Macro.to_string(res))
+if(!true) do
+  IO.puts("this should never be printed")
+end
+:ok
+```
+
+`Macro.expand_once/2` receives a quoted expression and expands it according to the current environment. In this case, it expanded/invoked the `Unless.macro_unless/2` macro and returned its result. We then proceeded to convert the returned quoted expression to a string and print it (we will talk about `__ENV__` later in this chapter).
+
+That's what macros are all about. They are about receiving quoted expressions and transforming them into something else.
+In fact, `if/2` in Elixir is implemented as a macro:
+
+```elixir
+defmacro if(clause, do: expression) do
+  quote do
+    case unquote(clause) do
+      x when x in [false, nil] -> nil
+      _ -> unquote(expression)
+  end
+end
+```
+
+Constructs such as `if/2`, `defmacro/2`, `def/2`, `defprotocol/2`, and many others used throughout the Elixir standard library are written in pure Elixir, often as a macro. This means that the constructs being used to build the language can be used by developers to extend the language to the domains they are working on.
+
+We can define any function and macro we want, including ones that override the built-in definitions provided by Elixir. The only exceptions are Elixir special forms which are not implemented in Elixir and therefore cannot be overridden. The full list of special forms is available in `Kernel.SpecialForms`.
+
+## Macro hygiene
+
+Elixir macros have "late resolution". This guarantees that a variable defined inside a quote won't conflict with a variable defined in the context where that macro is expanded. For example:
+
+```elixir
+defmodule Hygiene do
+  defmacro no_interference do
+    quote do: a = 1
+  end
+end
+
+defmodule HygieneTest do
+  def go do
+    require Hygiene
+    a = 13
+    Hygiene.no_interference()
+    a
+  end
+end
+
+HygieneTest.go()
+# => 13
+```
+
+In the example above, even though the macro injects `a = 1`, it does not affect the variable `a` defined by the `go/0` function. If a macro wants to explicitly affect the context, it can use `var!/1`:
+
+```elixir
+defmodule Hygiene do
+  defmacro interference do
+    quote do: var!(a) = 1
+  end
+end
+
+defmodule HygieneTest do
+  def go do
+    require Hygiene
+    a = 13
+    Hygiene.interference()
+    a
+  end
+end
+
+HygieneTest.go()
+# => 1
+```
+
+The code above will work but issue a warning: `variable "a" is unused`. The macro is overriding the original value and the original value is never used.
+
+Variable hygiene only works because Elixir annotates variables with their **context**. For example, a variable `x` defined on line 3 of a module would be represented as:
+
+```elixir
+{:x, [line: 3], nil}
+```
+
+However, a quoted variable would be represented as:
+
+```elixir
+defmodule Sample do
+  def quoted do
+    quote do: x
+  end
+end
+
+Sample.quoted() #=> {:x, [line: 3], Sample}
+```
+
+Notice that the *third element* in the quoted variable is the atom `Sample`, instead of `nil`, which marks the variable as coming from the `Sample` module. Therefore, Elixir considers these two variables as coming from different contexts and handles them accordingly.
+
+Elixir provides similar mechanisms for imports and aliases too. This guarantees that a macro will behave as specified by its source module rather than conflicting with the target module where the macro is expanded. Hygiene can be bypassed under specific situations by using macros like `var!/2` and `alias!/1`, although one must be careful when using those as they directly change the user environment.
+
+Sometimes variable names might be dynamically created. In such cases, `Macro.var/2` can be used to define new variables:
+
+```elixir
+defmodule Sample do
+  defmacro initialize_to_char_count(variables) do
+    Enum.map(variables, fn name ->
+      var = Macro.var(name, nil)
+      length = name |> Atom.to_string() |> String.length()
+
+      quote do
+        unquote(var) = unquote(length)
+      end
+    end)
+  end
+
+  def run do
+    initialize_to_char_count([:red, :green, :yellow])
+    [red, green, yellow]
+  end
+end
+
+> Sample.run() #=> [3, 5, 6]
+```
+
+Take note of the second argument to `Macro.var/2`. This is the **context** being used and will determine hygiene as described in the next section. Check out also `Macro.unique_var/2`, for cases when you need to generate variables with unique names.
+
+## The environment
+
+When calling `Macro.expand_once/2` earlier in this chapter, we used the special form `__ENV__/0`.
+
+`__ENV__/0` returns a `Macro.Env` struct which contains useful information about the compilation environment, including the current module, file, and line, all variables defined in the current scope, as well as imports, requires, and more:
+
+```elixir
+iex> __ENV__.module
+nil
+iex> __ENV__.file
+"iex"
+iex> __ENV__.requires
+[IEx.Helpers, Kernel, Kernel.Typespec]
+iex> require Integer
+nil
+iex> __ENV__.requires
+[IEx.Helpers, Integer, Kernel, Kernel.Typespec]
+```
+
+Many of the functions in the `Macro` module expect a `Macro.Env` environment. You can read more about these functions in `Macro` and learn more about the compilation environment in the `Macro.Env`.
+
+## Private macros
+
+Elixir also supports **private macros** via `defmacrop`. Like private functions, these macros are only available inside the module that defines them, and only at compilation time.
+
+It is important that a macro is defined before its usage. Failing to define a macro before its invocation will raise an error at runtime, since the macro won't be expanded and will be translated to a function call:
+
+```elixir
+iex> defmodule Sample do
+...>  def four, do: two() + two()
+...>  defmacrop two, do: 2
+...> end
+** (CompileError) iex:2: function two/0 undefined
+```
+
+## Write macros responsibly
+
+Macros are a powerful construct and Elixir provides many mechanisms to ensure they are used responsibly.
+
+  * Macros are **hygienic**: by default, variables defined inside a macro are not going to affect the user code. Furthermore, function calls and aliases available in the macro context are not going to leak into the user context.
+
+  * Macros are **lexical**: it is impossible to inject code or macros globally. In order to use a macro, you need to explicitly `require` or `import` the module that defines the macro.
+
+  * Macros are **explicit**: it is impossible to run a macro without explicitly invoking it. For example, some languages allow developers to completely rewrite functions behind the scenes, often via parse transforms or via some reflection mechanisms. In Elixir, a macro must be explicitly invoked in the caller during compilation time.
+
+  * Macros' language is clear: many languages provide syntax shortcuts for `quote` and `unquote`. In Elixir, we preferred to have them explicitly spelled out, in order to clearly delimit the boundaries of a macro definition and its quoted expressions.
+
+Even with such guarantees, the developer plays a big role when writing macros responsibly. If you are confident you need to resort to macros, remember that macros are not your API. Keep your macro definitions short, including their quoted contents. For example, instead of writing a macro like this:
+
+```elixir
+defmodule MyModule do
+  defmacro my_macro(a, b, c) do
+    quote do
+      do_this(unquote(a))
+      # ...
+      do_that(unquote(b))
+      # ...
+      and_that(unquote(c))
+    end
+  end
+end
+```
+
+write:
+
+```elixir
+defmodule MyModule do
+  defmacro my_macro(a, b, c) do
+    quote do
+      # Keep what you need to do here to a minimum
+      # and move everything else to a function
+      MyModule.do_this_that_and_that(unquote(a), unquote(b), unquote(c))
+    end
+  end
+
+  def do_this_that_and_that(a, b, c) do
+    do_this(a)
+    ...
+    do_that(b)
+    ...
+    and_that(c)
+  end
+end
+```
+
+This makes your code clearer and easier to test and maintain, as you can invoke and test `do_this_that_and_that/3` directly. It also helps you design an actual API for developers that do not want to rely on macros.
+
+With this guide, we finish our introduction to macros. The next guide is a brief discussion on **DSLs** that shows how we can mix macros and module attributes to annotate and extend modules and functions.
diff --git a/lib/elixir/pages/meta-programming/quote-and-unquote.md b/lib/elixir/pages/meta-programming/quote-and-unquote.md
new file mode 100644
index 00000000000..127861538c6
--- /dev/null
+++ b/lib/elixir/pages/meta-programming/quote-and-unquote.md
@@ -0,0 +1,153 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Quote and unquote
+
+This guide aims to introduce the meta-programming techniques available in Elixir. The ability to represent an Elixir program by its own data structures is at the heart of meta-programming. This chapter starts by exploring those structures and the associated `quote/2` and `unquote/1` constructs, so we can take a look at macros in the next guide, and finally build our own domain specific language.
+
+## Quoting
+
+The building block of an Elixir program is a tuple with three elements. For example, the function call `sum(1, 2, 3)` is represented internally as:
+
+```elixir
+{:sum, [], [1, 2, 3]}
+```
+
+You can get the representation of any expression by using the `quote/2` macro:
+
+```elixir
+iex> quote do: sum(1, 2, 3)
+{:sum, [], [1, 2, 3]}
+```
+
+The first element is the function name, the second is a keyword list containing metadata, and the third is the arguments list.
+
+Operators are also represented as such tuples:
+
+```elixir
+iex> quote do: 1 + 2
+{:+, [context: Elixir, import: Kernel], [1, 2]}
+```
+
+Even a map is represented as a call to `%{}`:
+
+```elixir
+iex> quote do: %{1 => 2}
+{:%{}, [], [{1, 2}]}
+```
+
+Variables are represented using such triplets, with the difference that the last element is an atom, instead of a list:
+
+```elixir
+iex> quote do: x
+{:x, [], Elixir}
+```
+
+When quoting more complex expressions, we can see that the code is represented in such tuples, which are often nested inside each other in a structure resembling a tree. Many languages would call such representations an [*Abstract Syntax Tree*](https://en.wikipedia.org/wiki/Abstract_syntax_tree) (AST). Elixir calls them *quoted expressions*:
+
+```elixir
+iex> quote do: sum(1, 2 + 3, 4)
+{:sum, [], [1, {:+, [context: Elixir, import: Kernel], [2, 3]}, 4]}
+```
+
+Sometimes, when working with quoted expressions, it may be useful to get the textual code representation back. This can be done with `Macro.to_string/1`:
+
+```elixir
+iex> Macro.to_string(quote do: sum(1, 2 + 3, 4))
+"sum(1, 2 + 3, 4)"
+```
+
+In general, the tuples above are structured according to the following format:
+
+```elixir
+{atom | tuple, list, list | atom}
+```
+
+  * The first element is an atom or another tuple in the same representation;
+  * The second element is a keyword list containing metadata, like numbers and contexts;
+  * The third element is either a list of arguments for the function call or an atom. When this element is an atom, it means the tuple represents a variable.
+
+Besides the tuple defined above, there are five Elixir literals that, when quoted, return themselves (and not a tuple). They are:
+
+```elixir
+:sum         #=> Atoms
+1.0          #=> Numbers
+[1, 2]       #=> Lists
+"strings"    #=> Strings
+{key, value} #=> Tuples with two elements
+```
+
+Most Elixir code has a straight-forward translation to its underlying quoted expression. We recommend you try out different code samples and see what the results are. For example, what does `String.upcase("foo")` expand to? We have also learned that `if(true, do: :this, else: :that)` is the same as `if true do :this else :that end`. How does this affirmation hold with quoted expressions?
+
+## Unquoting
+
+Quoting is about retrieving the inner representation of some particular chunk of code. However, sometimes it may be necessary to inject some other particular chunk of code inside the representation we want to retrieve.
+
+For example, imagine you have a variable called `number` which contains the number you want to inject inside a quoted expression.
+
+```elixir
+iex> number = 13
+iex> Macro.to_string(quote do: 11 + number)
+"11 + number"
+```
+
+That's not what we wanted, since the value of the `number` variable has not been injected and `number` has been quoted in the expression. In order to inject the *value* of the `number` variable, `unquote/1` has to be used inside the quoted representation:
+
+```elixir
+iex> number = 13
+iex> Macro.to_string(quote do: 11 + unquote(number))
+"11 + 13"
+```
+
+`unquote/1` can even be used to inject function names:
+
+```elixir
+iex> fun = :hello
+iex> Macro.to_string(quote do: unquote(fun)(:world))
+"hello(:world)"
+```
+
+In some cases, it may be necessary to inject many values inside a list. For example, imagine you have a list containing `[1, 2, 6]`, and we want to inject `[3, 4, 5]` into it. Using `unquote/1` won't yield the desired result:
+
+```elixir
+iex> inner = [3, 4, 5]
+iex> Macro.to_string(quote do: [1, 2, unquote(inner), 6])
+"[1, 2, [3, 4, 5], 6]"
+```
+
+That's when `unquote_splicing/1` comes in handy:
+
+```elixir
+iex> inner = [3, 4, 5]
+iex> Macro.to_string(quote do: [1, 2, unquote_splicing(inner), 6])
+"[1, 2, 3, 4, 5, 6]"
+```
+
+Unquoting is very useful when working with macros. When writing macros, developers are able to receive code chunks and inject them inside other code chunks, which can be used to transform code or write code that generates code during compilation.
+
+## Escaping
+
+As we saw at the beginning of this chapter, only some values are valid quoted expressions in Elixir. For example, a map is not a valid quoted expression. Neither is a tuple with four elements. However, such values *can* be expressed as a quoted expression:
+
+```elixir
+iex> quote do: %{1 => 2}
+{:%{}, [], [{1, 2}]}
+```
+
+In some cases, you may need to inject such *values* into *quoted expressions*. To do that, we need to first escape those values into quoted expressions with the help of `Macro.escape/1`:
+
+```elixir
+iex> map = %{hello: :world}
+iex> Macro.escape(map)
+{:%{}, [], [hello: :world]}
+```
+
+Macros receive quoted expressions and must return quoted expressions. However, sometimes during the execution of a macro, you may need to work with values and making a distinction between values and quoted expressions will be required.
+
+In other words, it is important to make a distinction between a regular Elixir value (like a list, a map, a process, a reference, and so on) and a quoted expression. Some values, such as integers, atoms, and strings, have a quoted expression equal to the value itself. Other values, like maps, need to be explicitly converted. Finally, values like functions and references cannot be converted to a quoted expression at all.
+
+When working with macros and code that generates code, check out the documentation for the `Macro` module, which contains many functions to work with Elixir's AST.
+
+In this introduction, we have laid the groundwork to finally write our first macro. You can check that out in the [next guide](macros.md).
diff --git a/lib/elixir/pages/mix-and-otp/agents.md b/lib/elixir/pages/mix-and-otp/agents.md
new file mode 100644
index 00000000000..e629061ea6c
--- /dev/null
+++ b/lib/elixir/pages/mix-and-otp/agents.md
@@ -0,0 +1,210 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Simple state with agents
+
+In this chapter, we will learn how to keep and share state between multiple entities. If you have previous programming experience, you may think of globally shared variables, but the model we will learn here is quite different. The next chapters will generalize the concepts introduced here.
+
+If you have skipped the *Getting Started* guide or read it long ago, be sure to re-read the [Processes](../getting-started/processes.md) chapter. We will use it as a starting point.
+
+## The trouble with (mutable) state
+
+Elixir is an immutable language where nothing is shared by default. If we want to share information, this is typically done by sending messages between processes.
+
+When it comes to processes though, we rarely hand-roll our own, instead we use the abstractions available in Elixir and OTP:
+
+  * `Agent` — Simple wrappers around state.
+  * `GenServer` — "Generic servers" (processes) that encapsulate state, provide sync and async calls, support code reloading, and more.
+  * `Task` — Asynchronous units of computation that allow spawning a process and potentially retrieving its result at a later time.
+
+Here, we will use agents, and create a module named `KV.Bucket`, responsible for storing our key-value entries in a way that allows them to be read and modified by other processes.
+
+## Agents 101
+
+`Agent`s are simple wrappers around state. If all you want from a process is to keep state, agents are a great fit. Let's start a `iex` session inside the project with:
+
+```console
+$ iex -S mix
+```
+
+And play a bit with agents:
+
+```elixir
+iex> {:ok, agent} = Agent.start_link(fn -> [] end)
+{:ok, #PID<0.57.0>}
+iex> Agent.update(agent, fn list -> ["eggs" | list] end)
+:ok
+iex> Agent.get(agent, fn list -> list end)
+["eggs"]
+iex> Agent.stop(agent)
+:ok
+```
+
+We started an agent with an initial state of an empty list. The `start_link/1` function returned the `:ok` tuple with a process identifier (PID) of the agent. We will use this PID for all further interactions. We then updated the agent's state, adding our new item to the head of the list. The second argument of `Agent.update/3` is a function that takes the agent's current state as input and returns its desired new state. Finally, we retrieved the whole list. The second argument of `Agent.get/3` is a function that takes the state as input and returns the value that `Agent.get/3` itself will return. Once we are done with the agent, we can call `Agent.stop/3` to terminate the agent process.
+
+The `Agent.update/3` function accepts as a second argument any function that receives one argument and returns a value:
+
+```elixir
+iex> {:ok, agent} = Agent.start_link(fn -> [] end)
+{:ok, #PID<0.338.0>}
+iex> Agent.update(agent, fn _list -> 123 end)
+:ok
+iex> Agent.update(agent, fn content -> %{a: content} end)
+:ok
+iex> Agent.update(agent, fn content -> [12 | [content]] end)
+:ok
+iex> Agent.update(agent, fn list -> [:nop | list] end)
+:ok
+iex> Agent.get(agent, fn content -> content end)
+[:nop, 12, %{a: 123}]
+```
+
+As you can see, we can modify the agent state in any way we want. Therefore, we most likely don't want to access the Agent API throughout many different places in our code. Instead, we want to encapsulate all Agent-related functionality in a single module, which we will call `KV.Bucket`. Before we implement it, let's write some tests which will outline the API exposed by our module.
+
+Create a file at `test/kv/bucket_test.exs` (remember the `.exs` extension) with the following:
+
+```elixir
+defmodule KV.BucketTest do
+  use ExUnit.Case, async: true
+
+  test "stores values by key" do
+    {:ok, bucket} = KV.Bucket.start_link([])
+    assert KV.Bucket.get(bucket, "milk") == nil
+
+    KV.Bucket.put(bucket, "milk", 3)
+    assert KV.Bucket.get(bucket, "milk") == 3
+  end
+end
+```
+
+`use ExUnit.Case` is responsible for setting up our module for testing and imports many test-related functionality, such as the `test/2` macro.
+
+Our first test starts a new `KV.Bucket` by calling the `start_link/1` and passing an empty list of options. Then we perform some `get/2` and `put/3` operations on it, asserting the result.
+
+Also note the `async: true` option passed to `ExUnit.Case`. This option makes the test case run in parallel with other `:async` test cases by using multiple cores in our machine. This is extremely useful to speed up our test suite. However, `:async` must *only* be set if the test case does not rely on or change any global values. For example, if the test requires writing to the file system or access a database, keep it synchronous (omit the `:async` option) to avoid race conditions between tests.
+
+Async or not, our new test should obviously fail, as none of the functionality is implemented in the module being tested:
+
+```text
+1) test stores values by key (KV.BucketTest)
+   test/kv/bucket_test.exs:4
+   ** (UndefinedFunctionError) function KV.Bucket.start_link/1 is undefined (module KV.Bucket is not available)
+```
+
+In order to fix the failing test, let's create a file at `lib/kv/bucket.ex` with the contents below. Feel free to give a try at implementing the `KV.Bucket` module yourself using agents before peeking at the implementation below.
+
+```elixir
+defmodule KV.Bucket do
+  use Agent
+
+  @doc """
+  Starts a new bucket.
+
+  All options are forwarded to `Agent.start_link/2`.
+  """
+  def start_link(opts) do
+    Agent.start_link(fn -> %{} end, opts)
+  end
+
+  @doc """
+  Gets a value from the `bucket` by `key`.
+  """
+  def get(bucket, key) do
+    Agent.get(bucket, &Map.get(&1, key))
+  end
+
+  @doc """
+  Puts the `value` for the given `key` in the `bucket`.
+  """
+  def put(bucket, key, value) do
+    Agent.update(bucket, &Map.put(&1, key, value))
+  end
+end
+```
+
+The first step in our implementation is to call `use Agent`. This is a pattern we will see throughout the guides and understand in depth in the next chapter.
+
+Then we define a `start_link/1` function, which will effectively start the agent. It is a convention to define a `start_link/1` function that always accepts a list of options. We then call `Agent.start_link/2` passing an anonymous function that returns the Agent's initial state and the same list of options we received.
+
+We are keeping a map inside the agent to store our keys and values. Getting and putting values on the map is done with the Agent API and the capture operator `&`, introduced in [the Getting Started guide](../getting-started/anonymous-functions.md#the-capture-operator). The agent passes its state to the anonymous function via the `&1` argument when `Agent.get/2` and `Agent.update/2` are called.
+
+Now that the `KV.Bucket` module has been defined, our test should pass! You can try it yourself by running: `mix test`.
+
+## Naming processes
+
+When starting `KV.Bucket`, we pass a list of options which we forward to `Agent.start_link/2`. One of the options accepted by `Agent.start_link/2` is a name option which allows us to name a process, so we can interact with it using its name instead of its PID.
+
+Let's write a test as an example. Back on `KV.BucketTest`, add this:
+
+```elixir
+  test "stores values by key on a named process" do
+    {:ok, _} = KV.Bucket.start_link(name: :shopping_list)
+    assert KV.Bucket.get(:shopping_list, "milk") == nil
+
+    KV.Bucket.put(:shopping_list, "milk", 3)
+    assert KV.Bucket.get(:shopping_list, "milk") == 3
+  end
+```
+
+However, keep in mind that names are shared in the current node. If two tests attempt to create two processes named `:shopping_list` at the same time, one would succeed and the other would fail. For this reason, it is a common practice in Elixir to name processes started during tests after the test itself, like this:
+
+```elixir
+  test "stores values by key on a named process", config do
+    {:ok, _} = KV.Bucket.start_link(name: config.test)
+    assert KV.Bucket.get(config.test, "milk") == nil
+
+    KV.Bucket.put(config.test, "milk", 3)
+    assert KV.Bucket.get(config.test, "milk") == 3
+  end
+```
+
+The `config` argument, passed after the test name, is the *test context* and it includes configuration and metadata about the current test, which is useful in scenarios like these.
+
+## Other agent actions
+
+Besides getting a value and updating the agent state, agents allow us to get a value and update the agent state in one function call via `Agent.get_and_update/2`. Let's implement a `KV.Bucket.delete/2` function that deletes a key from the bucket, returning its current value:
+
+```elixir
+@doc """
+Deletes `key` from `bucket`.
+
+Returns the current value of `key`, if `key` exists.
+"""
+def delete(bucket, key) do
+  Agent.get_and_update(bucket, &Map.pop(&1, key))
+end
+```
+
+Now it is your turn to write a test for the functionality above! Also, be sure to explore [the documentation for the `Agent` module](`Agent`) to learn more about them.
+
+## Client/server in agents
+
+Before we move on to the next chapter, let's discuss the client/server dichotomy in agents. Let's expand the `delete/2` function we have just implemented:
+
+```elixir
+def delete(bucket, key) do
+  Agent.get_and_update(bucket, fn map ->
+    Map.pop(map, key)
+  end)
+end
+```
+
+Everything that is inside the function we passed to the agent happens in the agent process. In this case, since the agent process is the one receiving and responding to our messages, we say the agent process is the server. Everything outside the function is happening in the client.
+
+This distinction is important. If there are expensive actions to be done, you must consider if it will be better to perform these actions on the client or on the server. For example:
+
+```elixir
+def delete(bucket, key) do
+  Process.sleep(1000) # puts client to sleep
+  Agent.get_and_update(bucket, fn map ->
+    Process.sleep(1000) # puts server to sleep
+    Map.pop(map, key)
+  end)
+end
+```
+
+When a long action is performed on the server, all other requests to that particular server will wait until the action is done, which may cause some clients to timeout.
+
+Some APIs, such as GenServers, make a clearer distinction between client and server, and we will explore them in future chapters. Next let's talk about naming things, applications, and supervisors.
diff --git a/lib/elixir/pages/mix-and-otp/config-and-distribution.md b/lib/elixir/pages/mix-and-otp/config-and-distribution.md
new file mode 100644
index 00000000000..6ed27bfb771
--- /dev/null
+++ b/lib/elixir/pages/mix-and-otp/config-and-distribution.md
@@ -0,0 +1,305 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Configuration and distribution
+
+So far we have hardcoded our applications to run a web server on port 4040. This has been somewhat problematic since we can't, for example, run our development server and tests at the same time. In this chapter, we will learn how to use the application environment for configuration, paving the way for us to enable distribution by running multiple development servers on the same machine (on different ports).
+
+In this last guide, we will make the routing table for our distributed key-value store configurable, and then finally package the software for production.
+
+Let's do this.
+
+## Application environment
+
+In the chapter [Registries, applications, and supervisors](supervisor-and-application.md), we have learned that our project is backed by an application, which bundles our modules and specifies how your supervision tree starts and shuts down. Each application can also have its own configuration, which in Erlang/OTP (and therefore Elixir) is called "application environment".
+
+We can use the application environment to configure our own application, as well as others. Let's see the application environment in practice. Create a file `config/runtime.exs` with the following:
+
+```elixir
+import Config
+
+port =
+  cond do
+    port_env = System.get_env("PORT") ->
+      String.to_integer(port_env)
+
+    config_env() == :test ->
+      4040
+
+    true ->
+      4050
+  end
+
+config :kv, :port, port
+```
+
+The above is attempting to read the "PORT" environment variable and use it as the port if defined. Otherwise, we default to port `4040` for tests and port `4050` for other environments, eliminating the conflict between environments we have seen in the past. Then we store its value under the `:port` key of our `:kv` application.
+
+Now we just need to read this configuration. Open up `lib/kv.ex` and the `start/2` function to the following:
+
+```elixir
+  def start(_type, _args) do
+    port = Application.fetch_env!(:kv, :port)
+
+    children = [
+      {Registry, name: KV, keys: :unique},
+      {DynamicSupervisor, name: KV.BucketSupervisor, strategy: :one_for_one},
+      {Task.Supervisor, name: KV.ServerSupervisor},
+      Supervisor.child_spec({Task, fn -> KV.Server.accept(port) end}, restart: :permanent)
+    ]
+
+    Supervisor.start_link(children, strategy: :one_for_one)
+  end
+```
+
+Run `iex -S mix` and you will see the following message printed:
+
+```text
+[info] Accepting connections on port 4050
+```
+
+Run tests, without killing the development server, and you will see it running on port 4040.
+
+Our change was straight-forward. We used `Application.fetch_env!/2` to read the entry for `port` in `:kv`'s environment. We explicitly used `fetch_env!/2` (instead of `get_env/2` or `fetch_env`) because it will raise if the port was not configured (preventing the app from booting).
+
+## Compile vs runtime configuration
+
+Configuration files provide a mechanism for us to configure the environment of any application. Elixir provides two configuration entry points:
+
+  * `config/config.exs` — this file is read at build time, before we compile our application and before we even load our dependencies. This means we can't access the code in our application nor in our dependencies. However, it means we can control how they are compiled
+
+  * `config/runtime.exs` — this file is read after our application and dependencies are compiled and therefore it can configure how our application works at runtime. If you want to read system environment variables (via `System.get_env/1`) or access external configuration, this is the appropriate place to do so
+
+You can learn more about configuration in the `Config` and `Config.Provider` modules.
+
+Generally speaking, we use `Application.fetch_env!/2` (and friends) to read runtime configuration. `Application.compile_env/2` is available for reading compile-time configuration. This allows Elixir to track which modules to recompile when the compilation environment changes.
+
+Now that we can start multiple servers, let's explore distribution.
+
+## Our first distributed code
+
+Elixir ships with facilities to connect nodes and exchange information between them. In fact, we use the same concepts of processes, message passing and receiving messages when working in a distributed environment because Elixir processes are *location transparent*. This means that when sending a message, it doesn't matter if the recipient process is on the same node or on another node, the VM will be able to deliver the message in both cases.
+
+In order to run distributed code, we need to start the VM with a name. The name can be short (when in the same network) or long (requires the full computer address). Let's start a new IEx session:
+
+```console
+$ iex --sname foo
+```
+
+You can see now the prompt is slightly different and shows the node name followed by the computer name:
+
+    Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)
+    iex(foo@jv)1>
+
+My computer is named `jv`, so I see `foo@jv` in the example above, but you will get a different result. We will use `foo@computer-name` in the following examples and you should update them accordingly when trying out the code.
+
+Let's define a module named `Hello` in this shell:
+
+```elixir
+iex> defmodule Hello do
+...>   def world, do: IO.puts("hello world")
+...> end
+```
+
+If you have another computer on the same network with both Erlang and Elixir installed, you can start another shell on it. If you don't, you can start another IEx session in another terminal. In either case, give it the short name of `bar`:
+
+```console
+$ iex --sname bar
+```
+
+Note that inside this new IEx session, we cannot access `Hello.world/0`:
+
+```elixir
+iex> Hello.world
+** (UndefinedFunctionError) function Hello.world/0 is undefined (module Hello is not available)
+    Hello.world()
+```
+
+However, we can spawn a new process on `foo@computer-name` from `bar@computer-name`! Let's give it a try (where `@computer-name` is the one you see locally):
+
+```elixir
+iex> Node.spawn_link(:"foo@computer-name", fn -> Hello.world() end)
+#PID<9014.59.0>
+hello world
+```
+
+Elixir spawned a process on another node and returned its PID. You can see the PID number no longer starts with zero, showing it belongs to another node. The code then executed on the other node where the `Hello.world/0` function exists and invoked that function. Note that the result of "hello world" was printed on the current node `bar` and not on `foo`. In other words, the message to be printed was sent back from `foo` to `bar`. This happens because the process spawned on the other node (`foo`) knows all the output should be sent back to the original node!
+
+We can send and receive messages from the PID returned by `Node.spawn_link/2` as usual. Let's try a quick ping-pong example:
+
+```elixir
+iex> pid = Node.spawn_link(:"foo@computer-name", fn ->
+...>   receive do
+...>     {:ping, client} -> send(client, :pong)
+...>   end
+...> end)
+#PID<9014.59.0>
+iex> send(pid, {:ping, self()})
+{:ping, #PID<0.73.0>}
+iex> flush()
+:pong
+:ok
+```
+
+In other words, we can spawn processes in other nodes, hold onto their PIDs, and then send messages to them as if they were running on the same machine. That's the *location transparency* principle. And because everything we have built so far was built on top of messaging passing, we should be able to adjust our key-value store to become a distributed one with little work.
+
+## Distributed naming registry with `:global`
+
+First, let's check that our code is not currently distributed. Start a new node like this:
+
+```console
+$ PORT=4100 iex --sname foo -S mix
+```
+
+And the other like this:
+
+```console
+$ PORT=4101 iex --sname bar -S mix
+```
+
+Now, within `foo@computer-name`, do this:
+
+```elixir
+iex> :erpc.call(:"bar@computer-name", KV, :create_bucket, ["shopping"])
+{:ok, #PID<22121.164.0>}
+```
+
+Instead of using `Node.spawn_link/2`, we used [Erlang's builtin RPC module](`:erpc`) to call the function `create_bucket` in the `KV` module passing a one element list with the string "shopping" as the argument list. We could have used `Node.spawn_link/2`, but `:erpc.call/4` conveniently returns the result of the invocation.
+
+Still in `foo@computer-name`, let's try to access the bucket:
+
+```elixir
+iex> KV.lookup_bucket("shopping")
+nil
+```
+
+It returns `nil`. However, if you run `KV.lookup_bucket("shopping")` in `bar@computer-name`, it will return the proper bucket. In other words, the nodes can communicate with each other, but buckets spawned in one node are not visible to the other.
+
+This is because we are using [Elixir's Registry](`Registry`) to name our buckets, which is a **local** process registry. In other words, it is designed for processes running on a single node and not for distribution.
+
+Luckily, Erlang ships with a distributed registry called [`:global`](`:global`), which is directly supported by the `:name` option by passing a `{:global, name}` tuple. All we need to do is update the `via/1` function in `lib/kv.ex` from this:
+
+```elixir
+  defp via(name), do: {:via, Registry, {KV, name}}
+```
+
+to this:
+
+```elixir
+  defp via(name), do: {:global, name}
+```
+
+Do the change above and restart both `foo@computer-name` and `bar@computer-name`. Now, back on `foo@computer-name`, let's give it another try:
+
+```elixir
+iex> :erpc.call(:"bar@computer-name", KV, :create_bucket, ["shopping"])
+{:ok, #PID<21821.179.0>}
+iex> KV.lookup_bucket("shopping")
+#PID<21821.179.0>
+```
+
+And there you go! By simply changing which naming registry we used, we now have a distributed key value store. You can even try using `telnet` to connect to the servers on different ports and validate that changes in one session are visible in the other one. Exciting!
+
+## Node discovery and dependencies
+
+There is one essential ingredient to wrap up our distributed key-value store. In order for the `:global` registry to work, we need to make sure the nodes are connected to each other. When we run `:erpc` call passing the node name:
+
+```elixir
+:erpc.call(:"bar@computer-name", KV, :create_bucket, ["shopping"])
+```
+
+Elixir automatically connected the nodes together. This is easy to do in an IEx session when both instances are running on the same machine but it requires more work in a production environment, where instances are on different machines which may be started at any time and running on different IP addresses.
+
+Luckily for us, this is also a well-solved problem. For example, if you are using [the Phoenix web framework](https://phoenixframework.org) in production, it ships with [the `dns_cluster` package](https://github.com/phoenixframework/dns_cluster), which automatically runs DNS queries to find new nodes and connect them. If you are using Kubernetes or cloud providers, [packages like `libcluster`](https://github.com/bitwalker/libcluster) ship with different strategies to discover and connect nodes.
+
+Installing dependencies in Elixir is simple. Most commonly, we use the [Hex Package Manager](https://hex.pm), by listing the dependency inside the deps function in our `mix.exs` file:
+
+```elixir
+def deps do
+  [{:dns_cluster, "~> 0.2"}]
+end
+```
+
+This dependency refers to the latest version of `dns_cluster` in the 0.x version series that has been pushed to Hex. This is indicated by the `~>` preceding the version number. For more information on specifying version requirements, see the documentation for the `Version` module.
+
+Typically, stable releases are pushed to Hex. If you want to depend on an external dependency still in development, Mix is able to manage Git dependencies too:
+
+```elixir
+def deps do
+  [{:dns_cluster, git: "https://github.com/phoenixframework/dns_cluster.git"}]
+end
+```
+
+You will notice that when you add a dependency to your project, Mix generates a `mix.lock` file that guarantees *repeatable builds*. The lock file must be checked in to your version control system, to guarantee that everyone who uses the project will use the same dependency versions as you.
+
+Mix provides many tasks for working with dependencies, which can be seen in `mix help`:
+
+```console
+$ mix help
+mix deps              # Lists dependencies and their status
+mix deps.clean        # Deletes the given dependencies' files
+mix deps.compile      # Compiles dependencies
+mix deps.get          # Gets all out of date dependencies
+mix deps.tree         # Prints the dependency tree
+mix deps.unlock       # Unlocks the given dependencies
+mix deps.update       # Updates the given dependencies
+```
+
+The most common tasks are `mix deps.get` and `mix deps.update`. Once fetched, dependencies are automatically compiled for you. You can read more about deps by running `mix help deps`.
+
+To wrap up this chapter, we will build a very simple node discovery mechanism, where the name of the nodes we should connect to are given on boot, using the lessons we learned in this chapter.
+
+## `Node.connect/1`
+
+We will change our application to support a "NODES" environment variable with the name of all nodes each instance should connect to.
+
+Open up `config/runtime.exs` and add this to the bottom:
+
+```elixir
+nodes =
+  System.get_env("NODES", "")
+  |> String.split(",", trim: true)
+  |> Enum.map(&String.to_atom/1)
+
+config :kv, :nodes, nodes
+```
+
+We fetch the environment variable, split it on "," while discarding all empty strings, and then convert each entry to an atom, as node names are atoms.
+
+Now, in your `start/2` callback, we will add this to of the `start/2` function:
+
+```elixir
+  def start(_type, _args) do
+    for node <- Application.fetch_env!(:kv, :nodes) do
+      Node.connect(node)
+    end
+```
+
+Now we can start our nodes as:
+
+```console
+$ NODES="foo@computer-name,bar@computer-name" PORT=4040 iex --sname foo -S mix
+$ NODES="foo@computer-name,bar@computer-name" PORT=4041 iex --sname bar -S mix
+```
+
+And they should connect to each other. Give it a try!
+
+In an actual production system, there is some additional care we must take. For example, we often use `--name` instead of `--sname` and give fully qualified node names.
+
+Furthermore, when connecting two instances, we must guarantee they have the same cookie, which is a secret Erlang uses to authorize the connection. When they run on the same machine, they share the same cookie by default, but it must be either explicitly set or shared in other ways when deploying in a cluster.
+
+We will revisit these topics in the last chapter when we talk about releases.
+
+## Distributed system trade-offs
+
+In this chapter, we made our key-value store distributed by using the `:global` naming registry. However, it is important to keep in mind that every distributed system, be it a library or a full-blown database, is designed with a series of trade-offs in mind.
+
+In particular, `:global` requires consistency across all known nodes whenever a new bucket is created. For example, if your cluster has three nodes, creating a new bucket will require all three nodes to agree on its name. This means if one node is unresponsive, perhaps due to a [network partition](https://en.wikipedia.org/wiki/Network_partition), the node will have to either reconnect or be kicked out before registration succeeds. This also means that, as your cluster grows in size, registration becomes more expensive, although lookups are always cheap and immediate. Within the ecosystem, there are other named registries, which explore different trade-offs, such as [Syn](https://github.com/ostinelli/syn).
+
+Further complications arise when we consider storage. Today, when our nodes terminate, we lose all data stored in the buckets. In our current design, since we allow each node to store their own buckets, it means we would need to backup each node. And, if we don't want data losses, we would also need to replicate the data.
+
+For those reasons, it is still very common to use a database (or any storage system) when writing production applications in Elixir, and use Elixir to implement the realtime and collaborative aspects of your applications that extend beyond storage. For example, we can use Elixir to track which clients are connected to the cluster at any given moment or implement a feed where users are notified in realtime whenever items are added or removed from a bucket.
+
+In fact, that's exactly what we will build in the next chapter. Allowing us to wrap up everything we have learned so far and also talk about one of the essential building blocks in Elixir software: GenServers.
diff --git a/lib/elixir/pages/mix-and-otp/docs-tests-and-with.md b/lib/elixir/pages/mix-and-otp/docs-tests-and-with.md
new file mode 100644
index 00000000000..eb9d0c62412
--- /dev/null
+++ b/lib/elixir/pages/mix-and-otp/docs-tests-and-with.md
@@ -0,0 +1,426 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Doctests, patterns, and with
+
+In this chapter, we will implement the code that parses the commands we described in the first chapter:
+
+```text
+CREATE shopping
+OK
+
+PUT shopping milk 1
+OK
+
+PUT shopping eggs 3
+OK
+
+GET shopping milk
+1
+OK
+
+DELETE shopping eggs
+OK
+```
+
+After the parsing is done, we will update our server to dispatch the parsed commands to the relevant buckets.
+
+## Doctests
+
+On the language homepage, we mention that Elixir makes documentation a first-class citizen in the language. We have explored this concept many times throughout this guide, be it via `mix help` or by typing `h Enum` or another module in an IEx console.
+
+In this section, we will implement the parsing functionality, document it and make sure our documentation is up to date with doctests. This helps us provide documentation with accurate code samples.
+
+Let's create our command parser at `lib/kv/command.ex` and start with the doctest:
+
+```elixir
+defmodule KV.Command do
+  @doc ~S"""
+  Parses the given `line` into a command.
+
+  ## Examples
+
+      iex> KV.Command.parse("CREATE shopping\r\n")
+      {:ok, {:create, "shopping"}}
+
+  """
+  def parse(_line) do
+    :not_implemented
+  end
+end
+```
+
+Doctests are specified by an indentation of four spaces followed by the `iex>` prompt in a documentation string. If a command spans multiple lines, you can use `...>`, as in IEx. The expected result should start at the next line after `iex>` or `...>` line(s) and is terminated either by a newline or a new `iex>` prefix.
+
+Also, note that we started the documentation string using `@doc ~S"""`. The `~S` prevents the `\r\n` characters from being converted to a carriage return and line feed until they are evaluated in the test.
+
+To run our doctests, we'll create a file at `test/kv/command_test.exs` and call `doctest KV.Command` in the test case:
+
+```elixir
+defmodule KV.CommandTest do
+  use ExUnit.Case, async: true
+  doctest KV.Command
+end
+```
+
+Run the test suite and the doctest should fail:
+
+```text
+  1) doctest KV.Command.parse/1 (1) (KV.CommandTest)
+     test/kv/command_test.exs:3
+     Doctest failed
+     doctest:
+       iex> KV.Command.parse("CREATE shopping\r\n")
+       {:ok, {:create, "shopping"}}
+     code: KV.Command.parse "CREATE shopping\r\n" === {:ok, {:create, "shopping"}}
+     left:  :not_implemented
+     right: {:ok, {:create, "shopping"}}
+     stacktrace:
+       lib/kv/command.ex:7: KV.Command (module)
+```
+
+Excellent!
+
+Now let's make the doctest pass. Let's implement the `parse/1` function:
+
+```elixir
+def parse(line) do
+  case String.split(line) do
+    ["CREATE", bucket] -> {:ok, {:create, bucket}}
+  end
+end
+```
+
+Our implementation splits the line on whitespace and then matches the command against a list. Using `String.split/1` means our commands will be whitespace-insensitive. Leading and trailing whitespace won't matter, nor will consecutive spaces between words. Let's add some new doctests to test this behavior along with the other commands:
+
+```elixir
+  @doc ~S"""
+  Parses the given `line` into a command.
+
+  ## Examples
+
+      iex> KV.Command.parse "CREATE shopping\r\n"
+      {:ok, {:create, "shopping"}}
+
+      iex> KV.Command.parse "CREATE  shopping  \r\n"
+      {:ok, {:create, "shopping"}}
+
+      iex> KV.Command.parse "PUT shopping milk 1\r\n"
+      {:ok, {:put, "shopping", "milk", "1"}}
+
+      iex> KV.Command.parse "GET shopping milk\r\n"
+      {:ok, {:get, "shopping", "milk"}}
+
+      iex> KV.Command.parse "DELETE shopping eggs\r\n"
+      {:ok, {:delete, "shopping", "eggs"}}
+
+  Unknown commands or commands with the wrong number of
+  arguments return an error:
+
+      iex> KV.Command.parse "UNKNOWN shopping eggs\r\n"
+      {:error, :unknown_command}
+
+      iex> KV.Command.parse "GET shopping\r\n"
+      {:error, :unknown_command}
+
+  """
+```
+
+With doctests at hand, it is your turn to make tests pass! Once you're ready, you can compare your work with our solution below:
+
+```elixir
+  def parse(line) do
+    case String.split(line) do
+      ["CREATE", bucket] -> {:ok, {:create, bucket}}
+      ["GET", bucket, key] -> {:ok, {:get, bucket, key}}
+      ["PUT", bucket, key, value] -> {:ok, {:put, bucket, key, value}}
+      ["DELETE", bucket, key] -> {:ok, {:delete, bucket, key}}
+      _ -> {:error, :unknown_command}
+    end
+  end
+```
+
+Notice how we were able to elegantly parse the commands without adding a bunch of `if/else` clauses that check the command name and number of arguments!
+
+Finally, you may have observed that each doctest corresponds to a different test in our suite, which now reports a total of 7 doctests. That is because ExUnit considers the following to define two different doctests:
+
+```elixir
+iex> KV.Command.parse("UNKNOWN shopping eggs\r\n")
+{:error, :unknown_command}
+
+iex> KV.Command.parse("GET shopping\r\n")
+{:error, :unknown_command}
+```
+
+Without new lines, as seen below, ExUnit compiles it into a single doctest:
+
+```elixir
+iex> KV.Command.parse("UNKNOWN shopping eggs\r\n")
+{:error, :unknown_command}
+iex> KV.Command.parse("GET shopping\r\n")
+{:error, :unknown_command}
+```
+
+As the name says, doctest is documentation first and a test later. Their goal is not to replace tests but to provide up-to-date documentation. You can read more about doctests in the `ExUnit.DocTest` documentation.
+
+## Using `with`
+
+As we are now able to parse commands, we can finally start implementing the logic that runs the commands. Let's add a stub definition for this function for now:
+
+```elixir
+defmodule KV.Command do
+  @doc """
+  Runs the given command.
+  """
+  def run(command, socket) do
+    :gen_tcp.send(socket, "OK\r\n")
+    :ok
+  end
+end
+```
+
+Before we implement this function, let's change our server to start using our new `parse/1` and `run/1` functions. Remember, our `read_line/1` function was also crashing when the client closed the socket, so let's take the opportunity to fix it, too. Open up `lib/kv/server.ex` and replace the existing server definition:
+
+```elixir
+  defp serve(socket) do
+    socket
+    |> read_line()
+    |> write_line(socket)
+
+    serve(socket)
+  end
+
+  defp read_line(socket) do
+    {:ok, data} = :gen_tcp.recv(socket, 0)
+    data
+  end
+
+  defp write_line(line, socket) do
+    :gen_tcp.send(socket, line)
+  end
+```
+
+by the following:
+
+```elixir
+  defp serve(socket) do
+    msg =
+      case read_line(socket) do
+        {:ok, data} ->
+          case KV.Command.parse(data) do
+            {:ok, command} ->
+              KV.Command.run(command, socket)
+
+            {:error, _} = err ->
+              err
+          end
+
+        {:error, _} = err ->
+          err
+      end
+
+    write_line(socket, msg)
+    serve(socket)
+  end
+
+  defp read_line(socket) do
+    :gen_tcp.recv(socket, 0)
+  end
+
+  defp write_line(_socket, :ok) do
+    :ok
+  end
+
+  defp write_line(socket, {:error, :unknown_command}) do
+    # Known error; write to the client
+    :gen_tcp.send(socket, "UNKNOWN COMMAND\r\n")
+  end
+
+  defp write_line(_socket, {:error, :closed}) do
+    # The connection was closed, exit politely
+    exit(:shutdown)
+  end
+
+  defp write_line(socket, {:error, error}) do
+    # Unknown error; write to the client and exit
+    :gen_tcp.send(socket, "ERROR\r\n")
+    exit(error)
+  end
+```
+
+If we start our server, we can now send commands to it. For now, we will get two different responses: "OK" when the command is known and "UNKNOWN COMMAND" otherwise:
+
+```console
+$ telnet 127.0.0.1 4040
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+CREATE shopping
+OK
+HELLO
+UNKNOWN COMMAND
+```
+
+This means our implementation is going in the correct direction, but it doesn't look very elegant, does it?
+
+The previous implementation used pipelines which made the logic straightforward to follow. However, now that we need to handle different error codes along the way, our server logic is nested inside many `case` calls.
+
+Thankfully, Elixir has the `with` construct, which allows you to simplify code like the above, replacing nested `case` calls with a chain of matching clauses. Let's rewrite the `serve/1` function to use `with`:
+
+```elixir
+  defp serve(socket) do
+    msg =
+      with {:ok, data} <- read_line(socket),
+          {:ok, command} <- KV.Command.parse(data),
+          do: KV.Command.run(command, socket)
+
+    write_line(socket, msg)
+    serve(socket)
+  end
+```
+
+Much better! `with` will retrieve the value returned by the right-side of `<-` and match it against the pattern on the left side. If the value matches the pattern, `with` moves on to the next expression. In case there is no match, the non-matching value is returned.
+
+In other words, we converted each expression given to `case/2` as a step in `with`. As soon as any of the steps return something that does not match `{:ok, x}`, `with` aborts, and returns the non-matching value.
+
+You can read more about `with/1` in our documentation.
+
+## Running commands
+
+The last step is to implement `KV.Command.run/1` to run the parsed commands on top of buckets. Its implementation is shown below:
+
+```elixir
+  @doc """
+  Runs the given command.
+  """
+  def run(command, socket)
+
+  def run({:create, bucket}, socket) do
+    KV.create_bucket(bucket)
+    :gen_tcp.send(socket, "OK\r\n")
+    :ok
+  end
+
+  def run({:get, bucket, key}, socket) do
+    lookup(bucket, fn pid ->
+      value = KV.Bucket.get(pid, key)
+      :gen_tcp.send(socket, "#{value}\r\nOK\r\n")
+      :ok
+    end)
+  end
+
+  def run({:put, bucket, key, value}, socket) do
+    lookup(bucket, fn pid ->
+      KV.Bucket.put(pid, key, value)
+      :gen_tcp.send(socket, "OK\r\n")
+      :ok
+    end)
+  end
+
+  def run({:delete, bucket, key}, socket) do
+    lookup(bucket, fn pid ->
+      KV.Bucket.delete(pid, key)
+      :gen_tcp.send(socket, "OK\r\n")
+      :ok
+    end)
+  end
+
+  defp lookup(bucket, callback) do
+    if bucket = KV.lookup_bucket(bucket) do
+      callback.(bucket)
+    else
+      {:error, :not_found}
+    end
+  end
+```
+
+Each function clause dispatches the appropriate command to the appropriate bucket.
+
+You might have noticed we have a function head, `def run(command, socket)`, without a body. In the [Modules and Functions](../getting-started/modules-and-functions.md#default-arguments) chapter, we learned that a bodiless function can be used to declare default arguments for a multi-clause function. Here is another use case where we use a function without a body to document what the arguments are.
+
+We have also defined a private function named `lookup/2` to help with the common functionality of looking up a bucket and returning its `pid` if it exists, `{:error, :not_found}` otherwise.
+
+By the way, since we are now returning `{:error, :not_found}`, we should amend the `write_line/2` function in `KV.Server` to print such error as well:
+
+```elixir
+defp write_line(socket, {:error, :not_found}) do
+  :gen_tcp.send(socket, "NOT FOUND\r\n")
+end
+```
+
+Our server functionality is almost complete. Only tests are missing.
+
+## Integration tests
+
+`KV.Command.run/1`'s implementation is sending commands directly to the `KV` module, which is using a local registry to name processes. This means if we have two tests sending messages to the same bucket, our tests will conflict with each other (and likely fail). One might think this would be a reason to use mocks and other strategies to keep our tests isolated, but such techniques often make our testing environment too distant from how our code actually runs in production, and you may end-up with bugs lurking.
+
+Luckily, there is a technique that we have been using throughout this guide that would be equally applicable here: it is ok to rely on the local registry as long as each test uses unique names. Using a combination of the test module and test name is more than enough to guarantee that.
+
+So let's write integration tests that rely on unique names to exercise the whole stack from the TCP server to the bucket.
+
+Create a new file at `test/kv/server_test.exs` as shown below:
+
+```elixir
+defmodule KV.ServerTest do
+  use ExUnit.Case, async: true
+
+  @socket_options [:binary, packet: :line, active: false]
+
+  setup config do
+    {:ok, socket} = :gen_tcp.connect(~c"localhost", 4040, @socket_options)
+    test_name = config.test |> Atom.to_string() |> String.replace(" ", "-")
+    %{socket: socket, name: "#{config.module}-#{test_name}"}
+  end
+
+  test "server interaction", %{socket: socket, name: name} do
+    # CREATE
+    assert send_and_recv(socket, "CREATE #{name}\r\n") == "OK\r\n"
+
+    # PUT
+    assert send_and_recv(socket, "PUT #{name} eggs 3\r\n") == "OK\r\n"
+
+    # GET
+    assert send_and_recv(socket, "GET #{name} eggs\r\n") == "3\r\n"
+    assert send_and_recv(socket, "") == "OK\r\n"
+
+    # DELETE
+    assert send_and_recv(socket, "DELETE #{name} eggs\r\n") == "OK\r\n"
+
+    # GET
+    assert send_and_recv(socket, "GET #{name} eggs\r\n") == "\r\n"
+    assert send_and_recv(socket, "") == "OK\r\n"
+  end
+
+  test "unknown command", %{socket: socket} do
+    assert send_and_recv(socket, "WHATEVER\r\n") ==
+             "UNKNOWN COMMAND\r\n"
+  end
+
+  test "unknown bucket", %{socket: socket} do
+    assert send_and_recv(socket, "GET whatever eggs\r\n") ==
+             "NOT FOUND\r\n"
+  end
+
+  defp send_and_recv(socket, command) do
+    :ok = :gen_tcp.send(socket, command)
+    {:ok, data} = :gen_tcp.recv(socket, 0, 1000)
+    data
+  end
+end
+```
+
+Run `mix test` and the tests should all pass. However, make sure to terminate any `iex -S mix` session you may have running, as currently tests and development environment are running on the same port (4040). We will address it in the next chapter.
+
+We added three tests, the first one tests most bucket actions, while the other two deal with error cases. Given there is a lot of shared setup across these tests, we used the `setup/2` macro to deal with common boilerplate. The macro receives the same *test context* as tests and starts a client TCP connection per test. It also defines a unique bucket name using the module name and the test name, making sure any space in the test name is replaced by `-` as to not interfere with our command parsing logic.
+
+Then, in each test, we pattern matched on the *test context*, extracting the socket or name as necessary. This is similar to the code we wrote in `test/kv/bucket_test.exs`:
+
+```elixir
+  test "stores values by key on a named process", config do
+```
+
+Except back then we matched on all config and, this time around, we matched only on the data we needed.
+
+Let's move to the next chapter. We will finally make our system distributed by adding a tiny bit of configuration and, *spoiler alert*, changing one line of code.
diff --git a/lib/elixir/pages/mix-and-otp/dynamic-supervisor.md b/lib/elixir/pages/mix-and-otp/dynamic-supervisor.md
new file mode 100644
index 00000000000..d3475fcf84c
--- /dev/null
+++ b/lib/elixir/pages/mix-and-otp/dynamic-supervisor.md
@@ -0,0 +1,233 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Supervising dynamic children
+
+We have successfully learned how our supervision tree is automatically started (and stopped) as part of our application's life cycle. We can also name our buckets via the `:name` option. We also learned that, in practice, we should always start new processes inside supervisors. Let's apply these insights by ensuring our buckets are named and supervised.
+
+## Child specs
+
+Supervisors know how to start processes because they are given "child specifications". In our `lib/kv.ex` file, we defined a list of children with a single child spec:
+
+```elixir
+children = [
+  {Registry, name: KV, keys: :unique}
+]
+```
+
+When the child specification is a tuple (as above) or module, then it is equivalent to calling the `child_spec/1` function on said module, which then returns the full specification. The pair above is equivalent to:
+
+```elixir
+iex> Registry.child_spec(name: KV, keys: :unique)
+%{
+  id: KV,
+  start: {Registry, :start_link, [[name: KV, keys: :unique]]},
+  type: :supervisor
+}
+```
+
+The underlying map returns the `:id` (required), the module-function-args triplet to invoke to start the process (required), the type of the process (optional), among other optional keys. In other words, the `child_spec/1` function allows us to compose and encapsulate specifications in modules.
+
+Therefore, if we want to supervise `KV.Bucket`, we only need to define a `child_spec/1` function. Luckily for us, whenever we invoke `use Agent` (or `use GenServer` or `use Supervisor` and so forth), an implementation with reasonable defaults is provided. So let's take it for a spin. Back on `iex -S mix`, try this:
+
+```elixir
+iex> KV.Bucket.child_spec([])
+%{id: KV.Bucket, start: {KV.Bucket, :start_link, [[]]}}
+iex> KV.Bucket.child_spec([name: :shopping])
+%{id: KV.Bucket, start: {KV.Bucket, :start_link, [[name: :shopping]]}}
+```
+
+Let's try to start it as part of a supervisor then, using the `{module, options}` format to pass the bucket name (let's also use an atom as the name for convenience):
+
+```elixir
+iex> children = [{KV.Bucket, name: :shopping}]
+iex> Supervisor.start_link(children, strategy: :one_for_one)
+iex> KV.Bucket.put(:shopping, "milk", 1)
+:ok
+iex> KV.Bucket.get(:shopping, "milk")
+1
+```
+
+What happens now if we explicitly kill the bucket process?
+
+```elixir
+# Find the pid for the given name
+iex> pid = Process.whereis(:shopping)
+#PID<0.48.0>
+# Send it a kill exit signal
+iex> Process.exit(pid, :kill)
+true
+# But a new process is alive in its place
+iex> Process.whereis(:shopping)
+#PID<0.50.0>
+```
+
+Given our buckets can already be supervised, it is time to hook them into our supervision tree.
+
+## Dynamic supervisors
+
+Given our buckets can already be supervised, you may be thinking to start them as part of our application `start/2` callback, such as:
+
+```elixir
+children = [
+  {Registry, name: KV, keys: :unique}
+  {KV.Bucket, name: {:via, Registry, {KV, "shopping"}}}
+]
+```
+
+And while the above would definitely work, it comes with a huge caveat: it only starts a single bucket. In practice, we want the user to be able to create new buckets at any time. In other words, we need to start and supervise processes dynamically.
+
+While the `Supervisor` module has APIs for starting children after its initialization, it was not designed or optimized for the use case of having potentially millions of children. For this purpose, Elixir instead provides the `DynamicSupervisor` module. Using it is quite similar to `Supervisor` except that, instead of specifying the children during start, you do it afterwards. Let's take it for a spin:
+
+```elixir
+iex> {:ok, sup_pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+iex> DynamicSupervisor.start_child(sup_pid, {KV.Bucket, name: :another_list})
+iex> KV.Bucket.put(:another_list, "milk", 1)
+:ok
+iex> KV.Bucket.get(:another_list, "milk")
+1
+```
+
+And it all works as expected. In fact, we can even give names to `DynamicSupervisor` themselves, instead of passing PIDs around and also use it to start buckets named using the registry:
+
+```elixir
+iex> DynamicSupervisor.start_link(strategy: :one_for_one, name: :dyn_sup)
+iex> name = {:via, Registry, {KV, "yet_another_list"}}
+iex> DynamicSupervisor.start_child(:dyn_sup, {KV.Bucket, name: name})
+iex> KV.Bucket.put(name, "milk", 1)
+:ok
+iex> KV.Bucket.get(name, "milk")
+1
+```
+
+Overall, processes can be named and supervised, regardless if they are supervisors, agents, etc, since all of Elixir standard library was designed around those capabilities.
+
+With all ingredients in place to supervise and name buckets, open up the `lib/kv.ex` module and let's add a new function called `KV.lookup_bucket/1`, which receives a name and either create or returns a bucket for the given name:
+
+```elixir
+defmodule KV do
+  use Application
+
+  @impl true
+  def start(_type, _args) do
+    children = [
+      {Registry, name: KV, keys: :unique},
+      {DynamicSupervisor, name: KV.BucketSupervisor, strategy: :one_for_one}
+    ]
+
+    Supervisor.start_link(children, strategy: :one_for_one)
+  end
+
+  @doc """
+  Creates a bucket with the given name.
+  """
+  def create_bucket(name) do
+    DynamicSupervisor.start_child(KV.BucketSupervisor, {KV.Bucket, name: via(name)})
+  end
+
+  @doc """
+  Looks up the given bucket.
+  """
+  def lookup_bucket(name) do
+    GenServer.whereis(via(name))
+  end
+
+  defp via(name), do: {:via, Registry, {KV, name}}
+end
+```
+
+The code is relatively simple. First we changed `start/2` to also start a dynamic supervisor named `KV.BucketSupervisor`. Then, when implemented `KV.create_bucket/1` which receives a bucket and starts with using our registry and dynamic supervisor. And we also added `KV.lookup_bucket/1` that receives the same name and attempts to find its PID.
+
+To make sure it all works as expected, let's write a test. Open up `test/kv_test.exs` and add this:
+
+```elixir
+defmodule KVTest do
+  use ExUnit.Case, async: true
+
+  test "creates and looks up buckets by any name" do
+    name = "a unique name that won't be shared"
+    assert is_nil(KV.lookup_bucket(name))
+
+    assert {:ok, bucket} = KV.create_bucket(name)
+    assert KV.lookup_bucket(name) == bucket
+
+    assert KV.create_bucket(name) == {:error, {:already_started, bucket}}
+  end
+end
+```
+
+The test shows we are creating and locating buckets with any name, making sure we use a unique name to avoid conflicts between tests.
+
+## The `start_supervised` test helper
+
+Before we move on, let's do some clean up.
+
+In `test/kv/bucket_test.exs`, we explicitly invoked `KV.Bucket.start_link/1` to start our buckets. However, we now know that we should avoid calling `start_link/1` directly and instead start processes as part of supervision trees.
+
+In order to aid testing, `ExUnit` already starts a supervision tree per test and provides the `start_supervised` function to start processes within test-specific supervision tree. One advantage of this approach is that `ExUnit` guarantees any started process is shut down at the end of the test too. Let's rewrite our tests to use it instead:
+
+```elixir
+defmodule KV.BucketTest do
+  use ExUnit.Case, async: true
+
+  test "stores values by key" do
+    {:ok, bucket} = start_supervised(KV.Bucket)
+    assert KV.Bucket.get(bucket, "milk") == nil
+
+    KV.Bucket.put(bucket, "milk", 3)
+    assert KV.Bucket.get(bucket, "milk") == 3
+  end
+
+  test "stores values by key on a named process", config do
+    {:ok, _} = start_supervised({KV.Bucket, name: config.test})
+    assert KV.Bucket.get(config.test, "milk") == nil
+
+    KV.Bucket.put(config.test, "milk", 3)
+    assert KV.Bucket.get(config.test, "milk") == 3
+  end
+end
+```
+
+It is a small change, but our tests are now using all of the relevant best practices. Excellent!
+
+## Observer
+
+Now that we have defined our supervision tree, it is a great opportunity to introduce the Observer tool that ships with Erlang. Start your application with `iex -S mix` and key this in:
+
+```elixir
+iex> :observer.start()
+```
+
+> #### Missing dependencies {: .warning}
+>
+> When running `iex` inside a project with `iex -S mix`, `observer` won't be available as a dependency. To do so, you will need to call the following functions:
+>
+> ```elixir
+> iex> Mix.ensure_application!(:observer)
+> iex> :observer.start()
+> ```
+>
+> If the call above fails, here is what may have happened: some package managers default to installing a minimized Erlang without WX bindings for GUI support. In some package managers, you may be able to replace the headless Erlang with a more complete package (look for packages named `erlang` vs `erlang-nox` on Debian/Ubuntu/Arch). In others managers, you may need to install a separate `erlang-wx` (or similarly named) package.
+>
+> There are conversations to improve this experience in future releases.
+
+A GUI should pop up containing all sorts of information about our system, from general statistics to load charts as well as a list of all running processes and applications.
+
+In the Applications tab, you will see all applications currently running in your system alongside their supervision tree. You can select the `kv` application to explore it further:
+
+<img src="assets/kv-observer.png" alt="Observer GUI screenshot" />
+
+Not only that, as you create new buckets on the terminal, you should see new processes spawned in the supervision tree shown in Observer:
+
+```elixir
+iex> KV.create_bucket("shopping")
+#PID<0.89.0>
+```
+
+We will leave it up to you to further explore what Observer provides. Note you can double-click any process in the supervision tree to retrieve more information about it, as well as right-click a process to send "a kill signal", a perfect way to emulate failures and see if your supervisor reacts as expected.
+
+At the end of the day, tools like Observer are one of the reasons you want to always start processes inside supervision trees, even if they are temporary, to ensure they are always reachable and introspectable.
+
+Now that our buckets are named and supervised, we are ready to start our server and start receiving requests.
diff --git a/lib/elixir/pages/mix-and-otp/genservers.md b/lib/elixir/pages/mix-and-otp/genservers.md
new file mode 100644
index 00000000000..30fcf2a7ce7
--- /dev/null
+++ b/lib/elixir/pages/mix-and-otp/genservers.md
@@ -0,0 +1,383 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Client-server with GenServer
+
+To wrap up our distributed key-value store, we will implement a feature where a client can subscribe to a bucket and receive realtime notifications of any modification happening in the bucket, regardless of where in the cluster the bucket is located.
+
+We will do by adding a new command, called SUBSCRIBE, to be used like this:
+
+```text
+SUBSCRIBE shopping
+milk SET TO 1
+eggs SET TO 10
+milk DELETED
+```
+
+To make this work, we must change our `KV.Bucket` implementation to track subscriptions and emit broadcasts. However, as we will see, we cannot implement such on top of agents, and we will need to rewrite our bucket implementation to a `GenServer`.
+
+## Links and monitors
+
+Processes in Elixir are isolated. When they need to communicate, they do so by sending messages. However, how do you know when a process terminates, either because it has completed or due to a crash?
+
+We have two options: links and monitors.
+
+We have used links extensively. Whenever we started a process, we typically did so by using `start_link` or similar. The idea behind links is that, if any of the processes crash, the other will crash due to the link. We talked about them in the [Process chapter of the Getting Started guide](../getting-started/processes.md). Here is a refresher:
+
+```elixir
+iex> self()
+#PID<0.115.0>
+iex> spawn_link(fn -> :nothing_bad_will_happen end)
+#PID<0.116.0>
+iex> self()
+#PID<0.115.0>
+```
+
+```elixir
+iex> spawn_link(fn -> raise "oops" end)
+#PID<0.117.0>
+
+12:37:33.229 [error] Process #PID<0.117.0> raised an exception
+Interactive Elixir (1.18.4) - press Ctrl+C to exit (type h() ENTER for help)
+iex> self()
+#PID<0.118.0>
+```
+
+The reason why we links are so pervasive is because when we start a process inside a supervisor, we want our process to crash if the supervisor terminates. On the other hand, we don't want the supervisor to crash when a child terminates, and therefore supervisors trap exits from links by calling `Process.flag(:trap_exit, true)`.
+
+In other words, links create an intrinsic relationship between the processes. If we simply want to track when a process dies, without tying their exit signals to each other, a better solution is to use monitors. When a monitored process terminates, we receive a message in our inbox, regardless of the reason:
+
+```elixir
+iex> pid = spawn(fn -> Process.sleep(5000) end)
+#PID<0.119.0>
+iex> Process.monitor(pid)
+#Reference<0.1076459149.2159017989.118674>
+iex> flush()
+:ok
+# Wait five seconds
+iex> flush()
+{:DOWN, #Reference<0.1076459149.2159017989.118674>, :process, #PID<0.119.0>, :normal}
+:ok
+```
+
+Once the process terminates, we receive a "DOWN message", represented in a five-element tuple. The last element is the reason why it crashed (`:normal` means it terminated successfully).
+
+Monitors will play a very important role in our subscribe feature. When a client subscribes to a bucket, the bucket will store the client PID and send messages to it on every change. However, if the client terminates (for example because it was disconnected), the bucket must remove the client from its list of subscribers (otherwise the list would keep on growing forever as clients connect and disconnect).
+
+We chose the `Agent` module to implement our `KV.Bucket` and, unfortunately, agents cannot receive messages. So the first step is to rewrite our `KV.Bucket` to a `GenServer`. The `GenServer` module documentation has a good overview on what they are and how to implement them. Give it a read and then we are ready to proceed.
+
+## GenServer callbacks
+
+A GenServer is a process that invokes a limited set of functions under specific conditions. When we used an `Agent`, we would keep both the client code and the server code side by side, like this:
+
+```elixir
+def put(bucket, key, value) do
+  Agent.update(bucket, &Map.put(&1, key, value))
+end
+```
+
+Let's break that code apart a bit:
+
+```elixir
+def put(bucket, key, value) do
+  # Here is the client code
+  Agent.update(bucket, fn state ->
+    # Here is the server code
+    Map.put(state, key, value)
+  end)
+  # Back to the client code
+end
+```
+
+In the code above, we have a process, which we call "the client" sending a request to an agent, "the server". The request contains an anonymous function, which must be executed by the server.
+
+In a GenServer, the code above would be two separate functions, roughly like this:
+
+```elixir
+def put(bucket, key, value) do
+  # Send the server a :put "instruction"
+  GenServer.call(bucket, {:put, key, value})
+end
+
+# Server callback
+
+def handle_call({:put, key, value}, _from, state) do
+  {:reply, :ok, Map.put(state, key, value)}
+end
+```
+
+Let's go ahead and rewrite `KV.Bucket` at once. Open up `lib/kv/bucket.ex` and replace its contents with this new version:
+
+```elixir
+defmodule KV.Bucket do
+  use GenServer
+
+  @doc """
+  Starts a new bucket.
+  """
+  def start_link(opts) do
+    GenServer.start_link(__MODULE__, %{}, opts)
+  end
+
+  @doc """
+  Gets a value from the `bucket` by `key`.
+  """
+  def get(bucket, key) do
+    GenServer.call(bucket, {:get, key})
+  end
+
+  @doc """
+  Puts the `value` for the given `key` in the `bucket`.
+  """
+  def put(bucket, key, value) do
+    GenServer.call(bucket, {:put, key, value})
+  end
+
+  @doc """
+  Deletes `key` from `bucket`.
+
+  Returns the current value of `key`, if `key` exists.
+  """
+  def delete(bucket, key) do
+    GenServer.call(bucket, {:delete, key})
+  end
+
+  ### Callbacks
+
+  @impl true
+  def init(bucket) do
+    state = %{
+      bucket: bucket
+    }
+
+    {:ok, state}
+  end
+
+  @impl true
+  def handle_call({:get, key}, _from, state) do
+    value = get_in(state.bucket[key])
+    {:reply, value, state}
+  end
+
+  def handle_call({:put, key, value}, _from, state) do
+    state = put_in(state.bucket[key], value)
+    {:reply, :ok, state}
+  end
+
+  def handle_call({:delete, key}, _from, state) do
+    {value, state} = pop_in(state.bucket[key])
+    {:reply, value, state}
+  end
+end
+```
+
+The first function is `start_link/1`, which starts a new GenServer passing a list of options. `GenServer.start_link/3`, which takes three arguments:
+
+1. The module where the server callbacks are implemented, in this case `__MODULE__` (meaning the current module)
+
+2. The initialization arguments, in this case the empty bucket `%{}`
+
+3. A list of options which can be used to specify things like the name of the server. Once again, we forward the list of options that we receive on `start_link/1` to `GenServer.start_link/3`, as we did for agents
+
+Once started, the GenServer will invoke the `init/1` callback, that receives the second argument given to `GenServer.start_link/3` and returns `{:ok, state}`, where state is a new map. We can already notice how the `GenServer` API makes the client/server segregation more apparent. `start_link/3` happens in the client, while `init/1` is the respective callback that runs on the server.
+
+There are two types of requests you can send to a GenServer: calls and casts. Calls are synchronous and the server **must** send a response back to such requests. While the server computes the response, the client is **waiting**. Casts are asynchronous: the server won't send a response back and therefore the client won't wait for one. Both requests are messages sent to the server, and will be handled in sequence. So far we have only used `GenServer.call/2`, to keep the same semantics as the Agent, but we will give `cast` a try when implementing subscriptions. Given we kept the same behaviour, all tests will still pass.
+
+Each request must be implemented as a specific callback. For `call/2` requests, we implement a `handle_call/3` callback that receives the `request`, the process from which we received the request (`_from`), and the current server state (`state`). The `handle_call/3` callback returns a tuple in the format `{:reply, reply, updated_state}`. The first element of the tuple, `:reply`, indicates that the server should send a reply back to the client. The second element, `reply`, is what will be sent to the client while the third, `updated_state` is the new server state.
+
+Another Elixir feature we used in the implementation above are the nested traversal functions: `get_in/1`, `put_in/2`, and `pop_in/1`. Instead of keeping the `bucket` as our GenServer state, we defined a state map with a `bucket` key inside. This will be important as we also need to track subscribers as part of the GenServer state. These new functions make it straight-forward to manipulate data structures nested in other data structures.
+
+With our GenServer in place, let's work on subscription, starting with the tests.
+
+## Implementing subscriptions
+
+Our new test will subscribe to a bucket and then assert that, as operations are performed against the bucket, we receive messages of said events.
+
+Open up `test/kv/bucket_test.exs` and key this in:
+
+```elixir
+  test "subscribes to puts and deletes" do
+    {:ok, bucket} = start_supervised(KV.Bucket)
+    KV.Bucket.subscribe(bucket)
+
+    KV.Bucket.put(bucket, "milk", 3)
+    assert_receive {:put, "milk", 3}
+
+    # Also check it works even from another process
+    spawn(fn -> KV.Bucket.delete(bucket, "milk") end)
+    assert_receive {:delete, "milk"}
+  end
+```
+
+In order to make the test pass, we need to implement the `KV.Bucket.subscribe/1`. So let's add these three new functions to `KV.Bucket`:
+
+```elixir
+  @doc """
+  Subscribes the current process to the bucket.
+  """
+  def subscribe(bucket) do
+    GenServer.cast(bucket, {:subscribe, self()})
+  end
+
+  @impl true
+  def handle_cast({:subscribe, pid}, state) do
+    Process.monitor(pid)
+    state = update_in(state.subscribers, &MapSet.put(&1, pid))
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_info({:DOWN, _ref, _type, pid, _reason}, state) do
+    state = update_in(state.subscribers, &MapSet.delete(&1, pid))
+    {:noreply, state}
+  end
+```
+
+On subscription, we send a `cast/2` request with the current process identifier and implement its `handle_cast/2` callback that receives the `request` and the current server state. We then proceed to monitor the given `pid` and add it to the list of subscribers, which we are implementing using `MapSet`. The `handle_cast/2` callback returns a tuple in the format `{:noreply, updated_state}`. Note that in a real application we would have probably implemented it with a synchronous call, as it provides back pressure, instead of an asynchronous cast. We are doing it this way to illustrate how to implement a cast callback.
+
+Then, because we have monitored a process, once that process terminates, we will receive a "DOWN message". GenServers handle regular messages using the `handle_info/2` callback, which also typically return `{:noreply, updated_state}`. In this callback, we remove the PID that terminated from our list of subscribers.
+
+We are almost there. We can see both `handle_cast/2` and `handle_info/2` callbacks assume there is a subscribers key in our state with a `MapSet`. So let's add it by updating the existing `init/1` to the following:
+
+```elixir
+  @impl true
+  def init(bucket) do
+    state = %{
+      bucket: bucket,
+      subscribers: MapSet.new()
+    }
+
+    {:ok, state}
+  end
+```
+
+And finally let's update the callbacks for `put/3` and `delete/2` to broadcast messages whenever they are invoked, like this:
+
+```elixir
+  def handle_call({:put, key, value}, _from, state) do
+    state = put_in(state.bucket[key], value)
+    broadcast(state, {:put, key, value})
+    {:reply, :ok, state}
+  end
+
+  def handle_call({:delete, key}, _from, state) do
+    {value, state} = pop_in(state.bucket[key])
+    broadcast(state, {:delete, key})
+    {:reply, value, state}
+  end
+
+  defp broadcast(state, message) do
+    for pid <- state.subscribers do
+      send(pid, message)
+    end
+  end
+```
+
+There is no need to modify the callback for `get/2`. And that's it, run the tests again, and our new test should pass!
+
+## Wiring it all up
+
+Now that our bucket deals with subscriptions, we need to expose this new functionality in our server. Let's once again start with the test.
+
+Open up `test/kv/server_test.exs` and add this new test:
+
+```elixir
+  test "subscribes to buckets", %{socket: socket, name: name} do
+    assert send_and_recv(socket, "CREATE #{name}\r\n") == "OK\r\n"
+    :gen_tcp.send(socket, "SUBSCRIBE #{name}\r\n")
+
+    {:ok, other} = :gen_tcp.connect(~c"localhost", 4040, @socket_options)
+
+    assert send_and_recv(other, "PUT #{name} milk 3\r\n") == "OK\r\n"
+    assert :gen_tcp.recv(socket, 0, 1000) == {:ok, "milk SET TO 3\r\n"}
+
+    assert send_and_recv(other, "DELETE #{name} milk\r\n") == "OK\r\n"
+    assert :gen_tcp.recv(socket, 0, 1000) == {:ok, "milk DELETED\r\n"}
+  end
+```
+
+The test creates a bucket and subscribes to it. Then it opens up another TCP connection to send commands. For each command sent, we expect the subscribed socket to receive a message.
+
+To make the test pass, we need to change `KV.Command` to parse the new `SUBSCRIBE` command and then run it. Open up `lib/kv/commands.ex` and then first change the `parse/1` definition to the following:
+
+```elixir
+  def parse(line) do
+    case String.split(line) do
+      ["SUBSCRIBE", bucket] -> {:ok, {:subscribe, bucket}}
+      ["CREATE", bucket] -> {:ok, {:create, bucket}}
+      ["GET", bucket, key] -> {:ok, {:get, bucket, key}}
+      ["PUT", bucket, key, value] -> {:ok, {:put, bucket, key, value}}
+      ["DELETE", bucket, key] -> {:ok, {:delete, bucket, key}}
+      _ -> {:error, :unknown_command}
+    end
+  end
+```
+
+We added a new clause that converts "SUBSCRIBE" into a tuple. Now we need to match on this tuple within `run/1`. We can do so by adding a new clause at the bottom of `run/1`, with the following code:
+
+```elixir
+  def run({:subscribe, bucket}, socket) do
+    lookup(bucket, fn pid ->
+      KV.Bucket.subscribe(pid)
+      :inet.setopts(socket, active: true)
+      receive_messages(socket)
+    end)
+  end
+
+  defp receive_messages(socket) do
+    receive do
+      {:put, key, value} ->
+        :gen_tcp.send(socket, "#{key} SET TO #{value}\r\n")
+        receive_messages(socket)
+
+      {:delete, key} ->
+        :gen_tcp.send(socket, "#{key} DELETED\r\n")
+        receive_messages(socket)
+
+      {:tcp_closed, ^socket} ->
+        {:error, :closed}
+
+      # If we receive any message, including socket writes, we discard them
+      _ ->
+        receive_messages(socket)
+    end
+  end
+```
+
+Let's go over it by parts. We use the existing `lookup/2` private function to lookup for a bucket. If one is found, we subscribe the current process to the bucket. Then we call `:inet.setopts(socket, active: true)` (which we will explain soon) and `receive_messages/1`.
+
+`receive_messages/1` awaits for messages from the bucket and then calls itself again, becoming a loop. We match on `{:put, key, value}` and `{:delete, key}` and write to those events to the socket. We also match on `{:tcp_closed, ^socket}`, which is a message that will be delivered if the TCP socket closes, and use it to abort the loop. We discard any other message.
+
+At this point you may be wondering: where does `{:tcp_closed, ^socket}` come from?
+
+So far, when receiving messages from the socket, we used `:gen_tcp.recv/3` to perform calls that will block the current process until content is available. This is known as "passive mode". However, we can also ask `:gen_tcp` to stream messages to the current process inbox as they arrive, which is known as "active mode", which is exactly what we configured when we called `:inet.setopts(socket, active: true)`. Those messages have the shape `{:tcp, socket, data}`. When the socket is in active mode and it is closed, it delivers a `{:tcp_closed, socket}` message. Once we receive this message, we exit the loop, which will exit the connection process. Since the bucket is monitoring the process, it will automatically remove the subscription too. You could verify this in practice by adding a `COUNT SUBSCRIPTIONS` command that returns the number of subscribers for a given bucket.
+
+In practice, many systems would prefer to call `:inet.setopts(socket, active: :once)` to specify only a single TCP message should be delivered to avoid overflowing message queues. Once the message is received, they call `:inet.setopts/2` again. In our case, we are simply discarding anything that arrives over the socket, so setting `active: true` is equally fine. In all scenarios, the benefit of using active mode is that the process can receive TCP messages as well as messages from other processes at the same time, instead of blocking on `:gen_tcp.recv/3`.
+
+To wrap it all up, you should give our new feature a try in a distributed setting too. Start two `NODES=... PORT=... iex --sname ... -S mix` instances. In one of them, create a bucket. In the other, subscribe to the same bucket. Once you go back to the first shell, you will see that, even as you send commands to the bucket in one machine, the messages will be streamed to the other one. In other words, our subscription system is also distributed, and all we had to do is to send messages!
+
+## `call`, `cast` or `info`?
+
+So far we have used three callbacks: `handle_call/3`, `handle_cast/2` and `handle_info/2`. Here is what we should consider when deciding when to use each:
+
+1. `handle_call/3` must be used for synchronous requests. This should be the default choice as waiting for the server reply is a useful back-pressure mechanism.
+
+2. `handle_cast/2` must be used for asynchronous requests, when you don't care about a reply. A cast does not guarantee the server has received the message and, for this reason, should be used sparingly. For example, the `subscribe/1` function we have defined in this chapter should have used `call/2`. We have used `cast/2` for educational purposes.
+
+3. `handle_info/2` must be used for all other messages a server may receive that are not sent via `GenServer.call/2` or `GenServer.cast/2`, including regular messages sent with `send/2`. The monitoring `:DOWN` messages are an example of this.
+
+To help developers remember the differences between call, cast and info, the supported return values and more, we have a tiny [GenServer cheat sheet](https://elixir-lang.org/downloads/cheatsheets/gen-server.pdf).
+
+## Agents or GenServers?
+
+Before moving forward to the last chapter, you may be wondering: in the future, should you use an `Agent` or a `GenServer`?
+
+As we saw throughout this guide, agents are straight-forward to get started but they are limited in what they can do. Agents are effectively a subset of GenServers. In fact, agents are implemented on top of GenServers. As well as supervisors, the `Registry` module, and many other features you will find in both Erlang and Elixir.
+
+In other words, GenServers are the most essential component for building concurrent and fault-tolerant systems in Elixir. They provide a robust and flexible framework for managing state and coordinating interactions between processes.
+
+For those reasons, many adopt a rule of thumb to never use Agents and jump straight into GenServers instead. On the other hand, others are more than fine with using agents to store a bit of state here and there. Either way, you will be fine!
+
+This is the last feature we have implemented for our distributed key-value store. In the next chapter, we will learn how to package our application before shipping it to production.
diff --git a/lib/elixir/pages/mix-and-otp/introduction-to-mix.md b/lib/elixir/pages/mix-and-otp/introduction-to-mix.md
new file mode 100644
index 00000000000..80b2bdd2688
--- /dev/null
+++ b/lib/elixir/pages/mix-and-otp/introduction-to-mix.md
@@ -0,0 +1,329 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Introduction to Mix
+
+In this guide, we will build a complete Elixir application, with its own supervision tree, configuration, tests, and more.
+
+The requirements for this guide are (see `elixir -v`):
+
+  * Elixir 1.18.0 onwards
+  * Erlang/OTP 27 onwards
+
+The application works as a distributed key-value store. We are going to organize key-value pairs into buckets and distribute those buckets across multiple nodes. We will also build a simple client that allows us to connect to any of those nodes and send requests such as:
+
+```text
+CREATE shopping
+OK
+
+PUT shopping milk 1
+OK
+
+PUT shopping eggs 3
+OK
+
+GET shopping milk
+1
+OK
+
+DELETE shopping eggs
+OK
+```
+
+In order to build our key-value application, we are going to use three main tools:
+
+  * ***OTP*** *(Open Telecom Platform)* is a set of libraries that ships with Erlang. Erlang developers use OTP to build robust, fault-tolerant applications. In this chapter we will explore how many aspects from OTP integrate with Elixir, including supervision trees, event managers and more;
+
+  * ***[Mix](`Mix`)*** is a build tool that ships with Elixir that provides tasks for creating, compiling, testing your application, managing its dependencies and much more;
+
+  * ***[ExUnit](`ExUnit`)*** is a unit-test based framework that ships with Elixir.
+
+In this chapter, we will create our first project using Mix and explore different features in OTP, Mix, and ExUnit as we go.
+
+> #### Source code {: .info}
+>
+> The final code for the application built in this guide is in [this repository](https://github.com/josevalim/kv) and can be used as a reference.
+
+> #### Is this guide required reading? {: .info}
+>
+> This guide is not required reading in your Elixir journey. We'll explain.
+>
+> As an Elixir developer, you will most likely use one of the many existing frameworks when writing your Elixir code. [Phoenix](https://phoenixframework.org) covers web applications, [Ecto](https://github.com/elixir-ecto/ecto) communicates with databases, you can craft embedded software with [Nerves](https://nerves-project.org/), [Nx](https://github.com/elixir-nx) powers machine learning and AI projects, [Membrane](https://membrane.stream/) assembles audio/video processing pipelines, [Broadway](https://elixir-broadway.org/) handles data ingestion and processing, and many more. These frameworks handle the lower level details of concurrency, distribution, and fault-tolerance, so you, as a user, can focus on your own needs and demands.
+>
+> On the other hand, if you want to learn the foundations these frameworks are built upon, and the abstractions that power the Elixir ecosystem, this guide will give you a tour through several important concepts.
+
+## Our first project
+
+When you install Elixir, besides getting the `elixir`, `elixirc`, and `iex` executables, you also get an executable Elixir script named `mix`.
+
+Let's create our first project by invoking `mix new` from the command line. We'll pass the project path as the argument (`kv`, in this case). By default, the application name and module name will be retrieved from the path. So we tell Mix that our main module should be the all-uppercase `KV`, instead of the default, which would have been `Kv`:
+
+```console
+$ mix new kv --module KV
+```
+
+Mix will create a directory named `kv` with a few files in it:
+
+```text
+* creating README.md
+* creating .formatter.exs
+* creating .gitignore
+* creating mix.exs
+* creating lib
+* creating lib/kv.ex
+* creating test
+* creating test/test_helper.exs
+* creating test/kv_test.exs
+```
+
+Let's take a brief look at those generated files.
+
+> #### Executables in the `PATH` {: .info}
+>
+> Mix is an Elixir executable. This means that in order to run `mix`, you need to have both `mix` and `elixir` executables in your [`PATH`](https://en.wikipedia.org/wiki/PATH_(variable)). That's what happens when you install Elixir.
+
+## Project compilation
+
+A file named `mix.exs` was generated inside our new project folder (`kv`) and its main responsibility is to configure our project. Let's take a look at it:
+
+```elixir
+defmodule KV.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :kv,
+      version: "0.1.0",
+      elixir: "~> 1.11",
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  # Run "mix help compile.app" to learn about applications
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
+  end
+
+  # Run "mix help deps" to learn about dependencies
+  defp deps do
+    [
+      # {:dep_from_hexpm, "~> 0.3.0"},
+      # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"},
+    ]
+  end
+end
+```
+
+Our `mix.exs` defines two public functions: `project`, which returns project configuration like the project name and version, and `application`, which is used to generate an application file.
+
+There is also a private function named `deps`, which is invoked from the `project` function, that defines our project dependencies. Defining `deps` as a separate function is not required, but it helps keep the project configuration tidy.
+
+Mix also generates a file at `lib/kv.ex` with a module containing exactly one function, called `hello`:
+
+```elixir
+defmodule KV do
+  @moduledoc """
+  Documentation for KV.
+  """
+
+  @doc """
+  Hello world.
+
+  ## Examples
+
+      iex> KV.hello()
+      :world
+
+  """
+  def hello do
+    :world
+  end
+end
+
+```
+
+This structure is enough to compile our project:
+
+```console
+$ cd kv
+$ mix compile
+```
+
+Will output:
+
+```text
+Compiling 1 file (.ex)
+Generated kv app
+```
+
+The `lib/kv.ex` file was compiled and an application manifest named `kv.app` was generated. All compilation artifacts are placed inside the `_build` directory using the options defined in the `mix.exs` file.
+
+Once the project is compiled, you can start a `iex` session inside the project by running the command below. The `-S mix` is necessary to load the project in the interactive shell:
+
+```console
+$ iex -S mix
+```
+
+We are going to work on this `kv` project, making modifications and trying out the latest changes from a `iex` session. While you may start a new session whenever there are changes to the project source code, you can also recompile the project from within `iex` with the `recompile` helper, like this:
+
+```elixir
+iex> recompile()
+Compiling 1 file (.ex)
+:ok
+iex> recompile()
+:noop
+```
+
+If anything had to be compiled, you see some informative text, and get the `:ok` atom back, otherwise the function is silent, and returns `:noop`.
+
+## Running tests
+
+Mix also generated the appropriate structure for running our project tests. Mix projects usually follow the convention of having a `<filename>_test.exs` file in the `test` directory for each file in the `lib` directory. For this reason, we can already find a `test/kv_test.exs` corresponding to our `lib/kv.ex` file. It doesn't do much at this point:
+
+```elixir
+defmodule KVTest do
+  use ExUnit.Case
+  doctest KV
+
+  test "greets the world" do
+    assert KV.hello() == :world
+  end
+end
+```
+
+It is important to note a couple of things:
+
+1. the test file is an Elixir script file (`.exs`). This is convenient because we don't need to compile test files before running them;
+
+2. we define a test module named `KVTest`, in which we [`use ExUnit.Case`](`ExUnit.Case`) to inject the testing API;
+
+3. we use one of the imported macros, `ExUnit.DocTest.doctest/1`, to indicate that the `KV` module contains doctests (we will discuss those in a later chapter);
+
+4. we use the `ExUnit.Case.test/2` macro to define a simple test;
+
+Mix also generated a file named `test/test_helper.exs` which is responsible for setting up the test framework:
+
+```elixir
+ExUnit.start()
+```
+
+This file will be required by Mix every time before we run our tests. We can run tests with:
+
+```console
+$ mix test
+Compiled lib/kv.ex
+Generated kv app
+Running ExUnit with seed: 540224, max_cases: 16
+..
+
+Finished in 0.04 seconds
+1 doctest, 1 test, 0 failures
+```
+
+Notice that by running `mix test`, Mix has compiled the source files and generated the application manifest once again. This happens because Mix supports multiple environments, which we will discuss later in this chapter.
+
+Furthermore, you can see that ExUnit prints a dot for each successful test and automatically randomizes tests too. Let's make the test fail on purpose and see what happens.
+
+Change the assertion in `test/kv_test.exs` to the following:
+
+```elixir
+assert KV.hello() == :oops
+```
+
+Now run `mix test` again (notice this time there will be no compilation):
+
+```text
+  1) test greets the world (KVTest)
+     test/kv_test.exs:5
+     Assertion with == failed
+     code:  assert KV.hello() == :oops
+     left:  :world
+     right: :oops
+     stacktrace:
+       test/kv_test.exs:6: (test)
+
+.
+
+Finished in 0.05 seconds
+1 doctest, 1 test, 1 failure
+```
+
+For each failure, ExUnit prints a detailed report, containing the test name with the test case, the code that failed and the values for the left side and right side (RHS) of the `==` operator.
+
+In the second line of the failure, right below the test name, there is the location where the test was defined. If you copy the test location in full, including the file and line number, and append it to `mix test`, Mix will load and run just that particular test:
+
+```console
+$ mix test test/kv_test.exs:5
+```
+
+This shortcut will be extremely useful as we build our project, allowing us to quickly iterate by running a single test.
+
+Finally, the stacktrace relates to the failure itself, giving information about the test and often the place the failure was generated from within the source files.
+
+## Automatic code formatting
+
+One of the files generated by `mix new` is the `.formatter.exs`. Elixir ships with a code formatter that is capable of automatically formatting our codebase according to a consistent style. The formatter is triggered with the `mix format` task. The generated `.formatter.exs` file configures which files should be formatted when `mix format` runs.
+
+To give the formatter a try, change a file in the `lib` or `test` directories to include extra spaces or extra newlines, such as `def  hello  do`, and then run `mix format`.
+
+Most editors provide built-in integration with the formatter, allowing a file to be formatted on save or via a chosen keybinding. If you are learning Elixir, editor integration gives you useful and quick feedback when learning the Elixir syntax.
+
+For companies and teams, we recommend developers to run `mix format --check-formatted` on their continuous integration servers, ensuring all current and future code follows the standard.
+
+You can learn more about the code formatter by checking [the format task documentation](`mix format`) or by reading [the release announcement for Elixir v1.6](https://elixir-lang.org/blog/2018/01/17/elixir-v1-6-0-released/), the first version to include the formatter.
+
+## Environments
+
+Mix provides the concept of "environments". They allow a developer to customize compilation and other options for specific scenarios. By default, Mix understands three environments:
+
+  * `:dev` — the one in which Mix tasks (like `compile`) run by default
+  * `:test` — used by `mix test`
+  * `:prod` — the one you will use to run your project in production
+
+The environment applies only to the current project. As we will see in future chapters, any dependency you add to your project will by default run in the `:prod` environment.
+
+Customization per environment can be done by accessing the `Mix.env/0` in your `mix.exs` file, which returns the current environment as an atom. That's what we have used in the `:start_permanent` options:
+
+```elixir
+def project do
+  [
+    ...,
+    start_permanent: Mix.env() == :prod,
+    ...
+  ]
+end
+```
+
+When true, the `:start_permanent` option starts your application in permanent mode, which means the Erlang VM will crash if your application's supervision tree shuts down. Notice we don't want this behavior in dev and test because it is useful to keep the VM instance running in those environments for troubleshooting purposes.
+
+Mix will default to the `:dev` environment, except for the `test` task that will default to the `:test` environment. The environment can be changed via the `MIX_ENV` environment variable:
+
+```console
+$ MIX_ENV=prod mix compile
+```
+
+Or on Windows:
+
+```batch
+> set "MIX_ENV=prod" && mix compile
+```
+
+> #### Mix in production {: .warning}
+>
+> Mix is a **build tool** and, as such, it is not expected to be available in production. Therefore, it is recommended to access `Mix.env/0` only in configuration files and inside `mix.exs`, never in your application code (`lib`).
+
+## Exploring
+
+There is much more to Mix, and we will continue to explore it as we build our project. A general overview is available on the [Mix documentation](`Mix`) and you can always invoke the help task to list all available tasks:
+
+```console
+$ mix help
+$ mix help compile
+```
+
+Now let's move forward and add the first modules and functions to our application.
diff --git a/lib/elixir/pages/mix-and-otp/releases.md b/lib/elixir/pages/mix-and-otp/releases.md
new file mode 100644
index 00000000000..526d1bbb35d
--- /dev/null
+++ b/lib/elixir/pages/mix-and-otp/releases.md
@@ -0,0 +1,170 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Releases
+
+Now that our application is ready, you may be wondering how we can package our application to run in production. After all, all of our code so far depends on Erlang and Elixir versions that are installed in your current system. To achieve this goal, Elixir provides releases.
+
+A release is a self-contained directory that consists of your application code, all of its dependencies, plus the whole Erlang Virtual Machine (VM) and runtime. Once a release is assembled, it can be packaged and deployed to a target as long as the target runs on the same operating system (OS) distribution and version as the machine that assembled the release.
+
+To get started, simply run `mix release` while setting `MIX_ENV=prod`:
+
+```console
+$ MIX_ENV=prod mix release
+Compiling 4 files (.ex)
+Generated kv app
+* assembling kv-0.1.0 on MIX_ENV=prod
+* using config/runtime.exs to configure the release at runtime
+
+Release created at _build/prod/rel/kv
+
+    # To start your system
+    _build/prod/rel/kv/bin/kv start
+
+Once the release is running:
+
+    # To connect to it remotely
+    _build/prod/rel/kv/bin/kv remote
+
+    # To stop it gracefully (you may also send SIGINT/SIGTERM)
+    _build/prod/rel/kv/bin/kv stop
+
+To list all commands:
+
+    _build/prod/rel/kv/bin/kv
+```
+
+Excellent! A release was assembled in `_build/prod/rel/kv`. Everything you need to run your application is inside that directory. In particular, there is a `bin/kv` file which is the entry point to your system. It supports multiple commands, such as:
+
+  * `bin/kv start`, `bin/kv start_iex`, `bin/kv restart`, and `bin/kv stop` — for general management of the release
+
+  * `bin/kv rpc COMMAND` and `bin/kv remote` — for running commands on the running system or to connect to the running system
+
+  * `bin/kv eval COMMAND` — to start a fresh system that runs a single command and then shuts down
+
+  * `bin/kv daemon` and `bin/kv daemon_iex` — to start the system as a daemon on Unix-like systems
+
+  * `bin/kv install` — to install the system as a service on Windows machines
+
+If you run `bin/kv start_iex` inside the release directory, it will start the system using a short name (`--sname`) equal to the release name, which in this case is `kv`. The next step is to start two instances, on different ports and different names, as we did earlier on. But before we do this, let's talk a bit about the benefits of releases.
+
+## Why releases?
+
+Releases allow developers to precompile and package all of their code and the runtime into a single unit. The benefits of releases are:
+
+  * Code preloading. The VM has two mechanisms for loading code: interactive and embedded. By default, it runs in the interactive mode which dynamically loads modules when they are used for the first time. The first time your application calls `Enum.map/2`, the VM will find the `Enum` module and load it. There's a downside. When you start a new server in production, it may need to load many other modules, causing the first requests to have an unusual spike in response time. Releases run in embedded mode, which loads all available modules upfront, guaranteeing your system is ready to handle requests after booting.
+
+  * Configuration and customization. Releases give developers fine grained control over system configuration and the VM flags used to start the system.
+
+  * Self-contained. A release does not require the source code to be included in your production artifacts. All of the code is precompiled and packaged. Releases do not even require Erlang or Elixir on your servers, as they include the Erlang VM and its runtime by default. Furthermore, both Erlang and Elixir standard libraries are stripped to bring only the parts you are actually using.
+
+  * Multiple releases. You can assemble different releases with different configuration per application or even with different applications altogether.
+
+We have written extensive documentation on releases, so [please check the official documentation for more information](`mix release`). For now, we will continue exploring some of the features outlined above.
+
+## Configuring releases
+
+Releases also provide built-in hooks for configuring almost every need of the production system:
+
+  * `config/config.exs` — provides build-time application configuration, which is executed before our application compiles. This file often imports configuration files based on the environment, such as `config/dev.exs` and `config/prod.exs`.
+
+  * `config/runtime.exs` — provides runtime application configuration. It is executed every time the release boots and is further extensible via config providers.
+
+  * `rel/env.sh.eex` and `rel/env.bat.eex` — template files that are copied into every release and executed on every command to set up environment variables, including ones specific to the VM, and the general environment.
+
+  * `rel/vm.args.eex` — a template file that is copied into every release and provides static configuration of the Erlang Virtual Machine and other runtime flags.
+
+In this case, we already have specified a `config/runtime.exs` that deals with both `PORT` and `NODES` environment variables. Furthermore, while releases don't accept a `--sname` parameter, they do allow us to set the name via the `RELEASE_NODE` env var. Therefore, we can start two copies of the system by jumping into `_build/prod/rel/kv` and typing this (remember to adjust `@computer-name` to your actual computer name):
+
+```console
+$ NODES="foo@computer-name,bar@computer-name" PORT=4040 RELEASE_NODE="foo" bin/kv start_iex
+```
+
+```console
+$ NODES="foo@computer-name,bar@computer-name" PORT=4041 RELEASE_NODE="bar" bin/kv start_iex
+```
+
+To verify it all worked out, you can type `Node.list` in the IEx section and see if it returns the other node. If it doesn't, you can start diagnosing, first by comparing the node names within each `iex>` prompt and calling `Node.connect/1` directly. With applications running, you can `telnet` into them as usual too.
+
+While the above is enough to get started, you may want to perform advanced configuration based on the environment you are replying to. Releases provide scripts for that, which are great to automate based on host, network, or cloud settings.
+
+## Operating System scripts
+
+Every release contains an environment file, named `env.sh` on Unix-like systems and `env.bat` on Windows machines, that executes before the Elixir system starts. In this file, you can execute any OS-level code, such as invoke other applications, set environment variables and so on. Some of those environment variables can even configure how the release itself runs.
+
+For instance, releases run using short-names (`--sname`). However, if you want to actually run a distributed key-value store in production, you will need multiple nodes and start the release with the `--name` option. We can achieve this by setting the `RELEASE_DISTRIBUTION` environment variable inside the `env.sh` and `env.bat` files. Mix already has a template for said files which we can customize, so let's ask Mix to copy them to our application:
+
+    $ mix release.init
+    * creating rel/vm.args.eex
+    * creating rel/remote.vm.args.eex
+    * creating rel/env.sh.eex
+    * creating rel/env.bat.eex
+
+If you open up `rel/env.sh.eex`, you will see:
+
+```shell
+#!/bin/sh
+
+# # Sets and enables heart (recommended only in daemon mode)
+# case $RELEASE_COMMAND in
+#   daemon*)
+#     HEART_COMMAND="$RELEASE_ROOT/bin/$RELEASE_NAME $RELEASE_COMMAND"
+#     export HEART_COMMAND
+#     export ELIXIR_ERL_OPTIONS="-heart"
+#     ;;
+#   *)
+#     ;;
+# esac
+
+# # Set the release to load code on demand (interactive) instead of preloading (embedded).
+# export RELEASE_MODE=interactive
+
+# # Set the release to work across nodes.
+# # RELEASE_DISTRIBUTION must be "sname" (local), "name" (distributed) or "none".
+# export RELEASE_DISTRIBUTION=name
+# export RELEASE_NODE=<%= @release.name %>
+```
+
+The steps necessary to work across nodes is already commented out as an example. You can enable full distribution by setting the `RELEASE_DISTRIBUTION` variable to `name`.
+
+If you are on Windows, you will have to open up `rel/env.bat.eex`, where you will find this:
+
+```bat
+@echo off
+rem Set the release to load code on demand (interactive) instead of preloading (embedded).
+rem set RELEASE_MODE=interactive
+
+rem Set the release to work across nodes.
+rem RELEASE_DISTRIBUTION must be "sname" (local), "name" (distributed) or "none".
+rem set RELEASE_DISTRIBUTION=name
+rem set RELEASE_NODE=<%= @release.name %>
+```
+
+Once again, set the `RELEASE_DISTRIBUTION` variable to `name` and you are good to go!
+
+## VM arguments
+
+The `rel/vm.args.eex` allows you to specify low-level flags that control how the Erlang VM and its runtime operate. You specify entries as if you were specifying arguments in the command line with code comments also supported. Here is the default generated file:
+
+    ## Customize flags given to the VM: https://www.erlang.org/doc/man/erl.html
+    ## -mode/-name/-sname/-setcookie are configured via env vars, do not set them here
+
+    ## Increase number of concurrent ports/sockets
+    ##+Q 65536
+
+    ## Tweak GC to run more often
+    ##-env ERL_FULLSWEEP_AFTER 10
+
+You can see [a complete list of VM arguments and flags in the Erlang documentation](http://www.erlang.org/doc/man/erl.html).
+
+## Summing up
+
+Throughout the guide, we have built a very simple distributed key-value store as an opportunity to explore many constructs like generic servers, supervisors, tasks, agents, applications and more. Not only that, we have written tests for the whole application, got familiar with ExUnit, and learned how to use the Mix build tool to accomplish a wide range of tasks.
+
+If you are looking for a distributed key-value store to use in production, you should definitely look into [Riak](http://riak.com/products/riak-kv/), which also runs in the Erlang VM. In Riak, the buckets are replicated and stored across several nodes to avoid data loss.
+
+Of course, Elixir can be used for much more than distributed key-value stores. Embedded systems, data-processing and data-ingestion, web applications, audio/video streaming systems, machine learning, and others are many of the different domains Elixir excels at. We hope this guide has prepared you to explore any of those domains or any future domain you may desire to bring Elixir into.
+
+Happy coding!
diff --git a/lib/elixir/pages/mix-and-otp/supervisor-and-application.md b/lib/elixir/pages/mix-and-otp/supervisor-and-application.md
new file mode 100644
index 00000000000..acc1fc8ee83
--- /dev/null
+++ b/lib/elixir/pages/mix-and-otp/supervisor-and-application.md
@@ -0,0 +1,253 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Registries and supervision trees
+
+In the [previous chapter](agents.md), we used agents to represent our buckets. In the [introduction to mix](introduction-to-mix.md), we specified we would like to name each bucket so we can do the following:
+
+```text
+CREATE shopping
+OK
+
+PUT shopping milk 1
+OK
+
+GET shopping milk
+1
+OK
+```
+
+In the example session above we interacted with the "shopping" bucket by referencing its name. Therefore, an important feature in our key-value store is to give names to processes.
+
+We have also learned in the previous chapter we can already name our buckets. For example:
+
+```elixir
+iex> KV.Bucket.start_link(name: :shopping)
+{:ok, #PID<0.43.0>}
+iex> KV.Bucket.put(:shopping, "milk", 1)
+:ok
+iex> KV.Bucket.get(:shopping, "milk")
+1
+```
+
+However, naming dynamic processes with atoms is a terrible idea! If we use atoms, we would need to convert the bucket name (often received from an external client) to atoms, and **we should never convert user input to atoms**. This is because atoms are not garbage collected. Once an atom is created, it is never reclaimed. Generating atoms from user input would mean the user can inject enough different names to exhaust our system memory!
+
+In practice, it is more likely you will reach the Erlang VM limit for the maximum number of atoms before you run out of memory, which will bring your system down regardless.
+
+Luckily, Elixir (and Erlang) comes with built-in abstractions for naming processes, called name registries, each with different trade-offs which we will explore throughout these guides.
+
+## Local, decentralized, and scalable registry
+
+Elixir ships with a single-node process registry module aptly called `Registry`. Its main feature is that you can use any Elixir value to name a process, not only atoms. Let's take it for a spin in `iex`:
+
+```elixir
+iex> Registry.start_link(name: KV, keys: :unique)
+iex> name = {:via, Registry, {KV, "shopping"}}
+iex> KV.Bucket.start_link(name: name)
+{:ok, #PID<0.43.0>}
+iex> KV.Bucket.put(name, "milk", 1)
+:ok
+iex> KV.Bucket.get(name, "milk")
+1
+```
+
+As you can see, instead of passing an atom to the `:name` option, we pass a tuple of shape `{:via, registry_module, {registry_name, process_name}}`, and everything just worked. You could have used anything as the `process_name`, even an integer or a map! That's because all of Elixir built-in behaviours, agents, supervisors, tasks, etc, are compatible with naming registries, as long as you pass them using the "via" tuple format.
+
+Therefore, all we need to do to name our buckets is to start a `Registry`, using `Registry.start_link/1`. But you may be wondering, where exactly should we place that?
+
+## Understanding applications
+
+Every Elixir project is an application. Elixir itself is defined in an application named `:elixir`. The `ExUnit.Case` module is part of the `:ex_unit` application. And so forth.
+
+In fact, we have been working inside an application this entire time. Every time we changed a file and ran `mix compile`, we could see a `Generated kv app` message in the compilation output.
+
+We can find the generated `.app` file at `_build/dev/lib/kv/ebin/kv.app`. Let's have a look at its contents:
+
+```erlang
+{application,kv,
+             [{applications,[kernel,stdlib,elixir,logger]},
+              {description,"kv"},
+              {modules,['Elixir.KV','Elixir.KV.Bucket']},
+              {registered,[]},
+              {vsn,"0.1.0"}]}.
+```
+
+This file contains Erlang terms (written using Erlang syntax). Even though we are not familiar with Erlang, it is easy to guess this file holds our application definition. It contains our application `version`, all the modules defined by it, as well as a list of applications we depend on, like Erlang's `kernel`, `elixir` itself, and `logger`.
+
+> The `logger` application ships as part of Elixir. We stated that our application needs it by specifying it in the `:extra_applications` list in `mix.exs`. See the [official documentation](`Logger`) for more information.
+
+In a nutshell, an application consists of all the modules defined in the `.app` file, including the `.app` file itself. The application itself is located at the `_build/dev/lib/kv` folder and typically has only two directories: `ebin`, for Elixir artifacts, such as `.beam` and `.app` files, and `priv`, with any other artifact or asset you may need in your application.
+
+Although Mix generates and maintains the `.app` file for us, we can customize its contents by adding new entries to the `application/0` function inside the `mix.exs` project file. We are going to do our first customization soon.
+
+### Starting applications
+
+Each application in our system can be started and stopped. The rules for starting and stopping an application are also defined in the `.app` file. When we invoke `iex -S mix`, Mix compiles our application and then starts it.
+
+Let's see this in practice. Start a console with `iex -S mix` and try:
+
+```elixir
+iex> Application.start(:kv)
+{:error, {:already_started, :kv}}
+```
+
+Oops, it's already started. Mix starts the current application and all of its dependencies automatically. This is also true for `mix test` and many other Mix commands.
+
+We can, however, stop our `:kv` application, as well as the `:logger` application:
+
+```elixir
+iex> Application.stop(:kv)
+:ok
+iex> Application.stop(:logger)
+:ok
+```
+
+And let's try to start our application again:
+
+```elixir
+iex> Application.start(:kv)
+{:error, {:not_started, :logger}}
+```
+
+Now we get an error because an application that `:kv` depends on (`:logger` in this case) isn't started. We need to either start each application manually in the correct order or call `Application.ensure_all_started/1` as follows:
+
+```elixir
+iex> Application.ensure_all_started(:kv)
+{:ok, [:logger, :kv]}
+```
+
+In practice, our tools always start our applications for us, and you don't have to worry about the above, but it is good to know how it all works behind the scenes.
+
+### The application callback
+
+Whenever we invoke `iex -S mix`, Mix automatically starts our application by calling `Application.start(:kv)`. But can we customize what happens when our application starts? As a matter of fact, we can! To do so, we define an application callback.
+
+The first step is to tell our application definition (for example, our `.app` file) which module is going to implement the application callback. Let's do so by opening `mix.exs` and changing `def application` to the following:
+
+```elixir
+  def application do
+    [
+      extra_applications: [:logger],
+      mod: {KV, []}
+    ]
+  end
+```
+
+The `:mod` option specifies the "application callback module", followed by the arguments to be passed on application start. The application callback module can be any module that invokes `use Application`. Since we have specified `KV` as the module callback, let's change the `KV` module defined in `lib/kv.ex` to the following:
+
+```elixir
+defmodule KV do
+  use Application
+end
+```
+
+Now run `mix test` and you will see a couple things happening. First of all, you will get a compilation warning:
+
+```text
+Compiling 1 file (.ex)
+    warning: function start/2 required by behaviour Application is not implemented (in module KV)
+    │
+  1 │ defmodule KV do
+    │ ~~~~~~~~~~~~~~~
+    │
+    └─ lib/kv.ex:1: KV (module)
+```
+
+This warning is telling us that `use Application` actually defines a behaviour, which expects us to implement to a `start/2` function in our `KV` module.
+
+Then our application does not even boot because the `start/2` function is not actually implemented:
+
+```text
+18:29:39.109 [notice] Application kv exited: exited in: KV.start(:normal, [])
+    ** (EXIT) an exception was raised:
+        ** (UndefinedFunctionError) function KV.start/2 is undefined or private
+```
+
+Implementing the `start/2` callback is relatively straight-forward, all we need to do is to start a supervision tree, and return `{:ok, root_supervisor_pid}`. The `Supervisor.start_link/2` function does precisely that, it only expects a list of children and the supervision strategy. Let's just pass an empty list of children for now:
+
+```elixir
+defmodule KV do
+  use Application
+
+  # The @impl true annotation says we are implementing a callback
+  @impl true
+  def start(_type, _args) do
+    Supervisor.start_link([], strategy: :one_for_one)
+  end
+end
+```
+
+Now run `mix test` again and our app should boot but we should see one failure. When we changed the `KV` module, we broke the boilerplate test case which tested the `KV.hello/0` function. You can simply remove that test case and we are back to a green suite.
+
+We wrote very little code but we did something incredibly powerful. We now have a function, `KV.start/2` that is invoked whenever your application starts. This gives us the perfect place to start our key-value registry. The `Application` module also allows us to define a `stop/1` callback and other functionality. You can check the `Application` and `Supervisor` modules for extensive documentation on their uses.
+
+Let's finally start our registry.
+
+## Supervision trees
+
+Now that we have the `start/2` callback, we can finally go ahead and start our registry. You may be tempted to do it like this:
+
+```elixir
+  def start(_type, _args) do
+    Registry.start_link(name: KV, keys: :unique)
+    Supervisor.start_link([], strategy: :one_for_one)
+  end
+```
+
+However, this would not be a good idea. In Elixir, we typically start processes inside supervision trees. In fact, we rarely use the `start_link` functions to start processes (except at the root of the supervision tree itself). Instead, do this:
+
+```elixir
+  def start(_type, _args) do
+    children = [
+      {Registry, name: KV, keys: :unique}
+    ]
+
+    Supervisor.start_link(children, strategy: :one_for_one)
+  end
+```
+
+A supervisor receives one or more child specifications that tell it exactly how to start each child. A child specification is typically represented by a `{module, options}` pair, as shown above, and often as simply the module name. Sometimes, these children are supervisors themselves, giving us supervision trees.
+
+Let's take it for a spin and see if we can indeed name our buckets using our new registry. Let's make sure to start a new `iex -S mix` (`recompile()` is not enough, as it does not reload your supervision tree) and then:
+
+```iex
+iex> name = {:via, Registry, {KV, "shopping"}}
+iex> KV.Bucket.start_link(name: name)
+{:ok, #PID<0.43.0>}
+iex> KV.Bucket.put(name, "milk", 1)
+:ok
+iex> KV.Bucket.get(name, "milk")
+1
+```
+
+Perfect, this time we didn't need to start the registry inside `iex`, as it was started as part of the application itself.
+
+By starting processes inside supervisors, we gain important properties such as:
+
+  * **Introspection**: for each application, you can fully introspect and visualize each process in its supervision tree, its memory usage, message queue, etc
+
+  * **Resilience**: when a process fails for an unexpected reason, its supervisor controls if and how those processes should be restarted, leading to self-healing systems
+
+  * **Graceful shutdown**: when your application is shutting down, the children of a supervision tree are terminated in the opposite order they were started, leading to graceful shutdowns
+
+## Projects or applications?
+
+Mix makes a distinction between projects and applications. Based on the contents of our `mix.exs` file, we would say we have a Mix project that defines the `:kv` application.
+
+When we say "project" you should think about Mix. Mix is the tool that manages your project. It knows how to compile your project, test your project and more. It also knows how to compile and start the application relevant to your project.
+
+When we talk about applications, we talk about OTP. Applications are the entities that are started and stopped as a whole by the runtime. You can learn more about applications and how they relate to booting and shutting down of your system as a whole in the documentation for the `Application` module.
+
+## Summing up
+
+We learned important concepts in this chapter:
+
+  * Naming registries allow us to find processes in a given machine (or, as we will see in the future, even in a cluster)
+
+  * Applications bundle our modules, its dependencies, and how code starts and stops
+
+  * Processes are started as part of supervisors for introspection and fault-tolerance
+
+In the next chapter, we will tie it all up by making sure all our buckets are named and supervised. To do so, we will learn a new tool called dynamic supervisors.
diff --git a/lib/elixir/pages/mix-and-otp/task-and-gen-tcp.md b/lib/elixir/pages/mix-and-otp/task-and-gen-tcp.md
new file mode 100644
index 00000000000..28468361b26
--- /dev/null
+++ b/lib/elixir/pages/mix-and-otp/task-and-gen-tcp.md
@@ -0,0 +1,308 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Task and gen_tcp
+
+In this chapter, we are going to learn how to use Erlang's [`:gen_tcp` module](`:gen_tcp`) to serve requests. This provides a great opportunity to explore Elixir's `Task` module. In future chapters, we will expand our server so that it can actually interact with buckets.
+
+## Echo server
+
+We will start our TCP server by first implementing an echo server. It will send a response with the text it received in the request. We will slowly improve our server until it is supervised and ready to handle multiple connections.
+
+A TCP server, in broad strokes, performs the following steps:
+
+  1. Listens to a port until the port is available and it gets hold of the socket
+  2. Waits for a client connection on that port and accepts it
+  3. Reads the client request and writes a response back
+
+Let's implement those steps. Create a new `lib/kv/server.ex` and add the following functions:
+
+```elixir
+defmodule KV.Server do
+  require Logger
+
+  def accept(port) do
+    # The options below mean:
+    #
+    # 1. `:binary` - receives data as binaries (instead of lists)
+    # 2. `packet: :line` - receives data line by line
+    # 3. `active: false` - blocks on `:gen_tcp.recv/2` until data is available
+    # 4. `reuseaddr: true` - allows us to reuse the address if the listener crashes
+    #
+    {:ok, socket} =
+      :gen_tcp.listen(port, [:binary, packet: :line, active: false, reuseaddr: true])
+    Logger.info("Accepting connections on port #{port}")
+    loop_acceptor(socket)
+  end
+
+  defp loop_acceptor(socket) do
+    {:ok, client} = :gen_tcp.accept(socket)
+    serve(client)
+    loop_acceptor(socket)
+  end
+
+  defp serve(socket) do
+    socket
+    |> read_line()
+    |> write_line(socket)
+
+    serve(socket)
+  end
+
+  defp read_line(socket) do
+    {:ok, data} = :gen_tcp.recv(socket, 0)
+    data
+  end
+
+  defp write_line(line, socket) do
+    :gen_tcp.send(socket, line)
+  end
+end
+```
+
+We are going to start our server by calling `KV.Server.accept(4040)`, where 4040 is the port. The first step in `accept/1` is to listen to the port until the socket becomes available and then call `loop_acceptor/1`. `loop_acceptor/1` is a loop accepting client connections. For each accepted connection, we call `serve/1`.
+
+`serve/1` is another loop that reads a line from the socket and writes those lines back to the socket. Note that the `serve/1` function uses the pipe operator `|>/2` to express this flow of operations. The pipe operator evaluates the left side and passes its result as the first argument to the function on the right side. The example above:
+
+```elixir
+socket |> read_line() |> write_line(socket)
+```
+
+is equivalent to:
+
+```elixir
+write_line(read_line(socket), socket)
+```
+
+The `read_line/1` implementation receives data from the socket using `:gen_tcp.recv/2` and `write_line/2` writes to the socket using `:gen_tcp.send/2`.
+
+Note that `serve/1` is an infinite loop called sequentially inside `loop_acceptor/1`, so the tail call to `loop_acceptor/1` is never reached and could be avoided. However, as we shall see, we will need to execute `serve/1` in a separate process, so we will need that tail call soon.
+
+This is pretty much all we need to implement our echo server. Let's give it a try!
+
+Start an IEx session inside the `kv_server` application with `iex -S mix`. Inside IEx, run:
+
+```elixir
+iex> KV.Server.accept(4040)
+```
+
+The server is now running, and you will even notice the console is blocked. Let's use [a `telnet` client](https://en.wikipedia.org/wiki/Telnet) to access our server. There are clients available on most operating systems, and their command lines are generally similar:
+
+```console
+$ telnet 127.0.0.1 4040
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+hello
+hello
+is it me
+is it me
+you are looking for?
+you are looking for?
+```
+
+Type "hello", press enter, and you will get "hello" back. Excellent!
+
+My particular telnet client can be exited by typing `ctrl + ]`, typing `quit`, and pressing `<Enter>`, but your client may require different steps.
+
+Once you exit the telnet client, you will likely see an error in the IEx session:
+
+```text
+** (MatchError) no match of right hand side value: {:error, :closed}
+    (kv) lib/kv/server.ex:45: KV.Server.read_line/1
+    (kv) lib/kv/server.ex:37: KV.Server.serve/1
+    (kv) lib/kv/server.ex:30: KV.Server.loop_acceptor/1
+```
+
+That's because we were expecting data from `:gen_tcp.recv/2` but the client closed the connection. We need to handle such cases better in future revisions of our server.
+
+For now, there is a more important bug we need to fix: what happens if our TCP acceptor crashes? Since there is no supervision, the server dies and we won't be able to serve more requests, because it won't be restarted. That's why we must move our server to a supervision tree.
+
+## Tasks
+
+Whenever you have an existing function and you simply want to execute it when your application starts, the `Task` module is exactly what you need. For example, it has a `Task.start_link/1` function that receives an anonymous function and executes it inside a new process that will be part of a supervision tree.
+
+Let's give it a try. Open up `lib/kv.ex` and let's add a new child:
+
+```elixir
+  def start(_type, _args) do
+    children = [
+      {Registry, name: KV, keys: :unique},
+      {DynamicSupervisor, name: KV.BucketSupervisor, strategy: :one_for_one},
+      {Task, fn -> KV.Server.accept(4040) end}
+    ]
+
+    Supervisor.start_link(children, strategy: :one_for_one)
+  end
+```
+
+With this change, we are saying that we want to run `KV.Server.accept(4040)` as a task. We are hardcoding the port for now but we will make this a configuration in later chapters. As usual, we've passed a two-element tuple as a child specification, which in turn will invoke `Task.start_link/1`.
+
+Now that the server is part of the supervision tree, it should start automatically when we run the application. Run `iex -S mix` to boot the app and use the `telnet` client to make sure that everything still works:
+
+```console
+$ telnet 127.0.0.1 4321
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+say you
+say you
+say me
+say me
+```
+
+Yes, it works! However, can it handle more than one client?
+
+Try to connect two telnet clients at the same time. When you do so, you will notice that the second client doesn't echo:
+
+```console
+$ telnet 127.0.0.1 4321
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+hello
+hello?
+HELLOOOOOO?
+```
+
+It doesn't seem to work at all. That's because we are serving requests in the same process that are accepting connections. When one client is connected, we can't accept another client.
+
+## Adding (flawed) concurrency
+
+In order to make our server handle simultaneous connections, we need to have one process working as an acceptor that spawns other processes to serve requests. One solution would be to change:
+
+```elixir
+defp loop_acceptor(socket) do
+  {:ok, client} = :gen_tcp.accept(socket)
+  serve(client)
+  loop_acceptor(socket)
+end
+```
+
+to also use `Task.start_link/1`:
+
+```elixir
+defp loop_acceptor(socket) do
+  {:ok, client} = :gen_tcp.accept(socket)
+  {:ok, pid} = Task.start_link(fn -> serve(client) end)
+  :ok = :gen_tcp.controlling_process(client, pid)
+  loop_acceptor(socket)
+end
+```
+
+In the new acceptor loop, we are starting a new task every time there is a new client. Now, if you attempt to connect two clients at the same time, it should work!
+
+Or does it? For example, what happens when you exit one telnet session? The other session should crash! The reason of this crash is two fold:
+
+1. We have a bug in our server where we don't expect `:gen_tcp.recv/2` to return an `{:error, :closed}` tuple
+
+2. Because each server task is linked to the acceptor process, if one task crashes, the acceptor process will also crash, taking down all other tasks and clients
+
+An important rule of thumb throughout this guide is to always start processes as children of supervisors. The code above is an excellent example of what happens when we don't. If we don't isolate the different parts of our systems, failures can now cascade through our system, as it would happen in other languages.
+
+To fix this, we could use a `DynamicSupervisor`, but tasks also provide a specialized `Task.Supervisor` which has better ergonomics and is optimized for supervising tasks themselves. Let's give it a try.
+
+## Adding a task supervisor
+
+Let's change `start/2` in `lib/kv.ex` once more, to add the task supervisor to our tree:
+
+```elixir
+  def start(_type, _args) do
+    children = [
+      {Registry, name: KV, keys: :unique},
+      {DynamicSupervisor, name: KV.BucketSupervisor, strategy: :one_for_one},
+      {Task.Supervisor, name: KV.ServerSupervisor},
+      {Task, fn -> KV.Server.accept(4040) end}
+    ]
+
+    Supervisor.start_link(children, strategy: :one_for_one)
+  end
+```
+
+We'll now start a `Task.Supervisor` process with name `KV.TaskSupervisor`. Keep in mind that the order children are started matters. For example, the acceptor must come last because, if it comes first, it means our application can start accepting requests before the `Task.Supervisor` is running or before we can locate buckets. Shutting down an application will also stop the children in reverse order, guaranteeing a clean termination.
+
+Now we need to change `loop_acceptor/1` to use `Task.Supervisor` to serve each request:
+
+```elixir
+defp loop_acceptor(socket) do
+  {:ok, client} = :gen_tcp.accept(socket)
+  {:ok, pid} = Task.Supervisor.start_child(KV.ServerSupervisor, fn -> serve(client) end)
+  :ok = :gen_tcp.controlling_process(client, pid)
+  loop_acceptor(socket)
+end
+```
+
+You might notice that we added a line, `:ok = :gen_tcp.controlling_process(client, pid)`. This makes the child process the "controlling process" of the `client` socket. If we didn't do this, the acceptor would bring down all the clients if it crashed because sockets would be tied to the process that accepted them (which is the default behavior).
+
+Now start a new server with `iex -S mix` and try to open up many concurrent telnet clients. You will notice that quitting a client does not bring the acceptor down, even though we haven't fixed the bug in `:gen_tcp.recv/2` yet (which we will address in the next chapter). Excellent!
+
+## Restart strategies
+
+There is one important topic we haven't explored yet with the necessary depth. What happens when a supervised process crashes?
+
+In the previous chapter, when we started a bucket and killed it, the supervisor automatically started one in its place:
+
+```elixir
+iex> children = [{KV.Bucket, name: :shopping}]
+iex> Supervisor.start_link(children, strategy: :one_for_one)
+iex> KV.Bucket.put(:shopping, "milk", 1)
+iex> pid = Process.whereis(:shopping)
+#PID<0.48.0>
+iex> Process.exit(pid, :kill)
+true
+iex> Process.whereis(:shopping)
+#PID<0.50.0>
+```
+
+What exactly happens when a process terminates is part of its child specification. For `KV.Bucket`, we have this:
+
+```elixir
+iex> KV.Bucket.child_spec([])
+%{id: KV.Bucket, start: {KV.Bucket, :start_link, [[]]}}
+```
+
+However, for tasks, we have this:
+
+```elixir
+iex> Task.child_spec(fn -> :ok end)
+%{
+  id: Task,
+  restart: :temporary,
+  start: {Task, :start_link, [#Function<43.39164016/0 in :erl_eval.expr/6>]}
+}
+```
+
+Notice that a task says `:restart` is `:temporary`. `KV.Bucket` says nothing, which means it defaults to `:permanent`. `:temporary` means that a process is never restarted, regardless of why it crashed. `:permanent` means a process is always restarted, regardless of the exit reason. There is also `:transient`, which means it won't be restarted as long as it terminates successfully.
+
+Now we must ask ourselves, are those the correct settings?
+
+For `KV.Bucket`, using `:permanent` seems logical, as we should not require the user to recreate a bucket they have previously created. Although currently we would lose the bucket data, in an actual system we would add mechanisms to recover it on initialization. However, for tasks, we have used them in two opposing ways in this chapter, which means at least one of them is wrong.
+
+We use a task to start the acceptor. The acceptor is a critical component of our infrastructure. If it crashes, it means we won't accept further requests, and our server would then be useless as no one can connect to it. On the other hand, we also use `Task.Supervisor` to start tasks that deal with each connection. In this case, restarting may not be useful at all, given the reason we crashed could just as well be a connection issue, and attempting to restart over the same connection would lead to further failures.
+
+Therefore, we want the acceptor to actually run in `:permanent` mode, while we preserve the `Task.Supervisor` as `:temporary`. Luckily Elixir has an API that allows us to change an existing child specification, which we use below.
+
+Let's change `start/2` in `lib/kv.ex` once more to the following:
+
+```elixir
+  def start(_type, _args) do
+    children = [
+      {Registry, name: KV, keys: :unique},
+      {DynamicSupervisor, name: KV.BucketSupervisor, strategy: :one_for_one},
+      {Task.Supervisor, name: KV.ServerSupervisor},
+      Supervisor.child_spec({Task, fn -> KV.Server.accept(4040) end}, restart: :permanent)
+    ]
+
+    Supervisor.start_link(children, strategy: :one_for_one)
+  end
+```
+
+Now we have an always running acceptor that starts temporary task processes under an always running task supervisor.
+
+## Leveraging the ecosystem
+
+In this chapter, we implemented a basic TCP acceptor while exploring concurrency and fault-tolerance. Our acceptor can manage concurrent connections, but it is still not ready for production. Production-ready TCP servers run a pool of acceptors, each with their own supervisor. Elixir's `PartitionSupervisor` might be used to partition and scale the acceptor, but it is out of scope for this guide. In practice, you will use existing packages tailored for this use-case, such as [Ranch](https://github.com/ninenines/ranch) (in Erlang) or [Thousand Island](https://github.com/mtrudel/thousand_island) (in Elixir).
+
+In the next chapter, we will start parsing the client requests and sending responses, finishing our server.
diff --git a/lib/elixir/pages/references/compatibility-and-deprecations.md b/lib/elixir/pages/references/compatibility-and-deprecations.md
new file mode 100644
index 00000000000..75a637fe804
--- /dev/null
+++ b/lib/elixir/pages/references/compatibility-and-deprecations.md
@@ -0,0 +1,246 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
+# Compatibility and deprecations
+
+Elixir is versioned according to a vMAJOR.MINOR.PATCH schema.
+
+Elixir is currently at major version v1. A new backwards compatible minor release happens every 6 months. Patch releases are not scheduled and are made whenever there are bug fixes or security patches.
+
+Elixir applies bug fixes only to the latest minor branch. Security patches are available for the last 5 minor branches:
+
+Elixir version | Support
+:------------- | :-----------------------------
+1.20           | Development
+1.19           | Bug fixes and security patches
+1.18           | Security patches only
+1.17           | Security patches only
+1.16           | Security patches only
+1.15           | Security patches only
+
+New releases are announced in the read-only [announcements mailing list](https://groups.google.com/group/elixir-lang-ann). All security releases [will be tagged with `[security]`](https://groups.google.com/forum/#!searchin/elixir-lang-ann/%5Bsecurity%5D%7Csort:date).
+
+There are currently no plans for a major v2 release.
+
+## Between non-major Elixir versions
+
+Elixir minor and patch releases are backwards compatible: well-defined behaviors and documented APIs in a given version will continue working on future versions.
+
+Although we expect the vast majority of programs to remain compatible over time, it is impossible to guarantee that no future change will break any program. Under some unlikely circumstances, we may introduce changes that break existing code:
+
+  * Security: a security issue in the implementation may arise whose resolution requires backwards incompatible changes. We reserve the right to address such security issues.
+
+  * Bugs: if an API has undesired behavior, a program that depends on the buggy behavior may break if the bug is fixed. We reserve the right to fix such bugs.
+
+  * Compiler front-end: improvements may be done to the compiler, introducing new warnings for ambiguous modes and providing more detailed error messages. Those can lead to compilation errors (when running with `--warnings-as-errors`) or tooling failures when asserting on specific error messages (although one should avoid such). We reserve the right to do such improvements.
+
+  * Imports: new functions may be added to the `Kernel` module, which is auto-imported. They may collide with local functions defined in your modules. Collisions can be resolved in a backwards compatible fashion using `import Kernel, except: [...]` with a list of all functions you don't want to be imported from `Kernel`. We reserve the right to do such additions.
+
+In order to continue evolving the language without introducing breaking changes, Elixir will rely on deprecations to demote certain practices and promote new ones. Our deprecation policy is outlined in the ["Deprecations" section](#deprecations).
+
+The only exception to the compatibility guarantees above are experimental features, which will be explicitly marked as such, and do not provide any compatibility guarantee until they are stabilized.
+
+## Between Elixir and Erlang/OTP
+
+Erlang/OTP versioning is independent from the versioning of Elixir. Erlang releases a new major version yearly. Our goal is to support the last three Erlang major versions by the time Elixir is released. The compatibility table is shown below.
+
+Elixir version | Supported Erlang/OTP versions
+:------------- | :-------------------------------
+1.20           | 26 - 28
+1.19           | 26 - 28
+1.18           | 25 - 27
+1.17           | 25 - 27
+1.16           | 24 - 26
+1.15           | 24 - 26
+1.14           | 23 - 25 (and Erlang/OTP 26 from v1.14.5)
+1.13           | 22 - 24 (and Erlang/OTP 25 from v1.13.4)
+1.12           | 22 - 24
+1.11           | 21 - 23 (and Erlang/OTP 24 from v1.11.4)
+1.10           | 21 - 22 (and Erlang/OTP 23 from v1.10.3)
+1.9            | 20 - 22
+1.8            | 20 - 22
+1.7            | 19 - 22
+1.6            | 19 - 20 (and Erlang/OTP 21 from v1.6.6)
+1.5            | 18 - 20
+1.4            | 18 - 19 (and Erlang/OTP 20 from v1.4.5)
+1.3            | 18 - 19
+1.2            | 18 - 18 (and Erlang/OTP 19 from v1.2.6)
+1.1            | 17 - 18
+1.0            | 17 - 17 (and Erlang/OTP 18 from v1.0.5)
+
+Elixir may add compatibility to new Erlang/OTP versions on patch releases, such as support for Erlang/OTP 20 in v1.4.5. Those releases are made for convenience and typically contain the minimum changes for Elixir to run without errors, if any changes are necessary. Only the next minor release, in this case v1.5.0, effectively leverages the new features provided by the latest Erlang/OTP release.
+
+## Deprecations
+
+### Policy
+
+Elixir deprecations happen in 3 steps:
+
+  1. The feature is soft-deprecated. It means both CHANGELOG and documentation must list the feature as deprecated but no warning is effectively emitted by running the code. There is no requirement to soft-deprecate a feature.
+
+  2. The feature is effectively deprecated by emitting warnings on usage. This is also known as hard-deprecation. In order to deprecate a feature, the proposed alternative MUST exist for AT LEAST THREE minor versions. For example, `Enum.uniq/2` was soft-deprecated in favor of `Enum.uniq_by/2` in Elixir v1.1. This means a deprecation warning may only be emitted by Elixir v1.4 or later.
+
+  3. The feature is removed. This can only happen on major releases. This means deprecated features in Elixir v1.x shall only be removed by Elixir v2.x.
+
+### Table of deprecations
+
+The first column is the version the feature was hard deprecated. The second column shortly describes the deprecated feature and the third column explains the replacement and from which the version the replacement is available from.
+
+Version | Deprecated feature                                  | Replaced by (available since)
+:-------| :-------------------------------------------------- | :---------------------------------------------------------------
+[v1.20] | `<<x::size(y)>>` in patterns without `^`            | `<<x::size(^y)>>` (v1.15)
+[v1.20] | `File.stream!(path, modes, lines_or_bytes)`         | `File.stream!(path, lines_or_bytes, modes)` (v1.16)
+[v1.20] | `Kernel.ParallelCompiler.async/1`                   | `Kernel.ParallelCompiler.pmap/2` (v1.16)
+[v1.20] | `Logger.*_backend` functions                        | The `LoggerBackends` module from [`:logger_backends`](https://hex.pm/packages/logger_backends) package
+[v1.20] | `Logger.enable/1` and `Logger.disable/1`            | `Logger.put_process_level/2` and `Logger.delete_process_level/1` respectively (v1.15)
+[v1.19] | CLI configuration in `def project` inside `mix.exs` | Moving it to `def cli` (v1.14)
+[v1.19] | Using `,` to separate tasks in `mix do`             | Using `+` (v1.14)
+[v1.19] | `Logger`'s `:backends` configuration                | `Logger`'s `:default_handler` configuration (v1.15)
+[v1.19] | Passing a callback to `File.cp/3`, `File.cp!/3`, `File.cp_r/3`, and `File.cp_r!/3` | The `:on_conflict` option (v1.14)
+[v1.18] | `<%#` in EEx                                        | `<%!--` (v1.14) or `<% #` (v1.0)
+[v1.18] | `EEx.Engine.handle_text/2` callback in EEx          | `c:EEx.Engine.handle_text/3` (v1.14)
+[v1.18] | Returning a 2-arity function from `Enumerable.slice/1` | Returning a 3-arity function (v1.14)
+[v1.18] | Ranges with negative steps in `Range.new/2`         | Explicit steps in ranges (v1.11)
+[v1.18] | `Tuple.append/2`                                    | `Tuple.insert_at/3` (v1.0)
+[v1.18] | `mix cmd --app APP`                                 | `mix do --app APP` (v1.14)
+[v1.18] | `List.zip/1`                                        | `Enum.zip/1` (v1.0)
+[v1.18] | `Module.eval_quoted/3`                              | `Code.eval_quoted/3` (v1.0)
+[v1.17] | Single-quoted charlists (`'foo'`)                   | `~c"foo"` (v1.0)
+[v1.17] | `left..right` in patterns and guards                | `left..right//step` (v1.11)
+[v1.17] | `ExUnit.Case.register_test/4`                       | `register_test/6` (v1.10)
+[v1.17] | `:all` in `IO.read/2` and `IO.binread/2`            | `:eof` (v1.13)
+[v1.16] | `~R/.../`                                           | `~r/.../` (v1.0)
+[v1.16] | Ranges with negative steps in `Enum.slice/2`        | Explicit steps in ranges (v1.11)
+[v1.16] | Ranges with negative steps in `String.slice/2`      | Explicit steps in ranges (v1.11)
+[v1.15] | `Calendar.ISO.day_of_week/3`                        | `Calendar.ISO.day_of_week/4` (v1.11)
+[v1.15] | `Exception.exception?/1`                            | `Kernel.is_exception/1` (v1.11)
+[v1.15] | `Regex.regex?/1`                                    | `Kernel.is_struct/2` (`Kernel.is_struct(term, Regex)`) (v1.11)
+[v1.15] | `Logger.warn/2`                                     | `Logger.warning/2` (v1.11)
+[v1.14] | `use Bitwise`                                       | `import Bitwise` (v1.0)
+[v1.14] | `~~~/1`                                             | `bnot/2` (v1.0)
+[v1.14] | `Application.get_env/3` and similar in module body  | `Application.compile_env/3` (v1.10)
+[v1.14] | Compiled patterns in `String.starts_with?/2`        | Pass a list of strings instead (v1.0)
+[v1.14] | `Mix.Tasks.Xref.calls/1`                            | Compilation tracers (outlined in `Code`) (v1.10)
+[v1.14] | `$levelpad` in Logger                               | *None*
+[v1.14] | `<\|>` as a custom operator                         | Another custom operator (v1.0)
+[v1.13] | `!` and `!=` in Version requirements                | `~>` or `>=` (v1.0)
+[v1.13] | `Mix.Config`                                        | `Config` (v1.9)
+[v1.13] | `:strip_beam` config to `mix escript.build`         | `:strip_beams` (v1.9)
+[v1.13] | `Macro.to_string/2`                                 | `Macro.to_string/1` (v1.0)
+[v1.13] | `System.get_pid/0`                                  | `System.pid/0` (v1.9)
+[v1.12] | `^^^/2`                                             | `bxor/2` (v1.0)
+[v1.12] | `@foo()` to read module attributes                  | Remove the parenthesis (v1.0)
+[v1.12] | `use EEx.Engine`                                    | Explicitly delegate to EEx.Engine instead (v1.0)
+[v1.12] | `:xref` compiler in Mix                             | Nothing (it always runs as part of the compiler now)
+[v1.11] | `Mix.Project.compile/2`                             | `Mix.Task.run("compile", args)` (v1.0)
+[v1.11] | `Supervisor.Spec.worker/3` and `Supervisor.Spec.supervisor/3` | The new child specs outlined in `Supervisor` (v1.5)
+[v1.11] | `Supervisor.start_child/2` and `Supervisor.terminate_child/2` | `DynamicSupervisor` (v1.6)
+[v1.11] | `System.stacktrace/1`                               | `__STACKTRACE__` in `try/catch/rescue` (v1.7)
+[v1.10] | `Code.ensure_compiled?/1`                           | `Code.ensure_compiled/1` (v1.0)
+[v1.10] | `Code.load_file/2`                                  | `Code.require_file/2` (v1.0) or `Code.compile_file/2` (v1.7)
+[v1.10] | `Code.loaded_files/0`                               | `Code.required_files/0` (v1.7)
+[v1.10] | `Code.unload_file/1`                                | `Code.unrequire_files/1` (v1.7)
+[v1.10] | Passing non-chardata to `Logger.log/2`              | Explicitly convert to string with `to_string/1` (v1.0)
+[v1.10] | `:compile_time_purge_level` in `Logger` app environment | `:compile_time_purge_matching` in `Logger` app environment (v1.7)
+[v1.10] | `Supervisor.Spec.supervise/2`                       | The new child specs outlined in `Supervisor` (v1.5)
+[v1.10] | `:simple_one_for_one` strategy in `Supervisor`      | `DynamicSupervisor` (v1.6)
+[v1.10] | `:restart` and `:shutdown` in `Task.Supervisor.start_link/1` | `:restart` and `:shutdown` in `Task.Supervisor.start_child/3` (v1.6)
+[v1.9]  | Enumerable keys in `Map.drop/2`, `Map.split/2`, and `Map.take/2` | Call `Enum.to_list/1` on the second argument before hand (v1.0)
+[v1.9]  | `Mix.Project.load_paths/1`                          | `Mix.Project.compile_path/1` (v1.0)
+[v1.9]  | Passing `:insert_replaced` to `String.replace/4`    | Use `:binary.replace/4` (v1.0)
+[v1.8]  | Passing a non-empty list to `Collectable.into/1`    | `++/2` or `Keyword.merge/2` (v1.0)
+[v1.8]  | Passing a non-empty list to `:into` in `for/1`      | `++/2` or `Keyword.merge/2` (v1.0)
+[v1.8]  | Passing a non-empty list to `Enum.into/2`           | `++/2` or `Keyword.merge/2` (v1.0)
+[v1.8]  | Time units in its plural form, such as: `:seconds`, `:milliseconds`, and the like | Use the singular form, such as: `:second`, `:millisecond`, and so on (v1.4)
+[v1.8]  | `Inspect.Algebra.surround/3`                        | `Inspect.Algebra.concat/2` and `Inspect.Algebra.nest/2` (v1.0)
+[v1.8]  | `Inspect.Algebra.surround_many/6`                   | `Inspect.Algebra.container_doc/6` (v1.6)
+[v1.9]  | `--detached` in `Kernel.CLI`                        | `--erl "-detached"` (v1.0)
+[v1.8]  | `Kernel.ParallelCompiler.files/2`                   | `Kernel.ParallelCompiler.compile/2` (v1.6)
+[v1.8]  | `Kernel.ParallelCompiler.files_to_path/2`           | `Kernel.ParallelCompiler.compile_to_path/2` (v1.6)
+[v1.8]  | `Kernel.ParallelRequire.files/2`                    | `Kernel.ParallelCompiler.require/2` (v1.6)
+[v1.8]  | Returning `{:ok, contents}` or `:error` from `Mix.Compilers.Erlang.compile/6`'s callback | Return `{:ok, contents, warnings}` or `{:error, errors, warnings}` (v1.6)
+[v1.8]  | `System.cwd/0` and `System.cwd!/0`                  | `File.cwd/0` and `File.cwd!/0` respectively (v1.0)
+[v1.7]  | `Code.get_docs/2`                                   | `Code.fetch_docs/1` (v1.7)
+[v1.7]  | `Enum.chunk/2,3,4`                                  | `Enum.chunk_every/2` and [`Enum.chunk_every/3,4`](`Enum.chunk_every/4`) (v1.5)
+[v1.7]  | Calling `super/1` in`GenServer` callbacks           | Implementing the behaviour explicitly without calling `super/1` (v1.0)
+[v1.7]  | [`not left in right`](`in/2`)                | [`left not in right`](`in/2`) (v1.5)
+[v1.7]  | `Registry.start_link/3`                             | `Registry.start_link/1` (v1.5)
+[v1.7]  | `Stream.chunk/2,3,4`                                | `Stream.chunk_every/2` and [`Stream.chunk_every/3,4`](`Stream.chunk_every/4`) (v1.5)
+[v1.6]  | `Enum.partition/2`                                  | `Enum.split_with/2` (v1.4)
+[v1.6]  | `Macro.unescape_tokens/1,2`                         | Use `Enum.map/2` to traverse over the arguments (v1.0)
+[v1.6]  | `Module.add_doc/6`                                  | [`@doc`](`Module`) module attribute (v1.0)
+[v1.6]  | `Range.range?/1`                                    | Pattern match on [`_.._`](`../2`) (v1.0)
+[v1.5]  | `()` to mean `nil`                                  | `nil` (v1.0)
+[v1.5]  | `char_list/0` type                                  | `t:charlist/0` type (v1.3)
+[v1.5]  | `Atom.to_char_list/1`                               | `Atom.to_charlist/1` (v1.3)
+[v1.5]  | `Enum.filter_map/3`                                 | `Enum.filter/2` + `Enum.map/2` or `for/1` comprehensions (v1.0)
+[v1.5]  | `Float.to_char_list/1`                              | `Float.to_charlist/1` (v1.3)
+[v1.5]  | `GenEvent` module                                   | `Supervisor` and `GenServer` (v1.0)
+[v1.5]  | `<%=` in middle and end expressions in `EEx`        | Use `<%` (`<%=` is allowed only in start expressions) (v1.0)
+[v1.5]  | `:as_char_lists` value in `t:Inspect.Opts.t/0` type | `:as_charlists` value (v1.3)
+[v1.5]  | `:char_lists` key in `t:Inspect.Opts.t/0` type      | `:charlists` key (v1.3)
+[v1.5]  | `Integer.to_char_list/1,2`                          | `Integer.to_charlist/1` and `Integer.to_charlist/2` (v1.3)
+[v1.5]  | `to_char_list/1`                                    | `to_charlist/1` (v1.3)
+[v1.5]  | `List.Chars.to_char_list/1`                         | `List.Chars.to_charlist/1` (v1.3)
+[v1.5]  | `@compile {:parse_transform, _}` in `Module`        | *None*
+[v1.5]  | `Stream.filter_map/3`                               | `Stream.filter/2` + `Stream.map/2` (v1.0)
+[v1.5]  | `String.ljust/3` and `String.rjust/3`               | Use `String.pad_leading/3` and `String.pad_trailing/3` with a binary padding (v1.3)
+[v1.5]  | `String.lstrip/1` and `String.rstrip/1`             | `String.trim_leading/1` and `String.trim_trailing/1` (v1.3)
+[v1.5]  | `String.lstrip/2` and `String.rstrip/2`             | Use `String.trim_leading/2` and `String.trim_trailing/2` with a binary as second argument (v1.3)
+[v1.5]  | `String.strip/1` and `String.strip/2`               | `String.trim/1` and `String.trim/2` (v1.3)
+[v1.5]  | `String.to_char_list/1`                             | `String.to_charlist/1` (v1.3)
+[v1.4]  | Anonymous functions with no expression after `->`   | Use an expression or explicitly return `nil` (v1.0)
+[v1.4]  | Support for making [private functions](`defp/2`) overridable | Use [public functions](`def/2`) (v1.0)
+[v1.4]  | Variable used as function call                      | Use parentheses (v1.0)
+[v1.4]  | `Access.key/1`                                      | `Access.key/2` (v1.3)
+[v1.4]  | `Behaviour` module                                  | `@callback` module attribute (v1.0)
+[v1.4]  | `Enum.uniq/2`                                       | `Enum.uniq_by/2` (v1.2)
+[v1.4]  | `Float.to_char_list/2`                              | `:erlang.float_to_list/2` (Erlang/OTP 17)
+[v1.4]  | `Float.to_string/2`                                 | `:erlang.float_to_binary/2` (Erlang/OTP 17)
+[v1.4]  | `HashDict` module                                   | `Map` (v1.2)
+[v1.4]  | `HashSet` module                                    | `MapSet` (v1.1)
+[v1.4]  | `IEx.Helpers.import_file/2`                         | `IEx.Helpers.import_file_if_available/1` (v1.3)
+[v1.4]  | `Mix.Utils.camelize/1`                              | `Macro.camelize/1` (v1.2)
+[v1.4]  | `Mix.Utils.underscore/1`                            | `Macro.underscore/1` (v1.2)
+[v1.4]  |  Multi-letter aliases in `OptionParser`             | Use single-letter aliases (v1.0)
+[v1.4]  | `Set` module                                        | `MapSet` (v1.1)
+[v1.4]  | `Stream.uniq/2`                                     | `Stream.uniq_by/2` (v1.2)
+[v1.3]  | `\x{X*}` inside strings/sigils/charlists            | `\uXXXX` or `\u{X*}` (v1.1)
+[v1.3]  | `Dict` module                                       | `Keyword` (v1.0) or `Map` (v1.2)
+[v1.3]  | `:append_first` option in `defdelegate/2`           | Define the function explicitly (v1.0)
+[v1.3]  | Map/dictionary as 2nd argument in `Enum.group_by/3` | `Enum.reduce/3` (v1.0)
+[v1.3]  | `Keyword.size/1`                                    | `length/1` (v1.0)
+[v1.3]  | `Map.size/1`                                        | `map_size/1` (v1.0)
+[v1.3]  | `/r` option in `Regex`                              | `/U` (v1.1)
+[v1.3]  | `Set` behaviour                                     | `MapSet` data structure (v1.1)
+[v1.3]  | `String.valid_character?/1`                         | `String.valid?/1` (v1.0)
+[v1.3]  | `Task.find/2`                                       | Use direct message matching (v1.0)
+[v1.3]  | Non-map as 2nd argument in `URI.decode_query/2`     | Use a map (v1.0)
+[v1.2]  | `Dict` behaviour                                    | `Map` and `Keyword` (v1.0)
+[v1.1]  | `?\xHEX`                                            | `0xHEX` (v1.0)
+[v1.1]  | `Access` protocol                                   | `Access` behaviour (v1.1)
+[v1.1]  | `as: true \| false` in `alias/2` and `require/2`    | *None*
+
+[v1.1]: https://github.com/elixir-lang/elixir/blob/v1.1/CHANGELOG.md#4-deprecations
+[v1.2]: https://github.com/elixir-lang/elixir/blob/v1.2/CHANGELOG.md#changelog-for-elixir-v12
+[v1.3]: https://github.com/elixir-lang/elixir/blob/v1.3/CHANGELOG.md#4-deprecations
+[v1.4]: https://github.com/elixir-lang/elixir/blob/v1.4/CHANGELOG.md#4-deprecations
+[v1.5]: https://github.com/elixir-lang/elixir/blob/v1.5/CHANGELOG.md#4-deprecations
+[v1.6]: https://github.com/elixir-lang/elixir/blob/v1.6/CHANGELOG.md#4-deprecations
+[v1.7]: https://github.com/elixir-lang/elixir/blob/v1.7/CHANGELOG.md#4-hard-deprecations
+[v1.8]: https://github.com/elixir-lang/elixir/blob/v1.8/CHANGELOG.md#4-hard-deprecations
+[v1.9]: https://github.com/elixir-lang/elixir/blob/v1.9/CHANGELOG.md#4-hard-deprecations
+[v1.10]: https://github.com/elixir-lang/elixir/blob/v1.10/CHANGELOG.md#4-hard-deprecations
+[v1.11]: https://github.com/elixir-lang/elixir/blob/v1.11/CHANGELOG.md#4-hard-deprecations
+[v1.12]: https://github.com/elixir-lang/elixir/blob/v1.12/CHANGELOG.md#4-hard-deprecations
+[v1.13]: https://github.com/elixir-lang/elixir/blob/v1.13/CHANGELOG.md#4-hard-deprecations
+[v1.14]: https://github.com/elixir-lang/elixir/blob/v1.14/CHANGELOG.md#4-hard-deprecations
+[v1.15]: https://github.com/elixir-lang/elixir/blob/v1.15/CHANGELOG.md#4-hard-deprecations
+[v1.16]: https://github.com/elixir-lang/elixir/blob/v1.16/CHANGELOG.md#4-hard-deprecations
+[v1.17]: https://github.com/elixir-lang/elixir/blob/v1.17/CHANGELOG.md#4-hard-deprecations
+[v1.18]: https://github.com/elixir-lang/elixir/blob/v1.18/CHANGELOG.md#4-hard-deprecations
+[v1.19]: https://github.com/elixir-lang/elixir/blob/v1.19/CHANGELOG.md#4-hard-deprecations
+[v1.20]: https://github.com/elixir-lang/elixir/blob/main/CHANGELOG.md#4-hard-deprecations
diff --git a/lib/elixir/pages/references/gradual-set-theoretic-types.md b/lib/elixir/pages/references/gradual-set-theoretic-types.md
new file mode 100644
index 00000000000..812d3b72352
--- /dev/null
+++ b/lib/elixir/pages/references/gradual-set-theoretic-types.md
@@ -0,0 +1,221 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Gradual set-theoretic types
+
+Elixir is in the process of incorporating set-theoretic types into the compiler. This document outlines the current stage of our implementation for this Elixir version. Elixir's type system is:
+
+  * **sound** - the inferred and assigned by the type system align with the behaviour of the program
+
+  * **gradual** - Elixir's type system includes the `dynamic()` type, which can be used when the type of a variable or expression is checked at runtime. In the absence of `dynamic()`, Elixir's type system behaves as a static one
+
+  * **developer friendly** - the types are described, implemented, and composed using basic set operations: unions, intersections, and negation (hence it is a set-theoretic type system)
+
+The current milestone aims to infer types from existing programs and use them for type checking, enabling the Elixir compiler to find faults and bugs in codebases without requiring changes to existing software. User provided type signatures are planned for future releases. The underlying principles, theory, and roadmap of our work have been outlined in ["The Design Principles of the Elixir Type System" by Giuseppe Castagna, Guillaume Duboc, José Valim](https://arxiv.org/abs/2306.06391).
+
+## A gentle introduction
+
+Types in Elixir are written using the type named followed by parentheses, such as `integer()` or `list(integer())`.
+
+The basic types are:
+
+```elixir
+atom()
+binary()
+empty_list()
+integer()
+float()
+function()
+map()
+non_empty_list(elem_type, tail_type)
+pid()
+port()
+reference()
+tuple()
+```
+
+Many of the types above can also be written more precisely. We will discuss their syntax in the next sections, but here are two examples:
+
+  * While `atom()` represents all atoms, the atom `:ok` can also be represented in the type system as `:ok`
+
+  * While `tuple()` represents all tuples, you can specify the type of a two-element tuple where the first element is the atom `:ok` and the second is an integer as `{:ok, integer()}`
+
+There are also three special types: `none()` (represents an empty set), `term()` (represents all types), `dynamic()` (represents a range of the given types).
+
+Given the types are set-theoretic, we can compose them using unions (`or`), intersections (`and`), and negations (`not`). For example, to say a function returns either atoms or integers, one could write: `atom() or integer()`.
+
+Intersections will find the elements in common between the operands. For example, `atom() and integer()`, which in this case is the empty set `none()`. You can combine intersections and negations to perform difference, for example, to say that a function expects all atoms, except `nil` (which is an atom), you could write: `atom() and not nil`.
+
+You can find a complete reference in the [set-theoretic types cheatsheet](../cheatsheets/types-cheat.cheatmd).
+
+## The syntax of data types
+
+In this section we will cover the syntax of all data types. At the moment, developers will interact with those types mostly through compiler warnings and diagnostics.
+
+### Indivisible types
+
+These types are indivisibile and have no further representation. They are: `binary()`, `integer()`, `float()`, `pid()`, `port()`, `reference()`.  For example, the numbers `1` and `42` are both represented by the type `integer()`.
+
+### Atoms
+
+You can represent all atoms as `atom()`. You can also represent each individual atom using their literal syntax. For instance, the atom `:foo` and `:hello_world` are also valid (distinct) types.
+
+`nil`, `true`, and `false` are also atoms and can be written as is. `boolean()` is a convenience type alias that represents `true or false`.
+
+### Tuples
+
+You can represent all tuples as `tuple()`. Tuples may also be written using the curly brackets syntax, such as `{:ok, binary()}`.
+
+You may use `...` at the end of the tuple to imply the overall size of the tuple is unknown. For example, the following tuple has at least two elements: `{:ok, binary(), ...}`.
+
+### Lists
+
+You can represent all _proper_ lists as `list()`, which also includes the empty list.
+
+You can also specify the type of the list element as argument. For example, `list(integer())` represents the values `[]` and `[1, 2, 3]`, but not `[1, "two", 3]`.
+
+Internally, Elixir represents the type `list(a)` as the union two distinct types, `empty_list()` and `not_empty_list(a)`. In other words, `list(integer())` is equivalent to `empty_list() or non_empty_list(integer())`.
+
+#### Improper lists
+
+While most developers will simply use `list(a)`, the type system can express all different representations of lists in Elixirby passing a second argument to `non_empty_list`, which represents the type of the tail.
+
+A proper list is one where the tail is the empty list itself. The type `non_empty_list(integer())` is equivalent to `non_empty_list(integer(), empty_list())`.
+
+If the `tail_type` is anything but a list, then we have an improper list. For example, the value `[1, 2 | 3]` would have the type `non_empty_list(integer(), integer())`.
+
+If you pass a list type as the tail, then the list type is merged into the element type. For example, `non_empty_list(integer(), list(binary()))` is the same as `non_empty_list(integer() or binary(), empty_list())`.
+
+### Maps
+
+You can represent all maps as `map()`.
+
+Maps may also be written using their literal syntax, such as `%{name: binary(), age: integer()}`, which outlines a map with exactly two keys, `:name` and `:age`, and values of type `binary()` and `integer()` respectively.
+
+A key may be marked as optional using the `if_set/1` operation on its value type. For example, `%{name: binary(), age: if_set(integer())}` is a map that certainly has the `:name` key but it may have the `:age` key (and if it has such key, its value type is `integer()`).
+
+We say the maps above are "closed": they only support the keys explicitly defined. We can also mark a map as "open", by including `...` as its first element.
+
+For example, the type `%{..., name: binary(), age: integer()}` means the keys `:name` and `:age` must exist, with their respective types, but any other key may also be present. In other words, `map()` is the same as `%{...}`. For the empty map, you may write `%{}`, although we recommend using `empty_map()` for clarity.
+
+#### Domain types
+
+In the examples above, all map keys were atoms, but we can also use other types as map keys. For example:
+
+```elixir
+# Closed map
+%{binary() or atom() => integer()}
+
+# Open map
+%{..., binary() or atom() => integer()}
+```
+
+Currently, the type system only tracks the top of each individial type as the domain keys. For example, if you say:
+
+```elixir
+%{list(integer()) => integer(), list(binary()) => binary()}
+```
+
+That's the same as specifying all lists:
+
+```elixir
+%{list() => integer() or binary()}
+```
+
+The supported domain keys are `atom()`, `binary()`, `integer()`, `float()`, `fun()`, `list()`, `map()`, `pid()`, `port()`, `reference()`, and `tuple()`.
+
+Furthermore, it is important to note that domain keys are, by definition, optional. Whenever you have a `%{integer() => integer()}`and you try to fetch a key, we must assume the key may not exist (after all, it is not possible to store all integers as map keys as they are infinite).
+
+#### Mixed keys
+
+It is also possible to mix domain and atom keys. For example, the following map says that all atom keys are of type `binary()`, except the `:root` key, which has type `integer()`:
+
+```elixir
+# Closed map
+%{atom() => binary(), root: integer()}
+
+# Open map
+%{..., atom() => binary(), root: integer()}
+```
+
+The order of the keys is of increasing precision. `:root` is more precise than `atom()`, therefore it comes later. This mirrors the runtime semantics of maps, where duplicate keys override the value of earlier ones.
+
+### Functions
+
+You can represent all functions as `function()`.  However, in practice, most functions are represented as arrows. For example, a function that receives an integer and return boolean would be written as `(integer() -> boolean())`. A function that receives two integers and return a string (i.e. a binary) would be written as `(integer(), integer() -> binary())`.
+
+When representing functions with multiple clauses, which may take different input types, we use intersections. For example, imagine the following function:
+
+```elixir
+def negate(x) when is_integer(x), do: -x
+def negate(x) when is_boolean(x), do: not x
+```
+
+If you give it an integer, it negates it. If you give it a boolean, it negates it.
+
+We can say this function has the type `(integer() -> integer())` because it is capable of receiving an integer and returning an integer. In this case, `(integer() -> integer())` is a set that represents all functions that can receive an integer and return an integer. Even though this function can receive other arguments and return other values, it is still part of the `(integer() -> integer())` set.
+
+This function also has the type `(boolean() -> boolean())`, because it also receives booleans and returns booleans. If you pass the function above to another function that expects `(boolean() -> boolean())`, type checking will succeed. Therefore, we can say the overall type of the function is `(integer() -> integer()) and (boolean() -> boolean())`. The intersection means the function belongs to both sets.
+
+At this point, you may ask, why not a union? As a real-world example, take a t-shirt with green and yellow stripes. We can say the t-shirt belongs to the set of "t-shirts with green color". We can also say the t-shirt belongs to the set of "t-shirts with yellow color". Let's see the difference between unions and intersections:
+
+  * `(t_shirts_with_green() or t_shirts_with_yellow())` - contains t-shirts with either green or yellow, such as green, green and red, green and yellow, but also only yellow, yellow and red, etc.
+
+  * `(t_shirts_with_green() and t_shirts_with_yellow())` - contains t-shirts with both green and yellow (and maybe other colors)
+
+Since the t-shirt has both colors, we could say it belongs to the union of green and yellow t-shirts, but doing so would not capture the fact it is both green and yellow. Therefore it is more precise to say it belongs to the intersection of both sets. The same way that a function that goes from `(integer() -> integer())` and `(boolean() -> boolean())` is also an intersection. In practice, it is not useful to define the union of two functions in Elixir, so the compiler will point you to the right direction if you specify the wrong one.
+
+## The `dynamic()` type
+
+Existing Elixir programs do not have type declarations, but we still want to be able to type check them. This is done with the introduction of the `dynamic()` type.
+
+When Elixir sees the following function:
+
+```elixir
+def negate(x) when is_integer(x), do: -x
+def negate(x) when is_boolean(x), do: not x
+```
+
+Elixir type checks it as if the function had the type `(dynamic() -> dynamic())`. Then, based on patterns and guards, we can refine the value of the variable `x` to be `dynamic() and integer()` and `dynamic() and boolean()` for each clause respectively. We say `dynamic()` is a gradual type, which leads us to _gradual set-theoretic types_.
+
+The simplest way to reason about `dynamic()` in Elixir is that it is a range of types. If you have a type `atom() or integer()`, the underlying code needs to work with both `atom() or integer()`. For example, if you call `Integer.to_string(var)`, and `var` has type `atom() or integer()`, the type system will emit a warning, because `Integer.to_string/1` does not accept atoms.
+
+However, by intersecting a type with `dynamic()`, we make the type gradual and therefore only a subset of the type needs to be valid. For instance, if you call `Integer.to_string(var)`, and `var` has type `dynamic() and (atom() or integer())`, the type system will not emit a warning, because `Integer.to_string/1` works with at least one of the types. For convenience, most programs will write `dynamic(atom() or integer())` instead of the intersection. They are equivalent.
+
+Compared to other gradually typed languages, the `dynamic()` type in Elixir is quite powerful: it restricts our program to certain types, via intersections, while still emitting warnings once it is certain the code will fail. This makes `dynamic()` an excellent tool for typing existing Elixir code with meaningful warnings.
+
+If the user provides their own types, and those types are not `dynamic()`, then Elixir's type system behaves as a statically typed one. This brings us to one last property of dynamic types in Elixir: dynamic types are always at the root. For example, when you write a tuple of type `{:ok, dynamic()}`, Elixir will rewrite it to `dynamic({:ok, term()})`. While this has the downside that you cannot make part of a tuple/map/list gradual, only the whole tuple/map/list, it comes with the upside that dynamic is always explicitly at the root, making it harder to accidentally sneak `dynamic()` in a statically typed program.
+
+## Type inference
+
+Type inference (or reconstruction) is the ability of a type system automatically deduce, either partially or fully, the type of an expression at compile time. Type inference may occur at different levels. For example, many programming languages can automatically infer the types of variables, also known "local type inference", but not all can infer type signatures of functions.
+
+Inferring type signatures comes with a series of trade-offs:
+
+  * Speed - type inference algorithms are often more computationally intensive than type checking algorithms.
+
+  * Expressiveness - in any given type system, the constructs that support inference are always a subset of those that can be type-checked. Therefore, if a programming language is restricted to fully reconstructed types, it is less expressive than a solely type checked counterpart.
+
+  * Incremental compilation - type inference complicates incremental compilation. If module A depends on module B, which depends on module C, a change to C may require the type signature in B to be reconstructed, which may then require A to be recomputed (and so on). This dependency chain may require large projects to explicitly add type signatures for stability and compilation efficiency.
+
+  * Cascading errors - when a user accidentally makes type errors or the code has conflicting assumptions, type inference may lead to less clear error messages as the type system tries to reconcile diverging type assumptions across code paths.
+
+On the other hand, type inference offers the benefit of enabling type checking for functions and codebases without requiring the user to add type annotations. To balance these trade-offs, Elixir aims to provide "module type inference": our goal is to infer the types of functions considering the current module, Elixir's standard library and your dependencies (in the future). Calls to modules within the same project are assumed to be `dynamic()` as to reduce cyclic dependencies and the need for recompilations. Once types are inferred, then the whole project is type checked considering all modules and all types (inferred or otherwise).
+
+Type inference in Elixir is best-effort: it doesn't guarantee it will find all possible type incompatibilities, only that it may find bugs where all combinations of a type _will_ fail, even in the absence of explicit type annotations. It is meant to be an efficient routine that brings developers some benefits of static typing without requiring any effort from them.
+
+In the long term, Elixir developers who want typing guarantees must explicitly add type signatures to their functions (see "Roadmap"). Any function with an explicit type signature will be typed checked against the user-provided annotations, as in other statically typed languages, without performing type inference. In summary, type checking will rely on type signatures and only fallback to inferred types when no signature is available.
+
+## Roadmap
+
+The current milestone is to implement type inference of existing codebases, as well as type checking of all language constructs, without changes to the Elixir language. At this stage, we want to collect feedback on the quality of error messages and performance, and therefore the type system has no user facing API. Full type inference of patterns was released in Elixir v1.18, and complete inference is expected as part of Elixir v1.20.
+
+If the results are satisfactory, the next milestone will include a mechanism for defining typed structs. Elixir programs frequently pattern match on structs, which reveals information about the struct fields, but it knows nothing about their respective types. By propagating types from structs and their fields throughout the program, we will increase the type system’s ability to find errors while further straining our type system implementation. Proposals including the required changes to the language surface will be sent to the community once we reach this stage.
+
+The third milestone is to introduce set-theoretic type signatures for functions. Unfortunately, the existing Erlang Typespecs are not precise enough for set-theoretic types and they will be phased out of the language and have their postprocessing moved into a separate library once this stage concludes.
+
+## Acknowledgements
+
+The type system was made possible thanks to a partnership between [CNRS](https://www.cnrs.fr/) and [Remote](https://remote.com/). The development work is currently sponsored by [Fresha](https://www.fresha.com/), and [Tidewave](https://tidewave.ai/).
diff --git a/lib/elixir/pages/references/library-guidelines.md b/lib/elixir/pages/references/library-guidelines.md
new file mode 100644
index 00000000000..8fdc4457f09
--- /dev/null
+++ b/lib/elixir/pages/references/library-guidelines.md
@@ -0,0 +1,57 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+-->
+
+# Library guidelines
+
+This document outlines general guidelines for those writing and publishing
+Elixir libraries meant to be consumed by other developers.
+
+## Getting started
+
+You can create a new Elixir library by running the `mix new` command:
+
+    $ mix new my_library
+
+The project name is given in the `snake_case` convention where all letters are lowercase and words are separate with underscores. This is the same convention used by variables, function names and atoms in Elixir. See the [Naming Conventions](naming-conventions.md) document for more information.
+
+Every project has a `mix.exs` file, with instructions on how to build, compile, run tests, and so on. Libraries commonly have a `lib` directory, which includes Elixir source code, and a `test` directory. A `src` directory may also exist for Erlang sources.
+
+The `mix new` command also allows the `--sup` option to scaffold a new project with a supervision tree out of the box. For more information on running your project, see the official [Mix & OTP guide](../mix-and-otp/introduction-to-mix.md) or [Mix documentation](`Mix`).
+
+## Publishing
+
+Writing code is only the first of many steps to publish a package. We strongly recommend developers to:
+
+  * Choose a versioning schema. Elixir requires versions to be in the format `MAJOR.MINOR.PATCH` but the meaning of those numbers is up to you. Most projects choose [Semantic Versioning](https://semver.org/).
+
+  * Choose a [license](https://choosealicense.com/). The most common licenses in the Elixir community are the [MIT License](https://choosealicense.com/licenses/mit/) and the [Apache License 2.0](https://choosealicense.com/licenses/apache-2.0/). The latter is also the one used by Elixir itself.
+
+  * Run the [code formatter](`mix format`). The code formatter formats your code according to a consistent style shared by your library and the whole community, making it easier for other developers to understand your code and contribute.
+
+  * Write tests. Elixir ships with a test-framework named [ExUnit](`ExUnit`). The project generated by `mix new` includes sample tests and doctests.
+
+  * Write documentation. The Elixir community is proud of treating documentation as a first-class citizen and making documentation easily accessible. Libraries contribute to the status quo by providing complete API documentation with examples for their modules, types and functions. See the [Writing documentation](../getting-started/writing-documentation.md) chapter of the Getting Started guide for more information. Projects like [ExDoc](https://github.com/elixir-lang/ex_doc) can be used to generate HTML and EPUB documents from the documentation. ExDoc also supports "extra pages", like this one that you are reading. Such pages augment the documentation with tutorials, guides, references, and even cheat-sheets.
+
+  * Follow best practices. The Elixir project documents [a series of anti-patterns](../anti-patterns/what-anti-patterns.md) that you may want to avoid in your code. The [process-related anti-patterns](../anti-patterns/process-anti-patterns.md) and [meta-programming anti-patterns](../anti-patterns/macro-anti-patterns.md) are of special attention to library authors.
+
+Projects are often made available to other developers [by publishing a Hex package](https://hex.pm/docs/publish). Hex also [supports private packages for organizations](https://hex.pm/pricing). If ExDoc is configured for the Mix project, publishing a package on Hex will also automatically publish the generated documentation to [HexDocs](https://hexdocs.pm).
+
+## Dependency handling
+
+When your library is used as a dependency, it runs by default in the `:prod` environment. Therefore, if your library has dependencies that are only useful in development or testing, you want to specify those dependencies with the `:only` option. You can also specify `:optional` dependencies in your library, which are not enforced upon users of your library. In such cases, you should also consider compiling your projects with the `mix compile --no-optional-deps --warnings-as-errors` in your test environments, to ensure your library compiles without warnings even if optional dependencies are missing. See `mix deps` for all available options.
+
+Keep in mind your library's [lockfile](`Mix.Project#module-configuration`) (usually named `mix.lock`) is _ignored by the host project_. Running `mix deps.get` in the host project attempts to get the latest possible versions of your library’s dependencies, as specified by the requirements in the `deps` section of your `mix.exs`. These versions might be greater than those stored in your `mix.lock` (and hence used in your tests / CI).
+
+On the other hand, contributors of your library, need a deterministic build, which implies the presence of `mix.lock` in your Version Control System (VCS), such as `git`.
+
+If you want to validate both scenarios, you should check the `mix.lock` into version control and run two different Continuous Integration (CI) workflows: one that relies on the `mix.lock` for deterministic builds, and another one, that starts with `mix deps.unlock --all` and always compiles your library and runs tests against latest versions of dependencies. The latter one might be even run nightly or otherwise recurrently to stay notified about any possible issue in regard to dependencies updates.
+
+### Dependency Version Requirements
+
+When depending on other libraries, the dependency version requirements are ultimately up to you. However, you should consider the effects that an overly strict dependency requirement can have on users of your library. Most dependencies adopt [Semantic Versioning](https://semver.org/), and therefore provide reasonable guarantees about what each release contains. For instance, if you use `{:some_dep, “== 0.2.3”}`, this prevents users from using any other version but the one that you specified, which means that they cannot receive bug fix upgrades to that package. When in doubt, use a dependency in the format of `"~> x.y"`. This prevents the user from using a higher major version of the library, but allows them to upgrade to newer minor and patch versions, which should only include bug fixes and non-breaking improvements.
+
+The exception to this is pre 1.0 libraries using [Semantic Versioning](https://semver.org/), which provide [no guarantees](https://semver.org/spec/v2.0.0.html#spec-item-4) about what might change from one version to the next. In this scenario, depending on the full patch version, i.e `"~> 0.1.2"` is a better default.
+
+A common mistake is to use a dependency in the format of `"~> x.y.z"` to express "a version greater than `x.y.z`". For example, if you are depending on `"~> 1.2"`, and the dependency publishes a fix in version `1.2.1` that you need for the next version of your library. If you use `"~> 1.2.1"` to express that dependency, you are preventing users from upgrading to `"1.3.0"` or higher! Instead of `"~> 1.2.1"`, you should use `"~> 1.2 and >= 1.2.1"` as the version requirement. This allows users to use any version less than `2.0`, and greater than `1.2.1`.
diff --git a/lib/elixir/pages/references/naming-conventions.md b/lib/elixir/pages/references/naming-conventions.md
new file mode 100644
index 00000000000..aac42e7cc51
--- /dev/null
+++ b/lib/elixir/pages/references/naming-conventions.md
@@ -0,0 +1,147 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
+# Naming conventions
+
+This document is a reference of the naming conventions in Elixir, from casing to punctuation characters.
+
+The naming convention is, by definition, a subset of the Elixir syntax. A convention aims to
+follow and set best practices for language and the community. If instead you want a complete reference into the Elixir syntax, beyond its conventions, see [the Syntax reference](syntax-reference.md).
+
+## Casing
+
+Elixir developers must use `snake_case` when defining variables, function names, module attributes, and the like:
+
+    some_map = %{this_is_a_key: "and a value"}
+    is_map(some_map)
+
+Aliases, commonly used as module names, are an exception as they must be capitalized and written in `CamelCase`, like `OptionParser`. For aliases, capital letters are kept in acronyms, like `ExUnit.CaptureIO` or `Mix.SCM`.
+
+Atoms can be written either in `:snake_case` or `:CamelCase`, although the convention is to use the snake case version throughout Elixir.
+
+Generally speaking, filenames follow the `snake_case` convention of the module they define. For example, `MyApp` should be defined inside the `my_app.ex` file. However, this is only a convention. At the end of the day any filename can be used as they do not affect the compiled code in any way.
+
+## Underscore (`_foo`)
+
+Elixir relies on underscores in different situations.
+
+For example, a value that is not meant to be used must be assigned to `_` or to a variable starting with underscore:
+
+    iex> {:ok, _contents} = File.read("README.md")
+
+Function names may also start with an underscore. Such functions are never imported by default:
+
+    iex> defmodule Example do
+    ...>   def _wont_be_imported do
+    ...>     :oops
+    ...>   end
+    ...> end
+
+    iex> import Example
+    iex> _wont_be_imported()
+    ** (CompileError) iex:1: undefined function _wont_be_imported/0
+
+Due to this property, Elixir relies on functions starting with underscore to attach compile-time metadata to modules. Such functions are most often in the `__foo__` format. For example, every module in Elixir has an [`__info__/1`](`c:Module.__info__/1`) function:
+
+    iex> String.__info__(:functions)
+    [at: 2, capitalize: 1, chunk: 2, ...]
+
+Elixir also includes five special forms that follow the double underscore format: `__CALLER__/0`, `__DIR__/0`, `__ENV__/0`and `__MODULE__/0` retrieve compile-time information about the current environment, while `__STACKTRACE__/0` retrieves the stacktrace for the current exception.
+
+## Trailing bang (`foo!`)
+
+A trailing bang (exclamation mark) signifies a function or macro where failure cases raise an exception. They most often exist as a "raising variant" of a function that returns `:ok`/`:error` tuples (or `nil`).
+
+One example is `File.read/1` and `File.read!/1`. `File.read/1` will return a success or failure tuple, whereas `File.read!/1` will return a plain value or else raise an exception:
+
+    iex> File.read("file.txt")
+    {:ok, "file contents"}
+    iex> File.read("no_such_file.txt")
+    {:error, :enoent}
+
+    iex> File.read!("file.txt")
+    "file contents"
+    iex> File.read!("no_such_file.txt")
+    ** (File.Error) could not read file no_such_file.txt: no such file or directory
+
+The version without `!` is preferred when you want to handle different outcomes using pattern matching:
+
+    case File.read(file) do
+      {:ok, body} -> # do something with the `body`
+      {:error, reason} -> # handle the error caused by `reason`
+    end
+
+However, if you expect the outcome to always be successful (for instance, if you expect the file always to exist), the bang variation can be more convenient and will raise a more helpful error message (than a failed pattern match) on failure.
+
+When thinking about failure cases, we are often thinking about semantic errors related to the operation being performed, such as failing to open a file or trying to fetch key from a map. Errors that come from invalid argument types, or similar, must always raise regardless if the function has a bang or not. In such cases, the exception is often an `ArgumentError` or a detailed `FunctionClauseError`:
+
+    iex(1)> File.read(123)
+    ** (FunctionClauseError) no function clause matching in IO.chardata_to_string/1
+
+        The following arguments were given to IO.chardata_to_string/1:
+
+            # 1
+            123
+
+        Attempted function clauses (showing 2 out of 2):
+
+            def chardata_to_string(string) when is_binary(string)
+            def chardata_to_string(list) when is_list(list)
+
+More examples of paired functions: `Base.decode16/2` and `Base.decode16!/2`, `File.cwd/0` and `File.cwd!/0`. In some situations, you may have bang functions without a non-bang counterpart. They also imply the possibility of errors, such as: `Protocol.assert_protocol!/1` and `PartitionSupervisor.resize!/2`. This can be useful if you foresee the possibility of adding a non-raising variant in the future.
+
+## Trailing question mark (`foo?`)
+
+Functions that return a boolean are named with a trailing question mark.
+
+Examples: `Keyword.keyword?/1`, `Mix.debug?/0`, `String.contains?/2`
+
+However, functions that return booleans and are valid in guards follow another convention, described next.
+
+## `is_` prefix (`is_foo`)
+
+Type checks and other boolean checks that are allowed in guard clauses are named with an `is_` prefix.
+
+Examples: `Integer.is_even/1`, `is_list/1`
+
+These functions and macros follow the Erlang convention of an `is_` prefix, instead of a trailing question mark, precisely to indicate that they are allowed in guard clauses. Type checks that are not valid in guard clauses do not follow this convention, such as `Keyword.keyword?/1`.
+
+A trailing question mark should not be used in combination with the `is_` prefix.
+
+## Special names
+
+Some names have specific meaning in Elixir. We detail those cases below.
+
+### length and size
+
+When you see `size` in a function name, it means the operation runs in constant time (also written as "O(1) time") because the size is stored alongside the data structure.
+
+Examples: `map_size/1`, `tuple_size/1`
+
+When you see `length`, the operation runs in linear time ("O(n) time") because the entire data structure has to be traversed.
+
+Examples: `length/1`, `String.length/1`
+
+In other words, functions using the word "size" in its name will take the same amount of time whether the data structure is tiny or huge. Conversely, functions having "length" in its name will take more time as the data structure grows in size.
+
+### get, fetch, fetch!
+
+When you see the functions `get`, `fetch`, and `fetch!` for key-value data structures, you can expect the following behaviours:
+
+  * `get` returns a default value (which itself defaults to `nil`) if the key is not present, or returns the requested value.
+  * `fetch` returns `:error` if the key is not present, or returns `{:ok, value}` if it is.
+  * `fetch!` *raises* if the key is not present, or returns the requested value.
+
+Examples: `Map.get/2`, `Map.fetch/2`, `Map.fetch!/2`, `Keyword.get/2`, `Keyword.fetch/2`, `Keyword.fetch!/2`
+
+### compare
+
+The function `compare/2` should return `:lt` if the first term is less than the second, `:eq` if the two
+terms compare as equivalent, or `:gt` if the first term is greater than the second.
+
+Examples: `DateTime.compare/2`
+
+Note that this specific convention is important due to the expectations of `Enum.sort/2`
diff --git a/lib/elixir/pages/references/operators.md b/lib/elixir/pages/references/operators.md
new file mode 100644
index 00000000000..99d61bf4e53
--- /dev/null
+++ b/lib/elixir/pages/references/operators.md
@@ -0,0 +1,156 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
+# Operators reference
+
+This document is a complete reference of operators in Elixir, how they are parsed, how they can be defined, and how they can be overridden.
+
+## General operators
+
+Elixir provides the following built-in operators:
+
+  * [`+`](`+/1`) and [`-`](`-/1`) - unary positive/negative
+  * [`+`](`+/2`), [`-`](`-/2`), [`*`](`*/2`), and [`/`](`//2`) - basic arithmetic operations
+  * [`++`](`++/2`) and [`--`](`--/2`) - list concatenation and subtraction
+  * [`and`](`and/2`) and [`&&`](`&&/2`) - strict and relaxed boolean "and"
+  * [`or`](`or/2`) and [`||`](`||/2`) - strict and relaxed boolean "or"
+  * [`not`](`not/1`) and [`!`](`!/1`) - strict and relaxed boolean "not"
+  * [`in`](`in/2`) and [`not in`](`in/2`) - membership
+  * [`@`](`@/1`) - module attribute
+  * [`..`](`../0`), [`..`](`../2`), and [`..//`](`..///3`) - range creation
+  * [`<>`](`<>/2`) - binary concatenation
+  * [`|>`](`|>/2`) - pipeline
+  * [`=~`](`=~/2`) - text-based match
+
+Many of those can be used in guards. Consult the [list of allowed guard functions and operators](patterns-and-guards.md#list-of-allowed-functions-and-operators).
+
+Additionally, there are a few other operators that Elixir parses but doesn't actually use.
+See [Custom and overridden operators](#custom-and-overridden-operators) below for a list and for guidelines about their use.
+
+Some other operators are special forms and cannot be overridden:
+
+  * [`^`](`^/1`) - pin operator
+  * [`.`](`./2`) - dot operator
+  * [`=`](`=/2`) - match operator
+  * [`&`](`&/1`) - capture operator
+  * [`::`](`::/2`) - type operator
+
+Finally, these operators appear in the precedence table below but are only meaningful within certain constructs:
+
+  * `=>` - see [`%{}`](`%{}/1`)
+  * `when` - see [Guards](patterns-and-guards.md#guards)
+  * `<-` - see [`for`](`for/1`) and [`with`](`with/1`)
+  * `\\` - see [Default arguments](`Kernel#def/2-default-arguments`)
+
+## Comparison operators
+
+Elixir provides the following built-in comparison operators (all of which can be used in guards):
+
+  * [`==`](`==/2`) - equal to
+  * [`===`](`===/2`) - strictly equal to
+  * [`!=`](`!=/2`) - not equal to
+  * [`!==`](`!==/2`) - strictly not equal to
+  * [`<`](`</2`) - less-than
+  * [`>`](`>/2`) - greater-than
+  * [`<=`](`<=/2`) - less-than or equal to
+  * [`>=`](`>=/2`) - greater-than or equal to
+
+The only difference between [`==`](`==/2`) and [`===`](`===/2`) is that [`===`](`===/2`) is strict when it comes to comparing integers and floats:
+
+```elixir
+iex> 1 == 1.0
+true
+iex> 1 === 1.0
+false
+```
+
+[`!=`](`!=/2`) and [`!==`](`!==/2`) act as the negation of [`==`](`==/2`) and [`===`](`===/2`), respectively.
+
+## Operator precedence and associativity
+
+The following is a list of all operators that Elixir is capable of parsing, ordered from higher to lower precedence, alongside their associativity:
+
+Operator                                       | Associativity
+---------------------------------------------- | -------------
+`@`                                            | Unary
+`.`                                            | Left
+`+` `-` `!` `^` `not`                          | Unary
+`**`                                           | Left
+`*` `/`                                        | Left
+`+` `-`                                        | Left
+`++` `--` `+++` `---` `..` `<>`                | Right
+`//` (valid only inside `..//`)                | Right
+`in` `not in`                                  | Left
+`\|>` `<<<` `>>>` `<<~` `~>>` `<~` `~>` `<~>`  | Left
+`<` `>` `<=` `>=`                              | Left
+`==` `!=` `=~` `===` `!==`                     | Left
+`&&` `&&&` `and`                               | Left
+`\|\|` `\|\|\|` `or`                           | Left
+`=`                                            | Right
+`&`, `...`                                     | Unary
+`\|`                                           | Right
+`::`                                           | Right
+`when`                                         | Right
+`<-` `\\`                                      | Left
+`=>` (valid only inside `%{}`)                 | None
+
+Elixir also has two ternary operators:
+
+Operator                                       | Associativity
+---------------------------------------------- | -------------
+`first..last//step`                            | Right
+`%{map \| key => value, ...}`                  | None
+
+> #### Deprecated operator precedence {: .info}
+>
+> Elixir parses `not left in right` as `not(left in right)` and `!left in right` as `!(left in right)`, which mismatches the precedence table above, but such behaviour is deprecated and emits a warning. Both constructs must be written as `left not in right` instead. In future major versions, the parser will match the table above.
+
+## Custom and overridden operators
+
+Elixir is capable of parsing a predefined set of operators. It's not possible to define new operators (as supported by some languages). However, not all operators that Elixir can parse are *used* by Elixir: for example, `+` and `||` are used by Elixir for addition and boolean *or*, but `<~>` is not used (but valid).
+
+To define an operator, you can use the usual `def*` constructs (`def`, `defp`, `defmacro`, and so on) but with a syntax similar to how the operator is used:
+
+```elixir
+defmodule MyOperators do
+  # We define ~> to return the maximum of the given two numbers,
+  # and <~ to return the minimum.
+
+  def a ~> b, do: max(a, b)
+  def a <~ b, do: min(a, b)
+end
+```
+
+To use the newly defined operators, you **have to** import the module that defines them:
+
+```elixir
+iex> import MyOperators
+iex> 1 ~> 2
+2
+iex> 1 <~ 2
+1
+```
+
+The following is a table of all the operators that Elixir is capable of parsing, but that are not used by default:
+
+  * `|||`
+  * `&&&`
+  * `<<<`
+  * `>>>`
+  * `<<~`
+  * `~>>`
+  * `<~`
+  * `~>`
+  * `<~>`
+  * `+++`
+  * `---`
+  * `...`
+
+The following operators are used by the `Bitwise` module when imported: [`&&&`](`Bitwise.&&&/2`), [`<<<`](`Bitwise.<<</2`), [`>>>`](`Bitwise.>>>/2`), and [`|||`](`Bitwise.|||/2`). See the `Bitwise` documentation for more information.
+
+Note that the Elixir community generally discourages custom operators. They can be hard to read and even more to understand, as they don't have a descriptive name like functions do. That said, some specific cases or custom domain specific languages (DSLs) may justify these practices.
+
+It is also possible to replace predefined operators, such as `+`, but doing so is extremely discouraged.
diff --git a/lib/elixir/pages/references/patterns-and-guards.md b/lib/elixir/pages/references/patterns-and-guards.md
new file mode 100644
index 00000000000..af9dc0866c7
--- /dev/null
+++ b/lib/elixir/pages/references/patterns-and-guards.md
@@ -0,0 +1,528 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
+# Patterns and guards
+
+Elixir provides pattern matching, which allows us to assert on the shape or extract values from data structures. Patterns are often augmented with guards, which give developers the ability to perform more complex checks, albeit limited.
+
+This document provides a complete reference on patterns and guards, their semantics, where they are allowed, and how to extend them.
+
+## Patterns
+
+Patterns in Elixir are made of variables, literals, and data structure specific syntax. One of the most used constructs to perform pattern matching is the match operator ([`=`](`=/2`)):
+
+```iex
+iex> x = 1
+1
+iex> 1 = x
+1
+```
+
+In the example above, `x` starts without a value and has `1` assigned to it. Then, we compare the value of `x` to the literal `1`, which succeeds as they are both `1`.
+
+Matching `x` against 2 would raise:
+
+```iex
+iex> 2 = x
+** (MatchError) no match of right hand side value: 1
+```
+
+Patterns are not bidirectional. If you have a variable `y` that was never assigned to (often called an unbound variable) and you write `1 = y`, an error will be raised:
+
+```iex
+iex> 1 = y
+** (CompileError) iex:2: undefined variable "y"
+```
+
+In other words, patterns are allowed only on the left side of `=`. The right side of `=` follows the regular evaluation semantics of the language.
+
+Now let's cover the pattern matching rules for each construct and then for each relevant data types.
+
+### Variables
+
+Variables in patterns are always assigned to:
+
+```iex
+iex> x = 1
+1
+iex> x = 2
+2
+iex> x
+2
+```
+
+In other words, Elixir supports rebinding. In case you don't want the value of a variable to change, you can use the pin operator (`^`):
+
+```iex
+iex> x = 1
+1
+iex> ^x = 2
+** (MatchError) no match of right hand side value: 2
+```
+
+If the same variable appears multiple times in the same pattern, then all of them must be bound to the same value:
+
+```iex
+iex> {x, x} = {1, 1}
+{1, 1}
+iex> {x, x} = {1, 2}
+** (MatchError) no match of right hand side value: {1, 2}
+```
+
+The underscore variable (`_`) has a special meaning as it can never be bound to any value. It is especially useful when you don't care about certain value in a pattern:
+
+```iex
+iex> {_, integer} = {:not_important, 1}
+{:not_important, 1}
+iex> integer
+1
+iex> _
+** (CompileError) iex:3: invalid use of _
+```
+
+A pinned value represents the value itself and not its – even if syntactically equal – pattern. The right hand side is compared to be equal to the pinned value:
+
+```iex
+iex> x = %{}
+%{}
+iex> {:ok, %{}} = {:ok, %{a: 13}}
+{:ok, %{a: 13}}
+iex> {:ok, ^x} = {:ok, %{a: 13}}
+** (MatchError) no match of right hand side value: {:ok, %{a: 13}}
+    (stdlib 6.2) erl_eval.erl:667: :erl_eval.expr/6
+    iex:2: (file)
+```
+
+### Literals (numbers and atoms)
+
+Atoms and numbers (integers and floats) can appear in patterns and they are always represented as is. For example, an atom will only match an atom if they are the same atom:
+
+```iex
+iex> :atom = :atom
+:atom
+iex> :atom = :another_atom
+** (MatchError) no match of right hand side value: :another_atom
+```
+
+Similar rule applies to numbers. Finally, note that numbers in patterns perform strict comparison. In other words, integers to do not match floats:
+
+```iex
+iex> 1 = 1.0
+** (MatchError) no match of right hand side value: 1.0
+```
+
+### Tuples
+
+Tuples may appear in patterns using the curly brackets syntax (`{}`). A tuple in a pattern will match only tuples of the same size, where each individual tuple element must also match:
+
+```iex
+iex> {:ok, integer} = {:ok, 13}
+{:ok, 13}
+
+# won't match due to different size
+iex> {:ok, integer} = {:ok, 11, 13}
+** (MatchError) no match of right hand side value: {:ok, 11, 13}
+
+# won't match due to mismatch on first element
+iex> {:ok, binary} = {:error, :enoent}
+** (MatchError) no match of right hand side value: {:error, :enoent}
+```
+
+### Lists
+
+Lists may appear in patterns using the square brackets syntax (`[]`). A list in a pattern will match only lists of the same size, where each individual list element must also match:
+
+```iex
+iex> [:ok, integer] = [:ok, 13]
+[:ok, 13]
+
+# won't match due to different size
+iex> [:ok, integer] = [:ok, 11, 13]
+** (MatchError) no match of right hand side value: [:ok, 11, 13]
+
+# won't match due to mismatch on first element
+iex> [:ok, binary] = [:error, :enoent]
+** (MatchError) no match of right hand side value: [:error, :enoent]
+```
+
+Opposite to tuples, lists also allow matching on non-empty lists by using the `[head | tail]` notation, which matches on the `head` and `tail` of a list:
+
+```iex
+iex> [head | tail] = [1, 2, 3]
+[1, 2, 3]
+iex> head
+1
+iex> tail
+[2, 3]
+```
+
+Multiple elements may prefix the `| tail` construct:
+
+```iex
+iex> [first, second | tail] = [1, 2, 3]
+[1, 2, 3]
+iex> tail
+[3]
+```
+
+Note `[head | tail]` does not match empty lists:
+
+```elixir
+iex> [head | tail] = []
+** (MatchError) no match of right hand side value: []
+```
+
+Given charlists are represented as a list of integers, one can also perform prefix matches on charlists using the list concatenation operator ([`++`](`++/2`)):
+
+```elixir
+iex> ~c"hello " ++ world = ~c"hello world"
+~c"hello world"
+iex> world
+~c"world"
+```
+
+Which is equivalent to matching on `[?h, ?e, ?l, ?l, ?o, ?\s | world]`. Suffix matches (`hello ++ ~c" world"`) are not valid patterns.
+
+### Maps
+
+Maps may appear in patterns using the percentage sign followed by the curly brackets syntax (`%{}`). Opposite to lists and tuples, maps perform a subset match. This means a map pattern will match any other map that has at least all of the keys in the pattern.
+
+Here is an example where all keys match:
+
+```iex
+iex> %{name: name} = %{name: "meg"}
+%{name: "meg"}
+iex> name
+"meg"
+```
+
+Here is when a subset of the keys match:
+
+```iex
+iex> %{name: name} = %{name: "meg", age: 23}
+%{age: 23, name: "meg"}
+iex> name
+"meg"
+```
+
+If a key in the pattern is not available in the map, then they won't match:
+
+```iex
+iex> %{name: name, age: age} = %{name: "meg"}
+** (MatchError) no match of right hand side value: %{name: "meg"}
+```
+
+Note that the empty map will match all maps, which is a contrast to tuples and lists, where an empty tuple or an empty list will only match empty tuples and empty lists respectively:
+
+```iex
+iex> %{} = %{name: "meg"}
+%{name: "meg"}
+```
+
+Finally, note map keys in patterns must always be literals or previously bound variables matched with the pin operator.
+
+### Structs
+
+Structs may appear in patterns using the percentage sign, the struct module name or a variable followed by the curly brackets syntax (`%{}`).
+
+Given the following struct:
+
+```elixir
+defmodule User do
+  defstruct [:name]
+end
+```
+
+Here is an example where all keys match:
+
+```iex
+iex> %User{name: name} = %User{name: "meg"}
+%User{name: "meg"}
+iex> name
+"meg"
+```
+
+If an unknown key is given, the compiler will raise an error:
+
+```iex
+iex> %User{type: type} = %User{name: "meg"}
+** (CompileError) iex: unknown key :type for struct User
+```
+
+The struct name can be extracted when putting a variable instead of a module name:
+
+```elixir
+iex> %struct_name{} = %User{name: "meg"}
+%User{name: "meg"}
+iex> struct_name
+User
+```
+
+### Binaries
+
+Binaries may appear in patterns using the double less-than/greater-than syntax ([`<<>>`](`<<>>/1`)). A binary in a pattern can match multiple segments at the same time, each with different type, size, and unit:
+
+```iex
+iex> <<val::unit(8)-size(2)-integer>> = <<123, 56>>
+"{8"
+iex> val
+31544
+```
+
+See the documentation for [`<<>>`](`<<>>/1`) for a complete definition of pattern matching for binaries.
+
+Finally, remember that strings in Elixir are UTF-8 encoded binaries. This means that, similar to charlists, prefix matches on strings are also possible with the binary concatenation operator ([`<>`](`<>/2`)):
+
+```elixir
+iex> "hello " <> world = "hello world"
+"hello world"
+iex> world
+"world"
+```
+
+Suffix matches (`hello <> " world"`) are not valid patterns.
+
+## Guards
+
+Guards are a way to augment pattern matching with more complex checks. They are allowed in a predefined set of constructs where pattern matching is allowed, such as function definitions, case clauses, and others.
+
+Not all expressions are allowed in guard clauses, but only a handful of them. This is a deliberate choice. This way, Elixir (through Erlang) ensures that all guards are predictable (no mutations or other side-effects) and they can be optimized and performed efficiently.
+
+### List of allowed functions and operators
+
+You can find the built-in list of guards [in the `Kernel` module](`Kernel#guards`). Here is an overview:
+
+  * comparison operators ([`==`](`==/2`), [`!=`](`!=/2`), [`===`](`===/2`), [`!==`](`!==/2`),
+    [`<`](`</2`), [`<=`](`<=/2`), [`>`](`>/2`), [`>=`](`>=/2`)), [`max`](`max/2`), [`min`](`min/2`)
+  * strictly boolean operators ([`and`](`and/2`), [`or`](`or/2`), [`not`](`not/1`)). Note [`&&`](`&&/2`), [`||`](`||/2`), and [`!`](`!/1`) sibling operators are **not allowed** as they're not *strictly* boolean - meaning they don't require arguments to be booleans
+  * arithmetic unary operators ([`+`](`+/1`), [`-`](`-/1`))
+  * arithmetic binary operators ([`+`](`+/2`), [`-`](`-/2`), [`*`](`*/2`), [`/`](`//2`))
+  * [`in`](`in/2`) and [`not in`](`in/2`) operators (as long as the right-hand side is a list or a range)
+  * "type-check" functions (`is_list/1`, `is_number/1`, and the like)
+  * functions that work on built-in data types (`abs/1`, `hd/1`, `map_size/1`, and others)
+  * the `map.field` syntax
+
+The module `Bitwise` also includes a handful of [Erlang bitwise operations as guards](Bitwise.html#guards).
+
+Macros constructed out of any combination of the above guards are also valid guards - for example, `Integer.is_even/1`. For more information, see the "Custom patterns and guards expressions" section shown below.
+
+### Why guards
+
+Let's see an example of a guard used in a function clause:
+
+```elixir
+def empty_map?(map) when map_size(map) == 0, do: true
+def empty_map?(map) when is_map(map), do: false
+```
+
+Guards start with the `when` operator, followed by a guard expression. The clause will be executed if and only if the guard expression returns `true`. Multiple boolean conditions can be combined with the [`and`](`and/2`) and [`or`](`or/2`) operators.
+
+Writing the `empty_map?/1` function by only using pattern matching would not be possible (as pattern matching on `%{}` would match *any* map, not only the empty ones).
+
+### Non-passing guards
+
+A function clause will be executed if and only if its guard expression evaluates to `true`. If any other value is returned, the function clause will be skipped. In particular, guards have no concept of "truthy" or "falsy".
+
+For example, imagine a function that checks that the head of a list is not `nil`:
+
+```elixir
+def not_nil_head?([head | _]) when head, do: true
+def not_nil_head?(_), do: false
+
+not_nil_head?(["some_value", "another_value"])
+#=> false
+```
+
+Even though the head of the list is not `nil`, the first clause for `not_nil_head?/1` fails because the expression does not evaluate to `true`, but to `"some_value"`, therefore triggering the second clause which returns `false`. To make the guard behave correctly, you must ensure that the guard evaluates to `true`, like so:
+
+```elixir
+def not_nil_head?([head | _]) when head != nil, do: true
+def not_nil_head?(_), do: false
+
+not_nil_head?(["some_value", "another_value"])
+#=> true
+```
+
+### Errors in guards
+
+In guards, when functions would normally raise exceptions, they cause the guard to fail instead.
+
+For example, the `tuple_size/1` function only works with tuples. If we use it with anything else, an argument error is raised:
+
+```elixir
+iex> tuple_size("hello")
+** (ArgumentError) argument error
+```
+
+However, when used in guards, the corresponding clause will fail to match instead of raising an error:
+
+```elixir
+iex> case "hello" do
+...>   something when tuple_size(something) == 2 ->
+...>     :worked
+...>   _anything_else ->
+...>     :failed
+...> end
+:failed
+```
+
+In many cases, we can take advantage of this. In the code above, we used `tuple_size/1` to both check that the given value is a tuple *and* check its size (instead of using `is_tuple(something) and tuple_size(something) == 2`).
+
+However, if your guard has multiple conditions, such as checking for tuples or maps, it is best to call type-check functions like `is_tuple/1` before `tuple_size/1`, otherwise the whole guard will fail if a tuple is not given. Alternatively, your function clause can use multiple guards as shown in the following section.
+
+### Multiple guards in the same clause
+
+There exists an additional way to simplify a chain of `or` expressions in guards: Elixir supports writing "multiple guards" in the same clause. The following code:
+
+```elixir
+def categorize_number(term) when is_integer(term) or is_float(term) or is_nil(term),
+  do: :maybe_number
+def categorize_number(_other),
+  do: :something_else
+```
+
+can be alternatively written as:
+
+```elixir
+def categorize_number(term)
+    when is_integer(term)
+    when is_float(term)
+    when is_nil(term) do
+  :maybe_number
+end
+
+def categorize_number(_other) do
+  :something_else
+end
+```
+
+If each guard expression always returns a boolean, the two forms are equivalent. However, recall that if any function call in a guard raises an exception, the entire guard fails. To illustrate this, the following function will not detect empty tuples:
+
+```elixir
+defmodule Check do
+  # If given a tuple, map_size/1 will raise, and tuple_size/1 will not be evaluated
+  def empty?(val) when map_size(val) == 0 or tuple_size(val) == 0, do: true
+  def empty?(_val), do: false
+end
+
+Check.empty?(%{})
+#=> true
+
+Check.empty?({})
+#=> false # true was expected!
+```
+
+This could be corrected by ensuring that no exception is raised, either via type checks like `is_map(val) and map_size(val) == 0`, or by using multiple guards, so that if an exception causes one guard to fail, the next one is evaluated.
+
+```elixir
+defmodule Check do
+  # If given a tuple, map_size/1 will raise, and the second guard will be evaluated
+  def empty?(val)
+      when map_size(val) == 0
+      when tuple_size(val) == 0,
+      do: true
+
+  def empty?(_val), do: false
+end
+
+Check.empty?(%{})
+#=> true
+
+Check.empty?({})
+#=> true
+```
+
+## Where patterns and guards can be used
+
+In the examples above, we have used the match operator ([`=`](`=/2`)) and function clauses to showcase patterns and guards respectively. Here is the list of the built-in constructs in Elixir that support patterns and guards.
+
+  * `match?/2`:
+
+    ```elixir
+    match?({:ok, value} when value > 0, {:ok, 13})
+    ```
+
+  * function clauses:
+
+    ```elixir
+    def type(term) when is_integer(term), do: :integer
+    def type(term) when is_float(term), do: :float
+    ```
+
+  * [`case`](`case/2`) expressions:
+
+    ```elixir
+    case x do
+      1 -> :one
+      2 -> :two
+      n when is_integer(n) and n > 2 -> :larger_than_two
+    end
+    ```
+
+  * anonymous functions (`fn/1`):
+
+    ```elixir
+    larger_than_two? = fn
+      n when is_integer(n) and n > 2 -> true
+      n when is_integer(n) -> false
+    end
+    ```
+
+  * [`for`](`for/1`) and [`with`](`with/1`) support patterns and guards on the left side of `<-`:
+
+    ```elixir
+    for x when x >= 0 <- [1, -2, 3, -4], do: x
+    ```
+
+    `with` also supports the `else` keyword, which supports patterns matching and guards.
+
+  * [`try`](`try/1`) supports patterns and guards on `catch` and `else`
+
+  * [`receive`](`receive/1`) supports patterns and guards to match on the received messages.
+
+  * custom guards can also be defined with `defguard/1` and `defguardp/1`. A custom guard can only be defined based on existing guards.
+
+Note that the match operator ([`=`](`=/2`)) does *not* support guards:
+
+```elixir
+{:ok, binary} = File.read("some/file")
+```
+
+## Custom patterns and guards expressions
+
+Only the constructs listed in this page are allowed in patterns and guards. However, we can take advantage of macros to write custom patterns guards that can simplify our programs or make them more domain-specific. At the end of the day, what matters is that the *output* of the macros boils down to a combination of the constructs above.
+
+For example, the `Record` module in Elixir provides a series of macros to be used in patterns and guards that allows tuples to have named fields during compilation.
+
+For defining your own guards, Elixir even provides conveniences in `defguard` and `defguardp`. Let's look at a quick case study: we want to check whether an argument is an even or an odd integer. With pattern matching this is impossible because there is an infinite number of integers, and therefore we can't pattern match on every single one of them. Therefore we must use guards. We will just focus on checking for even numbers since checking for the odd ones is almost identical.
+
+Such a guard would look like this:
+
+```elixir
+def my_function(number) when is_integer(number) and rem(number, 2) == 0 do
+  # do stuff
+end
+```
+
+It would be repetitive to write every time we need this check. Instead, you can use `defguard/1` and `defguardp/1` to create guard macros. Here's an example how:
+
+```elixir
+defmodule MyInteger do
+  defguard is_even(term) when is_integer(term) and rem(term, 2) == 0
+end
+```
+
+and then:
+
+```elixir
+import MyInteger, only: [is_even: 1]
+
+def my_function(number) when is_even(number) do
+  # do stuff
+end
+```
+
+While it's possible to create custom guards with macros, it's recommended to define them using `defguard/1` and `defguardp/1` which perform additional compile-time checks.
diff --git a/lib/elixir/pages/references/syntax-reference.md b/lib/elixir/pages/references/syntax-reference.md
new file mode 100644
index 00000000000..c658b2bb2ba
--- /dev/null
+++ b/lib/elixir/pages/references/syntax-reference.md
@@ -0,0 +1,432 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
+# Syntax reference
+
+Elixir syntax was designed to have a straightforward conversion to an abstract syntax tree (AST). This means the Elixir syntax is mostly uniform with a handful of "syntax sugar" constructs to reduce the noise in common Elixir idioms.
+
+This document covers all of Elixir syntax constructs as a reference and then discuss their exact AST representation.
+
+## Reserved words
+
+These are the reserved words in the Elixir language. They are detailed throughout this guide but summed up here for convenience:
+
+  * `true`, `false`, `nil` - used as atoms
+  * `when`, `and`, `or`, `not`, `in` - used as operators
+  * `fn` - used for anonymous function definitions
+  * `do`, `end`, `catch`, `rescue`, `after`, `else` - used in do-end blocks
+
+## Data types
+
+### Numbers
+
+Integers (`1234`) and floats (`123.4`) in Elixir are represented as a sequence of digits that may be separated by underscore for readability purposes, such as `1_000_000`. Integers never contain a dot (`.`) in their representation. Floats contain a dot and at least one other digit after the dot. Floats also support the scientific notation, such as `123.4e10` or `123.4E10`.
+
+### Atoms
+
+Unquoted atoms start with a colon (`:`) which must be immediately followed by a Unicode letter or an underscore. The atom may continue using a sequence of Unicode letters, numbers, underscores, and `@`. Atoms may end in `!` or `?`. Valid unquoted atoms are: `:ok`, `:ISO8601`, and `:integer?`.
+
+If the colon is immediately followed by a pair of double- or single-quotes surrounding the atom name, the atom is considered quoted. In contrast with an unquoted atom, this one can be made of any Unicode character (not only letters), such as `:'🌢 Elixir'`, `:"++olá++"`, and `:"123"`.
+
+Quoted and unquoted atoms with the same name are considered equivalent, so `:atom`, `:"atom"`, and `:'atom'` represent the same atom. The only catch is that the compiler will warn when quotes are used in atoms that do not need to be quoted.
+
+All operators in Elixir are also valid atoms. Valid examples are `:foo`, `:FOO`, `:foo_42`, `:foo@bar`, and `:++`. Invalid examples are `:@foo` (`@` is not allowed at start), `:123` (numbers are not allowed at start), and `:(*)` (not a valid operator).
+
+`true`, `false`, and `nil` are reserved words that are represented by the atoms `:true`, `:false` and `:nil` respectively.
+
+To learn more about all Unicode characters allowed in atom, see the [Unicode syntax](unicode-syntax.md) document.
+
+### Strings
+
+Single-line strings in Elixir are written between double-quotes, such as `"foo"`. Any double-quote inside the string must be escaped with `\ `. Strings support Unicode characters and are stored as UTF-8 encoded binaries.
+
+Multi-line strings in Elixir are called heredocs. They are written with three double-quotes, and can have unescaped quotes within them. The resulting string will end with a newline. The indentation of the last `"""` is used to strip indentation from the inner string. For example:
+
+```elixir
+iex> test = """
+...>     this
+...>     is
+...>     a
+...>     test
+...> """
+"    this\n    is\n    a\n    test\n"
+iex> test = """
+...>     This
+...>     Is
+...>     A
+...>     Test
+...>     """
+"This\nIs\nA\nTest\n"
+```
+
+Strings are always represented as themselves in the AST.
+
+### Charlists
+
+Charlists are lists of non-negative integers where each integer represents a Unicode code point.
+
+```elixir
+iex(6)> 'abc' === [97, 98, 99]
+true
+```
+
+Charlists are written in single-quotes, such as `'foo'`. Any single-quote inside the string must be escaped with `\ `.
+Multi-line charlists are written with three single-quotes (`'''`), the same way multi-line strings are.
+However, this syntax is deprecated in favor of the charlist sigil `~c`.
+
+Charlists are always represented as themselves in the AST.
+
+For more in-depth information, please read the "Charlists" section in the `List` module.
+
+### Lists, tuples and binaries
+
+Data structures such as lists, tuples, and binaries are marked respectively by the delimiters `[...]`, `{...}`, and `<<...>>`. Each element is separated by comma. A trailing comma is also allowed, such as in `[1, 2, 3,]`.
+
+### Maps and keyword lists
+
+Maps use the `%{...}` notation and each key-value is given by pairs marked with `=>`, such as `%{"hello" => 1, 2 => "world"}`.
+
+Both keyword lists (list of two-element tuples where the first element is an atom) and maps with atom keys support a keyword notation where the colon character `:` is moved to the end of the atom. `%{hello: "world"}` is equivalent to `%{:hello => "world"}` and `[foo: :bar]` is equivalent to `[{:foo, :bar}]`. We discuss keywords in later sections.
+
+### Structs
+
+Structs built on the map syntax by passing the struct name between `%` and `{`. For example, `%User{...}`.
+
+## Expressions
+
+### Variables
+
+Variables in Elixir must start with an underscore or a Unicode letter that is not in uppercase or titlecase. The variable may continue using a sequence of Unicode letters, numbers, and underscores. Variables may end in `?` or `!`. To learn more about all Unicode characters allowed in variables, see the [Unicode syntax](unicode-syntax.md) document.
+
+[Elixir's naming conventions](naming-conventions.md) recommend variables to be in `snake_case` format.
+
+### Non-qualified calls (local calls)
+
+Non-qualified calls, such as `add(1, 2)`, must start with characters and then follow the same rules as variables, which are optionally followed by parentheses, and then arguments.
+
+Parentheses are required for zero-arity calls (i.e. calls without arguments), to avoid ambiguity with variables. If parentheses are used, they must immediately follow the function name *without spaces*. For example, `add (1, 2)` is a syntax error, since `(1, 2)` is treated as an invalid block which is attempted to be given as a single argument to `add`.
+
+[Elixir's naming conventions](naming-conventions.md) recommend calls to be in `snake_case` format.
+
+### Operators
+
+As many programming languages, Elixir also support operators as non-qualified calls with their precedence and associativity rules. Constructs such as `=`, `when`, `&` and `@` are simply treated as operators. See [the Operators page](operators.md) for a full reference.
+
+### Qualified calls (remote calls)
+
+Qualified calls, such as `Math.add(1, 2)`, must start with characters and then follow the same rules as variables, which are optionally followed by parentheses, and then arguments. Qualified calls also support operators, such as `Kernel.+(1, 2)`. Elixir also allows the function name to be written between double- or single-quotes, allowing any character in between the quotes, such as `Math."++add++"(1, 2)`.
+
+Similar to non-qualified calls, parentheses have different meaning for zero-arity calls (i.e. calls without arguments). If parentheses are used, such as `mod.fun()`, it means a function call. If parenthesis are skipped, such as `map.field`, it means accessing a field of a map.
+
+[Elixir's naming conventions](naming-conventions.md) recommend calls to be in `snake_case` format.
+
+### Aliases
+
+Aliases are constructs that expand to atoms at compile-time. The alias `String` expands to the atom `:"Elixir.String"`. Aliases must start with an ASCII uppercase character which may be followed by any ASCII letter, number, or underscore. Non-ASCII characters are not supported in aliases.
+
+Multiple aliases can be joined with `.`, such as `MyApp.String`, and it expands to the atom `:"Elixir.MyApp.String"`. The dot is effectively part of the name but it can also be used for composition. If you define `alias MyApp.Example, as: Example` in your code, then `Example` will always expand to `:"Elixir.MyApp.Example"` and `Example.String` will expand to `:"Elixir.MyApp.Example.String"`.
+
+[Elixir's naming conventions](naming-conventions.md) recommend aliases to be in `CamelCase` format.
+
+### Module attributes
+
+Module attributes are module-specific storage and are written as the composition of the unary operator `@` with variables and local calls. For example, to write to a module attribute named `foo`, use `@foo "value"`, and use `@foo` to read from it. Given module attributes are written using existing constructs, they follow the same rules above defined for operators, variables, and local calls.
+
+### Blocks
+
+Blocks are multiple Elixir expressions separated by newlines or semi-colons. A new block may be created at any moment by using parentheses.
+
+### Left to right arrow
+
+The left to right arrow (`->`) is used to establish a relationship between left and right, commonly referred as clauses. The left side may have zero, one, or more arguments; the right side is zero, one, or more expressions separated by new line. The `->` may appear one or more times between one of the following terminators: `do`-`end`, `fn`-`end` or `(`-`)`. When `->` is used, only other clauses are allowed between those terminators. Mixing clauses and regular expressions is invalid syntax.
+
+It is seen on `case` and `cond` constructs between `do` and `end`:
+
+```elixir
+case 1 do
+  2 -> 3
+  4 -> 5
+end
+
+cond do
+  true -> false
+end
+```
+
+Seen in typespecs between `(` and `)`:
+
+```elixir
+(integer(), boolean() -> integer())
+```
+
+It is also used between `fn` and `end` for building anonymous functions:
+
+```elixir
+fn
+  x, y -> x + y
+end
+```
+
+### Sigils
+
+Sigils start with `~` and are followed by one lowercase letter or by one or more uppercase letters, immediately followed by one of the following pairs:
+
+  * `(` and `)`
+  * `{` and `}`
+  * `[` and `]`
+  * `<` and `>`
+  * `"` and `"`
+  * `'` and `'`
+  * `|` and `|`
+  * `/` and `/`
+
+After closing the pair, zero or more ASCII letters and digits can be given as a modifier. Sigils are expressed as non-qualified calls prefixed with `sigil_` where the first argument is the sigil contents as a string and the second argument is a list of integers as modifiers:
+
+If the sigil letter is in uppercase, no interpolation is allowed in the sigil, otherwise its contents may be dynamic. Compare the results of the sigils below for more information:
+
+```elixir
+~s/f#{"o"}o/
+~S/f#{"o"}o/
+```
+
+Sigils are useful to encode text with their own escaping rules, such as regular expressions, datetimes, and others.
+
+## The Elixir AST
+
+Elixir syntax was designed to have a straightforward conversion to an abstract syntax tree (AST). Elixir's AST is a regular Elixir data structure composed of the following elements:
+
+  * atoms - such as `:foo`
+  * integers - such as `42`
+  * floats - such as `13.1`
+  * strings - such as `"hello"`
+  * lists - such as `[1, 2, 3]`
+  * tuples with two elements - such as `{"hello", :world}`
+  * tuples with three elements, representing calls or variables, as explained next
+
+The building block of Elixir's AST is a call, such as:
+
+```elixir
+sum(1, 2, 3)
+```
+
+which is represented as a tuple with three elements:
+
+```elixir
+{:sum, meta, [1, 2, 3]}
+```
+
+the first element is an atom (or another tuple), the second element is a list of two-element tuples with metadata (such as line numbers) and the third is a list of arguments.
+
+We can retrieve the AST for any Elixir expression by calling `quote`:
+
+```elixir
+quote do
+  sum()
+end
+#=> {:sum, [], []}
+```
+
+Variables are also represented using a tuple with three elements and a combination of lists and atoms, for example:
+
+```elixir
+quote do
+  sum
+end
+#=> {:sum, [], Elixir}
+```
+
+You can see that variables are also represented with a tuple, except the third element is an atom expressing the variable context.
+
+Over the course of this section, we will explore many Elixir syntax constructs alongside their AST representations.
+
+### Operators
+
+Operators are treated as non-qualified calls:
+
+```elixir
+quote do
+  1 + 2
+end
+#=> {:+, [], [1, 2]}
+```
+
+Note that `.` is also an operator. Remote calls use the dot in the AST with two arguments, where the second argument is always an atom:
+
+```elixir
+quote do
+  foo.bar(1, 2, 3)
+end
+#=> {{:., [], [{:foo, [], Elixir}, :bar]}, [], [1, 2, 3]}
+```
+
+Calling anonymous functions uses the dot in the AST with a single argument, mirroring the fact the function name is "missing" from right side of the dot:
+
+```elixir
+quote do
+  foo.(1, 2, 3)
+end
+#=> {{:., [], [{:foo, [], Elixir}]}, [], [1, 2, 3]}
+```
+
+### Aliases
+
+Aliases are represented by an `__aliases__` call with each segment separated by a dot as an argument:
+
+```elixir
+quote do
+  Foo.Bar.Baz
+end
+#=> {:__aliases__, [], [:Foo, :Bar, :Baz]}
+
+quote do
+  __MODULE__.Bar.Baz
+end
+#=> {:__aliases__, [], [{:__MODULE__, [], Elixir}, :Bar, :Baz]}
+```
+
+All arguments, except the first, are guaranteed to be atoms.
+
+### Data structures
+
+Remember that lists are literals, so they are represented as themselves in the AST:
+
+```elixir
+quote do
+  [1, 2, 3]
+end
+#=> [1, 2, 3]
+```
+
+Tuples have their own representation, except for two-element tuples, which are represented as themselves:
+
+```elixir
+quote do
+  {1, 2}
+end
+#=> {1, 2}
+
+quote do
+  {1, 2, 3}
+end
+#=> {:{}, [], [1, 2, 3]}
+```
+
+Binaries have a representation similar to tuples, except they are tagged with `:<<>>` instead of `:{}`:
+
+```elixir
+quote do
+  <<1, 2, 3>>
+end
+#=> {:<<>>, [], [1, 2, 3]}
+```
+
+The same applies to maps, where pairs are treated as a list of tuples with two elements:
+
+```elixir
+quote do
+  %{1 => 2, 3 => 4}
+end
+#=> {:%{}, [], [{1, 2}, {3, 4}]}
+```
+
+### Blocks
+
+Blocks are represented as a `__block__` call with each line as a separate argument:
+
+```elixir
+quote do
+  1
+  2
+  3
+end
+#=> {:__block__, [], [1, 2, 3]}
+
+quote do 1; 2; 3; end
+#=> {:__block__, [], [1, 2, 3]}
+```
+
+### Left to right arrow
+
+The left to right arrow (`->`) is represented similar to operators except that they are always part of a list, its left side represents a list of arguments and the right side is an expression.
+
+For example, in `case` and `cond`:
+
+```elixir
+quote do
+  case 1 do
+    2 -> 3
+    4 -> 5
+  end
+end
+#=> {:case, [], [1, [do: [{:->, [], [[2], 3]}, {:->, [], [[4], 5]}]]]}
+
+quote do
+  cond do
+    true -> false
+  end
+end
+#=> {:cond, [], [[do: [{:->, [], [[true], false]}]]]}
+```
+
+Between `(` and `)`:
+
+```elixir
+quote do
+  (1, 2 -> 3
+   4, 5 -> 6)
+end
+#=> [{:->, [], [[1, 2], 3]}, {:->, [], [[4, 5], 6]}]
+```
+
+Between `fn` and `end`:
+
+```elixir
+quote do
+  fn
+    1, 2 -> 3
+    4, 5 -> 6
+  end
+end
+#=> {:fn, [], [{:->, [], [[1, 2], 3]}, {:->, [], [[4, 5], 6]}]}
+```
+
+### Qualified tuples
+
+Qualified tuples (`foo.{bar, baz}`) are represented by a `{:., [], [expr, :{}]}` call, where the `expr` represents the left hand side of the dot, and the arguments represent the elements inside the curly braces. This is used in Elixir to provide multi aliases:
+
+```elixir
+quote do
+  Foo.{Bar, Baz}
+end
+#=> {{:., [], [{:__aliases__, [], [:Foo]}, :{}]}, [], [{:__aliases__, [], [:Bar]}, {:__aliases__, [], [:Baz]}]}
+```
+
+### `do`-`end` blocks
+
+Elixir's `do`-`end` blocks are equivalent to keywords as the last argument of a function call, where the block contents are wrapped in parentheses. For example:
+
+```elixir
+if true do
+  this
+else
+  that
+end
+```
+
+is the same as:
+
+```elixir
+if(true, do: (this), else: (that))
+```
+
+While the construct above does not require custom nodes in Elixir's AST, they are restricted only to certain keywords, listed next:
+
+  * `after`
+  * `catch`
+  * `else`
+  * `rescue`
+
+You will find them in constructs such as `receive`, `try`, and others. You can also find more examples in [the Optional Syntax chapter](../getting-started/optional-syntax.md).
diff --git a/lib/elixir/pages/references/typespecs.md b/lib/elixir/pages/references/typespecs.md
new file mode 100644
index 00000000000..32ff5ad12eb
--- /dev/null
+++ b/lib/elixir/pages/references/typespecs.md
@@ -0,0 +1,442 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
+# Typespecs reference
+
+> #### Typespecs are not set-theoretic types {: .warning}
+>
+> Elixir is in the process of implementing its
+> [own type system](./gradual-set-theoretic-types.md) based on set-theoretic types.
+> Typespecs, which are described in the following document, are a distinct notation
+> for declaring types and specifications based on Erlang.
+> Typespecs may be phased out as the set-theoretic type effort moves forward.
+
+Elixir is a dynamically typed language, and as such, type specifications are never used by the compiler to optimize or modify code. Still, using type specifications is useful because:
+
+  * they provide documentation (for example, tools such as [`ExDoc`](https://hexdocs.pm/ex_doc/) show type specifications in the documentation)
+  * they're used by tools such as [Dialyzer](`:dialyzer`), that can analyze code with typespecs to find type inconsistencies and possible bugs
+
+Type specifications (most often referred to as *typespecs*) are defined in different contexts using the following attributes:
+
+  * `@type`
+  * `@opaque`
+  * `@typep`
+  * `@spec`
+  * `@callback`
+  * `@macrocallback`
+
+In addition, you can use `@typedoc` to document a custom `@type` definition.
+
+See the "User-defined types" and "Defining a specification" sub-sections below for more information on defining types and typespecs.
+
+## A simple example
+
+    defmodule StringHelpers do
+      @typedoc "A word from the dictionary"
+      @type word() :: String.t()
+
+      @spec long_word?(word()) :: boolean()
+      def long_word?(word) when is_binary(word) do
+        String.length(word) > 8
+      end
+    end
+
+In the example above:
+
+  * We declare a new type (`word()`) that is equivalent to the string type (`String.t()`).
+
+  * We describe the type using a `@typedoc`, which will be included in the generated documentation.
+
+  * We specify that the `long_word?/1` function takes an argument of type `word()` and
+    returns a boolean (`boolean()`), that is, either `true` or `false`.
+
+## Types and their syntax
+
+The syntax Elixir provides for type specifications is similar to [the one in Erlang](https://www.erlang.org/doc/reference_manual/typespec.html). Most of the built-in types provided in Erlang (for example, `pid()`) are expressed in the same way: `pid()` (or simply `pid`). Parameterized types (such as `list(integer)`) are supported as well and so are remote types (such as [`Enum.t()`](`t:Enum.t/0`)). Integers and atom literals are allowed as types (for example, `1`, `:atom`, or `false`). All other types are built out of unions of predefined types. Some types can also be declared using their syntactical notation, such as `[type]` for lists, `{type1, type2, ...}` for tuples and `<<_ * _>>` for binaries.
+
+The notation to represent the union of types is the pipe `|`. For example, the typespec `type :: atom() | pid() | tuple()` creates a type `type` that can be either an `atom`, a `pid`, or a `tuple`. This is usually called a [sum type](https://en.wikipedia.org/wiki/Tagged_union) in other languages
+
+> #### Differences with set-theoretic types {: .warning}
+>
+> While they do share some similarities, the types below do not map one-to-one
+> to the new types from the set-theoretic type system.
+>
+> For example, there is no plan to support subsets of the `integer()` type such
+> as positive, ranges or literals.
+>
+> Furthermore, set-theoretic types support the full range of set operations,
+> including intersections and negations.
+
+### Basic types
+
+    type ::
+          any()                     # the top type, the set of all terms
+          | none()                  # the bottom type, contains no terms
+          | atom()
+          | map()                   # any map
+          | pid()                   # process identifier
+          | port()                  # port identifier
+          | reference()
+          | tuple()                 # tuple of any size
+
+                                    ## Numbers
+          | float()
+          | integer()
+          | neg_integer()           # ..., -3, -2, -1
+          | non_neg_integer()       # 0, 1, 2, 3, ...
+          | pos_integer()           # 1, 2, 3, ...
+
+                                                                          ## Lists
+          | list(type)                                                    # proper list ([]-terminated)
+          | nonempty_list(type)                                           # non-empty proper list
+          | maybe_improper_list(content_type, termination_type)           # proper or improper list
+          | nonempty_improper_list(content_type, termination_type)        # improper list
+          | nonempty_maybe_improper_list(content_type, termination_type)  # non-empty proper or improper list
+
+          | Literals                # Described in section "Literals"
+          | BuiltIn                 # Described in section "Built-in types"
+          | Remotes                 # Described in section "Remote types"
+          | UserDefined             # Described in section "User-defined types"
+
+### Literals
+
+The following literals are also supported in typespecs:
+
+    type ::                               ## Atoms
+          :atom                           # atoms: :foo, :bar, ...
+          | true | false | nil            # special atom literals
+
+                                          ## Bitstrings
+          | <<>>                          # empty bitstring
+          | <<_::size>>                   # size is 0 or a positive integer
+          | <<_::_*unit>>                 # unit is an integer from 1 to 256
+          | <<_::size, _::_*unit>>
+
+                                          ## (Anonymous) Functions
+          | (-> type)                     # zero-arity, returns type
+          | (type1, type2 -> type)        # two-arity, returns type
+          | (... -> type)                 # any arity, returns type
+
+                                          ## Integers
+          | 1                             # integer
+          | 1..10                         # integer from 1 to 10
+
+                                          ## Lists
+          | [type]                        # list with any number of type elements
+          | []                            # empty list
+          | [...]                         # shorthand for nonempty_list(any())
+          | [type, ...]                   # shorthand for nonempty_list(type)
+          | [key: value_type]             # keyword list with optional key :key of value_type
+
+                                                  ## Maps
+          | %{}                                   # empty map
+          | %{key: value_type}                    # map with required key :key of value_type
+          | %{key_type => value_type}             # map with required pairs of key_type and value_type
+          | %{required(key_type) => value_type}   # map with required pairs of key_type and value_type
+          | %{optional(key_type) => value_type}   # map with optional pairs of key_type and value_type
+          | %SomeStruct{}                         # struct with all fields of any type
+          | %SomeStruct{key: value_type}          # struct with required key :key of value_type
+
+                                          ## Tuples
+          | {}                            # empty tuple
+          | {:ok, type}                   # two-element tuple with an atom and any type
+
+### Built-in types
+
+The following types are also provided by Elixir as shortcuts on top of the basic and literal types described above.
+
+Built-in type           | Defined as
+:---------------------- | :---------
+`term()`                | `any()`
+`arity()`               | `0..255`
+`as_boolean(t)`         | `t`
+`binary()`              | `<<_::_*8>>`
+`nonempty_binary()`     | `<<_::8, _::_*8>>`
+`bitstring()`           | `<<_::_*1>>`
+`nonempty_bitstring()`  | `<<_::1, _::_*1>>`
+`boolean()`             | `true` \| `false`
+`byte()`                | `0..255`
+`char()`                | `0..0x10FFFF`
+`charlist()`            | `[char()]`
+`nonempty_charlist()`   | `[char(), ...]`
+`fun()`                 | `(... -> any)`
+`function()`            | `fun()`
+`identifier()`          | `pid()` \| `port()` \| `reference()`
+`iodata()`              | `iolist()` \| `binary()`
+`iolist()`              | `maybe_improper_list(byte() \| binary() \| iolist(), binary() \| [])`
+`keyword()`             | `[{atom(), any()}]`
+`keyword(t)`            | `[{atom(), t}]`
+`list()`                | `[any()]`
+`nonempty_list()`       | `nonempty_list(any())`
+`maybe_improper_list()` | `maybe_improper_list(any(), any())`
+`nonempty_maybe_improper_list()` | `nonempty_maybe_improper_list(any(), any())`
+`mfa()`                 | `{module(), atom(), arity()}`
+`module()`              | `atom()`
+`no_return()`           | `none()`
+`node()`                | `atom()`
+`number()`              | `integer()` \| `float()`
+`struct()`              | `%{:__struct__ => atom(), optional(atom()) => any()}`
+`timeout()`             | `:infinity` \| `non_neg_integer()`
+
+`as_boolean(t)` exists to signal users that the given value will be treated as a boolean, where `nil` and `false` will be evaluated as `false` and everything else is `true`. For example, `Enum.filter/2` has the following specification: `filter(t, (element -> as_boolean(term))) :: list`.
+
+### Remote types
+
+Any module is also able to define its own types and the modules in Elixir are no exception. For example, the `Range` module defines a `t/0` type that represents a range: this type can be referred to as `t:Range.t/0`. In a similar fashion, a string is `t:String.t/0`, and so on.
+
+### Maps
+
+The key types in maps are allowed to overlap, and if they do, the leftmost key takes precedence.
+A map value does not belong to this type if it contains a key that is not in the allowed map keys.
+
+If you want to denote that keys that were not previously defined in the map are allowed,
+it is common to end a map type with `optional(any) => any`.
+
+Note that the syntactic representation of `map()` is `%{optional(any) => any}`, not `%{}`. The notation `%{}` specifies the singleton type for the empty map.
+
+### Keyword Lists
+
+Beyond `keyword()` and `keyword(t)`, it can be helpful to compose a spec for an expected keyword list.
+For example:
+
+```elixir
+@type option :: {:name, String.t} | {:max, pos_integer} | {:min, pos_integer}
+@type options :: [option()]
+```
+
+This makes it clear that only these options are allowed, none are required, and order does not matter.
+
+It also allows composition with existing types.
+For example:
+
+```elixir
+@type option :: {:my_option, String.t()} | GenServer.option()
+
+@spec start_link([option()]) :: GenServer.on_start()
+def start_link(opts) do
+  {my_opts, gen_server_opts} = Keyword.split(opts, [:my_option])
+  GenServer.start_link(__MODULE__, my_opts, gen_server_opts)
+end
+```
+
+The following spec syntaxes are equivalent:
+
+```elixir
+@type options [{:name, String.t} | {:max, pos_integer} | {:min, pos_integer}]
+
+@type options [name: String.t, max: pos_integer, min: pos_integer]
+```
+
+### User-defined types
+
+The `@type`, `@typep`, and `@opaque` module attributes can be used to define new types:
+
+    @type type_name :: type
+    @typep type_name :: type
+    @opaque type_name :: type
+
+A type defined with `@typep` is private. An opaque type, defined with `@opaque` is a type where the internal structure of the type will not be visible, but the type is still public.
+
+Types can be parameterized by defining variables as parameters; these variables can then be used to define the type.
+
+    @type dict(key, value) :: [{key, value}]
+
+## Defining a specification
+
+A specification for a function can be defined as follows:
+
+    @spec function_name(type1, type2) :: return_type
+
+Guards can be used to restrict type variables given as arguments to the function.
+
+    @spec function(arg) :: [arg] when arg: atom
+
+If you want to specify more than one variable, you separate them by a comma.
+
+    @spec function(arg1, arg2) :: {arg1, arg2} when arg1: atom, arg2: integer
+
+Type variables with no restriction can also be defined using `var`.
+
+    @spec function(arg) :: [arg] when arg: var
+
+This guard notation only works with `@spec`, `@callback`, and `@macrocallback`.
+
+You can also name your arguments in a typespec using `arg_name :: arg_type` syntax. This is particularly useful in documentation as a way to differentiate multiple arguments of the same type (or multiple elements of the same type in a type definition):
+
+    @spec days_since_epoch(year :: integer, month :: integer, day :: integer) :: integer
+    @type color :: {red :: integer, green :: integer, blue :: integer}
+
+Specifications can be overloaded, just like ordinary functions.
+
+    @spec function(integer) :: atom
+    @spec function(atom) :: integer
+
+## Behaviours
+
+Behaviours in Elixir (and Erlang) are a way to separate and abstract the generic part of a component (which becomes the *behaviour module*) from the specific part (which becomes the *callback module*).
+
+A behaviour module defines a set of functions and macros (referred to as *callbacks*) that callback modules implementing that behaviour must export. This "interface" identifies the specific part of the component. For example, the `GenServer` behaviour and functions abstract away all the message-passing (sending and receiving) and error reporting that a "server" process will likely want to implement from the specific parts such as the actions that this server process has to perform.
+
+Say we want to implement a bunch of parsers, each parsing structured data: for example, a JSON parser and a MessagePack parser. Each of these two parsers will *behave* the same way: both will provide a `parse/1` function and an `extensions/0` function. The `parse/1` function will return an Elixir representation of the structured data, while the `extensions/0` function will return a list of file extensions that can be used for each type of data (e.g., `.json` for JSON files).
+
+We can create a `Parser` behaviour:
+
+```elixir
+defmodule Parser do
+  @doc """
+  Parses a string.
+  """
+  @callback parse(String.t) :: {:ok, term} | {:error, atom}
+
+  @doc """
+  Lists all supported file extensions.
+  """
+  @callback extensions() :: [String.t]
+end
+```
+
+As seen in the example above, defining a callback is a matter of defining a specification for that callback, made of:
+
+  * the callback name (`parse` or `extensions` in the example)
+  * the arguments that the callback must accept (`String.t`)
+  * the *expected* type of the callback return value
+
+Modules adopting the `Parser` behaviour will have to implement all the functions defined with the `@callback` attribute. As you can see, `@callback` expects a function name but also a function specification like the ones used with the `@spec` attribute we saw above.
+
+### Implementing behaviours
+
+Implementing a behaviour is straightforward:
+
+```elixir
+defmodule JSONParser do
+  @behaviour Parser
+
+  @impl Parser
+  def parse(str), do: {:ok, "some json " <> str} # ... parse JSON
+
+  @impl Parser
+  def extensions, do: [".json"]
+end
+```
+
+```elixir
+defmodule CSVParser do
+  @behaviour Parser
+
+  @impl Parser
+  def parse(str), do: {:ok, "some csv " <> str} # ... parse CSV
+
+  @impl Parser
+  def extensions, do: [".csv"]
+end
+```
+
+If a module adopting a given behaviour doesn't implement one of the callbacks required by that behaviour, a compile-time warning will be generated.
+
+Furthermore, with `@impl` you can also make sure that you are implementing the **correct** callbacks from the given behaviour in an explicit manner. For example, the following parser implements both `parse` and `extensions`. However, thanks to a typo, `BADParser` is implementing `parse/0` instead of `parse/1`.
+
+```elixir
+defmodule BADParser do
+  @behaviour Parser
+
+  @impl Parser
+  def parse, do: {:ok, "something bad"}
+
+  @impl Parser
+  def extensions, do: ["bad"]
+end
+```
+
+This code generates a warning letting you know that you are mistakenly implementing `parse/0` instead of `parse/1`.
+You can read more about `@impl` in the [module documentation](`Module#module-impl`).
+
+### Using behaviours
+
+Behaviours are useful because you can pass modules around as arguments and you can then *call back* to any of the functions specified in the behaviour. For example, we can have a function that receives a filename, several parsers, and parses the file based on its extension:
+
+```elixir
+@spec parse_path(Path.t(), [module()]) :: {:ok, term} | {:error, atom}
+def parse_path(filename, parsers) do
+  with {:ok, ext} <- parse_extension(filename),
+       {:ok, parser} <- find_parser(ext, parsers),
+       {:ok, contents} <- File.read(filename) do
+    parser.parse(contents)
+  end
+end
+
+defp parse_extension(filename) do
+  if ext = Path.extname(filename) do
+    {:ok, ext}
+  else
+    {:error, :no_extension}
+  end
+end
+
+defp find_parser(ext, parsers) do
+  if parser = Enum.find(parsers, fn parser -> ext in parser.extensions() end) do
+    {:ok, parser}
+  else
+    {:error, :no_matching_parser}
+  end
+end
+```
+
+You could also invoke any parser directly: `CSVParser.parse(...)`.
+
+Note you don't need to define a behaviour in order to dynamically dispatch on a module, but those features often go hand in hand.
+
+### Optional callbacks
+
+Optional callbacks are callbacks that callback modules may implement if they want to, but are not required to. Usually, behaviour modules know if they should call those callbacks based on configuration, or they check if the callbacks are defined with `function_exported?/3` or `macro_exported?/3`.
+
+> ### Unloaded modules {: .warning}
+>
+> `function_exported?/3` (and `macro_exported?/3`) do *not* load the module in case it is not loaded and Elixir lazily loads modules by default (except on releases). So in practice you will want to invoke `Code.ensure_loaded?/1` before checking if the function/macro is exported. See the documentation for `function_exported?/3` for examples.
+
+Optional callbacks can be defined through the `@optional_callbacks` module attribute, which has to be a keyword list with function or macro name as key and arity as value. For example:
+
+    defmodule MyBehaviour do
+      @callback vital_fun() :: any
+      @callback non_vital_fun() :: any
+      @macrocallback non_vital_macro(arg :: any) :: Macro.t
+      @optional_callbacks non_vital_fun: 0, non_vital_macro: 1
+    end
+
+One example of optional callback in Elixir's standard library is `c:GenServer.format_status/1`.
+
+### Inspecting behaviours
+
+The `@callback` and `@optional_callbacks` attributes are used to create a `behaviour_info/1` function available on the defining module. This function can be used to retrieve the callbacks and optional callbacks defined by that module.
+
+For example, for the `MyBehaviour` module defined in "Optional callbacks" above:
+
+    MyBehaviour.behaviour_info(:callbacks)
+    #=> [vital_fun: 0, "MACRO-non_vital_macro": 2, non_vital_fun: 0]
+    MyBehaviour.behaviour_info(:optional_callbacks)
+    #=> ["MACRO-non_vital_macro": 2, non_vital_fun: 0]
+
+When using `iex`, the `IEx.Helpers.b/1` helper is also available.
+
+## Pitfalls
+
+There are some known pitfalls when using typespecs, they are documented next.
+
+## The `string()` type
+
+Elixir discourages the use of the `string()` type. The `string()` type refers to Erlang strings, which are known as "charlists" in Elixir. They do not refer to Elixir strings, which are UTF-8 encoded binaries. To avoid confusion, if you attempt to use the type `string()`, Elixir will emit a warning. You should use `charlist()`, `nonempty_charlist()`, `binary()` or `String.t()` accordingly, or any of the several literal representations for these types.
+
+Note that `String.t()` and `binary()` are equivalent to analysis tools. Although, for those reading the documentation, `String.t()` implies it is a UTF-8 encoded binary.
+
+## Functions which raise an error
+
+Typespecs do not need to indicate that a function can raise an error; any function can fail any time if given invalid input.
+In the past, the Elixir standard library sometimes used `no_return()` to indicate this, but these usages have been removed.
+
+The `no_return()` type also should not be used for functions which do return but whose purpose is a "side effect", such as `IO.puts/1`.
+In these cases, the expected return type is `:ok`.
+
+Instead, `no_return()` should be used as the return type for functions which can never return a value.
+This includes functions which loop forever calling `receive`, or which exist specifically to raise an error, or which shut down the VM.
diff --git a/lib/elixir/pages/references/unicode-syntax.md b/lib/elixir/pages/references/unicode-syntax.md
new file mode 100644
index 00000000000..c700590e3c5
--- /dev/null
+++ b/lib/elixir/pages/references/unicode-syntax.md
@@ -0,0 +1,159 @@
+<!--
+  SPDX-License-Identifier: Apache-2.0
+  SPDX-FileCopyrightText: 2021 The Elixir Team
+  SPDX-FileCopyrightText: 2012 Plataformatec
+-->
+
+# Unicode syntax
+
+Elixir supports Unicode throughout the language. This document is a complete reference of how
+Elixir supports Unicode in its syntax.
+
+Strings (`"olá"`) and charlists (`'olá'`) support Unicode since Elixir v1.0. Strings are UTF-8 encoded. Charlists are lists of Unicode code points. In such cases, the contents are kept as written by developers, without any transformation.
+
+Elixir also supports Unicode in variables, atoms, and calls since Elixir v1.5. The focus of this document is to provide a high-level introduction to how Elixir allows Unicode in its syntax. We also provide technical documentation describing how Elixir complies with the Unicode specification.
+
+To check the Unicode version of your current Elixir installation, run `String.Unicode.version()`.
+
+## Introduction
+
+Elixir allows Unicode characters in its variables, atoms, and calls. However, the Unicode characters must still obey the rules of the language syntax. In particular, variables and calls cannot start with an uppercase letter. From now on, we will refer to those terms as identifiers.
+
+The characters allowed in identifiers are the ones specified by Unicode. Generally speaking, it is restricted to characters typically used by the writing system of human languages still in activity. In particular, it excludes symbols such as emojis, alternate numeric representations, musical notes, and the like.
+
+Elixir imposes many restrictions on identifiers for security purposes. For example, the word "josé" can be written in two ways in Unicode: as the combination of the characters `j o s é` and as a combination of the characters `j o s e ́ `, where the accent is its own character. The former is called NFC form and the latter is the NFD form. Elixir normalizes all characters to be the in the NFC form.
+
+Elixir also disallows mixed-scripts which are not explicitly separated by `_`. For example, it is not possible to name a variable `аdmin`, where `а` is in Cyrillic and the remaining characters are in Latin. Doing so will raise the following error:
+
+```text
+** (SyntaxError) invalid mixed-script identifier found: аdmin
+
+Mixed-script identifiers are not supported for security reasons. 'аdmin' is made of the following scripts:
+
+  \u0430 а {Cyrillic}
+  \u0064 d {Latin}
+  \u006D m {Latin}
+  \u0069 i {Latin}
+  \u006E n {Latin}
+
+Make sure all characters in the identifier resolve to a single script or a highly
+restrictive script. See https://hexdocs.pm/elixir/unicode-syntax.html for more information.
+```
+
+Finally, Elixir will also warn of confusable identifiers in the same file. For example, Elixir will emit a warning if you use both variables `а` (Cyrillic) and `а` (Latin) in your code.
+
+That's the overall introduction of how Unicode is used in Elixir identifiers. In a nutshell, its goal is to support different writing systems in use today while keeping the Elixir language itself clear and secure.
+
+For the technical details, see the next sections that cover the technical Unicode requirements.
+
+## Unicode Standard Annex #31
+
+Elixir conforms to the standards outlined in the [Unicode Standard Annex #31: Unicode Identifiers and Syntax](https://unicode.org/reports/tr31/), version 17.0.
+
+### R1. Default Identifiers
+
+The general Elixir identifier rule is specified as:
+
+    <Identifier> := <Start> <Continue>* <Ending>?
+
+where `<Start>` uses the same categories as the spec but normalizes them to the NFC form (see R4):
+
+> characters derived from the Unicode General Category of uppercase letters, lowercase letters, titlecase letters, modifier letters, other letters, letter numbers, plus `Other_ID_Start`, minus `Pattern_Syntax` and `Pattern_White_Space` code points
+>
+> In set notation: `[\p{L}\p{Nl}\p{Other_ID_Start}-\p{Pattern_Syntax}-\p{Pattern_White_Space}]`.
+
+and `<Continue>` uses the same categories as the spec but normalizes them to the NFC form (see R4):
+
+> ID_Start characters, plus characters having the Unicode General Category of nonspacing marks, spacing combining marks, decimal number, connector punctuation, plus `Other_ID_Continue`, minus `Pattern_Syntax` and `Pattern_White_Space` code points.
+>
+> In set notation: `[\p{ID_Start}\p{Mn}\p{Mc}\p{Nd}\p{Pc}\p{Other_ID_Continue}-\p{Pattern_Syntax}-\p{Pattern_White_Space}]`.
+
+`<Ending>` is an addition specific to Elixir that includes only the code points `?` (003F) and `!` (0021).
+
+The spec also provides a `<Medial>` set, but Elixir does not include any character on this set. Therefore, the identifier rule has been simplified to consider this.
+
+Elixir does not allow the use of ZWJ or ZWNJ in identifiers and therefore does not implement R1a. Bidirectional control characters are also not supported. R1b is guaranteed for backwards compatibility purposes.
+
+#### Atoms
+
+Unicode atoms in Elixir follow the identifier rule above with the following modifications:
+
+  * `<Start>` additionally includes the code point `_` (005F)
+  * `<Continue>` additionally includes the code point `@` (0040)
+
+Note atoms can also be quoted, which allows any characters, such as `:"hello elixir"`. All Elixir operators are also valid atoms, such as `:+`, `:@`, `:|>`, and others. The full description of valid atoms is available in the ["Atoms" section in the syntax reference](syntax-reference.md#atoms).
+
+#### Variables, local calls, and remote calls
+
+Variables in Elixir follow the identifier rule above with the following modifications:
+
+  * `<Start>` additionally includes the code point `_` (005F)
+  * `<Start>` additionally excludes Lu (letter uppercase) and Lt (letter titlecase) characters
+
+In set notation: `[\u{005F}\p{Ll}\p{Lm}\p{Lo}\p{Nl}\p{Other_ID_Start}-\p{Pattern_Syntax}-\p{Pattern_White_Space}]`.
+
+#### Aliases
+
+Aliases in Elixir only allow ASCII characters, starting in uppercase, and no punctuation characters.
+
+### R3. Pattern_White_Space and Pattern_Syntax Characters
+
+Elixir supports only code points `\t` (0009), `\n` (000A), `\r` (000D) and `\s` (0020) as whitespace and therefore does not follow requirement R3. R3 requires a wider variety of whitespace and syntax characters to be supported.
+
+### R4. Equivalent Normalized Identifiers
+
+Identifiers in Elixir are case sensitive.
+
+Elixir normalizes all atoms and variables to NFC form. Quoted-atoms and strings can, however, be in any form and are not verified by the parser.
+
+In other words, the atom `:josé` can only be written with the code points `006A 006F 0073 00E9` or `006A 006F 0073 0065 0301`, but Elixir will rewrite it to the former (from Elixir 1.14). On the other hand, `:"josé"` may be written as `006A 006F 0073 00E9` or `006A 006F 0073 0065 0301` and its form will be retained, since it is written between quotes.
+
+Choosing requirement R4 automatically excludes requirements R5, R6, and R7.
+
+## Unicode Technical Standard #39
+
+Elixir conforms to the clauses outlined in the [Unicode Technical Standard #39](https://unicode.org/reports/tr39/) on Security, version 17.0.
+
+### C1. General Security Profile for Identifiers
+
+Elixir will not allow tokenization of identifiers with codepoints in `\p{Identifier_Status=Restricted}`, except for the outlined 'Additional normalizations' section below.
+
+> An implementation following the General Security Profile does not permit any characters in \p{Identifier_Status=Restricted}, ...
+
+For instance, the 'HANGUL FILLER' (`ㅤ`) character, which is often invisible, is an uncommon codepoint and will trigger a warning.
+
+### C2. Confusable detection
+
+Elixir will warn of identifiers that look the same, but aren't. Examples: in `а = a = 1`, the two 'a' characters are Cyrillic and Latin, and could be confused for each other; in `力 = カ = 1`, both are Japanese, but different codepoints, in different scripts of that writing system. Confusable identifiers can lead to hard-to-catch bugs (say, due to copy-pasted code) and can be unsafe, so we will warn of identifiers within a single file that could be confused with each other.
+
+We use the means described in Section 4, 'Confusable Detection', with one noted modification:
+
+> Alternatively, it shall declare that it uses a modification, and provide a precise list of character mappings that are added to or removed from the provided ones.
+
+Elixir will not warn about confusability for identifiers made up exclusively of characters in a-z, A-Z, 0-9, and _. This is because ASCII identifiers have existed for so long that the programming community has had their own means of dealing with confusability between identifiers like `l,1` or `O,0` (for instance, fonts designed for programming usually make it easy to differentiate between those characters).
+
+### C3. Mixed Script Detection
+
+Elixir will not allow tokenization of mixed-script identifiers unless it is via chunks separated by an underscore, like `http_сервер`. We use the means described in Section 5.1, Mixed-Script Detection, to determine if script mixing is occurring, with the 'Additional Normalizations' documented in.
+
+Examples: Elixir allows an identifiers like `幻한`, even though it includes characters from multiple 'scripts', as Han characters may be mixed with Japanese and Korean, according to the rules from UTS 39 5.1. When mixing Latin and Japanese scripts, underscores are necessary, as in `:T_シャツ` (the Japanese word for 't-shirt' with an additional underscore separating the letter T).
+
+Elixir does not allow code like `if аdmin, do: :ok, else: :err`, where the scriptset for the 'a' character is {Cyrillic} but all other characters have scriptsets of {Latin}. The scriptsets fail to resolve and a descriptive error is shown.
+
+### C4, C5 (inapplicable)
+
+'C4 - Restriction Level detection' conformance is not claimed and does not apply to identifiers in code; rather, it applies to classifying the level of safety of a given arbitrary string into one of 5 restriction levels.
+
+'C5 - Mixed number detection' conformance is inapplicable as Elixir does not support Unicode numbers.
+
+### Addition Normalizations
+
+As of Elixir 1.14, some codepoints in `\p{Identifier_Status=Restricted}` are *normalized* to other, unrestricted codepoints.
+
+This is currently only applied to translate MICRO SIGN (`µ`) to Greek lowercase mu (`μ`).
+
+The normalization avoids confusability and the mixed-script detection is modified to the extent that the normalized codepoint is given the union of scriptsets from both characters.
+
+  * For instance, in the example of MICRO => MU, MICRO was a 'Common'-script character - the same script given to the '_' underscore codepoint - and thus the normalized character's scriptset will be {Greek, Common}. 'Common' intersects with all non-empty scriptsets, and thus the normalized character can be used in tokens written in any script without causing script mixing.
+
+  * The code points normalized in this fashion are those that are in use in the community, and judged not likely to cause issues with unsafe script mixing. For instance, the MICRO or MU codepoint may be used in an atom or variable dealing with microseconds.
diff --git a/lib/elixir/rebar.config b/lib/elixir/rebar.config
deleted file mode 100644
index 902a412104c..00000000000
--- a/lib/elixir/rebar.config
+++ /dev/null
@@ -1,23 +0,0 @@
-{erl_opts, [
-            warn_unused_vars,
-            warn_export_all,
-            warn_shadow_vars,
-            warn_unused_import,
-            warn_unused_function,
-            warn_bif_clash,
-            warn_unused_record,
-            warn_deprecated_function,
-            warn_obsolete_guard,
-            strict_validation,
-            warn_exported_vars,
-            %% warn_export_vars,
-            %% warn_missing_spec,
-            %% warn_untyped_record,
-            %% warnings_as_errors,
-            debug_info
-           ]}.
-
-{yrl_opts, [
-            {report, true},
-            {verbose, false}
-           ]}.
diff --git a/lib/elixir/scripts/cover.exs b/lib/elixir/scripts/cover.exs
new file mode 100755
index 00000000000..a00973dd8f8
--- /dev/null
+++ b/lib/elixir/scripts/cover.exs
@@ -0,0 +1,30 @@
+#!bin/elixir
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("cover_record.exs", __DIR__)
+cover_pid = CoverageRecorder.enable_coverage()
+
+coverdata_inputs =
+  CoverageRecorder.cover_dir() |> Path.join("ex_unit_*.coverdata") |> Path.wildcard()
+
+coverdata_output = Path.join(CoverageRecorder.cover_dir(), "combined.coverdata")
+
+for file <- coverdata_inputs do
+  :ok = :cover.import(String.to_charlist(file))
+end
+
+:ok = :cover.export(String.to_charlist(coverdata_output))
+
+{:ok, _} = Application.ensure_all_started(:mix)
+
+# Silence analyse import messages emitted by cover
+{:ok, string_io} = StringIO.open("")
+Process.group_leader(cover_pid, string_io)
+
+:ok =
+  Mix.Tasks.Test.Coverage.generate_cover_results(
+    output: CoverageRecorder.cover_dir(),
+    summary: [threshold: 0]
+  )
diff --git a/lib/elixir/scripts/cover_record.exs b/lib/elixir/scripts/cover_record.exs
new file mode 100644
index 00000000000..ffe78f3ed85
--- /dev/null
+++ b/lib/elixir/scripts/cover_record.exs
@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule CoverageRecorder do
+  def maybe_record(suite_name) do
+    if enabled?() do
+      record(suite_name)
+
+      true
+    else
+      false
+    end
+  end
+
+  def enable_coverage do
+    _ = :cover.stop()
+    {:ok, pid} = :cover.start()
+
+    cover_compile_ebins()
+
+    pid
+  end
+
+  def cover_dir, do: Path.join(root_dir(), "cover")
+
+  defp enabled? do
+    case System.fetch_env("COVER") do
+      {:ok, truthy} when truthy in ~w[1 true yes y] ->
+        true
+
+      _ ->
+        false
+    end
+  end
+
+  defp root_dir, do: Path.join(__DIR__, "../../..")
+  defp ebins, do: root_dir() |> Path.join("lib/*/ebin") |> Path.wildcard()
+
+  defp record(suite_name) do
+    file = Path.join(cover_dir(), "ex_unit_#{suite_name}.coverdata")
+
+    enable_coverage()
+
+    System.at_exit(fn _status ->
+      File.mkdir_p!(cover_dir())
+
+      :ok = :cover.export(String.to_charlist(file))
+    end)
+  end
+
+  defp cover_compile_ebins do
+    relevant_beam_files()
+    |> Enum.map(&String.to_charlist/1)
+    |> :cover.compile_beam()
+    |> Enum.each(fn
+      {:ok, _module} ->
+        :ok
+
+      {:error, reason} ->
+        raise "Failed to cover compile with reason: #{inspect(reason)}"
+    end)
+  end
+
+  defp relevant_beam_files do
+    ebins()
+    |> Enum.flat_map(fn ebin ->
+      ebin |> Path.join("*.beam") |> Path.wildcard()
+    end)
+    |> Enum.reject(&skip_from_coverage?/1)
+  end
+
+  @to_skip [
+    # Tested via the CLI only
+    :elixir_sup,
+    :iex,
+    Kernel.CLI,
+    Mix.CLI,
+    Mix.Compilers.Test,
+    Mix.Tasks.Test,
+    Mix.Tasks.Test.Coverage,
+
+    # Bootstrap
+    :elixir_bootstrap,
+    Kernel.SpecialForms
+  ]
+
+  defp skip_from_coverage?(file) do
+    mod = file |> Path.basename(".beam") |> String.to_atom()
+    mod in @to_skip or match?({:docs_v1, _, _, _, _, %{deprecated: _}, _}, Code.fetch_docs(mod))
+  end
+end
diff --git a/lib/elixir/scripts/diff.exs b/lib/elixir/scripts/diff.exs
new file mode 100644
index 00000000000..5a12794a340
--- /dev/null
+++ b/lib/elixir/scripts/diff.exs
@@ -0,0 +1,193 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Diff do
+  @moduledoc """
+  Utilities for comparing build artifacts.
+  """
+
+  @atom_chunks ~w(
+    atoms
+    attributes
+    compile_info
+    debug_info
+    exports
+    labeled_exports
+    imports
+    indexed_imports
+    locals
+    labeled_locals
+  )a
+
+  @binary_chunks ~w(
+    Attr
+    AtU8
+    CInf
+    Dbgi
+    Docs
+    ExCk
+    ExpT
+    ImpT
+    LocT
+  )c
+
+  @doc """
+  Compares the build artifacts of two build directories.
+  """
+  @spec compare_dirs(Path.t(), Path.t()) ::
+          {
+            only1_paths :: list(Path.t()),
+            only2_paths :: list(Path.t()),
+            diff :: list({Path.t(), diff :: String.t()})
+          }
+  def compare_dirs(dir1, dir2) do
+    dir1 = Path.expand(dir1)
+    dir2 = Path.expand(dir2)
+
+    assert_dir!(dir1)
+    assert_dir!(dir2)
+
+    dir1_paths = relative_paths(dir1)
+    dir2_paths = relative_paths(dir2)
+
+    only1_paths = dir1_paths -- dir2_paths
+    only2_paths = dir2_paths -- dir1_paths
+    common_paths = dir1_paths -- only1_paths
+    common_files = Enum.reject(common_paths, &File.dir?/1)
+
+    diff =
+      Enum.flat_map(common_files, fn path ->
+        file1 = Path.join(dir1, path)
+        file2 = Path.join(dir2, path)
+
+        case compare_files(file1, file2) do
+          :eq -> []
+          {:diff, diff} -> [{path, diff}]
+        end
+      end)
+
+    {only1_paths, only2_paths, diff}
+  end
+
+  @doc """
+  Compares the contents of two files.
+
+  If the files are BEAM files, it performs a more human-friendly
+  "BEAM-diff".
+  """
+  @spec compare_files(Path.t(), Path.t()) :: :eq | {:diff, diff :: String.t()}
+  def compare_files(file1, file2) do
+    content1 = File.read!(file1)
+    content2 = File.read!(file2)
+
+    if content1 == content2 do
+      :eq
+    else
+      diff =
+        if String.ends_with?(file1, ".beam") do
+          beam_diff(file1, content1, file2, content2)
+        else
+          file_diff(file1, file2)
+        end
+
+      {:diff, diff}
+    end
+  end
+
+  defp beam_diff(file1, content1, file2, content2) do
+    chunk_diff(content1, content2, @atom_chunks, &inspect(&1, pretty: true, limit: :infinity)) ||
+      chunk_diff(content1, content2, @binary_chunks, &(&1 |> write_tmp() |> xxd_dump())) ||
+      (
+        tmp_file1 =
+          file1
+          |> xxd_dump()
+          |> write_tmp()
+
+        tmp_file2 =
+          file2
+          |> xxd_dump()
+          |> write_tmp()
+
+        file_diff(tmp_file1, tmp_file2)
+      )
+  end
+
+  defp chunk_diff(content1, content2, names, formatter) do
+    with {:ok, {module, chunks1}} <- :beam_lib.chunks(content1, names),
+         {:ok, {^module, chunks2}} <- :beam_lib.chunks(content2, names),
+         true <- chunks1 != chunks2 do
+      if length(chunks1) != length(chunks2) do
+        """
+        Different chunks:
+        * #{inspect(chunks1)}
+        * #{inspect(chunks2)}
+        """
+      else
+        for {{name1, chunk1}, {name2, chunk2}} <- Enum.zip(chunks1, chunks2),
+            true = name1 == name2,
+            chunk1 != chunk2 do
+          tmp_file1 = chunk1 |> formatter.() |> write_tmp()
+          tmp_file2 = chunk2 |> formatter.() |> write_tmp()
+          [to_string(name1), ?\n, file_diff(tmp_file1, tmp_file2)]
+        end
+      end
+    else
+      _ -> nil
+    end
+  end
+
+  defp xxd_dump(file) do
+    {dump, _} = System.cmd("xxd", [file])
+    dump
+  end
+
+  defp file_diff(file1, file2) do
+    {diff, _} = System.cmd("diff", ["--suppress-common-lines", file1, file2])
+    diff
+  end
+
+  defp relative_paths(dir) do
+    dir
+    |> Path.join("**")
+    |> Path.wildcard()
+    |> Enum.map(&Path.relative_to(&1, dir))
+  end
+
+  defp assert_dir!(dir) do
+    if not File.dir?(dir) do
+      raise ArgumentError, "#{inspect(dir)} is not a directory"
+    end
+  end
+
+  defp write_tmp(content) do
+    filename = "tmp-#{System.unique_integer([:positive])}"
+    File.mkdir_p!("tmp")
+    File.write!(Path.join("tmp", filename), content)
+    Path.join("tmp", filename)
+  end
+end
+
+if :deterministic not in :compile.env_compiler_options() do
+  IO.puts("Cannot validate if reproducible without setting ERL_COMPILER_OPTIONS=deterministic")
+  System.halt(1)
+end
+
+case System.argv() do
+  [dir1, dir2] ->
+    case Diff.compare_dirs(dir1, dir2) do
+      {[], [], []} ->
+        IO.puts("#{inspect(dir1)} and #{inspect(dir2)} are equal")
+
+      {only1, only2, diff} ->
+        for path <- only1, do: IO.puts("Only in #{dir1}: #{path}")
+        for path <- only2, do: IO.puts("Only in #{dir2}: #{path}")
+        for {path, diff} <- diff, do: IO.puts("Diff #{path}:\n#{diff}")
+
+        System.halt(1)
+    end
+
+  _ ->
+    IO.puts("Please, provide two directories as arguments")
+    System.halt(1)
+end
diff --git a/lib/elixir/scripts/docs_config.exs b/lib/elixir/scripts/docs_config.exs
new file mode 100644
index 00000000000..4e9a35254ff
--- /dev/null
+++ b/lib/elixir/scripts/docs_config.exs
@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+# Generate docs_config.js for version chooser in ExDoc
+[app] = System.argv()
+skipped = Version.parse!("1.0.3")
+root_dir = Path.expand("../../../", __DIR__)
+
+git_repo? =
+  root_dir
+  |> Path.join(".git")
+  |> File.dir?()
+
+versions =
+  if git_repo? do
+    {text_tags, 0} = System.cmd("git", ["tag"])
+
+    for(
+      "v" <> rest <- String.split(text_tags),
+      not String.ends_with?(rest, "-latest"),
+      version = Version.parse!(rest),
+      Version.compare(version, skipped) == :gt,
+      do: version
+    )
+    |> Enum.sort({:desc, Version})
+  else
+    IO.warn("skipping version dropdown", [])
+
+    []
+  end
+
+latest =
+  if git_repo? do
+    versions
+    |> Stream.filter(&(&1.pre == []))
+    |> Enum.fetch!(0)
+    |> Version.to_string()
+  else
+    System.version()
+  end
+
+version_nodes =
+  for version <- versions do
+    version_string = Version.to_string(version)
+    map = %{version: "v#{version_string}", url: "https://hexdocs.pm/#{app}/#{version_string}"}
+
+    if version_string == latest do
+      Map.put(map, :latest, true)
+    else
+      map
+    end
+  end
+
+search_nodes =
+  for app <- ~w(eex elixir ex_unit iex logger mix)s do
+    %{name: app, version: latest}
+  end
+
+File.mkdir_p!("doc/#{app}")
+
+File.write!("doc/#{app}/docs_config.js", """
+var versionNodes = #{JSON.encode_to_iodata!(version_nodes)};
+var searchNodes = #{JSON.encode_to_iodata!(search_nodes)};
+""")
diff --git a/lib/elixir/scripts/elixir_docs.exs b/lib/elixir/scripts/elixir_docs.exs
new file mode 100644
index 00000000000..6caa60a4c46
--- /dev/null
+++ b/lib/elixir/scripts/elixir_docs.exs
@@ -0,0 +1,245 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# Returns config for Elixir docs (exclusively)
+canonical = System.fetch_env!("CANONICAL")
+
+[
+  search: [
+    %{
+      name: "Elixir + libraries",
+      help: "Search Elixir, EEx, ExUnit, IEx, Logger, and Mix",
+      packages:
+        Enum.map(
+          [:elixir, :eex, :ex_unit, :iex, :logger, :mix],
+          &{&1, String.trim(canonical, "/")}
+        )
+    },
+    %{
+      name: "Current project",
+      help: "Search only this project"
+    }
+  ],
+  assets: %{"lib/elixir/pages/images" => "assets"},
+  extras: [
+    "lib/elixir/pages/getting-started/introduction.md",
+    "lib/elixir/pages/getting-started/basic-types.md",
+    "lib/elixir/pages/getting-started/lists-and-tuples.md",
+    "lib/elixir/pages/getting-started/pattern-matching.md",
+    "lib/elixir/pages/getting-started/case-cond-and-if.md",
+    "lib/elixir/pages/getting-started/anonymous-functions.md",
+    "lib/elixir/pages/getting-started/binaries-strings-and-charlists.md",
+    "lib/elixir/pages/getting-started/keywords-and-maps.md",
+    "lib/elixir/pages/getting-started/modules-and-functions.md",
+    "lib/elixir/pages/getting-started/alias-require-and-import.md",
+    "lib/elixir/pages/getting-started/module-attributes.md",
+    "lib/elixir/pages/getting-started/structs.md",
+    "lib/elixir/pages/getting-started/recursion.md",
+    "lib/elixir/pages/getting-started/enumerable-and-streams.md",
+    "lib/elixir/pages/getting-started/comprehensions.md",
+    "lib/elixir/pages/getting-started/protocols.md",
+    "lib/elixir/pages/getting-started/sigils.md",
+    "lib/elixir/pages/getting-started/try-catch-and-rescue.md",
+    "lib/elixir/pages/getting-started/processes.md",
+    "lib/elixir/pages/getting-started/io-and-the-file-system.md",
+    "lib/elixir/pages/getting-started/writing-documentation.md",
+    "lib/elixir/pages/getting-started/optional-syntax.md",
+    "lib/elixir/pages/getting-started/erlang-libraries.md",
+    "lib/elixir/pages/getting-started/debugging.md",
+    "lib/elixir/pages/cheatsheets/enum-cheat.cheatmd",
+    "lib/elixir/pages/cheatsheets/types-cheat.cheatmd",
+    "lib/elixir/pages/anti-patterns/what-anti-patterns.md",
+    "lib/elixir/pages/anti-patterns/code-anti-patterns.md",
+    "lib/elixir/pages/anti-patterns/design-anti-patterns.md",
+    "lib/elixir/pages/anti-patterns/process-anti-patterns.md",
+    "lib/elixir/pages/anti-patterns/macro-anti-patterns.md",
+    "lib/elixir/pages/references/compatibility-and-deprecations.md",
+    "lib/elixir/pages/references/gradual-set-theoretic-types.md",
+    "lib/elixir/pages/references/library-guidelines.md",
+    "lib/elixir/pages/references/naming-conventions.md",
+    "lib/elixir/pages/references/operators.md",
+    "lib/elixir/pages/references/patterns-and-guards.md",
+    "lib/elixir/pages/references/syntax-reference.md",
+    "lib/elixir/pages/references/typespecs.md",
+    "lib/elixir/pages/references/unicode-syntax.md",
+    "lib/elixir/pages/mix-and-otp/introduction-to-mix.md",
+    "lib/elixir/pages/mix-and-otp/agents.md",
+    "lib/elixir/pages/mix-and-otp/supervisor-and-application.md",
+    "lib/elixir/pages/mix-and-otp/dynamic-supervisor.md",
+    "lib/elixir/pages/mix-and-otp/task-and-gen-tcp.md",
+    "lib/elixir/pages/mix-and-otp/docs-tests-and-with.md",
+    "lib/elixir/pages/mix-and-otp/config-and-distribution.md",
+    "lib/elixir/pages/mix-and-otp/genservers.md",
+    "lib/elixir/pages/mix-and-otp/releases.md",
+    "lib/elixir/pages/meta-programming/quote-and-unquote.md",
+    "lib/elixir/pages/meta-programming/macros.md",
+    "lib/elixir/pages/meta-programming/domain-specific-languages.md",
+    "CHANGELOG.md"
+  ],
+  deps: [
+    eex: "https://hexdocs.pm/eex/#{canonical}",
+    ex_unit: "https://hexdocs.pm/ex_unit/#{canonical}",
+    iex: "https://hexdocs.pm/iex/#{canonical}",
+    logger: "https://hexdocs.pm/logger/#{canonical}",
+    mix: "https://hexdocs.pm/mix/#{canonical}"
+  ],
+  groups_for_extras: [
+    "Getting started": ~r"pages/getting-started/.*\.md$",
+    Cheatsheets: ~r"pages/cheatsheets/.*\.cheatmd$",
+    "Mix & OTP": ~r"pages/mix-and-otp/.*\.md$",
+    "Anti-patterns": ~r"pages/anti-patterns/.*\.md$",
+    "Meta-programming": ~r"pages/meta-programming/.*\.md$",
+    References: ~r"pages/references/.*\.md$"
+  ],
+  groups_for_docs: [
+    Guards: &(&1[:guard] == true)
+  ],
+  skip_undefined_reference_warnings_on: [
+    "lib/elixir/pages/references/compatibility-and-deprecations.md"
+  ],
+  skip_code_autolink_to: [
+    "Enumerable.List",
+    "Inspect.MapSet"
+  ],
+  formatters: ["html", "epub"],
+  groups_for_modules: [
+    # [Kernel, Kernel.SpecialForms],
+
+    "Data Types": [
+      Atom,
+      Base,
+      Bitwise,
+      Date,
+      DateTime,
+      Duration,
+      Exception,
+      Float,
+      Function,
+      Integer,
+      JSON,
+      Module,
+      NaiveDateTime,
+      Record,
+      Regex,
+      String,
+      Time,
+      Tuple,
+      URI,
+      Version,
+      Version.Requirement
+    ],
+    "Collections & Enumerables": [
+      Access,
+      Date.Range,
+      Enum,
+      Keyword,
+      List,
+      Map,
+      MapSet,
+      Range,
+      Stream
+    ],
+    "IO & System": [
+      File,
+      File.Stat,
+      File.Stream,
+      IO,
+      IO.ANSI,
+      IO.Stream,
+      OptionParser,
+      Path,
+      Port,
+      StringIO,
+      System
+    ],
+    Calendar: [
+      Calendar,
+      Calendar.ISO,
+      Calendar.TimeZoneDatabase,
+      Calendar.UTCOnlyTimeZoneDatabase
+    ],
+    "Processes & Applications": [
+      Agent,
+      Application,
+      Config,
+      Config.Provider,
+      Config.Reader,
+      DynamicSupervisor,
+      GenServer,
+      Node,
+      PartitionSupervisor,
+      Process,
+      Registry,
+      Supervisor,
+      Task,
+      Task.Supervisor
+    ],
+    Protocols: [
+      Collectable,
+      Enumerable,
+      JSON.Encoder,
+      Inspect,
+      Inspect.Algebra,
+      Inspect.Opts,
+      List.Chars,
+      Protocol,
+      String.Chars
+    ],
+    "Code & Macros": [
+      Code,
+      Code.Fragment,
+      Kernel.ParallelCompiler,
+      Macro,
+      Macro.Env
+    ]
+
+    ## Automatically detected groups
+
+    # Deprecated: [
+    #   Behaviour,
+    #   Dict,
+    #   GenEvent,
+    #   HashDict,
+    #   HashSet,
+    #   Set,
+    #   Supervisor.Spec
+    # ]
+  ],
+  before_closing_body_tag: fn
+    :html ->
+      """
+      <script defer src="https://cdn.jsdelivr.net/npm/mermaid@11.6.0/dist/mermaid.min.js"></script>
+      <script>
+        let initialized = false;
+
+        window.addEventListener("exdoc:loaded", () => {
+          if (!initialized) {
+            mermaid.initialize({
+              startOnLoad: false,
+              theme: document.body.className.includes("dark") ? "dark" : "default"
+            });
+            initialized = true;
+          }
+
+          let id = 0;
+          for (const codeEl of document.querySelectorAll("pre code.mermaid")) {
+            const preEl = codeEl.parentElement;
+            const graphDefinition = codeEl.textContent;
+            const graphEl = document.createElement("div");
+            const graphId = "mermaid-graph-" + id++;
+            mermaid.render(graphId, graphDefinition).then(({svg, bindFunctions}) => {
+              graphEl.innerHTML = svg;
+              bindFunctions?.(graphEl);
+              preEl.insertAdjacentElement("afterend", graphEl);
+              preEl.remove();
+            });
+          }
+        });
+      </script>
+      """
+
+    _ ->
+      ""
+  end
+]
diff --git a/lib/elixir/scripts/generate_app.escript b/lib/elixir/scripts/generate_app.escript
new file mode 100755
index 00000000000..8959fff4c25
--- /dev/null
+++ b/lib/elixir/scripts/generate_app.escript
@@ -0,0 +1,20 @@
+#!/usr/bin/env escript
+
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+%% -*- erlang -*-
+
+main([Version]) ->
+  Source = "lib/elixir/src/elixir.app.src",
+  Target = "lib/elixir/ebin/elixir.app",
+  {ok, [{application, Name, Props0}]} = file:consult(Source),
+  Ebin = filename:dirname(Target),
+  Files = filelib:wildcard(filename:join(Ebin, "*.beam")),
+  Mods = [list_to_atom(filename:basename(F, ".beam")) || F <- Files],
+  Props1 = lists:keyreplace(modules, 1, Props0, {modules, Mods}),
+  Props = lists:keyreplace(vsn, 1, Props1, {vsn, Version}),
+  AppDef = io_lib:format("~tp.~n", [{application, Name, Props}]),
+  ok = file:write_file(Target, AppDef),
+  io:format("Generated ~ts app~n", [Name]).
diff --git a/lib/elixir/scripts/mix_docs.exs b/lib/elixir/scripts/mix_docs.exs
new file mode 100644
index 00000000000..965153537e6
--- /dev/null
+++ b/lib/elixir/scripts/mix_docs.exs
@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+# Returns config for other apps except Elixir
+canonical = System.fetch_env!("CANONICAL")
+
+[
+  search: [
+    %{
+      name: "Elixir + libraries",
+      help: "Search Elixir, EEx, ExUnit, IEx, Logger, and Mix",
+      packages:
+        Enum.map(
+          [:elixir, :eex, :ex_unit, :iex, :logger, :mix],
+          &{&1, String.trim(canonical, "/")}
+        )
+    },
+    %{
+      name: "Current project",
+      help: "Search only this project"
+    }
+  ],
+  deps: [
+    eex: "https://hexdocs.pm/eex/#{canonical}",
+    elixir: "https://hexdocs.pm/elixir/#{canonical}",
+    ex_unit: "https://hexdocs.pm/ex_unit/#{canonical}",
+    iex: "https://hexdocs.pm/iex/#{canonical}",
+    logger: "https://hexdocs.pm/logger/#{canonical}",
+    mix: "https://hexdocs.pm/mix/#{canonical}"
+  ],
+  formatters: ["html", "epub"],
+  before_closing_body_tag: fn
+    :html ->
+      """
+      <script defer src="https://cdn.jsdelivr.net/npm/mermaid@11.6.0/dist/mermaid.min.js"></script>
+      <script>
+        let initialized = false;
+
+        window.addEventListener("exdoc:loaded", () => {
+          if (!initialized) {
+            mermaid.initialize({
+              startOnLoad: false,
+              theme: document.body.className.includes("dark") ? "dark" : "default"
+            });
+            initialized = true;
+          }
+
+          let id = 0;
+          for (const codeEl of document.querySelectorAll("pre code.mermaid")) {
+            const preEl = codeEl.parentElement;
+            const graphDefinition = codeEl.textContent;
+            const graphEl = document.createElement("div");
+            const graphId = "mermaid-graph-" + id++;
+            mermaid.render(graphId, graphDefinition).then(({svg, bindFunctions}) => {
+              graphEl.innerHTML = svg;
+              bindFunctions?.(graphEl);
+              preEl.insertAdjacentElement("afterend", graphEl);
+              preEl.remove();
+            });
+          }
+        });
+      </script>
+      """
+
+    _ ->
+      ""
+  end
+]
diff --git a/lib/elixir/scripts/windows_installer/.gitignore b/lib/elixir/scripts/windows_installer/.gitignore
new file mode 100644
index 00000000000..b5914cb62a6
--- /dev/null
+++ b/lib/elixir/scripts/windows_installer/.gitignore
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+tmp/
diff --git a/lib/elixir/scripts/windows_installer/assets/Elixir.ico b/lib/elixir/scripts/windows_installer/assets/Elixir.ico
new file mode 100644
index 00000000000..b0ba3ebae48
Binary files /dev/null and b/lib/elixir/scripts/windows_installer/assets/Elixir.ico differ
diff --git a/lib/elixir/scripts/windows_installer/build.sh b/lib/elixir/scripts/windows_installer/build.sh
new file mode 100755
index 00000000000..eb31f5916fa
--- /dev/null
+++ b/lib/elixir/scripts/windows_installer/build.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+# Usage:
+#
+# With Elixir archive:
+#
+#     ELIXIR_ZIP=Precompiled.zip OTP_VERSION=25.3.2.2 ./build.sh
+set -euo pipefail
+
+mkdir -p tmp
+rm -rf tmp/elixir
+unzip -d "tmp/elixir" "${ELIXIR_ZIP}"
+
+elixir_version=`cat tmp/elixir/VERSION`
+otp_release=`erl -noshell -eval 'io:put_chars(erlang:system_info(otp_release)), halt().'`
+otp_version=`erl -noshell -eval '{ok, Vsn} = file:read_file(code:root_dir() ++ "/releases/" ++ erlang:system_info(otp_release) ++ "/OTP_VERSION"), io:put_chars(Vsn), halt().'`
+elixir_exe=elixir-otp-${otp_release}.exe
+
+# brew install makensis
+# apt install -y nsis
+# choco install -y nsis
+export PATH="/c/Program Files (x86)/NSIS:${PATH}"
+makensis \
+  -X"OutFile tmp\\${elixir_exe}" \
+  -DOTP_RELEASE="${otp_release}" \
+  -DOTP_VERSION=${otp_version} \
+  -DELIXIR_DIR=tmp\\elixir \
+  -DELIXIR_VERSION=${elixir_version} \
+  installer.nsi
+
+echo "Installer path: tmp/${elixir_exe}"
diff --git a/lib/elixir/scripts/windows_installer/installer.nsi b/lib/elixir/scripts/windows_installer/installer.nsi
new file mode 100644
index 00000000000..b6f084c4a35
--- /dev/null
+++ b/lib/elixir/scripts/windows_installer/installer.nsi
@@ -0,0 +1,293 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+!include "MUI2.nsh"
+!include "StrFunc.nsh"
+${Using:StrFunc} UnStrStr
+
+Name "Elixir"
+ManifestDPIAware true
+Unicode True
+InstallDir "$PROGRAMFILES64\Elixir"
+!define MUI_ICON "assets\Elixir.ico"
+!define MUI_UNICON "assets\Elixir.ico"
+
+; Install Page: Install Erlang/OTP
+
+Page custom CheckOTPPageShow CheckOTPPageLeave
+
+var InstalledOTPRelease
+var OTPPath
+
+var Dialog
+var NoOTPLabel
+var NoOTPLabelCreated
+var OTPMismatchLabel
+var OTPMismatchLabelCreated
+var DownloadOTPLink
+var DownloadOTPLinkCreated
+var VerifyOTPButton
+var VerifyOTPButtonCreated
+Function CheckOTPPageShow
+  !insertmacro MUI_HEADER_TEXT "Checking Erlang/OTP" ""
+
+  nsDialogs::Create 1018
+  Pop $Dialog
+
+  ${If} $Dialog == error
+    Abort
+  ${EndIf}
+
+  Call VerifyOTP
+
+  nsDialogs::Show
+FunctionEnd
+
+Function VerifyOTP
+  ${If} $NoOTPLabelCreated == "true"
+    ShowWindow $NoOTPLabel ${SW_HIDE}
+  ${EndIf}
+
+  ${If} $OTPMismatchLabelCreated == "true"
+    ShowWindow $OTPMismatchLabel ${SW_HIDE}
+  ${EndIf}
+
+  ${If} $DownloadOTPLinkCreated == "true"
+    ShowWindow $DownloadOTPLink ${SW_HIDE}
+  ${Else}
+    StrCpy $DownloadOTPLinkCreated "true"
+    ${NSD_CreateLink}  0 60u 100% 20u "Download Erlang/OTP ${OTP_RELEASE}"
+    Pop $DownloadOTPLink
+    ${NSD_OnClick} $DownloadOTPLink OpenOTPDownloads
+    ShowWindow $DownloadOTPLink ${SW_HIDE}
+  ${EndIf}
+
+  ${If} $VerifyOTPButtonCreated == "true"
+    ShowWindow $VerifyOTPButton ${SW_HIDE}
+  ${Else}
+    StrCpy $VerifyOTPButtonCreated "true"
+    ${NSD_CreateButton} 0 80u 25% 12u "Verify Erlang/OTP"
+    Pop $VerifyOTPButton
+    ${NSD_OnClick} $VerifyOTPButton VerifyOTP
+    ShowWindow $VerifyOTPButton ${SW_HIDE}
+  ${EndIf}
+
+  StrCpy $0 0
+  loop:
+    EnumRegKey $1 HKLM "SOFTWARE\WOW6432NODE\Ericsson\Erlang" $0
+    StrCmp $1 "" done
+    ReadRegStr $1 HKLM "SOFTWARE\WOW6432NODE\Ericsson\Erlang\$1" ""
+    StrCpy $OTPPath $1
+    IntOp $0 $0 + 1
+    goto loop
+  done:
+
+  ${If} $OTPPath == ""
+    ${If} $NoOTPLabelCreated != "true"
+      StrCpy $NoOTPLabelCreated "true"
+      ${NSD_CreateLabel} 0 0   100% 20u "Couldn't find existing Erlang/OTP installation. Click the link below to download and install it before proceeding."
+      Pop $NoOTPLabel
+    ${EndIf}
+
+    ShowWindow $NoOTPLabel ${SW_SHOW}
+    ShowWindow $DownloadOTPLink ${SW_SHOW}
+    ShowWindow $VerifyOTPButton ${SW_SHOW}
+
+  ${Else}
+    nsExec::ExecToStack `$OTPPath\bin\erl.exe -noinput -eval "\
+    io:put_chars(erlang:system_info(otp_release)),\
+    halt()."`
+    Pop $0
+    Pop $1
+
+    ${If} $0 == 0
+      StrCpy $InstalledOTPRelease $1
+      ${If} $InstalledOTPRelease == ${OTP_RELEASE}
+        ${NSD_CreateLabel} 0 0 100% 60u "Found existing Erlang/OTP $InstalledOTPRelease installation at $OTPPath. Please proceed."
+
+      ${Else}
+        ${If} $OTPMismatchLabelCreated != "true"
+          StrCpy $OTPMismatchLabelCreated "true"
+          ${NSD_CreateLabel} 0 0 100% 60u "Found existing Erlang/OTP $InstalledOTPRelease installation at $OTPPath but this Elixir installer was precompiled for Erlang/OTP ${OTP_RELEASE}. \
+          $\r$\n$\r$\nYou can either search for another Elixir installer precompiled for Erlang/OTP $InstalledOTPRelease or download Erlang/OTP ${OTP_RELEASE} and install before proceeding."
+          Pop $OTPMismatchLabel
+        ${EndIf}
+
+        ShowWindow $OTPMismatchLabel ${SW_SHOW}
+        ShowWindow $DownloadOTPLink  ${SW_SHOW}
+        ShowWindow $VerifyOTPButton  ${SW_SHOW}
+      ${EndIf}
+    ${Else}
+      SetErrorlevel 5
+      MessageBox MB_ICONSTOP "Found existing Erlang/OTP installation at $OTPPath but checking it exited with $0: $1"
+    ${EndIf}
+  ${EndIf}
+FunctionEnd
+
+Function OpenOTPDownloads
+  ExecShell "open" "https://www.erlang.org/downloads/${OTP_RELEASE}"
+FunctionEnd
+
+Function CheckOTPPageLeave
+FunctionEnd
+
+; Install Page: Files
+
+!insertmacro MUI_PAGE_DIRECTORY
+!insertmacro MUI_PAGE_INSTFILES
+
+; Install Page: Finish
+
+Page custom FinishPageShow FinishPageLeave
+
+var AddOTPToPathCheckbox
+var AddElixirToPathCheckbox
+Function FinishPageShow
+  !insertmacro MUI_HEADER_TEXT "Finish Setup" ""
+
+  nsDialogs::Create 1018
+  Pop $Dialog
+
+  ${If} $Dialog == error
+    Abort
+  ${EndIf}
+
+  ; we add to PATH using erlang, so there must be an OTP installed to do so.
+  ${If} "$OTPPath" != ""
+    ${NSD_CreateCheckbox} 0 0 195u 10u "&Add $INSTDIR\bin to %PATH%"
+    Pop $AddElixirToPathCheckbox
+    SendMessage $AddElixirToPathCheckbox ${BM_SETCHECK} ${BST_CHECKED} 0
+
+    ${NSD_CreateCheckbox} 0 20u 195u 10u "&Add $OTPPath\bin to %PATH%"
+    Pop $AddOTPToPathCheckbox
+    SendMessage $AddOTPToPathCheckbox ${BM_SETCHECK} ${BST_CHECKED} 0
+
+    ${NSD_CreateLabel} 0 40u 100% 20u "Note: you need to restart your shell for the environment variable changes to take effect."
+  ${EndIf}
+
+  nsDialogs::Show
+FunctionEnd
+
+var PathsToAdd
+Function FinishPageLeave
+  ${NSD_GetState} $AddOTPToPathCheckbox $0
+  ${If} $0 <> ${BST_UNCHECKED}
+    StrCpy $PathsToAdd ";$OTPPath\bin"
+  ${EndIf}
+
+  ${NSD_GetState} $AddElixirToPathCheckbox $0
+  ${If} $0 <> ${BST_UNCHECKED}
+    StrCpy $PathsToAdd "$PathsToAdd;$INSTDIR\bin"
+  ${EndIf}
+
+  ${If} "$PathsToAdd" != ""
+    nsExec::ExecToStack `"$OTPPath\bin\escript.exe" "$INSTDIR\update_system_path.erl" add "$PathsToAdd"`
+    Pop $0
+    Pop $1
+    ${If} $0 != 0
+      SetErrorlevel 5
+      MessageBox MB_ICONSTOP "adding paths failed with $0: $1"
+      Quit
+    ${EndIf}
+  ${EndIf}
+FunctionEnd
+
+Section "Install Elixir" SectionElixir
+  SetOutPath "$INSTDIR"
+  File /r "${ELIXIR_DIR}\"
+  File "assets\Elixir.ico"
+  File "update_system_path.erl"
+  WriteRegStr   HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\Elixir" "DisplayName" "Elixir"
+  WriteRegStr   HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\Elixir" "DisplayVersion" "${ELIXIR_VERSION}"
+  WriteRegStr   HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\Elixir" "DisplayIcon" "$INSTDIR\Elixir.ico"
+  WriteRegStr   HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\Elixir" "Publisher" "The Elixir Team"
+  WriteRegStr   HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\Elixir" "UninstallString" '"$INSTDIR\Uninstall.exe"'
+  WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\Elixir" "NoModify" 1
+  WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\Elixir" "NoRepair" 1
+
+  WriteRegStr   HKLM "Software\Elixir\Elixir" "InstallRoot" "$INSTDIR"
+
+  WriteUninstaller "Uninstall.exe"
+SectionEnd
+
+; Uninstall Page: Remove from %PATH%
+
+var RemoveOTPFromPathCheckbox
+var RemoveElixirFromPathCheckbox
+Function un.FinishPageShow
+  !insertmacro MUI_HEADER_TEXT "Remove from %PATH%" ""
+
+  StrCpy $0 0
+  loop:
+    EnumRegKey $1 HKLM "SOFTWARE\WOW6432NODE\Ericsson\Erlang" $0
+    StrCmp $1 "" done
+    ReadRegStr $1 HKLM "SOFTWARE\WOW6432NODE\Ericsson\Erlang\$1" ""
+    StrCpy $OTPPath $1
+    IntOp $0 $0 + 1
+    goto loop
+  done:
+
+  nsDialogs::Create 1018
+  Pop $Dialog
+
+  ${If} $Dialog == error
+    Abort
+  ${EndIf}
+
+  ReadRegStr $0 HKCU "Environment" "Path"
+
+  ${UnStrStr} $1 "$0" "$INSTDIR\bin"
+  ${If} $1 != ""
+    ${NSD_CreateCheckbox} 0 0 195u 10u "&Remove $INSTDIR\bin from %PATH%"
+    Pop $RemoveElixirFromPathCheckbox
+    SendMessage $RemoveElixirFromPathCheckbox ${BM_SETCHECK} ${BST_CHECKED} 0
+  ${EndIf}
+
+  ${UnStrStr} $1 "$0" "$OTPPath\bin"
+  ${If} $1 != ""
+    ${NSD_CreateCheckbox} 0 20u 195u 10u "&Remove $OTPPath\bin from %PATH%"
+    Pop $RemoveOTPFromPathCheckbox
+    SendMessage $RemoveOTPFromPathCheckbox ${BM_SETCHECK} ${BST_CHECKED} 0
+  ${EndIf}
+
+  nsDialogs::Show
+FunctionEnd
+
+var PathsToRemove
+Function un.FinishPageLeave
+  ${NSD_GetState} $RemoveOTPFromPathCheckbox $1
+  ${If} $1 <> ${BST_UNCHECKED}
+    StrCpy $PathsToRemove ";$OTPPath\bin"
+  ${EndIf}
+
+  ${NSD_GetState} $RemoveElixirFromPathCheckbox $1
+  ${If} $1 <> ${BST_UNCHECKED}
+    StrCpy $PathsToRemove "$PathsToRemove;$INSTDIR\bin"
+  ${EndIf}
+
+  ${If} "$PathsToRemove" != ""
+    nsExec::ExecToStack `"$OTPPath\bin\escript.exe" "$INSTDIR\update_system_path.erl" remove "$PathsToRemove"`
+    Pop $0
+    Pop $1
+    ${If} $0 != 0
+      SetErrorlevel 5
+      MessageBox MB_ICONSTOP "removing paths failed with $0: $1"
+      Quit
+    ${EndIf}
+  ${EndIf}
+FunctionEnd
+
+UninstPage custom un.FinishPageShow un.FinishPageLeave
+
+!insertmacro MUI_UNPAGE_DIRECTORY
+!insertmacro MUI_UNPAGE_INSTFILES
+
+Section "Uninstall"
+  RMDir /r "$INSTDIR"
+  DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\Elixir"
+  DeleteRegKey HKLM "Software\Elixir\Elixir"
+  DeleteRegKey /ifempty HKLM "Software\Elixir"
+SectionEnd
+
+!insertmacro MUI_LANGUAGE "English"
diff --git a/lib/elixir/scripts/windows_installer/update_system_path.erl b/lib/elixir/scripts/windows_installer/update_system_path.erl
new file mode 100644
index 00000000000..568f781bb8b
--- /dev/null
+++ b/lib/elixir/scripts/windows_installer/update_system_path.erl
@@ -0,0 +1,45 @@
+#!/usr/bin/env escript
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+
+%%! -noinput
+
+%% This file is used by the Elixir installer and uninstaller.
+main(["add", ";" ++ PathsToAdd]) ->
+  {ok, Reg} = win32reg:open([read, write]),
+  ok = win32reg:change_key(Reg, "\\hkey_current_user\\environment"),
+  {ok, SystemPath} = win32reg:value(Reg, "path"),
+
+  NewSystemPath =
+    lists:foldl(
+      fun(Elem, Acc) ->
+        Elem ++ ";" ++
+          binary_to_list(
+            iolist_to_binary(
+              string:replace(Acc, Elem ++ ";", "", all)))
+      end,
+      SystemPath,
+      string:split(PathsToAdd, ";", all)
+    ),
+
+  ok = win32reg:set_value(Reg, "Path", NewSystemPath),
+  ok;
+
+main(["remove", ";" ++ PathsToRemove]) ->
+  {ok, Reg} = win32reg:open([read, write]),
+  ok = win32reg:change_key(Reg, "\\hkey_current_user\\environment"),
+  {ok, SystemPath} = win32reg:value(Reg, "path"),
+
+  NewSystemPath =
+    lists:foldl(
+      fun(Elem, Acc) ->
+        binary_to_list(
+          iolist_to_binary(
+            string:replace(Acc, Elem ++ ";", "", all)))
+      end,
+      SystemPath,
+      string:split(PathsToRemove, ";", all)
+    ),
+
+  ok = win32reg:set_value(Reg, "Path", NewSystemPath),
+  ok.
diff --git a/lib/elixir/src/elixir.app.src b/lib/elixir/src/elixir.app.src
new file mode 100644
index 00000000000..b7b5aaca5b8
--- /dev/null
+++ b/lib/elixir/src/elixir.app.src
@@ -0,0 +1,32 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+{application, elixir,
+[{description, "elixir"},
+ {vsn, '$will-be-replaced'},
+ {modules, '$will-be-replaced'},
+ {registered, [elixir_sup, elixir_config, elixir_code_server]},
+ {applications, [kernel,stdlib,compiler]},
+ {mod, {elixir,[]}},
+ {env, [
+  {ansi_syntax_colors, [
+    {atom, cyan},
+    {binary, default_color},
+    {boolean, magenta},
+    {charlist, yellow},
+    {list, default_color},
+    {map, default_color},
+    {nil, magenta},
+    {number, yellow},
+    {string, green},
+    {tuple, default_color},
+    {variable, light_cyan},
+    {call, default_color},
+    {operator, default_color}
+  ]},
+  {check_endianness, true},
+  {dbg_callback, {'Elixir.Macro', dbg, []}},
+  {time_zone_database, 'Elixir.Calendar.UTCOnlyTimeZoneDatabase'}
+ ]}
+]}.
diff --git a/lib/elixir/src/elixir.erl b/lib/elixir/src/elixir.erl
index a7548c56489..352c529dc61 100644
--- a/lib/elixir/src/elixir.erl
+++ b/lib/elixir/src/elixir.erl
@@ -1,221 +1,524 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 %% Main entry point for Elixir functions. All of those functions are
 %% private to the Elixir compiler and reserved to be used by Elixir only.
 -module(elixir).
 -behaviour(application).
--export([main/1, start_cli/0,
-  string_to_quoted/4, 'string_to_quoted!'/4,
-  env_for_eval/1, env_for_eval/2, quoted_to_erl/2, quoted_to_erl/3,
-  eval/2, eval/3, eval_forms/3, eval_forms/4, eval_quoted/3]).
+-export([start_cli/0, start/0]).
+-export([start/2, stop/1, config_change/3]).
+-export([
+  string_to_tokens/5, tokens_to_quoted/3, 'string_to_quoted!'/5,
+  env_for_eval/1, quoted_to_erl/2, eval_forms/3, eval_quoted/3,
+  eval_quoted/4, eval_local_handler/2, eval_external_handler/3,
+  format_token_error/1
+]).
 -include("elixir.hrl").
+-define(system, 'Elixir.System').
+-define(elixir_eval_env, {elixir, eval_env}).
 
 %% Top level types
--export_type([char_list/0, as_boolean/1]).
+%% TODO: Remove char_list type on v2.0
+-export_type([charlist/0, char_list/0, nonempty_charlist/0, struct/0, as_boolean/1, keyword/0, keyword/1]).
+-type charlist() :: string().
 -type char_list() :: string().
+-type nonempty_charlist() :: nonempty_string().
 -type as_boolean(T) :: T.
+-type keyword() :: [{atom(), any()}].
+-type keyword(T) :: [{atom(), T}].
+-type struct() :: #{'__struct__' := atom(), atom() => any()}.
 
 %% OTP Application API
 
--export([start/2, stop/1, config_change/3]).
-
 start(_Type, _Args) ->
-  %% In case there is a shell, we can't really change its
-  %% encoding, so we just set binary to true. Otherwise
-  %% we must set the encoding as the user with no shell
-  %% has encoding set to latin1.
-  Opts =
-    case init:get_argument(noshell) of
-      {ok, _} -> [binary,{encoding,utf8}];
-      error   -> [binary]
-    end,
-
-  io:setopts(standard_io, Opts),
-  io:setopts(standard_error, [{unicode,true}]),
-  case file:native_name_encoding() of
-    latin1 ->
-      io:format(standard_error,
-        "warning: the VM is running with native name encoding of latin1 which may cause "
-        "Elixir to malfunction as it expects utf8. Please ensure your locale is set to UTF-8 "
-        "(which can be verified by running \"locale\" in your shell)~n", []);
+  _OTP = parse_otp_release(),
+  preload_common_modules(),
+  ok = io:setopts(standard_io, [binary]),
+  check_file_encoding(file:native_name_encoding()),
+
+  case init:get_argument(elixir_root) of
+    {ok, [[Root]]} ->
+      code:add_pathsa([
+        Root ++ "/eex/ebin",
+        Root ++ "/ex_unit/ebin",
+        Root ++ "/iex/ebin",
+        Root ++ "/logger/ebin",
+        Root ++ "/mix/ebin",
+        Root ++ "/elixir/ebin"
+      ], cache);
     _ ->
       ok
   end,
 
-  elixir_sup:start_link().
+  case application:get_env(elixir, check_endianness, true) of
+    true  -> check_endianness();
+    false -> ok
+  end,
+
+  case application:get_env(elixir, ansi_enabled) of
+    {ok, _} ->
+      ok;
 
-stop(_S) ->
-  ok.
+    undefined ->
+      application:set_env(elixir, ansi_enabled, prim_tty:isatty(stdout) == true)
+  end,
+
+  Tokenizer = case code:ensure_loaded('Elixir.String.Tokenizer') of
+    {module, Mod} -> Mod;
+    _ -> elixir_tokenizer
+  end,
+
+  URIConfig = [
+    {{uri, <<"ftp">>}, 21},
+    {{uri, <<"sftp">>}, 22},
+    {{uri, <<"tftp">>}, 69},
+    {{uri, <<"http">>}, 80},
+    {{uri, <<"https">>}, 443},
+    {{uri, <<"ldap">>}, 389},
+    {{uri, <<"ws">>}, 80},
+    {{uri, <<"wss">>}, 443}
+  ],
+
+  Config = [
+    %% ARGV options
+    {at_exit, []},
+    {argv, []},
+    {no_halt, false},
+
+    %% Compiler options
+    {docs, true},
+    {ignore_already_consolidated, false},
+    {ignore_module_conflict, false},
+    {infer_signatures, [elixir]},
+    {on_undefined_variable, raise},
+    {parser_options, [{columns, true}]},
+    {debug_info, true},
+    {relative_paths, true},
+    {no_warn_undefined, []},
+    {tracers, []}
+    | URIConfig
+  ],
+
+  elixir_config:static(#{bootstrap => false, identifier_tokenizer => Tokenizer}),
+  Tab = elixir_config:new(Config),
+
+  case elixir_sup:start_link() of
+    {ok, Sup} ->
+      {ok, Sup, Tab};
+    {error, _Reason} = Error ->
+      elixir_config:delete(Tab),
+      Error
+  end.
+
+stop(Tab) ->
+  elixir_config:delete(Tab).
 
 config_change(_Changed, _New, _Remove) ->
   ok.
 
-%% escript entry point
+preload_common_modules() ->
+  %% We attempt to load those modules here so throughout
+  %% the codebase we can avoid code:ensure_loaded/1 checks.
+  _ = code:ensure_loaded('Elixir.Kernel'),
+  _ = code:ensure_loaded('Elixir.Macro.Env'),
+  ok.
 
-main(Args) ->
-  application:start(?MODULE),
-  'Elixir.Kernel.CLI':main(Args).
+parse_otp_release() ->
+  %% Whenever we change this check, we should also change Makefile.
+  case string:to_integer(erlang:system_info(otp_release)) of
+    {Num, _} when Num >= 26 ->
+      case Num == 28 andalso (code:ensure_loaded(re) == {module, re}) andalso not erlang:function_exported(re, import, 1) of
+        true ->
+          io:format(standard_error,
+            "warning! Erlang/OTP 28.0 detected.~n"
+            "Regexes will be re-compiled from source at runtime, which will cause degraded performance.~n"
+            "This can be fixed by using Erlang OTP 28.1+ or 27-.~n"
+          , []);
+        false ->
+          ok
+      end,
+      Num;
+    _ ->
+      io:format(standard_error, "ERROR! Unsupported Erlang/OTP version, expected Erlang/OTP 26+~n", []),
+      erlang:halt(1)
+  end.
+
+check_endianness() ->
+  case code:ensure_loaded(?system) of
+    {module, ?system} ->
+      Endianness = ?system:endianness(),
+      case ?system:compiled_endianness() of
+        Endianness ->
+          ok;
+        _ ->
+          io:format(standard_error,
+            "warning: Elixir is running in a system with a different endianness than the one its "
+            "source code was compiled in. Please make sure Elixir and all source files were compiled "
+            "in a machine with the same endianness as the current one: ~ts~n", [Endianness])
+      end;
+    {error, _} ->
+      ok
+  end.
+
+check_file_encoding(Encoding) ->
+  case Encoding of
+    latin1 ->
+      io:format(standard_error,
+        "warning: the VM is running with native name encoding of latin1 which may cause "
+        "Elixir to malfunction as it expects utf8. Please ensure your locale is set to UTF-8 "
+        "(which can be verified by running \"locale\" in your shell) or set the "
+        "ELIXIR_ERL_OPTIONS=\"+fnu\" environment variable~n", []);
+    _ ->
+      ok
+  end.
 
 %% Boot and process given options. Invoked by Elixir's script.
 
+start() ->
+  user_drv:start(#{initial_shell => iex:shell()}).
+
 start_cli() ->
-  application:start(?MODULE),
+  {ok, _} = application:ensure_all_started(elixir),
+
+  %% We start the Logger so tools that depend on Elixir
+  %% always have the Logger directly accessible. However
+  %% Logger is not a dependency of the Elixir application,
+  %% which means releases that want to use Logger must
+  %% always list it as part of its applications.
+  _ = case code:ensure_loaded('Elixir.Logger') of
+    {module, _} -> application:start(logger);
+    {error, _}  -> ok
+  end,
+
   'Elixir.Kernel.CLI':main(init:get_plain_arguments()).
 
 %% EVAL HOOKS
 
-env_for_eval(Opts) ->
-  env_for_eval((elixir_env:new())#{
-    local := nil,
-    requires := elixir_dispatch:default_requires(),
-    functions := elixir_dispatch:default_functions(),
-    macros := elixir_dispatch:default_macros()
- }, Opts).
-
-env_for_eval(Env, Opts) ->
-  Line = case lists:keyfind(line, 1, Opts) of
-    {line, LineOpt} when is_integer(LineOpt) -> LineOpt;
-    false -> ?m(Env, line)
+env_for_eval(#{lexical_tracker := Pid} = Env) ->
+  NewEnv = Env#{
+    context := nil,
+    macro_aliases := [],
+    versioned_vars := #{}
+  },
+
+  case is_pid(Pid) of
+    true ->
+      case is_process_alive(Pid) of
+        true ->
+          NewEnv;
+        false ->
+          'Elixir.IO':warn(
+            <<"an __ENV__ with outdated compilation information was given to eval, "
+              "call Macro.Env.prune_compile_info/1 to prune it">>
+          ),
+          NewEnv#{lexical_tracker := nil, tracers := []}
+      end;
+    false ->
+      NewEnv#{tracers := []}
+  end;
+env_for_eval(Opts) when is_list(Opts) ->
+  Env = elixir_env:new(),
+  Line = elixir_utils:get_line(Opts, Env),
+  File = elixir_utils:get_file(Opts, Env),
+
+  Module = case lists:keyfind(module, 1, Opts) of
+    {module, ModuleOpt} when is_atom(ModuleOpt) -> ModuleOpt;
+    false -> nil
   end,
 
-  File = case lists:keyfind(file, 1, Opts) of
-    {file, FileOpt} when is_binary(FileOpt) -> FileOpt;
-    false -> ?m(Env, file)
+  FA = case lists:keyfind(function, 1, Opts) of
+    {function, {Function, Arity}} when is_atom(Function), is_integer(Arity) -> {Function, Arity};
+    {function, nil} -> nil;
+    false -> nil
   end,
 
-  Local = case lists:keyfind(delegate_locals_to, 1, Opts) of
-    {delegate_locals_to, LocalOpt} when is_atom(LocalOpt) -> LocalOpt;
-    false -> ?m(Env, local)
+  TempTracers = case lists:keyfind(tracers, 1, Opts) of
+    {tracers, TracersOpt} when is_list(TracersOpt) -> TracersOpt;
+    false -> []
   end,
 
+  %% TODO: Remove the following deprecations in future releases
   Aliases = case lists:keyfind(aliases, 1, Opts) of
-    {aliases, AliasesOpt} when is_list(AliasesOpt) -> AliasesOpt;
-    false -> ?m(Env, aliases)
+    {aliases, AliasesOpt} when is_list(AliasesOpt) ->
+      'Elixir.IO':warn(<<":aliases option in eval is deprecated">>),
+      AliasesOpt;
+    false ->
+      ?key(Env, aliases)
   end,
 
   Requires = case lists:keyfind(requires, 1, Opts) of
-    {requires, RequiresOpt} when is_list(RequiresOpt) -> ordsets:from_list(RequiresOpt);
-    false -> ?m(Env, requires)
+    {requires, RequiresOpt} when is_list(RequiresOpt) ->
+      'Elixir.IO':warn(<<":requires option in eval is deprecated">>),
+      ordsets:from_list(RequiresOpt);
+    false ->
+      ?key(Env, requires)
   end,
 
   Functions = case lists:keyfind(functions, 1, Opts) of
-    {functions, FunctionsOpt} when is_list(FunctionsOpt) -> FunctionsOpt;
-    false -> ?m(Env, functions)
+    {functions, FunctionsOpt} when is_list(FunctionsOpt) ->
+      'Elixir.IO':warn(<<":functions option in eval is deprecated">>),
+      FunctionsOpt;
+    false ->
+      ?key(Env, functions)
   end,
 
   Macros = case lists:keyfind(macros, 1, Opts) of
-    {macros, MacrosOpt} when is_list(MacrosOpt) -> MacrosOpt;
-    false -> ?m(Env, macros)
+    {macros, MacrosOpt} when is_list(MacrosOpt) ->
+      'Elixir.IO':warn(<<":macros option in eval is deprecated">>),
+      MacrosOpt;
+    false ->
+      ?key(Env, macros)
   end,
 
-  Module = case lists:keyfind(module, 1, Opts) of
-    {module, ModuleOpt} when is_atom(ModuleOpt) -> ModuleOpt;
-    false -> nil
+  %% If there is a dead PID or lexical tracker is nil,
+  %% we assume the tracers also cannot be (re)used.
+  {LexicalTracker, Tracers} = case lists:keyfind(lexical_tracker, 1, Opts) of
+    {lexical_tracker, Pid} when is_pid(Pid) ->
+      'Elixir.IO':warn(<<":lexical_tracker option in eval is deprecated">>),
+      case is_process_alive(Pid) of
+        true -> {Pid, TempTracers};
+        false -> {nil, []}
+      end;
+    {lexical_tracker, nil} ->
+      'Elixir.IO':warn(<<":lexical_tracker option in eval is deprecated">>),
+      {nil, []};
+    false ->
+      {nil, TempTracers}
   end,
 
   Env#{
-    file := File, local := Local, module := Module,
-    macros := Macros, functions := Functions,
+    file := File, module := Module, function := FA, tracers := Tracers,
+    macros := Macros, functions := Functions, lexical_tracker := LexicalTracker,
     requires := Requires, aliases := Aliases, line := Line
   }.
 
-%% String evaluation
-
-eval(String, Binding) ->
-  eval(String, Binding, []).
-
-eval(String, Binding, Opts) when is_list(Opts) ->
-  eval(String, Binding, env_for_eval(Opts));
-eval(String, Binding, #{line := Line, file := File} = E) when
-    is_list(String), is_list(Binding), is_integer(Line), is_binary(File) ->
-  Forms = 'string_to_quoted!'(String, Line, File, []),
-  eval_forms(Forms, Binding, E).
-
 %% Quoted evaluation
 
-eval_quoted(Tree, Binding, Opts) when is_list(Opts) ->
-  eval_quoted(Tree, Binding, env_for_eval(Opts));
-eval_quoted(Tree, Binding, #{line := Line} = E) ->
-  eval_forms(elixir_quote:linify(Line, Tree), Binding, E).
-
-%% Handle forms evaluation. The main difference to
-%% to eval_quoted is that it does not linefy the given
-%% args.
-
-eval_forms(Tree, Binding, Opts) when is_list(Opts) ->
-  eval_forms(Tree, Binding, env_for_eval(Opts));
-eval_forms(Tree, Binding, E) ->
-  eval_forms(Tree, Binding, E, elixir_env:env_to_scope(E)).
-eval_forms(Tree, Binding, Env, Scope) ->
-  {ParsedBinding, ParsedScope} = elixir_scope:load_binding(Binding, Scope),
-  ParsedEnv = Env#{vars := [K || {K,_} <- ParsedScope#elixir_scope.vars]},
-  {Erl, NewEnv, NewScope} = quoted_to_erl(Tree, ParsedEnv, ParsedScope),
+eval_quoted(Tree, Binding, E) ->
+  eval_quoted(Tree, Binding, E, []).
+eval_quoted(Tree, Binding, #{line := Line} = E, Opts) ->
+  eval_forms(elixir_quote:linify(Line, line, Tree), Binding, E, Opts).
+
+eval_forms(Tree, Binding, OrigE) ->
+  eval_forms(Tree, Binding, OrigE, []).
+eval_forms(Tree, Binding, OrigE, Opts) ->
+  Prune = proplists:get_value(prune_binding, Opts, false),
+  {ExVars, ErlVars, ErlBinding} = elixir_erl_var:load_binding(Binding, Prune),
+  E = elixir_env:with_vars(OrigE, ExVars),
+  ExS = elixir_env:env_to_ex(E),
+  ErlS = elixir_erl_var:from_env(E, ErlVars),
+  {Erl, NewErlS, NewExS, NewE} = quoted_to_erl(Tree, ErlS, ExS, E),
 
   case Erl of
-    {atom, _, Atom} ->
-      {Atom, Binding, NewEnv, NewScope};
+    {Literal, _, Value} when Literal == atom; Literal == float; Literal == integer ->
+      if
+        Prune -> {Value, [], NewE#{versioned_vars := #{}}};
+        true -> {Value, Binding, NewE}
+      end;
+
     _  ->
-      {value, Value, NewBinding} = erl_eval(Erl, ParsedBinding),
-      {Value, elixir_scope:dump_binding(NewBinding, NewScope), NewEnv, NewScope}
+      Exprs =
+        case Erl of
+          {block, _, BlockExprs} -> BlockExprs;
+          _ -> [Erl]
+        end,
+
+      %% We use remote names so eval works across Elixir versions.
+      LocalHandler = {value, fun ?MODULE:eval_local_handler/2},
+      ExternalHandler = {value, fun ?MODULE:eval_external_handler/3},
+
+      {value, Value, NewBinding} =
+        try
+          %% ?elixir_eval_env is used by the external handler.
+          %%
+          %% The reason why we use the process dictionary to pass the environment
+          %% is because we want to avoid passing closures to erl_eval, as that
+          %% would effectively tie the eval code to the Elixir version and it is
+          %% best if it depends solely on Erlang/OTP.
+          %%
+          %% The downside is that functions that escape the eval context will no
+          %% longer have the original environment they came from.
+          erlang:put(?elixir_eval_env, NewE),
+          erl_eval:exprs(Exprs, ErlBinding, LocalHandler, ExternalHandler)
+        after
+          erlang:erase(?elixir_eval_env)
+        end,
+
+      PruneBefore = if Prune -> length(Binding); true -> -1 end,
+
+      {DumpedBinding, DumpedVars} =
+        elixir_erl_var:dump_binding(NewBinding, NewErlS, NewExS, PruneBefore),
+
+      {Value, DumpedBinding, NewE#{versioned_vars := DumpedVars}}
   end.
 
-erl_eval(Erl, ParsedBinding) ->
-  % Below must be all one line for locations to be the same when the stacktrace
-  % needs to be extended to the full stacktrace.
-  try erl_eval:expr(Erl, ParsedBinding) catch Class:Exception -> erlang:raise(Class, Exception, get_stacktrace()) end.
+eval_local_handler(FunName, Args) ->
+  {current_stacktrace, Stack} = erlang:process_info(self(), current_stacktrace),
+  Opts = [{module, nil}, {function, FunName}, {arity, length(Args)}, {reason, 'undefined local'}],
+  Exception = 'Elixir.UndefinedFunctionError':exception(Opts),
+  erlang:raise(error, Exception, Stack).
 
-get_stacktrace() ->
-  Stacktrace = erlang:get_stacktrace(),
-  % eval_eval and eval_bits can call :erlang.raise/3 without the full
-  % stacktrace. When this occurs re-add the current stacktrace so that no
-  % stack information is lost.
+eval_external_handler(Ann, FunOrModFun, Args) ->
   try
-    throw(stack)
+    case FunOrModFun of
+      {Mod, Fun} -> apply(Mod, Fun, Args);
+      Fun -> apply(Fun, Args)
+    end
   catch
-    throw:stack ->
-      % Ignore stack item for current function.
-      [_ | CurrentStack] = erlang:get_stacktrace(),
-      get_stacktrace(Stacktrace, CurrentStack)
+    Kind:Reason:Stacktrace ->
+      %% Take everything up to the Elixir module
+      Pruned =
+        lists:takewhile(fun
+          ({elixir,_,_,_}) -> false;
+          (_) -> true
+        end, Stacktrace),
+
+      Caller =
+        lists:dropwhile(fun
+          ({elixir,_,_,_}) -> false;
+          (_) -> true
+        end, Stacktrace),
+
+      %% Now we prune any shared code path from erl_eval
+      {current_stacktrace, Current} =
+        erlang:process_info(self(), current_stacktrace),
+
+      %% We need to make sure that we don't generate more
+      %% frames than supported. So we do our best to drop
+      %% from the Caller, but if the caller has no frames,
+      %% we need to drop from Pruned.
+      {DroppedCaller, ToDrop} =
+        case Caller of
+          [] -> {[], true};
+          _ -> {lists:droplast(Caller), false}
+        end,
+
+      Reversed = drop_common(lists:reverse(Current), lists:reverse(Pruned), ToDrop),
+
+      %% Add file+line information at the bottom
+      Bottom =
+        case erlang:get(?elixir_eval_env) of
+          #{file := File} ->
+            [{elixir_eval, '__FILE__', 1,
+             [{file, elixir_utils:characters_to_list(File)}, {line, erl_anno:line(Ann)}]}];
+
+          _ ->
+            []
+        end,
+
+      Custom = lists:reverse(Bottom ++ Reversed, DroppedCaller),
+      erlang:raise(Kind, Reason, Custom)
   end.
 
-% The stacktrace did not include the current stack, re-add it.
-get_stacktrace([], CurrentStack) ->
-  CurrentStack;
-% The stacktrace includes the current stack.
-get_stacktrace(CurrentStack, CurrentStack) ->
-  CurrentStack;
-get_stacktrace([StackItem | Stacktrace], CurrentStack) ->
-  [StackItem | get_stacktrace(Stacktrace, CurrentStack)].
-
-%% Converts a quoted expression to erlang abstract format
-
-quoted_to_erl(Quoted, Env) ->
-  quoted_to_erl(Quoted, Env, elixir_env:env_to_scope(Env)).
-
-quoted_to_erl(Quoted, Env, Scope) ->
-  {Expanded, NewEnv} = elixir_exp:expand(Quoted, Env),
-  {Erl, NewScope}    = elixir_translator:translate(Expanded, Scope),
-  {Erl, NewEnv, NewScope}.
-
-%% Converts a given string (char list) into quote expression
-
-string_to_quoted(String, StartLine, File, Opts) when is_integer(StartLine), is_binary(File) ->
-  case elixir_tokenizer:tokenize(String, StartLine, [{file, File}|Opts]) of
-    {ok, _Line, Tokens} ->
-      try elixir_parser:parse(Tokens) of
-        {ok, Forms} -> {ok, Forms};
-        {error, {Line, _, [Error, Token]}} -> {error, {Line, to_binary(Error), to_binary(Token)}}
-      catch
-        {error, {Line, _, [Error, Token]}} -> {error, {Line, to_binary(Error), to_binary(Token)}}
-      end;
-    {error, {Line, Error, Token}, _Rest, _SoFar} -> {error, {Line, to_binary(Error), to_binary(Token)}}
+%% We need to check if we have dropped any frames.
+%% If we have not dropped frames, then we need to drop one
+%% at the end so we can put the elixir_eval frame in. If
+%% we have more traces then depth, Erlang would discard
+%% the whole stacktrace.
+drop_common([H | T1], [H | T2], _ToDrop) -> drop_common(T1, T2, false);
+drop_common([_ | T1], T2, ToDrop) -> drop_common(T1, T2, ToDrop);
+drop_common([], [{?MODULE, _, _, _} | T2], _ToDrop) -> T2;
+drop_common([], [_ | T2], true) -> T2;
+drop_common([], T2, _) -> T2.
+
+%% Converts a quoted expression to Erlang abstract format
+
+quoted_to_erl(Quoted, E) ->
+  {_, ErlS} = elixir_erl_var:from_env(E),
+  ExS = elixir_env:env_to_ex(E),
+  quoted_to_erl(Quoted, ErlS, ExS, E).
+
+quoted_to_erl(Quoted, ErlS, ExS, Env) ->
+  {Expanded, NewExS, NewEnv} =
+    elixir_expand:expand(Quoted, ExS, Env),
+  {Erl, NewErlS} = elixir_erl_pass:translate(Expanded, erl_anno:new(?key(Env, line)), ErlS),
+  {Erl, NewErlS, NewExS, NewEnv}.
+
+%% Converts a given string (charlist) into quote expression
+
+string_to_tokens(String, StartLine, StartColumn, File, Opts) when is_integer(StartLine), is_binary(File) ->
+  case elixir_tokenizer:tokenize(String, StartLine, StartColumn, Opts) of
+    {ok, _Line, _Column, [], Tokens, []} ->
+      {ok, lists:reverse(Tokens)};
+    {ok, _Line, _Column, Warnings, Tokens, Terminators} ->
+      (lists:keyfind(emit_warnings, 1, Opts) /= {emit_warnings, false}) andalso
+        [elixir_errors:erl_warn(L, File, M) || {L, M} <- lists:reverse(Warnings)],
+      {ok, lists:reverse(Tokens, Terminators)};
+    {error, Info, _Rest, _Warnings, _SoFar} ->
+      {error, format_token_error(Info)}
   end.
 
-'string_to_quoted!'(String, StartLine, File, Opts) ->
-  case string_to_quoted(String, StartLine, File, Opts) of
+format_token_error({Location, {ErrorPrefix, ErrorSuffix}, Token}) ->
+  {Location, {to_binary(ErrorPrefix), to_binary(ErrorSuffix)}, to_binary(Token)};
+format_token_error({Location, Error, Token}) ->
+  {Location, to_binary(Error), to_binary(Token)}.
+
+tokens_to_quoted(Tokens, WarningFile, Opts) ->
+  handle_parsing_opts(WarningFile, Opts),
+
+  try elixir_parser:parse(Tokens) of
     {ok, Forms} ->
-      Forms;
-    {error, {Line, Error, Token}} ->
-      elixir_errors:parse_error(Line, File, Error, Token)
+      {ok, Forms};
+    {error, {Line, _, [{ErrorPrefix, ErrorSuffix}, Token]}} ->
+      {error, {parser_location(Line), {to_binary(ErrorPrefix), to_binary(ErrorSuffix)}, to_binary(Token)}};
+    {error, {Line, _, [Error, Token]}} ->
+      {error, {parser_location(Line), to_binary(Error), to_binary(Token)}}
+  after
+    erase(elixir_parser_warning_file),
+    erase(elixir_parser_columns),
+    erase(elixir_token_metadata),
+    erase(elixir_literal_encoder)
+  end.
+
+parser_location({Line, Column, _}) ->
+  [{line, Line}, {column, Column}];
+parser_location(Meta) ->
+  Line =
+    case lists:keyfind(line, 1, Meta) of
+      {line, L} -> L;
+      false -> 0
+    end,
+
+  case lists:keyfind(column, 1, Meta) of
+    {column, C} -> [{line, Line}, {column, C}];
+    false -> [{line, Line}]
+  end.
+
+'string_to_quoted!'(String, StartLine, StartColumn, File, Opts) ->
+  case string_to_tokens(String, StartLine, StartColumn, File, Opts) of
+    {ok, Tokens} ->
+      case tokens_to_quoted(Tokens, File, Opts) of
+        {ok, Forms} ->
+          Forms;
+        {error, {Meta, Error, Token}} ->
+          Indentation = proplists:get_value(indentation, Opts, 0),
+          Input = {String, StartLine, StartColumn, Indentation},
+          elixir_errors:parse_error(Meta, File, Error, Token, Input)
+      end;
+    {error, {Meta, Error, Token}} ->
+      Indentation = proplists:get_value(indentation, Opts, 0),
+      Input = {String, StartLine, StartColumn, Indentation},
+      elixir_errors:parse_error(Meta, File, Error, Token, Input)
   end.
 
 to_binary(List) when is_list(List) -> elixir_utils:characters_to_binary(List);
-to_binary(Atom) when is_atom(Atom) -> atom_to_binary(Atom, utf8).
+to_binary(Atom) when is_atom(Atom) -> atom_to_binary(Atom).
+
+handle_parsing_opts(File, Opts) ->
+  WarningFile =
+    case lists:keyfind(emit_warnings, 1, Opts) of
+      {emit_warnings, false} -> nil;
+      _ -> File
+    end,
+  LiteralEncoder =
+    case lists:keyfind(literal_encoder, 1, Opts) of
+      {literal_encoder, Fun} -> Fun;
+      false -> false
+    end,
+  TokenMetadata = lists:keyfind(token_metadata, 1, Opts) == {token_metadata, true},
+  Columns = lists:keyfind(columns, 1, Opts) == {columns, true},
+  put(elixir_parser_warning_file, WarningFile),
+  put(elixir_parser_columns, Columns),
+  put(elixir_token_metadata, TokenMetadata),
+  put(elixir_literal_encoder, LiteralEncoder).
diff --git a/lib/elixir/src/elixir.hrl b/lib/elixir/src/elixir.hrl
new file mode 100644
index 00000000000..eee33351eaf
--- /dev/null
+++ b/lib/elixir/src/elixir.hrl
@@ -0,0 +1,81 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+-define(key(M, K), map_get(K, M)).
+-define(ann(Meta), elixir_erl:get_ann(Meta)).
+-define(line(Meta), elixir_utils:get_line(Meta)).
+-define(generated(Meta), elixir_utils:generated(Meta)).
+-define(var_context, ?MODULE).
+-define(remote(Ann, Module, Function, Args), {call, Ann, {remote, Ann, {atom, Ann, Module}, {atom, Ann, Function}}, Args}).
+-define(tracker, 'Elixir.Kernel.LexicalTracker').
+
+-record(elixir_ex, {
+  %% Stores if __CALLER__ is allowed
+  caller=false,
+  %% Stores the variables available before a match.
+  %% May be one of:
+  %%
+  %%   * {Read, Cycle :: #{}, Meta :: Counter | {bitsize, Original}}
+  %%   * pin
+  %%   * none.
+  %%
+  %% The cycle is used to detect cyclic dependencies between
+  %% variables in a match.
+  %%
+  %% The bitsize is used when dealing with bitstring modifiers,
+  %% as they allow guards but also support the pin operator.
+  prematch=none,
+  %% Stores if __STACKTRACE__ is allowed
+  stacktrace=false,
+  %% A map of unused vars and a version counter for vars
+  unused={#{}, 0},
+  %% A list of modules defined in functions (runtime)
+  runtime_modules=[],
+  %% A tuple with maps of read and optional write current vars.
+  %% Read variables is all defined variables. Write variables
+  %% stores the variables that have been made available (written
+  %% to) but cannot be currently read. This is used in two occasions:
+  %%
+  %%   * To store variables graphs inside = in patterns
+  %%
+  %%   * To store variables defined inside calls. For example,
+  %%     if you write foo(a = 123), the value of `a` cannot be
+  %%     read in the following argument, only after the call
+  %%
+  vars={#{}, false}
+}).
+
+-record(elixir_erl, {
+  %% Can be match, guards or nil
+  context=nil,
+  %% Extra information about the context, like pin_guard and map_key
+  extra=nil,
+  %% When true, it means caller was invoked
+  caller=false,
+  %% Maps of defined variables and their alias
+  var_names=#{},
+  %% Extra guards from args expansion
+  extra_guards=[],
+  %% A map counting the variables defined
+  counter=#{},
+  %% A boolean to control if captures should be expanded
+  expand_captures=false,
+  %% Holds information about the stacktrace variable
+  stacktrace=nil
+}).
+
+-record(elixir_tokenizer, {
+  terminators=[],
+  unescape=true,
+  cursor_completion=false,
+  existing_atoms_only=false,
+  static_atoms_encoder=nil,
+  preserve_comments=nil,
+  identifier_tokenizer=elixir_tokenizer,
+  ascii_identifiers_only=true,
+  indentation=0,
+  column=1,
+  mismatch_hints=[],
+  warnings=[]
+}).
diff --git a/lib/elixir/src/elixir_aliases.erl b/lib/elixir/src/elixir_aliases.erl
index 8f06fffc8cb..ea480862bf0 100644
--- a/lib/elixir/src/elixir_aliases.erl
+++ b/lib/elixir/src/elixir_aliases.erl
@@ -1,101 +1,173 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(elixir_aliases).
--export([inspect/1, last/1, concat/1, safe_concat/1, format_error/1,
-         ensure_loaded/3, expand/4, store/7]).
+-export([inspect/1, concat/1, safe_concat/1, format_error/1,
+         ensure_loaded/3, expand/4, expand_or_concat/4, alias/6, require/5]).
 -include("elixir.hrl").
 
 inspect(Atom) when is_atom(Atom) ->
-  case elixir_compiler:get_opt(internal) of
-    true  -> atom_to_binary(Atom, utf8);
-    false -> 'Elixir.Inspect.Atom':inspect(Atom)
+  case elixir_config:is_bootstrap() of
+    true  -> atom_to_binary(Atom);
+    false -> 'Elixir.Macro':inspect_atom(literal, Atom)
+  end.
+
+require(Meta, Ref, Opts, E, Trace) ->
+  Trace andalso elixir_env:trace({require, Meta, Ref, Opts}, E),
+  E#{requires := ordsets:add_element(Ref, ?key(E, requires))}.
+
+alias(Meta, Ref, IncludeByDefault, Opts, E, Trace) ->
+  #{aliases := Aliases, macro_aliases := MacroAliases} = E,
+
+  case expand_as(lists:keyfind(as, 1, Opts), IncludeByDefault, Ref) of
+    {ok, Ref} ->
+      {ok, false,
+       E#{aliases := remove_alias(Ref, Aliases),
+          macro_aliases := remove_macro_alias(Meta, Ref, MacroAliases)}};
+
+    {ok, New} ->
+      Trace andalso elixir_env:trace({alias, Meta, Ref, New, Opts}, E),
+      {ok, New,
+       E#{aliases := store_alias(New, Ref, Aliases),
+          macro_aliases := store_macro_alias(Meta, New, Ref, MacroAliases)}};
+
+    none ->
+      {ok, false, E};
+
+    {error, Reason} ->
+      {error, Reason}
   end.
 
-%% Store an alias in the given scope
-store(_Meta, New, New, _TKV, Aliases, MacroAliases, _Lexical) ->
-  {Aliases, MacroAliases};
-store(Meta, New, Old, TKV, Aliases, MacroAliases, Lexical) ->
-  record_warn(Meta, New, TKV, Lexical),
-  {store_alias(New, Old, Aliases),
-    store_macro_alias(Meta, New, Old, MacroAliases)}.
+expand_as({as, Atom}, _IncludeByDefault, _Ref) when is_atom(Atom), not is_boolean(Atom) ->
+  case atom_to_list(Atom) of
+    "Elixir." ++ ([FirstLetter | _] = Rest) when FirstLetter >= $A, FirstLetter =< $Z ->
+      case string:tokens(Rest, ".") of
+        [_] ->
+          {ok, Atom};
+        _ ->
+          {error, {invalid_alias_for_as, nested_alias, Atom}}
+      end;
+    _ ->
+      {error, {invalid_alias_for_as, not_alias, Atom}}
+  end;
+expand_as({as, Other}, _IncludeByDefault, _Ref) ->
+  {error, {invalid_alias_for_as, not_alias, Other}};
+expand_as(false, true, Ref) ->
+  case atom_to_list(Ref) of
+    ("Elixir." ++ [FirstLetter | _]) = List when FirstLetter >= $A, FirstLetter =< $Z ->
+      Last = last(lists:reverse(List), []),
+      {ok, list_to_atom("Elixir." ++ Last)};
+    _ ->
+      {error, {invalid_alias_module, Ref}}
+  end;
+expand_as(false, false, _Ref) ->
+  none.
+
+last([$. | _], Acc) -> Acc;
+last([H | T], Acc)  -> last(T, [H | Acc]);
+last([], Acc)       -> Acc.
 
 store_alias(New, Old, Aliases) ->
   lists:keystore(New, 1, Aliases, {New, Old}).
+
 store_macro_alias(Meta, New, Old, Aliases) ->
-  case lists:keymember(context, 1, Meta) andalso
-       lists:keyfind(counter, 1, Meta) of
-    {counter, Counter} when is_integer(Counter) ->
+  case lists:keyfind(counter, 1, Meta) of
+    {counter, Counter} ->
       lists:keystore(New, 1, Aliases, {New, {Counter, Old}});
-    _ ->
+    false ->
       Aliases
   end.
 
-record_warn(Meta, Ref, Opts, Lexical) ->
-  Warn =
-    case lists:keyfind(warn, 1, Opts) of
-      {warn, false} -> false;
-      {warn, true} -> true;
-      false -> not lists:keymember(context, 1, Meta)
-    end,
-  elixir_lexical:record_alias(Ref, ?line(Meta), Warn, Lexical).
+remove_alias(Atom, Aliases) ->
+  lists:keydelete(Atom, 1, Aliases).
+
+remove_macro_alias(Meta, Atom, Aliases) ->
+  case lists:keyfind(counter, 1, Meta) of
+    {counter, _Counter} ->
+      lists:keydelete(Atom, 1, Aliases);
+    false ->
+      Aliases
+  end.
 
 %% Expand an alias. It returns an atom (meaning that there
 %% was an expansion) or a list of atoms.
 
-expand({'__aliases__', _Meta, ['Elixir'|_] = List}, _Aliases, _MacroAliases, _LexicalTracker) ->
-  concat(List);
+expand(_Meta, ['Elixir' | _] = List, _E, _Trace) ->
+  List;
+
+expand(_Meta, [H | _] = List, _E, _Trace) when not is_atom(H) ->
+  List;
 
-expand({'__aliases__', Meta, _} = Alias, Aliases, MacroAliases, LexicalTracker) ->
+expand(Meta, List, #{aliases := Aliases, macro_aliases := MacroAliases} = E, Trace) ->
   case lists:keyfind(alias, 1, Meta) of
     {alias, false} ->
-      expand(Alias, MacroAliases, LexicalTracker);
+      expand(Meta, List, MacroAliases, E, Trace);
     {alias, Atom} when is_atom(Atom) ->
       Atom;
     false ->
-      expand(Alias, Aliases, LexicalTracker)
+      expand(Meta, List, Aliases, E, Trace)
   end.
 
-expand({'__aliases__', Meta, [H|T]}, Aliases, LexicalTracker) when is_atom(H) ->
+expand(Meta, [H | T], Aliases, E, Trace) ->
   Lookup  = list_to_atom("Elixir." ++ atom_to_list(H)),
+
   Counter = case lists:keyfind(counter, 1, Meta) of
     {counter, C} -> C;
     _ -> nil
   end,
+
   case lookup(Lookup, Aliases, Counter) of
-    Lookup -> [H|T];
+    Lookup -> [H | T];
     Atom ->
-      elixir_lexical:record_alias(Lookup, LexicalTracker),
+      Trace andalso elixir_env:trace({alias_expansion, Meta, Lookup, Atom}, E),
       case T of
         [] -> Atom;
-        _  -> concat([Atom|T])
+        _  -> concat([Atom | T])
       end
-  end;
+  end.
+
+%% Expands or concat if possible.
 
-expand({'__aliases__', _Meta, List}, _Aliases, _LexicalTracker) ->
-  List.
+expand_or_concat(Meta, List, E, Trace) ->
+  case expand(Meta, List, E, Trace) of
+    [H | T] when is_atom(H) -> concat([H | T]);
+    AtomOrList -> AtomOrList
+  end.
 
 %% Ensure a module is loaded before its usage.
 
-ensure_loaded(_Meta, 'Elixir.Kernel', _E) -> ok;
-ensure_loaded(Meta, Ref, E) ->
-  try
-    Ref:module_info(compile)
-  catch
-    error:undef ->
-      Kind = case lists:member(Ref, ?m(E, context_modules)) of
-        true  -> scheduled_module;
-        false -> unloaded_module
-      end,
-      elixir_errors:form_error(Meta, ?m(E, file), ?MODULE, {Kind, Ref})
-  end.
+%% Skip Kernel verification for bootstrap purposes.
+ensure_loaded(_Meta, 'Elixir.Kernel', _E) ->
+  ok;
+ensure_loaded(Meta, Module, #{module := Module} = E) ->
+  elixir_errors:file_error(Meta, E, ?MODULE, {circular_module, Module});
+ensure_loaded(Meta, Module, E) ->
+  case code:ensure_loaded(Module) of
+    {module, Module} ->
+      ok;
 
-%% Receives an atom and returns the last bit as an alias.
+    _ ->
+      case wait_for_module(Module, Meta, E) of
+        found ->
+          ok;
 
-last(Atom) ->
-  Last = last(lists:reverse(atom_to_list(Atom)), []),
-  list_to_atom("Elixir." ++ Last).
+        Wait ->
+          Kind = case lists:member(Module, ?key(E, context_modules)) of
+            true -> scheduled_module;
+            false when Wait == deadlock -> deadlock_module;
+            false -> unloaded_module
+          end,
 
-last([$.|_], Acc) -> Acc;
-last([H|T], Acc) -> last(T, [H|Acc]);
-last([], Acc) -> Acc.
+          elixir_errors:file_error(Meta, E, ?MODULE, {Kind, Module})
+      end
+  end.
+
+wait_for_module(Module, Meta, E) ->
+  case erlang:get(elixir_compiler_info) of
+    undefined -> not_found;
+    _ -> 'Elixir.Kernel.ErrorHandler':ensure_compiled(Module, module, hard, elixir_utils:get_line(Meta, E))
+  end.
 
 %% Receives a list of atoms, binaries or lists
 %% representing modules and concatenates them.
@@ -103,20 +175,20 @@ last([], Acc) -> Acc.
 concat(Args)      -> binary_to_atom(do_concat(Args), utf8).
 safe_concat(Args) -> binary_to_existing_atom(do_concat(Args), utf8).
 
-do_concat([H|T]) when is_atom(H), H /= nil ->
-  do_concat([atom_to_binary(H, utf8)|T]);
-do_concat([<<"Elixir.", _/binary>>=H|T]) ->
+do_concat([H | T]) when is_atom(H), H /= nil ->
+  do_concat([atom_to_binary(H) | T]);
+do_concat([<<"Elixir.", _/binary>>=H | T]) ->
   do_concat(T, H);
-do_concat([<<"Elixir">>=H|T]) ->
+do_concat([<<"Elixir">>=H | T]) ->
   do_concat(T, H);
 do_concat(T) ->
   do_concat(T, <<"Elixir">>).
 
-do_concat([nil|T], Acc) ->
+do_concat([nil | T], Acc) ->
   do_concat(T, Acc);
-do_concat([H|T], Acc) when is_atom(H) ->
-  do_concat(T, <<Acc/binary, $., (to_partial(atom_to_binary(H, utf8)))/binary>>);
-do_concat([H|T], Acc) when is_binary(H) ->
+do_concat([H | T], Acc) when is_atom(H) ->
+  do_concat(T, <<Acc/binary, $., (to_partial(atom_to_binary(H)))/binary>>);
+do_concat([H | T], Acc) when is_binary(H) ->
   do_concat(T, <<Acc/binary, $., (to_partial(H))/binary>>);
 do_concat([], Acc) ->
   Acc.
@@ -127,18 +199,78 @@ to_partial(Arg) when is_binary(Arg)   -> Arg.
 
 %% Lookup an alias in the current scope.
 
-lookup(Else, Dict, Counter) ->
-  case lists:keyfind(Else, 1, Dict) of
-    {Else, {Counter, Value}} -> lookup(Value, Dict, Counter);
-    {Else, Value} when is_atom(Value) -> lookup(Value, Dict, Counter);
+lookup(Else, List, Counter) ->
+  case lists:keyfind(Else, 1, List) of
+    {Else, {Counter, Value}} -> Value;
+    {Else, Value} when is_atom(Value) -> Value;
     _ -> Else
   end.
 
 %% Errors
 
+format_error({invalid_alias_module, Ref}) ->
+  io_lib:format("alias cannot be inferred automatically for module: ~ts, please use the :as option. Implicit aliasing is only supported with Elixir modules",
+                ['Elixir.Macro':to_string(Ref)]);
+
+format_error({invalid_alias_for_as, Reason, Value}) ->
+  ExpectedGot =
+    case Reason of
+      not_alias -> "expected an alias, got";
+      nested_alias -> "expected a simple alias, got nested alias"
+    end,
+  io_lib:format("invalid value for option :as, ~ts: ~ts",
+                [ExpectedGot, 'Elixir.Macro':to_string(Value)]);
+
 format_error({unloaded_module, Module}) ->
-  io_lib:format("module ~ts is not loaded and could not be found", [elixir_aliases:inspect(Module)]);
+  io_lib:format("module ~ts is not loaded and could not be found", [inspect(Module)]);
+
+format_error({deadlock_module, Module}) ->
+  io_lib:format("module ~ts is not loaded and could not be found. "
+                "This may be happening because the module you are trying to load "
+                "directly or indirectly depends on the current module",
+                [inspect(Module)]);
 
 format_error({scheduled_module, Module}) ->
-  io_lib:format("module ~ts is not loaded but was defined. This happens because you are trying to use a module in the same context it is defined. Try defining the module outside the context that requires it.",
-    [inspect(Module)]).
\ No newline at end of file
+  io_lib:format(
+    "module ~ts is not loaded but was defined. This happens when you depend on "
+    "a module in the same context in which it is defined. For example:\n"
+    "\n"
+    "    defmodule MyApp do\n"
+    "      defmodule Mod do\n"
+    "      end\n"
+    "\n"
+    "      use Mod\n"
+    "    end\n"
+    "\n"
+    "Try defining the module outside the context that uses it:\n"
+    "\n"
+    "    defmodule MyApp.Mod do\n"
+    "    end\n"
+    "\n"
+    "    defmodule MyApp do\n"
+    "      use MyApp.Mod\n"
+    "    end\n"
+    "\n"
+    "If the module is defined at the top-level and you are trying to "
+    "use it at the top-level, this is not supported by Elixir",
+    [inspect(Module)]);
+
+format_error({circular_module, Module}) ->
+  io_lib:format(
+    "you are trying to use/import/require the module ~ts which is currently being defined.\n"
+    "\n"
+    "This may happen if you accidentally override the module you want to use. For example:\n"
+    "\n"
+    "    defmodule MyApp do\n"
+    "      defmodule Supervisor do\n"
+    "        use Supervisor\n"
+    "      end\n"
+    "    end\n"
+    "\n"
+    "In the example above, the new Supervisor conflicts with Elixir's Supervisor. "
+    "This may be fixed by using the fully qualified name in the definition:\n"
+    "\n"
+    "    defmodule MyApp.Supervisor do\n"
+    "      use Supervisor\n"
+    "    end\n",
+    [inspect(Module)]).
diff --git a/lib/elixir/src/elixir_bitstring.erl b/lib/elixir/src/elixir_bitstring.erl
index fadb4fec843..8e9c6f8e5bb 100644
--- a/lib/elixir/src/elixir_bitstring.erl
+++ b/lib/elixir/src/elixir_bitstring.erl
@@ -1,223 +1,425 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(elixir_bitstring).
--export([translate/3, expand/3, has_size/1]).
+-export([expand/5, format_error/1, validate_spec/2]).
+-import(elixir_errors, [function_error/4]).
 -include("elixir.hrl").
 
-%% Expansion
+expand_match(Expr, {S, OriginalS}, E) ->
+  {EExpr, SE, EE} = elixir_expand:expand(Expr, S, E),
+  {EExpr, {SE, OriginalS}, EE}.
 
-expand(Meta, Args, E) ->
-  case ?m(E, context) of
+expand(Meta, Args, S, E, RequireSize) ->
+  case ?key(E, context) of
     match ->
-      {EArgs, EA} = expand_bitstr(fun elixir_exp:expand/2, Args, [], E),
-      {{'<<>>', Meta, EArgs}, EA};
+      {EArgs, Alignment, {SA, _}, EA} =
+        expand(Meta, fun expand_match/3, Args, [], {S, S}, E, 0, RequireSize),
+
+      {{'<<>>', [{alignment, Alignment} | Meta], EArgs}, SA, EA};
     _ ->
-      {EArgs, {EC, EV}} = expand_bitstr(fun elixir_exp:expand_arg/2, Args, [], {E, E}),
-      {{'<<>>', Meta, EArgs}, elixir_env:mergea(EV, EC)}
-  end.
+      PairS = {elixir_env:prepare_write(S), S},
 
-expand_bitstr(_Fun, [], Acc, E) ->
-  {lists:reverse(Acc), E};
-expand_bitstr(Fun, [{'::',Meta,[Left,Right]}|T], Acc, E) ->
-  {ELeft, EL} = Fun(Left, E),
+      {EArgs, Alignment, {SA, _}, EA} =
+        expand(Meta, fun elixir_expand:expand_arg/3, Args, [], PairS, E, 0, RequireSize),
 
-  %% Variables defined outside the binary can be accounted
-  %% on subparts, however we can't assign new variables.
-  case E of
-    {ER, _} -> ok;               %% expand_arg,  no assigns
-    _ -> ER = E#{context := nil} %% expand_each, revert assigns
+      {{'<<>>', [{alignment, Alignment} | Meta], EArgs}, elixir_env:close_write(SA, S), EA}
+  end.
+
+expand(_BitstrMeta, _Fun, [], Acc, S, E, Alignment, _RequireSize) ->
+  {lists:reverse(Acc), Alignment, S, E};
+expand(BitstrMeta, Fun, [{'::', Meta, [Left, Right]} | T], Acc, S, E, Alignment, RequireSize) ->
+  % We don't want to consider variables added in the Left pattern inside the Right specs
+  {#elixir_ex{vars=BeforeVars}, _} = S,
+
+  {ELeft, {#elixir_ex{vars=AfterVars} = SL, OriginalS}, EL} = expand_expr(Left, Fun, S, E),
+  validate_expr(ELeft, Meta, E),
+
+  MatchOrRequireSize = RequireSize or is_match_size(T, EL),
+  EType = expr_type(ELeft),
+  ExpectSize = case ELeft of
+    _ when not MatchOrRequireSize -> optional;
+    {'^', _, [{_, _, _}]} -> {infer, ELeft};
+    _ -> required
   end,
 
-  ERight = expand_bit_info(Meta, Right, ER),
-  expand_bitstr(Fun, T, [{'::',Meta,[ELeft,ERight]}|Acc], EL);
+  {ERight, EAlignment, SS, ES} = expand_specs(EType, Meta, Right, SL#elixir_ex{vars=BeforeVars}, OriginalS, EL, ExpectSize),
+
+  EAcc = concat_or_prepend_bitstring(Meta, ELeft, ERight, Acc, ES, MatchOrRequireSize),
+  expand(BitstrMeta, Fun, T, EAcc, {SS#elixir_ex{vars=AfterVars}, OriginalS}, ES, alignment(Alignment, EAlignment), RequireSize);
+expand(BitstrMeta, Fun, [H | T], Acc, S, E, Alignment, RequireSize) ->
+  Meta = extract_meta(H, BitstrMeta),
+  {ELeft, {SS, OriginalS}, ES} = expand_expr(H, Fun, S, E),
+  validate_expr(ELeft, Meta, E),
+
+  MatchOrRequireSize = RequireSize or is_match_size(T, ES),
+  EType = expr_type(ELeft),
+  ERight = infer_spec(EType, Meta),
+
+  InferredMeta = [{inferred_bitstring_spec, true} | Meta],
+  EAcc = concat_or_prepend_bitstring(InferredMeta, ELeft, ERight, Acc, ES, MatchOrRequireSize),
+  expand(Meta, Fun, T, EAcc, {SS, OriginalS}, ES, Alignment, RequireSize).
+
+extract_meta({_, Meta, _}, _) -> Meta;
+extract_meta(_, Meta) -> Meta.
+
+%% Variables defined outside the binary can be accounted
+%% on subparts; however, we can't assign new variables.
+is_match_size([_ | _], #{context := match}) -> true;
+is_match_size(_, _) -> false.
+
+expr_type(Integer) when is_integer(Integer) -> integer;
+expr_type(Float) when is_float(Float) -> float;
+expr_type(Binary) when is_binary(Binary) -> binary;
+expr_type({'<<>>', _, _}) -> bitstring;
+expr_type(_) -> default.
+
+infer_spec(bitstring, Meta) -> {bitstring, Meta, nil};
+infer_spec(binary, Meta) -> {binary, Meta, nil};
+infer_spec(float, Meta) -> {float, Meta, nil};
+infer_spec(integer, Meta) -> {integer, Meta, nil};
+infer_spec(default, Meta) -> {integer, Meta, nil}.
+
+concat_or_prepend_bitstring(_Meta, {'<<>>', _, []}, _ERight, Acc, _E, _RequireSize) ->
+  Acc;
+concat_or_prepend_bitstring(Meta, {'<<>>', PartsMeta, Parts} = ELeft, ERight, Acc, E, RequireSize) ->
+  case E of
+    #{context := match} when RequireSize ->
+      case lists:last(Parts) of
+        {'::', SpecMeta, [Bin, {binary, _, nil}]} when not is_binary(Bin) ->
+          function_error(SpecMeta, E, ?MODULE, unsized_binary);
 
-expand_bitstr(Fun, [H|T], Acc, E) ->
-  {Expr, ES} = Fun(H, E),
-  expand_bitstr(Fun, T, [Expr|Acc], ES).
+        {'::', SpecMeta, [_, {bitstring, _, nil}]} ->
+          function_error(SpecMeta, E, ?MODULE, unsized_binary);
 
-%% Expand bit info
+        _ ->
+          ok
+      end;
+    _ ->
+      ok
+  end,
 
-expand_bit_info(Meta, Info, E) when is_list(Info) ->
-  expand_bit_info(Meta, Info, default, [], E);
+  case ERight of
+    {binary, _, nil} ->
+      {alignment, Alignment} = lists:keyfind(alignment, 1, PartsMeta),
 
-expand_bit_info(Meta, Info, E) ->
-  expand_bit_info(Meta, [Info], E).
+      if
+        is_integer(Alignment) ->
+          (Alignment /= 0) andalso function_error(Meta, E, ?MODULE, {unaligned_binary, ELeft}),
+          lists:reverse(Parts, Acc);
 
-expand_bit_info(Meta, [{Expr, ExprMeta, Args}|T], Size, Types, E) when is_atom(Expr) ->
-  ListArgs = if is_atom(Args) -> []; is_list(Args) -> Args end,
-  case expand_bit_type_or_size(Expr, ListArgs) of
-    type ->
-      {EArgs, EE} = elixir_exp:expand_args(ListArgs, E),
-      expand_bit_info(Meta, T, Size, [{Expr, [], EArgs}|Types], EE);
-    size ->
-      case Size of
-        default -> ok;
-        _ -> elixir_errors:compile_error(Meta, ?m(E, file), "duplicated size definition in bitstring")
-      end,
-      {EArgs, EE} = elixir_exp:expand_args(ListArgs, E),
-      expand_bit_info(Meta, T, {Expr, [], EArgs}, Types, EE);
-    none ->
-      handle_unknown_bit_info(Meta, {Expr, ExprMeta, ListArgs}, T, Size, Types, E)
+        true ->
+          [{'::', Meta, [ELeft, ERight]} | Acc]
+      end;
+    {bitstring, _, nil} ->
+      lists:reverse(Parts, Acc)
   end;
+concat_or_prepend_bitstring(Meta, ELeft, ERight, Acc, _E, _RequireSize) ->
+  [{'::', Meta, [ELeft, ERight]} | Acc].
+
+%% Handling of alignment
+
+alignment(Left, Right) when is_integer(Left), is_integer(Right) -> (Left + Right) rem 8;
+alignment(_, _) -> unknown.
+
+compute_alignment(_, Size, Unit) when is_integer(Size), is_integer(Unit) -> (Size * Unit) rem 8;
+compute_alignment(default, Size, Unit) -> compute_alignment(integer, Size, Unit);
+compute_alignment(integer, default, Unit) -> compute_alignment(integer, 8, Unit);
+compute_alignment(integer, Size, default) -> compute_alignment(integer, Size, 1);
+compute_alignment(bitstring, Size, default) -> compute_alignment(bitstring, Size, 1);
+compute_alignment(binary, Size, default) -> compute_alignment(binary, Size, 8);
+compute_alignment(binary, _, _) -> 0;
+compute_alignment(float, _, _) -> 0;
+compute_alignment(utf32, _, _) -> 0;
+compute_alignment(utf16, _, _) -> 0;
+compute_alignment(utf8, _, _) -> 0;
+compute_alignment(_, _, _) -> unknown.
+
+%% Expands the expression of a bitstring, that is, the LHS of :: or
+%% an argument of the bitstring (such as "foo" in "<<foo>>").
+%% If we are inside a match/guard, we inline interpolations explicitly,
+%% otherwise they are inlined by elixir_rewrite.erl.
+
+expand_expr({{'.', _, [Mod, to_string]}, _, [Arg]} = AST, Fun, S, #{context := Context} = E)
+    when Context /= nil, (Mod == 'Elixir.Kernel') orelse (Mod == 'Elixir.String.Chars') ->
+  case Fun(Arg, S, E) of
+    {EBin, SE, EE} when is_binary(EBin) -> {EBin, SE, EE};
+    _ -> Fun(AST, S, E) % Let it raise
+  end;
+expand_expr(Component, Fun, S, E) ->
+  Fun(Component, S, E).
 
-expand_bit_info(Meta, [Int|T], Size, Types, E) when is_integer(Int) ->
-  expand_bit_info(Meta, [{size, [], [Int]}|T], Size, Types, E);
-
-expand_bit_info(Meta, [Expr|_], _Size, _Types, E) ->
-  elixir_errors:compile_error(Meta, ?m(E, file),
-    "unknown bitstring specifier ~ts", ['Elixir.Kernel':inspect(Expr)]);
-
-expand_bit_info(_Meta, [], Size, Types, _) ->
-  case Size of
-    default -> lists:reverse(Types);
-    _ -> [Size|lists:reverse(Types)]
-  end.
+validate_expr(Expr, Meta, #{context := match} = E) ->
+  case Expr of
+    {Var, _Meta, Ctx} when is_atom(Var), is_atom(Ctx) -> ok;
+    {'<<>>', _, _} -> ok;
+    {'^', _, _} -> ok;
+    _ when is_number(Expr); is_binary(Expr) -> ok;
+    _ -> function_error(extract_meta(Expr, Meta), E, ?MODULE, {unknown_match, Expr})
+  end;
+validate_expr(_Expr, _Meta, _E) ->
+  ok.
+
+%% Expands and normalizes types of a bitstring.
+
+expand_specs(ExprType, Meta, Info, S, OriginalS, E, ExpectSize) ->
+  Default =
+    #{size => default,
+      unit => default,
+      sign => default,
+      type => default,
+      endianness => default},
+  {#{size := Size, unit := Unit, type := Type, endianness := Endianness, sign := Sign}, SS, ES} =
+    expand_each_spec(Meta, unpack_specs(Info, []), Default, S, OriginalS, E),
+
+  MergedType = type(Meta, ExprType, Type, E),
+  validate_size_required(Meta, ExpectSize, ExprType, MergedType, Size, ES),
+  SizeAndUnit = size_and_unit(Meta, ExprType, Size, Unit, ES),
+  Alignment = compute_alignment(MergedType, Size, Unit),
+
+  MaybeInferredSize = case {ExpectSize, MergedType, SizeAndUnit} of
+    {{infer, PinnedVar}, binary, []} -> [{size, Meta, [{{'.', Meta, [erlang, byte_size]}, Meta, [PinnedVar]}]}];
+    {{infer, PinnedVar}, bitstring, []} -> [{size, Meta, [{{'.', Meta, [erlang, bit_size]}, Meta, [PinnedVar]}]}];
+    _ -> SizeAndUnit
+  end,
 
-expand_bit_type_or_size(binary, [])    -> type;
-expand_bit_type_or_size(integer, [])   -> type;
-expand_bit_type_or_size(float, [])     -> type;
-expand_bit_type_or_size(bitstring, []) -> type;
-expand_bit_type_or_size(bytes, [])     -> type;
-expand_bit_type_or_size(bits, [])      -> type;
-expand_bit_type_or_size(utf8, [])      -> type;
-expand_bit_type_or_size(utf16, [])     -> type;
-expand_bit_type_or_size(utf32, [])     -> type;
-expand_bit_type_or_size(signed, [])    -> type;
-expand_bit_type_or_size(unsigned, [])  -> type;
-expand_bit_type_or_size(big, [])       -> type;
-expand_bit_type_or_size(little, [])    -> type;
-expand_bit_type_or_size(native, [])    -> type;
-expand_bit_type_or_size(unit, [_])     -> type;
-expand_bit_type_or_size(size, [_])     -> size;
-expand_bit_type_or_size(_, _)          -> none.
-
-handle_unknown_bit_info(Meta, {_, ExprMeta, _} = Expr, T, Size, Types, E) ->
-  case 'Elixir.Macro':expand(Expr, elixir_env:linify({?line(ExprMeta), E})) of
-    Expr ->
-      elixir_errors:compile_error(ExprMeta, ?m(E, file),
-        "unknown bitstring specifier ~ts", ['Elixir.Macro':to_string(Expr)]);
-    Other ->
-      List = case is_list(Other) of true -> Other; false -> [Other] end,
-      expand_bit_info(Meta, List ++ T, Size, Types, E)
-  end.
+  [H | T] = build_spec(Meta, Size, Unit, MergedType, Endianness, Sign, MaybeInferredSize, ES),
+  {lists:foldl(fun(I, Acc) -> {'-', Meta, [Acc, I]} end, H, T), Alignment, SS, ES}.
+
+type(_, default, default, _) ->
+  integer;
+type(_, ExprType, default, _) ->
+  ExprType;
+type(_, binary, Type, _) when Type == binary; Type == bitstring; Type == utf8; Type == utf16; Type == utf32 ->
+  Type;
+type(_, bitstring, Type, _) when Type == binary; Type == bitstring ->
+  Type;
+type(_, integer, Type, _) when Type == integer; Type == float; Type == utf8; Type == utf16; Type == utf32 ->
+  Type;
+type(_, float, Type, _) when Type == float ->
+  Type;
+type(_, default, Type, _) ->
+  Type;
+type(Meta, Other, Type, E) ->
+  function_error(Meta, E, ?MODULE, {bittype_mismatch, Type, Other, type}),
+  Type.
+
+expand_each_spec(Meta, [{Expr, MetaE, Args} = H | T], Map, S, OriginalS, E) when is_atom(Expr) ->
+  case validate_spec(Expr, Args) of
+    {Key, Arg} ->
+      case Args of
+        [] ->
+          elixir_errors:file_warn(Meta, E, ?MODULE, {parens_bittype, Expr});
+        _ -> ok
+      end,
+      {Value, SE, EE} = expand_spec_arg(Arg, S, OriginalS, E),
+      validate_spec_arg(Meta, Key, Value, SE, OriginalS, EE),
 
-%% Translation
+      case maps:get(Key, Map) of
+        default -> ok;
+        Value -> ok;
+        Other -> function_error(Meta, E, ?MODULE, {bittype_mismatch, Value, Other, Key})
+      end,
 
-has_size({bin, _, Elements}) ->
-  not lists:any(fun({bin_element, _Line, _Expr, Size, Types}) ->
-    (Types /= default) andalso (Size == default) andalso
-      lists:any(fun(X) -> lists:member(X, Types) end,
-                [bits, bytes, bitstring, binary])
-  end, Elements).
+      expand_each_spec(Meta, T, maps:put(Key, Value, Map), SE, OriginalS, EE);
 
-translate(Meta, Args, S) ->
-  case S#elixir_scope.context of
-    match ->
-      build_bitstr(fun elixir_translator:translate/2, Args, Meta, S);
-    _ ->
-      build_bitstr(fun(X, Acc) -> elixir_translator:translate_arg(X, Acc, S) end, Args, Meta, S)
-  end.
+    none ->
+      HA = case Args of
+        nil ->
+          elixir_errors:file_warn(Meta, E, ?MODULE, {unknown_bittype, Expr}),
+          {Expr, MetaE, []};
+        _ -> H
+      end,
 
-build_bitstr(Fun, Exprs, Meta, S) ->
-  {Final, FinalS} = build_bitstr_each(Fun, Exprs, Meta, S, []),
-  {{bin, ?line(Meta), lists:reverse(Final)}, FinalS}.
-
-build_bitstr_each(_Fun, [], _Meta, S, Acc) ->
-  {Acc, S};
-
-build_bitstr_each(Fun, [{'::',_,[H,V]}|T], Meta, S, Acc) ->
-  {Size, Types} = extract_bit_info(Meta, V, S#elixir_scope{context=nil}),
-  build_bitstr_each(Fun, T, Meta, S, Acc, H, Size, Types);
-
-build_bitstr_each(Fun, [H|T], Meta, S, Acc) ->
-  build_bitstr_each(Fun, T, Meta, S, Acc, H, default, default).
-
-build_bitstr_each(Fun, T, Meta, S, Acc, H, default, Types) when is_binary(H) ->
-  Element =
-    case types_allow_splice(Types, []) of
-      true ->
-        %% See explanation in elixir_utils:elixir_to_erl/1 to know
-        %% why we can simply convert the binary to a list.
-        {bin_element, ?line(Meta), {string, 0, binary_to_list(H)}, default, default};
-      false ->
-        case types_require_conversion(Types) of
-          true ->
-            {bin_element, ?line(Meta), {string, 0, elixir_utils:characters_to_list(H)}, default, Types};
-          false ->
-            elixir_errors:compile_error(Meta, S#elixir_scope.file, "invalid types for literal string in <<>>. "
-              "Accepted types are: little, big, utf8, utf16, utf32, bits, bytes, binary, bitstring")
-        end
-    end,
-
-  build_bitstr_each(Fun, T, Meta, S, [Element|Acc]);
-
-build_bitstr_each(_Fun, _T, Meta, S, _Acc, H, _Size, _Types) when is_binary(H) ->
-  elixir_errors:compile_error(Meta, S#elixir_scope.file, "size is not supported for literal string in <<>>");
-
-build_bitstr_each(_Fun, _T, Meta, S, _Acc, H, _Size, _Types) when is_list(H); is_atom(H) ->
-  elixir_errors:compile_error(Meta, S#elixir_scope.file, "invalid literal ~ts in <<>>",
-    ['Elixir.Macro':to_string(H)]);
-
-build_bitstr_each(Fun, T, Meta, S, Acc, H, Size, Types) ->
-  {Expr, NS} = Fun(H, S),
+      case 'Elixir.Macro':expand(HA, E#{line := ?line(Meta)}) of
+        HA ->
+          function_error(Meta, E, ?MODULE, {undefined_bittype, H}),
+          expand_each_spec(Meta, T, Map, S, OriginalS, E);
 
-  case Expr of
-    {bin, _, Elements} ->
-      case (Size == default) andalso types_allow_splice(Types, Elements) of
-        true  -> build_bitstr_each(Fun, T, Meta, NS, lists:reverse(Elements) ++ Acc);
-        false -> build_bitstr_each(Fun, T, Meta, NS, [{bin_element, ?line(Meta), Expr, Size, Types}|Acc])
+        NewTypes ->
+          expand_each_spec(Meta, unpack_specs(NewTypes, []) ++ T, Map, S, OriginalS, E)
+      end
+  end;
+expand_each_spec(Meta, [Expr | Tail], Map, S, OriginalS, E) ->
+  function_error(Meta, E, ?MODULE, {undefined_bittype, Expr}),
+  expand_each_spec(Meta, Tail, Map, S, OriginalS, E);
+expand_each_spec(_Meta, [], Map, S, _OriginalS, E) ->
+  {Map, S, E}.
+
+unpack_specs({'-', _, [H, T]}, Acc) ->
+  unpack_specs(H, unpack_specs(T, Acc));
+unpack_specs({'*', _, [{'_', _, Atom}, Unit]}, Acc) when is_atom(Atom) ->
+  [{unit, [], [Unit]} | Acc];
+unpack_specs({'*', _, [Size, Unit]}, Acc) ->
+  [{size, [], [Size]}, {unit, [], [Unit]} | Acc];
+unpack_specs(Size, Acc) when is_integer(Size) ->
+  [{size, [], [Size]} | Acc];
+unpack_specs({Expr, Meta, Args}, Acc) when is_atom(Expr) ->
+  ListArgs = if is_atom(Args) -> nil; is_list(Args) -> Args end,
+  [{Expr, Meta, ListArgs} | Acc];
+unpack_specs(Other, Acc) ->
+  [Other | Acc].
+
+validate_spec(Spec, [])       -> validate_spec(Spec, nil);
+validate_spec(big, nil)       -> {endianness, big};
+validate_spec(little, nil)    -> {endianness, little};
+validate_spec(native, nil)    -> {endianness, native};
+validate_spec(size, [Size])   -> {size, Size};
+validate_spec(unit, [Unit])   -> {unit, Unit};
+validate_spec(integer, nil)   -> {type, integer};
+validate_spec(float, nil)     -> {type, float};
+validate_spec(binary, nil)    -> {type, binary};
+validate_spec(bytes, nil)     -> {type, binary};
+validate_spec(bitstring, nil) -> {type, bitstring};
+validate_spec(bits, nil)      -> {type, bitstring};
+validate_spec(utf8, nil)      -> {type, utf8};
+validate_spec(utf16, nil)     -> {type, utf16};
+validate_spec(utf32, nil)     -> {type, utf32};
+validate_spec(signed, nil)    -> {sign, signed};
+validate_spec(unsigned, nil)  -> {sign, unsigned};
+validate_spec(_, _)           -> none.
+
+expand_spec_arg(Expr, S, _OriginalS, E) when is_atom(Expr); is_integer(Expr) ->
+  {Expr, S, E};
+expand_spec_arg(Expr, S, OriginalS, #{context := match} = E) ->
+  %% We can only access variables that are either on prematch or not in original
+  #elixir_ex{prematch={PreRead, PreCycle, _} = OldPre} = S,
+  #elixir_ex{vars={OriginalRead, _}} = OriginalS,
+  NewPre = {PreRead, PreCycle, {bitsize, OriginalRead}},
+  {EExpr, SE, EE} = elixir_expand:expand(Expr, S#elixir_ex{prematch=NewPre}, E#{context := guard}),
+  {EExpr, SE#elixir_ex{prematch=OldPre}, EE#{context := match}};
+expand_spec_arg(Expr, S, OriginalS, E) ->
+  elixir_expand:expand(Expr, elixir_env:reset_read(S, OriginalS), E).
+
+validate_spec_arg(Meta, unit, Value, _S, _OriginalS, E) when not is_integer(Value) ->
+  function_error(Meta, E, ?MODULE, {bad_unit_argument, Value}),
+  ok;
+validate_spec_arg(_Meta, _Key, _Value, _S, _OriginalS, _E) ->
+  ok.
+
+validate_size_required(Meta, required, default, Type, default, E) when Type == binary; Type == bitstring ->
+  function_error(Meta, E, ?MODULE, unsized_binary),
+  ok;
+validate_size_required(_, _, _, _, _, _) ->
+  ok.
+
+size_and_unit(Meta, bitstring, Size, Unit, E) when Size /= default; Unit /= default ->
+  function_error(Meta, E, ?MODULE, bittype_literal_bitstring),
+  [];
+size_and_unit(Meta, binary, Size, Unit, E) when Size /= default; Unit /= default ->
+  function_error(Meta, E, ?MODULE, bittype_literal_string),
+  [];
+size_and_unit(_Meta, _ExprType, Size, Unit, _E) ->
+  add_arg(unit, Unit, add_arg(size, Size, [])).
+
+add_arg(_Key, default, Spec) -> Spec;
+add_arg(Key, Arg, Spec) -> [{Key, [], [Arg]} | Spec].
+
+build_spec(Meta, Size, Unit, Type, Endianness, Sign, Spec, E) when Type == utf8; Type == utf16; Type == utf32 ->
+  if
+    Size /= default; Unit /= default ->
+      function_error(Meta, E, ?MODULE, bittype_utf);
+    Sign /= default ->
+      function_error(Meta, E, ?MODULE, bittype_signed);
+    true ->
+      ok
+  end,
+  add_spec(Type, add_spec(Endianness, Spec));
+
+build_spec(Meta, _Size, Unit, Type, _Endianness, Sign, Spec, E) when Type == binary; Type == bitstring ->
+  if
+    Type == bitstring, Unit /= default, Unit /= 1 ->
+      function_error(Meta, E, ?MODULE, {bittype_mismatch, Unit, 1, unit});
+    Sign /= default ->
+      function_error(Meta, E, ?MODULE, bittype_signed);
+    true ->
+      %% Endianness is supported but has no effect, so we just ignore it.
+      ok
+  end,
+  add_spec(Type, Spec);
+
+build_spec(Meta, Size, Unit, Type, Endianness, Sign, Spec, E) when Type == integer; Type == float ->
+  NumberSize = number_size(Size, Unit),
+  if
+    Type == float, is_integer(NumberSize) ->
+      case valid_float_size(NumberSize) of
+        true ->
+          add_spec(Type, add_spec(Endianness, add_spec(Sign, Spec)));
+        false ->
+          function_error(Meta, E, ?MODULE, {bittype_float_size, NumberSize}),
+          []
       end;
-    _ ->
-      build_bitstr_each(Fun, T, Meta, NS, [{bin_element, ?line(Meta), Expr, Size, Types}|Acc])
+    Size == default, Unit /= default ->
+      function_error(Meta, E, ?MODULE, bittype_unit),
+      [];
+    true ->
+      add_spec(Type, add_spec(Endianness, add_spec(Sign, Spec)))
   end.
 
-types_require_conversion([End|T]) when End == little; End == big -> types_require_conversion(T);
-types_require_conversion([UTF|T]) when UTF == utf8; UTF == utf16; UTF == utf32 -> types_require_conversion(T);
-types_require_conversion([]) -> true;
-types_require_conversion(_) -> false.
-
-types_allow_splice([bytes], Elements)  -> is_byte_size(Elements, 0);
-types_allow_splice([binary], Elements) -> is_byte_size(Elements, 0);
-types_allow_splice([bits], _)          -> true;
-types_allow_splice([bitstring], _)     -> true;
-types_allow_splice(default, _)         -> true;
-types_allow_splice(_, _)               -> false.
-
-is_byte_size([Element|T], Acc) ->
-  case elem_size(Element) of
-    {unknown, Unit} when Unit rem 8 == 0 -> is_byte_size(T, Acc);
-    {unknown, _Unit} -> false;
-    {Size, Unit} -> is_byte_size(T, Size*Unit + Acc)
-  end;
-is_byte_size([], Size) ->
-  Size rem 8 == 0.
-
-elem_size({bin_element, _, _, default, _})              -> {0, 0};
-elem_size({bin_element, _, _, {integer,_,Size}, Types}) -> {Size, unit_size(Types, 1)};
-elem_size({bin_element, _, _, _Size, Types})            -> {unknown, unit_size(Types, 1)}.
-
-unit_size([binary|T], _)       -> unit_size(T, 8);
-unit_size([{unit, Size}|_], _) -> Size;
-unit_size([_|T], Guess)        -> unit_size(T, Guess);
-unit_size([], Guess)           -> Guess.
-
-%% Extra bitstring specifiers
-
-extract_bit_info(Meta, [{size, _, [Arg]}|T], S) ->
-  case elixir_translator:translate(Arg, S) of
-    {{Kind, _, _} = Size, _} when Kind == integer; Kind == var ->
-      {Size, extract_bit_type(Meta, T, S)};
-    _ ->
-      elixir_errors:compile_error(Meta, S#elixir_scope.file,
-        "size in bitstring expects an integer or a variable as argument, got: ~ts", ['Elixir.Macro':to_string(Arg)])
-  end;
-extract_bit_info(Meta, T, S) ->
-  {default, extract_bit_type(Meta, T, S)}.
-
-extract_bit_type(Meta, [{unit, _, [Arg]}|T], S) when is_integer(Arg) ->
-  [{unit, Arg}|extract_bit_type(Meta, T, S)];
-extract_bit_type(Meta, [{unit, _, [Arg]}|_], S) ->
-  elixir_errors:compile_error(Meta, S#elixir_scope.file,
-    "unit in bitstring expects an integer as argument, got: ~ts", ['Elixir.Macro':to_string(Arg)]);
-extract_bit_type(Meta, [{Other, _, []}|T], S) ->
-  [Other|extract_bit_type(Meta, T, S)];
-extract_bit_type(_Meta, [], _S) ->
-  [].
+number_size(Size, default) when is_integer(Size) -> Size;
+number_size(Size, Unit) when is_integer(Size) -> Size * Unit;
+number_size(Size, _) -> Size.
+
+valid_float_size(16) -> true;
+valid_float_size(32) -> true;
+valid_float_size(64) -> true;
+valid_float_size(_) -> false.
+
+add_spec(default, Spec) -> Spec;
+add_spec(Key, Spec) -> [{Key, [], nil} | Spec].
+
+format_error({unaligned_binary, Expr}) ->
+  Message = "expected ~ts to be a binary but its number of bits is not divisible by 8",
+  io_lib:format(Message, ['Elixir.Macro':to_string(Expr)]);
+format_error(unsized_binary) ->
+  "a binary field without size is only allowed at the end of a binary pattern, "
+  "at the right side of binary concatenation and never allowed in binary generators. "
+  "The following examples are invalid:\n\n"
+  "    rest <> \"foo\"\n"
+  "    <<rest::binary, \"foo\">>\n\n"
+  "They are invalid because there is a bits/bitstring component not at the end. "
+  "However, the \"reverse\" would work:\n\n"
+  "    \"foo\" <> rest\n"
+  "    <<\"foo\", rest::binary>>\n\n";
+format_error(bittype_literal_bitstring) ->
+  "literal <<>> in bitstring supports only type specifiers, which must be one of: "
+    "binary or bitstring";
+format_error(bittype_literal_string) ->
+  "literal string in bitstring supports only endianness and type specifiers, which must be one of: "
+    "little, big, native, utf8, utf16, utf32, bits, bytes, binary or bitstring";
+format_error(bittype_utf) ->
+  "size and unit are not supported on utf types";
+format_error(bittype_signed) ->
+  "signed and unsigned specifiers are supported only on integer and float types";
+format_error(bittype_unit) ->
+  "integer and float types require a size specifier if the unit specifier is given";
+format_error({bittype_float_size, Other}) ->
+  io_lib:format("float requires size*unit to be 16, 32, or 64 (default), got: ~p", [Other]);
+format_error({undefined_bittype, Expr}) ->
+  io_lib:format("unknown bitstring specifier: ~ts", ['Elixir.Macro':to_string(Expr)]);
+format_error({unknown_bittype, Name}) ->
+  io_lib:format("bitstring specifier \"~ts\" does not exist and is being expanded to \"~ts()\","
+                " please use parentheses to remove the ambiguity.\n"
+                "You may run \"mix format --migrate\" to fix this warning automatically.", [Name, Name]);
+format_error({parens_bittype, Name}) ->
+    io_lib:format("extra parentheses on a bitstring specifier \"~ts()\" have been deprecated. "
+    "Please remove the parentheses: \"~ts\".\n"
+    "You may run \"mix format --migrate\" to fix this warning automatically."
+    ,
+    [Name, Name]);
+format_error({bittype_mismatch, Val1, Val2, Where}) ->
+  io_lib:format("conflicting ~ts specification for bit field: \"~p\" and \"~p\"", [Where, Val1, Val2]);
+format_error({bad_unit_argument, Unit}) ->
+  io_lib:format("unit in bitstring expects an integer as argument, got: ~ts",
+                ['Elixir.Macro':to_string(Unit)]);
+format_error({unknown_match, Expr}) ->
+  Message =
+    "a bitstring only accepts binaries, numbers, and variables inside a match, got: ~ts",
+  io_lib:format(Message, ['Elixir.Macro':to_string(Expr)]);
+format_error({undefined_var_in_spec, Var}) ->
+  Message =
+    "undefined variable \"~ts\" in bitstring segment. If the size of the binary is a "
+      "variable, the variable must be defined prior to its use in the binary/bitstring match "
+      "itself, or outside the pattern match",
+  io_lib:format(Message, ['Elixir.Macro':to_string(Var)]).
diff --git a/lib/elixir/src/elixir_bootstrap.erl b/lib/elixir/src/elixir_bootstrap.erl
index 97cf07fb215..0faa47fec44 100644
--- a/lib/elixir/src/elixir_bootstrap.erl
+++ b/lib/elixir/src/elixir_bootstrap.erl
@@ -1,5 +1,9 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 %% An Erlang module that behaves like an Elixir module
-%% used for bootstraping.
+%% used for bootstrapping.
 -module(elixir_bootstrap).
 -export(['MACRO-def'/2, 'MACRO-def'/3, 'MACRO-defp'/3, 'MACRO-defmodule'/3,
          'MACRO-defmacro'/2, 'MACRO-defmacro'/3, 'MACRO-defmacrop'/3,
@@ -18,34 +22,46 @@
 'MACRO-defmacro'(Caller, Call, Expr) -> define(Caller, defmacro, Call, Expr).
 'MACRO-defmacrop'(Caller, Call, Expr) -> define(Caller, defmacrop, Call, Expr).
 
-'MACRO-defmodule'(_Caller, Alias, [{do,Block}]) ->
-  {Escaped, _} = elixir_quote:escape(Block, false),
-  Args = [Alias, Escaped, [], env()],
+'MACRO-defmodule'({Line, _S, _E} = _Caller, Alias, [{do, Block}]) ->
+  Escaped = elixir_quote:escape(Block, escape, false),
+  Args = [[{line, Line}], Alias, Escaped, [], false, env()],
   {{'.', [], [elixir_module, compile]}, [], Args}.
 
 '__info__'(functions) ->
   [];
 '__info__'(macros) ->
   [{'@', 1},
-   {def,1},
-   {def,2},
-   {defmacro,1},
-   {defmacro,2},
-   {defmacrop,2},
-   {defmodule,2},
-   {defp,2}].
-
-define({Line,E}, Kind, Call, Expr) ->
-  {EscapedCall, UC} = elixir_quote:escape(Call, true),
-  {EscapedExpr, UE} = elixir_quote:escape(Expr, true),
-  Args = [Line, Kind, not(UC or UE), EscapedCall, EscapedExpr, elixir_locals:cache_env(E)],
+   {def, 1},
+   {def, 2},
+   {defmacro, 1},
+   {defmacro, 2},
+   {defmacrop, 2},
+   {defmodule, 2},
+   {defp, 2}].
+
+define({Line, _S, #{module := Module} = E}, Kind, Call, Expr) ->
+  UC = elixir_quote:has_unquotes(Call),
+  UE = elixir_quote:has_unquotes(Expr),
+
+  Store =
+    case UC or UE of
+      true ->
+        elixir_quote:escape({Call, Expr}, escape, true);
+
+      false ->
+        Key = erlang:unique_integer(),
+        elixir_module:write_cache(Module, Key, {Call, Expr}),
+        Key
+    end,
+
+  Args = [Kind, Store, elixir_module:cache_env(E#{line := Line})],
   {{'.', [], [elixir_def, store_definition]}, [], Args}.
 
 unless_loaded(Fun, Args, Callback) ->
-  case code:is_loaded(?kernel) of
-    {_, _} -> apply(?kernel, Fun, Args);
-    false   -> Callback()
+  case erlang:module_loaded(?kernel) of
+    true -> apply(?kernel, Fun, Args);
+    false -> Callback()
   end.
 
 env() ->
-  {'__ENV__', [], nil}.
\ No newline at end of file
+  {'__ENV__', [], nil}.
diff --git a/lib/elixir/src/elixir_clauses.erl b/lib/elixir/src/elixir_clauses.erl
index f5b3ef9e688..b252ae8b08a 100644
--- a/lib/elixir/src/elixir_clauses.erl
+++ b/lib/elixir/src/elixir_clauses.erl
@@ -1,226 +1,615 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 %% Handle code related to args, guard and -> matching for case,
 %% fn, receive and friends. try is handled in elixir_try.
 -module(elixir_clauses).
--export([match/3, clause/7, clauses/4, guards/4, get_pairs/3, get_pairs/4,
-  extract_splat_guards/1, extract_guards/1]).
+-export([parallel_match/4, match/6, clause/6, def/3, head/4,
+         'case'/4, 'receive'/4, 'try'/4, 'cond'/4, with/4,
+         format_error/1]).
+-import(elixir_errors, [file_error/4, file_warn/4]).
 -include("elixir.hrl").
 
-%% Get pairs from a clause.
+%% Deal with parallel matches and loops in variables
+
+parallel_match(Meta, Expr, S, #{context := match} = E) ->
+  #elixir_ex{vars={_Read, Write}} = S,
+  Matches = unpack_match(Expr, Meta, [], E),
+
+  {[{_, EHead} | ETail], EWrites, SM, EM} =
+    lists:foldl(fun({EMeta, Match}, {AccMatches, AccWrites, SI, EI}) ->
+      #elixir_ex{vars={Read, _Write}} = SI,
+      {EMatch, SM, EM} = elixir_expand:expand(Match, SI#elixir_ex{vars={Read, #{}}}, EI),
+      #elixir_ex{vars={_, EWrite}} = SM,
+      {[{EMeta, EMatch} | AccMatches], [EWrite | AccWrites], SM, EM}
+    end, {[], [], S, E}, Matches),
+
+  EMatch =
+    lists:foldl(fun({EMeta, EMatch}, Acc) ->
+      {'=', EMeta, [EMatch, Acc]}
+    end, EHead, ETail),
+
+  #elixir_ex{vars={VRead, _}, prematch={PRead, Cycles, PInfo}} = SM,
+  {PCycles, PWrites} = store_cycles(EWrites, Cycles, #{}),
+  VWrite = (Write /= false) andalso elixir_env:merge_vars(Write, PWrites),
+  {EMatch, SM#elixir_ex{vars={VRead, VWrite}, prematch={PRead, PCycles, PInfo}}, EM}.
+
+unpack_match({'=', Meta, [{_, VarMeta, _} = Node, Node]}, _Meta, Acc, E) ->
+  %% TODO: remove this clause on Elixir v1.23
+  file_warn(VarMeta, ?key(E, file), ?MODULE, {duplicate_match, Node}),
+  unpack_match(Node, Meta, Acc, E);
+unpack_match({'=', Meta, [Left, Right]}, _Meta, Acc, E) ->
+  unpack_match(Left, Meta, unpack_match(Right, Meta, Acc, E), E);
+unpack_match(Node, Meta, Acc, _E) ->
+  [{Meta, Node} | Acc].
+
+store_cycles([Write | Writes], {Cycles, SkipList}, Acc) ->
+  %% Compute the variables this parallel pattern depends on
+  DependsOn = lists:foldl(fun maps:merge/2, Acc, Writes),
+
+  %% For each variable on a sibling, we store it inside the graph (Cycles).
+  %% The graph will by definition have at least one degree cycles. We need
+  %% to find variables which depend on each other more than once (tagged as
+  %% error below) and also all second-degree (or later) cycles. In other
+  %% words, take this code:
+  %%
+  %%     {x = y, x = {:ok, y}} = expr()
+  %%
+  %% The first parallel match will say we store the following cycle:
+  %%
+  %%     #{{x,nil} => #{{y,nil} => 1}, {y,nil} => #{{x,nil} => 0}}
+  %%
+  %% That's why one degree cycles are allowed. However, once we go
+  %% over the next parallel pattern, we will have:
+  %%
+  %%     #{{x,nil} => #{{y,nil} => error}, {y,nil} => #{{x,nil} => error}}
+  %%
+  AccCycles =
+    maps:fold(fun(Pair, _, AccCycles) ->
+      maps:update_with(Pair, fun(Current) ->
+        maps:merge_with(fun(_, _, _) -> error end, Current, DependsOn)
+      end, DependsOn, AccCycles)
+    end, Cycles, Write),
+
+  %% The SkipList keeps variables that are seen as defined together by other
+  %% nodes. Those must be skipped on the graph traversal, as they will always
+  %% contain cycles between them. For example:
+  %%
+  %%     {{a} = b} = c = expr()
+  %%
+  %% In the example above, c sees "a" and "b" as defined together and therefore
+  %% one should not point to the other when looking for cycles.
+  AccSkipList =
+    case map_size(DependsOn) > 1 of
+      true -> [DependsOn | SkipList];
+      false -> SkipList
+    end,
+
+  store_cycles(Writes, {AccCycles, AccSkipList}, maps:merge(Acc, Write));
+store_cycles([], Cycles, Acc) ->
+  {Cycles, Acc}.
+
+validate_cycles({Cycles, SkipList}, Meta, Expr, E) ->
+  maps:fold(fun(Current, _DependsOn, Seen) ->
+    recur_cycles(Cycles, Current, root, Seen, SkipList, Meta, Expr, E)
+  end, #{}, Cycles).
+
+recur_cycles(Cycles, Current, Source, Seen, SkipList, Meta, Expr, E) ->
+  case is_map_key(Current, Seen) of
+    true ->
+      Seen;
 
-get_pairs(Key, Clauses, As) ->
-  get_pairs(Key, Clauses, As, false).
-get_pairs(Key, Clauses, As, AllowNil) ->
-  case lists:keyfind(Key, 1, Clauses) of
-    {Key, Pairs} when is_list(Pairs) ->
-      [{As, Meta, Left, Right} || {'->', Meta, [Left, Right]} <- Pairs];
-    {Key, nil} when AllowNil ->
-      [];
     false ->
-      []
-  end.
-
-%% Translate matches
-
-match(Fun, Args, #elixir_scope{context=Context, match_vars=MatchVars,
-    backup_vars=BackupVars, vars=Vars} = S) when Context /= match ->
-  {Result, NewS} = match(Fun, Args, S#elixir_scope{context=match,
-                       match_vars=ordsets:new(), backup_vars=Vars}),
-  {Result, NewS#elixir_scope{context=Context,
-      match_vars=MatchVars, backup_vars=BackupVars}};
-match(Fun, Args, S) -> Fun(Args, S).
-
-%% Translate clauses with args, guards and expressions
-
-clause(Line, Fun, Args, Expr, Guards, Return, S) when is_integer(Line) ->
-  {TArgs, SA} = match(Fun, Args, S#elixir_scope{extra_guards=[]}),
-  {TExpr, SE} = elixir_translator:translate_block(Expr, Return, SA#elixir_scope{extra_guards=nil}),
-
-  Extra = SA#elixir_scope.extra_guards,
-  TGuards = guards(Line, Guards, Extra, SA),
-  {{clause, Line, TArgs, TGuards, unblock(TExpr)}, SE}.
-
-% Translate/Extract guards from the given expression.
-
-guards(Line, Guards, Extra, S) ->
-  SG = S#elixir_scope{context=guard, extra_guards=nil},
-
-  case Guards of
-    [] -> case Extra of [] -> []; _ -> [Extra] end;
-    _  -> [translate_guard(Line, Guard, Extra, SG) || Guard <- Guards]
+      case maps:get(Current, Cycles) of
+        #{Current := _} ->
+          file_error(Meta, E, ?MODULE, {recursive, [Current], Expr});
+
+        DependsOn ->
+          %% We traverse over the skip list. For each entry that contains ourselves,
+          %% we will split the remaining variables in two groups: one which we have
+          %% direct dependencies and skip once and ones that we always skip.
+          %%
+          %% For example, take `foo = {bar = {baz, bat}}`. `baz` and `bat` never depend
+          %% on each other, so we always skip `baz` and `bat` whenever any of them are
+          %% seen. However, while `bar` is in the same group as `baz` and `bat` (from the
+          %% point of view of `foo`), it depends on them, so it only skips once.
+          {OnceKeys, AlwaysKeys} =
+            lists:foldl(fun
+              (#{Current := _} = Skip, Acc) ->
+                maps:fold(fun(K, _, {AccOnce, AccAlways}) ->
+                  case DependsOn of
+                    #{K := _} -> {[K | AccOnce], AccAlways};
+                    #{} -> {AccOnce, [K | AccAlways]}
+                  end
+                end, Acc, Skip);
+              (_Skip, Acc) ->
+                Acc
+            end, {[], []}, SkipList),
+
+          NewSeen = maps:merge(maps:from_keys(AlwaysKeys, false), maps:put(Current, true, Seen)),
+
+          maps:fold(fun
+            (Key, error, _See) ->
+              file_error(Meta, E, ?MODULE, {recursive, [Current, Key], Expr});
+
+            %% Never go back to the node that we came from (as we can always one hop).
+            (Key, _, AccSeen) when Key =:= Source ->
+              AccSeen;
+
+            (Key, _, AccSeen) ->
+              case lists:member(Key, OnceKeys) of
+                true ->
+                  AccSeen;
+
+                false when map_get(Key, Seen) ->
+                  file_error(Meta, E, ?MODULE, {recursive, [Current | maps:keys(Seen)], Expr});
+
+                false ->
+                  recur_cycles(Cycles, Key, Current, AccSeen, SkipList, Meta, Expr, E)
+              end
+          end, NewSeen, DependsOn)
+      end
   end.
 
-translate_guard(Line, Guard, Extra, S) ->
-  [element(1, elixir_translator:translate(elixir_quote:linify(Line, Guard), S))|Extra].
+%% Match
 
-extract_guards({'when', _, [Left, Right]}) -> {Left, extract_or_guards(Right)};
-extract_guards(Else) -> {Else, []}.
+match(Fun, Meta, Expr, AfterS, BeforeS, #{context := nil} = E) ->
+  #elixir_ex{vars=Current, unused={_, Counter} = Unused} = AfterS,
+  #elixir_ex{vars={Read, _}, prematch=Prematch} = BeforeS,
 
-extract_or_guards({'when', _, [Left, Right]}) -> [Left|extract_or_guards(Right)];
-extract_or_guards(Term) -> [Term].
-
-% Extract guards when multiple left side args are allowed.
+  CallS = BeforeS#elixir_ex{
+    prematch={Read, {#{}, []}, Counter},
+    unused=Unused,
+    vars=Current
+  },
 
-extract_splat_guards([{'when', _, [_,_|_] = Args}]) ->
-  {Left, Right} = elixir_utils:split_last(Args),
-  {Left, extract_or_guards(Right)};
-extract_splat_guards(Else) ->
-  {Else, []}.
+  CallE = E#{context := match},
+  {EExpr, SE, EE} = Fun(Expr, CallS, CallE),
 
-% Function for translating macros with match style like case and receive.
+  #elixir_ex{
+    vars=NewCurrent,
+    unused=NewUnused,
+    prematch={_, Cycles, _}
+  } = SE,
 
-clauses(Meta, Clauses, Return, #elixir_scope{export_vars=CV} = S) ->
-  {TC, TS} = do_clauses(Meta, Clauses, Return, S#elixir_scope{export_vars=[]}),
-  {TC, TS#elixir_scope{export_vars=elixir_scope:merge_opt_vars(CV, TS#elixir_scope.export_vars)}}.
+  validate_cycles(Cycles, Meta, {match, Expr}, E),
 
-do_clauses(_Meta, [], _Return, S) ->
-  {[], S};
+  EndS = AfterS#elixir_ex{
+    prematch=Prematch,
+    unused=NewUnused,
+    vars=NewCurrent
+  },
 
-do_clauses(Meta, DecoupledClauses, Return, S) ->
-  % Transform tree just passing the variables counter forward
-  % and storing variables defined inside each clause.
-  Transformer = fun(X, {SAcc, VAcc}) ->
-    {TX, TS} = each_clause(Meta, X, Return, SAcc),
-    {TX, {elixir_scope:mergec(S, TS), [TS#elixir_scope.export_vars|VAcc]}}
+  EndE = EE#{context := ?key(E, context)},
+  {EExpr, EndS, EndE}.
+
+def({Meta, Args, Guards, Body}, S, E) ->
+  {EArgs, SA, EA} = elixir_expand:expand_args(Args, S#elixir_ex{prematch={#{}, {#{}, []}, 0}}, E#{context := match}),
+  #elixir_ex{prematch={_, Cycles, _}} = SA,
+  validate_cycles(Cycles, Meta, {?key(E, function), Args}, E),
+  {EGuards, SG, EG} = guard(Guards, SA#elixir_ex{prematch=none}, EA#{context := guard}),
+  {EBody, SB, EB} = elixir_expand:expand(Body, SG, EG#{context := nil}),
+  elixir_env:check_unused_vars(SB, EB),
+  {Meta, EArgs, EGuards, EBody}.
+
+clause(_Meta, _Kind, Fun, {'->', Meta, [Left, Right]}, S, E) ->
+  {ELeft, SL, EL}  = case is_function(Fun, 4) of
+    true -> Fun(Meta, Left, S, E);
+    false -> Fun(Left, S, E)
+  end,
+  {ERight, SR, ER} = elixir_expand:expand(Right, SL, EL),
+  {{'->', Meta, [ELeft, ERight]}, SR, ER};
+clause(Meta, Kind, _Fun, _, _, E) ->
+  file_error(Meta, E, ?MODULE, {bad_or_missing_clauses, Kind}).
+
+head(Meta, [{'when', WhenMeta, [_ | _] = All}], S, E) ->
+  {Args, Guard} = elixir_utils:split_last(All),
+  guarded_head(Meta, WhenMeta, Args, Guard, S, E);
+head(Meta, Args, S, E) ->
+  match(fun elixir_expand:expand_args/3, Meta, Args, S, S, E).
+
+guarded_head(Meta, WhenMeta, Args, Guard, S, E) ->
+  {EArgs, SA, EA} = match(fun elixir_expand:expand_args/3, Meta, Args, S, S, E),
+  {EGuard, SG, EG} = guard(Guard, SA, EA#{context := guard}),
+  {[{'when', WhenMeta, EArgs ++ [EGuard]}], SG, EG#{context := nil}}.
+
+guard({'when', Meta, [Left, Right]}, S, E) ->
+  {ELeft, SL, EL}  = guard(Left, S, E),
+  {ERight, SR, ER} = guard(Right, SL, EL),
+  {{'when', Meta, [ELeft, ERight]}, SR, ER};
+guard(Guard, S, E) ->
+  {EGuard, SG, EG} = elixir_expand:expand(Guard, S, E),
+  warn_zero_length_guard(EGuard, EG),
+  {EGuard, SG, EG}.
+
+warn_zero_length_guard({{'.', _, [erlang, Op]}, Meta,
+                        [{{'.', _, [erlang, length]}, _, [Arg]}, 0]}, E) when Op == '=='; Op == '>' ->
+  Warn =
+    case Op of
+      '==' -> {zero_list_length_in_guard, Arg};
+      '>' -> {positive_list_length_in_guard, Arg}
+    end,
+  file_warn(Meta, ?key(E, file), ?MODULE, Warn);
+warn_zero_length_guard({Op, _, [L, R]}, E) when Op == 'or'; Op == 'and' ->
+  warn_zero_length_guard(L, E),
+  warn_zero_length_guard(R, E);
+warn_zero_length_guard(_, _) ->
+  ok.
+
+%% Case
+
+'case'(Meta, [], _S, E) ->
+  file_error(Meta, E, elixir_expand, {missing_option, 'case', [do]});
+'case'(Meta, Opts, _S, E) when not is_list(Opts) ->
+  file_error(Meta, E, elixir_expand, {invalid_args, 'case'});
+'case'(Meta, Opts, S, E) ->
+  ok = assert_at_most_once('do', Opts, 0, fun(Key) ->
+    file_error(Meta, E, ?MODULE, {duplicated_clauses, 'case', Key})
+  end),
+  {Case, SA} = lists:mapfoldl(fun(X, SA) -> expand_case(Meta, X, SA, E) end, S, Opts),
+  {Case, SA, E}.
+
+expand_case(Meta, {'do', _} = Do, S, E) ->
+  Fun = expand_head('case', 'do'),
+  expand_clauses(Meta, 'case', Fun, Do, S, E);
+expand_case(Meta, {Key, _}, _S, E) ->
+  file_error(Meta, E, ?MODULE, {unexpected_option, 'case', Key}).
+
+%% Cond
+
+'cond'(Meta, [], _S, E) ->
+  file_error(Meta, E, elixir_expand, {missing_option, 'cond', [do]});
+'cond'(Meta, Opts, _S, E) when not is_list(Opts) ->
+  file_error(Meta, E, elixir_expand, {invalid_args, 'cond'});
+'cond'(Meta, Opts, S, E) ->
+  ok = assert_at_most_once('do', Opts, 0, fun(Key) ->
+    file_error(Meta, E, ?MODULE, {duplicated_clauses, 'cond', Key})
+  end),
+  {Cond, SA} = lists:mapfoldl(fun(X, SA) -> expand_cond(Meta, X, SA, E) end, S, Opts),
+  {Cond, SA, E}.
+
+expand_cond(Meta, {'do', _} = Do, S, E) ->
+  Fun = expand_one(Meta, 'cond', 'do', fun elixir_expand:expand_args/3),
+  expand_clauses(Meta, 'cond', Fun, Do, S, E);
+expand_cond(Meta, {Key, _}, _S, E) ->
+  file_error(Meta, E, ?MODULE, {unexpected_option, 'cond', Key}).
+
+%% Receive
+
+'receive'(Meta, [], _S, E) ->
+  file_error(Meta, E, elixir_expand, {missing_option, 'receive', [do, 'after']});
+'receive'(Meta, Opts, _S, E) when not is_list(Opts) ->
+  file_error(Meta, E, elixir_expand, {invalid_args, 'receive'});
+'receive'(Meta, Opts, S, E) ->
+  RaiseError = fun(Key) ->
+    file_error(Meta, E, ?MODULE, {duplicated_clauses, 'receive', Key})
+  end,
+  ok = assert_at_most_once('do', Opts, 0, RaiseError),
+  ok = assert_at_most_once('after', Opts, 0, RaiseError),
+  {Receive, SA} = lists:mapfoldl(fun(X, SA) -> expand_receive(Meta, X, SA, E) end, S, Opts),
+  {Receive, SA, E}.
+
+expand_receive(_Meta, {'do', {'__block__', _, []}} = Do, S, _E) ->
+  {Do, S};
+expand_receive(Meta, {'do', _} = Do, S, E) ->
+  Fun = expand_head('receive', 'do'),
+  expand_clauses(Meta, 'receive', Fun, Do, S, E);
+expand_receive(Meta, {'after', [_]} = After, S, E) ->
+  Fun = expand_one(Meta, 'receive', 'after', fun elixir_expand:expand_args/3),
+  expand_clauses(Meta, 'receive', Fun, After, S, E);
+expand_receive(Meta, {'after', _}, _S, E) ->
+  file_error(Meta, E, ?MODULE, multiple_after_clauses_in_receive);
+expand_receive(Meta, {Key, _}, _S, E) ->
+  file_error(Meta, E, ?MODULE, {unexpected_option, 'receive', Key}).
+
+%% With
+
+with(Meta, Args, S, E) ->
+  {Exprs, Opts0} = elixir_utils:split_opts(Args),
+  S0 = elixir_env:reset_unused_vars(S),
+  {EExprs, {S1, E1, HasMatch}} = lists:mapfoldl(fun expand_with/2, {S0, E, false}, Exprs),
+  {EDo, Opts1, S2} = expand_with_do(Meta, Opts0, S, S1, E1),
+  {EOpts, Opts2, S3} = expand_with_else(Meta, Opts1, S2, E, HasMatch),
+
+  case Opts2 of
+    [{Key, _} | _] ->
+      file_error(Meta, E, elixir_clauses, {unexpected_option, with, Key});
+    [] ->
+      ok
   end,
 
-  {TClauses, {TS, ReverseCV}} =
-    lists:mapfoldl(Transformer, {S, []}, DecoupledClauses),
-
-  % Now get all the variables defined inside each clause
-  CV = lists:reverse(ReverseCV),
-  AllVars = lists:foldl(fun elixir_scope:merge_vars/2, [], CV),
-
-  % Create a new scope that contains a list of all variables
-  % defined inside all the clauses. It returns this new scope and
-  % a list of tuples where the first element is the variable name,
-  % the second one is the new pointer to the variable and the third
-  % is the old pointer.
-  {FinalVars, FS} = lists:mapfoldl(fun({Key, Val}, Acc) ->
-    normalize_vars(Key, Val, Acc)
-  end, TS, AllVars),
-
-  % Expand all clauses by adding a match operation at the end
-  % that defines variables missing in one clause to the others.
-  expand_clauses(?line(Meta), TClauses, CV, FinalVars, [], FS).
-
-expand_clauses(Line, [Clause|T], [ClauseVars|V], FinalVars, Acc, S) ->
-  case generate_match_vars(FinalVars, ClauseVars, [], []) of
-    {[], []} ->
-      expand_clauses(Line, T, V, FinalVars, [Clause|Acc], S);
-    {Left, Right} ->
-      MatchExpr   = generate_match(Line, Left, Right),
-      ClauseExprs = element(5, Clause),
-      [Final|RawClauseExprs] = lists:reverse(ClauseExprs),
-
-      % If the last sentence has a match clause, we need to assign its value
-      % in the variable list. If not, we insert the variable list before the
-      % final clause in order to keep it tail call optimized.
-      {FinalClauseExprs, FS} = case has_match_tuple(Final) of
-        true ->
-          case Final of
-            {match, _, {var, _, UserVarName} = UserVar, _} when UserVarName /= '_' ->
-              {[UserVar,MatchExpr,Final|RawClauseExprs], S};
-            _ ->
-              {VarName, _, SS} = elixir_scope:build_var('_', S),
-              StorageVar  = {var, Line, VarName},
-              StorageExpr = {match, Line, StorageVar, Final},
-              {[StorageVar,MatchExpr,StorageExpr|RawClauseExprs], SS}
-          end;
-        false ->
-          {[Final,MatchExpr|RawClauseExprs], S}
+  {{with, Meta, EExprs ++ [[{do, EDo} | EOpts]]}, S3, E}.
+
+expand_with({'<-', Meta, [Left, Right]}, {S, E, HasMatch}) ->
+  {ERight, SR, ER} = elixir_expand:expand(Right, S, E),
+  SM = elixir_env:reset_read(SR, S),
+  {[ELeft], SL, EL} = head(Meta, [Left], SM, ER),
+  NewHasMatch =
+    case ELeft of
+      {Var, _, Ctx} when is_atom(Var), is_atom(Ctx) -> HasMatch;
+      _ -> true
+    end,
+  {{'<-', Meta, [ELeft, ERight]}, {SL, EL, NewHasMatch}};
+expand_with(Expr, {S, E, HasMatch}) ->
+  {EExpr, SE, EE} = elixir_expand:expand(Expr, S, E),
+  {EExpr, {SE, EE, HasMatch}}.
+
+expand_with_do(Meta, Opts, S, Acc, E) ->
+  case lists:keytake(do, 1, Opts) of
+    {value, {do, Expr}, RestOpts} ->
+      {EExpr, SAcc, EAcc} = elixir_expand:expand(Expr, Acc, E),
+      {EExpr, RestOpts, elixir_env:merge_and_check_unused_vars(SAcc, S, EAcc)};
+    false ->
+      file_error(Meta, E, elixir_expand, {missing_option, 'with', [do]})
+  end.
+
+expand_with_else(Meta, Opts, S, E, HasMatch) ->
+  case lists:keytake('else', 1, Opts) of
+    {value, Pair, RestOpts} ->
+      if
+        HasMatch -> ok;
+        true -> file_warn(Meta, ?key(E, file), ?MODULE, unmatchable_else_in_with)
       end,
+      Fun = expand_head('with', 'else'),
+      {EPair, SE} = expand_clauses(Meta, 'with', Fun, Pair, S, E),
+      {[EPair], RestOpts, SE};
+    false ->
+      {[], Opts, S}
+  end.
 
-      FinalClause = setelement(5, Clause, lists:reverse(FinalClauseExprs)),
-      expand_clauses(Line, T, V, FinalVars, [FinalClause|Acc], FS)
+%% Try
+
+'try'(Meta, [], _S, E) ->
+  file_error(Meta, E, elixir_expand, {missing_option, 'try', [do]});
+'try'(Meta, [{do, _}], _S, E) ->
+  file_error(Meta, E, elixir_expand, {missing_option, 'try', ['catch', 'rescue', 'after']});
+'try'(Meta, Opts, _S, E) when not is_list(Opts) ->
+  file_error(Meta, E, elixir_expand, {invalid_args, 'try'});
+'try'(Meta, Opts, S, E) ->
+  % TODO: Make this an error on v2.0
+  case Opts of
+    [{do, _}, {'else', _}] ->
+      file_warn(Meta, ?key(E, file), ?MODULE, {try_with_only_else_clause, origin(Meta, 'try')});
+    _ ->
+      ok
+  end,
+  RaiseError = fun(Key) ->
+    file_error(Meta, E, ?MODULE, {duplicated_clauses, 'try', Key})
+  end,
+  ok = assert_at_most_once('do', Opts, 0, RaiseError),
+  ok = assert_at_most_once('rescue', Opts, 0, RaiseError),
+  ok = assert_at_most_once('catch', Opts, 0, RaiseError),
+  ok = assert_at_most_once('else', Opts, 0, RaiseError),
+  ok = assert_at_most_once('after', Opts, 0, RaiseError),
+  ok = warn_catch_before_rescue(Opts, Meta, E, false),
+  {Try, SA} = lists:mapfoldl(fun(X, SA) -> expand_try(Meta, X, SA, E) end, S, Opts),
+  {Try, SA, E}.
+
+expand_try(_Meta, {'do', Expr}, S, E) ->
+  {EExpr, SE, EE} = elixir_expand:expand(Expr, elixir_env:reset_unused_vars(S), E),
+  {{'do', EExpr}, elixir_env:merge_and_check_unused_vars(SE, S, EE)};
+expand_try(_Meta, {'after', Expr}, S, E) ->
+  {EExpr, SE, EE} = elixir_expand:expand(Expr, elixir_env:reset_unused_vars(S), E),
+  {{'after', EExpr}, elixir_env:merge_and_check_unused_vars(SE, S, EE)};
+expand_try(Meta, {'else', _} = Else, S, E) ->
+  Fun = expand_head('try', 'else'),
+  expand_clauses(Meta, 'try', Fun, Else, S, E);
+expand_try(Meta, {'catch', _} = Catch, S, E) ->
+  expand_clauses_with_stacktrace(Meta, fun expand_catch/4, Catch, S, E);
+expand_try(Meta, {'rescue', _} = Rescue, S, E) ->
+  expand_clauses_with_stacktrace(Meta, fun expand_rescue/4, Rescue, S, E);
+expand_try(Meta, {Key, _}, _S, E) ->
+  file_error(Meta, E, ?MODULE, {unexpected_option, 'try', Key}).
+
+expand_clauses_with_stacktrace(Meta, Fun, Clauses, S, E) ->
+  OldStacktrace = S#elixir_ex.stacktrace,
+  SS = S#elixir_ex{stacktrace=true},
+  {Ret, SE} = expand_clauses(Meta, 'try', Fun, Clauses, SS, E),
+  {Ret, SE#elixir_ex{stacktrace=OldStacktrace}}.
+
+expand_catch(Meta, [{'when', _, [_, _, _, _ | _]}], _, E) ->
+  Error = {wrong_number_of_args_for_clause, "one or two args", origin(Meta, 'try'), 'catch'},
+  file_error(Meta, E, ?MODULE, Error);
+expand_catch(Meta, [{'when', WhenMeta, [Arg1, Arg2, Guard]}], S, E) ->
+  guarded_head(Meta, WhenMeta, [Arg1, Arg2], Guard, S, E);
+expand_catch(Meta, [{'when', WhenMeta, [Arg1, Guard]}], S, E) ->
+  guarded_head(Meta, WhenMeta, [throw, Arg1], Guard, S, E);
+expand_catch(Meta, [Arg], S, E) ->
+  head(Meta, [throw, Arg], S, E);
+expand_catch(Meta, [_, _] = Args, S, E) ->
+  head(Meta, Args, S, E);
+expand_catch(Meta, _, _, E) ->
+  Error = {wrong_number_of_args_for_clause, "one or two args", origin(Meta, 'try'), 'catch'},
+  file_error(Meta, E, ?MODULE, Error).
+
+expand_rescue(Meta, [Arg], S, E) ->
+  case expand_rescue(Arg, S, E) of
+    {EArg, SA, EA} ->
+      {[EArg], SA, EA};
+    false ->
+      file_error(Meta, E, ?MODULE, {invalid_rescue_clause, Arg})
   end;
-
-expand_clauses(_Line, [], [], _FinalVars, Acc, S) ->
-  {lists:reverse(Acc), S}.
-
-% Handle each key/value clause pair and translate them accordingly.
-
-each_clause(Export, {match, Meta, [Condition], Expr}, Return, S) ->
-  Fun = wrap_export_fun(Export, fun elixir_translator:translate_args/2),
-  {Arg, Guards} = extract_guards(Condition),
-  clause(?line(Meta), Fun, [Arg], Expr, Guards, Return, S);
-
-each_clause(Export, {expr, Meta, [Condition], Expr}, Return, S) ->
-  {TCondition, SC} = (wrap_export_fun(Export, fun elixir_translator:translate/2))(Condition, S),
-  {TExpr, SB} = elixir_translator:translate_block(Expr, Return, SC),
-  {{clause, ?line(Meta), [TCondition], [], unblock(TExpr)}, SB}.
-
-wrap_export_fun(Meta, Fun) ->
-  case lists:keyfind(export_head, 1, Meta) of
-    {export_head, true} ->
-      Fun;
+expand_rescue(Meta, _, _, E) ->
+  Error = {wrong_number_of_args_for_clause, "one argument", origin(Meta, 'try'), 'rescue'},
+  file_error(Meta, E, ?MODULE, Error).
+
+%% rescue var
+expand_rescue({Name, Meta, Atom} = Var, S, E) when is_atom(Name), is_atom(Atom) ->
+  match(fun elixir_expand:expand/3, Meta, Var, S, S, E);
+
+%% rescue Alias => _ in [Alias]
+expand_rescue({'__aliases__', _, [_ | _]} = Alias, S, E) ->
+  expand_rescue({in, [], [{'_', [], ?key(E, module)}, Alias]}, S, E);
+
+%% rescue var in _
+expand_rescue({in, _, [{Name, Meta, VarContext} = Var, {'_', _, UnderscoreContext}]}, S, E)
+    when is_atom(Name), is_atom(VarContext), is_atom(UnderscoreContext) ->
+  match(fun elixir_expand:expand/3, Meta, Var, S, S, E);
+
+%% rescue var in (list() or atom())
+expand_rescue({in, Meta, [Left, Right]}, S, E) ->
+  {ELeft, SL, EL}  = match(fun elixir_expand:expand/3, Meta, Left, S, S, E),
+  {ERight, SR, ER} = elixir_expand:expand(Right, SL, EL),
+
+  case ELeft of
+    {Name, _, Atom} when is_atom(Name), is_atom(Atom) ->
+      case normalize_rescue(ERight) of
+        false -> false;
+        Other -> {{in, Meta, [ELeft, Other]}, SR, ER}
+      end;
     _ ->
-      fun(Args, S) ->
-        {TArgs, TS} = Fun(Args, S),
-        {TArgs, TS#elixir_scope{export_vars = S#elixir_scope.export_vars}}
-      end
-  end.
+      false
+  end;
 
-% Check if the given expression is a match tuple.
-% This is a small optimization to allow us to change
-% existing assignments instead of creating new ones every time.
-
-has_match_tuple({'receive', _, _, _, _}) ->
-  true;
-has_match_tuple({'receive', _, _}) ->
-  true;
-has_match_tuple({'case', _, _, _}) ->
-  true;
-has_match_tuple({match, _, _, _}) ->
-  true;
-has_match_tuple({'fun', _, {clauses, _}}) ->
-  false;
-has_match_tuple(H) when is_tuple(H) ->
-  has_match_tuple(tuple_to_list(H));
-has_match_tuple(H) when is_list(H) ->
-  lists:any(fun has_match_tuple/1, H);
-has_match_tuple(_) -> false.
-
-% Normalize the given var in between clauses
-% by picking one value as reference and retriving
-% its previous value.
-
-normalize_vars(Key, Value, #elixir_scope{vars=Vars,export_vars=ClauseVars} = S) ->
-  VS = S#elixir_scope{
-    vars=orddict:store(Key, Value, Vars),
-    export_vars=orddict:store(Key, Value, ClauseVars)
-  },
+%% rescue expr() => rescue expanded_expr()
+expand_rescue({_, Meta, _} = Arg, S, E) ->
+  case 'Elixir.Macro':expand_once(Arg, E#{line := ?line(Meta)}) of
+    Arg -> false;
+    NewArg -> expand_rescue(NewArg, S, E)
+  end;
 
-  Expr = case orddict:find(Key, Vars) of
-    {ok, {PreValue, _}} -> {var, 0, PreValue};
-    error -> {atom, 0, nil}
-  end,
+%% rescue list() or atom() => _ in (list() or atom())
+expand_rescue(Arg, S, E) ->
+  expand_rescue({in, [], [{'_', [], ?key(E, module)}, Arg]}, S, E).
+
+normalize_rescue(Atom) when is_atom(Atom) ->
+  [Atom];
+normalize_rescue(Other) ->
+  is_list(Other) andalso lists:all(fun is_atom/1, Other) andalso Other.
+
+%% Expansion helpers
+
+expand_head(Kind, Key) ->
+  fun
+    (Meta, [{'when', _, [_, _, _ | _]}], _, E) ->
+      file_error(Meta, E, ?MODULE, {wrong_number_of_args_for_clause, "one argument", Kind, Key});
+    (Meta, [_] = Args, S, E) ->
+      head(Meta, Args, S, E);
+    (Meta, _, _, E) ->
+      file_error(Meta, E, ?MODULE, {wrong_number_of_args_for_clause, "one argument", Kind, Key})
+  end.
 
-  {{Key, Value, Expr}, VS}.
-
-% Generate match vars by checking if they were updated
-% or not and assigning the previous value.
-
-generate_match_vars([{Key, Value, Expr}|T], ClauseVars, Left, Right) ->
-  case orddict:find(Key, ClauseVars) of
-    {ok, Value} ->
-      generate_match_vars(T, ClauseVars, Left, Right);
-    {ok, Clause} ->
-      generate_match_vars(T, ClauseVars,
-        [{var, 0, element(1, Value)}|Left],
-        [{var, 0, element(1, Clause)}|Right]);
-    error ->
-      generate_match_vars(T, ClauseVars,
-        [{var, 0, element(1, Value)}|Left], [Expr|Right])
-  end;
+%% Returns a function that expands arguments
+%% considering we have at maximum one entry.
+expand_one(Meta, Kind, Key, Fun) ->
+  fun
+    ([_] = Args, S, E) ->
+      Fun(Args, S, E);
+    (_, _, E) ->
+      file_error(Meta, E, ?MODULE, {wrong_number_of_args_for_clause, "one argument", Kind, Key})
+  end.
 
-generate_match_vars([], _ClauseVars, Left, Right) ->
-  {Left, Right}.
+%% Expands all -> pairs in a given key but do not keep the overall vars.
+expand_clauses(Meta, Kind, Fun, Clauses, S, E) ->
+  NewKind = origin(Meta, Kind),
+  expand_clauses_origin(Meta, NewKind, Fun, Clauses, S, E).
 
-generate_match(Line, [Left], [Right]) ->
-  {match, Line, Left, Right};
+expand_clauses_origin(Meta, Kind, Fun, {Key, [_ | _] = Clauses}, S, E) ->
+  Transformer = fun(Clause, SA) ->
+    {EClause, SAcc, EAcc} =
+      clause(Meta, {Kind, Key}, Fun, Clause, elixir_env:reset_unused_vars(SA), E),
 
-generate_match(Line, LeftVars, RightVars) ->
-  {match, Line, {tuple, Line, LeftVars}, {tuple, Line, RightVars}}.
+    {EClause, elixir_env:merge_and_check_unused_vars(SAcc, SA, EAcc)}
+  end,
+  {Values, SE} = lists:mapfoldl(Transformer, S, Clauses),
+  {{Key, Values}, SE};
+expand_clauses_origin(Meta, Kind, _Fun, {Key, _}, _, E) ->
+  file_error(Meta, E, ?MODULE, {bad_or_missing_clauses, {Kind, Key}}).
+
+assert_at_most_once(_Kind, [], _Count, _Fun) -> ok;
+assert_at_most_once(Kind, [{Kind, _} | _], 1, ErrorFun) ->
+  ErrorFun(Kind);
+assert_at_most_once(Kind, [{Kind, _} | Rest], Count, Fun) ->
+  assert_at_most_once(Kind, Rest, Count + 1, Fun);
+assert_at_most_once(Kind, [_ | Rest], Count, Fun) ->
+  assert_at_most_once(Kind, Rest, Count, Fun).
+
+warn_catch_before_rescue([], _, _, _) ->
+  ok;
+warn_catch_before_rescue([{'rescue', _} | _], Meta, E, true) ->
+  file_warn(Meta, ?key(E, file), ?MODULE, {catch_before_rescue, origin(Meta, 'try')});
+warn_catch_before_rescue([{'catch', _} | Rest], Meta, E, _) ->
+  warn_catch_before_rescue(Rest, Meta, E, true);
+warn_catch_before_rescue([_ | Rest], Meta, E, Found) ->
+  warn_catch_before_rescue(Rest, Meta, E, Found).
+
+origin(Meta, Default) ->
+  case lists:keyfind(origin, 1, Meta) of
+    {origin, Origin} -> Origin;
+    false -> Default
+  end.
 
-unblock({'block', _, Exprs}) -> Exprs;
-unblock(Exprs) -> [Exprs].
+format_error({duplicate_match, Expr}) ->
+  String = 'Elixir.Macro':to_string(Expr),
+  io_lib:format(
+    "this pattern is matched against itself inside a match: ~ts = ~ts",
+    [String, String]
+  );
+
+format_error({recursive, Vars, TypeExpr}) ->
+  Code =
+    case TypeExpr of
+      {match, Expr} -> 'Elixir.Macro':to_string(Expr);
+      {{Name, _Arity}, Args} -> 'Elixir.Macro':to_string({Name, [], Args})
+    end,
+
+  Message =
+    case lists:map(fun({Name, Context}) -> elixir_utils:var_info(Name, Context) end, lists:sort(Vars)) of
+      [Var] ->
+        io_lib:format("the variable ~ts is defined in function of itself", [Var]);
+      [Var1, Var2] ->
+        io_lib:format("the variable ~ts is defined recursively in function of ~ts", [Var1, Var2]);
+      [Head | Tail] ->
+        List = lists:foldl(fun(X, Acc) -> [Acc, $,, $\s, X] end, Head, Tail),
+        io_lib:format("the following variables form a cycle: ~ts", [List])
+    end,
+
+  io_lib:format(
+    "recursive variable definition in patterns:~n~n~ts~n~n~ts",
+    [Code, Message]
+  );
+
+format_error({bad_or_missing_clauses, {Kind, Key}}) ->
+  io_lib:format("invalid \"~ts\" block in \"~ts\", it expects \"pattern -> expr\" clauses", [Key, Kind]);
+
+format_error({duplicated_clauses, Kind, Key}) ->
+  io_lib:format("duplicate \"~ts\" clauses given for \"~ts\"", [Key, Kind]);
+
+format_error({unexpected_option, Kind, Option}) ->
+  io_lib:format("unexpected option ~ts in \"~ts\"", ['Elixir.Macro':to_string(Option), Kind]);
+
+format_error({wrong_number_of_args_for_clause, Expected, Kind, Key}) ->
+  io_lib:format("expected ~ts for \"~ts\" clauses (->) in \"~ts\"", [Expected, Key, Kind]);
+
+format_error(multiple_after_clauses_in_receive) ->
+  "expected a single -> clause for :after in \"receive\"";
+
+format_error({invalid_rescue_clause, Arg}) ->
+  io_lib:format(
+    "invalid \"rescue\" clause. The clause should match on an alias, a variable "
+    "or be in the \"var in [alias]\" format. Got: ~ts",
+    ['Elixir.Macro':to_string(Arg)]
+  );
+
+format_error({catch_before_rescue, Origin}) ->
+  io_lib:format("\"catch\" should always come after \"rescue\" in ~ts", [Origin]);
+
+format_error({try_with_only_else_clause, Origin}) ->
+  io_lib:format("\"else\" shouldn't be used as the only clause in \"~ts\", use \"case\" instead",
+                [Origin]);
+
+format_error(unmatchable_else_in_with) ->
+  "\"else\" clauses will never match because all patterns in \"with\" will always match";
+
+format_error({zero_list_length_in_guard, ListArg}) ->
+  Arg = 'Elixir.Macro':to_string(ListArg),
+  io_lib:format("do not use \"length(~ts) == 0\" to check if a list is empty since length "
+                "always traverses the whole list. Prefer to pattern match on an empty list or "
+                "use \"~ts == []\" as a guard", [Arg, Arg]);
+
+format_error({positive_list_length_in_guard, ListArg}) ->
+  Arg = 'Elixir.Macro':to_string(ListArg),
+  io_lib:format("do not use \"length(~ts) > 0\" to check if a list is not empty since length "
+                "always traverses the whole list. Prefer to pattern match on a non-empty list, "
+                "such as [_ | _], or use \"~ts != []\" as a guard", [Arg, Arg]).
diff --git a/lib/elixir/src/elixir_code_server.erl b/lib/elixir/src/elixir_code_server.erl
index 1a1f5e08bf5..4185cebd659 100644
--- a/lib/elixir/src/elixir_code_server.erl
+++ b/lib/elixir/src/elixir_code_server.erl
@@ -1,18 +1,18 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(elixir_code_server).
 -export([call/1, cast/1]).
 -export([start_link/0, init/1, handle_call/3, handle_cast/2,
   handle_info/2, terminate/2, code_change/3]).
 -behaviour(gen_server).
 
--define(timeout, 30000).
+-define(timeout, infinity).
 -record(elixir_code_server, {
-  compilation_status=[],
-  argv=[],
-  loaded=[],
-  at_exit=[],
-  pool={[],0},
-  compiler_options=[{docs,true},{debug_info,true},{warnings_as_errors,false}],
-  erl_compiler_options=nil
+  required=#{},
+  mod_pool={[], [], 0},
+  mod_ets=#{}
 }).
 
 call(Args) ->
@@ -27,114 +27,112 @@ start_link() ->
   gen_server:start_link({local, ?MODULE}, ?MODULE, ok, []).
 
 init(ok) ->
-  code:ensure_loaded('Elixir.Macro.Env'),
-  code:ensure_loaded('Elixir.Module.LocalsTracker'),
-  code:ensure_loaded('Elixir.Kernel.LexicalTracker'),
+  %% The table where we store module definitions
+  _ = ets:new(elixir_modules, [set, public, named_table, {read_concurrency, true}]),
   {ok, #elixir_code_server{}}.
 
+handle_call({defmodule, Module, Pid, Tuple}, _From, Config) ->
+  case ets:lookup(elixir_modules, Module) of
+    [] ->
+      {Ref, NewConfig} = defmodule(Pid, Tuple, Config),
+      {reply, {ok, Ref}, NewConfig};
+    [CurrentTuple] ->
+      {reply, {error, CurrentTuple}, Config}
+  end;
+
+handle_call({undefmodule, Ref}, _From, Config) ->
+  {reply, ok, undefmodule(Ref, Config)};
+
 handle_call({acquire, Path}, From, Config) ->
-  Current = Config#elixir_code_server.loaded,
-  case orddict:find(Path, Current) of
+  Current = Config#elixir_code_server.required,
+  case maps:find(Path, Current) of
     {ok, true} ->
-      {reply, loaded, Config};
-    {ok, {Ref, List}} when is_list(List), is_reference(Ref) ->
-      Queued = orddict:store(Path, {Ref, [From|List]}, Current),
-      {reply, {queued, Ref}, Config#elixir_code_server{loaded=Queued}};
+      {reply, required, Config};
+    {ok, Queued} when is_list(Queued) ->
+      Required = maps:put(Path, [From | Queued], Current),
+      {noreply, Config#elixir_code_server{required=Required}};
     error ->
-      Queued = orddict:store(Path, {make_ref(), []}, Current),
-      {reply, proceed, Config#elixir_code_server{loaded=Queued}}
+      Required = maps:put(Path, [], Current),
+      {reply, proceed, Config#elixir_code_server{required=Required}}
   end;
 
-handle_call(loaded, _From, Config) ->
-  {reply, [F || {F, true} <- Config#elixir_code_server.loaded], Config};
-
-handle_call(at_exit, _From, Config) ->
-  {reply, Config#elixir_code_server.at_exit, Config};
-
-handle_call(flush_at_exit, _From, Config) ->
-  {reply, Config#elixir_code_server.at_exit, Config#elixir_code_server{at_exit=[]}};
+handle_call(required, _From, Config) ->
+  {reply, [F || {F, true} <- maps:to_list(Config#elixir_code_server.required)], Config};
 
-handle_call(argv, _From, Config) ->
-  {reply, Config#elixir_code_server.argv, Config};
-
-handle_call(compiler_options, _From, Config) ->
-  {reply, Config#elixir_code_server.compiler_options, Config};
-
-handle_call({compilation_status, CompilerPid}, _From, Config) ->
-  CompilationStatusList    = Config#elixir_code_server.compilation_status,
-  CompilationStatusListNew = orddict:erase(CompilerPid, CompilationStatusList),
-  CompilationStatus        = orddict:fetch(CompilerPid, CompilationStatusList),
-  {reply, CompilationStatus, Config#elixir_code_server{compilation_status=CompilationStatusListNew}};
-
-handle_call(retrieve_module_name, _From, Config) ->
-  case Config#elixir_code_server.pool of
-    {[H|T], Counter} ->
-      {reply, module_tuple(H), Config#elixir_code_server{pool={T,Counter}}};
-    {[], Counter} ->
-      {reply, module_tuple(Counter), Config#elixir_code_server{pool={[],Counter+1}}}
+handle_call(retrieve_compiler_module, _From, Config) ->
+  case Config#elixir_code_server.mod_pool of
+    {Used, [Mod | Unused], Counter} ->
+      {reply, Mod, Config#elixir_code_server{mod_pool={Used, Unused, Counter}}};
+    {Used, [], Counter} ->
+      {reply, compiler_module(Counter), Config#elixir_code_server{mod_pool={Used, [], Counter+1}}}
   end;
 
-handle_call(erl_compiler_options, _From, Config) ->
-  case Config#elixir_code_server.erl_compiler_options of
-    nil ->
-      Opts = erl_compiler_options(),
-      {reply, Opts, Config#elixir_code_server{erl_compiler_options=Opts}};
-    Opts ->
-      {reply, Opts, Config}
-  end;
+handle_call(purge_compiler_modules, _From, Config) ->
+  {Used, Unused, Counter} = Config#elixir_code_server.mod_pool,
+  _ = [code:purge(Module) || Module <- Used],
+  ModPool = {[], Used ++ Unused, Counter},
+  {reply, {ok, length(Used)}, Config#elixir_code_server{mod_pool=ModPool}};
 
 handle_call(Request, _From, Config) ->
   {stop, {badcall, Request}, Config}.
 
-handle_cast({at_exit, AtExit}, Config) ->
-  {noreply, Config#elixir_code_server{at_exit=[AtExit|Config#elixir_code_server.at_exit]}};
-
-handle_cast({argv, Argv}, Config) ->
-  {noreply, Config#elixir_code_server{argv=Argv}};
-
-handle_cast({compiler_options, Options}, Config) ->
-  Final = orddict:merge(fun(_,_,V) -> V end, Config#elixir_code_server.compiler_options, Options),
-  {noreply, Config#elixir_code_server{compiler_options=Final}};
-
-handle_cast({register_warning, CompilerPid}, Config) ->
-  CompilationStatusCurrent = Config#elixir_code_server.compilation_status,
-  CompilationStatusNew     = orddict:store(CompilerPid, error, CompilationStatusCurrent),
-  case orddict:find(warnings_as_errors, Config#elixir_code_server.compiler_options) of
-    {ok, true} -> {noreply, Config#elixir_code_server{compilation_status=CompilationStatusNew}};
-    _ -> {noreply, Config}
-  end;
-
-handle_cast({reset_warnings, CompilerPid}, Config) ->
-  CompilationStatusCurrent = Config#elixir_code_server.compilation_status,
-  CompilationStatusNew     = orddict:store(CompilerPid, ok, CompilationStatusCurrent),
-  {noreply, Config#elixir_code_server{compilation_status=CompilationStatusNew}};
-
-handle_cast({loaded, Path}, Config) ->
-  Current = Config#elixir_code_server.loaded,
-  case orddict:find(Path, Current) of
+handle_cast({required, Path}, Config) ->
+  Current = Config#elixir_code_server.required,
+  case maps:find(Path, Current) of
     {ok, true} ->
       {noreply, Config};
-    {ok, {Ref, List}} when is_list(List), is_reference(Ref) ->
-      [Pid ! {elixir_code_server, Ref, loaded} || {Pid, _Tag} <- lists:reverse(List)],
-      Done = orddict:store(Path, true, Current),
-      {noreply, Config#elixir_code_server{loaded=Done}};
+    {ok, Queued} ->
+      _ = [gen_server:reply(From, required) || From <- lists:reverse(Queued)],
+      Done = maps:put(Path, true, Current),
+      {noreply, Config#elixir_code_server{required=Done}};
     error ->
-      Done = orddict:store(Path, true, Current),
-      {noreply, Config#elixir_code_server{loaded=Done}}
+      Done = maps:put(Path, true, Current),
+      {noreply, Config#elixir_code_server{required=Done}}
   end;
 
-handle_cast({unload_files, Files}, Config) ->
-  Current  = Config#elixir_code_server.loaded,
-  Unloaded = lists:foldl(fun(File, Acc) -> orddict:erase(File, Acc) end, Current, Files),
-  {noreply, Config#elixir_code_server{loaded=Unloaded}};
-
-handle_cast({return_module_name, H}, #elixir_code_server{pool={T,Counter}} = Config) ->
-  {noreply, Config#elixir_code_server{pool={[H|T],Counter}}};
+handle_cast({unrequire_files, Files}, Config) ->
+  Current  = Config#elixir_code_server.required,
+  Unrequired = maps:without(Files, Current),
+  {noreply, Config#elixir_code_server{required=Unrequired}};
+
+handle_cast({return_compiler_module, Module}, Config) ->
+  {Used, Unused, Counter} = Config#elixir_code_server.mod_pool,
+  ModPool = {[Module | Used], Unused, Counter},
+  {noreply, Config#elixir_code_server{mod_pool=ModPool}};
+
+handle_cast(purge_compiler_modules, Config) ->
+  {Used, Unused, Counter} = Config#elixir_code_server.mod_pool,
+
+  case Used of
+    [] -> ok;
+    _ ->
+      %% Purging modules became more expensive in Erlang/OTP 27+,
+      %% so we accumulate them all during compilation and then
+      %% purge them asynchronously, especially because they can
+      %% block the code server. Ideally we would purge them in
+      %% batches, but that's not supported at the moment.
+      Opts = [{monitor, [{tag, {purged, Used}}]}],
+      erlang:spawn_opt(fun() ->
+        [code:purge(Module) || Module <- Used],
+        ok
+      end, Opts)
+  end,
+
+  ModPool = {[], Unused, Counter},
+  {noreply, Config#elixir_code_server{mod_pool=ModPool}};
 
 handle_cast(Request, Config) ->
   {stop, {badcast, Request}, Config}.
 
-handle_info(_Request, Config) ->
+handle_info({{purged, Purged}, _Ref, process, _Pid, _Reason}, Config) ->
+  {Used, Unused, Counter} = Config#elixir_code_server.mod_pool,
+  ModPool = {Used, Purged ++ Unused, Counter},
+  {noreply, Config#elixir_code_server{mod_pool=ModPool}};
+
+handle_info({'DOWN', Ref, process, _Pid, _Reason}, Config) ->
+  {noreply, undefmodule(Ref, Config)};
+
+handle_info(_Msg, Config) ->
   {noreply, Config}.
 
 terminate(_Reason, _Config) ->
@@ -143,25 +141,20 @@ terminate(_Reason, _Config) ->
 code_change(_Old, Config, _Extra) ->
   {ok, Config}.
 
-module_tuple(I) ->
-  {list_to_atom("elixir_compiler_" ++ integer_to_list(I)), I}.
-
-erl_compiler_options() ->
-  Key = "ERL_COMPILER_OPTIONS",
-  case os:getenv(Key) of
-    false -> [];
-    Str when is_list(Str) ->
-      case erl_scan:string(Str) of
-        {ok,Tokens,_} ->
-          case erl_parse:parse_term(Tokens ++ [{dot, 1}]) of
-            {ok,List} when is_list(List) -> List;
-            {ok,Term} -> [Term];
-            {error,_Reason} ->
-              io:format("Ignoring bad term in ~ts\n", [Key]),
-              []
-          end;
-        {error, {_,_,_Reason}, _} ->
-          io:format("Ignoring bad term in ~ts\n", [Key]),
-          []
-      end
+compiler_module(I) ->
+  list_to_atom("elixir_compiler_" ++ integer_to_list(I)).
+
+defmodule(Pid, Tuple, #elixir_code_server{mod_ets=ModEts} = Config) ->
+  ets:insert(elixir_modules, Tuple),
+  Ref = erlang:monitor(process, Pid),
+  Mod = erlang:element(1, Tuple),
+  {Ref, Config#elixir_code_server{mod_ets=maps:put(Ref, Mod, ModEts)}}.
+
+undefmodule(Ref, #elixir_code_server{mod_ets=ModEts} = Config) ->
+  case maps:find(Ref, ModEts) of
+    {ok, Mod} ->
+      ets:delete(elixir_modules, Mod),
+      Config#elixir_code_server{mod_ets=maps:remove(Ref, ModEts)};
+    error ->
+      Config
   end.
diff --git a/lib/elixir/src/elixir_compiler.erl b/lib/elixir/src/elixir_compiler.erl
index cd5f52700a2..f2b4add4801 100644
--- a/lib/elixir/src/elixir_compiler.erl
+++ b/lib/elixir/src/elixir_compiler.erl
@@ -1,224 +1,229 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+%% Elixir compiler front-end to the Erlang backend.
 -module(elixir_compiler).
--export([get_opt/1, string/2, quoted/2, file/1, file_to_path/2]).
--export([core/0, module/4, eval_forms/3]).
+-export([string/3, quoted/3, bootstrap/0, file/2, compile/4]).
 -include("elixir.hrl").
 
-%% Public API
-
-get_opt(Key) ->
-  Dict = elixir_code_server:call(compiler_options),
-  case lists:keyfind(Key, 1, Dict) of
-    false -> false;
-    {Key, Value} -> Value
-  end.
+string(Contents, File, Callback) ->
+  Forms = elixir:'string_to_quoted!'(Contents, 1, 1, File, elixir_config:get(parser_options)),
+  quoted(Forms, File, Callback).
 
-%% Compilation entry points.
+quoted(Forms, File, Callback) ->
+  Previous = get(elixir_module_binaries),
 
-string(Contents, File) when is_list(Contents), is_binary(File) ->
-  Forms = elixir:'string_to_quoted!'(Contents, 1, File, []),
-  quoted(Forms, File).
+  try
+    put(elixir_module_binaries, []),
+    Env = (elixir_env:new())#{line := 1, file := File, tracers := elixir_config:get(tracers)},
 
-quoted(Forms, File) when is_binary(File) ->
-  Previous = get(elixir_compiled),
+    elixir_lexical:run(
+      Env,
+      fun (LexicalEnv) -> maybe_fast_compile(Forms, LexicalEnv) end,
+      fun (#{lexical_tracker := Pid}) -> Callback(File, Pid) end
+    ),
 
-  try
-    put(elixir_compiled, []),
-    elixir_lexical:run(File, fun
-      (Pid) ->
-        Env = elixir:env_for_eval([{line,1},{file,File}]),
-        eval_forms(Forms, [], Env#{lexical_tracker := Pid})
-    end),
-    lists:reverse(get(elixir_compiled))
+    lists:reverse(get(elixir_module_binaries))
   after
-    put(elixir_compiled, Previous)
+    put(elixir_module_binaries, Previous)
   end.
 
-file(Relative) when is_binary(Relative) ->
-  File = filename:absname(Relative),
+file(File, Callback) ->
   {ok, Bin} = file:read_file(File),
-  string(elixir_utils:characters_to_list(Bin), File).
+  string(elixir_utils:characters_to_list(Bin), File, Callback).
+
+%% Evaluates the given code through the Erlang compiler.
+%% It may end-up evaluating the code if it is deemed a
+%% more efficient strategy depending on the code snippet.
+maybe_fast_compile(Forms, E) ->
+  case (?key(E, module) == nil) andalso allows_fast_compilation(Forms) andalso
+        (not elixir_config:is_bootstrap()) of
+    true  -> fast_compile(Forms, E);
+    false -> compile(Forms, [], [], E)
+  end,
+  ok.
 
-file_to_path(File, Path) when is_binary(File), is_binary(Path) ->
-  Lists = file(File),
-  [binary_to_path(X, Path) || X <- Lists],
-  Lists.
+compile(Quoted, ArgsList, CompilerOpts, #{line := Line} = E) ->
+  Block = no_tail_optimize([{line, Line}], Quoted),
+  {Expanded, SE, EE} = elixir_expand:expand(Block, elixir_env:env_to_ex(E), E),
+  elixir_env:check_unused_vars(SE, EE),
 
-%% Evaluation
+  {Module, Fun, LabelledLocals} =
+    elixir_erl_compiler:spawn(fun() -> spawned_compile(Expanded, CompilerOpts, E) end),
 
-eval_forms(Forms, Vars, E) ->
-  case (?m(E, module) == nil) andalso allows_fast_compilation(Forms) of
-    true  -> eval_compilation(Forms, Vars, E);
-    false -> code_loading_compilation(Forms, Vars, E)
-  end.
+  Args = list_to_tuple(ArgsList),
+  {dispatch(Module, Fun, Args, LabelledLocals), SE, EE}.
+
+spawned_compile(ExExprs, CompilerOpts, #{line := Line, file := File} = E) ->
+  {Vars, S} = elixir_erl_var:from_env(E),
+  {ErlExprs, _} = elixir_erl_pass:translate(ExExprs, erl_anno:new(Line), S),
+
+  Module = retrieve_compiler_module(),
+  Fun = code_fun(?key(E, module)),
+  Forms = code_mod(Fun, ErlExprs, Line, File, Module, Vars),
+
+  {Module, Binary} = elixir_erl_compiler:noenv_forms(Forms, File, [nowarn_nomatch | CompilerOpts]),
+  code:load_binary(Module, "", Binary),
+  {Module, Fun, is_purgeable(Binary)}.
+
+is_purgeable(<<"FOR1", _Size:32, "BEAM", Rest/binary>>) ->
+  do_is_purgeable(Rest).
+
+do_is_purgeable(<<>>) -> true;
+do_is_purgeable(<<"LocT", 4:32, 0:32, _/binary>>) -> true;
+do_is_purgeable(<<"LocT", _:32, _/binary>>) -> false;
+do_is_purgeable(<<_:4/binary, Size:32, Beam/binary>>) ->
+  <<_:(4 * trunc((Size+3) / 4))/binary, Rest/binary>> = Beam,
+  do_is_purgeable(Rest).
 
-eval_compilation(Forms, Vars, E) ->
-  Binding = [{Key, Value} || {_Name, _Kind, Key, Value} <- Vars],
-  {Result, _Binding, EE, _S} = elixir:eval_forms(Forms, Binding, E),
-  {Result, EE}.
-
-code_loading_compilation(Forms, Vars, #{line := Line} = E) ->
-  Dict = [{{Name, Kind}, {Value, 0}} || {Name, Kind, Value, _} <- Vars],
-  S = elixir_env:env_to_scope_with_vars(E, Dict),
-  {Expr, EE, _S} = elixir:quoted_to_erl(Forms, E, S),
-
-  {Module, I} = retrieve_module_name(),
-  Fun  = code_fun(?m(E, module)),
-  Form = code_mod(Fun, Expr, Line, ?m(E, file), Module, Vars),
-  Args = list_to_tuple([V || {_, _, _, V} <- Vars]),
-
-  %% Pass {native, false} to speed up bootstrap
-  %% process when native is set to true
-  AllOpts   = elixir_code_server:call(erl_compiler_options),
-  FinalOpts = AllOpts -- [native, warn_missing_spec],
-  module(Form, ?m(E, file), FinalOpts, true, fun(_, Binary) ->
-    %% If we have labeled locals, anonymous functions
-    %% were created and therefore we cannot ditch the
-    %% module
-    Purgeable =
-      case beam_lib:chunks(Binary, [labeled_locals]) of
-        {ok, {_, [{labeled_locals, []}]}} -> true;
-        _ -> false
-      end,
-    dispatch_loaded(Module, Fun, Args, Purgeable, I, EE)
-  end).
-
-dispatch_loaded(Module, Fun, Args, Purgeable, I, E) ->
+dispatch(Module, Fun, Args, Purgeable) ->
   Res = Module:Fun(Args),
   code:delete(Module),
-  if Purgeable ->
-      code:purge(Module),
-      return_module_name(I);
-     true ->
-       ok
-  end,
-  {Res, E}.
+  Purgeable andalso return_compiler_module(Module),
+  Res.
 
 code_fun(nil) -> '__FILE__';
 code_fun(_)   -> '__MODULE__'.
 
 code_mod(Fun, Expr, Line, File, Module, Vars) when is_binary(File), is_integer(Line) ->
-  Tuple    = {tuple, Line, [{var, Line, K} || {_, _, K, _} <- Vars]},
+  Ann = erl_anno:new(Line),
+  Tuple = {tuple, Ann, [{var, Ann, Var} || {_, Var} <- Vars]},
   Relative = elixir_utils:relative_to_cwd(File),
 
-  [
-    {attribute, Line, file, {elixir_utils:characters_to_list(Relative), 1}},
-    {attribute, Line, module, Module},
-    {attribute, Line, export, [{Fun, 1}, {'__RELATIVE__', 0}]},
-    {function, Line, Fun, 1, [
-      {clause, Line, [Tuple], [], [Expr]}
-    ]},
-    {function, Line, '__RELATIVE__', 0, [
-      {clause, Line, [], [], [elixir_utils:elixir_to_erl(Relative)]}
-    ]}
-  ].
+  [{attribute, Ann, file, {elixir_utils:characters_to_list(Relative), 1}},
+   {attribute, Ann, module, Module},
+   {attribute, Ann, compile, no_auto_import},
+   {attribute, Ann, export, [{Fun, 1}, {'__RELATIVE__', 0}]},
+   {function, Ann, Fun, 1, [
+     {clause, Ann, [Tuple], [], [Expr]}
+   ]},
+   {function, Ann, '__RELATIVE__', 0, [
+     {clause, Ann, [], [], [elixir_erl:elixir_to_erl(Relative)]}
+   ]}].
 
-retrieve_module_name() ->
-  elixir_code_server:call(retrieve_module_name).
+retrieve_compiler_module() ->
+  elixir_code_server:call(retrieve_compiler_module).
 
-return_module_name(I) ->
-  elixir_code_server:cast({return_module_name, I}).
+return_compiler_module(Module) ->
+  elixir_code_server:cast({return_compiler_module, Module}).
 
 allows_fast_compilation({'__block__', _, Exprs}) ->
   lists:all(fun allows_fast_compilation/1, Exprs);
-allows_fast_compilation({defmodule,_,_}) -> true;
-allows_fast_compilation(_) -> false.
-
-%% INTERNAL API
-
-%% Compile the module by forms based on the scope information
-%% executes the callback in case of success. This automatically
-%% handles errors and warnings. Used by this module and elixir_module.
-module(Forms, File, Opts, Callback) ->
-  Final =
-    case (get_opt(debug_info) == true) orelse
-         lists:member(debug_info, Opts) of
-      true  -> [debug_info] ++ elixir_code_server:call(erl_compiler_options);
-      false -> elixir_code_server:call(erl_compiler_options)
-    end,
-  module(Forms, File, Final, false, Callback).
-
-module(Forms, File, Options, Bootstrap, Callback) when
-    is_binary(File), is_list(Forms), is_list(Options), is_boolean(Bootstrap), is_function(Callback) ->
-  Listname = elixir_utils:characters_to_list(File),
-
-  case compile:noenv_forms([no_auto_import()|Forms], [return,{source,Listname}|Options]) of
-    {ok, ModuleName, Binary, Warnings} ->
-      format_warnings(Bootstrap, Warnings),
-      code:load_binary(ModuleName, Listname, Binary),
-      Callback(ModuleName, Binary);
-    {error, Errors, Warnings} ->
-      format_warnings(Bootstrap, Warnings),
-      format_errors(Errors)
-  end.
-
-no_auto_import() ->
-  {attribute, 0, compile, no_auto_import}.
-
-%% CORE HANDLING
-
-core() ->
-  application:start(elixir),
-  elixir_code_server:cast({compiler_options, [{docs,false},{internal,true}]}),
-  [core_file(File) || File <- core_main()].
+allows_fast_compilation({defmodule, _, [_, [{do, _}]]}) ->
+  true;
+allows_fast_compilation(_) ->
+  false.
+
+fast_compile({'__block__', _, Exprs}, E) ->
+  lists:foldl(fun(Expr, _) -> fast_compile(Expr, E) end, nil, Exprs);
+fast_compile({defmodule, Meta, [Mod, [{do, Block}]]}, NoLineE) ->
+  E = NoLineE#{line := ?line(Meta)},
+
+  Expanded = case Mod of
+    {'__aliases__', AliasMeta, List} ->
+      case elixir_aliases:expand_or_concat(AliasMeta, List, E, true) of
+        Receiver when is_atom(Receiver) -> Receiver;
+        _ -> 'Elixir.Macro':expand(Mod, E)
+      end;
+
+    _ ->
+      'Elixir.Macro':expand(Mod, E)
+  end,
 
-core_file(File) ->
+  ContextModules = [Expanded | ?key(E, context_modules)],
+  elixir_module:compile(Meta, Expanded, Block, [], false, E#{context_modules := ContextModules}).
+
+no_tail_optimize(Meta, Block) ->
+  {'__block__', Meta, [
+    {'=', Meta, [{result, Meta, ?MODULE}, Block]},
+    {{'.', Meta, [elixir_utils, noop]}, Meta, []},
+    {result, Meta, ?MODULE}
+  ]}.
+
+%% Bootstrapper
+
+bootstrap() ->
+  {ok, _} = application:ensure_all_started(elixir),
+  elixir_config:static(#{bootstrap => true}),
+  elixir_config:put(docs, false),
+  elixir_config:put(ignore_module_conflict, true),
+  elixir_config:put(on_undefined_variable, raise),
+  elixir_config:put(parser_options, []),
+  elixir_config:put(relative_paths, false),
+  elixir_config:put(tracers, []),
+  elixir_config:put(infer_signatures, []),
+  {Init, Main} = bootstrap_files(),
+  {ok, Cwd} = file:get_cwd(),
+  Lib = filename:join(Cwd, "lib/elixir/lib"),
+  [bootstrap_file(Lib, File) || File <- [<<"kernel.ex">> | Init]],
+  [bootstrap_file(Lib, File) || File <- [<<"kernel.ex">> | Main]].
+
+bootstrap_file(Lib, Suffix) ->
   try
-    Lists = file(File),
-    [binary_to_path(X, "lib/elixir/ebin") || X <- Lists],
-    io:format("Compiled ~ts~n", [File])
+    File = filename:join(Lib, Suffix),
+    Mods = file(File, fun(_, _) -> ok end),
+    _ = [binary_to_path(X, "lib/elixir/ebin") || X <- Mods],
+    io:format("Compiled ~ts~n", [Suffix])
   catch
-    Kind:Reason ->
-      io:format("~p: ~p~nstacktrace: ~p~n", [Kind, Reason, erlang:get_stacktrace()]),
+    Kind:Reason:Stacktrace ->
+      io:format("~p: ~p~nstacktrace: ~p~n", [Kind, Reason, Stacktrace]),
       erlang:halt(1)
   end.
 
-core_main() ->
-  [<<"lib/elixir/lib/kernel.ex">>,
-   <<"lib/elixir/lib/macro/env.ex">>,
-   <<"lib/elixir/lib/keyword.ex">>,
-   <<"lib/elixir/lib/module.ex">>,
-   <<"lib/elixir/lib/list.ex">>,
-   <<"lib/elixir/lib/macro.ex">>,
-   <<"lib/elixir/lib/code.ex">>,
-   <<"lib/elixir/lib/module/locals_tracker.ex">>,
-   <<"lib/elixir/lib/kernel/typespec.ex">>,
-   <<"lib/elixir/lib/exception.ex">>,
-   <<"lib/elixir/lib/protocol.ex">>,
-   <<"lib/elixir/lib/stream/reducers.ex">>,
-   <<"lib/elixir/lib/enum.ex">>,
-   <<"lib/elixir/lib/inspect/algebra.ex">>,
-   <<"lib/elixir/lib/inspect.ex">>,
-   <<"lib/elixir/lib/range.ex">>,
-   <<"lib/elixir/lib/regex.ex">>,
-   <<"lib/elixir/lib/string.ex">>,
-   <<"lib/elixir/lib/string/chars.ex">>,
-   <<"lib/elixir/lib/io.ex">>,
-   <<"lib/elixir/lib/path.ex">>,
-   <<"lib/elixir/lib/file.ex">>,
-   <<"lib/elixir/lib/system.ex">>,
-   <<"lib/elixir/lib/kernel/cli.ex">>,
-   <<"lib/elixir/lib/kernel/error_handler.ex">>,
-   <<"lib/elixir/lib/kernel/parallel_compiler.ex">>,
-   <<"lib/elixir/lib/kernel/lexical_tracker.ex">>].
+bootstrap_files() ->
+  {
+    [
+     <<"kernel/utils.ex">>,
+     <<"macro/env.ex">>,
+     <<"range.ex">>,
+     <<"keyword.ex">>,
+     <<"module.ex">>,
+     <<"list.ex">>,
+     <<"macro.ex">>,
+     <<"kernel/typespec.ex">>,
+     <<"code.ex">>,
+     <<"code/identifier.ex">>,
+     <<"protocol.ex">>,
+     <<"stream/reducers.ex">>,
+     <<"enum.ex">>,
+     <<"regex.ex">>,
+     <<"inspect/algebra.ex">>,
+     <<"inspect.ex">>,
+     <<"string.ex">>,
+     <<"string/chars.ex">>
+    ],
+    [
+     <<"list/chars.ex">>,
+     <<"bitwise.ex">>,
+     <<"module/parallel_checker.ex">>,
+     <<"module/behaviour.ex">>,
+     <<"module/types/helpers.ex">>,
+     <<"module/types/descr.ex">>,
+     <<"module/types/of.ex">>,
+     <<"module/types/pattern.ex">>,
+     <<"module/types/apply.ex">>,
+     <<"module/types/expr.ex">>,
+     <<"module/types.ex">>,
+     <<"exception.ex">>,
+     <<"path.ex">>,
+     <<"file.ex">>,
+     <<"map.ex">>,
+     <<"access.ex">>,
+     <<"io.ex">>,
+     <<"system.ex">>,
+     <<"code/formatter.ex">>,
+     <<"code/normalizer.ex">>,
+     <<"kernel/cli.ex">>,
+     <<"kernel/error_handler.ex">>,
+     <<"kernel/parallel_compiler.ex">>,
+     <<"kernel/lexical_tracker.ex">>
+    ]
+  }.
 
 binary_to_path({ModuleName, Binary}, CompilePath) ->
   Path = filename:join(CompilePath, atom_to_list(ModuleName) ++ ".beam"),
-  ok = file:write_file(Path, Binary),
-  Path.
-
-%% ERROR HANDLING
-
-format_errors([]) ->
-  exit({nocompile, "compilation failed but no error was raised"});
-
-format_errors(Errors) ->
-  lists:foreach(fun ({File, Each}) ->
-    BinFile = elixir_utils:characters_to_binary(File),
-    lists:foreach(fun (Error) -> elixir_errors:handle_file_error(BinFile, Error) end, Each)
-  end, Errors).
-
-format_warnings(Bootstrap, Warnings) ->
-  lists:foreach(fun ({File, Each}) ->
-    BinFile = elixir_utils:characters_to_binary(File),
-    lists:foreach(fun (Warning) -> elixir_errors:handle_file_warning(Bootstrap, BinFile, Warning) end, Each)
-  end, Warnings).
+  case file:write_file(Path, Binary) of
+    ok -> Path;
+    {error, Reason} -> error('Elixir.File.Error':exception([{action, "write to"}, {path, Path}, {reason, Reason}]))
+  end.
diff --git a/lib/elixir/src/elixir_config.erl b/lib/elixir/src/elixir_config.erl
new file mode 100644
index 00000000000..9b956365d83
--- /dev/null
+++ b/lib/elixir/src/elixir_config.erl
@@ -0,0 +1,92 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+-module(elixir_config).
+-compile({no_auto_import, [get/1]}).
+-export([new/1, warn/2, serial/1]).
+-export([static/1, is_bootstrap/0, identifier_tokenizer/0]).
+-export([delete/1, put/2, get/1, get/2, update/2, get_and_put/2]).
+-export([start_link/0, init/1, handle_call/3, handle_cast/2]).
+-behaviour(gen_server).
+
+%% Persistent term
+
+static(Map) when is_map(Map) ->
+  persistent_term:put(?MODULE, maps:merge(persistent_term:get(?MODULE, #{}), Map)).
+is_bootstrap() ->
+  maps:get(bootstrap, persistent_term:get(?MODULE, #{}), false).
+identifier_tokenizer() ->
+  maps:get(identifier_tokenizer, persistent_term:get(?MODULE, #{}), 'Elixir.String.Tokenizer').
+
+%% Key-value store (concurrent reads, serial writes)
+
+get(Key) ->
+  [{_, Value}] = ets:lookup(?MODULE, Key),
+  Value.
+
+get(Key, Default) ->
+  try ets:lookup(?MODULE, Key) of
+    [{_, Value}] -> Value;
+    [] -> Default
+  catch
+    _:_ -> Default
+  end.
+
+put(Key, Value) ->
+  gen_server:call(?MODULE, {put, Key, Value}, infinity).
+
+get_and_put(Key, Value) ->
+  gen_server:call(?MODULE, {get_and_put, Key, Value}, infinity).
+
+update(Key, Fun) ->
+  gen_server:call(?MODULE, {update, Key, Fun}, infinity).
+
+new(Opts) ->
+  Tab = ets:new(?MODULE, [named_table, public, {read_concurrency, true}]),
+  true = ets:insert_new(?MODULE, Opts),
+  Tab.
+
+delete(?MODULE) ->
+  ets:delete(?MODULE).
+
+%% MISC
+
+serial(Fun) ->
+  gen_server:call(?MODULE, {serial, Fun}, infinity).
+
+%% Used to guarantee warnings are emitted only once per caller.
+warn(Key, [{Mod, Fun, ArgsOrArity, _} | _]) ->
+  EtsKey = {warn, Key, Mod, Fun, to_arity(ArgsOrArity)},
+  ets:update_counter(?MODULE, EtsKey, {2, 1, 1, 1}, {EtsKey, -1}) =:= 0;
+
+warn(_, _) ->
+  true.
+
+to_arity(Args) when is_list(Args) -> length(Args);
+to_arity(Arity) -> Arity.
+
+%% gen_server api
+
+start_link() ->
+  gen_server:start_link({local, ?MODULE}, ?MODULE, ?MODULE, []).
+
+init(?MODULE) ->
+  {ok, []}.
+
+handle_call({serial, Fun}, _From, State) ->
+  {reply, Fun(), State};
+  handle_call({put, Key, Value}, _From, State) ->
+  ets:insert(?MODULE, {Key, Value}),
+  {reply, ok, State};
+handle_call({update, Key, Fun}, _From, State) ->
+  Value = Fun(get(Key)),
+  ets:insert(?MODULE, {Key, Value}),
+  {reply, Value, State};
+handle_call({get_and_put, Key, Value}, _From, State) ->
+  OldValue = get(Key),
+  ets:insert(?MODULE, {Key, Value}),
+  {reply, OldValue, State}.
+
+handle_cast(Cast, Tab) ->
+  {stop, {bad_cast, Cast}, Tab}.
diff --git a/lib/elixir/src/elixir_counter.erl b/lib/elixir/src/elixir_counter.erl
deleted file mode 100644
index 35cfd160338..00000000000
--- a/lib/elixir/src/elixir_counter.erl
+++ /dev/null
@@ -1,38 +0,0 @@
--module(elixir_counter).
--export([start_link/0, init/1, handle_call/3, handle_cast/2,
-  handle_info/2, terminate/2, code_change/3, next/0]).
--behaviour(gen_server).
-
--define(timeout, 1000).     %% 1 second
--define(limit, 4294967296). %% 2^32
-
-next() ->
-  gen_server:call(?MODULE, next, ?timeout).
-
-start_link() ->
-  gen_server:start_link({local, ?MODULE}, ?MODULE, 0, []).
-
-init(Counter) ->
-  {ok, Counter}.
-
-handle_call(next, _From, Counter) ->
-  {reply, Counter, bump(Counter)};
-handle_call(Request, _From, Counter) ->
-  {stop, {badcall, Request}, Counter}.
-
-handle_cast(Request, Counter) ->
-  {stop, {badcast, Request}, Counter}.
-
-handle_info(_Request, Counter) ->
-  {noreply, Counter}.
-
-terminate(_Reason, _Counter) ->
-  ok.
-
-code_change(_Old, Counter, _Extra) ->
-  {ok, Counter}.
-
-bump(Counter) when Counter < ?limit ->
-  Counter + 1;
-bump(_Counter) ->
-  0.
diff --git a/lib/elixir/src/elixir_def.erl b/lib/elixir/src/elixir_def.erl
index e7c134e851a..d4859dcb513 100644
--- a/lib/elixir/src/elixir_def.erl
+++ b/lib/elixir/src/elixir_def.erl
@@ -1,386 +1,505 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 % Holds the logic responsible for function definitions (def(p) and defmacro(p)).
 -module(elixir_def).
--export([table/1, clauses_table/1, setup/1,
-  cleanup/1, reset_last/1, lookup_definition/2,
-  delete_definition/2, store_definition/6, unwrap_definitions/1,
-  store_each/8, format_error/1]).
+-export([setup/1, reset_last/1, local_for/5, external_for/5,
+  take_definition/2, store_definition/3, store_definition/9,
+  fetch_definitions/2, format_error/1]).
 -include("elixir.hrl").
+-define(last_def, {elixir, last_def}).
 
--define(attr, '__def_table').
--define(clauses_attr, '__clauses_table').
-
-%% Table management functions. Called internally.
+setup(DataTables) ->
+  reset_last(DataTables),
+  ok.
 
-table(Module) ->
-  ets:lookup_element(Module, ?attr, 2).
+reset_last({DataSet, _DataBag}) ->
+  ets:insert(DataSet, {?last_def, none});
 
-clauses_table(Module) ->
-  ets:lookup_element(Module, ?clauses_attr, 2).
+reset_last(Module) when is_atom(Module) ->
+  reset_last(elixir_module:data_tables(Module)).
 
-setup(Module) ->
-  ets:insert(Module, {?attr, ets:new(Module, [set, public])}),
-  ets:insert(Module, {?clauses_attr, ets:new(Module, [bag, public])}),
-  reset_last(Module),
-  ok.
+%% Finds the local definition for the current module.
+local_for(Meta, Name, Arity, Kinds, E) ->
+  External = fun({Mod, Fun}, Args) ->
+    invoke_external([{from_macro, true} | Meta], Mod, Fun, Args, E)
+  end,
+  fun_for(Meta, ?key(E, module), Name, Arity, Kinds, {value, External}).
 
-cleanup(Module) ->
-  ets:delete(table(Module)),
-  ets:delete(clauses_table(Module)).
+%% Finds the local definition for an external module.
+external_for(Meta, Module, Name, Arity, Kinds) ->
+  fun_for(Meta, Module, Name, Arity, Kinds, none).
 
-%% Reset the last item. Useful when evaling code.
-reset_last(Module) ->
-  ets:insert(table(Module), {last, []}).
+fun_for(Meta, Module, Name, Arity, Kinds, External) ->
+  Tuple = {Name, Arity},
 
-%% Looks up a definition from the database.
-lookup_definition(Module, Tuple) ->
-  case ets:lookup(table(Module), Tuple) of
-    [Result] ->
-      CTable = clauses_table(Module),
-      {Result, [Clause || {_, Clause} <- ets:lookup(CTable, Tuple)]};
-    _ ->
+  try
+    {Set, Bag} = elixir_module:data_tables(Module),
+    {ets:lookup(Set, {def, Tuple}), ets:lookup(Bag, {clauses, Tuple})}
+  of
+    {[{_, Kind, LocalMeta, _, _, _}], ClausesPairs} ->
+      case (Kinds == all) orelse (lists:member(Kind, Kinds)) of
+        true ->
+          (Kind == defmacrop) andalso track_defmacrop(Module, Tuple),
+          Local = {value, fun(Fun, Args) -> invoke_local(Meta, Module, Fun, Args, External) end},
+          Clauses = [Clause || {_, Clause} <- ClausesPairs],
+          elixir_erl:definition_to_anonymous(Kind, LocalMeta, Clauses, Local, External);
+        false ->
+          false
+      end;
+    {[], _} ->
       false
+  catch
+    _:_ -> false
+  end.
+
+invoke_local(Meta, Module, ErlName, Args, External) ->
+  {Name, Arity} = elixir_utils:erl_fa_to_elixir_fa(ErlName, length(Args)),
+
+  case fun_for(Meta, Module, Name, Arity, all, External) of
+    false ->
+      {current_stacktrace, [_ | T]} = erlang:process_info(self(), current_stacktrace),
+      erlang:raise(error, undef, [{Module, Name, Arity, []} | T]);
+    Fun ->
+      apply(Fun, Args)
   end.
 
-delete_definition(Module, Tuple) ->
-  ets:delete(table(Module), Tuple),
-  ets:delete(clauses_table(Module), Tuple).
+track_defmacrop(Module, FunArity) ->
+  {_, Bag} = elixir_module:data_tables(Module),
+  ets:insert(Bag, {used_private, FunArity}).
 
-% Invoked by the wrap definition with the function abstract tree.
-% Each function is then added to the function table.
+invoke_external(Meta, Mod, Name, Args, E) ->
+  is_map(E) andalso elixir_env:trace({require, Meta, Mod, []}, E),
+  apply(Mod, Name, Args).
 
-store_definition(Line, Kind, CheckClauses, Call, Body, Pos) ->
-  E = (elixir_locals:get_cached_env(Pos))#{line := Line},
-  {NameAndArgs, Guards} = elixir_clauses:extract_guards(Call),
+%% Take a definition out of the table
 
-  {Name, Args} = case NameAndArgs of
-    {N, _, A} when is_atom(N), is_atom(A) -> {N, []};
-    {N, _, A} when is_atom(N), is_list(A) -> {N, A};
-    _ -> elixir_errors:form_error(Line, ?m(E, file), ?MODULE, {invalid_def, Kind, NameAndArgs})
-  end,
+take_definition(Module, {Name, Arity} = Tuple) ->
+  {Set, Bag} = elixir_module:data_tables(Module),
+  case ets:take(Set, {def, Tuple}) of
+    [{{def, Tuple}, _, _, _, _, {Defaults, _, _}} = Result] ->
+      ets:delete_object(Bag, {defs, Tuple}),
+      ets:delete_object(Bag, {{default, Name}, Arity, Defaults}),
+      {Result, [Clause || {_, Clause} <- ets:take(Bag, {clauses, Tuple})]};
+    [] ->
+      false
+  end.
 
-  %% Now that we have verified the call format,
-  %% extract meta information like file and context.
-  {_, Meta, _} = Call,
-  DoCheckClauses = (not lists:keymember(context, 1, Meta)) andalso (CheckClauses),
+%% Fetch all available definitions
 
-  %% Check if there is a file information in the definition.
-  %% If so, we assume this come from another source and we need
-  %% to linify taking into account keep line numbers.
-  {File, Key}  = case lists:keyfind(file, 1, Meta) of
-    {file, Bin} when is_binary(Bin) -> {Bin, keep};
-    _ -> {nil, line}
+fetch_definitions(Module, E) ->
+  {Set, Bag} = elixir_module:data_tables(Module),
+
+  Entries = try
+    lists:sort(ets:lookup_element(Bag, defs, 2))
+  catch
+    error:badarg -> []
   end,
 
-  LinifyArgs   = elixir_quote:linify(Line, Key, Args),
-  LinifyGuards = elixir_quote:linify(Line, Key, Guards),
-  LinifyBody   = elixir_quote:linify(Line, Key, Body),
+  fetch_definition(Entries, E, Module, Set, Bag, [], []).
+
+fetch_definition([Tuple | T], E, Module, Set, Bag, All, Private) ->
+  [{_, Kind, Meta, _, Check, {MaxDefaults, _, Defaults}}] = ets:lookup(Set, {def, Tuple}),
+
+  try ets:lookup_element(Bag, {clauses, Tuple}, 2) of
+    Clauses ->
+      NewAll =
+        [{Tuple, Kind, add_defaults_to_meta(MaxDefaults, Meta), Clauses} | All],
+      NewPrivate =
+        case (Kind == defp) orelse (Kind == defmacrop) of
+          true ->
+            Metas = head_and_definition_meta(Check, Meta, MaxDefaults - Defaults, All),
+            [{Tuple, Kind, Metas, MaxDefaults} | Private];
+          false ->
+            Private
+        end,
+      fetch_definition(T, E, Module, Set, Bag, NewAll, NewPrivate)
+  catch
+    error:badarg ->
+      elixir_errors:module_error(Meta, E, ?MODULE, {function_head, Kind, Tuple}),
+      fetch_definition(T, E, Module, Set, Bag, All, Private)
+  end;
 
-  assert_no_aliases_name(Line, Name, Args, E),
-  store_definition(Line, Kind, DoCheckClauses, Name,
-                   LinifyArgs, LinifyGuards, LinifyBody, File, E).
+fetch_definition([], _E, _Module, _Set, _Bag, All, Private) ->
+  {All, Private}.
 
-store_definition(Line, Kind, CheckClauses, Name, Args, Guards, Body, MetaFile, #{module := Module} = ER) ->
-  Arity = length(Args),
-  Tuple = {Name, Arity},
-  E = ER#{function := Tuple},
-  elixir_locals:record_definition(Tuple, Kind, Module),
+add_defaults_to_meta(0, Meta) -> Meta;
+add_defaults_to_meta(Defaults, Meta) -> [{defaults, Defaults} | Meta].
 
-  Location = retrieve_location(Line, MetaFile, Module),
-  {Function, Defaults, Super} = translate_definition(Kind, Line, Module, Name, Args, Guards, Body, E),
+head_and_definition_meta(none, _Meta, _HeadDefaults, _All) ->
+  false;
+head_and_definition_meta(_, Meta, 0, _All) ->
+  Meta;
+head_and_definition_meta(_, _Meta, _HeadDefaults, [{_, _, HeadMeta, _} | _]) ->
+  HeadMeta.
+
+%% Section for storing definitions
+
+store_definition(Kind, {Call, Body}, Pos) ->
+  E = elixir_module:get_cached_env(Pos),
+  store_definition(Kind, false, Call, Body, E);
+store_definition(Kind, Key, Pos) ->
+  #{module := Module} = E = elixir_module:get_cached_env(Pos),
+  {Call, Body} = elixir_module:read_cache(Module, Key),
+  store_definition(Kind, true, Call, Body, E).
+
+store_definition(Kind, HasNoUnquote, Call, Body, #{line := Line} = E) ->
+  {NameAndArgs, Guards} = elixir_utils:extract_guards(Call),
+
+  {Name, Meta, Args} = case NameAndArgs of
+    {N, M, A} when is_atom(N), is_atom(A) -> {N, M, []};
+    {N, M, A} when is_atom(N), is_list(A) -> {N, M, A};
+    _ -> elixir_errors:file_error([{line, Line}], E, ?MODULE, {invalid_def, Kind, NameAndArgs})
+  end,
 
-  DefaultsLength = length(Defaults),
-  elixir_locals:record_defaults(Tuple, Kind, Module, DefaultsLength),
+  Context = case lists:keyfind(context, 1, Meta) of
+    {context, _} = ContextPair -> [ContextPair];
+    _ -> []
+  end,
 
-  File   = ?m(E, file),
-  Table  = table(Module),
-  CTable = clauses_table(Module),
+  Column = case lists:keyfind(column, 1, Meta) of
+    {column, _} = ColumnPair -> [ColumnPair | Context];
+    _ -> Context
+  end,
 
-  compile_super(Module, Super, E),
-  check_previous_defaults(Table, Line, Name, Arity, Kind, DefaultsLength, E),
+  Generated = case lists:keyfind(generated, 1, Meta) of
+    {generated, true} = GeneratedPair -> [GeneratedPair | Column];
+    _ -> Column
+  end,
 
-  store_each(CheckClauses, Kind, File, Location,
-    Table, CTable, DefaultsLength, Function),
-  [store_each(false, Kind, File, Location, Table, CTable, 0,
-    default_function_for(Kind, Name, Default)) || Default <- Defaults],
+  CheckClauses = if
+    Context /= [] -> none;
+    HasNoUnquote -> all;
+    true -> unused_only
+  end,
 
-  make_struct_available(Kind, Module, Name, Args),
-  {Name, Arity}.
+  %% Check if there is a file information in the definition.
+  %% If so, we assume this come from another source and
+  %% we need to linify taking into account keep line numbers.
+  %%
+  %% Line and File will always point to the caller. __ENV__.line
+  %% will always point to the quoted one and __ENV__.file will
+  %% always point to the one at @file or the quoted one.
+  {Location, LinifyArgs, LinifyGuards, LinifyBody} =
+    case elixir_utils:meta_keep(Meta) of
+      {_, _} = MetaFile ->
+        {MetaFile,
+         elixir_quote:linify(Line, keep, Args),
+         elixir_quote:linify(Line, keep, Guards),
+         elixir_quote:linify(Line, keep, Body)};
+      nil ->
+        {nil, Args, Guards, Body}
+    end,
 
-%% @on_definition
+  Arity = length(Args),
 
-run_on_definition_callbacks(Kind, Line, Module, Name, Args, Guards, Expr, E) ->
-  case elixir_compiler:get_opt(internal) of
-    true ->
-      ok;
-    _ ->
-      Env = elixir_env:linify({Line, E}),
-      Callbacks = 'Elixir.Module':get_attribute(Module, on_definition),
-      [Mod:Fun(Env, Kind, Name, Args, Guards, Expr) || {Mod, Fun} <- Callbacks]
-  end.
+  {File, DefMeta} =
+    case retrieve_location(Location, ?key(E, module)) of
+      {AF, RF, L} ->
+        {AF, [{line, Line}, {file, {RF, L}} | Generated]};
+      nil ->
+        {nil, [{line, Line} | Generated]}
+    end,
 
-make_struct_available(def, Module, '__struct__', []) ->
-  case erlang:get(elixir_compiler_pid) of
-    undefined -> ok;
-    Pid -> Pid ! {struct_available, Module}
-  end;
-make_struct_available(_, _, _, _) ->
-  ok.
+  run_with_location_change(File, E, fun(EL) ->
+    assert_no_aliases_name(DefMeta, Name, Args, EL),
+    assert_valid_name(DefMeta, Kind, Name, Args, EL),
+    store_definition(DefMeta, Kind, CheckClauses, Name, Arity,
+                     LinifyArgs, LinifyGuards, LinifyBody, ?key(E, file), EL)
+  end).
+
+store_definition(Meta, Kind, CheckClauses, Name, Arity, DefaultsArgs, Guards, Body, File, ER) ->
+  Module = ?key(ER, module),
+  Tuple = {Name, Arity},
+  {S, E} = env_for_expansion(Kind, Tuple, ER),
 
-%% Retrieve location from meta file or @file, otherwise nil
+  {Args, Defaults} = unpack_defaults(Kind, Meta, Name, DefaultsArgs, S, E),
+  Clauses = [elixir_clauses:def(Clause, S, E) ||
+             Clause <- def_to_clauses(Kind, Meta, Args, Guards, Body, E)],
 
-retrieve_location(Line, File, Module) ->
-  case get_location_attribute(Module) of
-    nil when not is_binary(File) ->
+  DefaultsLength = length(Defaults),
+  check_previous_defaults(Meta, Module, Name, Arity, Kind, DefaultsLength, E),
+
+  store_definition(CheckClauses, Kind, Meta, Name, Arity, File,
+                   Module, DefaultsLength, Clauses),
+  [store_definition(none, Kind, Meta, Name, length(DefaultArgs), File,
+                    Module, 0, [Default]) || {_, DefaultArgs, _, _} = Default <- Defaults],
+
+  run_on_definition_callbacks(Meta, Kind, Module, Name, DefaultsArgs, Guards, Body, E),
+  Tuple.
+
+env_for_expansion(Kind, Tuple, E) when Kind =:= defmacro; Kind =:= defmacrop ->
+  S = elixir_env:env_to_ex(E),
+  {S#elixir_ex{caller=true}, E#{function := Tuple}};
+env_for_expansion(_Kind, Tuple, E) ->
+  {elixir_env:env_to_ex(E), E#{function := Tuple}}.
+
+retrieve_location(Location, Module) ->
+  {Set, _} = elixir_module:data_tables(Module),
+  case ets:take(Set, file) of
+    [] when is_tuple(Location) ->
+      {File, Line} = Location,
+      {filename:absname(File), elixir_utils:relative_to_cwd(File), Line};
+    [] ->
       nil;
-    nil ->
-      {normalize_location(File), Line};
-    X when is_binary(X) ->
+    [{file, File, _, _}] when is_binary(File) ->
       'Elixir.Module':delete_attribute(Module, file),
-      {normalize_location(X), 0};
-    {X, L} when is_binary(X) andalso is_integer(L) ->
+      {filename:absname(File), elixir_utils:relative_to_cwd(File), 0};
+    [{file, {File, Line}, _, _}] when is_binary(File) andalso is_integer(Line) ->
       'Elixir.Module':delete_attribute(Module, file),
-      {normalize_location(X), L}
+      {filename:absname(File), elixir_utils:relative_to_cwd(File), Line}
   end.
 
-get_location_attribute(Module) ->
-  case elixir_compiler:get_opt(internal) of
-    true  -> nil;
-    false -> 'Elixir.Module':get_attribute(Module, file)
+run_with_location_change(nil, E, Callback) ->
+  Callback(E);
+run_with_location_change(File, #{file := File} = E, Callback) ->
+  Callback(E);
+run_with_location_change(File, E, Callback) ->
+  elixir_lexical:with_file(File, E, Callback).
+
+def_to_clauses(_Kind, Meta, Args, [], nil, E) ->
+  check_args_for_function_head(Meta, Args, E),
+  [];
+def_to_clauses(_Kind, Meta, Args, Guards, [{do, Body}], _E) ->
+  [{Meta, Args, Guards, Body}];
+def_to_clauses(Kind, Meta, Args, Guards, Body, E) ->
+  case is_list(Body) andalso lists:keyfind(do, 1, Body) of
+    {do, _} ->
+      [{Meta, Args, Guards, {'try', [{origin,  Kind} | Meta], [Body]}}];
+    false ->
+      elixir_errors:file_error(Meta, E, elixir_expand, {missing_option, Kind, [do]})
   end.
 
-normalize_location(X) ->
-  elixir_utils:characters_to_list(elixir_utils:relative_to_cwd(X)).
-
-%% Compile super
-
-compile_super(Module, true, #{function := Function}) ->
-  elixir_def_overridable:store(Module, Function, true);
-compile_super(_Module, _, _E) -> ok.
-
-%% Translate the given call and expression given
-%% and then store it in memory.
-
-translate_definition(Kind, Line, Module, Name, Args, Guards, Body, E) when is_integer(Line) ->
-  Arity = length(Args),
-
-  {EArgs, EGuards, EBody, _} = elixir_exp_clauses:def(fun elixir_def_defaults:expand/2,
-                                   Args, Guards, expr_from_body(Line, Body), E),
-
-  Body == nil andalso check_args_for_bodyless_clause(Line, EArgs, E),
-
-  S = elixir_env:env_to_scope(E),
-  {Unpacked, Defaults} = elixir_def_defaults:unpack(Kind, Name, EArgs, S),
-  {Clauses, Super} = translate_clause(Body, Line, Kind, Unpacked, EGuards, EBody, S),
-
-  run_on_definition_callbacks(Kind, Line, Module, Name, EArgs, EGuards, EBody, E),
-  Function = {function, Line, Name, Arity, Clauses},
-  {Function, Defaults, Super}.
+run_on_definition_callbacks(Meta, Kind, Module, Name, Args, Guards, Body, E) ->
+  {_, Bag} = elixir_module:data_tables(Module),
+  Callbacks = ets:lookup_element(Bag, {accumulate, on_definition}, 2),
+  _ = [begin
+    elixir_env:trace({remote_function, Meta, Mod, Fun, 6}, E),
+    Mod:Fun(E, Kind, Name, Args, Guards, Body)
+  end || {Mod, Fun} <- lists:reverse(Callbacks)],
+  ok.
 
-translate_clause(nil, _Line, _Kind, _Args, [], _Body, _S) ->
-  {[], false};
-translate_clause(nil, Line, Kind, _Args, _Guards, _Body, #elixir_scope{file=File}) ->
-  elixir_errors:form_error(Line, File, ?MODULE, {missing_do, Kind});
-translate_clause(_, Line, Kind, Args, Guards, Body, S) ->
-  {TClause, TS} = elixir_clauses:clause(Line,
-    fun elixir_translator:translate_args/2, Args, Body, Guards, true, S),
+store_definition(CheckClauses, Kind, Meta, Name, Arity, File, Module, Defaults, Clauses)
+    when CheckClauses == all; CheckClauses == none; CheckClauses == unused_only ->
+  {Set, Bag} = elixir_module:data_tables(Module),
+  Tuple = {Name, Arity},
+  HasBody = Clauses =/= [],
+  CheckAll = CheckClauses == all,
 
-  FClause = case is_macro(Kind) of
+  if
+    Defaults > 0 ->
+      ets:insert(Bag, {{default, Name}, Arity, Defaults});
     true ->
-      FArgs = {var, Line, '_@CALLER'},
-      MClause = setelement(3, TClause, [FArgs|element(3, TClause)]),
-
-      case TS#elixir_scope.caller of
-        true  ->
-          FBody = {'match', Line,
-            {'var', Line, '__CALLER__'},
-            elixir_utils:erl_call(Line, elixir_env, linify, [{var, Line, '_@CALLER'}])
-          },
-          setelement(5, MClause, [FBody|element(5, TClause)]);
-        false ->
-          MClause
-      end;
-    false ->
-      TClause
+      ok
   end,
 
-  {[FClause], TS#elixir_scope.super}.
-
-expr_from_body(_Line, nil)          -> nil;
-expr_from_body(_Line, [{do, Expr}]) -> Expr;
-expr_from_body(Line, Else)          -> {'try', [{line,Line}], [Else]}.
-
-is_macro(defmacro)  -> true;
-is_macro(defmacrop) -> true;
-is_macro(_)         -> false.
-
-% Unwrap the functions stored in the functions table.
-% It returns a list of all functions to be exported, plus the macros,
-% and the body of all functions.
-unwrap_definitions(Module) ->
-  Table = table(Module),
-  CTable = clauses_table(Module),
-  ets:delete(Table, last),
-  unwrap_definition(ets:tab2list(Table), CTable, [], [], [], [], [], [], []).
-
-unwrap_definition([Fun|T], CTable, All, Exports, Private, Def, Defmacro, Functions, Tail) ->
-  Tuple   = element(1, Fun),
-  Clauses = [Clause || {_, Clause} <- ets:lookup(CTable, Tuple)],
-
-  {NewFun, NewExports, NewPrivate, NewDef, NewDefmacro} =
-    case Clauses of
-      [] -> {false, Exports, Private, Def, Defmacro};
-      _  -> unwrap_definition(element(2, Fun), Tuple, Fun, Exports, Private, Def, Defmacro)
+  {MaxDefaults, FirstMeta} =
+    case ets:lookup(Set, {def, Tuple}) of
+      [{_, StoredKind, StoredMeta, StoredFile, StoredCheck, {StoredDefaults, LastHasBody, LastDefaults}}] ->
+        check_valid_kind(Meta, File, Name, Arity, Kind, StoredKind, StoredFile, StoredMeta),
+        check_valid_defaults(Meta, File, Name, Arity, Kind, Defaults, StoredMeta, StoredDefaults, LastDefaults, HasBody, LastHasBody),
+        (CheckAll and (StoredCheck == all)) andalso
+          check_valid_clause(Meta, File, Name, Arity, Kind, Set, StoredMeta, StoredFile, Clauses),
+
+        {max(Defaults, StoredDefaults), StoredMeta};
+      [] ->
+        ets:insert(Bag, {defs, Tuple}),
+        {Defaults, Meta}
     end,
 
-  {NewFunctions, NewTail} = case NewFun of
-    false ->
-      NewAll = All,
-      {Functions, Tail};
-    _ ->
-      NewAll = [Tuple|All],
-      function_for_stored_definition(NewFun, Clauses, Functions, Tail)
-  end,
-
-  unwrap_definition(T, CTable, NewAll, NewExports, NewPrivate,
-    NewDef, NewDefmacro, NewFunctions, NewTail);
-unwrap_definition([], _CTable, All, Exports, Private, Def, Defmacro, Functions, Tail) ->
-  {All, Exports, Private, ordsets:from_list(Def),
-    ordsets:from_list(Defmacro), lists:reverse(Tail ++ Functions)}.
-
-unwrap_definition(def, Tuple, Fun, Exports, Private, Def, Defmacro) ->
-  {Fun, [Tuple|Exports], Private, [Tuple|Def], Defmacro};
-unwrap_definition(defmacro, {Name, Arity} = Tuple, Fun, Exports, Private, Def, Defmacro) ->
-  Macro = {elixir_utils:macro_name(Name), Arity + 1},
-  {setelement(1, Fun, Macro), [Macro|Exports], Private, Def, [Tuple|Defmacro]};
-unwrap_definition(defp, Tuple, Fun, Exports, Private, Def, Defmacro) ->
-  %% {Name, Arity}, Kind, Line, Check, Defaults
-  Info = {Tuple, defp, element(3, Fun), element(5, Fun), element(7, Fun)},
-  {Fun, Exports, [Info|Private], Def, Defmacro};
-unwrap_definition(defmacrop, Tuple, Fun, Exports, Private, Def, Defmacro) ->
-  %% {Name, Arity}, Kind, Line, Check, Defaults
-  Info  = {Tuple, defmacrop, element(3, Fun), element(5, Fun), element(7, Fun)},
-  {false, Exports, [Info|Private], Def, Defmacro}.
-
-%% Helpers
-
-function_for_stored_definition({{Name,Arity}, _, Line, _, _, nil, _}, Clauses, Functions, Tail) ->
-  {[{function, Line, Name, Arity, Clauses}|Functions], Tail};
-
-function_for_stored_definition({{Name,Arity}, _, Line, _, _, Location, _}, Clauses, Functions, Tail) ->
-  {Functions, [
-    {function, Line, Name, Arity, Clauses},
-    {attribute, Line, file, Location} | Tail
-  ]}.
-
-default_function_for(Kind, Name, {clause, Line, Args, _Guards, _Exprs} = Clause)
-    when Kind == defmacro; Kind == defmacrop ->
-  {function, Line, Name, length(Args) - 1, [Clause]};
-
-default_function_for(_, Name, {clause, Line, Args, _Guards, _Exprs} = Clause) ->
-  {function, Line, Name, length(Args), [Clause]}.
-
-%% Store each definition in the table.
-%% This function also checks and emit warnings in case
-%% the kind, of the visibility of the function changes.
-
-store_each(Check, Kind, File, Location, Table, CTable, Defaults, {function, Line, Name, Arity, Clauses}) ->
-  Tuple = {Name, Arity},
-  case ets:lookup(Table, Tuple) of
-    [{Tuple, StoredKind, StoredLine, StoredFile, StoredCheck, StoredLocation, StoredDefaults}] ->
-      FinalLine = StoredLine,
-      FinalLocation = StoredLocation,
-      FinalDefaults = max(Defaults, StoredDefaults),
-      check_valid_kind(Line, File, Name, Arity, Kind, StoredKind),
-      (Check and StoredCheck) andalso
-        check_valid_clause(Line, File, Name, Arity, Kind, Table, StoredLine, StoredFile),
-      check_valid_defaults(Line, File, Name, Arity, Kind, Defaults, StoredDefaults);
-    [] ->
-      FinalLine = Line,
-      FinalLocation = Location,
-      FinalDefaults = Defaults
-  end,
-  Check andalso ets:insert(Table, {last, {Name, Arity}}),
-  ets:insert(CTable, [{Tuple, Clause} || Clause <- Clauses ]),
-  ets:insert(Table, {Tuple, Kind, FinalLine, File, Check, FinalLocation, FinalDefaults}).
+  CheckAll andalso ets:insert(Set, {?last_def, Tuple}),
+  ets:insert(Bag, [{{clauses, Tuple}, Clause} || Clause <- Clauses]),
+  ets:insert(Set, {{def, Tuple}, Kind, FirstMeta, File, CheckClauses, {MaxDefaults, HasBody, Defaults}}).
+
+%% Handling of defaults
+
+unpack_defaults(Kind, Meta, Name, Args, S, E) ->
+  {Expanded, #elixir_ex{unused={_, VersionOffset}}} = expand_defaults(Args, S, E#{context := nil}, []),
+  unpack_expanded(Kind, Meta, Name, Expanded, VersionOffset, [], []).
+
+unpack_expanded(Kind, Meta, Name, [{'\\\\', DefaultMeta, [Expr, _]} | T] = List, VersionOffset, Acc, Clauses) ->
+  Base = match_defaults(Acc, length(Acc) + VersionOffset, []),
+  {Args, Invoke} = extract_defaults(List, length(Base) + VersionOffset, [], []),
+  Clause = {Meta, Base ++ Args, [], {super, [{super, {Kind, Name}}, {default, true} | DefaultMeta], Base ++ Invoke}},
+  unpack_expanded(Kind, Meta, Name, T, VersionOffset, [Expr | Acc], [Clause | Clauses]);
+unpack_expanded(Kind, Meta, Name, [H | T], VersionOffset, Acc, Clauses) ->
+  unpack_expanded(Kind, Meta, Name, T, VersionOffset, [H | Acc], Clauses);
+unpack_expanded(_Kind, _Meta, _Name, [], _VersionOffset, Acc, Clauses) ->
+  {lists:reverse(Acc), lists:reverse(Clauses)}.
+
+expand_defaults([{'\\\\', Meta, [Expr, Default]} | Args], S, E, Acc) ->
+  {ExpandedDefault, SE, _} = elixir_expand:expand(Default, S, E),
+  expand_defaults(Args, SE, E, [{'\\\\', Meta, [Expr, ExpandedDefault]} | Acc]);
+expand_defaults([Arg | Args], S, E, Acc) ->
+   expand_defaults(Args, S, E, [Arg | Acc]);
+expand_defaults([], S, _E, Acc) ->
+  {lists:reverse(Acc), S}.
+
+extract_defaults([{'\\\\', _, [_Expr, Default]} | T], Counter, NewArgs, NewInvoke) ->
+  extract_defaults(T, Counter, NewArgs, [Default | NewInvoke]);
+extract_defaults([_ | T], Counter, NewArgs, NewInvoke) ->
+  H = default_var(Counter),
+  extract_defaults(T, Counter + 1, [H | NewArgs], [H | NewInvoke]);
+extract_defaults([], _Counter, NewArgs, NewInvoke) ->
+  {lists:reverse(NewArgs), lists:reverse(NewInvoke)}.
+
+match_defaults([], _Counter, Acc) ->
+  Acc;
+match_defaults([_ | T], Counter, Acc) ->
+  NewCounter = Counter - 1,
+  match_defaults(T, NewCounter, [default_var(NewCounter) | Acc]).
+
+default_var(Counter) ->
+  {list_to_atom([$x | integer_to_list(Counter)]), [{generated, true}, {version, Counter}], ?var_context}.
 
 %% Validations
 
-check_valid_kind(_Line, _File, _Name, _Arity, Kind, Kind) -> [];
-check_valid_kind(Line, File, Name, Arity, Kind, StoredKind) ->
-  elixir_errors:form_error(Line, File, ?MODULE,
-    {changed_kind, {Name, Arity, StoredKind, Kind}}).
+check_valid_kind(_Meta, _File, _Name, _Arity, Kind, Kind, _StoredFile, _StoredMeta) -> ok;
+check_valid_kind(Meta, File, Name, Arity, Kind, StoredKind, StoredFile, StoredMeta) ->
+  elixir_errors:file_error(Meta, File, ?MODULE,
+    {changed_kind, {Name, Arity, StoredKind, Kind, StoredFile, ?line(StoredMeta)}}).
 
-check_valid_clause(Line, File, Name, Arity, Kind, Table, StoredLine, StoredFile) ->
-  case ets:lookup_element(Table, last, 2) of
-    {Name,Arity} -> [];
-    [] -> [];
+check_valid_clause(Meta, File, Name, Arity, Kind, Set, StoredMeta, StoredFile, Clauses) ->
+  case ets:lookup_element(Set, ?last_def, 2) of
+    none ->
+      ok;
+    {Name, Arity} when Clauses == [] ->
+      elixir_errors:file_warn(Meta, File, ?MODULE,
+        {late_function_head, {Kind, Name, Arity}});
+    {Name, Arity} ->
+      ok;
+    {Name, _} ->
+      Relative = elixir_utils:relative_to_cwd(StoredFile),
+      elixir_errors:file_warn(Meta, File, ?MODULE,
+        {ungrouped_name, {Kind, Name, Arity, ?line(StoredMeta), Relative}});
     _ ->
       Relative = elixir_utils:relative_to_cwd(StoredFile),
-      elixir_errors:handle_file_warning(File, {Line, ?MODULE,
-        {ungrouped_clause, {Kind, Name, Arity, StoredLine, Relative}}})
+      elixir_errors:file_warn(Meta, File, ?MODULE,
+        {ungrouped_arity, {Kind, Name, Arity, ?line(StoredMeta), Relative}})
   end.
 
-check_valid_defaults(_Line, _File, _Name, _Arity, _Kind, 0, _) -> [];
-check_valid_defaults(Line, File, Name, Arity, Kind, _, 0) ->
-  elixir_errors:handle_file_warning(File, {Line, ?MODULE, {out_of_order_defaults, {Kind, Name, Arity}}});
-check_valid_defaults(Line, File, Name, Arity, Kind, _, _) ->
-  elixir_errors:form_error(Line, File, ?MODULE, {clauses_with_defaults, {Kind, Name, Arity}}).
+% Clause with defaults after clause with defaults
+check_valid_defaults(Meta, File, Name, Arity, Kind, Defaults, StoredMeta, StoredDefaults, _, _, _)
+    when Defaults > 0, StoredDefaults > 0 ->
+  elixir_errors:file_error(Meta, File, ?MODULE, {duplicate_defaults, {Kind, Name, Arity, StoredMeta}});
+% Clause with defaults after clause without defaults
+check_valid_defaults(Meta, File, Name, Arity, Kind, Defaults, StoredMeta, 0, _, _, _) when Defaults > 0 ->
+  elixir_errors:file_warn(Meta, File, ?MODULE, {mixed_defaults, {Kind, Name, Arity, StoredMeta}});
+% Clause without defaults directly after clause with defaults (bodiless does not count)
+check_valid_defaults(Meta, File, Name, Arity, Kind, 0, StoredMeta, _, LastDefaults, true, true) when LastDefaults > 0 ->
+  elixir_errors:file_warn(Meta, File, ?MODULE, {mixed_defaults, {Kind, Name, Arity, StoredMeta}});
+% Clause without defaults
+check_valid_defaults(_Meta, _File, _Name, _Arity, _Kind, 0, _StoredMeta, _StoredDefaults, _LastDefaults, _HasBody, _LastHasBody) ->
+  ok.
+
+check_args_for_function_head(Meta, Args, E) ->
+  [begin
+     elixir_errors:module_error(Meta, E, ?MODULE, invalid_args_for_function_head)
+   end || Arg <- Args, invalid_arg(Arg)].
+
+invalid_arg({Name, _, Kind}) when is_atom(Name), is_atom(Kind) -> false;
+invalid_arg(_) -> true.
 
-check_previous_defaults(Table, Line, Name, Arity, Kind, Defaults, E) ->
-  Matches = ets:match(Table, {{Name, '$2'}, '$1', '_', '_', '_', '_', '$3'}),
-  [ begin
-      elixir_errors:form_error(Line, ?m(E, file), ?MODULE,
-        {defs_with_defaults, Name, {Kind, Arity}, {K, A}})
-    end || [K, A, D] <- Matches, A /= Arity, D /= 0, defaults_conflict(A, D, Arity, Defaults)].
+check_previous_defaults(Meta, Module, Name, Arity, Kind, Defaults, E) ->
+  {_Set, Bag} = elixir_module:data_tables(Module),
+  Matches = ets:lookup(Bag, {default, Name}),
+  [begin
+     elixir_errors:file_error(Meta, E, ?MODULE,
+       {defs_with_defaults, Kind, Name, Arity, A})
+   end || {_, A, D} <- Matches, A /= Arity, D /= 0, defaults_conflict(A, D, Arity, Defaults)].
 
 defaults_conflict(A, D, Arity, Defaults) ->
   ((Arity >= (A - D)) andalso (Arity < A)) orelse
     ((A >= (Arity - Defaults)) andalso (A < Arity)).
 
-check_args_for_bodyless_clause(Line, Args, E) ->
-  [ begin
-      elixir_errors:form_error(Line, ?m(E, file), ?MODULE, invalid_args_for_bodyless_clause)
-    end || Arg <- Args, invalid_arg(Arg) ].
-
-invalid_arg({Name, _, Kind}) when is_atom(Name), is_atom(Kind) ->
-  false;
-invalid_arg({'\\\\', _, [{Name, _, Kind}, _]}) when is_atom(Name), is_atom(Kind) ->
-  false;
-invalid_arg(_) ->
-  true.
-
-assert_no_aliases_name(Line, '__aliases__', [Atom], #{file := File}) when is_atom(Atom) ->
-  elixir_errors:form_error(Line, File, ?MODULE, {no_alias, Atom});
-
+assert_no_aliases_name(Meta, '__aliases__', [Atom], #{file := File}) when is_atom(Atom) ->
+  elixir_errors:file_error(Meta, File, ?MODULE, {no_alias, Atom});
 assert_no_aliases_name(_Meta, _Aliases, _Args, _S) ->
   ok.
 
-%% Format errors
-
-format_error({no_module,{Kind,Name,Arity}}) ->
-  io_lib:format("cannot define function outside module, invalid scope for ~ts ~ts/~B", [Kind, Name, Arity]);
-
-format_error({defs_with_defaults, Name, {Kind, Arity}, {K, A}}) when Arity > A ->
-  io_lib:format("~ts ~ts/~B defaults conflicts with ~ts ~ts/~B",
-    [Kind, Name, Arity, K, Name, A]);
-
-format_error({defs_with_defaults, Name, {Kind, Arity}, {K, A}}) when Arity < A ->
-  io_lib:format("~ts ~ts/~B conflicts with defaults from ~ts ~ts/~B",
-    [Kind, Name, Arity, K, Name, A]);
+assert_valid_name(Meta, Kind, '__info__', [_], #{file := File}) ->
+  elixir_errors:file_error(Meta, File, ?MODULE, {'__info__', Kind});
+assert_valid_name(Meta, Kind, 'module_info', [], #{file := File}) ->
+  elixir_errors:file_error(Meta, File, ?MODULE, {module_info, Kind, 0});
+assert_valid_name(Meta, Kind, 'module_info', [_], #{file := File}) ->
+  elixir_errors:file_error(Meta, File, ?MODULE, {module_info, Kind, 1});
+assert_valid_name(Meta, Kind, is_record, [_, _], #{file := File}) when Kind == defp; Kind == def ->
+  elixir_errors:file_error(Meta, File, ?MODULE, {is_record, Kind});
+assert_valid_name(_Meta, _Kind, _Name, _Args, _S) ->
+  ok.
 
-format_error({clauses_with_defaults,{Kind,Name,Arity}}) ->
-  io_lib:format("~ts ~ts/~B has default values and multiple clauses, "
-    "define a function head with the defaults", [Kind, Name, Arity]);
+%% Format errors
 
-format_error({out_of_order_defaults,{Kind,Name,Arity}}) ->
-  io_lib:format("clause with defaults should be the first clause in ~ts ~ts/~B", [Kind, Name, Arity]);
+format_error({function_head, Kind, {Name, Arity}}) ->
+  io_lib:format("implementation not provided for predefined ~ts ~ts/~B", [Kind, Name, Arity]);
 
-format_error({ungrouped_clause,{Kind,Name,Arity,OrigLine,OrigFile}}) ->
-  io_lib:format("clauses for the same ~ts should be grouped together, ~ts ~ts/~B was previously defined (~ts:~B)",
-    [Kind, Kind, Name, Arity, OrigFile, OrigLine]);
+format_error({no_module, {Kind, Name, Arity}}) ->
+  io_lib:format("cannot define function outside module, invalid scope for ~ts ~ts/~B", [Kind, Name, Arity]);
 
-format_error({changed_kind,{Name,Arity,Previous,Current}}) ->
-  io_lib:format("~ts ~ts/~B already defined as ~ts", [Current, Name, Arity, Previous]);
+format_error({defs_with_defaults, Kind, Name, Arity, A}) when Arity > A ->
+  io_lib:format("~ts ~ts/~B defaults conflicts with ~ts/~B",
+    [Kind, Name, Arity, Name, A]);
+
+format_error({defs_with_defaults, Kind, Name, Arity, A}) when Arity < A ->
+  io_lib:format("~ts ~ts/~B conflicts with defaults from ~ts/~B",
+    [Kind, Name, Arity, Name, A]);
+
+format_error({duplicate_defaults, {Kind, Name, Arity, StoredMeta}}) ->
+  io_lib:format(
+    "~ts ~ts/~B defines defaults multiple times. "
+    "Elixir allows defaults to be declared once per definition. Instead of:\n"
+    "\n"
+    "    def foo(:first_clause, b \\\\ :default) do ... end\n"
+    "    def foo(:second_clause, b \\\\ :default) do ... end\n"
+    "\n"
+    "one should write:\n"
+    "\n"
+    "    def foo(a, b \\\\ :default)\n"
+    "    def foo(:first_clause, b) do ... end\n"
+    "    def foo(:second_clause, b) do ... end\n"
+    "~ts",
+    [Kind, Name, Arity, maybe_stored_meta_line(StoredMeta)]);
+
+format_error({mixed_defaults, {Kind, Name, Arity, StoredMeta}}) ->
+  io_lib:format(
+    "~ts ~ts/~B has multiple clauses and also declares default values. "
+    "In such cases, the default values should be defined in a header. Instead of:\n"
+    "\n"
+    "    def foo(:first_clause, b \\\\ :default) do ... end\n"
+    "    def foo(:second_clause, b) do ... end\n"
+    "\n"
+    "one should write:\n"
+    "\n"
+    "    def foo(a, b \\\\ :default)\n"
+    "    def foo(:first_clause, b) do ... end\n"
+    "    def foo(:second_clause, b) do ... end\n"
+    "~ts",
+    [Kind, Name, Arity, maybe_stored_meta_line(StoredMeta)]);
+
+format_error({ungrouped_name, {Kind, Name, Arity, OrigLine, OrigFile}}) ->
+   io_lib:format("clauses with the same name should be grouped together, \"~ts ~ts/~B\" was previously defined (~ts:~B)",
+     [Kind, Name, Arity, OrigFile, OrigLine]);
+
+format_error({ungrouped_arity, {Kind, Name, Arity, OrigLine, OrigFile}}) ->
+  io_lib:format("clauses with the same name and arity (number of arguments) should be grouped together, \"~ts ~ts/~B\" was previously defined (~ts:~B)",
+    [Kind, Name, Arity, OrigFile, OrigLine]);
+
+format_error({late_function_head, {Kind, Name, Arity}}) ->
+  io_lib:format("function head for ~ts ~ts/~B must come at the top of its direct implementation. Instead of:\n"
+    "\n"
+    "    def add(a, b), do: a + b\n"
+    "    def add(a, b)\n"
+    "\n"
+    "one should write:\n"
+    "\n"
+    "    def add(a, b)\n"
+    "    def add(a, b), do: a + b\n",
+    [Kind, Name, Arity]);
+
+format_error({changed_kind, {Name, Arity, Previous, Current, OrigFile, OrigLine}}) ->
+  OrigFileRelative = elixir_utils:relative_to_cwd(OrigFile),
+  io_lib:format("~ts ~ts/~B already defined as ~ts in ~ts:~B", [Current, Name, Arity, Previous, OrigFileRelative, OrigLine]);
 
 format_error({no_alias, Atom}) ->
   io_lib:format("function names should start with lowercase characters or underscore, invalid name ~ts", [Atom]);
@@ -388,8 +507,30 @@ format_error({no_alias, Atom}) ->
 format_error({invalid_def, Kind, NameAndArgs}) ->
   io_lib:format("invalid syntax in ~ts ~ts", [Kind, 'Elixir.Macro':to_string(NameAndArgs)]);
 
-format_error(invalid_args_for_bodyless_clause) ->
-  "can use only variables and \\\\ as arguments of bodyless clause";
-
-format_error({missing_do, Kind}) ->
-  io_lib:format("missing do keyword in ~ts", [Kind]).
+format_error(invalid_args_for_function_head) ->
+  "patterns are not allowed in function head, only variables and default arguments (using \\\\)\n"
+  "\n"
+  "If you did not intend to define a function head, make sure your function "
+  "definition has the proper syntax by wrapping the arguments in parentheses "
+  "and using the do instruction accordingly:\n\n"
+  "    def add(a, b), do: a + b\n\n"
+  "    def add(a, b) do\n"
+  "      a + b\n"
+  "    end\n";
+
+format_error({'__info__', Kind}) ->
+  io_lib:format("cannot define ~ts __info__/1 as it is automatically defined by Elixir", [Kind]);
+
+format_error({module_info, Kind, Arity}) ->
+  io_lib:format("cannot define ~ts module_info/~B as it is automatically defined by Erlang", [Kind, Arity]);
+
+format_error({is_record, Kind}) ->
+  io_lib:format("cannot define ~ts is_record/2 due to compatibility "
+                "with the Erlang compiler (it is a known limitation)", [Kind]).
+
+maybe_stored_meta_line(StoredMeta) ->
+  case lists:keyfind(line, 1, StoredMeta) of
+    {line, Line} when Line > 0 ->
+      "\nthe previous clause is defined on line " ++ integer_to_list(Line) ++ "\n";
+    _ -> ""
+  end.
diff --git a/lib/elixir/src/elixir_def_defaults.erl b/lib/elixir/src/elixir_def_defaults.erl
deleted file mode 100644
index 0b0a2683c55..00000000000
--- a/lib/elixir/src/elixir_def_defaults.erl
+++ /dev/null
@@ -1,73 +0,0 @@
-% Handle default clauses for function definitions.
--module(elixir_def_defaults).
--export([expand/2, unpack/4]).
--include("elixir.hrl").
-
-expand(Args, E) ->
-  lists:mapfoldl(fun
-    ({'\\\\', Meta, [Left, Right]}, Acc) ->
-      {ELeft, EL} = elixir_exp:expand(Left, Acc),
-      {ERight, _} = elixir_exp:expand(Right, Acc#{context := nil}),
-      {{'\\\\', Meta, [ELeft, ERight]}, EL};
-    (Left, Acc) ->
-      elixir_exp:expand(Left, Acc)
-  end, E, Args).
-
-unpack(Kind, Name, Args, S) ->
-  unpack_each(Kind, Name, Args, [], [], S).
-
-%% Helpers
-
-%% Unpack default from given args.
-%% Returns the given arguments without their default
-%% clauses and a list of clauses for the default calls.
-unpack_each(Kind, Name, [{'\\\\', DefMeta, [Expr, _]}|T] = List, Acc, Clauses, S) ->
-  Base = wrap_kind(Kind, build_match(Acc, [])),
-  {Args, Invoke} = extract_defaults(List, length(Base), [], []),
-
-  {DefArgs, SA}  = elixir_clauses:match(fun elixir_translator:translate_args/2, Base ++ Args, S),
-  {DefInvoke, _} = elixir_translator:translate_args(Base ++ Invoke, SA),
-
-  Line = ?line(DefMeta),
-
-  Call = {call, Line,
-    {atom, Line, name_for_kind(Kind, Name)},
-    DefInvoke
-  },
-
-  Clause = {clause, Line, DefArgs, [], [Call]},
-  unpack_each(Kind, Name, T, [Expr|Acc], [Clause|Clauses], S);
-
-unpack_each(Kind, Name, [H|T], Acc, Clauses, S) ->
-  unpack_each(Kind, Name, T, [H|Acc], Clauses, S);
-
-unpack_each(_Kind, _Name, [], Acc, Clauses, _S) ->
-  {lists:reverse(Acc), lists:reverse(Clauses)}.
-
-% Extract default values from args following the current default clause.
-
-extract_defaults([{'\\\\', _, [_Expr, Default]}|T], Counter, NewArgs, NewInvoke) ->
-  extract_defaults(T, Counter, NewArgs, [Default|NewInvoke]);
-
-extract_defaults([_|T], Counter, NewArgs, NewInvoke) ->
-  H = {elixir_utils:atom_concat(["x", Counter]), [], nil},
-  extract_defaults(T, Counter + 1, [H|NewArgs], [H|NewInvoke]);
-
-extract_defaults([], _Counter, NewArgs, NewInvoke) ->
-  {lists:reverse(NewArgs), lists:reverse(NewInvoke)}.
-
-% Build matches for all the previous argument until the current default clause.
-
-build_match([], Acc) -> Acc;
-
-build_match([_|T], Acc) ->
-  Var = {elixir_utils:atom_concat(["x", length(T)]), [], nil},
-  build_match(T, [Var|Acc]).
-
-% Given the invoked function name based on the kind
-
-wrap_kind(Kind, Args) when Kind == defmacro; Kind == defmacrop -> [{c, [], nil}|Args];
-wrap_kind(_Kind, Args) -> Args.
-
-name_for_kind(Kind, Name) when Kind == defmacro; Kind == defmacrop -> elixir_utils:macro_name(Name);
-name_for_kind(_Kind, Name) -> Name.
\ No newline at end of file
diff --git a/lib/elixir/src/elixir_def_overridable.erl b/lib/elixir/src/elixir_def_overridable.erl
deleted file mode 100644
index f0cf2b1a7a6..00000000000
--- a/lib/elixir/src/elixir_def_overridable.erl
+++ /dev/null
@@ -1,75 +0,0 @@
-% Holds the logic responsible for defining overridable functions and handling super.
--module(elixir_def_overridable).
--export([store_pending/1, ensure_defined/4,
-  name/2, store/3, format_error/1]).
--include("elixir.hrl").
-
-overridable(Module) ->
-  ets:lookup_element(elixir_module:data_table(Module), '__overridable', 2).
-
-overridable(Module, Value) ->
-  ets:insert(elixir_module:data_table(Module), {'__overridable', Value}).
-
-%% Check if an overridable function is defined.
-
-ensure_defined(Meta, Module, Tuple, S) ->
-  Overridable = overridable(Module),
-  case orddict:find(Tuple, Overridable) of
-    {ok, {_, _, _, _}} -> ok;
-    _ -> elixir_errors:form_error(Meta, S#elixir_scope.file, ?MODULE, {no_super, Module, Tuple})
-  end.
-
-%% Gets the name based on the function and stored overridables
-
-name(Module, Function) ->
-  name(Module, Function, overridable(Module)).
-
-name(_Module, {Name, _} = Function, Overridable) ->
-  {Count, _, _, _} = orddict:fetch(Function, Overridable),
-  elixir_utils:atom_concat([Name, " (overridable ", Count, ")"]).
-
-%% Store
-
-store(Module, Function, GenerateName) ->
-  Overridable = overridable(Module),
-  case orddict:fetch(Function, Overridable) of
-    {_Count, _Clause, _Neighbours, true} -> ok;
-    {Count, Clause, Neighbours, false} ->
-      overridable(Module, orddict:store(Function, {Count, Clause, Neighbours, true}, Overridable)),
-      {{{Name, Arity}, Kind, Line, File, _Check, Location, Defaults}, Clauses} = Clause,
-
-      {FinalKind, FinalName} = case GenerateName of
-        true  -> {defp, name(Module, Function, Overridable)};
-        false -> {Kind, Name}
-      end,
-
-      case code:is_loaded('Elixir.Module.LocalsTracker') of
-        {_, _} ->
-          'Elixir.Module.LocalsTracker':reattach(Module, Kind, {Name, Arity}, Neighbours);
-        _ ->
-          ok
-      end,
-
-      Def = {function, Line, FinalName, Arity, Clauses},
-      elixir_def:store_each(false, FinalKind, File, Location,
-        elixir_def:table(Module), elixir_def:clauses_table(Module), Defaults, Def)
-  end.
-
-%% Store pending declarations that were not manually made concrete.
-
-store_pending(Module) ->
-  [store(Module, X, false) || {X, {_, _, _, false}} <- overridable(Module),
-    not 'Elixir.Module':'defines?'(Module, X)].
-
-%% Error handling
-
-format_error({no_super, Module, {Name, Arity}}) ->
-  Bins   = [format_fa(X) || {X, {_, _, _, _}} <- overridable(Module)],
-  Joined = 'Elixir.Enum':join(Bins, <<", ">>),
-  io_lib:format("no super defined for ~ts/~B in module ~ts. Overridable functions available are: ~ts",
-    [Name, Arity, elixir_aliases:inspect(Module), Joined]).
-
-format_fa({Name, Arity}) ->
-  A = atom_to_binary(Name, utf8),
-  B = integer_to_binary(Arity),
-  << A/binary, $/, B/binary >>.
\ No newline at end of file
diff --git a/lib/elixir/src/elixir_dispatch.erl b/lib/elixir/src/elixir_dispatch.erl
index e4cbac4610f..436396857b5 100644
--- a/lib/elixir/src/elixir_dispatch.erl
+++ b/lib/elixir/src/elixir_dispatch.erl
@@ -1,327 +1,406 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 %% Helpers related to dispatching to imports and references.
 %% This module access the information stored on the scope
 %% by elixir_import and therefore assumes it is normalized (ordsets)
 -module(elixir_dispatch).
--export([dispatch_import/5, dispatch_require/6,
+-export([dispatch_import/6, dispatch_require/7,
   require_function/5, import_function/4,
-  expand_import/5, expand_require/5,
+  expand_import/7, expand_require/6, check_deprecated/6,
   default_functions/0, default_macros/0, default_requires/0,
-  find_import/4, format_error/1]).
+  find_import/4, find_imports/3, format_error/1, stop_generated/1]).
 -include("elixir.hrl").
 -import(ordsets, [is_element/2]).
-
--define(atom, 'Elixir.Atom').
--define(float, 'Elixir.Float').
--define(io, 'Elixir.IO').
--define(integer, 'Elixir.Integer').
 -define(kernel, 'Elixir.Kernel').
--define(list, 'Elixir.List').
--define(map, 'Elixir.Map').
--define(node, 'Elixir.Node').
--define(process, 'Elixir.Process').
--define(string, 'Elixir.String').
--define(system, 'Elixir.System').
--define(tuple, 'Elixir.Tuple').
+-define(application, 'Elixir.Application').
 
 default_functions() ->
   [{?kernel, elixir_imported_functions()}].
 default_macros() ->
   [{?kernel, elixir_imported_macros()}].
 default_requires() ->
-  ['Elixir.Kernel', 'Elixir.Kernel.Typespec'].
+  ['Elixir.Application', 'Elixir.Kernel'].
 
+%% This is used by elixir_quote. Note we don't record the
+%% import locally because at that point there is no
+%% ambiguity.
 find_import(Meta, Name, Arity, E) ->
   Tuple = {Name, Arity},
 
-  case find_dispatch(Meta, Tuple, [], E) of
+  case find_import_by_name_arity(Meta, Tuple, [], E) of
     {function, Receiver} ->
-      elixir_lexical:record_import(Receiver, ?m(E, lexical_tracker)),
-      elixir_locals:record_import(Tuple, Receiver, ?m(E, module), ?m(E, function)),
+      elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),
       Receiver;
     {macro, Receiver} ->
-      elixir_lexical:record_import(Receiver, ?m(E, lexical_tracker)),
-      elixir_locals:record_import(Tuple, Receiver, ?m(E, module), ?m(E, function)),
+      elixir_env:trace({imported_macro, Meta, Receiver, Name, Arity}, E),
       Receiver;
+    {ambiguous, _} = Ambiguous ->
+      elixir_errors:file_error(Meta, E, ?MODULE, {import, Ambiguous, Name, Arity});
     _ ->
       false
   end.
 
+find_imports(Meta, Name, E) ->
+  Funs = ?key(E, functions),
+  Macs = ?key(E, macros),
+
+  Acc0 = #{},
+  Acc1 = find_imports_by_name(Funs, Acc0, Name, Meta, E),
+  Acc2 = find_imports_by_name(Macs, Acc1, Name, Meta, E),
+
+  lists:sort(maps:to_list(Acc2)).
+
 %% Function retrieval
 
 import_function(Meta, Name, Arity, E) ->
   Tuple = {Name, Arity},
-  case find_dispatch(Meta, Tuple, [], E) of
+  case find_import_by_name_arity(Meta, Tuple, [], E) of
     {function, Receiver} ->
-      elixir_lexical:record_import(Receiver, ?m(E, lexical_tracker)),
-      elixir_locals:record_import(Tuple, Receiver, ?m(E, module), ?m(E, function)),
+      elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),
+      elixir_import:record(Tuple, Receiver, ?key(E, module), ?key(E, function)),
       remote_function(Meta, Receiver, Name, Arity, E);
     {macro, _Receiver} ->
       false;
     {import, Receiver} ->
       require_function(Meta, Receiver, Name, Arity, E);
+    {ambiguous, _} = Ambiguous ->
+      elixir_errors:file_error(Meta, E, ?MODULE, {import, Ambiguous, Name, Arity});
     false ->
       case elixir_import:special_form(Name, Arity) of
-        true  -> false;
+        true ->
+          false;
         false ->
-          elixir_locals:record_local(Tuple, ?m(E, module), ?m(E, function)),
-          {local, Name, Arity}
+          Function = ?key(E, function),
+
+          case (Function /= nil) andalso (Function /= Tuple) andalso
+                elixir_def:local_for(Meta, Name, Arity, [defmacro, defmacrop], E) of
+            false ->
+              elixir_env:trace({local_function, Meta, Name, Arity}, E),
+              {local, Name, Arity};
+            _ ->
+              false
+          end
       end
   end.
 
 require_function(Meta, Receiver, Name, Arity, E) ->
-  case is_element({Name, Arity}, get_optional_macros(Receiver)) of
+  Required = is_element(Receiver, ?key(E, requires)),
+
+  case is_macro(Name, Arity, Receiver, Required) of
     true  -> false;
-    false -> remote_function(Meta, Receiver, Name, Arity, E)
+    false ->
+      elixir_env:trace({remote_function, Meta, Receiver, Name, Arity}, E),
+      remote_function(Meta, Receiver, Name, Arity, E)
   end.
 
 remote_function(Meta, Receiver, Name, Arity, E) ->
-  check_deprecation(Meta, Receiver, Name, Arity, E),
+  check_deprecated(function, Meta, Receiver, Name, Arity, E),
 
-  elixir_lexical:record_remote(Receiver, ?m(E, lexical_tracker)),
-  case inline(Receiver, Name, Arity) of
+  case elixir_rewrite:inline(Receiver, Name, Arity) of
     {AR, AN} -> {remote, AR, AN, Arity};
     false    -> {remote, Receiver, Name, Arity}
   end.
 
 %% Dispatches
 
-dispatch_import(Meta, Name, Args, E, Callback) ->
+dispatch_import(Meta, Name, Args, S, E, Callback) ->
   Arity = length(Args),
-  case expand_import(Meta, {Name, Arity}, Args, E, []) of
-    {ok, Receiver, Quoted} ->
-      expand_quoted(Meta, Receiver, Name, Arity, Quoted, E);
-    {ok, Receiver, NewName, NewArgs} ->
-      elixir_exp:expand({{'.', [], [Receiver, NewName]}, Meta, NewArgs}, E);
-    error ->
-      Callback()
+
+  AllowLocals =
+    %% If we are inside a function, we support reading from locals.
+    case E of
+      #{function := {N, A}} when Name =/= N; Arity =/= A -> true;
+      _ -> false
+    end,
+
+  case expand_import(Meta, Name, Arity, E, [], AllowLocals, true) of
+    {macro, Receiver, Expander} ->
+      check_deprecated(macro, Meta, Receiver, Name, Arity, E),
+      Caller = {?line(Meta), S, E},
+      expand_quoted(Meta, Receiver, Name, Arity, Expander(stop_generated(Args), Caller), S, E);
+    {function, Receiver, NewName} ->
+      case elixir_rewrite:inline(Receiver, NewName, Arity) of
+        {AR, AN} ->
+          Callback({AR, AN});
+        false ->
+          check_deprecated(function, Meta, Receiver, Name, Arity, E),
+          Callback({Receiver, NewName})
+      end;
+    not_found ->
+      Callback(local);
+    Error ->
+      elixir_errors:file_error(Meta, E, ?MODULE, {import, Error, Name, Arity})
   end.
 
-dispatch_require(Meta, Receiver, Name, Args, E, Callback) when is_atom(Receiver) ->
+stop_generated(Args) ->
+  lists:map(fun
+    ({Call, Meta, Ctx}) when is_list(Meta) -> {Call, [{stop_generated, true} | Meta], Ctx};
+    (Other) -> Other
+  end, Args).
+
+dispatch_require(Meta, Receiver, Name, Args, S, E, Callback) when is_atom(Receiver) ->
   Arity = length(Args),
 
-  case rewrite(Receiver, Name, Args, Arity) of
-    {ok, AR, AN, AA} ->
-      Callback(AR, AN, AA);
+  case elixir_rewrite:inline(Receiver, Name, Arity) of
+    {AR, AN} ->
+      elixir_env:trace({remote_function, Meta, Receiver, Name, Arity}, E),
+      Callback(AR, AN);
     false ->
-      case expand_require(Meta, Receiver, {Name, Arity}, Args, E) of
-        {ok, Receiver, Quoted} -> expand_quoted(Meta, Receiver, Name, Arity, Quoted, E);
-        error -> Callback(Receiver, Name, Args)
+      case expand_require(Meta, Receiver, Name, Arity, E, true) of
+        {macro, Receiver, Expander} ->
+          check_deprecated(macro, Meta, Receiver, Name, Arity, E),
+          Caller = {?line(Meta), S, E},
+          expand_quoted(Meta, Receiver, Name, Arity, Expander(Args, Caller), S, E);
+        error ->
+          check_deprecated(function, Meta, Receiver, Name, Arity, E),
+          elixir_env:trace({remote_function, Meta, Receiver, Name, Arity}, E),
+          Callback(Receiver, Name)
       end
   end;
 
-dispatch_require(_Meta, Receiver, Name, Args, _E, Callback) ->
-  Callback(Receiver, Name, Args).
+dispatch_require(_Meta, Receiver, Name, _Args, _S, _E, Callback) ->
+  Callback(Receiver, Name).
 
 %% Macros expansion
 
-expand_import(Meta, {Name, Arity} = Tuple, Args, E, Extra) ->
-  Module   = ?m(E, module),
-  Dispatch = find_dispatch(Meta, Tuple, Extra, E),
-  Function = ?m(E, function),
-  Local    = (Function /= nil) andalso (Function /= Tuple) andalso
-              elixir_locals:macro_for(Module, Name, Arity),
+expand_import(Meta, Name, Arity, E, Extra, AllowLocals, Trace) ->
+  Tuple = {Name, Arity},
+  Module = ?key(E, module),
+  Dispatch = find_import_by_name_arity(Meta, Tuple, Extra, E),
 
   case Dispatch of
-    %% In case it is an import, we dispatch the import.
-    {import, _} ->
-      do_expand_import(Meta, Tuple, Args, Module, E, Dispatch);
-
-    %% There is a local and an import. This is a conflict unless
-    %% the receiver is the same as module (happens on bootstrap).
-    {_, Receiver} when Local /= false, Receiver /= Module ->
-      Error = {macro_conflict, {Receiver, Name, Arity}},
-      elixir_errors:form_error(Meta, ?m(E, file), ?MODULE, Error);
+    {ambiguous, Ambiguous} ->
+      {ambiguous, Ambiguous};
 
-    %% There is no local. Dispatch the import.
-    _ when Local == false ->
-      do_expand_import(Meta, Tuple, Args, Module, E, Dispatch);
+    {import, _} ->
+      do_expand_import(Dispatch, Meta, Name, Arity, Module, E, Trace);
 
-    %% Dispatch to the local.
     _ ->
-      elixir_locals:record_local(Tuple, Module, Function),
-      {ok, Module, expand_macro_fun(Meta, Local(), Module, Name, Args, E)}
+      Local = case AllowLocals of
+        false -> false;
+        true  -> elixir_def:local_for(Meta, Name, Arity, [defmacro, defmacrop], E);
+        Fun when is_function(Fun, 0) -> Fun()
+      end,
+
+      case Dispatch of
+        %% There is a local and an import. This is a conflict unless
+        %% the receiver is the same as module (happens on bootstrap).
+        {_, Receiver} when Local /= false, Receiver /= Module ->
+          {conflict, Receiver};
+
+        %% There is no local. Dispatch the import.
+        _ when Local == false ->
+          do_expand_import(Dispatch, Meta, Name, Arity, Module, E, Trace);
+
+        %% Dispatch to the local.
+        _ ->
+          Trace andalso elixir_env:trace({local_macro, Meta, Name, Arity}, E),
+          {macro, Module, expander_macro_fun(Meta, Local, Module, Name, E)}
+      end
   end.
 
-do_expand_import(Meta, {Name, Arity} = Tuple, Args, Module, E, Result) ->
+do_expand_import(Result, Meta, Name, Arity, Module, E, Trace) ->
   case Result of
     {function, Receiver} ->
-      elixir_lexical:record_import(Receiver, ?m(E, lexical_tracker)),
-      elixir_locals:record_import(Tuple, Receiver, Module, ?m(E, function)),
-
-      case rewrite(Receiver, Name, Args, Arity) of
-        {ok, _, _, _} = Res -> Res;
-        false -> {ok, Receiver, Name, Args}
-      end;
+      Trace andalso begin
+        elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),
+        elixir_import:record({Name, Arity}, Receiver, Module, ?key(E, function))
+      end,
+      {function, Receiver, Name};
     {macro, Receiver} ->
-      check_deprecation(Meta, Receiver, Name, Arity, E),
-      elixir_lexical:record_import(Receiver, ?m(E, lexical_tracker)),
-      elixir_locals:record_import(Tuple, Receiver, Module, ?m(E, function)),
-      {ok, Receiver, expand_macro_named(Meta, Receiver, Name, Arity, Args, E)};
+      Trace andalso begin
+        elixir_env:trace({imported_macro, Meta, Receiver, Name, Arity}, E),
+        elixir_import:record({Name, Arity}, Receiver, Module, ?key(E, function))
+      end,
+      {macro, Receiver, expander_macro_named(Meta, Receiver, Name, Arity, E)};
     {import, Receiver} ->
-      case expand_require([{require,false}|Meta], Receiver, Tuple, Args, E) of
-        {ok, _, _} = Response -> Response;
-        error -> {ok, Receiver, Name, Args}
+      case expand_require(true, Meta, Receiver, Name, Arity, E, Trace) of
+        {macro, _, _} = Response -> Response;
+        error ->
+          Trace andalso elixir_env:trace({remote_function, Meta, Receiver, Name, Arity}, E),
+          {function, Receiver, Name}
       end;
     false when Module == ?kernel ->
-      case rewrite(Module, Name, Args, Arity) of
-        {ok, _, _, _} = Res -> Res;
-        false -> error
+      case elixir_rewrite:inline(Module, Name, Arity) of
+        {AR, AN} -> {function, AR, AN};
+        false -> not_found
       end;
     false ->
-      error
+      not_found
   end.
 
-expand_require(Meta, Receiver, {Name, Arity} = Tuple, Args, E) ->
-  check_deprecation(Meta, Receiver, Name, Arity, E),
-  Module = ?m(E, module),
+expand_require(Meta, Receiver, Name, Arity, E, Trace) ->
+  Required = (Receiver == ?key(E, module))
+    orelse (lists:keyfind(required, 1, Meta) == {required, true})
+    orelse is_element(Receiver, ?key(E, requires)),
+
+  expand_require(Required, Meta, Receiver, Name, Arity, E, Trace).
 
-  case is_element(Tuple, get_optional_macros(Receiver)) of
+expand_require(Required, Meta, Receiver, Name, Arity, E, Trace) ->
+  case is_macro(Name, Arity, Receiver, Required) of
     true ->
-      Requires = ?m(E, requires),
-      case (Receiver == Module) orelse is_element(Receiver, Requires) orelse skip_require(Meta) of
-        true  ->
-          elixir_lexical:record_remote(Receiver, ?m(E, lexical_tracker)),
-          {ok, Receiver, expand_macro_named(Meta, Receiver, Name, Arity, Args, E)};
-        false ->
-          Info = {unrequired_module, {Receiver, Name, length(Args), Requires}},
-          elixir_errors:form_error(Meta, ?m(E, file), ?MODULE, Info)
-      end;
+      Trace andalso elixir_env:trace({remote_macro, Meta, Receiver, Name, Arity}, E),
+      {macro, Receiver, expander_macro_named(Meta, Receiver, Name, Arity, E)};
     false ->
       error
   end.
 
 %% Expansion helpers
 
-expand_macro_fun(Meta, Fun, Receiver, Name, Args, E) ->
-  Line = ?line(Meta),
-  EArg = {Line, E},
+expander_macro_fun(Meta, Fun, Receiver, Name, E) ->
+  fun(Args, Caller) -> expand_macro_fun(Meta, Fun, Receiver, Name, Args, Caller, E) end.
 
+expander_macro_named(Meta, Receiver, Name, Arity, E) ->
+  ProperName  = elixir_utils:macro_name(Name),
+  ProperArity = Arity + 1,
+  Fun         = fun Receiver:ProperName/ProperArity,
+  fun(Args, Caller) -> expand_macro_fun(Meta, Fun, Receiver, Name, Args, Caller, E) end.
+
+expand_macro_fun(Meta, Fun, Receiver, Name, Args, Caller, E) ->
   try
-    apply(Fun, [EArg|Args])
+    apply(Fun, [Caller | Args])
   catch
-    Kind:Reason ->
+    Kind:Reason:Stacktrace ->
       Arity = length(Args),
       MFA  = {Receiver, elixir_utils:macro_name(Name), Arity+1},
-      Info = [{Receiver, Name, Arity, [{file, "expanding macro"}]}, caller(Line, E)],
-      erlang:raise(Kind, Reason, prune_stacktrace(erlang:get_stacktrace(), MFA, Info, EArg))
+      Info = [{Receiver, Name, Arity, [{file, "expanding macro"}]}, caller(?line(Meta), E)],
+      erlang:raise(Kind, Reason, prune_stacktrace(Stacktrace, MFA, Info, {ok, Caller}))
   end.
 
-expand_macro_named(Meta, Receiver, Name, Arity, Args, E) ->
-  ProperName  = elixir_utils:macro_name(Name),
-  ProperArity = Arity + 1,
-  Fun         = fun Receiver:ProperName/ProperArity,
-  expand_macro_fun(Meta, Fun, Receiver, Name, Args, E).
-
-expand_quoted(Meta, Receiver, Name, Arity, Quoted, E) ->
-  Line = ?line(Meta),
-  Next = elixir_counter:next(),
+expand_quoted(Meta, Receiver, Name, Arity, Quoted, S, E) ->
+  Next = elixir_module:next_counter(?key(E, module)),
 
   try
-    elixir_exp:expand(
-      elixir_quote:linify_with_context_counter(Line, {Receiver, Next}, Quoted),
-      E)
+    ToExpand = elixir_quote:linify_with_context_counter(Meta, {Receiver, Next}, Quoted),
+    elixir_expand:expand(ToExpand, S, E)
   catch
-    Kind:Reason ->
+    Kind:Reason:Stacktrace ->
       MFA  = {Receiver, elixir_utils:macro_name(Name), Arity+1},
-      Info = [{Receiver, Name, Arity, [{file, "expanding macro"}]}, caller(Line, E)],
-      erlang:raise(Kind, Reason, prune_stacktrace(erlang:get_stacktrace(), MFA, Info, nil))
+      Info = [{Receiver, Name, Arity, [{file, "expanding macro"}]}, caller(?line(Meta), E)],
+      erlang:raise(Kind, Reason, prune_stacktrace(Stacktrace, MFA, Info, error))
   end.
 
-caller(Line, #{module := nil} = E) ->
-  {elixir_compiler, '__FILE__', 2, location(Line, E)};
-caller(Line, #{module := Module, function := nil} = E) ->
-  {Module, '__MODULE__', 0, location(Line, E)};
-caller(Line, #{module := Module, function := {Name, Arity}} = E) ->
-  {Module, Name, Arity, location(Line, E)}.
-
-location(Line, E) ->
-  [{file, elixir_utils:characters_to_list(elixir_utils:relative_to_cwd(?m(E, file)))},
-   {line, Line}].
+caller(Line, E) ->
+  elixir_utils:caller(Line, ?key(E, file), ?key(E, module), ?key(E, function)).
 
 %% Helpers
 
-skip_require(Meta) ->
-  lists:keyfind(require, 1, Meta) == {require, false}.
+find_imports_by_name([{Mod, Imports} | ModImports], Acc, Name, Meta, E) ->
+  NewAcc = find_imports_by_name(Name, Imports, Acc, Mod, Meta, E),
+  find_imports_by_name(ModImports, NewAcc, Name, Meta, E);
+find_imports_by_name([], Acc, _Name, _Meta, _E) ->
+  Acc.
+
+find_imports_by_name(Name, [{Name, Arity} | Imports], Acc, Mod, Meta, E) ->
+  case Acc of
+    #{Arity := OtherMod} ->
+      Error = {import, {ambiguous, [Mod, OtherMod]}, Name, Arity},
+      elixir_errors:file_error(Meta, E, ?MODULE, Error);
 
-find_dispatch(Meta, Tuple, Extra, E) ->
-  case is_import(Meta) of
+    #{} ->
+      find_imports_by_name(Name, Imports, Acc#{Arity => Mod}, Mod, Meta, E)
+  end;
+find_imports_by_name(Name, [{ImportName, _} | Imports], Acc, Mod, Meta, E) when Name > ImportName ->
+  find_imports_by_name(Name, Imports, Acc, Mod, Meta, E);
+find_imports_by_name(_Name, _Imports, Acc, _Mod, _Meta, _E) ->
+  Acc.
+
+find_import_by_name_arity(Meta, {_Name, Arity} = Tuple, Extra, E) ->
+  case is_import(Meta, Arity) of
     {import, _} = Import ->
       Import;
     false ->
-      Funs = ?m(E, functions),
-      Macs = Extra ++ ?m(E, macros),
-      FunMatch = find_dispatch(Tuple, Funs),
-      MacMatch = find_dispatch(Tuple, Macs),
+      Funs = ?key(E, functions),
+      Macs = Extra ++ ?key(E, macros),
+      FunMatch = find_import_by_name_arity(Tuple, Funs),
+      MacMatch = find_import_by_name_arity(Tuple, Macs),
 
       case {FunMatch, MacMatch} of
         {[], [Receiver]} -> {macro, Receiver};
         {[Receiver], []} -> {function, Receiver};
         {[], []} -> false;
-        _ ->
-          {Name, Arity} = Tuple,
-          [First, Second|_] = FunMatch ++ MacMatch,
-          Error = {ambiguous_call, {First, Second, Name, Arity}},
-          elixir_errors:form_error(Meta, ?m(E, file), ?MODULE, Error)
+        _ -> {ambiguous, FunMatch ++ MacMatch}
       end
   end.
 
-find_dispatch(Tuple, List) ->
+find_import_by_name_arity(Tuple, List) ->
   [Receiver || {Receiver, Set} <- List, is_element(Tuple, Set)].
 
-is_import(Meta) ->
-  case lists:keyfind(import, 1, Meta) of
-    {import, _} = Import ->
+is_import(Meta, Arity) ->
+  case lists:keyfind(imports, 1, Meta) of
+    {imports, [_ | _] = Imports} ->
       case lists:keyfind(context, 1, Meta) of
-        {context, _} -> Import;
-        false ->
-          false
+        {context, _} ->
+          case lists:keyfind(Arity, 1, Imports) of
+            {Arity, Receiver} -> {import, Receiver};
+            false -> false
+          end;
+        false -> false
       end;
-    false ->
-      false
+    _ -> false
   end.
 
 % %% We've reached the macro wrapper fun, skip it with the rest
-prune_stacktrace([{_, _, [E|_], _}|_], _MFA, Info, E) ->
+prune_stacktrace([{_, _, [Caller | _], _} | _], _MFA, Info, {ok, Caller}) ->
   Info;
 %% We've reached the invoked macro, skip it
-prune_stacktrace([{M, F, A, _}|_], {M, F, A}, Info, _E) ->
+prune_stacktrace([{M, F, A, _} | _], {M, F, A}, Info, _E) ->
   Info;
 %% We've reached the elixir_dispatch internals, skip it with the rest
-prune_stacktrace([{Mod, _, _, _}|_], _MFA, Info, _E) when Mod == elixir_dispatch; Mod == elixir_exp ->
+prune_stacktrace([{Mod, _, _, _} | _], _MFA, Info, _E) when Mod == elixir_dispatch; Mod == elixir_exp ->
   Info;
-prune_stacktrace([H|T], MFA, Info, E) ->
-  [H|prune_stacktrace(T, MFA, Info, E)];
+prune_stacktrace([H | T], MFA, Info, E) ->
+  [H | prune_stacktrace(T, MFA, Info, E)];
 prune_stacktrace([], _MFA, Info, _E) ->
   Info.
 
 %% ERROR HANDLING
 
-format_error({unrequired_module, {Receiver, Name, Arity, _Required}}) ->
-  Module = elixir_aliases:inspect(Receiver),
-  io_lib:format("you must require ~ts before invoking the macro ~ts.~ts/~B",
-    [Module, Module, Name, Arity]);
-format_error({macro_conflict, {Receiver, Name, Arity}}) ->
+format_error({import, {conflict, Receiver}, Name, Arity}) ->
   io_lib:format("call to local macro ~ts/~B conflicts with imported ~ts.~ts/~B, "
     "please rename the local macro or remove the conflicting import",
     [Name, Arity, elixir_aliases:inspect(Receiver), Name, Arity]);
-format_error({ambiguous_call, {Mod1, Mod2, Name, Arity}}) ->
+format_error({import, {ambiguous, [Mod1, Mod2 | _]}, Name, Arity}) ->
   io_lib:format("function ~ts/~B imported from both ~ts and ~ts, call is ambiguous",
-    [Name, Arity, elixir_aliases:inspect(Mod1), elixir_aliases:inspect(Mod2)]).
+    [Name, Arity, elixir_aliases:inspect(Mod1), elixir_aliases:inspect(Mod2)]);
+format_error({compile_env, Name, Arity}) ->
+  io_lib:format("Application.~s/~B is discouraged in the module body, use Application.compile_env/3 instead", [Name, Arity]);
+format_error({deprecated, Mod, '__using__', 1, Message}) ->
+  io_lib:format("use ~s is deprecated. ~s", [elixir_aliases:inspect(Mod), Message]);
+format_error({deprecated, Mod, Fun, Arity, Message}) ->
+  io_lib:format("~s.~s/~B is deprecated. ~s",[elixir_aliases:inspect(Mod), Fun, Arity, Message]).
 
 %% INTROSPECTION
 
-%% Do not try to get macros from Erlang. Speeds up compilation a bit.
-get_optional_macros(erlang) -> [];
+is_macro(_Name, _Arity, _Module, false) ->
+  false;
+is_macro(Name, Arity, Receiver, true) ->
+  try Receiver:'__info__'(macros) of
+    Macros -> is_element({Name, Arity}, Macros)
+  catch
+    error:_ -> false
+  end.
 
-get_optional_macros(Receiver) ->
+%% Deprecations checks only happen at the module body,
+%% so in there we can try to at least load the module.
+get_deprecations(Receiver) ->
   case code:ensure_loaded(Receiver) of
-    {module, Receiver} ->
+    {module, Receiver} -> get_info(Receiver, deprecated);
+    _ -> []
+  end.
+
+get_info(Receiver, Key) ->
+  case erlang:function_exported(Receiver, '__info__', 1) of
+    true ->
       try
-        Receiver:'__info__'(macros)
+        Receiver:'__info__'(Key)
       catch
-        error:undef -> []
+        error:_ -> []
       end;
-    {error, _} -> []
+    false ->
+      []
   end.
 
 elixir_imported_functions() ->
@@ -338,184 +417,31 @@ elixir_imported_macros() ->
     error:undef -> []
   end.
 
-rewrite(?atom, to_string, [Arg], _) ->
-  {ok, erlang, atom_to_binary, [Arg, utf8]};
-rewrite(?kernel, elem, [Tuple, Index], _) ->
-  {ok, erlang, element, [increment(Index), Tuple]};
-rewrite(?kernel, put_elem, [Tuple, Index, Value], _) ->
-  {ok, erlang, setelement, [increment(Index), Tuple, Value]};
-rewrite(?map, 'has_key?', [Map, Key], _) ->
-  {ok, maps, is_key, [Key, Map]};
-rewrite(?map, fetch, [Map, Key], _) ->
-  {ok, maps, find, [Key, Map]};
-rewrite(?map, put, [Map, Key, Value], _) ->
-  {ok, maps, put, [Key, Value, Map]};
-rewrite(?map, delete, [Map, Key], _) ->
-  {ok, maps, remove, [Key, Map]};
-rewrite(?process, monitor, [Arg], _) ->
-  {ok, erlang, monitor, [process, Arg]};
-rewrite(?string, to_atom, [Arg], _) ->
-  {ok, erlang, binary_to_atom, [Arg, utf8]};
-rewrite(?string, to_existing_atom, [Arg], _) ->
-  {ok, erlang, binary_to_existing_atom, [Arg, utf8]};
-rewrite(?tuple, insert_at, [Tuple, Index, Term], _) ->
-  {ok, erlang, insert_element, [increment(Index), Tuple, Term]};
-rewrite(?tuple, delete_at, [Tuple, Index], _) ->
-  {ok, erlang, delete_element, [increment(Index), Tuple]};
-rewrite(?tuple, duplicate, [Data, Size], _) ->
-  {ok, erlang, make_tuple, [Size, Data]};
-
-rewrite(Receiver, Name, Args, Arity) ->
-  case inline(Receiver, Name, Arity) of
-    {AR, AN} -> {ok, AR, AN, Args};
-    false    -> false
-  end.
-
-increment(Number) when is_number(Number) ->
-  Number + 1;
-increment(Other) ->
-  {{'.', [], [erlang, '+']}, [], [Other, 1]}.
-
-inline(?atom, to_char_list, 1) -> {erlang, atom_to_list};
-inline(?io, iodata_length, 1) -> {erlang, iolist_size};
-inline(?io, iodata_to_binary, 1) -> {erlang, iolist_to_binary};
-inline(?integer, to_string, 1) -> {erlang, integer_to_binary};
-inline(?integer, to_string, 2) -> {erlang, integer_to_binary};
-inline(?integer, to_char_list, 1) -> {erlang, integer_to_list};
-inline(?integer, to_char_list, 2) -> {erlang, integer_to_list};
-inline(?float, to_string, 1) -> {erlang, float_to_binary};
-inline(?float, to_char_list, 1) -> {erlang, float_to_list};
-inline(?list, to_atom, 1) -> {erlang, list_to_atom};
-inline(?list, to_existing_atom, 1) -> {erlang, list_to_existing_atom};
-inline(?list, to_float, 1) -> {erlang, list_to_float};
-inline(?list, to_integer, 1) -> {erlang, list_to_integer};
-inline(?list, to_integer, 2) -> {erlang, list_to_integer};
-inline(?list, to_tuple, 1) -> {erlang, list_to_tuple};
-
-inline(?kernel, '+', 2) -> {erlang, '+'};
-inline(?kernel, '-', 2) -> {erlang, '-'};
-inline(?kernel, '+', 1) -> {erlang, '+'};
-inline(?kernel, '-', 1) -> {erlang, '-'};
-inline(?kernel, '*', 2) -> {erlang, '*'};
-inline(?kernel, '/', 2) -> {erlang, '/'};
-inline(?kernel, '++', 2) -> {erlang, '++'};
-inline(?kernel, '--', 2) -> {erlang, '--'};
-inline(?kernel, 'not', 1) -> {erlang, 'not'};
-inline(?kernel, '<', 2) -> {erlang, '<'};
-inline(?kernel, '>', 2) -> {erlang, '>'};
-inline(?kernel, '<=', 2) -> {erlang, '=<'};
-inline(?kernel, '>=', 2) -> {erlang, '>='};
-inline(?kernel, '==', 2) -> {erlang, '=='};
-inline(?kernel, '!=', 2) -> {erlang, '/='};
-inline(?kernel, '===', 2) -> {erlang, '=:='};
-inline(?kernel, '!==', 2) -> {erlang, '=/='};
-inline(?kernel, abs, 1) -> {erlang, abs};
-inline(?kernel, apply, 2) -> {erlang, apply};
-inline(?kernel, apply, 3) -> {erlang, apply};
-inline(?kernel, binary_part, 3) -> {erlang, binary_part};
-inline(?kernel, bit_size, 1) -> {erlang, bit_size};
-inline(?kernel, byte_size, 1) -> {erlang, byte_size};
-inline(?kernel, 'div', 2) -> {erlang, 'div'};
-inline(?kernel, exit, 1) -> {erlang, exit};
-inline(?kernel, hd, 1) -> {erlang, hd};
-inline(?kernel, is_atom, 1) -> {erlang, is_atom};
-inline(?kernel, is_binary, 1) -> {erlang, is_binary};
-inline(?kernel, is_bitstring, 1) -> {erlang, is_bitstring};
-inline(?kernel, is_boolean, 1) -> {erlang, is_boolean};
-inline(?kernel, is_float, 1) -> {erlang, is_float};
-inline(?kernel, is_function, 1) -> {erlang, is_function};
-inline(?kernel, is_function, 2) -> {erlang, is_function};
-inline(?kernel, is_integer, 1) -> {erlang, is_integer};
-inline(?kernel, is_list, 1) -> {erlang, is_list};
-inline(?kernel, is_map, 1) -> {erlang, is_map};
-inline(?kernel, is_number, 1) -> {erlang, is_number};
-inline(?kernel, is_pid, 1) -> {erlang, is_pid};
-inline(?kernel, is_port, 1) -> {erlang, is_port};
-inline(?kernel, is_reference, 1) -> {erlang, is_reference};
-inline(?kernel, is_tuple, 1) -> {erlang, is_tuple};
-inline(?kernel, length, 1) -> {erlang, length};
-inline(?kernel, make_ref, 0) -> {erlang, make_ref};
-inline(?kernel, map_size, 1) -> {erlang, map_size};
-inline(?kernel, max, 2) -> {erlang, max};
-inline(?kernel, min, 2) -> {erlang, min};
-inline(?kernel, node, 0) -> {erlang, node};
-inline(?kernel, node, 1) -> {erlang, node};
-inline(?kernel, 'rem', 2) -> {erlang, 'rem'};
-inline(?kernel, round, 1) -> {erlang, round};
-inline(?kernel, self, 0) -> {erlang, self};
-inline(?kernel, send, 2) -> {erlang, send};
-inline(?kernel, spawn, 1) -> {erlang, spawn};
-inline(?kernel, spawn, 3) -> {erlang, spawn};
-inline(?kernel, spawn_link, 1) -> {erlang, spawn_link};
-inline(?kernel, spawn_link, 3) -> {erlang, spawn_link};
-inline(?kernel, spawn_monitor, 1) -> {erlang, spawn_monitor};
-inline(?kernel, spawn_monitor, 3) -> {erlang, spawn_monitor};
-inline(?kernel, throw, 1) -> {erlang, throw};
-inline(?kernel, tl, 1) -> {erlang, tl};
-inline(?kernel, trunc, 1) -> {erlang, trunc};
-inline(?kernel, tuple_size, 1) -> {erlang, tuple_size};
-
-inline(?map, keys, 1) -> {maps, keys};
-inline(?map, merge, 2) -> {maps, merge};
-inline(?map, size, 1) -> {maps, size};
-inline(?map, values, 1) -> {maps, values};
-inline(?map, to_list, 1) -> {maps, to_list};
-
-inline(?node, spawn, 2) -> {erlang, spawn};
-inline(?node, spawn, 3) -> {erlang, spawn_opt};
-inline(?node, spawn, 4) -> {erlang, spawn};
-inline(?node, spawn, 5) -> {erlang, spawn_opt};
-inline(?node, spawn_link, 2) -> {erlang, spawn_link};
-inline(?node, spawn_link, 4) -> {erlang, spawn_link};
-
-inline(?process, exit, 2) -> {erlang, exit};
-inline(?process, spawn, 2) -> {erlang, spawn_opt};
-inline(?process, spawn, 4) -> {erlang, spawn_opt};
-inline(?process, demonitor, 1) -> {erlang, demonitor};
-inline(?process, demonitor, 2) -> {erlang, demonitor};
-inline(?process, link, 1) -> {erlang, link};
-inline(?process, unlink, 1) -> {erlang, unlink};
-
-inline(?string, to_float, 1) -> {erlang, binary_to_float};
-inline(?string, to_integer, 1) -> {erlang, binary_to_integer};
-inline(?string, to_integer, 2) -> {erlang, binary_to_integer};
-inline(?system, stacktrace, 0) -> {erlang, get_stacktrace};
-inline(?tuple, to_list, 1) -> {erlang, tuple_to_list};
-
-inline(_, _, _) -> false.
-
-check_deprecation(Meta, Receiver, Name, Arity, #{file := File}) ->
-  case deprecation(Receiver, Name, Arity) of
-    false -> ok;
-    Message ->
-      Warning = deprecation_message(Receiver, Name, Arity, Message),
-      elixir_errors:warn(?line(Meta), File, Warning)
-  end.
+check_deprecated(_, _, erlang, _, _, _) -> ok;
+check_deprecated(_, _, elixir_def, _, _, _) -> ok;
+check_deprecated(_, _, elixir_module, _, _, _) -> ok;
+check_deprecated(_, _, ?kernel, _, _, _) -> ok;
+check_deprecated(Kind, Meta, ?application, Name, Arity, E) ->
+  case E of
+    #{module := Module, function := nil}
+    when (Module /= nil) or (Kind == macro), (Name == get_env) orelse (Name == fetch_env) orelse (Name == 'fetch_env!') ->
+      elixir_errors:file_warn(Meta, E, ?MODULE, {compile_env, Name, Arity});
 
-deprecation_message(Receiver, '__using__', _Arity, Message) ->
-  Warning = io_lib:format("use ~s is deprecated", [elixir_aliases:inspect(Receiver)]),
-  deprecation_message(Warning, Message);
+    _ ->
+      ok
+  end;
+check_deprecated(Kind, Meta, Receiver, Name, Arity, E) ->
+  %% Any compile time behavior cannot be verified by the runtime group pass.
+  case ((?key(E, function) == nil) or (Kind == macro)) andalso get_deprecations(Receiver) of
+    [_ | _] = Deprecations ->
+      case lists:keyfind({Name, Arity}, 1, Deprecations) of
+        {_, Message} ->
+          elixir_errors:file_warn(Meta, E, ?MODULE, {deprecated, Receiver, Name, Arity, Message});
 
-deprecation_message(Receiver, Name, Arity, Message) ->
-  Warning = io_lib:format("~s.~s/~B is deprecated",
-                          [elixir_aliases:inspect(Receiver), Name, Arity]),
-  deprecation_message(Warning, Message).
+        false ->
+          false
+      end;
 
-deprecation_message(Warning, Message) ->
-  case Message of
-    true -> Warning;
-    Message -> Warning ++ ", " ++ Message
+    _ ->
+      ok
   end.
-
-deprecation('Elixir.Mix.Generator', 'from_file', _) ->
-  "instead pass [from_file: file] to embed_text/2 and embed_template/2 macros. "
-  "Note that [from_file: file] expects paths relative to the current working "
-  "directory and not to the current file";
-deprecation('Elixir.EEx.TransformerEngine', '__using__', _) ->
-  "check EEx.SmartEngine for how to build custom engines";
-deprecation('Elixir.EEx.AssignsEngine', '__using__', _) ->
-  "check EEx.SmartEngine for how to build custom engines";
-deprecation('Elixir.Kernel', 'xor', _) ->
-  true; %% Remember to remove xor operator from tokenizer
-deprecation(_, _, _) ->
-  false.
diff --git a/lib/elixir/src/elixir_env.erl b/lib/elixir/src/elixir_env.erl
index fc32e1b0599..ec6df8f6366 100644
--- a/lib/elixir/src/elixir_env.erl
+++ b/lib/elixir/src/elixir_env.erl
@@ -1,62 +1,164 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(elixir_env).
 -include("elixir.hrl").
--export([new/0, linify/1, env_to_scope/1, env_to_scope_with_vars/2]).
--export([mergea/2, mergev/2, merge_vars/2, merge_opt_vars/2]).
+-export([
+  new/0, to_caller/1, merge_vars/2, with_vars/2, reset_vars/1, env_to_ex/1,
+  reset_unused_vars/1, check_unused_vars/2, merge_and_check_unused_vars/3, calculate_span/2,
+  trace/2, format_error/1,
+  reset_read/2, prepare_write/1, prepare_write/2, close_write/2
+]).
 
 new() ->
-  #{'__struct__' => 'Elixir.Macro.Env',
-    module => nil,                         %% the current module
-    file => <<"nofile">>,                  %% the current filename
-    line => 1,                             %% the current line
-    function => nil,                       %% the current function
-    context => nil,                        %% can be match_vars, guards or nil
-    requires => [],                        %% a set with modules required
-    aliases => [],                         %% an orddict with aliases by new -> old names
-    functions => [],                       %% a list with functions imported from module
-    macros => [],                          %% a list with macros imported from module
-    macro_aliases => [],                   %% keep aliases defined inside a macro
-    context_modules => [],                 %% modules defined in the current context
-    vars => [],                            %% a set of defined variables
-    export_vars => nil,                    %% a set of variables to be exported in some constructs
-    lexical_tracker => nil,                %% holds the lexical tracker pid
-    local => nil}.                         %% the module to delegate local functions to
-
-linify({Line, Env}) ->
-  Env#{line := Line}.
-
-env_to_scope(#{module := Module, file := File, function := Function, context := Context}) ->
-  #elixir_scope{module=Module, file=File, function=Function, context=Context}.
-
-env_to_scope_with_vars(Env, Vars) ->
-  (env_to_scope(Env))#elixir_scope{
-    vars=orddict:from_list(Vars),
-    counter=[{'_',length(Vars)}]
- }.
-
-%% SCOPE MERGING
-
-%% Receives two scopes and return a new scope based on the second
-%% with their variables merged.
-mergev(E1, E2) when is_list(E1) ->
-  E2#{
-    vars := merge_vars(E1, ?m(E2, vars)),
-    export_vars := merge_opt_vars(E1, ?m(E2, export_vars))
- };
-mergev(E1, E2) ->
-  E2#{
-    vars := merge_vars(?m(E1, vars), ?m(E2, vars)),
-    export_vars := merge_opt_vars(?m(E1, export_vars), ?m(E2, export_vars))
- }.
-
-%% Receives two scopes and return the later scope
-%% keeping the variables from the first (imports
-%% and everything else are passed forward).
-
-mergea(E1, E2) ->
-  E2#{vars := ?m(E1, vars)}.
-
-merge_vars(V1, V2) -> ordsets:union(V1, V2).
-
-merge_opt_vars(_V1, nil) -> nil;
-merge_opt_vars(nil, _V2) -> nil;
-merge_opt_vars(V1, V2)   -> ordsets:union(V1, V2).
+  #{
+    '__struct__' => 'Elixir.Macro.Env',
+    module => nil,                                    %% the current module
+    file => <<"nofile">>,                             %% the current filename
+    line => 1,                                        %% the current line
+    function => nil,                                  %% the current function
+    context => nil,                                   %% can be match, guard or nil
+    aliases => [],                                    %% a list of aliases by new -> old names
+    requires => elixir_dispatch:default_requires(),   %% a set with modules required
+    functions => elixir_dispatch:default_functions(), %% a list with functions imported from module
+    macros => elixir_dispatch:default_macros(),       %% a list with macros imported from module
+    macro_aliases => [],                              %% keep aliases defined inside a macro
+    context_modules => [],                            %% modules defined in the current context
+    versioned_vars => #{},                            %% a map of vars with their latest versions
+    lexical_tracker => nil,                           %% lexical tracker PID
+    tracers => []                                     %% available compilation tracers
+  }.
+
+trace(Event, #{tracers := Tracers} = E) ->
+  [ok = Tracer:trace(Event, E) || Tracer <- Tracers],
+  ok.
+
+to_caller({Line, #elixir_ex{vars={Read, _}}, Env}) ->
+  Env#{line := Line, versioned_vars := Read};
+to_caller(#{'__struct__' := 'Elixir.Macro.Env'} = Env) ->
+  Env.
+
+with_vars(Env, Vars) when is_list(Vars) ->
+  {ReversedVars, _} =
+    lists:foldl(fun(Var, {Acc, I}) -> {[{Var, I} | Acc], I + 1} end, {[], 0}, Vars),
+  Env#{versioned_vars := maps:from_list(ReversedVars)};
+with_vars(Env, #{} = Vars) ->
+  Env#{versioned_vars := Vars}.
+
+reset_vars(Env) ->
+  Env#{versioned_vars := #{}}.
+
+%% CONVERSIONS
+
+env_to_ex(#{context := match, versioned_vars := Vars}) ->
+  Counter = map_size(Vars),
+  #elixir_ex{
+    prematch={Vars, {#{}, []}, Counter},
+    vars={Vars, false},
+    unused={#{}, Counter}
+  };
+env_to_ex(#{versioned_vars := Vars}) ->
+  #elixir_ex{
+    vars={Vars, false},
+    unused={#{}, map_size(Vars)}
+  }.
+
+%% VAR HANDLING
+
+reset_read(#elixir_ex{vars={_, Write}} = S, #elixir_ex{vars={Read, _}}) ->
+  S#elixir_ex{vars={Read, Write}}.
+
+prepare_write(S, #{context := nil}) ->
+  prepare_write(S);
+prepare_write(S, _) ->
+  S.
+
+prepare_write(#elixir_ex{vars={Read, _}} = S) ->
+  S#elixir_ex{vars={Read, Read}}.
+
+close_write(#elixir_ex{vars={_Read, Write}} = S, #elixir_ex{vars={_, false}}) ->
+  S#elixir_ex{vars={Write, false}};
+close_write(#elixir_ex{vars={_Read, Write}} = S, #elixir_ex{vars={_, UpperWrite}}) ->
+  S#elixir_ex{vars={Write, merge_vars(UpperWrite, Write)}}.
+
+merge_vars(V, V) ->
+  V;
+merge_vars(V1, V2) ->
+  maps:fold(fun(K, M2, Acc) ->
+    case Acc of
+      #{K := M1} when M1 >= M2 -> Acc;
+      _ -> Acc#{K => M2}
+    end
+  end, V1, V2).
+
+%% UNUSED VARS
+
+reset_unused_vars(#elixir_ex{unused={_Unused, Version}} = S) ->
+  S#elixir_ex{unused={#{}, Version}}.
+
+check_unused_vars(#elixir_ex{unused={Unused, _Version}}, E) ->
+  [elixir_errors:file_warn(calculate_span(Meta, Name), E, ?MODULE, {unused_var, Name, Overridden}) ||
+    {{{Name, _Kind}, _Count}, {Meta, Overridden}} <- maps:to_list(Unused), is_unused_var(Name)],
+  E.
+
+calculate_span(Meta, Name) ->
+  case lists:keyfind(column, 1, Meta) of
+    {column, Column} ->
+      [{span, {?line(Meta), Column + string:length(atom_to_binary(Name))}} | Meta];
+
+    _ ->
+      Meta
+  end.
+
+merge_and_check_unused_vars(S, #elixir_ex{vars={Read, Write}, unused={Unused, _Version}}, E) ->
+  #elixir_ex{unused={ClauseUnused, Version}} = S,
+  NewUnused = merge_and_check_unused_vars(Read, Unused, ClauseUnused, E),
+  S#elixir_ex{unused={NewUnused, Version}, vars={Read, Write}}.
+
+merge_and_check_unused_vars(Current, Unused, ClauseUnused, E) ->
+  maps:fold(fun
+    ({Var, Count} = Key, false, Acc) ->
+      case Current of
+        #{Var := CurrentCount} when Count =< CurrentCount ->
+          %% The parent knows it, so we have to propagate it was used up.
+          Acc#{Key => false};
+
+        #{} ->
+          Acc
+      end;
+
+    ({{Name, _Kind}, _Count}, {Meta, Overridden}, Acc) ->
+      case is_unused_var(Name) of
+        true ->
+          Warn = {unused_var, Name, Overridden},
+          elixir_errors:file_warn(Meta, E, ?MODULE, Warn);
+
+        false ->
+          ok
+      end,
+
+      Acc
+  end, Unused, ClauseUnused).
+
+is_unused_var(Name) ->
+  case atom_to_list(Name) of
+    "_" ++ Rest -> is_compiler_var(Rest);
+    _ -> true
+  end.
+
+is_compiler_var([$_]) -> true;
+is_compiler_var([Var | Rest]) when Var =:= $_; Var >= $A, Var =< $Z -> is_compiler_var(Rest);
+is_compiler_var(_) -> false.
+
+format_error({unused_var, Name, Overridden}) ->
+  case atom_to_list(Name) of
+    "_" ++ _ ->
+      io_lib:format("unknown compiler variable \"~ts\" (expected one of __MODULE__, __ENV__, __DIR__, __CALLER__, __STACKTRACE__)", [Name]);
+    "&" ++ _ ->
+      io_lib:format("variable \"~ts\" is unused (this might happen when using a capture argument as a pattern)", [Name]);
+    _ when Overridden ->
+      io_lib:format("variable \"~ts\" is unused (there is a variable with the same name in the context, use the pin operator (^) to match on it or prefix this variable with underscore if it is not meant to be used)", [Name]);
+    _ ->
+      io_lib:format("variable \"~ts\" is unused (if the variable is not meant to be used, prefix it with an underscore)", [Name])
+  end.
diff --git a/lib/elixir/src/elixir_erl.erl b/lib/elixir/src/elixir_erl.erl
new file mode 100644
index 00000000000..fc8da5e3bd6
--- /dev/null
+++ b/lib/elixir/src/elixir_erl.erl
@@ -0,0 +1,694 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+%% Compiler backend to Erlang.
+
+-module(elixir_erl).
+-export([elixir_to_erl/1, elixir_to_erl/2, definition_to_anonymous/5, compile/2, consolidate/4,
+         get_ann/1, debug_info/4, scope/2, checker_version/0, format_error/1]).
+-include("elixir.hrl").
+-define(typespecs, 'Elixir.Kernel.Typespec').
+
+checker_version() ->
+  elixir_checker_v4.
+
+%% debug_info callback
+
+debug_info(elixir_v1, _Module, none, _Opts) ->
+  {error, missing};
+debug_info(elixir_v1, _Module, {elixir_v1, Map, _Specs}, _Opts) ->
+  {ok, Map};
+debug_info(erlang_v1, _Module, {elixir_v1, Map, Specs}, _Opts) ->
+  {Prefix, Forms, _, _, _} = dynamic_form(Map, nil),
+  {ok, Prefix ++ Specs ++ Forms};
+debug_info(core_v1, _Module, {elixir_v1, Map, Specs}, Opts) ->
+  {Prefix, Forms, _, _, _} = dynamic_form(Map, nil),
+  #{compile_opts := CompileOpts} = Map,
+  AllOpts = CompileOpts ++ Opts,
+
+  %% Do not rely on elixir_erl_compiler because we don't warn
+  %% warnings nor the other functionality provided there.
+  case elixir_erl_compiler:erl_to_core(Prefix ++ Specs ++ Forms, AllOpts) of
+    {ok, CoreForms, _} ->
+      try compile:noenv_forms(CoreForms, [no_spawn_compiler_process, from_core, to_core, return | AllOpts]) of
+        {ok, _, Core, _} -> {ok, Core};
+        _What -> {error, failed_conversion}
+      catch
+        error:_ -> {error, failed_conversion}
+      end;
+    _ ->
+      {error, failed_conversion}
+  end;
+debug_info(_, _, _, _) ->
+  {error, unknown_format}.
+
+%% Builds Erlang AST annotation.
+
+get_ann(Opts) when is_list(Opts) ->
+  get_ann(Opts, false, 0, undefined).
+
+get_ann([{generated, true} | T], _, Line, Column) -> get_ann(T, true, Line, Column);
+get_ann([{line, Line} | T], Gen, _, Column) when is_integer(Line) -> get_ann(T, Gen, Line, Column);
+get_ann([{column, Column} | T], Gen, Line, _) when is_integer(Column) -> get_ann(T, Gen, Line, Column);
+get_ann([_ | T], Gen, Line, Column) -> get_ann(T, Gen, Line, Column);
+get_ann([], Gen, Line, undefined) -> erl_anno:set_generated(Gen, erl_anno:new(Line));
+get_ann([], Gen, Line, Column) -> erl_anno:set_generated(Gen, erl_anno:new({Line, Column})).
+
+%% Converts an Elixir definition to an anonymous function.
+
+definition_to_anonymous(Kind, Meta, Clauses, LocalHandler, ExternalHandler) ->
+  ErlClauses = [translate_clause(Kind, 0, Clause, true) || Clause <- Clauses],
+  Fun = {'fun', ?ann(Meta), {clauses, ErlClauses}},
+  {value, Result, _Binding} = erl_eval:expr(Fun, [], LocalHandler, ExternalHandler),
+  Result.
+
+%% Converts Elixir quoted literals to Erlang AST.
+elixir_to_erl(Tree) ->
+  elixir_to_erl(Tree, erl_anno:new(0)).
+
+elixir_to_erl(Tree, Ann) when is_tuple(Tree) ->
+  {tuple, Ann, [elixir_to_erl(X, Ann) || X <- tuple_to_list(Tree)]};
+elixir_to_erl([], Ann) ->
+  {nil, Ann};
+elixir_to_erl(<<>>, Ann) ->
+  {bin, Ann, []};
+elixir_to_erl(#{} = Map, Ann) ->
+  Assocs = [{map_field_assoc, Ann, elixir_to_erl(K, Ann), elixir_to_erl(V, Ann)}
+            || {K, V} <- lists:sort(maps:to_list(Map))],
+  {map, Ann, Assocs};
+elixir_to_erl(Tree, Ann) when is_list(Tree) ->
+  elixir_to_erl_cons(Tree, Ann);
+elixir_to_erl(Tree, Ann) when is_atom(Tree) ->
+  {atom, Ann, Tree};
+elixir_to_erl(Tree, Ann) when is_integer(Tree) ->
+  {integer, Ann, Tree};
+elixir_to_erl(Tree, Ann) when is_float(Tree), Tree == 0.0 ->
+   % 0.0 needs to be rewritten as the AST for +0.0 in matches
+   Op =
+    case <<Tree/float>> of
+        <<1:1,_:63>> -> '-';
+        _ -> '+'
+    end,
+  {op, Ann, Op, {float, Ann, 0.0}};
+elixir_to_erl(Tree, Ann) when is_float(Tree) ->
+  {float, Ann, Tree};
+elixir_to_erl(Tree, Ann) when is_binary(Tree) ->
+  %% Note that our binaries are UTF-8 encoded and we are converting
+  %% to a list using binary_to_list. The reason for this is that Erlang
+  %% considers a string in a binary to be encoded in latin1, so the bytes
+  %% are not changed in any fashion.
+  {bin, Ann, [{bin_element, Ann, {string, Ann, binary_to_list(Tree)}, default, default}]};
+elixir_to_erl(Tree, Ann) when is_bitstring(Tree) ->
+  Segments = [elixir_to_erl_bitstring_segment(X, Ann) || X <- bitstring_to_list(Tree)],
+  {bin, Ann, Segments};
+elixir_to_erl(Tree, Ann) when is_function(Tree) ->
+  case (erlang:fun_info(Tree, type) == {type, external}) andalso
+       (erlang:fun_info(Tree, env) == {env, []}) of
+    true ->
+      {module, Module} = erlang:fun_info(Tree, module),
+      {name, Name} = erlang:fun_info(Tree, name),
+      {arity, Arity} = erlang:fun_info(Tree, arity),
+      {'fun', Ann, {function, {atom, Ann, Module}, {atom, Ann, Name}, {integer, Ann, Arity}}};
+    false ->
+      error(badarg, [Tree, Ann])
+  end;
+elixir_to_erl(Tree, Ann) when is_pid(Tree); is_port(Tree); is_reference(Tree) ->
+  ?remote(Ann, erlang, binary_to_term, [elixir_to_erl(term_to_binary(Tree), Ann)]);
+elixir_to_erl(Tree, Ann) ->
+  error(badarg, [Tree, Ann]).
+
+elixir_to_erl_cons([H | T], Ann) -> {cons, Ann, elixir_to_erl(H, Ann), elixir_to_erl_cons(T, Ann)};
+elixir_to_erl_cons(T, Ann) -> elixir_to_erl(T, Ann).
+
+elixir_to_erl_bitstring_segment(Int, Ann) when is_integer(Int) ->
+  {bin_element, Ann, {integer, Ann, Int}, default, [integer]};
+elixir_to_erl_bitstring_segment(Rest, Ann) when is_bitstring(Rest) ->
+  Size = bit_size(Rest),
+  <<Int:Size>> = Rest,
+  {bin_element, Ann, {integer, Ann, Int}, {integer, Ann, Size}, [integer]}.
+
+%% Returns a scope for translation.
+
+scope(_Meta, ExpandCaptures) ->
+  #elixir_erl{expand_captures=ExpandCaptures}.
+
+%% Static compilation hook, used in protocol consolidation
+
+consolidate(Map, Checker, TypeSpecs, DocsChunk) ->
+  {Prefix, Forms, _Def, _Defmacro, _Macros} = dynamic_form(Map, nil),
+  CheckerChunk = checker_chunk(Checker, chunk_opts(Map)),
+  load_form(Map, Prefix, Forms, TypeSpecs, DocsChunk ++ CheckerChunk).
+
+%% Dynamic compilation hook, used in regular compiler
+
+compile(#{module := Module, anno := Anno} = BaseMap, Signatures) ->
+  Map =
+    case elixir_erl_compiler:env_compiler_options() of
+      [] -> BaseMap;
+      EnvOptions -> BaseMap#{compile_opts := ?key(BaseMap, compile_opts) ++ EnvOptions}
+    end,
+
+  {Set, Bag} = elixir_module:data_tables(Module),
+
+  TranslatedTypespecs =
+    case elixir_config:is_bootstrap() andalso
+          (code:ensure_loaded(?typespecs) /= {module, ?typespecs}) of
+      true -> {[], [], [], [], []};
+      false -> ?typespecs:translate_typespecs_for_module(Set, Bag)
+    end,
+
+  MD5 = ets:lookup_element(Set, exports_md5, 2),
+  {Prefix, Forms, Def, Defmacro, Macros} = dynamic_form(Map, MD5),
+  {Types, Callbacks, TypeSpecs} = typespecs_form(Map, TranslatedTypespecs, Macros),
+
+  ChunkOpts = chunk_opts(Map),
+  DocsChunk = docs_chunk(Map, Set, Module, Anno, Def, Defmacro, Types, Callbacks, ChunkOpts),
+  CheckerChunk = checker_chunk(Map, Def, Signatures, ChunkOpts),
+  load_form(Map, Prefix, Forms, TypeSpecs, DocsChunk ++ CheckerChunk).
+
+chunk_opts(Map) ->
+  case lists:member(deterministic, ?key(Map, compile_opts)) of
+    true -> [deterministic];
+    false -> []
+  end.
+
+dynamic_form(#{module := Module, relative_file := RelativeFile,
+               attributes := Attributes, definitions := Definitions, unreachable := Unreachable,
+               deprecated := Deprecated, compile_opts := Opts} = Map, MD5) ->
+  %% TODO: Match on anno directly in Elixir v1.22+
+  Line = case Map of
+    #{anno := AnnoValue} -> erl_anno:line(AnnoValue);
+    #{line := LineValue} -> LineValue
+  end,
+
+  {Def, Defmacro, Macros, Exports, Functions} =
+    split_definition(Definitions, Unreachable, Line, [], [], [], [], {[], []}),
+
+  FilteredOpts = proplists:delete(debug_info, proplists:delete(no_warn_undefined, Opts)),
+  Location = {elixir_utils:characters_to_list(RelativeFile), Line},
+
+  Prefix = [{attribute, Line, file, Location},
+            {attribute, Line, module, Module},
+            {attribute, Line, compile, [no_auto_import | FilteredOpts]}],
+
+  Struct = maps:get(struct, Map, nil),
+  Forms0 = functions_form(Line, Module, Def, Defmacro, Exports, Functions, Deprecated, Struct, MD5),
+  Forms1 = attributes_form(Line, Attributes, Forms0),
+  {Prefix, Forms1, Def, Defmacro, Macros}.
+
+% Definitions
+
+split_definition([{Tuple, Kind, Meta, Clauses} | T], Unreachable, Line,
+                 Def, Defmacro, Macros, Exports, Functions) ->
+  case lists:member(Tuple, Unreachable) of
+    false ->
+      split_definition(Tuple, Kind, Meta, Clauses, T, Unreachable, Line,
+                       Def, Defmacro, Macros, Exports, Functions);
+    true ->
+      split_definition(T, Unreachable, Line, Def, Defmacro, Macros, Exports, Functions)
+  end;
+
+split_definition([], _Unreachable, _Line, Def, Defmacro, Macros, Exports, {Head, Tail}) ->
+  {lists:sort(Def), lists:sort(Defmacro), Macros, Exports, Head ++ Tail}.
+
+split_definition(Tuple, def, Meta, Clauses, T, Unreachable, Line,
+                 Def, Defmacro, Macros, Exports, Functions) ->
+  {_, _, N, A, _} = Entry = translate_definition(def, Line, Meta, Tuple, Clauses),
+  split_definition(T, Unreachable, Line, [{Tuple, Meta} | Def], Defmacro, Macros, [{N, A} | Exports],
+                   add_definition(Meta, Entry, Functions));
+
+split_definition(Tuple, defp, Meta, Clauses, T, Unreachable, Line,
+                 Def, Defmacro, Macros, Exports, Functions) ->
+  Entry = translate_definition(defp, Line, Meta, Tuple, Clauses),
+  split_definition(T, Unreachable, Line, Def, Defmacro, Macros, Exports,
+                   add_definition(Meta, Entry, Functions));
+
+split_definition(Tuple, defmacro, Meta, Clauses, T, Unreachable, Line,
+                 Def, Defmacro, Macros, Exports, Functions) ->
+  {_, _, N, A, _} = Entry = translate_definition(defmacro, Line, Meta, Tuple, Clauses),
+  split_definition(T, Unreachable, Line, Def, [{Tuple, Meta} | Defmacro], [Tuple | Macros], [{N, A} | Exports],
+                   add_definition(Meta, Entry, Functions));
+
+split_definition(Tuple, defmacrop, Meta, Clauses, T, Unreachable, Line,
+                 Def, Defmacro, Macros, Exports, Functions) ->
+  Entry = translate_definition(defmacro, Line, Meta, Tuple, Clauses),
+  split_definition(T, Unreachable, Line, Def, Defmacro, [Tuple | Macros], Exports,
+                   add_definition(Meta, Entry, Functions)).
+
+add_definition(Meta, Body, {Head, Tail}) ->
+  case lists:keyfind(file, 1, Meta) of
+    {file, {F, L}} ->
+      %% Erlang's epp attempts to perform offsetting when generated is set to true
+      %% and that causes cover to fail when processing modules. Therefore we never
+      %% pass the generated annotation forward for file attributes. The function
+      %% will still be marked as generated though if that's the case.
+      FileMeta = erl_anno:set_generated(false, ?ann(Meta)),
+      Attr = {attribute, FileMeta, file, {elixir_utils:characters_to_list(F), L}},
+      {Head, [Attr, Body | Tail]};
+    false ->
+      {[Body | Head], Tail}
+  end.
+
+translate_definition(Kind, Line, Meta, {Name, Arity}, Clauses) ->
+  ErlClauses = [translate_clause(Kind, Line, Clause, false) || Clause <- Clauses],
+
+  case is_macro(Kind) of
+    true -> {function, ?ann(Meta), elixir_utils:macro_name(Name), Arity + 1, ErlClauses};
+    false -> {function, ?ann(Meta), Name, Arity, ErlClauses}
+  end.
+
+translate_clause(Kind, Line, {Meta, Args, Guards, Body}, ExpandCaptures) ->
+  S = scope(Meta, ExpandCaptures),
+
+  %% If the line matches the module line, then it is most likely an
+  %% auto-generated function and we don't want to track its contents.
+  Ann =
+    case ?line(Meta) of
+      Line -> erl_anno:set_generated(true, erl_anno:new(0));
+      _ -> ?ann(Meta)
+    end,
+
+  {TClause, TS} =
+    elixir_erl_clauses:clause(Ann, fun elixir_erl_pass:translate_args/3, Args, Body, Guards, S),
+
+  case is_macro(Kind) of
+    true ->
+      FArgs = {var, Ann, '_@CALLER'},
+      MClause = setelement(3, TClause, [FArgs | element(3, TClause)]),
+
+      case TS#elixir_erl.caller of
+        true  ->
+          FBody = {'match', Ann,
+            {'var', Ann, '__CALLER__'},
+            ?remote(Ann, elixir_env, to_caller, [{var, Ann, '_@CALLER'}])
+          },
+          setelement(5, MClause, [FBody | element(5, TClause)]);
+        false ->
+          MClause
+      end;
+    false ->
+      TClause
+  end.
+
+is_macro(defmacro)  -> true;
+is_macro(defmacrop) -> true;
+is_macro(_)         -> false.
+
+% Functions
+
+functions_form(Line, Module, Def, Defmacro, Exports, Body, Deprecated, Struct, MD5) ->
+  {Spec, Info} = add_info_function(Line, Module, Def, Defmacro, Deprecated, Struct, MD5),
+  [{attribute, Line, export, lists:usort([{'__info__', 1} | Exports])}, Spec, Info | Body].
+
+add_info_function(Line, Module, Def, Defmacro, Deprecated, Struct, MD5) ->
+  DefNA = [NA || {NA, _Meta} <- Def],
+  DefmacroNA = [NA || {NA, _Meta} <- Defmacro],
+
+  AllowedAttrs = [attributes, compile, functions, macros, md5, exports_md5, module, deprecated, struct],
+  AllowedArgs = lists:map(fun(Atom) -> {atom, Line, Atom} end, AllowedAttrs),
+
+  Spec =
+    {attribute, Line, spec, {{'__info__', 1},
+      [{type, Line, 'fun', [
+        {type, Line, product, [
+          {type, Line, union, AllowedArgs}
+        ]},
+        {type, Line, any, []}
+      ]}]
+    }},
+
+  Info =
+    {function, 0, '__info__', 1, [
+      get_module_info(Module),
+      functions_info(DefNA),
+      macros_info(DefmacroNA),
+      struct_info(Struct),
+      exports_md5_info(MD5, DefNA, DefmacroNA, Struct),
+      get_module_info(Module, attributes),
+      get_module_info(Module, compile),
+      get_module_info(Module, md5),
+      deprecated_info(Deprecated)
+    ]},
+
+  {Spec, Info}.
+
+get_module_info(Module) ->
+  {clause, 0, [{atom, 0, module}], [], [{atom, 0, Module}]}.
+
+exports_md5_info(MD5Attr, Def, Defmacro, Struct) ->
+  MD5 = if
+    is_binary(MD5Attr) -> MD5Attr;
+    MD5Attr =:= nil -> elixir_module:exports_md5(Def, Defmacro, Struct)
+  end,
+  {clause, 0, [{atom, 0, exports_md5}], [], [elixir_to_erl(MD5)]}.
+
+functions_info(Def) ->
+  {clause, 0, [{atom, 0, functions}], [], [elixir_to_erl(Def)]}.
+
+macros_info(Defmacro) ->
+  {clause, 0, [{atom, 0, macros}], [], [elixir_to_erl(Defmacro)]}.
+
+struct_info(nil) ->
+  {clause, 0, [{atom, 0, struct}], [], [{atom, 0, nil}]};
+struct_info(Fields) ->
+  {clause, 0, [{atom, 0, struct}], [], [elixir_to_erl(Fields)]}.
+
+get_module_info(Module, Key) ->
+  Call = ?remote(0, erlang, get_module_info, [{atom, 0, Module}, {var, 0, 'Key'}]),
+  {clause, 0, [{match, 0, {var, 0, 'Key'}, {atom, 0, Key}}], [], [Call]}.
+
+deprecated_info(Deprecated) ->
+  {clause, 0, [{atom, 0, deprecated}], [], [elixir_to_erl(Deprecated)]}.
+
+% Typespecs
+
+typespecs_form(Map, TranslatedTypespecs, MacroNames) ->
+  {Types, Specs, Callbacks, MacroCallbacks, OptionalCallbacks} = TranslatedTypespecs,
+
+  AllCallbacks = Callbacks ++ MacroCallbacks,
+  MacroCallbackNames = [NameArity || {_, NameArity, _, _} <- MacroCallbacks],
+  validate_behaviour_info_and_attributes(Map, AllCallbacks),
+  validate_optional_callbacks(Map, AllCallbacks, OptionalCallbacks),
+
+  Forms0 = [],
+  Forms1 = types_form(Types, Forms0),
+  Forms2 = callspecs_form(spec, Specs, [], MacroNames, Forms1, Map),
+  Forms3 = callspecs_form(callback, AllCallbacks, OptionalCallbacks, MacroCallbackNames, Forms2, Map),
+
+  AllCallbacksWithoutSpecs = usort_callbacks([
+    {{Kind, Name, Arity}, Meta} || {Kind, {Name, Arity}, Meta, _Spec} <- AllCallbacks
+  ]),
+
+  {Types, AllCallbacksWithoutSpecs, Forms3}.
+
+usort_callbacks(Callbacks) ->
+  % Sort and deduplicate callbacks. For duplicated callbacks we take
+  % the one with earliest line.
+
+  LineComparator = fun
+    ({Callback1, Meta1}, {Callback1, Meta2}) -> ?line(Meta1) =< ?line(Meta2);
+    ({Callback1, _Meta1}, {Callback2, _Meta2}) -> Callback1 =< Callback2
+  end,
+
+  UniqFun = fun({Callback, _Meta}) -> Callback end,
+
+  lists:uniq(UniqFun, lists:sort(LineComparator, Callbacks)).
+
+%% Types
+
+types_form(Types, Forms) ->
+  Fun = fun
+    ({Kind, NameArity, Meta, Expr, true}, Acc) ->
+      Line = ?line(Meta),
+      [{attribute, Line, export_type, [NameArity]}, {attribute, Line, Kind, Expr} | Acc];
+    ({Kind, _NameArity, Meta, Expr, false}, Acc) ->
+      Line = ?line(Meta),
+      [{attribute, Line, Kind, Expr} | Acc]
+  end,
+
+  lists:foldl(Fun, Forms, Types).
+
+%% Specs and callbacks
+
+validate_behaviour_info_and_attributes(#{definitions := Defs} = Map, AllCallbacks) ->
+  case {lists:keyfind({behaviour_info, 1}, 1, Defs), AllCallbacks} of
+    {false, _} ->
+      ok;
+    {_, [{Kind, {Name, Arity}, _, _} | _]} when Kind == callback; Kind == macrocallback ->
+      file_error(Map, {callbacks_but_also_behaviour_info, {Kind, Name, Arity}});
+    {_, _} ->
+      ok
+  end.
+
+validate_optional_callbacks(Map, AllCallbacks, Optional) ->
+  lists:foldl(fun(Callback, Acc) ->
+    case Callback of
+      {Name, Arity} when is_atom(Name) and is_integer(Arity) -> ok;
+      _ -> file_error(Map, {ill_defined_optional_callback, Callback})
+    end,
+
+    case lists:keyfind(Callback, 2, AllCallbacks) of
+      false -> file_error(Map, {unknown_callback, Callback});
+      _ -> ok
+    end,
+
+    case Acc of
+      #{Callback := _} -> file_error(Map, {duplicate_optional_callback, Callback});
+      _ -> ok
+    end,
+
+    maps:put(Callback, true, Acc)
+  end, #{}, Optional).
+
+callspecs_form(_Kind, [], _Optional, _Macros, Forms, _ModuleMap) ->
+  Forms;
+callspecs_form(Kind, Entries, Optional, Macros, Forms, ModuleMap) ->
+  #{unreachable := Unreachable} = ModuleMap,
+
+  {SpecsMap, Signatures} =
+    lists:foldl(fun({_, NameArity, Meta, Spec}, {Acc, NA}) ->
+      Line = ?line(Meta),
+
+      case Kind of
+        spec -> validate_spec_for_existing_function(ModuleMap, NameArity, Line);
+        _ -> ok
+      end,
+
+      case lists:member(NameArity, Unreachable) of
+        false ->
+          case Acc of
+            #{NameArity := List} -> {Acc#{NameArity := [{Spec, Line} | List]}, NA};
+            #{} -> {Acc#{NameArity => [{Spec, Line}]}, [NameArity | NA]}
+          end;
+        true ->
+          {Acc, NA}
+      end
+    end, {#{}, []}, Entries),
+
+  lists:foldl(fun(NameArity, Acc) ->
+    #{NameArity := ExprsLines} = SpecsMap,
+    {Exprs, Lines} = lists:unzip(ExprsLines),
+    Line = lists:min(Lines),
+
+    {Key, Value} =
+      case lists:member(NameArity, Macros) of
+        true ->
+          {Name, Arity} = NameArity,
+          {{elixir_utils:macro_name(Name), Arity + 1},
+           lists:map(fun spec_for_macro/1, Exprs)};
+        false ->
+          {NameArity, Exprs}
+      end,
+
+    case lists:member(NameArity, Optional) of
+      true ->
+        [{attribute, Line, Kind, {Key, lists:reverse(Value)}},
+         {attribute, Line, optional_callbacks, [Key]} | Acc];
+      false ->
+        [{attribute, Line, Kind, {Key, lists:reverse(Value)}} | Acc]
+    end
+  end, Forms, lists:usort(Signatures)).
+
+spec_for_macro({type, Line, 'bounded_fun', [H | T]}) ->
+  {type, Line, 'bounded_fun', [spec_for_macro(H) | T]};
+spec_for_macro({type, Line, 'fun', [{type, _, product, Args} | T]}) ->
+  {type, Line, 'fun', [{type, Line, product, [{type, Line, term, []} | Args]} | T]};
+spec_for_macro(Else) ->
+  Else.
+
+validate_spec_for_existing_function(ModuleMap, NameAndArity, Line) ->
+  #{definitions := Defs, file := File} = ModuleMap,
+
+  case lists:keymember(NameAndArity, 1, Defs) of
+    true -> ok;
+    false -> file_error(#{anno => erl_anno:new(Line), file => File}, {spec_for_undefined_function, NameAndArity})
+  end.
+
+% Attributes
+
+attributes_form(Line, Attributes, Forms) ->
+  Fun = fun({Key, Value}, Acc) -> [{attribute, Line, Key, Value} | Acc] end,
+  lists:foldr(Fun, Forms, Attributes).
+
+% Loading forms
+
+load_form(#{file := File, compile_opts := Opts} = Map, Prefix, Forms, Specs, Chunks) ->
+  CompileOpts = extra_chunks_opts(Chunks, debug_opts(Map, Specs, Opts)),
+  {_, Binary} = elixir_erl_compiler:noenv_forms(Prefix ++ Specs ++ Forms, File, CompileOpts),
+  Binary.
+
+debug_opts(Map, Specs, Opts) ->
+  case take_debug_opts(Opts) of
+    {true, Rest} -> [{debug_info, {?MODULE, {elixir_v1, Map, Specs}}} | Rest];
+    {false, Rest} -> [{debug_info, {?MODULE, none}} | Rest]
+  end.
+
+take_debug_opts(Opts) ->
+  case proplists:get_value(debug_info, Opts) of
+    true -> {true, proplists:delete(debug_info, Opts)};
+    false -> {false, proplists:delete(debug_info, Opts)};
+    undefined -> {elixir_config:get(debug_info), Opts}
+  end.
+
+extra_chunks_opts([], Opts) -> Opts;
+extra_chunks_opts(Chunks, Opts) -> [{extra_chunks, Chunks} | Opts].
+
+docs_chunk(Map, Set, Module, Anno, Def, Defmacro, Types, Callbacks, ChunkOpts) ->
+  #{file := File, attributes := Attributes} = Map,
+
+  case elixir_config:get(docs) of
+    true ->
+      {ModuleDocLine, ModuleDoc} = get_moduledoc(erl_anno:line(Anno), Set),
+      ModuleDocMeta = get_moduledoc_meta(Set),
+      FunctionDocs = get_docs(Set, Module, Def, function),
+      MacroDocs = get_docs(Set, Module, Defmacro, macro),
+      CallbackDocs = get_callback_docs(Set, Callbacks),
+      TypeDocs = get_type_docs(Set, Types),
+
+      ModuleMeta = ModuleDocMeta#{
+        source_path => elixir_utils:characters_to_list(File),
+        source_annos => [Anno],
+        behaviours => [Mod || {behaviour, Mod} <- Attributes]
+      },
+
+      DocsChunkData = term_to_binary({docs_v1,
+        erl_anno:new(ModuleDocLine),
+        elixir,
+        <<"text/markdown">>,
+        ModuleDoc,
+        ModuleMeta,
+        FunctionDocs ++ MacroDocs ++ CallbackDocs ++ TypeDocs
+      }, [compressed | ChunkOpts]),
+
+      [{<<"Docs">>, DocsChunkData}];
+
+    false ->
+      []
+  end.
+
+doc_value(Doc, Name) ->
+  case Doc of
+    false ->
+      hidden;
+    nil ->
+      case erlang:atom_to_list(Name) of
+        [$_ | _] -> hidden;
+        _ -> none
+      end;
+    Doc ->
+      #{<<"en">> => Doc}
+  end.
+
+get_moduledoc(Line, Set) ->
+  case ets:lookup_element(Set, moduledoc, 2) of
+    nil -> {Line, none};
+    {DocLine, false} -> {DocLine, hidden};
+    {DocLine, nil} -> {DocLine, none};
+    {DocLine, Doc} -> {DocLine, #{<<"en">> => Doc}}
+  end.
+
+get_moduledoc_meta(Set) ->
+  case ets:lookup(Set, {moduledoc, meta}) of
+    [] -> #{};
+    [{{moduledoc, meta}, Map}] when is_map(Map) -> Map
+  end.
+
+get_docs(Set, Module, Definitions, Kind) ->
+  [{Key,
+    erl_anno:new(Line),
+    [signature_to_binary(Module, Name, Signature)],
+    doc_value(Doc, Name),
+    Meta#{source_annos => [?ann(DefinitionMeta)]}
+   } || {{Name, Arity}, DefinitionMeta} <- Definitions,
+        {Key, _Ctx, Line, Signature, Doc, Meta} <- ets:lookup(Set, {Kind, Name, Arity})].
+
+get_callback_docs(Set, Callbacks) ->
+  [{Key,
+    erl_anno:new(Line),
+    [],
+    doc_value(Doc, Name),
+    Meta#{source_annos => [?ann(DefinitionMeta)]}
+   } || {{Kind, Name, Arity}, DefinitionMeta} <- Callbacks, {Key, Line, Doc, Meta} <- ets:lookup(Set, {Kind, Name, Arity})].
+
+get_type_docs(Set, Types) ->
+  [{Key,
+    erl_anno:new(Line),
+    [],
+    doc_value(Doc, Name),
+    Meta#{source_annos => [?ann(DefinitionMeta)]}
+   } || {_Kind, {Name, Arity}, DefinitionMeta, _, true} <- Types,
+        {Key, Line, Doc, Meta} <- ets:lookup(Set, {type, Name, Arity})].
+
+signature_to_binary(_Module, Name, _Signature) when Name == '__aliases__'; Name == '__block__' ->
+  <<(atom_to_binary(Name))/binary, "(args)">>;
+
+signature_to_binary(_Module, fn, _Signature) ->
+  <<"fn(clauses)">>;
+
+signature_to_binary(_Module, Name, _Signature)
+    when Name == '__CALLER__'; Name == '__DIR__'; Name == '__ENV__';
+         Name == '__MODULE__'; Name == '__STACKTRACE__'; Name == '%{}' ->
+  atom_to_binary(Name);
+
+signature_to_binary(_Module, '%', _) ->
+  <<"%struct{}">>;
+
+signature_to_binary(Module, '__struct__', []) ->
+  <<"%", ('Elixir.Kernel':inspect(Module))/binary, "{}">>;
+
+signature_to_binary(_, Name, Signature) ->
+  Quoted = {Name, [{closing, []}], Signature},
+  Doc = 'Elixir.Inspect.Algebra':format('Elixir.Code':quoted_to_algebra(Quoted), infinity),
+  'Elixir.IO':iodata_to_binary(Doc).
+
+checker_chunk(nil, _ChunkOpts) ->
+  [];
+checker_chunk(Contents, ChunkOpts) ->
+  [{<<"ExCk">>, term_to_binary({checker_version(), Contents}, ChunkOpts)}].
+
+checker_chunk(Map, Def, Signatures, ChunkOpts) ->
+  #{deprecated := Deprecated, defines_behaviour := DefinesBehaviour, attributes := Attributes} = Map,
+  DeprecatedMap = maps:from_list(Deprecated),
+
+  Exports =
+    [begin
+      Signature = maps:get(FA, Signatures, none),
+      Info = case DeprecatedMap of
+        #{FA := Reason} -> #{deprecated => Reason, sig => Signature};
+        #{} -> #{sig => Signature}
+      end,
+      {FA, Info}
+    end || {FA, _Meta} <- prepend_behaviour_info(DefinesBehaviour, Def)],
+
+  Contents = #{
+    exports => Exports,
+    mode => case lists:keymember('__protocol__', 1, Attributes) of
+      true -> protocol;
+      false -> elixir
+    end
+  },
+
+  checker_chunk(Contents, ChunkOpts).
+
+prepend_behaviour_info(true, Def) -> [{{behaviour_info, 1}, []} | Def];
+prepend_behaviour_info(false, Def) -> Def.
+
+%% Errors
+
+file_error(#{anno := Anno, file := File}, Error) ->
+  Line = erl_anno:line(Anno),
+  elixir_errors:file_error([{line, Line}], File, ?MODULE, Error).
+
+format_error({ill_defined_optional_callback, Callback}) ->
+  io_lib:format("invalid optional callback ~ts. @optional_callbacks expects a "
+                "keyword list of callback names and arities", ['Elixir.Kernel':inspect(Callback)]);
+format_error({unknown_callback, {Name, Arity}}) ->
+  io_lib:format("unknown callback ~ts/~B given as optional callback", [Name, Arity]);
+format_error({duplicate_optional_callback, {Name, Arity}}) ->
+  io_lib:format("~ts/~B has been specified as optional callback more than once", [Name, Arity]);
+format_error({callbacks_but_also_behaviour_info, {Type, Fun, Arity}}) ->
+  io_lib:format("cannot define @~ts attribute for ~ts/~B when behaviour_info/1 is defined",
+                [Type, Fun, Arity]);
+format_error({spec_for_undefined_function, {Name, Arity}}) ->
+  io_lib:format("spec for undefined function ~ts/~B", [Name, Arity]).
diff --git a/lib/elixir/src/elixir_erl_clauses.erl b/lib/elixir/src/elixir_erl_clauses.erl
new file mode 100644
index 00000000000..a24e857e647
--- /dev/null
+++ b/lib/elixir/src/elixir_erl_clauses.erl
@@ -0,0 +1,69 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+%% Handle code related to args, guard and -> matching for case,
+%% fn, receive and friends. try is handled in elixir_erl_try.
+-module(elixir_erl_clauses).
+-export([match/4, clause/6, clauses/2, guards/4, get_clauses/3]).
+-include("elixir.hrl").
+
+%% Get clauses under the given key.
+
+get_clauses(Key, Keyword, As) ->
+  case lists:keyfind(Key, 1, Keyword) of
+    {Key, Clauses} when is_list(Clauses) ->
+      [{As, Meta, Left, Right} || {'->', Meta, [Left, Right]} <- Clauses];
+    _ ->
+      []
+  end.
+
+%% Translate matches
+
+match(Ann, Fun, Match, #elixir_erl{context=Context} = S) when Context =/= match ->
+  {Result, NewS} = Fun(Match, Ann, S#elixir_erl{context=match}),
+  {Result, NewS#elixir_erl{context=Context}};
+match(Ann, Fun, Match, S) ->
+  Fun(Match, Ann, S).
+
+%% Translate clauses with args, guards and expressions
+
+clause(Ann, Fun, Match, Expr, Guards, S) ->
+  {TMatch, SA} = match(Ann, Fun, Match, S),
+  SG = SA#elixir_erl{extra_guards=[]},
+  TGuards = guards(Ann, Guards, SA#elixir_erl.extra_guards, SG),
+  {TExpr, SE} = elixir_erl_pass:translate(Expr, Ann, SG),
+  {{clause, Ann, TMatch, TGuards, unblock(TExpr)}, SE}.
+
+% Translate/Extract guards from the given expression.
+
+guards(Ann, Guards, Extra, S) ->
+  SG = S#elixir_erl{context=guard},
+  case Guards of
+    [] -> case Extra of [] -> []; _ -> [Extra] end;
+    _  -> [translate_guard(Guard, Ann, SG, Extra) || Guard <- Guards]
+  end.
+
+translate_guard(Guard, Ann, S, Extra) ->
+  [element(1, elixir_erl_pass:translate(Guard, Ann, S)) | Extra].
+
+% Function for translating macros with match style like case and receive.
+
+clauses([], S) ->
+  {[], S};
+
+clauses(Clauses, S) ->
+  lists:mapfoldl(fun each_clause/2, S, Clauses).
+
+each_clause({match, Meta, [Condition], Expr}, S) ->
+  {Arg, Guards} = elixir_utils:extract_guards(Condition),
+  clause(?ann(Meta), fun elixir_erl_pass:translate_args/3, [Arg], Expr, Guards, S);
+
+each_clause({expr, Meta, [Condition], Expr}, S) ->
+  Ann = ?ann(Meta),
+  {TCondition, SC} = elixir_erl_pass:translate(Condition, Ann, S),
+  {TExpr, SB} = elixir_erl_pass:translate(Expr, Ann, SC),
+  {{clause, Ann, [TCondition], [], unblock(TExpr)}, SB}.
+
+unblock({'block', _, Exprs}) -> Exprs;
+unblock(Exprs) -> [Exprs].
diff --git a/lib/elixir/src/elixir_erl_compiler.erl b/lib/elixir/src/elixir_erl_compiler.erl
new file mode 100644
index 00000000000..3982b84ae35
--- /dev/null
+++ b/lib/elixir/src/elixir_erl_compiler.erl
@@ -0,0 +1,191 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+-module(elixir_erl_compiler).
+-export([spawn/1, noenv_forms/3, erl_to_core/2, env_compiler_options/0]).
+-include("elixir.hrl").
+
+spawn(Fun) ->
+  CompilerInfo = get(elixir_compiler_info),
+  {error_handler, ErrorHandler} = erlang:process_info(self(), error_handler),
+
+  CodeDiagnostics =
+    case get(elixir_code_diagnostics) of
+      undefined -> undefined;
+      {_Tail, Log} -> {[], Log}
+    end,
+
+  {_, Ref} =
+    spawn_monitor(fun() ->
+      erlang:process_flag(error_handler, ErrorHandler),
+      put(elixir_compiler_info, CompilerInfo),
+      put(elixir_code_diagnostics, CodeDiagnostics),
+
+      try Fun() of
+        Result -> exit({ok, Result, get(elixir_code_diagnostics)})
+      catch
+        Kind:Reason:Stack ->
+          exit({Kind, Reason, Stack, get(elixir_code_diagnostics)})
+      end
+    end),
+
+  receive
+    {'DOWN', Ref, process, _, {ok, Result, Diagnostics}} ->
+      copy_diagnostics(Diagnostics),
+      Result;
+    {'DOWN', Ref, process, _, {Kind, Reason, Stack, Diagnostics}} ->
+      copy_diagnostics(Diagnostics),
+      erlang:raise(Kind, Reason, Stack)
+  end.
+
+copy_diagnostics(undefined) ->
+  ok;
+copy_diagnostics({Head, _}) ->
+  case get(elixir_code_diagnostics) of
+    undefined -> ok;
+    {Tail, Log} -> put(elixir_code_diagnostics, {Head ++ Tail, Log})
+  end.
+
+env_compiler_options() ->
+  case persistent_term:get(?MODULE, undefined) of
+    undefined ->
+      Options = compile:env_compiler_options() -- [warnings_as_errors],
+      persistent_term:put(?MODULE, Options),
+      Options;
+
+    Options ->
+      Options
+  end.
+
+erl_to_core(Forms, Opts) ->
+  %% TODO: Remove parse transform handling on Elixir v2.0
+  case [M || {parse_transform, M} <- Opts] of
+    [] ->
+      v3_core:module(Forms, Opts);
+    _ ->
+      case compile:noenv_forms(Forms, [no_spawn_compiler_process, to_core0, return, no_auto_import | Opts]) of
+        {ok, _Module, Core, Warnings} -> {ok, Core, Warnings};
+        {error, Errors, Warnings} -> {error, Errors, Warnings}
+      end
+  end.
+
+noenv_forms(Forms, File, Opts) when is_list(Forms), is_list(Opts), is_binary(File) ->
+  Source = elixir_utils:characters_to_list(File),
+
+  case erl_to_core(Forms, Opts) of
+    {ok, CoreForms, CoreWarnings} ->
+      format_warnings(Opts, CoreWarnings),
+      CompileOpts = [no_spawn_compiler_process, from_core, no_core_prepare,
+                     no_auto_import, return, {source, Source} | Opts],
+
+      case compile:noenv_forms(CoreForms, CompileOpts) of
+        {ok, Module, Binary, Warnings} when is_binary(Binary) ->
+          format_warnings(Opts, Warnings),
+          {Module, Binary};
+
+        {ok, Module, _, _} ->
+          incompatible_options("could not compile module ~ts", [elixir_aliases:inspect(Module)], File);
+
+        {ok, Module, _} ->
+          incompatible_options("could not compile module ~ts", [elixir_aliases:inspect(Module)], File);
+
+        {error, Errors, Warnings} ->
+          format_warnings(Opts, Warnings),
+          format_errors(Errors);
+
+        _ ->
+          incompatible_options("could not compile module", [], File)
+      end;
+
+    {error, CoreErrors, CoreWarnings} ->
+      format_warnings(Opts, CoreWarnings),
+      format_errors(CoreErrors)
+  end.
+
+incompatible_options(Prefix, Args, File) ->
+  Message = io_lib:format(
+    Prefix ++ ". We expected the compiler to return a .beam binary but "
+    "got something else. This usually happens because ERL_COMPILER_OPTIONS or @compile "
+    "was set to change the compilation outcome in a way that is incompatible with Elixir",
+    Args
+  ),
+
+  elixir_errors:compile_error([], File, Message).
+
+format_errors([]) ->
+  exit({nocompile, "compilation failed but no error was raised"});
+format_errors(Errors) ->
+  lists:foreach(fun
+    ({File, Each}) when is_list(File) ->
+      BinFile = elixir_utils:characters_to_binary(File),
+      lists:foreach(fun(Error) -> handle_file_error(BinFile, Error) end, Each);
+    ({Mod, Each}) when is_atom(Mod) ->
+      lists:foreach(fun(Error) -> handle_file_error(elixir_aliases:inspect(Mod), Error) end, Each)
+  end, Errors).
+
+format_warnings(Opts, Warnings) ->
+  NoWarnNoMatch = proplists:get_value(nowarn_nomatch, Opts, false),
+  lists:foreach(fun ({File, Each}) ->
+    BinFile = elixir_utils:characters_to_binary(File),
+    lists:foreach(fun(Warning) ->
+      handle_file_warning(NoWarnNoMatch, BinFile, Warning)
+    end, Each)
+  end, Warnings).
+
+%% Handle warnings from Erlang land
+
+%% Those we implement ourselves
+handle_file_warning(_, _File, {_Line, v3_core, {map_key_repeated, _}}) -> ok;
+handle_file_warning(_, _File, {_Line, sys_core_fold, {ignored, useless_building}}) -> ok;
+
+%% We skip all of no_match related to no_clause, clause_type, guard, shadow.
+%% Those have too little information and they overlap with the type system.
+%% We keep the remaining ones because the Erlang compiler performs analyses
+%% on literals (including numbers), which the type system does not do.
+handle_file_warning(_, _File, {_Line, sys_core_fold, {nomatch, Reason}}) when is_atom(Reason) -> ok;
+
+%% Ignore all linting errors (only come up on parse transforms)
+handle_file_warning(_, _File, {_Line, erl_lint, _}) -> ok;
+
+handle_file_warning(_, File, {Line, Module, Desc}) ->
+  Message = custom_format(Module, Desc),
+  elixir_errors:erl_warn(Line, File, Message).
+
+%% Handle warnings
+
+handle_file_error(File, {beam_validator, Desc}) ->
+  elixir_errors:compile_error([{line, 0}], File, beam_validator:format_error(Desc));
+handle_file_error(File, {Line, Module, Desc}) ->
+  Message = custom_format(Module, Desc),
+  elixir_errors:compile_error([{line, Line}], File, Message).
+
+%% Mention the capture operator in make_fun
+custom_format(sys_core_fold, {ignored, {no_effect, {erlang, make_fun, 3}}}) ->
+  "the result of the capture operator & (Function.capture/3) is never used";
+
+%% Make no_effect clauses pretty
+custom_format(sys_core_fold, {ignored, {no_effect, {erlang, F, A}}}) ->
+  {Fmt, Args} = case erl_internal:comp_op(F, A) of
+    true -> {"use of operator ~ts has no effect", [elixir_utils:erlang_comparison_op_to_elixir(F)]};
+    false ->
+      case erl_internal:bif(F, A) of
+        false -> {"the call to :erlang.~ts/~B has no effect", [F, A]};
+        true ->  {"the call to ~ts/~B has no effect", [F, A]}
+      end
+  end,
+  io_lib:format(Fmt, Args);
+
+custom_format(sys_core_fold, {nomatch, {shadow, Line, {ErlName, ErlArity}}}) ->
+  {Name, Arity} = elixir_utils:erl_fa_to_elixir_fa(ErlName, ErlArity),
+
+  io_lib:format(
+    "this clause for ~ts/~B cannot match because a previous clause at line ~B always matches",
+    [Name, Arity, Line]
+  );
+
+custom_format([], Desc) ->
+  io_lib:format("~p", [Desc]);
+
+custom_format(Module, Desc) ->
+  Module:format_error(Desc).
diff --git a/lib/elixir/src/elixir_erl_for.erl b/lib/elixir/src/elixir_erl_for.erl
new file mode 100644
index 00000000000..61e558df549
--- /dev/null
+++ b/lib/elixir/src/elixir_erl_for.erl
@@ -0,0 +1,369 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+-module(elixir_erl_for).
+-export([translate/3]).
+-include("elixir.hrl").
+
+-define(empty_map_set_pattern, {map, _, [
+    {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.MapSet'}},
+    {map_field_assoc, _, {atom, _, map}, {map, _, []}}
+  ]}).
+
+translate(Meta, Args, S) ->
+  {Cases, [{do, Expr} | Opts]} = elixir_utils:split_last(Args),
+
+  case lists:keyfind(reduce, 1, Opts) of
+    {reduce, Reduce} -> translate_reduce(Meta, Cases, Expr, Reduce, S);
+    false -> translate_into(Meta, Cases, Expr, Opts, S)
+  end.
+
+translate_reduce(Meta, Cases, Expr, Reduce, S) ->
+  Ann = ?ann(Meta),
+  {TReduce, SR} = elixir_erl_pass:translate(Reduce, Ann, S),
+  {TCases, SC} = translate_gen(Meta, Cases, [], SR),
+  CaseExpr = {'case', Meta, [ok, [{do, Expr}]]},
+  {TExpr, SE} = elixir_erl_pass:translate(CaseExpr, Ann, SC),
+
+  InnerFun = fun
+    ({'case', CaseAnn, _, CaseBlock}, InnerAcc) -> {'case', CaseAnn, InnerAcc, CaseBlock}
+  end,
+
+  build_reduce(Ann, TCases, InnerFun, TExpr, TReduce, false, SE).
+
+translate_into(Meta, Cases, Expr, Opts, S) ->
+  Ann = ?ann(Meta),
+
+  {TInto, SI} =
+    case lists:keyfind(into, 1, Opts) of
+      {into, Into} -> elixir_erl_pass:translate(Into, Ann, S);
+      false -> {false, S}
+    end,
+
+  TUniq = lists:keyfind(uniq, 1, Opts) == {uniq, true},
+
+  {TCases, SC} = translate_gen(Meta, Cases, [], SI),
+  {TExpr, SE}  = elixir_erl_pass:translate(wrap_expr_if_unused(Expr, TInto), Ann, SC),
+
+  case inline_or_into(TInto) of
+    inline -> build_inline(Ann, TCases, TExpr, TInto, TUniq, SE);
+    into -> build_into(Ann, TCases, TExpr, TInto, TUniq, SE)
+  end.
+
+%% In case we have no return, we wrap the expression
+%% in a block that returns nil.
+wrap_expr_if_unused(Expr, false) -> {'__block__', [], [Expr, nil]};
+wrap_expr_if_unused(Expr, _)  -> Expr.
+
+translate_gen(ForMeta, [{'<-', Meta, [Left, Right]} | T], Acc, S) ->
+  {TLeft, TRight, TFilters, TT, TS} = translate_gen(Meta, Left, Right, T, S),
+  TAcc = [{enum, Meta, TLeft, TRight, TFilters} | Acc],
+  translate_gen(ForMeta, TT, TAcc, TS);
+translate_gen(ForMeta, [{'<<>>', _, [{'<-', Meta, [Left, Right]}]} | T], Acc, S) ->
+  {TLeft, TRight, TFilters, TT, TS} = translate_gen(Meta, Left, Right, T, S),
+  TAcc = [{bin, Meta, TLeft, TRight, TFilters} | Acc],
+  translate_gen(ForMeta, TT, TAcc, TS);
+translate_gen(_ForMeta, [], Acc, S) ->
+  {lists:reverse(Acc), S}.
+
+translate_gen(Meta, Left, Right, T, S) ->
+  Ann = ?ann(Meta),
+  {TRight, SR} = elixir_erl_pass:translate(Right, Ann, S),
+  {LeftArgs, LeftGuards} = elixir_utils:extract_guards(Left),
+  {TLeft, SL} = elixir_erl_clauses:match(Ann, fun elixir_erl_pass:translate/3, LeftArgs,
+                                         SR#elixir_erl{extra=pin_guard}),
+
+  TLeftGuards = elixir_erl_clauses:guards(Ann, LeftGuards, [], SL),
+  ExtraGuards = [{nil, X} || X <- SL#elixir_erl.extra_guards],
+  {Filters, TT} = collect_filters(T, []),
+
+  {TFilters, TS} =
+    lists:mapfoldr(
+      fun(F, SF) -> translate_filter(F, Ann, SF) end,
+      SL#elixir_erl{extra=S#elixir_erl.extra, extra_guards=[]},
+      Filters
+    ),
+
+  %% The list of guards is kept in reverse order
+  Guards = TFilters ++ translate_guards(TLeftGuards) ++ ExtraGuards,
+  {TLeft, TRight, Guards, TT, TS}.
+
+translate_guards([]) ->
+  [];
+translate_guards([[Guards]]) ->
+  [{nil, Guards}];
+translate_guards([[Left], [Right] | Rest]) ->
+  translate_guards([[{op, element(2, Left), 'orelse', Left, Right}] | Rest]).
+
+translate_filter(Filter, Ann, S) ->
+  {TFilter, TS} = elixir_erl_pass:translate(Filter, Ann, S),
+  case elixir_utils:returns_boolean(Filter) of
+    true ->
+      {{nil, TFilter}, TS};
+    false ->
+      {Name, VS} = elixir_erl_var:build('_', TS),
+      {{{var, 0, Name}, TFilter}, VS}
+  end.
+
+collect_filters([{'<-', _, [_, _]} | _] = T, Acc) ->
+  {Acc, T};
+collect_filters([{'<<>>', _, [{'<-', _, [_, _]}]} | _] = T, Acc) ->
+  {Acc, T};
+collect_filters([H | T], Acc) ->
+  collect_filters(T, [H | Acc]);
+collect_filters([], Acc) ->
+  {Acc, []}.
+
+build_inline(Ann, Clauses, Expr, Into, Uniq, S) ->
+  case not Uniq and lists:all(fun(Clause) -> element(1, Clause) == bin end, Clauses) of
+    true  -> {build_comprehension(Ann, Clauses, Expr, Into), S};
+    false -> build_inline_each(Ann, Clauses, Expr, Into, Uniq, S)
+  end.
+
+build_inline_each(Ann, Clauses, Expr, false, Uniq, S) ->
+  InnerFun = fun(InnerExpr, _InnerAcc) -> InnerExpr end,
+  build_reduce(Ann, Clauses, InnerFun, Expr, {nil, Ann}, Uniq, S);
+build_inline_each(Ann, [{enum, _, Left = {var, _, _}, Right, [] = _Filters}], Expr, {nil, _} = _Into, false, S) ->
+  Clauses = [{clause, Ann, [Left], [], [Expr]}],
+  Args = [Right, {'fun', Ann, {clauses, Clauses}}],
+  {?remote(Ann, 'Elixir.Enum', map, Args), S};
+build_inline_each(Ann, [{enum, _, Left = {var, _, _}, Right, [] = _Filters}], Expr, {map, _, []} = _Into, false, S) ->
+  Clauses = [{clause, Ann, [Left], [], [Expr]}],
+  Args = [Right, {'fun', Ann, {clauses, Clauses}}],
+  List = ?remote(Ann, 'Elixir.Enum', map, Args),
+  {?remote(Ann, maps, from_list, [List]), S};
+build_inline_each(Ann, Clauses, Expr, {nil, _} = Into, Uniq, S) ->
+  InnerFun = fun(InnerExpr, InnerAcc) -> {cons, Ann, InnerExpr, InnerAcc} end,
+  {ReduceExpr, SR} = build_reduce(Ann, Clauses, InnerFun, Expr, Into, Uniq, S),
+  {?remote(Ann, lists, reverse, [ReduceExpr]), SR};
+build_inline_each(Ann, Clauses, Expr, {bin, _, []}, Uniq, S) ->
+  {InnerValue, SV} = build_var(Ann, S),
+  Generated = erl_anno:set_generated(true, Ann),
+
+  InnerFun = fun(InnerExpr, InnerAcc) ->
+    {'case', Ann, InnerExpr, [
+      {clause, Generated,
+       [InnerValue],
+       [[?remote(Ann, erlang, is_bitstring, [InnerValue]),
+         ?remote(Ann, erlang, is_list, [InnerAcc])]],
+       [{cons, Generated, InnerAcc, InnerValue}]},
+      {clause, Generated,
+       [InnerValue],
+       [],
+       [?remote(Ann, erlang, error, [{tuple, Ann, [{atom, Ann, badarg}, InnerValue]}])]}
+    ]}
+  end,
+
+  {ReduceExpr, SR} = build_reduce(Ann, Clauses, InnerFun, Expr, {nil, Ann}, Uniq, SV),
+  {?remote(Ann, erlang, list_to_bitstring, [ReduceExpr]), SR}.
+
+build_into(Ann, Clauses, Expr, {map, _, []}, Uniq, S) ->
+  {ReduceExpr, SR} = build_inline_each(Ann, Clauses, Expr, {nil, Ann}, Uniq, S),
+  {?remote(Ann, maps, from_list, [ReduceExpr]), SR};
+build_into(Ann, Clauses, Expr, ?empty_map_set_pattern = _Into, Uniq, S) ->
+  InnerFun = fun(InnerExpr, InnerAcc) -> {cons, Ann, InnerExpr, InnerAcc} end,
+  {ReduceExpr, SR} = build_reduce(Ann, Clauses, InnerFun, Expr, {nil, Ann}, Uniq, S),
+  {?remote(Ann, 'Elixir.MapSet', new, [ReduceExpr]), SR};
+build_into(Ann, Clauses, Expr, Into, Uniq, S) ->
+  {Fun, SF}    = build_var(Ann, S),
+  {Acc, SA}    = build_var(Ann, SF),
+  {Kind, SK}   = build_var(Ann, SA),
+  {Reason, SR} = build_var(Ann, SK),
+  {Stack, ST}  = build_var(Ann, SR),
+  {Done, SD}   = build_var(Ann, ST),
+
+  InnerFun = fun(InnerExpr, InnerAcc) ->
+    {call, Ann, Fun, [InnerAcc, pair(Ann, cont, InnerExpr)]}
+  end,
+
+  MatchExpr = {match, Ann,
+    {tuple, Ann, [Acc, Fun]},
+    ?remote(Ann, 'Elixir.Collectable', into, [Into])
+  },
+
+  {IntoReduceExpr, SN} = build_reduce(Ann, Clauses, InnerFun, Expr, Acc, Uniq, SD),
+
+  TryExpr =
+    {'try', Ann,
+      [IntoReduceExpr],
+      [{clause, Ann,
+        [Done],
+        [],
+        [{call, Ann, Fun, [Done, {atom, Ann, done}]}]}],
+      [stacktrace_clause(Ann, Fun, Acc, Kind, Reason, Stack)],
+      []},
+
+  {{block, Ann, [MatchExpr, TryExpr]}, SN}.
+
+stacktrace_clause(Ann, Fun, Acc, Kind, Reason, Stack) ->
+  {clause, Ann,
+    [{tuple, Ann, [Kind, Reason, Stack]}],
+    [],
+    [{call, Ann, Fun, [Acc, {atom, Ann, halt}]},
+     ?remote(Ann, erlang, raise, [Kind, Reason, Stack])]}.
+
+%% Helpers
+
+build_reduce(Ann, Clauses, InnerFun, Expr, Into, false, S) ->
+  {Acc, SA} = build_var(Ann, S),
+  {build_reduce_each(Clauses, InnerFun(Expr, Acc), Into, Acc, SA), SA};
+build_reduce(Ann, Clauses, InnerFun, Expr, Into, true, S) ->
+  %% Those variables are used only inside the anonymous function
+  %% so we don't need to worry about returning the scope.
+  {Acc, SA} = build_var(Ann, S),
+  {Value, SV} = build_var(Ann, SA),
+  {IntoAcc, SI} = build_var(Ann, SV),
+  {UniqAcc, SU} = build_var(Ann, SI),
+
+  NewInto = {tuple, Ann, [Into, {map, Ann, []}]},
+  AccTuple = {tuple, Ann, [IntoAcc, UniqAcc]},
+  PutUniqExpr = {map, Ann, UniqAcc, [{map_field_assoc, Ann, Value, {atom, Ann, true}}]},
+
+  InnerExpr = {block, Ann, [
+    {match, Ann, AccTuple, Acc},
+    {match, Ann, Value, Expr},
+    {'case', Ann, UniqAcc, [
+      {clause, Ann, [{map, Ann, [{map_field_exact, Ann, Value, {atom, Ann, true}}]}], [], [AccTuple]},
+      {clause, Ann, [{map, Ann, []}], [], [{tuple, Ann, [InnerFun(Value, IntoAcc), PutUniqExpr]}]}
+    ]}
+  ]},
+
+  EnumReduceCall = build_reduce_each(Clauses, InnerExpr, NewInto, Acc, SU),
+  {?remote(Ann, erlang, element, [{integer, Ann, 1}, EnumReduceCall]), SU}.
+
+build_reduce_each([{enum, Meta, Left, Right, Filters} | T], Expr, Arg, Acc, S) ->
+  Ann = ?ann(Meta),
+  True = build_reduce_each(T, Expr, Acc, Acc, S),
+  False = Acc,
+  Generated = erl_anno:set_generated(true, Ann),
+
+  Clauses0 =
+    case is_var(Left) of
+      true  -> [];
+      false ->
+        [{clause, Generated,
+          [{var, Ann, '_'}, Acc], [],
+          [False]}]
+    end,
+
+  Clauses1 =
+    [{clause, Ann,
+      [Left, Acc], [],
+      [join_filters(Generated, Filters, True, False)]} | Clauses0],
+
+  Args  = [Right, Arg, {'fun', Ann, {clauses, Clauses1}}],
+  ?remote(Ann, 'Elixir.Enum', reduce, Args);
+
+build_reduce_each([{bin, Meta, Left, Right, Filters} | T], Expr, Arg, Acc, S) ->
+  Ann = ?ann(Meta),
+  Generated  = erl_anno:set_generated(true, Ann),
+  {Tail, ST} = build_var(Ann, S),
+  {Fun, SF}  = build_var(Ann, ST),
+
+  True = build_reduce_each(T, Expr, Acc, Acc, SF),
+  False = Acc,
+  {bin, _, Elements} = Left,
+  TailElement = {bin_element, Ann, Tail, default, [bitstring]},
+
+  Clauses =
+    [{clause, Generated,
+      [{bin, Ann, [TailElement]}, Acc], [],
+      [Acc]},
+     {clause, Generated,
+      [Tail, {var, Ann, '_'}], [],
+      [?remote(Ann, erlang, error, [pair(Ann, badarg, Tail)])]}],
+
+  NoVarClauses =
+    case no_var(Generated, Elements) of
+      error ->
+        Clauses;
+
+      NoVarElements ->
+        NoVarMatch = {bin, Ann, NoVarElements ++ [TailElement]},
+        [{clause, Generated, [NoVarMatch, Acc], [], [{call, Ann, Fun, [Tail, False]}]} | Clauses]
+    end,
+
+  BinMatch = {bin, Ann, Elements ++ [TailElement]},
+  VarClauses =
+    [{clause, Ann,
+     [BinMatch, Acc], [],
+     [{call, Ann, Fun, [Tail, join_filters(Generated, Filters, True, False)]}]} | NoVarClauses],
+
+  {call, Ann,
+    {named_fun, Ann, element(3, Fun), VarClauses},
+    [Right, Arg]};
+
+build_reduce_each([], Expr, _Arg, _Acc, _S) ->
+  Expr.
+
+is_var({var, _, _}) -> true;
+is_var(_) -> false.
+
+pair(Ann, Atom, Arg) ->
+  {tuple, Ann, [{atom, Ann, Atom}, Arg]}.
+
+build_var(Ann, S) ->
+  {Name, ST} = elixir_erl_var:build('_', S),
+  {{var, Ann, Name}, ST}.
+
+no_var(ParentAnn, Elements) ->
+  try
+    [{bin_element, Ann, NoVarExpr, no_var_size(Size), Types} ||
+     {bin_element, Ann, Expr, Size, Types} <- Elements,
+     NoVarExpr <- no_var_expr(ParentAnn, Expr)]
+  catch
+    unbound_size -> error
+  end.
+
+no_var_expr(Ann, {string, _, String}) -> [{var, Ann, '_'} || _ <- String];
+no_var_expr(Ann, _) -> [{var, Ann, '_'}].
+no_var_size({var, _, _}) -> throw(unbound_size);
+no_var_size(Size) -> Size.
+
+build_comprehension(Ann, Clauses, Expr, Into) ->
+  {comprehension_kind(Into), Ann, Expr, comprehension_clause(Clauses)}.
+
+comprehension_clause([{bin, Meta, Left, Right, Filters} | T]) ->
+  Ann = ?ann(Meta),
+  [{b_generate, Ann, Left, Right}] ++
+    comprehension_filter(Ann, Filters) ++
+    comprehension_clause(T);
+comprehension_clause([]) ->
+  [].
+
+comprehension_kind(false) -> lc;
+comprehension_kind({nil, _}) -> lc;
+comprehension_kind({bin, _, []}) -> bc.
+
+inline_or_into({bin, _, []}) -> inline;
+inline_or_into({nil, _}) -> inline;
+inline_or_into(false) -> inline;
+inline_or_into(_) -> into.
+
+comprehension_filter(Ann, Filters) ->
+  [join_filter(Ann, Filter, {atom, Ann, true}, {atom, Ann, false}) ||
+   Filter <- lists:reverse(Filters)].
+
+join_filters(_Ann, [], True, _False) ->
+  True;
+join_filters(Ann, [H | T], True, False) ->
+  lists:foldl(fun(Filter, Acc) ->
+    join_filter(Ann, Filter, Acc, False)
+  end, join_filter(Ann, H, True, False), T).
+
+join_filter(Ann, {nil, Filter}, True, False) ->
+  {'case', Ann, Filter, [
+    {clause, Ann, [{atom, Ann, true}], [], [True]},
+    {clause, Ann, [{atom, Ann, false}], [], [False]}
+  ]};
+join_filter(Ann, {Var, Filter}, True, False) ->
+  Guards = [[{op, Ann, 'orelse',
+    {op, Ann, '==', Var, {atom, Ann, false}},
+    {op, Ann, '==', Var, {atom, Ann, nil}}
+  }]],
+
+  {'case', Ann, Filter, [
+    {clause, Ann, [Var], Guards, [False]},
+    {clause, Ann, [{var, Ann, '_'}], [], [True]}
+  ]}.
diff --git a/lib/elixir/src/elixir_erl_pass.erl b/lib/elixir/src/elixir_erl_pass.erl
new file mode 100644
index 00000000000..a06c8c7ffeb
--- /dev/null
+++ b/lib/elixir/src/elixir_erl_pass.erl
@@ -0,0 +1,736 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+%% Translate Elixir quoted expressions to Erlang Abstract Format.
+-module(elixir_erl_pass).
+-export([translate/3, translate_args/3, no_parens_remote/2, parens_map_field/2]).
+-include("elixir.hrl").
+
+%% =
+
+translate({'=', Meta, [{'_', _, Atom}, Right]}, _Ann, S) when is_atom(Atom) ->
+  Ann = ?ann(Meta),
+  {TRight, SR} = translate(Right, Ann, S),
+  {{match, Ann, {var, Ann, '_'}, TRight}, SR};
+
+translate({'=', Meta, [Left, Right]}, _Ann, S) ->
+  Ann = ?ann(Meta),
+  {TRight, SR} = translate(Right, Ann, S),
+  case elixir_erl_clauses:match(Ann, fun translate/3, Left, SR) of
+    {TLeft, #elixir_erl{extra_guards=ExtraGuards, context=Context} = SL0}
+        when ExtraGuards =/= [], Context =/= match ->
+      SL1 = SL0#elixir_erl{extra_guards=[]},
+      {ResultVarName, SL2} = elixir_erl_var:build('_', SL1),
+      Match = {match, Ann, TLeft, TRight},
+      Generated = erl_anno:set_generated(true, Ann),
+      ResultVar = {var, Generated, ResultVarName},
+      ResultMatch = {match, Generated, ResultVar, Match},
+      True = {atom, Generated, true},
+      Reason = {tuple, Generated, [{atom, Generated, badmatch}, ResultVar]},
+      RaiseExpr = ?remote(Generated, erlang, error, [Reason]),
+      GuardsExp = {'if', Generated, [
+        {clause, Generated, [], [ExtraGuards], [ResultVar]},
+        {clause, Generated, [], [[True]], [RaiseExpr]}
+      ]},
+      {{block, Generated, [ResultMatch, GuardsExp]}, SL2};
+
+    {TLeft, SL} ->
+      {{match, Ann, TLeft, TRight}, SL}
+  end;
+
+%% Containers
+
+translate({'{}', Meta, Args}, _Ann, S) when is_list(Args) ->
+  Ann = ?ann(Meta),
+  {TArgs, SE} = translate_args(Args, Ann, S),
+  {{tuple, Ann, TArgs}, SE};
+
+translate({'%{}', Meta, Args}, _Ann, S) when is_list(Args) ->
+  translate_map(?ann(Meta), Args, S);
+
+translate({'%', Meta, [{'^', _, [{Name, _, Context}]} = Left, Right]}, _Ann, S) when is_atom(Name), is_atom(Context) ->
+  translate_struct_var_name(?ann(Meta), Left, Right, S);
+
+translate({'%', Meta, [{Name, _, Context} = Left, Right]}, _Ann, S) when is_atom(Name), is_atom(Context) ->
+  translate_struct_var_name(?ann(Meta), Left, Right, S);
+
+translate({'%', Meta, [Left, Right]}, _Ann, S) ->
+  translate_struct(?ann(Meta), Left, Right, S);
+
+translate({'<<>>', Meta, Args}, _Ann, S) when is_list(Args) ->
+  translate_bitstring(Meta, Args, S);
+
+%% Blocks
+
+translate({'__block__', Meta, Args}, _Ann, S) when is_list(Args) ->
+  Ann = ?ann(Meta),
+  {TArgs, SA} = translate_block(Args, Ann, [], S),
+  {{block, Ann, lists:reverse(TArgs)}, SA};
+
+%% Compilation environment macros
+
+translate({'__CALLER__', Meta, Atom}, _Ann, S) when is_atom(Atom) ->
+  {{var, ?ann(Meta), '__CALLER__'}, S#elixir_erl{caller=true}};
+
+translate({'__STACKTRACE__', Meta, Atom}, _Ann, S = #elixir_erl{stacktrace=Var}) when is_atom(Atom) ->
+  {{var, ?ann(Meta), Var}, S};
+
+translate({'super', Meta, Args}, _Ann, S) when is_list(Args) ->
+  Ann = ?ann(Meta),
+
+  %% In the expanded AST, super is used to invoke a function
+  %% in the current module originated from a default clause
+  %% or a super call.
+  {TArgs, SA} = translate_args(Args, Ann, S),
+  {super, {Kind, Name}} = lists:keyfind(super, 1, Meta),
+
+  if
+    Kind == defmacro; Kind == defmacrop ->
+      MacroName = elixir_utils:macro_name(Name),
+      {{call, Ann, {atom, Ann, MacroName}, [{var, Ann, '__CALLER__'} | TArgs]}, SA#elixir_erl{caller=true}};
+    Kind == def; Kind == defp ->
+      {{call, Ann, {atom, Ann, Name}, TArgs}, SA}
+  end;
+
+%% Functions
+
+translate({'&', Meta, [{'/', _, [{{'.', _, [Remote, Fun]}, _, []}, Arity]}]}, _Ann, S)
+    when is_atom(Fun), is_integer(Arity) ->
+  Ann = ?ann(Meta),
+  {TRemote, SR} = translate(Remote, Ann, S),
+  TFun = {atom, Ann, Fun},
+  TArity = {integer, Ann, Arity},
+  {{'fun', Ann, {function, TRemote, TFun, TArity}}, SR};
+translate({'&', Meta, [{'/', _, [{Fun, _, Atom}, Arity]}]}, Ann, S)
+    when is_atom(Fun), is_atom(Atom), is_integer(Arity) ->
+  case S of
+    #elixir_erl{expand_captures=true} ->
+      {Vars, SV} = lists:mapfoldl(fun(_, Acc) ->
+        {Var, _, AccS} = elixir_erl_var:assign(Meta, Acc),
+        {Var, AccS}
+      end, S, tl(lists:seq(0, Arity))),
+      translate({'fn', Meta, [{'->', Meta, [Vars, {Fun, Meta, Vars}]}]}, Ann, SV);
+
+    #elixir_erl{expand_captures=false} ->
+      {{'fun', ?ann(Meta), {function, Fun, Arity}}, S}
+  end;
+
+translate({fn, Meta, Clauses}, _Ann, S) ->
+  Transformer = fun({'->', CMeta, [ArgsWithGuards, Expr]}, Acc) ->
+    {Args, Guards} = elixir_utils:extract_splat_guards(ArgsWithGuards),
+    elixir_erl_clauses:clause(?ann(CMeta), fun translate_fn_match/3, Args, Expr, Guards, Acc)
+  end,
+  {TClauses, NS} = lists:mapfoldl(Transformer, S, Clauses),
+  {{'fun', ?ann(Meta), {clauses, TClauses}}, NS};
+
+%% Cond
+
+translate({'cond', CondMeta, [[{do, Clauses}]]}, Ann, S) ->
+  [{'->', Meta, [[Condition], _]} = H | T] = lists:reverse(Clauses),
+
+  FirstMeta =
+    if
+      is_atom(Condition), Condition /= false, Condition /= nil -> ?generated(Meta);
+      true -> Meta
+    end,
+
+  Error = {{'.', Meta, [erlang, error]}, Meta, [cond_clause]},
+  {Case, SC} = build_cond_clauses([H | T], Error, FirstMeta, S),
+  translate(replace_case_meta(CondMeta, Case), Ann, SC);
+
+%% Case
+
+translate({'case', Meta, [Expr, Opts]}, _Ann, S) ->
+  translate_case(Meta, Expr, Opts, S);
+
+%% Try
+
+translate({'try', Meta, [Opts]}, _Ann, S) ->
+  Ann = ?ann(Meta),
+  Do = proplists:get_value('do', Opts, nil),
+  {TDo, SB} = translate(Do, Ann, S),
+
+  Catch = [Tuple || {X, _} = Tuple <- Opts, X == 'rescue' orelse X == 'catch'],
+  {TCatch, SC} = elixir_erl_try:clauses(Ann, Catch, SB),
+
+  {TAfter, SA} = case lists:keyfind('after', 1, Opts) of
+    {'after', After} ->
+      {TBlock, SAExtracted} = translate(After, Ann, SC),
+      {unblock(TBlock), SAExtracted};
+    false ->
+      {[], SC}
+  end,
+
+  Else = elixir_erl_clauses:get_clauses('else', Opts, match),
+  {TElse, SE} = elixir_erl_clauses:clauses(Else, SA),
+  {{'try', ?ann(Meta), unblock(TDo), TElse, TCatch, TAfter}, SE};
+
+%% Receive
+
+translate({'receive', Meta, [Opts]}, _Ann, S) ->
+  Do = elixir_erl_clauses:get_clauses(do, Opts, match),
+
+  case lists:keyfind('after', 1, Opts) of
+    false ->
+      {TClauses, SC} = elixir_erl_clauses:clauses(Do, S),
+      {{'receive', ?ann(Meta), TClauses}, SC};
+    _ ->
+      After = elixir_erl_clauses:get_clauses('after', Opts, expr),
+      {TClauses, SC} = elixir_erl_clauses:clauses(Do ++ After, S),
+      {FClauses, TAfter} = elixir_utils:split_last(TClauses),
+      {_, _, [FExpr], _, FAfter} = TAfter,
+      {{'receive', ?ann(Meta), FClauses, FExpr, FAfter}, SC}
+  end;
+
+%% Comprehensions and with
+
+translate({for, Meta, [_ | _] = Args}, _Ann, S) ->
+  elixir_erl_for:translate(Meta, Args, S);
+
+translate({with, Meta, [_ | _] = Args}, _Ann, S) ->
+  Ann = ?ann(Meta),
+  {Exprs, [{do, Do} | Opts]} = elixir_utils:split_last(Args),
+  {ElseClause, MaybeFun, SE} = translate_with_else(Meta, Opts, S),
+  {Case, SD} = translate_with_do(Exprs, Ann, Do, ElseClause, SE),
+
+  case MaybeFun of
+    nil -> {Case, SD};
+    FunAssign -> {{block, Ann, [FunAssign, Case]}, SD}
+  end;
+
+%% Variables
+
+translate({'^', _, [{Name, VarMeta, Kind}]}, _Ann, S) when is_atom(Name), is_atom(Kind) ->
+  {Var, VS} = elixir_erl_var:translate(VarMeta, Name, Kind, S),
+
+  case S#elixir_erl.extra of
+    pin_guard ->
+      {PinVarName, PS} = elixir_erl_var:build('_', VS),
+      Ann = ?ann(?generated(VarMeta)),
+      PinVar = {var, Ann, PinVarName},
+      Guard = {op, Ann, '=:=', Var, PinVar},
+      {PinVar, PS#elixir_erl{extra_guards=[Guard | PS#elixir_erl.extra_guards]}};
+    _ ->
+      {Var, VS}
+  end;
+
+translate({Name, Meta, Kind}, _Ann, S) when is_atom(Name), is_atom(Kind) ->
+  elixir_erl_var:translate(Meta, Name, Kind, S);
+
+%% Local calls
+
+translate({Name, Meta, Args}, _Ann, S) when is_atom(Name), is_list(Meta), is_list(Args) ->
+  Ann = ?ann(Meta),
+  {TArgs, NS} = translate_args(Args, Ann, S),
+  {{call, Ann, {atom, Ann, Name}, TArgs}, NS};
+
+%% Remote calls
+
+translate({{'.', _, [Left, Right]}, Meta, []}, _Ann, #elixir_erl{context=guard} = S)
+    when is_tuple(Left), is_atom(Right), is_list(Meta) ->
+  Ann = ?ann(Meta),
+  {TLeft, SL}  = translate(Left, Ann, S),
+  TRight = {atom, Ann, Right},
+  {?remote(Ann, erlang, map_get, [TRight, TLeft]), SL};
+
+translate({{'.', _, [Left, Right]}, Meta, []}, _Ann, S)
+  when is_tuple(Left) orelse Left =:= nil orelse is_boolean(Left), is_atom(Right), is_list(Meta) ->
+  Ann = ?ann(Meta),
+  {TLeft, SL} = translate(Left, Ann, S),
+  TRight = {atom, Ann, Right},
+
+  Generated = erl_anno:set_generated(true, Ann),
+  {InnerVar, SI} = elixir_erl_var:build('_', SL),
+  TInnerVar = {var, Generated, InnerVar},
+  {Var, SV} = elixir_erl_var:build('_', SI),
+  TVar = {var, Generated, Var},
+
+  case proplists:get_value(no_parens, Meta, false) of
+    true ->
+      {{'case', Generated, TLeft, [
+        {clause, Generated,
+          [{map, Ann, [{map_field_exact, Ann, TRight, TVar}]}],
+          [],
+          [TVar]},
+        {clause, Generated,
+          [TVar],
+          [],
+          [{'case', Generated, ?remote(Generated, elixir_erl_pass, no_parens_remote, [TVar, TRight]), [
+            {clause, Generated,
+             [{tuple, Generated, [{atom, Generated, ok}, TInnerVar]}], [], [TInnerVar]},
+            {clause, Generated,
+             [{tuple, Generated, [{atom, Generated, error}, TInnerVar]}], [], [?remote(Ann, erlang, error, [TInnerVar])]}
+          ]}]}
+      ]}, SV};
+    false ->
+      {{'case', Generated, TLeft, [
+        {clause, Generated,
+          [{map, Ann, [{map_field_exact, Ann, TRight, TVar}]}],
+          [],
+          [?remote(Generated, elixir_erl_pass, parens_map_field, [TRight, TVar])]},
+        {clause, Generated,
+          [TVar],
+          [],
+          [{call, Generated, {remote, Generated, TVar, TRight}, []}]}
+      ]}, SV}
+    end;
+
+translate({{'.', _, [Left, Right]}, Meta, Args}, _Ann, S)
+    when (is_tuple(Left) orelse is_atom(Left)), is_atom(Right), is_list(Meta), is_list(Args) ->
+  translate_remote(Left, Right, Meta, Args, S);
+
+%% Anonymous function calls
+
+translate({{'.', _, [Expr]}, Meta, Args}, _Ann, S) when is_list(Args) ->
+  Ann = ?ann(Meta),
+  {TExpr, SE} = translate(Expr, Ann, S),
+  {TArgs, SA} = translate_args(Args, Ann, SE),
+  {{call, Ann, TExpr, TArgs}, SA};
+
+%% Literals
+
+translate({Left, Right}, Ann, S) ->
+  {TLeft, SL} = translate(Left, Ann, S),
+  {TRight, SR} = translate(Right, Ann, SL),
+  {{tuple, Ann, [TLeft, TRight]}, SR};
+
+translate(List, Ann, S) when is_list(List) ->
+  translate_list(List, Ann, [], S);
+
+translate(Other, Ann, S) ->
+  {elixir_erl:elixir_to_erl(Other, Ann), S}.
+
+%% Helpers
+
+translate_case(Meta, Expr, Opts, S) ->
+  Ann = ?ann(Meta),
+  {TExpr, SE} = translate(Expr, Ann, S),
+  Clauses = elixir_erl_clauses:get_clauses(do, Opts, match),
+  RClauses =
+    %% For constructs that optimize booleans, we mark them as generated
+    %% to avoid reports from the Erlang compiler but specially Dialyzer.
+    case lists:member({optimize_boolean, true}, Meta) of
+      true -> [{N, ?generated(M), H, B} || {N, M, H, B} <- Clauses];
+      false -> Clauses
+    end,
+  {TClauses, SC} = elixir_erl_clauses:clauses(RClauses, SE),
+  {{'case', Ann, TExpr, TClauses}, SC}.
+
+translate_list([{'|', _, [Left, Right]}], Ann, List, Acc) ->
+  {TLeft, LAcc} = translate(Left, Ann, Acc),
+  {TRight, TAcc} = translate(Right, Ann, LAcc),
+  {build_list([TLeft | List], TRight, Ann), TAcc};
+translate_list([H | T], Ann, List, Acc) ->
+  {TH, TAcc} = translate(H, Ann, Acc),
+  translate_list(T, Ann, [TH | List], TAcc);
+translate_list([], Ann, List, Acc) ->
+  {build_list(List, {nil, Ann}, Ann), Acc}.
+
+build_list([H | T], Acc, Ann) ->
+  build_list(T, {cons, Ann, H, Acc}, Ann);
+build_list([], Acc, _Ann) ->
+  Acc.
+
+%% Pack a list of expressions from a block.
+unblock({'block', _, Exprs}) -> Exprs;
+unblock(Expr)                -> [Expr].
+
+translate_fn_match(Arg, Ann, S) ->
+  {TArg, TS} = translate_args(Arg, Ann, S#elixir_erl{extra=pin_guard}),
+  {TArg, TS#elixir_erl{extra=S#elixir_erl.extra}}.
+
+%% Translate args
+
+translate_args(Args, Ann, S) ->
+  lists:mapfoldl(fun
+    (Arg, SA) when is_list(Arg) ->
+      translate_list(Arg, Ann, [], SA);
+    (Arg, SA) when is_tuple(Arg) ->
+      translate(Arg, Ann, SA);
+    (Arg, SA) ->
+      {elixir_erl:elixir_to_erl(Arg, Ann), SA}
+  end, S, Args).
+
+%% Translate blocks
+
+translate_block([], _Ann, Acc, S) ->
+  {Acc, S};
+translate_block([H], Ann, Acc, S) ->
+  {TH, TS} = translate(H, Ann, S),
+  translate_block([], Ann, [TH | Acc], TS);
+translate_block([{'__block__', Meta, Args} | T], Ann, Acc, S) when is_list(Args) ->
+  {TAcc, SA} = translate_block(Args, ?ann(Meta), Acc, S),
+  translate_block(T, Ann, TAcc, SA);
+translate_block([H | T], Ann, Acc, S) ->
+  {TH, TS} = translate(H, Ann, S),
+  translate_block(T, Ann, [TH | Acc], TS).
+
+%% Cond
+
+build_cond_clauses([{'->', NewMeta, [[Condition], Body]} | T], Acc, OldMeta, S) ->
+  {NewCondition, Truthy, Other, ST} = build_truthy_clause(NewMeta, Condition, Body, S),
+  Falsy = {'->', OldMeta, [[Other], Acc]},
+  Case = {'case', NewMeta, [NewCondition, [{do, [Truthy, Falsy]}]]},
+  build_cond_clauses(T, Case, NewMeta, ST);
+build_cond_clauses([], Acc, _, S) ->
+  {Acc, S}.
+
+replace_case_meta(Meta, {'case', _, Args}) ->
+  {'case', Meta, Args};
+replace_case_meta(_Meta, Other) ->
+  Other.
+
+build_truthy_clause(Meta, Condition, Body, S) ->
+  case returns_boolean(Condition, Body) of
+    {NewCondition, NewBody} ->
+      {NewCondition, {'->', Meta, [[true], NewBody]}, false, S};
+    false ->
+      {Var, _, SV} = elixir_erl_var:assign(Meta, S),
+      Head = {'when', [], [Var,
+        {{'.', [], [erlang, 'andalso']}, [], [
+          {{'.', [], [erlang, '/=']}, [], [Var, nil]},
+          {{'.', [], [erlang, '/=']}, [], [Var, false]}
+        ]}
+      ]},
+      {Condition, {'->', Meta, [[Head], Body]}, {'_', [], nil}, SV}
+  end.
+
+%% In case a variable is defined to match in a condition
+%% but a condition returns boolean, we can replace the
+%% variable directly by the boolean result.
+returns_boolean({'=', _, [{Var, _, Ctx}, Condition]}, {Var, _, Ctx}) when is_atom(Var), is_atom(Ctx) ->
+  case elixir_utils:returns_boolean(Condition) of
+    true  -> {Condition, true};
+    false -> false
+  end;
+
+%% For all other cases, we check the condition but
+%% return both condition and body untouched.
+returns_boolean(Condition, Body) ->
+  case elixir_utils:returns_boolean(Condition) of
+    true  -> {Condition, Body};
+    false -> false
+  end.
+
+%% with
+
+translate_with_else(Meta, [], S) ->
+  Ann = ?ann(Meta),
+  {VarName, SC} = elixir_erl_var:build('_', S),
+  Var = {var, Ann, VarName},
+  Generated = erl_anno:set_generated(true, Ann),
+  {{clause, Generated, [Var], [], [Var]}, nil, SC};
+translate_with_else(Meta, [{'else', [{'->', _, [[{Var, VarMeta, Kind}], Clause]}]}], S) when is_atom(Var), is_atom(Kind) ->
+  Ann = ?ann(Meta),
+  {ElseVarErl, SV} = elixir_erl_var:translate(VarMeta, Var, Kind, S#elixir_erl{context=match}),
+  {TranslatedClause, SC} = translate(Clause, Ann, SV#elixir_erl{context=nil}),
+  Clauses = [{clause, Ann, [ElseVarErl], [], [TranslatedClause]}],
+  with_else_closure(Meta, Clauses, SC);
+translate_with_else(Meta, [{'else', Else}], S) ->
+  Generated = ?generated(Meta),
+  {RaiseVar, _, SV} = elixir_erl_var:assign(Generated, S),
+
+  RaiseExpr = {{'.', Generated, [erlang, error]}, Generated, [{else_clause, RaiseVar}]},
+  RaiseClause = {'->', Generated, [[RaiseVar], RaiseExpr]},
+
+  Clauses = elixir_erl_clauses:get_clauses('else', [{'else', Else ++ [RaiseClause]}], match),
+  {TranslatedClauses, SC} = elixir_erl_clauses:clauses(Clauses, SV#elixir_erl{extra=pin_guard}),
+  with_else_closure(Generated, TranslatedClauses, SC#elixir_erl{extra=SV#elixir_erl.extra}).
+
+with_else_closure(Meta, TranslatedClauses, S) ->
+  Ann = ?ann(Meta),
+  {_, FunErlVar, SC} = elixir_erl_var:assign(Meta, S),
+  {_, ArgErlVar, SA} = elixir_erl_var:assign(Meta, SC),
+  Generated = erl_anno:set_generated(true, Ann),
+  FunAssign = {match, Ann, FunErlVar, {'fun', Generated, {clauses, TranslatedClauses}}},
+  FunCall = {call, Ann, FunErlVar, [ArgErlVar]},
+  {{clause, Generated, [ArgErlVar], [], [FunCall]}, FunAssign, SA}.
+
+translate_with_do([{'<-', Meta, [{Var, _, Ctx} = Left, Expr]} | Rest], Ann, Do, Else, S) when is_atom(Var), is_atom(Ctx) ->
+  translate_with_do([{'=', Meta, [Left, Expr]} | Rest], Ann, Do, Else, S);
+translate_with_do([{'<-', Meta, [Left, Expr]} | Rest], _Ann, Do, Else, S) ->
+  Ann = ?ann(Meta),
+  {Args, Guards} = elixir_utils:extract_guards(Left),
+  {TExpr, SR} = translate(Expr, Ann, S),
+  {TArgs, SA} = elixir_erl_clauses:match(Ann, fun translate/3, Args, SR),
+  TGuards = elixir_erl_clauses:guards(Ann, Guards, SA#elixir_erl.extra_guards, SA),
+  {TBody, SB} = translate_with_do(Rest, Ann, Do, Else, SA#elixir_erl{extra_guards=[]}),
+  Clause = {clause, Ann, [TArgs], TGuards, unblock(TBody)},
+  {{'case', Ann, TExpr, [Clause, Else]}, SB};
+translate_with_do([Expr | Rest], Ann, Do, Else, S) ->
+  {TExpr, TS} = translate(Expr, Ann, S),
+  {TRest, RS} = translate_with_do(Rest, Ann, Do, Else, TS),
+  {{block, Ann, [TExpr | unblock(TRest)]}, RS};
+translate_with_do([], Ann, Do, _Else, S) ->
+  translate(Do, Ann, S).
+
+%% Maps and structs
+
+translate_struct_var_name(Ann, Name, Args, S0) ->
+  {{map, MapAnn, TArgs0}, S1} = translate_struct(Ann, Name, Args, S0),
+  {TArgs1, S2} = generate_struct_name_guard(TArgs0, [], S1),
+  {{map, MapAnn, TArgs1}, S2}.
+
+translate_struct(Ann, _Name, {'%{}', _, [{'|', Meta, [Update, Assocs]}]}, S) ->
+  {TUpdate, SU} = translate(Update, Ann, S),
+  translate_map(?ann(Meta), Assocs, {ok, TUpdate}, SU);
+translate_struct(Ann, Name, {'%{}', _, Assocs}, S) ->
+  translate_map(Ann, [{'__struct__', Name}] ++ Assocs, none, S).
+
+translate_map(Ann, [{'|', Meta, [Update, Assocs]}], S) ->
+  {TUpdate, SU} = translate(Update, Ann, S),
+  translate_map(?ann(Meta), Assocs, {ok, TUpdate}, SU);
+translate_map(Ann, Assocs, S) ->
+  translate_map(Ann, Assocs, none, S).
+
+translate_map(Ann, Assocs, TUpdate, #elixir_erl{extra=Extra} = S) ->
+  Op = translate_key_val_op(TUpdate, S),
+
+  {TArgs, SA} = lists:mapfoldl(fun({Key, Value}, Acc0) ->
+    {TKey, Acc1} = translate(Key, Ann, Acc0#elixir_erl{extra=map_key}),
+    {TValue, Acc2} = translate(Value, Ann, Acc1#elixir_erl{extra=Extra}),
+    {{Op, Ann, TKey, TValue}, Acc2}
+  end, S, Assocs),
+
+  build_map(Ann, TUpdate, TArgs, SA).
+
+translate_key_val_op(_TUpdate, #elixir_erl{extra=map_key}) -> map_field_assoc;
+translate_key_val_op(_TUpdate, #elixir_erl{context=match}) -> map_field_exact;
+translate_key_val_op(none, _) -> map_field_assoc;
+translate_key_val_op(_, _) -> map_field_exact.
+
+build_map(Ann, {ok, TUpdate}, TArgs, SA) -> {{map, Ann, TUpdate, TArgs}, SA};
+build_map(Ann, none, TArgs, SA) -> {{map, Ann, TArgs}, SA}.
+
+%% Translate bitstrings
+
+translate_bitstring(Meta, Args, S) ->
+  build_bitstr(Args, ?ann(Meta), S, []).
+
+build_bitstr([{'::', Meta, [H, V]} | T], Ann, S, Acc) ->
+  {Size, Types} = extract_bit_info(V, Meta, S#elixir_erl{context=nil, extra=nil}),
+  build_bitstr(T, Ann, S, Acc, H, Size, Types);
+build_bitstr([], Ann, S, Acc) ->
+  {{bin, Ann, lists:reverse(Acc)}, S}.
+
+build_bitstr(T, Ann, S, Acc, H, default, Types) when is_binary(H) ->
+  Element =
+    case requires_utf_conversion(Types) of
+      false ->
+        %% See explanation in elixir_erl:elixir_to_erl/1 to
+        %% know why we can simply convert the binary to a list.
+        {bin_element, Ann, {string, 0, binary_to_list(H)}, default, default};
+      true ->
+        %% UTF types require conversion.
+        {bin_element, Ann, {string, 0, elixir_utils:characters_to_list(H)}, default, Types}
+    end,
+  build_bitstr(T, Ann, S, [Element | Acc]);
+
+build_bitstr(T, Ann, S, Acc, H, Size, Types) ->
+  {Expr, NS} = translate(H, Ann, S),
+  build_bitstr(T, Ann, NS, [{bin_element, Ann, Expr, Size, Types} | Acc]).
+
+requires_utf_conversion([bitstring | _]) -> false;
+requires_utf_conversion([binary | _]) -> false;
+requires_utf_conversion(_) -> true.
+
+extract_bit_info({'-', _, [L, {size, _, [Size]}]}, Meta, S) ->
+  {extract_bit_size(Size, Meta, S), extract_bit_type(L, [])};
+extract_bit_info({size, _, [Size]}, Meta, S) ->
+  {extract_bit_size(Size, Meta, S), []};
+extract_bit_info(L, _Meta, _S) ->
+  {default, extract_bit_type(L, [])}.
+
+extract_bit_size(Size, Meta, S) ->
+  {TSize, _} = translate(Size, ?ann(Meta), S#elixir_erl{context=guard}),
+  TSize.
+
+extract_bit_type({'-', _, [L, R]}, Acc) ->
+  extract_bit_type(L, extract_bit_type(R, Acc));
+extract_bit_type({unit, _, [Arg]}, Acc) ->
+  [{unit, Arg} | Acc];
+extract_bit_type({Other, _, nil}, Acc) ->
+  [Other | Acc];
+%% TODO: Remove me on Elixir v2.0.
+%% Elixir v1.14 and earlier emitted an empty list
+%% and may still be processed via debug_info.
+extract_bit_type({Other, _, []}, Acc) ->
+  [Other | Acc].
+
+%% Optimizations that are specific to Erlang and change
+%% the format of the AST.
+
+translate_remote('Elixir.String.Chars', to_string, Meta, [Arg], S) ->
+  Ann = ?ann(Meta),
+  {TArg, TS} = translate(Arg, Ann, S),
+  {VarName, VS} = elixir_erl_var:build('_', TS),
+
+  Generated = erl_anno:set_generated(true, Ann),
+  Var = {var, Generated, VarName},
+  Guard = ?remote(Generated, erlang, is_binary, [Var]),
+  Slow = ?remote(Generated, 'Elixir.String.Chars', to_string, [Var]),
+  Fast = Var,
+
+  {{'case', Generated, TArg, [
+    {clause, Generated, [Var], [[Guard]], [Fast]},
+    {clause, Generated, [Var], [], [Slow]}
+  ]}, VS};
+translate_remote(maps, put, Meta, [Key, Value, Map], S) ->
+  Ann = ?ann(Meta),
+
+  case translate_args([Key, Value, Map], Ann, S) of
+    {[TKey, TValue, {map, _, InnerMap, Pairs}], TS} ->
+      {{map, Ann, InnerMap, Pairs ++ [{map_field_assoc, Ann, TKey, TValue}]}, TS};
+
+    {[TKey, TValue, {map, _, Pairs}], TS} ->
+      {{map, Ann, Pairs ++ [{map_field_assoc, Ann, TKey, TValue}]}, TS};
+
+    {[TKey, TValue, TMap], TS} ->
+      {{map, Ann, TMap, [{map_field_assoc, Ann, TKey, TValue}]}, TS}
+  end;
+translate_remote(maps, merge, Meta, [Map1, Map2], S) ->
+  Ann = ?ann(Meta),
+
+  case translate_args([Map1, Map2], Ann, S) of
+    {[{map, _, Pairs1}, {map, _, Pairs2}], TS} ->
+      {{map, Ann, Pairs1 ++ Pairs2}, TS};
+
+    {[{map, _, InnerMap1, Pairs1}, {map, _, Pairs2}], TS} ->
+      {{map, Ann, InnerMap1, Pairs1 ++ Pairs2}, TS};
+
+    {[TMap1, {map, _, Pairs2}], TS} ->
+      {{map, Ann, TMap1, Pairs2}, TS};
+
+    {[TMap1, TMap2], TS} ->
+      {{call, Ann, {remote, Ann, {atom, Ann, maps}, {atom, Ann, merge}}, [TMap1, TMap2]}, TS}
+  end;
+translate_remote(Left, Right, Meta, Args, S) ->
+  Ann = ?ann(Meta),
+
+  case rewrite_strategy(Left, Right, Args) of
+    guard_op ->
+      {TArgs, SA} = translate_args(Args, Ann, S),
+      %% Rewrite Erlang function calls as operators so they
+      %% work in guards, matches and so on.
+      case TArgs of
+        [TOne]       -> {{op, Ann, Right, TOne}, SA};
+        [TOne, TTwo] -> {{op, Ann, Right, TOne, TTwo}, SA}
+      end;
+    {inline_pure, Result} ->
+      Generated = erl_anno:set_generated(true, Ann),
+      translate(Result, Generated, S);
+    {inline_args, NewArgs} ->
+      {TLeft, SL} = translate(Left, Ann, S),
+      {TArgs, SA} = translate_args(NewArgs, Ann, SL),
+      TRight = {atom, Ann, Right},
+      {{call, Ann, {remote, Ann, TLeft, TRight}, TArgs}, SA};
+    none ->
+      {TLeft, SL} = translate(Left, Ann, S),
+      {TArgs, SA} = translate_args(Args, Ann, SL),
+      TRight = {atom, Ann, Right},
+      {{call, Ann, {remote, Ann, TLeft, TRight}, TArgs}, SA}
+  end.
+
+rewrite_strategy(erlang, Right, Args) ->
+  Arity  = length(Args),
+  case elixir_utils:guard_op(Right, Arity) of
+    true -> guard_op;
+    false -> none
+  end;
+rewrite_strategy(Left, shift, [Struct, Opts | RestArgs]) when
+  Left == 'Elixir.Date';
+  Left == 'Elixir.DateTime';
+  Left == 'Elixir.NaiveDateTime';
+  Left == 'Elixir.Time'
+->
+  case basic_type_arg(Opts) of
+    true ->
+      try
+        {inline_args, [Struct, Left:'__duration__!'(Opts) | RestArgs]}
+      catch _:_ ->
+        % fail silently, will fail at runtime
+        none
+      end;
+    false ->
+      none
+  end;
+rewrite_strategy(Left, Right, Args) ->
+  case inline_pure_function(Left, Right) andalso basic_type_arg(Args) of
+    true ->
+      try
+        {inline_pure, apply(Left, Right, Args)}
+      catch _:_ ->
+        % fail silently, will fail at runtime
+        none
+      end;
+    false ->
+      none
+  end.
+
+inline_pure_function('Elixir.Duration', 'new!') -> true;
+inline_pure_function('Elixir.MapSet', new) -> true;
+inline_pure_function('Elixir.String', length) -> true;
+inline_pure_function('Elixir.String', graphemes) -> true;
+inline_pure_function('Elixir.String', codepoints) -> true;
+inline_pure_function('Elixir.String', split) -> true;
+inline_pure_function('Elixir.Kernel', to_timeout) -> true;
+inline_pure_function('Elixir.URI', new) -> true;
+inline_pure_function('Elixir.URI', 'new!') -> true;
+inline_pure_function('Elixir.URI', parse) -> true;
+inline_pure_function('Elixir.URI', encode_query) -> true;
+inline_pure_function('Elixir.URI', encode_www_form) -> true;
+inline_pure_function('Elixir.URI', decode) -> true;
+inline_pure_function('Elixir.URI', decode_www_form) -> true;
+inline_pure_function('Elixir.Version', parse) -> true;
+inline_pure_function('Elixir.Version', 'parse!') -> true;
+inline_pure_function('Elixir.Version', parse_requirement) -> true;
+inline_pure_function('Elixir.Version', 'parse_requirement!') -> true;
+inline_pure_function(_Left, _Right) -> false.
+
+% we do not want to try and inline calls which might depend on protocols that might be overridden later
+basic_type_arg(Term) when is_number(Term); is_atom(Term); is_binary(Term) -> true;
+basic_type_arg(List) when is_list(List) -> lists:all(fun basic_type_arg/1, List);
+basic_type_arg({Left, Right}) -> basic_type_arg(Left) and basic_type_arg(Right);
+basic_type_arg(_) -> false.
+
+generate_struct_name_guard([{map_field_exact, Ann, {atom, _, '__struct__'} = Key, Var} | Rest], Acc, S0) ->
+  {ModuleVarName, S1} = elixir_erl_var:build('_', S0),
+  Generated = erl_anno:set_generated(true, Ann),
+  ModuleVar = {var, Generated, ModuleVarName},
+  Match = {match, Generated, ModuleVar, Var},
+  Guard = ?remote(Generated, erlang, is_atom, [ModuleVar]),
+  S2 = S1#elixir_erl{extra_guards=[Guard | S1#elixir_erl.extra_guards]},
+  {lists:reverse(Acc, [{map_field_exact, Ann, Key, Match} | Rest]), S2};
+generate_struct_name_guard([Field | Rest], Acc, S) ->
+  generate_struct_name_guard(Rest, [Field | Acc], S).
+
+%% TODO: Make this a runtime error on Elixir v2.0
+no_parens_remote(nil, _Key) -> {error, {badmap, nil}};
+no_parens_remote(false, _Key) -> {error, {badmap, false}};
+no_parens_remote(true, _Key) -> {error, {badmap, true}};
+no_parens_remote(Atom, Fun) when is_atom(Atom) ->
+  Message = fun() ->
+    io_lib:format(
+      "using map.field notation (without parentheses) to invoke function ~ts.~ts() is deprecated, "
+      "you must add parentheses instead: remote.function()",
+      [elixir_aliases:inspect(Atom), Fun]
+    )
+  end,
+  'Elixir.IO':warn_once(?MODULE, Message, 3),
+  {ok, apply(Atom, Fun, [])};
+no_parens_remote(#{} = Map, Key) ->
+  {error, {badkey, Key, Map}};
+no_parens_remote(Other, _Key) ->
+  {error, {badmap, Other}}.
+
+parens_map_field(Key, Value) ->
+  Message = fun() ->
+    io_lib:format(
+      "using module.function() notation (with parentheses) to fetch map field ~ts is deprecated, "
+      "you must remove the parentheses: map.field",
+      [elixir_aliases:inspect(Key)]
+    )
+  end,
+  'Elixir.IO':warn_once(?MODULE, Message, 3),
+  Value.
diff --git a/lib/elixir/src/elixir_erl_try.erl b/lib/elixir/src/elixir_erl_try.erl
new file mode 100644
index 00000000000..36780a10409
--- /dev/null
+++ b/lib/elixir/src/elixir_erl_try.erl
@@ -0,0 +1,243 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+-module(elixir_erl_try).
+-export([clauses/3]).
+-include("elixir.hrl").
+-define(REQUIRES_STACKTRACE,
+        ['Elixir.FunctionClauseError', 'Elixir.UndefinedFunctionError',
+         'Elixir.KeyError', 'Elixir.ArgumentError', 'Elixir.SystemLimitError']).
+
+clauses(_Ann, Args, S) ->
+  Catch = elixir_erl_clauses:get_clauses('catch', Args, 'catch'),
+  Rescue = elixir_erl_clauses:get_clauses(rescue, Args, rescue),
+  {StackName, SV} = elixir_erl_var:build('__STACKTRACE__', S),
+  OldStack = SV#elixir_erl.stacktrace,
+  SS = SV#elixir_erl{stacktrace=StackName},
+  reduce_clauses(Rescue ++ Catch, [], OldStack, SS, SS).
+
+reduce_clauses([H | T], Acc, OldStack, SAcc, S) ->
+  {TH, TS} = each_clause(H, SAcc),
+  reduce_clauses(T, [TH | Acc], OldStack, TS, S);
+reduce_clauses([], Acc, OldStack, SAcc, _S) ->
+  {lists:reverse(Acc), SAcc#elixir_erl{stacktrace=OldStack}}.
+
+each_clause({'catch', Meta, Raw, Expr}, S) ->
+  {Args, Guards} = elixir_utils:extract_splat_guards(Raw),
+
+  Match =
+    %% TODO: Remove me on Elixir v2.0.
+    %% Elixir v1.17 and earlier emitted single argument
+    %% and may still be processed via debug_info.
+    case Args of
+      [X] -> [throw, X];
+      [X, Y] -> [X, Y]
+    end,
+
+  {{clause, Line, [TKind, TMatches], TGuards, TBody}, TS} =
+    elixir_erl_clauses:clause(?ann(Meta), fun elixir_erl_pass:translate_args/3, Match, Expr, Guards, S),
+
+  build_clause(Line, TKind, TMatches, TGuards, TBody, TS);
+
+each_clause({rescue, Meta, [{in, _, [Left, Right]}], Expr}, S) ->
+  {TempVar, _, CS} = elixir_erl_var:assign(Meta, S),
+  {Guards, ErlangAliases} = rescue_guards(Meta, TempVar, Right),
+  Body = normalize_rescue(Meta, TempVar, Left, Expr, ErlangAliases),
+  build_rescue(Meta, TempVar, Guards, Body, CS);
+
+each_clause({rescue, Meta, [{VarName, _, Context} = Left], Expr}, S) when is_atom(VarName), is_atom(Context) ->
+  {TempVar, _, CS} = elixir_erl_var:assign(Meta, S),
+  Body = normalize_rescue(Meta, TempVar, Left, Expr, ['Elixir.ErlangError']),
+  build_rescue(Meta, TempVar, [], Body, CS).
+
+normalize_rescue(_Meta, _Var, {'_', _, Atom}, Expr, _) when is_atom(Atom) ->
+  Expr;
+normalize_rescue(Meta, Var, Pattern, Expr, []) ->
+  prepend_to_block(Meta, {'=', Meta, [Pattern, Var]}, Expr);
+normalize_rescue(Meta, Var, Pattern, Expr, ErlangAliases) ->
+  Stacktrace =
+    case lists:member('Elixir.ErlangError', ErlangAliases) of
+      true ->
+        dynamic_normalize(Meta, Var, ?REQUIRES_STACKTRACE);
+
+      false ->
+        case lists:partition(fun is_normalized_with_stacktrace/1, ErlangAliases) of
+          {[], _} -> [];
+          {_, []} -> {'__STACKTRACE__', Meta, nil};
+          {Some, _} -> dynamic_normalize(Meta, Var, Some)
+        end
+    end,
+
+  Normalized = {{'.', Meta, ['Elixir.Exception', normalize]}, Meta, [error, Var, Stacktrace]},
+  prepend_to_block(Meta, {'=', Meta, [Pattern, Normalized]}, Expr).
+
+dynamic_normalize(Meta, Var, [H | T]) ->
+  Generated = ?generated(Meta),
+
+  Guards =
+    lists:foldl(fun(Alias, Acc) ->
+      {'when', Generated, [erl_rescue_stacktrace_for(Generated, Var, Alias), Acc]}
+    end, erl_rescue_stacktrace_for(Generated, Var, H), T),
+
+  {'case', Generated, [
+    Var,
+    [{do, [
+      {'->', Generated, [[{'when', Generated, [{'_', Generated, nil}, Guards]}], {'__STACKTRACE__', Generated, nil}]},
+      {'->', Generated, [[{'_', Generated, nil}], []]}
+    ]}]
+  ]}.
+
+erl_rescue_stacktrace_for(_Meta, _Var, 'Elixir.ErlangError') ->
+  %% ErlangError is a "meta" exception, we should never expand it here.
+  error(badarg);
+erl_rescue_stacktrace_for(Meta, Var, 'Elixir.KeyError') ->
+  %% Only the two-element tuple requires stacktrace.
+  erl_and(Meta, erl_tuple_size(Meta, Var, 2), erl_record_compare(Meta, Var, badkey));
+erl_rescue_stacktrace_for(Meta, Var, Module) ->
+  erl_rescue_guard_for(Meta, Var, Module).
+
+is_normalized_with_stacktrace(Module) ->
+  lists:member(Module, ?REQUIRES_STACKTRACE).
+
+%% Helpers
+
+build_rescue(Meta, Var, Guards, Body, S) ->
+  {{clause, Line, [TMatch], TGuards, TBody}, TS} =
+    elixir_erl_clauses:clause(?ann(Meta), fun elixir_erl_pass:translate_args/3, [Var], Body, Guards, S),
+
+  build_clause(Line, {atom, Line, error}, TMatch, TGuards, TBody, TS).
+
+%% Convert rescue clauses ("var in [alias1, alias2]") into guards.
+rescue_guards(_Meta, _Var, []) ->
+  {[], []};
+rescue_guards(Meta, Var, Aliases) ->
+  {ErlangGuards, ErlangAliases} = erl_rescue(Meta, Var, Aliases, [], []),
+
+  ElixirGuards =
+    [erl_and(Meta,
+       {erl(Meta, '=='), Meta, [{erl(Meta, map_get), Meta, ['__struct__', Var]}, Alias]},
+       {erl(Meta, map_get), Meta, ['__exception__', Var]}
+     ) || Alias <- Aliases],
+
+  {ElixirGuards ++ ErlangGuards, ErlangAliases}.
+
+build_clause(Line, Kind, Expr, Guards, Body, #elixir_erl{stacktrace=Var} = TS) ->
+  Match = {tuple, Line, [Kind, Expr, {var, Line, Var}]},
+  {{clause, Line, [Match], Guards, Body}, TS}.
+
+%% Rescue each atom name considering their Erlang or Elixir matches.
+%% Matching of variables is done with Erlang exceptions is done in
+%% function for optimization.
+
+erl_rescue(Meta, Var, [H | T], Guards, Aliases) when is_atom(H) ->
+  case erl_rescue_guard_for(Meta, Var, H) of
+    false -> erl_rescue(Meta, Var, T, Guards, Aliases);
+    Expr  -> erl_rescue(Meta, Var, T, [Expr | Guards], [H | Aliases])
+  end;
+erl_rescue(_, _, [], Guards, Aliases) ->
+  {Guards, Aliases}.
+
+%% Handle Erlang rescue matches.
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.UndefinedFunctionError') ->
+  {erl(Meta, '=='), Meta, [Var, undef]};
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.FunctionClauseError') ->
+  {erl(Meta, '=='), Meta, [Var, function_clause]};
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.SystemLimitError') ->
+  {erl(Meta, '=='), Meta, [Var, system_limit]};
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.ArithmeticError') ->
+  {erl(Meta, '=='), Meta, [Var, badarith]};
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.CondClauseError') ->
+  {erl(Meta, '=='), Meta, [Var, cond_clause]};
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.BadArityError') ->
+  erl_and(Meta,
+          erl_tuple_size(Meta, Var, 2),
+          erl_record_compare(Meta, Var, badarity));
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.BadFunctionError') ->
+  erl_and(Meta,
+          erl_tuple_size(Meta, Var, 2),
+          erl_record_compare(Meta, Var, badfun));
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.MatchError') ->
+  erl_and(Meta,
+          erl_tuple_size(Meta, Var, 2),
+          erl_record_compare(Meta, Var, badmatch));
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.CaseClauseError') ->
+  erl_and(Meta,
+          erl_tuple_size(Meta, Var, 2),
+          erl_record_compare(Meta, Var, case_clause));
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.WithClauseError') ->
+  erl_and(Meta,
+          erl_tuple_size(Meta, Var, 2),
+          erl_record_compare(Meta, Var, else_clause));
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.TryClauseError') ->
+  erl_and(Meta,
+          erl_tuple_size(Meta, Var, 2),
+          erl_record_compare(Meta, Var, try_clause));
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.BadMapError') ->
+  erl_and(Meta,
+          erl_tuple_size(Meta, Var, 2),
+          erl_record_compare(Meta, Var, badmap));
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.BadBooleanError') ->
+  erl_and(Meta,
+          erl_tuple_size(Meta, Var, 3),
+          erl_record_compare(Meta, Var, badbool));
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.KeyError') ->
+  erl_and(Meta,
+          erl_or(Meta,
+            erl_tuple_size(Meta, Var, 2),
+            erl_tuple_size(Meta, Var, 3)),
+          erl_record_compare(Meta, Var, badkey));
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.ArgumentError') ->
+  erl_or(Meta,
+         {erl(Meta, '=='), Meta, [Var, badarg]},
+         erl_and(Meta,
+                 erl_tuple_size(Meta, Var, 2),
+                 erl_record_compare(Meta, Var, badarg)));
+
+erl_rescue_guard_for(Meta, Var, 'Elixir.ErlangError') ->
+  Condition =
+    erl_and(
+      Meta,
+      {erl(Meta, is_map), Meta, [Var]},
+      {erl(Meta, is_map_key), Meta, ['__exception__', Var]}
+    ),
+  {erl(Meta, 'not'), Meta, [Condition]};
+
+erl_rescue_guard_for(_, _, _) ->
+  false.
+
+%% Helpers
+
+erl_tuple_size(Meta, Var, Size) ->
+  {erl(Meta, '=='), Meta, [{erl(Meta, tuple_size), Meta, [Var]}, Size]}.
+
+erl_record_compare(Meta, Var, Expr) ->
+  {erl(Meta, '=='), Meta, [
+    {erl(Meta, element), Meta, [1, Var]},
+    Expr
+  ]}.
+
+prepend_to_block(_Meta, Expr, {'__block__', Meta, Args}) ->
+  {'__block__', Meta, [Expr | Args]};
+
+prepend_to_block(Meta, Expr, Args) ->
+  {'__block__', Meta, [Expr, Args]}.
+
+erl(Meta, Op) -> {'.', Meta, [erlang, Op]}.
+erl_or(Meta, Left, Right) -> {erl(Meta, 'orelse'), Meta, [Left, Right]}.
+erl_and(Meta, Left, Right) -> {erl(Meta, 'andalso'), Meta, [Left, Right]}.
diff --git a/lib/elixir/src/elixir_erl_var.erl b/lib/elixir/src/elixir_erl_var.erl
new file mode 100644
index 00000000000..c3f731a0479
--- /dev/null
+++ b/lib/elixir/src/elixir_erl_var.erl
@@ -0,0 +1,127 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+%% Convenience functions used to manipulate scope and its variables.
+-module(elixir_erl_var).
+-export([
+  translate/4, assign/2, build/2,
+  load_binding/2, dump_binding/4,
+  from_env/1, from_env/2
+]).
+-include("elixir.hrl").
+
+%% VAR HANDLING
+
+translate(Meta, '_', _Kind, S) ->
+  {{var, ?ann(Meta), '_'}, S};
+
+translate(Meta, Name, Kind, #elixir_erl{var_names=VarNames} = S) ->
+  {version, Version} = lists:keyfind(version, 1, Meta),
+
+  case VarNames of
+    #{Version :=  ErlName} -> {{var, ?ann(Meta), ErlName}, S};
+    #{} when Kind /= nil -> assign(Meta, '_', Version, S);
+    #{} -> assign(Meta, Name, Version, S)
+  end.
+
+assign(Meta, #elixir_erl{var_names=VarNames} = S) ->
+  Version = -(map_size(VarNames)+1),
+  ExVar = {var, [{version, Version} | Meta], ?var_context},
+  {ErlVar, SV} = assign(Meta, '_', Version, S),
+  {ExVar, ErlVar, SV}.
+
+assign(Meta, Name, Version, #elixir_erl{var_names=VarNames} = S) ->
+  {NewVar, NS} = build(Name, S),
+  NewVarNames = VarNames#{Version => NewVar},
+  {{var, ?ann(Meta), NewVar}, NS#elixir_erl{var_names=NewVarNames}}.
+
+build(Key, #elixir_erl{counter=Counter} = S) ->
+  Count =
+    case Counter of
+      #{Key := Val} -> Val + 1;
+      _ -> 1
+    end,
+  {build_name(Key, Count),
+   S#elixir_erl{counter=Counter#{Key => Count}}}.
+
+build_name('_', Count) -> list_to_atom("_@" ++ integer_to_list(Count));
+build_name(Name, Count) -> list_to_atom("_" ++ atom_to_list(Name) ++ "@" ++ integer_to_list(Count)).
+
+%% BINDINGS
+
+from_env(#{versioned_vars := Read} = Env) ->
+  VarsList = to_erl_vars(maps:values(Read), 0),
+  {VarsList, from_env(Env, maps:from_list(VarsList))}.
+
+from_env(#{context := Context}, VarsMap) ->
+  #elixir_erl{
+    context=Context,
+    var_names=VarsMap,
+    counter=#{'_' => map_size(VarsMap)}
+  }.
+
+to_erl_vars([Version | Versions], Counter) ->
+  [{Version, to_erl_var(Counter)} | to_erl_vars(Versions, Counter + 1)];
+to_erl_vars([], _Counter) ->
+  [].
+
+to_erl_var(Counter) ->
+  list_to_atom("_@" ++ integer_to_list(Counter)).
+
+load_binding(Binding, Prune) ->
+  load_binding(Binding, #{}, [], [], 0, Prune).
+
+load_binding([Binding | NextBindings], ExVars, ErlVars, Normalized, Counter, Prune) ->
+  {Pair, Value} = load_pair(Binding),
+
+  case ExVars of
+    #{Pair := VarCounter} ->
+      ErlVar = to_erl_var(VarCounter),
+      load_binding(NextBindings, ExVars, ErlVars, [{ErlVar, Value} | Normalized], Counter, Prune);
+
+    #{} ->
+      ErlVar = to_erl_var(Counter),
+
+      load_binding(
+        NextBindings,
+        ExVars#{Pair => Counter},
+        [{Counter, ErlVar} | ErlVars],
+        [{ErlVar, Value} | Normalized],
+        Counter + 1,
+        Prune
+      )
+  end;
+load_binding([], ExVars, ErlVars, Normalized, Counter, true) ->
+  load_binding([{{elixir, prune_binding}, true}], ExVars, ErlVars, Normalized, Counter, false);
+load_binding([], ExVars, ErlVars, Normalized, _Counter, false) ->
+  {ExVars, maps:from_list(ErlVars), maps:from_list(lists:reverse(Normalized))}.
+
+load_pair({Key, Value}) when is_atom(Key) -> {{Key, nil}, Value};
+load_pair({Pair, Value}) -> {Pair, Value}.
+
+dump_binding(Binding, ErlS, ExS, PruneBefore) ->
+  #elixir_erl{var_names=ErlVars} = ErlS,
+  #elixir_ex{vars={ExVars, _}, unused={Unused, _}} = ExS,
+
+  maps:fold(fun
+    ({Var, Kind} = Pair, Version, {B, V})
+    when is_atom(Kind),
+         %% If the variable is part of the pruning (usually the input binding)
+         %% and is unused, we removed it from vars.
+         Version > PruneBefore orelse is_map_key({Pair, Version}, Unused) ->
+      Key = case Kind of
+        nil -> Var;
+        _ -> Pair
+      end,
+
+      ErlName = maps:get(Version, ErlVars),
+      Value = maps:get(ErlName, Binding, nil),
+      {[{Key, Value} | B], V};
+
+    (Pair, _, {B, V}) when PruneBefore >= 0 ->
+      {B, maps:remove(Pair, V)};
+
+    (_, _, Acc) ->
+      Acc
+  end, {[], ExVars}, ExVars).
diff --git a/lib/elixir/src/elixir_errors.erl b/lib/elixir/src/elixir_errors.erl
index 84bbb6c7c3b..53b0c557c7e 100644
--- a/lib/elixir/src/elixir_errors.erl
+++ b/lib/elixir/src/elixir_errors.erl
@@ -1,217 +1,530 @@
-% A bunch of helpers to help to deal with errors in Elixir source code.
-% This is not exposed in the Elixir language.
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+%% A bunch of helpers to help to deal with errors in Elixir source code.
+%% This is not exposed in the Elixir language.
+%%
+%% Note that this is also called by the Erlang backend, so we also support
+%% the line number to be none (as it may happen in some erlang errors).
 -module(elixir_errors).
--export([compile_error/3, compile_error/4,
-  form_error/4, parse_error/4, warn/2, warn/3,
-  handle_file_warning/2, handle_file_warning/3, handle_file_error/2]).
+-export([compile_error/1, compile_error/3, parse_error/5]).
+-export([function_error/4, module_error/4, file_error/4]).
+-export([format_snippet/6]).
+-export([erl_warn/3, file_warn/4]).
+-export([prefix/1]).
+-export([print_diagnostics/1, print_diagnostic/2, emit_diagnostic/6]).
+-export([print_warning/3]).
 -include("elixir.hrl").
+-type location() :: non_neg_integer() | {non_neg_integer(), non_neg_integer()}.
+
+%% Diagnostic API
+
+%% TODO: Remove me on Elixir v2.0.
+%% Called by deprecated Kernel.ParallelCompiler.print_warning.
+print_warning(Position, File, Message) ->
+  Output = format_snippet(warning, Position, File, Message, nil, #{}),
+  io:put_chars(standard_error, [Output, $\n, $\n]).
+
+read_snippet(nil, _Position) ->
+  nil;
+read_snippet(<<"nofile">>, _Position) ->
+  nil;
+read_snippet(File, Position) ->
+  LineNumber = extract_line(Position),
+  get_file_line(File, LineNumber).
+
+get_file_line(File, LineNumber) when is_integer(LineNumber), LineNumber > 0 ->
+  case file:open(File, [read, binary]) of
+    {ok, IoDevice} ->
+      Line = traverse_file_line(IoDevice, LineNumber),
+      ok = file:close(IoDevice),
+      Line;
+    {error, _} ->
+      nil
+  end;
+get_file_line(_, _) -> nil.
 
--type line_or_meta() :: integer() | list().
-
-warn(Warning) ->
-  CompilerPid = get(elixir_compiler_pid),
-  if
-    CompilerPid =/= undefined ->
-      elixir_code_server:cast({register_warning, CompilerPid});
-    true -> false
+traverse_file_line(IoDevice, 1) ->
+  case file:read_line(IoDevice) of
+    {ok, Line} -> binary:replace(Line, <<"\n">>, <<>>);
+    _ -> nil
+  end;
+traverse_file_line(IoDevice, N) ->
+  file:read_line(IoDevice),
+  traverse_file_line(IoDevice, N - 1).
+
+%% Used by Module.ParallelChecker.
+print_diagnostics([Diagnostic | Others]) ->
+  #{file := File, position := Position, message := Message} = Diagnostic,
+  Snippet = read_snippet(File, Position),
+  Formatted = format_snippet(warning, Position, File, Message, Snippet, Diagnostic),
+  LineNumber = extract_line(Position),
+  LineDigits = get_line_number_digits(LineNumber, 1),
+  Padding = case Snippet of
+    nil -> 0;
+    _ -> max(4, LineDigits + 2)
   end,
-  io:put_chars(standard_error, Warning).
+  Locations = [["\n", n_spaces(Padding), "└─ ", 'Elixir.Exception':format_stacktrace_entry(ES)] || #{stacktrace := [ES]} <- Others],
+  io:put_chars(standard_error, [Formatted, Locations, $\n, $\n]).
+
+print_diagnostic(#{severity := S, message := M, position := P, file := F} = Diagnostic, ReadSnippet) ->
+  Snippet =
+    case ReadSnippet of
+      true -> read_snippet(F, P);
+      false -> nil
+    end,
 
-warn(Caller, Warning) ->
-  warn([Caller, "warning: ", Warning]).
+  Output = format_snippet(S, P, F, M, Snippet, Diagnostic),
 
-warn(Line, File, Warning) when is_integer(Line) ->
-  warn(file_format(Line, File, "warning: " ++ Warning)).
+  MaybeStack =
+    case (F /= nil) orelse elixir_config:is_bootstrap() of
+      true -> [];
+      false -> [["\n  ", 'Elixir.Exception':format_stacktrace_entry(E)] || E <- ?key(Diagnostic, stacktrace)]
+    end,
 
-%% Raised during expansion/translation/compilation.
+  io:put_chars(standard_error, [Output, MaybeStack, $\n, $\n]),
+  Diagnostic.
 
--spec form_error(line_or_meta(), binary(), module(), any()) -> no_return().
+emit_diagnostic(Severity, Position, File, Message, Stacktrace, Options) ->
+  ReadSnippet = proplists:get_value(read_snippet, Options, false),
 
-form_error(Meta, File, Module, Desc) ->
-  compile_error(Meta, File, format_error(Module, Desc)).
+  Span = case lists:keyfind(span, 1, Options) of
+    {span, {EndLine, EndCol}} -> {EndLine, EndCol};
+    _ -> nil
+  end,
 
--spec compile_error(line_or_meta(), binary(), iolist()) -> no_return().
--spec compile_error(line_or_meta(), binary(), iolist(), list()) -> no_return().
+  Diagnostic = #{
+    severity => Severity,
+    source => case get(elixir_compiler_file) of
+      undefined -> File;
+      CompilerFile -> CompilerFile
+    end,
+    file => File,
+    position => Position,
+    message => unicode:characters_to_binary(Message),
+    stacktrace => Stacktrace,
+    span => Span
+  },
+
+  case get(elixir_code_diagnostics) of
+    undefined ->
+      case get(elixir_compiler_info) of
+        undefined -> print_diagnostic(Diagnostic, ReadSnippet);
+        {CompilerPid, _} -> CompilerPid ! {diagnostic, Diagnostic, ReadSnippet}
+      end;
+
+    {Tail, true} ->
+      put(elixir_code_diagnostics, {[print_diagnostic(Diagnostic, ReadSnippet) | Tail], true});
+
+    {Tail, false} ->
+      put(elixir_code_diagnostics, {[Diagnostic | Tail], false})
+  end,
 
-compile_error(Meta, File, Message) when is_list(Message) ->
-  raise(Meta, File, 'Elixir.CompileError', elixir_utils:characters_to_binary(Message)).
+  ok.
+
+extract_line({L, _}) -> L;
+extract_line(L) -> L.
+
+extract_column({_, C}) -> C;
+extract_column(_) -> nil.
+
+%% Format snippets
+%% "Snippet" here refers to the source code line where the diagnostic/error occurred
+
+format_snippet(Severity, _Position, nil, Message, nil, _Diagnostic) ->
+  Formatted = [prefix(Severity), " ", Message],
+  unicode:characters_to_binary(Formatted);
+
+format_snippet(Severity, Position, File, Message, nil, Diagnostic) ->
+  Location = location_format(Position, File, maps:get(stacktrace, Diagnostic, [])),
+
+  Formatted = io_lib:format(
+    "~ts ~ts\n"
+    "└─ ~ts",
+    [prefix(Severity), Message, Location]
+   ),
+
+  unicode:characters_to_binary(Formatted);
+
+format_snippet(Severity, Position, File, Message, Snippet, Diagnostic) ->
+  Column = extract_column(Position),
+  LineNumber = extract_line(Position),
+  LineDigits = get_line_number_digits(LineNumber, 1),
+  Spacing = n_spaces(max(2, LineDigits) + 1),
+  LineNumberSpacing = if LineDigits =:= 1 -> 1; true -> 0 end,
+  {FormattedLine, ColumnsTrimmed} = format_line(Snippet),
+  Location = location_format(Position, File, maps:get(stacktrace, Diagnostic, [])),
+  MessageDetail = format_detail(Diagnostic, Message),
+
+  Highlight =
+    case Column of
+      nil ->
+        highlight_below_line(FormattedLine, Severity);
+      _ ->
+        Length = calculate_span_length({LineNumber, Column}, Diagnostic),
+        highlight_at_position(Column - ColumnsTrimmed, Severity, Length)
+    end,
 
-compile_error(Meta, File, Format, Args) when is_list(Format)  ->
-  compile_error(Meta, File, io_lib:format(Format, Args)).
+  Formatted = io_lib:format(
+    " ~ts~ts ~ts\n"
+    " ~ts│\n"
+    " ~ts~p │ ~ts\n"
+    " ~ts│ ~ts\n"
+    " ~ts│\n"
+    " ~ts└─ ~ts",
+    [
+     Spacing, prefix(Severity), format_message(MessageDetail, LineDigits, 2 + LineNumberSpacing),
+     Spacing,
+     n_spaces(LineNumberSpacing), LineNumber, FormattedLine,
+     Spacing, Highlight,
+     Spacing,
+     Spacing, Location
+    ]),
+
+  unicode:characters_to_binary(Formatted).
+
+format_detail(#{details := #{typing_traces := _}}, Message) -> [Message | "\ntyping violation found at:"];
+format_detail(_, Message) -> Message.
+
+calculate_span_length({StartLine, StartCol}, #{span := {StartLine, EndCol}}) -> EndCol - StartCol;
+calculate_span_length({StartLine, _}, #{span := {EndLine, _}}) when EndLine > StartLine -> 1;
+calculate_span_length({_, _}, #{}) -> 1.
+
+format_line(Line) ->
+  case trim_line(Line, 0) of
+    {Trimmed, SpacesMatched} when SpacesMatched >= 27 ->
+      ColumnsTrimmed = SpacesMatched - 22,
+      {["...", n_spaces(19), Trimmed], ColumnsTrimmed};
+
+    {_, _} ->
+      {Line, 0}
+  end.
 
-%% Raised on tokenizing/parsing
+trim_line(<<$\s, Rest/binary>>, Count) -> trim_line(Rest, Count + 1);
+trim_line(<<$\t, Rest/binary>>, Count) -> trim_line(Rest, Count + 8);
+trim_line(Rest, Count) -> {Rest, Count}.
 
--spec parse_error(line_or_meta(), binary(), binary(), binary()) -> no_return().
+format_message(Message, NDigits, PaddingSize) ->
+  Padding = list_to_binary([$\n, n_spaces(NDigits + PaddingSize)]),
+  Bin = unicode:characters_to_binary(Message),
+  pad_line(binary:split(Bin, <<"\n">>, [global]), Padding).
 
-parse_error(Meta, File, Error, <<>>) ->
-  Message = case Error of
-    <<"syntax error before: ">> -> <<"syntax error: expression is incomplete">>;
-    _ -> Error
-  end,
-  raise(Meta, File, 'Elixir.TokenMissingError', Message);
-
-%% Show a nicer message for missing end tokens
-parse_error(Meta, File, <<"syntax error before: ">>, <<"'end'">>) ->
-  raise(Meta, File, 'Elixir.SyntaxError', <<"unexpected token: end">>);
-
-%% Binaries are wrapped in [<<...>>], so we need to unwrap them
-parse_error(Meta, File, Error, <<"[", _/binary>> = Full) when is_binary(Error) ->
-  Rest =
-    case binary:split(Full, <<"<<">>) of
-      [Lead, Token] ->
-        case binary:split(Token, <<">>">>) of
-          [Part, _] when Lead == <<$[>> -> Part;
-          _ -> <<$">>
-        end;
-      [_] ->
-        <<$">>
-    end,
-  raise(Meta, File, 'Elixir.SyntaxError', <<Error/binary, Rest/binary >>);
+pad_line([Last], _Padding) -> [Last];
+pad_line([First, <<"">> | Rest], Padding) -> [First, "\n" | pad_line([<<"">> | Rest], Padding)];
+pad_line([First | Rest], Padding) -> [First, Padding | pad_line(Rest, Padding)].
 
-%% Everything else is fine as is
-parse_error(Meta, File, Error, Token) when is_binary(Error), is_binary(Token) ->
-  Message = <<Error / binary, Token / binary >>,
-  raise(Meta, File, 'Elixir.SyntaxError', Message).
+highlight_at_position(Column, Severity, Length) ->
+  Spacing = n_spaces(max(Column - 1, 0)),
+  case Severity of
+    warning ->  highlight([Spacing, lists:duplicate(Length, $~)], warning);
+    error -> highlight([Spacing, lists:duplicate(Length, $^)], error)
+  end.
 
-%% Handle warnings and errors (called during module compilation)
+highlight_below_line(Line, Severity) ->
+  % Don't highlight leading whitespaces in line
+  {Rest, SpacesMatched} = trim_line(Line, 0),
 
-%% Ignore on bootstrap
-handle_file_warning(true, _File, {_Line, sys_core_fold, nomatch_guard}) -> [];
-handle_file_warning(true, _File, {_Line, sys_core_fold, {nomatch_shadow, _}}) -> [];
+  Length = string:length(Rest),
+  Highlight = case Severity of
+    warning -> highlight(lists:duplicate(Length, $~), warning);
+    error -> highlight(lists:duplicate(Length, $^), error)
+  end,
 
-%% Ignore always
-handle_file_warning(_, _File, {_Line, sys_core_fold, useless_building}) -> [];
+  [n_spaces(SpacesMatched), Highlight].
 
-%% This is an Erlang bug, it considers {tuple, _}.call to always fail
-handle_file_warning(_, _File, {_Line, v3_kernel, bad_call}) -> [];
+get_line_number_digits(Number, Acc) when Number < 10 -> Acc;
+get_line_number_digits(Number, Acc) ->
+  get_line_number_digits(Number div 10, Acc + 1).
 
-%% We handle unused local warnings ourselves
-handle_file_warning(_, _File, {_Line, erl_lint, {unused_function, _}}) -> [];
+n_spaces(N) -> lists:duplicate(N, " ").
 
-%% Make no_effect clauses pretty
-handle_file_warning(_, File, {Line, sys_core_fold, {no_effect, {erlang, F, A}}}) ->
-  {Fmt, Args} = case erl_internal:comp_op(F, A) of
-    true -> {"use of operator ~ts has no effect", [translate_comp_op(F)]};
-    false ->
-      case erl_internal:bif(F, A) of
-        false -> {"the call to :erlang.~ts/~B has no effect", [F,A]};
-        true -> {"the call to ~ts/~B has no effect", [F,A]}
-      end
-  end,
-  Message = io_lib:format(Fmt, Args),
-  warn(Line, File, Message);
-
-%% Rewrite undefined behaviour to check for protocols
-handle_file_warning(_, File, {Line,erl_lint,{undefined_behaviour_func,{Fun,Arity},Module}}) ->
-  {DefKind, Def, DefArity} =
-    case atom_to_list(Fun) of
-      "MACRO-" ++ Rest -> {macro, list_to_atom(Rest), Arity - 1};
-      _ -> {function, Fun, Arity}
-    end,
+%% Compilation error/warn handling.
 
-  Kind    = protocol_or_behaviour(Module),
-  Raw     = "undefined ~ts ~ts ~ts/~B (for ~ts ~ts)",
-  Message = io_lib:format(Raw, [Kind, DefKind, Def, DefArity, Kind, elixir_aliases:inspect(Module)]),
-  warn(Line, File, Message);
+%% Low-level warning, should be used only from Erlang passes.
+-spec erl_warn(location() | none, unicode:chardata(), unicode:chardata()) -> ok.
+erl_warn(none, File, Warning) ->
+  erl_warn(0, File, Warning);
+erl_warn(Location, File, Warning) when is_binary(File) ->
+  emit_diagnostic(warning, Location, File, Warning, [], [{read_snippet, true}]).
 
-handle_file_warning(_, File, {Line,erl_lint,{undefined_behaviour,Module}}) ->
-  case elixir_compiler:get_opt(internal) of
-    true  -> [];
+-spec file_warn(list(), binary() | #{file := binary(), _ => _}, module(), any()) -> ok.
+file_warn(Meta, File, Module, Desc) when is_list(Meta), is_binary(File) ->
+  file_warn(Meta, #{file => File}, Module, Desc);
+file_warn(Meta, E, Module, Desc) when is_list(Meta) ->
+  % Skip warnings during bootstrap, they will be reported during recompilation
+  case elixir_config:is_bootstrap() of
+    true -> ok;
     false ->
-      Message = io_lib:format("behaviour ~ts undefined", [elixir_aliases:inspect(Module)]),
-      warn(Line, File, Message)
-  end;
+      {EnvPosition, EnvFile, EnvStacktrace} = env_format(Meta, E),
+      Message = Module:format_error(Desc),
+      emit_diagnostic(warning, EnvPosition, EnvFile, Message, EnvStacktrace, [{read_snippet, true} | Meta])
+  end.
 
-%% Ignore unused vars at "weird" lines (<= 0)
-handle_file_warning(_, _File, {Line,erl_lint,{unused_var,_Var}}) when Line =< 0 ->
-  [];
+-spec file_error(list(), binary() | #{file := binary(), _ => _}, module(), any()) -> no_return().
+file_error(Meta, File, Module, Desc) when is_list(Meta), is_binary(File) ->
+  file_error(Meta, #{file => File}, Module, Desc);
+file_error(Meta, Env, Module, Desc) when is_list(Meta) ->
+  print_error(Meta, Env, Module, Desc),
+  compile_error(Env).
+
+%% A module error is one where it can continue if there is a module
+%% being compiled. If there is no module, it is a regular file_error.
+-spec module_error(list(), #{file := binary(), module => module() | nil, _ => _}, module(), any()) -> ok.
+module_error(Meta, #{module := EnvModule} = Env, Module, Desc) when EnvModule /= nil ->
+  print_error(Meta, Env, Module, Desc),
+  case elixir_module:taint(EnvModule) of
+    true -> ok;
+    false -> compile_error(Env)
+  end;
+module_error(Meta, Env, Module, Desc) ->
+  file_error(Meta, Env, Module, Desc).
+
+%% A function error is one where it can continue if there is a function
+%% being compiled. If there is no function, it is falls back to file_error.
+-spec function_error(list(), #{file := binary(), function => {term(), term()} | nil, _ => _}, module(), any()) -> ok.
+function_error(Meta, #{function := {_, _}} = Env, Module, Desc) ->
+  module_error(Meta, Env, Module, Desc);
+function_error(Meta, Env, Module, Desc) ->
+  file_error(Meta, Env, Module, Desc).
+
+print_error(Meta, Env, Module, Desc) ->
+  {EnvPosition, EnvFile, EnvStacktrace} = env_format(Meta, Env),
+  Message = Module:format_error(Desc),
+  emit_diagnostic(error, EnvPosition, EnvFile, Message, EnvStacktrace, [{read_snippet, true} | Meta]),
+  ok.
+
+%% Compilation error.
+
+-spec compile_error(#{file := binary(), _ => _}) -> no_return().
+%% We check for the lexical tracker because pry() inside a module
+%% will have the environment but not a tracker.
+compile_error(#{module := Module, file := File, lexical_tracker := LT}) when Module /= nil, LT /= nil ->
+  Inspected = elixir_aliases:inspect(Module),
+  Message = io_lib:format("cannot compile module ~ts (errors have been logged)", [Inspected]),
+  compile_error([], File, Message);
+compile_error(#{file := File}) ->
+  compile_error([], File, "cannot compile file (errors have been logged)").
+
+-spec compile_error(list(), binary(), binary() | unicode:charlist()) -> no_return().
+compile_error(Meta, File, Message) when is_binary(Message) ->
+  {File, Position} = meta_location(Meta, File),
+  raise('Elixir.CompileError', Message, [{file, File} | Position]);
+compile_error(Meta, File, Message) when is_list(Message) ->
+  {File, Position} = meta_location(Meta, File),
+  raise('Elixir.CompileError', elixir_utils:characters_to_binary(Message), [{file, File} | Position]).
 
-%% Ignore shadowed vars as we guarantee no conflicts ourselves
-handle_file_warning(_, _File, {_Line,erl_lint,{shadowed_var,_Var,_Where}}) ->
-  [];
+%% Tokenization parsing/errors.
 
-%% Properly format other unused vars
-handle_file_warning(_, File, {Line,erl_lint,{unused_var,Var}}) ->
-  Message = format_error(erl_lint, {unused_var, format_var(Var)}),
-  warn(Line, File, Message);
+-spec parse_error(elixir:keyword(), binary() | {binary(), binary()},
+                  binary(), binary(), {unicode:charlist(), integer(), integer()}) -> no_return().
+parse_error(Location, File, Error, <<>>, Input) ->
+  Message = case Error of
+    <<"syntax error before: ">> -> <<"syntax error: expression is incomplete">>;
+    _ -> <<Error/binary>>
+  end,
 
-%% Default behaviour
-handle_file_warning(_, File, {Line,Module,Desc}) ->
-  Message = format_error(Module, Desc),
-  warn(Line, File, Message).
+  raise_snippet(Location, File, Input, 'Elixir.TokenMissingError', Message);
+
+%% Show a nicer message for end of line
+parse_error(Location, File, <<"syntax error before: ">>, <<"eol">>, Input) ->
+  raise_snippet(Location, File, Input, 'Elixir.SyntaxError',
+        <<"unexpectedly reached end of line. The current expression is invalid or incomplete">>);
+
+%% Show a nicer message for keywords pt1 (Erlang keywords show up wrapped in single quotes)
+parse_error(Location, File, <<"syntax error before: ">>, Keyword, Input)
+    when Keyword == <<"'not'">>;
+         Keyword == <<"'and'">>;
+         Keyword == <<"'or'">>;
+         Keyword == <<"'when'">>;
+         Keyword == <<"'after'">>;
+         Keyword == <<"'catch'">>;
+         Keyword == <<"'end'">> ->
+  raise_reserved(Location, File, Input, binary_part(Keyword, 1, byte_size(Keyword) - 2));
+
+%% Show a nicer message for keywords pt2 (Elixir keywords show up as is)
+parse_error(Location, File, <<"syntax error before: ">>, Keyword, Input)
+    when Keyword == <<"fn">>;
+         Keyword == <<"else">>;
+         Keyword == <<"rescue">>;
+         Keyword == <<"true">>;
+         Keyword == <<"false">>;
+         Keyword == <<"nil">>;
+         Keyword == <<"in">> ->
+  raise_reserved(Location, File, Input, Keyword);
+
+%% Produce a human-readable message for errors before a sigil
+parse_error(Location, File, <<"syntax error before: ">>, <<"{sigil,", _Rest/binary>> = Full, Input) ->
+  {ok, {sigil, _, Atom, [Content | _], _, _, _}} = parse_erl_term(Full),
+  Content2 = case is_binary(Content) of
+    true -> Content;
+    false -> <<>>
+  end,
 
-handle_file_warning(File, Desc) ->
-  handle_file_warning(false, File, Desc).
+  % :static_atoms_encoder might encode :sigil_ atoms as arbitrary terms
+  MaybeSigil = case is_atom(Atom) of
+    true -> case atom_to_binary(Atom) of
+      <<"sigil_", Chars/binary>> -> <<"\~", Chars/binary, " ">>;
+      _ -> <<>>
+    end;
+    false -> <<>>
+  end,
 
--spec handle_file_error(file:filename_all(), {non_neg_integer(), module(), any()}) -> no_return().
+  Message = <<"syntax error before: sigil ", MaybeSigil/binary, "starting with content '", Content2/binary, "'">>,
+  raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message);
 
-handle_file_error(File, {Line,erl_lint,{unsafe_var,Var,{In,_Where}}}) ->
-  Translated = case In of
-    'orelse'  -> 'or';
-    'andalso' -> 'and';
-    _ -> In
+%% Binaries (and interpolation) are wrapped in [<<...>>]
+parse_error(Location, File, Error, <<"[", _/binary>> = Full, Input) when is_binary(Error) ->
+  Term = case parse_erl_term(Full) of
+    {ok, [H | _]} when is_binary(H) -> <<$", H/binary, $">>;
+    _ -> <<$">>
   end,
-  Message = io_lib:format("cannot define variable ~ts inside ~ts", [format_var(Var), Translated]),
-  raise(Line, File, 'Elixir.CompileError', iolist_to_binary(Message));
+  raise_snippet(Location, File, Input, 'Elixir.SyntaxError', <<Error/binary, Term/binary>>);
+
+%% Given a string prefix and suffix to insert the token inside the error message rather than append it
+parse_error(Location, File, {ErrorPrefix, ErrorSuffix}, Token, Input) when is_binary(ErrorPrefix), is_binary(ErrorSuffix), is_binary(Token) ->
+  Message = <<ErrorPrefix/binary, Token/binary, ErrorSuffix/binary>>,
+  raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message);
+
+%% Misplaced char tokens (for example, {char, _, 97}) are translated by Erlang into
+%% the char literal (i.e., the token in the previous example becomes $a),
+%% because {char, _, _} is a valid Erlang token for an Erlang char literal. We
+%% want to represent that token as ?a in the error, according to the Elixir
+%% syntax.
+parse_error(Location, File, <<"syntax error before: ">>, <<$$, Char/binary>>, Input) ->
+  Message = <<"syntax error before: ?", Char/binary>>,
+  raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message);
 
-handle_file_error(File, {Line,erl_lint,{spec_fun_undefined,{M,F,A}}}) ->
-  Message = io_lib:format("spec for undefined function ~ts.~ts/~B", [elixir_aliases:inspect(M), F, A]),
-  raise(Line, File, 'Elixir.CompileError', iolist_to_binary(Message));
+%% Everything else is fine as is
+parse_error(Location, File, Error, Token, Input) when is_binary(Error), is_binary(Token) ->
+  Message = <<Error/binary, Token/binary>>,
+  case lists:keytake(error_type, 1, Location) of
+    {value, {error_type, mismatched_delimiter}, Loc} ->
+      raise_snippet(Loc, File, Input, 'Elixir.MismatchedDelimiterError', Message);
+    _ ->
+      raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message)
+  end.
 
-handle_file_error(File, {Line,Module,Desc}) ->
-  form_error(Line, File, Module, Desc).
+parse_erl_term(Term) ->
+  case erl_scan:string(binary_to_list(Term)) of
+    {ok, Tokens, _} ->
+      case erl_parse:parse_term(Tokens ++ [{dot, 1}]) of
+        {ok, Parsed} -> {ok, Parsed};
+        _ -> error
+      end;
+    _ -> error
+  end.
 
-%% Helpers
+raise_reserved(Location, File, Input, Keyword) ->
+  raise_snippet(Location, File, Input, 'Elixir.SyntaxError',
+        <<"syntax error before: ", Keyword/binary, ". \"", Keyword/binary, "\" is a "
+          "reserved word in Elixir and therefore its usage is limited. For instance, "
+          "it can't be used as a variable or be defined nor invoked as a regular function">>).
+
+raise_snippet(Location, File, Input, Kind, Message) when is_binary(File) ->
+  Snippet = cut_snippet(Location, Input),
+  raise(Kind, Message, [{file, File}, {snippet, Snippet} | Location]).
+
+cut_snippet(Location, Input) ->
+  case lists:keyfind(column, 1, Location) of
+    {column, _} ->
+      {line, Line} = lists:keyfind(line, 1, Location),
+
+      case lists:keyfind(end_line, 1, Location) of
+        {end_line, EndLine} ->
+          cut_snippet(Input, Line, EndLine - Line + 1);
+
+        false ->
+          Snippet = cut_snippet(Input, Line, 1),
+          case string:trim(Snippet, leading) of
+            <<>> -> nil;
+            _ -> Snippet
+          end
+      end;
 
-raise(Meta, File, Kind, Message) when is_list(Meta) ->
-  raise(?line(Meta), File, Kind, Message);
+    false ->
+      nil
+  end.
 
-raise(none, File, Kind, Message) ->
-  raise(0, File, Kind, Message);
+cut_snippet({InputString, StartLine, StartColumn, Indentation}, Line, Span) ->
+  %% In case the code is indented, we need to add the indentation back
+  %% for the snippets to match the reported columns.
+  Prelude = lists:duplicate(max(StartColumn - Indentation - 1, 0), " "),
+  Lines = string:split(Prelude ++ InputString, "\n", all),
+  Indent = binary:copy(<<" ">>, Indentation),
+  [Head | Tail] = lists:nthtail(Line - StartLine, Lines),
+  IndentedTail = indent_n(Tail, Span - 1, <<"\n", Indent/binary>>),
+  elixir_utils:characters_to_binary([Indent, Head, IndentedTail]).
 
-raise(Line, File, Kind, Message) when is_integer(Line), is_binary(File) ->
-  %% Populate the stacktrace so we can raise it
-  try
-    throw(ok)
-  catch
-    ok -> ok
-  end,
-  Stacktrace = erlang:get_stacktrace(),
-  Exception = Kind:exception([{description, Message}, {file, File}, {line, Line}]),
-  erlang:raise(error, Exception, tl(Stacktrace)).
+indent_n([], _Count, _Indent) -> [];
+indent_n(_Lines, 0, _Indent) -> [];
+indent_n([H | T], Count, Indent) -> [Indent, H | indent_n(T, Count - 1, Indent)].
 
-file_format(0, File, Message) when is_binary(File) ->
-  io_lib:format("~ts: ~ts~n", [elixir_utils:relative_to_cwd(File), Message]);
+%% Helpers
 
-file_format(Line, File, Message) when is_binary(File) ->
-  io_lib:format("~ts:~w: ~ts~n", [elixir_utils:relative_to_cwd(File), Line, Message]).
+prefix(warning) -> highlight(<<"warning:">>, warning);
+prefix(error) -> highlight(<<"error:">>, error);
+prefix(hint) -> <<"hint:">>.
 
-format_var(Var) ->
-  list_to_atom(lists:takewhile(fun(X) -> X /= $@ end, atom_to_list(Var))).
+highlight(Message, Severity) ->
+  case {Severity, application:get_env(elixir, ansi_enabled, false)} of
+    {warning, true} -> yellow(Message);
+    {error, true} -> red(Message);
+    _ -> Message
+  end.
 
-format_error([], Desc) ->
-  io_lib:format("~p", [Desc]);
+yellow(Msg) -> ["\e[33m", Msg, "\e[0m"].
+red(Msg) -> ["\e[31m", Msg, "\e[0m"].
+
+env_format(Meta, #{file := EnvFile} = E) ->
+  {File, Position} = meta_location(Meta, EnvFile),
+  Line = ?line(Position),
+
+  Stacktrace =
+    case E of
+      #{function := {Name, Arity}, module := Module} ->
+        [{Module, Name, Arity, [{file, elixir_utils:relative_to_cwd(File)} | Position ]}];
+      #{module := Module} when Module /= nil ->
+        [{Module, '__MODULE__', 0, [{file, elixir_utils:relative_to_cwd(File)} | Position]}];
+      #{} ->
+        []
+    end,
 
-format_error(Module, Desc) ->
-  Module:format_error(Desc).
+  case lists:keyfind(column, 1, Position) of
+    {column, Column} -> {{Line, Column}, File, Stacktrace};
+    _ -> {Line, File, Stacktrace}
+  end.
 
-protocol_or_behaviour(Module) ->
-  case is_protocol(Module) of
-    true  -> protocol;
-    false -> behaviour
+%% We prefer the stacktrace, if available, as it also contains module/function.
+location_format(_Position, _File, [E | _]) ->
+  'Elixir.Exception':format_stacktrace_entry(E);
+location_format(Position, File, []) ->
+  file_format(Position, File).
+
+file_format({0, _Column}, File) ->
+  elixir_utils:relative_to_cwd(File);
+file_format({Line, nil}, File) ->
+  file_format(Line, File);
+file_format({Line, Column}, File) ->
+  io_lib:format("~ts:~w:~w", [elixir_utils:relative_to_cwd(File), Line, Column]);
+file_format(0, File) ->
+  elixir_utils:relative_to_cwd(File);
+file_format(Line, File) ->
+  io_lib:format("~ts:~w", [elixir_utils:relative_to_cwd(File), Line]).
+
+meta_location(Meta, File) ->
+  case elixir_utils:meta_keep(Meta) of
+    {F, L} -> {F, [{line, L}]};
+    nil    -> {File, maybe_add_col([{line, ?line(Meta)}], Meta)}
   end.
 
-is_protocol(Module) ->
-  case code:ensure_loaded(Module) of
-    {module, _} ->
-      erlang:function_exported(Module, '__protocol__', 1) andalso
-        Module:'__protocol__'(name) == Module;
-    {error, _} ->
-      false
+maybe_add_col(Position, Meta) ->
+  case lists:keyfind(column, 1, Meta) of
+    {column, Col} when is_integer(Col) -> [{column, Col} | Position];
+    false -> Position
   end.
 
-translate_comp_op('/=') -> '!=';
-translate_comp_op('=<') -> '<=';
-translate_comp_op('=:=') -> '===';
-translate_comp_op('=/=') -> '!==';
-translate_comp_op(Other) -> Other.
+raise(Kind, Message, Opts) when is_binary(Message) ->
+  Stacktrace = try throw(ok) catch _:_:Stack -> Stack end,
+  Exception = Kind:exception([{description, Message} | Opts]),
+  erlang:raise(error, Exception, tl(Stacktrace)).
diff --git a/lib/elixir/src/elixir_exp.erl b/lib/elixir/src/elixir_exp.erl
deleted file mode 100644
index ba786b4b885..00000000000
--- a/lib/elixir/src/elixir_exp.erl
+++ /dev/null
@@ -1,571 +0,0 @@
--module(elixir_exp).
--export([expand/2, expand_args/2, expand_arg/2]).
--import(elixir_errors, [compile_error/3, compile_error/4]).
--include("elixir.hrl").
-
-%% =
-
-expand({'=', Meta, [Left, Right]}, E) ->
-  assert_no_guard_scope(Meta, '=', E),
-  {ERight, ER} = expand(Right, E),
-  {ELeft, EL}  = elixir_exp_clauses:match(fun expand/2, Left, E),
-  {{'=', Meta, [ELeft, ERight]}, elixir_env:mergev(EL, ER)};
-
-%% Literal operators
-
-expand({'{}', Meta, Args}, E) ->
-  {EArgs, EA} = expand_args(Args, E),
-  {{'{}', Meta, EArgs}, EA};
-
-expand({'%{}', Meta, Args}, E) ->
-  elixir_map:expand_map(Meta, Args, E);
-
-expand({'%', Meta, [Left, Right]}, E) ->
-  elixir_map:expand_struct(Meta, Left, Right, E);
-
-expand({'<<>>', Meta, Args}, E) ->
-  elixir_bitstring:expand(Meta, Args, E);
-
-%% Other operators
-
-expand({'__op__', Meta, [_, _] = Args}, E) ->
-  {EArgs, EA} = expand_args(Args, E),
-  {{'__op__', Meta, EArgs}, EA};
-
-expand({'__op__', Meta, [_, _, _] = Args}, E) ->
-  {EArgs, EA} = expand_args(Args, E),
-  {{'__op__', Meta, EArgs}, EA};
-
-expand({'->', Meta, _Args}, E) ->
-  compile_error(Meta, ?m(E, file), "unhandled operator ->");
-
-%% __block__
-
-expand({'__block__', _Meta, []}, E) ->
-  {nil, E};
-expand({'__block__', _Meta, [Arg]}, E) ->
-  expand(Arg, E);
-expand({'__block__', Meta, Args}, E) when is_list(Args) ->
-  {EArgs, EA} = expand_many(Args, E),
-  {{'__block__', Meta, EArgs}, EA};
-
-%% __aliases__
-
-expand({'__aliases__', _, _} = Alias, E) ->
-  case elixir_aliases:expand(Alias, ?m(E, aliases),
-                             ?m(E, macro_aliases), ?m(E, lexical_tracker)) of
-    Receiver when is_atom(Receiver) ->
-      elixir_lexical:record_remote(Receiver, ?m(E, lexical_tracker)),
-      {Receiver, E};
-    Aliases ->
-      {EAliases, EA} = expand_args(Aliases, E),
-
-      case lists:all(fun is_atom/1, EAliases) of
-        true ->
-          Receiver = elixir_aliases:concat(EAliases),
-          elixir_lexical:record_remote(Receiver, ?m(E, lexical_tracker)),
-          {Receiver, EA};
-        false ->
-          {{{'.', [], [elixir_aliases, concat]}, [], [EAliases]}, EA}
-      end
-  end;
-
-%% alias
-
-expand({alias, Meta, [Ref]}, E) ->
-  expand({alias, Meta, [Ref,[]]}, E);
-expand({alias, Meta, [Ref, KV]}, E) ->
-  assert_no_match_or_guard_scope(Meta, alias, E),
-  {ERef, ER} = expand(Ref, E),
-  {EKV, ET}  = expand_opts(Meta, alias, [as, warn], no_alias_opts(KV), ER),
-
-  if
-    is_atom(ERef) ->
-      {{alias, Meta, [ERef, EKV]},
-        expand_alias(Meta, true, ERef, EKV, ET)};
-    true ->
-      compile_error(Meta, ?m(E, file),
-        "invalid argument for alias, expected a compile time atom or alias, got: ~ts",
-        ['Elixir.Kernel':inspect(ERef)])
-  end;
-
-expand({require, Meta, [Ref]}, E) ->
-  expand({require, Meta, [Ref, []]}, E);
-expand({require, Meta, [Ref, KV]}, E) ->
-  assert_no_match_or_guard_scope(Meta, require, E),
-
-  {ERef, ER} = expand(Ref, E),
-  {EKV, ET}  = expand_opts(Meta, require, [as, warn], no_alias_opts(KV), ER),
-
-  if
-    is_atom(ERef) ->
-      elixir_aliases:ensure_loaded(Meta, ERef, ET),
-      {{require, Meta, [ERef, EKV]},
-        expand_require(Meta, ERef, EKV, ET)};
-    true ->
-      compile_error(Meta, ?m(E, file),
-        "invalid argument for require, expected a compile time atom or alias, got: ~ts",
-        ['Elixir.Kernel':inspect(ERef)])
-  end;
-
-expand({import, Meta, [Left]}, E) ->
-  expand({import, Meta, [Left, []]}, E);
-
-expand({import, Meta, [Ref, KV]}, E) ->
-  assert_no_match_or_guard_scope(Meta, import, E),
-  {ERef, ER} = expand(Ref, E),
-  {EKV, ET}  = expand_opts(Meta, import, [only, except, warn], KV, ER),
-
-  if
-    is_atom(ERef) ->
-      elixir_aliases:ensure_loaded(Meta, ERef, ET),
-      {Functions, Macros} = elixir_import:import(Meta, ERef, EKV, ET),
-      {{import, Meta, [ERef, EKV]},
-        expand_require(Meta, ERef, EKV, ET#{functions := Functions, macros := Macros})};
-    true ->
-      compile_error(Meta, ?m(E, file),
-        "invalid argument for import, expected a compile time atom or alias, got: ~ts",
-        ['Elixir.Kernel':inspect(ERef)])
-  end;
-
-%% Pseudo vars
-
-expand({'__MODULE__', _, Atom}, E) when is_atom(Atom) ->
-  {?m(E, module), E};
-expand({'__DIR__', _, Atom}, E) when is_atom(Atom) ->
-  {filename:dirname(?m(E, file)), E};
-expand({'__CALLER__', _, Atom} = Caller, E) when is_atom(Atom) ->
-  {Caller, E};
-expand({'__ENV__', Meta, Atom}, E) when is_atom(Atom) ->
-  Env = elixir_env:linify({?line(Meta), E}),
-  {{'%{}', [], maps:to_list(Env)}, E};
-expand({{'.', DotMeta, [{'__ENV__', Meta, Atom}, Field]}, CallMeta, []}, E) when is_atom(Atom), is_atom(Field) ->
-  Env = elixir_env:linify({?line(Meta), E}),
-  case maps:is_key(Field, Env) of
-    true  -> {maps:get(Field, Env), E};
-    false -> {{{'.', DotMeta, [{'%{}', [], maps:to_list(Env)}, Field]}, CallMeta, []}, E}
-  end;
-
-%% Quote
-
-expand({Unquote, Meta, [_]}, E) when Unquote == unquote; Unquote == unquote_splicing ->
-  compile_error(Meta, ?m(E, file), "~p called outside quote", [Unquote]);
-
-expand({quote, Meta, [Opts]}, E) when is_list(Opts) ->
-  case lists:keyfind(do, 1, Opts) of
-    {do, Do} ->
-      expand({quote, Meta, [lists:keydelete(do, 1, Opts), [{do,Do}]]}, E);
-    false ->
-      compile_error(Meta, ?m(E, file), "missing do keyword in quote")
-  end;
-
-expand({quote, Meta, [_]}, E) ->
-  compile_error(Meta, ?m(E, file), "invalid arguments for quote");
-
-expand({quote, Meta, [KV, Do]}, E) when is_list(Do) ->
-  Exprs =
-    case lists:keyfind(do, 1, Do) of
-      {do, Expr} -> Expr;
-      false -> compile_error(Meta, E#elixir_scope.file, "missing do keyword in quote")
-    end,
-
-  ValidOpts = [context, location, line, unquote, bind_quoted],
-  {EKV, ET} = expand_opts(Meta, quote, ValidOpts, KV, E),
-
-  Context = case lists:keyfind(context, 1, EKV) of
-    {context, Ctx} when is_atom(Ctx) and (Ctx /= nil) ->
-      Ctx;
-    {context, Ctx} ->
-      compile_error(Meta, ?m(E, file), "invalid :context for quote, "
-        "expected non nil compile time atom or alias, got: ~ts", ['Elixir.Kernel':inspect(Ctx)]);
-    false ->
-      case ?m(E, module) of
-        nil -> 'Elixir';
-        Mod -> Mod
-      end
-  end,
-
-  Keep = lists:keyfind(location, 1, EKV) == {location, keep},
-  Line = proplists:get_value(line, EKV, false),
-
-  {Binding, DefaultUnquote} = case lists:keyfind(bind_quoted, 1, EKV) of
-    {bind_quoted, BQ} -> {BQ, false};
-    false -> {nil, true}
-  end,
-
-  Unquote = case lists:keyfind(unquote, 1, EKV) of
-    {unquote, Bool} when is_boolean(Bool) -> Bool;
-    false -> DefaultUnquote
-  end,
-
-  Q = #elixir_quote{line=Line, keep=Keep, unquote=Unquote, context=Context},
-
-  {Quoted, _Q} = elixir_quote:quote(Exprs, Binding, Q, ET),
-  expand(Quoted, ET);
-
-expand({quote, Meta, [_, _]}, E) ->
-  compile_error(Meta, ?m(E, file), "invalid arguments for quote");
-
-%% Functions
-
-expand({'&', _, [Arg]} = Original, E) when is_integer(Arg) ->
-  {Original, E};
-expand({'&', Meta, [Arg]}, E) ->
-  assert_no_match_or_guard_scope(Meta, '&', E),
-  case elixir_fn:capture(Meta, Arg, E) of
-    {local, Fun, Arity} ->
-      {{'&', Meta, [{'/', [], [{Fun, [], nil}, Arity]}]}, E};
-    {expanded, Expr, EE} ->
-      expand(Expr, EE)
-  end;
-
-expand({fn, Meta, Pairs}, E) ->
-  assert_no_match_or_guard_scope(Meta, fn, E),
-  elixir_fn:expand(Meta, Pairs, E);
-
-%% Case/Receive/Try
-
-expand({'cond', Meta, [KV]}, E) ->
-  assert_no_match_or_guard_scope(Meta, 'cond', E),
-  {EClauses, EC} = elixir_exp_clauses:'cond'(Meta, KV, E),
-  {{'cond', Meta, [EClauses]}, EC};
-
-expand({'case', Meta, [Expr, KV]}, E) ->
-  assert_no_match_or_guard_scope(Meta, 'case', E),
-  {EExpr, EE} = expand(Expr, E),
-  {EClauses, EC} = elixir_exp_clauses:'case'(Meta, KV, EE),
-  FClauses =
-    case (lists:keyfind(optimize_boolean, 1, Meta) == {optimize_boolean, true}) and
-         elixir_utils:returns_boolean(EExpr) of
-      true  -> rewrite_case_clauses(EClauses);
-      false -> EClauses
-    end,
-  {{'case', Meta, [EExpr, FClauses]}, EC};
-
-expand({'receive', Meta, [KV]}, E) ->
-  assert_no_match_or_guard_scope(Meta, 'receive', E),
-  {EClauses, EC} = elixir_exp_clauses:'receive'(Meta, KV, E),
-  {{'receive', Meta, [EClauses]}, EC};
-
-expand({'try', Meta, [KV]}, E) ->
-  assert_no_match_or_guard_scope(Meta, 'try', E),
-  {EClauses, EC} = elixir_exp_clauses:'try'(Meta, KV, E),
-  {{'try', Meta, [EClauses]}, EC};
-
-%% Comprehensions
-
-expand({for, Meta, [_|_] = Args}, E) ->
-  elixir_for:expand(Meta, Args, E);
-
-%% Super
-
-expand({super, Meta, Args}, E) when is_list(Args) ->
-  assert_no_match_or_guard_scope(Meta, super, E),
-  {EArgs, EA} = expand_args(Args, E),
-  {{super, Meta, EArgs}, EA};
-
-%% Vars
-
-expand({'^', Meta, [Arg]}, #{context := match} = E) ->
-  case expand(Arg, E) of
-    {{Name, _, Kind} = EArg, EA} when is_atom(Name), is_atom(Kind) ->
-      {{'^', Meta, [EArg]}, EA};
-    _ ->
-    Msg = "invalid argument for unary operator ^, expected an existing variable, got: ^~ts",
-    compile_error(Meta, ?m(E, file), Msg, ['Elixir.Macro':to_string(Arg)])
-  end;
-expand({'^', Meta, [Arg]}, E) ->
-  compile_error(Meta, ?m(E, file),
-    "cannot use ^~ts outside of match clauses", ['Elixir.Macro':to_string(Arg)]);
-
-expand({'_', _, Kind} = Var, E) when is_atom(Kind) ->
-  {Var, E};
-expand({Name, Meta, Kind} = Var, #{context := match, export_vars := Export} = E) when is_atom(Name), is_atom(Kind) ->
-  Pair      = {Name, var_kind(Meta, Kind)},
-  NewVars   = ordsets:add_element(Pair, ?m(E, vars)),
-  NewExport = case (Export /= nil) of
-    true  -> ordsets:add_element(Pair, Export);
-    false -> Export
-  end,
-  {Var, E#{vars := NewVars, export_vars := NewExport}};
-expand({Name, Meta, Kind} = Var, #{vars := Vars} = E) when is_atom(Name), is_atom(Kind) ->
-  case lists:member({Name, var_kind(Meta, Kind)}, Vars) of
-    true ->
-      {Var, E};
-    false ->
-      VarMeta = lists:keyfind(var, 1, Meta),
-      if
-        VarMeta == {var, true} ->
-          Extra = case Kind of
-            nil -> "";
-            _   -> io_lib:format(" (context ~ts)", [elixir_aliases:inspect(Kind)])
-          end,
-
-          compile_error(Meta, ?m(E, file), "expected var ~ts~ts to expand to an existing "
-                        "variable or be a part of a match", [Name, Extra]);
-        true ->
-          expand({Name, Meta, []}, E)
-      end
-  end;
-
-%% Local calls
-
-expand({Atom, Meta, Args}, E) when is_atom(Atom), is_list(Meta), is_list(Args) ->
-  assert_no_ambiguous_op(Atom, Meta, Args, E),
-
-  elixir_dispatch:dispatch_import(Meta, Atom, Args, E, fun() ->
-    expand_local(Meta, Atom, Args, E)
-  end);
-
-%% Remote calls
-
-expand({{'.', DotMeta, [Left, Right]}, Meta, Args}, E)
-    when (is_tuple(Left) orelse is_atom(Left)), is_atom(Right), is_list(Meta), is_list(Args) ->
-  {ELeft, EL} = expand(Left, E),
-
-  elixir_dispatch:dispatch_require(Meta, ELeft, Right, Args, EL, fun(AR, AF, AA) ->
-    expand_remote(AR, DotMeta, AF, Meta, AA, E, EL)
-  end);
-
-%% Anonymous calls
-
-expand({{'.', DotMeta, [Expr]}, Meta, Args}, E) when is_list(Args) ->
-  {EExpr, EE} = expand(Expr, E),
-  if
-    is_atom(EExpr) ->
-      compile_error(Meta, ?m(E, file), "invalid function call :~ts.()", [EExpr]);
-    true ->
-      {EArgs, EA} = expand_args(Args, elixir_env:mergea(E, EE)),
-      {{{'.', DotMeta, [EExpr]}, Meta, EArgs}, elixir_env:mergev(EE, EA)}
-  end;
-
-%% Invalid calls
-
-expand({_, Meta, Args} = Invalid, E) when is_list(Meta) and is_list(Args) ->
-  compile_error(Meta, ?m(E, file), "invalid call ~ts",
-    ['Elixir.Macro':to_string(Invalid)]);
-
-expand({_, _, _} = Tuple, E) ->
-  compile_error([{line,0}], ?m(E, file), "invalid quoted expression: ~ts",
-    ['Elixir.Kernel':inspect(Tuple, [{records,false}])]);
-
-%% Literals
-
-expand({Left, Right}, E) ->
-  {[ELeft, ERight], EE} = expand_args([Left, Right], E),
-  {{ELeft, ERight}, EE};
-
-expand(List, #{context := match} = E) when is_list(List) ->
-  expand_list(List, fun expand/2, E, []);
-
-expand(List, E) when is_list(List) ->
-  {EArgs, {EC, EV}} = expand_list(List, fun expand_arg/2, {E, E}, []),
-  {EArgs, elixir_env:mergea(EV, EC)};
-
-expand(Function, E) when is_function(Function) ->
-  case (erlang:fun_info(Function, type) == {type, external}) andalso
-       (erlang:fun_info(Function, env) == {env, []}) of
-    true ->
-      {Function, E};
-    false ->
-      compile_error([{line,0}], ?m(E, file),
-        "invalid quoted expression: ~ts", ['Elixir.Kernel':inspect(Function)])
-  end;
-
-expand(Other, E) when is_number(Other); is_atom(Other); is_binary(Other); is_pid(Other) ->
-  {Other, E};
-
-expand(Other, E) ->
-  compile_error([{line,0}], ?m(E, file),
-    "invalid quoted expression: ~ts", ['Elixir.Kernel':inspect(Other)]).
-
-%% Helpers
-
-expand_list([{'|', Meta, [_, _] = Args}], Fun, Acc, List) ->
-  {EArgs, EAcc} = lists:mapfoldl(Fun, Acc, Args),
-  expand_list([], Fun, EAcc, [{'|', Meta, EArgs}|List]);
-expand_list([H|T], Fun, Acc, List) ->
-  {EArg, EAcc} = Fun(H, Acc),
-  expand_list(T, Fun, EAcc, [EArg|List]);
-expand_list([], _Fun, Acc, List) ->
-  {lists:reverse(List), Acc}.
-
-expand_many(Args, E) ->
-  lists:mapfoldl(fun expand/2, E, Args).
-
-%% Variables in arguments are not propagated from one
-%% argument to the other. For instance:
-%%
-%%   x = 1
-%%   foo(x = x + 2, x)
-%%   x
-%%
-%% Should be the same as:
-%%
-%%   foo(3, 1)
-%%   3
-%%
-%% However, lexical information is.
-expand_arg(Arg, Acc) when is_number(Arg); is_atom(Arg); is_binary(Arg); is_pid(Arg) ->
-  {Arg, Acc};
-expand_arg(Arg, {Acc1, Acc2}) ->
-  {EArg, EAcc} = expand(Arg, Acc1),
-  {EArg, {elixir_env:mergea(Acc1, EAcc), elixir_env:mergev(Acc2, EAcc)}}.
-
-expand_args([Arg], E) ->
-  {EArg, EE} = expand(Arg, E),
-  {[EArg], EE};
-expand_args(Args, #{context := match} = E) ->
-  expand_many(Args, E);
-expand_args(Args, E) ->
-  {EArgs, {EC, EV}} = lists:mapfoldl(fun expand_arg/2, {E, E}, Args),
-  {EArgs, elixir_env:mergea(EV, EC)}.
-
-%% Match/var helpers
-
-var_kind(Meta, Kind) ->
-  case lists:keyfind(counter, 1, Meta) of
-    {counter, Counter} -> Counter;
-    false -> Kind
-  end.
-
-%% Locals
-
-assert_no_ambiguous_op(Name, Meta, [Arg], E) ->
-  case lists:keyfind(ambiguous_op, 1, Meta) of
-    {ambiguous_op, Kind} ->
-      case lists:member({Name, Kind}, ?m(E, vars)) of
-        true ->
-          compile_error(Meta, ?m(E, file), "\"~ts ~ts\" looks like a function call but "
-                        "there is a variable named \"~ts\", please use explicit parenthesis or even spaces",
-                        [Name, 'Elixir.Macro':to_string(Arg), Name]);
-        false ->
-          ok
-      end;
-    _ ->
-      ok
-  end;
-assert_no_ambiguous_op(_Atom, _Meta, _Args, _E) ->
-  ok.
-
-expand_local(Meta, Name, Args, #{local := nil, function := nil} = E) ->
-  {EArgs, EA} = expand_args(Args, E),
-  {{Name, Meta, EArgs}, EA};
-expand_local(Meta, Name, Args, #{local := nil, module := Module, function := Function} = E) ->
-  elixir_locals:record_local({Name, length(Args)}, Module, Function),
-  {EArgs, EA} = expand_args(Args, E),
-  {{Name, Meta, EArgs}, EA};
-expand_local(Meta, Name, Args, E) ->
-  expand({{'.', Meta, [?m(E, local), Name]}, Meta, Args}, E).
-
-%% Remote
-
-expand_remote(Receiver, DotMeta, Right, Meta, Args, E, EL) ->
-  if
-    is_atom(Receiver) -> elixir_lexical:record_remote(Receiver, ?m(E, lexical_tracker));
-    true -> ok
-  end,
-  {EArgs, EA} = expand_args(Args, E),
-  {{{'.', DotMeta, [Receiver, Right]}, Meta, EArgs}, elixir_env:mergev(EL, EA)}.
-
-%% Lexical helpers
-
-expand_opts(Meta, Kind, Allowed, Opts, E) ->
-  {EOpts, EE} = expand(Opts, E),
-  validate_opts(Meta, Kind, Allowed, EOpts, EE),
-  {EOpts, EE}.
-
-validate_opts(Meta, Kind, Allowed, Opts, E) when is_list(Opts) ->
-  [begin
-    compile_error(Meta, ?m(E, file),
-                  "unsupported option ~ts given to ~s", ['Elixir.Kernel':inspect(Key), Kind])
-  end || {Key, _} <- Opts, not lists:member(Key, Allowed)];
-
-validate_opts(Meta, Kind, _Allowed, _Opts, S) ->
-  compile_error(Meta, S#elixir_scope.file, "invalid options for ~s, expected a keyword list", [Kind]).
-
-no_alias_opts(KV) when is_list(KV) ->
-  case lists:keyfind(as, 1, KV) of
-    {as, As} -> lists:keystore(as, 1, KV, {as, no_alias_expansion(As)});
-    false -> KV
-  end;
-no_alias_opts(KV) -> KV.
-
-no_alias_expansion({'__aliases__', Meta, [H|T]}) when (H /= 'Elixir') and is_atom(H) ->
-  {'__aliases__', Meta, ['Elixir',H|T]};
-no_alias_expansion(Other) ->
-  Other.
-
-expand_require(Meta, Ref, KV, E) ->
-  RE = E#{requires := ordsets:add_element(Ref, ?m(E, requires))},
-  expand_alias(Meta, false, Ref, KV, RE).
-
-expand_alias(Meta, IncludeByDefault, Ref, KV, #{context_modules := Context} = E) ->
-  New = expand_as(lists:keyfind(as, 1, KV), Meta, IncludeByDefault, Ref, E),
-
-  %% Add the alias to context_modules if defined is true.
-  %% This is used by defmodule in order to store the defined
-  %% module in context modules.
-  NewContext =
-    case lists:keyfind(defined, 1, Meta) of
-      {defined, Mod} when is_atom(Mod) -> [Mod|Context];
-      false -> Context
-    end,
-
-  {Aliases, MacroAliases} = elixir_aliases:store(Meta, New, Ref, KV, ?m(E, aliases),
-                                ?m(E, macro_aliases), ?m(E, lexical_tracker)),
-
-  E#{aliases := Aliases, macro_aliases := MacroAliases, context_modules := NewContext}.
-
-expand_as({as, true}, _Meta, _IncludeByDefault, Ref, _E) ->
-  elixir_aliases:last(Ref);
-expand_as({as, false}, _Meta, _IncludeByDefault, Ref, _E) ->
-  Ref;
-expand_as({as, Atom}, Meta, _IncludeByDefault, _Ref, E) when is_atom(Atom) ->
-  case length(string:tokens(atom_to_list(Atom), ".")) of
-    1 -> compile_error(Meta, ?m(E, file),
-           "invalid value for keyword :as, expected an alias, got atom: ~ts", [elixir_aliases:inspect(Atom)]);
-    2 -> Atom;
-    _ -> compile_error(Meta, ?m(E, file),
-           "invalid value for keyword :as, expected an alias, got nested alias: ~ts", [elixir_aliases:inspect(Atom)])
-  end;
-expand_as(false, _Meta, IncludeByDefault, Ref, _E) ->
-  if IncludeByDefault -> elixir_aliases:last(Ref);
-     true -> Ref
-  end;
-expand_as({as, Other}, Meta, _IncludeByDefault, _Ref, E) ->
-  compile_error(Meta, ?m(E, file),
-    "invalid value for keyword :as, expected an alias, got: ~ts", ['Elixir.Macro':to_string(Other)]).
-
-%% Assertions
-
-rewrite_case_clauses([{do,[
-  {'->', FalseMeta, [
-    [{'when', _, [Var, {'__op__', _,[
-      'orelse',
-      {{'.', _, [erlang, '=:=']}, _, [Var, nil]},
-      {{'.', _, [erlang, '=:=']}, _, [Var, false]}
-    ]}]}],
-    FalseExpr
-  ]},
-  {'->', TrueMeta, [
-    [{'_', _, _}],
-    TrueExpr
-  ]}
-]}]) ->
-  [{do, [
-    {'->', FalseMeta, [[false], FalseExpr]},
-    {'->', TrueMeta, [[true], TrueExpr]}
-  ]}];
-rewrite_case_clauses(Clauses) ->
-  Clauses.
-
-assert_no_match_or_guard_scope(Meta, Kind, E) ->
-  assert_no_match_scope(Meta, Kind, E),
-  assert_no_guard_scope(Meta, Kind, E).
-assert_no_match_scope(Meta, _Kind, #{context := match, file := File}) ->
-  compile_error(Meta, File, "invalid expression in match");
-assert_no_match_scope(_Meta, _Kind, _E) -> [].
-assert_no_guard_scope(Meta, _Kind, #{context := guard, file := File}) ->
-  compile_error(Meta, File, "invalid expression in guard");
-assert_no_guard_scope(_Meta, _Kind, _E) -> [].
diff --git a/lib/elixir/src/elixir_exp_clauses.erl b/lib/elixir/src/elixir_exp_clauses.erl
deleted file mode 100644
index 577e7d6dc8a..00000000000
--- a/lib/elixir/src/elixir_exp_clauses.erl
+++ /dev/null
@@ -1,214 +0,0 @@
-%% Handle code related to args, guard and -> matching for case,
-%% fn, receive and friends. try is handled in elixir_try.
--module(elixir_exp_clauses).
--export([match/3, clause/5, def/5, head/2,
-         'case'/3, 'receive'/3, 'try'/3, 'cond'/3]).
--import(elixir_errors, [compile_error/3, compile_error/4]).
--include("elixir.hrl").
-
-match(Fun, Expr, #{context := Context} = E) ->
-  {EExpr, EE} = Fun(Expr, E#{context := match}),
-  {EExpr, EE#{context := Context}}.
-
-def(Fun, Args, Guards, Body, E) ->
-  {EArgs, EA}   = match(Fun, Args, E),
-  {EGuards, EG} = guard(Guards, EA#{context := guard}),
-  {EBody, EB}   = elixir_exp:expand(Body, EG#{context := ?m(E, context)}),
-  {EArgs, EGuards, EBody, EB}.
-
-clause(Meta, Kind, Fun, {'->', ClauseMeta, [_, _]} = Clause, E) when is_function(Fun, 3) ->
-  clause(Meta, Kind, fun(X, Acc) -> Fun(ClauseMeta, X, Acc) end, Clause, E);
-clause(_Meta, _Kind, Fun, {'->', Meta, [Left, Right]}, E) ->
-  {ELeft, EL}  = Fun(Left, E),
-  {ERight, ER} = elixir_exp:expand(Right, EL),
-  {{'->', Meta, [ELeft, ERight]}, ER};
-clause(Meta, Kind, _Fun, _, E) ->
-  compile_error(Meta, ?m(E, file), "expected -> clauses in ~ts", [Kind]).
-
-head([{'when', Meta, [_,_|_] = All}], E) ->
-  {Args, Guard} = elixir_utils:split_last(All),
-  {EArgs, EA}   = match(fun elixir_exp:expand_args/2, Args, E),
-  {EGuard, EG}  = guard(Guard, EA#{context := guard}),
-  {[{'when', Meta, EArgs ++ [EGuard]}], EG#{context := ?m(E, context)}};
-head(Args, E) ->
-  match(fun elixir_exp:expand_args/2, Args, E).
-
-guard({'when', Meta, [Left, Right]}, E) ->
-  {ELeft, EL}  = guard(Left, E),
-  {ERight, ER} = guard(Right, EL),
-  {{'when', Meta, [ELeft, ERight]}, ER};
-guard(Other, E) ->
-  elixir_exp:expand(Other, E).
-
-%% Case
-
-'case'(Meta, [], E) ->
-  compile_error(Meta, ?m(E, file), "missing do keyword in case");
-'case'(Meta, KV, E) when not is_list(KV) ->
-  compile_error(Meta, ?m(E, file), "invalid arguments for case");
-'case'(Meta, KV, E) ->
-  EE = E#{export_vars := []},
-  {EClauses, EVars} = lists:mapfoldl(fun(X, Acc) -> do_case(Meta, X, Acc, EE) end, [], KV),
-  {EClauses, elixir_env:mergev(EVars, E)}.
-
-do_case(Meta, {'do', _} = Do, Acc, E) ->
-  Fun = expand_one(Meta, 'case', 'do', fun head/2),
-  expand_with_export(Meta, 'case', Fun, Do, Acc, E);
-do_case(Meta, {Key, _}, _Acc, E) ->
-  compile_error(Meta, ?m(E, file), "unexpected keyword ~ts in case", [Key]).
-
-%% Cond
-
-'cond'(Meta, [], E) ->
-  compile_error(Meta, ?m(E, file), "missing do keyword in cond");
-'cond'(Meta, KV, E) when not is_list(KV) ->
-  compile_error(Meta, ?m(E, file), "invalid arguments for cond");
-'cond'(Meta, KV, E) ->
-  EE = E#{export_vars := []},
-  {EClauses, EVars} = lists:mapfoldl(fun(X, Acc) -> do_cond(Meta, X, Acc, EE) end, [], KV),
-  {EClauses, elixir_env:mergev(EVars, E)}.
-
-do_cond(Meta, {'do', _} = Do, Acc, E) ->
-  Fun = expand_one(Meta, 'cond', 'do', fun elixir_exp:expand_args/2),
-  expand_with_export(Meta, 'cond', Fun, Do, Acc, E);
-do_cond(Meta, {Key, _}, _Acc, E) ->
-  compile_error(Meta, ?m(E, file), "unexpected keyword ~ts in cond", [Key]).
-
-%% Receive
-
-'receive'(Meta, [], E) ->
-  compile_error(Meta, ?m(E, file), "missing do or after keyword in receive");
-'receive'(Meta, KV, E) when not is_list(KV) ->
-  compile_error(Meta, ?m(E, file), "invalid arguments for receive");
-'receive'(Meta, KV, E) ->
-  EE = E#{export_vars := []},
-  {EClauses, EVars} = lists:mapfoldl(fun(X, Acc) -> do_receive(Meta, X, Acc, EE) end, [], KV),
-  {EClauses, elixir_env:mergev(EVars, E)}.
-
-do_receive(_Meta, {'do', nil} = Do, Acc, _E) ->
-  {Do, Acc};
-do_receive(Meta, {'do', _} = Do, Acc, E) ->
-  Fun = expand_one(Meta, 'receive', 'do', fun head/2),
-  expand_with_export(Meta, 'receive', Fun, Do, Acc, E);
-do_receive(Meta, {'after', [_]} = After, Acc, E) ->
-  Fun = expand_one(Meta, 'receive', 'after', fun elixir_exp:expand_args/2),
-  expand_with_export(Meta, 'receive', Fun, After, Acc, E);
-do_receive(Meta, {'after', _}, _Acc, E) ->
-  compile_error(Meta, ?m(E, file), "expected a single -> clause for after in receive");
-do_receive(Meta, {Key, _}, _Acc, E) ->
-  compile_error(Meta, ?m(E, file), "unexpected keyword ~ts in receive", [Key]).
-
-%% Try
-
-'try'(Meta, [], E) ->
-  compile_error(Meta, ?m(E, file), "missing do keywords in try");
-'try'(Meta, KV, E) when not is_list(KV) ->
-  elixir_errors:compile_error(Meta, ?m(E, file), "invalid arguments for try");
-'try'(Meta, KV, E) ->
-  {lists:map(fun(X) -> do_try(Meta, X, E) end, KV), E}.
-
-do_try(_Meta, {'do', Expr}, E) ->
-  {EExpr, _} = elixir_exp:expand(Expr, E),
-  {'do', EExpr};
-do_try(_Meta, {'after', Expr}, E) ->
-  {EExpr, _} = elixir_exp:expand(Expr, E),
-  {'after', EExpr};
-do_try(Meta, {'else', _} = Else, E) ->
-  Fun = expand_one(Meta, 'try', 'else', fun head/2),
-  expand_without_export(Meta, 'try', Fun, Else, E);
-do_try(Meta, {'catch', _} = Catch, E) ->
-  expand_without_export(Meta, 'try', fun expand_catch/3, Catch, E);
-do_try(Meta, {'rescue', _} = Rescue, E) ->
-  expand_without_export(Meta, 'try', fun expand_rescue/3, Rescue, E);
-do_try(Meta, {Key, _}, E) ->
-  compile_error(Meta, ?m(E, file), "unexpected keyword ~ts in try", [Key]).
-
-expand_catch(_Meta, [_] = Args, E) ->
-  head(Args, E);
-expand_catch(_Meta, [_, _] = Args, E) ->
-  head(Args, E);
-expand_catch(Meta, _, E) ->
-  compile_error(Meta, ?m(E, file), "expected one or two args for catch clauses (->) in try").
-
-expand_rescue(Meta, [Arg], E) ->
-  case expand_rescue(Arg, E) of
-    {EArg, EA} ->
-      {[EArg], EA};
-    false ->
-      compile_error(Meta, ?m(E, file), "invalid rescue clause. The clause should "
-        "match on an alias, a variable or be in the `var in [alias]` format")
-  end;
-expand_rescue(Meta, _, E) ->
-  compile_error(Meta, ?m(E, file), "expected one arg for rescue clauses (->) in try").
-
-%% rescue var => var in _
-expand_rescue({Name, _, Atom} = Var, E) when is_atom(Name), is_atom(Atom) ->
-  expand_rescue({in, [], [Var, {'_', [], ?m(E, module)}]}, E);
-
-%% rescue var in [Exprs]
-expand_rescue({in, Meta, [Left, Right]}, E) ->
-  {ELeft, EL}  = match(fun elixir_exp:expand/2, Left, E),
-  {ERight, ER} = elixir_exp:expand(Right, EL),
-
-  case ELeft of
-    {Name, _, Atom} when is_atom(Name), is_atom(Atom) ->
-      case normalize_rescue(ERight) of
-        false -> false;
-        Other -> {{in, Meta, [ELeft, Other]}, ER}
-      end;
-    _ ->
-      false
-  end;
-
-%% rescue Error => _ in [Error]
-expand_rescue(Arg, E) ->
-  expand_rescue({in, [], [{'_', [], ?m(E, module)}, Arg]}, E).
-
-normalize_rescue({'_', _, Atom} = N) when is_atom(Atom) -> N;
-normalize_rescue(Atom) when is_atom(Atom) -> [Atom];
-normalize_rescue(Other) ->
-  is_list(Other) andalso lists:all(fun is_atom/1, Other) andalso Other.
-
-%% Expansion helpers
-
-%% Returns a function that expands arguments
-%% considering we have at maximum one entry.
-expand_one(Meta, Kind, Key, Fun) ->
-  fun
-    ([_] = Args, E) ->
-      Fun(Args, E);
-    (_, E) ->
-      compile_error(Meta, ?m(E, file),
-        "expected one arg for ~ts clauses (->) in ~ts", [Key, Kind])
-  end.
-
-%% Expands all -> pairs in a given key keeping the overall vars.
-expand_with_export(Meta, Kind, Fun, {Key, Clauses}, Acc, E) when is_list(Clauses) ->
-  EFun =
-    case lists:keyfind(export_head, 1, Meta) of
-      {export_head, true} ->
-        Fun;
-      _ ->
-        fun(Args, #{export_vars := ExportVars} = EE) ->
-          {FArgs, FE} = Fun(Args, EE),
-          {FArgs, FE#{export_vars := ExportVars}}
-        end
-    end,
-  Transformer = fun(Clause, Vars) ->
-    {EClause, EC} = clause(Meta, Kind, EFun, Clause, E),
-    {EClause, elixir_env:merge_vars(Vars, ?m(EC, export_vars))}
-  end,
-  {EClauses, EVars} = lists:mapfoldl(Transformer, Acc, Clauses),
-  {{Key, EClauses}, EVars};
-expand_with_export(Meta, Kind, _Fun, {Key, _}, _Acc, E) ->
-  compile_error(Meta, ?m(E, file), "expected -> clauses for ~ts in ~ts", [Key, Kind]).
-
-%% Expands all -> pairs in a given key but do not keep the overall vars.
-expand_without_export(Meta, Kind, Fun, {Key, Clauses}, E) when is_list(Clauses) ->
-  Transformer = fun(Clause) ->
-    {EClause, _} = clause(Meta, Kind, Fun, Clause, E),
-    EClause
-  end,
-  {Key, lists:map(Transformer, Clauses)};
-expand_without_export(Meta, Kind, _Fun, {Key, _}, E) ->
-  compile_error(Meta, ?m(E, file), "expected -> clauses for ~ts in ~ts", [Key, Kind]).
diff --git a/lib/elixir/src/elixir_expand.erl b/lib/elixir/src/elixir_expand.erl
new file mode 100644
index 00000000000..e1da7aee789
--- /dev/null
+++ b/lib/elixir/src/elixir_expand.erl
@@ -0,0 +1,1313 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+-module(elixir_expand).
+-export([expand/3, expand_args/3, expand_arg/3, format_error/1]).
+-import(elixir_errors, [file_error/4, module_error/4, function_error/4]).
+-include("elixir.hrl").
+
+%% =
+
+expand({'=', Meta, [_, _]} = Expr, S, #{context := match} = E) ->
+  elixir_clauses:parallel_match(Meta, Expr, S, E);
+
+expand({'=', Meta, [Left, Right]}, S, E) ->
+  assert_no_guard_scope(Meta, "=", S, E),
+  {ERight, SR, ER} = expand(Right, S, E),
+  {ELeft, SL, EL} = elixir_clauses:match(fun expand/3, Meta, Left, SR, S, ER),
+  {{'=', Meta, [ELeft, ERight]}, SL, EL};
+
+%% Literal operators
+
+expand({'{}', Meta, Args}, S, E) ->
+  {EArgs, SA, EA} = expand_args(Args, S, E),
+  {{'{}', Meta, EArgs}, SA, EA};
+
+expand({'%{}', Meta, Args}, S, E) ->
+  elixir_map:expand_map(Meta, Args, S, E);
+
+expand({'%', Meta, [Left, Right]}, S, E) ->
+  elixir_map:expand_struct(Meta, Left, Right, S, E);
+
+expand({'<<>>', Meta, Args}, S, E) ->
+  elixir_bitstring:expand(Meta, Args, S, E, false);
+
+expand({'->', Meta, [_, _]}, _S, E) ->
+  file_error(Meta, E, ?MODULE, unhandled_arrow_op);
+
+expand({'::', Meta, [_, _]}, _S, E) ->
+  file_error(Meta, E, ?MODULE, unhandled_type_op);
+
+expand({'|', Meta, [_, _]}, _S, E) ->
+  file_error(Meta, E, ?MODULE, unhandled_cons_op);
+
+%% __block__
+
+expand({'__block__', _Meta, []}, S, E) ->
+  {nil, S, E};
+expand({'__block__', _Meta, [Arg]}, S, E) ->
+  expand(Arg, S, E);
+expand({'__block__', Meta, Args}, S, E) when is_list(Args) ->
+  {EArgs, SA, EA} = expand_block(Args, [], Meta, S, E),
+  {{'__block__', Meta, EArgs}, SA, EA};
+
+%% __aliases__
+
+expand({'__aliases__', _, _} = Alias, S, E) ->
+  expand_aliases(Alias, S, E, true);
+
+%% alias
+
+expand({Kind, Meta, [{{'.', _, [Base, '{}']}, _, Refs} | Rest]}, S, E)
+    when Kind == alias; Kind == require; Kind == import ->
+  case Rest of
+    [] ->
+      expand_multi_alias_call(Kind, Meta, Base, Refs, [], S, E);
+    [Opts] ->
+      lists:keymember(as, 1, Opts) andalso file_error(Meta, E, ?MODULE, as_in_multi_alias_call),
+      expand_multi_alias_call(Kind, Meta, Base, Refs, Opts, S, E)
+  end;
+expand({alias, Meta, [Ref]}, S, E) ->
+  expand({alias, Meta, [Ref, []]}, S, E);
+expand({alias, Meta, [Ref, Opts]}, S, E) ->
+  assert_no_match_or_guard_scope(Meta, "alias", S, E),
+  {ERef, SR, ER} = expand_without_aliases_report(Ref, S, E),
+  {EOpts, ST, ET} = expand_opts(Meta, alias, [as, warn], no_alias_opts(Opts), SR, ER),
+
+  is_atom(ERef) orelse
+    file_error(Meta, E, ?MODULE, {expected_compile_time_module, alias, Ref}),
+
+  {ok, New, EQ} = alias(Meta, ERef, true, EOpts, ET),
+
+  Quoted =
+    case (New /= false) andalso should_warn(Meta, EOpts, EQ) of
+      false ->
+        ERef;
+
+      Pid when ?key(EQ, function) /= nil ->
+        ?tracker:warn_alias(Pid, Meta, New, ERef);
+
+      Pid ->
+        {{'.', Meta, [?tracker, warn_alias]}, Meta, [Pid, Meta, New, ERef]}
+    end,
+
+  {Quoted, ST, EQ};
+
+expand({require, Meta, [Ref]}, S, E) ->
+  expand({require, Meta, [Ref, []]}, S, E);
+expand({require, Meta, [Ref, Opts]}, S, E) ->
+  assert_no_match_or_guard_scope(Meta, "require", S, E),
+
+  {ERef, SR, ER} = expand_without_aliases_report(Ref, S, E),
+  {EOpts, ST, ET}  = expand_opts(Meta, require, [as, warn], no_alias_opts(Opts), SR, ER),
+
+  %% Add the alias to context_modules if defined is set.
+  %% This is used by defmodule in order to store the defined
+  %% module in context modules.
+  case lists:keyfind(defined, 1, Meta) of
+    {defined, Mod} when is_atom(Mod) ->
+      Mods = [Mod | ?key(ET, context_modules)],
+      {ok, _, EU} = alias(Meta, ERef, false, EOpts, ET#{context_modules := Mods}),
+
+      SU = case E of
+        #{function := nil} -> ST;
+        _ -> ST#elixir_ex{runtime_modules=[Mod | ST#elixir_ex.runtime_modules]}
+      end,
+
+      {ERef, SU, EU};
+
+    false when is_atom(ERef) ->
+      elixir_aliases:ensure_loaded(Meta, ERef, ET),
+      RE = elixir_aliases:require(Meta, ERef, EOpts, ET, true),
+      {ok, _, EU} = alias(Meta, ERef, false, EOpts, RE),
+
+      Quoted =
+        case should_warn(Meta, EOpts, EU) of
+          false ->
+            ERef;
+
+          Pid when ?key(EU, function) /= nil ->
+            ?tracker:warn_require(Pid, Meta, ERef);
+
+          Pid ->
+            {{'.', Meta, [?tracker, warn_require]}, Meta, [Pid, Meta, ERef]}
+        end,
+
+      {Quoted, ST, EU};
+
+    false ->
+      file_error(Meta, E, ?MODULE, {expected_compile_time_module, require, Ref})
+  end;
+
+expand({import, Meta, [Left]}, S, E) ->
+  expand({import, Meta, [Left, []]}, S, E);
+
+expand({import, Meta, [Ref, Opts]}, S, E) ->
+  assert_no_match_or_guard_scope(Meta, "import", S, E),
+  {ERef, SR, ER} = expand_without_aliases_report(Ref, S, E),
+  {EOpts, ST, ET} = expand_opts(Meta, import, [only, except, warn], Opts, SR, ER),
+
+  is_atom(ERef) orelse
+    file_error(Meta, E, ?MODULE, {expected_compile_time_module, import, Ref}),
+
+  elixir_aliases:ensure_loaded(Meta, ERef, ET),
+
+  case elixir_import:import(Meta, ERef, EOpts, ET, true, true) of
+    {ok, Imported, EI} ->
+      Quoted =
+        case Imported andalso should_warn(Meta, EOpts, ET) of
+          false ->
+            ERef;
+
+          Pid ->
+            Only =
+              case lists:keyfind(only, 1, EOpts) of
+                {only, List} when is_list(List) -> List;
+                _ -> []
+              end,
+
+            %% If we are outside a function, we turn on the warnings at execution time.
+            case ET of
+              #{function := nil} ->
+                ?tracker:add_import(Pid, ERef, Only, Meta, false),
+                {{'.', Meta, [?tracker, warn_import]}, Meta, [Pid, ERef]};
+
+              #{} ->
+                ?tracker:add_import(Pid, ERef, Only, Meta, true),
+                ERef
+            end
+        end,
+
+        {Quoted, ST, EI};
+
+    {error, Reason} ->
+      elixir_errors:file_error(Meta, E, elixir_import, Reason)
+  end;
+
+%% Compilation environment macros
+
+expand({'__MODULE__', _, Atom}, S, E) when is_atom(Atom) ->
+  {?key(E, module), S, E};
+expand({'__DIR__', _, Atom}, S, E) when is_atom(Atom) ->
+  {filename:dirname(?key(E, file)), S, E};
+expand({'__CALLER__', Meta, Atom} = Caller, S, E) when is_atom(Atom) ->
+  assert_no_match_scope(Meta, "__CALLER__", E),
+  (not S#elixir_ex.caller) andalso function_error(Meta, E, ?MODULE, caller_not_allowed),
+  {Caller, S, E};
+expand({'__STACKTRACE__', Meta, Atom} = Stacktrace, S, E) when is_atom(Atom) ->
+  assert_no_match_scope(Meta, "__STACKTRACE__", E),
+  (not S#elixir_ex.stacktrace) andalso function_error(Meta, E, ?MODULE, stacktrace_not_allowed),
+  {Stacktrace, S, E};
+expand({'__ENV__', Meta, Atom}, S, E) when is_atom(Atom) ->
+  assert_no_match_scope(Meta, "__ENV__", E),
+  {escape_map(escape_env_entries(Meta, S, E)), S, E};
+expand({{'.', DotMeta, [{'__ENV__', Meta, Atom}, Field]}, CallMeta, []}, S, E)
+    when is_atom(Atom), is_atom(Field) ->
+  assert_no_match_scope(Meta, "__ENV__", E),
+  Env = escape_env_entries(Meta, S, E),
+  case maps:is_key(Field, Env) of
+    true  -> {maps:get(Field, Env), S, E};
+    false -> {{{'.', DotMeta, [escape_map(Env), Field]}, CallMeta, []}, S, E}
+  end;
+expand({'__cursor__', Meta, Args}, _S, E) when is_list(Args) ->
+  file_error(Meta, E, ?MODULE, '__cursor__');
+
+%% Quote
+
+expand({Unquote, Meta, [_]}, _S, E) when Unquote == unquote; Unquote == unquote_splicing ->
+  file_error(Meta, E, ?MODULE, {unquote_outside_quote, Unquote});
+
+expand({quote, Meta, [Opts]}, S, E) when is_list(Opts) ->
+  case lists:keytake(do, 1, Opts) of
+    {value, {do, Do}, DoOpts} ->
+      expand({quote, Meta, [DoOpts, [{do, Do}]]}, S, E);
+    false ->
+      file_error(Meta, E, ?MODULE, {missing_option, 'quote', [do]})
+  end;
+
+expand({quote, Meta, [_]}, _S, E) ->
+  file_error(Meta, E, ?MODULE, {invalid_args, 'quote'});
+
+expand({quote, Meta, [Opts, Do]}, S, E) when is_list(Do) ->
+  Exprs =
+    case lists:keyfind(do, 1, Do) of
+      {do, Expr} -> Expr;
+      false -> file_error(Meta, E, ?MODULE, {missing_option, 'quote', [do]})
+    end,
+
+  ValidOpts = [context, location, line, file, unquote, bind_quoted, generated],
+  {EOpts, ST, ET} = expand_opts(Meta, quote, ValidOpts, Opts, S, E),
+
+  Context = proplists:get_value(context, EOpts, case ?key(E, module) of
+    nil -> 'Elixir';
+    Mod -> Mod
+  end),
+
+  {File, Line} = case lists:keyfind(location, 1, EOpts) of
+    {location, keep} ->
+      {?key(E, file), true};
+    false ->
+      {proplists:get_value(file, EOpts, nil), proplists:get_value(line, EOpts, false)}
+  end,
+
+  {Binding, DefaultUnquote} = case lists:keyfind(bind_quoted, 1, EOpts) of
+    {bind_quoted, BQ} ->
+      case is_list(BQ) andalso
+            lists:all(fun({Key, _}) when is_atom(Key) -> true; (_) -> false end, BQ) of
+        true -> {BQ, false};
+        false -> file_error(Meta, E, ?MODULE, {invalid_bind_quoted_for_quote, BQ})
+      end;
+    false ->
+      {[], true}
+  end,
+
+  Unquote = proplists:get_value(unquote, EOpts, DefaultUnquote),
+  Generated = proplists:get_value(generated, EOpts, false),
+
+  {Q, QContext, QPrelude} = elixir_quote:build(Meta, Line, File, Context, Unquote, Generated, ET),
+  {EPrelude, SP, EP} = expand(QPrelude, ST, ET),
+  {EContext, SC, EC} = expand(QContext, SP, EP),
+  Quoted = elixir_quote:quote(Exprs, Q),
+  {EQuoted, ES, EQ} = expand(Quoted, SC, EC),
+  BindingMeta = lists:keydelete(column, 1, Meta),
+
+  EBinding =
+      [{'{}', [],
+        ['=', [], [
+          {'{}', [], [K, BindingMeta, EContext]},
+          V
+        ]
+       ]} || {K, V} <- Binding],
+
+  EBindingQuoted =
+    case EBinding of
+      [] -> EQuoted;
+      _ -> {'{}', [], ['__block__', [], EBinding ++ [EQuoted]]}
+    end,
+
+  case EPrelude of
+    [] -> {EBindingQuoted, ES, EQ};
+    _ -> {{'__block__', [], EPrelude ++ [EBindingQuoted]}, ES, EQ}
+  end;
+
+expand({quote, Meta, [_, _]}, _S, E) ->
+  file_error(Meta, E, ?MODULE, {invalid_args, 'quote'});
+
+%% Functions
+
+expand({'&', Meta, [{super, SuperMeta, Args} = Expr]}, S, E) when is_list(Args) ->
+  assert_no_match_or_guard_scope(Meta, "&", S, E),
+
+  case resolve_super(Meta, length(Args), E) of
+    {Kind, Name, _} when Kind == def; Kind == defp ->
+      expand_fn_capture(Meta, {Name, SuperMeta, Args}, S, E);
+    _ ->
+      expand_fn_capture(Meta, Expr, S, E)
+  end;
+
+expand({'&', Meta, [{'/', ArityMeta, [{super, SuperMeta, Context}, Arity]} = Expr]}, S, E) when is_atom(Context), is_integer(Arity) ->
+  assert_no_match_or_guard_scope(Meta, "&", S, E),
+
+  case resolve_super(Meta, Arity, E) of
+    {Kind, Name, _} when Kind == def; Kind == defp ->
+      expand({'&', Meta, [{'/', ArityMeta, [{Name, SuperMeta, Context}, Arity]}]}, S, E);
+    _ ->
+      expand_fn_capture(Meta, Expr, S, E)
+  end;
+
+expand({'&', Meta, [Arg]}, S, E) ->
+  assert_no_match_or_guard_scope(Meta, "&", S, E),
+  expand_fn_capture(Meta, Arg, S, E);
+
+expand({fn, Meta, Pairs}, S, E) ->
+  assert_no_match_or_guard_scope(Meta, "fn", S, E),
+  elixir_fn:expand(Meta, Pairs, S, E);
+
+%% Case/Receive/Try
+
+expand({'cond', Meta, [Opts]}, S, E) ->
+  assert_no_match_or_guard_scope(Meta, "cond", S, E),
+  assert_no_underscore_clause_in_cond(Opts, E),
+  {EClauses, SC, EC} = elixir_clauses:'cond'(Meta, Opts, S, E),
+  {{'cond', Meta, [EClauses]}, SC, EC};
+
+expand({'case', Meta, [Expr, Options]}, S, E) ->
+  assert_no_match_or_guard_scope(Meta, "case", S, E),
+  expand_case(Meta, Expr, Options, S, E);
+
+expand({'receive', Meta, [Opts]}, S, E) ->
+  assert_no_match_or_guard_scope(Meta, "receive", S, E),
+  {EClauses, SC, EC} = elixir_clauses:'receive'(Meta, Opts, S, E),
+  {{'receive', Meta, [EClauses]}, SC, EC};
+
+expand({'try', Meta, [Opts]}, S, E) ->
+  assert_no_match_or_guard_scope(Meta, "try", S, E),
+  {EClauses, SC, EC} = elixir_clauses:'try'(Meta, Opts, S, E),
+  {{'try', Meta, [EClauses]}, SC, EC};
+
+%% Comprehensions
+
+expand({for, _, [_ | _] } = Expr, S, E) ->
+  expand_for(Expr, S, E, true);
+
+%% With
+
+expand({with, Meta, [_ | _] = Args}, S, E) ->
+  assert_no_match_or_guard_scope(Meta, "with", S, E),
+  elixir_clauses:with(Meta, Args, S, E);
+
+%% Super
+
+expand({super, Meta, Args}, S, E) when is_list(Args) ->
+  assert_no_match_or_guard_scope(Meta, "super", S, E),
+  Arity = length(Args),
+  {Kind, Name, _} = resolve_super(Meta, Arity, E),
+  elixir_env:trace({local_function, Meta, Name, Arity}, E),
+  {EArgs, SA, EA} = expand_args(Args, S, E),
+  {{super, [{super, {Kind, Name}} | Meta], EArgs}, SA, EA};
+
+%% Vars
+
+expand({'^', Meta, [Arg]}, #elixir_ex{prematch={Prematch, _, _}, vars={_, Write}} = S, E) ->
+  NoMatchS = S#elixir_ex{prematch=pin, vars={Prematch, Write}},
+
+  case expand(Arg, NoMatchS, E#{context := nil}) of
+    {{Name, _, Kind} = Var, #elixir_ex{unused=Unused}, _} when is_atom(Name), is_atom(Kind) ->
+      {{'^', Meta, [Var]}, S#elixir_ex{unused=Unused}, E};
+
+    _ ->
+      function_error(Meta, E, ?MODULE, {invalid_arg_for_pin, Arg}),
+      {{'^', Meta, [Arg]}, S, E}
+  end;
+expand({'^', Meta, [Arg]}, S, E) ->
+  function_error(Meta, E, ?MODULE, {pin_outside_of_match, Arg}),
+  {{'^', Meta, [Arg]}, S, E};
+
+expand({'_', Meta, Kind} = Var, S, #{context := Context} = E) when is_atom(Kind) ->
+  (Context /= match) andalso function_error(Meta, E, ?MODULE, unbound_underscore),
+  {Var, S, E};
+
+expand({Name, Meta, Kind}, S, #{context := match} = E) when is_atom(Name), is_atom(Kind) ->
+  #elixir_ex{
+    prematch={_, _, PrematchVersion},
+    unused={Unused, Version},
+    vars={Read, Write}
+  } = S,
+
+  Pair = {Name, elixir_utils:var_context(Meta, Kind)},
+
+  case Read of
+    %% Variable was already overridden
+    #{Pair := VarVersion} when VarVersion >= PrematchVersion ->
+      maybe_warn_underscored_var_repeat(Meta, Name, Kind, E),
+      NewUnused = var_used(Pair, Meta, VarVersion, Unused),
+      NewWrite = (Write /= false) andalso Write#{Pair => Version},
+      Var = {Name, [{version, VarVersion} | Meta], Kind},
+      {Var, S#elixir_ex{vars={Read, NewWrite}, unused={NewUnused, Version}}, E};
+
+    %% Variable is being overridden now
+    #{Pair := _} ->
+      NewUnused = var_unused(Pair, Meta, Version, Unused, true),
+      NewRead = Read#{Pair => Version},
+      NewWrite = (Write /= false) andalso Write#{Pair => Version},
+      Var = {Name, [{version, Version} | Meta], Kind},
+      {Var, S#elixir_ex{vars={NewRead, NewWrite}, unused={NewUnused, Version + 1}}, E};
+
+    %% Variable defined for the first time
+    _ ->
+      NewUnused = var_unused(Pair, Meta, Version, Unused, false),
+      NewRead = Read#{Pair => Version},
+      NewWrite = (Write /= false) andalso Write#{Pair => Version},
+      Var = {Name, [{version, Version} | Meta], Kind},
+      {Var, S#elixir_ex{vars={NewRead, NewWrite}, unused={NewUnused, Version + 1}}, E}
+  end;
+
+expand({Name, Meta, Kind}, S, E) when is_atom(Name), is_atom(Kind) ->
+  #elixir_ex{vars={Read, _Write}, unused={Unused, Version}, prematch=Prematch} = S,
+  Pair = {Name, elixir_utils:var_context(Meta, Kind)},
+
+  Result =
+    case Read of
+      #{Pair := CurrentVersion} ->
+        case Prematch of
+          {Pre, _Cycle, {bitsize, Original}} ->
+            if
+              map_get(Pair, Pre) /= CurrentVersion ->
+                {ok, CurrentVersion};
+
+              is_map_key(Pair, Pre) ->
+                %% TODO: Remove me on Elixir 2.0
+                elixir_errors:file_warn(Meta, E, ?MODULE, {unpinned_bitsize_var, Name, Kind}),
+                {ok, CurrentVersion};
+
+              not is_map_key(Pair, Original) ->
+                {ok, CurrentVersion};
+
+              true ->
+                raise
+            end;
+
+          _ ->
+            {ok, CurrentVersion}
+        end;
+
+      _ ->
+        case E of
+          #{context := guard} -> raise;
+          #{} when S#elixir_ex.prematch =:= pin -> pin;
+          %% TODO: Remove fallback on on_undefined_variable
+          _ -> elixir_config:get(on_undefined_variable)
+        end
+    end,
+
+  case Result of
+    {ok, PairVersion} ->
+      maybe_warn_underscored_var_access(Meta, Name, Kind, E),
+      Var = {Name, [{version, PairVersion} | Meta], Kind},
+      {Var, S#elixir_ex{unused={var_used(Pair, Meta, PairVersion, Unused), Version}}, E};
+
+    Error ->
+      case lists:keyfind(if_undefined, 1, Meta) of
+        {if_undefined, apply} ->
+          expand({Name, Meta, []}, S, E);
+
+        %% TODO: Remove this clause on v2.0 as we will raise by default
+        {if_undefined, raise} ->
+          function_error(Meta, E, ?MODULE, {undefined_var, Name, Kind}),
+          {{Name, Meta, Kind}, S, E};
+
+        %% TODO: Remove this clause on v2.0 as we will no longer support warn
+        _ when Error == warn ->
+          elixir_errors:file_warn(Meta, E, ?MODULE, {undefined_var_to_call, Name}),
+          expand({Name, [{if_undefined, warn} | Meta], []}, S, E);
+
+        _ when Error == pin ->
+          function_error(Meta, E, ?MODULE, {undefined_var_pin, Name, Kind}),
+          {{Name, Meta, Kind}, S, E};
+
+        _ when Error == raise ->
+          SpanMeta =  elixir_env:calculate_span(Meta, Name),
+          function_error(SpanMeta, E, ?MODULE, {undefined_var, Name, Kind}),
+          {{Name, SpanMeta, Kind}, S, E}
+      end
+  end;
+
+%% Local calls
+
+expand({Atom, Meta, Args}, S, E) when is_atom(Atom), is_list(Meta), is_list(Args) ->
+  assert_no_ambiguous_op(Atom, Meta, Args, S, E),
+
+  elixir_dispatch:dispatch_import(Meta, Atom, Args, S, E, fun
+    ({AR, AF}) ->
+      expand_remote(AR, Meta, AF, Meta, Args, S, elixir_env:prepare_write(S, E), E);
+
+    (local) ->
+      expand_local(Meta, Atom, Args, S, E)
+  end);
+
+%% Remote calls
+
+expand({{'.', DotMeta, [Left, Right]}, Meta, Args}, S, E)
+    when (is_tuple(Left) orelse is_atom(Left)), is_atom(Right), is_list(Meta), is_list(Args) ->
+  {ELeft, SL, EL} = expand(Left, elixir_env:prepare_write(S, E), E),
+
+  elixir_dispatch:dispatch_require(Meta, ELeft, Right, Args, S, EL, fun(AR, AF) ->
+    expand_remote(AR, DotMeta, AF, Meta, Args, S, SL, EL)
+  end);
+
+%% Anonymous calls
+
+expand({{'.', DotMeta, [Expr]}, Meta, Args}, S, E) when is_list(Args) ->
+  assert_no_match_or_guard_scope(Meta, "anonymous call", S, E),
+  {[EExpr | EArgs], SA, EA} = expand_args([Expr | Args], S, E),
+  {{{'.', DotMeta, [EExpr]}, Meta, EArgs}, SA, EA};
+
+%% Invalid calls
+
+expand({_, Meta, Args} = Invalid, _S, E) when is_list(Meta) and is_list(Args) ->
+  file_error(Meta, E, ?MODULE, {invalid_call, Invalid});
+
+%% Literals
+
+expand({Left, Right}, S, E) ->
+  {[ELeft, ERight], SE, EE} = expand_args([Left, Right], S, E),
+  {{ELeft, ERight}, SE, EE};
+
+expand(List, S, #{context := match} = E) when is_list(List) ->
+  expand_list(List, fun expand/3, S, E, []);
+
+expand(List, S, E) when is_list(List) ->
+  {EArgs, {SE, _}, EE} =
+    expand_list(List, fun expand_arg/3, {elixir_env:prepare_write(S), S}, E, []),
+
+  {EArgs, elixir_env:close_write(SE, S), EE};
+
+expand(Zero, S, #{context := match} = E) when is_float(Zero), Zero == 0.0 ->
+  elixir_errors:file_warn([], E, ?MODULE, invalid_match_on_zero_float),
+  {Zero, S, E};
+
+expand(Other, S, E) when is_number(Other); is_atom(Other); is_binary(Other) ->
+  {Other, S, E};
+
+expand(Function, S, E) when is_function(Function) ->
+  case (erlang:fun_info(Function, type) == {type, external}) andalso
+        (erlang:fun_info(Function, env) == {env, []}) of
+    true ->
+      {elixir_quote:fun_to_quoted(Function), S, E};
+    false ->
+      file_error([{line, 0}], ?key(E, file), ?MODULE, {invalid_quoted_expr, Function})
+  end;
+
+expand(Pid, S, E) when is_pid(Pid) ->
+  case ?key(E, function) of
+    nil ->
+      {Pid, S, E};
+    Function ->
+      %% TODO: Make me an error on v2.0
+      elixir_errors:file_warn([], E, ?MODULE, {invalid_pid_in_function, Pid, Function}),
+      {Pid, S, E}
+  end;
+
+expand(Other, _S, E) ->
+  file_error([{line, 0}], ?key(E, file), ?MODULE, {invalid_quoted_expr, Other}).
+
+%% Helpers
+
+escape_env_entries(Meta, #elixir_ex{vars={Read, _}}, Env0) ->
+  Env1 = case Env0 of
+    #{function := nil} -> Env0;
+    _ -> Env0#{lexical_tracker := nil, tracers := []}
+  end,
+
+  Env1#{versioned_vars := escape_map(Read), line := ?line(Meta)}.
+
+escape_map(Map) -> {'%{}', [], lists:sort(maps:to_list(Map))}.
+
+expand_multi_alias_call(Kind, Meta, Base, Refs, Opts, S, E) ->
+  {BaseRef, SB, EB} = expand_without_aliases_report(Base, S, E),
+
+  case is_atom(BaseRef) of
+    true ->
+      Fun = fun
+        ({'__aliases__', _, Ref}, SR, ER) ->
+          expand({Kind, Meta, [elixir_aliases:concat([BaseRef | Ref]), Opts]}, SR, ER);
+
+        (Ref, SR, ER) when is_atom(Ref) ->
+          expand({Kind, Meta, [elixir_aliases:concat([BaseRef, Ref]), Opts]}, SR, ER);
+
+        (Other, _SR, _ER) ->
+          file_error(Meta, E, ?MODULE, {expected_compile_time_module, Kind, Other})
+      end,
+
+      mapfold(Fun, SB, EB, Refs);
+
+    false ->
+      file_error(Meta, E, ?MODULE, {invalid_alias, Base})
+  end.
+
+resolve_super(Meta, Arity, E) ->
+  Module = assert_module_scope(Meta, super, E),
+  Function = assert_function_scope(Meta, super, E),
+
+  case Function of
+    {_, Arity} ->
+      {Kind, Name, SuperMeta} = elixir_overridable:super(Meta, Module, Function, E),
+      maybe_warn_deprecated_super_in_gen_server_callback(Meta, Function, SuperMeta, E),
+      {Kind, Name, SuperMeta};
+
+    _ ->
+      file_error(Meta, E, ?MODULE, wrong_number_of_args_for_super)
+  end.
+
+expand_fn_capture(Meta, Arg, S, E) ->
+  case elixir_fn:capture(Meta, Arg, S, E) of
+    {{remote, Remote, Fun, Arity}, RequireMeta, DotMeta, SE, EE} ->
+      AttachedMeta = attach_runtime_module(Remote, RequireMeta, S, E),
+      {{'&', Meta, [{'/', [], [{{'.', DotMeta, [Remote, Fun]}, AttachedMeta, []}, Arity]}]}, SE, EE};
+    {{local, Fun, Arity}, _, _, _SE, #{function := nil}} ->
+      file_error(Meta, E, ?MODULE, {undefined_local_capture, Fun, Arity});
+    {{local, Fun, Arity}, LocalMeta, _, SE, EE} ->
+      {{'&', Meta, [{'/', [], [{Fun, LocalMeta, nil}, Arity]}]}, SE, EE};
+    {expand, Expr, SE, EE} ->
+      expand(Expr, SE, EE)
+  end.
+
+expand_list([{'|', Meta, [_, _] = Args}], Fun, S, E, List) ->
+  {EArgs, SAcc, EAcc} = mapfold(Fun, S, E, Args),
+  expand_list([], Fun, SAcc, EAcc, [{'|', Meta, EArgs} | List]);
+expand_list([H | T], Fun, S, E, List) ->
+  {EArg, SAcc, EAcc} = Fun(H, S, E),
+  expand_list(T, Fun, SAcc, EAcc, [EArg | List]);
+expand_list([], _Fun, S, E, List) ->
+  {lists:reverse(List), S, E}.
+
+expand_block([], Acc, _Meta, S, E) ->
+  {lists:reverse(Acc), S, E};
+expand_block([H], Acc, Meta, S, E) ->
+  {EH, SE, EE} = expand(H, S, E),
+  expand_block([], [EH | Acc], Meta, SE, EE);
+expand_block([{for, _, [_ | _]} = H | T], Acc, Meta, S, E) ->
+  {EH, SE, EE} = expand_for(H, S, E, false),
+  expand_block(T, [EH | Acc], Meta, SE, EE);
+expand_block([{'=', _, [{'_', _, Ctx}, {for, _, [_ | _]} = H]}  | T], Acc, Meta, S, E) when is_atom(Ctx) ->
+  {EH, SE, EE} = expand_for(H, S, E, false),
+  expand_block(T, [EH | Acc], Meta, SE, EE);
+expand_block([H | T], Acc, Meta, S, E) ->
+  {EH, SE, EE} = expand(H, S, E),
+
+  %% Note that checks rely on the code BEFORE expansion
+  %% instead of relying on Erlang checks.
+  %%
+  %% That's because expansion may generate useless
+  %% terms on their own (think compile time removed
+  %% logger calls) and we don't want to catch those.
+  %%
+  %% Or, similarly, the work is all in the expansion
+  %% (for example, to register something) and it is
+  %% simply returning something as replacement.
+  case is_useless_building(H, EH, Meta) of
+    {UselessMeta, UselessTerm} ->
+      elixir_errors:file_warn(UselessMeta, E, ?MODULE, UselessTerm);
+
+    false ->
+      ok
+  end,
+
+  expand_block(T, [EH | Acc], Meta, SE, EE).
+
+%% Note that we don't handle atoms on purpose. They are common
+%% when unquoting AST and it is unlikely that we would catch
+%% bugs as we don't do binary operations on them like in
+%% strings or numbers.
+is_useless_building(H, _, Meta) when is_binary(H); is_number(H) ->
+  {Meta, {useless_literal, H}};
+is_useless_building({'@', Meta, [{Var, _, Ctx}]}, _, _) when is_atom(Ctx); Ctx == [] ->
+  {Meta, {useless_attr, Var}};
+is_useless_building({Var, Meta, Ctx}, {Var, _, Ctx}, _) when is_atom(Ctx) ->
+  {Meta, {useless_var, Var}};
+is_useless_building(_, _, _) ->
+  false.
+
+%% Variables in arguments are not propagated from one
+%% argument to the other. For instance:
+%%
+%%   x = 1
+%%   foo(x = x + 2, x)
+%%   x
+%%
+%% Should be the same as:
+%%
+%%   foo(3, 1)
+%%   3
+%%
+%% However, lexical information is.
+expand_arg(Arg, Acc, E) when is_number(Arg); is_atom(Arg); is_binary(Arg); is_pid(Arg) ->
+  {Arg, Acc, E};
+expand_arg(Arg, {Acc, S}, E) ->
+  {EArg, SAcc, EAcc} = expand(Arg, elixir_env:reset_read(Acc, S), E),
+  {EArg, {SAcc, S}, EAcc}.
+
+expand_args([Arg], S, E) ->
+  {EArg, SE, EE} = expand(Arg, S, E),
+  {[EArg], SE, EE};
+expand_args(Args, S, #{context := match} = E) ->
+  mapfold(fun expand/3, S, E, Args);
+expand_args(Args, S, E) ->
+  {EArgs, {SA, _}, EA} = mapfold(fun expand_arg/3, {elixir_env:prepare_write(S), S}, E, Args),
+  {EArgs, elixir_env:close_write(SA, S), EA}.
+
+mapfold(Fun, S, E, List) ->
+  mapfold(Fun, S, E, List, []).
+
+mapfold(Fun, S, E, [H | T], Acc) ->
+  {RH, RS, RE} = Fun(H, S, E),
+  mapfold(Fun, RS, RE, T, [RH | Acc]);
+mapfold(_Fun, S, E, [], Acc) ->
+  {lists:reverse(Acc), S, E}.
+
+%% Match/var helpers
+
+var_unused({_, Kind} = Pair, Meta, Version, Unused, Override) ->
+  case (Kind == nil) andalso should_warn(Meta) of
+    true -> Unused#{{Pair, Version} => {Meta, Override}};
+    false -> Unused
+  end.
+
+var_used({_, Kind} = Pair, Meta, Version, Unused) ->
+  KeepUnused = lists:keymember(keep_unused, 1, Meta),
+
+  if
+    KeepUnused -> Unused;
+    is_atom(Kind) -> Unused#{{Pair, Version} => false};
+    true -> Unused
+  end.
+
+maybe_warn_underscored_var_repeat(Meta, Name, Kind, E) ->
+  case should_warn(Meta) andalso atom_to_list(Name) of
+    "_" ++ _ ->
+      elixir_errors:file_warn(Meta, E, ?MODULE, {underscored_var_repeat, Name, Kind});
+    _ ->
+      ok
+  end.
+
+maybe_warn_underscored_var_access(Meta, Name, Kind, E) ->
+  case (Kind == nil) andalso should_warn(Meta) andalso atom_to_list(Name) of
+    "_" ++ _ ->
+      elixir_errors:file_warn(Meta, E, ?MODULE, {underscored_var_access, Name});
+    _ ->
+      ok
+  end.
+
+%% TODO: Remove this on Elixir v2.0 and make all GenServer callbacks optional
+maybe_warn_deprecated_super_in_gen_server_callback(Meta, Function, SuperMeta, E) ->
+  case lists:keyfind(context, 1, SuperMeta) of
+    {context, 'Elixir.GenServer'} ->
+      case Function of
+        {child_spec, 1} ->
+          ok;
+
+        _ ->
+          elixir_errors:file_warn(Meta, E, ?MODULE, {super_in_genserver, Function})
+      end;
+
+    _ ->
+      ok
+  end.
+
+should_warn(Meta) ->
+  lists:keyfind(generated, 1, Meta) /= {generated, true}.
+
+%% Case
+
+expand_case(Meta, Expr, Opts, S, E) ->
+  {EExpr, SE, EE} = expand(Expr, S, E),
+
+  ROpts =
+    case lists:member({optimize_boolean, true}, Meta) andalso elixir_utils:returns_boolean(EExpr) of
+      true -> rewrite_case_clauses(Opts);
+      false -> Opts
+    end,
+
+  {EOpts, SO, EO} = elixir_clauses:'case'(Meta, ROpts, SE, EE),
+  {{'case', Meta, [EExpr, EOpts]}, SO, EO}.
+
+rewrite_case_clauses([{do, [
+  {'->', FalseMeta, [
+    [{'when', _, [Var, {{'.', _, ['Elixir.Kernel', 'in']}, _, [Var, [false, nil]]}]}],
+    FalseExpr
+  ]},
+  {'->', TrueMeta, [
+    [{'_', _, _}],
+    TrueExpr
+  ]}
+]}]) ->
+  rewrite_case_clauses(FalseMeta, FalseExpr, TrueMeta, TrueExpr);
+
+rewrite_case_clauses([{do, [
+  {'->', FalseMeta, [[false], FalseExpr]},
+  {'->', TrueMeta, [[true], TrueExpr]} | _
+]}]) ->
+  rewrite_case_clauses(FalseMeta, FalseExpr, TrueMeta, TrueExpr);
+
+rewrite_case_clauses(Opts) ->
+  Opts.
+
+rewrite_case_clauses(FalseMeta, FalseExpr, TrueMeta, TrueExpr) ->
+  [{do, [
+    {'->', FalseMeta, [[false], FalseExpr]},
+    {'->', TrueMeta, [[true], TrueExpr]}
+  ]}].
+
+%% Comprehensions
+
+expand_for({for, Meta, [_ | _] = Args}, S, E, Return) ->
+  assert_no_match_or_guard_scope(Meta, "for", S, E),
+  {Cases, Block} = elixir_utils:split_opts(Args),
+  validate_opts(Meta, for, [do, into, uniq, reduce], Block, E),
+
+  {Expr, Opts} =
+    case lists:keytake(do, 1, Block) of
+      {value, {do, Do}, DoOpts} ->
+        {Do, DoOpts};
+      false ->
+        file_error(Meta, E, ?MODULE, {missing_option, for, [do]})
+    end,
+
+  {EOpts, SO, EO} = expand(Opts, elixir_env:reset_unused_vars(S), E),
+  {ECases, SC, EC} = mapfold(fun expand_for_generator/3, SO, EO, Cases),
+  assert_generator_start(Meta, ECases, E),
+
+  {{EExpr, SE, EE}, NormalizedOpts} =
+    case validate_for_options(EOpts, false, false, false, Return, Meta, E, []) of
+      {ok, MaybeReduce, NOpts} -> {expand_for_do_block(Meta, Expr, SC, EC, MaybeReduce), NOpts};
+      {error, Error} -> {file_error(Meta, E, ?MODULE, Error), EOpts}
+    end,
+
+  {{for, Meta, ECases ++ [[{do, EExpr} | NormalizedOpts]]},
+   elixir_env:merge_and_check_unused_vars(SE, S, EE),
+   E}.
+
+validate_for_options([{into, _} = Pair | Opts], _Into, Uniq, Reduce, Return, Meta, E, Acc) ->
+  validate_for_options(Opts, Pair, Uniq, Reduce, Return, Meta, E, [Pair | Acc]);
+validate_for_options([{uniq, Boolean} = Pair | Opts], Into, _Uniq, Reduce, Return, Meta, E, Acc) when is_boolean(Boolean) ->
+  validate_for_options(Opts, Into, Pair, Reduce, Return, Meta, E, [Pair | Acc]);
+validate_for_options([{uniq, Value} | _], _, _, _, _, _, _, _) ->
+  {error, {for_invalid_uniq, Value}};
+validate_for_options([{reduce, _} = Pair | Opts], Into, Uniq, _Reduce, Return, Meta, E, Acc) ->
+  validate_for_options(Opts, Into, Uniq, Pair, Return, Meta, E, [Pair | Acc]);
+validate_for_options([], Into, Uniq, {reduce, _}, _Return, _Meta, _E, _Acc) when Into /= false; Uniq /= false ->
+  {error, for_conflicting_reduce_into_uniq};
+validate_for_options([], _Into = false, Uniq, Reduce = false, Return = true, Meta, E, Acc) ->
+  Pair = {into, []},
+  validate_for_options([Pair], Pair, Uniq, Reduce, Return, Meta, E, Acc);
+validate_for_options([], Into = false, {uniq, true}, Reduce = false, Return = false, Meta, E, Acc) ->
+  elixir_errors:file_warn(Meta, E, ?MODULE, for_with_unused_uniq),
+  AccWithoutUniq = lists:keydelete(uniq, 1, Acc),
+  validate_for_options([], Into, false, Reduce, Return, Meta, E, AccWithoutUniq);
+validate_for_options([], _Into, _Uniq, Reduce, _Return, _Meta, _E, Acc) ->
+  {ok, Reduce, lists:reverse(Acc)}.
+
+expand_for_do_block(Meta, [{'->', _, _} | _], _S, E, false) ->
+  file_error(Meta, E, ?MODULE, for_without_reduce_bad_block);
+expand_for_do_block(_Meta, Expr, S, E, false) ->
+  expand(Expr, S, E);
+expand_for_do_block(Meta, [{'->', _, _} | _] = Clauses, S, E, {reduce, _}) ->
+  Transformer = fun
+    ({_, _, [[{'when', _, [_, _, _ | _]}], _]}, _) ->
+      file_error(Meta, E, ?MODULE, for_with_reduce_bad_block);
+
+    ({_, _, [[_], _]} = Clause, SA) ->
+      SReset = elixir_env:reset_unused_vars(SA),
+
+      {EClause, SAcc, EAcc} =
+        elixir_clauses:clause(Meta, fn, fun elixir_clauses:head/4, Clause, SReset, E),
+
+      {EClause, elixir_env:merge_and_check_unused_vars(SAcc, SA, EAcc)};
+
+    (_, _) ->
+      file_error(Meta, E, ?MODULE, for_with_reduce_bad_block)
+  end,
+
+  {Do, SA} = lists:mapfoldl(Transformer, S, Clauses),
+  {Do, SA, E};
+expand_for_do_block(Meta, _Expr, _S, E, {reduce, _}) ->
+  file_error(Meta, E, ?MODULE, for_with_reduce_bad_block).
+
+%% Locals
+
+assert_no_ambiguous_op(Name, Meta, [Arg], S, E) ->
+  case lists:keyfind(ambiguous_op, 1, Meta) of
+    {ambiguous_op, Kind} ->
+      Pair = {Name, Kind},
+      case S#elixir_ex.vars of
+        {#{Pair := _}, _} ->
+          file_error(Meta, E, ?MODULE, {op_ambiguity, Name, Arg});
+        _ ->
+          ok
+      end;
+    _ ->
+      ok
+  end;
+assert_no_ambiguous_op(_Atom, _Meta, _Args, _S, _E) ->
+  ok.
+
+expand_local(Meta, Name, Args, S, #{function := Function, context := Context} = E)
+    when Function /= nil ->
+  %% In case we have the wrong context, we log a module error
+  %% so we can print multiple entries at the same time.
+  case Context of
+    match ->
+      module_error(Meta, E, ?MODULE, {invalid_local_invocation, "match", {Name, Meta, Args}});
+
+    guard ->
+      module_error(Meta, E, ?MODULE, {invalid_local_invocation, elixir_utils:guard_info(S), {Name, Meta, Args}});
+
+    nil ->
+      elixir_env:trace({local_function, Meta, Name, length(Args)}, E)
+  end,
+
+  {EArgs, SA, EA} = expand_args(Args, S, E),
+  {{Name, Meta, EArgs}, SA, EA};
+expand_local(Meta, Name, Args, _S, #{function := nil} = E) ->
+  file_error(Meta, E, ?MODULE, {undefined_function, Name, Args}).
+
+%% Remote
+
+expand_remote(Receiver, DotMeta, Right, Meta, Args, S, SL, #{context := Context} = E)
+    when is_atom(Receiver) or is_tuple(Receiver) ->
+  if
+    Context =:= guard, is_tuple(Receiver) ->
+      (lists:keyfind(no_parens, 1, Meta) /= {no_parens, true}) andalso
+        function_error(Meta, E, ?MODULE, {parens_map_lookup, Receiver, Right, elixir_utils:guard_info(S)}),
+
+      {{{'.', DotMeta, [Receiver, Right]}, Meta, []}, SL, E};
+
+    Context =:= nil ->
+      AttachedMeta = attach_runtime_module(Receiver, Meta, S, E),
+      {EArgs, {SA, _}, EA} = mapfold(fun expand_arg/3, {SL, S}, E, Args),
+      Rewritten = elixir_rewrite:rewrite(Receiver, DotMeta, Right, AttachedMeta, EArgs),
+      {Rewritten, elixir_env:close_write(SA, S), EA};
+
+    true ->
+      case {Receiver, Right, Args} of
+        {erlang, '+', [Arg]} when is_number(Arg) -> {+Arg, SL, E};
+        {erlang, '-', [Arg]} when is_number(Arg) -> {-Arg, SL, E};
+        _ ->
+          {EArgs, SA, EA} = mapfold(fun expand/3, SL, E, Args),
+
+          case elixir_rewrite:Context(Receiver, DotMeta, Right, Meta, EArgs, S) of
+            {ok, Rewritten} -> {Rewritten, SA, EA};
+            {error, Error} -> file_error(Meta, E, elixir_rewrite, Error)
+          end
+      end
+  end;
+expand_remote(Receiver, DotMeta, Right, Meta, Args, _, _, E) ->
+  Call = {{'.', DotMeta, [Receiver, Right]}, Meta, Args},
+  file_error(Meta, E, ?MODULE, {invalid_call, Call}).
+
+attach_runtime_module(Receiver, Meta, S, _E) ->
+  case lists:member(Receiver, S#elixir_ex.runtime_modules) of
+    true -> [{runtime_module, true} | Meta];
+    false -> Meta
+  end.
+
+%% Lexical helpers
+
+expand_opts(Meta, Kind, Allowed, Opts, S, E) ->
+  {EOpts, SE, EE} = expand(Opts, S, E),
+  validate_opts(Meta, Kind, Allowed, EOpts, EE),
+  {EOpts, SE, EE}.
+
+validate_opts(Meta, Kind, Allowed, Opts, E) when is_list(Opts) ->
+  [begin
+    file_error(Meta, E, ?MODULE, {unsupported_option, Kind, Key})
+  end || {Key, _} <- Opts, not lists:member(Key, Allowed)];
+
+validate_opts(Meta, Kind, _Allowed, Opts, E) ->
+  file_error(Meta, E, ?MODULE, {options_are_not_keyword, Kind, Opts}).
+
+no_alias_opts(Opts) when is_list(Opts) ->
+  case lists:keyfind(as, 1, Opts) of
+    {as, As} -> lists:keystore(as, 1, Opts, {as, no_alias_expansion(As)});
+    false -> Opts
+  end;
+no_alias_opts(Opts) -> Opts.
+
+no_alias_expansion({'__aliases__', _, [H | T]}) when is_atom(H) ->
+  elixir_aliases:concat([H | T]);
+no_alias_expansion(Other) ->
+  Other.
+
+should_warn(_Meta, _Opts, #{lexical_tracker := nil}) ->
+  false;
+should_warn(Meta, Opts, #{lexical_tracker := Pid}) ->
+  case lists:keyfind(warn, 1, Opts) of
+    {warn, false} -> false;
+    {warn, true} -> Pid;
+    false ->
+      case lists:keymember(context, 1, Meta) of
+        true -> false;
+        false -> Pid
+      end
+  end.
+
+%% Aliases
+
+alias(Meta, Ref, IncludeByDefault, Opts, E) ->
+  case elixir_aliases:alias(Meta, Ref, IncludeByDefault, Opts, E, true) of
+    {ok, New, EA} -> {ok, New, EA};
+    {error, Reason} -> elixir_errors:file_error(Meta, E, elixir_aliases, Reason)
+  end.
+
+expand_without_aliases_report({'__aliases__', _, _} = Alias, S, E) ->
+  expand_aliases(Alias, S, E, false);
+expand_without_aliases_report(Other, S, E) ->
+  expand(Other, S, E).
+
+expand_aliases({'__aliases__', Meta, List} = Alias, S, E, Report) ->
+  case elixir_aliases:expand_or_concat(Meta, List, E, true) of
+    Receiver when is_atom(Receiver) ->
+      if
+        Receiver =:= 'Elixir.True'; Receiver =:= 'Elixir.False'; Receiver =:= 'Elixir.Nil' ->
+          elixir_errors:file_warn(Meta, E, ?MODULE, {commonly_mistaken_alias, Receiver});
+        true ->
+          ok
+      end,
+      Report andalso elixir_env:trace({alias_reference, Meta, Receiver}, E),
+      {Receiver, S, E};
+
+    [Head | Tail] ->
+      {EHead, SA, EA} = expand(Head, S, E),
+
+      case is_atom(EHead) of
+        true ->
+          Receiver = elixir_aliases:concat([EHead | Tail]),
+          Report andalso elixir_env:trace({alias_reference, Meta, Receiver}, E),
+          {Receiver, SA, EA};
+
+        false ->
+          file_error(Meta, E, ?MODULE, {invalid_alias, Alias})
+      end
+  end.
+
+%% Comprehensions
+
+expand_for_generator({'<-', Meta, [Left, Right]}, S, E) ->
+  {ERight, SR, ER} = expand(Right, S, E),
+  SM = elixir_env:reset_read(SR, S),
+  {[ELeft], SL, EL} = elixir_clauses:head(Meta, [Left], SM, ER),
+  {{'<-', Meta, [ELeft, ERight]}, SL, EL};
+expand_for_generator({'<<>>', Meta, Args} = X, S, E) when is_list(Args) ->
+  case elixir_utils:split_last(Args) of
+    {LeftStart, {'<-', OpMeta, [LeftEnd, Right]}} ->
+      {ERight, SR, ER} = expand(Right, S, E),
+      SM = elixir_env:reset_read(SR, S),
+      {ELeft, SL, EL} = elixir_clauses:match(fun(BArg, BS, BE) ->
+        elixir_bitstring:expand(Meta, BArg, BS, BE, true)
+      end, Meta, LeftStart ++ [LeftEnd], SM, SM, ER),
+      {{'<<>>', Meta, [{'<-', OpMeta, [ELeft, ERight]}]}, SL, EL};
+    _ ->
+      expand(X, S, E)
+  end;
+expand_for_generator(X, S, E) ->
+  expand(X, S, E).
+
+assert_generator_start(_, [{'<-', _, [_, _]} | _], _) ->
+  ok;
+assert_generator_start(_, [{'<<>>', _, [{'<-', _, [_, _]}]} | _], _) ->
+  ok;
+assert_generator_start(Meta, _, E) ->
+  elixir_errors:file_error(Meta, E, ?MODULE, for_generator_start).
+
+%% Assertions
+
+assert_module_scope(Meta, Kind, #{module := nil, file := File}) ->
+  file_error(Meta, File, ?MODULE, {invalid_expr_in_scope, "module", Kind});
+assert_module_scope(_Meta, _Kind, #{module:=Module}) -> Module.
+
+assert_function_scope(Meta, Kind, #{function := nil, file := File}) ->
+  file_error(Meta, File, ?MODULE, {invalid_expr_in_scope, "function", Kind});
+assert_function_scope(_Meta, _Kind, #{function := Function}) -> Function.
+
+assert_no_match_or_guard_scope(Meta, Kind, S, E) ->
+  assert_no_match_scope(Meta, Kind, E),
+  assert_no_guard_scope(Meta, Kind, S, E).
+assert_no_match_scope(Meta, Kind, #{context := match, file := File}) ->
+  file_error(Meta, File, ?MODULE, {invalid_pattern_in_match, Kind});
+assert_no_match_scope(_Meta, _Kind, _E) -> ok.
+assert_no_guard_scope(Meta, Kind, S, #{context := guard, file := File}) ->
+  Key =
+    case S of
+      #elixir_ex{prematch={_, _, {bitsize, _}}}  -> invalid_expr_in_bitsize;
+      _ -> invalid_expr_in_guard
+    end,
+  file_error(Meta, File, ?MODULE, {Key, Kind});
+assert_no_guard_scope(_Meta, _Kind, _S, _E) -> ok.
+
+%% Here we look into the Clauses "optimistically", that is, we don't check for
+%% multiple "do"s and similar stuff. After all, the error we're gonna give here
+%% is just a friendlier version of the "undefined variable _" error that we
+%% would raise if we found a "_ -> ..." clause in a "cond". For this reason, if
+%% Clauses has a bad shape, we just do nothing and let future functions catch
+%% this.
+assert_no_underscore_clause_in_cond([{do, Clauses}], E) when is_list(Clauses) ->
+  case lists:last(Clauses) of
+    {'->', Meta, [[{'_', _, Atom}], _]} when is_atom(Atom) ->
+      file_error(Meta, E, ?MODULE, underscore_in_cond);
+    _Other ->
+      ok
+  end;
+assert_no_underscore_clause_in_cond(_Other, _E) ->
+  ok.
+
+%% Errors
+
+format_error(invalid_match_on_zero_float) ->
+  "pattern matching on 0.0 is equivalent to matching only on +0.0 from Erlang/OTP 27+. Instead you must match on +0.0 or -0.0";
+format_error({useless_literal, Term}) ->
+  io_lib:format("code block contains unused literal ~ts "
+                "(remove the literal or assign it to _ to avoid warnings)",
+                ['Elixir.Macro':to_string(Term)]);
+format_error({useless_var, Var}) ->
+  io_lib:format("variable ~ts in code block has no effect as it is never returned "
+                "(remove the variable or assign it to _ to avoid warnings)",
+                [Var]);
+format_error({useless_attr, Attr}) ->
+  io_lib:format("module attribute @~ts in code block has no effect as it is never returned "
+                "(remove the attribute or assign it to _ to avoid warnings)",
+                [Attr]);
+format_error({missing_option, Construct, Opts}) when is_list(Opts) ->
+  StringOpts = lists:map(fun(Opt) -> [$: | atom_to_list(Opt)] end, Opts),
+  io_lib:format("missing ~ts option in \"~ts\"", [string:join(StringOpts, "/"), Construct]);
+format_error({invalid_args, Construct}) ->
+  io_lib:format("invalid arguments for \"~ts\"", [Construct]);
+format_error({for_invalid_uniq, Value}) ->
+  io_lib:format(":uniq option for comprehensions only accepts a boolean, got: ~ts", ['Elixir.Macro':to_string(Value)]);
+format_error(for_conflicting_reduce_into_uniq) ->
+  "cannot use :reduce alongside :into/:uniq in comprehension";
+format_error(for_with_reduce_bad_block) ->
+  "when using :reduce with comprehensions, the do block must be written using acc -> expr clauses, where each clause expects the accumulator as a single argument";
+format_error(for_without_reduce_bad_block) ->
+  "the do block was written using acc -> expr clauses but the :reduce option was not given";
+format_error(for_generator_start) ->
+  "for comprehensions must start with a generator";
+format_error(for_with_unused_uniq) ->
+  "the :uniq option has no effect since the result of the for comprehension is not used";
+format_error(unhandled_arrow_op) ->
+  "misplaced operator ->\n\n"
+  "This typically means invalid syntax or a macro is not available in scope";
+format_error(unhandled_cons_op) ->
+  "misplaced operator |/2\n\n"
+  "The | operator is typically used between brackets to mark the tail of a list:\n\n"
+  "    [head | tail]\n"
+  "    [head, middle, ... | tail]\n\n"
+  "It is also used to update maps and structs, via the %{map | key: value} notation, "
+  "and in typespecs, such as @type and @spec, to express the union of two types";
+format_error(unhandled_type_op) ->
+  "misplaced operator ::/2\n\n"
+  "The :: operator is typically used in bitstrings to specify types and sizes of segments:\n\n"
+  "    <<size::32-integer, letter::utf8, rest::binary>>\n\n"
+  "It is also used in typespecs, such as @type and @spec, to describe inputs and outputs";
+format_error(as_in_multi_alias_call) ->
+  ":as option is not supported by multi-alias call";
+format_error({commonly_mistaken_alias, Ref}) ->
+  Module = 'Elixir.Macro':to_string(Ref),
+  io_lib:format("reserved alias \"~ts\" expands to the atom :\"Elixir.~ts\". Perhaps you meant to write \"~ts\" instead?", [Module, Module, string:casefold(Module)]);
+format_error({expected_compile_time_module, Kind, GivenTerm}) ->
+  io_lib:format("invalid argument for ~ts, expected a compile time atom or alias, got: ~ts",
+                [Kind, 'Elixir.Macro':to_string(GivenTerm)]);
+format_error({unquote_outside_quote, Unquote}) ->
+  %% Unquote can be "unquote" or "unquote_splicing".
+  io_lib:format("~p called outside quote", [Unquote]);
+format_error({invalid_bind_quoted_for_quote, BQ}) ->
+  io_lib:format("invalid :bind_quoted for quote, expected a keyword list of variable names, got: ~ts",
+                ['Elixir.Macro':to_string(BQ)]);
+format_error(wrong_number_of_args_for_super) ->
+  "super must be called with the same number of arguments as the current definition";
+format_error({invalid_arg_for_pin, Arg}) ->
+  io_lib:format("invalid argument for unary operator ^, expected an existing variable, got: ^~ts",
+                ['Elixir.Macro':to_string(Arg)]);
+format_error({pin_outside_of_match, Arg}) ->
+  io_lib:format(
+    "misplaced operator ^~ts\n\n"
+    "The pin operator ^ is supported only inside matches or inside custom macros. "
+    "Make sure you are inside a match or all necessary macros have been required",
+    ['Elixir.Macro':to_string(Arg)]
+  );
+format_error(unbound_underscore) ->
+  "invalid use of _. _ can only be used inside patterns to ignore values and cannot be used in expressions. Make sure you are inside a pattern or change it accordingly";
+format_error({undefined_var, Name, Kind}) ->
+  io_lib:format("undefined variable ~ts", [elixir_utils:var_info(Name, Kind)]);
+format_error({undefined_var_pin, Name, Kind}) ->
+  Message = "undefined variable ^~ts. No variable ~ts has been defined before the current pattern",
+  io_lib:format(Message, [Name, elixir_utils:var_info(Name, Kind)]);
+format_error(underscore_in_cond) ->
+  "invalid use of _ inside \"cond\". If you want the last clause to always match, "
+    "you probably meant to use: true ->";
+format_error({invalid_pattern_in_match, Kind}) ->
+  io_lib:format("invalid pattern in match, ~ts is not allowed in matches", [Kind]);
+format_error({invalid_expr_in_scope, Scope, Kind}) ->
+  io_lib:format("cannot invoke ~ts outside ~ts", [Kind, Scope]);
+format_error({invalid_expr_in_guard, Kind}) ->
+  Message =
+    "invalid expression in guards, ~ts is not allowed in guards. To learn more about "
+    "guards, visit: https://hexdocs.pm/elixir/patterns-and-guards.html#guards",
+  io_lib:format(Message, [Kind]);
+format_error({invalid_expr_in_bitsize, Kind}) ->
+  Message =
+    "~ts is not allowed inside a bitstring size specifier. The size specifier in matches works like guards. "
+    "To learn more about guards, visit: https://hexdocs.pm/elixir/patterns-and-guards.html#guards",
+  io_lib:format(Message, [Kind]);
+format_error({invalid_alias, Expr}) ->
+  Message =
+    "invalid alias: \"~ts\". If you wanted to define an alias, an alias must expand "
+    "to an atom at compile time but it did not, you may use Module.concat/2 to build "
+    "it at runtime. If instead you wanted to invoke a function or access a field, "
+    "wrap the function or field name in double quotes",
+  io_lib:format(Message, ['Elixir.Macro':to_string(Expr)]);
+format_error({op_ambiguity, Name, Arg}) ->
+  NameString = atom_to_binary(Name),
+  ArgString = 'Elixir.Macro':to_string(Arg),
+
+  Message =
+    "\"~ts ~ts\" looks like a function call but there is a variable named \"~ts\". "
+    "If you want to perform a function call, use parentheses:\n"
+    "\n"
+    "    ~ts(~ts)\n"
+    "\n"
+    "If you want to perform an operation on the variable ~ts, use spaces "
+    "around the unary operator",
+  io_lib:format(Message, [NameString, ArgString, NameString, NameString, ArgString, NameString]);
+format_error({invalid_clauses, Name}) ->
+  Message =
+    "the function \"~ts\" cannot handle clauses with the -> operator because it is not a macro. "
+    "Please make sure you are invoking the proper name and that it is a macro",
+  io_lib:format(Message, [Name]);
+format_error({invalid_call, Call}) ->
+  io_lib:format("invalid call ~ts", ['Elixir.Macro':to_string(Call)]);
+format_error({invalid_quoted_expr, Expr}) ->
+  Message =
+    "invalid quoted expression: ~ts\n\n"
+    "Please make sure your quoted expressions are made of valid AST nodes. "
+    "If you would like to introduce a value into the AST, such as a four-element "
+    "tuple or a map, make sure to call Macro.escape/1 before",
+  io_lib:format(Message, ['Elixir.Kernel':inspect(Expr, [])]);
+format_error({invalid_local_invocation, Context, {Name, _, Args} = Call}) ->
+  Message =
+    "cannot find or invoke local ~ts/~B inside a ~ts. "
+    "Only macros can be invoked inside a ~ts and they must be defined before their invocation. Called as: ~ts",
+  io_lib:format(Message, [Name, length(Args), Context, Context, 'Elixir.Macro':to_string(Call)]);
+format_error({invalid_pid_in_function, Pid, {Name, Arity}}) ->
+  io_lib:format("cannot compile PID ~ts inside quoted expression for function ~ts/~B",
+                ['Elixir.Kernel':inspect(Pid, []), Name, Arity]);
+format_error({unsupported_option, Kind, Key}) ->
+  io_lib:format("unsupported option ~ts given to ~s",
+                ['Elixir.Macro':to_string(Key), Kind]);
+format_error({options_are_not_keyword, Kind, Opts}) ->
+  io_lib:format("invalid options for ~s, expected a keyword list, got: ~ts",
+                [Kind, 'Elixir.Macro':to_string(Opts)]);
+format_error({undefined_function, Name, Args}) ->
+  io_lib:format("undefined function ~ts/~B (there is no such import)", [Name, length(Args)]);
+format_error({unpinned_bitsize_var, Name, Kind}) ->
+  io_lib:format("the variable ~ts is accessed inside size(...) of a bitstring "
+                "but it was defined outside of the match. You must precede it with the "
+                "pin operator", [elixir_utils:var_info(Name, Kind)]);
+format_error({underscored_var_repeat, Name, Kind}) ->
+  io_lib:format("the underscored variable ~ts appears more than once in a "
+                "match. This means the pattern will only match if all \"~ts\" bind "
+                "to the same value. If this is the intended behaviour, please "
+                "remove the leading underscore from the variable name, otherwise "
+                "give the variables different names", [elixir_utils:var_info(Name, Kind), Name]);
+format_error({underscored_var_access, Name}) ->
+  io_lib:format("the underscored variable \"~ts\" is used after being set. "
+                "A leading underscore indicates that the value of the variable "
+                "should be ignored. If this is intended please rename the "
+                "variable to remove the underscore", [Name]);
+format_error({nested_comparison, CompExpr}) ->
+  String = 'Elixir.Macro':to_string(CompExpr),
+  io_lib:format("Elixir does not support nested comparisons. Something like\n\n"
+                "     x < y < z\n\n"
+                "is equivalent to\n\n"
+                "     (x < y) < z\n\n"
+                "which ultimately compares z with the boolean result of (x < y). "
+                "Instead, consider joining together each comparison segment with an \"and\", for example,\n\n"
+                "     x < y and y < z\n\n"
+                "You wrote: ~ts", [String]);
+format_error({undefined_local_capture, Fun, Arity}) ->
+  io_lib:format("undefined function ~ts/~B (there is no such import)", [Fun, Arity]);
+format_error(caller_not_allowed) ->
+  "__CALLER__ is available only inside defmacro and defmacrop";
+format_error(stacktrace_not_allowed) ->
+  "__STACKTRACE__ is available only inside catch and rescue clauses of try expressions";
+format_error({undefined_var_to_call, Name}) ->
+  io_lib:format("variable \"~ts\" does not exist and is being expanded to \"~ts()\","
+                " please use parentheses to remove the ambiguity or change the variable name", [Name, Name]);
+format_error({parens_map_lookup, Map, Field, Context}) ->
+  io_lib:format("cannot invoke remote function inside a ~ts. "
+                "If you want to do a map lookup instead, please remove parens from ~ts.~ts()",
+                [Context, 'Elixir.Macro':to_string(Map), Field]);
+format_error({super_in_genserver, {Name, Arity}}) ->
+  io_lib:format("calling super for GenServer callback ~ts/~B is deprecated", [Name, Arity]);
+format_error('__cursor__') ->
+  "reserved special form __cursor__ cannot be expanded, it is used exclusively to annotate ASTs".
\ No newline at end of file
diff --git a/lib/elixir/src/elixir_fn.erl b/lib/elixir/src/elixir_fn.erl
index d51d5702818..9a2a436d67f 100644
--- a/lib/elixir/src/elixir_fn.erl
+++ b/lib/elixir/src/elixir_fn.erl
@@ -1,164 +1,231 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(elixir_fn).
--export([translate/3, capture/3, expand/3]).
--import(elixir_errors, [compile_error/3, compile_error/4]).
+-export([capture/4, expand/4, format_error/1]).
+-import(elixir_errors, [file_error/4]).
 -include("elixir.hrl").
 
-translate(Meta, Clauses, S) ->
-  Transformer = fun({'->', CMeta, [ArgsWithGuards, Expr]}, Acc) ->
-    {Args, Guards} = elixir_clauses:extract_splat_guards(ArgsWithGuards),
-    {TClause, TS } = elixir_clauses:clause(?line(CMeta), fun translate_fn_match/2,
-                                             Args, Expr, Guards, true, Acc),
-    {TClause, elixir_scope:mergef(S, TS)}
+%% Anonymous functions
+
+expand(Meta, Clauses, S, E) when is_list(Clauses) ->
+  Transformer = fun({_, _, [Left, _Right]} = Clause, SA) ->
+    case lists:any(fun is_invalid_arg/1, Left) of
+      true ->
+        file_error(Meta, E, ?MODULE, defaults_in_args);
+      false ->
+        SReset = elixir_env:reset_unused_vars(SA),
+
+        {EClause, SAcc, EAcc} =
+          elixir_clauses:clause(Meta, fn, fun elixir_clauses:head/4, Clause, SReset, E),
+
+        {EClause, elixir_env:merge_and_check_unused_vars(SAcc, SA, EAcc)}
+    end
   end,
 
-  {TClauses, NS} = lists:mapfoldl(Transformer, S, Clauses),
-  Arities = [length(Args) || {clause, _Line, Args, _Guards, _Exprs} <- TClauses],
+  {EClauses, SE} = lists:mapfoldl(Transformer, S, Clauses),
+  EArities = [fn_arity(Args) || {'->', _, [Args, _]} <- EClauses],
 
-  case lists:usort(Arities) of
+  case lists:usort(EArities) of
     [_] ->
-      {{'fun', ?line(Meta), {clauses, TClauses}}, NS};
+      {{fn, Meta, EClauses}, SE, E};
     _ ->
-      compile_error(Meta, S#elixir_scope.file,
-                    "cannot mix clauses with different arities in function definition")
+      file_error(Meta, E, ?MODULE, clauses_with_different_arities)
   end.
 
-translate_fn_match(Arg, S) ->
-  {TArg, TS} = elixir_translator:translate_args(Arg, S#elixir_scope{backup_vars=orddict:new()}),
-  {TArg, TS#elixir_scope{backup_vars=S#elixir_scope.backup_vars}}.
-
-%% Expansion
+is_invalid_arg({'\\\\', _, _}) -> true;
+is_invalid_arg(_) -> false.
 
-expand(Meta, Clauses, E) when is_list(Clauses) ->
-  Transformer = fun(Clause) ->
-    {EClause, _} = elixir_exp_clauses:clause(Meta, fn, fun elixir_exp_clauses:head/2, Clause, E),
-    EClause
-  end,
-  {{fn, Meta, lists:map(Transformer, Clauses)}, E}.
+fn_arity([{'when', _, Args}]) -> length(Args) - 1;
+fn_arity(Args) -> length(Args).
 
 %% Capture
 
-capture(Meta, {'/', _, [{{'.', _, [_, F]} = Dot, RequireMeta , []}, A]}, E) when is_atom(F), is_integer(A) ->
-  Args = [{'&', [], [X]} || X <- lists:seq(1, A)],
-  capture_require(Meta, {Dot, RequireMeta, Args}, E, true);
+capture(Meta, {'/', _, [{{'.', _, [M, F]} = Dot, RequireMeta, []}, A]}, S, E) when is_atom(F), is_integer(A) ->
+  Args = args_from_arity(Meta, A, E),
+  handle_capture_possible_warning(Meta, RequireMeta, M, F, A, E),
+  capture_require({Dot, RequireMeta, Args}, S, E, arity);
 
-capture(Meta, {'/', _, [{F, _, C}, A]}, E) when is_atom(F), is_integer(A), is_atom(C) ->
-  ImportMeta =
-    case lists:keyfind(import_fa, 1, Meta) of
-      {import_fa, {Receiver, Context}} ->
-        lists:keystore(context, 1,
-          lists:keystore(import, 1, Meta, {import, Receiver}),
-          {context, Context}
-        );
-      false -> Meta
-    end,
-  Args = [{'&', [], [X]} || X <- lists:seq(1, A)],
-  capture_import(Meta, {F, ImportMeta, Args}, E, true);
+capture(Meta, {'/', _, [{F, ImportMeta, C}, A]}, S, E) when is_atom(F), is_integer(A), is_atom(C) ->
+  Args = args_from_arity(Meta, A, E),
+  capture_import({F, ImportMeta, Args}, S, E, arity);
 
-capture(Meta, {{'.', _, [_, Fun]}, _, Args} = Expr, E) when is_atom(Fun), is_list(Args) ->
-  capture_require(Meta, Expr, E, is_sequential_and_not_empty(Args));
+capture(_Meta, {{'.', _, [_, Fun]}, _, Args} = Expr, S, E) when is_atom(Fun), is_list(Args) ->
+  capture_require(Expr, S, E, check_sequential_and_not_empty(Args));
 
-capture(Meta, {{'.', _, [_]}, _, Args} = Expr, E) when is_list(Args) ->
-  do_capture(Meta, Expr, E, false);
+capture(Meta, {{'.', _, [_]}, _, Args} = Expr, S, E) when is_list(Args) ->
+  capture_expr(Meta, Expr, S, E, non_sequential);
 
-capture(Meta, {'__block__', _, [Expr]}, E) ->
-  capture(Meta, Expr, E);
+capture(Meta, {'__block__', _, [Expr]}, S, E) ->
+  capture(Meta, Expr, S, E);
 
-capture(Meta, {'__block__', _, _} = Expr, E) ->
-  Message = "invalid args for &, block expressions are not allowed, got: ~ts",
-  compile_error(Meta, ?m(E, file), Message, ['Elixir.Macro':to_string(Expr)]);
+capture(Meta, {'__block__', _, _} = Expr, _S, E) ->
+  file_error(Meta, E, ?MODULE, {block_expr_in_capture, Expr});
 
-capture(Meta, {Atom, _, Args} = Expr, E) when is_atom(Atom), is_list(Args) ->
-  capture_import(Meta, Expr, E, is_sequential_and_not_empty(Args));
+capture(_Meta, {Atom, _, Args} = Expr, S, E) when is_atom(Atom), is_list(Args) ->
+  capture_import(Expr, S, E, check_sequential_and_not_empty(Args));
 
-capture(Meta, {Left, Right}, E) ->
-  capture(Meta, {'{}', Meta, [Left, Right]}, E);
+capture(Meta, {Left, Right}, S, E) ->
+  capture(Meta, {'{}', Meta, [Left, Right]}, S, E);
 
-capture(Meta, List, E) when is_list(List) ->
-  do_capture(Meta, List, E, is_sequential_and_not_empty(List));
+capture(Meta, List, S, E) when is_list(List) ->
+  capture_expr(Meta, List, S, E, check_sequential_and_not_empty(List));
 
-capture(Meta, Arg, E) ->
+capture(Meta, Integer, _S, E) when is_integer(Integer) ->
+  file_error(Meta, E, ?MODULE, {capture_arg_outside_of_capture, Integer});
+
+capture(Meta, Arg, _S, E) ->
   invalid_capture(Meta, Arg, E).
 
-capture_import(Meta, {Atom, ImportMeta, Args} = Expr, E, Sequential) ->
-  Res = Sequential andalso
+capture_import({Atom, ImportMeta, Args} = Expr, S, E, ArgsType) ->
+  Res = ArgsType /= non_sequential andalso
         elixir_dispatch:import_function(ImportMeta, Atom, length(Args), E),
-  handle_capture(Res, Meta, Expr, E, Sequential).
-
-capture_require(Meta, {{'.', _, [Left, Right]}, RequireMeta, Args} = Expr, E, Sequential) ->
-  {Mod, EE} = elixir_exp:expand(Left, E),
-  Res = Sequential andalso case Mod of
-    {Name, _, Context} when is_atom(Name), is_atom(Context) ->
-      {remote, Mod, Right, length(Args)};
-    _ when is_atom(Mod) ->
-      elixir_dispatch:require_function(RequireMeta, Mod, Right, length(Args), EE);
-    _ ->
-      false
-  end,
-  handle_capture(Res, Meta, Expr, EE, Sequential).
-
-handle_capture({local, Fun, Arity}, _Meta, _Expr, _E, _Sequential) ->
-  {local, Fun, Arity};
-handle_capture({remote, Receiver, Fun, Arity}, Meta, _Expr, E, _Sequential) ->
-  Tree = {{'.', [], [erlang, make_fun]}, Meta, [Receiver, Fun, Arity]},
-  {expanded, Tree, E};
-handle_capture(false, Meta, Expr, E, Sequential) ->
-  do_capture(Meta, Expr, E, Sequential).
-
-do_capture(Meta, Expr, E, Sequential) ->
-  case do_escape(Expr, elixir_counter:next(), E, []) of
-    {_, []} when not Sequential ->
+  handle_capture(Res, ImportMeta, ImportMeta, Expr, S, E, ArgsType).
+
+capture_require({{'.', DotMeta, [Left, Right]}, RequireMeta, Args}, S, E, ArgsType) ->
+  case escape(Left, E, []) of
+    {EscLeft, []} ->
+      {ELeft, SE, EE} = elixir_expand:expand(EscLeft, S, E),
+
+      case ELeft of
+        _ when ArgsType /= arity -> ok;
+        Atom when is_atom(Atom) -> ok;
+        {Var, _, Ctx} when is_atom(Var), is_atom(Ctx) -> ok;
+        %% TODO: Raise on Elixir v2.0
+        _ -> elixir_errors:file_warn(RequireMeta, E, ?MODULE, {complex_module_capture, Left})
+      end,
+
+      Res = ArgsType /= non_sequential andalso case ELeft of
+        {Name, _, Context} when is_atom(Name), is_atom(Context) ->
+          {remote, ELeft, Right, length(Args)};
+        _ when is_atom(ELeft) ->
+          elixir_dispatch:require_function(RequireMeta, ELeft, Right, length(Args), EE);
+        _ ->
+          false
+      end,
+
+      Dot = {{'.', DotMeta, [ELeft, Right]}, RequireMeta, Args},
+      handle_capture(Res, RequireMeta, DotMeta, Dot, SE, EE, ArgsType);
+
+    {EscLeft, Escaped} ->
+      Dot = {{'.', DotMeta, [EscLeft, Right]}, RequireMeta, Args},
+      capture_expr(RequireMeta, Dot, S, E, Escaped, ArgsType)
+  end.
+
+handle_capture(false, Meta, _DotMeta, Expr, S, E, ArgsType) ->
+  capture_expr(Meta, Expr, S, E, ArgsType);
+handle_capture(LocalOrRemote, Meta, DotMeta, _Expr, S, E, _ArgsType) ->
+  {LocalOrRemote, Meta, DotMeta, S, E}.
+
+capture_expr(Meta, Expr, S, E, ArgsType) ->
+  capture_expr(Meta, Expr, S, E, [], ArgsType).
+capture_expr(Meta, Expr, S, E, Escaped, ArgsType) ->
+  case escape(Expr, E, Escaped) of
+    {_, []} when ArgsType == non_sequential ->
       invalid_capture(Meta, Expr, E);
+    %% TODO: Remove this clause once we raise on complex module captures like &get_mod().fun/0
+    {{{'.', _, [_, _]} = Dot, _, Args}, []} ->
+      Meta2 = lists:keydelete(no_parens, 1, Meta),
+      Fn = {fn, Meta2, [{'->', Meta2, [[], {Dot, Meta2, Args}]}]},
+      {expand, Fn, S, E};
     {EExpr, EDict} ->
       EVars = validate(Meta, EDict, 1, E),
-      Fn = {fn, Meta, [{'->', Meta, [EVars, EExpr]}]},
-      {expanded, Fn, E}
+      Fn = {fn, [{capture, true} | Meta], [{'->', Meta, [EVars, EExpr]}]},
+      {expand, Fn, S, E}
   end.
 
 invalid_capture(Meta, Arg, E) ->
-  Message = "invalid args for &, expected an expression in the format of &Mod.fun/arity, "
-            "&local/arity or a capture containing at least one argument as &1, got: ~ts",
-  compile_error(Meta, ?m(E, file), Message, ['Elixir.Macro':to_string(Arg)]).
-
-validate(Meta, [{Pos, Var}|T], Pos, E) ->
-  [Var|validate(Meta, T, Pos + 1, E)];
-
-validate(Meta, [{Pos, _}|_], Expected, E) ->
-  compile_error(Meta, ?m(E, file), "capture &~B cannot be defined without &~B", [Pos, Expected]);
+  file_error(Meta, E, ?MODULE, {invalid_args_for_capture, Arg}).
 
+validate(Meta, [{Pos, Var} | T], Pos, E) ->
+  [Var | validate(Meta, T, Pos + 1, E)];
+validate(Meta, [{Pos, _} | _], Expected, E) ->
+  file_error(Meta, E, ?MODULE, {capture_arg_without_predecessor, Pos, Expected});
 validate(_Meta, [], _Pos, _E) ->
   [].
 
-do_escape({'&', _, [Pos]}, Counter, _E, Dict) when is_integer(Pos), Pos > 0 ->
-  Var = {list_to_atom([$x, $@+Pos]), [{counter, Counter}], elixir_fn},
-  {Var, orddict:store(Pos, Var, Dict)};
-
-do_escape({'&', Meta, [Pos]}, _Counter, E, _Dict) when is_integer(Pos) ->
-  compile_error(Meta, ?m(E, file), "capture &~B is not allowed", [Pos]);
-
-do_escape({'&', Meta, _} = Arg, _Counter, E, _Dict) ->
-  Message = "nested captures via & are not allowed: ~ts",
-  compile_error(Meta, ?m(E, file), Message, ['Elixir.Macro':to_string(Arg)]);
-
-do_escape({Left, Meta, Right}, Counter, E, Dict0) ->
-  {TLeft, Dict1}  = do_escape(Left, Counter, E, Dict0),
-  {TRight, Dict2} = do_escape(Right, Counter, E, Dict1),
+escape({'&', Meta, [Pos]}, E, Dict) when is_integer(Pos), Pos > 0 ->
+  % Using a nil context here to emit warnings when variable is unused.
+  % This might pollute user space but is unlikely because variables
+  % named :"&1" are not valid syntax.
+  case orddict:find(Pos, Dict) of
+    {ok, Var} ->
+      {Var, Dict};
+    error ->
+      Next = elixir_module:next_counter(?key(E, module)),
+      Var = {capture, [{counter, Next}, {capture, Pos} | Meta], nil},
+      {Var, orddict:store(Pos, Var, Dict)}
+  end;
+escape({'&', Meta, [Pos]}, E, _Dict) when is_integer(Pos) ->
+  file_error(Meta, E, ?MODULE, {invalid_arity_for_capture, Pos});
+escape({'&', Meta, _} = Arg, E, _Dict) ->
+  file_error(Meta, E, ?MODULE, {nested_capture, Arg});
+escape({Left, Meta, Right}, E, Dict0) ->
+  {TLeft, Dict1}  = escape(Left, E, Dict0),
+  {TRight, Dict2} = escape(Right, E, Dict1),
   {{TLeft, Meta, TRight}, Dict2};
-
-do_escape({Left, Right}, Counter, E, Dict0) ->
-  {TLeft, Dict1}  = do_escape(Left, Counter, E, Dict0),
-  {TRight, Dict2} = do_escape(Right, Counter, E, Dict1),
+escape({Left, Right}, E, Dict0) ->
+  {TLeft, Dict1}  = escape(Left, E, Dict0),
+  {TRight, Dict2} = escape(Right, E, Dict1),
   {{TLeft, TRight}, Dict2};
+escape(List, E, Dict) when is_list(List) ->
+  lists:mapfoldl(fun(X, Acc) -> escape(X, E, Acc) end, Dict, List);
+escape(Other, _E, Dict) ->
+  {Other, Dict}.
 
-do_escape(List, Counter, E, Dict) when is_list(List) ->
-  lists:mapfoldl(fun(X, Acc) -> do_escape(X, Counter, E, Acc) end, Dict, List);
+args_from_arity(_Meta, A, _E) when is_integer(A), A >= 0, A =< 255 ->
+  [{'&', [], [X]} || X <- lists:seq(1, A)];
+args_from_arity(Meta, A, E) ->
+  file_error(Meta, E, ?MODULE, {invalid_arity_for_capture, A}).
 
-do_escape(Other, _Counter, _E, Dict) ->
-  {Other, Dict}.
+check_sequential_and_not_empty([])   -> non_sequential;
+check_sequential_and_not_empty(List) -> check_sequential(List, 1).
+
+check_sequential([{'&', _, [Int]} | T], Int) -> check_sequential(T, Int + 1);
+check_sequential([], _Int) -> sequential;
+check_sequential(_, _Int) -> non_sequential.
 
-is_sequential_and_not_empty([])   -> false;
-is_sequential_and_not_empty(List) -> is_sequential(List, 1).
+handle_capture_possible_warning(Meta, DotMeta, Mod, Fun, Arity, E) ->
+  case (Arity =:= 0) andalso (lists:keyfind(no_parens, 1, DotMeta) /= {no_parens, true}) of
+    true ->
+      elixir_errors:file_warn(Meta, E, ?MODULE, {parens_remote_capture, Mod, Fun});
+
+    false -> ok
+  end.
 
-is_sequential([{'&', _, [Int]}|T], Int) ->
-  is_sequential(T, Int + 1);
-is_sequential([], _Int) -> true;
-is_sequential(_, _Int) -> false.
+%% TODO: Raise on Elixir v2.0
+format_error({parens_remote_capture, Mod, Fun}) ->
+  io_lib:format("extra parentheses on a remote function capture &~ts.~ts()/0 have been "
+                 "deprecated. Please remove the parentheses: &~ts.~ts/0",
+                 ['Elixir.Macro':to_string(Mod), Fun, 'Elixir.Macro':to_string(Mod), Fun]);
+format_error({complex_module_capture, Mod}) ->
+  io_lib:format("expected the module in &module.fun/arity to expand to a variable or an atom, got: ~ts\n"
+                "You can either compute the module name outside of & or convert it to a regular anonymous function.",
+                 ['Elixir.Macro':to_string(Mod)]);
+format_error(clauses_with_different_arities) ->
+  "cannot mix clauses with different arities in anonymous functions";
+format_error(defaults_in_args) ->
+  "anonymous functions cannot have optional arguments";
+format_error({block_expr_in_capture, Expr}) ->
+  io_lib:format("block expressions are not allowed inside the capture operator &, got: ~ts",
+                ['Elixir.Macro':to_string(Expr)]);
+format_error({nested_capture, Arg}) ->
+  io_lib:format("nested captures are not allowed. You cannot define a function using "
+    "the capture operator & inside another function defined via &. Got invalid nested "
+    "capture: ~ts", ['Elixir.Macro':to_string(Arg)]);
+format_error({invalid_arity_for_capture, Arity}) ->
+  io_lib:format("capture argument &~B must be numbered between 1 and 255", [Arity]);
+format_error({capture_arg_outside_of_capture, Integer}) ->
+  io_lib:format("capture argument &~B must be used within the capture operator &", [Integer]);
+format_error({capture_arg_without_predecessor, Pos, Expected}) ->
+  io_lib:format("capture argument &~B cannot be defined without &~B "
+    "(you cannot skip arguments, all arguments must be numbered)", [Pos, Expected]);
+format_error({invalid_args_for_capture, Arg}) ->
+  Message =
+    "invalid args for &, expected one of:\n\n"
+    "  * &Mod.fun/arity to capture a remote function, such as &Enum.map/2\n"
+    "  * &fun/arity to capture a local or imported function, such as &is_atom/1\n"
+    "  * &some_code(&1, ...) containing at least one argument as &1, such as &List.flatten(&1)\n\n"
+    "Got: ~ts",
+  io_lib:format(Message, ['Elixir.Macro':to_string(Arg)]).
diff --git a/lib/elixir/src/elixir_for.erl b/lib/elixir/src/elixir_for.erl
deleted file mode 100644
index d017f6db4d0..00000000000
--- a/lib/elixir/src/elixir_for.erl
+++ /dev/null
@@ -1,338 +0,0 @@
--module(elixir_for).
--export([expand/3, translate/3]).
--include("elixir.hrl").
-
-%% Expansion
-
-expand(Meta, Args, E) ->
-  {Cases, Block} =
-    case elixir_utils:split_last(Args) of
-      {OuterCases, OuterOpts} when is_list(OuterOpts) ->
-        case elixir_utils:split_last(OuterCases) of
-          {InnerCases, InnerOpts} when is_list(InnerOpts) ->
-            {InnerCases, InnerOpts ++ OuterOpts};
-          _ ->
-            {OuterCases, OuterOpts}
-        end;
-      _ ->
-        {Args, []}
-    end,
-
-  {Expr, Opts} =
-    case lists:keyfind(do, 1, Block) of
-      {do, Do} -> {Do, lists:keydelete(do, 1, Block)};
-      _ -> elixir_errors:compile_error(Meta, ?m(E, file),
-            "missing do keyword in for comprehension")
-    end,
-
-  {EOpts, EO}  = elixir_exp:expand(Opts, E),
-  {ECases, EC} = lists:mapfoldl(fun expand/2, EO, Cases),
-  {EExpr, _}   = elixir_exp:expand(Expr, EC),
-  {{for, Meta, ECases ++ [[{do,EExpr}|EOpts]]}, E}.
-
-expand({'<-', Meta, [Left, Right]}, E) ->
-  {ERight, ER} = elixir_exp:expand(Right, E),
-  {ELeft, EL}  = elixir_exp_clauses:match(fun elixir_exp:expand/2, Left, E),
-  {{'<-', Meta, [ELeft, ERight]}, elixir_env:mergev(EL, ER)};
-expand({'<<>>', Meta, Args} = X, E) when is_list(Args) ->
-  case elixir_utils:split_last(Args) of
-    {LeftStart, {'<-', OpMeta, [LeftEnd, Right]}} ->
-      {ERight, ER} = elixir_exp:expand(Right, E),
-      Left = {'<<>>', Meta, LeftStart ++ [LeftEnd]},
-      {ELeft, EL}  = elixir_exp_clauses:match(fun elixir_exp:expand/2, Left, E),
-      {{'<<>>', [], [ {'<-', OpMeta, [ELeft, ERight]}]}, elixir_env:mergev(EL, ER)};
-    _ ->
-      elixir_exp:expand(X, E)
-  end;
-expand(X, E) ->
-  elixir_exp:expand(X, E).
-
-%% Translation
-
-translate(Meta, Args, #elixir_scope{return=Return} = RS) ->
-  S = RS#elixir_scope{return=true},
-  {AccName, _, SA} = elixir_scope:build_var('_', S),
-  {VarName, _, SV} = elixir_scope:build_var('_', SA),
-
-  Line = ?line(Meta),
-  Acc  = {var, Line, AccName},
-  Var  = {var, Line, VarName},
-
-  {Cases, [{do,Expr}|Opts]} = elixir_utils:split_last(Args),
-
-  {TInto, SI} =
-    case lists:keyfind(into, 1, Opts) of
-      {into, Into} -> elixir_translator:translate(Into, SV);
-      false when Return -> {{nil, Line}, SV};
-      false -> {false, SV}
-    end,
-
-  {TCases, SC} = translate_gen(Meta, Cases, [], SI),
-  {TExpr, SE}  = elixir_translator:translate_block(Expr, Return, SC),
-  SF = elixir_scope:mergec(SI, SE),
-
-  case comprehension_expr(TInto, TExpr) of
-    {inline, TIntoExpr} ->
-      {build_inline(Line, TCases, TIntoExpr, TInto, Var, Acc, SE), SF};
-    {into, TIntoExpr} ->
-      build_into(Line, TCases, TIntoExpr, TInto, Var, Acc, SF)
-  end.
-
-translate_gen(ForMeta, [{'<-', Meta, [Left, Right]}|T], Acc, S) ->
-  {TLeft, TRight, TFilters, TT, TS} = translate_gen(Meta, Left, Right, T, S),
-  TAcc = [{enum, Meta, TLeft, TRight, TFilters}|Acc],
-  translate_gen(ForMeta, TT, TAcc, TS);
-translate_gen(ForMeta, [{'<<>>', _, [ {'<-', Meta, [Left, Right]} ]}|T], Acc, S) ->
-  {TLeft, TRight, TFilters, TT, TS} = translate_gen(Meta, Left, Right, T, S),
-  TAcc = [{bin, Meta, TLeft, TRight, TFilters}|Acc],
-  case elixir_bitstring:has_size(TLeft) of
-    true  -> translate_gen(ForMeta, TT, TAcc, TS);
-    false ->
-      elixir_errors:compile_error(Meta, S#elixir_scope.file,
-        "bitstring fields without size are not allowed in bitstring generators")
-  end;
-translate_gen(_ForMeta, [], Acc, S) ->
-  {lists:reverse(Acc), S};
-translate_gen(ForMeta, _, _, S) ->
-  elixir_errors:compile_error(ForMeta, S#elixir_scope.file,
-    "for comprehensions must start with a generator").
-
-translate_gen(_Meta, Left, Right, T, S) ->
-  {TRight, SR} = elixir_translator:translate(Right, S),
-  {TLeft, SL} = elixir_clauses:match(fun elixir_translator:translate/2, Left, SR),
-  {TT, {TFilters, TS}} = translate_filters(T, SL),
-  {TLeft, TRight, TFilters, TT, TS}.
-
-translate_filters(T, S) ->
-  {Filters, Rest} = collect_filters(T, []),
-  {Rest, lists:mapfoldr(fun translate_filter/2, S, Filters)}.
-
-translate_filter(Filter, S) ->
-  {TFilter, TS} = elixir_translator:translate(Filter, S),
-  case elixir_utils:returns_boolean(Filter) of
-    true ->
-      {{nil, TFilter}, TS};
-    false ->
-      {Name, _, VS} = elixir_scope:build_var('_', TS),
-      {{{var, 0, Name}, TFilter}, VS}
-  end.
-
-collect_filters([{'<-', _, [_, _]}|_] = T, Acc) ->
-  {Acc, T};
-collect_filters([{'<<>>', _, [{'<-', _, [_, _]}]}|_] = T, Acc) ->
-  {Acc, T};
-collect_filters([H|T], Acc) ->
-  collect_filters(T, [H|Acc]);
-collect_filters([], Acc) ->
-  {Acc, []}.
-
-%% If all we have is one enum generator, we check if it is a list
-%% for optimization otherwise fallback to the reduce generator.
-build_inline(Line, [{enum, Meta, Left, Right, Filters}] = Orig, Expr, Into, Var, Acc, S) ->
-  case Right of
-    {cons, _, _, _} ->
-      build_comprehension(Line, Orig, Expr, Into);
-    {Other, _, _} when Other == tuple; Other == map ->
-      build_reduce(Orig, Expr, Into, Acc, S);
-    _ ->
-      Clauses = [{enum, Meta, Left, Var, Filters}],
-
-      {'case', -1, Right, [
-        {clause, -1,
-          [Var],
-          [[elixir_utils:erl_call(Line, erlang, is_list, [Var])]],
-          [build_comprehension(Line, Clauses, Expr, Into)]},
-        {clause, -1,
-          [Var],
-          [],
-          [build_reduce(Clauses, Expr, Into, Acc, S)]}
-      ]}
-  end;
-
-build_inline(Line, Clauses, Expr, Into, _Var, Acc, S) ->
-  case lists:all(fun(Clause) -> element(1, Clause) == bin end, Clauses) of
-    true  -> build_comprehension(Line, Clauses, Expr, Into);
-    false -> build_reduce(Clauses, Expr, Into, Acc, S)
-  end.
-
-build_into(Line, Clauses, Expr, Into, Fun, Acc, S) ->
-  {Kind, SK}   = build_var(Line, S),
-  {Reason, SR} = build_var(Line, SK),
-  {Stack, ST}  = build_var(Line, SR),
-  {Done, SD}   = build_var(Line, ST),
-
-  IntoExpr  = {call, Line, Fun, [Acc, pair(Line, cont, Expr)]},
-  MatchExpr = {match, Line,
-    {tuple, Line, [Acc, Fun]},
-    elixir_utils:erl_call(Line, 'Elixir.Collectable', into, [Into])
- },
-
-  TryExpr =
-    {'try', Line,
-      [build_reduce_clause(Clauses, IntoExpr, Acc, Acc, SD)],
-      [{clause, Line,
-        [Done],
-        [],
-        [{call, Line, Fun, [Done, {atom, Line, done}]}]}],
-      [{clause, Line,
-        [{tuple, Line, [Kind, Reason, {var, Line, '_'}]}],
-        [],
-        [{match, Line, Stack, elixir_utils:erl_call(Line, erlang, get_stacktrace, [])},
-         {call, Line, Fun, [Acc, {atom, Line, halt}]},
-         elixir_utils:erl_call(Line, erlang, raise, [Kind, Reason, Stack])]}],
-      []},
-
-  {{block, Line, [MatchExpr, TryExpr]}, SD}.
-
-%% Helpers
-
-build_reduce(Clauses, Expr, false, Acc, S) ->
-  build_reduce_clause(Clauses, Expr, {nil, 0}, Acc, S);
-build_reduce(Clauses, Expr, {nil, Line} = Into, Acc, S) ->
-  ListExpr = {cons, Line, Expr, Acc},
-  elixir_utils:erl_call(Line, lists, reverse,
-    [build_reduce_clause(Clauses, ListExpr, Into, Acc, S)]);
-build_reduce(Clauses, Expr, {bin, _, _} = Into, Acc, S) ->
-  {bin, Line, Elements} = Expr,
-  BinExpr = {bin, Line, [{bin_element, Line, Acc, default, [bitstring]}|Elements]},
-  build_reduce_clause(Clauses, BinExpr, Into, Acc, S).
-
-build_reduce_clause([{enum, Meta, Left, Right, Filters}|T], Expr, Arg, Acc, S) ->
-  Line  = ?line(Meta),
-  Inner = build_reduce_clause(T, Expr, Acc, Acc, S),
-
-  True  = pair(Line, cont, Inner),
-  False = pair(Line, cont, Acc),
-
-  Clauses0 =
-    case is_var(Left) of
-      true  -> [];
-      false ->
-        [{clause, -1,
-          [{var, Line, '_'}, Acc], [],
-          [False]}]
-    end,
-
-  Clauses1 =
-    [{clause, Line,
-      [Left, Acc], [],
-      [join_filters(Line, Filters, True, False)]}|Clauses0],
-
-  Args  = [Right, pair(Line, cont, Arg), {'fun', Line, {clauses, Clauses1}}],
-  Tuple = elixir_utils:erl_call(Line, 'Elixir.Enumerable', reduce, Args),
-
-  %% Use -1 because in case of no returns we don't care about the result
-  elixir_utils:erl_call(-1, erlang, element, [{integer, Line, 2}, Tuple]);
-
-build_reduce_clause([{bin, Meta, Left, Right, Filters}|T], Expr, Arg, Acc, S) ->
-  Line = ?line(Meta),
-  {Tail, ST} = build_var(Line, S),
-  {Fun, SF}  = build_var(Line, ST),
-
-  True  = build_reduce_clause(T, Expr, Acc, Acc, SF),
-  False = Acc,
-
-  {bin, _, Elements} = Left,
-
-  BinMatch =
-    {bin, Line, Elements ++ [{bin_element, Line, Tail, default, [bitstring]}]},
-  NoVarMatch =
-    {bin, Line, no_var(Elements) ++ [{bin_element, Line, Tail, default, [bitstring]}]},
-
-  Clauses =
-    [{clause, Line,
-      [BinMatch, Acc], [],
-      [{call, Line, Fun, [Tail, join_filters(Line, Filters, True, False)]}]},
-     {clause, -1,
-      [NoVarMatch, Acc], [],
-      [{call, Line, Fun, [Tail, False]}]},
-     {clause, -1,
-      [{bin, Line, []}, Acc], [],
-      [Acc]},
-     {clause, -1,
-      [Tail, {var, Line, '_'}], [],
-      [elixir_utils:erl_call(Line, erlang, error, [pair(Line, badarg, Tail)])]}],
-
-  {call, Line,
-    {named_fun, Line, element(3, Fun), Clauses},
-    [Right, Arg]};
-
-build_reduce_clause([], Expr, _Arg, _Acc, _S) ->
-  Expr.
-
-is_var({var, _, _}) -> true;
-is_var(_) -> false.
-
-pair(Line, Atom, Arg) ->
-  {tuple, Line, [{atom, Line, Atom}, Arg]}.
-
-build_var(Line, S) ->
-  {Name, _, ST} = elixir_scope:build_var('_', S),
-  {{var, Line, Name}, ST}.
-
-no_var(Elements) ->
-  [{bin_element, Line, no_var_expr(Expr), Size, Types} ||
-    {bin_element, Line, Expr, Size, Types} <- Elements].
-no_var_expr({var, Line, _}) ->
-  {var, Line, '_'}.
-
-build_comprehension(Line, Clauses, Expr, false) ->
-  {block, Line, [
-    build_comprehension(Line, Clauses, Expr, {nil, Line}),
-    {nil, Line}
-  ]};
-build_comprehension(Line, Clauses, Expr, Into) ->
-  {comprehension_kind(Into), Line, Expr, comprehension_clause(Clauses)}.
-
-comprehension_clause([{Kind, Meta, Left, Right, Filters}|T]) ->
-  Line = ?line(Meta),
-  [{comprehension_generator(Kind), Line, Left, Right}] ++
-    comprehension_filter(Line, Filters) ++
-    comprehension_clause(T);
-comprehension_clause([]) ->
-  [].
-
-comprehension_kind({nil, _}) -> lc;
-comprehension_kind({bin, _, []}) -> bc.
-
-comprehension_generator(enum) -> generate;
-comprehension_generator(bin) -> b_generate.
-
-comprehension_expr({bin, _, []}, {bin, _, _} = Expr) ->
-  {inline, Expr};
-comprehension_expr({bin, Line, []}, Expr) ->
-  BinExpr = {bin, Line, [{bin_element, Line, Expr, default, [bitstring]}]},
-  {inline, BinExpr};
-comprehension_expr({nil, _}, Expr) ->
-  {inline, Expr};
-comprehension_expr(false, Expr) ->
-  {inline, Expr};
-comprehension_expr(_, Expr) ->
-  {into, Expr}.
-
-comprehension_filter(Line, Filters) ->
-  [join_filter(Line, Filter, {atom, Line, true}, {atom, Line, false}) ||
-   Filter <- lists:reverse(Filters)].
-
-join_filters(_Line, [], True, _False) ->
-  True;
-join_filters(Line, [H|T], True, False) ->
-  lists:foldl(fun(Filter, Acc) ->
-    join_filter(Line, Filter, Acc, False)
-  end, join_filter(Line, H, True, False), T).
-
-join_filter(Line, {nil, Filter}, True, False) ->
-  {'case', Line, Filter, [
-    {clause, Line, [{atom, Line, true}], [], [True]},
-    {clause, Line, [{atom, Line, false}], [], [False]}
-  ]};
-join_filter(Line, {Var, Filter}, True, False) ->
-  Guard =
-    {op, Line, 'orelse',
-      {op, Line, '==', Var, {atom, Line, false}},
-      {op, Line, '==', Var, {atom, Line, nil}}},
-
-  {'case', Line, Filter, [
-    {clause, Line, [Var], [[Guard]], [False]},
-    {clause, Line, [{var, Line, '_'}], [], [True]}
-  ]}.
diff --git a/lib/elixir/src/elixir_import.erl b/lib/elixir/src/elixir_import.erl
index ece17e12828..ea7e07833cc 100644
--- a/lib/elixir/src/elixir_import.erl
+++ b/lib/elixir/src/elixir_import.erl
@@ -1,166 +1,285 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 %% Module responsible for handling imports and conflicts
-%% in between local functions and imports.
+%% between local functions and imports.
 %% For imports dispatch, please check elixir_dispatch.
 -module(elixir_import).
--export([import/4, special_form/2, format_error/1]).
+-export([import/6, import/7, special_form/2,
+         record/4, ensure_no_local_conflict/3,
+         format_error/1]).
+-compile(inline_list_funcs).
 -include("elixir.hrl").
 
-%% IMPORT
-
-import(Meta, Ref, Opts, E) ->
-  Res =
-    case keyfind(only, Opts) of
-      {only, functions} ->
-        {import_functions(Meta, Ref, Opts, E),
-          ?m(E, macros)};
-      {only, macros} ->
-        {?m(E, functions),
-          import_macros(true, Meta, Ref, Opts, E)};
-      {only, List} when is_list(List) ->
-        {import_functions(Meta, Ref, Opts, E),
-          import_macros(false, Meta, Ref, Opts, E)};
-      false ->
-        {import_functions(Meta, Ref, Opts, E),
-          import_macros(false, Meta, Ref, Opts, E)}
-    end,
+import(Meta, Ref, Opts, E, Warn, Trace) ->
+  import(Meta, Ref, Opts, E, Warn, Trace, fun Ref:'__info__'/1).
 
-  record_warn(Meta, Ref, Opts, E),
-  Res.
+import(Meta, Ref, Opts, E, Warn, Trace, InfoCallback) ->
+  case import_only_except(Meta, Ref, Opts, E, Warn, InfoCallback) of
+    {Functions, Macros, Added} ->
+      Trace andalso elixir_env:trace({import, Meta, Ref, Opts}, E),
+      EI = E#{functions := Functions, macros := Macros},
+      {ok, Added, elixir_aliases:require(Meta, Ref, [{warn, false} | Opts], EI, Trace)};
 
-import_functions(Meta, Ref, Opts, E) ->
-  calculate(Meta, Ref, Opts, ?m(E, functions), E, fun() -> get_functions(Ref) end).
+    {error, Reason} ->
+      {error, Reason}
+  end.
 
-import_macros(Force, Meta, Ref, Opts, E) ->
-  calculate(Meta, Ref, Opts, ?m(E, macros), E, fun() ->
-    case Force of
-      true  -> get_macros(Meta, Ref, E);
-      false -> get_optional_macros(Ref)
-    end
+import_only_except(Meta, Ref, Opts, E, Warn, InfoCallback) ->
+  MaybeOnly = lists:keyfind(only, 1, Opts),
+
+  case lists:keyfind(except, 1, Opts) of
+    false ->
+      import_only_except(Meta, Ref, MaybeOnly, false, E, Warn, InfoCallback);
+
+    {except, DupExcept} when is_list(DupExcept) ->
+      case ensure_keyword_list(DupExcept) of
+        ok ->
+          Except = ensure_no_duplicates(DupExcept, except, Meta, E, Warn),
+          import_only_except(Meta, Ref, MaybeOnly, Except, E, Warn, InfoCallback);
+
+        error ->
+          {error, {invalid_option, except, DupExcept}}
+      end;
+
+    {except, Other} ->
+      {error, {invalid_option, except, Other}}
+  end.
+
+import_only_except(Meta, Ref, MaybeOnly, Except, E, Warn, InfoCallback) ->
+  case MaybeOnly of
+    {only, functions} ->
+      {Added1, _Used1, Funs} = import_functions(Meta, Ref, Except, E, Warn, InfoCallback),
+      {Funs, keydelete(Ref, ?key(E, macros)), Added1};
+
+    {only, macros} ->
+      {Added2, _Used2, Macs} = import_macros(Meta, Ref, Except, E, Warn, InfoCallback),
+      {keydelete(Ref, ?key(E, functions)), Macs, Added2};
+
+    {only, sigils} ->
+      {Added1, _Used1, Funs} = import_sigil_functions(Meta, Ref, Except, E, Warn, InfoCallback),
+      {Added2, _Used2, Macs} = import_sigil_macros(Meta, Ref, Except, E, Warn, InfoCallback),
+      {Funs, Macs, Added1 or Added2};
+
+    {only, DupOnly} when is_list(DupOnly) ->
+      case ensure_keyword_list(DupOnly) of
+        ok when Except =:= false ->
+          Only = ensure_no_duplicates(DupOnly, only, Meta, E, Warn),
+          {Added1, Used1, Funs} = import_listed_functions(Meta, Ref, Only, E, Warn, InfoCallback),
+          {Added2, Used2, Macs} = import_listed_macros(Meta, Ref, Only, E, Warn, InfoCallback),
+          [Warn andalso elixir_errors:file_warn(Meta, E, ?MODULE, {invalid_import, {Ref, Name, Arity}}) ||
+            {Name, Arity} <- (Only -- Used1) -- Used2],
+          {Funs, Macs, Added1 or Added2};
+
+        ok ->
+          {error, only_and_except_given};
+
+        error ->
+          {error, {invalid_option, only, DupOnly}}
+      end;
+
+    {only, Other} ->
+      {error, {invalid_option, only, Other}};
+
+    false ->
+      {Added1, _Used1, Funs} = import_functions(Meta, Ref, Except, E, Warn, InfoCallback),
+      {Added2, _Used2, Macs} = import_macros(Meta, Ref, Except, E, Warn, InfoCallback),
+      {Funs, Macs, Added1 or Added2}
+  end.
+
+import_listed_functions(Meta, Ref, Only, E, Warn, InfoCallback) ->
+  New = intersection(Only, get_functions(Ref, InfoCallback)),
+  calculate_key(Meta, Ref, ?key(E, functions), New, E, Warn).
+
+import_listed_macros(Meta, Ref, Only, E, Warn, InfoCallback) ->
+  New = intersection(Only, get_macros(InfoCallback)),
+  calculate_key(Meta, Ref, ?key(E, macros), New, E, Warn).
+
+import_functions(Meta, Ref, Except, E, Warn, InfoCallback) ->
+  calculate_except(Meta, Ref, Except, ?key(E, functions), E, Warn, fun() ->
+    get_functions(Ref, InfoCallback)
+  end).
+
+import_macros(Meta, Ref, Except, E, Warn, InfoCallback) ->
+  calculate_except(Meta, Ref, Except, ?key(E, macros), E, Warn, fun() ->
+    get_macros(InfoCallback)
+  end).
+
+import_sigil_functions(Meta, Ref, Except, E, Warn, InfoCallback) ->
+  calculate_except(Meta, Ref, Except, ?key(E, functions), E, Warn, fun() ->
+    filter_sigils(InfoCallback(functions))
+  end).
+
+import_sigil_macros(Meta, Ref, Except, E, Warn, InfoCallback) ->
+  calculate_except(Meta, Ref, Except, ?key(E, macros), E, Warn, fun() ->
+    filter_sigils(InfoCallback(macros))
   end).
 
-record_warn(Meta, Ref, Opts, E) ->
-  Warn =
-    case keyfind(warn, Opts) of
-      {warn, false} -> false;
-      {warn, true} -> true;
-      false -> not lists:keymember(context, 1, Meta)
+calculate_except(Meta, Key, false, Old, E, Warn, Existing) ->
+  New = remove_underscored(Existing()),
+  calculate_key(Meta, Key, Old, New, E, Warn);
+
+calculate_except(Meta, Key, Except, Old, E, Warn, Existing) ->
+  %% We are not checking existence of exports listed in :except
+  %% option on purpose: to support backwards compatible code.
+  %% For example, "import String, except: [trim: 1]"
+  %% should work across all Elixir versions.
+  New =
+    case lists:keyfind(Key, 1, Old) of
+      false -> remove_underscored(Existing()) -- Except;
+      {Key, OldImports} -> OldImports -- Except
     end,
-  elixir_lexical:record_import(Ref, ?line(Meta), Warn, ?m(E, lexical_tracker)).
-
-%% Calculates the imports based on only and except
-
-calculate(Meta, Key, Opts, Old, E, Existing) ->
-  New = case keyfind(only, Opts) of
-    {only, Only} when is_list(Only) ->
-      case Only -- get_exports(Key) of
-        [{Name,Arity}|_] ->
-          Tuple = {invalid_import, {Key, Name, Arity}},
-          elixir_errors:form_error(Meta, ?m(E, file), ?MODULE, Tuple);
-        _ ->
-          intersection(Only, Existing())
-      end;
-    _ ->
-      case keyfind(except, Opts) of
-        false -> remove_underscored(Existing());
-        {except, []} -> remove_underscored(Existing());
-        {except, Except} when is_list(Except) ->
-          case keyfind(Key, Old) of
-            false -> remove_underscored(Existing()) -- Except;
-            {Key,OldImports} -> OldImports -- Except
-          end
-      end
-  end,
-
-  %% Normalize the data before storing it
-  Set   = ordsets:from_list(New),
-  Final = remove_internals(Set),
-
-  case Final of
-    [] -> keydelete(Key, Old);
-    _  ->
-      ensure_no_special_form_conflict(Meta, ?m(E, file), Key, Final),
-      [{Key, Final}|keydelete(Key, Old)]
+  calculate_key(Meta, Key, Old, New, E, Warn).
+
+calculate_key(Meta, Key, Old, New, E, Warn) ->
+  case ordsets:from_list(New) of
+    [] ->
+      {false, [], keydelete(Key, Old)};
+    Set  ->
+      FinalSet = ensure_no_special_form_conflict(Set, Key, Meta, E, Warn),
+      {true, FinalSet, [{Key, FinalSet} | keydelete(Key, Old)]}
   end.
 
-%% Retrieve functions and macros from modules
+%% Record function calls for local conflicts
 
-get_exports(Module) ->
+record(_Tuple, Receiver, Module, Function)
+  when Function == nil; Module == Receiver -> false;
+record(Tuple, Receiver, Module, _Function) ->
   try
-    Module:'__info__'(functions) ++ Module:'__info__'(macros)
+    {Set, _Bag} = elixir_module:data_tables(Module),
+    ets:insert(Set, {{import, Tuple}, Receiver}),
+    true
   catch
-    error:undef -> Module:module_info(exports)
+    error:badarg -> false
   end.
 
-get_functions(Module) ->
+ensure_no_local_conflict('Elixir.Kernel', _All, _E) ->
+  ok;
+ensure_no_local_conflict(Module, AllDefinitions, E) ->
+  {Set, _} = elixir_module:data_tables(Module),
+
+  [try
+     Receiver = ets:lookup_element(Set, {import, Pair}, 2),
+     elixir_errors:module_error(Meta, E, ?MODULE, {import_conflict, Receiver, Pair})
+   catch
+    error:badarg -> false
+   end || {Pair, _, Meta, _} <- AllDefinitions].
+
+%% Retrieve functions and macros from modules
+
+get_functions(Module, InfoCallback) ->
   try
-    Module:'__info__'(functions)
+    InfoCallback(functions)
   catch
-    error:undef -> Module:module_info(exports)
+    error:undef -> remove_internals(Module:module_info(exports))
   end.
 
-get_macros(Meta, Module, E) ->
+get_macros(InfoCallback) ->
   try
-    Module:'__info__'(macros)
+    InfoCallback(macros)
   catch
-    error:undef ->
-      Tuple = {no_macros, Module},
-      elixir_errors:form_error(Meta, ?m(E, file), ?MODULE, Tuple)
+    error:undef -> []
   end.
 
-get_optional_macros(Module)  ->
-  case code:ensure_loaded(Module) of
-    {module, Module} ->
-      try
-        Module:'__info__'(macros)
-      catch
-        error:undef -> []
+filter_sigils(Funs) ->
+  lists:filter(fun is_sigil/1, Funs).
+
+is_sigil({Name, 2}) ->
+  case atom_to_list(Name) of
+    "sigil_" ++ Letters ->
+      case Letters of
+        [L] when L >= $a, L =< $z -> true;
+        [] -> false;
+        [H|T] when H >= $A, H =< $Z ->
+              lists:all(fun(L) -> (L >= $0 andalso L =< $9)
+                                  orelse (L>= $A andalso L =< $Z)
+                        end, T)
       end;
-    {error, _} -> []
-  end.
-
-%% VALIDATION HELPERS
-
-ensure_no_special_form_conflict(Meta, File, Key, [{Name,Arity}|T]) ->
-  case special_form(Name, Arity) of
-    true  ->
-      Tuple = {special_form_conflict, {Key, Name, Arity}},
-      elixir_errors:form_error(Meta, File, ?MODULE, Tuple);
-    false ->
-      ensure_no_special_form_conflict(Meta, File, Key, T)
+    _ ->
+      false
   end;
-
-ensure_no_special_form_conflict(_Meta, _File, _Key, []) -> ok.
+is_sigil(_) ->
+  false.
+
+%% VALIDATION HELPERS\
+
+ensure_keyword_list([]) ->
+  ok;
+ensure_keyword_list([{Key, Value} | Rest]) when is_atom(Key), is_integer(Value) ->
+  ensure_keyword_list(Rest);
+ensure_keyword_list(_Other) ->
+  error.
+
+ensure_no_special_form_conflict(Set, Key, Meta, E, Warn) ->
+  lists:filter(fun({Name, Arity}) ->
+    case special_form(Name, Arity) of
+      true  ->
+        Warn andalso elixir_errors:file_warn(Meta, E, ?MODULE, {special_form_conflict, {Key, Name, Arity}}),
+        false;
+      false ->
+        true
+    end
+  end, Set).
+
+ensure_no_duplicates(Option, Kind, Meta, E, Warn) ->
+  lists:foldl(fun({Name, Arity}, Acc) ->
+    case lists:member({Name, Arity}, Acc) of
+      true ->
+        Warn andalso elixir_errors:file_warn(Meta, E, ?MODULE, {duplicated_import, {Kind, Name, Arity}}),
+        Acc;
+      false ->
+        [{Name, Arity} | Acc]
+    end
+  end, [], Option).
 
 %% ERROR HANDLING
 
-format_error({invalid_import,{Receiver, Name, Arity}}) ->
-  io_lib:format("cannot import ~ts.~ts/~B because it doesn't exist",
+format_error(only_and_except_given) ->
+  ":only and :except can only be given together to import "
+  "when :only is :functions, :macros, or :sigils";
+
+format_error({duplicated_import, {Option, Name, Arity}}) ->
+  io_lib:format("invalid :~s option for import, ~ts/~B is duplicated", [Option, Name, Arity]);
+
+format_error({invalid_import, {Receiver, Name, Arity}}) ->
+  io_lib:format("cannot import ~ts.~ts/~B because it is undefined or private",
     [elixir_aliases:inspect(Receiver), Name, Arity]);
 
-format_error({special_form_conflict,{Receiver, Name, Arity}}) ->
-  io_lib:format("cannot import ~ts.~ts/~B because it conflicts with Elixir special forms",
+format_error({invalid_option, only, Value}) ->
+  Message = "invalid :only option for import, expected value to be an atom :functions, :macros"
+  ", or a literal keyword list of function names with arity as values, got: ~s",
+  io_lib:format(Message, ['Elixir.Macro':to_string(Value)]);
+
+format_error({invalid_option, except, Value}) ->
+  Message = "invalid :except option for import, expected value to be a literal keyword list of function names with arity as values, got: ~s",
+  io_lib:format(Message, ['Elixir.Macro':to_string(Value)]);
+
+format_error({special_form_conflict, {Receiver, Name, Arity}}) ->
+  io_lib:format("cannot import ~ts.~ts/~B because it conflicts with Elixir special forms, the import has been discarded",
     [elixir_aliases:inspect(Receiver), Name, Arity]);
 
 format_error({no_macros, Module}) ->
-  io_lib:format("could not load macros from module ~ts", [elixir_aliases:inspect(Module)]).
+  io_lib:format("could not load macros from module ~ts", [elixir_aliases:inspect(Module)]);
 
-%% LIST HELPERS
+format_error({import_conflict, Receiver, {Name, Arity}}) ->
+  io_lib:format("imported ~ts.~ts/~B conflicts with local function",
+    [elixir_aliases:inspect(Receiver), Name, Arity]).
 
-keyfind(Key, List) ->
-  lists:keyfind(Key, 1, List).
+%% LIST HELPERS
 
 keydelete(Key, List) ->
   lists:keydelete(Key, 1, List).
 
-intersection([H|T], All) ->
+intersection([H | T], All) ->
   case lists:member(H, All) of
-    true  -> [H|intersection(T, All)];
+    true  -> [H | intersection(T, All)];
     false -> intersection(T, All)
   end;
 
 intersection([], _All) -> [].
 
-%% Internal funs that are never imported etc.
+%% Internal funs that are never imported, and the like
 
 remove_underscored(List) ->
   lists:filter(fun({Name, _}) ->
@@ -171,8 +290,7 @@ remove_underscored(List) ->
   end, List).
 
 remove_internals(Set) ->
-  ordsets:del_element({module_info, 1},
-    ordsets:del_element({module_info, 0}, Set)).
+  Set -- [{behaviour_info, 1}, {module_info, 1}, {module_info, 0}].
 
 %% Special forms
 
@@ -180,9 +298,12 @@ special_form('&', 1) -> true;
 special_form('^', 1) -> true;
 special_form('=', 2) -> true;
 special_form('%', 2) -> true;
-special_form('__op__', 2) -> true;
-special_form('__op__', 3) -> true;
+special_form('|', 2) -> true;
+special_form('.', 2) -> true;
+special_form('::', 2) -> true;
+special_form('__aliases__', _) -> true;
 special_form('__block__', _) -> true;
+special_form('__cursor__', _) -> true;
 special_form('->', _) -> true;
 special_form('<<>>', _) -> true;
 special_form('{}', _) -> true;
@@ -195,9 +316,9 @@ special_form('import', 1) -> true;
 special_form('import', 2) -> true;
 special_form('__ENV__', 0) -> true;
 special_form('__CALLER__', 0) -> true;
+special_form('__STACKTRACE__', 0) -> true;
 special_form('__MODULE__', 0) -> true;
 special_form('__DIR__', 0) -> true;
-special_form('__aliases__', _) -> true;
 special_form('quote', 1) -> true;
 special_form('quote', 2) -> true;
 special_form('unquote', 1) -> true;
@@ -205,8 +326,9 @@ special_form('unquote_splicing', 1) -> true;
 special_form('fn', _) -> true;
 special_form('super', _) -> true;
 special_form('for', _) -> true;
+special_form('with', _) -> true;
 special_form('cond', 1) -> true;
 special_form('case', 2) -> true;
-special_form('try', 2) -> true;
+special_form('try', 1) -> true;
 special_form('receive', 1) -> true;
 special_form(_, _) -> false.
diff --git a/lib/elixir/src/elixir_interpolation.erl b/lib/elixir/src/elixir_interpolation.erl
index 1221811b7a0..90321f4fe76 100644
--- a/lib/elixir/src/elixir_interpolation.erl
+++ b/lib/elixir/src/elixir_interpolation.erl
@@ -1,139 +1,258 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 % Handle string and string-like interpolations.
 -module(elixir_interpolation).
--export([extract/5, unescape_chars/1, unescape_chars/2,
-unescape_tokens/1, unescape_tokens/2, unescape_map/1]).
+-export([extract/6, unescape_string/1, unescape_string/2,
+unescape_tokens/1, unescape_map/1]).
 -include("elixir.hrl").
+-include("elixir_tokenizer.hrl").
 
 %% Extract string interpolations
 
-extract(Line, Raw, Interpol, String, Last) ->
-  %% Ignore whatever is in the scope and enable terminator checking.
-  Scope = Raw#elixir_tokenizer{terminators=[], check_terminators=true},
-  extract(Line, Scope, Interpol, String, [], [], Last).
+extract(Line, Column, Scope, Interpol, String, Last) ->
+  extract(String, [], [], Line, Column, Scope, Interpol, Last).
 
 %% Terminators
 
-extract(Line, _Scope, _Interpol, [], Buffer, Output, []) ->
-  finish_extraction(Line, Buffer, Output, []);
+extract([], _Buffer, _Output, Line, Column, #elixir_tokenizer{cursor_completion=false}, _Interpol, Last) ->
+  {error, {string, Line, Column, io_lib:format("missing terminator: ~ts", [[Last]]), []}};
 
-extract(Line, _Scope, _Interpol, [], _Buffer, _Output, Last) ->
-  {error, {string, Line, io_lib:format("missing terminator: ~ts", [[Last]]), []}};
+extract([], Buffer, Output, Line, Column, Scope, _Interpol, _Last) ->
+  finish_extraction([], Buffer, Output, Line, Column, Scope);
 
-extract(Line, _Scope, _Interpol, [Last|Remaining], Buffer, Output, Last) ->
-  finish_extraction(Line, Buffer, Output, Remaining);
+extract([Last | Rest], Buffer, Output, Line, Column, Scope, _Interpol, Last) ->
+  finish_extraction(Rest, Buffer, Output, Line, Column + 1, Scope);
 
 %% Going through the string
 
-extract(Line, Scope, Interpol, [$\\, $\n|Rest], Buffer, Output, Last) ->
-  extract(Line+1, Scope, Interpol, Rest, Buffer, Output, Last);
+extract([$\\, $\r, $\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) ->
+  extract_nl(Rest, [$\n, $\r, $\\ | Buffer], Output, Line, Scope, Interpol, Last);
+
+extract([$\\, $\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) ->
+  extract_nl(Rest, [$\n, $\\ | Buffer], Output, Line, Scope, Interpol, Last);
+
+extract([$\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) ->
+  extract_nl(Rest, [$\n | Buffer], Output, Line, Scope, Interpol, Last);
+
+extract([$\\, Last | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last) ->
+  NewScope =
+    %% TODO: Remove this on Elixir v2.0
+    case Interpol of
+      true ->
+        Scope;
+      false ->
+        Msg = "using \\~ts to escape the closing of an uppercase sigil is deprecated, please use another delimiter or a lowercase sigil instead",
+        prepend_warning(Line, Column, io_lib:format(Msg, [[Last]]), Scope)
+    end,
+
+  extract(Rest, [Last | Buffer], Output, Line, Column+2, NewScope, Interpol, Last);
+
+extract([$\\, Last, Last, Last | Rest], Buffer, Output, Line, Column, Scope, Interpol, [Last, Last, Last] = All) ->
+  extract(Rest, [Last, Last, Last | Buffer], Output, Line, Column+4, Scope, Interpol, All);
+
+extract([$\\, $#, ${ | Rest], Buffer, Output, Line, Column, Scope, true, Last) ->
+  extract(Rest, [${, $#, $\\ | Buffer], Output, Line, Column+3, Scope, true, Last);
+
+extract([$#, ${ | Rest], Buffer, Output, Line, Column, Scope, true, Last) ->
+  Output1 = build_string(Buffer, Output),
+  case elixir_tokenizer:tokenize(Rest, Line, Column + 2, Scope#elixir_tokenizer{terminators=[]}) of
+    {error, {Location, _, "}"}, [$} | NewRest], Warnings, Tokens} ->
+      NewScope = Scope#elixir_tokenizer{warnings=Warnings},
+      {line, EndLine} = lists:keyfind(line, 1, Location),
+      {column, EndColumn} = lists:keyfind(column, 1, Location),
+      Output2 = build_interpol(Line, Column, EndLine, EndColumn, lists:reverse(Tokens), Output1),
+      extract(NewRest, [], Output2, EndLine, EndColumn + 1, NewScope, true, Last);
+    {error, Reason, _, _, _} ->
+      {error, Reason};
+    {ok, EndLine, EndColumn, Warnings, Tokens, Terminators} when Scope#elixir_tokenizer.cursor_completion /= false ->
+      NewScope = Scope#elixir_tokenizer{warnings=Warnings, cursor_completion=noprune},
+      {CursorTerminators, _} = cursor_complete(EndLine, EndColumn, Terminators),
+      Output2 = build_interpol(Line, Column, EndLine, EndColumn, lists:reverse(Tokens, CursorTerminators), Output1),
+      extract([], [], Output2, EndLine, EndColumn, NewScope, true, Last);
+    {ok, _, _, _, _, _} ->
+      {error, {string, Line, Column, "missing interpolation terminator: \"}\"", []}}
+  end;
 
-extract(Line, Scope, Interpol, [$\\, $\r, $\n|Rest], Buffer, Output, Last) ->
-  extract(Line+1, Scope, Interpol, Rest, Buffer, Output, Last);
+extract([$\\ | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last) ->
+  extract_char(Rest, [$\\ | Buffer], Output, Line, Column + 1, Scope, Interpol, Last);
 
-extract(Line, Scope, Interpol, [$\n|Rest], Buffer, Output, Last) ->
-  extract(Line+1, Scope, Interpol, Rest, [$\n|Buffer], Output, Last);
+%% Catch all clause
 
-extract(Line, Scope, Interpol, [$\\, $#, ${|Rest], Buffer, Output, Last) ->
-  extract(Line, Scope, Interpol, Rest, [${,$#|Buffer], Output, Last);
+extract([Char1, Char2 | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last)
+    when Char1 =< 255, Char2 =< 255 ->
+  extract([Char2 | Rest], [Char1 | Buffer], Output, Line, Column + 1, Scope, Interpol, Last);
 
-extract(Line, Scope, Interpol, [$\\,Char|Rest], Buffer, Output, Last) ->
-  extract(Line, Scope, Interpol, Rest, [Char,$\\|Buffer], Output, Last);
+extract(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last) ->
+  extract_char(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last).
 
-extract(Line, Scope, true, [$#, ${|Rest], Buffer, Output, Last) ->
-  Output1 = build_string(Line, Buffer, Output),
+extract_char(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last) ->
+  case unicode_util:gc(Rest) of
+    [Char | _] when ?bidi(Char); ?break(Char) ->
+      Token = io_lib:format("\\u~4.16.0B", [Char]),
+      Pre = if
+        ?bidi(Char) -> "invalid bidirectional formatting character in string: ";
+        true -> "invalid line break character in string: "
+      end,
+      Pos = io_lib:format(". If you want to use such character, use it in its escaped ~ts form instead", [Token]),
+      {error, {?LOC(Line, Column), {Pre, Pos}, Token}};
 
-  case elixir_tokenizer:tokenize(Rest, Line, Scope) of
-    {error, {EndLine, _, "}"}, [$}|NewRest], Tokens} ->
-      Output2 = build_interpol(Line, Tokens, Output1),
-      extract(EndLine, Scope, true, NewRest, [], Output2, Last);
-    {error, Reason, _, _} ->
-      {error, Reason};
-    {ok, _EndLine, _} ->
-      {error, {string, Line, "missing interpolation terminator:}", []}}
-  end;
+    [Char | NewRest] when is_list(Char) ->
+      extract(NewRest, lists:reverse(Char, Buffer), Output, Line, Column + 1, Scope, Interpol, Last);
 
-%% Catch all clause
+    [Char | NewRest] when is_integer(Char) ->
+      extract(NewRest, [Char | Buffer], Output, Line, Column + 1, Scope, Interpol, Last);
+
+    [] ->
+      extract([], Buffer, Output, Line, Column, Scope, Interpol, Last)
+  end.
 
-extract(Line, Scope, Interpol, [Char|Rest], Buffer, Output, Last) ->
-  extract(Line, Scope, Interpol, Rest, [Char|Buffer], Output, Last).
+%% Handle newlines. Heredocs require special attention
+
+extract_nl(Rest, Buffer, Output, Line, Scope, Interpol, [H,H,H] = Last) ->
+  case strip_horizontal_space(Rest, Buffer, 1) of
+    {[H,H,H|NewRest], _NewBuffer, Column} ->
+      finish_extraction(NewRest, Buffer, Output, Line + 1, Column + 3, Scope);
+    {NewRest, NewBuffer, Column} ->
+      extract(NewRest, NewBuffer, Output, Line + 1, Column, Scope, Interpol, Last)
+  end;
+extract_nl(Rest, Buffer, Output, Line, Scope, Interpol, Last) ->
+  extract(Rest, Buffer, Output, Line + 1, Scope#elixir_tokenizer.column, Scope, Interpol, Last).
+
+strip_horizontal_space([H | T], Buffer, Counter) when H =:= $\s; H =:= $\t ->
+  strip_horizontal_space(T, [H | Buffer], Counter + 1);
+strip_horizontal_space(T, Buffer, Counter) ->
+  {T, Buffer, Counter}.
+
+cursor_complete(Line, Column, Terminators) ->
+  lists:mapfoldl(
+    fun({Start, _, _}, AccColumn) ->
+      End = elixir_tokenizer:terminator(Start),
+      {{End, {Line, AccColumn, nil}}, AccColumn + length(erlang:atom_to_list(End))}
+    end,
+    Column,
+    Terminators
+  ).
 
 %% Unescape a series of tokens as returned by extract.
 
 unescape_tokens(Tokens) ->
-  unescape_tokens(Tokens, fun unescape_map/1).
+  try [unescape_token(Token, fun unescape_map/1) || Token <- Tokens] of
+    Unescaped -> {ok, Unescaped}
+  catch
+    {error, _Reason, _Token} = Error -> Error
+  end.
 
-unescape_tokens(Tokens, Map) ->
-  [unescape_token(Token, Map) || Token <- Tokens].
+unescape_token(Token, Map) when is_list(Token) ->
+  unescape_chars(elixir_utils:characters_to_binary(Token), Map);
+unescape_token(Token, Map) when is_binary(Token) ->
+  unescape_chars(Token, Map);
+unescape_token(Other, _Map) ->
+  Other.
 
-unescape_token(Token, Map) when is_binary(Token) -> unescape_chars(Token, Map);
-unescape_token(Other, _Map) -> Other.
+% Unescape string. This is called by Elixir. Wrapped by convenience.
 
-% Unescape chars. For instance, "\" "n" (two chars) needs to be converted to "\n" (one char).
+unescape_string(String) ->
+  unescape_string(String, fun unescape_map/1).
 
-unescape_chars(String) ->
-  unescape_chars(String, fun unescape_map/1).
+unescape_string(String, Map) ->
+  try
+    unescape_chars(String, Map)
+  catch
+    {error, Reason, _} ->
+      Message = elixir_utils:characters_to_binary(Reason),
+      error('Elixir.ArgumentError':exception([{message, Message}]))
+  end.
+
+% Unescape chars. For instance, "\" "n" (two chars) needs to be converted to "\n" (one char).
 
 unescape_chars(String, Map) ->
-  Octals = Map($0) /= false,
-  Hex    = Map($x) /= false,
-  unescape_chars(String, Map, Octals, Hex, <<>>).
+  unescape_chars(String, Map, <<>>).
 
-unescape_chars(<<$\\,A,B,C,Rest/binary>>, Map, true, Hex, Acc) when ?is_octal(A), A =< $3, ?is_octal(B), ?is_octal(C) ->
-  append_escaped(Rest, Map, [A,B,C], true, Hex, Acc, 8);
+unescape_chars(<<$\\, $x, Rest/binary>>, Map, Acc) ->
+  case Map(hex) of
+    true  -> unescape_hex(Rest, Map, Acc);
+    false -> unescape_chars(Rest, Map, <<Acc/binary, $\\, $x>>)
+  end;
 
-unescape_chars(<<$\\,A,B,Rest/binary>>, Map, true, Hex, Acc) when ?is_octal(A), ?is_octal(B) ->
-  append_escaped(Rest, Map, [A,B], true, Hex, Acc, 8);
+unescape_chars(<<$\\, $u, Rest/binary>>, Map, Acc) ->
+  case Map(unicode) of
+    true  -> unescape_unicode(Rest, Map, Acc);
+    false -> unescape_chars(Rest, Map, <<Acc/binary, $\\, $u>>)
+  end;
 
-unescape_chars(<<$\\,A,Rest/binary>>, Map, true, Hex, Acc) when ?is_octal(A) ->
-  append_escaped(Rest, Map, [A], true, Hex, Acc, 8);
+unescape_chars(<<$\\, $\n, Rest/binary>>, Map, Acc) ->
+  case Map(newline) of
+    true  -> unescape_chars(Rest, Map, Acc);
+    false -> unescape_chars(Rest, Map, <<Acc/binary, $\\, $\n>>)
+  end;
 
-unescape_chars(<<$\\,P,A,B,Rest/binary>>, Map, Octal, true, Acc) when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B) ->
-  append_escaped(Rest, Map, [A,B], Octal, true, Acc, 16);
+unescape_chars(<<$\\, $\r, $\n, Rest/binary>>, Map, Acc) ->
+  case Map(newline) of
+    true  -> unescape_chars(Rest, Map, Acc);
+    false -> unescape_chars(Rest, Map, <<Acc/binary, $\\, $\r, $\n>>)
+  end;
 
-unescape_chars(<<$\\,P,A,Rest/binary>>, Map, Octal, true, Acc) when (P == $x orelse P == $X), ?is_hex(A) ->
-  append_escaped(Rest, Map, [A], Octal, true, Acc, 16);
+unescape_chars(<<$\\, Escaped, Rest/binary>>, Map, Acc) ->
+  case Map(Escaped) of
+    false -> unescape_chars(Rest, Map, <<Acc/binary, $\\, Escaped>>);
+    Other -> unescape_chars(Rest, Map, <<Acc/binary, Other>>)
+  end;
 
-unescape_chars(<<$\\,P,${,A,$},Rest/binary>>, Map, Octal, true, Acc) when (P == $x orelse P == $X), ?is_hex(A) ->
-  append_escaped(Rest, Map, [A], Octal, true, Acc, 16);
+unescape_chars(<<Char, Rest/binary>>, Map, Acc) ->
+  unescape_chars(Rest, Map, <<Acc/binary, Char>>);
 
-unescape_chars(<<$\\,P,${,A,B,$},Rest/binary>>, Map, Octal, true, Acc) when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B) ->
-  append_escaped(Rest, Map, [A,B], Octal, true, Acc, 16);
+unescape_chars(<<>>, _Map, Acc) -> Acc.
 
-unescape_chars(<<$\\,P,${,A,B,C,$},Rest/binary>>, Map, Octal, true, Acc) when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B), ?is_hex(C) ->
-  append_escaped(Rest, Map, [A,B,C], Octal, true, Acc, 16);
+% Unescape Helpers
 
-unescape_chars(<<$\\,P,${,A,B,C,D,$},Rest/binary>>, Map, Octal, true, Acc) when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
-  append_escaped(Rest, Map, [A,B,C,D], Octal, true, Acc, 16);
+unescape_hex(<<A, B, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B) ->
+  Bytes = list_to_integer([A, B], 16),
+  unescape_chars(Rest, Map, <<Acc/binary, Bytes>>);
 
-unescape_chars(<<$\\,P,${,A,B,C,D,E,$},Rest/binary>>, Map, Octal, true, Acc) when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) ->
-    append_escaped(Rest, Map, [A,B,C,D,E], Octal, true, Acc, 16);
+unescape_hex(<<_/binary>>, _Map, _Acc) ->
+  throw({error, "invalid hex escape character, expected \\xHH where H is a hexadecimal digit", "\\x"}).
 
-unescape_chars(<<$\\,P,${,A,B,C,D,E,F,$},Rest/binary>>, Map, Octal, true, Acc) when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) ->
-  append_escaped(Rest, Map, [A,B,C,D,E,F], Octal, true, Acc, 16);
+%% Finish deprecated sequences
 
-unescape_chars(<<$\\,Escaped,Rest/binary>>, Map, Octals, Hex, Acc) ->
-  case Map(Escaped) of
-    false -> unescape_chars(Rest, Map, Octals, Hex, <<Acc/binary, $\\, Escaped>>);
-    Other -> unescape_chars(Rest, Map, Octals, Hex, <<Acc/binary, Other>>)
-  end;
+unescape_unicode(<<A, B, C, D, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
+  append_codepoint(Rest, Map, [A, B, C, D], Acc, 16);
 
-unescape_chars(<<Char, Rest/binary>>, Map, Octals, Hex, Acc) ->
-  unescape_chars(Rest, Map, Octals, Hex, <<Acc/binary, Char>>);
+unescape_unicode(<<${, A, $}, Rest/binary>>, Map, Acc) when ?is_hex(A) ->
+  append_codepoint(Rest, Map, [A], Acc, 16);
 
-unescape_chars(<<>>, _Map, _Octals, _Hex, Acc) -> Acc.
+unescape_unicode(<<${, A, B, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B) ->
+  append_codepoint(Rest, Map, [A, B], Acc, 16);
 
-append_escaped(Rest, Map, List, Octal, Hex, Acc, Base) ->
+unescape_unicode(<<${, A, B, C, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C) ->
+  append_codepoint(Rest, Map, [A, B, C], Acc, 16);
+
+unescape_unicode(<<${, A, B, C, D, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
+  append_codepoint(Rest, Map, [A, B, C, D], Acc, 16);
+
+unescape_unicode(<<${, A, B, C, D, E, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) ->
+  append_codepoint(Rest, Map, [A, B, C, D, E], Acc, 16);
+
+unescape_unicode(<<${, A, B, C, D, E, F, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) ->
+  append_codepoint(Rest, Map, [A, B, C, D, E, F], Acc, 16);
+
+unescape_unicode(<<_/binary>>, _Map, _Acc) ->
+  throw({error, "invalid Unicode escape character, expected \\uHHHH or \\u{H*} where H is a hexadecimal digit", "\\u"}).
+
+append_codepoint(Rest, Map, List, Acc, Base) ->
   Codepoint = list_to_integer(List, Base),
   try <<Acc/binary, Codepoint/utf8>> of
-    Binary -> unescape_chars(Rest, Map, Octal, Hex, Binary)
+    Binary -> unescape_chars(Rest, Map, Binary)
   catch
     error:badarg ->
-      Msg = <<"invalid or reserved unicode codepoint ", (integer_to_binary(Codepoint))/binary>>,
-      error('Elixir.ArgumentError':exception([{message,Msg}]))
+      throw({error, "invalid or reserved Unicode code point \\u{" ++ List ++ "}", "\\u"})
   end.
 
-% Unescape Helpers
-
+unescape_map(newline) -> true;
+unescape_map(unicode) -> true;
+unescape_map(hex) -> true;
+unescape_map($0) -> 0;
 unescape_map($a) -> 7;
 unescape_map($b) -> $\b;
 unescape_map($d) -> $\d;
@@ -148,16 +267,19 @@ unescape_map(E)  -> E.
 
 % Extract Helpers
 
-finish_extraction(Line, Buffer, Output, Remaining) ->
-  case build_string(Line, Buffer, Output) of
-    []    -> Final = [<<>>];
-    Final -> []
+finish_extraction(Remaining, Buffer, Output, Line, Column, Scope) ->
+  Final = case build_string(Buffer, Output) of
+    [] -> [[]];
+    F  -> F
   end,
-  {Line, lists:reverse(Final), Remaining}.
 
-build_string(_Line, [], Output) -> Output;
-build_string(_Line, Buffer, Output) ->
-  [elixir_utils:characters_to_binary(lists:reverse(Buffer))|Output].
+  {Line, Column, lists:reverse(Final), Remaining, Scope}.
+
+build_string([], Output) -> Output;
+build_string(Buffer, Output) -> [lists:reverse(Buffer) | Output].
+
+build_interpol(Line, Column, EndLine, EndColumn, Buffer, Output) ->
+  [{{Line, Column, nil}, {EndLine, EndColumn, nil}, Buffer} | Output].
 
-build_interpol(Line, Buffer, Output) ->
-  [{Line, lists:reverse(Buffer)}|Output].
+prepend_warning(Line, Column, Msg, #elixir_tokenizer{warnings=Warnings} = Scope) ->
+  Scope#elixir_tokenizer{warnings = [{{Line, Column}, Msg} | Warnings]}.
diff --git a/lib/elixir/src/elixir_json.erl b/lib/elixir/src/elixir_json.erl
new file mode 100644
index 00000000000..6413fb1e8d9
--- /dev/null
+++ b/lib/elixir/src/elixir_json.erl
@@ -0,0 +1,1140 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2024-2024. All Rights Reserved.
+%%
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(elixir_json).
+
+-dialyzer(no_improper_lists).
+
+-export([
+    encode/1, encode/2,
+    encode_value/2,
+    encode_atom/2,
+    encode_integer/1,
+    encode_float/1,
+    encode_list/2,
+    encode_map/2,
+    encode_map_checked/2,
+    encode_key_value_list/2,
+    encode_key_value_list_checked/2,
+    encode_binary/1,
+    encode_binary_escape_all/1
+]).
+-export_type([encoder/0, encode_value/0]).
+
+-export([
+    decode/1, decode/3, decode_start/3, decode_continue/2
+]).
+-export_type([
+    from_binary_fun/0,
+    array_start_fun/0,
+    array_push_fun/0,
+    array_finish_fun/0,
+    object_start_fun/0,
+    object_push_fun/0,
+    object_finish_fun/0,
+    decoders/0,
+    decode_value/0,
+    continuation_state/0
+]).
+
+-compile({inline, [
+    encode_atom/2,
+    encode_integer/1,
+    encode_float/1,
+    encode_object/1,
+    escape/1,
+    escape_binary/1,
+    escape_all/1,
+    utf8t/0,
+    utf8s/0,
+    utf8s0/0,
+    hex_to_int/4,
+    string/6
+]}).
+
+%% A lot of the macros below use multi-value comparisons where
+%% range checks would have worked just fine. This is because
+%% the compiler & JIT can emit better code in some cases when
+%% multiple clauses are to be dispatched based on such sets
+%% of values. They'll generate an efficient "jump table",
+%% which gets to the correct clause in one go, rather
+%% than going through a set of comparisons.
+%% However, this might not always be the best way (see is_0_to_9),
+%% so as always with any performance work - measure, don't guess!
+
+-define(is_1_to_9(X),
+    X =:= $1 orelse
+    X =:= $2 orelse
+    X =:= $3 orelse
+    X =:= $4 orelse
+    X =:= $5 orelse
+    X =:= $6 orelse
+    X =:= $7 orelse
+    X =:= $8 orelse
+    X =:= $9
+).
+
+-define(is_0_to_9(X), X >= $0 andalso X =< $9).
+
+-define(is_ws(X), X =:= $\s; X =:= $\t; X =:= $\r; X =:= $\n).
+
+-define(is_ascii_escape(Byte),
+    Byte =:= 0 orelse
+    Byte =:= 1 orelse
+    Byte =:= 2 orelse
+    Byte =:= 3 orelse
+    Byte =:= 4 orelse
+    Byte =:= 5 orelse
+    Byte =:= 6 orelse
+    Byte =:= 7 orelse
+    Byte =:= 8 orelse
+    Byte =:= 9 orelse
+    Byte =:= 10 orelse
+    Byte =:= 11 orelse
+    Byte =:= 12 orelse
+    Byte =:= 13 orelse
+    Byte =:= 14 orelse
+    Byte =:= 15 orelse
+    Byte =:= 16 orelse
+    Byte =:= 17 orelse
+    Byte =:= 18 orelse
+    Byte =:= 19 orelse
+    Byte =:= 20 orelse
+    Byte =:= 21 orelse
+    Byte =:= 22 orelse
+    Byte =:= 23 orelse
+    Byte =:= 24 orelse
+    Byte =:= 25 orelse
+    Byte =:= 26 orelse
+    Byte =:= 27 orelse
+    Byte =:= 28 orelse
+    Byte =:= 29 orelse
+    Byte =:= 30 orelse
+    Byte =:= 31 orelse
+    Byte =:= 34 orelse
+    Byte =:= 92
+).
+-define(is_ascii_plain(Byte),
+    Byte =:= 32 orelse
+    Byte =:= 33 orelse
+    Byte =:= 35 orelse
+    Byte =:= 36 orelse
+    Byte =:= 37 orelse
+    Byte =:= 38 orelse
+    Byte =:= 39 orelse
+    Byte =:= 40 orelse
+    Byte =:= 41 orelse
+    Byte =:= 42 orelse
+    Byte =:= 43 orelse
+    Byte =:= 44 orelse
+    Byte =:= 45 orelse
+    Byte =:= 46 orelse
+    Byte =:= 47 orelse
+    Byte =:= 48 orelse
+    Byte =:= 49 orelse
+    Byte =:= 50 orelse
+    Byte =:= 51 orelse
+    Byte =:= 52 orelse
+    Byte =:= 53 orelse
+    Byte =:= 54 orelse
+    Byte =:= 55 orelse
+    Byte =:= 56 orelse
+    Byte =:= 57 orelse
+    Byte =:= 58 orelse
+    Byte =:= 59 orelse
+    Byte =:= 60 orelse
+    Byte =:= 61 orelse
+    Byte =:= 62 orelse
+    Byte =:= 63 orelse
+    Byte =:= 64 orelse
+    Byte =:= 65 orelse
+    Byte =:= 66 orelse
+    Byte =:= 67 orelse
+    Byte =:= 68 orelse
+    Byte =:= 69 orelse
+    Byte =:= 70 orelse
+    Byte =:= 71 orelse
+    Byte =:= 72 orelse
+    Byte =:= 73 orelse
+    Byte =:= 74 orelse
+    Byte =:= 75 orelse
+    Byte =:= 76 orelse
+    Byte =:= 77 orelse
+    Byte =:= 78 orelse
+    Byte =:= 79 orelse
+    Byte =:= 80 orelse
+    Byte =:= 81 orelse
+    Byte =:= 82 orelse
+    Byte =:= 83 orelse
+    Byte =:= 84 orelse
+    Byte =:= 85 orelse
+    Byte =:= 86 orelse
+    Byte =:= 87 orelse
+    Byte =:= 88 orelse
+    Byte =:= 89 orelse
+    Byte =:= 90 orelse
+    Byte =:= 91 orelse
+    Byte =:= 93 orelse
+    Byte =:= 94 orelse
+    Byte =:= 95 orelse
+    Byte =:= 96 orelse
+    Byte =:= 97 orelse
+    Byte =:= 98 orelse
+    Byte =:= 99 orelse
+    Byte =:= 100 orelse
+    Byte =:= 101 orelse
+    Byte =:= 102 orelse
+    Byte =:= 103 orelse
+    Byte =:= 104 orelse
+    Byte =:= 105 orelse
+    Byte =:= 106 orelse
+    Byte =:= 107 orelse
+    Byte =:= 108 orelse
+    Byte =:= 109 orelse
+    Byte =:= 110 orelse
+    Byte =:= 111 orelse
+    Byte =:= 112 orelse
+    Byte =:= 113 orelse
+    Byte =:= 114 orelse
+    Byte =:= 115 orelse
+    Byte =:= 116 orelse
+    Byte =:= 117 orelse
+    Byte =:= 118 orelse
+    Byte =:= 119 orelse
+    Byte =:= 120 orelse
+    Byte =:= 121 orelse
+    Byte =:= 122 orelse
+    Byte =:= 123 orelse
+    Byte =:= 124 orelse
+    Byte =:= 125 orelse
+    Byte =:= 126 orelse
+    Byte =:= 127
+).
+
+-define(are_all_ascii_plain(B1, B2, B3, B4, B5, B6, B7, B8),
+    (?is_ascii_plain(B1)) andalso
+    (?is_ascii_plain(B2)) andalso
+    (?is_ascii_plain(B3)) andalso
+    (?is_ascii_plain(B4)) andalso
+    (?is_ascii_plain(B5)) andalso
+    (?is_ascii_plain(B6)) andalso
+    (?is_ascii_plain(B7)) andalso
+    (?is_ascii_plain(B8))
+).
+
+-define(UTF8_ACCEPT, 0).
+-define(UTF8_REJECT, 12).
+
+%%
+%% Encoding implementation
+%%
+
+-type encoder() :: fun((any(), encoder()) -> iodata()).
+
+-type encode_value() ::
+    integer()
+    | float()
+    | boolean()
+    | null
+    | binary()
+    | atom()
+    | list(encode_value())
+    | encode_map(encode_value()).
+
+-type encode_map(Value) :: #{binary() | atom() | integer() => Value}.
+
+-spec encode(encode_value()) -> iodata().
+encode(Term) -> encode(Term, fun do_encode/2).
+
+-spec encode(any(), encoder()) -> iodata().
+encode(Term, Encoder) when is_function(Encoder, 2) ->
+    Encoder(Term, Encoder).
+
+-spec encode_value(any(), encoder()) -> iodata().
+encode_value(Value, Encode) ->
+    do_encode(Value, Encode).
+
+-spec do_encode(any(), encoder()) -> iodata().
+do_encode(Value, Encode) when is_atom(Value) ->
+    encode_atom(Value, Encode);
+do_encode(Value, _Encode) when is_binary(Value) ->
+    escape_binary(Value);
+do_encode(Value, _Encode) when is_integer(Value) ->
+    encode_integer(Value);
+do_encode(Value, _Encode) when is_float(Value) ->
+    encode_float(Value);
+do_encode(Value, Encode) when is_list(Value) ->
+    do_encode_list(Value, Encode);
+do_encode(Value, Encode) when is_map(Value) ->
+    do_encode_map(Value, Encode);
+do_encode(Other, _Encode) ->
+    error({unsupported_type, Other}).
+
+-spec encode_atom(atom(), encoder()) -> iodata().
+encode_atom(null, _Encode) -> <<"null">>;
+encode_atom(true, _Encode) -> <<"true">>;
+encode_atom(false, _Encode) -> <<"false">>;
+encode_atom(Other, Encode) -> Encode(atom_to_binary(Other, utf8), Encode).
+
+-spec encode_integer(integer()) -> iodata().
+encode_integer(Integer) -> integer_to_binary(Integer).
+
+-spec encode_float(float()) -> iodata().
+encode_float(Float) -> float_to_binary(Float, [short]).
+
+-spec encode_list(list(), encoder()) -> iodata().
+encode_list(List, Encode) when is_list(List) ->
+    do_encode_list(List, Encode).
+
+do_encode_list([], _Encode) ->
+    <<"[]">>;
+do_encode_list([First | Rest], Encode) when is_function(Encode, 2) ->
+    [$[, Encode(First, Encode) | list_loop(Rest, Encode)].
+
+list_loop([], _Encode) -> "]";
+list_loop([Elem | Rest], Encode) -> [$,, Encode(Elem, Encode) | list_loop(Rest, Encode)].
+
+-spec encode_map(encode_map(any()), encoder()) -> iodata().
+encode_map(Map, Encode) when is_map(Map) ->
+    do_encode_map(Map, Encode).
+
+do_encode_map(Map, Encode) when is_function(Encode, 2) ->
+    encode_object([[$,, key(Key, Encode), $: | Encode(Value, Encode)] || Key := Value <- Map]).
+
+-spec encode_map_checked(map(), encoder()) -> iodata().
+encode_map_checked(Map, Encode) ->
+    do_encode_checked(maps:to_list(Map), Encode).
+
+-spec encode_key_value_list([{term(), term()}], encoder()) -> iodata().
+encode_key_value_list(List, Encode) when is_function(Encode, 2) ->
+    encode_object([[$,, key(Key, Encode), $: | Encode(Value, Encode)] || {Key, Value} <- List]).
+
+-spec encode_key_value_list_checked([{term(), term()}], encoder()) -> iodata().
+encode_key_value_list_checked(List, Encode) ->
+    do_encode_checked(List, Encode).
+
+do_encode_checked(List, Encode) when is_function(Encode, 2) ->
+    encode_object(do_encode_checked(List, Encode, #{})).
+
+do_encode_checked([{Key, Value} | Rest], Encode, Visited0) ->
+    EncodedKey = iolist_to_binary(key(Key, Encode)),
+    case is_map_key(EncodedKey, Visited0) of
+        true ->
+            error({duplicate_key, Key});
+        _ ->
+            Visited = Visited0#{EncodedKey => true},
+            [[$,, EncodedKey, $: | Encode(Value, Encode)] | do_encode_checked(Rest, Encode, Visited)]
+    end;
+do_encode_checked([], _, _) ->
+    [].
+
+%% Dispatching any value through `Encode` could allow incorrect
+%% JSON to be emitted (with keys not being strings). To avoid this,
+%% the default encoder only supports binaries, atoms, and numbers.
+%% Customisation is possible by overriding how maps are encoded in general.
+key(Key, Encode) when is_binary(Key) -> Encode(Key, Encode);
+key(Key, Encode) when is_atom(Key) -> Encode(atom_to_binary(Key, utf8), Encode);
+key(Key, _Encode) when is_integer(Key) -> [$", encode_integer(Key), $"];
+key(Key, _Encode) when is_float(Key) -> [$", encode_float(Key), $"].
+
+encode_object([]) -> <<"{}">>;
+encode_object([[_Comma | Entry] | Rest]) -> ["{", Entry, Rest, "}"].
+
+-spec encode_binary(binary()) -> iodata().
+encode_binary(Bin) when is_binary(Bin) ->
+    escape_binary(Bin).
+
+-spec encode_binary_escape_all(binary()) -> iodata().
+encode_binary_escape_all(Bin) when is_binary(Bin) ->
+    escape_all(Bin).
+
+escape_binary(Bin) -> escape_binary_ascii(Bin, [$"], Bin, 0, 0).
+
+escape_binary_ascii(Binary, Acc, Orig, Skip, Len) ->
+    case Binary of
+        <<B1, B2, B3, B4, B5, B6, B7, B8, Rest/binary>> when ?are_all_ascii_plain(B1, B2, B3, B4, B5, B6, B7, B8) ->
+            escape_binary_ascii(Rest, Acc, Orig, Skip, Len + 8);
+        Other ->
+            escape_binary(Other, Acc, Orig, Skip, Len)
+    end.
+
+escape_binary(<<Byte, Rest/binary>>, Acc, Orig, Skip, Len) when ?is_ascii_plain(Byte) ->
+    %% we got here because there were either less than 8 bytes left
+    %% or we have an escape in the next 8 bytes,
+    %% escape_binary_ascii would fail and dispatch here anyway
+    escape_binary(Rest, Acc, Orig, Skip, Len + 1);
+escape_binary(<<Byte, Rest/binary>>, Acc, Orig, Skip0, Len) when ?is_ascii_escape(Byte) ->
+    Escape = escape(Byte),
+    Skip = Skip0 + Len + 1,
+    case Len of
+        0 ->
+            escape_binary_ascii(Rest, [Acc | Escape], Orig, Skip, 0);
+        _ ->
+            Part = binary_part(Orig, Skip0, Len),
+            escape_binary_ascii(Rest, [Acc, Part | Escape], Orig, Skip, 0)
+    end;
+escape_binary(<<Byte, Rest/binary>>, Acc, Orig, Skip, Len) ->
+    case element(Byte - 127, utf8s0()) of
+        ?UTF8_REJECT -> invalid_byte(Orig, Skip + Len);
+        %% all accept cases are ASCII, already covered above
+        State -> escape_binary_utf8(Rest, Acc, Orig, Skip, Len, State)
+    end;
+escape_binary(_, _Acc, Orig, 0, _Len) ->
+    [$", Orig, $"];
+escape_binary(_, Acc, _Orig, _Skip, 0) ->
+    [Acc, $"];
+escape_binary(_, Acc, Orig, Skip, Len) ->
+    Part = binary_part(Orig, Skip, Len),
+    [Acc, Part, $"].
+
+escape_binary_utf8(<<Byte, Rest/binary>>, Acc, Orig, Skip, Len, State0) ->
+    Type = element(Byte + 1, utf8t()),
+    case element(State0 + Type, utf8s()) of
+        ?UTF8_ACCEPT -> escape_binary_ascii(Rest, Acc, Orig, Skip, Len + 2);
+        ?UTF8_REJECT -> invalid_byte(Orig, Skip + Len + 1);
+        State -> escape_binary_utf8(Rest, Acc, Orig, Skip, Len + 1, State)
+    end;
+escape_binary_utf8(_, _Acc, Orig, Skip, Len, _State) ->
+    unexpected_utf8(Orig, Skip + Len + 1).
+
+escape_all(Bin) -> escape_all_ascii(Bin, [$"], Bin, 0, 0).
+
+escape_all_ascii(Binary, Acc, Orig, Skip, Len) ->
+    case Binary of
+        <<B1, B2, B3, B4, B5, B6, B7, B8, Rest/binary>> when ?are_all_ascii_plain(B1, B2, B3, B4, B5, B6, B7, B8) ->
+            escape_all_ascii(Rest, Acc, Orig, Skip, Len + 8);
+        Other ->
+            escape_all(Other, Acc, Orig, Skip, Len)
+    end.
+
+escape_all(<<Byte, Rest/binary>>, Acc, Orig, Skip, Len) when ?is_ascii_plain(Byte) ->
+    escape_all(Rest, Acc, Orig, Skip, Len + 1);
+escape_all(<<Byte, Rest/bits>>, Acc, Orig, Skip, Len) when ?is_ascii_escape(Byte) ->
+    Escape = escape(Byte),
+    case Len of
+        0 ->
+            escape_all(Rest, [Acc | Escape], Orig, Skip + 1, 0);
+        _ ->
+            Part = binary_part(Orig, Skip, Len),
+            escape_all(Rest, [Acc, Part | Escape], Orig, Skip + Len + 1, 0)
+    end;
+escape_all(<<Char/utf8, Rest/bits>>, Acc, Orig, Skip, 0) ->
+    escape_char(Rest, Acc, Orig, Skip, Char);
+escape_all(<<Char/utf8, Rest/bits>>, Acc, Orig, Skip, Len) ->
+    Part = binary_part(Orig, Skip, Len),
+    escape_char(Rest, [Acc | Part], Orig, Skip + Len, Char);
+escape_all(<<>>, _Acc, Orig, 0, _Len) ->
+    [$", Orig, $"];
+escape_all(<<>>, Acc, _Orig, _Skip, 0) ->
+    [Acc, $"];
+escape_all(<<>>, Acc, Orig, Skip, Len) ->
+    Part = binary_part(Orig, Skip, Len),
+    [Acc, Part, $"];
+escape_all(_Other, _Acc, Orig, Skip, Len) ->
+    invalid_byte(Orig, Skip + Len).
+
+escape_char(<<Rest/bits>>, Acc, Orig, Skip, Char) when Char =< 16#FF ->
+    Acc1 = [Acc, "\\u00" | integer_to_binary(Char, 16)],
+    escape_all(Rest, Acc1, Orig, Skip + 2, 0);
+escape_char(<<Rest/bits>>, Acc, Orig, Skip, Char) when Char =< 16#7FF ->
+    Acc1 = [Acc, "\\u0" | integer_to_binary(Char, 16)],
+    escape_all(Rest, Acc1, Orig, Skip + 2, 0);
+escape_char(<<Rest/bits>>, Acc, Orig, Skip, Char) when Char =< 16#FFF ->
+    Acc1 = [Acc, "\\u0" | integer_to_binary(Char, 16)],
+    escape_all(Rest, Acc1, Orig, Skip + 3, 0);
+escape_char(<<Rest/bits>>, Acc, Orig, Skip, Char) when Char =< 16#FFFF ->
+    Acc1 = [Acc, "\\u" | integer_to_binary(Char, 16)],
+    escape_all(Rest, Acc1, Orig, Skip + 3, 0);
+escape_char(<<Rest/bits>>, Acc, Orig, Skip, Char0) ->
+    Char = Char0 - 16#10000,
+    First = integer_to_binary(16#800 bor (Char bsr 10), 16),
+    Second = integer_to_binary(16#C00 bor (Char band 16#3FF), 16),
+    Acc1 = [Acc, "\\uD", First, "\\uD" | Second],
+    escape_all(Rest, Acc1, Orig, Skip + 4, 0).
+
+-spec escape(byte()) -> binary() | no.
+escape($\x00) -> <<"\\u0000">>;
+escape($\x01) -> <<"\\u0001">>;
+escape($\x02) -> <<"\\u0002">>;
+escape($\x03) -> <<"\\u0003">>;
+escape($\x04) -> <<"\\u0004">>;
+escape($\x05) -> <<"\\u0005">>;
+escape($\x06) -> <<"\\u0006">>;
+escape($\x07) -> <<"\\u0007">>;
+escape($\b) -> <<"\\b">>;
+escape($\t) -> <<"\\t">>;
+escape($\n) -> <<"\\n">>;
+escape($\x0b) -> <<"\\u000B">>;
+escape($\f) -> <<"\\f">>;
+escape($\r) -> <<"\\r">>;
+escape($\x0e) -> <<"\\u000E">>;
+escape($\x0f) -> <<"\\u000F">>;
+escape($\x10) -> <<"\\u0010">>;
+escape($\x11) -> <<"\\u0011">>;
+escape($\x12) -> <<"\\u0012">>;
+escape($\x13) -> <<"\\u0013">>;
+escape($\x14) -> <<"\\u0014">>;
+escape($\x15) -> <<"\\u0015">>;
+escape($\x16) -> <<"\\u0016">>;
+escape($\x17) -> <<"\\u0017">>;
+escape($\x18) -> <<"\\u0018">>;
+escape($\x19) -> <<"\\u0019">>;
+escape($\x1A) -> <<"\\u001A">>;
+escape($\x1B) -> <<"\\u001B">>;
+escape($\x1C) -> <<"\\u001C">>;
+escape($\x1D) -> <<"\\u001D">>;
+escape($\x1E) -> <<"\\u001E">>;
+escape($\x1F) -> <<"\\u001F">>;
+escape($") -> <<"\\\"">>;
+escape($\\) -> <<"\\\\">>;
+escape(_) -> no.
+
+%% This is an adapted table from "Flexible and Economical UTF-8 Decoding" by Bjoern Hoehrmann.
+%% http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+
+%% Map character to character class
+utf8t() ->
+    {
+        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,
+        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,
+        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,
+        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,
+        1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+        7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+        8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+       10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8
+    }.
+
+%% Transition table mapping combination of state & class to next state
+utf8s() ->
+    {
+           12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12,
+        12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12,
+        12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12,
+        12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12,
+        12,36,12,12,12,12,12,12,12,12,12,12
+    }.
+
+%% Optimisation for 1st byte direct state lookup,
+%% we know starting state is 0 and ASCII bytes were already handled
+utf8s0() ->
+    {
+        12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+        12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+        12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+        12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
+        12,12,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
+        24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,24,
+        48,36,36,36,36,36,36,36,36,36,36,36,36,60,36,36,
+        72,84,84,84,96,12,12,12,12,12,12,12,12,12,12,12
+    }.
+
+invalid_byte(Bin, Skip) ->
+    Byte = binary:at(Bin, Skip),
+    error({invalid_byte, Byte}, none, error_info(Skip)).
+
+error_info(Skip) ->
+    [{error_info, #{cause => #{position => Skip}}}].
+
+%%
+%% Decoding implementation
+%%
+
+-define(ARRAY, array).
+-define(OBJECT, object).
+
+-type from_binary_fun() :: fun((binary()) -> any()).
+-type array_start_fun() :: fun((Acc :: any()) -> ArrayAcc :: any()).
+-type array_push_fun() :: fun((Value :: any(), Acc :: any()) -> NewAcc :: any()).
+-type array_finish_fun() :: fun((ArrayAcc :: any(), OldAcc :: any()) -> {any(), any()}).
+-type object_start_fun() :: fun((Acc :: any()) -> ObjectAcc :: any()).
+-type object_push_fun() :: fun((Key :: any(), Value :: any(), Acc :: any()) -> NewAcc :: any()).
+-type object_finish_fun() :: fun((ObjectAcc :: any(), OldAcc :: any()) -> {any(), any()}).
+
+-type decoders() :: #{
+    array_start => array_start_fun(),
+    array_push => array_push_fun(),
+    array_finish => array_finish_fun(),
+    object_start => object_start_fun(),
+    object_push => object_push_fun(),
+    object_finish => object_finish_fun(),
+    float => from_binary_fun(),
+    integer => from_binary_fun(),
+    string => from_binary_fun(),
+    null => term()
+}.
+
+-record(decode, {
+    array_start :: array_start_fun() | undefined,
+    array_push :: array_push_fun() | undefined,
+    array_finish :: array_finish_fun() | undefined,
+    object_start :: object_start_fun() | undefined,
+    object_push :: object_push_fun() | undefined,
+    object_finish :: object_finish_fun() | undefined,
+    float = fun erlang:binary_to_float/1 :: from_binary_fun(),
+    integer = fun erlang:binary_to_integer/1 :: from_binary_fun(),
+    string :: from_binary_fun() | undefined,
+    null = null :: term()
+}).
+
+-type acc() :: any().
+-type stack() :: [?ARRAY | ?OBJECT | binary() | acc()].
+-type decode() :: #decode{}.
+
+-opaque continuation_state() :: tuple().
+
+-type decode_value() ::
+    integer()
+    | float()
+    | boolean()
+    | null
+    | binary()
+    | list(decode_value())
+    | #{binary() => decode_value()}.
+
+-spec decode(binary()) -> decode_value().
+decode(Binary) when is_binary(Binary) ->
+    case value(Binary, Binary, 0, ok, [], #decode{}) of
+        {Result, _Acc, <<>>} ->
+            Result;
+        {_, _, Rest} ->
+            invalid_byte(Rest, 0);
+        {continue, {_Bin, _Acc, [], _Decode, {number, Number}}} ->
+            Number;
+        {continue, {_, _, _, _, {float_error, Token, Skip}}} ->
+            unexpected_sequence(Token, Skip);
+        {continue, _} ->
+            error(unexpected_end)
+    end.
+
+-spec decode(binary(), any(), decoders()) ->
+  {Result :: any(), Acc :: any(), binary()}.
+decode(Binary, Acc0, Decoders) when is_binary(Binary) ->
+    Decode = maps:fold(fun parse_decoder/3, #decode{}, Decoders),
+    case value(Binary, Binary, 0, Acc0, [], Decode) of
+        {continue, {_Bin, Acc, [], _Decode, {number, Val}}} ->
+            {Val, Acc, <<>>};
+        {continue, {_, _, _, _, {float_error, Token, Skip}}} ->
+            unexpected_sequence(Token, Skip);
+        {continue, _} ->
+            error(unexpected_end);
+        Result ->
+            Result
+    end.
+
+-spec decode_start(binary(), any(), decoders()) ->
+  {Result :: any(), Acc :: any(), binary()} | {continue, continuation_state()}.
+decode_start(Binary, Acc, Decoders) when is_binary(Binary) ->
+    Decode = maps:fold(fun parse_decoder/3, #decode{}, Decoders),
+    value(Binary, Binary, 0, Acc, [], Decode).
+
+-spec decode_continue(binary() | end_of_input, Opaque::term()) ->
+          {Result :: any(), Acc :: any(), binary()} | {continue, continuation_state()}.
+decode_continue(end_of_input, State) ->
+    case State of
+        {_, Acc, [], _Decode, {number, Val}} ->
+            {Val, Acc, <<>>};
+        {_, _, _, _, {float_error, Token, Skip}} ->
+            unexpected_sequence(Token, Skip);
+        _ ->
+            error(unexpected_end)
+    end;
+decode_continue(Cont, {Rest, Acc, Stack, #decode{} = Decode, FuncData}) when is_binary(Cont) ->
+    Binary = <<Rest/binary, Cont/binary>>,
+    case FuncData of
+        value ->
+            value(Binary, Binary, 0, Acc, Stack, Decode);
+        {number, _} ->
+            value(Binary, Binary, 0, Acc, Stack, Decode);
+        {float_error, _Token, _Skip} ->
+            value(Binary, Binary, 0, Acc, Stack, Decode);
+        {array_push, Val} ->
+            array_push(Binary, Binary, 0, Acc, Stack, Decode, Val);
+        {object_value, Key} ->
+            object_value(Binary, Binary, 0, Acc, Stack, Decode, Key);
+        {object_push, Value, Key} ->
+            object_push(Binary, Binary, 0, Acc, Stack, Decode, Value, Key);
+        object_key ->
+            object_key(Binary, Binary, 0, Acc, Stack, Decode)
+    end.
+
+parse_decoder(array_start, Fun, Decode) when is_function(Fun, 1) ->
+    Decode#decode{array_start = Fun};
+parse_decoder(array_push, Fun, Decode) when is_function(Fun, 2) ->
+    Decode#decode{array_push = Fun};
+parse_decoder(array_finish, Fun, Decode) when is_function(Fun, 2) ->
+    Decode#decode{array_finish = Fun};
+parse_decoder(object_start, Fun, Decode) when is_function(Fun, 1) ->
+    Decode#decode{object_start = Fun};
+parse_decoder(object_push, Fun, Decode) when is_function(Fun, 3) ->
+    Decode#decode{object_push = Fun};
+parse_decoder(object_finish, Fun, Decode) when is_function(Fun, 2) ->
+    Decode#decode{object_finish = Fun};
+parse_decoder(float, Fun, Decode) when is_function(Fun, 1) ->
+    Decode#decode{float = Fun};
+parse_decoder(integer, Fun, Decode) when is_function(Fun, 1) ->
+    Decode#decode{integer = Fun};
+parse_decoder(string, Fun, Decode) when is_function(Fun, 1) ->
+    Decode#decode{string = Fun};
+parse_decoder(null, Null, Decode) ->
+    Decode#decode{null = Null}.
+
+value(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode) when ?is_ws(Byte) ->
+    value(Rest, Original, Skip + 1, Acc, Stack, Decode);
+value(<<$0, Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    number_zero(Rest, Original, Skip, Acc, Stack, Decode, 1);
+value(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode) when ?is_1_to_9(Byte) ->
+    number(Rest, Original, Skip, Acc, Stack, Decode, 1);
+value(<<$-, Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    number_minus(Rest, Original, Skip, Acc, Stack, Decode);
+value(<<$t, Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    true(Rest, Original, Skip, Acc, Stack, Decode);
+value(<<$f, Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    false(Rest, Original, Skip, Acc, Stack, Decode);
+value(<<$n, Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    null(Rest, Original, Skip, Acc, Stack, Decode);
+value(<<$", Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    string(Rest, Original, Skip + 1, Acc, Stack, Decode);
+value(<<$[, Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    array_start(Rest, Original, Skip, Acc, Stack, Decode, 1);
+value(<<${, Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    object_start(Rest, Original, Skip, Acc, Stack, Decode, 1);
+value(<<Byte, _/bits>>, Original, Skip, _Acc, _Stack, _Decode) when ?is_ascii_plain(Byte) ->
+    %% this clause is effectively the same as the last one, but necessary to
+    %% force compiler to emit a jump table dispatch, rather than binary search
+    invalid_byte(Original, Skip);
+value(_, Original, Skip, Acc, Stack, Decode) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, 0, 0, value).
+
+true(<<"rue", Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    continue(Rest, Original, Skip+4, Acc, Stack, Decode, true);
+true(_Rest, Original, Skip, Acc, Stack, Decode) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, 1, 3, value).
+
+false(<<"alse", Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    continue(Rest, Original, Skip+5, Acc, Stack, Decode, false);
+false(_Rest, Original, Skip, Acc, Stack, Decode) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, 1, 4, value).
+
+null(<<"ull", Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    continue(Rest, Original, Skip+4, Acc, Stack, Decode, Decode#decode.null);
+null(_Rest, Original, Skip, Acc, Stack, Decode) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, 1, 3, value).
+
+number_minus(<<$0, Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    number_zero(Rest, Original, Skip, Acc, Stack, Decode, 2);
+number_minus(<<Num, Rest/bits>>, Original, Skip, Acc, Stack, Decode) when ?is_1_to_9(Num) ->
+    number(Rest, Original, Skip, Acc, Stack, Decode, 2);
+number_minus(_Rest, Original, Skip, Acc, Stack, Decode) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, 1, 0, value).
+
+number_zero(<<$., Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) ->
+    number_frac(Rest, Original, Skip, Acc, Stack, Decode, Len + 1);
+number_zero(<<E, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when E =:= $E; E =:= $e ->
+    number_exp_copy(Rest, Original, Skip, Acc, Stack, Decode, Len + 1, <<"0">>);
+number_zero(<<>>, Original, Skip, Acc, Stack, Decode, Len) ->
+    Value = (Decode#decode.integer)(<<"0">>),
+    unexpected(Original, Skip, Acc, Stack, Decode, Len, 0, {number, Value});
+number_zero(Rest, Original, Skip, Acc, Stack, Decode, Len) ->
+    Value = (Decode#decode.integer)(<<"0">>),
+    continue(Rest, Original, Skip+Len, Acc, Stack, Decode, Value).
+
+number(<<Num, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when ?is_0_to_9(Num) ->
+    number(Rest, Original, Skip, Acc, Stack, Decode, Len + 1);
+number(<<$., Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) ->
+    number_frac(Rest, Original, Skip, Acc, Stack, Decode, Len + 1);
+number(<<E, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when E =:= $E; E =:= $e ->
+    Prefix = binary_part(Original, Skip, Len),
+    number_exp_copy(Rest, Original, Skip, Acc, Stack, Decode, Len + 1, Prefix);
+number(<<>>, Original, Skip, Acc, Stack, Decode, Len) ->
+    Int = (Decode#decode.integer)(binary_part(Original, Skip, Len)),
+    unexpected(Original, Skip, Acc, Stack, Decode, Len, 0, {number, Int});
+number(Rest, Original, Skip, Acc, Stack, Decode, Len) ->
+    Int = (Decode#decode.integer)(binary_part(Original, Skip, Len)),
+    continue(Rest, Original, Skip+Len, Acc, Stack, Decode, Int).
+
+number_frac(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when ?is_0_to_9(Byte) ->
+    number_frac_cont(Rest, Original, Skip, Acc, Stack, Decode, Len + 1);
+number_frac(_, Original, Skip, Acc, Stack, Decode, Len) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, Len, 0, value).
+
+number_frac_cont(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when ?is_0_to_9(Byte) ->
+    number_frac_cont(Rest, Original, Skip, Acc, Stack, Decode, Len + 1);
+number_frac_cont(<<E, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when E =:= $e; E =:= $E ->
+    number_exp(Rest, Original, Skip, Acc, Stack, Decode, Len + 1);
+number_frac_cont(Rest, Original, Skip, Acc, Stack, Decode, Len) ->
+    Token = binary_part(Original, Skip, Len),
+    float_decode(Rest, Original, Skip, Acc, Stack, Decode, Len, Token).
+
+float_decode(<<>>, Original, Skip, Acc, Stack, Decode, Len, Token) ->
+    try (Decode#decode.float)(Token) of
+        Float -> unexpected(Original, Skip, Acc, Stack, Decode, Len, 0, {number, Float})
+    catch
+        _:_ -> unexpected(Original, Skip, Acc, Stack, Decode, Len, 0, {float_error, Token, Skip})
+    end;
+float_decode(<<Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len, Token) ->
+    try (Decode#decode.float)(Token) of
+        Float ->
+            continue(Rest, Original, Skip+Len, Acc, Stack, Decode, Float)
+    catch
+        _:_ -> unexpected_sequence(Token, Skip)
+    end.
+
+number_exp(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when ?is_0_to_9(Byte) ->
+    number_exp_cont(Rest, Original, Skip, Acc, Stack, Decode, Len + 1);
+number_exp(<<Sign, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when Sign =:= $+; Sign =:= $- ->
+    number_exp_sign(Rest, Original, Skip, Acc, Stack, Decode, Len + 1);
+number_exp(_, Original, Skip, Acc, Stack, Decode, Len) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, Len, 0, value).
+
+number_exp_sign(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when ?is_0_to_9(Byte) ->
+    number_exp_cont(Rest, Original, Skip, Acc, Stack, Decode, Len + 1);
+number_exp_sign(_, Original, Skip, Acc, Stack, Decode, Len) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, Len, 0, value).
+
+number_exp_cont(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when ?is_0_to_9(Byte) ->
+    number_exp_cont(Rest, Original, Skip, Acc, Stack, Decode, Len + 1);
+number_exp_cont(Rest, Original, Skip, Acc, Stack, Decode, Len) ->
+    Token = binary_part(Original, Skip, Len),
+    float_decode(Rest, Original, Skip, Acc, Stack, Decode, Len, Token).
+
+number_exp_copy(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len, Prefix) when ?is_0_to_9(Byte) ->
+    number_exp_cont(Rest, Original, Skip, Acc, Stack, Decode, Len, Prefix, 1);
+number_exp_copy(<<Sign, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len, Prefix) when Sign =:= $+; Sign =:= $- ->
+    number_exp_sign(Rest, Original, Skip, Acc, Stack, Decode, Len, Prefix, 1);
+number_exp_copy(_, Original, Skip, Acc, Stack, Decode, Len, _Prefix) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, Len, 0, value).
+
+number_exp_sign(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len, Prefix, ExpLen) when ?is_0_to_9(Byte) ->
+    number_exp_cont(Rest, Original, Skip, Acc, Stack, Decode, Len, Prefix, ExpLen + 1);
+number_exp_sign(_, Original, Skip, Acc, Stack, Decode, Len, _Prefix, ExpLen) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, Len + ExpLen, 0, value).
+
+number_exp_cont(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len, Prefix, ExpLen) when ?is_0_to_9(Byte) ->
+    number_exp_cont(Rest, Original, Skip, Acc, Stack, Decode, Len, Prefix, ExpLen + 1);
+number_exp_cont(Rest, Original, Skip, Acc, Stack, Decode, Len, Prefix, ExpLen) ->
+    Suffix = binary_part(Original, Skip + Len, ExpLen),
+    Token = <<Prefix/binary, ".0e", Suffix/binary>>,
+    float_decode(Rest, Original, Skip, Acc, Stack, Decode, Len + ExpLen, Token).
+
+string(Binary, Original, Skip, Acc, Stack, Decode) ->
+    string_ascii(Binary, Original, Skip, Acc, Stack, Decode, 0).
+
+string_ascii(Binary, Original, Skip, Acc, Stack, Decode, Len) ->
+    case Binary of
+        <<B1, B2, B3, B4, B5, B6, B7, B8, Rest/binary>> when ?are_all_ascii_plain(B1, B2, B3, B4, B5, B6, B7, B8) ->
+            string_ascii(Rest, Original, Skip, Acc, Stack, Decode, Len + 8);
+        Other ->
+            string(Other, Original, Skip, Acc, Stack, Decode, Len)
+    end.
+
+-spec string(binary(), binary(), integer(), acc(), stack(), decode(), integer()) -> any().
+string(<<Byte, Rest/bits>>, Orig, Skip, Acc, Stack, Decode, Len) when ?is_ascii_plain(Byte) ->
+    string(Rest, Orig, Skip, Acc, Stack, Decode, Len + 1);
+string(<<$\\, Rest/bits>>, Orig, Skip, Acc, Stack, Decode, Len) ->
+    Part = binary_part(Orig, Skip, Len),
+    SAcc = <<>>,
+    unescape(Rest, Orig, Skip, Acc, Stack, Decode, Skip-1, Len, <<SAcc/binary, Part/binary>>);
+string(<<$", Rest/bits>>, Orig, Skip0, Acc, Stack, Decode, Len) ->
+    Value = binary_part(Orig, Skip0, Len),
+    Skip = Skip0 + Len + 1,
+    case Decode#decode.string of
+        undefined -> continue(Rest, Orig, Skip, Acc, Stack, Decode, Value);
+        Fun -> continue(Rest, Orig, Skip, Acc, Stack, Decode, Fun(Value))
+    end;
+string(<<Byte, _/bits>>, Orig, Skip, _Acc, _Stack, _Decode, Len) when ?is_ascii_escape(Byte) ->
+    invalid_byte(Orig, Skip + Len);
+string(<<Byte, Rest/bytes>>, Orig, Skip, Acc, Stack, Decode, Len) ->
+    case element(Byte - 127, utf8s0()) of
+        ?UTF8_REJECT -> invalid_byte(Orig, Skip + Len);
+        %% all accept cases are ASCII, already covered above
+        State -> string_utf8(Rest, Orig, Skip, Acc, Stack, Decode, Len, State)
+    end;
+string(_, Orig, Skip, Acc, Stack, Decode, Len) ->
+    unexpected(Orig, Skip-1, Acc, Stack, Decode, Len + 1, 0, value).
+
+string_utf8(<<Byte, Rest/binary>>, Orig, Skip, Acc, Stack, Decode, Len, State0) ->
+    Type = element(Byte + 1, utf8t()),
+    case element(State0 + Type, utf8s()) of
+        ?UTF8_ACCEPT -> string_ascii(Rest, Orig, Skip, Acc, Stack, Decode, Len + 2);
+        ?UTF8_REJECT -> invalid_byte(Orig, Skip + Len + 1);
+        State -> string_utf8(Rest, Orig, Skip, Acc, Stack, Decode, Len + 1, State)
+    end;
+string_utf8(_, Orig, Skip, Acc, Stack, Decode, Len, _State0) ->
+    unexpected(Orig, Skip-1, Acc, Stack, Decode, Len + 2, 0, value).
+
+string_ascii(Binary, Original, Skip, Acc, Stack, Decode, Start, Len, SAcc) ->
+    case Binary of
+        <<B1, B2, B3, B4, B5, B6, B7, B8, Rest/binary>> when ?are_all_ascii_plain(B1, B2, B3, B4, B5, B6, B7, B8) ->
+            string_ascii(Rest, Original, Skip, Acc, Stack, Decode, Start, Len + 8, SAcc);
+        Other ->
+            string(Other, Original, Skip, Acc, Stack, Decode, Start, Len, SAcc)
+    end.
+
+-spec string(binary(), binary(), integer(), acc(), stack(), decode(), integer(), integer(), binary()) -> any().
+string(<<Byte, Rest/bits>>, Orig, Skip, Acc, Stack, Decode, Start, Len, SAcc) when ?is_ascii_plain(Byte) ->
+    string(Rest, Orig, Skip, Acc, Stack, Decode, Start, Len + 1, SAcc);
+string(<<$\\, Rest/bits>>, Orig, Skip, Acc, Stack, Decode, Start, Len, SAcc) ->
+    Part = binary_part(Orig, Skip, Len),
+    unescape(Rest, Orig, Skip, Acc, Stack, Decode, Start, Len, <<SAcc/binary, Part/binary>>);
+string(<<$", Rest/bits>>, Orig, Skip0, Acc, Stack, Decode, _Start, Len, SAcc) ->
+    Part = binary_part(Orig, Skip0, Len),
+    Value = <<SAcc/binary, Part/binary>>,
+    Skip = Skip0 + Len + 1,
+    case Decode#decode.string of
+        undefined -> continue(Rest, Orig, Skip, Acc, Stack, Decode, Value);
+        Fun -> continue(Rest, Orig, Skip, Acc, Stack, Decode, Fun(Value))
+    end;
+string(<<Byte, _/bits>>, Orig, Skip, _Acc, _Stack, _Decode, _Start, Len, _SAcc) when ?is_ascii_escape(Byte) ->
+    invalid_byte(Orig, Skip + Len);
+string(<<Byte, Rest/bytes>>, Orig, Skip, Acc, Stack, Decode, Start, Len, SAcc) ->
+    case element(Byte - 127, utf8s0()) of
+        ?UTF8_REJECT -> invalid_byte(Orig, Skip + Len);
+        %% all accept cases are ASCII, already covered above
+        State -> string_utf8(Rest, Orig, Skip, Acc, Stack, Decode, Start, Len, SAcc, State)
+    end;
+string(_, Orig, Skip, Acc, Stack, Decode, Start, Len, _SAcc) ->
+    Extra = Skip - Start,
+    unexpected(Orig, Start, Acc, Stack, Decode, Len+Extra, 0, value).
+
+string_utf8(<<Byte, Rest/binary>>, Orig, Skip, Acc, Stack, Decode, Start, Len, SAcc, State0) ->
+    Type = element(Byte + 1, utf8t()),
+    case element(State0 + Type, utf8s()) of
+        ?UTF8_ACCEPT -> string_ascii(Rest, Orig, Skip, Acc, Stack, Decode, Start, Len + 2, SAcc);
+        ?UTF8_REJECT -> invalid_byte(Orig, Skip + Len + 1);
+        State -> string_utf8(Rest, Orig, Skip, Acc, Stack, Decode, Start, Len + 1, SAcc, State)
+    end;
+string_utf8(_, Orig, Skip, Acc, Stack, Decode, Start, Len, _SAcc, _State0) ->
+    Extra = Skip - Start,
+    unexpected(Orig, Start, Acc, Stack, Decode, Len + 1 + Extra, 0, value).
+
+unescape(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Start, Len, SAcc) ->
+    Val =
+        case Byte of
+            $b -> $\b;
+            $f -> $\f;
+            $n -> $\n;
+            $r -> $\r;
+            $t -> $\t;
+            $" -> $";
+            $\\ -> $\\;
+            $/ -> $/;
+            $u -> unicode;
+            _ -> error
+        end,
+    case Val of
+        unicode -> unescapeu(Rest, Original, Skip, Acc, Stack, Decode, Start, Len, SAcc);
+        error -> invalid_byte(Original, Skip+Len+1);
+        Int -> string_ascii(Rest, Original, Skip + Len + 2, Acc, Stack, Decode, Start, 0, <<SAcc/binary, Int>>)
+    end;
+unescape(_, Original, Skip, Acc, Stack, Decode, Start, Len, _SAcc) ->
+    Extra = Skip - Start,
+    unexpected(Original, Start, Acc, Stack, Decode, Len + 1 + Extra, 0, value).
+
+unescapeu(<<E1, E2, E3, E4, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Start, Len, SAcc) ->
+    try hex_to_int(E1, E2, E3, E4) of
+        CP when CP >= 16#D800, CP =< 16#DBFF ->
+            unescape_surrogate(Rest, Original, Skip, Acc, Stack, Decode, Start, Len, SAcc, CP);
+        CP ->
+            try <<SAcc/binary, CP/utf8>> of
+                SAcc1 -> string_ascii(Rest, Original, Skip + Len + 6, Acc, Stack, Decode, Start, 0, SAcc1)
+            catch
+                _:_ -> unexpected_sequence(binary_part(Original, Skip + Len, 6), Skip + Len)
+            end
+    catch
+        _:_ ->
+            unexpected_sequence(binary_part(Original, Skip + Len, 6), Skip + Len)
+    end;
+unescapeu(_Rest, Original, Skip, Acc, Stack, Decode, Start, Len, _SAcc) ->
+    Extra = Skip - Start,
+    unexpected(Original, Start, Acc, Stack, Decode, Len + 2 + Extra, 4, value).
+
+unescape_surrogate(<<"\\u", E1, E2, E3, E4, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Start, Len, SAcc, Hi) ->
+    try hex_to_int(E1, E2, E3, E4) of
+        Lo when Lo >= 16#DC00, Lo =< 16#DFFF ->
+            CP = 16#10000 + ((Hi band 16#3FF) bsl 10) + (Lo band 16#3FF),
+            try <<SAcc/binary, CP/utf8>> of
+                SAcc1 -> string_ascii(Rest, Original, Skip + Len + 12, Acc, Stack, Decode, Start, 0, SAcc1)
+            catch
+                _:_ -> unexpected_sequence(binary_part(Original, Skip + Len, 12), Skip + Len)
+            end;
+        _ ->
+            unexpected_sequence(binary_part(Original, Skip + Len, 12), Skip + Len)
+    catch
+        _:_ -> unexpected_sequence(binary_part(Original, Skip + Len, 12), Skip + Len)
+    end;
+unescape_surrogate(_Rest, Original, Skip, Acc, Stack, Decode, Start, Len, _SAcc, _Hi) ->
+    Extra = Skip - Start,
+    unexpected(Original, Start, Acc, Stack, Decode, Len + 6 + Extra, 5, value).
+
+%% erlfmt-ignore
+%% this is a macro instead of an inlined function - compiler refused to inline
+-define(hex_digit(C), element(C - $0 + 1, {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, n, n, n, n, n, %% 0x30
+    n, n, 10,11,12,13,14,15,n, n, n, n, n, n, n, %% 0x40
+    n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, %% 0x50
+    n, n, n, n, 10,11,12,13,14,15                %% 0x60
+})).
+
+-spec hex_to_int(byte(), byte(), byte(), byte()) -> integer().
+hex_to_int(H1, H2, H3, H4) ->
+    ?hex_digit(H4) + 16 * (?hex_digit(H3) + 16 * (?hex_digit(H2) + 16 * ?hex_digit(H1))).
+
+array_start(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when ?is_ws(Byte) ->
+    array_start(Rest, Original, Skip, Acc, Stack, Decode, Len+1);
+array_start(<<"]", Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) ->
+    {Value, NewAcc} =
+        case {Decode#decode.array_start, Decode#decode.array_finish} of
+            {undefined, undefined} -> {[], Acc};
+            {Start, undefined} -> {lists:reverse(Start(Acc)), Acc};
+            {undefined, Finish} -> Finish([], Acc);
+            {Start, Finish} -> Finish(Start(Acc), Acc)
+        end,
+    continue(Rest, Original, Skip+Len+1, NewAcc, Stack, Decode, Value);
+array_start(<<>>, Original, Skip, Acc, Stack, Decode, Len) ->
+    %% Handles empty array [] in continuation mode
+    unexpected(Original, Skip, Acc, Stack, Decode, Len, 0, value);
+array_start(Rest, Original, Skip, OldAcc, Stack, Decode, Len) ->
+    case Decode#decode.array_start of
+        undefined -> value(Rest, Original, Skip+Len, [], [?ARRAY, OldAcc | Stack], Decode);
+        Fun -> value(Rest, Original, Skip+Len, Fun(OldAcc), [?ARRAY, OldAcc | Stack], Decode)
+    end.
+
+array_push(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Value) when ?is_ws(Byte) ->
+    array_push(Rest, Original, Skip + 1, Acc, Stack, Decode, Value);
+array_push(<<"]", Rest/bits>>, Original, Skip, Acc0, Stack0, Decode, Value) ->
+    Acc =
+        case Decode#decode.array_push of
+            undefined -> [Value | Acc0];
+            Push -> Push(Value, Acc0)
+        end,
+    [_, OldAcc | Stack] = Stack0,
+    {ArrayValue, NewAcc} =
+        case Decode#decode.array_finish of
+            undefined -> {lists:reverse(Acc), OldAcc};
+            Finish -> Finish(Acc, OldAcc)
+        end,
+    continue(Rest, Original, Skip + 1, NewAcc, Stack, Decode, ArrayValue);
+array_push(<<$,, Rest/bits>>, Original, Skip0, Acc, Stack, Decode, Value) ->
+    Skip = Skip0 + 1,
+    case Decode#decode.array_push of
+        undefined -> value(Rest, Original, Skip, [Value | Acc], Stack, Decode);
+        Fun -> value(Rest, Original, Skip, Fun(Value, Acc), Stack, Decode)
+    end;
+array_push(_, Original, Skip, Acc, Stack, Decode, Value) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, 0, 0, {?FUNCTION_NAME, Value}).
+
+
+object_start(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) when ?is_ws(Byte) ->
+    object_start(Rest, Original, Skip, Acc, Stack, Decode, Len+1);
+object_start(<<"}", Rest/bits>>, Original, Skip, Acc, Stack, Decode, Len) ->
+    {Value, NewAcc} =
+        case {Decode#decode.object_start, Decode#decode.object_finish} of
+            {undefined, undefined} -> {#{}, Acc};
+            {Start, undefined} -> {maps:from_list(Start(Acc)), Acc};
+            {undefined, Finish} -> Finish([], Acc);
+            {Start, Finish} -> Finish(Start(Acc), Acc)
+        end,
+    continue(Rest, Original, Skip+Len+1, NewAcc, Stack, Decode, Value);
+object_start(<<$", Rest/bits>>, Original, Skip0, OldAcc, Stack0, Decode, Len) ->
+    Stack = [?OBJECT, OldAcc | Stack0],
+    Skip = Skip0 + Len + 1,
+    case Decode#decode.object_start of
+        undefined ->
+            string(Rest, Original, Skip, [], Stack, Decode);
+        Fun ->
+            Acc = Fun(OldAcc),
+            string(Rest, Original, Skip, Acc, Stack, Decode)
+    end;
+object_start(_, Original, Skip, Acc, Stack, Decode, Len) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, Len, 0, value).
+
+object_value(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Key) when ?is_ws(Byte) ->
+    object_value(Rest, Original, Skip + 1, Acc, Stack, Decode, Key);
+object_value(<<$:, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Key) ->
+    value(Rest, Original, Skip + 1, Acc, [Key | Stack], Decode);
+object_value(_, Original, Skip, Acc, Stack, Decode, Key) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, 0, 0, {?FUNCTION_NAME, Key}).
+
+object_push(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode, Value, Key) when ?is_ws(Byte) ->
+    object_push(Rest, Original, Skip + 1, Acc, Stack, Decode, Value, Key);
+object_push(<<"}", Rest/bits>>, Original, Skip, Acc0, Stack0, Decode, Value, Key) ->
+    Acc =
+        case Decode#decode.object_push of
+            undefined -> [{Key, Value} | Acc0];
+            Fun -> Fun(Key, Value, Acc0)
+        end,
+    [_, OldAcc | Stack] = Stack0,
+    {ObjectValue, NewAcc} =
+        case Decode#decode.object_finish of
+            undefined -> {maps:from_list(Acc), OldAcc};
+            Finish -> Finish(Acc, OldAcc)
+        end,
+    continue(Rest, Original, Skip + 1, NewAcc, Stack, Decode, ObjectValue);
+object_push(<<$,, Rest/bits>>, Original, Skip, Acc0, Stack, Decode, Value, Key) ->
+    case Decode#decode.object_push of
+        undefined -> object_key(Rest, Original, Skip + 1, [{Key, Value} | Acc0], Stack, Decode);
+        Fun -> object_key(Rest, Original, Skip + 1, Fun(Key, Value, Acc0), Stack, Decode)
+    end;
+object_push(_, Original, Skip, Acc, Stack, Decode, Value, Key) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, 0, 0, {?FUNCTION_NAME, Value, Key}).
+
+object_key(<<Byte, Rest/bits>>, Original, Skip, Acc, Stack, Decode) when ?is_ws(Byte) ->
+    object_key(Rest, Original, Skip + 1, Acc, Stack, Decode);
+object_key(<<$", Rest/bits>>, Original, Skip, Acc, Stack, Decode) ->
+    string(Rest, Original, Skip + 1, Acc, Stack, Decode);
+object_key(_, Original, Skip, Acc, Stack, Decode) ->
+    unexpected(Original, Skip, Acc, Stack, Decode, 0, 0, ?FUNCTION_NAME).
+
+continue(<<Rest/bits>>, Original, Skip, Acc, Stack0, Decode, Value) ->
+    case Stack0 of
+        [] -> terminate(Rest, Original, Skip, Acc, Value);
+        [?ARRAY | _] -> array_push(Rest, Original, Skip, Acc, Stack0, Decode, Value);
+        [?OBJECT | _] -> object_value(Rest, Original, Skip, Acc, Stack0, Decode, Value);
+        [Key | Stack] -> object_push(Rest, Original, Skip, Acc, Stack, Decode, Value, Key)
+    end.
+
+terminate(<<Byte, Rest/bits>>, Original, Skip, Acc, Value) when ?is_ws(Byte) ->
+    terminate(Rest, Original, Skip, Acc, Value);
+terminate(<<>>, _, _Skip, Acc, Value) ->
+    {Value, Acc, <<>>};
+terminate(<<_/bits>>, Original, Skip, Acc, Value) ->
+    <<_:Skip/binary, Rest/binary>> = Original,
+    {Value, Acc, Rest}.
+
+-spec unexpected_utf8(binary(), non_neg_integer()) -> no_return().
+unexpected_utf8(Original, Skip) when byte_size(Original) =:= Skip ->
+    error(unexpected_end);
+unexpected_utf8(Original, Skip) ->
+    invalid_byte(Original, Skip).
+
+unexpected(Original, Skip, Acc, Stack, Decode, Pos, Len, FuncData) ->
+    RequiredSize = Skip+Pos+Len,
+    OrigSize = byte_size(Original),
+    case OrigSize =< RequiredSize of
+        true ->
+            <<_:Skip/binary, Rest/binary>> = Original,
+            {continue, {Rest, Acc, Stack, Decode, FuncData}};
+        false ->
+            invalid_byte(Original, Skip+Pos)
+    end.
+
+-spec unexpected_sequence(binary(), non_neg_integer()) -> no_return().
+unexpected_sequence(Value, Skip) ->
+    error({unexpected_sequence, Value}, none, error_info(Skip)).
diff --git a/lib/elixir/src/elixir_lexical.erl b/lib/elixir/src/elixir_lexical.erl
index 7f299442deb..b4c5d8d6f9f 100644
--- a/lib/elixir/src/elixir_lexical.erl
+++ b/lib/elixir/src/elixir_lexical.erl
@@ -1,79 +1,122 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 %% Module responsible for tracking lexical information.
 -module(elixir_lexical).
--export([run/2,
-  record_alias/4, record_alias/2,
-  record_import/4, record_import/2,
-  record_remote/2, format_error/1
-]).
+-export([run/3, with_file/3, trace/2, format_error/1]).
 -include("elixir.hrl").
 
--define(tracker, 'Elixir.Kernel.LexicalTracker').
+run(#{tracers := Tracers} = E, ExecutionCallback, AfterExecutionCallback) ->
+  case elixir_config:is_bootstrap() of
+    false ->
+      {ok, Pid} = ?tracker:start_link(),
+      LexEnv = E#{lexical_tracker := Pid, tracers := [?MODULE | Tracers]},
+      elixir_env:trace(start, LexEnv),
 
-run(File, Callback) ->
-  case code:is_loaded(?tracker) of
-    {file, _} ->
-      Pid = ?tracker:start_link(),
-      try
-        Callback(Pid)
+      try ExecutionCallback(LexEnv) of
+        Res ->
+          warn_unused_aliases(Pid, LexEnv),
+          warn_unused_imports(Pid, LexEnv),
+          warn_unused_requires(Pid, LexEnv),
+          AfterExecutionCallback(LexEnv),
+          Res
       after
-        warn_unused_aliases(File, Pid),
-        warn_unused_imports(File, Pid),
-        unlink(Pid), ?tracker:stop(Pid)
+        elixir_env:trace(stop, LexEnv),
+        unlink(Pid),
+        ?tracker:stop(Pid)
       end;
-    false ->
-      Callback(nil)
-  end.
-
-%% RECORD
-
-record_alias(Module, Line, Warn, Ref) ->
-  if_tracker(Ref, fun(Pid) ->
-    ?tracker:add_alias(Pid, Module, Line, Warn),
-    true
-  end).
 
-record_import(Module, Line, Warn, Ref) ->
-  if_tracker(Ref, fun(Pid) ->
-    ?tracker:add_import(Pid, Module, Line, Warn),
-    true
-  end).
+    true ->
+      ExecutionCallback(E),
+      AfterExecutionCallback(E)
+  end.
+trace({alias_expansion, _Meta, Lookup, _Result}, #{lexical_tracker := Pid}) ->
+  ?tracker:alias_dispatch(Pid, Lookup),
+  ok;
+trace({require, Meta, Module, _Opts}, #{lexical_tracker := Pid}) ->
+  case lists:keyfind(from_macro, 1, Meta) of
+    {from_macro, true} -> ?tracker:remote_dispatch(Pid, Module, compile);
+    _ -> ?tracker:add_export(Pid, Module)
+  end,
+  ok;
+trace({struct_expansion, _Meta, Module, _Keys}, #{lexical_tracker := Pid}) ->
+  ?tracker:add_export(Pid, Module),
+  ok;
+trace({alias_reference, _Meta, Module}, #{lexical_tracker := Pid} = E) ->
+  case E of
+    %% Alias references inside patterns and guards in functions are not
+    %% compile time dependencies.
+    #{function := nil} -> ?tracker:remote_dispatch(Pid, Module, compile);
+    #{context := nil} -> ?tracker:remote_dispatch(Pid, Module, runtime);
+    #{} -> ok
+  end,
+  ok;
+trace({remote_function, _Meta, Module, _Function, _Arity}, #{lexical_tracker := Pid} = E) ->
+  ?tracker:remote_dispatch(Pid, Module, mode(E)),
+  ok;
+trace({remote_macro, _Meta, Module, _Function, _Arity}, #{lexical_tracker := Pid}) ->
+  ?tracker:remote_dispatch(Pid, Module, compile),
+  ok;
+trace({imported_function, _Meta, Module, Function, Arity}, #{lexical_tracker := Pid} = E) ->
+  ?tracker:import_dispatch(Pid, Module, {Function, Arity}, mode(E)),
+  ok;
+trace({imported_macro, _Meta, Module, Function, Arity}, #{lexical_tracker := Pid}) ->
+  ?tracker:import_dispatch(Pid, Module, {Function, Arity}, compile),
+  ok;
+trace({imported_quoted, _Meta, Module, Function, Arities}, #{lexical_tracker := Pid}) ->
+  ?tracker:import_quoted(Pid, Module, Function, Arities),
+  ok;
+trace({compile_env, App, Path, Return}, #{lexical_tracker := Pid}) ->
+  ?tracker:add_compile_env(Pid, App, Path, Return),
+  ok;
+trace(_, _) ->
+  ok.
 
-record_alias(Module, Ref) ->
-  if_tracker(Ref, fun(Pid) ->
-    ?tracker:alias_dispatch(Pid, Module),
-    true
-  end).
+mode(#{function := nil}) -> compile;
+mode(#{}) -> runtime.
 
-record_import(Module, Ref) ->
-  if_tracker(Ref, fun(Pid) ->
-    ?tracker:import_dispatch(Pid, Module),
-    true
-  end).
+%% EXTERNAL SOURCES
 
-record_remote(Module, Ref) ->
-  if_tracker(Ref, fun(Pid) ->
-    ?tracker:remote_dispatch(Pid, Module),
-    true
-  end).
+with_file(File, #{lexical_tracker := nil} = E, Callback) ->
+  Callback(E#{file := File});
+with_file(File, #{lexical_tracker := Pid} = E, Callback) ->
+  try
+    ?tracker:set_file(Pid, File),
+    Callback(E#{file := File})
+  after
+    ?tracker:reset_file(Pid)
+  end.
 
-%% HELPERS
+%% ERROR HANDLING
 
-if_tracker(nil, _Callback) -> false;
-if_tracker(Pid, Callback) when is_pid(Pid) -> Callback(Pid).
+warn_unused_imports(Pid, E) ->
+  [elixir_errors:file_warn(Meta, ?key(E, file), ?MODULE, {unused_import, ModOrMFA})
+   || {Module, Imports} <- ?tracker:collect_unused_imports(Pid),
+      {ModOrMFA, Meta} <- unused_imports_for_module(Module, Imports)],
+  ok.
 
-%% ERROR HANDLING
+warn_unused_requires(Pid, E) ->
+  [elixir_errors:file_warn(Meta, ?key(E, file), ?MODULE, {unused_require, Module})
+   || {Module, Meta} <- ?tracker:collect_unused_requires(Pid)],
+  ok.
 
-warn_unused_imports(File, Pid) ->
-  [ begin
-      elixir_errors:handle_file_warning(File, {L, ?MODULE, {unused_import, M}})
-    end || {M, L} <- ?tracker:collect_unused_imports(Pid)].
+unused_imports_for_module(Module, Imports) ->
+  case Imports of
+    #{Module := Meta} -> [{Module, Meta}];
+    #{} -> [{{Module, Fun, Arity}, Meta} || {{Fun, Arity}, Meta} <- maps:to_list(Imports)]
+  end.
 
-warn_unused_aliases(File, Pid) ->
-  [ begin
-      elixir_errors:handle_file_warning(File, {L, ?MODULE, {unused_alias, M}})
-    end || {M, L} <- ?tracker:collect_unused_aliases(Pid)].
+warn_unused_aliases(Pid, E) ->
+  [elixir_errors:file_warn(Meta, ?key(E, file), ?MODULE, {unused_alias, Module})
+   || {Module, Meta} <- ?tracker:collect_unused_aliases(Pid)],
+  ok.
 
 format_error({unused_alias, Module}) ->
   io_lib:format("unused alias ~ts", [elixir_aliases:inspect(Module)]);
+format_error({unused_import, {Module, Function, Arity}}) ->
+  io_lib:format("unused import ~ts.~ts/~w", [elixir_aliases:inspect(Module), Function, Arity]);
 format_error({unused_import, Module}) ->
-  io_lib:format("unused import ~ts", [elixir_aliases:inspect(Module)]).
+  io_lib:format("unused import ~ts", [elixir_aliases:inspect(Module)]);
+format_error({unused_require, Module}) ->
+  io_lib:format("unused require ~ts", [elixir_aliases:inspect(Module)]).
diff --git a/lib/elixir/src/elixir_locals.erl b/lib/elixir/src/elixir_locals.erl
deleted file mode 100644
index 92991d772a0..00000000000
--- a/lib/elixir/src/elixir_locals.erl
+++ /dev/null
@@ -1,181 +0,0 @@
-%% Module responsible for tracking invocations of module calls.
--module(elixir_locals).
--export([
-  setup/1, cleanup/1, cache_env/1, get_cached_env/1,
-  record_local/2, record_local/3, record_import/4,
-  record_definition/3, record_defaults/4,
-  ensure_no_function_conflict/4, warn_unused_local/3, format_error/1
-]).
--export([macro_for/3, local_for/3, local_for/4]).
-
--include("elixir.hrl").
--define(attr, '__locals_tracker').
--define(tracker, 'Elixir.Module.LocalsTracker').
-
-macro_for(Module, Name, Arity) ->
-  Tuple = {Name, Arity},
-  try elixir_def:lookup_definition(Module, Tuple) of
-    {{Tuple, Kind, Line, _, _, _, _}, [_|_] = Clauses}
-        when Kind == defmacro; Kind == defmacrop ->
-      fun() -> get_function(Line, Module, Clauses) end;
-    _ ->
-      false
-  catch
-    error:badarg -> false
-  end.
-
-local_for(Module, Name, Arity) ->
-  local_for(Module, Name, Arity, nil).
-local_for(Module, Name, Arity, Given) ->
-  Tuple = {Name, Arity},
-  case elixir_def:lookup_definition(Module, Tuple) of
-    {{Tuple, Kind, Line, _, _, _, _}, [_|_] = Clauses}
-        when Given == nil; Kind == Given ->
-      get_function(Line, Module, Clauses);
-    _ ->
-      [_|T] = erlang:get_stacktrace(),
-      erlang:raise(error, undef, [{Module,Name,Arity,[]}|T])
-  end.
-
-get_function(Line, Module, Clauses) ->
-  RewrittenClauses = [rewrite_clause(Clause, Module) || Clause <- Clauses],
-  Fun = {'fun', Line, {clauses, RewrittenClauses}},
-  {value, Result, _Binding} = erl_eval:exprs([Fun], []),
-  Result.
-
-rewrite_clause({call, Line, {atom, Line, RawName}, Args}, Module) ->
-  Remote = {remote, Line,
-    {atom, Line, ?MODULE},
-    {atom, Line, local_for}
- },
-
-  %% If we have a macro, its arity in the table is
-  %% actually one less than in the function call
-  {Name, Arity} = case atom_to_list(RawName) of
-    "MACRO-" ++ Rest -> {list_to_atom(Rest), length(Args) - 1};
-    _ -> {RawName, length(Args)}
-  end,
-
-  FunCall = {call, Line, Remote, [
-    {atom, Line, Module}, {atom, Line, Name}, {integer, Line, Arity}
-  ]},
-  {call, Line, FunCall, Args};
-
-rewrite_clause(Tuple, Module) when is_tuple(Tuple) ->
-  list_to_tuple(rewrite_clause(tuple_to_list(Tuple), Module));
-
-rewrite_clause(List, Module) when is_list(List) ->
-  [rewrite_clause(Item, Module) || Item <- List];
-
-rewrite_clause(Else, _) -> Else.
-
-%% TRACKING
-
-setup(Module) ->
-  case code:is_loaded(?tracker) of
-    {file, _} -> ets:insert(Module, {?attr, ?tracker:start_link()});
-    false -> ok
-  end.
-
-cleanup(Module) ->
-  if_tracker(Module, fun(Pid) -> unlink(Pid), ?tracker:stop(Pid) end).
-
-record_local(Tuple, Module) when is_atom(Module) ->
-  if_tracker(Module, fun(Pid) ->
-    ?tracker:add_local(Pid, Tuple),
-    true
-  end).
-record_local(Tuple, _Module, Function)
-  when Function == nil; Function == Tuple -> false;
-record_local(Tuple, Module, Function) ->
-  if_tracker(Module, fun(Pid) ->
-    ?tracker:add_local(Pid, Function, Tuple),
-    true
-  end).
-
-record_import(_Tuple, Receiver, Module, _Function)
-  when Module == nil; Module == Receiver -> false;
-record_import(Tuple, Receiver, Module, Function) ->
-  if_tracker(Module, fun(Pid) ->
-    ?tracker:add_import(Pid, Function, Receiver, Tuple),
-    true
-  end).
-
-record_definition(Tuple, Kind, Module) ->
-  if_tracker(Module, fun(Pid) ->
-    ?tracker:add_definition(Pid, Kind, Tuple),
-    true
-  end).
-
-record_defaults(_Tuple, _Kind, _Module, 0) ->
-  true;
-record_defaults(Tuple, Kind, Module, Defaults) ->
-  if_tracker(Module, fun(Pid) ->
-    ?tracker:add_defaults(Pid, Kind, Tuple, Defaults),
-    true
-  end).
-
-if_tracker(Module, Callback) ->
-  try ets:lookup_element(Module, ?attr, 2) of
-    Pid -> Callback(Pid)
-  catch
-    error:badarg -> false
-  end.
-
-%% CACHING
-
-cache_env(#{module := Module} = RE) ->
-  E = RE#{line := nil,vars := []},
-  try ets:lookup_element(Module, ?attr, 2) of
-    Pid ->
-      {Pid, ?tracker:cache_env(Pid, E)}
-  catch
-    error:badarg ->
-      {Escaped, _} = elixir_quote:escape(E, false),
-      Escaped
-  end.
-
-get_cached_env({Pid,Ref}) -> ?tracker:get_cached_env(Pid, Ref);
-get_cached_env(Env) -> Env.
-
-%% ERROR HANDLING
-
-ensure_no_function_conflict(Meta, File, Module, AllDefined) ->
-  if_tracker(Module, fun(Pid) ->
-    [ begin
-        elixir_errors:form_error(Meta, File, ?MODULE, {function_conflict, Error})
-      end || Error <- ?tracker:collect_imports_conflicts(Pid, AllDefined) ]
-  end),
-  ok.
-
-warn_unused_local(File, Module, Private) ->
-  if_tracker(Module, fun(Pid) ->
-    Args = [ {Fun, Kind, Defaults} ||
-             {Fun, Kind, _Line, true, Defaults} <- Private],
-
-    Unused = ?tracker:collect_unused_locals(Pid, Args),
-
-    [ begin
-        {_, _, Line, _, _} = lists:keyfind(element(2, Error), 1, Private),
-        elixir_errors:handle_file_warning(File, {Line, ?MODULE, Error})
-      end || Error <- Unused ]
-  end).
-
-format_error({function_conflict,{Receivers, Name, Arity}}) ->
-  io_lib:format("imported ~ts.~ts/~B conflicts with local function",
-    [elixir_aliases:inspect(hd(Receivers)), Name, Arity]);
-
-format_error({unused_args,{Name, Arity}}) ->
-  io_lib:format("default arguments in ~ts/~B are never used", [Name, Arity]);
-
-format_error({unused_args,{Name, Arity},1}) ->
-  io_lib:format("the first default argument in ~ts/~B is never used", [Name, Arity]);
-
-format_error({unused_args,{Name, Arity},Count}) ->
-  io_lib:format("the first ~B default arguments in ~ts/~B are never used", [Count, Name, Arity]);
-
-format_error({unused_def,{Name, Arity},defp}) ->
-  io_lib:format("function ~ts/~B is unused", [Name, Arity]);
-
-format_error({unused_def,{Name, Arity},defmacrop}) ->
-  io_lib:format("macro ~ts/~B is unused", [Name, Arity]).
diff --git a/lib/elixir/src/elixir_map.erl b/lib/elixir/src/elixir_map.erl
index 957530e8761..d38597e5864 100644
--- a/lib/elixir/src/elixir_map.erl
+++ b/lib/elixir/src/elixir_map.erl
@@ -1,175 +1,302 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(elixir_map).
--export([expand_map/3, translate_map/3, expand_struct/4, translate_struct/4]).
--import(elixir_errors, [compile_error/4]).
+-export([expand_map/4, expand_struct/5, format_error/1, maybe_load_struct_info/5]).
+-import(elixir_errors, [function_error/4, file_error/4, file_warn/4]).
 -include("elixir.hrl").
 
-expand_map(Meta, [{'|', UpdateMeta, [Left, Right]}], E) ->
-  {[ELeft|ERight], EA} = elixir_exp:expand_args([Left|Right], E),
-  {{'%{}', Meta, [{'|', UpdateMeta, [ELeft, ERight]}]}, EA};
-expand_map(Meta, Args, E) ->
-  {EArgs, EA} = elixir_exp:expand_args(Args, E),
-  {{'%{}', Meta, EArgs}, EA}.
+expand_map(Meta, [{'|', UpdateMeta, [Left, Right]}], S, #{context := nil} = E) ->
+  {[ELeft | ERight], SE, EE} = elixir_expand:expand_args([Left | Right], S, E),
+  validate_kv(Meta, ERight, Right, E),
+  {{'%{}', Meta, [{'|', UpdateMeta, [ELeft, ERight]}]}, SE, EE};
+expand_map(Meta, [{'|', _, [_, _]}] = Args, _S, #{context := Context, file := File}) ->
+  file_error(Meta, File, ?MODULE, {update_syntax_in_wrong_context, Context, {'%{}', Meta, Args}});
+expand_map(Meta, Args, S, E) ->
+  {EArgs, SE, EE} = elixir_expand:expand_args(Args, S, E),
+  validate_kv(Meta, EArgs, Args, E),
+  {{'%{}', Meta, EArgs}, SE, EE}.
+
+expand_struct(Meta, Left, {'%{}', MapMeta, MapArgs}, S, #{context := Context} = E) ->
+  CleanMapArgs = delete_struct_key(Meta, MapArgs, E),
+  {[ELeft, ERight], SE, EE} = elixir_expand:expand_args([Left, {'%{}', MapMeta, CleanMapArgs}], S, E),
+
+  case validate_struct(ELeft, Context) of
+    true when is_atom(ELeft) ->
+      case ERight of
+        {'%{}', MapMeta, [{'|', _, [_, Assocs]}]} ->
+          _ = load_struct_info(Meta, ELeft, Assocs, EE),
+          {{'%', Meta, [ELeft, ERight]}, SE, EE};
 
-expand_struct(Meta, Left, Right, E) ->
-  {[ELeft, ERight], EE} = elixir_exp:expand_args([Left, Right], E),
+        {'%{}', MapMeta, Assocs} when Context /= match ->
+          AssocKeys = [K || {K, _} <- Assocs],
+          Struct = load_struct(Meta, ELeft, Assocs, EE),
+          Keys = ['__struct__'] ++ AssocKeys,
+          WithoutKeys = lists:sort(maps:to_list(maps:without(Keys, Struct))),
+          StructAssocs = elixir_quote:escape(WithoutKeys, escape, false),
+          {{'%', Meta, [ELeft, {'%{}', MapMeta, StructAssocs ++ Assocs}]}, SE, EE};
+
+        {'%{}', MapMeta, Assocs} ->
+          _ = load_struct_info(Meta, ELeft, Assocs, EE),
+          {{'%', Meta, [ELeft, ERight]}, SE, EE}
+      end;
+
+    true ->
+      {{'%', Meta, [ELeft, ERight]}, SE, EE};
+
+    false when Context == match ->
+      file_error(Meta, E, ?MODULE, {invalid_struct_name_in_match, ELeft});
 
-  case is_atom(ELeft) of
-    true  -> ok;
     false ->
-      compile_error(Meta, ?m(E, file), "expected struct name to be a compile "
-        "time atom or alias, got: ~ts", ['Elixir.Macro':to_string(ELeft)])
-  end,
-
-  EMeta =
-    case lists:member(ELeft, ?m(E, context_modules)) of
-      true ->
-        case (ELeft == ?m(E, module)) and
-             (?m(E, function) == nil) of
-          true ->
-            compile_error(Meta, ?m(E, file),
-              "cannot access struct ~ts in body of the module that defines it as "
-              "the struct fields are not yet accessible",
-              [elixir_aliases:inspect(ELeft)]);
-          false ->
-            [{struct, context}|Meta]
-        end;
-      false ->
-        Meta
-    end,
+      file_error(Meta, E, ?MODULE, {invalid_struct_name, ELeft})
+  end;
+expand_struct(Meta, _Left, Right, _S, E) ->
+  file_error(Meta, E, ?MODULE, {non_map_after_struct, Right}).
+
+delete_struct_key(Meta, [{'|', PipeMeta, [Left, MapAssocs]}], E) ->
+  [{'|', PipeMeta, [Left, delete_struct_key_assoc(Meta, MapAssocs, E)]}];
+delete_struct_key(Meta, MapAssocs, E) ->
+  delete_struct_key_assoc(Meta, MapAssocs, E).
 
-  case ERight of
-    {'%{}', _, _} -> ok;
-    _ -> compile_error(Meta, ?m(E, file),
-           "expected struct to be followed by a map, got: ~ts",
-           ['Elixir.Macro':to_string(ERight)])
-  end,
+delete_struct_key_assoc(Meta, Assocs, E) ->
+  case lists:keytake('__struct__', 1, Assocs) of
+    {value, _, CleanAssocs} ->
+      file_warn(Meta, ?key(E, file), ?MODULE, ignored_struct_key_in_struct),
+      CleanAssocs;
+    false ->
+      Assocs
+  end.
 
-  {{'%', EMeta, [ELeft, ERight]}, EE}.
+validate_match_key(Meta, {Name, _, Context}, E) when is_atom(Name), is_atom(Context) ->
+  file_error(Meta, E, ?MODULE, {invalid_variable_in_map_key_match, Name});
+validate_match_key(Meta, {'::', _, [Left, _]}, E) ->
+  validate_match_key(Meta, Left, E);
+validate_match_key(_, {'^', _, [{Name, _, Context}]}, _) when is_atom(Name), is_atom(Context) ->
+  ok;
+validate_match_key(_, {'%{}', _, [_ | _]}, _) ->
+  ok;
+validate_match_key(Meta, {Left, _, Right}, E) ->
+  validate_match_key(Meta, Left, E),
+  validate_match_key(Meta, Right, E);
+validate_match_key(Meta, {Left, Right}, E) ->
+  validate_match_key(Meta, Left, E),
+  validate_match_key(Meta, Right, E);
+validate_match_key(Meta, List, E) when is_list(List) ->
+  [validate_match_key(Meta, Each, E) || Each <- List];
+validate_match_key(_, _, _) ->
+  ok.
 
-translate_map(Meta, Args, S) ->
-  {Assocs, TUpdate, US} = extract_assoc_update(Args, S),
-  translate_map(Meta, Assocs, TUpdate, US).
+validate_not_repeated(Meta, Key, Used, E) ->
+  case is_literal(Key) andalso Used of
+    #{Key := true} ->
+      case E of
+        #{context := match} -> function_error(Meta, ?key(E, file), ?MODULE, {repeated_key, Key});
+        _ -> file_warn(Meta, ?key(E, file), ?MODULE, {repeated_key, Key})
+      end,
+      Used;
 
-translate_struct(Meta, Name, {'%{}', MapMeta, Args}, S) ->
-  {Assocs, TUpdate, US} = extract_assoc_update(Args, S),
-  Struct = load_struct(Meta, Name, S),
+    #{} ->
+      Used#{Key => true};
 
-  case is_map(Struct) of
-    true  ->
-      assert_struct_keys(Meta, Name, Struct, Assocs, S);
     false ->
-      compile_error(Meta, S#elixir_scope.file, "expected ~ts.__struct__/0 to "
-        "return a map, got: ~ts", [elixir_aliases:inspect(Name), 'Elixir.Kernel':inspect(Struct)])
-  end,
+      Used
+  end.
 
-  if
-    TUpdate /= nil ->
-      Line  = ?line(Meta),
-      {VarName, _, VS} = elixir_scope:build_var('_', US),
+is_literal({_, _, _}) -> false;
+is_literal({Left, Right}) -> is_literal(Left) andalso is_literal(Right);
+is_literal([_ | _] = List) -> lists:all(fun is_literal/1, List);
+is_literal(_) -> true.
 
-      Var = {var, Line, VarName},
-      Map = {map, Line, [{map_field_exact, Line, {atom, Line, '__struct__'}, {atom, Line, Name}}]},
+validate_kv(Meta, KV, Original, #{context := Context} = E) ->
+  lists:foldl(fun
+    ({K, _V}, {Index, Used}) ->
+      (Context == match) andalso validate_match_key(Meta, K, E),
+      NewUsed = validate_not_repeated(Meta, K, Used, E),
+      {Index + 1, NewUsed};
+    (_, {Index, _Used}) ->
+      file_error(Meta, E, ?MODULE, {not_kv_pair, lists:nth(Index, Original)})
+  end, {1, #{}}, KV).
 
-      Match = {match, Line, Var, Map},
-      Error = {tuple, Line, [{atom, Line, badstruct}, {atom, Line, Name}, Var]},
+validate_struct({'^', _, [{Var, _, Ctx}]}, match) when is_atom(Var), is_atom(Ctx) -> true;
+validate_struct({Var, _Meta, Ctx}, match) when is_atom(Var), is_atom(Ctx) -> true;
+validate_struct(Atom, _) when is_atom(Atom) -> true;
+validate_struct(_, _) -> false.
 
-      {TMap, TS} = translate_map(MapMeta, Assocs, Var, VS),
+load_struct_info(Meta, Name, Assocs, E) ->
+  assert_struct_assocs(Meta, Assocs, E),
 
-      {{'case', Line, TUpdate, [
-        {clause, Line, [Match], [], [TMap]},
-        {clause, Line, [Var], [], [elixir_utils:erl_call(Line, erlang, error, [Error])]}
-      ]}, TS};
-    S#elixir_scope.context == match ->
-      translate_map(MapMeta, Assocs ++ [{'__struct__', Name}], nil, US);
-    true ->
-      Keys = [K || {K,_} <- Assocs],
-      {StructAssocs, _} = elixir_quote:escape(maps:to_list(maps:without(Keys, Struct)), false),
-      translate_map(MapMeta, StructAssocs ++ Assocs ++ [{'__struct__', Name}], nil, US)
+  case maybe_load_struct_info(Meta, Name, Assocs, true, E) of
+    {ok, Info} -> Info;
+    {error, Desc} -> file_error(Meta, E, ?MODULE, Desc)
+  end.
+
+maybe_load_struct_info(Meta, Name, Assocs, Trace, E) ->
+  try
+    case is_open(Name, Meta, E) andalso lookup_struct_info_from_data_tables(Name) of
+      %% If I am accessing myself and there is no attribute,
+      %% don't invoke the fallback to avoid calling loaded code.
+      false when ?key(E, module) =:= Name -> nil;
+      false -> Name:'__info__'(struct);
+      InfoList -> InfoList
+    end
+  of
+    nil ->
+      {error, detail_undef(Name, E)};
+
+    Info ->
+      Keys = [begin
+        lists:any(fun(Field) -> ?key(Field, field) =:= Key end, Info) orelse
+          function_error(Meta, E, ?MODULE, {unknown_key_for_struct, Name, Key}),
+        Key
+      end || {Key, _} <- Assocs],
+      Trace andalso elixir_env:trace({struct_expansion, Meta, Name, Keys}, E),
+      {ok, Info}
+  catch
+    error:undef -> {error, detail_undef(Name, E)}
   end.
 
-%% Helpers
+lookup_struct_info_from_data_tables(Module) ->
+  try
+    {Set, _} = elixir_module:data_tables(Module),
+    ets:lookup_element(Set, {elixir, struct}, 2)
+  catch
+    _:_ -> false
+  end.
 
-load_struct(Meta, Name, S) ->
-  Local =
-    elixir_module:is_open(Name) andalso
-    (case lists:keyfind(struct, 1, Meta) of
-      {struct, context} -> true;
-      _ -> wait_for_struct(Name)
-    end),
+load_struct(Meta, Name, Assocs, E) ->
+  assert_struct_assocs(Meta, Assocs, E),
 
   try
-    case Local of
-      true ->
+    maybe_load_struct(Meta, Name, Assocs, E)
+  of
+    {ok, Struct} -> Struct;
+    {error, Desc} -> file_error(Meta, E, ?MODULE, Desc)
+  catch
+    Kind:Reason ->
+      Info = [{Name, '__struct__', 1, [{file, "expanding struct"}]},
+              elixir_utils:caller(?line(Meta), ?key(E, file), ?key(E, module), ?key(E, function))],
+      erlang:raise(Kind, Reason, Info)
+  end.
+
+maybe_load_struct(Meta, Name, Assocs, E) ->
+  try
+    case is_open(Name, Meta, E) andalso elixir_def:external_for(Meta, Name, '__struct__', 1, [def]) of
+      %% If I am accessing myself and there is no __struct__ function,
+      %% don't invoke the fallback to avoid calling loaded code.
+      false when ?key(E, module) =:= Name ->
+        error(undef);
+
+      false ->
+        Name:'__struct__'(Assocs);
+
+      ExternalFun ->
+        %% There is an inherent race condition when using external_for.
+        %% By the time we got to execute the function, the ETS table
+        %% with temporary definitions for the given module may no longer
+        %% be available, so any function invocation happening inside the
+        %% local function will fail. In this case, we need to fall back to
+        %% the regular dispatching since the module will be available if
+        %% the table has not been deleted (unless compilation of that
+        %% module failed which should then cause this call to fail too).
         try
-          (elixir_locals:local_for(Name, '__struct__', 0, def))()
+          ExternalFun(Assocs)
         catch
-          error:undef  -> Name:'__struct__'();
-          error:badarg -> Name:'__struct__'()
-        end;
-      false ->
-        Name:'__struct__'()
+          error:undef -> Name:'__struct__'(Assocs)
+        end
     end
+  of
+    #{'__struct__' := Name} = Struct ->
+      Keys = [begin
+        maps:is_key(Key, Struct) orelse
+          function_error(Meta, E, ?MODULE, {unknown_key_for_struct, Name, Key}),
+        Key
+      end || {Key, _} <- Assocs],
+      elixir_env:trace({struct_expansion, Meta, Name, Keys}, E),
+      {ok, Struct};
+
+    #{'__struct__' := StructName} when is_atom(StructName) ->
+      {error, {struct_name_mismatch, Name, StructName}};
+
+    Other ->
+      {error, {invalid_struct_return_value, Name, Other}}
   catch
-    error:undef ->
-      Inspected = elixir_aliases:inspect(Name),
-      compile_error(Meta, S#elixir_scope.file, "~ts.__struct__/0 is undefined, "
-        "cannot expand struct ~ts", [Inspected, Inspected])
+    error:undef -> {error, detail_undef(Name, E)}
   end.
 
-wait_for_struct(Module) ->
-  case erlang:get(elixir_compiler_pid) of
-    undefined ->
-      false;
-    Pid ->
-      Ref = erlang:make_ref(),
-      Pid ! {waiting, struct, self(), Ref, Module},
-      receive
-        {Ref, ready} ->
-          true;
-        {Ref, release} ->
-          'Elixir.Kernel.ErrorHandler':release(),
-          false
-      end
+assert_struct_assocs(Meta, Assocs, E) ->
+  [function_error(Meta, E, ?MODULE, {invalid_key_for_struct, K})
+   || {K, _} <- Assocs, not is_atom(K)].
+
+is_open(Name, Meta, E) ->
+  in_context(Name, E) orelse ((code:ensure_loaded(Name) /= {module, Name}) andalso wait_for_struct(Name, Meta, E)).
+
+in_context(Name, E) ->
+  %% We also include the current module because it won't be present
+  %% in context module in case the module name is defined dynamically.
+  lists:member(Name, [?key(E, module) | ?key(E, context_modules)]).
+
+wait_for_struct(Module, Meta, E) ->
+  (erlang:get(elixir_compiler_info) /= undefined) andalso
+    ('Elixir.Kernel.ErrorHandler':ensure_compiled(Module, struct, hard, elixir_utils:get_line(Meta, E)) =:= found).
+
+detail_undef(Name, E) ->
+  case in_context(Name, E) andalso (?key(E, function) == nil) of
+    true -> {inaccessible_struct, Name};
+    false -> {undefined_struct, Name}
   end.
 
-translate_map(Meta, Assocs, TUpdate, #elixir_scope{extra=Extra} = S) ->
-  {Op, KeyFun, ValFun} = extract_key_val_op(TUpdate, S),
-
-  Line = ?line(Meta),
-
-  {TArgs, SA} = lists:mapfoldl(fun
-    ({Key, Value}, Acc) ->
-      {TKey, Acc1}   = KeyFun(Key, Acc),
-      {TValue, Acc2} = ValFun(Value, Acc1#elixir_scope{extra=Extra}),
-      {{Op, ?line(Meta), TKey, TValue}, Acc2};
-    (Other, _Acc) ->
-      compile_error(Meta, S#elixir_scope.file, "expected key-value pairs in map, got: ~ts",
-                     ['Elixir.Macro':to_string(Other)])
-  end, S, Assocs),
-
-  build_map(Line, TUpdate, TArgs, SA).
-
-extract_assoc_update([{'|', _Meta, [Update, Args]}], S) ->
-  {TArg, SA} = elixir_translator:translate_arg(Update, S, S),
-  {Args, TArg, SA};
-extract_assoc_update(Args, SA) -> {Args, nil, SA}.
-
-extract_key_val_op(_TUpdate, #elixir_scope{context=match}) ->
-  {map_field_exact,
-    fun(X, Acc) -> elixir_translator:translate(X, Acc#elixir_scope{extra=map_key}) end,
-    fun elixir_translator:translate/2};
-extract_key_val_op(TUpdate, S) ->
-  KS = S#elixir_scope{extra=map_key},
-  Op = if TUpdate == nil -> map_field_assoc; true -> map_field_exact end,
-  {Op,
-    fun(X, Acc) -> elixir_translator:translate_arg(X, Acc, KS) end,
-    fun(X, Acc) -> elixir_translator:translate_arg(X, Acc, S) end}.
-
-build_map(Line, nil, TArgs, SA) -> {{map, Line, TArgs}, SA};
-build_map(Line, TUpdate, TArgs, SA) -> {{map, Line, TUpdate, TArgs}, SA}.
-
-assert_struct_keys(Meta, Name, Struct, Assocs, S) ->
-  [begin
-     compile_error(Meta, S#elixir_scope.file, "unknown key ~ts for struct ~ts",
-                   ['Elixir.Kernel':inspect(Key), elixir_aliases:inspect(Name)])
-   end || {Key, _} <- Assocs, not maps:is_key(Key, Struct)].
+format_error({update_syntax_in_wrong_context, Context, Expr}) ->
+  io_lib:format("cannot use map/struct update syntax in ~ts, got: ~ts",
+                [Context, 'Elixir.Macro':to_string(Expr)]);
+format_error({invalid_struct_name_in_match, Expr}) ->
+  Message =
+    "expected struct name in a match to be a compile time atom, alias or a "
+    "variable, got: ~ts",
+  io_lib:format(Message, ['Elixir.Macro':to_string(Expr)]);
+format_error({invalid_struct_name, Expr}) ->
+  Message = "expected struct name to be a compile time atom or alias, got: ~ts",
+  io_lib:format(Message, ['Elixir.Macro':to_string(Expr)]);
+format_error({invalid_variable_in_map_key_match, Name}) ->
+  Message =
+    "cannot use variable ~ts as map key inside a pattern. Map keys in patterns can only be literals "
+    "(such as atoms, strings, tuples, and the like) or an existing variable matched with the pin operator "
+    "(such as ^some_var)",
+  io_lib:format(Message, [Name]);
+format_error({repeated_key, Key}) ->
+    io_lib:format("key ~ts will be overridden in map", ['Elixir.Macro':to_string(Key)]);
+format_error({not_kv_pair, Expr}) ->
+  io_lib:format("expected key-value pairs in a map, got: ~ts",
+                ['Elixir.Macro':to_string(Expr)]);
+format_error({non_map_after_struct, Expr}) ->
+  io_lib:format("expected struct to be followed by a map, got: ~ts",
+                ['Elixir.Macro':to_string(Expr)]);
+format_error({struct_name_mismatch, Module, StructName}) ->
+  Name = elixir_aliases:inspect(Module),
+  Message = "expected struct name returned by ~ts.__struct__/1 to be ~ts, got: ~ts",
+  io_lib:format(Message, [Name, Name, elixir_aliases:inspect(StructName)]);
+format_error({invalid_struct_return_value, Module, Value}) ->
+  Message =
+    "expected ~ts.__struct__/1 to return a map with a :__struct__ key that holds the "
+    "name of the struct (atom), got: ~ts",
+  io_lib:format(Message, [elixir_aliases:inspect(Module), 'Elixir.Kernel':inspect(Value)]);
+format_error({inaccessible_struct, Module}) ->
+  Message =
+    "cannot access struct ~ts, the struct was not yet defined or the struct is "
+    "being accessed in the same context that defines it",
+  io_lib:format(Message, [elixir_aliases:inspect(Module)]);
+format_error({undefined_struct, Module}) ->
+  Name = elixir_aliases:inspect(Module),
+  io_lib:format(
+    "~ts.__struct__/1 is undefined, cannot expand struct ~ts. "
+    "Make sure the struct name is correct. If the struct name exists and is correct "
+    "but it still cannot be found, you likely have cyclic module usage in your code",
+    [Name, Name]);
+format_error({unknown_key_for_struct, Module, Key}) ->
+  io_lib:format("unknown key ~ts for struct ~ts",
+                ['Elixir.Macro':to_string(Key), elixir_aliases:inspect(Module)]);
+format_error({invalid_key_for_struct, Key}) ->
+  io_lib:format("invalid key ~ts for struct, struct keys must be atoms, got: ",
+                ['Elixir.Macro':to_string(Key)]);
+format_error(ignored_struct_key_in_struct) ->
+  "key :__struct__ is ignored when using structs".
\ No newline at end of file
diff --git a/lib/elixir/src/elixir_module.erl b/lib/elixir/src/elixir_module.erl
index 971b50eb472..643291c9a83 100644
--- a/lib/elixir/src/elixir_module.erl
+++ b/lib/elixir/src/elixir_module.erl
@@ -1,365 +1,380 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(elixir_module).
--export([compile/4, data_table/1, docs_table/1, is_open/1,
-         expand_callback/6, add_beam_chunk/3, format_error/1]).
+-export([file/1, data_tables/1, is_open/1, mode/1, delete_definition_attributes/6,
+         compile/6, expand_callback/6, format_error/1, compiler_modules/0, exports_md5/3,
+         write_cache/3, read_cache/2, next_counter/1, taint/1, cache_env/1, get_cached_env/1]).
 -include("elixir.hrl").
+-define(counter_attr, {elixir, counter}).
+-define(cache_key, {elixir, cache_env}).
 
--define(acc_attr, '__acc_attributes').
--define(docs_attr, '__docs_table').
--define(lexical_attr, '__lexical_tracker').
--define(persisted_attr, '__persisted_attributes').
--define(overridable_attr, '__overridable').
--define(location_attr, '__location').
-
-%% TABLE METHODS
-
-data_table(Module) ->
-  Module.
-
-docs_table(Module) ->
-  ets:lookup_element(Module, ?docs_attr, 2).
-
-is_open(Module) ->
-  Module == ets:info(Module, name).
-
-%% Compilation hook
-
-compile(Module, Block, Vars, #{line := Line} = Env) when is_atom(Module) ->
-  %% In case we are generating a module from inside a function,
-  %% we get rid of the lexical tracker information as, at this
-  %% point, the lexical tracker process is long gone.
-  LexEnv = case ?m(Env, function) of
-    nil -> Env#{module := Module, local := nil};
-    _   -> Env#{lexical_tracker := nil, function := nil, module := Module, local := nil}
-  end,
-
-  case ?m(LexEnv, lexical_tracker) of
-    nil ->
-      elixir_lexical:run(?m(LexEnv, file), fun(Pid) ->
-        do_compile(Line, Module, Block, Vars, LexEnv#{lexical_tracker := Pid})
-      end);
-    _ ->
-      do_compile(Line, Module, Block, Vars, LexEnv)
-  end;
-
-compile(Module, _Block, _Vars, #{line := Line, file := File}) ->
-  elixir_errors:form_error(Line, File, ?MODULE, {invalid_module, Module}).
+%% Stores modules currently being defined by the compiler
 
-do_compile(Line, Module, Block, Vars, E) ->
-  File = ?m(E, file),
-  check_module_availability(Line, File, Module),
-  build(Line, File, Module, ?m(E, lexical_tracker)),
-
-  try
-    {Result, NE} = eval_form(Line, Module, Block, Vars, E),
-    {Base, Export, Private, Def, Defmacro, Functions} = elixir_def:unwrap_definitions(Module),
-
-    {All, Forms0} = functions_form(Line, File, Module, Base, Export, Def, Defmacro, Functions),
-    Forms1        = specs_form(Module, Private, Defmacro, Forms0),
-    Forms2        = types_form(Module, Forms1),
-    Forms3        = attributes_form(Line, File, Module, Forms2),
-
-    case ets:lookup(data_table(Module), 'on_load') of
-      [] -> ok;
-      [{on_load,OnLoad}] ->
-        [elixir_locals:record_local(Tuple, Module) || Tuple <- OnLoad]
-    end,
-
-    AllFunctions = Def ++ [T || {T, defp, _, _, _} <- Private],
-    elixir_locals:ensure_no_function_conflict(Line, File, Module, AllFunctions),
-    elixir_locals:warn_unused_local(File, Module, Private),
-    warn_invalid_clauses(Line, File, Module, All),
-    warn_unused_docs(Line, File, Module),
-
-    Location = {elixir_utils:relative_to_cwd(elixir_utils:characters_to_list(File)), Line},
-
-    Final = [
-      {attribute, Line, file, Location},
-      {attribute, Line, module, Module} | Forms3
-    ],
-
-    Binary = load_form(Line, Final, compile_opts(Module), NE),
-    {module, Module, Binary, Result}
-  after
-    elixir_locals:cleanup(Module),
-    elixir_def:cleanup(Module),
-    ets:delete(docs_table(Module)),
-    ets:delete(data_table(Module))
+compiler_modules() ->
+  case erlang:get(elixir_compiler_modules) of
+    undefined -> [];
+    M when is_list(M) -> M
   end.
 
-%% Hook that builds both attribute and functions and set up common hooks.
+put_compiler_modules([]) ->
+  erlang:erase(elixir_compiler_modules);
+put_compiler_modules(M) when is_list(M) ->
+  erlang:put(elixir_compiler_modules, M).
 
-build(Line, File, Module, Lexical) ->
-  %% Table with meta information about the module.
-  DataTable = data_table(Module),
+exports_md5(Def, Defmacro, Struct) ->
+  erlang:md5(term_to_binary({lists:sort(Def), lists:sort(Defmacro), Struct}, [deterministic])).
 
-  OldTable = ets:info(DataTable, name),
-  case OldTable == DataTable of
-    true ->
-      [{OldFile, OldLine}] = ets:lookup_element(OldTable, ?location_attr, 2),
-      Error = {module_in_definition, Module, OldFile, OldLine},
-      elixir_errors:form_error(Line, File, ?MODULE, Error);
-    false ->
-      []
-  end,
+%% Table functions
 
-  ets:new(DataTable, [set, named_table, public]),
-  ets:insert(DataTable, {before_compile, []}),
-  ets:insert(DataTable, {after_compile, []}),
+file(Module) ->
+  ets:lookup_element(elixir_modules, Module, 4).
 
-  case elixir_compiler:get_opt(docs) of
-    true -> ets:insert(DataTable, {on_definition, [{'Elixir.Module', compile_doc}]});
-    _    -> ets:insert(DataTable, {on_definition, []})
-  end,
+data_tables(Module) ->
+  ets:lookup_element(elixir_modules, Module, 2).
 
-  Attributes = [behaviour, on_load, spec, type, typep, opaque, callback, compile, external_resource],
-  ets:insert(DataTable, {?acc_attr, [before_compile, after_compile, on_definition, derive|Attributes]}),
-  ets:insert(DataTable, {?persisted_attr, [vsn|Attributes]}),
-  ets:insert(DataTable, {?docs_attr, ets:new(DataTable, [ordered_set, public])}),
-  ets:insert(DataTable, {?lexical_attr, Lexical}),
-  ets:insert(DataTable, {?overridable_attr, []}),
-  ets:insert(DataTable, {?location_attr, [{File, Line}]}),
-
-  %% Setup other modules
-  elixir_def:setup(Module),
-  elixir_locals:setup(Module).
-
-%% Receives the module representation and evaluates it.
-
-eval_form(Line, Module, Block, Vars, E) ->
-  {Value, EE} = elixir_compiler:eval_forms(Block, Vars, E),
-  elixir_def_overridable:store_pending(Module),
-  EV = elixir_env:linify({Line, EE#{vars := [], export_vars := nil}}),
-  EC = eval_callbacks(Line, Module, before_compile, [EV], EV),
-  elixir_def_overridable:store_pending(Module),
-  {Value, EC}.
-
-eval_callbacks(Line, Module, Name, Args, E) ->
-  Callbacks = lists:reverse(ets:lookup_element(data_table(Module), Name, 2)),
-
-  lists:foldl(fun({M,F}, Acc) ->
-    expand_callback(Line, M, F, Args, Acc#{vars := [], export_vars := nil},
-                    fun(AM, AF, AA) -> apply(AM, AF, AA) end)
-  end, E, Callbacks).
+is_open(Module) ->
+  ets:member(elixir_modules, Module).
 
-%% Return the form with exports and function declarations.
+mode(Module) ->
+  try ets:lookup_element(elixir_modules, Module, 5) of
+    Mode -> Mode
+  catch
+    _:badarg -> closed
+  end.
 
-functions_form(Line, File, Module, BaseAll, BaseExport, Def, Defmacro, BaseFunctions) ->
-  {InfoSpec, Info} = add_info_function(Line, File, Module, BaseExport, Def, Defmacro),
+make_readonly(Module) ->
+  ets:update_element(elixir_modules, Module, {5, readonly}).
 
-  All       = [{'__info__', 1}|BaseAll],
-  Export    = [{'__info__', 1}|BaseExport],
-  Functions = [InfoSpec,Info|BaseFunctions],
+delete_definition_attributes(#{module := Module}, _, _, _, _, _) ->
+  {DataSet, _} = data_tables(Module),
+  ets:delete(DataSet, doc),
+  ets:delete(DataSet, deprecated),
+  ets:delete(DataSet, impl).
 
-  {All, [
-    {attribute, Line, export, lists:sort(Export)} | Functions
-  ]}.
+write_cache(Module, Key, Value) ->
+  {DataSet, _} = data_tables(Module),
+  ets:insert(DataSet, {{cache, Key}, Value}).
 
-%% Add attributes handling to the form
+read_cache(Module, Key) ->
+  {DataSet, _} = data_tables(Module),
+  ets:lookup_element(DataSet, {cache, Key}, 2).
 
-attributes_form(Line, File, Module, Current) ->
-  Table = data_table(Module),
+next_counter(nil) -> erlang:unique_integer();
+next_counter(Module) ->
+  try
+    {DataSet, _} = data_tables(Module),
+    {Module, ets:update_counter(DataSet, ?counter_attr, 1)}
+  catch
+    _:_ -> erlang:unique_integer()
+  end.
 
-  AccAttrs = ets:lookup_element(Table, '__acc_attributes', 2),
-  PersistedAttrs = ets:lookup_element(Table, '__persisted_attributes', 2),
+taint(Module) ->
+  try
+    {DataSet, _} = data_tables(Module),
+    ets:insert(DataSet, [{{elixir, taint}}]),
+    true
+  catch
+    _:_ -> false
+  end.
 
-  Transform = fun({Key, Value}, Acc) ->
-    case lists:member(Key, PersistedAttrs) of
-      false -> Acc;
-      true  ->
-        Values =
-          case lists:member(Key, AccAttrs) of
-            true  -> Value;
-            false -> [Value]
-          end,
+cache_env(#{line := Line, module := Module} = E) ->
+  {Set, _} = data_tables(Module),
+  Cache = elixir_env:reset_vars(E#{line := nil}),
+  PrevKey = ets:lookup_element(Set, ?cache_key, 2),
 
-        lists:foldl(fun(X, Final) ->
-          [{attribute, Line, Key, X}|Final]
-        end, Acc, process_attribute(Line, File, Key, Values))
-    end
-  end,
+  Pos =
+    case ets:lookup(Set, {cache_env, PrevKey}) of
+      [{_, Cache}] ->
+        PrevKey;
+      _ ->
+        NewKey = PrevKey + 1,
+        ets:insert(Set, [{{cache_env, NewKey}, Cache}, {?cache_key, NewKey}]),
+        NewKey
+    end,
 
-  ets:foldl(Transform, Current, Table).
+  {Module, {Line, Pos}}.
 
-process_attribute(Line, File, external_resource, Values) ->
-  lists:usort([process_external_resource(Line, File, Value) || Value <- Values]);
-process_attribute(_Line, _File, _Key, Values) ->
-  Values.
+get_cached_env({Module, {Line, Pos}}) ->
+  {Set, _} = data_tables(Module),
+  (ets:lookup_element(Set, {cache_env, Pos}, 2))#{line := Line};
+get_cached_env(Env) ->
+  Env.
 
-process_external_resource(_Line, _File, Value) when is_binary(Value) ->
-  Value;
-process_external_resource(Line, File, Value) ->
-  elixir_errors:handle_file_error(File,
-    {Line, ?MODULE, {invalid_external_resource, Value}}).
+%% Compilation hook
 
-%% Types
+compile(Meta, Module, Block, Vars, Prune, Env) ->
+  ModuleAsCharlist = validate_module_name(Module),
+  #{function := Function, versioned_vars := OldVerVars} = Env,
 
-types_form(Module, Forms0) ->
-  case code:ensure_loaded('Elixir.Kernel.Typespec') of
-    {module, 'Elixir.Kernel.Typespec'} ->
-      Types0 = 'Elixir.Module':get_attribute(Module, type) ++
-               'Elixir.Module':get_attribute(Module, typep) ++
-               'Elixir.Module':get_attribute(Module, opaque),
+  {VerVars, _} =
+    lists:mapfoldl(fun({Var, _}, I) -> {{Var, I}, I + 1} end, 0, maps:to_list(OldVerVars)),
 
-      Types1 = ['Elixir.Kernel.Typespec':translate_type(Kind, Expr, Doc, Caller) ||
-                {Kind, Expr, Doc, Caller} <- Types0],
+  BaseEnv = Env#{module := Module, versioned_vars := maps:from_list(VerVars)},
 
-      'Elixir.Module':delete_attribute(Module, type),
-      'Elixir.Module':delete_attribute(Module, typep),
-      'Elixir.Module':delete_attribute(Module, opaque),
+  MaybeLexEnv =
+    case Function of
+      nil -> BaseEnv;
+      _   -> BaseEnv#{lexical_tracker := nil, tracers := [], function := nil}
+    end,
 
-      Forms1 = types_attributes(Types1, Forms0),
-      Forms2 = export_types_attributes(Types1, Forms1),
-      typedocs_attributes(Types1, Forms2);
+  case MaybeLexEnv of
+    #{lexical_tracker := nil} ->
+      elixir_lexical:run(
+        MaybeLexEnv,
+        fun(LexEnv) -> compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, LexEnv) end,
+        fun(_LexEnv) -> ok end
+      );
+    _ ->
+      compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, MaybeLexEnv)
+  end.
 
-    {error, _} ->
-      Forms0
+validate_module_name(Module) when Module == nil; is_boolean(Module); not is_atom(Module) ->
+  invalid_module_name(Module);
+validate_module_name(Module) ->
+  Charlist = atom_to_list(Module),
+  case lists:any(fun(Char) -> (Char =:= $/) or (Char =:= $\\) end, Charlist) of
+    true -> invalid_module_name(Module);
+    false -> Charlist
   end.
 
-types_attributes(Types, Forms) ->
-  Fun = fun({{Kind, _NameArity, Expr}, Line, _Export, _Doc}, Acc) ->
-    [{attribute, Line, Kind, Expr}|Acc]
-  end,
-  lists:foldl(Fun, Forms, Types).
-
-export_types_attributes(Types, Forms) ->
-  Fun = fun
-    ({{_Kind, NameArity, _Expr}, Line, true, _Doc}, Acc) ->
-      [{attribute, Line, export_type, [NameArity]}|Acc];
-    ({_Type, _Line, false, _Doc}, Acc) ->
-      Acc
-  end,
-  lists:foldl(Fun, Forms, Types).
-
-typedocs_attributes(Types, Forms) ->
-  Fun = fun
-    ({{_Kind, NameArity, _Expr}, Line, true, Doc}, Acc) when Doc =/= nil ->
-      [{attribute, Line, typedoc, {NameArity, Doc}}|Acc];
-    ({_Type, _Line, _Export, _Doc}, Acc) ->
-      Acc
-  end,
-  lists:foldl(Fun, Forms, Types).
+invalid_module_name(Module) ->
+  %% We raise an argument error to keep it close to Elixir errors before it starts.
+  erlang:error('Elixir.ArgumentError':exception(
+    <<"invalid module name: ",
+      ('Elixir.Kernel':inspect(Module))/binary>>
+  )).
 
-%% Specs
+compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
+  Anno = ?ann(Meta),
+  Line = erl_anno:line(Anno),
 
-specs_form(Module, Private, Defmacro, Forms) ->
-  case code:ensure_loaded('Elixir.Kernel.Typespec') of
-    {module, 'Elixir.Kernel.Typespec'} ->
-      Defmacrop = [Tuple || {Tuple, defmacrop, _, _, _} <- Private],
+  File = ?key(E, file),
+  check_module_availability(Module, Line, E),
+  elixir_env:trace(defmodule, E),
 
-      Specs0 = 'Elixir.Module':get_attribute(Module, spec) ++
-               'Elixir.Module':get_attribute(Module, callback),
+  CompilerModules = compiler_modules(),
+  {Tables, Ref} = build(Module, Line, File, E),
+  {DataSet, DataBag} = Tables,
 
-      Specs1 = ['Elixir.Kernel.Typespec':translate_spec(Kind, Expr, Caller) ||
-                {Kind, Expr, Caller} <- Specs0],
-      Specs2 = lists:flatmap(fun(Spec) ->
-                               translate_macro_spec(Spec, Defmacro, Defmacrop)
-                             end, Specs1),
+  try
+    put_compiler_modules([Module | CompilerModules]),
+    {Result, ModuleE, CallbackE} = eval_form(Line, Module, DataBag, Block, Vars, Prune, E),
+    CheckerInfo = checker_info(),
+    {BeamLocation, Forceload} = beam_location(ModuleAsCharlist),
+
+    {Binary, PersistedAttributes, Autoload} =
+      elixir_erl_compiler:spawn(fun() ->
+        PersistedAttributes = ets:lookup_element(DataBag, persisted_attributes, 2),
+        Attributes = attributes(DataSet, DataBag, PersistedAttributes),
+        {AllDefinitions, Private} = elixir_def:fetch_definitions(Module, E),
+
+        OnLoadAttribute = lists:keyfind(on_load, 1, Attributes),
+        validate_on_load_attribute(OnLoadAttribute, AllDefinitions, DataBag, Line, E),
+
+        DialyzerAttribute = lists:keyfind(dialyzer, 1, Attributes),
+        validate_dialyzer_attribute(DialyzerAttribute, AllDefinitions, Line, E),
+
+        NifsAttribute = lists:keyfind(nifs, 1, Attributes),
+        validate_nifs_attribute(NifsAttribute, AllDefinitions, Line, E),
+        elixir_import:ensure_no_local_conflict(Module, AllDefinitions, E),
+        make_readonly(Module),
+
+        (not elixir_config:is_bootstrap()) andalso
+         'Elixir.Module':'__check_attributes__'(E, DataSet, DataBag),
+
+        AfterVerify = bag_lookup_element(DataBag, {accumulate, after_verify}, 2),
+        [elixir_env:trace({remote_function, [{line, Line}], VerifyMod, VerifyFun, 1}, CallbackE) ||
+         {VerifyMod, VerifyFun} <- AfterVerify],
+
+        %% Ensure there are no errors before we infer types
+        compile_error_if_tainted(DataSet, E),
+
+        {Signatures, Unreachable} =
+          case elixir_config:is_bootstrap() of
+            true -> {#{}, []};
+            false ->
+              UsedPrivate = bag_lookup_element(DataBag, used_private, 2),
+              'Elixir.Module.Types':infer(Module, File, Attributes, AllDefinitions, Private, UsedPrivate, E, CheckerInfo)
+          end,
 
-      'Elixir.Module':delete_attribute(Module, spec),
-      'Elixir.Module':delete_attribute(Module, callback),
-      specs_attributes(Forms, Specs2);
+        RawCompileOpts = bag_lookup_element(DataBag, {accumulate, compile}, 2),
+        CompileOpts = validate_compile_opts(RawCompileOpts, AllDefinitions, Unreachable, Line, E),
+        Impls = bag_lookup_element(DataBag, impls, 2),
+
+        Struct = get_struct(DataSet),
+        set_exports_md5(DataSet, AllDefinitions, Struct),
+
+        ModuleMap = #{
+          struct => Struct,
+          module => Module,
+          anno => Anno,
+          file => File,
+          relative_file => elixir_utils:relative_to_cwd(File),
+          attributes => Attributes,
+          definitions => AllDefinitions,
+          after_verify => AfterVerify,
+          compile_opts => CompileOpts,
+          deprecated => get_deprecated(DataBag),
+          defines_behaviour => defines_behaviour(DataBag),
+          impls => Impls,
+          unreachable => Unreachable
+        },
+
+        compile_error_if_tainted(DataSet, E),
+        Binary = elixir_erl:compile(ModuleMap, Signatures),
+        Autoload = Forceload or proplists:get_value(autoload, CompileOpts, false),
+        spawn_parallel_checker(CheckerInfo, Module, ModuleMap, Signatures, BeamLocation),
+        {Binary, PersistedAttributes, Autoload}
+      end),
+
+    Autoload andalso code:load_binary(Module, BeamLocation, Binary),
+    make_module_available(Module, Binary, Autoload),
+    put_compiler_modules(CompilerModules),
+    eval_callbacks(Line, DataBag, after_compile, [CallbackE, Binary], CallbackE),
+    elixir_env:trace({on_module, Binary, none}, ModuleE),
+    warn_unused_attributes(DataSet, DataBag, PersistedAttributes, E),
+    (element(2, CheckerInfo) == nil) andalso
+      [VerifyMod:VerifyFun(Module) ||
+       {VerifyMod, VerifyFun} <- bag_lookup_element(DataBag, {accumulate, after_verify}, 2)],
+    {module, Module, Binary, Result}
+  catch
+    error:undef:Stacktrace ->
+      case Stacktrace of
+        [{Module, Fun, Args, _Info} | _] = Stack when is_list(Args) ->
+          compile_undef(Module, Fun, length(Args), Stack);
+        [{Module, Fun, Arity, _Info} | _] = Stack ->
+          compile_undef(Module, Fun, Arity, Stack);
+        Stack ->
+          erlang:raise(error, undef, Stack)
+      end
+  after
+    put_compiler_modules(CompilerModules),
+    ets:delete(DataSet),
+    ets:delete(DataBag),
+    elixir_code_server:call({undefmodule, Ref})
+  end.
 
-    {error, _} ->
-      Forms
+compile_error_if_tainted(DataSet, E) ->
+  case ets:member(DataSet, {elixir, taint}) of
+    true -> elixir_errors:compile_error(E);
+    false -> ok
   end.
 
-specs_attributes(Forms, Specs) ->
-  Dict = lists:foldl(fun({{Kind, NameArity, Spec}, Line}, Acc) ->
-                       dict:append({Kind, NameArity}, {Spec, Line}, Acc)
-                     end, dict:new(), Specs),
-  dict:fold(fun({Kind, NameArity}, ExprsLines, Acc) ->
-    {Exprs, Lines} = lists:unzip(ExprsLines),
-    Line = lists:min(Lines),
-    [{attribute, Line, Kind, {NameArity, Exprs}}|Acc]
-  end, Forms, Dict).
-
-translate_macro_spec({{spec, NameArity, Spec}, Line}, Defmacro, Defmacrop) ->
-  case ordsets:is_element(NameArity, Defmacrop) of
-    true  -> [];
+set_exports_md5(DataSet, AllDefinitions, Struct) ->
+  {Funs, Macros} =
+    lists:foldl(fun
+      ({Tuple, def, _Meta, _Clauses}, {Funs, Macros}) -> {[Tuple | Funs], Macros};
+      ({Tuple, defmacro, _Meta, _Clauses}, {Funs, Macros}) -> {Funs, [Tuple | Macros]};
+      ({_Tuple, _Kind, _Meta, _Clauses}, {Funs, Macros}) -> {Funs, Macros}
+    end, {[], []}, AllDefinitions),
+  MD5 = exports_md5(Funs, Macros, Struct),
+  ets:insert(DataSet, {exports_md5, MD5, nil, []}).
+
+validate_compile_opts(Opts, Defs, Unreachable, Line, E) ->
+  lists:flatmap(fun (Opt) -> validate_compile_opt(Opt, Defs, Unreachable, Line, E) end, Opts).
+
+%% TODO: Make this an error on v2.0
+validate_compile_opt({parse_transform, Module} = Opt, _Defs, _Unreachable, Line, E) ->
+  elixir_errors:file_warn([{line, Line}], E, ?MODULE, {parse_transform, Module}),
+  [Opt];
+validate_compile_opt({inline, Inlines}, Defs, Unreachable, Line, E) ->
+  case validate_inlines(Inlines, Defs, Unreachable, []) of
+    {ok, []} ->
+      [];
+    {ok, FilteredInlines} ->
+      [{inline, FilteredInlines}];
+    {error, Reason} ->
+      elixir_errors:module_error([{line, Line}], E, ?MODULE, Reason),
+      []
+  end;
+validate_compile_opt(Opt, Defs, Unreachable, Line, E) when is_list(Opt) ->
+  validate_compile_opts(Opt, Defs, Unreachable, Line, E);
+validate_compile_opt(Opt, _Defs, _Unreachable, _Line, _E) ->
+  [Opt].
+
+validate_inlines([Inline | Inlines], Defs, Unreachable, Acc) ->
+  case lists:keyfind(Inline, 1, Defs) of
     false ->
-      case ordsets:is_element(NameArity, Defmacro) of
-        true ->
-          {Name, Arity} = NameArity,
-          [{{spec, {elixir_utils:macro_name(Name), Arity + 1}, spec_for_macro(Spec)}, Line}];
-        false ->
-          [{{spec, NameArity, Spec}, Line}]
+      {error, {undefined_function, {compile, inline}, Inline}};
+    {_Def, Kind, _Meta, _Clauses} when Kind == defmacro; Kind == defmacrop ->
+      {error, {bad_macro, {compile, inline}, Inline}};
+    _ ->
+      case lists:member(Inline, Unreachable) of
+        true -> validate_inlines(Inlines, Defs, Unreachable, Acc);
+        false -> validate_inlines(Inlines, Defs, Unreachable, [Inline | Acc])
       end
   end;
+validate_inlines([], _Defs, _Unreachable, Acc) -> {ok, Acc}.
 
-translate_macro_spec({{callback, NameArity, Spec}, Line}, _Defmacro, _Defmacrop) ->
-  [{{callback, NameArity, Spec}, Line}].
-
-spec_for_macro({type, Line, 'fun', [{type, _, product, Args}|T]}) ->
-  NewArgs = [{type, Line, term, []}|Args],
-  {type, Line, 'fun', [{type, Line, product, NewArgs}|T]};
-
-spec_for_macro(Else) -> Else.
-
-%% Loads the form into the code server.
-
-compile_opts(Module) ->
-  case ets:lookup(data_table(Module), compile) of
-    [{compile,Opts}] when is_list(Opts) -> Opts;
-    [] -> []
-  end.
-
-load_form(Line, Forms, Opts, #{file := File} = E) ->
-  elixir_compiler:module(Forms, File, Opts, fun(Module, Binary0) ->
-    Docs = elixir_compiler:get_opt(docs),
-    Binary = add_docs_chunk(Binary0, Module, Line, Docs),
-    eval_callbacks(Line, Module, after_compile, [E, Binary], E),
-
-    case get(elixir_compiled) of
-      Current when is_list(Current) ->
-        put(elixir_compiled, [{Module,Binary}|Current]),
-
-        case get(elixir_compiler_pid) of
-          undefined -> [];
-          PID ->
-            Ref = make_ref(),
-            PID ! {module_available, self(), Ref, File, Module, Binary},
-            receive {Ref, ack} -> ok end
-        end;
-      _ ->
-        []
-    end,
+validate_on_load_attribute({on_load, Def}, Defs, Bag, Line, E) ->
+  case lists:keyfind(Def, 1, Defs) of
+    false ->
+      elixir_errors:module_error([{line, Line}], E, ?MODULE, {undefined_function, on_load, Def});
+    {_Def, Kind, _Meta, _Clauses} when Kind == defmacro; Kind == defmacrop ->
+      elixir_errors:module_error([{line, Line}], E, ?MODULE, {bad_macro, on_load, Def});
+    {{Name, Arity}, Kind, _Meta, _Clauses} ->
+      elixir_env:trace({local_function, [{line, Line}], Name, Arity}, E),
+      (Kind == defp) andalso ets:insert(Bag, {used_private, Def})
+  end;
+validate_on_load_attribute(false, _Defs, _Bag, _Line, _E) -> ok.
 
-    Binary
-  end).
+validate_dialyzer_attribute({dialyzer, Dialyzer}, Defs, Line, E) ->
+  [validate_definition({dialyzer, Key}, Fun, Defs, Line, E)
+   || {Key, Funs} <- lists:flatten([Dialyzer]), Fun <- lists:flatten([Funs])];
+validate_dialyzer_attribute(false, _Defs, _Line, _E) ->
+  ok.
 
-add_docs_chunk(Bin, Module, Line, true) ->
-  ChunkData = term_to_binary({elixir_docs_v1, [
-        {docs, get_docs(Module)},
-        {moduledoc, get_moduledoc(Line, Module)}
-    ]}),
-  add_beam_chunk(Bin, "ExDc", ChunkData);
+validate_nifs_attribute({nifs, Funs}, Defs, Line, E) ->
+  [validate_definition(nifs, Fun, Defs, Line, E) || Fun <- lists:flatten([Funs])];
+validate_nifs_attribute(false, _Defs, _Line, _E) ->
+  ok.
 
-add_docs_chunk(Bin, _, _, _) -> Bin.
+validate_definition(Key, Fun, Defs, Line, E) ->
+  case lists:keyfind(Fun, 1, Defs) of
+    false ->
+      elixir_errors:module_error([{line, Line}], E, ?MODULE, {undefined_function, Key, Fun});
+    {Fun, Type, _Meta, _Clauses} when Type == defmacro; Type == defmacrop ->
+      elixir_errors:module_error([{line, Line}], E, ?MODULE, {bad_macro, Key, Fun});
+    _ ->
+      ok
+   end.
 
-get_docs(Module) ->
-  ordsets:from_list(
-    [{Tuple, Line, Kind, Sig, Doc} ||
-     {Tuple, Line, Kind, Sig, Doc} <- ets:tab2list(docs_table(Module)),
-     Kind =/= type, Kind =/= opaque]).
+defines_behaviour(DataBag) ->
+  ets:member(DataBag, {accumulate, callback}) orelse ets:member(DataBag, {accumulate, macrocallback}).
 
-get_moduledoc(Line, Module) ->
-  {Line, 'Elixir.Module':get_attribute(Module, moduledoc)}.
+%% An undef error for a function in the module being compiled might result in an
+%% exception message suggesting the current module is not loaded. This is
+%% misleading so use a custom reason.
+compile_undef(Module, Fun, Arity, Stack) ->
+  case elixir_config:is_bootstrap() of
+    false ->
+      Opts = [{module, Module}, {function, Fun}, {arity, Arity},
+              {reason, 'function not available'}],
+      Exception = 'Elixir.UndefinedFunctionError':exception(Opts),
+      erlang:raise(error, Exception, Stack);
+    true ->
+      erlang:raise(error, undef, Stack)
+  end.
 
+%% Handle reserved modules and duplicates.
 
-check_module_availability(Line, File, Module) ->
-  Reserved = ['Elixir.Any', 'Elixir.BitString', 'Elixir.Function', 'Elixir.PID',
+check_module_availability(Module, Line, E) ->
+  Reserved = ['Elixir.True', 'Elixir.False', 'Elixir.Nil',
+              'Elixir.Any', 'Elixir.BitString', 'Elixir.PID',
               'Elixir.Reference', 'Elixir.Elixir', 'Elixir'],
 
   case lists:member(Module, Reserved) of
-    true  -> elixir_errors:handle_file_error(File, {Line, ?MODULE, {module_reserved, Module}});
+    true  -> elixir_errors:file_error([{line, Line}], E, ?MODULE, {module_reserved, Module});
     false -> ok
   end,
 
-  case elixir_compiler:get_opt(ignore_module_conflict) of
+  case elixir_config:get(ignore_module_conflict) of
     false ->
       case code:ensure_loaded(Module) of
         {module, _} ->
-          elixir_errors:handle_file_warning(File, {Line, ?MODULE, {module_defined, Module}});
+          elixir_errors:file_warn([{line, Line}], E, ?MODULE, {module_defined, Module});
         {error, _}  ->
           ok
       end;
@@ -367,132 +382,280 @@ check_module_availability(Line, File, Module) ->
       ok
   end.
 
-warn_invalid_clauses(_Line, _File, 'Elixir.Kernel.SpecialForms', _All) -> ok;
-warn_invalid_clauses(_Line, File, Module, All) ->
-  ets:foldl(fun
-    ({_, _, Kind, _, _}, _) when Kind == type; Kind == opaque ->
-      ok;
-    ({Tuple, Line, _, _, _}, _) ->
-      case lists:member(Tuple, All) of
-        false ->
-          elixir_errors:handle_file_warning(File, {Line, ?MODULE, {invalid_clause, Tuple}});
-        true ->
-          ok
-      end
-  end, ok, docs_table(Module)).
-
-warn_unused_docs(Line, File, Module) ->
-  lists:foreach(fun(Attribute) ->
-    case ets:member(data_table(Module), Attribute) of
-      true ->
-        elixir_errors:handle_file_warning(File, {Line, ?MODULE, {unused_doc, Attribute}});
-      _ ->
-        ok
-    end
-  end, [typedoc]).
-
-% EXTRA FUNCTIONS
-
-add_info_function(Line, File, Module, Export, Def, Defmacro) ->
-  Pair = {'__info__', 1},
-  case lists:member(Pair, Export) of
-    true  ->
-      elixir_errors:form_error(Line, File, ?MODULE, {internal_function_overridden, Pair});
-    false ->
-      {
-        {attribute, Line, spec, {{'__info__', 1},
-          [{type, Line, 'fun', [{type, Line, product, [ {type, Line, atom, []}]}, {type, Line, term, []} ]}]
-        }},
-        {function, 0, '__info__', 1, [
-          functions_clause(Def),
-          macros_clause(Defmacro),
-          module_clause(Module),
-          else_clause()
-        ]}
-      }
-  end.
-
-functions_clause(Def) ->
-  {clause, 0, [{atom, 0, functions}], [], [elixir_utils:elixir_to_erl(Def)]}.
-
-macros_clause(Defmacro) ->
-  {clause, 0, [{atom, 0, macros}], [], [elixir_utils:elixir_to_erl(Defmacro)]}.
-
-module_clause(Module) ->
-  {clause, 0, [{atom, 0, module}], [], [{atom, 0, Module}]}.
-
-else_clause() ->
-  Info = {call, 0, {atom, 0, module_info}, [{var, 0, atom}]},
-  {clause, 0, [{var, 0, atom}], [], [Info]}.
+%% Hook that builds both attribute and functions and set up common hooks.
 
-% HELPERS
+build(Module, Line, File, E) ->
+  %% In the set table we store:
+  %%
+  %% * {Attribute, Value, AccumulateOrUnsetOrReadOrUnreadline, TraceLineOrNil}
+  %% * {{elixir, ...}, ...}
+  %% * {{cache, ...}, ...}
+  %% * {{function, Tuple}, ...}, {{macro, Tuple}, ...}
+  %% * {{type, Tuple}, ...}, {{opaque, Tuple}, ...}
+  %% * {{callback, Tuple}, ...}, {{macrocallback, Tuple}, ...}
+  %% * {{def, Tuple}, ...} (from elixir_def)
+  %% * {{overridable, Tuple}, ...} (from elixir_overridable)
+  %%
+  DataSet = ets:new(Module, [set, public]),
+
+  %% In the bag table we store:
+  %%
+  %% * {{accumulate, Attribute}, ...} (includes typespecs)
+  %% * {warn_attributes, ...}
+  %% * {impls, ...}
+  %% * {deprecated, ...}
+  %% * {persisted_attributes, ...}
+  %% * {defs, ...} (from elixir_def)
+  %% * {overridables, ...} (from elixir_overridable)
+  %% * {{default, Name}, ...} (from elixir_def)
+  %% * {{clauses, Tuple}, ...} (from elixir_def)
+  %%
+  DataBag = ets:new(Module, [duplicate_bag, public]),
+
+  ets:insert(DataSet, [
+    % {Key, Value, ReadOrUnreadLine, TraceLine}
+    {moduledoc, nil, nil, []},
+
+    % {Key, Value, accumulate, TraceLine}
+    {after_compile, [], accumulate, []},
+    {after_verify, [], accumulate, []},
+    {before_compile, [], accumulate, []},
+    {behaviour, [], accumulate, []},
+    {compile, [], accumulate, []},
+    {derive, [], accumulate, []},
+    {dialyzer, [], accumulate, []},
+    {external_resource, [], accumulate, []},
+    {nifs, [], accumulate, []},
+    {on_definition, [], accumulate, []},
+    {opaque, [], accumulate, []},
+    {type, [], accumulate, []},
+    {typep, [], accumulate, []},
+    {spec, [], accumulate, []},
+    {callback, [], accumulate, []},
+    {macrocallback, [], accumulate, []},
+    {optional_callbacks, [], accumulate, []},
+
+    % Others
+    {?cache_key, 0},
+    {?counter_attr, 0}
+  ]),
+
+  Persisted = [behaviour, dialyzer, external_resource, nifs, on_load, vsn],
+  ets:insert(DataBag, [{persisted_attributes, Attr} || Attr <- Persisted]),
+
+  OnDefinition =
+    case elixir_config:is_bootstrap() of
+      false -> {'Elixir.Module', compile_definition_attributes};
+      _ -> {elixir_module, delete_definition_attributes}
+    end,
+  ets:insert(DataBag, {{accumulate, on_definition}, OnDefinition}),
+
+  %% Setup definition related modules
+  Tables = {DataSet, DataBag},
+  elixir_def:setup(Tables),
+  Tuple = {Module, Tables, Line, File, all},
+
+  Ref =
+    case elixir_code_server:call({defmodule, Module, self(), Tuple}) of
+      {ok, ModuleRef} ->
+        ModuleRef;
+      {error, {Module, _, OldLine, OldFile, _}} ->
+        ets:delete(DataSet),
+        ets:delete(DataBag),
+        Error = {module_in_definition, Module, OldFile, OldLine},
+        elixir_errors:file_error([{line, Line}], E, ?MODULE, Error)
+    end,
 
-%% Adds custom chunk to a .beam binary
-add_beam_chunk(Bin, Id, ChunkData)
-        when is_binary(Bin), is_list(Id), is_binary(ChunkData) ->
-  {ok, _, Chunks0} = beam_lib:all_chunks(Bin),
-  NewChunk = {Id, ChunkData},
-  Chunks = [NewChunk|Chunks0],
-  {ok, NewBin} = beam_lib:build_module(Chunks),
-  NewBin.
+  {Tables, Ref}.
+
+%% Handles module and callback evaluations.
+
+eval_form(Line, Module, DataBag, Block, Vars, Prune, E) ->
+  %% Given Elixir modules can get very long to compile due to metaprogramming,
+  %% we disable expansions that take linear time to code size.
+  {Value, ExS, EE} = elixir_compiler:compile(Block, Vars, [no_bool_opt, no_ssa_opt], E),
+  elixir_overridable:store_not_overridden(Module),
+  EV = (elixir_env:reset_vars(EE))#{line := Line},
+  EC = eval_callbacks(Line, DataBag, before_compile, [EV], EV),
+  elixir_overridable:store_not_overridden(Module),
+  {Value, maybe_prune_versioned_vars(Prune, Vars, ExS, E), EC}.
+
+maybe_prune_versioned_vars(false, _Vars, _Exs, E) ->
+  E;
+maybe_prune_versioned_vars(true, Vars, ExS, E) ->
+  PruneBefore = length(Vars),
+  #elixir_ex{vars={ExVars, _}, unused={Unused, _}} = ExS,
+
+  VersionedVars =
+    maps:filter(fun
+      (Pair, Version) when Version < PruneBefore, not is_map_key({Pair, Version}, Unused) -> false;
+      (_, _) -> true
+    end, ExVars),
+
+  E#{versioned_vars := VersionedVars}.
+
+eval_callbacks(Line, DataBag, Name, Args, E) ->
+  Callbacks = bag_lookup_element(DataBag, {accumulate, Name}, 2),
+  lists:foldl(fun({M, F}, Acc) ->
+    expand_callback(Line, M, F, Args, Acc, fun(AM, AF, AA) -> apply(AM, AF, AA) end)
+  end, E, Callbacks).
 
-%% Expands a callback given by M:F(Args). In case
-%% the callback can't be expanded, invokes the given
-%% fun passing a possibly expanded AM:AF(Args).
-expand_callback(Line, M, F, Args, E, Fun) ->
-  Meta = [{line,Line},{require,false}],
+expand_callback(Line, M, F, Args, Acc, Fun) ->
+  E = elixir_env:reset_vars(Acc),
+  S = elixir_env:env_to_ex(E),
+  Meta = [{line, Line}, {required, true}],
 
-  {EE, ET} = elixir_dispatch:dispatch_require(Meta, M, F, Args, E, fun(AM, AF, AA) ->
-    Fun(AM, AF, AA),
-    {ok, E}
-  end),
+  {EE, _S, ET} =
+    elixir_dispatch:dispatch_require(Meta, M, F, Args, S, E, fun(AM, AF) ->
+      Fun(AM, AF, Args),
+      {ok, S, E}
+    end),
 
   if
     is_atom(EE) ->
       ET;
     true ->
       try
-        {_Value, _Binding, EF, _S} = elixir:eval_forms(EE, [], ET),
+        {_Value, _Binding, EF} = elixir:eval_forms(EE, [], ET),
         EF
       catch
-        Kind:Reason ->
+        Kind:Reason:Stacktrace ->
           Info = {M, F, length(Args), location(Line, E)},
-          erlang:raise(Kind, Reason, prune_stacktrace(Info, erlang:get_stacktrace()))
+          erlang:raise(Kind, Reason, prune_stacktrace(Info, Stacktrace))
       end
   end.
 
-location(Line, E) ->
-  [{file, elixir_utils:characters_to_list(?m(E, file))}, {line, Line}].
+%% Add attributes handling to the form
+
+attributes(DataSet, DataBag, PersistedAttributes) ->
+  [{Key, Value} || Key <- PersistedAttributes, Value <- lookup_attribute(DataSet, DataBag, Key)].
+
+lookup_attribute(DataSet, DataBag, Key) when is_atom(Key) ->
+  case ets:lookup(DataSet, Key) of
+    [{_, _, accumulate, _}] -> bag_lookup_element(DataBag, {accumulate, Key}, 2);
+    [{_, _, unset, _}] -> [];
+    [{_, Value, _, _}] -> [Value];
+    [] -> []
+  end.
+
+warn_unused_attributes(DataSet, DataBag, PersistedAttrs, E) ->
+  StoredAttrs = bag_lookup_element(DataBag, warn_attributes, 2),
+  %% This is the same list as in Module.put_attribute
+  %% without moduledoc which are never warned on.
+  Attrs = [doc, typedoc, impl, deprecated | StoredAttrs -- PersistedAttrs],
+  Query = [{{Attr, '_', '$1', '_'}, [{is_integer, '$1'}], [[Attr, '$1']]} || Attr <- Attrs],
+  [elixir_errors:file_warn([{line, Line}], E, ?MODULE, {unused_attribute, Key})
+   || [Key, Line] <- ets:select(DataSet, Query)].
+
+get_struct(Set) ->
+  case ets:lookup(Set, {elixir, struct}) of
+    [] -> nil;
+    [{_, Fields}] -> Fields
+  end.
+
+get_deprecated(Bag) ->
+  lists:usort(bag_lookup_element(Bag, deprecated, 2)).
+
+bag_lookup_element(Table, Name, Pos) ->
+  try
+    ets:lookup_element(Table, Name, Pos)
+  catch
+    error:badarg -> []
+  end.
+
+beam_location(ModuleAsCharlist) ->
+  case get(elixir_compiler_dest) of
+    {Dest, Forceload} when is_binary(Dest) ->
+      {filename:join(elixir_utils:characters_to_list(Dest), ModuleAsCharlist ++ ".beam"),
+       Forceload};
+    _ ->
+      {"", true}
+  end.
+
+%% Integration with elixir_compiler that makes the module available
+
+checker_info() ->
+  case get(elixir_checker_info) of
+    undefined -> {self(), nil};
+    _ -> 'Elixir.Module.ParallelChecker':get()
+  end.
+
+spawn_parallel_checker({_, nil}, _Module, _ModuleMap, _Signatures, _BeamLocation) ->
+  ok;
+spawn_parallel_checker(CheckerInfo, Module, ModuleMap, Signatures, BeamLocation) ->
+  Log =
+    case erlang:get(elixir_code_diagnostics) of
+      {_, false} -> false;
+      _ -> true
+    end,
+  'Elixir.Module.ParallelChecker':spawn(CheckerInfo, Module, ModuleMap, Signatures, BeamLocation, Log).
+
+make_module_available(Module, Binary, Loaded) ->
+  case get(elixir_module_binaries) of
+    Current when is_list(Current) ->
+      put(elixir_module_binaries, [{Module, Binary} | Current]);
+    _ ->
+      ok
+  end,
+
+  case get(elixir_compiler_info) of
+    undefined ->
+      ok;
+    {PID, _} ->
+      Ref = make_ref(),
+      PID ! {module_available, self(), Ref, get(elixir_compiler_file), Module, Binary, Loaded},
+      receive {Ref, ack} -> ok end
+  end.
+
+%% Error handling and helpers.
 
 %% We've reached the elixir_module or eval internals, skip it with the rest
-prune_stacktrace(Info, [{elixir, eval_forms, _, _}|_]) ->
+prune_stacktrace(Info, [{elixir, eval_forms, _, _} | _]) ->
   [Info];
-prune_stacktrace(Info, [{elixir_module, _, _, _}|_]) ->
+prune_stacktrace(Info, [{elixir_module, _, _, _} | _]) ->
   [Info];
-prune_stacktrace(Info, [H|T]) ->
-  [H|prune_stacktrace(Info, T)];
+prune_stacktrace(Info, [H | T]) ->
+  [H | prune_stacktrace(Info, T)];
 prune_stacktrace(Info, []) ->
   [Info].
 
-% ERROR HANDLING
-
-format_error({invalid_clause, {Name, Arity}}) ->
-  io_lib:format("empty clause provided for nonexistent function or macro ~ts/~B", [Name, Arity]);
-format_error({invalid_external_resource, Value}) ->
-  io_lib:format("expected a string value for @external_resource, got: ~p",
-    ['Elixir.Kernel':inspect(Value)]);
-format_error({unused_doc, typedoc}) ->
-  "@typedoc provided but no type follows it";
-format_error({unused_doc, doc}) ->
-  "@doc provided but no definition follows it";
-format_error({internal_function_overridden, {Name, Arity}}) ->
-  io_lib:format("function ~ts/~B is internal and should not be overridden", [Name, Arity]);
-format_error({invalid_module, Module}) ->
-  io_lib:format("invalid module name: ~ts", ['Elixir.Kernel':inspect(Module)]);
+location(Line, E) ->
+  [{file, elixir_utils:characters_to_list(?key(E, file))}, {line, Line}].
+
+format_error({unused_attribute, typedoc}) ->
+  "module attribute @typedoc was set but no type follows it";
+format_error({unused_attribute, doc}) ->
+  "module attribute @doc was set but no definition follows it";
+format_error({unused_attribute, impl}) ->
+  "module attribute @impl was set but no definition follows it";
+format_error({unused_attribute, deprecated}) ->
+  "module attribute @deprecated was set but no definition follows it";
+format_error({unused_attribute, Attr}) ->
+  io_lib:format("module attribute @~ts was set but never used", [Attr]);
 format_error({module_defined, Module}) ->
-  io_lib:format("redefining module ~ts", [elixir_aliases:inspect(Module)]);
+  Extra =
+    case code:which(Module) of
+      "" ->
+        " (current version defined in memory)";
+      Path when is_list(Path) ->
+        io_lib:format(" (current version loaded from ~ts)", [elixir_utils:relative_to_cwd(Path)]);
+      _ ->
+        ""
+    end,
+  io_lib:format("redefining module ~ts~ts", [elixir_aliases:inspect(Module), Extra]);
 format_error({module_reserved, Module}) ->
   io_lib:format("module ~ts is reserved and cannot be defined", [elixir_aliases:inspect(Module)]);
 format_error({module_in_definition, Module, File, Line}) ->
   io_lib:format("cannot define module ~ts because it is currently being defined in ~ts:~B",
-    [elixir_aliases:inspect(Module), 'Elixir.Path':relative_to_cwd(File), Line]).
+    [elixir_aliases:inspect(Module), elixir_utils:relative_to_cwd(File), Line]);
+format_error({undefined_function, {Attr, Key}, {Name, Arity}}) ->
+  io_lib:format("undefined function ~ts/~B given to @~ts :~ts", [Name, Arity, Attr, Key]);
+format_error({undefined_function, Attr, {Name, Arity}}) ->
+  io_lib:format("undefined function ~ts/~B given to @~ts", [Name, Arity, Attr]);
+format_error({bad_macro, {Attr, Key}, {Name, Arity}}) ->
+  io_lib:format("macro ~ts/~B given to @~ts :~ts (only functions are supported)", [Name, Arity, Attr, Key]);
+format_error({bad_macro, Attr, {Name, Arity}}) ->
+  io_lib:format("macro ~ts/~B given to @~ts (only functions are supported)", [Name, Arity, Attr]);
+format_error({parse_transform, Module}) ->
+  io_lib:format("@compile {:parse_transform, ~ts} is deprecated. Elixir will no longer support "
+                "Erlang-based transforms in future versions", [elixir_aliases:inspect(Module)]).
diff --git a/lib/elixir/src/elixir_overridable.erl b/lib/elixir/src/elixir_overridable.erl
new file mode 100644
index 00000000000..bac527a5bf3
--- /dev/null
+++ b/lib/elixir/src/elixir_overridable.erl
@@ -0,0 +1,137 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+% Holds the logic responsible for defining overridable functions and handling super.
+-module(elixir_overridable).
+-export([overridables_for/1, overridable_for/2,
+         record_overridable/3, super/4,
+         store_not_overridden/1, format_error/1]).
+-include("elixir.hrl").
+-define(overridden_pos, 4).
+
+overridables_for(Module) ->
+  {_, Bag} = elixir_module:data_tables(Module),
+  try
+    ets:lookup_element(Bag, overridables, 2)
+  catch
+    _:_ -> []
+  end.
+
+overridable_for(Module, Tuple) ->
+  {Set, _} = elixir_module:data_tables(Module),
+
+  case ets:lookup(Set, {overridable, Tuple}) of
+    [Overridable] -> Overridable;
+    [] -> not_overridable
+  end.
+
+record_overridable(Module, Tuple, Def) ->
+  {Set, Bag} = elixir_module:data_tables(Module),
+
+  case ets:insert_new(Set, {{overridable, Tuple}, 1, Def, false}) of
+    true ->
+      ets:insert(Bag, {overridables, Tuple});
+    false ->
+      [{_, Count, PreviousDef, _}] = ets:lookup(Set, {overridable, Tuple}),
+      {{_, Kind, Meta, File, _, _}, _} = Def,
+      {{_, PreviousKind, _, _, _, _}, _} = PreviousDef,
+
+      case is_valid_kind(Kind, PreviousKind) of
+        true ->
+          ets:insert(Set, {{overridable, Tuple}, Count + 1, Def, false});
+        false ->
+          elixir_errors:file_error(Meta, File, ?MODULE, {bad_kind, Module, Tuple, Kind})
+      end
+  end,
+
+  ok.
+
+super(Meta, Module, Tuple, E) ->
+  {Set, _} = elixir_module:data_tables(Module),
+
+  case ets:lookup(Set, {overridable, Tuple}) of
+    [Overridable] ->
+      store(Set, Module, Tuple, Overridable, true);
+    [] ->
+      elixir_errors:file_error(Meta, E, ?MODULE, {no_super, Module, Tuple})
+  end.
+
+store_not_overridden(Module) ->
+  {Set, Bag} = elixir_module:data_tables(Module),
+
+  lists:foreach(fun({_, Tuple}) ->
+    [Overridable] = ets:lookup(Set, {overridable, Tuple}),
+
+    case ets:lookup(Set, {def, Tuple}) of
+      [] ->
+        store(Set, Module, Tuple, Overridable, false);
+      [{_, Kind, Meta, File, _, _}] ->
+        {{_, OverridableKind, _, _, _, _}, _} = element(3, Overridable),
+
+        case is_valid_kind(Kind, OverridableKind) of
+          true -> ok;
+          false -> elixir_errors:file_error(Meta, File, ?MODULE, {bad_kind, Module, Tuple, Kind})
+        end
+    end
+  end, ets:lookup(Bag, overridables)).
+
+%% Private
+
+store(Set, Module, Tuple, {_, Count, Def, Overridden}, Hidden) ->
+  {{{def, {Name, Arity}}, Kind, BaseMeta, File, _Check,
+   {Defaults, _HasBody, _LastDefaults}}, Clauses} = Def,
+  Meta = [{from_super, Hidden} | BaseMeta],
+
+  {FinalKind, FinalName, FinalArity, FinalClauses} =
+    case Hidden of
+      false ->
+        {Kind, Name, Arity, Clauses};
+      true when Kind == defmacro; Kind == defmacrop ->
+        {defmacrop, name(Name, Count), Arity, Clauses};
+      true ->
+        {defp, name(Name, Count), Arity, Clauses}
+    end,
+
+  case Overridden of
+    false ->
+      ets:update_element(Set, {overridable, Tuple}, {?overridden_pos, true}),
+      elixir_def:store_definition(none, FinalKind, Meta, FinalName, FinalArity,
+                                  File, Module, Defaults, FinalClauses);
+    true ->
+      ok
+  end,
+
+  {FinalKind, FinalName, Meta}.
+
+name(Name, Count) when is_integer(Count) ->
+  list_to_atom(atom_to_list(Name) ++ " (overridable " ++ integer_to_list(Count) ++ ")").
+
+is_valid_kind(NewKind, PreviousKind) ->
+  is_macro(NewKind) =:= is_macro(PreviousKind).
+
+is_macro(defmacro) -> true;
+is_macro(defmacrop) -> true;
+is_macro(_) -> false.
+
+%% Error handling
+format_error({bad_kind, Module, {Name, Arity}, Kind}) ->
+  case is_macro(Kind) of
+    true ->
+      io_lib:format("cannot override function (def, defp) ~ts/~B in module ~ts as a macro (defmacro, defmacrop)",
+        [Name, Arity, elixir_aliases:inspect(Module)]);
+    false ->
+      io_lib:format("cannot override macro (defmacro, defmacrop) ~ts/~B in module ~ts as a function (def, defp)",
+        [Name, Arity, elixir_aliases:inspect(Module)])
+  end;
+
+format_error({no_super, Module, {Name, Arity}}) ->
+  Bins   = [format_fa(Tuple) || Tuple <- overridables_for(Module)],
+  Joined = 'Elixir.Enum':join(Bins, <<", ">>),
+  io_lib:format("no super defined for ~ts/~B in module ~ts. Overridable functions available are: ~ts",
+    [Name, Arity, elixir_aliases:inspect(Module), Joined]).
+
+format_fa({Name, Arity}) ->
+  A = 'Elixir.Macro':inspect_atom(remote_call, Name),
+  B = integer_to_binary(Arity),
+  <<A/binary, $/, B/binary>>.
diff --git a/lib/elixir/src/elixir_parser.yrl b/lib/elixir/src/elixir_parser.yrl
index e8d4c9f45aa..adfedc5907d 100644
--- a/lib/elixir/src/elixir_parser.yrl
+++ b/lib/elixir/src/elixir_parser.yrl
@@ -1,69 +1,95 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+%% REUSE-IgnoreStart
+Header "%% SPDX-License-Identifier: Apache-2.0"
+"%% SPDX-FileCopyrightText: 2021 The Elixir Team"
+"%% SPDX-FileCopyrightText: 2012 Plataformatec".
+%% REUSE-IgnoreEnd
+
 Nonterminals
   grammar expr_list
-  expr container_expr block_expr no_parens_expr no_parens_one_expr access_expr
-  bracket_expr bracket_at_expr bracket_arg matched_expr unmatched_expr max_expr
-  op_expr matched_op_expr no_parens_op_expr
+  expr container_expr block_expr access_expr
+  no_parens_expr no_parens_zero_expr no_parens_one_expr no_parens_one_ambig_expr
+  bracket_expr bracket_at_expr bracket_arg matched_expr unmatched_expr sub_matched_expr
+  unmatched_op_expr matched_op_expr no_parens_op_expr no_parens_many_expr
   comp_op_eol at_op_eol unary_op_eol and_op_eol or_op_eol capture_op_eol
-  add_op_eol mult_op_eol hat_op_eol two_op_eol pipe_op_eol stab_op_eol
-  arrow_op_eol match_op_eol when_op_eol in_op_eol in_match_op_eol
-  type_op_eol rel_op_eol
-  open_paren close_paren empty_paren
+  dual_op_eol mult_op_eol power_op_eol concat_op_eol xor_op_eol pipe_op_eol
+  stab_op_eol arrow_op_eol match_op_eol when_op_eol in_op_eol in_match_op_eol
+  type_op_eol rel_op_eol range_op_eol ternary_op_eol
+  open_paren close_paren empty_paren eoe
   list list_args open_bracket close_bracket
   tuple open_curly close_curly
-  bit_string open_bit close_bit
-  map map_op map_close map_args map_expr struct_op
-  assoc_op_eol assoc_expr assoc_base assoc_update assoc_update_kw assoc
-  container_args_base container_args call_args_parens_base call_args_parens parens_call
-  call_args_no_parens_one call_args_no_parens_expr call_args_no_parens_comma_expr
-  call_args_no_parens_all call_args_no_parens_many call_args_no_parens_many_strict
-  stab stab_eol stab_expr stab_maybe_expr stab_parens_many
-  kw_eol kw_base kw call_args_no_parens_kw_expr call_args_no_parens_kw
-  dot_op dot_alias dot_identifier dot_op_identifier dot_do_identifier
-  dot_paren_identifier dot_bracket_identifier
-  do_block fn_eol do_eol end_eol block_eol block_item block_list
+  bitstring open_bit close_bit
+  map map_op map_base_expr map_close map_args
+  assoc_op_eol assoc_expr assoc_base assoc assoc_update assoc_update_kw
+  container_args_base container_args
+  call_args_parens_expr call_args_parens_base call_args_parens parens_call
+  call_args_no_parens_one call_args_no_parens_ambig call_args_no_parens_expr
+  call_args_no_parens_comma_expr call_args_no_parens_all call_args_no_parens_many
+  call_args_no_parens_many_strict
+  stab stab_eoe stab_expr stab_op_eol_and_expr stab_parens_many
+  kw_eol kw_base kw_data kw_call call_args_no_parens_kw_expr call_args_no_parens_kw
+  dot_op dot_alias dot_bracket_identifier dot_call_identifier
+  dot_identifier dot_op_identifier dot_do_identifier dot_paren_identifier
+  do_block fn_eoe do_eoe block_eoe block_item block_list
   .
 
 Terminals
   identifier kw_identifier kw_identifier_safe kw_identifier_unsafe bracket_identifier
-  paren_identifier do_identifier block_identifier
-  fn 'end' aliases
-  number signed_number atom atom_safe atom_unsafe bin_string list_string sigil
-  dot_call_op op_identifier
-  comp_op at_op unary_op and_op or_op arrow_op match_op in_op in_match_op
-  type_op dual_op add_op mult_op hat_op two_op pipe_op stab_op when_op assoc_op
-  capture_op rel_op
-  'true' 'false' 'nil' 'do' eol ',' '.'
+  paren_identifier do_identifier block_identifier op_identifier
+  fn 'end' alias
+  atom atom_quoted atom_safe atom_unsafe bin_string list_string sigil
+  bin_heredoc list_heredoc
+  comp_op at_op unary_op and_op or_op arrow_op match_op in_op in_match_op ellipsis_op
+  type_op dual_op mult_op power_op concat_op range_op xor_op pipe_op stab_op when_op
+  capture_int capture_op assoc_op rel_op ternary_op dot_call_op
+  'true' 'false' 'nil' 'do' eol ';' ',' '.'
   '(' ')' '[' ']' '{' '}' '<<' '>>' '%{}' '%'
+  int flt char
   .
 
 Rootsymbol grammar.
 
-%% There are two shift/reduce conflicts coming from call_args_parens.
-Expect 2.
+%% Two shift/reduce conflicts coming from call_args_parens and
+%% one coming from empty_paren on stab.
+Expect 3.
+
+%% Changes in ops and precedence should be reflected on:
+%%
+%%   1. lib/elixir/lib/code/identifier.ex
+%%   2. lib/elixir/pages/operators.md
+%%   3. lib/iex/lib/iex/evaluator.ex
+%%
+%% Note though the operator => in practice has lower precedence
+%% than all others, its entry in the table is only to support the
+%% %{user | foo => bar} syntax.
 
-%% Changes in ops and precedence should be reflected on lib/elixir/lib/macro.ex
-%% Note though the operator => in practice has lower precedence than all others,
-%% its entry in the table is only to support the %{user | foo => bar} syntax.
 Left       5 do.
 Right     10 stab_op_eol.     %% ->
 Left      20 ','.
-Nonassoc  30 capture_op_eol.  %% &
 Left      40 in_match_op_eol. %% <-, \\ (allowed in matches along =)
 Right     50 when_op_eol.     %% when
 Right     60 type_op_eol.     %% ::
 Right     70 pipe_op_eol.     %% |
 Right     80 assoc_op_eol.    %% =>
-Right     90 match_op_eol.    %% =
-Left     130 or_op_eol.       %% ||, |||, or, xor
-Left     140 and_op_eol.      %% &&, &&&, and
-Left     150 comp_op_eol.     %% ==, !=, =~, ===, !==
-Left     160 rel_op_eol.      %% <, >, <=, >=
-Left     170 arrow_op_eol.    %% < (op), (op) > (e.g |>, <<<, >>>)
-Left     180 in_op_eol.       %% in
-Right    200 two_op_eol.      %% ++, --, .., <>
-Left     210 add_op_eol.      %% + (op), - (op)
-Left     220 mult_op_eol.     %% * (op), / (op)
-Left     250 hat_op_eol.      %% ^ (op) (e.g ^^^)
+Nonassoc  90 capture_op_eol.  %% &
+Nonassoc  90 ellipsis_op.     %% ...
+Right    100 match_op_eol.    %% =
+Left     120 or_op_eol.       %% ||, |||, or
+Left     130 and_op_eol.      %% &&, &&&, and
+Left     140 comp_op_eol.     %% ==, !=, =~, ===, !==
+Left     150 rel_op_eol.      %% <, >, <=, >=
+Left     160 arrow_op_eol.    %% <<<, >>>, |>, <<~, ~>>, <~, ~>, <~>, <|>
+Left     170 in_op_eol.       %% in, not in
+Left     180 xor_op_eol.      %% ^^^
+Right    190 ternary_op_eol.  %% //
+Right    200 concat_op_eol.   %% ++, --, +++, ---, <>
+Right    200 range_op_eol.    %% ..
+Left     210 dual_op_eol.     %% +, -
+Left     220 mult_op_eol.     %% *, /
+Left     230 power_op_eol.    %% **
 Nonassoc 300 unary_op_eol.    %% +, -, !, ^, not, ~~~
 Left     310 dot_call_op.
 Left     310 dot_op.          %% .
@@ -72,18 +98,17 @@ Nonassoc 330 dot_identifier.
 
 %%% MAIN FLOW OF EXPRESSIONS
 
-grammar -> eol : nil.
-grammar -> expr_list : to_block('$1').
-grammar -> eol expr_list : to_block('$2').
-grammar -> expr_list eol : to_block('$1').
-grammar -> eol expr_list eol : to_block('$2').
-grammar -> '$empty' : nil.
+grammar -> eoe : {'__block__', meta_from_location({1, 1, nil}), []}.
+grammar -> expr_list : build_block(reverse('$1')).
+grammar -> eoe expr_list : build_block(reverse('$2')).
+grammar -> expr_list eoe : build_block(reverse(annotate_eoe('$2', '$1'))).
+grammar -> eoe expr_list eoe : build_block(reverse(annotate_eoe('$3', '$2'))).
+grammar -> '$empty' : {'__block__', meta_from_location({1, 1, nil}), []}.
 
 % Note expressions are on reverse order
 expr_list -> expr : ['$1'].
-expr_list -> expr_list eol expr : ['$3'|'$1'].
+expr_list -> expr_list eoe expr : ['$3' | annotate_eoe('$2', '$1')].
 
-expr -> empty_paren : nil.
 expr -> matched_expr : '$1'.
 expr -> no_parens_expr : '$1'.
 expr -> unmatched_expr : '$1'.
@@ -92,6 +117,23 @@ expr -> unmatched_expr : '$1'.
 %% without parentheses and with do blocks. They are represented
 %% in the AST as matched, no_parens and unmatched.
 %%
+%% Calls without parentheses are further divided according to how
+%% problematic they are:
+%%
+%% (a) no_parens_one: a call with one unproblematic argument
+%% (for example, `f a` or `f g a` and similar) (includes unary operators)
+%%
+%% (b) no_parens_many: a call with several arguments (for example, `f a, b`)
+%%
+%% (c) no_parens_one_ambig: a call with one argument which is
+%% itself a no_parens_many or no_parens_one_ambig (for example, `f g a, b`,
+%% `f g h a, b` and similar)
+%%
+%% Note, in particular, that no_parens_one_ambig expressions are
+%% ambiguous and are interpreted such that the outer function has
+%% arity 1. For instance, `f g a, b` is interpreted as `f(g(a, b))` rather
+%% than `f(g(a), b)`. Hence the name, no_parens_one_ambig.
+%%
 %% The distinction is required because we can't, for example, have
 %% a function call with a do block as argument inside another do
 %% block call, unless there are parentheses:
@@ -104,270 +146,328 @@ expr -> unmatched_expr : '$1'.
 %%
 %%   foo a, bar b, c  #=> invalid
 %%   foo(a, bar b, c) #=> invalid
-%%   foo a, bar b     #=> valid
+%%   foo bar a, b     #=> valid
 %%   foo a, bar(b, c) #=> valid
 %%
 %% So the different grammar rules need to take into account
 %% if calls without parentheses are do blocks in particular
 %% segments and act accordingly.
-matched_expr -> matched_expr matched_op_expr : build_op(element(1, '$2'), '$1', element(2, '$2')).
-matched_expr -> matched_expr no_parens_op_expr : build_op(element(1, '$2'), '$1', element(2, '$2')).
+matched_expr -> matched_expr matched_op_expr : build_op('$1', '$2').
 matched_expr -> unary_op_eol matched_expr : build_unary_op('$1', '$2').
-matched_expr -> unary_op_eol no_parens_expr : build_unary_op('$1', '$2').
 matched_expr -> at_op_eol matched_expr : build_unary_op('$1', '$2').
-matched_expr -> at_op_eol no_parens_expr : build_unary_op('$1', '$2').
 matched_expr -> capture_op_eol matched_expr : build_unary_op('$1', '$2').
-matched_expr -> capture_op_eol no_parens_expr : build_unary_op('$1', '$2').
+matched_expr -> ellipsis_op matched_expr : build_unary_op('$1', '$2').
 matched_expr -> no_parens_one_expr : '$1'.
-matched_expr -> access_expr : '$1'.
-
-no_parens_expr -> dot_op_identifier call_args_no_parens_many_strict : build_identifier('$1', '$2').
-no_parens_expr -> dot_identifier call_args_no_parens_many_strict : build_identifier('$1', '$2').
+matched_expr -> sub_matched_expr : '$1'.
 
-unmatched_expr -> empty_paren op_expr : build_op(element(1, '$2'), nil, element(2, '$2')).
-unmatched_expr -> matched_expr op_expr : build_op(element(1, '$2'), '$1', element(2, '$2')).
-unmatched_expr -> unmatched_expr op_expr : build_op(element(1, '$2'), '$1', element(2, '$2')).
+unmatched_expr -> matched_expr unmatched_op_expr : build_op('$1', '$2').
+unmatched_expr -> unmatched_expr matched_op_expr : build_op('$1', '$2').
+unmatched_expr -> unmatched_expr unmatched_op_expr : build_op('$1', '$2').
+unmatched_expr -> unmatched_expr no_parens_op_expr : warn_no_parens_after_do_op('$2'), build_op('$1', '$2').
 unmatched_expr -> unary_op_eol expr : build_unary_op('$1', '$2').
 unmatched_expr -> at_op_eol expr : build_unary_op('$1', '$2').
 unmatched_expr -> capture_op_eol expr : build_unary_op('$1', '$2').
+unmatched_expr -> ellipsis_op expr : build_unary_op('$1', '$2').
 unmatched_expr -> block_expr : '$1'.
 
-block_expr -> parens_call call_args_parens do_block : build_identifier('$1', '$2' ++ '$3').
-block_expr -> parens_call call_args_parens call_args_parens do_block : build_nested_parens('$1', '$2', '$3' ++ '$4').
-block_expr -> dot_do_identifier do_block : build_identifier('$1', '$2').
-block_expr -> dot_identifier call_args_no_parens_all do_block : build_identifier('$1', '$2' ++ '$3').
-
-op_expr -> match_op_eol expr : {'$1', '$2'}.
-op_expr -> add_op_eol expr : {'$1', '$2'}.
-op_expr -> mult_op_eol expr : {'$1', '$2'}.
-op_expr -> hat_op_eol expr : {'$1', '$2'}.
-op_expr -> two_op_eol expr : {'$1', '$2'}.
-op_expr -> and_op_eol expr : {'$1', '$2'}.
-op_expr -> or_op_eol expr : {'$1', '$2'}.
-op_expr -> in_op_eol expr : {'$1', '$2'}.
-op_expr -> in_match_op_eol expr : {'$1', '$2'}.
-op_expr -> type_op_eol expr : {'$1', '$2'}.
-op_expr -> when_op_eol expr : {'$1', '$2'}.
-op_expr -> pipe_op_eol expr : {'$1', '$2'}.
-op_expr -> comp_op_eol expr : {'$1', '$2'}.
-op_expr -> rel_op_eol expr : {'$1', '$2'}.
-op_expr -> arrow_op_eol expr : {'$1', '$2'}.
+no_parens_expr -> matched_expr no_parens_op_expr : build_op('$1', '$2').
+no_parens_expr -> unary_op_eol no_parens_expr : build_unary_op('$1', '$2').
+no_parens_expr -> at_op_eol no_parens_expr : build_unary_op('$1', '$2').
+no_parens_expr -> capture_op_eol no_parens_expr : build_unary_op('$1', '$2').
+no_parens_expr -> ellipsis_op no_parens_expr : build_unary_op('$1', '$2').
+no_parens_expr -> no_parens_one_ambig_expr : '$1'.
+no_parens_expr -> no_parens_many_expr : '$1'.
+
+block_expr -> dot_call_identifier call_args_parens do_block : build_parens('$1', '$2', '$3').
+block_expr -> dot_call_identifier call_args_parens call_args_parens do_block : build_nested_parens('$1', '$2', '$3', '$4').
+block_expr -> dot_do_identifier do_block : build_no_parens_do_block('$1', [], '$2').
+block_expr -> dot_op_identifier call_args_no_parens_all do_block : build_no_parens_do_block('$1', '$2', '$3').
+block_expr -> dot_identifier call_args_no_parens_all do_block : build_no_parens_do_block('$1', '$2', '$3').
+
+matched_op_expr -> match_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> dual_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> mult_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> power_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> concat_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> range_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> ternary_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> xor_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> and_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> or_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> in_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> in_match_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> type_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> when_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> pipe_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> comp_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> rel_op_eol matched_expr : {'$1', '$2'}.
+matched_op_expr -> arrow_op_eol matched_expr : {'$1', '$2'}.
+
+%% We warn exclusively of |> and friends because they are used
+%% in other languages with lower precedence than function application,
+%% which can be the source of confusion.
+matched_op_expr -> arrow_op_eol no_parens_one_expr : warn_pipe('$1', '$2'), {'$1', '$2'}.
+
+unmatched_op_expr -> match_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> dual_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> mult_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> power_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> concat_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> range_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> ternary_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> xor_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> and_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> or_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> in_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> in_match_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> type_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> when_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> pipe_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> comp_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> rel_op_eol unmatched_expr : {'$1', '$2'}.
+unmatched_op_expr -> arrow_op_eol unmatched_expr : {'$1', '$2'}.
 
 no_parens_op_expr -> match_op_eol no_parens_expr : {'$1', '$2'}.
-no_parens_op_expr -> add_op_eol no_parens_expr : {'$1', '$2'}.
+no_parens_op_expr -> dual_op_eol no_parens_expr : {'$1', '$2'}.
 no_parens_op_expr -> mult_op_eol no_parens_expr : {'$1', '$2'}.
-no_parens_op_expr -> hat_op_eol no_parens_expr : {'$1', '$2'}.
-no_parens_op_expr -> two_op_eol no_parens_expr : {'$1', '$2'}.
+no_parens_op_expr -> power_op_eol no_parens_expr : {'$1', '$2'}.
+no_parens_op_expr -> concat_op_eol no_parens_expr : {'$1', '$2'}.
+no_parens_op_expr -> range_op_eol no_parens_expr : {'$1', '$2'}.
+no_parens_op_expr -> ternary_op_eol no_parens_expr : {'$1', '$2'}.
+no_parens_op_expr -> xor_op_eol no_parens_expr : {'$1', '$2'}.
 no_parens_op_expr -> and_op_eol no_parens_expr : {'$1', '$2'}.
 no_parens_op_expr -> or_op_eol no_parens_expr : {'$1', '$2'}.
 no_parens_op_expr -> in_op_eol no_parens_expr : {'$1', '$2'}.
 no_parens_op_expr -> in_match_op_eol no_parens_expr : {'$1', '$2'}.
 no_parens_op_expr -> type_op_eol no_parens_expr : {'$1', '$2'}.
+no_parens_op_expr -> when_op_eol no_parens_expr : {'$1', '$2'}.
 no_parens_op_expr -> pipe_op_eol no_parens_expr : {'$1', '$2'}.
 no_parens_op_expr -> comp_op_eol no_parens_expr : {'$1', '$2'}.
 no_parens_op_expr -> rel_op_eol no_parens_expr : {'$1', '$2'}.
-no_parens_op_expr -> arrow_op_eol no_parens_expr : {'$1', '$2'}.
+no_parens_op_expr -> arrow_op_eol no_parens_expr : warn_pipe('$1', '$2'), {'$1', '$2'}.
 
 %% Allow when (and only when) with keywords
-no_parens_op_expr -> when_op_eol no_parens_expr : {'$1', '$2'}.
 no_parens_op_expr -> when_op_eol call_args_no_parens_kw : {'$1', '$2'}.
 
-matched_op_expr -> match_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> add_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> mult_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> hat_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> two_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> and_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> or_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> in_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> in_match_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> type_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> when_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> pipe_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> comp_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> rel_op_eol matched_expr : {'$1', '$2'}.
-matched_op_expr -> arrow_op_eol matched_expr : {'$1', '$2'}.
+no_parens_one_ambig_expr -> dot_op_identifier call_args_no_parens_ambig : build_no_parens('$1', '$2').
+no_parens_one_ambig_expr -> dot_identifier call_args_no_parens_ambig : build_no_parens('$1', '$2').
+
+no_parens_many_expr -> dot_op_identifier call_args_no_parens_many_strict : build_no_parens('$1', '$2').
+no_parens_many_expr -> dot_identifier call_args_no_parens_many_strict : build_no_parens('$1', '$2').
 
-no_parens_one_expr -> dot_op_identifier call_args_no_parens_one : build_identifier('$1', '$2').
-no_parens_one_expr -> dot_identifier call_args_no_parens_one : build_identifier('$1', '$2').
-no_parens_one_expr -> dot_do_identifier : build_identifier('$1', nil).
-no_parens_one_expr -> dot_identifier : build_identifier('$1', nil).
+no_parens_one_expr -> dot_op_identifier call_args_no_parens_one : build_no_parens('$1', '$2').
+no_parens_one_expr -> dot_identifier call_args_no_parens_one : build_no_parens('$1', '$2').
+no_parens_zero_expr -> dot_do_identifier : build_identifier('$1').
+no_parens_zero_expr -> dot_identifier : build_identifier('$1').
+
+sub_matched_expr -> no_parens_zero_expr : '$1'.
+sub_matched_expr -> range_op : build_nullary_op('$1').
+sub_matched_expr -> ellipsis_op : build_nullary_op('$1').
+sub_matched_expr -> access_expr : '$1'.
+sub_matched_expr -> access_expr kw_identifier : error_invalid_kw_identifier('$2').
 
 %% From this point on, we just have constructs that can be
-%% used with the access syntax. Notice that (dot_)identifier
+%% used with the access syntax. Note that (dot_)identifier
 %% is not included in this list simply because the tokenizer
 %% marks identifiers followed by brackets as bracket_identifier.
 access_expr -> bracket_at_expr : '$1'.
 access_expr -> bracket_expr : '$1'.
-access_expr -> at_op_eol number : build_unary_op('$1', ?exprs('$2')).
-access_expr -> unary_op_eol number : build_unary_op('$1', ?exprs('$2')).
-access_expr -> capture_op_eol number : build_unary_op('$1', ?exprs('$2')).
-access_expr -> fn_eol stab end_eol : build_fn('$1', build_stab(reverse('$2'))).
-access_expr -> open_paren stab close_paren : build_stab(reverse('$2')).
-access_expr -> number : ?exprs('$1').
-access_expr -> signed_number : {element(4, '$1'), meta('$1'), ?exprs('$1')}.
+access_expr -> capture_int int : build_unary_op('$1', number_value('$2')).
+access_expr -> fn_eoe stab_eoe 'end' : build_fn('$1', '$2', '$3').
+access_expr -> open_paren stab_eoe ')' : build_paren_stab('$1', '$2', '$3').
+access_expr -> open_paren ';' stab_eoe ')' : build_paren_stab('$1', '$3', '$4').
+access_expr -> open_paren ';' close_paren : build_paren_stab('$1', [], '$3').
+access_expr -> empty_paren : warn_empty_paren('$1'), {'__block__', parens_meta('$1'), []}.
+access_expr -> int : handle_number(number_value('$1'), '$1', ?exprs('$1')).
+access_expr -> flt : handle_number(number_value('$1'), '$1', ?exprs('$1')).
+access_expr -> char : handle_number(?exprs('$1'), '$1', number_value('$1')).
 access_expr -> list : element(1, '$1').
 access_expr -> map : '$1'.
 access_expr -> tuple : '$1'.
-access_expr -> 'true' : ?id('$1').
-access_expr -> 'false' : ?id('$1').
-access_expr -> 'nil' : ?id('$1').
-access_expr -> bin_string  : build_bin_string('$1').
-access_expr -> list_string : build_list_string('$1').
-access_expr -> bit_string : '$1'.
+access_expr -> 'true' : handle_literal(?id('$1'), '$1').
+access_expr -> 'false' : handle_literal(?id('$1'), '$1').
+access_expr -> 'nil' : handle_literal(?id('$1'), '$1').
+access_expr -> bin_string : build_bin_string('$1', delimiter(<<$">>)).
+access_expr -> list_string : build_list_string('$1', delimiter(<<$'>>)).
+access_expr -> bin_heredoc : build_bin_heredoc('$1').
+access_expr -> list_heredoc : build_list_heredoc('$1').
+access_expr -> bitstring : '$1'.
 access_expr -> sigil : build_sigil('$1').
-access_expr -> max_expr : '$1'.
+access_expr -> atom : handle_literal(?exprs('$1'), '$1', atom_colon_meta('$1')).
+access_expr -> atom_quoted : handle_literal(?exprs('$1'), '$1', atom_delimiter_meta('$1')).
+access_expr -> atom_safe : build_quoted_atom('$1', true, atom_delimiter_meta('$1')).
+access_expr -> atom_unsafe : build_quoted_atom('$1', false, atom_delimiter_meta('$1')).
+access_expr -> dot_alias : '$1'.
+access_expr -> parens_call : '$1'.
 
-%% Aliases and properly formed calls. Used by map_expr.
-max_expr -> atom : ?exprs('$1').
-max_expr -> atom_safe : build_quoted_atom('$1', true).
-max_expr -> atom_unsafe : build_quoted_atom('$1', false).
-max_expr -> parens_call call_args_parens : build_identifier('$1', '$2').
-max_expr -> parens_call call_args_parens call_args_parens : build_nested_parens('$1', '$2', '$3').
-max_expr -> dot_alias : '$1'.
+%% Also used by maps and structs
+parens_call -> dot_call_identifier call_args_parens : build_parens('$1', '$2', {[], []}).
+parens_call -> dot_call_identifier call_args_parens call_args_parens : build_nested_parens('$1', '$2', '$3', {[], []}).
 
-bracket_arg -> open_bracket ']' : build_list('$1', []).
-bracket_arg -> open_bracket kw close_bracket : build_list('$1', '$2').
-bracket_arg -> open_bracket container_expr close_bracket : build_list('$1', '$2').
-bracket_arg -> open_bracket container_expr ',' close_bracket : build_list('$1', '$2').
+bracket_arg -> open_bracket kw_data close_bracket : build_access_arg('$1', '$2', '$3').
+bracket_arg -> open_bracket container_expr close_bracket : build_access_arg('$1', '$2', '$3').
+bracket_arg -> open_bracket container_expr ',' close_bracket : build_access_arg('$1', '$2', '$4').
+bracket_arg -> open_bracket container_expr ',' container_args close_bracket : error_too_many_access_syntax('$3').
 
-bracket_expr -> dot_bracket_identifier bracket_arg : build_access(build_identifier('$1', nil), '$2').
-bracket_expr -> access_expr bracket_arg : build_access('$1', '$2').
+bracket_expr -> dot_bracket_identifier bracket_arg : build_access(build_identifier('$1'), meta_with_from_brackets('$2')).
+bracket_expr -> access_expr bracket_arg : build_access('$1', meta_with_from_brackets('$2')).
 
 bracket_at_expr -> at_op_eol dot_bracket_identifier bracket_arg :
-                     build_access(build_unary_op('$1', build_identifier('$2', nil)), '$3').
+                     build_access(build_unary_op('$1', build_identifier('$2')), meta_with_from_brackets('$3')).
 bracket_at_expr -> at_op_eol access_expr bracket_arg :
-                     build_access(build_unary_op('$1', '$2'), '$3').
+                     build_access(build_unary_op('$1', '$2'), meta_with_from_brackets('$3')).
 
 %% Blocks
 
-do_block -> do_eol 'end' : [[{do,nil}]].
-do_block -> do_eol stab end_eol : [[{do, build_stab(reverse('$2'))}]].
-do_block -> do_eol block_list 'end' : [[{do, nil}|'$2']].
-do_block -> do_eol stab_eol block_list 'end' : [[{do, build_stab(reverse('$2'))}|'$3']].
+do_block -> do_eoe 'end' :
+              {do_end_meta('$1', '$2'), [[{handle_literal(do, '$1'), {'__block__', meta_from_token('$1'), []}}]]}.
+do_block -> do_eoe stab_eoe 'end' :
+              {do_end_meta('$1', '$3'), [[{handle_literal(do, '$1'), build_stab('$2', meta_from_token('$1'))}]]}.
+do_block -> do_eoe block_list 'end' :
+              {do_end_meta('$1', '$3'), [[{handle_literal(do, '$1'), {'__block__', meta_from_token('$1'), []}} | '$2']]}.
+do_block -> do_eoe stab_eoe block_list 'end' :
+              {do_end_meta('$1', '$4'), [[{handle_literal(do, '$1'), build_stab('$2', meta_from_token('$1'))} | '$3']]}.
 
-fn_eol -> 'fn' : '$1'.
-fn_eol -> 'fn' eol : '$1'.
+eoe -> eol : '$1'.
+eoe -> ';' : '$1'.
+eoe -> eol ';' : '$1'.
 
-do_eol -> 'do' : '$1'.
-do_eol -> 'do' eol : '$1'.
+fn_eoe -> 'fn' : '$1'.
+fn_eoe -> 'fn' eoe : next_is_eol('$1', '$2').
 
-end_eol -> 'end' : '$1'.
-end_eol -> eol 'end' : '$2'.
+do_eoe -> 'do' : '$1'.
+do_eoe -> 'do' eoe : '$1'.
 
-block_eol -> block_identifier : '$1'.
-block_eol -> block_identifier eol : '$1'.
+block_eoe -> block_identifier : '$1'.
+block_eoe -> block_identifier eoe : '$1'.
 
 stab -> stab_expr : ['$1'].
-stab -> stab eol stab_expr : ['$3'|'$1'].
-
-stab_eol -> stab : '$1'.
-stab_eol -> stab eol : '$1'.
-
-stab_expr -> expr : '$1'.
-stab_expr -> stab_op_eol stab_maybe_expr : build_op('$1', [], '$2').
-stab_expr -> call_args_no_parens_all stab_op_eol stab_maybe_expr :
-               build_op('$2', unwrap_when(unwrap_splice('$1')), '$3').
-stab_expr -> stab_parens_many stab_op_eol stab_maybe_expr :
-               build_op('$2', unwrap_splice('$1'), '$3').
-stab_expr -> stab_parens_many when_op expr stab_op_eol stab_maybe_expr :
-               build_op('$4', [{'when', meta('$2'), unwrap_splice('$1') ++ ['$3']}], '$5').
-
-stab_maybe_expr -> 'expr' : '$1'.
-stab_maybe_expr -> '$empty' : nil.
-
-block_item -> block_eol stab_eol : {?exprs('$1'), build_stab(reverse('$2'))}.
-block_item -> block_eol : {?exprs('$1'), nil}.
+stab -> stab eoe stab_expr : ['$3' | annotate_eoe('$2', '$1')].
+
+stab_eoe -> stab : '$1'.
+stab_eoe -> stab eoe : annotate_eoe('$2', '$1').
+
+stab_expr -> expr :
+               '$1'.
+stab_expr -> stab_op_eol_and_expr :
+               build_op([], '$1').
+stab_expr -> empty_paren stab_op_eol_and_expr :
+               build_op_with_meta([], '$2', parens_meta('$1')).
+stab_expr -> empty_paren when_op expr stab_op_eol_and_expr :
+               build_op_with_meta([{'when', meta_from_token('$2'), ['$3']}], '$4', parens_meta('$1')).
+stab_expr -> call_args_no_parens_all stab_op_eol_and_expr :
+               build_op(unwrap_when(unwrap_splice('$1')), '$2').
+stab_expr -> stab_parens_many stab_op_eol_and_expr :
+               build_op_with_meta(unwrap_splice(element(2, '$1')), '$2', parens_meta('$1')).
+stab_expr -> stab_parens_many when_op expr stab_op_eol_and_expr :
+               build_op_with_meta([{'when', meta_from_token('$2'), unwrap_splice(element(2, '$1')) ++ ['$3']}], '$4', parens_meta('$1')).
+
+stab_op_eol_and_expr -> stab_op_eol expr : {'$1', '$2'}.
+stab_op_eol_and_expr -> stab_op_eol : warn_empty_stab_clause('$1'), {'$1', handle_literal(nil, '$1')}.
+
+block_item -> block_eoe stab_eoe :
+                {handle_literal(?exprs('$1'), '$1'), build_stab('$2', [])}.
+block_item -> block_eoe :
+                {handle_literal(?exprs('$1'), '$1'), {'__block__', [], []}}.
 
 block_list -> block_item : ['$1'].
-block_list -> block_item block_list : ['$1'|'$2'].
+block_list -> block_item block_list : ['$1' | '$2'].
 
 %% Helpers
 
 open_paren -> '('      : '$1'.
-open_paren -> '(' eol  : '$1'.
+open_paren -> '(' eol  : next_is_eol('$1', '$2').
 close_paren -> ')'     : '$1'.
 close_paren -> eol ')' : '$2'.
 
-empty_paren -> open_paren ')' : '$1'.
+empty_paren -> open_paren ')' : {'$1', '$2'}.
 
-open_bracket  -> '['         : '$1'.
-open_bracket  -> '[' eol     : '$1'.
-close_bracket -> ']'         : '$1'.
-close_bracket -> eol ']'     : '$2'.
+open_bracket  -> '['     : '$1'.
+open_bracket  -> '[' eol : next_is_eol('$1', '$2').
+close_bracket -> ']'     : '$1'.
+close_bracket -> eol ']' : '$2'.
 
-open_bit  -> '<<'         : '$1'.
-open_bit  -> '<<' eol     : '$1'.
-close_bit -> '>>'         : '$1'.
-close_bit -> eol '>>'     : '$2'.
+open_bit  -> '<<'     : '$1'.
+open_bit  -> '<<' eol : next_is_eol('$1', '$2').
+close_bit -> '>>'     : '$1'.
+close_bit -> eol '>>' : '$2'.
 
 open_curly  -> '{'     : '$1'.
-open_curly  -> '{' eol : '$1'.
-close_curly -> '}'         : '$1'.
-close_curly -> eol '}'     : '$2'.
+open_curly  -> '{' eol : next_is_eol('$1', '$2').
+close_curly -> '}'     : '$1'.
+close_curly -> eol '}' : '$2'.
 
 % Operators
 
-add_op_eol -> add_op : '$1'.
-add_op_eol -> add_op eol : '$1'.
-add_op_eol -> dual_op : '$1'.
-add_op_eol -> dual_op eol : '$1'.
+unary_op_eol -> unary_op : '$1'.
+unary_op_eol -> unary_op eol : '$1'.
+unary_op_eol -> dual_op : '$1'.
+unary_op_eol -> dual_op eol : '$1'.
+unary_op_eol -> ternary_op : '$1'.
+unary_op_eol -> ternary_op eol : '$1'.
+
+capture_op_eol -> capture_op : '$1'.
+capture_op_eol -> capture_op eol : '$1'.
+
+at_op_eol -> at_op : '$1'.
+at_op_eol -> at_op eol : '$1'.
+
+match_op_eol -> match_op : '$1'.
+match_op_eol -> match_op eol : next_is_eol('$1', '$2').
+
+dual_op_eol -> dual_op : '$1'.
+dual_op_eol -> dual_op eol : next_is_eol('$1', '$2').
 
 mult_op_eol -> mult_op : '$1'.
-mult_op_eol -> mult_op eol : '$1'.
+mult_op_eol -> mult_op eol : next_is_eol('$1', '$2').
 
-hat_op_eol -> hat_op : '$1'.
-hat_op_eol -> hat_op eol : '$1'.
+power_op_eol -> power_op : '$1'.
+power_op_eol -> power_op eol : next_is_eol('$1', '$2').
 
-two_op_eol -> two_op : '$1'.
-two_op_eol -> two_op eol : '$1'.
+concat_op_eol -> concat_op : '$1'.
+concat_op_eol -> concat_op eol : next_is_eol('$1', '$2').
 
-pipe_op_eol -> pipe_op : '$1'.
-pipe_op_eol -> pipe_op eol : '$1'.
+range_op_eol -> range_op : '$1'.
+range_op_eol -> range_op eol : next_is_eol('$1', '$2').
 
-capture_op_eol -> capture_op : '$1'.
-capture_op_eol -> capture_op eol : '$1'.
+ternary_op_eol -> ternary_op : '$1'.
+ternary_op_eol -> ternary_op eol : next_is_eol('$1', '$2').
 
-unary_op_eol -> unary_op : '$1'.
-unary_op_eol -> unary_op eol : '$1'.
-unary_op_eol -> dual_op : '$1'.
-unary_op_eol -> dual_op eol : '$1'.
+xor_op_eol -> xor_op : '$1'.
+xor_op_eol -> xor_op eol : next_is_eol('$1', '$2').
 
-match_op_eol -> match_op : '$1'.
-match_op_eol -> match_op eol : '$1'.
+pipe_op_eol -> pipe_op : '$1'.
+pipe_op_eol -> pipe_op eol : next_is_eol('$1', '$2').
 
 and_op_eol -> and_op : '$1'.
-and_op_eol -> and_op eol : '$1'.
+and_op_eol -> and_op eol : next_is_eol('$1', '$2').
 
 or_op_eol -> or_op : '$1'.
-or_op_eol -> or_op eol : '$1'.
+or_op_eol -> or_op eol : next_is_eol('$1', '$2').
 
 in_op_eol -> in_op : '$1'.
-in_op_eol -> in_op eol : '$1'.
+in_op_eol -> in_op eol : next_is_eol('$1', '$2').
 
 in_match_op_eol -> in_match_op : '$1'.
-in_match_op_eol -> in_match_op eol : '$1'.
+in_match_op_eol -> in_match_op eol : next_is_eol('$1', '$2').
 
 type_op_eol -> type_op : '$1'.
-type_op_eol -> type_op eol : '$1'.
+type_op_eol -> type_op eol : next_is_eol('$1', '$2').
 
 when_op_eol -> when_op : '$1'.
-when_op_eol -> when_op eol : '$1'.
+when_op_eol -> when_op eol : next_is_eol('$1', '$2').
 
 stab_op_eol -> stab_op : '$1'.
-stab_op_eol -> stab_op eol : '$1'.
-
-at_op_eol -> at_op : '$1'.
-at_op_eol -> at_op eol : '$1'.
+stab_op_eol -> stab_op eol : next_is_eol('$1', '$2').
 
 comp_op_eol -> comp_op : '$1'.
-comp_op_eol -> comp_op eol : '$1'.
+comp_op_eol -> comp_op eol : next_is_eol('$1', '$2').
 
 rel_op_eol -> rel_op : '$1'.
-rel_op_eol -> rel_op eol : '$1'.
+rel_op_eol -> rel_op eol : next_is_eol('$1', '$2').
 
 arrow_op_eol -> arrow_op : '$1'.
-arrow_op_eol -> arrow_op eol : '$1'.
+arrow_op_eol -> arrow_op eol : next_is_eol('$1', '$2').
 
 % Dot operator
 
@@ -377,8 +477,10 @@ dot_op -> '.' eol : '$1'.
 dot_identifier -> identifier : '$1'.
 dot_identifier -> matched_expr dot_op identifier : build_dot('$2', '$1', '$3').
 
-dot_alias -> aliases : {'__aliases__', meta('$1', 0), ?exprs('$1')}.
-dot_alias -> matched_expr dot_op aliases : build_dot_alias('$2', '$1', '$3').
+dot_alias -> alias : build_alias('$1').
+dot_alias -> matched_expr dot_op alias : build_dot_alias('$2', '$1', '$3').
+dot_alias -> matched_expr dot_op open_curly '}' : build_dot_container('$2', '$1', [], newlines_pair('$3', '$4')).
+dot_alias -> matched_expr dot_op open_curly container_args close_curly : build_dot_container('$2', '$1', '$4', newlines_pair('$3', '$5')).
 
 dot_op_identifier -> op_identifier : '$1'.
 dot_op_identifier -> matched_expr dot_op op_identifier : build_dot('$2', '$1', '$3').
@@ -392,121 +494,146 @@ dot_bracket_identifier -> matched_expr dot_op bracket_identifier : build_dot('$2
 dot_paren_identifier -> paren_identifier : '$1'.
 dot_paren_identifier -> matched_expr dot_op paren_identifier : build_dot('$2', '$1', '$3').
 
-parens_call -> dot_paren_identifier : '$1'.
-parens_call -> matched_expr dot_call_op : {'.', meta('$2'), ['$1']}. % Fun/local calls
+dot_call_identifier -> dot_paren_identifier : '$1'.
+dot_call_identifier -> matched_expr dot_call_op : {'.', meta_from_token('$2'), ['$1']}. % Fun/local calls
 
 % Function calls with no parentheses
 
 call_args_no_parens_expr -> matched_expr : '$1'.
-call_args_no_parens_expr -> empty_paren : nil.
-call_args_no_parens_expr -> no_parens_expr : throw_no_parens_many_strict('$1').
+call_args_no_parens_expr -> no_parens_expr : error_no_parens_many_strict('$1').
 
 call_args_no_parens_comma_expr -> matched_expr ',' call_args_no_parens_expr : ['$3', '$1'].
-call_args_no_parens_comma_expr -> call_args_no_parens_comma_expr ',' call_args_no_parens_expr : ['$3'|'$1'].
+call_args_no_parens_comma_expr -> call_args_no_parens_comma_expr ',' call_args_no_parens_expr : ['$3' | '$1'].
 
 call_args_no_parens_all -> call_args_no_parens_one : '$1'.
+call_args_no_parens_all -> call_args_no_parens_ambig : '$1'.
 call_args_no_parens_all -> call_args_no_parens_many : '$1'.
 
 call_args_no_parens_one -> call_args_no_parens_kw : ['$1'].
 call_args_no_parens_one -> matched_expr : ['$1'].
-call_args_no_parens_one -> no_parens_expr : ['$1'].
+
+%% This is the only no parens ambiguity where we don't
+%% raise nor warn: "parent_call nested_call 1, 2, 3"
+%% always assumes that all arguments are nested.
+call_args_no_parens_ambig -> no_parens_expr : ['$1'].
 
 call_args_no_parens_many -> matched_expr ',' call_args_no_parens_kw : ['$1', '$3'].
 call_args_no_parens_many -> call_args_no_parens_comma_expr : reverse('$1').
-call_args_no_parens_many -> call_args_no_parens_comma_expr ',' call_args_no_parens_kw : reverse(['$3'|'$1']).
+call_args_no_parens_many -> call_args_no_parens_comma_expr ',' call_args_no_parens_kw : reverse(['$3' | '$1']).
 
 call_args_no_parens_many_strict -> call_args_no_parens_many : '$1'.
-call_args_no_parens_many_strict -> empty_paren : throw_no_parens_strict('$1').
-call_args_no_parens_many_strict -> open_paren call_args_no_parens_kw close_paren : throw_no_parens_strict('$1').
-call_args_no_parens_many_strict -> open_paren call_args_no_parens_many close_paren : throw_no_parens_strict('$1').
+call_args_no_parens_many_strict -> open_paren call_args_no_parens_kw close_paren : error_no_parens_strict('$1').
+call_args_no_parens_many_strict -> open_paren call_args_no_parens_many close_paren : error_no_parens_strict('$1').
 
-stab_parens_many -> empty_paren : [].
-stab_parens_many -> open_paren call_args_no_parens_kw close_paren : ['$2'].
-stab_parens_many -> open_paren call_args_no_parens_many close_paren : '$2'.
+stab_parens_many -> open_paren call_args_no_parens_kw close_paren : {'$1', ['$2'], '$3'}.
+stab_parens_many -> open_paren call_args_no_parens_many close_paren : {'$1', '$2', '$3'}.
 
-% Containers and function calls with parentheses
+% Containers
 
-container_expr -> empty_paren : nil.
 container_expr -> matched_expr : '$1'.
 container_expr -> unmatched_expr : '$1'.
-container_expr -> no_parens_expr : throw_no_parens_many_strict('$1').
+container_expr -> no_parens_expr : error_no_parens_container_strict('$1').
 
 container_args_base -> container_expr : ['$1'].
-container_args_base -> container_args_base ',' container_expr : ['$3'|'$1'].
+container_args_base -> container_args_base ',' container_expr : ['$3' | '$1'].
 
-container_args -> container_args_base : lists:reverse('$1').
-container_args -> container_args_base ',' : lists:reverse('$1').
-container_args -> container_args_base ',' kw : lists:reverse(['$3'|'$1']).
+container_args -> container_args_base : reverse('$1').
+container_args -> container_args_base ',' : reverse('$1').
+container_args -> container_args_base ',' kw_data : reverse(['$3' | '$1']).
 
-call_args_parens_base -> container_expr : ['$1'].
-call_args_parens_base -> call_args_parens_base ',' container_expr : ['$3'|'$1'].
+% Function calls with parentheses
 
-call_args_parens -> empty_paren : [].
-call_args_parens -> open_paren no_parens_expr close_paren : ['$2'].
-call_args_parens -> open_paren kw close_paren : ['$2'].
-call_args_parens -> open_paren call_args_parens_base close_paren : reverse('$2').
-call_args_parens -> open_paren call_args_parens_base ',' kw close_paren : reverse(['$4'|'$2']).
+call_args_parens_expr -> matched_expr : '$1'.
+call_args_parens_expr -> unmatched_expr : '$1'.
+call_args_parens_expr -> no_parens_expr : error_no_parens_many_strict('$1').
+
+call_args_parens_base -> call_args_parens_expr : ['$1'].
+call_args_parens_base -> call_args_parens_base ',' call_args_parens_expr : ['$3' | '$1'].
+
+call_args_parens -> open_paren ')' :
+                      {newlines_pair('$1', '$2'), []}.
+call_args_parens -> open_paren no_parens_expr close_paren :
+                      {newlines_pair('$1', '$3'), ['$2']}.
+call_args_parens -> open_paren kw_call close_paren :
+                      {newlines_pair('$1', '$3'), ['$2']}.
+call_args_parens -> open_paren call_args_parens_base close_paren :
+                      {newlines_pair('$1', '$3'), reverse('$2')}.
+call_args_parens -> open_paren call_args_parens_base ',' kw_call close_paren :
+                      {newlines_pair('$1', '$5'), reverse(['$4' | '$2'])}.
 
 % KV
 
-kw_eol -> kw_identifier : ?exprs('$1').
-kw_eol -> kw_identifier eol : ?exprs('$1').
-kw_eol -> kw_identifier_safe : build_quoted_atom('$1', true).
-kw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true).
-kw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false).
-kw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false).
+kw_eol -> kw_identifier : handle_literal(?exprs('$1'), '$1', kw_identifier_meta('$1')).
+kw_eol -> kw_identifier eol : handle_literal(?exprs('$1'), '$1', kw_identifier_meta('$1')).
+kw_eol -> kw_identifier_safe : build_quoted_atom('$1', true, kw_identifier_meta('$1')).
+kw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true, kw_identifier_meta('$1')).
+kw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false, kw_identifier_meta('$1')).
+kw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false, kw_identifier_meta('$1')).
 
 kw_base -> kw_eol container_expr : [{'$1', '$2'}].
-kw_base -> kw_base ',' kw_eol container_expr : [{'$3', '$4'}|'$1'].
+kw_base -> kw_base ',' kw_eol container_expr : [{'$3', '$4'} | '$1'].
+
+kw_call -> kw_base : reverse('$1').
+kw_call -> kw_base ',' : warn_trailing_comma('$2'), reverse('$1').
+kw_call -> kw_base ',' matched_expr : maybe_bad_keyword_call_follow_up('$2', '$1', '$3').
 
-kw -> kw_base : reverse('$1').
-kw -> kw_base ',' : reverse('$1').
+kw_data -> kw_base : reverse('$1').
+kw_data -> kw_base ',' : reverse('$1').
+kw_data -> kw_base ',' matched_expr : maybe_bad_keyword_data_follow_up('$2', '$1', '$3').
+
+call_args_no_parens_kw_expr -> kw_eol matched_expr : {'$1', '$2'}.
+call_args_no_parens_kw_expr -> kw_eol no_parens_expr : warn_nested_no_parens_keyword('$1', '$2'), {'$1', '$2'}.
 
-call_args_no_parens_kw_expr -> kw_eol call_args_no_parens_expr : {'$1','$2'}.
 call_args_no_parens_kw -> call_args_no_parens_kw_expr : ['$1'].
-call_args_no_parens_kw -> call_args_no_parens_kw_expr ',' call_args_no_parens_kw : ['$1'|'$3'].
+call_args_no_parens_kw -> call_args_no_parens_kw_expr ',' call_args_no_parens_kw : ['$1' | '$3'].
+call_args_no_parens_kw -> call_args_no_parens_kw_expr ',' matched_expr : maybe_bad_keyword_call_follow_up('$2', ['$1'], '$3').
 
 % Lists
 
-list_args -> kw : '$1'.
+list_args -> kw_data : '$1'.
 list_args -> container_args_base : reverse('$1').
 list_args -> container_args_base ',' : reverse('$1').
-list_args -> container_args_base ',' kw : reverse('$1', '$3').
+list_args -> container_args_base ',' kw_data : reverse('$1', '$3').
 
-list -> open_bracket ']' : build_list('$1', []).
-list -> open_bracket list_args close_bracket : build_list('$1', '$2').
+list -> open_bracket ']' : build_list('$1', [], '$2').
+list -> open_bracket list_args close_bracket : build_list('$1', '$2', '$3').
 
 % Tuple
 
-tuple -> open_curly '}' : build_tuple('$1', []).
-tuple -> open_curly container_args close_curly :  build_tuple('$1', '$2').
+tuple -> open_curly '}' : build_tuple('$1', [], '$2').
+tuple -> open_curly kw_data '}' : bad_keyword('$1', tuple, "'{'").
+tuple -> open_curly container_args close_curly :  build_tuple('$1', '$2', '$3').
 
 % Bitstrings
 
-bit_string -> open_bit '>>' : build_bit('$1', []).
-bit_string -> open_bit container_args close_bit : build_bit('$1', '$2').
+bitstring -> open_bit '>>' : build_bit('$1', [], '$2').
+bitstring -> open_bit kw_data '>>' : bad_keyword('$1', bitstring, "'<<'").
+bitstring -> open_bit container_args close_bit : build_bit('$1', '$2', '$3').
 
 % Map and structs
 
-map_expr -> max_expr : '$1'.
-map_expr -> dot_identifier : build_identifier('$1', nil).
-map_expr -> at_op_eol map_expr : build_unary_op('$1', '$2').
+map_base_expr -> sub_matched_expr : '$1'.
+map_base_expr -> at_op_eol map_base_expr : build_unary_op('$1', '$2').
+map_base_expr -> unary_op_eol map_base_expr : build_unary_op('$1', '$2').
+map_base_expr -> ellipsis_op map_base_expr : build_unary_op('$1', '$2').
 
 assoc_op_eol -> assoc_op : '$1'.
 assoc_op_eol -> assoc_op eol : '$1'.
 
-assoc_expr -> container_expr assoc_op_eol container_expr : {'$1', '$3'}.
-assoc_expr -> map_expr : '$1'.
+assoc_expr -> matched_expr assoc_op_eol matched_expr : {with_assoc_meta('$1', '$2'), '$3'}.
+assoc_expr -> unmatched_expr assoc_op_eol unmatched_expr : {with_assoc_meta('$1', '$2'), '$3'}.
+assoc_expr -> matched_expr assoc_op_eol unmatched_expr : {with_assoc_meta('$1', '$2'), '$3'}.
+assoc_expr -> unmatched_expr assoc_op_eol matched_expr : {with_assoc_meta('$1', '$2'), '$3'}.
+assoc_expr -> map_base_expr : '$1'.
 
-assoc_update -> matched_expr pipe_op_eol matched_expr assoc_op_eol matched_expr : {'$2', '$1', [{'$3', '$5'}]}.
-assoc_update -> unmatched_expr pipe_op_eol expr assoc_op_eol expr : {'$2', '$1', [{'$3', '$5'}]}.
-assoc_update -> matched_expr pipe_op_eol map_expr : {'$2', '$1', ['$3']}.
+assoc_update -> matched_expr pipe_op_eol assoc_expr : {'$2', '$1', ['$3']}.
+assoc_update -> unmatched_expr pipe_op_eol assoc_expr : {'$2', '$1', ['$3']}.
 
-assoc_update_kw -> matched_expr pipe_op_eol kw : {'$2', '$1', '$3'}.
-assoc_update_kw -> unmatched_expr pipe_op_eol kw : {'$2', '$1', '$3'}.
+assoc_update_kw -> matched_expr pipe_op_eol kw_data : {'$2', '$1', '$3'}.
+assoc_update_kw -> unmatched_expr pipe_op_eol kw_data : {'$2', '$1', '$3'}.
 
 assoc_base -> assoc_expr : ['$1'].
-assoc_base -> assoc_base ',' assoc_expr : ['$3'|'$1'].
+assoc_base -> assoc_base ',' assoc_expr : ['$3' | '$1'].
 
 assoc -> assoc_base : reverse('$1').
 assoc -> assoc_base ',' : reverse('$1').
@@ -514,86 +641,268 @@ assoc -> assoc_base ',' : reverse('$1').
 map_op -> '%{}' : '$1'.
 map_op -> '%{}' eol : '$1'.
 
-map_close -> kw close_curly : '$1'.
-map_close -> assoc close_curly : '$1'.
-map_close -> assoc_base ',' kw close_curly : reverse('$1', '$3').
-
-map_args -> open_curly '}' : build_map('$1', []).
-map_args -> open_curly map_close : build_map('$1', '$2').
-map_args -> open_curly assoc_update close_curly : build_map_update('$1', '$2', []).
-map_args -> open_curly assoc_update ',' close_curly : build_map_update('$1', '$2', []).
-map_args -> open_curly assoc_update ',' map_close : build_map_update('$1', '$2', '$4').
-map_args -> open_curly assoc_update_kw close_curly : build_map_update('$1', '$2', []).
+map_close -> kw_data close_curly : {'$1', '$2'}.
+map_close -> assoc close_curly : {'$1', '$2'}.
+map_close -> assoc_base ',' kw_data close_curly : {reverse('$1', '$3'), '$4'}.
 
-struct_op -> '%' : '$1'.
-struct_op -> '%' eol : '$1'.
+map_args -> open_curly '}' : build_map('$1', [], '$2').
+map_args -> open_curly map_close : build_map('$1', element(1, '$2'), element(2, '$2')).
+map_args -> open_curly assoc_update close_curly : build_map_update('$1', '$2', '$3', []).
+map_args -> open_curly assoc_update ',' close_curly : build_map_update('$1', '$2', '$4', []).
+map_args -> open_curly assoc_update ',' map_close : build_map_update('$1', '$2', element(2, '$4'), element(1, '$4')).
+map_args -> open_curly assoc_update_kw close_curly : build_map_update('$1', '$2', '$3', []).
 
 map -> map_op map_args : '$2'.
-map -> struct_op map_expr map_args : {'%', meta('$1'), ['$2', '$3']}.
-map -> struct_op map_expr eol map_args : {'%', meta('$1'), ['$2', '$4']}.
+map -> '%' map_base_expr map_args : {'%', meta_from_token('$1'), ['$2', '$3']}.
+map -> '%' map_base_expr eol map_args : {'%', meta_from_token('$1'), ['$2', '$4']}.
 
 Erlang code.
 
--define(id(Node), element(1, Node)).
--define(line(Node), element(2, Node)).
--define(exprs(Node), element(3, Node)).
+-define(columns(), get(elixir_parser_columns)).
+-define(token_metadata(), get(elixir_token_metadata)).
+
+-define(id(Token), element(1, Token)).
+-define(location(Token), element(2, Token)).
+-define(exprs(Token), element(3, Token)).
+-define(meta(Node), element(2, Node)).
 -define(rearrange_uop(Op), (Op == 'not' orelse Op == '!')).
 
-%% The following directive is needed for (significantly) faster
-%% compilation of the generated .erl file by the HiPE compiler
--compile([{hipe,[{regalloc,linear_scan}]}]).
+-compile({inline, meta_from_token/1, meta_from_location/1, is_eol/1}).
 -import(lists, [reverse/1, reverse/2]).
 
-meta(Line, Counter) -> [{counter,Counter}|meta(Line)].
-meta(Line) when is_integer(Line) -> [{line,Line}];
-meta(Node) -> meta(?line(Node)).
+meta_from_token(Token) ->
+  meta_from_location(?location(Token)).
+
+meta_from_location({Line, Column, _}) ->
+  case ?columns() of
+    true -> [{line, Line}, {column, Column}];
+    false -> [{line, Line}]
+  end.
+
+do_end_meta(Do, End) ->
+  case ?token_metadata() of
+    true ->
+      [{do, meta_from_token(Do)}, {'end', meta_from_token(End)}];
+    false ->
+      []
+  end.
+
+meta_from_token_with_closing(Begin, End) ->
+  case ?token_metadata() of
+    true ->
+      [{closing, meta_from_token(End)} | meta_from_token(Begin)];
+    false ->
+      meta_from_token(Begin)
+  end.
+
+append_non_empty(Left, []) -> Left;
+append_non_empty(Left, Right) -> Left ++ Right.
+
+%% Handle metadata in literals
+
+handle_literal(Literal, Token) ->
+  handle_literal(Literal, Token, []).
+
+handle_literal(Literal, Token, ExtraMeta) ->
+  case get(elixir_literal_encoder) of
+    false ->
+      Literal;
+
+    Fun ->
+      Meta = ExtraMeta ++ meta_from_token(Token),
+      case Fun(Literal, Meta) of
+        {ok, EncodedLiteral} ->
+          EncodedLiteral;
+        {error, Reason} ->
+          return_error(?location(Token), elixir_utils:characters_to_list(Reason) ++ [": "], "literal")
+      end
+  end.
+
+handle_number(Number, Token, Original) ->
+  case ?token_metadata() of
+    true -> handle_literal(Number, Token, [{token, elixir_utils:characters_to_binary(Original)}]);
+    false -> handle_literal(Number, Token, [])
+  end.
+
+number_value({_, {_, _, Value}, _}) ->
+  Value.
 
 %% Operators
 
-build_op({_Kind, Line, 'in'}, {UOp, _, [Left]}, Right) when ?rearrange_uop(UOp) ->
-  {UOp, meta(Line), [{'in', meta(Line), [Left, Right]}]};
+build_op_with_meta(Left, {Op, Right}, Meta) ->
+  {Op1, OpMeta, Args} = build_op(Left, Op, Right),
+  {Op1, Meta ++ OpMeta, Args}.
+
+build_op(Left, {Op, Right}) ->
+  build_op(Left, Op, Right).
+
+build_op(AST, {_Kind, Location, '//'}, Right) ->
+  case AST of
+    {'..', Meta, [Left, Middle]} ->
+      {'..//', Meta, [Left, Middle, Right]};
+
+    _ ->
+      return_error(Location, "the range step operator (//) must immediately follow the range definition operator (..), for example: 1..9//2. If you wanted to define a default argument, use (\\\\) instead. Syntax error before: ", "'//'")
+  end;
+
+build_op({UOp, UMeta, [Left]}, {_Kind, {Line, Column, _} = Location, 'in'}, Right) when ?rearrange_uop(UOp) ->
+  %% TODO: Remove "not left in right" rearrangement on v2.0
+  warn({Line, Column}, case UOp of
+    '!' -> "\"!expr1 in expr2\" is deprecated, use \"expr1 not in expr2\" instead";
+    'not' -> "\"not expr1 in expr2\" is deprecated, use \"expr1 not in expr2\" instead"
+  end),
+  Meta = meta_from_location(Location),
+  {UOp, UMeta, [{'in', Meta, [Left, Right]}]};
+
+build_op(Left, {in_op, NotLocation, 'not in', InLocation}, Right) ->
+  NotMeta = newlines_op(NotLocation) ++ meta_from_location(NotLocation),
+  InMeta = meta_from_location(InLocation),
+  {'not', NotMeta, [{'in', InMeta, [Left, Right]}]};
+
+build_op(Left, {_Kind, Location, Op}, Right) ->
+  {Op, newlines_op(Location) ++ meta_from_location(Location), [Left, Right]}.
+
+build_unary_op({_Kind, {Line, Column, _}, '//'}, Expr) ->
+  {Outer, Inner} =
+    case ?columns() of
+      true -> {[{column, Column+1}], [{column, Column}]};
+      false -> {[], []}
+    end,
+  {'/', [{line, Line} | Outer], [{'/', [{line, Line} | Inner], nil}, Expr]};
 
-build_op({_Kind, Line, Op}, Left, Right) ->
-  {Op, meta(Line), [Left, Right]}.
+build_unary_op({_Kind, Location, Op}, Expr) ->
+  {Op, meta_from_location(Location), [Expr]}.
 
-build_unary_op({_Kind, Line, Op}, Expr) ->
-  {Op, meta(Line), [Expr]}.
+build_nullary_op({_Kind, Location, Op}) ->
+  {Op, meta_from_location(Location), []}.
 
-build_list(Marker, Args) ->
-  {Args, ?line(Marker)}.
+build_list(Left, Args, Right) ->
+  {handle_literal(Args, Left, newlines_pair(Left, Right)), ?location(Left)}.
 
-build_tuple(_Marker, [Left, Right]) ->
-  {Left, Right};
-build_tuple(Marker, Args) ->
-  {'{}', meta(Marker), Args}.
+build_tuple(Left, [Arg1, Arg2], Right) ->
+  handle_literal({Arg1, Arg2}, Left, newlines_pair(Left, Right));
+build_tuple(Left, Args, Right) ->
+  {'{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}.
 
-build_bit(Marker, Args) ->
-  {'<<>>', meta(Marker), Args}.
+build_bit(Left, Args, Right) ->
+  {'<<>>', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}.
 
-build_map(Marker, Args) ->
-  {'%{}', meta(Marker), Args}.
+build_map(Left, Args, Right) ->
+  {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}.
 
-build_map_update(Marker, {Pipe, Left, Right}, Extra) ->
-  {'%{}', meta(Marker), [build_op(Pipe, Left, Right ++ Extra)]}.
+build_map_update(Left, {Pipe, Struct, Map}, Right, Extra) ->
+  Op = build_op(Struct, Pipe, append_non_empty(Map, Extra)),
+  {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), [Op]}.
 
 %% Blocks
 
-build_block([{Op,_,[_]}]=Exprs) when ?rearrange_uop(Op) -> {'__block__', [], Exprs};
-build_block([{unquote_splicing,_,Args}]=Exprs) when
-                                      length(Args) =< 2 -> {'__block__', [], Exprs};
-build_block([Expr])                                     -> Expr;
-build_block(Exprs)                                      -> {'__block__', [], Exprs}.
+build_block(Exprs) -> build_block(Exprs, []).
 
-%% Dots
+build_block([{unquote_splicing, _, [_]}]=Exprs, Meta) ->
+  {'__block__', Meta, Exprs};
+build_block([{Op, ExprMeta, Args}], Meta) ->
+  ExprMetaWithExtra =
+    case ?token_metadata() of
+      true when Meta /= [] -> [{parens, Meta} | ExprMeta];
+      _ -> ExprMeta
+    end,
+  {Op, ExprMetaWithExtra, Args};
+build_block([Expr], _Meta) ->
+  Expr;
+build_block(Exprs, Meta) ->
+  {'__block__', Meta, Exprs}.
+
+%% Newlines
+
+newlines_pair(Left, Right) ->
+  case ?token_metadata() of
+    true ->
+      newlines(?location(Left), [{closing, meta_from_token(Right)}]);
+    false ->
+      []
+  end.
+
+newlines_op(Location) ->
+  case ?token_metadata() of
+    true -> newlines(Location, []);
+    false -> []
+  end.
 
-build_dot_alias(Dot, {'__aliases__', _, Left}, {'aliases', _, Right}) ->
-  {'__aliases__', meta(Dot), Left ++ Right};
+next_is_eol(Token, {_, {_, _, Count}}) ->
+  {Line, Column, _} = ?location(Token),
+  setelement(2, Token, {Line, Column, Count}).
+
+newlines({_, _, Count}, Meta) when is_integer(Count) and (Count > 0) ->
+  [{newlines, Count} | Meta];
+newlines(_, Meta) ->
+  Meta.
+
+annotate_eoe(Token, Stack) ->
+  case ?token_metadata() of
+    true ->
+      case {Token, Stack} of
+        {{_, Location}, [{'->', StabMeta, [StabArgs, {Left, Meta, Right}]} | Rest]} when is_list(Meta) ->
+          [{'->', StabMeta, [StabArgs, {Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right}]} | Rest];
+
+        {{_, Location}, [{Left, Meta, Right} | Rest]} when is_list(Meta), Left =/= '->' ->
+          [{Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right} | Rest];
+
+        _ ->
+          Stack
+      end;
+    false ->
+      Stack
+  end.
 
-build_dot_alias(Dot, Other, {'aliases', _, Right}) ->
-  {'__aliases__', meta(Dot), [Other|Right]}.
+end_of_expression({_, _, Count} = Location) when is_integer(Count) ->
+  [{newlines, Count} | meta_from_location(Location)];
+end_of_expression(Location) ->
+  meta_from_location(Location).
 
-build_dot(Dot, Left, Right) ->
-  {'.', meta(Dot), [Left, extract_identifier(Right)]}.
+%% Dots
+
+build_alias({'alias', Location, Alias}) ->
+  Meta = meta_from_location(Location),
+  MetaWithExtra =
+    case ?token_metadata() of
+      true -> [{last, meta_from_location(Location)} | Meta];
+      false -> Meta
+    end,
+  {'__aliases__', MetaWithExtra, [Alias]}.
+
+build_dot_alias(_Dot, {'__aliases__', Meta, Left}, {'alias', SegmentLocation, Right}) ->
+  MetaWithExtra =
+    case ?token_metadata() of
+      true -> lists:keystore(last, 1, Meta, {last, meta_from_location(SegmentLocation)});
+      false -> Meta
+    end,
+  {'__aliases__', MetaWithExtra, Left ++ [Right]};
+build_dot_alias(_Dot, Atom, Right) when is_atom(Atom) ->
+  error_bad_atom(Right);
+build_dot_alias(Dot, Expr, {'alias', SegmentLocation, Right}) ->
+  Meta = meta_from_token(Dot),
+  MetaWithExtra =
+    case ?token_metadata() of
+      true -> [{last, meta_from_location(SegmentLocation)} | Meta];
+      false -> Meta
+    end,
+  {'__aliases__', MetaWithExtra, [Expr, Right]}.
+
+build_dot_container(Dot, Left, Right, Extra) ->
+  Meta = meta_from_token(Dot),
+  {{'.', Meta, [Left, '{}']}, Extra ++ Meta, Right}.
+
+build_dot(Dot, Left, {_, Location, _} = Right) ->
+  Meta = meta_from_token(Dot),
+  IdentifierMeta0 = meta_from_location(Location),
+  IdentifierMeta1 =
+    case Location of
+      {_Line, _Column, Delimiter} when is_integer(Delimiter) ->
+        delimiter(<<Delimiter>>) ++ IdentifierMeta0;
+      _ ->
+        IdentifierMeta0
+    end,
+  {'.', Meta, IdentifierMeta1, [Left, extract_identifier(Right)]}.
 
 extract_identifier({Kind, _, Identifier}) when
     Kind == identifier; Kind == bracket_identifier; Kind == paren_identifier;
@@ -602,72 +911,185 @@ extract_identifier({Kind, _, Identifier}) when
 
 %% Identifiers
 
-build_nested_parens(Dot, Args1, Args2) ->
-  Identifier = build_identifier(Dot, Args1),
-  Meta = element(2, Identifier),
-  {Identifier, Meta, Args2}.
+build_nested_parens(Dot, Args1, {Args2Meta, Args2}, {BlockMeta, Block}) ->
+  Identifier = build_parens(Dot, Args1, {[], []}),
+  %% Take line and column meta from the call target node
+  LocationMeta = lists:filter(fun({Key, _}) -> Key == line orelse Key == column end, ?meta(Identifier)),
+  Meta = BlockMeta ++ Args2Meta ++ LocationMeta,
+  {Identifier, Meta, append_non_empty(Args2, Block)}.
+
+build_parens(Expr, {ArgsMeta, Args}, {BlockMeta, Block}) ->
+  {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, append_non_empty(Args, Block)),
+  {BuiltExpr, BlockMeta ++ ArgsMeta ++ BuiltMeta, BuiltArgs}.
 
-build_identifier({'.', Meta, _} = Dot, Args) ->
-  FArgs = case Args of
-    nil -> [];
-    _ -> Args
-  end,
-  {Dot, Meta, FArgs};
+build_no_parens_do_block(Expr, Args, {BlockMeta, Block}) ->
+  {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, Args ++ Block),
+  {BuiltExpr, BlockMeta ++ BuiltMeta, BuiltArgs}.
 
-build_identifier({Keyword, Line}, Args) when Keyword == fn ->
-  {fn, meta(Line), Args};
+build_no_parens(Expr, Args) ->
+  build_call(Expr, Args).
 
-build_identifier({op_identifier, Line, Identifier}, [Arg]) ->
-  {Identifier, [{ambiguous_op,nil}|meta(Line)], [Arg]};
+build_identifier({'.', Meta, IdentifierMeta, DotArgs}) ->
+  {{'.', Meta, DotArgs}, [{no_parens, true} | IdentifierMeta], []};
 
-build_identifier({_, Line, Identifier}, Args) ->
-  {Identifier, meta(Line), Args}.
+build_identifier({'.', Meta, _} = Dot) ->
+  {Dot, [{no_parens, true} | Meta], []};
+
+build_identifier({_, Location, Identifier}) ->
+  {Identifier, meta_from_location(Location), nil}.
+
+build_call({'.', Meta, IdentifierMeta, DotArgs}, Args) ->
+  {{'.', Meta, DotArgs}, IdentifierMeta, Args};
+
+build_call({'.', Meta, _} = Dot, Args) ->
+  {Dot, Meta, Args};
+
+build_call({op_identifier, Location, Identifier}, [Arg]) ->
+  {Identifier, [{ambiguous_op, nil} | meta_from_location(Location)], [Arg]};
+
+build_call({_, Location, Identifier}, Args) ->
+  {Identifier, meta_from_location(Location), Args}.
 
 %% Fn
 
-build_fn(Op, Stab) ->
-  {fn, meta(Op), Stab}.
+build_fn(Fn, Stab, End) ->
+  case check_stab(Stab, none) of
+    stab ->
+      Meta = newlines_op(?location(Fn)) ++ meta_from_token_with_closing(Fn, End),
+      {fn, Meta, collect_stab(Stab, [], [])};
+    block ->
+      return_error(?location(Fn), "expected anonymous functions to be defined with -> inside: ", "'fn'")
+  end.
 
 %% Access
 
-build_access(Expr, {List, Line}) ->
-  Meta = meta(Line),
+build_access_arg(Left, Args, Right) ->
+  {Args, newlines_pair(Left, Right) ++ meta_from_token(Left)}.
+
+build_access(Expr, {List, Meta}) ->
   {{'.', Meta, ['Elixir.Access', get]}, Meta, [Expr, List]}.
 
 %% Interpolation aware
 
-build_sigil({sigil, Line, Sigil, Parts, Modifiers}) ->
-  Meta = meta(Line),
-  {list_to_atom("sigil_" ++ [Sigil]), Meta, [ {'<<>>', Meta, string_parts(Parts)}, Modifiers ]}.
-
-build_bin_string({bin_string, _Line, [H]}) when is_binary(H) ->
-  H;
-build_bin_string({bin_string, Line, Args}) ->
-  {'<<>>', meta(Line), string_parts(Args)}.
-
-build_list_string({list_string, _Line, [H]}) when is_binary(H) ->
-  elixir_utils:characters_to_list(H);
-build_list_string({list_string, Line, Args}) ->
-  Meta = meta(Line),
-  {{'.', Meta, ['Elixir.String', to_char_list]}, Meta, [{'<<>>', Meta, string_parts(Args)}]}.
+build_sigil({sigil, Location, Atom, Parts, Modifiers, Indentation, Delimiter}) ->
+  Meta = meta_from_location(Location),
+  MetaWithDelimiter = [{delimiter, Delimiter} | Meta],
+  MetaWithIndentation = meta_with_indentation(Meta, Indentation),
+  {Atom,
+   MetaWithDelimiter,
+   [{'<<>>', MetaWithIndentation, string_parts(Parts)}, Modifiers]}.
+
+meta_with_indentation(Meta, nil) ->
+  Meta;
+meta_with_indentation(Meta, Indentation) ->
+  [{indentation, Indentation} | Meta].
+
+meta_with_from_brackets({List, Meta}) ->
+  {List, [{from_brackets, true} | Meta]}.
+
+build_bin_heredoc({bin_heredoc, Location, Indentation, Args}) ->
+  ExtraMeta =
+    case ?token_metadata() of
+      true -> [{delimiter, <<$", $", $">>}, {indentation, Indentation}];
+      false -> []
+    end,
+  build_bin_string({bin_string, Location, Args}, ExtraMeta).
 
-build_quoted_atom({_, _Line, [H]}, Safe) when is_binary(H) ->
-  Op = binary_to_atom_op(Safe), erlang:Op(H, utf8);
-build_quoted_atom({_, Line, Args}, Safe) ->
-  Meta = meta(Line),
-  {{'.', Meta, [erlang, binary_to_atom_op(Safe)]}, Meta, [{'<<>>', Meta, string_parts(Args)}, utf8]}.
+build_list_heredoc({list_heredoc, Location, Indentation, Args}) ->
+  ExtraMeta =
+    case ?token_metadata() of
+      true -> [{delimiter, <<$', $', $'>>}, {indentation, Indentation}];
+      false -> []
+    end,
+  build_list_string({list_string, Location, Args}, ExtraMeta).
+
+build_bin_string({bin_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) ->
+  handle_literal(H, Token, ExtraMeta);
+build_bin_string({bin_string, Location, Args}, ExtraMeta) ->
+  Meta =
+    case ?token_metadata() of
+      true -> ExtraMeta ++ meta_from_location(Location);
+      false -> meta_from_location(Location)
+    end,
+  {'<<>>', Meta, string_parts(Args)}.
+
+build_list_string({list_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) ->
+  try
+    List = elixir_utils:characters_to_list(H),
+    handle_literal(List, Token, ExtraMeta)
+  catch
+    error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->
+      return_error(?location(Token), elixir_utils:characters_to_list(Message), "'")
+  end;
+build_list_string({list_string, Location, Args}, ExtraMeta) ->
+  Meta = meta_from_location(Location),
+  MetaWithExtra =
+    case ?token_metadata() of
+      true -> ExtraMeta ++ Meta;
+      false -> Meta
+    end,
+  {{'.', Meta, ['Elixir.List', to_charlist]}, MetaWithExtra, [charlist_parts(Args)]}.
+
+build_quoted_atom({_, _Location, [H]} = Token, Safe, ExtraMeta) when is_binary(H) ->
+  Op = binary_to_atom_op(Safe),
+  handle_literal(erlang:Op(H, utf8), Token, ExtraMeta);
+build_quoted_atom({_, Location, Args}, Safe, ExtraMeta) ->
+  Meta = meta_from_location(Location),
+  MetaWithExtra =
+    case ?token_metadata() of
+      true -> ExtraMeta ++ Meta;
+      false -> Meta
+    end,
+  {{'.', Meta, [erlang, binary_to_atom_op(Safe)]}, MetaWithExtra, [{'<<>>', Meta, string_parts(Args)}, utf8]}.
 
 binary_to_atom_op(true)  -> binary_to_existing_atom;
 binary_to_atom_op(false) -> binary_to_atom.
 
+atom_colon_meta({atom, _Location, Atom}) when Atom =:= true orelse Atom =:= false orelse Atom =:= nil ->
+  [{format, atom}];
+atom_colon_meta(_) ->
+  [].
+
+atom_delimiter_meta({_Kind, {_Line, _Column, Delimiter}, _Args}) ->
+  case ?token_metadata() of
+    true -> [{delimiter, <<Delimiter>>}];
+    false -> []
+  end.
+
+kw_identifier_meta({_Kind, {_Line, _Column, Delimiter}, _Args}) ->
+  Meta = [{format, keyword}],
+  case ?token_metadata() of
+    true when is_integer(Delimiter) -> [{delimiter, <<Delimiter>>} | Meta];
+    _ -> Meta
+  end.
+
+charlist_parts(Parts) ->
+  [charlist_part(Part) || Part <- Parts].
+charlist_part(Binary) when is_binary(Binary) ->
+  Binary;
+charlist_part({Begin, End, Tokens}) ->
+  Form = string_tokens_parse(Tokens),
+  Meta = meta_from_location(Begin),
+  MetaWithExtra =
+    case ?token_metadata() of
+      true -> [{closing, meta_from_location(End)} | Meta];
+      false -> Meta
+    end,
+  {{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}.
+
 string_parts(Parts) ->
   [string_part(Part) || Part <- Parts].
 string_part(Binary) when is_binary(Binary) ->
   Binary;
-string_part({Line, Tokens}) ->
+string_part({Begin, End, Tokens}) ->
   Form = string_tokens_parse(Tokens),
-  Meta = meta(Line),
-  {'::', Meta, [{{'.', Meta, ['Elixir.Kernel', to_string]}, Meta, [Form]}, {binary, Meta, nil}]}.
+  Meta = meta_from_location(Begin),
+  MetaWithExtra =
+    case ?token_metadata() of
+      true -> [{closing, meta_from_location(End)} | Meta];
+      false -> Meta
+    end,
+  {'::', Meta, [{{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}, {binary, Meta, nil}]}.
 
 string_tokens_parse(Tokens) ->
   case parse(Tokens) of
@@ -675,36 +1097,56 @@ string_tokens_parse(Tokens) ->
     {error, _} = Error -> throw(Error)
   end.
 
+delimiter(Delimiter) ->
+  case ?token_metadata() of
+    true -> [{delimiter, Delimiter}];
+    false -> []
+  end.
+
 %% Keywords
 
-build_stab([{'->', Meta, [Left, Right]}|T]) ->
-  build_stab(Meta, T, Left, [Right], []);
+check_stab([{'->', _, [_, _]}], _) -> stab;
+check_stab([], none) -> block;
+check_stab([_], none) -> block;
+check_stab([_], Meta) -> error_invalid_stab(Meta);
+check_stab([{'->', Meta, [_, _]} | T], _) -> check_stab(T, Meta);
+check_stab([_ | T], MaybeMeta) -> check_stab(T, MaybeMeta).
+
+build_stab(Stab, BlockMeta) ->
+  case check_stab(Stab, none) of
+    block -> build_block(reverse(Stab), BlockMeta);
+    stab -> collect_stab(Stab, [], [])
+  end.
 
-build_stab(Else) ->
-  build_block(Else).
+build_paren_stab(_Before, [{Op, _, [_]}]=Exprs, _After) when ?rearrange_uop(Op) ->
+  {'__block__', [], Exprs};
+build_paren_stab(Before, Stab, After) ->
+  case check_stab(Stab, none) of
+    block -> build_block(reverse(Stab), meta_from_token_with_closing(Before, After));
+    stab -> handle_literal(collect_stab(Stab, [], []), Before, newlines_pair(Before, After))
+  end.
 
-build_stab(Old, [{'->', New, [Left, Right]}|T], Marker, Temp, Acc) ->
-  H = {'->', Old, [Marker, build_block(reverse(Temp))]},
-  build_stab(New, T, Left, [Right], [H|Acc]);
+collect_stab([{'->', Meta, [Left, Right]} | T], Exprs, Stabs) ->
+  Stab = {'->', Meta, [Left, build_block([Right | Exprs])]},
+  collect_stab(T, [], [Stab | Stabs]);
 
-build_stab(Meta, [H|T], Marker, Temp, Acc) ->
-  build_stab(Meta, T, Marker, [H|Temp], Acc);
+collect_stab([H | T], Exprs, Stabs) ->
+  collect_stab(T, [H | Exprs], Stabs);
 
-build_stab(Meta, [], Marker, Temp, Acc) ->
-  H = {'->', Meta, [Marker, build_block(reverse(Temp))]},
-  reverse([H|Acc]).
+collect_stab([], [], Stabs) ->
+  Stabs.
 
 %% Every time the parser sees a (unquote_splicing())
 %% it assumes that a block is being spliced, wrapping
 %% the splicing in a __block__. But in the stab clause,
-%% we can have (unquote_splicing(1,2,3)) -> :ok, in such
+%% we can have (unquote_splicing(1, 2, 3)) -> :ok, in such
 %% case, we don't actually want the block, since it is
 %% an arg style call. unwrap_splice unwraps the splice
 %% from such blocks.
-unwrap_splice([{'__block__', [], [{unquote_splicing, _, _}] = Splice}]) ->
+unwrap_splice([{'__block__', _, [{unquote_splicing, _, _}] = Splice}]) ->
   Splice;
-
-unwrap_splice(Other) -> Other.
+unwrap_splice(Other) ->
+  Other.
 
 unwrap_when(Args) ->
   case elixir_utils:split_last(Args) of
@@ -714,25 +1156,196 @@ unwrap_when(Args) ->
       Args
   end.
 
-to_block([One]) -> One;
-to_block(Other) -> {'__block__', [], reverse(Other)}.
-
-%% Errors
-
-throw(Line, Error, Token) ->
-  throw({error, {Line, ?MODULE, [Error, Token]}}).
-
-throw_no_parens_strict(Token) ->
-  throw(?line(Token), "unexpected parenthesis. If you are making a "
-    "function call, do not insert spaces in between the function name and the "
+parens_meta({Open, Close}) ->
+  case ?token_metadata() of
+    true ->
+      ParensEntry = [{closing, meta_from_token(Close)} | meta_from_token(Open)],
+      [{parens, ParensEntry}];
+    false ->
+      []
+  end;
+parens_meta({Open, _Args, Close}) ->
+  parens_meta({Open, Close}).
+
+with_assoc_meta({Target, Meta, Args}, AssocToken) ->
+  case ?token_metadata() of
+    true ->
+      {Target, [{assoc, meta_from_token(AssocToken)} | Meta], Args};
+    false ->
+      {Target, Meta, Args}
+  end;
+
+with_assoc_meta(Left, _AssocToken) -> Left.
+
+%% Warnings and errors
+
+return_error({Line, Column, _}, ErrorMessage, ErrorToken) ->
+  return_error([{line, Line}, {column, Column}], [ErrorMessage, ErrorToken]).
+
+%% We should prefer to use return_error as it includes
+%% Line and Column but that's not always possible.
+return_error_with_meta(Meta, ErrorMessage, ErrorToken) ->
+  return_error(Meta, [ErrorMessage, ErrorToken]).
+
+error_invalid_stab(MetaStab) ->
+  return_error_with_meta(MetaStab,
+    "unexpected operator ->. If you want to define multiple clauses, the first expression must use ->. "
+    "Syntax error before: ", "'->'").
+
+error_bad_atom(Token) ->
+  return_error(?location(Token), "atom cannot be followed by an alias. "
+    "If the '.' was meant to be part of the atom's name, "
+    "the atom name must be quoted. Syntax error before: ", "'.'").
+
+bad_keyword(Token, Context, StartString) ->
+  return_error(?location(Token),
+    "unexpected keyword list inside " ++ atom_to_list(Context) ++ ". "
+    "Did you mean to write a map (using %{...}) or a list (using [...]) instead? "
+    "Syntax error after: ", StartString).
+
+maybe_bad_keyword_call_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) ->
+  reverse([Expr | KW]);
+maybe_bad_keyword_call_follow_up(Token, _KW, _Expr) ->
+  return_error(?location(Token),
+    "unexpected expression after keyword list. Keyword lists must always come as the last argument. Therefore, this is not allowed:\n\n"
+    "    function_call(1, some: :option, 2)\n\n"
+    "Instead, wrap the keyword in brackets:\n\n"
+    "    function_call(1, [some: :option], 2)\n\n"
+    "Syntax error after: ", "','").
+
+maybe_bad_keyword_data_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) ->
+  reverse([Expr | KW]);
+maybe_bad_keyword_data_follow_up(Token, _KW, _Expr) ->
+  return_error(?location(Token),
+    "unexpected expression after keyword list. Keyword lists must always come last in lists and maps. Therefore, this is not allowed:\n\n"
+    "    [some: :value, :another]\n"
+    "    %{some: :value, another => value}\n\n"
+    "Instead, reorder it to be the last entry:\n\n"
+    "    [:another, some: :value]\n"
+    "    %{another => value, some: :value}\n\n"
+    "Syntax error after: ", "','").
+
+error_no_parens_strict(Token) ->
+  return_error(?location(Token), "unexpected parentheses. If you are making a "
+    "function call, do not insert spaces between the function name and the "
     "opening parentheses. Syntax error before: ", "'('").
 
-throw_no_parens_many_strict(Token) ->
-  Line =
-    case lists:keyfind(line, 1, element(2, Token)) of
-      {line, L} -> L;
-      false -> 0
-    end,
-
-  throw(Line, "unexpected comma. Parentheses are required to solve ambiguity "
-    "in nested calls. Syntax error before: ", "','").
+error_no_parens_many_strict(Node) ->
+  return_error_with_meta(?meta(Node),
+    "unexpected comma. Parentheses are required to solve ambiguity in nested calls.\n\n"
+    "This error happens when you have nested function calls without parentheses. "
+    "For example:\n\n"
+    "    parent_call a, nested_call b, c, d\n\n"
+    "In the example above, we don't know if the parameters \"c\" and \"d\" apply "
+    "to the function \"parent_call\" or \"nested_call\". You can solve this by "
+    "explicitly adding parentheses:\n\n"
+    "    parent_call a, nested_call(b, c, d)\n\n"
+    "Or by adding commas (in case a nested call is not intended):\n\n"
+    "    parent_call a, nested_call, b, c, d\n\n"
+    "Elixir cannot compile otherwise. Syntax error before: ", "','").
+
+error_no_parens_container_strict(Node) ->
+  return_error_with_meta(?meta(Node),
+    "unexpected comma. Parentheses are required to solve ambiguity inside containers.\n\n"
+    "This error may happen when you forget a comma in a list or other container:\n\n"
+    "    [a, b c, d]\n\n"
+    "Or when you have ambiguous calls:\n\n"
+    "    [function a, b, c]\n\n"
+    "In the example above, we don't know if the values \"b\" and \"c\" "
+    "belongs to the list or the function \"function\". You can solve this by explicitly "
+    "adding parentheses:\n\n"
+    "    [one, function(a, b, c)]\n\n"
+    "Elixir cannot compile otherwise. Syntax error before: ", "','").
+
+error_too_many_access_syntax(Comma) ->
+  return_error(?location(Comma), "too many arguments when accessing a value. "
+    "The value[key] notation in Elixir expects either a single argument or a keyword list. "
+    "The following examples are allowed:\n\n"
+    "    value[one]\n"
+    "    value[one: 1, two: 2]\n"
+    "    value[[one, two, three]]\n\n"
+    "These are invalid:\n\n"
+    "    value[1, 2, 3]\n"
+    "    value[one, two, three]\n\n"
+    "Syntax error after: ", "','").
+
+error_invalid_kw_identifier({_, Location, do}) ->
+  return_error(Location, elixir_tokenizer:invalid_do_error("unexpected keyword: "), "do:");
+error_invalid_kw_identifier({_, Location, KW}) ->
+  return_error(Location, "syntax error before: ", "'" ++ atom_to_list(KW) ++ ":'").
+
+%% TODO: Make this an error on v2.0
+warn_trailing_comma({',', {Line, Column, _}}) ->
+  warn({Line, Column}, "trailing commas are not allowed inside function/macro call arguments").
+
+%% TODO: Make this an error on v2.0
+warn_pipe({arrow_op, {Line, Column, _}, Op}, {_, [_ | _], [_ | _]}) ->
+  warn(
+    {Line, Column},
+    io_lib:format(
+      "parentheses are required when piping into a function call. For example:\n\n"
+      "    foo 1 ~ts bar 2 ~ts baz 3\n\n"
+      "is ambiguous and should be written as\n\n"
+      "    foo(1) ~ts bar(2) ~ts baz(3)\n\n"
+      "Ambiguous pipe found at:",
+      [Op, Op, Op, Op]
+    )
+  );
+warn_pipe(_Token, _) ->
+  ok.
+
+%% TODO: Make this an error on v2.0
+warn_no_parens_after_do_op({{_Type, Location, Op}, _}) ->
+  {Line, _, _} = Location,
+
+  warn(
+    Line,
+    "missing parentheses on expression following operator \"" ++ atom_to_list(Op) ++ "\", "
+    "you must add parentheses to avoid ambiguities"
+  ).
+
+%% TODO: Make this an error on v2.0
+warn_nested_no_parens_keyword(Key, Value) when is_atom(Key) ->
+  {line, Line} = lists:keyfind(line, 1, ?meta(Value)),
+  warn(
+    Line,
+    "missing parentheses for expression following \"" ++ atom_to_list(Key) ++ ":\" keyword. "
+    "Parentheses are required to solve ambiguity inside keywords.\n\n"
+    "This error happens when you have function calls without parentheses inside keywords. "
+    "For example:\n\n"
+    "    function(arg, one: nested_call a, b, c)\n"
+    "    function(arg, one: if expr, do: :this, else: :that)\n\n"
+    "In the examples above, we don't know if the arguments \"b\" and \"c\" apply "
+    "to the function \"function\" or \"nested_call\". Or if the keywords \"do\" and "
+    "\"else\" apply to the function \"function\" or \"if\". You can solve this by "
+    "explicitly adding parentheses:\n\n"
+    "    function(arg, one: if(expr, do: :this, else: :that))\n"
+    "    function(arg, one: nested_call(a, b, c))\n\n"
+    "Ambiguity found at:"
+  );
+
+% Key might not be an atom when using literal_encoder, we just skip the warning
+warn_nested_no_parens_keyword(_Key, _Value) ->
+  ok.
+
+warn_empty_paren({{_, {Line, Column, _}}, _}) ->
+  warn(
+    {Line, Column},
+    "invalid expression (). "
+    "If you want to invoke or define a function, make sure there are "
+    "no spaces between the function name and its arguments. If you wanted "
+    "to pass an empty block or code, pass a value instead, such as a nil or an atom"
+  ).
+
+warn_empty_stab_clause({stab_op, {Line, Column, _}, '->'}) ->
+  warn(
+    {Line, Column},
+    "an expression is always required on the right side of ->. "
+    "Please provide a value after ->"
+  ).
+
+warn(LineColumn, Message) ->
+  case get(elixir_parser_warning_file) of
+    nil -> ok;
+    File -> elixir_errors:erl_warn(LineColumn, File, Message)
+  end.
diff --git a/lib/elixir/src/elixir_quote.erl b/lib/elixir/src/elixir_quote.erl
index 9e8cbc7bd9f..b05eeab7a45 100644
--- a/lib/elixir/src/elixir_quote.erl
+++ b/lib/elixir/src/elixir_quote.erl
@@ -1,310 +1,639 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(elixir_quote).
--export([escape/2, linify/2, linify/3, linify_with_context_counter/3, quote/4]).
--export([dot/6, tail_list/3, list/2]). %% Quote callbacks
+
+-feature(maybe_expr, enable).
+
+-export([escape/3, linify/3, linify_with_context_counter/3, build/7, quote/2, has_unquotes/1, fun_to_quoted/1]).
+-export([dot/5, tail_list/3, list/2, validate_runtime/2, shallow_validate_ast/1]). %% Quote callbacks
 
 -include("elixir.hrl").
--define(defs(Kind), Kind == def; Kind == defp; Kind == defmacro; Kind == defmacrop).
--define(lexical(Kind), Kind == import; Kind == alias; Kind == '__aliases__').
--compile({inline, [keyfind/2, keystore/3, keydelete/2, keyreplace/3, keynew/3]}).
+-define(defs(Kind), Kind == def; Kind == defp; Kind == defmacro; Kind == defmacrop; Kind == '@').
+-define(lexical(Kind), Kind == import; Kind == alias; Kind == require).
+-compile({inline, [keyfind/2, keystore/3, keydelete/2, keynew/3, do_tuple_linify/6]}).
+
+-record(elixir_quote, {
+  line=false,
+  file=nil,
+  context=nil,
+  op=escape, % escape | escape_and_prune | {struct, Module} | quote
+  aliases_hygiene=nil,
+  imports_hygiene=nil,
+  unquote=true,
+  generated=false,
+  shallow_validate=false
+}).
+
+%% fun_to_quoted
+
+fun_to_quoted(Function) ->
+  Meta = [],
+  {module, Module} = erlang:fun_info(Function, module),
+  {name, Name}     = erlang:fun_info(Function, name),
+  {arity, Arity}   = erlang:fun_info(Function, arity),
+  {'&', Meta, [{'/', Meta, [{{'.', Meta, [Module, Name]}, [{no_parens, true} | Meta], []}, Arity]}]}.
+
+%% has_unquotes
+
+has_unquotes(Ast) -> has_unquotes(Ast, 0).
+
+has_unquotes({quote, _, [Child]}, QuoteLevel) ->
+  has_unquotes(Child, QuoteLevel + 1);
+has_unquotes({quote, _, [QuoteOpts, Child]}, QuoteLevel) ->
+  case disables_unquote(QuoteOpts) of
+    true -> false;
+    _ -> has_unquotes(Child, QuoteLevel + 1)
+  end;
+has_unquotes({Unquote, _, [Child]}, QuoteLevel)
+  when Unquote == unquote; Unquote == unquote_splicing ->
+  case QuoteLevel of
+    0 -> true;
+    _ ->  has_unquotes(Child, QuoteLevel - 1)
+end;
+has_unquotes({{'.', _, [_, unquote]}, _, [_]}, _) -> true;
+has_unquotes({Var, _, Ctx}, _) when is_atom(Var), is_atom(Ctx) -> false;
+has_unquotes({Name, _, Args}, QuoteLevel) when is_list(Args) ->
+  has_unquotes(Name) orelse lists:any(fun(Child) -> has_unquotes(Child, QuoteLevel) end, Args);
+has_unquotes({Left, Right}, QuoteLevel) ->
+  has_unquotes(Left, QuoteLevel) orelse has_unquotes(Right, QuoteLevel);
+has_unquotes(List, QuoteLevel) when is_list(List) ->
+  lists:any(fun(Child) -> has_unquotes(Child, QuoteLevel) end, List);
+has_unquotes(_Other, _) -> false.
+
+disables_unquote([{unquote, false} | _]) -> true;
+disables_unquote([{bind_quoted, _} | _]) -> true;
+disables_unquote([_H | T]) -> disables_unquote(T);
+disables_unquote(_) -> false.
 
 %% Apply the line from site call on quoted contents.
 %% Receives a Key to look for the default line as argument.
-linify(Line, Exprs) when is_integer(Line) ->
-  do_linify(Line, line, nil, Exprs).
-
+linify(0, _Key, Exprs) ->
+  Exprs;
 linify(Line, Key, Exprs) when is_integer(Line) ->
-  do_linify(Line, Key, nil, Exprs).
+  Fun =
+    case Key of
+      line ->
+        fun(Meta) -> keynew(line, Meta, Line) end;
+      keep ->
+        fun(Meta) ->
+          case lists:keytake(keep, 1, Meta) of
+            {value, {keep, {_, Int}}, MetaNoFile} ->
+              [{line, Int} | keydelete(line, MetaNoFile)];
+            _ ->
+              keynew(line, Meta, Line)
+          end
+        end
+    end,
 
-%% Same as linify but also considers the context counter.
-linify_with_context_counter(Line, Var, Exprs) when is_integer(Line) ->
-  do_linify(Line, line, Var, Exprs).
+  do_linify(Fun, Exprs, nil, false).
 
-do_linify(Line, Key, {Receiver, Counter} = Var, {Left, Meta, Receiver})
-    when is_atom(Left), is_list(Meta), Left /= '_' ->
-  do_tuple_linify(Line, Key, Var, keynew(counter, Meta, Counter), Left, Receiver);
+%% Same as linify but also considers the context counter and generated.
+linify_with_context_counter(ContextMeta, Var, Exprs) when is_list(ContextMeta) ->
+  Line = ?line(ContextMeta),
 
-do_linify(Line, Key, {_, Counter} = Var, {Lexical, [_|_] = Meta, [_|_] = Args}) when ?lexical(Lexical) ->
-  do_tuple_linify(Line, Key, Var, keynew(counter, Meta, Counter), Lexical, Args);
+  Generated = keyfind(generated, ContextMeta) == {generated, true},
 
-do_linify(Line, Key, Var, {Left, Meta, Right}) when is_list(Meta) ->
-  do_tuple_linify(Line, Key, Var, Meta, Left, Right);
+  Fun = if
+    Line =:= 0 -> fun(Meta) -> Meta end;
+    true -> fun(Meta) -> keynew(line, Meta, Line) end
+  end,
 
-do_linify(Line, Key, Var, {Left, Right}) ->
-  {do_linify(Line, Key, Var, Left), do_linify(Line, Key, Var, Right)};
+  do_linify(Fun, Exprs, Var, Generated).
 
-do_linify(Line, Key, Var, List) when is_list(List) ->
-  [do_linify(Line, Key, Var, X) || X <- List];
+do_linify(Fun, {quote, Meta, [_ | _] = Args}, {Receiver, Counter} = Var, Gen)
+    when is_list(Meta) ->
+  NewMeta =
+    case keyfind(context, Meta) == {context, Receiver} of
+      true -> keynew(counter, Meta, Counter);
+      false -> Meta
+    end,
+  do_tuple_linify(Fun, NewMeta, quote, Args, Var, Gen);
 
-do_linify(_, _, _, Else) -> Else.
+do_linify(Fun, {Left, Meta, Receiver}, {Receiver, Counter} = Var, Gen)
+    when is_atom(Left), is_list(Meta), Left /= '_' ->
+  do_tuple_linify(Fun, keynew(counter, Meta, Counter), Left, Receiver, Var, Gen);
 
-do_tuple_linify(Line, Key, Var, Meta, Left, Right) ->
-  {do_linify(Line, Key, Var, Left),
-    do_linify_meta(Line, Key, Meta),
-    do_linify(Line, Key, Var, Right)}.
+do_linify(Fun, {Lexical, Meta, [_ | _] = Args}, {_, Counter} = Var, Gen)
+    when ?lexical(Lexical); Lexical == '__aliases__' ->
+  do_tuple_linify(Fun, keynew(counter, Meta, Counter), Lexical, Args, Var, Gen);
 
-do_linify_meta(0, line, Meta) ->
-  Meta;
-do_linify_meta(Line, line, Meta) ->
-  case keyfind(line, Meta) of
-    {line, Int} when is_integer(Int), Int /= 0 ->
-      Meta;
-    _ ->
-      keystore(line, Meta, Line)
-  end;
-do_linify_meta(Line, Key, Meta) ->
-  case keyfind(Key, Meta) of
-    {Key, Int} when is_integer(Int), Int /= 0 ->
-      keyreplace(Key, Meta, {line, Int});
-    _ ->
-      do_linify_meta(Line, line, Meta)
-  end.
+do_linify(Fun, {Left, Meta, Right}, Var, Gen) when is_list(Meta) ->
+  do_tuple_linify(Fun, Meta, Left, Right, Var, Gen);
 
-%% Some expressions cannot be unquoted at compilation time.
-%% This function is responsible for doing runtime unquoting.
-dot(Meta, Left, Right, Args, Context, File) ->
-  annotate(dot(Meta, Left, Right, Args), Context, File).
+do_linify(Fun, {Left, Right}, Var, Gen) ->
+  {do_linify(Fun, Left, Var, Gen), do_linify(Fun, Right, Var, Gen)};
 
-dot(Meta, Left, {'__aliases__', _, Args}, nil) ->
-  {'__aliases__', Meta, [Left|Args]};
+do_linify(Fun, List, Var, Gen) when is_list(List) ->
+  [do_linify(Fun, X, Var, Gen) || X <- List];
 
-dot(Meta, Left, Right, nil) when is_atom(Right) ->
-  case atom_to_list(Right) of
-    "Elixir." ++ _ ->
-      {'__aliases__', Meta, [Left, Right]};
-    _ ->
-      {{'.', Meta, [Left, Right]}, Meta, []}
-  end;
+do_linify(_, Else, _, _Gen) -> Else.
 
-dot(Meta, Left, {Right, _, Context}, nil) when is_atom(Right), is_atom(Context) ->
-  {{'.', Meta, [Left, Right]}, Meta, []};
+do_tuple_linify(Fun, Meta, Left, Right, Var, Gen) ->
+  {NewMeta, NewGen} =
+    case keyfind(stop_generated, Meta) of
+      {stop_generated, true} -> {keydelete(stop_generated, Meta), false};
+      _ when Gen -> {elixir_utils:generated(Meta), Gen};
+      _ -> {Meta, Gen}
+    end,
 
-dot(Meta, Left, {Right, _, Args}, nil) when is_atom(Right) ->
-  {{'.', Meta, [Left, Right]}, Meta, Args};
+  {do_linify(Fun, Left, Var, NewGen), Fun(NewMeta), do_linify(Fun, Right, Var, NewGen)}.
 
-dot(_Meta, _Left, Right, nil) ->
-  argument_error(<<"expected unquote after dot to return an atom, an alias or a quoted call, got: ",
-                   ('Elixir.Macro':to_string(Right))/binary>>);
+%% Escaping
 
-dot(Meta, Left, Right, Args) when is_atom(Right) ->
-  {{'.', Meta, [Left, Right]}, Meta, Args};
+%% Escapes the given expression. It is similar to quote, but
+%% lines are kept and hygiene mechanisms are disabled.
+escape(Expr, Op, Unquote) ->
+  try
+    do_quote(Expr, #elixir_quote{
+      line=true,
+      file=nil,
+      op=Op,
+      unquote=Unquote
+    })
+  catch
+    Kind:Reason:Stacktrace ->
+      Pruned = lists:dropwhile(fun
+        ({?MODULE, _, _, _}) -> true;
+        (_) -> false
+      end, Stacktrace),
+      erlang:raise(Kind, Reason, Pruned)
+  end.
 
-dot(Meta, Left, {Right, _, Context}, Args) when is_atom(Right), is_atom(Context) ->
-  {{'.', Meta, [Left, Right]}, Meta, Args};
+do_escape({Left, Meta, Right}, #elixir_quote{op=escape_and_prune} = Q) when is_list(Meta) ->
+  TM = [{K, V} || {K, V} <- Meta, (K == no_parens) orelse (K == line) orelse (K == delimiter)],
+  TL = do_quote(Left, Q),
+  TR = do_quote(Right, Q),
+  {'{}', [], [TL, TM, TR]};
+
+do_escape({Left, Right}, Q) ->
+  {do_quote(Left, Q), do_quote(Right, Q)};
+
+do_escape(Tuple, Q) when is_tuple(Tuple) ->
+  TT = do_quote(tuple_to_list(Tuple), Q),
+  {'{}', [], TT};
+
+do_escape(BitString, _) when is_bitstring(BitString) ->
+  case bit_size(BitString) rem 8 of
+    0 ->
+      BitString;
+    Size ->
+      <<Bits:Size, Bytes/binary>> = BitString,
+      {'<<>>', [], [{'::', [], [Bits, {size, [], [Size]}]}, {'::', [], [Bytes, {binary, [], nil}]}]}
+  end;
 
-dot(_Meta, _Left, Right, _Args) ->
-  argument_error(<<"expected unquote after dot with args to return an atom or a quoted call, got: ",
-                   ('Elixir.Macro':to_string(Right))/binary>>).
+do_escape(Map, Q) when is_map(Map) ->
+  maybe
+    #{'__struct__' := Module} ?= Map,
+    true ?= is_atom(Module),
+    % We never escape ourselves (it can only happen during Elixir bootstrapping)
+    true ?= (Q#elixir_quote.op /= {struct, Module}),
+    {module, Module} ?= code:ensure_loaded(Module),
+    true ?= erlang:function_exported(Module, '__escape__', 1),
+    case Q#elixir_quote.op of
+      {struct, _Module} ->
+        argument_error(<<('Elixir.Kernel':inspect(Module))/binary,
+          " defines custom escaping rules which are not supported in struct defaults",
+          (bad_escape_hint())/binary>>);
+
+      _ ->
+        Expr = Module:'__escape__'(Map),
+        case shallow_valid_ast(Expr) of
+          true -> Expr;
+          false -> argument_error(
+            <<('Elixir.Kernel':inspect(Module))/binary, ".__escape__/1 returned invalid AST: ", ('Elixir.Kernel':inspect(Expr))/binary>>
+          )
+        end
+    end
+  else
+    _ ->
+      TT = [
+        {do_quote(K, Q), do_quote(V, Q)}
+        || {K, V} <- lists:sort(maps:to_list(Map))
+      ],
+      {'%{}', [], TT}
+  end;
 
-list(Left, Right) when is_list(Right) ->
-  validate_list(Left),
-  Left ++ Right.
+do_escape([], _) ->
+  [];
+
+do_escape([H | T], #elixir_quote{unquote=false} = Q) ->
+  do_quote_simple_list(T, do_escape(H, Q), Q);
+
+do_escape([H | T], Q) ->
+  %% The improper case is inefficient, but improper lists are rare.
+  try lists:reverse(T, [H]) of
+    L -> do_quote_tail(L, Q)
+  catch
+    _:_ ->
+      {L, R} = reverse_improper(T, [H]),
+      TL = do_quote_splice(L, Q, [], []),
+      TR = do_quote(R, Q),
+      update_last(TL, fun(X) -> {'|', [], [X, TR]} end)
+  end;
 
-tail_list(Left, Right, Tail) when is_list(Right), is_list(Tail) ->
-  validate_list(Left),
-  Tail ++ Left ++ Right;
+do_escape(Other, _) when is_number(Other); is_atom(Other); is_pid(Other) ->
+  Other;
 
-tail_list(Left, Right, Tail) when is_list(Left) ->
-  validate_list(Left),
-  [H|T] = lists:reverse(Tail ++ Left),
-  lists:reverse([{'|', [], [H, Right]}|T]).
+do_escape(Fun, _) when is_function(Fun) ->
+  case (erlang:fun_info(Fun, env) == {env, []}) andalso
+       (erlang:fun_info(Fun, type) == {type, external}) of
+    true  -> fun_to_quoted(Fun);
+    false -> bad_escape(Fun)
+  end;
 
-validate_list(List) when is_list(List) ->
-  ok;
-validate_list(List) when not is_list(List) ->
-  argument_error(<<"expected a list with quoted expressions in unquote_splicing/1, got: ",
-                   ('Elixir.Kernel':inspect(List))/binary>>).
+do_escape(Other, _) ->
+  bad_escape(Other).
+
+bad_escape(Arg) ->
+  argument_error(<<"cannot escape ", ('Elixir.Kernel':inspect(Arg, []))/binary,
+                   (bad_escape_hint())/binary>>).
+
+bad_escape_hint() ->
+  <<". The supported values are: lists, tuples, maps, atoms, numbers, bitstrings, ",
+    "PIDs and remote functions in the format &Mod.fun/arity">>.
+
+%% Quote entry points
+
+build(Meta, Line, File, Context, Unquote, Generated, E) ->
+  Acc0 = [],
+  {VLine, Acc1} = validate_compile(Meta, line, Line, Acc0),
+  {VFile, Acc2} = validate_compile(Meta, file, File, Acc1),
+  {VContext, Acc3} = validate_compile(Meta, context, Context, Acc2),
+  validate_runtime(unquote, Unquote),
+  validate_runtime(generated, Generated),
+
+  Q = #elixir_quote{
+    op=quote,
+    aliases_hygiene=E,
+    imports_hygiene=E,
+    line=VLine,
+    file=VFile,
+    unquote=Unquote,
+    context=VContext,
+    generated=Generated,
+    shallow_validate=true
+  },
+
+  {Q, VContext, Acc3}.
+
+validate_compile(_Meta, line, Value, Acc) when is_boolean(Value) ->
+  {Value, Acc};
+validate_compile(_Meta, file, nil, Acc) ->
+  {nil, Acc};
+validate_compile(Meta, Key, Value, Acc) ->
+  case is_valid(Key, Value) of
+    true ->
+      {Value, Acc};
+    false ->
+      Var = {Key, Meta, ?MODULE},
+      Call = {{'.', Meta, [?MODULE, validate_runtime]}, Meta, [Key, Value]},
+      {Var, [{'=', Meta, [Var, Call]} | Acc]}
+  end.
 
-argument_error(Message) ->
-  error('Elixir.ArgumentError':exception([{message,Message}])).
+validate_runtime(Key, Value) ->
+  case is_valid(Key, Value) of
+    true ->
+      Value;
 
-%% Annotates the AST with context and other info
+    false ->
+      erlang:error(
+        'Elixir.ArgumentError':exception(
+          <<"invalid runtime value for option :", (erlang:atom_to_binary(Key))/binary,
+            " in quote, got: ", ('Elixir.Kernel':inspect(Value))/binary>>
+        )
+      )
+  end.
 
-annotate({Def, Meta, [{H, M, A}|T]}, Context, File) when ?defs(Def) ->
-  %% Store the context information in the first element of the
-  %% definition tuple so we can access it later on.
-  MM = keystore(context, keystore(file, M, File), Context),
-  {Def, Meta, [{H, MM, A}|T]};
-annotate({{'.', _, [_, Def]} = Target, Meta, [{H, M, A}|T]}, Context, File) when ?defs(Def) ->
-  MM = keystore(context, keystore(file, M, File), Context),
-  {Target, Meta, [{H, MM, A}|T]};
+is_valid(line, Line) -> is_integer(Line);
+is_valid(file, File) -> is_binary(File);
+is_valid(context, Context) -> is_atom(Context) andalso (Context /= nil);
+is_valid(generated, Generated) -> is_boolean(Generated);
+is_valid(unquote, Unquote) -> is_boolean(Unquote).
+
+shallow_validate_ast(Expr) ->
+  case shallow_valid_ast(Expr) of
+    true -> Expr;
+    false -> argument_error(
+      <<"tried to unquote invalid AST: ", ('Elixir.Kernel':inspect(Expr))/binary,
+        "\nDid you forget to escape term using Macro.escape/1?">>)
+  end.
 
-annotate({Lexical, Meta, [_|_] = Args}, Context, _File) when Lexical == import; Lexical == alias ->
-  NewMeta = keystore(context, keydelete(counter, Meta), Context),
-  {Lexical, NewMeta, Args};
-annotate(Tree, _Context, _File) -> Tree.
+shallow_valid_ast(Expr) when is_list(Expr) -> valid_ast_list(Expr);
+shallow_valid_ast(Expr) -> valid_ast_elem(Expr).
 
-%% Escapes the given expression. It is similar to quote, but
-%% lines are kept and hygiene mechanisms are disabled.
-escape(Expr, Unquote) ->
-  {Res, Q} = quote(Expr, nil, #elixir_quote{
-    line=true,
-    keep=false,
-    vars_hygiene=false,
-    aliases_hygiene=false,
-    imports_hygiene=false,
-    unquote=Unquote,
-    escape=true
- }, nil),
-  {Res, Q#elixir_quote.unquoted}.
+valid_ast_list([]) -> true;
+valid_ast_list([Head | Tail]) -> valid_ast_elem(Head) andalso valid_ast_list(Tail);
+valid_ast_list(_Improper) -> false.
 
-%% Quotes an expression and return its quoted Elixir AST.
+valid_ast_elem(Expr) when is_list(Expr); is_atom(Expr); is_binary(Expr); is_number(Expr); is_pid(Expr); is_function(Expr) -> true;
+valid_ast_elem({Left, Right}) -> valid_ast_elem(Left) andalso valid_ast_elem(Right);
+valid_ast_elem({Atom, Meta, Args}) when is_atom(Atom), is_list(Meta), is_atom(Args) orelse is_list(Args) -> true;
+valid_ast_elem({Call, Meta, Args}) when is_list(Meta), is_list(Args) -> shallow_valid_ast(Call);
+valid_ast_elem(_Term) -> false.
 
-quote(Expr, nil, Q, E) ->
-  do_quote(Expr, Q, E);
+quote({unquote_splicing, _, [_]}, #elixir_quote{unquote=true}) ->
+  argument_error(<<"unquote_splicing only works inside arguments and block contexts, "
+    "wrap it in parens if you want it to work with one-liners">>);
+quote(Expr, Q) ->
+  do_quote(Expr, Q).
 
-quote(Expr, Binding, Q, E) ->
-  Context = Q#elixir_quote.context,
+%% quote/unquote
 
-  Vars = [ {'{}', [],
-    [ '=', [], [
-      {'{}', [], [K, [], Context]},
-      V
-    ] ]
- } || {K, V} <- Binding],
+do_quote({quote, Meta, [Arg]}, Q) when is_list(Meta) ->
+  TArg = do_quote(Arg, Q#elixir_quote{unquote=false}),
 
-  {TExprs, TQ} = do_quote(Expr, Q, E),
-  {{'{}',[], ['__block__',[], Vars ++ [TExprs] ]}, TQ}.
+  NewMeta = case Q of
+    #elixir_quote{op=quote, context=Context} -> keystore(context, Meta, Context);
+    _ -> Meta
+  end,
 
-%% Actual quoting and helpers
+  {'{}', [], [quote, meta(NewMeta, Q), [TArg]]};
 
-do_quote({quote, _, Args} = Tuple, #elixir_quote{unquote=true} = Q, E) when length(Args) == 1; length(Args) == 2 ->
-  {TTuple, TQ} = do_quote_tuple(Tuple, Q#elixir_quote{unquote=false}, E),
-  {TTuple, TQ#elixir_quote{unquote=true}};
+do_quote({quote, Meta, [Opts, Arg]}, Q) when is_list(Meta) ->
+  TOpts = do_quote(Opts, Q),
+  TArg = do_quote(Arg, Q#elixir_quote{unquote=false}),
 
-do_quote({unquote, _Meta, [Expr]}, #elixir_quote{unquote=true} = Q, _) ->
-  {Expr, Q#elixir_quote{unquoted=true}};
+  NewMeta = case Q of
+    #elixir_quote{op=quote, context=Context} -> keystore(context, Meta, Context);
+    _ -> Meta
+  end,
+
+  {'{}', [], [quote, meta(NewMeta, Q), [TOpts, TArg]]};
+
+do_quote({unquote, Meta, [Expr]}, #elixir_quote{unquote=true, shallow_validate=Validate}) when is_list(Meta) ->
+  case Validate of
+    true -> {{'.', Meta, [?MODULE, shallow_validate_ast]}, Meta, [Expr]};
+    false -> Expr
+  end;
 
 %% Aliases
 
-do_quote({'__aliases__', Meta, [H|T]} = Alias, #elixir_quote{aliases_hygiene=true} = Q, E) when is_atom(H) and (H /= 'Elixir') ->
-  Annotation = case elixir_aliases:expand(Alias, ?m(E, aliases),
-                      ?m(E, macro_aliases), ?m(E, lexical_tracker)) of
-    Atom when is_atom(Atom) -> Atom;
-    Aliases when is_list(Aliases) -> false
-  end,
+do_quote({'__aliases__', Meta, [H | T]}, #elixir_quote{aliases_hygiene=(#{}=E)} = Q)
+     when is_list(Meta), is_atom(H), H /= 'Elixir' ->
+  Annotation =
+    case elixir_aliases:expand(Meta, [H | T], E, true) of
+      Atom when is_atom(Atom) -> Atom;
+      Aliases when is_list(Aliases) -> false
+    end,
   AliasMeta = keystore(alias, keydelete(counter, Meta), Annotation),
-  do_quote_tuple({'__aliases__', AliasMeta, [H|T]}, Q, E);
+  do_quote_tuple('__aliases__', AliasMeta, [H | T], Q);
 
 %% Vars
 
-do_quote({Left, Meta, nil}, #elixir_quote{vars_hygiene=true} = Q, E) when is_atom(Left) ->
-  do_quote_tuple({Left, Meta, Q#elixir_quote.context}, Q, E);
+do_quote({Name, Meta, nil}, #elixir_quote{op=quote} = Q)
+    when is_atom(Name), is_list(Meta) ->
+  ImportMeta = case Q#elixir_quote.imports_hygiene of
+    nil -> Meta;
+    E -> import_meta(Meta, Name, 0, Q, E)
+  end,
+
+  {'{}', [], [Name, meta(ImportMeta, Q), Q#elixir_quote.context]};
 
 %% Unquote
 
-do_quote({{{'.', Meta, [Left, unquote]}, _, [Expr]}, _, Args}, #elixir_quote{unquote=true} = Q, E) ->
-  do_quote_call(Left, Meta, Expr, Args, Q, E);
+do_quote({{{'.', Meta, [Left, unquote]}, _, [Expr]}, _, Args}, #elixir_quote{unquote=true} = Q) when is_list(Meta) ->
+  do_quote_call(Left, Meta, Expr, Args, Q);
 
-do_quote({{'.', Meta, [Left, unquote]}, _, [Expr]}, #elixir_quote{unquote=true} = Q, E) ->
-  do_quote_call(Left, Meta, Expr, nil, Q, E);
+do_quote({{'.', Meta, [Left, unquote]}, _, [Expr]}, #elixir_quote{unquote=true} = Q) when is_list(Meta) ->
+  do_quote_call(Left, Meta, Expr, nil, Q);
 
 %% Imports
 
 do_quote({'&', Meta, [{'/', _, [{F, _, C}, A]}] = Args},
-    #elixir_quote{imports_hygiene=true} = Q, E) when is_atom(F), is_integer(A), is_atom(C) ->
-  do_quote_fa('&', Meta, Args, F, A, Q, E);
+  #elixir_quote{imports_hygiene=(#{}=E)} = Q) when is_atom(F), is_integer(A), is_atom(C), is_list(Meta) ->
+  NewMeta =
+    case elixir_dispatch:find_import(Meta, F, A, E) of
+      false ->
+        Meta;
+
+      Receiver ->
+        keystore(context, keystore(imports, Meta, [{A, Receiver}]), Q#elixir_quote.context)
+    end,
+  do_quote_tuple('&', NewMeta, Args, Q);
 
-do_quote({Name, Meta, ArgsOrAtom}, #elixir_quote{imports_hygiene=true} = Q, E) when is_atom(Name) ->
-  Arity = case is_atom(ArgsOrAtom) of
-    true  -> 0;
-    false -> length(ArgsOrAtom)
+do_quote({Name, Meta, ArgsOrContext}, #elixir_quote{imports_hygiene=(#{}=E)} = Q)
+    when is_atom(Name), is_list(Meta), is_list(ArgsOrContext) or is_atom(ArgsOrContext) ->
+  Arity = if
+    is_atom(ArgsOrContext) -> 0;
+    true -> length(ArgsOrContext)
   end,
 
-  NewMeta = case (keyfind(import, Meta) == false) andalso
-      elixir_dispatch:find_import(Meta, Name, Arity, E) of
-    false ->
+  ImportMeta = import_meta(Meta, Name, Arity, Q, E),
+  Annotated = annotate({Name, ImportMeta, ArgsOrContext}, Q#elixir_quote.context),
+  do_quote_tuple(Annotated, Q);
+
+%% Two-element tuples
+
+do_quote({Left, Right}, #elixir_quote{unquote=true} = Q) when
+    is_tuple(Left)  andalso (element(1, Left) == unquote_splicing);
+    is_tuple(Right) andalso (element(1, Right) == unquote_splicing) ->
+  do_quote({'{}', [], [Left, Right]}, Q);
+
+do_quote({Left, Right}, Q) ->
+  TLeft  = do_quote(Left, Q),
+  TRight = do_quote(Right, Q),
+  {TLeft, TRight};
+
+%% Everything else
+
+do_quote(Other, #elixir_quote{op=Op} = Q) when Op =/= quote ->
+  do_escape(Other, Q);
+
+do_quote({_, _, _} = Tuple, Q) ->
+  Annotated = annotate(Tuple, Q#elixir_quote.context),
+  do_quote_tuple(Annotated, Q);
+
+do_quote([], _) ->
+  [];
+
+do_quote([H | T], #elixir_quote{unquote=false} = Q) ->
+  do_quote_simple_list(T, do_quote(H, Q), Q);
+
+do_quote([H | T], Q) ->
+  do_quote_tail(lists:reverse(T, [H]), Q);
+
+do_quote(Other, _) ->
+  Other.
+
+import_meta(Meta, Name, Arity, Q, E) ->
+  case (keyfind(imports, Meta) == false) andalso
+      elixir_dispatch:find_imports(Meta, Name, E) of
+    [_ | _] = Imports ->
+      trace_import_quoted(Imports, Meta, Name, E),
+      keystore(imports, keystore(context, Meta, Q#elixir_quote.context), Imports);
+
+    _ ->
       case (Arity == 1) andalso keyfind(ambiguous_op, Meta) of
         {ambiguous_op, nil} -> keystore(ambiguous_op, Meta, Q#elixir_quote.context);
         _ -> Meta
-      end;
-    Receiver ->
-      keystore(import, keystore(context, Meta, Q#elixir_quote.context), Receiver)
-  end,
+      end
+  end.
 
-  Annotated = annotate({Name, NewMeta, ArgsOrAtom}, Q#elixir_quote.context, file(E, Q)),
-  do_quote_tuple(Annotated, Q, E);
+trace_import_quoted([{Arity, Mod} | Imports], Meta, Name, E) ->
+  {Rest, Arities} = collect_trace_import_quoted(Imports, Mod, [], [Arity]),
+  elixir_env:trace({imported_quoted, Meta, Mod, Name, Arities}, E),
+  trace_import_quoted(Rest, Meta, Name, E);
+trace_import_quoted([], _Meta, _Name, _E) ->
+  ok.
+
+collect_trace_import_quoted([{Arity, Mod} | Imports], Mod, Acc, Arities) ->
+  collect_trace_import_quoted(Imports, Mod, Acc, [Arity | Arities]);
+collect_trace_import_quoted([Import | Imports], Mod, Acc, Arities) ->
+  collect_trace_import_quoted(Imports, Mod, [Import | Acc], Arities);
+collect_trace_import_quoted([], _Mod, Acc, Arities) ->
+  {lists:reverse(Acc), lists:reverse(Arities)}.
+
+%% do_quote_*
+
+do_quote_call(Left, Meta, Expr, Args, Q) ->
+  All  = [Left, {unquote, Meta, [Expr]}, Args, Q#elixir_quote.context],
+  TAll = [do_quote(X, Q) || X <- All],
+  {{'.', Meta, [elixir_quote, dot]}, Meta, [meta(Meta, Q) | TAll]}.
+
+do_quote_tuple({Left, Meta, Right}, Q) ->
+  do_quote_tuple(Left, Meta, Right, Q).
+
+do_quote_tuple(Left, Meta, Right, Q) ->
+  TLeft = do_quote(Left, Q),
+  TRight = do_quote(Right, Q),
+  {'{}', [], [TLeft, meta(Meta, Q), TRight]}.
+
+do_quote_simple_list([], Prev, _) -> [Prev];
+do_quote_simple_list([H | T], Prev, Q) ->
+  [Prev | do_quote_simple_list(T, do_quote(H, Q), Q)];
+do_quote_simple_list(Other, Prev, Q) ->
+  [{'|', [], [Prev, do_quote(Other, Q)]}].
+
+do_quote_tail([{'|', Meta, [{unquote_splicing, _, [Left]}, Right]} | T], #elixir_quote{unquote=true} = Q) ->
+  %% Process the remaining entries on the list.
+  %% For [1, 2, 3, unquote_splicing(arg) | tail], this will quote
+  %% 1, 2 and 3, which could even be unquotes.
+  TT = do_quote_splice(T, Q, [], []),
+  TR = do_quote(Right, Q),
+  do_runtime_list(Meta, tail_list, [Left, TR, TT]);
 
-do_quote({_, _, _} = Tuple, #elixir_quote{escape=false} = Q, E) ->
-  Annotated = annotate(Tuple, Q#elixir_quote.context, file(E, Q)),
-  do_quote_tuple(Annotated, Q, E);
+do_quote_tail(List, Q) ->
+  do_quote_splice(List, Q, [], []).
 
-%% Literals
+do_quote_splice([{unquote_splicing, Meta, [Expr]} | T], #elixir_quote{unquote=true} = Q, Buffer, Acc) ->
+  Runtime = do_runtime_list(Meta, list, [Expr, do_list_concat(Buffer, Acc)]),
+  do_quote_splice(T, Q, [], Runtime);
 
-do_quote({Left, Right}, #elixir_quote{unquote=true} = Q, E) when
-    is_tuple(Left)  andalso (element(1, Left) == unquote_splicing);
-    is_tuple(Right) andalso (element(1, Right) == unquote_splicing) ->
-  do_quote({'{}', [], [Left, Right]}, Q, E);
-
-do_quote({Left, Right}, Q, E) ->
-  {TLeft, LQ}  = do_quote(Left, Q, E),
-  {TRight, RQ} = do_quote(Right, LQ, E),
-  {{TLeft, TRight}, RQ};
-
-do_quote(Map, #elixir_quote{escape=true} = Q, E) when is_map(Map) ->
-  {TT, TQ} = do_quote(maps:to_list(Map), Q, E),
-  {{'%{}', [], TT}, TQ};
-
-do_quote(Tuple, #elixir_quote{escape=true} = Q, E) when is_tuple(Tuple) ->
-  {TT, TQ} = do_quote(tuple_to_list(Tuple), Q, E),
-  {{'{}', [], TT}, TQ};
-
-do_quote(List, #elixir_quote{escape=true} = Q, E) when is_list(List) ->
-  % The improper case is pretty inefficient, but improper lists are are.
-  case reverse_improper(List) of
-    {L}       -> do_splice(L, Q, E);
-    {L, R}    ->
-      {TL, QL} = do_splice(L, Q, E, [], []),
-      {TR, QR} = do_quote(R, QL, E),
-      {update_last(TL, fun(X) -> {'|', [], [X, TR]} end), QR}
+do_quote_splice([H | T], Q, Buffer, Acc) ->
+  TH = do_quote(H, Q),
+  do_quote_splice(T, Q, [TH | Buffer], Acc);
+
+do_quote_splice([], _Q, Buffer, Acc) ->
+  do_list_concat(Buffer, Acc).
+
+do_list_concat(Left, []) -> Left;
+do_list_concat([], Right) -> Right;
+do_list_concat(Left, Right) -> {{'.', [], [erlang, '++']}, [], [Left, Right]}.
+
+do_runtime_list(Meta, Fun, Args) ->
+  {{'.', Meta, [elixir_quote, Fun]}, Meta, Args}.
+
+%% Callbacks
+
+%% Some expressions cannot be unquoted at compilation time.
+%% This function is responsible for doing runtime unquoting.
+dot(Meta, Left, Right, Args, Context) ->
+  annotate(dot(Meta, Left, Right, Args), Context).
+
+dot(Meta, Left, {'__aliases__', _, Args}, nil) ->
+  {'__aliases__', Meta, [Left | Args]};
+
+dot(Meta, Left, Right, nil) when is_atom(Right) ->
+  case atom_to_list(Right) of
+    "Elixir." ++ _ ->
+      {'__aliases__', Meta, [Left, Right]};
+    _ ->
+      {{'.', Meta, [Left, Right]}, [{no_parens, true} | Meta], []}
   end;
-do_quote(List, Q, E) when is_list(List) ->
-    do_splice(lists:reverse(List), Q, E);
 
-do_quote(Other, Q, _) ->
-  {Other, Q}.
+dot(Meta, Left, {Right, _, Context}, nil) when is_atom(Right), is_atom(Context) ->
+  {{'.', Meta, [Left, Right]}, [{no_parens, true} | Meta], []};
 
-%% Quote helpers
+dot(Meta, Left, {Right, _, Args}, nil) when is_atom(Right) ->
+  {{'.', Meta, [Left, Right]}, Meta, Args};
 
-do_quote_call(Left, Meta, Expr, Args, Q, E) ->
-  All  = [meta(Meta, Q), Left, {unquote, Meta, [Expr]}, Args,
-          Q#elixir_quote.context, file(E, Q)],
-  {TAll, TQ} = lists:mapfoldl(fun(X, Acc) -> do_quote(X, Acc, E) end, Q, All),
-  {{{'.', Meta, [elixir_quote, dot]}, Meta, TAll}, TQ}.
+dot(_Meta, _Left, Right, nil) ->
+  argument_error(<<"expected unquote after dot to return an atom, an alias or a quoted call, got: ",
+                   ('Elixir.Macro':to_string(Right))/binary>>);
 
-do_quote_fa(Target, Meta, Args, F, A, Q, E) ->
-  NewMeta =
-    case (keyfind(import_fa, Meta) == false) andalso
-         elixir_dispatch:find_import(Meta, F, A, E) of
-      false    -> Meta;
-      Receiver -> keystore(import_fa, Meta, {Receiver, Q#elixir_quote.context})
-    end,
-  do_quote_tuple({Target, NewMeta, Args}, Q, E).
+dot(Meta, Left, Right, Args) when is_atom(Right) ->
+  {{'.', Meta, [Left, Right]}, Meta, Args};
 
-do_quote_tuple({Left, Meta, Right}, Q, E) ->
-  {TLeft, LQ}  = do_quote(Left, Q, E),
-  {TRight, RQ} = do_quote(Right, LQ, E),
-  {{'{}', [], [TLeft, meta(Meta, Q), TRight]}, RQ}.
+dot(Meta, Left, {Right, _, Context}, Args) when is_atom(Right), is_atom(Context) ->
+  {{'.', Meta, [Left, Right]}, Meta, Args};
 
-file(#{file := File}, #elixir_quote{keep=true}) -> File;
-file(_, _) -> nil.
+dot(_Meta, _Left, Right, _Args) ->
+  argument_error(<<"expected unquote after dot with args to return an atom or a quoted call, got: ",
+                   ('Elixir.Macro':to_string(Right))/binary>>).
+
+list(Left, Right) when is_list(Right) ->
+  validate_list(Left),
+  Left ++ Right.
+
+tail_list(Left, Right, Tail) when is_list(Right), is_list(Tail) ->
+  validate_list(Left),
+  Tail ++ Left ++ Right;
+
+tail_list(Left, Right, Tail) when is_list(Left) ->
+  validate_list(Left),
+  [H | T] = lists:reverse(Tail ++ Left),
+  lists:reverse([{'|', [], [H, Right]} | T]).
+
+validate_list(List) ->
+  case valid_ast_list(List) of
+    true -> ok;
+    false -> argument_error(<<"expected a list with quoted expressions in unquote_splicing/1, got: ",
+                   ('Elixir.Kernel':inspect(List))/binary>>)
+  end.
+
+argument_error(Message) ->
+  error('Elixir.ArgumentError':exception([{message, Message}])).
 
-meta(Meta, #elixir_quote{keep=true}) ->
-  [case KV of {line, V} -> {keep, V}; _ -> KV end || KV <- Meta];
-meta(Meta, #elixir_quote{line=true}) ->
+%% Helpers
+
+meta(Meta, #elixir_quote{op=quote} = Q) ->
+  generated(keep(keydelete(column, Meta), Q), Q);
+meta(Meta, Q) ->
+  do_quote(Meta, Q).
+
+generated(Meta, #elixir_quote{generated=true}) -> [{generated, true} | Meta];
+generated(Meta, #elixir_quote{generated=false}) -> Meta.
+
+keep(Meta, #elixir_quote{file=nil, line=Line}) ->
+  line(Meta, Line);
+keep(Meta, #elixir_quote{file=File, line=true}) ->
+  case lists:keytake(line, 1, Meta) of
+    {value, {line, Line}, MetaNoLine} ->
+      [{keep, {File, Line}} | MetaNoLine];
+    false ->
+      [{keep, {File, 0}} | Meta]
+  end;
+keep(Meta, #elixir_quote{file=File, line=false}) ->
+  [{keep, {File, 0}} | keydelete(line, Meta)];
+keep(Meta, #elixir_quote{file=File, line=Line}) ->
+  [{keep, {File, Line}} | keydelete(line, Meta)].
+
+line(Meta, true) ->
   Meta;
-meta(Meta, #elixir_quote{line=false}) ->
+line(Meta, false) ->
   keydelete(line, Meta);
-meta(Meta, #elixir_quote{line=Line}) ->
+line(Meta, Line) ->
   keystore(line, Meta, Line).
 
-reverse_improper(L) -> reverse_improper(L, []).
-reverse_improper([], Acc) -> {Acc};
-reverse_improper([H|T], Acc) when is_list(T) -> reverse_improper(T, [H|Acc]);
-reverse_improper([H|T], Acc) -> {[H|Acc], T}.
+reverse_improper([H | T], Acc) -> reverse_improper(T, [H | Acc]);
+reverse_improper([], Acc) -> Acc;
+reverse_improper(T, Acc) -> {Acc, T}.
 
 update_last([], _) -> [];
 update_last([H], F) -> [F(H)];
-update_last([H|T], F) -> [H|update_last(T,F)].
+update_last([H | T], F) -> [H | update_last(T, F)].
 
 keyfind(Key, Meta) ->
   lists:keyfind(Key, 1, Meta).
@@ -314,42 +643,31 @@ keystore(_Key, Meta, nil) ->
   Meta;
 keystore(Key, Meta, Value) ->
   lists:keystore(Key, 1, Meta, {Key, Value}).
-keyreplace(Key, Meta, {Key, _V}) ->
-  Meta;
-keyreplace(Key, Meta, Tuple) ->
-  lists:keyreplace(Key, 1, Meta, Tuple).
 keynew(Key, Meta, Value) ->
-  case keyfind(Key, Meta) of
-    {Key, _} -> Meta;
-    _ -> keystore(Key, Meta, Value)
+  case lists:keymember(Key, 1, Meta) of
+    true -> Meta;
+    false -> [{Key, Value} | Meta]
   end.
 
-%% Quote splicing
-
-do_splice([{'|', Meta, [{unquote_splicing, _, [Left]}, Right]}|T], #elixir_quote{unquote=true} = Q, E) ->
-  %% Process the remaining entries on the list.
-  %% For [1, 2, 3, unquote_splicing(arg)|tail], this will quote
-  %% 1, 2 and 3, which could even be unquotes.
-  {TT, QT} = do_splice(T, Q, E, [], []),
-  {TR, QR} = do_quote(Right, QT, E),
-  {do_runtime_list(Meta, tail_list, [Left, TR, TT]), QR#elixir_quote{unquoted=true}};
-
-do_splice(List, Q, E) ->
-  do_splice(List, Q, E, [], []).
-
-do_splice([{unquote_splicing, Meta, [Expr]}|T], #elixir_quote{unquote=true} = Q, E, Buffer, Acc) ->
-  do_splice(T, Q#elixir_quote{unquoted=true}, E, [], do_runtime_list(Meta, list, [Expr, do_join(Buffer, Acc)]));
-
-do_splice([H|T], Q, E, Buffer, Acc) ->
-  {TH, TQ} = do_quote(H, Q, E),
-  do_splice(T, TQ, E, [TH|Buffer], Acc);
-
-do_splice([], Q, _E, Buffer, Acc) ->
-  {do_join(Buffer, Acc), Q}.
-
-do_join(Left, [])    -> Left;
-do_join([], Right)   -> Right;
-do_join(Left, Right) -> {{'.', [], [erlang, '++']}, [], [Left, Right]}.
-
-do_runtime_list(Meta, Fun, Args) ->
-  {{'.', Meta, [elixir_quote, Fun]}, Meta, Args}.
+%% Annotates the AST with context and other info.
+%%
+%% Note we need to delete the counter because linify
+%% adds the counter recursively, even inside quoted
+%% expressions, so we need to clean up the forms to
+%% allow them to get a new counter on the next expansion.
+
+annotate({Def, Meta, [H | T]}, Context) when ?defs(Def) ->
+  {Def, Meta, [annotate_def(H, Context) | T]};
+annotate({{'.', _, [_, Def]} = Target, Meta, [H | T]}, Context) when ?defs(Def) ->
+  {Target, Meta, [annotate_def(H, Context) | T]};
+annotate({Lexical, Meta, [_ | _] = Args}, Context) when ?lexical(Lexical) ->
+  NewMeta = keystore(context, keydelete(counter, Meta), Context),
+  {Lexical, NewMeta, Args};
+annotate(Tree, _Context) -> Tree.
+
+annotate_def({'when', Meta, [Left, Right]}, Context) ->
+  {'when', Meta, [annotate_def(Left, Context), Right]};
+annotate_def({Fun, Meta, Args}, Context) ->
+  {Fun, keystore(context, Meta, Context), Args};
+annotate_def(Other, _Context) ->
+  Other.
diff --git a/lib/elixir/src/elixir_rewrite.erl b/lib/elixir/src/elixir_rewrite.erl
new file mode 100644
index 00000000000..697a1b9170c
--- /dev/null
+++ b/lib/elixir/src/elixir_rewrite.erl
@@ -0,0 +1,386 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
+-module(elixir_rewrite).
+-compile({inline, [inner_inline/4, inner_rewrite/5]}).
+-compile(nowarn_shadow_vars).
+-export([erl_to_ex/3, inline/3, rewrite/5, match/6, guard/6, format_error/1]).
+-include("elixir.hrl").
+
+%% Convenience variables
+
+-define(atom, 'Elixir.Atom').
+-define(bitwise, 'Elixir.Bitwise').
+-define(enum, 'Elixir.Enum').
+-define(float, 'Elixir.Float').
+-define(function, 'Elixir.Function').
+-define(integer, 'Elixir.Integer').
+-define(io, 'Elixir.IO').
+-define(kernel, 'Elixir.Kernel').
+-define(list, 'Elixir.List').
+-define(map, 'Elixir.Map').
+-define(node, 'Elixir.Node').
+-define(port, 'Elixir.Port').
+-define(process, 'Elixir.Process').
+-define(string, 'Elixir.String').
+-define(string_chars, 'Elixir.String.Chars').
+-define(system, 'Elixir.System').
+-define(tuple, 'Elixir.Tuple').
+
+% Macros used to define inline and rewrite rules.
+% Defines the rules from Elixir function to Erlang function
+% and the reverse, rewrites that are not reversible or have
+% complex rules are defined without the macros.
+-define(
+  inline(ExMod, ExFun, Arity, ErlMod, ErlFun),
+  inner_inline(ex_to_erl, ExMod, ExFun, Arity) -> {ErlMod, ErlFun};
+  inner_inline(erl_to_ex, ErlMod, ErlFun, Arity) -> {ExMod, ExFun}
+).
+
+-define(
+  rewrite(ExMod, ExFun, ExArgs, ErlMod, ErlFun, ErlArgs),
+  inner_rewrite(ex_to_erl, _Meta, ExMod, ExFun, ExArgs) -> {ErlMod, ErlFun, ErlArgs};
+  inner_rewrite(erl_to_ex, _Meta, ErlMod, ErlFun, ErlArgs) -> {ExMod, ExFun, ExArgs, fun(ErlArgs) -> ExArgs end}
+).
+
+erl_to_ex(Mod, Fun, Args) when is_list(Args) ->
+  case inner_inline(erl_to_ex, Mod, Fun, length(Args)) of
+    false -> inner_rewrite(erl_to_ex, [], Mod, Fun, Args);
+    {ExMod, ExFun} -> {ExMod, ExFun, Args, fun identity/1}
+  end;
+
+erl_to_ex(Mod, Fun, Arity) when is_integer(Arity) ->
+  inner_inline(erl_to_ex, Mod, Fun, Arity).
+
+%% Inline rules
+%%
+%% Inline rules are straightforward, they keep the same
+%% number and order of arguments and show up on captures.
+inline(Mod, Fun, Arity) -> inner_inline(ex_to_erl, Mod, Fun, Arity).
+
+?inline(?atom, to_charlist, 1, erlang, atom_to_list);
+?inline(?atom, to_string, 1, erlang, atom_to_binary);
+
+?inline(?bitwise, 'bnot', 1, erlang, 'bnot');
+?inline(?bitwise, 'band', 2, erlang, 'band');
+?inline(?bitwise, 'bor', 2, erlang, 'bor');
+?inline(?bitwise, 'bxor', 2, erlang, 'bxor');
+?inline(?bitwise, 'bsl', 2, erlang, 'bsl');
+?inline(?bitwise, 'bsr', 2, erlang, 'bsr');
+
+?inline(?function, capture, 3, erlang, make_fun);
+?inline(?function, info, 1, erlang, fun_info);
+?inline(?function, info, 2, erlang, fun_info);
+
+?inline(?integer, to_charlist, 1, erlang, integer_to_list);
+?inline(?integer, to_charlist, 2, erlang, integer_to_list);
+?inline(?integer, to_string, 1, erlang, integer_to_binary);
+?inline(?integer, to_string, 2, erlang, integer_to_binary);
+
+?inline(?io, iodata_length, 1, erlang, iolist_size);
+?inline(?io, iodata_to_binary, 1, erlang, iolist_to_binary);
+
+?inline(?kernel, '!=', 2, erlang, '/=');
+?inline(?kernel, '!==', 2, erlang, '=/=');
+?inline(?kernel, '*', 2, erlang, '*');
+?inline(?kernel, '+', 1, erlang, '+');
+?inline(?kernel, '+', 2, erlang, '+');
+?inline(?kernel, '++', 2, erlang, '++');
+?inline(?kernel, '-', 1, erlang, '-');
+?inline(?kernel, '-', 2, erlang, '-');
+?inline(?kernel, '--', 2, erlang, '--');
+?inline(?kernel, '/', 2, erlang, '/');
+?inline(?kernel, '<', 2, erlang, '<');
+?inline(?kernel, '<=', 2, erlang, '=<');
+?inline(?kernel, '==', 2, erlang, '==');
+?inline(?kernel, '===', 2, erlang, '=:=');
+?inline(?kernel, '>', 2, erlang, '>');
+?inline(?kernel, '>=', 2, erlang, '>=');
+?inline(?kernel, abs, 1, erlang, abs);
+?inline(?kernel, apply, 2, erlang, apply);
+?inline(?kernel, apply, 3, erlang, apply);
+?inline(?kernel, binary_part, 3, erlang, binary_part);
+?inline(?kernel, bit_size, 1, erlang, bit_size);
+?inline(?kernel, byte_size, 1, erlang, byte_size);
+?inline(?kernel, ceil, 1, erlang, ceil);
+?inline(?kernel, 'div', 2, erlang, 'div');
+?inline(?kernel, exit, 1, erlang, exit);
+?inline(?kernel, floor, 1, erlang, floor);
+?inline(?kernel, 'function_exported?', 3, erlang, function_exported);
+?inline(?kernel, hd, 1, erlang, hd);
+?inline(?kernel, is_atom, 1, erlang, is_atom);
+?inline(?kernel, is_binary, 1, erlang, is_binary);
+?inline(?kernel, is_bitstring, 1, erlang, is_bitstring);
+?inline(?kernel, is_boolean, 1, erlang, is_boolean);
+?inline(?kernel, is_float, 1, erlang, is_float);
+?inline(?kernel, is_function, 1, erlang, is_function);
+?inline(?kernel, is_function, 2, erlang, is_function);
+?inline(?kernel, is_integer, 1, erlang, is_integer);
+?inline(?kernel, is_list, 1, erlang, is_list);
+?inline(?kernel, is_map, 1, erlang, is_map);
+?inline(?kernel, is_number, 1, erlang, is_number);
+?inline(?kernel, is_pid, 1, erlang, is_pid);
+?inline(?kernel, is_port, 1, erlang, is_port);
+?inline(?kernel, is_reference, 1, erlang, is_reference);
+?inline(?kernel, is_tuple, 1, erlang, is_tuple);
+?inline(?kernel, length, 1, erlang, length);
+?inline(?kernel, make_ref, 0, erlang, make_ref);
+?inline(?kernel, map_size, 1, erlang, map_size);
+?inline(?kernel, max, 2, erlang, max);
+?inline(?kernel, min, 2, erlang, min);
+?inline(?kernel, node, 0, erlang, node);
+?inline(?kernel, node, 1, erlang, node);
+?inline(?kernel, 'not', 1, erlang, 'not');
+?inline(?kernel, 'rem', 2, erlang, 'rem');
+?inline(?kernel, round, 1, erlang, round);
+?inline(?kernel, self, 0, erlang, self);
+?inline(?kernel, send, 2, erlang, send);
+?inline(?kernel, spawn, 1, erlang, spawn);
+?inline(?kernel, spawn, 3, erlang, spawn);
+?inline(?kernel, spawn_link, 1, erlang, spawn_link);
+?inline(?kernel, spawn_link, 3, erlang, spawn_link);
+?inline(?kernel, spawn_monitor, 1, erlang, spawn_monitor);
+?inline(?kernel, spawn_monitor, 3, erlang, spawn_monitor);
+?inline(?kernel, throw, 1, erlang, throw);
+?inline(?kernel, tl, 1, erlang, tl);
+?inline(?kernel, trunc, 1, erlang, trunc);
+?inline(?kernel, tuple_size, 1, erlang, tuple_size);
+
+?inline(?list, to_atom, 1, erlang, list_to_atom);
+?inline(?list, to_existing_atom, 1, erlang, list_to_existing_atom);
+?inline(?list, to_float, 1, erlang, list_to_float);
+?inline(?list, to_integer, 1, erlang, list_to_integer);
+?inline(?list, to_integer, 2, erlang, list_to_integer);
+?inline(?list, to_tuple, 1, erlang, list_to_tuple);
+
+?inline(?map, from_keys, 2, maps, from_keys);
+?inline(?map, intersect, 2, maps, intersect);
+?inline(?map, keys, 1, maps, keys);
+?inline(?map, merge, 2, maps, merge);
+?inline(?map, to_list, 1, maps, to_list);
+?inline(?map, values, 1, maps, values);
+
+?inline(?node, list, 0, erlang, nodes);
+?inline(?node, list, 1, erlang, nodes);
+?inline(?node, spawn, 2, erlang, spawn);
+?inline(?node, spawn, 3, erlang, spawn_opt);
+?inline(?node, spawn, 4, erlang, spawn);
+?inline(?node, spawn, 5, erlang, spawn_opt);
+?inline(?node, spawn_link, 2, erlang, spawn_link);
+?inline(?node, spawn_link, 4, erlang, spawn_link);
+?inline(?node, spawn_monitor, 2, erlang, spawn_monitor);
+?inline(?node, spawn_monitor, 4, erlang, spawn_monitor);
+
+?inline(?port, close, 1, erlang, port_close);
+?inline(?port, command, 2, erlang, port_command);
+?inline(?port, command, 3, erlang, port_command);
+?inline(?port, connect, 2, erlang, port_connect);
+?inline(?port, list, 0, erlang, ports);
+?inline(?port, open, 2, erlang, open_port);
+
+?inline(?process, alias, 0, erlang, alias);
+?inline(?process, alias, 1, erlang, alias);
+?inline(?process, 'alive?', 1, erlang, is_process_alive);
+?inline(?process, cancel_timer, 1, erlang, cancel_timer);
+?inline(?process, cancel_timer, 2, erlang, cancel_timer);
+?inline(?process, demonitor, 1, erlang, demonitor);
+?inline(?process, demonitor, 2, erlang, demonitor);
+?inline(?process, exit, 2, erlang, exit);
+?inline(?process, flag, 2, erlang, process_flag);
+?inline(?process, flag, 3, erlang, process_flag);
+?inline(?process, get, 0, erlang, get);
+?inline(?process, get_keys, 0, erlang, get_keys);
+?inline(?process, get_keys, 1, erlang, get_keys);
+?inline(?process, group_leader, 0, erlang, group_leader);
+?inline(?process, hibernate, 3, erlang, hibernate);
+?inline(?process, link, 1, erlang, link);
+?inline(?process, list, 0, erlang, processes);
+?inline(?process, read_timer, 1, erlang, read_timer);
+?inline(?process, registered, 0, erlang, registered);
+?inline(?process, send, 3, erlang, send);
+?inline(?process, spawn, 2, erlang, spawn_opt);
+?inline(?process, spawn, 4, erlang, spawn_opt);
+?inline(?process, unalias, 1, erlang, unalias);
+?inline(?process, unlink, 1, erlang, unlink);
+?inline(?process, unregister, 1, erlang, unregister);
+
+?inline(?string, duplicate, 2, binary, copy);
+?inline(?string, to_atom, 1, erlang, binary_to_atom);
+?inline(?string, to_existing_atom, 1, erlang, binary_to_existing_atom);
+?inline(?string, to_float, 1, erlang, binary_to_float);
+?inline(?string, to_integer, 1, erlang, binary_to_integer);
+?inline(?string, to_integer, 2, erlang, binary_to_integer);
+
+?inline(?system, monotonic_time, 0, erlang, monotonic_time);
+?inline(?system, os_time, 0, os, system_time);
+?inline(?system, system_time, 0, erlang, system_time);
+?inline(?system, time_offset, 0, erlang, time_offset);
+?inline(?system, unique_integer, 0, erlang, unique_integer);
+?inline(?system, unique_integer, 1, erlang, unique_integer);
+?inline(?tuple, to_list, 1, erlang, tuple_to_list);
+
+% Defined without macro to avoid conflict with Bitwise named operators
+inner_inline(ex_to_erl, ?bitwise, '~~~', 1) -> {erlang, 'bnot'};
+inner_inline(ex_to_erl, ?bitwise, '&&&', 2) -> {erlang, 'band'};
+inner_inline(ex_to_erl, ?bitwise, '|||', 2) -> {erlang, 'bor'};
+inner_inline(ex_to_erl, ?bitwise, '^^^', 2) -> {erlang, 'bxor'};
+inner_inline(ex_to_erl, ?bitwise, '<<<', 2) -> {erlang, 'bsl'};
+inner_inline(ex_to_erl, ?bitwise, '>>>', 2) -> {erlang, 'bsr'};
+
+% Defined without macro to avoid conflict with Process.demonitor
+inner_inline(ex_to_erl, ?port, demonitor, 1) -> {erlang, demonitor};
+inner_inline(ex_to_erl, ?port, demonitor, 2) -> {erlang, demonitor};
+
+inner_inline(_, _, _, _) -> false.
+
+%% Rewrite rules
+%%
+%% Rewrite rules are more complex than regular inlining code
+%% as they may change the number of arguments. However, they
+%% don't add new code (such as case expressions), at best they
+%% perform dead code removal.
+rewrite(?string_chars, DotMeta, to_string, Meta, [Arg]) ->
+  case is_always_string(Arg) of
+    true -> Arg;
+    false -> {{'.', DotMeta, [?string_chars, to_string]}, Meta, [Arg]}
+  end;
+rewrite(erlang, _, '+', _, [Arg]) when is_number(Arg) -> +Arg;
+rewrite(erlang, _, '-', _, [Arg]) when is_number(Arg) -> -Arg;
+rewrite(Receiver, DotMeta, Right, Meta, Args) ->
+  {EReceiver, ERight, EArgs} = inner_rewrite(ex_to_erl, DotMeta, Receiver, Right, Args),
+  {{'.', DotMeta, [EReceiver, ERight]}, Meta, EArgs}.
+
+?rewrite(?float, to_charlist, [Arg], erlang, float_to_list, [Arg, [short]]);
+?rewrite(?float, to_string, [Arg], erlang, float_to_binary, [Arg, [short]]);
+?rewrite(?kernel, is_map_key, [Map, Key], erlang, is_map_key, [Key, Map]);
+?rewrite(?map, delete, [Map, Key], maps, remove, [Key, Map]);
+?rewrite(?map, fetch, [Map, Key], maps, find, [Key, Map]);
+?rewrite(?map, 'fetch!', [Map, Key], maps, get, [Key, Map]);
+?rewrite(?map, 'has_key?', [Map, Key], maps, is_key, [Key, Map]);
+?rewrite(?map, put, [Map, Key, Value], maps, put, [Key, Value, Map]);
+?rewrite(?map, 'replace!', [Map, Key, Value], maps, update, [Key, Value, Map]);
+?rewrite(?port, monitor, [Arg], erlang, monitor, [port, Arg]);
+?rewrite(?process, group_leader, [Pid, Leader], erlang, group_leader, [Leader, Pid]);
+?rewrite(?process, monitor, [Arg], erlang, monitor, [process, Arg]);
+?rewrite(?process, monitor, [Arg, Opts], erlang, monitor, [process, Arg, Opts]);
+?rewrite(?process, send_after, [Dest, Msg, Time], erlang, send_after, [Time, Dest, Msg]);
+?rewrite(?process, send_after, [Dest, Msg, Time, Opts], erlang, send_after, [Time, Dest, Msg, Opts]);
+?rewrite(?tuple, duplicate, [Data, Size], erlang, make_tuple, [Size, Data]);
+
+inner_rewrite(ex_to_erl, Meta, ?tuple, delete_at, [Tuple, Index]) ->
+  {erlang, delete_element, [increment(Meta, Index), Tuple]};
+inner_rewrite(ex_to_erl, Meta, ?tuple, insert_at, [Tuple, Index, Term]) ->
+  {erlang, insert_element, [increment(Meta, Index), Tuple, Term]};
+inner_rewrite(ex_to_erl, Meta, ?kernel, elem, [Tuple, Index]) ->
+  {erlang, element, [increment(Meta, Index), Tuple]};
+inner_rewrite(ex_to_erl, Meta, ?kernel, put_elem, [Tuple, Index, Value]) ->
+  {erlang, setelement, [increment(Meta, Index), Tuple, Value]};
+
+inner_rewrite(erl_to_ex, _Meta, erlang, delete_element, [Index, Tuple]) when is_number(Index) ->
+  {?tuple, delete_at, [Tuple, Index - 1], fun([Index, Tuple]) -> [Tuple, Index] end};
+inner_rewrite(erl_to_ex, _Meta, erlang, insert_element, [Index, Tuple, Term]) when is_number(Index) ->
+  {?tuple, insert_at, [Tuple, Index - 1, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};
+inner_rewrite(erl_to_ex, _Meta, erlang, element, [Index, Tuple]) when is_number(Index) ->
+  {?kernel, elem, [Tuple, Index - 1], fun([Index, Tuple]) -> [Tuple, Index] end};
+inner_rewrite(erl_to_ex, _Meta, erlang, setelement, [Index, Tuple, Term]) when is_number(Index) ->
+  {?kernel, put_elem, [Tuple, Index - 1, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};
+
+inner_rewrite(erl_to_ex, _Meta, erlang, delete_element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple]) ->
+  {?tuple, delete_at, [Tuple, Index], fun([Index, Tuple]) -> [Tuple, Index] end};
+inner_rewrite(erl_to_ex, _Meta, erlang, insert_element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Term]) ->
+  {?tuple, insert_at, [Tuple, Index, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};
+inner_rewrite(erl_to_ex, _Meta, erlang, element, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple]) ->
+  {?kernel, elem, [Tuple, Index], fun([Index, Tuple]) -> [Tuple, Index] end};
+inner_rewrite(erl_to_ex, _Meta, erlang, setelement, [{{'.', _, [erlang, '+']}, _, [Index, 1]}, Tuple, Term]) ->
+  {?kernel, put_elem, [Tuple, Index, Term], fun([Index, Tuple, Term]) -> [Tuple, Index, Term] end};
+
+inner_rewrite(erl_to_ex, _Meta, erlang, 'orelse', [_, _] = Args) ->
+  {?kernel, 'or', Args, fun identity/1};
+inner_rewrite(erl_to_ex, _Meta, erlang, 'andalso', [_, _] = Args) ->
+  {?kernel, 'and', Args, fun identity/1};
+
+inner_rewrite(ex_to_erl, _Meta, Mod, Fun, Args) -> {Mod, Fun, Args};
+inner_rewrite(erl_to_ex, _Meta, Mod, Fun, Args) -> {Mod, Fun, Args, fun identity/1}.
+
+identity(Arg) -> Arg.
+
+increment(_Meta, Number) when is_number(Number) ->
+  Number + 1;
+increment(Meta, Other) ->
+  {{'.', Meta, [erlang, '+']}, Meta, [Other, 1]}.
+
+%% Match rewrite
+%%
+%% Match rewrite is similar to regular rewrite, except
+%% it also verifies the rewrite rule applies in a match context.
+%% The allowed operations are very limited.
+%% The Kernel operators are already inlined by now, we only need to
+%% care about Erlang ones.
+match(erlang, _, '++', Meta, [Left, Right], _S) ->
+  try {ok, static_append(Left, Right, Meta)}
+  catch impossible -> {error, {invalid_match_append, Left}}
+  end;
+match(Receiver, _, Right, _, Args, _S) ->
+  {error, {invalid_match, Receiver, Right, length(Args)}}.
+
+static_append([], Right, _Meta) -> Right;
+static_append([{'|', InnerMeta, [Head, Tail]}], Right, Meta) when is_list(Tail) ->
+  [{'|', InnerMeta, [Head, static_append(Tail, Right, Meta)]}];
+static_append([{'|', _, [_, _]}], _, _) -> throw(impossible);
+static_append([Last], Right, Meta) -> [{'|', Meta, [Last, Right]}];
+static_append([Head | Tail], Right, Meta) -> [Head | static_append(Tail, Right, Meta)];
+static_append(_, _, _) -> throw(impossible).
+
+%% Guard rewrite
+%%
+%% Guard rewrite is similar to regular rewrite, except
+%% it also verifies the resulting function is supported in
+%% guard context - only certain BIFs and operators are.
+guard(Receiver, DotMeta, Right, Meta, Args, S) ->
+  case inner_rewrite(ex_to_erl, DotMeta, Receiver, Right, Args) of
+    {erlang, RRight, RArgs} ->
+      case allowed_guard(RRight, length(RArgs)) of
+        true -> {ok, {{'.', DotMeta, [erlang, RRight]}, Meta, RArgs}};
+        false -> {error, {invalid_guard, Receiver, Right, length(Args), elixir_utils:guard_info(S)}}
+      end;
+    _ -> {error, {invalid_guard, Receiver, Right, length(Args), elixir_utils:guard_info(S)}}
+  end.
+
+%% erlang:is_record/2-3 are compiler guards in Erlang which we
+%% need to explicitly forbid as they are allowed in erl_internal.
+allowed_guard(is_record, 2) -> false;
+allowed_guard(is_record, 3) -> false;
+allowed_guard(Right, Arity) ->
+  erl_internal:guard_bif(Right, Arity) orelse elixir_utils:guard_op(Right, Arity).
+
+format_error({invalid_guard, Receiver, Right, Arity, Context}) ->
+  io_lib:format(cannot_invoke_or_maybe_require(Receiver, Right, Arity) ++ " ~ts.~ts/~B inside a ~ts",
+                ['Elixir.Macro':to_string(Receiver), Right, Arity, Context]);
+format_error({invalid_match, Receiver, Right, Arity}) ->
+  io_lib:format(cannot_invoke_or_maybe_require(Receiver, Right, Arity) ++ " ~ts.~ts/~B inside a match",
+                ['Elixir.Macro':to_string(Receiver), Right, Arity]);
+format_error({invalid_match_append, Arg}) ->
+  io_lib:format("invalid argument for ++ operator inside a match, expected a literal proper list, got: ~ts",
+                ['Elixir.Macro':to_string(Arg)]).
+
+cannot_invoke_or_maybe_require(Receiver, Fun, Arity) ->
+  try
+    true = lists:member({Fun, Arity}, Receiver:'__info__'(macros)),
+    ["you must require the module", 'Elixir.Macro':to_string(Receiver), " before invoking macro"]
+  catch
+    _:_ -> "cannot invoke remote function"
+  end.
+
+is_always_string({{'.', _, [Module, Function]}, _, Args}) ->
+  is_always_string(Module, Function, length(Args));
+is_always_string(Ast) ->
+  is_binary(Ast).
+
+is_always_string('Elixir.Enum', join, _) -> true;
+is_always_string('Elixir.Enum', map_join, _) -> true;
+is_always_string('Elixir.Kernel', inspect, _) -> true;
+is_always_string('Elixir.Macro', to_string, _) -> true;
+is_always_string('Elixir.String.Chars', to_string, _) -> true;
+is_always_string('Elixir.Path', join, _) -> true;
+is_always_string(_Module, _Function, _Args) -> false.
diff --git a/lib/elixir/src/elixir_scope.erl b/lib/elixir/src/elixir_scope.erl
deleted file mode 100644
index c9f02e3dd0f..00000000000
--- a/lib/elixir/src/elixir_scope.erl
+++ /dev/null
@@ -1,140 +0,0 @@
-%% Convenience functions used to manipulate scope and its variables.
--module(elixir_scope).
--export([translate_var/4, build_var/2,
-  load_binding/2, dump_binding/2,
-  mergev/2, mergec/2, mergef/2,
-  merge_vars/2, merge_opt_vars/2
-]).
--include("elixir.hrl").
-
-%% VAR HANDLING
-
-translate_var(Meta, Name, Kind, S) when is_atom(Kind); is_integer(Kind) ->
-  Line  = ?line(Meta),
-  Tuple = {Name, Kind},
-  Vars  = S#elixir_scope.vars,
-
-  case orddict:find({Name, Kind}, Vars) of
-    {ok, {Current, _}} -> Exists = true;
-    error -> Current = nil, Exists = false
-  end,
-
-  case S#elixir_scope.context of
-    match ->
-      MatchVars = S#elixir_scope.match_vars,
-
-      case Exists andalso ordsets:is_element(Tuple, MatchVars) of
-        true ->
-          {{var, Line, Current}, S};
-        false ->
-          %% We attempt to give vars a nice name because we
-          %% still use the unused vars warnings from erl_lint.
-          %%
-          %% Once we move the warning to Elixir compiler, we
-          %% can name vars as _@COUNTER.
-          {NewVar, Counter, NS} =
-            if
-              Kind /= nil ->
-                build_var('_', S);
-              true ->
-                build_var(Name, S)
-            end,
-
-          FS = NS#elixir_scope{
-            vars=orddict:store(Tuple, {NewVar, Counter}, Vars),
-            match_vars=ordsets:add_element(Tuple, MatchVars),
-            export_vars=case S#elixir_scope.export_vars of
-              nil -> nil;
-              EV  -> orddict:store(Tuple, {NewVar, Counter}, EV)
-            end
-          },
-
-          {{var, Line, NewVar}, FS}
-      end;
-    _  when Exists ->
-      {{var, Line, Current}, S}
-  end.
-
-build_var(Key, S) ->
-  New = orddict:update_counter(Key, 1, S#elixir_scope.counter),
-  Cnt = orddict:fetch(Key, New),
-  {elixir_utils:atom_concat([Key, "@", Cnt]), Cnt, S#elixir_scope{counter=New}}.
-
-%% SCOPE MERGING
-
-%% Receives two scopes and return a new scope based on
-%% the second with their variables merged.
-
-mergev(S1, S2) ->
-  S2#elixir_scope{
-    vars=merge_vars(S1#elixir_scope.vars, S2#elixir_scope.vars),
-    export_vars=merge_opt_vars(S1#elixir_scope.export_vars, S2#elixir_scope.export_vars)
- }.
-
-%% Receives two scopes and return the first scope with
-%% counters and flags from the later.
-
-mergec(S1, S2) ->
-  S1#elixir_scope{
-    counter=S2#elixir_scope.counter,
-    super=S2#elixir_scope.super,
-    caller=S2#elixir_scope.caller
- }.
-
-%% Similar to mergec but does not merge the user vars counter.
-
-mergef(S1, S2) ->
-  S1#elixir_scope{
-    super=S2#elixir_scope.super,
-    caller=S2#elixir_scope.caller
- }.
-
-%% Mergers.
-
-merge_vars(V, V) -> V;
-merge_vars(V1, V2) ->
-  orddict:merge(fun var_merger/3, V1, V2).
-
-merge_opt_vars(nil, _C2) -> nil;
-merge_opt_vars(_C1, nil) -> nil;
-merge_opt_vars(C, C)     -> C;
-merge_opt_vars(C1, C2)   ->
-  orddict:merge(fun var_merger/3, C1, C2).
-
-var_merger(_Var, {_, V1} = K1, {_, V2}) when V1 > V2 -> K1;
-var_merger(_Var, _K1, K2) -> K2.
-
-%% BINDINGS
-
-load_binding(Binding, Scope) ->
-  {NewBinding, NewVars, NewCounter} = load_binding(Binding, [], [], 0),
-  {NewBinding, Scope#elixir_scope{
-    vars=NewVars,
-    counter=[{'_',NewCounter}]
- }}.
-
-load_binding([{Key,Value}|T], Binding, Vars, Counter) ->
-  Actual = case Key of
-    {_Name, _Kind} -> Key;
-    Name when is_atom(Name) -> {Name, nil}
-  end,
-  InternalName = elixir_utils:atom_concat(["_@", Counter]),
-  load_binding(T,
-    orddict:store(InternalName, Value, Binding),
-    orddict:store(Actual, {InternalName, 0}, Vars), Counter + 1);
-load_binding([], Binding, Vars, Counter) ->
-  {Binding, Vars, Counter}.
-
-dump_binding(Binding, #elixir_scope{vars=Vars}) ->
-  dump_binding(Vars, Binding, []).
-
-dump_binding([{{Var, Kind} = Key, {InternalName,_}}|T], Binding, Acc) when is_atom(Kind) ->
-  Actual = case Kind of
-    nil -> Var;
-    _   -> Key
-  end,
-  Value = proplists:get_value(InternalName, Binding, nil),
-  dump_binding(T, Binding, orddict:store(Actual, Value, Acc));
-dump_binding([_|T], Binding, Acc) ->
-  dump_binding(T, Binding, Acc);
-dump_binding([], _Binding, Acc) -> Acc.
diff --git a/lib/elixir/src/elixir_sup.erl b/lib/elixir/src/elixir_sup.erl
index 80767df73c1..8071647f06c 100644
--- a/lib/elixir/src/elixir_sup.erl
+++ b/lib/elixir/src/elixir_sup.erl
@@ -1,3 +1,7 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(elixir_sup).
 -behaviour(supervisor).
 -export([init/1, start_link/0]).
@@ -8,24 +12,24 @@ start_link() ->
 init(ok) ->
   Workers = [
     {
-      elixir_code_server,
-      {elixir_code_server, start_link, []},
+      elixir_config,
+      {elixir_config, start_link, []},
 
       permanent,                    % Restart  = permanent | transient | temporary
       2000,                         % Shutdown = brutal_kill | int() >= 0 | infinity
       worker,                       % Type     = worker | supervisor
-      [elixir_code_server]          % Modules  = [Module] | dynamic
-   },
+      [elixir_config]               % Modules  = [Module] | dynamic
+    },
 
     {
-      elixir_counter,
-      {elixir_counter, start_link, []},
+      elixir_code_server,
+      {elixir_code_server, start_link, []},
 
       permanent,                    % Restart  = permanent | transient | temporary
       2000,                         % Shutdown = brutal_kill | int() >= 0 | infinity
       worker,                       % Type     = worker | supervisor
-      [elixir_counter]              % Modules  = [Module] | dynamic
-   }
+      [elixir_code_server]          % Modules  = [Module] | dynamic
+    }
   ],
 
   {ok, {{one_for_one, 3, 10}, Workers}}.
diff --git a/lib/elixir/src/elixir_tokenizer.erl b/lib/elixir/src/elixir_tokenizer.erl
index 84310831eb6..14ea3ca7922 100644
--- a/lib/elixir/src/elixir_tokenizer.erl
+++ b/lib/elixir/src/elixir_tokenizer.erl
@@ -1,894 +1,1637 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(elixir_tokenizer).
 -include("elixir.hrl").
--export([tokenize/3]).
--import(elixir_interpolation, [unescape_tokens/1]).
+-include("elixir_tokenizer.hrl").
+-export([tokenize/1, tokenize/3, tokenize/4, invalid_do_error/1, terminator/1]).
 
 -define(at_op(T),
-  T == $@).
+  T =:= $@).
 
 -define(capture_op(T),
-  T == $&).
+  T =:= $&).
 
 -define(unary_op(T),
-  T == $!;
-  T == $^).
+  T =:= $!;
+  T =:= $^).
 
--define(unary_op3(T1, T2, T3),
-  T1 == $~, T2 == $~, T3 == $~).
+-define(range_op(T1, T2),
+  T1 =:= $., T2 =:= $.).
 
--define(hat_op3(T1, T2, T3),
-  T1 == $^, T2 == $^, T3 == $^).
+-define(concat_op(T1, T2),
+  T1 =:= $+, T2 =:= $+;
+  T1 =:= $-, T2 =:= $-;
+  T1 =:= $<, T2 =:= $>).
 
--define(two_op(T1, T2),
-  T1 == $+, T2 == $+;
-  T1 == $-, T2 == $-;
-  T1 == $<, T2 == $>;
-  T1 == $., T2 == $.).
+-define(concat_op3(T1, T2, T3),
+  T1 =:= $+, T2 =:= $+, T3 =:= $+;
+  T1 =:= $-, T2 =:= $-, T3 =:= $-).
+
+-define(power_op(T1, T2),
+  T1 =:= $*, T2 =:= $*).
 
 -define(mult_op(T),
-  T == $* orelse T == $/).
+  T =:= $* orelse T =:= $/).
 
 -define(dual_op(T),
-  T == $+ orelse T == $-).
+  T =:= $+ orelse T =:= $-).
 
 -define(arrow_op3(T1, T2, T3),
-  T1 == $<, T2 == $<, T3 == $<;
-  T1 == $>, T2 == $>, T3 == $>).
+  T1 =:= $<, T2 =:= $<, T3 =:= $<;
+  T1 =:= $>, T2 =:= $>, T3 =:= $>;
+  T1 =:= $~, T2 =:= $>, T3 =:= $>;
+  T1 =:= $<, T2 =:= $<, T3 =:= $~;
+  T1 =:= $<, T2 =:= $~, T3 =:= $>;
+  T1 =:= $<, T2 =:= $|, T3 =:= $>).
 
 -define(arrow_op(T1, T2),
-  T1 == $|, T2 == $>).
+  T1 =:= $|, T2 =:= $>;
+  T1 =:= $~, T2 =:= $>;
+  T1 =:= $<, T2 =:= $~).
 
 -define(rel_op(T),
-  T == $<;
-  T == $>).
+  T =:= $<;
+  T =:= $>).
 
 -define(rel_op2(T1, T2),
-  T1 == $<, T2 == $=;
-  T1 == $>, T2 == $=).
+  T1 =:= $<, T2 =:= $=;
+  T1 =:= $>, T2 =:= $=).
 
 -define(comp_op2(T1, T2),
-  T1 == $=, T2 == $=;
-  T1 == $=, T2 == $~;
-  T1 == $!, T2 == $=).
+  T1 =:= $=, T2 =:= $=;
+  T1 =:= $=, T2 =:= $~;
+  T1 =:= $!, T2 =:= $=).
 
 -define(comp_op3(T1, T2, T3),
-  T1 == $=, T2 == $=, T3 == $=;
-  T1 == $!, T2 == $=, T3 == $=).
+  T1 =:= $=, T2 =:= $=, T3 =:= $=;
+  T1 =:= $!, T2 =:= $=, T3 =:= $=).
+
+-define(ternary_op(T1, T2),
+  T1 =:= $/, T2 =:= $/).
 
 -define(and_op(T1, T2),
-  T1 == $&, T2 == $&).
+  T1 =:= $&, T2 =:= $&).
 
 -define(or_op(T1, T2),
-  T1 == $|, T2 == $|).
+  T1 =:= $|, T2 =:= $|).
 
 -define(and_op3(T1, T2, T3),
-  T1 == $&, T2 == $&, T3 == $&).
+  T1 =:= $&, T2 =:= $&, T3 =:= $&).
 
 -define(or_op3(T1, T2, T3),
-  T1 == $|, T2 == $|, T3 == $|).
+  T1 =:= $|, T2 =:= $|, T3 =:= $|).
 
 -define(match_op(T),
-  T == $=).
+  T =:= $=).
 
 -define(in_match_op(T1, T2),
-  T1 == $<, T2 == $-;
-  T1 == $\\, T2 == $\\).
+  T1 =:= $<, T2 =:= $-;
+  T1 =:= $\\, T2 =:= $\\).
 
 -define(stab_op(T1, T2),
-  T1 == $-, T2 == $>).
+  T1 =:= $-, T2 =:= $>).
 
 -define(type_op(T1, T2),
-  T1 == $:, T2 == $:).
+  T1 =:= $:, T2 =:= $:).
 
--define(pipe_op(T1),
-  T == $|).
+-define(pipe_op(T),
+  T =:= $|).
 
-tokenize(String, Line, #elixir_tokenizer{} = Scope) ->
-  tokenize(String, Line, Scope, []);
+-define(ellipsis_op3(T1, T2, T3),
+  T1 =:= $., T2 =:= $., T3 =:= $.).
 
-tokenize(String, Line, Opts) ->
-  File = case lists:keyfind(file, 1, Opts) of
-    {file, V1} -> V1;
-    false -> <<"nofile">>
-  end,
+%% Deprecated operators
 
-  Existing = case lists:keyfind(existing_atoms_only, 1, Opts) of
-    {existing_atoms_only, true} -> true;
-    false -> false
-  end,
+-define(unary_op3(T1, T2, T3),
+  T1 =:= $~, T2 =:= $~, T3 =:= $~).
+
+-define(xor_op3(T1, T2, T3),
+  T1 =:= $^, T2 =:= $^, T3 =:= $^).
+
+tokenize(String, Line, Column, #elixir_tokenizer{} = Scope) ->
+  tokenize(String, Line, Column, Scope, []);
+
+tokenize(String, Line, Column, Opts) ->
+  IdentifierTokenizer = elixir_config:identifier_tokenizer(),
+
+  Scope =
+    lists:foldl(fun
+      ({check_terminators, false}, Acc) ->
+        Acc#elixir_tokenizer{cursor_completion=false, terminators=none};
+      ({check_terminators, {cursor, Terminators}}, Acc) ->
+        Acc#elixir_tokenizer{cursor_completion=prune_and_cursor, terminators=Terminators};
+      ({existing_atoms_only, ExistingAtomsOnly}, Acc) when is_boolean(ExistingAtomsOnly) ->
+        Acc#elixir_tokenizer{existing_atoms_only=ExistingAtomsOnly};
+      ({static_atoms_encoder, StaticAtomsEncoder}, Acc) when is_function(StaticAtomsEncoder) ->
+        Acc#elixir_tokenizer{static_atoms_encoder=StaticAtomsEncoder};
+      ({preserve_comments, PreserveComments}, Acc) when is_function(PreserveComments) ->
+        Acc#elixir_tokenizer{preserve_comments=PreserveComments};
+      ({unescape, Unescape}, Acc) when is_boolean(Unescape) ->
+        Acc#elixir_tokenizer{unescape=Unescape};
+      ({indentation, Indentation}, Acc) when Indentation >= 0 ->
+        Acc#elixir_tokenizer{column=Indentation+1};
+      (_, Acc) ->
+        Acc
+    end, #elixir_tokenizer{identifier_tokenizer=IdentifierTokenizer}, Opts),
+
+  tokenize(String, Line, Column, Scope, []).
 
-  Check = case lists:keyfind(check_terminators, 1, Opts) of
-    {check_terminators, false} -> false;
-    false -> true
-  end,
+tokenize(String, Line, Opts) ->
+  tokenize(String, Line, 1, Opts).
 
-  tokenize(String, Line, #elixir_tokenizer{
-    file=File,
-    existing_atoms_only=Existing,
-    check_terminators=Check
- }).
+tokenize([], Line, Column, #elixir_tokenizer{cursor_completion=Cursor} = Scope, Tokens) when Cursor /= false ->
+  #elixir_tokenizer{ascii_identifiers_only=Ascii, terminators=Terminators, warnings=Warnings} = Scope,
 
-tokenize([], Line, #elixir_tokenizer{terminators=[]}, Tokens) ->
-  {ok, Line, lists:reverse(Tokens)};
+  {CursorColumn, AccTerminators, AccTokens} =
+    add_cursor(Line, Column, Cursor, Terminators, Tokens),
 
-tokenize([], EndLine, #elixir_tokenizer{terminators=[{Start, StartLine}|_]}, Tokens) ->
-  End     = terminator(Start),
-  Message = io_lib:format("missing terminator: ~ts (for \"~ts\" starting at line ~B)", [End, Start, StartLine]),
-  {error, {EndLine, Message, []}, [], Tokens};
+  AllWarnings = maybe_unicode_lint_warnings(Ascii, Tokens, Warnings),
+  {ok, Line, CursorColumn, AllWarnings, AccTokens, AccTerminators};
+
+tokenize([], EndLine, EndColumn, #elixir_tokenizer{terminators=[{Start, {StartLine, StartColumn, _}, _} | _]} = Scope, Tokens) ->
+  End = terminator(Start),
+  Hint = missing_terminator_hint(Start, End, Scope),
+  Message = "missing terminator: ~ts",
+  Formatted = io_lib:format(Message, [End]),
+  Meta = [
+    {opening_delimiter, Start},
+    {expected_delimiter, End},
+    {line, StartLine},
+    {column, StartColumn},
+    {end_line, EndLine},
+    {end_column, EndColumn}
+  ],
+  error({Meta, [Formatted, Hint], []}, [], Scope, Tokens);
+
+tokenize([], Line, Column, #elixir_tokenizer{} = Scope, Tokens) ->
+  #elixir_tokenizer{ascii_identifiers_only=Ascii, warnings=Warnings} = Scope,
+  AllWarnings = maybe_unicode_lint_warnings(Ascii, Tokens, Warnings),
+  {ok, Line, Column, AllWarnings, Tokens, []};
+
+% VC merge conflict
+
+tokenize(("<<<<<<<" ++ _) = Original, Line, 1, Scope, Tokens) ->
+  FirstLine = lists:takewhile(fun(C) -> C =/= $\n andalso C =/= $\r end, Original),
+  Reason = {?LOC(Line, 1), "found an unexpected version control marker, please resolve the conflicts: ", FirstLine},
+  error(Reason, Original, Scope, Tokens);
 
 % Base integers
 
-tokenize([$0,X,H|T], Line, Scope, Tokens) when (X == $x orelse X == $X), ?is_hex(H) ->
-  {Rest, Number} = tokenize_hex([H|T], []),
-  tokenize(Rest, Line, Scope, [{number, Line, Number}|Tokens]);
+tokenize([$0, $x, H | T], Line, Column, Scope, Tokens) when ?is_hex(H) ->
+  {Rest, Number, OriginalRepresentation, Length} = tokenize_hex(T, [H], 1),
+  Token = {int, {Line, Column, Number}, OriginalRepresentation},
+  tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]);
 
-tokenize([$0,B,H|T], Line, Scope, Tokens) when (B == $b orelse B == $B), ?is_bin(H) ->
-  {Rest, Number} = tokenize_bin([H|T], []),
-  tokenize(Rest, Line, Scope, [{number, Line, Number}|Tokens]);
+tokenize([$0, $b, H | T], Line, Column, Scope, Tokens) when ?is_bin(H) ->
+  {Rest, Number, OriginalRepresentation, Length} = tokenize_bin(T, [H], 1),
+  Token = {int, {Line, Column, Number}, OriginalRepresentation},
+  tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]);
 
-tokenize([$0,H|T], Line, Scope, Tokens) when ?is_octal(H) ->
-  {Rest, Number} = tokenize_octal([H|T], []),
-  tokenize(Rest, Line, Scope, [{number, Line, Number}|Tokens]);
+tokenize([$0, $o, H | T], Line, Column, Scope, Tokens) when ?is_octal(H) ->
+  {Rest, Number, OriginalRepresentation, Length} = tokenize_octal(T, [H], 1),
+  Token = {int, {Line, Column, Number}, OriginalRepresentation},
+  tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]);
 
 % Comments
 
-tokenize([$#|String], Line, Scope, Tokens) ->
-  Rest = tokenize_comment(String),
-  tokenize(Rest, Line, Scope, Tokens);
+tokenize([$# | String], Line, Column, Scope, Tokens) ->
+  case tokenize_comment(String, [$#]) of
+    {error, Char, Reason} ->
+      error_comment(Char, Reason, [$# | String], Line, Column, Scope, Tokens);
+    {Rest, Comment} ->
+      preserve_comments(Line, Column, Tokens, Comment, Rest, Scope),
+      tokenize(Rest, Line, Column, Scope, reset_eol(Tokens))
+  end;
 
 % Sigils
 
-tokenize([$~,S,H,H,H|T] = Original, Line, Scope, Tokens) when ?is_quote(H), ?is_upcase(S) orelse ?is_downcase(S) ->
-  case extract_heredoc_with_interpolation(Line, Scope, ?is_downcase(S), T, H) of
-    {ok, NewLine, Parts, Rest} ->
-      {Final, Modifiers} = collect_modifiers(Rest, []),
-      tokenize(Final, NewLine, Scope, [{sigil, Line, S, Parts, Modifiers}|Tokens]);
-    {error, Reason} ->
-      {error, Reason, Original, Tokens}
-  end;
-
-tokenize([$~,S,H|T] = Original, Line, Scope, Tokens) when ?is_sigil(H), ?is_upcase(S) orelse ?is_downcase(S) ->
-  case elixir_interpolation:extract(Line, Scope, ?is_downcase(S), T, sigil_terminator(H)) of
-    {NewLine, Parts, Rest} ->
-      {Final, Modifiers} = collect_modifiers(Rest, []),
-      tokenize(Final, NewLine, Scope, [{sigil, Line, S, Parts, Modifiers}|Tokens]);
-    {error, Reason} ->
-      Sigil = [$~,S,H],
-      interpolation_error(Reason, Original, Tokens, " (for sigil ~ts starting at line ~B)", [Sigil, Line])
-  end;
+tokenize([$~, H | _T] = Original, Line, Column, Scope, Tokens) when ?is_upcase(H) orelse ?is_downcase(H) ->
+  tokenize_sigil(Original, Line, Column, Scope, Tokens);
 
 % Char tokens
 
-tokenize([$?,$\\,P,${,A,B,C,D,E,F,$}|T], Line, Scope, Tokens)
-    when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) ->
-  Char = escape_char([$\\,P,${,A,B,C,D,E,F,$}]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,P,${,A,B,C,D,E,$}|T], Line, Scope, Tokens)
-    when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) ->
-  Char = escape_char([$\\,P,${,A,B,C,D,E,$}]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,P,${,A,B,C,D,$}|T], Line, Scope, Tokens)
-    when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
-  Char = escape_char([$\\,P,${,A,B,C,D,$}]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,P,${,A,B,C,$}|T], Line, Scope, Tokens)
-    when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B), ?is_hex(C) ->
-  Char = escape_char([$\\,P,${,A,B,C,$}]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,P,${,A,B,$}|T], Line, Scope, Tokens)
-    when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B) ->
-  Char = escape_char([$\\,P,${,A,B,$}]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,P,${,A,$}|T], Line, Scope, Tokens)
-    when (P == $x orelse P == $X), ?is_hex(A) ->
-  Char = escape_char([$\\,P,${,A,$}]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,P,A,B|T], Line, Scope, Tokens)
-    when (P == $x orelse P == $X), ?is_hex(A), ?is_hex(B) ->
-  Char = escape_char([$\\,P,A,B]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,P,A|T], Line, Scope, Tokens)
-    when (P == $x orelse P == $X), ?is_hex(A) ->
-  Char = escape_char([$\\,P,A]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,A,B,C|T], Line, Scope, Tokens)
-    when ?is_octal(A), A =< $3,?is_octal(B), ?is_octal(C) ->
-  Char = escape_char([$\\,A,B,C]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,A,B|T], Line, Scope, Tokens)
-    when ?is_octal(A), ?is_octal(B) ->
-  Char = escape_char([$\\,A,B]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,A|T], Line, Scope, Tokens)
-    when ?is_octal(A) ->
-  Char = escape_char([$\\,A]),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
-
-tokenize([$?,$\\,H|T], Line, Scope, Tokens) ->
+% We tokenize char literals (?a) as {char, _, CharInt} instead of {number, _,
+% CharInt}. This is exactly what Erlang does with Erlang char literals
+% ($a). This means we'll have to adjust the error message for char literals in
+% elixir_errors.erl as by default {char, _, _} tokens are "hijacked" by Erlang
+% and printed with Erlang syntax ($a) in the parser's error messages.
+
+tokenize([$?, $\\, H | T], Line, Column, Scope, Tokens) ->
   Char = elixir_interpolation:unescape_map(H),
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
 
-tokenize([$?,Char|T], Line, Scope, Tokens) ->
-  tokenize(T, Line, Scope, [{number, Line, Char}|Tokens]);
+  NewScope = if
+    H =:= Char, H =/= $\\ ->
+      case handle_char(Char) of
+        {Escape, Name} ->
+          Msg = io_lib:format("found ?\\ followed by code point 0x~.16B (~ts), please use ?~ts instead",
+                              [Char, Name, Escape]),
+          prepend_warning(Line, Column, Msg, Scope);
 
-% Heredocs
+        false when ?is_downcase(H); ?is_upcase(H) ->
+          Msg = io_lib:format("unknown escape sequence ?\\~tc, use ?~tc instead", [H, H]),
+          prepend_warning(Line, Column, Msg, Scope);
 
-tokenize("\"\"\"" ++ T, Line, Scope, Tokens) ->
-  handle_heredocs(T, Line, $", Scope, Tokens);
+        false ->
+          Scope
+      end;
+    true ->
+      Scope
+  end,
 
-tokenize("'''" ++ T, Line, Scope, Tokens) ->
-  handle_heredocs(T, Line, $', Scope, Tokens);
+  Token = {char, {Line, Column, [$?, $\\, H]}, Char},
+  case H of
+    $\n ->
+      %% If original char is a literal line feed, we already emit a warning,
+      %% but we need to bump the line without emitting an EOL token.
+      tokenize_eol(T, Line, NewScope, [Token | Tokens]);
+    _ ->
+      tokenize(T, Line, Column + 3, NewScope, [Token | Tokens])
+  end;
 
-% Strings
+tokenize([$?, Char | T], Line, Column, Scope, Tokens) ->
+  NewScope = case handle_char(Char) of
+    {Escape, Name} ->
+      Msg = io_lib:format("found ? followed by code point 0x~.16B (~ts), please use ?~ts instead",
+                          [Char, Name, Escape]),
+      prepend_warning(Line, Column, Msg, Scope);
+    false ->
+      Scope
+  end,
+  Token = {char, {Line, Column, [$?, Char]}, Char},
+  case Char of
+    $\n ->
+      %% If original char is a literal line feed, we already emit a warning,
+      %% but we need to bump the line without emitting an EOL token.
+      tokenize_eol(T, Line, NewScope, [Token | Tokens]);
+    _ ->
+      tokenize(T, Line, Column + 2, NewScope, [Token | Tokens])
+  end;
 
-tokenize([$"|T], Line, Scope, Tokens) ->
-  handle_strings(T, Line, $", Scope, Tokens);
-tokenize([$'|T], Line, Scope, Tokens) ->
-  handle_strings(T, Line, $', Scope, Tokens);
+% Heredocs
 
-% Atoms
+tokenize("\"\"\"" ++ T, Line, Column, Scope, Tokens) ->
+  handle_heredocs(T, Line, Column, $", Scope, Tokens);
 
-tokenize([$:,H|T] = Original, Line, Scope, Tokens) when ?is_quote(H) ->
-  case elixir_interpolation:extract(Line, Scope, true, T, H) of
-    {NewLine, Parts, Rest} ->
-      Unescaped = unescape_tokens(Parts),
-      Key = case Scope#elixir_tokenizer.existing_atoms_only of
-        true  -> atom_safe;
-        false -> atom_unsafe
-      end,
-      tokenize(Rest, NewLine, Scope, [{Key, Line, Unescaped}|Tokens]);
-    {error, Reason} ->
-      interpolation_error(Reason, Original, Tokens, " (for atom starting at line ~B)", [Line])
-  end;
+%% TODO: Remove me in Elixir v2.0
+tokenize("'''" ++ T, Line, Column, Scope, Tokens) ->
+  NewScope = prepend_warning(Line, Column, "single-quoted string represent charlists. Use ~c''' if you indeed want a charlist or use \"\"\" instead", Scope),
+  handle_heredocs(T, Line, Column, $', NewScope, Tokens);
 
-tokenize([$:,T|String] = Original, Line, Scope, Tokens) when ?is_atom_start(T) ->
-  {Rest, Part} = tokenize_atom([T|String], []),
-  case unsafe_to_atom(Part, Line, Scope) of
-    {ok, Atom} ->
-      tokenize(Rest, Line, Scope, [{atom, Line, Atom}|Tokens]);
-    {error, Reason} ->
-      {error, Reason, Original, Tokens}
-  end;
+% Strings
 
-% %% Special atom identifiers / operators
-
-tokenize(":..." ++ Rest, Line, Scope, Tokens) ->
-  tokenize(Rest, Line, Scope, [{atom, Line, '...'}|Tokens]);
-tokenize(":<<>>" ++ Rest, Line, Scope, Tokens) ->
-  tokenize(Rest, Line, Scope, [{atom, Line, '<<>>'}|Tokens]);
-tokenize(":%{}" ++ Rest, Line, Scope, Tokens) ->
-  tokenize(Rest, Line, Scope, [{atom, Line, '%{}'}|Tokens]);
-tokenize(":%" ++ Rest, Line, Scope, Tokens) ->
-  tokenize(Rest, Line, Scope, [{atom, Line, '%'}|Tokens]);
-tokenize(":{}" ++ Rest, Line, Scope, Tokens) ->
-  tokenize(Rest, Line, Scope, [{atom, Line, '{}'}|Tokens]);
-
-tokenize("...:" ++ Rest, Line, Scope, Tokens) when ?is_space(hd(Rest)) ->
-  tokenize(Rest, Line, Scope, [{kw_identifier, Line, '...'}|Tokens]);
-tokenize("<<>>:" ++ Rest, Line, Scope, Tokens) when ?is_space(hd(Rest)) ->
-  tokenize(Rest, Line, Scope, [{kw_identifier, Line, '<<>>'}|Tokens]);
-tokenize("%{}:" ++ Rest, Line, Scope, Tokens) when ?is_space(hd(Rest)) ->
-  tokenize(Rest, Line, Scope, [{kw_identifier, Line, '%{}'}|Tokens]);
-tokenize("%:" ++ Rest, Line, Scope, Tokens) when ?is_space(hd(Rest)) ->
-  tokenize(Rest, Line, Scope, [{kw_identifier, Line, '%'}|Tokens]);
-tokenize("{}:" ++ Rest, Line, Scope, Tokens) when ?is_space(hd(Rest)) ->
-  tokenize(Rest, Line, Scope, [{kw_identifier, Line, '{}'}|Tokens]);
+tokenize([$" | T], Line, Column, Scope, Tokens) ->
+  handle_strings(T, Line, Column + 1, $", Scope, Tokens);
+
+%% TODO: Remove me in Elixir v2.0
+tokenize([$' | T], Line, Column, Scope, Tokens) ->
+  handle_strings(T, Line, Column + 1, $', Scope, Tokens);
+
+% Operator atoms
+
+tokenize(".:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->
+  tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '.'} | Tokens]);
+
+tokenize("<<>>:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->
+  tokenize(Rest, Line, Column + 5, Scope, [{kw_identifier, {Line, Column, nil}, '<<>>'} | Tokens]);
+tokenize("%{}:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->
+  tokenize(Rest, Line, Column + 4, Scope, [{kw_identifier, {Line, Column, nil}, '%{}'} | Tokens]);
+tokenize("%:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->
+  tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '%'} | Tokens]);
+tokenize("&:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->
+  tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '&'} | Tokens]);
+tokenize("{}:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->
+  tokenize(Rest, Line, Column + 3, Scope, [{kw_identifier, {Line, Column, nil}, '{}'} | Tokens]);
+tokenize("..//:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) ->
+  tokenize(Rest, Line, Column + 5, Scope, [{kw_identifier, {Line, Column, nil}, '..//'} | Tokens]);
+
+tokenize(":<<>>" ++ Rest, Line, Column, Scope, Tokens) ->
+  tokenize(Rest, Line, Column + 5, Scope, [{atom, {Line, Column, nil}, '<<>>'} | Tokens]);
+tokenize(":%{}" ++ Rest, Line, Column, Scope, Tokens) ->
+  tokenize(Rest, Line, Column + 4, Scope, [{atom, {Line, Column, nil}, '%{}'} | Tokens]);
+tokenize(":%" ++ Rest, Line, Column, Scope, Tokens) ->
+  tokenize(Rest, Line, Column + 2, Scope, [{atom, {Line, Column, nil}, '%'} | Tokens]);
+tokenize(":{}" ++ Rest, Line, Column, Scope, Tokens) ->
+  tokenize(Rest, Line, Column + 3, Scope, [{atom, {Line, Column, nil}, '{}'} | Tokens]);
+tokenize(":..//" ++ Rest, Line, Column, Scope, Tokens) ->
+  tokenize(Rest, Line, Column + 5, Scope, [{atom, {Line, Column, nil}, '..//'} | Tokens]);
 
 % ## Three Token Operators
-tokenize([$:,T1,T2,T3|Rest], Line, Scope, Tokens) when
+tokenize([$:, T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when
     ?unary_op3(T1, T2, T3); ?comp_op3(T1, T2, T3); ?and_op3(T1, T2, T3); ?or_op3(T1, T2, T3);
-    ?arrow_op3(T1, T2, T3); ?hat_op3(T1, T2, T3) ->
-  tokenize(Rest, Line, Scope, [{atom, Line, list_to_atom([T1,T2,T3])}|Tokens]);
+    ?arrow_op3(T1, T2, T3); ?xor_op3(T1, T2, T3); ?concat_op3(T1, T2, T3); ?ellipsis_op3(T1, T2, T3) ->
+  Token = {atom, {Line, Column, nil}, list_to_atom([T1, T2, T3])},
+  tokenize(Rest, Line, Column + 4, Scope, [Token | Tokens]);
 
 % ## Two Token Operators
-tokenize([$:,T1,T2|Rest], Line, Scope, Tokens) when
+
+tokenize([$:, $:, $: | Rest], Line, Column, Scope, Tokens) ->
+  Message = "atom ::: must be written between quotes, as in :\"::\", to avoid ambiguity",
+  NewScope = prepend_warning(Line, Column, Message, Scope),
+  Token = {atom, {Line, Column, nil}, '::'},
+  tokenize(Rest, Line, Column + 3, NewScope, [Token | Tokens]);
+
+tokenize([$:, T1, T2 | Rest], Line, Column, Scope, Tokens) when
     ?comp_op2(T1, T2); ?rel_op2(T1, T2); ?and_op(T1, T2); ?or_op(T1, T2);
-    ?arrow_op(T1, T2); ?in_match_op(T1, T2); ?two_op(T1, T2); ?stab_op(T1, T2);
-    ?type_op(T1, T2) ->
-  tokenize(Rest, Line, Scope, [{atom, Line, list_to_atom([T1,T2])}|Tokens]);
+    ?arrow_op(T1, T2); ?in_match_op(T1, T2); ?concat_op(T1, T2); ?power_op(T1, T2);
+    ?stab_op(T1, T2); ?range_op(T1, T2) ->
+  Token = {atom, {Line, Column, nil}, list_to_atom([T1, T2])},
+  tokenize(Rest, Line, Column + 3, Scope, [Token | Tokens]);
 
 % ## Single Token Operators
-tokenize([$:,T|Rest], Line, Scope, Tokens) when
+tokenize([$:, T | Rest], Line, Column, Scope, Tokens) when
     ?at_op(T); ?unary_op(T); ?capture_op(T); ?dual_op(T); ?mult_op(T);
-    ?rel_op(T); ?match_op(T); ?pipe_op(T); T == $. ->
-  tokenize(Rest, Line, Scope, [{atom, Line, list_to_atom([T])}|Tokens]);
+    ?rel_op(T); ?match_op(T); ?pipe_op(T); T =:= $. ->
+  Token = {atom, {Line, Column, nil}, list_to_atom([T])},
+  tokenize(Rest, Line, Column + 2, Scope, [Token | Tokens]);
+
+% ## Stand-alone tokens
+
+tokenize("=>" ++ Rest, Line, Column, Scope, Tokens) ->
+  Token = {assoc_op, {Line, Column, previous_was_eol(Tokens)}, '=>'},
+  tokenize(Rest, Line, Column + 2, Scope, add_token_with_eol(Token, Tokens));
+
+tokenize("..//" ++ Rest = String, Line, Column, Scope, Tokens) ->
+  case strip_horizontal_space(Rest, Line, Column + 4, Scope) of
+    {[$/ | _] = Remaining, NewLine, NewColumn} ->
+      Token = {identifier, {Line, Column, nil}, '..//'},
+      tokenize(Remaining, NewLine, NewColumn, Scope, [Token | Tokens]);
+    {_, _, _} ->
+      unexpected_token(String, Line, Column, Scope, Tokens)
+  end;
 
-% End of line
+% ## Ternary operator
 
-tokenize(";" ++ Rest, Line, Scope, []) ->
-  tokenize(Rest, Line, Scope, eol(Line, ';', []));
+% ## Three token operators
+tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?unary_op3(T1, T2, T3) ->
+  handle_unary_op(Rest, Line, Column, unary_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens);
 
-tokenize(";" ++ Rest, Line, Scope, [Top|Tokens]) when element(1, Top) /= eol ->
-  tokenize(Rest, Line, Scope, eol(Line, ';', [Top|Tokens]));
+tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?ellipsis_op3(T1, T2, T3) ->
+  handle_unary_op(Rest, Line, Column, ellipsis_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens);
 
-tokenize("\\\n" ++ Rest, Line, Scope, Tokens) ->
-  tokenize(Rest, Line + 1, Scope, Tokens);
+tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?comp_op3(T1, T2, T3) ->
+  handle_op(Rest, Line, Column, comp_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens);
 
-tokenize("\\\r\n" ++ Rest, Line, Scope, Tokens) ->
-  tokenize(Rest, Line + 1, Scope, Tokens);
+tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?and_op3(T1, T2, T3) ->
+  NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope),
+  handle_op(Rest, Line, Column, and_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens);
 
-tokenize("\n" ++ Rest, Line, Scope, Tokens) ->
-  tokenize(Rest, Line + 1, Scope, eol(Line, newline, Tokens));
+tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?or_op3(T1, T2, T3) ->
+  NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope),
+  handle_op(Rest, Line, Column, or_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens);
 
-tokenize("\r\n" ++ Rest, Line, Scope, Tokens) ->
-  tokenize(Rest, Line + 1, Scope, eol(Line, newline, Tokens));
+tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?xor_op3(T1, T2, T3) ->
+  NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope),
+  handle_op(Rest, Line, Column, xor_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens);
 
-% Stand-alone tokens
+tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?concat_op3(T1, T2, T3) ->
+  NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope),
+  handle_op(Rest, Line, Column, concat_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens);
 
-tokenize("..." ++ Rest, Line, Scope, Tokens) ->
-  Token = check_call_identifier(identifier, Line, '...', Rest),
-  tokenize(Rest, Line, Scope, [Token|Tokens]);
+tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?arrow_op3(T1, T2, T3) ->
+  handle_op(Rest, Line, Column, arrow_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens);
 
-tokenize("=>" ++ Rest, Line, Scope, Tokens) ->
-  tokenize(Rest, Line, Scope, add_token_with_nl({assoc_op, Line, '=>'}, Tokens));
+% ## Containers + punctuation tokens
+tokenize([$, | Rest], Line, Column, Scope, Tokens) ->
+  Token = {',', {Line, Column, 0}},
+  tokenize(Rest, Line, Column + 1, Scope, [Token | Tokens]);
+
+tokenize([$<, $< | Rest], Line, Column, Scope, Tokens) ->
+  Token = {'<<', {Line, Column, nil}},
+  handle_terminator(Rest, Line, Column + 2, Scope, Token, Tokens);
+
+tokenize([$>, $> | Rest], Line, Column, Scope, Tokens) ->
+  Token = {'>>', {Line, Column, previous_was_eol(Tokens)}},
+  handle_terminator(Rest, Line, Column + 2, Scope, Token, Tokens);
+
+tokenize([${ | Rest], Line, Column, Scope, [{'%', _} | _] = Tokens) ->
+  Message =
+    "unexpected space between % and {\n\n"
+    "If you want to define a map, write %{...}, with no spaces.\n"
+    "If you want to define a struct, write %StructName{...}.\n\n"
+    "Syntax error before: ",
+  error({?LOC(Line, Column), Message, [${]}, Rest, Scope, Tokens);
+
+tokenize([T | Rest], Line, Column, Scope, Tokens) when T =:= $(; T =:= ${; T =:= $[ ->
+  Token = {list_to_atom([T]), {Line, Column, nil}},
+  handle_terminator(Rest, Line, Column + 1, Scope, Token, Tokens);
+
+tokenize([T | Rest], Line, Column, Scope, Tokens) when T =:= $); T =:= $}; T =:= $] ->
+  Token = {list_to_atom([T]), {Line, Column, previous_was_eol(Tokens)}},
+  handle_terminator(Rest, Line, Column + 1, Scope, Token, Tokens);
 
-% ## Three token operators
-tokenize([T1,T2,T3|Rest], Line, Scope, Tokens) when ?unary_op3(T1, T2, T3) ->
-  handle_unary_op(Rest, Line, unary_op, list_to_atom([T1,T2,T3]), Scope, Tokens);
+% ## Two Token Operators
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?ternary_op(T1, T2) ->
+  Op = list_to_atom([T1, T2]),
+  Token = {ternary_op, {Line, Column, previous_was_eol(Tokens)}, Op},
+  tokenize(Rest, Line, Column + 2, Scope, add_token_with_eol(Token, Tokens));
 
-tokenize([T1,T2,T3|Rest], Line, Scope, Tokens) when ?comp_op3(T1, T2, T3) ->
-  handle_op(Rest, Line, comp_op, list_to_atom([T1,T2,T3]), Scope, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?power_op(T1, T2) ->
+  handle_op(Rest, Line, Column, power_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-tokenize([T1,T2,T3|Rest], Line, Scope, Tokens) when ?and_op3(T1, T2, T3) ->
-  handle_op(Rest, Line, and_op, list_to_atom([T1,T2,T3]), Scope, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?range_op(T1, T2) ->
+  handle_op(Rest, Line, Column, range_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-tokenize([T1,T2,T3|Rest], Line, Scope, Tokens) when ?or_op3(T1, T2, T3) ->
-  handle_op(Rest, Line, or_op, list_to_atom([T1,T2,T3]), Scope, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?concat_op(T1, T2) ->
+  handle_op(Rest, Line, Column, concat_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-tokenize([T1,T2,T3|Rest], Line, Scope, Tokens) when ?arrow_op3(T1, T2, T3) ->
-  handle_op(Rest, Line, arrow_op, list_to_atom([T1,T2,T3]), Scope, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?arrow_op(T1, T2) ->
+  handle_op(Rest, Line, Column, arrow_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-tokenize([T1,T2,T3|Rest], Line, Scope, Tokens) when ?hat_op3(T1, T2, T3) ->
-  handle_op(Rest, Line, hat_op, list_to_atom([T1,T2,T3]), Scope, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?comp_op2(T1, T2) ->
+  handle_op(Rest, Line, Column, comp_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-% ## Containers + punctuation tokens
-tokenize([T,T|Rest], Line, Scope, Tokens) when T == $<; T == $> ->
-  Token = {list_to_atom([T,T]), Line},
-  handle_terminator(Rest, Line, Scope, Token, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?rel_op2(T1, T2) ->
+  handle_op(Rest, Line, Column, rel_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-tokenize([T|Rest], Line, Scope, Tokens) when T == $(;
-    T == ${; T == $}; T == $[; T == $]; T == $); T == $, ->
-  Token = {list_to_atom([T]), Line},
-  handle_terminator(Rest, Line, Scope, Token, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?and_op(T1, T2) ->
+  handle_op(Rest, Line, Column, and_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-% ## Two Token Operators
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?two_op(T1, T2) ->
-  handle_op(Rest, Line, two_op, list_to_atom([T1, T2]), Scope, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?or_op(T1, T2) ->
+  handle_op(Rest, Line, Column, or_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?arrow_op(T1, T2) ->
-  handle_op(Rest, Line, arrow_op, list_to_atom([T1, T2]), Scope, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?in_match_op(T1, T2) ->
+  handle_op(Rest, Line, Column, in_match_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?comp_op2(T1, T2) ->
-  handle_op(Rest, Line, comp_op, list_to_atom([T1, T2]), Scope, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?type_op(T1, T2) ->
+  handle_op(Rest, Line, Column, type_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?rel_op2(T1, T2) ->
-  handle_op(Rest, Line, rel_op, list_to_atom([T1, T2]), Scope, Tokens);
+tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?stab_op(T1, T2) ->
+  handle_op(Rest, Line, Column, stab_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
 
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?and_op(T1, T2) ->
-  handle_op(Rest, Line, and_op, list_to_atom([T1, T2]), Scope, Tokens);
+% ## Single Token Operators
 
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?or_op(T1, T2) ->
-  handle_op(Rest, Line, or_op, list_to_atom([T1, T2]), Scope, Tokens);
+tokenize([$& | Rest], Line, Column, Scope, Tokens) ->
+  Kind =
+    case strip_horizontal_space(Rest, Line, 0, Scope) of
+      {[Int | _], Line, 0} when ?is_digit(Int) ->
+        capture_int;
 
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?in_match_op(T1, T2) ->
-  handle_op(Rest, Line, in_match_op, list_to_atom([T1, T2]), Scope, Tokens);
+      {[$/ | NewRest], _, _} ->
+        case strip_horizontal_space(NewRest, Line, 0, Scope) of
+          {[$/ | _], _, _} -> capture_op;
+          {_, _, _} -> identifier
+        end;
 
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?type_op(T1, T2) ->
-  handle_op(Rest, Line, type_op, list_to_atom([T1, T2]), Scope, Tokens);
+      {_, _, _} ->
+        capture_op
+    end,
 
-tokenize([T1,T2|Rest], Line, Scope, Tokens) when ?stab_op(T1, T2) ->
-  handle_op(Rest, Line, stab_op, list_to_atom([T1, T2]), Scope, Tokens);
+  Token = {Kind, {Line, Column, nil}, '&'},
+  tokenize(Rest, Line, Column + 1, Scope, [Token | Tokens]);
 
-% ## Single Token Operators
+tokenize([T | Rest], Line, Column, Scope, Tokens) when ?at_op(T) ->
+  handle_unary_op(Rest, Line, Column, at_op, 1, list_to_atom([T]), Scope, Tokens);
 
-tokenize([T|Rest], Line, Scope, Tokens) when ?at_op(T) ->
-  handle_unary_op(Rest, Line, at_op, list_to_atom([T]), Scope, Tokens);
+tokenize([T | Rest], Line, Column, Scope, Tokens) when ?unary_op(T) ->
+  handle_unary_op(Rest, Line, Column, unary_op, 1, list_to_atom([T]), Scope, Tokens);
 
-tokenize([T|Rest], Line, Scope, Tokens) when ?capture_op(T) ->
-  handle_unary_op(Rest, Line, capture_op, list_to_atom([T]), Scope, Tokens);
+tokenize([T | Rest], Line, Column, Scope, Tokens) when ?rel_op(T) ->
+  handle_op(Rest, Line, Column, rel_op, 1, list_to_atom([T]), Scope, Tokens);
 
-tokenize([T|Rest], Line, Scope, Tokens) when ?unary_op(T) ->
-  handle_unary_op(Rest, Line, unary_op, list_to_atom([T]), Scope, Tokens);
+tokenize([T | Rest], Line, Column, Scope, Tokens) when ?dual_op(T) ->
+  handle_unary_op(Rest, Line, Column, dual_op, 1, list_to_atom([T]), Scope, Tokens);
 
-tokenize([T|Rest], Line, Scope, Tokens) when ?rel_op(T) ->
-  handle_op(Rest, Line, rel_op, list_to_atom([T]), Scope, Tokens);
+tokenize([T | Rest], Line, Column, Scope, Tokens) when ?mult_op(T) ->
+  handle_op(Rest, Line, Column, mult_op, 1, list_to_atom([T]), Scope, Tokens);
 
-tokenize([T|Rest], Line, Scope, Tokens) when ?dual_op(T) ->
-  handle_unary_op(Rest, Line, dual_op, list_to_atom([T]), Scope, Tokens);
+tokenize([T | Rest], Line, Column, Scope, Tokens) when ?match_op(T) ->
+  handle_op(Rest, Line, Column, match_op, 1, list_to_atom([T]), Scope, Tokens);
 
-tokenize([T|Rest], Line, Scope, Tokens) when ?mult_op(T) ->
-  handle_op(Rest, Line, mult_op, list_to_atom([T]), Scope, Tokens);
+tokenize([T | Rest], Line, Column, Scope, Tokens) when ?pipe_op(T) ->
+  handle_op(Rest, Line, Column, pipe_op, 1, list_to_atom([T]), Scope, Tokens);
 
-tokenize([T|Rest], Line, Scope, Tokens) when ?match_op(T) ->
-  handle_op(Rest, Line, match_op, list_to_atom([T]), Scope, Tokens);
+% Non-operator Atoms
 
-tokenize([T|Rest], Line, Scope, Tokens) when ?pipe_op(T) ->
-  handle_op(Rest, Line, pipe_op, list_to_atom([T]), Scope, Tokens);
+tokenize([$:, H | T] = Original, Line, Column, BaseScope, Tokens) when ?is_quote(H) ->
+  Scope = case H == $' of
+    true ->
+      prepend_warning(Line, Column, "single quotes around atoms are deprecated. Use double quotes instead", BaseScope);
 
-% Others
+    false ->
+      BaseScope
+  end,
+
+  case elixir_interpolation:extract(Line, Column + 2, Scope, true, T, H) of
+    {NewLine, NewColumn, Parts, Rest, InterScope} ->
+      NewScope = case is_unnecessary_quote(Parts, InterScope) of
+        true ->
+          WarnMsg = io_lib:format(
+            "found quoted atom \"~ts\" but the quotes are not required. "
+            "Atoms made exclusively of ASCII letters, numbers, underscores, "
+            "beginning with a letter or underscore, and optionally ending with ! or ? "
+            "do not require quotes",
+            [hd(Parts)]
+          ),
+          prepend_warning(Line, Column, WarnMsg, InterScope);
+
+        false ->
+          InterScope
+      end,
 
-tokenize([$%|T], Line, Scope, Tokens) ->
-  case strip_space(T, 0) of
-    {[${|_] = Rest, Counter} -> tokenize(Rest, Line + Counter, Scope, [{'%{}', Line}|Tokens]);
-    {Rest, Counter}          -> tokenize(Rest, Line + Counter, Scope, [{'%', Line}|Tokens])
+      case unescape_tokens(Parts, Line, Column, NewScope) of
+        {ok, [Part]} when is_binary(Part) ->
+          case unsafe_to_atom(Part, Line, Column, Scope) of
+            {ok, Atom} ->
+              Token = {atom_quoted, {Line, Column, H}, Atom},
+              tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]);
+
+            {error, Reason} ->
+              error(Reason, Rest, NewScope, Tokens)
+          end;
+
+        {ok, Unescaped} ->
+          Key = case Scope#elixir_tokenizer.existing_atoms_only of
+            true  -> atom_safe;
+            false -> atom_unsafe
+          end,
+          Token = {Key, {Line, Column, H}, Unescaped},
+          tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]);
+
+        {error, Reason} ->
+          error(Reason, Rest, NewScope, Tokens)
+      end;
+
+    {error, Reason} ->
+      Message = " (for atom starting at line ~B)",
+      interpolation_error(Reason, Original, Scope, Tokens, Message, [Line], Line, Column + 1, [H], [H])
   end;
 
-tokenize([$.|T], Line, Scope, Tokens) ->
-  {Rest, Counter} = strip_space(T, 0),
-  handle_dot([$.|Rest], Line + Counter, Scope, Tokens);
+tokenize([$: | String] = Original, Line, Column, Scope, Tokens) ->
+  case tokenize_identifier(String, Line, Column, Scope, false) of
+    {_Kind, Unencoded, Atom, Rest, Length, Ascii, _Special} ->
+      NewScope = maybe_warn_for_ambiguous_bang_before_equals(atom, Unencoded, Rest, Line, Column, Scope),
+      TrackedScope = track_ascii(Ascii, NewScope),
+      Token = {atom, {Line, Column, Unencoded}, Atom},
+      tokenize(Rest, Line, Column + 1 + Length, TrackedScope, [Token | Tokens]);
+    empty when Scope#elixir_tokenizer.cursor_completion == false ->
+      unexpected_token(Original, Line, Column, Scope, Tokens);
+    empty ->
+      tokenize([], Line, Column, Scope, Tokens);
+    {unexpected_token, Length} ->
+      unexpected_token(lists:nthtail(Length - 1, String), Line, Column + Length - 1, Scope, Tokens);
+    {error, Reason} ->
+      error(Reason, Original, Scope, Tokens)
+  end;
 
 % Integers and floats
+% We use int and flt otherwise elixir_parser won't format them
+% properly in case of errors.
+
+tokenize([H | T], Line, Column, Scope, Tokens) when ?is_digit(H) ->
+  case tokenize_number(T, [H], 1, false) of
+    {error, Reason, Original} ->
+      error({?LOC(Line, Column), Reason, Original}, T, Scope, Tokens);
+    {[I | Rest], Number, Original, _Length} when ?is_upcase(I); ?is_downcase(I); I == $_ ->
+      if
+        Number == 0, (I =:= $x) orelse (I =:= $o) orelse (I =:= $b), Rest == [],
+        Scope#elixir_tokenizer.cursor_completion /= false ->
+          tokenize([], Line, Column, Scope, Tokens);
+
+        true ->
+          Msg =
+            io_lib:format(
+              "invalid character \"~ts\" after number ~ts. If you intended to write a number, "
+              "make sure to separate the number from the character (using comma, space, etc). "
+              "If you meant to write a function name or a variable, note that identifiers in "
+              "Elixir cannot start with numbers. Unexpected token: ",
+              [[I], Original]
+            ),
+
+          error({?LOC(Line, Column), Msg, [I]}, T, Scope, Tokens)
+      end;
+    {Rest, Number, Original, Length} when is_integer(Number) ->
+      Token = {int, {Line, Column, Number}, Original},
+      tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]);
+    {Rest, Number, Original, Length} ->
+      Token = {flt, {Line, Column, Number}, Original},
+      tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens])
+  end;
 
-tokenize([H|_] = String, Line, Scope, Tokens) when ?is_digit(H) ->
-  {Rest, Number} = tokenize_number(String, [], false),
-  tokenize(Rest, Line, Scope, [{number, Line, Number}|Tokens]);
+% Spaces
 
-% Aliases
+tokenize([T | Rest], Line, Column, Scope, Tokens) when ?is_horizontal_space(T) ->
+  {Remaining, NewLine, NewColumn} = strip_horizontal_space(Rest, Line, Column + 1, Scope),
+  handle_space_sensitive_tokens(Remaining, NewLine, NewColumn, Scope, Tokens);
+
+% End of line
+
+tokenize(";" ++ Rest, Line, Column, Scope, []) ->
+  tokenize(Rest, Line, Column + 1, Scope, [{';', {Line, Column, 0}}]);
+
+tokenize(";" ++ Rest, Line, Column, Scope, [Top | _] = Tokens) when element(1, Top) /= ';' ->
+  tokenize(Rest, Line, Column + 1, Scope, [{';', {Line, Column, 0}} | Tokens]);
+
+tokenize("\\" = Original, Line, Column, Scope, Tokens) ->
+  error({?LOC(Line, Column), "invalid escape \\ at end of file", []}, Original, Scope, Tokens);
+
+tokenize("\\\n" = Original, Line, Column, Scope, Tokens) ->
+  error({?LOC(Line, Column), "invalid escape \\ at end of file", []}, Original, Scope, Tokens);
+
+tokenize("\\\r\n" = Original, Line, Column, Scope, Tokens) ->
+  error({?LOC(Line, Column), "invalid escape \\ at end of file", []}, Original, Scope, Tokens);
+
+tokenize("\\\n" ++ Rest, Line, _Column, Scope, Tokens) ->
+  tokenize_eol(Rest, Line, Scope, Tokens);
+
+tokenize("\\\r\n" ++ Rest, Line, _Column, Scope, Tokens) ->
+  tokenize_eol(Rest, Line, Scope, Tokens);
+
+tokenize("\n" ++ Rest, Line, Column, Scope, Tokens) ->
+  tokenize_eol(Rest, Line, Scope, eol(Line, Column, Tokens));
+
+tokenize("\r\n" ++ Rest, Line, Column, Scope, Tokens) ->
+  tokenize_eol(Rest, Line, Scope, eol(Line, Column, Tokens));
+
+% Others
+
+tokenize([$%, $( | Rest], Line, Column, Scope, Tokens) ->
+  Reason = {?LOC(Line, Column), "expected %{ to define a map, got: ", [$%, $(]},
+  error(Reason, Rest, Scope, Tokens);
+
+tokenize([$%, $[ | Rest], Line, Column, Scope, Tokens) ->
+  Reason = {?LOC(Line, Column), "expected %{ to define a map, got: ", [$%, $[]},
+  error(Reason, Rest, Scope, Tokens);
+
+tokenize([$%, ${ | T], Line, Column, Scope, Tokens) ->
+  Token = {'{', {Line, Column, nil}},
+  handle_terminator(T, Line, Column + 2, Scope, Token, [{'%{}', {Line, Column, nil}} | Tokens]);
+
+tokenize([$% | T], Line, Column, Scope, Tokens) ->
+  tokenize(T, Line, Column + 1, Scope, [{'%', {Line, Column, nil}} | Tokens]);
+
+tokenize([$. | T], Line, Column, Scope, Tokens) ->
+  tokenize_dot(T, Line, Column + 1, {Line, Column, nil}, Scope, Tokens);
+
+% Identifiers
+
+tokenize(String, Line, Column, OriginalScope, Tokens) ->
+  case tokenize_identifier(String, Line, Column, OriginalScope, not previous_was_dot(Tokens)) of
+    {Kind, Unencoded, Atom, Rest, Length, Ascii, Special} ->
+      HasAt = lists:member(at, Special),
+      Scope = track_ascii(Ascii, OriginalScope),
 
-tokenize([H|_] = Original, Line, Scope, Tokens) when ?is_upcase(H) ->
-  {Rest, Alias} = tokenize_identifier(Original, []),
-  case unsafe_to_atom(Alias, Line, Scope) of
-    {ok, Atom} ->
       case Rest of
-        [$:|T] when ?is_space(hd(T)) ->
-          tokenize(T, Line, Scope, [{kw_identifier, Line, Atom}|Tokens]);
+        [$: | T] when ?is_space(hd(T)) ->
+          Token = {kw_identifier, {Line, Column, Unencoded}, Atom},
+          tokenize(T, Line, Column + Length + 1, Scope, [Token | Tokens]);
+
+        [$: | T] when hd(T) =/= $: ->
+          AtomName = atom_to_list(Atom) ++ [$:],
+          Reason = {?LOC(Line, Column), "keyword argument must be followed by space after: ", AtomName},
+          error(Reason, String, Scope, Tokens);
+
+        _ when HasAt ->
+          Reason = {?LOC(Line, Column), invalid_character_error(Kind, $@), atom_to_list(Atom)},
+          error(Reason, String, Scope, Tokens);
+
+        _ when Atom == '__aliases__'; Atom == '__block__' ->
+          error({?LOC(Line, Column), "reserved token: ", atom_to_list(Atom)}, Rest, Scope, Tokens);
+
+        _ when Kind == alias ->
+          tokenize_alias(Rest, Line, Column, Unencoded, Atom, Length, Ascii, Special, Scope, Tokens);
+
+        _ when Kind == identifier ->
+          NewScope = maybe_warn_for_ambiguous_bang_before_equals(identifier, Unencoded, Rest, Line, Column, Scope),
+          Token = check_call_identifier(Line, Column, Unencoded, Atom, Rest),
+          tokenize(Rest, Line, Column + Length, NewScope, [Token | Tokens]);
+
         _ ->
-          tokenize(Rest, Line, Scope, [{aliases, Line, [Atom]}|Tokens])
+          unexpected_token(String, Line, Column, Scope, Tokens)
       end;
-    {error, Reason} ->
-      {error, Reason, Original, Tokens}
-  end;
-
-% Identifier
 
-tokenize([H|_] = String, Line, Scope, Tokens) when ?is_downcase(H); H == $_ ->
-  case tokenize_any_identifier(String, Line, Scope, Tokens) of
-    {keyword, Rest, Check, T} ->
-      handle_terminator(Rest, Line, Scope, Check, T);
-    {identifier, Rest, Token} ->
-      tokenize(Rest, Line, Scope, [Token|Tokens]);
-    {error, _, _, _} = Error ->
-      Error
-  end;
+    {keyword, Atom, Type, Rest, Length} ->
+      tokenize_keyword(Type, Rest, Line, Column, Atom, Length, OriginalScope, Tokens);
 
-% Ambiguous unary/binary operators tokens
+    empty when OriginalScope#elixir_tokenizer.cursor_completion == false ->
+      unexpected_token(String, Line, Column, OriginalScope, Tokens);
 
-tokenize([Space, Sign, NotMarker|T], Line, Scope, [{Identifier, _, _} = H|Tokens]) when
-    ?dual_op(Sign),
-    ?is_horizontal_space(Space),
-    not(?is_space(NotMarker)),
-    NotMarker /= $(, NotMarker /= $[, NotMarker /= $<, NotMarker /= ${,                  %% containers
-    NotMarker /= $%, NotMarker /= $+, NotMarker /= $-, NotMarker /= $/, NotMarker /= $>, %% operators
-    Identifier == identifier ->
-  Rest = [NotMarker|T],
-  tokenize(Rest, Line, Scope, [{dual_op, Line, list_to_atom([Sign])}, setelement(1, H, op_identifier)|Tokens]);
+    empty  ->
+      case String of
+        [$~, L] when ?is_upcase(L); ?is_downcase(L) -> tokenize([], Line, Column, OriginalScope, Tokens);
+        [$~] -> tokenize([], Line, Column, OriginalScope, Tokens);
+        _ -> unexpected_token(String, Line, Column, OriginalScope, Tokens)
+      end;
 
-% Spaces
+    {unexpected_token, Length} ->
+      unexpected_token(lists:nthtail(Length - 1, String), Line, Column + Length - 1, OriginalScope, Tokens);
 
-tokenize([T|Rest], Line, Scope, Tokens) when ?is_horizontal_space(T) ->
-  tokenize(strip_horizontal_space(Rest), Line, Scope, Tokens);
-tokenize(T, Line, _Scope, Tokens) ->
-  {error, {Line, "invalid token: ", until_eol(T)}, T, Tokens}.
-
-strip_horizontal_space([H|T]) when ?is_horizontal_space(H) ->
-  strip_horizontal_space(T);
-strip_horizontal_space(T) ->
-  T.
-
-strip_space(T, Counter) ->
-  case strip_horizontal_space(T) of
-    "\r\n" ++ Rest -> strip_space(Rest, Counter + 1);
-    "\n" ++ Rest   -> strip_space(Rest, Counter + 1);
-    Rest           -> {Rest, Counter}
+    {error, Reason} ->
+      error(Reason, String, OriginalScope, Tokens)
   end.
 
-until_eol("\r\n" ++ _) -> [];
-until_eol("\n" ++ _)   -> [];
-until_eol([])          -> [];
-until_eol([H|T])       -> [H|until_eol(T)].
+previous_was_dot([{'.', _} | _]) -> true;
+previous_was_dot(_) -> false.
+
+unexpected_token([T | Rest], Line, Column, Scope, Tokens) ->
+  Message =
+    case handle_char(T) of
+      {_Escaped, Explanation} ->
+        io_lib:format("~ts (column ~p, code point U+~4.16.0B)", [Explanation, Column, T]);
+      false ->
+        io_lib:format("\"~ts\" (column ~p, code point U+~4.16.0B)", [[T], Column, T])
+    end,
+  error({?LOC(Line, Column), "unexpected token: ", Message}, Rest, Scope, Tokens).
+
+tokenize_eol(Rest, Line, Scope, Tokens) ->
+  {StrippedRest, NewLine, NewColumn} =
+    strip_horizontal_space(Rest, Line + 1, Scope#elixir_tokenizer.column, Scope),
+  IndentedScope = Scope#elixir_tokenizer{indentation=NewColumn-1},
+  tokenize(StrippedRest, NewLine, NewColumn, IndentedScope, Tokens).
+
+strip_horizontal_space([H | T], Line, Counter, Scope) when ?is_horizontal_space(H) ->
+  strip_horizontal_space(T, Line, Counter + 1, Scope);
+%% \\ at the end of lines is treated as horizontal whitespace
+%% except at the very end of the buffer, which we treat as incomplete
+strip_horizontal_space("\\\n" ++ T, Line, _Counter, Scope) when T /= [] ->
+  strip_horizontal_space(T, Line+1, Scope#elixir_tokenizer.column, Scope);
+strip_horizontal_space("\\\r\n" ++ T, Line, _Counter, Scope) when T /= [] ->
+  strip_horizontal_space(T, Line+1, Scope#elixir_tokenizer.column, Scope);
+strip_horizontal_space(T, Line, Counter, _Scope) ->
+  {T, Line, Counter}.
+
+tokenize_dot(T, Line, Column, DotInfo, Scope, Tokens) ->
+  case strip_horizontal_space(T, Line, Column, Scope) of
+    {[$# | R], NewLine, NewColumn} ->
+      case tokenize_comment(R, [$#]) of
+        {error, Char, Reason} ->
+          error_comment(Char, Reason, [$# | R], NewLine, NewColumn, Scope, Tokens);
+
+        {Rest, Comment} ->
+          preserve_comments(NewLine, NewColumn, Tokens, Comment, Rest, Scope),
+          tokenize_dot(Rest, NewLine, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens)
+      end;
+    {"\r\n" ++ Rest, NewLine, _NewColumn} ->
+      tokenize_dot(Rest, NewLine + 1, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens);
+    {"\n" ++ Rest, NewLine, _NewColumn} ->
+      tokenize_dot(Rest, NewLine + 1, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens);
+    {Rest, NewLine, NewColumn} ->
+      handle_dot([$. | Rest], NewLine, NewColumn, DotInfo, Scope, Tokens)
+  end.
 
-escape_char(List) ->
-  << Char/utf8 >> = elixir_interpolation:unescape_chars(list_to_binary(List)),
-  Char.
+handle_char(0)   -> {"\\0", "null byte"};
+handle_char(7)   -> {"\\a", "alert"};
+handle_char($\b) -> {"\\b", "backspace"};
+handle_char($\d) -> {"\\d", "delete"};
+handle_char($\e) -> {"\\e", "escape"};
+handle_char($\f) -> {"\\f", "form feed"};
+handle_char($\n) -> {"\\n", "newline"};
+handle_char($\r) -> {"\\r", "carriage return"};
+handle_char($\s) -> {"\\s", "space"};
+handle_char($\t) -> {"\\t", "tab"};
+handle_char($\v) -> {"\\v", "vertical tab"};
+handle_char(_)  -> false.
 
 %% Handlers
 
-handle_heredocs(T, Line, H, Scope, Tokens) ->
-  case extract_heredoc_with_interpolation(Line, Scope, true, T, H) of
-    {ok, NewLine, Parts, Rest} ->
-      Token = {string_type(H), Line, unescape_tokens(Parts)},
-      tokenize(Rest, NewLine, Scope, [Token|Tokens]);
+handle_heredocs(T, Line, Column, H, Scope, Tokens) ->
+  case extract_heredoc_with_interpolation(Line, Column, Scope, true, T, H) of
+    {ok, NewLine, NewColumn, Parts, Rest, NewScope} ->
+      case unescape_tokens(Parts, Line, Column, NewScope) of
+        {ok, Unescaped} ->
+          Token = {heredoc_type(H), {Line, Column, nil}, NewColumn - 4, Unescaped},
+          tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]);
+
+        {error, Reason} ->
+          error(Reason, Rest, Scope, Tokens)
+      end;
+
     {error, Reason} ->
-      {error, Reason, [H, H, H] ++ T, Tokens}
+      error(Reason, [H, H, H] ++ T, Scope, Tokens)
   end.
 
-handle_strings(T, Line, H, Scope, Tokens) ->
-  case elixir_interpolation:extract(Line, Scope, true, T, H) of
+handle_strings(T, Line, Column, H, Scope, Tokens) ->
+  case elixir_interpolation:extract(Line, Column, Scope, true, T, H) of
     {error, Reason} ->
-      interpolation_error(Reason, [H|T], Tokens, " (for string starting at line ~B)", [Line]);
-    {NewLine, Parts, [$:|Rest]} when ?is_space(hd(Rest)) ->
-      Unescaped = unescape_tokens(Parts),
-      Key = case Scope#elixir_tokenizer.existing_atoms_only of
-        true  -> kw_identifier_safe;
-        false -> kw_identifier_unsafe
+      interpolation_error(Reason, [H | T], Scope, Tokens, " (for string starting at line ~B)", [Line], Line, Column-1, [H], [H]);
+
+    {NewLine, NewColumn, Parts, [$: | Rest], InterScope} when ?is_space(hd(Rest)) ->
+      NewScope = case is_unnecessary_quote(Parts, InterScope) of
+        true ->
+          WarnMsg = io_lib:format(
+            "found quoted keyword \"~ts\" but the quotes are not required. "
+            "Note that keywords are always atoms, even when quoted. "
+            "Similar to atoms, keywords made exclusively of ASCII "
+            "letters, numbers, and underscores and not beginning with a "
+            "number do not require quotes",
+            [hd(Parts)]
+          ),
+          prepend_warning(Line, Column-1, WarnMsg, InterScope);
+
+        false when H =:= $' ->
+          WarnMsg = "single quotes around keywords are deprecated. Use double quotes instead",
+          prepend_warning(Line, Column-1, WarnMsg, InterScope);
+
+        false ->
+          InterScope
       end,
-      tokenize(Rest, NewLine, Scope, [{Key, Line, Unescaped}|Tokens]);
-    {NewLine, Parts, Rest} ->
-      Token = {string_type(H), Line, unescape_tokens(Parts)},
-      tokenize(Rest, NewLine, Scope, [Token|Tokens])
-  end.
 
-handle_unary_op([$:|Rest], Line, _Kind, Op, Scope, Tokens) when ?is_space(hd(Rest)) ->
-  tokenize(Rest, Line, Scope, [{kw_identifier, Line, Op}|Tokens]);
+      case unescape_tokens(Parts, Line, Column, NewScope) of
+        {ok, [Part]} when is_binary(Part) ->
+          case unsafe_to_atom(Part, Line, Column - 1, Scope) of
+            {ok, Atom} ->
+              Token = {kw_identifier, {Line, Column - 1, H}, Atom},
+              tokenize(Rest, NewLine, NewColumn + 1, NewScope, [Token | Tokens]);
+            {error, Reason} ->
+              error(Reason, Rest, NewScope, Tokens)
+          end;
+
+        {ok, Unescaped} ->
+          Key = case Scope#elixir_tokenizer.existing_atoms_only of
+            true  -> kw_identifier_safe;
+            false -> kw_identifier_unsafe
+          end,
+          Token = {Key, {Line, Column - 1, H}, Unescaped},
+          tokenize(Rest, NewLine, NewColumn + 1, NewScope, [Token | Tokens]);
 
-handle_unary_op(Rest, Line, Kind, Op, Scope, Tokens) ->
-  case strip_horizontal_space(Rest) of
-    [$/|_] -> tokenize(Rest, Line, Scope, [{identifier, Line, Op}|Tokens]);
-    _ -> tokenize(Rest, Line, Scope, [{Kind, Line, Op}|Tokens])
+        {error, Reason} ->
+          error(Reason, Rest, NewScope, Tokens)
+      end;
+
+    {NewLine, NewColumn, Parts, Rest, InterScope} ->
+      NewScope =
+        case H of
+          $' ->
+            Message = "using single-quoted strings to represent charlists is deprecated.\n"
+              "Use ~c\"\" if you indeed want a charlist or use \"\" instead.\n"
+              "You may run \"mix format --migrate\" to change all single-quoted\n"
+              "strings to use the ~c sigil and fix this warning.",
+            prepend_warning(Line, Column-1, Message, InterScope);
+
+          _ ->
+            InterScope
+        end,
+
+      case unescape_tokens(Parts, Line, Column, NewScope) of
+        {ok, Unescaped} ->
+          Token = {string_type(H), {Line, Column - 1, nil}, Unescaped},
+          tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]);
+
+        {error, Reason} ->
+          error(Reason, Rest, NewScope, Tokens)
+      end
   end.
 
-handle_op([$:|Rest], Line, _Kind, Op, Scope, Tokens) when ?is_space(hd(Rest)) ->
-  tokenize(Rest, Line, Scope, [{kw_identifier, Line, Op}|Tokens]);
+handle_unary_op([$: | Rest], Line, Column, _Kind, Length, Op, Scope, Tokens) when ?is_space(hd(Rest)) ->
+  Token = {kw_identifier, {Line, Column, nil}, Op},
+  tokenize(Rest, Line, Column + Length + 1, Scope, [Token | Tokens]);
+
+handle_unary_op(Rest, Line, Column, Kind, Length, Op, Scope, Tokens) ->
+  case strip_horizontal_space(Rest, Line, Column + Length, Scope) of
+    {[$/ | _] = Remaining, NewLine, NewColumn} ->
+      Token = {identifier, {Line, Column, nil}, Op},
+      tokenize(Remaining, NewLine, NewColumn, Scope, [Token | Tokens]);
+    {Remaining, NewLine, NewColumn} ->
+      NewScope =
+        %% TODO: Remove these deprecations on Elixir v2.0
+        case Op of
+          '~~~' ->
+            Msg = "~~~ is deprecated. Use Bitwise.bnot/1 instead for clarity",
+            prepend_warning(Line, Column, Msg, Scope);
+          _ ->
+            Scope
+        end,
+
+      Token = {Kind, {Line, Column, nil}, Op},
+      tokenize(Remaining, NewLine, NewColumn, NewScope, [Token | Tokens])
+  end.
 
-handle_op(Rest, Line, Kind, Op, Scope, Tokens) ->
-  case strip_horizontal_space(Rest) of
-    [$/|_] -> tokenize(Rest, Line, Scope, [{identifier, Line, Op}|Tokens]);
-    _ -> tokenize(Rest, Line, Scope, add_token_with_nl({Kind, Line, Op}, Tokens))
+handle_op([$: | Rest], Line, Column, _Kind, Length, Op, Scope, Tokens) when ?is_space(hd(Rest)) ->
+  Token = {kw_identifier, {Line, Column, nil}, Op},
+  tokenize(Rest, Line, Column + Length + 1, Scope, [Token | Tokens]);
+
+handle_op(Rest, Line, Column, Kind, Length, Op, Scope, Tokens) ->
+  case strip_horizontal_space(Rest, Line, Column + Length, Scope) of
+    {[$/ | _] = Remaining, NewLine, NewColumn} ->
+      Token = {identifier, {Line, Column, nil}, Op},
+      tokenize(Remaining, NewLine, NewColumn, Scope, [Token | Tokens]);
+    {Remaining, NewLine, NewColumn} ->
+      NewScope =
+        %% TODO: Remove these deprecations on Elixir v2.0
+        case Op of
+          '^^^' ->
+            Msg = "^^^ is deprecated. It is typically used as xor but it has the wrong precedence, use Bitwise.bxor/2 instead",
+            prepend_warning(Line, Column, Msg, Scope);
+
+          '<|>' ->
+            Msg = "<|> is deprecated. Use another pipe-like operator",
+            prepend_warning(Line, Column, Msg, Scope);
+
+          _ ->
+            Scope
+        end,
+
+      Token = {Kind, {Line, Column, previous_was_eol(Tokens)}, Op},
+      tokenize(Remaining, NewLine, NewColumn, NewScope, add_token_with_eol(Token, Tokens))
   end.
 
 % ## Three Token Operators
-handle_dot([$.,T1,T2,T3|Rest], Line, Scope, Tokens) when
+handle_dot([$., T1, T2, T3 | Rest], Line, Column, DotInfo, Scope, Tokens) when
     ?unary_op3(T1, T2, T3); ?comp_op3(T1, T2, T3); ?and_op3(T1, T2, T3); ?or_op3(T1, T2, T3);
-    ?arrow_op3(T1, T2, T3); ?hat_op3(T1, T2, T3) ->
-  handle_call_identifier(Rest, Line, list_to_atom([T1, T2, T3]), Scope, Tokens);
+    ?arrow_op3(T1, T2, T3); ?xor_op3(T1, T2, T3); ?concat_op3(T1, T2, T3) ->
+  handle_call_identifier(Rest, Line, Column, DotInfo, 3, [T1, T2, T3], Scope, Tokens);
 
 % ## Two Token Operators
-handle_dot([$.,T1,T2|Rest], Line, Scope, Tokens) when
+handle_dot([$., T1, T2 | Rest], Line, Column, DotInfo, Scope, Tokens) when
     ?comp_op2(T1, T2); ?rel_op2(T1, T2); ?and_op(T1, T2); ?or_op(T1, T2);
-    ?arrow_op(T1, T2); ?in_match_op(T1, T2); ?two_op(T1, T2); ?stab_op(T1, T2);
+    ?arrow_op(T1, T2); ?in_match_op(T1, T2); ?concat_op(T1, T2); ?power_op(T1, T2);
     ?type_op(T1, T2) ->
-  handle_call_identifier(Rest, Line, list_to_atom([T1, T2]), Scope, Tokens);
+  handle_call_identifier(Rest, Line, Column, DotInfo, 2, [T1, T2], Scope, Tokens);
 
 % ## Single Token Operators
-handle_dot([$.,T|Rest], Line, Scope, Tokens) when
+handle_dot([$., T | Rest], Line, Column, DotInfo, Scope, Tokens) when
     ?at_op(T); ?unary_op(T); ?capture_op(T); ?dual_op(T); ?mult_op(T);
-    ?rel_op(T); ?match_op(T); ?pipe_op(T); T == $% ->
-  handle_call_identifier(Rest, Line, list_to_atom([T]), Scope, Tokens);
+    ?rel_op(T); ?match_op(T); ?pipe_op(T) ->
+  handle_call_identifier(Rest, Line, Column, DotInfo, 1, [T], Scope, Tokens);
 
 % ## Exception for .( as it needs to be treated specially in the parser
-handle_dot([$.,$(|Rest], Line, Scope, Tokens) ->
-  tokenize([$(|Rest], Line, Scope, add_token_with_nl({dot_call_op, Line, '.'}, Tokens));
+handle_dot([$., $( | Rest], Line, Column, DotInfo, Scope, Tokens) ->
+  TokensSoFar = add_token_with_eol({dot_call_op, DotInfo, '.'}, Tokens),
+  tokenize([$( | Rest], Line, Column, Scope, TokensSoFar);
+
+handle_dot([$., H | T] = Original, Line, Column, DotInfo, BaseScope, Tokens) when ?is_quote(H) ->
+  Scope = case H == $' of
+    true ->
+      prepend_warning(Line, Column, "single quotes around calls are deprecated. Use double quotes instead", BaseScope);
+
+    false ->
+      BaseScope
+  end,
+
+  case elixir_interpolation:extract(Line, Column + 1, Scope, true, T, H) of
+    {NewLine, NewColumn, [Part], Rest, InterScope} when is_list(Part) ->
+      NewScope = case is_unnecessary_quote([Part], InterScope) of
+        true ->
+          WarnMsg = io_lib:format(
+            "found quoted call \"~ts\" but the quotes are not required. "
+            "Calls made exclusively of Unicode letters, numbers, and underscores "
+            "and not beginning with a number do not require quotes",
+            [Part]
+          ),
+          prepend_warning(Line, Column, WarnMsg, InterScope);
+
+        false ->
+          InterScope
+      end,
+
+      case unescape_tokens([Part], Line, Column, NewScope) of
+        {ok, [UnescapedPart]} ->
+          case unsafe_to_atom(UnescapedPart, Line, Column, NewScope) of
+            {ok, Atom} ->
+              Token = check_call_identifier(Line, Column, H, Atom, Rest),
+              TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens),
+              tokenize(Rest, NewLine, NewColumn, NewScope, [Token | TokensSoFar]);
+
+            {error, Reason} ->
+              error(Reason, Original, NewScope, Tokens)
+          end;
 
-handle_dot([$.,H|T] = Original, Line, Scope, Tokens) when ?is_quote(H) ->
-  case elixir_interpolation:extract(Line, Scope, true, T, H) of
-    {NewLine, [Part], Rest} when is_binary(Part) ->
-      case unsafe_to_atom(Part, Line, Scope) of
-        {ok, Atom} ->
-          Token = check_call_identifier(identifier, Line, Atom, Rest),
-          tokenize(Rest, NewLine, Scope, [Token|add_token_with_nl({'.', Line}, Tokens)]);
         {error, Reason} ->
-          {error, Reason, Original, Tokens}
+          error(Reason, Original, NewScope, Tokens)
       end;
+
+    {_NewLine, _NewColumn, _Parts, Rest, NewScope} ->
+      Message = "interpolation is not allowed when calling function/macro. Found interpolation in a call starting with: ",
+      error({?LOC(Line, Column), Message, [H]}, Rest, NewScope, Tokens);
     {error, Reason} ->
-      interpolation_error(Reason, Original, Tokens, " (for function name starting at line ~B)", [Line])
+      interpolation_error(Reason, Original, Scope, Tokens, " (for function name starting at line ~B)", [Line], Line, Column, [H], [H])
   end;
 
-handle_dot([$.|Rest], Line, Scope, Tokens) ->
-  tokenize(Rest, Line, Scope, add_token_with_nl({'.', Line}, Tokens)).
-
-handle_call_identifier(Rest, Line, Op, Scope, Tokens) ->
-  Token = check_call_identifier(identifier, Line, Op, Rest),
-  tokenize(Rest, Line, Scope, [Token|add_token_with_nl({'.', Line}, Tokens)]).
+handle_dot([$. | Rest], Line, Column, DotInfo, Scope, Tokens) ->
+  TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens),
+  tokenize(Rest, Line, Column, Scope, TokensSoFar).
+
+handle_call_identifier(Rest, Line, Column, DotInfo, Length, UnencodedOp, Scope, Tokens) ->
+  Token = check_call_identifier(Line, Column, UnencodedOp, list_to_atom(UnencodedOp), Rest),
+  TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens),
+  tokenize(Rest, Line, Column + Length, Scope, [Token | TokensSoFar]).
+
+% ## Ambiguous unary/binary operators tokens
+% Keywords are not ambiguous operators
+handle_space_sensitive_tokens([Sign, $:, Space | _] = String, Line, Column, Scope, Tokens) when
+    ?dual_op(Sign), ?is_space(Space) ->
+  tokenize(String, Line, Column, Scope, Tokens);
+
+% But everything else, except other operators, are
+handle_space_sensitive_tokens([Sign, NotMarker | T], Line, Column, Scope, [{identifier, _, _} = H | Tokens]) when
+    ?dual_op(Sign), not(?is_space(NotMarker)),
+    %% Do not match ++ or --
+    NotMarker =/= Sign,
+    %% Do not match +/2 or -/2
+    NotMarker =/= $/,
+    %% Do not match ->
+    NotMarker =/= $>,
+    %% Do not match +\\n or -\\n (it should be treated as if a space is there)
+    NotMarker =/= $\\ ->
+  Rest = [NotMarker | T],
+  DualOpToken = {dual_op, {Line, Column, nil}, list_to_atom([Sign])},
+  tokenize(Rest, Line, Column + 1, Scope, [DualOpToken, setelement(1, H, op_identifier) | Tokens]);
+
+% Handle cursor completion
+handle_space_sensitive_tokens([], Line, Column,
+                              #elixir_tokenizer{cursor_completion=Cursor} = Scope,
+                              [{identifier, Info, Identifier} | Tokens]) when Cursor /= false ->
+  tokenize([$(], Line, Column+1, Scope, [{paren_identifier, Info, Identifier} | Tokens]);
+
+handle_space_sensitive_tokens(String, Line, Column, Scope, Tokens) ->
+  tokenize(String, Line, Column, Scope, Tokens).
 
 %% Helpers
 
-eol(_Line, _Mod, [{',',_}|_] = Tokens)   -> Tokens;
-eol(_Line, _Mod, [{eol,_,_}|_] = Tokens) -> Tokens;
-eol(Line, Mod, Tokens) -> [{eol,Line,Mod}|Tokens].
+eol(_Line, _Column, [{',', {Line, Column, Count}} | Tokens]) ->
+  [{',', {Line, Column, Count + 1}} | Tokens];
+eol(_Line, _Column, [{';', {Line, Column, Count}} | Tokens]) ->
+  [{';', {Line, Column, Count + 1}} | Tokens];
+eol(_Line, _Column, [{eol, {Line, Column, Count}} | Tokens]) ->
+  [{eol, {Line, Column, Count + 1}} | Tokens];
+eol(Line, Column, Tokens) ->
+  [{eol, {Line, Column, 1}} | Tokens].
+
+is_unnecessary_quote([Part], Scope) when is_list(Part) ->
+  case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(Part) of
+    {identifier, _, [], _, true, Special} -> not lists:member(at, Special);
+    _ -> false
+  end;
+is_unnecessary_quote(_Parts, _Scope) ->
+  false.
 
-unsafe_to_atom(Part, Line, #elixir_tokenizer{}) when
-    is_binary(Part) andalso size(Part) > 255;
+unsafe_to_atom(Part, Line, Column, #elixir_tokenizer{}) when
+    is_binary(Part) andalso byte_size(Part) > 255;
     is_list(Part) andalso length(Part) > 255 ->
-  {error, {Line, "atom length must be less than system limit", ":"}};
-unsafe_to_atom(Binary, _Line, #elixir_tokenizer{existing_atoms_only=true}) when is_binary(Binary) ->
-  {ok, binary_to_existing_atom(Binary, utf8)};
-unsafe_to_atom(Binary, _Line, #elixir_tokenizer{}) when is_binary(Binary) ->
-  {ok, binary_to_atom(Binary, utf8)};
-unsafe_to_atom(List, _Line, #elixir_tokenizer{existing_atoms_only=true}) when is_list(List) ->
-  {ok, list_to_existing_atom(List)};
-unsafe_to_atom(List, _Line, #elixir_tokenizer{}) when is_list(List) ->
-  {ok, list_to_atom(List)}.
-
-collect_modifiers([H|T], Buffer) when ?is_downcase(H) ->
-  collect_modifiers(T, [H|Buffer]);
+  try
+    PartList = elixir_utils:characters_to_list(Part),
+    {error, {?LOC(Line, Column), "atom length must be less than system limit: ", PartList}}
+  catch
+    error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->
+      {error, {?LOC(Line, Column), "invalid encoding in atom: ", elixir_utils:characters_to_list(Message)}}
+  end;
+unsafe_to_atom(Part, Line, Column, #elixir_tokenizer{static_atoms_encoder=StaticAtomsEncoder}) when
+    is_function(StaticAtomsEncoder) ->
+  EncodeResult = try
+    ValueEncBin = elixir_utils:characters_to_binary(Part),
+    ValueEncList = elixir_utils:characters_to_list(Part),
+    {ok, ValueEncBin, ValueEncList}
+  catch
+    error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->
+      {error, {?LOC(Line, Column), "invalid encoding in atom: ", elixir_utils:characters_to_list(Message)}}
+  end,
+
+  case EncodeResult of
+    {ok, Value, ValueList} ->
+      case StaticAtomsEncoder(Value, [{line, Line}, {column, Column}]) of
+        {ok, Term} ->
+          {ok, Term};
+        {error, Reason} when is_binary(Reason) ->
+          {error, {?LOC(Line, Column), elixir_utils:characters_to_list(Reason) ++ ": ", ValueList}}
+      end;
+    EncError -> EncError
+  end;
+unsafe_to_atom(Binary, Line, Column, #elixir_tokenizer{existing_atoms_only=true}) when is_binary(Binary) ->
+  try
+    {ok, binary_to_existing_atom(Binary, utf8)}
+  catch
+    error:badarg ->
+      % Check if it's a UTF-8 issue by trying to convert to list
+      try
+        List = elixir_utils:characters_to_list(Binary),
+        % If we get here, it's not a UTF-8 issue
+        {error, {?LOC(Line, Column), "unsafe atom does not exist: ", List}}
+      catch
+        error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->
+          {error, {?LOC(Line, Column), "invalid encoding in atom: ", elixir_utils:characters_to_list(Message)}}
+      end
+  end;
+unsafe_to_atom(Binary, Line, Column, #elixir_tokenizer{}) when is_binary(Binary) ->
+  try
+    {ok, binary_to_atom(Binary, utf8)}
+  catch
+    error:badarg ->
+      % Try to convert using elixir_utils to get proper UnicodeConversionError
+      try
+        List = elixir_utils:characters_to_list(Binary),
+        % If we get here, it's not a UTF-8 issue, so it's some other badarg
+        {error, {?LOC(Line, Column), "invalid atom: ", List}}
+      catch
+        error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->
+          {error, {?LOC(Line, Column), "invalid encoding in atom: ", elixir_utils:characters_to_list(Message)}}
+      end
+  end;
+unsafe_to_atom(List, Line, Column, #elixir_tokenizer{existing_atoms_only=true}) when is_list(List) ->
+  try
+    {ok, list_to_existing_atom(List)}
+  catch
+    error:badarg ->
+      % Try to convert using elixir_utils to get proper UnicodeConversionError
+      try
+        elixir_utils:characters_to_binary(List),
+        % If we get here, it's not a UTF-8 issue
+        {error, {?LOC(Line, Column), "unsafe atom does not exist: ", List}}
+      catch
+        error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->
+          {error, {?LOC(Line, Column), "invalid encoding in atom: ", elixir_utils:characters_to_list(Message)}}
+      end
+  end;
+unsafe_to_atom(List, Line, Column, #elixir_tokenizer{}) when is_list(List) ->
+  try
+    {ok, list_to_atom(List)}
+  catch
+    error:badarg ->
+      % Try to convert using elixir_utils to get proper UnicodeConversionError
+      try
+        elixir_utils:characters_to_binary(List),
+        % If we get here, it's not a UTF-8 issue, so it's some other badarg
+        {error, {?LOC(Line, Column), "invalid atom: ", List}}
+      catch
+        error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->
+          {error, {?LOC(Line, Column), "invalid encoding in atom: ", elixir_utils:characters_to_list(Message)}}
+      end
+  end.
+
+collect_modifiers([H | T], Buffer) when ?is_downcase(H) or ?is_upcase(H) or ?is_digit(H) ->
+  collect_modifiers(T, [H | Buffer]);
 
 collect_modifiers(Rest, Buffer) ->
   {Rest, lists:reverse(Buffer)}.
 
 %% Heredocs
 
-extract_heredoc_with_interpolation(Line, Scope, Interpol, T, H) ->
-  case extract_heredoc(Line, T, H) of
-    {ok, NewLine, Body, Rest} ->
-      case elixir_interpolation:extract(Line + 1, Scope, Interpol, Body, 0) of
-        {error, Reason} ->
-          {error, interpolation_format(Reason, " (for heredoc starting at line ~B)", [Line])};
-        {_, Parts, []} ->
-          {ok, NewLine, Parts, Rest}
-      end;
-    {error, _} = Error ->
-      Error
-  end.
-
-extract_heredoc(Line0, Rest0, Marker) ->
-  case extract_heredoc_header(Rest0) of
-    {ok, Rest1} ->
+extract_heredoc_with_interpolation(Line, Column, Scope, Interpol, T, H) ->
+  case extract_heredoc_header(T) of
+    {ok, Headerless} ->
       %% We prepend a new line so we can transparently remove
-      %% spaces later. This new line is removed by calling `tl`
+      %% spaces later. This new line is removed by calling "tl"
       %% in the final heredoc body three lines below.
-      case extract_heredoc_body(Line0, Marker, [$\n|Rest1], []) of
-        {ok, Line1, Body, Rest2, Spaces} ->
-          {ok, Line1, tl(remove_heredoc_spaces(Body, Spaces)), Rest2};
-        {error, ErrorLine} ->
-          Terminator = [Marker, Marker, Marker],
-          Message = "missing terminator: ~ts (for heredoc starting at line ~B)",
-          {error, {ErrorLine, io_lib:format(Message, [Terminator, Line0]), []}}
+      case elixir_interpolation:extract(Line, Column, Scope, Interpol, [$\n|Headerless], [H,H,H]) of
+        {NewLine, NewColumn, Parts0, Rest, InterScope} ->
+          Indent = NewColumn - 4,
+          Fun = fun(Part, Acc) -> extract_heredoc_indent(Part, Acc, Indent) end,
+          {Parts1, {ShouldWarn, _}} = lists:mapfoldl(Fun, {false, Line}, Parts0),
+          Parts2 = extract_heredoc_head(Parts1),
+          NewScope = maybe_heredoc_warn(ShouldWarn, Column, InterScope, H),
+          try
+            {ok, NewLine, NewColumn, tokens_to_binary(Parts2), Rest, NewScope}
+          catch
+            error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->
+              {error, interpolation_format(Message, " (for heredoc starting at line ~B)", [Line], Line, Column, [H, H, H], [H, H, H])}
+          end;
+
+        {error, Reason} ->
+          {error, interpolation_format(Reason, " (for heredoc starting at line ~B)", [Line], Line, Column, [H, H, H], [H, H, H])}
       end;
+
     error ->
-      Message = "heredoc start must be followed by a new line after ",
-      {error, {Line0, io_lib:format(Message, []), [Marker, Marker, Marker]}}
+      Message = "heredoc allows only whitespace characters followed by a new line after opening ",
+      {error, {?LOC(Line, Column + 3), io_lib:format(Message, []), [H, H, H]}}
   end.
 
-%% Remove spaces from heredoc based on the position of the final quotes.
-
-remove_heredoc_spaces(Body, 0) ->
-  lists:reverse([0|Body]);
-remove_heredoc_spaces(Body, Spaces) ->
-  remove_heredoc_spaces([0|Body], [], Spaces, Spaces).
-remove_heredoc_spaces([H,$\n|T], [Backtrack|Buffer], Spaces, Original) when Spaces > 0, ?is_horizontal_space(H) ->
-  remove_heredoc_spaces([Backtrack,$\n|T], Buffer, Spaces - 1, Original);
-remove_heredoc_spaces([$\n=H|T], Buffer, _Spaces, Original) ->
-  remove_heredoc_spaces(T, [H|Buffer], Original, Original);
-remove_heredoc_spaces([H|T], Buffer, Spaces, Original) ->
-  remove_heredoc_spaces(T, [H|Buffer], Spaces, Original);
-remove_heredoc_spaces([], Buffer, _Spaces, _Original) ->
-  Buffer.
-
-%% Extract the heredoc header.
-
 extract_heredoc_header("\r\n" ++ Rest) ->
   {ok, Rest};
 extract_heredoc_header("\n" ++ Rest) ->
   {ok, Rest};
-extract_heredoc_header([H|T]) when ?is_horizontal_space(H) ->
+extract_heredoc_header([H | T]) when ?is_horizontal_space(H) ->
   extract_heredoc_header(T);
 extract_heredoc_header(_) ->
   error.
 
-%% Extract heredoc body. It returns the heredoc body (in reverse order),
-%% the remaining of the document and the number of spaces the heredoc
-%% is aligned.
-
-extract_heredoc_body(Line, Marker, Rest, Buffer) ->
-  case extract_heredoc_line(Marker, Rest, Buffer, 0) of
-    {ok, NewBuffer, NewRest} ->
-      extract_heredoc_body(Line + 1, Marker, NewRest, NewBuffer);
-    {ok, NewBuffer, NewRest, Spaces} ->
-      {ok, Line, NewBuffer, NewRest, Spaces};
-    {error, eof} ->
-      {error, Line}
+extract_heredoc_indent(Part, {Warned, Line}, Indent) when is_list(Part) ->
+  extract_heredoc_indent(Part, [], Warned, Line, Indent);
+extract_heredoc_indent({_, {EndLine, _, _}, _} = Part, {Warned, _Line}, _Indent) ->
+  {Part, {Warned, EndLine}}.
+
+extract_heredoc_indent([$\n | Rest], Acc, Warned, Line, Indent) ->
+  {Trimmed, ShouldWarn} = trim_space(Rest, Indent),
+  Warn = if ShouldWarn, not Warned -> Line + 1; true -> Warned end,
+  extract_heredoc_indent(Trimmed, [$\n | Acc], Warn, Line + 1, Indent);
+extract_heredoc_indent([Head | Rest], Acc, Warned, Line, Indent) ->
+  extract_heredoc_indent(Rest, [Head | Acc], Warned, Line, Indent);
+extract_heredoc_indent([], Acc, Warned, Line, _Indent) ->
+  {lists:reverse(Acc), {Warned, Line}}.
+
+trim_space(Rest, 0) -> {Rest, false};
+trim_space([$\r, $\n | _] = Rest, _) -> {Rest, false};
+trim_space([$\n | _] = Rest, _) -> {Rest, false};
+trim_space([H | T], Spaces) when ?is_horizontal_space(H) -> trim_space(T, Spaces - 1);
+trim_space([], _Spaces) -> {[], false};
+trim_space(Rest, _Spaces) -> {Rest, true}.
+
+maybe_heredoc_warn(false, _Column, Scope, _Marker) ->
+  Scope;
+maybe_heredoc_warn(Line, Column, Scope, Marker) ->
+  Msg = io_lib:format("outdented heredoc line. The contents inside the heredoc should be indented "
+                      "at the same level as the closing ~ts. The following is forbidden:~n~n"
+                      "    def text do~n"
+                      "      \"\"\"~n"
+                      "    contents~n"
+                      "      \"\"\"~n"
+                      "    end~n~n"
+                      "Instead make sure the contents are indented as much as the heredoc closing:~n~n"
+                      "    def text do~n"
+                      "      \"\"\"~n"
+                      "      contents~n"
+                      "      \"\"\"~n"
+                      "    end~n~n"
+                      "The current heredoc line is indented too little", [[Marker, Marker, Marker]]),
+
+  prepend_warning(Line, Column, Msg, Scope).
+
+extract_heredoc_head([[$\n|H]|T]) -> [H|T].
+
+unescape_tokens(Tokens, Line, Column, #elixir_tokenizer{unescape=true}) ->
+  case elixir_interpolation:unescape_tokens(Tokens) of
+    {ok, Result} ->
+      {ok, Result};
+
+    {error, Message, Token} ->
+      {error, {?LOC(Line, Column), Message ++ ". Syntax error after: ", Token}}
+  end;
+unescape_tokens(Tokens, Line, Column, #elixir_tokenizer{unescape=false}) ->
+  try
+    {ok, tokens_to_binary(Tokens)}
+  catch
+    error:#{'__struct__' := 'Elixir.UnicodeConversionError', message := Message} ->
+      {error, {?LOC(Line, Column), "invalid encoding in tokens: ", elixir_utils:characters_to_list(Message)}}
   end.
 
-%% Extract a line from the heredoc prepending its contents to a buffer.
-
-extract_heredoc_line("\r\n" ++ Rest, Buffer) ->
-  {ok, [$\n|Buffer], Rest};
-extract_heredoc_line("\n" ++ Rest, Buffer) ->
-  {ok, [$\n|Buffer], Rest};
-extract_heredoc_line([H|T], Buffer) ->
-  extract_heredoc_line(T, [H|Buffer]);
-extract_heredoc_line(_, _) ->
-  {error, eof}.
-
-%% Extract each heredoc line trying to find a match according to the marker.
-
-extract_heredoc_line(Marker, [H|T], Buffer, Counter) when ?is_horizontal_space(H) ->
-  extract_heredoc_line(Marker, T, [H|Buffer], Counter + 1);
-extract_heredoc_line(Marker, [Marker,Marker,Marker|T], Buffer, Counter) ->
-  {ok, Buffer, T, Counter};
-extract_heredoc_line(_Marker, Rest, Buffer, _Counter) ->
-  extract_heredoc_line(Rest, Buffer).
+tokens_to_binary(Tokens) ->
+  [if is_list(Token) -> elixir_utils:characters_to_binary(Token); true -> Token end
+   || Token <- Tokens].
 
 %% Integers and floats
 %% At this point, we are at least sure the first digit is a number.
 
 %% Check if we have a point followed by a number;
-tokenize_number([$.,H|T], Acc, false) when ?is_digit(H) ->
-  tokenize_number(T, [H,$.|Acc], true);
+tokenize_number([$., H | T], Acc, Length, false) when ?is_digit(H) ->
+  tokenize_number(T, [H, $. | Acc], Length + 2, true);
 
 %% Check if we have an underscore followed by a number;
-tokenize_number([$_,H|T], Acc, Bool) when ?is_digit(H) ->
-  tokenize_number(T, [H|Acc], Bool);
+tokenize_number([$_, H | T], Acc, Length, Bool) when ?is_digit(H) ->
+  tokenize_number(T, [H, $_ | Acc], Length + 2, Bool);
 
 %% Check if we have e- followed by numbers (valid only for floats);
-tokenize_number([E,S,H|T], Acc, true)
-    when (E == $E) or (E == $e), ?is_digit(H), S == $+ orelse S == $- ->
-  tokenize_number(T, [H,S,$e|Acc], true);
+tokenize_number([E, S, H | T], Acc, Length, true)
+    when (E =:= $E) or (E =:= $e), ?is_digit(H), S =:= $+ orelse S =:= $- ->
+  tokenize_number(T, [H, S, E | Acc], Length + 3, true);
 
 %% Check if we have e followed by numbers (valid only for floats);
-tokenize_number([E,H|T], Acc, true)
-    when (E == $E) or (E == $e), ?is_digit(H) ->
-  tokenize_number(T, [H,$e|Acc], true);
+tokenize_number([E, H | T], Acc, Length, true)
+    when (E =:= $E) or (E =:= $e), ?is_digit(H) ->
+  tokenize_number(T, [H, E | Acc], Length + 2, true);
 
 %% Finally just numbers.
-tokenize_number([H|T], Acc, Bool) when ?is_digit(H) ->
-  tokenize_number(T, [H|Acc], Bool);
+tokenize_number([H | T], Acc, Length, Bool) when ?is_digit(H) ->
+  tokenize_number(T, [H | Acc], Length + 1, Bool);
 
 %% Cast to float...
-tokenize_number(Rest, Acc, true) ->
-  {Rest, list_to_float(lists:reverse(Acc))};
+tokenize_number(Rest, Acc, Length, true) ->
+  try
+    {Number, Original} = reverse_number(Acc, [], []),
+    {Rest, list_to_float(Number), Original, Length}
+  catch
+    error:badarg -> {error, "invalid float number ", lists:reverse(Acc)}
+  end;
 
 %% Or integer.
-tokenize_number(Rest, Acc, false) ->
-  {Rest, list_to_integer(lists:reverse(Acc))}.
+tokenize_number(Rest, Acc, Length, false) ->
+  {Number, Original} = reverse_number(Acc, [], []),
+  {Rest, list_to_integer(Number), Original, Length}.
+
+tokenize_hex([H | T], Acc, Length) when ?is_hex(H) ->
+  tokenize_hex(T, [H | Acc], Length + 1);
+tokenize_hex([$_, H | T], Acc, Length) when ?is_hex(H) ->
+  tokenize_hex(T, [H, $_ | Acc], Length + 2);
+tokenize_hex(Rest, Acc, Length) ->
+  {Number, Original} = reverse_number(Acc, [], []),
+  {Rest, list_to_integer(Number, 16), [$0, $x | Original], Length}.
+
+tokenize_octal([H | T], Acc, Length) when ?is_octal(H) ->
+  tokenize_octal(T, [H | Acc], Length + 1);
+tokenize_octal([$_, H | T], Acc, Length) when ?is_octal(H) ->
+  tokenize_octal(T, [H, $_ | Acc], Length + 2);
+tokenize_octal(Rest, Acc, Length) ->
+  {Number, Original} = reverse_number(Acc, [], []),
+  {Rest, list_to_integer(Number, 8), [$0, $o | Original], Length}.
+
+tokenize_bin([H | T], Acc, Length) when ?is_bin(H) ->
+  tokenize_bin(T, [H | Acc], Length + 1);
+tokenize_bin([$_, H | T], Acc, Length) when ?is_bin(H) ->
+  tokenize_bin(T, [H, $_ | Acc], Length + 2);
+tokenize_bin(Rest, Acc, Length) ->
+  {Number, Original} = reverse_number(Acc, [], []),
+  {Rest, list_to_integer(Number, 2), [$0, $b | Original], Length}.
+
+reverse_number([$_ | T], Number, Original) ->
+  reverse_number(T, Number, [$_ | Original]);
+reverse_number([H | T], Number, Original) ->
+  reverse_number(T, [H | Number], [H | Original]);
+reverse_number([], Number, Original) ->
+  {Number, Original}.
 
-tokenize_hex([H|T], Acc) when ?is_hex(H) -> tokenize_hex(T, [H|Acc]);
-tokenize_hex(Rest, Acc) -> {Rest, list_to_integer(lists:reverse(Acc), 16)}.
+%% Comments
 
-tokenize_octal([H|T], Acc) when ?is_octal(H) -> tokenize_octal(T, [H|Acc]);
-tokenize_octal(Rest, Acc) -> {Rest, list_to_integer(lists:reverse(Acc), 8)}.
+reset_eol([{eol, {Line, Column, _}} | Rest]) -> [{eol, {Line, Column, 0}} | Rest];
+reset_eol(Rest) -> Rest.
+
+tokenize_comment("\r\n" ++ _ = Rest, Acc) ->
+  {Rest, lists:reverse(Acc)};
+tokenize_comment("\n" ++ _ = Rest, Acc) ->
+  {Rest, lists:reverse(Acc)};
+tokenize_comment([H | _Rest], _) when ?bidi(H) ->
+  {error, H, "invalid bidirectional formatting character in comment: "};
+tokenize_comment([H | _Rest], _) when ?break(H) ->
+  {error, H, "invalid line break character in comment: "};
+tokenize_comment([H | Rest], Acc) ->
+  tokenize_comment(Rest, [H | Acc]);
+tokenize_comment([], Acc) ->
+  {[], lists:reverse(Acc)}.
+
+error_comment(Char, Reason, Comment, Line, Column, Scope, Tokens) ->
+  Token = io_lib:format("\\u~4.16.0B", [Char]),
+  error({?LOC(Line, Column), Reason, Token}, Comment, Scope, Tokens).
+
+preserve_comments(Line, Column, Tokens, Comment, Rest, Scope) ->
+  case Scope#elixir_tokenizer.preserve_comments of
+    Fun when is_function(Fun) ->
+      Fun(Line, Column, Tokens, Comment, Rest);
+    nil ->
+      ok
+  end.
 
-tokenize_bin([H|T], Acc) when ?is_bin(H) -> tokenize_bin(T, [H|Acc]);
-tokenize_bin(Rest, Acc) -> {Rest, list_to_integer(lists:reverse(Acc), 2)}.
+%% Identifiers
 
-%% Comments
+tokenize([H | T]) when ?is_upcase(H) ->
+  {Acc, Rest, Length, Special} = tokenize_continue(T, [H], 1, []),
+  {alias, lists:reverse(Acc), Rest, Length, true, Special};
+tokenize([H | T]) when ?is_downcase(H); H =:= $_ ->
+  {Acc, Rest, Length, Special} = tokenize_continue(T, [H], 1, []),
+  {identifier, lists:reverse(Acc), Rest, Length, true, Special};
+tokenize(_List) ->
+  {error, empty}.
+
+tokenize_continue([$@ | T], Acc, Length, Special) ->
+  tokenize_continue(T, [$@ | Acc], Length + 1, [at | lists:delete(at, Special)]);
+tokenize_continue([$! | T], Acc, Length, Special) ->
+  {[$! | Acc], T, Length + 1, [punctuation | Special]};
+tokenize_continue([$? | T], Acc, Length, Special) ->
+  {[$? | Acc], T, Length + 1, [punctuation | Special]};
+tokenize_continue([H | T], Acc, Length, Special) when ?is_upcase(H); ?is_downcase(H); ?is_digit(H); H =:= $_ ->
+  tokenize_continue(T, [H | Acc], Length + 1, Special);
+tokenize_continue(Rest, Acc, Length, Special) ->
+  {Acc, Rest, Length, Special}.
+
+tokenize_identifier(String, Line, Column, Scope, MaybeKeyword) ->
+  case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(String) of
+    {Kind, Acc, Rest, Length, Ascii, Special} ->
+      Keyword = MaybeKeyword andalso maybe_keyword(Rest),
+
+      case keyword_or_unsafe_to_atom(Keyword, Acc, Line, Column, Scope) of
+        {keyword, Atom, Type} ->
+          {keyword, Atom, Type, Rest, Length};
+        {ok, Atom} ->
+          {Kind, Acc, Atom, Rest, Length, Ascii, Special};
+        {error, _Reason} = Error ->
+          Error
+      end;
 
-tokenize_comment("\r\n" ++ _ = Rest) -> Rest;
-tokenize_comment("\n" ++ _ = Rest)   -> Rest;
-tokenize_comment([_|Rest])           -> tokenize_comment(Rest);
-tokenize_comment([])                 -> [].
+    {error, {mixed_script, Wrong, {Prefix, Suffix}}} ->
+      WrongColumn = Column + length(Wrong) - 1,
+      case suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) of
+        no_suggestion ->
+          %% we append a pointer to more info if we aren't appending a suggestion
+          MoreInfo = "\nSee https://hexdocs.pm/elixir/unicode-syntax.html for more information.",
+          {error, {?LOC(Line, Column), {Prefix, Suffix ++ MoreInfo}, Wrong}};
 
-%% Atoms
-%% Handle atoms specially since they support @
+        {_, {Location, _, SuggestionMessage}} = _SuggestionError ->
+          {error, {Location, {Prefix, Suffix ++ SuggestionMessage}, Wrong}}
+      end;
 
-tokenize_atom([H|T], Acc) when ?is_atom(H) ->
-  tokenize_atom(T, [H|Acc]);
+    {error, {unexpected_token, Wrong}} ->
+      WrongColumn = Column + length(Wrong) - 1,
+      case suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) of
+        no_suggestion ->
+          [T | _] = lists:reverse(Wrong),
+          case suggest_simpler_unexpected_token_in_error([T], Line, WrongColumn, Scope) of
+            no_suggestion -> {unexpected_token, length(Wrong)};
+            SuggestionError -> SuggestionError
+          end;
+
+        SuggestionError ->
+          SuggestionError
+      end;
 
-tokenize_atom([H|T], Acc) when H == $?; H == $! ->
-  {T, lists:reverse([H|Acc])};
+    {error, empty} ->
+      empty
+  end.
 
-tokenize_atom(Rest, Acc) ->
-  {Rest, lists:reverse(Acc)}.
+%% heuristic: try nfkc; try confusability skeleton; try calling this again w/just failed codepoint
+suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) ->
+  NFKC = unicode:characters_to_nfkc_list(Wrong),
+  case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(NFKC) of
+    {error, _Reason} ->
+       ConfusableSkeleton = 'Elixir.String.Tokenizer.Security':confusable_skeleton(Wrong),
+       case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(ConfusableSkeleton) of
+         {_, Simpler, _, _, _, _} ->
+           Message = suggest_change("Codepoint failed identifier tokenization, but a simpler form was found.",
+                                    Wrong,
+                                    "You could write the above in a similar way that is accepted by Elixir:",
+                                    Simpler,
+                                    "See https://hexdocs.pm/elixir/unicode-syntax.html for more information."),
+           {error, {?LOC(Line, WrongColumn), "unexpected token: ", Message}};
+         _other ->
+           no_suggestion
+       end;
+    {_, _NFKC, _, _, _, _} ->
+      Message = suggest_change("Elixir expects unquoted Unicode atoms, variables, and calls to use allowed codepoints and to be in NFC form.",
+                               Wrong,
+                               "You could write the above in a compatible format that is accepted by Elixir:",
+                               NFKC,
+                               "See https://hexdocs.pm/elixir/unicode-syntax.html for more information."),
+          {error, {?LOC(Line, WrongColumn), "unexpected token: ", Message}}
+    end.
+
+suggest_change(Intro, WrongForm, Hint, HintedForm, Ending) ->
+  WrongCodepoints = list_to_codepoint_hex(WrongForm),
+  HintedCodepoints = list_to_codepoint_hex(HintedForm),
+  io_lib:format("~ts\n\nGot:\n\n    \"~ts\" (code points~ts)\n\n"
+                "Hint: ~ts\n\n    \"~ts\" (code points~ts)\n\n~ts",
+                [Intro, WrongForm, WrongCodepoints, Hint, HintedForm, HintedCodepoints, Ending]).
+
+maybe_keyword([]) -> true;
+maybe_keyword([$:, $: | _]) -> true;
+maybe_keyword([$: | _]) -> false;
+maybe_keyword(_) -> true.
+
+list_to_codepoint_hex(List) ->
+  [io_lib:format(" 0x~5.16.0B", [Codepoint]) || Codepoint <- List].
+
+tokenize_alias(Rest, Line, Column, Unencoded, Atom, Length, Ascii, Special, Scope, Tokens) ->
+  if
+    not Ascii or (Special /= []) ->
+      Invalid = hd([C || C <- Unencoded, (C < $A) or (C > 127)]),
+      Reason = {?LOC(Line, Column), invalid_character_error("alias (only ASCII characters, without punctuation, are allowed)", Invalid), Unencoded},
+      error(Reason, Unencoded ++ Rest, Scope, Tokens);
+
+    true ->
+      AliasesToken = {alias, {Line, Column, Unencoded}, Atom},
+      tokenize(Rest, Line, Column + Length, Scope, [AliasesToken | Tokens])
+  end.
 
-%% Identifiers
-%% At this point, the validity of the first character was already verified.
+%% Check if it is a call identifier (paren | bracket | do)
 
-tokenize_identifier([H|T], Acc) when ?is_identifier(H) ->
-  tokenize_identifier(T, [H|Acc]);
+check_call_identifier(Line, Column, Info, Atom, [$( | _]) ->
+  {paren_identifier, {Line, Column, Info}, Atom};
+check_call_identifier(Line, Column, Info, Atom, [$[ | _]) ->
+  {bracket_identifier, {Line, Column, Info}, Atom};
+check_call_identifier(Line, Column, Info, Atom, _Rest) ->
+  {identifier, {Line, Column, Info}, Atom}.
 
-tokenize_identifier(Rest, Acc) ->
-  {Rest, lists:reverse(Acc)}.
+add_token_with_eol({unary_op, _, _} = Left, T) -> [Left | T];
+add_token_with_eol(Left, [{eol, _} | T]) -> [Left | T];
+add_token_with_eol(Left, T) -> [Left | T].
 
-%% Tokenize any identifier, handling kv, punctuated, paren, bracket and do identifiers.
+previous_was_eol([{',', {_, _, Count}} | _]) when Count > 0 -> Count;
+previous_was_eol([{';', {_, _, Count}} | _]) when Count > 0 -> Count;
+previous_was_eol([{eol, {_, _, Count}} | _]) when Count > 0 -> Count;
+previous_was_eol(_) -> nil.
 
-tokenize_any_identifier(Original, Line, Scope, Tokens) ->
-  {Rest, Identifier} = tokenize_identifier(Original, []),
+%% Error handling
 
-  {AllIdentifier, AllRest} =
-    case Rest of
-      [H|T] when H == $?; H == $! -> {Identifier ++ [H], T};
-      _ -> {Identifier, Rest}
-    end,
+interpolation_error(Reason, Rest, Scope, Tokens, Extension, Args, Line, Column, Opening, Closing) ->
+  error(interpolation_format(Reason, Extension, Args, Line, Column, Opening, Closing), Rest, Scope, Tokens).
+
+interpolation_format({string, EndLine, EndColumn, Message, Token}, Extension, Args, Line, Column, Opening, Closing) ->
+  Meta = [
+    {opening_delimiter, list_to_atom(Opening)},
+    {expected_delimiter, list_to_atom(Closing)},
+    {line, Line},
+    {column, Column},
+    {end_line, EndLine},
+    {end_column, EndColumn}
+  ],
+  {Meta, [Message, io_lib:format(Extension, Args)], Token};
+interpolation_format({_, _, _} = Reason, _Extension, _Args, _Line, _Column, _Opening, _Closing) ->
+  Reason.
 
-  case unsafe_to_atom(AllIdentifier, Line, Scope) of
-    {ok, Atom} ->
-      tokenize_kw_or_other(AllRest, identifier, Line, Atom, Tokens);
+%% Terminators
+
+handle_terminator(Rest, _, _, Scope, {'(', {Line, Column, _}}, [{alias, _, Alias} | Tokens]) when is_atom(Alias) ->
+  Reason =
+    io_lib:format(
+      "unexpected ( after alias ~ts. Function names and identifiers in Elixir "
+      "start with lowercase characters or underscore. For example:\n\n"
+      "    hello_world()\n"
+      "    _starting_with_underscore()\n"
+      "    numb3rs_are_allowed()\n"
+      "    may_finish_with_question_mark?()\n"
+      "    may_finish_with_exclamation_mark!()\n\n"
+      "Unexpected token: ",
+      [Alias]
+    ),
+
+  error({?LOC(Line, Column), Reason, ["("]}, atom_to_list(Alias) ++ [$( | Rest], Scope, Tokens);
+handle_terminator(Rest, Line, Column, #elixir_tokenizer{terminators=none} = Scope, Token, Tokens) ->
+  tokenize(Rest, Line, Column, Scope, [Token | Tokens]);
+handle_terminator(Rest, Line, Column, Scope, Token, Tokens) ->
+  #elixir_tokenizer{terminators=Terminators} = Scope,
+
+  case check_terminator(Token, Terminators, Scope) of
     {error, Reason} ->
-      {error, Reason, Original, Tokens}
+      error(Reason, atom_to_list(element(1, Token)) ++ Rest, Scope, Tokens);
+    {ok, New} ->
+      tokenize(Rest, Line, Column, New, [Token | Tokens])
   end.
 
-tokenize_kw_or_other([$:,H|T], _Kind, Line, Atom, _Tokens) when ?is_space(H) ->
-  {identifier, [H|T], {kw_identifier, Line, Atom}};
-
-tokenize_kw_or_other([$:,H|T], _Kind, Line, Atom, Tokens) when ?is_atom_start(H); ?is_digit(H) ->
-  Original = atom_to_list(Atom) ++ [$:],
-  Reason   = {Line, "keyword argument must be followed by space after: ", Original},
-  {error, Reason, Original ++ [H|T], Tokens};
-
-tokenize_kw_or_other(Rest, Kind, Line, Atom, Tokens) ->
-  case check_keyword(Line, Atom, Tokens) of
-    nomatch ->
-      {identifier, Rest, check_call_identifier(Kind, Line, Atom, Rest)};
-    {ok, [Check|T]} ->
-      {keyword, Rest, Check, T};
-    {error, Token} ->
-      {error, {Line, "syntax error before: ", Token}, atom_to_list(Atom) ++ Rest, Tokens}
-  end.
+check_terminator({Start, Meta}, Terminators, Scope)
+    when Start == '('; Start == '['; Start == '{'; Start == '<<' ->
+  Indentation = Scope#elixir_tokenizer.indentation,
+  {ok, Scope#elixir_tokenizer{terminators=[{Start, Meta, Indentation} | Terminators]}};
 
-%% Check if it is a call identifier (paren | bracket | do)
+check_terminator({Start, Meta}, Terminators, Scope) when Start == 'fn'; Start == 'do' ->
+  Indentation = Scope#elixir_tokenizer.indentation,
 
-check_call_identifier(_Kind, Line, Atom, [$(|_]) -> {paren_identifier, Line, Atom};
-check_call_identifier(_Kind, Line, Atom, [$[|_]) -> {bracket_identifier, Line, Atom};
-check_call_identifier(Kind, Line, Atom, _Rest)   -> {Kind, Line, Atom}.
+  NewScope =
+    case Terminators of
+      %% If the do is indented equally or less than the previous do, it may be a missing end error!
+      [{Start, _, PreviousIndentation} = Previous | _] when Indentation =< PreviousIndentation ->
+        Scope#elixir_tokenizer{mismatch_hints=[Previous | Scope#elixir_tokenizer.mismatch_hints]};
 
-add_token_with_nl(Left, [{eol,_,newline}|T]) -> [Left|T];
-add_token_with_nl(Left, T) -> [Left|T].
+      _ ->
+        Scope
+    end,
 
-%% Error handling
+  {ok, NewScope#elixir_tokenizer{terminators=[{Start, Meta, Indentation} | Terminators]}};
 
-interpolation_error(Reason, Rest, Tokens, Extension, Args) ->
-  {error, interpolation_format(Reason, Extension, Args), Rest, Tokens}.
+check_terminator({'end', {EndLine, _, _}}, [{'do', _, Indentation} | Terminators], Scope) ->
+  NewScope =
+    %% If the end is more indented than the do, it may be a missing do error!
+    case Scope#elixir_tokenizer.indentation > Indentation of
+      true ->
+        Hint = {'end', EndLine, Scope#elixir_tokenizer.indentation},
+        Scope#elixir_tokenizer{mismatch_hints=[Hint | Scope#elixir_tokenizer.mismatch_hints]};
 
-interpolation_format({string, Line, Message, Token}, Extension, Args) ->
-  {Line, io_lib:format("~ts" ++ Extension, [Message|Args]), Token};
-interpolation_format({_, _, _} = Reason, _Extension, _Args) ->
-  Reason.
+      false ->
+        Scope
+    end,
 
-%% Terminators
+  {ok, NewScope#elixir_tokenizer{terminators=Terminators}};
+
+check_terminator({End, {EndLine, EndColumn, _}}, [{Start, {StartLine, StartColumn, _}, _} | Terminators], Scope)
+    when End == 'end'; End == ')'; End == ']'; End == '}'; End == '>>' ->
+  case terminator(Start) of
+    End ->
+      {ok, Scope#elixir_tokenizer{terminators=Terminators}};
+
+    ExpectedEnd ->
+      Meta = [
+        {line, StartLine},
+        {column, StartColumn},
+        {end_line, EndLine},
+        {end_column, EndColumn},
+        {error_type, mismatched_delimiter},
+        {opening_delimiter, Start},
+        {closing_delimiter, End},
+        {expected_delimiter, ExpectedEnd}
+     ],
+     {error, {Meta, unexpected_token_or_reserved(End), [atom_to_list(End)]}}
+  end;
 
-handle_terminator(Rest, Line, Scope, Token, Tokens) ->
-  case handle_terminator(Token, Scope) of
-    {error, Reason} ->
-      {error, Reason, atom_to_list(element(1, Token)) ++ Rest, Tokens};
-    New ->
-      tokenize(Rest, Line, New, [Token|Tokens])
-  end.
+check_terminator({'end', {Line, Column, _}}, [], #elixir_tokenizer{mismatch_hints=Hints}) ->
+  Suffix =
+    case lists:keyfind('end', 1, Hints) of
+      {'end', HintLine, _Indentation} ->
+        io_lib:format("\n~ts the \"end\" on line ~B may not have a matching \"do\" "
+                      "defined before it (based on indentation)", [elixir_errors:prefix(hint), HintLine]);
+      false ->
+        ""
+    end,
 
-handle_terminator(_, #elixir_tokenizer{check_terminators=false} = Scope) ->
-  Scope;
-handle_terminator(Token, #elixir_tokenizer{terminators=Terminators} = Scope) ->
-  case check_terminator(Token, Terminators) of
-    {error, _} = Error -> Error;
-    New -> Scope#elixir_tokenizer{terminators=New}
-  end.
+  {error, {?LOC(Line, Column), {"unexpected reserved word: ", Suffix}, "end"}};
 
-check_terminator({S, Line}, Terminators) when S == 'fn' ->
-  [{fn, Line}|Terminators];
-
-check_terminator({S, _} = New, Terminators) when
-    S == 'do';
-    S == '(';
-    S == '[';
-    S == '{';
-    S == '<<' ->
-  [New|Terminators];
-
-check_terminator({E, _}, [{S, _}|Terminators]) when
-    S == 'do', E == 'end';
-    S == 'fn', E == 'end';
-    S == '(',  E == ')';
-    S == '[',  E == ']';
-    S == '{',  E == '}';
-    S == '<<', E == '>>' ->
-  Terminators;
-
-check_terminator({E, Line}, [{Start, StartLine}|_]) when
-    E == 'end'; E == ')'; E == ']'; E == '}'; E == '>>' ->
-  End = terminator(Start),
-  Message = io_lib:format("\"~ts\" starting at line ~B is missing terminator \"~ts\". "
-                          "Unexpected token: ", [Start, StartLine, End]),
-  {error, {Line, Message, atom_to_list(E)}};
+check_terminator({End, {Line, Column, _}}, [], _Scope)
+    when End == ')'; End == ']'; End == '}'; End == '>>' ->
+  {error, {?LOC(Line, Column), "unexpected token: ", atom_to_list(End)}};
 
-check_terminator({E, Line}, []) when
-    E == 'end'; E == ')'; E == ']'; E == '}'; E == '>>' ->
-  {error, {Line, "unexpected token: ", atom_to_list(E)}};
+check_terminator(_, _, Scope) ->
+  {ok, Scope}.
 
-check_terminator(_, Terminators) ->
-  Terminators.
+unexpected_token_or_reserved('end') -> "unexpected reserved word: ";
+unexpected_token_or_reserved(_) -> "unexpected token: ".
+
+missing_terminator_hint(Start, End, #elixir_tokenizer{mismatch_hints=Hints}) ->
+  case lists:keyfind(Start, 1, Hints) of
+    {Start, {HintLine, _, _}, _} ->
+      io_lib:format("\n~ts it looks like the \"~ts\" on line ~B does not have a matching \"~ts\"",
+                    [elixir_errors:prefix(hint), Start, HintLine, End]);
+    false ->
+      ""
+  end.
 
 string_type($") -> bin_string;
 string_type($') -> list_string.
 
+heredoc_type($") -> bin_heredoc;
+heredoc_type($') -> list_heredoc.
+
 sigil_terminator($() -> $);
 sigil_terminator($[) -> $];
 sigil_terminator(${) -> $};
@@ -904,55 +1647,335 @@ terminator('<<') -> '>>'.
 
 %% Keywords checking
 
-check_keyword(_Line, _Atom, [{'.', _}|_]) ->
-  nomatch;
-check_keyword(DoLine, do, [{Identifier, Line, Atom}|T]) when Identifier == identifier ->
-  {ok, add_token_with_nl({do, DoLine}, [{do_identifier, Line, Atom}|T])};
-check_keyword(Line, do, Tokens) ->
-  case do_keyword_valid(Tokens) of
-    true  -> {ok, add_token_with_nl({do, Line}, Tokens)};
-    false -> {error, "do"}
+keyword_or_unsafe_to_atom(true, "fn", _Line, _Column, _Scope) -> {keyword, 'fn', terminator};
+keyword_or_unsafe_to_atom(true, "do", _Line, _Column, _Scope) -> {keyword, 'do', terminator};
+keyword_or_unsafe_to_atom(true, "end", _Line, _Column, _Scope) -> {keyword, 'end', terminator};
+keyword_or_unsafe_to_atom(true, "true", _Line, _Column, _Scope) -> {keyword, 'true', token};
+keyword_or_unsafe_to_atom(true, "false", _Line, _Column, _Scope) -> {keyword, 'false', token};
+keyword_or_unsafe_to_atom(true, "nil", _Line, _Column, _Scope) -> {keyword, 'nil', token};
+
+keyword_or_unsafe_to_atom(true, "not", _Line, _Column, _Scope) -> {keyword, 'not', unary_op};
+keyword_or_unsafe_to_atom(true, "and", _Line, _Column, _Scope) -> {keyword, 'and', and_op};
+keyword_or_unsafe_to_atom(true, "or", _Line, _Column, _Scope) -> {keyword, 'or', or_op};
+keyword_or_unsafe_to_atom(true, "when", _Line, _Column, _Scope) -> {keyword, 'when', when_op};
+keyword_or_unsafe_to_atom(true, "in", _Line, _Column, _Scope) -> {keyword, 'in', in_op};
+
+keyword_or_unsafe_to_atom(true, "after", _Line, _Column, _Scope) -> {keyword, 'after', block};
+keyword_or_unsafe_to_atom(true, "else", _Line, _Column, _Scope) -> {keyword, 'else', block};
+keyword_or_unsafe_to_atom(true, "catch", _Line, _Column, _Scope) -> {keyword, 'catch', block};
+keyword_or_unsafe_to_atom(true, "rescue", _Line, _Column, _Scope) -> {keyword, 'rescue', block};
+
+keyword_or_unsafe_to_atom(_, Part, Line, Column, Scope) ->
+  unsafe_to_atom(Part, Line, Column, Scope).
+
+tokenize_keyword(terminator, Rest, Line, Column, Atom, Length, Scope, Tokens) ->
+  case tokenize_keyword_terminator(Line, Column, Atom, Tokens) of
+    {ok, [Check | T]} ->
+      handle_terminator(Rest, Line, Column + Length, Scope, Check, T);
+    {error, Message, Token} ->
+      error({?LOC(Line, Column), Message, Token}, Token ++ Rest, Scope, Tokens)
   end;
-check_keyword(Line, Atom, Tokens) ->
-  case keyword(Atom) of
-    false    -> nomatch;
-    token    -> {ok, [{Atom, Line}|Tokens]};
-    block    -> {ok, [{block_identifier, Line, Atom}|Tokens]};
-    unary_op -> {ok, [{unary_op, Line, Atom}|Tokens]};
-    Kind     -> {ok, add_token_with_nl({Kind, Line, Atom}, Tokens)}
+
+tokenize_keyword(token, Rest, Line, Column, Atom, Length, Scope, Tokens) ->
+  Token = {Atom, {Line, Column, nil}},
+  tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]);
+
+tokenize_keyword(block, Rest, Line, Column, Atom, Length, Scope, Tokens) ->
+  Token = {block_identifier, {Line, Column, nil}, Atom},
+  tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]);
+
+tokenize_keyword(Kind, Rest, Line, Column, Atom, Length, Scope, Tokens) ->
+  NewTokens =
+    case strip_horizontal_space(Rest, Line, Column, Scope) of
+      {[$/ | _], _, _} ->
+        [{identifier, {Line, Column, nil}, Atom} | Tokens];
+
+      _ ->
+        Info = {Line, Column, previous_was_eol(Tokens)},
+
+        case {Kind, Tokens} of
+          {in_op, [{unary_op, NotInfo, 'not'} | T]} ->
+            add_token_with_eol({in_op, NotInfo, 'not in', Info}, T);
+
+          {_, _} ->
+            add_token_with_eol({Kind, Info, Atom}, Tokens)
+        end
+    end,
+
+  tokenize(Rest, Line, Column + Length, Scope, NewTokens).
+
+tokenize_sigil([$~ | T], Line, Column, Scope, Tokens) ->
+  case tokenize_sigil_name(T, [], Line, Column + 1, Scope, Tokens) of
+    {ok, Name, Rest, NewLine, NewColumn, NewScope, NewTokens} ->
+      tokenize_sigil_contents(Rest, Name, NewLine, NewColumn, NewScope, NewTokens);
+
+    {error, Message, Token} ->
+      Reason = {?LOC(Line, Column), Message, Token},
+      error(Reason, T, Scope, Tokens)
+  end.
+
+% A one-letter sigil is ok both as upcase as well as downcase.
+tokenize_sigil_name([S | T], [], Line, Column, Scope, Tokens) when ?is_downcase(S) ->
+  tokenize_lower_sigil_name(T, [S], Line, Column + 1, Scope, Tokens);
+tokenize_sigil_name([S | T], [], Line, Column, Scope, Tokens) when ?is_upcase(S) ->
+    tokenize_upper_sigil_name(T, [S], Line, Column + 1, Scope, Tokens).
+
+tokenize_lower_sigil_name([S | _T] = Original, [_ | _] = NameAcc, _Line, _Column, _Scope, _Tokens) when ?is_downcase(S) ->
+  SigilName = lists:reverse(NameAcc) ++ Original,
+  {error, sigil_name_error(), [$~] ++ SigilName};
+tokenize_lower_sigil_name(T, NameAcc, Line, Column, Scope, Tokens) ->
+  {ok, lists:reverse(NameAcc), T, Line, Column, Scope, Tokens}.
+
+% If we have an uppercase letter, we keep tokenizing the name.
+% A digit is allowed but an uppercase letter or digit must proceed it.
+tokenize_upper_sigil_name([S | T], NameAcc, Line, Column, Scope, Tokens) when ?is_upcase(S); ?is_digit(S) ->
+  tokenize_upper_sigil_name(T, [S | NameAcc], Line, Column + 1, Scope, Tokens);
+% With a lowercase letter and a non-empty NameAcc we return an error.
+tokenize_upper_sigil_name([S | _T] = Original, [_ | _] = NameAcc, _Line, _Column, _Scope, _Tokens) when ?is_downcase(S) ->
+  SigilName = lists:reverse(NameAcc) ++ Original,
+  {error,  sigil_name_error(), [$~] ++ SigilName};
+% We finished the letters, so the name is over.
+tokenize_upper_sigil_name(T, NameAcc, Line, Column, Scope, Tokens) ->
+  {ok, lists:reverse(NameAcc), T, Line, Column, Scope, Tokens}.
+
+sigil_name_error() ->
+  "invalid sigil name, it should be either a one-letter lowercase letter or an " ++
+  "uppercase letter optionally followed by uppercase letters and digits, got: ".
+
+tokenize_sigil_contents([H, H, H | T] = Original, [S | _] = SigilName, Line, Column, Scope, Tokens)
+    when ?is_quote(H) ->
+  case extract_heredoc_with_interpolation(Line, Column, Scope, ?is_downcase(S), T, H) of
+    {ok, NewLine, NewColumn, Parts, Rest, NewScope} ->
+      Indentation = NewColumn - 4,
+      add_sigil_token(SigilName, Line, Column, NewLine, NewColumn, Parts, Rest, NewScope, Tokens, Indentation, <<H, H, H>>);
+
+    {error, Reason} ->
+      error(Reason, [$~] ++ SigilName ++ Original, Scope, Tokens)
+  end;
+
+tokenize_sigil_contents([H | T] = Original, [S | _] = SigilName, Line, Column, Scope, Tokens)
+    when ?is_sigil(H) ->
+  case elixir_interpolation:extract(Line, Column + 1, Scope, ?is_downcase(S), T, sigil_terminator(H)) of
+    {NewLine, NewColumn, Parts, Rest, NewScope} ->
+      Indentation = nil,
+      add_sigil_token(SigilName, Line, Column, NewLine, NewColumn, tokens_to_binary(Parts), Rest, NewScope, Tokens, Indentation, <<H>>);
+
+    {error, Reason} ->
+      Sigil = [$~, S, H],
+      Message = " (for sigil ~ts starting at line ~B)",
+      interpolation_error(Reason, [$~] ++ SigilName ++ Original, Scope, Tokens, Message, [Sigil, Line], Line, Column, [H], [sigil_terminator(H)])
+  end;
+
+tokenize_sigil_contents([H | _] = Original, SigilName, Line, Column, Scope, Tokens) ->
+  MessageString =
+    "\"~ts\" (column ~p, code point U+~4.16.0B). The available delimiters are: "
+    "//, ||, \"\", '', (), [], {}, <>",
+  Message = io_lib:format(MessageString, [[H], Column, H]),
+  ErrorColumn = Column - 1 - length(SigilName),
+  error({?LOC(Line, ErrorColumn), "invalid sigil delimiter: ", Message}, [$~] ++ SigilName ++ Original, Scope, Tokens);
+
+% Incomplete sigil.
+tokenize_sigil_contents([], _SigilName, Line, Column, Scope, Tokens) ->
+  tokenize([], Line, Column, Scope, Tokens).
+
+add_sigil_token(SigilName, Line, Column, NewLine, NewColumn, Parts, Rest, Scope, Tokens, Indentation, Delimiter) ->
+  TokenColumn = Column - 1 - length(SigilName),
+  MaybeEncoded = case SigilName of
+    % Single-letter sigils present no risk of atom exhaustion (limited possibilities)
+    [_Char] -> {ok, list_to_atom("sigil_" ++ SigilName)};
+    _ -> unsafe_to_atom("sigil_" ++ SigilName, Line, TokenColumn, Scope)
+  end,
+  case MaybeEncoded of
+    {ok, Atom} ->
+      {Final, Modifiers} = collect_modifiers(Rest, []),
+      Token = {sigil, {Line, TokenColumn, nil}, Atom, Parts, Modifiers, Indentation, Delimiter},
+      NewColumnWithModifiers = NewColumn + length(Modifiers),
+      tokenize(Final, NewLine, NewColumnWithModifiers, Scope, [Token | Tokens]);
+
+    {error, Reason} ->
+      error(Reason, Rest, Scope, Tokens)
   end.
 
-%% do is only valid after the end, true, false and nil keywords
-do_keyword_valid([{Atom, _}|_]) ->
+%% Fail early on invalid do syntax. For example, after
+%% most keywords, after comma and so on.
+tokenize_keyword_terminator(DoLine, DoColumn, do, [{identifier, {Line, Column, Meta}, Atom} | T]) ->
+  {ok, add_token_with_eol({do, {DoLine, DoColumn, nil}},
+                          [{do_identifier, {Line, Column, Meta}, Atom} | T])};
+tokenize_keyword_terminator(_Line, _Column, do, [{'fn', _} | _]) ->
+  {error, invalid_do_with_fn_error("unexpected reserved word: "), "do"};
+tokenize_keyword_terminator(Line, Column, do, Tokens) ->
+  case is_valid_do(Tokens) of
+    true  -> {ok, add_token_with_eol({do, {Line, Column, nil}}, Tokens)};
+    false -> {error, invalid_do_error("unexpected reserved word: "), "do"}
+  end;
+tokenize_keyword_terminator(Line, Column, Atom, Tokens) ->
+  {ok, [{Atom, {Line, Column, nil}} | Tokens]}.
+
+is_valid_do([{Atom, _} | _]) ->
   case Atom of
-    'end' -> true;
-    nil   -> true;
-    true  -> true;
-    false -> true;
-    _     -> keyword(Atom) == false
+    ','      -> false;
+    ';'      -> false;
+    'not'    -> false;
+    'and'    -> false;
+    'or'     -> false;
+    'when'   -> false;
+    'in'     -> false;
+    'after'  -> false;
+    'else'   -> false;
+    'catch'  -> false;
+    'rescue' -> false;
+    _        -> true
   end;
-do_keyword_valid(_) ->
+is_valid_do(_) ->
   true.
 
-% Regular keywords
-keyword('fn')    -> token;
-keyword('end')   -> token;
-keyword('true')  -> token;
-keyword('false') -> token;
-keyword('nil')   -> token;
-
-% Operators keywords
-keyword('not')    -> unary_op;
-keyword('and')    -> and_op;
-keyword('or')     -> or_op;
-keyword('xor')    -> or_op;
-keyword('when')   -> when_op;
-keyword('in')     -> in_op;
-
-% Block keywords
-keyword('after')  -> block;
-keyword('else')   -> block;
-keyword('rescue') -> block;
-keyword('catch')  -> block;
-
-keyword(_) -> false.
+invalid_character_error(What, Char) ->
+  io_lib:format("invalid character \"~ts\" (code point U+~4.16.0B) in ~ts: ", [[Char], Char, What]).
+
+invalid_do_error(Prefix) ->
+  {Prefix, ". In case you wanted to write a \"do\" expression, "
+  "you must either use do-blocks or separate the keyword argument with comma. "
+  "For example, you should either write:\n\n"
+  "    if some_condition? do\n"
+  "      :this\n"
+  "    else\n"
+  "      :that\n"
+  "    end\n\n"
+  "or the equivalent construct:\n\n"
+  "    if(some_condition?, do: :this, else: :that)\n\n"
+  "where \"some_condition?\" is the first argument and the second argument is a keyword list.\n\n"
+  "You may see this error if you forget a trailing comma before the \"do\" in a \"do\" block"}.
+
+invalid_do_with_fn_error(Prefix) ->
+  {Prefix, ". Anonymous functions are written as:\n\n"
+  "    fn pattern -> expression end\n\nPlease remove the \"do\" keyword"}.
+
+% TODO: Turn into an error on v2.0
+maybe_warn_too_many_of_same_char([T | _] = Token, [T | _] = _Rest, Line, Column, Scope) ->
+  Message = io_lib:format(
+    "found \"~ts\" followed by \"~ts\", please use a space between \"~ts\" and the next \"~ts\"",
+    [Token, [T], Token, [T]]
+  ),
+  prepend_warning(Line, Column, Message, Scope);
+maybe_warn_too_many_of_same_char(_Token, _Rest, _Line, _Column, Scope) ->
+  Scope.
+
+%% TODO: Turn into an error on v2.0
+maybe_warn_for_ambiguous_bang_before_equals(Kind, Unencoded, [$= | _], Line, Column, Scope) ->
+  {What, Identifier} =
+    case Kind of
+      atom -> {"atom", [$: | Unencoded]};
+      identifier -> {"identifier", Unencoded}
+    end,
+
+  case lists:last(Identifier) of
+    Last when Last =:= $!; Last =:= $? ->
+      Msg = io_lib:format("found ~ts \"~ts\", ending with \"~ts\", followed by =. "
+                          "It is unclear if you mean \"~ts ~ts=\" or \"~ts =\". Please add "
+                          "a space before or after ~ts to remove the ambiguity",
+                          [What, Identifier, [Last], lists:droplast(Identifier), [Last], Identifier, [Last]]),
+      prepend_warning(Line, Column, Msg, Scope);
+    _ ->
+      Scope
+  end;
+maybe_warn_for_ambiguous_bang_before_equals(_Kind, _Atom, _Rest, _Line, _Column, Scope) ->
+  Scope.
+
+prepend_warning(Line, Column, Msg, #elixir_tokenizer{warnings=Warnings} = Scope) ->
+  Scope#elixir_tokenizer{warnings = [{{Line, Column}, Msg} | Warnings]}.
+
+track_ascii(true, Scope) -> Scope;
+track_ascii(false, Scope) -> Scope#elixir_tokenizer{ascii_identifiers_only=false}.
+
+maybe_unicode_lint_warnings(_Ascii=false, Tokens, Warnings) ->
+  'Elixir.String.Tokenizer.Security':unicode_lint_warnings(lists:reverse(Tokens)) ++ Warnings;
+maybe_unicode_lint_warnings(_Ascii=true, _Tokens, Warnings) ->
+  Warnings.
+
+error(Reason, Rest, #elixir_tokenizer{warnings=Warnings}, Tokens) ->
+  {error, Reason, Rest, Warnings, Tokens}.
+
+%% Cursor handling
+
+add_cursor(_Line, Column, noprune, Terminators, Tokens) ->
+  {Column, Terminators, Tokens};
+add_cursor(Line, Column, prune_and_cursor, Terminators, Tokens) ->
+  PrePrunedTokens = prune_identifier(Tokens),
+  PrunedTokens = prune_tokens(PrePrunedTokens, []),
+  CursorTokens = [
+    {')', {Line, Column + 11, nil}},
+    {'(', {Line, Column + 10, nil}},
+    {paren_identifier, {Line, Column, nil}, '__cursor__'}
+    | PrunedTokens
+  ],
+  {Column + 12, Terminators, CursorTokens}.
+
+prune_identifier([{identifier, _, _} | Tokens]) -> Tokens;
+prune_identifier(Tokens) -> Tokens.
+
+%%% Any terminator needs to be closed
+prune_tokens([{'end', _} | Tokens], Opener) ->
+  prune_tokens(Tokens, ['end' | Opener]);
+prune_tokens([{')', _} | Tokens], Opener) ->
+  prune_tokens(Tokens, [')' | Opener]);
+prune_tokens([{']', _} | Tokens], Opener) ->
+  prune_tokens(Tokens, [']' | Opener]);
+prune_tokens([{'}', _} | Tokens], Opener) ->
+  prune_tokens(Tokens, ['}' | Opener]);
+prune_tokens([{'>>', _} | Tokens], Opener) ->
+  prune_tokens(Tokens, ['>>' | Opener]);
+%%% Close opened terminators
+prune_tokens([{'fn', _} | Tokens], ['end' | Opener]) ->
+  prune_tokens(Tokens, Opener);
+prune_tokens([{'do', _} | Tokens], ['end' | Opener]) ->
+  prune_tokens(Tokens, Opener);
+prune_tokens([{'(', _} | Tokens], [')' | Opener]) ->
+  prune_tokens(Tokens, Opener);
+prune_tokens([{'[', _} | Tokens], [']' | Opener]) ->
+  prune_tokens(Tokens, Opener);
+prune_tokens([{'{', _} | Tokens], ['}' | Opener]) ->
+  prune_tokens(Tokens, Opener);
+prune_tokens([{'<<', _} | Tokens], ['>>' | Opener]) ->
+  prune_tokens(Tokens, Opener);
+%%% or it is time to stop...
+prune_tokens([{';', _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{'eol', _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{',', _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{'fn', _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{'do', _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{'(', _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{'[', _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{'{', _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{'<<', _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{identifier, _, _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{block_identifier, _, _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{kw_identifier, _, _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{kw_identifier_safe, _, _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{kw_identifier_unsafe, _, _} | _] = Tokens, []) ->
+  Tokens;
+prune_tokens([{OpType, _, _} | _] = Tokens, [])
+  when OpType =:= comp_op; OpType =:= at_op; OpType =:= unary_op; OpType =:= and_op;
+       OpType =:= or_op; OpType =:= arrow_op; OpType =:= match_op; OpType =:= in_op;
+       OpType =:= in_match_op; OpType =:= type_op; OpType =:= dual_op; OpType =:= mult_op;
+       OpType =:= power_op; OpType =:= concat_op; OpType =:= range_op; OpType =:= xor_op;
+       OpType =:= pipe_op; OpType =:= stab_op; OpType =:= when_op; OpType =:= assoc_op;
+       OpType =:= rel_op; OpType =:= ternary_op; OpType =:= capture_op; OpType =:= ellipsis_op ->
+  Tokens;
+%%% or we traverse until the end.
+prune_tokens([_ | Tokens], Opener) ->
+  prune_tokens(Tokens, Opener);
+prune_tokens([], _Opener) ->
+  [].
diff --git a/lib/elixir/src/elixir_tokenizer.hrl b/lib/elixir/src/elixir_tokenizer.hrl
new file mode 100644
index 00000000000..88325989597
--- /dev/null
+++ b/lib/elixir/src/elixir_tokenizer.hrl
@@ -0,0 +1,43 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+
+%% Numbers
+-define(is_hex(S), (?is_digit(S) orelse (S >= $A andalso S =< $F) orelse (S >= $a andalso S =< $f))).
+-define(is_bin(S), (S >= $0 andalso S =< $1)).
+-define(is_octal(S), (S >= $0 andalso S =< $7)).
+
+%% Digits and letters
+-define(is_digit(S), (S >= $0 andalso S =< $9)).
+-define(is_upcase(S), (S >= $A andalso S =< $Z)).
+-define(is_downcase(S), (S >= $a andalso S =< $z)).
+
+%% Others
+-define(is_quote(S), (S =:= $" orelse S =:= $')).
+-define(is_sigil(S), (S =:= $/ orelse S =:= $< orelse S =:= $" orelse S =:= $' orelse
+                      S =:= $[ orelse S =:= $( orelse S =:= ${ orelse S =:= $|)).
+-define(LOC(Line, Column), [{line, Line}, {column, Column}]).
+
+%% Spaces
+-define(is_horizontal_space(S), (S =:= $\s orelse S =:= $\t)).
+-define(is_vertical_space(S), (S =:= $\r orelse S =:= $\n)).
+-define(is_space(S), (?is_horizontal_space(S) orelse ?is_vertical_space(S))).
+
+%% Bidirectional control
+%% Retrieved from https://trojansource.codes/trojan-source.pdf
+-define(bidi(C), C =:= 16#202A;
+                 C =:= 16#202B;
+                 C =:= 16#202D;
+                 C =:= 16#202E;
+                 C =:= 16#2066;
+                 C =:= 16#2067;
+                 C =:= 16#2068;
+                 C =:= 16#202C;
+                 C =:= 16#2069).
+
+%% Unsupported newlines
+%% https://www.unicode.org/reports/tr55/
+-define(break(C), C =:= 16#000B;
+                  C =:= 16#000C;
+                  C =:= 16#0085;
+                  C =:= 16#2028;
+                  C =:= 16#2029).
\ No newline at end of file
diff --git a/lib/elixir/src/elixir_translator.erl b/lib/elixir/src/elixir_translator.erl
deleted file mode 100644
index bc0b1389ee9..00000000000
--- a/lib/elixir/src/elixir_translator.erl
+++ /dev/null
@@ -1,425 +0,0 @@
-%% Translate Elixir quoted expressions to Erlang Abstract Format.
-%% Expects the tree to be expanded.
--module(elixir_translator).
--export([translate/2, translate_arg/3, translate_args/2, translate_block/3]).
--import(elixir_scope, [mergev/2, mergec/2]).
--import(elixir_errors, [compile_error/3, compile_error/4]).
--include("elixir.hrl").
-
-%% =
-
-translate({'=', Meta, [Left, Right]}, S) ->
-  Return = case Left of
-    {'_', _, Atom} when is_atom(Atom) -> false;
-    _ -> true
-  end,
-
-  {TRight, SR} = translate_block(Right, Return, S),
-  {TLeft, SL} = elixir_clauses:match(fun translate/2, Left, SR),
-  {{match, ?line(Meta), TLeft, TRight}, SL};
-
-%% Containers
-
-translate({'{}', Meta, Args}, S) when is_list(Args) ->
-  {TArgs, SE} = translate_args(Args, S),
-  {{tuple, ?line(Meta), TArgs}, SE};
-
-translate({'%{}', Meta, Args}, S) when is_list(Args) ->
-  elixir_map:translate_map(Meta, Args, S);
-
-translate({'%', Meta, [Left, Right]}, S) ->
-  elixir_map:translate_struct(Meta, Left, Right, S);
-
-translate({'<<>>', Meta, Args}, S) when is_list(Args) ->
-  elixir_bitstring:translate(Meta, Args, S);
-
-%% Blocks
-
-translate({'__block__', Meta, Args}, #elixir_scope{return=Return} = S) when is_list(Args) ->
-  {TArgs, SA} = translate_block(Args, [], Return, S#elixir_scope{return=true}),
-  {{block, ?line(Meta), TArgs}, SA};
-
-%% Erlang op
-
-translate({'__op__', Meta, [Op, Expr]}, S) when is_atom(Op) ->
-  {TExpr, NS} = translate(Expr, S),
-  {{op, ?line(Meta), Op, TExpr}, NS};
-
-translate({'__op__', Meta, [Op, Left, Right]}, S) when is_atom(Op) ->
-  {[TLeft, TRight], NS}  = translate_args([Left, Right], S),
-  {{op, ?line(Meta), Op, TLeft, TRight}, NS};
-
-%% Lexical
-
-translate({Lexical, _, [_, _]}, S) when Lexical == import; Lexical == alias; Lexical == require ->
-  {{atom, 0, nil}, S};
-
-%% Pseudo variables
-
-translate({'__CALLER__', Meta, Atom}, S) when is_atom(Atom) ->
-  {{var, ?line(Meta), '__CALLER__'}, S#elixir_scope{caller=true}};
-
-%% Functions
-
-translate({'&', Meta, [{'/', [], [{Fun, [], Atom}, Arity]}]}, S)
-    when is_atom(Fun), is_atom(Atom), is_integer(Arity) ->
-  {{'fun', ?line(Meta), {function, Fun, Arity}}, S};
-translate({'&', Meta, [Arg]}, S) when is_integer(Arg) ->
-  compile_error(Meta, S#elixir_scope.file, "unhandled &~B outside of a capture", [Arg]);
-
-translate({fn, Meta, Clauses}, S) ->
-  elixir_fn:translate(Meta, Clauses, S);
-
-%% Cond
-
-translate({'cond', _Meta, [[{do, Pairs}]]}, S) ->
-  [{'->', Meta, [[Condition], Body]}|T] = lists:reverse(Pairs),
-  Case =
-    case Condition of
-      {'_', _, Atom} when is_atom(Atom) ->
-        compile_error(Meta, S#elixir_scope.file, "unbound variable _ inside cond. "
-          "If you want the last clause to always match, you probably meant to use: true ->");
-      X when is_atom(X) and (X /= false) and (X /= nil) ->
-        build_cond_clauses(T, Body, Meta);
-      _ ->
-        {Truthy, Other} = build_truthy_clause(Meta, Condition, Body),
-        Error = {{'.', Meta, [erlang, error]}, [], [cond_clause]},
-        Falsy = {'->', Meta, [[Other], Error]},
-        Acc = {'case', Meta, [Condition, [{do, [Truthy, Falsy]}]]},
-        build_cond_clauses(T, Acc, Meta)
-    end,
-  translate(Case, S);
-
-%% Case
-
-translate({'case', Meta, [Expr, KV]}, #elixir_scope{return=Return} = RS) ->
-  S = RS#elixir_scope{return=true},
-  Clauses = elixir_clauses:get_pairs(do, KV, match),
-  {TExpr, NS} = translate(Expr, S),
-  {TClauses, TS} = elixir_clauses:clauses(Meta, Clauses, Return, NS),
-  {{'case', ?line(Meta), TExpr, TClauses}, TS};
-
-%% Try
-
-translate({'try', Meta, [Clauses]}, #elixir_scope{return=Return} = RS) ->
-  S  = RS#elixir_scope{noname=true, return=true},
-  Do = proplists:get_value('do', Clauses, nil),
-  {TDo, SB} = elixir_translator:translate(Do, S),
-
-  Catch = [Tuple || {X, _} = Tuple <- Clauses, X == 'rescue' orelse X == 'catch'],
-  {TCatch, SC} = elixir_try:clauses(Meta, Catch, Return, mergec(S, SB)),
-
-  case lists:keyfind('after', 1, Clauses) of
-    {'after', After} ->
-      {TBlock, SA} = translate(After, mergec(S, SC)),
-      TAfter = unblock(TBlock);
-    false ->
-      {TAfter, SA} = {[], mergec(S, SC)}
-  end,
-
-  Else = elixir_clauses:get_pairs(else, Clauses, match),
-  {TElse, SE} = elixir_clauses:clauses(Meta, Else, Return, mergec(S, SA)),
-
-  SF = (mergec(S, SE))#elixir_scope{noname=RS#elixir_scope.noname},
-  {{'try', ?line(Meta), unblock(TDo), TElse, TCatch, TAfter}, SF};
-
-%% Receive
-
-translate({'receive', Meta, [KV]}, #elixir_scope{return=Return} = RS) ->
-  S  = RS#elixir_scope{return=true},
-  Do = elixir_clauses:get_pairs(do, KV, match, true),
-
-  case lists:keyfind('after', 1, KV) of
-    false ->
-      {TClauses, SC} = elixir_clauses:clauses(Meta, Do, Return, S),
-      {{'receive', ?line(Meta), TClauses}, SC};
-    _ ->
-      After = elixir_clauses:get_pairs('after', KV, expr),
-      {TClauses, SC} = elixir_clauses:clauses(Meta, Do ++ After, Return, S),
-      {FClauses, TAfter} = elixir_utils:split_last(TClauses),
-      {_, _, [FExpr], _, FAfter} = TAfter,
-      {{'receive', ?line(Meta), FClauses, FExpr, FAfter}, SC}
-  end;
-
-%% Comprehensions
-
-translate({for, Meta, [_|_] = Args}, S) ->
-  elixir_for:translate(Meta, Args, S);
-
-%% Super
-
-translate({super, Meta, Args}, S) when is_list(Args) ->
-  Module = assert_module_scope(Meta, super, S),
-  Function = assert_function_scope(Meta, super, S),
-  elixir_def_overridable:ensure_defined(Meta, Module, Function, S),
-
-  {_, Arity} = Function,
-
-  {TArgs, TS} = if
-    length(Args) == Arity ->
-      translate_args(Args, S);
-    true ->
-      compile_error(Meta, S#elixir_scope.file, "super must be called with the same number of "
-                    "arguments as the current function")
-  end,
-
-  Super = elixir_def_overridable:name(Module, Function),
-  {{call, ?line(Meta), {atom, ?line(Meta), Super}, TArgs}, TS#elixir_scope{super=true}};
-
-%% Variables
-
-translate({'^', Meta, [{Name, VarMeta, Kind}]}, #elixir_scope{context=match} = S) when is_atom(Name), is_atom(Kind) ->
-  Tuple = {Name, var_kind(VarMeta, Kind)},
-  case orddict:find(Tuple, S#elixir_scope.backup_vars) of
-    {ok, {Value, _Counter}} ->
-      {{var, ?line(Meta), Value}, S};
-    error ->
-      compile_error(Meta, S#elixir_scope.file, "unbound variable ^~ts", [Name])
-  end;
-
-translate({'_', Meta, Kind}, #elixir_scope{context=match} = S) when is_atom(Kind) ->
-  {{var, ?line(Meta), '_'}, S};
-
-translate({'_', Meta, Kind}, S) when is_atom(Kind) ->
-  compile_error(Meta, S#elixir_scope.file, "unbound variable _");
-
-translate({Name, Meta, Kind}, #elixir_scope{extra=map_key} = S) when is_atom(Name), is_atom(Kind) ->
-  compile_error(Meta, S#elixir_scope.file, "illegal use of variable ~ts in map key", [Name]);
-
-translate({Name, Meta, Kind}, S) when is_atom(Name), is_atom(Kind) ->
-  elixir_scope:translate_var(Meta, Name, var_kind(Meta, Kind), S);
-
-%% Local calls
-
-translate({Name, Meta, Args}, S) when is_atom(Name), is_list(Meta), is_list(Args) ->
-  if
-    S#elixir_scope.context == match ->
-      compile_error(Meta, S#elixir_scope.file,
-                    "cannot invoke function ~ts/~B inside match", [Name, length(Args)]);
-    S#elixir_scope.context == guard ->
-      Arity = length(Args),
-      File  = S#elixir_scope.file,
-      case Arity of
-        0 -> compile_error(Meta, File, "unknown variable ~ts or cannot invoke "
-                           "function ~ts/~B inside guard", [Name, Name, Arity]);
-        _ -> compile_error(Meta, File, "cannot invoke local ~ts/~B inside guard",
-                           [Name, Arity])
-      end;
-    S#elixir_scope.function == nil ->
-      compile_error(Meta, S#elixir_scope.file, "undefined function ~ts/~B", [Name, length(Args)]);
-    true ->
-      Line = ?line(Meta),
-      {TArgs, NS} = translate_args(Args, S),
-      {{call, Line, {atom, Line, Name}, TArgs}, NS}
-  end;
-
-%% Remote calls
-
-translate({{'.', _, [Left, Right]}, Meta, Args}, S)
-    when (is_tuple(Left) orelse is_atom(Left)), is_atom(Right), is_list(Meta), is_list(Args) ->
-  {TLeft, SL} = translate(Left, S),
-  {TArgs, SA} = translate_args(Args, mergec(S, SL)),
-
-  Line   = ?line(Meta),
-  Arity  = length(Args),
-  TRight = {atom, Line, Right},
-
-  %% We need to rewrite erlang function calls as operators
-  %% because erl_eval chokes on them. We can remove this
-  %% once a fix is merged into Erlang, keeping only the
-  %% list operators one (since it is required for inlining
-  %% [1,2,3] ++ Right in matches).
-  case (Left == erlang) andalso erl_op(Right, Arity) of
-    true ->
-      {list_to_tuple([op, Line, Right] ++ TArgs), mergev(SL, SA)};
-    false ->
-      assert_allowed_in_context(Meta, Left, Right, Arity, S),
-      SC = mergev(SL, SA),
-
-      case not is_atom(Left) andalso (Arity == 0) of
-        true ->
-          {Var, _, SV} = elixir_scope:build_var('_', SC),
-          TVar = {var, Line, Var},
-          TMap = {map, Line, [
-            {map_field_assoc, Line,
-              {atom, Line, '__struct__'},
-              {atom, Line, 'Elixir.KeyError'}},
-            {map_field_assoc, Line,
-              {atom, Line, '__exception__'},
-              {atom, Line, 'true'}},
-            {map_field_assoc, Line,
-              {atom, Line, key},
-              {atom, Line, TRight}},
-            {map_field_assoc, Line,
-              {atom, Line, term},
-              TVar}]},
-
-          %% TODO There is a bug in dialyzer that makes it fail on
-          %% empty maps. We work around the bug below by using
-          %% the is_map/1 guard instead of matching on map. Hopefully
-          %% we can use a match on 17.1.
-          %%
-          %% http://erlang.org/pipermail/erlang-bugs/2014-April/004338.html
-          {{'case', -1, TLeft, [
-            {clause, -1,
-              [{map, Line, [{map_field_exact, Line, TRight, TVar}]}],
-              [],
-              [TVar]},
-            {clause, -1,
-              [TVar],
-              [[elixir_utils:erl_call(Line, erlang, is_map, [TVar])]],
-              [elixir_utils:erl_call(Line, erlang, error, [TMap])]},
-            {clause, -1,
-              [TVar],
-              [],
-              [{call, Line, {remote, Line, TVar, TRight}, []}]}
-          ]}, SV};
-        false ->
-          {{call, Line, {remote, Line, TLeft, TRight}, TArgs}, SC}
-      end
-  end;
-
-%% Anonymous function calls
-
-translate({{'.', _, [Expr]}, Meta, Args}, S) when is_list(Args) ->
-  {TExpr, SE} = translate(Expr, S),
-  {TArgs, SA} = translate_args(Args, mergec(S, SE)),
-  {{call, ?line(Meta), TExpr, TArgs}, mergev(SE, SA)};
-
-%% Literals
-
-translate(List, S) when is_list(List) ->
-  Fun = case S#elixir_scope.context of
-    match -> fun translate/2;
-    _     -> fun(X, Acc) -> translate_arg(X, Acc, S) end
-  end,
-  translate_list(List, Fun, S, []);
-
-translate({Left, Right}, S) ->
-  {TArgs, SE} = translate_args([Left, Right], S),
-  {{tuple, 0, TArgs}, SE};
-
-translate(Other, S) ->
-  {elixir_utils:elixir_to_erl(Other), S}.
-
-%% Helpers
-
-erl_op(Op, Arity) ->
-  erl_internal:list_op(Op, Arity) orelse
-    erl_internal:comp_op(Op, Arity) orelse
-    erl_internal:bool_op(Op, Arity) orelse
-    erl_internal:arith_op(Op, Arity).
-
-translate_list([{'|', _, [_, _]=Args}], Fun, Acc, List) ->
-  {[TLeft,TRight], TAcc} = lists:mapfoldl(Fun, Acc, Args),
-  {build_list([TLeft|List], TRight), TAcc};
-translate_list([H|T], Fun, Acc, List) ->
-  {TH, TAcc} = Fun(H, Acc),
-  translate_list(T, Fun, TAcc, [TH|List]);
-translate_list([], _Fun, Acc, List) ->
-  {build_list(List, {nil, 0}), Acc}.
-
-build_list([H|T], Acc) ->
-  build_list(T, {cons, 0, H, Acc});
-build_list([], Acc) ->
-  Acc.
-
-var_kind(Meta, Kind) ->
-  case lists:keyfind(counter, 1, Meta) of
-    {counter, Counter} -> Counter;
-    false -> Kind
-  end.
-
-%% Pack a list of expressions from a block.
-unblock({'block', _, Exprs}) -> Exprs;
-unblock(Expr)                -> [Expr].
-
-%% Translate args
-
-translate_arg(Arg, Acc, S) when is_number(Arg); is_atom(Arg); is_binary(Arg); is_pid(Arg); is_function(Arg) ->
-  {TArg, _} = translate(Arg, S),
-  {TArg, Acc};
-translate_arg(Arg, Acc, S) ->
-  {TArg, TAcc} = translate(Arg, mergec(S, Acc)),
-  {TArg, mergev(Acc, TAcc)}.
-
-translate_args(Args, #elixir_scope{context=match} = S) ->
-  lists:mapfoldl(fun translate/2, S, Args);
-
-translate_args(Args, S) ->
-  lists:mapfoldl(fun(X, Acc) -> translate_arg(X, Acc, S) end, S, Args).
-
-%% Translate blocks
-
-translate_block([], Acc, _Return, S) ->
-  {lists:reverse(Acc), S};
-translate_block([H], Acc, Return, S) ->
-  {TH, TS} = translate_block(H, Return, S),
-  translate_block([], [TH|Acc], Return, TS);
-translate_block([H|T], Acc, Return, S) ->
-  {TH, TS} = translate_block(H, false, S),
-  translate_block(T, [TH|Acc], Return, TS).
-
-translate_block(Expr, Return, S) ->
-  case (Return == false) andalso handles_no_return(Expr) of
-    true  -> translate(Expr, S#elixir_scope{return=Return});
-    false -> translate(Expr, S)
-  end.
-
-%% return is typically true, except when we find one
-%% of the expressions below, which may handle return=false
-%% but must always return return=true.
-handles_no_return({'try', _, [_]}) -> true;
-handles_no_return({'cond', _, [_]}) -> true;
-handles_no_return({'for', _, [_|_]}) -> true;
-handles_no_return({'case', _, [_, _]}) -> true;
-handles_no_return({'receive', _, [_]}) -> true;
-handles_no_return({'__block__', _, [_|_]}) -> true;
-handles_no_return(_) -> false.
-
-%% Cond
-
-build_cond_clauses([{'->', NewMeta, [[Condition], Body]}|T], Acc, OldMeta) ->
-  {Truthy, Other} = build_truthy_clause(NewMeta, Condition, Body),
-  Falsy = {'->', OldMeta, [[Other], Acc]},
-  Case = {'case', NewMeta, [Condition, [{do, [Truthy, Falsy]}]]},
-  build_cond_clauses(T, Case, NewMeta);
-build_cond_clauses([], Acc, _) ->
-  Acc.
-
-build_truthy_clause(Meta, Condition, Body) ->
-  case elixir_utils:returns_boolean(Condition) of
-    true ->
-      {{'->', Meta, [[true], Body]}, false};
-    false ->
-      Var  = {'cond', [], 'Elixir'},
-      Head = {'when', [], [Var,
-        {'__op__', [], [
-          'andalso',
-          {{'.', [], [erlang, '/=']}, [], [Var, nil]},
-          {{'.', [], [erlang, '/=']}, [], [Var, false]}
-        ]}
-      ]},
-      {{'->', Meta, [[Head], Body]}, {'_', [], nil}}
-  end.
-
-%% Assertions
-
-assert_module_scope(Meta, Kind, #elixir_scope{module=nil,file=File}) ->
-  compile_error(Meta, File, "cannot invoke ~ts outside module", [Kind]);
-assert_module_scope(_Meta, _Kind, #elixir_scope{module=Module}) -> Module.
-
-assert_function_scope(Meta, Kind, #elixir_scope{function=nil,file=File}) ->
-  compile_error(Meta, File, "cannot invoke ~ts outside function", [Kind]);
-assert_function_scope(_Meta, _Kind, #elixir_scope{function=Function}) -> Function.
-
-assert_allowed_in_context(Meta, Left, Right, Arity, #elixir_scope{context=Context} = S)
-    when (Context == match) orelse (Context == guard) ->
-  case (Left == erlang) andalso erl_internal:guard_bif(Right, Arity) of
-    true  -> ok;
-    false ->
-      compile_error(Meta, S#elixir_scope.file, "cannot invoke remote function ~ts.~ts/~B inside ~ts",
-        ['Elixir.Macro':to_string(Left), Right, Arity, Context])
-  end;
-assert_allowed_in_context(_, _, _, _, _) ->
-  ok.
diff --git a/lib/elixir/src/elixir_try.erl b/lib/elixir/src/elixir_try.erl
deleted file mode 100644
index 73729a70ec9..00000000000
--- a/lib/elixir/src/elixir_try.erl
+++ /dev/null
@@ -1,195 +0,0 @@
--module(elixir_try).
--export([clauses/4]).
--include("elixir.hrl").
-
-clauses(_Meta, Clauses, Return, S) ->
-  Catch  = elixir_clauses:get_pairs('catch', Clauses, 'catch'),
-  Rescue = elixir_clauses:get_pairs(rescue, Clauses, rescue),
-  reduce_clauses(Rescue ++ Catch, [], S, Return, S).
-
-reduce_clauses([H|T], Acc, SAcc, Return, S) ->
-  {TH, TS} = each_clause(H, Return, SAcc),
-  reduce_clauses(T, TH ++ Acc, elixir_scope:mergec(S, TS), Return, S);
-reduce_clauses([], Acc, SAcc, _Return, _S) ->
-  {lists:reverse(Acc), SAcc}.
-
-each_clause({'catch', Meta, Raw, Expr}, Return, S) ->
-  {Args, Guards} = elixir_clauses:extract_splat_guards(Raw),
-
-  Final = case Args of
-    [X]   -> [throw, X, {'_', Meta, nil}];
-    [X,Y] -> [X, Y, {'_', Meta, nil}]
-  end,
-
-  Condition = [{'{}', Meta, Final}],
-  {TC, TS} = elixir_clauses:clause(?line(Meta), fun elixir_translator:translate_args/2,
-                                   Condition, Expr, Guards, Return, S),
-  {[TC], TS};
-
-each_clause({rescue, Meta, [{in, _, [Left, Right]}], Expr}, Return, S) ->
-  {VarName, _, CS} = elixir_scope:build_var('_', S),
-  Var = {VarName, Meta, nil},
-  {Parts, Safe, FS} = rescue_guards(Meta, Var, Right, CS),
-
-  Body =
-    case Left of
-      {'_', _, Atom} when is_atom(Atom) ->
-        Expr;
-      _ ->
-        Normalized =
-          case Safe of
-            true  -> Var;
-            false -> {{'.', Meta, ['Elixir.Exception', normalize]}, Meta, [error, Var]}
-          end,
-        prepend_to_block(Meta, {'=', Meta, [Left, Normalized]}, Expr)
-    end,
-
-  build_rescue(Meta, Parts, Body, Return, FS);
-
-each_clause({rescue, Meta, _, _}, _Return, S) ->
-  elixir_errors:compile_error(Meta, S#elixir_scope.file, "invalid arguments for rescue in try");
-
-each_clause({Key, Meta, _, _}, _Return, S) ->
-  elixir_errors:compile_error(Meta, S#elixir_scope.file, "invalid key ~ts in try", [Key]).
-
-%% Helpers
-
-build_rescue(Meta, Parts, Body, Return, S) ->
-  Matches = [Match || {Match, _} <- Parts],
-
-  {{clause, Line, TMatches, _, TBody}, TS} =
-    elixir_clauses:clause(?line(Meta), fun elixir_translator:translate_args/2,
-                          Matches, Body, [], Return, S),
-
-  TClauses =
-    [begin
-      TArgs   = [{tuple, Line, [{atom, Line, error}, TMatch, {var, Line, '_'}]}],
-      TGuards = elixir_clauses:guards(Line, Guards, [], TS),
-      {clause, Line, TArgs, TGuards, TBody}
-     end || {TMatch, {_, Guards}} <- lists:zip(TMatches, Parts)],
-
-  {TClauses, TS}.
-
-%% Convert rescue clauses into guards.
-rescue_guards(_, Var, {'_', _, _}, S) -> {[{Var, []}], false, S};
-
-rescue_guards(Meta, Var, Aliases, S) ->
-  {Elixir, Erlang} = rescue_each_ref(Meta, Var, Aliases, [], [], S),
-
-  {ElixirParts, ES} =
-    case Elixir of
-      [] -> {[], S};
-      _  ->
-        {VarName, _, CS} = elixir_scope:build_var('_', S),
-        StructVar = {VarName, Meta, nil},
-        Map = {'%{}', Meta, [{'__struct__', StructVar}, {'__exception__', true}]},
-        Match = {'=', Meta, [Map, Var]},
-        Guards = [{erl(Meta, '=='), Meta, [StructVar, Mod]} || Mod <- Elixir],
-        {[{Match, Guards}], CS}
-    end,
-
-  ErlangParts =
-    case Erlang of
-      [] -> [];
-      _  -> [{Var, Erlang}]
-    end,
-
-  {ElixirParts ++ ErlangParts, ErlangParts == [], ES}.
-
-%% Rescue each atom name considering their Erlang or Elixir matches.
-%% Matching of variables is done with Erlang exceptions is done in
-%% function for optimization.
-
-rescue_each_ref(Meta, Var, [H|T], Elixir, Erlang, S) when is_atom(H) ->
-  case erl_rescue_guard_for(Meta, Var, H) of
-    false -> rescue_each_ref(Meta, Var, T, [H|Elixir], Erlang, S);
-    Expr  -> rescue_each_ref(Meta, Var, T, [H|Elixir], [Expr|Erlang], S)
-  end;
-
-rescue_each_ref(_, _, [], Elixir, Erlang, _) ->
-  {Elixir, Erlang}.
-
-%% Handle erlang rescue matches.
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.UndefinedFunctionError') ->
-  {erl(Meta, '=='), Meta, [Var, undef]};
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.FunctionClauseError') ->
-  {erl(Meta, '=='), Meta, [Var, function_clause]};
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.SystemLimitError') ->
-  {erl(Meta, '=='), Meta, [Var, system_limit]};
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.ArithmeticError') ->
-  {erl(Meta, '=='), Meta, [Var, badarith]};
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.CondClauseError') ->
-  {erl(Meta, '=='), Meta, [Var, cond_clause]};
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.BadArityError') ->
-  erl_and(Meta,
-          erl_tuple_size(Meta, Var, 2),
-          erl_record_compare(Meta, Var, badarity));
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.BadFunctionError') ->
-  erl_and(Meta,
-          erl_tuple_size(Meta, Var, 2),
-          erl_record_compare(Meta, Var, badfun));
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.MatchError') ->
-  erl_and(Meta,
-          erl_tuple_size(Meta, Var, 2),
-          erl_record_compare(Meta, Var, badmatch));
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.CaseClauseError') ->
-  erl_and(Meta,
-          erl_tuple_size(Meta, Var, 2),
-          erl_record_compare(Meta, Var, case_clause));
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.TryClauseError') ->
-  erl_and(Meta,
-          erl_tuple_size(Meta, Var, 2),
-          erl_record_compare(Meta, Var, try_clause));
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.BadStructError') ->
-  erl_and(Meta,
-          erl_tuple_size(Meta, Var, 3),
-          erl_record_compare(Meta, Var, badstruct));
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.ArgumentError') ->
-  erl_or(Meta,
-         {erl(Meta, '=='), Meta, [Var, badarg]},
-         erl_and(Meta,
-                 erl_tuple_size(Meta, Var, 2),
-                 erl_record_compare(Meta, Var, badarg)));
-
-erl_rescue_guard_for(Meta, Var, 'Elixir.ErlangError') ->
-  IsNotTuple  = {erl(Meta, 'not'), Meta, [{erl(Meta, is_tuple), Meta, [Var]}]},
-  IsException = {erl(Meta, '/='), Meta, [
-    {erl(Meta, element), Meta, [2, Var]}, '__exception__'
-  ]},
-  erl_or(Meta, IsNotTuple, IsException);
-
-erl_rescue_guard_for(_, _, _) ->
-  false.
-
-%% Helpers
-
-erl_tuple_size(Meta, Var, Size) ->
-  {erl(Meta, '=='), Meta, [{erl(Meta, tuple_size), Meta, [Var]}, Size]}.
-
-erl_record_compare(Meta, Var, Expr) ->
-  {erl(Meta, '=='), Meta, [
-    {erl(Meta, element), Meta, [1, Var]},
-    Expr
-  ]}.
-
-prepend_to_block(_Meta, Expr, {'__block__', Meta, Args}) ->
-  {'__block__', Meta, [Expr|Args]};
-
-prepend_to_block(Meta, Expr, Args) ->
-  {'__block__', Meta, [Expr, Args]}.
-
-erl(Meta, Op)      -> {'.', Meta, [erlang, Op]}.
-erl_or(Meta, Left, Right) -> {'__op__', Meta, ['orelse', Left, Right]}.
-erl_and(Meta, Left, Right) -> {'__op__', Meta, ['andalso', Left, Right]}.
diff --git a/lib/elixir/src/elixir_utils.erl b/lib/elixir/src/elixir_utils.erl
index 1268bd6b185..0a6095a9e72 100644
--- a/lib/elixir/src/elixir_utils.erl
+++ b/lib/elixir/src/elixir_utils.erl
@@ -1,38 +1,110 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 %% Convenience functions used throughout elixir source code
 %% for ast manipulation and querying.
 -module(elixir_utils).
--export([elixir_to_erl/1, get_line/1, split_last/1,
-  characters_to_list/1, characters_to_binary/1, macro_name/1,
-  convert_to_boolean/4, returns_boolean/1, atom_concat/1,
-  read_file_type/1, read_link_type/1, relative_to_cwd/1, erl_call/4]).
+-export([get_line/1, get_line/2, get_file/2, generated/1,
+  split_last/1, split_opts/1, noop/0, var_context/2,
+  characters_to_list/1, characters_to_binary/1, relative_to_cwd/1,
+  macro_name/1, returns_boolean/1, caller/4, meta_keep/1,
+  read_file_type/1, read_file_type/2, read_link_type/1, read_posix_mtime_and_size/1,
+  change_posix_time/2, change_universal_time/2, var_info/2,
+  guard_op/2, guard_info/1, extract_splat_guards/1, extract_guards/1,
+  erlang_comparison_op_to_elixir/1, erl_fa_to_elixir_fa/2, jaro_similarity/2]).
 -include("elixir.hrl").
 -include_lib("kernel/include/file.hrl").
 
+var_info(Name, Kind) when Kind == nil; is_integer(Kind) ->
+  io_lib:format("\"~ts\"", [Name]);
+var_info(Name, Kind) ->
+  io_lib:format("\"~ts\" (context ~ts)", [Name, elixir_aliases:inspect(Kind)]).
+
+guard_info(#elixir_ex{prematch={_, _, {bitsize, _}}}) -> "bitstring size specifier";
+guard_info(_) -> "guard".
+
 macro_name(Macro) ->
-  list_to_atom(lists:concat(['MACRO-',Macro])).
+  list_to_atom("MACRO-" ++ atom_to_list(Macro)).
 
-atom_concat(Atoms) ->
-  list_to_atom(lists:concat(Atoms)).
+erl_fa_to_elixir_fa(Name, Arity) ->
+  case atom_to_list(Name) of
+    "MACRO-" ++ Rest -> {list_to_atom(Rest), Arity - 1};
+    _ -> {Name, Arity}
+  end.
 
-erl_call(Line, Module, Function, Args) ->
-  {call, Line,
-    {remote, Line, {atom, Line, Module}, {atom, Line, Function}},
-    Args
-  }.
+guard_op('andalso', 2) ->
+  true;
+guard_op('orelse', 2) ->
+  true;
+guard_op(Op, Arity) ->
+  try erl_internal:op_type(Op, Arity) of
+    arith -> true;
+    comp  -> true;
+    bool  -> true;
+    list  -> false;
+    send  -> false
+  catch
+    _:_ -> false
+  end.
 
-get_line(Opts) when is_list(Opts) ->
-  case lists:keyfind(line, 1, Opts) of
-    {line, Line} when is_integer(Line) -> Line;
-    false -> 0
+erlang_comparison_op_to_elixir('/=') -> '!=';
+erlang_comparison_op_to_elixir('=<') -> '<=';
+erlang_comparison_op_to_elixir('=:=') -> '===';
+erlang_comparison_op_to_elixir('=/=') -> '!==';
+erlang_comparison_op_to_elixir(Other) -> Other.
+
+var_context(Meta, Kind) ->
+  case lists:keyfind(counter, 1, Meta) of
+    {counter, Counter} -> Counter;
+    false -> Kind
   end.
 
-split_last([])         -> {[], []};
-split_last(List)       -> split_last(List, []).
-split_last([H], Acc)   -> {lists:reverse(Acc), H};
-split_last([H|T], Acc) -> split_last(T, [H|Acc]).
+% Extract guards
+
+extract_guards({'when', _, [Left, Right]}) -> {Left, extract_or_guards(Right)};
+extract_guards(Else) -> {Else, []}.
+
+extract_or_guards({'when', _, [Left, Right]}) -> [Left | extract_or_guards(Right)];
+extract_or_guards(Term) -> [Term].
+
+% Extract guards when multiple left side args are allowed.
+
+extract_splat_guards([{'when', _, [_ | _] = Args}]) ->
+  {Left, Right} = split_last(Args),
+  {Left, extract_or_guards(Right)};
+extract_splat_guards(Else) ->
+  {Else, []}.
+
+%% No-op function that can be used for stuff like preventing tail-call
+%% optimization to kick in.
+noop() ->
+  ok.
+
+split_last([])           -> {[], []};
+split_last(List)         -> split_last(List, []).
+split_last([H], Acc)     -> {lists:reverse(Acc), H};
+split_last([H | T], Acc) -> split_last(T, [H | Acc]).
+
+%% Useful to handle options similarly in `opts, do ... end` and `opts, do: ...`.
+split_opts(Args) ->
+  case elixir_utils:split_last(Args) of
+    {OuterCases, OuterOpts} when is_list(OuterOpts) ->
+      case elixir_utils:split_last(OuterCases) of
+        {InnerCases, InnerOpts} when is_list(InnerOpts) ->
+          {InnerCases, InnerOpts ++ OuterOpts};
+        _ ->
+          {OuterCases, OuterOpts}
+      end;
+    _ ->
+      {Args, []}
+  end.
 
 read_file_type(File) ->
-  case file:read_file_info(File) of
+  read_file_type(File, []).
+
+read_file_type(File, Opts) ->
+  case file:read_file_info(File, [{time, posix} | Opts]) of
     {ok, #file_info{type=Type}} -> {ok, Type};
     {error, _} = Error -> Error
   end.
@@ -43,89 +115,96 @@ read_link_type(File) ->
     {error, _} = Error -> Error
   end.
 
+read_posix_mtime_and_size(File) ->
+  case file:read_file_info(File, [raw, {time, posix}]) of
+    {ok, #file_info{mtime=Mtime, size=Size}} -> {ok, Mtime, Size};
+    {error, _} = Error -> Error
+  end.
+
+change_posix_time(Name, Time) when is_integer(Time) ->
+  file:write_file_info(Name, #file_info{mtime=Time}, [raw, {time, posix}]).
+
+change_universal_time(Name, {{Y, M, D}, {H, Min, Sec}}=Time)
+    when is_integer(Y), is_integer(M), is_integer(D),
+         is_integer(H), is_integer(Min), is_integer(Sec) ->
+  file:write_file_info(Name, #file_info{mtime=Time}, [raw, {time, universal}]).
+
 relative_to_cwd(Path) ->
-  case elixir_compiler:get_opt(internal) of
-    true  -> Path;
-    false -> 'Elixir.String':to_char_list('Elixir.Path':relative_to_cwd(Path))
+  try elixir_config:get(relative_paths) of
+    true  -> 'Elixir.Path':relative_to_cwd(Path);
+    false -> Path
+  catch
+    _:_ -> Path
   end.
 
 characters_to_list(Data) when is_list(Data) ->
   Data;
 characters_to_list(Data) ->
-  case elixir_compiler:get_opt(internal) of
-    true  -> unicode:characters_to_list(Data);
-    false -> 'Elixir.String':to_char_list(Data)
+  case unicode:characters_to_list(Data) of
+    Result when is_list(Result) -> Result;
+    {error, Encoded, Rest} -> conversion_error(invalid, Encoded, Rest);
+    {incomplete, Encoded, Rest} -> conversion_error(incomplete, Encoded, Rest)
   end.
 
 characters_to_binary(Data) when is_binary(Data) ->
   Data;
 characters_to_binary(Data) ->
-  case elixir_compiler:get_opt(internal) of
-    true  -> unicode:characters_to_binary(Data);
-    false -> 'Elixir.List':to_string(Data)
+  case unicode:characters_to_binary(Data) of
+    Result when is_binary(Result) -> Result;
+    {error, Encoded, Rest} -> conversion_error(invalid, Encoded, Rest);
+    {incomplete, Encoded, Rest} -> conversion_error(incomplete, Encoded, Rest)
   end.
 
-%% elixir to erl. Handles only valid quoted expressions,
-%% that's why things like maps and references are not in the list.
-
-elixir_to_erl(Tree) when is_tuple(Tree) ->
-  {tuple, 0, [elixir_to_erl(X) || X <- tuple_to_list(Tree)]};
+conversion_error(Kind, Encoded, Rest) ->
+  error('Elixir.UnicodeConversionError':exception([{encoded, Encoded}, {rest, Rest}, {kind, Kind}])).
 
-elixir_to_erl([]) ->
-  {nil, 0};
+%% Returns the caller as a stacktrace entry.
+caller(Line, File, nil, _) ->
+  {elixir_compiler_0, '__FILE__', 1, stack_location(Line, File)};
+caller(Line, File, Module, nil) ->
+  {Module, '__MODULE__', 0, stack_location(Line, File)};
+caller(Line, File, Module, {Name, Arity}) ->
+  {Module, Name, Arity, stack_location(Line, File)}.
 
-elixir_to_erl(<<>>) ->
-  {bin, 0, []};
+stack_location(Line, File) ->
+  [{file, elixir_utils:characters_to_list(elixir_utils:relative_to_cwd(File))},
+   {line, Line}].
 
-elixir_to_erl(Tree) when is_list(Tree) ->
-  elixir_to_erl_cons_1(Tree, []);
-
-elixir_to_erl(Tree) when is_atom(Tree) ->
-  {atom, 0, Tree};
-
-elixir_to_erl(Tree) when is_integer(Tree) ->
-  {integer, 0, Tree};
-
-elixir_to_erl(Tree) when is_float(Tree) ->
-  {float, 0, Tree};
-
-elixir_to_erl(Tree) when is_binary(Tree) ->
-  %% Note that our binaries are utf-8 encoded and we are converting
-  %% to a list using binary_to_list. The reason for this is that Erlang
-  %% considers a string in a binary to be encoded in latin1, so the bytes
-  %% are not changed in any fashion.
-  {bin, 0, [{bin_element, 0, {string, 0, binary_to_list(Tree)}, default, default}]};
-
-elixir_to_erl(Function) when is_function(Function) ->
-  case (erlang:fun_info(Function, type) == {type, external}) andalso
-       (erlang:fun_info(Function, env) == {env, []}) of
-    true ->
-      {module, Module} = erlang:fun_info(Function, module),
-      {name, Name}     = erlang:fun_info(Function, name),
-      {arity, Arity}   = erlang:fun_info(Function, arity),
-
-      {'fun', 0, {function,
-        {atom, 0, Module},
-        {atom, 0, Name},
-        {integer, 0, Arity}}};
-    false ->
-      error(badarg)
-  end;
-
-elixir_to_erl(Pid) when is_pid(Pid) ->
-  elixir_utils:erl_call(0, erlang, binary_to_term,
-    [elixir_utils:elixir_to_erl(term_to_binary(Pid))]);
+get_line(Opts) when is_list(Opts) ->
+  case lists:keyfind(line, 1, Opts) of
+    {line, Line} when is_integer(Line) -> Line;
+    _ -> 0
+  end.
 
-elixir_to_erl(_Other) ->
-  error(badarg).
+get_line(Meta, Env) when is_list(Meta) ->
+  case lists:keyfind(line, 1, Meta) of
+    {line, LineOpt} when is_integer(LineOpt) -> LineOpt;
+    false -> ?key(Env, line)
+  end.
 
-elixir_to_erl_cons_1([H|T], Acc) -> elixir_to_erl_cons_1(T, [H|Acc]);
-elixir_to_erl_cons_1(Other, Acc) -> elixir_to_erl_cons_2(Acc, elixir_to_erl(Other)).
+get_file(Meta, Env) when is_list(Meta) ->
+  case lists:keyfind(file, 1, Meta) of
+    {file, FileOpt} when is_binary(FileOpt) -> FileOpt;
+    false -> ?key(Env, file)
+  end.
 
-elixir_to_erl_cons_2([H|T], Acc) ->
-  elixir_to_erl_cons_2(T, {cons, 0, elixir_to_erl(H), Acc});
-elixir_to_erl_cons_2([], Acc) ->
-  Acc.
+generated([{generated, true} | _] = Meta) -> Meta;
+generated(Meta) -> [{generated, true} | Meta].
+
+%% Meta location.
+%%
+%% Macros add a file pair on location keep which we
+%% should take into account for error reporting.
+%%
+%% Returns {binary, integer} on location keep or nil.
+
+meta_keep(Meta) ->
+  case lists:keyfind(keep, 1, Meta) of
+    {keep, {File, Line} = Pair} when is_binary(File), is_integer(Line) ->
+      Pair;
+    _ ->
+      nil
+  end.
 
 %% Boolean checks
 
@@ -138,61 +217,116 @@ returns_boolean({{'.', _, [erlang, Op]}, _, [_, _]}) when
   Op == '==';  Op == '/='; Op == '=<';  Op == '>=';
   Op == '<';   Op == '>';  Op == '=:='; Op == '=/=' -> true;
 
-returns_boolean({'__op__', _, [Op, _, Right]}) when Op == 'andalso'; Op == 'orelse' ->
+returns_boolean({{'.', _, [erlang, Op]}, _, [_, Right]}) when
+  Op == 'andalso'; Op == 'orelse' ->
   returns_boolean(Right);
 
 returns_boolean({{'.', _, [erlang, Fun]}, _, [_]}) when
   Fun == is_atom;   Fun == is_binary;   Fun == is_bitstring; Fun == is_boolean;
   Fun == is_float;  Fun == is_function; Fun == is_integer;   Fun == is_list;
   Fun == is_number; Fun == is_pid;      Fun == is_port;      Fun == is_reference;
-  Fun == is_tuple -> true;
+  Fun == is_tuple;  Fun == is_map;      Fun == is_process_alive -> true;
 
 returns_boolean({{'.', _, [erlang, Fun]}, _, [_, _]}) when
-  Fun == is_function -> true;
+  Fun == is_map_key; Fun == is_function; Fun == is_record -> true;
 
 returns_boolean({{'.', _, [erlang, Fun]}, _, [_, _, _]}) when
-  Fun == function_exported -> true;
+  Fun == function_exported; Fun == is_record -> true;
 
 returns_boolean({'case', _, [_, [{do, Clauses}]]}) ->
   lists:all(fun
-    ({'->',_,[_, Expr]}) -> returns_boolean(Expr)
+    ({'->', _, [_, Expr]}) -> returns_boolean(Expr)
   end, Clauses);
 
 returns_boolean({'cond', _, [[{do, Clauses}]]}) ->
   lists:all(fun
-    ({'->',_,[_, Expr]}) -> returns_boolean(Expr)
+    ({'->', _, [_, Expr]}) -> returns_boolean(Expr)
   end, Clauses);
 
-returns_boolean({'__block__', [], Exprs}) ->
+returns_boolean({'__block__', _, Exprs}) ->
   returns_boolean(lists:last(Exprs));
 
 returns_boolean(_) -> false.
 
-convert_to_boolean(Line, Expr, Bool, S) when is_integer(Line) ->
-  case {returns_boolean(Expr), Bool} of
-    {true, true}  -> {Expr, S};
-    {true, false} -> {{op, Line, 'not', Expr}, S};
-    _               -> do_convert_to_boolean(Line, Expr, Bool, S)
-  end.
 
-%% Notice we use a temporary var and bundle nil
-%% and false checks in the same clause since
-%% it makes dialyzer happy.
-do_convert_to_boolean(Line, Expr, Bool, S) ->
-  {Name, _, TS} = elixir_scope:build_var('_', S),
-  Var = {var, Line, Name},
-  Any = {var, Line, '_'},
-  OrElse = do_guarded_convert_to_boolean(Line, Var, 'orelse', '=='),
-
-  FalseResult = {atom,Line,not Bool},
-  TrueResult  = {atom,Line,Bool},
-
-  {{'case', Line, Expr, [
-    {clause, Line, [Var], [[OrElse]], [FalseResult]},
-    {clause, Line, [Any], [], [TrueResult]}
-  ]}, TS}.
-
-do_guarded_convert_to_boolean(Line, Expr, Op, Comp) ->
-  Left  = {op, Line, Comp, Expr, {atom, Line, false}},
-  Right = {op, Line, Comp, Expr, {atom, Line, nil}},
-  {op, Line, Op, Left, Right}.
+% TODO: Remove me when we require Erlang/OTP 27+
+% This is a polyfill for older versions, copying the code from
+% https://github.com/erlang/otp/pull/7879
+-spec jaro_similarity(String1, String2) -> Similarity when
+      String1 :: unicode:chardata(),
+      String2 :: unicode:chardata(),
+      Similarity :: float(). %% Between +0.0 and 1.0
+jaro_similarity(A0, B0) ->
+    {A, ALen} = str_to_gcl_and_length(A0),
+    {B, BLen} = str_to_indexmap(B0),
+    Dist = max(ALen, BLen) div 2,
+    {AM, BM} = jaro_match(A, B, -Dist, Dist, [], []),
+    if
+        ALen =:= 0 andalso BLen =:= 0 ->
+            1.0;
+        ALen =:= 0 orelse BLen =:= 0 ->
+            0.0;
+        AM =:= [] ->
+            0.0;
+        true ->
+            {M,T} = jaro_calc_mt(AM, BM, 0, 0),
+            (M/ALen + M/BLen + (M-T/2)/M) / 3
+    end.
+
+jaro_match([A|As], B0, Min, Max, AM, BM) ->
+    case jaro_detect(maps:get(A, B0, []), Min, Max) of
+        false ->
+            jaro_match(As, B0, Min+1, Max+1, AM, BM);
+        {J, Remain} ->
+            B = B0#{A => Remain},
+            jaro_match(As, B, Min+1, Max+1, [A|AM], add_rsorted({J,A},BM))
+    end;
+jaro_match(_A, _B, _Min, _Max, AM, BM) ->
+    {AM, BM}.
+
+jaro_detect([Idx|Rest], Min, Max) when Min < Idx, Idx < Max ->
+    {Idx, Rest};
+jaro_detect([Idx|Rest], Min, Max) when Idx < Max ->
+    jaro_detect(Rest, Min, Max);
+jaro_detect(_, _, _) ->
+    false.
+
+jaro_calc_mt([CharA|AM], [{_, CharA}|BM], M, T) ->
+    jaro_calc_mt(AM, BM, M+1, T);
+jaro_calc_mt([_|AM], [_|BM], M, T) ->
+    jaro_calc_mt(AM, BM, M+1, T+1);
+jaro_calc_mt([], [], M, T) ->
+    {M, T}.
+
+
+%% Returns GC list and length
+str_to_gcl_and_length(S0) ->
+    gcl_and_length(unicode_util:gc(S0), [], 0).
+
+gcl_and_length([C|Str], Acc, N) ->
+    gcl_and_length(unicode_util:gc(Str), [C|Acc], N+1);
+gcl_and_length([], Acc, N) ->
+    {lists:reverse(Acc), N};
+gcl_and_length({error, Err}, _, _) ->
+    error({badarg, Err}).
+
+%% Returns GC map with index and length
+str_to_indexmap(S) ->
+    [M|L] = str_to_map(unicode_util:gc(S), 0),
+    {M,L}.
+
+str_to_map([], L) -> [#{}|L];
+str_to_map([G | Gs], I) ->
+    [M|L] = str_to_map(unicode_util:gc(Gs), I+1),
+    [maps:put(G, [I | maps:get(G, M, [])], M)| L];
+str_to_map({error,Error}, _) ->
+    error({badarg, Error}).
+
+%% Add in decreasing order
+add_rsorted(A, [H|_]=BM) when A > H ->
+    [A|BM];
+add_rsorted(A, [H|BM]) ->
+    [H|add_rsorted(A,BM)];
+add_rsorted(A, []) ->
+    [A].
+
diff --git a/lib/elixir/src/iex.erl b/lib/elixir/src/iex.erl
new file mode 100644
index 00000000000..5a2f9a9da68
--- /dev/null
+++ b/lib/elixir/src/iex.erl
@@ -0,0 +1,87 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+
+-module(iex).
+-export([start/0, start/2, shell/0, sync_remote/2]).
+
+%% Manual tests for changing the CLI boot.
+%%
+%% 1. In some situations, we cannot read inputs as IEx boots:
+%%
+%%      $ iex -e ":io.get_line(:foo)"
+%%
+%% 2. In some situations, connecting to a remote node via --remsh
+%%    is not possible. This can be tested by starting two IEx nodes:
+%%
+%%      $ iex --sname foo
+%%      $ iex --sname bar --remsh foo
+%%
+%% 3. When still using --remsh, we need to guarantee the arguments
+%%    are processed on the local node and not the remote one. For such,
+%%    one can replace the last line above by:
+%%
+%%      $ iex --sname bar --remsh foo -e 'IO.inspect node()'
+%%
+%%    And verify that the local node name is printed.
+%%
+%% 4. Finally, in some other circumstances, printing messages may become
+%%    borked. This can be verified with:
+%%
+%%      $ iex -e ":logger.info(~c'foo~nbar', [])"
+%%
+%% By the time those instructions have been written, all tests above pass.
+
+start() ->
+  start([], {elixir_utils, noop, []}).
+
+start(Opts, MFA) ->
+  {ok, _} = application:ensure_all_started(elixir),
+  {ok, _} = application:ensure_all_started(iex),
+
+  spawn(fun() ->
+    case init:notify_when_started(self()) of
+      started -> ok;
+      _ -> init:wait_until_started()
+    end,
+
+    ok = io:setopts([{binary, true}, {encoding, unicode}]),
+    'Elixir.IEx.Server':run_from_shell(Opts, MFA)
+  end).
+
+shell() ->
+  Args = init:get_plain_arguments(),
+
+  case get_remsh(Args) of
+    nil ->
+      start_mfa(Args, {elixir, start_cli, []});
+
+    Remote ->
+      Ref = make_ref(),
+
+      Parent =
+        spawn_link(fun() ->
+          receive
+            {'begin', Ref, Other} ->
+              elixir:start_cli(),
+              Other ! {done, Ref}
+          end
+        end),
+
+      {remote, Remote, start_mfa(Args, {?MODULE, sync_remote, [Parent, Ref]})}
+  end.
+
+sync_remote(Parent, Ref) ->
+  Parent ! {'begin', Ref, self()},
+  receive {done, Ref} -> ok end.
+
+start_mfa(Args, MFA) ->
+  Opts = [{dot_iex, get_dot_iex(Args)}, {on_eof, halt}],
+  {?MODULE, start, [Opts, MFA]}.
+
+get_dot_iex(["--dot-iex", H | _]) -> elixir_utils:characters_to_binary(H);
+get_dot_iex([_ | T]) -> get_dot_iex(T);
+get_dot_iex([]) -> nil.
+
+get_remsh(["--remsh", H | _]) -> H;
+get_remsh([_ | T]) -> get_remsh(T);
+get_remsh([]) -> nil.
diff --git a/lib/elixir/test/doc_test.exs b/lib/elixir/test/doc_test.exs
deleted file mode 100644
index 3713782a0b1..00000000000
--- a/lib/elixir/test/doc_test.exs
+++ /dev/null
@@ -1,42 +0,0 @@
-ExUnit.start []
-
-defmodule KernelTest do
-  use ExUnit.Case, async: true
-
-  doctest Access
-  doctest Atom
-  doctest Base
-  doctest Bitwise
-  doctest Code
-  doctest Collectable
-  doctest Enum
-  doctest Exception
-  doctest Float
-  doctest Inspect
-  doctest Inspect.Algebra
-  doctest Integer
-  doctest IO
-  doctest IO.ANSI
-  doctest Kernel
-  doctest Kernel.SpecialForms
-  doctest Keyword
-  doctest List
-  doctest Macro
-  doctest Map
-  doctest Module
-  doctest Node
-  doctest OptionParser
-  doctest Path
-  doctest Process
-  doctest Protocol
-  doctest Range
-  doctest Record
-  doctest Regex
-  doctest Stream
-  doctest String
-  doctest String.Chars
-  doctest StringIO
-  doctest Tuple
-  doctest URI
-  doctest Version
-end
diff --git a/lib/elixir/test/elixir/access_test.exs b/lib/elixir/test/elixir/access_test.exs
index b28993addf3..7dda561db09 100644
--- a/lib/elixir/test/elixir/access_test.exs
+++ b/lib/elixir/test/elixir/access_test.exs
@@ -1,8 +1,14 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule AccessTest do
   use ExUnit.Case, async: true
 
+  doctest Access
+
   # Test nil at compilation time does not fail
   # and that @config[:foo] has proper precedence.
   @config nil
@@ -19,8 +25,12 @@ defmodule AccessTest do
 
   test "for nil" do
     assert nil[:foo] == nil
+    assert Access.fetch(nil, :foo) == :error
     assert Access.get(nil, :foo) == nil
-    assert Access.get_and_update(nil, :foo, fn nil -> {:ok, :bar} end) == {:ok, :bar}
+
+    assert_raise ArgumentError, "could not put/update key :foo on a nil value", fn ->
+      Access.get_and_update(nil, :foo, fn nil -> {:ok, :bar} end)
+    end
   end
 
   test "for keywords" do
@@ -28,9 +38,23 @@ defmodule AccessTest do
     assert [foo: [bar: :baz]][:foo][:bar] == :baz
     assert [foo: [bar: :baz]][:fuu][:bar] == nil
 
+    assert Access.fetch([foo: :bar], :foo) == {:ok, :bar}
+    assert Access.fetch([foo: :bar], :bar) == :error
+
+    msg = ~r/the Access calls for keywords expect the key to be an atom/
+
+    assert_raise ArgumentError, msg, fn ->
+      Access.fetch([], "foo")
+    end
+
     assert Access.get([foo: :bar], :foo) == :bar
     assert Access.get_and_update([], :foo, fn nil -> {:ok, :baz} end) == {:ok, [foo: :baz]}
-    assert Access.get_and_update([foo: :bar], :foo, fn :bar -> {:ok, :baz} end) == {:ok, [foo: :baz]}
+
+    assert Access.get_and_update([foo: :bar], :foo, fn :bar -> {:ok, :baz} end) ==
+             {:ok, [foo: :baz]}
+
+    assert Access.pop([foo: :bar], :foo) == {:bar, []}
+    assert Access.pop([], :foo) == {nil, []}
   end
 
   test "for maps" do
@@ -39,18 +63,298 @@ defmodule AccessTest do
     assert %{1.0 => 1.0}[1.0] == 1.0
     assert %{1 => 1}[1.0] == nil
 
+    assert Access.fetch(%{foo: :bar}, :foo) == {:ok, :bar}
+    assert Access.fetch(%{foo: :bar}, :bar) == :error
+
     assert Access.get(%{foo: :bar}, :foo) == :bar
     assert Access.get_and_update(%{}, :foo, fn nil -> {:ok, :baz} end) == {:ok, %{foo: :baz}}
-    assert Access.get_and_update(%{foo: :bar}, :foo, fn :bar -> {:ok, :baz} end) == {:ok, %{foo: :baz}}
+
+    assert Access.get_and_update(%{foo: :bar}, :foo, fn :bar -> {:ok, :baz} end) ==
+             {:ok, %{foo: :baz}}
+
+    assert Access.pop(%{foo: :bar}, :foo) == {:bar, %{}}
+    assert Access.pop(%{}, :foo) == {nil, %{}}
   end
 
-  test "for atoms" do
-    assert_raise Protocol.UndefinedError, ~r"protocol Access not implemented for :foo", fn ->
-      Access.get(:foo, :bar)
+  test "for struct" do
+    defmodule Sample do
+      defstruct [:name]
+    end
+
+    message =
+      ~r"function AccessTest.Sample.fetch/2 is undefined \(AccessTest.Sample does not implement the Access behaviour"
+
+    assert_raise UndefinedFunctionError, message, fn ->
+      Access.fetch(struct(Sample, []), :name)
     end
 
-    assert_raise Protocol.UndefinedError, ~r"protocol Access not implemented for :foo", fn ->
-      Access.get_and_update(:foo, :bar, fn _ -> {:ok, :baz} end)
+    message =
+      ~r"function AccessTest.Sample.get_and_update/3 is undefined \(AccessTest.Sample does not implement the Access behaviour"
+
+    assert_raise UndefinedFunctionError, message, fn ->
+      Access.get_and_update(struct(Sample, []), :name, fn nil -> {:ok, :baz} end)
+    end
+
+    message =
+      ~r"function AccessTest.Sample.pop/2 is undefined \(AccessTest.Sample does not implement the Access behaviour"
+
+    assert_raise UndefinedFunctionError, message, fn ->
+      Access.pop(struct(Sample, []), :name)
+    end
+  end
+
+  describe "fetch!/2" do
+    assert Access.fetch!(%{foo: :bar}, :foo) == :bar
+
+    assert_raise ArgumentError,
+                 ~r/the Access calls for keywords expect the key to be an atom/,
+                 fn -> Access.fetch!([], "foo") end
+
+    assert_raise KeyError,
+                 ~r/key \"foo\" not found/,
+                 fn -> Access.fetch!(nil, "foo") end
+  end
+
+  describe "filter/1" do
+    @test_list [1, 2, 3, 4, 5, 6]
+
+    test "filters in get_in" do
+      assert get_in(@test_list, [Access.filter(&(&1 > 3))]) == [4, 5, 6]
+    end
+
+    test "retains order in get_and_update_in" do
+      assert get_and_update_in(@test_list, [Access.filter(&(&1 == 3 || &1 == 2))], &{&1 * 2, &1}) ==
+               {[4, 6], [1, 2, 3, 4, 5, 6]}
+    end
+
+    test "retains order in pop_in" do
+      assert pop_in(@test_list, [Access.filter(&(&1 == 3 || &1 == 2))]) == {[2, 3], [1, 4, 5, 6]}
+    end
+
+    test "chains with other access functions" do
+      mixed_map_and_list = %{foo: Enum.map(@test_list, &%{value: &1})}
+
+      assert get_in(mixed_map_and_list, [:foo, Access.filter(&(&1.value <= 3)), :value]) ==
+               [1, 2, 3]
+    end
+  end
+
+  describe "slice/1" do
+    @test_list [1, 2, 3, 4, 5, 6, 7]
+
+    test "retrieves a range from the start of the list" do
+      assert [2, 3] == get_in(@test_list, [Access.slice(1..2)])
+    end
+
+    test "retrieves a range from the end of the list" do
+      assert [6, 7] == get_in(@test_list, [Access.slice(-2..-1)])
+    end
+
+    test "retrieves a range from positive first and negative last" do
+      assert [2, 3, 4, 5, 6] == get_in(@test_list, [Access.slice(1..-2//1)])
+    end
+
+    test "retrieves a range from negative first and positive last" do
+      assert [6, 7] == get_in(@test_list, [Access.slice(-2..7//1)])
+    end
+
+    test "retrieves a range with steps" do
+      assert [1, 3] == get_in(@test_list, [Access.slice(0..2//2)])
+      assert [2, 5] == get_in(@test_list, [Access.slice(1..4//3)])
+      assert [2] == get_in(@test_list, [Access.slice(1..2//3)])
+      assert [1, 3, 5, 7] == get_in(@test_list, [Access.slice(0..6//2)])
+    end
+
+    test "pops a range from the start of the list" do
+      assert {[2, 3], [1, 4, 5, 6, 7]} == pop_in(@test_list, [Access.slice(1..2)])
+    end
+
+    test "pops a range from the end of the list" do
+      assert {[6, 7], [1, 2, 3, 4, 5]} == pop_in(@test_list, [Access.slice(-2..-1)])
+    end
+
+    test "pops a range from positive first and negative last" do
+      assert {[2, 3, 4, 5, 6], [1, 7]} == pop_in(@test_list, [Access.slice(1..-2//1)])
+    end
+
+    test "pops a range from negative first and positive last" do
+      assert {[6, 7], [1, 2, 3, 4, 5]} == pop_in(@test_list, [Access.slice(-2..7//1)])
+    end
+
+    test "pops a range with steps" do
+      assert {[1, 3, 5], [2, 4, 6, 7]} == pop_in(@test_list, [Access.slice(0..4//2)])
+      assert {[2], [1, 3, 4, 5, 6, 7]} == pop_in(@test_list, [Access.slice(1..2//2)])
+      assert {[1, 4], [1, 2, 5, 6, 7]} == pop_in([1, 2, 1, 4, 5, 6, 7], [Access.slice(2..3)])
+    end
+
+    test "updates range from the start of the list" do
+      assert [-1, 2, 3, 4, 5, 6, 7] == update_in(@test_list, [Access.slice(0..0)], &(&1 * -1))
+
+      assert [1, -2, -3, 4, 5, 6, 7] == update_in(@test_list, [Access.slice(1..2)], &(&1 * -1))
+    end
+
+    test "updates range from the end of the list" do
+      assert [1, 2, 3, 4, 5, -6, -7] == update_in(@test_list, [Access.slice(-2..-1)], &(&1 * -1))
+
+      assert [-1, -2, 3, 4, 5, 6, 7] == update_in(@test_list, [Access.slice(-7..-6)], &(&1 * -1))
+    end
+
+    test "updates a range from positive first and negative last" do
+      assert [1, -2, -3, -4, -5, -6, 7] ==
+               update_in(@test_list, [Access.slice(1..-2//1)], &(&1 * -1))
+    end
+
+    test "updates a range from negative first and positive last" do
+      assert [1, 2, 3, 4, 5, -6, -7] ==
+               update_in(@test_list, [Access.slice(-2..7//1)], &(&1 * -1))
+    end
+
+    test "updates a range with steps" do
+      assert [-1, 2, -3, 4, -5, 6, 7] ==
+               update_in(@test_list, [Access.slice(0..4//2)], &(&1 * -1))
+    end
+
+    test "returns empty when the start of the range is greater than the end" do
+      assert [] == get_in(@test_list, [Access.slice(2..1//1)])
+    end
+  end
+
+  describe "at/1" do
+    @test_list [1, 2, 3, 4, 5, 6]
+
+    test "returns element from the end if index is negative" do
+      assert get_in(@test_list, [Access.at(-2)]) == 5
+    end
+
+    test "returns nil if index is out of bounds counting from the end" do
+      assert get_in(@test_list, [Access.at(-10)]) == nil
+    end
+
+    test "updates the element counting from the end if index is negative" do
+      assert get_and_update_in(@test_list, [Access.at(-2)], fn prev ->
+               {prev, :foo}
+             end) == {5, [1, 2, 3, 4, :foo, 6]}
+    end
+
+    test "returns nil and does not update if index is out of bounds" do
+      assert get_and_update_in(@test_list, [Access.at(-10)], fn prev ->
+               {prev, :foo}
+             end) == {nil, [1, 2, 3, 4, 5, 6]}
+    end
+  end
+
+  describe "at!/1" do
+    @test_list [1, 2, 3, 4, 5, 6]
+
+    test "returns a list element when the index is within bounds, with get_in" do
+      assert get_in(@test_list, [Access.at!(5)]) == 6
+      assert get_in(@test_list, [Access.at!(-6)]) == 1
+    end
+
+    test "updates a list element when the index is within bounds, with get_and_update_in" do
+      assert get_and_update_in(@test_list, [Access.at!(5)], fn prev ->
+               {prev, :foo}
+             end) == {6, [1, 2, 3, 4, 5, :foo]}
+
+      assert get_and_update_in(@test_list, [Access.at!(-6)], fn prev ->
+               {prev, :foo}
+             end) == {1, [:foo, 2, 3, 4, 5, 6]}
+    end
+
+    test "raises OutOfBoundsError when out of bounds, with get_in" do
+      assert_raise Enum.OutOfBoundsError, fn ->
+        get_in(@test_list, [Access.at!(6)])
+      end
+
+      assert_raise Enum.OutOfBoundsError, fn ->
+        get_in(@test_list, [Access.at!(-7)])
+      end
+    end
+
+    test "raises OutOfBoundsError when out of bounds, with get_and_update_in" do
+      assert_raise Enum.OutOfBoundsError, fn ->
+        get_and_update_in(@test_list, [Access.at!(6)], fn prev -> {prev, :foo} end)
+      end
+
+      assert_raise Enum.OutOfBoundsError, fn ->
+        get_and_update_in(@test_list, [Access.at!(-7)], fn prev -> {prev, :foo} end)
+      end
+    end
+
+    test "raises when not given a list" do
+      assert_raise RuntimeError, "Access.at!/1 expected a list, got: %{}", fn ->
+        get_in(%{}, [Access.at!(0)])
+      end
+    end
+
+    test "chains" do
+      input = %{list: [%{greeting: "hi"}]}
+      assert get_in(input, [:list, Access.at!(0), :greeting]) == "hi"
+    end
+  end
+
+  describe "values/0" do
+    @test_map %{a: 1, b: 2, c: 3, d: 4}
+    @test_list [a: 1, b: 2, c: 3, d: 4]
+
+    test "retrieves values in a map" do
+      assert [1, 2, 3, 4] = get_in(@test_map, [Access.values()]) |> Enum.sort()
+    end
+
+    test "retrieves values in a keyword list" do
+      assert [1, 2, 3, 4] = get_in(@test_list, [Access.values()])
+    end
+
+    test "gets and updates values in a map" do
+      assert {gets, %{a: 3, b: 4, c: 5, d: 6}} =
+               get_and_update_in(@test_map, [Access.values()], fn n -> {n + 1, n + 2} end)
+
+      assert [2, 3, 4, 5] = Enum.sort(gets)
+    end
+
+    test "gets and updates values in a keyword list" do
+      assert {[2, 3, 4, 5], [a: 3, b: 4, c: 5, d: 6]} =
+               get_and_update_in(@test_list, [Access.values()], fn n -> {n + 1, n + 2} end)
+    end
+
+    test "pops values from a map" do
+      assert {gets, %{c: 4, d: 5}} =
+               get_and_update_in(@test_map, [Access.values()], fn n ->
+                 if(n > 2, do: {-n, n + 1}, else: :pop)
+               end)
+
+      assert [-4, -3, 1, 2] = Enum.sort(gets)
+    end
+
+    test "pops values from a keyword list" do
+      assert {[1, 2, -3, -4], [c: 4, d: 5]} =
+               get_and_update_in(@test_list, [Access.values()], fn n ->
+                 if(n > 2, do: {-n, n + 1}, else: :pop)
+               end)
+    end
+
+    test "raises when not given a map or a keyword list" do
+      message = ~r[^Access.values/0 expected a map or a keyword list, got: .*]
+
+      assert_raise RuntimeError, message, fn ->
+        get_in(123, [Access.values()])
+      end
+
+      assert_raise RuntimeError, message, fn ->
+        get_and_update_in(:some_atom, [Access.values()], fn x -> {x, x} end)
+      end
+
+      assert_raise RuntimeError, message, fn ->
+        get_in([:a, :b, :c], [Access.values()])
+      end
+
+      assert_raise RuntimeError, message, fn ->
+        get_in([{:a, :b, :c}, {:d, :e, :f}], [Access.values()])
+      end
+
+      assert_raise RuntimeError, message, fn ->
+        get_in([{1, 2}, {3, 4}], [Access.values()])
+      end
     end
   end
 end
diff --git a/lib/elixir/test/elixir/agent_test.exs b/lib/elixir/test/elixir/agent_test.exs
index d4d58548806..ec0e5c3c45f 100644
--- a/lib/elixir/test/elixir/agent_test.exs
+++ b/lib/elixir/test/elixir/agent_test.exs
@@ -1,37 +1,81 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule AgentTest do
   use ExUnit.Case, async: true
 
-  test "start_link/2 workflow with unregistered name" do
-    {:ok, pid} = Agent.start_link(fn -> %{} end)
+  doctest Agent
+
+  def identity(state) do
+    state
+  end
+
+  test "can be supervised directly" do
+    assert {:ok, _} = Supervisor.start_link([{Agent, fn -> :ok end}], strategy: :one_for_one)
+  end
+
+  test "generates child_spec/1" do
+    defmodule MyAgent do
+      use Agent
+    end
 
-    {:links, links} = Process.info(self, :links)
+    assert MyAgent.child_spec([:hello]) == %{
+             id: MyAgent,
+             start: {MyAgent, :start_link, [[:hello]]}
+           }
+
+    defmodule CustomAgent do
+      use Agent, id: :id, restart: :temporary, shutdown: :infinity, start: {:foo, :bar, []}
+    end
+
+    assert CustomAgent.child_spec([:hello]) == %{
+             id: :id,
+             restart: :temporary,
+             shutdown: :infinity,
+             start: {:foo, :bar, []}
+           }
+  end
+
+  test "start_link/2 workflow with unregistered name and anonymous functions" do
+    {:ok, pid} = Agent.start_link(&Map.new/0)
+
+    {:links, links} = Process.info(self(), :links)
     assert pid in links
 
+    assert :proc_lib.translate_initial_call(pid) == {Map, :new, 0}
+
     assert Agent.update(pid, &Map.put(&1, :hello, :world)) == :ok
     assert Agent.get(pid, &Map.get(&1, :hello), 3000) == :world
     assert Agent.get_and_update(pid, &Map.pop(&1, :hello), 3000) == :world
-    assert Agent.get(pid, &(&1)) == %{}
+    assert Agent.get(pid, & &1) == %{}
     assert Agent.stop(pid) == :ok
     wait_until_dead(pid)
   end
 
-  test "start/2 workflow with registered name" do
-    {:ok, pid} = Agent.start(fn -> %{} end, name: :agent)
+  test "start_link/2 with spawn_opt" do
+    {:ok, pid} = Agent.start_link(fn -> 0 end, spawn_opt: [priority: :high])
+    assert Process.info(pid, :priority) == {:priority, :high}
+  end
+
+  test "start/2 workflow with registered name and module functions" do
+    {:ok, pid} = Agent.start(Map, :new, [], name: :agent)
     assert Process.info(pid, :registered_name) == {:registered_name, :agent}
-    assert Agent.cast(:agent, &Map.put(&1, :hello, :world)) == :ok
-    assert Agent.get(:agent, &Map.get(&1, :hello)) == :world
-    assert Agent.get_and_update(:agent, &Map.pop(&1, :hello)) == :world
-    assert Agent.get(:agent, &(&1)) == %{}
+    assert :proc_lib.translate_initial_call(pid) == {Map, :new, 0}
+    assert Agent.cast(:agent, Map, :put, [:hello, :world]) == :ok
+    assert Agent.get(:agent, Map, :get, [:hello]) == :world
+    assert Agent.get_and_update(:agent, Map, :pop, [:hello]) == :world
+    assert Agent.get(:agent, AgentTest, :identity, []) == %{}
     assert Agent.stop(:agent) == :ok
     assert Process.info(pid, :registered_name) == nil
   end
 
   test ":sys.change_code/4 with mfa" do
-    { :ok, pid } = Agent.start_link(fn -> %{} end)
+    {:ok, pid} = Agent.start_link(fn -> %{} end)
     :ok = :sys.suspend(pid)
-    mfa = { Map, :put, [:hello, :world] }
+    mfa = {Map, :put, [:hello, :world]}
     assert :sys.change_code(pid, __MODULE__, "vsn", mfa) == :ok
     :ok = :sys.resume(pid)
     assert Agent.get(pid, &Map.get(&1, :hello)) == :world
@@ -39,12 +83,12 @@ defmodule AgentTest do
   end
 
   test ":sys.change_code/4 with raising mfa" do
-    { :ok, pid } = Agent.start_link(fn -> %{} end)
+    {:ok, pid} = Agent.start_link(fn -> %{} end)
     :ok = :sys.suspend(pid)
-    mfa = { :erlang, :error, [] }
-    assert match?({ :error, _ }, :sys.change_code(pid, __MODULE__, "vsn", mfa))
+    mfa = {:erlang, :error, []}
+    assert match?({:error, _}, :sys.change_code(pid, __MODULE__, "vsn", mfa))
     :ok = :sys.resume(pid)
-    assert Agent.get(pid, &(&1)) == %{}
+    assert Agent.get(pid, & &1) == %{}
     assert Agent.stop(pid) == :ok
   end
 
diff --git a/lib/elixir/test/elixir/application_test.exs b/lib/elixir/test/elixir/application_test.exs
index 20258320fb2..7c1b380e8fa 100644
--- a/lib/elixir/test/elixir/application_test.exs
+++ b/lib/elixir/test/elixir/application_test.exs
@@ -1,31 +1,203 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule ApplicationTest do
   use ExUnit.Case, async: true
 
+  import PathHelpers
+  import ExUnit.CaptureIO
+
+  @app :elixir
+
   test "application environment" do
+    assert_raise ArgumentError, ~r/because the application was not loaded nor configured/, fn ->
+      Application.fetch_env!(:unknown, :unknown)
+    end
+
+    assert_raise ArgumentError, ~r/because configuration at :unknown was not set/, fn ->
+      Application.fetch_env!(:elixir, :unknown)
+    end
+
     assert Application.get_env(:elixir, :unknown) == nil
     assert Application.get_env(:elixir, :unknown, :default) == :default
     assert Application.fetch_env(:elixir, :unknown) == :error
 
     assert Application.put_env(:elixir, :unknown, :known) == :ok
     assert Application.fetch_env(:elixir, :unknown) == {:ok, :known}
+    assert Application.fetch_env!(:elixir, :unknown) == :known
     assert Application.get_env(:elixir, :unknown, :default) == :known
     assert {:unknown, :known} in Application.get_all_env(:elixir)
 
     assert Application.delete_env(:elixir, :unknown) == :ok
     assert Application.get_env(:elixir, :unknown, :default) == :default
+  after
+    Application.delete_env(:elixir, :unknown)
+  end
+
+  test "deprecated non-atom keys" do
+    assert_deprecated(fn ->
+      Application.put_env(:elixir, [:a, :b], :c)
+    end)
+
+    assert_deprecated(fn ->
+      assert Application.get_env(:elixir, [:a, :b]) == :c
+    end)
+
+    assert_deprecated(fn ->
+      assert Application.fetch_env!(:elixir, [:a, :b]) == :c
+    end)
+  after
+    assert_deprecated(fn ->
+      Application.delete_env(:elixir, [:a, :b])
+    end)
+  end
+
+  defp assert_deprecated(fun) do
+    assert capture_io(:stderr, fun) =~ ~r/passing non-atom as application env key is deprecated/
+  end
+
+  describe "compile environment" do
+    test "invoked at compile time" do
+      assert_raise ArgumentError, ~r/because the application was not loaded nor configured/, fn ->
+        compile_env!(:unknown, :unknown)
+      end
+
+      assert_received {:compile_env, :unknown, [:unknown], :error}
+
+      assert_raise ArgumentError, ~r/because configuration at :unknown was not set/, fn ->
+        compile_env!(:elixir, :unknown)
+      end
+
+      assert_received {:compile_env, :elixir, [:unknown], :error}
+
+      assert compile_env(:elixir, :unknown) == nil
+      assert_received {:compile_env, :elixir, [:unknown], :error}
+
+      assert compile_env(:elixir, :unknown, :default) == :default
+      assert_received {:compile_env, :elixir, [:unknown], :error}
+
+      assert Application.put_env(:elixir, :unknown, nested: [key: :value]) == :ok
+
+      assert compile_env(@app, :unknown, :default) == [nested: [key: :value]]
+      assert_received {:compile_env, :elixir, [:unknown], {:ok, [nested: [key: :value]]}}
+      assert compile_env(:elixir, :unknown, :default) == [nested: [key: :value]]
+      assert_received {:compile_env, :elixir, [:unknown], {:ok, [nested: [key: :value]]}}
+
+      assert compile_env(:elixir, :unknown) == [nested: [key: :value]]
+      assert_received {:compile_env, :elixir, [:unknown], {:ok, [nested: [key: :value]]}}
+
+      assert compile_env!(@app, :unknown) == [nested: [key: :value]]
+      assert_received {:compile_env, :elixir, [:unknown], {:ok, [nested: [key: :value]]}}
+      assert compile_env!(:elixir, :unknown) == [nested: [key: :value]]
+      assert_received {:compile_env, :elixir, [:unknown], {:ok, [nested: [key: :value]]}}
+
+      assert compile_env(:elixir, [:unknown, :nested]) == [key: :value]
+      assert_received {:compile_env, :elixir, [:unknown, :nested], {:ok, [key: :value]}}
+
+      assert compile_env!(:elixir, [:unknown, :nested]) == [key: :value]
+      assert_received {:compile_env, :elixir, [:unknown, :nested], {:ok, [key: :value]}}
+
+      assert compile_env(:elixir, [:unknown, :nested, :key]) == :value
+      assert_received {:compile_env, :elixir, [:unknown, :nested, :key], {:ok, :value}}
+
+      assert compile_env!(:elixir, [:unknown, :nested, :key]) == :value
+      assert_received {:compile_env, :elixir, [:unknown, :nested, :key], {:ok, :value}}
+
+      assert compile_env(:elixir, [:unknown, :unknown, :key], :default) == :default
+      assert_received {:compile_env, :elixir, [:unknown, :unknown, :key], :error}
+
+      assert compile_env(:elixir, [:unknown, :nested, :unknown], :default) == :default
+      assert_received {:compile_env, :elixir, [:unknown, :nested, :unknown], :error}
+    after
+      Application.delete_env(:elixir, :unknown)
+    end
+
+    def trace({:compile_env, _, _, _} = msg, %Macro.Env{}) do
+      send(self(), msg)
+      :ok
+    end
+
+    def trace(_, _), do: :ok
+
+    defp compile_env(app, key, default \\ nil) do
+      code =
+        quote do
+          require Application
+          Application.compile_env(unquote(app), unquote(key), unquote(default))
+        end
+
+      {result, _binding} = Code.eval_quoted(code, [], tracers: [__MODULE__])
+      result
+    end
+
+    defp compile_env!(app, key) do
+      code =
+        quote do
+          require Application
+          Application.compile_env!(unquote(app), unquote(key))
+        end
+
+      {result, _binding} = Code.eval_quoted(code, [], tracers: [__MODULE__])
+      result
+    end
+  end
+
+  test "loaded and started applications" do
+    started = Application.started_applications()
+    assert is_list(started)
+    assert {:elixir, ~c"elixir", _} = List.keyfind(started, :elixir, 0)
+
+    started_timeout = Application.started_applications(7000)
+    assert is_list(started_timeout)
+    assert {:elixir, ~c"elixir", _} = List.keyfind(started_timeout, :elixir, 0)
+
+    loaded = Application.loaded_applications()
+    assert is_list(loaded)
+    assert {:elixir, ~c"elixir", _} = List.keyfind(loaded, :elixir, 0)
+  end
+
+  test "application specification" do
+    assert is_list(Application.spec(:elixir))
+    assert Application.spec(:unknown) == nil
+    assert Application.spec(:unknown, :description) == nil
+
+    assert Application.spec(:elixir, :description) == ~c"elixir"
+    assert_raise FunctionClauseError, fn -> Application.spec(:elixir, :unknown) end
+  end
+
+  test "application module" do
+    assert Application.get_application(String) == :elixir
+    assert Application.get_application(__MODULE__) == nil
+    assert Application.get_application(__MODULE__.Unknown) == nil
   end
 
   test "application directory" do
     root = Path.expand("../../../..", __DIR__)
-    assert Application.app_dir(:elixir) ==
-           Path.join(root, "bin/../lib/elixir")
-    assert Application.app_dir(:elixir, "priv") ==
-           Path.join(root, "bin/../lib/elixir/priv")
+
+    assert normalize_app_dir(Application.app_dir(:elixir)) ==
+             normalize_app_dir(Path.join(root, "bin/../lib/elixir"))
+
+    assert normalize_app_dir(Application.app_dir(:elixir, "priv")) ==
+             normalize_app_dir(Path.join(root, "bin/../lib/elixir/priv"))
+
+    assert normalize_app_dir(Application.app_dir(:elixir, ["priv", "foo"])) ==
+             normalize_app_dir(Path.join(root, "bin/../lib/elixir/priv/foo"))
 
     assert_raise ArgumentError, fn ->
       Application.app_dir(:unknown)
     end
   end
+
+  if windows?() do
+    defp normalize_app_dir(path) do
+      path |> String.downcase() |> Path.expand()
+    end
+  else
+    defp normalize_app_dir(path) do
+      path |> String.downcase()
+    end
+  end
 end
diff --git a/lib/elixir/test/elixir/atom_test.exs b/lib/elixir/test/elixir/atom_test.exs
index 7d6d5bcb7ff..e72b7fd9ff7 100644
--- a/lib/elixir/test/elixir/atom_test.exs
+++ b/lib/elixir/test/elixir/atom_test.exs
@@ -1,13 +1,19 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule AtomTest do
   use ExUnit.Case, async: true
 
+  doctest Atom, except: [:moduledoc]
+
   test "to_string/1" do
-    assert Atom.to_string(:"héllo") == "héllo"
+    assert "héllo" |> String.to_atom() |> Atom.to_string() == "héllo"
   end
 
-  test "to_char_list/1" do
-    assert Atom.to_char_list(:"héllo") == 'héllo'
+  test "to_charlist/1" do
+    assert "héllo" |> String.to_atom() |> Atom.to_charlist() == ~c"héllo"
   end
 end
diff --git a/lib/elixir/test/elixir/base_test.exs b/lib/elixir/test/elixir/base_test.exs
index d976bc14173..aeb5f4b5c24 100644
--- a/lib/elixir/test/elixir/base_test.exs
+++ b/lib/elixir/test/elixir/base_test.exs
@@ -1,10 +1,16 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule BaseTest do
   use ExUnit.Case, async: true
+
+  doctest Base
   import Base
 
-  test "encode16" do
+  test "encode16/1" do
     assert "" == encode16("")
     assert "66" == encode16("f")
     assert "666F" == encode16("fo")
@@ -14,10 +20,11 @@ defmodule BaseTest do
     assert "666F6F626172" == encode16("foobar")
     assert "A1B2C3D4E5F67891" == encode16(<<161, 178, 195, 212, 229, 246, 120, 145>>)
 
-    assert "a1b2c3d4e5f67891" == encode16(<<161, 178, 195, 212, 229, 246, 120, 145>>, case: :lower)
+    assert "a1b2c3d4e5f67891" ==
+             encode16(<<161, 178, 195, 212, 229, 246, 120, 145>>, case: :lower)
   end
 
-  test "decode16" do
+  test "decode16/1" do
     assert {:ok, ""} == decode16("")
     assert {:ok, "f"} == decode16("66")
     assert {:ok, "fo"} == decode16("666F")
@@ -25,13 +32,16 @@ defmodule BaseTest do
     assert {:ok, "foob"} == decode16("666F6F62")
     assert {:ok, "fooba"} == decode16("666F6F6261")
     assert {:ok, "foobar"} == decode16("666F6F626172")
-    assert {:ok, <<161, 178,  195, 212, 229, 246, 120, 145>>} == decode16("A1B2C3D4E5F67891")
+    assert {:ok, <<161, 178, 195, 212, 229, 246, 120, 145>>} == decode16("A1B2C3D4E5F67891")
+
+    assert {:ok, <<161, 178, 195, 212, 229, 246, 120, 145>>} ==
+             decode16("a1b2c3d4e5f67891", case: :lower)
 
-    assert {:ok, <<161, 178,  195, 212, 229, 246, 120, 145>>} == decode16("a1b2c3d4e5f67891", case: :lower)
-    assert {:ok, <<161, 178,  195, 212, 229, 246, 120, 145>>} == decode16("a1B2c3D4e5F67891", case: :mixed)
+    assert {:ok, <<161, 178, 195, 212, 229, 246, 120, 145>>} ==
+             decode16("a1B2c3D4e5F67891", case: :mixed)
   end
 
-  test "decode16!" do
+  test "decode16!/1" do
     assert "" == decode16!("")
     assert "f" == decode16!("66")
     assert "fo" == decode16!("666F")
@@ -41,424 +51,1048 @@ defmodule BaseTest do
     assert "foobar" == decode16!("666F6F626172")
     assert <<161, 178, 195, 212, 229, 246, 120, 145>> == decode16!("A1B2C3D4E5F67891")
 
-    assert <<161, 178,  195, 212, 229, 246, 120, 145>> == decode16!("a1b2c3d4e5f67891", case: :lower)
-    assert  <<161, 178,  195, 212, 229, 246, 120, 145>> == decode16!("a1B2c3D4e5F67891", case: :mixed)
+    assert <<161, 178, 195, 212, 229, 246, 120, 145>> ==
+             decode16!("a1b2c3d4e5f67891", case: :lower)
+
+    assert <<161, 178, 195, 212, 229, 246, 120, 145>> ==
+             decode16!("a1B2c3D4e5F67891", case: :mixed)
   end
 
-  test "decode16 non-alphabet digit" do
+  test "decode16/1 errors on non-alphabet character" do
     assert :error == decode16("66KF")
     assert :error == decode16("66ff")
     assert :error == decode16("66FF", case: :lower)
   end
 
-  test "decode16! non-alphabet digit" do
-    assert_raise ArgumentError, "non-alphabet digit found: K", fn ->
+  test "decode16!/1 errors on non-alphabet character" do
+    assert_raise ArgumentError, "non-alphabet character found: \"K\" (byte 75)", fn ->
       decode16!("66KF")
     end
-    assert_raise ArgumentError, "non-alphabet digit found: f", fn ->
+
+    assert_raise ArgumentError, "non-alphabet character found: \"f\" (byte 102)", fn ->
       decode16!("66ff")
     end
-    assert_raise ArgumentError, "non-alphabet digit found: F", fn ->
+
+    assert_raise ArgumentError, "non-alphabet character found: \"F\" (byte 70)", fn ->
       decode16!("66FF", case: :lower)
     end
   end
 
-  test "decode16 odd-length string" do
+  test "decode16/1 errors on odd-length string" do
     assert :error == decode16("666")
   end
 
-  test "decode16! odd-length string" do
-    assert_raise ArgumentError, "odd-length string", fn ->
+  test "decode16!/1 errors odd-length string" do
+    assert_raise ArgumentError, ~r/string given to decode has wrong length/, fn ->
       decode16!("666")
     end
   end
 
-  test "encode64 empty" do
+  test "valid16?/1" do
+    assert valid16?("")
+    assert valid16?("66")
+    assert valid16?("666F")
+    assert valid16?("666F6F")
+    assert valid16?("666F6F62")
+    assert valid16?("666F6F6261")
+    assert valid16?("666F6F626172")
+    assert valid16?("A1B2C3D4E5F67891")
+    assert valid16?("a1b2c3d4e5f67891", case: :lower)
+    assert valid16?("a1B2c3D4e5F67891", case: :mixed)
+  end
+
+  test "valid16?/1 returns false on non-alphabet character" do
+    refute valid16?("66KF")
+    refute valid16?("66ff")
+    refute valid16?("66FF", case: :lower)
+    refute valid16?("66fg", case: :mixed)
+  end
+
+  test "valid16?/1 errors on odd-length string" do
+    refute valid16?("666")
+  end
+
+  test "encode64/1 can deal with empty strings" do
     assert "" == encode64("")
   end
 
-  test "encode64 two pads" do
+  test "encode64/1 with two pads" do
     assert "QWxhZGRpbjpvcGVuIHNlc2FtZQ==" == encode64("Aladdin:open sesame")
   end
 
-  test "encode64 one pad" do
+  test "encode64/1 with one pad" do
     assert "SGVsbG8gV29ybGQ=" == encode64("Hello World")
   end
 
-  test "encode64 no pad" do
+  test "encode64/1 with no pad" do
     assert "QWxhZGRpbjpvcGVuIHNlc2Ft" == encode64("Aladdin:open sesam")
-    assert "MDEyMzQ1Njc4OSFAIzBeJiooKTs6PD4sLiBbXXt9" == encode64(<<"0123456789!@#0^&*();:<>,. []{}">>)
+
+    assert "MDEyMzQ1Njc4OSFAIzBeJiooKTs6PD4sLiBbXXt9" ==
+             encode64(<<"0123456789!@#0^&*();:<>,. []{}">>)
+  end
+
+  test "encode64/1 with one pad and ignoring padding" do
+    assert "SGVsbG8gV29ybGQ" == encode64("Hello World", padding: false)
+  end
+
+  test "encode64/1 with two pads and ignoring padding" do
+    assert "QWxhZGRpbjpvcGVuIHNlc2FtZQ" == encode64("Aladdin:open sesame", padding: false)
+  end
+
+  test "encode64/1 with no pads and ignoring padding" do
+    assert "QWxhZGRpbjpvcGVuIHNlc2Ft" == encode64("Aladdin:open sesam", padding: false)
   end
 
-  test "decode64 empty" do
+  test "decode64/1 can deal with empty strings" do
     assert {:ok, ""} == decode64("")
   end
 
-  test "decode64! empty" do
+  test "decode64!/1 can deal with empty strings" do
     assert "" == decode64!("")
   end
 
-  test "decode64 two pads" do
+  test "decode64/1 with two pads" do
     assert {:ok, "Aladdin:open sesame"} == decode64("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
   end
 
-  test "decode64! two pads" do
+  test "decode64!/1 with two pads" do
     assert "Aladdin:open sesame" == decode64!("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
   end
 
-  test "decode64 one pad" do
+  test "decode64/1 with one pad" do
     assert {:ok, "Hello World"} == decode64("SGVsbG8gV29ybGQ=")
   end
 
-  test "decode64! one pad" do
+  test "decode64!/1 with one pad" do
     assert "Hello World" == decode64!("SGVsbG8gV29ybGQ=")
   end
 
-  test "decode64 no pad" do
+  test "decode64/1 with no pad" do
     assert {:ok, "Aladdin:open sesam"} == decode64("QWxhZGRpbjpvcGVuIHNlc2Ft")
   end
 
-  test "decode64! no pad" do
+  test "decode64!/1 with no pad" do
     assert "Aladdin:open sesam" == decode64!("QWxhZGRpbjpvcGVuIHNlc2Ft")
   end
 
-  test "decode64 non-alphabet digit" do
+  test "decode64/1 errors on non-alphabet character" do
     assert :error == decode64("Zm9)")
   end
 
-  test "decode64! non-alphabet digit" do
-    assert_raise ArgumentError, "non-alphabet digit found: )", fn ->
+  test "decode64!/1 errors on non-alphabet character" do
+    assert_raise ArgumentError, "non-alphabet character found: \")\" (byte 41)", fn ->
       decode64!("Zm9)")
     end
   end
 
-  test "decode64 incorrect padding" do
+  test "decode64/1 errors on whitespace unless there's ignore: :whitespace" do
+    assert :error == decode64("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t")
+
+    assert {:ok, "Aladdin:open sesam"} ==
+             decode64("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t", ignore: :whitespace)
+  end
+
+  test "decode64!/1 errors on whitespace unless there's ignore: :whitespace" do
+    assert_raise ArgumentError, "non-alphabet character found: \"\\n\" (byte 10)", fn ->
+      decode64!("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t")
+    end
+
+    assert "Aladdin:open sesam" ==
+             decode64!("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t", ignore: :whitespace)
+  end
+
+  test "decode64/1 errors on incorrect padding" do
     assert :error == decode64("SGVsbG8gV29ybGQ")
   end
 
-  test "decode64! incorrect padding" do
+  test "decode64!/1 errors on incorrect padding" do
     assert_raise ArgumentError, "incorrect padding", fn ->
       decode64!("SGVsbG8gV29ybGQ")
     end
   end
 
-  test "url_encode64 empty" do
+  test "decode64/2 with two pads and ignoring padding" do
+    assert {:ok, "Aladdin:open sesame"} == decode64("QWxhZGRpbjpvcGVuIHNlc2FtZQ", padding: false)
+  end
+
+  test "decode64!/2 with two pads and ignoring padding" do
+    assert "Aladdin:open sesame" == decode64!("QWxhZGRpbjpvcGVuIHNlc2FtZQ", padding: false)
+  end
+
+  test "decode64/2 with one pad and ignoring padding" do
+    assert {:ok, "Hello World"} == decode64("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "decode64!/2 with one pad and ignoring padding" do
+    assert "Hello World" == decode64!("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "decode64/2 with no pad and ignoring padding" do
+    assert {:ok, "Aladdin:open sesam"} == decode64("QWxhZGRpbjpvcGVuIHNlc2Ft", padding: false)
+  end
+
+  test "decode64!/2 with no pad and ignoring padding" do
+    assert "Aladdin:open sesam" == decode64!("QWxhZGRpbjpvcGVuIHNlc2Ft", padding: false)
+  end
+
+  test "decode64/2 with incorrect padding and ignoring padding" do
+    assert {:ok, "Hello World"} == decode64("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "decode64!/2 with incorrect padding and ignoring padding" do
+    assert "Hello World" == decode64!("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "valid64?/1 can deal with empty strings" do
+    assert valid64?("")
+  end
+
+  test "valid64?/1 with two pads" do
+    assert valid64?("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
+  end
+
+  test "valid64?/1 with one pad" do
+    assert valid64?("SGVsbG8gV29ybGQ=")
+  end
+
+  test "valid64?/1 with no pad" do
+    assert valid64?("QWxhZGRpbjpvcGVuIHNlc2Ft")
+  end
+
+  test "valid64?/1 returns false on non-alphabet character" do
+    refute valid64?("Zm9)")
+  end
+
+  test "valid64?/1 returns false on whitespace unless there's ignore: :whitespace" do
+    refute valid64?("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t")
+
+    assert valid64?("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t", ignore: :whitespace)
+  end
+
+  test "valid64?/1 returns false on incorrect padding" do
+    refute valid64?("SGVsbG8gV29ybGQ")
+  end
+
+  test "valid64?/2 with two pads and ignoring padding" do
+    assert valid64?("QWxhZGRpbjpvcGVuIHNlc2FtZQ", padding: false)
+  end
+
+  test "valid64?/2 with one pad and ignoring padding" do
+    assert valid64?("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "valid64?/2 with no pad and ignoring padding" do
+    assert valid64?("QWxhZGRpbjpvcGVuIHNlc2Ft", padding: false)
+  end
+
+  test "valid64?/2 with incorrect padding and ignoring padding" do
+    assert valid64?("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "url_encode64/1 can deal with empty strings" do
     assert "" == url_encode64("")
   end
 
-  test "url_encode64 two pads" do
+  test "url_encode64/1 with two pads" do
     assert "QWxhZGRpbjpvcGVuIHNlc2FtZQ==" == url_encode64("Aladdin:open sesame")
   end
 
-  test "url_encode64 one pad" do
+  test "url_encode64/1 with one pad" do
     assert "SGVsbG8gV29ybGQ=" == url_encode64("Hello World")
   end
 
-  test "url_encode64 no pad" do
+  test "url_encode64/1 with no pad" do
     assert "QWxhZGRpbjpvcGVuIHNlc2Ft" == url_encode64("Aladdin:open sesam")
-    assert "MDEyMzQ1Njc4OSFAIzBeJiooKTs6PD4sLiBbXXt9" == url_encode64(<<"0123456789!@#0^&*();:<>,. []{}">>)
+
+    assert "MDEyMzQ1Njc4OSFAIzBeJiooKTs6PD4sLiBbXXt9" ==
+             url_encode64(<<"0123456789!@#0^&*();:<>,. []{}">>)
   end
 
-  test "url_encode64 no URL unsafe characters" do
-    refute "/3/+/A==" == url_encode64(<<255,127,254,252>>)
-    assert "_3_-_A==" == url_encode64(<<255,127,254,252>>)
+  test "url_encode64/2 with two pads and ignoring padding" do
+    assert "QWxhZGRpbjpvcGVuIHNlc2FtZQ" == url_encode64("Aladdin:open sesame", padding: false)
   end
 
-  test "url_decode64 empty" do
+  test "url_encode64/2 with one pad and ignoring padding" do
+    assert "SGVsbG8gV29ybGQ" == url_encode64("Hello World", padding: false)
+  end
+
+  test "url_encode64/2 with no pad and ignoring padding" do
+    assert "QWxhZGRpbjpvcGVuIHNlc2Ft" == url_encode64("Aladdin:open sesam", padding: false)
+  end
+
+  test "url_encode64/1 doesn't produce URL-unsafe characters" do
+    refute "/3/+/A==" == url_encode64(<<255, 127, 254, 252>>)
+    assert "_3_-_A==" == url_encode64(<<255, 127, 254, 252>>)
+  end
+
+  test "url_decode64/1 can deal with empty strings" do
     assert {:ok, ""} == url_decode64("")
   end
 
-  test "url_decode64! empty" do
+  test "url_decode64!/1 can deal with empty strings" do
     assert "" == url_decode64!("")
   end
 
-  test "url_decode64 two pads" do
+  test "url_decode64/1 with two pads" do
     assert {:ok, "Aladdin:open sesame"} == url_decode64("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
   end
 
-  test "url_decode64! two pads" do
+  test "url_decode64!/1 with two pads" do
     assert "Aladdin:open sesame" == url_decode64!("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
   end
 
-  test "url_decode64 one pad" do
+  test "url_decode64/1 with one pad" do
     assert {:ok, "Hello World"} == url_decode64("SGVsbG8gV29ybGQ=")
   end
 
-  test "url_decode64! one pad" do
+  test "url_decode64!/1 with one pad" do
     assert "Hello World" == url_decode64!("SGVsbG8gV29ybGQ=")
   end
 
-  test "url_decode64 no pad" do
+  test "url_decode64/1 with no pad" do
     assert {:ok, "Aladdin:open sesam"} == url_decode64("QWxhZGRpbjpvcGVuIHNlc2Ft")
   end
 
-  test "url_decode64! no pad" do
+  test "url_decode64!/1 with no pad" do
     assert "Aladdin:open sesam" == url_decode64!("QWxhZGRpbjpvcGVuIHNlc2Ft")
   end
 
-  test "url_decode64 non-alphabet digit" do
+  test "url_decode64/1,2 error on whitespace unless there's ignore: :whitespace" do
+    assert :error == url_decode64("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t")
+
+    assert {:ok, "Aladdin:open sesam"} ==
+             url_decode64("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t", ignore: :whitespace)
+  end
+
+  test "url_decode64!/1,2 error on whitespace unless there's ignore: :whitespace" do
+    assert_raise ArgumentError, "non-alphabet character found: \"\\n\" (byte 10)", fn ->
+      url_decode64!("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t")
+    end
+
+    assert "Aladdin:open sesam" ==
+             url_decode64!("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t", ignore: :whitespace)
+  end
+
+  test "url_decode64/1 errors on non-alphabet character" do
     assert :error == url_decode64("Zm9)")
   end
 
-  test "url_decode64! non-alphabet digit" do
-    assert_raise ArgumentError, "non-alphabet digit found: )", fn ->
+  test "url_decode64!/1 errors on non-alphabet character" do
+    assert_raise ArgumentError, "non-alphabet character found: \")\" (byte 41)", fn ->
       url_decode64!("Zm9)")
     end
   end
 
-  test "url_decode64 incorrect padding" do
+  test "url_decode64/1 errors on incorrect padding" do
     assert :error == url_decode64("SGVsbG8gV29ybGQ")
   end
 
-  test "url_decode64! incorrect padding" do
+  test "url_decode64!/1 errors on incorrect padding" do
     assert_raise ArgumentError, "incorrect padding", fn ->
       url_decode64!("SGVsbG8gV29ybGQ")
     end
   end
 
-  test "encode32 empty" do
+  test "url_decode64/2 with two pads and ignoring padding" do
+    assert {:ok, "Aladdin:open sesame"} ==
+             url_decode64("QWxhZGRpbjpvcGVuIHNlc2FtZQ", padding: false)
+  end
+
+  test "url_decode64!/2 with two pads and ignoring padding" do
+    assert "Aladdin:open sesame" == url_decode64!("QWxhZGRpbjpvcGVuIHNlc2FtZQ", padding: false)
+  end
+
+  test "url_decode64/2 with one pad and ignoring padding" do
+    assert {:ok, "Hello World"} == url_decode64("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "url_decode64!/2 with one pad and ignoring padding" do
+    assert "Hello World" == url_decode64!("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "url_decode64/2 with no pad and ignoring padding" do
+    assert {:ok, "Aladdin:open sesam"} == url_decode64("QWxhZGRpbjpvcGVuIHNlc2Ft", padding: false)
+  end
+
+  test "url_decode64!/2 with no pad and ignoring padding" do
+    assert "Aladdin:open sesam" == url_decode64!("QWxhZGRpbjpvcGVuIHNlc2Ft", padding: false)
+  end
+
+  test "url_decode64/2 ignores incorrect padding when :padding is false" do
+    assert {:ok, "Hello World"} == url_decode64("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "url_decode64!/2 ignores incorrect padding when :padding is false" do
+    assert "Hello World" == url_decode64!("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "url_valid64?/1 can deal with empty strings" do
+    assert url_valid64?("")
+  end
+
+  test "url_valid64?/1 with two pads" do
+    assert url_valid64?("QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
+  end
+
+  test "url_valid64?/1 with one pad" do
+    assert url_valid64?("SGVsbG8gV29ybGQ=")
+  end
+
+  test "url_valid64?/1 with no pad" do
+    assert url_valid64?("QWxhZGRpbjpvcGVuIHNlc2Ft")
+  end
+
+  test "url_valid64?/1 returns false on non-alphabet character" do
+    refute url_valid64?("Zm9)")
+  end
+
+  test "url_valid64?/1 returns false on whitespace unless there's ignore: :whitespace" do
+    refute url_valid64?("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t")
+
+    assert url_valid64?("\nQWxhZGRp bjpvcGVu\sIHNlc2Ft\t", ignore: :whitespace)
+  end
+
+  test "url_valid64?/1 returns false on incorrect padding" do
+    refute url_valid64?("SGVsbG8gV29ybGQ")
+  end
+
+  test "url_valid64?/2 with two pads and ignoring padding" do
+    assert url_valid64?("QWxhZGRpbjpvcGVuIHNlc2FtZQ", padding: false)
+  end
+
+  test "url_valid64?/2 with one pad and ignoring padding" do
+    assert url_valid64?("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "url_valid64?/2 with no pad and ignoring padding" do
+    assert url_valid64?("QWxhZGRpbjpvcGVuIHNlc2Ft", padding: false)
+  end
+
+  test "url_valid64?/2 errors on incorrect padding" do
+    refute url_valid64?("SGVsbG8gV29ybGQ")
+  end
+
+  test "url_valid64?/2 ignores incorrect padding when :padding is false" do
+    assert url_valid64?("SGVsbG8gV29ybGQ", padding: false)
+  end
+
+  test "encode32/1 can deal with empty strings" do
     assert "" == encode32("")
   end
 
-  test "encode32 one pad" do
+  test "encode32/1 with one pad" do
     assert "MZXW6YQ=" == encode32("foob")
   end
 
-  test "encode32 three pads" do
+  test "encode32/1 with three pads" do
     assert "MZXW6===" == encode32("foo")
   end
 
-  test "encode32 four pads" do
+  test "encode32/1 with four pads" do
     assert "MZXQ====" == encode32("fo")
   end
 
-  test "encode32 six pads" do
+  test "encode32/1 with six pads" do
     assert "MZXW6YTBOI======" == encode32("foobar")
     assert "MY======" == encode32("f")
   end
 
-  test "encode32 no pads" do
+  test "encode32/1 with no pads" do
     assert "MZXW6YTB" == encode32("fooba")
   end
 
-  test "encode32 lowercase" do
+  test "encode32/2 with one pad and ignoring padding" do
+    assert "MZXW6YQ" == encode32("foob", padding: false)
+  end
+
+  test "encode32/2 with three pads and ignoring padding" do
+    assert "MZXW6" == encode32("foo", padding: false)
+  end
+
+  test "encode32/2 with four pads and ignoring padding" do
+    assert "MZXQ" == encode32("fo", padding: false)
+  end
+
+  test "encode32/2 with six pads and ignoring padding" do
+    assert "MZXW6YTBOI" == encode32("foobar", padding: false)
+  end
+
+  test "encode32/2 with no pads and ignoring padding" do
+    assert "MZXW6YTB" == encode32("fooba", padding: false)
+  end
+
+  test "encode32/2 with lowercase" do
     assert "mzxw6ytb" == encode32("fooba", case: :lower)
   end
 
-  test "decode32 empty" do
+  test "decode32/1 can deal with empty strings" do
     assert {:ok, ""} == decode32("")
   end
 
-  test "decode32! empty" do
+  test "decode32!/2 can deal with empty strings" do
     assert "" == decode32!("")
   end
 
-  test "decode32 one pad" do
+  test "decode32/1 with one pad" do
     assert {:ok, "foob"} == decode32("MZXW6YQ=")
   end
 
-  test "decode32! one pad" do
+  test "decode32!/1 with one pad" do
     assert "foob" == decode32!("MZXW6YQ=")
   end
 
-  test "decode32 three pads" do
+  test "decode32/1 with three pads" do
     assert {:ok, "foo"} == decode32("MZXW6===")
   end
 
-  test "decode32! three pads" do
+  test "decode32!/1 with three pads" do
     assert "foo" == decode32!("MZXW6===")
   end
 
-  test "decode32 four pads" do
+  test "decode32/1 with four pads" do
     assert {:ok, "fo"} == decode32("MZXQ====")
   end
 
-  test "decode32! four pads" do
+  test "decode32!/1 with four pads" do
     assert "fo" == decode32!("MZXQ====")
   end
 
-  test "decode32 lowercase" do
+  test "decode32/2 with lowercase" do
     assert {:ok, "fo"} == decode32("mzxq====", case: :lower)
   end
 
-  test "decode32! lowercase" do
+  test "decode32!/2 with lowercase" do
     assert "fo" == decode32!("mzxq====", case: :lower)
   end
 
-  test "decode32 mixed case" do
+  test "decode32/2 with mixed case" do
     assert {:ok, "fo"} == decode32("mZXq====", case: :mixed)
   end
 
-  test "decode32! mixed case" do
+  test "decode32!/2 with mixed case" do
     assert "fo" == decode32!("mZXq====", case: :mixed)
   end
 
-  test "decode32 six pads" do
+  test "decode32/1 with six pads" do
     assert {:ok, "foobar"} == decode32("MZXW6YTBOI======")
     assert {:ok, "f"} == decode32("MY======")
   end
 
-  test "decode32! six pads" do
+  test "decode32!/1 with six pads" do
     assert "foobar" == decode32!("MZXW6YTBOI======")
     assert "f" == decode32!("MY======")
   end
 
-  test "decode32 no pads" do
+  test "decode32/1 with no pads" do
     assert {:ok, "fooba"} == decode32("MZXW6YTB")
   end
 
-  test "decode32! no pads" do
+  test "decode32!/1 with no pads" do
     assert "fooba" == decode32!("MZXW6YTB")
   end
 
-  test "decode32 non-alphabet digit" do
+  test "decode32/1,2 error on non-alphabet character" do
     assert :error == decode32("MZX)6YTB")
     assert :error == decode32("66ff")
     assert :error == decode32("66FF", case: :lower)
   end
 
-  test "decode32! non-alphabet digit" do
-    assert_raise ArgumentError, "non-alphabet digit found: )", fn ->
+  test "decode32!/1,2 argument error on non-alphabet character" do
+    assert_raise ArgumentError, "non-alphabet character found: \")\" (byte 41)", fn ->
       decode32!("MZX)6YTB")
     end
-    assert_raise ArgumentError, "non-alphabet digit found: m", fn ->
+
+    assert_raise ArgumentError, "non-alphabet character found: \"m\" (byte 109)", fn ->
       decode32!("mzxw6ytboi======")
     end
-    assert_raise ArgumentError, "non-alphabet digit found: M", fn ->
+
+    assert_raise ArgumentError, "non-alphabet character found: \"M\" (byte 77)", fn ->
       decode32!("MZXW6YTBOI======", case: :lower)
     end
+
+    assert_raise ArgumentError, "non-alphabet character found: \"0\" (byte 48)", fn ->
+      decode32!("0ZXW6YTB0I======", case: :mixed)
+    end
   end
 
-  test "decode32 incorrect padding" do
+  test "decode32/1 errors on incorrect padding" do
     assert :error == decode32("MZXW6YQ")
   end
 
-  test "decode32! incorrect padding" do
+  test "decode32!/1 errors on incorrect padding" do
     assert_raise ArgumentError, "incorrect padding", fn ->
       decode32!("MZXW6YQ")
     end
   end
 
-  test "hex_encode32 empty" do
+  test "decode32/2 with one pad and :padding to false" do
+    assert {:ok, "foob"} == decode32("MZXW6YQ", padding: false)
+  end
+
+  test "decode32!/2 with one pad and :padding to false" do
+    assert "foob" == decode32!("MZXW6YQ", padding: false)
+  end
+
+  test "decode32/2 with three pads and ignoring padding" do
+    assert {:ok, "foo"} == decode32("MZXW6", padding: false)
+  end
+
+  test "decode32!/2 with three pads and ignoring padding" do
+    assert "foo" == decode32!("MZXW6", padding: false)
+  end
+
+  test "decode32/2 with four pads and ignoring padding" do
+    assert {:ok, "fo"} == decode32("MZXQ", padding: false)
+  end
+
+  test "decode32!/2 with four pads and ignoring padding" do
+    assert "fo" == decode32!("MZXQ", padding: false)
+  end
+
+  test "decode32/2 with :lower case and ignoring padding" do
+    assert {:ok, "fo"} == decode32("mzxq", case: :lower, padding: false)
+  end
+
+  test "decode32!/2 with :lower case and ignoring padding" do
+    assert "fo" == decode32!("mzxq", case: :lower, padding: false)
+  end
+
+  test "decode32/2 with :mixed case and ignoring padding" do
+    assert {:ok, "fo"} == decode32("mZXq", case: :mixed, padding: false)
+  end
+
+  test "decode32!/2 with :mixed case and ignoring padding" do
+    assert "fo" == decode32!("mZXq", case: :mixed, padding: false)
+  end
+
+  test "decode32/2 with six pads and ignoring padding" do
+    assert {:ok, "foobar"} == decode32("MZXW6YTBOI", padding: false)
+  end
+
+  test "decode32!/2 with six pads and ignoring padding" do
+    assert "foobar" == decode32!("MZXW6YTBOI", padding: false)
+  end
+
+  test "decode32/2 with no pads and ignoring padding" do
+    assert {:ok, "fooba"} == decode32("MZXW6YTB", padding: false)
+  end
+
+  test "decode32!/2 with no pads and ignoring padding" do
+    assert "fooba" == decode32!("MZXW6YTB", padding: false)
+  end
+
+  test "decode32/2 ignores incorrect padding when :padding is false" do
+    assert {:ok, "foob"} == decode32("MZXW6YQ", padding: false)
+  end
+
+  test "decode32!/2 ignores incorrect padding when :padding is false" do
+    "foob" = decode32!("MZXW6YQ", padding: false)
+  end
+
+  test "valid32?/1 can deal with empty strings" do
+    assert valid32?("")
+  end
+
+  test "valid32?/1 with one pad" do
+    assert valid32?("MZXW6YQ=")
+  end
+
+  test "valid32?/1 with three pads" do
+    assert valid32?("MZXW6===")
+  end
+
+  test "valid32?/1 with four pads" do
+    assert valid32?("MZXQ====")
+  end
+
+  test "valid32?/1 with lowercase" do
+    assert valid32?("mzxq====", case: :lower)
+  end
+
+  test "valid32?/1 with mixed case" do
+    assert valid32?("mZXq====", case: :mixed)
+  end
+
+  test "valid32?/1 with six pads" do
+    assert valid32?("MZXW6YTBOI======")
+  end
+
+  test "valid32?/1 with no pads" do
+    assert valid32?("MZXW6YTB")
+  end
+
+  test "valid32?/1,2 returns false on non-alphabet character" do
+    refute valid32?("MZX)6YTB")
+    refute valid32?("66ff")
+    refute valid32?("66FF", case: :lower)
+    refute valid32?("0ZXW6YTB0I======", case: :mixed)
+  end
+
+  test "valid32?/1 returns false on incorrect padding" do
+    refute valid32?("MZXW6YQ")
+  end
+
+  test "valid32?/2 with one pad and :padding to false" do
+    assert valid32?("MZXW6YQ", padding: false)
+  end
+
+  test "valid32?/2 with three pads and ignoring padding" do
+    assert valid32?("MZXW6", padding: false)
+  end
+
+  test "valid32?/2 with four pads and ignoring padding" do
+    assert valid32?("MZXQ", padding: false)
+  end
+
+  test "valid32?/2 with :lower case and ignoring padding" do
+    assert valid32?("mzxq", case: :lower, padding: false)
+  end
+
+  test "valid32?/2 with :mixed case and ignoring padding" do
+    assert valid32?("mZXq", case: :mixed, padding: false)
+  end
+
+  test "valid32?/2 with six pads and ignoring padding" do
+    assert valid32?("MZXW6YTBOI", padding: false)
+  end
+
+  test "valid32?/2 with no pads and ignoring padding" do
+    assert valid32?("MZXW6YTB", padding: false)
+  end
+
+  test "valid32?/2 ignores incorrect padding when :padding is false" do
+    assert valid32?("MZXW6YQ", padding: false)
+  end
+
+  test "hex_encode32/1 can deal with empty strings" do
     assert "" == hex_encode32("")
   end
 
-  test "hex_encode32 one pad" do
+  test "hex_encode32/1 with one pad" do
     assert "CPNMUOG=" == hex_encode32("foob")
   end
 
-  test "hex_encode32 three pads" do
+  test "hex_encode32/1 with three pads" do
     assert "CPNMU===" == hex_encode32("foo")
   end
 
-  test "hex_encode32 four pads" do
+  test "hex_encode32/1 with four pads" do
     assert "CPNG====" == hex_encode32("fo")
   end
 
-  test "hex_encode32 six pads" do
+  test "hex_encode32/1 with six pads" do
     assert "CPNMUOJ1E8======" == hex_encode32("foobar")
     assert "CO======" == hex_encode32("f")
   end
 
-  test "hex_encode32 no pads" do
+  test "hex_encode32/1 with no pads" do
     assert "CPNMUOJ1" == hex_encode32("fooba")
   end
 
-  test "hex_encode32 lowercase" do
+  test "hex_encode32/2 with one pad and ignoring padding" do
+    assert "CPNMUOG" == hex_encode32("foob", padding: false)
+  end
+
+  test "hex_encode32/2 with three pads and ignoring padding" do
+    assert "CPNMU" == hex_encode32("foo", padding: false)
+  end
+
+  test "hex_encode32/2 with four pads and ignoring padding" do
+    assert "CPNG" == hex_encode32("fo", padding: false)
+  end
+
+  test "hex_encode32/2 with six pads and ignoring padding" do
+    assert "CPNMUOJ1E8" == hex_encode32("foobar", padding: false)
+  end
+
+  test "hex_encode32/2 with no pads and ignoring padding" do
+    assert "CPNMUOJ1" == hex_encode32("fooba", padding: false)
+  end
+
+  test "hex_encode32/2 with lowercase" do
     assert "cpnmuoj1" == hex_encode32("fooba", case: :lower)
   end
 
-  test "hex_decode32 empty" do
+  test "hex_decode32/1 can deal with empty strings" do
     assert {:ok, ""} == hex_decode32("")
   end
 
-  test "hex_decode32! empty" do
+  test "hex_decode32!/1 can deal with empty strings" do
     assert "" == hex_decode32!("")
   end
 
-  test "hex_decode32 one pad" do
+  test "hex_decode32/1 with one pad" do
     assert {:ok, "foob"} == hex_decode32("CPNMUOG=")
   end
 
-  test "hex_decode32! one pad" do
+  test "hex_decode32!/1 with one pad" do
     assert "foob" == hex_decode32!("CPNMUOG=")
   end
 
-  test "hex_decode32 three pads" do
+  test "hex_decode32/1 with three pads" do
     assert {:ok, "foo"} == hex_decode32("CPNMU===")
   end
 
-  test "hex_decode32! three pads" do
+  test "hex_decode32!/1 with three pads" do
     assert "foo" == hex_decode32!("CPNMU===")
   end
 
-  test "hex_decode32 four pads" do
+  test "hex_decode32/1 with four pads" do
     assert {:ok, "fo"} == hex_decode32("CPNG====")
   end
 
-  test "hex_decode32! four pads" do
+  test "hex_decode32!/1 with four pads" do
     assert "fo" == hex_decode32!("CPNG====")
   end
 
-  test "hex_decode32 six pads" do
+  test "hex_decode32/1 with six pads" do
     assert {:ok, "foobar"} == hex_decode32("CPNMUOJ1E8======")
     assert {:ok, "f"} == hex_decode32("CO======")
   end
 
-  test "hex_decode32! six pads" do
+  test "hex_decode32!/1 with six pads" do
     assert "foobar" == hex_decode32!("CPNMUOJ1E8======")
     assert "f" == hex_decode32!("CO======")
   end
 
-  test "hex_decode32 no pads" do
+  test "hex_decode32/1 with no pads" do
     assert {:ok, "fooba"} == hex_decode32("CPNMUOJ1")
   end
 
-  test "hex_decode32! no pads" do
+  test "hex_decode32!/1 with no pads" do
     assert "fooba" == hex_decode32!("CPNMUOJ1")
   end
 
-  test "hex_decode32 non-alphabet digit" do
+  test "hex_decode32/1,2 error on non-alphabet character" do
     assert :error == hex_decode32("CPN)UOJ1")
     assert :error == hex_decode32("66f")
     assert :error == hex_decode32("66F", case: :lower)
   end
 
-  test "hex_decode32! non-alphabet digit" do
-    assert_raise ArgumentError, "non-alphabet digit found: )", fn ->
+  test "hex_decode32!/1,2 error non-alphabet character" do
+    assert_raise ArgumentError, "non-alphabet character found: \")\" (byte 41)", fn ->
       hex_decode32!("CPN)UOJ1")
     end
-    assert_raise ArgumentError, "non-alphabet digit found: c", fn ->
+
+    assert_raise ArgumentError, "non-alphabet character found: \"c\" (byte 99)", fn ->
       hex_decode32!("cpnmuoj1e8======")
     end
-    assert_raise ArgumentError, "non-alphabet digit found: C", fn ->
+
+    assert_raise ArgumentError, "non-alphabet character found: \"C\" (byte 67)", fn ->
       hex_decode32!("CPNMUOJ1E8======", case: :lower)
     end
   end
 
-  test "hex_decode32 incorrect padding" do
+  test "hex_decode32/1 errors on incorrect padding" do
     assert :error == hex_decode32("CPNMUOG")
   end
 
-  test "hex_decode32! incorrect padding" do
+  test "hex_decode32!/1 errors on incorrect padding" do
     assert_raise ArgumentError, "incorrect padding", fn ->
       hex_decode32!("CPNMUOG")
     end
   end
 
-  test "hex_decode32 lowercase" do
+  test "hex_decode32/2 with lowercase" do
     assert {:ok, "fo"} == hex_decode32("cpng====", case: :lower)
   end
 
-  test "hex_decode32! lowercase" do
+  test "hex_decode32!/2 with lowercase" do
     assert "fo" == hex_decode32!("cpng====", case: :lower)
   end
 
-  test "hex_decode32 mixed case" do
+  test "hex_decode32/2 with mixed case" do
     assert {:ok, "fo"} == hex_decode32("cPNg====", case: :mixed)
   end
 
-  test "hex_decode32! mixed case" do
+  test "hex_decode32!/2 with mixed case" do
     assert "fo" == hex_decode32!("cPNg====", case: :mixed)
   end
+
+  test "decode16!/1 errors on non-UTF-8 char" do
+    assert_raise ArgumentError, "non-alphabet character found: \"\\0\" (byte 0)", fn ->
+      decode16!("012" <> <<0>>)
+    end
+  end
+
+  test "hex_decode32/2 with one pad and ignoring padding" do
+    assert {:ok, "foob"} == hex_decode32("CPNMUOG", padding: false)
+  end
+
+  test "hex_decode32!/2 with one pad and ignoring padding" do
+    assert "foob" == hex_decode32!("CPNMUOG", padding: false)
+  end
+
+  test "hex_decode32/2 with three pads and ignoring padding" do
+    assert {:ok, "foo"} == hex_decode32("CPNMU", padding: false)
+  end
+
+  test "hex_decode32!/2 with three pads and ignoring padding" do
+    assert "foo" == hex_decode32!("CPNMU", padding: false)
+  end
+
+  test "hex_decode32/2 with four pads and ignoring padding" do
+    assert {:ok, "fo"} == hex_decode32("CPNG", padding: false)
+  end
+
+  test "hex_decode32!/2 with four pads and ignoring padding" do
+    assert "fo" == hex_decode32!("CPNG", padding: false)
+  end
+
+  test "hex_decode32/2 with six pads and ignoring padding" do
+    assert {:ok, "foobar"} == hex_decode32("CPNMUOJ1E8", padding: false)
+  end
+
+  test "hex_decode32!/2 with six pads and ignoring padding" do
+    assert "foobar" == hex_decode32!("CPNMUOJ1E8", padding: false)
+  end
+
+  test "hex_decode32/2 with no pads and ignoring padding" do
+    assert {:ok, "fooba"} == hex_decode32("CPNMUOJ1", padding: false)
+  end
+
+  test "hex_decode32!/2 with no pads and ignoring padding" do
+    assert "fooba" == hex_decode32!("CPNMUOJ1", padding: false)
+  end
+
+  test "hex_decode32/2 ignores incorrect padding when :padding is false" do
+    assert {:ok, "foob"} == hex_decode32("CPNMUOG", padding: false)
+  end
+
+  test "hex_decode32!/2 ignores incorrect padding when :padding is false" do
+    "foob" = hex_decode32!("CPNMUOG", padding: false)
+  end
+
+  test "hex_decode32/2 with :lower case and ignoring padding" do
+    assert {:ok, "fo"} == hex_decode32("cpng", case: :lower, padding: false)
+  end
+
+  test "hex_decode32!/2 with :lower case and ignoring padding" do
+    assert "fo" == hex_decode32!("cpng", case: :lower, padding: false)
+  end
+
+  test "hex_decode32/2 with :mixed case and ignoring padding" do
+    assert {:ok, "fo"} == hex_decode32("cPNg====", case: :mixed, padding: false)
+  end
+
+  test "hex_decode32!/2 with :mixed case and ignoring padding" do
+    assert "fo" == hex_decode32!("cPNg", case: :mixed, padding: false)
+  end
+
+  test "hex_valid32?/1 can deal with empty strings" do
+    assert hex_valid32?("")
+  end
+
+  test "hex_valid32?/1 with one pad" do
+    assert hex_valid32?("CPNMUOG=")
+  end
+
+  test "hex_valid32?/1 with three pads" do
+    assert hex_valid32?("CPNMU===")
+  end
+
+  test "hex_valid32?/1 with four pads" do
+    assert hex_valid32?("CPNG====")
+  end
+
+  test "hex_valid32?/1 with six pads" do
+    assert hex_valid32?("CPNMUOJ1E8======")
+    assert hex_valid32?("CO======")
+  end
+
+  test "hex_valid32?/1 with no pads" do
+    assert hex_valid32?("CPNMUOJ1")
+  end
+
+  test "hex_valid32?/1,2 returns false on non-alphabet character" do
+    refute hex_valid32?("CPN)UOJ1")
+    refute hex_valid32?("66f")
+    refute hex_valid32?("66F", case: :lower)
+  end
+
+  test "hex_valid32?/1 returns false on incorrect padding" do
+    refute hex_valid32?("CPNMUOG")
+  end
+
+  test "hex_valid32?/2 with lowercase" do
+    assert hex_valid32?("cpng====", case: :lower)
+  end
+
+  test "hex_valid32?/2 with mixed case" do
+    assert hex_valid32?("cPNg====", case: :mixed)
+  end
+
+  test "hex_valid32?/2 with one pad and ignoring padding" do
+    assert hex_valid32?("CPNMUOG", padding: false)
+  end
+
+  test "hex_valid32?/2 with three pads and ignoring padding" do
+    assert hex_valid32?("CPNMU", padding: false)
+  end
+
+  test "hex_valid32?/2 with four pads and ignoring padding" do
+    assert hex_valid32?("CPNG", padding: false)
+  end
+
+  test "hex_valid32?/2 with six pads and ignoring padding" do
+    assert hex_valid32?("CPNMUOJ1E8", padding: false)
+  end
+
+  test "hex_valid32?/2 with no pads and ignoring padding" do
+    assert hex_valid32?("CPNMUOJ1", padding: false)
+  end
+
+  test "hex_valid32?/2 ignores incorrect padding when :padding is false" do
+    assert hex_valid32?("CPNMUOG", padding: false)
+  end
+
+  test "hex_valid32?/2 with :lower case and ignoring padding" do
+    assert hex_valid32?("cpng", case: :lower, padding: false)
+  end
+
+  test "hex_valid32?/2 with :mixed case and ignoring padding" do
+    assert hex_valid32?("cPNg====", case: :mixed, padding: false)
+  end
+
+  # TODO: add valid? tests
+  test "encode then decode is identity" do
+    for {encode, decode, valid?} <- [
+          {&encode16/2, &decode16!/2, &valid16?/2},
+          {&encode32/2, &decode32!/2, &valid32?/2},
+          {&hex_encode32/2, &hex_decode32!/2, &hex_valid32?/2},
+          {&encode64/2, &decode64!/2, &valid64?/2},
+          {&url_encode64/2, &url_decode64!/2, &url_valid64?/2}
+        ],
+        encode_case <- [:upper, :lower],
+        decode_case <- [:upper, :lower, :mixed],
+        encode_case == decode_case or decode_case == :mixed,
+        pad? <- [true, false],
+        len <- 0..256 do
+      data =
+        0
+        |> :lists.seq(len - 1)
+        |> Enum.shuffle()
+        |> IO.iodata_to_binary()
+
+      allowed_opts =
+        encode
+        |> Function.info()
+        |> Keyword.fetch!(:name)
+        |> case do
+          :encode16 -> [:case]
+          :encode64 -> [:padding]
+          :url_encode64 -> [:padding]
+          _ -> [:case, :padding]
+        end
+
+      encoded = encode.(data, Keyword.take([case: encode_case, padding: pad?], allowed_opts))
+
+      decode_opts = Keyword.take([case: decode_case, padding: pad?], allowed_opts)
+      assert valid?.(encoded, decode_opts)
+      expected = decode.(encoded, decode_opts)
+
+      assert data == expected,
+             "identity did not match for #{inspect(data)} when #{inspect(encode)} (#{encode_case})"
+    end
+  end
 end
diff --git a/lib/elixir/test/elixir/behaviour_test.exs b/lib/elixir/test/elixir/behaviour_test.exs
deleted file mode 100644
index 3ff575302d5..00000000000
--- a/lib/elixir/test/elixir/behaviour_test.exs
+++ /dev/null
@@ -1,64 +0,0 @@
-Code.require_file "test_helper.exs", __DIR__
-
-defmodule BehaviourTest do
-  use ExUnit.Case, async: true
-
-  defmodule Sample do
-    use Behaviour
-
-    @doc "I should be first."
-    defcallback first(integer) :: integer
-
-    @doc "Foo"
-    defcallback foo(atom(), binary) :: binary
-
-    @doc "Bar"
-    defcallback bar(External.hello, my_var :: binary) :: binary
-
-    defcallback guarded(my_var) :: my_var when my_var: binary
-
-    defcallback orr(atom | integer) :: atom
-
-    defcallback literal(123, {atom}, :atom, [integer], true) :: atom
-
-    @doc "I should be last."
-    defmacrocallback last(integer) :: Macro.t
-  end
-
-  test :docs do
-    docs = Sample.__behaviour__(:docs)
-    assert [
-      {{:first, 1}, 10, :def, "I should be first."},
-      {{:foo, 2}, 13, :def, "Foo"},
-      {{:bar, 2}, 16, :def, "Bar"},
-      {{:guarded, 1}, 18, :def, nil},
-      {{:orr, 1}, 20, :def, nil},
-      {{:literal, 5}, 22, :def, nil},
-      {{:last, 1}, 25, :defmacro, "I should be last."}
-    ] = docs
-  end
-
-  test :callbacks do
-    assert Sample.__behaviour__(:callbacks) == [first: 1, guarded: 1, "MACRO-last": 2, literal: 5, orr: 1, foo: 2, bar: 2]
-  end
-
-  test :specs do
-    assert length(Keyword.get_values(Sample.module_info[:attributes], :callback)) == 7
-  end
-
-  test :default_is_not_supported do
-    assert_raise ArgumentError, fn ->
-      defmodule WithDefault do
-        use Behaviour
-        defcallback hello(num \\ 0 :: integer) :: integer
-      end
-    end
-
-    assert_raise ArgumentError, fn ->
-      defmodule WithDefault do
-        use Behaviour
-        defcallback hello(num :: integer \\ 0) :: integer
-      end
-    end
-  end
-end
diff --git a/lib/elixir/test/elixir/bitwise_test.exs b/lib/elixir/test/elixir/bitwise_test.exs
index 17872979d26..41e13d9d06f 100644
--- a/lib/elixir/test/elixir/bitwise_test.exs
+++ b/lib/elixir/test/elixir/bitwise_test.exs
@@ -1,59 +1,52 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-defmodule Bitwise.FunctionsTest do
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule BitwiseTest do
   use ExUnit.Case, async: true
-  use Bitwise, skip_operators: true
 
-  test :bnot do
+  import Bitwise
+  doctest Bitwise
+
+  test "bnot/1" do
     assert bnot(1) == -2
   end
 
-  test :band do
+  test "band/2" do
     assert band(1, 1) == 1
   end
 
-  test :bor do
+  test "bor/2" do
     assert bor(0, 1) == 1
   end
 
-  test :bxor do
+  test "bxor/2" do
     assert bxor(1, 1) == 0
   end
 
-  test :bsl do
+  test "bsl/2" do
     assert bsl(1, 1) == 2
   end
 
-  test :bsr do
+  test "bsr/2" do
     assert bsr(1, 1) == 0
   end
-end
-
-defmodule Bitwise.OperatorsTest do
-  use ExUnit.Case, async: true
-  use Bitwise, only_operators: true
 
-  test :bnot do
-    assert ~~~1 == -2
-  end
-
-  test :band do
+  test "band (&&&)" do
     assert (1 &&& 1) == 1
   end
 
-  test :bor do
+  test "bor (|||)" do
     assert (0 ||| 1) == 1
   end
 
-  test :bxor do
-    assert 1 ^^^ 1 == 0
-  end
-
-  test :bsl do
-    assert (1 <<< 1) == 2
+  test "bsl (<<<)" do
+    assert 1 <<< 1 == 2
   end
 
-  test :bsr do
-    assert (1 >>> 1) == 0
+  test "bsr (>>>)" do
+    assert 1 >>> 1 == 0
   end
 end
diff --git a/lib/elixir/test/elixir/calendar/date_range_test.exs b/lib/elixir/test/elixir/calendar/date_range_test.exs
new file mode 100644
index 00000000000..fe6cab37e59
--- /dev/null
+++ b/lib/elixir/test/elixir/calendar/date_range_test.exs
@@ -0,0 +1,200 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file("holocene.exs", __DIR__)
+
+defmodule Date.RangeTest do
+  use ExUnit.Case, async: true
+
+  @asc_range Date.range(~D[2000-01-01], ~D[2001-01-01])
+  @asc_range_2 Date.range(~D[2000-01-01], ~D[2001-01-01], 2)
+  @desc_range Date.range(~D[2001-01-01], ~D[2000-01-01], -1)
+  @desc_range_2 Date.range(~D[2001-01-01], ~D[2000-01-01], -2)
+  @empty_range Date.range(~D[2001-01-01], ~D[2000-01-01], 1)
+
+  describe "Enum.member?/2" do
+    test "for ascending range" do
+      assert Enum.member?(@asc_range, ~D[2000-02-22])
+      assert Enum.member?(@asc_range, ~D[2000-01-01])
+      assert Enum.member?(@asc_range, ~D[2001-01-01])
+      refute Enum.member?(@asc_range, ~D[2002-01-01])
+      refute Enum.member?(@asc_range, Calendar.Holocene.date(12000, 1, 1))
+
+      assert Enum.member?(@asc_range_2, ~D[2000-01-03])
+      refute Enum.member?(@asc_range_2, ~D[2000-01-02])
+    end
+
+    test "for descending range" do
+      assert Enum.member?(@desc_range, ~D[2000-02-22])
+      assert Enum.member?(@desc_range, ~D[2000-01-01])
+      assert Enum.member?(@desc_range, ~D[2001-01-01])
+      refute Enum.member?(@desc_range, ~D[1999-01-01])
+      refute Enum.member?(@desc_range, Calendar.Holocene.date(12000, 1, 1))
+
+      assert Enum.member?(@desc_range_2, ~D[2000-12-30])
+      refute Enum.member?(@desc_range_2, ~D[2000-12-29])
+    end
+
+    test "empty range" do
+      refute Enum.member?(@empty_range, @empty_range.first)
+    end
+  end
+
+  describe "Enum.count/1" do
+    test "for ascending range" do
+      assert Enum.count(@asc_range) == 367
+      assert Enum.count(@asc_range_2) == 184
+    end
+
+    test "for descending range" do
+      assert Enum.count(@desc_range) == 367
+      assert Enum.count(@desc_range_2) == 184
+    end
+
+    test "for empty range" do
+      assert Enum.count(@empty_range) == 0
+    end
+  end
+
+  describe "Enum.slice/3" do
+    test "for ascending range" do
+      assert Enum.slice(@asc_range, 3, 3) == [~D[2000-01-04], ~D[2000-01-05], ~D[2000-01-06]]
+      assert Enum.slice(@asc_range, -3, 3) == [~D[2000-12-30], ~D[2000-12-31], ~D[2001-01-01]]
+
+      assert Enum.slice(@asc_range_2, 3, 3) == [~D[2000-01-07], ~D[2000-01-09], ~D[2000-01-11]]
+      assert Enum.slice(@asc_range_2, -3, 3) == [~D[2000-12-28], ~D[2000-12-30], ~D[2001-01-01]]
+    end
+
+    test "for descending range" do
+      assert Enum.slice(@desc_range, 3, 3) == [~D[2000-12-29], ~D[2000-12-28], ~D[2000-12-27]]
+      assert Enum.slice(@desc_range, -3, 3) == [~D[2000-01-03], ~D[2000-01-02], ~D[2000-01-01]]
+
+      assert Enum.slice(@desc_range_2, 3, 3) == [~D[2000-12-26], ~D[2000-12-24], ~D[2000-12-22]]
+      assert Enum.slice(@desc_range_2, -3, 3) == [~D[2000-01-05], ~D[2000-01-03], ~D[2000-01-01]]
+    end
+
+    test "for empty range" do
+      assert Enum.slice(@empty_range, 1, 3) == []
+      assert Enum.slice(@empty_range, 3, 3) == []
+      assert Enum.slice(@empty_range, -1, 3) == []
+      assert Enum.slice(@empty_range, -3, 3) == []
+    end
+  end
+
+  describe "Enum.reduce/3" do
+    test "for ascending range" do
+      assert Enum.take(@asc_range, 3) == [~D[2000-01-01], ~D[2000-01-02], ~D[2000-01-03]]
+
+      assert Enum.take(@asc_range_2, 3) == [~D[2000-01-01], ~D[2000-01-03], ~D[2000-01-05]]
+    end
+
+    test "for descending range" do
+      assert Enum.take(@desc_range, 3) == [~D[2001-01-01], ~D[2000-12-31], ~D[2000-12-30]]
+
+      assert Enum.take(@desc_range_2, 3) == [~D[2001-01-01], ~D[2000-12-30], ~D[2000-12-28]]
+    end
+
+    test "for empty range" do
+      assert Enum.take(@empty_range, 3) == []
+    end
+  end
+
+  test "Enum.take/1 for empty range with negative step" do
+    assert Enum.take(@empty_range, -1) == []
+  end
+
+  test "works with date-like structs" do
+    range = Date.range(~N[2000-01-01 09:00:00], ~U[2000-01-02 09:00:00Z])
+    assert range.first == ~D[2000-01-01]
+    assert range.last == ~D[2000-01-02]
+    assert Enum.to_list(range) == [~D[2000-01-01], ~D[2000-01-02]]
+
+    range = Date.range(~N[2000-01-01 09:00:00], ~U[2000-01-03 09:00:00Z], 2)
+    assert range.first == ~D[2000-01-01]
+    assert range.last == ~D[2000-01-03]
+    assert Enum.to_list(range) == [~D[2000-01-01], ~D[2000-01-03]]
+  end
+
+  test "both dates must have matching calendars" do
+    first = ~D[2000-01-01]
+    last = Calendar.Holocene.date(12001, 1, 1)
+
+    assert_raise ArgumentError, "both dates must have matching calendars", fn ->
+      Date.range(first, last)
+    end
+  end
+
+  test "accepts equal but non Calendar.ISO calendars" do
+    first = Calendar.Holocene.date(12000, 1, 1)
+    last = Calendar.Holocene.date(12001, 1, 1)
+    range = Date.range(first, last)
+    assert range
+    assert first in range
+    assert last in range
+    assert Enum.count(range) == 367
+  end
+
+  test "step is a non-zero integer" do
+    step = 1.0
+    message = ~r"the step must be a non-zero integer"
+
+    assert_raise ArgumentError, message, fn ->
+      Date.range(~D[2000-01-01], ~D[2000-01-31], step)
+    end
+
+    step = 0
+    message = ~r"the step must be a non-zero integer"
+
+    assert_raise ArgumentError, message, fn ->
+      Date.range(~D[2000-01-01], ~D[2000-01-31], step)
+    end
+  end
+
+  describe "old date ranges" do
+    test "enumerable" do
+      asc = %{
+        __struct__: Date.Range,
+        first: ~D[2021-07-14],
+        first_in_iso_days: 738_350,
+        last: ~D[2021-07-17],
+        last_in_iso_days: 738_353
+      }
+
+      desc = %{
+        __struct__: Date.Range,
+        first: ~D[2021-07-17],
+        first_in_iso_days: 738_353,
+        last: ~D[2021-07-14],
+        last_in_iso_days: 738_350
+      }
+
+      # member? implementations tests also empty?
+      assert Enumerable.member?(asc, ~D[2021-07-15])
+      assert {:ok, 4, _} = Enumerable.slice(asc)
+
+      assert Enum.reduce(asc, [], fn x, acc -> [x | acc] end) == [
+               ~D[2021-07-17],
+               ~D[2021-07-16],
+               ~D[2021-07-15],
+               ~D[2021-07-14]
+             ]
+
+      assert Enum.count(asc) == 4
+
+      # member? implementations tests also empty?
+      assert Enumerable.member?(desc, ~D[2021-07-15])
+      assert {:ok, 4, _} = Enumerable.slice(desc)
+
+      assert Enum.reduce(desc, [], fn x, acc -> [x | acc] end) == [
+               ~D[2021-07-14],
+               ~D[2021-07-15],
+               ~D[2021-07-16],
+               ~D[2021-07-17]
+             ]
+
+      assert Enum.count(desc) == 4
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/calendar/date_test.exs b/lib/elixir/test/elixir/calendar/date_test.exs
new file mode 100644
index 00000000000..c7d33533335
--- /dev/null
+++ b/lib/elixir/test/elixir/calendar/date_test.exs
@@ -0,0 +1,299 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file("holocene.exs", __DIR__)
+Code.require_file("fakes.exs", __DIR__)
+
+defmodule DateTest do
+  use ExUnit.Case, async: true
+  doctest Date
+
+  test "sigil_D" do
+    assert ~D[2000-01-01] ==
+             %Date{calendar: Calendar.ISO, year: 2000, month: 1, day: 1}
+
+    assert ~D[20001-01-01 Calendar.Holocene] ==
+             %Date{calendar: Calendar.Holocene, year: 20001, month: 1, day: 1}
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2000-50-50" as Date for Calendar.ISO, reason: :invalid_date/,
+                 fn -> Code.eval_string("~D[2000-50-50]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2000-04-15 notalias" as Date for Calendar.ISO, reason: :invalid_format/,
+                 fn -> Code.eval_string("~D[2000-04-15 notalias]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "20010415" as Date for Calendar.ISO, reason: :invalid_format/,
+                 fn -> Code.eval_string(~s{~D[20010415]}) end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "20001-50-50" as Date for Calendar.Holocene, reason: :invalid_date/,
+                 fn -> Code.eval_string("~D[20001-50-50 Calendar.Holocene]") end
+
+    assert_raise UndefinedFunctionError, fn ->
+      Code.eval_string("~D[2000-01-01 UnknownCalendar]")
+    end
+  end
+
+  test "to_string/1" do
+    date = ~D[2000-01-01]
+    assert to_string(date) == "2000-01-01"
+    assert Date.to_string(date) == "2000-01-01"
+    assert Date.to_string(Map.from_struct(date)) == "2000-01-01"
+
+    assert to_string(%{date | calendar: FakeCalendar}) == "1/1/2000"
+    assert Date.to_string(%{date | calendar: FakeCalendar}) == "1/1/2000"
+
+    date2 = Date.new!(5_874_897, 12, 31)
+    assert to_string(date2) == "5874897-12-31"
+    assert Date.to_string(date2) == "5874897-12-31"
+    assert Date.to_string(Map.from_struct(date2)) == "5874897-12-31"
+
+    assert to_string(%{date2 | calendar: FakeCalendar}) == "31/12/5874897"
+    assert Date.to_string(%{date2 | calendar: FakeCalendar}) == "31/12/5874897"
+  end
+
+  test "inspect/1" do
+    assert inspect(~D[2000-01-01]) == "~D[2000-01-01]"
+    assert inspect(~D[-0100-12-31]) == "~D[-0100-12-31]"
+
+    date = %{~D[2000-01-01] | calendar: FakeCalendar}
+    assert inspect(date) == "~D[1/1/2000 FakeCalendar]"
+
+    assert inspect(Date.new!(99999, 12, 31)) == "Date.new!(99999, 12, 31)"
+    assert inspect(Date.new!(-99999, 1, 1)) == "Date.new!(-99999, 1, 1)"
+
+    date2 = %{Date.new!(99999, 12, 31) | calendar: FakeCalendar}
+
+    assert inspect(%{date2 | calendar: FakeCalendar}) ==
+             "~D[31/12/99999 FakeCalendar]"
+  end
+
+  test "compare/2" do
+    date1 = ~D[-0001-12-30]
+    date2 = ~D[-0001-12-31]
+    date3 = ~D[0001-01-01]
+    date4 = Date.new!(5_874_897, 12, 31)
+    date5 = Date.new!(-4713, 1, 1)
+
+    assert Date.compare(date1, date1) == :eq
+    assert Date.compare(date1, date2) == :lt
+    assert Date.compare(date2, date1) == :gt
+    assert Date.compare(date3, date3) == :eq
+    assert Date.compare(date2, date3) == :lt
+    assert Date.compare(date3, date2) == :gt
+    assert Date.compare(date4, date1) == :gt
+    assert Date.compare(date1, date4) == :lt
+    assert Date.compare(date4, date4) == :eq
+    assert Date.compare(date4, date5) == :gt
+    assert Date.compare(date5, date4) == :lt
+    assert Date.compare(date5, date5) == :eq
+
+    assert_raise ArgumentError,
+                 ~r/cannot compare .*\n\n.* their calendars have incompatible day rollover moments/,
+                 fn -> Date.compare(date1, %{date2 | calendar: FakeCalendar}) end
+  end
+
+  test "before?/2 and after?/2" do
+    date1 = ~D[2022-11-01]
+    date2 = ~D[2022-11-02]
+    date3 = Date.new!(5_874_897, 12, 31)
+    date4 = Date.new!(-4713, 1, 1)
+
+    assert Date.before?(date1, date2)
+    assert Date.before?(date1, date3)
+    assert Date.before?(date4, date1)
+    assert not Date.before?(date2, date1)
+    assert not Date.before?(date3, date1)
+    assert not Date.before?(date1, date4)
+
+    assert Date.after?(date2, date1)
+    assert Date.after?(date3, date2)
+    assert Date.after?(date2, date4)
+    assert not Date.after?(date1, date2)
+    assert not Date.after?(date2, date3)
+    assert not Date.after?(date4, date2)
+  end
+
+  test "compare/2 across calendars" do
+    date1 = ~D[2000-01-01]
+    date2 = Calendar.Holocene.date(12000, 01, 01)
+    assert Date.compare(date1, date2) == :eq
+
+    date2 = Calendar.Holocene.date(12001, 01, 01)
+    assert Date.compare(date1, date2) == :lt
+    assert Date.compare(date2, date1) == :gt
+  end
+
+  test "day_of_week/1" do
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 10, 31)) == 1
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 01)) == 2
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 02)) == 3
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 03)) == 4
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 04)) == 5
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 05)) == 6
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 06)) == 7
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 07)) == 1
+
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 10, 30), :sunday) == 1
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 10, 31), :sunday) == 2
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 01), :sunday) == 3
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 02), :sunday) == 4
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 03), :sunday) == 5
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 04), :sunday) == 6
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 05), :sunday) == 7
+    assert Date.day_of_week(Calendar.Holocene.date(2016, 11, 06), :sunday) == 1
+  end
+
+  test "beginning_of_week" do
+    assert Date.beginning_of_week(Calendar.Holocene.date(2020, 07, 11)) ==
+             Calendar.Holocene.date(2020, 07, 06)
+
+    assert Date.beginning_of_week(Calendar.Holocene.date(2020, 07, 06)) ==
+             Calendar.Holocene.date(2020, 07, 06)
+
+    assert Date.beginning_of_week(Calendar.Holocene.date(2020, 07, 11), :sunday) ==
+             Calendar.Holocene.date(2020, 07, 05)
+
+    assert Date.beginning_of_week(Calendar.Holocene.date(2020, 07, 11), :saturday) ==
+             Calendar.Holocene.date(2020, 07, 11)
+  end
+
+  test "end_of_week" do
+    assert Date.end_of_week(Calendar.Holocene.date(2020, 07, 11)) ==
+             Calendar.Holocene.date(2020, 07, 12)
+
+    assert Date.end_of_week(Calendar.Holocene.date(2020, 07, 05)) ==
+             Calendar.Holocene.date(2020, 07, 05)
+
+    assert Date.end_of_week(Calendar.Holocene.date(2020, 07, 05), :sunday) ==
+             Calendar.Holocene.date(2020, 07, 11)
+
+    assert Date.end_of_week(Calendar.Holocene.date(2020, 07, 05), :saturday) ==
+             Calendar.Holocene.date(2020, 07, 10)
+  end
+
+  test "convert/2" do
+    assert Date.convert(~D[2000-01-01], Calendar.Holocene) ==
+             {:ok, Calendar.Holocene.date(12000, 01, 01)}
+
+    assert ~D[2000-01-01]
+           |> Date.convert!(Calendar.Holocene)
+           |> Date.convert!(Calendar.ISO) == ~D[2000-01-01]
+
+    assert Date.convert(~N[2000-01-01 00:00:00], Calendar.Holocene) ==
+             {:ok, Calendar.Holocene.date(12000, 01, 01)}
+
+    assert Date.convert(~D[2016-02-03], FakeCalendar) == {:error, :incompatible_calendars}
+
+    assert_raise ArgumentError,
+                 "cannot convert ~D[2016-02-03] to target calendar FakeCalendar, reason: :incompatible_calendars",
+                 fn -> Date.convert!(~D[2016-02-03], FakeCalendar) end
+  end
+
+  test "add/2" do
+    assert Date.add(~D[0000-01-01], 3_652_424) == ~D[9999-12-31]
+    assert Date.add(~D[0000-01-01], 3_652_425) == Date.new!(10000, 1, 1)
+    assert Date.add(~D[0000-01-01], -1) == ~D[-0001-12-31]
+    assert Date.add(~D[0000-01-01], -365) == ~D[-0001-01-01]
+    assert Date.add(~D[0000-01-01], -366) == ~D[-0002-12-31]
+    assert Date.add(~D[0000-01-01], -(365 * 4)) == ~D[-0004-01-02]
+    assert Date.add(~D[0000-01-01], -(365 * 5)) == ~D[-0005-01-02]
+    assert Date.add(~D[0000-01-01], -(365 * 100)) == ~D[-0100-01-25]
+    assert Date.add(~D[0000-01-01], -3_652_059) == ~D[-9999-01-01]
+    assert Date.add(~D[0000-01-01], -3_652_060) == Date.new!(-10000, 12, 31)
+    assert Date.add(Date.new!(5_874_897, 12, 31), 1) == Date.new!(5_874_898, 1, 1)
+  end
+
+  test "diff/2" do
+    assert Date.diff(~D[2000-01-31], ~D[2000-01-01]) == 30
+    assert Date.diff(~D[2000-01-01], ~D[2000-01-31]) == -30
+
+    assert Date.diff(~D[0000-01-01], ~D[-0001-01-01]) == 365
+    assert Date.diff(~D[-0003-01-01], ~D[-0004-01-01]) == 366
+
+    assert Date.diff(Date.new!(5_874_898, 1, 1), Date.new!(5_874_897, 1, 1)) == 365
+    assert Date.diff(Date.new!(5_874_905, 1, 1), Date.new!(5_874_904, 1, 1)) == 366
+
+    date1 = ~D[2000-01-01]
+    date2 = Calendar.Holocene.date(12000, 01, 14)
+    assert Date.diff(date1, date2) == -13
+    assert Date.diff(date2, date1) == 13
+
+    assert_raise ArgumentError,
+                 ~r/cannot calculate the difference between .* because their calendars are not compatible/,
+                 fn -> Date.diff(date1, %{date2 | calendar: FakeCalendar}) end
+  end
+
+  test "shift/2" do
+    assert Date.shift(~D[2012-02-29], day: -1) == ~D[2012-02-28]
+    assert Date.shift(~D[2012-02-29], month: -1) == ~D[2012-01-29]
+    assert Date.shift(~D[2012-02-29], week: -9) == ~D[2011-12-28]
+    assert Date.shift(~D[2012-02-29], month: 1) == ~D[2012-03-29]
+    assert Date.shift(~D[2012-02-29], year: -1) == ~D[2011-02-28]
+    assert Date.shift(~D[2012-02-29], year: 4) == ~D[2016-02-29]
+    assert Date.shift(~D[0000-01-01], day: -1) == ~D[-0001-12-31]
+    assert Date.shift(~D[0000-01-01], month: -1) == ~D[-0001-12-01]
+    assert Date.shift(~D[0000-01-01], year: -1) == ~D[-0001-01-01]
+    assert Date.shift(~D[0000-01-01], year: -1) == ~D[-0001-01-01]
+    assert Date.shift(~D[2000-01-01], month: 12) == ~D[2001-01-01]
+    assert Date.shift(~D[0000-01-01], day: 2, year: 1, month: 37) == ~D[0004-02-03]
+
+    assert Date.shift(Date.new!(5_874_904, 2, 29), day: -1) == Date.new!(5_874_904, 2, 28)
+    assert Date.shift(Date.new!(5_874_904, 2, 29), month: -2) == Date.new!(5_874_903, 12, 29)
+    assert Date.shift(Date.new!(5_874_904, 2, 29), week: -9) == Date.new!(5_874_903, 12, 28)
+    assert Date.shift(Date.new!(5_874_904, 2, 29), month: 1) == Date.new!(5_874_904, 3, 29)
+    assert Date.shift(Date.new!(5_874_904, 2, 29), year: -1) == Date.new!(5_874_903, 2, 28)
+    assert Date.shift(Date.new!(5_874_904, 2, 29), year: -4) == Date.new!(5_874_900, 2, 28)
+    assert Date.shift(Date.new!(5_874_904, 2, 29), year: 4) == Date.new!(5_874_908, 2, 29)
+
+    assert Date.shift(Date.new!(5_874_904, 2, 29), day: 1, year: 4, month: 2) ==
+             Date.new!(5_874_908, 4, 30)
+
+    assert_raise ArgumentError,
+                 "unsupported unit :second. Expected :year, :month, :week, :day",
+                 fn -> Date.shift(~D[2012-02-29], second: 86400) end
+
+    assert_raise ArgumentError,
+                 "unknown unit :months. Expected :year, :month, :week, :day",
+                 fn -> Date.shift(~D[2012-01-01], months: 12) end
+
+    assert_raise ArgumentError,
+                 "unsupported value nil for :day. Expected an integer",
+                 fn -> Date.shift(~D[2012-02-29], year: 1, day: nil) end
+
+    assert_raise ArgumentError,
+                 "cannot shift date by time scale unit. Expected :year, :month, :week, :day",
+                 fn -> Date.shift(~D[2012-02-29], %Duration{second: 86400}) end
+
+    # Microsecond precision is ignored
+    assert Date.shift(~D[2012-02-29], Duration.new!(microsecond: {0, 6})) == ~D[2012-02-29]
+
+    assert_raise ArgumentError,
+                 "cannot shift date by time scale unit. Expected :year, :month, :week, :day",
+                 fn -> Date.shift(~D[2012-02-29], %Duration{microsecond: {100, 6}}) end
+
+    # Implements calendar callback
+    assert_raise RuntimeError, "shift_date/4 not implemented", fn ->
+      date = Calendar.Holocene.date(10000, 01, 01)
+      Date.shift(date, month: 1)
+    end
+  end
+
+  test "utc_today/1" do
+    date = Date.utc_today()
+    assert date.year > 2020
+    assert date.calendar == Calendar.ISO
+
+    date = Date.utc_today(Calendar.ISO)
+    assert date.year > 2020
+    assert date.calendar == Calendar.ISO
+
+    date = Date.utc_today(Calendar.Holocene)
+    assert date.year > 12020
+    assert date.calendar == Calendar.Holocene
+  end
+end
diff --git a/lib/elixir/test/elixir/calendar/datetime_test.exs b/lib/elixir/test/elixir/calendar/datetime_test.exs
new file mode 100644
index 00000000000..712e34633ee
--- /dev/null
+++ b/lib/elixir/test/elixir/calendar/datetime_test.exs
@@ -0,0 +1,1181 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file("holocene.exs", __DIR__)
+Code.require_file("fakes.exs", __DIR__)
+
+defmodule DateTimeTest do
+  use ExUnit.Case
+  doctest DateTime
+
+  test "sigil_U" do
+    assert ~U[2000-01-01T12:34:56Z] ==
+             %DateTime{
+               calendar: Calendar.ISO,
+               year: 2000,
+               month: 1,
+               day: 1,
+               hour: 12,
+               minute: 34,
+               second: 56,
+               std_offset: 0,
+               utc_offset: 0,
+               time_zone: "Etc/UTC",
+               zone_abbr: "UTC"
+             }
+
+    assert ~U[2000-01-01T12:34:56+00:00 Calendar.Holocene] ==
+             %DateTime{
+               calendar: Calendar.Holocene,
+               year: 2000,
+               month: 1,
+               day: 1,
+               hour: 12,
+               minute: 34,
+               second: 56,
+               std_offset: 0,
+               utc_offset: 0,
+               time_zone: "Etc/UTC",
+               zone_abbr: "UTC"
+             }
+
+    assert ~U[2000-01-01 12:34:56+00:00] ==
+             %DateTime{
+               calendar: Calendar.ISO,
+               year: 2000,
+               month: 1,
+               day: 1,
+               hour: 12,
+               minute: 34,
+               second: 56,
+               std_offset: 0,
+               utc_offset: 0,
+               time_zone: "Etc/UTC",
+               zone_abbr: "UTC"
+             }
+
+    assert ~U[2000-01-01 12:34:56Z Calendar.Holocene] ==
+             %DateTime{
+               calendar: Calendar.Holocene,
+               year: 2000,
+               month: 1,
+               day: 1,
+               hour: 12,
+               minute: 34,
+               second: 56,
+               std_offset: 0,
+               utc_offset: 0,
+               time_zone: "Etc/UTC",
+               zone_abbr: "UTC"
+             }
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-50-50T12:34:56Z" as UTC DateTime for Calendar.ISO, reason: :invalid_date/,
+                 fn -> Code.eval_string("~U[2001-50-50T12:34:56Z]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-01-01T12:34:65Z" as UTC DateTime for Calendar.ISO, reason: :invalid_time/,
+                 fn -> Code.eval_string("~U[2001-01-01T12:34:65Z]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-01-01T12:34:56\+01:00" as UTC DateTime for Calendar.ISO, reason: :non_utc_offset/,
+                 fn -> Code.eval_string("~U[2001-01-01T12:34:56+01:00]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-01-01 12:34:56Z notalias" as UTC DateTime for Calendar.ISO, reason: :invalid_format/,
+                 fn -> Code.eval_string("~U[2001-01-01 12:34:56Z notalias]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-01-01T12:34:56Z notalias" as UTC DateTime for Calendar.ISO, reason: :invalid_format/,
+                 fn -> Code.eval_string("~U[2001-01-01T12:34:56Z notalias]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-50-50T12:34:56Z" as UTC DateTime for Calendar.Holocene, reason: :invalid_date/,
+                 fn -> Code.eval_string("~U[2001-50-50T12:34:56Z Calendar.Holocene]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-01-01T12:34:65Z" as UTC DateTime for Calendar.Holocene, reason: :invalid_time/,
+                 fn -> Code.eval_string("~U[2001-01-01T12:34:65Z Calendar.Holocene]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-01-01T12:34:56+01:00 Calendar.Holocene" as UTC DateTime for Calendar.Holocene, reason: :non_utc_offset/,
+                 fn -> Code.eval_string("~U[2001-01-01T12:34:56+01:00 Calendar.Holocene]") end
+
+    assert_raise UndefinedFunctionError, fn ->
+      Code.eval_string("~U[2001-01-01 12:34:56 UnknownCalendar]")
+    end
+
+    assert_raise UndefinedFunctionError, fn ->
+      Code.eval_string("~U[2001-01-01T12:34:56 UnknownCalendar]")
+    end
+  end
+
+  test "to_string/1" do
+    datetime = %DateTime{
+      year: 2000,
+      month: 2,
+      day: 29,
+      zone_abbr: "BRM",
+      hour: 23,
+      minute: 0,
+      second: 7,
+      microsecond: {0, 0},
+      utc_offset: -12600,
+      std_offset: 3600,
+      time_zone: "Brazil/Manaus"
+    }
+
+    assert to_string(datetime) == "2000-02-29 23:00:07-02:30 BRM Brazil/Manaus"
+    assert DateTime.to_string(datetime) == "2000-02-29 23:00:07-02:30 BRM Brazil/Manaus"
+
+    assert DateTime.to_string(Map.from_struct(datetime)) ==
+             "2000-02-29 23:00:07-02:30 BRM Brazil/Manaus"
+
+    assert to_string(%{datetime | calendar: FakeCalendar}) ==
+             "29/2/2000F23::0::7 Brazil/Manaus BRM -12600 3600"
+
+    assert DateTime.to_string(%{datetime | calendar: FakeCalendar}) ==
+             "29/2/2000F23::0::7 Brazil/Manaus BRM -12600 3600"
+  end
+
+  test "inspect/1" do
+    utc_datetime = ~U[2000-01-01 23:00:07.005Z]
+    assert inspect(utc_datetime) == "~U[2000-01-01 23:00:07.005Z]"
+
+    assert inspect(%{utc_datetime | year: 99999}) == "#DateTime<99999-01-01 23:00:07.005Z>"
+
+    assert inspect(%{utc_datetime | calendar: FakeCalendar}) ==
+             "~U[1/1/2000F23::0::7 Etc/UTC UTC 0 0 FakeCalendar]"
+
+    datetime = %DateTime{
+      year: 2000,
+      month: 2,
+      day: 29,
+      zone_abbr: "BRM",
+      hour: 23,
+      minute: 0,
+      second: 7,
+      microsecond: {0, 0},
+      utc_offset: -12600,
+      std_offset: 3600,
+      time_zone: "Brazil/Manaus"
+    }
+
+    assert inspect(datetime) == "#DateTime<2000-02-29 23:00:07-02:30 BRM Brazil/Manaus>"
+
+    assert inspect(%{datetime | calendar: FakeCalendar}) ==
+             "#DateTime<29/2/2000F23::0::7 Brazil/Manaus BRM -12600 3600 FakeCalendar>"
+  end
+
+  test "from_iso8601/1 handles positive and negative offsets" do
+    assert DateTime.from_iso8601("2015-01-24T09:50:07-10:00") |> elem(1) ==
+             %DateTime{
+               microsecond: {0, 0},
+               month: 1,
+               std_offset: 0,
+               time_zone: "Etc/UTC",
+               utc_offset: 0,
+               year: 2015,
+               zone_abbr: "UTC",
+               day: 24,
+               hour: 19,
+               minute: 50,
+               second: 7
+             }
+
+    assert DateTime.from_iso8601("2015-01-24T09:50:07+10:00") |> elem(1) ==
+             %DateTime{
+               microsecond: {0, 0},
+               month: 1,
+               std_offset: 0,
+               time_zone: "Etc/UTC",
+               utc_offset: 0,
+               year: 2015,
+               zone_abbr: "UTC",
+               day: 23,
+               hour: 23,
+               minute: 50,
+               second: 7
+             }
+
+    assert DateTime.from_iso8601("0000-01-01T01:22:07+10:30") |> elem(1) ==
+             %DateTime{
+               microsecond: {0, 0},
+               month: 12,
+               std_offset: 0,
+               time_zone: "Etc/UTC",
+               utc_offset: 0,
+               year: -1,
+               zone_abbr: "UTC",
+               day: 31,
+               hour: 14,
+               minute: 52,
+               second: 7
+             }
+  end
+
+  test "from_iso8601/1 handles negative dates" do
+    assert DateTime.from_iso8601("-2015-01-24T09:50:07-10:00") |> elem(1) ==
+             %DateTime{
+               microsecond: {0, 0},
+               month: 1,
+               std_offset: 0,
+               time_zone: "Etc/UTC",
+               utc_offset: 0,
+               year: -2015,
+               zone_abbr: "UTC",
+               day: 24,
+               hour: 19,
+               minute: 50,
+               second: 7
+             }
+
+    assert DateTime.from_iso8601("-2015-01-24T09:50:07+10:00") |> elem(1) ==
+             %DateTime{
+               microsecond: {0, 0},
+               month: 1,
+               std_offset: 0,
+               time_zone: "Etc/UTC",
+               utc_offset: 0,
+               year: -2015,
+               zone_abbr: "UTC",
+               day: 23,
+               hour: 23,
+               minute: 50,
+               second: 7
+             }
+
+    assert DateTime.from_iso8601("-0001-01-01T01:22:07+10:30") |> elem(1) ==
+             %DateTime{
+               microsecond: {0, 0},
+               month: 12,
+               std_offset: 0,
+               time_zone: "Etc/UTC",
+               utc_offset: 0,
+               year: -2,
+               zone_abbr: "UTC",
+               day: 31,
+               hour: 14,
+               minute: 52,
+               second: 7
+             }
+
+    assert DateTime.from_iso8601("-0001-01-01T01:22:07-10:30") |> elem(1) ==
+             %DateTime{
+               microsecond: {0, 0},
+               month: 1,
+               std_offset: 0,
+               time_zone: "Etc/UTC",
+               utc_offset: 0,
+               year: -1,
+               zone_abbr: "UTC",
+               day: 1,
+               hour: 11,
+               minute: 52,
+               second: 7
+             }
+
+    assert DateTime.from_iso8601("-0001-12-31T23:22:07-10:30") |> elem(1) ==
+             %DateTime{
+               microsecond: {0, 0},
+               month: 1,
+               std_offset: 0,
+               time_zone: "Etc/UTC",
+               utc_offset: 0,
+               year: 0,
+               zone_abbr: "UTC",
+               day: 1,
+               hour: 9,
+               minute: 52,
+               second: 7
+             }
+  end
+
+  test "from_iso8601/3 with basic format handles positive and negative offsets" do
+    assert DateTime.from_iso8601("20150124T095007-1000", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("2015-01-24T09:50:07-10:00", Calendar.ISO)
+
+    assert DateTime.from_iso8601("20150124T095007+1000", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("2015-01-24T09:50:07+10:00", Calendar.ISO)
+
+    assert DateTime.from_iso8601("00000101T012207+1030", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("0000-01-01T01:22:07+10:30", Calendar.ISO)
+  end
+
+  test "from_iso8601/3 with basic format handles negative dates" do
+    assert DateTime.from_iso8601("-20150124T095007-1000", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("-2015-01-24T09:50:07-10:00", Calendar.ISO)
+
+    assert DateTime.from_iso8601("-20150124T095007+1000", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("-2015-01-24T09:50:07+10:00", Calendar.ISO)
+
+    assert DateTime.from_iso8601("-00010101T012207+1030", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("-0001-01-01T01:22:07+10:30", Calendar.ISO)
+
+    assert DateTime.from_iso8601("-00010101T012207-1030", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("-0001-01-01T01:22:07-10:30", Calendar.ISO)
+
+    assert DateTime.from_iso8601("-00011231T232207-1030", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("-0001-12-31T23:22:07-10:30", Calendar.ISO)
+  end
+
+  test "from_iso8601/2 handles either a calendar or a format as the second parameter" do
+    assert DateTime.from_iso8601("20150124T095007-1000", :basic) ==
+             DateTime.from_iso8601("2015-01-24T09:50:07-10:00", Calendar.ISO)
+  end
+
+  test "from_iso8601 handles invalid date, time, formats correctly" do
+    assert DateTime.from_iso8601("2015-01-23T23:50:07") == {:error, :missing_offset}
+    assert DateTime.from_iso8601("2015-01-23 23:50:61") == {:error, :invalid_time}
+    assert DateTime.from_iso8601("2015-01-32 23:50:07") == {:error, :invalid_date}
+    assert DateTime.from_iso8601("2015-01-23 23:50:07A") == {:error, :invalid_format}
+    assert DateTime.from_iso8601("2015-01-23T23:50:07.123-00:60") == {:error, :invalid_format}
+
+    assert DateTime.from_iso8601("20150123T235007", Calendar.ISO, :basic) ==
+             {:error, :missing_offset}
+
+    assert DateTime.from_iso8601("20150123 235061", Calendar.ISO, :basic) ==
+             {:error, :invalid_time}
+
+    assert DateTime.from_iso8601("20150132 235007", Calendar.ISO, :basic) ==
+             {:error, :invalid_date}
+
+    assert DateTime.from_iso8601("20150123 235007A", Calendar.ISO, :basic) ==
+             {:error, :invalid_format}
+
+    assert DateTime.from_iso8601("2015-01-24T09:50:07-10:00", Calendar.ISO, :basic) ==
+             {:error, :invalid_format}
+
+    assert DateTime.from_iso8601("20150123T235007.123-0060", Calendar.ISO, :basic) ==
+             {:error, :invalid_format}
+  end
+
+  test "from_unix/2" do
+    min_datetime = %DateTime{
+      calendar: Calendar.ISO,
+      day: 1,
+      hour: 0,
+      microsecond: {0, 0},
+      minute: 0,
+      month: 1,
+      second: 0,
+      std_offset: 0,
+      time_zone: "Etc/UTC",
+      utc_offset: 0,
+      year: -9999,
+      zone_abbr: "UTC"
+    }
+
+    assert DateTime.from_unix(-377_705_116_800) == {:ok, min_datetime}
+
+    assert DateTime.from_unix(-377_705_116_800_000_001, :microsecond) ==
+             {:error, :invalid_unix_time}
+
+    assert DateTime.from_unix(143_256_036_886_856, 1024) ==
+             {:ok,
+              %DateTime{
+                calendar: Calendar.ISO,
+                day: 17,
+                hour: 7,
+                microsecond: {320_312, 6},
+                minute: 5,
+                month: 3,
+                second: 22,
+                std_offset: 0,
+                time_zone: "Etc/UTC",
+                utc_offset: 0,
+                year: 6403,
+                zone_abbr: "UTC"
+              }}
+
+    max_datetime = %DateTime{
+      calendar: Calendar.ISO,
+      day: 31,
+      hour: 23,
+      microsecond: {999_999, 6},
+      minute: 59,
+      month: 12,
+      second: 59,
+      std_offset: 0,
+      time_zone: "Etc/UTC",
+      utc_offset: 0,
+      year: 9999,
+      zone_abbr: "UTC"
+    }
+
+    assert DateTime.from_unix(253_402_300_799_999_999, :microsecond) == {:ok, max_datetime}
+
+    assert DateTime.from_unix(253_402_300_800) == {:error, :invalid_unix_time}
+
+    minus_datetime = %DateTime{
+      calendar: Calendar.ISO,
+      day: 31,
+      hour: 23,
+      microsecond: {999_999, 6},
+      minute: 59,
+      month: 12,
+      second: 59,
+      std_offset: 0,
+      time_zone: "Etc/UTC",
+      utc_offset: 0,
+      year: 1969,
+      zone_abbr: "UTC"
+    }
+
+    assert DateTime.from_unix(-1, :microsecond) == {:ok, minus_datetime}
+
+    assert_raise ArgumentError, fn ->
+      DateTime.from_unix(0, :unknown_atom)
+    end
+
+    assert_raise ArgumentError, fn ->
+      DateTime.from_unix(0, "invalid type")
+    end
+  end
+
+  test "from_unix!/2" do
+    # with Unix times back to 0 Gregorian seconds
+    datetime = %DateTime{
+      calendar: Calendar.ISO,
+      day: 1,
+      hour: 0,
+      microsecond: {0, 0},
+      minute: 0,
+      month: 1,
+      second: 0,
+      std_offset: 0,
+      time_zone: "Etc/UTC",
+      utc_offset: 0,
+      year: 0,
+      zone_abbr: "UTC"
+    }
+
+    assert DateTime.from_unix!(-62_167_219_200) == datetime
+
+    assert_raise ArgumentError, fn ->
+      DateTime.from_unix!(-377_705_116_801)
+    end
+
+    assert_raise ArgumentError, fn ->
+      DateTime.from_unix!(0, :unknown_atom)
+    end
+
+    assert_raise ArgumentError, fn ->
+      DateTime.from_unix!(0, "invalid type")
+    end
+  end
+
+  test "to_unix/2 works with Unix times back to 0 Gregorian seconds" do
+    # with Unix times back to 0 Gregorian seconds
+    gregorian_0 = %DateTime{
+      calendar: Calendar.ISO,
+      day: 1,
+      hour: 0,
+      microsecond: {0, 0},
+      minute: 0,
+      month: 1,
+      second: 0,
+      std_offset: 0,
+      time_zone: "Etc/UTC",
+      utc_offset: 0,
+      year: 0,
+      zone_abbr: "UTC"
+    }
+
+    assert DateTime.to_unix(gregorian_0) == -62_167_219_200
+    assert DateTime.to_unix(Map.from_struct(gregorian_0)) == -62_167_219_200
+
+    min_datetime = %{gregorian_0 | year: -9999}
+    assert DateTime.to_unix(min_datetime) == -377_705_116_800
+  end
+
+  test "compare/2" do
+    datetime1 = %DateTime{
+      year: 2000,
+      month: 2,
+      day: 29,
+      zone_abbr: "CET",
+      hour: 23,
+      minute: 0,
+      second: 7,
+      microsecond: {0, 0},
+      utc_offset: 3600,
+      std_offset: 0,
+      time_zone: "Europe/Warsaw"
+    }
+
+    datetime2 = %DateTime{
+      year: 2000,
+      month: 2,
+      day: 29,
+      zone_abbr: "AMT",
+      hour: 23,
+      minute: 0,
+      second: 7,
+      microsecond: {0, 0},
+      utc_offset: -14400,
+      std_offset: 0,
+      time_zone: "America/Manaus"
+    }
+
+    datetime3 = %DateTime{
+      year: -99,
+      month: 2,
+      day: 28,
+      zone_abbr: "AMT",
+      hour: 23,
+      minute: 0,
+      second: 7,
+      microsecond: {0, 0},
+      utc_offset: -14400,
+      std_offset: 0,
+      time_zone: "America/Manaus"
+    }
+
+    assert DateTime.compare(datetime1, datetime1) == :eq
+    assert DateTime.compare(datetime1, datetime2) == :lt
+    assert DateTime.compare(datetime2, datetime1) == :gt
+    assert DateTime.compare(datetime3, datetime3) == :eq
+    assert DateTime.compare(datetime2, datetime3) == :gt
+    assert DateTime.compare(datetime3, datetime1) == :lt
+    assert DateTime.compare(Map.from_struct(datetime3), Map.from_struct(datetime1)) == :lt
+  end
+
+  test "before?/2 and after?/2" do
+    datetime1 = ~U[2015-01-02T12:34:56Z]
+    datetime2 = ~U[2015-01-02T12:55:55Z]
+
+    assert DateTime.before?(datetime1, datetime2)
+    assert not DateTime.before?(datetime2, datetime1)
+
+    assert DateTime.after?(datetime2, datetime1)
+    assert not DateTime.after?(datetime1, datetime2)
+  end
+
+  test "convert/2" do
+    datetime_iso = %DateTime{
+      year: 2000,
+      month: 2,
+      day: 29,
+      zone_abbr: "CET",
+      hour: 23,
+      minute: 0,
+      second: 7,
+      microsecond: {0, 0},
+      utc_offset: 3600,
+      std_offset: 0,
+      time_zone: "Europe/Warsaw"
+    }
+
+    datetime_hol = %DateTime{
+      year: 12000,
+      month: 2,
+      day: 29,
+      zone_abbr: "CET",
+      hour: 23,
+      minute: 0,
+      second: 7,
+      microsecond: {0, 0},
+      utc_offset: 3600,
+      std_offset: 0,
+      time_zone: "Europe/Warsaw",
+      calendar: Calendar.Holocene
+    }
+
+    assert DateTime.convert(datetime_iso, Calendar.Holocene) == {:ok, datetime_hol}
+
+    assert datetime_iso
+           |> DateTime.convert!(Calendar.Holocene)
+           |> DateTime.convert!(Calendar.ISO) == datetime_iso
+
+    assert %{datetime_iso | microsecond: {123, 6}}
+           |> DateTime.convert!(Calendar.Holocene)
+           |> DateTime.convert!(Calendar.ISO) == %{datetime_iso | microsecond: {123, 6}}
+
+    assert DateTime.convert(datetime_iso, FakeCalendar) == {:error, :incompatible_calendars}
+
+    # Test passing non-struct map when converting to different calendar returns DateTime struct
+    assert DateTime.convert(Map.from_struct(datetime_iso), Calendar.Holocene) ==
+             {:ok, datetime_hol}
+
+    # Test passing non-struct map when converting to same calendar returns DateTime struct
+    assert DateTime.convert(Map.from_struct(datetime_iso), Calendar.ISO) ==
+             {:ok, datetime_iso}
+  end
+
+  test "from_iso8601/1 with tz offsets" do
+    assert DateTime.from_iso8601("2017-06-02T14:00:00+01:00")
+           |> elem(1) ==
+             %DateTime{
+               year: 2017,
+               month: 6,
+               day: 2,
+               zone_abbr: "UTC",
+               hour: 13,
+               minute: 0,
+               second: 0,
+               microsecond: {0, 0},
+               utc_offset: 0,
+               std_offset: 0,
+               time_zone: "Etc/UTC"
+             }
+
+    assert DateTime.from_iso8601("2017-06-02T14:00:00-04:00")
+           |> elem(1) ==
+             %DateTime{
+               year: 2017,
+               month: 6,
+               day: 2,
+               zone_abbr: "UTC",
+               hour: 18,
+               minute: 0,
+               second: 0,
+               microsecond: {0, 0},
+               utc_offset: 0,
+               std_offset: 0,
+               time_zone: "Etc/UTC"
+             }
+
+    assert DateTime.from_iso8601("2017-06-02T14:00:00+0100")
+           |> elem(1) ==
+             %DateTime{
+               year: 2017,
+               month: 6,
+               day: 2,
+               zone_abbr: "UTC",
+               hour: 13,
+               minute: 0,
+               second: 0,
+               microsecond: {0, 0},
+               utc_offset: 0,
+               std_offset: 0,
+               time_zone: "Etc/UTC"
+             }
+
+    assert DateTime.from_iso8601("2017-06-02T14:00:00-0400")
+           |> elem(1) ==
+             %DateTime{
+               year: 2017,
+               month: 6,
+               day: 2,
+               zone_abbr: "UTC",
+               hour: 18,
+               minute: 0,
+               second: 0,
+               microsecond: {0, 0},
+               utc_offset: 0,
+               std_offset: 0,
+               time_zone: "Etc/UTC"
+             }
+
+    assert DateTime.from_iso8601("2017-06-02T14:00:00+01")
+           |> elem(1) ==
+             %DateTime{
+               year: 2017,
+               month: 6,
+               day: 2,
+               zone_abbr: "UTC",
+               hour: 13,
+               minute: 0,
+               second: 0,
+               microsecond: {0, 0},
+               utc_offset: 0,
+               std_offset: 0,
+               time_zone: "Etc/UTC"
+             }
+
+    assert DateTime.from_iso8601("2017-06-02T14:00:00-04")
+           |> elem(1) ==
+             %DateTime{
+               year: 2017,
+               month: 6,
+               day: 2,
+               zone_abbr: "UTC",
+               hour: 18,
+               minute: 0,
+               second: 0,
+               microsecond: {0, 0},
+               utc_offset: 0,
+               std_offset: 0,
+               time_zone: "Etc/UTC"
+             }
+  end
+
+  test "from_iso8601/3 with basic format with tz offsets" do
+    assert DateTime.from_iso8601("20170602T140000+0100", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("2017-06-02T14:00:00+01:00", Calendar.ISO)
+
+    assert DateTime.from_iso8601("20170602T140000-0400", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("2017-06-02T14:00:00-04:00")
+
+    assert DateTime.from_iso8601("20170602T140000+01", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("2017-06-02T14:00:00+01")
+
+    assert DateTime.from_iso8601("20170602T140000-04", Calendar.ISO, :basic) ==
+             DateTime.from_iso8601("2017-06-02T14:00:00-04")
+  end
+
+  test "truncate/2" do
+    datetime = %DateTime{
+      year: 2017,
+      month: 11,
+      day: 6,
+      zone_abbr: "CET",
+      hour: 0,
+      minute: 6,
+      second: 23,
+      microsecond: {0, 0},
+      utc_offset: 3600,
+      std_offset: 0,
+      time_zone: "Europe/Paris"
+    }
+
+    datetime_map = Map.from_struct(datetime)
+
+    assert DateTime.truncate(%{datetime | microsecond: {123_456, 6}}, :microsecond) ==
+             %{datetime | microsecond: {123_456, 6}}
+
+    # A struct should be returned when passing a map.
+    assert DateTime.truncate(%{datetime_map | microsecond: {123_456, 6}}, :microsecond) ==
+             %{datetime | microsecond: {123_456, 6}}
+
+    assert DateTime.truncate(%{datetime | microsecond: {0, 0}}, :millisecond) ==
+             %{datetime | microsecond: {0, 0}}
+
+    assert DateTime.truncate(%{datetime | microsecond: {000_100, 6}}, :millisecond) ==
+             %{datetime | microsecond: {0, 3}}
+
+    assert DateTime.truncate(%{datetime | microsecond: {000_999, 6}}, :millisecond) ==
+             %{datetime | microsecond: {0, 3}}
+
+    assert DateTime.truncate(%{datetime | microsecond: {001_000, 6}}, :millisecond) ==
+             %{datetime | microsecond: {1000, 3}}
+
+    assert DateTime.truncate(%{datetime | microsecond: {001_200, 6}}, :millisecond) ==
+             %{datetime | microsecond: {1000, 3}}
+
+    assert DateTime.truncate(%{datetime | microsecond: {123_456, 6}}, :millisecond) ==
+             %{datetime | microsecond: {123_000, 3}}
+
+    assert DateTime.truncate(%{datetime | microsecond: {123_456, 6}}, :second) ==
+             %{datetime | microsecond: {0, 0}}
+  end
+
+  describe "diff" do
+    test "diff with invalid time unit" do
+      dt = DateTime.utc_now()
+
+      message =
+        ~r/unsupported time unit\. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got "day"/
+
+      assert_raise ArgumentError, message, fn -> DateTime.diff(dt, dt, "day") end
+    end
+
+    test "diff with valid time unit" do
+      dt1 = %DateTime{
+        year: 100,
+        month: 2,
+        day: 28,
+        zone_abbr: "CET",
+        hour: 23,
+        minute: 0,
+        second: 7,
+        microsecond: {0, 0},
+        utc_offset: 3600,
+        std_offset: 0,
+        time_zone: "Europe/Warsaw"
+      }
+
+      dt2 = %DateTime{
+        year: -0004,
+        month: 2,
+        day: 29,
+        zone_abbr: "CET",
+        hour: 23,
+        minute: 0,
+        second: 7,
+        microsecond: {0, 0},
+        utc_offset: 3600,
+        std_offset: 0,
+        time_zone: "Europe/Warsaw"
+      }
+
+      assert DateTime.diff(dt1, dt2) == 3_281_904_000
+
+      # Test with a non-struct map conforming to Calendar.datetime
+      assert DateTime.diff(Map.from_struct(dt1), Map.from_struct(dt2)) == 3_281_904_000
+    end
+
+    test "diff with microseconds" do
+      datetime = ~U[2023-02-01 10:30:10.123456Z]
+
+      in_almost_7_days =
+        datetime
+        |> DateTime.add(7, :day)
+        |> DateTime.add(-1, :microsecond)
+
+      assert DateTime.diff(in_almost_7_days, datetime, :day) == 6
+    end
+
+    test "diff in microseconds" do
+      datetime1 = ~U[2023-02-01 10:30:10.000000Z]
+      datetime2 = DateTime.add(datetime1, 1234, :microsecond)
+
+      assert DateTime.diff(datetime1, datetime2, :microsecond) == -1234
+    end
+  end
+
+  describe "from_naive" do
+    test "uses default time zone database from config" do
+      Calendar.put_time_zone_database(FakeTimeZoneDatabase)
+
+      assert DateTime.from_naive(
+               ~N[2018-07-01 12:34:25.123456],
+               "Europe/Copenhagen",
+               FakeTimeZoneDatabase
+             ) ==
+               {:ok,
+                %DateTime{
+                  day: 1,
+                  hour: 12,
+                  microsecond: {123_456, 6},
+                  minute: 34,
+                  month: 7,
+                  second: 25,
+                  std_offset: 3600,
+                  time_zone: "Europe/Copenhagen",
+                  utc_offset: 3600,
+                  year: 2018,
+                  zone_abbr: "CEST"
+                }}
+    after
+      Calendar.put_time_zone_database(Calendar.UTCOnlyTimeZoneDatabase)
+    end
+
+    test "with compatible calendar on unambiguous wall clock" do
+      holocene_ndt = %NaiveDateTime{
+        calendar: Calendar.Holocene,
+        year: 12018,
+        month: 7,
+        day: 1,
+        hour: 12,
+        minute: 34,
+        second: 25,
+        microsecond: {123_456, 6}
+      }
+
+      assert DateTime.from_naive(holocene_ndt, "Europe/Copenhagen", FakeTimeZoneDatabase) ==
+               {:ok,
+                %DateTime{
+                  calendar: Calendar.Holocene,
+                  day: 1,
+                  hour: 12,
+                  microsecond: {123_456, 6},
+                  minute: 34,
+                  month: 7,
+                  second: 25,
+                  std_offset: 3600,
+                  time_zone: "Europe/Copenhagen",
+                  utc_offset: 3600,
+                  year: 12018,
+                  zone_abbr: "CEST"
+                }}
+    end
+
+    test "with compatible calendar on ambiguous wall clock" do
+      holocene_ndt = %NaiveDateTime{
+        calendar: Calendar.Holocene,
+        year: 12018,
+        month: 10,
+        day: 28,
+        hour: 02,
+        minute: 30,
+        second: 00,
+        microsecond: {123_456, 6}
+      }
+
+      assert {:ambiguous, first_dt, second_dt} =
+               DateTime.from_naive(holocene_ndt, "Europe/Copenhagen", FakeTimeZoneDatabase)
+
+      assert %DateTime{calendar: Calendar.Holocene, zone_abbr: "CEST"} = first_dt
+      assert %DateTime{calendar: Calendar.Holocene, zone_abbr: "CET"} = second_dt
+    end
+
+    test "with compatible calendar on gap" do
+      holocene_ndt = %NaiveDateTime{
+        calendar: Calendar.Holocene,
+        year: 12019,
+        month: 03,
+        day: 31,
+        hour: 02,
+        minute: 30,
+        second: 00,
+        microsecond: {123_456, 6}
+      }
+
+      assert {:gap, first_dt, second_dt} =
+               DateTime.from_naive(holocene_ndt, "Europe/Copenhagen", FakeTimeZoneDatabase)
+
+      assert %DateTime{calendar: Calendar.Holocene, zone_abbr: "CET"} = first_dt
+      assert %DateTime{calendar: Calendar.Holocene, zone_abbr: "CEST"} = second_dt
+    end
+
+    test "with incompatible calendar" do
+      ndt = %{~N[2018-07-20 00:00:00] | calendar: FakeCalendar}
+
+      assert DateTime.from_naive(ndt, "Europe/Copenhagen", FakeTimeZoneDatabase) ==
+               {:error, :incompatible_calendars}
+    end
+  end
+
+  describe "from_naive!" do
+    test "raises on ambiguous wall clock" do
+      assert_raise ArgumentError, ~r"ambiguous", fn ->
+        DateTime.from_naive!(~N[2018-10-28 02:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      end
+    end
+
+    test "raises on gap" do
+      assert_raise ArgumentError, ~r"gap", fn ->
+        DateTime.from_naive!(~N[2019-03-31 02:30:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+      end
+    end
+  end
+
+  describe "shift_zone" do
+    test "with compatible calendar" do
+      holocene_ndt = %NaiveDateTime{
+        calendar: Calendar.Holocene,
+        year: 12018,
+        month: 7,
+        day: 1,
+        hour: 12,
+        minute: 34,
+        second: 25,
+        microsecond: {123_456, 6}
+      }
+
+      {:ok, holocene_dt} =
+        DateTime.from_naive(holocene_ndt, "Europe/Copenhagen", FakeTimeZoneDatabase)
+
+      {:ok, dt} = DateTime.shift_zone(holocene_dt, "America/Los_Angeles", FakeTimeZoneDatabase)
+
+      assert dt == %DateTime{
+               calendar: Calendar.Holocene,
+               day: 1,
+               hour: 3,
+               microsecond: {123_456, 6},
+               minute: 34,
+               month: 7,
+               second: 25,
+               std_offset: 3600,
+               time_zone: "America/Los_Angeles",
+               utc_offset: -28800,
+               year: 12018,
+               zone_abbr: "PDT"
+             }
+    end
+
+    test "uses default time zone database from config" do
+      Calendar.put_time_zone_database(FakeTimeZoneDatabase)
+
+      {:ok, dt} = DateTime.from_naive(~N[2018-07-01 12:34:25.123456], "Europe/Copenhagen")
+      {:ok, dt} = DateTime.shift_zone(dt, "America/Los_Angeles")
+
+      assert dt == %DateTime{
+               day: 1,
+               hour: 3,
+               microsecond: {123_456, 6},
+               minute: 34,
+               month: 7,
+               second: 25,
+               std_offset: 3600,
+               time_zone: "America/Los_Angeles",
+               utc_offset: -28800,
+               year: 2018,
+               zone_abbr: "PDT"
+             }
+    after
+      Calendar.put_time_zone_database(Calendar.UTCOnlyTimeZoneDatabase)
+    end
+  end
+
+  describe "add" do
+    test "add with invalid time unit" do
+      dt = DateTime.utc_now()
+
+      message =
+        ~r/unsupported time unit\. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got "day"/
+
+      assert_raise ArgumentError, message, fn -> DateTime.add(dt, 1, "day") end
+    end
+
+    test "add with non-struct map that conforms to Calendar.datetime" do
+      dt_map = DateTime.from_naive!(~N[2018-08-28 00:00:00], "Etc/UTC") |> Map.from_struct()
+
+      assert DateTime.add(dt_map, 1, :second) == %DateTime{
+               calendar: Calendar.ISO,
+               year: 2018,
+               month: 8,
+               day: 28,
+               hour: 0,
+               minute: 0,
+               second: 1,
+               std_offset: 0,
+               time_zone: "Etc/UTC",
+               zone_abbr: "UTC",
+               utc_offset: 0,
+               microsecond: {0, 0}
+             }
+    end
+
+    test "error with UTC only database and non UTC datetime" do
+      dt =
+        DateTime.from_naive!(~N[2018-08-28 00:00:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+
+      assert_raise ArgumentError, fn ->
+        DateTime.add(dt, 1, :second)
+      end
+    end
+
+    test "add/2 with other calendars" do
+      assert ~N[2000-01-01 12:34:15.123456]
+             |> NaiveDateTime.convert!(Calendar.Holocene)
+             |> DateTime.from_naive!("Etc/UTC")
+             |> DateTime.add(10, :second) ==
+               %DateTime{
+                 calendar: Calendar.Holocene,
+                 year: 12000,
+                 month: 1,
+                 day: 1,
+                 hour: 12,
+                 minute: 34,
+                 second: 25,
+                 std_offset: 0,
+                 time_zone: "Etc/UTC",
+                 zone_abbr: "UTC",
+                 utc_offset: 0,
+                 microsecond: {123_456, 6}
+               }
+    end
+  end
+
+  describe "to_iso8601" do
+    test "to_iso8601/2 with a normal DateTime struct" do
+      datetime = DateTime.from_naive!(~N[2018-07-01 12:34:25.123456], "Etc/UTC")
+
+      assert DateTime.to_iso8601(datetime) == "2018-07-01T12:34:25.123456Z"
+    end
+
+    test "to_iso8601/2 with a non-struct map conforming to the Calendar.datetime type" do
+      datetime_map =
+        DateTime.from_naive!(~N[2018-07-01 12:34:25.123456], "Etc/UTC") |> Map.from_struct()
+
+      assert DateTime.to_iso8601(datetime_map) == "2018-07-01T12:34:25.123456Z"
+    end
+  end
+
+  describe "to_date/1" do
+    test "upcasting" do
+      assert catch_error(DateTime.to_date(~N[2000-02-29 12:23:34]))
+    end
+  end
+
+  describe "to_time/1" do
+    test "upcasting" do
+      assert catch_error(DateTime.to_time(~N[2000-02-29 12:23:34]))
+    end
+  end
+
+  describe "to_naive/1" do
+    test "upcasting" do
+      assert catch_error(DateTime.to_naive(~N[2000-02-29 12:23:34]))
+    end
+  end
+
+  test "shift/2" do
+    assert DateTime.shift(~U[2000-01-01 00:00:00Z], year: 1) == ~U[2001-01-01 00:00:00Z]
+    assert DateTime.shift(~U[2000-01-01 00:00:00Z], month: 1) == ~U[2000-02-01 00:00:00Z]
+    assert DateTime.shift(~U[2000-01-01 00:00:00Z], month: 1, day: 28) == ~U[2000-02-29 00:00:00Z]
+    assert DateTime.shift(~U[2000-01-01 00:00:00Z], month: 1, day: 30) == ~U[2000-03-02 00:00:00Z]
+    assert DateTime.shift(~U[2000-01-01 00:00:00Z], month: 2, day: 29) == ~U[2000-03-30 00:00:00Z]
+
+    assert DateTime.shift(~U[2000-01-01 00:00:00Z], microsecond: {4000, 4}) ==
+             ~U[2000-01-01 00:00:00.0040Z]
+
+    assert DateTime.shift(~U[2000-02-29 00:00:00Z], year: -1) == ~U[1999-02-28 00:00:00Z]
+    assert DateTime.shift(~U[2000-02-29 00:00:00Z], month: -1) == ~U[2000-01-29 00:00:00Z]
+
+    assert DateTime.shift(~U[2000-02-29 00:00:00Z], month: -1, day: -28) ==
+             ~U[2000-01-01 00:00:00Z]
+
+    assert DateTime.shift(~U[2000-02-29 00:00:00Z], month: -1, day: -30) ==
+             ~U[1999-12-30 00:00:00Z]
+
+    assert DateTime.shift(~U[2000-02-29 00:00:00Z], month: -1, day: -29) ==
+             ~U[1999-12-31 00:00:00Z]
+
+    datetime =
+      DateTime.new!(~D[2018-11-04], ~T[03:00:00], "America/Los_Angeles", FakeTimeZoneDatabase)
+
+    assert DateTime.shift(datetime, [month: -1], FakeTimeZoneDatabase) ==
+             %DateTime{
+               calendar: Calendar.ISO,
+               year: 2018,
+               month: 10,
+               day: 4,
+               hour: 4,
+               minute: 0,
+               second: 0,
+               microsecond: {0, 0},
+               time_zone: "America/Los_Angeles",
+               std_offset: 3600,
+               utc_offset: -28800,
+               zone_abbr: "PDT"
+             }
+
+    datetime =
+      DateTime.new!(~D[2018-11-04], ~T[00:00:00], "America/Los_Angeles", FakeTimeZoneDatabase)
+
+    assert DateTime.shift(datetime, [hour: 2], FakeTimeZoneDatabase) ==
+             %DateTime{
+               calendar: Calendar.ISO,
+               year: 2018,
+               month: 11,
+               day: 4,
+               hour: 1,
+               minute: 0,
+               second: 0,
+               microsecond: {0, 0},
+               time_zone: "America/Los_Angeles",
+               std_offset: 0,
+               utc_offset: -28800,
+               zone_abbr: "PST"
+             }
+
+    datetime =
+      DateTime.new!(~D[2019-03-31], ~T[01:00:00], "Europe/Copenhagen", FakeTimeZoneDatabase)
+
+    assert DateTime.shift(datetime, [hour: 1], FakeTimeZoneDatabase) ==
+             %DateTime{
+               calendar: Calendar.ISO,
+               year: 2019,
+               month: 03,
+               day: 31,
+               hour: 3,
+               minute: 0,
+               second: 0,
+               microsecond: {0, 0},
+               time_zone: "Europe/Copenhagen",
+               std_offset: 3600,
+               utc_offset: 3600,
+               zone_abbr: "CEST"
+             }
+
+    assert_raise ArgumentError,
+                 "unknown unit :months. Expected :year, :month, :week, :day, :hour, :minute, :second, :microsecond",
+                 fn -> DateTime.shift(~U[2012-01-01 00:00:00Z], months: 12) end
+  end
+end
diff --git a/lib/elixir/test/elixir/calendar/duration_test.exs b/lib/elixir/test/elixir/calendar/duration_test.exs
new file mode 100644
index 00000000000..faa4671426d
--- /dev/null
+++ b/lib/elixir/test/elixir/calendar/duration_test.exs
@@ -0,0 +1,439 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule DurationTest do
+  use ExUnit.Case, async: true
+  doctest Duration
+
+  test "new!/1" do
+    assert Duration.new!(year: 2, month: 1, week: 3) == %Duration{year: 2, month: 1, week: 3}
+    assert Duration.new!(microsecond: {20000, 2}) == %Duration{microsecond: {20000, 2}}
+
+    duration = %Duration{year: 1}
+    assert ^duration = Duration.new!(duration)
+
+    assert_raise ArgumentError,
+                 "unsupported value nil for :month. Expected an integer",
+                 fn -> Duration.new!(month: nil) end
+
+    assert_raise ArgumentError,
+                 "unknown unit :years. Expected :year, :month, :week, :day, :hour, :minute, :second, :microsecond",
+                 fn -> Duration.new!(years: 1) end
+
+    assert_raise ArgumentError,
+                 "unsupported value {1, 2, 3} for :microsecond. Expected a tuple {ms, precision} where precision is an integer from 0 to 6",
+                 fn -> Duration.new!(microsecond: {1, 2, 3}) end
+
+    assert_raise ArgumentError,
+                 "unsupported value {100, 7} for :microsecond. Expected a tuple {ms, precision} where precision is an integer from 0 to 6",
+                 fn -> Duration.new!(microsecond: {100, 7}) end
+  end
+
+  test "add/2" do
+    d1 = %Duration{
+      year: 1,
+      month: 2,
+      week: 3,
+      day: 4,
+      hour: 5,
+      minute: 6,
+      second: 7,
+      microsecond: {8, 6}
+    }
+
+    d2 = %Duration{
+      year: 8,
+      month: 7,
+      week: 6,
+      day: 5,
+      hour: 4,
+      minute: 3,
+      second: 2,
+      microsecond: {1, 6}
+    }
+
+    assert Duration.add(d1, d2) == %Duration{
+             year: 9,
+             month: 9,
+             week: 9,
+             day: 9,
+             hour: 9,
+             minute: 9,
+             second: 9,
+             microsecond: {9, 6}
+           }
+
+    assert Duration.add(d1, d2) == Duration.add(d2, d1)
+
+    d1 = %Duration{month: 2, week: 3, day: 4}
+    d2 = %Duration{year: 8, day: 2, second: 2}
+
+    assert Duration.add(d1, d2) == %Duration{
+             year: 8,
+             month: 2,
+             week: 3,
+             day: 6,
+             hour: 0,
+             minute: 0,
+             second: 2,
+             microsecond: {0, 0}
+           }
+
+    d1 = %Duration{microsecond: {1000, 4}}
+    d2 = %Duration{microsecond: {5, 6}}
+    assert Duration.add(d1, d2) == %Duration{microsecond: {1005, 6}}
+  end
+
+  test "subtract/2" do
+    d1 = %Duration{
+      year: 1,
+      month: 2,
+      week: 3,
+      day: 4,
+      hour: 5,
+      minute: 6,
+      second: 7,
+      microsecond: {8, 6}
+    }
+
+    d2 = %Duration{
+      year: 8,
+      month: 7,
+      week: 6,
+      day: 5,
+      hour: 4,
+      minute: 3,
+      second: 2,
+      microsecond: {1, 6}
+    }
+
+    assert Duration.subtract(d1, d2) == %Duration{
+             year: -7,
+             month: -5,
+             week: -3,
+             day: -1,
+             hour: 1,
+             minute: 3,
+             second: 5,
+             microsecond: {7, 6}
+           }
+
+    assert Duration.subtract(d2, d1) == %Duration{
+             year: 7,
+             month: 5,
+             week: 3,
+             day: 1,
+             hour: -1,
+             minute: -3,
+             second: -5,
+             microsecond: {-7, 6}
+           }
+
+    assert Duration.subtract(d1, d2) != Duration.subtract(d2, d1)
+
+    d1 = %Duration{year: 10, month: 2, week: 3, day: 4}
+    d2 = %Duration{year: 8, day: 2, second: 2}
+
+    assert Duration.subtract(d1, d2) == %Duration{
+             year: 2,
+             month: 2,
+             week: 3,
+             day: 2,
+             hour: 0,
+             minute: 0,
+             second: -2,
+             microsecond: {0, 0}
+           }
+
+    d1 = %Duration{microsecond: {1000, 4}}
+    d2 = %Duration{microsecond: {5, 6}}
+    assert Duration.subtract(d1, d2) == %Duration{microsecond: {995, 6}}
+  end
+
+  test "multiply/2" do
+    duration = %Duration{
+      year: 1,
+      month: 2,
+      week: 3,
+      day: 4,
+      hour: 5,
+      minute: 6,
+      second: 7,
+      microsecond: {8, 6}
+    }
+
+    assert Duration.multiply(duration, 3) == %Duration{
+             year: 3,
+             month: 6,
+             week: 9,
+             day: 12,
+             hour: 15,
+             minute: 18,
+             second: 21,
+             microsecond: {24, 6}
+           }
+
+    assert Duration.multiply(%Duration{year: 2, day: 4, minute: 5}, 4) ==
+             %Duration{
+               year: 8,
+               month: 0,
+               week: 0,
+               day: 16,
+               hour: 0,
+               minute: 20,
+               second: 0,
+               microsecond: {0, 0}
+             }
+  end
+
+  test "negate/1" do
+    duration = %Duration{
+      year: 1,
+      month: 2,
+      week: 3,
+      day: 4,
+      hour: 5,
+      minute: 6,
+      second: 7,
+      microsecond: {8, 6}
+    }
+
+    assert Duration.negate(duration) == %Duration{
+             year: -1,
+             month: -2,
+             week: -3,
+             day: -4,
+             hour: -5,
+             minute: -6,
+             second: -7,
+             microsecond: {-8, 6}
+           }
+
+    assert Duration.negate(%Duration{year: 2, day: 4, minute: 5}) ==
+             %Duration{
+               year: -2,
+               month: 0,
+               week: 0,
+               day: -4,
+               hour: 0,
+               minute: -5,
+               second: 0,
+               microsecond: {0, 0}
+             }
+  end
+
+  test "from_iso8601/1" do
+    assert Duration.from_iso8601("P1Y2M3DT4H5M6S") ==
+             {:ok, %Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}}
+
+    assert Duration.from_iso8601("P3WT5H3M") == {:ok, %Duration{week: 3, hour: 5, minute: 3}}
+    assert Duration.from_iso8601("PT5H3M") == {:ok, %Duration{hour: 5, minute: 3}}
+    assert Duration.from_iso8601("P1Y2M3D") == {:ok, %Duration{year: 1, month: 2, day: 3}}
+    assert Duration.from_iso8601("PT4H5M6S") == {:ok, %Duration{hour: 4, minute: 5, second: 6}}
+    assert Duration.from_iso8601("P1Y2M") == {:ok, %Duration{year: 1, month: 2}}
+    assert Duration.from_iso8601("P3D") == {:ok, %Duration{day: 3}}
+    assert Duration.from_iso8601("PT4H5M") == {:ok, %Duration{hour: 4, minute: 5}}
+    assert Duration.from_iso8601("PT6S") == {:ok, %Duration{second: 6}}
+    assert Duration.from_iso8601("P2M4Y") == {:error, :invalid_date_component}
+    assert Duration.from_iso8601("P4Y2W3Y") == {:error, :invalid_date_component}
+    assert Duration.from_iso8601("P5HT4MT3S") == {:error, :invalid_date_component}
+    assert Duration.from_iso8601("P5H3HT4M") == {:error, :invalid_date_component}
+    assert Duration.from_iso8601("P0.5Y") == {:error, :invalid_date_component}
+    assert Duration.from_iso8601("PT1D") == {:error, :invalid_time_component}
+    assert Duration.from_iso8601("PT.6S") == {:error, :invalid_time_component}
+    assert Duration.from_iso8601("PT0.5H") == {:error, :invalid_time_component}
+    assert Duration.from_iso8601("invalid") == {:error, :invalid_duration}
+  end
+
+  test "from_iso8601!/1" do
+    assert Duration.from_iso8601!("P1Y2M3DT4H5M6S") == %Duration{
+             year: 1,
+             month: 2,
+             day: 3,
+             hour: 4,
+             minute: 5,
+             second: 6
+           }
+
+    assert Duration.from_iso8601!("P3WT5H3M") == %Duration{week: 3, hour: 5, minute: 3}
+    assert Duration.from_iso8601!("PT5H3M") == %Duration{hour: 5, minute: 3}
+    assert Duration.from_iso8601!("P1Y2M3D") == %Duration{year: 1, month: 2, day: 3}
+    assert Duration.from_iso8601!("PT4H5M6S") == %Duration{hour: 4, minute: 5, second: 6}
+    assert Duration.from_iso8601!("P1Y2M") == %Duration{year: 1, month: 2}
+    assert Duration.from_iso8601!("P3D") == %Duration{day: 3}
+    assert Duration.from_iso8601!("PT4H5M") == %Duration{hour: 4, minute: 5}
+    assert Duration.from_iso8601!("PT6S") == %Duration{second: 6}
+    assert Duration.from_iso8601!("PT1,6S") == %Duration{second: 1, microsecond: {600_000, 1}}
+    assert Duration.from_iso8601!("PT-1.6S") == %Duration{second: -1, microsecond: {-600_000, 1}}
+    assert Duration.from_iso8601!("PT0,6S") == %Duration{second: 0, microsecond: {600_000, 1}}
+    assert Duration.from_iso8601!("PT-0,6S") == %Duration{second: 0, microsecond: {-600_000, 1}}
+    assert Duration.from_iso8601!("-PT-0,6S") == %Duration{second: 0, microsecond: {600_000, 1}}
+    assert Duration.from_iso8601!("-P10DT4H") == %Duration{day: -10, hour: -4}
+    assert Duration.from_iso8601!("-P10DT-4H") == %Duration{day: -10, hour: 4}
+    assert Duration.from_iso8601!("P-10D") == %Duration{day: -10}
+    assert Duration.from_iso8601!("+P10DT-4H") == %Duration{day: 10, hour: -4}
+    assert Duration.from_iso8601!("P+10D") == %Duration{day: 10}
+    assert Duration.from_iso8601!("-P+10D") == %Duration{day: -10}
+
+    assert Duration.from_iso8601!("PT-1.234567S") == %Duration{
+             second: -1,
+             microsecond: {-234_567, 6}
+           }
+
+    assert Duration.from_iso8601!("PT1.12345678S") == %Duration{
+             second: 1,
+             microsecond: {123_456, 6}
+           }
+
+    assert Duration.from_iso8601!("P3Y4W-3DT-6S") == %Duration{
+             year: 3,
+             week: 4,
+             day: -3,
+             second: -6
+           }
+
+    assert Duration.from_iso8601!("PT-4.23S") == %Duration{second: -4, microsecond: {-230_000, 2}}
+
+    assert_raise ArgumentError,
+                 ~s/failed to parse duration "P5H3HT4M". reason: :invalid_date_component/,
+                 fn ->
+                   Duration.from_iso8601!("P5H3HT4M")
+                 end
+
+    assert_raise ArgumentError,
+                 ~s/failed to parse duration "P4Y2W3Y". reason: :invalid_date_component/,
+                 fn ->
+                   Duration.from_iso8601!("P4Y2W3Y")
+                 end
+
+    assert_raise ArgumentError,
+                 ~s/failed to parse duration "invalid". reason: :invalid_duration/,
+                 fn ->
+                   Duration.from_iso8601!("invalid")
+                 end
+
+    assert_raise ArgumentError,
+                 ~s/failed to parse duration "P4.5YT6S". reason: :invalid_date_component/,
+                 fn ->
+                   Duration.from_iso8601!("P4.5YT6S")
+                 end
+  end
+
+  test "to_iso8601/1" do
+    assert %Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}
+           |> Duration.to_iso8601() == "P1Y2M3DT4H5M6S"
+
+    assert %Duration{week: 3, hour: 5, minute: 3} |> Duration.to_iso8601() == "P3WT5H3M"
+    assert %Duration{hour: 5, minute: 3} |> Duration.to_iso8601() == "PT5H3M"
+    assert %Duration{year: 1, month: 2, day: 3} |> Duration.to_iso8601() == "P1Y2M3D"
+    assert %Duration{hour: 4, minute: 5, second: 6} |> Duration.to_iso8601() == "PT4H5M6S"
+    assert %Duration{year: 1, month: 2} |> Duration.to_iso8601() == "P1Y2M"
+    assert %Duration{day: 3} |> Duration.to_iso8601() == "P3D"
+    assert %Duration{hour: 4, minute: 5} |> Duration.to_iso8601() == "PT4H5M"
+    assert %Duration{second: 6} |> Duration.to_iso8601() == "PT6S"
+    assert %Duration{second: 1, microsecond: {600_000, 1}} |> Duration.to_iso8601() == "PT1.6S"
+    assert %Duration{second: -1, microsecond: {-600_000, 1}} |> Duration.to_iso8601() == "PT-1.6S"
+
+    assert %Duration{second: -1, microsecond: {-234_567, 6}} |> Duration.to_iso8601() ==
+             "PT-1.234567S"
+
+    assert %Duration{second: 1, microsecond: {123_456, 6}} |> Duration.to_iso8601() ==
+             "PT1.123456S"
+
+    assert %Duration{year: 3, week: 4, day: -3, second: -6} |> Duration.to_iso8601() ==
+             "P3Y4W-3DT-6S"
+
+    assert %Duration{second: -4, microsecond: {-230_000, 2}} |> Duration.to_iso8601() ==
+             "PT-4.23S"
+
+    assert %Duration{second: -4, microsecond: {230_000, 2}} |> Duration.to_iso8601() ==
+             "PT-3.77S"
+
+    assert %Duration{second: 2, microsecond: {-1_200_000, 4}} |> Duration.to_iso8601() ==
+             "PT0.8000S"
+
+    assert %Duration{second: 1, microsecond: {-1_200_000, 3}} |> Duration.to_iso8601() ==
+             "PT-0.200S"
+
+    assert %Duration{microsecond: {-800_000, 2}} |> Duration.to_iso8601() == "PT-0.80S"
+    assert %Duration{microsecond: {-800_000, 0}} |> Duration.to_iso8601() == "PT0S"
+    assert %Duration{microsecond: {-1_200_000, 2}} |> Duration.to_iso8601() == "PT-1.20S"
+  end
+
+  test "to_string/1" do
+    assert Duration.to_string(%Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6}) ==
+             "1a 2mo 3d 4h 5min 6s"
+
+    assert Duration.to_string(%Duration{week: 3, hour: 5, minute: 3}) ==
+             "3wk 5h 3min"
+
+    assert Duration.to_string(%Duration{hour: 5, minute: 3}) ==
+             "5h 3min"
+
+    assert Duration.to_string(%Duration{year: 1, month: 2, day: 3}) ==
+             "1a 2mo 3d"
+
+    assert Duration.to_string(%Duration{hour: 4, minute: 5, second: 6}) ==
+             "4h 5min 6s"
+
+    assert Duration.to_string(%Duration{year: 1, month: 2}) ==
+             "1a 2mo"
+
+    assert Duration.to_string(%Duration{day: 3}) ==
+             "3d"
+
+    assert Duration.to_string(%Duration{hour: 4, minute: 5}) ==
+             "4h 5min"
+
+    assert Duration.to_string(%Duration{second: 6}) ==
+             "6s"
+
+    assert Duration.to_string(%Duration{second: 1, microsecond: {600_000, 1}}) ==
+             "1.6s"
+
+    assert Duration.to_string(%Duration{second: -1, microsecond: {-600_000, 1}}) ==
+             "-1.6s"
+
+    assert Duration.to_string(%Duration{second: -1, microsecond: {-234_567, 6}}) ==
+             "-1.234567s"
+
+    assert Duration.to_string(%Duration{second: 1, microsecond: {123_456, 6}}) ==
+             "1.123456s"
+
+    assert Duration.to_string(%Duration{year: 3, week: 4, day: -3, second: -6}) ==
+             "3a 4wk -3d -6s"
+
+    assert Duration.to_string(%Duration{second: -4, microsecond: {-230_000, 2}}) ==
+             "-4.23s"
+
+    assert Duration.to_string(%Duration{second: -4, microsecond: {230_000, 2}}) ==
+             "-3.77s"
+
+    assert Duration.to_string(%Duration{second: 2, microsecond: {-1_200_000, 4}}) ==
+             "0.8000s"
+
+    assert Duration.to_string(%Duration{second: 1, microsecond: {-1_200_000, 3}}) ==
+             "-0.200s"
+
+    assert Duration.to_string(%Duration{microsecond: {-800_000, 2}}) ==
+             "-0.80s"
+
+    assert Duration.to_string(%Duration{microsecond: {-800_000, 0}}) ==
+             "0s"
+
+    assert Duration.to_string(%Duration{microsecond: {-1_200_000, 2}}) ==
+             "-1.20s"
+
+    assert Duration.to_string(%Duration{year: 1, month: 2, day: 3, hour: 4, minute: 5, second: 6},
+             units: [year: "year", month: "month", day: "day"],
+             separator: "-"
+           ) ==
+             "1year-2month-3day-4h-5min-6s"
+  end
+
+  test "inspect/1" do
+    assert inspect(%Duration{hour: 5, minute: 3}) == "%Duration{hour: 5, minute: 3}"
+  end
+end
diff --git a/lib/elixir/test/elixir/calendar/fakes.exs b/lib/elixir/test/elixir/calendar/fakes.exs
new file mode 100644
index 00000000000..21b3043a7c3
--- /dev/null
+++ b/lib/elixir/test/elixir/calendar/fakes.exs
@@ -0,0 +1,235 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule FakeCalendar do
+  def time_to_string(hour, minute, second, _), do: "#{hour}::#{minute}::#{second}"
+  def date_to_string(year, month, day), do: "#{day}/#{month}/#{year}"
+
+  def naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) do
+    date_to_string(year, month, day) <> "F" <> time_to_string(hour, minute, second, microsecond)
+  end
+
+  def datetime_to_string(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        time_zone,
+        abbr,
+        utc_offset,
+        std_offset
+      ) do
+    naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) <>
+      " #{time_zone} #{abbr} #{utc_offset} #{std_offset}"
+  end
+
+  def day_rollover_relative_to_midnight_utc, do: {123_456, 123_457}
+end
+
+defmodule FakeTimeZoneDatabase do
+  @behaviour Calendar.TimeZoneDatabase
+
+  @time_zone_period_cph_summer_2018 %{
+    std_offset: 3600,
+    utc_offset: 3600,
+    zone_abbr: "CEST",
+    from_wall: ~N[2018-03-25 03:00:00],
+    until_wall: ~N[2018-10-28 03:00:00]
+  }
+
+  @time_zone_period_cph_winter_2018_2019 %{
+    std_offset: 0,
+    utc_offset: 3600,
+    zone_abbr: "CET",
+    from_wall: ~N[2018-10-28 02:00:00],
+    until_wall: ~N[2019-03-31 02:00:00]
+  }
+
+  @time_zone_period_cph_summer_2019 %{
+    std_offset: 3600,
+    utc_offset: 3600,
+    zone_abbr: "CEST",
+    from_wall: ~N[2019-03-31 03:00:00],
+    until_wall: ~N[2019-10-27 03:00:00]
+  }
+
+  @time_zone_period_usla_summer_2018 %{
+    std_offset: 3600,
+    utc_offset: -28800,
+    zone_abbr: "PDT",
+    from_wall: ~N[2018-03-11 02:00:00],
+    until_wall: ~N[2018-11-04 02:00:00]
+  }
+
+  @time_zone_period_usla_winter_2018_2019 %{
+    std_offset: 0,
+    utc_offset: -28800,
+    zone_abbr: "PST",
+    from_wall: ~N[2018-11-04 02:00:00],
+    until_wall: ~N[2019-03-10 03:00:00]
+  }
+
+  @spec time_zone_period_from_utc_iso_days(Calendar.iso_days(), Calendar.time_zone()) ::
+          {:ok, TimeZoneDatabase.time_zone_period()} | {:error, :time_zone_not_found}
+  @impl true
+  def time_zone_period_from_utc_iso_days(iso_days, time_zone) do
+    {:ok, ndt} = naive_datetime_from_iso_days(iso_days)
+    time_zone_periods_from_utc(time_zone, NaiveDateTime.to_erl(ndt))
+  end
+
+  @spec time_zone_periods_from_wall_datetime(Calendar.naive_datetime(), Calendar.time_zone()) ::
+          {:ok, TimeZoneDatabase.time_zone_period()}
+          | {:ambiguous, TimeZoneDatabase.time_zone_period(), TimeZoneDatabase.time_zone_period()}
+          | {:gap,
+             {TimeZoneDatabase.time_zone_period(), TimeZoneDatabase.time_zone_period_limit()},
+             {TimeZoneDatabase.time_zone_period(), TimeZoneDatabase.time_zone_period_limit()}}
+          | {:error, :time_zone_not_found}
+  @impl true
+  def time_zone_periods_from_wall_datetime(naive_datetime, time_zone) do
+    time_zone_periods_from_wall(time_zone, NaiveDateTime.to_erl(naive_datetime))
+  end
+
+  defp time_zone_periods_from_utc("Europe/Copenhagen", erl_datetime)
+       when erl_datetime >= {{2018, 3, 25}, {1, 0, 0}} and
+              erl_datetime < {{2018, 10, 28}, {3, 0, 0}} do
+    {:ok, @time_zone_period_cph_summer_2018}
+  end
+
+  defp time_zone_periods_from_utc("Europe/Copenhagen", erl_datetime)
+       when erl_datetime >= {{2018, 10, 28}, {2, 0, 0}} and
+              erl_datetime < {{2019, 3, 31}, {1, 0, 0}} do
+    {:ok, @time_zone_period_cph_winter_2018_2019}
+  end
+
+  defp time_zone_periods_from_utc("Europe/Copenhagen", erl_datetime)
+       when erl_datetime >= {{2019, 3, 31}, {1, 0, 0}} and
+              erl_datetime < {{2019, 10, 28}, {3, 0, 0}} do
+    {:ok, @time_zone_period_cph_summer_2019}
+  end
+
+  defp time_zone_periods_from_utc("Europe/Copenhagen", erl_datetime)
+       when erl_datetime >= {{2015, 3, 29}, {1, 0, 0}} and
+              erl_datetime < {{2015, 10, 25}, {1, 0, 0}} do
+    {:ok,
+     %{
+       std_offset: 3600,
+       utc_offset: 3600,
+       zone_abbr: "CEST"
+     }}
+  end
+
+  defp time_zone_periods_from_utc("America/Los_Angeles", erl_datetime)
+       when erl_datetime >= {{2018, 3, 11}, {2, 0, 0}} and
+              erl_datetime < {{2018, 11, 4}, {2, 0, 0}} do
+    {:ok, @time_zone_period_usla_summer_2018}
+  end
+
+  defp time_zone_periods_from_utc("America/Los_Angeles", erl_datetime)
+       when erl_datetime >= {{2018, 11, 4}, {2, 0, 0}} and
+              erl_datetime < {{2019, 3, 10}, {3, 0, 0}} do
+    {:ok, @time_zone_period_usla_winter_2018_2019}
+  end
+
+  defp time_zone_periods_from_utc("Etc/UTC", _erl_datetime) do
+    {:ok,
+     %{
+       std_offset: 0,
+       utc_offset: 0,
+       zone_abbr: "UTC"
+     }}
+  end
+
+  defp time_zone_periods_from_utc(time_zone, _) when time_zone != "Europe/Copenhagen" do
+    {:error, :time_zone_not_found}
+  end
+
+  defp time_zone_periods_from_wall("Europe/Copenhagen", erl_datetime)
+       when erl_datetime >= {{2019, 3, 31}, {2, 0, 0}} and
+              erl_datetime < {{2019, 3, 31}, {3, 0, 0}} do
+    {:gap,
+     {@time_zone_period_cph_winter_2018_2019, @time_zone_period_cph_winter_2018_2019.until_wall},
+     {@time_zone_period_cph_summer_2019, @time_zone_period_cph_summer_2019.from_wall}}
+  end
+
+  defp time_zone_periods_from_wall("Europe/Copenhagen", erl_datetime)
+       when erl_datetime < {{2018, 10, 28}, {3, 0, 0}} and
+              erl_datetime >= {{2018, 10, 28}, {2, 0, 0}} do
+    {:ambiguous, @time_zone_period_cph_summer_2018, @time_zone_period_cph_winter_2018_2019}
+  end
+
+  defp time_zone_periods_from_wall("Europe/Copenhagen", erl_datetime)
+       when erl_datetime >= {{2018, 3, 25}, {3, 0, 0}} and
+              erl_datetime < {{2018, 10, 28}, {3, 0, 0}} do
+    {:ok, @time_zone_period_cph_summer_2018}
+  end
+
+  defp time_zone_periods_from_wall("Europe/Copenhagen", erl_datetime)
+       when erl_datetime >= {{2018, 10, 28}, {2, 0, 0}} and
+              erl_datetime < {{2019, 3, 31}, {2, 0, 0}} do
+    {:ok, @time_zone_period_cph_winter_2018_2019}
+  end
+
+  defp time_zone_periods_from_wall("Europe/Copenhagen", erl_datetime)
+       when erl_datetime >= {{2019, 3, 31}, {3, 0, 0}} and
+              erl_datetime < {{2019, 10, 27}, {3, 0, 0}} do
+    {:ok, @time_zone_period_cph_summer_2019}
+  end
+
+  defp time_zone_periods_from_wall("America/Los_Angeles", erl_datetime)
+       when erl_datetime >= {{2018, 3, 11}, {2, 0, 0}} and
+              erl_datetime < {{2018, 11, 4}, {2, 0, 0}} do
+    {:ok, @time_zone_period_usla_summer_2018}
+  end
+
+  defp time_zone_periods_from_wall("America/Los_Angeles", erl_datetime)
+       when erl_datetime >= {{2018, 11, 4}, {3, 0, 0}} and
+              erl_datetime < {{2019, 3, 10}, {3, 0, 0}} do
+    {:ok, @time_zone_period_usla_winter_2018_2019}
+  end
+
+  defp time_zone_periods_from_wall("Europe/Copenhagen", erl_datetime)
+       when erl_datetime >= {{2015, 3, 29}, {3, 0, 0}} and
+              erl_datetime < {{2015, 10, 25}, {3, 0, 0}} do
+    {:ok,
+     %{
+       std_offset: 3600,
+       utc_offset: 3600,
+       zone_abbr: "CEST"
+     }}
+  end
+
+  defp time_zone_periods_from_wall("Europe/Copenhagen", erl_datetime)
+       when erl_datetime >= {{2090, 3, 26}, {3, 0, 0}} and
+              erl_datetime < {{2090, 10, 29}, {3, 0, 0}} do
+    {:ok,
+     %{
+       std_offset: 3600,
+       utc_offset: 3600,
+       zone_abbr: "CEST"
+     }}
+  end
+
+  defp time_zone_periods_from_wall("Etc/UTC", _erl_datetime) do
+    {:ok,
+     %{
+       std_offset: 0,
+       utc_offset: 0,
+       zone_abbr: "UTC"
+     }}
+  end
+
+  defp time_zone_periods_from_wall(time_zone, _) when time_zone != "Europe/Copenhagen" do
+    {:error, :time_zone_not_found}
+  end
+
+  defp naive_datetime_from_iso_days(iso_days) do
+    {year, month, day, hour, minute, second, microsecond} =
+      Calendar.ISO.naive_datetime_from_iso_days(iso_days)
+
+    NaiveDateTime.new(year, month, day, hour, minute, second, microsecond)
+  end
+end
diff --git a/lib/elixir/test/elixir/calendar/holocene.exs b/lib/elixir/test/elixir/calendar/holocene.exs
new file mode 100644
index 00000000000..8e9e2a9b3ee
--- /dev/null
+++ b/lib/elixir/test/elixir/calendar/holocene.exs
@@ -0,0 +1,177 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Calendar.Holocene do
+  # This calendar is used to test conversions between calendars.
+  # It implements the Holocene calendar, which is based on the
+  # Proleptic Gregorian calendar with every year + 10000.
+
+  @behaviour Calendar
+
+  def date(year, month, day) do
+    %Date{year: year, month: month, day: day, calendar: __MODULE__}
+  end
+
+  def naive_datetime(year, month, day, hour, minute, second, microsecond \\ {0, 0}) do
+    %NaiveDateTime{
+      year: year,
+      month: month,
+      day: day,
+      hour: hour,
+      minute: minute,
+      second: second,
+      microsecond: microsecond,
+      calendar: __MODULE__
+    }
+  end
+
+  @impl true
+  def date_to_string(year, month, day) do
+    "#{year}-#{zero_pad(month, 2)}-#{zero_pad(day, 2)}"
+  end
+
+  @impl true
+  def naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) do
+    "#{year}-#{zero_pad(month, 2)}-#{zero_pad(day, 2)}" <>
+      Calendar.ISO.time_to_string(hour, minute, second, microsecond)
+  end
+
+  @impl true
+  def datetime_to_string(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        microsecond,
+        _time_zone,
+        zone_abbr,
+        _utc_offset,
+        _std_offset
+      ) do
+    "#{year}-#{zero_pad(month, 2)}-#{zero_pad(day, 2)}" <>
+      Calendar.ISO.time_to_string(hour, minute, second, microsecond) <>
+      " #{zone_abbr}"
+  end
+
+  @impl true
+  defdelegate time_to_string(hour, minute, second, microsecond), to: Calendar.ISO
+
+  @impl true
+  def day_rollover_relative_to_midnight_utc(), do: {0, 1}
+
+  @impl true
+  def naive_datetime_from_iso_days(entry) do
+    {year, month, day, hour, minute, second, microsecond} =
+      Calendar.ISO.naive_datetime_from_iso_days(entry)
+
+    {year + 10000, month, day, hour, minute, second, microsecond}
+  end
+
+  @impl true
+  def naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) do
+    Calendar.ISO.naive_datetime_to_iso_days(
+      year - 10000,
+      month,
+      day,
+      hour,
+      minute,
+      second,
+      microsecond
+    )
+  end
+
+  defp zero_pad(val, count) when val >= 0 do
+    String.pad_leading("#{val}", count, ["0"])
+  end
+
+  defp zero_pad(val, count) do
+    "-" <> zero_pad(-val, count)
+  end
+
+  @impl true
+  def parse_date(string) do
+    {year, month, day} =
+      string
+      |> String.split("-")
+      |> Enum.map(&String.to_integer/1)
+      |> List.to_tuple()
+
+    if valid_date?(year, month, day) do
+      {:ok, {year, month, day}}
+    else
+      {:error, :invalid_date}
+    end
+  end
+
+  @impl true
+  def valid_date?(year, month, day) do
+    :calendar.valid_date(year, month, day)
+  end
+
+  @impl true
+  defdelegate parse_time(string), to: Calendar.ISO
+
+  @impl true
+  defdelegate parse_naive_datetime(string), to: Calendar.ISO
+
+  @impl true
+  defdelegate parse_utc_datetime(string), to: Calendar.ISO
+
+  @impl true
+  defdelegate time_from_day_fraction(day_fraction), to: Calendar.ISO
+
+  @impl true
+  defdelegate time_to_day_fraction(hour, minute, second, microsecond), to: Calendar.ISO
+
+  @impl true
+  defdelegate leap_year?(year), to: Calendar.ISO
+
+  @impl true
+  defdelegate days_in_month(year, month), to: Calendar.ISO
+
+  @impl true
+  defdelegate months_in_year(year), to: Calendar.ISO
+
+  @impl true
+  defdelegate day_of_week(year, month, day, starting_on), to: Calendar.ISO
+
+  @impl true
+  defdelegate day_of_year(year, month, day), to: Calendar.ISO
+
+  @impl true
+  defdelegate quarter_of_year(year, month, day), to: Calendar.ISO
+
+  @impl true
+  defdelegate year_of_era(year, month, day), to: Calendar.ISO
+
+  @impl true
+  defdelegate day_of_era(year, month, day), to: Calendar.ISO
+
+  @impl true
+  defdelegate valid_time?(hour, minute, second, microsecond), to: Calendar.ISO
+
+  @impl true
+  defdelegate iso_days_to_beginning_of_day(iso_days), to: Calendar.ISO
+
+  @impl true
+  defdelegate iso_days_to_end_of_day(iso_days), to: Calendar.ISO
+
+  # The Holocene calendar extends most year and day count guards implemented in the ISO calendars.
+  @impl true
+  def shift_date(_year, _month, _day, _duration) do
+    raise "shift_date/4 not implemented"
+  end
+
+  @impl true
+  def shift_naive_datetime(_year, _month, _day, _hour, _minute, _second, _microsecond, _duration) do
+    raise "shift_naive_datetime/8 not implemented"
+  end
+
+  @impl true
+  def shift_time(_hour, _minute, _second, _microsecond, _duration) do
+    raise "shift_time/5 not implemented"
+  end
+end
diff --git a/lib/elixir/test/elixir/calendar/iso_test.exs b/lib/elixir/test/elixir/calendar/iso_test.exs
new file mode 100644
index 00000000000..8a77e9f5730
--- /dev/null
+++ b/lib/elixir/test/elixir/calendar/iso_test.exs
@@ -0,0 +1,651 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Calendar.ISOTest do
+  use ExUnit.Case, async: true
+  doctest Calendar.ISO
+
+  describe "date_from_iso_days" do
+    test "with positive dates" do
+      assert {0, 1, 1} == iso_day_roundtrip(0, 1, 1)
+      assert {0, 12, 31} == iso_day_roundtrip(0, 12, 31)
+      assert {1, 12, 31} == iso_day_roundtrip(1, 12, 31)
+      assert {4, 1, 1} == iso_day_roundtrip(4, 1, 1)
+      assert {4, 12, 31} == iso_day_roundtrip(4, 12, 31)
+      assert {9999, 12, 31} == iso_day_roundtrip(9999, 12, 31)
+      assert {9999, 1, 1} == iso_day_roundtrip(9999, 1, 1)
+      assert {9996, 12, 31} == iso_day_roundtrip(9996, 12, 31)
+      assert {9996, 1, 1} == iso_day_roundtrip(9996, 1, 1)
+    end
+
+    test "with negative dates" do
+      assert {-1, 1, 1} == iso_day_roundtrip(-1, 1, 1)
+      assert {-1, 12, 31} == iso_day_roundtrip(-1, 12, 31)
+      assert {-1, 12, 31} == iso_day_roundtrip(-1, 12, 31)
+      assert {-2, 1, 1} == iso_day_roundtrip(-2, 1, 1)
+      assert {-5, 12, 31} == iso_day_roundtrip(-5, 12, 31)
+
+      assert {-4, 1, 1} == iso_day_roundtrip(-4, 1, 1)
+      assert {-4, 12, 31} == iso_day_roundtrip(-4, 12, 31)
+
+      assert {-9999, 12, 31} == iso_day_roundtrip(-9999, 12, 31)
+      assert {-9996, 12, 31} == iso_day_roundtrip(-9996, 12, 31)
+
+      assert {-9996, 12, 31} == iso_day_roundtrip(-9996, 12, 31)
+      assert {-9996, 1, 1} == iso_day_roundtrip(-9996, 1, 1)
+    end
+  end
+
+  describe "date_to_string/4" do
+    test "regular use" do
+      assert Calendar.ISO.date_to_string(1000, 1, 1, :basic) == "10000101"
+      assert Calendar.ISO.date_to_string(1000, 1, 1, :extended) == "1000-01-01"
+
+      assert Calendar.ISO.date_to_string(-123, 1, 1, :basic) == "-01230101"
+      assert Calendar.ISO.date_to_string(-123, 1, 1, :extended) == "-0123-01-01"
+    end
+
+    test "handles years > 9999" do
+      assert Calendar.ISO.date_to_string(10000, 1, 1, :basic) == "100000101"
+      assert Calendar.ISO.date_to_string(10000, 1, 1, :extended) == "10000-01-01"
+    end
+  end
+
+  describe "naive_datetime_to_iso_days/7" do
+    test "raises with invalid dates" do
+      assert_raise ArgumentError, "invalid date: 2018-02-30", fn ->
+        Calendar.ISO.naive_datetime_to_iso_days(2018, 2, 30, 0, 0, 0, {0, 0})
+      end
+
+      assert_raise ArgumentError, "invalid date: 2017-11--03", fn ->
+        Calendar.ISO.naive_datetime_to_iso_days(2017, 11, -3, 0, 0, 0, {0, 0})
+      end
+    end
+  end
+
+  describe "day_of_week/4" do
+    test "raises with invalid dates" do
+      assert_raise ArgumentError, "invalid date: 2018-02-30", fn ->
+        Calendar.ISO.day_of_week(2018, 2, 30, :default)
+      end
+
+      assert_raise ArgumentError, "invalid date: 2017-11-00", fn ->
+        Calendar.ISO.day_of_week(2017, 11, 0, :default)
+      end
+    end
+  end
+
+  describe "day_of_era/3" do
+    test "raises with invalid dates" do
+      assert_raise ArgumentError, "invalid date: 2018-02-30", fn ->
+        Calendar.ISO.day_of_era(2018, 2, 30)
+      end
+
+      assert_raise ArgumentError, "invalid date: 2017-11-00", fn ->
+        Calendar.ISO.day_of_era(2017, 11, 0)
+      end
+    end
+  end
+
+  describe "day_of_year/3" do
+    test "raises with invalid dates" do
+      assert_raise ArgumentError, "invalid date: 2018-02-30", fn ->
+        Calendar.ISO.day_of_year(2018, 2, 30)
+      end
+
+      assert_raise ArgumentError, "invalid date: 2017-11-00", fn ->
+        Calendar.ISO.day_of_year(2017, 11, 0)
+      end
+    end
+  end
+
+  test "year_of_era/3" do
+    # Compatibility tests for year_of_era/1
+    assert Calendar.ISO.year_of_era(-9999) == {10000, 0}
+    assert Calendar.ISO.year_of_era(-1) == {2, 0}
+    assert Calendar.ISO.year_of_era(0) == {1, 0}
+    assert Calendar.ISO.year_of_era(1) == {1, 1}
+    assert Calendar.ISO.year_of_era(1984) == {1984, 1}
+
+    assert Calendar.ISO.year_of_era(-9999, 1, 1) == {10000, 0}
+    assert Calendar.ISO.year_of_era(-1, 1, 1) == {2, 0}
+    assert Calendar.ISO.year_of_era(0, 12, 1) == {1, 0}
+    assert Calendar.ISO.year_of_era(1, 12, 1) == {1, 1}
+    assert Calendar.ISO.year_of_era(1984, 12, 1) == {1984, 1}
+
+    random_positive_year = Enum.random(1..9999)
+    assert Calendar.ISO.year_of_era(random_positive_year, 1, 1) == {random_positive_year, 1}
+  end
+
+  defp iso_day_roundtrip(year, month, day) do
+    iso_days = Calendar.ISO.date_to_iso_days(year, month, day)
+    Calendar.ISO.date_from_iso_days(iso_days)
+  end
+
+  describe "parse_date/1" do
+    test "supports both only extended format by default" do
+      assert Calendar.ISO.parse_date("20150123") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_date("2015-01-23") == {:ok, {2015, 1, 23}}
+    end
+  end
+
+  describe "parse_date/2" do
+    test "allows enforcing basic formats" do
+      assert Calendar.ISO.parse_date("20150123", :basic) == {:ok, {2015, 1, 23}}
+      assert Calendar.ISO.parse_date("2015-01-23", :basic) == {:error, :invalid_format}
+    end
+
+    test "allows enforcing extended formats" do
+      assert Calendar.ISO.parse_date("20150123", :extended) == {:error, :invalid_format}
+      assert Calendar.ISO.parse_date("2015-01-23", :extended) == {:ok, {2015, 1, 23}}
+    end
+
+    test "errors on other format names" do
+      assert_raise FunctionClauseError, fn ->
+        Calendar.ISO.parse_date("20150123", :other)
+      end
+
+      assert_raise FunctionClauseError, fn ->
+        Calendar.ISO.parse_date("2015-01-23", :other)
+      end
+    end
+  end
+
+  describe "parse_time/1" do
+    test "supports only extended format by default" do
+      assert Calendar.ISO.parse_time("235007") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("23:50:07") == {:ok, {23, 50, 7, {0, 0}}}
+    end
+
+    test "ignores offset data but requires valid ones" do
+      assert Calendar.ISO.parse_time("23:50:07Z") == {:ok, {23, 50, 7, {0, 0}}}
+      assert Calendar.ISO.parse_time("23:50:07+01:00") == {:ok, {23, 50, 7, {0, 0}}}
+
+      assert Calendar.ISO.parse_time("2015-01-23 23:50-00:00") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("2015-01-23 23:50-00:60") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("2015-01-23 23:50-24:00") == {:error, :invalid_format}
+    end
+
+    test "supports either comma or period millisecond delimiters" do
+      assert Calendar.ISO.parse_time("23:50:07,012345") == {:ok, {23, 50, 7, {12345, 6}}}
+      assert Calendar.ISO.parse_time("23:50:07.012345") == {:ok, {23, 50, 7, {12345, 6}}}
+    end
+
+    test "only supports reduced precision for milliseconds" do
+      assert Calendar.ISO.parse_time("23:50:07.012345") == {:ok, {23, 50, 7, {12345, 6}}}
+      assert Calendar.ISO.parse_time("23:50:07") == {:ok, {23, 50, 7, {0, 0}}}
+      assert Calendar.ISO.parse_time("23:50") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("23") == {:error, :invalid_format}
+    end
+
+    test "supports various millisecond precisions" do
+      assert Calendar.ISO.parse_time("23:50:07.012345") == {:ok, {23, 50, 7, {12345, 6}}}
+      assert Calendar.ISO.parse_time("23:50:07.0123") == {:ok, {23, 50, 7, {12300, 4}}}
+      assert Calendar.ISO.parse_time("23:50:07.01") == {:ok, {23, 50, 7, {10000, 2}}}
+      assert Calendar.ISO.parse_time("23:50:07.0") == {:ok, {23, 50, 7, {0, 1}}}
+      assert Calendar.ISO.parse_time("23:50:07") == {:ok, {23, 50, 7, {0, 0}}}
+    end
+
+    test "truncates extra millisecond precision" do
+      assert Calendar.ISO.parse_time("23:50:07.012345") == {:ok, {23, 50, 7, {12345, 6}}}
+      assert Calendar.ISO.parse_time("23:50:07.0123456") == {:ok, {23, 50, 7, {12345, 6}}}
+    end
+
+    test "rejects strings with formatting errors" do
+      assert Calendar.ISO.parse_time("23:50:07A") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("23:50:07.") == {:error, :invalid_format}
+    end
+
+    test "refuses to parse the wrong thing" do
+      assert Calendar.ISO.parse_time("2015:01:23 23-50-07") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("2015-01-23 23:50:07") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("2015:01:23T23-50-07") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("2015-01-23T23:50:07") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("2015:01:23") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("2015-01-23") == {:error, :invalid_format}
+    end
+
+    test "recognizes invalid times" do
+      assert Calendar.ISO.parse_time("23:59:61") == {:error, :invalid_time}
+      assert Calendar.ISO.parse_time("23:61:59") == {:error, :invalid_time}
+      assert Calendar.ISO.parse_time("25:59:59") == {:error, :invalid_time}
+    end
+  end
+
+  describe "parse_time/2" do
+    test "allows enforcing basic formats" do
+      assert Calendar.ISO.parse_time("235007", :basic) == {:ok, {23, 50, 7, {0, 0}}}
+      assert Calendar.ISO.parse_time("23:50:07", :basic) == {:error, :invalid_format}
+    end
+
+    test "allows enforcing extended formats" do
+      assert Calendar.ISO.parse_time("235007", :extended) == {:error, :invalid_format}
+      assert Calendar.ISO.parse_time("23:50:07", :extended) == {:ok, {23, 50, 7, {0, 0}}}
+    end
+
+    test "errors on other format names" do
+      assert_raise FunctionClauseError, fn ->
+        Calendar.ISO.parse_time("235007", :other)
+      end
+
+      assert_raise FunctionClauseError, fn ->
+        Calendar.ISO.parse_time("23:50:07", :other)
+      end
+    end
+  end
+
+  describe "parse_naive_datetime/1" do
+    test "rejects strings with formatting errors" do
+      assert Calendar.ISO.parse_naive_datetime("2015:01:23 23-50-07") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23P23:50:07") == {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07A") ==
+               {:error, :invalid_format}
+    end
+
+    test "recognizes invalid dates and times" do
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:61") == {:error, :invalid_time}
+      assert Calendar.ISO.parse_naive_datetime("2015-01-32 23:50:07") == {:error, :invalid_date}
+    end
+
+    test "ignores offset data but requires valid ones" do
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23T23:50:07.123+02:30") ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23T23:50:07.123+00:00") ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23T23:50:07.123-02:30") ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23T23:50:07.123-00:00") ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23T23:50:07.123-00:60") ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23T23:50:07.123-24:00") ==
+               {:error, :invalid_format}
+    end
+
+    test "supports both spaces and 'T' as datetime separators" do
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07") ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23T23:50:07") ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}}
+    end
+
+    test "supports only extended format by default" do
+      assert Calendar.ISO.parse_naive_datetime("20150123 235007.123") ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07.123") ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}
+    end
+
+    test "errors on mixed basic and extended formats" do
+      assert Calendar.ISO.parse_naive_datetime("20150123 23:50:07.123") ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23 235007.123") ==
+               {:error, :invalid_format}
+    end
+  end
+
+  describe "parse_naive_datetime/2" do
+    test "allows enforcing basic formats" do
+      assert Calendar.ISO.parse_naive_datetime("20150123 235007.123", :basic) ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07.123", :basic) ==
+               {:error, :invalid_format}
+    end
+
+    test "allows enforcing extended formats" do
+      assert Calendar.ISO.parse_naive_datetime("20150123 235007.123", :extended) ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07.123", :extended) ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}}
+    end
+
+    test "errors on other format names" do
+      assert_raise FunctionClauseError, fn ->
+        Calendar.ISO.parse_naive_datetime("20150123 235007.123", :other)
+      end
+
+      assert_raise FunctionClauseError, fn ->
+        Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07.123", :other)
+      end
+    end
+  end
+
+  describe "parse_utc_datetime/1" do
+    test "rejects strings with formatting errors" do
+      assert Calendar.ISO.parse_utc_datetime("2015:01:23 23-50-07Z") == {:error, :invalid_format}
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23P23:50:07Z") == {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:07A") == {:error, :invalid_format}
+    end
+
+    test "recognizes invalid dates, times, and offsets" do
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:07") == {:error, :missing_offset}
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:61Z") == {:error, :invalid_time}
+      assert Calendar.ISO.parse_utc_datetime("2015-01-32 23:50:07Z") == {:error, :invalid_date}
+    end
+
+    test "interprets offset data" do
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23T23:50:07.123+02:30") ==
+               {:ok, {2015, 1, 23, 21, 20, 7, {123_000, 3}}, 9000}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23T23:50:07.123+00:00") ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}, 0}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23T23:50:07.123-02:30") ==
+               {:ok, {2015, 1, 24, 2, 20, 7, {123_000, 3}}, -9000}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23T23:50:07.123-00:00") ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23T23:50:07.123-00:60") ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23T23:50:07.123-24:00") ==
+               {:error, :invalid_format}
+    end
+
+    test "supports both spaces and 'T' as datetime separators" do
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:07Z") ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}, 0}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23T23:50:07Z") ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {0, 0}}, 0}
+    end
+
+    test "supports only extended format by default" do
+      assert Calendar.ISO.parse_utc_datetime("20150123 235007.123Z") ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:07.123Z") ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}, 0}
+    end
+
+    test "errors on mixed basic and extended formats" do
+      assert Calendar.ISO.parse_utc_datetime("20150123 23:50:07.123Z") ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23 235007.123Z") ==
+               {:error, :invalid_format}
+    end
+  end
+
+  describe "parse_utc_datetime/2" do
+    test "allows enforcing basic formats" do
+      assert Calendar.ISO.parse_utc_datetime("20150123 235007.123Z", :basic) ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}, 0}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:07.123Z", :basic) ==
+               {:error, :invalid_format}
+    end
+
+    test "allows enforcing extended formats" do
+      assert Calendar.ISO.parse_utc_datetime("20150123 235007.123Z", :extended) ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23 23:50:07.123Z", :extended) ==
+               {:ok, {2015, 1, 23, 23, 50, 7, {123_000, 3}}, 0}
+    end
+
+    test "errors on other format names" do
+      assert_raise FunctionClauseError, fn ->
+        Calendar.ISO.parse_naive_datetime("20150123 235007.123Z", :other)
+      end
+
+      assert_raise FunctionClauseError, fn ->
+        Calendar.ISO.parse_naive_datetime("2015-01-23 23:50:07.123Z", :other)
+      end
+    end
+
+    test "errors on mixed basic and extended formats" do
+      assert Calendar.ISO.parse_utc_datetime("20150123 23:50:07.123Z", :basic) ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_utc_datetime("20150123 23:50:07.123Z", :extended) ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23 235007.123Z", :basic) ==
+               {:error, :invalid_format}
+
+      assert Calendar.ISO.parse_utc_datetime("2015-01-23 235007.123Z", :extended) ==
+               {:error, :invalid_format}
+    end
+  end
+
+  test "shift_date/2" do
+    assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!([])) == {2024, 3, 2}
+    assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(year: 1)) == {2025, 3, 2}
+    assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(month: 2)) == {2024, 5, 2}
+    assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(week: 3)) == {2024, 3, 23}
+    assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(day: 5)) == {2024, 3, 7}
+
+    assert Calendar.ISO.shift_date(0, 1, 1, Duration.new!(month: 1)) == {0, 2, 1}
+    assert Calendar.ISO.shift_date(0, 1, 1, Duration.new!(year: 1)) == {1, 1, 1}
+    assert Calendar.ISO.shift_date(0, 1, 1, Duration.new!(year: -2, month: 2)) == {-2, 3, 1}
+    assert Calendar.ISO.shift_date(-4, 1, 1, Duration.new!(year: -1)) == {-5, 1, 1}
+
+    assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(year: 1, month: 2, week: 3, day: 5)) ==
+             {2025, 5, 28}
+
+    assert Calendar.ISO.shift_date(2024, 3, 2, Duration.new!(year: -1, month: -2, week: -3)) ==
+             {2022, 12, 12}
+
+    assert Calendar.ISO.shift_date(2020, 2, 28, Duration.new!(day: 1)) == {2020, 2, 29}
+    assert Calendar.ISO.shift_date(2020, 2, 29, Duration.new!(year: 1)) == {2021, 2, 28}
+    assert Calendar.ISO.shift_date(2024, 3, 31, Duration.new!(month: -1)) == {2024, 2, 29}
+    assert Calendar.ISO.shift_date(2024, 3, 31, Duration.new!(month: -2)) == {2024, 1, 31}
+    assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 1)) == {2024, 2, 29}
+    assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 2)) == {2024, 3, 31}
+    assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 3)) == {2024, 4, 30}
+    assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 4)) == {2024, 5, 31}
+    assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 5)) == {2024, 6, 30}
+    assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 6)) == {2024, 7, 31}
+    assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 7)) == {2024, 8, 31}
+    assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 8)) == {2024, 9, 30}
+    assert Calendar.ISO.shift_date(2024, 1, 31, Duration.new!(month: 9)) == {2024, 10, 31}
+  end
+
+  test "shift_naive_datetime/2" do
+    assert Calendar.ISO.shift_naive_datetime(
+             2024,
+             3,
+             2,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!([])
+           ) == {2024, 3, 2, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             1,
+             1,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(year: 1)
+           ) == {2001, 1, 1, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             1,
+             1,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(month: 1)
+           ) == {2000, 2, 1, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             1,
+             1,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(month: 1, day: 28)
+           ) == {2000, 2, 29, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             1,
+             1,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(month: 1, day: 30)
+           ) == {2000, 3, 2, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             1,
+             1,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(month: 2, day: 29)
+           ) == {2000, 3, 30, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             2,
+             29,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(year: -1)
+           ) == {1999, 2, 28, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             2,
+             29,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(month: -1)
+           ) == {2000, 1, 29, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             2,
+             29,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(month: -1, day: -28)
+           ) == {2000, 1, 1, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             2,
+             29,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(month: -1, day: -30)
+           ) == {1999, 12, 30, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             2,
+             29,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(month: -1, day: -29)
+           ) == {1999, 12, 31, 0, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             1,
+             1,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(hour: 12)
+           ) == {2000, 1, 1, 12, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_naive_datetime(
+             2000,
+             1,
+             1,
+             0,
+             0,
+             0,
+             {0, 0},
+             Duration.new!(minute: -65)
+           ) == {1999, 12, 31, 22, 55, 0, {0, 0}}
+  end
+
+  test "shift_time/2" do
+    assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(hour: 1)) == {1, 0, 0, {0, 0}}
+    assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(hour: -1)) == {23, 0, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(minute: 30)) ==
+             {0, 30, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(minute: -30)) ==
+             {23, 30, 0, {0, 0}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(second: 30)) ==
+             {0, 0, 30, {0, 0}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(second: -30)) ==
+             {23, 59, 30, {0, 0}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(microsecond: {100, 6})) ==
+             {0, 0, 0, {100, 6}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(microsecond: {-100, 6})) ==
+             {23, 59, 59, {999_900, 6}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(microsecond: {2000, 4})) ==
+             {0, 0, 0, {2000, 4}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {0, 0}, Duration.new!(microsecond: {-2000, 4})) ==
+             {23, 59, 59, {998_000, 4}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {3500, 6}, Duration.new!(microsecond: {-2000, 4})) ==
+             {0, 0, 0, {1500, 4}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {3500, 4}, Duration.new!(minute: 5)) ==
+             {0, 5, 0, {3500, 4}}
+
+    assert Calendar.ISO.shift_time(0, 0, 0, {3500, 6}, Duration.new!(hour: 4)) ==
+             {4, 0, 0, {3500, 6}}
+
+    assert Calendar.ISO.shift_time(
+             23,
+             59,
+             59,
+             {999_900, 6},
+             Duration.new!(hour: 4, microsecond: {100, 6})
+           ) == {4, 0, 0, {0, 6}}
+  end
+end
diff --git a/lib/elixir/test/elixir/calendar/naive_datetime_test.exs b/lib/elixir/test/elixir/calendar/naive_datetime_test.exs
new file mode 100644
index 00000000000..a3796a34a91
--- /dev/null
+++ b/lib/elixir/test/elixir/calendar/naive_datetime_test.exs
@@ -0,0 +1,461 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file("holocene.exs", __DIR__)
+Code.require_file("fakes.exs", __DIR__)
+
+defmodule NaiveDateTimeTest do
+  use ExUnit.Case, async: true
+  doctest NaiveDateTime
+
+  test "sigil_N" do
+    assert ~N[2000-01-01T12:34:56] ==
+             %NaiveDateTime{
+               calendar: Calendar.ISO,
+               year: 2000,
+               month: 1,
+               day: 1,
+               hour: 12,
+               minute: 34,
+               second: 56
+             }
+
+    assert ~N[2000-01-01T12:34:56 Calendar.Holocene] ==
+             %NaiveDateTime{
+               calendar: Calendar.Holocene,
+               year: 2000,
+               month: 1,
+               day: 1,
+               hour: 12,
+               minute: 34,
+               second: 56
+             }
+
+    assert ~N[2000-01-01 12:34:56] ==
+             %NaiveDateTime{
+               calendar: Calendar.ISO,
+               year: 2000,
+               month: 1,
+               day: 1,
+               hour: 12,
+               minute: 34,
+               second: 56
+             }
+
+    assert ~N[2000-01-01 12:34:56 Calendar.Holocene] ==
+             %NaiveDateTime{
+               calendar: Calendar.Holocene,
+               year: 2000,
+               month: 1,
+               day: 1,
+               hour: 12,
+               minute: 34,
+               second: 56
+             }
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-50-50T12:34:56" as NaiveDateTime for Calendar.ISO, reason: :invalid_date/,
+                 fn -> Code.eval_string("~N[2001-50-50T12:34:56]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-01-01T12:34:65" as NaiveDateTime for Calendar.ISO, reason: :invalid_time/,
+                 fn -> Code.eval_string("~N[2001-01-01T12:34:65]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "20010101 123456" as NaiveDateTime for Calendar.ISO, reason: :invalid_format/,
+                 fn -> Code.eval_string(~s{~N[20010101 123456]}) end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-01-01 12:34:56 notalias" as NaiveDateTime for Calendar.ISO, reason: :invalid_format/,
+                 fn -> Code.eval_string("~N[2001-01-01 12:34:56 notalias]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-01-01T12:34:56 notalias" as NaiveDateTime for Calendar.ISO, reason: :invalid_format/,
+                 fn -> Code.eval_string("~N[2001-01-01T12:34:56 notalias]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-50-50T12:34:56" as NaiveDateTime for Calendar.Holocene, reason: :invalid_date/,
+                 fn -> Code.eval_string("~N[2001-50-50T12:34:56 Calendar.Holocene]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "2001-01-01T12:34:65" as NaiveDateTime for Calendar.Holocene, reason: :invalid_time/,
+                 fn -> Code.eval_string("~N[2001-01-01T12:34:65 Calendar.Holocene]") end
+
+    assert_raise UndefinedFunctionError, fn ->
+      Code.eval_string("~N[2001-01-01 12:34:56 UnknownCalendar]")
+    end
+
+    assert_raise UndefinedFunctionError, fn ->
+      Code.eval_string("~N[2001-01-01T12:34:56 UnknownCalendar]")
+    end
+  end
+
+  test "to_string/1" do
+    assert to_string(~N[2000-01-01 23:00:07.005]) == "2000-01-01 23:00:07.005"
+    assert NaiveDateTime.to_string(~N[2000-01-01 23:00:07.005]) == "2000-01-01 23:00:07.005"
+
+    ndt = %{~N[2000-01-01 23:00:07.005] | calendar: FakeCalendar}
+    assert to_string(ndt) == "1/1/2000F23::0::7"
+  end
+
+  test "inspect/1" do
+    assert inspect(~N[2000-01-01 23:00:07.005]) == "~N[2000-01-01 23:00:07.005]"
+    assert inspect(~N[-0100-12-31 23:00:07.005]) == "~N[-0100-12-31 23:00:07.005]"
+
+    assert inspect(%{~N[2000-01-01 23:00:07.005] | year: 99999}) ==
+             "NaiveDateTime.new!(99999, 1, 1, 23, 0, 7, {5000, 3})"
+
+    ndt = %{~N[2000-01-01 23:00:07.005] | calendar: FakeCalendar}
+    assert inspect(ndt) == "~N[1/1/2000F23::0::7 FakeCalendar]"
+  end
+
+  test "compare/2" do
+    ndt1 = ~N[2000-04-16 13:30:15.0049]
+    ndt2 = ~N[2000-04-16 13:30:15.0050]
+    ndt3 = ~N[2001-04-16 13:30:15.0050]
+    ndt4 = ~N[-0001-04-16 13:30:15.004]
+    assert NaiveDateTime.compare(ndt1, ndt1) == :eq
+    assert NaiveDateTime.compare(ndt1, ndt2) == :lt
+    assert NaiveDateTime.compare(ndt2, ndt1) == :gt
+    assert NaiveDateTime.compare(ndt3, ndt1) == :gt
+    assert NaiveDateTime.compare(ndt3, ndt2) == :gt
+    assert NaiveDateTime.compare(ndt4, ndt4) == :eq
+    assert NaiveDateTime.compare(ndt1, ndt4) == :gt
+    assert NaiveDateTime.compare(ndt4, ndt3) == :lt
+  end
+
+  test "before?/2 and after?/2" do
+    ndt1 = ~N[2022-01-12 10:10:11.0019]
+    ndt2 = ~N[2022-02-16 13:20:15.0019]
+
+    assert NaiveDateTime.before?(ndt1, ndt2)
+    assert not NaiveDateTime.before?(ndt2, ndt1)
+
+    assert NaiveDateTime.after?(ndt2, ndt1)
+    assert not NaiveDateTime.after?(ndt1, ndt2)
+  end
+
+  test "to_iso8601/1" do
+    ndt = ~N[2000-04-16 12:34:15.1234]
+    ndt = put_in(ndt.calendar, FakeCalendar)
+
+    message =
+      "cannot convert #{inspect(ndt)} to target calendar Calendar.ISO, " <>
+        "reason: #{inspect(ndt.calendar)} and Calendar.ISO have different day rollover moments, " <>
+        "making this conversion ambiguous"
+
+    assert_raise ArgumentError, message, fn ->
+      NaiveDateTime.to_iso8601(ndt)
+    end
+  end
+
+  describe "add" do
+    test "add with invalid time unit" do
+      dt = NaiveDateTime.utc_now()
+
+      message =
+        ~r/unsupported time unit\. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got "day"/
+
+      assert_raise ArgumentError, message, fn -> NaiveDateTime.add(dt, 1, "day") end
+    end
+
+    test "add with other calendars" do
+      assert ~N[2000-01-01 12:34:15.123456]
+             |> NaiveDateTime.convert!(Calendar.Holocene)
+             |> NaiveDateTime.add(10, :second) ==
+               %NaiveDateTime{
+                 calendar: Calendar.Holocene,
+                 year: 12000,
+                 month: 1,
+                 day: 1,
+                 hour: 12,
+                 minute: 34,
+                 second: 25,
+                 microsecond: {123_456, 6}
+               }
+    end
+
+    test "add with datetime" do
+      dt = %DateTime{
+        year: 2000,
+        month: 2,
+        day: 29,
+        zone_abbr: "CET",
+        hour: 23,
+        minute: 0,
+        second: 7,
+        microsecond: {0, 0},
+        utc_offset: 3600,
+        std_offset: 0,
+        time_zone: "Europe/Warsaw"
+      }
+
+      assert NaiveDateTime.add(dt, 21, :second) == ~N[2000-02-29 23:00:28]
+    end
+  end
+
+  describe "diff" do
+    test "diff with invalid time unit" do
+      dt = NaiveDateTime.utc_now()
+
+      message =
+        ~r/unsupported time unit\. Expected :day, :hour, :minute, :second, :millisecond, :microsecond, :nanosecond, or a positive integer, got "day"/
+
+      assert_raise ArgumentError, message, fn -> NaiveDateTime.diff(dt, dt, "day") end
+    end
+
+    test "diff with other calendars" do
+      assert ~N[2000-01-01 12:34:15.123456]
+             |> NaiveDateTime.convert!(Calendar.Holocene)
+             |> NaiveDateTime.add(10, :second)
+             |> NaiveDateTime.diff(~N[2000-01-01 12:34:15.123456]) == 10
+    end
+
+    test "diff with datetime" do
+      dt = %DateTime{
+        year: 2000,
+        month: 2,
+        day: 29,
+        zone_abbr: "CET",
+        hour: 23,
+        minute: 0,
+        second: 7,
+        microsecond: {0, 0},
+        utc_offset: 3600,
+        std_offset: 0,
+        time_zone: "Europe/Warsaw"
+      }
+
+      assert NaiveDateTime.diff(%{dt | second: 57}, dt, :second) == 50
+    end
+  end
+
+  test "convert/2" do
+    assert NaiveDateTime.convert(~N[2000-01-01 12:34:15.123400], Calendar.Holocene) ==
+             {:ok, Calendar.Holocene.naive_datetime(12000, 1, 1, 12, 34, 15, {123_400, 6})}
+
+    assert ~N[2000-01-01 12:34:15]
+           |> NaiveDateTime.convert!(Calendar.Holocene)
+           |> NaiveDateTime.convert!(Calendar.ISO) == ~N[2000-01-01 12:34:15]
+
+    assert ~N[2000-01-01 12:34:15.123456]
+           |> NaiveDateTime.convert!(Calendar.Holocene)
+           |> NaiveDateTime.convert!(Calendar.ISO) == ~N[2000-01-01 12:34:15.123456]
+
+    assert NaiveDateTime.convert(~N[2016-02-03 00:00:01], FakeCalendar) ==
+             {:error, :incompatible_calendars}
+
+    assert NaiveDateTime.convert(~N[1970-01-01 00:00:00], Calendar.Holocene) ==
+             {:ok, Calendar.Holocene.naive_datetime(11970, 1, 1, 0, 0, 0, {0, 0})}
+
+    assert NaiveDateTime.convert(DateTime.from_unix!(0, :second), Calendar.Holocene) ==
+             {:ok, Calendar.Holocene.naive_datetime(11970, 1, 1, 0, 0, 0, {0, 0})}
+  end
+
+  test "truncate/2" do
+    assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :microsecond) ==
+             ~N[2017-11-06 00:23:51.123456]
+
+    assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.0], :millisecond) ==
+             ~N[2017-11-06 00:23:51.0]
+
+    assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.999], :millisecond) ==
+             ~N[2017-11-06 00:23:51.999]
+
+    assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.1009], :millisecond) ==
+             ~N[2017-11-06 00:23:51.100]
+
+    assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :millisecond) ==
+             ~N[2017-11-06 00:23:51.123]
+
+    assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.000456], :millisecond) ==
+             ~N[2017-11-06 00:23:51.000]
+
+    assert NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :second) ==
+             ~N[2017-11-06 00:23:51]
+  end
+
+  test "truncate/2 with datetime" do
+    dt = %DateTime{
+      year: 2000,
+      month: 2,
+      day: 29,
+      zone_abbr: "CET",
+      hour: 23,
+      minute: 0,
+      second: 7,
+      microsecond: {3000, 6},
+      utc_offset: 3600,
+      std_offset: 0,
+      time_zone: "Europe/Warsaw"
+    }
+
+    assert NaiveDateTime.truncate(dt, :millisecond) == ~N[2000-02-29 23:00:07.003]
+    assert catch_error(NaiveDateTime.truncate(~T[00:00:00.000000], :millisecond))
+  end
+
+  describe "utc_now/1" do
+    test "utc_now/1 with default calendar (ISO)" do
+      naive_datetime = NaiveDateTime.utc_now()
+      assert naive_datetime.year >= 2019
+    end
+
+    test "utc_now/1 with alternative calendar" do
+      naive_datetime = NaiveDateTime.utc_now(Calendar.Holocene)
+      assert naive_datetime.calendar == Calendar.Holocene
+      assert naive_datetime.year >= 12019
+    end
+  end
+
+  describe "local_now/1" do
+    test "local_now/1 with default calendar (ISO)" do
+      naive_datetime = NaiveDateTime.local_now()
+      assert naive_datetime.year >= 2018
+    end
+
+    test "local_now/1 alternative calendar" do
+      naive_datetime = NaiveDateTime.local_now(Calendar.Holocene)
+      assert naive_datetime.calendar == Calendar.Holocene
+      assert naive_datetime.year >= 12018
+    end
+
+    test "local_now/1 incompatible calendar" do
+      assert_raise ArgumentError,
+                   ~s(cannot get "local now" in target calendar FakeCalendar, reason: cannot convert from Calendar.ISO to FakeCalendar.),
+                   fn ->
+                     NaiveDateTime.local_now(FakeCalendar)
+                   end
+    end
+  end
+
+  describe "to_date/2" do
+    test "downcasting" do
+      dt = %DateTime{
+        year: 2000,
+        month: 2,
+        day: 29,
+        zone_abbr: "CET",
+        hour: 23,
+        minute: 0,
+        second: 7,
+        microsecond: {3000, 6},
+        utc_offset: 3600,
+        std_offset: 0,
+        time_zone: "Europe/Warsaw"
+      }
+
+      assert NaiveDateTime.to_date(dt) == ~D[2000-02-29]
+    end
+
+    test "upcasting" do
+      assert catch_error(NaiveDateTime.to_date(~D[2000-02-29]))
+    end
+  end
+
+  describe "to_time/2" do
+    test "downcasting" do
+      dt = %DateTime{
+        year: 2000,
+        month: 2,
+        day: 29,
+        zone_abbr: "CET",
+        hour: 23,
+        minute: 0,
+        second: 7,
+        microsecond: {3000, 6},
+        utc_offset: 3600,
+        std_offset: 0,
+        time_zone: "Europe/Warsaw"
+      }
+
+      assert NaiveDateTime.to_time(dt) == ~T[23:00:07.003000]
+    end
+
+    test "upcasting" do
+      assert catch_error(NaiveDateTime.to_time(~T[00:00:00.000000]))
+    end
+  end
+
+  describe "beginning_of_day/1" do
+    test "precision" do
+      assert NaiveDateTime.beginning_of_day(~N[2000-01-01 23:00:07.123]) ==
+               ~N[2000-01-01 00:00:00.000]
+
+      assert NaiveDateTime.beginning_of_day(~N[2000-01-01 23:00:07]) == ~N[2000-01-01 00:00:00]
+    end
+  end
+
+  describe "end_of_day/1" do
+    test "precision" do
+      assert NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07.1]) == ~N[2000-01-01 23:59:59.9]
+      assert NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07.123]) == ~N[2000-01-01 23:59:59.999]
+
+      assert NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07.12345]) ==
+               ~N[2000-01-01 23:59:59.99999]
+
+      assert NaiveDateTime.end_of_day(~N[2000-01-01 23:00:07]) == ~N[2000-01-01 23:59:59]
+    end
+  end
+
+  test "shift/2" do
+    naive_datetime = ~N[2000-01-01 00:00:00]
+    assert NaiveDateTime.shift(naive_datetime, year: 1) == ~N[2001-01-01 00:00:00]
+    assert NaiveDateTime.shift(naive_datetime, month: 1) == ~N[2000-02-01 00:00:00]
+    assert NaiveDateTime.shift(naive_datetime, week: 3) == ~N[2000-01-22 00:00:00]
+    assert NaiveDateTime.shift(naive_datetime, day: 2) == ~N[2000-01-03 00:00:00]
+    assert NaiveDateTime.shift(naive_datetime, hour: 6) == ~N[2000-01-01 06:00:00]
+    assert NaiveDateTime.shift(naive_datetime, minute: 30) == ~N[2000-01-01 00:30:00]
+    assert NaiveDateTime.shift(naive_datetime, second: 45) == ~N[2000-01-01 00:00:45]
+    assert NaiveDateTime.shift(naive_datetime, year: -1) == ~N[1999-01-01 00:00:00]
+    assert NaiveDateTime.shift(naive_datetime, month: -1) == ~N[1999-12-01 00:00:00]
+    assert NaiveDateTime.shift(naive_datetime, week: -1) == ~N[1999-12-25 00:00:00]
+    assert NaiveDateTime.shift(naive_datetime, day: -1) == ~N[1999-12-31 00:00:00]
+    assert NaiveDateTime.shift(naive_datetime, hour: -12) == ~N[1999-12-31 12:00:00]
+    assert NaiveDateTime.shift(naive_datetime, minute: -45) == ~N[1999-12-31 23:15:00]
+    assert NaiveDateTime.shift(naive_datetime, second: -30) == ~N[1999-12-31 23:59:30]
+    assert NaiveDateTime.shift(naive_datetime, year: 1, month: 2) == ~N[2001-03-01 00:00:00]
+
+    assert NaiveDateTime.shift(naive_datetime, microsecond: {-500, 6}) ==
+             ~N[1999-12-31 23:59:59.999500]
+
+    assert NaiveDateTime.shift(naive_datetime, microsecond: {500, 6}) ==
+             ~N[2000-01-01 00:00:00.000500]
+
+    assert NaiveDateTime.shift(naive_datetime, microsecond: {100, 6}) ==
+             ~N[2000-01-01 00:00:00.000100]
+
+    assert NaiveDateTime.shift(naive_datetime, microsecond: {100, 4}) ==
+             ~N[2000-01-01 00:00:00.0001]
+
+    assert NaiveDateTime.shift(naive_datetime, month: 2, day: 3, hour: 6, minute: 15) ==
+             ~N[2000-03-04 06:15:00]
+
+    assert NaiveDateTime.shift(naive_datetime,
+             year: 1,
+             month: 2,
+             week: 3,
+             day: 4,
+             hour: 5,
+             minute: 6,
+             second: 7,
+             microsecond: {8, 6}
+           ) == ~N[2001-03-26 05:06:07.000008]
+
+    assert NaiveDateTime.shift(naive_datetime,
+             year: -1,
+             month: -2,
+             week: -3,
+             day: -4,
+             hour: -5,
+             minute: -6,
+             second: -7,
+             microsecond: {-8, 6}
+           ) == ~N[1998-10-06 18:53:52.999992]
+
+    assert_raise ArgumentError,
+                 "unknown unit :months. Expected :year, :month, :week, :day, :hour, :minute, :second, :microsecond",
+                 fn -> NaiveDateTime.shift(~N[2000-01-01 00:00:00], months: 12) end
+  end
+end
diff --git a/lib/elixir/test/elixir/calendar/time_test.exs b/lib/elixir/test/elixir/calendar/time_test.exs
new file mode 100644
index 00000000000..2818e755117
--- /dev/null
+++ b/lib/elixir/test/elixir/calendar/time_test.exs
@@ -0,0 +1,177 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file("holocene.exs", __DIR__)
+Code.require_file("fakes.exs", __DIR__)
+
+defmodule TimeTest do
+  use ExUnit.Case, async: true
+  doctest Time
+
+  test "sigil_T" do
+    assert ~T[12:34:56] ==
+             %Time{calendar: Calendar.ISO, hour: 12, minute: 34, second: 56}
+
+    assert ~T[12:34:56 Calendar.Holocene] ==
+             %Time{calendar: Calendar.Holocene, hour: 12, minute: 34, second: 56}
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "12:34:65" as Time for Calendar.ISO, reason: :invalid_time/,
+                 fn -> Code.eval_string("~T[12:34:65]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "123456" as Time for Calendar.ISO, reason: :invalid_format/,
+                 fn -> Code.eval_string("~T[123456]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "12:34:56 notalias" as Time for Calendar.ISO, reason: :invalid_format/,
+                 fn -> Code.eval_string("~T[12:34:56 notalias]") end
+
+    assert_raise ArgumentError,
+                 ~s/cannot parse "12:34:65" as Time for Calendar.Holocene, reason: :invalid_time/,
+                 fn -> Code.eval_string("~T[12:34:65 Calendar.Holocene]") end
+
+    assert_raise UndefinedFunctionError, fn ->
+      Code.eval_string("~T[12:34:56 UnknownCalendar]")
+    end
+  end
+
+  test "to_iso8601/2" do
+    time1 = ~T[23:00:07.005]
+    assert Time.to_iso8601(time1) == "23:00:07.005"
+    assert Time.to_iso8601(Map.from_struct(time1)) == "23:00:07.005"
+    assert Time.to_iso8601(time1, :basic) == "230007.005"
+
+    time2 = ~T[23:00:07.005 Calendar.Holocene]
+    assert Time.to_iso8601(time2) == "23:00:07.005"
+    assert Time.to_iso8601(Map.from_struct(time2)) == "23:00:07.005"
+    assert Time.to_iso8601(time2, :basic) == "230007.005"
+  end
+
+  test "to_string/1" do
+    time = ~T[23:00:07.005]
+    assert to_string(time) == "23:00:07.005"
+    assert Time.to_string(time) == "23:00:07.005"
+    assert Time.to_string(Map.from_struct(time)) == "23:00:07.005"
+
+    assert to_string(%{time | calendar: FakeCalendar}) == "23::0::7"
+    assert Time.to_string(%{time | calendar: FakeCalendar}) == "23::0::7"
+  end
+
+  test "inspect/1" do
+    assert inspect(~T[23:00:07.005]) == "~T[23:00:07.005]"
+
+    time = %{~T[23:00:07.005] | calendar: FakeCalendar}
+    assert inspect(time) == "~T[23::0::7 FakeCalendar]"
+  end
+
+  test "compare/2" do
+    time0 = ~T[01:01:01.0]
+    time1 = ~T[01:01:01.005]
+    time2 = ~T[01:01:01.0050]
+    time3 = ~T[23:01:01.0050]
+    assert Time.compare(time0, time1) == :lt
+    assert Time.compare(time1, time1) == :eq
+    assert Time.compare(time1, time2) == :eq
+    assert Time.compare(time1, time3) == :lt
+    assert Time.compare(time3, time2) == :gt
+
+    time1_holocene = ~T[01:01:01.005 Calendar.Holocene]
+    assert Time.compare(time1_holocene, time1) == :eq
+    assert Time.compare(time1_holocene, time2) == :eq
+    assert Time.compare(time1_holocene, time3) == :lt
+  end
+
+  test "before?/2 and after?/2" do
+    time1 = ~T[05:02:01.234]
+    time2 = ~T[10:00:04.123]
+
+    assert Time.before?(time1, time2)
+    assert not Time.before?(time2, time1)
+
+    assert Time.after?(time2, time1)
+    assert not Time.after?(time1, time2)
+  end
+
+  test "diff/3" do
+    time1 = ~T[05:02:01.234]
+    time2 = ~T[10:00:04.123]
+    time1_holocene = ~T[05:02:01.234 Calendar.Holocene]
+
+    assert Time.diff(time1, time2) == -17883
+    assert Time.diff(time1, time2, :hour) == -4
+    assert Time.diff(time1, time2, :minute) == -298
+    assert Time.diff(time1, time2, :second) == -17883
+    assert Time.diff(time1, time2, :millisecond) == -17_882_889
+    assert Time.diff(time1, time2, :microsecond) == -17_882_889_000
+
+    assert Time.diff(time1_holocene, time2) == -17883
+    assert Time.diff(time1_holocene, time2, :hour) == -4
+    assert Time.diff(time1_holocene, time2, :minute) == -298
+    assert Time.diff(time1_holocene, time2, :second) == -17883
+    assert Time.diff(time1_holocene, time2, :millisecond) == -17_882_889
+    assert Time.diff(time1_holocene, time2, :microsecond) == -17_882_889_000
+  end
+
+  test "truncate/2" do
+    assert Time.truncate(~T[01:01:01.123456], :microsecond) == ~T[01:01:01.123456]
+
+    assert Time.truncate(~T[01:01:01.0], :millisecond) == ~T[01:01:01.0]
+    assert Time.truncate(~T[01:01:01.00], :millisecond) == ~T[01:01:01.00]
+    assert Time.truncate(~T[01:01:01.1], :millisecond) == ~T[01:01:01.1]
+    assert Time.truncate(~T[01:01:01.100], :millisecond) == ~T[01:01:01.100]
+    assert Time.truncate(~T[01:01:01.999], :millisecond) == ~T[01:01:01.999]
+    assert Time.truncate(~T[01:01:01.1000], :millisecond) == ~T[01:01:01.100]
+    assert Time.truncate(~T[01:01:01.1001], :millisecond) == ~T[01:01:01.100]
+    assert Time.truncate(~T[01:01:01.123456], :millisecond) == ~T[01:01:01.123]
+    assert Time.truncate(~T[01:01:01.000123], :millisecond) == ~T[01:01:01.000]
+    assert Time.truncate(~T[01:01:01.00012], :millisecond) == ~T[01:01:01.000]
+
+    assert Time.truncate(~T[01:01:01.123456], :second) == ~T[01:01:01]
+  end
+
+  test "add/3" do
+    time = ~T[00:00:00.0]
+
+    assert Time.add(time, 1, :hour) == ~T[01:00:00.0]
+
+    assert Time.add(time, 1, 10) == ~T[00:00:00.100000]
+
+    assert_raise ArgumentError, ~r/Expected :hour, :minute, :second/, fn ->
+      Time.add(time, 1, 0)
+    end
+  end
+
+  test "shift/2" do
+    time = ~T[00:00:00.0]
+    assert Time.shift(time, hour: 1) == ~T[01:00:00.0]
+    assert Time.shift(time, hour: 25) == ~T[01:00:00.0]
+    assert Time.shift(time, minute: 25) == ~T[00:25:00.0]
+    assert Time.shift(time, second: 50) == ~T[00:00:50.0]
+    assert Time.shift(time, microsecond: {150, 6}) == ~T[00:00:00.000150]
+    assert Time.shift(time, microsecond: {1000, 4}) == ~T[00:00:00.0010]
+    assert Time.shift(time, hour: 2, minute: 65, second: 5) == ~T[03:05:05.0]
+
+    assert_raise ArgumentError,
+                 "unsupported unit :day. Expected :hour, :minute, :second, :microsecond",
+                 fn -> Time.shift(time, day: 1) end
+
+    assert_raise ArgumentError,
+                 "unknown unit :hours. Expected :hour, :minute, :second, :microsecond",
+                 fn -> Time.shift(time, hours: 12) end
+
+    assert_raise ArgumentError,
+                 "cannot shift time by date scale unit. Expected :hour, :minute, :second, :microsecond",
+                 fn -> Time.shift(time, %Duration{day: 1}) end
+
+    assert_raise ArgumentError,
+                 "unsupported value nil for :minute. Expected an integer",
+                 fn -> Time.shift(time, minute: nil) end
+
+    assert_raise ArgumentError,
+                 ~r/unsupported value 1 for :microsecond. Expected a tuple \{ms, precision\}/,
+                 fn -> Time.shift(time, microsecond: 1) end
+  end
+end
diff --git a/lib/elixir/test/elixir/calendar_test.exs b/lib/elixir/test/elixir/calendar_test.exs
new file mode 100644
index 00000000000..c812f311ac1
--- /dev/null
+++ b/lib/elixir/test/elixir/calendar_test.exs
@@ -0,0 +1,450 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule CalendarTest do
+  use ExUnit.Case, async: true
+  doctest Calendar
+
+  describe "strftime/3" do
+    test "returns received string if there is no datetime formatting to be found in it" do
+      assert Calendar.strftime(~N[2019-08-20 15:47:34.001], "same string") == "same string"
+    end
+
+    test "formats all time zones blank when receiving a NaiveDateTime" do
+      assert Calendar.strftime(~N[2019-08-15 17:07:57.001], "%z%Z") == ""
+    end
+
+    test "raises error when trying to format a date with a map that has no date fields" do
+      time_without_date = %{hour: 15, minute: 47, second: 34, microsecond: {0, 0}}
+
+      assert_raise KeyError, fn -> Calendar.strftime(time_without_date, "%x") end
+    end
+
+    test "raises error when trying to format a time with a map that has no time fields" do
+      date_without_time = %{year: 2019, month: 8, day: 20}
+
+      assert_raise KeyError, fn -> Calendar.strftime(date_without_time, "%X") end
+    end
+
+    test "raises error when the format is invalid" do
+      assert_raise ArgumentError, "invalid strftime format: %-", fn ->
+        Calendar.strftime(~N[2019-08-20 15:47:34.001], "%-2-ç")
+      end
+
+      assert_raise ArgumentError, "invalid strftime format: %", fn ->
+        Calendar.strftime(~N[2019-08-20 15:47:34.001], "%")
+      end
+    end
+
+    test "raises error when the preferred_datetime calls itself" do
+      assert_raise ArgumentError, fn ->
+        Calendar.strftime(~N[2019-08-20 15:47:34.001], "%c", preferred_datetime: "%c")
+      end
+    end
+
+    test "raises error when the preferred_date calls itself" do
+      assert_raise ArgumentError, fn ->
+        Calendar.strftime(~N[2019-08-20 15:47:34.001], "%x", preferred_date: "%x")
+      end
+    end
+
+    test "raises error when the preferred_time calls itself" do
+      assert_raise ArgumentError, fn ->
+        Calendar.strftime(~N[2019-08-20 15:47:34.001], "%X", preferred_time: "%X")
+      end
+    end
+
+    test "raises error when the preferred formats creates a circular chain" do
+      assert_raise ArgumentError, fn ->
+        Calendar.strftime(~N[2019-08-20 15:47:34.001], "%c",
+          preferred_datetime: "%x",
+          preferred_date: "%X",
+          preferred_time: "%c"
+        )
+      end
+    end
+
+    test "with preferred formats are included multiple times on the same string" do
+      assert Calendar.strftime(~N[2019-08-15 17:07:57.001], "%c %c %x %x %X %X") ==
+               "2019-08-15 17:07:57 2019-08-15 17:07:57 2019-08-15 2019-08-15 17:07:57 17:07:57"
+    end
+
+    test "`-` removes padding" do
+      assert Calendar.strftime(~D[2019-01-01], "%-j") == "1"
+      assert Calendar.strftime(~T[17:07:57.001], "%-999M") == "7"
+    end
+
+    test "formats time zones correctly when receiving a DateTime" do
+      datetime_with_zone = %DateTime{
+        year: 2019,
+        month: 8,
+        day: 15,
+        zone_abbr: "EEST",
+        hour: 17,
+        minute: 7,
+        second: 57,
+        microsecond: {0, 0},
+        utc_offset: 7200,
+        std_offset: 3600,
+        time_zone: "UK"
+      }
+
+      assert Calendar.strftime(datetime_with_zone, "%z %Z") == "+0300 EEST"
+    end
+
+    test "formats AM and PM correctly on the %P and %p options" do
+      am_time_almost_pm = ~U[2019-08-26 11:59:59.001Z]
+      pm_time = ~U[2019-08-26 12:00:57.001Z]
+      pm_time_almost_am = ~U[2019-08-26 23:59:57.001Z]
+      am_time = ~U[2019-08-26 00:00:01.001Z]
+
+      assert Calendar.strftime(am_time_almost_pm, "%P %p") == "am AM"
+      assert Calendar.strftime(pm_time, "%P %p") == "pm PM"
+      assert Calendar.strftime(pm_time_almost_am, "%P %p") == "pm PM"
+      assert Calendar.strftime(am_time, "%P %p") == "am AM"
+    end
+
+    test "formats all weekdays correctly with %A and %a formats" do
+      sunday = ~U[2019-08-25 11:59:59.001Z]
+      monday = ~U[2019-08-26 11:59:59.001Z]
+      tuesday = ~U[2019-08-27 11:59:59.001Z]
+      wednesday = ~U[2019-08-28 11:59:59.001Z]
+      thursday = ~U[2019-08-29 11:59:59.001Z]
+      friday = ~U[2019-08-30 11:59:59.001Z]
+      saturday = ~U[2019-08-31 11:59:59.001Z]
+
+      assert Calendar.strftime(sunday, "%A %a") == "Sunday Sun"
+      assert Calendar.strftime(monday, "%A %a") == "Monday Mon"
+      assert Calendar.strftime(tuesday, "%A %a") == "Tuesday Tue"
+      assert Calendar.strftime(wednesday, "%A %a") == "Wednesday Wed"
+      assert Calendar.strftime(thursday, "%A %a") == "Thursday Thu"
+      assert Calendar.strftime(friday, "%A %a") == "Friday Fri"
+      assert Calendar.strftime(saturday, "%A %a") == "Saturday Sat"
+    end
+
+    test "formats all months correctly with the %B and %b formats" do
+      assert Calendar.strftime(%{month: 1}, "%B %b") == "January Jan"
+      assert Calendar.strftime(%{month: 2}, "%B %b") == "February Feb"
+      assert Calendar.strftime(%{month: 3}, "%B %b") == "March Mar"
+      assert Calendar.strftime(%{month: 4}, "%B %b") == "April Apr"
+      assert Calendar.strftime(%{month: 5}, "%B %b") == "May May"
+      assert Calendar.strftime(%{month: 6}, "%B %b") == "June Jun"
+      assert Calendar.strftime(%{month: 7}, "%B %b") == "July Jul"
+      assert Calendar.strftime(%{month: 8}, "%B %b") == "August Aug"
+      assert Calendar.strftime(%{month: 9}, "%B %b") == "September Sep"
+      assert Calendar.strftime(%{month: 10}, "%B %b") == "October Oct"
+      assert Calendar.strftime(%{month: 11}, "%B %b") == "November Nov"
+      assert Calendar.strftime(%{month: 12}, "%B %b") == "December Dec"
+    end
+
+    test "formats all weekdays correctly on %A with day_of_week_names option" do
+      sunday = ~U[2019-08-25 11:59:59.001Z]
+      monday = ~U[2019-08-26 11:59:59.001Z]
+      tuesday = ~U[2019-08-27 11:59:59.001Z]
+      wednesday = ~U[2019-08-28 11:59:59.001Z]
+      thursday = ~U[2019-08-29 11:59:59.001Z]
+      friday = ~U[2019-08-30 11:59:59.001Z]
+      saturday = ~U[2019-08-31 11:59:59.001Z]
+
+      day_of_week_names = fn day_of_week ->
+        {"segunda-feira", "terça-feira", "quarta-feira", "quinta-feira", "sexta-feira", "sábado",
+         "domingo"}
+        |> elem(day_of_week - 1)
+      end
+
+      assert Calendar.strftime(sunday, "%A", day_of_week_names: day_of_week_names) ==
+               "domingo"
+
+      assert Calendar.strftime(monday, "%A", day_of_week_names: day_of_week_names) ==
+               "segunda-feira"
+
+      assert Calendar.strftime(tuesday, "%A", day_of_week_names: day_of_week_names) ==
+               "terça-feira"
+
+      assert Calendar.strftime(wednesday, "%A", day_of_week_names: day_of_week_names) ==
+               "quarta-feira"
+
+      assert Calendar.strftime(thursday, "%A", day_of_week_names: day_of_week_names) ==
+               "quinta-feira"
+
+      assert Calendar.strftime(friday, "%A", day_of_week_names: day_of_week_names) ==
+               "sexta-feira"
+
+      assert Calendar.strftime(saturday, "%A", day_of_week_names: day_of_week_names) ==
+               "sábado"
+    end
+
+    test "formats all months correctly on the %B with month_names option" do
+      month_names = fn month ->
+        {"январь", "февраль", "март", "апрель", "май", "июнь", "июль", "август", "сентябрь",
+         "октябрь", "ноябрь", "декабрь"}
+        |> elem(month - 1)
+      end
+
+      assert Calendar.strftime(%{month: 1}, "%B", month_names: month_names) == "январь"
+      assert Calendar.strftime(%{month: 2}, "%B", month_names: month_names) == "февраль"
+      assert Calendar.strftime(%{month: 3}, "%B", month_names: month_names) == "март"
+      assert Calendar.strftime(%{month: 4}, "%B", month_names: month_names) == "апрель"
+      assert Calendar.strftime(%{month: 5}, "%B", month_names: month_names) == "май"
+      assert Calendar.strftime(%{month: 6}, "%B", month_names: month_names) == "июнь"
+      assert Calendar.strftime(%{month: 7}, "%B", month_names: month_names) == "июль"
+      assert Calendar.strftime(%{month: 8}, "%B", month_names: month_names) == "август"
+      assert Calendar.strftime(%{month: 9}, "%B", month_names: month_names) == "сентябрь"
+      assert Calendar.strftime(%{month: 10}, "%B", month_names: month_names) == "октябрь"
+      assert Calendar.strftime(%{month: 11}, "%B", month_names: month_names) == "ноябрь"
+      assert Calendar.strftime(%{month: 12}, "%B", month_names: month_names) == "декабрь"
+    end
+
+    test "formats all weekdays correctly on the %a format with abbreviated_day_of_week_names option" do
+      sunday = ~U[2019-08-25 11:59:59.001Z]
+      monday = ~U[2019-08-26 11:59:59.001Z]
+      tuesday = ~U[2019-08-27 11:59:59.001Z]
+      wednesday = ~U[2019-08-28 11:59:59.001Z]
+      thursday = ~U[2019-08-29 11:59:59.001Z]
+      friday = ~U[2019-08-30 11:59:59.001Z]
+      saturday = ~U[2019-08-31 11:59:59.001Z]
+
+      abbreviated_day_of_week_names = fn day_of_week ->
+        {"seg", "ter", "qua", "qui", "sex", "sáb", "dom"}
+        |> elem(day_of_week - 1)
+      end
+
+      assert Calendar.strftime(sunday, "%a",
+               abbreviated_day_of_week_names: abbreviated_day_of_week_names
+             ) == "dom"
+
+      assert Calendar.strftime(monday, "%a",
+               abbreviated_day_of_week_names: abbreviated_day_of_week_names
+             ) == "seg"
+
+      assert Calendar.strftime(tuesday, "%a",
+               abbreviated_day_of_week_names: abbreviated_day_of_week_names
+             ) == "ter"
+
+      assert Calendar.strftime(wednesday, "%a",
+               abbreviated_day_of_week_names: abbreviated_day_of_week_names
+             ) == "qua"
+
+      assert Calendar.strftime(thursday, "%a",
+               abbreviated_day_of_week_names: abbreviated_day_of_week_names
+             ) == "qui"
+
+      assert Calendar.strftime(friday, "%a",
+               abbreviated_day_of_week_names: abbreviated_day_of_week_names
+             ) == "sex"
+
+      assert Calendar.strftime(saturday, "%a",
+               abbreviated_day_of_week_names: abbreviated_day_of_week_names
+             ) == "sáb"
+    end
+
+    test "formats all months correctly on the %b format with abbreviated_month_names option" do
+      abbreviated_month_names = fn month ->
+        {"янв", "февр", "март", "апр", "май", "июнь", "июль", "авг", "сент", "окт", "нояб", "дек"}
+        |> elem(month - 1)
+      end
+
+      assert Calendar.strftime(%{month: 1}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) ==
+               "янв"
+
+      assert Calendar.strftime(%{month: 2}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) ==
+               "февр"
+
+      assert Calendar.strftime(%{month: 3}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) ==
+               "март"
+
+      assert Calendar.strftime(%{month: 4}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) ==
+               "апр"
+
+      assert Calendar.strftime(%{month: 5}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) ==
+               "май"
+
+      assert Calendar.strftime(%{month: 6}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) ==
+               "июнь"
+
+      assert Calendar.strftime(%{month: 7}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) ==
+               "июль"
+
+      assert Calendar.strftime(%{month: 8}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) ==
+               "авг"
+
+      assert Calendar.strftime(%{month: 9}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) ==
+               "сент"
+
+      assert Calendar.strftime(%{month: 10}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) == "окт"
+
+      assert Calendar.strftime(%{month: 11}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) == "нояб"
+
+      assert Calendar.strftime(%{month: 12}, "%b",
+               abbreviated_month_names: abbreviated_month_names
+             ) == "дек"
+    end
+
+    test "formats ignores padding and width options on microseconds" do
+      datetime = ~U[2019-08-15 17:07:57.001234Z]
+      assert Calendar.strftime(datetime, "%f") == "001234"
+      assert Calendar.strftime(datetime, "%f") == Calendar.strftime(datetime, "%_20f")
+      assert Calendar.strftime(datetime, "%f") == Calendar.strftime(datetime, "%020f")
+      assert Calendar.strftime(datetime, "%f") == Calendar.strftime(datetime, "%-f")
+    end
+
+    test "formats properly dates with different microsecond precisions" do
+      assert Calendar.strftime(~U[2019-08-15 17:07:57.5Z], "%f") == "5"
+      assert Calendar.strftime(~U[2019-08-15 17:07:57.45Z], "%f") == "45"
+      assert Calendar.strftime(~U[2019-08-15 17:07:57.345Z], "%f") == "345"
+      assert Calendar.strftime(~U[2019-08-15 17:07:57.2345Z], "%f") == "2345"
+      assert Calendar.strftime(~U[2019-08-15 17:07:57.12345Z], "%f") == "12345"
+      assert Calendar.strftime(~U[2019-08-15 17:07:57.012345Z], "%f") == "012345"
+    end
+
+    test "formats properly different microsecond precisions of zero" do
+      assert Calendar.strftime(~N[2019-08-15 17:07:57.0], "%f") == "0"
+      assert Calendar.strftime(~N[2019-08-15 17:07:57.00], "%f") == "00"
+      assert Calendar.strftime(~N[2019-08-15 17:07:57.000], "%f") == "000"
+      assert Calendar.strftime(~N[2019-08-15 17:07:57.0000], "%f") == "0000"
+      assert Calendar.strftime(~N[2019-08-15 17:07:57.00000], "%f") == "00000"
+      assert Calendar.strftime(~N[2019-08-15 17:07:57.000000], "%f") == "000000"
+    end
+
+    test "returns a single zero if there's no microseconds precision" do
+      assert Calendar.strftime(~N[2019-08-15 17:07:57], "%f") == "0"
+    end
+
+    test "handles `0` both as padding and as part of a width" do
+      assert Calendar.strftime(~N[2019-08-15 17:07:57], "%10A") == "  Thursday"
+      assert Calendar.strftime(~N[2019-08-15 17:07:57], "%010A") == "00Thursday"
+    end
+
+    test "formats Epoch time with %s" do
+      assert Calendar.strftime(~N[2019-08-15 17:07:57], "%s") == "1565888877"
+
+      datetime = %DateTime{
+        year: 2019,
+        month: 8,
+        day: 15,
+        hour: 17,
+        minute: 7,
+        second: 57,
+        microsecond: {0, 0},
+        time_zone: "Europe/Berlin",
+        zone_abbr: "CET",
+        utc_offset: 3600,
+        std_offset: 0
+      }
+
+      assert Calendar.strftime(datetime, "%s") == "1565885277"
+    end
+
+    test "formats datetime with all options and modifiers" do
+      assert Calendar.strftime(
+               ~U[2019-08-15 17:07:57.001Z],
+               "%04% %a %A %b %B %-3c %d %f %H %I %j %m %_5M %p %P %q %S %u %x %X %y %Y %z %Z"
+             ) ==
+               "000% Thu Thursday Aug August 2019-08-15 17:07:57 15 001 17 05 227 08     7 PM pm 3 57 4 2019-08-15 17:07:57 19 2019 +0000 UTC"
+    end
+
+    test "formats according to custom configs" do
+      assert Calendar.strftime(
+               ~U[2019-08-15 17:07:57.001Z],
+               "%A %a %p %B %b %c %x %X",
+               am_pm_names: fn
+                 :am -> "a"
+                 :pm -> "p"
+               end,
+               month_names: fn month ->
+                 {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto",
+                  "Setembro", "Outubro", "Novembro", "Dezembro"}
+                 |> elem(month - 1)
+               end,
+               day_of_week_names: fn day_of_week ->
+                 {"понедельник", "вторник", "среда", "четверг", "пятница", "суббота",
+                  "воскресенье"}
+                 |> elem(day_of_week - 1)
+               end,
+               abbreviated_month_names: fn month ->
+                 {"Jan", "Fev", "Mar", "Abr", "Mai", "Jun", "Jul", "Ago", "Set", "Out", "Nov",
+                  "Dez"}
+                 |> elem(month - 1)
+               end,
+               abbreviated_day_of_week_names: fn day_of_week ->
+                 {"ПНД", "ВТР", "СРД", "ЧТВ", "ПТН", "СБТ", "ВСК"}
+                 |> elem(day_of_week - 1)
+               end,
+               preferred_date: "%05Y-%m-%d",
+               preferred_time: "%M:%_3H%S",
+               preferred_datetime: "%%"
+             ) == "четверг ЧТВ P Agosto Ago % 02019-08-15 07: 1757"
+    end
+
+    test "formats according to custom configs with 2-arity functions" do
+      assert Calendar.strftime(
+               ~U[2019-08-15 17:07:57.001Z],
+               "%A %a %p %B %b %c %x %X",
+               am_pm_names: fn
+                 :am, ~U[2019-08-15 17:07:57.001Z] -> "a"
+                 :pm, ~U[2019-08-15 17:07:57.001Z] -> "p"
+               end,
+               month_names: fn month, ~U[2019-08-15 17:07:57.001Z] ->
+                 {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto",
+                  "Setembro", "Outubro", "Novembro", "Dezembro"}
+                 |> elem(month - 1)
+               end,
+               day_of_week_names: fn day_of_week, ~U[2019-08-15 17:07:57.001Z] ->
+                 {"понедельник", "вторник", "среда", "четверг", "пятница", "суббота",
+                  "воскресенье"}
+                 |> elem(day_of_week - 1)
+               end,
+               abbreviated_month_names: fn month, ~U[2019-08-15 17:07:57.001Z] ->
+                 {"Jan", "Fev", "Mar", "Abr", "Mai", "Jun", "Jul", "Ago", "Set", "Out", "Nov",
+                  "Dez"}
+                 |> elem(month - 1)
+               end,
+               abbreviated_day_of_week_names: fn day_of_week, ~U[2019-08-15 17:07:57.001Z] ->
+                 {"ПНД", "ВТР", "СРД", "ЧТВ", "ПТН", "СБТ", "ВСК"}
+                 |> elem(day_of_week - 1)
+               end,
+               preferred_date: "%05Y-%m-%d",
+               preferred_time: "%M:%_3H%S",
+               preferred_datetime: "%%"
+             ) == "четверг ЧТВ P Agosto Ago % 02019-08-15 07: 1757"
+    end
+
+    test "raises on unknown option according to custom configs" do
+      assert_raise ArgumentError, "unknown option :unknown given to Calendar.strftime/3", fn ->
+        Calendar.strftime(~D[2019-08-15], "%D", unknown: "option")
+      end
+    end
+
+    test "zero padding for negative year" do
+      assert Calendar.strftime(Date.new!(-1, 1, 1), "%Y") == "-0001"
+      assert Calendar.strftime(Date.new!(-11, 1, 1), "%Y") == "-0011"
+      assert Calendar.strftime(Date.new!(-111, 1, 1), "%Y") == "-0111"
+      assert Calendar.strftime(Date.new!(-1111, 1, 1), "%Y") == "-1111"
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/changelog_test.exs b/lib/elixir/test/elixir/changelog_test.exs
new file mode 100644
index 00000000000..9245d3de06e
--- /dev/null
+++ b/lib/elixir/test/elixir/changelog_test.exs
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+ExUnit.start()
+
+defmodule ChangelogTest do
+  use ExUnit.Case, async: true
+  doctest_file(Path.expand("../../../../CHANGELOG.md", __DIR__))
+end
diff --git a/lib/elixir/test/elixir/code_formatter/calls_test.exs b/lib/elixir/test/elixir/code_formatter/calls_test.exs
new file mode 100644
index 00000000000..61ef8c9148f
--- /dev/null
+++ b/lib/elixir/test/elixir/code_formatter/calls_test.exs
@@ -0,0 +1,1233 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Code.Formatter.CallsTest do
+  use ExUnit.Case, async: true
+
+  import CodeFormatterHelpers
+
+  @short_length [line_length: 10]
+  @medium_length [line_length: 20]
+
+  describe "next break fits" do
+    test "does not apply to function calls" do
+      bad = "foo(very_long_call(bar))"
+
+      good = """
+      foo(
+        very_long_call(
+          bar
+        )
+      )
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "does not apply to strings" do
+      bad = "foo(\"very long string\")"
+
+      good = """
+      foo(
+        "very long string"
+      )
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "for functions" do
+      assert_same """
+      foo(fn x -> y end)
+      """
+
+      assert_same """
+      foo(fn
+        a1 -> :ok
+        b2 -> :error
+      end)
+      """
+
+      assert_same """
+      foo(bar, fn
+        a1 -> :ok
+        b2 -> :error
+      end)
+      """
+
+      assert_same """
+                  foo(fn x ->
+                    :really_long_atom
+                  end)
+                  """,
+                  @medium_length
+
+      assert_same """
+                  foo(bar, fn
+                    a1 ->
+                      :ok
+
+                    b2 ->
+                      :really_long_error
+                  end)
+                  """,
+                  @medium_length
+    end
+
+    test "for heredocs" do
+      assert_same """
+      foo(~c'''
+      bar
+      ''')
+      """
+
+      assert_same ~S'''
+      foo("""
+      bar
+      """)
+      '''
+
+      assert_same """
+      foo(~S'''
+      bar
+      ''')
+      """
+
+      assert_same """
+                  foo(~S'''
+                  very long line does trigger another break
+                  ''')
+                  """,
+                  @short_length
+    end
+
+    test "for lists" do
+      bad = "foo([1, 2, 3, 4])"
+
+      good = """
+      foo([
+        1,
+        2,
+        3,
+        4
+      ])
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "for {} calls" do
+      bad = """
+      alias Foo.{
+              Bar, Baz
+            }
+      """
+
+      good = """
+      alias Foo.{
+        Bar,
+        Baz
+      }
+      """
+
+      assert_format bad, good, @medium_length
+    end
+
+    test "for binaries only on eol" do
+      bad = "foo(<<1, 2, 3, 4>>)"
+
+      good = """
+      foo(
+        <<1, 2,
+          3, 4>>
+      )
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = """
+      foo(<<
+        # foo
+        1,
+        2,
+        3,
+        4>>)
+      """
+
+      good = """
+      foo(<<
+        # foo
+        1,
+        2,
+        3,
+        4
+      >>)
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "for maps" do
+      assert_same "a(%{x: 1})", @short_length
+      assert_format "ab(%{x: 1})", "ab(%{\n  x: 1\n})", @short_length
+    end
+  end
+
+  describe "local calls" do
+    test "without arguments" do
+      assert_format "foo( )", "foo()"
+    end
+
+    test "without arguments doesn't split on line limit" do
+      assert_same "very_long_function_name()", @short_length
+    end
+
+    test "removes outer parens except for unquote_splicing/1" do
+      assert_format "(foo())", "foo()"
+      assert_same "(unquote_splicing(123))"
+    end
+
+    test "with arguments" do
+      assert_format "foo( :one ,:two,\n   :three)", "foo(:one, :two, :three)"
+    end
+
+    test "with arguments splits on line limit" do
+      bad = """
+      fun(x, y, z)
+      """
+
+      good = """
+      fun(
+        x,
+        y,
+        z
+      )
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with arguments on comma limit" do
+      bad = """
+      import(foo(abc, cde), :next)
+      """
+
+      good = """
+      import(
+        foo(abc, cde),
+        :next
+      )
+      """
+
+      assert_format bad, good, @medium_length
+    end
+
+    test "with keyword lists" do
+      assert_same "foo(foo: 1, bar: 2)"
+      assert_same "foo(:hello, foo: 1, bar: 2)"
+
+      bad = """
+      foo(:hello, foo: 1, bar: 2)
+      """
+
+      good = """
+      foo(
+        :hello,
+        foo: 1,
+        bar: 2
+      )
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = """
+      foo(:hello, foo: 1,
+        bar: 2, baz: 3)
+      """
+
+      assert_format bad, """
+      foo(:hello, foo: 1, bar: 2, baz: 3)
+      """
+    end
+
+    test "with lists maybe rewritten as keyword lists" do
+      assert_format "foo([foo: 1, bar: 2])", "foo(foo: 1, bar: 2)"
+      assert_format "foo(:arg, [foo: 1, bar: 2])", "foo(:arg, foo: 1, bar: 2)"
+      assert_same "foo(:arg, [:elem, foo: 1, bar: 2])"
+    end
+
+    test "without parens" do
+      assert_same "import :foo, :bar"
+      assert_same "bar = if foo, do: bar, else: baz"
+
+      assert_same """
+      for :one,
+          :two,
+          :three,
+          fn ->
+            :ok
+          end
+      """
+
+      assert_same """
+      for :one, fn ->
+        :ok
+      end
+      """
+    end
+
+    test "without parens on line limit" do
+      bad = "import :long_atom, :other_arg"
+
+      good = """
+      import :long_atom,
+             :other_arg
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "without parens on comma limit" do
+      bad = """
+      import foo(abc, cde), :next
+      """
+
+      good = """
+      import foo(
+               abc,
+               cde
+             ),
+             :next
+      """
+
+      assert_format bad, good, @medium_length
+    end
+
+    test "without parens and with keyword lists preserves multiline" do
+      assert_same """
+      defstruct foo: 1,
+                bar: 2
+      """
+
+      assert_same """
+      config :app,
+        foo: 1
+      """
+
+      assert_same """
+      config :app,
+        foo: 1,
+        bar: 2
+      """
+
+      assert_same """
+      config :app, :key,
+        foo: 1,
+        bar: 2
+      """
+
+      assert_same """
+      config :app,
+             :key,
+             foo: 1,
+             bar: 2
+      """
+
+      bad = """
+      config :app, foo: 1,
+        bar: 2
+      """
+
+      assert_format bad, """
+      config :app,
+        foo: 1,
+        bar: 2
+      """
+    end
+
+    test "without parens and with keyword lists on comma limit" do
+      bad = """
+      import foo(abc, cde), opts: :next
+      """
+
+      good = """
+      import foo(
+               abc,
+               cde
+             ),
+             opts: :next
+      """
+
+      assert_format bad, good, @medium_length
+    end
+
+    test "without parens and with keyword lists on line limit" do
+      assert_same "import :atom, opts: [foo: :bar]"
+
+      bad = "import :atom, opts: [foo: :bar]"
+
+      good = """
+      import :atom,
+        opts: [foo: :bar]
+      """
+
+      assert_format bad, good, @medium_length
+
+      bad = "import :atom, really_long_key: [foo: :bar]"
+
+      good = """
+      import :atom,
+        really_long_key: [
+          foo: :bar
+        ]
+      """
+
+      assert_format bad, good, @medium_length
+
+      assert_same """
+                  import :foo,
+                    one: two,
+                    three: four,
+                    five: [6, 7, 8, 9]
+                  """,
+                  @medium_length
+
+      assert_same """
+                  import :really_long_atom_but_no_breaks,
+                    one: two,
+                    three: four
+                  """,
+                  @medium_length
+
+      bad = "with :really_long_atom1, :really_long_atom2, opts: [foo: :bar]"
+
+      good = """
+      with :really_long_atom1,
+           :really_long_atom2,
+           opts: [
+             foo: :bar
+           ]
+      """
+
+      assert_format bad, good, @medium_length
+    end
+
+    test "without parens from option" do
+      assert_format "foo bar", "foo(bar)"
+      assert_same "foo bar", locals_without_parens: [foo: 1]
+      assert_same "foo(bar)", locals_without_parens: [foo: 1]
+      assert_same "foo bar", locals_without_parens: [foo: :*]
+      assert_same "foo(bar)", locals_without_parens: [foo: :*]
+    end
+
+    test "without parens on unique argument" do
+      assert_same "foo(for 1, 2, 3)"
+      assert_same "foo(bar, for(1, 2, 3))"
+      assert_same "assert for 1, 2, 3"
+      assert_same "assert foo, for(1, 2, 3)"
+
+      assert_same """
+      assert for 1, 2, 3 do
+        :ok
+      end
+      """
+
+      assert_same """
+      assert foo, for(1, 2, 3) do
+        :ok
+      end
+      """
+
+      assert_same """
+      assert for(1, 2, 3) do
+        :ok
+      end
+      """
+
+      assert_same """
+      assert (for 1, 2, 3 do
+                :ok
+              end)
+      """
+    end
+
+    test "call on call" do
+      assert_same "unquote(call)()"
+      assert_same "unquote(call)(one, two)"
+
+      assert_same """
+      unquote(call)() do
+        :ok
+      end
+      """
+
+      assert_same """
+      unquote(call)(one, two) do
+        :ok
+      end
+      """
+    end
+
+    test "call on call on line limit" do
+      bad = "foo(bar)(one, two, three)"
+
+      good = """
+      foo(bar)(
+        one,
+        two,
+        three
+      )
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with generators" do
+      assert_same "foo(bar <- baz, is_bat(bar))"
+      assert_same "for bar <- baz, is_bat(bar)"
+
+      assert_same """
+      foo(
+        bar <- baz,
+        is_bat(bar),
+        bat <- bar
+      )
+      """
+
+      assert_same """
+      for bar <- baz,
+          is_bat(bar),
+          bat <- bar
+      """
+
+      assert_same """
+      for bar <- baz,
+          is_bat(bar),
+          bat <- bar do
+        :ok
+      end
+      """
+
+      assert_same """
+      for bar <- baz,
+          is_bat(bar),
+          bat <- bar,
+          into: %{}
+      """
+    end
+
+    test "preserves user choice on parens even when it fits" do
+      assert_same """
+      call(
+        :hello,
+        :foo,
+        :bar
+      )
+      """
+
+      assert_same """
+      call(
+        :hello,
+        :foo,
+        :bar
+      ) do
+        1 + 2
+      end
+      """
+
+      # Doesn't preserve this because only the ending has a newline
+      assert_format "call(foo, bar, baz\n)", "call(foo, bar, baz)"
+
+      # Doesn't preserve because there are no args
+      bad = """
+      call() do
+        1 + 2
+      end
+      """
+
+      assert_format bad, """
+      call do
+        1 + 2
+      end
+      """
+
+      # Doesn't preserve because we have a single argument with next break fits
+      bad = """
+      call(
+        %{
+          key: :value
+        }
+      )
+      """
+
+      assert_format bad, """
+      call(%{
+        key: :value
+      })
+      """
+    end
+  end
+
+  describe "remote calls" do
+    test "with no arguments" do
+      assert_format "Foo . Bar . baz", "Foo.Bar.baz()"
+      assert_format ":erlang.\nget_stacktrace", ":erlang.get_stacktrace()"
+      assert_format "@foo.bar", "@foo.bar"
+      assert_format "@foo.bar()", "@foo.bar()"
+      assert_format "(@foo).bar()", "@foo.bar()"
+      assert_format "__MODULE__.start_link", "__MODULE__.start_link()"
+      assert_format "Foo.bar.baz.bong", "Foo.bar().baz.bong"
+      assert_format "(1 + 2).foo", "(1 + 2).foo"
+      assert_format "(1 + 2).foo()", "(1 + 2).foo()"
+    end
+
+    test "with arguments" do
+      assert_format "Foo . Bar. baz(1, 2, 3)", "Foo.Bar.baz(1, 2, 3)"
+      assert_format ":erlang.\nget(\n:some_key)", ":erlang.get(:some_key)"
+      assert_format ":erlang.\nget(:some_key\n)", ":erlang.get(:some_key)"
+      assert_same "@foo.bar(1, 2, 3)"
+      assert_same "__MODULE__.start_link(1, 2, 3)"
+      assert_same "foo.bar(1).baz(2, 3)"
+    end
+
+    test "inspects function names correctly" do
+      assert_same ~S[MyModule."my function"(1, 2)]
+      assert_same ~S[MyModule."Foo.Bar"(1, 2)]
+      assert_same ~S[Kernel.+(1, 2)]
+      assert_same ~S[:erlang.+(1, 2)]
+      assert_same ~S[foo."bar baz"(1, 2)]
+      assert_same ~S[foo."bar\nbaz"(1, 2)]
+    end
+
+    test "splits on arguments and dot on line limit" do
+      bad = """
+      MyModule.Foo.bar(:one, :two, :three)
+      """
+
+      good = """
+      MyModule.Foo.bar(
+        :one,
+        :two,
+        :three
+      )
+      """
+
+      assert_format bad, good, @medium_length
+
+      bad = """
+      My_function.foo().bar(2, 3).baz(4, 5)
+      """
+
+      good = """
+      My_function.foo().bar(
+        2,
+        3
+      ).baz(4, 5)
+      """
+
+      assert_format bad, good, @medium_length
+    end
+
+    test "doesn't split on parens on empty arguments" do
+      assert_same "Mod.func()", @short_length
+    end
+
+    test "with keyword lists" do
+      assert_same "mod.foo(foo: 1, bar: 2)"
+
+      assert_same "mod.foo(:hello, foo: 1, bar: 2)"
+
+      assert_same """
+                  mod.really_long_function_name(
+                    :hello,
+                    foo: 1,
+                    bar: 2
+                  )
+                  """,
+                  @short_length
+
+      assert_same """
+                  really_long_module_name.foo(
+                    :hello,
+                    foo: 1,
+                    bar: 2
+                  )
+                  """,
+                  @short_length
+    end
+
+    test "wraps left side in parens if it is an anonymous function" do
+      assert_same "(fn -> :ok end).foo"
+    end
+
+    test "wraps left side in parens if it is a do-end block" do
+      assert_same """
+      (if true do
+         :ok
+       end).foo
+      """
+    end
+
+    test "wraps left side in parens if it is a do-end block as an argument" do
+      assert_same """
+      import (if true do
+                :ok
+              end).foo
+      """
+    end
+
+    test "call on call" do
+      assert_same "foo.bar(call)()"
+      assert_same "foo.bar(call)(one, two)"
+
+      assert_same """
+      foo.bar(call)() do
+      end
+      """
+
+      assert_same """
+      foo.bar(call)(one, two) do
+        :ok
+      end
+      """
+    end
+
+    test "call on call on line limit" do
+      bad = "a.b(foo)(one, two, three)"
+
+      good = """
+      a.b(foo)(
+        one,
+        two,
+        three
+      )
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "on vars" do
+      assert_same "foo.bar"
+      assert_same "foo.bar()"
+    end
+
+    test "on vars before blocks" do
+      assert_same """
+      if var.field do
+        raise "oops"
+      end
+      """
+    end
+
+    test "on vars before brackets" do
+      assert_same """
+      exception.opts[:foo]
+      """
+    end
+
+    test "preserves user choice on parens even when it fits" do
+      assert_same """
+      Remote.call(
+        :hello,
+        :foo,
+        :bar
+      )
+      """
+
+      # Doesn't preserve this because only the ending has a newline
+      assert_format "Remote.call(foo, bar, baz\n)", "Remote.call(foo, bar, baz)"
+
+      assert_same """
+      Remote.call(
+        :hello,
+        :foo,
+        fn -> :bar end
+      )
+      """
+    end
+  end
+
+  describe "anonymous function calls" do
+    test "without arguments" do
+      assert_format "foo . ()", "foo.()"
+      assert_format "(foo.()).().()", "foo.().().()"
+      assert_same "@foo.()"
+      assert_same "(1 + 1).()"
+      assert_same ":foo.()"
+    end
+
+    test "with arguments" do
+      assert_format "foo . (1, 2  ,  3 )", "foo.(1, 2, 3)"
+      assert_format "foo . (1, 2 ).(3,4)", "foo.(1, 2).(3, 4)"
+      assert_same "@foo.(:one, :two)"
+      assert_same "foo.(1 + 1).(hello)"
+    end
+
+    test "does not split on dot on line limit" do
+      assert_same "my_function.()", @short_length
+    end
+
+    test "splits on arguments on line limit" do
+      bad = """
+      my_function.(1, 2, 3)
+      """
+
+      good = """
+      my_function.(
+        1,
+        2,
+        3
+      )
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = """
+      my_function.(1, 2).f(3, 4).(5, 6)
+      """
+
+      good = """
+      my_function.(
+        1,
+        2
+      ).f(3, 4).(
+        5,
+        6
+      )
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with keyword lists" do
+      assert_same "foo.(foo: 1, bar: 2)"
+
+      assert_same "foo.(:hello, foo: 1, bar: 2)"
+
+      assert_same """
+                  foo.(
+                    :hello,
+                    foo: 1,
+                    bar: 2
+                  )
+                  """,
+                  @short_length
+    end
+
+    test "wraps left side in parens if it is an anonymous function" do
+      assert_same "(fn -> :ok end).()"
+    end
+
+    test "wraps left side in parens if it is a do-end block" do
+      assert_same """
+      (if true do
+         :ok
+       end).()
+      """
+    end
+
+    test "wraps left side in parens if it is a do-end block as an argument" do
+      assert_same """
+      import (if true do
+                :ok
+              end).()
+      """
+    end
+
+    test "preserves user choice on parens even when it fits" do
+      assert_same """
+      call.(
+        :hello,
+        :foo,
+        :bar
+      )
+      """
+
+      # Doesn't preserve this because only the ending has a newline
+      assert_format "call.(foo, bar, baz\n)", "call.(foo, bar, baz)"
+    end
+  end
+
+  describe "do-end blocks" do
+    test "with non-block keywords" do
+      assert_same "foo(do: nil)"
+    end
+
+    test "with forced block keywords" do
+      good = """
+      foo do
+        nil
+      end
+      """
+
+      assert_format "foo(do: nil)", good, force_do_end_blocks: true
+
+      # Avoid false positives
+      assert_same "foo(do: 1, do: 2)", force_do_end_blocks: true
+      assert_same "foo(do: 1, another: 2)", force_do_end_blocks: true
+    end
+
+    test "with multiple keywords" do
+      assert_same """
+      foo do
+        :do
+      rescue
+        :rescue
+      catch
+        :catch
+      else
+        :else
+      after
+        :after
+      end
+      """
+    end
+
+    test "with multiple keywords and arrows" do
+      assert_same """
+      foo do
+        a1 -> a2
+        b1 -> b2
+      rescue
+        a1 -> a2
+        b1 -> b2
+      catch
+        a1 -> a2
+        b1 -> b2
+      else
+        a1 -> a2
+        b1 -> b2
+      after
+        a1 -> a2
+        b1 -> b2
+      end
+      """
+    end
+
+    test "with no extra arguments" do
+      assert_same """
+      foo do
+        :ok
+      end
+      """
+    end
+
+    test "with no extra arguments and line breaks" do
+      assert_same """
+                  foo do
+                    a1 ->
+                      really_long_line
+
+                    b1 ->
+                      b2
+                  rescue
+                    c1
+                  catch
+                    d1 -> d1
+                    e1 -> e1
+                  else
+                    f2
+                  after
+                    g1 ->
+                      really_long_line
+
+                    h1 ->
+                      h2
+                  end
+                  """,
+                  @medium_length
+    end
+
+    test "with extra arguments" do
+      assert_same """
+      foo bar, baz do
+        :ok
+      end
+      """
+    end
+
+    test "with extra arguments and line breaks" do
+      assert_same """
+                  foo bar do
+                    a1 ->
+                      really_long_line
+
+                    b1 ->
+                      b2
+                  rescue
+                    c1
+                  catch
+                    d1 -> d1
+                    e1 -> e1
+                  else
+                    f2
+                  after
+                    g1 ->
+                      really_long_line
+
+                    h1 ->
+                      h2
+                  end
+                  """,
+                  @medium_length
+
+      assert_same """
+                  foo really,
+                      long,
+                      list,
+                      of,
+                      arguments do
+                    a1 ->
+                      really_long_line
+
+                    b1 ->
+                      b2
+                  rescue
+                    c1
+                  catch
+                    d1 -> d1
+                    e1 -> e1
+                  else
+                    f2
+                  after
+                    g1 ->
+                      really_long_line
+
+                    h1 ->
+                      h2
+                  end
+                  """,
+                  @medium_length
+    end
+
+    test "when empty" do
+      assert_same """
+      foo do
+      end
+      """
+
+      assert_same """
+      foo do
+      rescue
+      catch
+      else
+      after
+      end
+      """
+    end
+
+    test "inside call" do
+      bad = "foo (bar do :ok end)"
+
+      good = """
+      foo(
+        bar do
+          :ok
+        end
+      )
+      """
+
+      assert_format bad, good
+
+      bad = "import (bar do :ok end)"
+
+      good = """
+      import (bar do
+                :ok
+              end)
+      """
+
+      assert_format bad, good
+    end
+
+    test "inside operator" do
+      bad = "foo + bar do :ok end"
+
+      good = """
+      foo +
+        bar do
+          :ok
+        end
+      """
+
+      assert_format bad, good
+    end
+
+    test "inside operator inside argument" do
+      bad = "fun foo + (bar do :ok end)"
+
+      good = """
+      fun(
+        foo +
+          bar do
+            :ok
+          end
+      )
+      """
+
+      assert_format bad, good
+
+      bad = "if foo + (bar do :ok end) do :ok end"
+
+      good = """
+      if foo +
+           (bar do
+              :ok
+            end) do
+        :ok
+      end
+      """
+
+      assert_format bad, good
+    end
+
+    test "inside operator inside argument with remote call" do
+      bad = "if foo + (Bar.baz do :ok end) do :ok end"
+
+      good = """
+      if foo +
+           (Bar.baz do
+              :ok
+            end) do
+        :ok
+      end
+      """
+
+      assert_format bad, good
+    end
+
+    test "keeps repeated keys" do
+      assert_same """
+      receive do
+        :ok
+      after
+        0 -> 1
+      after
+        2 -> 3
+      end
+      """
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      case do
+        1 ->
+          :ok
+
+        2 ->
+          :ok
+      end
+      """
+
+      assert_same """
+      case do
+        1 ->
+          :ok
+
+        2 ->
+          :ok
+
+        3 ->
+          :ok
+      end
+      """
+    end
+  end
+
+  describe "tuple calls" do
+    test "without arguments" do
+      assert_format "foo . {}", "foo.{}"
+    end
+
+    test "with arguments" do
+      assert_format "foo.{bar,baz,bat,}", "foo.{bar, baz, bat}"
+    end
+
+    test "with arguments on line limit" do
+      bad = "foo.{bar,baz,bat,}"
+
+      good = """
+      foo.{
+        bar,
+        baz,
+        bat
+      }
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "really_long_expression.{bar,baz,bat,}"
+
+      good = """
+      really_long_expression.{
+        bar,
+        baz,
+        bat
+      }
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with keywords" do
+      assert_same "expr.{:hello, foo: bar, baz: bat}"
+    end
+
+    test "preserves user choice on parens even when it fits" do
+      assert_same """
+      call.{
+        :hello,
+        :foo,
+        :bar
+      }
+      """
+
+      assert_format "call.{foo, bar, baz\n}", "call.{foo, bar, baz}"
+    end
+  end
+
+  describe "access" do
+    test "with one argument" do
+      assert_format "foo[ bar ]", "foo[bar]"
+    end
+
+    test "with arguments on line limit" do
+      bad = "foo[really_long_argument()]"
+
+      good = """
+      foo[
+        really_long_argument()
+      ]
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "really_long_expression[really_long_argument()]"
+
+      good = """
+      really_long_expression[
+        really_long_argument()
+      ]
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with do-end blocks" do
+      assert_same """
+      (if true do
+         false
+       end)[key]
+      """
+    end
+
+    test "with keywords" do
+      assert_format "expr[[]]", "expr[[]]"
+      assert_format "expr[foo: bar, baz: bat]", "expr[foo: bar, baz: bat]"
+      assert_format "expr[[foo: bar, baz: bat]]", "expr[[foo: bar, baz: bat]]"
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/code_formatter/comments_test.exs b/lib/elixir/test/elixir/code_formatter/comments_test.exs
new file mode 100644
index 00000000000..c5f8c8e8e2c
--- /dev/null
+++ b/lib/elixir/test/elixir/code_formatter/comments_test.exs
@@ -0,0 +1,1553 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Code.Formatter.CommentsTest do
+  use ExUnit.Case, async: true
+
+  import CodeFormatterHelpers
+
+  @short_length [line_length: 10]
+
+  describe "at the root" do
+    test "for empty documents" do
+      assert_same "# hello world"
+    end
+
+    test "are reformatted" do
+      assert_format "#oops", "# oops"
+      assert_format "##oops", "## oops"
+      assert_same "# ## oops"
+    end
+
+    test "recognizes hashbangs" do
+      assert_format "#! /usr/bin/env elixir", "#! /usr/bin/env elixir"
+      assert_format "#!/usr/bin/env elixir", "#!/usr/bin/env elixir"
+      assert_same "#!"
+    end
+
+    test "before and after expressions" do
+      assert_same """
+      # before comment
+      :hello
+      """
+
+      assert_same """
+      :hello
+      # after comment
+      """
+
+      assert_same """
+      # before comment
+      :hello
+      # after comment
+      """
+    end
+
+    test "on expressions" do
+      bad = """
+      :hello # this is hello
+      :world # this is world
+      """
+
+      good = """
+      # this is hello
+      :hello
+      # this is world
+      :world
+      """
+
+      assert_format bad, good
+
+      bad = """
+      foo   # this is foo
+      ++ bar # this is bar
+      ++ baz # this is baz
+      """
+
+      good = """
+      # this is foo
+      # this is bar
+      # this is baz
+      foo ++
+        bar ++
+        baz
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "empty comment" do
+      assert_same """
+      #
+      :foo
+      """
+    end
+
+    test "before and after expressions with newlines" do
+      assert_same """
+      # before comment
+      # second line
+
+      :hello
+
+      # middle comment 1
+
+      #
+
+      # middle comment 2
+
+      :world
+
+      # after comment
+      # second line
+      """
+    end
+  end
+
+  describe "modules attributes" do
+    test "with comments around" do
+      assert_same """
+      defmodule Sample do
+        # Comment 0
+        @moduledoc false
+        # Comment 1
+
+        # Comment 2
+        @attr1 1
+        # Comment 3
+
+        # Comment 4
+        @doc "Doc"
+        # Comment 5
+        @attr2 2
+        # Comment 6
+        def sample, do: :sample
+      end
+      """
+    end
+
+    test "with comments only after" do
+      assert_same """
+      @moduledoc false
+      # Comment 1
+
+      @attr 1
+      """
+    end
+
+    test "with too many new lines" do
+      bad = """
+      defmodule Sample do
+
+        # Comment 0
+
+
+        @moduledoc false
+
+
+        # Comment 1
+
+
+        # Comment 2
+
+
+        @attr1 1
+
+
+        # Comment 3
+
+
+        # Comment 4
+
+
+        @doc "Doc"
+
+
+        # Comment 5
+
+
+        @attr2 2
+
+
+        # Comment 6
+
+
+        def sample, do: :sample
+      end
+      """
+
+      assert_format bad, """
+      defmodule Sample do
+        # Comment 0
+
+        @moduledoc false
+
+        # Comment 1
+
+        # Comment 2
+
+        @attr1 1
+
+        # Comment 3
+
+        # Comment 4
+
+        @doc "Doc"
+
+        # Comment 5
+
+        @attr2 2
+
+        # Comment 6
+
+        def sample, do: :sample
+      end
+      """
+    end
+  end
+
+  describe "interpolation" do
+    test "with comment outside before, during and after" do
+      assert_same ~S"""
+      # comment
+      IO.puts("Hello #{world}")
+      """
+
+      assert_same ~S"""
+      IO.puts("Hello #{world}")
+      # comment
+      """
+    end
+
+    test "with trailing comments" do
+      # This is trailing so we move the comment out
+      trailing = ~S"""
+      IO.puts("Hello #{world}") # comment
+      """
+
+      assert_format trailing, ~S"""
+      # comment
+      IO.puts("Hello #{world}")
+      """
+
+      # This is ambiguous so we move the comment out
+      ambiguous = ~S"""
+      IO.puts("Hello #{world # comment
+      }")
+      """
+
+      assert_format ambiguous, ~S"""
+      # comment
+      IO.puts("Hello #{world}")
+      """
+    end
+
+    test "with comment inside before and after" do
+      bad = ~S"""
+      IO.puts(
+        "Hello #{
+          # comment
+          world
+        }"
+      )
+      """
+
+      good = ~S"""
+      IO.puts(
+        # comment
+        "Hello #{world}"
+      )
+      """
+
+      assert_format bad, good
+
+      bad = ~S"""
+      IO.puts(
+        "Hello #{
+          world
+          # comment
+        }"
+      )
+      """
+
+      good = ~S"""
+      IO.puts(
+        "Hello #{world}"
+        # comment
+      )
+      """
+
+      assert_format bad, good
+
+      bad = ~S"""
+      IO.puts("Hello #{hello
+      world}")
+      """
+
+      good = ~S"""
+      IO.puts(
+        "Hello #{hello
+        world}"
+      )
+      """
+
+      assert_format bad, good
+    end
+  end
+
+  describe "parens blocks" do
+    test "with comment outside before and after" do
+      assert_same ~S"""
+      # comment
+      assert (
+               hello
+               world
+             )
+      """
+
+      assert_same ~S"""
+      assert (
+               hello
+               world
+             )
+
+      # comment
+      """
+    end
+
+    test "with trailing comments" do
+      # This is ambiguous so we move the comment out
+      ambiguous = ~S"""
+      assert ( # comment
+               hello
+               world
+             )
+      """
+
+      assert_format ambiguous, ~S"""
+      # comment
+      assert (
+               hello
+               world
+             )
+      """
+
+      # This is ambiguous so we move the comment out
+      ambiguous = ~S"""
+      assert (
+               hello
+               world
+             ) # comment
+      """
+
+      assert_format ambiguous, ~S"""
+      assert (
+               hello
+               world
+             )
+
+      # comment
+      """
+    end
+
+    test "with comment inside before and after" do
+      assert_same ~S"""
+      assert (
+               # comment
+               hello
+               world
+             )
+      """
+
+      assert_same ~S"""
+      assert (
+               hello
+               world
+               # comment
+             )
+      """
+    end
+  end
+
+  describe "access" do
+    test "before and after single arg" do
+      assert_same ~S"""
+      foo[
+        # bar
+        baz
+        # bat
+      ]
+      """
+    end
+
+    test "before and after keywords" do
+      assert_same ~S"""
+      foo[
+        # bar
+        one: :two,
+        # baz
+        three: :four
+        # bat
+      ]
+      """
+    end
+  end
+
+  describe "calls" do
+    test "local with parens inside before and after" do
+      assert_same ~S"""
+      call(
+        # before
+        hello,
+        # middle
+        world
+        # after
+      )
+      """
+
+      assert_same ~S"""
+      call(
+        # command
+      )
+      """
+    end
+
+    test "remote with parens inside before and after" do
+      assert_same ~S"""
+      Remote.call(
+        # before
+        hello,
+        # middle
+        world
+        # after
+      )
+      """
+
+      assert_same ~S"""
+      Remote.call(
+        # command
+      )
+      """
+    end
+
+    test "local with parens and keywords inside before and after" do
+      assert_same ~S"""
+      call(
+        # before
+        hello,
+        # middle
+        world,
+        # key before
+        key: hello,
+        # key middle
+        key: world
+        # key after
+      )
+      """
+    end
+
+    test "remote with parens and keywords inside before and after" do
+      assert_same ~S"""
+      call(
+        # before
+        hello,
+        # middle
+        world,
+        # key before
+        key: hello,
+        # key middle
+        key: world
+        # key after
+      )
+      """
+    end
+
+    test "local with no parens inside before and after" do
+      bad = ~S"""
+             # before
+      assert hello,
+             # middle
+             world
+             # after
+      """
+
+      assert_format bad, ~S"""
+      # before
+      assert hello,
+             # middle
+             world
+
+      # after
+      """
+    end
+
+    test "local with no parens and keywords inside before and after" do
+      bad = ~S"""
+      config hello, world,
+        # key before
+        key: hello,
+        # key middle
+        key: world
+        # key after
+      """
+
+      assert_format bad, ~S"""
+      config hello, world,
+        # key before
+        key: hello,
+        # key middle
+        key: world
+
+      # key after
+      """
+
+      bad = ~S"""
+             # before
+      config hello,
+             # middle
+             world,
+             # key before
+             key: hello,
+             # key middle
+             key: world
+             # key after
+      """
+
+      assert_format bad, ~S"""
+      # before
+      config hello,
+             # middle
+             world,
+             # key before
+             key: hello,
+             # key middle
+             key: world
+
+      # key after
+      """
+    end
+  end
+
+  describe "anonymous functions" do
+    test "with one clause and no args" do
+      assert_same ~S"""
+      fn ->
+        # comment
+        hello
+        world
+      end
+      """
+
+      assert_same ~S"""
+      fn ->
+        hello
+        world
+        # comment
+      end
+      """
+    end
+
+    test "with one clause and no args and trailing comments" do
+      bad = ~S"""
+      fn # comment
+        ->
+        hello
+        world
+      end
+      """
+
+      assert_format bad, ~S"""
+      # comment
+      fn ->
+        hello
+        world
+      end
+      """
+
+      bad = ~S"""
+      fn
+        # comment
+        ->
+        hello
+        world
+      end
+      """
+
+      assert_format bad, ~S"""
+      # comment
+      fn ->
+        hello
+        world
+      end
+      """
+    end
+
+    test "with one clause and args" do
+      assert_same ~S"""
+      fn hello ->
+        # before
+        hello
+        # middle
+        world
+        # after
+      end
+      """
+    end
+
+    test "with one clause and args and trailing comments" do
+      bad = ~S"""
+      fn # fn
+        # before head
+        hello # middle head
+        # after head
+        ->
+          # before body
+          world # middle body
+          # after body
+      end
+      """
+
+      assert_format bad, ~S"""
+      # fn
+      fn
+        # before head
+        # middle head
+        hello ->
+          # after head
+          # before body
+          # middle body
+          world
+          # after body
+      end
+      """
+    end
+
+    test "with multiple clauses and args" do
+      bad = ~S"""
+      fn # fn
+        # before one
+        one, # middle one
+        # after one / before two
+        two # middle two
+        # after two
+        ->
+          # before hello
+          hello # middle hello
+          # after hello
+
+        # before three
+        three # middle three
+        # after three
+        ->
+          # before world
+          world # middle world
+          # after world
+      end
+      """
+
+      assert_format bad, ~S"""
+      # fn
+      fn
+        # before one
+        # middle one
+        # after one / before two
+        # middle two
+        one, two ->
+          # after two
+          # before hello
+          # middle hello
+          hello
+
+        # after hello
+
+        # before three
+        # middle three
+        three ->
+          # after three
+          # before world
+          # middle world
+          world
+          # after world
+      end
+      """
+    end
+
+    test "with commented out clause" do
+      assert_same """
+      fn
+        arg1 ->
+          body1
+
+        # arg2 ->
+        #   body 2
+
+        arg3 ->
+          body3
+      end
+      """
+    end
+  end
+
+  describe "do-end blocks" do
+    test "with comment outside before and after" do
+      assert_same ~S"""
+      # comment
+      assert do
+        hello
+        world
+      end
+      """
+
+      assert_same ~S"""
+      assert do
+        hello
+        world
+      end
+
+      # comment
+      """
+    end
+
+    test "with trailing comments" do
+      # This is ambiguous so we move the comment out
+      ambiguous = ~S"""
+      assert do # comment
+        hello
+        world
+      end
+      """
+
+      assert_format ambiguous, ~S"""
+      # comment
+      assert do
+        hello
+        world
+      end
+      """
+
+      # This is ambiguous so we move the comment out
+      ambiguous = ~S"""
+      assert do
+        hello
+        world
+      end # comment
+      """
+
+      assert_format ambiguous, ~S"""
+      assert do
+        hello
+        world
+      end
+
+      # comment
+      """
+    end
+
+    test "with comment inside before and after" do
+      assert_same ~S"""
+      assert do
+        # comment
+        hello
+        world
+      end
+      """
+
+      assert_same ~S"""
+      assert do
+        hello
+        world
+        # comment
+      end
+      """
+    end
+
+    test "with comment inside before and after and multiple keywords" do
+      assert_same ~S"""
+      assert do
+        # before
+        hello
+        world
+        # after
+      rescue
+        # before
+        hello
+        world
+        # after
+      after
+        # before
+        hello
+        world
+        # after
+      catch
+        # before
+        hello
+        world
+        # after
+      else
+        # before
+        hello
+        world
+        # after
+      end
+      """
+    end
+
+    test "when empty" do
+      assert_same ~S"""
+      assert do
+        # comment
+      end
+      """
+
+      assert_same ~S"""
+      assert do
+        # comment
+      rescue
+        # comment
+      after
+        # comment
+      catch
+        # comment
+      else
+        # comment
+      end
+      """
+    end
+
+    test "with one-line clauses" do
+      bad = ~S"""
+      assert do # do
+        # before
+        one -> two
+      end
+      """
+
+      assert_format bad, ~S"""
+      # do
+      assert do
+        # before
+        one -> two
+      end
+      """
+
+      bad = ~S"""
+      assert do # do
+        # before
+        one -> two
+        # after
+        three -> four
+      end
+      """
+
+      assert_format bad, ~S"""
+      # do
+      assert do
+        # before
+        one -> two
+        # after
+        three -> four
+      end
+      """
+    end
+
+    test "with multiple clauses and args" do
+      bad = ~S"""
+      assert do # do
+        # before one
+        one, # middle one
+        # after one / before two
+        two # middle two
+        # after two
+        ->
+          # before hello
+          hello # middle hello
+          # after hello
+
+        # before three
+        three # middle three
+        # after three
+        ->
+          # before world
+          world # middle world
+          # after world
+      end
+      """
+
+      assert_format bad, ~S"""
+      # do
+      assert do
+        # before one
+        # middle one
+        # after one / before two
+        # middle two
+        one, two ->
+          # after two
+          # before hello
+          # middle hello
+          hello
+
+        # after hello
+
+        # before three
+        # middle three
+        three ->
+          # after three
+          # before world
+          # middle world
+          world
+          # after world
+      end
+      """
+    end
+  end
+
+  describe "operators" do
+    test "with comment before, during and after uniform pipelines" do
+      assert_same """
+      foo
+      # |> bar
+      # |> baz
+      |> bat
+      """
+
+      bad = """
+      # before
+      foo    # this is foo
+      |> bar # this is bar
+      |> baz # this is baz
+      # after
+      """
+
+      good = """
+      # before
+      # this is foo
+      foo
+      # this is bar
+      |> bar
+      # this is baz
+      |> baz
+
+      # after
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with comment before, during and after mixed pipelines" do
+      assert_same """
+      foo
+      # |> bar
+      # |> baz
+      ~> bat
+      """
+
+      bad = """
+      # before
+      foo    # this is foo
+      ~> bar # this is bar
+      <~> baz # this is baz
+      # after
+      """
+
+      good = """
+      # before
+      # this is foo
+      foo
+      # this is bar
+      ~> bar
+      # this is baz
+      <~> baz
+
+      # after
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with comment before, during and after uniform right" do
+      assert_same """
+      foo
+      # | bar
+      # | baz
+      | bat
+      """
+
+      bad = """
+      # before
+      foo    # this is foo
+      | bar # this is bar
+      | baz # this is baz
+      # after
+      """
+
+      good = """
+      # before
+      # this is foo
+      foo
+      # this is bar
+      | bar
+      # this is baz
+      | baz
+
+      # after
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with comment before, during and after mixed right" do
+      assert_same """
+      one
+      # when two
+      # when three
+      when four
+           # | five
+           | six
+      """
+    end
+
+    test "handles nodes without meta info" do
+      assert_same "(a -> b) |> (c -> d)"
+      assert_same "(a -> b) when c: d"
+      assert_same "(a -> b) when (c -> d)"
+    end
+  end
+
+  describe "containers" do
+    test "with comment outside before, during and after" do
+      assert_same ~S"""
+      # comment
+      [one, two, three]
+      """
+
+      assert_same ~S"""
+      [one, two, three]
+      # comment
+      """
+    end
+
+    test "with trailing comments" do
+      # This is trailing so we move the comment out
+      trailing = ~S"""
+      [one, two, three] # comment
+      """
+
+      assert_format trailing, ~S"""
+      # comment
+      [one, two, three]
+      """
+
+      # This is ambiguous so we move the comment out
+      ambiguous = ~S"""
+      [# comment
+       one, two, three]
+      """
+
+      assert_format ambiguous, ~S"""
+      # comment
+      [
+        one,
+        two,
+        three
+      ]
+      """
+    end
+
+    test "when empty" do
+      assert_same ~S"""
+      [
+        # comment
+      ]
+      """
+    end
+
+    test "with block" do
+      assert_same ~S"""
+      [
+        (
+          # before
+          multi
+          line
+          # after
+        )
+      ]
+      """
+    end
+
+    test "with comments inside lists before and after" do
+      bad = ~S"""
+      [
+        # 1. one
+
+        # 1. two
+        # 1. three
+        one,
+        after_one,
+        after_one do
+          :ok
+        end,
+
+        # 2. one
+
+        # 2. two
+        # 2. three
+        # two,
+
+        # 3. one
+
+        # 3. two
+        # 3. three
+        three # final
+
+        # 4. one
+
+        # 4. two
+        # 4. three
+        # four
+      ]
+      """
+
+      good = ~S"""
+      [
+        # 1. one
+
+        # 1. two
+        # 1. three
+        one,
+        after_one,
+        after_one do
+          :ok
+        end,
+
+        # 2. one
+
+        # 2. two
+        # 2. three
+        # two,
+
+        # 3. one
+
+        # 3. two
+        # 3. three
+        # final
+        three
+
+        # 4. one
+
+        # 4. two
+        # 4. three
+        # four
+      ]
+      """
+
+      assert_format bad, good
+    end
+
+    test "with comments inside tuples before and after" do
+      bad = ~S"""
+      {
+        # 1. one
+
+        # 1. two
+        # 1. three
+        one,
+        after_one,
+        after_one do
+          :ok
+        end,
+
+        # 2. one
+
+        # 2. two
+        # 2. three
+        # two,
+
+        # 3. one
+
+        # 3. two
+        # 3. three
+        three # final
+
+        # 4. one
+
+        # 4. two
+        # 4. three
+        # four
+      }
+      """
+
+      good = ~S"""
+      {
+        # 1. one
+
+        # 1. two
+        # 1. three
+        one,
+        after_one,
+        after_one do
+          :ok
+        end,
+
+        # 2. one
+
+        # 2. two
+        # 2. three
+        # two,
+
+        # 3. one
+
+        # 3. two
+        # 3. three
+        # final
+        three
+
+        # 4. one
+
+        # 4. two
+        # 4. three
+        # four
+      }
+      """
+
+      assert_format bad, good
+    end
+
+    test "with comments inside bitstrings before and after" do
+      bad = ~S"""
+      <<
+        # 1. one
+
+        # 1. two
+        # 1. three
+        one,
+        after_one,
+        after_one do
+          :ok
+        end,
+
+        # 2. one
+
+        # 2. two
+        # 2. three
+        # two,
+
+        # 3. one
+
+        # 3. two
+        # 3. three
+        three # final
+
+        # 4. one
+
+        # 4. two
+        # 4. three
+        # four
+      >>
+      """
+
+      good = ~S"""
+      <<
+        # 1. one
+
+        # 1. two
+        # 1. three
+        one,
+        after_one,
+        after_one do
+          :ok
+        end,
+
+        # 2. one
+
+        # 2. two
+        # 2. three
+        # two,
+
+        # 3. one
+
+        # 3. two
+        # 3. three
+        # final
+        three
+
+        # 4. one
+
+        # 4. two
+        # 4. three
+        # four
+      >>
+      """
+
+      assert_format bad, good
+    end
+
+    test "with comments inside maps before and after" do
+      bad = ~S"""
+      %{
+        # 1. one
+
+        # 1. two
+        # 1. three
+        one: one,
+        one: after_one,
+        one: after_one do
+          :ok
+        end,
+
+        # 2. one
+
+        # 2. two
+        # 2. three
+        # two,
+
+        # 3. one
+
+        # 3. two
+        # 3. three
+        three: three # final
+
+        # 4. one
+
+        # 4. two
+        # 4. three
+        # four
+      }
+      """
+
+      good = ~S"""
+      %{
+        # 1. one
+
+        # 1. two
+        # 1. three
+        one: one,
+        one: after_one,
+        one:
+          after_one do
+            :ok
+          end,
+
+        # 2. one
+
+        # 2. two
+        # 2. three
+        # two,
+
+        # 3. one
+
+        # 3. two
+        # 3. three
+        # final
+        three: three
+
+        # 4. one
+
+        # 4. two
+        # 4. three
+        # four
+      }
+      """
+
+      assert_format bad, good
+    end
+
+    test "with comments inside structs before and after" do
+      bad = ~S"""
+      %Foo{bar |
+        # 1. one
+
+        # 1. two
+        # 1. three
+        one: one,
+        one: after_one,
+        one: after_one do
+          :ok
+        end,
+
+        # 2. one
+
+        # 2. two
+        # 2. three
+        # two,
+
+        # 3. one
+
+        # 3. two
+        # 3. three
+        three: three # final
+
+        # 4. one
+
+        # 4. two
+        # 4. three
+        # four
+      }
+      """
+
+      good = ~S"""
+      %Foo{
+        bar
+        | # 1. one
+
+          # 1. two
+          # 1. three
+          one: one,
+          one: after_one,
+          one:
+            after_one do
+              :ok
+            end,
+
+          # 2. one
+
+          # 2. two
+          # 2. three
+          # two,
+
+          # 3. one
+
+          # 3. two
+          # 3. three
+          # final
+          three: three
+
+          # 4. one
+
+          # 4. two
+          # 4. three
+          # four
+      }
+      """
+
+      assert_format bad, good
+    end
+  end
+
+  describe "defstruct" do
+    test "with first field comments" do
+      bad = ~S"""
+      defmodule Foo do
+        # defstruct
+        defstruct [ # foo
+          # 1. one
+          one: 1, # 2. one
+          # 1. two
+          # 2. two
+          two: 2
+        ]
+      end
+      """
+
+      good = ~S"""
+      defmodule Foo do
+        # defstruct
+        # foo
+        defstruct [
+          # 1. one
+          # 2. one
+          one: 1,
+          # 1. two
+          # 2. two
+          two: 2
+        ]
+      end
+      """
+
+      assert_format bad, good
+    end
+
+    test "with first field comments and defstruct has the parens" do
+      bad = ~S"""
+      defmodule Foo do
+        # defstruct
+        defstruct([ # foo
+          # 1. one
+          one: 1, # 2. one
+          # 1. two
+          # 2. two
+          two: 2
+        ])
+      end
+      """
+
+      good = ~S"""
+      defmodule Foo do
+        # defstruct
+        # foo
+        defstruct(
+          # 1. one
+          # 2. one
+          one: 1,
+          # 1. two
+          # 2. two
+          two: 2
+        )
+      end
+      """
+
+      assert_format bad, good
+    end
+
+    test "without first field comments" do
+      bad = ~S"""
+      defmodule Foo do
+        # defstruct
+        defstruct [
+          one: 1,
+          # 1. two
+          two: 2 # 2. two
+        ]
+      end
+      """
+
+      good = ~S"""
+      defmodule Foo do
+        # defstruct
+        defstruct one: 1,
+                  # 1. two
+                  # 2. two
+                  two: 2
+      end
+      """
+
+      assert_format bad, good
+    end
+
+    test "without field comments" do
+      bad = ~S"""
+      defmodule Foo do
+        # defstruct
+        defstruct [
+          one: 1,
+          two: 2
+        ]
+      end
+      """
+
+      good = ~S"""
+      defmodule Foo do
+        # defstruct
+        defstruct one: 1,
+                  two: 2
+      end
+      """
+
+      assert_format bad, good
+    end
+
+    test "without square brackets" do
+      assert_same ~S"""
+      defmodule Foo do
+        # defstruct
+        defstruct one: 1,
+                  # 1. two
+                  # 2. two
+                  two: 2
+      end
+      """
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/code_formatter/containers_test.exs b/lib/elixir/test/elixir/code_formatter/containers_test.exs
new file mode 100644
index 00000000000..a62c1513403
--- /dev/null
+++ b/lib/elixir/test/elixir/code_formatter/containers_test.exs
@@ -0,0 +1,664 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Code.Formatter.ContainersTest do
+  use ExUnit.Case, async: true
+
+  import CodeFormatterHelpers
+
+  @short_length [line_length: 10]
+  @medium_length [line_length: 20]
+
+  describe "tuples" do
+    test "without arguments" do
+      assert_format "{ }", "{}"
+    end
+
+    test "with arguments" do
+      assert_format "{1,2}", "{1, 2}"
+      assert_format "{1,2,3}", "{1, 2, 3}"
+    end
+
+    test "is flex on line limits" do
+      bad = "{1, 2, 3, 4}"
+
+      good = """
+      {1, 2, 3,
+       4}
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "removes trailing comma" do
+      assert_format "{1,}", "{1}"
+      assert_format "{1, 2, 3,}", "{1, 2, 3}"
+    end
+
+    test "with keyword lists" do
+      # The one below is not valid syntax
+      # assert_same "{foo: 1, bar: 2}"
+      assert_same "{:hello, foo: 1, bar: 2}"
+
+      tuple = """
+      {
+        :hello,
+        foo: 1,
+        bar: 2
+      }
+      """
+
+      assert_same tuple, @short_length
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      {
+        :hello,
+        :foo,
+        :bar
+      }
+      """
+
+      # Doesn't preserve this because only the ending has a newline
+      assert_format "{foo, bar, baz\n}", "{foo, bar, baz}"
+    end
+
+    test "preserves user choice even when it fits with trailing comma" do
+      bad = """
+      {
+        :hello,
+        :foo,
+        :bar,
+      }
+      """
+
+      assert_format bad, """
+      {
+        :hello,
+        :foo,
+        :bar
+      }
+      """
+    end
+  end
+
+  describe "lists" do
+    test "empty" do
+      assert_format "[ ]", "[]"
+      assert_format "[\n]", "[]"
+    end
+
+    test "with elements" do
+      assert_format "[ 1 , 2,3, 4 ]", "[1, 2, 3, 4]"
+    end
+
+    test "with tail" do
+      assert_format "[1,2,3|4]", "[1, 2, 3 | 4]"
+    end
+
+    test "are strict on line limit" do
+      bad = """
+      [11, 22, 33, 44]
+      """
+
+      good = """
+      [
+        11,
+        22,
+        33,
+        44
+      ]
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = """
+      [11, 22, 33 | 44]
+      """
+
+      good = """
+      [
+        11,
+        22,
+        33 | 44
+      ]
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = """
+      [1, 2, 3 | 4]
+      """
+
+      good = """
+      [
+        1,
+        2,
+        3 | 4
+      ]
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = """
+      [1, 2, 3 | really_long_expression()]
+      """
+
+      good = """
+      [
+        1,
+        2,
+        3
+        | really_long_expression()
+      ]
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "removes trailing comma" do
+      assert_format "[1,]", "[1]"
+      assert_format "[1, 2, 3,]", "[1, 2, 3]"
+    end
+
+    test "with keyword lists" do
+      assert_same "[foo: 1, bar: 2]"
+      assert_same "[:hello, foo: 1, bar: 2]"
+
+      # Pseudo keyword lists are kept as is
+      assert_same "[{:foo, 1}, {:bar, 2}]"
+
+      keyword = """
+      [
+        foo: 1,
+        bar: 2
+      ]
+      """
+
+      assert_same keyword, @short_length
+    end
+
+    test "with keyword lists on comma line limit" do
+      bad = """
+      [
+        foooo: 1,
+        barrr: 2
+      ]
+      """
+
+      good = """
+      [
+        foooo:
+          1,
+        barrr: 2
+      ]
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with quoted keyword lists" do
+      assert_same ~S(["with spaces": 1])
+      assert_same ~S(["one #{two} three": 1])
+      assert_same ~S(["\w": 1, "\\w": 2])
+      assert_same ~S(["Elixir.Foo": 1, "Elixir.Bar": 2])
+      assert_format ~S(["Foo": 1, "Bar": 2]), ~S([Foo: 1, Bar: 2])
+      assert_same ~S(["with \"scare quotes\"": 1])
+    end
+
+    test "with operators keyword lists" do
+      assert_same ~S([.: :.])
+      assert_same ~S([..: :..])
+      assert_same ~S([...: :...])
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      [
+        :hello,
+        :foo,
+        :bar
+      ]
+      """
+
+      # Doesn't preserve this because only the ending has a newline
+      assert_format "[foo, bar, baz\n]", "[foo, bar, baz]"
+    end
+
+    test "preserves user choice even when it fits with trailing comma" do
+      bad = """
+      [
+        :hello,
+        :foo,
+        :bar,
+      ]
+      """
+
+      assert_format bad, """
+      [
+        :hello,
+        :foo,
+        :bar
+      ]
+      """
+    end
+  end
+
+  describe "bitstrings" do
+    test "without arguments" do
+      assert_format "<< >>", "<<>>"
+      assert_format "<<\n>>", "<<>>"
+    end
+
+    test "with arguments" do
+      assert_format "<<1,2,3>>", "<<1, 2, 3>>"
+    end
+
+    test "add parens on first and last in case of binary ambiguity" do
+      assert_format "<< <<>> >>", "<<(<<>>)>>"
+      assert_format "<< <<>> + <<>> >>", "<<(<<>> + <<>>)>>"
+      assert_format "<< 1 + <<>> >>", "<<(1 + <<>>)>>"
+      assert_format "<< <<>> + 1 >>", "<<(<<>> + 1)>>"
+      assert_format "<< <<>>, <<>>, <<>> >>", "<<(<<>>), <<>>, (<<>>)>>"
+      assert_format "<< <<>>::1, <<>>::2, <<>>::3 >>", "<<(<<>>)::1, <<>>::2, <<>>::3>>"
+      assert_format "<< <<>>::<<>> >>", "<<(<<>>)::(<<>>)>>"
+    end
+
+    test "add parens on first in case of operator ambiguity" do
+      assert_format "<< ~~~1::8 >>", "<<(~~~1)::8>>"
+      assert_format "<< ~s[foo]::binary >>", "<<(~s[foo])::binary>>"
+    end
+
+    test "with modifiers" do
+      assert_format "<< 1 :: 1 >>", "<<1::1>>"
+      assert_format "<< 1 :: 2 + 3 >>", "<<1::(2 + 3)>>"
+      assert_format "<< 1 :: 2 - integer >>", "<<1::2-integer>>"
+      assert_format "<< 1 :: 2 - unit(3) >>", "<<1::2-unit(3)>>"
+      assert_format "<< 1 :: 2 * 3 - unit(4) >>", "<<1::2*3-unit(4)>>"
+      assert_format "<< 1 :: 2 - unit(3) - 4 / 5 >>", "<<1::2-unit(3)-(4 / 5)>>"
+      assert_format "<<0 :: ( x - 1 ) * 5>>", "<<0::(x-1)*5>>"
+      assert_format "<<0 :: 2 * 3 * 4>>", "<<0::(2*3)*4>>"
+    end
+
+    test "in comprehensions" do
+      assert_format "<< 0, 1 :: 1 <- x >>", "<<0, 1::1 <- x>>"
+      assert_format "<< 0, 1 :: 2 + 3 <- x >>", "<<0, 1::(2 + 3) <- x>>"
+      assert_format "<< 0, 1 :: 2 - integer <- x >>", "<<0, 1::2-integer <- x>>"
+      assert_format "<< 0, 1 :: 2 - unit(3) <- x >>", "<<0, 1::2-unit(3) <- x>>"
+      assert_format "<< 0, 1 :: 2 * 3 - unit(4) <- x >>", "<<0, 1::2*3-unit(4) <- x>>"
+      assert_format "<< 0, 1 :: 2 - unit(3) - 4 / 5 <- x >>", "<<0, 1::2-unit(3)-(4 / 5) <- x>>"
+
+      assert_same "<<(<<y>> <- <<x>>)>>"
+      assert_same "<<(y <- <<x>>)>>"
+      assert_same "<<(<<y>> <- x)>>"
+    end
+
+    test "keeps parentheses by default" do
+      assert_same "<<foo::binary()>>"
+      assert_same "<<foo::binary>>"
+
+      assert_same "<<foo::custom_type>>"
+      assert_same "<<foo::custom_type()>>"
+
+      assert_same "<<x::binary()-(13 * 6)-custom>>"
+      assert_same "<<0, 1::2-integer() <- x>>"
+    end
+
+    test "is flex on line limits" do
+      bad = "<<1, 2, 3, 4>>"
+
+      good = """
+      <<1, 2, 3,
+        4>>
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      <<
+        :hello,
+        :foo,
+        :bar
+      >>
+      """
+
+      # Doesn't preserve this because only the ending has a newline
+      assert_format "<<foo, bar, baz\n>>", "<<foo, bar, baz>>"
+    end
+
+    test "preserves user choice even when it fits with trailing comma" do
+      bad = """
+      <<
+        :hello,
+        :foo,
+        :bar,
+      >>
+      """
+
+      assert_format bad, """
+      <<
+        :hello,
+        :foo,
+        :bar
+      >>
+      """
+    end
+  end
+
+  describe "maps" do
+    test "without arguments" do
+      assert_format "%{ }", "%{}"
+    end
+
+    test "with arguments" do
+      assert_format "%{1 => 2,3 => 4}", "%{1 => 2, 3 => 4}"
+    end
+
+    test "is strict on line limits" do
+      bad = "%{1 => 2, 3 => 4}"
+
+      good = """
+      %{
+        1 => 2,
+        3 => 4
+      }
+      """
+
+      assert_format bad, good, @short_length
+
+      map = """
+      %{
+        a(1, 2) => b,
+        c(3, 4) => d
+      }
+      """
+
+      assert_same map, @medium_length
+
+      map = """
+      %{
+        a => fn x ->
+          y
+        end,
+        b => fn y ->
+          z
+        end
+      }
+      """
+
+      assert_same map, @medium_length
+
+      map = """
+      %{
+        a =>
+          for(
+            y <- x,
+            z <- y,
+            do: 123
+          )
+      }
+      """
+
+      assert_same map, @medium_length
+
+      map = """
+      %{
+        a =>
+          for do
+            :ok
+          end
+      }
+      """
+
+      assert_same map, @short_length
+    end
+
+    test "removes trailing comma" do
+      assert_format "%{1 => 2,}", "%{1 => 2}"
+    end
+
+    test "with keyword lists" do
+      assert_same "%{:foo => :bar, baz: :bat}"
+
+      map = """
+      %{
+        :foo => :bar,
+        baz: :bat
+      }
+      """
+
+      assert_same map, @medium_length
+    end
+
+    test "preserves user choice in regards to =>" do
+      assert_same "%{:hello => 1, :world => 2}"
+      assert_format "%{:true => 1, :false => 2}", "%{true => 1, false => 2}"
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      %{
+        :hello => 1,
+        :foo => 2,
+        :bar => 3
+      }
+      """
+
+      # Doesn't preserve this because only the ending has a newline
+      assert_format "%{foo: 1, bar: 2\n}", "%{foo: 1, bar: 2}"
+    end
+
+    test "preserves user choice even when it fits with trailing comma" do
+      bad = """
+      %{
+        hello,
+        foo,
+        bar,
+      }
+      """
+
+      assert_format bad, """
+      %{
+        hello,
+        foo,
+        bar
+      }
+      """
+    end
+
+    test "preserves user choice when a newline is used after keyword" do
+      good = """
+      %{
+        hello:
+          {:ok, :world}
+      }
+      """
+
+      assert_same good, @medium_length
+    end
+
+    test "preserves user choice when a newline is used after assoc" do
+      good = """
+      %{
+        hello =>
+          {:ok, :world}
+      }
+      """
+
+      assert_same good, @medium_length
+    end
+  end
+
+  describe "maps with update" do
+    test "with arguments" do
+      assert_format "%{foo | 1 => 2,3 => 4}", "%{foo | 1 => 2, 3 => 4}"
+    end
+
+    test "is strict on line limits" do
+      bad = "%{foo | 1 => 2, 3 => 4}"
+
+      good = """
+      %{
+        foo
+        | 1 => 2,
+          3 => 4
+      }
+      """
+
+      assert_format bad, good, line_length: 11
+    end
+
+    test "removes trailing comma" do
+      assert_format "%{foo | 1 => 2,}", "%{foo | 1 => 2}"
+    end
+
+    test "with keyword lists" do
+      assert_same "%{foo | :foo => :bar, baz: :bat}"
+
+      map = """
+      %{
+        foo
+        | :foo => :bar,
+          baz: :bat
+      }
+      """
+
+      assert_same map, @medium_length
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      %{
+        foo
+        | :hello => 1,
+          :foo => 2,
+          :bar => 3
+      }
+      """
+    end
+
+    test "wraps operators in parens" do
+      assert_format "%{foo && bar | baz: :bat}", "%{(foo && bar) | baz: :bat}"
+      assert_same "%{@foo | baz: :bat}"
+    end
+  end
+
+  describe "structs" do
+    test "without arguments" do
+      assert_format "%struct{ }", "%struct{}"
+    end
+
+    test "with arguments" do
+      assert_format "%struct{1 => 2,3 => 4}", "%struct{1 => 2, 3 => 4}"
+    end
+
+    test "is strict on line limits" do
+      bad = "%struct{1 => 2, 3 => 4}"
+
+      good = """
+      %struct{
+        1 => 2,
+        3 => 4
+      }
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "removes trailing comma" do
+      assert_format "%struct{1 => 2,}", "%struct{1 => 2}"
+    end
+
+    test "with keyword lists" do
+      assert_same "%struct{:foo => :bar, baz: :bat}"
+
+      struct = """
+      %struct{
+        :foo => :bar,
+        baz: :bat
+      }
+      """
+
+      assert_same struct, @medium_length
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      %Foo{
+        :hello => 1,
+        :foo => 2,
+        :bar => 3
+      }
+      """
+    end
+  end
+
+  describe "struct with update" do
+    test "with arguments" do
+      assert_format "%struct{foo | 1 => 2,3 => 4}", "%struct{foo | 1 => 2, 3 => 4}"
+    end
+
+    test "is strict on line limits" do
+      bad = "%struct{foo | 1 => 2, 3 => 4}"
+
+      good = """
+      %struct{
+        foo
+        | 1 => 2,
+          3 => 4
+      }
+      """
+
+      assert_format bad, good, line_length: 11
+    end
+
+    test "removes trailing comma" do
+      assert_format "%struct{foo | 1 => 2,}", "%struct{foo | 1 => 2}"
+    end
+
+    test "with keyword lists" do
+      assert_same "%struct{foo | :foo => :bar, baz: :bat}"
+
+      struct = """
+      %struct{
+        foo
+        | :foo => :bar,
+          baz: :bat
+      }
+      """
+
+      assert_same struct, @medium_length
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      %Foo{
+        foo
+        | :hello => 1,
+          :foo => 2,
+          :bar => 3
+      }
+      """
+    end
+
+    test "converges" do
+      bad = "hello_world(%struct{foo | 1 => 2, 3 => 4})"
+
+      good = """
+      hello_world(%struct{
+        foo
+        | 1 => 2,
+          3 => 4
+      })
+      """
+
+      assert_format bad, good, line_length: 30
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/code_formatter/general_test.exs b/lib/elixir/test/elixir/code_formatter/general_test.exs
new file mode 100644
index 00000000000..3c91e5fba5c
--- /dev/null
+++ b/lib/elixir/test/elixir/code_formatter/general_test.exs
@@ -0,0 +1,947 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Code.Formatter.GeneralTest do
+  use ExUnit.Case, async: true
+
+  import CodeFormatterHelpers
+
+  @short_length [line_length: 10]
+
+  test "does not emit warnings" do
+    assert_format "fn -> end", "fn -> nil end"
+  end
+
+  describe "unicode normalization" do
+    test "with nfc normalizations" do
+      assert_format "ç", "ç"
+    end
+
+    test "with custom normalizations" do
+      assert_format "µs", "μs"
+    end
+  end
+
+  describe "aliases" do
+    test "with atom-only parts" do
+      assert_same "Elixir"
+      assert_same "Elixir.Foo"
+      assert_same "Foo.Bar.Baz"
+    end
+
+    test "removes spaces between aliases" do
+      assert_format "Foo . Bar . Baz", "Foo.Bar.Baz"
+    end
+
+    test "starting with expression" do
+      assert_same "__MODULE__.Foo.Bar"
+      # Syntactically valid, semantically invalid
+      assert_same ~S[~c"Foo".Bar.Baz]
+    end
+
+    test "wraps the head in parens if it has an operator" do
+      assert_format "+(Foo . Bar . Baz)", "+Foo.Bar.Baz"
+      assert_format "(+Foo) . Bar . Baz", "(+Foo).Bar.Baz"
+    end
+  end
+
+  describe "sigils" do
+    test "without interpolation" do
+      assert_same ~S[~s(foo)]
+      assert_same ~S[~s{foo bar}]
+      assert_same ~S[~r/Bar Baz/]
+      assert_same ~S[~w<>]
+      assert_same ~S[~W()]
+      assert_same ~S[~MAT()]
+      assert_same ~S[~MAT{1,2,3}]
+    end
+
+    test "with escapes" do
+      assert_same ~S[~s(foo \) bar)]
+      assert_same ~S[~s(f\a\b\ro)]
+
+      assert_same ~S"""
+      ~S(foo\
+      bar)
+      """
+    end
+
+    test "with nested new lines" do
+      assert_same ~S"""
+      foo do
+        ~S(foo\
+      bar)
+      end
+      """
+
+      assert_same ~S"""
+      foo do
+        ~s(#{bar}
+      )
+      end
+      """
+    end
+
+    test "with interpolation" do
+      assert_same ~S[~s(one #{2} three)]
+    end
+
+    test "with modifiers" do
+      assert_same ~S[~w(one two three)a]
+      assert_same ~S[~z(one two three)foo]
+    end
+
+    test "with interpolation on line limit" do
+      assert_same ~S"""
+                  ~s(one #{"two"} three)
+                  """,
+                  @short_length
+    end
+
+    test "with heredoc syntax" do
+      assert_same ~S"""
+      ~s'''
+      one\a
+      #{:two}\r
+      three\0
+      '''
+      """
+
+      assert_same ~S'''
+      ~s"""
+      one\a
+      #{:two}\r
+      three\0
+      """
+      '''
+    end
+
+    test "with heredoc syntax and modifier" do
+      assert_same ~S"""
+      ~s'''
+      foo
+      '''rsa
+      """
+    end
+
+    test "with heredoc syntax and interpolation on line limit" do
+      assert_same ~S"""
+                  ~s'''
+                  one #{"two two"} three
+                  '''
+                  """,
+                  @short_length
+    end
+
+    test "with custom formatting" do
+      bad = """
+      ~W/foo  bar  baz/
+      """
+
+      good = """
+      ~W/foo bar baz/
+      """
+
+      formatter = fn content, opts ->
+        assert opts == [file: nil, line: 1, sigil: :W, modifiers: [], opening_delimiter: "/"]
+        content |> String.split(~r/ +/) |> Enum.join(" ")
+      end
+
+      assert_format bad, good, sigils: [W: formatter]
+
+      bad = """
+      var = ~W<foo  bar  baz>abc
+      """
+
+      good = """
+      var = ~W<foo bar baz>abc
+      """
+
+      formatter = fn content, opts ->
+        assert opts == [file: nil, line: 1, sigil: :W, modifiers: ~c"abc", opening_delimiter: "<"]
+        content |> String.split(~r/ +/) |> Enum.intersperse(" ")
+      end
+
+      assert_format bad, good, sigils: [W: formatter]
+
+      bad = """
+      var = ~MAT{foo  bar  baz}abc
+      """
+
+      good = """
+      var = ~MAT{foo bar baz}abc
+      """
+
+      formatter = fn content, opts ->
+        assert opts == [
+                 file: nil,
+                 line: 1,
+                 sigil: :MAT,
+                 modifiers: ~c"abc",
+                 opening_delimiter: "{"
+               ]
+
+        content |> String.split(~r/ +/) |> Enum.intersperse(" ")
+      end
+
+      assert_format bad, good, sigils: [MAT: formatter]
+    end
+
+    test "with custom formatting on heredocs" do
+      bad = """
+      ~W'''
+      foo  bar  baz
+      '''
+      """
+
+      good = """
+      ~W'''
+      foo bar baz
+      '''
+      """
+
+      formatter = fn content, opts ->
+        assert opts == [file: nil, line: 1, sigil: :W, modifiers: [], opening_delimiter: "'''"]
+        content |> String.split(~r/ +/) |> Enum.join(" ")
+      end
+
+      assert_format bad, good, sigils: [W: formatter]
+
+      bad = ~S'''
+      if true do
+        ~W"""
+        foo
+        bar
+        baz
+        """abc
+      end
+      '''
+
+      good = ~S'''
+      if true do
+        ~W"""
+        foo
+        bar
+        baz
+        """abc
+      end
+      '''
+
+      formatter = fn content, opts ->
+        assert opts == [
+                 file: nil,
+                 line: 2,
+                 sigil: :W,
+                 modifiers: ~c"abc",
+                 opening_delimiter: ~S/"""/
+               ]
+
+        content |> String.split(~r/ +/) |> Enum.join("\n")
+      end
+
+      assert_format bad, good, sigils: [W: formatter]
+    end
+  end
+
+  describe "anonymous functions" do
+    test "with a single clause and no arguments" do
+      assert_format "fn  ->:ok  end", "fn -> :ok end"
+
+      bad = "fn -> :foo end"
+
+      good = """
+      fn ->
+        :foo
+      end
+      """
+
+      assert_format bad, good, @short_length
+
+      assert_same "fn () when node() == :nonode@nohost -> true end"
+    end
+
+    test "with a single clause and arguments" do
+      assert_format "fn  x ,y-> x + y  end", "fn x, y -> x + y end"
+
+      bad = "fn x -> foo(x) end"
+
+      good = """
+      fn x ->
+        foo(x)
+      end
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "fn one, two, three -> foo(x) end"
+
+      good = """
+      fn one,
+         two,
+         three ->
+        foo(x)
+      end
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with a single clause and when" do
+      code = """
+      fn arg
+         when guard ->
+        :ok
+      end
+      """
+
+      assert_same code, @short_length
+    end
+
+    test "keeps parens if argument includes keyword list" do
+      assert_same """
+      fn [] when is_integer(x) ->
+        x + 42
+      end
+      """
+
+      bad = """
+      fn (input: x) when is_integer(x) ->
+        x + 42
+      end
+      """
+
+      good = """
+      fn [input: x] when is_integer(x) ->
+        x + 42
+      end
+      """
+
+      assert_format bad, good
+    end
+
+    test "with a single clause, followed by a newline, and can fit in one line" do
+      assert_same """
+      fn
+        hello -> world
+      end
+      """
+    end
+
+    test "with a single clause, followed by a newline, and can not fit in one line" do
+      assert_same """
+      SomeModule.long_function_name_that_approaches_max_columns(argument, acc, fn
+        %SomeStruct{key: key}, acc -> more_code(key, acc)
+      end)
+      """
+    end
+
+    test "with multiple clauses" do
+      code = """
+      fn
+        1 -> :ok
+        2 -> :ok
+      end
+      """
+
+      assert_same code, @short_length
+
+      code = """
+      fn
+        1 ->
+          :ok
+
+        2 ->
+          :error
+      end
+      """
+
+      assert_same code, @short_length
+
+      code = """
+      fn
+        arg11,
+        arg12 ->
+          body1
+
+        arg21,
+        arg22 ->
+          body2
+      end
+      """
+
+      assert_same code, @short_length
+
+      code = """
+      fn
+        arg11,
+        arg12 ->
+          body1
+
+        arg21,
+        arg22 ->
+          body2
+
+        arg31,
+        arg32 ->
+          body3
+      end
+      """
+
+      assert_same code, @short_length
+    end
+
+    test "with heredocs" do
+      assert_same ~S'''
+      fn
+        arg1 ->
+          """
+          foo
+          """
+
+        arg2 ->
+          """
+          bar
+          """
+      end
+      '''
+    end
+
+    test "with multiple empty clauses" do
+      assert_same """
+      fn
+        () -> :ok1
+        () -> :ok2
+      end
+      """
+    end
+
+    test "with when in clauses" do
+      assert_same """
+      fn
+        a1 when a + b -> :ok
+        b1 when c + d -> :ok
+      end
+      """
+
+      long = """
+      fn
+        a1, a2 when a + b -> :ok
+        b1, b2 when c + d -> :ok
+      end
+      """
+
+      assert_same long
+
+      good = """
+      fn
+        a1, a2
+        when a +
+               b ->
+          :ok
+
+        b1, b2
+        when c +
+               d ->
+          :ok
+      end
+      """
+
+      assert_format long, good, @short_length
+    end
+
+    test "uses block context for the body of each clause" do
+      assert_same "fn -> @foo bar end"
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      fn
+        1 ->
+          :ok
+
+        2 ->
+          :ok
+      end
+      """
+
+      assert_same """
+      fn
+        1 ->
+          :ok
+
+        2 ->
+          :ok
+
+        3 ->
+          :ok
+      end
+      """
+    end
+
+    test "with -> on line limit" do
+      bad = """
+      fn ab, cd ->
+        ab + cd
+      end
+      """
+
+      good = """
+      fn ab,
+         cd ->
+        ab + cd
+      end
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = """
+      fn
+        ab, cd ->
+          1
+        xy, zw ->
+          2
+      end
+      """
+
+      good = """
+      fn
+        ab,
+        cd ->
+          1
+
+        xy,
+        zw ->
+          2
+      end
+      """
+
+      assert_format bad, good, @short_length
+    end
+  end
+
+  describe "anonymous functions types" do
+    test "with a single clause and no arguments" do
+      assert_same "(-> :ok)"
+      assert_format "(->:ok)", "(-> :ok)"
+      assert_format "( -> :ok)", "(-> :ok)"
+      assert_format "(() -> :really_long_atom)", "(-> :really_long_atom)", @short_length
+      assert_same "(() when node() == :nonode@nohost -> true)"
+    end
+
+    test "with a single clause and arguments" do
+      assert_format "( x ,y-> x + y  )", "(x, y -> x + y)"
+
+      bad = "(x -> :really_long_atom)"
+
+      good = """
+      (x ->
+         :really_long_atom)
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "(one, two, three -> foo(x))"
+
+      good = """
+      (one,
+       two,
+       three ->
+         foo(x))
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with multiple clauses" do
+      code = """
+      (
+        1 -> :ok
+        2 -> :ok
+      )
+      """
+
+      assert_same code, @short_length
+
+      code = """
+      (
+        1 ->
+          :ok
+
+        2 ->
+          :error
+      )
+      """
+
+      assert_same code, @short_length
+
+      code = """
+      (
+        arg11,
+        arg12 ->
+          body1
+
+        arg21,
+        arg22 ->
+          body2
+      )
+      """
+
+      assert_same code, @short_length
+
+      code = """
+      (
+        arg11,
+        arg12 ->
+          body1
+
+        arg21,
+        arg22 ->
+          body2
+
+        arg31,
+        arg32 ->
+          body2
+      )
+      """
+
+      assert_same code, @short_length
+    end
+
+    test "with heredocs" do
+      assert_same ~S'''
+      (
+        arg1 ->
+          """
+          foo
+          """
+
+        arg2 ->
+          """
+          bar
+          """
+      )
+      '''
+    end
+
+    test "with multiple empty clauses" do
+      assert_same """
+      (
+        () -> :ok1
+        () -> :ok2
+      )
+      """
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      (
+        1 ->
+          :ok
+
+        2 ->
+          :ok
+      )
+      """
+
+      assert_same """
+      (
+        1 ->
+          :ok
+
+        2 ->
+          :ok
+
+        3 ->
+          :ok
+      )
+      """
+    end
+  end
+
+  describe "blocks" do
+    test "empty" do
+      assert_format "(;)", ""
+      assert_format "quote do: (;)", "quote do: nil"
+      assert_format "quote do end", "quote do\nend"
+      assert_format "quote do ; end", "quote do\nend"
+    end
+
+    test "with multiple lines" do
+      assert_same """
+      foo = bar
+      baz = bat
+      """
+    end
+
+    test "with multiple lines with line limit" do
+      code = """
+      foo =
+        bar(one)
+
+      baz =
+        bat(two)
+
+      a(b)
+      """
+
+      assert_same code, @short_length
+
+      code = """
+      foo =
+        bar(one)
+
+      a(b)
+
+      baz =
+        bat(two)
+      """
+
+      assert_same code, @short_length
+
+      code = """
+      a(b)
+
+      foo =
+        bar(one)
+
+      baz =
+        bat(two)
+      """
+
+      assert_same code, @short_length
+
+      code = """
+      foo =
+        bar(one)
+
+      one =
+        two(ghi)
+
+      baz =
+        bat(two)
+      """
+
+      assert_same code, @short_length
+    end
+
+    test "with multiple lines with line limit inside block" do
+      code = """
+      block do
+        a =
+          b(foo)
+
+        c =
+          d(bar)
+
+        e =
+          f(baz)
+      end
+      """
+
+      assert_same code, @short_length
+    end
+
+    test "with multiple lines with cancel expressions" do
+      code = """
+      foo(%{
+        key: 1
+      })
+
+      bar(%{
+        key: 1
+      })
+
+      baz(%{
+        key: 1
+      })
+      """
+
+      assert_same code, @short_length
+    end
+
+    test "with heredoc" do
+      assert_same ~S'''
+      block do
+        """
+        a
+
+        b
+
+        c
+        """
+      end
+      '''
+    end
+
+    test "keeps user newlines" do
+      assert_same """
+      defmodule Mod do
+        field(:foo)
+        field(:bar)
+        field(:baz)
+        belongs_to(:one)
+        belongs_to(:two)
+        timestamp()
+        lock()
+        has_many(:three)
+        has_many(:four)
+        :ok
+        has_one(:five)
+        has_one(:six)
+        foo = 1
+        bar = 2
+        :before
+        baz = 3
+        :after
+      end
+      """
+
+      bad = """
+      defmodule Mod do
+        field(:foo)
+
+        field(:bar)
+
+        field(:baz)
+
+
+        belongs_to(:one)
+        belongs_to(:two)
+
+
+        timestamp()
+
+        lock()
+
+
+        has_many(:three)
+        has_many(:four)
+
+
+        :ok
+
+
+        has_one(:five)
+        has_one(:six)
+
+
+        foo = 1
+        bar = 2
+
+
+        :before
+        baz = 3
+        :after
+      end
+      """
+
+      good = """
+      defmodule Mod do
+        field(:foo)
+
+        field(:bar)
+
+        field(:baz)
+
+        belongs_to(:one)
+        belongs_to(:two)
+
+        timestamp()
+
+        lock()
+
+        has_many(:three)
+        has_many(:four)
+
+        :ok
+
+        has_one(:five)
+        has_one(:six)
+
+        foo = 1
+        bar = 2
+
+        :before
+        baz = 3
+        :after
+      end
+      """
+
+      assert_format bad, good
+    end
+
+    test "with multiple defs" do
+      assert_same """
+      def foo(:one), do: 1
+      def foo(:two), do: 2
+      def foo(:three), do: 3
+      """
+    end
+
+    test "with module attributes" do
+      assert_same ~S'''
+      defmodule Foo do
+        @constant 1
+        @constant 2
+
+        @doc """
+        foo
+        """
+        def foo do
+          :ok
+        end
+
+        @spec bar :: 1
+        @spec bar :: 2
+        def bar do
+          :ok
+        end
+
+        @other_constant 3
+
+        @spec baz :: 4
+        @doc """
+        baz
+        """
+        def baz do
+          :ok
+        end
+
+        @another_constant 5
+        @another_constant 5
+
+        @doc """
+        baz
+        """
+        @spec baz :: 6
+        def baz do
+          :ok
+        end
+      end
+      '''
+    end
+
+    test "as function arguments" do
+      assert_same """
+      fun(
+        (
+          foo
+          bar
+        )
+      )
+      """
+
+      assert_same """
+      assert true,
+        do:
+          (
+            foo
+            bar
+          )
+      """
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/code_formatter/integration_test.exs b/lib/elixir/test/elixir/code_formatter/integration_test.exs
new file mode 100644
index 00000000000..7534bcd8823
--- /dev/null
+++ b/lib/elixir/test/elixir/code_formatter/integration_test.exs
@@ -0,0 +1,720 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Code.Formatter.IntegrationTest do
+  use ExUnit.Case, async: true
+
+  import CodeFormatterHelpers
+
+  test "empty documents" do
+    assert_format "   ", ""
+    assert_format "\n", ""
+    assert_format ";", ""
+  end
+
+  test "function with multiple calls and case" do
+    assert_same """
+    def equivalent(string1, string2) when is_binary(string1) and is_binary(string2) do
+      quoted1 = Code.string_to_quoted!(string1)
+      quoted2 = Code.string_to_quoted!(string2)
+
+      case not_equivalent(quoted1, quoted2) do
+        {left, right} -> {:error, left, right}
+        nil -> :ok
+      end
+    end
+    """
+  end
+
+  test "function with long pipeline" do
+    assert_same ~S"""
+    def to_algebra!(string, opts \\ []) when is_binary(string) and is_list(opts) do
+      string
+      |> Code.string_to_quoted!(wrap_literals_in_blocks: true, unescape: false)
+      |> block_to_algebra(state(opts))
+      |> elem(0)
+    end
+    """
+  end
+
+  test "case with multiple multi-line arrows" do
+    assert_same ~S"""
+    case meta[:format] do
+      :list_heredoc ->
+        string = list |> List.to_string() |> escape_string(:heredoc)
+        {@single_heredoc |> line(string) |> concat(@single_heredoc) |> force_unfit(), state}
+
+      :charlist ->
+        string = list |> List.to_string() |> escape_string(@single_quote)
+        {@single_quote |> concat(string) |> concat(@single_quote), state}
+
+      _other ->
+        list_to_algebra(list, state)
+    end
+    """
+  end
+
+  test "function with long guards" do
+    assert_same """
+    defp module_attribute_read?({:@, _, [{var, _, var_context}]})
+         when is_atom(var) and is_atom(var_context) do
+      Macro.classify_atom(var) == :identifier
+    end
+    """
+  end
+
+  test "anonymous function with single clause and blocks" do
+    assert_same """
+    {args_doc, state} =
+      Enum.reduce(args, {[], state}, fn quoted, {acc, state} ->
+        {doc, state} = quoted_to_algebra(quoted, :block, state)
+        doc = doc |> concat(nest(break(""), :reset)) |> group()
+        {[doc | acc], state}
+      end)
+    """
+  end
+
+  test "anonymous function with long single clause and blocks" do
+    assert_same """
+    {function_count, call_count, total_time} =
+      Enum.reduce(call_results, {0, 0, 0}, fn {_, {count, time}},
+                                              {function_count, call_count, total_time} ->
+        {function_count + 1, call_count + count, total_time + time}
+      end)
+    """
+  end
+
+  test "cond with long clause args" do
+    assert_same """
+    cond do
+      parent_prec == prec and parent_assoc == side ->
+        binary_op_to_algebra(op, op_string, left, right, context, state, op_info, nesting)
+
+      parent_op in @required_parens_on_binary_operands or parent_prec > prec or
+          (parent_prec == prec and parent_assoc != side) ->
+        {operand, state} =
+          binary_op_to_algebra(op, op_string, left, right, context, state, op_info, 2)
+
+        {concat(concat("(", nest(operand, 1)), ")"), state}
+
+      true ->
+        binary_op_to_algebra(op, op_string, left, right, context, state, op_info, 2)
+    end
+    """
+  end
+
+  test "type with multiple |" do
+    assert_same """
+    @type t ::
+            binary
+            | :doc_nil
+            | :doc_line
+            | doc_string
+            | doc_cons
+            | doc_nest
+            | doc_break
+            | doc_group
+            | doc_color
+            | doc_force
+            | doc_cancel
+    """
+  end
+
+  test "spec with when keywords and |" do
+    assert_same """
+    @spec send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend
+          when dest: pid | port | atom | {atom, node},
+               msg: any,
+               option: :noconnect | :nosuspend
+    """
+
+    assert_same """
+    @spec send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend
+          when dest:
+                 pid
+                 | port
+                 | atom
+                 | {atom, node}
+                 | and_a_really_long_type_to_force_a_line_break
+                 | followed_by_another_really_long_type
+    """
+
+    assert_same """
+    @callback get_and_update(data, key, (value -> {get_value, value} | :pop)) :: {get_value, data}
+              when get_value: var, data: container
+    """
+  end
+
+  test "spec with multiple keys on type" do
+    assert_same """
+    @spec foo(%{(String.t() | atom) => any}) :: any
+    """
+  end
+
+  test "multiple whens with new lines" do
+    assert_same """
+    def sleep(timeout)
+        when is_integer(timeout) and timeout >= 0
+        when timeout == :infinity do
+      receive after: (timeout -> :ok)
+    end
+    """
+  end
+
+  test "function with operator and pipeline" do
+    assert_same """
+    defp apply_next_break_fits?({fun, meta, args}) when is_atom(fun) and is_list(args) do
+      meta[:terminator] in [@double_heredoc, @single_heredoc] and
+        fun |> Atom.to_string() |> String.starts_with?("sigil_")
+    end
+    """
+  end
+
+  test "mixed parens and no parens calls with anonymous function" do
+    assert_same ~S"""
+    node interface do
+      resolve_type(fn
+        %{__struct__: str}, _ ->
+          str |> Model.Node.model_to_node_type()
+
+        value, _ ->
+          Logger.warning("Could not extract node type from value: #{inspect(value)}")
+          nil
+      end)
+    end
+    """
+  end
+
+  test "long defstruct definition" do
+    assert_same """
+    defstruct name: nil,
+              module: nil,
+              schema: nil,
+              alias: nil,
+              base_module: nil,
+              web_module: nil,
+              basename: nil,
+              file: nil,
+              test_file: nil
+    """
+  end
+
+  test "mix of operators and arguments" do
+    assert_same """
+    def count(%{path: path, line_or_bytes: bytes}) do
+      case File.stat(path) do
+        {:ok, %{size: 0}} -> {:error, __MODULE__}
+        {:ok, %{size: size}} -> {:ok, div(size, bytes) + if(rem(size, bytes) == 0, do: 0, else: 1)}
+        {:error, reason} -> raise File.Error, reason: reason, action: "stream", path: path
+      end
+    end
+    """
+  end
+
+  test "mix of left and right operands" do
+    assert_same """
+    defp server_get_modules(handlers) do
+      for(handler(module: module) <- handlers, do: module)
+      |> :ordsets.from_list()
+      |> :ordsets.to_list()
+    end
+    """
+
+    assert_same """
+    neighbours = for({_, _} = t <- neighbours, do: t) |> :sets.from_list()
+    """
+  end
+
+  test "long expression with single line anonymous function" do
+    assert_same """
+    for_many(uniq_list_of(integer(1..10000)), fn list ->
+      assert Enum.uniq(list) == list
+    end)
+    """
+  end
+
+  test "long comprehension" do
+    assert_same """
+    for %{app: app, opts: opts, top_level: true} <- Mix.Dep.cached(),
+        Keyword.get(opts, :app, true),
+        Keyword.get(opts, :runtime, true),
+        not Keyword.get(opts, :optional, false),
+        app not in included_applications,
+        app not in included_applications,
+        do: app
+    """
+  end
+
+  test "short comprehensions" do
+    assert_same """
+    for {protocol, :protocol, _beam} <- removed_metadata,
+        remove_consolidated(protocol, output),
+        do: {protocol, true},
+        into: %{}
+    """
+  end
+
+  test "comprehensions with when" do
+    assert_same """
+    for {key, value} when is_atom(key) <- Map.to_list(map),
+        key = Atom.to_string(key),
+        String.starts_with?(key, hint) do
+      %{kind: :map_key, name: key, value_is_map: is_map(value)}
+    end
+    """
+
+    assert_same """
+    with {_, doc} when unquote(doc_attr?) <-
+           Module.get_attribute(__MODULE__, unquote(name), unquote(escaped)),
+         do: doc
+    """
+  end
+
+  test "next break fits followed by inline tuple" do
+    assert_same """
+    assert ExUnit.Filters.eval([line: "1"], [:line], %{line: 3, describe_line: 2}, tests) ==
+             {:error, "due to line filter"}
+    """
+  end
+
+  test "try/catch with clause comment" do
+    assert_same """
+    def format_error(reason) do
+      try do
+        do_format_error(reason)
+      catch
+        # A user could create an error that looks like a built-in one
+        # causing an error.
+        :error, _ ->
+          inspect(reason)
+      end
+    end
+    """
+  end
+
+  test "case with when and clause comment" do
+    assert_same """
+    case decomposition do
+      # Decomposition
+      <<h, _::binary>> when h != ?< ->
+        decomposition =
+          decomposition
+          |> :binary.split(" ", [:global])
+          |> Enum.map(&String.to_integer(&1, 16))
+
+        Map.put(dacc, String.to_integer(codepoint, 16), decomposition)
+
+      _ ->
+        dacc
+    end
+    """
+  end
+
+  test "do-end inside binary" do
+    assert_same """
+    <<if true do
+        "hello"
+      end::binary>>
+    """
+  end
+
+  test "anonymous function with parens around integer argument" do
+    bad = """
+    fn (1) -> "hello" end
+    """
+
+    assert_format bad, """
+    fn 1 -> "hello" end
+    """
+  end
+
+  test "no parens keywords at the end of the line" do
+    bad = """
+    defmodule Mod do
+      def token_list_downcase(<<char, rest::binary>>, acc) when is_whitespace(char) or is_comma(char), do: token_list_downcase(rest, acc)
+      def token_list_downcase(some_really_long_arg11, some_really_long_arg22, some_really_long_arg33), do: token_list_downcase(rest, acc)
+    end
+    """
+
+    assert_format bad, """
+    defmodule Mod do
+      def token_list_downcase(<<char, rest::binary>>, acc) when is_whitespace(char) or is_comma(char),
+        do: token_list_downcase(rest, acc)
+
+      def token_list_downcase(some_really_long_arg11, some_really_long_arg22, some_really_long_arg33),
+        do: token_list_downcase(rest, acc)
+    end
+    """
+  end
+
+  test "do at the end of the line" do
+    bad = """
+    foo bar, baz, quux do
+      :ok
+    end
+    """
+
+    good = """
+    foo bar,
+        baz,
+        quux do
+      :ok
+    end
+    """
+
+    assert_format bad, good, line_length: 18
+  end
+
+  test "keyword lists in last line" do
+    assert_same """
+    content =
+      config(VeryLongModuleNameThatWillCauseBreak, "new.html",
+        conn: conn,
+        changeset: changeset,
+        categories: categories
+      )
+    """
+
+    assert_same """
+    content =
+      config VeryLongModuleNameThatWillCauseBreak, "new.html",
+        conn: conn,
+        changeset: changeset,
+        categories: categories
+    """
+  end
+
+  test "keyword list at line limit" do
+    bad = """
+    pre()
+    config(arg, foo: bar)
+    post()
+    """
+
+    good = """
+    pre()
+
+    config(arg,
+      foo: bar
+    )
+
+    post()
+    """
+
+    assert_format bad, good, line_length: 20
+  end
+
+  test "do at the end of the line with single argument" do
+    bad = """
+    defmodule Location do
+      def new(line, column) when is_integer(line) and line >= 0 and is_integer(column) and column >= 0 do
+        %{column: column, line: line}
+      end
+    end
+    """
+
+    assert_format bad, """
+    defmodule Location do
+      def new(line, column)
+          when is_integer(line) and line >= 0 and is_integer(column) and column >= 0 do
+        %{column: column, line: line}
+      end
+    end
+    """
+  end
+
+  test "tuples as trees" do
+    bad = """
+    @document Parser.parse(
+      {"html", [], [
+         {"head", [], []},
+         {"body", [], [
+              {"div", [], [
+                  {"p", [], ["1"]},
+                  {"p", [], ["2"]},
+                  {"div", [], [
+                      {"p", [], ["3"]},
+                      {"p", [], ["4"]}]},
+                  {"p", [], ["5"]}]}]}]})
+    """
+
+    assert_format bad, """
+    @document Parser.parse(
+                {"html", [],
+                 [
+                   {"head", [], []},
+                   {"body", [],
+                    [
+                      {"div", [],
+                       [
+                         {"p", [], ["1"]},
+                         {"p", [], ["2"]},
+                         {"div", [],
+                          [
+                            {"p", [], ["3"]},
+                            {"p", [], ["4"]}
+                          ]},
+                         {"p", [], ["5"]}
+                       ]}
+                    ]}
+                 ]}
+              )
+    """
+  end
+
+  test "nested tuples as lines" do
+    assert_same """
+                {:ok,
+                 {1, 2, 3,
+                  4, 5}} =
+                  call()
+                """,
+                line_length: 10
+  end
+
+  test "first argument in a call without parens with comments" do
+    assert_same """
+    with bar ::
+           :ok
+           | :invalid
+           # | :unknown
+           | :other
+    """
+
+    assert_same """
+    @spec bar ::
+            :ok
+            | :invalid
+            # | :unknown
+            | :other
+    """
+  end
+
+  test "when with keywords inside call" do
+    assert_same """
+    quote((bar(foo(1)) when bat: foo(1)), [])
+    """
+
+    assert_same """
+    quote(do: (bar(foo(1)) when bat: foo(1)), line: 1)
+    """
+
+    assert_same """
+    typespec(quote(do: (bar(foo(1)) when bat: foo(1))), [foo: 1], [])
+    """
+  end
+
+  test "false positive sigil" do
+    assert_same """
+    def sigil_d(<<year::2-bytes, "-", month::2-bytes, "-", day::2-bytes>>, calendar) do
+      ymd(year, month, day, calendar)
+    end
+    """
+  end
+
+  test "newline after stab" do
+    assert_same """
+    capture_io(":erl. mof*,,l", fn ->
+      assert :io.scan_erl_form(~c">") == {:ok, [{:":", 1}, {:atom, 1, :erl}, {:dot, 1}], 1}
+
+      expected_tokens = [{:atom, 1, :mof}, {:*, 1}, {:",", 1}, {:",", 1}, {:atom, 1, :l}]
+      assert :io.scan_erl_form(~c">") == {:ok, expected_tokens, 1}
+
+      assert :io.scan_erl_form(~c">") == {:eof, 1}
+    end)
+    """
+  end
+
+  test "capture with operators" do
+    assert_same """
+    "this works" |> (&String.upcase/1) |> (&String.downcase/1)
+    """
+
+    assert_same """
+    "this works" || (&String.upcase/1) || (&String.downcase/1)
+    """
+
+    assert_same """
+    "this works" == (&String.upcase/1) == (&String.downcase/1)
+    """
+
+    bad = """
+    "this works" = (&String.upcase/1) = (&String.downcase/1)
+    """
+
+    assert_format bad, """
+    "this works" = (&String.upcase/1) = &String.downcase/1
+    """
+
+    bad = """
+    "this works" ++ (&String.upcase/1) ++ (&String.downcase/1)
+    """
+
+    assert_format bad, """
+    "this works" ++ (&String.upcase/1) ++ &String.downcase/1
+    """
+
+    bad = """
+    "this works" +++ (&String.upcase/1) +++ (&String.downcase/1)
+    """
+
+    assert_format bad, """
+    "this works" +++ (&String.upcase/1) +++ &String.downcase/1
+    """
+
+    bad = """
+    "this works" | (&String.upcase/1) | (&String.downcase/1)
+    """
+
+    assert_format bad, """
+    "this works" | (&String.upcase/1) | &String.downcase/1
+    """
+
+    bad = ~S"""
+    "this works" \\ (&String.upcase/1) \\ (&String.downcase/1)
+    """
+
+    assert_format bad, ~S"""
+    "this works" \\ &String.upcase/1 \\ &String.downcase/1
+    """
+  end
+
+  test "multiline expression inside interpolation" do
+    bad = ~S"""
+    Logger.info("Example: #{
+      inspect(%{
+        a: 1,
+        b: 2
+      })
+    }")
+    """
+
+    assert_format bad, ~S"""
+    Logger.info("Example: #{inspect(%{a: 1, b: 2})}")
+    """
+  end
+
+  test "comment inside operator with when" do
+    bad = """
+    raise function(x) ::
+            # Comment
+            any
+    """
+
+    assert_format bad, """
+    # Comment
+    raise function(x) ::
+            any
+    """
+
+    bad = """
+    raise function(x) ::
+            # Comment
+            any
+          when x: any
+    """
+
+    assert_format bad, """
+    raise function(x) ::
+            any
+          # Comment
+          when x: any
+    """
+
+    bad = """
+    @spec function(x) ::
+            # Comment
+            any
+          when x: any
+    """
+
+    assert_format bad, """
+    @spec function(x) ::
+            any
+          # Comment
+          when x: any
+    """
+
+    bad = """
+    @spec function(x) ::
+            # Comment
+            any
+          when x
+          when y
+    """
+
+    assert_format bad, """
+    @spec function(x) ::
+            any
+          # Comment
+          when x
+          when y
+    """
+  end
+
+  test "nested heredocs with multi-line string in interpolation" do
+    bad = ~S'''
+    def foo do
+      """
+      #{(feature_flag(:feature_x) && "
+      new_field
+      " || "")}
+      """
+    end
+    '''
+
+    good = ~S'''
+    def foo do
+      """
+      #{(feature_flag(:feature_x) && "
+      new_field
+      ") || ""}
+      """
+    end
+    '''
+
+    assert_format bad, good
+  end
+
+  test "functions with infinity line length" do
+    assert_same ~S"""
+                x = fn ->
+                  {:ok, pid} = Repl.start_link({self(), opts})
+                  assert Exception.message(error) =~ msg
+                end
+                """,
+                line_length: :infinity
+
+    assert_same ~S"""
+                capture_log(fn x ->
+                  {:ok, pid} = Repl.start_link({self(), opts})
+                  assert Exception.message(error) =~ msg
+                end) =~ msg
+                """,
+                line_length: :infinity
+
+    assert_same ~S"""
+                capture_log(fn ->
+                  {:ok, pid} = Repl.start_link({self(), opts})
+                  assert Exception.message(error) =~ msg
+                end) =~ msg
+                """,
+                line_length: :infinity
+
+    assert_same ~S"""
+                capture_log(fn x ->
+                  {:ok, pid} = Repl.start_link({self(), opts})
+                  assert Exception.message(error) =~ msg
+                end) =~ msg
+                """,
+                line_length: :infinity
+  end
+
+  test "functions without parentheses within do: keyword" do
+    assert_format ~S"defmodule Foo, do: foo bar, baz",
+                  ~S"defmodule Foo, do: foo(bar, baz)"
+  end
+end
diff --git a/lib/elixir/test/elixir/code_formatter/literals_test.exs b/lib/elixir/test/elixir/code_formatter/literals_test.exs
new file mode 100644
index 00000000000..da252fbf4e0
--- /dev/null
+++ b/lib/elixir/test/elixir/code_formatter/literals_test.exs
@@ -0,0 +1,412 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Code.Formatter.LiteralsTest do
+  use ExUnit.Case, async: true
+
+  import CodeFormatterHelpers
+
+  @short_length [line_length: 10]
+
+  describe "integers" do
+    test "in decimal base" do
+      assert_same "0"
+      assert_same "100"
+      assert_same "007"
+      assert_same "10000"
+      assert_same "100_00"
+      assert_format "100000", "100_000"
+      assert_format "1000000", "1_000_000"
+    end
+
+    test "in binary base" do
+      assert_same "0b0"
+      assert_same "0b1"
+      assert_same "0b101"
+      assert_same "0b01"
+      assert_same "0b111_111"
+    end
+
+    test "in octal base" do
+      assert_same "0o77"
+      assert_same "0o0"
+      assert_same "0o01"
+      assert_same "0o777_777"
+    end
+
+    test "in hex base" do
+      assert_same "0x1"
+      assert_format "0xabcdef", "0xABCDEF"
+      assert_same "0x01"
+      assert_format "0xfff_fff", "0xFFF_FFF"
+    end
+
+    test "as chars" do
+      assert_same "?a"
+      assert_same "?1"
+      assert_same "?è"
+      assert_same "??"
+      assert_same "?\\\\"
+      assert_same "?\\s"
+      assert_same "?🎾"
+    end
+  end
+
+  describe "floats" do
+    test "with normal notation" do
+      assert_same "0.0"
+      assert_same "1.0"
+      assert_same "123.456"
+      assert_same "0.0000001"
+      assert_same "001.100"
+      assert_same "0_10000_0.000_000"
+      assert_format "0100000.000000", "0_100_000.000000"
+    end
+
+    test "with scientific notation" do
+      assert_same "1.0e1"
+      assert_same "1.0e-1"
+      assert_same "1.0e01"
+      assert_same "1.0e-01"
+      assert_same "001.100e-010"
+      assert_same "0_100_0000.100e-010"
+      assert_format "0100000.0e-5", "0_100_000.0e-5"
+
+      assert_format "1.0E01", "1.0e01"
+      assert_format "1.0E-01", "1.0e-01"
+    end
+  end
+
+  describe "atoms" do
+    test "true, false, nil" do
+      assert_same "nil"
+      assert_same "true"
+      assert_same "false"
+    end
+
+    test "without escapes" do
+      assert_same ~S[:foo]
+      assert_same ~S[:\\]
+    end
+
+    test "with escapes" do
+      assert_same ~S[:"f\a\b\ro"]
+      assert_format ~S[:'f\a\b\ro'], ~S[:"f\a\b\ro"]
+      assert_format ~S[:'single \' quote'], ~S[:"single ' quote"]
+      assert_format ~S[:"double \" quote"], ~S[:"double \" quote"]
+      assert_same ~S[:"\\"]
+    end
+
+    test "with unicode" do
+      assert_same ~S[:ólá]
+    end
+
+    test "does not reformat aliases" do
+      assert_same ~S[:"Elixir.String"]
+    end
+
+    test "removes quotes when they are not necessary" do
+      assert_format ~S[:"foo"], ~S[:foo]
+      assert_format ~S[:"++"], ~S[:++]
+    end
+
+    test "quoted operators" do
+      assert_same ~S[:"::"]
+    end
+
+    test "uses double quotes even when single quotes are used" do
+      assert_format ~S[:'foo bar'], ~S[:"foo bar"]
+    end
+
+    test "with interpolation" do
+      assert_same ~S[:"one #{2} three"]
+    end
+
+    test "with escapes and interpolation" do
+      assert_same ~S[:"one\n\"#{2}\"\nthree"]
+    end
+
+    test "with interpolation on line limit" do
+      assert_same ~S"""
+                  :"one #{"two"} three"
+                  """,
+                  @short_length
+    end
+  end
+
+  describe "strings" do
+    test "without escapes" do
+      assert_same ~S["foo"]
+    end
+
+    test "with escapes" do
+      assert_same ~S["f\a\b\ro"]
+      assert_same ~S["double \" quote"]
+    end
+
+    test "keeps literal new lines" do
+      assert_same """
+      "fo
+      o"
+      """
+    end
+
+    test "with interpolation" do
+      assert_same ~S["one #{} three"]
+      assert_same ~S["one #{2} three"]
+    end
+
+    test "with interpolation uses block content" do
+      assert_format ~S["one #{@two(three)}"], ~S["one #{@two three}"]
+    end
+
+    test "with interpolation on line limit" do
+      assert_same ~S"""
+                  "one #{"two"} three"
+                  """,
+                  @short_length
+    end
+
+    test "with escaped interpolation" do
+      assert_same ~S["one\#{two}three"]
+    end
+
+    test "with escapes and interpolation" do
+      assert_same ~S["one\n\"#{2}\"\nthree"]
+    end
+
+    test "is measured in graphemes" do
+      assert_same ~S"""
+                  "áá#{0}áá"
+                  """,
+                  @short_length
+    end
+
+    test "literal new lines don't count towards line limit" do
+      assert_same ~S"""
+                  "one
+                  #{"two"}
+                  three"
+                  """,
+                  @short_length
+    end
+  end
+
+  describe "charlists" do
+    test "without escapes" do
+      assert_same ~S['']
+      assert_same ~S[' ']
+      assert_same ~S['foo']
+    end
+
+    test "with escapes" do
+      assert_same ~S['f\a\b\ro']
+      assert_same ~S['single \' quote']
+      assert_same ~S['double " quote']
+      assert_same ~S['escaped \" quote']
+      assert_same ~S['\\"']
+    end
+
+    test "keeps literal new lines" do
+      assert_same """
+      'fo
+      o'
+      """
+    end
+
+    test "with interpolation" do
+      assert_same ~S['one #{2} three']
+      assert_same ~S['#{1}\n \\ " \"']
+    end
+
+    test "with escape and interpolation" do
+      assert_same ~S['one\n\'#{2}\'\nthree']
+    end
+
+    test "with interpolation on line limit" do
+      assert_same ~S"""
+                  'one #{"two"} three'
+                  """,
+                  @short_length
+    end
+
+    test "literal new lines don't count towards line limit" do
+      assert_same ~S"""
+                  'one
+                  #{"two"}
+                  three'
+                  """,
+                  @short_length
+    end
+  end
+
+  describe "string heredocs" do
+    test "without escapes" do
+      assert_same ~S'''
+      """
+      hello
+      """
+      '''
+    end
+
+    test "with escapes" do
+      assert_same ~S'''
+      """
+      f\a\b\ro
+      """
+      '''
+
+      assert_same ~S'''
+      """
+      multiple "\"" quotes
+      """
+      '''
+    end
+
+    test "with interpolation" do
+      assert_same ~S'''
+      """
+      one
+      #{2}
+      three
+      """
+      '''
+
+      assert_same ~S'''
+      """
+      one
+      "
+      #{2}
+      "
+      three
+      """
+      '''
+    end
+
+    test "with interpolation on line limit" do
+      assert_same ~S'''
+                  """
+                  one #{"two two"} three
+                  """
+                  ''',
+                  @short_length
+    end
+
+    test "nested with empty lines" do
+      assert_same ~S'''
+      nested do
+        """
+
+        foo
+
+
+        bar
+
+        """
+      end
+      '''
+    end
+
+    test "nested with empty lines and interpolation" do
+      assert_same ~S'''
+      nested do
+        """
+
+        #{foo}
+
+
+        #{bar}
+
+        """
+      end
+      '''
+
+      assert_same ~S'''
+      nested do
+        """
+        #{foo}
+
+
+        #{bar}
+        """
+      end
+      '''
+    end
+
+    test "literal new lines don't count towards line limit" do
+      assert_same ~S'''
+                  """
+                  one
+                  #{"two"}
+                  three
+                  """
+                  ''',
+                  @short_length
+    end
+
+    test "with escaped new lines" do
+      assert_same ~S'''
+      """
+      one\
+      #{"two"}\
+      three\
+      """
+      '''
+    end
+
+    test "with new lines" do
+      assert_format ~s|foo do\n  """\n  foo\n  \n  bar\n  """\nend|,
+                    ~s|foo do\n  """\n  foo\n\n  bar\n  """\nend|
+
+      assert_format ~s|foo do\r\n  """\r\n  foo\r\n  \r\n  bar\r\n  """\r\nend|,
+                    ~s|foo do\n  """\n  foo\r\n\r\n  bar\r\n  """\nend|
+    end
+  end
+
+  describe "charlist heredocs" do
+    test "without escapes" do
+      assert_same ~S"""
+      '''
+      hello
+      '''
+      """
+    end
+
+    test "with escapes" do
+      assert_same ~S"""
+      '''
+      f\a\b\ro
+      '''
+      """
+
+      assert_same ~S"""
+      '''
+      multiple "\"" quotes
+      '''
+      """
+    end
+
+    test "with interpolation" do
+      assert_same ~S"""
+      '''
+      one
+      #{2}
+      three
+      '''
+      """
+
+      assert_same ~S"""
+      '''
+      one
+      "
+      #{2}
+      "
+      three
+      '''
+      """
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/code_formatter/migration_test.exs b/lib/elixir/test/elixir/code_formatter/migration_test.exs
new file mode 100644
index 00000000000..67ebee75798
--- /dev/null
+++ b/lib/elixir/test/elixir/code_formatter/migration_test.exs
@@ -0,0 +1,328 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Code.Formatter.MigrationTest do
+  use ExUnit.Case, async: true
+
+  import CodeFormatterHelpers
+
+  @short_length [line_length: 10]
+
+  describe "migrate_bitstring_modifiers: true" do
+    @opts [migrate_bitstring_modifiers: true]
+
+    test "normalizes bitstring modifiers" do
+      assert_format "<<foo::binary()>>", "<<foo::binary>>", @opts
+      assert_same "<<foo::binary>>", @opts
+
+      assert_format "<<foo::custom_type>>", "<<foo::custom_type()>>", @opts
+      assert_same "<<foo::custom_type()>>", @opts
+
+      assert_format "<<x::binary()-(13 * 6)-custom>>", "<<x::binary-(13 * 6)-custom()>>", @opts
+      assert_same "<<x::binary-(13 * 6)-custom()>>", @opts
+      assert_same "<<0::size*unit, bytes::binary>>", @opts
+      assert_format "<<0::size*unit, bytes::custom>>", "<<0::size*unit, bytes::custom()>>", @opts
+
+      assert_format "<<0, 1::2-integer() <- x>>", "<<0, 1::2-integer <- x>>", @opts
+      assert_same "<<0, 1::2-integer <- x>>", @opts
+    end
+  end
+
+  describe "migrate_call_parens_on_pipe: true" do
+    @opts [migrate_call_parens_on_pipe: true]
+
+    test "adds parentheses on the right operand" do
+      assert_format "x |> y", "x |> y()", @opts
+      assert_format "x |> y |> z", "x |> y() |> z()", @opts
+      assert_format "x |> y.z", "x |> y.z()", @opts
+      assert_format "x |> y.z.t", "x |> y.z.t()", @opts
+    end
+
+    test "does nothing within defmacro" do
+      assert_same "defmacro left |> right, do: ...", @opts
+    end
+
+    test "does nothing without the migrate_unless option" do
+      assert_same "x |> y"
+      assert_same "x |> y |> z"
+      assert_same "x |> y.z"
+    end
+  end
+
+  describe "migrate_charlists_as_sigils: true" do
+    @opts [migrate_charlists_as_sigils: true]
+
+    test "without escapes" do
+      assert_format ~S[''], ~S[~c""], @opts
+      assert_format ~S[' '], ~S[~c" "], @opts
+      assert_format ~S['foo'], ~S[~c"foo"], @opts
+    end
+
+    test "with escapes" do
+      assert_format ~S['f\a\b\ro'], ~S[~c"f\a\b\ro"], @opts
+      assert_format ~S['single \' quote'], ~S[~c"single ' quote"], @opts
+      assert_format ~S['double " quote'], ~S[~c'double " quote'], @opts
+      assert_format ~S['escaped \" quote'], ~S[~c'escaped \" quote'], @opts
+      assert_format ~S['\\"'], ~S[~c'\\"'], @opts
+    end
+
+    test "keeps literal new lines" do
+      assert_format """
+                    'fo
+                    o'
+                    """,
+                    """
+                    ~c"fo
+                    o"
+                    """,
+                    @opts
+    end
+
+    test "with interpolation" do
+      assert_format ~S['one #{2} three'], ~S[~c"one #{2} three"], @opts
+      assert_format ~S['#{1}\n \\ " \"'], ~S[~c'#{1}\n \\ " \"'], @opts
+    end
+
+    test "with escape and interpolation" do
+      assert_format ~S['one\n\'#{2}\'\nthree'], ~S[~c"one\n'#{2}'\nthree"], @opts
+      assert_format ~S['one\n"#{2}"\nthree'], ~S[~c'one\n"#{2}"\nthree'], @opts
+    end
+
+    test "with interpolation on line limit" do
+      assert_format ~S"""
+                    'one #{"two"} three'
+                    """,
+                    ~S"""
+                    ~c"one #{"two"} three"
+                    """,
+                    @short_length ++ @opts
+    end
+
+    test "literal new lines don't count towards line limit" do
+      assert_format ~S"""
+                    'one
+                    #{"two"}
+                    three'
+                    """,
+                    ~S"""
+                    ~c"one
+                    #{"two"}
+                    three"
+                    """,
+                    @short_length ++ @opts
+    end
+
+    test "heredocs without escapes" do
+      assert_format ~S"""
+                    '''
+                    hello
+                    '''
+                    """,
+                    ~S'''
+                    ~c"""
+                    hello
+                    """
+                    ''',
+                    @opts
+    end
+
+    test "heredocs with escapes" do
+      assert_format ~S"""
+                    '''
+                    f\a\b\ro
+                    '''
+                    """,
+                    ~S'''
+                    ~c"""
+                    f\a\b\ro
+                    """
+                    ''',
+                    @opts
+
+      assert_format ~S"""
+                    '''
+                    multiple "\"" quotes
+                    '''
+                    """,
+                    ~S'''
+                    ~c"""
+                    multiple "\"" quotes
+                    """
+                    ''',
+                    @opts
+    end
+
+    test "heredocs with interpolation" do
+      assert_format ~S"""
+                    '''
+                    one
+                    #{2}
+                    three
+                    '''
+                    """,
+                    ~S'''
+                    ~c"""
+                    one
+                    #{2}
+                    three
+                    """
+                    ''',
+                    @opts
+
+      assert_format ~S"""
+                    '''
+                    one
+                    "
+                    #{2}
+                    "
+                    three
+                    '''
+                    """,
+                    ~S'''
+                    ~c"""
+                    one
+                    "
+                    #{2}
+                    "
+                    three
+                    """
+                    ''',
+                    @opts
+    end
+
+    test "heredocs with interpolation on line limit" do
+      assert_format ~S"""
+                    '''
+                    one #{"two two"} three
+                    '''
+                    """,
+                    ~S'''
+                    ~c"""
+                    one #{"two two"} three
+                    """
+                    ''',
+                    @short_length ++ @opts
+    end
+
+    test "heredocs literal new lines don't count towards line limit" do
+      assert_format ~S"""
+                    '''
+                    one
+                    #{"two"}
+                    three
+                    '''
+                    """,
+                    ~S'''
+                    ~c"""
+                    one
+                    #{"two"}
+                    three
+                    """
+                    ''',
+                    @short_length ++ @opts
+    end
+  end
+
+  describe "migrate_unless: true" do
+    @opts [migrate_unless: true]
+
+    test "rewrites unless as an if with negated condition" do
+      bad = "unless x, do: y"
+
+      good = "if !x, do: y"
+
+      assert_format bad, good, @opts
+
+      bad = """
+      unless x do
+        y
+      else
+        z
+      end
+      """
+
+      good = """
+      if !x do
+        y
+      else
+        z
+      end
+      """
+
+      assert_format bad, good, @opts
+    end
+
+    test "rewrites pipelines with negated condition" do
+      bad = "x |> unless(do: y)"
+
+      good = "!x |> if(do: y)"
+
+      assert_format bad, good, @opts
+
+      bad = "x |> foo() |> unless(do: y)"
+
+      good = "x |> foo() |> Kernel.!() |> if(do: y)"
+
+      assert_format bad, good, @opts
+
+      bad = "unless x |> foo(), do: y"
+      good = "if !(x |> foo()), do: y"
+
+      assert_format bad, good, @opts
+    end
+
+    test "rewrites in as not in" do
+      assert_format "unless x in y, do: 1", "if x not in y, do: 1", @opts
+    end
+
+    test "rewrites equality operators" do
+      assert_format "unless x == y, do: 1", "if x != y, do: 1", @opts
+      assert_format "unless x === y, do: 1", "if x !== y, do: 1", @opts
+      assert_format "unless x != y, do: 1", "if x == y, do: 1", @opts
+      assert_format "unless x !== y, do: 1", "if x === y, do: 1", @opts
+    end
+
+    test "rewrites boolean or is_* conditions with not" do
+      assert_format "unless x > 0, do: 1", "if not (x > 0), do: 1", @opts
+      assert_format "unless is_atom(x), do: 1", "if not is_atom(x), do: 1", @opts
+    end
+
+    test "removes ! or not in condition" do
+      assert_format "unless not x, do: 1", "if x, do: 1", @opts
+      assert_format "unless !x, do: 1", "if x, do: 1", @opts
+    end
+
+    test "does nothing without the migrate_unless option" do
+      assert_same "unless x, do: y"
+      assert_same "unless x, do: y, else: z"
+    end
+  end
+
+  describe "migrate: true" do
+    test "enables :migrate_bitstring_modifiers" do
+      assert_format "<<foo::binary()>>", "<<foo::binary>>", migrate: true
+    end
+
+    test "enables :migrate_call_parens_on_pipe" do
+      bad = "x |> y"
+
+      good = "x |> y()"
+
+      assert_format bad, good, migrate: true
+    end
+
+    test "enables :migrate_charlists_as_sigils" do
+      assert_format ~S['abc'], ~S[~c"abc"], migrate: true
+    end
+
+    test "enables :migrate_unless" do
+      bad = "unless x, do: y"
+
+      good = "if !x, do: y"
+
+      assert_format bad, good, migrate: true
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/code_formatter/operators_test.exs b/lib/elixir/test/elixir/code_formatter/operators_test.exs
new file mode 100644
index 00000000000..e897d5729f4
--- /dev/null
+++ b/lib/elixir/test/elixir/code_formatter/operators_test.exs
@@ -0,0 +1,986 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Code.Formatter.OperatorsTest do
+  use ExUnit.Case, async: true
+
+  import CodeFormatterHelpers
+
+  @short_length [line_length: 10]
+  @medium_length [line_length: 20]
+
+  describe "nullary" do
+    test "formats symbol operators" do
+      assert_same ".."
+    end
+
+    test "combines with unary and binary operators" do
+      assert_same "not .."
+      assert_same "left = .."
+      assert_same ".. = right"
+    end
+
+    test "is wrapped in parentheses on ambiguous calls" do
+      assert_same "require (..)"
+      assert_same "require foo, (..)"
+      assert_same "require (..), bar"
+      assert_same "require(..)"
+      assert_same "require(foo, ..)"
+      assert_same "require(.., bar)"
+
+      assert_same "assert [.., :ok]"
+      assert_same "assert {.., :ok}"
+      assert_same "assert (..) == 0..-1//1"
+      assert_same "assert 0..-1//1 == (..)"
+
+      assert_same """
+      defmacro (..) do
+        :ok
+      end\
+      """
+
+      assert_format "Range.range? (..)", "Range.range?(..)"
+    end
+  end
+
+  describe "unary" do
+    test "formats symbol operators without spaces" do
+      assert_format "+ 1", "+1"
+      assert_format "- 1", "-1"
+      assert_format "! 1", "!1"
+      assert_format "^ 1", "^1"
+    end
+
+    test "formats word operators with spaces" do
+      assert_same "not 1"
+      assert_same "not true"
+    end
+
+    test "wraps operand if it is a unary or binary operator" do
+      assert_format "!+1", "!(+1)"
+      assert_format "+ +1", "+(+1)"
+      assert_format "not +1", "not (+1)"
+      assert_format "!not 1", "!(not 1)"
+      assert_format "not !1", "not (!1)"
+      assert_format "not(!1)", "not (!1)"
+      assert_format "not(1 + 1)", "not (1 + 1)"
+      assert_format "-(2**2)", "-(2 ** 2)"
+    end
+
+    test "wraps operand in ambiguous calls" do
+      assert_same "def -(2 ** 2)"
+      assert_same "def -var"
+      assert_format "def (-(2 ** 2))", "def -(2 ** 2)"
+      assert_format "def --var", "def -- var"
+      assert_format "def -+var", "def -(+var)"
+    end
+
+    test "does not wrap operand if it is a nestable operator" do
+      assert_format "! ! var", "!!var"
+      assert_same "not not var"
+    end
+
+    test "nests operand" do
+      bad = "+foo(bar, baz, bat)"
+
+      good = """
+      +foo(
+        bar,
+        baz,
+        bat
+      )
+      """
+
+      assert_format bad, good, @short_length
+
+      operator = """
+      +assert foo,
+              bar
+      """
+
+      assert_same operator, @short_length
+    end
+
+    test "does not nest operand" do
+      bad = "not foo(bar, baz, bat)"
+
+      good = """
+      not foo(
+        bar,
+        baz,
+        bat
+      )
+      """
+
+      assert_format bad, good, @short_length
+
+      operator = """
+      not assert foo,
+                 bar
+      """
+
+      assert_same operator, @short_length
+    end
+
+    test "inside do-end block" do
+      assert_same """
+      if +value do
+        true
+      end
+      """
+    end
+  end
+
+  describe "binary without space" do
+    test "formats without spaces" do
+      assert_format "1 .. 2", "1..2"
+    end
+
+    test "never breaks" do
+      assert_same "123_456_789..987_654_321", @short_length
+    end
+  end
+
+  describe "ternary without space" do
+    test "formats without spaces" do
+      assert_format "1 .. 2 // 3", "1..2//3"
+      assert_same "(1..2//3).step"
+    end
+
+    test "never breaks" do
+      assert_same "123_456_789..987_654_321//147_268_369", @short_length
+    end
+  end
+
+  describe "binary without newline" do
+    test "formats without spaces" do
+      assert_same "1 in 2"
+      assert_format "1\\\\2", "1 \\\\ 2"
+    end
+
+    test "never breaks" do
+      assert_same "123_456_789 in 987_654_321", @short_length
+    end
+
+    test "not in" do
+      assert_format "not(foo in bar)", "foo not in bar"
+
+      assert_same "foo not in bar"
+      assert_same "(not foo) in bar"
+      assert_same "(!foo) in bar"
+    end
+
+    test "bitwise precedence" do
+      assert_format "(crc >>> 8) ||| byte", "crc >>> 8 ||| byte"
+      assert_same "crc >>> (8 ||| byte)"
+    end
+  end
+
+  describe "binary operators with preceding new line" do
+    test "formats with spaces" do
+      assert_format "1|>2", "1 |> 2"
+    end
+
+    test "breaks into new line" do
+      bad = "123_456_789 |> 987_654_321"
+
+      good = """
+      123_456_789
+      |> 987_654_321
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "123 |> foo(bar, baz)"
+
+      good = """
+      123
+      |> foo(
+        bar,
+        baz
+      )
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "123 |> foo(bar) |> bar(bat)"
+
+      good = """
+      123
+      |> foo(
+        bar
+      )
+      |> bar(
+        bat
+      )
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "foo(bar, 123 |> bar(baz))"
+
+      good = """
+      foo(
+        bar,
+        123
+        |> bar(
+          baz
+        )
+      )
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "foo(bar, baz) |> 123"
+
+      good = """
+      foo(
+        bar,
+        baz
+      )
+      |> 123
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "foo(bar, baz) |> 123 |> 456"
+
+      good = """
+      foo(
+        bar,
+        baz
+      )
+      |> 123
+      |> 456
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "123 |> foo(bar, baz) |> 456"
+
+      good = """
+      123
+      |> foo(
+        bar,
+        baz
+      )
+      |> 456
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with multiple of the different entry and same precedence" do
+      assert_same "foo <~> bar ~> baz"
+
+      bad = "foo <~> bar ~> baz"
+
+      good = """
+      foo
+      <~> bar
+      ~> baz
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with multiple of the different entry, same precedence and right associative" do
+      assert_format "foo ++ bar ++ baz -- bat", "foo ++ bar ++ (baz -- bat)"
+
+      assert_format "foo +++ bar +++ baz --- bat", "foo +++ bar +++ (baz --- bat)"
+    end
+
+    test "preserves user choice even when it fits" do
+      assert_same """
+      foo
+      |> bar
+      """
+
+      assert_same """
+      foo =
+        one
+        |> two()
+        |> three()
+      """
+
+      bad = """
+      foo |>
+        bar
+      """
+
+      good = """
+      foo
+      |> bar
+      """
+
+      assert_format bad, good
+    end
+  end
+
+  describe "binary with following new line" do
+    test "formats with spaces" do
+      assert_format "1++2", "1 ++ 2"
+
+      assert_format "1+++2", "1 +++ 2"
+    end
+
+    test "breaks into new line" do
+      bad = "123_456_789 ++ 987_654_321"
+
+      good = """
+      123_456_789 ++
+        987_654_321
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "123 ++ foo(bar)"
+
+      good = """
+      123 ++
+        foo(bar)
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "123 ++ foo(bar, baz)"
+
+      good = """
+      123 ++
+        foo(
+          bar,
+          baz
+        )
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "foo(bar, 123 ++ bar(baz))"
+
+      good = """
+      foo(
+        bar,
+        123 ++
+          bar(
+            baz
+          )
+      )
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "foo(bar, baz) ++ 123"
+
+      good = """
+      foo(
+        bar,
+        baz
+      ) ++ 123
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with multiple of the same entry and left associative" do
+      assert_same "foo == bar == baz"
+
+      bad = "a == b == c"
+
+      good = """
+      a == b ==
+        c
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "(a == (b == c))"
+
+      good = """
+      a ==
+        (b == c)
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "foo == bar == baz"
+
+      good = """
+      foo == bar ==
+        baz
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "(foo == (bar == baz))"
+
+      good = """
+      foo ==
+        (bar ==
+           baz)
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with multiple of the same entry and right associative" do
+      assert_same "foo ++ bar ++ baz"
+      assert_format "foo -- bar -- baz", "foo -- (bar -- baz)"
+      assert_same "foo +++ bar +++ baz"
+      assert_format "foo --- bar --- baz", "foo --- (bar --- baz)"
+
+      bad = "a ++ b ++ c"
+
+      good = """
+      a ++
+        b ++ c
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "((a ++ b) ++ c)"
+
+      good = """
+      (a ++ b) ++
+        c
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "foo ++ bar ++ baz"
+
+      good = """
+      foo ++
+        bar ++
+        baz
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "((foo ++ bar) ++ baz)"
+
+      good = """
+      (foo ++
+         bar) ++
+        baz
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with precedence" do
+      assert_format "(a + b) == (c + d)", "a + b == c + d"
+      assert_format "a + (b == c) + d", "a + (b == c) + d"
+
+      bad = "(a + b) == (c + d)"
+
+      good = """
+      a + b ==
+        c + d
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "a * (b + c) * d"
+
+      good = """
+      a *
+        (b + c) *
+        d
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "(one + two) == (three + four)"
+
+      good = """
+      one + two ==
+        three + four
+      """
+
+      assert_format bad, good, @medium_length
+
+      bad = "one * (two + three) * four"
+
+      good = """
+      one * (two + three) *
+        four
+      """
+
+      assert_format bad, good, @medium_length
+
+      bad = "one * (two + three + four) * five"
+
+      good = """
+      one *
+        (two + three +
+           four) * five
+      """
+
+      assert_format bad, good, @medium_length
+
+      bad = "var = one * (two + three + four) * five"
+
+      good = """
+      var =
+        one *
+          (two + three +
+             four) * five
+      """
+
+      assert_format bad, good, @medium_length
+    end
+
+    test "with required parens" do
+      assert_same "(a |> b) ++ (c |> d)"
+      assert_format "a + b |> c + d", "(a + b) |> (c + d)"
+      assert_format "a ++ b |> c ++ d", "(a ++ b) |> (c ++ d)"
+      assert_format "a |> b ++ c |> d", "a |> (b ++ c) |> d"
+    end
+
+    test "with required parens skips on no parens" do
+      assert_same "1..2 |> 3..4"
+    end
+
+    test "with logical operators" do
+      assert_same "a or b or c"
+      assert_format "a or b and c", "a or (b and c)"
+      assert_format "a and b or c", "(a and b) or c"
+    end
+
+    test "mixed before and after lines" do
+      bad = "var :: a | b and c | d"
+
+      good = """
+      var ::
+        a
+        | b and
+            c
+        | d
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "var :: a | b and c + d + e + f | g"
+
+      good = """
+      var ::
+        a
+        | b and
+            c + d + e + f
+        | g
+      """
+
+      assert_format bad, good, @medium_length
+
+      assert_same """
+      var ::
+        {
+          :one,
+          :two
+        }
+        | :three
+      """
+    end
+
+    test "preserves user choice even when it fits and left associative" do
+      assert_same """
+      foo + bar +
+        baz + bat
+      """
+
+      assert_same """
+      foo +
+        bar +
+        baz +
+        bat
+      """
+    end
+
+    test "preserves user choice even when it fits and right associative" do
+      bad = """
+      foo ++ bar ++
+        baz ++ bat
+      """
+
+      assert_format bad, """
+      foo ++
+        bar ++
+        baz ++ bat
+      """
+
+      assert_same """
+      foo ++
+        bar ++
+        baz ++
+        bat
+      """
+    end
+  end
+
+  # Theoretically it fits under binary operators
+  # but the goal of this section is to test common idioms.
+  describe "match" do
+    test "with calls" do
+      bad = "var = fun(one, two, three)"
+
+      good = """
+      var =
+        fun(
+          one,
+          two,
+          three
+        )
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "fun(one, two, three) = var"
+
+      good = """
+      fun(
+        one,
+        two,
+        three
+      ) = var
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "fun(foo, bar) = fun(baz, bat)"
+
+      good = """
+      fun(
+        foo,
+        bar
+      ) =
+        fun(
+          baz,
+          bat
+        )
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "fun(foo, bar) = fun(baz, bat)"
+
+      good = """
+      fun(foo, bar) =
+        fun(baz, bat)
+      """
+
+      assert_format bad, good, @medium_length
+    end
+
+    test "with containers" do
+      bad = "var = [one, two, three]"
+
+      good = """
+      var = [
+        one,
+        two,
+        three
+      ]
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = """
+      var =
+        [one, two, three]
+      """
+
+      good = """
+      var =
+        [
+          one,
+          two,
+          three
+        ]
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "[one, two, three] = var"
+
+      good = """
+      [
+        one,
+        two,
+        three
+      ] = var
+      """
+
+      assert_format bad, good, @short_length
+
+      bad = "[one, two, three] = foo(bar, baz)"
+
+      good = """
+      [one, two, three] =
+        foo(bar, baz)
+      """
+
+      assert_format bad, good, @medium_length
+    end
+
+    test "with heredoc" do
+      heredoc = ~S'''
+      var = """
+      one
+      """
+      '''
+
+      assert_same heredoc, @short_length
+
+      heredoc = ~S'''
+      var = """
+      #{one}
+      """
+      '''
+
+      assert_same heredoc, @short_length
+    end
+
+    test "with anonymous functions" do
+      bad = "var = fn arg1 -> body1; arg2 -> body2 end"
+
+      good = """
+      var = fn
+        arg1 ->
+          body1
+
+        arg2 ->
+          body2
+      end
+      """
+
+      assert_format bad, good, @short_length
+
+      good = """
+      var = fn
+        arg1 -> body1
+        arg2 -> body2
+      end
+      """
+
+      assert_format bad, good, @medium_length
+    end
+
+    test "with do-end blocks" do
+      assert_same """
+      var =
+        case true do
+          foo -> bar
+          baz -> bat
+        end
+      """
+    end
+  end
+
+  describe "module attributes" do
+    test "when reading" do
+      assert_format "@ my_attribute", "@my_attribute"
+    end
+
+    test "when setting" do
+      assert_format "@ my_attribute(:some_value)", "@my_attribute :some_value"
+    end
+
+    test "doesn't split when reading on line limit" do
+      assert_same "@my_long_attribute", @short_length
+    end
+
+    test "doesn't split when setting on line limit" do
+      assert_same "@my_long_attribute :some_value", @short_length
+    end
+
+    test "with do-end block" do
+      assert_same """
+      @attr (for x <- y do
+               z
+             end)
+      """
+    end
+
+    test "is parenthesized when setting inside a call" do
+      assert_same "my_fun(@foo(bar), baz)"
+    end
+
+    test "fall back to @ as an operator when needed" do
+      assert_same "@(1 + 1)"
+      assert_same "@:foo"
+      assert_same "+@foo"
+      assert_same "@@foo"
+      assert_same "@(+foo)"
+      assert_same "!(@(1 + 1))"
+      assert_same "(@Foo).Baz"
+      assert_same "@bar(1, 2)"
+
+      assert_format "@+1", "@(+1)"
+      assert_format "@Foo.Baz", "(@Foo).Baz"
+      assert_format "@(Foo.Bar).Baz", "(@(Foo.Bar)).Baz"
+    end
+
+    test "with next break fits" do
+      attribute = ~S'''
+      @doc """
+      foo
+      """
+      '''
+
+      assert_same attribute
+
+      attribute = ~S'''
+      @doc foo: """
+           bar
+           """
+      '''
+
+      assert_same attribute
+    end
+
+    test "without next break fits" do
+      bad = "@really_long_expr foo + bar"
+
+      good = """
+      @really_long_expr foo +
+                          bar
+      """
+
+      assert_format bad, good, @short_length
+    end
+
+    test "with do-end blocks" do
+      attribute = """
+      @doc do
+        :ok
+      end
+      """
+
+      assert_same attribute, @short_length
+
+      attribute = """
+      use (@doc do
+             :end
+           end)
+      """
+
+      assert_same attribute, @short_length
+    end
+
+    test "do not rewrite lists to keyword lists" do
+      assert_same """
+      @foo [
+        bar: baz
+      ]
+      """
+    end
+  end
+
+  describe "capture" do
+    test "with integers" do
+      assert_same "&1"
+      assert_format "&(&1)", "& &1"
+      assert_format "&(&1.foo)", "& &1.foo"
+    end
+
+    test "with operators inside" do
+      assert_format "& +1", "&(+1)"
+      assert_format "& 1[:foo]", "& 1[:foo]"
+      assert_format "& not &1", "&(not &1)"
+      assert_format "& a ++ b", "&(a ++ b)"
+      assert_format "& &1 && &2", "&(&1 && &2)"
+      assert_same "&(&1 | &2)"
+    end
+
+    test "with operators outside" do
+      assert_same "(& &1) == (& &2)"
+      assert_same "(& &1) and (& &2)"
+      assert_same "(&foo/1) and (&bar/1)"
+      assert_same "[(&IO.puts/1) | &IO.puts/2]"
+    end
+
+    test "with call expressions" do
+      assert_format "& local(&1, &2)", "&local(&1, &2)"
+      assert_format "&-local(&1, &2)", "&(-local(&1, &2))"
+    end
+
+    test "with blocks" do
+      bad = "&(1; 2)"
+
+      good = """
+      &(
+        1
+        2
+      )
+      """
+
+      assert_format bad, good
+    end
+
+    test "with no parens" do
+      capture = """
+      &assert foo,
+              bar
+      """
+
+      assert_same capture, @short_length
+    end
+
+    test "precedence when combined with calls" do
+      assert_same "(&Foo).Bar"
+      assert_format "&(Foo).Bar", "&Foo.Bar"
+      assert_format "&(Foo.Bar).Baz", "&Foo.Bar.Baz"
+    end
+
+    test "local/arity" do
+      assert_format "&(foo/1)", "&foo/1"
+      assert_format "&(foo/bar)", "&(foo / bar)"
+    end
+
+    test "operator/arity" do
+      assert_same "&+/2"
+      assert_same "&and/2"
+      assert_same "& &&/2"
+      assert_same "& &/1"
+      assert_same "&//2"
+    end
+
+    test "Module.remote/arity" do
+      assert_format "&(Mod.foo/1)", "&Mod.foo/1"
+      assert_format "&(Mod.++/1)", "&Mod.++/1"
+      assert_format ~s[&(Mod."foo bar"/1)], ~s[&Mod."foo bar"/1]
+      assert_format ~S[&(Mod."foo\nbar"/1)], ~S[&Mod."foo\nbar"/1]
+
+      # Invalid
+      assert_format "& Mod.foo/bar", "&(Mod.foo() / bar)"
+
+      # This is "invalid" as a special form but we don't
+      # have enough knowledge to know that, so let's just
+      # make sure we format it properly with proper wrapping.
+      assert_same "&(1 + 2).foo/1"
+
+      assert_same "&my_function.foo.bar/3", @short_length
+    end
+  end
+
+  describe "when" do
+    test "with keywords" do
+      assert_same "foo when bar: :baz"
+    end
+
+    test "with keywords on line breaks" do
+      bad = "foo when one: :two, three: :four"
+
+      good = """
+      foo
+      when one: :two,
+           three: :four
+      """
+
+      assert_format bad, good, @medium_length
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/code_fragment_test.exs b/lib/elixir/test/elixir/code_fragment_test.exs
new file mode 100644
index 00000000000..497ca3ae0bf
--- /dev/null
+++ b/lib/elixir/test/elixir/code_fragment_test.exs
@@ -0,0 +1,1507 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule CodeFragmentTest do
+  use ExUnit.Case, async: true
+
+  doctest Code.Fragment
+  alias Code.Fragment, as: CF
+
+  describe "cursor_context/2" do
+    test "expressions" do
+      assert CF.cursor_context([]) == :expr
+      assert CF.cursor_context(",") == :expr
+      assert CF.cursor_context("[") == :expr
+      assert CF.cursor_context("<<") == :expr
+      assert CF.cursor_context("=>") == :expr
+      assert CF.cursor_context("->") == :expr
+      assert CF.cursor_context("foo(<<") == :expr
+      assert CF.cursor_context("hello: ") == :expr
+      assert CF.cursor_context("\n") == :expr
+      assert CF.cursor_context(~c"\n") == :expr
+      assert CF.cursor_context("\n\n") == :expr
+      assert CF.cursor_context(~c"\n\n") == :expr
+      assert CF.cursor_context("\r\n") == :expr
+      assert CF.cursor_context(~c"\r\n") == :expr
+      assert CF.cursor_context("\r\n\r\n") == :expr
+      assert CF.cursor_context(~c"\r\n\r\n") == :expr
+    end
+
+    test "local_or_var" do
+      assert CF.cursor_context("hello_wo") == {:local_or_var, ~c"hello_wo"}
+      assert CF.cursor_context("hello_world?") == {:local_or_var, ~c"hello_world?"}
+      assert CF.cursor_context("hello_world!") == {:local_or_var, ~c"hello_world!"}
+      assert CF.cursor_context("hello/wor") == {:local_or_var, ~c"wor"}
+      assert CF.cursor_context("hello..wor") == {:local_or_var, ~c"wor"}
+      assert CF.cursor_context("hello::wor") == {:local_or_var, ~c"wor"}
+      assert CF.cursor_context("[hello_wo") == {:local_or_var, ~c"hello_wo"}
+      assert CF.cursor_context("'hello_wo") == {:local_or_var, ~c"hello_wo"}
+      assert CF.cursor_context("hellò_wó") == {:local_or_var, ~c"hellò_wó"}
+      assert CF.cursor_context("hello? world") == {:local_or_var, ~c"world"}
+      assert CF.cursor_context("hello! world") == {:local_or_var, ~c"world"}
+      assert CF.cursor_context("hello: world") == {:local_or_var, ~c"world"}
+      assert CF.cursor_context("__MODULE__") == {:local_or_var, ~c"__MODULE__"}
+    end
+
+    test "dot" do
+      assert CF.cursor_context("hello.") == {:dot, {:var, ~c"hello"}, ~c""}
+      assert CF.cursor_context(":hello.") == {:dot, {:unquoted_atom, ~c"hello"}, ~c""}
+      assert CF.cursor_context("nested.map.") == {:dot, {:dot, {:var, ~c"nested"}, ~c"map"}, ~c""}
+
+      assert CF.cursor_context("Hello.") == {:dot, {:alias, ~c"Hello"}, ~c""}
+      assert CF.cursor_context("Hello.World.") == {:dot, {:alias, ~c"Hello.World"}, ~c""}
+      assert CF.cursor_context("Hello.wor") == {:dot, {:alias, ~c"Hello"}, ~c"wor"}
+      assert CF.cursor_context("hello.wor") == {:dot, {:var, ~c"hello"}, ~c"wor"}
+      assert CF.cursor_context("Hello.++") == {:dot, {:alias, ~c"Hello"}, ~c"++"}
+      assert CF.cursor_context(":hello.wor") == {:dot, {:unquoted_atom, ~c"hello"}, ~c"wor"}
+      assert CF.cursor_context(":hell@o.wor") == {:dot, {:unquoted_atom, ~c"hell@o"}, ~c"wor"}
+      assert CF.cursor_context(":he@ll@o.wor") == {:dot, {:unquoted_atom, ~c"he@ll@o"}, ~c"wor"}
+      assert CF.cursor_context(":hell@@o.wor") == {:dot, {:unquoted_atom, ~c"hell@@o"}, ~c"wor"}
+      assert CF.cursor_context("@hello.wor") == {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context("@hello. wor") == {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+      assert CF.cursor_context("@hello .wor") == {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+      assert CF.cursor_context("@hello . wor") == {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context("@hello.\nwor") == {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+      assert CF.cursor_context("@hello. \nwor") == {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+      assert CF.cursor_context("@hello.\n wor") == {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context("@hello.\r\nwor") ==
+               {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context("@hello\n.wor") == {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+      assert CF.cursor_context("@hello \n.wor") == {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+      assert CF.cursor_context("@hello\n .wor") == {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context("@hello. # some comment\nwor") ==
+               {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context("@hello. # some comment\n\nwor") ==
+               {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context("@hello. # some comment\nsub\n.wor") ==
+               {:dot, {:dot, {:module_attribute, ~c"hello"}, ~c"sub"}, ~c"wor"}
+
+      assert CF.cursor_context(~c"@hello.\nwor") ==
+               {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context(~c"@hello.\r\nwor") ==
+               {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context(~c"@hello\n.wor") ==
+               {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context(~c"@hello. # some comment\nwor") ==
+               {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context(~c"@hello. # some comment\n\nwor") ==
+               {:dot, {:module_attribute, ~c"hello"}, ~c"wor"}
+
+      assert CF.cursor_context(~c"@hello. # some comment\nsub\n.wor") ==
+               {:dot, {:dot, {:module_attribute, ~c"hello"}, ~c"sub"}, ~c"wor"}
+
+      assert CF.cursor_context("nested.map.wor") ==
+               {:dot, {:dot, {:var, ~c"nested"}, ~c"map"}, ~c"wor"}
+
+      assert CF.cursor_context("__MODULE__.") == {:dot, {:var, ~c"__MODULE__"}, ~c""}
+
+      assert CF.cursor_context("__MODULE__.Sub.") ==
+               {:dot, {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Sub"}, ~c""}
+
+      assert CF.cursor_context("@hello.Sub.wor") ==
+               {:dot, {:alias, {:module_attribute, ~c"hello"}, ~c"Sub"}, ~c"wor"}
+    end
+
+    test "local_arity" do
+      assert CF.cursor_context("hello/") == {:local_arity, ~c"hello"}
+    end
+
+    test "local_call" do
+      assert CF.cursor_context("hello\s") == {:local_call, ~c"hello"}
+      assert CF.cursor_context("hello\t") == {:local_call, ~c"hello"}
+      assert CF.cursor_context("hello(") == {:local_call, ~c"hello"}
+      assert CF.cursor_context("hello(\s") == {:local_call, ~c"hello"}
+      assert CF.cursor_context("hello(\t") == {:local_call, ~c"hello"}
+      assert CF.cursor_context("hello(\n") == {:local_call, ~c"hello"}
+      assert CF.cursor_context("hello(\r\n") == {:local_call, ~c"hello"}
+    end
+
+    test "dot_arity" do
+      assert CF.cursor_context("Foo.hello/") == {:dot_arity, {:alias, ~c"Foo"}, ~c"hello"}
+      assert CF.cursor_context("Foo.+/") == {:dot_arity, {:alias, ~c"Foo"}, ~c"+"}
+      assert CF.cursor_context("Foo . hello /") == {:dot_arity, {:alias, ~c"Foo"}, ~c"hello"}
+      assert CF.cursor_context("Foo . + /") == {:dot_arity, {:alias, ~c"Foo"}, ~c"+"}
+      assert CF.cursor_context("foo.hello/") == {:dot_arity, {:var, ~c"foo"}, ~c"hello"}
+
+      assert CF.cursor_context(":foo.hello/") ==
+               {:dot_arity, {:unquoted_atom, ~c"foo"}, ~c"hello"}
+
+      assert CF.cursor_context("@f.hello/") == {:dot_arity, {:module_attribute, ~c"f"}, ~c"hello"}
+    end
+
+    test "dot_call" do
+      assert CF.cursor_context("Foo.hello\s") == {:dot_call, {:alias, ~c"Foo"}, ~c"hello"}
+      assert CF.cursor_context("Foo.hello\t") == {:dot_call, {:alias, ~c"Foo"}, ~c"hello"}
+      assert CF.cursor_context("Foo.hello(") == {:dot_call, {:alias, ~c"Foo"}, ~c"hello"}
+      assert CF.cursor_context("Foo.hello(\s") == {:dot_call, {:alias, ~c"Foo"}, ~c"hello"}
+      assert CF.cursor_context("Foo.hello(\t") == {:dot_call, {:alias, ~c"Foo"}, ~c"hello"}
+      assert CF.cursor_context("Foo . hello (") == {:dot_call, {:alias, ~c"Foo"}, ~c"hello"}
+      assert CF.cursor_context("Foo . hello (\s") == {:dot_call, {:alias, ~c"Foo"}, ~c"hello"}
+      assert CF.cursor_context("Foo . hello (\t") == {:dot_call, {:alias, ~c"Foo"}, ~c"hello"}
+
+      assert CF.cursor_context(":foo.hello\s") ==
+               {:dot_call, {:unquoted_atom, ~c"foo"}, ~c"hello"}
+
+      assert CF.cursor_context(":foo.hello\t") ==
+               {:dot_call, {:unquoted_atom, ~c"foo"}, ~c"hello"}
+
+      assert CF.cursor_context(":foo.hello(") == {:dot_call, {:unquoted_atom, ~c"foo"}, ~c"hello"}
+
+      assert CF.cursor_context(":foo.hello(\s") ==
+               {:dot_call, {:unquoted_atom, ~c"foo"}, ~c"hello"}
+
+      assert CF.cursor_context(":foo.hello(\t") ==
+               {:dot_call, {:unquoted_atom, ~c"foo"}, ~c"hello"}
+
+      assert CF.cursor_context(":foo.hello\s") ==
+               {:dot_call, {:unquoted_atom, ~c"foo"}, ~c"hello"}
+
+      assert CF.cursor_context("foo.hello\s") == {:dot_call, {:var, ~c"foo"}, ~c"hello"}
+      assert CF.cursor_context("foo.hello\t") == {:dot_call, {:var, ~c"foo"}, ~c"hello"}
+      assert CF.cursor_context("foo.hello(") == {:dot_call, {:var, ~c"foo"}, ~c"hello"}
+      assert CF.cursor_context("foo.hello(\s") == {:dot_call, {:var, ~c"foo"}, ~c"hello"}
+      assert CF.cursor_context("foo.hello(\t") == {:dot_call, {:var, ~c"foo"}, ~c"hello"}
+      assert CF.cursor_context("foo.hello(\n") == {:dot_call, {:var, ~c"foo"}, ~c"hello"}
+      assert CF.cursor_context("foo.hello(\r\n") == {:dot_call, {:var, ~c"foo"}, ~c"hello"}
+
+      assert CF.cursor_context("@f.hello\s") == {:dot_call, {:module_attribute, ~c"f"}, ~c"hello"}
+      assert CF.cursor_context("@f.hello\t") == {:dot_call, {:module_attribute, ~c"f"}, ~c"hello"}
+      assert CF.cursor_context("@f.hello(") == {:dot_call, {:module_attribute, ~c"f"}, ~c"hello"}
+
+      assert CF.cursor_context("@f.hello(\s") ==
+               {:dot_call, {:module_attribute, ~c"f"}, ~c"hello"}
+
+      assert CF.cursor_context("@f.hello(\t") ==
+               {:dot_call, {:module_attribute, ~c"f"}, ~c"hello"}
+
+      assert CF.cursor_context("Foo.+\s") == {:dot_call, {:alias, ~c"Foo"}, ~c"+"}
+      assert CF.cursor_context("Foo.+\t") == {:dot_call, {:alias, ~c"Foo"}, ~c"+"}
+      assert CF.cursor_context("Foo.+(") == {:dot_call, {:alias, ~c"Foo"}, ~c"+"}
+      assert CF.cursor_context("Foo.+(\s") == {:dot_call, {:alias, ~c"Foo"}, ~c"+"}
+      assert CF.cursor_context("Foo.+(\t") == {:dot_call, {:alias, ~c"Foo"}, ~c"+"}
+      assert CF.cursor_context("Foo . + (") == {:dot_call, {:alias, ~c"Foo"}, ~c"+"}
+      assert CF.cursor_context("Foo . + (\s") == {:dot_call, {:alias, ~c"Foo"}, ~c"+"}
+      assert CF.cursor_context("Foo . + (\t") == {:dot_call, {:alias, ~c"Foo"}, ~c"+"}
+
+      assert CF.cursor_context("__MODULE__.Foo.hello(") ==
+               {:dot_call, {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Foo"}, ~c"hello"}
+
+      assert CF.cursor_context("@foo.Foo.hello(") ==
+               {:dot_call, {:alias, {:module_attribute, ~c"foo"}, ~c"Foo"}, ~c"hello"}
+    end
+
+    test "anonymous_call" do
+      assert CF.cursor_context("hello.(") == {:anonymous_call, {:var, ~c"hello"}}
+      assert CF.cursor_context("hello.(\s") == {:anonymous_call, {:var, ~c"hello"}}
+      assert CF.cursor_context("hello.(\t") == {:anonymous_call, {:var, ~c"hello"}}
+      assert CF.cursor_context("hello.(\n") == {:anonymous_call, {:var, ~c"hello"}}
+      assert CF.cursor_context("hello.(\r\n") == {:anonymous_call, {:var, ~c"hello"}}
+
+      assert CF.cursor_context("hello . (") == {:anonymous_call, {:var, ~c"hello"}}
+
+      assert CF.cursor_context("@hello.(") == {:anonymous_call, {:module_attribute, ~c"hello"}}
+      assert CF.cursor_context("@hello . (") == {:anonymous_call, {:module_attribute, ~c"hello"}}
+    end
+
+    test "nested expressions" do
+      assert CF.cursor_context("Hello.world()") == :none
+      assert CF.cursor_context("hello().") == {:dot, :expr, ~c""}
+      assert CF.cursor_context("Foo.hello ('(').") == {:dot, :expr, ~c""}
+      assert CF.cursor_context("Foo.hello('(', ?), ?().bar") == {:dot, :expr, ~c"bar"}
+      assert CF.cursor_context("Hello.bar(World.call(42), ?), ?().foo") == {:dot, :expr, ~c"foo"}
+      assert CF.cursor_context("Foo.hello( ).world") == {:dot, :expr, ~c"world"}
+      assert CF.cursor_context("hello.dyn_impl().call(42).bar") == {:dot, :expr, ~c"bar"}
+
+      assert CF.cursor_context("Foo.dyn_impl().call(") == {:dot_call, :expr, ~c"call"}
+      assert CF.cursor_context("hello().call(") == {:dot_call, :expr, ~c"call"}
+    end
+
+    test "alias" do
+      assert CF.cursor_context("HelloWor") == {:alias, ~c"HelloWor"}
+      assert CF.cursor_context("Hello.Wor") == {:alias, ~c"Hello.Wor"}
+      assert CF.cursor_context("Hello.\nWor") == {:alias, ~c"Hello.Wor"}
+      assert CF.cursor_context("Hello.\r\nWor") == {:alias, ~c"Hello.Wor"}
+      assert CF.cursor_context("Hello . Wor") == {:alias, ~c"Hello.Wor"}
+      assert CF.cursor_context("Hello::Wor") == {:alias, ~c"Wor"}
+      assert CF.cursor_context("Hello..Wor") == {:alias, ~c"Wor"}
+
+      assert CF.cursor_context("hello.World") ==
+               {:alias, {:local_or_var, ~c"hello"}, ~c"World"}
+
+      assert CF.cursor_context("__MODULE__.Wor") ==
+               {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Wor"}
+
+      assert CF.cursor_context("@foo.Wor") == {:alias, {:module_attribute, ~c"foo"}, ~c"Wor"}
+    end
+
+    test "structs" do
+      assert CF.cursor_context("%") == {:struct, ~c""}
+      assert CF.cursor_context(":%") == {:unquoted_atom, ~c"%"}
+      assert CF.cursor_context("::%") == {:struct, ~c""}
+
+      assert CF.cursor_context("%HelloWor") == {:struct, ~c"HelloWor"}
+
+      assert CF.cursor_context("%Hello.") == {:struct, {:dot, {:alias, ~c"Hello"}, ~c""}}
+      assert CF.cursor_context("%Hello.nam") == {:struct, {:dot, {:alias, ~c"Hello"}, ~c"nam"}}
+      assert CF.cursor_context("%Hello.Wor") == {:struct, ~c"Hello.Wor"}
+      assert CF.cursor_context("% Hello . Wor") == {:struct, ~c"Hello.Wor"}
+
+      assert CF.cursor_context("%__MODULE_") == {:struct, {:local_or_var, ~c"__MODULE_"}}
+      assert CF.cursor_context("%__MODULE__") == {:struct, {:local_or_var, ~c"__MODULE__"}}
+
+      assert CF.cursor_context("%__MODULE__.") ==
+               {:struct, {:dot, {:local_or_var, ~c"__MODULE__"}, ~c""}}
+
+      assert CF.cursor_context("%__MODULE__.Sub.") ==
+               {:struct, {:dot, {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Sub"}, ~c""}}
+
+      assert CF.cursor_context("%__MODULE__.Wor") ==
+               {:struct, {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Wor"}}
+
+      assert CF.cursor_context("%@foo") ==
+               {:struct, {:module_attribute, ~c"foo"}}
+
+      assert CF.cursor_context("%@foo.") ==
+               {:struct, {:dot, {:module_attribute, ~c"foo"}, ~c""}}
+
+      assert CF.cursor_context("%@foo.Wor") ==
+               {:struct, {:alias, {:module_attribute, ~c"foo"}, ~c"Wor"}}
+    end
+
+    test "unquoted atom" do
+      assert CF.cursor_context(":") == {:unquoted_atom, ~c""}
+      assert CF.cursor_context(":HelloWor") == {:unquoted_atom, ~c"HelloWor"}
+      assert CF.cursor_context(":HelloWór") == {:unquoted_atom, ~c"HelloWór"}
+      assert CF.cursor_context(":hello_wor") == {:unquoted_atom, ~c"hello_wor"}
+      assert CF.cursor_context(":Óla_mundo") == {:unquoted_atom, ~c"Óla_mundo"}
+      assert CF.cursor_context(":Ol@_mundo") == {:unquoted_atom, ~c"Ol@_mundo"}
+      assert CF.cursor_context(":Ol@") == {:unquoted_atom, ~c"Ol@"}
+      assert CF.cursor_context("foo:hello_wor") == {:unquoted_atom, ~c"hello_wor"}
+
+      # Operators from atoms
+      assert CF.cursor_context(":+") == {:unquoted_atom, ~c"+"}
+      assert CF.cursor_context(":or") == {:unquoted_atom, ~c"or"}
+      assert CF.cursor_context(":<") == {:unquoted_atom, ~c"<"}
+      assert CF.cursor_context(":.") == {:unquoted_atom, ~c"."}
+      assert CF.cursor_context(":..") == {:unquoted_atom, ~c".."}
+      assert CF.cursor_context(":->") == {:unquoted_atom, ~c"->"}
+      assert CF.cursor_context(":%") == {:unquoted_atom, ~c"%"}
+    end
+
+    test "operators" do
+      assert CF.cursor_context("/") == {:operator, ~c"/"}
+      assert CF.cursor_context("+") == {:operator, ~c"+"}
+      assert CF.cursor_context("++") == {:operator, ~c"++"}
+      assert CF.cursor_context("!") == {:operator, ~c"!"}
+      assert CF.cursor_context("<") == {:operator, ~c"<"}
+      assert CF.cursor_context("<<<") == {:operator, ~c"<<<"}
+      assert CF.cursor_context("..") == {:operator, ~c".."}
+      assert CF.cursor_context("<~") == {:operator, ~c"<~"}
+      assert CF.cursor_context("=~") == {:operator, ~c"=~"}
+      assert CF.cursor_context("<~>") == {:operator, ~c"<~>"}
+      assert CF.cursor_context("::") == {:operator, ~c"::"}
+
+      assert CF.cursor_context("+ ") == {:operator_call, ~c"+"}
+      assert CF.cursor_context("++ ") == {:operator_call, ~c"++"}
+      assert CF.cursor_context("! ") == {:operator_call, ~c"!"}
+      assert CF.cursor_context("< ") == {:operator_call, ~c"<"}
+      assert CF.cursor_context("<<< ") == {:operator_call, ~c"<<<"}
+      assert CF.cursor_context(".. ") == {:operator_call, ~c".."}
+      assert CF.cursor_context("<~ ") == {:operator_call, ~c"<~"}
+      assert CF.cursor_context("=~ ") == {:operator_call, ~c"=~"}
+      assert CF.cursor_context("<~> ") == {:operator_call, ~c"<~>"}
+      assert CF.cursor_context(":: ") == {:operator_call, ~c"::"}
+
+      assert CF.cursor_context("...(") == {:operator_call, ~c"..."}
+      assert CF.cursor_context("...(\s") == {:operator_call, ~c"..."}
+      assert CF.cursor_context("+(") == {:operator_call, ~c"+"}
+      assert CF.cursor_context("++(\s") == {:operator_call, ~c"++"}
+
+      assert CF.cursor_context("+/") == {:operator_arity, ~c"+"}
+      assert CF.cursor_context("++/") == {:operator_arity, ~c"++"}
+      assert CF.cursor_context("!/") == {:operator_arity, ~c"!"}
+      assert CF.cursor_context("</") == {:operator_arity, ~c"<"}
+      assert CF.cursor_context("<<</") == {:operator_arity, ~c"<<<"}
+      assert CF.cursor_context("../") == {:operator_arity, ~c".."}
+      assert CF.cursor_context("<~/") == {:operator_arity, ~c"<~"}
+      assert CF.cursor_context("=~/") == {:operator_arity, ~c"=~"}
+      assert CF.cursor_context("<~>/") == {:operator_arity, ~c"<~>"}
+      assert CF.cursor_context("::/") == {:operator_arity, ~c"::"}
+
+      # Unknown operators altogether
+      assert CF.cursor_context("***") == :none
+
+      # Textual operators are shown as local_or_var UNLESS there is space
+      assert CF.cursor_context("when") == {:local_or_var, ~c"when"}
+      assert CF.cursor_context("when ") == {:operator_call, ~c"when"}
+      assert CF.cursor_context("when.") == :none
+
+      assert CF.cursor_context("not") == {:local_or_var, ~c"not"}
+      assert CF.cursor_context("not ") == {:operator_call, ~c"not"}
+      assert CF.cursor_context("not.") == :none
+    end
+
+    test "sigil" do
+      assert CF.cursor_context("~") == {:sigil, ~c""}
+      assert CF.cursor_context("~ ") == :none
+
+      assert CF.cursor_context("~r") == {:sigil, ~c"r"}
+      assert CF.cursor_context("~r/") == :none
+      assert CF.cursor_context("~r<") == :none
+
+      assert CF.cursor_context("~r''") == :none
+      assert CF.cursor_context("~r' '") == :none
+      assert CF.cursor_context("~r'foo'") == :none
+
+      # The slash is used in sigils, arities, and operators, so there is ambiguity
+      assert CF.cursor_context("~r//") == {:operator, ~c"/"}
+      assert CF.cursor_context("~r/ /") == {:operator, ~c"/"}
+      assert CF.cursor_context("~r/foo/") == {:local_arity, ~c"foo"}
+
+      assert CF.cursor_context("~R") == {:sigil, ~c"R"}
+      assert CF.cursor_context("~R/") == :none
+      assert CF.cursor_context("~R<") == :none
+
+      assert CF.cursor_context("Foo.~") == :none
+      assert CF.cursor_context("Foo.~ ") == :none
+    end
+
+    test "module attribute" do
+      assert CF.cursor_context("@") == {:module_attribute, ~c""}
+      assert CF.cursor_context("@hello_wo") == {:module_attribute, ~c"hello_wo"}
+    end
+
+    test "keyword or binary operator" do
+      # Literals
+      assert CF.cursor_context("Foo.Bar ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("Foo ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context(":foo ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("123 ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("nil ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("true ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("false ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("\"foo\" ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("'foo' ") == {:block_keyword_or_binary_operator, ~c""}
+
+      # Containers
+      assert CF.cursor_context("(foo) ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("[foo] ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("{foo} ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("<<foo>> ") == {:block_keyword_or_binary_operator, ~c""}
+
+      # False positives
+      assert CF.cursor_context("foo ~>> ") == {:operator_call, ~c"~>>"}
+      assert CF.cursor_context("foo >>> ") == {:operator_call, ~c">>>"}
+    end
+
+    test "keyword from keyword or binary operator" do
+      # Literals
+      assert CF.cursor_context("Foo.Bar do") == {:block_keyword_or_binary_operator, ~c"do"}
+      assert CF.cursor_context("Foo.Bar d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("Foo d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context(":foo d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("123 d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("nil d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("true d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("false d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("\"foo\" d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("'foo' d") == {:block_keyword_or_binary_operator, ~c"d"}
+
+      # Containers
+      assert CF.cursor_context("(foo) d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("[foo] d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("{foo} d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("<<foo>> d") == {:block_keyword_or_binary_operator, ~c"d"}
+
+      # False positives
+      assert CF.cursor_context("foo ~>> d") == {:local_or_var, ~c"d"}
+      assert CF.cursor_context("foo >>> d") == {:local_or_var, ~c"d"}
+    end
+
+    test "operator from keyword or binary operator" do
+      # Literals
+      assert CF.cursor_context("Foo.Bar +") == {:operator, ~c"+"}
+      assert CF.cursor_context("Foo +") == {:operator, ~c"+"}
+      assert CF.cursor_context(":foo +") == {:operator, ~c"+"}
+      assert CF.cursor_context("123 +") == {:operator, ~c"+"}
+      assert CF.cursor_context("nil +") == {:operator, ~c"+"}
+      assert CF.cursor_context("true +") == {:operator, ~c"+"}
+      assert CF.cursor_context("false +") == {:operator, ~c"+"}
+      assert CF.cursor_context("\"foo\" +") == {:operator, ~c"+"}
+      assert CF.cursor_context("'foo' +") == {:operator, ~c"+"}
+
+      # Containers
+      assert CF.cursor_context("(foo) +") == {:operator, ~c"+"}
+      assert CF.cursor_context("[foo] +") == {:operator, ~c"+"}
+      assert CF.cursor_context("{foo} +") == {:operator, ~c"+"}
+      assert CF.cursor_context("<<foo>> +") == {:operator, ~c"+"}
+
+      # False positives
+      assert CF.cursor_context("foo ~>> +") == {:operator, ~c"+"}
+      assert CF.cursor_context("foo >>> +") == {:operator, ~c"+"}
+    end
+
+    test "none" do
+      # Punctuation
+      assert CF.cursor_context(")") == :none
+      assert CF.cursor_context("}") == :none
+      assert CF.cursor_context(">>") == :none
+      assert CF.cursor_context("'") == :none
+      assert CF.cursor_context("\"") == :none
+
+      # Numbers
+      assert CF.cursor_context("123") == :none
+      assert CF.cursor_context("123?") == :none
+      assert CF.cursor_context("123!") == :none
+      assert CF.cursor_context("123var?") == :none
+      assert CF.cursor_context("0x") == :none
+
+      # Codepoints
+      assert CF.cursor_context("?") == :none
+      assert CF.cursor_context("?a") == :none
+      assert CF.cursor_context("?foo") == :none
+
+      # Dots
+      assert CF.cursor_context(".") == :none
+      assert CF.cursor_context("Mundo.Óla") == :none
+      assert CF.cursor_context(":hello.World") == :none
+
+      # Aliases
+      assert CF.cursor_context("Hello::Wór") == :none
+      assert CF.cursor_context("ÓlaMundo") == :none
+      assert CF.cursor_context("HelloWór") == :none
+      assert CF.cursor_context("@Hello") == :none
+      assert CF.cursor_context("Hello(") == :none
+
+      # Identifier
+      assert CF.cursor_context("foo@bar") == :none
+      assert CF.cursor_context("@foo@bar") == :none
+    end
+
+    test "newlines" do
+      assert CF.cursor_context("this+does-not*matter\nHello.") ==
+               {:dot, {:alias, ~c"Hello"}, ~c""}
+
+      assert CF.cursor_context(~c"this+does-not*matter\nHello.") ==
+               {:dot, {:alias, ~c"Hello"}, ~c""}
+
+      assert CF.cursor_context("this+does-not*matter\r\nHello.") ==
+               {:dot, {:alias, ~c"Hello"}, ~c""}
+
+      assert CF.cursor_context(~c"this+does-not*matter\r\nHello.") ==
+               {:dot, {:alias, ~c"Hello"}, ~c""}
+    end
+  end
+
+  describe "surround_context/2" do
+    test "newlines" do
+      for i <- 1..8 do
+        assert CF.surround_context("\n\nhello_wo\n", {3, i}) == %{
+                 context: {:local_or_var, ~c"hello_wo"},
+                 begin: {3, 1},
+                 end: {3, 9}
+               }
+
+        assert CF.surround_context("\r\n\r\nhello_wo\r\n", {3, i}) == %{
+                 context: {:local_or_var, ~c"hello_wo"},
+                 begin: {3, 1},
+                 end: {3, 9}
+               }
+
+        assert CF.surround_context(~c"\r\n\r\nhello_wo\r\n", {3, i}) == %{
+                 context: {:local_or_var, ~c"hello_wo"},
+                 begin: {3, 1},
+                 end: {3, 9}
+               }
+      end
+    end
+
+    test "column out of range" do
+      assert CF.surround_context("hello", {1, 20}) == :none
+    end
+
+    test "local_or_var" do
+      for i <- 1..8 do
+        assert CF.surround_context("hello_wo", {1, i}) == %{
+                 context: {:local_or_var, ~c"hello_wo"},
+                 begin: {1, 1},
+                 end: {1, 9}
+               }
+      end
+
+      assert CF.surround_context("hello_wo", {1, 9}) == :none
+
+      for i <- 2..9 do
+        assert CF.surround_context(" hello_wo", {1, i}) == %{
+                 context: {:local_or_var, ~c"hello_wo"},
+                 begin: {1, 2},
+                 end: {1, 10}
+               }
+      end
+
+      assert CF.surround_context(" hello_wo", {1, 10}) == :none
+
+      for i <- 1..6 do
+        assert CF.surround_context("hello!", {1, i}) == %{
+                 context: {:local_or_var, ~c"hello!"},
+                 begin: {1, 1},
+                 end: {1, 7}
+               }
+      end
+
+      assert CF.surround_context("hello!", {1, 7}) == :none
+
+      for i <- 1..5 do
+        assert CF.surround_context("안녕_세상", {1, i}) == %{
+                 context: {:local_or_var, ~c"안녕_세상"},
+                 begin: {1, 1},
+                 end: {1, 6}
+               }
+      end
+
+      assert CF.surround_context("안녕_세상", {1, 6}) == :none
+
+      # Keywords are not local or var
+      for keyword <- ~w(do end after catch else rescue fn true false nil)c,
+          length = length(keyword),
+          i <- 1..length do
+        assert CF.surround_context(keyword, {1, i}) == %{
+                 context: {:keyword, keyword},
+                 begin: {1, 1},
+                 end: {1, length + 1}
+               }
+
+        assert CF.surround_context(~c"Foo " ++ keyword, {1, 4 + i}) == %{
+                 context: {:keyword, keyword},
+                 begin: {1, 5},
+                 end: {1, length + 5}
+               }
+      end
+    end
+
+    test "local call" do
+      for i <- 1..8 do
+        assert CF.surround_context("hello_wo(", {1, i}) == %{
+                 context: {:local_call, ~c"hello_wo"},
+                 begin: {1, 1},
+                 end: {1, 9}
+               }
+      end
+
+      assert CF.surround_context("hello_wo(", {1, 9}) == :none
+
+      for i <- 1..8 do
+        assert CF.surround_context("hello_wo (", {1, i}) == %{
+                 context: {:local_call, ~c"hello_wo"},
+                 begin: {1, 1},
+                 end: {1, 9}
+               }
+      end
+
+      assert CF.surround_context("hello_wo (", {1, 9}) == :none
+
+      for i <- 1..6 do
+        assert CF.surround_context("hello!(", {1, i}) == %{
+                 context: {:local_call, ~c"hello!"},
+                 begin: {1, 1},
+                 end: {1, 7}
+               }
+      end
+
+      assert CF.surround_context("hello!(", {1, 7}) == :none
+
+      for i <- 1..5 do
+        assert CF.surround_context("안녕_세상(", {1, i}) == %{
+                 context: {:local_call, ~c"안녕_세상"},
+                 begin: {1, 1},
+                 end: {1, 6}
+               }
+      end
+
+      assert CF.surround_context("안녕_세상(", {1, 6}) == :none
+    end
+
+    test "local arity" do
+      for i <- 1..8 do
+        assert CF.surround_context("hello_wo/", {1, i}) == %{
+                 context: {:local_arity, ~c"hello_wo"},
+                 begin: {1, 1},
+                 end: {1, 9}
+               }
+      end
+
+      assert CF.surround_context("hello_wo/", {1, 9}) == :none
+
+      for i <- 1..8 do
+        assert CF.surround_context("hello_wo /", {1, i}) == %{
+                 context: {:local_arity, ~c"hello_wo"},
+                 begin: {1, 1},
+                 end: {1, 9}
+               }
+      end
+
+      assert CF.surround_context("hello_wo /", {1, 9}) == :none
+
+      for i <- 1..6 do
+        assert CF.surround_context("hello!/", {1, i}) == %{
+                 context: {:local_arity, ~c"hello!"},
+                 begin: {1, 1},
+                 end: {1, 7}
+               }
+      end
+
+      assert CF.surround_context("hello!/", {1, 7}) == :none
+
+      for i <- 1..5 do
+        assert CF.surround_context("안녕_세상/", {1, i}) == %{
+                 context: {:local_arity, ~c"안녕_세상"},
+                 begin: {1, 1},
+                 end: {1, 6}
+               }
+      end
+
+      assert CF.surround_context("안녕_세상/", {1, 6}) == :none
+    end
+
+    test "textual operators" do
+      for op <- ~w(when not or and in), i <- 1..byte_size(op) do
+        assert CF.surround_context("#{op}", {1, i}) == %{
+                 context: {:operator, String.to_charlist(op)},
+                 begin: {1, 1},
+                 end: {1, byte_size(op) + 1}
+               }
+
+        assert CF.surround_context("Foo #{op}", {1, 4 + i}) == %{
+                 context: {:operator, String.to_charlist(op)},
+                 begin: {1, 5},
+                 end: {1, byte_size(op) + 5}
+               }
+      end
+    end
+
+    test "dot" do
+      for i <- 1..5 do
+        assert CF.surround_context("Hello.wor", {1, i}) == %{
+                 context: {:alias, ~c"Hello"},
+                 begin: {1, 1},
+                 end: {1, 6}
+               }
+      end
+
+      for i <- 6..9 do
+        assert CF.surround_context("Hello.wor", {1, i}) == %{
+                 context: {:dot, {:alias, ~c"Hello"}, ~c"wor"},
+                 begin: {1, 1},
+                 end: {1, 10}
+               }
+      end
+
+      assert CF.surround_context("Hello.", {1, 6}) == :none
+
+      for i <- 1..5 do
+        assert CF.surround_context("Hello . wor", {1, i}) == %{
+                 context: {:alias, ~c"Hello"},
+                 begin: {1, 1},
+                 end: {1, 6}
+               }
+      end
+
+      for i <- 6..11 do
+        assert CF.surround_context("Hello . wor", {1, i}) == %{
+                 context: {:dot, {:alias, ~c"Hello"}, ~c"wor"},
+                 begin: {1, 1},
+                 end: {1, 12}
+               }
+      end
+
+      assert CF.surround_context("Hello .", {1, 6}) == :none
+
+      for i <- 1..5 do
+        assert CF.surround_context("hello.wor", {1, i}) == %{
+                 context: {:local_or_var, ~c"hello"},
+                 begin: {1, 1},
+                 end: {1, 6}
+               }
+      end
+
+      for i <- 6..9 do
+        assert CF.surround_context("hello.wor", {1, i}) == %{
+                 context: {:dot, {:var, ~c"hello"}, ~c"wor"},
+                 begin: {1, 1},
+                 end: {1, 10}
+               }
+      end
+
+      assert CF.surround_context("hello # comment\n  .wor", {2, 4}) == %{
+               context: {:dot, {:var, ~c"hello"}, ~c"wor"},
+               begin: {1, 1},
+               end: {2, 7}
+             }
+
+      assert CF.surround_context("123 + hello. # comment\n\n  wor", {3, 4}) == %{
+               context: {:dot, {:var, ~c"hello"}, ~c"wor"},
+               begin: {1, 7},
+               end: {3, 6}
+             }
+
+      assert CF.surround_context("hello. # comment\n\n # wor", {3, 5}) == %{
+               context: {:local_or_var, ~c"wor"},
+               begin: {3, 4},
+               end: {3, 7}
+             }
+    end
+
+    test "alias" do
+      for i <- 1..8 do
+        assert CF.surround_context("HelloWor", {1, i}) == %{
+                 context: {:alias, ~c"HelloWor"},
+                 begin: {1, 1},
+                 end: {1, 9}
+               }
+      end
+
+      assert CF.surround_context("HelloWor", {1, 9}) == :none
+
+      for i <- 2..9 do
+        assert CF.surround_context(" HelloWor", {1, i}) == %{
+                 context: {:alias, ~c"HelloWor"},
+                 begin: {1, 2},
+                 end: {1, 10}
+               }
+      end
+
+      assert CF.surround_context(" HelloWor", {1, 10}) == :none
+
+      for i <- 1..9 do
+        assert CF.surround_context("Hello.Wor", {1, i}) == %{
+                 context: {:alias, ~c"Hello.Wor"},
+                 begin: {1, 1},
+                 end: {1, 10}
+               }
+      end
+
+      assert CF.surround_context("Hello.Wor", {1, 10}) == :none
+
+      for i <- 1..11 do
+        assert CF.surround_context("Hello . Wor", {1, i}) == %{
+                 context: {:alias, ~c"Hello.Wor"},
+                 begin: {1, 1},
+                 end: {1, 12}
+               }
+      end
+
+      assert CF.surround_context("Hello . Wor", {1, 12}) == :none
+
+      for i <- 1..15 do
+        assert CF.surround_context("Foo . Bar . Baz", {1, i}) == %{
+                 context: {:alias, ~c"Foo.Bar.Baz"},
+                 begin: {1, 1},
+                 end: {1, 16}
+               }
+      end
+
+      for i <- 1..3 do
+        assert CF.surround_context("Foo # dc\n. Bar .\n Baz", {i, 1}) == %{
+                 context: {:alias, ~c"Foo.Bar.Baz"},
+                 begin: {1, 1},
+                 end: {3, 5}
+               }
+      end
+
+      for i <- 1..11 do
+        assert CF.surround_context("Foo.Bar.Baz.foo(bar)", {1, i}) == %{
+                 context: {:alias, ~c"Foo.Bar.Baz"},
+                 begin: {1, 1},
+                 end: {1, 12}
+               }
+      end
+    end
+
+    test "underscored special forms" do
+      assert CF.surround_context("__MODULE__", {1, 1}) == %{
+               context: {:local_or_var, ~c"__MODULE__"},
+               begin: {1, 1},
+               end: {1, 11}
+             }
+
+      for i <- 1..14 do
+        assert CF.surround_context("__MODULE__.Foo", {1, i}) == %{
+                 context: {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Foo"},
+                 begin: {1, 1},
+                 end: {1, 15}
+               }
+      end
+
+      for i <- 1..18 do
+        assert CF.surround_context("__MODULE__.Foo.Sub", {1, i}) == %{
+                 context: {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Foo.Sub"},
+                 begin: {1, 1},
+                 end: {1, 19}
+               }
+      end
+
+      assert CF.surround_context("%__MODULE__{}", {1, 5}) == %{
+               context: {:struct, {:local_or_var, ~c"__MODULE__"}},
+               begin: {1, 1},
+               end: {1, 12}
+             }
+
+      assert CF.surround_context("%__MODULE__.Foo{}", {1, 13}) == %{
+               context: {:struct, {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Foo"}},
+               begin: {1, 1},
+               end: {1, 16}
+             }
+
+      assert CF.surround_context("%__MODULE__.Foo.Sub{}", {1, 17}) == %{
+               context: {:struct, {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Foo.Sub"}},
+               begin: {1, 1},
+               end: {1, 20}
+             }
+
+      assert CF.surround_context("__MODULE__.call()", {1, 13}) == %{
+               context: {:dot, {:var, ~c"__MODULE__"}, ~c"call"},
+               begin: {1, 1},
+               end: {1, 16}
+             }
+
+      assert CF.surround_context("__MODULE__.Foo.call()", {1, 17}) == %{
+               context: {:dot, {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Foo"}, ~c"call"},
+               begin: {1, 1},
+               end: {1, 20}
+             }
+
+      assert CF.surround_context("__MODULE__.Foo.Sub.call()", {1, 21}) == %{
+               context: {:dot, {:alias, {:local_or_var, ~c"__MODULE__"}, ~c"Foo.Sub"}, ~c"call"},
+               begin: {1, 1},
+               end: {1, 24}
+             }
+
+      assert CF.surround_context("__ENV__.module.call()", {1, 17}) == %{
+               context: {:dot, {:dot, {:var, ~c"__ENV__"}, ~c"module"}, ~c"call"},
+               begin: {1, 1},
+               end: {1, 20}
+             }
+    end
+
+    test "attribute submodules" do
+      for i <- 1..9 do
+        assert CF.surround_context("@some.Foo", {1, i}) == %{
+                 context: {:alias, {:module_attribute, ~c"some"}, ~c"Foo"},
+                 begin: {1, 1},
+                 end: {1, 10}
+               }
+      end
+
+      for i <- 1..13 do
+        assert CF.surround_context("@some.Foo.Sub", {1, i}) == %{
+                 context: {:alias, {:module_attribute, ~c"some"}, ~c"Foo.Sub"},
+                 begin: {1, 1},
+                 end: {1, 14}
+               }
+      end
+
+      assert CF.surround_context("%@some{}", {1, 5}) == %{
+               context: {:struct, {:module_attribute, ~c"some"}},
+               begin: {1, 1},
+               end: {1, 7}
+             }
+
+      assert CF.surround_context("%@some.Foo{}", {1, 10}) == %{
+               context: {:struct, {:alias, {:module_attribute, ~c"some"}, ~c"Foo"}},
+               begin: {1, 1},
+               end: {1, 11}
+             }
+
+      assert CF.surround_context("%@some.Foo.Sub{}", {1, 14}) == %{
+               context: {:struct, {:alias, {:module_attribute, ~c"some"}, ~c"Foo.Sub"}},
+               begin: {1, 1},
+               end: {1, 15}
+             }
+
+      assert CF.surround_context("@some.call()", {1, 8}) == %{
+               context: {:dot, {:module_attribute, ~c"some"}, ~c"call"},
+               begin: {1, 1},
+               end: {1, 11}
+             }
+
+      assert CF.surround_context("@some.Foo.call()", {1, 12}) == %{
+               context: {:dot, {:alias, {:module_attribute, ~c"some"}, ~c"Foo"}, ~c"call"},
+               begin: {1, 1},
+               end: {1, 15}
+             }
+
+      assert CF.surround_context("@some.Foo.Sub.call()", {1, 16}) == %{
+               context: {:dot, {:alias, {:module_attribute, ~c"some"}, ~c"Foo.Sub"}, ~c"call"},
+               begin: {1, 1},
+               end: {1, 19}
+             }
+    end
+
+    test "struct" do
+      assert CF.surround_context("%", {1, 1}) == :none
+      assert CF.surround_context("::%", {1, 1}) == :none
+      assert CF.surround_context("::%", {1, 2}) == :none
+      assert CF.surround_context("::%Hello", {1, 1}) == :none
+      assert CF.surround_context("::%Hello", {1, 2}) == :none
+
+      assert CF.surround_context("::%Hello", {1, 3}) == %{
+               context: {:struct, ~c"Hello"},
+               begin: {1, 3},
+               end: {1, 9}
+             }
+
+      assert CF.surround_context("::% Hello", {1, 3}) == %{
+               context: {:struct, ~c"Hello"},
+               begin: {1, 3},
+               end: {1, 10}
+             }
+
+      assert CF.surround_context("::% Hello", {1, 4}) == %{
+               context: {:struct, ~c"Hello"},
+               begin: {1, 3},
+               end: {1, 10}
+             }
+
+      # Alias
+      assert CF.surround_context("%HelloWor", {1, 1}) == %{
+               context: {:struct, ~c"HelloWor"},
+               begin: {1, 1},
+               end: {1, 10}
+             }
+
+      assert CF.surround_context("%HelloWor.some", {1, 12}) == %{
+               context: {:struct, {:dot, {:alias, ~c"HelloWor"}, ~c"some"}},
+               begin: {1, 1},
+               end: {1, 15}
+             }
+
+      for i <- 2..9 do
+        assert CF.surround_context("%HelloWor", {1, i}) == %{
+                 context: {:struct, ~c"HelloWor"},
+                 begin: {1, 1},
+                 end: {1, 10}
+               }
+      end
+
+      assert CF.surround_context("%HelloWor", {1, 10}) == :none
+
+      # With dot
+      assert CF.surround_context("%Hello.Wor", {1, 1}) == %{
+               context: {:struct, ~c"Hello.Wor"},
+               begin: {1, 1},
+               end: {1, 11}
+             }
+
+      for i <- 2..10 do
+        assert CF.surround_context("%Hello.Wor", {1, i}) == %{
+                 context: {:struct, ~c"Hello.Wor"},
+                 begin: {1, 1},
+                 end: {1, 11}
+               }
+      end
+
+      assert CF.surround_context("%Hello.Wor", {1, 11}) == :none
+
+      # With spaces
+      assert CF.surround_context("% Hello . Wor", {1, 1}) == %{
+               context: {:struct, ~c"Hello.Wor"},
+               begin: {1, 1},
+               end: {1, 14}
+             }
+
+      for i <- 2..13 do
+        assert CF.surround_context("% Hello . Wor", {1, i}) == %{
+                 context: {:struct, ~c"Hello.Wor"},
+                 begin: {1, 1},
+                 end: {1, 14}
+               }
+      end
+
+      assert CF.surround_context("% Hello . Wor", {1, 14}) == :none
+    end
+
+    test "module attributes" do
+      for i <- 1..10 do
+        assert CF.surround_context("@hello_wor", {1, i}) == %{
+                 context: {:module_attribute, ~c"hello_wor"},
+                 begin: {1, 1},
+                 end: {1, 11}
+               }
+      end
+
+      assert CF.surround_context("@Hello", {1, 1}) == :none
+    end
+
+    test "operators" do
+      for i <- 2..4 do
+        assert CF.surround_context("1<<<3", {1, i}) == %{
+                 context: {:operator, ~c"<<<"},
+                 begin: {1, 2},
+                 end: {1, 5}
+               }
+      end
+
+      for i <- 3..5 do
+        assert CF.surround_context("1 <<< 3", {1, i}) == %{
+                 context: {:operator, ~c"<<<"},
+                 begin: {1, 3},
+                 end: {1, 6}
+               }
+      end
+
+      for i <- 2..3 do
+        assert CF.surround_context("1::3", {1, i}) == %{
+                 context: {:operator, ~c"::"},
+                 begin: {1, 2},
+                 end: {1, 4}
+               }
+      end
+
+      for i <- 3..4 do
+        assert CF.surround_context("1 :: 3", {1, i}) == %{
+                 context: {:operator, ~c"::"},
+                 begin: {1, 3},
+                 end: {1, 5}
+               }
+      end
+
+      for i <- 2..3 do
+        assert CF.surround_context("x..y", {1, i}) == %{
+                 context: {:operator, ~c".."},
+                 begin: {1, 2},
+                 end: {1, 4}
+               }
+      end
+
+      for i <- 3..4 do
+        assert CF.surround_context("x .. y", {1, i}) == %{
+                 context: {:operator, ~c".."},
+                 begin: {1, 3},
+                 end: {1, 5}
+               }
+      end
+
+      assert CF.surround_context("@", {1, 1}) == %{
+               context: {:operator, ~c"@"},
+               begin: {1, 1},
+               end: {1, 2}
+             }
+
+      assert CF.surround_context("!", {1, 1}) == %{
+               context: {:operator, ~c"!"},
+               begin: {1, 1},
+               end: {1, 2}
+             }
+
+      assert CF.surround_context("!foo", {1, 1}) == %{
+               context: {:operator, ~c"!"},
+               begin: {1, 1},
+               end: {1, 2}
+             }
+
+      assert CF.surround_context("foo !bar", {1, 5}) == %{
+               context: {:operator, ~c"!"},
+               begin: {1, 5},
+               end: {1, 6}
+             }
+
+      # invalid
+      assert CF.surround_context("->", {1, 2}) == :none
+    end
+
+    test "sigil" do
+      assert CF.surround_context("~", {1, 1}) == :none
+      assert CF.surround_context("~~r", {1, 1}) == :none
+      assert CF.surround_context("~~r", {1, 2}) == :none
+
+      assert CF.surround_context("~r/foo/", {1, 1}) == %{
+               begin: {1, 1},
+               context: {:sigil, ~c"r"},
+               end: {1, 3}
+             }
+
+      assert CF.surround_context("~r/foo/", {1, 2}) == %{
+               begin: {1, 1},
+               context: {:sigil, ~c"r"},
+               end: {1, 3}
+             }
+
+      assert CF.surround_context("~r/foo/", {1, 3}) == :none
+
+      assert CF.surround_context("~R<foo>", {1, 1}) == %{
+               begin: {1, 1},
+               context: {:sigil, ~c"R"},
+               end: {1, 3}
+             }
+
+      assert CF.surround_context("~R<foo>", {1, 2}) == %{
+               begin: {1, 1},
+               context: {:sigil, ~c"R"},
+               end: {1, 3}
+             }
+
+      assert CF.surround_context("~R<foo>", {1, 3}) == :none
+    end
+
+    test "dot operator" do
+      for i <- 4..7 do
+        assert CF.surround_context("Foo.<<<", {1, i}) == %{
+                 context: {:dot, {:alias, ~c"Foo"}, ~c"<<<"},
+                 begin: {1, 1},
+                 end: {1, 8}
+               }
+      end
+
+      for i <- 4..9 do
+        assert CF.surround_context("Foo . <<<", {1, i}) == %{
+                 context: {:dot, {:alias, ~c"Foo"}, ~c"<<<"},
+                 begin: {1, 1},
+                 end: {1, 10}
+               }
+      end
+
+      for i <- 4..6 do
+        assert CF.surround_context("Foo.::", {1, i}) == %{
+                 context: {:dot, {:alias, ~c"Foo"}, ~c"::"},
+                 begin: {1, 1},
+                 end: {1, 7}
+               }
+      end
+
+      for i <- 4..8 do
+        assert CF.surround_context("Foo . ::", {1, i}) == %{
+                 context: {:dot, {:alias, ~c"Foo"}, ~c"::"},
+                 begin: {1, 1},
+                 end: {1, 9}
+               }
+      end
+    end
+
+    test "capture operator" do
+      assert CF.surround_context("& &123 + 1", {1, 1}) == %{
+               context: {:operator, ~c"&"},
+               begin: {1, 1},
+               end: {1, 2}
+             }
+
+      for i <- 3..6 do
+        assert CF.surround_context("& &123 + 1", {1, i}) == %{
+                 context: {:capture_arg, ~c"&123"},
+                 begin: {1, 3},
+                 end: {1, 7}
+               }
+      end
+    end
+
+    test "capture operator false positive" do
+      assert CF.surround_context("1&&2", {1, 3}) == %{
+               context: {:operator, ~c"&&"},
+               begin: {1, 2},
+               end: {1, 4}
+             }
+
+      assert CF.surround_context("1&&2", {1, 4}) == :none
+
+      assert CF.surround_context("&a", {1, 2}) == %{
+               context: {:local_or_var, ~c"a"},
+               begin: {1, 2},
+               end: {1, 3}
+             }
+    end
+
+    test "unquoted atom" do
+      for i <- 1..10 do
+        assert CF.surround_context(":hello_wor", {1, i}) == %{
+                 context: {:unquoted_atom, ~c"hello_wor"},
+                 begin: {1, 1},
+                 end: {1, 11}
+               }
+      end
+
+      for i <- 1..10 do
+        assert CF.surround_context(":Hello@Wor", {1, i}) == %{
+                 context: {:unquoted_atom, ~c"Hello@Wor"},
+                 begin: {1, 1},
+                 end: {1, 11}
+               }
+      end
+
+      assert CF.surround_context(":", {1, 1}) == :none
+    end
+
+    test "keyword keys" do
+      for i <- 2..4 do
+        assert CF.surround_context("[foo:", {1, i}) == %{
+                 context: {:key, ~c"foo"},
+                 begin: {1, 2},
+                 end: {1, 5}
+               }
+      end
+
+      for i <- 10..12 do
+        assert CF.surround_context("[foo: 1, bar: 2]", {1, i}) == %{
+                 context: {:key, ~c"bar"},
+                 begin: {1, 10},
+                 end: {1, 13}
+               }
+      end
+
+      assert CF.surround_context("if foo?, do: bar()", {1, 10}) == %{
+               context: {:key, ~c"do"},
+               begin: {1, 10},
+               end: {1, 12}
+             }
+    end
+
+    test "keyword false positives" do
+      assert CF.surround_context("<<foo::", {1, 3}) == %{
+               context: {:local_or_var, ~c"foo"},
+               begin: {1, 3},
+               end: {1, 6}
+             }
+
+      assert CF.surround_context("[foo  :atom", {1, 2}) == %{
+               context: {:local_or_var, ~c"foo"},
+               begin: {1, 2},
+               end: {1, 5}
+             }
+    end
+  end
+
+  describe "container_cursor_to_quoted/2" do
+    def s2q!(arg, opts \\ []), do: Code.string_to_quoted!(arg, opts)
+
+    def cc2q!(arg, opts \\ []) do
+      {:ok, res} = CF.container_cursor_to_quoted(arg, opts)
+      res
+    end
+
+    test "completes terminators" do
+      assert cc2q!("(") == s2q!("(__cursor__())")
+      assert cc2q!("[") == s2q!("[__cursor__()]")
+      assert cc2q!("{") == s2q!("{__cursor__()}")
+      assert cc2q!("<<") == s2q!("<<__cursor__()>>")
+      assert cc2q!("foo do") == s2q!("foo do __cursor__() end")
+      assert cc2q!("foo do true else") == s2q!("foo do true else __cursor__() end")
+    end
+
+    test "inside interpolation" do
+      assert cc2q!(~S|"foo #{(|) == s2q!(~S|"foo #{(__cursor__())}"|)
+      assert cc2q!(~S|"foo #{"bar #{{|) == s2q!(~S|"foo #{"bar #{{__cursor__()}}"}"|)
+    end
+
+    test "keeps operators" do
+      assert cc2q!("1 + 2") == s2q!("1 + __cursor__()")
+      assert cc2q!("&foo") == s2q!("&__cursor__()")
+      assert cc2q!("&foo/") == s2q!("&foo/__cursor__()")
+    end
+
+    test "keeps function calls without parens" do
+      assert cc2q!("alias") == s2q!("__cursor__()")
+      assert cc2q!("alias ") == s2q!("alias __cursor__()")
+      assert cc2q!("alias foo") == s2q!("alias __cursor__()")
+      assert cc2q!("alias Foo.Bar") == s2q!("alias __cursor__()")
+      assert cc2q!("alias Foo.Bar,") == s2q!("alias Foo.Bar, __cursor__()")
+      assert cc2q!("alias Foo.Bar, as: ") == s2q!("alias Foo.Bar, as: __cursor__()")
+    end
+
+    test "do-end blocks" do
+      assert cc2q!("foo do baz") == s2q!("foo do __cursor__() end")
+      assert cc2q!("foo do bar; baz") == s2q!("foo do bar; __cursor__() end")
+      assert cc2q!("foo do bar\nbaz") == s2q!("foo do bar\n__cursor__() end")
+
+      assert cc2q!("foo(bar do baz") == s2q!("foo(bar do __cursor__() end)")
+      assert cc2q!("foo(bar do baz ") == s2q!("foo(bar do baz(__cursor__()) end)")
+      assert cc2q!("foo(bar do baz(") == s2q!("foo(bar do baz(__cursor__()) end)")
+      assert cc2q!("foo(bar do baz bat,") == s2q!("foo(bar do baz(bat, __cursor__()) end)")
+
+      assert cc2q!("foo(bar do baz, bat", trailing_fragment: " -> :ok end") ==
+               s2q!("foo(bar do baz, __cursor__() -> :ok end)")
+    end
+
+    test "keyword lists" do
+      assert cc2q!("[bar: ") == s2q!("[bar: __cursor__()]")
+      assert cc2q!("[bar: baz,") == s2q!("[bar: baz, __cursor__()]")
+      assert cc2q!("[arg, bar: baz,") == s2q!("[arg, bar: baz, __cursor__()]")
+      assert cc2q!("[arg: val, bar: baz,") == s2q!("[arg: val, bar: baz, __cursor__()]")
+
+      assert cc2q!("{arg, bar: ") == s2q!("{arg, bar: __cursor__()}")
+      assert cc2q!("{arg, bar: baz,") == s2q!("{arg, bar: baz, __cursor__()}")
+
+      assert cc2q!("foo(bar: ") == s2q!("foo(bar: __cursor__())")
+      assert cc2q!("foo(bar: baz,") == s2q!("foo([bar: baz, __cursor__()])")
+      assert cc2q!("foo(arg, bar: ") == s2q!("foo(arg, bar: __cursor__())")
+      assert cc2q!("foo(arg, bar: baz,") == s2q!("foo(arg, [bar: baz, __cursor__()])")
+      assert cc2q!("foo(arg: val, bar: ") == s2q!("foo(arg: val, bar: __cursor__())")
+      assert cc2q!("foo(arg: val, bar: baz,") == s2q!("foo([arg: val, bar: baz, __cursor__()])")
+
+      assert cc2q!("foo bar: ") == s2q!("foo(bar: __cursor__())")
+      assert cc2q!("foo bar: baz,") == s2q!("foo([bar: baz, __cursor__()])")
+      assert cc2q!("foo arg, bar: ") == s2q!("foo(arg, bar: __cursor__())")
+      assert cc2q!("foo arg, bar: baz,") == s2q!("foo(arg, [bar: baz, __cursor__()])")
+      assert cc2q!("foo arg: val, bar: ") == s2q!("foo(arg: val, bar: __cursor__())")
+      assert cc2q!("foo arg: val, bar: baz,") == s2q!("foo([arg: val, bar: baz, __cursor__()])")
+    end
+
+    test "maps and structs" do
+      assert cc2q!("%") == s2q!("__cursor__()")
+      assert cc2q!("%{") == s2q!("%{__cursor__()}")
+      assert cc2q!("%{bar:") == s2q!("%{__cursor__()}")
+      assert cc2q!("%{bar: ") == s2q!("%{bar: __cursor__()}")
+      assert cc2q!("%{bar: baz,") == s2q!("%{bar: baz, __cursor__()}")
+      assert cc2q!("%{foo | ") == s2q!("%{foo | __cursor__()}")
+      assert cc2q!("%{foo | bar:") == s2q!("%{foo | __cursor__()}")
+      assert cc2q!("%{foo | bar: ") == s2q!("%{foo | bar: __cursor__()}")
+      assert cc2q!("%{foo | bar: baz,") == s2q!("%{foo | bar: baz, __cursor__()}")
+
+      assert cc2q!("%Foo") == s2q!("__cursor__()")
+      assert cc2q!("%Foo{") == s2q!("%Foo{__cursor__()}")
+      assert cc2q!("%Foo{bar: ") == s2q!("%Foo{bar: __cursor__()}")
+      assert cc2q!("%Foo{bar: baz,") == s2q!("%Foo{bar: baz, __cursor__()}")
+      assert cc2q!("%Foo{foo | ") == s2q!("%Foo{foo | __cursor__()}")
+      assert cc2q!("%Foo{foo | bar:") == s2q!("%Foo{foo | __cursor__()}")
+      assert cc2q!("%Foo{foo | bar: ") == s2q!("%Foo{foo | bar: __cursor__()}")
+      assert cc2q!("%Foo{foo | bar: baz,") == s2q!("%Foo{foo | bar: baz, __cursor__()}")
+    end
+
+    test "binaries" do
+      assert cc2q!("<<") == s2q!("<<__cursor__()>>")
+      assert cc2q!("<<foo") == s2q!("<<__cursor__()>>")
+      assert cc2q!("<<foo, bar") == s2q!("<<foo, __cursor__()>>")
+      assert cc2q!("<<foo, bar::baz") == s2q!("<<foo, bar::__cursor__()>>")
+    end
+
+    test "anonymous functions" do
+      assert cc2q!("(fn", trailing_fragment: "-> end)") == s2q!("(fn __cursor__() -> nil end)")
+
+      assert cc2q!("(fn", trailing_fragment: "-> 1 + 2 end)") ==
+               s2q!("(fn __cursor__() -> 1 + 2 end)")
+
+      assert cc2q!("(fn x", trailing_fragment: "-> :ok end)") ==
+               s2q!("(fn __cursor__() -> :ok end)")
+
+      assert cc2q!("(fn x", trailing_fragment: ", y -> :ok end)") ==
+               s2q!("(fn __cursor__(), y -> :ok end)")
+
+      assert cc2q!("(fn x,", trailing_fragment: "y -> :ok end)") ==
+               s2q!("(fn x, __cursor__() -> :ok end)")
+
+      assert cc2q!("(fn x,", trailing_fragment: "\ny -> :ok end)") ==
+               s2q!("(fn x, __cursor__()\n -> :ok end)")
+
+      assert cc2q!("(fn x, {", trailing_fragment: "y, z} -> :ok end)") ==
+               s2q!("(fn x, {__cursor__(), z} -> :ok end)")
+
+      assert cc2q!("(fn x, {y", trailing_fragment: ", z} -> :ok end)") ==
+               s2q!("(fn x, {__cursor__(), z} -> :ok end)")
+
+      assert cc2q!("(fn x, {y, ", trailing_fragment: "z} -> :ok end)") ==
+               s2q!("(fn x, {y, __cursor__()} -> :ok end)")
+
+      assert cc2q!("(fn x ->", trailing_fragment: ":ok end)") ==
+               s2q!("(fn x -> __cursor__() end)")
+
+      assert cc2q!("(fn x ->", trailing_fragment: "\n:ok end)") ==
+               s2q!("(fn x -> __cursor__() end)")
+
+      assert cc2q!("(fn x when ", trailing_fragment: "-> :ok end)") ==
+               s2q!("(fn x when __cursor__() -> :ok end)")
+
+      assert cc2q!("(fn x when ", trailing_fragment: "->\n:ok end)") ==
+               s2q!("(fn x when __cursor__() -> :ok end)")
+
+      assert cc2q!("(fn") == s2q!("(__cursor__())")
+      assert cc2q!("(fn x") == s2q!("(__cursor__())")
+      assert cc2q!("(fn x,") == s2q!("(__cursor__())")
+      assert cc2q!("(fn x ->") == s2q!("(fn x -> __cursor__() end)")
+      assert cc2q!("(fn x -> x") == s2q!("(fn x -> __cursor__() end)")
+      assert cc2q!("(fn x, y -> x + y") == s2q!("(fn x, y -> x + __cursor__() end)")
+      assert cc2q!("(fn x, y -> x + y end") == s2q!("(__cursor__())")
+    end
+
+    test "do -> end" do
+      assert cc2q!("if do\nx ->\n", trailing_fragment: "y\nz ->\nw\nend") ==
+               s2q!("if do\nx ->\n__cursor__()\nz -> \nw\nend")
+
+      assert cc2q!("if do\nx ->\ny", trailing_fragment: "\nz ->\nw\nend") ==
+               s2q!("if do\nx ->\n__cursor__()\nz -> \nw\nend")
+
+      assert cc2q!("if do\nx ->\ny\n", trailing_fragment: "\nz ->\nw\nend") ==
+               s2q!("if do\nx ->\ny\n__cursor__()\nz -> \nw\nend")
+
+      assert cc2q!("for x <- [], reduce: %{} do\ny, ", trailing_fragment: "-> :ok\nend") ==
+               s2q!("for x <- [], reduce: %{} do\ny, __cursor__() -> :ok\nend")
+
+      assert cc2q!("for x <- [], reduce: %{} do\ny, z when ", trailing_fragment: "-> :ok\nend") ==
+               s2q!("for x <- [], reduce: %{} do\ny, z when __cursor__() -> :ok\nend")
+
+      assert cc2q!("case do\na -> a\nb = ", trailing_fragment: "c -> c\nend") ==
+               s2q!("case do\na -> a\nb = __cursor__() -> c\nend")
+    end
+
+    test "removes tokens until opening" do
+      assert cc2q!("(123") == s2q!("(__cursor__())")
+      assert cc2q!("[foo") == s2q!("[__cursor__()]")
+      assert cc2q!("{'foo'") == s2q!("{__cursor__()}")
+      assert cc2q!("foo do :atom") == s2q!("foo do __cursor__() end")
+      assert cc2q!("foo(:atom") == s2q!("foo(__cursor__())")
+    end
+
+    test "removes tokens until comma" do
+      assert cc2q!("[bar, 123") == s2q!("[bar, __cursor__()]")
+      assert cc2q!("{bar, 'foo'") == s2q!("{bar, __cursor__()}")
+      assert cc2q!("<<bar, \"sample\"") == s2q!("<<bar, __cursor__()>>")
+      assert cc2q!("foo(bar, :atom") == s2q!("foo(bar, __cursor__())")
+      assert cc2q!("foo bar, :atom") == s2q!("foo(bar, __cursor__())")
+    end
+
+    test "removes closed terminators" do
+      assert cc2q!("foo([1, 2, 3]") == s2q!("foo(__cursor__())")
+      assert cc2q!("foo({1, 2, 3}") == s2q!("foo(__cursor__())")
+      assert cc2q!("foo((1, 2, 3)") == s2q!("foo(__cursor__())")
+      assert cc2q!("foo(<<1, 2, 3>>") == s2q!("foo(__cursor__())")
+      assert cc2q!("foo(bar do :done end") == s2q!("foo(__cursor__())")
+    end
+
+    test "incomplete expressions" do
+      assert cc2q!("foo(123, :") == s2q!("foo(123, __cursor__())")
+      assert cc2q!("foo(123, %") == s2q!("foo(123, __cursor__())")
+      assert cc2q!("foo(123, 0x") == s2q!("foo(123, __cursor__())")
+      assert cc2q!("foo(123, ~") == s2q!("foo(123, __cursor__())")
+      assert cc2q!("foo(123, ~r") == s2q!("foo(123, __cursor__())")
+      assert cc2q!("foo(123, ~r/") == s2q!("foo(123, __cursor__())")
+    end
+
+    test "no warnings" do
+      assert cc2q!(~s"?\\ ") == s2q!("__cursor__()")
+      assert cc2q!(~s"{fn -> end, ") == s2q!("{fn -> nil end, __cursor__()}")
+    end
+
+    test "options" do
+      opts = [columns: true]
+      assert cc2q!("foo(", opts) == s2q!("foo(__cursor__())", opts)
+      assert cc2q!("foo(123,", opts) == s2q!("foo(123,__cursor__())", opts)
+
+      opts = [token_metadata: true]
+      assert cc2q!("foo(", opts) == s2q!("foo(__cursor__())", opts)
+      assert cc2q!("foo(123,", opts) == s2q!("foo(123,__cursor__())", opts)
+
+      opts = [literal_encoder: fn ast, _ -> {:ok, {:literal, ast}} end]
+      assert cc2q!("foo(", opts) == s2q!("foo(__cursor__())", opts)
+      assert cc2q!("foo(123,", opts) == s2q!("foo({:literal, 123},__cursor__())", [])
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/code_identifier_test.exs b/lib/elixir/test/elixir/code_identifier_test.exs
new file mode 100644
index 00000000000..769359b802b
--- /dev/null
+++ b/lib/elixir/test/elixir/code_identifier_test.exs
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule Code.IdentifierTest do
+  use ExUnit.Case, async: true
+  doctest Code.Identifier
+end
diff --git a/lib/elixir/test/elixir/code_normalizer/formatted_ast_test.exs b/lib/elixir/test/elixir/code_normalizer/formatted_ast_test.exs
new file mode 100644
index 00000000000..0061feed9db
--- /dev/null
+++ b/lib/elixir/test/elixir/code_normalizer/formatted_ast_test.exs
@@ -0,0 +1,603 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Code.Normalizer.FormatterASTTest do
+  use ExUnit.Case, async: true
+
+  defmacro assert_same(good, opts \\ []) do
+    quote bind_quoted: [good: good, opts: opts], location: :keep do
+      assert IO.iodata_to_binary(Code.format_string!(good, opts)) ==
+               string_to_string(good, opts)
+    end
+  end
+
+  def string_to_string(good, opts) do
+    line_length = Keyword.get(opts, :line_length, 98)
+    good = String.trim(good)
+
+    to_quoted_opts =
+      Keyword.merge(
+        [
+          literal_encoder: &{:ok, {:__block__, &2, [&1]}},
+          token_metadata: true,
+          unescape: false
+        ],
+        opts
+      )
+
+    {quoted, comments} = Code.string_to_quoted_with_comments!(good, to_quoted_opts)
+
+    to_algebra_opts = [comments: comments, escape: false] ++ opts
+
+    quoted
+    |> Code.quoted_to_algebra(to_algebra_opts)
+    |> Inspect.Algebra.format(line_length)
+    |> IO.iodata_to_binary()
+  end
+
+  describe "integers" do
+    test "in decimal base" do
+      assert_same "0"
+      assert_same "100"
+      assert_same "007"
+      assert_same "10000"
+      assert_same "100_00"
+    end
+
+    test "in binary base" do
+      assert_same "0b0"
+      assert_same "0b1"
+      assert_same "0b101"
+      assert_same "0b01"
+      assert_same "0b111_111"
+    end
+
+    test "in octal base" do
+      assert_same "0o77"
+      assert_same "0o0"
+      assert_same "0o01"
+      assert_same "0o777_777"
+    end
+
+    test "in hex base" do
+      assert_same "0x1"
+      assert_same "0x01"
+    end
+
+    test "as chars" do
+      assert_same "?a"
+      assert_same "?1"
+      assert_same "?è"
+      assert_same "??"
+      assert_same "?\\\\"
+      assert_same "?\\s"
+      assert_same "?🎾"
+    end
+  end
+
+  describe "floats" do
+    test "with normal notation" do
+      assert_same "0.0"
+      assert_same "1.0"
+      assert_same "123.456"
+      assert_same "0.0000001"
+      assert_same "001.100"
+      assert_same "0_10000_0.000_000"
+    end
+
+    test "with scientific notation" do
+      assert_same "1.0e1"
+      assert_same "1.0e-1"
+      assert_same "1.0e01"
+      assert_same "1.0e-01"
+      assert_same "001.100e-010"
+      assert_same "0_100_0000.100e-010"
+    end
+  end
+
+  describe "atoms" do
+    test "true, false, nil" do
+      assert_same "nil"
+      assert_same "true"
+      assert_same "false"
+    end
+
+    test "without escapes" do
+      assert_same ~S[:foo]
+    end
+
+    test "with escapes" do
+      assert_same ~S[:"f\a\b\ro"]
+    end
+
+    test "with unicode" do
+      assert_same ~S[:ólá]
+    end
+
+    test "does not reformat aliases" do
+      assert_same ~S[:"Elixir.String"]
+      assert_same ~S[:"Elixir"]
+    end
+
+    test "quoted operators" do
+      assert_same ~S[:"::"]
+      assert_same ~S[:"..//"]
+      assert_same ~S{["..//": 1]}
+    end
+
+    test "with interpolation" do
+      assert_same ~S[:"one #{2} three"]
+    end
+
+    test "with escapes and interpolation" do
+      assert_same ~S[:"one\n\"#{2}\"\nthree"]
+    end
+  end
+
+  describe "strings" do
+    test "without escapes" do
+      assert_same ~S["foo"]
+    end
+
+    test "with escapes" do
+      assert_same ~S["\x0A"]
+      assert_same ~S["f\a\b\ro"]
+      assert_same ~S["double \" quote"]
+    end
+
+    test "keeps literal new lines" do
+      assert_same """
+      "fo
+      o"
+      """
+    end
+
+    test "with interpolation" do
+      assert_same ~S["one #{} three"]
+      assert_same ~S["one #{2} three"]
+    end
+
+    test "with escaped interpolation" do
+      assert_same ~S["one\#{two}three"]
+    end
+
+    test "with escapes and interpolation" do
+      assert_same ~S["one\n\"#{2}\"\nthree"]
+    end
+  end
+
+  describe "lists" do
+    test "on module attribute" do
+      assert_same ~S"@foo [1]"
+    end
+  end
+
+  describe "charlists" do
+    test "without escapes" do
+      assert_same ~S[~c""]
+      assert_same ~S[~c" "]
+      assert_same ~S[~c"foo"]
+    end
+
+    test "with escapes" do
+      assert_same ~S[~c"f\a\b\ro"]
+      assert_same ~S[~c'single \' quote']
+      assert_same ~S[~c"double \" quote"]
+    end
+
+    test "keeps literal new lines" do
+      assert_same """
+      ~c"fo
+      o"
+      """
+    end
+
+    test "with interpolation" do
+      assert_same ~S[~c"one #{2} three"]
+    end
+
+    test "with escape and interpolation" do
+      assert_same ~S[~c'one\n\'#{2}\'\nthree']
+    end
+  end
+
+  describe "string heredocs" do
+    test "without escapes" do
+      assert_same ~S'''
+      """
+      hello
+      """
+      '''
+    end
+
+    test "with escapes" do
+      assert_same ~S'''
+      """
+      f\a\b\ro
+      """
+      '''
+
+      assert_same ~S'''
+      """
+      multiple "\"" quotes
+      """
+      '''
+    end
+
+    test "with interpolation" do
+      assert_same ~S'''
+      """
+      one
+      #{2}
+      three
+      """
+      '''
+
+      assert_same ~S'''
+      """
+      one
+      "
+      #{2}
+      "
+      three
+      """
+      '''
+    end
+
+    test "nested with empty lines" do
+      assert_same ~S'''
+      nested do
+        """
+
+        foo
+
+
+        bar
+
+        """
+      end
+      '''
+    end
+
+    test "nested with empty lines and interpolation" do
+      assert_same ~S'''
+      nested do
+        """
+
+        #{foo}
+
+
+        #{bar}
+
+        """
+      end
+      '''
+
+      assert_same ~S'''
+      nested do
+        """
+        #{foo}
+
+
+        #{bar}
+        """
+      end
+      '''
+    end
+
+    test "with escaped new lines" do
+      assert_same ~S'''
+      """
+      one\
+      #{"two"}\
+      three\
+      """
+      '''
+    end
+  end
+
+  describe "charlist heredocs" do
+    test "without escapes" do
+      assert_same ~S"""
+      ~c'''
+      hello
+      '''
+      """
+    end
+
+    test "with escapes" do
+      assert_same ~S"""
+      ~c'''
+      f\a\b\ro
+      '''
+      """
+
+      assert_same ~S"""
+      ~c'''
+      multiple "\"" quotes
+      '''
+      """
+    end
+
+    test "with interpolation" do
+      assert_same ~S"""
+      ~c'''
+      one
+      #{2}
+      three
+      '''
+      """
+
+      assert_same ~S"""
+      ~c'''
+      one
+      "
+      #{2}
+      "
+      three
+      '''
+      """
+    end
+  end
+
+  describe "keyword list" do
+    test "blocks" do
+      assert_same ~S"""
+      defmodule Example do
+        def sample, do: :ok
+      end
+      """
+
+      assert_same ~S"""
+      with true, do: :ok, else: (_ -> :ok)
+      """
+    end
+
+    test "omitting brackets" do
+      assert_same ~S"""
+      @type foo :: a when b: :c
+      """
+    end
+
+    test "last tuple element as keyword list keeps its format" do
+      assert_same ~S"{:wrapped, [opt1: true, opt2: false]}"
+      assert_same ~S"{:unwrapped, opt1: true, opt2: false}"
+      assert_same ~S"{:wrapped, 1, [opt1: true, opt2: false]}"
+      assert_same ~S"{:unwrapped, 1, opt1: true, opt2: false}"
+    end
+
+    test "on module attribute" do
+      assert_same ~S"""
+      @foo a: b,
+           c: d
+      """
+
+      assert_same ~S"@foo [
+        a: b,
+        c: d
+      ]"
+    end
+  end
+
+  describe "preserves user choice on parenthesis" do
+    test "in functions with do blocks" do
+      assert_same(~S"""
+      foo Bar do
+        :ok
+      end
+      """)
+
+      assert_same(~S"""
+      foo(Bar) do
+        :ok
+      end
+      """)
+    end
+  end
+
+  describe "preserves formatting for sigils" do
+    test "without interpolation" do
+      assert_same ~S[~s(foo)]
+      assert_same ~S[~s{foo bar}]
+      assert_same ~S[~r/Bar Baz/]
+      assert_same ~S[~w<>]
+      assert_same ~S[~W()]
+    end
+
+    test "with escapes" do
+      assert_same ~S[~s(foo \) bar)]
+      assert_same ~S[~s(f\a\b\ro)]
+
+      assert_same ~S"""
+      ~S(foo\
+      bar)
+      """
+    end
+
+    test "with nested new lines" do
+      assert_same ~S"""
+      foo do
+        ~S(foo\
+      bar)
+      end
+      """
+
+      assert_same ~S"""
+      foo do
+        ~s(#{bar}
+      )
+      end
+      """
+    end
+
+    test "with interpolation" do
+      assert_same ~S[~s(one #{2} three)]
+    end
+
+    test "with modifiers" do
+      assert_same ~S[~w(one two three)a]
+      assert_same ~S[~z(one two three)foo]
+    end
+
+    test "with heredoc syntax" do
+      assert_same ~S"""
+      ~s'''
+      one\a
+      #{:two}\r
+      three\0
+      '''
+      """
+
+      assert_same ~S'''
+      ~s"""
+      one\a
+      #{:two}\r
+      three\0
+      """
+      '''
+    end
+
+    test "with heredoc syntax and modifier" do
+      assert_same ~S"""
+      ~s'''
+      foo
+      '''rsa
+      """
+    end
+  end
+
+  describe "preserves comments formatting" do
+    test "before and after expressions" do
+      assert_same """
+      # before comment
+      :hello
+      """
+
+      assert_same """
+      :hello
+      # after comment
+      """
+
+      assert_same """
+      # before comment
+      :hello
+      # after comment
+      """
+    end
+
+    test "empty comment" do
+      assert_same """
+      #
+      :foo
+      """
+    end
+
+    test "handles comments with unescaped literal" do
+      assert_same """
+                  # before
+                  Mix.install([:foo])
+                  # after
+                  """,
+                  literal_encoder: fn literal, _ -> {:ok, literal} end
+
+      assert_same """
+                  # before
+                  Mix.install([1 + 2, :foo])
+                  # after
+                  """,
+                  literal_encoder: fn literal, _ -> {:ok, literal} end
+
+      assert_same """
+                  # before
+                  Mix.install([:foo, 1 + 2])
+                  # after
+                  """,
+                  literal_encoder: fn literal, _ -> {:ok, literal} end
+
+      assert_same """
+                  block do
+                    # before 1
+                    1 + 1
+
+                    # before 2
+                    2 + 2
+                  end
+                  """,
+                  literal_encoder: fn literal, _ -> {:ok, literal} end
+
+      assert_same """
+                  block do
+                    # before 1
+                    Mix.install([1 + 1])
+
+                    # before 2
+                    Mix.install([2 + 2])
+                  end
+                  """,
+                  literal_encoder: fn literal, _ -> {:ok, literal} end
+    end
+
+    test "before and after expressions with newlines" do
+      assert_same """
+      # before comment
+      # second line
+
+      :hello
+
+      # middle comment 1
+
+      #
+
+      # middle comment 2
+
+      :world
+
+      # after comment
+      # second line
+      """
+    end
+
+    test "interpolation with comment outside before and after" do
+      assert_same ~S"""
+      # comment
+      IO.puts("Hello #{world}")
+      """
+
+      assert_same ~S"""
+      IO.puts("Hello #{world}")
+      # comment
+      """
+    end
+
+    test "blocks with keyword list" do
+      assert_same ~S"""
+      defp sample do
+        [
+          # comment
+          {:a, "~> 1.2"}
+        ]
+      end
+      """
+
+      assert_same ~S"""
+      defp sample do
+        [
+          # comment
+          {:a, "~> 1.2"},
+          {:b, "~> 1.2"}
+        ]
+      end
+      """
+    end
+
+    test "keyword literals with variable values" do
+      assert_same(~S"""
+      foo = foo()
+      [foo: foo]
+      """)
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/code_normalizer/quoted_ast_test.exs b/lib/elixir/test/elixir/code_normalizer/quoted_ast_test.exs
new file mode 100644
index 00000000000..c10fdf041a2
--- /dev/null
+++ b/lib/elixir/test/elixir/code_normalizer/quoted_ast_test.exs
@@ -0,0 +1,823 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Code.Normalizer.QuotedASTTest do
+  use ExUnit.Case, async: true
+
+  describe "quoted_to_algebra/2" do
+    test "variable" do
+      assert quoted_to_string(quote(do: foo)) == "foo"
+      assert quoted_to_string({:{}, [], nil}) == "{}"
+    end
+
+    test "variable with colors" do
+      opts = [syntax_colors: [variable: :blue]]
+      assert quoted_to_string(quote(do: foo), opts) == "\e[34mfoo\e[0m"
+    end
+
+    test "local call" do
+      assert quoted_to_string(quote(do: foo(1, 2, 3))) == "foo(1, 2, 3)"
+      assert quoted_to_string(quote(do: foo([1, 2, 3]))) == "foo([1, 2, 3])"
+
+      assert quoted_to_string(quote(do: foo(1, 2, 3)), locals_without_parens: [foo: 3]) ==
+               "foo 1, 2, 3"
+
+      # Mixing literals and non-literals
+      assert quoted_to_string(quote(do: foo(a, 2))) == "foo(a, 2)"
+      assert quoted_to_string(quote(do: foo(1, b))) == "foo(1, b)"
+
+      # Mixing literals and non-literals with line
+      assert quoted_to_string(quote(line: __ENV__.line, do: foo(a, 2))) == "foo(a, 2)"
+      assert quoted_to_string(quote(line: __ENV__.line, do: foo(1, b))) == "foo(1, b)"
+    end
+
+    test "local call with colors" do
+      opts = [syntax_colors: [call: :blue, number: :yellow, variable: :red]]
+
+      assert quoted_to_string(quote(do: foo(1, a)), opts) ==
+               "\e[34mfoo\e[0m(\e[33m1\e[0m, \e[31ma\e[0m)"
+    end
+
+    test "local call no parens" do
+      assert quoted_to_string({:def, [], [1, 2]}) == "def 1, 2"
+      assert quoted_to_string({:def, [closing: []], [1, 2]}) == "def(1, 2)"
+    end
+
+    test "remote call" do
+      assert quoted_to_string(quote(do: foo.bar(1, 2, 3))) == "foo.bar(1, 2, 3)"
+      assert quoted_to_string(quote(do: foo.bar([1, 2, 3]))) == "foo.bar([1, 2, 3])"
+
+      quoted =
+        quote do
+          (foo do
+             :ok
+           end).bar([1, 2, 3])
+        end
+
+      assert quoted_to_string(quoted) == "(foo do\n   :ok\n end).bar([1, 2, 3])"
+    end
+
+    test "nullary remote call" do
+      assert quoted_to_string(quote do: foo.bar) == "foo.bar"
+      assert quoted_to_string(quote do: foo.bar()) == "foo.bar()"
+    end
+
+    test "atom remote call" do
+      assert quoted_to_string(quote(do: :foo.bar(1, 2, 3))) == ":foo.bar(1, 2, 3)"
+    end
+
+    test "remote and fun call" do
+      assert quoted_to_string(quote(do: foo.bar().(1, 2, 3))) == "foo.bar().(1, 2, 3)"
+      assert quoted_to_string(quote(do: foo.bar().([1, 2, 3]))) == "foo.bar().([1, 2, 3])"
+    end
+
+    test "unusual remote atom fun call" do
+      assert quoted_to_string(quote(do: Foo."42"())) == ~s/Foo."42"()/
+      assert quoted_to_string(quote(do: Foo."Bar"())) == ~s/Foo."Bar"()/
+      assert quoted_to_string(quote(do: Foo."bar baz"().""())) == ~s/Foo."bar baz"().""()/
+      assert quoted_to_string(quote(do: Foo."%{}"())) == ~s/Foo."%{}"()/
+      assert quoted_to_string(quote(do: Foo."..."())) == ~s/Foo."..."()/
+    end
+
+    test "atom fun call" do
+      assert quoted_to_string(quote(do: :foo.(1, 2, 3))) == ":foo.(1, 2, 3)"
+    end
+
+    test "aliases call" do
+      assert quoted_to_string(quote(do: Foo.Bar.baz(1, 2, 3))) == "Foo.Bar.baz(1, 2, 3)"
+      assert quoted_to_string(quote(do: Foo.Bar.baz([1, 2, 3]))) == "Foo.Bar.baz([1, 2, 3])"
+      assert quoted_to_string(quote(do: ?0.Bar.baz([1, 2, 3]))) == "48.Bar.baz([1, 2, 3])"
+      assert quoted_to_string(quote(do: Foo.bar(<<>>, []))) == "Foo.bar(<<>>, [])"
+    end
+
+    test "remote call with colors" do
+      opts = [syntax_colors: [call: :blue, number: :yellow, variable: :red, atom: :green]]
+
+      assert quoted_to_string(quote(do: foo.bar(1, 2)), opts) ==
+               "\e[31mfoo\e[0m.\e[34mbar\e[0m(\e[33m1\e[0m, \e[33m2\e[0m)"
+
+      assert quoted_to_string(quote(do: :foo.bar(1, 2)), opts) ==
+               "\e[32m:foo\e[0m.\e[34mbar\e[0m(\e[33m1\e[0m, \e[33m2\e[0m)"
+
+      assert quoted_to_string(quote(do: Foo.Bar.bar(1, 2)), opts) ==
+               "\e[32mFoo.Bar\e[0m.\e[34mbar\e[0m(\e[33m1\e[0m, \e[33m2\e[0m)"
+    end
+
+    test "keyword call" do
+      assert quoted_to_string(quote(do: Foo.bar(foo: :bar))) == "Foo.bar(foo: :bar)"
+      assert quoted_to_string(quote(do: Foo.bar("Elixir.Foo": :bar))) == "Foo.bar([{Foo, :bar}])"
+    end
+
+    test "sigil call" do
+      assert quoted_to_string(quote(do: ~r"123")) == ~S/~r"123"/
+      assert quoted_to_string(quote(do: ~r"\n123")) == ~S/~r"\n123"/
+      assert quoted_to_string(quote(do: ~r"12\"3")) == ~S/~r"12\"3"/
+      assert quoted_to_string(quote(do: ~r/12\/3/u)) == ~S"~r/12\/3/u"
+      assert quoted_to_string(quote(do: ~r{\n123})) == ~S/~r{\n123}/
+      assert quoted_to_string(quote(do: ~r((1\)(2\)3))) == ~S/~r((1\)(2\)3)/
+      assert quoted_to_string(quote(do: ~r{\n1{1\}23})) == ~S/~r{\n1{1\}23}/
+      assert quoted_to_string(quote(do: ~r|12\|3|)) == ~S"~r|12\|3|"
+
+      assert quoted_to_string(quote(do: ~r[1#{two}3])) == ~S/~r[1#{two}3]/
+      assert quoted_to_string(quote(do: ~r|1[#{two}]3|)) == ~S/~r|1[#{two}]3|/
+      assert quoted_to_string(quote(do: ~r'1#{two}3'u)) == ~S/~r'1#{two}3'u/
+
+      assert quoted_to_string(quote(do: ~R"123")) == ~S/~R"123"/
+      assert quoted_to_string(quote(do: ~R"123"u)) == ~S/~R"123"u/
+      assert quoted_to_string(quote(do: ~R"\n123")) == ~S/~R"\n123"/
+
+      assert quoted_to_string(quote(do: ~S["'(123)'"])) == ~S/~S["'(123)'"]/
+      assert quoted_to_string(quote(do: ~s"#{"foo"}")) == ~S/~s"#{"foo"}"/
+
+      assert quoted_to_string(quote(do: ~S["'(123)'"]) |> strip_metadata()) == ~S/~S"\"'(123)'\""/
+      assert quoted_to_string(quote(do: ~s"#{"foo"}") |> strip_metadata()) == ~S/~s"#{"foo"}"/
+
+      assert quoted_to_string(
+               quote do
+                 ~s"""
+                 "\""foo"\""
+                 """
+               end
+             ) == ~s[~s"""\n"\\""foo"\\""\n"""]
+
+      assert quoted_to_string(
+               quote do
+                 ~s'''
+                 '\''foo'\''
+                 '''
+               end
+             ) == ~s[~s'''\n'\\''foo'\\''\n''']
+
+      assert quoted_to_string(
+               quote do
+                 ~s"""
+                 "\"foo\""
+                 """
+               end
+             ) == ~s[~s"""\n"\\"foo\\""\n"""]
+
+      assert quoted_to_string(
+               quote do
+                 ~s'''
+                 '\"foo\"'
+                 '''
+               end
+             ) == ~s[~s'''\n'\\"foo\\"'\n''']
+
+      assert quoted_to_string(
+               quote do
+                 ~S"""
+                 "123"
+                 """
+               end
+             ) == ~s[~S"""\n"123"\n"""]
+    end
+
+    test "regression: invalid sigil calls" do
+      assert quoted_to_string(quote do: sigil_r(<<"foo", 123>>, [])) ==
+               "sigil_r(<<\"foo\", 123>>, [])"
+
+      assert quoted_to_string(quote do: sigil_r(<<"foo">>, :invalid_modifiers)) ==
+               "sigil_r(\"foo\", :invalid_modifiers)"
+
+      assert quoted_to_string(quote do: sigil_r(<<"foo">>, [:invalid_modifier])) ==
+               "sigil_r(\"foo\", [:invalid_modifier])"
+
+      assert quoted_to_string(quote do: sigil_r(<<"foo">>, [])) == "~r\"foo\""
+      assert quoted_to_string(quote do: sigil_r(<<"foo">>, [?a, ?b, ?c])) == "~r\"foo\"abc"
+    end
+
+    test "tuple" do
+      assert quoted_to_string(quote do: {1, 2}) == "{1, 2}"
+      assert quoted_to_string(quote do: {1}) == "{1}"
+      assert quoted_to_string(quote do: {1, 2, 3}) == "{1, 2, 3}"
+      assert quoted_to_string(quote do: {1, 2, 3, foo: :bar}) == "{1, 2, 3, foo: :bar}"
+    end
+
+    test "tuple with colors" do
+      opts = [syntax_colors: [tuple: :blue, number: :yellow]]
+
+      assert quoted_to_string(quote(do: {1, 2, 3}), opts) ==
+               "\e[34m{\e[0m\e[33m1\e[0m, \e[33m2\e[0m, \e[33m3\e[0m\e[34m}\e[0m"
+    end
+
+    test "tuple call" do
+      assert quoted_to_string(quote(do: alias(Foo.{Bar, Baz, Bong}))) ==
+               "alias Foo.{Bar, Baz, Bong}"
+
+      assert quoted_to_string(quote(do: foo(Foo.{}))) == "foo(Foo.{})"
+    end
+
+    test "arrow" do
+      assert quoted_to_string(quote(do: foo(1, (2 -> 3)))) == "foo(1, (2 -> 3))"
+    end
+
+    test "block" do
+      quoted =
+        quote do
+          1
+          2
+
+          (
+            :foo
+            :bar
+          )
+
+          3
+        end
+
+      expected = """
+      1
+      2
+
+      (
+        :foo
+        :bar
+      )
+
+      3
+      """
+
+      assert quoted_to_string(quoted) <> "\n" == expected
+    end
+
+    test "not in" do
+      assert quoted_to_string(quote(do: false not in [])) == "false not in []"
+    end
+
+    test "if else" do
+      expected = """
+      if foo do
+        bar
+      else
+        baz
+      end
+      """
+
+      assert quoted_to_string(quote(do: if(foo, do: bar, else: baz))) <> "\n" == expected
+    end
+
+    test "case" do
+      quoted =
+        quote do
+          case foo do
+            true ->
+              0
+
+            false ->
+              1
+              2
+          end
+        end
+
+      expected = """
+      case foo do
+        true ->
+          0
+
+        false ->
+          1
+          2
+      end
+      """
+
+      assert quoted_to_string(quoted) <> "\n" == expected
+    end
+
+    test "case if else" do
+      expected = """
+      case (if foo do
+              bar
+            else
+              baz
+            end) do
+      end
+      """
+
+      assert quoted_to_string(
+               quote(
+                 do:
+                   case if(foo, do: bar, else: baz) do
+                   end
+               )
+             ) <> "\n" == expected
+    end
+
+    test "try" do
+      quoted =
+        quote do
+          try do
+            foo
+          catch
+            _, _ ->
+              2
+          rescue
+            ArgumentError ->
+              1
+          after
+            4
+          else
+            _ ->
+              3
+          end
+        end
+
+      expected = """
+      try do
+        foo
+      catch
+        _, _ -> 2
+      rescue
+        ArgumentError -> 1
+      after
+        4
+      else
+        _ -> 3
+      end
+      """
+
+      assert quoted_to_string(quoted) <> "\n" == expected
+    end
+
+    test "fn" do
+      assert quoted_to_string(quote(do: fn -> 1 + 2 end)) == "fn -> 1 + 2 end"
+      assert quoted_to_string(quote(do: fn x -> x + 1 end)) == "fn x -> x + 1 end"
+
+      quoted =
+        quote do
+          fn x ->
+            y = x + 1
+            y
+          end
+        end
+
+      expected = """
+      fn x ->
+        y = x + 1
+        y
+      end
+      """
+
+      assert quoted_to_string(quoted) <> "\n" == expected
+
+      quoted =
+        quote do
+          fn
+            x ->
+              y = x + 1
+              y
+
+            z ->
+              z
+          end
+        end
+
+      expected = """
+      fn
+        x ->
+          y = x + 1
+          y
+
+        z ->
+          z
+      end
+      """
+
+      assert quoted_to_string(quoted) <> "\n" == expected
+
+      assert quoted_to_string(quote(do: (fn x -> x end).(1))) == "(fn x -> x end).(1)"
+
+      quoted =
+        quote do
+          (fn
+             %{} -> :map
+             _ -> :other
+           end).(1)
+        end
+
+      expected = """
+      (fn
+         %{} -> :map
+         _ -> :other
+       end).(1)
+      """
+
+      assert quoted_to_string(quoted) <> "\n" == expected
+    end
+
+    test "range" do
+      assert quoted_to_string(quote(do: -1..+2)) == "-1..+2"
+      assert quoted_to_string(quote(do: Foo.integer()..3)) == "Foo.integer()..3"
+      assert quoted_to_string(quote(do: -1..+2//-3)) == "-1..+2//-3"
+
+      assert quoted_to_string(quote(do: Foo.integer()..3//Bar.bat())) ==
+               "Foo.integer()..3//Bar.bat()"
+
+      # invalid AST
+      assert quoted_to_string(-1..+2) == "-1..2"
+      assert quoted_to_string(-1..+2//-3) == "-1..2//-3"
+    end
+
+    test "when" do
+      assert quoted_to_string(quote(do: (-> x))) == "(-> x)"
+      assert quoted_to_string(quote(do: (x when y -> z))) == "(x when y -> z)"
+      assert quoted_to_string(quote(do: (x, y when z -> w))) == "(x, y when z -> w)"
+      assert quoted_to_string(quote(do: (x, y when z -> w))) == "(x, y when z -> w)"
+      assert quoted_to_string(quote(do: (x, y when z -> w))) == "(x, y when z -> w)"
+      assert quoted_to_string(quote(do: (x when y: z))) == "x when y: z"
+      assert quoted_to_string(quote(do: (x when y: z, z: w))) == "x when y: z, z: w"
+    end
+
+    test "nested" do
+      quoted =
+        quote do
+          defmodule Foo do
+            def foo do
+              1 + 1
+            end
+          end
+        end
+
+      expected = """
+      defmodule Foo do
+        def foo do
+          1 + 1
+        end
+      end
+      """
+
+      assert quoted_to_string(quoted) <> "\n" == expected
+    end
+
+    test "operator precedence" do
+      assert quoted_to_string(quote(do: (1 + 2) * (3 - 4))) == "(1 + 2) * (3 - 4)"
+      assert quoted_to_string(quote(do: (1 + 2) * 3 - 4)) == "(1 + 2) * 3 - 4"
+      assert quoted_to_string(quote(do: 1 + 2 + 3)) == "1 + 2 + 3"
+      assert quoted_to_string(quote(do: 1 + 2 - 3)) == "1 + 2 - 3"
+    end
+
+    test "capture operator" do
+      assert quoted_to_string(quote(do: &foo/0)) == "&foo/0"
+      assert quoted_to_string(quote(do: &Foo.foo/0)) == "&Foo.foo/0"
+      assert quoted_to_string(quote(do: &(&1 + &2))) == "&(&1 + &2)"
+      assert quoted_to_string(quote(do: & &1)) == "& &1"
+      assert quoted_to_string(quote(do: & &1.(:x))) == "& &1.(:x)"
+      assert quoted_to_string(quote(do: (& &1).(:x))) == "(& &1).(:x)"
+    end
+
+    test "operators" do
+      assert quoted_to_string(quote(do: foo |> {1, 2})) == "foo |> {1, 2}"
+      assert quoted_to_string(quote(do: foo |> {:map, arg})) == "foo |> {:map, arg}"
+    end
+
+    test "containers" do
+      assert quoted_to_string(quote(do: {})) == "{}"
+      assert quoted_to_string(quote(do: [])) == "[]"
+      assert quoted_to_string(quote(do: {1, 2, 3})) == "{1, 2, 3}"
+      assert quoted_to_string(quote(do: [1, 2, 3])) == "[1, 2, 3]"
+      assert quoted_to_string(quote(do: ["Elixir.Foo": :bar])) == "[{Foo, :bar}]"
+      assert quoted_to_string(quote(do: %{})) == "%{}"
+      assert quoted_to_string(quote(do: %{:foo => :bar})) == "%{foo: :bar}"
+      assert quoted_to_string(quote(do: %{:"Elixir.Foo" => :bar})) == "%{Foo => :bar}"
+      assert quoted_to_string(quote(do: %{{1, 2} => [1, 2, 3]})) == "%{{1, 2} => [1, 2, 3]}"
+      assert quoted_to_string(quote(do: %{map | "a" => "b"})) == "%{map | \"a\" => \"b\"}"
+      assert quoted_to_string(quote(do: [1, 2, 3])) == "[1, 2, 3]"
+    end
+
+    test "false positive containers" do
+      assert quoted_to_string({:%{}, [], nil}) == "%{}"
+    end
+
+    test "struct" do
+      assert quoted_to_string(quote(do: %Test{})) == "%Test{}"
+      assert quoted_to_string(quote(do: %Test{foo: 1, bar: 1})) == "%Test{foo: 1, bar: 1}"
+      assert quoted_to_string(quote(do: %Test{struct | foo: 2})) == "%Test{struct | foo: 2}"
+      assert quoted_to_string(quote(do: %Test{} + 1)) == "%Test{} + 1"
+      assert quoted_to_string(quote(do: %Test{foo(1)} + 2)) == "%Test{foo(1)} + 2"
+    end
+
+    test "binary operators" do
+      assert quoted_to_string(quote(do: 1 + 2)) == "1 + 2"
+      assert quoted_to_string(quote(do: [1, 2 | 3])) == "[1, 2 | 3]"
+      assert quoted_to_string(quote(do: [h | t] = [1, 2, 3])) == "[h | t] = [1, 2, 3]"
+      assert quoted_to_string(quote(do: (x ++ y) ++ z)) == "(x ++ y) ++ z"
+      assert quoted_to_string(quote(do: (x +++ y) +++ z)) == "(x +++ y) +++ z"
+    end
+
+    test "unary operators" do
+      assert quoted_to_string(quote(do: not 1)) == "not 1"
+      assert quoted_to_string(quote(do: not foo)) == "not foo"
+      assert quoted_to_string(quote(do: -1)) == "-1"
+      assert quoted_to_string(quote(do: +(+1))) == "+(+1)"
+      assert quoted_to_string(quote(do: !(foo > bar))) == "!(foo > bar)"
+      assert quoted_to_string(quote(do: @foo(bar))) == "@foo bar"
+      assert quoted_to_string(quote(do: identity(&1))) == "identity(&1)"
+    end
+
+    test "operators with colors" do
+      opts = [syntax_colors: [operator: :blue, number: :yellow]]
+      assert quoted_to_string(quote(do: !!1), opts) == "\e[34m!\e[0m\e[34m!\e[0m\e[33m1\e[0m"
+      assert quoted_to_string(quote(do: 1 + 2), opts) == "\e[33m1\e[0m\e[34m +\e[0m \e[33m2\e[0m"
+    end
+
+    test "access" do
+      assert quoted_to_string(quote(do: a[b])) == "a[b]"
+      assert quoted_to_string(quote(do: a[1 + 2])) == "a[1 + 2]"
+      assert quoted_to_string(quote(do: (a || [a: 1])[:a])) == "(a || [a: 1])[:a]"
+      assert quoted_to_string(quote(do: Map.put(%{}, :a, 1)[:a])) == "Map.put(%{}, :a, 1)[:a]"
+    end
+
+    test "keyword list" do
+      assert quoted_to_string(quote(do: [a: a, b: b])) == "[a: a, b: b]"
+      assert quoted_to_string(quote(do: [a: 1, b: 1 + 2])) == "[a: 1, b: 1 + 2]"
+      assert quoted_to_string(quote(do: ["a.b": 1, c: 1 + 2])) == "[\"a.b\": 1, c: 1 + 2]"
+
+      tuple = {{:__block__, [format: :keyword], [:a]}, {:b, [], nil}}
+      assert quoted_to_string([tuple, :foo, tuple]) == "[{:a, b}, :foo, a: b]"
+      assert quoted_to_string([tuple, :foo, {:c, :d}, tuple]) == "[{:a, b}, :foo, c: :d, a: b]"
+
+      # Not keyword lists
+      assert quoted_to_string(quote(do: [{binary(), integer()}])) == "[{binary(), integer()}]"
+    end
+
+    test "keyword list with colors" do
+      opts = [syntax_colors: [list: :blue, atom: :green, number: :yellow]]
+
+      assert quoted_to_string(quote(do: [a: 1, b: 2]), opts) ==
+               "\e[34m[\e[0m\e[32ma:\e[0m \e[33m1\e[0m, \e[32mb:\e[0m \e[33m2\e[0m\e[34m]\e[0m"
+    end
+
+    test "keyword list with :do as operand" do
+      assert quoted_to_string(quote(do: a = [do: 1])) == "a = [do: 1]"
+    end
+
+    test "interpolation" do
+      assert quoted_to_string(quote(do: "foo#{bar}baz")) == ~S["foo#{bar}baz"]
+    end
+
+    test "bit syntax" do
+      ast = quote(do: <<1::8*4>>)
+      assert quoted_to_string(ast) == "<<1::8*4>>"
+
+      ast = quote(do: @type(foo :: <<_::8, _::_*4>>))
+      assert quoted_to_string(ast) == "@type foo :: <<_::8, _::_*4>>"
+
+      ast = quote(do: <<69 - 4::bits-size(8 - 4)-unit(1), 65>>)
+      assert quoted_to_string(ast) == "<<69 - 4::bits-size(8 - 4)-unit(1), 65>>"
+
+      ast = quote(do: <<(<<65>>), 65>>)
+      assert quoted_to_string(ast) == "<<(<<65>>), 65>>"
+
+      ast = quote(do: <<65, (<<65>>)>>)
+      assert quoted_to_string(ast) == "<<65, (<<65>>)>>"
+
+      ast = quote(do: for(<<(a::4 <- <<1, 2>>)>>, do: a))
+      assert quoted_to_string(ast) == "for <<(a::4 <- <<1, 2>>)>> do\n  a\nend"
+    end
+
+    test "integer/float" do
+      assert quoted_to_string(1) == "1"
+      assert quoted_to_string({:__block__, [], [1]}) == "1"
+      assert quoted_to_string(1.23) == "1.23"
+    end
+
+    test "integer/float with colors" do
+      opts = [syntax_colors: [number: :yellow]]
+      assert quoted_to_string(1, opts) == "\e[33m1\e[0m"
+      assert quoted_to_string(1.23, opts) == "\e[33m1.23\e[0m"
+    end
+
+    test "charlist" do
+      assert quoted_to_string(quote(do: [])) == "[]"
+      assert quoted_to_string(quote(do: ~c"abc")) == ~S/~c"abc"/
+
+      # False positive
+      assert quoted_to_string(
+               quote do
+                 :"Elixir.List".to_charlist([
+                   case var do
+                     var -> var
+                   end
+                 ])
+               end
+             ) =~ "List.to_charlist([\n  case var do\n    var -> var\n  end\n])"
+    end
+
+    test "string" do
+      assert quoted_to_string(quote(do: "")) == ~S/""/
+      assert quoted_to_string(quote(do: "abc")) == ~S/"abc"/
+      assert quoted_to_string(quote(do: "#{"abc"}")) == ~S/"#{"abc"}"/
+    end
+
+    test "string with colors" do
+      opts = [syntax_colors: [string: :green]]
+      assert quoted_to_string(quote(do: "abc"), opts) == "\e[32m\"abc\"\e[0m"
+    end
+
+    test "catch-all" do
+      assert quoted_to_string(quote do: {unquote(self())}) == "{#{inspect(self())}}"
+      assert quoted_to_string(quote do: foo(unquote(self()))) == "foo(#{inspect(self())})"
+    end
+
+    test "last arg keyword list" do
+      assert quoted_to_string(quote(do: foo([]))) == "foo([])"
+      assert quoted_to_string(quote(do: foo(x: y))) == "foo(x: y)"
+      assert quoted_to_string(quote(do: foo(x: 1 + 2))) == "foo(x: 1 + 2)"
+      assert quoted_to_string(quote(do: foo(x: y, p: q))) == "foo(x: y, p: q)"
+      assert quoted_to_string(quote(do: foo(a, x: y, p: q))) == "foo(a, x: y, p: q)"
+
+      assert quoted_to_string(quote(do: {[]})) == "{[]}"
+      assert quoted_to_string(quote(do: {[a: b]})) == "{[a: b]}"
+      assert quoted_to_string(quote(do: {x, a: b})) == "{x, a: b}"
+      assert quoted_to_string(quote(do: foo(else: a))) == "foo(else: a)"
+      assert quoted_to_string(quote(do: foo(catch: a))) == "foo(catch: a)"
+      assert quoted_to_string(quote(do: foo |> [bar: :baz])) == "foo |> [bar: :baz]"
+    end
+
+    test "keyword arg with cursor" do
+      input = "def foo, do: :bar, __cursor__()"
+      expected = "def foo, [{:do, :bar}, __cursor__()]"
+
+      ast = Code.string_to_quoted!(input)
+      assert quoted_to_string(ast) == expected
+
+      encoder = &{:ok, {:__block__, &2, [&1]}}
+      ast = Code.string_to_quoted!(input, literal_encoder: encoder)
+      assert quoted_to_string(ast) == expected
+
+      ast = Code.string_to_quoted!(input, token_metadata: true)
+      assert quoted_to_string(ast) == expected
+
+      ast = Code.string_to_quoted!(input, literal_encoder: encoder, token_metadata: true)
+      assert quoted_to_string(ast) == expected
+    end
+
+    test "keyword arg with literal encoder and no metadata" do
+      input = """
+      foo(Bar) do
+        :ok
+      end
+      """
+
+      encoder = &{:ok, {:__block__, &2, [&1]}}
+      ast = Code.string_to_quoted!(input, literal_encoder: encoder)
+      assert quoted_to_string(ast) == "foo(Bar, do: :ok)"
+    end
+
+    test "list in module attribute" do
+      assert quoted_to_string(
+               quote do
+                 @foo []
+               end
+             ) == "@foo []"
+
+      assert quoted_to_string(
+               quote do
+                 @foo [1]
+               end
+             ) == "@foo [1]"
+
+      assert quoted_to_string(
+               quote do
+                 @foo [foo: :bar]
+               end
+             ) == "@foo foo: :bar"
+
+      assert quoted_to_string(
+               quote do
+                 @foo [1, foo: :bar]
+               end
+             ) == "@foo [1, foo: :bar]"
+    end
+  end
+
+  describe "quoted_to_algebra/2 escapes" do
+    test "strings with slash escapes" do
+      assert quoted_to_string(quote(do: "\a\b\d\e\f\n\r\t\v"), escape: false) ==
+               ~s/"\a\b\d\e\f\n\r\t\v"/
+
+      assert quoted_to_string(quote(do: "\a\b\d\e\f\n\r\t\v")) ==
+               ~s/"\\a\\b\\d\\e\\f\\n\\r\\t\\v"/
+
+      assert quoted_to_string({:__block__, [], ["\a\b\d\e\f\n\r\t\v"]}, escape: false) ==
+               ~s/"\a\b\d\e\f\n\r\t\v"/
+
+      assert quoted_to_string({:__block__, [], ["\a\b\d\e\f\n\r\t\v"]}) ==
+               ~s/"\\a\\b\\d\\e\\f\\n\\r\\t\\v"/
+    end
+
+    test "strings with non printable characters" do
+      assert quoted_to_string(quote(do: "\x00\x01\x10"), escape: false) == ~s/"\x00\x01\x10"/
+      assert quoted_to_string(quote(do: "\x00\x01\x10")) == ~S/"\0\x01\x10"/
+    end
+
+    test "charlists with slash escapes" do
+      assert quoted_to_string(~c"\a\b\e\n\r\t\v", escape: false) ==
+               ~s/~c"\a\b\e\n\r\t\v"/
+
+      assert quoted_to_string(~c"\a\b\e\n\r\t\v") ==
+               ~s/~c"\\a\\b\\e\\n\\r\\t\\v"/
+
+      assert quoted_to_string({:__block__, [], [~c"\a\b\e\n\r\t\v"]}, escape: false) ==
+               ~s/~c"\a\b\e\n\r\t\v"/
+
+      assert quoted_to_string({:__block__, [], [~c"\a\b\e\n\r\t\v"]}) ==
+               ~s/~c"\\a\\b\\e\\n\\r\\t\\v"/
+    end
+
+    test "charlists with non printable characters" do
+      assert quoted_to_string(~c"\x00\x01\x10", escape: false) == ~S/[0, 1, 16]/
+      assert quoted_to_string(~c"\x00\x01\x10") == ~S/[0, 1, 16]/
+    end
+
+    test "atoms" do
+      assert quoted_to_string(quote(do: :"a\nb\tc"), escape: false) == ~s/:"a\nb\tc"/
+      assert quoted_to_string(quote(do: :"a\nb\tc")) == ~S/:"a\nb\tc"/
+
+      assert quoted_to_string({:__block__, [], [:"a\nb\tc"]}, escape: false) == ~s/:"a\nb\tc"/
+      assert quoted_to_string({:__block__, [], [:"a\nb\tc"]}) == ~S/:"a\nb\tc"/
+
+      assert quoted_to_string(quote(do: :"Elixir")) == "Elixir"
+      assert quoted_to_string(quote(do: :"Elixir.Foo")) == "Foo"
+      assert quoted_to_string(quote(do: :"Elixir.Foo.Bar")) == "Foo.Bar"
+      assert quoted_to_string(quote(do: :"Elixir.foobar")) == ~S/:"Elixir.foobar"/
+    end
+
+    test "atoms with non printable characters" do
+      assert quoted_to_string(quote(do: :"\x00\x01\x10"), escape: false) == ~s/:"\0\x01\x10"/
+      assert quoted_to_string(quote(do: :"\x00\x01\x10")) == ~S/:"\0\x01\x10"/
+    end
+
+    test "atoms with interpolations" do
+      assert quoted_to_string(quote(do: :"foo\n#{bar}\tbaz"), escape: false) ==
+               ~s[:"foo\n\#{bar}\tbaz"]
+
+      assert quoted_to_string(quote(do: :"foo\n#{bar}\tbaz")) == ~S[:"foo\n#{bar}\tbaz"]
+
+      assert quoted_to_string(quote(do: :"foo\"bar"), escape: false) == ~S[:"foo\"bar"]
+      assert quoted_to_string(quote(do: :"foo\"bar")) == ~S[:"foo\"bar"]
+
+      assert quoted_to_string(quote(do: :"foo#{~s/\n/}bar"), escape: false) ==
+               ~S[:"foo#{~s/\n/}bar"]
+
+      assert quoted_to_string(quote(do: :"foo#{~s/\n/}bar")) == ~S[:"foo#{~s/\n/}bar"]
+
+      assert quoted_to_string(quote(do: :"one\n\"#{2}\"\nthree"), escape: false) ==
+               ~s[:"one\n\\"\#{2}\\"\nthree"]
+
+      assert quoted_to_string(quote(do: :"one\n\"#{2}\"\nthree")) == ~S[:"one\n\"#{2}\"\nthree"]
+    end
+
+    test ":erlang.binary_to_atom/2 edge cases" do
+      assert quoted_to_string(quote(do: :erlang.binary_to_atom(<<>>, :utf8))) == ~S[:""]
+
+      assert quoted_to_string(quote(do: :erlang.binary_to_atom(<<1>>, :utf8))) ==
+               ~S":erlang.binary_to_atom(<<1>>, :utf8)"
+    end
+  end
+
+  describe "quoted_to_algebra/2 with invalid" do
+    test "block" do
+      assert quoted_to_string({:__block__, [], {:bar, [], []}}) ==
+               "{:__block__, [], {:bar, [], []}}"
+
+      assert quoted_to_string({:foo, [], [{:do, :ok}, :not_keyword]}) ==
+               "foo({:do, :ok}, :not_keyword)"
+
+      assert quoted_to_string({:foo, [], [[{:do, :ok}, :not_keyword]]}) ==
+               "foo([{:do, :ok}, :not_keyword])"
+    end
+
+    test "ode" do
+      assert quoted_to_string(1..3) == "1..3"
+    end
+  end
+
+  describe "quoted_to_algebra/2 does not escape" do
+    test "sigils" do
+      assert quoted_to_string(quote(do: ~s/a\nb\tc/), escape: false) == ~S"~s/a\nb\tc/"
+      assert quoted_to_string(quote(do: ~s/a\nb\tc/)) == ~S"~s/a\nb\tc/"
+
+      assert quoted_to_string(quote(do: ~s/\a\b\d\e\f\n\r\t\v/), escape: false) ==
+               ~S"~s/\a\b\d\e\f\n\r\t\v/"
+
+      assert quoted_to_string(quote(do: ~s/\a\b\d\e\f\n\r\t\v/)) == ~S"~s/\a\b\d\e\f\n\r\t\v/"
+
+      assert quoted_to_string(quote(do: ~s/\x00\x01\x10/), escape: false) == ~S"~s/\x00\x01\x10/"
+      assert quoted_to_string(quote(do: ~s/\x00\x01\x10/)) == ~S"~s/\x00\x01\x10/"
+    end
+  end
+
+  defp strip_metadata(ast) do
+    Macro.prewalk(ast, &Macro.update_meta(&1, fn _ -> [] end))
+  end
+
+  defp quoted_to_string(quoted, opts \\ []) do
+    doc = Code.quoted_to_algebra(quoted, opts)
+
+    Inspect.Algebra.format(doc, 98)
+    |> IO.iodata_to_binary()
+  end
+end
diff --git a/lib/elixir/test/elixir/code_test.exs b/lib/elixir/test/elixir/code_test.exs
index 645f784548c..2a71e824dd3 100644
--- a/lib/elixir/test/elixir/code_test.exs
+++ b/lib/elixir/test/elixir/code_test.exs
@@ -1,74 +1,268 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule CodeTest do
   use ExUnit.Case, async: true
+
+  doctest Code
   import PathHelpers
 
-  def one, do: 1
   def genmodule(name) do
     defmodule name do
-      Kernel.LexicalTracker.remotes(__MODULE__)
+      Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
     end
   end
 
-  contents = quote do
-    defmodule CodeTest.Sample do
-      def eval_quoted_info, do: {__MODULE__, __ENV__.file, __ENV__.line}
+  contents =
+    quote do
+      defmodule CodeTest.Sample do
+        def eval_quoted_info, do: {__MODULE__, __ENV__.file, __ENV__.line}
+      end
     end
-  end
 
-  Code.eval_quoted contents, [], file: "sample.ex", line: 13
+  Code.eval_quoted(contents, [], file: "sample.ex", line: 13)
 
-  test :eval_string do
-    assert Code.eval_string("1 + 2") == {3, []}
-    assert {3, _} = Code.eval_string("a + b", [a: 1, b: 2], Macro.Env.location(__ENV__))
-  end
+  describe "with_diagnostics/2" do
+    test "captures warnings" do
+      assert {:warn, [%{message: "hello"}]} =
+               Code.with_diagnostics(fn ->
+                 IO.warn("hello")
+                 :warn
+               end)
+    end
 
-  test :eval_string_with_other_context do
-    assert Code.eval_string("var!(a, Sample) = 1") == {1, [{{:a,Sample},1}]}
-  end
+    test "captures and logs warnings" do
+      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               assert {:warn, [%{message: "hello"}]} =
+                        Code.with_diagnostics([log: true], fn ->
+                          IO.warn("hello")
+                          :warn
+                        end)
+             end) =~ "hello"
+    end
 
-  test :eval_with_unnamed_scopes do
-    assert {%RuntimeError{}, [a: %RuntimeError{}]} =
-           Code.eval_string("a = (try do (raise \"hello\") rescue e -> e end)")
-  end
+    test "can be nested" do
+      assert {:warn, [%{message: "hello"}]} =
+               Code.with_diagnostics(fn ->
+                 IO.warn("hello")
 
-  test :eval_with_scope do
-    assert Code.eval_string("one", [], delegate_locals_to: __MODULE__) == {1, []}
-  end
+                 assert {:nested, [%{message: "world"}]} =
+                          Code.with_diagnostics(fn ->
+                            IO.warn("world")
+                            :nested
+                          end)
 
-  test :eval_options do
-    assert Code.eval_string("is_atom(:foo) and K.is_list([])", [],
-                            functions: [{Kernel, [is_atom: 1]}],
-                            macros: [{Kernel, [..: 2, and: 2]}],
-                            aliases: [{K, Kernel}],
-                            requires: [Kernel]) == {true, []}
-  end
+                 :warn
+               end)
+    end
 
-  test :eval_stacktrace do
-    try do
-      Code.eval_string("<<a :: size(b)>>", a: :a, b: :b)
-    rescue
-      _ ->
-        assert System.stacktrace |> Enum.any?(&(elem(&1, 0) == __MODULE__))
+    test "includes column information on unused variables" do
+      assert {_, [%{position: {1, 12}}]} =
+               Code.with_diagnostics(fn ->
+                 quoted = Code.string_to_quoted!("if true do var = :foo end", columns: true)
+                 Code.eval_quoted(quoted, [])
+               end)
     end
-  end
 
-  test :eval_with_requires do
-    assert Code.eval_string("Kernel.if true, do: :ok", [], requires: [Z, Kernel]) == {:ok, []}
+    test "includes column information on unused aliases" do
+      sample = """
+      defmodule CodeTest.UnusedAlias do
+        alias String.Chars
+      end
+      """
+
+      assert {_, [%{position: {2, 3}}]} =
+               Code.with_diagnostics(fn ->
+                 quoted = Code.string_to_quoted!(sample, columns: true)
+                 Code.eval_quoted(quoted, [])
+               end)
+    end
+
+    test "includes column information on unused imports" do
+      sample = """
+      defmodule CodeTest.UnusedImport do
+        import URI
+      end
+      """
+
+      assert {_, [%{position: {2, 3}}]} =
+               Code.with_diagnostics(fn ->
+                 quoted = Code.string_to_quoted!(sample, columns: true)
+                 Code.eval_quoted(quoted, [])
+               end)
+    end
+
+    test "includes column information on unknown remote function calls" do
+      sample = """
+      defmodule CodeTest.UnknownRemoteCall do
+        def perform do
+          UnknownModule.foo()
+        end
+      end
+      """
+
+      assert {_, [%{position: {3, 19}}]} =
+               Code.with_diagnostics(fn ->
+                 quoted = Code.string_to_quoted!(sample, columns: true)
+                 Code.eval_quoted(quoted, [])
+               end)
+    end
+
+    test "captures unknown local calls" do
+      sample = """
+      defmodule CodeTest.UnknownLocalCall do
+        def perform do
+          foo()
+        end
+      end
+      """
+
+      assert {:rescued, [%{message: message}]} =
+               Code.with_diagnostics(fn ->
+                 try do
+                   quoted = Code.string_to_quoted!(sample, columns: true)
+                   Code.eval_quoted(quoted, [])
+                 rescue
+                   _ -> :rescued
+                 end
+               end)
+
+      assert message =~ "undefined function foo/0"
+    end
   end
 
-  test :eval_quoted do
-    assert Code.eval_quoted(quote(do: 1 + 2)) == {3, []}
-    assert CodeTest.Sample.eval_quoted_info() == {CodeTest.Sample, "sample.ex", 13}
+  describe "eval_string/1,2,3" do
+    test "correctly evaluates a string of code" do
+      assert Code.eval_string("1 + 2") == {3, []}
+      assert Code.eval_string("two = 1 + 1") == {2, [two: 2]}
+    end
+
+    test "keeps bindings on optimized evals" do
+      assert Code.eval_string("import Enum", x: 1) == {Enum, [x: 1]}
+    end
+
+    test "supports a %Macro.Env{} struct as the third argument" do
+      assert {3, _} = Code.eval_string("a + b", [a: 1, b: 2], __ENV__)
+    end
+
+    test "supports unnamed scopes" do
+      assert {%RuntimeError{}, [a: %RuntimeError{}]} =
+               Code.eval_string("a = (try do (raise \"hello\") rescue e -> e end)")
+    end
+
+    test "returns bindings from a different context" do
+      assert Code.eval_string("var!(a, Sample) = 1") == {1, [{{:a, Sample}, 1}]}
+    end
+
+    defmacro hygiene_var do
+      quote do
+        a = 1
+      end
+    end
+
+    test "does not return bindings from macro hygiene" do
+      assert Code.eval_string("require CodeTest; CodeTest.hygiene_var()") == {1, []}
+    end
+
+    test "does not raise on duplicate bindings" do
+      # The order of which values win is not guaranteed, but it should evaluate successfully.
+      assert Code.eval_string("b = String.Chars.to_string(a)", a: 0, a: 1) ==
+               {"1", [{:b, "1"}, {:a, 1}]}
+
+      assert Code.eval_string("b = String.Chars.to_string(a)", a: 0, a: 1, c: 2) ==
+               {"1", [{:c, 2}, {:b, "1"}, {:a, 1}]}
+    end
+
+    test "keeps caller in stacktrace" do
+      try do
+        Code.eval_string("<<a::size(b)>>", [a: :a, b: :b], file: "myfile")
+      rescue
+        _ ->
+          assert Enum.any?(__STACKTRACE__, &(elem(&1, 0) == __MODULE__))
+      end
+    end
+
+    test "includes eval file in stacktrace" do
+      try do
+        Code.eval_string("<<a::size(b)>>", [a: :a, b: :b], file: "myfile")
+      rescue
+        _ ->
+          assert Exception.format_stacktrace(__STACKTRACE__) =~ "myfile:1"
+      end
+
+      try do
+        Code.eval_string(
+          "Enum.map([a: :a, b: :b], fn {a, b} -> <<a::size(b)>> end)",
+          [],
+          file: "myfile"
+        )
+      rescue
+        _ ->
+          assert Exception.format_stacktrace(__STACKTRACE__) =~ "myfile:1"
+      end
+    end
+
+    test "warns when lexical tracker process is dead" do
+      {pid, ref} = spawn_monitor(fn -> :ok end)
+      assert_receive {:DOWN, ^ref, _, _, _}
+      env = %{__ENV__ | lexical_tracker: pid}
+
+      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               assert Code.eval_string("1 + 2", [], env) == {3, []}
+             end) =~ "an __ENV__ with outdated compilation information was given to eval"
+    end
+
+    test "formats diagnostic file paths as relatives" do
+      {_, diagnostics} =
+        Code.with_diagnostics(fn ->
+          try do
+            Code.eval_string("x", [])
+          rescue
+            e -> e
+          end
+        end)
+
+      assert [
+               %{
+                 message: "undefined variable \"x\"",
+                 position: 1,
+                 file: "nofile",
+                 source: "nofile",
+                 stacktrace: [],
+                 severity: :error
+               }
+             ] = diagnostics
+    end
   end
 
-  test :eval_quoted_with_env do
-    alias :lists, as: MyList
-    assert Code.eval_quoted(quote(do: MyList.flatten [[1, 2, 3]]), [], __ENV__) == {[1, 2, 3],[]}
+  describe "eval_quoted/1" do
+    test "evaluates expression" do
+      assert Code.eval_quoted(quote(do: 1 + 2)) == {3, []}
+      assert CodeTest.Sample.eval_quoted_info() == {CodeTest.Sample, "sample.ex", 13}
+    end
+
+    test "with %Macro.Env{} at runtime" do
+      alias :lists, as: MyList
+      quoted = quote(do: MyList.flatten([[1, 2, 3]]))
+
+      assert Code.eval_quoted(quoted, [], __ENV__) == {[1, 2, 3], []}
+
+      # Let's check it discards tracers since the lexical tracker is explicitly nil
+      assert Code.eval_quoted(quoted, [], %{__ENV__ | tracers: [:bad]}) == {[1, 2, 3], []}
+    end
+
+    test "with %Macro.Env{} at compile time" do
+      defmodule CompileTimeEnv do
+        alias String.Chars
+        {"foo", []} = Code.eval_string("Chars.to_string(:foo)", [], __ENV__)
+      end
+    end
   end
 
-  test :eval_file do
+  test "eval_file/1" do
     assert Code.eval_file(fixture_path("code_sample.exs")) == {3, [var: 3]}
 
     assert_raise Code.LoadError, fn ->
@@ -76,94 +270,577 @@ defmodule CodeTest do
     end
   end
 
-  test :require do
-    Code.require_file fixture_path("code_sample.exs")
-    assert fixture_path("code_sample.exs") in Code.loaded_files
+  describe "eval_quoted_with_env/3" do
+    test "returns results, bindings, and env" do
+      alias :lists, as: MyList
+      quoted = quote(do: MyList.flatten([[1, 2, 3]]))
+      env = Code.env_for_eval(__ENV__)
+      assert Code.eval_quoted_with_env(quoted, [], env) == {[1, 2, 3], [], env}
+
+      quoted = quote(do: alias(:dict, as: MyDict))
+      {:dict, [], env} = Code.eval_quoted_with_env(quoted, [], env)
+      assert Keyword.fetch(env.aliases, Elixir.MyDict) == {:ok, :dict}
+    end
+
+    test "manages env vars" do
+      env = Code.env_for_eval(__ENV__)
+      {1, [x: 1], env} = Code.eval_quoted_with_env(quote(do: var!(x) = 1), [], env)
+      assert Macro.Env.vars(env) == [{:x, nil}]
+    end
+
+    test "prunes vars" do
+      env = Code.env_for_eval(__ENV__)
+
+      fun = fn quoted, binding ->
+        {_, binding, env} = Code.eval_quoted_with_env(quoted, binding, env, prune_binding: true)
+        {binding, Macro.Env.vars(env)}
+      end
+
+      assert fun.(quote(do: 123), []) == {[], []}
+      assert fun.(quote(do: 123), x: 2, y: 3) == {[], []}
+
+      assert fun.(quote(do: var!(x) = 1), []) == {[x: 1], [x: nil]}
+      assert fun.(quote(do: var!(x) = 1), x: 2, y: 3) == {[x: 1], [x: nil]}
+
+      assert fun.(quote(do: var!(x, :foo) = 1), []) == {[{{:x, :foo}, 1}], [x: :foo]}
+      assert fun.(quote(do: var!(x, :foo) = 1), x: 2, y: 3) == {[{{:x, :foo}, 1}], [x: :foo]}
+
+      assert fun.(quote(do: var!(x, :foo) = 1), [{{:x, :foo}, 2}, {{:y, :foo}, 3}]) ==
+               {[{{:x, :foo}, 1}], [x: :foo]}
+
+      assert fun.(quote(do: fn -> var!(x, :foo) = 1 end), []) == {[], []}
+      assert fun.(quote(do: fn -> var!(x, :foo) = 1 end), x: 1, y: 2) == {[], []}
+
+      assert fun.(quote(do: fn -> var!(x) end), x: 2, y: 3) == {[x: 2], [x: nil]}
+
+      assert fun.(quote(do: fn -> var!(x, :foo) end), [{{:x, :foo}, 2}, {{:y, :foo}, 3}]) ==
+               {[{{:x, :foo}, 2}], [x: :foo]}
+    end
+
+    test "undefined function" do
+      env = Code.env_for_eval(__ENV__)
+      quoted = quote do: foo()
+
+      assert_exception(
+        UndefinedFunctionError,
+        ["** (UndefinedFunctionError) function foo/0 is undefined (there is no such import)"],
+        fn ->
+          Code.eval_quoted_with_env(quoted, [], env)
+        end
+      )
+    end
+
+    defmodule Tracer do
+      def trace(event, env) do
+        send(self(), {:trace, event, env})
+        :ok
+      end
+    end
+
+    test "with tracing and pruning" do
+      env = %{Code.env_for_eval(__ENV__) | tracers: [Tracer], function: nil}
+      binding = [x: 1, y: 2, z: 3]
+
+      quoted =
+        quote do
+          defmodule Elixir.CodeTest.TracingPruning do
+            var!(y) = :updated
+            var!(y)
+            var!(x)
+          end
+        end
+
+      {_, binding, env} = Code.eval_quoted_with_env(quoted, binding, env, prune_binding: true)
+      assert Enum.sort(binding) == []
+      assert env.versioned_vars == %{}
+
+      assert_receive {:trace, {:on_module, _, _}, %{module: CodeTest.TracingPruning} = trace_env}
+
+      assert trace_env.versioned_vars == %{
+               {:result, :elixir_compiler} => 5,
+               {:x, nil} => 1,
+               {:y, nil} => 4
+             }
+    end
+
+    test "with defguard" do
+      require Integer, warn: false
+      env = Code.env_for_eval(__ENV__)
+      quoted = quote do: Integer.is_even(1)
+      {false, binding, env} = Code.eval_quoted_with_env(quoted, [], env, prune_binding: true)
+      assert binding == []
+      assert Macro.Env.vars(env) == []
+    end
+  end
+
+  describe "compile_file/1" do
+    test "compiles the given path" do
+      assert Code.compile_file(fixture_path("code_sample.exs")) == []
+      refute fixture_path("code_sample.exs") in Code.required_files()
+    end
+  end
+
+  test "require_file/1" do
+    assert Code.require_file(fixture_path("code_sample.exs")) == []
+    assert fixture_path("code_sample.exs") in Code.required_files()
     assert Code.require_file(fixture_path("code_sample.exs")) == nil
 
-    Code.unload_files [fixture_path("code_sample.exs")]
-    refute fixture_path("code_sample.exs") in Code.loaded_files
+    Code.unrequire_files([fixture_path("code_sample.exs")])
+    refute fixture_path("code_sample.exs") in Code.required_files()
     assert Code.require_file(fixture_path("code_sample.exs")) != nil
+  after
+    Code.unrequire_files([fixture_path("code_sample.exs")])
+  end
+
+  test "string_to_quoted!/2 errors take lines/columns/indentation into account" do
+    assert_exception(
+      SyntaxError,
+      ["nofile:1:5:", "syntax error before:", "1 + * 3", "^"],
+      fn ->
+        Code.string_to_quoted!("1 + * 3")
+      end
+    )
+
+    assert_exception(
+      SyntaxError,
+      ["nofile:10:5:", "syntax error before:", "1 + * 3", "^"],
+      fn ->
+        Code.string_to_quoted!("1 + * 3", line: 10)
+      end
+    )
+
+    assert_exception(
+      SyntaxError,
+      ["nofile:10:7:", "syntax error before:", "1 + * 3", "^"],
+      fn ->
+        Code.string_to_quoted!("1 + * 3", line: 10, column: 3)
+      end
+    )
+
+    assert_exception(
+      SyntaxError,
+      ["nofile:11:15:", "syntax error before:", "1 + * 3", "^"],
+      fn ->
+        Code.string_to_quoted!(":ok\n1 + * 3", line: 10, column: 3, indentation: 10)
+      end
+    )
   end
 
-  test :string_to_quoted do
-    assert Code.string_to_quoted("1 + 2")  == {:ok, {:+, [line: 1], [1, 2]}}
-    assert Code.string_to_quoted!("1 + 2") == {:+, [line: 1], [1, 2]}
+  test "string_to_quoted only requires the List.Chars protocol implementation to work" do
+    assert {:ok, 1.23} = Code.string_to_quoted(1.23)
+    assert 1.23 = Code.string_to_quoted!(1.23)
+    assert {:ok, 1.23, []} = Code.string_to_quoted_with_comments(1.23)
+    assert {1.23, []} = Code.string_to_quoted_with_comments!(1.23)
+  end
+
+  test "string_to_quoted returns error on incomplete escaped string" do
+    assert {:error, {meta, "missing terminator: \" (for string starting at line 1)", ""}} =
+             Code.string_to_quoted("\"\\")
+
+    assert meta[:line] == 1
+    assert meta[:column] == 1
+    assert meta[:end_line] == 1
+    assert meta[:end_column] == 3
+  end
+
+  test "string_to_quoted with comments" do
+    assert Code.string_to_quoted_with_comments("""
+           # top
+           [
+             # before
+
+             # right-before
+             expr, # middle
+             # right-after
+
+             # after
+           ]
+           # bottom
+           """) ==
+             {
+               :ok,
+               [{:expr, [line: 6], nil}],
+               [
+                 %{
+                   column: 1,
+                   line: 1,
+                   next_eol_count: 1,
+                   previous_eol_count: 1,
+                   text: "# top"
+                 },
+                 %{
+                   column: 3,
+                   line: 3,
+                   next_eol_count: 2,
+                   previous_eol_count: 1,
+                   text: "# before"
+                 },
+                 %{
+                   column: 3,
+                   line: 5,
+                   next_eol_count: 1,
+                   previous_eol_count: 2,
+                   text: "# right-before"
+                 },
+                 %{
+                   column: 9,
+                   line: 6,
+                   next_eol_count: 1,
+                   previous_eol_count: 0,
+                   text: "# middle"
+                 },
+                 %{
+                   column: 3,
+                   line: 7,
+                   next_eol_count: 2,
+                   previous_eol_count: 1,
+                   text: "# right-after"
+                 },
+                 %{
+                   column: 3,
+                   line: 9,
+                   next_eol_count: 1,
+                   previous_eol_count: 2,
+                   text: "# after"
+                 },
+                 %{
+                   column: 1,
+                   line: 11,
+                   next_eol_count: 1,
+                   previous_eol_count: 1,
+                   text: "# bottom"
+                 }
+               ]
+             }
+  end
+
+  test "string_to_quoted handles unescape errors properly" do
+    # Test invalid hex escape character
+    assert {:error, {meta, message, token}} = Code.string_to_quoted("a.'\\xg'")
+
+    assert meta[:line] == 1
+    assert meta[:column] == 3
 
-    assert Code.string_to_quoted("a.1") ==
-           {:error, {1, "syntax error before: ", "1"}}
+    assert message ==
+             "invalid hex escape character, expected \\xHH where H is a hexadecimal digit. Syntax error after: "
 
-    assert_raise SyntaxError, fn ->
-      Code.string_to_quoted!("a.1")
+    assert token == "\\x"
+
+    # Test invalid Unicode escape character
+    assert {:error, {meta2, message2, token2}} = Code.string_to_quoted("a.'\\ug'")
+
+    assert meta2[:line] == 1
+    assert meta2[:column] == 3
+
+    assert message2 ==
+             "invalid Unicode escape character, expected \\uHHHH or \\u{H*} where H is a hexadecimal digit. Syntax error after: "
+
+    assert token2 == "\\u"
+
+    # Test invalid Unicode code point (surrogate pair)
+    assert {:error, {meta3, message3, token3}} = Code.string_to_quoted("a.'\\u{D800}'")
+
+    assert meta3[:line] == 1
+    assert meta3[:column] == 3
+
+    assert message3 == "invalid or reserved Unicode code point \\u{D800}. Syntax error after: "
+    assert token3 == "\\u"
+
+    # Test Unicode code point beyond valid range
+    assert {:error, {meta4, message4, token4}} = Code.string_to_quoted("a.'\\u{110000}'")
+
+    assert meta4[:line] == 1
+    assert meta4[:column] == 3
+
+    assert message4 == "invalid or reserved Unicode code point \\u{110000}. Syntax error after: "
+    assert token4 == "\\u"
+  end
+
+  test "string_to_quoted returns error for invalid UTF-8 in strings" do
+    invalid_utf8_cases = [
+      # charlist
+      "'\\xFF'",
+      # charlist heredoc
+      "'''\n\\xFF\\\n'''"
+    ]
+
+    for code <- invalid_utf8_cases do
+      assert {:error, {_, message, _}} = Code.string_to_quoted(code)
+      assert message =~ "invalid encoding starting at <<255>>"
+    end
+  end
+
+  test "string_to_quoted returns error for invalid UTF-8 in quoted atoms and function calls" do
+    invalid_utf8_cases = [
+      # charlist
+      # ~S{'\xFF'},
+      # charlist heredoc
+      # ~s{'''\n\xFF\n'''},
+      # Quoted atom
+      ~S{:"\xFF"},
+      ~S{:'\xFF'},
+      # Quoted keyword identifier
+      ~S{["\xFF": 1]},
+      ~S{['\xFF': 1]},
+      # Quoted function call
+      ~S{foo."\xFF"()},
+      ~S{foo.'\xFF'()}
+    ]
+
+    for code <- invalid_utf8_cases do
+      assert {:error, {_, message, detail}} = Code.string_to_quoted(code)
+      assert message =~ "invalid encoding in atom: "
+      assert detail =~ "invalid encoding starting at <<255>>"
+
+      assert {:error, {_, message, detail}} =
+               Code.string_to_quoted(code, existing_atoms_only: true)
+
+      assert message =~ "invalid encoding in atom: "
+      assert detail =~ "invalid encoding starting at <<255>>"
     end
   end
 
-  test :string_to_quoted_existing_atoms_only do
-    assert :badarg = catch_error(Code.string_to_quoted!(":thereisnosuchatom", existing_atoms_only: true))
+  @tag :requires_source
+  test "compile source" do
+    assert __MODULE__.__info__(:compile)[:source] == String.to_charlist(__ENV__.file)
   end
 
-  test :string_to_quoted! do
-    assert Code.string_to_quoted!("1 + 2") == {:+, [line: 1], [1, 2]}
+  describe "compile_string/1" do
+    test "compiles the given string" do
+      assert [{CompileStringSample, _}] =
+               Code.compile_string("defmodule CompileStringSample, do: :ok")
+    after
+      :code.purge(CompileSimpleSample)
+      :code.delete(CompileSimpleSample)
+    end
 
-    assert_raise SyntaxError, fn ->
-      Code.string_to_quoted!("a.1")
+    test "works across lexical scopes" do
+      assert [{CompileCrossSample, _}] =
+               Code.compile_string("CodeTest.genmodule CompileCrossSample")
+    after
+      :code.purge(CompileCrossSample)
+      :code.delete(CompileCrossSample)
     end
 
-    assert_raise TokenMissingError, fn ->
-      Code.string_to_quoted!("1 +")
+    test "disables tail call optimization at the root" do
+      try do
+        Code.compile_string("List.flatten(123)")
+      rescue
+        _ -> assert Enum.any?(__STACKTRACE__, &match?({_, :__FILE__, 1, _}, &1))
+      end
     end
   end
 
-  test :compile_source do
-    assert __MODULE__.__info__(:compile)[:source] == String.to_char_list(__ENV__.file)
+  test "format_string/2 returns empty iodata for empty string" do
+    assert Code.format_string!("") == ""
   end
 
-  test :compile_info_returned_with_source_accessible_through_keyword_module do
-    compile = __MODULE__.__info__(:compile)
-    assert Keyword.get(compile, :source) != nil
+  test "ensure_loaded?/1" do
+    assert Code.ensure_loaded?(__MODULE__)
+    refute Code.ensure_loaded?(Code.NoFile)
   end
 
-  test :compile_string_works_accross_lexical_scopes do
-    assert [{CompileCrossSample, _}] = Code.compile_string("CodeTest.genmodule CompileCrossSample")
-  after
-    :code.purge CompileCrossSample
-    :code.delete CompileCrossSample
+  test "ensure_loaded!/1" do
+    assert Code.ensure_loaded!(__MODULE__) == __MODULE__
+
+    assert_raise ArgumentError, "could not load module Code.NoFile due to reason :nofile", fn ->
+      Code.ensure_loaded!(Code.NoFile)
+    end
   end
 
-  test :compile_string do
-    assert [{CompileStringSample, _}] = Code.compile_string("defmodule CompileStringSample, do: :ok")
-  after
-    :code.purge CompileSimpleSample
-    :code.delete CompileSimpleSample
+  test "ensure_all_loaded/1" do
+    assert Code.ensure_all_loaded([__MODULE__]) == :ok
+    assert Code.ensure_all_loaded([__MODULE__, Kernel]) == :ok
+
+    assert {:error, [error]} = Code.ensure_all_loaded([__MODULE__, Code.NoFile, __MODULE__])
+    assert error == {Code.NoFile, :nofile}
   end
 
-  test :compile_quoted do
-    assert [{CompileQuotedSample, _}] = Code.compile_string("defmodule CompileQuotedSample, do: :ok")
-  after
-    :code.purge CompileQuotedSample
-    :code.delete CompileQuotedSample
+  test "ensure_all_loaded!/1" do
+    assert Code.ensure_all_loaded!([__MODULE__]) == :ok
+    assert Code.ensure_all_loaded!([__MODULE__, Kernel]) == :ok
+
+    message = """
+    could not load the following modules:
+
+      * Code.NoFile due to reason :nofile
+      * Code.OtherNoFile due to reason :nofile\
+    """
+
+    assert_raise ArgumentError, message, fn ->
+      Code.ensure_all_loaded!([__MODULE__, Code.NoFile, Code.OtherNoFile])
+    end
   end
 
-  test :ensure_loaded? do
-    assert Code.ensure_loaded?(__MODULE__)
-    refute Code.ensure_loaded?(Unknown.Module)
+  test "ensure_compiled/1" do
+    assert Code.ensure_compiled(__MODULE__) == {:module, __MODULE__}
+    assert Code.ensure_compiled(Code.NoFile) == {:error, :nofile}
+  end
+
+  test "ensure_compiled!/1" do
+    assert Code.ensure_compiled!(__MODULE__) == __MODULE__
+
+    assert_raise ArgumentError, "could not load module Code.NoFile due to reason :nofile", fn ->
+      Code.ensure_compiled!(Code.NoFile)
+    end
+  end
+
+  test "put_compiler_option/2 validates options" do
+    message = "unknown compiler option: :not_a_valid_option"
+
+    assert_raise RuntimeError, message, fn ->
+      Code.put_compiler_option(:not_a_valid_option, :foo)
+    end
+
+    message = "compiler option :debug_info should be a boolean, got: :not_a_boolean"
+
+    assert_raise RuntimeError, message, fn ->
+      Code.put_compiler_option(:debug_info, :not_a_boolean)
+    end
+  end
+
+  describe "fetch_docs/1" do
+    test "is case sensitive" do
+      assert {:docs_v1, _, :elixir, _, %{"en" => module_doc}, _, _} = Code.fetch_docs(IO)
+
+      assert "Functions handling input/output (IO)." =
+               module_doc |> String.split("\n") |> Enum.at(0)
+
+      assert Code.fetch_docs(Io) == {:error, :module_not_found}
+    end
   end
 
-  test :ensure_compiled? do
-    assert Code.ensure_compiled?(__MODULE__)
-    refute Code.ensure_compiled?(Unknown.Module)
+  defp assert_exception(ex, messages, callback) do
+    e =
+      assert_raise ex, fn ->
+        callback.()
+      end
+
+    error_msg = Exception.format(:error, e, [])
+
+    for msg <- messages do
+      assert error_msg =~ msg
+    end
   end
 end
 
 defmodule Code.SyncTest do
   use ExUnit.Case
 
-  test :path_manipulation do
+  import PathHelpers
+
+  if System.otp_release() >= "26" do
+    defp assert_cached(path) do
+      assert find_path(path) != :nocache
+    end
+
+    defp refute_cached(path) do
+      assert find_path(path) == :nocache
+    end
+
+    defp find_path(path) do
+      {:status, _, {:module, :code_server}, [_, :running, _, _, state]} =
+        :sys.get_status(:code_server)
+
+      [:state, _, _otp_root, paths | _] = Tuple.to_list(state)
+      {_, value} = List.keyfind(paths, to_charlist(path), 0)
+      value
+    end
+  else
+    defp assert_cached(_path), do: :ok
+    defp refute_cached(_path), do: :ok
+  end
+
+  test "prepend_path" do
+    path = Path.join(__DIR__, "fixtures")
+    true = Code.prepend_path(path)
+    assert to_charlist(path) in :code.get_path()
+    refute_cached(path)
+
+    true = Code.prepend_path(path, cache: true)
+    assert_cached(path)
+
+    Code.delete_path(path)
+    refute to_charlist(path) in :code.get_path()
+  end
+
+  test "append_path" do
+    path = Path.join(__DIR__, "fixtures")
+    true = Code.append_path(path)
+    assert to_charlist(path) in :code.get_path()
+    refute_cached(path)
+
+    true = Code.append_path(path, cache: true)
+    assert_cached(path)
+
+    Code.delete_path(path)
+    refute to_charlist(path) in :code.get_path()
+  end
+
+  test "prepend_paths" do
+    path = Path.join(__DIR__, "fixtures")
+    :ok = Code.prepend_paths([path])
+    assert to_charlist(path) in :code.get_path()
+    refute_cached(path)
+
+    :ok = Code.prepend_paths([path], cache: true)
+    assert_cached(path)
+
+    Code.delete_paths([path])
+    refute to_charlist(path) in :code.get_path()
+  end
+
+  test "append_paths" do
     path = Path.join(__DIR__, "fixtures")
-    Code.prepend_path path
-    assert to_char_list(path) in :code.get_path
+    :ok = Code.append_paths([path])
+    assert to_charlist(path) in :code.get_path()
+    refute_cached(path)
+
+    :ok = Code.append_paths([path], cache: true)
+    assert_cached(path)
+
+    Code.delete_paths([path])
+    refute to_charlist(path) in :code.get_path()
+  end
+
+  test "purges compiler modules" do
+    quoted = quote(do: :ok)
+    Code.compile_quoted(quoted)
+
+    {:ok, claimed} = Code.purge_compiler_modules()
+    assert claimed > 0
 
-    Code.delete_path path
-    refute to_char_list(path) in :code.get_path
+    {:ok, claimed} = Code.purge_compiler_modules()
+    assert claimed == 0
+
+    quoted = quote(do: Agent.start_link(fn -> :ok end))
+    Code.compile_quoted(quoted)
+
+    {:ok, claimed} = Code.purge_compiler_modules()
+    assert claimed == 0
+  end
+
+  test "returns previous options when setting compiler options" do
+    Code.compiler_options(debug_info: false)
+    assert Code.compiler_options(debug_info: true) == %{debug_info: false}
+  after
+    Code.compiler_options(debug_info: true)
+  end
+
+  test "compile_file/1 return value" do
+    assert [{CompileSample, binary}] = Code.compile_file(fixture_path("compile_sample.ex"))
+    assert is_binary(binary)
+  after
+    :code.purge(CompileSample)
+    :code.delete(CompileSample)
+  end
+
+  test "require_file/1 return value" do
+    assert [{CompileSample, binary}] = Code.require_file(fixture_path("compile_sample.ex"))
+    assert is_binary(binary)
+  after
+    Code.unrequire_files([fixture_path("compile_sample.ex")])
+    :code.purge(CompileSample)
+    :code.delete(CompileSample)
   end
 end
diff --git a/lib/elixir/test/elixir/collectable_test.exs b/lib/elixir/test/elixir/collectable_test.exs
new file mode 100644
index 00000000000..edd0fd0c250
--- /dev/null
+++ b/lib/elixir/test/elixir/collectable_test.exs
@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule CollectableTest do
+  use ExUnit.Case, async: true
+
+  doctest Collectable
+end
diff --git a/lib/elixir/test/elixir/config/provider_test.exs b/lib/elixir/test/elixir/config/provider_test.exs
new file mode 100644
index 00000000000..9ab0ca12f35
--- /dev/null
+++ b/lib/elixir/test/elixir/config/provider_test.exs
@@ -0,0 +1,202 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Config.ProviderTest do
+  use ExUnit.Case
+
+  doctest Config.Provider
+  alias Config.Provider
+  import PathHelpers
+  import ExUnit.CaptureIO
+
+  @tmp_path tmp_path("config_provider")
+  @env_var "ELIXIR_CONFIG_PROVIDER_BOOTED"
+  @sys_config Path.join(@tmp_path, "sys.config")
+
+  setup context do
+    File.rm_rf(@tmp_path)
+    File.mkdir_p!(@tmp_path)
+    write_sys_config!(context[:sys_config] || [])
+
+    on_exit(fn ->
+      Application.delete_env(:elixir, :config_provider_init)
+      Application.delete_env(:elixir, :config_provider_booted)
+      System.delete_env(@env_var)
+    end)
+  end
+
+  test "validate_compile_env" do
+    assert Config.Provider.validate_compile_env([{:elixir, [:unknown], :error}]) == :ok
+
+    Application.put_env(:elixir, :unknown, nested: [key: :value])
+
+    assert Config.Provider.validate_compile_env([
+             {:elixir, [:unknown], {:ok, [nested: [key: :value]]}}
+           ]) == :ok
+
+    assert Config.Provider.validate_compile_env([
+             {:elixir, [:unknown, :nested], {:ok, [key: :value]}}
+           ]) == :ok
+
+    assert Config.Provider.validate_compile_env([
+             {:elixir, [:unknown, :nested, :key], {:ok, :value}}
+           ]) == :ok
+
+    assert Config.Provider.validate_compile_env([
+             {:elixir, [:unknown, :nested, :unknown], :error}
+           ]) == :ok
+
+    assert {:error, msg} =
+             Config.Provider.validate_compile_env([{:elixir, [:unknown, :nested], :error}])
+
+    assert msg =~ "Compile time value was not set"
+
+    assert {:error, msg} =
+             Config.Provider.validate_compile_env([
+               {:elixir, [:unknown, :nested], {:ok, :another}}
+             ])
+
+    assert msg =~ "Compile time value was set to: :another"
+
+    keys = [:unknown, :nested, :key, :too_deep]
+
+    assert {:error, msg} =
+             Config.Provider.validate_compile_env([{:elixir, keys, :error}])
+
+    assert msg =~
+             "application :elixir failed reading its compile environment for path [:nested, :key, :too_deep] inside key :unknown"
+  after
+    Application.delete_env(:elixir, :unknown)
+  end
+
+  describe "config_path" do
+    test "validate!" do
+      assert Provider.validate_config_path!("/foo") == :ok
+      assert Provider.validate_config_path!({:system, "foo", "bar"}) == :ok
+
+      assert_raise ArgumentError, fn -> Provider.validate_config_path!({:system, 1, 2}) end
+      assert_raise ArgumentError, fn -> Provider.validate_config_path!(~c"baz") end
+    end
+
+    test "resolve!" do
+      env_var = "ELIXIR_CONFIG_PROVIDER_PATH"
+
+      try do
+        System.put_env(env_var, @tmp_path)
+        assert Provider.resolve_config_path!("/foo") == "/foo"
+        assert Provider.resolve_config_path!({:system, env_var, "/bar"}) == @tmp_path <> "/bar"
+      after
+        System.delete_env(env_var)
+      end
+    end
+  end
+
+  describe "boot" do
+    test "runs providers" do
+      init_and_assert_boot()
+      config = consult(@sys_config)
+      assert config[:my_app] == [key: :value]
+      assert config[:elixir] == [config_provider_booted: {:booted, nil}]
+    end
+
+    @tag sys_config: [my_app: [encoding: {:_μ, :"£", "£", ~c"£"}]]
+    test "writes sys_config with encoding" do
+      init_and_assert_boot()
+      config = consult(@sys_config)
+      assert config[:my_app][:encoding] == {:_μ, :"£", "£", ~c"£"}
+    end
+
+    @tag sys_config: [my_app: [key: :old_value, sys_key: :sys_value, extra_config: :old_value]]
+    test "writes extra config with overrides" do
+      init_and_assert_boot(extra_config: [my_app: [key: :old_extra_value, extra_config: :value]])
+
+      assert consult(@sys_config)[:my_app] ==
+               [sys_key: :sys_value, extra_config: :value, key: :value]
+    end
+
+    test "returns :booted if already booted and keeps config file" do
+      init_and_assert_boot()
+      Application.put_all_env(Keyword.take(consult(@sys_config), [:elixir]))
+      assert boot() == :booted
+      refute_received :restart
+      assert File.exists?(@sys_config)
+    end
+
+    test "returns :booted if already booted and prunes config file" do
+      init_and_assert_boot(prune_runtime_sys_config_after_boot: true)
+      Application.put_all_env(Keyword.take(consult(@sys_config), [:elixir]))
+      assert boot() == :booted
+      refute_received :restart
+      refute File.exists?(@sys_config)
+    end
+
+    test "returns :booted if already booted and runs validate_compile_env" do
+      init_and_assert_boot(
+        prune_runtime_sys_config_after_boot: true,
+        validate_compile_env: [{:elixir, [:unknown], {:ok, :value}}]
+      )
+
+      Application.put_all_env(Keyword.take(consult(@sys_config), [:elixir]))
+
+      assert capture_abort(fn -> boot() end) =~
+               "the application :elixir has a different value set for key :unknown"
+    end
+
+    test "returns without rebooting" do
+      reader = {Config.Reader, fixture_path("configs/kernel.exs")}
+      init = Config.Provider.init([reader], @sys_config, reboot_system_after_config: false)
+      Application.put_all_env(init)
+
+      assert capture_abort(fn ->
+               Provider.boot(fn ->
+                 raise "should not be called"
+               end)
+             end) =~
+               "Cannot configure :kernel because :reboot_system_after_config has been set to false"
+
+      # Make sure values before and after match
+      write_sys_config!(kernel: [elixir_reboot: true])
+      Application.put_all_env(init)
+      System.delete_env(@env_var)
+
+      Provider.boot(fn -> raise "should not be called" end)
+      assert Application.get_env(:kernel, :elixir_reboot) == true
+      assert Application.get_env(:elixir_reboot, :key) == :value
+    end
+  end
+
+  defp init(opts) do
+    reader = {Config.Reader, fixture_path("configs/good_config.exs")}
+    init = Config.Provider.init([reader], Keyword.get(opts, :path, @sys_config), opts)
+    Application.put_all_env(init)
+    init
+  end
+
+  defp boot do
+    Provider.boot(fn -> send(self(), :restart) end)
+  end
+
+  defp init_and_assert_boot(opts \\ []) do
+    init(opts ++ [reboot_system_after_config: true])
+    boot()
+    assert_received :restart
+  end
+
+  defp consult(file) do
+    {:ok, [config]} = :file.consult(file)
+    config
+  end
+
+  defp capture_abort(fun) do
+    capture_io(fn ->
+      assert_raise ErlangError, fun
+    end)
+  end
+
+  defp write_sys_config!(data) do
+    File.write!(@sys_config, IO.chardata_to_string(:io_lib.format("~tw.~n", [data])))
+  end
+end
diff --git a/lib/elixir/test/elixir/config/reader_test.exs b/lib/elixir/test/elixir/config/reader_test.exs
new file mode 100644
index 00000000000..4d9b36616f7
--- /dev/null
+++ b/lib/elixir/test/elixir/config/reader_test.exs
@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Config.ReaderTest do
+  use ExUnit.Case, async: true
+
+  doctest Config.Reader
+  import PathHelpers
+
+  test "read_imports!/2" do
+    assert Config.Reader.read_imports!(fixture_path("configs/good_kw.exs")) ==
+             {[my_app: [key: :value]], [fixture_path("configs/good_kw.exs")]}
+
+    assert Config.Reader.read_imports!(fixture_path("configs/good_config.exs")) ==
+             {[my_app: [key: :value]], [fixture_path("configs/good_config.exs")]}
+
+    assert Config.Reader.read_imports!(fixture_path("configs/good_import.exs")) ==
+             {[my_app: [key: :value]],
+              [fixture_path("configs/good_config.exs"), fixture_path("configs/good_import.exs")]}
+
+    assert_raise ArgumentError,
+                 ":imports must be a list of paths",
+                 fn -> Config.Reader.read_imports!("config", imports: :disabled) end
+
+    assert_raise File.Error,
+                 fn -> Config.Reader.read_imports!(fixture_path("configs/bad_root.exs")) end
+
+    assert_raise File.Error,
+                 fn -> Config.Reader.read_imports!(fixture_path("configs/bad_import.exs")) end
+  end
+
+  test "read!/2" do
+    assert Config.Reader.read!(fixture_path("configs/good_kw.exs")) ==
+             [my_app: [key: :value]]
+
+    assert Config.Reader.read!(fixture_path("configs/good_config.exs")) ==
+             [my_app: [key: :value]]
+
+    assert Config.Reader.read!(fixture_path("configs/good_import.exs")) ==
+             [my_app: [key: :value]]
+
+    assert Config.Reader.read!(fixture_path("configs/env.exs"), env: :dev, target: :host) ==
+             [my_app: [env: :dev, target: :host]]
+
+    assert Config.Reader.read!(fixture_path("configs/env.exs"), env: :prod, target: :embedded) ==
+             [my_app: [env: :prod, target: :embedded]]
+
+    assert_raise ArgumentError,
+                 ~r"expected config for app :sample in .*/bad_app.exs to return keyword list",
+                 fn -> Config.Reader.read!(fixture_path("configs/bad_app.exs")) end
+
+    assert_raise RuntimeError, "no :env key was given to this configuration file", fn ->
+      Config.Reader.read!(fixture_path("configs/env.exs"))
+    end
+
+    assert_raise RuntimeError, "no :target key was given to this configuration file", fn ->
+      Config.Reader.read!(fixture_path("configs/env.exs"), env: :prod)
+    end
+
+    assert_raise RuntimeError,
+                 ~r"import_config/1 is not enabled for this configuration file",
+                 fn ->
+                   Config.Reader.read!(fixture_path("configs/good_import.exs"),
+                     imports: :disabled
+                   )
+                 end
+  end
+
+  test "eval!/3" do
+    files = ["configs/good_kw.exs", "configs/good_config.exs", "configs/good_import.exs"]
+
+    for file <- files do
+      file = fixture_path(file)
+      assert Config.Reader.read!(file) == Config.Reader.eval!(file, File.read!(file))
+    end
+
+    file = fixture_path("configs/env.exs")
+
+    assert Config.Reader.read!(file, env: :dev, target: :host) ==
+             Config.Reader.eval!(file, File.read!(file), env: :dev, target: :host)
+  end
+
+  test "as a provider" do
+    state = Config.Reader.init(fixture_path("configs/good_config.exs"))
+    assert Config.Reader.load([my_app: [key: :old_value]], state) == [my_app: [key: :value]]
+
+    state = Config.Reader.init(path: fixture_path("configs/env.exs"), env: :prod, target: :host)
+
+    assert Config.Reader.load([my_app: [env: :dev]], state) ==
+             [my_app: [env: :prod, target: :host]]
+  end
+end
diff --git a/lib/elixir/test/elixir/config_test.exs b/lib/elixir/test/elixir/config_test.exs
new file mode 100644
index 00000000000..29488e092b7
--- /dev/null
+++ b/lib/elixir/test/elixir/config_test.exs
@@ -0,0 +1,133 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule ConfigTest do
+  use ExUnit.Case, async: true
+
+  doctest Config
+  import Config
+  import PathHelpers
+
+  setup config do
+    Process.put({Config, :opts}, {config[:env], config[:target]})
+    Process.put({Config, :config}, [])
+    Process.put({Config, :imports}, config[:imports] || [])
+    :ok
+  end
+
+  defp config do
+    Process.get({Config, :config})
+  end
+
+  defp files do
+    Process.get({Config, :imports})
+  end
+
+  test "config/2" do
+    assert config() == []
+
+    config :lager, key: :value
+    assert config() == [lager: [key: :value]]
+
+    config :lager, other: :value
+    assert config() == [lager: [key: :value, other: :value]]
+
+    config :lager, key: :other
+    assert config() == [lager: [other: :value, key: :other]]
+
+    # Works inside functions too...
+    f = fn -> config(:lager, key: :fn) end
+    f.()
+    assert config() == [lager: [other: :value, key: :fn]]
+
+    # ...and in for comprehensions.
+    for _ <- 0..0, do: config(:lager, key: :for)
+    assert config() == [lager: [other: :value, key: :for]]
+  end
+
+  test "config/3" do
+    config :app, Repo, key: :value
+    assert config() == [app: [{Repo, key: :value}]]
+
+    config :app, Repo, other: :value
+    assert config() == [app: [{Repo, key: :value, other: :value}]]
+
+    config :app, Repo, key: :other
+    assert config() == [app: [{Repo, other: :value, key: :other}]]
+
+    config :app, Repo, key: [nested: false]
+    assert config() == [app: [{Repo, other: :value, key: [nested: false]}]]
+
+    config :app, Repo, key: [nested: true]
+    assert config() == [app: [{Repo, other: :value, key: [nested: true]}]]
+
+    config :app, Repo, key: :other
+    assert config() == [app: [{Repo, other: :value, key: :other}]]
+  end
+
+  test "read_config/1" do
+    assert read_config(:lager) == nil
+
+    config :lager, key: :value
+    assert read_config(:lager) == [key: :value]
+
+    config :lager, other: :value
+    assert read_config(:lager) == [key: :value, other: :value]
+  end
+
+  @tag env: :dev
+  test "config_env/0" do
+    assert config_env() == :dev
+  end
+
+  test "config_env/0 raises if no env is set" do
+    assert_raise RuntimeError, "no :env key was given to this configuration file", fn ->
+      config_env()
+    end
+  end
+
+  @tag target: :host
+  test "config_target/0" do
+    assert config_target() == :host
+  end
+
+  test "config_target/0 raises if no env is set" do
+    assert_raise RuntimeError, "no :target key was given to this configuration file", fn ->
+      config_target()
+    end
+  end
+
+  test "import_config/1" do
+    import_config fixture_path("configs/good_config.exs")
+    assert config() == [my_app: [key: :value]]
+    assert files() == [fixture_path("configs/good_config.exs")]
+  end
+
+  @tag imports: :disabled
+  test "import_config/1 raises when disabled" do
+    assert_raise RuntimeError,
+                 ~r"import_config/1 is not enabled for this configuration file",
+                 fn -> import_config fixture_path("configs/good_config.exs") end
+  end
+
+  test "import_config/1 raises for recursive import" do
+    assert_raise ArgumentError,
+                 ~r"attempting to load configuration .*/imports_recursive.exs recursively",
+                 fn -> import_config fixture_path("configs/imports_recursive.exs") end
+  end
+
+  test "import_config/1 with nested" do
+    config :app, Repo, key: [nested: false, other: true]
+    import_config fixture_path("configs/nested.exs")
+    assert config() == [app: [{Repo, key: [other: true, nested: true]}]]
+  end
+
+  test "import_config/1 with bad path" do
+    assert_raise File.Error, ~r"could not read file .*/configs/unknown.exs", fn ->
+      import_config fixture_path("configs/unknown.exs")
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/dict_test.exs b/lib/elixir/test/elixir/dict_test.exs
deleted file mode 100644
index 31e15b447c0..00000000000
--- a/lib/elixir/test/elixir/dict_test.exs
+++ /dev/null
@@ -1,415 +0,0 @@
-Code.require_file "test_helper.exs", __DIR__
-
-# A TestDict implementation used only for testing.
-defmodule TestDict do
-  defstruct list: []
-
-  def new(list \\ []) when is_list(list) do
-    %TestDict{list: list}
-  end
-
-  def size(%TestDict{list: list}) do
-    length(list)
-  end
-
-  def update(%TestDict{list: list} = map, key, initial, fun) do
-    %{map | list: update(list, key, initial, fun)}
-  end
-
-  def update([{key, value}|list], key, _initial, fun) do
-    [{key, fun.(value)}|list]
-  end
-
-  def update([{_, _} = e|list], key, initial, fun) do
-    [e|update(list, key, initial, fun)]
-  end
-
-  def update([], key, initial, _fun) do
-    [{key, initial}]
-  end
-
-  defimpl Enumerable do
-    def reduce(%{list: list}, acc, fun), do: Enumerable.List.reduce(list, acc, fun)
-    def member?(%{list: list}, other), do: Enumerable.List.member(list, other)
-    def count(%{list: list}), do: Enumerable.List.count(list)
-  end
-end
-
-defmodule DictTest.Common do
-  defmacro __using__(_) do
-    quote location: :keep do
-      import Enum, only: [sort: 1]
-
-      defp new_dict(list \\ [{"first_key", 1}, {"second_key", 2}]) do
-        Enum.into list, dict_impl.new
-      end
-
-      defp new_dict(list, transform) do
-        Enum.into list, dict_impl.new, transform
-      end
-
-      defp int_dict do
-        Enum.into [{1,1}], dict_impl.new
-      end
-
-      test "access" do
-        dict = new_dict()
-        assert dict["first_key"] == 1
-        assert dict["other_key"] == nil
-      end
-
-      test "access uses match operation" do
-        dict = int_dict()
-        assert dict[1] == 1
-        assert dict[1.0] == nil
-      end
-
-      test "get/2 and get/3" do
-        dict = new_dict()
-        assert Dict.get(dict, "first_key")    == 1
-        assert Dict.get(dict, "second_key")   == 2
-        assert Dict.get(dict, "other_key")    == nil
-        assert Dict.get(dict, "other_key", 3) == 3
-      end
-
-      test "get/2 with match" do
-        assert Dict.get(int_dict, 1) == 1
-        assert Dict.get(int_dict, 1.0) == nil
-      end
-
-      test "fetch/2" do
-        dict = new_dict()
-        assert Dict.fetch(dict, "first_key")  == {:ok, 1}
-        assert Dict.fetch(dict, "second_key") == {:ok, 2}
-        assert Dict.fetch(dict, "other_key")  == :error
-      end
-
-      test "fetch/2 with match" do
-        assert Dict.fetch(int_dict, 1)   == {:ok, 1}
-        assert Dict.fetch(int_dict, 1.0) == :error
-      end
-
-      test "fetch!/2" do
-        dict = new_dict()
-        assert Dict.fetch!(dict, "first_key") == 1
-        assert Dict.fetch!(dict, "second_key") == 2
-        assert_raise KeyError, fn ->
-          Dict.fetch!(dict, "other_key")
-        end
-      end
-
-      test "put/3" do
-        dict = new_dict() |> Dict.put("first_key", {1})
-        assert Dict.get(dict, "first_key")  == {1}
-        assert Dict.get(dict, "second_key") == 2
-      end
-
-      test "put/3 with_match" do
-        dict = int_dict()
-        assert Dict.get(Dict.put(dict, 1, :other), 1)     == :other
-        assert Dict.get(Dict.put(dict, 1.0, :other), 1)   == 1
-        assert Dict.get(Dict.put(dict, 1, :other), 1.0)   == nil
-        assert Dict.get(Dict.put(dict, 1.0, :other), 1.0) == :other
-      end
-
-      test "put_new/3" do
-        dict = Dict.put_new(new_dict(), "first_key", {1})
-        assert Dict.get(dict, "first_key") == 1
-      end
-
-      test "put_new/3 with_match" do
-        assert Dict.get(Dict.put_new(int_dict, 1, :other), 1)     == 1
-        assert Dict.get(Dict.put_new(int_dict, 1.0, :other), 1)   == 1
-        assert Dict.get(Dict.put_new(int_dict, 1, :other), 1.0)   == nil
-        assert Dict.get(Dict.put_new(int_dict, 1.0, :other), 1.0) == :other
-      end
-
-      test "keys/1" do
-        assert Enum.sort(Dict.keys(new_dict())) == ["first_key", "second_key"]
-        assert Dict.keys(new_dict([])) == []
-      end
-
-      test "values/1" do
-        assert Enum.sort(Dict.values(new_dict())) == [1, 2]
-        assert Dict.values(new_dict([])) == []
-      end
-
-      test "delete/2" do
-        dict = Dict.delete(new_dict(), "second_key")
-        assert Dict.size(dict) == 1
-        assert Dict.has_key?(dict, "first_key")
-        refute Dict.has_key?(dict, "second_key")
-
-        dict = Dict.delete(new_dict(), "other_key")
-        assert dict == new_dict()
-        assert Dict.size(dict) == 2
-      end
-
-      test "delete/2 with match" do
-        assert Dict.get(Dict.delete(int_dict, 1), 1) == nil
-        assert Dict.get(Dict.delete(int_dict, 1.0), 1) == 1
-      end
-
-      test "merge/2" do
-        dict = new_dict()
-        assert Dict.merge(new_dict([]), dict) == dict
-        assert Dict.merge(dict, new_dict([])) == dict
-        assert Dict.merge(dict, dict)         == dict
-        assert Dict.merge(new_dict([]), new_dict([])) == new_dict([])
-
-        dict1 = new_dict [{"a", 1}, {"b", 2}, {"c", 3}]
-        dict2 = new_dict [{"a", 3}, {"c", :a}, {"d", 0}]
-        assert Dict.merge(dict1, dict2) |> Enum.sort ==
-               [{"a", 3}, {"b", 2}, {"c", :a}, {"d", 0}]
-      end
-
-      test "merge/2 with other dict" do
-        dict1 = new_dict [{"a", 1}, {"b", 2}, {"c", 3}]
-        dict2 = TestDict.new [{"a",3}, {"c",:a}, {"d",0}]
-        actual = Dict.merge(dict1, dict2)
-        assert Dict.merge(dict1, dict2) |> Enum.sort ==
-               [{"a", 3}, {"b", 2}, {"c", :a}, {"d", 0}]
-        assert Dict.merge(dict2, dict1) |> Enum.sort ==
-               [{"a", 1}, {"b", 2}, {"c", 3}, {"d", 0}]
-      end
-
-      test "merge/3" do
-        dict1 = new_dict [{"a", 1}, {"b", 2}]
-        dict2 = new_dict [{"a", 3}, {"d", 4}]
-        actual = Dict.merge dict1, dict2, fn _k, v1, v2 -> v1 + v2 end
-        assert Enum.sort(actual) == [{"a", 4}, {"b", 2}, {"d", 4}]
-      end
-
-      test "has_key?/2" do
-        dict = new_dict()
-        assert Dict.has_key?(dict, "first_key")
-        refute Dict.has_key?(dict, "other_key")
-      end
-
-      test "has_key?/2 with match" do
-        assert Dict.has_key?(int_dict, 1)
-        refute Dict.has_key?(int_dict, 1.0)
-      end
-
-      test "size/1" do
-        assert Dict.size(new_dict()) == 2
-        assert Dict.size(new_dict([])) == 0
-      end
-
-      test "update!/3" do
-        dict = Dict.update!(new_dict(), "first_key", fn val -> -val end)
-        assert Dict.get(dict, "first_key") == -1
-
-        assert_raise KeyError, fn ->
-          Dict.update!(new_dict(), "non-existent", fn val -> -val end)
-        end
-      end
-
-      test "update!/3 with match" do
-        assert Dict.get(Dict.update!(int_dict(), 1, &(&1 + 1)), 1) == 2
-      end
-
-      test "update/4" do
-        dict = Dict.update(new_dict(), "first_key", 0, fn val -> -val end)
-        assert Dict.get(dict, "first_key") == -1
-
-        dict = Dict.update(new_dict(), "non-existent", "...", fn val -> -val end)
-        assert Dict.get(dict, "non-existent") == "..."
-      end
-
-      test "update/4 with match" do
-        dict = int_dict()
-        assert Dict.get(Dict.update(dict, 1.0, 2, &(&1 + 1)), 1) == 1
-        assert Dict.get(Dict.update(dict, 1.0, 2, &(&1 + 1)), 1.0) == 2
-      end
-
-      test "pop/2 and pop/3" do
-        dict = new_dict()
-
-        {v, actual} = Dict.pop(dict, "first_key")
-        assert v == 1
-        assert actual == new_dict([{"second_key", 2}])
-
-        {v, actual} = Dict.pop(dict, "other_key")
-        assert v == nil
-        assert dict == actual
-
-        {v, actual} = Dict.pop(dict, "other_key", "default")
-        assert v == "default"
-        assert dict == actual
-      end
-
-      test "pop/2 and pop/3 with match" do
-        dict = int_dict()
-
-        {v, actual} = Dict.pop(dict, 1)
-        assert v == 1
-        assert Enum.sort(actual) == []
-
-        {v, actual} = Dict.pop(dict, 1.0)
-        assert v == nil
-        assert actual == dict
-      end
-
-      test "split/2" do
-        dict = new_dict()
-
-        {take, drop} = Dict.split(dict, [])
-        assert take == new_dict([])
-        assert drop == dict
-
-        {take, drop} = Dict.split(dict, ["unknown_key"])
-        assert take == new_dict([])
-        assert drop == dict
-
-        split_keys   = ["first_key", "second_key", "unknown_key"]
-        {take, drop} = Dict.split(dict, split_keys)
-
-        take_expected = new_dict([])
-                        |> Dict.put("first_key", 1)
-                        |> Dict.put("second_key", 2)
-
-        drop_expected = new_dict([])
-                        |> Dict.delete("first_key")
-                        |> Dict.delete("second_key")
-
-        assert Enum.sort(take) == Enum.sort(take_expected)
-        assert Enum.sort(drop) == Enum.sort(drop_expected)
-      end
-
-      test "split/2 with match" do
-        dict = int_dict()
-        {take, drop} = Dict.split(dict, [1])
-        assert take == dict
-        assert drop == new_dict([])
-
-        {take, drop} = Dict.split(dict, [1.0])
-        assert take == new_dict([])
-        assert drop == dict
-      end
-
-      test "split/2 with enum" do
-        dict = int_dict()
-        {take, drop} = Dict.split(dict, 1..3)
-        assert take == dict
-        assert drop == new_dict([])
-      end
-
-      test "take/2" do
-        dict = new_dict()
-        take = Dict.take(dict, ["unknown_key"])
-        assert take == new_dict([])
-
-        take = Dict.take(dict, ["first_key"])
-        assert take == new_dict([{"first_key", 1}])
-      end
-
-      test "take/2 with match" do
-        dict = int_dict()
-        assert Dict.take(dict, [1])   == dict
-        assert Dict.take(dict, [1.0]) == new_dict([])
-      end
-
-      test "take/2 with enum" do
-        dict = int_dict()
-        assert Dict.take(dict, 1..3) == dict
-      end
-
-      test "drop/2" do
-        dict = new_dict()
-        drop = Dict.drop(dict, ["unknown_key"])
-        assert drop == dict
-
-        drop = Dict.drop(dict, ["first_key"])
-        assert drop == new_dict([{"second_key", 2}])
-      end
-
-      test "drop/2 with match" do
-        dict = int_dict()
-        assert Dict.drop(dict, [1]) == new_dict([])
-        assert Dict.drop(dict, [1.0]) == dict
-      end
-
-      test "drop/2 with enum" do
-        dict = int_dict()
-        assert Dict.drop(dict, 1..3) == new_dict([])
-      end
-
-      test "equal?/2" do
-        dict1 = new_dict(a: 2, b: 3, f: 5, c: 123)
-        dict2 = new_dict(a: 2, b: 3, f: 5, c: 123)
-        assert dict_impl.equal?(dict1, dict2)
-        assert Dict.equal?(dict1, dict2)
-
-        dict2 = Dict.put(dict2, :a, 3)
-        refute dict_impl.equal?(dict1, dict2)
-        refute Dict.equal?(dict1, dict2)
-
-        dict3 = [a: 2, b: 3, f: 5, c: 123, z: 666]
-        refute Dict.equal?(dict1, dict3)
-        refute Dict.equal?(dict3, dict1)
-      end
-
-      test "equal?/2 with match" do
-        dict1 = new_dict([{1,1}])
-        dict2 = new_dict([{1.0,1}])
-        assert Dict.equal?(dict1, dict1)
-        refute Dict.equal?(dict1, dict2)
-      end
-
-      test "equal?/2 with other dict" do
-        dict = new_dict([{1,1}])
-        assert Dict.equal?(dict, TestDict.new([{1,1}]))
-        refute Dict.equal?(dict, TestDict.new([{1.0,1}]))
-      end
-
-      test "is enumerable" do
-        dict = new_dict()
-        assert Enum.empty?(new_dict([]))
-        refute Enum.empty?(dict)
-        assert Enum.member?(dict, {"first_key", 1})
-        refute Enum.member?(dict, {"first_key", 2})
-        assert Enum.count(dict) == 2
-        assert Enum.reduce(dict, 0, fn({k, v}, acc) -> v + acc end) == 3
-      end
-
-      test "is collectable" do
-        dict = new_dict()
-        assert Dict.size(dict) == 2
-        assert Enum.sort(dict) == [{"first_key", 1}, {"second_key", 2}]
-
-        dict = new_dict([{1}, {2}, {3}], fn {x} -> {<<x + 64>>, x} end)
-        assert Dict.size(dict) == 3
-        assert Enum.sort(dict) == [{"A", 1}, {"B", 2}, {"C", 3}]
-
-        assert Collectable.empty(new_dict) == new_dict([])
-      end
-
-      test "is zippable" do
-        dict = new_dict()
-        list = Dict.to_list(dict)
-        assert Enum.zip(list, list) == Enum.zip(dict, dict)
-
-        dict = new_dict(1..120, fn i -> {i, i} end)
-        list = Dict.to_list(dict)
-        assert Enum.zip(list, list) == Enum.zip(dict, dict)
-      end
-    end
-  end
-end
-
-defmodule Dict.HashDictTest do
-  use ExUnit.Case, async: true
-  use DictTest.Common
-
-  doctest Dict
-  defp dict_impl, do: HashDict
-end
-
-defmodule Dict.MapDictTest do
-  use ExUnit.Case, async: true
-  use DictTest.Common
-
-  doctest Dict
-  defp dict_impl, do: Map
-end
diff --git a/lib/elixir/test/elixir/dynamic_supervisor_test.exs b/lib/elixir/test/elixir/dynamic_supervisor_test.exs
new file mode 100644
index 00000000000..ea6e1a16c8b
--- /dev/null
+++ b/lib/elixir/test/elixir/dynamic_supervisor_test.exs
@@ -0,0 +1,774 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule DynamicSupervisorTest do
+  use ExUnit.Case, async: true
+
+  defmodule Simple do
+    use DynamicSupervisor
+
+    def init(args), do: args
+  end
+
+  test "can be supervised directly" do
+    children = [{DynamicSupervisor, name: :dyn_sup_spec_test}]
+    assert {:ok, _} = Supervisor.start_link(children, strategy: :one_for_one)
+    assert DynamicSupervisor.which_children(:dyn_sup_spec_test) == []
+  end
+
+  test "multiple supervisors can be supervised and identified with simple child spec" do
+    {:ok, _} = Registry.start_link(keys: :unique, name: DynSup.Registry)
+
+    children = [
+      {DynamicSupervisor, name: :simple_name},
+      {DynamicSupervisor, name: {:global, :global_name}},
+      {DynamicSupervisor, name: {:via, Registry, {DynSup.Registry, "via_name"}}}
+    ]
+
+    assert {:ok, supsup} = Supervisor.start_link(children, strategy: :one_for_one)
+
+    assert {:ok, no_name_dynsup} =
+             Supervisor.start_child(supsup, {DynamicSupervisor, strategy: :one_for_one})
+
+    assert DynamicSupervisor.which_children(:simple_name) == []
+    assert DynamicSupervisor.which_children({:global, :global_name}) == []
+    assert DynamicSupervisor.which_children({:via, Registry, {DynSup.Registry, "via_name"}}) == []
+    assert DynamicSupervisor.which_children(no_name_dynsup) == []
+
+    assert Supervisor.start_child(supsup, {DynamicSupervisor, strategy: :one_for_one}) ==
+             {:error, {:already_started, no_name_dynsup}}
+  end
+
+  describe "use/2" do
+    test "generates child_spec/1" do
+      assert Simple.child_spec([:hello]) == %{
+               id: Simple,
+               start: {Simple, :start_link, [[:hello]]},
+               type: :supervisor
+             }
+
+      defmodule Custom do
+        use DynamicSupervisor,
+          id: :id,
+          restart: :temporary,
+          shutdown: :infinity,
+          start: {:foo, :bar, []}
+
+        def init(arg), do: {:producer, arg}
+      end
+
+      assert Custom.child_spec([:hello]) == %{
+               id: :id,
+               restart: :temporary,
+               shutdown: :infinity,
+               start: {:foo, :bar, []},
+               type: :supervisor
+             }
+    end
+  end
+
+  describe "init/1" do
+    test "set default options" do
+      assert DynamicSupervisor.init([]) ==
+               {:ok,
+                %{
+                  strategy: :one_for_one,
+                  intensity: 3,
+                  period: 5,
+                  max_children: :infinity,
+                  extra_arguments: []
+                }}
+    end
+  end
+
+  describe "start_link/3" do
+    test "with non-ok init" do
+      Process.flag(:trap_exit, true)
+
+      assert DynamicSupervisor.start_link(Simple, {:ok, %{strategy: :unknown}}) ==
+               {:error, {:supervisor_data, {:invalid_strategy, :unknown}}}
+
+      assert DynamicSupervisor.start_link(Simple, {:ok, %{intensity: -1}}) ==
+               {:error, {:supervisor_data, {:invalid_intensity, -1}}}
+
+      assert DynamicSupervisor.start_link(Simple, {:ok, %{period: 0}}) ==
+               {:error, {:supervisor_data, {:invalid_period, 0}}}
+
+      assert DynamicSupervisor.start_link(Simple, {:ok, %{max_children: -1}}) ==
+               {:error, {:supervisor_data, {:invalid_max_children, -1}}}
+
+      assert DynamicSupervisor.start_link(Simple, {:ok, %{extra_arguments: -1}}) ==
+               {:error, {:supervisor_data, {:invalid_extra_arguments, -1}}}
+
+      assert DynamicSupervisor.start_link(Simple, {:ok, %{auto_shutdown: :any_significant}}) ==
+               {:error, {:supervisor_data, {:invalid_auto_shutdown, :any_significant}}}
+
+      assert DynamicSupervisor.start_link(Simple, :unknown) ==
+               {:error, {:bad_return, {Simple, :init, :unknown}}}
+
+      assert DynamicSupervisor.start_link(Simple, :ignore) == :ignore
+    end
+
+    test "with registered process" do
+      {:ok, pid} = DynamicSupervisor.start_link(Simple, {:ok, %{}}, name: __MODULE__)
+
+      # Sets up a link
+      {:links, links} = Process.info(self(), :links)
+      assert pid in links
+
+      # A name
+      assert Process.whereis(__MODULE__) == pid
+
+      # And the initial call
+      assert {:supervisor, DynamicSupervisorTest.Simple, 1} =
+               :proc_lib.translate_initial_call(pid)
+
+      # And shuts down
+      assert DynamicSupervisor.stop(__MODULE__) == :ok
+    end
+
+    test "with spawn_opt" do
+      {:ok, pid} =
+        DynamicSupervisor.start_link(strategy: :one_for_one, spawn_opt: [priority: :high])
+
+      assert Process.info(pid, :priority) == {:priority, :high}
+    end
+
+    test "sets initial call to the same as a regular supervisor" do
+      {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)
+      assert :proc_lib.initial_call(pid) == {:supervisor, Supervisor.Default, [:Argument__1]}
+
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+      assert :proc_lib.initial_call(pid) == {:supervisor, Supervisor.Default, [:Argument__1]}
+    end
+  end
+
+  ## Code change
+
+  describe "code_change/3" do
+    test "with non-ok init" do
+      {:ok, pid} = DynamicSupervisor.start_link(Simple, {:ok, %{}})
+
+      assert fake_upgrade(pid, {:ok, %{strategy: :unknown}}) ==
+               {:error, {:error, {:supervisor_data, {:invalid_strategy, :unknown}}}}
+
+      assert fake_upgrade(pid, {:ok, %{intensity: -1}}) ==
+               {:error, {:error, {:supervisor_data, {:invalid_intensity, -1}}}}
+
+      assert fake_upgrade(pid, {:ok, %{period: 0}}) ==
+               {:error, {:error, {:supervisor_data, {:invalid_period, 0}}}}
+
+      assert fake_upgrade(pid, {:ok, %{max_children: -1}}) ==
+               {:error, {:error, {:supervisor_data, {:invalid_max_children, -1}}}}
+
+      assert fake_upgrade(pid, :unknown) == {:error, :unknown}
+      assert fake_upgrade(pid, :ignore) == :ok
+    end
+
+    test "with ok init" do
+      {:ok, pid} = DynamicSupervisor.start_link(Simple, {:ok, %{}})
+      {:ok, _} = DynamicSupervisor.start_child(pid, sleepy_worker())
+      assert %{active: 1} = DynamicSupervisor.count_children(pid)
+
+      assert fake_upgrade(pid, {:ok, %{max_children: 1}}) == :ok
+      assert %{active: 1} = DynamicSupervisor.count_children(pid)
+      assert DynamicSupervisor.start_child(pid, {Task, fn -> :ok end}) == {:error, :max_children}
+    end
+
+    defp fake_upgrade(pid, init_arg) do
+      :ok = :sys.suspend(pid)
+      :sys.replace_state(pid, fn state -> %{state | args: init_arg} end)
+      res = :sys.change_code(pid, :gen_server, 123, :extra)
+      :ok = :sys.resume(pid)
+      res
+    end
+  end
+
+  describe "start_child/2" do
+    test "supports old child spec" do
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+      child = {Task, {Task, :start_link, [fn -> :ok end]}, :temporary, 5000, :worker, [Task]}
+      assert {:ok, pid} = DynamicSupervisor.start_child(pid, child)
+      assert is_pid(pid)
+    end
+
+    test "supports new child spec as tuple" do
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+      child = %{id: Task, restart: :temporary, start: {Task, :start_link, [fn -> :ok end]}}
+      assert {:ok, pid} = DynamicSupervisor.start_child(pid, child)
+      assert is_pid(pid)
+    end
+
+    test "supports new child spec" do
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+      child = {Task, fn -> Process.sleep(:infinity) end}
+      assert {:ok, pid} = DynamicSupervisor.start_child(pid, child)
+      assert is_pid(pid)
+    end
+
+    test "supports extra arguments" do
+      parent = self()
+      fun = fn -> send(parent, :from_child) end
+
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, extra_arguments: [fun])
+      child = %{id: Task, restart: :temporary, start: {Task, :start_link, []}}
+      assert {:ok, pid} = DynamicSupervisor.start_child(pid, child)
+      assert is_pid(pid)
+      assert_receive :from_child
+    end
+
+    test "with invalid child spec" do
+      assert DynamicSupervisor.start_child(:not_used, %{}) == {:error, {:invalid_child_spec, %{}}}
+
+      assert DynamicSupervisor.start_child(:not_used, {1, 2, 3, 4, 5, 6}) ==
+               {:error, {:invalid_mfa, 2}}
+
+      assert DynamicSupervisor.start_child(:not_used, %{id: 1, start: {Task, :foo, :bar}}) ==
+               {:error, {:invalid_mfa, {Task, :foo, :bar}}}
+
+      assert DynamicSupervisor.start_child(:not_used, %{
+               id: 1,
+               start: {Task, :foo, [:bar]},
+               shutdown: -1
+             }) ==
+               {:error, {:invalid_shutdown, -1}}
+
+      assert DynamicSupervisor.start_child(:not_used, %{
+               id: 1,
+               start: {Task, :foo, [:bar]},
+               significant: true
+             }) ==
+               {:error, {:invalid_significant, true}}
+    end
+
+    test "with different returns" do
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      assert {:ok, _, :extra} = DynamicSupervisor.start_child(pid, current_module_worker([:ok3]))
+      assert {:ok, _} = DynamicSupervisor.start_child(pid, current_module_worker([:ok2]))
+      assert :ignore = DynamicSupervisor.start_child(pid, current_module_worker([:ignore]))
+
+      assert {:error, :found} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:error]))
+
+      assert {:error, :unknown} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:unknown]))
+    end
+
+    test "with throw/error/exit" do
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      assert {:error, {{:nocatch, :oops}, [_ | _]}} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:non_local, :throw]))
+
+      assert {:error, {%RuntimeError{}, [_ | _]}} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:non_local, :error]))
+
+      assert {:error, :oops} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:non_local, :exit]))
+    end
+
+    test "with max_children" do
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_children: 0)
+
+      assert {:error, :max_children} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:ok2]))
+    end
+
+    test "temporary child is not restarted regardless of reason" do
+      child = current_module_worker([:ok2], restart: :temporary)
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, :shutdown)
+      assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(pid)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, :whatever)
+      assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(pid)
+    end
+
+    test "transient child is restarted unless normal/shutdown/{shutdown, _}" do
+      child = current_module_worker([:ok2], restart: :transient)
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, :shutdown)
+      assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(pid)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, {:shutdown, :signal})
+      assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(pid)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, :whatever)
+      assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(pid)
+    end
+
+    test "permanent child is restarted regardless of reason" do
+      child = current_module_worker([:ok2], restart: :permanent)
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 100_000)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, :shutdown)
+      assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(pid)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, {:shutdown, :signal})
+      assert %{workers: 2, active: 2} = DynamicSupervisor.count_children(pid)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, :whatever)
+      assert %{workers: 3, active: 3} = DynamicSupervisor.count_children(pid)
+    end
+
+    test "child is restarted with different values" do
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 100_000)
+
+      assert {:ok, child1} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:restart, :ok2]))
+
+      assert [{:undefined, ^child1, :worker, [DynamicSupervisorTest]}] =
+               DynamicSupervisor.which_children(pid)
+
+      assert_kill(child1, :shutdown)
+      assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(pid)
+
+      assert {:ok, child2} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:restart, :ok3]))
+
+      assert [
+               {:undefined, _, :worker, [DynamicSupervisorTest]},
+               {:undefined, ^child2, :worker, [DynamicSupervisorTest]}
+             ] = DynamicSupervisor.which_children(pid)
+
+      assert_kill(child2, :shutdown)
+      assert %{workers: 2, active: 2} = DynamicSupervisor.count_children(pid)
+
+      assert {:ok, child3} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:restart, :ignore]))
+
+      assert [
+               {:undefined, _, :worker, [DynamicSupervisorTest]},
+               {:undefined, _, :worker, [DynamicSupervisorTest]},
+               {:undefined, _, :worker, [DynamicSupervisorTest]}
+             ] = DynamicSupervisor.which_children(pid)
+
+      assert_kill(child3, :shutdown)
+      assert %{workers: 2, active: 2} = DynamicSupervisor.count_children(pid)
+
+      assert {:ok, child4} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:restart, :error]))
+
+      assert [
+               {:undefined, _, :worker, [DynamicSupervisorTest]},
+               {:undefined, _, :worker, [DynamicSupervisorTest]},
+               {:undefined, _, :worker, [DynamicSupervisorTest]}
+             ] = DynamicSupervisor.which_children(pid)
+
+      assert_kill(child4, :shutdown)
+      assert %{workers: 3, active: 2} = DynamicSupervisor.count_children(pid)
+
+      assert {:ok, child5} =
+               DynamicSupervisor.start_child(pid, current_module_worker([:restart, :unknown]))
+
+      assert [
+               {:undefined, _, :worker, [DynamicSupervisorTest]},
+               {:undefined, _, :worker, [DynamicSupervisorTest]},
+               {:undefined, :restarting, :worker, [DynamicSupervisorTest]},
+               {:undefined, _, :worker, [DynamicSupervisorTest]}
+             ] = DynamicSupervisor.which_children(pid)
+
+      assert_kill(child5, :shutdown)
+      assert %{workers: 4, active: 2} = DynamicSupervisor.count_children(pid)
+    end
+
+    test "restarting on init children counted in max_children" do
+      child = current_module_worker([:restart, :error], restart: :permanent)
+      opts = [strategy: :one_for_one, max_children: 1, max_restarts: 100_000]
+      {:ok, pid} = DynamicSupervisor.start_link(opts)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, :shutdown)
+      assert %{workers: 1, active: 0} = DynamicSupervisor.count_children(pid)
+
+      child = current_module_worker([:restart, :ok2], restart: :permanent)
+      assert {:error, :max_children} = DynamicSupervisor.start_child(pid, child)
+    end
+
+    test "restarting on exit children counted in max_children" do
+      child = current_module_worker([:ok2], restart: :permanent)
+      opts = [strategy: :one_for_one, max_children: 1, max_restarts: 100_000]
+      {:ok, pid} = DynamicSupervisor.start_link(opts)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, :shutdown)
+      assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(pid)
+
+      child = current_module_worker([:ok2], restart: :permanent)
+      assert {:error, :max_children} = DynamicSupervisor.start_child(pid, child)
+    end
+
+    test "restarting a child with extra_arguments successfully restarts child" do
+      parent = self()
+
+      fun = fn ->
+        send(parent, :from_child)
+        Process.sleep(:infinity)
+      end
+
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one, extra_arguments: [fun])
+      child = %{id: Task, restart: :transient, start: {Task, :start_link, []}}
+
+      assert {:ok, child} = DynamicSupervisor.start_child(sup, child)
+      assert is_pid(child)
+      assert_receive :from_child
+      assert %{active: 1, workers: 1} = DynamicSupervisor.count_children(sup)
+      assert_kill(child, :oops)
+      assert_receive :from_child
+      assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(sup)
+    end
+
+    test "child is restarted when trying again" do
+      child = current_module_worker([:try_again, self()], restart: :permanent)
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 2)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_received {:try_again, true}
+      assert_kill(child_pid, :shutdown)
+      assert_receive {:try_again, false}
+      assert_receive {:try_again, true}
+      assert %{workers: 1, active: 1} = DynamicSupervisor.count_children(pid)
+    end
+
+    test "child triggers maximum restarts" do
+      Process.flag(:trap_exit, true)
+      child = current_module_worker([:restart, :error], restart: :permanent)
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 1)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, :shutdown)
+      assert_receive {:EXIT, ^pid, :shutdown}
+    end
+
+    test "child triggers maximum intensity when trying again" do
+      Process.flag(:trap_exit, true)
+      child = current_module_worker([:restart, :error], restart: :permanent)
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 10)
+
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(pid, child)
+      assert_kill(child_pid, :shutdown)
+      assert_receive {:EXIT, ^pid, :shutdown}
+    end
+
+    test "with valid shutdown" do
+      Process.flag(:trap_exit, true)
+
+      {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      for n <- 0..1 do
+        assert {:ok, child_pid} =
+                 DynamicSupervisor.start_child(pid, %{
+                   id: n,
+                   start: {Task, :start_link, [fn -> Process.sleep(:infinity) end]},
+                   shutdown: n
+                 })
+
+        assert_kill(child_pid, :shutdown)
+      end
+    end
+
+    test "with invalid valid shutdown" do
+      assert DynamicSupervisor.start_child(:not_used, %{
+               id: 1,
+               start: {Task, :start_link, [fn -> :ok end]},
+               shutdown: -1
+             }) == {:error, {:invalid_shutdown, -1}}
+    end
+
+    def start_link(:ok3), do: {:ok, spawn_link(fn -> Process.sleep(:infinity) end), :extra}
+    def start_link(:ok2), do: {:ok, spawn_link(fn -> Process.sleep(:infinity) end)}
+    def start_link(:error), do: {:error, :found}
+    def start_link(:ignore), do: :ignore
+    def start_link(:unknown), do: :unknown
+
+    def start_link(:non_local, :throw), do: throw(:oops)
+    def start_link(:non_local, :error), do: raise("oops")
+    def start_link(:non_local, :exit), do: exit(:oops)
+
+    def start_link(:try_again, notify) do
+      if Process.get(:try_again) do
+        Process.put(:try_again, false)
+        send(notify, {:try_again, false})
+        {:error, :try_again}
+      else
+        Process.put(:try_again, true)
+        send(notify, {:try_again, true})
+        start_link(:ok2)
+      end
+    end
+
+    def start_link(:restart, value) do
+      if Process.get({:restart, value}) do
+        start_link(value)
+      else
+        Process.put({:restart, value}, true)
+        start_link(:ok2)
+      end
+    end
+  end
+
+  describe "terminate/2" do
+    test "terminates children with brutal kill" do
+      Process.flag(:trap_exit, true)
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      child = sleepy_worker(shutdown: :brutal_kill)
+      assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)
+
+      Process.monitor(child1)
+      Process.monitor(child2)
+      Process.monitor(child3)
+      assert_kill(sup, :shutdown)
+      assert_receive {:DOWN, _, :process, ^child1, :killed}
+      assert_receive {:DOWN, _, :process, ^child2, :killed}
+      assert_receive {:DOWN, _, :process, ^child3, :killed}
+    end
+
+    test "terminates children with infinity shutdown" do
+      Process.flag(:trap_exit, true)
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      child = sleepy_worker(shutdown: :infinity)
+      assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)
+
+      Process.monitor(child1)
+      Process.monitor(child2)
+      Process.monitor(child3)
+      assert_kill(sup, :shutdown)
+      assert_receive {:DOWN, _, :process, ^child1, :shutdown}
+      assert_receive {:DOWN, _, :process, ^child2, :shutdown}
+      assert_receive {:DOWN, _, :process, ^child3, :shutdown}
+    end
+
+    test "terminates children with infinity shutdown and abnormal reason" do
+      Process.flag(:trap_exit, true)
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+      parent = self()
+
+      fun = fn ->
+        Process.flag(:trap_exit, true)
+        send(parent, :ready)
+        receive(do: (_ -> exit({:shutdown, :oops})))
+      end
+
+      child = Supervisor.child_spec({Task, fun}, shutdown: :infinity)
+      assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)
+
+      assert_receive :ready
+      assert_receive :ready
+      assert_receive :ready
+
+      Process.monitor(child1)
+      Process.monitor(child2)
+      Process.monitor(child3)
+      assert_kill(sup, :shutdown)
+
+      assert_receive {:DOWN, _, :process, ^child1, {:shutdown, :oops}}
+      assert_receive {:DOWN, _, :process, ^child2, {:shutdown, :oops}}
+      assert_receive {:DOWN, _, :process, ^child3, {:shutdown, :oops}}
+    end
+
+    test "terminates children with integer shutdown" do
+      Process.flag(:trap_exit, true)
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      child = sleepy_worker(shutdown: 1000)
+      assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)
+
+      Process.monitor(child1)
+      Process.monitor(child2)
+      Process.monitor(child3)
+      assert_kill(sup, :shutdown)
+      assert_receive {:DOWN, _, :process, ^child1, :shutdown}
+      assert_receive {:DOWN, _, :process, ^child2, :shutdown}
+      assert_receive {:DOWN, _, :process, ^child3, :shutdown}
+    end
+
+    test "terminates children with integer shutdown and abnormal reason" do
+      Process.flag(:trap_exit, true)
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+      parent = self()
+
+      fun = fn ->
+        Process.flag(:trap_exit, true)
+        send(parent, :ready)
+        receive(do: (_ -> exit({:shutdown, :oops})))
+      end
+
+      child = Supervisor.child_spec({Task, fun}, shutdown: 1000)
+      assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)
+
+      assert_receive :ready
+      assert_receive :ready
+      assert_receive :ready
+
+      Process.monitor(child1)
+      Process.monitor(child2)
+      Process.monitor(child3)
+      assert_kill(sup, :shutdown)
+
+      assert_receive {:DOWN, _, :process, ^child1, {:shutdown, :oops}}
+      assert_receive {:DOWN, _, :process, ^child2, {:shutdown, :oops}}
+      assert_receive {:DOWN, _, :process, ^child3, {:shutdown, :oops}}
+    end
+
+    test "terminates children with expired integer shutdown" do
+      Process.flag(:trap_exit, true)
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+      parent = self()
+
+      fun = fn ->
+        Process.sleep(:infinity)
+      end
+
+      tmt = fn ->
+        Process.flag(:trap_exit, true)
+        send(parent, :ready)
+        Process.sleep(:infinity)
+      end
+
+      child_fun = Supervisor.child_spec({Task, fun}, shutdown: 1)
+      child_tmt = Supervisor.child_spec({Task, tmt}, shutdown: 1)
+      assert {:ok, child1} = DynamicSupervisor.start_child(sup, child_fun)
+      assert {:ok, child2} = DynamicSupervisor.start_child(sup, child_tmt)
+      assert {:ok, child3} = DynamicSupervisor.start_child(sup, child_fun)
+
+      assert_receive :ready
+      Process.monitor(child1)
+      Process.monitor(child2)
+      Process.monitor(child3)
+      assert_kill(sup, :shutdown)
+
+      assert_receive {:DOWN, _, :process, ^child1, :shutdown}
+      assert_receive {:DOWN, _, :process, ^child2, :killed}
+      assert_receive {:DOWN, _, :process, ^child3, :shutdown}
+    end
+
+    test "terminates children with permanent restart and normal reason" do
+      Process.flag(:trap_exit, true)
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+      parent = self()
+
+      fun = fn ->
+        Process.flag(:trap_exit, true)
+        send(parent, :ready)
+        receive(do: (_ -> exit(:normal)))
+      end
+
+      child = Supervisor.child_spec({Task, fun}, shutdown: :infinity, restart: :permanent)
+      assert {:ok, child1} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child2} = DynamicSupervisor.start_child(sup, child)
+      assert {:ok, child3} = DynamicSupervisor.start_child(sup, child)
+
+      assert_receive :ready
+      assert_receive :ready
+      assert_receive :ready
+
+      Process.monitor(child1)
+      Process.monitor(child2)
+      Process.monitor(child3)
+      assert_kill(sup, :shutdown)
+      assert_receive {:DOWN, _, :process, ^child1, :normal}
+      assert_receive {:DOWN, _, :process, ^child2, :normal}
+      assert_receive {:DOWN, _, :process, ^child3, :normal}
+    end
+
+    test "terminates with mixed children" do
+      Process.flag(:trap_exit, true)
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      assert {:ok, child1} =
+               DynamicSupervisor.start_child(sup, sleepy_worker(shutdown: :infinity))
+
+      assert {:ok, child2} =
+               DynamicSupervisor.start_child(sup, sleepy_worker(shutdown: :brutal_kill))
+
+      Process.monitor(child1)
+      Process.monitor(child2)
+      assert_kill(sup, :shutdown)
+      assert_receive {:DOWN, _, :process, ^child1, :shutdown}
+      assert_receive {:DOWN, _, :process, ^child2, :killed}
+    end
+  end
+
+  describe "terminate_child/2" do
+    test "terminates child with brutal kill" do
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      child = sleepy_worker(shutdown: :brutal_kill)
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(sup, child)
+
+      Process.monitor(child_pid)
+      assert :ok = DynamicSupervisor.terminate_child(sup, child_pid)
+      assert_receive {:DOWN, _, :process, ^child_pid, :killed}
+
+      assert {:error, :not_found} = DynamicSupervisor.terminate_child(sup, child_pid)
+      assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(sup)
+    end
+
+    test "terminates child with integer shutdown" do
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+      child = sleepy_worker(shutdown: 1000)
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(sup, child)
+
+      Process.monitor(child_pid)
+      assert :ok = DynamicSupervisor.terminate_child(sup, child_pid)
+      assert_receive {:DOWN, _, :process, ^child_pid, :shutdown}
+
+      assert {:error, :not_found} = DynamicSupervisor.terminate_child(sup, child_pid)
+      assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(sup)
+    end
+
+    test "terminates restarting child" do
+      {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one, max_restarts: 100_000)
+
+      child = current_module_worker([:restart, :error], restart: :permanent)
+      assert {:ok, child_pid} = DynamicSupervisor.start_child(sup, child)
+      assert_kill(child_pid, :shutdown)
+      assert :ok = DynamicSupervisor.terminate_child(sup, child_pid)
+
+      assert {:error, :not_found} = DynamicSupervisor.terminate_child(sup, child_pid)
+      assert %{workers: 0, active: 0} = DynamicSupervisor.count_children(sup)
+    end
+  end
+
+  defp sleepy_worker(opts \\ []) do
+    mfa = {Task, :start_link, [Process, :sleep, [:infinity]]}
+    Supervisor.child_spec(%{id: Task, start: mfa}, opts)
+  end
+
+  defp current_module_worker(args, opts \\ []) do
+    Supervisor.child_spec(%{id: __MODULE__, start: {__MODULE__, :start_link, args}}, opts)
+  end
+
+  defp assert_kill(pid, reason) do
+    ref = Process.monitor(pid)
+    Process.exit(pid, reason)
+    assert_receive {:DOWN, ^ref, _, _, _}
+  end
+end
diff --git a/lib/elixir/test/elixir/enum_test.exs b/lib/elixir/test/elixir/enum_test.exs
index 779d73605fa..7396f04663e 100644
--- a/lib/elixir/test/elixir/enum_test.exs
+++ b/lib/elixir/test/elixir/enum_test.exs
@@ -1,53 +1,94 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-defmodule EnumTest.List do
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule EnumTest do
   use ExUnit.Case, async: true
+  doctest Enum
 
-  test :empty? do
-    assert Enum.empty?([])
-    refute Enum.empty?([1, 2, 3])
-    refute Enum.empty?(1..3)
-  end
+  defp assert_runs_enumeration_only_once(enum_fun) do
+    enumerator =
+      Stream.map([:element], fn element ->
+        send(self(), element)
+        element
+      end)
 
-  test :member? do
-    assert Enum.member?([1, 2, 3], 2)
-    refute Enum.member?([], 0)
-    refute Enum.member?([1, 2, 3], 0)
-    assert Enum.member?(1..3, 2)
-    refute Enum.member?(1..3, 0)
+    enum_fun.(enumerator)
+    assert_received :element
+    refute_received :element
   end
 
-  test :count do
-    assert Enum.count([1, 2, 3]) == 3
-    assert Enum.count([]) == 0
-  end
+  describe "zip_reduce/4" do
+    test "two non lists" do
+      left = %{a: 1}
+      right = %{b: 2}
+      reducer = fn {_, x}, {_, y}, acc -> [x + y | acc] end
+      assert Enum.zip_reduce(left, right, [], reducer) == [3]
+
+      # Empty Left
+      assert Enum.zip_reduce(%{}, right, [], reducer) == []
+
+      # Empty Right
+      assert Enum.zip_reduce(left, %{}, [], reducer) == []
+    end
 
-  test :count_fun do
-    assert Enum.count([1, 2, 3], fn(x) -> rem(x, 2) == 0 end) == 1
-    assert Enum.count([], fn(x) -> rem(x, 2) == 0 end) == 0
+    test "lists" do
+      assert Enum.zip_reduce([1, 2], [3, 4], 0, fn x, y, acc -> x + y + acc end) == 10
+      assert Enum.zip_reduce([1, 2], [3, 4], [], fn x, y, acc -> [x + y | acc] end) == [6, 4]
+    end
+
+    test "when left empty" do
+      assert Enum.zip_reduce([], [1, 2], 0, fn x, y, acc -> x + y + acc end) == 0
+    end
+
+    test "when right empty" do
+      assert Enum.zip_reduce([1, 2], [], 0, fn x, y, acc -> x + y + acc end) == 0
+    end
   end
 
-  test :all? do
-    assert Enum.all?([2, 4, 6], fn(x) -> rem(x, 2) == 0 end)
-    refute Enum.all?([2, 3, 4], fn(x) -> rem(x, 2) == 0 end)
+  describe "zip_reduce/3" do
+    test "when enums empty" do
+      assert Enum.zip_reduce([], 0, fn _, acc -> acc end) == 0
+    end
+
+    test "lists work" do
+      enums = [[1, 1], [2, 2], [3, 3]]
+      result = Enum.zip_reduce(enums, [], fn elements, acc -> [List.to_tuple(elements) | acc] end)
+      assert result == [{1, 2, 3}, {1, 2, 3}]
+    end
 
+    test "mix and match" do
+      enums = [[1, 2], 3..4, [5, 6]]
+      result = Enum.zip_reduce(enums, [], fn elements, acc -> [List.to_tuple(elements) | acc] end)
+      assert result == [{2, 4, 6}, {1, 3, 5}]
+    end
+  end
+
+  test "all?/2" do
     assert Enum.all?([2, 4, 6])
     refute Enum.all?([2, nil, 4])
-
     assert Enum.all?([])
+
+    assert Enum.all?([2, 4, 6], fn x -> rem(x, 2) == 0 end)
+    refute Enum.all?([2, 3, 4], fn x -> rem(x, 2) == 0 end)
   end
 
-  test :any? do
-    refute Enum.any?([2, 4, 6], fn(x) -> rem(x, 2) == 1 end)
-    assert Enum.any?([2, 3, 4], fn(x) -> rem(x, 2) == 1 end)
+  test "any?/2" do
+    refute Enum.any?([2, 4, 6], fn x -> rem(x, 2) == 1 end)
+    assert Enum.any?([2, 3, 4], fn x -> rem(x, 2) == 1 end)
 
     refute Enum.any?([false, false, false])
     assert Enum.any?([false, true, false])
 
+    assert Enum.any?([:foo, false, false])
+    refute Enum.any?([false, nil, false])
+
     refute Enum.any?([])
   end
 
-  test :at do
+  test "at/3" do
     assert Enum.at([2, 4, 6], 0) == 2
     assert Enum.at([2, 4, 6], 2) == 6
     assert Enum.at([2, 4, 6], 4) == nil
@@ -56,42 +97,182 @@ defmodule EnumTest.List do
     assert Enum.at([2, 4, 6], -4) == nil
   end
 
-  test :concat_1 do
+  test "chunk/3" do
+    enum = String.to_atom("Elixir.Enum")
+    assert enum.chunk(1..5, 2, 1) == Enum.chunk_every(1..5, 2, 1, :discard)
+  end
+
+  test "chunk/4" do
+    enum = String.to_atom("Elixir.Enum")
+    assert enum.chunk(1..5, 2, 1, nil) == Enum.chunk_every(1..5, 2, 1, :discard)
+  end
+
+  test "chunk_every/2" do
+    assert Enum.chunk_every([1, 2, 3, 4, 5], 2) == [[1, 2], [3, 4], [5]]
+  end
+
+  test "chunk_every/4" do
+    assert Enum.chunk_every([1, 2, 3, 4, 5], 2, 2, [6]) == [[1, 2], [3, 4], [5, 6]]
+    assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard) == [[1, 2, 3], [3, 4, 5]]
+    assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 2, 3, :discard) == [[1, 2], [4, 5]]
+    assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, []) == [[1, 2, 3], [3, 4, 5], [5, 6]]
+    assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 3, 3, []) == [[1, 2, 3], [4, 5, 6]]
+    assert Enum.chunk_every([1, 2, 3, 4, 5], 4, 4, 6..10) == [[1, 2, 3, 4], [5, 6, 7, 8]]
+    assert Enum.chunk_every([1, 2, 3, 4, 5], 2, 3, []) == [[1, 2], [4, 5]]
+    assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 2, 3, []) == [[1, 2], [4, 5]]
+    assert Enum.chunk_every([1, 2, 3, 4, 5, 6, 7], 2, 3, []) == [[1, 2], [4, 5], [7]]
+    assert Enum.chunk_every([1, 2, 3, 4, 5, 6, 7], 2, 3, [8]) == [[1, 2], [4, 5], [7, 8]]
+    assert Enum.chunk_every([1, 2, 3, 4, 5, 6, 7], 2, 4, []) == [[1, 2], [5, 6]]
+  end
+
+  test "chunk_by/2" do
+    assert Enum.chunk_by([1, 2, 2, 3, 4, 4, 6, 7, 7], &(rem(&1, 2) == 1)) ==
+             [[1], [2, 2], [3], [4, 4, 6], [7, 7]]
+
+    assert Enum.chunk_by([1, 2, 3, 4], fn _ -> true end) == [[1, 2, 3, 4]]
+    assert Enum.chunk_by([], fn _ -> true end) == []
+    assert Enum.chunk_by([1], fn _ -> true end) == [[1]]
+  end
+
+  test "chunk_while/4" do
+    chunk_fun = fn i, acc ->
+      cond do
+        i > 10 ->
+          {:halt, acc}
+
+        rem(i, 2) == 0 ->
+          {:cont, Enum.reverse([i | acc]), []}
+
+        true ->
+          {:cont, [i | acc]}
+      end
+    end
+
+    after_fun = fn
+      [] -> {:cont, []}
+      acc -> {:cont, Enum.reverse(acc), []}
+    end
+
+    assert Enum.chunk_while([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [], chunk_fun, after_fun) ==
+             [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
+
+    assert Enum.chunk_while(0..9, [], chunk_fun, after_fun) ==
+             [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9]]
+
+    assert Enum.chunk_while(0..10, [], chunk_fun, after_fun) ==
+             [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
+
+    assert Enum.chunk_while(0..11, [], chunk_fun, after_fun) ==
+             [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
+
+    assert Enum.chunk_while([5, 7, 9, 11], [], chunk_fun, after_fun) == [[5, 7, 9]]
+
+    assert Enum.chunk_while([1, 2, 3, 5, 7], [], chunk_fun, after_fun) == [[1, 2], [3, 5, 7]]
+
+    chunk_fn2 = fn
+      -1, acc -> {:cont, acc, 0}
+      i, acc -> {:cont, acc + i}
+    end
+
+    after_fn2 = fn acc -> {:cont, acc, 0} end
+
+    assert Enum.chunk_while([1, -1, 2, 3, -1, 4, 5, 6], 0, chunk_fn2, after_fn2) == [1, 5, 15]
+  end
+
+  test "concat/1" do
     assert Enum.concat([[1, [2], 3], [4], [5, 6]]) == [1, [2], 3, 4, 5, 6]
-    assert Enum.concat(1..3, []) == [1,2,3]
 
     assert Enum.concat([[], []]) == []
-    assert Enum.concat([[]])     == []
-    assert Enum.concat([])       == []
-
-    assert Enum.concat([1..5, fn acc, _ -> acc end, [1]]) == [1,2,3,4,5,1]
+    assert Enum.concat([[]]) == []
+    assert Enum.concat([]) == []
   end
 
-  test :concat_2 do
+  test "concat/2" do
     assert Enum.concat([], [1]) == [1]
     assert Enum.concat([1, [2], 3], [4, 5]) == [1, [2], 3, 4, 5]
-    assert Enum.concat(1..3, []) == [1,2,3]
+
+    assert Enum.concat([1, 2], 3..5) == [1, 2, 3, 4, 5]
 
     assert Enum.concat([], []) == []
+    assert Enum.concat([], 1..3) == [1, 2, 3]
 
     assert Enum.concat(fn acc, _ -> acc end, [1]) == [1]
   end
 
-  test :fetch! do
-    assert Enum.fetch!([2, 4, 6], 0) == 2
-    assert Enum.fetch!([2, 4, 6], 2) == 6
-    assert Enum.fetch!([2, 4, 6], -2) == 4
+  test "count/1" do
+    assert Enum.count([1, 2, 3]) == 3
+    assert Enum.count([]) == 0
+    assert Enum.count([1, true, false, nil]) == 4
+  end
 
-    assert_raise Enum.OutOfBoundsError, fn ->
-      Enum.fetch!([2, 4, 6], 4)
-    end
+  test "count/2" do
+    assert Enum.count([1, 2, 3], fn x -> rem(x, 2) == 0 end) == 1
+    assert Enum.count([], fn x -> rem(x, 2) == 0 end) == 0
+    assert Enum.count([1, true, false, nil], & &1) == 2
+  end
 
-    assert_raise Enum.OutOfBoundsError, fn ->
-      Enum.fetch!([2, 4, 6], -4)
+  test "count_until/2" do
+    assert Enum.count_until([1, 2, 3], 2) == 2
+    assert Enum.count_until([], 2) == 0
+    assert Enum.count_until([1, 2], 2) == 2
+  end
+
+  test "count_until/2 with streams" do
+    count_until_stream = fn list, limit -> list |> Stream.map(& &1) |> Enum.count_until(limit) end
+
+    assert count_until_stream.([1, 2, 3], 2) == 2
+    assert count_until_stream.([], 2) == 0
+    assert count_until_stream.([1, 2], 2) == 2
+  end
+
+  test "count_until/3" do
+    assert Enum.count_until([1, 2, 3, 4, 5, 6], fn x -> rem(x, 2) == 0 end, 2) == 2
+    assert Enum.count_until([1, 2], fn x -> rem(x, 2) == 0 end, 2) == 1
+    assert Enum.count_until([1, 2, 3, 4], fn x -> rem(x, 2) == 0 end, 2) == 2
+    assert Enum.count_until([], fn x -> rem(x, 2) == 0 end, 2) == 0
+  end
+
+  test "count_until/3 with streams" do
+    count_until_stream = fn list, fun, limit ->
+      list |> Stream.map(& &1) |> Enum.count_until(fun, limit)
     end
+
+    assert count_until_stream.([1, 2, 3, 4, 5, 6], fn x -> rem(x, 2) == 0 end, 2) == 2
+    assert count_until_stream.([1, 2], fn x -> rem(x, 2) == 0 end, 2) == 1
+    assert count_until_stream.([1, 2, 3, 4], fn x -> rem(x, 2) == 0 end, 2) == 2
+    assert count_until_stream.([], fn x -> rem(x, 2) == 0 end, 2) == 0
+  end
+
+  test "dedup/1" do
+    assert Enum.dedup([1, 1, 2, 1, 1, 2, 1]) == [1, 2, 1, 2, 1]
+    assert Enum.dedup([2, 1, 1, 2, 1]) == [2, 1, 2, 1]
+    assert Enum.dedup([1, 2, 3, 4]) == [1, 2, 3, 4]
+    assert Enum.dedup([1, 1.0, 2.0, 2]) == [1, 1.0, 2.0, 2]
+    assert Enum.dedup([]) == []
+    assert Enum.dedup([nil, nil, true, {:value, true}]) == [nil, true, {:value, true}]
+    assert Enum.dedup([nil]) == [nil]
+  end
+
+  test "dedup/1 with streams" do
+    dedup_stream = fn list -> list |> Stream.map(& &1) |> Enum.dedup() end
+
+    assert dedup_stream.([1, 1, 2, 1, 1, 2, 1]) == [1, 2, 1, 2, 1]
+    assert dedup_stream.([2, 1, 1, 2, 1]) == [2, 1, 2, 1]
+    assert dedup_stream.([1, 2, 3, 4]) == [1, 2, 3, 4]
+    assert dedup_stream.([1, 1.0, 2.0, 2]) == [1, 1.0, 2.0, 2]
+    assert dedup_stream.([]) == []
+    assert dedup_stream.([nil, nil, true, {:value, true}]) == [nil, true, {:value, true}]
+    assert dedup_stream.([nil]) == [nil]
   end
 
-  test :drop do
+  test "dedup_by/2" do
+    assert Enum.dedup_by([{1, :x}, {2, :y}, {2, :z}, {1, :x}], fn {x, _} -> x end) ==
+             [{1, :x}, {2, :y}, {1, :x}]
+
+    assert Enum.dedup_by([5, 1, 2, 3, 2, 1], fn x -> x > 2 end) == [5, 1, 3, 2]
+  end
+
+  test "drop/2" do
     assert Enum.drop([1, 2, 3], 0) == [1, 2, 3]
     assert Enum.drop([1, 2, 3], 1) == [2, 3]
     assert Enum.drop([1, 2, 3], 2) == [3]
@@ -101,221 +282,1232 @@ defmodule EnumTest.List do
     assert Enum.drop([1, 2, 3], -2) == [1]
     assert Enum.drop([1, 2, 3], -4) == []
     assert Enum.drop([], 3) == []
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.drop([1, 2, 3], 0.0)
+    end
   end
 
-  test :drop_while do
-    assert Enum.drop_while([1, 2, 3, 4, 3, 2, 1], fn(x) -> x <= 3 end) == [4, 3, 2, 1]
-    assert Enum.drop_while([1, 2, 3], fn(_) -> false end) == [1, 2, 3]
-    assert Enum.drop_while([1, 2, 3], fn(x) -> x <= 3 end) == []
-    assert Enum.drop_while([], fn(_) -> false end) == []
+  test "drop/2 with streams" do
+    drop_stream = fn list, count -> list |> Stream.map(& &1) |> Enum.drop(count) end
+
+    assert drop_stream.([1, 2, 3], 0) == [1, 2, 3]
+    assert drop_stream.([1, 2, 3], 1) == [2, 3]
+    assert drop_stream.([1, 2, 3], 2) == [3]
+    assert drop_stream.([1, 2, 3], 3) == []
+    assert drop_stream.([1, 2, 3], 4) == []
+    assert drop_stream.([1, 2, 3], -1) == [1, 2]
+    assert drop_stream.([1, 2, 3], -2) == [1]
+    assert drop_stream.([1, 2, 3], -4) == []
+    assert drop_stream.([], 3) == []
   end
 
-  test :find do
-    assert Enum.find([2, 4, 6], fn(x) -> rem(x, 2) == 1 end) == nil
-    assert Enum.find([2, 4, 6], 0, fn(x) -> rem(x, 2) == 1 end) == 0
-    assert Enum.find([2, 3, 4], fn(x) -> rem(x, 2) == 1 end) == 3
+  test "drop_every/2" do
+    assert Enum.drop_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2) == [2, 4, 6, 8, 10]
+    assert Enum.drop_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3) == [2, 3, 5, 6, 8, 9]
+    assert Enum.drop_every([], 2) == []
+    assert Enum.drop_every([1, 2], 2) == [2]
+    assert Enum.drop_every([1, 2, 3], 0) == [1, 2, 3]
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.drop_every([1, 2, 3], -1)
+    end
   end
 
-  test :find_value do
-    assert Enum.find_value([2, 4, 6], fn(x) -> rem(x, 2) == 1 end) == nil
-    assert Enum.find_value([2, 4, 6], 0, fn(x) -> rem(x, 2) == 1 end) == 0
-    assert Enum.find_value([2, 3, 4], fn(x) -> rem(x, 2) == 1 end)
+  test "drop_while/2" do
+    assert Enum.drop_while([1, 2, 3, 4, 3, 2, 1], fn x -> x <= 3 end) == [4, 3, 2, 1]
+    assert Enum.drop_while([1, 2, 3], fn _ -> false end) == [1, 2, 3]
+    assert Enum.drop_while([1, 2, 3], fn x -> x <= 3 end) == []
+    assert Enum.drop_while([], fn _ -> false end) == []
   end
 
-  test :find_index do
-    assert Enum.find_index([2, 4, 6], fn(x) -> rem(x, 2) == 1 end) == nil
-    assert Enum.find_index([2, 3, 4], fn(x) -> rem(x, 2) == 1 end) == 1
+  test "each/2" do
+    try do
+      assert Enum.each([], fn x -> x end) == :ok
+      assert Enum.each([1, 2, 3], fn x -> Process.put(:enum_test_each, x * 2) end) == :ok
+      assert Process.get(:enum_test_each) == 6
+    after
+      Process.delete(:enum_test_each)
+    end
   end
 
-  test :each do
-    assert Enum.each([], fn(x) -> x end) == :ok
-    assert Enum.each([1, 2, 3], fn(x) -> Process.put(:enum_test_each, x * 2) end) == :ok
-    assert Process.get(:enum_test_each) == 6
-  after
-    Process.delete(:enum_test_each)
+  test "empty?/1" do
+    assert Enum.empty?([])
+    assert Enum.empty?(%{})
+    refute Enum.empty?([1, 2, 3])
+    refute Enum.empty?(%{one: 1})
+    refute Enum.empty?(1..3)
+
+    assert Stream.take([1], 0) |> Enum.empty?()
+    refute Stream.take([1], 1) |> Enum.empty?()
   end
 
-  test :fetch do
+  test "fetch/2" do
+    assert Enum.fetch([66], 0) == {:ok, 66}
+    assert Enum.fetch([66], -1) == {:ok, 66}
+    assert Enum.fetch([66], 1) == :error
+    assert Enum.fetch([66], -2) == :error
+
     assert Enum.fetch([2, 4, 6], 0) == {:ok, 2}
+    assert Enum.fetch([2, 4, 6], -1) == {:ok, 6}
     assert Enum.fetch([2, 4, 6], 2) == {:ok, 6}
     assert Enum.fetch([2, 4, 6], 4) == :error
     assert Enum.fetch([2, 4, 6], -2) == {:ok, 4}
     assert Enum.fetch([2, 4, 6], -4) == :error
+
+    assert Enum.fetch([], 0) == :error
+    assert Enum.fetch([], 1) == :error
   end
 
-  test :filter do
-    assert Enum.filter([1, 2, 3], fn(x) -> rem(x, 2) == 0 end) == [2]
-    assert Enum.filter([2, 4, 6], fn(x) -> rem(x, 2) == 0 end) == [2, 4, 6]
+  test "fetch!/2" do
+    assert Enum.fetch!([2, 4, 6], 0) == 2
+    assert Enum.fetch!([2, 4, 6], 2) == 6
+    assert Enum.fetch!([2, 4, 6], -2) == 4
+
+    assert_raise Enum.OutOfBoundsError, fn ->
+      Enum.fetch!([2, 4, 6], 4)
+    end
+
+    assert_raise Enum.OutOfBoundsError, fn ->
+      Enum.fetch!([2, 4, 6], -4)
+    end
   end
 
-  test :filter_with_match do
+  test "filter/2" do
+    assert Enum.filter([1, 2, 3], fn x -> rem(x, 2) == 0 end) == [2]
+    assert Enum.filter([2, 4, 6], fn x -> rem(x, 2) == 0 end) == [2, 4, 6]
+
+    assert Enum.filter([1, 2, false, 3, nil], & &1) == [1, 2, 3]
     assert Enum.filter([1, 2, 3], &match?(1, &1)) == [1]
     assert Enum.filter([1, 2, 3], &match?(x when x < 3, &1)) == [1, 2]
-    assert Enum.filter([1, 2, 3], &match?(_, &1)) == [1, 2, 3]
+    assert Enum.filter([1, 2, 3], fn _ -> true end) == [1, 2, 3]
   end
 
-  test :filter_map do
-    assert Enum.filter_map([1, 2, 3], fn(x) -> rem(x, 2) == 0 end, &(&1 * 2)) == [4]
-    assert Enum.filter_map([2, 4, 6], fn(x) -> rem(x, 2) == 0 end, &(&1 * 2)) == [4, 8, 12]
+  test "find/3" do
+    assert Enum.find([2, 4, 6], fn x -> rem(x, 2) == 1 end) == nil
+    assert Enum.find([2, 4, 6], 0, fn x -> rem(x, 2) == 1 end) == 0
+    assert Enum.find([2, 3, 4], fn x -> rem(x, 2) == 1 end) == 3
   end
 
-  test :flat_map do
-    assert Enum.flat_map([], fn(x) -> [x, x] end) == []
-    assert Enum.flat_map([1, 2, 3], fn(x) -> [x, x] end) == [1, 1, 2, 2, 3, 3]
-    assert Enum.flat_map([1, 2, 3], fn(x) -> x..x+1 end) == [1, 2, 2, 3, 3, 4]
+  test "find_index/2" do
+    assert Enum.find_index([2, 4, 6], fn x -> rem(x, 2) == 1 end) == nil
+    assert Enum.find_index([2, 3, 4], fn x -> rem(x, 2) == 1 end) == 1
+    assert Stream.take(1..3, 3) |> Enum.find_index(fn _ -> false end) == nil
+    assert Stream.take(1..6, 6) |> Enum.find_index(fn x -> x == 5 end) == 4
   end
 
-  test :flat_map_reduce do
-    assert Enum.flat_map_reduce([1, 2, 3], 0, &{[&1, &2], &1 + &2}) ==
-           {[1, 0, 2, 1, 3, 3], 6}
+  test "find_value/2" do
+    assert Enum.find_value([2, 4, 6], fn x -> rem(x, 2) == 1 end) == nil
+    assert Enum.find_value([2, 4, 6], 0, fn x -> rem(x, 2) == 1 end) == 0
+    assert Enum.find_value([2, 3, 4], fn x -> rem(x, 2) == 1 end)
+  end
 
-    assert Enum.flat_map_reduce(1..100, 0, fn i, acc ->
-      if acc < 3, do: {[i], acc + 1}, else: {:halt, acc}
-    end) == {[1,2,3], 3}
+  test "flat_map/2" do
+    assert Enum.flat_map([], fn x -> [x, x] end) == []
+    assert Enum.flat_map([1, 2, 3], fn x -> [x, x] end) == [1, 1, 2, 2, 3, 3]
+    assert Enum.flat_map([1, 2, 3], fn x -> x..(x + 1) end) == [1, 2, 2, 3, 3, 4]
+    assert Enum.flat_map([1, 2, 3], fn x -> Stream.duplicate(x, 2) end) == [1, 1, 2, 2, 3, 3]
   end
 
-  test :group_by do
-    assert Enum.group_by([], fn -> nil end) == %{}
-    assert Enum.group_by(1..6, &rem(&1, 3)) ==
-           %{0 => [6, 3], 1 => [4, 1], 2 => [5, 2]}
+  test "flat_map/2 with streams" do
+    flat_map_stream = fn list, fun -> list |> Stream.map(& &1) |> Enum.flat_map(fun) end
 
-    result = Enum.group_by(1..6, %{3 => :default}, &rem(&1, 3))
-    assert result[0] == [6, 3]
-    assert result[3] == :default
+    assert flat_map_stream.([], fn x -> [x, x] end) == []
+    assert flat_map_stream.([1, 2, 3], fn x -> [x, x] end) == [1, 1, 2, 2, 3, 3]
+    assert flat_map_stream.([1, 2, 3], fn x -> x..(x + 1) end) == [1, 2, 2, 3, 3, 4]
+    assert flat_map_stream.([1, 2, 3], fn x -> Stream.duplicate(x, 2) end) == [1, 1, 2, 2, 3, 3]
   end
 
-  test :into do
-    assert Enum.into([a: 1, b: 2], %{}) == %{a: 1, b: 2}
-    assert Enum.into([a: 1, b: 2], %{c: 3}) == %{a: 1, b: 2, c: 3}
-    assert Enum.into(%{a: 1, b: 2}, []) == [a: 1, b: 2]
-    assert Enum.into([1, 2, 3], "numbers: ", &to_string/1) == "numbers: 123"
-    assert Enum.into([1, 2, 3], fn
-      func, {:cont, x} when is_function(func) -> [x]
-      list, {:cont, x} -> [x|list]
-      list, _ -> list
-    end) == [3, 2, 1]
+  test "flat_map_reduce/3" do
+    assert Enum.flat_map_reduce([1, 2, 3], 0, &{[&1, &2], &1 + &2}) == {[1, 0, 2, 1, 3, 3], 6}
+  end
+
+  test "frequencies/1" do
+    assert Enum.frequencies([]) == %{}
+    assert Enum.frequencies(~w{a c a a c b}) == %{"a" => 3, "b" => 1, "c" => 2}
+  end
+
+  test "frequencies_by/2" do
+    assert Enum.frequencies_by([], fn _ -> raise "oops" end) == %{}
+    assert Enum.frequencies_by([12, 7, 6, 5, 1], &Integer.mod(&1, 2)) == %{0 => 2, 1 => 3}
   end
 
-  test :intersperse do
+  test "group_by/3" do
+    assert Enum.group_by([], fn _ -> raise "oops" end) == %{}
+    assert Enum.group_by([1, 2, 3], &rem(&1, 2)) == %{0 => [2], 1 => [1, 3]}
+  end
+
+  test "intersperse/2" do
     assert Enum.intersperse([], true) == []
     assert Enum.intersperse([1], true) == [1]
-    assert Enum.intersperse([1,2,3], true) == [1, true, 2, true, 3]
+    assert Enum.intersperse([1, 2, 3], true) == [1, true, 2, true, 3]
+
+    assert Enum.intersperse(.., true) == []
+    assert Enum.intersperse(1..1, true) == [1]
+    assert Enum.intersperse(1..3, true) == [1, true, 2, true, 3]
   end
 
-  test :join do
+  test "into/2" do
+    assert Enum.into([a: 1, b: 2], %{}) == %{a: 1, b: 2}
+    assert Enum.into([a: 1, b: 2], %{c: 3}) == %{a: 1, b: 2, c: 3}
+    assert Enum.into(MapSet.new(a: 1, b: 2), %{}) == %{a: 1, b: 2}
+    assert Enum.into(MapSet.new(a: 1, b: 2), %{c: 3}) == %{a: 1, b: 2, c: 3}
+    assert Enum.into(%{a: 1, b: 2}, []) |> Enum.sort() == [a: 1, b: 2]
+    assert Enum.into(1..3, []) == [1, 2, 3]
+    assert Enum.into(["H", "i"], "") == "Hi"
+
+    assert Enum.into([a: 1, b: 2], MapSet.new()) == MapSet.new(a: 1, b: 2)
+    assert Enum.into(%{a: 1, b: 2}, MapSet.new()) == MapSet.new(a: 1, b: 2)
+    assert Enum.into([a: 1, b: 2], MapSet.new(a: 1, c: 3)) == MapSet.new(a: 1, b: 2, c: 3)
+  end
+
+  test "into/2 exceptions" do
+    assert_raise ArgumentError,
+                 "collecting into a map requires {key, value} tuples, got: 1",
+                 fn -> Enum.into(1..10, %{}) end
+
+    assert_raise ArgumentError, "collecting into a binary requires a bitstring, got: 1", fn ->
+      Enum.into(1..10, <<>>)
+    end
+
+    assert_raise ArgumentError, "collecting into a bitstring requires a bitstring, got: 1", fn ->
+      Enum.into(1..10, <<1::1>>)
+    end
+  end
+
+  test "into/3" do
+    assert Enum.into([1, 2, 3], [], fn x -> x * 2 end) == [2, 4, 6]
+    assert Enum.into([1, 2, 3], "numbers: ", &to_string/1) == "numbers: 123"
+
+    assert Enum.into([1, 2, 3], MapSet.new(), &(&1 * 2)) == MapSet.new([2, 4, 6])
+    assert Enum.into([1, 2, 3], MapSet.new([0, 2]), &(&1 * 2)) == MapSet.new([0, 2, 4, 6])
+
+    assert_raise MatchError, fn ->
+      Enum.into([2, 3], %{a: 1}, & &1)
+    end
+  end
+
+  test "join/2" do
     assert Enum.join([], " = ") == ""
     assert Enum.join([1, 2, 3], " = ") == "1 = 2 = 3"
     assert Enum.join([1, "2", 3], " = ") == "1 = 2 = 3"
     assert Enum.join([1, 2, 3]) == "123"
     assert Enum.join(["", "", 1, 2, "", 3, "", "\n"], ";") == ";;1;2;;3;;\n"
     assert Enum.join([""]) == ""
+
+    assert Enum.join(fn acc, _ -> acc end, ".") == ""
+  end
+
+  test "map/2" do
+    assert Enum.map([], fn x -> x * 2 end) == []
+    assert Enum.map([1, 2, 3], fn x -> x * 2 end) == [2, 4, 6]
   end
 
-  test :map_join do
+  test "map_every/3" do
+    assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2, fn x -> x * 2 end) ==
+             [2, 2, 6, 4, 10, 6, 14, 8, 18, 10]
+
+    assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3, fn x -> x * 2 end) ==
+             [2, 2, 3, 8, 5, 6, 14, 8, 9, 20]
+
+    assert Enum.map_every([], 2, fn x -> x * 2 end) == []
+    assert Enum.map_every([1, 2], 2, fn x -> x * 2 end) == [2, 2]
+
+    assert Enum.map_every([1, 2, 3], 0, fn _x -> raise "should not be invoked" end) ==
+             [1, 2, 3]
+
+    assert Enum.map_every(1..3, 1, fn x -> x * 2 end) == [2, 4, 6]
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.map_every([1, 2, 3], -1, fn x -> x * 2 end)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.map_every(1..10, 3.33, fn x -> x * 2 end)
+    end
+
+    assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 9, fn x -> x + 1000 end) ==
+             [1001, 2, 3, 4, 5, 6, 7, 8, 9, 1010]
+
+    assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10, fn x -> x + 1000 end) ==
+             [1001, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    assert Enum.map_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 100, fn x -> x + 1000 end) ==
+             [1001, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  end
+
+  test "map_intersperse/3" do
+    assert Enum.map_intersperse([], :a, &(&1 * 2)) == []
+    assert Enum.map_intersperse([1], :a, &(&1 * 2)) == [2]
+    assert Enum.map_intersperse([1, 2, 3], :a, &(&1 * 2)) == [2, :a, 4, :a, 6]
+  end
+
+  test "map_join/3" do
     assert Enum.map_join([], " = ", &(&1 * 2)) == ""
     assert Enum.map_join([1, 2, 3], " = ", &(&1 * 2)) == "2 = 4 = 6"
     assert Enum.map_join([1, 2, 3], &(&1 * 2)) == "246"
-    assert Enum.map_join(["", "", 1, 2, "", 3, "", "\n"], ";", &(&1)) == ";;1;2;;3;;\n"
-    assert Enum.map_join([""], "", &(&1)) == ""
+    assert Enum.map_join(["", "", 1, 2, "", 3, "", "\n"], ";", & &1) == ";;1;2;;3;;\n"
+    assert Enum.map_join([""], "", & &1) == ""
+    assert Enum.map_join(fn acc, _ -> acc end, ".", &(&1 + 0)) == ""
   end
 
-  test :join_empty do
-    fun = fn (acc, _) -> acc end
-    assert Enum.join(fun, ".") == ""
-    assert Enum.map_join(fun, ".", &(&1 + 0)) == ""
+  test "map_reduce/3" do
+    assert Enum.map_reduce([], 1, fn x, acc -> {x * 2, x + acc} end) == {[], 1}
+    assert Enum.map_reduce([1, 2, 3], 1, fn x, acc -> {x * 2, x + acc} end) == {[2, 4, 6], 7}
   end
 
-  test :map do
-    assert Enum.map([], fn x -> x * 2 end) == []
-    assert Enum.map([1, 2, 3], fn x -> x * 2 end) == [2, 4, 6]
+  test "max/1" do
+    assert Enum.max([1]) == 1
+    assert Enum.max([1, 2, 3]) == 3
+    assert Enum.max([1, [], :a, {}]) == []
+
+    assert Enum.max([1, 1.0]) === 1
+    assert Enum.max([1.0, 1]) === 1.0
+
+    assert_raise Enum.EmptyError, fn ->
+      Enum.max([])
+    end
+  end
+
+  test "max/2 with empty fallback" do
+    assert Enum.max([], fn -> 0 end) === 0
+    assert Enum.max([1, 2], fn -> 0 end) === 2
+  end
+
+  test "max/2 with stable sorting" do
+    assert Enum.max([1, 1.0], &>=/2) === 1
+    assert Enum.max([1.0, 1], &>=/2) === 1.0
+    assert Enum.max([1, 1.0], &>/2) === 1.0
+    assert Enum.max([1.0, 1], &>/2) === 1
+  end
+
+  test "max/2 with module" do
+    assert Enum.max([~D[2019-01-01], ~D[2020-01-01]], Date) === ~D[2020-01-01]
+  end
+
+  test "max/3" do
+    assert Enum.max([1], &>=/2, fn -> nil end) == 1
+    assert Enum.max([1, 2, 3], &>=/2, fn -> nil end) == 3
+    assert Enum.max([1, [], :a, {}], &>=/2, fn -> nil end) == []
+    assert Enum.max([], &>=/2, fn -> :empty_value end) == :empty_value
+    assert Enum.max(%{}, &>=/2, fn -> :empty_value end) == :empty_value
+    assert_runs_enumeration_only_once(&Enum.max(&1, fn a, b -> a >= b end, fn -> nil end))
+  end
+
+  test "max_by/2" do
+    assert Enum.max_by(["a", "aa", "aaa"], fn x -> String.length(x) end) == "aaa"
+
+    assert Enum.max_by([1, 1.0], & &1) === 1
+    assert Enum.max_by([1.0, 1], & &1) === 1.0
+
+    assert_raise Enum.EmptyError, fn ->
+      Enum.max_by([], fn x -> String.length(x) end)
+    end
+
+    assert_raise Enum.EmptyError, fn ->
+      Enum.max_by(%{}, & &1)
+    end
+  end
+
+  test "max_by/3 with stable sorting" do
+    assert Enum.max_by([1, 1.0], & &1, &>=/2) === 1
+    assert Enum.max_by([1.0, 1], & &1, &>=/2) === 1.0
+    assert Enum.max_by([1, 1.0], & &1, &>/2) === 1.0
+    assert Enum.max_by([1.0, 1], & &1, &>/2) === 1
+  end
+
+  test "max_by/3 with module" do
+    users = [%{id: 1, date: ~D[2019-01-01]}, %{id: 2, date: ~D[2020-01-01]}]
+    assert Enum.max_by(users, & &1.date, Date).id == 2
+
+    users = [%{id: 1, date: ~D[2020-01-01]}, %{id: 2, date: ~D[2020-01-01]}]
+    assert Enum.max_by(users, & &1.date, Date).id == 1
   end
 
-  test :map_reduce do
-    assert Enum.map_reduce([], 1, fn(x, acc) -> {x * 2, x + acc} end) == {[], 1}
-    assert Enum.map_reduce([1, 2, 3], 1, fn(x, acc) -> {x * 2, x + acc} end) == {[2, 4, 6], 7}
+  test "max_by/4" do
+    assert Enum.max_by(["a", "aa", "aaa"], fn x -> String.length(x) end, &>=/2, fn -> nil end) ==
+             "aaa"
+
+    assert Enum.max_by([], fn x -> String.length(x) end, &>=/2, fn -> :empty_value end) ==
+             :empty_value
+
+    assert Enum.max_by(%{}, & &1, &>=/2, fn -> :empty_value end) == :empty_value
+    assert Enum.max_by(%{}, & &1, &>=/2, fn -> {:a, :tuple} end) == {:a, :tuple}
+
+    assert_runs_enumeration_only_once(
+      &Enum.max_by(&1, fn e -> e end, fn a, b -> a >= b end, fn -> nil end)
+    )
   end
 
-  test :partition do
-    assert Enum.partition([1, 2, 3], fn(x) -> rem(x, 2) == 0 end) == {[2], [1, 3]}
-    assert Enum.partition([2, 4, 6], fn(x) -> rem(x, 2) == 0 end) == {[2, 4, 6], []}
+  test "member?/2" do
+    assert Enum.member?([1, 2, 3], 2)
+    refute Enum.member?([], 0)
+    refute Enum.member?([1, 2, 3], 0)
   end
 
-  test :reduce do
-    assert Enum.reduce([], 1, fn(x, acc) -> x + acc end) == 1
-    assert Enum.reduce([1, 2, 3], 1, fn(x, acc) -> x + acc end) == 7
+  test "min/1" do
+    assert Enum.min([1]) == 1
+    assert Enum.min([1, 2, 3]) == 1
+    assert Enum.min([[], :a, {}]) == :a
+
+    assert Enum.min([1, 1.0]) === 1
+    assert Enum.min([1.0, 1]) === 1.0
 
-    assert Enum.reduce([1, 2, 3], fn(x, acc) -> x + acc end) == 6
     assert_raise Enum.EmptyError, fn ->
-      Enum.reduce([], fn(x, acc) -> x + acc end)
+      Enum.min([])
     end
   end
 
-  test :reject do
-    assert Enum.reject([1, 2, 3], fn(x) -> rem(x, 2) == 0 end) == [1, 3]
-    assert Enum.reject([2, 4, 6], fn(x) -> rem(x, 2) == 0 end) == []
+  test "min/2 with empty fallback" do
+    assert Enum.min([], fn -> 0 end) === 0
+    assert Enum.min([1, 2], fn -> 0 end) === 1
+  end
+
+  test "min/2 with stable sorting" do
+    assert Enum.min([1, 1.0], &<=/2) === 1
+    assert Enum.min([1.0, 1], &<=/2) === 1.0
+    assert Enum.min([1, 1.0], &</2) === 1.0
+    assert Enum.min([1.0, 1], &</2) === 1
+  end
+
+  test "min/2 with module" do
+    assert Enum.min([~D[2019-01-01], ~D[2020-01-01]], Date) === ~D[2019-01-01]
+  end
+
+  test "min/3" do
+    assert Enum.min([1], &<=/2, fn -> nil end) == 1
+    assert Enum.min([1, 2, 3], &<=/2, fn -> nil end) == 1
+    assert Enum.min([[], :a, {}], &<=/2, fn -> nil end) == :a
+    assert Enum.min([], &<=/2, fn -> :empty_value end) == :empty_value
+    assert Enum.min(%{}, &<=/2, fn -> :empty_value end) == :empty_value
+    assert_runs_enumeration_only_once(&Enum.min(&1, fn a, b -> a <= b end, fn -> nil end))
+  end
+
+  test "min_by/2" do
+    assert Enum.min_by(["a", "aa", "aaa"], fn x -> String.length(x) end) == "a"
+
+    assert Enum.min_by([1, 1.0], & &1) === 1
+    assert Enum.min_by([1.0, 1], & &1) === 1.0
+
+    assert_raise Enum.EmptyError, fn ->
+      Enum.min_by([], fn x -> String.length(x) end)
+    end
+
+    assert_raise Enum.EmptyError, fn ->
+      Enum.min_by(%{}, & &1)
+    end
   end
 
-  test :reverse do
+  test "min_by/3 with stable sorting" do
+    assert Enum.min_by([1, 1.0], & &1, &<=/2) === 1
+    assert Enum.min_by([1.0, 1], & &1, &<=/2) === 1.0
+    assert Enum.min_by([1, 1.0], & &1, &</2) === 1.0
+    assert Enum.min_by([1.0, 1], & &1, &</2) === 1
+  end
+
+  test "min_by/3 with module" do
+    users = [%{id: 1, date: ~D[2019-01-01]}, %{id: 2, date: ~D[2020-01-01]}]
+    assert Enum.min_by(users, & &1.date, Date).id == 1
+
+    users = [%{id: 1, date: ~D[2020-01-01]}, %{id: 2, date: ~D[2020-01-01]}]
+    assert Enum.min_by(users, & &1.date, Date).id == 1
+  end
+
+  test "min_by/4" do
+    assert Enum.min_by(["a", "aa", "aaa"], fn x -> String.length(x) end, &<=/2, fn -> nil end) ==
+             "a"
+
+    assert Enum.min_by([], fn x -> String.length(x) end, &<=/2, fn -> :empty_value end) ==
+             :empty_value
+
+    assert Enum.min_by(%{}, & &1, &<=/2, fn -> :empty_value end) == :empty_value
+    assert Enum.min_by(%{}, & &1, &<=/2, fn -> {:a, :tuple} end) == {:a, :tuple}
+
+    assert_runs_enumeration_only_once(
+      &Enum.min_by(&1, fn e -> e end, fn a, b -> a <= b end, fn -> nil end)
+    )
+  end
+
+  test "min_max/1" do
+    assert Enum.min_max([1]) == {1, 1}
+    assert Enum.min_max([2, 3, 1]) == {1, 3}
+    assert Enum.min_max([[], :a, {}]) == {:a, []}
+
+    assert Enum.min_max([1, 1.0]) === {1, 1}
+    assert Enum.min_max([1.0, 1]) === {1.0, 1.0}
+
+    assert_raise Enum.EmptyError, fn ->
+      Enum.min_max([])
+    end
+  end
+
+  test "min_max/2" do
+    assert Enum.min_max([1], fn -> nil end) == {1, 1}
+    assert Enum.min_max([2, 3, 1], fn -> nil end) == {1, 3}
+    assert Enum.min_max([[], :a, {}], fn -> nil end) == {:a, []}
+    assert Enum.min_max([], fn -> {:empty_min, :empty_max} end) == {:empty_min, :empty_max}
+    assert Enum.min_max(%{}, fn -> {:empty_min, :empty_max} end) == {:empty_min, :empty_max}
+    assert_runs_enumeration_only_once(&Enum.min_max(&1, fn -> nil end))
+  end
+
+  test "min_max/3" do
+    dates = [~D[2020-01-01], ~D[2019-01-01]]
+
+    assert Enum.min_max(dates, Date) ==
+             {~D[2019-01-01], ~D[2020-01-01]}
+
+    assert Enum.min_max([~D[2000-01-01]], Date) ==
+             {~D[2000-01-01], ~D[2000-01-01]}
+
+    assert Enum.min_max([3, 1, 2], &>/2, fn -> nil end) ==
+             {3, 1}
+
+    assert Enum.min_max([], &>/2, fn -> {:no_min, :no_max} end) ==
+             {:no_min, :no_max}
+
+    assert Enum.min_max(%{}, &>/2, fn -> {:no_min, :no_max} end) ==
+             {:no_min, :no_max}
+
+    assert Enum.min_max(1..5, &>/2, fn -> {:no_min, :no_max} end) ==
+             {5, 1}
+
+    assert_runs_enumeration_only_once(&Enum.min_max(&1, fn a, b -> a > b end, fn -> nil end))
+  end
+
+  test "min_max_by/2" do
+    assert Enum.min_max_by(["aaa", "a", "aa"], fn x -> String.length(x) end) == {"a", "aaa"}
+
+    assert Enum.min_max_by([1, 1.0], & &1) === {1, 1}
+    assert Enum.min_max_by([1.0, 1], & &1) === {1.0, 1.0}
+
+    assert_raise Enum.EmptyError, fn ->
+      Enum.min_max_by([], fn x -> String.length(x) end)
+    end
+  end
+
+  test "min_max_by/3" do
+    assert Enum.min_max_by(["aaa", "a", "aa"], fn x -> String.length(x) end, fn -> nil end) ==
+             {"a", "aaa"}
+
+    assert Enum.min_max_by([], fn x -> String.length(x) end, fn -> {:no_min, :no_max} end) ==
+             {:no_min, :no_max}
+
+    assert Enum.min_max_by(%{}, fn x -> String.length(x) end, fn -> {:no_min, :no_max} end) ==
+             {:no_min, :no_max}
+
+    assert Enum.min_max_by(["aaa", "a", "aa"], fn x -> String.length(x) end, &>/2) == {"aaa", "a"}
+
+    assert_runs_enumeration_only_once(&Enum.min_max_by(&1, fn x -> x end, fn -> nil end))
+  end
+
+  test "min_max_by/4" do
+    users = [%{id: 1, date: ~D[2019-01-01]}, %{id: 2, date: ~D[2020-01-01]}]
+
+    assert Enum.min_max_by(users, & &1.date, Date) ==
+             {%{id: 1, date: ~D[2019-01-01]}, %{id: 2, date: ~D[2020-01-01]}}
+
+    assert Enum.min_max_by(["aaa", "a", "aa"], fn x -> String.length(x) end, &>/2, fn -> nil end) ==
+             {"aaa", "a"}
+
+    assert Enum.min_max_by([], fn x -> String.length(x) end, &>/2, fn -> {:no_min, :no_max} end) ==
+             {:no_min, :no_max}
+
+    assert Enum.min_max_by(%{}, fn x -> String.length(x) end, &>/2, fn -> {:no_min, :no_max} end) ==
+             {:no_min, :no_max}
+
+    assert_runs_enumeration_only_once(
+      &Enum.min_max_by(&1, fn x -> x end, fn a, b -> a > b end, fn -> nil end)
+    )
+  end
+
+  test "split_with/2" do
+    assert Enum.split_with([], fn x -> rem(x, 2) == 0 end) == {[], []}
+    assert Enum.split_with([1, 2, 3], fn x -> rem(x, 2) == 0 end) == {[2], [1, 3]}
+    assert Enum.split_with([2, 4, 6], fn x -> rem(x, 2) == 0 end) == {[2, 4, 6], []}
+
+    assert Enum.split_with(1..5, fn x -> rem(x, 2) == 0 end) == {[2, 4], [1, 3, 5]}
+    assert Enum.split_with(-3..0, fn x -> x > 0 end) == {[], [-3, -2, -1, 0]}
+
+    assert Enum.split_with(%{}, fn x -> rem(x, 2) == 0 end) == {[], []}
+
+    assert Enum.split_with(%{a: 1, b: 2}, fn {_k, v} -> rem(v, 2) == 0 end) ==
+             {[b: 2], [a: 1]}
+
+    assert Enum.split_with(%{b: 2, d: 4, f: 6}, fn {_k, v} -> rem(v, 2) == 0 end) ==
+             {Map.to_list(%{b: 2, d: 4, f: 6}), []}
+  end
+
+  test "random/1" do
+    # corner cases, independent of the seed
+    assert_raise Enum.EmptyError, fn -> Enum.random([]) end
+    assert Enum.random([1]) == 1
+
+    # set a fixed seed so the test can be deterministic
+    # please note the order of following assertions is important
+    seed1 = {1406, 407_414, 139_258}
+    seed2 = {1306, 421_106, 567_597}
+    :rand.seed(:exsss, seed1)
+    assert Enum.random([1, 2]) == 1
+    assert Enum.random([1, 2]) == 2
+    :rand.seed(:exsss, seed1)
+    assert Enum.random([1, 2]) == 1
+    assert Enum.random([1, 2, 3]) == 1
+    assert Enum.random([1, 2, 3, 4]) == 2
+    assert Enum.random([1, 2, 3, 4, 5]) == 3
+    :rand.seed(:exsss, seed2)
+    assert Enum.random([1, 2]) == 1
+    assert Enum.random([1, 2, 3]) == 2
+    assert Enum.random([1, 2, 3, 4]) == 4
+    assert Enum.random([1, 2, 3, 4, 5]) == 3
+  end
+
+  test "random/1 with streams" do
+    random_stream = fn list -> list |> Stream.map(& &1) |> Enum.random() end
+
+    assert_raise Enum.EmptyError, fn -> random_stream.([]) end
+    assert random_stream.([1]) == 1
+
+    seed = {1406, 407_414, 139_258}
+    :rand.seed(:exsss, seed)
+
+    assert random_stream.([1, 2]) == 2
+    assert random_stream.([1, 2, 3]) == 3
+    assert random_stream.([1, 2, 3, 4]) == 1
+    assert random_stream.([1, 2, 3, 4, 5]) == 3
+  end
+
+  test "reduce/2" do
+    assert Enum.reduce([1, 2, 3], fn x, acc -> x + acc end) == 6
+
+    assert_raise Enum.EmptyError, fn ->
+      Enum.reduce([], fn x, acc -> x + acc end)
+    end
+
+    assert_raise Enum.EmptyError, fn ->
+      Enum.reduce(%{}, fn _, acc -> acc end)
+    end
+  end
+
+  test "reduce/3" do
+    assert Enum.reduce([], 1, fn x, acc -> x + acc end) == 1
+    assert Enum.reduce([1, 2, 3], 1, fn x, acc -> x + acc end) == 7
+  end
+
+  test "reduce/3 with streams" do
+    reduce_stream = fn list, acc, fun -> list |> Stream.map(& &1) |> Enum.reduce(acc, fun) end
+
+    assert reduce_stream.([], 1, fn x, acc -> x + acc end) == 1
+    assert reduce_stream.([1, 2, 3], 1, fn x, acc -> x + acc end) == 7
+  end
+
+  test "reduce_while/3" do
+    assert Enum.reduce_while([1, 2, 3], 1, fn i, acc -> {:cont, acc + i} end) == 7
+    assert Enum.reduce_while([1, 2, 3], 1, fn _i, acc -> {:halt, acc} end) == 1
+    assert Enum.reduce_while([], 0, fn _i, acc -> {:cont, acc} end) == 0
+  end
+
+  test "reject/2" do
+    assert Enum.reject([1, 2, 3], fn x -> rem(x, 2) == 0 end) == [1, 3]
+    assert Enum.reject([2, 4, 6], fn x -> rem(x, 2) == 0 end) == []
+    assert Enum.reject([1, true, nil, false, 2], & &1) == [nil, false]
+  end
+
+  test "reverse/1" do
     assert Enum.reverse([]) == []
     assert Enum.reverse([1, 2, 3]) == [3, 2, 1]
+    assert Enum.reverse([5..5]) == [5..5]
+  end
+
+  test "reverse/2" do
     assert Enum.reverse([1, 2, 3], [4, 5, 6]) == [3, 2, 1, 4, 5, 6]
+    assert Enum.reverse([1, 2, 3], []) == [3, 2, 1]
+    assert Enum.reverse([5..5], [5]) == [5..5, 5]
+  end
+
+  test "reverse_slice/3" do
+    assert Enum.reverse_slice([], 1, 2) == []
+    assert Enum.reverse_slice([1, 2, 3], 0, 0) == [1, 2, 3]
+    assert Enum.reverse_slice([1, 2, 3], 0, 1) == [1, 2, 3]
+    assert Enum.reverse_slice([1, 2, 3], 0, 2) == [2, 1, 3]
+    assert Enum.reverse_slice([1, 2, 3], 0, 20_000_000) == [3, 2, 1]
+    assert Enum.reverse_slice([1, 2, 3], 100, 2) == [1, 2, 3]
+    assert Enum.reverse_slice([1, 2, 3], 10, 10) == [1, 2, 3]
+  end
+
+  describe "slide/3" do
+    test "on an empty enum produces an empty list" do
+      for enum <- [[], %{}, 0..-1//1, MapSet.new()] do
+        assert Enum.slide(enum, 0..0, 0) == []
+        assert Enum.slide(enum, 1..1, 2) == []
+      end
+    end
+
+    test "on a single-element enumerable is the same as transforming to list" do
+      for enum <- [["foo"], [1], [%{foo: "bar"}], %{foo: :bar}, MapSet.new(["foo"]), 1..1] do
+        assert Enum.slide(enum, 0..0, 0) == Enum.to_list(enum)
+      end
+    end
+
+    test "moves a single element" do
+      for zero_to_20 <- [0..20, Enum.to_list(0..20)] do
+        expected_numbers = Enum.flat_map([0..7, [14], 8..13, 15..20], &Enum.to_list/1)
+        assert Enum.slide(zero_to_20, 14..14, 8) == expected_numbers
+      end
+
+      assert Enum.slide([:a, :b, :c, :d, :e, :f], 3..3, 2) == [:a, :b, :d, :c, :e, :f]
+      assert Enum.slide([:a, :b, :c, :d, :e, :f], 3, 3) == [:a, :b, :c, :d, :e, :f]
+    end
+
+    test "on a subsection of a list reorders the range correctly" do
+      for zero_to_20 <- [0..20, Enum.to_list(0..20)] do
+        expected_numbers = Enum.flat_map([0..7, 14..18, 8..13, 19..20], &Enum.to_list/1)
+        assert Enum.slide(zero_to_20, 14..18, 8) == expected_numbers
+      end
+
+      assert Enum.slide([:a, :b, :c, :d, :e, :f], 3..4, 2) == [:a, :b, :d, :e, :c, :f]
+    end
+
+    test "handles negative indices" do
+      make_negative_range = fn first..last//1, length ->
+        (first - length)..(last - length)//1
+      end
+
+      test_specs = [
+        {[], 0..0, 0},
+        {[1], 0..0, 0},
+        {[-2, 1], 1..1, 1},
+        {[4, -3, 2, -1], 3..3, 2},
+        {[-5, -3, 4, 4, 5], 0..2, 3},
+        {[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 4..7, 9},
+        {[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 4..7, 0}
+      ]
+
+      for {list, range, insertion_point} <- test_specs do
+        negative_range = make_negative_range.(range, length(list))
+
+        assert Enum.slide(list, negative_range, insertion_point) ==
+                 Enum.slide(list, range, insertion_point)
+      end
+    end
+
+    test "handles mixed positive and negative indices" do
+      for zero_to_20 <- [0..20, Enum.to_list(0..20)] do
+        assert Enum.slide(zero_to_20, -6..-1, 8) ==
+                 Enum.slide(zero_to_20, 15..20, 8)
+
+        assert Enum.slide(zero_to_20, 15..-1//1, 8) ==
+                 Enum.slide(zero_to_20, 15..20, 8)
+
+        assert Enum.slide(zero_to_20, -6..20, 8) ==
+                 Enum.slide(zero_to_20, 15..20, 8)
+
+        assert Enum.slide(zero_to_20, -100..5, 8) ==
+                 Enum.slide(zero_to_20, 0..5, 8)
+      end
+    end
+
+    test "raises an error when the step is not exactly 1" do
+      slide_ranges_that_should_fail = [2..10//2, 8..-1//-1, 10..2//-1, 10..4//-2, -1..-8//-1]
+
+      for zero_to_20 <- [0..20, Enum.to_list(0..20)],
+          range_that_should_fail <- slide_ranges_that_should_fail do
+        assert_raise(ArgumentError, fn ->
+          Enum.slide(zero_to_20, range_that_should_fail, 1)
+        end)
+      end
+    end
+
+    test "doesn't change the order when the first and middle indices match" do
+      for zero_to_20 <- [0..20, Enum.to_list(0..20)] do
+        assert Enum.slide(zero_to_20, 8..18, 8) == Enum.to_list(0..20)
+      end
+
+      assert Enum.slide([:a, :b, :c, :d, :e, :f], 1..3, 1) == [:a, :b, :c, :d, :e, :f]
+    end
+
+    test "on the whole of an enumerable reorders it correctly" do
+      for zero_to_20 <- [0..20, Enum.to_list(0..20)] do
+        expected_numbers = Enum.flat_map([10..20, 0..9], &Enum.to_list/1)
+        assert Enum.slide(zero_to_20, 10..20, 0) == expected_numbers
+      end
+
+      assert Enum.slide([:a, :b, :c, :d, :e, :f], 4..5, 0) == [:e, :f, :a, :b, :c, :d]
+    end
+
+    test "raises when the insertion point is inside the range" do
+      for zero_to_20 <- [0..20, Enum.to_list(0..20)] do
+        assert_raise ArgumentError, fn ->
+          Enum.slide(zero_to_20, 10..18, 14)
+        end
+      end
+    end
+
+    test "accepts range starts that are off the end of the enum, returning the input list" do
+      assert Enum.slide([], 1..5, 0) == []
+
+      for zero_to_20 <- [0..20, Enum.to_list(0..20)] do
+        assert Enum.slide(zero_to_20, 21..25, 3) == Enum.to_list(0..20)
+      end
+    end
+
+    test "accepts range ends that are off the end of the enum, truncating the moved range" do
+      for zero_to_10 <- [0..10, Enum.to_list(0..10)] do
+        assert Enum.slide(zero_to_10, 8..15, 4) == Enum.slide(zero_to_10, 8..10, 4)
+      end
+    end
+
+    test "matches behavior for lists vs. ranges" do
+      range = 0..20
+      list = Enum.to_list(range)
+      # Below 32 elements, the map implementation currently sticks values in order.
+      # If ever the MapSet implementation changes, this will fail (not affecting the correctness
+      # of slide). I figured it'd be worth testing this for the time being just to have
+      # another enumerable (aside from range) testing the generic implementation.
+      set = MapSet.new(list)
+
+      test_specs = [
+        {0..0, 0},
+        {0..0, 20},
+        {11..11, 14},
+        {11..11, 3},
+        {4..8, 19},
+        {4..8, 0},
+        {4..8, 2},
+        {10..20, 0},
+        {2..1//1, -20}
+      ]
+
+      for {slide_range, insertion_point} <- test_specs do
+        slide = &Enum.slide(&1, slide_range, insertion_point)
+        assert slide.(list) == slide.(set)
+        assert slide.(list) == slide.(range)
+      end
+    end
+
+    test "inserts at negative indices" do
+      for zero_to_5 <- [0..5, Enum.to_list(0..5)] do
+        assert Enum.slide(zero_to_5, 0, -1) == [1, 2, 3, 4, 5, 0]
+        assert Enum.slide(zero_to_5, 1, -1) == [0, 2, 3, 4, 5, 1]
+        assert Enum.slide(zero_to_5, 1..2, -2) == [0, 3, 4, 1, 2, 5]
+        assert Enum.slide(zero_to_5, -5..-4//1, -2) == [0, 3, 4, 1, 2, 5]
+      end
+
+      assert Enum.slide([:a, :b, :c, :d, :e, :f], -5..-3//1, -2) ==
+               Enum.slide([:a, :b, :c, :d, :e, :f], 1..3, 4)
+    end
+
+    test "raises when insertion index would fall inside the range" do
+      for zero_to_5 <- [0..5, Enum.to_list(0..5)] do
+        assert_raise ArgumentError, fn ->
+          Enum.slide(zero_to_5, 2..3, -3)
+        end
+      end
+
+      for zero_to_10 <- [0..10, Enum.to_list(0..10)],
+          insertion_idx <- 3..5 do
+        assert_raise ArgumentError, fn ->
+          assert Enum.slide(zero_to_10, 2..5, insertion_idx)
+        end
+      end
+    end
   end
 
-  test :scan do
-    assert Enum.scan([1,2,3,4,5], &(&1 + &2)) == [1,3,6,10,15]
+  test "scan/2" do
+    assert Enum.scan([1, 2, 3, 4, 5], &(&1 + &2)) == [1, 3, 6, 10, 15]
     assert Enum.scan([], &(&1 + &2)) == []
+  end
 
-    assert Enum.scan([1,2,3,4,5], 0, &(&1 + &2)) == [1,3,6,10,15]
+  test "scan/3" do
+    assert Enum.scan([1, 2, 3, 4, 5], 0, &(&1 + &2)) == [1, 3, 6, 10, 15]
     assert Enum.scan([], 0, &(&1 + &2)) == []
   end
 
-  test :shuffle do
+  test "shuffle/1" do
     # set a fixed seed so the test can be deterministic
-    :random.seed(1374, 347975, 449264)
-    assert Enum.shuffle([1, 2, 3, 4, 5]) == [2, 4, 1, 5, 3]
+    :rand.seed(:exsss, {1374, 347_975, 449_264})
+    assert Enum.shuffle([1, 2, 3, 4, 5]) == [2, 5, 4, 3, 1]
+  end
+
+  test "slice/2" do
+    list = [1, 2, 3, 4, 5]
+    assert Enum.slice(list, 0..0) == [1]
+    assert Enum.slice(list, 0..1) == [1, 2]
+    assert Enum.slice(list, 0..2) == [1, 2, 3]
+
+    assert Enum.slice(list, 0..10//2) == [1, 3, 5]
+    assert Enum.slice(list, 0..10//3) == [1, 4]
+    assert Enum.slice(list, 0..10//4) == [1, 5]
+    assert Enum.slice(list, 0..10//5) == [1]
+    assert Enum.slice(list, 0..10//6) == [1]
+
+    assert Enum.slice(list, 0..2//2) == [1, 3]
+    assert Enum.slice(list, 0..2//3) == [1]
+
+    assert Enum.slice(list, 0..-1//2) == [1, 3, 5]
+    assert Enum.slice(list, 0..-1//3) == [1, 4]
+    assert Enum.slice(list, 0..-1//4) == [1, 5]
+    assert Enum.slice(list, 0..-1//5) == [1]
+    assert Enum.slice(list, 0..-1//6) == [1]
+
+    assert Enum.slice(list, 1..-1//2) == [2, 4]
+    assert Enum.slice(list, 1..-1//3) == [2, 5]
+    assert Enum.slice(list, 1..-1//4) == [2]
+    assert Enum.slice(list, 1..-1//5) == [2]
+
+    assert Enum.slice(list, -4..-1//2) == [2, 4]
+    assert Enum.slice(list, -4..-1//3) == [2, 5]
+    assert Enum.slice(list, -4..-1//4) == [2]
+    assert Enum.slice(list, -4..-1//5) == [2]
+  end
+
+  test "slice/3" do
+    list = [1, 2, 3, 4, 5]
+    assert Enum.slice(list, 0, 0) == []
+    assert Enum.slice(list, 0, 1) == [1]
+    assert Enum.slice(list, 0, 2) == [1, 2]
+    assert Enum.slice(list, 1, 2) == [2, 3]
+    assert Enum.slice(list, 1, 0) == []
+    assert Enum.slice(list, 2, 5) == [3, 4, 5]
+    assert Enum.slice(list, 2, 6) == [3, 4, 5]
+    assert Enum.slice(list, 5, 5) == []
+    assert Enum.slice(list, 6, 5) == []
+    assert Enum.slice(list, 6, 0) == []
+    assert Enum.slice(list, -6, 0) == []
+    assert Enum.slice(list, -6, 5) == [1, 2, 3, 4, 5]
+    assert Enum.slice(list, -2, 5) == [4, 5]
+    assert Enum.slice(list, -3, 1) == [3]
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(list, 0, -1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(list, 0.99, 0)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(list, 0, 0.99)
+    end
+  end
+
+  test "slice on infinite streams" do
+    assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0, 2) == [1, 2]
+    assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0, 5) == [1, 2, 3, 1, 2]
+    assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0..1) == [1, 2]
+    assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0..4) == [1, 2, 3, 1, 2]
+    assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0..4//2) == [1, 3, 2]
+    assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(0..5//2) == [1, 3, 2]
+    assert [1, 2, 3] |> Stream.cycle() |> Enum.slice(1..6//2) == [2, 1, 3]
+  end
+
+  test "slice on pruned infinite streams" do
+    assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(0, 2) == [1, 2]
+    assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(0, 5) == [1, 2, 3, 1, 2]
+    assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(0..1) == [1, 2]
+    assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(0..4) == [1, 2, 3, 1, 2]
+    assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(0..4//2) == [1, 3, 2]
+
+    assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(-10..-9//1) ==
+             [1, 2]
+
+    assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(-10..-6//1) ==
+             [1, 2, 3, 1, 2]
+
+    assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(-10..-6//2) ==
+             [1, 3, 2]
+
+    assert [1, 2, 3] |> Stream.cycle() |> Stream.take(10) |> Enum.slice(-9..-5//2) ==
+             [2, 1, 3]
+  end
+
+  test "slice on MapSets" do
+    assert MapSet.new(1..10) |> Enum.slice(0, 2) |> Enum.count() == 2
+    assert MapSet.new(1..3) |> Enum.slice(0, 10) |> Enum.count() == 3
+    assert MapSet.new(1..10) |> Enum.slice(0..1) |> Enum.count() == 2
+    assert MapSet.new(1..3) |> Enum.slice(0..10) |> Enum.count() == 3
+
+    assert MapSet.new(1..10) |> Enum.slice(0..4//2) |> Enum.count() == 3
+    assert MapSet.new(1..10) |> Enum.slice(0..5//2) |> Enum.count() == 3
+  end
+
+  test "sort/1" do
+    assert Enum.sort([5, 3, 2, 4, 1]) == [1, 2, 3, 4, 5]
+  end
+
+  test "sort/2" do
+    assert Enum.sort([5, 3, 2, 4, 1], &(&1 >= &2)) == [5, 4, 3, 2, 1]
+    assert Enum.sort([5, 3, 2, 4, 1], :asc) == [1, 2, 3, 4, 5]
+    assert Enum.sort([5, 3, 2, 4, 1], :desc) == [5, 4, 3, 2, 1]
+
+    assert Enum.sort([3, 2, 1, 3, 2, 3], :asc) == [1, 2, 2, 3, 3, 3]
+    assert Enum.sort([3, 2, 1, 3, 2, 3], :desc) == [3, 3, 3, 2, 2, 1]
+
+    shuffled = Enum.shuffle(1..100)
+    assert Enum.sort(shuffled, :asc) == Enum.to_list(1..100)
+    assert Enum.sort(shuffled, :desc) == Enum.reverse(1..100)
+  end
+
+  test "sort/2 with module" do
+    assert Enum.sort([~D[2020-01-01], ~D[2018-01-01], ~D[2019-01-01]], Date) ==
+             [~D[2018-01-01], ~D[2019-01-01], ~D[2020-01-01]]
+
+    assert Enum.sort([~D[2020-01-01], ~D[2018-01-01], ~D[2019-01-01]], {:asc, Date}) ==
+             [~D[2018-01-01], ~D[2019-01-01], ~D[2020-01-01]]
+
+    assert Enum.sort([~D[2020-01-01], ~D[2018-01-01], ~D[2019-01-01]], {:desc, Date}) ==
+             [~D[2020-01-01], ~D[2019-01-01], ~D[2018-01-01]]
+  end
+
+  test "sort/2 with streams" do
+    sort_stream = fn list, sorter -> list |> Stream.map(& &1) |> Enum.sort(sorter) end
+
+    assert sort_stream.([5, 3, 2, 4, 1], &(&1 >= &2)) == [5, 4, 3, 2, 1]
+    assert sort_stream.([5, 3, 2, 4, 1], :asc) == [1, 2, 3, 4, 5]
+    assert sort_stream.([5, 3, 2, 4, 1], :desc) == [5, 4, 3, 2, 1]
+
+    assert sort_stream.([3, 2, 1, 3, 2, 3], :asc) == [1, 2, 2, 3, 3, 3]
+    assert sort_stream.([3, 2, 1, 3, 2, 3], :desc) == [3, 3, 3, 2, 2, 1]
+
+    shuffled = Enum.shuffle(1..100)
+    assert sort_stream.(shuffled, :asc) == Enum.to_list(1..100)
+    assert sort_stream.(shuffled, :desc) == Enum.reverse(1..100)
+  end
+
+  test "sort_by/3" do
+    collection = [
+      [sorted_data: 4],
+      [sorted_data: 5],
+      [sorted_data: 2],
+      [sorted_data: 1],
+      [sorted_data: 3]
+    ]
+
+    asc = [
+      [sorted_data: 1],
+      [sorted_data: 2],
+      [sorted_data: 3],
+      [sorted_data: 4],
+      [sorted_data: 5]
+    ]
+
+    desc = [
+      [sorted_data: 5],
+      [sorted_data: 4],
+      [sorted_data: 3],
+      [sorted_data: 2],
+      [sorted_data: 1]
+    ]
+
+    assert Enum.sort_by(collection, & &1[:sorted_data]) == asc
+    assert Enum.sort_by(collection, & &1[:sorted_data], :asc) == asc
+    assert Enum.sort_by(collection, & &1[:sorted_data], &>=/2) == desc
+    assert Enum.sort_by(collection, & &1[:sorted_data], :desc) == desc
+  end
+
+  test "sort_by/3 with stable sorting" do
+    collection = [
+      [other_data: 2, sorted_data: 4],
+      [other_data: 1, sorted_data: 5],
+      [other_data: 2, sorted_data: 2],
+      [other_data: 3, sorted_data: 1],
+      [other_data: 4, sorted_data: 3]
+    ]
+
+    # Stable sorting
+    assert Enum.sort_by(collection, & &1[:other_data]) == [
+             [other_data: 1, sorted_data: 5],
+             [other_data: 2, sorted_data: 4],
+             [other_data: 2, sorted_data: 2],
+             [other_data: 3, sorted_data: 1],
+             [other_data: 4, sorted_data: 3]
+           ]
+
+    assert Enum.sort_by(collection, & &1[:other_data]) ==
+             Enum.sort_by(collection, & &1[:other_data], :asc)
+
+    assert Enum.sort_by(collection, & &1[:other_data], &</2) == [
+             [other_data: 1, sorted_data: 5],
+             [other_data: 2, sorted_data: 2],
+             [other_data: 2, sorted_data: 4],
+             [other_data: 3, sorted_data: 1],
+             [other_data: 4, sorted_data: 3]
+           ]
+
+    assert Enum.sort_by(collection, & &1[:other_data], :desc) == [
+             [other_data: 4, sorted_data: 3],
+             [other_data: 3, sorted_data: 1],
+             [other_data: 2, sorted_data: 4],
+             [other_data: 2, sorted_data: 2],
+             [other_data: 1, sorted_data: 5]
+           ]
+  end
+
+  test "sort_by/3 with module" do
+    collection = [
+      [sorted_data: ~D[2010-01-05]],
+      [sorted_data: ~D[2010-01-04]],
+      [sorted_data: ~D[2010-01-03]],
+      [sorted_data: ~D[2010-01-02]],
+      [sorted_data: ~D[2010-01-01]]
+    ]
+
+    assert Enum.sort_by(collection, & &1[:sorted_data], Date) == [
+             [sorted_data: ~D[2010-01-01]],
+             [sorted_data: ~D[2010-01-02]],
+             [sorted_data: ~D[2010-01-03]],
+             [sorted_data: ~D[2010-01-04]],
+             [sorted_data: ~D[2010-01-05]]
+           ]
+
+    assert Enum.sort_by(collection, & &1[:sorted_data], Date) ==
+             assert(Enum.sort_by(collection, & &1[:sorted_data], {:asc, Date}))
+
+    assert Enum.sort_by(collection, & &1[:sorted_data], {:desc, Date}) == [
+             [sorted_data: ~D[2010-01-05]],
+             [sorted_data: ~D[2010-01-04]],
+             [sorted_data: ~D[2010-01-03]],
+             [sorted_data: ~D[2010-01-02]],
+             [sorted_data: ~D[2010-01-01]]
+           ]
+  end
+
+  test "sort_by/3 with module and stable sorting" do
+    collection = [
+      [other_data: ~D[2010-01-02], sorted_data: 4],
+      [other_data: ~D[2010-01-01], sorted_data: 5],
+      [other_data: ~D[2010-01-02], sorted_data: 2],
+      [other_data: ~D[2010-01-03], sorted_data: 1],
+      [other_data: ~D[2010-01-04], sorted_data: 3]
+    ]
+
+    # Stable sorting
+    assert Enum.sort_by(collection, & &1[:other_data], Date) == [
+             [other_data: ~D[2010-01-01], sorted_data: 5],
+             [other_data: ~D[2010-01-02], sorted_data: 4],
+             [other_data: ~D[2010-01-02], sorted_data: 2],
+             [other_data: ~D[2010-01-03], sorted_data: 1],
+             [other_data: ~D[2010-01-04], sorted_data: 3]
+           ]
+
+    assert Enum.sort_by(collection, & &1[:other_data], Date) ==
+             Enum.sort_by(collection, & &1[:other_data], {:asc, Date})
+
+    assert Enum.sort_by(collection, & &1[:other_data], {:desc, Date}) == [
+             [other_data: ~D[2010-01-04], sorted_data: 3],
+             [other_data: ~D[2010-01-03], sorted_data: 1],
+             [other_data: ~D[2010-01-02], sorted_data: 4],
+             [other_data: ~D[2010-01-02], sorted_data: 2],
+             [other_data: ~D[2010-01-01], sorted_data: 5]
+           ]
+  end
+
+  test "split/2" do
+    assert Enum.split([1, 2, 3], 0) == {[], [1, 2, 3]}
+    assert Enum.split([1, 2, 3], 1) == {[1], [2, 3]}
+    assert Enum.split([1, 2, 3], 2) == {[1, 2], [3]}
+    assert Enum.split([1, 2, 3], 3) == {[1, 2, 3], []}
+    assert Enum.split([1, 2, 3], 4) == {[1, 2, 3], []}
+    assert Enum.split([], 3) == {[], []}
+    assert Enum.split([1, 2, 3], -1) == {[1, 2], [3]}
+    assert Enum.split([1, 2, 3], -2) == {[1], [2, 3]}
+    assert Enum.split([1, 2, 3], -3) == {[], [1, 2, 3]}
+    assert Enum.split([1, 2, 3], -10) == {[], [1, 2, 3]}
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.split([1, 2, 3], 0.0)
+    end
+  end
+
+  test "split_while/2" do
+    assert Enum.split_while([1, 2, 3], fn _ -> false end) == {[], [1, 2, 3]}
+    assert Enum.split_while([1, 2, 3], fn _ -> true end) == {[1, 2, 3], []}
+    assert Enum.split_while([1, 2, 3], fn x -> x > 2 end) == {[], [1, 2, 3]}
+    assert Enum.split_while([1, 2, 3], fn x -> x > 3 end) == {[], [1, 2, 3]}
+    assert Enum.split_while([1, 2, 3], fn x -> x < 3 end) == {[1, 2], [3]}
+    assert Enum.split_while([], fn _ -> true end) == {[], []}
+  end
+
+  test "sum/1" do
+    assert Enum.sum([]) == 0
+    assert Enum.sum([1]) == 1
+    assert Enum.sum([1, 2, 3]) == 6
+    assert Enum.sum([1.1, 2.2, 3.3]) == 6.6
+    assert Enum.sum([-3, -2, -1, 0, 1, 2, 3]) == 0
+    assert Enum.sum(42..42) == 42
+    assert Enum.sum(11..17) == 98
+    assert Enum.sum(17..11//-1) == 98
+    assert Enum.sum(11..-17//-1) == Enum.sum(-17..11)
+
+    assert_raise ArithmeticError, fn ->
+      Enum.sum([{}])
+    end
+
+    assert_raise ArithmeticError, fn ->
+      Enum.sum([1, {}])
+    end
   end
 
-  test :sort do
-    assert Enum.sort([5, 3, 2, 4, 1]) == [1, 2, 3, 4, 5]
-    assert Enum.sort([5, 3, 2, 4, 1], &(&1 > &2)) == [5, 4, 3, 2, 1]
+  test "sum_by/2" do
+    assert Enum.sum_by([], &hd/1) == 0
+    assert Enum.sum_by([[1]], &hd/1) == 1
+    assert Enum.sum_by([[1], [2], [3]], &hd/1) == 6
+    assert Enum.sum_by([[1.1], [2.2], [3.3]], &hd/1) == 6.6
+    assert Enum.sum_by([[-3], [-2], [-1], [0], [1], [2], [3]], &hd/1) == 0
+
+    assert Enum.sum_by(1..3, &(&1 ** 2)) == 14
+
+    assert_raise ArithmeticError, fn ->
+      Enum.sum_by([[{}]], &hd/1)
+    end
+
+    assert_raise ArithmeticError, fn ->
+      Enum.sum_by([[1], [{}]], &hd/1)
+    end
+  end
+
+  test "product/1" do
+    assert Enum.product([]) == 1
+    assert Enum.product([1]) == 1
+    assert Enum.product([1, 2, 3, 4, 5]) == 120
+    assert Enum.product([1, -2, 3, 4, 5]) == -120
+    assert Enum.product(1..5) == 120
+    assert Enum.product(11..-17//-1) == Enum.product(-17..11)
+
+    assert_raise ArithmeticError, fn ->
+      Enum.product([{}])
+    end
+
+    assert_raise ArithmeticError, fn ->
+      Enum.product([1, {}])
+    end
+
+    assert_raise ArithmeticError, fn ->
+      Enum.product(%{a: 1, b: 2})
+    end
   end
 
-  test :split do
-    assert Enum.split([1, 2, 3], 0) == {[], [1, 2, 3]}
-    assert Enum.split([1, 2, 3], 1) == {[1], [2, 3]}
-    assert Enum.split([1, 2, 3], 2) == {[1, 2], [3]}
-    assert Enum.split([1, 2, 3], 3) == {[1, 2, 3], []}
-    assert Enum.split([1, 2, 3], 4) == {[1, 2, 3], []}
-    assert Enum.split([], 3) == {[], []}
-    assert Enum.split([1, 2, 3], -1) == {[1, 2], [3]}
-    assert Enum.split([1, 2, 3], -2) == {[1], [2, 3]}
-    assert Enum.split([1, 2, 3], -3) == {[], [1, 2, 3]}
-    assert Enum.split([1, 2, 3], -10) == {[], [1, 2, 3]}
-  end
+  test "product_by/2" do
+    assert Enum.product_by([], &hd/1) == 1
+    assert Enum.product_by([[1]], &hd/1) == 1
+    assert Enum.product_by([[1], [2], [3], [4], [5]], &hd/1) == 120
+    assert Enum.product_by([[1], [-2], [3], [4], [5]], &hd/1) == -120
+    assert Enum.product_by(1..5, & &1) == 120
+    assert Enum.product_by(11..-17//-1, & &1) == 0
 
-  test :split_while do
-    assert Enum.split_while([1, 2, 3], fn(_) -> false end) == {[], [1, 2, 3]}
-    assert Enum.split_while([1, 2, 3], fn(_) -> true end) == {[1, 2, 3], []}
-    assert Enum.split_while([1, 2, 3], fn(x) -> x > 2 end) == {[], [1, 2, 3]}
-    assert Enum.split_while([1, 2, 3], fn(x) -> x > 3 end) == {[], [1, 2, 3]}
-    assert Enum.split_while([1, 2, 3], fn(x) -> x < 3 end) == {[1, 2], [3]}
-    assert Enum.split_while([], fn(_) -> true end) == {[], []}
-  end
+    assert_raise ArithmeticError, fn ->
+      Enum.product_by([[{}]], &hd/1)
+    end
 
-  test :sum do
-    assert Enum.sum([]) == 0
-    assert Enum.sum([1]) == 1
-    assert Enum.sum([1, 2, 3]) == 6
-    assert Enum.sum([1.1, 2.2, 3.3]) == 6.6
     assert_raise ArithmeticError, fn ->
-      Enum.sum([{}])
+      Enum.product_by([[1], [{}]], &hd/1)
     end
+
     assert_raise ArithmeticError, fn ->
-      Enum.sum([1,{}])
+      Enum.product_by(%{a: 1, b: 2}, & &1)
     end
   end
 
-  test :take do
+  test "take/2" do
     assert Enum.take([1, 2, 3], 0) == []
     assert Enum.take([1, 2, 3], 1) == [1]
     assert Enum.take([1, 2, 3], 2) == [1, 2]
@@ -325,178 +1517,480 @@ defmodule EnumTest.List do
     assert Enum.take([1, 2, 3], -2) == [2, 3]
     assert Enum.take([1, 2, 3], -4) == [1, 2, 3]
     assert Enum.take([], 3) == []
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.take([1, 2, 3], 0.0)
+    end
   end
 
-  test :take_every do
+  test "take_every/2" do
     assert Enum.take_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2) == [1, 3, 5, 7, 9]
+    assert Enum.take_every([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3) == [1, 4, 7, 10]
     assert Enum.take_every([], 2) == []
     assert Enum.take_every([1, 2], 2) == [1]
     assert Enum.take_every([1, 2, 3], 0) == []
+    assert Enum.take_every(1..3, 1) == [1, 2, 3]
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.take_every([1, 2, 3], -1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.take_every(1..10, 3.33)
+    end
+  end
+
+  test "take_random/2" do
+    assert Enum.take_random(-42..-42, 1) == [-42]
+
+    # corner cases, independent of the seed
+    assert_raise FunctionClauseError, fn -> Enum.take_random([1, 2], -1) end
+    assert Enum.take_random([], 0) == []
+    assert Enum.take_random([], 3) == []
+    assert Enum.take_random([1], 0) == []
+    assert Enum.take_random([1], 2) == [1]
+    assert Enum.take_random([1, 2], 0) == []
+
+    # set a fixed seed so the test can be deterministic
+    # please note the order of following assertions is important
+    seed1 = {1406, 407_414, 139_258}
+    seed2 = {1406, 421_106, 567_597}
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random([1, 2, 3], 1) == [2]
+    assert Enum.take_random([1, 2, 3], 2) == [2, 3]
+    assert Enum.take_random([1, 2, 3], 3) == [3, 1, 2]
+    assert Enum.take_random([1, 2, 3], 4) == [2, 3, 1]
+    :rand.seed(:exsss, seed2)
+    assert Enum.take_random([1, 2, 3], 1) == [1]
+    assert Enum.take_random([1, 2, 3], 2) == [3, 1]
+    assert Enum.take_random([1, 2, 3], 3) == [2, 3, 1]
+    assert Enum.take_random([1, 2, 3], 4) == [3, 2, 1]
+    assert Enum.take_random([1, 2, 3], 129) == [2, 1, 3]
+
+    # assert that every item in the sample comes from the input list
+    list = for _ <- 1..100, do: make_ref()
+
+    for x <- Enum.take_random(list, 50) do
+      assert x in list
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.take_random(1..10, -1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.take_random(1..10, 10.0)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.take_random(1..10, 128.1)
+    end
   end
 
-  test :take_while do
-    assert Enum.take_while([1, 2, 3], fn(x) -> x > 3 end) == []
-    assert Enum.take_while([1, 2, 3], fn(x) -> x <= 1 end) == [1]
-    assert Enum.take_while([1, 2, 3], fn(x) -> x <= 3 end) == [1, 2, 3]
-    assert Enum.take_while([], fn(_) -> true end) == []
+  test "take_while/2" do
+    assert Enum.take_while([1, 2, 3], fn x -> x > 3 end) == []
+    assert Enum.take_while([1, 2, 3], fn x -> x <= 1 end) == [1]
+    assert Enum.take_while([1, 2, 3], fn x -> x <= 3 end) == [1, 2, 3]
+    assert Enum.take_while([], fn _ -> true end) == []
   end
 
-  test :to_list do
+  test "to_list/1" do
     assert Enum.to_list([]) == []
-    assert Enum.to_list(1 .. 3) == [1, 2, 3]
   end
 
-  test :traverse do
-    assert Enum.traverse([1, 2, 3], &(&1 * &1)) == [1, 4, 9]
-    assert Enum.traverse(%{a: 1, b: 2}, fn {k, v} -> {k, v*2} end) == %{a: 2, b: 4}
+  test "uniq/1" do
+    assert Enum.uniq([5, 1, 2, 3, 2, 1]) == [5, 1, 2, 3]
+  end
+
+  test "uniq_by/2" do
+    assert Enum.uniq_by([1, 2, 3, 2, 1], fn x -> x end) == [1, 2, 3]
+  end
+
+  test "unzip/1" do
+    assert Enum.unzip([{:a, 1}, {:b, 2}, {:c, 3}]) == {[:a, :b, :c], [1, 2, 3]}
+    assert Enum.unzip([]) == {[], []}
+    assert Enum.unzip(%{a: 1}) == {[:a], [1]}
+    assert Enum.unzip(foo: "a", bar: "b") == {[:foo, :bar], ["a", "b"]}
+
+    assert_raise FunctionClauseError, fn -> Enum.unzip([{:a, 1}, {:b, 2, "foo"}]) end
+    assert_raise FunctionClauseError, fn -> Enum.unzip([{1, 2, {3, {4, 5}}}]) end
+    assert_raise FunctionClauseError, fn -> Enum.unzip([1, 2, 3]) end
   end
 
-  test :uniq do
-    assert Enum.uniq([1, 2, 3, 2, 1]) == [1, 2, 3]
-    assert Enum.uniq([1, 2, 3, 2, 1], fn x -> x end) == [1, 2, 3]
+  test "with_index/2" do
+    assert Enum.with_index([]) == []
+    assert Enum.with_index([1, 2, 3]) == [{1, 0}, {2, 1}, {3, 2}]
+    assert Enum.with_index([1, 2, 3], 10) == [{1, 10}, {2, 11}, {3, 12}]
+
+    assert Enum.with_index([1, 2, 3], fn element, index -> {index, element} end) ==
+             [{0, 1}, {1, 2}, {2, 3}]
+
+    assert Enum.with_index(1..0//1) == []
+    assert Enum.with_index(1..3) == [{1, 0}, {2, 1}, {3, 2}]
+    assert Enum.with_index(1..3, 10) == [{1, 10}, {2, 11}, {3, 12}]
+
+    assert Enum.with_index(1..3, fn element, index -> {index, element} end) ==
+             [{0, 1}, {1, 2}, {2, 3}]
   end
 
-  test :zip do
+  test "zip/2" do
     assert Enum.zip([:a, :b], [1, 2]) == [{:a, 1}, {:b, 2}]
     assert Enum.zip([:a, :b], [1, 2, 3, 4]) == [{:a, 1}, {:b, 2}]
     assert Enum.zip([:a, :b, :c, :d], [1, 2]) == [{:a, 1}, {:b, 2}]
+
     assert Enum.zip([], [1]) == []
     assert Enum.zip([1], []) == []
-    assert Enum.zip([], [])  == []
+    assert Enum.zip([], []) == []
   end
 
-  test :with_index do
-    assert Enum.with_index([]) == []
-    assert Enum.with_index([1,2,3]) == [{1,0},{2,1},{3,2}]
-  end
+  test "zip/2 with infinite streams" do
+    assert Enum.zip([], Stream.cycle([1, 2])) == []
+    assert Enum.zip([], Stream.cycle(1..2)) == []
+    assert Enum.zip(.., Stream.cycle([1, 2])) == []
+    assert Enum.zip(.., Stream.cycle(1..2)) == []
 
-  test :max do
-    assert Enum.max([1]) == 1
-    assert Enum.max([1, 2, 3]) == 3
-    assert Enum.max([1, [], :a, {}]) == []
-    assert_raise Enum.EmptyError, fn ->
-      Enum.max([])
-    end
+    assert Enum.zip(Stream.cycle([1, 2]), ..) == []
+    assert Enum.zip(Stream.cycle(1..2), ..) == []
+    assert Enum.zip(Stream.cycle([1, 2]), ..) == []
+    assert Enum.zip(Stream.cycle(1..2), ..) == []
   end
 
-  test :max_by do
-    assert Enum.max_by(["a", "aa", "aaa"], fn(x) -> String.length(x) end) == "aaa"
-    assert_raise Enum.EmptyError, fn ->
-      Enum.max_by([], fn(x) -> String.length(x) end)
-    end
-  end
+  test "zip/1" do
+    assert Enum.zip([[:a, :b], [1, 2], ["foo", "bar"]]) == [{:a, 1, "foo"}, {:b, 2, "bar"}]
 
-  test :min do
-    assert Enum.min([1]) == 1
-    assert Enum.min([1, 2, 3]) == 1
-    assert Enum.min([[], :a, {}]) == :a
-    assert_raise Enum.EmptyError, fn ->
-      Enum.min([])
-    end
-  end
+    assert Enum.zip([[:a, :b], [1, 2, 3, 4], ["foo", "bar", "baz", "qux"]]) ==
+             [{:a, 1, "foo"}, {:b, 2, "bar"}]
 
-  test :min_by do
-    assert Enum.min_by(["a", "aa", "aaa"], fn(x) -> String.length(x) end) == "a"
-    assert_raise Enum.EmptyError, fn ->
-      Enum.min_by([], fn(x) -> String.length(x) end)
-    end
-  end
+    assert Enum.zip([[:a, :b, :c, :d], [1, 2], ["foo", "bar", "baz", "qux"]]) ==
+             [{:a, 1, "foo"}, {:b, 2, "bar"}]
+
+    assert Enum.zip([[:a, :b, :c, :d], [1, 2, 3, 4], ["foo", "bar"]]) ==
+             [{:a, 1, "foo"}, {:b, 2, "bar"}]
+
+    assert Enum.zip([1..10, ["foo", "bar"]]) == [{1, "foo"}, {2, "bar"}]
 
-  test :chunk do
-    assert Enum.chunk([1, 2, 3, 4, 5], 2) == [[1, 2], [3, 4]]
-    assert Enum.chunk([1, 2, 3, 4, 5], 2, 2, [6]) == [[1, 2], [3, 4], [5, 6]]
-    assert Enum.chunk([1, 2, 3, 4, 5, 6], 3, 2) == [[1, 2, 3], [3, 4, 5]]
-    assert Enum.chunk([1, 2, 3, 4, 5, 6], 2, 3) == [[1, 2], [4, 5]]
-    assert Enum.chunk([1, 2, 3, 4, 5, 6], 3, 2, []) == [[1, 2, 3], [3, 4, 5], [5, 6]]
-    assert Enum.chunk([1, 2, 3, 4, 5, 6], 3, 3, []) == [[1, 2, 3], [4, 5, 6]]
-    assert Enum.chunk([1, 2, 3, 4, 5], 4, 4, 6..10) == [[1, 2, 3, 4], [5, 6, 7, 8]]
+    assert Enum.zip([]) == []
+    assert Enum.zip([[]]) == []
+    assert Enum.zip([[1]]) == [{1}]
+
+    assert Enum.zip([[], [], [], []]) == []
+    assert Enum.zip(%{}) == []
   end
 
-  test :chunk_by do
-    assert Enum.chunk_by([1, 2, 2, 3, 4, 4, 6, 7, 7], &(rem(&1, 2) == 1)) == [[1], [2, 2], [3], [4, 4, 6], [7, 7]]
-    assert Enum.chunk_by([1, 2, 3, 4], fn _ -> true end) == [[1, 2, 3, 4]]
-    assert Enum.chunk_by([], fn _ -> true end) == []
-    assert Enum.chunk_by([1], fn _ -> true end) == [[1]]
+  test "zip_with/3" do
+    assert Enum.zip_with([1, 2], [3, 4], fn a, b -> a * b end) == [3, 8]
+    assert Enum.zip_with([:a, :b], [1, 2], &{&1, &2}) == [{:a, 1}, {:b, 2}]
+    assert Enum.zip_with([:a, :b], [1, 2, 3, 4], &{&1, &2}) == [{:a, 1}, {:b, 2}]
+    assert Enum.zip_with([:a, :b, :c, :d], [1, 2], &{&1, &2}) == [{:a, 1}, {:b, 2}]
+    assert Enum.zip_with([], [1], &{&1, &2}) == []
+    assert Enum.zip_with([1], [], &{&1, &2}) == []
+    assert Enum.zip_with([], [], &{&1, &2}) == []
+
+    # Ranges
+    assert Enum.zip_with(1..6, 3..4, fn a, b -> a + b end) == [4, 6]
+    assert Enum.zip_with([1, 2, 5, 6], 3..4, fn a, b -> a + b end) == [4, 6]
+    assert Enum.zip_with(fn _, _ -> {:cont, [1, 2]} end, 3..4, fn a, b -> a + b end) == [4, 6]
+    assert Enum.zip_with(1..1, 0..0, fn a, b -> a + b end) == [1]
+
+    # Date.range
+    week_1 = Date.range(~D[2020-10-12], ~D[2020-10-16])
+    week_2 = Date.range(~D[2020-10-19], ~D[2020-10-23])
+
+    result =
+      Enum.zip_with(week_1, week_2, fn a, b ->
+        Date.day_of_week(a) + Date.day_of_week(b)
+      end)
+
+    assert result == [2, 4, 6, 8, 10]
+
+    # Maps
+    result = Enum.zip_with(%{a: 7}, 3..4, fn {key, value}, b -> {key, value + b} end)
+    assert result == [a: 10]
+
+    result = Enum.zip_with(3..4, %{a: 7}, fn a, {key, value} -> {key, value + a} end)
+    assert result == [a: 10]
   end
 
-  test :slice do
-    assert Enum.slice([1,2,3,4,5], 0, 0) == []
-    assert Enum.slice([1,2,3,4,5], 0, 1) == [1]
-    assert Enum.slice([1,2,3,4,5], 0, 2) == [1, 2]
-    assert Enum.slice([1,2,3,4,5], 1, 2) == [2, 3]
-    assert Enum.slice([1,2,3,4,5], 1, 0) == []
-    assert Enum.slice([1,2,3,4,5], 2, 5) == [3, 4, 5]
-    assert Enum.slice([1,2,3,4,5], 2, 6) == [3, 4, 5]
-    assert Enum.slice([1,2,3,4,5], 5, 5) == []
-    assert Enum.slice([1,2,3,4,5], 6, 5) == []
-    assert Enum.slice([1,2,3,4,5], 6, 0) == []
-    assert Enum.slice([1,2,3,4,5], -6, 0) == []
-    assert Enum.slice([1,2,3,4,5], -6, 5) == []
-    assert Enum.slice([1,2,3,4,5], -2, 5) == [4, 5]
-    assert Enum.slice([1,2,3,4,5], -3, 1) == [3]
-  end
-
-  test :slice_range do
-    assert Enum.slice([1,2,3,4,5], 0..0) == [1]
-    assert Enum.slice([1,2,3,4,5], 0..1) == [1, 2]
-    assert Enum.slice([1,2,3,4,5], 0..2) == [1, 2, 3]
-    assert Enum.slice([1,2,3,4,5], 1..2) == [2, 3]
-    assert Enum.slice([1,2,3,4,5], 1..0) == []
-    assert Enum.slice([1,2,3,4,5], 2..5) == [3, 4, 5]
-    assert Enum.slice([1,2,3,4,5], 2..6) == [3, 4, 5]
-    assert Enum.slice([1,2,3,4,5], 4..4) == [5]
-    assert Enum.slice([1,2,3,4,5], 5..5) == []
-    assert Enum.slice([1,2,3,4,5], 6..5) == []
-    assert Enum.slice([1,2,3,4,5], 6..0) == []
-    assert Enum.slice([1,2,3,4,5], -6..0) == []
-    assert Enum.slice([1,2,3,4,5], -6..5) == []
-    assert Enum.slice([1,2,3,4,5], -5..-1) == [1, 2, 3, 4, 5]
-    assert Enum.slice([1,2,3,4,5], -5..-3) == [1, 2, 3]
-    assert Enum.slice([1,2,3,4,5], -6..-1) == []
-    assert Enum.slice([1,2,3,4,5], -6..-3) == []
+  test "zip_with/2" do
+    zip_fun = fn items -> List.to_tuple(items) end
+    result = Enum.zip_with([[:a, :b], [1, 2], ["foo", "bar"]], zip_fun)
+    assert result == [{:a, 1, "foo"}, {:b, 2, "bar"}]
+
+    map = %{a: :b, c: :d}
+    [x1, x2] = Map.to_list(map)
+    lots = Enum.zip_with([[:a, :b], [1, 2], ["foo", "bar"], map], zip_fun)
+    assert lots == [{:a, 1, "foo", x1}, {:b, 2, "bar", x2}]
+
+    assert Enum.zip_with([[:a, :b], [1, 2, 3, 4], ["foo", "bar", "baz", "qux"]], zip_fun) ==
+             [{:a, 1, "foo"}, {:b, 2, "bar"}]
+
+    assert Enum.zip_with([[:a, :b, :c, :d], [1, 2], ["foo", "bar", "baz", "qux"]], zip_fun) ==
+             [{:a, 1, "foo"}, {:b, 2, "bar"}]
+
+    assert Enum.zip_with([[:a, :b, :c, :d], [1, 2, 3, 4], ["foo", "bar"]], zip_fun) ==
+             [{:a, 1, "foo"}, {:b, 2, "bar"}]
+
+    assert Enum.zip_with([1..10, ["foo", "bar"]], zip_fun) == [{1, "foo"}, {2, "bar"}]
+    assert Enum.zip_with([], zip_fun) == []
+    assert Enum.zip_with([[]], zip_fun) == []
+    assert Enum.zip_with([[1]], zip_fun) == [{1}]
+    assert Enum.zip_with([[], [], [], []], zip_fun) == []
+    assert Enum.zip_with(%{}, zip_fun) == []
+    assert Enum.zip_with([[1, 2, 5, 6], 3..4], fn [x, y] -> x + y end) == [4, 6]
+
+    # Ranges
+    assert Enum.zip_with([1..6, 3..4], fn [a, b] -> a + b end) == [4, 6]
+    assert Enum.zip_with([[1, 2, 5, 6], 3..4], fn [a, b] -> a + b end) == [4, 6]
+    assert Enum.zip_with([fn _, _ -> {:cont, [1, 2]} end, 3..4], fn [a, b] -> a + b end) == [4, 6]
+    assert Enum.zip_with([1..1, 0..0], fn [a, b] -> a + b end) == [1]
+
+    # Date.range
+    week_1 = Date.range(~D[2020-10-12], ~D[2020-10-16])
+    week_2 = Date.range(~D[2020-10-19], ~D[2020-10-23])
+
+    result =
+      Enum.zip_with([week_1, week_2], fn [a, b] ->
+        Date.day_of_week(a) + Date.day_of_week(b)
+      end)
+
+    assert result == [2, 4, 6, 8, 10]
+
+    # Maps
+    result = Enum.zip_with([%{a: 7}, 3..4], fn [{key, value}, b] -> {key, value + b} end)
+    assert result == [a: 10]
+
+    result = Enum.zip_with([%{a: 7}, 3..4], fn [{key, value}, b] -> {key, value + b} end)
+    assert result == [a: 10]
   end
 end
 
 defmodule EnumTest.Range do
+  # Ranges use custom callbacks for protocols in many operations.
   use ExUnit.Case, async: true
 
-  test :all? do
-    range = 0..5
-    refute Enum.all?(range, fn(x) -> rem(x, 2) == 0 end)
+  test "all?/2" do
+    assert Enum.all?(0..1)
+    assert Enum.all?(1..0//-1)
+    refute Enum.all?(0..5, fn x -> rem(x, 2) == 0 end)
+    assert Enum.all?(0..1, fn x -> x < 2 end)
+
+    assert Enum.all?(0..1//-1)
+    assert Enum.all?(0..5//2, fn x -> rem(x, 2) == 0 end)
+    refute Enum.all?(1..5//2, fn x -> rem(x, 2) == 0 end)
+  end
+
+  test "any?/2" do
+    assert Enum.any?(1..0//-1)
+    refute Enum.any?(0..5, &(&1 > 10))
+    assert Enum.any?(0..5, &(&1 > 3))
+
+    refute Enum.any?(0..1//-1)
+    assert Enum.any?(0..5//2, fn x -> rem(x, 2) == 0 end)
+    refute Enum.any?(1..5//2, fn x -> rem(x, 2) == 0 end)
+  end
+
+  test "at/3" do
+    assert Enum.at(2..6, 0) == 2
+    assert Enum.at(2..6, 4) == 6
+    assert Enum.at(2..6, 6) == nil
+    assert Enum.at(2..6, 6, :none) == :none
+    assert Enum.at(2..6, -2) == 5
+    assert Enum.at(2..6, -8) == nil
+
+    assert Enum.at(0..1//-1, 0) == nil
+    assert Enum.at(1..1//5, 0) == 1
+    assert Enum.at(1..3//2, 0) == 1
+    assert Enum.at(1..3//2, 1) == 3
+    assert Enum.at(1..3//2, 2) == nil
+    assert Enum.at(1..3//2, -1) == 3
+    assert Enum.at(1..3//2, -2) == 1
+    assert Enum.at(1..3//2, -3) == nil
+  end
+
+  test "chunk_every/2" do
+    assert Enum.chunk_every(1..5, 2) == [[1, 2], [3, 4], [5]]
+    assert Enum.chunk_every(1..10//2, 2) == [[1, 3], [5, 7], [9]]
+  end
 
-    range = 0..1
-    assert Enum.all?(range, fn(x) -> x < 2 end)
-    assert Enum.all?(range)
+  test "chunk_every/4" do
+    assert Enum.chunk_every(1..5, 2, 2) == [[1, 2], [3, 4], [5]]
+    assert Enum.chunk_every(1..6, 3, 2, :discard) == [[1, 2, 3], [3, 4, 5]]
+    assert Enum.chunk_every(1..6, 2, 3, :discard) == [[1, 2], [4, 5]]
+    assert Enum.chunk_every(1..6, 3, 2, []) == [[1, 2, 3], [3, 4, 5], [5, 6]]
+    assert Enum.chunk_every(1..5, 4, 4, 6..10) == [[1, 2, 3, 4], [5, 6, 7, 8]]
+    assert Enum.chunk_every(1..10//2, 4, 4, 11..20) == [[1, 3, 5, 7], [9, 11, 12, 13]]
+  end
 
-    range = 1..0
-    assert Enum.all?(range)
+  test "chunk_by/2" do
+    assert Enum.chunk_by(1..4, fn _ -> true end) == [[1, 2, 3, 4]]
+    assert Enum.chunk_by(1..4, &(rem(&1, 2) == 1)) == [[1], [2], [3], [4]]
+    assert Enum.chunk_by(1..20//3, &(rem(&1, 2) == 1)) == [[1], [4], [7], [10], [13], [16], [19]]
+  end
+
+  test "concat/1" do
+    assert Enum.concat([1..2, 4..6]) == [1, 2, 4, 5, 6]
+    assert Enum.concat([1..5, fn acc, _ -> acc end, [1]]) == [1, 2, 3, 4, 5, 1]
+    assert Enum.concat([1..5, 6..10//2]) == [1, 2, 3, 4, 5, 6, 8, 10]
+  end
+
+  test "concat/2" do
+    assert Enum.concat(1..3, 4..5) == [1, 2, 3, 4, 5]
+    assert Enum.concat(1..3, [4, 5]) == [1, 2, 3, 4, 5]
+    assert Enum.concat(1..3, []) == [1, 2, 3]
+    assert Enum.concat(1..3, 0..0) == [1, 2, 3, 0]
+    assert Enum.concat(1..5, 6..10//2) == [1, 2, 3, 4, 5, 6, 8, 10]
+    assert Enum.concat(1..5, 0..1//-1) == [1, 2, 3, 4, 5]
+    assert Enum.concat(1..5, 1..0//1) == [1, 2, 3, 4, 5]
+  end
+
+  test "count/1" do
+    assert Enum.count(1..5) == 5
+    assert Enum.count(1..1) == 1
+    assert Enum.count(1..9//2) == 5
+    assert Enum.count(1..10//2) == 5
+    assert Enum.count(1..11//2) == 6
+    assert Enum.count(1..11//-2) == 0
+    assert Enum.count(11..1//-2) == 6
+    assert Enum.count(10..1//-2) == 5
+    assert Enum.count(9..1//-2) == 5
+    assert Enum.count(9..1//2) == 0
+  end
+
+  test "count/2" do
+    assert Enum.count(1..5, fn x -> rem(x, 2) == 0 end) == 2
+    assert Enum.count(1..1, fn x -> rem(x, 2) == 0 end) == 0
+    assert Enum.count(0..5//2, fn x -> rem(x, 2) == 0 end) == 3
+    assert Enum.count(1..5//2, fn x -> rem(x, 2) == 0 end) == 0
+  end
+
+  test "dedup/1" do
+    assert Enum.dedup(1..3) == [1, 2, 3]
+    assert Enum.dedup(1..3//2) == [1, 3]
+  end
+
+  test "dedup_by/2" do
+    assert Enum.dedup_by(1..3, fn _ -> 1 end) == [1]
+    assert Enum.dedup_by(1..3//2, fn _ -> 1 end) == [1]
+  end
+
+  test "drop/2" do
+    assert Enum.drop(1..3, 0) == [1, 2, 3]
+    assert Enum.drop(1..3, 1) == [2, 3]
+    assert Enum.drop(1..3, 2) == [3]
+    assert Enum.drop(1..3, 3) == []
+    assert Enum.drop(1..3, 4) == []
+    assert Enum.drop(1..3, -1) == [1, 2]
+    assert Enum.drop(1..3, -2) == [1]
+    assert Enum.drop(1..3, -4) == []
+    assert Enum.drop(1..0//-1, 3) == []
+
+    assert Enum.drop(1..9//2, 2) == [5, 7, 9]
+    assert Enum.drop(1..9//2, -2) == [1, 3, 5]
+    assert Enum.drop(9..1//-2, 2) == [5, 3, 1]
+    assert Enum.drop(9..1//-2, -2) == [9, 7, 5]
+  end
+
+  test "drop_every/2" do
+    assert Enum.drop_every(1..10, 2) == [2, 4, 6, 8, 10]
+    assert Enum.drop_every(1..10, 3) == [2, 3, 5, 6, 8, 9]
+    assert Enum.drop_every(0..0, 2) == []
+    assert Enum.drop_every(1..2, 2) == [2]
+    assert Enum.drop_every(1..3, 0) == [1, 2, 3]
+    assert Enum.drop_every(1..3, 1) == []
+
+    assert Enum.drop_every(1..5//2, 0) == [1, 3, 5]
+    assert Enum.drop_every(1..5//2, 1) == []
+    assert Enum.drop_every(1..5//2, 2) == [3]
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.drop_every(1..10, 3.33)
+    end
   end
 
-  test :any? do
-    range = 0..5
-    refute Enum.any?(range, &(&1 > 10))
+  test "drop_while/2" do
+    assert Enum.drop_while(0..6, fn x -> x <= 3 end) == [4, 5, 6]
+    assert Enum.drop_while(0..6, fn _ -> false end) == [0, 1, 2, 3, 4, 5, 6]
+    assert Enum.drop_while(0..3, fn x -> x <= 3 end) == []
+    assert Enum.drop_while(1..0//-1, fn _ -> nil end) == [1, 0]
+  end
 
-    range = 0..5
-    assert Enum.any?(range, &(&1 > 3))
+  test "each/2" do
+    try do
+      assert Enum.each(1..0//-1, fn x -> x end) == :ok
+      assert Enum.each(1..3, fn x -> Process.put(:enum_test_each, x * 2) end) == :ok
+      assert Process.get(:enum_test_each) == 6
+    after
+      Process.delete(:enum_test_each)
+    end
 
-    range = 1..0
-    assert Enum.any?(range)
+    try do
+      assert Enum.each(-1..-3//-1, fn x -> Process.put(:enum_test_each, x * 2) end) == :ok
+      assert Process.get(:enum_test_each) == -6
+    after
+      Process.delete(:enum_test_each)
+    end
   end
 
-  test :fetch! do
+  test "empty?/1" do
+    refute Enum.empty?(1..0//-1)
+    refute Enum.empty?(1..2)
+    refute Enum.empty?(1..2//2)
+    assert Enum.empty?(1..2//-2)
+  end
+
+  test "fetch/2" do
+    # ascending order
+    assert Enum.fetch(-10..20, 4) == {:ok, -6}
+    assert Enum.fetch(-10..20, -4) == {:ok, 17}
+    # ascending order, first
+    assert Enum.fetch(-10..20, 0) == {:ok, -10}
+    assert Enum.fetch(-10..20, -31) == {:ok, -10}
+    # ascending order, last
+    assert Enum.fetch(-10..20, -1) == {:ok, 20}
+    assert Enum.fetch(-10..20, 30) == {:ok, 20}
+    # ascending order, out of bound
+    assert Enum.fetch(-10..20, 31) == :error
+    assert Enum.fetch(-10..20, -32) == :error
+
+    # descending order
+    assert Enum.fetch(20..-10//-1, 4) == {:ok, 16}
+    assert Enum.fetch(20..-10//-1, -4) == {:ok, -7}
+    # descending order, first
+    assert Enum.fetch(20..-10//-1, 0) == {:ok, 20}
+    assert Enum.fetch(20..-10//-1, -31) == {:ok, 20}
+    # descending order, last
+    assert Enum.fetch(20..-10//-1, -1) == {:ok, -10}
+    assert Enum.fetch(20..-10//-1, 30) == {:ok, -10}
+    # descending order, out of bound
+    assert Enum.fetch(20..-10//-1, 31) == :error
+    assert Enum.fetch(20..-10//-1, -32) == :error
+
+    # edge cases
+    assert Enum.fetch(42..42, 0) == {:ok, 42}
+    assert Enum.fetch(42..42, -1) == {:ok, 42}
+    assert Enum.fetch(42..42, 2) == :error
+    assert Enum.fetch(42..42, -2) == :error
+
+    assert Enum.fetch(42..42//2, 0) == {:ok, 42}
+    assert Enum.fetch(42..42//2, -1) == {:ok, 42}
+    assert Enum.fetch(42..42//2, 2) == :error
+    assert Enum.fetch(42..42//2, -2) == :error
+  end
+
+  test "fetch!/2" do
     assert Enum.fetch!(2..6, 0) == 2
     assert Enum.fetch!(2..6, 4) == 6
     assert Enum.fetch!(2..6, -1) == 6
     assert Enum.fetch!(2..6, -2) == 5
-    assert Enum.fetch!(-2..-6, 0) == -2
-    assert Enum.fetch!(-2..-6, 4) == -6
+    assert Enum.fetch!(-2..-6//-1, 0) == -2
+    assert Enum.fetch!(-2..-6//-1, 4) == -6
 
     assert_raise Enum.OutOfBoundsError, fn ->
       Enum.fetch!(2..6, 8)
     end
 
     assert_raise Enum.OutOfBoundsError, fn ->
-      Enum.fetch!(-2..-6, 8)
+      Enum.fetch!(-2..-6//-1, 8)
     end
 
     assert_raise Enum.OutOfBoundsError, fn ->
@@ -504,371 +1998,585 @@ defmodule EnumTest.Range do
     end
   end
 
-  test :count do
-    range = 1..5
-    assert Enum.count(range) == 5
-    range = 1..1
-    assert Enum.count(range) == 1
-  end
+  test "filter/2" do
+    assert Enum.filter(1..3, fn x -> rem(x, 2) == 0 end) == [2]
+    assert Enum.filter(1..6, fn x -> rem(x, 2) == 0 end) == [2, 4, 6]
 
-  test :count_fun do
-    range = 1..5
-    assert Enum.count(range, fn(x) -> rem(x, 2) == 0 end) == 2
-    range = 1..1
-    assert Enum.count(range, fn(x) -> rem(x, 2) == 0 end) == 0
+    assert Enum.filter(1..3, &match?(1, &1)) == [1]
+    assert Enum.filter(1..3, &match?(x when x < 3, &1)) == [1, 2]
+    assert Enum.filter(1..3, fn _ -> true end) == [1, 2, 3]
   end
 
-  test :chunk do
-    assert Enum.chunk(1..5, 2) == [[1, 2], [3, 4]]
-    assert Enum.chunk(1..5, 2, 2, [6]) == [[1, 2], [3, 4], [5, 6]]
-    assert Enum.chunk(1..6, 3, 2) == [[1, 2, 3], [3, 4, 5]]
-    assert Enum.chunk(1..6, 2, 3) == [[1, 2], [4, 5]]
-    assert Enum.chunk(1..6, 3, 2, []) == [[1, 2, 3], [3, 4, 5], [5, 6]]
-    assert Enum.chunk(1..5, 4, 4, 6..10) == [[1, 2, 3, 4], [5, 6, 7, 8]]
+  test "find/3" do
+    assert Enum.find(2..6, fn x -> rem(x, 2) == 0 end) == 2
+    assert Enum.find(2..6, fn x -> rem(x, 2) == 1 end) == 3
+    assert Enum.find(2..6, fn _ -> false end) == nil
+    assert Enum.find(2..6, 0, fn _ -> false end) == 0
   end
 
-  test :chunk_by do
-    assert Enum.chunk_by(1..4, fn _ -> true end) == [[1, 2, 3, 4]]
-    assert Enum.chunk_by(1..4, &(rem(&1, 2) == 1)) == [[1], [2], [3], [4]]
+  test "find_index/2" do
+    assert Enum.find_index(2..6, fn x -> rem(x, 2) == 1 end) == 1
   end
 
-  test :drop do
-    range = 1..3
-    assert Enum.drop(range, 0) == [1, 2, 3]
-    assert Enum.drop(range, 1) == [2, 3]
-    assert Enum.drop(range, 2) == [3]
-    assert Enum.drop(range, 3) == []
-    assert Enum.drop(range, 4) == []
-    assert Enum.drop(range, -1) == [1, 2]
-    assert Enum.drop(range, -2) == [1]
-    assert Enum.drop(range, -4) == []
+  test "find_value/3" do
+    assert Enum.find_value(2..6, fn x -> rem(x, 2) == 1 end)
+  end
 
-    range = 1..0
-    assert Enum.drop(range, 3) == []
+  test "flat_map/2" do
+    assert Enum.flat_map(1..3, fn x -> [x, x] end) == [1, 1, 2, 2, 3, 3]
   end
 
-  test :drop_while do
-    range = 0..6
-    assert Enum.drop_while(range, fn(x) -> x <= 3 end) == [4, 5, 6]
-    assert Enum.drop_while(range, fn(_) -> false end) == [0, 1, 2, 3, 4, 5, 6]
+  test "flat_map_reduce/3" do
+    assert Enum.flat_map_reduce(1..100, 0, fn i, acc ->
+             if acc < 3, do: {[i], acc + 1}, else: {:halt, acc}
+           end) == {[1, 2, 3], 3}
+  end
 
-    range = 0..3
-    assert Enum.drop_while(range, fn(x) -> x <= 3 end) == []
+  test "group_by/3" do
+    assert Enum.group_by(1..6, &rem(&1, 3)) == %{0 => [3, 6], 1 => [1, 4], 2 => [2, 5]}
 
-    range = 1..0
-    assert Enum.drop_while(range, fn(_) -> false end) == [1, 0]
+    assert Enum.group_by(1..6, &rem(&1, 3), &(&1 * 2)) ==
+             %{0 => [6, 12], 1 => [2, 8], 2 => [4, 10]}
   end
 
-  test :find do
-    range = 2..6
-    assert Enum.find(range, fn(x) -> rem(x, 2) == 0 end) == 2
-    assert Enum.find(range, fn(x) -> rem(x, 2) == 1 end) == 3
-    assert Enum.find(range, fn _ -> false end) == nil
-    assert Enum.find(range, 0, fn _ -> false end) == 0
+  test "intersperse/2" do
+    assert Enum.intersperse(1..0//-1, true) == [1, true, 0]
+    assert Enum.intersperse(1..3, false) == [1, false, 2, false, 3]
   end
 
-  test :find_value do
-    range = 2..6
-    assert Enum.find_value(range, fn(x) -> rem(x, 2) == 1 end)
+  test "into/2" do
+    assert Enum.into(1..5, []) == [1, 2, 3, 4, 5]
+    assert Enum.into(1..5, MapSet.new()) == MapSet.new([1, 2, 3, 4, 5])
   end
 
-  test :find_index do
-    range = 2..6
-    assert Enum.find_index(range, fn(x) -> rem(x, 2) == 1 end) == 1
+  test "into/3" do
+    assert Enum.into(1..5, [], fn x -> x * 2 end) == [2, 4, 6, 8, 10]
+    assert Enum.into(1..3, "numbers: ", &to_string/1) == "numbers: 123"
+    assert Enum.into(1..3, MapSet.new(), &(&1 * 2)) == MapSet.new([2, 4, 6])
   end
 
-  test :empty? do
-    range = 1..0
-    refute Enum.empty?(range)
+  test "join/2" do
+    assert Enum.join(1..0//-1, " = ") == "1 = 0"
+    assert Enum.join(1..3, " = ") == "1 = 2 = 3"
+    assert Enum.join(1..3) == "123"
+  end
 
-    range = 1..2
-    refute Enum.empty?(range)
+  test "map/2" do
+    assert Enum.map(1..3, fn x -> x * 2 end) == [2, 4, 6]
+    assert Enum.map(-1..-3//-1, fn x -> x * 2 end) == [-2, -4, -6]
+    assert Enum.map(1..10//2, fn x -> x * 2 end) == [2, 6, 10, 14, 18]
+    assert Enum.map(3..1//-2, fn x -> x * 2 end) == [6, 2]
+    assert Enum.map(0..1//-1, fn x -> x * 2 end) == []
   end
 
-  test :each do
-    try do
-      range = 1..0
-      assert Enum.each(range, fn(x) -> x end) == :ok
+  test "map_every/3" do
+    assert Enum.map_every(1..10, 2, fn x -> x * 2 end) == [2, 2, 6, 4, 10, 6, 14, 8, 18, 10]
 
-      range = 1..3
-      assert Enum.each(range, fn(x) -> Process.put(:enum_test_each, x * 2) end) == :ok
-      assert Process.get(:enum_test_each) == 6
-    after
-      Process.delete(:enum_test_each)
-    end
+    assert Enum.map_every(-1..-10//-1, 2, fn x -> x * 2 end) ==
+             [-2, -2, -6, -4, -10, -6, -14, -8, -18, -10]
 
-    try do
-      range = -1..-3
-      assert Enum.each(range, fn(x) -> Process.put(:enum_test_each, x * 2) end) == :ok
-      assert Process.get(:enum_test_each) == -6
-    after
-      Process.delete(:enum_test_each)
+    assert Enum.map_every(1..2, 2, fn x -> x * 2 end) == [2, 2]
+    assert Enum.map_every(1..3, 0, fn x -> x * 2 end) == [1, 2, 3]
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.map_every(1..3, -1, fn x -> x * 2 end)
     end
   end
 
-  test :filter do
-    range = 1..3
-    assert Enum.filter(range, fn(x) -> rem(x, 2) == 0 end) == [2]
-
-    range = 1..6
-    assert Enum.filter(range, fn(x) -> rem(x, 2) == 0 end) == [2, 4, 6]
+  test "map_intersperse/3" do
+    assert Enum.map_intersperse(1..1, :a, &(&1 * 2)) == [2]
+    assert Enum.map_intersperse(1..3, :a, &(&1 * 2)) == [2, :a, 4, :a, 6]
   end
 
-  test :filter_with_match do
-    range = 1..3
-    assert Enum.filter(range, &match?(1, &1)) == [1]
-    assert Enum.filter(range, &match?(x when x < 3, &1)) == [1, 2]
-    assert Enum.filter(range, &match?(_, &1)) == [1, 2, 3]
+  test "map_join/3" do
+    assert Enum.map_join(1..0//-1, " = ", &(&1 * 2)) == "2 = 0"
+    assert Enum.map_join(1..3, " = ", &(&1 * 2)) == "2 = 4 = 6"
+    assert Enum.map_join(1..3, &(&1 * 2)) == "246"
   end
 
-  test :filter_map do
-    range = 1..3
-    assert Enum.filter_map(range, fn(x) -> rem(x, 2) == 0 end, &(&1 * 2)) == [4]
-
-    range = 2..6
-    assert Enum.filter_map(range, fn(x) -> rem(x, 2) == 0 end, &(&1 * 2)) == [4, 8, 12]
+  test "map_reduce/3" do
+    assert Enum.map_reduce(1..0//-1, 1, fn x, acc -> {x * 2, x + acc} end) == {[2, 0], 2}
+    assert Enum.map_reduce(1..3, 1, fn x, acc -> {x * 2, x + acc} end) == {[2, 4, 6], 7}
   end
 
-  test :flat_map do
-    range = 1..3
-    assert Enum.flat_map(range, fn(x) -> [x, x] end) == [1, 1, 2, 2, 3, 3]
-  end
+  test "max/1" do
+    assert Enum.max(1..1) == 1
+    assert Enum.max(1..3) == 3
+    assert Enum.max(3..1//-1) == 3
 
-  test :intersperse do
-    range = 1..0
-    assert Enum.intersperse(range, true) == [1, true, 0]
+    assert Enum.max(1..9//2) == 9
+    assert Enum.max(1..10//2) == 9
+    assert Enum.max(-1..-9//-2) == -1
 
-    range = 1..3
-    assert Enum.intersperse(range, false) == [1, false, 2, false, 3]
+    assert_raise Enum.EmptyError, fn -> Enum.max(1..0//1) end
   end
 
-  test :into do
-    assert Enum.into([a: 1, b: 2], %{}) == %{a: 1, b: 2}
-    assert Enum.into(%{a: 1, b: 2}, []) == [a: 1, b: 2]
-    assert Enum.into(3..5, [1, 2]) == [1, 2, 3, 4, 5]
-    assert Enum.into(1..5, []) == [1, 2, 3, 4, 5]
-    assert Enum.into(1..5, [], fn x -> x * 2 end) == [2, 4, 6, 8, 10]
-    assert Enum.into(1..3, "numbers: ", &to_string/1) == "numbers: 123"
+  test "max/2 with empty fallback" do
+    assert Enum.max(.., fn -> 0 end) === 0
+    assert Enum.max(1..2, fn -> 0 end) === 2
   end
 
-  test :join do
-    range = 1..0
-    assert Enum.join(range, " = ") == "1 = 0"
+  test "max_by/2" do
+    assert Enum.max_by(1..1, fn x -> :math.pow(-2, x) end) == 1
+    assert Enum.max_by(1..3, fn x -> :math.pow(-2, x) end) == 2
 
-    range = 1..3
-    assert Enum.join(range, " = ") == "1 = 2 = 3"
-    assert Enum.join(range) == "123"
+    assert Enum.max_by(1..8//3, fn x -> :math.pow(-2, x) end) == 4
+    assert_raise Enum.EmptyError, fn -> Enum.max_by(1..0//1, & &1) end
   end
 
-  test :map_join do
-    range = 1..0
-    assert Enum.map_join(range, " = ", &(&1 * 2)) == "2 = 0"
+  test "member?/2" do
+    assert Enum.member?(1..3, 2)
+    refute Enum.member?(1..3, 0)
 
-    range = 1..3
-    assert Enum.map_join(range, " = ", &(&1 * 2)) == "2 = 4 = 6"
-    assert Enum.map_join(range, &(&1 * 2)) == "246"
-  end
+    assert Enum.member?(1..9//2, 1)
+    assert Enum.member?(1..9//2, 9)
+    refute Enum.member?(1..9//2, 10)
+    refute Enum.member?(1..10//2, 10)
+    assert Enum.member?(1..2//2, 1)
+    refute Enum.member?(1..2//2, 2)
 
-  test :map do
-    range = 1..3
-    assert Enum.map(range, fn x -> x * 2 end) == [2, 4, 6]
+    assert Enum.member?(-1..-9//-2, -1)
+    assert Enum.member?(-1..-9//-2, -9)
+    refute Enum.member?(-1..-9//-2, -8)
 
-    range = -1..-3
-    assert Enum.map(range, fn x -> x * 2 end) == [-2, -4, -6]
+    refute Enum.member?(1..0//1, 1)
+    refute Enum.member?(0..1//-1, 1)
   end
 
-  test :map_reduce do
-    range = 1..0
-    assert Enum.map_reduce(range, 1, fn(x, acc) -> {x * 2, x + acc} end) == {[2, 0], 2}
+  test "min/1" do
+    assert Enum.min(1..1) == 1
+    assert Enum.min(1..3) == 1
 
-    range = 1..3
-    assert Enum.map_reduce(range, 1, fn(x, acc) -> {x * 2, x + acc} end) == {[2, 4, 6], 7}
+    assert Enum.min(1..9//2) == 1
+    assert Enum.min(1..10//2) == 1
+    assert Enum.min(-1..-9//-2) == -9
+
+    assert_raise Enum.EmptyError, fn -> Enum.min(1..0//1) end
   end
 
-  test :max do
-    assert Enum.max(1..1) == 1
-    assert Enum.max(1..3) == 3
-    assert Enum.max(3..1) == 3
+  test "min/2 with empty fallback" do
+    assert Enum.min(.., fn -> 0 end) === 0
+    assert Enum.min(1..2, fn -> 0 end) === 1
   end
 
-  test :max_by do
-    assert Enum.max_by(1..1, fn(x) -> :math.pow(-2, x) end) == 1
-    assert Enum.max_by(1..3, fn(x) -> :math.pow(-2, x) end) == 2
+  test "min_by/2" do
+    assert Enum.min_by(1..1, fn x -> :math.pow(-2, x) end) == 1
+    assert Enum.min_by(1..3, fn x -> :math.pow(-2, x) end) == 3
+
+    assert Enum.min_by(1..8//3, fn x -> :math.pow(-2, x) end) == 7
+    assert_raise Enum.EmptyError, fn -> Enum.min_by(1..0//1, & &1) end
   end
 
-  test :min do
-    assert Enum.min([1]) == 1
-    assert Enum.min([1, 2, 3]) == 1
-    assert Enum.min([[], :a, {}]) == :a
+  test "min_max/1" do
+    assert Enum.min_max(1..1) == {1, 1}
+    assert Enum.min_max(1..3) == {1, 3}
+    assert Enum.min_max(3..1//-1) == {1, 3}
+
+    assert Enum.min_max(1..9//2) == {1, 9}
+    assert Enum.min_max(1..10//2) == {1, 9}
+    assert Enum.min_max(-1..-9//-2) == {-9, -1}
+
+    assert_raise Enum.EmptyError, fn -> Enum.min_max(1..0//1) end
   end
 
-  test :min_by do
-    assert Enum.min_by(1..1, fn(x) -> :math.pow(-2, x) end) == 1
-    assert Enum.min_by(1..3, fn(x) -> :math.pow(-2, x) end) == 3
+  test "min_max_by/2" do
+    assert Enum.min_max_by(1..1, fn x -> x end) == {1, 1}
+    assert Enum.min_max_by(1..3, fn x -> x end) == {1, 3}
+
+    assert Enum.min_max_by(1..8//3, fn x -> :math.pow(-2, x) end) == {7, 4}
+    assert_raise Enum.EmptyError, fn -> Enum.min_max_by(1..0//1, & &1) end
   end
 
-  test :partition do
-    range = 1..3
-    assert Enum.partition(range, fn(x) -> rem(x, 2) == 0 end) == {[2], [1, 3]}
+  test "split_with/2" do
+    assert Enum.split_with(1..3, fn x -> rem(x, 2) == 0 end) == {[2], [1, 3]}
   end
 
-  test :reduce do
-    range = 1..0
-    assert Enum.reduce(range, 1, fn(x, acc) -> x + acc end) == 2
+  test "random/1" do
+    # corner cases, independent of the seed
+    assert Enum.random(1..1) == 1
+
+    # set a fixed seed so the test can be deterministic
+    # please note the order of following assertions is important
+    seed1 = {1406, 407_414, 139_258}
+    seed2 = {1306, 421_106, 567_597}
+    :rand.seed(:exsss, seed1)
+    assert Enum.random(1..2) == 1
+    assert Enum.random(1..3) == 1
+    assert Enum.random(3..1//-1) == 2
+
+    :rand.seed(:exsss, seed2)
+    assert Enum.random(1..2) == 1
+    assert Enum.random(1..3) == 2
 
-    range = 1..3
-    assert Enum.reduce(range, 1, fn(x, acc) -> x + acc end) == 7
+    assert Enum.random(1..10//2) == 7
+    assert Enum.random(1..10//2) == 5
 
-    range = 1..3
-    assert Enum.reduce(range, fn(x, acc) -> x + acc end) == 6
+    assert_raise Enum.EmptyError, fn -> Enum.random(..) end
   end
 
-  test :reject do
-    range = 1..3
-    assert Enum.reject(range, fn(x) -> rem(x, 2) == 0 end) == [1, 3]
+  test "reduce/2" do
+    assert Enum.reduce(1..3, fn x, acc -> x + acc end) == 6
+    assert Enum.reduce(1..10//2, fn x, acc -> x + acc end) == 25
+    assert_raise Enum.EmptyError, fn -> Enum.reduce(0..1//-1, &+/2) end
+  end
 
-    range = 1..6
-    assert Enum.reject(range, fn(x) -> rem(x, 2) == 0 end) == [1, 3, 5]
+  test "reduce/3" do
+    assert Enum.reduce(1..0//-1, 1, fn x, acc -> x + acc end) == 2
+    assert Enum.reduce(1..3, 1, fn x, acc -> x + acc end) == 7
+    assert Enum.reduce(1..10//2, 1, fn x, acc -> x + acc end) == 26
+    assert Enum.reduce(0..1//-1, 1, fn x, acc -> x + acc end) == 1
   end
 
-  test :reverse do
-    assert Enum.reverse([]) == []
-    assert Enum.reverse([1, 2, 3]) == [3, 2, 1]
-    assert Enum.reverse([1, 2, 3], [4, 5, 6]) == [3, 2, 1, 4, 5, 6]
+  test "reduce_while/3" do
+    assert Enum.reduce_while(1..100, 0, fn i, acc ->
+             if i <= 3, do: {:cont, acc + i}, else: {:halt, acc}
+           end) == 6
+  end
+
+  test "reject/2" do
+    assert Enum.reject(1..3, fn x -> rem(x, 2) == 0 end) == [1, 3]
+    assert Enum.reject(1..6, fn x -> rem(x, 2) == 0 end) == [1, 3, 5]
+  end
 
+  test "reverse/1" do
     assert Enum.reverse(0..0) == [0]
     assert Enum.reverse(1..3) == [3, 2, 1]
+    assert Enum.reverse(-3..5) == [5, 4, 3, 2, 1, 0, -1, -2, -3]
+    assert Enum.reverse(5..5) == [5]
+
+    assert Enum.reverse(0..1//-1) == []
+    assert Enum.reverse(1..10//2) == [9, 7, 5, 3, 1]
+  end
+
+  test "reverse/2" do
     assert Enum.reverse(1..3, 4..6) == [3, 2, 1, 4, 5, 6]
     assert Enum.reverse([1, 2, 3], 4..6) == [3, 2, 1, 4, 5, 6]
     assert Enum.reverse(1..3, [4, 5, 6]) == [3, 2, 1, 4, 5, 6]
+    assert Enum.reverse(-3..5, MapSet.new([-3, -2])) == [5, 4, 3, 2, 1, 0, -1, -2, -3, -3, -2]
+    assert Enum.reverse(5..5, [5]) == [5, 5]
+  end
+
+  test "reverse_slice/3" do
+    assert Enum.reverse_slice(1..6, 2, 0) == [1, 2, 3, 4, 5, 6]
+    assert Enum.reverse_slice(1..6, 2, 2) == [1, 2, 4, 3, 5, 6]
+    assert Enum.reverse_slice(1..6, 2, 4) == [1, 2, 6, 5, 4, 3]
+    assert Enum.reverse_slice(1..6, 2, 10_000_000) == [1, 2, 6, 5, 4, 3]
+    assert Enum.reverse_slice(1..6, 10_000_000, 4) == [1, 2, 3, 4, 5, 6]
+    assert Enum.reverse_slice(1..6, 50, 50) == [1, 2, 3, 4, 5, 6]
+  end
+
+  test "scan/2" do
+    assert Enum.scan(1..5, &(&1 + &2)) == [1, 3, 6, 10, 15]
   end
 
-  test :scan do
-    assert Enum.scan(1..5, &(&1 + &2)) == [1,3,6,10,15]
-    assert Enum.scan(1..5, 0, &(&1 + &2)) == [1,3,6,10,15]
+  test "scan/3" do
+    assert Enum.scan(1..5, 0, &(&1 + &2)) == [1, 3, 6, 10, 15]
   end
 
-  test :shuffle do
+  test "shuffle/1" do
     # set a fixed seed so the test can be deterministic
-    :random.seed(1374, 347975, 449264)
-    assert Enum.shuffle(1..5) == [2, 4, 1, 5, 3]
+    :rand.seed(:exsss, {1374, 347_975, 449_264})
+    assert Enum.shuffle(1..5) == [2, 5, 4, 3, 1]
+    assert Enum.shuffle(1..10//2) == [5, 1, 7, 9, 3]
   end
 
-  test :slice do
+  test "slice/2" do
+    assert Enum.slice(1..5, 0..0) == [1]
+    assert Enum.slice(1..5, 0..1) == [1, 2]
+    assert Enum.slice(1..5, 0..2) == [1, 2, 3]
+    assert Enum.slice(1..5, 1..2) == [2, 3]
+    assert Enum.slice(1..5, 1..0//1) == []
+    assert Enum.slice(1..5, 2..5) == [3, 4, 5]
+    assert Enum.slice(1..5, 2..6) == [3, 4, 5]
+    assert Enum.slice(1..5, 4..4) == [5]
+    assert Enum.slice(1..5, 5..5) == []
+    assert Enum.slice(1..5, 6..5//1) == []
+    assert Enum.slice(1..5, 6..0//1) == []
+    assert Enum.slice(1..5, -3..0) == []
+    assert Enum.slice(1..5, -3..1) == []
+    assert Enum.slice(1..5, -6..0) == [1]
+    assert Enum.slice(1..5, -6..5) == [1, 2, 3, 4, 5]
+    assert Enum.slice(1..5, -6..-1) == [1, 2, 3, 4, 5]
+    assert Enum.slice(1..5, -5..-1) == [1, 2, 3, 4, 5]
+    assert Enum.slice(1..5, -5..-3) == [1, 2, 3]
+
+    assert Enum.slice(1..5, 0..10//2) == [1, 3, 5]
+    assert Enum.slice(1..5, 0..10//3) == [1, 4]
+    assert Enum.slice(1..5, 0..10//4) == [1, 5]
+    assert Enum.slice(1..5, 0..10//5) == [1]
+    assert Enum.slice(1..5, 0..10//6) == [1]
+
+    assert Enum.slice(1..5, 0..2//2) == [1, 3]
+    assert Enum.slice(1..5, 0..2//3) == [1]
+
+    assert Enum.slice(1..5, 0..-1//2) == [1, 3, 5]
+    assert Enum.slice(1..5, 0..-1//3) == [1, 4]
+    assert Enum.slice(1..5, 0..-1//4) == [1, 5]
+    assert Enum.slice(1..5, 0..-1//5) == [1]
+    assert Enum.slice(1..5, 0..-1//6) == [1]
+
+    assert Enum.slice(1..5, 1..-1//2) == [2, 4]
+    assert Enum.slice(1..5, 1..-1//3) == [2, 5]
+    assert Enum.slice(1..5, 1..-1//4) == [2]
+    assert Enum.slice(1..5, 1..-1//5) == [2]
+
+    assert Enum.slice(1..5, -4..-1//2) == [2, 4]
+    assert Enum.slice(1..5, -4..-1//3) == [2, 5]
+    assert Enum.slice(1..5, -4..-1//4) == [2]
+    assert Enum.slice(1..5, -4..-1//5) == [2]
+
+    assert Enum.slice(5..1//-1, 0..0) == [5]
+    assert Enum.slice(5..1//-1, 0..1) == [5, 4]
+    assert Enum.slice(5..1//-1, 0..2) == [5, 4, 3]
+    assert Enum.slice(5..1//-1, 1..2) == [4, 3]
+    assert Enum.slice(5..1//-1, 1..0//1) == []
+    assert Enum.slice(5..1//-1, 2..5) == [3, 2, 1]
+    assert Enum.slice(5..1//-1, 2..6) == [3, 2, 1]
+    assert Enum.slice(5..1//-1, 4..4) == [1]
+    assert Enum.slice(5..1//-1, 5..5) == []
+    assert Enum.slice(5..1//-1, 6..5//1) == []
+    assert Enum.slice(5..1//-1, 6..0//1) == []
+    assert Enum.slice(5..1//-1, -6..0) == [5]
+    assert Enum.slice(5..1//-1, -6..5) == [5, 4, 3, 2, 1]
+    assert Enum.slice(5..1//-1, -6..-1) == [5, 4, 3, 2, 1]
+    assert Enum.slice(5..1//-1, -5..-1) == [5, 4, 3, 2, 1]
+    assert Enum.slice(5..1//-1, -5..-3) == [5, 4, 3]
+
+    assert Enum.slice(1..10//2, 0..0) == [1]
+    assert Enum.slice(1..10//2, 0..1) == [1, 3]
+    assert Enum.slice(1..10//2, 0..2) == [1, 3, 5]
+    assert Enum.slice(1..10//2, 1..2) == [3, 5]
+    assert Enum.slice(1..10//2, 1..0//1) == []
+    assert Enum.slice(1..10//2, 2..5) == [5, 7, 9]
+    assert Enum.slice(1..10//2, 2..6) == [5, 7, 9]
+    assert Enum.slice(1..10//2, 4..4) == [9]
+    assert Enum.slice(1..10//2, 5..5) == []
+    assert Enum.slice(1..10//2, 6..5//1) == []
+    assert Enum.slice(1..10//2, 6..0//1) == []
+    assert Enum.slice(1..10//2, -3..0) == []
+    assert Enum.slice(1..10//2, -3..1) == []
+    assert Enum.slice(1..10//2, -6..0) == [1]
+    assert Enum.slice(1..10//2, -6..5) == [1, 3, 5, 7, 9]
+    assert Enum.slice(1..10//2, -6..-1) == [1, 3, 5, 7, 9]
+    assert Enum.slice(1..10//2, -5..-1) == [1, 3, 5, 7, 9]
+    assert Enum.slice(1..10//2, -5..-3) == [1, 3, 5]
+
+    assert_raise ArgumentError,
+                 "Enum.slice/2 does not accept ranges with negative steps, got: 1..3//-2",
+                 fn -> Enum.slice(1..5, 1..3//-2) end
+  end
+
+  test "slice/3" do
     assert Enum.slice(1..5, 0, 0) == []
     assert Enum.slice(1..5, 0, 1) == [1]
     assert Enum.slice(1..5, 0, 2) == [1, 2]
     assert Enum.slice(1..5, 1, 2) == [2, 3]
     assert Enum.slice(1..5, 1, 0) == []
-    assert Enum.slice(1..5, 2, 5) == [3, 4, 5]
+    assert Enum.slice(1..5, 2, 3) == [3, 4, 5]
     assert Enum.slice(1..5, 2, 6) == [3, 4, 5]
     assert Enum.slice(1..5, 5, 5) == []
     assert Enum.slice(1..5, 6, 5) == []
     assert Enum.slice(1..5, 6, 0) == []
     assert Enum.slice(1..5, -6, 0) == []
-    assert Enum.slice(1..5, -6, 5) == []
+    assert Enum.slice(1..5, -6, 5) == [1, 2, 3, 4, 5]
     assert Enum.slice(1..5, -2, 5) == [4, 5]
     assert Enum.slice(1..5, -3, 1) == [3]
-  end
 
-  test :slice_range do
-    assert Enum.slice(1..5, 0..0) == [1]
-    assert Enum.slice(1..5, 0..1) == [1, 2]
-    assert Enum.slice(1..5, 0..2) == [1, 2, 3]
-    assert Enum.slice(1..5, 1..2) == [2, 3]
-    assert Enum.slice(1..5, 1..0) == []
-    assert Enum.slice(1..5, 2..5) == [3, 4, 5]
-    assert Enum.slice(1..5, 2..6) == [3, 4, 5]
-    assert Enum.slice(1..5, 4..4) == [5]
-    assert Enum.slice(1..5, 5..5) == []
-    assert Enum.slice(1..5, 6..5) == []
-    assert Enum.slice(1..5, 6..0) == []
-    assert Enum.slice(1..5, -6..0) == []
-    assert Enum.slice(1..5, -6..5) == []
-    assert Enum.slice(1..5, -5..-1) == [1, 2, 3, 4, 5]
-    assert Enum.slice(1..5, -5..-3) == [1, 2, 3]
-    assert Enum.slice(1..5, -6..-1) == []
-    assert Enum.slice(1..5, -6..-3) == []
-  end
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(1..5, 0, -1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(1..5, 0.99, 0)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(1..5, 0, 0.99)
+    end
 
-  test :sort do
-    assert Enum.sort(3..1) == [1, 2, 3]
-    assert Enum.sort(2..1) == [1, 2]
+    assert Enum.slice(5..1//-1, 0, 0) == []
+    assert Enum.slice(5..1//-1, 0, 1) == [5]
+    assert Enum.slice(5..1//-1, 0, 2) == [5, 4]
+    assert Enum.slice(5..1//-1, 1, 2) == [4, 3]
+    assert Enum.slice(5..1//-1, 1, 0) == []
+    assert Enum.slice(5..1//-1, 2, 3) == [3, 2, 1]
+    assert Enum.slice(5..1//-1, 2, 6) == [3, 2, 1]
+    assert Enum.slice(5..1//-1, 4, 4) == [1]
+    assert Enum.slice(5..1//-1, 5, 5) == []
+    assert Enum.slice(5..1//-1, 6, 5) == []
+    assert Enum.slice(5..1//-1, 6, 0) == []
+    assert Enum.slice(5..1//-1, -6, 0) == []
+    assert Enum.slice(5..1//-1, -6, 5) == [5, 4, 3, 2, 1]
+
+    assert Enum.slice(1..10//2, 0, 0) == []
+    assert Enum.slice(1..10//2, 0, 1) == [1]
+    assert Enum.slice(1..10//2, 0, 2) == [1, 3]
+    assert Enum.slice(1..10//2, 1, 2) == [3, 5]
+    assert Enum.slice(1..10//2, 1, 0) == []
+    assert Enum.slice(1..10//2, 2, 3) == [5, 7, 9]
+    assert Enum.slice(1..10//2, 2, 6) == [5, 7, 9]
+    assert Enum.slice(1..10//2, 5, 5) == []
+    assert Enum.slice(1..10//2, 6, 5) == []
+    assert Enum.slice(1..10//2, 6, 0) == []
+    assert Enum.slice(1..10//2, -6, 0) == []
+    assert Enum.slice(1..10//2, -6, 5) == [1, 3, 5, 7, 9]
+    assert Enum.slice(1..10//2, -2, 5) == [7, 9]
+    assert Enum.slice(1..10//2, -3, 1) == [5]
+  end
+
+  test "sort/1" do
+    assert Enum.sort(3..1//-1) == [1, 2, 3]
+    assert Enum.sort(2..1//-1) == [1, 2]
     assert Enum.sort(1..1) == [1]
+  end
 
-    assert Enum.sort(3..1, &(&1 > &2)) == [3, 2, 1]
-    assert Enum.sort(2..1, &(&1 > &2)) == [2, 1]
+  test "sort/2" do
+    assert Enum.sort(3..1//-1, &(&1 > &2)) == [3, 2, 1]
+    assert Enum.sort(2..1//-1, &(&1 > &2)) == [2, 1]
     assert Enum.sort(1..1, &(&1 > &2)) == [1]
-  end
 
-  test :split do
-    range = 1..3
-    assert Enum.split(range, 0) == {[], [1, 2, 3]}
-    assert Enum.split(range, 1) == {[1], [2, 3]}
-    assert Enum.split(range, 2) == {[1, 2], [3]}
-    assert Enum.split(range, 3) == {[1, 2, 3], []}
-    assert Enum.split(range, 4) == {[1, 2, 3], []}
-    assert Enum.split(range, -1) == {[1, 2], [3]}
-    assert Enum.split(range, -2) == {[1], [2, 3]}
-    assert Enum.split(range, -3) == {[], [1, 2, 3]}
-    assert Enum.split(range, -10) == {[], [1, 2, 3]}
+    assert Enum.sort(3..1//-1, :asc) == [1, 2, 3]
+    assert Enum.sort(3..1//-1, :desc) == [3, 2, 1]
+  end
 
-    range = 1..0
-    assert Enum.split(range, 3) == {[1, 0], []}
+  test "sort_by/2" do
+    assert Enum.sort_by(3..1//-1, & &1) == [1, 2, 3]
+    assert Enum.sort_by(3..1//-1, & &1, :asc) == [1, 2, 3]
+    assert Enum.sort_by(3..1//-1, & &1, :desc) == [3, 2, 1]
   end
 
-  test :split_while do
-    range = 1..3
-    assert Enum.split_while(range, fn(_) -> false end) == {[], [1, 2, 3]}
-    assert Enum.split_while(range, fn(_) -> true end) == {[1, 2, 3], []}
-    assert Enum.split_while(range, fn(x) -> x > 2 end) == {[], [1, 2, 3]}
-    assert Enum.split_while(range, fn(x) -> x > 3 end) == {[], [1, 2, 3]}
-    assert Enum.split_while(range, fn(x) -> x < 3 end) == {[1, 2], [3]}
+  test "split/2" do
+    assert Enum.split(1..3, 0) == {[], [1, 2, 3]}
+    assert Enum.split(1..3, 1) == {[1], [2, 3]}
+    assert Enum.split(1..3, 2) == {[1, 2], [3]}
+    assert Enum.split(1..3, 3) == {[1, 2, 3], []}
+    assert Enum.split(1..3, 4) == {[1, 2, 3], []}
+    assert Enum.split(1..3, -1) == {[1, 2], [3]}
+    assert Enum.split(1..3, -2) == {[1], [2, 3]}
+    assert Enum.split(1..3, -3) == {[], [1, 2, 3]}
+    assert Enum.split(1..3, -10) == {[], [1, 2, 3]}
+    assert Enum.split(1..0//-1, 3) == {[1, 0], []}
+  end
 
-    range = 1..0
-    assert Enum.split_while(range, fn(_) -> true end) == {[1, 0], []}
+  test "split_while/2" do
+    assert Enum.split_while(1..3, fn _ -> false end) == {[], [1, 2, 3]}
+    assert Enum.split_while(1..3, fn _ -> nil end) == {[], [1, 2, 3]}
+    assert Enum.split_while(1..3, fn _ -> true end) == {[1, 2, 3], []}
+    assert Enum.split_while(1..3, fn x -> x > 2 end) == {[], [1, 2, 3]}
+    assert Enum.split_while(1..3, fn x -> x > 3 end) == {[], [1, 2, 3]}
+    assert Enum.split_while(1..3, fn x -> x < 3 end) == {[1, 2], [3]}
+    assert Enum.split_while(1..3, fn x -> x end) == {[1, 2, 3], []}
+    assert Enum.split_while(1..0//-1, fn _ -> true end) == {[1, 0], []}
   end
 
-  test :sum do
+  test "sum/1" do
+    assert Enum.sum(0..0) == 0
     assert Enum.sum(1..1) == 1
     assert Enum.sum(1..3) == 6
+    assert Enum.sum(0..100) == 5050
+    assert Enum.sum(10..100) == 5005
+    assert Enum.sum(100..10//-1) == 5005
+    assert Enum.sum(-10..-20//-1) == -165
+    assert Enum.sum(-10..2) == -52
+
+    assert Enum.sum(0..1//-1) == 0
+    assert Enum.sum(1..9//2) == 25
+    assert Enum.sum(1..10//2) == 25
+    assert Enum.sum(9..1//-2) == 25
+  end
+
+  test "take/2" do
+    assert Enum.take(1..3, 0) == []
+    assert Enum.take(1..3, 1) == [1]
+    assert Enum.take(1..3, 2) == [1, 2]
+    assert Enum.take(1..3, 3) == [1, 2, 3]
+    assert Enum.take(1..3, 4) == [1, 2, 3]
+    assert Enum.take(1..3, -1) == [3]
+    assert Enum.take(1..3, -2) == [2, 3]
+    assert Enum.take(1..3, -4) == [1, 2, 3]
+    assert Enum.take(1..0//-1, 3) == [1, 0]
+    assert Enum.take(1..0//1, -3) == []
+  end
+
+  test "take_every/2" do
+    assert Enum.take_every(1..10, 2) == [1, 3, 5, 7, 9]
+    assert Enum.take_every(1..2, 2) == [1]
+    assert Enum.take_every(1..3, 0) == []
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.take_every(1..3, -1)
+    end
   end
 
-  test :take do
-    range = 1..3
-    assert Enum.take(range, 0) == []
-    assert Enum.take(range, 1) == [1]
-    assert Enum.take(range, 2) == [1, 2]
-    assert Enum.take(range, 3) == [1, 2, 3]
-    assert Enum.take(range, 4) == [1, 2, 3]
-    assert Enum.take(range, -1) == [3]
-    assert Enum.take(range, -2) == [2, 3]
-    assert Enum.take(range, -4) == [1, 2, 3]
+  test "take_random/2" do
+    # corner cases, independent of the seed
+    assert_raise FunctionClauseError, fn -> Enum.take_random(1..2, -1) end
+    assert Enum.take_random(1..1, 0) == []
+    assert Enum.take_random(1..1, 1) == [1]
+    assert Enum.take_random(1..1, 2) == [1]
+    assert Enum.take_random(1..2, 0) == []
 
-    range = 1..0
-    assert Enum.take(range, 3) == [1, 0]
+    # set a fixed seed so the test can be deterministic
+    # please note the order of following assertions is important
+    seed1 = {1406, 407_414, 139_258}
+    seed2 = {1406, 421_106, 567_597}
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random(1..3, 1) == [2]
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random(1..3, 2) == [3, 1]
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random(1..3, 3) == [3, 1, 2]
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random(1..3, 4) == [3, 1, 2]
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random(1..3, 5) == [3, 1, 2]
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random(3..1//-1, 1) == [2]
+    :rand.seed(:exsss, seed2)
+    assert Enum.take_random(1..3, 1) == [1]
+    :rand.seed(:exsss, seed2)
+    assert Enum.take_random(1..3, 2) == [3, 2]
+    :rand.seed(:exsss, seed2)
+    assert Enum.take_random(1..3, 3) == [1, 3, 2]
+    :rand.seed(:exsss, seed2)
+    assert Enum.take_random(1..3, 4) == [1, 3, 2]
+    :rand.seed(:exsss, seed2)
+    assert Enum.take_random(1..3, 5) == [1, 3, 2]
+  end
+
+  test "take_while/2" do
+    assert Enum.take_while(1..3, fn x -> x > 3 end) == []
+    assert Enum.take_while(1..3, fn x -> x <= 1 end) == [1]
+    assert Enum.take_while(1..3, fn x -> x <= 3 end) == [1, 2, 3]
+    assert Enum.take_while(1..3, fn x -> x end) == [1, 2, 3]
+    assert Enum.take_while(1..3, fn _ -> nil end) == []
+  end
+
+  test "to_list/1" do
+    assert Enum.to_list(1..3) == [1, 2, 3]
+    assert Enum.to_list(1..3//2) == [1, 3]
+    assert Enum.to_list(3..1//-2) == [3, 1]
+    assert Enum.to_list(0..1//-1) == []
+  end
+
+  test "uniq/1" do
+    assert Enum.uniq(1..3) == [1, 2, 3]
   end
 
-  test :take_every do
-    assert Enum.take_every(1..10, 2) == [1, 3, 5, 7, 9]
-    assert Enum.take_every(1..2, 2) == [1]
-    assert Enum.take_every(1..3, 0) == []
+  test "uniq_by/2" do
+    assert Enum.uniq_by(1..3, fn x -> x end) == [1, 2, 3]
   end
 
-  test :take_while do
-    range = 1..3
-    assert Enum.take_while(range, fn(x) -> x > 3 end) == []
-    assert Enum.take_while(range, fn(x) -> x <= 1 end) == [1]
-    assert Enum.take_while(range, fn(x) -> x <= 3 end) == [1, 2, 3]
-    assert Enum.take_while([], fn(_) -> true end) == []
+  test "unzip/1" do
+    assert_raise FunctionClauseError, fn -> Enum.unzip(1..3) end
   end
 
-  test :uniq do
-    assert Enum.uniq(1..3) == [1, 2, 3]
-    assert Enum.uniq(1..3, fn x -> x end) == [1, 2, 3]
+  test "with_index/2" do
+    assert Enum.with_index(1..3) == [{1, 0}, {2, 1}, {3, 2}]
+    assert Enum.with_index(1..3, 3) == [{1, 3}, {2, 4}, {3, 5}]
   end
 
-  test :zip do
+  test "zip/2" do
     assert Enum.zip([:a, :b], 1..2) == [{:a, 1}, {:b, 2}]
     assert Enum.zip([:a, :b], 1..4) == [{:a, 1}, {:b, 2}]
     assert Enum.zip([:a, :b, :c, :d], 1..2) == [{:a, 1}, {:b, 2}]
@@ -880,10 +2588,168 @@ defmodule EnumTest.Range do
     assert Enum.zip(1..2, 1..2) == [{1, 1}, {2, 2}]
     assert Enum.zip(1..4, 1..2) == [{1, 1}, {2, 2}]
     assert Enum.zip(1..2, 1..4) == [{1, 1}, {2, 2}]
+
+    assert Enum.zip(1..10//2, 1..10//3) == [{1, 1}, {3, 4}, {5, 7}, {7, 10}]
+    assert Enum.zip(0..1//-1, 1..10//3) == []
+  end
+end
+
+defmodule EnumTest.Map do
+  # Maps use different protocols path than lists and ranges in the cases below.
+  use ExUnit.Case, async: true
+
+  test "random/1" do
+    map = %{a: 1, b: 2, c: 3}
+    [x1, x2, x3] = Map.to_list(map)
+    seed1 = {1406, 407_414, 139_258}
+    seed2 = {1406, 421_106, 567_597}
+    :rand.seed(:exsss, seed1)
+    assert Enum.random(map) == x3
+    assert Enum.random(map) == x1
+    assert Enum.random(map) == x2
+
+    :rand.seed(:exsss, seed2)
+    assert Enum.random(map) == x3
+    assert Enum.random(map) == x2
+  end
+
+  test "take_random/2" do
+    # corner cases, independent of the seed
+    assert_raise FunctionClauseError, fn -> Enum.take_random(1..2, -1) end
+    assert Enum.take_random(%{a: 1}, 0) == []
+    assert Enum.take_random(%{a: 1}, 2) == [a: 1]
+    assert Enum.take_random(%{a: 1, b: 2}, 0) == []
+
+    # set a fixed seed so the test can be deterministic
+    # please note the order of following assertions is important
+    map = %{a: 1, b: 2, c: 3}
+    [x1, x2, x3] = Map.to_list(map)
+    seed1 = {1406, 407_414, 139_258}
+    seed2 = {1406, 421_106, 567_597}
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random(map, 1) == [x2]
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random(map, 2) == [x3, x1]
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random(map, 3) == [x3, x1, x2]
+    :rand.seed(:exsss, seed1)
+    assert Enum.take_random(map, 4) == [x3, x1, x2]
+    :rand.seed(:exsss, seed2)
+    assert Enum.take_random(map, 1) == [x1]
+    :rand.seed(:exsss, seed2)
+    assert Enum.take_random(map, 2) == [x3, x2]
+    :rand.seed(:exsss, seed2)
+    assert Enum.take_random(map, 3) == [x1, x3, x2]
+    :rand.seed(:exsss, seed2)
+    assert Enum.take_random(map, 4) == [x1, x3, x2]
+  end
+
+  test "reverse/1" do
+    assert Enum.reverse(%{}) == []
+    assert Enum.reverse(MapSet.new()) == []
+
+    map = %{a: 1, b: 2, c: 3}
+    assert Enum.reverse(map) == Map.to_list(map) |> Enum.reverse()
+  end
+
+  test "reverse/2" do
+    assert Enum.reverse([a: 1, b: 2, c: 3, a: 1], %{x: 1}) == [a: 1, c: 3, b: 2, a: 1, x: 1]
+
+    assert Enum.reverse([], %{a: 1}) == [a: 1]
+    assert Enum.reverse([], %{}) == []
+    assert Enum.reverse(%{a: 1}, []) == [a: 1]
+    assert Enum.reverse(MapSet.new(), %{}) == []
+  end
+
+  test "fetch/2" do
+    map = %{a: 1, b: 2, c: 3, d: 4, e: 5}
+    [x1, _x2, _x3, x4, x5] = Map.to_list(map)
+    assert Enum.fetch(map, 0) == {:ok, x1}
+    assert Enum.fetch(map, -2) == {:ok, x4}
+    assert Enum.fetch(map, -6) == :error
+    assert Enum.fetch(map, 5) == :error
+    assert Enum.fetch(%{}, 0) == :error
+
+    assert Stream.take(map, 3) |> Enum.fetch(3) == :error
+    assert Stream.take(map, 5) |> Enum.fetch(4) == {:ok, x5}
+  end
+
+  test "map_intersperse/3" do
+    assert Enum.map_intersperse(%{}, :a, & &1) == []
+    assert Enum.map_intersperse(%{foo: :bar}, :a, & &1) == [{:foo, :bar}]
+
+    map = %{foo: :bar, baz: :bat}
+    [x1, x2] = Map.to_list(map)
+
+    assert Enum.map_intersperse(map, :a, & &1) == [x1, :a, x2]
+  end
+
+  test "slice/2" do
+    map = %{a: 1, b: 2, c: 3, d: 4, e: 5}
+    [x1, x2, x3 | _] = Map.to_list(map)
+    assert Enum.slice(map, 0..0) == [x1]
+    assert Enum.slice(map, 0..1) == [x1, x2]
+    assert Enum.slice(map, 0..2) == [x1, x2, x3]
+  end
+
+  test "slice/3" do
+    map = %{a: 1, b: 2, c: 3, d: 4, e: 5}
+    [x1, x2, x3, x4, x5] = Map.to_list(map)
+    assert Enum.slice(map, 1, 2) == [x2, x3]
+    assert Enum.slice(map, 1, 0) == []
+    assert Enum.slice(map, 2, 5) == [x3, x4, x5]
+    assert Enum.slice(map, 2, 6) == [x3, x4, x5]
+    assert Enum.slice(map, 5, 5) == []
+    assert Enum.slice(map, 6, 5) == []
+    assert Enum.slice(map, 6, 0) == []
+    assert Enum.slice(map, -6, 0) == []
+    assert Enum.slice(map, -6, 5) == [x1, x2, x3, x4, x5]
+    assert Enum.slice(map, -2, 5) == [x4, x5]
+    assert Enum.slice(map, -3, 1) == [x3]
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(map, 0, -1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(map, 0.99, 0)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(map, 0, 0.99)
+    end
+
+    assert Enum.slice(map, 0, 0) == []
+    assert Enum.slice(map, 0, 1) == [x1]
+    assert Enum.slice(map, 0, 2) == [x1, x2]
+    assert Enum.slice(map, 1, 2) == [x2, x3]
+    assert Enum.slice(map, 1, 0) == []
+    assert Enum.slice(map, 2, 5) == [x3, x4, x5]
+    assert Enum.slice(map, 2, 6) == [x3, x4, x5]
+    assert Enum.slice(map, 5, 5) == []
+    assert Enum.slice(map, 6, 5) == []
+    assert Enum.slice(map, 6, 0) == []
+    assert Enum.slice(map, -6, 0) == []
+    assert Enum.slice(map, -6, 5) == [x1, x2, x3, x4, x5]
+    assert Enum.slice(map, -2, 5) == [x4, x5]
+    assert Enum.slice(map, -3, 1) == [x3]
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(map, 0, -1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(map, 0.99, 0)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Enum.slice(map, 0, 0.99)
+    end
   end
 
-  test :with_index do
-    assert Enum.with_index(1..3) == [{1,0},{2,1},{3,2}]
+  test "reduce/3" do
+    assert Enum.reduce(%{}, 1, fn x, acc -> x + acc end) == 1
+    assert Enum.reduce(%{a: 1, b: 2}, 1, fn {_, x}, acc -> x + acc end) == 4
   end
 end
 
@@ -891,17 +2757,22 @@ defmodule EnumTest.SideEffects do
   use ExUnit.Case, async: true
 
   import ExUnit.CaptureIO
-  import PathHelpers
 
-  test "take with side effects" do
-    stream = Stream.unfold(1, fn x -> IO.puts x; {x, x + 1} end)
+  test "take/2 with side effects" do
+    stream =
+      Stream.unfold(1, fn x ->
+        IO.puts(x)
+        {x, x + 1}
+      end)
+
     assert capture_io(fn ->
-      Enum.take(stream, 1)
-    end) == "1\n"
+             Enum.take(stream, 1)
+           end) == "1\n"
   end
 
-  test "take does not consume next without a need" do
-    path = tmp_path("oneliner.txt")
+  @tag :tmp_dir
+  test "take/2 does not consume next without a need", config do
+    path = Path.join(config.tmp_dir, "oneliner.txt")
     File.mkdir(Path.dirname(path))
 
     try do
@@ -917,8 +2788,8 @@ defmodule EnumTest.SideEffects do
     end
   end
 
-  test "take with no item works as no-op" do
-    iterator = File.stream!(fixture_path("unknown.txt"))
+  test "take/2 with no elements works as no-op" do
+    iterator = File.stream!(PathHelpers.fixture_path("unknown.txt"))
 
     assert Enum.take(iterator, 0) == []
     assert Enum.take(iterator, 0) == []
@@ -926,3 +2797,13 @@ defmodule EnumTest.SideEffects do
     assert Enum.take(iterator, 0) == []
   end
 end
+
+defmodule EnumTest.Function do
+  use ExUnit.Case, async: true
+
+  test "raises Protocol.UndefinedError for funs of wrong arity" do
+    assert_raise Protocol.UndefinedError, fn ->
+      Enum.to_list(fn -> nil end)
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/exception_test.exs b/lib/elixir/test/elixir/exception_test.exs
index d474028aae7..cc8c8040666 100644
--- a/lib/elixir/test/elixir/exception_test.exs
+++ b/lib/elixir/test/elixir/exception_test.exs
@@ -1,328 +1,1114 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-defmodule Kernel.ExceptionTest do
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule ExceptionTest do
   use ExUnit.Case, async: true
 
-  test "raise preserves the stacktrace" do
-    stacktrace =
-      try do
-        raise "a"
-      rescue _ ->
-        [top|_] = System.stacktrace
-        top
-      end
-    file = __ENV__.file |> Path.relative_to_cwd |> String.to_char_list
-    assert {Kernel.ExceptionTest, :"test raise preserves the stacktrace", _,
-           [file: ^file, line: 9]} = stacktrace
+  defp capture_err(fun) do
+    ExUnit.CaptureIO.capture_io(:stderr, fun)
   end
 
-  test "exception?" do
-    assert Exception.exception?(%RuntimeError{})
-    refute Exception.exception?(%Regex{})
-    refute Exception.exception?({})
-  end
+  doctest Exception
 
-  test "message" do
+  doctest RuntimeError
+  doctest SystemLimitError
+  doctest MismatchedDelimiterError
+  doctest SyntaxError
+  doctest TokenMissingError
+  doctest BadBooleanError
+  doctest UndefinedFunctionError
+  doctest FunctionClauseError
+  doctest Protocol.UndefinedError
+  doctest UnicodeConversionError
+  doctest Enum.OutOfBoundsError
+  doctest Enum.EmptyError
+  doctest File.Error
+  doctest File.CopyError
+  doctest File.RenameError
+  doctest File.LinkError
+  doctest ErlangError
+
+  test "message/1" do
     defmodule BadException do
-      def message(_) do
-        raise "oops"
+      def message(exception) do
+        if exception.raise do
+          raise "oops"
+        end
       end
     end
 
-    message = ~r/Got RuntimeError with message \"oops\" while retrieving message for/
+    assert "got RuntimeError with message \"oops\" while retrieving Exception.message/1 for %{" <>
+             inspected =
+             Exception.message(%{__struct__: BadException, __exception__: true, raise: true})
 
-    assert_raise ArgumentError, message, fn ->
-      Exception.message(%{__struct__: BadException, __exception__: true})
-    end
-  end
+    assert inspected =~ "raise: true"
+    assert inspected =~ "__exception__: true"
+    assert inspected =~ "__struct__: ExceptionTest.BadException"
 
-  require Record
+    assert "got nil while retrieving Exception.message/1 for %{" <> inspected =
+             Exception.message(%{__struct__: BadException, __exception__: true, raise: false})
 
-  test "normalize" do
-    assert Exception.normalize(:throw, :badarg) == :badarg
-    assert Exception.normalize(:exit, :badarg) == :badarg
-    assert Exception.normalize({:EXIT, self}, :badarg) == :badarg
-    assert Exception.normalize(:error, :badarg).__struct__ == ArgumentError
-    assert Exception.normalize(:error, %ArgumentError{}).__struct__ == ArgumentError
+    assert inspected =~ "raise: false"
+    assert inspected =~ "__exception__: true"
+    assert inspected =~ "__struct__: ExceptionTest.BadException"
   end
 
-  test "format_banner" do
-    assert Exception.format_banner(:error, :badarg) == "** (ArgumentError) argument error"
-    assert Exception.format_banner(:throw, :badarg) == "** (throw) :badarg"
-    assert Exception.format_banner(:exit, :badarg) == "** (exit) :badarg"
-    assert Exception.format_banner({:EXIT, self}, :badarg) == "** (EXIT from #{inspect self}) :badarg"
-  end
+  test "normalize/2" do
+    assert Exception.normalize(:throw, :badarg, []) == :badarg
+    assert Exception.normalize(:exit, :badarg, []) == :badarg
+    assert Exception.normalize({:EXIT, self()}, :badarg, []) == :badarg
+    assert Exception.normalize(:error, :badarg, []).__struct__ == ArgumentError
+    assert Exception.normalize(:error, %ArgumentError{}, []).__struct__ == ArgumentError
 
-  test "format without stacktrace" do
-    stacktrace = try do throw(:stack) catch :stack -> System.stacktrace() end
-    assert Exception.format(:error, :badarg) == "** (ArgumentError) argument error" <>
-      "\n" <> Exception.format_stacktrace(stacktrace)
-  end
+    assert %ErlangError{original: :no_translation, reason: ": foo"} =
+             Exception.normalize(:error, :no_translation, [
+               {:io, :put_chars, [self(), <<222>>],
+                [error_info: %{module: __MODULE__, function: :dummy_error_extras}]}
+             ])
 
-  test "format with empty stacktrace" do
-    assert Exception.format(:error, :badarg, []) == "** (ArgumentError) argument error"
+    assert %ErlangError{original: {:failed_load_cacerts, :enoent}, reason: ": this is chardata"} =
+             Exception.normalize(:error, {:failed_load_cacerts, :enoent}, [
+               {:pubkey_os_cacerts, :get, 0,
+                [error_info: %{module: __MODULE__, function: :dummy_error_chardata}]}
+             ])
   end
 
-  test "format with EXIT has no stacktrace" do
-    try do throw(:stack) catch :stack -> System.stacktrace() end
-    assert Exception.format({:EXIT, self}, :badarg) == "** (EXIT from #{inspect self}) :badarg"
-  end
+  test "format/2 without stacktrace" do
+    stacktrace =
+      try do
+        throw(:stack)
+      catch
+        :stack -> __STACKTRACE__
+      end
 
-  test "format_exit" do
-    assert Exception.format_exit(:bye) == ":bye"
-    assert Exception.format_exit(:noconnection) == "no connection"
-    assert Exception.format_exit({:nodedown, :"node@host"}) == "no connection to node@host"
-    assert Exception.format_exit(:timeout) == "time out"
-    assert Exception.format_exit(:noproc) == "no process"
-    assert Exception.format_exit(:killed) == "killed"
-    assert Exception.format_exit(:normal) == "normal"
-    assert Exception.format_exit(:shutdown) == "shutdown"
-    assert Exception.format_exit({:shutdown, :bye}) == "shutdown: :bye"
-    assert Exception.format_exit({:badarg,[{:not_a_real_module, :function, 0, []}]}) ==
-           "an exception was raised:\n    ** (ArgumentError) argument error\n        :not_a_real_module.function/0"
-    assert Exception.format_exit({:bad_call, :request}) == "bad call: :request"
-    assert Exception.format_exit({:bad_cast, :request}) == "bad cast: :request"
-    assert Exception.format_exit({:start_spec, :unexpected}) ==
-           "bad start spec: :unexpected"
-    assert Exception.format_exit({:supervisor_data, :unexpected}) ==
-           "bad supervisor data: :unexpected"
+    assert Exception.format(:error, :badarg, stacktrace) ==
+             "** (ArgumentError) argument error\n" <> Exception.format_stacktrace(stacktrace)
   end
 
-  defmodule Sup do
-    def start_link(fun), do: :supervisor.start_link(__MODULE__, fun)
-
-    def init(fun), do: fun.()
+  test "format/2 with empty stacktrace" do
+    assert Exception.format(:error, :badarg, []) == "** (ArgumentError) argument error"
   end
 
-  test "format_exit with supervisor errors" do
-    trap = Process.flag(:trap_exit, true)
-
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> :foo end)
-    assert Exception.format_exit(reason) ==
-           "#{inspect(__MODULE__.Sup)}.init/1 returned a bad value: :foo"
-
-    return = {:ok, {:foo, []}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad supervisor data: invalid type: :foo"
-
-    return = {:ok, {{:foo, 1, 1}, []}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad supervisor data: invalid strategy: :foo"
-
-    return = {:ok, {{:one_for_one, :foo, 1}, []}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad supervisor data: invalid intensity: :foo"
-
-    return = {:ok, {{:one_for_one, 1, :foo}, []}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad supervisor data: invalid period: :foo"
-
-    return = {:ok, {{:simple_one_for_one, 1, 1}, :foo}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad start spec: invalid children: :foo"
-
-    return = {:ok, {{:one_for_one, 1, 1}, [:foo]}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad start spec: invalid child spec: :foo"
-
-    return = {:ok, {{:one_for_one, 1, 1},
-        [{:child, :foo, :temporary, 1, :worker, []}]}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad start spec: invalid mfa: :foo"
-
-    return = {:ok, {{:one_for_one, 1, 1},
-        [{:child, {:m, :f, []}, :foo, 1, :worker, []}]}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad start spec: invalid restart type: :foo"
-
-    return = {:ok, {{:one_for_one, 1, 1},
-        [{:child, {:m, :f, []}, :temporary, :foo, :worker, []}]}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad start spec: invalid shutdown: :foo"
-
-    return = {:ok, {{:one_for_one, 1, 1},
-        [{:child, {:m, :f, []}, :temporary, 1, :foo, []}]}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad start spec: invalid child type: :foo"
-
-    return = {:ok, {{:one_for_one, 1, 1},
-        [{:child, {:m, :f, []}, :temporary, 1, :worker, :foo}]}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad start spec: invalid modules: :foo"
-
-    return = {:ok, {{:one_for_one, 1, 1},
-        [{:child, {:m, :f, []}, :temporary, 1, :worker, [{:foo}]}]}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "bad start spec: invalid module: {:foo}"
-
-    return = {:ok, {{:one_for_one, 1, 1},
-        [{:child, {Kernel, :exit, [:foo]}, :temporary, 1, :worker, []}]}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "shutdown: failed to start child: :child\n    ** (EXIT) :foo"
-
-    return = {:ok, {{:one_for_one, 1, 1},
-        [{:child, {Kernel, :apply, [fn() -> {:error, :foo} end, []]}, :temporary, 1, :worker, []}]}}
-    {:error, reason} = __MODULE__.Sup.start_link(fn() -> return end)
-    assert Exception.format_exit(reason) ==
-           "shutdown: failed to start child: :child\n    ** (EXIT) :foo"
-
-    Process.flag(:trap_exit, trap)
+  test "format/2 with EXIT (has no stacktrace)" do
+    assert Exception.format({:EXIT, self()}, :badarg, []) ==
+             "** (EXIT from #{inspect(self())}) :badarg"
   end
 
-  test "format_exit with call" do
-    reason = try do
-      :gen_server.call(:does_not_exist, :hello)
-    catch
-      :exit, reason -> reason
-    end
-
-    assert Exception.format_exit(reason) ==
-           "exited in: :gen_server.call(:does_not_exist, :hello)\n    ** (EXIT) no process"
-  end
+  test "format_banner/2" do
+    assert Exception.format_banner(:error, :badarg) == "** (ArgumentError) argument error"
+    assert Exception.format_banner(:throw, :badarg) == "** (throw) :badarg"
+    assert Exception.format_banner(:exit, :badarg) == "** (exit) :badarg"
 
-  test "format_exit with call with exception" do
-    # Fake reason to prevent error_logger printing to stdout
-    fsm_reason = {%ArgumentError{}, [{:not_a_real_module, :function, 0, []}]}
-    reason = try do
-      :gen_fsm.sync_send_event(spawn(fn() ->
-          :timer.sleep(200) ; exit(fsm_reason)
-      end), :hello)
-    catch
-      :exit, reason -> reason
-    end
-
-    formatted = Exception.format_exit(reason)
-    assert formatted =~ ~r"exited in: :gen_fsm\.sync_send_event\(#PID<\d+\.\d+\.\d+>, :hello\)"
-    assert formatted =~ ~r"\s{4}\*\* \(EXIT\) an exception was raised:\n"
-    assert formatted =~ ~r"\s{8}\*\* \(ArgumentError\) argument error\n"
-    assert formatted =~ ~r"\s{12}:not_a_real_module\.function/0"
+    assert Exception.format_banner({:EXIT, self()}, :badarg) ==
+             "** (EXIT from #{inspect(self())}) :badarg"
   end
 
-  test "format_exit with nested calls" do
-    # Fake reason to prevent error_logger printing to stdout
-    event_fun = fn() -> :timer.sleep(200) ; exit(:normal) end
-    server_pid = spawn(fn()-> :gen_event.call(spawn(event_fun), :handler, :hello) end)
-    reason = try do
-      :gen_server.call(server_pid, :hi)
-    catch
-      :exit, reason -> reason
+  test "format_stacktrace/1 from file" do
+    try do
+      Code.eval_string("def foo do end", [], file: "my_file")
+    rescue
+      ArgumentError ->
+        assert Exception.format_stacktrace(__STACKTRACE__) =~ "my_file:1: (file)"
+    else
+      _ -> flunk("expected failure")
     end
-
-    formatted = Exception.format_exit(reason)
-    assert formatted =~ ~r"exited in: :gen_server\.call\(#PID<\d+\.\d+\.\d+>, :hi\)\n"
-    assert formatted =~ ~r"\s{4}\*\* \(EXIT\) exited in: :gen_event\.call\(#PID<\d+\.\d+\.\d+>, :handler, :hello\)\n"
-    assert formatted =~ ~r"\s{8}\*\* \(EXIT\) normal"
   end
 
-  test "format_exit with nested calls and exception" do
-    # Fake reason to prevent error_logger printing to stdout
-    event_reason = {%ArgumentError{}, [{:not_a_real_module, :function, 0, []}]}
-    event_fun = fn() -> :timer.sleep(200) ; exit(event_reason) end
-    server_pid = spawn(fn()-> :gen_event.call(spawn(event_fun), :handler, :hello) end)
-    reason = try do
-      :gen_server.call(server_pid, :hi)
-    catch
-      :exit, reason -> reason
-    end
-
-    formatted = Exception.format_exit(reason)
-    assert formatted =~ ~r"exited in: :gen_server\.call\(#PID<\d+\.\d+\.\d+>, :hi\)\n"
-    assert formatted =~ ~r"\s{4}\*\* \(EXIT\) exited in: :gen_event\.call\(#PID<\d+\.\d+\.\d+>, :handler, :hello\)\n"
-    assert formatted =~ ~r"\s{8}\*\* \(EXIT\) an exception was raised:\n"
-    assert formatted =~ ~r"\s{12}\*\* \(ArgumentError\) argument error\n"
-    assert formatted =~ ~r"\s{16}:not_a_real_module\.function/0"
+  test "format_stacktrace/1 from module" do
+    try do
+      Code.eval_string(
+        "defmodule FmtStack do raise ArgumentError, ~s(oops) end",
+        [],
+        file: "my_file"
+      )
+    rescue
+      ArgumentError ->
+        assert Exception.format_stacktrace(__STACKTRACE__) =~ "my_file:1: (module)"
+    else
+      _ -> flunk("expected failure")
+    end
   end
 
-  test "format_stacktrace_entry with no file or line" do
+  test "format_stacktrace_entry/1 with no file or line" do
     assert Exception.format_stacktrace_entry({Foo, :bar, [1, 2, 3], []}) == "Foo.bar(1, 2, 3)"
     assert Exception.format_stacktrace_entry({Foo, :bar, [], []}) == "Foo.bar()"
     assert Exception.format_stacktrace_entry({Foo, :bar, 1, []}) == "Foo.bar/1"
   end
 
-  test "format_stacktrace_entry with file and line" do
-    assert Exception.format_stacktrace_entry({Foo, :bar, [], [file: 'file.ex', line: 10]}) == "file.ex:10: Foo.bar()"
-    assert Exception.format_stacktrace_entry({Foo, :bar, [1, 2, 3], [file: 'file.ex', line: 10]}) == "file.ex:10: Foo.bar(1, 2, 3)"
-    assert Exception.format_stacktrace_entry({Foo, :bar, 1, [file: 'file.ex', line: 10]}) == "file.ex:10: Foo.bar/1"
+  test "format_stacktrace_entry/1 with file and line" do
+    assert Exception.format_stacktrace_entry({Foo, :bar, [], [file: ~c"file.ex", line: 10]}) ==
+             "file.ex:10: Foo.bar()"
+
+    assert Exception.format_stacktrace_entry(
+             {Foo, :bar, [1, 2, 3], [file: ~c"file.ex", line: 10]}
+           ) ==
+             "file.ex:10: Foo.bar(1, 2, 3)"
+
+    assert Exception.format_stacktrace_entry({Foo, :bar, 1, [file: ~c"file.ex", line: 10]}) ==
+             "file.ex:10: Foo.bar/1"
   end
 
-  test "format_stacktrace_entry with file no line" do
-    assert Exception.format_stacktrace_entry({Foo, :bar, [], [file: 'file.ex']}) == "file.ex: Foo.bar()"
-    assert Exception.format_stacktrace_entry({Foo, :bar, [], [file: 'file.ex', line: 0]}) == "file.ex: Foo.bar()"
-    assert Exception.format_stacktrace_entry({Foo, :bar, [1, 2, 3], [file: 'file.ex']}) == "file.ex: Foo.bar(1, 2, 3)"
-    assert Exception.format_stacktrace_entry({Foo, :bar, 1, [file: 'file.ex']}) == "file.ex: Foo.bar/1"
+  test "format_stacktrace_entry/1 with file no line" do
+    assert Exception.format_stacktrace_entry({Foo, :bar, [], [file: ~c"file.ex"]}) ==
+             "file.ex: Foo.bar()"
+
+    assert Exception.format_stacktrace_entry({Foo, :bar, [], [file: ~c"file.ex", line: 0]}) ==
+             "file.ex: Foo.bar()"
+
+    assert Exception.format_stacktrace_entry({Foo, :bar, [1, 2, 3], [file: ~c"file.ex"]}) ==
+             "file.ex: Foo.bar(1, 2, 3)"
+
+    assert Exception.format_stacktrace_entry({Foo, :bar, 1, [file: ~c"file.ex"]}) ==
+             "file.ex: Foo.bar/1"
   end
 
-  test "format_stacktrace_entry with application" do
-    assert Exception.format_stacktrace_entry({Exception, :bar, [], [file: 'file.ex']}) ==
-                       "(elixir) file.ex: Exception.bar()"
-    assert Exception.format_stacktrace_entry({Exception, :bar, [], [file: 'file.ex', line: 10]}) ==
-                       "(elixir) file.ex:10: Exception.bar()"
-    assert Exception.format_stacktrace_entry({:lists, :bar, [1, 2, 3], []}) ==
-                       "(stdlib) :lists.bar(1, 2, 3)"
+  test "format_stacktrace_entry/1 with application" do
+    assert Exception.format_stacktrace_entry({Exception, :bar, [], [file: ~c"file.ex"]}) ==
+             "(elixir #{System.version()}) file.ex: Exception.bar()"
+
+    assert Exception.format_stacktrace_entry({Exception, :bar, [], [file: ~c"file.ex", line: 10]}) ==
+             "(elixir #{System.version()}) file.ex:10: Exception.bar()"
   end
 
-  test "format_stacktrace_entry with fun" do
-    assert Exception.format_stacktrace_entry({fn(x) -> x end, [1], []}) =~ ~r/#Function<.+>\(1\)/
-    assert Exception.format_stacktrace_entry({fn(x, y) -> {x, y} end, 2, []}) =~ ~r"#Function<.+>/2"
+  test "format_stacktrace_entry/1 with fun" do
+    assert Exception.format_stacktrace_entry({fn x -> x end, [1], []}) =~ ~r/#Function<.+>\(1\)/
+
+    assert Exception.format_stacktrace_entry({fn x, y -> {x, y} end, 2, []}) =~
+             ~r"#Function<.+>/2"
   end
 
-  test "format_mfa" do
+  test "format_mfa/3" do
+    # Let's create this atom so that String.to_existing_atom/1 inside
+    # format_mfa/3 doesn't raise.
+    _ = :"some function"
+
     assert Exception.format_mfa(Foo, nil, 1) == "Foo.nil/1"
     assert Exception.format_mfa(Foo, :bar, 1) == "Foo.bar/1"
     assert Exception.format_mfa(Foo, :bar, []) == "Foo.bar()"
     assert Exception.format_mfa(nil, :bar, []) == "nil.bar()"
     assert Exception.format_mfa(:foo, :bar, [1, 2]) == ":foo.bar(1, 2)"
+    assert Exception.format_mfa(Foo, :b@r, 1) == "Foo.\"b@r\"/1"
     assert Exception.format_mfa(Foo, :"bar baz", 1) == "Foo.\"bar baz\"/1"
     assert Exception.format_mfa(Foo, :"-func/2-fun-0-", 4) == "anonymous fn/4 in Foo.func/2"
+
+    assert Exception.format_mfa(Foo, :"-some function/2-fun-0-", 4) ==
+             "anonymous fn/4 in Foo.\"some function\"/2"
+
+    assert Exception.format_mfa(Foo, :"42", 1) == "Foo.\"42\"/1"
+    assert Exception.format_mfa(Foo, :Bar, [1, 2]) == "Foo.\"Bar\"(1, 2)"
+    assert Exception.format_mfa(Foo, :%{}, [1, 2]) == "Foo.\"%{}\"(1, 2)"
+    assert Exception.format_mfa(Foo, :..., 1) == "Foo.\"...\"/1"
   end
 
-  test "format_fa" do
-    assert Exception.format_fa(fn -> end, 1) =~
-           ~r"#Function<\d\.\d+/0 in Kernel\.ExceptionTest\.test format_fa/1>/1"
+  test "format_mfa/3 with Unicode" do
+    assert Exception.format_mfa(Foo, :olá, [1, 2]) == "Foo.olá(1, 2)"
+    assert Exception.format_mfa(Foo, :Olá, [1, 2]) == "Foo.\"Olá\"(1, 2)"
+    assert Exception.format_mfa(Foo, :Ólá, [1, 2]) == "Foo.\"Ólá\"(1, 2)"
+    assert Exception.format_mfa(Foo, :こんにちは世界, [1, 2]) == "Foo.こんにちは世界(1, 2)"
+
+    nfd = :unicode.characters_to_nfd_binary("olá")
+    assert Exception.format_mfa(Foo, String.to_atom(nfd), [1, 2]) == "Foo.\"#{nfd}\"(1, 2)"
   end
 
-  import Exception, only: [message: 1]
+  test "format_fa/2" do
+    assert Exception.format_fa(fn -> nil end, 1) =~
+             ~r"#Function<\d+\.\d+/0 in ExceptionTest\.\"test format_fa/2\"/1>/1"
+  end
+
+  describe "format_exit/1" do
+    test "with atom/tuples" do
+      assert Exception.format_exit(:bye) == ":bye"
+      assert Exception.format_exit(:noconnection) == "no connection"
+      assert Exception.format_exit({:nodedown, :node@host}) == "no connection to node@host"
+      assert Exception.format_exit(:timeout) == "time out"
+      assert Exception.format_exit(:noproc) |> String.starts_with?("no process:")
+      assert Exception.format_exit(:killed) == "killed"
+      assert Exception.format_exit(:normal) == "normal"
+      assert Exception.format_exit(:shutdown) == "shutdown"
+      assert Exception.format_exit(:calling_self) == "process attempted to call itself"
+      assert Exception.format_exit({:shutdown, :bye}) == "shutdown: :bye"
+
+      assert Exception.format_exit({:badarg, [{:not_a_real_module, :function, 0, []}]}) ==
+               "an exception was raised:\n    ** (ArgumentError) argument error\n        :not_a_real_module.function/0"
+
+      assert Exception.format_exit({:bad_call, :request}) == "bad call: :request"
+      assert Exception.format_exit({:bad_cast, :request}) == "bad cast: :request"
+
+      assert Exception.format_exit({:start_spec, :unexpected}) ==
+               "bad child specification, got: :unexpected"
+
+      assert Exception.format_exit({:supervisor_data, :unexpected}) ==
+               "bad supervisor configuration, got: :unexpected"
+    end
+
+    defmodule Sup do
+      def start_link(fun), do: :supervisor.start_link(__MODULE__, fun)
+
+      def init(fun), do: fun.()
+    end
+
+    test "with supervisor errors" do
+      Process.flag(:trap_exit, true)
+
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> :foo end)
+
+      assert Exception.format_exit(reason) ==
+               "#{inspect(__MODULE__.Sup)}.init/1 returned a bad value: :foo"
+
+      return = {:ok, {:foo, []}}
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+      assert Exception.format_exit(reason) == "bad supervisor configuration, invalid type: :foo"
+
+      return = {:ok, {{:foo, 1, 1}, []}}
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+
+      assert Exception.format_exit(reason) ==
+               "bad supervisor configuration, invalid strategy: :foo"
+
+      return = {:ok, {{:one_for_one, :foo, 1}, []}}
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+
+      assert Exception.format_exit(reason) ==
+               "bad supervisor configuration, invalid max_restarts (intensity): :foo"
+
+      return = {:ok, {{:one_for_one, 1, :foo}, []}}
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+
+      assert Exception.format_exit(reason) ==
+               "bad supervisor configuration, invalid max_seconds (period): :foo"
+
+      return = {:ok, {{:simple_one_for_one, 1, 1}, :foo}}
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+      assert Exception.format_exit(reason) == "bad child specification, invalid children: :foo"
+
+      return = {:ok, {{:one_for_one, 1, 1}, [:foo]}}
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+
+      assert Exception.format_exit(reason) ==
+               "bad child specification, invalid child specification: :foo"
+
+      return = {:ok, {{:one_for_one, 1, 1}, [{:child, :foo, :temporary, 1, :worker, []}]}}
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+      assert Exception.format_exit(reason) == "bad child specification, invalid mfa: :foo"
+
+      return = {:ok, {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :foo, 1, :worker, []}]}}
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+
+      assert Exception.format_exit(reason) =~
+               "bad child specification, invalid restart type: :foo"
+
+      return = {
+        :ok,
+        {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :temporary, :foo, :worker, []}]}
+      }
+
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+      assert Exception.format_exit(reason) =~ "bad child specification, invalid shutdown: :foo"
+
+      return = {:ok, {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :temporary, 1, :foo, []}]}}
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+      assert Exception.format_exit(reason) =~ "bad child specification, invalid child type: :foo"
+
+      return =
+        {:ok, {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :temporary, 1, :worker, :foo}]}}
+
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+      assert Exception.format_exit(reason) =~ "bad child specification, invalid modules: :foo"
+
+      return = {
+        :ok,
+        {{:one_for_one, 1, 1}, [{:child, {:m, :f, []}, :temporary, 1, :worker, [{:foo}]}]}
+      }
+
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+      assert Exception.format_exit(reason) =~ "bad child specification, invalid module: {:foo}"
+
+      return = {
+        :ok,
+        {
+          {:one_for_one, 1, 1},
+          [
+            {:child, {:m, :f, []}, :permanent, 1, :worker, []},
+            {:child, {:m, :f, []}, :permanent, 1, :worker, []}
+          ]
+        }
+      }
+
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+
+      assert Exception.format_exit(reason) =~
+               "bad child specification, more than one child specification has the id: :child"
+
+      return = {
+        :ok,
+        {{:one_for_one, 1, 1}, [{:child, {Kernel, :exit, [:foo]}, :temporary, 1, :worker, []}]}
+      }
+
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+
+      assert Exception.format_exit(reason) ==
+               "shutdown: failed to start child: :child\n    ** (EXIT) :foo"
+
+      return = {
+        :ok,
+        {
+          {:one_for_one, 1, 1},
+          [{:child, {Kernel, :apply, [fn -> {:error, :foo} end, []]}, :temporary, 1, :worker, []}]
+        }
+      }
 
-  test "runtime error message" do
-    assert %RuntimeError{} |> message == "runtime error"
-    assert %RuntimeError{message: "exception"} |> message == "exception"
+      {:error, reason} = __MODULE__.Sup.start_link(fn -> return end)
+
+      assert Exception.format_exit(reason) ==
+               "shutdown: failed to start child: :child\n    ** (EXIT) :foo"
+    end
+
+    test "with call" do
+      reason =
+        try do
+          :gen_server.call(:does_not_exist, :hello)
+        catch
+          :exit, reason -> reason
+        end
+
+      expected_to_start_with =
+        "exited in: :gen_server.call(:does_not_exist, :hello)\n    ** (EXIT) no process:"
+
+      assert Exception.format_exit(reason) |> String.starts_with?(expected_to_start_with)
+    end
+
+    test "with nested calls" do
+      Process.flag(:trap_exit, true)
+      # Fake reason to prevent error_logger printing to stdout
+      exit_fun = fn -> receive do: (_ -> exit(:normal)) end
+
+      outer_pid =
+        spawn_link(fn ->
+          Process.flag(:trap_exit, true)
+
+          receive do
+            _ ->
+              :gen_event.call(spawn_link(exit_fun), :handler, :hello)
+          end
+        end)
+
+      reason =
+        try do
+          :gen_server.call(outer_pid, :hi)
+        catch
+          :exit, reason -> reason
+        end
+
+      formatted = Exception.format_exit(reason)
+      assert formatted =~ ~r"exited in: :gen_server\.call\(#PID<\d+\.\d+\.\d+>, :hi\)\n"
+
+      assert formatted =~
+               ~r"\s{4}\*\* \(EXIT\) exited in: :gen_event\.call\(#PID<\d+\.\d+\.\d+>, :handler, :hello\)\n"
+
+      assert formatted =~ ~r"\s{8}\*\* \(EXIT\) normal"
+    end
+
+    test "format_exit/1 with nested calls and exception" do
+      Process.flag(:trap_exit, true)
+      # Fake reason to prevent error_logger printing to stdout
+      exit_reason = {%ArgumentError{}, [{:not_a_real_module, :function, 0, []}]}
+      exit_fun = fn -> receive do: (_ -> exit(exit_reason)) end
+
+      outer_pid =
+        spawn_link(fn ->
+          Process.flag(:trap_exit, true)
+          :gen_event.call(spawn_link(exit_fun), :handler, :hello)
+        end)
+
+      reason =
+        try do
+          :gen_server.call(outer_pid, :hi)
+        catch
+          :exit, reason -> reason
+        end
+
+      formatted = Exception.format_exit(reason)
+      assert formatted =~ ~r"exited in: :gen_server\.call\(#PID<\d+\.\d+\.\d+>, :hi\)\n"
+
+      assert formatted =~
+               ~r"\s{4}\*\* \(EXIT\) exited in: :gen_event\.call\(#PID<\d+\.\d+\.\d+>, :handler, :hello\)\n"
+
+      assert formatted =~ ~r"\s{8}\*\* \(EXIT\) an exception was raised:\n"
+      assert formatted =~ ~r"\s{12}\*\* \(ArgumentError\) argument error\n"
+      assert formatted =~ ~r"\s{16}:not_a_real_module\.function/0"
+    end
   end
 
-  test "argument error message" do
-    assert %ArgumentError{} |> message == "argument error"
-    assert %ArgumentError{message: "exception"} |> message == "exception"
+  describe "blaming" do
+    test "does not annotate throws/exits" do
+      stack = [{Keyword, :pop, [%{}, :key, nil], [line: 13]}]
+      assert Exception.blame(:throw, :function_clause, stack) == {:function_clause, stack}
+      assert Exception.blame(:exit, :function_clause, stack) == {:function_clause, stack}
+    end
+
+    test "handles operators precedence" do
+      import PathHelpers
+
+      write_beam(
+        defmodule OperatorPrecedence do
+          def test!(x, y) when x in [1, 2, 3] and y >= 4, do: :ok
+        end
+      )
+
+      :code.purge(OperatorPrecedence)
+      :code.delete(OperatorPrecedence)
+
+      assert blame_message(OperatorPrecedence, & &1.test!(1, 2)) =~ """
+             no function clause matching in ExceptionTest.OperatorPrecedence.test!/2
+
+             The following arguments were given to ExceptionTest.OperatorPrecedence.test!/2:
+
+                 # 1
+                 1
+
+                 # 2
+                 2
+
+             Attempted function clauses (showing 1 out of 1):
+
+                 def test!(x, y) when (x === 1 or -x === 2- or -x === 3-) and -y >= 4-
+             """
+    end
+
+    test "reverts is_struct macro on guards for blaming" do
+      import PathHelpers
+
+      write_beam(
+        defmodule Req do
+          def get!(url)
+              when is_binary(url) or (is_struct(url) and is_struct(url, URI) and false) do
+            url
+          end
+
+          def get!(url, url_module)
+              when is_binary(url) or (is_struct(url) and is_struct(url, url_module) and false) do
+            url
+          end
+
+          def sub_get!(url) when is_struct(url.sub, URI), do: url.sub
+        end
+      )
+
+      :code.purge(Req)
+      :code.delete(Req)
+
+      assert blame_message(Req, & &1.get!(url: "https://elixir-lang.org")) =~ """
+             no function clause matching in ExceptionTest.Req.get!/1
+
+             The following arguments were given to ExceptionTest.Req.get!/1:
+
+                 # 1
+                 [url: "https://elixir-lang.org"]
+
+             Attempted function clauses (showing 1 out of 1):
+
+                 def get!(url) when -is_binary(url)- or -is_struct(url)- and -is_struct(url, URI)- and -false-
+             """
+
+      elixir_uri = %URI{} = URI.parse("https://elixir-lang.org")
+
+      assert blame_message(Req, & &1.get!(elixir_uri, URI)) =~ """
+             no function clause matching in ExceptionTest.Req.get!/2
+
+             The following arguments were given to ExceptionTest.Req.get!/2:
+
+                 # 1
+                 %URI{scheme: \"https\", authority: \"elixir-lang.org\", userinfo: nil, host: \"elixir-lang.org\", port: 443, path: nil, query: nil, fragment: nil}
+
+                 # 2
+                 URI
+
+             Attempted function clauses (showing 1 out of 1):
+
+                 def get!(url, url_module) when -is_binary(url)- or is_struct(url) and is_struct(url, url_module) and -false-
+             """
+
+      assert blame_message(Req, & &1.get!(elixir_uri)) =~ """
+             no function clause matching in ExceptionTest.Req.get!/1
+
+             The following arguments were given to ExceptionTest.Req.get!/1:
+
+                 # 1
+                 %URI{scheme: \"https\", authority: \"elixir-lang.org\", userinfo: nil, host: \"elixir-lang.org\", port: 443, path: nil, query: nil, fragment: nil}
+
+             Attempted function clauses (showing 1 out of 1):
+
+                 def get!(url) when -is_binary(url)- or is_struct(url) and is_struct(url, URI) and -false-
+             """
+
+      assert blame_message(Req, & &1.sub_get!(%{})) =~ """
+             no function clause matching in ExceptionTest.Req.sub_get!/1
+
+             The following arguments were given to ExceptionTest.Req.sub_get!/1:
+
+                 # 1
+                 %{}
+
+             Attempted function clauses (showing 1 out of 1):
+
+                 def sub_get!(url) when -is_struct(url.sub, URI)-
+             """
+    end
+
+    test "annotates badarg on apply" do
+      assert blame_message([], & &1.foo()) ==
+               "you attempted to apply a function named :foo on []. If you are using Kernel.apply/3, make sure " <>
+                 "the module is an atom. If you are using the dot syntax, such as " <>
+                 "module.function(), make sure the left-hand side of the dot is an atom representing a module"
+
+      assert blame_message([], &apply(&1, :foo, [])) ==
+               "you attempted to apply a function named :foo on []. If you are using Kernel.apply/3, make sure " <>
+                 "the module is an atom. If you are using the dot syntax, such as " <>
+                 "module.function(), make sure the left-hand side of the dot is an atom representing a module"
+
+      assert blame_message([], &apply(&1, :foo, [1, 2])) ==
+               "you attempted to apply a function on []. Modules (the first argument of apply) must always be an atom"
+    end
+
+    test "annotates function clause errors" do
+      import PathHelpers
+
+      write_beam(
+        defmodule ExampleModule do
+          def fun(arg1, arg2)
+          def fun(:one, :one), do: :ok
+          def fun(:two, :two), do: :ok
+        end
+      )
+
+      message = blame_message(ExceptionTest.ExampleModule, & &1.fun(:three, :four))
+
+      assert message =~ """
+             no function clause matching in ExceptionTest.ExampleModule.fun/2
+
+             The following arguments were given to ExceptionTest.ExampleModule.fun/2:
+
+                 # 1
+                 :three
+
+                 # 2
+                 :four
+
+             Attempted function clauses (showing 2 out of 2):
+
+                 def fun(-:one-, -:one-)
+                 def fun(-:two-, -:two-)
+             """
+    end
+
+    test "annotates undefined function error with suggestions" do
+      assert blame_message(Enum, & &1.map(:ok)) == """
+             function Enum.map/1 is undefined or private. Did you mean:
+
+                 * map/2
+             """
+
+      assert blame_message(Enum, & &1.man(:ok)) == """
+             function Enum.man/1 is undefined or private. Did you mean:
+
+                 * map/2
+                 * max/1
+                 * max/2
+                 * max/3
+                 * min/1
+             """
+
+      message = blame_message(:erlang, & &1.gt_cookie())
+      assert message =~ "function :erlang.gt_cookie/0 is undefined or private. Did you mean:"
+      assert message =~ "* get_cookie/0"
+      assert message =~ "* set_cookie/2"
+    end
+
+    test "annotates undefined function error with module suggestions" do
+      import PathHelpers
+
+      modules = [
+        Namespace.A.One,
+        Namespace.A.Two,
+        Namespace.A.Three,
+        Namespace.B.One,
+        Namespace.B.Two,
+        Namespace.B.Three
+      ]
+
+      for module <- modules do
+        write_beam(
+          defmodule module do
+            def foo, do: :bar
+          end
+        )
+      end
+
+      assert blame_message(ENUM, & &1.map(&1, 1)) == """
+             function ENUM.map/2 is undefined (module ENUM is not available). Did you mean:
+
+                   * Enum.map/2
+             """
+
+      assert blame_message(ENUM, & &1.not_a_function(&1, 1)) ==
+               "function ENUM.not_a_function/2 is undefined (module ENUM is not available). " <>
+                 "Make sure the module name is correct and has been specified in full (or that an alias has been defined)"
+
+      assert blame_message(One, & &1.foo()) == """
+             function One.foo/0 is undefined (module One is not available). Did you mean:
+
+                   * Namespace.A.One.foo/0
+                   * Namespace.B.One.foo/0
+             """
+
+      for module <- modules do
+        :code.purge(module)
+        :code.delete(module)
+      end
+    end
+
+    test "annotates undefined function clause error with macro hints" do
+      assert blame_message(Integer, & &1.is_odd(1)) ==
+               "function Integer.is_odd/1 is undefined or private. However, there is " <>
+                 "a macro with the same name and arity. Be sure to require Integer if " <>
+                 "you intend to invoke this macro"
+    end
+
+    test "annotates undefined function clause error with callback hints" do
+      capture_err(fn ->
+        Code.eval_string("""
+          defmodule Behaviour do
+            @callback callback() :: :ok
+          end
+
+          defmodule Implementation do
+            @behaviour Behaviour
+          end
+        """)
+      end)
+
+      assert blame_message(Implementation, & &1.callback()) ==
+               "function Implementation.callback/0 is undefined or private" <>
+                 ", but the behaviour Behaviour expects it to be present"
+    end
+
+    test "does not annotate undefined function clause error with callback hints when callback is optional" do
+      defmodule BehaviourWithOptional do
+        @callback callback() :: :ok
+        @callback optional() :: :ok
+        @optional_callbacks callback: 0, optional: 0
+      end
+
+      defmodule ImplementationWithOptional do
+        @behaviour BehaviourWithOptional
+        def callback(), do: :ok
+      end
+
+      assert blame_message(ImplementationWithOptional, & &1.optional()) ==
+               "function ExceptionTest.ImplementationWithOptional.optional/0 is undefined or private"
+    end
+
+    test "annotates undefined function clause error with otp obsolete hints" do
+      assert blame_message(:erlang, & &1.hash(1, 2)) ==
+               "function :erlang.hash/2 is undefined or private, use erlang:phash2/2 instead"
+    end
+
+    test "annotates undefined function clause error with nil hints" do
+      assert blame_message(nil, & &1.foo()) ==
+               "function nil.foo/0 is undefined. If you are using the dot syntax, " <>
+                 "such as module.function(), make sure the left-hand side of " <>
+                 "the dot is a module atom"
+
+      assert blame_message("nil.foo()", &Code.eval_string/1) ==
+               "function nil.foo/0 is undefined. If you are using the dot syntax, " <>
+                 "such as module.function(), make sure the left-hand side of " <>
+                 "the dot is a module atom"
+    end
+
+    test "annotates key error with suggestions if keys are atoms" do
+      message = blame_message(%{first: nil, second: nil}, fn map -> map.firts end)
+
+      assert message ==
+               """
+               key :firts not found in:
+
+                   %{first: nil, second: nil}
+
+               Did you mean:
+
+                   * :first
+               """
+
+      message = blame_message(%{"first" => nil, "second" => nil}, fn map -> map.firts end)
+
+      assert message == """
+             key :firts not found in:
+
+                 %{"first" => nil, "second" => nil}
+             """
+
+      message =
+        blame_message(%{"first" => nil, "second" => nil}, fn map -> Map.fetch!(map, "firts") end)
+
+      assert message ==
+               """
+               key "firts" not found in:
+
+                   %{"first" => nil, "second" => nil}
+               """
+
+      message =
+        blame_message(
+          [
+            created_at: nil,
+            updated_at: nil,
+            deleted_at: nil,
+            started_at: nil,
+            finished_at: nil
+          ],
+          fn kwlist ->
+            Keyword.fetch!(kwlist, :inserted_at)
+          end
+        )
+
+      assert message == """
+             key :inserted_at not found in:
+
+                 [
+                   created_at: nil,
+                   updated_at: nil,
+                   deleted_at: nil,
+                   started_at: nil,
+                   finished_at: nil
+                 ]
+
+             Did you mean:
+
+                 * :created_at
+                 * :finished_at
+                 * :started_at
+             """
+    end
+
+    test "annotates key error with suggestions for structs" do
+      message = blame_message(%URI{}, fn map -> map.schema end)
+      assert message =~ "key :schema not found in:\n\n    %URI{"
+      assert message =~ "Did you mean:"
+      assert message =~ "* :scheme"
+    end
+
+    test "annotates +/1 arithmetic errors" do
+      assert blame_message(:foo, &(+&1)) == "bad argument in arithmetic expression: +(:foo)"
+    end
+
+    test "annotates -/1 arithmetic errors" do
+      assert blame_message(:foo, &(-&1)) == "bad argument in arithmetic expression: -(:foo)"
+    end
+
+    test "annotates div arithmetic errors" do
+      assert blame_message(0, &div(10, &1)) ==
+               "bad argument in arithmetic expression: div(10, 0)"
+    end
+
+    test "annotates rem arithmetic errors" do
+      assert blame_message(0, &rem(10, &1)) ==
+               "bad argument in arithmetic expression: rem(10, 0)"
+    end
+
+    test "annotates band arithmetic errors" do
+      import Bitwise
+
+      assert blame_message(:foo, &band(&1, 10)) ==
+               "bad argument in arithmetic expression: Bitwise.band(:foo, 10)"
+
+      assert blame_message(:foo, &(&1 &&& 10)) ==
+               "bad argument in arithmetic expression: Bitwise.band(:foo, 10)"
+    end
+
+    test "annotates bor arithmetic errors" do
+      import Bitwise
+
+      assert blame_message(:foo, &bor(&1, 10)) ==
+               "bad argument in arithmetic expression: Bitwise.bor(:foo, 10)"
+
+      assert blame_message(:foo, &(&1 ||| 10)) ==
+               "bad argument in arithmetic expression: Bitwise.bor(:foo, 10)"
+    end
+
+    test "annotates bxor arithmetic errors" do
+      import Bitwise
+
+      assert blame_message(:foo, &bxor(&1, 10)) ==
+               "bad argument in arithmetic expression: Bitwise.bxor(:foo, 10)"
+    end
+
+    test "annotates bsl arithmetic errors" do
+      import Bitwise
+
+      assert blame_message(:foo, &bsl(10, &1)) ==
+               "bad argument in arithmetic expression: Bitwise.bsl(10, :foo)"
+
+      assert blame_message(:foo, &(10 <<< &1)) ==
+               "bad argument in arithmetic expression: Bitwise.bsl(10, :foo)"
+    end
+
+    test "annotates bsr arithmetic errors" do
+      import Bitwise
+
+      assert blame_message(:foo, &bsr(10, &1)) ==
+               "bad argument in arithmetic expression: Bitwise.bsr(10, :foo)"
+
+      assert blame_message(:foo, &(10 >>> &1)) ==
+               "bad argument in arithmetic expression: Bitwise.bsr(10, :foo)"
+    end
+
+    test "annotates bnot arithmetic errors" do
+      import Bitwise
+
+      assert blame_message(:foo, &bnot(&1)) ==
+               "bad argument in arithmetic expression: Bitwise.bnot(:foo)"
+    end
+
+    defp blame_message(arg, fun) do
+      try do
+        fun.(arg)
+      rescue
+        e ->
+          Exception.blame(:error, e, __STACKTRACE__) |> elem(0) |> Exception.message()
+      end
+    end
+  end
+
+  describe "blaming unit tests" do
+    test "annotates clauses errors" do
+      import PathHelpers
+
+      write_beam(
+        defmodule BlameModule do
+          def fun(arg), do: arg
+        end
+      )
+
+      args = [nil]
+
+      {exception, stack} =
+        Exception.blame(:error, :function_clause, [{BlameModule, :fun, args, [line: 13]}])
+
+      assert %FunctionClauseError{kind: :def, args: ^args, clauses: [_]} = exception
+      assert stack == [{BlameModule, :fun, 1, [line: 13]}]
+    end
+
+    @tag :require_ast
+    test "annotates args and clauses from mfa" do
+      import PathHelpers
+
+      write_beam(
+        defmodule Blaming do
+          def with_elem(x, y) when elem(x, 1) == 0 and elem(x, y) == 1 do
+            {x, y}
+          end
+
+          def fetch(%module{} = container, key), do: {module, container, key}
+          def fetch(map, key) when is_map(map), do: {map, key}
+          def fetch(list, key) when is_list(list) and is_atom(key), do: {list, key}
+          def fetch(nil, _key), do: nil
+
+          require Integer
+          def even_and_odd(foo, bar) when Integer.is_even(foo) and Integer.is_odd(bar), do: :ok
+        end
+      )
+
+      :code.purge(Blaming)
+      :code.delete(Blaming)
+
+      {:ok, :def, clauses} = Exception.blame_mfa(Blaming, :with_elem, [1, 2])
+
+      assert annotated_clauses_to_string(clauses) == [
+               "{[+x+, +y+], [-elem(x, 1) == 0- and -elem(x, y) == 1-]}"
+             ]
+
+      {:ok, :def, clauses} = Exception.blame_mfa(Blaming, :fetch, [self(), "oops"])
+
+      assert annotated_clauses_to_string(clauses) == [
+               "{[-%module{} = container-, +key+], []}",
+               "{[+map+, +key+], [-is_map(map)-]}",
+               "{[+list+, +key+], [-is_list(list)- and -is_atom(key)-]}",
+               "{[-nil-, +_key+], []}"
+             ]
+
+      {:ok, :def, clauses} = Exception.blame_mfa(Blaming, :even_and_odd, [1, 1])
+
+      assert annotated_clauses_to_string(clauses) == [
+               "{[+foo+, +bar+], [+is_integer(foo)+ and -Bitwise.band(foo, 1) == 0- and +is_integer(bar)+ and +Bitwise.band(bar, 1) == 1+]}"
+             ]
+
+      {:ok, :defmacro, clauses} = Exception.blame_mfa(Kernel, :!, [true])
+
+      assert annotated_clauses_to_string(clauses) == [
+               "{[-{:!, _, [value]}-], []}",
+               "{[+value+], []}"
+             ]
+    end
+
+    defp annotated_clauses_to_string(clauses) do
+      Enum.map(clauses, fn {args, clauses} ->
+        args = Enum.map_join(args, ", ", &arg_to_string/1)
+        clauses = Enum.map_join(clauses, ", ", &clause_to_string/1)
+        "{[#{args}], [#{clauses}]}"
+      end)
+    end
+
+    defp arg_to_string(%{match?: true, node: node}), do: "+" <> Macro.to_string(node) <> "+"
+    defp arg_to_string(%{match?: false, node: node}), do: "-" <> Macro.to_string(node) <> "-"
+
+    defp clause_to_string({op, _, [left, right]}),
+      do: clause_to_string(left) <> " #{op} " <> clause_to_string(right)
+
+    defp clause_to_string(other),
+      do: arg_to_string(other)
+  end
+
+  describe "exception messages" do
+    import Exception, only: [message: 1]
+
+    test "RuntimeError" do
+      assert %RuntimeError{} |> message() == "runtime error"
+      assert %RuntimeError{message: "unexpected roquefort"} |> message() == "unexpected roquefort"
+    end
+
+    test "ArithmeticError" do
+      assert %ArithmeticError{} |> message() == "bad argument in arithmetic expression"
+
+      assert %ArithmeticError{message: "unexpected camembert"}
+             |> message() == "unexpected camembert"
+    end
+
+    test "ArgumentError" do
+      assert %ArgumentError{} |> message() == "argument error"
+      assert %ArgumentError{message: "unexpected comté"} |> message() == "unexpected comté"
+    end
+
+    test "KeyError" do
+      assert %KeyError{} |> message() == "key nil not found"
+      assert %KeyError{message: "key missed"} |> message() == "key missed"
+    end
+
+    test "Enum.OutOfBoundsError" do
+      assert %Enum.OutOfBoundsError{} |> message() == "out of bounds error"
+
+      assert %Enum.OutOfBoundsError{message: "the brie is not on the table"}
+             |> message() == "the brie is not on the table"
+    end
+
+    test "Enum.EmptyError" do
+      assert %Enum.EmptyError{} |> message() == "empty error"
+
+      assert %Enum.EmptyError{message: "there is no saint-nectaire left!"}
+             |> message() == "there is no saint-nectaire left!"
+    end
+
+    test "UndefinedFunctionError" do
+      assert %UndefinedFunctionError{} |> message() == "undefined function"
+
+      assert %UndefinedFunctionError{module: Kernel, function: :bar, arity: 1}
+             |> message() == "function Kernel.bar/1 is undefined or private"
+
+      assert %UndefinedFunctionError{module: Foo, function: :bar, arity: 1}
+             |> message() ==
+               "function Foo.bar/1 is undefined (module Foo is not available). " <>
+                 "Make sure the module name is correct and has been specified in full (or that an alias has been defined)"
+
+      assert %UndefinedFunctionError{module: nil, function: :bar, arity: 3}
+             |> message() == "function nil.bar/3 is undefined"
+
+      assert %UndefinedFunctionError{module: nil, function: :bar, arity: 0}
+             |> message() == "function nil.bar/0 is undefined"
+    end
+
+    test "FunctionClauseError" do
+      assert %FunctionClauseError{} |> message() == "no function clause matches"
+
+      assert %FunctionClauseError{module: Foo, function: :bar, arity: 1}
+             |> message() == "no function clause matching in Foo.bar/1"
+    end
+
+    test "ErlangError" do
+      assert %ErlangError{original: :sample} |> message() == "Erlang error: :sample"
+    end
+
+    test "MissingApplicationsError" do
+      assert %MissingApplicationsError{
+               apps: [{:logger, "~> 1.18"}, {:ex_unit, Version.parse_requirement!(">= 0.0.0")}],
+               description: "applications are required"
+             }
+             |> message() == """
+             applications are required
+
+             To address this, include these applications as your dependencies:
+
+               {:logger, "~> 1.18"}
+               {:ex_unit, ">= 0.0.0"}\
+             """
+    end
   end
 
-  test "undefined function message" do
-    assert %UndefinedFunctionError{} |> message == "undefined function"
-    assert %UndefinedFunctionError{module: Foo, function: :bar, arity: 1} |> message ==
-           "undefined function: Foo.bar/1"
-    assert %UndefinedFunctionError{module: nil, function: :bar, arity: 0} |> message ==
-           "undefined function: nil.bar/0"
+  describe "error_info" do
+    test "badarg on erlang" do
+      assert message(:erlang, & &1.element("foo", "bar")) == """
+             errors were found at the given arguments:
+
+               * 1st argument: not an integer
+               * 2nd argument: not a tuple
+             """
+    end
+
+    test "badarg on ets" do
+      ets = :ets.new(:foo, [])
+      :ets.delete(ets)
+
+      assert message(:ets, & &1.insert(ets, 1)) == """
+             errors were found at the given arguments:
+
+               * 1st argument: the table identifier does not refer to an existing ETS table
+               * 2nd argument: not a tuple
+             """
+    end
+
+    test "system_limit on counters" do
+      assert message(:counters, & &1.new(123_456_789_123_456_789_123_456_789, [])) == """
+             a system limit has been reached due to errors at the given arguments:
+
+               * 1st argument: counters array size reached a system limit
+             """
+    end
   end
 
-  test "function clause message" do
-    assert %FunctionClauseError{} |> message ==
-           "no function clause matches"
-    assert %FunctionClauseError{module: Foo, function: :bar, arity: 1} |> message ==
-           "no function clause matching in Foo.bar/1"
+  describe "binary constructor error info" do
+    defp concat(a, b), do: a <> b
+
+    test "on binary concatenation" do
+      assert message(123, &concat(&1, "bar")) ==
+               "construction of binary failed: segment 1 of type 'binary': expected a binary but got: 123"
+
+      assert message(~D[0001-02-03], &concat(&1, "bar")) ==
+               "construction of binary failed: segment 1 of type 'binary': expected a binary but got: ~D[0001-02-03]"
+    end
   end
 
-  test "erlang error message" do
-    assert %ErlangError{original: :sample} |> message ==
-           "erlang error: :sample"
+  defp message(arg, fun) do
+    try do
+      fun.(arg)
+    rescue
+      e -> Exception.message(e)
+    end
+  end
+
+  def dummy_error_extras(_exception, _stacktrace), do: %{general: "foo"}
+
+  def dummy_error_chardata(_exception, _stacktrace) do
+    %{general: ~c"this is " ++ [~c"chardata"], reason: ~c"this " ++ [~c"too"]}
   end
 end
diff --git a/lib/elixir/test/elixir/file/stream_test.exs b/lib/elixir/test/elixir/file/stream_test.exs
new file mode 100644
index 00000000000..cade78f0c85
--- /dev/null
+++ b/lib/elixir/test/elixir/file/stream_test.exs
@@ -0,0 +1,310 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule File.StreamTest do
+  use ExUnit.Case
+  import PathHelpers
+
+  setup do
+    File.mkdir_p!(tmp_path())
+    on_exit(fn -> File.rm_rf(tmp_path()) end)
+    :ok
+  end
+
+  defp stream!(node, src, lines_or_bytes_or_modes \\ []) do
+    :erpc.call(node, File, :stream!, [src, lines_or_bytes_or_modes])
+  end
+
+  defp stream!(node, src, modes, lines_or_bytes) do
+    :erpc.call(node, File, :stream!, [src, modes, lines_or_bytes])
+  end
+
+  distributed_node = :"secondary@#{node() |> Atom.to_string() |> :binary.split("@") |> tl()}"
+
+  for {type, node} <- [local: node(), distributed: distributed_node] do
+    describe "#{type} node" do
+      @describetag type
+      @node node
+
+      test "returns a struct" do
+        src = fixture_path("file.txt")
+        stream = stream!(@node, src)
+        assert %File.Stream{} = stream
+        assert stream.modes == [:raw, :read_ahead, :binary]
+        assert stream.raw
+        assert stream.line_or_bytes == :line
+
+        stream = stream!(@node, src, read_ahead: false)
+        assert %File.Stream{} = stream
+        assert stream.modes == [:raw, :binary]
+        assert stream.raw
+
+        stream = stream!(@node, src, read_ahead: 5000)
+        assert %File.Stream{} = stream
+        assert stream.modes == [:raw, {:read_ahead, 5000}, :binary]
+        assert stream.raw
+
+        stream = stream!(@node, src, 10, [:utf8])
+        assert %File.Stream{} = stream
+        assert stream.modes == [{:encoding, :utf8}, :binary]
+        refute stream.raw
+        assert stream.line_or_bytes == 10
+      end
+
+      test "counts bytes/characters" do
+        src = fixture_path("file.txt")
+        stream = stream!(@node, src)
+        assert Enum.count(stream) == 1
+
+        stream = stream!(@node, src, [:utf8])
+        assert Enum.count(stream) == 1
+
+        stream = stream!(@node, src, 2)
+        assert Enum.count(stream) == 2
+      end
+
+      test "reads and writes lines" do
+        src = fixture_path("file.txt")
+        dest = tmp_path("tmp_test.txt")
+
+        try do
+          stream = stream!(@node, src)
+
+          File.open(dest, [:write], fn target ->
+            Enum.each(stream, fn line ->
+              IO.write(target, String.replace(line, "O", "A"))
+            end)
+          end)
+
+          assert File.read(dest) == {:ok, "FAA\n"}
+        after
+          File.rm(dest)
+        end
+      end
+
+      test "reads and writes bytes" do
+        src = fixture_path("file.txt")
+        dest = tmp_path("tmp_test.txt")
+
+        try do
+          stream = stream!(@node, src, 1)
+
+          File.open(dest, [:write], fn target ->
+            Enum.each(stream, fn <<char>> ->
+              IO.write(target, <<char + 1>>)
+            end)
+          end)
+
+          assert File.read(dest) == {:ok, "GPP\v"}
+        after
+          File.rm(dest)
+        end
+      end
+
+      test "is collectable" do
+        src = fixture_path("file.txt")
+        dest = tmp_path("tmp_test.txt")
+
+        try do
+          refute File.exists?(dest)
+          original = stream!(@node, dest)
+
+          stream =
+            stream!(@node, src)
+            |> Stream.map(&String.replace(&1, "O", "A"))
+            |> Enum.into(original)
+
+          assert stream == original
+          assert File.read(dest) == {:ok, "FAA\n"}
+        after
+          File.rm(dest)
+        end
+      end
+
+      test "is collectable with append" do
+        src = fixture_path("file.txt")
+        dest = tmp_path("tmp_test.txt")
+
+        try do
+          refute File.exists?(dest)
+          original = stream!(@node, dest, [:append])
+
+          stream!(@node, src, [:append])
+          |> Stream.map(&String.replace(&1, "O", "A"))
+          |> Enum.into(original)
+
+          stream!(@node, src, [:append])
+          |> Enum.into(original)
+
+          assert File.read(dest) == {:ok, "FAA\nFOO\n"}
+        after
+          File.rm(dest)
+        end
+      end
+
+      test "supports byte offset" do
+        src = fixture_path("file.txt")
+
+        assert @node
+               |> stream!(src, read_offset: 0)
+               |> Enum.take(1) == ["FOO\n"]
+
+        assert @node
+               |> stream!(src, read_offset: 1)
+               |> Enum.take(1) == ["OO\n"]
+
+        assert @node
+               |> stream!(src, read_offset: 4)
+               |> Enum.take(1) == []
+
+        assert @node |> stream!(src, 1, read_offset: 1) |> Enum.count() == 3
+        assert @node |> stream!(src, 1, read_offset: 4) |> Enum.count() == 0
+      end
+
+      test "applies offset after trimming BOM" do
+        src = fixture_path("utf8_bom.txt")
+
+        assert @node
+               |> stream!(src, [:trim_bom, read_offset: 4])
+               |> Enum.take(1) == ["сский\n"]
+
+        assert @node |> stream!(src, 1, [:trim_bom, read_offset: 4]) |> Enum.count() == 15
+      end
+
+      test "keeps BOM when raw" do
+        src = fixture_path("utf8_bom.txt")
+
+        assert @node
+               |> stream!(src, [])
+               |> Enum.take(1) == [<<239, 187, 191>> <> "Русский\n"]
+
+        assert @node
+               |> stream!(src, 1)
+               |> Enum.take(5) == [<<239>>, <<187>>, <<191>>, <<208>>, <<160>>]
+
+        assert @node |> stream!(src, []) |> Enum.count() == 2
+        assert @node |> stream!(src, 1) |> Enum.count() == 22
+      end
+
+      test "trims BOM via option when raw" do
+        src = fixture_path("utf8_bom.txt")
+
+        assert @node
+               |> stream!(src, [:trim_bom])
+               |> Enum.take(1) == ["Русский\n"]
+
+        assert @node
+               |> stream!(src, 1, [:trim_bom])
+               |> Enum.take(5) == [<<208>>, <<160>>, <<209>>, <<131>>, <<209>>]
+
+        assert @node |> stream!(src, [:trim_bom]) |> Enum.count() == 2
+        assert @node |> stream!(src, 1, [:trim_bom]) |> Enum.count() == 19
+        assert @node |> stream!(src, 2, [:trim_bom]) |> Enum.count() == 10
+      end
+
+      test "keeps BOM with utf8 encoding" do
+        src = fixture_path("utf8_bom.txt")
+
+        assert @node
+               |> stream!(src, encoding: :utf8)
+               |> Enum.take(1) == [<<239, 187, 191>> <> "Русский\n"]
+
+        assert @node
+               |> stream!(src, 1, encoding: :utf8)
+               |> Enum.take(9) == ["\uFEFF", "Р", "у", "с", "с", "к", "и", "й", "\n"]
+      end
+
+      test "trims BOM via option with utf8 encoding" do
+        src = fixture_path("utf8_bom.txt")
+
+        assert @node
+               |> stream!(src, [{:encoding, :utf8}, :trim_bom])
+               |> Enum.take(1) == ["Русский\n"]
+
+        assert @node
+               |> stream!(src, 1, [{:encoding, :utf8}, :trim_bom])
+               |> Enum.take(8) == ["Р", "у", "с", "с", "к", "и", "й", "\n"]
+      end
+
+      test "keeps BOM with UTF16 BE" do
+        src = fixture_path("utf16_be_bom.txt")
+
+        assert @node
+               |> stream!(src, [{:encoding, {:utf16, :big}}])
+               |> Enum.take(1) == ["\uFEFFРусский\n"]
+      end
+
+      test "keeps BOM with UTF16 LE" do
+        src = fixture_path("utf16_le_bom.txt")
+
+        assert @node
+               |> stream!(src, [{:encoding, {:utf16, :little}}])
+               |> Enum.take(1) == ["\uFEFFРусский\n"]
+      end
+
+      test "trims BOM via option with utf16 BE encoding" do
+        src = fixture_path("utf16_be_bom.txt")
+
+        assert @node
+               |> stream!(src, [{:encoding, {:utf16, :big}}, :trim_bom])
+               |> Enum.take(1) == ["Русский\n"]
+
+        assert @node
+               |> stream!(src, 1, [{:encoding, {:utf16, :big}}, :trim_bom])
+               |> Enum.take(8) == ["Р", "у", "с", "с", "к", "и", "й", "\n"]
+      end
+
+      test "trims BOM via option with utf16 LE encoding" do
+        src = fixture_path("utf16_le_bom.txt")
+
+        assert @node
+               |> stream!(src, [{:encoding, {:utf16, :little}}, :trim_bom])
+               |> Enum.take(1) == ["Русский\n"]
+
+        assert @node
+               |> stream!(src, 1, [{:encoding, {:utf16, :little}}, :trim_bom])
+               |> Enum.take(8) == ["Р", "у", "с", "с", "к", "и", "й", "\n"]
+      end
+
+      test "reads and writes line by line in UTF-8" do
+        src = fixture_path("file.txt")
+        dest = tmp_path("tmp_test.txt")
+
+        try do
+          stream = stream!(@node, src)
+
+          File.open(dest, [:write, :utf8], fn target ->
+            Enum.each(stream, fn line ->
+              IO.write(target, String.replace(line, "O", "A"))
+            end)
+          end)
+
+          assert File.read(dest) == {:ok, "FAA\n"}
+        after
+          File.rm(dest)
+        end
+      end
+
+      test "reads and writes character in UTF-8" do
+        src = fixture_path("file.txt")
+        dest = tmp_path("tmp_test.txt")
+
+        try do
+          stream = stream!(@node, src, 1, [:utf8])
+
+          File.open(dest, [:write], fn target ->
+            Enum.each(stream, fn <<char::utf8>> ->
+              IO.write(target, <<char + 1::utf8>>)
+            end)
+          end)
+
+          assert File.read(dest) == {:ok, "GPP\v"}
+        after
+          File.rm(dest)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/file_test.exs b/lib/elixir/test/elixir/file_test.exs
index 3c43287e693..cdfca308578 100644
--- a/lib/elixir/test/elixir/file_test.exs
+++ b/lib/elixir/test/elixir/file_test.exs
@@ -1,31 +1,371 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-defmodule Elixir.FileCase do
-  use ExUnit.CaseTemplate
-  import PathHelpers
+Code.require_file("test_helper.exs", __DIR__)
 
-  using do
-    quote do
-      import PathHelpers
-    end
-  end
+defmodule FileTest do
+  use ExUnit.Case
+  import PathHelpers
 
   setup do
-    File.mkdir_p!(tmp_path)
-    on_exit(fn -> File.rm_rf(tmp_path) end)
+    File.mkdir_p!(tmp_path())
+    on_exit(fn -> File.rm_rf(tmp_path()) end)
     :ok
   end
-end
 
-defmodule FileTest do
-  use Elixir.FileCase
-  import Regex, only: [escape: 1]
+  describe "rename" do
+    # Following Erlang's underlying implementation
+    #
+    # Renaming files
+    # :ok               -> rename file to existing file default behavior
+    # {:error, :eisdir} -> rename file to existing empty dir
+    # {:error, :eisdir} -> rename file to existing non-empty dir
+    # :ok               -> rename file to non-existing location
+    # {:error, :eexist} -> rename file to existing file
+    # :ok               -> rename file to itself
+
+    # Renaming dirs
+    # {:error, :enotdir} -> rename dir to existing file
+    # :ok                -> rename dir to non-existing leaf location
+    # {:error, ??}       -> rename dir to non-existing parent location
+    # :ok                -> rename dir to itself
+    # :ok                -> rename dir to existing empty dir default behavior
+    # {:error, :eexist}  -> rename dir to existing empty dir
+    # {:error, :einval}  -> rename parent dir to existing sub dir
+    # {:error, :einval}  -> rename parent dir to non-existing sub dir
+    # {:error, :eexist}  -> rename dir to existing non-empty dir
+
+    # other tests
+    # {:error, :enoent} -> rename unknown source
+    # :ok               -> rename preserves mode
+    test "rename file to existing file default behavior" do
+      src = tmp_fixture_path("file.txt")
+      dest = tmp_path("tmp.file")
+
+      File.write!(dest, "hello")
+
+      try do
+        assert File.exists?(dest)
+        assert File.rename(src, dest) == :ok
+        refute File.exists?(src)
+        assert File.read!(dest) == "FOO\n"
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename file to existing empty dir" do
+      src = tmp_fixture_path("file.txt")
+      dest = tmp_path("tmp")
+
+      try do
+        File.mkdir(dest)
+        assert File.rename(src, dest) == {:error, :eisdir}
+        assert File.exists?(src)
+        refute File.exists?(tmp_path("tmp/file.txt"))
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename file to existing non-empty dir" do
+      src = tmp_fixture_path("file.txt")
+      dest = tmp_path("tmp")
+
+      try do
+        File.mkdir_p(Path.join(dest, "a"))
+        assert File.rename(src, dest) in [{:error, :eisdir}, {:error, :eexist}]
+        assert File.exists?(src)
+        refute File.exists?(Path.join(dest, "file.txt"))
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename file to non-existing location" do
+      src = tmp_fixture_path("file.txt")
+      dest = tmp_path("tmp.file")
+
+      try do
+        refute File.exists?(dest)
+        assert File.rename(src, dest) == :ok
+        assert File.exists?(dest)
+        refute File.exists?(src)
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename file to existing file" do
+      src = tmp_fixture_path("file.txt")
+      dest = tmp_path("tmp.file")
+
+      File.write!(dest, "hello")
+
+      try do
+        assert File.exists?(dest)
+        assert File.rename(src, dest) == :ok
+        refute File.exists?(src)
+        assert File.read!(dest) == "FOO\n"
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename file to itself" do
+      src = tmp_fixture_path("file.txt")
+      dest = src
+
+      try do
+        assert File.exists?(src)
+        assert File.rename(src, dest) == :ok
+        assert File.exists?(src)
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename! file to existing file default behavior" do
+      src = tmp_fixture_path("file.txt")
+      dest = tmp_path("tmp.file")
+
+      File.write!(dest, "hello")
+
+      try do
+        assert File.exists?(dest)
+        assert File.rename!(src, dest) == :ok
+        refute File.exists?(src)
+        assert File.read!(dest) == "FOO\n"
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename! with invalid file" do
+      src = tmp_fixture_path("invalid.txt")
+      dest = tmp_path("tmp.file")
+
+      message =
+        "could not rename from #{inspect(src)} to #{inspect(dest)}: no such file or directory"
+
+      assert_raise File.RenameError, message, fn ->
+        File.rename!(src, dest)
+      end
+    end
+
+    test "rename dir to existing file" do
+      src = tmp_fixture_path("cp_r")
+      dest = tmp_path("tmp.file")
+
+      try do
+        File.touch(dest)
+        assert File.rename(src, dest) == {:error, :enotdir}
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename dir to non-existing leaf location" do
+      src = tmp_fixture_path("cp_r")
+      dest = tmp_path("tmp")
+
+      try do
+        refute File.exists?(tmp_path("tmp/a/1.txt"))
+        refute File.exists?(tmp_path("tmp/a/a/2.txt"))
+        refute File.exists?(tmp_path("tmp/b/3.txt"))
+
+        assert File.rename(src, dest) == :ok
+        {:ok, files} = File.ls(dest)
+        assert length(files) == 2
+        assert "a" in files
+
+        {:ok, files} = File.ls(tmp_path("tmp/a"))
+        assert length(files) == 2
+        assert "1.txt" in files
+
+        assert File.exists?(tmp_path("tmp/a/1.txt"))
+        assert File.exists?(tmp_path("tmp/a/a/2.txt"))
+        assert File.exists?(tmp_path("tmp/b/3.txt"))
+
+        refute File.exists?(src)
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename dir to non-existing parent location" do
+      src = tmp_fixture_path("cp_r")
+      dest = tmp_path("tmp/a/b")
+
+      try do
+        assert File.rename(src, dest) == {:error, :enoent}
+        assert File.exists?(src)
+        refute File.exists?(dest)
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename dir to itself" do
+      src = tmp_fixture_path("cp_r")
+      dest = src
+
+      try do
+        assert File.exists?(src)
+        assert File.rename(src, dest) == :ok
+        assert File.exists?(src)
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename parent dir to existing sub dir" do
+      src = tmp_fixture_path("cp_r")
+      dest = tmp_path("cp_r/a")
+
+      try do
+        assert File.exists?(src)
+        assert File.rename(src, dest) in [{:error, :einval}, {:error, :eexist}]
+        assert File.exists?(src)
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename parent dir to non-existing sub dir" do
+      src = tmp_fixture_path("cp_r")
+      dest = tmp_path("cp_r/x")
+
+      try do
+        assert File.exists?(src)
+        assert File.rename(src, dest) == {:error, :einval}
+        assert File.exists?(src)
+        refute File.exists?(dest)
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename dir to existing empty dir default behavior" do
+      src = tmp_fixture_path("cp_r")
+      dest = tmp_path("tmp")
+
+      File.mkdir(dest)
+
+      try do
+        refute File.exists?(tmp_path("tmp/a"))
+
+        assert File.rename(src, dest) == :ok
+        {:ok, files} = File.ls(dest)
+        assert length(files) == 2
+        assert "a" in files
+
+        {:ok, files} = File.ls(tmp_path("tmp/a"))
+        assert length(files) == 2
+        assert "1.txt" in files
+
+        assert File.exists?(tmp_path("tmp/a/1.txt"))
+        assert File.exists?(tmp_path("tmp/a/a/2.txt"))
+        assert File.exists?(tmp_path("tmp/b/3.txt"))
+
+        refute File.exists?(src)
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename dir to existing empty dir" do
+      src = tmp_fixture_path("cp_r")
+      dest = tmp_path("tmp")
+
+      File.mkdir(dest)
+
+      try do
+        assert File.exists?(dest)
+        assert File.rename(src, dest) == :ok
+        refute File.exists?(src)
+        assert File.exists?(tmp_path("tmp/a"))
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename dir to existing non-empty dir" do
+      src = tmp_fixture_path("cp_r")
+      dest = tmp_path("tmp")
+
+      File.mkdir_p(tmp_path("tmp/x"))
+
+      try do
+        assert File.exists?(tmp_path("tmp/x"))
+        assert File.exists?(src)
+        refute File.exists?(tmp_path("tmp/a"))
+
+        assert File.rename(src, dest) == {:error, :eexist}
+
+        assert File.exists?(tmp_path("tmp/x"))
+        assert File.exists?(src)
+        refute File.exists?(tmp_path("tmp/a"))
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "rename unknown source" do
+      src = fixture_path("unknown")
+      dest = tmp_path("tmp")
+
+      try do
+        assert File.rename(src, dest) == {:error, :enoent}
+      after
+        File.rm_rf(dest)
+      end
+    end
 
-  defmodule Cp do
-    use Elixir.FileCase
+    test "rename preserves mode" do
+      File.mkdir_p!(tmp_path("tmp"))
+      src = tmp_fixture_path("cp_mode")
+      dest = tmp_path("tmp/cp_mode")
+
+      try do
+        %File.Stat{mode: src_mode} = File.stat!(src)
+        File.rename(src, dest)
+        %File.Stat{mode: dest_mode} = File.stat!(dest)
+        assert src_mode == dest_mode
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    def tmp_fixture_path(extra) do
+      src = fixture_path(extra)
+      dest = tmp_path(extra)
+      File.cp_r(src, dest)
+      dest
+    end
+  end
 
-    test :cp_with_src_file_and_dest_file do
-      src  = fixture_path("file.txt")
+  describe "cp" do
+    test "cp with src file and dest file" do
+      src = fixture_path("file.txt")
       dest = tmp_path("sample.txt")
 
       File.touch(dest)
@@ -39,8 +379,8 @@ defmodule FileTest do
       end
     end
 
-    test :cp_with_src_file_and_dest_dir do
-      src  = fixture_path("file.txt")
+    test "cp with src file and dest dir" do
+      src = fixture_path("file.txt")
       dest = tmp_path("tmp")
 
       File.mkdir(dest)
@@ -48,32 +388,32 @@ defmodule FileTest do
       try do
         assert File.cp(src, dest) == {:error, :eisdir}
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_with_src_file_and_dest_unknown do
-      src   = fixture_path("file.txt")
-      dest  = tmp_path("tmp.file")
+    test "cp with src file and dest unknown" do
+      src = fixture_path("file.txt")
+      dest = tmp_path("tmp.file")
 
       try do
         refute File.exists?(dest)
         assert File.cp(src, dest) == :ok
         assert File.exists?(dest)
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_with_src_dir do
-      src   = fixture_path("cp_r")
-      dest  = tmp_path("tmp.file")
+    test "cp with src dir" do
+      src = fixture_path("cp_r")
+      dest = tmp_path("tmp.file")
       assert File.cp(src, dest) == {:error, :eisdir}
     end
 
-    test :cp_with_conflict do
-      src   = fixture_path("file.txt")
-      dest  = tmp_path("tmp.file")
+    test "cp with conflict" do
+      src = fixture_path("file.txt")
+      dest = tmp_path("tmp.file")
 
       File.write!(dest, "hello")
 
@@ -82,31 +422,35 @@ defmodule FileTest do
         assert File.cp(src, dest) == :ok
         assert File.read!(dest) == "FOO\n"
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_with_conflict_with_function do
-      src   = fixture_path("file.txt")
-      dest  = tmp_path("tmp.file")
+    test "cp with conflict with function" do
+      src = fixture_path("file.txt")
+      dest = tmp_path("tmp.file")
 
       File.write!(dest, "hello")
 
       try do
         assert File.exists?(dest)
-        assert File.cp(src, dest, fn(src_file, dest_file) ->
-          assert src_file  == src
-          assert dest_file == dest
-          false
-        end) == :ok
+
+        assert File.cp(src, dest,
+                 on_conflict: fn src_file, dest_file ->
+                   assert src_file == src
+                   assert dest_file == dest
+                   false
+                 end
+               ) == :ok
+
         assert File.read!(dest) == "hello"
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_with_src_file_and_dest_file! do
-      src  = fixture_path("file.txt")
+    test "cp! with src file and dest file" do
+      src = fixture_path("file.txt")
       dest = tmp_path("sample.txt")
 
       File.touch(dest)
@@ -120,17 +464,39 @@ defmodule FileTest do
       end
     end
 
-    test :cp_with_src_dir! do
-      src   = fixture_path("cp_r")
-      dest  = tmp_path("tmp.file")
-      assert_raise File.CopyError, "could not copy recursively from #{src} to #{dest}: " <>
-          "illegal operation on a directory", fn ->
+    test "cp! with src dir" do
+      src = fixture_path("cp_r")
+      dest = tmp_path("tmp.file")
+
+      message =
+        "could not copy from #{inspect(src)} to #{inspect(dest)}: illegal operation on a directory"
+
+      assert_raise File.CopyError, message, fn ->
         File.cp!(src, dest)
       end
     end
 
-    test :cp_r_with_src_file_and_dest_file do
-      src  = fixture_path("file.txt")
+    test "cp itself" do
+      src = dest = tmp_path("tmp.file")
+
+      File.write!(src, "here")
+
+      try do
+        assert File.cp(src, dest) == :ok
+        assert File.read!(dest) == "here"
+        assert File.cp_r(src, dest) == {:ok, []}
+      after
+        File.rm(dest)
+      end
+    end
+
+    test "cp_r raises on path with null byte" do
+      assert_raise ArgumentError, ~r/null byte/, fn -> File.cp_r("source", "foo\0bar") end
+      assert_raise ArgumentError, ~r/null byte/, fn -> File.cp_r("foo\0bar", "dest") end
+    end
+
+    test "cp_r with src file and dest file" do
+      src = fixture_path("file.txt")
       dest = tmp_path("sample.txt")
 
       File.touch(dest)
@@ -144,34 +510,34 @@ defmodule FileTest do
       end
     end
 
-    test :cp_r_with_src_file_and_dest_dir do
-      src   = fixture_path("file.txt")
-      dest  = tmp_path("tmp")
+    test "cp_r with src file and dest dir" do
+      src = fixture_path("file.txt")
+      dest = tmp_path("tmp")
 
       File.mkdir(dest)
 
       try do
-        assert io_error? File.cp_r(src, dest)
+        assert io_error?(File.cp_r(src, dest))
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_r_with_src_file_and_dest_unknown do
-      src   = fixture_path("file.txt")
-      dest  = tmp_path("tmp.file")
+    test "cp_r with src file and dest unknown" do
+      src = fixture_path("file.txt")
+      dest = tmp_path("tmp.file")
 
       try do
         refute File.exists?(dest)
         assert File.cp_r(src, dest) == {:ok, [dest]}
         assert File.exists?(dest)
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_r_with_src_dir_and_dest_dir do
-      src  = fixture_path("cp_r")
+    test "cp_r with src dir and dest dir" do
+      src = fixture_path("cp_r")
       dest = tmp_path("tmp")
 
       File.mkdir(dest)
@@ -190,24 +556,24 @@ defmodule FileTest do
         assert File.exists?(tmp_path("tmp/a/a/2.txt"))
         assert File.exists?(tmp_path("tmp/b/3.txt"))
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_r_with_src_dir_and_dest_file do
-      src  = fixture_path("cp_r")
+    test "cp_r with src dir and dest file" do
+      src = fixture_path("cp_r")
       dest = tmp_path("tmp.file")
 
       try do
         File.touch!(dest)
-        assert (File.cp_r(src, dest) |> io_error?)
+        assert File.cp_r(src, dest) |> io_error?()
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_r_with_src_dir_and_dest_unknown do
-      src  = fixture_path("cp_r")
+    test "cp_r with src dir and dest unknown" do
+      src = fixture_path("cp_r")
       dest = tmp_path("tmp")
 
       try do
@@ -222,32 +588,112 @@ defmodule FileTest do
         assert File.exists?(tmp_path("tmp/a/a/2.txt"))
         assert File.exists?(tmp_path("tmp/b/3.txt"))
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_r_with_src_unknown do
-      src  = fixture_path("unknown")
+    test "cp_r with src unknown" do
+      src = fixture_path("unknown")
       dest = tmp_path("tmp")
       assert File.cp_r(src, dest) == {:error, :enoent, src}
     end
 
-    test :cp_r_with_dir_and_file_conflict do
-      src  = fixture_path("cp_r")
+    test "cp_r with absolute symlink" do
+      linked_src = fixture_path("cp_r")
+      src = tmp_path("tmp/src")
+      dest = tmp_path("tmp/dest")
+
+      File.mkdir_p!(src)
+      :ok = :file.make_symlink(Path.join(linked_src, "a"), Path.join(src, "sym"))
+
+      try do
+        {:ok, files} = File.cp_r(src, dest)
+        assert length(files) == 2
+
+        assert File.exists?(tmp_path("tmp/dest/sym/1.txt"))
+        assert File.exists?(tmp_path("tmp/dest/sym/a/2.txt"))
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "cp_r with dereference absolute symlink" do
+      linked_src = fixture_path("cp_r")
+      src = tmp_path("tmp/src")
+      dest = tmp_path("tmp/dest")
+
+      File.mkdir_p!(src)
+      :ok = :file.make_symlink(Path.join(linked_src, "a"), Path.join(src, "sym"))
+
+      try do
+        {:ok, files} = File.cp_r(src, dest, dereference_symlinks: true)
+        assert length(files) == 5
+
+        assert File.exists?(tmp_path("tmp/dest/sym/1.txt"))
+        assert File.exists?(tmp_path("tmp/dest/sym/a/2.txt"))
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    @tag :unix
+    test "cp_r with relative symlink" do
+      doc = tmp_path("tmp/doc")
+      src = tmp_path("tmp/src")
+      dest = tmp_path("tmp/dest")
+
+      File.mkdir_p!(src)
+      File.write!(doc, "hello")
+      :ok = :file.make_symlink("../doc", Path.join(src, "sym"))
+
+      try do
+        {:ok, files} = File.cp_r(src, dest)
+        assert length(files) == 2
+        assert File.lstat!(tmp_path("tmp/dest/sym")).type == :symlink
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    @tag :unix
+    test "cp_r with dereference relative symlink" do
+      doc = tmp_path("tmp/doc")
+      src = tmp_path("tmp/src")
+      dest = tmp_path("tmp/dest")
+
+      File.mkdir_p!(src)
+      File.write!(doc, "hello")
+      :ok = :file.make_symlink("../doc", Path.join(src, "sym"))
+
+      try do
+        {:ok, files} = File.cp_r(src, dest, dereference_symlinks: true)
+        assert length(files) == 2
+        assert File.lstat!(tmp_path("tmp/dest/sym")).type == :regular
+      after
+        File.rm_rf(src)
+        File.rm_rf(dest)
+      end
+    end
+
+    test "cp_r with dir and file conflict" do
+      src = fixture_path("cp_r")
       dest = tmp_path("tmp")
 
       try do
         File.mkdir(dest)
         File.write!(Path.join(dest, "a"), "hello")
-        assert io_error? File.cp_r(src, dest)
+        assert io_error?(File.cp_r(src, dest))
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_r_with_src_dir_and_dest_dir_using_lists do
-      src  = fixture_path("cp_r") |> to_char_list
-      dest = tmp_path("tmp") |> to_char_list
+    test "cp_r with src dir and dest dir using lists" do
+      src = fixture_path("cp_r") |> to_charlist()
+      dest = tmp_path("tmp") |> to_charlist()
 
       File.mkdir(dest)
 
@@ -264,48 +710,52 @@ defmodule FileTest do
         assert File.exists?(tmp_path("tmp/a/a/2.txt"))
         assert File.exists?(tmp_path("tmp/b/3.txt"))
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_r_with_src_with_file_conflict do
-      src  = fixture_path("cp_r")
+    test "cp_r with src with file conflict" do
+      src = fixture_path("cp_r")
       dest = tmp_path("tmp")
 
-      File.mkdir_p tmp_path("tmp/a")
-      File.write! tmp_path("tmp/a/1.txt"), "hello"
+      File.mkdir_p(tmp_path("tmp/a"))
+      File.write!(tmp_path("tmp/a/1.txt"), "hello")
 
       try do
         assert File.exists?(tmp_path("tmp/a/1.txt"))
         File.cp_r(src, dest)
         assert File.read!(tmp_path("tmp/a/1.txt")) == ""
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_r_with_src_with_file_conflict_callback do
-      src  = fixture_path("cp_r")
+    test "cp_r with src with file conflict callback" do
+      src = fixture_path("cp_r")
       dest = tmp_path("tmp")
 
-      File.mkdir_p tmp_path("tmp/a")
-      File.write! tmp_path("tmp/a/1.txt"), "hello"
+      File.mkdir_p(tmp_path("tmp/a"))
+      File.write!(tmp_path("tmp/a/1.txt"), "hello")
 
       try do
         assert File.exists?(tmp_path("tmp/a/1.txt"))
-        File.cp_r(src, dest, fn(src_file, dest_file) ->
-          assert src_file == fixture_path("cp_r/a/1.txt")
-          assert dest_file == tmp_path("tmp/a/1.txt")
-          false
-        end)
+
+        File.cp_r(src, dest,
+          on_conflict: fn src_file, dest_file ->
+            assert src_file == fixture_path("cp_r/a/1.txt")
+            assert dest_file == tmp_path("tmp/a/1.txt")
+            false
+          end
+        )
+
         assert File.read!(tmp_path("tmp/a/1.txt")) == "hello"
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_r! do
-      src  = fixture_path("cp_r")
+    test "cp_r!" do
+      src = fixture_path("cp_r")
       dest = tmp_path("tmp")
 
       File.mkdir(dest)
@@ -321,69 +771,93 @@ defmodule FileTest do
         assert File.exists?(tmp_path("tmp/a/a/2.txt"))
         assert File.exists?(tmp_path("tmp/b/3.txt"))
       after
-        File.rm_rf dest
+        File.rm_rf(dest)
       end
     end
 
-    test :cp_r_with_src_unknown! do
-      src  = fixture_path("unknown")
+    test "cp_r! with src unknown" do
+      src = fixture_path("unknown")
       dest = tmp_path("tmp")
-      assert_raise File.CopyError, "could not copy recursively from #{src} to #{dest}. #{src}: no such file or directory", fn ->
+
+      message =
+        "could not copy recursively from #{inspect(src)} to #{inspect(dest)}. #{src}: no such file or directory"
+
+      assert_raise File.CopyError, message, fn ->
         File.cp_r!(src, dest)
       end
     end
 
-    test :cp_preserves_mode do
-     File.mkdir_p!(tmp_path("tmp"))
-     src  = fixture_path("cp_mode")
-     dest = tmp_path("tmp/cp_mode")
+    test "cp_r! with file src and dest unknown" do
+      src = fixture_path("cp_r/a/1.txt")
+      dest = tmp_path("tmp/unknown/")
 
-     File.cp!(src, dest)
-     %File.Stat{mode: src_mode} = File.stat! src
-     %File.Stat{mode: dest_mode} = File.stat! dest
-     assert src_mode == dest_mode
+      message =
+        "could not copy recursively from #{inspect(src)} to #{inspect(dest)}. #{dest}: no such file or directory"
 
-     # On overwrite
-     File.cp! src, dest, fn(_, _) -> true end
-     %File.Stat{mode: src_mode} = File.stat! src
-     %File.Stat{mode: dest_mode} = File.stat! dest
-     assert src_mode == dest_mode
+      assert_raise File.CopyError, message, fn ->
+        File.cp_r!(src, dest)
+      end
     end
 
-    defp io_error?(result) do
-      elem(result, 1) in [:enotdir, :eio, :enoent, :eisdir]
+    test "cp preserves mode" do
+      File.mkdir_p!(tmp_path("tmp"))
+      src = fixture_path("cp_mode")
+      dest = tmp_path("tmp/cp_mode")
+
+      File.cp!(src, dest)
+      %File.Stat{mode: src_mode} = File.stat!(src)
+      %File.Stat{mode: dest_mode} = File.stat!(dest)
+      assert src_mode == dest_mode
+
+      # On overwrite
+      File.cp!(src, dest, on_conflict: fn _, _ -> true end)
+      %File.Stat{mode: src_mode} = File.stat!(src)
+      %File.Stat{mode: dest_mode} = File.stat!(dest)
+      assert src_mode == dest_mode
     end
   end
 
   defmodule Queries do
     use ExUnit.Case
 
-    test :regular do
+    test "regular" do
       assert File.regular?(__ENV__.file)
-      assert File.regular?(String.to_char_list(__ENV__.file))
+      assert File.regular?(String.to_charlist(__ENV__.file))
       refute File.regular?("#{__ENV__.file}.unknown")
     end
 
-    test :exists do
+    test "exists" do
       assert File.exists?(__ENV__.file)
-      assert File.exists?(fixture_path)
+      assert File.exists?(fixture_path())
       assert File.exists?(fixture_path("file.txt"))
 
       refute File.exists?(fixture_path("missing.txt"))
       refute File.exists?("_missing.txt")
     end
+
+    test "exists with dangling symlink" do
+      invalid_file = tmp_path("invalid_file")
+      dest = tmp_path("dangling_symlink")
+      File.ln_s(invalid_file, dest)
+
+      try do
+        refute File.exists?(dest)
+      after
+        File.rm(dest)
+      end
+    end
   end
 
-  test :ls do
-    {:ok, value} = File.ls(fixture_path)
+  test "ls" do
+    {:ok, value} = File.ls(fixture_path())
     assert "code_sample.exs" in value
     assert "file.txt" in value
 
     {:error, :enoent} = File.ls(fixture_path("non-existent-subdirectory"))
   end
 
-  test :ls! do
-    value = File.ls!(fixture_path)
+  test "ls!" do
+    value = File.ls!(fixture_path())
     assert "code_sample.exs" in value
     assert "file.txt" in value
 
@@ -392,45 +866,45 @@ defmodule FileTest do
     end
   end
 
-  defmodule OpenReadWrite do
-    use Elixir.FileCase
-
-    test :read_with_binary do
+  describe "open-read-write" do
+    test "read with binary" do
       assert {:ok, "FOO\n"} = File.read(fixture_path("file.txt"))
       assert {:error, :enoent} = File.read(fixture_path("missing.txt"))
     end
 
-    test :read_with_list do
-      assert {:ok, "FOO\n"} = File.read(Path.expand('fixtures/file.txt', __DIR__))
-      assert {:error, :enoent} = File.read(Path.expand('fixtures/missing.txt', __DIR__))
+    test "read with list" do
+      assert {:ok, "FOO\n"} = File.read(Path.expand(~c"fixtures/file.txt", __DIR__))
+      assert {:error, :enoent} = File.read(Path.expand(~c"fixtures/missing.txt", __DIR__))
     end
 
-    test :read_with_utf8 do
-      assert {:ok, "Русский\n日\n"} = File.read(Path.expand('fixtures/utf8.txt', __DIR__))
+    test "read with UTF-8" do
+      assert {:ok, "Русский\n日\n"} = File.read(Path.expand(~c"fixtures/utf8.txt", __DIR__))
     end
 
-    test :read! do
+    test "read!" do
       assert File.read!(fixture_path("file.txt")) == "FOO\n"
-      expected_message = "could not read file fixtures/missing.txt: no such file or directory"
+      expected_message = "could not read file \"fixtures/missing.txt\": no such file or directory"
 
       assert_raise File.Error, expected_message, fn ->
         File.read!("fixtures/missing.txt")
       end
     end
 
-    test :write_ascii_content do
+    test "write ASCII content" do
       fixture = tmp_path("tmp_test.txt")
+
       try do
         refute File.exists?(fixture)
-        assert File.write(fixture, 'test text') == :ok
+        assert File.write(fixture, ~c"test text") == :ok
         assert File.read(fixture) == {:ok, "test text"}
       after
         File.rm(fixture)
       end
     end
 
-    test :write_utf8 do
+    test "write UTF-8" do
       fixture = tmp_path("tmp_test.txt")
+
       try do
         refute File.exists?(fixture)
         assert File.write(fixture, "Русский\n日\n") == :ok
@@ -440,8 +914,9 @@ defmodule FileTest do
       end
     end
 
-    test :write_with_options do
+    test "write with options" do
       fixture = tmp_path("tmp_test.txt")
+
       try do
         refute File.exists?(fixture)
         assert File.write(fixture, "Русский\n日\n") == :ok
@@ -452,32 +927,33 @@ defmodule FileTest do
       end
     end
 
-    test :open_file_without_modes do
+    test "open file without modes" do
       {:ok, file} = File.open(fixture_path("file.txt"))
       assert IO.gets(file, "") == "FOO\n"
       assert File.close(file) == :ok
     end
 
-    test :open_file_with_char_list do
-      {:ok, file} = File.open(fixture_path("file.txt"), [:char_list])
-      assert IO.gets(file, "") == 'FOO\n'
+    test "open file with charlist" do
+      {:ok, file} = File.open(fixture_path("file.txt"), [:charlist])
+      assert IO.gets(file, "") == ~c"FOO\n"
       assert File.close(file) == :ok
     end
 
-    test :open_utf8_by_default do
+    test "open UTF-8 by default" do
       {:ok, file} = File.open(fixture_path("utf8.txt"), [:utf8])
       assert IO.gets(file, "") == "Русский\n"
       assert File.close(file) == :ok
     end
 
-    test :open_readonly_by_default do
+    test "open readonly by default" do
       {:ok, file} = File.open(fixture_path("file.txt"))
       assert_raise ArgumentError, fn -> IO.write(file, "foo") end
       assert File.close(file) == :ok
     end
 
-    test :open_with_write_permission do
+    test "open with write permission" do
       fixture = tmp_path("tmp_text.txt")
+
       try do
         {:ok, file} = File.open(fixture, [:write])
         assert IO.write(file, "foo") == :ok
@@ -488,118 +964,132 @@ defmodule FileTest do
       end
     end
 
-    test :open_with_binwrite_permission do
+    test "open with binwrite permission" do
       fixture = tmp_path("tmp_text.txt")
+
       try do
         {:ok, file} = File.open(fixture, [:write])
         assert IO.binwrite(file, "Русский") == :ok
         assert File.close(file) == :ok
+        assert_raise ErlangError, fn -> IO.binwrite(file, "Русский") end
         assert File.read(fixture) == {:ok, "Русский"}
       after
         File.rm(fixture)
       end
     end
 
-    test :open_utf8_and_charlist do
-      {:ok, file} = File.open(fixture_path("utf8.txt"), [:char_list, :utf8])
+    test "open UTF-8 and charlist" do
+      {:ok, file} = File.open(fixture_path("utf8.txt"), [:charlist, :utf8])
       assert IO.gets(file, "") == [1056, 1091, 1089, 1089, 1082, 1080, 1081, 10]
       assert File.close(file) == :ok
     end
 
-    test :open_respects_encoding do
+    test "open respects encoding" do
       {:ok, file} = File.open(fixture_path("utf8.txt"), [{:encoding, :latin1}])
-      assert IO.gets(file, "") == <<195, 144, 194, 160, 195, 145, 194, 131, 195, 145, 194, 129, 195, 145, 194, 129, 195, 144, 194, 186, 195, 144, 194, 184, 195, 144, 194, 185, 10>>
+
+      data =
+        <<195, 144, 194, 160, 195, 145, 194, 131, 195, 145, 194, 129, 195, 145>> <>
+          <<194, 129, 195, 144, 194, 186, 195, 144, 194, 184, 195, 144, 194, 185, 10>>
+
+      assert IO.gets(file, "") == data
       assert File.close(file) == :ok
     end
 
-    test :open_a_missing_file do
-      assert File.open('missing.txt') == {:error, :enoent}
+    test "open a missing file" do
+      assert File.open(~c"missing.txt") == {:error, :enoent}
     end
 
-    test :open_a_file_with_function do
+    test "open a file with function" do
       file = fixture_path("file.txt")
       assert File.open(file, &IO.read(&1, :line)) == {:ok, "FOO\n"}
     end
 
-    test :open_a_missing_file! do
-      message = "could not open missing.txt: no such file or directory"
+    test "open! a missing file" do
+      message = "could not open \"missing.txt\": no such file or directory"
+
       assert_raise File.Error, message, fn ->
-        File.open!('missing.txt')
+        File.open!(~c"missing.txt")
       end
     end
 
-    test :open_a_file_with_function! do
+    test "open! a file with function" do
       file = fixture_path("file.txt")
       assert File.open!(file, &IO.read(&1, :line)) == "FOO\n"
     end
   end
 
-  defmodule Mkdir do
-    use Elixir.FileCase
-
-    test :mkdir_with_binary do
+  describe "mkdir" do
+    test "mkdir with binary" do
       fixture = tmp_path("tmp_test")
+
       try do
         refute File.exists?(fixture)
         assert File.mkdir(fixture) == :ok
         assert File.exists?(fixture)
       after
-        File.rmdir fixture
+        File.rmdir(fixture)
       end
     end
 
-    test :mkdir_with_list do
-      fixture = tmp_path("tmp_test") |> to_char_list
+    test "mkdir with list" do
+      fixture = tmp_path("tmp_test") |> to_charlist()
+
       try do
         refute File.exists?(fixture)
         assert File.mkdir(fixture) == :ok
         assert File.exists?(fixture)
       after
-        File.rmdir fixture
+        File.rmdir(fixture)
       end
     end
 
-    test :mkdir_with_invalid_path do
+    test "mkdir with invalid path" do
       fixture = fixture_path("file.txt")
-      invalid = Path.join fixture, "test"
+      invalid = Path.join(fixture, "test")
       assert File.exists?(fixture)
-      assert io_error? File.mkdir(invalid)
+      assert io_error?(File.mkdir(invalid))
       refute File.exists?(invalid)
     end
 
-    test :mkdir! do
+    test "mkdir!" do
       fixture = tmp_path("tmp_test")
+
       try do
         refute File.exists?(fixture)
         assert File.mkdir!(fixture) == :ok
         assert File.exists?(fixture)
       after
-        File.rmdir fixture
+        File.rmdir(fixture)
       end
     end
 
-    test :mkdir_with_invalid_path! do
+    test "mkdir! with invalid path" do
       fixture = fixture_path("file.txt")
-      invalid = Path.join fixture, "test"
+      invalid = Path.join(fixture, "test")
       assert File.exists?(fixture)
-      assert_raise File.Error, ~r"^could not make directory #{escape invalid}: (not a directory|no such file or directory)", fn ->
+
+      message =
+        ~r"\Acould not make directory #{inspect(invalid)}: (not a directory|no such file or directory)"
+
+      assert_raise File.Error, message, fn ->
         File.mkdir!(invalid)
       end
     end
 
-    test :mkdir_p_with_one_directory do
+    test "mkdir_p with one directory" do
       fixture = tmp_path("tmp_test")
+
       try do
         refute File.exists?(fixture)
         assert File.mkdir_p(fixture) == :ok
         assert File.exists?(fixture)
       after
-        File.rm_rf fixture
+        File.rm_rf(fixture)
       end
     end
 
-    test :mkdir_p_with_nested_directory_and_binary do
-      base    = tmp_path("tmp_test")
+    test "mkdir_p with nested directory and binary" do
+      base = tmp_path("tmp_test")
       fixture = Path.join(base, "test")
       refute File.exists?(base)
 
@@ -608,12 +1098,12 @@ defmodule FileTest do
         assert File.exists?(base)
         assert File.exists?(fixture)
       after
-        File.rm_rf base
+        File.rm_rf(base)
       end
     end
 
-    test :mkdir_p_with_nested_directory_and_list do
-      base    = tmp_path("tmp_test") |> to_char_list
+    test "mkdir_p with nested directory and list" do
+      base = tmp_path("tmp_test") |> to_charlist()
       fixture = Path.join(base, "test")
       refute File.exists?(base)
 
@@ -622,12 +1112,12 @@ defmodule FileTest do
         assert File.exists?(base)
         assert File.exists?(fixture)
       after
-        File.rm_rf base
+        File.rm_rf(base)
       end
     end
 
-    test :mkdir_p_with_nested_directory_and_existing_parent do
-      base    = tmp_path("tmp_test")
+    test "mkdir_p with nested directory and existing parent" do
+      base = tmp_path("tmp_test")
       fixture = Path.join(base, "test")
 
       File.mkdir(base)
@@ -637,72 +1127,92 @@ defmodule FileTest do
         assert File.exists?(base)
         assert File.exists?(fixture)
       after
-        File.rm_rf base
+        File.rm_rf(base)
       end
     end
 
-    test :mkdir_p_with_invalid_path do
+    test "mkdir_p with invalid path" do
       assert File.exists?(fixture_path("file.txt"))
-      invalid = Path.join fixture_path("file.txt"), "test/foo"
-      assert io_error? File.mkdir(invalid)
+      invalid = Path.join(fixture_path("file.txt"), "test/foo")
+      assert io_error?(File.mkdir(invalid))
       refute File.exists?(invalid)
     end
 
-    test :mkdir_p! do
+    test "mkdir_p!" do
       fixture = tmp_path("tmp_test")
+
       try do
         refute File.exists?(fixture)
         assert File.mkdir_p!(fixture) == :ok
         assert File.exists?(fixture)
       after
-        File.rm_rf fixture
+        File.rm_rf(fixture)
       end
     end
 
-    test :mkdir_p_with_invalid_path! do
+    test "mkdir_p! with invalid path" do
       fixture = fixture_path("file.txt")
-      invalid = Path.join fixture, "test"
+      invalid = Path.join(fixture, "test")
       assert File.exists?(fixture)
-      assert_raise File.Error, ~r"^could not make directory \(with -p\) #{escape invalid}: (not a directory|no such file or directory)", fn ->
+
+      message =
+        ~r"\Acould not make directory \(with -p\) #{inspect(invalid)}: (not a directory|no such file or directory)"
+
+      assert_raise File.Error, message, fn ->
         File.mkdir_p!(invalid)
       end
     end
 
-    defp io_error?(result) do
-      {:error, errorcode} = result
-      errorcode in [:enotdir, :eio, :enoent, :eisdir]
+    @tag :unix
+    test "mkdir_p with non-accessible parent directory" do
+      fixture = tmp_path("tmp_test_parent")
+
+      try do
+        refute File.exists?(fixture)
+        assert File.mkdir_p!(fixture) == :ok
+        %File.Stat{mode: orig_mode} = File.stat!(fixture)
+        assert File.chmod!(fixture, 0o000) == :ok
+
+        child = Path.join(fixture, "child")
+        refute File.exists?(child)
+
+        assert File.mkdir_p(child) == {:error, :eacces}
+        refute File.exists?(child)
+
+        assert File.chmod!(fixture, orig_mode) == :ok
+      after
+        File.rm_rf(fixture)
+      end
     end
   end
 
-  defmodule Rm do
-    use Elixir.FileCase
-
-    test :rm_file do
+  describe "rm" do
+    test "rm file" do
       fixture = tmp_path("tmp_test.txt")
       File.write(fixture, "test")
       assert File.exists?(fixture)
       assert File.rm(fixture) == :ok
       refute File.exists?(fixture)
     end
-    
-    test :rm_read_only_file do
+
+    test "rm read only file" do
       fixture = tmp_path("tmp_test.txt")
       File.write(fixture, "test")
       assert File.exists?(fixture)
-      File.chmod(fixture, 0100444)
+      File.chmod(fixture, 0o100444)
       assert File.rm(fixture) == :ok
       refute File.exists?(fixture)
     end
 
-    test :rm_file_with_dir do
-      assert File.rm(fixture_path) == {:error, :eperm}
+    test "rm file with dir" do
+      assert File.rm(fixture_path()) == {:error, :eperm}
     end
 
-    test :rm_nonexistent_file do
-      assert File.rm('missing.txt') == {:error, :enoent}
+    test "rm nonexistent file" do
+      assert File.rm(~c"missing.txt") == {:error, :enoent}
     end
 
-    test :rm! do
+    test "rm!" do
       fixture = tmp_path("tmp_test.txt")
       File.write(fixture, "test")
       assert File.exists?(fixture)
@@ -710,13 +1220,15 @@ defmodule FileTest do
       refute File.exists?(fixture)
     end
 
-    test :rm_with_invalid_file! do
-      assert_raise File.Error, "could not remove file missing.file: no such file or directory", fn ->
+    test "rm! with invalid file" do
+      message = "could not remove file \"missing.file\": no such file or directory"
+
+      assert_raise File.Error, message, fn ->
         File.rm!("missing.file")
       end
     end
 
-    test :rmdir do
+    test "rmdir" do
       fixture = tmp_path("tmp_test")
       File.mkdir_p(fixture)
       assert File.dir?(fixture)
@@ -724,11 +1236,11 @@ defmodule FileTest do
       refute File.exists?(fixture)
     end
 
-    test :rmdir_with_file do
-      assert io_error? File.rmdir(fixture_path("file.txt"))
+    test "rmdir with file" do
+      assert io_error?(File.rmdir(fixture_path("file.txt")))
     end
 
-    test :rmdir! do
+    test "rmdir!" do
       fixture = tmp_path("tmp_test")
       File.mkdir_p(fixture)
       assert File.dir?(fixture)
@@ -736,14 +1248,42 @@ defmodule FileTest do
       refute File.exists?(fixture)
     end
 
-    test :rmdir_with_file! do
+    test "rmdir! with file" do
       fixture = fixture_path("file.txt")
-      assert_raise File.Error, ~r"^could not remove directory #{escape fixture}: (not a directory|I/O error)", fn ->
+      message = ~r"\Acould not remove directory #{inspect(fixture)}: (not a directory|I/O error)"
+
+      assert_raise File.Error, message, fn ->
         File.rmdir!(fixture)
       end
     end
 
-    test :rm_rf do
+    test "rmdir! error messages" do
+      fixture = tmp_path("tmp_test")
+      File.mkdir_p(fixture)
+      File.touch(fixture <> "/file")
+
+      # directory is not empty
+      dir_not_empty_message =
+        "could not remove directory #{inspect(fixture)}: directory is not empty"
+
+      assert_raise File.Error, dir_not_empty_message, fn ->
+        File.rmdir!(fixture)
+      end
+
+      # directory does not exist
+      non_existent_dir = fixture <> "/non_existent_dir"
+
+      non_existent_dir_message =
+        ~r"\Acould not remove directory #{inspect(non_existent_dir)}: (not a directory|no such file or directory)"
+
+      assert_raise File.Error, non_existent_dir_message, fn ->
+        File.rmdir!(non_existent_dir)
+      end
+
+      File.rm_rf(fixture)
+    end
+
+    test "rm_rf" do
       fixture = tmp_path("tmp")
       File.mkdir(fixture)
       File.cp_r!(fixture_path("cp_r"), fixture)
@@ -763,15 +1303,19 @@ defmodule FileTest do
       refute File.exists?(fixture)
     end
 
-    test :rm_rf_with_symlink do
+    test "rm_rf raises on path with null byte" do
+      assert_raise ArgumentError, ~r/null byte/, fn -> File.rm_rf("foo\0bar") end
+    end
+
+    test "rm_rf with symlink" do
       from = tmp_path("tmp/from")
-      to   = tmp_path("tmp/to")
+      to = tmp_path("tmp/to")
 
       File.mkdir_p!(to)
       File.write!(Path.join(to, "hello"), "world")
       :file.make_symlink(to, from)
 
-      if File.exists?(from) or not is_win? do
+      if File.exists?(from) or not windows?() do
         assert File.exists?(from)
 
         {:ok, files} = File.rm_rf(from)
@@ -784,8 +1328,8 @@ defmodule FileTest do
       File.rm(tmp_path("tmp/from"))
     end
 
-    test :rm_rf_with_char_list do
-      fixture = tmp_path("tmp") |> to_char_list
+    test "rm_rf with charlist" do
+      fixture = tmp_path("tmp") |> to_charlist()
       File.mkdir(fixture)
       File.cp_r!(fixture_path("cp_r"), fixture)
 
@@ -804,23 +1348,31 @@ defmodule FileTest do
       refute File.exists?(fixture)
     end
 
-    test :rm_rf_with_file do
+    test "rm_rf with file" do
       fixture = tmp_path("tmp")
       File.write(fixture, "hello")
       assert File.rm_rf(fixture) == {:ok, [fixture]}
     end
 
-    test :rm_rf_with_unknown do
+    test "rm_rf with write-only subdir" do
+      dir = tmp_path("tmp")
+      subdir = Path.join(dir, "write-only")
+      File.mkdir_p!(subdir)
+      File.chmod!(subdir, 0o222)
+      assert File.rm_rf(dir) == {:ok, [dir, subdir]}
+    end
+
+    test "rm_rf with unknown" do
       fixture = tmp_path("tmp.unknown")
       assert File.rm_rf(fixture) == {:ok, []}
     end
 
-    test :rm_rf_with_invalid do
-      fixture = fixture_path "file.txt/path"
+    test "rm_rf with invalid" do
+      fixture = fixture_path("file.txt/path")
       assert File.rm_rf(fixture) == {:ok, []}
     end
 
-    test :rm_rf! do
+    test "rm_rf!" do
       fixture = tmp_path("tmp")
       File.mkdir(fixture)
       File.cp_r!(fixture_path("cp_r"), fixture)
@@ -840,455 +1392,540 @@ defmodule FileTest do
       refute File.exists?(fixture)
     end
 
-    test :rm_rf_with_invalid! do
-      fixture = fixture_path "file.txt/path"
+    test "rm_rf! with invalid path" do
+      fixture = fixture_path("file.txt/path")
       assert File.rm_rf!(fixture) == []
     end
+  end
 
-    defp io_error?(result) do
-      elem(result, 1) in [:enotdir, :eio, :enoent, :eisdir]
+  describe "stat" do
+    test "stat" do
+      {:ok, info} = File.stat(__ENV__.file)
+      assert info.mtime
     end
-  end
 
-  test :stat do
-    {:ok, info} = File.stat(__ENV__.file)
-    assert info.mtime
-  end
+    test "stat!" do
+      assert File.stat!(__ENV__.file).mtime
+    end
 
-  test :stat! do
-    assert File.stat!(__ENV__.file).mtime
-  end
+    test "stat with invalid file" do
+      assert {:error, _} = File.stat("./invalid_file")
+    end
 
-  test :stat_with_invalid_file do
-    assert {:error, _} = File.stat("./invalid_file")
-  end
+    test "stat! with invalid_file" do
+      assert_raise File.Error, fn ->
+        File.stat!("./invalid_file")
+      end
+    end
 
-  test :stat_with_invalid_file! do
-    assert_raise File.Error, fn ->
-      File.stat!("./invalid_file")
+    test "lstat" do
+      {:ok, info} = File.lstat(__ENV__.file)
+      assert info.mtime
     end
-  end
 
-  test :io_stream_utf8 do
-    src  = File.open! fixture_path("file.txt"), [:utf8]
-    dest = tmp_path("tmp_test.txt")
+    test "lstat!" do
+      assert File.lstat!(__ENV__.file).mtime
+    end
+
+    test "lstat with invalid file" do
+      invalid_file = tmp_path("invalid_file")
+      assert {:error, _} = File.lstat(invalid_file)
+    end
 
-    try do
-      stream = IO.stream(src, :line)
-      File.open dest, [:write], fn(target) ->
-        Enum.into stream, IO.stream(target, :line), &String.replace(&1, "O", "A")
+    test "lstat! with invalid file" do
+      invalid_file = tmp_path("invalid_file")
+
+      assert_raise File.Error, fn ->
+        File.lstat!(invalid_file)
       end
-      assert File.read(dest) == {:ok, "FAA\n"}
-    after
-      File.rm(dest)
     end
-  end
 
-  test :io_stream do
-    src  = File.open! fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
+    test "lstat with dangling symlink" do
+      invalid_file = tmp_path("invalid_file")
+      dest = tmp_path("dangling_symlink")
+      File.ln_s(invalid_file, dest)
 
-    try do
-      stream = IO.binstream(src, :line)
-      File.open dest, [:write], fn(target) ->
-        Enum.into stream, IO.binstream(target, :line), &String.replace(&1, "O", "A")
+      try do
+        assert {:ok, info} = File.lstat(dest)
+        assert info.type == :symlink
+      after
+        File.rm(dest)
       end
-      assert File.read(dest) == {:ok, "FAA\n"}
-    after
-      File.rm(dest)
     end
-  end
 
-  test :stream_map do
-    src = fixture_path("file.txt")
-    stream = File.stream!(src)
-    assert %File.Stream{} = stream
-    assert stream.modes == [:raw, :read_ahead, :binary]
-    assert stream.raw
-    assert stream.line_or_bytes == :line
-
-    src = fixture_path("file.txt")
-    stream = File.stream!(src, [:utf8], 10)
-    assert %File.Stream{} = stream
-    assert stream.modes == [{:encoding, :utf8}, :binary]
-    refute stream.raw
-    assert stream.line_or_bytes == 10
+    test "lstat! with dangling symlink" do
+      invalid_file = tmp_path("invalid_file")
+      dest = tmp_path("dangling_symlink")
+      File.ln_s(invalid_file, dest)
+
+      try do
+        assert File.lstat!(dest).type == :symlink
+      after
+        File.rm(dest)
+      end
+    end
   end
 
-  test :stream_line_utf8 do
-    src  = fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
+  describe "IO stream" do
+    test "IO stream UTF-8" do
+      src = File.open!(fixture_path("file.txt"), [:utf8])
+      dest = tmp_path("tmp_test.txt")
 
-    try do
-      stream = File.stream!(src)
-      File.open dest, [:write, :utf8], fn(target) ->
-        Enum.each stream, fn(line) ->
-          IO.write target, String.replace(line, "O", "A")
-        end
+      try do
+        stream = IO.stream(src, :line)
+
+        File.open(dest, [:write], fn target ->
+          Enum.into(stream, IO.stream(target, :line), &String.replace(&1, "O", "A"))
+        end)
+
+        assert File.read(dest) == {:ok, "FAA\n"}
+      after
+        File.rm(dest)
       end
-      assert File.read(dest) == {:ok, "FAA\n"}
-    after
-      File.rm(dest)
     end
-  end
 
-  test :stream_bytes_utf8 do
-    src  = fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
+    test "IO stream" do
+      src = File.open!(fixture_path("file.txt"))
+      dest = tmp_path("tmp_test.txt")
 
-    try do
-      stream = File.stream!(src, [:utf8], 1)
-      File.open dest, [:write], fn(target) ->
-        Enum.each stream, fn(line) ->
-          IO.write target, String.replace(line, "OO", "AA")
-        end
+      try do
+        stream = IO.binstream(src, :line)
+
+        File.open(dest, [:write], fn target ->
+          Enum.into(stream, IO.binstream(target, :line), &String.replace(&1, "O", "A"))
+        end)
+
+        assert File.read(dest) == {:ok, "FAA\n"}
+      after
+        File.rm(dest)
       end
-      assert File.read(dest) == {:ok, "FOO\n"}
-    after
-      File.rm(dest)
     end
   end
 
-  test :stream_line do
-    src  = fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
+  describe "links" do
+    test "read_link with regular file" do
+      dest = tmp_path("symlink")
+      File.touch(dest)
 
-    try do
-      stream = File.stream!(src)
-      File.open dest, [:write], fn(target) ->
-        Enum.each stream, fn(line) ->
-          IO.write target, String.replace(line, "O", "A")
-        end
+      try do
+        assert File.read_link(dest) == {:error, :einval}
+      after
+        File.rm(dest)
       end
-      assert File.read(dest) == {:ok, "FAA\n"}
-    after
-      File.rm(dest)
     end
-  end
 
-  test :stream_bytes do
-    src  = fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
+    test "read_link with nonexistent file" do
+      dest = tmp_path("does_not_exist")
+      assert File.read_link(dest) == {:error, :enoent}
+    end
 
-    try do
-      stream = File.stream!(src, [], 1)
-      File.open dest, [:write], fn(target) ->
-        Enum.each stream, fn(line) ->
-          IO.write target, String.replace(line, "OO", "AA")
-        end
+    test "read_link! with nonexistent file" do
+      dest = tmp_path("does_not_exist")
+      assert_raise File.Error, fn -> File.read_link!(dest) end
+    end
+
+    @tag :unix
+    test "read_link with symlink" do
+      target = tmp_path("does_not_need_to_exist")
+      dest = tmp_path("symlink")
+      File.ln_s(target, dest)
+
+      try do
+        assert File.read_link(dest) == {:ok, target}
+      after
+        File.rm(dest)
       end
-      assert File.read(dest) == {:ok, "FOO\n"}
-    after
-      File.rm(dest)
     end
-  end
 
-  test :stream_into do
-    src  = fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
+    @tag :unix
+    test "read_link! with symlink" do
+      target = tmp_path("does_not_need_to_exist")
+      dest = tmp_path("symlink")
+      File.ln_s(target, dest)
 
-    try do
-      refute File.exists?(dest)
+      try do
+        assert File.read_link!(dest) == target
+      after
+        File.rm(dest)
+      end
+    end
 
-      original = File.stream!(dest)
-      stream   = File.stream!(src)
-                 |> Stream.map(&String.replace(&1, "O", "A"))
-                 |> Enum.into(original)
+    test "ln" do
+      existing = fixture_path("file.txt")
+      new = tmp_path("tmp_test.txt")
 
-      assert stream == original
-      assert File.read(dest) == {:ok, "FAA\n"}
-    after
-      File.rm(dest)
+      try do
+        refute File.exists?(new)
+        assert File.ln(existing, new) == :ok
+        assert File.read(new) == {:ok, "FOO\n"}
+      after
+        File.rm(new)
+      end
     end
-  end
 
-  test :stream_into_append do
-    src  = fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
+    test "ln with existing destination" do
+      existing = fixture_path("file.txt")
+      assert File.ln(existing, existing) == {:error, :eexist}
+    end
 
-    try do
-      refute File.exists?(dest)
-      original = File.stream!(dest, [:append])
+    test "ln! with existing destination" do
+      assert_raise File.LinkError, fn ->
+        existing = fixture_path("file.txt")
+        File.ln!(existing, existing)
+      end
+    end
 
-      File.stream!(src, [:append])
-      |> Stream.map(&String.replace(&1, "O", "A"))
-      |> Enum.into(original)
+    test "ln_s" do
+      existing = fixture_path("file.txt")
+      new = tmp_path("tmp_test.txt")
 
-      File.stream!(src, [:append])
-      |> Enum.into(original)
+      try do
+        refute File.exists?(new)
+        assert File.ln_s(existing, new) == :ok
+        assert File.read(new) == {:ok, "FOO\n"}
+      after
+        File.rm(new)
+      end
+    end
 
-      assert File.read(dest) == {:ok, "FAA\nFOO\n"}
-    after
-      File.rm(dest)
+    test "ln_s with existing destination" do
+      existing = fixture_path("file.txt")
+      assert File.ln_s(existing, existing) == {:error, :eexist}
     end
-  end
 
-  test :ln_s do
-    existing  = fixture_path("file.txt")
-    new = tmp_path("tmp_test.txt")
-    try do
-      refute File.exists?(new)
-      assert File.ln_s(existing, new) == :ok
-      assert File.read(new) == {:ok, "FOO\n"}
-    after
-      File.rm(new)
+    test "ln_s! with existing destination" do
+      existing = fixture_path("file.txt")
+
+      assert_raise File.LinkError, fn ->
+        File.ln_s!(existing, existing)
+      end
     end
   end
 
-  test :ln_s_with_existing_destination do
-    existing  = fixture_path("file.txt")
-    assert File.ln_s(existing, existing) == {:error, :eexist}
-  end
+  describe "copy" do
+    test "copy" do
+      src = fixture_path("file.txt")
+      dest = tmp_path("tmp_test.txt")
 
-  test :copy do
-    src  = fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
-    try do
-      refute File.exists?(dest)
-      assert File.copy(src, dest) == {:ok, 4}
-      assert File.read(dest) == {:ok, "FOO\n"}
-    after
-      File.rm(dest)
+      try do
+        refute File.exists?(dest)
+        assert File.copy(src, dest) == {:ok, 4}
+        assert File.read(dest) == {:ok, "FOO\n"}
+      after
+        File.rm(dest)
+      end
     end
-  end
 
-  test :copy_with_bytes_count do
-    src  = fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
-    try do
-      refute File.exists?(dest)
-      assert File.copy(src, dest, 2) == {:ok, 2}
-      assert {:ok, "FO"} == File.read(dest)
-    after
-      File.rm(dest)
+    test "copy with an io_device" do
+      {:ok, src} = File.open(fixture_path("file.txt"))
+      dest = tmp_path("tmp_test.txt")
+
+      try do
+        refute File.exists?(dest)
+        assert File.copy(src, dest) == {:ok, 4}
+        assert File.read(dest) == {:ok, "FOO\n"}
+      after
+        File.close(src)
+        File.rm(dest)
+      end
     end
-  end
 
-  test :copy_with_invalid_file do
-    src  = fixture_path("invalid.txt")
-    dest = tmp_path("tmp_test.txt")
-    assert File.copy(src, dest, 2) == {:error, :enoent}
-  end
+    test "copy with raw io_device" do
+      {:ok, src} = File.open(fixture_path("file.txt"), [:raw])
+      dest = tmp_path("tmp_test.txt")
 
-  test :copy! do
-    src  = fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
-    try do
-      refute File.exists?(dest)
-      assert File.copy!(src, dest) == 4
-      assert {:ok, "FOO\n"} == File.read(dest)
-    after
-      File.rm(dest)
+      try do
+        refute File.exists?(dest)
+        assert File.copy(src, dest) == {:ok, 4}
+        assert File.read(dest) == {:ok, "FOO\n"}
+      after
+        File.close(src)
+        File.rm(dest)
+      end
     end
-  end
 
-  test :copy_with_bytes_count! do
-    src  = fixture_path("file.txt")
-    dest = tmp_path("tmp_test.txt")
-    try do
-      refute File.exists?(dest)
-      assert File.copy!(src, dest, 2) == 2
-      assert {:ok, "FO"} == File.read(dest)
-    after
-      File.rm(dest)
+    test "copy with ram io_device" do
+      {:ok, src} = File.open("FOO\n", [:ram])
+      dest = tmp_path("tmp_test.txt")
+
+      try do
+        refute File.exists?(dest)
+        assert File.copy(src, dest) == {:ok, 4}
+        assert File.read(dest) == {:ok, "FOO\n"}
+      after
+        File.close(src)
+        File.rm(dest)
+      end
     end
-  end
 
-  test :copy_with_invalid_file! do
-    src  = fixture_path("invalid.txt")
-    dest = tmp_path("tmp_test.txt")
-    assert_raise File.CopyError, "could not copy from #{src} to #{dest}: no such file or directory", fn ->
-      File.copy!(src, dest, 2)
+    test "copy with bytes count" do
+      src = fixture_path("file.txt")
+      dest = tmp_path("tmp_test.txt")
+
+      try do
+        refute File.exists?(dest)
+        assert File.copy(src, dest, 2) == {:ok, 2}
+        assert {:ok, "FO"} == File.read(dest)
+      after
+        File.rm(dest)
+      end
     end
-  end
 
-  test :cwd_and_cd do
-    {:ok, current} = File.cwd
-    try do
-      assert File.cd(fixture_path) == :ok
-      assert File.exists?("file.txt")
-    after
-      File.cd!(current)
+    test "copy with invalid file" do
+      src = fixture_path("invalid.txt")
+      dest = tmp_path("tmp_test.txt")
+      assert File.copy(src, dest, 2) == {:error, :enoent}
     end
-  end
 
-  if :file.native_name_encoding == :utf8 do
-    test :cwd_and_cd_with_utf8 do
-      File.mkdir_p(tmp_path("héllò"))
+    test "copy!" do
+      src = fixture_path("file.txt")
+      dest = tmp_path("tmp_test.txt")
 
-      File.cd!(tmp_path("héllò"), fn ->
-        assert Path.basename(File.cwd!) == "héllò"
-      end)
-    after
-      File.rm_rf tmp_path("héllò")
+      try do
+        refute File.exists?(dest)
+        assert File.copy!(src, dest) == 4
+        assert {:ok, "FOO\n"} == File.read(dest)
+      after
+        File.rm(dest)
+      end
     end
-  end
 
-  test :invalid_cd do
-    assert io_error? File.cd(fixture_path("file.txt"))
-  end
+    test "copy! with bytes count" do
+      src = fixture_path("file.txt")
+      dest = tmp_path("tmp_test.txt")
 
-  test :invalid_cd! do
-    message = ~r"^could not set current working directory to #{escape fixture_path("file.txt")}: (not a directory|no such file or directory)"
-    assert_raise File.Error, message, fn ->
-      File.cd!(fixture_path("file.txt"))
+      try do
+        refute File.exists?(dest)
+        assert File.copy!(src, dest, 2) == 2
+        assert {:ok, "FO"} == File.read(dest)
+      after
+        File.rm(dest)
+      end
     end
-  end
 
-  test :cd_with_function do
-    assert File.cd!(fixture_path, fn ->
-      assert File.exists?("file.txt")
-      :cd_result
-    end) == :cd_result
-  end
+    test "copy! with invalid file" do
+      src = fixture_path("invalid.txt")
+      dest = tmp_path("tmp_test.txt")
 
-  test :touch_with_no_file do
-    fixture = tmp_path("tmp_test.txt")
-    time = {{2010, 4, 17}, {14, 0, 0}}
+      message =
+        "could not copy from #{inspect(src)} to #{inspect(dest)}: no such file or directory"
 
-    try do
-      refute File.exists?(fixture)
-      assert File.touch(fixture, time) == :ok
-      assert {:ok, ""} == File.read(fixture)
-      assert File.stat!(fixture).mtime == time
-    after
-      File.rm(fixture)
+      assert_raise File.CopyError, message, fn ->
+        File.copy!(src, dest, 2)
+      end
     end
   end
 
-  test :touch_with_timestamp do
-    fixture = tmp_path("tmp_test.txt")
+  describe "cwd and cd" do
+    test "cwd and cd" do
+      {:ok, current} = File.cwd()
+
+      try do
+        assert File.cd(fixture_path()) == :ok
+        assert File.exists?("file.txt")
+      after
+        File.cd!(current)
+      end
+    end
 
-    try do
-      assert File.touch!(fixture) == :ok
-      stat = File.stat!(fixture)
+    if :file.native_name_encoding() == :utf8 do
+      test "cwd and cd with UTF-8" do
+        File.mkdir_p(tmp_path("héllò"))
 
-      assert File.touch!(fixture, last_year) == :ok
-      assert stat.mtime > File.stat!(fixture).mtime
-    after
-      File.rm(fixture)
+        File.cd!(tmp_path("héllò"), fn ->
+          assert Path.basename(File.cwd!()) == "héllò"
+        end)
+      after
+        File.rm_rf(tmp_path("héllò"))
+      end
     end
-  end
 
-  test :touch_with_dir do
-    assert File.touch(fixture_path) == :ok
-  end
+    test "invalid cd" do
+      assert io_error?(File.cd(fixture_path("file.txt")))
+    end
 
-  test :touch_with_failure do
-    fixture = fixture_path("file.txt/bar")
-    assert io_error? File.touch(fixture)
-  end
+    test "invalid_cd!" do
+      message =
+        ~r"\Acould not set current working directory to #{inspect(fixture_path("file.txt"))}: (not a directory|no such file or directory|I/O error)"
 
-  test :touch_with_success! do
-    assert File.touch!(fixture_path) == :ok
-  end
+      assert_raise File.Error, message, fn ->
+        File.cd!(fixture_path("file.txt"))
+      end
+    end
 
-  test :touch_with_failure! do
-    fixture = fixture_path("file.txt/bar")
-    assert_raise File.Error, ~r"could not touch #{escape fixture}: (not a directory|no such file or directory)", fn ->
-      File.touch!(fixture)
+    test "cd with function" do
+      assert File.cd!(fixture_path(), fn ->
+               assert File.exists?("file.txt")
+               :cd_result
+             end) == :cd_result
     end
   end
 
-  test :chmod_with_success do
-    fixture = tmp_path("tmp_test.txt")
+  describe "touch" do
+    test "touch with no file" do
+      fixture = tmp_path("tmp_test.txt")
+      time = {{2010, 4, 17}, {14, 0, 0}}
+
+      try do
+        refute File.exists?(fixture)
+        assert File.touch(fixture, time) == :ok
+        assert {:ok, ""} == File.read(fixture)
+        assert File.stat!(fixture).mtime == time
+      after
+        File.rm(fixture)
+      end
+    end
 
-    File.touch(fixture)
-    try do
-      assert File.chmod(fixture, 0100666) == :ok
-      stat = File.stat!(fixture)
-      assert stat.mode == 0100666
+    test "touch with Erlang timestamp" do
+      fixture = tmp_path("tmp_erlang_touch.txt")
 
-      unless is_win? do
-        assert File.chmod(fixture, 0100777) == :ok
+      try do
+        assert File.touch!(fixture, :erlang.universaltime()) == :ok
         stat = File.stat!(fixture)
-        assert stat.mode == 0100777
+
+        assert File.touch!(fixture, last_year()) == :ok
+        assert stat.mtime > File.stat!(fixture).mtime
+      after
+        File.rm(fixture)
+      end
+    end
+
+    test "touch with posix timestamp" do
+      fixture = tmp_path("tmp_posix_touch.txt")
+
+      try do
+        assert File.touch!(fixture, System.os_time(:second)) == :ok
+        stat = File.stat!(fixture)
+
+        assert File.touch!(fixture, last_year()) == :ok
+        assert stat.mtime > File.stat!(fixture).mtime
+      after
+        File.rm(fixture)
+      end
+    end
+
+    test "touch with dir" do
+      assert File.touch(fixture_path()) == :ok
+    end
+
+    test "touch with failure" do
+      fixture = fixture_path("file.txt/bar")
+      assert io_error?(File.touch(fixture))
+    end
+
+    test "touch! raises" do
+      fixture = fixture_path("file.txt/bar")
+
+      message =
+        ~r"\Acould not touch #{inspect(fixture)}: (not a directory|no such file or directory)"
+
+      assert_raise File.Error, message, fn ->
+        File.touch!(fixture)
       end
-    after
-      File.rm(fixture)
     end
   end
 
-  test :chmod_with_success! do
-    fixture = tmp_path("tmp_test.txt")
+  describe "ch*" do
+    test "chmod with success" do
+      fixture = tmp_path("tmp_test.txt")
 
-    File.touch(fixture)
-    try do
-      assert File.chmod!(fixture, 0100666) == :ok
-      stat = File.stat!(fixture)
-      assert stat.mode == 0100666
+      File.touch(fixture)
 
-      unless is_win? do
-        assert File.chmod!(fixture, 0100777) == :ok
+      try do
+        assert File.chmod(fixture, 0o100666) == :ok
         stat = File.stat!(fixture)
-        assert stat.mode == 0100777
+        assert stat.mode == 0o100666
+
+        if not windows?() do
+          assert File.chmod(fixture, 0o100777) == :ok
+          stat = File.stat!(fixture)
+          assert stat.mode == 0o100777
+        end
+      after
+        File.rm(fixture)
       end
-    after
-      File.rm(fixture)
     end
-  end
 
-  test :chmod_with_failure do
-    fixture = tmp_path("tmp_test.txt")
-    File.rm(fixture)
+    test "chmod! with success" do
+      fixture = tmp_path("tmp_test.txt")
 
-    assert File.chmod(fixture, 0100777) == {:error,:enoent}
-  end
+      File.touch(fixture)
+
+      try do
+        assert File.chmod!(fixture, 0o100666) == :ok
+        stat = File.stat!(fixture)
+        assert stat.mode == 0o100666
+
+        if not windows?() do
+          assert File.chmod!(fixture, 0o100777) == :ok
+          stat = File.stat!(fixture)
+          assert stat.mode == 0o100777
+        end
+      after
+        File.rm(fixture)
+      end
+    end
 
-  test :chmod_with_failure! do
-    fixture = tmp_path("tmp_test.txt")
-    File.rm(fixture)
+    test "chmod with failure" do
+      fixture = tmp_path("tmp_test.txt")
+      File.rm(fixture)
 
-    message = ~r"could not change mode for #{escape fixture}: no such file or directory"
-    assert_raise File.Error, message, fn ->
-      File.chmod!(fixture, 0100777)
+      assert File.chmod(fixture, 0o100777) == {:error, :enoent}
     end
-  end
 
-  test :chgrp_with_failure do
-    fixture = tmp_path("tmp_test.txt")
-    File.rm(fixture)
+    test "chmod! with failure" do
+      fixture = tmp_path("tmp_test.txt")
+      File.rm(fixture)
+
+      message = ~r"could not change mode for #{inspect(fixture)}: no such file or directory"
 
-    assert File.chgrp(fixture, 1) == {:error,:enoent}
-  end
+      assert_raise File.Error, message, fn ->
+        File.chmod!(fixture, 0o100777)
+      end
+    end
 
-  test :chgrp_with_failure! do
-    fixture = tmp_path("tmp_test.txt")
-    File.rm(fixture)
+    test "chgrp with failure" do
+      fixture = tmp_path("tmp_test.txt")
+      File.rm(fixture)
 
-    message = ~r"could not change group for #{escape fixture}: no such file or directory"
-    assert_raise File.Error, message, fn ->
-      File.chgrp!(fixture, 1)
+      assert File.chgrp(fixture, 1) == {:error, :enoent}
     end
-  end
 
-  test :chown_with_failure do
-    fixture = tmp_path("tmp_test.txt")
-    File.rm(fixture)
+    test "chgrp! with failure" do
+      fixture = tmp_path("tmp_test.txt")
+      File.rm(fixture)
+
+      message = ~r"could not change group for #{inspect(fixture)}: no such file or directory"
 
-    assert File.chown(fixture, 1) == {:error,:enoent}
-  end
+      assert_raise File.Error, message, fn ->
+        File.chgrp!(fixture, 1)
+      end
+    end
 
-  test :chown_with_failure! do
-    fixture = tmp_path("tmp_test.txt")
-    File.rm(fixture)
+    test "chown with failure" do
+      fixture = tmp_path("tmp_test.txt")
+      File.rm(fixture)
 
-    message = ~r"could not change owner for #{escape fixture}: no such file or directory"
-    assert_raise File.Error, message, fn ->
-      File.chown!(fixture, 1)
+      assert File.chown(fixture, 1) == {:error, :enoent}
     end
-  end
 
-  defp last_year do
-    last_year :calendar.local_time
+    test "chown! with failure" do
+      fixture = tmp_path("tmp_test.txt")
+      File.rm(fixture)
+
+      message = ~r"could not change owner for #{inspect(fixture)}: no such file or directory"
+
+      assert_raise File.Error, message, fn ->
+        File.chown!(fixture, 1)
+      end
+    end
   end
 
-  defp last_year({{year, month, day}, time}) do
-    {{year - 1, month, day}, time}
+  defp last_year do
+    System.os_time(:second) - 365 * 24 * 60 * 60
   end
 
   defp io_error?(result) do
-    {:error, errorcode} = result
-    errorcode in [:enotdir, :eio, :enoent, :eisdir]
+    elem(result, 1) in [:enotdir, :eio, :enoent, :eisdir]
   end
 end
diff --git a/lib/elixir/test/elixir/fixtures/at_exit.exs b/lib/elixir/test/elixir/fixtures/at_exit.exs
index 78460b222ba..f0150a4333b 100644
--- a/lib/elixir/test/elixir/fixtures/at_exit.exs
+++ b/lib/elixir/test/elixir/fixtures/at_exit.exs
@@ -1,8 +1,9 @@
 defmodule AtExit do
   def at_exit(str) do
-    System.at_exit fn(_) -> IO.write(str) end
+    System.at_exit(fn _ -> IO.write(str) end)
   end
 end
-System.at_exit fn(status) -> IO.puts "cruel world with status #{status}" end
+
+System.at_exit(fn status -> IO.puts("cruel world with status #{status}") end)
 AtExit.at_exit("goodbye ")
-exit(0)
\ No newline at end of file
+exit({:shutdown, 1})
diff --git a/lib/elixir/test/elixir/fixtures/code_sample.exs b/lib/elixir/test/elixir/fixtures/code_sample.exs
index f1895089889..511623e3a7c 100644
--- a/lib/elixir/test/elixir/fixtures/code_sample.exs
+++ b/lib/elixir/test/elixir/fixtures/code_sample.exs
@@ -1,3 +1,3 @@
 # Some Comments
 var = 1 + 2
-var
\ No newline at end of file
+var
diff --git a/lib/elixir/test/elixir/fixtures/compile_sample.ex b/lib/elixir/test/elixir/fixtures/compile_sample.ex
index 7cbd92b5a29..78761880f11 100644
--- a/lib/elixir/test/elixir/fixtures/compile_sample.ex
+++ b/lib/elixir/test/elixir/fixtures/compile_sample.ex
@@ -1 +1 @@
-defmodule CompileSample, do: nil
\ No newline at end of file
+defmodule(CompileSample, do: nil)
diff --git a/lib/mix/test/fixtures/configs/bad_app.exs b/lib/elixir/test/elixir/fixtures/configs/bad_app.exs
similarity index 100%
rename from lib/mix/test/fixtures/configs/bad_app.exs
rename to lib/elixir/test/elixir/fixtures/configs/bad_app.exs
diff --git a/lib/elixir/test/elixir/fixtures/configs/bad_import.exs b/lib/elixir/test/elixir/fixtures/configs/bad_import.exs
new file mode 100644
index 00000000000..d03906ea1e9
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/configs/bad_import.exs
@@ -0,0 +1,2 @@
+import Config
+import_config "bad_root.exs"
diff --git a/lib/elixir/test/elixir/fixtures/configs/env.exs b/lib/elixir/test/elixir/fixtures/configs/env.exs
new file mode 100644
index 00000000000..739e6236941
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/configs/env.exs
@@ -0,0 +1,2 @@
+import Config
+config :my_app, env: config_env(), target: config_target()
diff --git a/lib/elixir/test/elixir/fixtures/configs/good_config.exs b/lib/elixir/test/elixir/fixtures/configs/good_config.exs
new file mode 100644
index 00000000000..dd2bb471195
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/configs/good_config.exs
@@ -0,0 +1,2 @@
+import Config
+config :my_app, :key, :value
diff --git a/lib/mix/test/fixtures/configs/good_import.exs b/lib/elixir/test/elixir/fixtures/configs/good_import.exs
similarity index 71%
rename from lib/mix/test/fixtures/configs/good_import.exs
rename to lib/elixir/test/elixir/fixtures/configs/good_import.exs
index 759edb0108a..549312a2db6 100644
--- a/lib/mix/test/fixtures/configs/good_import.exs
+++ b/lib/elixir/test/elixir/fixtures/configs/good_import.exs
@@ -1,3 +1,3 @@
-use Mix.Config
+import Config
 import_config "good_config.exs"
 :done
diff --git a/lib/elixir/test/elixir/fixtures/configs/good_kw.exs b/lib/elixir/test/elixir/fixtures/configs/good_kw.exs
new file mode 100644
index 00000000000..0c13b63b986
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/configs/good_kw.exs
@@ -0,0 +1 @@
+[my_app: [key: :value]]
diff --git a/lib/elixir/test/elixir/fixtures/configs/imports_recursive.exs b/lib/elixir/test/elixir/fixtures/configs/imports_recursive.exs
new file mode 100644
index 00000000000..c71c4418ec6
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/configs/imports_recursive.exs
@@ -0,0 +1,2 @@
+import Config
+import_config "recursive.exs"
diff --git a/lib/elixir/test/elixir/fixtures/configs/kernel.exs b/lib/elixir/test/elixir/fixtures/configs/kernel.exs
new file mode 100644
index 00000000000..5020372a5d8
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/configs/kernel.exs
@@ -0,0 +1,3 @@
+import Config
+config :kernel, :elixir_reboot, true
+config :elixir_reboot, :key, :value
diff --git a/lib/elixir/test/elixir/fixtures/configs/nested.exs b/lib/elixir/test/elixir/fixtures/configs/nested.exs
new file mode 100644
index 00000000000..5570ef976d9
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/configs/nested.exs
@@ -0,0 +1,2 @@
+import Config
+config :app, Repo, key: [nested: true]
diff --git a/lib/elixir/test/elixir/fixtures/configs/recursive.exs b/lib/elixir/test/elixir/fixtures/configs/recursive.exs
new file mode 100644
index 00000000000..eb25bb4076d
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/configs/recursive.exs
@@ -0,0 +1,2 @@
+import Config
+import_config "imports_recursive.exs"
diff --git a/lib/elixir/test/elixir/fixtures/consolidation/no_impl.ex b/lib/elixir/test/elixir/fixtures/consolidation/no_impl.ex
new file mode 100644
index 00000000000..7cd9f90db4c
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/consolidation/no_impl.ex
@@ -0,0 +1,3 @@
+defprotocol Protocol.ConsolidationTest.NoImpl do
+  def ok(term)
+end
diff --git a/lib/elixir/test/elixir/fixtures/consolidation/sample.ex b/lib/elixir/test/elixir/fixtures/consolidation/sample.ex
new file mode 100644
index 00000000000..ee7edea3fbc
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/consolidation/sample.ex
@@ -0,0 +1,7 @@
+defprotocol Protocol.ConsolidationTest.Sample do
+  @type t :: any
+  @doc "Ok"
+  @deprecated "Reason"
+  @spec ok(t) :: boolean
+  def ok(term)
+end
diff --git a/lib/elixir/test/elixir/fixtures/consolidation/with_any.ex b/lib/elixir/test/elixir/fixtures/consolidation/with_any.ex
new file mode 100644
index 00000000000..513257ec5d2
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/consolidation/with_any.ex
@@ -0,0 +1,5 @@
+defprotocol Protocol.ConsolidationTest.WithAny do
+  @fallback_to_any true
+  @doc "Ok"
+  def ok(term, opts)
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/assertions.ex b/lib/elixir/test/elixir/fixtures/dialyzer/assertions.ex
new file mode 100644
index 00000000000..a81ceedcd2c
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/assertions.ex
@@ -0,0 +1,35 @@
+defmodule Dialyzer.Assertions do
+  import ExUnit.Assertions
+
+  def assert_with_truthy_match do
+    assert :ok = known_type_truthy()
+  end
+
+  def assert_with_truthy_value do
+    assert known_type_truthy()
+  end
+
+  def assert_with_unknown_type do
+    assert unknown_type_truthy()
+  end
+
+  def refute_with_falsy_value do
+    refute known_type_falsy()
+  end
+
+  def refute_with_unknown_type do
+    refute unknown_type_falsy()
+  end
+
+  def refute_with_operator(log) do
+    refute log == "failure"
+  end
+
+  defp known_type_truthy, do: :ok
+  defp known_type_falsy, do: nil
+
+  @spec unknown_type_truthy :: any
+  defp unknown_type_truthy, do: Enum.random([1, true, :ok])
+  @spec unknown_type_falsy :: any
+  defp unknown_type_falsy, do: Enum.random([false, nil])
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/boolean_check.ex b/lib/elixir/test/elixir/fixtures/dialyzer/boolean_check.ex
new file mode 100644
index 00000000000..e8123315370
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/boolean_check.ex
@@ -0,0 +1,9 @@
+defmodule Dialyzer.BooleanCheck do
+  def and_check(arg) when is_boolean(arg) do
+    arg and arg
+  end
+
+  def or_check(arg) when is_boolean(arg) do
+    arg or arg
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/callback.ex b/lib/elixir/test/elixir/fixtures/dialyzer/callback.ex
new file mode 100644
index 00000000000..0eeff5f5c3d
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/callback.ex
@@ -0,0 +1,14 @@
+defmodule Dialyzer.Callback do
+  @callback required(atom) :: atom
+  @callback required(list) :: list
+end
+
+defmodule Dialyzer.Callback.ImplAtom do
+  @behaviour Dialyzer.Callback
+  def required(:ok), do: :ok
+end
+
+defmodule Dialyzer.Callback.ImplList do
+  @behaviour Dialyzer.Callback
+  def required([a, b]), do: [b, a]
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/cond.ex b/lib/elixir/test/elixir/fixtures/dialyzer/cond.ex
new file mode 100644
index 00000000000..9419b9b8e36
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/cond.ex
@@ -0,0 +1,27 @@
+defmodule Dialyzer.Cond do
+  def one_boolean do
+    cond do
+      true -> :ok
+    end
+  end
+
+  def two_boolean do
+    cond do
+      List.flatten([]) == [] -> :ok
+      true -> :ok
+    end
+  end
+
+  def one_otherwise do
+    cond do
+      :otherwise -> :ok
+    end
+  end
+
+  def two_otherwise do
+    cond do
+      List.flatten([]) == [] -> :ok
+      :otherwise -> :ok
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/defmacrop.ex b/lib/elixir/test/elixir/fixtures/dialyzer/defmacrop.ex
new file mode 100644
index 00000000000..e8d0a42ce7d
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/defmacrop.ex
@@ -0,0 +1,11 @@
+defmodule Dialyzer.Defmacrop do
+  defmacrop good_macro(id) do
+    quote do
+      {:good, {:good_macro, unquote(id)}}
+    end
+  end
+
+  def run() do
+    good_macro("Not So Bad")
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/for_bitstring.ex b/lib/elixir/test/elixir/fixtures/dialyzer/for_bitstring.ex
new file mode 100644
index 00000000000..1d22de458e6
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/for_bitstring.ex
@@ -0,0 +1,5 @@
+defmodule Dialyzer.ForBitstring do
+  def foo() do
+    for a <- 1..3, into: "", do: <<a>>
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/for_boolean_check.ex b/lib/elixir/test/elixir/fixtures/dialyzer/for_boolean_check.ex
new file mode 100644
index 00000000000..968efe7873e
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/for_boolean_check.ex
@@ -0,0 +1,7 @@
+defmodule Dialyzer.ForBooleanCheck do
+  def foo(enum, potential) when is_binary(potential) do
+    for element <- enum, string = Atom.to_string(element), string == potential do
+      element
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/is_struct.ex b/lib/elixir/test/elixir/fixtures/dialyzer/is_struct.ex
new file mode 100644
index 00000000000..c61a6a1b1b3
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/is_struct.ex
@@ -0,0 +1,9 @@
+defmodule Dialyzer.IsStruct do
+  def map_literal_atom_literal() do
+    is_struct(%Macro.Env{}, Macro.Env)
+  end
+
+  def arg_atom_literal(arg) do
+    is_struct(arg, Macro.Env)
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/macrocallback.ex b/lib/elixir/test/elixir/fixtures/dialyzer/macrocallback.ex
new file mode 100644
index 00000000000..42bd2bc9bc7
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/macrocallback.ex
@@ -0,0 +1,11 @@
+defmodule Dialyzer.Macrocallback do
+  @macrocallback required(atom) :: Macro.t()
+  @macrocallback optional(atom) :: Macro.t()
+  @optional_callbacks [optional: 1]
+end
+
+defmodule Dialyzer.Macrocallback.Impl do
+  @behaviour Dialyzer.Macrocallback
+  defmacro required(var), do: Macro.expand(var, __CALLER__)
+  defmacro optional(var), do: Macro.expand(var, __CALLER__)
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/opaqueness.ex b/lib/elixir/test/elixir/fixtures/dialyzer/opaqueness.ex
new file mode 100644
index 00000000000..d8371c386e5
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/opaqueness.ex
@@ -0,0 +1,22 @@
+defmodule Dialyzer.Opaqueness do
+  @spec bar(MapSet.t()) :: term()
+  def bar(set) do
+    set
+  end
+
+  def inlined do
+    # inlining of literals should not violate opaqueness check
+    bar(MapSet.new([1, 2, 3]))
+  end
+
+  @my_set MapSet.new([1, 2, 3])
+  def module_attr do
+    bar(@my_set)
+  end
+
+  # Task.Supervisor returns a Task.t() containing an opaque Task.ref()
+  @spec run_task() :: Task.t()
+  def run_task do
+    Task.Supervisor.async(SupervisorName, fn -> :ok end)
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/raise.ex b/lib/elixir/test/elixir/fixtures/dialyzer/raise.ex
new file mode 100644
index 00000000000..808ba3b0233
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/raise.ex
@@ -0,0 +1,21 @@
+defmodule Dialyzer.Raise do
+  defexception [:message]
+
+  def exception_var() do
+    ex = %Dialyzer.Raise{}
+    raise ex
+  end
+
+  def exception_var(ex = %Dialyzer.Raise{}) do
+    raise ex
+  end
+
+  def string_var() do
+    string = "hello"
+    raise string
+  end
+
+  def string_var(string) when is_binary(string) do
+    raise string
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/regressions.ex b/lib/elixir/test/elixir/fixtures/dialyzer/regressions.ex
new file mode 100644
index 00000000000..8cb04f394ae
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/regressions.ex
@@ -0,0 +1,18 @@
+defmodule Dialyzer.Regressions do
+  def io_inspect_opts do
+    IO.inspect(123, label: "foo", limit: :infinity)
+  end
+
+  def format_opts do
+    Code.format_string!("",
+      line_length: 120,
+      force_do_end_blocks: true,
+      locals_without_parens: true,
+      migrate: true
+    )
+  end
+
+  def eex_eval_opts do
+    EEx.eval_string("foo <%= bar %>", [bar: "baz"], trim: true)
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/remote_call.ex b/lib/elixir/test/elixir/fixtures/dialyzer/remote_call.ex
new file mode 100644
index 00000000000..a63654b4c8d
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/remote_call.ex
@@ -0,0 +1,29 @@
+defmodule Dialyzer.RemoteCall do
+  _ = Application.load(:dialyzer)
+
+  case Application.spec(:dialyzer, :vsn) do
+    ~c(2.) ++ _ ->
+      @dialyzer {:no_fail_call, [map_var: 0]}
+
+    three when three < ~c(3.0.2) ->
+      # regression introduced in 3.0 for map warnings fixed in 3.0.2
+      @dialyzer {:no_match, [map_var: 0, mod_var: 0]}
+
+    _ ->
+      :ok
+  end
+
+  def map_var() do
+    map = %{key: 1}
+    map.key
+  end
+
+  def map_var(map) when is_map(map) do
+    map.key
+  end
+
+  def mod_var() do
+    module = String.to_atom("Elixir.Hello")
+    module.fun()
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/rewrite.ex b/lib/elixir/test/elixir/fixtures/dialyzer/rewrite.ex
new file mode 100644
index 00000000000..129f0bbea68
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/rewrite.ex
@@ -0,0 +1,9 @@
+defmodule Dialyzer.Rewrite do
+  def interpolation do
+    "foo #{:a}"
+  end
+
+  def reverse do
+    Enum.reverse(1..3)
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/try.ex b/lib/elixir/test/elixir/fixtures/dialyzer/try.ex
new file mode 100644
index 00000000000..69f9ca4b45f
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/try.ex
@@ -0,0 +1,9 @@
+defmodule Dialyzer.Try do
+  def rescue_error do
+    try do
+      :erlang.error(:badarg)
+    rescue
+      e in ErlangError -> {:ok, e}
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/with.ex b/lib/elixir/test/elixir/fixtures/dialyzer/with.ex
new file mode 100644
index 00000000000..e4a9a0eb87b
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/with.ex
@@ -0,0 +1,45 @@
+defmodule Dialyzer.With do
+  def with_else do
+    with :ok <- ok_or_error(),
+         :ok <- ok_or_other_error(),
+         :ok <- ok_or_tuple_error(),
+         :ok <- ok_or_tuple_list_error() do
+      :ok
+    else
+      :error ->
+        :error
+
+      :other_error ->
+        :other_error
+
+      {:error, msg} when is_list(msg) or is_tuple(msg) ->
+        :error
+
+      {:error, msg} when is_list(msg) when is_tuple(msg) ->
+        :error
+
+      {:error, _msg} ->
+        :error
+    end
+  end
+
+  @spec ok_or_error() :: :ok | :error
+  defp ok_or_error do
+    Enum.random([:ok, :error])
+  end
+
+  @spec ok_or_other_error() :: :ok | :other_error
+  defp ok_or_other_error do
+    Enum.random([:ok, :other_error])
+  end
+
+  @spec ok_or_tuple_error() :: :ok | {:error, :err}
+  defp ok_or_tuple_error do
+    Enum.random([:ok, {:error, :err}])
+  end
+
+  @spec ok_or_tuple_list_error() :: :ok | {:error, [:err]}
+  defp ok_or_tuple_list_error do
+    Enum.random([:ok, {:error, [:err]}])
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/with_no_return.ex b/lib/elixir/test/elixir/fixtures/dialyzer/with_no_return.ex
new file mode 100644
index 00000000000..264f58c8ff8
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/with_no_return.ex
@@ -0,0 +1,13 @@
+defmodule Dialyzer.WithNoReturn do
+  def with_no_return(list) do
+    no_return = fn -> throw(:no_return) end
+
+    with [] <- list do
+      :ok
+    else
+      # note: throwing here directly wouldn't be caught in the first place,
+      # calling a no_return function is what could cause an issue.
+      _ -> no_return.()
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/dialyzer/with_throwing_else.ex b/lib/elixir/test/elixir/fixtures/dialyzer/with_throwing_else.ex
new file mode 100644
index 00000000000..1ea99134e37
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/dialyzer/with_throwing_else.ex
@@ -0,0 +1,12 @@
+defmodule Dialyzer.WithThrowingElse do
+  def with_throwing_else(map) do
+    with {:ok, foo} <- Map.fetch(map, :foo),
+         false <- Enum.empty?(foo) do
+      foo
+    else
+      # several clauses but one is a no_return
+      :error -> throw(:empty_map)
+      true -> nil
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/fixtures/file.bin b/lib/elixir/test/elixir/fixtures/file.bin
new file mode 100644
index 00000000000..491c0980ddb
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/file.bin
@@ -0,0 +1,4 @@
+LF
+CR
CRLF
+LFCR
+
\ No newline at end of file
diff --git a/lib/elixir/test/elixir/fixtures/init_sample.exs b/lib/elixir/test/elixir/fixtures/init_sample.exs
deleted file mode 100644
index 4a1775c5027..00000000000
--- a/lib/elixir/test/elixir/fixtures/init_sample.exs
+++ /dev/null
@@ -1 +0,0 @@
-IO.puts to_string(1 + 2)
\ No newline at end of file
diff --git a/lib/elixir/test/elixir/fixtures/multiline_file.txt b/lib/elixir/test/elixir/fixtures/multiline_file.txt
new file mode 100644
index 00000000000..9899a767b6c
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/multiline_file.txt
@@ -0,0 +1,2 @@
+this is the first line
+this is the second line
diff --git a/lib/elixir/test/elixir/fixtures/parallel_compiler/bar.ex b/lib/elixir/test/elixir/fixtures/parallel_compiler/bar.ex
deleted file mode 100644
index d6134b4c825..00000000000
--- a/lib/elixir/test/elixir/fixtures/parallel_compiler/bar.ex
+++ /dev/null
@@ -1,5 +0,0 @@
-defmodule Bar do
-end
-
-require Foo
-IO.puts Foo.message
\ No newline at end of file
diff --git a/lib/elixir/test/elixir/fixtures/parallel_compiler/bat.ex b/lib/elixir/test/elixir/fixtures/parallel_compiler/bat.ex
deleted file mode 100644
index 87cfccc56c9..00000000000
--- a/lib/elixir/test/elixir/fixtures/parallel_compiler/bat.ex
+++ /dev/null
@@ -1,3 +0,0 @@
-defmodule Bat do
-  ThisModuleWillNeverBeAvailable[]
-end
\ No newline at end of file
diff --git a/lib/elixir/test/elixir/fixtures/parallel_compiler/foo.ex b/lib/elixir/test/elixir/fixtures/parallel_compiler/foo.ex
deleted file mode 100644
index ea9a7cd6d50..00000000000
--- a/lib/elixir/test/elixir/fixtures/parallel_compiler/foo.ex
+++ /dev/null
@@ -1,3 +0,0 @@
-defmodule Foo do
-  def message, do: "message_from_foo"
-end
\ No newline at end of file
diff --git a/lib/elixir/test/elixir/fixtures/parallel_deadlock/bar.ex b/lib/elixir/test/elixir/fixtures/parallel_deadlock/bar.ex
deleted file mode 100644
index 4cb9fca2c7b..00000000000
--- a/lib/elixir/test/elixir/fixtures/parallel_deadlock/bar.ex
+++ /dev/null
@@ -1,3 +0,0 @@
-defmodule Bar do
-  Foo.__info__(:macros)
-end
\ No newline at end of file
diff --git a/lib/elixir/test/elixir/fixtures/parallel_deadlock/foo.ex b/lib/elixir/test/elixir/fixtures/parallel_deadlock/foo.ex
deleted file mode 100644
index d50072d11af..00000000000
--- a/lib/elixir/test/elixir/fixtures/parallel_deadlock/foo.ex
+++ /dev/null
@@ -1,3 +0,0 @@
-defmodule Foo do
-  Bar.__info__(:macros)
-end
\ No newline at end of file
diff --git a/lib/elixir/test/elixir/fixtures/parallel_struct/bar.ex b/lib/elixir/test/elixir/fixtures/parallel_struct/bar.ex
deleted file mode 100644
index 6e697731403..00000000000
--- a/lib/elixir/test/elixir/fixtures/parallel_struct/bar.ex
+++ /dev/null
@@ -1,4 +0,0 @@
-defmodule Bar do
-  defstruct name: ""
-  def foo?(%Foo{}), do: true
-end
diff --git a/lib/elixir/test/elixir/fixtures/parallel_struct/foo.ex b/lib/elixir/test/elixir/fixtures/parallel_struct/foo.ex
deleted file mode 100644
index 0e7153e01de..00000000000
--- a/lib/elixir/test/elixir/fixtures/parallel_struct/foo.ex
+++ /dev/null
@@ -1,4 +0,0 @@
-defmodule Foo do
-  defstruct name: ""
-  def bar?(%Bar{}), do: true
-end
diff --git a/lib/elixir/test/elixir/fixtures/utf16_be_bom.txt b/lib/elixir/test/elixir/fixtures/utf16_be_bom.txt
new file mode 100644
index 00000000000..2499c9df2b1
Binary files /dev/null and b/lib/elixir/test/elixir/fixtures/utf16_be_bom.txt differ
diff --git a/lib/elixir/test/elixir/fixtures/utf16_le_bom.txt b/lib/elixir/test/elixir/fixtures/utf16_le_bom.txt
new file mode 100644
index 00000000000..5e16b0d385a
Binary files /dev/null and b/lib/elixir/test/elixir/fixtures/utf16_le_bom.txt differ
diff --git a/lib/elixir/test/elixir/fixtures/utf8_bom.txt b/lib/elixir/test/elixir/fixtures/utf8_bom.txt
new file mode 100644
index 00000000000..bed73fc4ca1
--- /dev/null
+++ b/lib/elixir/test/elixir/fixtures/utf8_bom.txt
@@ -0,0 +1,2 @@
+Русский
+日
diff --git a/lib/elixir/test/elixir/fixtures/warnings_sample.ex b/lib/elixir/test/elixir/fixtures/warnings_sample.ex
deleted file mode 100644
index 4a0bfef0ffd..00000000000
--- a/lib/elixir/test/elixir/fixtures/warnings_sample.ex
+++ /dev/null
@@ -1,4 +0,0 @@
-defmodule WarningsSample do
-  def hello(a), do: a
-  def hello(b), do: b
-end
diff --git a/lib/elixir/test/elixir/float_test.exs b/lib/elixir/test/elixir/float_test.exs
index a1a1471095e..fbc9230a490 100644
--- a/lib/elixir/test/elixir/float_test.exs
+++ b/lib/elixir/test/elixir/float_test.exs
@@ -1,17 +1,36 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule FloatTest do
   use ExUnit.Case, async: true
 
-  test :parse do
+  doctest Float
+
+  # TODO remove and replace by assert once we require Erlang/OTP 27+
+  # We can't easily distinguish between -0.0 and +0.0 on previous version
+  defmacrop float_assert({:===, _, [left, right]}) do
+    quote do
+      # note: these are pure functions so no need to use bind_quoted
+      # we favor a useful error message instead
+      assert unquote(left) === unquote(right)
+      assert to_string(unquote(left)) === to_string(unquote(right))
+    end
+  end
+
+  test "parse/1" do
     assert Float.parse("12") === {12.0, ""}
     assert Float.parse("-12") === {-12.0, ""}
     assert Float.parse("-0.1") === {-0.1, ""}
-    assert Float.parse("123456789") === {123456789.0, ""}
+    assert Float.parse("123456789") === {123_456_789.0, ""}
     assert Float.parse("12.5") === {12.5, ""}
     assert Float.parse("12.524235") === {12.524235, ""}
     assert Float.parse("-12.5") === {-12.5, ""}
     assert Float.parse("-12.524235") === {-12.524235, ""}
+    assert Float.parse("0.3534091") === {0.3534091, ""}
+    assert Float.parse("0.3534091elixir") === {0.3534091, "elixir"}
     assert Float.parse("7.5e3") === {7.5e3, ""}
     assert Float.parse("7.5e-3") === {7.5e-3, ""}
     assert Float.parse("12x") === {12.0, "x"}
@@ -20,51 +39,201 @@ defmodule FloatTest do
     assert Float.parse("-12.32453e-10") === {-1.232453e-9, ""}
     assert Float.parse("0.32453e-10") === {3.2453e-11, ""}
     assert Float.parse("1.32453e-10") === {1.32453e-10, ""}
+    assert Float.parse("1.7976931348623159e-99999foo") === {0.0, "foo"}
     assert Float.parse("1.32.45") === {1.32, ".45"}
     assert Float.parse("1.o") === {1.0, ".o"}
+    assert Float.parse("+12.3E+4") === {1.23e5, ""}
+    assert Float.parse("+12.3E-4x") === {0.00123, "x"}
+    assert Float.parse("-1.23e-0xFF") === {-1.23, "xFF"}
+    assert Float.parse("-1.e2") === {-1.0, ".e2"}
+    assert Float.parse(".12") === :error
     assert Float.parse("--1.2") === :error
     assert Float.parse("++1.2") === :error
     assert Float.parse("pi") === :error
+    assert Float.parse("1.7976931348623157e308") === {1.7976931348623157e308, ""}
+    assert Float.parse("1.7976931348623157e308foo") === {1.7976931348623157e308, "foo"}
+    assert Float.parse("1.7976931348623157e+308foo") === {1.7976931348623157e308, "foo"}
+    assert Float.parse("1.7976931348623157e-308foo") === {1.7976931348623155e-308, "foo"}
+    assert Float.parse("1.7976931348623159e308") === :error
+    assert Float.parse("1.7976931348623159e+308") === :error
+    assert Float.parse("9e8363") === :error
+  end
+
+  test "floor/1" do
+    float_assert Float.floor(12.524235) === 12.0
+    float_assert Float.floor(-12.5) === -13.0
+    float_assert Float.floor(-12.524235) === -13.0
+    float_assert Float.floor(7.5e3) === 7500.0
+    float_assert Float.floor(7.5432e3) === 7543.0
+    float_assert Float.floor(7.5e-3) === 0.0
+    float_assert Float.floor(-12.32453e4) === -123_246.0
+    float_assert Float.floor(-12.32453e-10) === -1.0
+    float_assert Float.floor(0.32453e-10) === 0.0
+    float_assert Float.floor(-0.32453e-10) === -1.0
+    float_assert Float.floor(1.32453e-10) === 0.0
+  end
+
+  describe "floor/2" do
+    test "with 0.0" do
+      for precision <- 0..15 do
+        float_assert Float.floor(0.0, precision) === 0.0
+        float_assert Float.floor(-0.0, precision) === -0.0
+      end
+    end
+
+    test "floor/2 with precision" do
+      float_assert Float.floor(12.524235, 0) === 12.0
+      float_assert Float.floor(-12.524235, 0) === -13.0
+
+      float_assert Float.floor(12.52, 2) === 12.51
+      float_assert Float.floor(-12.52, 2) === -12.52
+
+      float_assert Float.floor(12.524235, 2) === 12.52
+      float_assert Float.floor(-12.524235, 3) === -12.525
+
+      float_assert Float.floor(12.32453e-20, 2) === 0.0
+      float_assert Float.floor(-12.32453e-20, 2) === -0.01
+
+      assert_raise ArgumentError, "precision 16 is out of valid range of 0..15", fn ->
+        Float.floor(1.1, 16)
+      end
+    end
+
+    test "with subnormal floats" do
+      float_assert Float.floor(-5.0e-324, 0) === -1.0
+      float_assert Float.floor(-5.0e-324, 1) === -0.1
+      float_assert Float.floor(-5.0e-324, 2) === -0.01
+      float_assert Float.floor(-5.0e-324, 15) === -0.000000000000001
+
+      for precision <- 0..15 do
+        float_assert Float.floor(5.0e-324, precision) === 0.0
+      end
+    end
+  end
+
+  test "ceil/1" do
+    float_assert Float.ceil(12.524235) === 13.0
+    float_assert Float.ceil(-12.5) === -12.0
+    float_assert Float.ceil(-12.524235) === -12.0
+    float_assert Float.ceil(7.5e3) === 7500.0
+    float_assert Float.ceil(7.5432e3) === 7544.0
+    float_assert Float.ceil(7.5e-3) === 1.0
+    float_assert Float.ceil(-12.32453e4) === -123_245.0
+    float_assert Float.ceil(-12.32453e-10) === -0.0
+    float_assert Float.ceil(0.32453e-10) === 1.0
+    float_assert Float.ceil(-0.32453e-10) === -0.0
+    float_assert Float.ceil(1.32453e-10) === 1.0
+    float_assert Float.ceil(0.0) === 0.0
   end
 
-  test :floor do
-    assert Float.floor(12) === 12
-    assert Float.floor(-12) === -12
-    assert Float.floor(12.524235) === 12
-    assert Float.floor(-12.5) === -13
-    assert Float.floor(-12.524235) === -13
-    assert Float.floor(7.5e3) === 7500
-    assert Float.floor(7.5432e3) === 7543
-    assert Float.floor(7.5e-3) === 0
-    assert Float.floor(-12.32453e4) === -123246
-    assert Float.floor(-12.32453e-10) === -1
-    assert Float.floor(0.32453e-10) === 0
-    assert Float.floor(-0.32453e-10) === -1
-    assert Float.floor(1.32453e-10) === 0
+  describe "ceil/2" do
+    test "with 0.0" do
+      for precision <- 0..15 do
+        float_assert Float.ceil(0.0, precision) === 0.0
+        float_assert Float.ceil(-0.0, precision) === -0.0
+      end
+    end
+
+    test "with regular floats" do
+      float_assert Float.ceil(12.524235, 0) === 13.0
+      float_assert Float.ceil(-12.524235, 0) === -12.0
+
+      float_assert Float.ceil(12.52, 2) === 12.52
+      float_assert Float.ceil(-12.52, 2) === -12.51
+
+      float_assert Float.ceil(12.524235, 2) === 12.53
+      float_assert Float.ceil(-12.524235, 3) === -12.524
+
+      float_assert Float.ceil(12.32453e-20, 2) === 0.01
+      float_assert Float.ceil(-12.32453e-20, 2) === -0.0
+
+      float_assert Float.ceil(0.0, 2) === 0.0
+
+      assert_raise ArgumentError, "precision 16 is out of valid range of 0..15", fn ->
+        Float.ceil(1.1, 16)
+      end
+    end
+
+    test "with small floats rounded up to -0.0" do
+      float_assert Float.ceil(-0.1, 0) === -0.0
+      float_assert Float.ceil(-0.01, 1) === -0.0
+    end
+
+    test "with subnormal floats" do
+      float_assert Float.ceil(5.0e-324, 0) === 1.0
+      float_assert Float.ceil(5.0e-324, 1) === 0.1
+      float_assert Float.ceil(5.0e-324, 2) === 0.01
+      float_assert Float.ceil(5.0e-324, 15) === 0.000000000000001
+
+      for precision <- 0..15 do
+        float_assert Float.ceil(-5.0e-324, precision) === -0.0
+      end
+    end
   end
 
-  test :ceil do
-    assert Float.ceil(12) === 12
-    assert Float.ceil(-12) === -12
-    assert Float.ceil(12.524235) === 13
-    assert Float.ceil(-12.5) === -12
-    assert Float.ceil(-12.524235) === -12
-    assert Float.ceil(7.5e3) === 7500
-    assert Float.ceil(7.5432e3) === 7544
-    assert Float.ceil(7.5e-3) === 1
-    assert Float.ceil(-12.32453e4) === -123245
-    assert Float.ceil(-12.32453e-10) === 0
-    assert Float.ceil(0.32453e-10) === 1
-    assert Float.ceil(-0.32453e-10) === 0
-    assert Float.ceil(1.32453e-10) === 1
+  describe "round/2" do
+    test "with 0.0" do
+      for precision <- 0..15 do
+        float_assert Float.round(0.0, precision) === 0.0
+        float_assert Float.round(-0.0, precision) === -0.0
+      end
+    end
+
+    test "with regular floats" do
+      float_assert Float.round(5.5675, 3) === 5.567
+      float_assert Float.round(-5.5674, 3) === -5.567
+      float_assert Float.round(5.5, 3) === 5.5
+      float_assert Float.round(5.5e-10, 10) === 5.0e-10
+      float_assert Float.round(5.5e-10, 8) === 0.0
+      float_assert Float.round(5.0, 0) === 5.0
+
+      assert_raise ArgumentError, "precision 16 is out of valid range of 0..15", fn ->
+        Float.round(1.1, 16)
+      end
+    end
+
+    test "with small floats rounded to +0.0 / -0.0" do
+      float_assert Float.round(0.01, 0) === 0.0
+      float_assert Float.round(0.01, 1) === 0.0
+
+      float_assert Float.round(-0.01, 0) === -0.0
+      float_assert Float.round(-0.01, 1) === -0.0
+
+      float_assert Float.round(-0.49999, 0) === -0.0
+      float_assert Float.round(-0.049999, 1) === -0.0
+    end
+
+    test "with subnormal floats" do
+      for precision <- 0..15 do
+        float_assert Float.round(5.0e-324, precision) === 0.0
+        float_assert Float.round(-5.0e-324, precision) === -0.0
+      end
+    end
   end
 
-  test :round do
-    assert Float.round(5.5675, 3) === 5.568
-    assert Float.round(-5.5674, 3) === -5.567
-    assert Float.round(5.5, 3) === 5.5
-    assert Float.round(5.5e-10, 10) === 6.0e-10
-    assert Float.round(5.5e-10, 8) === 0.0
-    assert Float.round(5.0, 0) === 5.0
+  describe "ratio/1" do
+    test "with 0.0" do
+      assert Float.ratio(0.0) == {0, 1}
+    end
+
+    test "with regular floats" do
+      assert Float.ratio(3.14) == {7_070_651_414_971_679, 2_251_799_813_685_248}
+      assert Float.ratio(-3.14) == {-7_070_651_414_971_679, 2_251_799_813_685_248}
+      assert Float.ratio(1.5) == {3, 2}
+    end
+
+    test "with subnormal floats" do
+      assert Float.ratio(5.0e-324) ==
+               {1,
+                202_402_253_307_310_618_352_495_346_718_917_307_049_556_649_764_142_118_356_901_358_027_430_339_567_995_346_891_960_383_701_437_124_495_187_077_864_316_811_911_389_808_737_385_793_476_867_013_399_940_738_509_921_517_424_276_566_361_364_466_907_742_093_216_341_239_767_678_472_745_068_562_007_483_424_692_698_618_103_355_649_159_556_340_810_056_512_358_769_552_333_414_615_230_502_532_186_327_508_646_006_263_307_707_741_093_494_784}
+
+      assert Float.ratio(1.0e-323) ==
+               {1,
+                101_201_126_653_655_309_176_247_673_359_458_653_524_778_324_882_071_059_178_450_679_013_715_169_783_997_673_445_980_191_850_718_562_247_593_538_932_158_405_955_694_904_368_692_896_738_433_506_699_970_369_254_960_758_712_138_283_180_682_233_453_871_046_608_170_619_883_839_236_372_534_281_003_741_712_346_349_309_051_677_824_579_778_170_405_028_256_179_384_776_166_707_307_615_251_266_093_163_754_323_003_131_653_853_870_546_747_392}
+
+      assert Float.ratio(2.225073858507201e-308) ==
+               {4_503_599_627_370_495,
+                202_402_253_307_310_618_352_495_346_718_917_307_049_556_649_764_142_118_356_901_358_027_430_339_567_995_346_891_960_383_701_437_124_495_187_077_864_316_811_911_389_808_737_385_793_476_867_013_399_940_738_509_921_517_424_276_566_361_364_466_907_742_093_216_341_239_767_678_472_745_068_562_007_483_424_692_698_618_103_355_649_159_556_340_810_056_512_358_769_552_333_414_615_230_502_532_186_327_508_646_006_263_307_707_741_093_494_784}
+    end
   end
 end
diff --git a/lib/elixir/test/elixir/function_test.exs b/lib/elixir/test/elixir/function_test.exs
new file mode 100644
index 00000000000..f99a25f7155
--- /dev/null
+++ b/lib/elixir/test/elixir/function_test.exs
@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule DummyFunction do
+  def function_with_arity_0 do
+    true
+  end
+
+  def zero?(0), do: true
+  def zero?(_), do: false
+end
+
+defmodule FunctionTest do
+  use ExUnit.Case, async: true
+
+  doctest Function
+  import Function
+
+  @information_keys_for_named [:type, :module, :arity, :name, :env]
+  @information_keys_for_anonymous @information_keys_for_named ++
+                                    [:pid, :index, :new_index, :new_uniq, :uniq]
+
+  describe "capture/3" do
+    test "captures module functions with arity 0" do
+      f = capture(DummyFunction, :function_with_arity_0, 0)
+
+      assert is_function(f)
+    end
+
+    test "captures module functions with any arity" do
+      f = capture(DummyFunction, :zero?, 1)
+
+      assert is_function(f)
+      assert f.(0)
+    end
+  end
+
+  describe "info/1" do
+    test "returns info for named captured functions" do
+      f = &DummyFunction.zero?/1
+      expected = [module: DummyFunction, name: :zero?, arity: 1, env: [], type: :external]
+
+      result = info(f)
+
+      assert expected == result
+    end
+
+    test "returns info for anonymous functions" do
+      f = fn x -> x end
+
+      result = info(f)
+
+      for {key, _value} <- result do
+        assert key in @information_keys_for_anonymous
+      end
+    end
+  end
+
+  describe "info/2" do
+    test "returns info for every possible information key for named functions" do
+      f = &DummyFunction.zero?/1
+
+      for x <- @information_keys_for_named do
+        assert {^x, _} = info(f, x)
+      end
+    end
+
+    test "returns info for every possible information key for anonymous functions" do
+      f = &DummyFunction.zero?/1
+
+      for x <- @information_keys_for_anonymous do
+        assert {^x, _} = info(f, x)
+      end
+
+      assert {:arity, 1} = info(f, :arity)
+    end
+  end
+
+  describe "identity/1" do
+    test "returns whatever it gets passed" do
+      assert :hello = Function.identity(:hello)
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/gen_event_test.exs b/lib/elixir/test/elixir/gen_event_test.exs
deleted file mode 100644
index 005cb715b21..00000000000
--- a/lib/elixir/test/elixir/gen_event_test.exs
+++ /dev/null
@@ -1,392 +0,0 @@
-Code.require_file "test_helper.exs", __DIR__
-
-defmodule GenEventTest do
-  use ExUnit.Case, async: true
-
-  defmodule LoggerHandler do
-    use GenEvent
-
-    def handle_event({:log, x}, messages) do
-      {:ok, [x|messages]}
-    end
-
-    def handle_call(:messages, messages) do
-      {:ok, Enum.reverse(messages), []}
-    end
-
-    def handle_call(call, state) do
-      super(call, state)
-    end
-  end
-
-  defmodule SlowHandler do
-    use GenEvent
-
-    def handle_event(_event, _state) do
-      :timer.sleep(100)
-      :remove_handler
-    end
-  end
-
-  @receive_timeout 1000
-
-  test "start_link/2 and handler workflow" do
-    {:ok, pid} = GenEvent.start_link()
-
-    {:links, links} = Process.info(self, :links)
-    assert pid in links
-
-    assert GenEvent.notify(pid, {:log, 0}) == :ok
-    assert GenEvent.add_handler(pid, LoggerHandler, []) == :ok
-    assert GenEvent.notify(pid, {:log, 1}) == :ok
-    assert GenEvent.notify(pid, {:log, 2}) == :ok
-
-    assert GenEvent.call(pid, LoggerHandler, :messages) == [1, 2]
-    assert GenEvent.call(pid, LoggerHandler, :messages) == []
-
-    assert GenEvent.call(pid, LoggerHandler, :whatever)  == {:error, :bad_call}
-    assert GenEvent.call(pid, UnknownHandler, :messages) == {:error, :bad_module}
-
-    assert GenEvent.remove_handler(pid, LoggerHandler, []) == :ok
-    assert GenEvent.stop(pid) == :ok
-  end
-
-  test "start/2 with linked handler" do
-    {:ok, pid} = GenEvent.start()
-
-    {:links, links} = Process.info(self, :links)
-    refute pid in links
-
-    assert GenEvent.add_handler(pid, LoggerHandler, [], link: true) == :ok
-
-    {:links, links} = Process.info(self, :links)
-    assert pid in links
-
-    assert GenEvent.notify(pid, {:log, 1}) == :ok
-    assert GenEvent.sync_notify(pid, {:log, 2}) == :ok
-
-    assert GenEvent.call(pid, LoggerHandler, :messages) == [1, 2]
-    assert GenEvent.stop(pid) == :ok
-  end
-
-  test "start/2 with linked swap" do
-    {:ok, pid} = GenEvent.start()
-
-    assert GenEvent.add_handler(pid, LoggerHandler, []) == :ok
-
-    {:links, links} = Process.info(self, :links)
-    refute pid in links
-
-    assert GenEvent.swap_handler(pid, LoggerHandler, [], LoggerHandler, [], link: true) == :ok
-
-    {:links, links} = Process.info(self, :links)
-    assert pid in links
-
-    assert GenEvent.stop(pid) == :ok
-  end
-
-  test "start/2 with registered name" do
-    {:ok, _} = GenEvent.start(name: :logger)
-    assert GenEvent.stop(:logger) == :ok
-  end
-
-  test "sync stream/2" do
-    {:ok, pid} = GenEvent.start_link()
-    parent = self()
-
-    spawn_link fn ->
-      send parent, Enum.take(GenEvent.stream(pid, mode: :sync), 3)
-    end
-
-    wait_for_handlers(pid, 1)
-
-    for i <- 1..3 do
-      GenEvent.sync_notify(pid, i)
-    end
-
-    # Receive one of the results
-    assert_receive [1, 2, 3], @receive_timeout
-    wait_for_handlers(pid, 0)
-
-    spawn_link fn ->
-      Enum.each(GenEvent.stream(pid, mode: :sync), fn _ ->
-        :timer.sleep(:infinity)
-      end)
-    end
-
-    wait_for_handlers(pid, 1)
-
-    for i <- 1..6 do
-      GenEvent.notify(pid, i)
-    end
-
-    wait_for_queue_length(pid, 5)
-  end
-
-  test "async stream/2" do
-    {:ok, pid} = GenEvent.start_link()
-    parent = self()
-
-    spawn_link fn ->
-      Enum.each(GenEvent.stream(pid, mode: :async), fn _ ->
-        :timer.sleep(:infinity)
-      end)
-    end
-
-    spawn_link fn ->
-      send parent, Enum.take(GenEvent.stream(pid, mode: :async), 3)
-    end
-
-    wait_for_handlers(pid, 2)
-
-    for i <- 1..3 do
-      GenEvent.sync_notify(pid, i)
-    end
-
-    # Receive one of the results
-    assert_receive  [1, 2, 3], @receive_timeout
-
-    # One of the subscriptions are gone
-    wait_for_handlers(pid, 1)
-  end
-
-  Enum.each [:sync, :async], fn mode ->
-    test "#{mode} stream/2 with parallel use (and first finishing first)" do
-      {:ok, pid} = GenEvent.start_link()
-      stream = GenEvent.stream(pid, duration: 200, mode: unquote(mode))
-
-      parent = self()
-      spawn_link fn -> send parent, {:take, Enum.take(stream, 3)} end
-      wait_for_handlers(pid, 1)
-      spawn_link fn -> send parent, {:to_list, Enum.to_list(stream)} end
-      wait_for_handlers(pid, 2)
-
-      # Notify the events for both handlers
-      for i <- 1..3 do
-        GenEvent.sync_notify(pid, i)
-      end
-      assert_receive {:take, [1, 2, 3]}, @receive_timeout
-
-      # Notify the events for to_list stream handler
-      for i <- 4..5 do
-        GenEvent.sync_notify(pid, i)
-      end
-
-      assert_receive {:to_list, [1, 2, 3, 4, 5]}, @receive_timeout
-    end
-
-    test "#{mode} stream/2 with timeout" do
-      # Start a manager
-      {:ok, pid} = GenEvent.start_link()
-      Process.flag(:trap_exit, true)
-
-      pid = spawn_link fn ->
-        Enum.take(GenEvent.stream(pid, timeout: 50, mode: unquote(mode)), 5)
-      end
-
-      assert_receive {:EXIT, ^pid,
-                       {:timeout, {Enumerable.GenEvent, :next, [_, _]}}}, @receive_timeout
-    end
-
-    test "#{mode} stream/2 with error/timeout on subscription" do
-      # Start a manager
-      {:ok, pid} = GenEvent.start_link()
-
-      # Start a subscriber with timeout
-      child = spawn fn -> Enum.to_list(GenEvent.stream(pid, mode: unquote(mode))) end
-      wait_for_handlers(pid, 1)
-
-      # Kill and wait until we have 0 handlers
-      Process.exit(child, :kill)
-      wait_for_handlers(pid, 0)
-      GenEvent.stop(pid)
-    end
-
-    test "#{mode} stream/2 with manager stop" do
-      # Start a manager and subscribers
-      {:ok, pid} = GenEvent.start_link()
-
-      parent = self()
-      stream_pid = spawn_link fn ->
-        send parent, Enum.take(GenEvent.stream(pid, mode: unquote(mode)), 5)
-      end
-      wait_for_handlers(pid, 1)
-
-      # Notify the events
-      for i <- 1..3 do
-        GenEvent.sync_notify(pid, i)
-      end
-
-      Process.flag(:trap_exit, true)
-      GenEvent.stop(pid)
-      assert_receive {:EXIT, ^stream_pid,
-                       {:shutdown, {Enumerable.GenEvent, :next, [_, _]}}}, @receive_timeout
-    end
-
-    test "#{mode} stream/2 with cancel streams" do
-      # Start a manager and subscribers
-      {:ok, pid} = GenEvent.start_link()
-      stream = GenEvent.stream(pid, id: make_ref(), mode: unquote(mode))
-
-      parent = self()
-      spawn_link fn -> send parent, Enum.take(stream, 5) end
-      wait_for_handlers(pid, 1)
-
-      # Notify the events
-      for i <- 1..3 do
-        GenEvent.sync_notify(pid, i)
-      end
-
-      GenEvent.cancel_streams(stream)
-      assert_receive [1, 2, 3], @receive_timeout
-      GenEvent.stop(pid)
-    end
-
-    test "#{mode} stream/2 with swap_handler" do
-      # Start a manager and subscribers
-      {:ok, pid} = GenEvent.start_link()
-      stream = GenEvent.stream(pid, id: make_ref(), mode: unquote(mode))
-
-      parent = self()
-      stream_pid = spawn_link fn -> send parent, Enum.take(stream, 5) end
-      wait_for_handlers(pid, 1)
-
-      # Notify the events
-      for i <- 1..3 do
-        GenEvent.sync_notify(pid, i)
-      end
-
-      [handler] = GenEvent.which_handlers(pid)
-      Process.flag(:trap_exit, true)
-      GenEvent.swap_handler(pid, handler, :swap_handler, LogHandler, [])
-      assert_receive {:EXIT, ^stream_pid,
-                       {{:swapped, LogHandler, _},
-                        {Enumerable.GenEvent, :next, [_, _]}}}, @receive_timeout
-    end
-
-    test "#{mode} stream/2 with duration" do
-      # Start a manager and subscribers
-      {:ok, pid} = GenEvent.start_link()
-      stream = GenEvent.stream(pid, duration: 200, mode: unquote(mode))
-
-      parent = self()
-      spawn_link fn -> send parent, {:duration, Enum.take(stream, 10)} end
-      wait_for_handlers(pid, 1)
-
-      # Notify the events
-      for i <- 1..5 do
-        GenEvent.sync_notify(pid, i)
-      end
-
-      # Wait until the handler is gone
-      wait_for_handlers(pid, 0)
-
-      # The stream is not complete but terminated anyway due to duration
-      assert_receive {:duration, [1, 2, 3, 4, 5]}, @receive_timeout
-
-      GenEvent.stop(pid)
-    end
-
-    test "#{mode} stream/2 with manager killed and trap_exit" do
-      # Start a manager and subscribers
-      {:ok, pid} = GenEvent.start_link()
-      stream = GenEvent.stream(pid, mode: unquote(mode))
-
-      parent = self()
-      stream_pid = spawn_link fn ->
-        send parent, Enum.to_list(stream)
-      end
-      wait_for_handlers(pid, 1)
-
-      Process.flag(:trap_exit, true)
-      Process.exit(pid, :kill)
-      assert_receive {:EXIT, ^pid, :killed}, @receive_timeout
-      assert_receive {:EXIT, ^stream_pid,
-                       {:killed, {Enumerable.GenEvent, :next, [_,_]}}}, @receive_timeout
-    end
-
-    test "#{mode} stream/2 with manager not alive" do
-      # Start a manager and subscribers
-      stream = GenEvent.stream(:does_not_exit, mode: unquote(mode))
-
-      parent = self()
-      stream_pid = spawn_link fn ->
-        send parent, Enum.to_list(stream)
-      end
-
-      Process.flag(:trap_exit, true)
-      assert_receive {:EXIT, ^stream_pid,
-                       {:noproc, {Enumerable.GenEvent, :start, [_]}}}, @receive_timeout
-    end
-
-    test "#{mode} stream/2 with manager unregistered" do
-      # Start a manager and subscribers
-      {:ok, pid} = GenEvent.start_link(name: :unreg)
-      stream = GenEvent.stream(:unreg, mode: unquote(mode))
-
-      parent = self()
-      spawn_link fn ->
-        send parent, Enum.take(stream, 5)
-      end
-      wait_for_handlers(pid, 1)
-
-      # Notify the events
-      for i <- 1..3 do
-        GenEvent.sync_notify(pid, i)
-      end
-
-      # Unregister the process
-      Process.unregister(:unreg)
-
-      # Notify the remaining events
-      for i <- 4..5 do
-        GenEvent.sync_notify(pid, i)
-      end
-
-      # We should have gotten the message and all handlers were removed
-      assert_receive [1, 2, 3, 4, 5], @receive_timeout
-      wait_for_handlers(pid, 0)
-    end
-
-    test "#{mode} stream/2 flushes events on abort" do
-      # Start a manager and subscribers
-      {:ok, pid} = GenEvent.start_link()
-
-      spawn_link fn ->
-        wait_for_handlers(pid, 2)
-        GenEvent.notify(pid, 1)
-        GenEvent.notify(pid, 2)
-        GenEvent.notify(pid, 3)
-      end
-
-      GenEvent.add_handler(pid, SlowHandler, [])
-      stream = GenEvent.stream(pid, mode: unquote(mode))
-
-      try do
-        Enum.each stream, fn _ -> throw :done end
-      catch
-        :done -> :ok
-      end
-
-      # Wait for the slow handler to be removed
-      # so all events have been handled
-      wait_for_handlers(pid, 0)
-
-      # Check no messages leaked.
-      refute_received _any
-    end
-  end
-
-  defp wait_for_handlers(pid, count) do
-    unless length(GenEvent.which_handlers(pid)) == count do
-      wait_for_handlers(pid, count)
-    end
-  end
-
-  defp wait_for_queue_length(pid, count) do
-    {:message_queue_len, n} = Process.info(pid, :message_queue_len)
-    unless n == count do
-      wait_for_queue_length(pid, count)
-    end
-  end
-end
diff --git a/lib/elixir/test/elixir/gen_server_test.exs b/lib/elixir/test/elixir/gen_server_test.exs
index 880d7d0f864..31ef3dbf802 100644
--- a/lib/elixir/test/elixir/gen_server_test.exs
+++ b/lib/elixir/test/elixir/gen_server_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule GenServerTest do
   use ExUnit.Case, async: true
@@ -6,49 +10,143 @@ defmodule GenServerTest do
   defmodule Stack do
     use GenServer
 
-    def handle_call(:stop, from, state) do
-      GenServer.reply(from, :ok)
-      {:stop, :normal, state}
+    def init(args) do
+      {:ok, args}
     end
 
-    def handle_call(:pop, _from, [h|t]) do
+    def handle_call(:pop, _from, [h | t]) do
       {:reply, h, t}
     end
 
-    def handle_call(request, from, state) do
-      super(request, from, state)
+    def handle_call(:noreply, _from, h) do
+      {:noreply, h}
     end
 
-    def handle_cast({:push, item}, state) do
-      {:noreply, [item|state]}
+    def handle_call(:stop_self, _from, state) do
+      reason = catch_exit(GenServer.stop(self()))
+      {:reply, reason, state}
     end
 
-    def handle_cast(request, state) do
-      super(request, state)
+    def handle_cast({:push, element}, state) do
+      {:noreply, [element | state]}
     end
 
     def terminate(_reason, _state) do
       # There is a race condition if the agent is
       # restarted too fast and it is registered.
       try do
-        self |> Process.info(:registered_name) |> elem(1) |> Process.unregister
+        self() |> Process.info(:registered_name) |> elem(1) |> Process.unregister()
       rescue
         _ -> :ok
       end
+
       :ok
     end
   end
 
+  test "generates child_spec/1" do
+    assert Stack.child_spec([:hello]) == %{
+             id: Stack,
+             start: {Stack, :start_link, [[:hello]]}
+           }
+
+    defmodule CustomStack do
+      use GenServer, id: :id, restart: :temporary, shutdown: :infinity, start: {:foo, :bar, []}
+
+      def init(args) do
+        {:ok, args}
+      end
+    end
+
+    assert CustomStack.child_spec([:hello]) == %{
+             id: :id,
+             restart: :temporary,
+             shutdown: :infinity,
+             start: {:foo, :bar, []}
+           }
+  end
+
+  test "start_link/3" do
+    assert_raise ArgumentError, ~r"expected :name option to be one of the following:", fn ->
+      GenServer.start_link(Stack, [:hello], name: "my_gen_server_name")
+    end
+
+    assert_raise ArgumentError, ~r"expected :name option to be one of the following:", fn ->
+      GenServer.start_link(Stack, [:hello], name: {:invalid_tuple, "my_gen_server_name"})
+    end
+
+    assert_raise ArgumentError, ~r"expected :name option to be one of the following:", fn ->
+      GenServer.start_link(Stack, [:hello], name: {:via, "Via", "my_gen_server_name"})
+    end
+
+    assert_raise ArgumentError, ~r/Got: "my_gen_server_name"/, fn ->
+      GenServer.start_link(Stack, [:hello], name: "my_gen_server_name")
+    end
+  end
+
+  test "start_link/3 with via" do
+    GenServer.start_link(Stack, [:hello], name: {:via, :global, :via_stack})
+    assert GenServer.call({:via, :global, :via_stack}, :pop) == :hello
+  end
+
+  test "start_link/3 with global" do
+    GenServer.start_link(Stack, [:hello], name: {:global, :global_stack})
+    assert GenServer.call({:global, :global_stack}, :pop) == :hello
+  end
+
+  test "start_link/3 with local" do
+    GenServer.start_link(Stack, [:hello], name: :stack)
+    assert GenServer.call(:stack, :pop) == :hello
+  end
+
   test "start_link/2, call/2 and cast/2" do
     {:ok, pid} = GenServer.start_link(Stack, [:hello])
 
-    {:links, links} = Process.info(self, :links)
+    {:links, links} = Process.info(self(), :links)
     assert pid in links
 
     assert GenServer.call(pid, :pop) == :hello
     assert GenServer.cast(pid, {:push, :world}) == :ok
     assert GenServer.call(pid, :pop) == :world
-    assert GenServer.call(pid, :stop) == :ok
+    assert GenServer.stop(pid) == :ok
+
+    assert GenServer.cast({:global, :foo}, {:push, :world}) == :ok
+    assert GenServer.cast({:via, :foo, :bar}, {:push, :world}) == :ok
+    assert GenServer.cast(:foo, {:push, :world}) == :ok
+  end
+
+  @tag capture_log: true
+  test "call/3 exit messages" do
+    name = :self
+    Process.register(self(), name)
+    :global.register_name(name, self())
+    {:ok, pid} = GenServer.start_link(Stack, [:hello])
+    {:ok, stopped_pid} = GenServer.start(Stack, [:hello])
+    GenServer.stop(stopped_pid)
+
+    assert catch_exit(GenServer.call(name, :pop, 5000)) ==
+             {:calling_self, {GenServer, :call, [name, :pop, 5000]}}
+
+    assert catch_exit(GenServer.call({:global, name}, :pop, 5000)) ==
+             {:calling_self, {GenServer, :call, [{:global, name}, :pop, 5000]}}
+
+    assert catch_exit(GenServer.call({:via, :global, name}, :pop, 5000)) ==
+             {:calling_self, {GenServer, :call, [{:via, :global, name}, :pop, 5000]}}
+
+    assert catch_exit(GenServer.call(self(), :pop, 5000)) ==
+             {:calling_self, {GenServer, :call, [self(), :pop, 5000]}}
+
+    assert catch_exit(GenServer.call(pid, :noreply, 1)) ==
+             {:timeout, {GenServer, :call, [pid, :noreply, 1]}}
+
+    assert catch_exit(GenServer.call(nil, :pop, 5000)) ==
+             {:noproc, {GenServer, :call, [nil, :pop, 5000]}}
+
+    assert catch_exit(GenServer.call(stopped_pid, :pop, 5000)) ==
+             {:noproc, {GenServer, :call, [stopped_pid, :pop, 5000]}}
+
+    assert catch_exit(GenServer.call({:stack, :bogus_node}, :pop, 5000)) ==
+             {{:nodedown, :bogus_node}, {GenServer, :call, [{:stack, :bogus_node}, :pop, 5000]}}
   end
 
   test "nil name" do
@@ -58,31 +156,64 @@ defmodule GenServerTest do
 
   test "start/2" do
     {:ok, pid} = GenServer.start(Stack, [:hello])
-    {:links, links} = Process.info(self, :links)
+    {:links, links} = Process.info(self(), :links)
     refute pid in links
-    GenServer.call(pid, :stop)
+    GenServer.stop(pid)
   end
 
-  test "abcast/3" do
-    {:ok, _} = GenServer.start_link(Stack, [], name: :stack)
+  test "abcast/3", %{test: name} do
+    {:ok, _} = GenServer.start_link(Stack, [], name: name)
 
-    assert GenServer.abcast(:stack, {:push, :hello}) == :abcast
-    assert GenServer.call({:stack, node()}, :pop) == :hello
+    assert GenServer.abcast(name, {:push, :hello}) == :abcast
+    assert GenServer.call({name, node()}, :pop) == :hello
 
-    assert GenServer.abcast([node, :foo@bar], :stack, {:push, :world}) == :abcast
-    assert GenServer.call(:stack, :pop) == :world
+    assert GenServer.abcast([node(), :foo@bar], name, {:push, :world}) == :abcast
+    assert GenServer.call(name, :pop) == :world
+  end
+
+  test "multi_call/4", %{test: name} do
+    {:ok, _} = GenServer.start_link(Stack, [:hello, :world], name: name)
+    node = node()
 
-    GenServer.call(:stack, :stop)
+    assert {[{^node, :hello}], _} = GenServer.multi_call(name, :pop)
+    assert {[{^node, :world}], [:foo@bar]} = GenServer.multi_call([node(), :foo@bar], name, :pop)
   end
 
-  test "multi_call/4" do
-    {:ok, _} = GenServer.start_link(Stack, [:hello, :world], name: :stack)
+  test "whereis/1" do
+    name = :whereis_server
+
+    {:ok, pid} = GenServer.start_link(Stack, [], name: name)
+    assert GenServer.whereis(name) == pid
+    assert GenServer.whereis({name, node()}) == pid
+    assert GenServer.whereis({name, :another_node}) == {name, :another_node}
+    assert GenServer.whereis(pid) == pid
+    assert GenServer.whereis(:whereis_bad_server) == nil
+
+    {:ok, pid} = GenServer.start_link(Stack, [], name: {:global, name})
+    assert GenServer.whereis({:global, name}) == pid
+    assert GenServer.whereis({:global, :whereis_bad_server}) == nil
+    assert GenServer.whereis({:via, :global, name}) == pid
+    assert GenServer.whereis({:via, :global, :whereis_bad_server}) == nil
+  end
+
+  test "stop/3", %{test: name} do
+    {:ok, pid} = GenServer.start(Stack, [])
+    assert GenServer.stop(pid, :normal) == :ok
+
+    stopped_pid = pid
+
+    assert catch_exit(GenServer.stop(stopped_pid)) ==
+             {:noproc, {GenServer, :stop, [stopped_pid, :normal, :infinity]}}
+
+    assert catch_exit(GenServer.stop(nil)) ==
+             {:noproc, {GenServer, :stop, [nil, :normal, :infinity]}}
+
+    {:ok, pid} = GenServer.start(Stack, [])
 
-    assert GenServer.multi_call(:stack, :pop) ==
-           {[{node(), :hello}], []}
-    assert GenServer.multi_call([node, :foo@bar], :stack, :pop) ==
-           {[{node, :world}], [:foo@bar]}
+    assert GenServer.call(pid, :stop_self) ==
+             {:calling_self, {GenServer, :stop, [pid, :normal, :infinity]}}
 
-    GenServer.call(:stack, :stop)
+    {:ok, _} = GenServer.start(Stack, [], name: name)
+    assert GenServer.stop(name, :normal) == :ok
   end
 end
diff --git a/lib/elixir/test/elixir/hash_dict_test.exs b/lib/elixir/test/elixir/hash_dict_test.exs
deleted file mode 100644
index 3a64f3e818b..00000000000
--- a/lib/elixir/test/elixir/hash_dict_test.exs
+++ /dev/null
@@ -1,91 +0,0 @@
-Code.require_file "test_helper.exs", __DIR__
-
-defmodule HashDictTest do
-  use ExUnit.Case, async: true
-
-  @dict Enum.into([foo: :bar], HashDict.new)
-
-  test "access" do
-    dict = Enum.into([foo: :baz], HashDict.new)
-    assert Access.get(@dict, :foo) == :bar
-    assert Access.get_and_update(@dict, :foo, fn :bar -> {:ok, :baz} end) == {:ok, dict}
-    assert Access.get_and_update(HashDict.new, :foo, fn nil -> {:ok, :baz} end) == {:ok, dict}
-  end
-
-  test "is serializable as attribute" do
-    assert @dict == Enum.into([foo: :bar], HashDict.new)
-  end
-
-  test "is accessible as attribute" do
-    assert @dict[:foo] == :bar
-  end
-
-  test "small dict smoke test" do
-    smoke_test(1..8)
-    smoke_test(8..1)
-  end
-
-  test "medium dict smoke test" do
-    smoke_test(1..80)
-    smoke_test(80..1)
-  end
-
-  test "large dict smoke test" do
-    smoke_test(1..1200)
-    smoke_test(1200..1)
-  end
-
-  test "reduce/3 (via to_list)" do
-    dict = filled_dict(8)
-    list = dict |> HashDict.to_list
-    assert length(list) == 8
-    assert {1, 1} in list
-    assert list == Enum.to_list(dict)
-
-    dict = filled_dict(20)
-    list = dict |> HashDict.to_list
-    assert length(list) == 20
-    assert {1, 1} in list
-    assert list == Enum.to_list(dict)
-
-    dict = filled_dict(120)
-    list = dict |> HashDict.to_list
-    assert length(list) == 120
-    assert {1, 1} in list
-    assert list == Enum.to_list(dict)
-  end
-
-  test "comparison when subsets" do
-    d1 = Enum.into [a: 0], HashDict.new
-    d2 = Enum.into [a: 0, b: 1], HashDict.new
-
-    refute HashDict.equal?(d1, d2)
-    refute HashDict.equal?(d2, d1)
-  end
-
-  defp smoke_test(range) do
-    {dict, _} = Enum.reduce range, {HashDict.new, 1}, fn(x, {acc, i}) ->
-      acc = HashDict.put(acc, x, x)
-      assert HashDict.size(acc) == i
-      {acc, i + 1}
-    end
-
-    Enum.each range, fn(x) ->
-      assert HashDict.get(dict, x) == x
-    end
-
-    {dict, _} = Enum.reduce range, {dict, Enum.count(range)}, fn(x, {acc, i}) ->
-      assert HashDict.size(acc) == i
-      acc = HashDict.delete(acc, x)
-      assert HashDict.size(acc) == i - 1
-      assert HashDict.get(acc, x) == nil
-      {acc, i - 1}
-    end
-
-    assert dict == HashDict.new
-  end
-
-  defp filled_dict(range) do
-    Enum.reduce 1..range, HashDict.new, &HashDict.put(&2, &1, &1)
-  end
-end
diff --git a/lib/elixir/test/elixir/hash_set_test.exs b/lib/elixir/test/elixir/hash_set_test.exs
deleted file mode 100644
index cb231a1a2a6..00000000000
--- a/lib/elixir/test/elixir/hash_set_test.exs
+++ /dev/null
@@ -1,55 +0,0 @@
-Code.require_file "test_helper.exs", __DIR__
-
-defmodule HashSetTest do
-  use ExUnit.Case, async: true
-
-  test "union" do
-    assert HashSet.union(filled_set(21), filled_set(22)) == filled_set(22)
-    assert HashSet.union(filled_set(121), filled_set(120)) == filled_set(121)
-  end
-
-  test "intersection" do
-    assert HashSet.intersection(filled_set(21), filled_set(20)) == filled_set(20)
-    assert HashSet.equal?(HashSet.intersection(filled_set(120), filled_set(121)), filled_set(120))
-  end
-
-  test "difference" do
-    assert HashSet.equal?(HashSet.difference(filled_set(20), filled_set(21)), HashSet.new)
-
-    diff = HashSet.difference(filled_set(9000), filled_set(9000))
-    assert HashSet.equal?(diff, HashSet.new)
-    assert HashSet.size(diff) == 0
-  end
-
-  test "subset?" do
-    assert HashSet.subset?(HashSet.new, HashSet.new)
-    assert HashSet.subset?(filled_set(6), filled_set(10))
-    assert HashSet.subset?(filled_set(6), filled_set(120))
-    refute HashSet.subset?(filled_set(120), filled_set(6))
-  end
-
-  test "equal?" do
-    assert HashSet.equal?(HashSet.new, HashSet.new)
-    assert HashSet.equal?(filled_set(20), HashSet.delete(filled_set(21), 21))
-    assert HashSet.equal?(filled_set(120), filled_set(120))
-  end
-
-  test "to_list" do
-    set = filled_set(20)
-    list = HashSet.to_list(set)
-    assert length(list) == 20
-    assert 1 in list
-    assert Enum.sort(list) == Enum.sort(1..20)
-
-    set = filled_set(120)
-    list = HashSet.to_list(set)
-    assert length(list) == 120
-    assert 1 in list
-    assert Enum.sort(list) == Enum.sort(1..120)
-  end
-
-  defp filled_set(range) do
-    Enum.into 1..range, HashSet.new
-  end
-end
-
diff --git a/lib/elixir/test/elixir/inspect/algebra_test.exs b/lib/elixir/test/elixir/inspect/algebra_test.exs
index 3b4b46a5263..f9ca94b3dc8 100644
--- a/lib/elixir/test/elixir/inspect/algebra_test.exs
+++ b/lib/elixir/test/elixir/inspect/algebra_test.exs
@@ -1,125 +1,326 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Inspect.OptsTest do
+  use ExUnit.Case
+
+  test "new" do
+    opts = Inspect.Opts.new(limit: 13, pretty: true)
+    assert opts.limit == 13
+    assert opts.pretty
+  end
+
+  test "default_inspect_fun" do
+    assert Inspect.Opts.default_inspect_fun() == (&Inspect.inspect/2)
+
+    assert Inspect.Opts.default_inspect_fun(fn
+             :rewrite_atom, _ -> "rewritten_atom"
+             value, opts -> Inspect.inspect(value, opts)
+           end) == :ok
+
+    assert inspect(:rewrite_atom) == "rewritten_atom"
+  after
+    Inspect.Opts.default_inspect_fun(&Inspect.inspect/2)
+  end
+end
 
 defmodule Inspect.AlgebraTest do
   use ExUnit.Case, async: true
 
+  doctest Inspect.Algebra
+
   import Inspect.Algebra
 
-  def helloabcd do
-    concat(
-      glue(
-        glue(
-          glue("hello", "a"),
-          "b"),
-        "c"),
-      "d")
+  defp render(doc, limit) do
+    doc |> group() |> format(limit) |> IO.iodata_to_binary()
   end
 
-  def factor(doc, w), do: format(w, 0, [{0, :flat, group(doc)}])
-
   test "empty doc" do
-    # Consistence with definitions
-    assert empty == :doc_nil
-
-    # Consistence of corresponding sdoc
-    assert factor(empty, 80) == []
+    # Consistent with definitions
+    assert empty() == []
 
     # Consistent formatting
-    assert pretty(empty, 80) == ""
+    assert render(empty(), 80) == ""
   end
 
-  test "break doc" do
-    # Consistence with definitions
-    assert break("break") == {:doc_break, "break"}
-    assert break("") == {:doc_break, ""}
+  test "strict break doc" do
+    # Consistent with definitions
+    assert break("break") == {:doc_break, "break", :strict}
+    assert break("") == {:doc_break, "", :strict}
 
     # Wrong argument type
     assert_raise FunctionClauseError, fn -> break(42) end
 
-    # Consistence of corresponding sdoc
-    assert factor(break("_"), 80) == ["_"]
+    # Consistent formatting
+    assert render(break("_"), 80) == "_"
+    assert render(glue("foo", " ", glue("bar", " ", "baz")), 10) == "foo\nbar\nbaz"
+  end
+
+  test "flex break doc" do
+    # Consistent with definitions
+    assert flex_break("break") == {:doc_break, "break", :flex}
+    assert flex_break("") == {:doc_break, "", :flex}
+
+    # Wrong argument type
+    assert_raise FunctionClauseError, fn -> flex_break(42) end
 
     # Consistent formatting
-    assert pretty(break("_"), 80) == "_"
+    assert render(flex_break("_"), 80) == "_"
+    assert render(flex_glue("foo", " ", flex_glue("bar", " ", "baz")), 10) == "foo bar\nbaz"
   end
 
   test "glue doc" do
-    # Consistence with definitions
-    assert glue("a", "->", "b") == {:doc_cons,
-      "a", {:doc_cons, {:doc_break, "->"}, "b"}
-   }
+    # Consistent with definitions
+    assert glue("a", "->", "b") == ["a", {:doc_break, "->", :strict} | "b"]
     assert glue("a", "b") == glue("a", " ", "b")
 
     # Wrong argument type
     assert_raise FunctionClauseError, fn -> glue("a", 42, "b") end
   end
 
-  test "text doc" do
-    # Consistence of corresponding sdoc
-    assert factor("_", 80) == ["_"]
+  test "flex glue doc" do
+    # Consistent with definitions
+    assert flex_glue("a", "->", "b") ==
+             ["a", {:doc_break, "->", :flex} | "b"]
 
-    # Consistent formatting
-    assert pretty("_", 80) == "_"
+    assert flex_glue("a", "b") == flex_glue("a", " ", "b")
+
+    # Wrong argument type
+    assert_raise FunctionClauseError, fn -> flex_glue("a", 42, "b") end
+  end
+
+  test "binary doc" do
+    assert render("_", 80) == "_"
+  end
+
+  test "string doc" do
+    # Consistent with definitions
+    assert string("ólá") == {:doc_string, "ólá", 3}
+
+    # Counts graphemes
+    doc = glue(string("olá"), " ", string("mundo"))
+    assert render(doc, 9) == "olá mundo"
   end
 
   test "space doc" do
-    # Consistency with definitions
-    assert space("a", "b") == {:doc_cons,
-      "a", {:doc_cons, " ", "b"}
-   }
+    # Consistent with definitions
+    assert space("a", "b") == ["a", " " | "b"]
+  end
+
+  test "always nest doc" do
+    # Consistent with definitions
+    assert nest(empty(), 1) == {:doc_nest, empty(), 1, :always}
+    assert nest(empty(), 0) == []
+
+    # Wrong argument type
+    assert_raise FunctionClauseError, fn -> nest("foo", empty()) end
+
+    # Consistent formatting
+    assert render(nest("a", 1), 80) == "a"
+    assert render(nest(glue("a", "b"), 1), 2) == "a\n b"
+    assert render(nest(line("a", "b"), 1), 20) == "a\n b"
   end
 
-  test "nest doc" do
-    # Consistence with definitions
-    assert nest(empty, 1) == {:doc_nest, empty, 1}
-    assert nest(empty, 0) == :doc_nil
+  test "break nest doc" do
+    # Consistent with definitions
+    assert nest(empty(), 1, :break) == {:doc_nest, empty(), 1, :break}
+    assert nest(empty(), 0, :break) == []
 
     # Wrong argument type
-    assert_raise FunctionClauseError, fn -> nest("foo", empty) end
+    assert_raise FunctionClauseError, fn -> nest("foo", empty(), :break) end
 
-    # Consistence of corresponding sdoc
-    assert factor(nest("a", 1), 80)  == ["a"]
-    assert format(2, 0, [{0, :break, nest(glue("a", "b"), 1)}]) == ["a", "\n ", "b"]
+    # Consistent formatting
+    assert render(nest("a", 1, :break), 80) == "a"
+    assert render(nest(glue("a", "b"), 1, :break), 2) == "a\n b"
+    assert render(nest(line("a", "b"), 1, :break), 20) == "a\nb"
+  end
+
+  test "cursor nest doc" do
+    # Consistent with definitions
+    assert nest(empty(), :cursor) == {:doc_nest, empty(), :cursor, :always}
 
     # Consistent formatting
-    assert pretty(nest("a", 1), 80) == "a"
-    assert render(format 2, 0, [{0, :break, nest(glue("a", "b"), 1)}]) == "a\n b"
+    assert render(nest("a", :cursor), 80) == "a"
+    assert render(concat("prefix ", nest(glue("a", "b"), :cursor)), 2) == "prefix a\n       b"
+    assert render(concat("prefix ", nest(line("a", "b"), :cursor)), 2) == "prefix a\n       b"
   end
 
-  test "line doc" do
-    # Consistency with definitions
-    assert line("a", "b") ==
-      {:doc_cons, "a", {:doc_cons, :doc_line, "b"}}
+  test "reset nest doc" do
+    # Consistent with definitions
+    assert nest(empty(), :reset) == {:doc_nest, empty(), :reset, :always}
+
+    # Consistent formatting
+    assert render(nest("a", :reset), 80) == "a"
+    assert render(nest(nest(glue("a", "b"), :reset), 10), 2) == "a\nb"
+    assert render(nest(nest(line("a", "b"), :reset), 10), 2) == "a\nb"
+  end
+
+  test "color doc" do
+    # Consistent with definitions
+    opts = %Inspect.Opts{}
+    assert color_doc(empty(), :atom, opts) == empty()
+
+    opts = %Inspect.Opts{syntax_colors: [regex: :red]}
+    assert color_doc(empty(), :atom, opts) == empty()
 
-    # Consistence of corresponding sdoc
-    assert factor(line("a", "b"), 1) == ["a", "\n", "b"]
-    assert factor(line("a", "b"), 9) == ["a", "\n", "b"]
+    opts = %Inspect.Opts{syntax_colors: [atom: :red]}
+    doc1 = {:doc_color, "Hi", IO.ANSI.red()}
+    doc2 = {:doc_color, empty(), IO.ANSI.reset()}
+    assert color_doc("Hi", :atom, opts) == concat(doc1, doc2)
+
+    opts = %Inspect.Opts{syntax_colors: [reset: :red]}
+    assert color_doc(empty(), :atom, opts) == empty()
+
+    opts = %Inspect.Opts{syntax_colors: [number: :cyan, reset: :red]}
+    doc1 = {:doc_color, "123", IO.ANSI.cyan()}
+    doc2 = {:doc_color, empty(), IO.ANSI.red()}
+    assert color_doc("123", :number, opts) == concat(doc1, doc2)
+
+    # Consistent formatting
+    opts = %Inspect.Opts{syntax_colors: [atom: :cyan]}
+    assert render(glue(color_doc("AA", :atom, opts), "BB"), 5) == "\e[36mAA\e[0m BB"
+    assert render(glue(color_doc("AA", :atom, opts), "BB"), 3) == "\e[36mAA\e[0m\nBB"
+    assert render(glue("AA", color_doc("BB", :atom, opts)), 6) == "AA \e[36mBB\e[0m"
+  end
+
+  test "line doc" do
+    # Consistent with definitions
+    assert line("a", "b") == ["a", :doc_line | "b"]
 
     # Consistent formatting
-    assert pretty(line(glue("aaa", "bbb"), glue("ccc", "ddd")), 10) ==
-           "aaa bbb\nccc ddd"
+    assert render(line(glue("aaa", "bbb"), glue("ccc", "ddd")), 10) == "aaa bbb\nccc ddd"
   end
 
   test "group doc" do
-    # Consistency with definitions
-    assert group(glue("a", "b")) ==
-      {:doc_group, {:doc_cons, "a", concat(break, "b")}}
-    assert group(empty) == {:doc_group, empty}
+    # Consistent with definitions
+    assert group("ab") == {:doc_group, "ab", :normal}
+    assert group(empty()) == {:doc_group, empty(), :normal}
+
+    # Consistent formatting
+    doc = concat(glue(glue(glue("hello", "a"), "b"), "c"), "d")
+    assert render(group(doc), 5) == "hello\na\nb\ncd"
+  end
+
+  test "group modes doc" do
+    doc = glue(glue("hello", "a"), "b")
+    assert render(doc, 10) == "hello a b"
+
+    assert render(doc |> glue("c") |> group(), 10) ==
+             "hello\na\nb\nc"
+
+    assert render(doc |> group() |> glue("c") |> group() |> glue("d"), 10) ==
+             "hello a b\nc\nd"
+
+    assert render(doc |> group(:optimistic) |> glue("c") |> group() |> glue("d"), 10) ==
+             "hello\na\nb c d"
+
+    assert render(doc |> group(:optimistic) |> glue("c") |> group(:pessimistic) |> glue("d"), 10) ==
+             "hello\na\nb c\nd"
+  end
+
+  test "no limit doc" do
+    doc = no_limit(group(glue(glue("hello", "a"), "b")))
+    assert render(doc, 5) == "hello a b"
+    assert render(doc, :infinity) == "hello a b"
+  end
+
+  test "collapse lines" do
+    # Consistent with definitions
+    assert collapse_lines(3) == {:doc_collapse, 3}
+
+    # Wrong argument type
+    assert_raise FunctionClauseError, fn -> collapse_lines(0) end
+    assert_raise FunctionClauseError, fn -> collapse_lines(empty()) end
+
+    # Consistent formatting
+    doc = concat([collapse_lines(2), line(), line(), line()])
+    assert render(doc, 10) == "\n\n"
+    assert render(nest(doc, 2), 10) == "\n\n  "
+
+    doc = concat([collapse_lines(2), line(), line()])
+    assert render(doc, 10) == "\n\n"
+    assert render(nest(doc, 2), 10) == "\n\n  "
+
+    doc = concat([collapse_lines(2), line()])
+    assert render(doc, 10) == "\n"
+    assert render(nest(doc, 2), 10) == "\n  "
 
-    # Consistence of corresponding sdoc
-    assert factor(glue("a", "b"), 1) == ["a", " ", "b"]
-    assert factor(glue("a", "b"), 9) == ["a", " ", "b"]
+    doc = concat([collapse_lines(2), line(), "", line(), "", line()])
+    assert render(doc, 10) == "\n\n"
+    assert render(nest(doc, 2), 10) == "\n\n  "
+
+    doc = concat([collapse_lines(2), line(), "foo", line(), "bar", line()])
+    assert render(doc, 10) == "\nfoo\nbar\n"
+    assert render(nest(doc, 2), 10) == "\n  foo\n  bar\n  "
+  end
+
+  test "force doc and cancel doc" do
+    # Consistent with definitions
+    assert force_unfit("ab") == {:doc_force, "ab"}
+    assert force_unfit(empty()) == {:doc_force, empty()}
 
     # Consistent formatting
-    assert pretty(helloabcd, 5) == "hello\na b\ncd"
-    assert pretty(helloabcd, 80) == "hello a b cd"
+    doc = force_unfit(glue(glue("hello", "a"), "b"))
+    assert render(doc, 20) == "hello\na\nb"
+
+    assert render(doc |> glue("c") |> group(), 20) ==
+             "hello\na\nb\nc"
+
+    assert render(doc |> group(:optimistic) |> glue("c") |> group() |> glue("d"), 20) ==
+             "hello\na\nb c d"
+
+    assert render(doc |> group(:optimistic) |> glue("c") |> group(:pessimistic) |> glue("d"), 20) ==
+             "hello\na\nb c\nd"
+  end
+
+  test "formatting groups with lines" do
+    doc = line(glue("a", "b"), glue("hello", "world"))
+    assert render(group(doc), 5) == "a\nb\nhello\nworld"
+    assert render(group(doc), 100) == "a b\nhello world"
   end
 
   test "formatting with infinity" do
-    s = String.duplicate "x", 50
-    g = ";"
-    doc = group(glue(s, g, s) |>  glue(g, s) |>  glue(g, s) |> glue(g, s))
+    str = String.duplicate("x", 50)
+    colon = ";"
+
+    doc =
+      str
+      |> glue(colon, str)
+      |> glue(colon, str)
+      |> glue(colon, str)
+      |> glue(colon, str)
+      |> group()
+
+    assert render(doc, :infinity) ==
+             str <> colon <> str <> colon <> str <> colon <> str <> colon <> str
+  end
+
+  test "formatting container_doc with empty" do
+    sm = &container_doc("[", &1, "]", %Inspect.Opts{}, fn d, _ -> d end, separator: ",")
+
+    assert sm.([]) |> render(80) == "[]"
+    assert sm.([empty()]) |> render(80) == "[]"
+    assert sm.([empty(), empty()]) |> render(80) == "[]"
+    assert sm.(["a"]) |> render(80) == "[a]"
+    assert sm.(["a", empty()]) |> render(80) == "[a]"
+    assert sm.([empty(), "a"]) |> render(80) == "[a]"
+    assert sm.(["a", empty(), "b"]) |> render(80) == "[a, b]"
+    assert sm.([empty(), "a", "b"]) |> render(80) == "[a, b]"
+    assert sm.(["a", "b", empty()]) |> render(80) == "[a, b]"
+    assert sm.(["a", "b" | "c"]) |> render(80) == "[a, b | c]"
+    assert sm.(["a" | "b"]) |> render(80) == "[a | b]"
+    assert sm.(["a" | empty()]) |> render(80) == "[a]"
+    assert sm.([empty() | "b"]) |> render(80) == "[b]"
+  end
+
+  test "formatting container_doc with empty and limit" do
+    opts = %Inspect.Opts{limit: 2}
+    value = ["a", empty(), "b"]
 
-    assert pretty(doc, :infinity) == s <> g <> s <> g <> s <> g <> s <> g <> s
+    assert container_doc("[", value, "]", opts, fn d, _ -> d end, separator: ",") |> render(80) ==
+             "[a, b]"
   end
 end
diff --git a/lib/elixir/test/elixir/inspect_test.exs b/lib/elixir/test/elixir/inspect_test.exs
index 307801d8efc..67a1544c9e6 100644
--- a/lib/elixir/test/elixir/inspect_test.exs
+++ b/lib/elixir/test/elixir/inspect_test.exs
@@ -1,343 +1,1025 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule Inspect.AtomTest do
   use ExUnit.Case, async: true
 
-  test :basic do
+  doctest Inspect
+
+  test "basic" do
     assert inspect(:foo) == ":foo"
   end
 
-  test :empty do
+  test "empty" do
     assert inspect(:"") == ":\"\""
   end
 
-  test :true_false_nil do
+  test "true, false, nil" do
     assert inspect(false) == "false"
     assert inspect(true) == "true"
     assert inspect(nil) == "nil"
   end
 
-  test :with_uppercase do
+  test "with uppercase letters" do
     assert inspect(:fOO) == ":fOO"
     assert inspect(:FOO) == ":FOO"
   end
 
-  test :alias_atom do
+  test "aliases" do
     assert inspect(Foo) == "Foo"
     assert inspect(Foo.Bar) == "Foo.Bar"
     assert inspect(Elixir) == "Elixir"
+    assert inspect(Elixir.Foo) == "Foo"
     assert inspect(Elixir.Elixir) == "Elixir.Elixir"
+    assert inspect(Elixir.Elixir.Foo) == "Elixir.Elixir.Foo"
   end
 
-  test :with_integers do
-    assert inspect(User1)  == "User1"
+  test "with integers" do
+    assert inspect(User1) == "User1"
     assert inspect(:user1) == ":user1"
   end
 
-  test :with_punctuation do
+  test "with trailing ? or !" do
     assert inspect(:foo?) == ":foo?"
     assert inspect(:bar!) == ":bar!"
+    assert inspect(:Foo?) == ":Foo?"
   end
 
-  test :op do
-    assert inspect(:+)   == ":+"
+  test "operators" do
+    assert inspect(:+) == ":+"
+    assert inspect(:<~) == ":<~"
+    assert inspect(:~>) == ":~>"
     assert inspect(:&&&) == ":&&&"
-    assert inspect(:~~~) == ":~~~"
+    assert inspect(:"~~~") == ":\"~~~\""
+    assert inspect(:<<~) == ":<<~"
+    assert inspect(:~>>) == ":~>>"
+    assert inspect(:<~>) == ":<~>"
+    assert inspect(:+++) == ":+++"
+    assert inspect(:---) == ":---"
   end
 
-  test :... do
-    assert inspect(:...) == ":..."
+  test "::" do
+    assert inspect(:"::") == ~s[:"::"]
   end
 
-  test :@ do
+  test "with @" do
     assert inspect(:@) == ":@"
     assert inspect(:foo@bar) == ":foo@bar"
     assert inspect(:foo@bar@) == ":foo@bar@"
     assert inspect(:foo@bar@baz) == ":foo@bar@baz"
   end
 
-  test :others do
+  test "others" do
+    assert inspect(:...) == ":..."
     assert inspect(:<<>>) == ":<<>>"
-    assert inspect(:{})   == ":{}"
-    assert inspect(:%{})  == ":%{}"
-    assert inspect(:%)    == ":%"
+    assert inspect(:{}) == ":{}"
+    assert inspect(:%{}) == ":%{}"
+    assert inspect(:%) == ":%"
+    assert inspect(:->) == ":->"
+  end
+
+  test "escaping" do
+    assert inspect(:"hy-phen") == ~s(:"hy-phen")
+    assert inspect(:"@hello") == ~s(:"@hello")
+    assert inspect(:"Wat!?") == ~s(:"Wat!?")
+    assert inspect(:"'quotes' and \"double quotes\"") == ~S(:"'quotes' and \"double quotes\"")
+  end
+
+  test "colors" do
+    opts = [syntax_colors: [atom: :red]]
+    assert inspect(:hello, opts) == "\e[31m:hello\e[0m"
+    opts = [syntax_colors: [reset: :cyan]]
+    assert inspect(:hello, opts) == ":hello"
+  end
+
+  test "Unicode" do
+    assert inspect(:olá) == ":olá"
+    assert inspect(:Olá) == ":Olá"
+    assert inspect(:Ólá) == ":Ólá"
+    assert inspect(:こんにちは世界) == ":こんにちは世界"
+
+    nfd = :unicode.characters_to_nfd_binary("olá")
+    assert inspect(String.to_atom(nfd)) == ":\"#{nfd}\""
   end
 end
 
 defmodule Inspect.BitStringTest do
   use ExUnit.Case, async: true
 
-  test :bitstring do
-    assert inspect(<<1 :: [size(12), integer, signed]>>) == "<<0, 1::size(4)>>"
+  test "bitstring" do
+    assert inspect(<<1::12-integer-signed>>) == "<<0, 1::size(4)>>"
+
+    assert inspect(<<1::12-integer-signed>>, syntax_colors: [number: :blue]) ==
+             "<<\e[34m0\e[0m, \e[34m1\e[0m::size(4)>>"
+
+    assert inspect(<<1, 2, 3, 4, 5>>, pretty: true, width: 10) == "<<1, 2, 3,\n  4, 5>>"
   end
 
-  test :binary do
+  test "binary" do
     assert inspect("foo") == "\"foo\""
     assert inspect(<<?a, ?b, ?c>>) == "\"abc\""
   end
 
-  test :escape do
+  test "escaping" do
     assert inspect("f\no") == "\"f\\no\""
     assert inspect("f\\o") == "\"f\\\\o\""
     assert inspect("f\ao") == "\"f\\ao\""
+
+    assert inspect("\a\b\d\e\f\n\r\s\t\v") == "\"\\a\\b\\d\\e\\f\\n\\r \\t\\v\""
   end
 
-  test :utf8 do
+  test "UTF-8" do
     assert inspect(" ゆんゆん") == "\" ゆんゆん\""
+    # BOM
+    assert inspect("\uFEFFhello world") == "\"\\uFEFFhello world\""
+    # Invisible characters
+    assert inspect("\u2063") == "\"\\u2063\""
   end
 
-  test :all_escapes do
-    assert inspect("\a\b\d\e\f\n\r\s\t\v") ==
-           "\"\\a\\b\\d\\e\\f\\n\\r \\t\\v\""
-  end
+  test "infer" do
+    assert inspect(<<"john", 193, "doe">>, binaries: :infer) ==
+             ~s(<<106, 111, 104, 110, 193, 100, 111, 101>>)
 
-  test :opt_infer do
-    assert inspect(<<"eric", 193, "mj">>, binaries: :infer) == ~s(<<101, 114, 105, 99, 193, 109, 106>>)
-    assert inspect(<<"eric">>, binaries: :infer) == ~s("eric")
+    assert inspect(<<"john">>, binaries: :infer) == ~s("john")
     assert inspect(<<193>>, binaries: :infer) == ~s(<<193>>)
   end
 
-  test :opt_as_strings do
-    assert inspect(<<"eric", 193, "mj">>, binaries: :as_strings) == ~s("eric\\301mj")
-    assert inspect(<<"eric">>, binaries: :as_strings) == ~s("eric")
-    assert inspect(<<193>>, binaries: :as_strings) == ~s("\\301")
+  test "as strings" do
+    assert inspect(<<"john", 193, "doe">>, binaries: :as_strings) == ~s("john\\xC1doe")
+    assert inspect(<<"john">>, binaries: :as_strings) == ~s("john")
+    assert inspect(<<193>>, binaries: :as_strings) == ~s("\\xC1")
+    assert inspect(<<193>>, base: :hex, binaries: :as_strings) == ~s("\\xC1")
   end
 
-  test :opt_as_binaries do
-    assert inspect(<<"eric", 193, "mj">>, binaries: :as_binaries) == "<<101, 114, 105, 99, 193, 109, 106>>"
-    assert inspect(<<"eric">>, binaries: :as_binaries) == "<<101, 114, 105, 99>>"
+  test "as binaries" do
+    assert inspect(<<"john", 193, "doe">>, binaries: :as_binaries) ==
+             "<<106, 111, 104, 110, 193, 100, 111, 101>>"
+
+    assert inspect(<<"john">>, binaries: :as_binaries) == "<<106, 111, 104, 110>>"
     assert inspect(<<193>>, binaries: :as_binaries) == "<<193>>"
+
+    # Any base other than :decimal implies "binaries: :as_binaries"
+    assert inspect("abc", base: :hex) == "<<0x61, 0x62, 0x63>>"
+    assert inspect("abc", base: :octal) == "<<0o141, 0o142, 0o143>>"
+
+    # Size is still represented as decimal
+    assert inspect(<<10, 11, 12::4>>, base: :hex) == "<<0xA, 0xB, 0xC::size(4)>>"
   end
 
-  test :unprintable_with_opts do
+  test "unprintable with limit" do
     assert inspect(<<193, 193, 193, 193>>, limit: 3) == "<<193, 193, 193, ...>>"
   end
+
+  test "printable limit" do
+    assert inspect("hello world", printable_limit: 4) == ~s("hell" <> ...)
+
+    # Non-printable characters after the limit don't matter
+    assert inspect("hello world" <> <<0>>, printable_limit: 4) == ~s("hell" <> ...)
+
+    # Non printable strings aren't affected by printable limit
+    assert inspect(<<0, 1, 2, 3, 4>>, printable_limit: 3) == ~s(<<0, 1, 2, 3, 4>>)
+  end
 end
 
 defmodule Inspect.NumberTest do
   use ExUnit.Case, async: true
 
-  test :integer do
+  test "integer" do
     assert inspect(100) == "100"
   end
 
-  test :float do
+  test "decimal" do
+    assert inspect(100, base: :decimal) == "100"
+  end
+
+  test "hex" do
+    assert inspect(100, base: :hex) == "0x64"
+    assert inspect(-100, base: :hex) == "-0x64"
+  end
+
+  test "octal" do
+    assert inspect(100, base: :octal) == "0o144"
+    assert inspect(-100, base: :octal) == "-0o144"
+  end
+
+  test "binary" do
+    assert inspect(86, base: :binary) == "0b1010110"
+    assert inspect(-86, base: :binary) == "-0b1010110"
+  end
+
+  test "float" do
     assert inspect(1.0) == "1.0"
-    assert inspect(1.0E10) == "1.0e10"
-    assert inspect(1.0e10) == "1.0e10"
+    assert inspect(1.0e10) == "10000000000.0"
     assert inspect(1.0e-10) == "1.0e-10"
   end
+
+  test "integer colors" do
+    opts = [syntax_colors: [number: :red]]
+    assert inspect(123, opts) == "\e[31m123\e[0m"
+    opts = [syntax_colors: [reset: :cyan]]
+    assert inspect(123, opts) == "123"
+  end
+
+  test "float colors" do
+    opts = [syntax_colors: [number: :red]]
+    assert inspect(1.3, opts) == "\e[31m1.3\e[0m"
+    opts = [syntax_colors: [reset: :cyan]]
+    assert inspect(1.3, opts) == "1.3"
+  end
 end
 
 defmodule Inspect.TupleTest do
-  use ExUnit.Case
+  use ExUnit.Case, async: true
 
-  test :basic do
+  test "basic" do
     assert inspect({1, "b", 3}) == "{1, \"b\", 3}"
-    assert inspect({1, "b", 3}, [pretty: true, width: 1]) == "{1,\n \"b\",\n 3}"
+    assert inspect({1, "b", 3}, pretty: true, width: 1) == "{1,\n \"b\",\n 3}"
+    assert inspect({1, "b", 3}, pretty: true, width: 10) == "{1, \"b\",\n 3}"
   end
 
-  test :empty do
+  test "empty" do
     assert inspect({}) == "{}"
   end
 
-  test :with_limit do
+  test "with limit" do
     assert inspect({1, 2, 3, 4}, limit: 3) == "{1, 2, 3, ...}"
   end
+
+  test "colors" do
+    opts = [syntax_colors: []]
+    assert inspect({}, opts) == "{}"
+
+    opts = [syntax_colors: [reset: :cyan]]
+    assert inspect({}, opts) == "{}"
+    assert inspect({:x, :y}, opts) == "{:x, :y}"
+
+    opts = [syntax_colors: [reset: :cyan, atom: :red]]
+    assert inspect({}, opts) == "{}"
+    assert inspect({:x, :y}, opts) == "{\e[31m:x\e[36m, \e[31m:y\e[36m}"
+
+    opts = [syntax_colors: [tuple: :green, reset: :cyan, atom: :red]]
+    assert inspect({}, opts) == "\e[32m{\e[36m\e[32m}\e[36m"
+
+    assert inspect({:x, :y}, opts) ==
+             "\e[32m{\e[36m\e[31m:x\e[36m\e[32m,\e[36m \e[31m:y\e[36m\e[32m}\e[36m"
+  end
 end
 
 defmodule Inspect.ListTest do
   use ExUnit.Case, async: true
 
-  test :basic do
-    assert inspect([ 1, "b", 3 ]) == "[1, \"b\", 3]"
-    assert inspect([ 1, "b", 3 ], [pretty: true, width: 1]) == "[1,\n \"b\",\n 3]"
+  test "basic" do
+    assert inspect([1, "b", 3]) == "[1, \"b\", 3]"
+    assert inspect([1, "b", 3], pretty: true, width: 1) == "[1,\n \"b\",\n 3]"
   end
 
-  test :printable do
-    assert inspect('abc') == "'abc'"
+  test "printable" do
+    assert inspect(~c"abc") == ~s(~c"abc")
   end
 
-  test :keyword do
-    assert inspect([a: 1]) == "[a: 1]"
-    assert inspect([a: 1, b: 2]) == "[a: 1, b: 2]"
-    assert inspect([a: 1, a: 2, b: 2]) == "[a: 1, a: 2, b: 2]"
-    assert inspect(["123": 1]) == ~s(["123": 1])
+  test "printable limit" do
+    assert inspect(~c"hello world", printable_limit: 4) == ~s(~c"hell" ++ ...)
+    # Non printable characters after the limit don't matter
+    assert inspect(~c"hello world" ++ [0], printable_limit: 4) == ~s(~c"hell" ++ ...)
+    # Non printable strings aren't affected by printable limit
+    assert inspect([0, 1, 2, 3, 4], printable_limit: 3) == ~s([0, 1, 2, 3, 4])
+  end
+
+  test "keyword" do
+    assert inspect(a: 1) == "[a: 1]"
+    assert inspect(a: 1, b: 2) == "[a: 1, b: 2]"
+    assert inspect(a: 1, a: 2, b: 2) == "[a: 1, a: 2, b: 2]"
+    assert inspect("123": 1) == ~s(["123": 1])
+
+    assert inspect([foo: [1, 2, 3], baz: [4, 5, 6]], pretty: true, width: 20) ==
+             "[\n  foo: [1, 2, 3],\n  baz: [4, 5, 6]\n]"
+  end
 
-    assert inspect([foo: [1,2,3,:bar], bazzz: :bat], [pretty: true, width: 30]) ==
-           "[foo: [1, 2, 3, :bar],\n bazzz: :bat]"
+  test "keyword operators" do
+    assert inspect("::": 1, +: 2) == ~s(["::": 1, +: 2])
   end
 
-  test :opt_infer do
-    assert inspect('eric' ++ [0] ++ 'mj', char_lists: :infer) == "[101, 114, 105, 99, 0, 109, 106]"
-    assert inspect('eric', char_lists: :infer) == "'eric'"
-    assert inspect([0], char_lists: :infer) == "[0]"
+  test "opt infer" do
+    assert inspect(~c"john" ++ [0] ++ ~c"doe", charlists: :infer) ==
+             "[106, 111, 104, 110, 0, 100, 111, 101]"
+
+    assert inspect(~c"john", charlists: :infer) == ~s(~c"john")
+    assert inspect([0], charlists: :infer) == "[0]"
   end
 
-  test :opt_as_strings do
-    assert inspect('eric' ++ [0] ++ 'mj', char_lists: :as_char_lists) == "'eric\\000mj'"
-    assert inspect('eric', char_lists: :as_char_lists) == "'eric'"
-    assert inspect([0], char_lists: :as_char_lists) == "'\\000'"
+  test "opt as strings" do
+    assert inspect(~c"john" ++ [0] ++ ~c"doe", charlists: :as_charlists) == ~s(~c"john\\0doe")
+    assert inspect(~c"john", charlists: :as_charlists) == ~s(~c"john")
+    assert inspect([0], charlists: :as_charlists) == ~s(~c"\\0")
   end
 
-  test :opt_as_lists do
-    assert inspect('eric' ++ [0] ++ 'mj', char_lists: :as_lists) == "[101, 114, 105, 99, 0, 109, 106]"
-    assert inspect('eric', char_lists: :as_lists) == "[101, 114, 105, 99]"
-    assert inspect([0], char_lists: :as_lists) == "[0]"
+  test "opt as lists" do
+    assert inspect(~c"john" ++ [0] ++ ~c"doe", charlists: :as_lists) ==
+             "[106, 111, 104, 110, 0, 100, 111, 101]"
+
+    assert inspect(~c"john", charlists: :as_lists) == "[106, 111, 104, 110]"
+    assert inspect([0], charlists: :as_lists) == "[0]"
   end
 
-  test :non_printable do
+  test "non printable" do
     assert inspect([{:b, 1}, {:a, 1}]) == "[b: 1, a: 1]"
   end
 
-  test :unproper do
+  test "improper" do
     assert inspect([:foo | :bar]) == "[:foo | :bar]"
 
-    assert inspect([1,2,3,4,5|42], [pretty: true, width: 1]) == "[1,\n 2,\n 3,\n 4,\n 5 |\n 42]"
+    assert inspect([1, 2, 3, 4, 5 | 42], pretty: true, width: 1) ==
+             "[1,\n 2,\n 3,\n 4,\n 5 |\n 42]"
+  end
+
+  test "nested" do
+    assert inspect(Enum.reduce(1..5, [0], &[&2, &1]), limit: 5) ==
+             "[[[[[[...], ...], ...], ...], ...], ...]"
+
+    assert inspect(Enum.reduce(1..5, [0], &[&2, &1]), limit: 10) ==
+             "[[[[[[0], 1], 2], 3], 4], ...]"
+
+    assert inspect(Enum.reduce(1..6, [0], &[&2, &1]), limit: 10) ==
+             "[[[[[[[0], 1], 2], 3], ...], ...], ...]"
+
+    assert inspect(Enum.reduce(1..100, [0], &[&2 | &1]), limit: 5) ==
+             "[[[[[[...] | 96] | 97] | 98] | 99] | 100]"
   end
 
-  test :codepoints do
-    assert inspect('é') == "[233]"
+  test "codepoints" do
+    assert inspect(~c"é") == "[233]"
   end
 
-  test :empty do
+  test "empty" do
     assert inspect([]) == "[]"
   end
 
-  test :with_limit do
-    assert inspect([ 1, 2, 3, 4 ], limit: 3) == "[1, 2, 3, ...]"
+  test "with limit" do
+    assert inspect([1, 2, 3, 4], limit: 3) == "[1, 2, 3, ...]"
+  end
+
+  test "colors" do
+    opts = [syntax_colors: []]
+    assert inspect([], opts) == "[]"
+
+    opts = [syntax_colors: [reset: :cyan]]
+    assert inspect([], opts) == "[]"
+    assert inspect([:x, :y], opts) == "[:x, :y]"
+
+    opts = [syntax_colors: [reset: :cyan, atom: :red]]
+    assert inspect([], opts) == "[]"
+    assert inspect([:x, :y], opts) == "[\e[31m:x\e[36m, \e[31m:y\e[36m]"
+
+    opts = [syntax_colors: [reset: :cyan, atom: :red, list: :green]]
+    assert inspect([], opts) == "\e[32m[]\e[36m"
+
+    assert inspect([:x, :y], opts) ==
+             "\e[32m[\e[36m\e[31m:x\e[36m\e[32m,\e[36m \e[31m:y\e[36m\e[32m]\e[36m"
+  end
+
+  test "keyword with colors" do
+    opts = [syntax_colors: [reset: :cyan, list: :green, number: :blue]]
+    assert inspect([], opts) == "\e[32m[]\e[36m"
+
+    assert inspect([a: 9999], opts) == "\e[32m[\e[36ma: \e[34m9999\e[36m\e[32m]\e[36m"
+
+    opts = [syntax_colors: [reset: :cyan, atom: :red, list: :green, number: :blue]]
+    assert inspect([], opts) == "\e[32m[]\e[36m"
+
+    assert inspect([a: 9999], opts) == "\e[32m[\e[36m\e[31ma:\e[36m \e[34m9999\e[36m\e[32m]\e[36m"
+  end
+
+  test "limit with colors" do
+    opts = [limit: 1, syntax_colors: [reset: :cyan, list: :green, atom: :red]]
+    assert inspect([], opts) == "\e[32m[]\e[36m"
+
+    assert inspect([:x, :y], opts) == "\e[32m[\e[36m\e[31m:x\e[36m\e[32m,\e[36m ...\e[32m]\e[36m"
   end
 end
 
 defmodule Inspect.MapTest do
-  use ExUnit.Case
+  use ExUnit.Case, async: true
 
-  test :basic do
+  test "basic" do
     assert inspect(%{1 => "b"}) == "%{1 => \"b\"}"
-    assert inspect(%{1 => "b", 2 => "c"}, [pretty: true, width: 1]) == "%{1 => \"b\",\n  2 => \"c\"}"
+
+    assert inspect(%{1 => "b", 2 => "c"},
+             pretty: true,
+             width: 1,
+             custom_options: [sort_maps: true]
+           ) ==
+             "%{\n  1 => \"b\",\n  2 => \"c\"\n}"
   end
 
-  test :keyword do
+  test "keyword" do
     assert inspect(%{a: 1}) == "%{a: 1}"
-    assert inspect(%{a: 1, b: 2}) == "%{a: 1, b: 2}"
-    assert inspect(%{a: 1, b: 2, c: 3}) == "%{a: 1, b: 2, c: 3}"
+    assert inspect(%{a: 1, b: 2}, custom_options: [sort_maps: true]) == "%{a: 1, b: 2}"
+
+    assert inspect(%{a: 1, b: 2, c: 3}, custom_options: [sort_maps: true]) ==
+             "%{a: 1, b: 2, c: 3}"
   end
 
-  test :with_limit do
-    assert inspect(%{1 => 1, 2 => 2, 3 => 3, 4 => 4}, limit: 3) == "%{1 => 1, 2 => 2, 3 => 3, ...}"
+  test "with limit" do
+    assert inspect(%{1 => 1, 2 => 2, 3 => 3, 4 => 4}, limit: 3) ==
+             "%{1 => 1, 2 => 2, 3 => 3, ...}"
   end
 
   defmodule Public do
-    def __struct__ do
-      %{key: 0, __struct__: Public}
-    end
+    defstruct key: 0
   end
 
   defmodule Private do
   end
 
-  test :public_struct do
+  test "public struct" do
     assert inspect(%Public{key: 1}) == "%Inspect.MapTest.Public{key: 1}"
   end
 
-  test :public_modified_struct do
+  test "public modified struct" do
     public = %Public{key: 1}
-    assert inspect(Map.put(public, :foo, :bar)) ==
-           "%{__struct__: Inspect.MapTest.Public, foo: :bar, key: 1}"
+
+    assert inspect(Map.put(public, :foo, :bar), custom_options: [sort_maps: true]) ==
+             "%{__struct__: Inspect.MapTest.Public, foo: :bar, key: 1}"
   end
 
-  test :private_struct do
-    assert inspect(%{__struct__: Private, key: 1}) == "%{__struct__: Inspect.MapTest.Private, key: 1}"
+  test "public modified struct with defimpl" do
+    map_set = MapSet.new([1, 2])
+
+    assert inspect(Map.put(map_set, :foo, :bar), custom_options: [sort_maps: true]) ==
+             "%{__struct__: MapSet, foo: :bar, map: %{1 => [], 2 => []}}"
+  end
+
+  test "private struct" do
+    assert inspect(%{__struct__: Private, key: 1}, custom_options: [sort_maps: true]) ==
+             "%{__struct__: Inspect.MapTest.Private, key: 1}"
   end
 
   defmodule Failing do
-    def __struct__ do
-      %{key: 0}
-    end
+    @enforce_keys [:name]
+    defstruct @enforce_keys
 
     defimpl Inspect do
-      def inspect(_, _) do
-        raise "failing"
+      def inspect(%Failing{name: name}, _) do
+        Atom.to_string(name)
       end
     end
   end
 
-  test :bad_implementation do
-    msg = "Got RuntimeError with message \"failing\" " <>
-          "while inspecting %{__struct__: Inspect.MapTest.Failing, key: 0}"
+  test "safely inspect bad implementation" do
+    assert_raise ArgumentError, ~r/argument error/, fn ->
+      raise(ArgumentError)
+    end
+
+    message = ~s'''
+    #Inspect.Error<
+      got ArgumentError with message:
+
+          """
+          errors were found at the given arguments:
+
+            * 1st argument: not an atom
+          """
+
+      while inspecting:
+
+          %{__struct__: Inspect.MapTest.Failing, name: "Foo"}
+    '''
+
+    assert inspect(%Failing{name: "Foo"}, custom_options: [sort_maps: true]) =~ message
+  end
+
+  test "safely inspect bad implementation disables colors" do
+    message = ~s'''
+    #Inspect.Error<
+      got ArgumentError with message:
+
+          """
+          errors were found at the given arguments:
+
+            * 1st argument: not an atom
+          """
+
+      while inspecting:
+
+          %{__struct__: Inspect.MapTest.Failing, name: "Foo"}
+    '''
+
+    assert inspect(%Failing{name: "Foo"},
+             syntax_colors: [atom: [:green]],
+             custom_options: [sort_maps: true]
+           ) =~ message
+  end
 
-    assert_raise ArgumentError, msg, fn ->
-      inspect(%Failing{})
+  test "unsafely inspect bad implementation" do
+    exception_message = ~s'''
+    got ArgumentError with message:
+
+        """
+        errors were found at the given arguments:
+
+          * 1st argument: not an atom
+        """
+
+    while inspecting:
+
+        %{__struct__: Inspect.MapTest.Failing, name: "Foo"}
+    '''
+
+    try do
+      inspect(%Failing{name: "Foo"}, safe: false, custom_options: [sort_maps: true])
+    rescue
+      exception in Inspect.Error ->
+        assert Exception.message(exception) =~ exception_message
+        assert [{:erlang, :atom_to_binary, [_], [_ | _]} | _] = __STACKTRACE__
+    else
+      _ -> flunk("expected failure")
     end
   end
 
-  test :exception do
+  test "raise when trying to inspect with a bad implementation from inside another exception that is being raised" do
+    # Inspect.Error is raised here when we tried to print the error message
+    # called by another exception (Protocol.UndefinedError in this case)
+    exception_message = ~s'''
+    protocol Enumerable not implemented for Inspect.MapTest.Failing (a struct)
+
+    Got value:
+
+        #Inspect.Error<
+          got ArgumentError with message:
+
+              """
+              errors were found at the given arguments:
+
+                * 1st argument: not an atom
+              """
+
+          while inspecting:
+
+    '''
+
+    try do
+      Enum.to_list(%Failing{name: "Foo"})
+    rescue
+      exception in Protocol.UndefinedError ->
+        message = Exception.message(exception)
+        assert message =~ exception_message
+        assert message =~ "__struct__: Inspect.MapTest.Failing"
+        assert message =~ "name: \"Foo\""
+
+        assert [
+                 {Enumerable, :impl_for!, 1, _} | _
+               ] = __STACKTRACE__
+
+        # The culprit
+        assert Enum.any?(__STACKTRACE__, fn
+                 {Enum, :to_list, 1, _} -> true
+                 _ -> false
+               end)
+
+        # The line calling the culprit
+        assert Enum.any?(__STACKTRACE__, fn
+                 {Inspect.MapTest, _test_name, 1, file: file, line: _line_number} ->
+                   String.ends_with?(List.to_string(file), "test/elixir/inspect_test.exs")
+
+                 _ ->
+                   false
+               end)
+    else
+      _ -> flunk("expected failure")
+    end
+  end
+
+  test "Exception.message/1 with bad implementation" do
+    failing = %Failing{name: "Foo"}
+
+    message = ~s'''
+    #Inspect.Error<
+      got ArgumentError with message:
+
+          """
+          errors were found at the given arguments:
+
+            * 1st argument: not an atom
+          """
+
+      while inspecting:
+
+          %{__struct__: Inspect.MapTest.Failing, name: "Foo"}
+    '''
+
+    {my_argument_error, stacktrace} =
+      try do
+        atom_to_string(Process.get(:unused, failing.name))
+      rescue
+        e -> {e, __STACKTRACE__}
+      end
+
+    inspected =
+      inspect(
+        Inspect.Error.exception(
+          exception: my_argument_error,
+          stacktrace: stacktrace,
+          inspected_struct: "%{__struct__: Inspect.MapTest.Failing, name: \"Foo\"}"
+        )
+      )
+
+    assert inspect(failing, custom_options: [sort_maps: true]) =~ message
+    assert inspected =~ message
+  end
+
+  defp atom_to_string(atom) do
+    Atom.to_string(atom)
+  end
+
+  test "exception" do
     assert inspect(%RuntimeError{message: "runtime error"}) ==
-           "%RuntimeError{message: \"runtime error\"}"
+             "%RuntimeError{message: \"runtime error\"}"
+  end
+
+  test "colors" do
+    opts = [syntax_colors: [reset: :cyan, atom: :red, number: :magenta]]
+    assert inspect(%{1 => 2}, opts) == "%{\e[35m1\e[36m => \e[35m2\e[36m}"
+
+    assert inspect(%{a: 1}, opts) == "%{\e[31ma:\e[36m \e[35m1\e[36m}"
+
+    assert inspect(%Public{key: 1}, opts) ==
+             "%Inspect.MapTest.Public{\e[31mkey:\e[36m \e[35m1\e[36m}"
+
+    opts = [syntax_colors: [reset: :cyan, atom: :red, map: :green, number: :blue]]
+
+    assert inspect(%{a: 9999}, opts) ==
+             "\e[32m%{\e[36m" <> "\e[31ma:\e[36m " <> "\e[34m9999\e[36m" <> "\e[32m}\e[36m"
+  end
+
+  defmodule StructWithoutOptions do
+    @derive Inspect
+    defstruct [:a, :b, :c, :d]
+  end
+
+  test "struct without options" do
+    struct = %StructWithoutOptions{a: 1, b: 2, c: 3, d: 4}
+    assert inspect(struct) == "%Inspect.MapTest.StructWithoutOptions{a: 1, b: 2, c: 3, d: 4}"
+
+    assert inspect(struct, pretty: true, width: 1) ==
+             "%Inspect.MapTest.StructWithoutOptions{\n  a: 1,\n  b: 2,\n  c: 3,\n  d: 4\n}"
+  end
+
+  defmodule StructWithOnlyOption do
+    @derive {Inspect, only: [:b, :c]}
+    defstruct [:a, :b, :c, :d]
+  end
+
+  test "struct with :only option" do
+    struct = %StructWithOnlyOption{a: 1, b: 2, c: 3, d: 4}
+    assert inspect(struct) == "#Inspect.MapTest.StructWithOnlyOption<b: 2, c: 3, ...>"
+
+    assert inspect(struct, pretty: true, width: 1) ==
+             "#Inspect.MapTest.StructWithOnlyOption<\n  b: 2,\n  c: 3,\n  ...\n>"
+
+    struct = %{struct | c: [1, 2, 3, 4]}
+    assert inspect(struct) == "#Inspect.MapTest.StructWithOnlyOption<b: 2, c: [1, 2, 3, 4], ...>"
+  end
+
+  defmodule StructWithEmptyOnlyOption do
+    @derive {Inspect, only: []}
+    defstruct [:a, :b, :c, :d]
+  end
+
+  test "struct with empty :only option" do
+    struct = %StructWithEmptyOnlyOption{a: 1, b: 2, c: 3, d: 4}
+    assert inspect(struct) == "#Inspect.MapTest.StructWithEmptyOnlyOption<...>"
+  end
+
+  defmodule StructWithAllFieldsInOnlyOption do
+    @derive {Inspect, only: [:a, :b]}
+    defstruct [:a, :b]
+  end
+
+  test "struct with all fields in the :only option" do
+    struct = %StructWithAllFieldsInOnlyOption{a: 1, b: 2}
+    assert inspect(struct) == "%Inspect.MapTest.StructWithAllFieldsInOnlyOption{a: 1, b: 2}"
+
+    assert inspect(struct, pretty: true, width: 1) ==
+             "%Inspect.MapTest.StructWithAllFieldsInOnlyOption{\n  a: 1,\n  b: 2\n}"
+  end
+
+  test "struct missing fields in the :only option" do
+    assert_raise ArgumentError,
+                 "unknown fields [:c] in :only when deriving the Inspect protocol for Inspect.MapTest.StructMissingFieldsInOnlyOption",
+                 fn ->
+                   defmodule StructMissingFieldsInOnlyOption do
+                     @derive {Inspect, only: [:c]}
+                     defstruct [:a, :b]
+                   end
+                 end
+  end
+
+  test "struct missing fields in the :except option" do
+    assert_raise ArgumentError,
+                 "unknown fields [:c, :d] in :except when deriving the Inspect protocol for Inspect.MapTest.StructMissingFieldsInExceptOption",
+                 fn ->
+                   defmodule StructMissingFieldsInExceptOption do
+                     @derive {Inspect, except: [:c, :d]}
+                     defstruct [:a, :b]
+                   end
+                 end
+  end
+
+  test "passing a non-list to the :only option" do
+    assert_raise ArgumentError,
+                 "invalid value :not_a_list in :only when deriving the Inspect protocol for Inspect.MapTest.StructInvalidListInOnlyOption (expected a list)",
+                 fn ->
+                   defmodule StructInvalidListInOnlyOption do
+                     @derive {Inspect, only: :not_a_list}
+                     defstruct [:a, :b]
+                   end
+                 end
+  end
+
+  defmodule StructWithExceptOption do
+    @derive {Inspect, except: [:b, :c]}
+    defstruct [:a, :b, :c, :d]
+  end
+
+  test "struct with :except option" do
+    struct = %StructWithExceptOption{a: 1, b: 2, c: 3, d: 4}
+    assert inspect(struct) == "#Inspect.MapTest.StructWithExceptOption<a: 1, d: 4, ...>"
+
+    assert inspect(struct, pretty: true, width: 1) ==
+             "#Inspect.MapTest.StructWithExceptOption<\n  a: 1,\n  d: 4,\n  ...\n>"
+  end
+
+  defmodule StructWithBothOnlyAndExceptOptions do
+    @derive {Inspect, only: [:a, :b], except: [:b, :c]}
+    defstruct [:a, :b, :c, :d]
+  end
+
+  test "struct with both :only and :except options" do
+    struct = %StructWithBothOnlyAndExceptOptions{a: 1, b: 2, c: 3, d: 4}
+    assert inspect(struct) == "#Inspect.MapTest.StructWithBothOnlyAndExceptOptions<a: 1, ...>"
+
+    assert inspect(struct, pretty: true, width: 1) ==
+             "#Inspect.MapTest.StructWithBothOnlyAndExceptOptions<\n  a: 1,\n  ...\n>"
+  end
+
+  defmodule StructWithOptionalAndOrder do
+    @derive {Inspect, optional: [:b, :c]}
+    defstruct [:c, :d, :a, :b]
+  end
+
+  test "struct with both :order and :optional options" do
+    struct = %StructWithOptionalAndOrder{a: 1, b: 2, c: 3, d: 4}
+
+    assert inspect(struct) ==
+             "%Inspect.MapTest.StructWithOptionalAndOrder{c: 3, d: 4, a: 1, b: 2}"
+
+    struct = %StructWithOptionalAndOrder{}
+    assert inspect(struct) == "%Inspect.MapTest.StructWithOptionalAndOrder{d: nil, a: nil}"
+  end
+
+  defmodule StructWithExceptOptionalAndOrder do
+    @derive {Inspect, optional: [:b, :c], except: [:e]}
+    defstruct [:c, :d, :e, :a, :b]
+  end
+
+  test "struct with :except, :order, and :optional options" do
+    struct = %StructWithExceptOptionalAndOrder{a: 1, b: 2, c: 3, d: 4}
+
+    assert inspect(struct) ==
+             "#Inspect.MapTest.StructWithExceptOptionalAndOrder<c: 3, d: 4, a: 1, b: 2, ...>"
+
+    struct = %StructWithExceptOptionalAndOrder{}
+
+    assert inspect(struct) ==
+             "#Inspect.MapTest.StructWithExceptOptionalAndOrder<d: nil, a: nil, ...>"
+  end
+
+  defmodule StructWithOptionalAll do
+    @derive {Inspect, optional: :all}
+    defstruct [:a, :b, :c, :d]
+  end
+
+  test "struct with :optional set to :all" do
+    struct = %StructWithOptionalAll{a: 1, b: 2}
+
+    assert inspect(struct) == "%Inspect.MapTest.StructWithOptionalAll{a: 1, b: 2}"
+
+    struct = %StructWithOptionalAll{}
+    assert inspect(struct) == "%Inspect.MapTest.StructWithOptionalAll{}"
   end
 end
 
 defmodule Inspect.OthersTest do
   use ExUnit.Case, async: true
 
-  def f do
-    fn() -> :ok end
+  def fun() do
+    fn -> :ok end
   end
 
-  test :external_elixir_funs do
+  def unquote(:"weirdly named/fun-")() do
+    fn -> :ok end
+  end
+
+  test "external Elixir funs" do
     bin = inspect(&Enum.map/2)
     assert bin == "&Enum.map/2"
+
+    assert inspect(&__MODULE__."weirdly named/fun-"/0) ==
+             ~s(&Inspect.OthersTest."weirdly named/fun-"/0)
   end
 
-  test :external_erlang_funs do
+  test "external Erlang funs" do
     bin = inspect(&:lists.map/2)
     assert bin == "&:lists.map/2"
   end
 
-  test :outdated_functions do
+  test "outdated functions" do
     defmodule V do
       def fun do
         fn -> 1 end
       end
     end
 
-    Application.put_env(:elixir, :anony, V.fun)
+    Application.put_env(:elixir, :anony, V.fun())
     Application.put_env(:elixir, :named, &V.fun/0)
 
-    :code.delete(V)
     :code.purge(V)
+    :code.delete(V)
 
     anony = Application.get_env(:elixir, :anony)
     named = Application.get_env(:elixir, :named)
 
-    assert inspect(anony) =~ ~r"#Function<0.\d+/0 in Inspect.OthersTest.V>"
+    assert inspect(anony) =~ ~r"#Function<0.\d+/0"
     assert inspect(named) =~ ~r"&Inspect.OthersTest.V.fun/0"
   after
     Application.delete_env(:elixir, :anony)
     Application.delete_env(:elixir, :named)
   end
 
-  test :other_funs do
-    assert "#Function<" <> _ = inspect(fn(x) -> x + 1 end)
-    assert "#Function<" <> _ = inspect(f)
+  test "other funs" do
+    assert "#Function<" <> _ = inspect(fn x -> x + 1 end)
+    assert "#Function<" <> _ = inspect(fun())
+    opts = [syntax_colors: []]
+    assert "#Function<" <> _ = inspect(fun(), opts)
+    opts = [syntax_colors: [reset: :red]]
+    assert "#Function<" <> rest = inspect(fun(), opts)
+    assert String.ends_with?(rest, ">")
+
+    inspected = inspect(__MODULE__."weirdly named/fun-"())
+    assert inspected =~ ~r(#Function<\d+\.\d+/0 in Inspect\.OthersTest\."weirdly named/fun-"/0>)
+  end
+
+  test "map set" do
+    assert "MapSet.new(" <> _ = inspect(MapSet.new())
+  end
+
+  test "PIDs" do
+    assert "#PID<" <> _ = inspect(self())
+    opts = [syntax_colors: []]
+    assert "#PID<" <> _ = inspect(self(), opts)
+    opts = [syntax_colors: [reset: :cyan]]
+    assert "#PID<" <> rest = inspect(self(), opts)
+    assert String.ends_with?(rest, ">")
+  end
+
+  test "references" do
+    assert "#Reference<" <> _ = inspect(make_ref())
   end
 
-  test :hash_dict_set do
-    assert "#HashDict<" <> _ = inspect(HashDict.new)
-    assert "#HashSet<" <> _ = inspect(HashSet.new)
+  test "regex" do
+    assert inspect(~r(foo)m) == "~r/foo/m"
+    assert inspect(~r[\\\#{2,}]iu) == ~S"~r/\\\#{2,}/iu"
+
+    assert inspect(Regex.compile!("a\\/b")) == "~r/a\\/b/"
+
+    assert inspect(Regex.compile!("\a\b\d\e\f\n\r\s\t\v/")) ==
+             "~r/\\a\\x08\\x7F\\x1B\\f\\n\\r \\t\\v\\//"
+
+    assert inspect(~r<\a\b\d\e\f\n\r\s\t\v/>) == "~r/\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v\\//"
+    assert inspect(~r" \\/ ") == "~r/ \\\\\\/ /"
+    assert inspect(~r/hi/, syntax_colors: [regex: :red]) == "\e[31m~r/hi/\e[0m"
+
+    assert inspect(Regex.compile!("foo", "i")) == "~r/foo/i"
+    assert inspect(Regex.compile!("foo", [:ucp])) == ~S'Regex.compile!("foo", [:ucp])'
   end
 
-  test :pids do
-    assert "#PID<" <> _ = inspect(self)
+  @tag :re_import
+  test "exported regex" do
+    assert inspect(~r/foo/E) == "~r/foo/E"
   end
 
-  test :references do
-    assert "#Reference<" <> _ = inspect(make_ref)
+  test "inspect_fun" do
+    fun = fn
+      integer, _opts when is_integer(integer) ->
+        "<#{integer}>"
+
+      %URI{} = uri, _opts ->
+        "#URI<#{uri}>"
+
+      term, opts ->
+        Inspect.inspect(term, opts)
+    end
+
+    opts = [inspect_fun: fun]
+
+    assert inspect(1000, opts) == "<1000>"
+    assert inspect([1000], opts) == "[<1000>]"
+
+    uri = URI.parse("https://elixir-lang.org")
+    assert inspect(uri, opts) == "#URI<https://elixir-lang.org>"
+    assert inspect([uri], opts) == "[#URI<https://elixir-lang.org>]"
   end
 
-  test :regex do
-    "~r/foo/m" = inspect(~r(foo)m)
-    "~r/\\a\\010\\177\\033\\f\\n\\r \\t\\v\\//" = inspect(Regex.compile!("\a\b\d\e\f\n\r\s\t\v/"))
-    "~r/\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v\\//" = inspect(~r<\a\b\d\e\f\n\r\s\t\v/>)
+  defmodule Nested do
+    defstruct nested: nil
+
+    defimpl Inspect do
+      import Inspect.Algebra
+
+      def inspect(%Nested{nested: nested}, opts) do
+        indent = Keyword.get(opts.custom_options, :indent, 2)
+        level = Keyword.get(opts.custom_options, :level, 1)
+
+        nested_str =
+          Kernel.inspect(nested, custom_options: [level: level + 1, indent: indent + 2])
+
+        concat(
+          nest(line("#Nested[##{level}/#{indent}]<", nested_str), indent),
+          nest(line("", ">"), indent - 2)
+        )
+      end
+    end
+  end
+
+  test "custom_options" do
+    assert inspect(%Nested{nested: %Nested{nested: 42}}) ==
+             "#Nested[#1/2]<\n  #Nested[#2/4]<\n    42\n  >\n>"
+  end
+end
+
+defmodule Inspect.CustomProtocolTest do
+  use ExUnit.Case, async: true
+
+  defprotocol CustomInspect do
+    def inspect(term, opts)
+  end
+
+  defmodule MissingImplementation do
+    defstruct []
+  end
+
+  test "unsafely inspect missing implementation" do
+    msg = ~S'''
+    got Protocol.UndefinedError with message:
+
+        """
+        protocol Inspect.CustomProtocolTest.CustomInspect not implemented for Inspect.CustomProtocolTest.MissingImplementation (a struct)
+
+        Got value:
+
+            %Inspect.CustomProtocolTest.MissingImplementation{}
+        """
+
+    while inspecting:
+
+        %{__struct__: Inspect.CustomProtocolTest.MissingImplementation}
+    '''
+
+    opts = [safe: false, inspect_fun: &CustomInspect.inspect/2]
+
+    try do
+      inspect(%MissingImplementation{}, opts)
+    rescue
+      e in Inspect.Error ->
+        assert Exception.message(e) =~ msg
+        assert [{Inspect.CustomProtocolTest.CustomInspect, :impl_for!, 1, _} | _] = __STACKTRACE__
+    else
+      _ -> flunk("expected failure")
+    end
+  end
+
+  test "safely inspect missing implementation" do
+    msg = ~S'''
+    #Inspect.Error<
+      got Protocol.UndefinedError with message:
+
+          """
+          protocol Inspect.CustomProtocolTest.CustomInspect not implemented for Inspect.CustomProtocolTest.MissingImplementation (a struct)
+
+          Got value:
+
+              %Inspect.CustomProtocolTest.MissingImplementation{}
+          """
+
+      while inspecting:
+
+          %{__struct__: Inspect.CustomProtocolTest.MissingImplementation}
+    '''
+
+    opts = [inspect_fun: &CustomInspect.inspect/2]
+    assert inspect(%MissingImplementation{}, opts) =~ msg
   end
 end
diff --git a/lib/elixir/test/elixir/integer_test.exs b/lib/elixir/test/elixir/integer_test.exs
index 547c71567a0..5069eb58da0 100644
--- a/lib/elixir/test/elixir/integer_test.exs
+++ b/lib/elixir/test/elixir/integer_test.exs
@@ -1,33 +1,157 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule IntegerTest do
   use ExUnit.Case, async: true
+
+  doctest Integer
+
   require Integer
 
-  test :odd? do
-    assert Integer.odd?(0) == false
-    assert Integer.odd?(1) == true
-    assert Integer.odd?(2) == false
-    assert Integer.odd?(3) == true
-    assert Integer.odd?(-1) == true
-    assert Integer.odd?(-2) == false
-    assert Integer.odd?(-3) == true
+  def test_is_odd_in_guards(number) when Integer.is_odd(number), do: number
+  def test_is_odd_in_guards(_number), do: false
+
+  def test_is_even_in_guards(number) when Integer.is_even(number), do: number
+  def test_is_even_in_guards(_number), do: false
+
+  test "is_odd/1" do
+    assert Integer.is_odd(0) == false
+    assert Integer.is_odd(1) == true
+    assert Integer.is_odd(2) == false
+    assert Integer.is_odd(3) == true
+    assert Integer.is_odd(-1) == true
+    assert Integer.is_odd(-2) == false
+    assert Integer.is_odd(-3) == true
+    assert test_is_odd_in_guards(10) == false
+    assert test_is_odd_in_guards(11) == 11
+    assert test_is_odd_in_guards(:not_integer) == false
+  end
+
+  test "is_even/1" do
+    assert Integer.is_even(0) == true
+    assert Integer.is_even(1) == false
+    assert Integer.is_even(2) == true
+    assert Integer.is_even(3) == false
+    assert Integer.is_even(-1) == false
+    assert Integer.is_even(-2) == true
+    assert Integer.is_even(-3) == false
+    assert test_is_even_in_guards(10) == 10
+    assert test_is_even_in_guards(11) == false
+    assert test_is_even_in_guards(:not_integer) == false
+  end
+
+  test "mod/2" do
+    assert Integer.mod(10, -5) == 0
+    assert Integer.mod(3, 2) == 1
+    assert Integer.mod(0, 10) == 0
+    assert Integer.mod(0, -5) == 0
+    assert Integer.mod(30000, 2001) == 1986
+    assert Integer.mod(30000, -2001) == -15
+    assert Integer.mod(-20, 11) == 2
+    assert Integer.mod(-55, -22) == -11
+  end
+
+  test "mod/2 raises ArithmeticError when divisor is 0" do
+    assert_raise ArithmeticError, fn -> Integer.mod(3, 0) end
+    assert_raise ArithmeticError, fn -> Integer.mod(-50, 0) end
+  end
+
+  test "floor_div/2" do
+    assert Integer.floor_div(10, -5) == -2
+    assert Integer.floor_div(3, 2) == 1
+    assert Integer.floor_div(0, 10) == 0
+    assert Integer.floor_div(0, -5) == 0
+    assert Integer.floor_div(30000, 2001) == 14
+    assert Integer.floor_div(30000, -2001) == -15
+    assert Integer.floor_div(-20, 11) == -2
+    assert Integer.floor_div(-55, -22) == 2
+  end
+
+  test "floor_div/2 raises ArithmeticError when divisor is 0" do
+    assert_raise ArithmeticError, fn -> Integer.floor_div(3, 0) end
+    assert_raise ArithmeticError, fn -> Integer.floor_div(-50, 0) end
+  end
+
+  test "floor_div/2 raises ArithmeticError when non-integers used as arguments" do
+    assert_raise ArithmeticError, fn -> Integer.floor_div(3.0, 2) end
+    assert_raise ArithmeticError, fn -> Integer.floor_div(20, 1.2) end
+  end
+
+  test "ceil_div/2" do
+    assert Integer.ceil_div(10, -5) == -2
+    assert Integer.ceil_div(3, 2) == 2
+    assert Integer.ceil_div(0, 10) == 0
+    assert Integer.ceil_div(0, -10) == 0
+    assert Integer.ceil_div(30000, -2001) == -14
+    assert Integer.ceil_div(-20, 11) == -1
+    assert Integer.ceil_div(-55, -22) == 3
+  end
+
+  test "ceil_div/2 raises ArithmeticError when divisor is 0" do
+    assert_raise ArithmeticError, fn -> Integer.ceil_div(3, 0) end
+    assert_raise ArithmeticError, fn -> Integer.ceil_div(-50, 0) end
+  end
+
+  test "ceil_div/2 raises ArithmeticError when non-integers used as arguments" do
+    assert_raise ArithmeticError, fn -> Integer.ceil_div(3.0, 2) end
+    assert_raise ArithmeticError, fn -> Integer.ceil_div(20, 1.2) end
+  end
+
+  test "digits/2" do
+    assert Integer.digits(0) == [0]
+    assert Integer.digits(0, 2) == [0]
+    assert Integer.digits(1) == [1]
+    assert Integer.digits(-1) == [-1]
+    assert Integer.digits(123, 123) == [1, 0]
+    assert Integer.digits(-123, 123) == [-1, 0]
+    assert Integer.digits(456, 1000) == [456]
+    assert Integer.digits(-456, 1000) == [-456]
+    assert Integer.digits(123) == [1, 2, 3]
+    assert Integer.digits(-123) == [-1, -2, -3]
+    assert Integer.digits(58127, 2) == [1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]
+    assert Integer.digits(-58127, 2) == [-1, -1, -1, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, -1, -1]
+
+    for n <- Enum.to_list(-1..1) do
+      assert_raise FunctionClauseError, fn ->
+        Integer.digits(10, n)
+        Integer.digits(-10, n)
+      end
+    end
   end
 
-  test :even? do
-    assert Integer.even?(0) == true
-    assert Integer.even?(1) == false
-    assert Integer.even?(2) == true
-    assert Integer.even?(3) == false
-    assert Integer.even?(-1) == false
-    assert Integer.even?(-2) == true
-    assert Integer.even?(-3) == false
+  test "undigits/2" do
+    assert Integer.undigits([]) == 0
+    assert Integer.undigits([0]) == 0
+    assert Integer.undigits([1]) == 1
+    assert Integer.undigits([1, 0, 1]) == 101
+    assert Integer.undigits([1, 4], 16) == 0x14
+    assert Integer.undigits([1, 4], 8) == 0o14
+    assert Integer.undigits([1, 1], 2) == 0b11
+    assert Integer.undigits([1, 2, 3, 4, 5]) == 12345
+    assert Integer.undigits([1, 0, -5]) == 95
+    assert Integer.undigits([-1, -1, -5]) == -115
+    assert Integer.undigits([0, 0, 0, -1, -1, -5]) == -115
+
+    for n <- Enum.to_list(-1..1) do
+      assert_raise FunctionClauseError, fn ->
+        Integer.undigits([1, 0, 1], n)
+      end
+    end
+
+    assert_raise ArgumentError, "invalid digit 17 in base 16", fn ->
+      Integer.undigits([1, 2, 17], 16)
+    end
   end
 
-  test :parse do
+  test "parse/2" do
     assert Integer.parse("12") === {12, ""}
+    assert Integer.parse("012") === {12, ""}
+    assert Integer.parse("+12") === {12, ""}
     assert Integer.parse("-12") === {-12, ""}
-    assert Integer.parse("123456789") === {123456789, ""}
+    assert Integer.parse("123456789") === {123_456_789, ""}
     assert Integer.parse("12.5") === {12, ".5"}
     assert Integer.parse("7.5e-3") === {7, ".5e-3"}
     assert Integer.parse("12x") === {12, "x"}
@@ -35,5 +159,128 @@ defmodule IntegerTest do
     assert Integer.parse("--1") === :error
     assert Integer.parse("+-1") === :error
     assert Integer.parse("three") === :error
+
+    assert Integer.parse("12", 10) === {12, ""}
+    assert Integer.parse("-12", 12) === {-14, ""}
+    assert Integer.parse("12345678", 9) === {6_053_444, ""}
+    assert Integer.parse("3.14", 4) === {3, ".14"}
+    assert Integer.parse("64eb", 16) === {25835, ""}
+    assert Integer.parse("64eb", 10) === {64, "eb"}
+    assert Integer.parse("10", 2) === {2, ""}
+    assert Integer.parse("++4", 10) === :error
+
+    # Base should be in range 2..36
+    assert_raise ArgumentError, "invalid base 1", fn -> Integer.parse("2", 1) end
+    assert_raise ArgumentError, "invalid base 37", fn -> Integer.parse("2", 37) end
+
+    # Base should be an integer
+    assert_raise ArgumentError, "invalid base 10.2", fn -> Integer.parse("2", 10.2) end
+
+    assert_raise ArgumentError, "invalid base nil", fn -> Integer.parse("2", nil) end
+  end
+
+  test "to_string/2" do
+    assert Integer.to_string(42) == "42"
+    assert Integer.to_string(+42) == "42"
+    assert Integer.to_string(-42) == "-42"
+    assert Integer.to_string(-0001) == "-1"
+
+    for n <- [42.0, :forty_two, ~c"42", "42"] do
+      assert_raise ArgumentError, fn ->
+        Integer.to_string(n)
+      end
+    end
+
+    assert Integer.to_string(42, 2) == "101010"
+    assert Integer.to_string(42, 10) == "42"
+    assert Integer.to_string(42, 16) == "2A"
+    assert Integer.to_string(+42, 16) == "2A"
+    assert Integer.to_string(-42, 16) == "-2A"
+    assert Integer.to_string(-042, 16) == "-2A"
+
+    for n <- [42.0, :forty_two, ~c"42", "42"] do
+      assert_raise ArgumentError, fn ->
+        Integer.to_string(n, 42)
+      end
+    end
+
+    for n <- [-1, 0, 1, 37] do
+      assert_raise ArgumentError, fn ->
+        Integer.to_string(42, n)
+      end
+
+      assert_raise ArgumentError, fn ->
+        Integer.to_string(n, n)
+      end
+    end
+  end
+
+  test "to_charlist/2" do
+    module = String.to_atom("Elixir.Integer")
+
+    assert Integer.to_charlist(42) == ~c"42"
+    assert Integer.to_charlist(+42) == ~c"42"
+    assert Integer.to_charlist(-42) == ~c"-42"
+    assert Integer.to_charlist(-0001) == ~c"-1"
+
+    for n <- [42.0, :forty_two, ~c"42", "42"] do
+      assert_raise ArgumentError, fn ->
+        Integer.to_charlist(n)
+      end
+    end
+
+    assert module.to_char_list(42) == ~c"42"
+    assert module.to_char_list(42, 2) == ~c"101010"
+
+    assert Integer.to_charlist(42, 2) == ~c"101010"
+    assert Integer.to_charlist(42, 10) == ~c"42"
+    assert Integer.to_charlist(42, 16) == ~c"2A"
+    assert Integer.to_charlist(+42, 16) == ~c"2A"
+    assert Integer.to_charlist(-42, 16) == ~c"-2A"
+    assert Integer.to_charlist(-042, 16) == ~c"-2A"
+
+    for n <- [42.0, :forty_two, ~c"42", "42"] do
+      assert_raise ArgumentError, fn ->
+        Integer.to_charlist(n, 42)
+      end
+    end
+
+    for n <- [-1, 0, 1, 37] do
+      assert_raise ArgumentError, fn ->
+        Integer.to_charlist(42, n)
+      end
+
+      assert_raise ArgumentError, fn ->
+        Integer.to_charlist(n, n)
+      end
+    end
+  end
+
+  test "gcd/2" do
+    assert Integer.gcd(1, 5) == 1
+    assert Integer.gcd(2, 3) == 1
+    assert Integer.gcd(8, 12) == 4
+    assert Integer.gcd(-8, 12) == 4
+    assert Integer.gcd(8, -12) == 4
+    assert Integer.gcd(-8, -12) == 4
+    assert Integer.gcd(27, 27) == 27
+    assert Integer.gcd(-27, -27) == 27
+    assert Integer.gcd(-27, 27) == 27
+    assert Integer.gcd(0, 3) == 3
+    assert Integer.gcd(0, -3) == 3
+    assert Integer.gcd(3, 0) == 3
+    assert Integer.gcd(-3, 0) == 3
+    assert Integer.gcd(0, 0) == 0
+  end
+
+  test "extended_gcd" do
+    # Poor's man properby based testing
+    for _ <- 1..100 do
+      left = :rand.uniform(1000)
+      right = :rand.uniform(1000)
+      {gcd, m, n} = Integer.extended_gcd(left, right)
+      assert Integer.gcd(left, right) == gcd
+      assert m * left + n * right == gcd
+    end
   end
 end
diff --git a/lib/elixir/test/elixir/io/ansi/docs_test.exs b/lib/elixir/test/elixir/io/ansi/docs_test.exs
index 66173bc3b5c..23ace94e8c1 100644
--- a/lib/elixir/test/elixir/io/ansi/docs_test.exs
+++ b/lib/elixir/test/elixir/io/ansi/docs_test.exs
@@ -1,219 +1,668 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule IO.ANSI.DocsTest do
   use ExUnit.Case, async: true
   import ExUnit.CaptureIO
 
-  def format_heading(str) do
-    capture_io(fn -> IO.ANSI.Docs.print_heading(str, []) end) |> String.strip
-  end
-
-  def format(str) do
-    capture_io(fn -> IO.ANSI.Docs.print(str, []) end) |> String.strip
-  end
-
-  test "heading is formatted" do
-    result = format_heading("wibble")
-    assert String.starts_with?(result, "\e[0m\n\e[7m\e[33m\e[1m")
-    assert String.ends_with?(result, "\e[0m\n\e[0m")
-    assert String.contains?(result, " wibble ")
-  end
-
-  test "first level heading is converted" do
-    result = format("# wibble\n\ntext\n")
-    assert result == "\e[33m\e[1mWIBBLE\e[0m\n\e[0m\ntext\n\e[0m"
-  end
-
-  test "second level heading is converted" do
-    result = format("## wibble\n\ntext\n")
-    assert result == "\e[33m\e[1mwibble\e[0m\n\e[0m\ntext\n\e[0m"
-  end
-
-  test "third level heading is converted" do
-    result = format("## wibble\n\ntext\n")
-    assert result == "\e[33m\e[1mwibble\e[0m\n\e[0m\ntext\n\e[0m"
-  end
-
-  test "code block is converted" do
-    result = format("line\n\n    code\n    code2\n\nline2\n")
-    assert result == "line\n\e[0m\n\e[36m\e[1m┃ code\n┃ code2\e[0m\n\e[0m\nline2\n\e[0m"
-  end
-
-  test "* list is converted" do
-    result = format("* one\n* two\n* three\n")
-    assert result == "• one\n• two\n• three\n\e[0m"
-  end
-
-  test "* list surrounded by text is converted" do
-    result = format("Count:\n\n* one\n* two\n* three\n\nDone")
-    assert result == "Count:\n\e[0m\n• one\n• two\n• three\n\e[0m\nDone\n\e[0m"
-  end
-
-  test "* list with continuation is converted" do
-    result = format("* one\n  two\n  three\n* four")
-    assert result == "• one two three\n• four"
-  end
-
-  test "* nested lists are converted" do
-    result = format("* one\n  * one.one\n  * one.two\n* two")
-    assert result == "• one\n  • one.one\n  • one.two\n• two"
-  end
-
-  test "* lists with spaces are converted" do
-    result = format("  * one\n  * two\n  * three")
-    assert result == "• one\n• two\n• three"
-  end
+  def format_headings(list) do
+    capture_io(fn -> IO.ANSI.Docs.print_headings(list, []) end) |> String.trim_trailing()
+  end
+
+  def format_metadata(map) do
+    capture_io(fn -> IO.ANSI.Docs.print_metadata(map, []) end)
+  end
+
+  def format_markdown(str, opts \\ []) do
+    capture_io(fn -> IO.ANSI.Docs.print(str, "text/markdown", opts) end)
+    |> String.trim_trailing()
+  end
+
+  describe "heading" do
+    test "is formatted" do
+      result = format_headings(["foo"])
+      assert String.starts_with?(result, "\e[0m\n\e[7m\e[33m")
+      assert String.ends_with?(result, "\e[0m\n\e[0m")
+      assert String.contains?(result, " foo ")
+    end
+
+    test "multiple entries formatted" do
+      result = format_headings(["foo", "bar"])
+      assert :binary.matches(result, "\e[0m\n\e[7m\e[33m") |> length() == 2
+      assert String.starts_with?(result, "\e[0m\n\e[7m\e[33m")
+      assert String.ends_with?(result, "\e[0m\n\e[0m")
+      assert String.contains?(result, " foo ")
+      assert String.contains?(result, " bar ")
+    end
+
+    test "is correctly formatted when newline character is present" do
+      result = format_headings(["foo\nbar"])
+      assert :binary.matches(result, "\e[0m\n\e[7m\e[33m") |> length() == 2
+      assert ["\e[0m", foo_line, bar_line, "\e[0m"] = String.split(result, "\n")
+      assert Regex.match?(~r/\e\[7m\e\[33m +foo +\e\[0m/, foo_line)
+      assert Regex.match?(~r/\e\[7m\e\[33m +bar +\e\[0m/, bar_line)
+    end
+  end
+
+  describe "metadata" do
+    test "is formatted" do
+      result =
+        format_metadata(%{
+          since: "1.2.3",
+          deprecated: "Use that other one",
+          author: "Alice",
+          delegate_to: {Foo, :bar, 3}
+        })
+
+      assert result == """
+             \e[33mdelegate_to:\e[0m Foo.bar/3
+             \e[33mdeprecated:\e[0m Use that other one
+             \e[33msince:\e[0m 1.2.3
+
+             """
+
+      assert format_metadata(%{author: "Alice"}) == ""
+    end
+  end
+
+  describe "markdown" do
+    test "first level heading is converted" do
+      result = format_markdown("# wibble\n\ntext\n")
+      assert result == "\e[33m# wibble\e[0m\n\e[0m\ntext\n\e[0m"
+    end
+
+    test "second level heading is converted" do
+      result = format_markdown("## wibble\n\ntext\n")
+      assert result == "\e[33m## wibble\e[0m\n\e[0m\ntext\n\e[0m"
+    end
+
+    test "third level heading is converted" do
+      result = format_markdown("### wibble\n\ntext\n")
+      assert result == "\e[33m### wibble\e[0m\n\e[0m\ntext\n\e[0m"
+    end
+
+    test "short single-line quote block is converted into single-line quote" do
+      result =
+        format_markdown("""
+        line
+
+        > normal *italics* `code`
+
+        line2
+        """)
+
+      assert result ==
+               """
+               line
+               \e[0m
+               \e[90m> \e[0mnormal \e[4mitalics\e[0m \e[36mcode\e[0m
+               \e[0m
+               line2
+               \e[0m\
+               """
+    end
+
+    test "short multi-line quote block is converted into single-line quote" do
+      result =
+        format_markdown("""
+        line
+
+        > normal
+        > *italics*
+        > `code`
+
+        line2
+        """)
+
+      assert result ==
+               """
+               line
+               \e[0m
+               \e[90m> \e[0mnormal \e[4mitalics\e[0m \e[36mcode\e[0m
+               \e[0m
+               line2
+               \e[0m\
+               """
+    end
+
+    test "long multi-line quote block is converted into wrapped multi-line quote" do
+      result =
+        format_markdown("""
+        line
+
+        > normal
+        > *italics*
+        > `code`
+        > some-extremely-long-word-which-can-not-possibly-fit-into-the-previous-line
+
+        line2
+        """)
+
+      assert result ==
+               """
+               line
+               \e[0m
+               \e[90m> \e[0mnormal \e[4mitalics\e[0m \e[36mcode\e[0m
+               \e[90m> \e[0msome-extremely-long-word-which-can-not-possibly-fit-into-the-previous-line
+               \e[0m
+               line2
+               \e[0m\
+               """
+    end
+
+    test "multi-line quote block containing empty lines is converted into wrapped multi-line quote" do
+      result =
+        format_markdown("""
+        line
+
+        > normal
+        > *italics*
+        >
+        > `code`
+        > some-extremely-long-word-which-can-not-possibly-fit-into-the-previous-line
+
+        line2
+        """)
+
+      assert result ==
+               """
+               line
+               \e[0m
+               \e[90m> \e[0mnormal \e[4mitalics\e[0m
+               \e[90m> \e[0m
+               \e[90m> \e[0m\e[36mcode\e[0m
+               \e[90m> \e[0msome-extremely-long-word-which-can-not-possibly-fit-into-the-previous-line
+               \e[0m
+               line2
+               \e[0m\
+               """
+    end
+
+    test "code block is converted" do
+      result = format_markdown("line\n\n    code\n    code2\n\nline2\n")
+      assert result == "line\n\e[0m\n\e[36m    code\n    code2\e[0m\n\e[0m\nline2\n\e[0m"
+    end
+
+    test "fenced code block is converted" do
+      result = format_markdown("line\n```\ncode\ncode2\n```\nline2\n")
+      assert result == "line\n\e[0m\n\e[36m    code\n    code2\e[0m\n\e[0m\nline2\n\e[0m"
+      result = format_markdown("line\n```elixir\ncode\ncode2\n```\nline2\n")
+      assert result == "line\n\e[0m\n\e[36m    code\n    code2\e[0m\n\e[0m\nline2\n\e[0m"
+    end
+
+    test "mermaid fenced code block is discarded" do
+      result = format_markdown("line\n```mermaid\ncode\ncode2\n```\nline2\n")
+      assert result == "line\n\e[0m\nline2\n\e[0m"
+    end
+
+    test "* list is converted" do
+      result = format_markdown("* one\n* two\n* three\n")
+      assert result == "  • one\n  • two\n  • three\n\e[0m"
+    end
+
+    test "* list is converted without ansi" do
+      result = format_markdown("* one\n* two\n* three\n", enabled: false)
+      assert result == "  * one\n  * two\n  * three"
+    end
+
+    test "* list surrounded by text is converted" do
+      result = format_markdown("Count:\n\n* one\n* two\n* three\n\nDone")
+      assert result == "Count:\n\e[0m\n  • one\n  • two\n  • three\n\e[0m\nDone\n\e[0m"
+    end
+
+    test "* list with continuation is converted" do
+      result = format_markdown("* one\ntwo\n\n    three\nfour\n* five")
+      assert result == "  • one two\n    three four\n\e[0m\n  • five\n\e[0m"
+    end
+
+    test "* nested lists are converted" do
+      result = format_markdown("* one\n  * one.one\n  * one.two\n* two")
+      assert result == "  • one\n    • one.one\n    • one.two\n\e[0m\n  • two\n\e[0m"
+    end
+
+    test "* deep nested lists are converted" do
+      result =
+        format_markdown("""
+          * level 1
+            * level 2a
+            * level 2b
+              * level 3
+                * level 4a
+                * level 4b
+                  * level 5
+                    * level 6
+        """)
+
+      assert result ==
+               "  • level 1\n    • level 2a\n    • level 2b\n      • level 3\n        • level 4a\n        • level 4b\n          • level 5\n            • level 6\n\e[0m\n\e[0m\n\e[0m\n\e[0m\n\e[0m\n\e[0m"
+    end
+
+    test "* lists with spaces are converted" do
+      result = format_markdown("  * one\n  * two\n  * three")
+      assert result == "  • one\n  • two\n  • three\n\e[0m"
+    end
+
+    test "* lists with code" do
+      result = format_markdown("  * one\n        two three")
+      assert result == "  • one\n\e[36m        two three\e[0m\n\e[0m\n\e[0m"
+    end
+
+    test "- list is converted" do
+      result = format_markdown("- one\n- two\n- three\n")
+      assert result == "  • one\n  • two\n  • three\n\e[0m"
+    end
+
+    test "+ list is converted" do
+      result = format_markdown("+ one\n+ two\n+ three\n")
+      assert result == "  • one\n  • two\n  • three\n\e[0m"
+    end
+
+    test "+ and - nested lists are converted" do
+      result = format_markdown("- one\n  + one.one\n  + one.two\n- two")
+      assert result == "  • one\n    • one.one\n    • one.two\n\e[0m\n  • two\n\e[0m"
+    end
+
+    test "paragraphs are split" do
+      result = format_markdown("para1\n\npara2")
+      assert result == "para1\n\e[0m\npara2\n\e[0m"
+    end
+
+    test "extra whitespace is ignored between paras" do
+      result = format_markdown("para1\n   \npara2")
+      assert result == "para1\n\e[0m\npara2\n\e[0m"
+    end
+
+    test "extra whitespace doesn't mess up a following list" do
+      result = format_markdown("para1\n   \n* one\n* two")
+      assert result == "para1\n\e[0m\n  • one\n  • two\n\e[0m"
+    end
+
+    test "star/underscore/backtick works" do
+      result = format_markdown("*world*")
+      assert result == "\e[4mworld\e[0m\n\e[0m"
+
+      result = format_markdown("*world*.")
+      assert result == "\e[4mworld\e[0m.\n\e[0m"
+
+      result = format_markdown("**world**")
+      assert result == "\e[1mworld\e[0m\n\e[0m"
+
+      result = format_markdown("_world_")
+      assert result == "\e[4mworld\e[0m\n\e[0m"
+
+      result = format_markdown("__world__")
+      assert result == "\e[1mworld\e[0m\n\e[0m"
+
+      result = format_markdown("`world`")
+      assert result == "\e[36mworld\e[0m\n\e[0m"
+    end
+
+    test "star/underscore/backtick works across words" do
+      result = format_markdown("*hello world*")
+      assert result == "\e[4mhello world\e[0m\n\e[0m"
+
+      result = format_markdown("**hello world**")
+      assert result == "\e[1mhello world\e[0m\n\e[0m"
+
+      result = format_markdown("_hello world_")
+      assert result == "\e[4mhello world\e[0m\n\e[0m"
+
+      result = format_markdown("__hello world__")
+      assert result == "\e[1mhello world\e[0m\n\e[0m"
+
+      result = format_markdown("`hello world`")
+      assert result == "\e[36mhello world\e[0m\n\e[0m"
+    end
+
+    test "star/underscore/backtick works across words with ansi disabled" do
+      result = format_markdown("*hello world*", enabled: false)
+      assert result == "*hello world*"
+
+      result = format_markdown("**hello world**", enabled: false)
+      assert result == "**hello world**"
+
+      result = format_markdown("_hello world_", enabled: false)
+      assert result == "_hello world_"
+
+      result = format_markdown("__hello world__", enabled: false)
+      assert result == "__hello world__"
 
-  test "- list is converted" do
-    result = format("- one\n- two\n- three\n")
-    assert result == "• one\n• two\n• three\n\e[0m"
-  end
+      result = format_markdown("`hello world`", enabled: false)
+      assert result == "`hello world`"
+    end
 
-  test "- list surrounded by text is converted" do
-    result = format("Count:\n\n- one\n- two\n- three\n\nDone")
-    assert result == "Count:\n\e[0m\n• one\n• two\n• three\n\e[0m\nDone\n\e[0m"
-  end
+    test "multiple stars/underscores/backticks work" do
+      result = format_markdown("*hello world* *hello world*")
+      assert result == "\e[4mhello world\e[0m \e[4mhello world\e[0m\n\e[0m"
 
-  test "- list with continuation is converted" do
-    result = format("- one\n  two\n  three\n- four")
-    assert result == "• one two three\n• four"
-  end
+      result = format_markdown("_hello world_ _hello world_")
+      assert result == "\e[4mhello world\e[0m \e[4mhello world\e[0m\n\e[0m"
 
-  test "+ list is converted" do
-    result = format("+ one\n+ two\n+ three\n")
-    assert result == "• one\n• two\n• three\n\e[0m"
-  end
+      result = format_markdown("`hello world` `hello world`")
+      assert result == "\e[36mhello world\e[0m \e[36mhello world\e[0m\n\e[0m"
+    end
 
-  test "+ and - nested lists are converted" do
-    result = format("- one\n  + one.one\n  + one.two\n- two")
-    assert result == "• one\n  • one.one\n  • one.two\n• two"
-  end
+    test "multiple stars/underscores/backticks work when separated by other words" do
+      result = format_markdown("*hello world* unit test *hello world*")
+      assert result == "\e[4mhello world\e[0m unit test \e[4mhello world\e[0m\n\e[0m"
 
-  test "paragraphs are split" do
-    result = format("para1\n\npara2")
-    assert result == "para1\n\e[0m\npara2\n\e[0m"
-  end
+      result = format_markdown("_hello world_ unit test _hello world_")
+      assert result == "\e[4mhello world\e[0m unit test \e[4mhello world\e[0m\n\e[0m"
 
-  test "extra whitespace is ignored between paras" do
-    result = format("para1\n   \npara2")
-    assert result == "para1\n\e[0m\npara2\n\e[0m"
-  end
+      result = format_markdown("`hello world` unit test `hello world`")
+      assert result == "\e[36mhello world\e[0m unit test \e[36mhello world\e[0m\n\e[0m"
+    end
 
-  test "extra whitespace doesn't mess up a following list" do
-    result = format("para1\n   \n* one\n* two")
-    assert result == "para1\n\e[0m\n• one\n• two"
-  end
+    test "star/underscore preceded by space doesn't get interpreted" do
+      result = format_markdown("_unit _size")
+      assert result == "_unit _size\n\e[0m"
 
-  test "star/underscore/backtick works" do
-    result = format("*world*")
-    assert result == "\e[1mworld\e[0m\n\e[0m"
+      result = format_markdown("**unit **size")
+      assert result == "**unit **size\n\e[0m"
 
-    result = format("**world**")
-    assert result == "\e[1mworld\e[0m\n\e[0m"
+      result = format_markdown("*unit *size")
+      assert result == "*unit *size\n\e[0m"
+    end
 
-    result = format("_world_")
-    assert result == "\e[4mworld\e[0m\n\e[0m"
+    test "star/underscore/backtick preceded by non-space delimiters gets interpreted" do
+      result = format_markdown("(`hello world`)")
+      assert result == "(\e[36mhello world\e[0m)\n\e[0m"
+      result = format_markdown("<`hello world`>")
+      assert result == "<\e[36mhello world\e[0m>\n\e[0m"
 
-    result = format("`world`")
-    assert result == "\e[36mworld\e[0m\n\e[0m"
-  end
+      result = format_markdown("(*hello world*)")
+      assert result == "(\e[4mhello world\e[0m)\n\e[0m"
+      result = format_markdown("@*hello world*@")
+      assert result == "@\e[4mhello world\e[0m@\n\e[0m"
 
-  test "star/underscore/backtick works accross words" do
-    result = format("*hello world*")
-    assert result == "\e[1mhello world\e[0m\n\e[0m"
+      result = format_markdown("(_hello world_)")
+      assert result == "(\e[4mhello world\e[0m)\n\e[0m"
+      result = format_markdown("'_hello world_'")
+      assert result == "'\e[4mhello world\e[0m'\n\e[0m"
+    end
 
-    result = format("**hello world**")
-    assert result == "\e[1mhello world\e[0m\n\e[0m"
+    test "star/underscore/backtick starts/ends within a word doesn't get interpreted" do
+      result = format_markdown("foo_bar, foo_bar_baz!")
+      assert result == "foo_bar, foo_bar_baz!\n\e[0m"
 
-    result = format("_hello world_")
-    assert result == "\e[4mhello world\e[0m\n\e[0m"
+      result = format_markdown("_foo_bar")
+      assert result == "_foo_bar\n\e[0m"
 
-    result = format("`hello world`")
-    assert result == "\e[36mhello world\e[0m\n\e[0m"
-  end
+      result = format_markdown("foo_bar_")
+      assert result == "foo_bar_\n\e[0m"
 
-  test "star/underscore preceeded by space doesn't get interpreted" do
-    result = format("_unit _size")
-    assert result == "_unit _size\n\e[0m"
+      result = format_markdown("foo*bar, foo*bar*baz!")
+      assert result == "foo*bar, foo*bar*baz!\n\e[0m"
 
-    result = format("**unit **size")
-    assert result == "**unit **size\n\e[0m"
+      result = format_markdown("*foo*bar")
+      assert result == "*foo*bar\n\e[0m"
 
-    result = format("*unit *size")
-    assert result == "*unit *size\n\e[0m"
-  end
+      result = format_markdown("foo*bar*")
+      assert result == "foo*bar*\n\e[0m"
+    end
 
-  test "backtick preceeded by space gets interpreted" do
-    result = format("`unit `size")
-    assert result == "\e[36munit \e[0msize\n\e[0m"
-  end
-
-  test "star/underscore/backtick with leading escape" do
-    result = format("\\_unit_")
-    assert result == "_unit_\n\e[0m"
-
-    result = format("\\*unit*")
-    assert result == "*unit*\n\e[0m"
+    test "backtick preceded by space gets interpreted" do
+      result = format_markdown("`unit `size")
+      assert result == "\e[36munit \e[0msize\n\e[0m"
+    end
 
-    result = format("\\`unit`")
-    assert result == "`unit`\n\e[0m"
-  end
+    test "backtick does not escape characters" do
+      result = format_markdown("`Ctrl+\\ `")
+      assert result == "\e[36mCtrl+\\ \e[0m\n\e[0m"
+    end
 
-  test "star/underscore/backtick with closing escape" do
-    result = format("_unit\\_")
-    assert result == "_unit_\n\e[0m"
+    test "star/underscore/backtick with leading escape" do
+      result = format_markdown("\\_unit_")
+      assert result == "_unit_\n\e[0m"
 
-    result = format("*unit\\*")
-    assert result == "*unit*\n\e[0m"
+      result = format_markdown("\\*unit*")
+      assert result == "*unit*\n\e[0m"
 
-    result = format("`unit\\`")
-    assert result == "\e[36munit\\\e[0m\n\e[0m"
-  end
+      result = format_markdown("\\`unit`")
+      assert result == "`unit`\n\e[0m"
+    end
 
-  test "star/underscore/backtick with double escape" do
-    result = format("\\\\*world*")
-    assert result == "\\\e[1mworld\e[0m\n\e[0m"
+    test "star/underscore/backtick with closing escape" do
+      result = format_markdown("_unit\\_")
+      assert result == "_unit_\n\e[0m"
 
-    result = format("\\\\_world_")
-    assert result == "\\\e[4mworld\e[0m\n\e[0m"
+      result = format_markdown("*unit\\*")
+      assert result == "*unit*\n\e[0m"
 
-    result = format("\\\\`world`")
-    assert result == "\\\e[36mworld\e[0m\n\e[0m"
-  end
+      result = format_markdown("`unit\\`")
+      assert result == "\e[36munit\\\e[0m\n\e[0m"
+    end
 
-  test "star/underscore/backtick when incomplete" do
-    result = format("unit_size")
-    assert result == "unit_size\n\e[0m"
+    test "star/underscore/backtick with double escape" do
+      result = format_markdown("\\\\*world*")
+      assert result == "\\\e[4mworld\e[0m\n\e[0m"
+
+      result = format_markdown("\\\\_world_")
+      assert result == "\\\e[4mworld\e[0m\n\e[0m"
+
+      result = format_markdown("\\\\`world`")
+      assert result == "\\\e[36mworld\e[0m\n\e[0m"
+    end
+
+    test "star/underscore/backtick when incomplete" do
+      result = format_markdown("unit_size")
+      assert result == "unit_size\n\e[0m"
+
+      result = format_markdown("unit`size")
+      assert result == "unit`size\n\e[0m"
+
+      result = format_markdown("unit*size")
+      assert result == "unit*size\n\e[0m"
+
+      result = format_markdown("unit**size")
+      assert result == "unit**size\n\e[0m"
+    end
+
+    test "backtick with escape" do
+      result = format_markdown("`\\`")
+      assert result == "\e[36m\\\e[0m\n\e[0m"
+    end
+
+    test "backtick close to underscores gets interpreted as code" do
+      result = format_markdown("`__world__`")
+      assert result == "\e[36m__world__\e[0m\n\e[0m"
+    end
+
+    test "escaping of underlines within links" do
+      result = format_markdown("(https://en.wikipedia.org/wiki/ANSI_escape_code)")
+      assert result == "(https://en.wikipedia.org/wiki/ANSI_escape_code)\n\e[0m"
+
+      result =
+        format_markdown("[ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code)")
+
+      assert result == "ANSI escape code (https://en.wikipedia.org/wiki/ANSI_escape_code)\n\e[0m"
+
+      result = format_markdown("(ftp://example.com/ANSI_escape_code.zip)")
+      assert result == "(ftp://example.com/ANSI_escape_code.zip)\n\e[0m"
+    end
+
+    test "escaping of underlines within links does not escape surrounding text" do
+      result =
+        format_markdown(
+          "_emphasis_ (https://en.wikipedia.org/wiki/ANSI_escape_code) more _emphasis_"
+        )
+
+      assert result ==
+               "\e[4memphasis\e[0m (https://en.wikipedia.org/wiki/ANSI_escape_code) more \e[4memphasis\e[0m\n\e[0m"
+    end
+
+    test "escaping of underlines within links avoids false positives" do
+      assert format_markdown("`https_proxy`") == "\e[36mhttps_proxy\e[0m\n\e[0m"
+    end
+
+    test "escaping of several Markdown links in one line" do
+      assert format_markdown("[List](`List`) (`[1, 2, 3]`), [Map](`Map`)") ==
+               "List (\e[36mList\e[0m) (\e[36m[1, 2, 3]\e[0m), Map (\e[36mMap\e[0m)\n\e[0m"
+    end
+
+    test "one reference link label per line" do
+      assert format_markdown("  [id]: //example.com\n  [Elixir]:  https://elixir-lang.org") ==
+               "  [id]: //example.com\n  [Elixir]:  https://elixir-lang.org"
+    end
+  end
+
+  describe "markdown tables" do
+    test "lone thing that looks like a table line isn't" do
+      assert format_markdown("one\n2 | 3\ntwo\n") == "one 2 | 3 two\n\e[0m"
+    end
+
+    test "lone table line at end of input isn't" do
+      assert format_markdown("one\n2 | 3") == "one 2 | 3\n\e[0m"
+    end
+
+    test "two successive table lines are a table" do
+      # note spacing
+      assert format_markdown("a | b\none | two\n") == "a   | b  \none | two\n\e[0m"
+    end
+
+    test "table with heading" do
+      assert format_markdown("column 1 | and 2\n-- | --\na | b\none | two\n") ==
+               "\e[7mcolumn 1 | and 2\e[0m\na        | b    \none      | two  \n\e[0m"
+    end
+
+    test "table with heading alignment" do
+      table = """
+      column 1 | 2        | and three
+      -------: | :------: | :-----
+          a    |  even    | c\none | odd | three
+      """
+
+      expected =
+        """
+        \e[7mcolumn 1 |   2   | and three\e[0m
+               a | even  | c\s\s\s\s\s\s\s\s
+             one |  odd  | three\s\s\s\s
+        \e[0m
+        """
+        |> String.trim_trailing()
+
+      assert format_markdown(table) == expected
+    end
+
+    test "table with heading alignment and no space around \"|\"" do
+      table = """
+      | Value | Encoding | Value | Encoding |
+      |------:|:---------|------:|:---------|
+      |     0 | A        |    17 | R        |
+      |     1 | B        |    18 | S        |
+      """
+
+      expected =
+        "\e[7m" <>
+          "Value | Encoding | Value | Encoding\e[0m\n" <>
+          "    0 | A        |    17 | R       \n" <>
+          "    1 | B        |    18 | S       \n\e[0m"
+
+      assert format_markdown(table) == expected
+    end
+
+    test "table with formatting in cells" do
+      assert format_markdown("`a` | _b_\nc | d") == "\e[36ma\e[0m | \e[4mb\e[0m\nc | d\n\e[0m"
+
+      assert format_markdown("`abc` | d \n`e` | f") ==
+               "\e[36mabc\e[0m | d\n\e[36me\e[0m   | f\n\e[0m"
+    end
+
+    test "table with variable number of columns" do
+      assert format_markdown("a | b | c\nd | e") == "a | b | c\nd | e |  \n\e[0m"
+    end
+
+    test "table with escaped \"|\" inside cell" do
+      table = "a | smth\\|smth_else | c\nd | e | f"
+
+      expected =
+        """
+        a | smth|smth_else | c
+        d | e              | f
+        \e[0m
+        """
+        |> String.trim_trailing()
+
+      assert format_markdown(table) == expected
+    end
+
+    test "table with last two columns empty" do
+      table = """
+      AAA |     |     |
+      BBB | CCC |     |
+      GGG | HHH | III |
+      JJJ | KKK | LLL | MMM
+      """
+
+      expected =
+        """
+        AAA |     |     |\s\s\s\s
+        BBB | CCC |     |\s\s\s\s
+        GGG | HHH | III |\s\s\s\s
+        JJJ | KKK | LLL | MMM
+        \e[0m
+        """
+        |> String.trim_trailing()
+
+      assert format_markdown(table) == expected
+    end
+
+    test "HTML comments are ignored" do
+      markdown = """
+      <!-- comment -->
+      hello
+      """
+
+      assert format_markdown(markdown) == "hello\n\e[0m"
+
+      markdown = """
+      <!-- comment -->
+
+      hello
+      """
+
+      assert format_markdown(markdown) == "hello\n\e[0m"
+
+      markdown = """
+      hello
+      <!-- comment -->
+      world
+      """
+
+      assert format_markdown(markdown) == "hello\n\e[0m\nworld\n\e[0m"
+
+      markdown = """
+      hello
+
+      <!-- comment -->
+
+      world
+      """
 
-    result = format("unit`size")
-    assert result == "unit`size\n\e[0m"
+      assert format_markdown(markdown) == "hello\n\e[0m\nworld\n\e[0m"
 
-    result = format("unit*size")
-    assert result == "unit*size\n\e[0m"
+      markdown = """
+      hello
+      <!-- comment --> world
+      """
+
+      assert format_markdown(markdown) == "hello world\n\e[0m"
 
-    result = format("unit**size")
-    assert result == "unit**size\n\e[0m"
-  end
-
-  test "backtick with escape" do
-    result = format("`\\`")
-    assert result == "\e[36m\\\e[0m\n\e[0m"
-  end
-
-  test "backtick close to underscores gets interpreted as code" do
-    result = format("`__world__`")
-    assert result == "\e[36m__world__\e[0m\n\e[0m"
-  end
+      markdown = """
+      hello <!-- comment --> world
+      """
 
-  test "backtick works inside parenthesis" do
-    result = format("(`hello world`)")
-    assert result == "(\e[36mhello world\e[0m)\n\e[0m"
+      assert format_markdown(markdown) == "hello  world\n\e[0m"
+    end
   end
 
-  test "escaping of underlines within links" do
-    result = format("(http://en.wikipedia.org/wiki/ANSI_escape_code)")
-    assert result == "(http://en.wikipedia.org/wiki/ANSI_escape_code)\n\e[0m"
-    result = format("[ANSI escape code](http://en.wikipedia.org/wiki/ANSI_escape_code)")
-    assert result == "ANSI escape code (http://en.wikipedia.org/wiki/ANSI_escape_code)\n\e[0m"
+  describe "invalid format" do
+    test "prints message" do
+      assert capture_io(fn -> IO.ANSI.Docs.print("hello", "text/unknown", []) end) ==
+               "\nUnknown documentation format \"text/unknown\"\n\n"
+    end
   end
 end
diff --git a/lib/elixir/test/elixir/io/ansi_test.exs b/lib/elixir/test/elixir/io/ansi_test.exs
index f05a0679985..ecafe2196a1 100644
--- a/lib/elixir/test/elixir/io/ansi_test.exs
+++ b/lib/elixir/test/elixir/io/ansi_test.exs
@@ -1,54 +1,239 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule IO.ANSITest do
   use ExUnit.Case, async: true
 
-  test :escape_single do
-    assert IO.ANSI.escape("Hello, %{red}world!", true) ==
-           "Hello, #{IO.ANSI.red}world!#{IO.ANSI.reset}"
-    assert IO.ANSI.escape("Hello, %{red}world!", true) ==
-           "Hello, #{IO.ANSI.red}world!#{IO.ANSI.reset}"
+  doctest IO.ANSI
+
+  test "format ansicode" do
+    assert IO.chardata_to_string(IO.ANSI.format(:green, true)) ==
+             "#{IO.ANSI.green()}#{IO.ANSI.reset()}"
+
+    assert IO.chardata_to_string(IO.ANSI.format(:green, false)) == ""
+  end
+
+  test "format binary" do
+    assert IO.chardata_to_string(IO.ANSI.format("Hello, world!", true)) == "Hello, world!"
+
+    assert IO.chardata_to_string(IO.ANSI.format("A map: %{foo: :bar}", false)) ==
+             "A map: %{foo: :bar}"
+  end
+
+  test "format empty list" do
+    assert IO.chardata_to_string(IO.ANSI.format([], true)) == ""
+    assert IO.chardata_to_string(IO.ANSI.format([], false)) == ""
+  end
+
+  test "format ansicode list" do
+    assert IO.chardata_to_string(IO.ANSI.format([:red, :bright], true)) ==
+             "#{IO.ANSI.red()}#{IO.ANSI.bright()}#{IO.ANSI.reset()}"
+
+    assert IO.chardata_to_string(IO.ANSI.format([:red, :bright], false)) == ""
+  end
+
+  test "format binary list" do
+    assert IO.chardata_to_string(IO.ANSI.format(["Hello, ", "world!"], true)) == "Hello, world!"
+    assert IO.chardata_to_string(IO.ANSI.format(["Hello, ", "world!"], false)) == "Hello, world!"
+  end
+
+  test "format charlist" do
+    assert IO.chardata_to_string(IO.ANSI.format(~c"Hello, world!", true)) == "Hello, world!"
+    assert IO.chardata_to_string(IO.ANSI.format(~c"Hello, world!", false)) == "Hello, world!"
+  end
+
+  test "format mixed list" do
+    data = ["Hello", ?,, 32, :red, "world!"]
+
+    assert IO.chardata_to_string(IO.ANSI.format(data, true)) ==
+             "Hello, #{IO.ANSI.red()}world!#{IO.ANSI.reset()}"
+
+    assert IO.chardata_to_string(IO.ANSI.format(data, false)) == "Hello, world!"
+  end
+
+  test "format nested list" do
+    data = ["Hello, ", ["nested", 32, :red, "world!"]]
+
+    assert IO.chardata_to_string(IO.ANSI.format(data, true)) ==
+             "Hello, nested #{IO.ANSI.red()}world!#{IO.ANSI.reset()}"
+
+    assert IO.chardata_to_string(IO.ANSI.format(data, false)) == "Hello, nested world!"
+  end
+
+  test "format improper list" do
+    data = ["Hello, ", :red, "world" | "!"]
+
+    assert IO.chardata_to_string(IO.ANSI.format(data, true)) ==
+             "Hello, #{IO.ANSI.red()}world!#{IO.ANSI.reset()}"
+
+    assert IO.chardata_to_string(IO.ANSI.format(data, false)) == "Hello, world!"
+  end
+
+  test "format nested improper list" do
+    data = [["Hello, " | :red], "world!" | :green]
+
+    assert IO.chardata_to_string(IO.ANSI.format(data, true)) ==
+             "Hello, #{IO.ANSI.red()}world!#{IO.ANSI.green()}#{IO.ANSI.reset()}"
+
+    assert IO.chardata_to_string(IO.ANSI.format(data, false)) == "Hello, world!"
+  end
+
+  test "format fragment" do
+    assert IO.chardata_to_string(IO.ANSI.format_fragment([:red, "Hello!"], true)) ==
+             "#{IO.ANSI.red()}Hello!"
+  end
+
+  test "format invalid sequence" do
+    assert_raise ArgumentError, "invalid ANSI sequence specification: :brigh", fn ->
+      IO.ANSI.format([:brigh, "Hello!"], true)
+    end
+
+    assert_raise ArgumentError, "invalid ANSI sequence specification: nil", fn ->
+      IO.ANSI.format(["Hello!", nil], true)
+    end
+
+    assert_raise ArgumentError, "invalid ANSI sequence specification: :brigh", fn ->
+      IO.ANSI.format([:brigh, "Hello!"], false)
+    end
+
+    assert_raise ArgumentError, "invalid ANSI sequence specification: nil", fn ->
+      IO.ANSI.format(["Hello!", nil], false)
+    end
+
+    assert_raise ArgumentError, "invalid ANSI sequence specification: :invalid", fn ->
+      IO.ANSI.format(:invalid, false)
+    end
   end
 
-  test :escape_non_attribute do
-    assert IO.ANSI.escape("Hello %{clear}world!", true) ==
-           "Hello #{IO.ANSI.clear}world!#{IO.ANSI.reset}"
-    assert IO.ANSI.escape("Hello %{home}world!", true) ==
-           "Hello #{IO.ANSI.home}world!#{IO.ANSI.reset}"
+  test "colors" do
+    assert IO.ANSI.red() == "\e[31m"
+    assert IO.ANSI.light_red() == "\e[91m"
+
+    assert IO.ANSI.red_background() == "\e[41m"
+    assert IO.ANSI.light_red_background() == "\e[101m"
   end
 
-  test :escape_multiple do
-    assert IO.ANSI.escape("Hello, %{red,bright}world!", true) ==
-           "Hello, #{IO.ANSI.red}#{IO.ANSI.bright}world!#{IO.ANSI.reset}"
-    assert IO.ANSI.escape("Hello, %{red, bright}world!", true) ==
-           "Hello, #{IO.ANSI.red}#{IO.ANSI.bright}world!#{IO.ANSI.reset}"
-    assert IO.ANSI.escape("Hello, %{red , bright}world!", true) ==
-           "Hello, #{IO.ANSI.red}#{IO.ANSI.bright}world!#{IO.ANSI.reset}"
+  test "color/1" do
+    assert IO.ANSI.color(0) == "\e[38;5;0m"
+    assert IO.ANSI.color(42) == "\e[38;5;42m"
+    assert IO.ANSI.color(255) == "\e[38;5;255m"
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.color(-1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.color(256)
+    end
   end
 
-  test :no_emit do
-    assert IO.ANSI.escape("Hello, %{}world!", false) ==
-           "Hello, world!"
+  test "color/3" do
+    assert IO.ANSI.color(0, 4, 2) == "\e[38;5;42m"
+    assert IO.ANSI.color(1, 1, 1) == "\e[38;5;59m"
+    assert IO.ANSI.color(5, 5, 5) == "\e[38;5;231m"
 
-    assert IO.ANSI.escape("Hello, %{red,bright}world!", false) ==
-           "Hello, world!"
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.color(0, 6, 1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.color(5, -1, 1)
+    end
   end
 
-  test :fragment do
-    assert IO.ANSI.escape("%{red}", true) == "#{IO.ANSI.red}#{IO.ANSI.reset}"
-    assert IO.ANSI.escape_fragment("", true) == ""
+  test "color_background/1" do
+    assert IO.ANSI.color_background(0) == "\e[48;5;0m"
+    assert IO.ANSI.color_background(42) == "\e[48;5;42m"
+    assert IO.ANSI.color_background(255) == "\e[48;5;255m"
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.color_background(-1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.color_background(256)
+    end
   end
 
-  test :noop do
-    assert IO.ANSI.escape("") == ""
+  test "color_background/3" do
+    assert IO.ANSI.color_background(0, 4, 2) == "\e[48;5;42m"
+    assert IO.ANSI.color_background(1, 1, 1) == "\e[48;5;59m"
+    assert IO.ANSI.color_background(5, 5, 5) == "\e[48;5;231m"
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.color_background(0, 6, 1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.color_background(5, -1, 1)
+    end
   end
 
-  test :invalid do
-    assert_raise ArgumentError, "invalid ANSI sequence specification: brigh", fn ->
-      IO.ANSI.escape("%{brigh}, yes")
+  test "cursor/2" do
+    assert IO.ANSI.cursor(0, 0) == "\e[0;0H"
+    assert IO.ANSI.cursor(11, 12) == "\e[11;12H"
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.cursor(-1, 5)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.cursor(5, -1)
     end
-    assert_raise ArgumentError, "invalid ANSI sequence specification: brigh", fn ->
-      IO.ANSI.escape("%{brigh,red}, yes")
+  end
+
+  test "cursor_up/1" do
+    assert IO.ANSI.cursor_up() == "\e[1A"
+    assert IO.ANSI.cursor_up(12) == "\e[12A"
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.cursor_up(0)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.cursor_up(-1)
+    end
+  end
+
+  test "cursor_down/1" do
+    assert IO.ANSI.cursor_down() == "\e[1B"
+    assert IO.ANSI.cursor_down(2) == "\e[2B"
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.cursor_right(0)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.cursor_down(-1)
+    end
+  end
+
+  test "cursor_left/1" do
+    assert IO.ANSI.cursor_left() == "\e[1D"
+    assert IO.ANSI.cursor_left(3) == "\e[3D"
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.cursor_left(0)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.cursor_left(-1)
+    end
+  end
+
+  test "cursor_right/1" do
+    assert IO.ANSI.cursor_right() == "\e[1C"
+    assert IO.ANSI.cursor_right(4) == "\e[4C"
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.cursor_right(0)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      IO.ANSI.cursor_right(-1)
     end
   end
 end
diff --git a/lib/elixir/test/elixir/io_test.exs b/lib/elixir/test/elixir/io_test.exs
index 7d46dbbf563..594d35feb80 100644
--- a/lib/elixir/test/elixir/io_test.exs
+++ b/lib/elixir/test/elixir/io_test.exs
@@ -1,29 +1,58 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule IOTest do
   use ExUnit.Case, async: true
+
+  doctest IO
+
   import ExUnit.CaptureIO
 
-  test :read_with_count do
-    {:ok, file} = File.open(Path.expand('fixtures/file.txt', __DIR__), [:char_list])
-    assert 'FOO' == IO.read(file, 3)
+  test "read with count" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/file.txt", __DIR__), [:charlist])
+    assert ~c"FOO" == IO.read(file, 3)
     assert File.close(file) == :ok
   end
 
-  test :read_with_utf8_and_binary do
-    {:ok, file} = File.open(Path.expand('fixtures/utf8.txt', __DIR__), [:utf8])
+  test "read with UTF-8 and binary" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/utf8.txt", __DIR__), [:utf8])
     assert "Русский" == IO.read(file, 7)
     assert File.close(file) == :ok
   end
 
-  test :binread do
-    {:ok, file} = File.open(Path.expand('fixtures/utf8.txt', __DIR__))
+  test "read all charlist" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/multiline_file.txt", __DIR__), [:charlist])
+    assert ~c"this is the first line\nthis is the second line\n" == IO.read(file, :eof)
+    assert File.close(file) == :ok
+  end
+
+  test "read empty file" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/cp_mode", __DIR__), [])
+    assert IO.read(file, :eof) == :eof
+    assert File.close(file) == :ok
+
+    {:ok, file} = File.open(Path.expand(~c"fixtures/cp_mode", __DIR__), [:charlist])
+    assert IO.read(file, :eof) == :eof
+    assert File.close(file) == :ok
+  end
+
+  test "binread" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/utf8.txt", __DIR__))
     assert "Русский" == IO.binread(file, 14)
     assert File.close(file) == :ok
   end
 
-  test :getn do
-    {:ok, file} = File.open(Path.expand('fixtures/file.txt', __DIR__))
+  test "binread eof" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/file.bin", __DIR__))
+    assert "LF\nCR\rCRLF\r\nLFCR\n\r" == IO.binread(file, :eof)
+    assert File.close(file) == :ok
+  end
+
+  test "getn" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/file.txt", __DIR__))
     assert "F" == IO.getn(file, "")
     assert "O" == IO.getn(file, "")
     assert "O" == IO.getn(file, "")
@@ -32,78 +61,221 @@ defmodule IOTest do
     assert File.close(file) == :ok
   end
 
-  test :getn_with_count do
-    {:ok, file} = File.open(Path.expand('fixtures/file.txt', __DIR__), [:char_list])
-    assert 'FOO' == IO.getn(file, "", 3)
+  test "getn with count" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/file.txt", __DIR__), [:charlist])
+    assert ~c"F" == IO.getn(file, "λ")
+    assert ~c"OO" == IO.getn(file, "", 2)
+    assert ~c"\n" == IO.getn(file, "λ", 99)
+    assert :eof == IO.getn(file, "λ", 1)
     assert File.close(file) == :ok
   end
 
-  test :getn_with_utf8_and_binary do
-    {:ok, file} = File.open(Path.expand('fixtures/utf8.txt', __DIR__), [:utf8])
+  test "getn with eof" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/file.txt", __DIR__), [:charlist])
+    assert ~c"F" == IO.getn(file, "λ")
+    assert ~c"OO\n" == IO.getn(file, "", :eof)
+    assert :eof == IO.getn(file, "", :eof)
+    assert File.close(file) == :ok
+  end
+
+  test "getn with UTF-8 and binary" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/utf8.txt", __DIR__), [:utf8])
     assert "Русский" == IO.getn(file, "", 7)
+    assert "\n日\n" == IO.getn(file, "", :eof)
+    assert :eof == IO.getn(file, "", :eof)
     assert File.close(file) == :ok
   end
 
-  test :gets do
-    {:ok, file} = File.open(Path.expand('fixtures/file.txt', __DIR__), [:char_list])
-    assert 'FOO\n' == IO.gets(file, "")
+  test "gets" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/file.txt", __DIR__), [:charlist])
+    assert ~c"FOO\n" == IO.gets(file, "")
     assert :eof == IO.gets(file, "")
     assert File.close(file) == :ok
   end
 
-  test :gets_with_utf8_and_binary do
-    {:ok, file} = File.open(Path.expand('fixtures/utf8.txt', __DIR__), [:utf8])
+  test "gets with UTF-8 and binary" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/utf8.txt", __DIR__), [:utf8])
     assert "Русский\n" == IO.gets(file, "")
     assert "日\n" == IO.gets(file, "")
     assert File.close(file) == :ok
   end
 
-  test :readline do
-    {:ok, file} = File.open(Path.expand('fixtures/file.txt', __DIR__))
+  test "read with eof" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/file.txt", __DIR__))
+    assert "FOO\n" == IO.read(file, :eof)
+    assert :eof == IO.read(file, :eof)
+    assert File.close(file) == :ok
+  end
+
+  test "read with eof and UTF-8 and binary" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/utf8.txt", __DIR__), [:utf8])
+    assert "Русский\n日\n" == IO.read(file, :eof)
+    assert :eof == IO.read(file, :eof)
+    assert File.close(file) == :ok
+  end
+
+  test "readline" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/file.txt", __DIR__))
     assert "FOO\n" == IO.read(file, :line)
     assert :eof == IO.read(file, :line)
     assert File.close(file) == :ok
   end
 
-  test :readline_with_utf8_and_binary do
-    {:ok, file} = File.open(Path.expand('fixtures/utf8.txt', __DIR__), [:utf8])
+  test "readline with UTF-8 and binary" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/utf8.txt", __DIR__), [:utf8])
     assert "Русский\n" == IO.read(file, :line)
     assert "日\n" == IO.read(file, :line)
     assert File.close(file) == :ok
   end
 
-  test :binreadline do
-    {:ok, file} = File.open(Path.expand('fixtures/utf8.txt', __DIR__))
+  test "binread with eof" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/utf8.txt", __DIR__))
+    assert "Русский\n日\n" == IO.binread(file, :eof)
+    assert :eof == IO.binread(file, :eof)
+    assert File.close(file) == :ok
+  end
+
+  test "binread with line" do
+    {:ok, file} = File.open(Path.expand(~c"fixtures/utf8.txt", __DIR__))
     assert "Русский\n" == IO.binread(file, :line)
     assert "日\n" == IO.binread(file, :line)
     assert File.close(file) == :ok
   end
 
-  test :puts_with_chardata do
+  test "puts with chardata" do
     assert capture_io(fn -> IO.puts("hello") end) == "hello\n"
-    assert capture_io(fn -> IO.puts('hello') end) == "hello\n"
+    assert capture_io(fn -> IO.puts(~c"hello") end) == "hello\n"
     assert capture_io(fn -> IO.puts(:hello) end) == "hello\n"
     assert capture_io(fn -> IO.puts(13) end) == "13\n"
   end
 
-  test :write_with_chardata do
+  describe "warn" do
+    test "with chardata" do
+      capture_io(:stderr, fn -> IO.warn("hello") end)
+      |> assert_emits(["hello", "(ex_unit #{System.version()}) lib/ex_unit"])
+
+      capture_io(:stderr, fn -> IO.warn(~c"hello") end)
+      |> assert_emits(["hello", "(ex_unit #{System.version()}) lib/ex_unit"])
+
+      capture_io(:stderr, fn -> IO.warn(:hello) end)
+      |> assert_emits(["hello", "(ex_unit #{System.version()}) lib/ex_unit"])
+
+      capture_io(:stderr, fn -> IO.warn(13) end)
+      |> assert_emits(["13", "(ex_unit #{System.version()}) lib/ex_unit"])
+    end
+
+    test "no stacktrace" do
+      assert capture_io(:stderr, fn -> IO.warn("hello", []) end) =~ "hello\n"
+    end
+
+    test "with stacktrace" do
+      stacktrace = [{IEx.Evaluator, :eval, 4, [file: ~c"lib/iex/evaluator.ex", line: 108]}]
+
+      output = capture_io(:stderr, fn -> IO.warn("hello", stacktrace) end)
+
+      assert output =~ "hello"
+      assert output =~ "lib/iex/evaluator.ex:108: IEx.Evaluator.eval/4"
+    end
+
+    test "with env" do
+      output = capture_io(:stderr, fn -> IO.warn("hello", __ENV__) end)
+
+      assert output =~ "hello"
+
+      assert output =~
+               ~r"(lib/elixir/)?test/elixir/io_test.exs:#{__ENV__.line - 5}: IOTest.\"test warn with env\"/1"
+    end
+
+    test "with options" do
+      capture_io(:stderr, fn ->
+        IO.warn("hello", line: 13, file: "lib/foo.ex", module: Foo, function: {:bar, 1})
+      end)
+      |> assert_emits(["hello", "lib/foo.ex:13: Foo.bar/1"])
+
+      capture_io(:stderr, fn ->
+        IO.warn("hello", file: "lib/foo.ex", module: Foo, function: {:bar, 1})
+      end)
+      |> assert_emits(["hello", "lib/foo.ex: Foo.bar/1"])
+
+      capture_io(:stderr, fn -> IO.warn("hello", file: "lib/foo.ex", module: Foo) end)
+      |> assert_emits(["hello", "lib/foo.ex: Foo (module)"])
+
+      capture_io(:stderr, fn -> IO.warn("hello", file: "lib/foo.ex") end)
+      |> assert_emits(["hello", "lib/foo.ex: (file)"])
+
+      capture_io(:stderr, fn ->
+        IO.warn("hello", file: "lib/foo.ex", function: {:bar, 1})
+      end)
+      |> assert_emits(["hello", "lib/foo.ex: (file)"])
+
+      assert capture_io(:stderr, fn ->
+               IO.warn("hello", line: 13, module: Foo, function: {:bar, 1})
+             end) =~ "hello"
+    end
+  end
+
+  test "write with chardata" do
     assert capture_io(fn -> IO.write("hello") end) == "hello"
-    assert capture_io(fn -> IO.write('hello') end) == "hello"
+    assert capture_io(fn -> IO.write(~c"hello") end) == "hello"
     assert capture_io(fn -> IO.write(:hello) end) == "hello"
     assert capture_io(fn -> IO.write(13) end) == "13"
   end
 
-  test :gets_with_chardata do
+  test "gets with chardata" do
     assert capture_io("foo\n", fn -> IO.gets("hello") end) == "hello"
-    assert capture_io("foo\n", fn -> IO.gets('hello') end) == "hello"
+    assert capture_io("foo\n", fn -> IO.gets(~c"hello") end) == "hello"
     assert capture_io("foo\n", fn -> IO.gets(:hello) end) == "hello"
     assert capture_io("foo\n", fn -> IO.gets(13) end) == "13"
   end
 
-  test :getn_with_chardata do
+  test "getn with chardata" do
     assert capture_io("foo\n", fn -> IO.getn("hello", 3) end) == "hello"
-    assert capture_io("foo\n", fn -> IO.getn('hello', 3) end) == "hello"
+    assert capture_io("foo\n", fn -> IO.getn(~c"hello", 3) end) == "hello"
     assert capture_io("foo\n", fn -> IO.getn(:hello, 3) end) == "hello"
     assert capture_io("foo\n", fn -> IO.getn(13, 3) end) == "13"
   end
+
+  test "getn with different arities" do
+    assert capture_io("hello", fn ->
+             input = IO.getn(">")
+             IO.write(input)
+           end) == ">h"
+
+    assert capture_io("hello", fn ->
+             input = IO.getn(">", 3)
+             IO.write(input)
+           end) == ">hel"
+
+    assert capture_io("hello", fn ->
+             input = IO.getn(Process.group_leader(), ">")
+             IO.write(input)
+           end) == ">h"
+
+    assert capture_io("hello", fn ->
+             input = IO.getn(Process.group_leader(), ">")
+             IO.write(input)
+           end) == ">h"
+
+    assert capture_io("hello", fn ->
+             input = IO.getn(Process.group_leader(), ">", 99)
+             IO.write(input)
+           end) == ">hello"
+  end
+
+  test "inspect" do
+    assert capture_io(fn -> IO.inspect(1) end) == "1\n"
+    assert capture_io(fn -> IO.inspect(1, label: "foo") end) == "foo: 1\n"
+    assert capture_io(fn -> IO.inspect(1, label: :foo) end) == "foo: 1\n"
+  end
+
+  test "stream" do
+    assert IO.stream() == IO.stream(:stdio, :line)
+    assert IO.binstream() == IO.binstream(:stdio, :line)
+  end
+
+  defp assert_emits(output, messages) do
+    for m <- messages do
+      assert output =~ m
+    end
+  end
 end
diff --git a/lib/elixir/test/elixir/json_test.exs b/lib/elixir/test/elixir/json_test.exs
new file mode 100644
index 00000000000..79bff828702
--- /dev/null
+++ b/lib/elixir/test/elixir/json_test.exs
@@ -0,0 +1,199 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule JSONTest do
+  use ExUnit.Case, async: true
+
+  defmodule Token do
+    defstruct [:value]
+
+    defimpl JSON.Encoder do
+      def encode(token, encoder) do
+        [?[, encoder.(token.value, encoder), ?]]
+      end
+    end
+  end
+
+  doctest JSON
+
+  describe "encode" do
+    test "atoms" do
+      assert JSON.encode!([nil, false, true, :another]) == "[null,false,true,\"another\"]"
+    end
+
+    test "binaries" do
+      assert JSON.encode!("hello\0world\t✂️") == "\"hello\\u0000world\\t✂️\""
+    end
+
+    test "integers" do
+      assert JSON.encode!(123_456) == "123456"
+    end
+
+    test "floats" do
+      assert JSON.encode!(123.456) == "123.456"
+    end
+
+    test "maps" do
+      assert JSON.encode!(%{1 => 2, 3.0 => 4.0, ~c"list" => ~c"list", key: :bar}) ==
+               "{\"1\":2,\"3.0\":4.0,\"key\":\"bar\",\"list\":[108,105,115,116]}"
+    end
+
+    test "lists" do
+      assert JSON.encode!([1, 1.0, "one", %{1 => 2, 3.0 => 4.0, key: :bar}]) ==
+               "[1,1.0,\"one\",{\"1\":2,\"3.0\":4.0,\"key\":\"bar\"}]"
+    end
+
+    test "structs" do
+      assert JSON.encode!(%Token{value: :example}) == "[\"example\"]"
+      assert JSON.encode!(%Token{value: "hello\0world"}) == "[\"hello\\u0000world\"]"
+    end
+
+    test "calendar" do
+      assert JSON.encode!(~D[2010-04-17]) == "\"2010-04-17\""
+      assert JSON.encode!(~T[14:00:00.123]) == "\"14:00:00.123\""
+      assert JSON.encode!(~N[2010-04-17 14:00:00.123]) == "\"2010-04-17T14:00:00.123\""
+      assert JSON.encode!(~U[2010-04-17 14:00:00.123Z]) == "\"2010-04-17T14:00:00.123Z\""
+      assert JSON.encode!(Duration.new!(month: 2, hour: 3)) == "\"P2MT3H\""
+    end
+  end
+
+  describe "JSON.Encoder" do
+    defp protocol_encode(term) do
+      term
+      |> JSON.Encoder.encode(&JSON.protocol_encode/2)
+      |> IO.iodata_to_binary()
+    end
+
+    test "atoms" do
+      assert protocol_encode(:another) == "\"another\""
+      assert protocol_encode([nil, false, true, :another]) == "[null,false,true,\"another\"]"
+    end
+
+    test "binaries" do
+      assert protocol_encode("hello\0world\t✂️") == "\"hello\\u0000world\\t✂️\""
+    end
+
+    test "integers" do
+      assert protocol_encode(123_456) == "123456"
+    end
+
+    test "floats" do
+      assert protocol_encode(123.456) == "123.456"
+    end
+
+    test "maps" do
+      assert protocol_encode(%{1 => 2, 3.0 => 4.0, ~c"list" => ~c"list", key: :bar}) ==
+               "{\"1\":2,\"3.0\":4.0,\"key\":\"bar\",\"list\":[108,105,115,116]}"
+    end
+
+    test "lists" do
+      assert protocol_encode([1, 1.0, "one", %{1 => 2, 3.0 => 4.0, key: :bar}]) ==
+               "[1,1.0,\"one\",{\"1\":2,\"3.0\":4.0,\"key\":\"bar\"}]"
+    end
+
+    test "structs" do
+      assert protocol_encode(%Token{value: :example}) == "[\"example\"]"
+      assert protocol_encode(%Token{value: "hello\0world"}) == "[\"hello\\u0000world\"]"
+    end
+  end
+
+  test "encode_to_iodata" do
+    list = JSON.encode_to_iodata!([1, 1.0, "one", %{1 => 2, 3.0 => 4.0, key: :bar}])
+    assert is_list(list)
+    assert IO.iodata_to_binary(list) == "[1,1.0,\"one\",{\"1\":2,\"3.0\":4.0,\"key\":\"bar\"}]"
+
+    list =
+      JSON.encode_to_iodata!([
+        ~T[12:34:56.78],
+        ~D[2024-12-31],
+        ~N[2010-04-17 14:00:00.123],
+        ~U[2010-04-17 14:00:00.123Z],
+        Duration.new!(month: 2, hour: 3)
+      ])
+
+    assert IO.iodata_to_binary(list) ==
+             ~s'["12:34:56.78","2024-12-31","2010-04-17T14:00:00.123","2010-04-17T14:00:00.123Z","P2MT3H"]'
+  end
+
+  test "deprecated" do
+    assert JSON.encode!([:hello, "world"]) == "[\"hello\",\"world\"]"
+
+    list = JSON.encode_to_iodata!([:hello, "world"])
+    assert is_list(list)
+    assert IO.iodata_to_binary(list) == "[\"hello\",\"world\"]"
+  end
+
+  describe "deriving" do
+    defmodule WithOnly do
+      @derive {JSON.Encoder, only: [:a, :b, :d]}
+      # The encoded order depends on only
+      defstruct Enum.shuffle([:a, :b, :c, :d])
+    end
+
+    test "with only" do
+      assert ["{\"a\":", _, ",\"b\":", _, ",\"d\":", _, 125] =
+               json = JSON.encode_to_iodata!(%WithOnly{a: :a, b: "b", c: make_ref(), d: [?d]})
+
+      assert IO.iodata_to_binary(json) == "{\"a\":\"a\",\"b\":\"b\",\"d\":[100]}"
+    end
+
+    defmodule WithExcept do
+      @derive {JSON.Encoder, except: [:c]}
+      defstruct [:a, :b, :c, :d]
+    end
+
+    test "with except" do
+      assert ["{\"a\":", _, ",\"b\":", _, ",\"d\":", _, 125] =
+               json = JSON.encode_to_iodata!(%WithExcept{a: :a, b: "b", c: make_ref(), d: [?d]})
+
+      assert IO.iodata_to_binary(json) == "{\"a\":\"a\",\"b\":\"b\",\"d\":[100]}"
+    end
+
+    defmodule WithEmpty do
+      @derive {JSON.Encoder, only: []}
+      defstruct [:a, :b]
+    end
+
+    test "with empty" do
+      assert JSON.encode_to_iodata!(%WithEmpty{}) == "{}"
+    end
+  end
+
+  describe "decode" do
+    test "succeeds" do
+      assert JSON.decode("[null,123,456.7,\"string\",{\"key\":\"value\"}]") ==
+               {:ok, [nil, 123, 456.7, "string", %{"key" => "value"}]}
+
+      assert JSON.decode!("[null,123,456.7,\"string\",{\"key\":\"value\"}]") ==
+               [nil, 123, 456.7, "string", %{"key" => "value"}]
+    end
+
+    test "unexpected end" do
+      assert JSON.decode("{") == {:error, {:unexpected_end, 1}}
+
+      assert_raise JSON.DecodeError,
+                   "unexpected end of JSON binary at position (byte offset) 1",
+                   fn -> JSON.decode!("{") end
+    end
+
+    test "invalid byte" do
+      assert JSON.decode(",") == {:error, {:invalid_byte, 0, ?,}}
+      assert JSON.decode("123o") == {:error, {:invalid_byte, 3, ?o}}
+
+      assert_raise JSON.DecodeError,
+                   "invalid byte 111 at position (byte offset) 3",
+                   fn -> JSON.decode!("123o") end
+    end
+
+    test "unexpected sequence" do
+      assert JSON.decode("\"\\ud8aa\\udcxx\"") ==
+               {:error, {:unexpected_sequence, 1, "\\ud8aa\\udcxx"}}
+
+      assert_raise JSON.DecodeError,
+                   "unexpected sequence \"\\\\ud8aa\\\\udcxx\" at position (byte offset) 1",
+                   fn -> JSON.decode!("\"\\ud8aa\\udcxx\"") end
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/alias_test.exs b/lib/elixir/test/elixir/kernel/alias_test.exs
index be552061d10..d897fedb5ed 100644
--- a/lib/elixir/test/elixir/kernel/alias_test.exs
+++ b/lib/elixir/test/elixir/kernel/alias_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 alias Kernel.AliasTest.Nested, as: Nested
 
@@ -9,26 +13,33 @@ end
 defmodule Kernel.AliasTest do
   use ExUnit.Case, async: true
 
-  test :alias_erlang do
+  test "alias Erlang" do
     alias :lists, as: MyList
     assert MyList.flatten([1, [2], 3]) == [1, 2, 3]
     assert Elixir.MyList.Bar == :"Elixir.MyList.Bar"
     assert MyList.Bar == :"Elixir.lists.Bar"
   end
 
-  test :double_alias do
+  test "double alias" do
     alias Kernel.AliasTest.Nested, as: Nested2
-    assert Nested.value  == 1
-    assert Nested2.value == 1
+    assert Nested.value() == 1
+    assert Nested2.value() == 1
   end
 
-  test :overwriten_alias do
-    alias List, as: Nested
+  test "overwritten alias" do
+    assert alias(List, as: Nested) == List
     assert Nested.flatten([[13]]) == [13]
   end
 
-  test :lexical do
-    if true do
+  test "non-recursive alias" do
+    alias Billing, as: BillingLib
+    alias MyApp.Billing
+    assert BillingLib == :"Elixir.Billing"
+    assert Billing == :"Elixir.MyApp.Billing"
+  end
+
+  test "lexical" do
+    if true_fun() do
       alias OMG, as: List, warn: false
     else
       alias ABC, as: List, warn: false
@@ -37,12 +48,29 @@ defmodule Kernel.AliasTest do
     assert List.flatten([1, [2], 3]) == [1, 2, 3]
   end
 
+  defp true_fun(), do: true
+
   defmodule Elixir do
     def sample, do: 1
   end
 
-  test :nested_elixir_alias do
-    assert Kernel.AliasTest.Elixir.sample == 1
+  test "nested Elixir alias" do
+    assert Kernel.AliasTest.Elixir.sample() == 1
+  end
+
+  test "multi-call" do
+    result = alias unquote(Inspect).{Opts, Algebra}
+    assert result == [Inspect.Opts, Inspect.Algebra]
+    assert %Opts{} == %Inspect.Opts{}
+    assert Algebra.empty() == []
+  end
+
+  test "alias removal" do
+    alias __MODULE__.Foo
+    assert Foo == __MODULE__.Foo
+    alias Elixir.Foo
+    assert Foo == Elixir.Foo
+    alias Elixir.Bar
   end
 end
 
@@ -54,7 +82,7 @@ defmodule Kernel.AliasNestingGenerator do
       end
 
       defmodule Parent.Child do
-        def b, do: Parent.a
+        def b, do: Parent.a()
       end
     end
   end
@@ -63,20 +91,46 @@ end
 defmodule Kernel.AliasNestingTest do
   use ExUnit.Case, async: true
 
-  require Kernel.AliasNestingGenerator
-  Kernel.AliasNestingGenerator.create
+  test "aliases nesting" do
+    require Kernel.AliasNestingGenerator
+    Kernel.AliasNestingGenerator.create()
 
-  test :aliases_nesting do
-    assert Parent.a == :a
-    assert Parent.Child.b == :a
+    assert Parent.a() == :a
+    assert Parent.Child.b() == :a
   end
 
   defmodule Nested do
     def value, do: 2
   end
 
-  test :aliases_nesting_with_previous_alias do
-    assert Nested.value == 2
+  test "aliases nesting with previous alias" do
+    assert Nested.value() == 2
+  end
+
+  alias Another.AliasEnv, warn: false
+  def aliases_before, do: __ENV__.aliases
+
+  defmodule Elixir.AliasEnv do
+    def aliases_nested, do: __ENV__.aliases
+  end
+
+  def aliases_after, do: __ENV__.aliases
+
+  test "keeps env after overriding nested Elixir module of the same name" do
+    assert aliases_before() == [
+             {Elixir.Nested, Kernel.AliasNestingTest.Nested},
+             {Elixir.AliasEnv, Another.AliasEnv}
+           ]
+
+    assert Elixir.AliasEnv.aliases_nested() == [
+             {Elixir.Nested, Kernel.AliasNestingTest.Nested},
+             {Elixir.AliasEnv, Another.AliasEnv}
+           ]
+
+    assert aliases_after() == [
+             {Elixir.Nested, Kernel.AliasNestingTest.Nested},
+             {Elixir.AliasEnv, Another.AliasEnv}
+           ]
   end
 end
 
@@ -96,6 +150,7 @@ defmodule Macro.AliasTest.Definer do
       defmodule First do
         defstruct foo: :bar
       end
+
       defmodule Second do
         defstruct baz: %First{}
       end
@@ -118,7 +173,7 @@ defmodule Macro.AliasTest.User do
   use Macro.AliasTest.Aliaser
 
   test "has a struct defined from after compile" do
-    assert is_map struct(Macro.AliasTest.User.First, [])
-    assert is_map struct(Macro.AliasTest.User.Second, []).baz
+    assert is_map(struct(Macro.AliasTest.User.First, []))
+    assert is_map(struct(Macro.AliasTest.User.Second, []).baz)
   end
 end
diff --git a/lib/elixir/test/elixir/kernel/binary_test.exs b/lib/elixir/test/elixir/kernel/binary_test.exs
index e6e7934dd16..c48c2b9613c 100644
--- a/lib/elixir/test/elixir/kernel/binary_test.exs
+++ b/lib/elixir/test/elixir/kernel/binary_test.exs
@@ -1,56 +1,79 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.BinaryTest do
   use ExUnit.Case, async: true
 
-  test :heredoc do
-    assert 7 == __ENV__.line
+  test "heredoc" do
+    assert 11 == __ENV__.line
+
     assert "foo\nbar\n" == """
-foo
-bar
-"""
+           foo
+           bar
+           """
+
+    assert 18 == __ENV__.line
 
-    assert 13 == __ENV__.line
     assert "foo\nbar \"\"\"\n" == """
-foo
-bar """
-"""
+           foo
+           bar \"""
+           """
   end
 
-  test :aligned_heredoc do
+  test "aligned heredoc" do
     assert "foo\nbar\n" == """
-    foo
-    bar
-    """
+           foo
+           bar
+           """
   end
 
-  test :heredoc_with_interpolation do
-    assert "29\n" == """
-    #{__ENV__.line}
-    """
+  test "heredoc with interpolation" do
+    assert "35\n" == """
+           #{__ENV__.line}
+           """
+
+    assert "\n40\n" == """
 
-    assert "\n34\n" == """
+           #{__ENV__.line}
+           """
+  end
 
-    #{__ENV__.line}
-    """
+  test "heredoc in call" do
+    assert "foo\nbar" ==
+             Kernel.<>(
+               """
+               foo
+               """,
+               "bar"
+             )
   end
 
-  test :heredoc_in_call do
-    assert "foo\nbar" == Kernel.<>("""
-    foo
-    """, "bar")
+  test "heredoc with heredoc inside interpolation" do
+    assert """
+           1
+           #{"""
+           2
+           """}
+           """ == "1\n2\n\n"
   end
 
-  test :utf8 do
+  test "UTF-8" do
     assert byte_size(" ゆんゆん") == 13
   end
 
-  test :utf8_char do
+  test "UTF-8 char" do
     assert ?ゆ == 12422
-    assert ?\ゆ == 12422
   end
 
-  test :string_concatenation_as_match do
+  test "size outside match" do
+    x = 16
+    assert <<0::size(x)>> == <<0, 0>>
+  end
+
+  test "string concatenation as match" do
     "foo" <> x = "foobar"
     assert x == "bar"
 
@@ -60,142 +83,255 @@ bar """
     <<"f", "oo">> <> x = "foobar"
     assert x == "bar"
 
-    <<x :: [binary, size(3)]>> <> _ = "foobar"
+    <<x::binary-size(3)>> <> _ = "foobar"
     assert x == "foo"
 
     size = 3
-    <<x :: [binary, size(size)]>> <> _ = "foobar"
+    <<x::binary-size(^size)>> <> _ = "foobar"
     assert x == "foo"
 
-    <<x :: [binary, size(6), unit(4)]>> <> _ = "foobar"
+    size = 3
+    <<size, x::binary-size(^size)>> <> _ = <<10, "foobar">>
     assert x == "foo"
+    assert size == 10
+
+    <<x::6*4-binary>> <> _ = "foobar"
+    assert x == "foo"
+
+    <<x::3-bytes>> <> _ = "foobar"
+    assert x == "foo"
+
+    <<x::24-bits>> <> _ = "foobar"
+    assert x == "foo"
+
+    <<x::utf8>> <> _ = "foobar"
+    assert x == ?f
+  end
+
+  test "string concatenation outside match" do
+    x = "bar"
+    assert "foobar" = "foo" <> x
+    assert "barfoo" = x <> "foo"
+  end
 
-    assert_raise ErlangError, fn ->
-      Code.eval_string(~s{<<x :: [binary, size(3), unit(4)]>> <> _ = "foobar"})
+  test "invalid string concatenation arguments" do
+    assert_raise ArgumentError, ~r"expected binary argument in <> operator but got: :bar", fn ->
+      Code.eval_string(~s["foo" <> :bar])
     end
 
-    assert_raise ErlangError, fn ->
-      Code.eval_string(~s{<<x :: [integer, size(4)]>> <> _ = "foobar"})
+    assert_raise ArgumentError, ~r"expected binary argument in <> operator but got: 1", fn ->
+      Code.eval_string(~s["foo" <> 1])
     end
-  end
 
-  test :octals do
-    assert "\1" == <<1>>
-    assert "\12" == "\n"
-    assert "\123" == "S"
-    assert "\123" == "S"
-    assert "\377" == "ÿ"
-    assert "\128" == "\n8"
-    assert "\18"  == <<1, ?8>>
+    message = ~r"cannot perform prefix match because the left operand of <> has unknown size."
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string(~s[a <> "b" = "ab"])
+    end
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string(~s["a" <> b <> "c" = "abc"])
+    end
   end
 
-  test :hex do
-    assert "\xa" == "\n"
-    assert "\xE9" == "é"
-    assert "\xFF" == "ÿ"
-    assert "\x{A}"== "\n"
-    assert "\x{E9}"== "é"
-    assert "\x{10F}" == <<196, 143>>
-    assert "\x{10FF}" == <<225, 131, 191>>
-    assert "\x{10FFF}" == <<240, 144, 191, 191>>
-    assert "\x{10FFFF}" == <<244, 143, 191, 191>>
+  test "hex" do
+    assert "\x76" == "v"
+    assert "\u00FF" == "ÿ"
+    assert "\u{A}" == "\n"
+    assert "\u{E9}" == "é"
+    assert "\u{10F}" == <<196, 143>>
+    assert "\u{10FF}" == <<225, 131, 191>>
+    assert "\u{10FFF}" == <<240, 144, 191, 191>>
+    assert "\u{10FFFF}" == <<244, 143, 191, 191>>
   end
 
-  test :match do
-    assert match?(<< ?a, _ :: binary >>, "ab")
-    refute match?(<< ?a, _ :: binary >>, "cd")
-    assert match?(<< _ :: utf8 >> <> _, "éf")
+  test "match" do
+    assert match?(<<?a, _::binary>>, "ab")
+    refute match?(<<?a, _::binary>>, "cd")
+    assert match?(<<_::utf8>> <> _, "éf")
   end
 
-  test :interpolation do
+  test "interpolation" do
     res = "hello \\abc"
     assert "hello #{"\\abc"}" == res
     assert "hello #{"\\abc" <> ""}" == res
   end
 
-  test :pattern_match do
+  test "pattern match" do
     s = 16
-    assert <<_a, _b :: size(s)>> = "foo"
+    assert <<_a, _b::size(^s)>> = "foo"
   end
 
-  test :pattern_match_with_splice do
-    assert << 1, <<2, 3, 4>>, 5 >> = <<1, 2, 3, 4, 5>>
+  test "pattern match with splice" do
+    assert <<1, <<2, 3, 4>>, 5>> = <<1, 2, 3, 4, 5>>
   end
 
-  test :partial_application do
-    assert (&<< &1, 2 >>).(1) == << 1, 2 >>
-    assert (&<< &1, &2 >>).(1, 2) == << 1, 2 >>
-    assert (&<< &2, &1 >>).(2, 1) == << 1, 2 >>
+  test "partial application" do
+    assert (&<<&1, 2>>).(1) == <<1, 2>>
+    assert (&<<&1, &2>>).(1, 2) == <<1, 2>>
+    assert (&<<&2, &1>>).(2, 1) == <<1, 2>>
   end
 
-  test :literal do
-    assert <<106,111,115,195,169>> == << "josé" :: binary >>
-    assert <<106,111,115,195,169>> == << "josé" :: bits >>
-    assert <<106,111,115,195,169>> == << "josé" :: bitstring >>
-    assert <<106,111,115,195,169>> == << "josé" :: bytes >>
-
-    assert <<106,111,115,195,169>> == << "josé" :: utf8 >>
-    assert <<0,106,0,111,0,115,0,233>> == << "josé" :: utf16 >>
-    assert <<106,0,111,0,115,0,233,0>> == << "josé" :: [utf16, little] >>
-    assert <<0,0,0,106,0,0,0,111,0,0,0,115,0,0,0,233>> == << "josé" :: utf32 >>
+  test "literal" do
+    assert <<106, 111, 115, 195, 169>> == <<"josé">>
+    assert <<106, 111, 115, 195, 169>> == <<"#{:josé}">>
+    assert <<106, 111, 115, 195, 169>> == <<"josé"::binary>>
+    assert <<106, 111, 115, 195, 169>> == <<"josé"::bits>>
+    assert <<106, 111, 115, 195, 169>> == <<"josé"::bitstring>>
+    assert <<106, 111, 115, 195, 169>> == <<"josé"::bytes>>
+
+    assert <<106, 111, 115, 195, 169>> == <<"josé"::utf8>>
+    assert <<0, 106, 0, 111, 0, 115, 0, 233>> == <<"josé"::utf16>>
+    assert <<106, 0, 111, 0, 115, 0, 233, 0>> == <<"josé"::little-utf16>>
+    assert <<0, 0, 0, 106, 0, 0, 0, 111, 0, 0, 0, 115, 0, 0, 0, 233>> == <<"josé"::utf32>>
   end
 
-  test :literal_errors do
-    assert_raise CompileError, fn ->
-      Code.eval_string(~s[<< "foo" :: integer >>])
-    end
+  test "literal errors" do
+    message = "conflicting type specification for bit field"
 
-    assert_raise CompileError, fn ->
-      Code.eval_string(~s[<< "foo" :: float >>])
-    end
+    assert_compile_error(message, fn ->
+      Code.eval_string(~s[<<"foo"::integer>>])
+    end)
 
-    assert_raise CompileError, fn ->
-      Code.eval_string(~s[<< 'foo' :: binary >>])
-    end
+    assert_compile_error(message, fn ->
+      Code.eval_string(~s[<<"foo"::float>>])
+    end)
+  end
 
-    assert_raise ArgumentError, fn ->
-      Code.eval_string(~s[<<1::size(4)>> <> "foo"])
-    end
+  @bitstring <<"foo", 16::4>>
+
+  test "bitstring attribute" do
+    assert @bitstring == <<"foo", 16::4>>
   end
 
   @binary "new "
 
-  test :bitsyntax_with_expansion do
+  test "bitsyntax expansion" do
     assert <<@binary, "world">> == "new world"
   end
 
-  test :bitsyntax_translation do
+  test "bitsyntax translation" do
     refb = "sample"
     sec_data = "another"
-    << byte_size(refb) :: [size(1), big, signed, integer, unit(8)],
-       refb :: binary,
-       byte_size(sec_data) :: [size(1), big, signed, integer, unit(16)],
-       sec_data :: binary >>
+
+    <<
+      byte_size(refb)::size(1)-big-signed-integer-unit(8),
+      refb::binary,
+      byte_size(sec_data)::1*16-big-signed-integer,
+      sec_data::binary
+    >>
+  end
+
+  test "bitsyntax size shortcut" do
+    assert <<1::3>> == <<1::size(3)>>
+    assert <<1::3*8>> == <<1::size(3)-unit(8)>>
+  end
+
+  test "bitsyntax variable size" do
+    x = 8
+    assert <<_, _::size(^x)>> = <<?a, ?b>>
+    assert (fn <<_, _::size(^x)>> -> true end).(<<?a, ?b>>)
   end
 
-  test :bitsyntax_size_shorcut do
-    assert << 1 :: 3 >> == << 1 :: size(3) >>
-    assert << 1 :: [unit(8), 3] >> == << 1 :: [unit(8), size(3)] >>
+  test "bitsyntax size using expressions" do
+    x = 8
+    assert <<1::size(x - 5)>>
+
+    foo = %{bar: 5}
+    assert <<1::size(foo.bar)>>
+    assert <<1::size(length(~c"abcd"))>>
+    assert <<255::size(hd(List.flatten([3])))>>
   end
 
-  defmacrop signed_16 do
+  test "bitsyntax size using guard expressions in match context" do
+    x = 8
+    assert <<1::size(^x - 5)>> = <<1::3>>
+    assert <<1::size(^x - 5)-unit(8)>> = <<1::3*8>>
+    assert <<1::size(length(~c"abcd"))>> = <<1::4>>
+
+    foo = %{bar: 5}
+    assert <<1::size((^foo).bar)>> = <<1::5>>
+  end
+
+  test "bitsyntax size with pinned integer" do
+    a = 1
+    b = <<2, 3>>
+    assert <<^a, ^b::binary>> = <<1, 2, 3>>
+  end
+
+  test "automatic size computation of matched bitsyntax variable" do
+    var = "foo"
+    <<^var::binary, rest::binary>> = "foobar"
+    assert rest == "bar"
+
+    <<^var::bytes, rest::bytes>> = "foobar"
+    assert rest == "bar"
+
+    ^var <> rest = "foobar"
+    assert rest == "bar"
+
+    var = <<0, 1>>
+    <<^var::bitstring, rest::bitstring>> = <<0, 1, 2, 3>>
+    assert rest == <<2, 3>>
+
+    <<^var::bits, rest::bits>> = <<0, 1, 2, 3>>
+    assert rest == <<2, 3>>
+
+    ^var <> rest = <<0, 1, 2, 3>>
+    assert rest == <<2, 3>>
+  end
+
+  defmacro signed_16 do
     quote do
-      [big, signed, integer, unit(16)]
+      big - signed - integer - unit(16)
     end
   end
 
-  defmacrop refb_spec do
+  defmacro refb_spec do
     quote do
-      [size(1), big, signed, integer, unit(8)]
+      1 * 8 - big - signed - integer
     end
   end
 
-  test :bitsyntax_macro do
+  test "bitsyntax macro" do
     refb = "sample"
     sec_data = "another"
-    << byte_size(refb) :: refb_spec,
-       refb :: binary,
-       byte_size(sec_data) :: [size(1), signed_16],
-       sec_data :: binary >>
+
+    <<
+      byte_size(refb)::refb_spec(),
+      refb::binary,
+      byte_size(sec_data)::size(1)-signed_16(),
+      sec_data::binary
+    >>
+  end
+
+  test "bitsyntax macro is expanded with a warning" do
+    assert capture_err(fn ->
+             Code.eval_string("<<1::refb_spec>>", [], __ENV__)
+           end) =~
+             "bitstring specifier \"refb_spec\" does not exist and is being expanded to \"refb_spec()\""
+
+    assert capture_err(fn ->
+             Code.eval_string("<<1::size(1)-signed_16>>", [], __ENV__)
+           end) =~
+             "bitstring specifier \"signed_16\" does not exist and is being expanded to \"signed_16()\""
+  end
+
+  test "bitsyntax with extra parentheses warns" do
+    assert capture_err(fn ->
+             Code.eval_string("<<1::big()>>")
+           end) =~ "extra parentheses on a bitstring specifier \"big()\" have been deprecated"
+
+    assert capture_err(fn ->
+             Code.eval_string("<<1::size(8)-integer()>>")
+           end) =~ "extra parentheses on a bitstring specifier \"integer()\" have been deprecated"
+  end
+
+  defp capture_err(fun) do
+    ExUnit.CaptureIO.capture_io(:stderr, fun)
+  end
+
+  defp assert_compile_error(message, fun) do
+    assert capture_err(fn -> assert_raise CompileError, fun end) =~ message
   end
 end
diff --git a/lib/elixir/test/elixir/kernel/case_test.exs b/lib/elixir/test/elixir/kernel/case_test.exs
deleted file mode 100644
index 9c9755c5564..00000000000
--- a/lib/elixir/test/elixir/kernel/case_test.exs
+++ /dev/null
@@ -1,66 +0,0 @@
-Code.require_file "../test_helper.exs", __DIR__
-
-defmodule Kernel.CaseTest do
-  use ExUnit.Case, async: true
-
-  test :inline_case do
-    assert (case 1, do: (1 -> :ok; 2 -> :wrong)) == :ok
-  end
-
-  test :nested_variables do
-    assert vars_case(400, 1) == {400, 1}
-    assert vars_case(401, 1) == {400, -1}
-    assert vars_case(0, -1)  == {0, -1}
-    assert vars_case(-1, -1) == {0, 1}
-  end
-
-  test :nested_vars_match do
-    x = {:error, {:ok, :done}}
-    assert (case x do
-      {:ok, right} ->
-        right
-      {_left, right} ->
-        case right do
-          {:ok, right}  -> right
-        end
-    end) == :done
-  end
-
-  test :in_operator_outside_case do
-    x = 1
-    y = 4
-    assert x in [1, 2, 3], "in assertion"
-    assert not y in [1, 2, 3], "not in assertion"
-  end
-
-  test :in_with_match do
-    refute 1.0 in [1, 2, 3], "not in assertion"
-  end
-
-  test :in_cond_clause do
-    assert (cond do
-      format() && (f = format()) ->
-        f
-      true ->
-        :text
-    end) == :html
-  end
-
-  defp format, do: :html
-
-  defp vars_case(x, vx) do
-    case x > 400 do
-      true ->
-        x = 400
-        vx = -vx
-      _ ->
-        case x < 0 do
-          true ->
-            x = 0
-            vx = -vx
-          _ -> nil
-        end
-    end
-    {x, vx}
-  end
-end
diff --git a/lib/elixir/test/elixir/kernel/char_list_test.exs b/lib/elixir/test/elixir/kernel/char_list_test.exs
deleted file mode 100644
index 7bbc381f2b2..00000000000
--- a/lib/elixir/test/elixir/kernel/char_list_test.exs
+++ /dev/null
@@ -1,45 +0,0 @@
-Code.require_file "../test_helper.exs", __DIR__
-
-defmodule CharListTest do
-  use ExUnit.Case, async: true
-
-  test :heredoc do
-    assert __ENV__.line == 7
-    assert 'foo\nbar\n' == '''
-foo
-bar
-'''
-
-    assert __ENV__.line == 13
-    assert 'foo\nbar \'\'\'\n' == '''
-foo
-bar '''
-'''
-  end
-
-  test :utf8 do
-    assert length(' ゆんゆん') == 5
-  end
-
-  test :octals do
-    assert '\1' == [1]
-    assert '\12' == '\n'
-    assert '\123' == 'S'
-    assert '\123' == 'S'
-    assert '\377' == 'ÿ'
-    assert '\128' == '\n8'
-    assert '\18' == [1, ?8]
-  end
-
-  test :hex do
-    assert '\xa' == '\n'
-    assert '\xE9' == 'é'
-    assert '\xfF' == 'ÿ'
-    assert '\x{A}' == '\n'
-    assert '\x{e9}' == 'é'
-    assert '\x{10F}' == [271]
-    assert '\x{10FF}' == [4351]
-    assert '\x{10FFF}' == [69631]
-    assert '\x{10FFFF}' == [1114111]
-  end
-end
diff --git a/lib/elixir/test/elixir/kernel/charlist_test.exs b/lib/elixir/test/elixir/kernel/charlist_test.exs
new file mode 100644
index 00000000000..6266a67bf66
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/charlist_test.exs
@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule CharlistTest do
+  use ExUnit.Case, async: true
+
+  test "heredoc" do
+    assert __ENV__.line == 11
+
+    assert ~c"foo\nbar\n" == ~c"""
+           foo
+           bar
+           """
+
+    assert __ENV__.line == 18
+
+    assert ~c"foo\nbar '''\n" == ~c"""
+           foo
+           bar \'\'\'
+           """
+  end
+
+  test "UTF-8" do
+    assert length(~c" ゆんゆん") == 5
+  end
+
+  test "hex" do
+    assert ~c"\x76" == ~c"v"
+    assert ~c"\u00fF" == ~c"ÿ"
+    assert ~c"\u{A}" == ~c"\n"
+    assert ~c"\u{e9}" == ~c"é"
+    assert ~c"\u{10F}" == [271]
+    assert ~c"\u{10FF}" == [4351]
+    assert ~c"\u{10FFF}" == [69631]
+    assert ~c"\u{10FFFF}" == [1_114_111]
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/cli_test.exs b/lib/elixir/test/elixir/kernel/cli_test.exs
index 65369f4d78e..5f2e9f3edff 100644
--- a/lib/elixir/test/elixir/kernel/cli_test.exs
+++ b/lib/elixir/test/elixir/kernel/cli_test.exs
@@ -1,166 +1,349 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 import PathHelpers
 
-defmodule Kernel.CLI.ARGVTest do
+defmodule Retry do
+  # Tests that write to stderr fail on Windows due to late writes,
+  # so we do a simple retry already them.
+  defmacro stderr_test(msg, context \\ quote(do: _), do: block) do
+    if windows?() do
+      quote do
+        test unquote(msg), unquote(context) do
+          unquote(__MODULE__).retry(fn -> unquote(block) end, 3)
+        end
+      end
+    else
+      quote do
+        test(unquote(msg), unquote(context), do: unquote(block))
+      end
+    end
+  end
+
+  def retry(fun, 1) do
+    fun.()
+  end
+
+  def retry(fun, n) do
+    try do
+      fun.()
+    rescue
+      _ -> retry(fun, n - 1)
+    end
+  end
+end
+
+defmodule Kernel.CLITest do
   use ExUnit.Case, async: true
 
   import ExUnit.CaptureIO
 
   defp run(argv) do
-    {config, argv} = Kernel.CLI.parse_argv(argv)
+    {config, argv} = Kernel.CLI.parse_argv(Enum.map(argv, &String.to_charlist/1))
     assert Kernel.CLI.process_commands(config) == []
-    argv
+    Enum.map(argv, &IO.chardata_to_string/1)
   end
 
   test "argv handling" do
     assert capture_io(fn ->
-      assert run(["-e", "IO.puts :ok", "sample.exs", "-o", "1", "2"]) ==
-             ["sample.exs", "-o", "1", "2"]
-    end) == "ok\n"
-
-    assert capture_io(fn ->
-      assert run(["-e", "IO.puts :ok", "--", "sample.exs", "-o", "1", "2"]) ==
-             ["sample.exs", "-o", "1", "2"]
-    end) == "ok\n"
+             assert run(["-e", "IO.puts :ok", "sample.exs", "-o", "1", "2"]) ==
+                      ["sample.exs", "-o", "1", "2"]
+           end) == "ok\n"
 
     assert capture_io(fn ->
-      assert run(["-e", "IO.puts :ok", "--hidden", "sample.exs", "-o", "1", "2"]) ==
-             ["sample.exs", "-o", "1", "2"]
-    end) == "ok\n"
+             assert run(["-e", "IO.puts :ok", "--", "sample.exs", "-o", "1", "2"]) ==
+                      ["sample.exs", "-o", "1", "2"]
+           end) == "ok\n"
 
     assert capture_io(fn ->
-      assert run(["-e", "IO.puts :ok", "--", "--hidden", "sample.exs", "-o", "1", "2"]) ==
-             ["--hidden", "sample.exs", "-o", "1", "2"]
-    end) == "ok\n"
+             assert run(["-e", "", "--", "sample.exs", "-o", "1", "2"]) ==
+                      ["sample.exs", "-o", "1", "2"]
+           end)
   end
 end
 
-defmodule Kernel.CLI.OptionParsingTest do
-  use ExUnit.Case, async: true
+test_parameters =
+  if(PathHelpers.windows?(),
+    do: [%{cli_extension: ".bat"}],
+    else: [%{cli_extension: ""}]
+  )
+
+defmodule Kernel.CLI.ExecutableTest do
+  use ExUnit.Case,
+    async: true,
+    parameterize: test_parameters
+
+  import Retry
+
+  @tag :tmp_dir
+  test "file smoke test", context do
+    file = Path.join(context.tmp_dir, "hello_world!.exs")
+    File.write!(file, "IO.puts :hello_world123")
+    {output, 0} = System.cmd(elixir_executable(context.cli_extension), [file])
+    assert output =~ "hello_world123"
+  end
+
+  test "--eval smoke test", context do
+    {output, 0} =
+      System.cmd(elixir_executable(context.cli_extension), ["--eval", "IO.puts :hello_world123"])
+
+    assert output =~ "hello_world123"
+
+    # Check for -e and exclamation mark handling on Windows
+    assert {_output, 0} =
+             System.cmd(elixir_executable(context.cli_extension), ["-e", "Time.new!(0, 0, 0)"])
+
+    # TODO: remove this once we bump CI to Erlang/OTP 27
+    if not (windows?() and System.otp_release() == "26") do
+      {output, 0} =
+        System.cmd(iex_executable(context.cli_extension), [
+          "--eval",
+          "IO.puts :hello_world123; System.halt()"
+        ])
+
+      assert output =~ "hello_world123"
+
+      {output, 0} =
+        System.cmd(iex_executable(context.cli_extension), [
+          "-e",
+          "IO.puts :hello_world123; System.halt()"
+        ])
+
+      assert output =~ "hello_world123"
+    end
+  end
+
+  @tag :unix
+  # This test hangs on Windows but "iex --version" works on the command line
+  test "iex smoke test", %{cli_extension: cli_extension} do
+    output = iex(~c"--version", cli_extension)
+    assert output =~ "Erlang/OTP #{System.otp_release()}"
+    assert output =~ "IEx #{System.version()}"
+  end
+
+  test "--version smoke test", %{cli_extension: cli_extension} do
+    output = elixir(~c"--version", cli_extension)
+    assert output =~ "Erlang/OTP #{System.otp_release()}"
+    assert output =~ "Elixir #{System.version()}"
+
+    output = elixir(~c"--version -e \"IO.puts(:test_output)\"", cli_extension)
+    assert output =~ "Erlang/OTP #{System.otp_release()}"
+    assert output =~ "Elixir #{System.version()}"
+    assert output =~ "Standalone options can't be combined with other options"
+  end
+
+  test "--short-version smoke test", %{cli_extension: cli_extension} do
+    output = elixir(~c"--short-version", cli_extension)
+    assert output =~ System.version()
+    refute output =~ "Erlang"
+  end
+
+  stderr_test "--help smoke test", %{cli_extension: cli_extension} do
+    output = elixir(~c"--help", cli_extension)
+    assert output =~ "Usage: elixir"
+  end
+
+  stderr_test "combining --help results in error", %{cli_extension: cli_extension} do
+    output = elixir(~c"-e 1 --help", cli_extension)
+    assert output =~ "--help : Standalone options can't be combined with other options"
+
+    output = elixir(~c"--help -e 1", cli_extension)
+    assert output =~ "--help : Standalone options can't be combined with other options"
+  end
+
+  stderr_test "combining --short-version results in error", %{cli_extension: cli_extension} do
+    output = elixir(~c"--short-version -e 1", cli_extension)
+    assert output =~ "--short-version : Standalone options can't be combined with other options"
+
+    output = elixir(~c"-e 1 --short-version", cli_extension)
+    assert output =~ "--short-version : Standalone options can't be combined with other options"
+  end
 
-  test "properly parses paths" do
-    root = fixture_path("../../..") |> to_char_list
-    list = elixir('-pa "#{root}/*" -pz "#{root}/lib/*" -e "IO.inspect(:code.get_path, limit: :infinity)"')
-    {path, _} = Code.eval_string list, []
+  test "parses paths", %{cli_extension: cli_extension} do
+    root = fixture_path("../../..") |> to_charlist()
+
+    args =
+      ~c"-pa \"#{root}/*\" -pz \"#{root}/lib/*\" -e \"IO.inspect(:code.get_path(), limit: :infinity)\""
+
+    list = elixir(args, cli_extension)
+    {path, _} = Code.eval_string(list, [])
 
     # pa
-    assert to_char_list(Path.expand('ebin', root)) in path
-    assert to_char_list(Path.expand('lib', root)) in path
-    assert to_char_list(Path.expand('src', root)) in path
+    assert to_charlist(Path.expand(~c"ebin", root)) in path
+    assert to_charlist(Path.expand(~c"lib", root)) in path
+    assert to_charlist(Path.expand(~c"src", root)) in path
 
     # pz
-    assert to_char_list(Path.expand('lib/list', root)) in path
+    assert to_charlist(Path.expand(~c"lib/list", root)) in path
   end
-end
 
-defmodule Kernel.CLI.AtExitTest do
-  use ExUnit.Case, async: true
+  stderr_test "formats errors", %{cli_extension: cli_extension} do
+    assert String.starts_with?(elixir(~c"-e \":erlang.throw 1\"", cli_extension), "** (throw) 1")
+
+    assert String.starts_with?(
+             elixir(~c"-e \":erlang.error 1\"", cli_extension),
+             "** (ErlangError) Erlang error: 1"
+           )
+
+    assert String.starts_with?(elixir(~c"-e \"1 +\"", cli_extension), "** (TokenMissingError)")
+
+    assert elixir(
+             ~c"-e \"Task.async(fn -> raise ArgumentError end) |> Task.await\"",
+             cli_extension
+           ) =~
+             "an exception was raised:\n    ** (ArgumentError) argument error"
+
+    assert elixir(
+             ~c"-e \"IO.puts(Process.flag(:trap_exit, false)); exit({:shutdown, 1})\"",
+             cli_extension
+           ) ==
+             "false\n"
+  end
+
+  stderr_test "blames exceptions", %{cli_extension: cli_extension} do
+    error = elixir(~c"-e \"Access.fetch :foo, :bar\"", cli_extension)
+    assert error =~ "** (FunctionClauseError) no function clause matching in Access.fetch/2"
+    assert error =~ "The following arguments were given to Access.fetch/2"
+    assert error =~ ":foo"
+    assert error =~ "def fetch(-%module{} = container-, +key+)"
+    assert error =~ ~r"\(elixir #{System.version()}\) lib/access\.ex:\d+: Access\.fetch/2"
+  end
 
   test "invokes at_exit callbacks" do
-    assert elixir(fixture_path("at_exit.exs") |> to_char_list) ==
-      'goodbye cruel world with status 0\n'
+    assert elixir(fixture_path("at_exit.exs") |> to_charlist()) ==
+             "goodbye cruel world with status 1\n"
   end
 end
 
-defmodule Kernel.CLI.ErrorTest do
+defmodule Kernel.CLI.RPCTest do
   use ExUnit.Case, async: true
 
-  test "properly format errors" do
-    assert :string.str('** (throw) 1', elixir('-e "throw 1"')) == 0
-    assert :string.str('** (ErlangError) erlang error: 1', elixir('-e "error 1"')) == 0
+  import Retry
 
-    # It does not catch exits with integers nor strings...
-    assert elixir('-e "exit 1"') == ''
+  defp rpc_eval(command) do
+    node = "cli-rpc#{System.unique_integer()}@127.0.0.1"
+    elixir(~c"--name #{node} --rpc-eval #{node} \"#{command}\"")
   end
-end
 
-defmodule Kernel.CLI.CompileTest do
-  use ExUnit.Case, async: true
+  test "invokes command on remote node" do
+    assert rpc_eval("IO.puts :ok") == "ok\n"
+  end
 
-  test "compiles code" do
-    fixture = fixture_path "compile_sample.ex"
-    assert elixirc('#{fixture} -o #{tmp_path}') == ''
-    assert File.regular?(tmp_path "Elixir.CompileSample.beam")
-  after
-    File.rm(tmp_path("Elixir.CompileSample.beam"))
+  test "invokes command on remote node without host and --name after --rpc-eval" do
+    node = "cli-rpc#{System.unique_integer()}"
+    assert elixir(~c"--rpc-eval #{node} \"IO.puts :ok\" --name #{node}@127.0.0.1 ") == "ok\n"
   end
 
-  test "compiles code with verbose mode" do
-    fixture = fixture_path "compile_sample.ex"
-    assert elixirc('#{fixture} -o #{tmp_path} --verbose') ==
-      'Compiled #{fixture}\n'
-    assert File.regular?(tmp_path "Elixir.CompileSample.beam")
-  after
-    File.rm(tmp_path("Elixir.CompileSample.beam"))
+  test "can be invoked multiple times" do
+    node = "cli-rpc#{System.unique_integer()}"
+
+    assert elixir(
+             ~c"--name #{node}@127.0.0.1 --rpc-eval #{node} \"IO.puts :foo\" --rpc-eval #{node} \"IO.puts :bar\""
+           ) == "foo\nbar\n"
   end
 
-  test "fails on missing patterns" do
-    fixture = fixture_path "compile_sample.ex"
-    output = elixirc('#{fixture} non_existing.ex -o #{tmp_path}')
-    assert :string.str(output, 'non_existing.ex') > 0, "expected non_existing.ex to be mentionned"
-    assert :string.str(output, 'compile_sample.ex') == 0, "expected compile_sample.ex to not be mentionned"
-    refute File.exists?(tmp_path("Elixir.CompileSample.beam")) , "expected the sample to not be compiled"
+  # Windows does not provide an easy to check for missing args
+  @tag :unix
+  test "fails on wrong arguments" do
+    node = "cli-rpc#{System.unique_integer()}"
+
+    assert elixir(~c"--name #{node}@127.0.0.1 --rpc-eval") ==
+             "--rpc-eval : wrong number of arguments\n"
+
+    assert elixir(~c"--name #{node}@127.0.0.1 --rpc-eval #{node}") ==
+             "--rpc-eval : wrong number of arguments\n"
+  end
+
+  stderr_test "properly formats errors" do
+    assert String.starts_with?(rpc_eval(":erlang.throw 1"), "** (throw) 1")
+    assert String.starts_with?(rpc_eval(":erlang.error 1"), "** (ErlangError) Erlang error: 1")
+    assert String.starts_with?(rpc_eval("1 +"), "** (TokenMissingError)")
+
+    assert rpc_eval("Task.async(fn -> raise ArgumentError end) |> Task.await") =~
+             "an exception was raised:\n    ** (ArgumentError) argument error"
+
+    assert rpc_eval("IO.puts(Process.flag(:trap_exit, false)); exit({:shutdown, 1})") ==
+             "false\n"
   end
 end
 
-defmodule Kernel.CLI.ParallelCompilerTest do
-  use ExUnit.Case
-  import ExUnit.CaptureIO
+defmodule Kernel.CLI.CompileTest do
+  use ExUnit.Case,
+    async: true,
+    parameterize: test_parameters
 
-  test "compiles files solving dependencies" do
-    fixtures = [fixture_path("parallel_compiler/bar.ex"), fixture_path("parallel_compiler/foo.ex")]
-    assert capture_io(fn ->
-      assert [Bar, Foo] = Kernel.ParallelCompiler.files fixtures
-    end) =~ "message_from_foo"
-  after
-    Enum.map [Foo, Bar], fn mod ->
-      :code.purge(mod)
-      :code.delete(mod)
-    end
+  import Retry
+  @moduletag :tmp_dir
+
+  setup context do
+    beam_file_path = Path.join([context.tmp_dir, "Elixir.CompileSample.beam"])
+    fixture = fixture_path("compile_sample.ex")
+    {:ok, [beam_file_path: beam_file_path, fixture: fixture]}
   end
 
-  test "compiles files with structs solving dependencies" do
-    fixtures = [fixture_path("parallel_struct/bar.ex"), fixture_path("parallel_struct/foo.ex")]
-    assert [Bar, Foo] = Kernel.ParallelCompiler.files(fixtures) |> Enum.sort
+  test "compiles code", context do
+    assert elixirc(~c"#{context.fixture} -o #{context.tmp_dir}", context.cli_extension) == ""
+    assert File.regular?(context.beam_file_path)
+
+    # Assert that the module is loaded into memory with the proper destination for the BEAM file.
+    Code.append_path(context.tmp_dir)
+    assert :code.which(CompileSample) |> List.to_string() == Path.expand(context.beam_file_path)
   after
-    Enum.map [Foo, Bar], fn mod ->
-      :code.purge(mod)
-      :code.delete(mod)
+    :code.purge(CompileSample)
+    :code.delete(CompileSample)
+    Code.delete_path(context.tmp_dir)
+  end
+
+  @tag :windows
+  stderr_test "compiles code with Windows paths", context do
+    try do
+      fixture = String.replace(context.fixture, "/", "\\")
+      tmp_dir_path = String.replace(context.tmp_dir, "/", "\\")
+      assert elixirc(~c"#{fixture} -o #{tmp_dir_path}", context.cli_extension) == ""
+      assert File.regular?(context[:beam_file_path])
+
+      # Assert that the module is loaded into memory with the proper destination for the BEAM file.
+      Code.append_path(context.tmp_dir)
+
+      assert :code.which(CompileSample) |> List.to_string() ==
+               Path.expand(context[:beam_file_path])
+    after
+      :code.purge(CompileSample)
+      :code.delete(CompileSample)
+      Code.delete_path(context.tmp_dir)
     end
   end
 
-  test "does not hang on missing dependencies" do
-    fixtures = [fixture_path("parallel_compiler/bat.ex")]
-    assert capture_io(fn ->
-      assert catch_exit(Kernel.ParallelCompiler.files(fixtures)) == 1
-    end) =~ "Compilation error"
+  stderr_test "fails on missing patterns", context do
+    output =
+      elixirc(~c"#{context.fixture} non_existing.ex -o #{context.tmp_dir}", context.cli_extension)
+
+    assert output =~ "non_existing.ex"
+    refute output =~ "compile_sample.ex"
+    refute File.exists?(context.beam_file_path)
   end
 
-  test "handles possible deadlocks" do
-    fixtures = [fixture_path("parallel_deadlock/foo.ex"),
-                fixture_path("parallel_deadlock/bar.ex")]
+  stderr_test "fails on missing write access to .beam file", context do
+    compilation_args = ~c"#{context.fixture} -o #{context.tmp_dir}"
 
-    msg = capture_io(fn ->
-      assert catch_exit(Kernel.ParallelCompiler.files fixtures) == 1
-    end)
+    assert elixirc(compilation_args, context.cli_extension) == ""
+    assert File.regular?(context.beam_file_path)
 
-    assert msg =~ ~r"== Compilation error on file .+parallel_deadlock/foo\.ex =="
-    assert msg =~ ~r"== Compilation error on file .+parallel_deadlock/bar\.ex =="
-  end
+    # Set the .beam file to read-only
+    File.chmod!(context.beam_file_path, 4)
+    {:ok, %{access: access}} = File.stat(context.beam_file_path)
 
-  test "warnings as errors" do
-    warnings_as_errors = Code.compiler_options[:warnings_as_errors]
-    fixtures = [fixture_path("warnings_sample.ex")]
+    # Can only assert when read-only applies to the user
+    if access != :read_write do
+      output = elixirc(compilation_args, context.cli_extension)
 
-    try do
-      Code.compiler_options(warnings_as_errors: true)
+      expected =
+        "(File.Error) could not write to file #{inspect(context.beam_file_path)}: permission denied"
 
-      capture_io :stderr, fn ->
-        assert catch_exit(Kernel.ParallelCompiler.files fixtures) == 1
-      end
-    after
-      Code.compiler_options(warnings_as_errors: warnings_as_errors)
+      assert output =~ expected
     end
   end
 end
diff --git a/lib/elixir/test/elixir/kernel/comprehension_test.exs b/lib/elixir/test/elixir/kernel/comprehension_test.exs
index 1a731460407..97a0a6b733e 100644
--- a/lib/elixir/test/elixir/kernel/comprehension_test.exs
+++ b/lib/elixir/test/elixir/kernel/comprehension_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.ComprehensionTest do
   use ExUnit.Case, async: true
@@ -6,8 +10,24 @@ defmodule Kernel.ComprehensionTest do
   import ExUnit.CaptureIO
   require Integer
 
+  defmodule Pdict do
+    defstruct []
+
+    defimpl Collectable do
+      def into(struct) do
+        fun = fn
+          _, {:cont, x} -> Process.put(:into_cont, [x | Process.get(:into_cont)])
+          _, :done -> Process.put(:into_done, true)
+          _, :halt -> Process.put(:into_halt, true)
+        end
+
+        {struct, fun}
+      end
+    end
+  end
+
   defp to_bin(x) do
-    << x >>
+    <<x>>
   end
 
   defp nilly, do: nil
@@ -20,46 +40,161 @@ defmodule Kernel.ComprehensionTest do
   end
 
   test "for comprehensions with matching" do
-    assert for({_,x} <- 1..3, do: x * 2) == []
+    assert for({_, x} <- 1..3, do: x * 2) == []
+  end
+
+  test "for comprehensions with pin matching" do
+    maps = [x: 1, y: 2, x: 3]
+    assert for({:x, v} <- maps, do: v * 2) == [2, 6]
+    x = :x
+    assert for({^x, v} <- maps, do: v * 2) == [2, 6]
+  end
+
+  test "for comprehensions with guards" do
+    assert for(x when x < 4 <- 1..10, do: x) == [1, 2, 3]
+    assert for(x when x == 3 when x == 7 <- 1..10, do: x) == [3, 7]
+  end
+
+  test "for comprehensions with guards and filters" do
+    assert for(
+             {var, _}
+             when is_atom(var) <- [{:foo, 1}, {2, :bar}],
+             var = Atom.to_string(var),
+             do: var
+           ) == ["foo"]
+  end
+
+  test "for comprehensions with map key matching" do
+    maps = [%{x: 1}, %{y: 2}, %{x: 3}]
+    assert for(%{x: v} <- maps, do: v * 2) == [2, 6]
+    x = :x
+    assert for(%{^x => v} <- maps, do: v * 2) == [2, 6]
   end
 
   test "for comprehensions with filters" do
     assert for(x <- 1..3, x > 1, x < 3, do: x * 2) == [4]
   end
 
+  test "for comprehensions with unique values" do
+    list = [1, 1, 2, 3]
+    assert for(x <- list, uniq: true, do: x * 2) == [2, 4, 6]
+    assert for(x <- list, uniq: true, into: [], do: x * 2) == [2, 4, 6]
+    assert for(x <- list, uniq: true, into: %{}, do: {x, 1}) == %{1 => 1, 2 => 1, 3 => 1}
+    assert for(x <- list, uniq: true, into: "", do: to_bin(x * 2)) == <<2, 4, 6>>
+    assert for(<<x <- "abcabc">>, uniq: true, into: "", do: to_bin(x)) == "abc"
+
+    Process.put(:into_cont, [])
+    Process.put(:into_done, false)
+    Process.put(:into_halt, false)
+
+    for x <- list, uniq: true, into: %Pdict{} do
+      x * 2
+    end
+
+    assert Process.get(:into_cont) == [6, 4, 2]
+    assert Process.get(:into_done)
+    refute Process.get(:into_halt)
+
+    assert_raise RuntimeError, "oops", fn ->
+      for _ <- [1, 2, 3], uniq: true, into: %Pdict{}, do: raise("oops")
+    end
+
+    assert Process.get(:into_halt)
+  end
+
+  test "nested for comprehensions with unique values" do
+    assert for(x <- [1, 1, 2], uniq: true, do: for(y <- [3, 3], uniq: true, do: x * y)) == [
+             [3],
+             [6]
+           ]
+
+    assert for(<<x <- "abcabc">>,
+             uniq: true,
+             into: "",
+             do: for(<<y <- "zz">>, uniq: true, into: "", do: to_bin(x) <> to_bin(y))
+           ) == "azbzcz"
+  end
+
   test "for comprehensions with nilly filters" do
-    assert for(x <- 1..3, nilly, do: x * 2) == []
+    assert for(x <- 1..3, nilly(), do: x * 2) == []
+  end
+
+  test "for comprehensions with unique option where value is not used" do
+    assert capture_io(:stderr, fn ->
+             assert capture_io(fn ->
+                      Code.eval_quoted(
+                        quote do
+                          for x <- [1, 2, 1, 2], uniq: true, do: IO.puts(x)
+                          nil
+                        end
+                      )
+                    end) ==
+                      "1\n2\n1\n2\n"
+           end) =~
+             "the :uniq option has no effect since the result of the for comprehension is not used"
+  end
+
+  test "for comprehensions with unique option where value is assigned to _" do
+    assert capture_io(:stderr, fn ->
+             assert capture_io(fn ->
+                      Code.eval_quoted(
+                        quote do
+                          _ = for x <- [1, 2, 1, 2], uniq: true, do: IO.puts(x)
+                          nil
+                        end
+                      )
+                    end) ==
+                      "1\n2\n1\n2\n"
+           end) =~
+             "the :uniq option has no effect since the result of the for comprehension is not used"
   end
 
   test "for comprehensions with errors on filters" do
     assert_raise ArgumentError, fn ->
-      for(x <- 1..3, hd(x), do: x * 2)
+      for x <- 1..3, hd(x), do: :ok
     end
   end
 
   test "for comprehensions with variables in filters" do
-    assert for(x <- 1..3, y = x + 1, y > 2, z = y, do: x * z) ==
-           [6, 12]
+    assert for(x <- 1..3, y = x + 1, y > 2, z = y, do: x * z) == [6, 12]
   end
 
   test "for comprehensions with two enum generators" do
-    assert (for x <- [1, 2, 3], y <- [4, 5, 6], do: x * y) ==
-           [4, 5, 6, 8, 10, 12, 12, 15, 18]
+    assert for(
+             x <- [1, 2, 3],
+             y <- [4, 5, 6],
+             do: x * y
+           ) == [4, 5, 6, 8, 10, 12, 12, 15, 18]
   end
 
   test "for comprehensions with two enum generators and filters" do
-    assert (for x <- [1, 2, 3], y <- [4, 5, 6], y / 2 == x, do: x * y) ==
-           [8, 18]
+    assert for(
+             x <- [1, 2, 3],
+             y <- [4, 5, 6],
+             y / 2 == x,
+             do: x * y
+           ) == [8, 18]
   end
 
   test "for comprehensions generators precedence" do
-    assert (for {_, _} = x <- [foo: :bar], do: x) ==
-           [foo: :bar]
+    assert for({_, _} = x <- [foo: :bar], do: x) == [foo: :bar]
+  end
+
+  test "for comprehensions with shadowing" do
+    assert for(
+             a <-
+               (
+                 b = 1
+                 _ = b
+                 [1]
+               ),
+             b <- [2],
+             do: a + b
+           ) == [3]
   end
 
   test "for comprehensions with binary, enum generators and filters" do
-    assert (for x <- [1, 2, 3], << y <- <<4, 5, 6>> >>, y / 2 == x, do: x * y) ==
-           [8, 18]
+    assert for(x <- [1, 2, 3], <<(y <- <<4, 5, 6>>)>>, y / 2 == x, do: x * y) == [8, 18]
   end
 
   test "for comprehensions into list" do
@@ -68,17 +203,47 @@ defmodule Kernel.ComprehensionTest do
   end
 
   test "for comprehensions into binary" do
-    enum = 1..3
-    assert for(x <- enum, into: "", do: to_bin(x * 2)) == <<2, 4, 6>>
+    enum = 0..3
+
+    assert (for x <- enum, into: "" do
+              to_bin(x * 2)
+            end) == <<0, 2, 4, 6>>
+
+    assert (for x <- enum, into: "" do
+              if Integer.is_even(x), do: <<x::size(2)>>, else: <<x::size(1)>>
+            end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>
+  end
+
+  test "for comprehensions into dynamic binary" do
+    enum = 0..3
+    into = ""
+
+    assert (for x <- enum, into: into do
+              to_bin(x * 2)
+            end) == <<0, 2, 4, 6>>
+
+    assert (for x <- enum, into: into do
+              if Integer.is_even(x), do: <<x::size(2)>>, else: <<x::size(1)>>
+            end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>
+
+    into = <<7::size(1)>>
+
+    assert (for x <- enum, into: into do
+              to_bin(x * 2)
+            end) == <<7::size(1), 0, 2, 4, 6>>
+
+    assert (for x <- enum, into: into do
+              if Integer.is_even(x), do: <<x::size(2)>>, else: <<x::size(1)>>
+            end) == <<7::size(1), 0::size(2), 1::size(1), 2::size(2), 3::size(1)>>
   end
 
   test "for comprehensions where value is not used" do
     enum = 1..3
 
     assert capture_io(fn ->
-      for(x <- enum, do: IO.puts x)
-      nil
-    end) == "1\n2\n3\n"
+             for x <- enum, do: IO.puts(x)
+             nil
+           end) == "1\n2\n3\n"
   end
 
   test "for comprehensions with into" do
@@ -86,7 +251,7 @@ defmodule Kernel.ComprehensionTest do
     Process.put(:into_done, false)
     Process.put(:into_halt, false)
 
-    for x <- 1..3, into: collectable_pdict do
+    for x <- 1..3, into: %Pdict{} do
       x * 2
     end
 
@@ -101,7 +266,7 @@ defmodule Kernel.ComprehensionTest do
     Process.put(:into_halt, false)
 
     catch_error(
-      for x <- 1..3, into: collectable_pdict do
+      for x <- 1..3, into: %Pdict{} do
         if x > 2, do: raise("oops"), else: x
       end
     )
@@ -114,19 +279,38 @@ defmodule Kernel.ComprehensionTest do
   test "for comprehension with into, generators and filters" do
     Process.put(:into_cont, [])
 
-    for x <- 1..3, Integer.odd?(x), << y <- "hello" >>, into: collectable_pdict do
+    for x <- 1..3, Integer.is_odd(x), <<y <- "hello">>, into: %Pdict{} do
       x + y
     end
 
     assert IO.iodata_to_binary(Process.get(:into_cont)) == "roohkpmmfi"
   end
 
-  defp collectable_pdict do
-    fn
-      _, {:cont, x} -> Process.put(:into_cont, [x|Process.get(:into_cont)])
-      _, :done -> Process.put(:into_done, true)
-      _, :halt -> Process.put(:into_halt, true)
-    end
+  test "for comprehensions of map into map" do
+    enum = %{a: 2, b: 3}
+    assert for({k, v} <- enum, into: %{}, do: {k, v * v}) == %{a: 4, b: 9}
+  end
+
+  test "for comprehensions with reduce, generators and filters" do
+    acc =
+      for x <- 1..3, Integer.is_odd(x), <<y <- "hello">>, reduce: %{} do
+        acc -> Map.update(acc, x, [y], &[y | &1])
+      end
+
+    assert acc == %{1 => ~c"olleh", 3 => ~c"olleh"}
+  end
+
+  test "for comprehensions with matched reduce" do
+    acc =
+      for entry <- [1, 2, 3], reduce: {:ok, nil} do
+        {:ok, _} ->
+          {:ok, entry}
+
+        {:error, _} = error ->
+          error
+      end
+
+    assert acc == {:ok, 3}
   end
 
   ## List generators (inlined by the compiler)
@@ -137,26 +321,33 @@ defmodule Kernel.ComprehensionTest do
   end
 
   test "list for comprehensions with matching" do
-    assert for({_,x} <- [1, 2, a: 3, b: 4, c: 5], do: x * 2) == [6, 8, 10]
+    assert for({_, x} <- [1, 2, a: 3, b: 4, c: 5], do: x * 2) == [6, 8, 10]
+  end
+
+  test "list for comprehension matched to '_' on last line of block" do
+    assert (if true_fun() do
+              _ = for x <- [1, 2, 3], do: x * 2
+            end) == [2, 4, 6]
   end
 
+  defp true_fun(), do: true
+
   test "list for comprehensions with filters" do
     assert for(x <- [1, 2, 3], x > 1, x < 3, do: x * 2) == [4]
   end
 
   test "list for comprehensions with nilly filters" do
-    assert for(x <- [1, 2, 3], nilly, do: x * 2) == []
+    assert for(x <- [1, 2, 3], nilly(), do: x * 2) == []
   end
 
   test "list for comprehensions with errors on filters" do
     assert_raise ArgumentError, fn ->
-      for(x <- [1, 2, 3], hd(x), do: x * 2)
+      for x <- [1, 2, 3], hd(Process.get(:unused, x)), do: x * 2
     end
   end
 
   test "list for comprehensions with variables in filters" do
-    assert for(x <- [1, 2, 3], y = x + 1, y > 2, z = y, do: x * z) ==
-           [6, 12]
+    assert for(x <- [1, 2, 3], y = x + 1, y > 2, z = y, do: x * z) == [6, 12]
   end
 
   test "list for comprehensions into list" do
@@ -164,53 +355,185 @@ defmodule Kernel.ComprehensionTest do
     assert for(x <- enum, into: [], do: x * 2) == [2, 4, 6]
   end
 
-  test "list for comprehensions into binaries" do
-    enum = [1, 2, 3]
-    assert for(x <- enum, into: "", do: to_bin(x * 2)) == <<2, 4, 6>>
+  test "list for comprehensions into binary" do
+    enum = [0, 1, 2, 3]
+
+    assert (for x <- enum, into: "" do
+              to_bin(x * 2)
+            end) == <<0, 2, 4, 6>>
+
+    assert (for x <- enum, into: "" do
+              if Integer.is_even(x), do: <<x::size(2)>>, else: <<x::size(1)>>
+            end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>
+  end
+
+  test "list for comprehensions into dynamic binary" do
+    enum = [0, 1, 2, 3]
+    into = ""
+
+    assert (for x <- enum, into: into do
+              to_bin(x * 2)
+            end) == <<0, 2, 4, 6>>
+
+    assert (for x <- enum, into: into do
+              if Integer.is_even(x), do: <<x::size(2)>>, else: <<x::size(1)>>
+            end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>
+
+    into = <<7::size(1)>>
+
+    assert (for x <- enum, into: into do
+              to_bin(x * 2)
+            end) == <<7::size(1), 0, 2, 4, 6>>
+
+    assert (for x <- enum, into: into do
+              if Integer.is_even(x), do: <<x::size(2)>>, else: <<x::size(1)>>
+            end) == <<7::size(1), 0::size(2), 1::size(1), 2::size(2), 3::size(1)>>
   end
 
   test "list for comprehensions where value is not used" do
-    enum = [1,2,3]
+    enum = [1, 2, 3]
 
     assert capture_io(fn ->
-      for(x <- enum, do: IO.puts x)
-      nil
-    end) == "1\n2\n3\n"
+             for x <- enum, do: IO.puts(x)
+             nil
+           end) == "1\n2\n3\n"
+  end
+
+  test "list for comprehensions with reduce, generators and filters" do
+    acc =
+      for x <- [1, 2, 3], Integer.is_odd(x), <<y <- "hello">>, reduce: %{} do
+        acc -> Map.update(acc, x, [y], &[y | &1])
+      end
+
+    assert acc == %{1 => ~c"olleh", 3 => ~c"olleh"}
   end
 
   ## Binary generators (inlined by the compiler)
 
   test "binary for comprehensions" do
     bin = <<1, 2, 3>>
-    assert for(<< x <- bin >>, do: x * 2) == [2, 4, 6]
+    assert for(<<x <- bin>>, do: x * 2) == [2, 4, 6]
   end
 
   test "binary for comprehensions with inner binary" do
     bin = <<1, 2, 3>>
-    assert for(<< <<x>> <- bin >>, do: x * 2) == [2, 4, 6]
+    assert for(<<(<<x>> <- bin)>>, do: x * 2) == [2, 4, 6]
   end
 
   test "binary for comprehensions with two generators" do
-    assert (for << x <- <<1, 2, 3>> >>, << y <- <<4, 5, 6>> >>, y / 2 == x, do: x * y) ==
-           [8, 18]
+    assert for(<<(x <- <<1, 2, 3>>)>>, <<(y <- <<4, 5, 6>>)>>, y / 2 == x, do: x * y) == [8, 18]
   end
 
   test "binary for comprehensions into list" do
     bin = <<1, 2, 3>>
-    assert for(<< x <- bin >>, into: [], do: x * 2) == [2, 4, 6]
+    assert for(<<x <- bin>>, into: [], do: x * 2) == [2, 4, 6]
   end
 
-  test "binary for comprehensions into binaries" do
-    bin = <<1, 2, 3>>
-    assert for(<< x <- bin >>, into: "", do: to_bin(x * 2)) == <<2, 4, 6>>
+  test "binary for comprehensions into binary" do
+    bin = <<0, 1, 2, 3>>
+
+    assert (for <<x <- bin>>, into: "" do
+              to_bin(x * 2)
+            end) == <<0, 2, 4, 6>>
+
+    assert (for <<x <- bin>>, into: "" do
+              if Integer.is_even(x), do: <<x::size(2)>>, else: <<x::size(1)>>
+            end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>
+  end
+
+  test "binary for comprehensions into dynamic binary" do
+    bin = <<0, 1, 2, 3>>
+    into = ""
+
+    assert (for <<x <- bin>>, into: into do
+              to_bin(x * 2)
+            end) == <<0, 2, 4, 6>>
+
+    assert (for <<x <- bin>>, into: into do
+              if Integer.is_even(x), do: <<x::size(2)>>, else: <<x::size(1)>>
+            end) == <<0::size(2), 1::size(1), 2::size(2), 3::size(1)>>
+
+    into = <<7::size(1)>>
+
+    assert (for <<x <- bin>>, into: into do
+              to_bin(x * 2)
+            end) == <<7::size(1), 0, 2, 4, 6>>
+
+    assert (for <<x <- bin>>, into: into do
+              if Integer.is_even(x), do: <<x::size(2)>>, else: <<x::size(1)>>
+            end) == <<7::size(1), 0::size(2), 1::size(1), 2::size(2), 3::size(1)>>
+  end
+
+  test "binary for comprehensions with literal matches" do
+    # Integers
+    bin = <<1, 2, 1, 3, 1, 4>>
+    assert for(<<1, x <- bin>>, into: "", do: to_bin(x)) == <<2, 3, 4>>
+    assert for(<<1, x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2, 3 => 3, 4 => 4}
+
+    bin = <<1, 2, 3, 1, 4>>
+    assert for(<<1, x <- bin>>, into: "", do: to_bin(x)) == <<2>>
+    assert for(<<1, x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2}
+
+    # Floats
+    bin = <<1.0, 2, 1.0, 3, 1.0, 4>>
+    assert for(<<1.0, x <- bin>>, into: "", do: to_bin(x)) == <<2, 3, 4>>
+    assert for(<<1.0, x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2, 3 => 3, 4 => 4}
+
+    bin = <<1.0, 2, 3, 1.0, 4>>
+    assert for(<<1.0, x <- bin>>, into: "", do: to_bin(x)) == <<2>>
+    assert for(<<1.0, x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2}
+
+    # Binaries
+    bin = <<"foo", 2, "foo", 3, "foo", 4>>
+    assert for(<<"foo", x <- bin>>, into: "", do: to_bin(x)) == <<2, 3, 4>>
+    assert for(<<"foo", x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2, 3 => 3, 4 => 4}
+
+    bin = <<"foo", 2, 3, "foo", 4>>
+    assert for(<<"foo", x <- bin>>, into: "", do: to_bin(x)) == <<2>>
+    assert for(<<"foo", x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2}
+
+    bin = <<"foo", 2, 3, 4, "foo", 5>>
+    assert for(<<"foo", x <- bin>>, into: "", do: to_bin(x)) == <<2>>
+    assert for(<<"foo", x <- bin>>, into: %{}, do: {x, x}) == %{2 => 2}
+  end
+
+  test "binary for comprehensions with variable size" do
+    s = 16
+    bin = <<1, 2, 3, 4, 5, 6>>
+    assert for(<<x::size(^s) <- bin>>, into: "", do: to_bin(div(x, 2))) == <<129, 130, 131>>
+
+    s = 8
+    bin = <<1, 2, 3, 4, 5, 6>>
+    assert for(<<s, x::size(^s) <- bin>>, into: "", do: <<x * s>>) == <<2, 12, 30>>
+
+    # Aligned
+    bin = <<8, 1, 16, 2, 3>>
+    assert for(<<s, x::size(s) <- bin>>, into: "", do: <<x::size(s)>>) == <<1, 2, 3>>
+    assert for(<<s, x::size(s) <- bin>>, into: %{}, do: {s, x}) == %{8 => 1, 16 => 515}
+
+    # Unaligned
+    bin = <<8, 1, 32, 2, 3>>
+    assert for(<<s, x::size(s) <- bin>>, into: "", do: <<x::size(s)>>) == <<1>>
+    assert for(<<s, x::size(s) <- bin>>, into: %{}, do: {s, x}) == %{8 => 1}
   end
 
   test "binary for comprehensions where value is not used" do
     bin = <<1, 2, 3>>
 
     assert capture_io(fn ->
-      for(<<x <- bin>>, do: IO.puts x)
-      nil
-    end) == "1\n2\n3\n"
+             for <<x <- bin>>, do: IO.puts(x)
+             nil
+           end) == "1\n2\n3\n"
+  end
+
+  test "binary for comprehensions with reduce, generators and filters" do
+    bin = <<1, 2, 3>>
+
+    acc =
+      for <<x <- bin>>, Integer.is_odd(x), <<y <- "hello">>, reduce: %{} do
+        acc -> Map.update(acc, x, [y], &[y | &1])
+      end
+
+    assert acc == %{1 => ~c"olleh", 3 => ~c"olleh"}
   end
 end
diff --git a/lib/elixir/test/elixir/kernel/defaults_test.exs b/lib/elixir/test/elixir/kernel/defaults_test.exs
new file mode 100644
index 00000000000..4c5df72118d
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/defaults_test.exs
@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.DefaultsTest do
+  use ExUnit.Case, async: true
+
+  import ExUnit.CaptureIO
+
+  def fun_with_fn_defaults(
+        x,
+        fun1 \\ & &1,
+        fun2 \\ & &1,
+        y
+      ) do
+    {fun1.(x), fun2.(y)}
+  end
+
+  def fun_with_block_defaults(
+        x,
+        y \\ (
+          default = "y"
+          default
+        ),
+        z \\ (
+          default = "z"
+          default
+        )
+      ) do
+    {x, y, z}
+  end
+
+  test "with anonymous function defaults" do
+    assert {1, 2} = fun_with_fn_defaults(1, 2)
+    assert {100, 2} = fun_with_fn_defaults(1, &(&1 * 100), 2)
+    assert {100, 12} = fun_with_fn_defaults(1, &(&1 * 100), &(&1 + 10), 2)
+  end
+
+  test "with block defaults" do
+    assert {1, "y", "z"} = fun_with_block_defaults(1)
+    assert {1, 2, "z"} = fun_with_block_defaults(1, 2)
+    assert {1, 2, 3} = fun_with_block_defaults(1, 2, 3)
+  end
+
+  test "errors on accessing variable from default block" do
+    assert_compile_error(~r/undefined variable \"default\"/, fn ->
+      defmodule VarDefaultScope do
+        def test(_ \\ default = 1),
+          do: default
+      end
+    end)
+  end
+
+  test "errors on multiple defaults" do
+    message = ~r"def hello/1 defines defaults multiple times"
+
+    assert_compile_error(message, fn ->
+      defmodule Kernel.ErrorsTest.ClauseWithDefaults do
+        def hello(_arg \\ 0)
+        def hello(_arg \\ 1)
+      end
+    end)
+
+    assert_compile_error(message, fn ->
+      defmodule Kernel.ErrorsTest.ClauseWithDefaults do
+        def hello(_arg \\ 0), do: nil
+        def hello(_arg \\ 1), do: nil
+      end
+    end)
+
+    assert_compile_error(message, fn ->
+      defmodule Kernel.ErrorsTest.ClauseWithDefaults do
+        def hello(_arg \\ 0)
+        def hello(_arg \\ 1), do: nil
+      end
+    end)
+
+    assert_compile_error(message, fn ->
+      defmodule Kernel.ErrorsTest.ClauseWithDefaults do
+        def hello(_arg \\ 0), do: nil
+        def hello(_arg \\ 1)
+      end
+    end)
+
+    assert_compile_error("undefined variable \"foo\"", fn ->
+      defmodule Kernel.ErrorsTest.ClauseWithDefaults5 do
+        def hello(foo, bar \\ foo)
+        def hello(foo, bar), do: foo + bar
+      end
+    end)
+  end
+
+  test "errors on conflicting defaults" do
+    assert_compile_error(~r"def hello/3 defaults conflicts with hello/2", fn ->
+      defmodule Kernel.ErrorsTest.DifferentDefsWithDefaults1 do
+        def hello(a, b \\ nil), do: a + b
+        def hello(a, b \\ nil, c \\ nil), do: a + b + c
+      end
+    end)
+
+    assert_compile_error(~r"def hello/2 conflicts with defaults from hello/3", fn ->
+      defmodule Kernel.ErrorsTest.DifferentDefsWithDefaults2 do
+        def hello(a, b \\ nil, c \\ nil), do: a + b + c
+        def hello(a, b \\ nil), do: a + b
+      end
+    end)
+  end
+
+  defp assert_compile_error(message, fun) do
+    assert capture_io(:stderr, fn ->
+             assert_raise CompileError, fun
+           end) =~ message
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/deprecated_test.exs b/lib/elixir/test/elixir/kernel/deprecated_test.exs
new file mode 100644
index 00000000000..be2145b19e8
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/deprecated_test.exs
@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.DeprecatedTest do
+  use ExUnit.Case
+
+  import PathHelpers
+
+  test "raises on invalid @deprecated" do
+    assert_raise ArgumentError, ~r"should be a string with the reason", fn ->
+      defmodule InvalidDeprecated do
+        @deprecated 1.2
+        def foo, do: :bar
+      end
+    end
+  end
+
+  test "takes into account deprecated from defaults" do
+    defmodule DefaultDeprecated do
+      @deprecated "reason"
+      def foo(x \\ true), do: x
+    end
+
+    assert DefaultDeprecated.__info__(:deprecated) == [
+             {{:foo, 0}, "reason"},
+             {{:foo, 1}, "reason"}
+           ]
+  end
+
+  test "add deprecated to __info__" do
+    write_beam(
+      defmodule SampleDeprecated do
+        @deprecated "Use SampleDeprecated.bar/0 instead"
+        def foo, do: true
+
+        def bar, do: false
+      end
+    )
+
+    deprecated = [
+      {{:foo, 0}, "Use SampleDeprecated.bar/0 instead"}
+    ]
+
+    assert SampleDeprecated.__info__(:deprecated) == deprecated
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/diagnostics_test.exs b/lib/elixir/test/elixir/kernel/diagnostics_test.exs
new file mode 100644
index 00000000000..cf34c5ce741
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/diagnostics_test.exs
@@ -0,0 +1,1512 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.DiagnosticsTest do
+  use ExUnit.Case, async: false
+
+  import ExUnit.CaptureIO
+
+  setup_all do
+    previous = Application.get_env(:elixir, :ansi_enabled, false)
+    Application.put_env(:elixir, :ansi_enabled, false)
+    on_exit(fn -> Application.put_env(:elixir, :ansi_enabled, previous) end)
+  end
+
+  describe "mismatched delimiter" do
+    test "same line - handles unicode input" do
+      output =
+        capture_raise(
+          """
+          [1, 2, 3, 4, 5, 6) <- 😎
+          """,
+          MismatchedDelimiterError
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:1:18:
+                 error: unexpected token: )
+                 │
+               1 │ [1, 2, 3, 4, 5, 6) <- 😎
+                 │ │                └ mismatched closing delimiter (expected "]")
+                 │ └ unclosed delimiter
+                 │
+                 └─ nofile:1:18\
+             """
+    end
+
+    test "same line" do
+      output =
+        capture_raise(
+          """
+          [1, 2, 3, 4, 5, 6)
+          """,
+          MismatchedDelimiterError
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:1:18:
+                 error: unexpected token: )
+                 │
+               1 │ [1, 2, 3, 4, 5, 6)
+                 │ │                └ mismatched closing delimiter (expected "]")
+                 │ └ unclosed delimiter
+                 │
+                 └─ nofile:1:18\
+             """
+    end
+
+    test "same line with offset" do
+      output =
+        capture_raise(
+          """
+          [1, 2, 3, 4, 5, 6)
+          """,
+          MismatchedDelimiterError,
+          line: 3
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:3:18:
+                 error: unexpected token: )
+                 │
+               3 │ [1, 2, 3, 4, 5, 6)
+                 │ │                └ mismatched closing delimiter (expected "]")
+                 │ └ unclosed delimiter
+                 │
+                 └─ nofile:3:18\
+             """
+    end
+
+    test "two-line span" do
+      output =
+        capture_raise(
+          """
+          [a, b, c
+           d, f, g}
+          """,
+          MismatchedDelimiterError
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:2:9:
+                 error: unexpected token: }
+                 │
+               1 │ [a, b, c
+                 │ └ unclosed delimiter
+               2 │  d, f, g}
+                 │         └ mismatched closing delimiter (expected "]")
+                 │
+                 └─ nofile:2:9\
+             """
+    end
+
+    test "two-line span with offset" do
+      output =
+        capture_raise(
+          """
+          [a, b, c
+           d, f, g}
+          """,
+          MismatchedDelimiterError,
+          line: 3
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:4:9:
+                 error: unexpected token: }
+                 │
+               3 │ [a, b, c
+                 │ └ unclosed delimiter
+               4 │  d, f, g}
+                 │         └ mismatched closing delimiter (expected "]")
+                 │
+                 └─ nofile:4:9\
+             """
+    end
+
+    test "many-line span" do
+      output =
+        capture_raise(
+          """
+              [ a,
+            b,
+            c,
+            d
+            e )
+          """,
+          MismatchedDelimiterError
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:5:5:
+                 error: unexpected token: )
+                 │
+               1 │     [ a,
+                 │     └ unclosed delimiter
+               2 │   b,
+               3 │   c,
+               4 │   d
+               5 │   e )
+                 │     └ mismatched closing delimiter (expected "]")
+                 │
+                 └─ nofile:5:5\
+             """
+    end
+
+    test "many-line span with offset" do
+      output =
+        capture_raise(
+          """
+          fn always_forget_end ->
+            IO.inspect(2 + 2) + 2
+          )
+          """,
+          MismatchedDelimiterError,
+          line: 3
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:5:1:
+                 error: unexpected token: )
+                 │
+               3 │ fn always_forget_end ->
+                 │ └ unclosed delimiter
+               4 │   IO.inspect(2 + 2) + 2
+               5 │ )
+                 │ └ mismatched closing delimiter (expected "end")
+                 │
+                 └─ nofile:5:1\
+             """
+    end
+
+    test "line range - handles unicode input" do
+      output =
+        capture_raise(
+          """
+          defmodule A do
+            IO.inspect(2 + 2)
+          ) <- 😎
+          """,
+          MismatchedDelimiterError
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:3:1:
+                 error: unexpected token: )
+                 │
+               1 │ defmodule A do
+                 │             └ unclosed delimiter
+               2 │   IO.inspect(2 + 2)
+               3 │ ) <- 😎
+                 │ └ mismatched closing delimiter (expected "end")
+                 │
+                 └─ nofile:3:1\
+             """
+    end
+
+    test "trim in between lines if too many" do
+      output =
+        capture_raise(
+          """
+          [ :a,
+            :b,
+            :c,
+            :d,
+            :e,
+            :f,
+            :g,
+            :h
+          )
+          """,
+          MismatchedDelimiterError
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:9:1:
+                 error: unexpected token: )
+                 │
+               1 │ [ :a,
+                 │ └ unclosed delimiter
+              ...
+               9 │ )
+                 │ └ mismatched closing delimiter (expected "]")
+                 │
+                 └─ nofile:9:1\
+             """
+    end
+
+    test "trimmed line range - handles unicode input" do
+      output =
+        capture_raise(
+          """
+          [ :a,
+            :b,
+            :c,
+            :d,
+            :e,
+            :f,
+            :g,
+            :h
+          ) <- 😎
+          """,
+          MismatchedDelimiterError
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:9:1:
+                 error: unexpected token: )
+                 │
+               1 │ [ :a,
+                 │ └ unclosed delimiter
+              ...
+               9 │ ) <- 😎
+                 │ └ mismatched closing delimiter (expected "]")
+                 │
+                 └─ nofile:9:1\
+             """
+    end
+
+    test "pads according to line number digits" do
+      output =
+        capture_raise(
+          """
+          [ a,
+          #{String.duplicate("\n", 10)}
+            b )
+          """,
+          MismatchedDelimiterError
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:13:5:
+                 error: unexpected token: )
+                 │
+               1 │ [ a,
+                 │ └ unclosed delimiter
+              ...
+              13 │   b )
+                 │     └ mismatched closing delimiter (expected "]")
+                 │
+                 └─ nofile:13:5\
+             """
+
+      output =
+        capture_raise(
+          """
+          [ a,
+          #{String.duplicate("\n", 400)}
+            b )
+          """,
+          MismatchedDelimiterError
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:403:5:
+                  error: unexpected token: )
+                  │
+                1 │ [ a,
+                  │ └ unclosed delimiter
+              ...
+              403 │   b )
+                  │     └ mismatched closing delimiter (expected "]")
+                  │
+                  └─ nofile:403:5\
+             """
+
+      output =
+        capture_raise(
+          """
+          #{String.duplicate("\n", 97)}
+          [ a,
+          #{String.duplicate("\n", 6)}
+            b )
+          """,
+          MismatchedDelimiterError
+        )
+
+      assert output == """
+             ** (MismatchedDelimiterError) mismatched delimiter found on nofile:107:5:
+                  error: unexpected token: )
+                  │
+               99 │ [ a,
+                  │ └ unclosed delimiter
+              ...
+              107 │   b )
+                  │     └ mismatched closing delimiter (expected "]")
+                  │
+                  └─ nofile:107:5\
+             """
+    end
+  end
+
+  describe "token missing error" do
+    test "missing parens terminator" do
+      output =
+        capture_raise(
+          """
+          my_numbers = [1, 2, 3, 4, 5, 6
+          IO.inspect(my_numbers)
+          """,
+          TokenMissingError
+        )
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:2:23:
+                 error: missing terminator: ]
+                 │
+               1 │ my_numbers = [1, 2, 3, 4, 5, 6
+                 │              └ unclosed delimiter
+               2 │ IO.inspect(my_numbers)
+                 │                       └ missing closing delimiter (expected "]")
+                 │
+                 └─ nofile:2:23\
+             """
+    end
+
+    test "missing heredoc terminator" do
+      output =
+        capture_raise(
+          """
+          a = \"""
+          test string
+
+          IO.inspect(10 + 20)
+          """,
+          TokenMissingError
+        )
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:4:20:
+                 error: missing terminator: \""" (for heredoc starting at line 1)
+                 │
+               1 │ a = \"""
+                 │     └ unclosed delimiter
+               2 │ test string
+               3 │\s
+               4 │ IO.inspect(10 + 20)
+                 │                    └ missing closing delimiter (expected \""")
+                 │
+                 └─ nofile:4:20\
+             """
+    end
+
+    test "missing sigil terminator" do
+      output =
+        capture_raise("~s<foobar", TokenMissingError)
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:1:10:
+                 error: missing terminator: > (for sigil ~s< starting at line 1)
+                 │
+               1 │ ~s<foobar
+                 │   │      └ missing closing delimiter (expected ">")
+                 │   └ unclosed delimiter
+                 │
+                 └─ nofile:1:10\
+             """
+
+      output =
+        capture_raise("~s|foobar", TokenMissingError)
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:1:10:
+                 error: missing terminator: | (for sigil ~s| starting at line 1)
+                 │
+               1 │ ~s|foobar
+                 │   │      └ missing closing delimiter (expected "|")
+                 │   └ unclosed delimiter
+                 │
+                 └─ nofile:1:10\
+             """
+    end
+
+    test "missing string terminator" do
+      output =
+        capture_raise("\"foobar", TokenMissingError)
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:1:8:
+                 error: missing terminator: " (for string starting at line 1)
+                 │
+               1 │ "foobar
+                 │ │      └ missing closing delimiter (expected ")
+                 │ └ unclosed delimiter
+                 │
+                 └─ nofile:1:8\
+             """
+    end
+
+    test "missing atom terminator" do
+      output =
+        capture_raise(":\"foobar", TokenMissingError)
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:1:9:
+                 error: missing terminator: " (for atom starting at line 1)
+                 │
+               1 │ :"foobar
+                 │  │      └ missing closing delimiter (expected ")
+                 │  └ unclosed delimiter
+                 │
+                 └─ nofile:1:9\
+             """
+    end
+
+    test "missing function terminator" do
+      output =
+        capture_raise("K.\"foobar", TokenMissingError)
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:1:10:
+                 error: missing terminator: " (for function name starting at line 1)
+                 │
+               1 │ K."foobar
+                 │   │      └ missing closing delimiter (expected ")
+                 │   └ unclosed delimiter
+                 │
+                 └─ nofile:1:10\
+             """
+    end
+
+    test "shows in between lines if EOL is not far below" do
+      output =
+        capture_raise(
+          """
+          my_numbers = [1, 2, 3, 4, 5, 6
+          my_numbers
+          |> Enum.map(&(&1 + 1))
+          |> Enum.map(&(&1 * &1))
+          |> IO.inspect()
+          """,
+          TokenMissingError
+        )
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:5:16:
+                 error: missing terminator: ]
+                 │
+               1 │ my_numbers = [1, 2, 3, 4, 5, 6
+                 │              └ unclosed delimiter
+               2 │ my_numbers
+               3 │ |> Enum.map(&(&1 + 1))
+               4 │ |> Enum.map(&(&1 * &1))
+               5 │ |> IO.inspect()
+                 │                └ missing closing delimiter (expected "]")
+                 │
+                 └─ nofile:5:16\
+             """
+    end
+
+    test "trims lines" do
+      output =
+        capture_raise(
+          """
+          my_numbers = (1, 2, 3, 4, 5, 6
+
+
+
+
+
+
+          IO.inspect(my_numbers)
+          """,
+          TokenMissingError
+        )
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:8:23:
+                 error: missing terminator: )
+                 │
+               1 │ my_numbers = (1, 2, 3, 4, 5, 6
+                 │              └ unclosed delimiter
+              ...
+               8 │ IO.inspect(my_numbers)
+                 │                       └ missing closing delimiter (expected ")")
+                 │
+                 └─ nofile:8:23\
+             """
+    end
+
+    test "shows the last non-empty line of a file" do
+      output =
+        capture_raise(
+          """
+          my_numbers = {1, 2, 3, 4, 5, 6
+          IO.inspect(my_numbers)
+
+
+
+
+          """,
+          TokenMissingError
+        )
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:2:23:
+                 error: missing terminator: }
+                 │
+               1 │ my_numbers = {1, 2, 3, 4, 5, 6
+                 │              └ unclosed delimiter
+               2 │ IO.inspect(my_numbers)
+                 │                       └ missing closing delimiter (expected "}")
+                 │
+                 └─ nofile:2:23\
+             """
+    end
+
+    test "supports unicode" do
+      output =
+        capture_raise(
+          """
+          my_emojis = [1, 2, 3, 4 # ⚗️
+          IO.inspect(my_numbers)
+          """,
+          TokenMissingError
+        )
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:2:23:
+                 error: missing terminator: ]
+                 │
+               1 │ my_emojis = [1, 2, 3, 4 # ⚗️
+                 │             └ unclosed delimiter
+               2 │ IO.inspect(my_numbers)
+                 │                       └ missing closing delimiter (expected "]")
+                 │
+                 └─ nofile:2:23\
+             """
+    end
+  end
+
+  describe "compile-time exceptions" do
+    test "SyntaxError (snippet)" do
+      output =
+        capture_raise(
+          """
+          [1, 2, 3, 4, 5, *]
+          """,
+          SyntaxError
+        )
+
+      assert output == """
+             ** (SyntaxError) invalid syntax found on nofile:1:17:
+                 error: syntax error before: '*'
+                 │
+               1 │ [1, 2, 3, 4, 5, *]
+                 │                 ^
+                 │
+                 └─ nofile:1:17\
+             """
+    end
+
+    test "SyntaxError (snippet) with offset" do
+      output =
+        capture_raise(
+          """
+          [1, 2, 3, 4, 5, *]
+          """,
+          SyntaxError,
+          line: 3
+        )
+
+      assert output == """
+             ** (SyntaxError) invalid syntax found on nofile:3:17:
+                 error: syntax error before: '*'
+                 │
+               3 │ [1, 2, 3, 4, 5, *]
+                 │                 ^
+                 │
+                 └─ nofile:3:17\
+             """
+    end
+
+    test "TokenMissingError (snippet)" do
+      output =
+        capture_raise(
+          """
+          1 +
+          """,
+          TokenMissingError
+        )
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:1:4:
+                 error: syntax error: expression is incomplete
+                 │
+               1 │ 1 +
+                 │    ^
+                 │
+                 └─ nofile:1:4\
+             """
+    end
+
+    test "TokenMissingError (snippet) with offset and column" do
+      output =
+        capture_raise(
+          """
+          1 +
+          """,
+          TokenMissingError,
+          line: 3,
+          column: 3
+        )
+
+      assert output == """
+             ** (TokenMissingError) token missing on nofile:3:6:
+                 error: syntax error: expression is incomplete
+                 │
+               3 │   1 +
+                 │      ^
+                 │
+                 └─ nofile:3:6\
+             """
+    end
+
+    test "TokenMissingError (unclosed delimiter)" do
+      expected = """
+      ** (TokenMissingError) token missing on nofile:1:5:
+          error: missing terminator: end
+          │
+        1 │ fn a
+          │ │   └ missing closing delimiter (expected "end")
+          │ └ unclosed delimiter
+          │
+          └─ nofile:1:5\
+      """
+
+      output =
+        capture_raise(
+          """
+          fn a
+          """,
+          TokenMissingError
+        )
+
+      assert output == expected
+    end
+
+    test "keeps trailing whitespace if under threshold" do
+      expected = """
+      ** (SyntaxError) invalid syntax found on nofile:1:23:
+          error: unexpected token: "😎" (column 23, code point U+****)
+          │
+        1 │                   a + 😎
+          │                       ^
+          │
+          └─ nofile:1:23\
+      """
+
+      output =
+        capture_raise(
+          """
+                            a + 😎
+          """,
+          SyntaxError
+        )
+
+      assert output == expected
+    end
+
+    test "limits trailing whitespace if too many" do
+      expected = """
+      ** (SyntaxError) invalid syntax found on nofile:1:43:
+          error: unexpected token: "😎" (column 43, code point U+****)
+          │
+        1 │ ...                   a + 😎
+          │                           ^
+          │
+          └─ nofile:1:43\
+      """
+
+      output =
+        capture_raise(
+          """
+                                                a + 😎
+          """,
+          SyntaxError
+        )
+
+      assert output == expected
+    end
+
+    test "shows stacktrace if present" do
+      fake_stacktrace = [
+        {:fake, :fun, 3, [file: "nofile", line: 10]},
+        {:real, :fun, 2, [file: "nofile", line: 10]}
+      ]
+
+      expected = """
+      ** (TokenMissingError) token missing on nofile:1:4:
+          error: syntax error: expression is incomplete
+          │
+        1 │ 1 -
+          │    ^
+          │
+          └─ nofile:1:4
+          nofile:10: :fake.fun/3
+          nofile:10: :real.fun/2
+      """
+
+      output =
+        capture_raise(
+          """
+          1 -
+          """,
+          TokenMissingError,
+          stacktrace: fake_stacktrace
+        )
+
+      assert output == expected
+    end
+
+    test "2-digit line errors stay aligned 1-digit line errors" do
+      fake_stacktrace = [
+        {:fake, :fun, 3, [file: "nofile", line: 10]}
+      ]
+
+      expected = """
+      ** (TokenMissingError) token missing on nofile:12:4:
+          error: syntax error: expression is incomplete
+          │
+       12 │ 1 -
+          │    ^
+          │
+          └─ nofile:12:4
+          nofile:10: :fake.fun/3
+      """
+
+      output =
+        capture_raise(
+          """
+          #{String.duplicate("\n", 10)}
+          1 -
+          """,
+          TokenMissingError,
+          stacktrace: fake_stacktrace
+        )
+
+      assert output == expected
+    end
+
+    test "handles unicode" do
+      source = """
+      defmodule Sample do
+        def a do
+          10 + 😎
+        end
+      end
+      """
+
+      output = capture_raise(source, SyntaxError)
+
+      assert output =~ "😎"
+    after
+      purge(Sample)
+    end
+  end
+
+  describe "compiler warnings" do
+    @tag :tmp_dir
+    test "simple warning (line + column + file)", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "long-warning.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+        defp a, do: Unknown.b()
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: Unknown.b/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)
+          │
+        3 │   defp a, do: Unknown.b()
+          │                       ~
+          │
+          └─ #{path}:3:23: Sample.a/0
+      """
+
+      assert capture_eval(source) =~ expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "simple warning (line + file)", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "long-warning.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+        defp a, do: Unknown.b()
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: Unknown.b/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)
+          │
+        3 │   defp a, do: Unknown.b()
+          │   ~~~~~~~~~~~~~~~~~~~~~~~
+          │
+          └─ #{path}:3: Sample.a/0
+      """
+
+      assert capture_eval(source, columns: false) =~ expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "simple warning with tabs (line + file)", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "long-warning.ex")
+
+      source = """
+      defmodule Sample do
+      \t@file "#{path}"
+      \tdefp a do
+      \t\tUnknown.b()
+      \tend
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: Unknown.b/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)
+          │
+        4 │ \t\tUnknown.b()
+          │                 ~~~~~~~~~~~
+          │
+          └─ #{path}:4: Sample.a/0
+      """
+
+      assert capture_eval(source, columns: false) =~ expected
+    after
+      purge(Sample)
+    end
+
+    test "simple warning (no file)" do
+      source = """
+      defmodule Sample do
+        defp a, do: Unknown.b()
+      end
+      """
+
+      expected = """
+      warning: Unknown.b/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)
+      └─ nofile:2:23: Sample.a/0
+      """
+
+      assert capture_eval(source) =~ expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "IO.warn file+line", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "io-warn-file-line.ex")
+
+      source = """
+      IO.warn("oops\\nmulti\\nline", file: __ENV__.file, line: __ENV__.line)
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: oops
+          multi
+          line
+          │
+        1 │ IO.warn("oops\\nmulti\\nline", file: __ENV__.file, line: __ENV__.line)
+          │ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          │
+          └─ tmp\
+      """
+
+      assert capture_io(:stderr, fn -> Code.eval_file(path) end) =~ expected
+    end
+
+    @tag :tmp_dir
+    test "IO.warn file+line+column", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "io-warn-file-line-column.ex")
+
+      source = """
+      IO.warn("oops\\nmulti\\nline", file: __ENV__.file, line: __ENV__.line, column: 4)
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: oops
+          multi
+          line
+          │
+        1 │ IO.warn("oops\\nmulti\\nline", file: __ENV__.file, line: __ENV__.line, column: 4)
+          │    ~
+          │
+          └─ tmp\
+      """
+
+      assert capture_io(:stderr, fn -> Code.eval_file(path) end) =~ expected
+    end
+
+    test "IO.warn with missing data" do
+      assert capture_eval("""
+             IO.warn("oops-bad", file: #{inspect(__ENV__.file)}, line: 3, column: nil)
+             """) =~ "warning: oops-bad"
+
+      assert capture_eval("""
+             IO.warn("oops-bad", file: #{inspect(__ENV__.file)}, line: nil)
+             """) =~ "oops-bad"
+
+      assert capture_eval("""
+             IO.warn("oops-bad", file: nil)
+             """) =~ "oops-bad"
+    end
+
+    @tag :tmp_dir
+    test "trims lines if too many whitespaces", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "trim_warning_line.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+
+        def a do
+                                                  Unknown.bar(:test)
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: Unknown.bar/1 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)
+          │
+        5 │ ...                   Unknown.bar(:test)
+          │                               ~
+          │
+          └─ #{path}:5:53: Sample.a/0
+
+      """
+
+      assert capture_eval(source) == expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "handles unicode", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "warning_group_unicode.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+
+        def a do
+          Unknown.bar("😎")
+          Unknown.bar("😎")
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      assert capture_eval(source) =~ "😎"
+    after
+      purge(Sample)
+    end
+  end
+
+  describe "warning groups" do
+    test "no file" do
+      source = """
+      defmodule Sample do
+        def a do
+          Unknown.bar()
+          Unknown.bar()
+          Unknown.bar()
+          Unknown.bar()
+        end
+      end
+      """
+
+      expected = """
+      warning: Unknown.bar/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)
+      └─ nofile:3:13: Sample.a/0
+      └─ nofile:4:13: Sample.a/0
+      └─ nofile:5:13: Sample.a/0
+      └─ nofile:6:13: Sample.a/0
+
+      """
+
+      assert capture_eval(source) =~ expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "file + line + column", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "warning_group_nofile.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+
+        def a do
+          Unknown.bar()
+          Unknown.bar()
+          Unknown.bar()
+          Unknown.bar()
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: Unknown.bar/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)
+          │
+        5 │     Unknown.bar()
+          │             ~
+          │
+          └─ #{path}:5:13: Sample.a/0
+          └─ #{path}:6:13: Sample.a/0
+          └─ #{path}:7:13: Sample.a/0
+          └─ #{path}:8:13: Sample.a/0
+
+      """
+
+      assert capture_eval(source) == expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "file + line", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "warning_group_nofile.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+
+        def a do
+          Unknown.bar()
+          Unknown.bar()
+          Unknown.bar()
+          Unknown.bar()
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: Unknown.bar/0 is undefined (module Unknown is not available or is yet to be defined). Make sure the module name is correct and has been specified in full (or that an alias has been defined)
+          │
+        5 │     Unknown.bar()
+          │     ~~~~~~~~~~~~~
+          │
+          └─ #{path}:5: Sample.a/0
+          └─ #{path}:6: Sample.a/0
+          └─ #{path}:7: Sample.a/0
+          └─ #{path}:8: Sample.a/0
+
+      """
+
+      assert capture_eval(source, columns: false) == expected
+    after
+      purge(Sample)
+    end
+  end
+
+  describe "error diagnostics" do
+    @tag :tmp_dir
+    test "line only", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "error_line_only.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+        def CamelCase do
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          error: function names should start with lowercase characters or underscore, invalid name CamelCase
+          │
+        3 │   def CamelCase do
+          │   ^^^^^^^^^^^^^^^^
+          │
+          └─ #{path}:3
+
+      """
+
+      assert capture_compile(source, columns: false) == expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "shows span for unused variables", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "error_line_column.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+
+        def foo(unused_param) do
+          :constant
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: variable "unused_param" is unused (if the variable is not meant to be used, prefix it with an underscore)
+          │
+        4 │   def foo(unused_param) do
+          │           ~~~~~~~~~~~~
+          │
+          └─ #{path}:4:11: Sample.foo/1
+
+      """
+
+      assert capture_eval(source) == expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "shows span for undefined variables", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "undefined_variable_span.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+
+        def foo(a) do
+          a - unknown_var
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          error: undefined variable "unknown_var"
+          │
+        5 │     a - unknown_var
+          │         ^^^^^^^^^^^
+          │
+          └─ #{path}:5:9: Sample.foo/1
+
+      """
+
+      assert capture_compile(source) == expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "shows span for unknown local function calls", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "unknown_local_function_call.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+
+        def foo do
+          _result = unknown_func_call!(:hello!)
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          error: undefined function unknown_func_call!/1 (expected Sample to define such a function or for it to be imported, but none are available)
+          │
+        5 │     _result = unknown_func_call!(:hello!)
+          │               ^^^^^^^^^^^^^^^^^^
+          │
+          └─ #{path}:5:15: Sample.foo/0
+
+      """
+
+      assert capture_compile(source) == expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "line + column", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "error_line_column.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+
+        def foo do
+          IO.puts(bar)
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          error: undefined variable "bar"
+          │
+        5 │     IO.puts(bar)
+          │             ^^^
+          │
+          └─ #{path}:5:13: Sample.foo/0
+
+      """
+
+      assert capture_compile(source) == expected
+    after
+      purge(Sample)
+    end
+
+    test "no file" do
+      expected = """
+      error: undefined function module_info/0 (this function is auto-generated by the compiler and must always be called as a remote, as in __MODULE__.module_info/0)
+      └─ nofile:2:16: Sample.foo/0
+
+      """
+
+      output =
+        capture_compile("""
+        defmodule Sample do
+          def foo, do: module_info()
+        end
+        """)
+
+      assert expected == output
+    after
+      purge(Sample)
+    end
+  end
+
+  describe "warning diagnostics" do
+    @tag :tmp_dir
+    test "line only", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "warn_line.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+        def a(unused), do: 1
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: variable "unused" is unused (if the variable is not meant to be used, prefix it with an underscore)
+          │
+        3 │   def a(unused), do: 1
+          │   ~~~~~~~~~~~~~~~~~~~~
+          │
+          └─ #{path}:3: Sample.a/1
+
+      """
+
+      assert capture_eval(source, columns: false) == expected
+    after
+      purge(Sample)
+    end
+
+    @tag :tmp_dir
+    test "line + column", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "warn_line_column.ex")
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+        @foo 1
+
+        def bar do
+          @foo
+          :ok
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      expected = """
+          warning: module attribute @foo in code block has no effect as it is never returned (remove the attribute or assign it to _ to avoid warnings)
+          │
+        6 │     @foo
+          │     ~
+          │
+          └─ #{path}:6:5: Sample.bar/0
+
+      """
+
+      assert capture_eval(source) == expected
+    after
+      purge(Sample)
+    end
+
+    test "no file" do
+      expected = """
+      warning: unused alias List
+      └─ nofile:2:3
+
+      """
+
+      output =
+        capture_eval("""
+        defmodule Sample do
+          alias :lists, as: List
+          import MapSet
+          new()
+        end
+        """)
+
+      assert output == expected
+    after
+      purge(Sample)
+    end
+  end
+
+  describe "Code.print_diagnostic" do
+    @tag :tmp_dir
+    test "handles diagnostic with span", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "diagnostic_length.ex")
+
+      diagnostic = %{
+        file: path,
+        severity: :error,
+        message: "Diagnostic span test",
+        stacktrace: [],
+        position: {4, 7},
+        span: {4, 10},
+        compiler_name: "Elixir"
+      }
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+
+        def bar do
+          nil
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      result =
+        ExUnit.CaptureIO.capture_io(:stderr, fn ->
+          Code.print_diagnostic(diagnostic)
+        end)
+
+      assert result == """
+                 error: Diagnostic span test
+                 │
+               4 │   def bar do
+                 │       ^^^
+                 │
+                 └─ #{path}:4:7
+
+             """
+    end
+
+    @tag :tmp_dir
+    test "prints single marker for multiline diagnostic", %{tmp_dir: tmp_dir} do
+      path = make_relative_tmp(tmp_dir, "diagnostic_length.ex")
+
+      diagnostic = %{
+        file: path,
+        severity: :error,
+        message: "Diagnostic span test",
+        stacktrace: [],
+        position: {4, 7},
+        span: {5, 2},
+        compiler_name: "Elixir"
+      }
+
+      source = """
+      defmodule Sample do
+        @file "#{path}"
+
+        def bar do
+          nil
+        end
+      end
+      """
+
+      File.write!(path, source)
+
+      result =
+        ExUnit.CaptureIO.capture_io(:stderr, fn ->
+          Code.print_diagnostic(diagnostic)
+        end)
+
+      assert result == """
+                 error: Diagnostic span test
+                 │
+               4 │   def bar do
+                 │       ^
+                 │
+                 └─ #{path}:4:7
+
+             """
+    end
+  end
+
+  defp make_relative_tmp(tmp_dir, filename) do
+    # Compiler outputs relative, so we just grab the tmp dir
+    tmp_dir
+    |> Path.join(filename)
+    |> Path.relative_to_cwd()
+  end
+
+  defp capture_eval(source, opts \\ [columns: true]) do
+    capture_io(:stderr, fn ->
+      quoted = Code.string_to_quoted!(source, opts)
+      Code.eval_quoted(quoted)
+    end)
+  end
+
+  defp capture_compile(source, opts \\ [columns: true]) do
+    capture_io(:stderr, fn ->
+      assert_raise CompileError, fn ->
+        ast = Code.string_to_quoted!(source, opts)
+        Code.eval_quoted(ast)
+      end
+    end)
+  end
+
+  defp capture_raise(source, exception, opts \\ []) do
+    {stacktrace, opts} = Keyword.pop(opts, :stacktrace, [])
+
+    e =
+      assert_raise exception, fn ->
+        ast = Code.string_to_quoted!(source, [columns: true] ++ opts)
+        Code.eval_quoted(ast)
+      end
+
+    Exception.format(:error, e, stacktrace)
+  end
+
+  defp purge(module) when is_atom(module) do
+    :code.purge(module)
+    :code.delete(module)
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/dialyzer_test.exs b/lib/elixir/test/elixir/kernel/dialyzer_test.exs
new file mode 100644
index 00000000000..84182774343
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/dialyzer_test.exs
@@ -0,0 +1,218 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.DialyzerTest do
+  use ExUnit.Case, async: true
+
+  @moduletag :dialyzer
+  @moduletag :require_ast
+  import PathHelpers
+
+  setup_all do
+    dir = tmp_path("dialyzer")
+    File.rm_rf!(dir)
+    File.mkdir_p!(dir)
+
+    plt =
+      dir
+      |> Path.join("base_plt")
+      |> String.to_charlist()
+
+    # Some OSs (like Windows) do not provide the HOME environment variable.
+    if !System.get_env("HOME") do
+      System.put_env("HOME", System.user_home())
+    end
+
+    # Add a few key Elixir modules for types and macro functions
+    mods = [
+      :elixir,
+      :elixir_env,
+      :elixir_erl_pass,
+      :maps,
+      :sets,
+      ArgumentError,
+      Atom,
+      Code,
+      EEx,
+      Enum,
+      Exception,
+      ExUnit.AssertionError,
+      ExUnit.Assertions,
+      IO,
+      Kernel,
+      Kernel.Utils,
+      List,
+      Macro,
+      Macro.Env,
+      MapSet,
+      Module,
+      Protocol,
+      String,
+      String.Chars,
+      Task,
+      Task.Supervisor
+    ]
+
+    files = Enum.map(mods, &:code.which/1)
+    dialyzer_run(analysis_type: :plt_build, output_plt: plt, apps: [:erts], files: files)
+
+    # Compile Dialyzer fixtures
+    source_files = Path.wildcard(Path.join(fixture_path("dialyzer"), "*"))
+
+    {:ok, _, _} =
+      Kernel.ParallelCompiler.compile_to_path(source_files, dir, return_diagnostics: true)
+
+    {:ok, [base_dir: dir, base_plt: plt]}
+  end
+
+  setup context do
+    dir = String.to_charlist(context.tmp_dir)
+
+    plt =
+      dir
+      |> Path.join("plt")
+      |> String.to_charlist()
+
+    File.cp!(context.base_plt, plt)
+    warnings = Map.get(context, :warnings, [])
+
+    dialyzer = [
+      analysis_type: :succ_typings,
+      check_plt: false,
+      files_rec: [dir],
+      plts: [plt],
+      warnings: warnings
+    ]
+
+    {:ok, [outdir: dir, dialyzer: dialyzer]}
+  end
+
+  @moduletag :tmp_dir
+
+  @tag warnings: [:specdiffs]
+  test "no warnings on specdiffs", context do
+    copy_beam!(context, Dialyzer.RemoteCall)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on valid remote calls", context do
+    copy_beam!(context, Dialyzer.RemoteCall)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on rewrites", context do
+    copy_beam!(context, Dialyzer.Rewrite)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on raise", context do
+    copy_beam!(context, Dialyzer.Raise)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on macrocallback", context do
+    copy_beam!(context, Dialyzer.Macrocallback)
+    copy_beam!(context, Dialyzer.Macrocallback.Impl)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on callback", context do
+    copy_beam!(context, Dialyzer.Callback)
+    copy_beam!(context, Dialyzer.Callback.ImplAtom)
+    copy_beam!(context, Dialyzer.Callback.ImplList)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on and/2 and or/2", context do
+    copy_beam!(context, Dialyzer.BooleanCheck)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on cond", context do
+    copy_beam!(context, Dialyzer.Cond)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on for comprehensions with bitstrings", context do
+    copy_beam!(context, Dialyzer.ForBitstring)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on for falsy check that always boolean", context do
+    copy_beam!(context, Dialyzer.ForBooleanCheck)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on with/else", context do
+    copy_beam!(context, Dialyzer.With)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on with when else has a no_return type", context do
+    copy_beam!(context, Dialyzer.WithNoReturn)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on with when multiple else clauses and one is a no_return", context do
+    copy_beam!(context, Dialyzer.WithThrowingElse)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on defmacrop", context do
+    copy_beam!(context, Dialyzer.Defmacrop)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warnings on try", context do
+    copy_beam!(context, Dialyzer.Try)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warning on is_struct/2", context do
+    copy_beam!(context, Dialyzer.IsStruct)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warning on ExUnit assertions", context do
+    copy_beam!(context, Dialyzer.Assertions)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warning due to opaqueness edge cases", context do
+    copy_beam!(context, Dialyzer.Opaqueness)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  test "no warning in various non-regression cases", context do
+    copy_beam!(context, Dialyzer.Regressions)
+    assert_dialyze_no_warnings!(context)
+  end
+
+  defp copy_beam!(context, module) do
+    name = "#{module}.beam"
+    File.cp!(Path.join(context.base_dir, name), Path.join(context.outdir, name))
+  end
+
+  defp assert_dialyze_no_warnings!(context) do
+    case dialyzer_run(context.dialyzer) do
+      [] ->
+        :ok
+
+      warnings ->
+        formatted = for warn <- warnings, do: [:dialyzer.format_warning(warn), ?\n]
+        formatted |> IO.chardata_to_string() |> flunk()
+    end
+  end
+
+  defp dialyzer_run(opts) do
+    try do
+      :dialyzer.run(opts)
+    catch
+      :throw, {:dialyzer_error, chardata} ->
+        raise "dialyzer error: " <> IO.chardata_to_string(chardata)
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/docs_test.exs b/lib/elixir/test/elixir/kernel/docs_test.exs
index 1b0d55a4986..fde228722a4 100644
--- a/lib/elixir/test/elixir/kernel/docs_test.exs
+++ b/lib/elixir/test/elixir/kernel/docs_test.exs
@@ -1,60 +1,457 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.DocsTest do
   use ExUnit.Case
 
-  test "compiled with docs" do
-    deftestmodule(SampleDocs)
-    docs = Code.get_docs(SampleDocs, :all)
+  import PathHelpers
 
-    assert [{{:fun, 2}, _, :def, [{:x, [], nil}, {:y, [], nil}], "This is fun!\n"},
-            {{:nofun, 0}, _, :def, [], nil},
-            {{:sneaky, 1}, _, :def, [{:bool1, [], Elixir}], false}] = docs[:docs]
-    assert {_, "Hello, I am a module"} = docs[:moduledoc]
+  defmacro wrong_doc_baz do
+    quote do
+      @doc "Wrong doc"
+      @doc since: "1.2"
+      def baz(_arg)
+      def baz(arg), do: arg + 1
+    end
+  end
+
+  test "attributes format" do
+    defmodule DocAttributes do
+      @moduledoc "Module doc"
+      assert @moduledoc == "Module doc"
+      assert Module.get_attribute(__MODULE__, :moduledoc) == {__ENV__.line - 2, "Module doc"}
+
+      @typedoc "Type doc"
+      assert @typedoc == "Type doc"
+      assert Module.get_attribute(__MODULE__, :typedoc) == {__ENV__.line - 2, "Type doc"}
+      @type foobar :: any
+
+      @doc "Function doc"
+      assert @doc == "Function doc"
+      assert Module.get_attribute(__MODULE__, :doc) == {__ENV__.line - 2, "Function doc"}
+
+      def foobar() do
+        :ok
+      end
+    end
   end
 
   test "compiled without docs" do
     Code.compiler_options(docs: false)
 
-    deftestmodule(SampleNoDocs)
+    write_beam(
+      defmodule WithoutDocs do
+        @moduledoc "Module doc"
+
+        @doc "Some doc"
+        def foobar(arg), do: arg
+      end
+    )
 
-    assert Code.get_docs(SampleNoDocs, :docs) == nil
-    assert Code.get_docs(SampleNoDocs, :moduledoc) == nil
+    assert Code.fetch_docs(WithoutDocs) == {:error, :chunk_not_found}
   after
     Code.compiler_options(docs: true)
   end
 
   test "compiled in memory does not have accessible docs" do
-    defmodule NoDocs do
-      @moduledoc "moduledoc"
+    defmodule InMemoryDocs do
+      @moduledoc "Module doc"
 
-      @doc "Some example"
-      def example(var), do: var
+      @doc "Some doc"
+      def foobar(arg), do: arg
     end
 
-    assert Code.get_docs(NoDocs, :docs) == nil
-    assert Code.get_docs(NoDocs, :moduledoc) == nil
+    assert Code.fetch_docs(InMemoryDocs) == {:error, :module_not_found}
   end
 
-  defp deftestmodule(name) do
-    import PathHelpers
+  test "non-existent beam file" do
+    assert {:error, :module_not_found} = Code.fetch_docs("bad.beam")
+  end
 
-    write_beam(defmodule name do
-      @moduledoc "Hello, I am a module"
+  test "raises on invalid @doc since: ..." do
+    assert_raise ArgumentError, ~r"should be a string representing the version", fn ->
+      defmodule InvalidSince do
+        @doc since: 1.2
+        def foo, do: :bar
+      end
+    end
+  end
 
-      @doc """
-      This is fun!
-      """
-      def fun(x, y) do
-        {x, y}
+  test "raises on invalid @doc" do
+    assert_raise ArgumentError, ~r/When set dynamically, it should be {line, doc}/, fn ->
+      defmodule DocAttributesFormat do
+        Module.put_attribute(__MODULE__, :moduledoc, "Other")
       end
+    end
+
+    message = ~r/should be either false, nil, a string, or a keyword list/
 
-      @doc false
-      def sneaky(true), do: false
+    assert_raise ArgumentError, message, fn ->
+      defmodule AtSyntaxDocAttributesFormat do
+        @moduledoc :not_a_binary
+      end
+    end
 
-      def nofun() do
-        'not fun at all'
+    assert_raise ArgumentError, message, fn ->
+      defmodule AtSyntaxDocAttributesFormat do
+        @moduledoc true
       end
-    end)
+    end
+  end
+
+  describe "compiled with docs" do
+    test "infers signatures" do
+      write_beam(
+        defmodule SignatureDocs do
+          def arg_names([], [], %{}, [], %{}), do: false
+
+          @year 2015
+          def with_defaults(@year, arg \\ 0, year \\ @year, fun \\ &>=/2) do
+            {fun, arg + year}
+          end
+
+          def with_map_and_default(%{key: value} \\ %{key: :default}), do: value
+          def with_struct(%URI{}), do: :ok
+
+          def with_underscore({_, _} = _two_tuple), do: :ok
+          def with_underscore(_), do: :error
+
+          def only_underscore(_), do: :ok
+
+          def two_good_names(first, :ok), do: first
+          def two_good_names(second, :error), do: second
+
+          def really_long_signature(
+                really_long_var_named_one,
+                really_long_var_named_two,
+                really_long_var_named_three
+              ) do
+            {really_long_var_named_one, really_long_var_named_two, really_long_var_named_three}
+          end
+        end
+      )
+
+      assert {:docs_v1, _, :elixir, _, _, _, docs} = Code.fetch_docs(SignatureDocs)
+      signatures = for {{:function, n, a}, _, signature, _, %{}} <- docs, do: {{n, a}, signature}
+
+      assert [
+               arg_names,
+               only_underscore,
+               really_long_signature,
+               two_good_names,
+               with_defaults,
+               with_map_and_default,
+               with_struct,
+               with_underscore
+             ] = Enum.sort(signatures)
+
+      # arg_names/5
+      assert {{:arg_names, 5}, ["arg_names(list1, list2, map1, list3, map2)"]} = arg_names
+
+      # only_underscore/1
+      assert {{:only_underscore, 1}, ["only_underscore(_)"]} = only_underscore
+
+      # really_long_signature/3
+      assert {{:really_long_signature, 3},
+              [
+                "really_long_signature(really_long_var_named_one, really_long_var_named_two, really_long_var_named_three)"
+              ]} = really_long_signature
+
+      # two_good_names/2
+      assert {{:two_good_names, 2}, ["two_good_names(first, atom)"]} = two_good_names
+
+      # with_defaults/4
+      assert {{:with_defaults, 4},
+              ["with_defaults(int, arg \\\\ 0, year \\\\ 2015, fun \\\\ &>=/2)"]} = with_defaults
+
+      # with_map_and_default/1
+      assert {{:with_map_and_default, 1}, ["with_map_and_default(map \\\\ %{key: :default})"]} =
+               with_map_and_default
+
+      # with_struct/1
+      assert {{:with_struct, 1}, ["with_struct(uri)"]} = with_struct
+
+      # with_underscore/1
+      assert {{:with_underscore, 1}, ["with_underscore(two_tuple)"]} = with_underscore
+    end
+
+    test "includes docs for functions, modules, types and callbacks" do
+      line = __ENV__.line
+
+      write_beam(
+        defmodule SampleDocs do
+          @moduledoc "Module doc"
+          @moduledoc authors: "Elixir Contributors", purpose: :test
+
+          @doc "My struct"
+          defstruct [:sample]
+
+          @typedoc "Type doc"
+          @typedoc since: "1.2.3", color: :red
+          @type foo(any) :: any
+
+          @typedoc "Opaque type doc"
+          @opaque bar(any) :: any
+
+          @doc "Callback doc"
+          @doc since: "1.2.3", color: :red, deprecated: "use baz/2 instead"
+          @doc color: :blue, stable: true
+          @callback foo(any) :: any
+
+          @doc false
+          @doc since: "1.2.3"
+          @callback bar() :: term
+          @callback baz(any, term) :: any
+
+          @doc "Callback with multiple clauses"
+          @callback callback_multi(integer) :: integer
+          @callback callback_multi(atom) :: atom
+
+          @doc "Macrocallback doc"
+          @macrocallback qux(any) :: any
+
+          @doc "Macrocallback with multiple clauses"
+          @macrocallback macrocallback_multi(integer) :: integer
+          @macrocallback macrocallback_multi(atom) :: atom
+
+          @doc "Function doc"
+          @doc since: "1.2.3", color: :red
+          @doc color: :blue, stable: true
+          @deprecated "use baz/2 instead"
+          def foo(arg \\ 0), do: arg + 1
+
+          @doc "Multiple function head doc"
+          @deprecated "something else"
+          def bar(_arg)
+          def bar(arg), do: arg + 1
+
+          require Kernel.DocsTest
+          Kernel.DocsTest.wrong_doc_baz()
+
+          @doc "Multiple function head and docs"
+          @doc since: "1.2.3"
+          def baz(_arg)
+
+          @doc false
+          def qux(true), do: false
+
+          @doc "A guard"
+          defguard is_zero(v) when v == 0
+
+          # We do this to avoid the deprecation warning.
+          module = Module
+          module.add_doc(__MODULE__, __ENV__.line, :def, {:nullary, 0}, [], "add_doc")
+          def nullary, do: 0
+
+          defmodule SampleBehaviour do
+            @callback foo(any()) :: any()
+          end
+
+          @behaviour SampleBehaviour
+        end
+      )
+
+      assert {:docs_v1, _, :elixir, "text/markdown", %{"en" => module_doc}, module_doc_meta, docs} =
+               Code.fetch_docs(SampleDocs)
+
+      assert module_doc == "Module doc"
+
+      file = String.to_charlist(__ENV__.file)
+
+      source_annos = [:erl_anno.new({line + 3, 19})]
+
+      assert %{
+               # Generated meta
+               source_path: ^file,
+               source_annos: ^source_annos,
+               behaviours: [SampleDocs.SampleBehaviour],
+               # User meta
+               authors: "Elixir Contributors",
+               purpose: :test
+             } = module_doc_meta
+
+      [
+        callback_bar,
+        callback_baz,
+        callback_multi,
+        callback_foo,
+        function_struct_0,
+        function_struct_1,
+        function_bar,
+        function_baz,
+        function_foo,
+        function_nullary,
+        function_qux,
+        guard_is_zero,
+        macrocallback_multi,
+        macrocallback_qux,
+        type_bar,
+        type_foo
+      ] = Enum.sort(docs)
+
+      assert {{:callback, :bar, 0}, _, [], :hidden, %{}} = callback_bar
+      assert {{:callback, :baz, 2}, _, [], :none, %{}} = callback_baz
+
+      source_annos = [:erl_anno.new({line + 20, 21})]
+
+      assert {{:callback, :foo, 1}, _, [], %{"en" => "Callback doc"},
+              %{
+                source_annos: ^source_annos,
+                since: "1.2.3",
+                deprecated: "use baz/2 instead",
+                color: :blue,
+                stable: true
+              }} = callback_foo
+
+      assert {{:callback, :callback_multi, 1}, _, [], %{"en" => "Callback with multiple clauses"},
+              %{}} = callback_multi
+
+      assert {{:function, :__struct__, 0}, _, ["%Kernel.DocsTest.SampleDocs{}"],
+              %{"en" => "My struct"}, %{}} = function_struct_0
+
+      assert {{:function, :__struct__, 1}, _, ["__struct__(kv)"], :hidden, %{}} =
+               function_struct_1
+
+      assert {{:function, :bar, 1}, _, ["bar(arg)"], %{"en" => "Multiple function head doc"},
+              %{deprecated: "something else"}} = function_bar
+
+      assert {{:function, :baz, 1}, _, ["baz(arg)"], %{"en" => "Multiple function head and docs"},
+              %{since: "1.2.3"}} = function_baz
+
+      source_annos = [:erl_anno.new({line + 42, 15})]
+
+      assert {{:function, :foo, 1}, _, ["foo(arg \\\\ 0)"], %{"en" => "Function doc"},
+              %{
+                source_annos: ^source_annos,
+                since: "1.2.3",
+                deprecated: "use baz/2 instead",
+                color: :blue,
+                stable: true,
+                defaults: 1
+              }} = function_foo
+
+      assert {{:function, :nullary, 0}, _, ["nullary()"], %{"en" => "add_doc"}, %{}} =
+               function_nullary
+
+      assert {{:function, :qux, 1}, _, ["qux(bool)"], :hidden, %{}} = function_qux
+
+      source_annos = [:erl_anno.new({line + 60, 20})]
+
+      assert {{:macro, :is_zero, 1}, _, ["is_zero(v)"], %{"en" => "A guard"},
+              %{source_annos: ^source_annos, guard: true}} = guard_is_zero
+
+      assert {{:macrocallback, :macrocallback_multi, 1}, _, [],
+              %{"en" => "Macrocallback with multiple clauses"}, %{}} = macrocallback_multi
+
+      assert {{:macrocallback, :qux, 1}, _, [], %{"en" => "Macrocallback doc"}, %{}} =
+               macrocallback_qux
+
+      assert {{:type, :bar, 1}, _, [], %{"en" => "Opaque type doc"}, %{opaque: true}} = type_bar
+
+      source_annos = [:erl_anno.new({line + 12, 17})]
+
+      assert {{:type, :foo, 1}, _, [], %{"en" => "Type doc"},
+              %{
+                source_annos: ^source_annos,
+                since: "1.2.3",
+                color: :red
+              }} = type_foo
+    end
+  end
+
+  test "fetch docs chunk from doc/chunks" do
+    Code.compiler_options(docs: false)
+
+    doc_chunks_path = Path.join([tmp_path(), "doc", "chunks"])
+    File.rm_rf!(doc_chunks_path)
+    File.mkdir_p!(doc_chunks_path)
+
+    write_beam(
+      defmodule ExternalDocs do
+      end
+    )
+
+    assert Code.fetch_docs(ExternalDocs) == {:error, :chunk_not_found}
+
+    path = Path.join([doc_chunks_path, "#{ExternalDocs}.chunk"])
+    chunk = {:docs_v1, 1, :elixir, "text/markdown", %{"en" => "Some docs"}, %{}}
+    File.write!(path, :erlang.term_to_binary(chunk))
+
+    assert Code.fetch_docs(ExternalDocs) == chunk
+  after
+    Code.compiler_options(docs: true)
+  end
+
+  test "@impl true doesn't set @doc false if previous implementation has docs" do
+    write_beam(
+      defmodule Docs do
+        defmodule SampleBehaviour do
+          @callback foo(any()) :: any()
+          @callback bar() :: any()
+          @callback baz() :: any()
+        end
+
+        @behaviour SampleBehaviour
+
+        @doc "Foo docs"
+        def foo(nil), do: nil
+
+        @impl true
+        def foo(_), do: false
+
+        @impl true
+        def bar(), do: true
+
+        @doc "Baz docs"
+        @impl true
+        def baz(), do: true
+
+        def fuz(), do: true
+      end
+    )
+
+    {:docs_v1, _, _, _, _, _, docs} = Code.fetch_docs(Docs)
+    function_docs = for {{:function, name, arity}, _, _, doc, _} <- docs, do: {{name, arity}, doc}
+
+    assert [
+             {{:bar, 0}, :hidden},
+             {{:baz, 0}, %{"en" => "Baz docs"}},
+             {{:foo, 1}, %{"en" => "Foo docs"}},
+             {{:fuz, 0}, :none}
+           ] = Enum.sort(function_docs)
+  end
+
+  test "generated functions are annotated as such" do
+    line = __ENV__.line
+
+    write_beam(
+      defmodule ToBeUsed do
+        defmacro __using__(_) do
+          quote generated: true do
+            @doc "Hello"
+            def foo, do: :bar
+          end
+        end
+      end
+    )
+
+    write_beam(
+      defmodule WillBeUsing do
+        use ToBeUsed
+      end
+    )
+
+    {:docs_v1, _, _, _, _, _, docs} = Code.fetch_docs(WillBeUsing)
+
+    doc_anno = :erl_anno.new(line + 15)
+    source_anno = :erl_anno.set_generated(true, :erl_anno.new(line + 15))
+
+    assert [
+             {{:function, :foo, 0}, ^doc_anno, ["foo()"], %{"en" => "Hello"},
+              %{source_annos: [^source_anno]}}
+           ] = docs
   end
 end
diff --git a/lib/elixir/test/elixir/kernel/errors_test.exs b/lib/elixir/test/elixir/kernel/errors_test.exs
index 5e5fa194a7a..f6dd6c4190f 100644
--- a/lib/elixir/test/elixir/kernel/errors_test.exs
+++ b/lib/elixir/test/elixir/kernel/errors_test.exs
@@ -1,717 +1,1042 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.ErrorsTest do
   use ExUnit.Case, async: true
-  import CompileAssertion
-
-  defmodule UnproperMacro do
-    defmacro unproper(args), do: args
-    defmacro exit(args), do: args
-  end
 
-  test :invalid_token do
-    assert_compile_fail SyntaxError,
-      "nofile:1: invalid token: \end",
-      '\end\nlol\nbarbecue'
+  defmacro hello do
+    quote location: :keep do
+      def hello, do: :world
+    end
   end
 
-  test :invalid_quoted_token do
-    assert_compile_fail SyntaxError,
-      "nofile:1: syntax error before: \"world\"",
-      '"hello" "world"'
-
-    assert_compile_fail SyntaxError,
-      "nofile:1: syntax error before: foo",
-      'Foo.:foo'
-
-    assert_compile_fail SyntaxError,
-      "nofile:1: syntax error before: \"foo\"",
-      'Foo.:"foo\#{:bar}"'
+  test "no default arguments in fn" do
+    assert_compile_error(
+      ["nofile:1:1", "anonymous functions cannot have optional arguments"],
+      ~c"fn x \\\\ 1 -> x end"
+    )
+
+    assert_compile_error(
+      ["nofile:1:1", "anonymous functions cannot have optional arguments"],
+      ~c"fn x, y \\\\ 1 -> x + y end"
+    )
+  end
+
+  test "invalid __CALLER__" do
+    assert_compile_error(
+      ["nofile:1:34", "__CALLER__ is available only inside defmacro and defmacrop"],
+      ~c"defmodule Sample do def hello do __CALLER__ end end"
+    )
+  end
+
+  test "invalid __STACKTRACE__" do
+    assert_compile_error(
+      [
+        "nofile:1:34",
+        "__STACKTRACE__ is available only inside catch and rescue clauses of try expressions"
+      ],
+      ~c"defmodule Sample do def hello do __STACKTRACE__ end end"
+    )
+
+    assert_compile_error(
+      [
+        "nofile:1:66",
+        "__STACKTRACE__ is available only inside catch and rescue clauses of try expressions"
+      ],
+      ~c"defmodule Sample do try do raise \"oops\" rescue _ -> def hello do __STACKTRACE__ end end end"
+    )
+  end
+
+  test "undefined function" do
+    assert_compile_error(
+      [
+        "hello.ex:4:5: ",
+        "undefined function bar/0 (expected Kernel.ErrorsTest.BadForm to define such a function or for it to be imported, but none are available)"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.BadForm do
+        @file "hello.ex"
+        def foo do
+          bar()
+        end
+      end
+      """
+    )
+
+    assert_compile_error(
+      [
+        "nofile:2:16",
+        "undefined function module_info/0 (this function is auto-generated by the compiler and must always be called as a remote, as in __MODULE__.module_info/0)"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.Info do
+        def foo, do: module_info()
+      end
+      """
+    )
+
+    assert_compile_error(
+      [
+        "nofile:3:16",
+        "undefined function behaviour_info/1 (this function is auto-generated by the compiler and must always be called as a remote, as in __MODULE__.behaviour_info/1)"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.BehaviourInfo do
+        @callback dummy() :: :ok
+        def foo, do: behaviour_info(:callbacks)
+      end
+      """
+    )
+
+    assert_compile_error(
+      [
+        "nofile:3:5",
+        "undefined function bar/1 (expected Kernel.ErrorsTest.BadForm to define such a function or for it to be imported, but none are available)"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.BadForm do
+        def foo do
+          bar(
+            baz(1, 2)
+          )
+        end
+      end
+      """
+    )
+
+    assert_compile_error(
+      [
+        "nofile:8:5",
+        "undefined function baz/0 (expected Sample to define such a function or for it to be imported, but none are available)"
+      ],
+      ~c"""
+      defmodule Sample do
+        def foo do
+          bar()
+        end
 
-    assert_compile_fail SyntaxError,
-      "nofile:1: syntax error before: \"",
-      'Foo.:"\#{:bar}"'
+        defoverridable [foo: 0]
+        def foo do
+          baz()
+        end
+      end
+      """
+    )
   end
 
-  test :invalid_or_reserved_codepoint do
-    assert_compile_fail ArgumentError,
-      "invalid or reserved unicode codepoint 55296",
-      '?\\x{D800}'
+  test "undefined function within unused function" do
+    assert_compile_error(
+      ["nofile:2:8", "undefined function bar/0"],
+      ~c"""
+      defmodule Sample do
+        defp foo, do: bar()
+      end
+      """
+    )
   end
 
-  test :sigil_terminator do
-    assert_compile_fail TokenMissingError,
-      "nofile:3: missing terminator: \" (for sigil ~r\" starting at line 1)",
-      '~r"foo\n\n'
-
-    assert_compile_fail TokenMissingError,
-      "nofile:3: missing terminator: } (for sigil ~r{ starting at line 1)",
-      '~r{foo\n\n'
+  test "undefined non-local function" do
+    assert_compile_error(
+      ["nofile:1:1", "undefined function call/2 (there is no such import)"],
+      ~c"call foo, do: :foo"
+    )
   end
 
-  test :dot_terminator do
-    assert_compile_fail TokenMissingError,
-      "nofile:1: missing terminator: \" (for function name starting at line 1)",
-      'foo."bar'
+  test "undefined variables" do
+    assert_compile_error(
+      ["nofile:3:13", "undefined variable \"bar\"", "nofile:4:13", "undefined variable \"baz\""],
+      ~c"""
+      defmodule Sample do
+        def foo do
+          IO.puts bar
+          IO.puts baz
+        end
+      end
+      """
+    )
+  end
+
+  test "recursive variables on definition" do
+    assert_compile_error(
+      [
+        "nofile:2:7: ",
+        "recursive variable definition in patterns:",
+        "foo(x = y, y = z, z = x)",
+        "the following variables form a cycle: \"x\", \"y\", \"z\""
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.RecursiveVars do
+        def foo(x = y, y = z, z = x), do: {x, y, z}
+      end
+      """
+    )
   end
 
-  test :string_terminator do
-    assert_compile_fail TokenMissingError,
-      "nofile:1: missing terminator: \" (for string starting at line 1)",
-      '"bar'
-  end
+  test "function without definition" do
+    assert_compile_error(
+      ["nofile:2:7: ", "implementation not provided for predefined def foo/0"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.FunctionWithoutDefinition do
+        def foo
+      end
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:10: ", "implementation not provided for predefined def example/2"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.FunctionTemplate do
+        defmacro __using__(_) do
+          quote do
+            def example(foo, bar \\\\ [])
+          end
+        end
+      end
 
-  test :heredoc_start do
-    assert_compile_fail SyntaxError,
-      "nofile:1: heredoc start must be followed by a new line after \"\"\"",
-      '"""bar\n"""'
+      defmodule Kernel.ErrorsTest.UseFunctionTemplate do
+        use Kernel.ErrorsTest.FunctionTemplate
+      end
+      """
+    )
   end
 
-  test :heredoc_terminator do
-    assert_compile_fail TokenMissingError,
-      "nofile:2: missing terminator: \"\"\" (for heredoc starting at line 1)",
-      '"""\nbar'
+  test "guard without definition" do
+    assert_compile_error(
+      ["nofile:2:12: ", "implementation not provided for predefined defmacro foo/1"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.GuardWithoutDefinition do
+        defguard foo(bar)
+      end
+      """
+    )
   end
 
-  test :unexpected_end do
-    assert_compile_fail SyntaxError,
-      "nofile:1: unexpected token: end",
-      '1 end'
+  test "literal on map and struct" do
+    assert_compile_error(
+      ["nofile:1:10", "expected key-value pairs in a map, got: put_in(foo.bar.baz, nil)"],
+      ~c"foo = 1; %{put_in(foo.bar.baz, nil), foo}"
+    )
   end
 
-  test :syntax_error do
-    assert_compile_fail SyntaxError,
-      "nofile:1: syntax error before: '.'",
-      '+.foo'
+  test "struct fields on defstruct" do
+    assert_eval_raise ArgumentError, ["struct field names must be atoms, got: 1"], ~c"""
+    defmodule Kernel.ErrorsTest.StructFieldsOnDefstruct do
+      defstruct [1, 2, 3]
+    end
+    """
+  end
+
+  test "struct access on body" do
+    assert_compile_error(
+      [
+        "nofile:3:3",
+        "cannot access struct Kernel.ErrorsTest.StructAccessOnBody, " <>
+          "the struct was not yet defined or the struct " <>
+          "is being accessed in the same context that defines it"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.StructAccessOnBody do
+        defstruct %{name: "Brasilia"}
+        %Kernel.ErrorsTest.StructAccessOnBody{}
+      end
+      """
+    )
   end
 
-  test :compile_error_on_op_ambiguity do
-    msg = "nofile:1: \"a -1\" looks like a function call but there is a variable named \"a\", " <>
-          "please use explicit parenthesis or even spaces"
-    assert_compile_fail CompileError, msg, 'a = 1; a -1'
+  describe "struct errors" do
+    test "bad errors" do
+      assert_compile_error(
+        ["nofile:1:1", "BadStruct.__struct__/1 is undefined, cannot expand struct BadStruct"],
+        ~c"%BadStruct{}"
+      )
 
-    max = 1
-    assert max == 1
-    assert (max 1, 2) == 2
-  end
+      assert_compile_error(
+        ["nofile:1:1", "BadStruct.__struct__/1 is undefined, cannot expand struct BadStruct"],
+        ~c"%BadStruct{} = %{}"
+      )
 
-  test :syntax_error_on_parens_call do
-    msg = "nofile:1: unexpected parenthesis. If you are making a function call, do not " <>
-          "insert spaces in between the function name and the opening parentheses. " <>
-          "Syntax error before: '('"
+      bad_struct_type_error =
+        ~r"expected Kernel.ErrorsTest.BadStructType.__struct__/(0|1) to return a map.*, got: :invalid"
 
-    assert_compile_fail SyntaxError, msg, 'foo (hello, world)'
-    assert_compile_fail SyntaxError, msg, 'foo ()'
-    assert_compile_fail SyntaxError, msg, 'foo (), 1'
-  end
+      defmodule BadStructType do
+        def __struct__, do: :invalid
+        def __struct__(_), do: :invalid
+      end
 
-  test :syntax_error_on_nested_no_parens_call do
-    msg = "nofile:1: unexpected comma. Parentheses are required to solve ambiguity in " <>
-          "nested calls. Syntax error before: ','"
+      assert_compile_error(bad_struct_type_error, ~c"%#{BadStructType}{}")
 
-    assert_compile_fail SyntaxError, msg, '[foo 1, 2]'
-    assert_compile_fail SyntaxError, msg, '[do: foo 1, 2]'
-    assert_compile_fail SyntaxError, msg, 'foo(do: bar 1, 2)'
-    assert_compile_fail SyntaxError, msg, '{foo 1, 2}'
-    assert_compile_fail SyntaxError, msg, 'foo 1, foo 2, 3'
-    assert_compile_fail SyntaxError, msg, 'foo(1, foo 2, 3)'
+      assert_raise ArgumentError, bad_struct_type_error, fn ->
+        struct(BadStructType)
+      end
 
-    assert is_list List.flatten [1]
-    assert is_list Enum.reverse [3, 2, 1], [4, 5, 6]
-    assert is_list(Enum.reverse [3, 2, 1], [4, 5, 6])
-  end
+      assert_raise ArgumentError, bad_struct_type_error, fn ->
+        struct(BadStructType, foo: 1)
+      end
+    end
 
-  test :syntax_error_with_no_token do
-    assert_compile_fail TokenMissingError,
-      "nofile:1: missing terminator: ) (for \"(\" starting at line 1)",
-      'case 1 ('
-  end
+    test "bad struct on module conflict" do
+      Code.put_compiler_option(:ignore_module_conflict, true)
 
-  test :clause_with_defaults do
-    assert_compile_fail CompileError,
-      "nofile:3: def hello/1 has default values and multiple clauses, " <>
-      "define a function head with the defaults",
-      ~C'''
-      defmodule ErrorsTest do
-        def hello(arg \\ 0), do: nil
-        def hello(arg \\ 1), do: nil
+      assert_compile_error(~r'MissingStructOnReload\.__struct__/1 is undefined', ~c'''
+      defmodule MissingStructOnReload do
+        defstruct [:title]
+        def d(), do: %MissingStructOnReload{}
       end
-      '''
-  end
 
-  test :invalid_match_pattern do
-    assert_compile_fail CompileError,
-    "nofile:2: invalid expression in match",
-    '''
-    case true do
-      true && true -> true
+      defmodule MissingStructOnReload do
+        def d(), do: %MissingStructOnReload{}
+      end
+      ''')
+    after
+      Code.put_compiler_option(:ignore_module_conflict, false)
     end
-    '''
-  end
 
-  test :different_defs_with_defaults do
-    assert_compile_fail CompileError,
-      "nofile:3: def hello/3 defaults conflicts with def hello/2",
-      ~C'''
-      defmodule ErrorsTest do
-        def hello(a, b \\ nil), do: a + b
-        def hello(a, b \\ nil, c \\ nil), do: a + b + c
+    test "missing struct key" do
+      missing_struct_key_error =
+        ~r"expected Kernel.ErrorsTest.MissingStructKey.__struct__/(0|1) to return a map.*, got: %\{\}"
+
+      defmodule MissingStructKey do
+        def __struct__, do: %{}
+        def __struct__(_), do: %{}
       end
-      '''
 
-    assert_compile_fail CompileError,
-      "nofile:3: def hello/2 conflicts with defaults from def hello/3",
-      ~C'''
-      defmodule ErrorsTest do
-        def hello(a, b \\ nil, c \\ nil), do: a + b + c
-        def hello(a, b \\ nil), do: a + b
+      assert_compile_error(missing_struct_key_error, ~c"%#{MissingStructKey}{}")
+
+      assert_raise ArgumentError, missing_struct_key_error, fn ->
+        struct(MissingStructKey)
       end
-      '''
-  end
 
-  test :bad_form do
-    assert_compile_fail CompileError,
-      "nofile:2: function bar/0 undefined",
-      '''
-      defmodule ErrorsTest do
-        def foo, do: bar
+      assert_raise ArgumentError, missing_struct_key_error, fn ->
+        struct(MissingStructKey, foo: 1)
       end
-      '''
-  end
 
-  test :unbound_var do
-    assert_compile_fail CompileError,
-      "nofile:1: unbound variable ^x",
-      '^x = 1'
-  end
+      invalid_struct_key_error =
+        ~r"expected Kernel.ErrorsTest.InvalidStructKey.__struct__/(0|1) to return a map.*, got: %\{__struct__: 1\}"
 
-  test :unbound_not_match do
-    assert_compile_fail CompileError,
-      "nofile:1: cannot use ^x outside of match clauses",
-      '^x'
-  end
+      defmodule InvalidStructKey do
+        def __struct__, do: %{__struct__: 1}
+        def __struct__(_), do: %{__struct__: 1}
+      end
 
-  test :unbound_expr do
-    assert_compile_fail CompileError,
-      "nofile:1: invalid argument for unary operator ^, expected an existing variable, got: ^x(1)",
-      '^x(1) = 1'
-  end
+      assert_compile_error(invalid_struct_key_error, ~c"%#{InvalidStructKey}{}")
 
-  test :literal_on_map_and_struct do
-    assert_compile_fail SyntaxError,
-      "nofile:1: syntax error before: '}'",
-      '%{{:a, :b}}'
+      assert_raise ArgumentError, invalid_struct_key_error, fn ->
+        struct(InvalidStructKey)
+      end
 
-    assert_compile_fail SyntaxError,
-      "nofile:1: syntax error before: '{'",
-      '%{:a, :b}{a: :b}'
-  end
+      assert_raise ArgumentError, invalid_struct_key_error, fn ->
+        struct(InvalidStructKey, foo: 1)
+      end
+    end
+
+    test "invalid struct" do
+      invalid_struct_name_error =
+        ~r"expected struct name returned by Kernel.ErrorsTest.InvalidStructName.__struct__/(0|1) to be Kernel.ErrorsTest.InvalidStructName, got: InvalidName"
 
-  test :struct_fields_on_defstruct do
-    assert_compile_fail ArgumentError,
-      "struct field names must be atoms, got: 1",
-      '''
-      defmodule TZ do
-        defstruct [1, 2, 3]
+      defmodule InvalidStructName do
+        def __struct__, do: %{__struct__: InvalidName}
+        def __struct__(_), do: %{__struct__: InvalidName}
       end
-      '''
-  end
 
-  test :struct_access_on_body do
-    assert_compile_fail CompileError,
-      "nofile:3: cannot access struct TZ in body of the module that defines it " <>
-      "as the struct fields are not yet accessible",
-      '''
-      defmodule TZ do
-        defstruct %{name: "Brasilia"}
-        %TZ{}
+      assert_compile_error(invalid_struct_name_error, ~c"%#{InvalidStructName}{}")
+
+      assert_raise ArgumentError, invalid_struct_name_error, fn ->
+        struct(InvalidStructName)
       end
-      '''
-  end
 
-  test :unbound_map_key_var do
-    assert_compile_fail CompileError,
-      "nofile:1: illegal use of variable x in map key",
-      '%{x => 1} = %{}'
+      assert_raise ArgumentError, invalid_struct_name_error, fn ->
+        struct(InvalidStructName, foo: 1)
+      end
+    end
 
-    assert_compile_fail CompileError,
-      "nofile:1: illegal use of variable x in map key",
-      '%{x = 1 => 1}'
-  end
+    test "good struct" do
+      defmodule GoodStruct do
+        defstruct name: "john"
+      end
+
+      assert_eval_raise KeyError,
+                        ["key :age not found"],
+                        ~c"%#{GoodStruct}{age: 27}"
 
-  test :struct_errors do
-    assert_compile_fail CompileError,
-      "nofile:1: BadStruct.__struct__/0 is undefined, cannot expand struct BadStruct",
-      '%BadStruct{}'
+      assert_compile_error(
+        ["nofile:1:1", "unknown key :age for struct Kernel.ErrorsTest.GoodStruct"],
+        ~c"%#{GoodStruct}{age: 27} = %{}"
+      )
+    end
 
-    defmodule BadStruct do
-      def __struct__ do
-        []
+    test "enforce @enforce_keys" do
+      defmodule EnforceKeys do
+        @enforce_keys [:foo]
+        defstruct(foo: nil)
       end
+
+      assert_raise ArgumentError,
+                   "@enforce_keys required keys ([:fo, :bar]) that are not defined in defstruct: [foo: nil]",
+                   fn ->
+                     defmodule EnforceKeysError do
+                       @enforce_keys [:foo, :fo, :bar]
+                       defstruct(foo: nil)
+                     end
+                   end
     end
+  end
+
+  test "invalid unquote" do
+    assert_compile_error(["nofile:1:1", "unquote called outside quote"], ~c"unquote 1")
+  end
 
-    assert_compile_fail CompileError,
-      "nofile:1: expected Kernel.ErrorsTest.BadStruct.__struct__/0 to return a map, got: []",
-      '%#{BadStruct}{}'
+  test "invalid unquote splicing in one-liners" do
+    assert_eval_raise ArgumentError,
+                      [
+                        "unquote_splicing only works inside arguments and block contexts, " <>
+                          "wrap it in parens if you want it to work with one-liners"
+                      ],
+                      ~c"""
+                      defmodule Kernel.ErrorsTest.InvalidUnquoteSplicingInOneliners do
+                        defmacro oneliner2 do
+                          quote do: unquote_splicing 1
+                        end
 
-    defmodule GoodStruct do
-      def __struct__ do
-        %{name: "josé"}
+                        def callme do
+                          oneliner2
+                        end
+                      end
+                      """
+  end
+
+  test "invalid attribute" do
+    msg = ~r"cannot inject attribute @foo into function/macro because cannot escape "
+
+    assert_raise ArgumentError, msg, fn ->
+      defmodule InvalidAttribute do
+        @foo fn -> nil end
+        def bar, do: @foo
       end
     end
-
-    assert_compile_fail CompileError,
-      "nofile:1: unknown key :age for struct Kernel.ErrorsTest.GoodStruct",
-      '%#{GoodStruct}{age: 27}'
   end
 
-  test :name_for_defmodule do
-    assert_compile_fail CompileError,
-      "nofile:1: invalid module name: 3",
-      'defmodule 1 + 2, do: 3'
+  test "typespec attributes set via Module.put_attribute/4" do
+    message =
+      "attributes type, typep, opaque, spec, callback, and macrocallback " <>
+        "must be set directly via the @ notation"
+
+    for kind <- [:type, :typep, :opaque, :spec, :callback, :macrocallback] do
+      assert_eval_raise ArgumentError,
+                        [message],
+                        """
+                        defmodule PutTypespecAttribute do
+                          Module.put_attribute(__MODULE__, #{inspect(kind)}, {})
+                        end
+                        """
+    end
   end
 
-  test :invalid_unquote do
-    assert_compile_fail CompileError,
-      "nofile:1: unquote called outside quote",
-      'unquote 1'
+  test "invalid struct field value" do
+    msg = ~r"invalid default value for struct field baz, cannot escape "
+
+    assert_raise ArgumentError, msg, fn ->
+      defmodule InvalidStructFieldValue do
+        defstruct baz: fn -> nil end
+      end
+    end
   end
 
-  test :invalid_quote_args do
-    assert_compile_fail CompileError,
-      "nofile:1: invalid arguments for quote",
-      'quote 1'
+  test "invalid case clauses" do
+    assert_compile_error(
+      ["nofile:1:37", "expected one argument for \"do\" clauses (->) in \"case\""],
+      ~c"case nil do 0, z when not is_nil(z) -> z end"
+    )
   end
 
-  test :invalid_calls do
-    assert_compile_fail CompileError,
-      "nofile:1: invalid call foo(1)(2)",
-      'foo(1)(2)'
+  test "invalid fn args" do
+    exception =
+      assert_eval_raise TokenMissingError,
+                        [
+                          "nofile:1:5:",
+                          ~r/missing terminator: end/
+                        ],
+                        ~c"fn 1"
 
-    assert_compile_fail CompileError,
-      "nofile:1: invalid call 1.foo()",
-      '1.foo'
+    assert exception.opening_delimiter == :fn
   end
 
-  test :unhandled_stab do
-    assert_compile_fail CompileError,
-      "nofile:3: unhandled operator ->",
-      '''
-      defmodule Mod do
-        def fun do
-          casea foo, do: (bar -> baz)
-        end
-      end
-      '''
+  test "invalid escape" do
+    assert_eval_raise TokenMissingError,
+                      ["nofile:1:3:", "invalid escape \\ at end of file"],
+                      ~c"1 \\"
   end
 
-  test :undefined_non_local_function do
-    assert_compile_fail CompileError,
-      "nofile:1: undefined function casea/2",
-      'casea foo, do: 1'
+  test "show snippet on missing tokens" do
+    assert_eval_raise TokenMissingError,
+                      [
+                        "nofile:1:25:",
+                        "missing terminator: end",
+                        "defmodule ShowSnippet do\n",
+                        "└ unclosed delimiter"
+                      ],
+                      ~c"defmodule ShowSnippet do"
   end
 
-  test :invalid_fn_args do
-    assert_compile_fail TokenMissingError,
-      "nofile:1: missing terminator: end (for \"fn\" starting at line 1)",
-      'fn 1'
+  test "don't show snippet when error line is empty" do
+    assert_eval_raise TokenMissingError,
+                      ["nofile:1:25:", "missing terminator: end"],
+                      ~c"defmodule ShowSnippet do\n\n"
   end
 
-  test :function_local_conflict do
-    assert_compile_fail CompileError,
-      "nofile:1: imported Kernel.&&/2 conflicts with local function",
-      '''
-      defmodule ErrorsTest do
+  test "function local conflict" do
+    assert_compile_error(
+      ["nofile:3:9: ", "imported Kernel.&&/2 conflicts with local function"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.FunctionLocalConflict do
         def other, do: 1 && 2
         def _ && _, do: :error
       end
-      '''
-  end
-
-  test :macro_local_conflict do
-    assert_compile_fail CompileError,
-      "nofile:6: call to local macro &&/2 conflicts with imported Kernel.&&/2, " <>
-      "please rename the local macro or remove the conflicting import",
-      '''
-      defmodule ErrorsTest do
+      """
+    )
+  end
+
+  test "macro local conflict" do
+    assert_compile_error(
+      [
+        "nofile:6:20",
+        "call to local macro &&/2 conflicts with imported Kernel.&&/2, " <>
+          "please rename the local macro or remove the conflicting import"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.MacroLocalConflict do
         def hello, do: 1 || 2
         defmacro _ || _, do: :ok
 
         defmacro _ && _, do: :error
         def world, do: 1 && 2
       end
-      '''
-  end
-
-  test :macro_with_undefined_local do
-    assert_compile_fail UndefinedFunctionError,
-      "undefined function: ErrorsTest.unknown/1",
-      '''
-      defmodule ErrorsTest do
-        defmacrop bar, do: unknown(1)
-        def baz, do: bar()
+      """
+    )
+  end
+
+  test "macro with undefined local" do
+    assert_eval_raise UndefinedFunctionError,
+                      [
+                        "function Kernel.ErrorsTest.MacroWithUndefinedLocal.unknown/1 is undefined (function not available)"
+                      ],
+                      ~c"""
+                      defmodule Kernel.ErrorsTest.MacroWithUndefinedLocal do
+                        defmacrop bar, do: unknown(1)
+                        def baz, do: bar()
+                      end
+                      """
+  end
+
+  test "private macro" do
+    assert_eval_raise UndefinedFunctionError,
+                      [
+                        "function Kernel.ErrorsTest.PrivateMacro.foo/0 is undefined (function not available)"
+                      ],
+                      ~c"""
+                      defmodule Kernel.ErrorsTest.PrivateMacro do
+                        defmacrop foo, do: 1
+                        defmacro bar, do: __MODULE__.foo()
+                        defmacro baz, do: bar()
+                      end
+                      """
+  end
+
+  test "macro invoked before its definition" do
+    assert_compile_error(
+      ["nofile:2:16", "cannot invoke macro bar/0 before its definition"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.IncorrectMacroDispatch do
+        def foo, do: bar()
+        defmacro bar, do: :bar
       end
-      '''
-  end
-
-  test :private_macro do
-    assert_compile_fail UndefinedFunctionError,
-      "undefined function: ErrorsTest.foo/0",
-      '''
-      defmodule ErrorsTest do
-        defmacrop foo, do: 1
-        defmacro bar, do: __MODULE__.foo
-        defmacro baz, do: bar
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:2:16", "cannot invoke macro bar/0 before its definition"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.IncorrectMacropDispatch do
+        def foo, do: bar()
+        defmacrop bar, do: :ok
       end
-      '''
-  end
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:2:40", "cannot invoke macro bar/1 before its definition"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.IncorrectMacroDispatch do
+        defmacro bar(a) when is_atom(a), do: bar([a])
+      end
+      """
+    )
+  end
+
+  test "macro captured before its definition" do
+    assert_compile_error(
+      ["nofile:3:18", "cannot invoke macro is_ok/1 before its definition"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.IncorrectMacroDispatch.Capture do
+        def foo do
+          predicate = &is_ok/1
+          Enum.any?([:ok, :error, :foo], predicate)
+        end
 
-  test :function_definition_with_alias do
-    assert_compile_fail CompileError,
-      "nofile:2: function names should start with lowercase characters or underscore, invalid name Bar",
-      '''
-      defmodule ErrorsTest do
+        defmacro is_ok(atom), do: atom == :ok
+      end
+      """
+    )
+  end
+
+  test "function definition with alias" do
+    assert_compile_error(
+      [
+        "nofile:2:7\n",
+        "function names should start with lowercase characters or underscore, invalid name Bar"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.FunctionDefinitionWithAlias do
         def Bar do
           :baz
         end
       end
-      '''
+      """
+    )
   end
 
-  test :function_import_conflict do
-    assert_compile_fail CompileError,
-      "nofile:3: function exit/1 imported from both :erlang and Kernel, call is ambiguous",
-      '''
-      defmodule ErrorsTest do
-        import :erlang, warn: false
+  test "function import conflict" do
+    assert_compile_error(
+      ["nofile:3:16", "function exit/1 imported from both :erlang and Kernel, call is ambiguous"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.FunctionImportConflict do
+        import :erlang, only: [exit: 1], warn: false
         def foo, do: exit(:test)
       end
-      '''
-  end
-
-  test :import_invalid_macro do
-    assert_compile_fail CompileError,
-      "nofile:1: cannot import Kernel.invalid/1 because it doesn't exist",
-      'import Kernel, only: [invalid: 1]'
-  end
-
-  test :unrequired_macro do
-    assert_compile_fail SyntaxError,
-      "nofile:2: you must require Kernel.ErrorsTest.UnproperMacro before invoking " <>
-      "the macro Kernel.ErrorsTest.UnproperMacro.unproper/1 "
-      '''
-      defmodule ErrorsTest do
-        Kernel.ErrorsTest.UnproperMacro.unproper([])
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:3:17", "function exit/1 imported from both :erlang and Kernel, call is ambiguous"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.FunctionImportConflict do
+        import :erlang, only: [exit: 1], warn: false
+        def foo, do: &exit/1
+      end
+      """
+    )
+  end
+
+  test "ensure valid import :only option" do
+    assert_compile_error(
+      [
+        "nofile:3:3",
+        "invalid :only option for import, expected value to be an atom :functions, :macros, or a literal keyword list of function names with arity as values, got: x"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.Only do
+        x = [flatten: 1]
+        import List, only: x
       end
-      '''
+      """
+    )
+  end
+
+  test "ensure valid import :except option" do
+    assert_compile_error(
+      [
+        "nofile:3:3",
+        "invalid :except option for import, expected value to be a literal keyword list of function names " <>
+          "with arity as values, got: Module.__get_attribute__(Kernel.ErrorsTest.Only, :x, 3, true)"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.Only do
+        @x [flatten: 1]
+        import List, except: @x
+      end
+      """
+    )
   end
 
-  test :def_defmacro_clause_change do
-    assert_compile_fail CompileError,
-      "nofile:3: defmacro foo/1 already defined as def",
-      '''
-      defmodule ErrorsTest do
+  test "def defmacro clause change" do
+    assert_compile_error(
+      ["nofile:3:12\n", "defmacro foo/1 already defined as def in nofile:2"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.DefDefmacroClauseChange do
         def foo(1), do: 1
         defmacro foo(x), do: x
       end
-      '''
+      """
+    )
   end
 
-  test :internal_function_overridden do
-    assert_compile_fail CompileError,
-      "nofile:1: function __info__/1 is internal and should not be overridden",
-      '''
-      defmodule ErrorsTest do
-        def __info__(_), do: []
-      end
-      '''
+  test "def defp clause change from another file" do
+    assert_compile_error(["nofile:4\n", "def hello/0 already defined as defp"], ~c"""
+    defmodule Kernel.ErrorsTest.DefDefmacroClauseChange do
+      require Kernel.ErrorsTest
+      defp hello, do: :world
+      Kernel.ErrorsTest.hello()
+    end
+    """)
   end
 
-  test :no_macros do
-    assert_compile_fail CompileError,
-      "nofile:2: could not load macros from module :lists",
-      '''
-      defmodule ErrorsTest do
-        import :lists, only: :macros
+  test "internal function overridden" do
+    assert_compile_error(
+      ["nofile:2:7\n", "cannot define def __info__/1 as it is automatically defined by Elixir"],
+      ~c"""
+      defmodule Kernel.ErrorsTest.InternalFunctionOverridden do
+        def __info__(_), do: []
       end
-      '''
+      """
+    )
   end
 
-  test :invalid_macro do
-    assert_compile_fail CompileError,
-      "nofile: invalid quoted expression: {:foo, :bar, :baz, :bat}",
-      '''
-      defmodule ErrorsTest do
+  test "invalid macro" do
+    assert_compile_error(
+      "invalid quoted expression: {:foo, :bar, :baz, :bat}",
+      ~c"""
+      defmodule Kernel.ErrorsTest.InvalidMacro do
         defmacrop oops do
           {:foo, :bar, :baz, :bat}
         end
 
-        def test, do: oops
+        def test, do: oops()
       end
-      '''
+      """
+    )
   end
 
-  test :unloaded_module do
-    assert_compile_fail CompileError,
-      "nofile:1: module Certainly.Doesnt.Exist is not loaded and could not be found",
-      'import Certainly.Doesnt.Exist'
+  test "unloaded module" do
+    assert_compile_error(
+      ["nofile:1:1", "module Certainly.Doesnt.Exist is not loaded and could not be found"],
+      ~c"import Certainly.Doesnt.Exist"
+    )
   end
 
-  test :scheduled_module do
-    assert_compile_fail CompileError,
-      "nofile:4: module ErrorsTest.Hygiene is not loaded but was defined. " <>
-      "This happens because you are trying to use a module in the same context it is defined. " <>
-      "Try defining the module outside the context that requires it.",
-      '''
-      defmodule ErrorsTest do
+  test "module imported from the context it was defined in" do
+    assert_compile_error(
+      [
+        "nofile:4:3",
+        "module Kernel.ErrorsTest.ScheduledModule.Hygiene is not loaded but was defined."
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.ScheduledModule do
+        defmodule Hygiene do
+        end
+        import Kernel.ErrorsTest.ScheduledModule.Hygiene
+      end
+      """
+    )
+  end
+
+  test "module imported from the same module" do
+    assert_compile_error(
+      [
+        "nofile:3:5",
+        "you are trying to use/import/require the module Kernel.ErrorsTest.ScheduledModule.Hygiene which is currently being defined"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.ScheduledModule do
         defmodule Hygiene do
+          import Kernel.ErrorsTest.ScheduledModule.Hygiene
         end
-        import ErrorsTest.Hygiene
       end
-      '''
+      """
+    )
   end
 
-  test :already_compiled_module do
-    assert_compile_fail ArgumentError,
-      "could not call eval_quoted on module Record " <>
-      "because it was already compiled",
-      'Module.eval_quoted Record, quote(do: 1), [], file: __ENV__.file'
-  end
+  test "invalid @compile inline" do
+    assert_compile_error(
+      ["nofile:1: ", "undefined function foo/1 given to @compile :inline"],
+      ~c"defmodule Test do @compile {:inline, foo: 1} end"
+    )
 
-  test :interpolation_error do
-    assert_compile_fail SyntaxError,
-      "nofile:1: \"do\" starting at line 1 is missing terminator \"end\". Unexpected token: )",
-      '"foo\#{case 1 do )}bar"'
+    assert_compile_error(
+      ["nofile:1: ", "macro foo/1 given to @compile :inline"],
+      ~c"defmodule Test do @compile {:inline, foo: 1}; defmacro foo(_), do: :ok end"
+    )
   end
 
-  test :in_definition_module do
-    assert_compile_fail CompileError,
-      "nofile:1: cannot define module ErrorsTest because it is currently being defined in nofile:1",
-      'defmodule ErrorsTest, do: (defmodule Elixir.ErrorsTest, do: true)'
-  end
+  test "invalid @nifs attribute" do
+    assert_compile_error(
+      ["nofile:1: ", "undefined function foo/1 given to @nifs"],
+      ~c"defmodule Test do @nifs [foo: 1] end"
+    )
 
-  test :invalid_definition do
-    assert_compile_fail CompileError,
-      "nofile:1: invalid syntax in def 1.(hello)",
-      'defmodule ErrorsTest, do: (def 1.(hello), do: true)'
-  end
+    assert_compile_error(
+      ["nofile:1: ", "undefined function foo/1 given to @nifs"],
+      ~c"defmodule Test do @nifs [foo: 1]; defmacro foo(_) end"
+    )
 
-  test :duplicated_bitstring_size do
-    assert_compile_fail CompileError,
-      "nofile:1: duplicated size definition in bitstring",
-      '<<1 :: [size(12), size(13)]>>'
+    assert_eval_raise ArgumentError,
+                      ["@nifs is a built-in module attribute"],
+                      ~c"defmodule Test do @nifs :not_an_option end"
   end
 
-  test :invalid_bitstring_specified do
-    assert_compile_fail CompileError,
-      "nofile:1: unknown bitstring specifier :atom",
-      '<<1 :: :atom>>'
-
-    assert_compile_fail CompileError,
-      "nofile:1: unknown bitstring specifier unknown()",
-      '<<1 :: unknown>>'
+  test "invalid @dialyzer options" do
+    assert_compile_error(
+      ["nofile:1: ", "undefined function foo/1 given to @dialyzer :nowarn_function"],
+      ~c"defmodule Test do @dialyzer {:nowarn_function, {:foo, 1}} end"
+    )
 
-    assert_compile_fail CompileError,
-      "nofile:1: unknown bitstring specifier another(12)",
-      '<<1 :: another(12)>>'
+    assert_compile_error(
+      ["nofile:1: ", "macro foo/1 given to @dialyzer :nowarn_function"],
+      ~c"defmodule Test do @dialyzer {:nowarn_function, {:foo, 1}}; defmacro foo(_), do: :ok end"
+    )
 
-    assert_compile_fail CompileError,
-      "nofile:1: size in bitstring expects an integer or a variable as argument, got: :a",
-      '<<1 :: size(:a)>>'
+    assert_compile_error(
+      ["nofile:1: ", "undefined function foo/1 given to @dialyzer :no_opaque"],
+      ~c"defmodule Test do @dialyzer {:no_opaque, {:foo, 1}} end"
+    )
 
-    assert_compile_fail CompileError,
-      "nofile:1: unit in bitstring expects an integer as argument, got: :x",
-      '<<1 :: unit(:x)>>'
+    assert_eval_raise ArgumentError,
+                      ["invalid value for @dialyzer attribute: :not_an_option"],
+                      ~c"defmodule Test do @dialyzer :not_an_option end"
   end
 
-  test :invalid_var! do
-    assert_compile_fail CompileError,
-      "nofile:1: expected var x to expand to an existing variable or be a part of a match",
-      'var!(x)'
-  end
-
-  test :invalid_alias do
-    assert_compile_fail CompileError,
-      "nofile:1: invalid value for keyword :as, expected an alias, got nested alias: Sample.Lists",
-      'alias :lists, as: Sample.Lists'
-  end
-
-  test :invalid_import_option do
-    assert_compile_fail CompileError,
-      "nofile:1: unsupported option :ops given to import",
-      'import :lists, [ops: 1]'
-  end
-
-  test :invalid_rescue_clause do
-    assert_compile_fail CompileError,
-      "nofile:4: invalid rescue clause. The clause should match on an alias, a variable or be in the `var in [alias]` format",
-      'try do\n1\nrescue\n%UndefinedFunctionError{arity: 1} -> false\nend'
+  test "@on_load attribute format" do
+    assert_raise ArgumentError, ~r/should be an atom or an {atom, 0} tuple/, fn ->
+      defmodule BadOnLoadAttribute do
+        Module.put_attribute(__MODULE__, :on_load, "not an atom")
+      end
+    end
   end
 
-  test :invalid_for_without_generators do
-    assert_compile_fail CompileError,
-      "nofile:1: for comprehensions must start with a generator",
-      'for x, do: x'
+  test "duplicated @on_load attribute" do
+    assert_raise ArgumentError, "the @on_load attribute can only be set once per module", fn ->
+      defmodule DuplicatedOnLoadAttribute do
+        @on_load :foo
+        @on_load :bar
+      end
+    end
   end
 
-  test :invalid_for_bit_generator do
-    assert_compile_fail CompileError,
-      "nofile:1: bitstring fields without size are not allowed in bitstring generators",
-      'for << x :: binary <- "123" >>, do: x'
+  test "@on_load attribute with undefined function" do
+    assert_compile_error(
+      ["nofile:1: ", "undefined function foo/0 given to @on_load"],
+      ~c"defmodule UndefinedOnLoadFunction do @on_load :foo end"
+    )
   end
 
-  test :unbound_cond do
-    assert_compile_fail CompileError,
-      "nofile:1: unbound variable _ inside cond. If you want the last clause to always match, " <>
-      "you probably meant to use: true ->",
-      'cond do _ -> true end'
+  test "wrong kind for @on_load attribute" do
+    assert_compile_error(
+      ["nofile:1: ", "macro foo/0 given to @on_load"],
+      ~c"""
+      defmodule PrivateOnLoadFunction do
+        @on_load :foo
+        defmacro foo, do: :ok
+      end
+      """
+    )
+  end
+
+  test "in definition module" do
+    assert_compile_error(
+      [
+        "nofile:2: ",
+        "cannot define module Kernel.ErrorsTest.InDefinitionModule " <>
+          "because it is currently being defined in nofile:1"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.InDefinitionModule do
+        defmodule Elixir.Kernel.ErrorsTest.InDefinitionModule, do: true
+      end
+      """
+    )
   end
 
-  test :fun_different_arities do
-    assert_compile_fail CompileError,
-      "nofile:1: cannot mix clauses with different arities in function definition",
-      'fn x -> x; x, y -> x + y end'
+  test "invalid definition" do
+    assert_compile_error(
+      ["nofile:1: ", "invalid syntax in def 1.(hello)"],
+      ~c"defmodule Kernel.ErrorsTest.InvalidDefinition, do: (def 1.(hello), do: true)"
+    )
   end
 
-  test :new_line_error do
-    assert_compile_fail SyntaxError,
-      "nofile:3: syntax error before: newline",
-      'if true do\n  foo = [],\n  baz\nend'
-  end
+  test "function head with guard" do
+    assert_compile_error(["nofile:2:7: ", "missing :do option in \"def\""], ~c"""
+    defmodule Kernel.ErrorsTest.BodyessFunctionWithGuard do
+      def foo(n) when is_number(n)
+    end
+    """)
 
-  test :invalid_var_or_function_on_guard do
-    assert_compile_fail CompileError,
-      "nofile:2: unknown variable something_that_does_not_exist or " <>
-      "cannot invoke function something_that_does_not_exist/0 inside guard",
-      '''
-      case [] do
-        [] when something_that_does_not_exist == [] -> :ok
+    assert_compile_error(["nofile:2:7: ", "missing :do option in \"def\""], ~c"""
+    defmodule Kernel.ErrorsTest.BodyessFunctionWithGuard do
+      def foo(n) when is_number(n), true
+    end
+    """)
+  end
+
+  test "invalid args for function head" do
+    assert_compile_error(
+      [
+        "nofile:2:7: ",
+        "patterns are not allowed in function head, only variables and default arguments (using \\\\)"
+      ],
+      ~c"""
+      defmodule Kernel.ErrorsTest.InvalidArgsForBodylessClause do
+        def foo(nil)
+        def foo(_), do: :ok
       end
-      '''
+      """
+    )
+  end
+
+  test "bad multi-call" do
+    assert_compile_error(
+      [
+        "nofile:1:1",
+        "invalid argument for alias, expected a compile time atom or alias, got: 42"
+      ],
+      ~c"alias IO.{ANSI, 42}"
+    )
+
+    assert_compile_error(
+      ["nofile:1:1", ":as option is not supported by multi-alias call"],
+      ~c"alias Elixir.{Map}, as: Dict"
+    )
+
+    assert_eval_raise UndefinedFunctionError,
+                      ["function List.\"{}\"/1 is undefined or private"],
+                      ~c"[List.{Chars}, \"one\"]"
+  end
+
+  test "macros error stacktrace" do
+    assert [
+             {:erlang, :+, [1, :foo], _},
+             {Kernel.ErrorsTest.MacrosErrorStacktrace, :sample, 1, _} | _
+           ] =
+             rescue_stacktrace("""
+             defmodule Kernel.ErrorsTest.MacrosErrorStacktrace do
+               defmacro sample(num), do: num + :foo
+               def other, do: sample(1)
+             end
+             """)
+  end
+
+  test "macros function clause stacktrace" do
+    assert [{__MODULE__, :sample, 1, _} | _] =
+             rescue_stacktrace("""
+             defmodule Kernel.ErrorsTest.MacrosFunctionClauseStacktrace do
+               import Kernel.ErrorsTest
+               sample(1)
+             end
+             """)
+  end
+
+  test "macros interpreted function clause stacktrace" do
+    assert [{Kernel.ErrorsTest.MacrosInterpretedFunctionClauseStacktrace, :sample, 1, _} | _] =
+             rescue_stacktrace("""
+             defmodule Kernel.ErrorsTest.MacrosInterpretedFunctionClauseStacktrace do
+               defmacro sample(0), do: 0
+               def other, do: sample(1)
+             end
+             """)
+  end
+
+  test "macros compiled callback" do
+    assert [{Kernel.ErrorsTest, :__before_compile__, [env], _} | _] =
+             rescue_stacktrace("""
+             defmodule Kernel.ErrorsTest.MacrosCompiledCallback do
+               Module.put_attribute(__MODULE__, :before_compile, Kernel.ErrorsTest)
+             end
+             """)
+
+    assert %Macro.Env{module: Kernel.ErrorsTest.MacrosCompiledCallback} = env
+  end
+
+  test "failed remote call stacktrace includes file/line info" do
+    try do
+      bad_remote_call(Process.get(:unused, 1))
+    rescue
+      ArgumentError ->
+        assert [
+                 {:erlang, :apply, [1, :foo, []], _},
+                 {__MODULE__, :bad_remote_call, 1, [file: _, line: _]} | _
+               ] = __STACKTRACE__
+    end
   end
 
-  test :bodyless_function_with_guard do
-    assert_compile_fail CompileError,
-      "nofile:2: missing do keyword in def",
-      '''
-      defmodule ErrorsTest do
-        def foo(n) when is_number(n)
+  test "def fails when rescue, else or catch don't have clauses" do
+    assert_compile_error(
+      ~r"invalid \"rescue\" block in \"def\", it expects \"pattern -> expr\" clauses",
+      """
+      defmodule Example do
+        def foo do
+          bar()
+        rescue
+          baz()
+        end
       end
-      '''
+      """
+    )
   end
 
-  test :invalid_args_for_bodyless_clause do
-    assert_compile_fail CompileError,
-      "nofile:2: can use only variables and \\\\ as arguments of bodyless clause",
-      '''
-      defmodule ErrorsTest do
-        def foo(arg // nil)
-        def foo(_), do: :ok
-      end
-      '''
-  end
+  test "duplicate map keys" do
+    assert_compile_error(["nofile:1:3", "key :a will be overridden in map"], """
+      %{a: :b, a: :c} = %{a: :c}
+    """)
 
-  test :invalid_function_on_match do
-    assert_compile_fail CompileError,
-      "nofile:1: cannot invoke function something_that_does_not_exist/0 inside match",
-      'case [] do; something_that_does_not_exist() -> :ok; end'
+    assert_compile_error(["nofile:1:3", "key :a will be overridden in map"], """
+      %{a: :b, a: :c, a: :d} = %{a: :c}
+    """)
   end
 
-  test :invalid_remote_on_match do
-    assert_compile_fail CompileError,
-      "nofile:1: cannot invoke remote function Hello.something_that_does_not_exist/0 inside match",
-      'case [] do; Hello.something_that_does_not_exist() -> :ok; end'
-  end
+  test "| outside of cons" do
+    assert_compile_error(["nofile:1:3", "misplaced operator |/2"], "1 | 2")
 
-  test :invalid_remote_on_guard do
-    assert_compile_fail CompileError,
-      "nofile:1: cannot invoke remote function Hello.something_that_does_not_exist/0 inside guard",
-      'case [] do; [] when Hello.something_that_does_not_exist == [] -> :ok; end'
+    assert_compile_error(
+      ["nofile:1:45", "misplaced operator |/2"],
+      "defmodule MisplacedOperator, do: (def bar(1 | 2), do: :ok)"
+    )
   end
 
-  test :typespec_errors do
-    assert_compile_fail CompileError,
-      "nofile:2: type foo() undefined",
-      '''
-      defmodule ErrorsTest do
-        @type omg :: foo
-      end
-      '''
+  defp bad_remote_call(x), do: x.foo()
 
-    assert_compile_fail CompileError,
-      "nofile:2: spec for undefined function ErrorsTest.omg/0",
-      '''
-      defmodule ErrorsTest do
-        @spec omg :: atom
-      end
-      '''
-  end
+  defmacro sample(0), do: 0
 
-  test :bad_unquoting do
-    assert_compile_fail CompileError,
-      "nofile: invalid quoted expression: {:foo, 0, 1}",
-      '''
-      defmodule ErrorsTest do
-        def range(unquote({:foo, 0, 1})), do: :ok
-      end
-      '''
+  defmacro before_compile(_) do
+    quote(do: _)
   end
 
-  test :macros_error_stacktrace do
-    assert [{:erlang, :+, [1, :foo], _}, {ErrorsTest, :sample, 1, _}|_] =
-      rescue_stacktrace("""
-      defmodule ErrorsTest do
-        defmacro sample(num), do: num + :foo
-        def other, do: sample(1)
-      end
-      """)
-  end
+  ## Helpers
 
-  test :macros_function_clause_stacktrace do
-    assert [{__MODULE__, :sample, 1, _}|_] =
-      rescue_stacktrace("""
-      defmodule ErrorsTest do
-        import Kernel.ErrorsTest
-        sample(1)
+  defp assert_eval_raise(given_exception, messages, source) do
+    exception =
+      assert_raise given_exception, fn ->
+        Code.eval_string(source)
       end
-      """)
-  end
 
-  test :macros_interpreted_function_clause_stacktrace do
-    assert [{ErrorsTest, :sample, 1, _}|_] =
-      rescue_stacktrace("""
-      defmodule ErrorsTest do
-        defmacro sample(0), do: 0
-        def other, do: sample(1)
-      end
-      """)
-  end
+    error_msg = Exception.format(:error, exception, [])
 
-  test :macros_compiled_callback do
-    assert [{Kernel.ErrorsTest, :__before_compile__, [%Macro.Env{module: ErrorsTest}], _}|_] =
-      rescue_stacktrace("""
-      defmodule ErrorsTest do
-        Module.put_attribute(__MODULE__, :before_compile, Kernel.ErrorsTest)
-      end
-      """)
+    for msg <- messages do
+      assert error_msg =~ msg
+    end
+
+    exception
   end
 
-  defmacro sample(0), do: 0
+  defp assert_compile_error(messages, string) do
+    captured =
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        ast = Code.string_to_quoted!(string, columns: true)
+        assert_raise CompileError, fn -> Code.eval_quoted(ast) end
+      end)
 
-  defmacro before_compile(_) do
-    quote(do: _)
+    for message <- List.wrap(messages) do
+      assert captured =~ message
+    end
   end
 
-  ## Helpers
-
-  defp rescue_stacktrace(expr) do
-    result = try do
-      :elixir.eval(to_char_list(expr), [])
+  defp rescue_stacktrace(string) do
+    try do
+      Code.eval_string(string)
       nil
     rescue
-      _ -> System.stacktrace
+      _ -> __STACKTRACE__
+    else
+      _ -> flunk("Expected expression to fail")
     end
-
-    result || raise(ExUnit.AssertionError, message: "Expected function given to rescue_stacktrace to fail")
   end
 end
diff --git a/lib/elixir/test/elixir/kernel/expansion_test.exs b/lib/elixir/test/elixir/kernel/expansion_test.exs
index ca6048bd386..d1b2af82280 100644
--- a/lib/elixir/test/elixir/kernel/expansion_test.exs
+++ b/lib/elixir/test/elixir/kernel/expansion_test.exs
@@ -1,474 +1,3091 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.ExpansionTarget do
   defmacro seventeen, do: 17
+  defmacro bar, do: "bar"
+
+  defmacro message_hello(arg) do
+    send(self(), :hello)
+    arg
+  end
 end
 
 defmodule Kernel.ExpansionTest do
   use ExUnit.Case, async: true
 
-  ## __block__
+  import ExUnit.CaptureIO
 
-  test "__block__: expands to nil when empty" do
-    assert expand(quote do: __block__()) == nil
-  end
+  describe "__block__" do
+    test "expands to nil when empty" do
+      assert expand(quote(do: unquote(:__block__)())) == nil
+    end
 
-  test "__block__: expands to argument when arity is 1" do
-    assert expand(quote do: __block__(1)) == 1
-  end
+    test "expands to argument when arity is 1" do
+      assert expand(quote(do: unquote(:__block__)(1))) == 1
+    end
 
-  test "__block__: is recursive to argument when arity is 1" do
-    assert expand(quote do: __block__(1, __block__(2))) == quote do: __block__(1, 2)
-  end
+    test "is recursive to argument when arity is 1" do
+      expanded =
+        quote do
+          _ = 1
+          2
+        end
 
-  test "__block__: accumulates vars" do
-    assert expand(quote(do: (a = 1; a))) == quote do: (a = 1; a)
+      assert expand(quote(do: unquote(:__block__)(_ = 1, unquote(:__block__)(2)))) == expanded
+    end
+
+    test "accumulates vars" do
+      before_expansion =
+        quote do
+          a = 1
+          a
+        end
+
+      after_expansion =
+        quote do
+          a = 1
+          a
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
   end
 
-  ## alias
+  describe "alias" do
+    test "expand args, defines alias and returns itself" do
+      alias true, as: True
 
-  test "alias: expand args, defines alias and returns itself" do
-    alias true, as: True
+      input = quote(do: alias(:hello, as: World, warn: True))
+      {output, env} = expand_env(input, __ENV__)
 
-    input = quote do: (alias :hello, as: World, warn: True)
-    {output, env} = expand_env(input, __ENV__)
+      assert output == :hello
+      assert env.aliases == [{:"Elixir.True", true}, {:"Elixir.World", :hello}]
+    end
 
-    assert output == quote do: (alias :hello, as: :"Elixir.World", warn: true)
-    assert env.aliases == [{:"Elixir.True", true}, {:"Elixir.World", :hello}]
-  end
+    test "invalid alias" do
+      message =
+        ~r"invalid value for option :as, expected a simple alias, got nested alias: Sample.Lists"
 
-  ## __aliases__
+      assert_compile_error(message, fn ->
+        expand(quote(do: alias(:lists, as: Sample.Lists)))
+      end)
 
-  test "__aliases__: expands even if no alias" do
-    assert expand(quote do: World) == :"Elixir.World"
-    assert expand(quote do: Elixir.World) == :"Elixir.World"
-  end
+      message = ~r"invalid argument for alias, expected a compile time atom or alias, got: 1 \+ 2"
 
-  test "__aliases__: expands with alias" do
-    alias Hello, as: World
-    assert expand_env(quote(do: World), __ENV__) |> elem(0) == :"Elixir.Hello"
-  end
+      assert_compile_error(message, fn ->
+        expand(quote(do: alias(1 + 2)))
+      end)
 
-  test "__aliases__: expands with alias is recursive" do
-    alias Source, as: Hello
-    alias Hello, as: World
-    assert expand_env(quote(do: World), __ENV__) |> elem(0) == :"Elixir.Source"
-  end
+      message = ~r"invalid value for option :as, expected an alias, got: :foobar"
 
-  test "__aliases__: expands to elixir_aliases on runtime" do
-    assert expand(quote do: hello.World) ==
-           quote do: :elixir_aliases.concat([hello(), :World])
-  end
+      assert_compile_error(message, fn ->
+        expand(quote(do: alias(:lists, as: :foobar)))
+      end)
 
-  ## =
+      message = ~r"invalid value for option :as, expected an alias, got: :\"Elixir.foobar\""
 
-  test "=: sets context to match" do
-    assert expand(quote do: __ENV__.context = :match) == quote do: :match = :match
-  end
+      assert_compile_error(message, fn ->
+        expand(quote(do: alias(:lists, as: :"Elixir.foobar")))
+      end)
 
-  test "=: defines vars" do
-    {output, env} = expand_env(quote(do: a = 1), __ENV__)
-    assert output == quote(do: a = 1)
-    assert {:a, __MODULE__} in env.vars
-  end
+      message =
+        ~r"alias cannot be inferred automatically for module: :lists, please use the :as option"
 
-  test "=: does not carry rhs imports" do
-    assert expand(quote(do: flatten([1,2,3]) = import List)) ==
-           quote(do: flatten([1,2,3]) = import :"Elixir.List", [])
-  end
+      assert_compile_error(message, fn ->
+        expand(quote(do: alias(:lists)))
+      end)
+    end
 
-  test "=: does not define _" do
-    {output, env} = expand_env(quote(do: _ = 1), __ENV__)
-    assert output == quote(do: _ = 1)
-    assert env.vars == []
-  end
+    test "invalid expansion" do
+      assert_compile_error(~r"invalid alias: \"foo\.Foo\"", fn ->
+        code =
+          quote do
+            foo = :foo
+            foo.Foo
+          end
 
-  ## Pseudo vars
+        expand(code)
+      end)
+    end
 
-  test "__MODULE__" do
-    assert expand(quote do: __MODULE__) == __MODULE__
-  end
+    test "raises if :as is passed to multi-alias aliases" do
+      assert_compile_error(~r":as option is not supported by multi-alias call", fn ->
+        expand(quote(do: alias(Foo.{Bar, Baz}, as: BarBaz)))
+      end)
+    end
 
-  test "__DIR__" do
-    assert expand(quote do: __DIR__) == __DIR__
-  end
+    test "raises on multi-alias with non-atom base" do
+      assert_compile_error(~r"invalid alias: \"foo\"", fn ->
+        expand(quote(do: alias(foo.{Bar, Baz})))
+      end)
+    end
 
-  test "__CALLER__" do
-    assert expand(quote do: __CALLER__) == quote do: __CALLER__
+    test "invalid options" do
+      assert_compile_error(~r"unsupported option :ops given to alias", fn ->
+        expand(quote(do: alias(Foo, ops: 1)))
+      end)
+    end
   end
 
-  test "__ENV__" do
-    env = %{__ENV__ | line: 0}
-    assert expand_env(quote(do: __ENV__), env) ==
-           {{:%{}, [], Map.to_list(env)}, env}
-  end
+  describe "__aliases__" do
+    test "expands even if no alias" do
+      assert expand(quote(do: World)) == :"Elixir.World"
+      assert expand(quote(do: Elixir.World)) == :"Elixir.World"
+    end
 
-  test "__ENV__.accessor" do
-    env = %{__ENV__ | line: 0}
-    assert expand_env(quote(do: __ENV__.file), env) == {__ENV__.file, env}
-    assert expand_env(quote(do: __ENV__.unknown), env) ==
-           {quote(do: unquote({:%{}, [], Map.to_list(env)}).unknown), env}
+    test "expands with alias" do
+      alias Hello, as: World
+      assert expand_env(quote(do: World), __ENV__) |> elem(0) == :"Elixir.Hello"
+    end
+
+    test "expands with alias is recursive" do
+      alias Source, as: Hello
+      alias Hello, as: World
+      assert expand_env(quote(do: World), __ENV__) |> elem(0) == :"Elixir.Source"
+    end
   end
 
-  ## Super
+  describe "import" do
+    test "raises on conflicting options" do
+      message =
+        ~r":only and :except can only be given together to import when :only is :functions, :macros, or :sigils"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: import(Kernel, only: [], except: [])))
+      end)
+    end
+
+    test "invalid import option" do
+      assert_compile_error(~r"unsupported option :ops given to import", fn ->
+        expand(quote(do: import(:lists, ops: 1)))
+      end)
+    end
 
-  test "super: expand args" do
-    assert expand(quote do: super(a, b)) == quote do: super(a(), b())
+    test "raises for non-compile-time module" do
+      assert_compile_error(~r"invalid argument for import, .*, got: {:a, :tuple}", fn ->
+        expand(quote(do: import({:a, :tuple})))
+      end)
+    end
   end
 
-  ## Vars
+  describe "require" do
+    test "raises for non-compile-time module" do
+      assert_compile_error(~r"invalid argument for require, .*, got: {:a, :tuple}", fn ->
+        expand(quote(do: require({:a, :tuple})))
+      end)
+    end
 
-  test "vars: expand to local call" do
-    {output, env} = expand_env(quote(do: a), __ENV__)
-    assert output == quote(do: a())
-    assert env.vars == []
+    test "invalid options" do
+      assert_compile_error(~r"unsupported option :ops given to require", fn ->
+        expand(quote(do: require(Foo, ops: 1)))
+      end)
+    end
   end
 
-  test "vars: forces variable to exist" do
-    assert expand(quote do: (var!(a) = 1; var!(a)))
+  describe "=" do
+    test "defines vars" do
+      {output, env} = expand_env(quote(do: a = 1), __ENV__)
+      assert output == quote(do: a = 1)
+      assert Macro.Env.has_var?(env, {:a, __MODULE__})
+    end
+
+    test "does not define _" do
+      {output, env} = expand_env(quote(do: _ = 1), __ENV__)
+      assert output == quote(do: _ = 1)
+      assert Macro.Env.vars(env) == []
+    end
 
-    message = ~r"expected var a to expand to an existing variable or be a part of a match"
-    assert_raise CompileError, message, fn -> expand(quote do: var!(a)) end
+    test "errors on directly recursive definitions" do
+      assert_compile_error(
+        ~r"""
+        recursive variable definition in patterns:
 
-    message = ~r"expected var a \(context Unknown\) to expand to an existing variable or be a part of a match"
-    assert_raise CompileError, message, fn -> expand(quote do: var!(a, Unknown)) end
-  end
+        \{x = \{:ok, x\}\}
 
-  test "^: expands args" do
-    assert expand(quote do: ^a = 1) == quote do: ^a = 1
-  end
+        the variable "x" \(context Kernel.ExpansionTest\) is defined in function of itself
+        """,
+        fn -> expand(quote(do: {x = {:ok, x}} = :ok)) end
+      )
+
+      assert_compile_error(
+        ~r"""
+        recursive variable definition in patterns:
 
-  test "^: raises outside match" do
-    assert_raise CompileError, ~r"cannot use \^a outside of match clauses", fn ->
-      expand(quote do: ^a)
+        \{\{x, y\} = \{y, x\}\}
+
+        the variable "x" \(context Kernel.ExpansionTest\) is defined in function of itself
+        """,
+        fn -> expand(quote(do: {{x, y} = {y, x}} = :ok)) end
+      )
+
+      assert_compile_error(
+        ~r"""
+        recursive variable definition in patterns:
+
+        \{\{:x, y\} = \{x, :y\}, x = y\}
+
+        the variable "x" \(context Kernel.ExpansionTest\) is defined recursively in function of "y" \(context Kernel.ExpansionTest\)
+        """,
+        fn -> expand(quote(do: {{:x, y} = {x, :y}, x = y} = :ok)) end
+      )
+
+      assert_compile_error(
+        ~r"""
+        recursive variable definition in patterns:
+
+        \{x = y, y = z, z = x\}
+
+        the following variables form a cycle: "x" \(context Kernel.ExpansionTest\), "y" \(context Kernel.ExpansionTest\), "z" \(context Kernel.ExpansionTest\)
+        """,
+        fn -> expand(quote(do: {x = y, y = z, z = x} = :ok)) end
+      )
     end
-  end
 
-  test "^: raises without var" do
-    assert_raise CompileError, ~r"invalid argument for unary operator \^, expected an existing variable, got: \^1", fn ->
-      expand(quote do: ^1 = 1)
+    test "complex recursive variable definitions" do
+      assert expand(
+               quote do:
+                       {%{type: type, client_id: client_id} = message,
+                        %{type: type, client_id: client_id} = state} = :ok
+             )
+
+      assert_compile_error(
+        ~r"recursive variable definition in patterns",
+        fn ->
+          expand(
+            quote do:
+                    {%{type: type, client_id: client_id} = message,
+                     %{type: type, client_id: client_id} = state, client_id = type} = :ok
+          )
+        end
+      )
     end
   end
 
-  ## Locals
+  describe "environment macros" do
+    test "__MODULE__" do
+      assert expand(quote(do: __MODULE__)) == __MODULE__
+    end
 
-  test "locals: expands to remote calls" do
-    assert {{:., _, [Kernel, :=~]}, _, [{:a, _, []}, {:b, _, []}]} =
-          expand(quote do: a =~ b)
-  end
+    test "__DIR__" do
+      assert expand(quote(do: __DIR__)) == __DIR__
+    end
 
-  test "locals: expands to configured local" do
-    assert expand_env(quote(do: a), %{__ENV__ | local: Hello}) |> elem(0) ==
-           quote(do: :"Elixir.Hello".a())
-  end
+    test "__ENV__" do
+      env = %{__ENV__ | line: 0}
+      assert expand_env(quote(do: __ENV__), env) == {Macro.escape(env), env}
+      assert %{lexical_tracker: nil, tracers: []} = __ENV__
+    end
 
-  test "locals: in guards" do
-    assert expand(quote(do: fn pid when :erlang.==(pid, self) -> pid end)) ==
-           quote(do: fn pid when :erlang.==(pid, :erlang.self()) -> pid end)
-  end
+    test "__ENV__.accessor" do
+      env = %{__ENV__ | line: 0}
+      assert expand_env(quote(do: __ENV__.file), env) == {__ENV__.file, env}
 
-  test "locals: custom imports" do
-    assert expand(quote do: (import Kernel.ExpansionTarget; seventeen)) ==
-           quote do: (import :"Elixir.Kernel.ExpansionTarget", []; 17)
-  end
+      assert expand_env(quote(do: __ENV__.unknown), env) ==
+               {quote(do: unquote(Macro.escape(env)).unknown), env}
 
-  ## Tuples
+      assert __ENV__.lexical_tracker == nil
+      assert __ENV__.tracers == []
+    end
 
-  test "tuples: expanded as arguments" do
-    assert expand(quote(do: {a = 1, a})) == quote do: {a = 1, a()}
-    assert expand(quote(do: {b, a = 1, a})) == quote do: {b(), a = 1, a()}
+    test "on match" do
+      assert_compile_error(
+        ~r"invalid pattern in match, __ENV__ is not allowed in matches",
+        fn -> expand(quote(do: __ENV__ = :ok)) end
+      )
+
+      assert_compile_error(
+        ~r"invalid pattern in match, __CALLER__ is not allowed in matches",
+        fn -> expand(quote(do: __CALLER__ = :ok)) end
+      )
+
+      assert_compile_error(
+        ~r"invalid pattern in match, __STACKTRACE__ is not allowed in matches",
+        fn -> expand(quote(do: __STACKTRACE__ = :ok)) end
+      )
+    end
   end
 
-  ## Maps & structs
+  describe "vars" do
+    test "raises on undefined var by default" do
+      assert_compile_error(~r"undefined variable \"a\"", fn ->
+        expand_env({:a, [], nil}, __ENV__, [])
+      end)
+    end
+
+    test "expands vars to local call when :on_undefined_variable is :warn" do
+      Code.put_compiler_option(:on_undefined_variable, :warn)
 
-  test "maps: expanded as arguments" do
-    assert expand(quote(do: %{a: a = 1, b: a})) == quote do: %{a: a = 1, b: a()}
-  end
+      {output, env} = expand_env({:a, [], nil}, __ENV__, [])
+      assert output == {:a, [if_undefined: :warn], []}
+      assert Macro.Env.vars(env) == []
+    after
+      Code.put_compiler_option(:on_undefined_variable, :raise)
+    end
 
-  test "structs: expanded as arguments" do
-    assert expand(quote(do: %:elixir{a: a = 1, b: a})) ==
-           quote do: %:elixir{a: a = 1, b: a()}
+    test "expands vars to local call without warning" do
+      env = __ENV__
 
-    assert expand(quote(do: %:"Elixir.Kernel"{a: a = 1, b: a})) ==
-           quote do: %:"Elixir.Kernel"{a: a = 1, b: a()}
-  end
+      {output, _, env} =
+        :elixir_expand.expand({:a, [if_undefined: :apply], nil}, :elixir_env.env_to_ex(env), env)
 
-  test "structs: expects atoms" do
-    assert_raise CompileError, ~r"expected struct name to be a compile time atom or alias", fn ->
-      expand(quote do: %unknown{a: 1})
+      assert output == {:a, [if_undefined: :apply], []}
+      assert Macro.Env.vars(env) == []
     end
-  end
 
-  ## quote
+    test "raises when expanding var to local call" do
+      env = __ENV__
 
-  test "quote: expanded to raw forms" do
-    assert expand(quote do: (quote do: hello)) == {:{}, [], [:hello, [], __MODULE__]}
-  end
+      assert_compile_error(~r"undefined variable \"a\"", fn ->
+        :elixir_expand.expand({:a, [if_undefined: :raise], nil}, :elixir_env.env_to_ex(env), env)
+      end)
+    end
 
-  ## Anonymous calls
+    test "forces variable to exist" do
+      code =
+        quote do
+          var!(a) = 1
+          var!(a)
+        end
 
-  test "anonymous calls: expands base and args" do
-    assert expand(quote do: a.(b)) == quote do: a().(b())
-  end
+      assert expand(code)
+
+      message = ~r"undefined variable \"a\""
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: var!(a)))
+      end)
 
-  test "anonymous calls: raises on atom base" do
-    assert_raise CompileError, ~r"invalid function call :foo.()", fn ->
-      expand(quote do: :foo.(a))
+      message = ~r"undefined variable \"a\" \(context Unknown\)"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: var!(a, Unknown)))
+      end)
     end
-  end
 
-  ## Remote calls
+    test "raises for _ used outside of a match" do
+      assert_compile_error(~r"invalid use of _", fn ->
+        expand(quote(do: {1, 2, _}))
+      end)
+    end
 
-  test "remote calls: expands to erlang" do
-    assert expand(quote do: Kernel.is_atom(a)) == quote do: :erlang.is_atom(a())
-  end
+    defmacrop var_ver(var, version) do
+      quote do
+        {unquote(var), [version: unquote(version)], __MODULE__}
+      end
+    end
 
-  test "remote calls: expands macros" do
-    assert expand(quote do: Kernel.ExpansionTest.thirteen) == 13
-  end
+    defp expand_with_version(expr) do
+      env = :elixir_env.reset_vars(__ENV__)
+      {expr, _, _} = :elixir_expand.expand(expr, :elixir_env.env_to_ex(env), env)
+      expr
+    end
 
-  test "remote calls: expands receiver and args" do
-    assert expand(quote do: a.is_atom(b)) == quote do: a().is_atom(b())
-    assert expand(quote do: (a = :foo).is_atom(a)) == quote do: (a = :foo).is_atom(a())
+    test "tracks variable version" do
+      assert {:__block__, _, [{:=, _, [var_ver(:x, 0), 0]}, {:=, _, [_, var_ver(:x, 0)]}]} =
+               expand_with_version(
+                 quote do
+                   x = 0
+                   _ = x
+                 end
+               )
+
+      assert {:__block__, _,
+              [
+                {:=, _, [var_ver(:x, 0), 0]},
+                {:=, _, [_, var_ver(:x, 0)]},
+                {:=, _, [var_ver(:x, 1), 1]},
+                {:=, _, [_, var_ver(:x, 1)]}
+              ]} =
+               expand_with_version(
+                 quote do
+                   x = 0
+                   _ = x
+                   x = 1
+                   _ = x
+                 end
+               )
+
+      assert {:__block__, _,
+              [
+                {:=, _, [var_ver(:x, 0), 0]},
+                {:fn, _, [{:->, _, [[var_ver(:x, 1)], {:=, _, [var_ver(:x, 2), 2]}]}]},
+                {:=, _, [_, var_ver(:x, 0)]},
+                {:=, _, [var_ver(:x, 3), 3]}
+              ]} =
+               expand_with_version(
+                 quote do
+                   x = 0
+                   fn x -> x = 2 end
+                   _ = x
+                   x = 3
+                 end
+               )
+
+      assert {:__block__, _,
+              [
+                {:=, _, [var_ver(:x, 0), 0]},
+                {:case, _, [:foo, [do: [{:->, _, [[var_ver(:x, 1)], var_ver(:x, 1)]}]]]},
+                {:=, _, [_, var_ver(:x, 0)]},
+                {:=, _, [var_ver(:x, 2), 2]}
+              ]} =
+               expand_with_version(
+                 quote do
+                   x = 0
+                   case(:foo, do: (x -> x))
+                   _ = x
+                   x = 2
+                 end
+               )
+    end
   end
 
-  test "remote calls: modules must be required for macros" do
-    assert expand(quote do: (require Kernel.ExpansionTarget; Kernel.ExpansionTarget.seventeen)) ==
-           quote do: (require :"Elixir.Kernel.ExpansionTarget", []; 17)
-  end
+  describe "^" do
+    test "expands args" do
+      before_expansion =
+        quote do
+          after_expansion = 1
+          ^after_expansion = 1
+        end
+
+      after_expansion =
+        quote do
+          after_expansion = 1
+          ^after_expansion = 1
+        end
 
-  test "remote calls: raises when not required" do
-    msg = ~r"you must require Kernel\.ExpansionTarget before invoking the macro Kernel\.ExpansionTarget\.seventeen/0"
-    assert_raise CompileError, msg, fn ->
-      expand(quote do: Kernel.ExpansionTarget.seventeen)
+      assert expand(before_expansion) == after_expansion
     end
-  end
 
-  ## Comprehensions
+    test "raises outside match" do
+      assert_compile_error(~r"misplaced operator \^a", fn ->
+        expand(quote(do: ^a))
+      end)
+    end
 
-  test "variables inside comprehensions do not leak with enums" do
-    assert expand(quote do: (for(a <- b, do: c = 1); c)) ==
-           quote do: (for(a <- b(), do: c = 1); c())
-  end
+    test "raises without var" do
+      message =
+        ~r"invalid argument for unary operator \^, expected an existing variable, got: \^1"
 
-  test "variables inside comprehensions do not leak with binaries" do
-    assert expand(quote do: (for(<<a <- b>>, do: c = 1); c)) ==
-           quote do: (for(<< <<a>> <- b() >>, do: c = 1); c())
-  end
+      assert_compile_error(message, fn ->
+        expand(quote(do: ^1 = 1))
+      end)
+    end
 
-  test "variables inside filters are available in blocks" do
-    assert expand(quote do: for(a <- b, c = a, do: c)) ==
-           quote do: (for(a <- b(), c = a, do: c))
+    test "raises when the var is undefined" do
+      assert_compile_error(~r"undefined variable \^foo", fn ->
+        expand(quote(do: ^foo = :foo), [])
+      end)
+    end
   end
 
-  test "variables inside comprehensions options do not leak" do
-    assert expand(quote do: (for(a <- c = b, into: [], do: 1); c)) ==
-           quote do: (for(a <- c = b(), do: 1, into: []); c())
+  describe "locals" do
+    test "expands to remote calls" do
+      assert {{:., _, [Kernel, :=~]}, _, [{:a, _, []}, {:b, _, []}]} = expand(quote(do: a =~ b))
+    end
 
-    assert expand(quote do: (for(a <- b, into: c = [], do: 1); c)) ==
-           quote do: (for(a <- b(), do: 1, into: c = []); c())
-  end
+    test "in matches" do
+      assert_compile_error(
+        ~r"cannot find or invoke local foo/1 inside a match. .+ Called as: foo\(:bar\)",
+        fn ->
+          expand(quote(do: foo(:bar) = :bar))
+        end
+      )
+    end
 
-  ## Capture
+    test "in guards" do
+      code = quote(do: fn pid when :erlang.==(pid, self) -> pid end)
+      expanded_code = quote(do: fn pid when :erlang.==(pid, :erlang.self()) -> pid end)
+      assert clean_meta(expand(code), [:imports, :context]) == expanded_code
 
-  test "&: keeps locals" do
-    assert expand(quote do: &unknown/2) ==
-           {:&, [], [{:/, [], [{:unknown,[],nil}, 2]}]}
-    assert expand(quote do: &unknown(&1, &2)) ==
-           {:&, [], [{:/, [], [{:unknown,[],nil}, 2]}]}
-  end
+      assert_compile_error(~r"cannot find or invoke local foo/1", fn ->
+        expand(quote(do: fn arg when foo(arg) -> arg end))
+      end)
+    end
 
-  test "&: expands remotes" do
-    assert expand(quote do: &List.flatten/2) ==
-           quote do: :erlang.make_fun(:"Elixir.List", :flatten, 2)
+    test "custom imports" do
+      before_expansion =
+        quote do
+          import Kernel.ExpansionTarget
+          seventeen()
+        end
 
-    assert expand(quote do: &Kernel.is_atom/1) ==
-           quote do: :erlang.make_fun(:erlang, :is_atom, 1)
-  end
+      after_expansion =
+        quote do
+          :"Elixir.Kernel.ExpansionTarget"
+          17
+        end
 
-  test "&: expands macros" do
+      assert expand(before_expansion) == after_expansion
+    end
 
-    assert expand(quote do: (require Kernel.ExpansionTarget; &Kernel.ExpansionTarget.seventeen/0)) ==
-           quote do: (require :"Elixir.Kernel.ExpansionTarget", []; fn -> 17 end)
+    test "invalid metadata" do
+      assert expand({:foo, [imports: 2, context: :unknown], [1, 2]}) ==
+               {:foo, [imports: 2, context: :unknown], [1, 2]}
+    end
   end
 
-  ## fn
+  describe "floats" do
+    test "cannot be 0.0 inside match" do
+      assert capture_io(:stderr, fn -> expand(quote(do: 0.0 = 0.0)) end) =~
+               "pattern matching on 0.0 is equivalent to matching only on +0.0 from Erlang/OTP 27+"
 
-  test "fn: expands each clause" do
-    assert expand(quote do: fn x -> x; _ -> x end) ==
-           quote do: fn x -> x; _ -> x() end
+      assert {:=, [], [+0.0, +0.0]} = expand(quote(do: +0.0 = 0.0))
+      assert {:=, [], [-0.0, +0.0]} = expand(quote(do: -0.0 = 0.0))
+    end
   end
 
-  test "fn: does not share lexical in between clauses" do
-    assert expand(quote do: fn 1 -> import List; 2 -> flatten([1,2,3]) end) ==
-           quote do: fn 1 -> import :"Elixir.List", []; 2 -> flatten([1,2,3]) end
-  end
+  describe "tuples" do
+    test "expanded as arguments" do
+      assert expand(quote(do: {after_expansion = 1, a})) == quote(do: {after_expansion = 1, a()})
 
-  test "fn: expands guards" do
-    assert expand(quote do: fn x when x when __ENV__.context -> true end) ==
-           quote do: fn x when x when :guard -> true end
+      assert expand(quote(do: {b, after_expansion = 1, a})) ==
+               quote(do: {b(), after_expansion = 1, a()})
+    end
   end
 
-  test "fn: does not leak vars" do
-    assert expand(quote do: (fn x -> x end; x)) ==
-           quote do: (fn x -> x end; x())
-  end
+  describe "maps" do
+    test "expanded as arguments" do
+      assert expand(quote(do: %{a: after_expansion = 1, b: a})) ==
+               quote(do: %{a: after_expansion = 1, b: a()})
+    end
 
-  ## Cond
+    test "with variables on keys inside patterns" do
+      ast =
+        quote do
+          %{(x = 1) => 1}
+        end
 
-  test "cond: expands each clause" do
-    assert expand_and_clean(quote do: (cond do x = 1 -> x; _ -> x end)) ==
-           quote do: (cond do x = 1 -> x; _ -> x() end)
-  end
+      assert expand(ast) == ast
 
-  test "cond: does not share lexical in between clauses" do
-    assert expand_and_clean(quote do: (cond do 1 -> import List; 2 -> flatten([1,2,3]) end)) ==
-           quote do: (cond do 1 -> import :"Elixir.List", []; 2 -> flatten([1,2,3]) end)
-  end
+      ast =
+        quote do
+          x = 1
+          %{%{^x => 1} => 2} = y()
+        end
 
-  test "cond: does not leaks vars on head" do
-    assert expand_and_clean(quote do: (cond do x = 1 -> x; y = 2 -> y end; :erlang.+(x, y))) ==
-           quote do: (cond do x = 1 -> x; y = 2 -> y end; :erlang.+(x(), y()))
-  end
+      assert expand(ast) == ast
 
-  test "cond: leaks vars" do
-    assert expand_and_clean(quote do: (cond do 1 -> x = 1; 2 -> y = 2 end; :erlang.+(x, y))) ==
-           quote do: (cond do 1 -> x = 1; 2 -> y = 2 end; :erlang.+(x, y))
-  end
+      ast =
+        quote do
+          x = 1
+          %{{^x} => 1} = %{{1} => 1}
+        end
 
-  ## Case
+      assert expand(ast) == ast
 
-  test "case: expands each clause" do
-    assert expand_and_clean(quote do: (case w do x -> x; _ -> x end)) ==
-           quote do: (case w() do x -> x; _ -> x() end)
-  end
+      assert_compile_error(~r"cannot use variable x as map key inside a pattern", fn ->
+        expand(quote(do: %{x => 1} = %{}))
+      end)
 
-  test "case: does not share lexical in between clauses" do
-    assert expand_and_clean(quote do: (case w do 1 -> import List; 2 -> flatten([1,2,3]) end)) ==
-           quote do: (case w() do 1 -> import :"Elixir.List", []; 2 -> flatten([1,2,3]) end)
-  end
+      assert_compile_error(~r"undefined variable \^x", fn ->
+        expand(quote(do: {x, %{^x => 1}} = %{}), [])
+      end)
+    end
 
-  test "case: expands guards" do
-    assert expand_and_clean(quote do: (case w do x when x when __ENV__.context -> true end)) ==
-           quote do: (case w() do x when x when :guard -> true end)
-  end
+    test "with binaries in keys inside patterns" do
+      before_ast =
+        quote do
+          %{<<0>> => nil} = %{<<0>> => nil}
+        end
 
-  test "case: does not leaks vars on head" do
-    assert expand_and_clean(quote do: (case w do x -> x; y -> y end; :erlang.+(x, y))) ==
-           quote do: (case w() do x -> x; y -> y end; :erlang.+(x(), y()))
-  end
+      after_ast =
+        quote do
+          %{<<0::integer>> => nil} = %{<<0::integer>> => nil}
+        end
 
-  test "case: leaks vars" do
-    assert expand_and_clean(quote do: (case w do x -> x = x; y -> y = y end; :erlang.+(x, y))) ==
-           quote do: (case w() do x -> x = x; y -> y = y end; :erlang.+(x, y))
-  end
+      assert expand(before_ast) |> clean_meta([:alignment]) == clean_bit_modifiers(after_ast)
+      assert expand(after_ast) |> clean_meta([:alignment]) == clean_bit_modifiers(after_ast)
 
-  ## Receive
+      ast =
+        quote do
+          x = 8
+          %{<<0::integer-size(x)>> => nil} = %{<<0::integer>> => nil}
+        end
 
-  test "receive: expands each clause" do
-    assert expand_and_clean(quote do: (receive do x -> x; _ -> x end)) ==
-           quote do: (receive do x -> x; _ -> x() end)
-  end
+      assert expand(ast) |> clean_meta([:alignment]) ==
+               clean_bit_modifiers(ast) |> clean_meta([:context, :imports])
 
-  test "receive: does not share lexical in between clauses" do
-    assert expand_and_clean(quote do: (receive do 1 -> import List; 2 -> flatten([1,2,3]) end)) ==
-           quote do: (receive do 1 -> import :"Elixir.List", []; 2 -> flatten([1,2,3]) end)
-  end
+      assert_compile_error(~r"cannot use variable x as map key inside a pattern", fn ->
+        expand(quote(do: %{<<x::integer>> => 1} = %{}), [])
+      end)
+    end
 
-  test "receive: expands guards" do
-    assert expand_and_clean(quote do: (receive do x when x when __ENV__.context -> true end)) ==
-           quote do: (receive do x when x when :guard -> true end)
+    test "expects key-value pairs" do
+      assert_compile_error(~r"expected key-value pairs in a map, got: :foo", fn ->
+        expand(quote(do: unquote({:%{}, [], [:foo]})))
+      end)
+    end
   end
 
-  test "receive: does not leaks clause vars" do
-    assert expand_and_clean(quote do: (receive do x -> x; y -> y end; :erlang.+(x, y))) ==
-           quote do: (receive do x -> x; y -> y end; :erlang.+(x(), y()))
+  defmodule User do
+    defstruct name: "", age: 0
   end
 
-  test "receive: leaks vars" do
-    assert expand_and_clean(quote do: (receive do x -> x = x; y -> y = y end; :erlang.+(x, y))) ==
-           quote do: (receive do x -> x = x; y -> y = y end; :erlang.+(x, y))
-  end
+  describe "structs" do
+    test "expanded as arguments" do
+      assert expand(quote(do: %User{})) ==
+               quote(do: %:"Elixir.Kernel.ExpansionTest.User"{age: 0, name: ""})
 
-  test "receive: leaks vars on after" do
-    assert expand_and_clean(quote do: (receive do x -> x = x after y -> y; w = y end; :erlang.+(x, w))) ==
-           quote do: (receive do x -> x = x after y() -> y(); w = y() end; :erlang.+(x, w))
-  end
+      assert expand(quote(do: %User{name: "john doe"})) ==
+               quote(do: %:"Elixir.Kernel.ExpansionTest.User"{age: 0, name: "john doe"})
+    end
 
-  ## Try
+    test "expects atoms" do
+      expand(quote(do: %unknown{a: 1} = x))
 
-  test "try: expands do" do
-    assert expand(quote do: (try do x = y end; x)) ==
-           quote do: (try do x = y() end; x())
-  end
+      message = ~r"expected struct name to be a compile time atom or alias"
 
-  test "try: expands catch" do
-    assert expand(quote do: (try do x catch x, y -> z = :erlang.+(x, y) end; z)) ==
-           quote do: (try do x() catch x, y -> z = :erlang.+(x, y) end; z())
-  end
+      assert_compile_error(message, fn ->
+        expand(quote(do: %unknown{a: 1}))
+      end)
 
-  test "try: expands after" do
-    assert expand(quote do: (try do x after z = y end; z)) ==
-           quote do: (try do x() after z = y() end; z())
-  end
+      message = ~r"expected struct name to be a compile time atom or alias"
 
-  test "try: expands else" do
-    assert expand(quote do: (try do x else z -> z end; z)) ==
-           quote do: (try do x() else z -> z end; z())
-  end
+      assert_compile_error(message, fn ->
+        expand(quote(do: %unquote(1){a: 1}))
+      end)
+
+      message = ~r"expected struct name in a match to be a compile time atom, alias or a variable"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: %unquote(1){a: 1} = x))
+      end)
+    end
+
+    test "update syntax" do
+      expand(quote(do: %{%{a: 0} | a: 1}))
+
+      assert_compile_error(~r"cannot use map/struct update syntax in match", fn ->
+        expand(quote(do: %{%{a: 0} | a: 1} = %{}))
+      end)
+    end
+
+    test "dynamic syntax expands to itself" do
+      assert expand(quote(do: %x{} = 1)) == quote(do: %x{} = 1)
+    end
+
+    test "invalid keys in structs" do
+      assert_compile_error(~r"invalid key :erlang\.\+\(1, 2\) for struct", fn ->
+        expand(
+          quote do
+            %User{(1 + 2) => :my_value}
+          end
+        )
+      end)
+    end
 
-  test "try: expands rescue" do
-    assert expand(quote do: (try do x rescue x -> x; Error -> x end; x)) ==
-           quote do: (try do x() rescue unquote(:in)(x, _) -> x; unquote(:in)(_, [:"Elixir.Error"]) -> x() end; x())
+    test "unknown key in structs" do
+      message = ~r"unknown key :foo for struct Kernel\.ExpansionTest\.User"
+
+      assert_compile_error(message, fn ->
+        expand(
+          quote do
+            %User{foo: :my_value} = %{}
+          end
+        )
+      end)
+    end
   end
 
-  ## Binaries
+  describe "quote" do
+    test "expanded to raw forms" do
+      assert expand(quote(do: quote(do: hello)), []) == {:{}, [], [:hello, [], __MODULE__]}
+    end
+
+    test "raises if the :bind_quoted option is invalid" do
+      assert_compile_error(~r"invalid :bind_quoted for quote", fn ->
+        expand(quote(do: quote(bind_quoted: self(), do: :ok)))
+      end)
+
+      assert_compile_error(~r"invalid :bind_quoted for quote", fn ->
+        expand(quote(do: quote(bind_quoted: [{1, 2}], do: :ok)))
+      end)
+    end
+
+    test "raises for missing do" do
+      assert_compile_error(~r"missing :do option in \"quote\"", fn ->
+        expand(quote(do: quote(context: Foo)))
+      end)
+    end
 
-  test "bitstrings: expands modifiers" do
-    assert expand(quote do: (import Kernel.ExpansionTarget; << x :: seventeen >>)) ==
-           quote do: (import :"Elixir.Kernel.ExpansionTarget", []; << x() :: [unquote(:size)(17)] >>)
+    test "raises for invalid arguments" do
+      assert_compile_error(~r"invalid arguments for \"quote\"", fn ->
+        expand(quote(do: quote(1 + 1)))
+      end)
+    end
 
-    assert expand(quote do: (import Kernel.ExpansionTarget; << seventeen :: seventeen, x :: size(seventeen) >> = 1)) ==
-           quote do: (import :"Elixir.Kernel.ExpansionTarget", [];
-                      << seventeen :: [unquote(:size)(17)], x :: [unquote(:size)(seventeen)] >> = 1)
+    test "raises unless its options are a keyword list" do
+      assert_compile_error(~r"invalid options for quote, expected a keyword list", fn ->
+        expand(quote(do: quote(:foo, do: :foo)))
+      end)
+    end
   end
 
-  test "bitstrings: expands modifiers args" do
-    assert expand(quote do: (require Kernel.ExpansionTarget; << x :: size(Kernel.ExpansionTarget.seventeen) >>)) ==
-           quote do: (require :"Elixir.Kernel.ExpansionTarget", []; << x() :: [unquote(:size)(17)] >>)
+  describe "anonymous calls" do
+    test "expands base and args" do
+      assert expand(quote(do: a.(b))) == quote(do: a().(b()))
+    end
   end
 
-  ## Invalid
+  describe "remotes" do
+    test "expands to Erlang" do
+      assert expand(quote(do: Kernel.is_atom(a))) == quote(do: :erlang.is_atom(a()))
+    end
+
+    test "expands macros" do
+      assert expand(quote(do: Kernel.ExpansionTest.thirteen())) == 13
+    end
+
+    test "expands receiver and args" do
+      assert expand(quote(do: a.is_atom(b))) == quote(do: a().is_atom(b()))
 
-  test "handles invalid expressions" do
-    assert_raise CompileError, ~r"invalid quoted expression: {1, 2, 3}", fn ->
-      expand(quote do: unquote({1, 2, 3}))
+      assert expand(quote(do: (after_expansion = :foo).is_atom(a))) ==
+               quote(do: (after_expansion = :foo).is_atom(a()))
+    end
+
+    test "modules must be required for macros" do
+      before_expansion =
+        quote do
+          require Kernel.ExpansionTarget
+          Kernel.ExpansionTarget.seventeen()
+        end
+
+      after_expansion =
+        quote do
+          :"Elixir.Kernel.ExpansionTarget"
+          17
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "in matches" do
+      message = ~r"cannot invoke remote function Hello.fun_that_does_not_exist/0 inside a match"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: Hello.fun_that_does_not_exist() = :foo))
+      end)
+
+      message = ~r"cannot invoke remote function :erlang.make_ref/0 inside a match"
+      assert_compile_error(message, fn -> expand(quote(do: make_ref() = :foo)) end)
+
+      message = ~r"invalid argument for \+\+ operator inside a match"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: "a" ++ "b" = "ab"))
+      end)
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: [1 | 2] ++ [3] = [1, 2, 3]))
+      end)
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: [1] ++ 2 ++ [3] = [1, 2, 3]))
+      end)
+
+      assert {:=, _, [-1, -1]} =
+               expand(quote(do: -1 = -1))
+
+      assert {:=, _, [1, 1]} =
+               expand(quote(do: +1 = +1))
+
+      assert {:=, _, [[{:|, _, [1, [{:|, _, [2, 3]}]]}], [1, 2, 3]]} =
+               expand(quote(do: [1] ++ [2] ++ 3 = [1, 2, 3]))
+    end
+
+    test "in guards" do
+      message =
+        ~r"cannot invoke remote function Hello.something_that_does_not_exist/1 inside a guard"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: fn arg when Hello.something_that_does_not_exist(arg) -> arg end))
+      end)
+
+      message = ~r"cannot invoke remote function :erlang.make_ref/0 inside a guard"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: fn arg when make_ref() -> arg end))
+      end)
     end
 
-    assert_raise CompileError, ~r"invalid quoted expression: #Function<", fn ->
-      expand(quote do: unquote({:sample, fn -> end}))
+    test "in guards with macros" do
+      message =
+        ~r"you must require the moduleInteger before invoking macro Integer.is_even/1 inside a guard"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: fn arg when Integer.is_even(arg) -> arg end))
+      end)
+    end
+
+    test "in guards with bitstrings" do
+      message = ~r"cannot invoke remote function String.Chars.to_string/1 inside a guard"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: fn arg when "#{arg}foo" == "argfoo" -> arg end))
+      end)
+
+      assert_compile_error(message, fn ->
+        expand(
+          quote do
+            fn arg when <<:"Elixir.Kernel".to_string(arg)::binary, "foo">> == "argfoo" ->
+              arg
+            end
+          end
+        )
+      end)
     end
   end
 
-  ## Helpers
+  describe "comprehensions" do
+    test "variables do not leak with enums" do
+      before_expansion =
+        quote do
+          for(a <- b, do: c = 1)
+          c
+        end
 
-  defmacro thirteen do
-    13
+      after_expansion =
+        quote do
+          for(a <- b(), do: c = 1)
+          c()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "variables do not leak with binaries" do
+      before_expansion =
+        quote do
+          for(<<a <- b>>, do: c = 1)
+          c
+        end
+
+      after_expansion =
+        quote do
+          for(<<(<<a::integer>> <- b())>>, do: c = 1)
+          c()
+        end
+
+      assert expand(before_expansion) |> clean_meta([:alignment]) ==
+               clean_bit_modifiers(after_expansion)
+    end
+
+    test "variables inside generator args do not leak" do
+      before_expansion =
+        quote do
+          for(
+            b <-
+              (
+                a = 1
+                [2]
+              ),
+            do: {a, b}
+          )
+
+          a
+        end
+
+      after_expansion =
+        quote do
+          for(
+            b <-
+              (
+                a = 1
+                [2]
+              ),
+            do: {a(), b}
+          )
+
+          a()
+        end
+
+      assert expand(before_expansion) == after_expansion
+
+      before_expansion =
+        quote do
+          for(
+            b <-
+              (
+                a = 1
+                [2]
+              ),
+            d <-
+              (
+                c = 3
+                [4]
+              ),
+            do: {a, b, c, d}
+          )
+        end
+
+      after_expansion =
+        quote do
+          for(
+            b <-
+              (
+                a = 1
+                [2]
+              ),
+            d <-
+              (
+                c = 3
+                [4]
+              ),
+            do: {a(), b, c(), d},
+            into: []
+          )
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "variables inside filters are available in blocks" do
+      assert expand(quote(do: for(a <- b, c = a, do: c))) ==
+               quote(do: for(a <- b(), c = a, do: c, into: []))
+    end
+
+    test "variables inside options do not leak" do
+      before_expansion =
+        quote do
+          for(a <- c = b, into: [], do: 1)
+          c
+        end
+
+      after_expansion =
+        quote do
+          for(a <- c = b(), do: 1, into: [])
+          c()
+        end
+
+      assert expand(before_expansion) == after_expansion
+
+      before_expansion =
+        quote do
+          for(a <- b, into: c = [], do: 1)
+          c
+        end
+
+      after_expansion =
+        quote do
+          for(a <- b(), do: 1, into: c = [])
+          c()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "must start with generators" do
+      assert_compile_error(~r"for comprehensions must start with a generator", fn ->
+        expand(quote(do: for(is_atom(:foo), do: :foo)))
+      end)
+
+      assert_compile_error(~r"for comprehensions must start with a generator", fn ->
+        expand(quote(do: for(do: :foo)))
+      end)
+    end
+
+    test "requires size on binary generators" do
+      message = ~r"a binary field without size is only allowed at the end of a binary pattern"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: for(<<x::binary <- "123">>, do: x)))
+      end)
+    end
+
+    test "require do option" do
+      assert_compile_error(~r"missing :do option in \"for\"", fn ->
+        expand(quote(do: for(_ <- 1..2)))
+      end)
+    end
+
+    test "uniq option is boolean" do
+      message = ~r":uniq option for comprehensions only accepts a boolean, got: x"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: for(x <- 1..2, uniq: x, do: x)))
+      end)
+    end
+
+    test "raise error on invalid reduce" do
+      assert_compile_error(
+        ~r"cannot use :reduce alongside :into/:uniq in comprehension",
+        fn ->
+          expand(quote(do: for(x <- 1..3, reduce: %{}, into: %{}, do: (acc -> acc))))
+        end
+      )
+
+      assert_compile_error(
+        ~r"the do block was written using acc -> expr clauses but the :reduce option was not given",
+        fn -> expand(quote(do: for(x <- 1..3, do: (acc -> acc)))) end
+      )
+
+      assert_compile_error(
+        ~r"when using :reduce with comprehensions, the do block must be written using acc -> expr clauses",
+        fn -> expand(quote(do: for(x <- 1..3, reduce: %{}, do: x))) end
+      )
+
+      assert_compile_error(
+        ~r"when using :reduce with comprehensions, the do block must be written using acc -> expr clauses",
+        fn -> expand(quote(do: for(x <- 1..3, reduce: %{}, do: (acc, x -> x)))) end
+      )
+
+      assert_compile_error(
+        ~r"when using :reduce with comprehensions, the do block must be written using acc -> expr clauses",
+        fn -> expand(quote(do: for(x <- 1..3, reduce: %{}, do: (acc, x when 1 == 1 -> x)))) end
+      )
+    end
+
+    test "raise error for unknown options" do
+      assert_compile_error(~r"unsupported option :else given to for", fn ->
+        expand(quote(do: for(_ <- 1..2, do: 1, else: 1)))
+      end)
+
+      assert_compile_error(~r"unsupported option :other given to for", fn ->
+        expand(quote(do: for(_ <- 1..2, do: 1, other: 1)))
+      end)
+    end
   end
 
-  defp expand_and_clean(expr) do
-    cleaner = &Keyword.drop(&1, [:export])
-    expr
-    |> expand_env(__ENV__)
-    |> elem(0)
-    |> Macro.prewalk(&Macro.update_meta(&1, cleaner))
+  describe "with" do
+    test "variables do not leak" do
+      before_expansion =
+        quote do
+          with({foo} <- {bar}, do: baz = :ok)
+          baz
+        end
+
+      after_expansion =
+        quote do
+          with({foo} <- {bar()}, do: baz = :ok)
+          baz()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "variables inside args expression do not leak" do
+      before_expansion =
+        quote do
+          with(
+            b <-
+              (
+                a = 1
+                2
+              ),
+            do: {a, b}
+          )
+
+          a
+        end
+
+      after_expansion =
+        quote do
+          with(
+            b <-
+              (
+                a = 1
+                2
+              ),
+            do: {a(), b}
+          )
+
+          a()
+        end
+
+      assert expand(before_expansion) == after_expansion
+
+      before_expansion =
+        quote do
+          with(
+            b <-
+              (
+                a = 1
+                2
+              ),
+            d <-
+              (
+                c = 3
+                4
+              ),
+            do: {a, b, c, d}
+          )
+        end
+
+      after_expansion =
+        quote do
+          with(
+            b <-
+              (
+                a = 1
+                2
+              ),
+            d <-
+              (
+                c = 3
+                4
+              ),
+            do: {a(), b, c(), d}
+          )
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "variables are available in do option" do
+      before_expansion =
+        quote do
+          with({foo} <- {bar}, do: baz = foo)
+          baz
+        end
+
+      after_expansion =
+        quote do
+          with({foo} <- {bar()}, do: baz = foo)
+          baz()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "variables inside else do not leak" do
+      before_expansion =
+        quote do
+          with({foo} <- {bar}, do: :ok, else: (baz -> baz))
+          baz
+        end
+
+      after_expansion =
+        quote do
+          with({foo} <- {bar()}, do: :ok, else: (baz -> baz))
+          baz()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "fails if \"do\" is missing" do
+      assert_compile_error(~r"missing :do option in \"with\"", fn ->
+        expand(quote(do: with(_ <- true, [])))
+      end)
+    end
+
+    test "fails on invalid else option" do
+      assert_compile_error(
+        ~r"invalid \"else\" block in \"with\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          expand(quote(do: with(_ <- true, do: :ok, else: [:error])))
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"else\" block in \"with\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          expand(quote(do: with(_ <- true, do: :ok, else: :error)))
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"else\" block in \"with\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          expand(quote(do: with(_ <- true, do: :ok, else: [])))
+        end
+      )
+    end
+
+    test "fails for invalid options" do
+      # Only the required "do" is present alongside the unexpected option.
+      assert_compile_error(~r"unexpected option :foo in \"with\"", fn ->
+        expand(quote(do: with(_ <- true, foo: :bar, do: :ok)))
+      end)
+
+      # More options are present alongside the unexpected option.
+      assert_compile_error(~r"unexpected option :foo in \"with\"", fn ->
+        expand(quote(do: with(_ <- true, do: :ok, else: (_ -> :ok), foo: :bar)))
+      end)
+
+      assert_compile_error(~r"unexpected option :foo in \"with\"", fn ->
+        expand(
+          quote do
+            with _ <- true, foo: :bar do
+              :ok
+            end
+          end
+        )
+      end)
+    end
   end
 
-  defp expand(expr) do
-    expand_env(expr, __ENV__) |> elem(0)
+  describe "&" do
+    test "keeps locals" do
+      assert expand(quote(do: &unknown/2)) == {:&, [], [{:/, [], [{:unknown, [], nil}, 2]}]}
+      assert expand(quote(do: &unknown(&1, &2))) == {:&, [], [{:/, [], [{:unknown, [], nil}, 2]}]}
+    end
+
+    test "keeps position meta on & variables" do
+      assert expand(Code.string_to_quoted!("& &1")) |> clean_meta([:counter]) ==
+               {:fn, [capture: true, line: 1],
+                [
+                  {:->, [line: 1],
+                   [
+                     [{:capture, [capture: 1, line: 1], nil}],
+                     {:capture, [capture: 1, line: 1], nil}
+                   ]}
+                ]}
+    end
+
+    test "removes no_parens when expanding 0-arity capture to fn" do
+      assert expand(quote(do: &foo().bar/0)) ==
+               quote(do: fn -> foo().bar() end)
+    end
+
+    test "expands remotes" do
+      assert expand(quote(do: &List.flatten/2)) ==
+               quote(do: &:"Elixir.List".flatten/2)
+               |> clean_meta([:imports, :context])
+
+      assert expand(quote(do: &Kernel.is_atom/1)) ==
+               quote(do: &:erlang.is_atom/1) |> clean_meta([:imports, :context])
+    end
+
+    test "expands macros" do
+      before_expansion =
+        quote do
+          require Kernel.ExpansionTarget
+          &Kernel.ExpansionTarget.seventeen/0
+        end
+
+      after_expansion =
+        quote do
+          :"Elixir.Kernel.ExpansionTarget"
+          fn -> 17 end
+        end
+
+      assert clean_meta(expand(before_expansion), [:imports, :context, :no_parens]) ==
+               after_expansion
+    end
+
+    test "fails on non-continuous" do
+      assert_compile_error(~r"capture argument &0 must be numbered between 1 and 255", fn ->
+        expand(quote(do: &foo(&0)))
+      end)
+
+      assert_compile_error(~r"capture argument &2 cannot be defined without &1", fn ->
+        expand(quote(do: & &2))
+      end)
+
+      assert_compile_error(~r"capture argument &255 cannot be defined without &1", fn ->
+        expand(quote(do: & &255))
+      end)
+    end
+
+    test "fails on block" do
+      message = ~r"block expressions are not allowed inside the capture operator &, got: 1\n2"
+
+      assert_compile_error(message, fn ->
+        code =
+          quote do
+            &(
+              1
+              2
+            )
+          end
+
+        expand(code)
+      end)
+    end
+
+    test "fails on other types" do
+      assert_compile_error(~r"invalid args for &, expected one of:", fn ->
+        expand(quote(do: &:foo))
+      end)
+    end
+
+    test "fails on invalid arity" do
+      message = ~r"capture argument &256 must be numbered between 1 and 255"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: &Mod.fun/256))
+      end)
+    end
+
+    test "fails when no captures" do
+      assert_compile_error(~r"invalid args for &, expected one of:", fn ->
+        expand(quote(do: &foo()))
+      end)
+    end
+
+    test "fails on nested capture" do
+      assert_compile_error(~r"nested captures are not allowed", fn ->
+        expand(quote(do: &(& &1)))
+      end)
+    end
+
+    test "fails on integers" do
+      assert_compile_error(
+        ~r"capture argument &1 must be used within the capture operator &",
+        fn -> expand(quote(do: &1)) end
+      )
+    end
   end
 
-  defp expand_env(expr, env) do
-    :elixir_exp.expand(expr, env)
+  describe "fn" do
+    test "expands each clause" do
+      before_expansion =
+        quote do
+          fn
+            x -> x
+            _ -> x
+          end
+        end
+
+      after_expansion =
+        quote do
+          fn
+            x -> x
+            _ -> x()
+          end
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not share lexical scope between clauses" do
+      before_expansion =
+        quote do
+          fn
+            1 -> import List
+            2 -> flatten([1, 2, 3])
+          end
+        end
+
+      after_expansion =
+        quote do
+          fn
+            1 -> :"Elixir.List"
+            2 -> flatten([1, 2, 3])
+          end
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expands guards" do
+      assert expand(quote(do: fn x when x when __ENV__.context -> true end)) ==
+               quote(do: fn x when x when :guard -> true end)
+    end
+
+    test "does not leak vars" do
+      before_expansion =
+        quote do
+          fn x -> x end
+          x
+        end
+
+      after_expansion =
+        quote do
+          fn x -> x end
+          x()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "raises on mixed arities" do
+      message = ~r"cannot mix clauses with different arities in anonymous functions"
+
+      assert_compile_error(message, fn ->
+        code =
+          quote do
+            fn
+              x -> x
+              x, y -> x + y
+            end
+          end
+
+        expand(code)
+      end)
+    end
+  end
+
+  describe "cond" do
+    test "expands each clause" do
+      before_expansion =
+        quote do
+          cond do
+            x = 1 -> x
+            true -> x
+          end
+        end
+
+      after_expansion =
+        quote do
+          cond do
+            x = 1 -> x
+            true -> x()
+          end
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not share lexical scope between clauses" do
+      before_expansion =
+        quote do
+          cond do
+            1 -> import List
+            2 -> flatten([1, 2, 3])
+          end
+        end
+
+      after_expansion =
+        quote do
+          cond do
+            1 -> :"Elixir.List"
+            2 -> flatten([1, 2, 3])
+          end
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not leaks vars on head" do
+      before_expansion =
+        quote do
+          cond do
+            x = 1 -> x
+            y = 2 -> y
+          end
+
+          :erlang.+(x, y)
+        end
+
+      after_expansion =
+        quote do
+          cond do
+            x = 1 -> x
+            y = 2 -> y
+          end
+
+          :erlang.+(x(), y())
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not leak vars" do
+      before_expansion =
+        quote do
+          cond do
+            1 -> x = 1
+            2 -> y = 2
+          end
+
+          :erlang.+(x, y)
+        end
+
+      after_expansion =
+        quote do
+          cond do
+            1 -> x = 1
+            2 -> y = 2
+          end
+
+          :erlang.+(x(), y())
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expects exactly one do" do
+      assert_compile_error(~r"missing :do option in \"cond\"", fn ->
+        expand(quote(do: cond([])))
+      end)
+
+      assert_compile_error(~r"duplicate \"do\" clauses given for \"cond\"", fn ->
+        expand(quote(do: cond(do: (x -> x), do: (y -> y))))
+      end)
+    end
+
+    test "expects clauses" do
+      assert_compile_error(
+        ~r"invalid \"do\" block in \"cond\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          expand(quote(do: cond(do: :ok)))
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"do\" block in \"cond\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          expand(quote(do: cond(do: [:not, :clauses])))
+        end
+      )
+    end
+
+    test "expects one argument in clauses" do
+      assert_compile_error(
+        ~r"expected one argument for \"do\" clauses \(->\) in \"cond\"",
+        fn ->
+          code =
+            quote do
+              cond do
+                _, _ -> :ok
+              end
+            end
+
+          expand(code)
+        end
+      )
+    end
+
+    test "raises for invalid arguments" do
+      assert_compile_error(~r"invalid arguments for \"cond\"", fn ->
+        expand(quote(do: cond(:foo)))
+      end)
+    end
+
+    test "raises with invalid options" do
+      assert_compile_error(~r"unexpected option :foo in \"cond\"", fn ->
+        expand(quote(do: cond(do: (1 -> 1), foo: :bar)))
+      end)
+    end
+
+    test "raises for _ in clauses" do
+      message = ~r"invalid use of _ inside \"cond\"\. If you want the last clause"
+
+      assert_compile_error(message, fn ->
+        code =
+          quote do
+            cond do
+              x -> x
+              _ -> :raise
+            end
+          end
+
+        expand(code)
+      end)
+    end
+  end
+
+  describe "case" do
+    test "expands each clause" do
+      before_expansion =
+        quote do
+          case w do
+            x -> x
+            _ -> x
+          end
+        end
+
+      after_expansion =
+        quote do
+          case w() do
+            x -> x
+            _ -> x()
+          end
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not share lexical scope between clauses" do
+      before_expansion =
+        quote do
+          case w do
+            1 -> import List
+            2 -> flatten([1, 2, 3])
+          end
+        end
+
+      after_expansion =
+        quote do
+          case w() do
+            1 -> :"Elixir.List"
+            2 -> flatten([1, 2, 3])
+          end
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expands guards" do
+      before_expansion =
+        quote do
+          case w do
+            x when x when __ENV__.context -> true
+          end
+        end
+
+      after_expansion =
+        quote do
+          case w() do
+            x when x when :guard -> true
+          end
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not leaks vars on head" do
+      before_expansion =
+        quote do
+          case w do
+            x -> x
+            y -> y
+          end
+
+          :erlang.+(x, y)
+        end
+
+      after_expansion =
+        quote do
+          case w() do
+            x -> x
+            y -> y
+          end
+
+          :erlang.+(x(), y())
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not leak vars" do
+      before_expansion =
+        quote do
+          case w do
+            x -> x = x
+            y -> y = y
+          end
+
+          :erlang.+(x, y)
+        end
+
+      after_expansion =
+        quote do
+          case w() do
+            x -> x = x
+            y -> y = y
+          end
+
+          :erlang.+(x(), y())
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expects exactly one do" do
+      assert_compile_error(~r"missing :do option in \"case\"", fn ->
+        expand(quote(do: case(e, [])))
+      end)
+
+      assert_compile_error(~r"duplicate \"do\" clauses given for \"case\"", fn ->
+        expand(quote(do: case(e, do: (x -> x), do: (y -> y))))
+      end)
+    end
+
+    test "expects clauses" do
+      assert_compile_error(
+        ~r"invalid \"do\" block in \"case\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              case e do
+                x
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"do\" block in \"case\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              case e do
+                [:not, :clauses]
+              end
+            end
+
+          expand(code)
+        end
+      )
+    end
+
+    test "expects exactly one argument in clauses" do
+      assert_compile_error(
+        ~r"expected one argument for \"do\" clauses \(->\) in \"case\"",
+        fn ->
+          code =
+            quote do
+              case e do
+                _, _ -> :ok
+              end
+            end
+
+          expand(code)
+        end
+      )
+    end
+
+    test "fails with invalid arguments" do
+      assert_compile_error(~r"invalid arguments for \"case\"", fn ->
+        expand(quote(do: case(:foo, :bar)))
+      end)
+    end
+
+    test "fails for invalid options" do
+      assert_compile_error(~r"unexpected option :foo in \"case\"", fn ->
+        expand(quote(do: case(e, do: (x -> x), foo: :bar)))
+      end)
+    end
+  end
+
+  describe "receive" do
+    test "expands each clause" do
+      before_expansion =
+        quote do
+          receive do
+            x -> x
+            _ -> x
+          end
+        end
+
+      after_expansion =
+        quote do
+          receive do
+            x -> x
+            _ -> x()
+          end
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not share lexical scope between clauses" do
+      before_expansion =
+        quote do
+          receive do
+            1 -> import List
+            2 -> flatten([1, 2, 3])
+          end
+        end
+
+      after_expansion =
+        quote do
+          receive do
+            1 -> :"Elixir.List"
+            2 -> flatten([1, 2, 3])
+          end
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expands guards" do
+      before_expansion =
+        quote do
+          receive do
+            x when x when __ENV__.context -> true
+          end
+        end
+
+      after_expansion =
+        quote do
+          receive do
+            x when x when :guard -> true
+          end
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not leaks clause vars" do
+      before_expansion =
+        quote do
+          receive do
+            x -> x
+            y -> y
+          end
+
+          :erlang.+(x, y)
+        end
+
+      after_expansion =
+        quote do
+          receive do
+            x -> x
+            y -> y
+          end
+
+          :erlang.+(x(), y())
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not leak vars" do
+      before_expansion =
+        quote do
+          receive do
+            x -> x = x
+            y -> y = y
+          end
+
+          :erlang.+(x, y)
+        end
+
+      after_expansion =
+        quote do
+          receive do
+            x -> x = x
+            y -> y = y
+          end
+
+          :erlang.+(x(), y())
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "does not leak vars on after" do
+      before_expansion =
+        quote do
+          receive do
+            x -> x = x
+          after
+            y ->
+              y
+              w = y
+          end
+
+          :erlang.+(x, w)
+        end
+
+      after_expansion =
+        quote do
+          receive do
+            x -> x = x
+          after
+            y() ->
+              y()
+              w = y()
+          end
+
+          :erlang.+(x(), w())
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expects exactly one do or after" do
+      assert_compile_error(~r"missing :do/:after option in \"receive\"", fn ->
+        expand(quote(do: receive([])))
+      end)
+
+      assert_compile_error(~r"duplicate \"do\" clauses given for \"receive\"", fn ->
+        expand(quote(do: receive(do: (x -> x), do: (y -> y))))
+      end)
+
+      assert_compile_error(~r"duplicate \"after\" clauses given for \"receive\"", fn ->
+        code =
+          quote do
+            receive do
+              x -> x
+            after
+              y -> y
+            after
+              z -> z
+            end
+          end
+
+        expand(code)
+      end)
+    end
+
+    test "expects clauses" do
+      assert_compile_error(
+        ~r"invalid \"do\" block in \"receive\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              receive do
+                x
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"do\" block in \"receive\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              receive do
+                [:not, :clauses]
+              end
+            end
+
+          expand(code)
+        end
+      )
+    end
+
+    test "expects on argument for do/after clauses" do
+      assert_compile_error(
+        ~r"expected one argument for \"do\" clauses \(->\) in \"receive\"",
+        fn ->
+          code =
+            quote do
+              receive do
+                _, _ -> :ok
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      message = ~r"expected one argument for \"after\" clauses \(->\) in \"receive\""
+
+      assert_compile_error(message, fn ->
+        code =
+          quote do
+            receive do
+              x -> x
+            after
+              _, _ -> :ok
+            end
+          end
+
+        expand(code)
+      end)
+    end
+
+    test "expects a single clause for \"after\"" do
+      assert_compile_error(~r"expected a single -> clause for :after in \"receive\"", fn ->
+        code =
+          quote do
+            receive do
+              x -> x
+            after
+              1 -> y
+              2 -> z
+            end
+          end
+
+        expand(code)
+      end)
+    end
+
+    test "raises for invalid arguments" do
+      assert_compile_error(~r"invalid arguments for \"receive\"", fn ->
+        expand(quote(do: receive(:foo)))
+      end)
+    end
+
+    test "raises with invalid options" do
+      assert_compile_error(~r"unexpected option :foo in \"receive\"", fn ->
+        expand(quote(do: receive(do: (x -> x), foo: :bar)))
+      end)
+    end
+  end
+
+  describe "try" do
+    test "expands catch" do
+      before_expansion =
+        quote do
+          try do
+            x
+          catch
+            x, y -> z = :erlang.+(x, y)
+          end
+
+          z
+        end
+
+      after_expansion =
+        quote do
+          try do
+            x()
+          catch
+            x, y -> z = :erlang.+(x, y)
+          end
+
+          z()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expands catch with when" do
+      before_expansion =
+        quote do
+          try do
+            x
+          catch
+            x when x -> z = :erlang.-(x)
+          end
+
+          z
+        end
+
+      after_expansion =
+        quote do
+          try do
+            x()
+          catch
+            :throw, x when x -> z = :erlang.-(x)
+          end
+
+          z()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expands after" do
+      before_expansion =
+        quote do
+          try do
+            x
+          after
+            z = y
+          end
+
+          z
+        end
+
+      after_expansion =
+        quote do
+          try do
+            x()
+          after
+            z = y()
+          end
+
+          z()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expands else" do
+      before_expansion =
+        quote do
+          try do
+            x
+          catch
+            _, _ -> :ok
+          else
+            z -> z
+          end
+
+          z
+        end
+
+      after_expansion =
+        quote do
+          try do
+            x()
+          catch
+            _, _ -> :ok
+          else
+            z -> z
+          end
+
+          z()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expands rescue" do
+      before_expansion =
+        quote do
+          try do
+            x
+          rescue
+            x -> x
+            Error -> x
+          end
+
+          x
+        end
+
+      after_expansion =
+        quote do
+          try do
+            x()
+          rescue
+            x -> x
+            unquote(:in)(_, [:"Elixir.Error"]) -> x()
+          end
+
+          x()
+        end
+
+      assert expand(before_expansion) == after_expansion
+    end
+
+    test "expects more than do" do
+      assert_compile_error(~r"missing :catch/:rescue/:after option in \"try\"", fn ->
+        code =
+          quote do
+            try do
+              x = y
+            end
+
+            x
+          end
+
+        expand(code)
+      end)
+    end
+
+    test "raises if do is missing" do
+      assert_compile_error(~r"missing :do option in \"try\"", fn ->
+        expand(quote(do: try([])))
+      end)
+    end
+
+    test "expects at most one clause" do
+      assert_compile_error(~r"duplicate \"do\" clauses given for \"try\"", fn ->
+        expand(quote(do: try(do: e, do: f)))
+      end)
+
+      assert_compile_error(~r"duplicate \"rescue\" clauses given for \"try\"", fn ->
+        code =
+          quote do
+            try do
+              e
+            rescue
+              x -> x
+            rescue
+              y -> y
+            end
+          end
+
+        expand(code)
+      end)
+
+      assert_compile_error(~r"duplicate \"after\" clauses given for \"try\"", fn ->
+        code =
+          quote do
+            try do
+              e
+            after
+              x = y
+            after
+              x = y
+            end
+          end
+
+        expand(code)
+      end)
+
+      assert_compile_error(~r"duplicate \"else\" clauses given for \"try\"", fn ->
+        code =
+          quote do
+            try do
+              e
+            else
+              x -> x
+            else
+              y -> y
+            end
+          end
+
+        expand(code)
+      end)
+
+      assert_compile_error(~r"duplicate \"catch\" clauses given for \"try\"", fn ->
+        code =
+          quote do
+            try do
+              e
+            catch
+              x -> x
+            catch
+              y -> y
+            end
+          end
+
+        expand(code)
+      end)
+    end
+
+    test "raises with invalid arguments" do
+      assert_compile_error(~r"invalid arguments for \"try\"", fn ->
+        expand(quote(do: try(:foo)))
+      end)
+    end
+
+    test "raises with invalid options" do
+      assert_compile_error(~r"unexpected option :foo in \"try\"", fn ->
+        expand(quote(do: try(do: x, foo: :bar)))
+      end)
+    end
+
+    test "expects exactly one argument in rescue clauses" do
+      assert_compile_error(
+        ~r"expected one argument for \"rescue\" clauses \(->\) in \"try\"",
+        fn ->
+          code =
+            quote do
+              try do
+                x
+              rescue
+                _, _ -> :ok
+              end
+            end
+
+          expand(code)
+        end
+      )
+    end
+
+    test "expects an alias, a variable, or \"var in [alias]\" as the argument of rescue clauses" do
+      assert_compile_error(~r"invalid \"rescue\" clause\. The clause should match", fn ->
+        code =
+          quote do
+            try do
+              x
+            rescue
+              function(:call) -> :ok
+            end
+          end
+
+        expand(code)
+      end)
+    end
+
+    test "expects one or two args for catch clauses" do
+      message = ~r"expected one or two args for \"catch\" clauses \(->\) in \"try\""
+
+      assert_compile_error(message, fn ->
+        code =
+          quote do
+            try do
+              x
+            catch
+              _, _, _ -> :ok
+            end
+          end
+
+        expand(code)
+      end)
+
+      assert_compile_error(message, fn ->
+        code =
+          quote do
+            try do
+              x
+            catch
+              _, _, _ when 1 == 1 -> :ok
+            end
+          end
+
+        expand(code)
+      end)
+    end
+
+    test "expects clauses for rescue, else, catch" do
+      assert_compile_error(
+        ~r"invalid \"rescue\" block in \"try\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              try do
+                e
+              rescue
+                x
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"rescue\" block in \"try\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              try do
+                e
+              rescue
+                [:not, :clauses]
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"rescue\" block in \"try\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              try do
+                e
+              rescue
+                []
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"catch\" block in \"try\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              try do
+                e
+              catch
+                x
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"catch\" block in \"try\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              try do
+                e
+              catch
+                [:not, :clauses]
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"catch\" block in \"try\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              try do
+                e
+              catch
+                []
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"else\" block in \"try\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              try do
+                e
+              catch
+                _ -> :ok
+              else
+                x
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"else\" block in \"try\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              try do
+                e
+              catch
+                _ -> :ok
+              else
+                [:not, :clauses]
+              end
+            end
+
+          expand(code)
+        end
+      )
+
+      assert_compile_error(
+        ~r"invalid \"else\" block in \"try\", it expects \"pattern -> expr\" clauses",
+        fn ->
+          code =
+            quote do
+              try do
+                e
+              catch
+                _ -> :ok
+              else
+                []
+              end
+            end
+
+          expand(code)
+        end
+      )
+    end
+  end
+
+  describe "bitstrings" do
+    test "parallel match" do
+      assert expand(quote(do: <<foo>> = <<bar>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<foo::integer>> = <<bar()::integer>>)
+               |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<foo>> = baz = <<bar>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<foo::integer>> = baz = <<bar()::integer>>)
+               |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<foo>> = <<bar>> = baz)) |> clean_meta([:alignment]) ==
+               quote(do: <<foo::integer>> = <<bar::integer>> = baz())
+               |> clean_bit_modifiers()
+    end
+
+    test "invalid match" do
+      assert_compile_error(
+        "a bitstring only accepts binaries, numbers, and variables inside a match",
+        fn ->
+          expand(quote(do: <<%{}>> = foo()))
+        end
+      )
+    end
+
+    test "nested match" do
+      assert expand(quote(do: <<foo = bar>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<foo = bar()::integer>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<?-, <<_, _::binary>> = rest()::binary>>))
+             |> clean_meta([:alignment]) ==
+               quote(do: <<45::integer, <<_::integer, _::binary>> = rest()::binary>>)
+               |> clean_bit_modifiers()
+    end
+
+    test "inlines binaries inside interpolation" do
+      import Kernel.ExpansionTarget
+
+      # Check expansion happens only once
+      assert expand(quote(do: "foo#{message_hello("bar")}")) |> clean_meta([:alignment]) ==
+               quote(do: <<"foo"::binary, "bar"::binary>>) |> clean_bit_modifiers()
+
+      assert_received :hello
+      refute_received :hello
+
+      # And it also works in match
+      assert expand(quote(do: "foo#{bar()}" = "foobar")) |> clean_meta([:alignment]) ==
+               quote(do: <<"foo"::binary, "bar"::binary>> = "foobar")
+               |> clean_bit_modifiers()
+    end
+
+    test "inlines binaries inside interpolation is isomorphic after manual expansion" do
+      import Kernel.ExpansionTarget
+
+      quoted = Macro.prewalk(quote(do: "foo#{bar()}" = "foobar"), &Macro.expand(&1, __ENV__))
+
+      assert expand(quoted) |> clean_meta([:alignment]) ==
+               quote(do: <<"foo"::binary, "bar"::binary>> = "foobar")
+               |> clean_bit_modifiers()
+    end
+
+    test "expands size * unit" do
+      import Kernel, except: [-: 1, -: 2]
+      import Kernel.ExpansionTarget
+
+      assert expand(quote(do: <<x::13>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer-size(13)>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::13*6>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer-unit(6)-size(13)>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::_*6-binary>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::binary-unit(6)>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::13*6-binary>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::binary-unit(6)-size(13)>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::binary-(13 * 6)-binary>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::binary-unit(6)-size(13)>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::seventeen()>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer-size(17)>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::seventeen()*2>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer-unit(2)-size(17)>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::seventeen()*seventeen()>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer-unit(17)-size(17)>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::_*seventeen()-binary>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::binary-unit(17)>>) |> clean_bit_modifiers()
+    end
+
+    test "expands binary/bitstring specifiers" do
+      import Kernel, except: [-: 1, -: 2]
+
+      assert expand(quote(do: <<x::binary>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::binary>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::bytes>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::binary>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::bitstring>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::bitstring>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::bits>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::bitstring>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::binary-little>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::binary>>) |> clean_bit_modifiers()
+
+      message = ~r"signed and unsigned specifiers are supported only on integer and float type"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<x()::binary-signed>>))
+      end)
+    end
+
+    test "expands utf* specifiers" do
+      import Kernel, except: [-: 1, -: 2]
+
+      assert expand(quote(do: <<x::utf8>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::utf8>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::utf16>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::utf16>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::utf32-little>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::utf32-little>>) |> clean_bit_modifiers()
+
+      message = ~r"signed and unsigned specifiers are supported only on integer and float type"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<x()::utf8-signed>>))
+      end)
+
+      assert_compile_error(~r"size and unit are not supported on utf types", fn ->
+        expand(quote(do: <<x()::utf8-size(32)>>))
+      end)
+    end
+
+    test "expands numbers specifiers" do
+      import Kernel, except: [-: 1, -: 2]
+
+      assert expand(quote(do: <<x::integer>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::little>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer-little>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::signed>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer-signed>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::signed-native>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer-native-signed>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x::float-signed-native>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::float-native-signed>>) |> clean_bit_modifiers()
+
+      message =
+        ~r"integer and float types require a size specifier if the unit specifier is given"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<x::unit(8)>>))
+      end)
+    end
+
+    test "expands macro specifiers" do
+      import Kernel, except: [-: 1, -: 2]
+      import Kernel.ExpansionTarget
+
+      assert expand(quote(do: <<x::seventeen()>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer-size(17)>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<seventeen::seventeen(), x::size(seventeen)>> = 1))
+             |> clean_meta([:alignment]) ==
+               quote(do: <<seventeen::integer-size(17), x::integer-size(seventeen)>> = 1)
+               |> clean_bit_modifiers()
+    end
+
+    test "expands macro in args" do
+      import Kernel, except: [-: 1, -: 2]
+
+      before_expansion =
+        quote do
+          require Kernel.ExpansionTarget
+          <<x::size(Kernel.ExpansionTarget.seventeen())>>
+        end
+
+      after_expansion =
+        quote do
+          :"Elixir.Kernel.ExpansionTarget"
+          <<x()::integer-size(17)>>
+        end
+
+      assert expand(before_expansion) |> clean_meta([:alignment]) ==
+               clean_bit_modifiers(after_expansion)
+    end
+
+    test "supports dynamic size" do
+      import Kernel, except: [-: 1, -: 2]
+
+      before_expansion =
+        quote do
+          var = 1
+          <<x::size(var)-unit(8)>>
+        end
+
+      after_expansion =
+        quote do
+          var = 1
+          <<x()::integer-unit(8)-size(var)>>
+        end
+
+      assert expand(before_expansion) |> clean_meta([:alignment]) ==
+               clean_bit_modifiers(after_expansion)
+    end
+
+    defmacro offset(size, binary) do
+      quote do
+        offset = unquote(size)
+        <<_::size(^offset)>> = unquote(binary)
+      end
+    end
+
+    test "supports size from counters" do
+      assert offset(8, <<0>>)
+    end
+
+    test "merges bitstrings" do
+      import Kernel, except: [-: 1, -: 2]
+
+      assert expand(quote(do: <<x, <<y::signed-native>>, z>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer, y()::integer-native-signed, z()::integer>>)
+               |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<x, <<y::signed-native>>::bitstring, z>>))
+             |> clean_meta([:alignment]) ==
+               quote(do: <<x()::integer, y()::integer-native-signed, z()::integer>>)
+               |> clean_bit_modifiers()
+    end
+
+    test "merges binaries" do
+      import Kernel, except: [-: 1, -: 2]
+
+      assert expand(quote(do: "foo" <> x)) |> clean_meta([:alignment]) ==
+               quote(do: <<"foo"::binary, x()::binary>>) |> clean_bit_modifiers()
+
+      assert expand(quote(do: "foo" <> <<x::size(4), y::size(4)>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<"foo"::binary, x()::integer-size(4), y()::integer-size(4)>>)
+               |> clean_bit_modifiers()
+
+      assert expand(quote(do: <<"foo", <<x::size(4), y::size(4)>>::binary>>))
+             |> clean_meta([:alignment]) ==
+               quote(do: <<"foo"::binary, x()::integer-size(4), y()::integer-size(4)>>)
+               |> clean_bit_modifiers()
+    end
+
+    test "guard expressions on size" do
+      import Kernel, except: [-: 1, -: 2, +: 1, +: 2, length: 1]
+
+      # Arithmetic operations with literals and variables are valid expressions
+      # for bitstring size in OTP 23+
+
+      before_expansion =
+        quote do
+          var = 1
+          <<x::size(var + 3)>>
+        end
+
+      after_expansion =
+        quote do
+          var = 1
+          <<x()::integer-size(:erlang.+(var, 3))>>
+        end
+
+      assert expand(before_expansion) |> clean_meta([:alignment]) ==
+               clean_bit_modifiers(after_expansion)
+
+      # Other valid guard expressions are also legal for bitstring size in OTP 23+
+
+      before_expansion = quote(do: <<x::size(length(~c"test"))>>)
+      after_expansion = quote(do: <<x()::integer-size(:erlang.length([?t, ?e, ?s, ?t]))>>)
+
+      assert expand(before_expansion) |> clean_meta([:alignment]) ==
+               clean_bit_modifiers(after_expansion)
+    end
+
+    test "map lookup on size" do
+      import Kernel, except: [-: 1, -: 2]
+
+      before_expansion =
+        quote do
+          var = %{foo: 3}
+          <<x::size(var.foo)>>
+        end
+
+      after_expansion =
+        quote do
+          var = %{foo: 3}
+          <<x()::integer-size(var.foo)>>
+        end
+
+      assert expand(before_expansion) |> clean_meta([:alignment]) ==
+               clean_bit_modifiers(after_expansion)
+    end
+
+    test "raises on unaligned binaries in match" do
+      message = ~r"its number of bits is not divisible by 8"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<rest::size(3)>> <> _ = "foo"))
+      end)
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<1::4>> <> "foo"))
+      end)
+    end
+
+    test "raises on size or unit for literal bitstrings" do
+      message = ~r"literal <<>> in bitstring supports only type specifiers"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<(<<"foo">>)::32>>))
+      end)
+    end
+
+    test "raises on size or unit for literal strings" do
+      message = ~r"literal string in bitstring supports only endianness and type specifiers"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<"foo"::32>>))
+      end)
+    end
+
+    test "16-bit floats" do
+      import Kernel, except: [-: 1, -: 2]
+
+      assert expand(quote(do: <<12.3::float-16>>)) |> clean_meta([:alignment]) ==
+               quote(do: <<12.3::float-size(16)>>) |> clean_bit_modifiers()
+    end
+
+    test "raises for invalid size * unit for floats" do
+      message = ~r"float requires size\*unit to be 16, 32, or 64 \(default\), got: 128"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<12.3::32*4>>))
+      end)
+
+      message = ~r"float requires size\*unit to be 16, 32, or 64 \(default\), got: 256"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<12.3::256>>))
+      end)
+    end
+
+    test "raises for invalid size" do
+      assert_compile_error(~r/undefined variable "foo"/, fn ->
+        code =
+          quote do
+            fn <<_::size(foo)>> -> :ok end
+          end
+
+        expand(code, [])
+      end)
+
+      assert_compile_error(~r/undefined variable "foo"/, fn ->
+        code =
+          quote do
+            fn <<_::size(foo), foo::size(8)>> -> :ok end
+          end
+
+        expand(code, [])
+      end)
+
+      assert_compile_error(~r/undefined variable "foo"/, fn ->
+        code =
+          quote do
+            fn foo, <<_::size(foo)>> -> :ok end
+          end
+
+        expand(code, [])
+      end)
+
+      assert_compile_error(~r/undefined variable "foo"/, fn ->
+        code =
+          quote do
+            fn foo, <<_::size(foo + 1)>> -> :ok end
+          end
+
+        expand(code, [])
+      end)
+
+      assert_compile_error(
+        ~r"cannot find or invoke local foo/0 inside a bitstring size specifier",
+        fn ->
+          code =
+            quote do
+              fn <<_::size(foo())>> -> :ok end
+            end
+
+          expand(code, [])
+        end
+      )
+
+      message = ~r"anonymous call is not allowed inside a bitstring size specifier"
+
+      assert_compile_error(message, fn ->
+        code =
+          quote do
+            fn <<_::size(foo.())>> -> :ok end
+          end
+
+        expand(code, [])
+      end)
+
+      message = ~r"cannot invoke remote function inside a bitstring size specifier"
+
+      assert_compile_error(message, fn ->
+        code =
+          quote do
+            foo = %{bar: true}
+            fn <<_::size(foo.bar())>> -> :ok end
+          end
+
+        expand(code, [])
+      end)
+
+      message = ~r"cannot invoke remote function Foo.bar/0 inside a bitstring size specifier"
+
+      assert_compile_error(message, fn ->
+        code =
+          quote do
+            fn <<_::size(Foo.bar())>> -> :ok end
+          end
+
+        expand(code, [])
+      end)
+    end
+
+    test "raises for variable used both in pattern and size" do
+      assert_compile_error(~r/undefined variable "foo"/, fn ->
+        code =
+          quote do
+            fn <<foo::size(foo)>> -> :ok end
+          end
+
+        expand(code, [])
+      end)
+    end
+
+    test "raises for invalid unit" do
+      message = ~r"unit in bitstring expects an integer as argument, got: :oops"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<"foo"::size(8)-unit(:oops)>>))
+      end)
+    end
+
+    test "raises for unknown specifier" do
+      assert_compile_error(~r"unknown bitstring specifier: unknown()", fn ->
+        expand(quote(do: <<1::unknown()>>))
+      end)
+    end
+
+    test "raises for conflicting specifiers" do
+      assert_compile_error(~r"conflicting endianness specification for bit field", fn ->
+        expand(quote(do: <<1::little-big>>))
+      end)
+
+      assert_compile_error(~r"conflicting unit specification for bit field", fn ->
+        expand(quote(do: <<x::bitstring-unit(2)>>))
+      end)
+    end
+
+    test "raises on binary fields with size in matches" do
+      assert expand(quote(do: <<x::binary-size(3), y::binary>> = "foobar"))
+
+      message = ~r"a binary field without size is only allowed at the end of a binary pattern"
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<x::binary, y::binary>> = "foobar"))
+      end)
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<(<<x::binary>>), y::binary>> = "foobar"))
+      end)
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<(<<x::bitstring>>), y::bitstring>> = "foobar"))
+      end)
+
+      assert_compile_error(message, fn ->
+        expand(quote(do: <<(<<x::bitstring>>)::bitstring, y::bitstring>> = "foobar"))
+      end)
+    end
+  end
+
+  describe "op ambiguity" do
+    test "raises when a call is ambiguous" do
+      # We use string_to_quoted! here to avoid the formatter adding parentheses
+      message = ~r["a -1" looks like a function call but there is a variable named "a"]
+
+      assert_compile_error(message, fn ->
+        code =
+          Code.string_to_quoted!("""
+          a = 1
+          a -1
+          """)
+
+        expand(code)
+      end)
+
+      message =
+        ~r["a -1\.\.\(a \+ 1\)" looks like a function call but there is a variable named "a"]
+
+      assert_compile_error(message, fn ->
+        code =
+          Code.string_to_quoted!("""
+          a = 1
+          a -1 .. a + 1
+          """)
+
+        expand(code)
+      end)
+    end
+  end
+
+  test "handles invalid expressions" do
+    assert_compile_error(~r"invalid quoted expression: {1, 2, 3}", fn ->
+      expand_env({1, 2, 3}, __ENV__)
+    end)
+
+    assert_compile_error(~r"invalid quoted expression: #Function\<", fn ->
+      expand({:sample, fn -> nil end})
+    end)
+
+    assert_compile_error(~r"invalid pattern in match", fn ->
+      code =
+        quote do
+          x = & &1
+
+          case true do
+            x.(false) -> true
+          end
+        end
+
+      expand(code)
+    end)
+
+    assert_compile_error(~r"anonymous call is not allowed in guards", fn ->
+      code =
+        quote do
+          x = & &1
+
+          case true do
+            true when x.(true) -> true
+          end
+        end
+
+      expand(code)
+    end)
+
+    assert_compile_error(~r"invalid call foo\(1\)\(2\)", fn ->
+      expand(quote(do: foo(1)(2)))
+    end)
+
+    assert_compile_error(~r"invalid call 1\.foo", fn ->
+      expand(quote(do: 1.foo))
+    end)
+
+    assert_compile_error(~r"invalid call 0\.foo", fn ->
+      expand(quote(do: __ENV__.line.foo))
+    end)
+
+    assert_compile_error(~r"misplaced operator ->", fn ->
+      expand(quote(do: (foo -> bar)))
+    end)
+  end
+
+  ## Helpers
+
+  defmacro thirteen do
+    13
+  end
+
+  defp assert_compile_error(message, fun) do
+    assert capture_io(:stderr, fn ->
+             assert_raise CompileError, fun
+           end) =~ message
+  end
+
+  defp clean_meta(expr, vars) do
+    cleaner = &Keyword.drop(&1, vars)
+    Macro.prewalk(expr, &Macro.update_meta(&1, cleaner))
+  end
+
+  @bitstring_modifiers [
+    :integer,
+    :float,
+    :binary,
+    :utf8,
+    :utf16,
+    :utf32,
+    :native,
+    :signed,
+    :bitstring,
+    :little
+  ]
+
+  defp clean_bit_modifiers(expr) do
+    Macro.prewalk(expr, fn
+      {expr, meta, atom} when expr in @bitstring_modifiers and is_atom(atom) ->
+        {expr, meta, nil}
+
+      other ->
+        other
+    end)
+  end
+
+  defp expand(expr, extra_meta \\ [if_undefined: :apply]) do
+    add_meta = &Keyword.merge(&1, extra_meta)
+
+    expr
+    |> Macro.postwalk(&Macro.update_meta(&1, add_meta))
+    |> expand_env(__ENV__)
+    |> elem(0)
+  end
+
+  defp expand_env(expr, env, to_clean \\ [:version, :inferred_bitstring_spec, :if_undefined]) do
+    {{expr, scope, env}, _capture} =
+      with_io(:stderr, fn ->
+        :elixir_expand.expand(expr, :elixir_env.env_to_ex(env), env)
+      end)
+
+    env = :elixir_env.to_caller({env.line, scope, env})
+    {clean_meta(expr, to_clean), env}
   end
 end
diff --git a/lib/elixir/test/elixir/kernel/fn_test.exs b/lib/elixir/test/elixir/kernel/fn_test.exs
index 5e934d4ca9d..eac16496319 100644
--- a/lib/elixir/test/elixir/kernel/fn_test.exs
+++ b/lib/elixir/test/elixir/kernel/fn_test.exs
@@ -1,47 +1,81 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.FnTest do
   use ExUnit.Case, async: true
-  import CompileAssertion
 
   test "arithmetic constants on match" do
-    assert (fn 1 + 2 -> :ok end).(3)  == :ok
-    assert (fn 1 - 2 -> :ok end).(-1) == :ok
-    assert (fn -1 -> :ok end).(-1) == :ok
-    assert (fn +1 -> :ok end).(1)  == :ok
+    assert (fn -1 -> true end).(-1)
+    assert (fn +1 -> true end).(1)
+  end
+
+  defp fun_match(x) do
+    fn
+      ^x -> true
+      _ -> false
+    end
+  end
+
+  test "pin operator on match" do
+    refute fun_match(1).(0)
+    assert fun_match(1).(1)
+    refute fun_match(1).(1.0)
+  end
+
+  test "guards with no args" do
+    fun = fn () when node() == :nonode@nohost -> true end
+    assert is_function(fun, 0)
+  end
+
+  test "case function hoisting does not affect anonymous fns" do
+    result =
+      if atom?(0) do
+        user = :defined
+        user
+      else
+        (fn ->
+           user = :undefined
+           user
+         end).()
+      end
+
+    assert result == :undefined
   end
 
   test "capture with access" do
-    assert (&(&1[:hello])).([hello: :world]) == :world
+    assert (& &1[:hello]).(hello: :world) == :world
   end
 
   test "capture remote" do
-    assert (&:erlang.atom_to_list/1).(:a) == 'a'
-    assert (&Atom.to_char_list/1).(:a) == 'a'
+    assert (&:erlang.atom_to_list/1).(:a) == ~c"a"
+    assert (&Atom.to_charlist/1).(:a) == ~c"a"
 
     assert (&List.flatten/1).([[0]]) == [0]
-    assert (&(List.flatten/1)).([[0]]) == [0]
+    assert (&List.flatten/1).([[0]]) == [0]
     assert (&List.flatten(&1)).([[0]]) == [0]
     assert (&List.flatten(&1)) == (&List.flatten/1)
   end
 
   test "capture local" do
-    assert (&atl/1).(:a) == 'a'
-    assert (&(atl/1)).(:a) == 'a'
-    assert (&atl(&1)).(:a) == 'a'
+    assert (&atl/1).(:a) == ~c"a"
+    assert (&atl/1).(:a) == ~c"a"
+    assert (&atl(&1)).(:a) == ~c"a"
   end
 
   test "capture local with question mark" do
-    assert (&is_a?/2).(:atom, :a)
-    assert (&(is_a?/2)).(:atom, :a)
-    assert (&is_a?(&1, &2)).(:atom, :a)
+    assert (&atom?/1).(:a)
+    assert (&atom?/1).(:a)
+    assert (&atom?(&1)).(:a)
   end
 
   test "capture imported" do
     assert (&is_atom/1).(:a)
-    assert (&(is_atom/1)).(:a)
+    assert (&is_atom/1).(:a)
     assert (&is_atom(&1)).(:a)
-    assert (&is_atom(&1)) == &is_atom/1
+    assert (&is_atom(&1)) == (&is_atom/1)
   end
 
   test "capture macro" do
@@ -52,26 +86,27 @@ defmodule Kernel.FnTest do
   end
 
   test "capture operator" do
-    assert is_function &+/2
-    assert is_function &(&&/2)
-    assert is_function & &1 + &2, 2
+    assert is_function(&+/2)
+    assert is_function(& &&/2)
+    assert is_function(&(&1 + &2), 2)
+    assert is_function(&and/2)
   end
 
   test "capture with variable module" do
     mod = List
     assert (&mod.flatten(&1)).([1, [2], 3]) == [1, 2, 3]
     assert (&mod.flatten/1).([1, [2], 3]) == [1, 2, 3]
-    assert (&mod.flatten/1) == &List.flatten/1
+    assert (&mod.flatten/1) == (&List.flatten/1)
   end
 
   test "local partial application" do
     assert (&atb(&1, :utf8)).(:a) == "a"
-    assert (&atb(List.to_atom(&1), :utf8)).('a') == "a"
+    assert (&atb(List.to_atom(&1), :utf8)).(~c"a") == "a"
   end
 
   test "imported partial application" do
     import Record
-    assert (&record?(&1, :sample)).({:sample, 1})
+    assert (&is_record(&1, :sample)).({:sample, 1})
   end
 
   test "remote partial application" do
@@ -88,62 +123,42 @@ defmodule Kernel.FnTest do
   end
 
   test "capture and partially apply lists" do
-    assert (&[ &1, &2 ]).(1, 2) == [ 1, 2 ]
-    assert (&[ &1, &2, &3 ]).(1, 2, 3) == [ 1, 2, 3 ]
+    assert (&[&1, &2]).(1, 2) == [1, 2]
+    assert (&[&1, &2, &3]).(1, 2, 3) == [1, 2, 3]
 
-    assert (&[ 1, &1 ]).(2) == [ 1, 2 ]
-    assert (&[ 1, &1, &2 ]).(2, 3) == [ 1, 2, 3 ]
+    assert (&[1, &1]).(2) == [1, 2]
+    assert (&[1, &1, &2]).(2, 3) == [1, 2, 3]
 
-    assert (&[&1|&2]).(1, 2) == [1|2]
+    assert (&[&1 | &2]).(1, 2) == [1 | 2]
   end
 
   test "capture and partially apply on call" do
-    assert (&(&1.module)).(__ENV__) == __MODULE__
+    assert (& &1.module).(__ENV__) == __MODULE__
   end
 
   test "capture block like" do
     assert (&(!is_atom(&1))).(:foo) == false
   end
 
-  test "capture other" do
+  test "capture with function call" do
     assert (& &1).(:ok) == :ok
 
     fun = fn a, b -> a + b end
     assert (&fun.(&1, 2)).(1) == 3
   end
 
-  test "failure on non-continuous" do
-    assert_compile_fail CompileError, "nofile:1: capture &2 cannot be defined without &1", "&(&2)"
-  end
-
-  test "failure on integers" do
-    assert_compile_fail CompileError, "nofile:1: unhandled &1 outside of a capture", "&1"
-    assert_compile_fail CompileError, "nofile:1: capture &0 is not allowed", "&foo(&0)"
-  end
-
-  test "failure on block" do
-    assert_compile_fail CompileError,
-      "nofile:1: invalid args for &, block expressions " <>
-      "are not allowed, got: (\n  1\n  2\n)",
-      "&(1;2)"
-  end
-
-  test "failure on other types" do
-    assert_compile_fail CompileError,
-      "nofile:1: invalid args for &, expected an expression in the format of &Mod.fun/arity, " <>
-      "&local/arity or a capture containing at least one argument as &1, got: :foo",
-      "&:foo"
+  defmacro c(x) do
+    quote do
+      &(unquote(x) <> &1)
+    end
   end
 
-  test "failure when no captures" do
-    assert_compile_fail CompileError,
-      "nofile:1: invalid args for &, expected an expression in the format of &Mod.fun/arity, " <>
-      "&local/arity or a capture containing at least one argument as &1, got: foo()",
-      "&foo()"
+  test "capture within capture through macro" do
+    assert (&c(&1).("b")).("a") == "ab"
   end
 
-  defp is_a?(:atom, atom) when is_atom(atom), do: true
-  defp is_a?(_, _), do: false
+  defp atom?(atom) when is_atom(atom), do: true
+  defp atom?(_), do: false
 
   defp atl(arg) do
     :erlang.atom_to_list(arg)
diff --git a/lib/elixir/test/elixir/kernel/guard_test.exs b/lib/elixir/test/elixir/kernel/guard_test.exs
new file mode 100644
index 00000000000..342d81638fa
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/guard_test.exs
@@ -0,0 +1,499 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.GuardTest do
+  use ExUnit.Case, async: true
+
+  import ExUnit.CaptureIO
+
+  describe "defguard(p) usage" do
+    defmodule GuardsInMacros do
+      defguard is_foo(atom) when atom == :foo
+
+      defmacro is_compile_time_foo(atom) when is_foo(atom) do
+        quote do: unquote(__MODULE__).is_foo(unquote(atom))
+      end
+    end
+
+    test "guards can be used in other macros in the same module" do
+      require GuardsInMacros
+      assert GuardsInMacros.is_foo(:foo)
+      refute GuardsInMacros.is_foo(:baz)
+      assert GuardsInMacros.is_compile_time_foo(:foo)
+    end
+
+    defmodule GuardsInFuns do
+      defguard is_foo(atom) when atom == :foo
+      defguard is_equal(foo, bar) when foo == bar
+
+      def foo?(atom) when is_foo(atom) do
+        is_foo(atom)
+      end
+    end
+
+    test "guards can be used in other funs in the same module" do
+      require GuardsInFuns
+      assert GuardsInFuns.is_foo(:foo)
+      refute GuardsInFuns.is_foo(:bar)
+    end
+
+    test "guards do not change code evaluation semantics" do
+      require GuardsInFuns
+      x = 1
+      assert GuardsInFuns.is_equal(x = 2, x) == false
+      assert x == 2
+    end
+
+    defmodule MacrosInGuards do
+      defmacro is_foo(atom) do
+        quote do
+          unquote(atom) == :foo
+        end
+      end
+
+      defguard is_foobar(atom) when is_foo(atom) or atom == :bar
+    end
+
+    test "macros can be used in other guards in the same module" do
+      require MacrosInGuards
+      assert MacrosInGuards.is_foobar(:foo)
+      assert MacrosInGuards.is_foobar(:bar)
+      refute MacrosInGuards.is_foobar(:baz)
+    end
+
+    defmodule UnquotedInGuardCall do
+      @value :foo
+
+      defguard unquote(String.to_atom("is_#{@value}"))(x) when x == unquote(@value)
+    end
+
+    test "guards names can be defined dynamically using unquote" do
+      require UnquotedInGuardCall
+      assert UnquotedInGuardCall.is_foo(:foo)
+      refute UnquotedInGuardCall.is_foo(:bar)
+    end
+
+    defmodule GuardsInGuards do
+      defguard is_foo(atom) when atom == :foo
+      defguard is_foobar(atom) when is_foo(atom) or atom == :bar
+    end
+
+    test "guards can be used in other guards in the same module" do
+      require GuardsInGuards
+      assert GuardsInGuards.is_foobar(:foo)
+      assert GuardsInGuards.is_foobar(:bar)
+      refute GuardsInGuards.is_foobar(:baz)
+    end
+
+    defmodule DefaultArgs do
+      defguard is_divisible(value, remainder \\ 2)
+               when is_integer(value) and rem(value, remainder) == 0
+    end
+
+    test "permits default values in args" do
+      require DefaultArgs
+      assert DefaultArgs.is_divisible(2)
+      refute DefaultArgs.is_divisible(1)
+      assert DefaultArgs.is_divisible(3, 3)
+      refute DefaultArgs.is_divisible(3, 4)
+    end
+
+    test "doesn't allow matching in args" do
+      assert_raise ArgumentError, ~r"invalid syntax in defguard", fn ->
+        defmodule Integer.Args do
+          defguard foo(value, 1) when is_integer(value)
+        end
+      end
+
+      assert_raise ArgumentError, ~r"invalid syntax in defguard", fn ->
+        defmodule String.Args do
+          defguard foo(value, "string") when is_integer(value)
+        end
+      end
+
+      assert_raise ArgumentError, ~r"invalid syntax in defguard", fn ->
+        defmodule Atom.Args do
+          defguard foo(value, :atom) when is_integer(value)
+        end
+      end
+
+      assert_raise ArgumentError, ~r"invalid syntax in defguard", fn ->
+        defmodule Tuple.Args do
+          defguard foo(value, {foo, bar}) when is_integer(value)
+        end
+      end
+    end
+
+    defmodule GuardFromMacro do
+      defmacro __using__(_) do
+        quote do
+          defguard is_even(value) when is_integer(value) and rem(value, 2) == 0
+        end
+      end
+    end
+
+    test "defguard defines a guard from inside another macro" do
+      defmodule UseGuardFromMacro do
+        use GuardFromMacro
+
+        def assert! do
+          assert is_even(0)
+          refute is_even(1)
+        end
+      end
+
+      UseGuardFromMacro.assert!()
+    end
+
+    defmodule IntegerPrivateGuards do
+      defguardp is_even(value) when is_integer(value) and rem(value, 2) == 0
+
+      def even_and_large?(value) when is_even(value) and value > 100, do: true
+      def even_and_large?(_), do: false
+
+      def even_and_small?(value) do
+        if is_even(value) and value <= 100, do: true, else: false
+      end
+    end
+
+    test "defguardp defines private guards that work inside and outside guard clauses" do
+      assert IntegerPrivateGuards.even_and_large?(102)
+      refute IntegerPrivateGuards.even_and_large?(98)
+      refute IntegerPrivateGuards.even_and_large?(99)
+      refute IntegerPrivateGuards.even_and_large?(103)
+
+      assert IntegerPrivateGuards.even_and_small?(98)
+      refute IntegerPrivateGuards.even_and_small?(99)
+      refute IntegerPrivateGuards.even_and_small?(102)
+      refute IntegerPrivateGuards.even_and_small?(103)
+
+      assert_compile_error(~r"cannot find or invoke local is_even/1", fn ->
+        defmodule IntegerPrivateGuardUtils do
+          import IntegerPrivateGuards
+
+          def even_and_large?(value) when is_even(value) and value > 100, do: true
+          def even_and_large?(_), do: false
+        end
+      end)
+
+      assert_compile_error(~r"undefined function is_even/1", fn ->
+        defmodule IntegerPrivateFunctionUtils do
+          import IntegerPrivateGuards
+
+          def even_and_small?(value) do
+            if is_even(value) and value <= 100, do: true, else: false
+          end
+        end
+      end)
+    end
+
+    test "requires a proper macro name" do
+      assert_raise ArgumentError, ~r"invalid syntax in defguard", fn ->
+        defmodule(LiteralUsage, do: defguard("literal is bad"))
+      end
+
+      assert_raise ArgumentError, ~r"invalid syntax in defguard", fn ->
+        defmodule(RemoteUsage, do: defguard(Remote.call(is_bad)))
+      end
+    end
+
+    test "handles overriding appropriately" do
+      assert_compile_error(~r"defmacro (.*?) already defined as def", fn ->
+        defmodule OverriddenFunUsage do
+          def foo(bar), do: bar
+          defguard foo(bar) when bar
+        end
+      end)
+
+      assert_compile_error(~r"defmacro (.*?) already defined as defp", fn ->
+        defmodule OverriddenPrivateFunUsage do
+          defp foo(bar), do: bar
+          defguard foo(bar) when bar
+        end
+      end)
+
+      assert_compile_error(~r"defmacro (.*?) already defined as defmacrop", fn ->
+        defmodule OverriddenPrivateFunUsage do
+          defmacrop foo(bar), do: bar
+          defguard foo(bar) when bar
+        end
+      end)
+
+      assert_compile_error(~r"defmacrop (.*?) already defined as def", fn ->
+        defmodule OverriddenFunUsage do
+          def foo(bar), do: bar
+          defguardp foo(bar) when bar
+        end
+      end)
+
+      assert_compile_error(~r"defmacrop (.*?) already defined as defp", fn ->
+        defmodule OverriddenPrivateFunUsage do
+          defp foo(bar), do: bar
+          defguardp foo(bar) when bar
+        end
+      end)
+
+      assert_compile_error(~r"defmacrop (.*?) already defined as defmacro", fn ->
+        defmodule OverriddenPrivateFunUsage do
+          defmacro foo(bar), do: bar
+          defguardp foo(bar) when bar
+        end
+      end)
+    end
+
+    test "does not allow multiple guard clauses" do
+      assert_raise ArgumentError, ~r"invalid syntax in defguard", fn ->
+        defmodule MultiGuardUsage do
+          defguardp foo(bar, baz) when bar == 1 when baz == 2
+        end
+      end
+    end
+
+    test "does not accept a block" do
+      assert_compile_error(~r"undefined function defguard/2", fn ->
+        defmodule OnelinerBlockUsage do
+          defguard(foo(bar), do: one_liner)
+        end
+      end)
+
+      assert_compile_error(~r"undefined function defguard/2", fn ->
+        defmodule MultilineBlockUsage do
+          defguard foo(bar) do
+            multi
+            liner
+          end
+        end
+      end)
+
+      assert_compile_error(~r"undefined function defguard/2", fn ->
+        defmodule ImplAndBlockUsage do
+          defguard(foo(bar) when both_given, do: error)
+        end
+      end)
+    end
+  end
+
+  describe "defguard(p) compilation" do
+    test "refuses to compile nonsensical code" do
+      assert_compile_error("cannot find or invoke local undefined/1", fn ->
+        defmodule UndefinedUsage do
+          defguard foo(function) when undefined(function)
+        end
+      end)
+    end
+
+    test "fails on expressions not allowed in guards" do
+      # Slightly unique errors
+
+      assert_raise ArgumentError, ~r{invalid right argument for operator "in"}, fn ->
+        defmodule RuntimeListUsage do
+          defguard foo(bar, baz) when bar in baz
+        end
+      end
+
+      assert_compile_error("cannot invoke remote function", fn ->
+        defmodule BadErlangFunctionUsage do
+          defguard foo(bar) when :erlang.binary_to_atom("foo")
+        end
+      end)
+
+      assert_compile_error("cannot invoke remote function", fn ->
+        defmodule SendUsage do
+          defguard foo(bar) when send(self(), :baz)
+        end
+      end)
+
+      # Consistent errors
+
+      assert_raise ArgumentError, ~r"invalid expression in guard, ! is not allowed", fn ->
+        defmodule SoftNegationLogicUsage do
+          defguard foo(logic) when !logic
+        end
+      end
+
+      assert_raise ArgumentError, ~r"invalid expression in guard, && is not allowed", fn ->
+        defmodule SoftAndLogicUsage do
+          defguard foo(soft, logic) when soft && logic
+        end
+      end
+
+      assert_raise ArgumentError, ~r"invalid expression in guard, || is not allowed", fn ->
+        defmodule SoftOrLogicUsage do
+          defguard foo(soft, logic) when soft || logic
+        end
+      end
+
+      assert_compile_error(
+        "cannot invoke remote function :erlang\.is_record/2 inside a guard",
+        fn ->
+          defmodule IsRecord2Usage do
+            defguard foo(rec) when :erlang.is_record(rec, :tag)
+          end
+        end
+      )
+
+      assert_compile_error(
+        "cannot invoke remote function :erlang\.is_record/3 inside a guard",
+        fn ->
+          defmodule IsRecord3Usage do
+            defguard foo(rec) when :erlang.is_record(rec, :tag, 7)
+          end
+        end
+      )
+
+      assert_compile_error(
+        ~r"cannot invoke remote function :erlang\.\+\+/2 inside a guard",
+        fn ->
+          defmodule ListSubtractionUsage do
+            defguard foo(list) when list ++ []
+          end
+        end
+      )
+
+      assert_compile_error(
+        "cannot invoke remote function :erlang\.\-\-/2 inside a guard",
+        fn ->
+          defmodule ListSubtractionUsage do
+            defguard foo(list) when list -- []
+          end
+        end
+      )
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule LocalCallUsage do
+          defguard foo(local, call) when local.(call)
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule ComprehensionUsage do
+          defguard foo(bar) when for(x <- [1, 2, 3], do: x * bar)
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule AliasUsage do
+          defguard foo(bar) when alias(bar)
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule ImportUsage do
+          defguard foo(bar) when import(bar)
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule RequireUsage do
+          defguard foo(bar) when require(bar)
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule SuperUsage do
+          defguard foo(bar) when super(bar)
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule SpawnUsage do
+          defguard foo(bar) when spawn(& &1)
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule ReceiveUsage do
+          defguard foo(bar) when receive(do: (baz -> baz))
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule CaseUsage do
+          defguard foo(bar) when case(bar, do: (baz -> :baz))
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule CondUsage do
+          defguard foo(bar) when cond(do: (bar -> :baz))
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule TryUsage do
+          defguard foo(bar) when try(do: (baz -> baz))
+        end
+      end)
+
+      assert_compile_error("invalid expression in guard", fn ->
+        defmodule WithUsage do
+          defguard foo(bar) when with(do: (baz -> baz))
+        end
+      end)
+
+      assert_compile_error(
+        "cannot invoke remote function inside a guard. " <>
+          "If you want to do a map lookup instead, please remove parens from map.field()",
+        fn ->
+          defmodule MapDot do
+            def map_dot(map) when map.field(), do: true
+          end
+        end
+      )
+
+      assert_compile_error("cannot invoke remote function Module.fun/0 inside a guard", fn ->
+        defmodule MapDot do
+          def map_dot(map) when Module.fun(), do: true
+        end
+      end)
+    end
+  end
+
+  describe "defguard(p) expansion" do
+    defguard with_unused_vars(foo, bar, _baz) when foo + bar
+
+    test "doesn't obscure unused variables" do
+      args = quote(do: [1 + 1, 2 + 2, 3 + 3])
+
+      assert expand_defguard_to_string(:with_unused_vars, args, :guard) == """
+             :erlang.+(1 + 1, 2 + 2)
+             """
+
+      assert expand_defguard_to_string(:with_unused_vars, args, nil) == """
+             {arg1, arg2} = {1 + 1, 2 + 2}
+             :erlang.+(arg1, arg2)
+             """
+    end
+
+    defguard with_reused_vars(foo, bar, baz) when foo + foo + bar + baz
+
+    test "handles re-used variables" do
+      args = quote(do: [1 + 1, 2 + 2, 3 + 3])
+
+      assert expand_defguard_to_string(:with_reused_vars, args, :guard) == """
+             :erlang.+(:erlang.+(:erlang.+(1 + 1, 1 + 1), 2 + 2), 3 + 3)
+             """
+
+      assert expand_defguard_to_string(:with_reused_vars, args, nil) == """
+             {arg1, arg2, arg3} = {1 + 1, 2 + 2, 3 + 3}
+             :erlang.+(:erlang.+(:erlang.+(arg1, arg1), arg2), arg3)
+             """
+    end
+
+    defp expand_defguard_to_string(fun, args, context) do
+      {{:., [], [__MODULE__, fun]}, [], args}
+      |> Macro.expand(%{__ENV__ | context: context})
+      |> Macro.to_string()
+      |> Kernel.<>("\n")
+    end
+  end
+
+  defp assert_compile_error(message, fun) do
+    assert capture_io(:stderr, fn ->
+             assert_raise CompileError, fun
+           end) =~ message
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/impl_test.exs b/lib/elixir/test/elixir/kernel/impl_test.exs
new file mode 100644
index 00000000000..95a0b2e837d
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/impl_test.exs
@@ -0,0 +1,628 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.ImplTest do
+  use ExUnit.Case, async: true
+
+  defp capture_err(fun) do
+    ExUnit.CaptureIO.capture_io(:stderr, fun)
+  end
+
+  defp purge(module) do
+    :code.purge(module)
+    :code.delete(module)
+  end
+
+  setup do
+    on_exit(fn -> purge(Kernel.ImplTest.ImplAttributes) end)
+  end
+
+  defprotocol AProtocol do
+    def foo(term)
+    def bar(term)
+  end
+
+  defmodule Behaviour do
+    @callback foo() :: any
+  end
+
+  defmodule BehaviourWithArgument do
+    @callback foo(any) :: any
+  end
+
+  defmodule BehaviourWithThreeArguments do
+    @callback foo(any, any, any) :: any
+  end
+
+  defmodule UseBehaviourWithoutImpl do
+    @callback foo_without_impl() :: any
+    @callback bar_without_impl() :: any
+    @callback baz_without_impl() :: any
+
+    defmacro __using__(_opts) do
+      quote do
+        @behaviour Kernel.ImplTest.UseBehaviourWithoutImpl
+        def foo_without_impl(), do: :auto_generated
+      end
+    end
+  end
+
+  defmodule UseBehaviourWithImpl do
+    @callback foo_with_impl() :: any
+    @callback bar_with_impl() :: any
+    @callback baz_with_impl() :: any
+
+    defmacro __using__(_opts) do
+      quote do
+        @behaviour Kernel.ImplTest.UseBehaviourWithImpl
+        @impl true
+        def foo_with_impl(), do: :auto_generated
+        def bar_with_impl(), do: :auto_generated
+      end
+    end
+  end
+
+  defmodule MacroBehaviour do
+    @macrocallback bar :: any
+  end
+
+  defmodule ManualBehaviour do
+    def behaviour_info(:callbacks), do: [foo: 0]
+    def behaviour_info(:optional_callbacks), do: :undefined
+  end
+
+  test "sets @impl to boolean" do
+    defmodule ImplAttributes do
+      @behaviour Behaviour
+
+      @impl true
+      def foo(), do: :ok
+
+      @impl false
+      def foo(term) do
+        term
+      end
+    end
+  end
+
+  test "sets @impl to nil" do
+    assert_raise ArgumentError, ~r/should be a module or a boolean/, fn ->
+      defmodule ImplAttributes do
+        @behaviour Behaviour
+        @impl nil
+        def foo(), do: :ok
+      end
+    end
+  end
+
+  test "sets @impl to behaviour" do
+    defmodule ImplAttributes do
+      @behaviour Behaviour
+      @impl Behaviour
+      def foo(), do: :ok
+    end
+  end
+
+  test "does not set @impl" do
+    defmodule ImplAttributes do
+      @behaviour Behaviour
+      def foo(), do: :ok
+    end
+  end
+
+  test "sets @impl to boolean on manual behaviour" do
+    defmodule ImplAttributes do
+      @behaviour ManualBehaviour
+
+      @impl true
+      def foo(), do: :ok
+    end
+  end
+
+  test "warns of undefined module, but does not warn at @impl line" do
+    capture_err =
+      capture_err(fn ->
+        Code.eval_string("""
+        defmodule Kernel.ImplTest.ImplAttributes do
+          @behaviour Abc
+
+          @impl Abc
+          def foo(), do: :ok
+        end
+        """)
+      end)
+
+    assert capture_err =~
+             "@behaviour Abc does not exist (in module Kernel.ImplTest.ImplAttributes)"
+
+    refute capture_err =~
+             "got \"@impl Abc\""
+  end
+
+  test "warns of undefined behaviour, but does not warn at @impl line" do
+    capture_err =
+      capture_err(fn ->
+        Code.eval_string("""
+        defmodule Kernel.ImplTest.ImplAttributes do
+          @behaviour Enum
+
+          @impl Enum
+          def foo(), do: :ok
+        end
+        """)
+      end)
+
+    assert capture_err =~
+             "module Enum is not a behaviour (in module Kernel.ImplTest.ImplAttributes)"
+
+    refute capture_err =~
+             "got \"@impl Abc\""
+  end
+
+  test "warns of callbacks without impl and @impl has been set before" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @behaviour Kernel.ImplTest.MacroBehaviour
+
+               @impl true
+               def foo(), do: :ok
+
+               defmacro bar(), do: :ok
+             end
+             """)
+           end) =~
+             "module attribute @impl was not set for macro bar/0 callback (specified in Kernel.ImplTest.MacroBehaviour)"
+  end
+
+  test "warns of callbacks without impl and @impl has been set after" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @behaviour Kernel.ImplTest.MacroBehaviour
+
+               defmacro bar(), do: :ok
+
+               @impl true
+               def foo(), do: :ok
+             end
+             """)
+           end) =~
+             "module attribute @impl was not set for macro bar/0 callback (specified in Kernel.ImplTest.MacroBehaviour)"
+  end
+
+  test "warns when @impl is set on private function" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @impl true
+               defp foo(), do: :ok
+             end
+             """)
+           end) =~
+             "function foo/0 is private, @impl attribute is always discarded for private functions/macros"
+  end
+
+  test "warns when @impl is set and no function" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @impl true
+             end
+             """)
+           end) =~ "module attribute @impl was set but no definition follows it"
+  end
+
+  test "warns of @impl true and no behaviour" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @impl true
+               def foo(), do: :ok
+             end
+             """)
+           end) =~ "got \"@impl true\" for function foo/0 but no behaviour was declared"
+  end
+
+  test "warns of @impl true with callback name not in behaviour" do
+    message =
+      capture_err(fn ->
+        Code.eval_string("""
+        defmodule Kernel.ImplTest.ImplAttributes do
+          @behaviour Kernel.ImplTest.Behaviour
+          @impl true
+          def bar(), do: :ok
+        end
+        """)
+      end)
+
+    assert message =~
+             "got \"@impl true\" for function bar/0 but no behaviour specifies such callback"
+
+    assert message =~ "The known callbacks are"
+    assert message =~ "* Kernel.ImplTest.Behaviour.foo/0 (function)"
+  end
+
+  test "warns of @impl true with macro callback name not in behaviour" do
+    message =
+      capture_err(fn ->
+        Code.eval_string("""
+        defmodule Kernel.ImplTest.ImplAttributes do
+          @behaviour Kernel.ImplTest.MacroBehaviour
+          @impl true
+          defmacro foo(), do: :ok
+        end
+        """)
+      end)
+
+    assert message =~
+             "got \"@impl true\" for macro foo/0 but no behaviour specifies such callback"
+
+    assert message =~ "The known callbacks are"
+    assert message =~ "* Kernel.ImplTest.MacroBehaviour.bar/0 (macro)"
+  end
+
+  test "warns of @impl true with callback kind not in behaviour" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.MacroBehaviour
+               @impl true
+               def foo(), do: :ok
+             end
+             """)
+           end) =~
+             "got \"@impl true\" for function foo/0 but no behaviour specifies such callback"
+  end
+
+  test "warns of @impl true with wrong arity" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @impl true
+               def foo(arg), do: arg
+             end
+             """)
+           end) =~
+             "got \"@impl true\" for function foo/1 but no behaviour specifies such callback"
+  end
+
+  test "warns of @impl false and there are no callbacks" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @impl false
+               def baz(term), do: term
+             end
+             """)
+           end) =~ "got \"@impl false\" for function baz/1 but no behaviour was declared"
+  end
+
+  test "warns of @impl false and it is a callback" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @impl false
+               def foo(), do: :ok
+             end
+             """)
+           end) =~
+             "got \"@impl false\" for function foo/0 but it is a callback specified in Kernel.ImplTest.Behaviour"
+  end
+
+  test "warns of @impl module and no behaviour" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @impl Kernel.ImplTest.Behaviour
+               def foo(), do: :ok
+             end
+             """)
+           end) =~
+             "got \"@impl Kernel.ImplTest.Behaviour\" for function foo/0 but no behaviour was declared"
+  end
+
+  test "warns of @impl module with callback name not in behaviour" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @impl Kernel.ImplTest.Behaviour
+               def bar(), do: :ok
+             end
+             """)
+           end) =~
+             "got \"@impl Kernel.ImplTest.Behaviour\" for function bar/0 but Kernel.ImplTest.Behaviour does not specify such callback"
+  end
+
+  test "warns of @impl module with macro callback name not in behaviour" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.MacroBehaviour
+               @impl Kernel.ImplTest.MacroBehaviour
+               defmacro foo(), do: :ok
+             end
+             """)
+           end) =~
+             "got \"@impl Kernel.ImplTest.MacroBehaviour\" for macro foo/0 but Kernel.ImplTest.MacroBehaviour does not specify such callback"
+  end
+
+  test "warns of @impl module with macro callback kind not in behaviour" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.MacroBehaviour
+               @impl Kernel.ImplTest.MacroBehaviour
+               def foo(), do: :ok
+             end
+             """)
+           end) =~
+             "got \"@impl Kernel.ImplTest.MacroBehaviour\" for function foo/0 but Kernel.ImplTest.MacroBehaviour does not specify such callback"
+  end
+
+  test "warns of @impl module and callback belongs to another known module" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @behaviour Kernel.ImplTest.MacroBehaviour
+               @impl Kernel.ImplTest.Behaviour
+               def bar(), do: :ok
+             end
+             """)
+           end) =~
+             "got \"@impl Kernel.ImplTest.Behaviour\" for function bar/0 but Kernel.ImplTest.Behaviour does not specify such callback"
+  end
+
+  test "warns of @impl module and callback belongs to another unknown module" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @impl Kernel.ImplTest.MacroBehaviour
+               def bar(), do: :ok
+             end
+             """)
+           end) =~
+             "got \"@impl Kernel.ImplTest.MacroBehaviour\" for function bar/0 but this behaviour was not declared with @behaviour"
+  end
+
+  test "does not warn of @impl when the function with default conforms with several typespecs" do
+    Code.eval_string(~S"""
+    defmodule Kernel.ImplTest.ImplAttributes do
+      @behaviour Kernel.ImplTest.Behaviour
+      @behaviour Kernel.ImplTest.BehaviourWithArgument
+
+      @impl true
+      def foo(args \\ []), do: args
+    end
+    """)
+  end
+
+  test "does not warn of @impl when the function conforms to behaviour but has default value for arg" do
+    Code.eval_string(~S"""
+    defmodule Kernel.ImplTest.ImplAttributes do
+      @behaviour Kernel.ImplTest.BehaviourWithArgument
+
+      @impl true
+      def foo(args \\ []), do: args
+    end
+    """)
+  end
+
+  test "does not warn of @impl when the function conforms to behaviour but has additional trailing default args" do
+    Code.eval_string(~S"""
+    defmodule Kernel.ImplTest.ImplAttributes do
+      @behaviour Kernel.ImplTest.BehaviourWithArgument
+
+      @impl true
+      def foo(arg_1, _args \\ []), do: arg_1
+    end
+    """)
+  end
+
+  test "does not warn of @impl when the function conforms to behaviour but has additional leading default args" do
+    Code.eval_string(~S"""
+    defmodule Kernel.ImplTest.ImplAttributes do
+      @behaviour Kernel.ImplTest.BehaviourWithArgument
+
+      @impl true
+      def foo(_defaulted_arg \\ [], args), do: args
+    end
+    """)
+  end
+
+  test "does not warn of @impl when the function has more args than callback, but they're all defaulted" do
+    Code.eval_string(~S"""
+    defmodule Kernel.ImplTest.ImplAttributes do
+      @behaviour Kernel.ImplTest.BehaviourWithArgument
+
+      @impl true
+      def foo(args \\ [], _bar \\ []), do: args
+    end
+    """)
+  end
+
+  test "does not warn of @impl with defaults when the same function is defined multiple times" do
+    Code.eval_string(~S"""
+    defmodule Kernel.ImplTest.ImplAttributes do
+      @behaviour Kernel.ImplTest.BehaviourWithArgument
+      @behaviour Kernel.ImplTest.BehaviourWithThreeArguments
+
+      @impl Kernel.ImplTest.BehaviourWithArgument
+      def foo(_foo \\ [], _bar \\ []), do: :ok
+
+      @impl Kernel.ImplTest.BehaviourWithThreeArguments
+      def foo(_foo, _bar, _baz, _qux \\ []), do: :ok
+    end
+    """)
+  end
+
+  test "does not warn of no @impl when overriding callback" do
+    Code.eval_string(~S"""
+    defmodule Kernel.ImplTest.ImplAttributes do
+      @behaviour Kernel.ImplTest.Behaviour
+
+      def foo(), do: :overridable
+
+      defoverridable Kernel.ImplTest.Behaviour
+
+      def foo(), do: :overridden
+    end
+    """)
+  end
+
+  test "does not warn of overridable function missing @impl" do
+    Code.eval_string(~S"""
+    defmodule Kernel.ImplTest.ImplAttributes do
+      @behaviour Kernel.ImplTest.Behaviour
+
+      def foo(), do: :overridable
+
+      defoverridable Kernel.ImplTest.Behaviour
+
+      @impl Kernel.ImplTest.Behaviour
+      def foo(), do: :overridden
+    end
+    """)
+  end
+
+  test "warns correctly of missing @impl only for end-user implemented function" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @behaviour Kernel.ImplTest.MacroBehaviour
+
+               def foo(), do: :overridable
+
+               defoverridable Kernel.ImplTest.Behaviour
+
+               def foo(), do: :overridden
+
+               @impl true
+               defmacro bar(), do: :overridden
+             end
+             """)
+           end) =~
+             "module attribute @impl was not set for function foo/0 callback (specified in Kernel.ImplTest.Behaviour)"
+  end
+
+  test "warns correctly of incorrect @impl in overridable callback" do
+    assert capture_err(fn ->
+             Code.eval_string("""
+             defmodule Kernel.ImplTest.ImplAttributes do
+               @behaviour Kernel.ImplTest.Behaviour
+               @behaviour Kernel.ImplTest.MacroBehaviour
+
+               @impl Kernel.ImplTest.MacroBehaviour
+               def foo(), do: :overridable
+
+               defoverridable Kernel.ImplTest.Behaviour
+
+               @impl Kernel.ImplTest.Behaviour
+               def foo(), do: :overridden
+             end
+             """)
+           end) =~
+             "got \"@impl Kernel.ImplTest.MacroBehaviour\" for function foo/0 but Kernel.ImplTest.MacroBehaviour does not specify such callback"
+  end
+
+  test "warns only of non-generated functions in non-generated @impl" do
+    message =
+      capture_err(fn ->
+        Code.eval_string("""
+        defmodule Kernel.ImplTest.ImplAttributes do
+          @behaviour Kernel.ImplTest.Behaviour
+          use Kernel.ImplTest.UseBehaviourWithoutImpl
+
+          @impl true
+          def bar_without_impl(), do: :overridden
+          def baz_without_impl(), do: :overridden
+
+          defdelegate foo(), to: __MODULE__, as: :baz
+          def baz(), do: :ok
+        end
+        """)
+      end)
+
+    assert message =~
+             "module attribute @impl was not set for function baz_without_impl/0 callback"
+
+    assert message =~
+             "module attribute @impl was not set for function foo/0 callback"
+
+    refute message =~ "foo_without_impl/0"
+  end
+
+  test "warns only of non-generated functions in non-generated @impl in protocols" do
+    message =
+      capture_err(fn ->
+        Code.eval_string("""
+        defimpl  Kernel.ImplTest.AProtocol, for: List do
+          @impl true
+          def foo(_list), do: :ok
+
+          defdelegate bar(list), to: __MODULE__, as: :baz
+          def baz(_list), do: :ok
+        end
+        """)
+      end)
+
+    assert message =~
+             "module attribute @impl was not set for function bar/1 callback"
+  end
+
+  test "warns only of generated functions in generated @impl" do
+    message =
+      capture_err(fn ->
+        Code.eval_string("""
+        defmodule Kernel.ImplTest.ImplAttributes do
+          use Kernel.ImplTest.UseBehaviourWithImpl
+          def baz_with_impl(), do: :overridden
+        end
+        """)
+      end)
+
+    assert message =~ "module attribute @impl was not set for function bar_with_impl/0 callback"
+    refute message =~ "foo_with_impl/0"
+  end
+
+  test "does not warn of overridable callback when using __before_compile__/1 hook" do
+    Code.eval_string(~S"""
+    defmodule BeforeCompile do
+      defmacro __before_compile__(_) do
+        quote do
+          @behaviour Kernel.ImplTest.Behaviour
+
+          def foo(), do: :overridable
+
+          defoverridable Kernel.ImplTest.Behaviour
+        end
+      end
+    end
+
+    defmodule Kernel.ImplTest.ImplAttributes do
+      @before_compile BeforeCompile
+      @behaviour Kernel.ImplTest.MacroBehaviour
+
+      defmacro bar(), do: :overridable
+
+      defoverridable Kernel.ImplTest.MacroBehaviour
+
+      @impl Kernel.ImplTest.MacroBehaviour
+      defmacro bar(), do: :overridden
+    end
+    """)
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/import_test.exs b/lib/elixir/test/elixir/kernel/import_test.exs
index 2b107cdd83f..900d069f193 100644
--- a/lib/elixir/test/elixir/kernel/import_test.exs
+++ b/lib/elixir/test/elixir/kernel/import_test.exs
@@ -1,16 +1,41 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.ImportTest do
   use ExUnit.Case, async: true
 
+  # This should not warn due to the empty only
+  import URI, only: []
+
   defmodule ImportAvailable do
     defmacro flatten do
       [flatten: 1]
     end
   end
 
+  test "multi-call" do
+    assert [List, String] = import(Elixir.{List, unquote(:String)})
+    assert keymember?([a: 1], :a, 0)
+    assert valid?("ø")
+  end
+
+  test "blank multi-call" do
+    assert [] = import(List.{})
+    # Buggy local duplicate is untouched
+    assert duplicate([1], 2) == [1]
+  end
+
+  test "multi-call with options" do
+    assert [List] = import(Elixir.{List}, only: [])
+    # Buggy local duplicate is untouched
+    assert duplicate([1], 2) == [1]
+  end
+
   test "import all" do
-    import :lists
+    assert :lists = import(:lists)
     assert flatten([1, [2], 3]) == [1, 2, 3]
   end
 
@@ -20,13 +45,15 @@ defmodule Kernel.ImportTest do
   end
 
   test "import except one" do
-    import :lists, except: [each: 2]
+    import :lists, except: [duplicate: 2]
     assert flatten([1, [2], 3]) == [1, 2, 3]
+    # Buggy local duplicate is untouched
+    assert duplicate([1], 2) == [1]
   end
 
   test "import only via macro" do
     require ImportAvailable
-    import :lists, only: ImportAvailable.flatten
+    import :lists, only: ImportAvailable.flatten()
     assert flatten([1, [2], 3]) == [1, 2, 3]
   end
 
@@ -35,7 +62,7 @@ defmodule Kernel.ImportTest do
   end
 
   test "import with options via macro" do
-    import :lists, dynamic_opts
+    import :lists, dynamic_opts()
     assert flatten([1, [2], 3]) == [1, 2, 3]
   end
 
@@ -47,8 +74,24 @@ defmodule Kernel.ImportTest do
     assert duplicate([1], 2) == [1]
   end
 
+  test "import except none respects previous import with except" do
+    import :lists, except: [duplicate: 2]
+    import :lists, except: []
+    assert append([1], [2, 3]) == [1, 2, 3]
+    # Buggy local duplicate is untouched
+    assert duplicate([1], 2) == [1]
+  end
+
+  test "import except none respects previous import with only" do
+    import :lists, only: [append: 2]
+    import :lists, except: []
+    assert append([1], [2, 3]) == [1, 2, 3]
+    # Buggy local duplicate is untouched
+    assert duplicate([1], 2) == [1]
+  end
+
   defmodule Underscored do
-    def hello(x),          do: x
+    def hello(x), do: x
     def __underscore__(x), do: x
   end
 
@@ -61,7 +104,7 @@ defmodule Kernel.ImportTest do
     assert __underscore__(3) == 3
   end
 
-  test "import non underscored" do
+  test "import non-underscored" do
     import ExplicitUnderscored, only: [__underscore__: 1]
     import Underscored
     assert hello(2) == 2
@@ -69,14 +112,14 @@ defmodule Kernel.ImportTest do
   end
 
   defmodule MessedBitwise do
-    defmacro bnot(x),   do: x
+    defmacro bnot(x), do: x
     defmacro bor(x, _), do: x
   end
 
-  import Bitwise, only: :macros
+  import Bitwise, only: :functions
 
-  test "conflicing imports with only and except" do
-    import Bitwise, only: :macros, except: [bnot: 1]
+  test "conflicting imports with only and except" do
+    import Bitwise, only: :functions, except: [bnot: 1]
     import MessedBitwise, only: [bnot: 1]
     assert bnot(0) == 0
     assert bor(0, 1) == 1
@@ -100,15 +143,79 @@ defmodule Kernel.ImportTest do
 
   test "import many" do
     [import(List), import(String)]
-    assert capitalize("foo")  == "Foo"
+    assert capitalize("foo") == "Foo"
     assert flatten([1, [2], 3]) == [1, 2, 3]
   end
 
+  test "does not import *_info in Erlang" do
+    import :gen_server, warn: false
+    assert Macro.Env.lookup_import(__ENV__, {:module_info, 1}) == []
+    assert Macro.Env.lookup_import(__ENV__, {:behaviour_info, 1}) == []
+  end
+
+  test "does not import *_info in Elixir" do
+    import GenServer, warn: false
+    assert Macro.Env.lookup_import(__ENV__, {:module_info, 1}) == []
+    assert Macro.Env.lookup_import(__ENV__, {:behaviour_info, 1}) == []
+  end
+
+  defmodule ModuleWithSigils do
+    def sigil_i(string, []), do: String.to_integer(string)
+
+    defmacro sigil_I(string, []) do
+      quote do
+        String.to_integer(unquote(string))
+      end
+    end
+
+    defmacro sigil_III(string, []) do
+      quote do
+        3 * String.to_integer(unquote(string))
+      end
+    end
+
+    def sigil_w(_string, []), do: []
+
+    def bnot(x), do: x
+    defmacro bor(x, _), do: x
+  end
+
+  test "import only sigils" do
+    import Kernel, except: [sigil_w: 2]
+    import ModuleWithSigils, only: :sigils
+
+    # Ensure that both function and macro sigils are imported
+    assert ~i'10' == 10
+    assert ~I'10' == 10
+    assert ~III'10' == 30
+    assert ~w(abc def) == []
+
+    # Ensure that non-sigil functions and macros from ModuleWithSigils were not loaded
+    assert bnot(0) == -1
+    assert bor(0, 1) == 1
+  end
+
+  test "import only sigils with except" do
+    import ModuleWithSigils, only: :sigils, except: [sigil_w: 2]
+
+    assert ~i'10' == 10
+    assert ~I'10' == 10
+    assert ~III'10' == 30
+    assert ~w(abc def) == ["abc", "def"]
+  end
+
+  test "import only removes the non-import part" do
+    import List
+    import List, only: :macros
+    # Buggy local duplicate is used because we asked only for macros
+    assert duplicate([1], 2) == [1]
+  end
+
   test "import lexical on if" do
     if false do
-      import :lists
+      import List
       flatten([1, [2], 3])
-      flunk
+      flunk()
     else
       # Buggy local duplicate is untouched
       assert duplicate([1], 2) == [1]
@@ -116,22 +223,45 @@ defmodule Kernel.ImportTest do
   end
 
   test "import lexical on case" do
-    case true do
+    case Process.get(:unused, true) do
       false ->
-        import :lists
+        import List
         flatten([1, [2], 3])
-        flunk
+        flunk()
+
       true ->
         # Buggy local duplicate is untouched
         assert duplicate([1], 2) == [1]
     end
   end
 
+  test "import lexical on for" do
+    for x <- [1, 2, 3], x > 10 do
+      import List
+      flatten([1, [2], 3])
+      flunk()
+    end
+
+    # Buggy local duplicate is untouched
+    assert duplicate([1], 2) == [1]
+  end
+
+  test "import lexical on with" do
+    with [_ | _] <- List.flatten([]) do
+      import List
+      flatten([1, [2], 3])
+      flunk()
+    end
+
+    # Buggy local duplicate is untouched
+    assert duplicate([1], 2) == [1]
+  end
+
   test "import lexical on try" do
     try do
-      import :lists
+      import List
       flatten([1, [2], 3])
-      flunk
+      flunk()
     catch
       _, _ ->
         # Buggy local duplicate is untouched
diff --git a/lib/elixir/test/elixir/kernel/lexical_tracker_test.exs b/lib/elixir/test/elixir/kernel/lexical_tracker_test.exs
index da2a9cf4931..979abdc2bb2 100644
--- a/lib/elixir/test/elixir/kernel/lexical_tracker_test.exs
+++ b/lib/elixir/test/elixir/kernel/lexical_tracker_test.exs
@@ -1,58 +1,606 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.LexicalTrackerTest do
   use ExUnit.Case, async: true
 
   alias Kernel.LexicalTracker, as: D
+  defstruct used_by_tests: :ok
 
   setup do
-    {:ok, [pid: D.start_link]}
+    {:ok, pid} = D.start_link()
+    {:ok, [pid: pid]}
   end
 
-  test "can add remote dispatches", config do
-    D.remote_dispatch(config[:pid], String)
-    assert D.remotes(config[:pid]) == [String]
+  test "can add remote dispatch", config do
+    D.remote_dispatch(config[:pid], String, :runtime)
+    assert D.references(config[:pid]) == {[], [], [String], []}
+
+    D.remote_dispatch(config[:pid], String, :compile)
+    assert D.references(config[:pid]) == {[String], [], [], []}
+
+    D.remote_dispatch(config[:pid], String, :runtime)
+    assert D.references(config[:pid]) == {[String], [], [], []}
   end
 
-  test "can add imports", config do
-    D.add_import(config[:pid], String, 1, true)
-    assert D.remotes(config[:pid]) == [String]
+  test "can add requires", config do
+    D.add_export(config[:pid], URI)
+    assert D.references(config[:pid]) == {[], [URI], [], []}
+
+    D.remote_dispatch(config[:pid], URI, :runtime)
+    assert D.references(config[:pid]) == {[], [URI], [URI], []}
+
+    D.remote_dispatch(config[:pid], URI, :compile)
+    assert D.references(config[:pid]) == {[URI], [URI], [], []}
+  end
+
+  test "can add module imports", config do
+    D.add_export(config[:pid], String)
+    D.add_import(config[:pid], String, [], 1, true)
+
+    D.import_dispatch(config[:pid], String, {:upcase, 1}, :runtime)
+    assert D.references(config[:pid]) == {[], [String], [String], []}
+
+    D.import_dispatch(config[:pid], String, {:upcase, 1}, :compile)
+    assert D.references(config[:pid]) == {[String], [String], [], []}
+  end
+
+  test "can add module with {function, arity} imports", config do
+    D.add_export(config[:pid], String)
+    D.add_import(config[:pid], String, [upcase: 1], 1, true)
+
+    D.import_dispatch(config[:pid], String, {:upcase, 1}, :compile)
+    assert D.references(config[:pid]) == {[String], [String], [], []}
   end
 
   test "can add aliases", config do
-    D.add_alias(config[:pid], String, 1, true)
-    assert D.remotes(config[:pid]) == [String]
+    D.alias_dispatch(config[:pid], String)
+    assert D.references(config[:pid]) == {[], [], [], []}
   end
 
-  test "unused imports", config do
-    D.add_import(config[:pid], String, 1, true)
-    assert D.collect_unused_imports(config[:pid]) == [{String,1}]
+  test "unused module imports", config do
+    D.add_import(config[:pid], String, [], 1, true)
+    assert D.collect_unused_imports(config[:pid]) == [{String, %{String => 1}}]
   end
 
-  test "used imports are not unused", config do
-    D.add_import(config[:pid], String, 1, true)
-    D.import_dispatch(config[:pid], String)
-    assert D.collect_unused_imports(config[:pid]) == []
+  test "used module imports are not unused", config do
+    D.add_import(config[:pid], String, [], 1, true)
+    D.import_dispatch(config[:pid], String, {:upcase, 1}, :compile)
+    assert D.collect_unused_imports(config[:pid]) == [{String, %{}}]
+  end
+
+  test "unused {module, function, arity} imports", config do
+    D.add_import(config[:pid], String, [upcase: 1], 1, true)
+    assert D.collect_unused_imports(config[:pid]) == [{String, %{String => 1, {:upcase, 1} => 1}}]
+  end
+
+  test "used {module, function, arity} imports are not unused", config do
+    D.add_import(config[:pid], String, [upcase: 1], 1, true)
+    D.add_import(config[:pid], String, [downcase: 1], 1, true)
+    D.import_dispatch(config[:pid], String, {:upcase, 1}, :compile)
+    assert D.collect_unused_imports(config[:pid]) == [{String, %{{:downcase, 1} => 1}}]
+  end
+
+  test "overwriting {module, function, arity} import with module import", config do
+    D.add_import(config[:pid], String, [upcase: 1], 1, true)
+    D.add_import(config[:pid], String, [], 1, true)
+    D.import_dispatch(config[:pid], String, {:downcase, 1}, :compile)
+    assert D.collect_unused_imports(config[:pid]) == [{String, %{}}]
   end
 
   test "imports with no warn are not unused", config do
-    D.add_import(config[:pid], String, 1, false)
+    D.add_import(config[:pid], String, [], 1, false)
     assert D.collect_unused_imports(config[:pid]) == []
   end
 
+  test "unused requires", config do
+    D.warn_require(config[:pid], [], String)
+    D.warn_require(config[:pid], [], List)
+    D.remote_dispatch(config[:pid], String, :compile)
+    assert D.collect_unused_requires(config[:pid]) == [{List, []}]
+  end
+
+  test "function calls do not count as macro usage", config do
+    D.warn_require(config[:pid], [], String)
+    D.remote_dispatch(config[:pid], String, :runtime)
+    assert D.collect_unused_requires(config[:pid]) == [{String, []}]
+  end
+
   test "unused aliases", config do
-    D.add_alias(config[:pid], String, 1, true)
-    assert D.collect_unused_aliases(config[:pid]) == [{String,1}]
+    D.warn_alias(config[:pid], [], String, String)
+    assert D.collect_unused_aliases(config[:pid]) == [{String, []}]
   end
 
   test "used aliases are not unused", config do
-    D.add_alias(config[:pid], String, 1, true)
+    D.warn_alias(config[:pid], [], String, String)
     D.alias_dispatch(config[:pid], String)
     assert D.collect_unused_aliases(config[:pid]) == []
   end
 
-  test "aliases with no warn are not unused", config do
-    D.add_alias(config[:pid], String, 1, false)
+  test "used aliases are not unused in reverse order", config do
+    D.alias_dispatch(config[:pid], String)
+    D.warn_alias(config[:pid], [], String, String)
     assert D.collect_unused_aliases(config[:pid]) == []
   end
+
+  describe "references" do
+    test "typespecs do not tag aliases nor types" do
+      Code.eval_string("""
+      defmodule Kernel.LexicalTrackerTest.AliasTypespecs do
+        alias Foo.Bar, as: Bar, warn: false
+        @type bar :: Foo.Bar | Foo.Bar.t
+        @opaque bar2 :: Foo.Bar.t
+        @typep bar3 :: Foo.Bar.t
+        @callback foo :: Foo.Bar.t
+        @macrocallback foo2(Foo.Bar.t) :: Foo.Bar.t
+        @spec foo(bar3) :: Foo.Bar.t
+        def foo(_), do: :ok
+
+        # References from specs are processed only late
+        @after_compile __MODULE__
+        def __after_compile__(env, _) do
+          send(self(), {:references, Kernel.LexicalTracker.references(env.lexical_tracker)})
+        end
+      end
+      """)
+
+      assert_received {:references, {compile, _exports, runtime, _}}
+
+      refute Elixir.Bar in runtime
+      refute Elixir.Bar in compile
+
+      refute Foo.Bar in runtime
+      refute Foo.Bar in compile
+    end
+
+    test "typespecs track structs as exports" do
+      Code.eval_string("""
+      defmodule Kernel.LexicalTrackerTest.StructTypespecs do
+        @type uri :: %URI{}
+
+        # References from specs are processed only late
+        @after_compile __MODULE__
+        def __after_compile__(env, _) do
+          send(self(), {:references, Kernel.LexicalTracker.references(env.lexical_tracker)})
+        end
+      end
+      """)
+
+      assert_received {:references, {compile, exports, runtime, _}}
+
+      assert URI in runtime
+      assert URI in exports
+      refute URI in compile
+    end
+
+    test "attributes adds dependency based on expansion" do
+      {{compile, _, _, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Attribute1 do
+          @example [String, Enum, 3 + 10]
+          def foo(atom) when atom in @example, do: atom
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute String in compile
+      refute Enum in compile
+
+      {{compile, _, _, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Attribute2 do
+          @example [String, Enum]
+          def foo(atom) when atom in @example, do: atom
+          _ = @example
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert String in compile
+      assert Enum in compile
+
+      {{compile, _, _, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Attribute3 do
+          @example [String, Enum]
+          _ = Module.get_attribute(__MODULE__, :example)
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert String in compile
+      assert Enum in compile
+
+      {{compile, _, _, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Attribute4 do
+          Module.register_attribute(__MODULE__, :example, accumulate: true)
+          @example String
+          def foo(atom) when atom in @example, do: atom
+          @example Enum
+          def bar(atom) when atom in @example, do: atom
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute String in compile
+      refute Enum in compile
+
+      {{compile, _, _, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Attribute5 do
+          Module.register_attribute(__MODULE__, :example, accumulate: true)
+          @example String
+          def foo(atom) when atom in @example, do: atom
+          @example Enum
+          def bar(atom) when atom in @example, do: atom
+          _ = Module.get_attribute(__MODULE__, :example)
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert String in compile
+      assert Enum in compile
+
+      {{compile, _, _, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Attribute6 do
+          @example %{foo: Application.compile_env(:elixir, Enum, String)}
+          def foo(atom) when atom == @example.foo, do: atom
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute String in compile
+      refute Enum in compile
+
+      {{compile, _, _, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Attribute7 do
+          Module.register_attribute(__MODULE__, :example, accumulate: true)
+          @example String
+          @example Enum
+          _ = Module.get_last_attribute(__MODULE__, :example)
+
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert String in compile
+      assert Enum in compile
+    end
+
+    test "@compile adds a runtime dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Compile do
+          @compile {:no_warn_undefined, String}
+          @compile {:no_warn_undefined, {Enum, :concat, 1}}
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute String in compile
+      refute String in exports
+      assert String in runtime
+
+      refute Enum in compile
+      refute Enum in exports
+      assert Enum in runtime
+    end
+
+    def __before_compile__(_), do: :ok
+    def __after_compile__(_, _), do: :ok
+    def __on_definition__(_, _, _, _, _, _), do: :ok
+
+    test "module callbacks add a compile dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.BeforeCompile do
+          @before_compile Kernel.LexicalTrackerTest
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert Kernel.LexicalTrackerTest in compile
+      refute Kernel.LexicalTrackerTest in exports
+      refute Kernel.LexicalTrackerTest in runtime
+
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.AfterCompile do
+          @after_compile Kernel.LexicalTrackerTest
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert Kernel.LexicalTrackerTest in compile
+      refute Kernel.LexicalTrackerTest in exports
+      refute Kernel.LexicalTrackerTest in runtime
+
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.OnDefinition do
+          @on_definition Kernel.LexicalTrackerTest
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert Kernel.LexicalTrackerTest in compile
+      refute Kernel.LexicalTrackerTest in exports
+      refute Kernel.LexicalTrackerTest in runtime
+    end
+
+    test "defdelegate with literal adds runtime dependency" do
+      {{compile, _exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Defdelegate do
+          defdelegate decode_query(query), to: URI
+
+          opts = [to: Enum]
+          defdelegate concat(enum), opts
+
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute URI in compile
+      assert Enum in compile
+      assert URI in runtime
+    end
+
+    test "dbg adds a compile dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Dbg do
+          def foo, do: dbg(:ok)
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert Macro in compile
+      refute Macro in exports
+      refute Macro in runtime
+
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.NoDbg do
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute Macro in compile
+      refute Macro in exports
+      refute Macro in runtime
+    end
+
+    test "imports adds an export dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Imports do
+          import String, warn: false
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute String in compile
+      assert String in exports
+      refute String in runtime
+    end
+
+    test "structs are exports or compile time" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.StructRuntime do
+          def expand, do: %URI{}
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute URI in compile
+      assert URI in exports
+      assert URI in runtime
+
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.StructCompile do
+          _ = %URI{}
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert URI in compile
+      assert URI in exports
+      refute URI in runtime
+
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.StructPattern do
+          def uri?(%URI{}), do: true
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute URI in compile
+      assert URI in exports
+      assert URI in runtime
+    end
+
+    test "Macro.struct_info! adds an export dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.MacroStruct do
+          # We do not use the alias because it would be a compile time
+          # dependency. The alias may happen in practice, which is the
+          # mechanism to make this expansion become a compile-time one.
+          # However, in some cases, such as typespecs, we don't necessarily
+          # want the compile-time dependency to happen.
+          Macro.struct_info!(:"Elixir.URI", __ENV__)
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute URI in compile
+      assert URI in exports
+      refute URI in runtime
+    end
+
+    test "aliases in patterns and guards inside functions do not add runtime dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.PatternGuardsRuntime do
+          def uri_atom?(URI), do: true
+          def range_struct?(range) when is_struct(range, Range), do: true
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute URI in compile
+      refute URI in exports
+      refute URI in runtime
+      refute Range in compile
+      refute Range in exports
+      refute Range in runtime
+    end
+
+    test "aliases in patterns and guards outside functions do add compile dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.PatternGuardsCompile do
+          %URI{} = URI.parse("/")
+          case Range.new(1, 3) do
+            range when is_struct(range, Range) -> :ok
+          end
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert URI in compile
+      assert URI in exports
+      refute URI in runtime
+      assert Range in compile
+      refute Range in exports
+      refute Range in runtime
+    end
+
+    test "compile_env! does not add a compile dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.CompileEnvStruct do
+          require Application
+          Application.compile_env(:elixir, URI)
+          Application.compile_env(:elixir, [:foo, URI, :bar])
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute URI in compile
+      refute URI in exports
+      assert URI in runtime
+    end
+
+    test "defmodule does not add a compile dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Defmodule do
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute Kernel.LexicalTrackerTest.Defmodule in compile
+      refute Kernel.LexicalTrackerTest.Defmodule in exports
+      refute Kernel.LexicalTrackerTest.Defmodule in runtime
+    end
+
+    test "defmacro adds a compile-time dependency for local calls" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.Defmacro do
+          defmacro uri(path) do
+            Macro.escape(URI.parse(path))
+          end
+
+          def fun() do
+            uri("/hello")
+          end
+
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert URI in compile
+      refute URI in exports
+      refute URI in runtime
+    end
+
+    test "imported functions from quote adds dependencies" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.QuotedFun do
+          import URI
+
+          defmacro parse_root() do
+            quote do
+              parse("/")
+            end
+          end
+        end
+
+        defmodule Kernel.LexicalTrackerTest.UsingQuotedFun do
+          require Kernel.LexicalTrackerTest.QuotedFun, as: QF
+          QF.parse_root()
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert URI in compile
+      refute URI in exports
+      refute URI in runtime
+    end
+
+    test "imported macro from quote adds dependencies" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.QuotedMacro do
+          import Config
+
+          defmacro config_env() do
+            quote do
+              config_env()
+            end
+          end
+        end
+
+        defmodule Kernel.LexicalTrackerTest.UsingQuotedMacro do
+          require Kernel.LexicalTrackerTest.QuotedMacro, as: QM
+          def fun(), do: QM.config_env()
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert Config in compile
+      refute Config in exports
+      refute Config in runtime
+    end
+
+    test "defimpl does not add dependencies on for only on impl" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defimpl String.Chars, for: Kernel.LexicalTrackerTest do
+          def to_string(val), do: val.used_by_tests
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute String.Chars in compile
+      assert String.Chars in exports
+
+      refute Kernel.LexicalTrackerTest in compile
+      refute Kernel.LexicalTrackerTest in exports
+      refute Kernel.LexicalTrackerTest in runtime
+    end
+  end
 end
diff --git a/lib/elixir/test/elixir/kernel/macros_test.exs b/lib/elixir/test/elixir/kernel/macros_test.exs
index fd2f7511e7c..c5f2975280f 100644
--- a/lib/elixir/test/elixir/kernel/macros_test.exs
+++ b/lib/elixir/test/elixir/kernel/macros_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.MacrosTest.Nested do
   defmacro value, do: 1
@@ -6,49 +10,85 @@ defmodule Kernel.MacrosTest.Nested do
   defmacro do_identity!(do: x) do
     x
   end
+
+  defmacro unused_require do
+    quote do
+      require Integer
+    end
+  end
 end
 
 defmodule Kernel.MacrosTest do
-  require Kernel.MacrosTest.Nested, as: Nested
-
   use ExUnit.Case, async: true
 
+  Kernel.MacrosTest.Nested = require Kernel.MacrosTest.Nested, as: Nested
+
+  # Unused require from macro should not warn
+  Kernel.MacrosTest.Nested.unused_require()
+
+  @spec my_macro :: Macro.t()
   defmacro my_macro do
-    quote do: 1 + 1
+    quote(do: 1 + 1)
   end
 
+  @spec my_private_macro :: Macro.t()
   defmacrop my_private_macro do
-    quote do: 1 + 3
+    quote(do: 1 + 3)
   end
 
   defmacro my_macro_with_default(value \\ 5) do
-    quote do: 1 + unquote(value)
+    quote(do: 1 + unquote(value))
+  end
+
+  defp by_two(x), do: x * 2
+
+  defmacro my_macro_with_local(value) do
+    value = by_two(by_two(value))
+    quote(do: 1 + unquote(value))
   end
 
-  test :require do
-    assert Kernel.MacrosTest.Nested.value == 1
+  defmacro my_macro_with_capture(value) do
+    Enum.map(value, &by_two/1)
   end
 
-  test :require_with_alias do
-    assert Nested.value == 1
+  test "require" do
+    assert Kernel.MacrosTest.Nested.value() == 1
   end
 
-  test :local_but_private_macro do
-    assert my_private_macro == 4
+  test "require with alias" do
+    assert Nested.value() == 1
   end
 
-  test :local_with_defaults_macro do
-    assert my_macro_with_default == 6
+  test "local with private macro" do
+    assert my_private_macro() == 4
   end
 
-  test :macros_cannot_be_called_dynamically do
-    x = Nested
-    assert_raise UndefinedFunctionError, fn -> x.value end
+  test "local with defaults macro" do
+    assert my_macro_with_default() == 6
   end
 
-  test :bang_do_block do
+  test "local with local call" do
+    assert my_macro_with_local(4) == 17
+  end
+
+  test "local with capture" do
+    assert my_macro_with_capture([1, 2, 3]) == [2, 4, 6]
+  end
+
+  test "macros cannot be called dynamically" do
+    x = String.to_atom("Elixir.Nested")
+    assert_raise UndefinedFunctionError, fn -> x.func() end
+  end
+
+  test "macros with bang and do block have proper precedence" do
     import Kernel.MacrosTest.Nested
-    assert (do_identity! do 1 end) == 1
-    assert (Kernel.MacrosTest.Nested.do_identity! do 1 end) == 1
+
+    assert (do_identity! do
+              1
+            end) == 1
+
+    assert (Kernel.MacrosTest.Nested.do_identity! do
+              1
+            end) == 1
   end
-end
\ No newline at end of file
+end
diff --git a/lib/elixir/test/elixir/kernel/overridable_test.exs b/lib/elixir/test/elixir/kernel/overridable_test.exs
index 1397e53d793..51992f0b4ba 100644
--- a/lib/elixir/test/elixir/kernel/overridable_test.exs
+++ b/lib/elixir/test/elixir/kernel/overridable_test.exs
@@ -1,10 +1,10 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-defmodule Kernel.Overridable do
-  defmacrop super? do
-    Module.overridable?(__CALLER__.module, __CALLER__.function)
-  end
+Code.require_file("../test_helper.exs", __DIR__)
 
+defmodule Kernel.Overridable do
   def sample do
     1
   end
@@ -17,50 +17,54 @@ defmodule Kernel.Overridable do
     1
   end
 
-  def explicit_nested_super do
-    {super?, 2}
+  def super_with_multiple_args(x, y) do
+    x + y
   end
 
-  false = Module.overridable? __MODULE__, {:explicit_nested_super, 0}
-
-  defoverridable [sample: 0, with_super: 0, without_super: 0, explicit_nested_super: 0]
-
-  true = Module.overridable? __MODULE__, {:explicit_nested_super, 0}
-
-  def explicit_nested_super do
-    {super, super?, 1}
+  def capture_super(x) do
+    x
   end
 
-  true = Module.overridable? __MODULE__, {:explicit_nested_super, 0}
-
-  defoverridable [explicit_nested_super: 0]
-
-  true = Module.overridable? __MODULE__, {:explicit_nested_super, 0}
-
-  def implicit_nested_super do
-    {super?, 1}
+  defmacro capture_super_macro(x) do
+    x
   end
 
-  defoverridable [implicit_nested_super: 0]
+  def many_clauses(0) do
+    11
+  end
 
-  def implicit_nested_super do
-    {super, super?, 0}
+  def many_clauses(1) do
+    13
   end
 
-  def super_with_explicit_args(x, y) do
-    x + y
+  def locals do
+    undefined_function()
   end
 
-  def many_clauses(0) do
-    11
+  def multiple_overrides do
+    [1]
   end
 
-  def many_clauses(1) do
-    13
+  def public_to_private do
+    :public
   end
 
-  defoverridable [implicit_nested_super: 0,
-    super_with_explicit_args: 2, many_clauses: 1]
+  defoverridable sample: 0,
+                 with_super: 0,
+                 without_super: 0,
+                 super_with_multiple_args: 2,
+                 capture_super: 1,
+                 capture_super_macro: 1,
+                 many_clauses: 1,
+                 locals: 0,
+                 multiple_overrides: 0,
+                 public_to_private: 0
+
+  true = Module.overridable?(__MODULE__, {:without_super, 0})
+  true = Module.overridable?(__MODULE__, {:with_super, 0})
+
+  true = {:with_super, 0} in Module.overridables_in(__MODULE__)
+  true = {:without_super, 0} in Module.overridables_in(__MODULE__)
 
   def without_super do
     :without_super
@@ -70,16 +74,22 @@ defmodule Kernel.Overridable do
     super() + 2
   end
 
-  def no_overridable do
-    {:no_overridable, super?}
+  true = Module.overridable?(__MODULE__, {:without_super, 0})
+  true = Module.overridable?(__MODULE__, {:with_super, 0})
+
+  true = {:with_super, 0} in Module.overridables_in(__MODULE__)
+  true = {:without_super, 0} in Module.overridables_in(__MODULE__)
+
+  def super_with_multiple_args(x, y) do
+    super(x, y * 2)
   end
 
-  def explicit_nested_super do
-    {super, super?, 0}
+  def capture_super(x) do
+    Enum.map(1..x, &super(&1)) ++ Enum.map(1..x, &super/1)
   end
 
-  def super_with_explicit_args(x, y) do
-    super x, y * 2
+  defmacro capture_super_macro(x) do
+    Enum.map(1..x, &super(&1)) ++ Enum.map(1..x, &super/1)
   end
 
   def many_clauses(2) do
@@ -93,38 +103,171 @@ defmodule Kernel.Overridable do
   def many_clauses(x) do
     super(x)
   end
+
+  def locals do
+    :ok
+  end
+
+  def multiple_overrides do
+    [2 | super()]
+  end
+
+  defp public_to_private do
+    :private
+  end
+
+  def test_public_to_private do
+    public_to_private()
+  end
+
+  defoverridable multiple_overrides: 0
+
+  def multiple_overrides do
+    [3 | super()]
+  end
+
+  ## Macros
+
+  defmacro overridable_macro(x) do
+    quote do
+      unquote(x) + 100
+    end
+  end
+
+  defoverridable overridable_macro: 1
+
+  defmacro overridable_macro(x) do
+    quote do
+      unquote(super(x)) + 1000
+    end
+  end
+
+  defmacrop private_macro(x) do
+    quote do
+      unquote(x) + 100
+    end
+  end
+
+  defoverridable private_macro: 1
+
+  defmacrop private_macro(x) do
+    quote do
+      unquote(super(x)) + 1000
+    end
+  end
+
+  def private_macro_call(val \\ 11) do
+    private_macro(val)
+  end
+end
+
+defmodule Kernel.OverridableExampleBehaviour do
+  @callback required_callback :: any
+  @callback optional_callback :: any
+  @macrocallback required_macro_callback(arg :: any) :: Macro.t()
+  @macrocallback optional_macro_callback(arg :: any, arg2 :: any) :: Macro.t()
+  @optional_callbacks optional_callback: 0, optional_macro_callback: 2
 end
 
 defmodule Kernel.OverridableTest do
   require Kernel.Overridable, as: Overridable
-  use ExUnit.Case, async: true
+  use ExUnit.Case
+
+  defp purge(module) do
+    :code.purge(module)
+    :code.delete(module)
+  end
+
+  test "overridable keeps function ordering" do
+    defmodule OverridableOrder do
+      def not_private(str) do
+        process_url(str)
+      end
+
+      def process_url(_str) do
+        :first
+      end
+
+      # There was a bug where the order in which we removed
+      # overridable expressions lead to errors. This module
+      # aims to guarantee removing process_url/1 before we
+      # remove the function that depends on it does not cause
+      # errors. If it compiles, it works!
+      defoverridable process_url: 1, not_private: 1
+
+      def process_url(_str) do
+        :second
+      end
+    end
+  end
+
+  test "overridable works with defaults" do
+    defmodule OverridableDefault do
+      def fun(value, opt \\ :from_parent) do
+        {value, opt}
+      end
+
+      defmacro macro(value, opt \\ :from_parent) do
+        {{value, opt}, Macro.escape(__CALLER__)}
+      end
+
+      # There was a bug where the default function would
+      # attempt to call its overridable name instead of
+      # func/1. If it compiles, it works!
+      defoverridable fun: 1, fun: 2, macro: 1, macro: 2
+
+      def fun(value) do
+        {value, super(value)}
+      end
+
+      defmacro macro(value) do
+        {{value, super(value)}, Macro.escape(__CALLER__)}
+      end
+    end
+
+    defmodule OverridableCall do
+      require OverridableDefault
+      OverridableDefault.fun(:foo)
+      OverridableDefault.macro(:bar)
+    end
+  end
 
   test "overridable is made concrete if no other is defined" do
-    assert Overridable.sample == 1
+    assert Overridable.sample() == 1
   end
 
   test "overridable overridden with super" do
-    assert Overridable.with_super == 3
+    assert Overridable.with_super() == 3
   end
 
   test "overridable overridden without super" do
-    assert Overridable.without_super == :without_super
+    assert Overridable.without_super() == :without_super
   end
 
-  test "overridable overridden with nested super" do
-    assert Overridable.explicit_nested_super == {{{false, 2}, true, 1}, true, 0}
+  test "public overridable overridden as private function" do
+    assert Overridable.test_public_to_private() == :private
+    refute {:public_to_private, 0} in Overridable.module_info(:exports)
   end
 
-  test "overridable node overridden with nested super" do
-    assert Overridable.implicit_nested_super == {{false, 1}, true, 0}
+  test "overridable locals are ignored without super" do
+    assert Overridable.locals() == :ok
   end
 
-  test "calling super with explicit args" do
-    assert Overridable.super_with_explicit_args(1, 2) == 5
+  test "calling super with multiple args" do
+    assert Overridable.super_with_multiple_args(1, 2) == 5
   end
 
-  test "function without overridable returns false for super?" do
-    assert Overridable.no_overridable == {:no_overridable, false}
+  test "calling super using function captures" do
+    assert Overridable.capture_super(5) == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
+  end
+
+  test "calling super of an overridable macro using function captures" do
+    assert Overridable.capture_super_macro(5) == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
+  end
+
+  test "super as a variable" do
+    super = :ok
+    assert super == :ok
   end
 
   test "overridable with many clauses" do
@@ -135,18 +278,283 @@ defmodule Kernel.OverridableTest do
   end
 
   test "overridable definitions are private" do
-    refute {:"with_super (overridable 0)", 0} in Overridable.__info__(:exports)
+    refute {:"with_super (overridable 0)", 0} in Overridable.module_info(:exports)
+    refute {:"with_super (overridable 1)", 0} in Overridable.module_info(:exports)
+  end
+
+  test "multiple overrides" do
+    assert Overridable.multiple_overrides() == [3, 2, 1]
+  end
+
+  test "overridable macros" do
+    a = 11
+    assert Overridable.overridable_macro(a) == 1111
+    assert Overridable.private_macro_call() == 1111
   end
 
   test "invalid super call" do
-    try do
-      :elixir.eval 'defmodule Foo.Forwarding do\ndef bar, do: 1\ndefoverridable [bar: 0]\ndef foo, do: super\nend', []
-      flunk "expected eval to fail"
-    rescue
-      error ->
-        assert Exception.message(error) ==
-          "nofile:4: no super defined for foo/0 in module Foo.Forwarding. " <>
-          "Overridable functions available are: bar/0"
+    messages = [
+      "nofile:4",
+      "no super defined for foo/0 in module Kernel.OverridableOrder.Forwarding. " <>
+        "Overridable functions available are: bar/0"
+    ]
+
+    assert_compile_error(messages, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableOrder.Forwarding do
+        def bar(), do: 1
+        defoverridable bar: 0
+        def foo(), do: super()
+      end
+      """)
+    end)
+
+    purge(Kernel.OverridableOrder.Forwarding)
+  end
+
+  test "invalid super call with different arity" do
+    messages = [
+      "nofile:4",
+      "super must be called with the same number of arguments as the current definition"
+    ]
+
+    assert_compile_error(messages, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableSuper.DifferentArities do
+        def bar(a), do: a
+        defoverridable bar: 1
+        def bar(_), do: super()
+      end
+      """)
+    end)
+  end
+
+  test "invalid super capture with different arity" do
+    messages = [
+      "nofile:4",
+      "super must be called with the same number of arguments as the current definition"
+    ]
+
+    assert_compile_error(messages, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableSuperCapture.DifferentArities do
+        def bar(a), do: a
+        defoverridable bar: 1
+        def bar(_), do: (&super/0).()
+      end
+      """)
+    end)
+  end
+
+  test "does not allow to override a macro as a function" do
+    messages = [
+      "nofile:4",
+      "cannot override macro (defmacro, defmacrop) foo/0 in module " <>
+        "Kernel.OverridableMacro.FunctionOverride as a function (def, defp)"
+    ]
+
+    assert_compile_error(messages, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableMacro.FunctionOverride do
+        defmacro foo(), do: :ok
+        defoverridable foo: 0
+        def foo(), do: :invalid
+      end
+      """)
+    end)
+
+    purge(Kernel.OverridableMacro.FunctionOverride)
+
+    assert_compile_error(messages, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableMacro.FunctionOverride do
+        defmacro foo(), do: :ok
+        defoverridable foo: 0
+        def foo(), do: :invalid
+        defoverridable foo: 0
+        def foo(), do: :invalid
+      end
+      """)
+    end)
+
+    purge(Kernel.OverridableMacro.FunctionOverride)
+
+    assert_compile_error(messages, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableMacro.FunctionOverride do
+        defmacro foo(), do: :ok
+        defoverridable foo: 0
+        def foo(), do: super()
+      end
+      """)
+    end)
+
+    purge(Kernel.OverridableMacro.FunctionOverride)
+  end
+
+  test "does not allow to override a function as a macro" do
+    messages = [
+      "nofile:4",
+      "cannot override function (def, defp) foo/0 in module " <>
+        "Kernel.OverridableFunction.MacroOverride as a macro (defmacro, defmacrop)"
+    ]
+
+    assert_compile_error(messages, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableFunction.MacroOverride do
+        def foo(), do: :ok
+        defoverridable foo: 0
+        defmacro foo(), do: :invalid
+      end
+      """)
+    end)
+
+    purge(Kernel.OverridableFunction.MacroOverride)
+
+    assert_compile_error(messages, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableFunction.MacroOverride do
+        def foo(), do: :ok
+        defoverridable foo: 0
+        defmacro foo(), do: :invalid
+        defoverridable foo: 0
+        defmacro foo(), do: :invalid
+      end
+      """)
+    end)
+
+    purge(Kernel.OverridableFunction.MacroOverride)
+
+    assert_compile_error(messages, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableFunction.MacroOverride do
+        def foo(), do: :ok
+        defoverridable foo: 0
+        defmacro foo(), do: super()
+      end
+      """)
+    end)
+
+    purge(Kernel.OverridableFunction.MacroOverride)
+  end
+
+  test "undefined functions can't be marked as overridable" do
+    message = "cannot make function foo/2 overridable because it was not defined"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableOrder.Foo do
+        defoverridable foo: 2
+      end
+      """)
+    end
+
+    purge(Kernel.OverridableOrder.Foo)
+  end
+
+  test "overrides with behaviour" do
+    defmodule OverridableWithBehaviour do
+      @behaviour Elixir.Kernel.OverridableExampleBehaviour
+
+      def required_callback(), do: "original"
+
+      def optional_callback(), do: "original"
+
+      def not_a_behaviour_callback(), do: "original"
+
+      defmacro required_macro_callback(boolean) do
+        quote do
+          if unquote(boolean) do
+            "original"
+          end
+        end
+      end
+
+      defoverridable Elixir.Kernel.OverridableExampleBehaviour
+
+      defmacro optional_macro_callback(arg1, arg2), do: {arg1, arg2}
+
+      assert Module.overridable?(__MODULE__, {:required_callback, 0})
+      assert Module.overridable?(__MODULE__, {:optional_callback, 0})
+      assert Module.overridable?(__MODULE__, {:required_macro_callback, 1})
+      refute Module.overridable?(__MODULE__, {:optional_macro_callback, 1})
+      refute Module.overridable?(__MODULE__, {:not_a_behaviour_callback, 1})
+    end
+  end
+
+  test "undefined module can't be passed as argument to defoverridable" do
+    message =
+      "cannot pass module Kernel.OverridableTest.Bar as argument to defoverridable/1 because it was not defined"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableTest.Foo do
+        defoverridable Kernel.OverridableTest.Bar
+      end
+      """)
+    end
+
+    purge(Kernel.OverridableTest.Foo)
+  end
+
+  test "module without @behaviour can't be passed as argument to defoverridable" do
+    message =
+      "cannot pass module Kernel.OverridableExampleBehaviour as argument to defoverridable/1" <>
+        " because its corresponding behaviour is missing. Did you forget to add " <>
+        "@behaviour Kernel.OverridableExampleBehaviour?"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableTest.Foo do
+        defoverridable Kernel.OverridableExampleBehaviour
+      end
+      """)
+    end
+
+    purge(Kernel.OverridableTest.Foo)
+  end
+
+  test "module with no callbacks can't be passed as argument to defoverridable" do
+    message =
+      "cannot pass module Kernel.OverridableTest.Bar as argument to defoverridable/1 because it does not define any callbacks"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableTest.Bar do
+      end
+      defmodule Kernel.OverridableTest.Foo do
+        @behaviour Kernel.OverridableTest.Bar
+        defoverridable Kernel.OverridableTest.Bar
+      end
+      """)
+    end
+
+    purge(Kernel.OverridableTest.Bar)
+    purge(Kernel.OverridableTest.Foo)
+  end
+
+  test "atom which is not a module can't be passed as argument to defoverridable" do
+    message = "cannot pass module :abc as argument to defoverridable/1 because it was not defined"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
+      defmodule Kernel.OverridableTest.Foo do
+        defoverridable :abc
+      end
+      """)
+    end
+
+    purge(Kernel.OverridableTest.Foo)
+  end
+
+  defp assert_compile_error(messages, fun) do
+    captured =
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        assert_raise CompileError, fun
+      end)
+
+    for message <- List.wrap(messages) do
+      assert captured =~ message
     end
   end
 end
diff --git a/lib/elixir/test/elixir/kernel/parallel_compiler_test.exs b/lib/elixir/test/elixir/kernel/parallel_compiler_test.exs
new file mode 100644
index 00000000000..1bd2c86d8eb
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/parallel_compiler_test.exs
@@ -0,0 +1,662 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+import PathHelpers
+
+defmodule Kernel.ParallelCompilerTest do
+  use ExUnit.Case
+  import ExUnit.CaptureIO
+
+  @no_warnings %{compile_warnings: [], runtime_warnings: []}
+
+  defp compile(files, opts \\ []) do
+    Kernel.ParallelCompiler.compile(files, [return_diagnostics: true] ++ opts)
+  end
+
+  defp purge(modules) do
+    Enum.map(modules, fn mod ->
+      :code.purge(mod)
+      :code.delete(mod)
+    end)
+  end
+
+  defp write_tmp(context, kv) do
+    dir = tmp_path(context)
+    File.rm_rf!(dir)
+    File.mkdir_p!(dir)
+
+    for {key, contents} <- kv do
+      path = Path.join(dir, "#{key}.ex")
+      File.write!(path, contents)
+      path
+    end
+  end
+
+  describe "compile" do
+    test "with profiling" do
+      fixtures =
+        write_tmp(
+          "profile_time",
+          bar: """
+          defmodule HelloWorld do
+          end
+          """
+        )
+
+      profile =
+        capture_io(:stderr, fn ->
+          assert {:ok, modules, @no_warnings} = compile(fixtures, profile: :time)
+
+          assert HelloWorld in modules
+        end)
+
+      assert profile =~
+               ~r"\[profile\] [\s\d]{6}ms compiling \+      0ms waiting while compiling .*tmp/profile_time/bar.ex"
+
+      assert profile =~ ~r"\[profile\] Finished compilation cycle of 1 modules in \d+ms"
+      assert profile =~ ~r"\[profile\] Finished group pass check of 1 modules in \d+ms"
+    after
+      purge([HelloWorld])
+    end
+
+    test "immediately loads modules when not writing them to disk" do
+      fixtures =
+        write_tmp(
+          "compile_loads",
+          will_be_loaded: """
+          defmodule WillBeLoaded do
+          end
+          true = Code.loaded?(WillBeLoaded)
+          """
+        )
+
+      assert {:ok, _modules, @no_warnings} = compile(fixtures)
+    end
+
+    test "lazily loads modules when writing them to disk" do
+      fixtures =
+        write_tmp(
+          "compile_lazy_loads",
+          will_be_lazy_loaded: """
+          defmodule WillBeLazyLoaded do
+          end
+          false = Code.loaded?(WillBeLazyLoaded)
+          {:error, _} = Code.ensure_loaded(WillBeLazyLoaded)
+          {:module, _} = Code.ensure_compiled(WillBeLazyLoaded)
+          """,
+          is_autoloaded: """
+          defmodule WillBeAutoLoaded do
+            @compile {:autoload, true}
+          end
+          true = Code.loaded?(WillBeAutoLoaded)
+          """
+        )
+
+      assert {:ok, _modules, @no_warnings} =
+               Kernel.ParallelCompiler.compile_to_path(fixtures, tmp_path("pcload"),
+                 return_diagnostics: true
+               )
+    end
+
+    test "solves dependencies between modules" do
+      fixtures =
+        write_tmp(
+          "parallel_compiler",
+          bar: """
+          defmodule BarParallel do
+          end
+
+          require FooParallel
+          IO.puts(FooParallel.message())
+          """,
+          foo: """
+          defmodule FooParallel do
+            # We use this ensure_compiled clause so both Foo and
+            # Bar block. Foo depends on Unknown and Bar depends on
+            # Foo. The compiler will see this dependency and first
+            # release Foo and then Bar, compiling with success.
+            {:error, _} = Code.ensure_compiled(Unknown)
+            def message, do: "message_from_foo"
+          end
+          """
+        )
+
+      assert capture_io(fn ->
+               assert {:ok, modules, @no_warnings} = compile(fixtures)
+               assert BarParallel in modules
+               assert FooParallel in modules
+             end) =~ "message_from_foo"
+    after
+      purge([FooParallel, BarParallel])
+    end
+
+    test "solves dependencies between structs" do
+      fixtures =
+        write_tmp(
+          "parallel_struct",
+          bar: """
+          defmodule BarStruct do
+            defstruct name: "", foo: %FooStruct{}
+          end
+          """,
+          foo: """
+          defmodule FooStruct do
+            defstruct name: ""
+            def bar?(%BarStruct{}), do: true
+          end
+          """
+        )
+
+      assert {:ok, modules, @no_warnings} = compile(fixtures)
+      assert [BarStruct, FooStruct] = Enum.sort(modules)
+    after
+      purge([FooStruct, BarStruct])
+    end
+
+    test "solves dependencies between structs in typespecs" do
+      fixtures =
+        write_tmp(
+          "parallel_typespec_struct",
+          bar: """
+          defmodule BarStruct do
+            defstruct name: ""
+            @type t :: %FooStruct{}
+          end
+          """,
+          foo: """
+          defmodule FooStruct do
+            defstruct name: ""
+            @type t :: %BarStruct{}
+          end
+          """
+        )
+
+      assert {:ok, modules, @no_warnings} = compile(fixtures)
+      assert [BarStruct, FooStruct] = Enum.sort(modules)
+    after
+      purge([FooStruct, BarStruct])
+    end
+
+    test "returns struct undefined error when local struct is undefined" do
+      [fixture] =
+        write_tmp(
+          "compile_struct",
+          undef: """
+          defmodule Undef do
+            def undef() do
+              %__MODULE__{}
+            end
+          end
+          """
+        )
+
+      expected_msg = "Undef.__struct__/1 is undefined, cannot expand struct Undef"
+
+      assert capture_io(:stderr, fn ->
+               assert {:error,
+                       [
+                         %{file: ^fixture, position: {3, 5}, message: msg},
+                         %{file: ^fixture, position: 0, message: compile_msg}
+                       ], @no_warnings} =
+                        compile([fixture])
+
+               assert msg =~ expected_msg
+               assert compile_msg =~ "cannot compile module Undef (errors have been logged)"
+             end) =~ expected_msg
+    end
+
+    test "returns error when fails to expand struct" do
+      [fixture] =
+        write_tmp(
+          "compile_struct_invalid_key",
+          undef: """
+          defmodule InvalidStructKey do
+            def invalid_struct_key() do
+              %Date{invalid_key: 2020}
+            end
+          end
+          """
+        )
+
+      expected_msg = "** (KeyError) key :invalid_key not found"
+
+      assert capture_io(:stderr, fn ->
+               assert {:error, [%{file: ^fixture, position: 3, message: msg}], @no_warnings} =
+                        compile([fixture])
+
+               assert msg =~ expected_msg
+             end) =~ expected_msg
+    end
+
+    test "does not crash with pending monitor message" do
+      {pid, ref} = spawn_monitor(fn -> :ok end)
+
+      [fixture] =
+        write_tmp(
+          "quick_example",
+          quick_example: """
+          defmodule QuickExample do
+          end
+          """
+        )
+
+      assert {:ok, [QuickExample], @no_warnings} = compile([fixture])
+      assert_received {:DOWN, ^ref, _, ^pid, :normal}
+    after
+      purge([QuickExample])
+    end
+
+    test "does not crash on external reports" do
+      [fixture] =
+        write_tmp(
+          "compile_quoted",
+          quick_example: """
+          defmodule CompileQuoted do
+            try do
+              Code.compile_quoted({:fn, [], [{:->, [], [[], quote(do: unknown_var)]}]})
+            rescue
+              _ -> :ok
+            end
+          end
+          """
+        )
+
+      assert capture_io(:stderr, fn ->
+               assert {:ok, [CompileQuoted], @no_warnings} = compile([fixture])
+             end) =~ "undefined variable \"unknown_var\""
+    after
+      purge([CompileQuoted])
+    end
+
+    test "does not hang on missing dependencies" do
+      [fixture] =
+        write_tmp(
+          "compile_does_not_hang",
+          with_behaviour_and_struct: """
+          # We need to ensure it won't block even after multiple calls.
+          # So we use both behaviour and struct expansion below.
+          defmodule WithBehaviourAndStruct do
+            # @behaviour will call ensure_compiled().
+            @behaviour :unknown
+            # Struct expansion calls it as well.
+            %ThisModuleWillNeverBeAvailable{}
+          end
+          """
+        )
+
+      expected_msg =
+        "ThisModuleWillNeverBeAvailable.__struct__/1 is undefined, cannot expand struct ThisModuleWillNeverBeAvailable"
+
+      assert capture_io(:stderr, fn ->
+               assert {:error,
+                       [
+                         %{file: ^fixture, position: {7, 3}, message: msg},
+                         %{file: ^fixture, position: 0, message: compile_msg}
+                       ], @no_warnings} =
+                        compile([fixture])
+
+               assert msg =~ expected_msg
+
+               assert compile_msg =~
+                        "cannot compile module WithBehaviourAndStruct (errors have been logged)"
+             end) =~ expected_msg
+    end
+
+    test "does not deadlock on missing dependencies" do
+      [missing_struct, depends_on] =
+        write_tmp(
+          "does_not_deadlock",
+          missing_struct: """
+          defmodule MissingStruct do
+            %ThisModuleWillNeverBeAvailable{}
+            def hello, do: :ok
+          end
+          """,
+          depends_on_missing_struct: """
+          MissingStruct.hello()
+          """
+        )
+
+      expected_msg =
+        "ThisModuleWillNeverBeAvailable.__struct__/1 is undefined, cannot expand struct ThisModuleWillNeverBeAvailable"
+
+      assert capture_io(:stderr, fn ->
+               assert {:error,
+                       [
+                         %{file: ^missing_struct, position: {2, 3}, message: msg},
+                         %{file: ^missing_struct, position: 0, message: compile_msg}
+                       ], @no_warnings} =
+                        compile([missing_struct, depends_on])
+
+               assert msg =~ expected_msg
+
+               assert compile_msg =~
+                        "cannot compile module MissingStruct (errors have been logged)"
+             end) =~ expected_msg
+    end
+
+    test "does not deadlock on missing import/struct dependencies" do
+      [missing_import, depends_on] =
+        write_tmp(
+          "import_and_structs",
+          missing_import: """
+          defmodule MissingStruct do
+            import Unknown.Module
+          end
+          """,
+          depends_on_missing_struct: """
+          %MissingStruct{}
+          """
+        )
+
+      expected_msg = "module Unknown.Module is not loaded and could not be found"
+
+      assert capture_io(:stderr, fn ->
+               assert {:error,
+                       [
+                         %{file: ^missing_import, position: {2, 3}, message: msg},
+                         %{file: ^missing_import, position: 0, message: compile_msg}
+                       ], @no_warnings} =
+                        compile([missing_import, depends_on])
+
+               assert msg =~ expected_msg
+
+               assert compile_msg =~
+                        "cannot compile module MissingStruct (errors have been logged)"
+             end) =~ expected_msg
+    end
+
+    test "handles deadlocks" do
+      [foo, bar] =
+        write_tmp(
+          "parallel_deadlock",
+          foo: """
+          defmodule FooDeadlock do
+            BarDeadlock.__info__(:module)
+          end
+          """,
+          bar: """
+          defmodule BarDeadlock do
+            %FooDeadlock{}
+          end
+          """
+        )
+
+      msg =
+        capture_io(:stderr, fn ->
+          fixtures = [foo, bar]
+          assert {:error, [bar_error, foo_error], @no_warnings} = compile(fixtures)
+
+          assert %{file: ^bar, position: 2, message: "deadlocked waiting on struct FooDeadlock"} =
+                   bar_error
+
+          assert %{file: ^foo, position: nil, message: "deadlocked waiting on module BarDeadlock"} =
+                   foo_error
+        end)
+
+      assert msg =~ "Compilation failed because of a deadlock between files."
+      assert msg =~ "parallel_deadlock/foo.ex => BarDeadlock"
+      assert msg =~ "parallel_deadlock/bar.ex => FooDeadlock"
+      assert msg =~ ~r"== Compilation error in file .+parallel_deadlock/foo\.ex =="
+      assert msg =~ "** (CompileError) deadlocked waiting on module BarDeadlock"
+      assert msg =~ ~r"== Compilation error in file .+parallel_deadlock/bar\.ex:2 =="
+      assert msg =~ "** (CompileError) deadlocked waiting on struct FooDeadlock"
+    end
+
+    test "does not deadlock from Code.ensure_compiled" do
+      [foo, bar] =
+        write_tmp(
+          "parallel_ensure_nodeadlock",
+          foo: """
+          defmodule FooCircular do
+            {:error, :unavailable} = Code.ensure_compiled(BarCircular)
+          end
+          """,
+          bar: """
+          defmodule BarCircular do
+            {:error, :unavailable} = Code.ensure_compiled(FooCircular)
+          end
+          """
+        )
+
+      assert {:ok, _modules, @no_warnings} = compile([foo, bar])
+      assert Enum.sort([FooCircular, BarCircular]) == [BarCircular, FooCircular]
+    after
+      purge([FooCircular, BarCircular])
+    end
+
+    test "handles pmap compilation" do
+      [foo, bar] =
+        write_tmp(
+          "async_compile",
+          foo: """
+          defmodule FooAsync do
+            true = Code.can_await_module_compilation?()
+
+            [BarAsync] =
+              Kernel.ParallelCompiler.pmap([:ok], fn :ok ->
+                true = Code.can_await_module_compilation?()
+                BarAsync.__info__(:module)
+              end)
+          end
+          """,
+          bar: """
+          defmodule BarAsync do
+            true = Code.can_await_module_compilation?()
+          end
+          """
+        )
+
+      capture_io(:stderr, fn ->
+        fixtures = [foo, bar]
+        assert {:ok, modules, @no_warnings} = compile(fixtures)
+        assert FooAsync in modules
+        assert BarAsync in modules
+      end)
+    after
+      purge([FooAsync, BarAsync])
+    end
+
+    test "handles pmap deadlocks" do
+      [foo, bar] =
+        write_tmp(
+          "async_deadlock",
+          foo: """
+          defmodule FooAsyncDeadlock do
+            Kernel.ParallelCompiler.pmap([:ok], fn :ok ->
+              BarAsyncDeadlock.__info__(:module)
+            end)
+          end
+          """,
+          bar: """
+          defmodule BarAsyncDeadlock do
+            FooAsyncDeadlock.__info__(:module)
+          end
+          """
+        )
+
+      capture_io(:stderr, fn ->
+        fixtures = [foo, bar]
+        assert {:error, [bar_error, foo_error], @no_warnings} = compile(fixtures)
+
+        assert %{
+                 file: ^bar,
+                 position: nil,
+                 message: "deadlocked waiting on module FooAsyncDeadlock"
+               } = bar_error
+
+        assert %{file: ^foo, position: nil, message: "deadlocked waiting on pmap [#PID<" <> _} =
+                 foo_error
+      end)
+    end
+
+    test "does not use incorrect line number when error originates in another file" do
+      File.mkdir_p!(tmp_path())
+
+      [a, b] =
+        write_tmp(
+          "error_line",
+          a: """
+          defmodule PCA do
+            def fun(arg), do: arg / 2
+          end
+          """,
+          b: """
+          defmodule PCB do
+            def fun(arg) do
+              PCA.fun(arg)
+              :ok
+            end
+          end
+          PCB.fun(:not_a_number)
+          """
+        )
+
+      capture_io(:stderr, fn ->
+        assert {:error, [%{file: ^b, position: 0, message: _}], _} = compile([a, b])
+      end)
+    end
+
+    test "gets both source and file on @file annotations" do
+      File.mkdir_p!(tmp_path())
+
+      [a] =
+        write_tmp(
+          "file_source",
+          a: """
+          defmodule FileAttr do
+            @file "unknown.foo.bar"
+            def fun, do: (unused = :ok)
+          end
+          """
+        )
+
+      capture_io(:stderr, fn ->
+        assert {:ok, [FileAttr], %{compile_warnings: [%{source: ^a, file: file, message: _}]}} =
+                 compile([a])
+
+        assert String.ends_with?(file, "unknown.foo.bar")
+        assert Path.type(file) == :absolute
+      end)
+    after
+      purge([FileAttr])
+    end
+
+    test "gets correct line number for UndefinedFunctionError" do
+      File.mkdir_p!(tmp_path())
+
+      [fixture] =
+        write_tmp("undef",
+          undef: """
+          defmodule UndefErrorLine do
+            Bogus.fun()
+          end
+          """
+        )
+
+      capture_io(:stderr, fn ->
+        assert {:error, [%{file: ^fixture, position: 2, message: _}], _} = compile([fixture])
+      end)
+    end
+
+    test "gets correct file+line+column number for SyntaxError" do
+      File.mkdir_p!(tmp_path())
+
+      [fixture] =
+        write_tmp("error",
+          error: """
+          raise SyntaxError, file: "foo/bar.ex", line: 3, column: 10
+          """
+        )
+
+      file = Path.absname("foo/bar.ex")
+
+      capture_io(:stderr, fn ->
+        assert {:error, [%{file: ^file, source: ^fixture, position: {3, 10}}], _} =
+                 compile([fixture])
+      end)
+    end
+
+    test "gets proper beam destinations from dynamic modules" do
+      fixtures =
+        write_tmp(
+          "dynamic",
+          dynamic: """
+          Module.create(Dynamic, quote(do: :ok), file: "dynamic.ex")
+          [_ | _] = :code.which(Dynamic)
+          """
+        )
+
+      assert {:ok, [Dynamic], @no_warnings} = compile(fixtures, dest: "sample")
+    after
+      purge([Dynamic])
+    end
+  end
+
+  describe "require" do
+    test "returns struct undefined error when local struct is undefined" do
+      [fixture] =
+        write_tmp(
+          "require_struct",
+          undef: """
+          defmodule Undef do
+            def undef() do
+              %__MODULE__{}
+            end
+          end
+          """
+        )
+
+      expected_msg = "Undef.__struct__/1 is undefined, cannot expand struct Undef"
+
+      assert capture_io(:stderr, fn ->
+               assert {:error,
+                       [
+                         %{file: ^fixture, position: {3, 5}, message: msg},
+                         %{file: ^fixture, position: 0, message: compile_msg}
+                       ], @no_warnings} =
+                        Kernel.ParallelCompiler.require([fixture], return_diagnostics: true)
+
+               assert msg =~ expected_msg
+               assert compile_msg =~ "cannot compile module Undef (errors have been logged)"
+             end) =~ expected_msg
+    end
+
+    test "does not hang on missing dependencies" do
+      [fixture] =
+        write_tmp(
+          "require_does_not_hang",
+          with_behaviour_and_struct: """
+          # We need to ensure it won't block even after multiple calls.
+          # So we use both behaviour and struct expansion below.
+          defmodule WithBehaviourAndStruct do
+            # @behaviour will call ensure_compiled().
+            @behaviour :unknown
+            # Struct expansion calls it as well.
+            %ThisModuleWillNeverBeAvailable{}
+          end
+          """
+        )
+
+      expected_msg =
+        "ThisModuleWillNeverBeAvailable.__struct__/1 is undefined, cannot expand struct ThisModuleWillNeverBeAvailable"
+
+      assert capture_io(:stderr, fn ->
+               assert {:error,
+                       [
+                         %{file: ^fixture, position: {7, 3}, message: msg},
+                         %{file: ^fixture, position: 0, message: compile_msg}
+                       ], @no_warnings} =
+                        Kernel.ParallelCompiler.require([fixture], return_diagnostics: true)
+
+               assert msg =~ expected_msg
+
+               assert compile_msg =~
+                        "cannot compile module WithBehaviourAndStruct (errors have been logged)"
+             end) =~ expected_msg
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/parser_test.exs b/lib/elixir/test/elixir/kernel/parser_test.exs
new file mode 100644
index 00000000000..8502a5a0b4d
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/parser_test.exs
@@ -0,0 +1,1677 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.ParserTest do
+  use ExUnit.Case, async: true
+
+  test "empty" do
+    assert Code.string_to_quoted!("") == {:__block__, [line: 1], []}
+    assert Code.string_to_quoted!("", columns: true) == {:__block__, [line: 1, column: 1], []}
+
+    assert Code.string_to_quoted!("  \n") == {:__block__, [line: 1], []}
+    assert Code.string_to_quoted!("  \n", columns: true) == {:__block__, [line: 1, column: 1], []}
+  end
+
+  describe "nullary ops" do
+    test "in expressions" do
+      assert parse!("..") == {:.., [line: 1], []}
+      assert parse!("...") == {:..., [line: 1], []}
+    end
+
+    test "in capture" do
+      assert parse!("&../0") == {:&, [line: 1], [{:/, [line: 1], [{:.., [line: 1], nil}, 0]}]}
+      assert parse!("&.../0") == {:&, [line: 1], [{:/, [line: 1], [{:..., [line: 1], nil}, 0]}]}
+    end
+
+    test "raises on ambiguous uses when also binary" do
+      assert_raise SyntaxError, ~r/syntax error before: do/, fn ->
+        parse!("if .. do end")
+      end
+    end
+  end
+
+  describe "unary ops" do
+    test "in keywords" do
+      assert parse!("f(!: :ok)") == {:f, [line: 1], [[!: :ok]]}
+      assert parse!("f @: :ok") == {:f, [line: 1], [[@: :ok]]}
+    end
+
+    test "in maps" do
+      assert parse!("%{+foo, bar => bat, ...baz}") ==
+               {:%{}, [line: 1],
+                [
+                  {:+, [line: 1], [{:foo, [line: 1], nil}]},
+                  {{:bar, [line: 1], nil}, {:bat, [line: 1], nil}},
+                  {:..., [line: 1], [{:baz, [line: 1], nil}]}
+                ]}
+    end
+
+    test "ambiguous ops" do
+      assert parse!("f -var") ==
+               {:f, [ambiguous_op: nil, line: 1], [{:-, [line: 1], [{:var, [line: 1], nil}]}]}
+
+      assert parse!("f -(var)") ==
+               {:f, [ambiguous_op: nil, line: 1], [{:-, [line: 1], [{:var, [line: 1], nil}]}]}
+
+      assert parse!("f +-var") ==
+               {:f, [{:ambiguous_op, nil}, {:line, 1}],
+                [{:+, [line: 1], [{:-, [line: 1], [{:var, [line: 1], nil}]}]}]}
+
+      assert parse!("f - var") ==
+               {:-, [line: 1], [{:f, [line: 1], nil}, {:var, [line: 1], nil}]}
+
+      assert parse!("f --var") ==
+               {:--, [line: 1], [{:f, [line: 1], nil}, {:var, [line: 1], nil}]}
+
+      assert parse!("(f ->var)") ==
+               [{:->, [line: 1], [[{:f, [line: 1], nil}], {:var, [line: 1], nil}]}]
+    end
+
+    test "ambiguous ops in keywords" do
+      assert parse!("f(+: :ok)") == {:f, [line: 1], [[+: :ok]]}
+      assert parse!("f +: :ok") == {:f, [line: 1], [[+: :ok]]}
+      assert parse!("f +:\n:ok") == {:f, [line: 1], [[+: :ok]]}
+    end
+  end
+
+  describe "ternary ops" do
+    test "root" do
+      assert parse!("1..2//3") == {:..//, [line: 1], [1, 2, 3]}
+      assert parse!("(1..2)//3") == {:..//, [line: 1], [1, 2, 3]}
+    end
+
+    test "with do-blocks" do
+      assert parse!("foo do end..bar do end//baz do end") == {
+               :..//,
+               [line: 1],
+               [
+                 {:foo, [line: 1], [[do: {:__block__, [line: 1], []}]]},
+                 {:bar, [line: 1], [[do: {:__block__, [line: 1], []}]]},
+                 {:baz, [line: 1], [[do: {:__block__, [line: 1], []}]]}
+               ]
+             }
+    end
+
+    test "with no parens" do
+      assert parse!("1..foo do end//bar bat") == {
+               :..//,
+               [line: 1],
+               [
+                 1,
+                 {:foo, [line: 1], [[do: {:__block__, [line: 1], []}]]},
+                 {:bar, [line: 1], [{:bat, [line: 1], nil}]}
+               ]
+             }
+    end
+
+    test "errors" do
+      msg =
+        "the range step operator (//) must immediately follow the range definition operator (..)"
+
+      assert_syntax_error([msg], "foo..bar baz//bat")
+      assert_syntax_error([msg], "foo++bar//bat")
+      assert_syntax_error([msg], "foo..(bar//bat)")
+    end
+  end
+
+  describe "\\\\ + newline" do
+    test "with ambiguous ops" do
+      assert parse!("f \\\n-var") ==
+               {:f, [ambiguous_op: nil, line: 1], [{:-, [line: 2], [{:var, [line: 2], nil}]}]}
+
+      assert parse!("f \\\n- var") ==
+               {:-, [line: 2], [{:f, [line: 1], nil}, {:var, [line: 2], nil}]}
+
+      assert parse!("f -\\\nvar") ==
+               {:-, [line: 1], [{:f, [line: 1], nil}, {:var, [line: 2], nil}]}
+
+      assert parse!("f -\\\n var") ==
+               {:-, [line: 1], [{:f, [line: 1], nil}, {:var, [line: 2], nil}]}
+    end
+
+    test "with capture" do
+      assert parse!("&..//\\\n/3") ==
+               {:&, [line: 1], [{:/, [line: 2], [{:..//, [line: 1], nil}, 3]}]}
+
+      assert parse!("&\\\n+/2") == {:&, [line: 1], [{:/, [line: 2], [{:+, [line: 2], nil}, 2]}]}
+      assert parse!("&\\\n//2") == {:&, [line: 1], [{:/, [line: 2], [{:/, [line: 2], nil}, 2]}]}
+      assert parse!("&\\\nor/2") == {:&, [line: 1], [{:/, [line: 2], [{:or, [line: 2], nil}, 2]}]}
+
+      assert parse!("&+\\\n/2") == {:&, [line: 1], [{:/, [line: 2], [{:+, [line: 1], nil}, 2]}]}
+      assert parse!("&/\\\n/2") == {:&, [line: 1], [{:/, [line: 2], [{:/, [line: 1], nil}, 2]}]}
+      assert parse!("&or\\\n/2") == {:&, [line: 1], [{:/, [line: 2], [{:or, [line: 1], nil}, 2]}]}
+
+      assert parse!("&+/\\\n2") == {:&, [line: 1], [{:/, [line: 1], [{:+, [line: 1], nil}, 2]}]}
+      assert parse!("&//\\\n2") == {:&, [line: 1], [{:/, [line: 1], [{:/, [line: 1], nil}, 2]}]}
+      assert parse!("&or/\\\n2") == {:&, [line: 1], [{:/, [line: 1], [{:or, [line: 1], nil}, 2]}]}
+    end
+  end
+
+  describe "identifier unicode normalization" do
+    test "stops at ascii codepoints" do
+      assert {:ok, {:ç, _, nil}} = Code.string_to_quoted("ç\n")
+      assert {:ok, {:\\, _, [{:ç, _, nil}, 1]}} = Code.string_to_quoted(~S"ç\\1")
+    end
+
+    test "nfc normalization is performed" do
+      # before elixir 1.14, non-nfc would error
+      #  non-nfc:        "ç" (code points 0x0063 0x0327)
+      #  nfc-normalized: "ç" (code points 0x00E7)
+      assert Code.eval_string("ç = 1; ç") == {1, [ç: 1]}
+    end
+
+    test "elixir's additional normalization is performed" do
+      # Common micro => Greek mu. See code formatter test too.
+      assert Code.eval_string("µs = 1; μs") == {1, [{:μs, 1}]}
+
+      # commented out: math symbols capability in elixir
+      # normalizations, to ensure that we *can* handle codepoints
+      # that are Common-script and non-ASCII
+      # assert Code.eval_string("_ℕ𝕩 = 1") == {1, [{:"_ℕ𝕩", 1}]}
+    end
+
+    test "handles graphemes inside quoted identifiers" do
+      string_to_quoted =
+        fn code ->
+          Code.string_to_quoted!(code,
+            token_metadata: true,
+            literal_encoder: &{:ok, {:__block__, &2, [&1]}},
+            emit_warnings: false
+          )
+        end
+
+      assert {
+               {:., _, [{:foo, _, nil}, :"➡️"]},
+               [no_parens: true, delimiter: ~S["], line: 1],
+               []
+             } = string_to_quoted.(~S|foo."➡️"|)
+
+      assert {
+               {:., _, [{:foo, _, nil}, :"➡️"]},
+               [no_parens: true, delimiter: ~S['], line: 1],
+               []
+             } = string_to_quoted.(~S|foo.'➡️'|)
+
+      assert {:__block__, [delimiter: ~S["], line: 1], [:"➡️"]} = string_to_quoted.(~S|:"➡️"|)
+
+      assert {:__block__, [delimiter: ~S['], line: 1], [:"➡️"]} = string_to_quoted.(~S|:'➡️'|)
+
+      assert {:__block__, [closing: [line: 1], line: 1],
+              [
+                [
+                  {{:__block__, [delimiter: ~S["], format: :keyword, line: 1], [:"➡️"]},
+                   {:x, [line: 1], nil}}
+                ]
+              ]} = string_to_quoted.(~S|["➡️": x]|)
+
+      assert {:__block__, [closing: [line: 1], line: 1],
+              [
+                [
+                  {{:__block__, [delimiter: ~S['], format: :keyword, line: 1], [:"➡️"]},
+                   {:x, [line: 1], nil}}
+                ]
+              ]} = string_to_quoted.(~S|['➡️': x]|)
+    end
+  end
+
+  describe "strings/sigils" do
+    test "delimiter information for sigils is included" do
+      string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: false)
+
+      assert parse!("~r/foo/") ==
+               {:sigil_r, [delimiter: "/", line: 1], [{:<<>>, [line: 1], ["foo"]}, []]}
+
+      assert string_to_quoted.("~r[foo]") ==
+               {:sigil_r, [delimiter: "[", line: 1], [{:<<>>, [line: 1], ["foo"]}, []]}
+
+      assert string_to_quoted.("~r\"foo\"") ==
+               {:sigil_r, [delimiter: "\"", line: 1], [{:<<>>, [line: 1], ["foo"]}, []]}
+
+      meta = [delimiter: "\"\"\"", line: 1]
+      args = {:sigil_S, meta, [{:<<>>, [indentation: 0, line: 1], ["sigil heredoc\n"]}, []]}
+      assert string_to_quoted.("~S\"\"\"\nsigil heredoc\n\"\"\"") == args
+
+      meta = [delimiter: "'''", line: 1]
+      args = {:sigil_S, meta, [{:<<>>, [indentation: 0, line: 1], ["sigil heredoc\n"]}, []]}
+      assert string_to_quoted.("~S'''\nsigil heredoc\n'''") == args
+    end
+
+    test "valid multi-letter sigils" do
+      string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: false)
+
+      assert string_to_quoted.("~REGEX/foo/") ==
+               {:sigil_REGEX, [delimiter: "/", line: 1], [{:<<>>, [line: 1], ["foo"]}, []]}
+
+      assert string_to_quoted.("~REGEX/foo/mods") ==
+               {:sigil_REGEX, [delimiter: "/", line: 1], [{:<<>>, [line: 1], ["foo"]}, ~c"mods"]}
+
+      assert string_to_quoted.("~REGEX[foo]") ==
+               {:sigil_REGEX, [delimiter: "[", line: 1], [{:<<>>, [line: 1], ["foo"]}, []]}
+
+      meta = [delimiter: "\"\"\"", line: 1]
+      args = {:sigil_MAT, meta, [{:<<>>, [indentation: 0, line: 1], ["1,2,3\n"]}, []]}
+      assert string_to_quoted.("~MAT\"\"\"\n1,2,3\n\"\"\"") == args
+
+      args = {:sigil_FOO1, meta, [{:<<>>, [indentation: 0, line: 1], ["1,2,3\n"]}, []]}
+      assert string_to_quoted.("~FOO1\"\"\"\n1,2,3\n\"\"\"") == args
+
+      args = {:sigil_BAR321, meta, [{:<<>>, [indentation: 0, line: 1], ["1,2,3\n"]}, []]}
+      assert string_to_quoted.("~BAR321\"\"\"\n1,2,3\n\"\"\"") == args
+
+      args = {:sigil_I18N, meta, [{:<<>>, [indentation: 0, line: 1], ["1,2,3\n"]}, []]}
+      assert string_to_quoted.("~I18N\"\"\"\n1,2,3\n\"\"\"") == args
+    end
+
+    test "invalid multi-letter sigils" do
+      msg =
+        ~r/invalid sigil name, it should be either a one-letter lowercase letter or an uppercase letter optionally followed by uppercase letters and digits/
+
+      assert_syntax_error(["nofile:1:1:", msg], "~Regex/foo/")
+
+      assert_syntax_error(["nofile:1:1:", msg], "~FOo1{bar]")
+
+      assert_syntax_error(["nofile:1:1:", msg], "~foo1{bar]")
+    end
+
+    test "sigil newlines" do
+      assert {:sigil_s, _, [{:<<>>, _, ["here\ndoc"]}, []]} =
+               Code.string_to_quoted!(~s|~s"here\ndoc"|)
+
+      assert {:sigil_s, _, [{:<<>>, _, ["here\r\ndoc"]}, []]} =
+               Code.string_to_quoted!(~s|~s"here\r\ndoc"|)
+    end
+
+    test "string newlines" do
+      assert Code.string_to_quoted!(~s|"here\ndoc"|) == "here\ndoc"
+      assert Code.string_to_quoted!(~s|"here\r\ndoc"|) == "here\r\ndoc"
+      assert Code.string_to_quoted!(~s|"here\\\ndoc"|) == "heredoc"
+      assert Code.string_to_quoted!(~s|"here\\\r\ndoc"|) == "heredoc"
+    end
+
+    test "heredoc newlines" do
+      assert Code.string_to_quoted!(~s|"""\nhere\ndoc\n"""|) == "here\ndoc\n"
+      assert Code.string_to_quoted!(~s|"""\r\nhere\r\ndoc\r\n"""|) == "here\r\ndoc\r\n"
+      assert Code.string_to_quoted!(~s|  """\n  here\n  doc\n  """|) == "here\ndoc\n"
+      assert Code.string_to_quoted!(~s|  """\r\n  here\r\n  doc\r\n  """|) == "here\r\ndoc\r\n"
+      assert Code.string_to_quoted!(~s|"""\nhere\\\ndoc\\\n"""|) == "heredoc"
+      assert Code.string_to_quoted!(~s|"""\r\nhere\\\r\ndoc\\\r\n"""|) == "heredoc"
+    end
+
+    test "heredoc indentation" do
+      meta = [delimiter: "'''", line: 1]
+      args = {:sigil_S, meta, [{:<<>>, [indentation: 2, line: 1], ["  sigil heredoc\n"]}, []]}
+      assert Code.string_to_quoted!("~S'''\n    sigil heredoc\n  '''") == args
+    end
+  end
+
+  describe "string_to_quoted/2" do
+    test "converts strings to quoted expressions" do
+      assert Code.string_to_quoted("1 + 2") == {:ok, {:+, [line: 1], [1, 2]}}
+
+      assert Code.string_to_quoted("a.1") ==
+               {:error, {[line: 1, column: 3], "syntax error before: ", "\"1\""}}
+    end
+  end
+
+  describe "string_to_quoted/2 and atom handling" do
+    test "ensures :existing_atoms_only" do
+      assert Code.string_to_quoted(":there_is_no_such_atom", existing_atoms_only: true) ==
+               {:error,
+                {[line: 1, column: 1], "unsafe atom does not exist: ", "there_is_no_such_atom"}}
+
+      assert Code.string_to_quoted("~UNKNOWN'foo bar'", existing_atoms_only: true) ==
+               {:error, {[line: 1, column: 1], "unsafe atom does not exist: ", "sigil_UNKNOWN"}}
+    end
+
+    test "encodes atoms" do
+      ref = make_ref()
+
+      encoder = fn atom, meta ->
+        assert atom == "there_is_no_such_atom"
+        assert meta[:line] == 1
+        assert meta[:column] == 1
+        {:ok, {:my, "atom", ref}}
+      end
+
+      assert {:ok, {:my, "atom", ^ref}} =
+               Code.string_to_quoted(":there_is_no_such_atom", static_atoms_encoder: encoder)
+    end
+
+    test "encodes vars" do
+      ref = make_ref()
+
+      encoder = fn atom, meta ->
+        assert atom == "there_is_no_such_var"
+        assert meta[:line] == 1
+        assert meta[:column] == 1
+        {:ok, {:my, "atom", ref}}
+      end
+
+      assert {:ok, {{:my, "atom", ^ref}, [line: 1], nil}} =
+               Code.string_to_quoted("there_is_no_such_var", static_atoms_encoder: encoder)
+    end
+
+    test "encodes quoted keyword keys" do
+      ref = make_ref()
+
+      encoder = fn atom, meta ->
+        assert atom == "there is no such key"
+        assert meta[:line] == 1
+        assert meta[:column] == 2
+        {:ok, {:my, "atom", ref}}
+      end
+
+      assert {:ok, [{{:my, "atom", ^ref}, true}]} =
+               Code.string_to_quoted(~S(["there is no such key": true]),
+                 static_atoms_encoder: encoder
+               )
+    end
+
+    test "encodes multi-letter sigils" do
+      ref = make_ref()
+
+      encoder = fn atom, meta ->
+        assert atom == "sigil_UNKNOWN"
+        assert meta[:line] == 1
+        assert meta[:column] == 1
+        {:ok, ref}
+      end
+
+      assert {:ok, {^ref, [delimiter: "'", line: 1], [{:<<>>, [line: 1], ["abc"]}, []]}} =
+               Code.string_to_quoted("~UNKNOWN'abc'", static_atoms_encoder: encoder)
+    end
+
+    test "addresses ambiguities" do
+      encoder = fn string, _meta -> {:ok, {:atom, string}} end
+
+      # We check a=1 for precedence issues with a!=1, make sure it works
+      assert Code.string_to_quoted!("a = 1", static_atoms_encoder: encoder)
+      assert Code.string_to_quoted!("a=1", static_atoms_encoder: encoder)
+    end
+
+    test "does not encode keywords" do
+      encoder = fn atom, _meta -> raise "shouldn't be invoked for #{atom}" end
+
+      assert {:ok, {:fn, [line: 1], [{:->, [line: 1], [[1], 2]}]}} =
+               Code.string_to_quoted("fn 1 -> 2 end", static_atoms_encoder: encoder)
+
+      assert {:ok, {:or, [line: 1], [true, false]}} =
+               Code.string_to_quoted("true or false", static_atoms_encoder: encoder)
+
+      encoder = fn atom, _meta -> {:ok, {:encoded, atom}} end
+
+      assert {:ok, [encoded: "true", encoded: "do", encoded: "and"]} =
+               Code.string_to_quoted("[:true, :do, :and]", static_atoms_encoder: encoder)
+
+      assert {:ok, [{{:encoded, "do"}, 1}, {{:encoded, "true"}, 2}, {{:encoded, "end"}, 3}]} =
+               Code.string_to_quoted("[do: 1, true: 2, end: 3]", static_atoms_encoder: encoder)
+    end
+
+    test "does not encode one-letter sigils" do
+      encoder = fn atom, _meta -> raise "shouldn't be invoked for #{atom}" end
+
+      assert {:ok, {:sigil_z, [{:delimiter, "'"}, {:line, 1}], [{:<<>>, [line: 1], ["foo"]}, []]}} =
+               Code.string_to_quoted("~z'foo'", static_atoms_encoder: encoder)
+
+      assert {:ok, {:sigil_Z, [{:delimiter, "'"}, {:line, 1}], [{:<<>>, [line: 1], ["foo"]}, []]}} =
+               Code.string_to_quoted("~Z'foo'", static_atoms_encoder: encoder)
+    end
+
+    test "returns errors on long atoms even when using static_atoms_encoder" do
+      atom = String.duplicate("a", 256)
+
+      encoder = fn atom, _meta -> {:ok, atom} end
+
+      assert Code.string_to_quoted(atom, static_atoms_encoder: encoder) ==
+               {:error,
+                {[line: 1, column: 1], "atom length must be less than system limit: ", atom}}
+    end
+
+    test "avoids crashes on invalid AST" do
+      encoder = fn atom, _meta -> {:ok, {:atom, [], [atom]}} end
+
+      assert {:error, {_, "missing terminator: )", ""}} =
+               Code.string_to_quoted("Module(", static_atoms_encoder: encoder)
+
+      assert {:error, {_, "syntax error before: ", "'('"}} =
+               Code.string_to_quoted("Module()", static_atoms_encoder: encoder)
+    end
+
+    test "may return errors" do
+      encoder = fn _atom, _meta ->
+        {:error, "Invalid atom name"}
+      end
+
+      assert {:error, {[line: 1, column: 1], "Invalid atom name: ", "there_is_no_such_atom"}} =
+               Code.string_to_quoted(":there_is_no_such_atom", static_atoms_encoder: encoder)
+
+      assert {:error, {[line: 1, column: 1], "Invalid atom name: ", "sigil_UNKNOWN"}} =
+               Code.string_to_quoted("~UNKNOWN'foo bar'", static_atoms_encoder: encoder)
+    end
+
+    test "may return tuples" do
+      encoder = fn string, _metadata ->
+        try do
+          {:ok, String.to_existing_atom(string)}
+        rescue
+          ArgumentError ->
+            {:ok, {:user_atom, string}}
+        end
+      end
+
+      assert {:ok, {:try, _, [[do: {:test, _, [{{:user_atom, "atom_does_not_exist"}, _, []}]}]]}} =
+               Code.string_to_quoted("try do: test(atom_does_not_exist())",
+                 static_atoms_encoder: encoder
+               )
+    end
+  end
+
+  describe "string_to_quoted/2 with :columns" do
+    test "includes column information" do
+      string_to_quoted = &Code.string_to_quoted(&1, columns: true)
+      assert string_to_quoted.("1 + 2") == {:ok, {:+, [line: 1, column: 3], [1, 2]}}
+
+      foo = {:foo, [line: 1, column: 1], nil}
+      bar = {:bar, [line: 1, column: 7], nil}
+      assert string_to_quoted.("foo + bar") == {:ok, {:+, [line: 1, column: 5], [foo, bar]}}
+
+      nfc_abba = [225, 98, 98, 224]
+      nfd_abba = [97, 769, 98, 98, 97, 768]
+      context = [line: 1, column: 8]
+      expr = "\"ábbà\" = 1"
+
+      assert string_to_quoted.(String.normalize(expr, :nfc)) ==
+               {:ok, {:=, context, [List.to_string(nfc_abba), 1]}}
+
+      assert string_to_quoted.(String.normalize(expr, :nfd)) ==
+               {:ok, {:=, context, [List.to_string(nfd_abba), 1]}}
+    end
+
+    test "not in" do
+      assert Code.string_to_quoted!("a not in b", columns: true) ==
+               {:not, [line: 1, column: 3],
+                [
+                  {:in, [line: 1, column: 7],
+                   [{:a, [line: 1, column: 1], nil}, {:b, [line: 1, column: 10], nil}]}
+                ]}
+
+      assert Code.string_to_quoted!("a not  in b", columns: true, token_metadata: true) ==
+               {:not, [line: 1, column: 3],
+                [
+                  {:in, [line: 1, column: 8],
+                   [{:a, [line: 1, column: 1], nil}, {:b, [line: 1, column: 11], nil}]}
+                ]}
+
+      assert Code.string_to_quoted!("a\nnot in b", columns: true, token_metadata: true) ==
+               {:not, [newlines: 1, line: 2, column: 1],
+                [
+                  {:in, [line: 2, column: 5],
+                   [{:a, [line: 1, column: 1], nil}, {:b, [line: 2, column: 8], nil}]}
+                ]}
+
+      assert Code.string_to_quoted!("a not in\nb", columns: true, token_metadata: true) ==
+               {:not, [newlines: 1, line: 1, column: 3],
+                [
+                  {:in, [line: 1, column: 7],
+                   [{:a, [line: 1, column: 1], nil}, {:b, [line: 2, column: 1], nil}]}
+                ]}
+
+      assert Code.string_to_quoted!("a\nnot in\nb", columns: true, token_metadata: true) ==
+               {:not, [newlines: 1, line: 2, column: 1],
+                [
+                  {:in, [line: 2, column: 5],
+                   [{:a, [line: 1, column: 1], nil}, {:b, [line: 3, column: 1], nil}]}
+                ]}
+    end
+
+    test "deprecated not/in" do
+      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               assert Code.string_to_quoted!("not a in b", columns: true) ==
+                        {:not, [line: 1, column: 1],
+                         [
+                           {:in, [line: 1, column: 7],
+                            [
+                              {:a, [line: 1, column: 5], nil},
+                              {:b, [line: 1, column: 10], nil}
+                            ]}
+                         ]}
+             end) =~ "not expr1 in expr2"
+
+      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               assert Code.string_to_quoted!("!a in b", columns: true) ==
+                        {:!, [line: 1, column: 1],
+                         [
+                           {:in, [line: 1, column: 4],
+                            [
+                              {:a, [line: 1, column: 2], nil},
+                              {:b, [line: 1, column: 7], nil}
+                            ]}
+                         ]}
+             end) =~ "!expr1 in expr2"
+    end
+
+    test "handles maps and structs" do
+      assert Code.string_to_quoted("%{}", columns: true) ==
+               {:ok, {:%{}, [line: 1, column: 1], []}}
+
+      assert Code.string_to_quoted("%:atom{}", columns: true) ==
+               {:ok, {:%, [line: 1, column: 1], [:atom, {:%{}, [line: 1, column: 7], []}]}}
+    end
+  end
+
+  describe "string_to_quoted/2 with :token_metadata" do
+    test "adds end_of_expression information to blocks" do
+      file = """
+      one();two()
+      three()
+
+      four()
+
+
+      five()
+      """
+
+      args = [
+        {:one,
+         [
+           end_of_expression: [newlines: 0, line: 1, column: 6],
+           closing: [line: 1, column: 5],
+           line: 1,
+           column: 1
+         ], []},
+        {:two,
+         [
+           end_of_expression: [newlines: 1, line: 1, column: 12],
+           closing: [line: 1, column: 11],
+           line: 1,
+           column: 7
+         ], []},
+        {:three,
+         [
+           end_of_expression: [newlines: 2, line: 2, column: 8],
+           closing: [line: 2, column: 7],
+           line: 2,
+           column: 1
+         ], []},
+        {:four,
+         [
+           end_of_expression: [newlines: 3, line: 4, column: 7],
+           closing: [line: 4, column: 6],
+           line: 4,
+           column: 1
+         ], []},
+        {:five,
+         [
+           end_of_expression: [newlines: 1, line: 7, column: 7],
+           closing: [line: 7, column: 6],
+           line: 7,
+           column: 1
+         ], []}
+      ]
+
+      assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==
+               {:__block__, [], args}
+    end
+
+    test "adds end_of_expression to the right hand side of ->" do
+      file = """
+      case true do
+        :foo -> bar(); two()
+        :baz -> bat()
+      end
+      """
+
+      assert Code.string_to_quoted!(file, token_metadata: true) ==
+               {:case,
+                [
+                  end_of_expression: [newlines: 1, line: 4],
+                  do: [line: 1],
+                  end: [line: 4],
+                  line: 1
+                ],
+                [
+                  true,
+                  [
+                    do: [
+                      {:->, [line: 2],
+                       [
+                         [:foo],
+                         {:__block__, [],
+                          [
+                            {:bar,
+                             [
+                               end_of_expression: [newlines: 0, line: 2],
+                               closing: [line: 2],
+                               line: 2
+                             ], []},
+                            {:two,
+                             [
+                               end_of_expression: [newlines: 1, line: 2],
+                               closing: [line: 2],
+                               line: 2
+                             ], []}
+                          ]}
+                       ]},
+                      {:->, [line: 3],
+                       [
+                         [:baz],
+                         {:bat,
+                          [
+                            end_of_expression: [newlines: 1, line: 3],
+                            closing: [line: 3],
+                            line: 3
+                          ], []}
+                       ]}
+                    ]
+                  ]
+                ]}
+    end
+
+    test "end of expression with literal" do
+      file = """
+      a do
+        d ->
+          (
+            b -> c
+          )
+      end
+      """
+
+      assert Code.string_to_quoted!(file,
+               token_metadata: true,
+               literal_encoder: &{:ok, {:__block__, &2, [&1]}}
+             ) ==
+               {:a,
+                [
+                  end_of_expression: [newlines: 1, line: 6],
+                  do: [line: 1],
+                  end: [line: 6],
+                  line: 1
+                ],
+                [
+                  [
+                    {{:__block__, [line: 1], [:do]},
+                     [
+                       {:->, [newlines: 1, line: 2],
+                        [
+                          [{:d, [line: 2], nil}],
+                          {:__block__,
+                           [
+                             end_of_expression: [newlines: 1, line: 5],
+                             newlines: 1,
+                             closing: [line: 5],
+                             line: 3
+                           ],
+                           [
+                             [
+                               {:->, [line: 4],
+                                [
+                                  [{:b, [line: 4], nil}],
+                                  {:c, [end_of_expression: [newlines: 1, line: 4], line: 4], nil}
+                                ]}
+                             ]
+                           ]}
+                        ]}
+                     ]}
+                  ]
+                ]}
+    end
+
+    test "does not add end of expression to ->" do
+      file = """
+      case true do
+        :foo -> :bar
+        :baz -> :bat
+      end\
+      """
+
+      assert Code.string_to_quoted!(file, token_metadata: true) ==
+               {:case, [do: [line: 1], end: [line: 4], line: 1],
+                [
+                  true,
+                  [
+                    do: [
+                      {:->, [line: 2], [[:foo], :bar]},
+                      {:->, [line: 3], [[:baz], :bat]}
+                    ]
+                  ]
+                ]}
+    end
+
+    test "adds pairing information" do
+      string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: true)
+
+      assert string_to_quoted.("foo") == {:foo, [line: 1], nil}
+      assert string_to_quoted.("foo()") == {:foo, [closing: [line: 1], line: 1], []}
+
+      assert string_to_quoted.("foo(\n)") ==
+               {:foo, [newlines: 1, closing: [line: 2], line: 1], []}
+
+      assert string_to_quoted.("%{\n}") == {:%{}, [newlines: 1, closing: [line: 2], line: 1], []}
+
+      assert string_to_quoted.("foo(\n) do\nend") ==
+               {:foo, [do: [line: 2], end: [line: 3], newlines: 1, closing: [line: 2], line: 1],
+                [[do: {:__block__, [line: 2], []}]]}
+
+      assert string_to_quoted.("foo(\n)(\n)") ==
+               {{:foo, [newlines: 1, closing: [line: 2], line: 1], []},
+                [newlines: 1, closing: [line: 3], line: 1], []}
+    end
+
+    test "adds opening and closing information for single-expression block" do
+      file = "1 + (2 + 3)"
+
+      assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==
+               {:+, [line: 1, column: 3],
+                [
+                  1,
+                  {:+,
+                   [
+                     parens: [closing: [line: 1, column: 11], line: 1, column: 5],
+                     line: 1,
+                     column: 8
+                   ], [2, 3]}
+                ]}
+
+      file = "1 + ((2 + 3))"
+
+      assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==
+               {:+, [line: 1, column: 3],
+                [
+                  1,
+                  {:+,
+                   [
+                     parens: [closing: [line: 1, column: 13], line: 1, column: 5],
+                     parens: [closing: [line: 1, column: 12], line: 1, column: 6],
+                     line: 1,
+                     column: 9
+                   ], [2, 3]}
+                ]}
+    end
+
+    test "adds opening and closing information for tuples" do
+      string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: true, columns: true)
+
+      assert string_to_quoted.("{}") ==
+               {:{}, [closing: [line: 1, column: 2], line: 1, column: 1], []}
+
+      assert string_to_quoted.("{123}") ==
+               {:{}, [closing: [line: 1, column: 5], line: 1, column: 1], [123]}
+
+      assert string_to_quoted.("x.{}") ==
+               {{:., [line: 1, column: 2], [{:x, [line: 1, column: 1], nil}, :{}]},
+                [closing: [line: 1, column: 4], line: 1, column: 2], []}
+
+      assert string_to_quoted.("x.{123}") ==
+               {{:., [line: 1, column: 2], [{:x, [line: 1, column: 1], nil}, :{}]},
+                [closing: [line: 1, column: 7], line: 1, column: 2], [123]}
+    end
+
+    test "adds opening and closing information for empty block" do
+      string_to_quoted =
+        &Code.string_to_quoted!(&1, token_metadata: true, columns: true, emit_warnings: false)
+
+      file = "()"
+
+      assert string_to_quoted.(file) ==
+               {:__block__, [parens: [closing: [line: 1, column: 2], line: 1, column: 1]], []}
+
+      file = "(())"
+
+      assert string_to_quoted.(file) ==
+               {:__block__,
+                [
+                  parens: [closing: [line: 1, column: 4], line: 1, column: 1],
+                  parens: [closing: [line: 1, column: 3], line: 1, column: 2]
+                ], []}
+
+      file = """
+      (
+        # Foo
+        (
+          # Bar
+        )
+      )
+      """
+
+      assert string_to_quoted.(file) ==
+               {:__block__,
+                [
+                  end_of_expression: [newlines: 1, line: 6, column: 2],
+                  parens: [closing: [line: 6, column: 1], line: 1, column: 1],
+                  end_of_expression: [newlines: 1, line: 5, column: 4],
+                  parens: [closing: [line: 5, column: 3], line: 3, column: 3]
+                ], []}
+    end
+
+    test "adds opening and closing information for stab arguments" do
+      file = "fn () -> x end "
+
+      assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==
+               {:fn, [closing: [line: 1, column: 12], line: 1, column: 1],
+                [
+                  {:->,
+                   [
+                     parens: [closing: [line: 1, column: 5], line: 1, column: 4],
+                     line: 1,
+                     column: 7
+                   ], [[], {:x, [line: 1, column: 10], nil}]}
+                ]}
+
+      file = "fn (x, y) -> x end "
+
+      assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==
+               {
+                 :fn,
+                 [{:closing, [line: 1, column: 16]}, {:line, 1}, {:column, 1}],
+                 [
+                   {:->,
+                    [
+                      parens: [closing: [line: 1, column: 9], line: 1, column: 4],
+                      line: 1,
+                      column: 11
+                    ],
+                    [
+                      [{:x, [line: 1, column: 5], nil}, {:y, [line: 1, column: 8], nil}],
+                      {:x, [line: 1, column: 14], nil}
+                    ]}
+                 ]
+               }
+
+      file = "if true do (x, y) -> x end"
+
+      assert Code.string_to_quoted!(file, token_metadata: true, columns: true) ==
+               {
+                 :if,
+                 [
+                   {:do, [line: 1, column: 9]},
+                   {:end, [line: 1, column: 24]},
+                   {:line, 1},
+                   {:column, 1}
+                 ],
+                 [
+                   true,
+                   [
+                     do: [
+                       {:->,
+                        [
+                          parens: [closing: [line: 1, column: 17], line: 1, column: 12],
+                          line: 1,
+                          column: 19
+                        ],
+                        [
+                          [{:x, [line: 1, column: 13], nil}, {:y, [line: 1, column: 16], nil}],
+                          {:x, [line: 1, column: 22], nil}
+                        ]}
+                     ]
+                   ]
+                 ]
+               }
+    end
+
+    test "with :literal_encoder" do
+      opts = [literal_encoder: &{:ok, {:__block__, &2, [&1]}}, token_metadata: true]
+      string_to_quoted = &Code.string_to_quoted!(&1, opts)
+
+      assert string_to_quoted.(~s("one")) == {:__block__, [delimiter: "\"", line: 1], ["one"]}
+      assert string_to_quoted.("?é") == {:__block__, [token: "?é", line: 1], [233]}
+      assert string_to_quoted.("0b10") == {:__block__, [token: "0b10", line: 1], [2]}
+      assert string_to_quoted.("12") == {:__block__, [token: "12", line: 1], [12]}
+      assert string_to_quoted.("0o123") == {:__block__, [token: "0o123", line: 1], [83]}
+      assert string_to_quoted.("0xEF") == {:__block__, [token: "0xEF", line: 1], [239]}
+      assert string_to_quoted.("12.3") == {:__block__, [token: "12.3", line: 1], [12.3]}
+      assert string_to_quoted.("nil") == {:__block__, [line: 1], [nil]}
+      assert string_to_quoted.(":one") == {:__block__, [line: 1], [:one]}
+
+      assert string_to_quoted.("true") == {:__block__, [line: 1], [true]}
+      assert string_to_quoted.(":true") == {:__block__, [format: :atom, line: 1], [true]}
+
+      assert string_to_quoted.("[one: :two]") == {
+               :__block__,
+               [{:closing, [line: 1]}, {:line, 1}],
+               [
+                 [
+                   {{:__block__, [format: :keyword, line: 1], [:one]},
+                    {:__block__, [line: 1], [:two]}}
+                 ]
+               ]
+             }
+
+      assert string_to_quoted.("[1]") ==
+               {:__block__, [closing: [line: 1], line: 1],
+                [[{:__block__, [token: "1", line: 1], [1]}]]}
+
+      assert string_to_quoted.(~s("""\nhello\n""")) ==
+               {:__block__, [delimiter: ~s["""], indentation: 0, line: 1], ["hello\n"]}
+
+      assert string_to_quoted.(~s[fn (1) -> "hello" end]) ==
+               {:fn, [closing: [line: 1], line: 1],
+                [
+                  {:->, [line: 1],
+                   [
+                     [
+                       {:__block__,
+                        [
+                          parens: [closing: [line: 1], line: 1],
+                          token: "1",
+                          line: 1
+                        ], [1]}
+                     ],
+                     {:__block__, [delimiter: "\"", line: 1], ["hello"]}
+                   ]}
+                ]}
+
+      assert string_to_quoted.("(1)") ==
+               {:__block__, [parens: [closing: [line: 1], line: 1], token: "1", line: 1], [1]}
+    end
+
+    test "adds identifier_location for qualified identifiers" do
+      string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: true, columns: true)
+
+      assert string_to_quoted.("foo.\nbar") ==
+               {{:., [line: 1, column: 4],
+                 [
+                   {:foo, [line: 1, column: 1], nil},
+                   :bar
+                 ]}, [no_parens: true, line: 2, column: 1], []}
+
+      assert string_to_quoted.("foo\n.\nbar") ==
+               {{:., [line: 2, column: 1],
+                 [
+                   {:foo, [line: 1, column: 1], nil},
+                   :bar
+                 ]}, [no_parens: true, line: 3, column: 1], []}
+
+      assert string_to_quoted.(~s[Foo.\nbar(1)]) ==
+               {{:., [line: 1, column: 4],
+                 [
+                   {:__aliases__, [last: [line: 1, column: 1], line: 1, column: 1], [:Foo]},
+                   :bar
+                 ]}, [closing: [line: 2, column: 6], line: 2, column: 1], [1]}
+    end
+
+    test "adds metadata for the last alias segment" do
+      string_to_quoted = &Code.string_to_quoted!(&1, token_metadata: true)
+
+      assert string_to_quoted.("Foo") == {:__aliases__, [last: [line: 1], line: 1], [:Foo]}
+
+      assert string_to_quoted.("Foo.\nBar\n.\nBaz") ==
+               {:__aliases__, [last: [line: 4], line: 1], [:Foo, :Bar, :Baz]}
+
+      assert string_to_quoted.("foo.\nBar\n.\nBaz") ==
+               {:__aliases__, [last: [line: 4], line: 1], [{:foo, [line: 1], nil}, :Bar, :Baz]}
+    end
+
+    test "adds metadata about assoc operator position in maps" do
+      opts = [
+        literal_encoder: &{:ok, {:__block__, &2, [&1]}},
+        token_metadata: true,
+        columns: true
+      ]
+
+      string_to_quoted = &Code.string_to_quoted!(&1, opts)
+
+      file = "%{:key => 1, {} => {}}"
+
+      assert string_to_quoted.(file) ==
+               {
+                 :%{},
+                 [closing: [line: 1, column: 22], line: 1, column: 1],
+                 [
+                   {{:__block__, [assoc: [line: 1, column: 8], line: 1, column: 3], [:key]},
+                    {:__block__, [token: "1", line: 1, column: 11], [1]}},
+                   {
+                     {:{},
+                      [
+                        assoc: [line: 1, column: 17],
+                        closing: [line: 1, column: 15],
+                        line: 1,
+                        column: 14
+                      ], []},
+                     {:{}, [closing: [line: 1, column: 21], line: 1, column: 20], []}
+                   }
+                 ]
+               }
+    end
+  end
+
+  describe "syntax errors" do
+    test "invalid heredoc start" do
+      assert_syntax_error(
+        [
+          "nofile:1:4:",
+          ~r/heredoc allows only whitespace characters followed by a new line after opening \"\"\"/
+        ],
+        ~c"\"\"\"bar\n\"\"\""
+      )
+    end
+
+    test "invalid fn" do
+      assert_syntax_error(
+        ["nofile:1:1:", "expected anonymous functions to be defined with -> inside: 'fn'"],
+        ~c"fn 1 end"
+      )
+
+      assert_syntax_error(
+        ["nofile:2:", "unexpected operator ->. If you want to define multiple clauses,"],
+        ~c"fn 1\n2 -> 3 end"
+      )
+    end
+
+    test "invalid token" do
+      assert_syntax_error(
+        ["nofile:1:1:", ~s/unexpected token: "#{"\u3164"}" (column 1, code point U+3164)/],
+        ~c"ㅤ = 1"
+      )
+
+      assert_syntax_error(
+        ["nofile:1:7:", ~s/unexpected token: "#{"\u200B"}" (column 7, code point U+200B)/],
+        ~c"[foo: \u200B]\noops"
+      )
+
+      assert_syntax_error(
+        ["nofile:1:1:", ~s/unexpected token: carriage return (column 1, code point U+000D)/],
+        ~c"\r"
+      )
+    end
+
+    test "invalid bidi in source" do
+      assert_syntax_error(
+        ["nofile:1:1:", ~s/invalid bidirectional formatting character in comment: \\u202A/],
+        ~c"# This is a \u202A"
+      )
+
+      assert_syntax_error(
+        ["nofile:1:6:", "invalid bidirectional formatting character in comment: \\u202A"],
+        ~c"foo. # This is a \u202A"
+      )
+
+      assert_syntax_error(
+        [
+          "nofile:1:12:",
+          "invalid bidirectional formatting character in string: \\u202A. If you want to use such character, use it in its escaped \\u202A form instead"
+        ],
+        ~c"\"this is a \u202A\""
+      )
+
+      assert_syntax_error(
+        [
+          "nofile:1:13:",
+          "invalid bidirectional formatting character in string: \\u202A. If you want to use such character, use it in its escaped \\u202A form instead"
+        ],
+        ~c"\"this is a \\\u202A\""
+      )
+    end
+
+    test "invalid newline in source" do
+      assert_syntax_error(
+        ["nofile:1:1:", ~s/invalid line break character in comment: \\u2028/],
+        ~c"# This is a \u2028"
+      )
+
+      assert_syntax_error(
+        ["nofile:1:6:", "invalid line break character in comment: \\u2028"],
+        ~c"foo. # This is a \u2028"
+      )
+
+      assert_syntax_error(
+        [
+          "nofile:1:12:",
+          "invalid line break character in string: \\u2028. If you want to use such character, use it in its escaped \\u2028 form instead"
+        ],
+        ~c"\"this is a \u2028\""
+      )
+
+      assert_syntax_error(
+        [
+          "nofile:1:13:",
+          "invalid line break character in string: \\u2028. If you want to use such character, use it in its escaped \\u2028 form instead"
+        ],
+        ~c"\"this is a \\\u2028\""
+      )
+    end
+
+    test "reserved tokens" do
+      assert_syntax_error(["nofile:1:1:", "reserved token: __aliases__"], ~c"__aliases__")
+      assert_syntax_error(["nofile:1:1:", "reserved token: __block__"], ~c"__block__")
+    end
+
+    test "invalid alias terminator" do
+      assert_syntax_error(["nofile:1:4:", "unexpected ( after alias Foo"], ~c"Foo()")
+    end
+
+    test "invalid quoted token" do
+      assert_syntax_error(
+        ["nofile:1:9:", "syntax error before: \"world\""],
+        ~c"\"hello\" \"world\""
+      )
+
+      assert_syntax_error(
+        ["nofile:1:3:", "syntax error before: 'Foobar'"],
+        ~c"1 Foobar"
+      )
+
+      assert_syntax_error(
+        ["nofile:1:5:", "syntax error before: foo"],
+        ~c"Foo.:foo"
+      )
+
+      assert_syntax_error(
+        ["nofile:1:5:", "syntax error before: \"foo\""],
+        ~c"Foo.:\"foo\#{:bar}\""
+      )
+
+      assert_syntax_error(
+        ["nofile:1:5:", "syntax error before: \""],
+        ~c"Foo.:\"\#{:bar}\""
+      )
+    end
+
+    test "invalid identifier" do
+      message =
+        &["nofile:1:1:", ~s/invalid character "@" (code point U+0040) in identifier: #{&1}/]
+
+      assert_syntax_error(message.("foo@"), ~c"foo@")
+      assert_syntax_error(message.("foo@"), ~c"foo@ ")
+      assert_syntax_error(message.("foo@bar"), ~c"foo@bar")
+
+      message =
+        &["nofile:1:1:", "invalid character \"@\" (code point U+0040) in alias: #{&1}"]
+
+      assert_syntax_error(message.("Foo@"), ~c"Foo@")
+      assert_syntax_error(message.("Foo@bar"), ~c"Foo@bar")
+
+      message =
+        [
+          "nofile:1:1:",
+          ~s/invalid character "!" (code point U+0021) in alias (only ASCII characters, without punctuation, are allowed): Foo!/
+        ]
+
+      assert_syntax_error(message, ~c"Foo!")
+
+      message =
+        [
+          "nofile:1:1:",
+          ~s/invalid character "?" (code point U+003F) in alias (only ASCII characters, without punctuation, are allowed): Foo?/
+        ]
+
+      assert_syntax_error(message, ~c"Foo?")
+
+      message =
+        [
+          "nofile:1:1:",
+          ~s/invalid character "ó" (code point U+00F3) in alias (only ASCII characters, without punctuation, are allowed): Foó/
+        ]
+
+      assert_syntax_error(message, ~c"Foó")
+
+      # token suggestion heuristic:
+      #  "for foO𝚳, NFKC isn't enough because 𝚳 nfkc's to Greek Μ, would be mixed script.
+      #   however the 'confusability skeleton' for that token produces an all-Latin foOM
+      #   and would tokenize -- so suggest that, in case that's what they want"
+      message = [
+        "Codepoint failed identifier tokenization, but a simpler form was found.",
+        "Got:",
+        ~s/"foO𝚳" (code points 0x00066 0x0006F 0x0004F 0x1D6B3)/,
+        "Hint: You could write the above in a similar way that is accepted by Elixir:",
+        ~s/"foOM" (code points 0x00066 0x0006F 0x0004F 0x0004D)/,
+        "See https://hexdocs.pm/elixir/unicode-syntax.html for more information."
+      ]
+
+      assert_syntax_error(message, ~c"foO𝚳")
+
+      # token suggestion heuristic:
+      #  "for fooی𝚳, both NKFC and confusability would result in mixed scripts,
+      #   because the Farsi letter is confusable with a different Arabic letter.
+      #   Well, can't fix it all at once -- let's check for a suggestion just on
+      #   the one codepoint that triggered this, the 𝚳 -- that would at least
+      #   nudge them forwards."
+      message = [
+        "Elixir expects unquoted Unicode atoms, variables, and calls to use allowed codepoints and to be in NFC form.",
+        "Got:",
+        ~s/"𝚳" (code points 0x1D6B3)/,
+        "Hint: You could write the above in a compatible format that is accepted by Elixir:",
+        ~s/"Μ" (code points 0x0039C)/,
+        "See https://hexdocs.pm/elixir/unicode-syntax.html for more information."
+      ]
+
+      assert_syntax_error(message, ~c"fooی𝚳")
+    end
+
+    test "keyword missing space" do
+      msg = ["nofile:1:1:", "keyword argument must be followed by space after: foo:"]
+
+      assert_syntax_error(msg, "foo:bar")
+      assert_syntax_error(msg, "foo:+")
+      assert_syntax_error(msg, "foo:+1")
+    end
+
+    test "invalid keyword list in tuple/binary" do
+      assert_syntax_error(
+        ["unexpected keyword list inside tuple"],
+        ~c"{foo: :bar}"
+      )
+
+      assert_syntax_error(
+        ["unexpected keyword list inside tuple"],
+        ~c"{foo: :bar, baz: :bar}"
+      )
+
+      assert_syntax_error(
+        ["unexpected keyword list inside bitstring"],
+        ~c"<<foo: :bar, baz: :bar>>"
+      )
+    end
+
+    test "expression after keyword lists" do
+      assert_syntax_error(
+        ["unexpected expression after keyword list"],
+        ~c"call foo: 1, :bar"
+      )
+
+      assert_syntax_error(
+        ["unexpected expression after keyword list"],
+        ~c"call(foo: 1, :bar)"
+      )
+
+      assert_syntax_error(
+        ["unexpected expression after keyword list"],
+        ~c"[foo: 1, :bar]"
+      )
+
+      assert_syntax_error(
+        ["unexpected expression after keyword list"],
+        ~c"%{foo: 1, :bar => :bar}"
+      )
+    end
+
+    test "syntax errors include formatted snippet" do
+      message = ["nofile:1:5:", "syntax error before:", "1 + * 3", "^"]
+      assert_syntax_error(message, "1 + * 3")
+    end
+
+    test "invalid map start" do
+      assert_syntax_error(
+        ["nofile:1:7:", "expected %{ to define a map, got: %["],
+        "{:ok, %[], %{}}"
+      )
+
+      assert_syntax_error(
+        ["nofile:1:3:", "unexpected space between % and {"],
+        "% {1, 2, 3}"
+      )
+    end
+
+    test "invalid access" do
+      msg = ["nofile:1:6:", "too many arguments when accessing a value"]
+      assert_syntax_error(msg, "foo[1, 2]")
+      assert_syntax_error(msg, "foo[1, 2, 3]")
+      assert_syntax_error(msg, "foo[1, 2, 3,]")
+    end
+
+    test "unexpected end" do
+      assert_syntax_error(["nofile:1:3:", "unexpected reserved word: end"], ~c"1 end")
+
+      assert_syntax_error(
+        [
+          "hint:",
+          "the \"end\" on line 2 may not have a matching \"do\" defined before it (based on indentation)"
+        ],
+        ~c"""
+        defmodule MyApp do
+          def one end
+          def two do end
+        end
+        """
+      )
+
+      assert_syntax_error(
+        [
+          "hint:",
+          "the \"end\" on line 3 may not have a matching \"do\" defined before it (based on indentation)"
+        ],
+        ~c"""
+        defmodule MyApp do
+          def one
+          end
+
+          def two do
+          end
+        end
+        """
+      )
+
+      assert_syntax_error(
+        [
+          "hint:",
+          "the \"end\" on line 6 may not have a matching \"do\" defined before it (based on indentation)"
+        ],
+        ~c"""
+        defmodule MyApp do
+          def one do
+          end
+
+          def two
+          end
+        end
+        """
+      )
+    end
+
+    test "invalid keywords" do
+      assert_syntax_error(
+        ["nofile:1:2:", "syntax error before: '.'"],
+        ~c"+.foo"
+      )
+
+      assert_syntax_error(
+        ["nofile:1:1:", "syntax error before: after. \"after\" is a reserved word"],
+        ~c"after = 1"
+      )
+    end
+
+    test "before sigil" do
+      msg = &["nofile:1:9:", "syntax error before: sigil ~s starting with content '#{&1}'"]
+
+      assert_syntax_error(msg.("bar baz"), ~c"~s(foo) ~s(bar baz)")
+      assert_syntax_error(msg.(""), ~c"~s(foo) ~s()")
+      assert_syntax_error(msg.("bar "), ~c"~s(foo) ~s(bar \#{:baz})")
+      assert_syntax_error(msg.(""), ~c"~s(foo) ~s(\#{:bar} baz)")
+    end
+
+    test "invalid do" do
+      assert_syntax_error(
+        ["nofile:1:10:", "unexpected reserved word: do."],
+        ~c"if true, do\n"
+      )
+
+      assert_syntax_error(["nofile:1:9:", "unexpected keyword: do:."], ~c"if true do:\n")
+    end
+
+    test "invalid parens call" do
+      msg =
+        [
+          "nofile:1:5:",
+          "unexpected parentheses",
+          "If you are making a function call, do not insert spaces between the function name and the opening parentheses.",
+          "Syntax error before: '\('"
+        ]
+
+      assert_syntax_error(msg, ~c"foo (hello, world)")
+    end
+
+    test "invalid nested no parens call" do
+      msg = ["nofile:1:", "unexpected comma. Parentheses are required to solve ambiguity"]
+
+      assert_syntax_error(msg, ~c"[foo 1, 2]")
+      assert_syntax_error(msg, ~c"[foo bar 1, 2]")
+      assert_syntax_error(msg, ~c"[do: foo 1, 2]")
+      assert_syntax_error(msg, ~c"foo(do: bar 1, 2)")
+      assert_syntax_error(msg, ~c"{foo 1, 2}")
+      assert_syntax_error(msg, ~c"{foo bar 1, 2}")
+      assert_syntax_error(msg, ~c"foo 1, foo 2, 3")
+      assert_syntax_error(msg, ~c"foo 1, @bar 3, 4")
+      assert_syntax_error(msg, ~c"foo 1, 2 + bar 3, 4")
+      assert_syntax_error(msg, ~c"foo(1, foo 2, 3)")
+
+      interpret = fn x -> Macro.to_string(Code.string_to_quoted!(x)) end
+      assert interpret.("f 1 + g h 2, 3") == "f(1 + g(h(2, 3)))"
+
+      assert interpret.("assert [] = TestRepo.all from p in Post, where: p.title in ^[]") ==
+               "assert [] = TestRepo.all(from(p in Post, where: p.title in ^[]))"
+    end
+
+    test "invalid atom dot alias" do
+      msg =
+        [
+          "nofile:1:6:",
+          "atom cannot be followed by an alias. If the '.' was meant to be " <>
+            "part of the atom's name, the atom name must be quoted. Syntax error before: '.'"
+        ]
+
+      assert_syntax_error(msg, ~c":foo.Bar")
+      assert_syntax_error(msg, ~c":\"+\".Bar")
+    end
+
+    test "invalid map/struct" do
+      assert_syntax_error(["nofile:1:15:", "syntax error before: '}'"], ~c"%{foo bar, baz}")
+      assert_syntax_error(["nofile:1:8:", "syntax error before: '{'"], ~c"%{a, b}{a: :b}")
+    end
+
+    test "mismatching delimiters" do
+      assert_mismatched_delimiter_error(
+        [
+          "nofile:1:9:",
+          "unexpected token:",
+          "└ unclosed delimiter",
+          "└ mismatched closing delimiter"
+        ],
+        ~c"fn a -> )"
+      )
+
+      assert_mismatched_delimiter_error(
+        [
+          "nofile:1:16:",
+          "unexpected token:",
+          "└ unclosed delimiter",
+          "└ mismatched closing delimiter"
+        ],
+        ~c"defmodule A do ]"
+      )
+
+      assert_mismatched_delimiter_error(
+        [
+          "nofile:1:9:",
+          "unexpected token:",
+          "└ unclosed delimiter",
+          "└ mismatched closing delimiter"
+        ],
+        ~c"(1, 2, 3}"
+      )
+
+      assert_mismatched_delimiter_error(
+        [
+          "nofile:1:14:",
+          "unexpected reserved word:",
+          "└ unclosed delimiter",
+          "└ mismatched closing delimiter"
+        ],
+        ~c"<<1, 2, 3, 4 end"
+      )
+    end
+
+    test "invalid interpolation" do
+      assert_mismatched_delimiter_error(
+        [
+          "nofile:1:17:",
+          "unexpected token:",
+          "└ unclosed delimiter",
+          "└ mismatched closing delimiter"
+        ],
+        ~c"\"foo\#{case 1 do )}bar\""
+      )
+
+      assert_mismatched_delimiter_error(
+        [
+          "nofile:8:3:",
+          "unexpected token: )",
+          "└ unclosed delimiter",
+          "└ mismatched closing delimiter"
+        ],
+        ~c"""
+        defmodule MyApp do
+          (
+            def one do
+            # end
+
+            def two do
+            end
+          )
+        end
+        """
+      )
+    end
+
+    test "invalid end of expression" do
+      # All valid examples
+      Code.eval_quoted(~c"""
+      1;
+      2;
+      3
+
+      (;)
+      (;1)
+      (1;)
+      (1; 2)
+
+      fn -> 1; 2 end
+      fn -> ; end
+
+      if true do
+        ;
+      end
+
+      try do
+        ;
+      catch
+        _, _ -> ;
+      after
+        ;
+      end
+      """)
+
+      # All invalid examples
+      assert_syntax_error(["nofile:1:3:", "syntax error before: ';'"], ~c"1+;\n2")
+
+      assert_syntax_error(["nofile:1:8:", "syntax error before: ';'"], ~c"max(1, ;2)")
+    end
+
+    test "invalid new line" do
+      assert_syntax_error(
+        [
+          "nofile:3:6:",
+          "unexpectedly reached end of line. The current expression is invalid or incomplete",
+          "baz",
+          "^"
+        ],
+        ~c"if true do\n  foo = [],\n  baz\nend"
+      )
+    end
+
+    test "invalid \"fn do expr end\"" do
+      assert_syntax_error(
+        [
+          "nofile:1:4:",
+          "unexpected reserved word: do. Anonymous functions are written as:",
+          "fn pattern -> expression end",
+          "Please remove the \"do\" keyword",
+          "fn do :ok end",
+          "^"
+        ],
+        ~c"fn do :ok end"
+      )
+    end
+
+    test "characters literal are printed correctly in syntax errors" do
+      assert_syntax_error(["nofile:1:5:", "syntax error before: ?a"], ~c":ok ?a")
+      assert_syntax_error(["nofile:1:5:", "syntax error before: ?\\s"], ~c":ok ?\\s")
+      assert_syntax_error(["nofile:1:5:", "syntax error before: ?す"], ~c":ok ?す")
+    end
+
+    test "character literals take newlines into account" do
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        assert parse!("{?\n}\n{123}") ==
+                 {:__block__, [], [{:{}, [line: 1], ~c"\n"}, {:{}, [line: 3], ~c"{"}]}
+
+        assert parse!("{?\\n}\n{123}") ==
+                 {:__block__, [], [{:{}, [line: 1], ~c"\n"}, {:{}, [line: 2], ~c"{"}]}
+
+        assert parse!("{?\\\n}\n{123}") ==
+                 {:__block__, [], [{:{}, [line: 1], ~c"\n"}, {:{}, [line: 3], ~c"{"}]}
+      end)
+    end
+
+    test "numbers are printed correctly in syntax errors" do
+      assert_syntax_error(["nofile:1:5:", ~s/syntax error before: "12"/], ~c":ok 12")
+      assert_syntax_error(["nofile:1:5:", ~s/syntax error before: "0b1"/], ~c":ok 0b1")
+      assert_syntax_error(["nofile:1:5:", ~s/syntax error before: "12.3"/], ~c":ok 12.3")
+
+      assert_syntax_error(
+        ["nofile:1:1:", ~s/invalid character "_" after number 123_456/],
+        ~c"123_456_foo"
+      )
+    end
+
+    test "on hex errors" do
+      msg =
+        "invalid hex escape character, expected \\xHH where H is a hexadecimal digit. Syntax error after: \\x"
+
+      assert_syntax_error(["nofile:1:2:", msg], ~S["\x"])
+      assert_syntax_error(["nofile:1:1:", msg], ~S[:"\x"])
+      assert_syntax_error(["nofile:1:2:", msg], ~S["\x": 123])
+      assert_syntax_error(["nofile:1:1:", msg], ~s["""\n\\x\n"""])
+    end
+
+    test "on unicode errors" do
+      msg = "invalid Unicode escape character"
+
+      assert_syntax_error(["nofile:1:2:", msg], ~S["\u"])
+      assert_syntax_error(["nofile:1:1:", msg], ~S[:"\u"])
+      assert_syntax_error(["nofile:1:2:", msg], ~S["\u": 123])
+      assert_syntax_error(["nofile:1:1:", msg], ~s["""\n\\u\n"""])
+
+      assert_syntax_error(
+        [
+          "nofile:1:2:",
+          "invalid or reserved Unicode code point \\u{FFFFFF}. Syntax error after: \\u"
+        ],
+        ~S["\u{FFFFFF}"]
+      )
+    end
+
+    test "on interpolation in calls" do
+      msg =
+        "interpolation is not allowed when calling function/macro. Found interpolation in a call starting with: \""
+
+      assert_syntax_error([msg], ".\"\#{}\"")
+      assert_syntax_error([msg], ".\"a\#{:b}\"c")
+    end
+
+    test "on long atoms" do
+      atom =
+        "@GR{+z]`_XrNla!d<GTZ]iw[s'l2N<5hGD0(.xh&}>0ptDp(amr.oS&<q(FA)5T3=},^{=JnwIOE*DPOslKV KF-kb7NF&Y#Lp3D7l/!s],^hnz1iB |E8~Y'-Rp&*E(O}|zoB#xsE.S/~~'=%H'2HOZu0PCfz6j=eHq5:yk{7&|}zeRONM+KWBCAUKWFw(tv9vkHTu#Ek$&]Q:~>,UbT}v$L|rHHXGV{;W!>avHbD[T-G5xrzR6m?rQPot-37B@"
+
+      assert_syntax_error(
+        ["atom length must be less than system limit: "],
+        ~s{:"#{atom}"}
+      )
+
+      assert_syntax_error(
+        ["atom length must be less than system limit: "],
+        ~s{["#{atom}": 123]}
+      )
+    end
+  end
+
+  defp parse!(string), do: Code.string_to_quoted!(string)
+
+  defp assert_syntax_error(given_messages, source) do
+    e = assert_raise SyntaxError, fn -> parse!(source) end
+    assert_exception_msg(e, given_messages)
+  end
+
+  defp assert_mismatched_delimiter_error(given_messages, source) do
+    e = assert_raise MismatchedDelimiterError, fn -> parse!(source) end
+    assert_exception_msg(e, given_messages)
+  end
+
+  defp assert_exception_msg(exception, messages) do
+    error_msg = Exception.format(:error, exception, [])
+
+    for msg <- messages do
+      assert error_msg =~ msg
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/quote_test.exs b/lib/elixir/test/elixir/kernel/quote_test.exs
index 2d8de03c0ae..8cfa3be07de 100644
--- a/lib/elixir/test/elixir/kernel/quote_test.exs
+++ b/lib/elixir/test/elixir/kernel/quote_test.exs
@@ -1,109 +1,222 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.QuoteTest do
   use ExUnit.Case, async: true
 
-  test :list do
+  @some_fun &List.flatten/1
+
+  test "fun" do
+    assert is_function(@some_fun)
+  end
+
+  test "list" do
     assert quote(do: [1, 2, 3]) == [1, 2, 3]
   end
 
-  test :tuple do
+  test "tuple" do
     assert quote(do: {:a, 1}) == {:a, 1}
   end
 
-  test :keep_line do
-    ## DO NOT MOVE THIS LINE
-    assert quote(location: :keep, do: bar(1, 2, 3)) == {:bar, [keep: 16], [1, 2, 3]}
+  test "keep line" do
+    line = __ENV__.line + 2
+
+    assert quote(location: :keep, do: bar(1, 2, 3)) ==
+             {:bar, [keep: {__ENV__.file, line}], [1, 2, 3]}
   end
 
-  test :fixed_line do
+  test "fixed line" do
     assert quote(line: 3, do: bar(1, 2, 3)) == {:bar, [line: 3], [1, 2, 3]}
+    assert quote(line: false, do: bar(1, 2, 3)) == {:bar, [], [1, 2, 3]}
+    assert quote(line: true, do: bar(1, 2, 3)) == {:bar, [line: __ENV__.line], [1, 2, 3]}
+  end
+
+  test "file line" do
+    assert quote(file: "foo", line: 3, do: bar(1, 2, 3)) ==
+             {:bar, [keep: {"foo", 3}], [1, 2, 3]}
+
+    assert quote(file: "foo", line: false, do: bar(1, 2, 3)) ==
+             {:bar, [keep: {"foo", 0}], [1, 2, 3]}
+
+    assert quote(file: "foo", line: true, do: bar(1, 2, 3)) ==
+             {:bar, [keep: {"foo", __ENV__.line - 1}], [1, 2, 3]}
   end
 
-  test :quote_line_var do
-    ## DO NOT MOVE THIS LINE
+  test "quote line var" do
     line = __ENV__.line
-    assert quote(line: line, do: bar(1, 2, 3)) == {:bar, [line: 25], [1, 2, 3]}
+    assert quote(line: line, do: bar(1, 2, 3)) == {:bar, [line: line], [1, 2, 3]}
+
+    assert_raise ArgumentError, fn ->
+      line = "oops"
+      quote(line: line, do: bar(1, 2, 3))
+    end
+
+    assert_raise ArgumentError, fn ->
+      line = true
+      quote(line: line, do: bar(1, 2, 3))
+    end
   end
 
-  test :unquote_call do
+  test "quote context var" do
+    context = :dynamic
+    assert quote(context: context, do: bar) == {:bar, [], :dynamic}
+
+    assert_raise ArgumentError, fn ->
+      context = "oops"
+      quote(context: context, do: bar)
+    end
+
+    assert_raise ArgumentError, fn ->
+      context = nil
+      quote(context: context, do: bar)
+    end
+  end
+
+  test "quote context bind_quoted" do
+    assert {:__block__, _,
+            [{:=, [], [{:some_var, _, :fallback}, 321]}, {:some_var, _, :fallback}]} =
+             (quote bind_quoted: [some_var: 321], context: __ENV__.context || :fallback do
+                some_var
+              end)
+  end
+
+  test "operator precedence" do
+    assert {:+, _, [{:+, _, [1, _]}, 1]} = quote(do: 1 + Foo.l() + 1)
+    assert {:+, _, [1, {_, _, [{:+, _, [1]}]}]} = quote(do: 1 + Foo.l(+1))
+  end
+
+  test "generated" do
+    assert quote(generated: true, do: bar(1)) == {:bar, [generated: true], [1]}
+  end
+
+  test "unquote call" do
     assert quote(do: foo(bar)[unquote(:baz)]) == quote(do: foo(bar)[:baz])
     assert quote(do: unquote(:bar)()) == quote(do: bar())
-    assert quote(do: unquote(:bar)(1) do 2 + 3 end) == quote(do: bar(1) do 2 + 3 end)
+
+    assert (quote do
+              unquote(:bar)(1) do
+                2 + 3
+              end
+            end) ==
+             (quote do
+                bar 1 do
+                  2 + 3
+                end
+              end)
+
     assert quote(do: foo.unquote(:bar)) == quote(do: foo.bar)
+    assert quote(do: foo.unquote(:bar)()) == quote(do: foo.bar())
     assert quote(do: foo.unquote(:bar)(1)) == quote(do: foo.bar(1))
-    assert quote(do: foo.unquote(:bar)(1) do 2 + 3 end) == quote(do: foo.bar(1) do 2 + 3 end)
+
+    assert (quote do
+              foo.unquote(:bar)(1) do
+                2 + 3
+              end
+            end) ==
+             (quote do
+                foo.bar 1 do
+                  2 + 3
+                end
+              end)
+
     assert quote(do: foo.unquote({:bar, [], nil})) == quote(do: foo.bar)
-    assert quote(do: foo.unquote({:bar, [], [1,2]})) == quote(do: foo.bar(1,2))
+    assert quote(do: foo.unquote({:bar, [], nil})()) == quote(do: foo.bar())
+    assert quote(do: foo.unquote({:bar, [], [1, 2]})) == quote(do: foo.bar(1, 2))
 
-    assert Code.eval_quoted(quote(do: Foo.unquote(Bar)))  == {Elixir.Foo.Bar, []}
-    assert Code.eval_quoted(quote(do: Foo.unquote(quote do: Bar))) == {Elixir.Foo.Bar, []}
+    assert Code.eval_quoted(quote(do: Foo.unquote(Bar))) == {Elixir.Foo.Bar, []}
+    assert Code.eval_quoted(quote(do: Foo.unquote(quote(do: Bar)))) == {Elixir.Foo.Bar, []}
 
     assert_raise ArgumentError, fn ->
       quote(do: foo.unquote(1))
     end
   end
 
-  test :nested_quote do
+  test "unquote call with dynamic line" do
+    assert quote(line: String.to_integer("123"), do: Foo.unquote(:bar)()) ==
+             quote(line: 123, do: Foo.bar())
+  end
+
+  test "nested quote" do
     assert {:quote, _, [[do: {:unquote, _, _}]]} = quote(do: quote(do: unquote(x)))
   end
 
+  test "import inside nested quote" do
+    # Check that we can evaluate imports from quote inside quote
+    assert {{:to_string, meta, [123]}, _} = Code.eval_quoted(quote(do: quote(do: to_string(123))))
+    assert meta[:imports] == [{1, Kernel}]
+  end
+
   defmacrop nested_quote_in_macro do
     x = 1
+
     quote do
       x = unquote(x)
+
       quote do
         unquote(x)
       end
     end
   end
 
-  test :nested_quote_in_macro do
-    assert nested_quote_in_macro == 1
+  test "nested quote in macro" do
+    assert nested_quote_in_macro() == 1
   end
 
-  Enum.each [foo: 1, bar: 2, baz: 3], fn {k, v} ->
-    def unquote(k)(arg) do
-      unquote(v) + arg
+  defmodule Dyn do
+    for {k, v} <- [foo: 1, bar: 2, baz: 3] do
+      # Local call unquote
+      def unquote(k)(), do: unquote(v)
+
+      # Remote call unquote
+      def unquote(k)(arg), do: __MODULE__.unquote(k)() + arg
     end
   end
 
-  test :dynamic_definition_with_unquote do
-    assert foo(1) == 2
-    assert bar(2) == 4
-    assert baz(3) == 6
+  test "dynamic definition with unquote" do
+    assert Dyn.foo() == 1
+    assert Dyn.bar() == 2
+    assert Dyn.baz() == 3
+
+    assert Dyn.foo(1) == 2
+    assert Dyn.bar(2) == 4
+    assert Dyn.baz(3) == 6
   end
 
-  test :splice_on_root do
+  test "splice on root" do
     contents = [1, 2, 3]
-    assert quote(do: (unquote_splicing(contents))) == quote do: (1; 2; 3)
+
+    assert quote(do: (unquote_splicing(contents))) ==
+             (quote do
+                1
+                2
+                3
+              end)
   end
 
-  test :splice_with_tail do
+  test "splice with tail" do
     contents = [1, 2, 3]
-    assert quote(do: [unquote_splicing(contents)|[1, 2, 3]]) ==
-           [1, 2, 3, 1, 2, 3]
 
-    assert quote(do: [unquote_splicing(contents)|val]) ==
-           quote(do: [1, 2, 3 | val])
+    assert quote(do: [unquote_splicing(contents) | [1, 2, 3]]) == [1, 2, 3, 1, 2, 3]
 
-    assert quote(do: [unquote_splicing(contents)|unquote([4])]) ==
-           quote(do: [1, 2, 3, 4])
+    assert quote(do: [unquote_splicing(contents) | val]) == quote(do: [1, 2, 3 | val])
+
+    assert quote(do: [unquote_splicing(contents) | unquote([4])]) == quote(do: [1, 2, 3, 4])
   end
 
-  test :splice_on_stab do
-    {fun, []} =
-      Code.eval_quoted(quote(do: fn(unquote_splicing([1, 2, 3])) -> :ok end), [])
+  test "splice on stab" do
+    {fun, []} = Code.eval_quoted(quote(do: fn unquote_splicing([1, 2, 3]) -> :ok end), [])
     assert fun.(1, 2, 3) == :ok
 
-    {fun, []} =
-      Code.eval_quoted(quote(do: fn(1, unquote_splicing([2, 3])) -> :ok end), [])
+    {fun, []} = Code.eval_quoted(quote(do: fn 1, unquote_splicing([2, 3]) -> :ok end), [])
     assert fun.(1, 2, 3) == :ok
   end
 
-  test :splice_on_definition do
+  test "splice on definition" do
     defmodule Hello do
-      def world([unquote_splicing(["foo", "bar"])|rest]) do
+      def world([unquote_splicing(["foo", "bar"]) | rest]) do
         rest
       end
     end
@@ -111,79 +224,150 @@ defmodule Kernel.QuoteTest do
     assert Hello.world(["foo", "bar", "baz"]) == ["baz"]
   end
 
-  test :splice_on_map do
-    assert %{unquote_splicing([foo: :bar])} == %{foo: :bar}
-    assert %{unquote_splicing([foo: :bar]), baz: :bat} == %{foo: :bar, baz: :bat}
-    assert %{unquote_splicing([foo: :bar]), :baz => :bat} == %{foo: :bar, baz: :bat}
-    assert %{:baz => :bat, unquote_splicing([foo: :bar])} == %{foo: :bar, baz: :bat}
+  test "splice on map" do
+    assert %{unquote_splicing(foo: :bar)} == %{foo: :bar}
+    assert %{unquote_splicing(foo: :bar), baz: :bat} == %{foo: :bar, baz: :bat}
+    assert %{unquote_splicing(foo: :bar), :baz => :bat} == %{foo: :bar, baz: :bat}
+    assert %{:baz => :bat, unquote_splicing(foo: :bar)} == %{foo: :bar, baz: :bat}
 
     map = %{foo: :default}
-    assert %{map | unquote_splicing([foo: :bar])} == %{foo: :bar}
+    assert %{map | unquote_splicing(foo: :bar)} == %{foo: :bar}
   end
 
-  test :when do
-    assert [{:->,_,[[{:when,_,[1,2,3,4]}],5]}] = quote(do: (1, 2, 3 when 4 -> 5))
-    assert [{:->,_,[[{:when,_,[1,2,3,4]}],5]}] = quote(do: ((1, 2, 3) when 4 -> 5))
+  test "when" do
+    assert [{:->, _, [[{:when, _, [1, 2, 3, 4]}], 5]}] = quote(do: (1, 2, 3 when 4 -> 5))
 
-    assert [{:->,_,[[{:when,_,[1,2,3,{:when,_,[4,5]}]}],6]}] =
-             quote(do: ((1, 2, 3) when 4 when 5 -> 6))
+    assert [{:->, _, [[{:when, _, [1, 2, 3, {:when, _, [4, 5]}]}], 6]}] =
+             quote(do: (1, 2, 3 when 4 when 5 -> 6))
   end
 
-  test :stab do
-    assert [{:->, _, [[], nil]}] = (quote do -> end)
-    assert [{:->, _, [[], nil]}] = (quote do: (->))
+  test "stab" do
+    assert [{:->, _, [[], 1]}] =
+             (quote do
+                () -> 1
+              end)
 
-    assert [{:->, _, [[1], nil]}] = (quote do 1 -> end)
-    assert [{:->, _, [[1], nil]}] = (quote do: (1 ->))
+    assert [{:->, _, [[], 1]}] = quote(do: (-> 1))
+  end
 
-    assert [{:->, _, [[], 1]}] = (quote do -> 1 end)
-    assert [{:->, _, [[], 1]}] = (quote do: (-> 1))
+  test "empty block" do
+    # Since ; is allowed by itself, it must also be allowed inside ()
+    # The exception to this rule is an empty (). While empty expressions
+    # are allowed, an empty () is ambiguous. We also can't use quote here,
+    # since the formatter will rewrite (;) to something else.
+    assert {:ok, {:__block__, [line: 1], []}} = Code.string_to_quoted("(;)")
   end
 
-  test :bind_quoted do
-    assert quote(bind_quoted: [foo: 1 + 2], do: foo) == {:__block__, [], [
-      {:=, [], [{:foo, [], Kernel.QuoteTest}, 3]},
+  test "bind quoted" do
+    args = [
+      {:=, [], [{:foo, [line: __ENV__.line + 4], Kernel.QuoteTest}, 3]},
       {:foo, [], Kernel.QuoteTest}
-    ]}
-  end
+    ]
 
-  test :literals do
-    assert (quote do: []) == []
-    assert (quote do: nil) == nil
-    assert (quote do [] end) == []
-    assert (quote do nil end) == nil
+    quoted = quote(bind_quoted: [foo: 1 + 2], do: foo)
+    assert quoted == {:__block__, [], args}
   end
 
-  defmacrop dynamic_opts do
-    [line: 3]
-  end
+  test "literals" do
+    assert quote(do: []) == []
+    assert quote(do: nil) == nil
+
+    assert (quote do
+              []
+            end) == []
 
-  test :with_dynamic_opts do
-    assert quote(dynamic_opts, do: bar(1, 2, 3)) == {:bar, [line: 3], [1, 2, 3]}
+    assert (quote do
+              nil
+            end) == nil
   end
 
-  test :unary_with_integer_precedence do
-    assert quote(do: +1.foo) == quote(do: (+1).foo)
-    assert quote(do: @1.foo) == quote(do: (@1).foo)
-    assert quote(do: &1.foo) == quote(do: (&1).foo)
+  defmacrop dynamic_opts do
+    [line: 3]
   end
 
-  test :operators_slash_arity do
-    assert {:/, _, [{:+, _, _}, 2]} = quote do: +/2
-    assert {:/, _, [{:&&, _, _}, 3]} = quote do: &&/3
+  test "with dynamic opts" do
+    assert quote(dynamic_opts(), do: bar(1, 2, 3)) == {:bar, [line: 3], [1, 2, 3]}
+  end
+
+  test "unary with integer precedence" do
+    assert quote(do: +1.foo) == quote(do: +1.foo)
+    assert quote(do: (@1).foo) == quote(do: (@1).foo)
+    assert quote(do: &1.foo) == quote(do: &1.foo)
+  end
+
+  test "pipe precedence" do
+    assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =
+             quote(do: foo |> bar |> baz)
+
+    assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =
+             (quote do
+                foo do
+                end
+                |> bar
+                |> baz
+              end)
+
+    assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =
+             (quote do
+                foo
+                |> bar do
+                end
+                |> baz
+              end)
+
+    assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =
+             (quote do
+                foo
+                |> bar
+                |> baz do
+                end
+              end)
+
+    assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =
+             (quote do
+                foo do
+                end
+                |> bar
+                |> baz do
+                end
+              end)
+
+    assert {:|>, _, [{:|>, _, [{:foo, _, _}, {:bar, _, _}]}, {:baz, _, _}]} =
+             (quote do
+                foo do
+                end
+                |> bar do
+                end
+                |> baz do
+                end
+              end)
+  end
+
+  test "capture" do
+    assert Code.string_to_quoted!("&1[:foo]") == Code.string_to_quoted!("(&1)[:foo]")
+    assert Code.string_to_quoted!("&1 [:foo]") == Code.string_to_quoted!("(&1)[:foo]")
+    assert Code.string_to_quoted!("& 1[:foo]") == Code.string_to_quoted!("&(1[:foo])")
+  end
+
+  test "not and ! as rearrange ops" do
+    assert {:__block__, _, [{:not, [line: 1], [true]}]} = Code.string_to_quoted!("(not true)")
+
+    assert {:fn, _, [{:->, _, [[], {:not, _, [true]}]}]} =
+             Code.string_to_quoted!("fn -> not true end")
   end
 end
 
-## DO NOT MOVE THIS LINE
 defmodule Kernel.QuoteTest.Errors do
-  defmacro defadd do
+  def line, do: __ENV__.line + 4
+
+  defmacro defraise do
     quote location: :keep do
-      def add(a, b), do: a + b
+      def will_raise(_a, _b), do: raise("oops")
     end
   end
 
   defmacro will_raise do
-    quote location: :keep, do: raise "omg"
+    quote(location: :keep, do: raise("oops"))
   end
 end
 
@@ -192,44 +376,49 @@ defmodule Kernel.QuoteTest.ErrorsTest do
   import Kernel.QuoteTest.Errors
 
   # Defines the add function
-  defadd
-
-  test :inside_function_error do
-    assert_raise ArithmeticError, fn ->
-      add(:a, :b)
+  defraise()
+
+  @line line()
+  test "inside function error" do
+    try do
+      will_raise(:a, :b)
+    rescue
+      RuntimeError ->
+        mod = Kernel.QuoteTest.ErrorsTest
+        file = __ENV__.file |> Path.relative_to_cwd() |> String.to_charlist()
+        assert [{^mod, :will_raise, 2, [file: ^file, line: @line] ++ _} | _] = __STACKTRACE__
     end
-
-    mod  = Kernel.QuoteTest.ErrorsTest
-    file = __ENV__.file |> Path.relative_to_cwd |> String.to_char_list
-    assert [{^mod, :add, 2, [file: ^file, line: 181]}|_] = System.stacktrace
   end
 
-  test :outside_function_error do
-    assert_raise RuntimeError, fn ->
-      will_raise
+  @line __ENV__.line + 3
+  test "outside function error" do
+    try do
+      will_raise()
+      flunk("expected failure")
+    rescue
+      RuntimeError ->
+        mod = Kernel.QuoteTest.ErrorsTest
+        file = __ENV__.file |> Path.relative_to_cwd() |> String.to_charlist()
+        assert [{^mod, _, _, [file: ^file, line: @line] ++ _} | _] = __STACKTRACE__
     end
-
-    mod  = Kernel.QuoteTest.ErrorsTest
-    file = __ENV__.file |> Path.relative_to_cwd |> String.to_char_list
-    assert [{^mod, _, _, [file: ^file, line: 209]}|_] = System.stacktrace
   end
 end
 
 defmodule Kernel.QuoteTest.VarHygiene do
   defmacro no_interference do
-    quote do: a = 1
+    quote(do: a = 1)
   end
 
   defmacro write_interference do
-    quote do: var!(a) = 1
+    quote(do: var!(a) = 1)
   end
 
   defmacro read_interference do
-    quote do: 10 = var!(a)
+    quote(do: 10 = var!(a))
   end
 
   defmacro cross_module_interference do
-    quote do: var!(a, Kernel.QuoteTest.VarHygieneTest) = 1
+    quote(do: var!(a, Kernel.QuoteTest.VarHygieneTest) = 1)
   end
 end
 
@@ -238,11 +427,11 @@ defmodule Kernel.QuoteTest.VarHygieneTest do
   import Kernel.QuoteTest.VarHygiene
 
   defmacrop cross_module_no_interference do
-    quote do: a = 10
+    quote(do: a = 10)
   end
 
   defmacrop read_cross_module do
-    quote do: var!(a, __MODULE__)
+    quote(do: var!(a, __MODULE__))
   end
 
   defmacrop nested(var, do: block) do
@@ -255,44 +444,88 @@ defmodule Kernel.QuoteTest.VarHygieneTest do
 
   defmacrop hat do
     quote do
-      var  = 1
+      var = 1
       ^var = 1
       var
     end
   end
 
-  test :no_interference do
+  test "no interference" do
     a = 10
-    no_interference
+    no_interference()
     assert a == 10
   end
 
-  test :cross_module_interference do
-    cross_module_no_interference
-    cross_module_interference
-    assert read_cross_module == 1
+  test "cross module interference" do
+    cross_module_no_interference()
+    cross_module_interference()
+    assert read_cross_module() == 1
   end
 
-  test :write_interference do
-    write_interference
+  test "write interference" do
+    write_interference()
     assert a == 1
   end
 
-  test :read_interference do
+  test "read interference" do
     a = 10
-    read_interference
+    read_interference()
   end
 
-  test :nested do
+  test "hat" do
+    assert hat() == 1
+  end
+
+  test "nested macro" do
     assert (nested 1 do
-      nested 2 do
-        :ok
+              nested 2 do
+                _ = :ok
+              end
+            end) == 1
+  end
+
+  test "nested quoted" do
+    defmodule NestedQuote do
+      defmacro __using__(_) do
+        quote unquote: false do
+          arg = quote(do: arg)
+
+          def test(arg) do
+            unquote(arg)
+          end
+        end
       end
-    end) == 1
+    end
+
+    defmodule UseNestedQuote do
+      use NestedQuote
+    end
+
+    assert UseNestedQuote.test("foo") == "foo"
   end
 
-  test :hat do
-    assert hat == 1
+  test "nested bind quoted" do
+    defmodule NestedBindQuoted do
+      defmacrop macro(arg) do
+        quote bind_quoted: [arg: arg] do
+          quote bind_quoted: [arg: arg], do: String.duplicate(arg, 2)
+        end
+      end
+
+      defmacro __using__(_) do
+        quote do
+          def test do
+            unquote(macro("foo"))
+          end
+        end
+      end
+    end
+
+    defmodule UseNestedBindQuoted do
+      use NestedBindQuoted
+    end
+
+    assert UseNestedBindQuoted.test() == "foofoo"
   end
 end
 
@@ -300,11 +533,11 @@ defmodule Kernel.QuoteTest.AliasHygiene do
   alias Dict, as: SuperDict
 
   defmacro dict do
-    quote do: Dict.Bar
+    quote(do: Dict.Bar)
   end
 
   defmacro super_dict do
-    quote do: SuperDict.Bar
+    quote(do: SuperDict.Bar)
   end
 end
 
@@ -313,64 +546,79 @@ defmodule Kernel.QuoteTest.AliasHygieneTest do
 
   alias Dict, as: SuperDict
 
-  test :annotate_aliases do
-    assert {:__aliases__, [alias: false], [:Foo, :Bar]} =
-           quote(do: Foo.Bar)
-    assert {:__aliases__, [alias: false], [:Dict, :Bar]} =
-           quote(do: Dict.Bar)
-    assert {:__aliases__, [alias: Dict.Bar], [:SuperDict, :Bar]} =
-           quote(do: SuperDict.Bar)
+  test "annotate aliases" do
+    assert {:__aliases__, [alias: false], [:Foo, :Bar]} = quote(do: Foo.Bar)
+    assert {:__aliases__, [alias: false], [:Dict, :Bar]} = quote(do: Dict.Bar)
+    assert {:__aliases__, [alias: Dict.Bar], [:SuperDict, :Bar]} = quote(do: SuperDict.Bar)
+
+    # Edge-case
+    assert {:__aliases__, _, [Elixir]} = quote(do: Elixir)
   end
 
-  test :expand_aliases do
-    assert Code.eval_quoted(quote do: SuperDict.Bar) == {Elixir.Dict.Bar, []}
-    assert Code.eval_quoted(quote do: alias!(SuperDict.Bar)) == {Elixir.SuperDict.Bar, []}
+  test "expand aliases" do
+    assert Code.eval_quoted(quote(do: SuperDict.Bar)) == {Elixir.Dict.Bar, []}
+    assert Code.eval_quoted(quote(do: alias!(SuperDict.Bar))) == {Elixir.SuperDict.Bar, []}
   end
 
-  test :expand_aliases_without_macro do
+  test "expand aliases without macro" do
     alias HashDict, as: SuperDict
     assert SuperDict.Bar == Elixir.HashDict.Bar
   end
 
-  test :expand_aliases_with_macro_does_not_expand_source_alias do
+  test "expand aliases with macro does not expand source alias" do
     alias HashDict, as: Dict, warn: false
     require Kernel.QuoteTest.AliasHygiene
-    assert Kernel.QuoteTest.AliasHygiene.dict == Elixir.Dict.Bar
+    assert Kernel.QuoteTest.AliasHygiene.dict() == Elixir.Dict.Bar
   end
 
-  test :expand_aliases_with_macro_has_higher_preference do
+  test "expand aliases with macro has higher preference" do
     alias HashDict, as: SuperDict, warn: false
     require Kernel.QuoteTest.AliasHygiene
-    assert Kernel.QuoteTest.AliasHygiene.super_dict == Elixir.Dict.Bar
+    assert Kernel.QuoteTest.AliasHygiene.super_dict() == Elixir.Dict.Bar
   end
 end
 
 defmodule Kernel.QuoteTest.ImportsHygieneTest do
   use ExUnit.Case, async: true
 
+  # We are redefining |> and using it inside the quote
+  # and only inside the quote. This code should still compile.
+  defmacro x |> f do
+    quote do
+      unquote(x) |> unquote(f)
+    end
+  end
+
   defmacrop get_list_length do
     quote do
-      length('hello')
+      length(~c"hello")
+    end
+  end
+
+  defmacrop get_list_length_with_pipe do
+    quote do
+      ~c"hello" |> length()
     end
   end
 
   defmacrop get_list_length_with_partial do
     quote do
-      (&length(&1)).('hello')
+      (&length(&1)).(~c"hello")
     end
   end
 
   defmacrop get_list_length_with_function do
     quote do
-      (&length/1).('hello')
+      (&length/1).(~c"hello")
     end
   end
 
-  test :expand_imports do
+  test "expand imports" do
     import Kernel, except: [length: 1]
-    assert get_list_length == 5
-    assert get_list_length_with_partial == 5
-    assert get_list_length_with_function == 5
+    assert get_list_length() == 5
+    assert get_list_length_with_pipe() == 5
+    assert get_list_length_with_partial() == 5
+    assert get_list_length_with_function() == 5
   end
 
   defmacrop get_string_length do
@@ -381,30 +629,209 @@ defmodule Kernel.QuoteTest.ImportsHygieneTest do
     end
   end
 
-  test :lazy_expand_imports do
+  test "lazy expand imports" do
     import Kernel, except: [length: 1]
     import String, only: [length: 1]
-    assert get_string_length == 5
+    assert get_string_length() == 5
   end
 
-  test :lazy_expand_imports_no_conflicts do
+  test "lazy expand imports no conflicts" do
     import Kernel, except: [length: 1]
-    import String, only: [length: 1]
+    import String, only: [length: 1], warn: false
 
-    assert get_list_length == 5
-    assert get_list_length_with_partial == 5
-    assert get_list_length_with_function == 5
+    assert get_list_length() == 5
+    assert get_list_length_with_partial() == 5
+    assert get_list_length_with_function() == 5
   end
 
   defmacrop with_length do
     quote do
       import Kernel, except: [length: 1]
       import String, only: [length: 1]
-      length('hello')
+      length(~c"hello")
+    end
+  end
+
+  test "explicitly overridden imports" do
+    assert with_length() == 5
+  end
+
+  defmodule BinaryUtils do
+    defmacro int32 do
+      quote do
+        integer - size(32)
+      end
     end
   end
 
-  test :explicitly_overridden_imports do
-    assert with_length == 5
+  test "checks the context also for variables to zero-arity functions" do
+    import BinaryUtils
+    {:int32, meta, __MODULE__} = quote(do: int32)
+    assert meta[:imports] == [{0, BinaryUtils}]
+  end
+end
+
+defmodule Kernel.QuoteTest.HasUnquoteTest do
+  use ExUnit.Case, async: true
+
+  test "expression without unquote returns false" do
+    ast =
+      quote unquote: false do
+        opts = [x: 5]
+        x = Keyword.fetch!(opts, :x)
+        x + 1
+      end
+
+    refute :elixir_quote.has_unquotes(ast)
+  end
+
+  test "expression with unquote returns true" do
+    ast =
+      quote unquote: false do
+        [x: unquote(x)]
+      end
+
+    assert :elixir_quote.has_unquotes(ast)
+
+    ast =
+      quote unquote: false do
+        unquote(module).fun(x)
+      end
+
+    assert :elixir_quote.has_unquotes(ast)
+
+    ast =
+      quote unquote: false do
+        module.unquote(fun)(x)
+      end
+
+    assert :elixir_quote.has_unquotes(ast)
+
+    ast =
+      quote unquote: false do
+        module.fun(unquote(x))
+      end
+
+    assert :elixir_quote.has_unquotes(ast)
+
+    ast =
+      quote unquote: false do
+        module.fun(unquote_splicing(args))
+      end
+
+    assert :elixir_quote.has_unquotes(ast)
+  end
+
+  test "expression with unquote within quote returns false" do
+    ast =
+      quote unquote: false do
+        quote do
+          x + unquote(y)
+        end
+      end
+
+    refute :elixir_quote.has_unquotes(ast)
+
+    ast =
+      quote unquote: false do
+        quote do
+          foo = bar(unquote_splicing(args))
+        end
+      end
+
+    refute :elixir_quote.has_unquotes(ast)
+  end
+
+  test "expression with unquote within unquote within quote returns true" do
+    ast =
+      quote unquote: false do
+        quote do
+          x + unquote(unquote(y))
+        end
+      end
+
+    assert :elixir_quote.has_unquotes(ast)
+
+    ast =
+      quote unquote: false do
+        quote do
+          foo = bar(unquote_splicing(unquote(args)))
+        end
+      end
+
+    assert :elixir_quote.has_unquotes(ast)
+
+    ast =
+      quote unquote: false do
+        quote do
+          foo = bar(unquote(unquote_splicing(args)))
+        end
+      end
+
+    assert :elixir_quote.has_unquotes(ast)
+  end
+
+  test "expression within quote disabling unquotes always returns false" do
+    ast =
+      quote unquote: false do
+        quote unquote: false do
+          x + unquote(unquote(y))
+        end
+      end
+
+    refute :elixir_quote.has_unquotes(ast)
+
+    ast =
+      quote unquote: false do
+        quote bind_quoted: [x: x] do
+          x + unquote(unquote(y))
+        end
+      end
+
+    refute :elixir_quote.has_unquotes(ast)
+  end
+
+  test "unquote with invalid AST (shallow check)" do
+    for term <- [
+          %{unescaped: :map},
+          1..10,
+          {:bad_meta, nil, []},
+          {:bad_arg, nil, 1},
+          {:bad_tuple},
+          make_ref(),
+          [:improper | :list],
+          [nested: {}]
+        ] do
+      message = """
+      tried to unquote invalid AST: #{inspect(term)}
+      Did you forget to escape term using Macro.escape/1?\
+      """
+
+      assert_raise ArgumentError, message, fn -> quote do: unquote(term) end
+    end
+  end
+
+  test "unquote with invalid AST is not checked deeply" do
+    assert quote do: unquote(foo: [1 | 2]) == [foo: [1 | 2]]
+    assert quote do: unquote(foo: [bar: %{}]) == [foo: [bar: %{}]]
+  end
+
+  test "unquote_splicing with invalid AST" do
+    for args <- [
+          "not_a_list",
+          [:improper | :list],
+          [%{unescaped: :map}],
+          [1..10],
+          [{:bad_meta, nil, []}],
+          [{:bad_arg, nil, 1}],
+          [{:bad_tuple}],
+          [make_ref()],
+          [nested: {}]
+        ] do
+      message =
+        "expected a list with quoted expressions in unquote_splicing/1, got: #{inspect(args)}"
+
+      assert_raise ArgumentError, message, fn -> quote do: [unquote_splicing(args)] end
+    end
   end
 end
diff --git a/lib/elixir/test/elixir/kernel/raise_test.exs b/lib/elixir/test/elixir/kernel/raise_test.exs
index 2b6567e949a..6a4e2d95046 100644
--- a/lib/elixir/test/elixir/kernel/raise_test.exs
+++ b/lib/elixir/test/elixir/kernel/raise_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.RaiseTest do
   use ExUnit.Case, async: true
@@ -9,8 +13,23 @@ defmodule Kernel.RaiseTest do
   defp opts, do: [message: "message"]
   defp struct, do: %RuntimeError{message: "message"}
 
+  @compile {:no_warn_undefined, DoNotExist}
   @trace [{:foo, :bar, 0, []}]
 
+  test "raise preserves the stacktrace" do
+    stacktrace =
+      try do
+        raise "a"
+      rescue
+        _ -> Enum.fetch!(__STACKTRACE__, 0)
+      end
+
+    file = __ENV__.file |> Path.relative_to_cwd() |> String.to_charlist()
+
+    assert {__MODULE__, :"test raise preserves the stacktrace", _, [file: ^file, line: 22] ++ _} =
+             stacktrace
+  end
+
   test "raise message" do
     assert_raise RuntimeError, "message", fn ->
       raise "message"
@@ -56,318 +75,511 @@ defmodule Kernel.RaiseTest do
     end
   end
 
+  test "raise with error_info" do
+    {exception, stacktrace} =
+      try do
+        raise "a"
+      rescue
+        e -> {e, __STACKTRACE__}
+      end
+
+    assert [{__MODULE__, _, _, meta} | _] = stacktrace
+    assert meta[:error_info] == %{module: Exception}
+
+    assert Exception.format_error(exception, stacktrace) ==
+             %{general: "a", reason: "#Elixir.RuntimeError"}
+  end
+
   test "reraise message" do
     try do
       reraise "message", @trace
-      flunk "should not reach"
+      flunk("should not reach")
     rescue
       RuntimeError ->
-        assert @trace == :erlang.get_stacktrace()
+        assert @trace == __STACKTRACE__
     end
 
     try do
       var = binary()
       reraise var, @trace
-      flunk "should not reach"
+      flunk("should not reach")
     rescue
       RuntimeError ->
-        assert @trace == :erlang.get_stacktrace()
+        assert @trace == __STACKTRACE__
     end
   end
 
   test "reraise with no arguments" do
     try do
       reraise RuntimeError, @trace
-      flunk "should not reach"
+      flunk("should not reach")
     rescue
       RuntimeError ->
-        assert @trace == :erlang.get_stacktrace()
+        assert @trace == __STACKTRACE__
     end
 
     try do
       var = atom()
       reraise var, @trace
-      flunk "should not reach"
+      flunk("should not reach")
     rescue
       RuntimeError ->
-        assert @trace == :erlang.get_stacktrace()
+        assert @trace == __STACKTRACE__
     end
   end
 
   test "reraise with arguments" do
     try do
       reraise RuntimeError, [message: "message"], @trace
-      flunk "should not reach"
+      flunk("should not reach")
     rescue
       RuntimeError ->
-        assert @trace == :erlang.get_stacktrace()
+        assert @trace == __STACKTRACE__
     end
 
     try do
       atom = atom()
       opts = opts()
       reraise atom, opts, @trace
-      flunk "should not reach"
+      flunk("should not reach")
     rescue
       RuntimeError ->
-        assert @trace == :erlang.get_stacktrace()
+        assert @trace == __STACKTRACE__
     end
   end
 
   test "reraise existing exception" do
     try do
       reraise %RuntimeError{message: "message"}, @trace
-      flunk "should not reach"
+      flunk("should not reach")
     rescue
       RuntimeError ->
-        assert @trace == :erlang.get_stacktrace()
+        assert @trace == __STACKTRACE__
     end
 
     try do
       var = struct()
       reraise var, @trace
-      flunk "should not reach"
+      flunk("should not reach")
     rescue
       RuntimeError ->
-        assert @trace == :erlang.get_stacktrace()
+        assert @trace == __STACKTRACE__
     end
   end
 
-  test :rescue_with_underscore_no_exception do
-    result = try do
-      RescueUndefinedModule.go
-    rescue
-      _ -> true
-    end
+  describe "rescue" do
+    test "runtime error" do
+      result =
+        try do
+          raise "an exception"
+        rescue
+          RuntimeError -> true
+        catch
+          :error, _ -> false
+        end
+
+      assert result
+
+      result =
+        try do
+          raise "an exception"
+        rescue
+          ArgumentError -> true
+        catch
+          :error, _ -> false
+        end
 
-    assert result
-  end
+      refute result
+    end
+
+    test "named runtime error" do
+      result =
+        try do
+          raise "an exception"
+        rescue
+          x in [RuntimeError] -> Exception.message(x)
+        catch
+          :error, _ -> false
+        end
+
+      assert result == "an exception"
+    end
+
+    test "named runtime or argument error" do
+      result =
+        try do
+          raise "an exception"
+        rescue
+          x in [ArgumentError, RuntimeError] -> Exception.message(x)
+        catch
+          :error, _ -> false
+        end
 
-  test :rescue_with_higher_precedence_than_catch do
-    result = try do
-      RescueUndefinedModule.go
-    catch
-      _, _ -> false
-    rescue
-      _ -> true
+      assert result == "an exception"
     end
 
-    assert result
-  end
+    test "named function clause (stacktrace) or runtime (no stacktrace) error" do
+      result =
+        try do
+          Access.get("foo", 0)
+        rescue
+          x in [FunctionClauseError, CaseClauseError] -> Exception.message(x)
+        end
 
-  test :rescue_runtime_error do
-    result = try do
-      raise "an exception"
-    rescue
-      RuntimeError -> true
-    catch
-      :error, _ -> false
+      assert result == "no function clause matching in Access.get/3"
     end
 
-    assert result
+    test "with higher precedence than catch" do
+      result =
+        try do
+          raise "an exception"
+        rescue
+          _ -> true
+        catch
+          _, _ -> false
+        end
 
-    result = try do
-      raise "an exception"
-    rescue
-      AnotherError -> true
-    catch
-      :error, _ -> false
+      assert result
     end
 
-    refute result
-  end
+    test "argument error from Erlang" do
+      result =
+        try do
+          :erlang.error(:badarg)
+        rescue
+          ArgumentError -> true
+        end
 
-  test :rescue_named_runtime_error do
-    result = try do
-      raise "an exception"
-    rescue
-      x in [RuntimeError] -> Exception.message(x)
-    catch
-      :error, _ -> false
+      assert result
     end
 
-    assert result == "an exception"
-  end
+    test "argument error from Elixir" do
+      result =
+        try do
+          raise ArgumentError, ""
+        rescue
+          ArgumentError -> true
+        end
 
-  test :rescue_argument_error_from_elixir do
-    result = try do
-     raise ArgumentError, ""
-    rescue
-      ArgumentError -> true
+      assert result
     end
 
-    assert result
-  end
+    test "catch-all variable" do
+      result =
+        try do
+          raise "an exception"
+        rescue
+          x -> Exception.message(x)
+        end
 
-  test :rescue_named_with_underscore do
-    result = try do
-      raise "an exception"
-    rescue
-      x in _ -> Exception.message(x)
+      assert result == "an exception"
     end
 
-    assert result == "an exception"
-  end
+    test "catch-all underscore" do
+      result =
+        try do
+          raise "an exception"
+        rescue
+          _ -> true
+        end
 
-  test :wrap_custom_erlang_error do
-    result = try do
-      :erlang.error(:sample)
-    rescue
-      x in [RuntimeError, ErlangError] -> Exception.message(x)
+      assert result
     end
 
-    assert result == "erlang error: :sample"
-  end
+    test "catch-all unused variable" do
+      result =
+        try do
+          raise "an exception"
+        rescue
+          _any -> true
+        end
 
-  test :undefined_function_error do
-    result = try do
-      DoNotExist.for_sure()
-    rescue
-      x in [UndefinedFunctionError] -> Exception.message(x)
+      assert result
     end
 
-    assert result == "undefined function: DoNotExist.for_sure/0"
-  end
+    test "catch-all with \"x in _\" syntax" do
+      result =
+        try do
+          raise "an exception"
+        rescue
+          exception in _ ->
+            Exception.message(exception)
+        end
 
-  test :function_clause_error do
-    result = try do
-      zero(1)
-    rescue
-      x in [FunctionClauseError] -> Exception.message(x)
+      assert result == "an exception"
+    end
+
+    defmacrop argerr(e) do
+      quote(do: unquote(e) in ArgumentError)
     end
 
-    assert result == "no function clause matching in Kernel.RaiseTest.zero/1"
+    test "with rescue macro" do
+      result =
+        try do
+          raise ArgumentError, "oops, badarg"
+        rescue
+          argerr(e) -> Exception.message(e)
+        end
+
+      assert result == "oops, badarg"
+    end
   end
 
-  test :badarg_error do
-    result = try do
-      :erlang.error(:badarg)
-    rescue
-      x in [ArgumentError] -> Exception.message(x)
+  describe "normalize" do
+    test "wrap custom Erlang error" do
+      result =
+        try do
+          :erlang.error(:sample)
+        rescue
+          x in [ErlangError] -> Exception.message(x)
+        end
+
+      assert result == "Erlang error: :sample"
     end
 
-    assert result == "argument error"
-  end
+    test "undefined function error" do
+      result =
+        try do
+          DoNotExist.for_sure()
+        rescue
+          x in [UndefinedFunctionError] -> Exception.message(x)
+        end
 
-  test :tuple_badarg_error do
-    result = try do
-      :erlang.error({:badarg, [1, 2, 3]})
-    rescue
-      x in [ArgumentError] -> Exception.message(x)
+      assert result ==
+               "function DoNotExist.for_sure/0 is undefined (module DoNotExist is not available). " <>
+                 "Make sure the module name is correct and has been specified in full (or that an alias has been defined)"
     end
 
-    assert result == "argument error: [1, 2, 3]"
-  end
+    test "function clause error" do
+      result =
+        try do
+          Access.get(:ok, :error)
+        rescue
+          x in [FunctionClauseError] -> Exception.message(x)
+        end
 
-  test :badarith_error do
-    result = try do
-      :erlang.error(:badarith)
-    rescue
-      x in [ArithmeticError] -> Exception.message(x)
+      assert result == "no function clause matching in Access.get/3"
     end
 
-    assert result == "bad argument in arithmetic expression"
-  end
+    test "badarg error" do
+      result =
+        try do
+          :erlang.error(:badarg)
+        rescue
+          x in [ArgumentError] -> Exception.message(x)
+        end
+
+      assert result == "argument error"
+    end
 
-  test :badarity_error do
-    fun    = fn(x) -> x end
-    string = "#{inspect(fun)} with arity 1 called with 2 arguments (1, 2)"
+    test "tuple badarg error" do
+      result =
+        try do
+          :erlang.error({:badarg, [1, 2, 3]})
+        rescue
+          x in [ArgumentError] -> Exception.message(x)
+        end
 
-    result = try do
-      fun.(1, 2)
-    rescue
-      x in [BadArityError] -> Exception.message(x)
+      assert result == "argument error: [1, 2, 3]"
     end
 
-    assert result == string
-  end
+    test "badarith error" do
+      result =
+        try do
+          :erlang.error(:badarith)
+        rescue
+          x in [ArithmeticError] -> Exception.message(x)
+        end
 
-  test :badfun_error do
-    x = :example
-    result = try do
-      x.(2)
-    rescue
-      x in [BadFunctionError] -> Exception.message(x)
+      assert result == "bad argument in arithmetic expression"
     end
 
-    assert result == "expected a function, got: :example"
-  end
+    test "badarity error" do
+      fun = fn x -> x end
+      string = "#{inspect(fun)} with arity 1 called with 2 arguments (1, 2)"
 
-  test :badmatch_error do
-    x = :example
-    result = try do
-      ^x = zero(0)
-    rescue
-      x in [MatchError] -> Exception.message(x)
+      result =
+        try do
+          Process.get(:unused, fun).(1, 2)
+        rescue
+          x in [BadArityError] -> Exception.message(x)
+        end
+
+      assert result == string
     end
 
-    assert result == "no match of right hand side value: 0"
-  end
+    test "badfun error" do
+      result =
+        try do
+          Process.get(:unused, :example).(2)
+        rescue
+          x in [BadFunctionError] -> Exception.message(x)
+        end
 
-  test :case_clause_error do
-    x = :example
-    result = try do
-      case zero(0) do
-        ^x -> nil
-      end
-    rescue
-      x in [CaseClauseError] -> Exception.message(x)
+      assert result == "expected a function, got: :example"
     end
 
-    assert result == "no case clause matching: 0"
-  end
+    test "badfun error when the function is gone" do
+      defmodule BadFunction.Missing do
+        def fun, do: fn -> :ok end
+      end
+
+      fun = BadFunction.Missing.fun()
+
+      :code.purge(BadFunction.Missing)
+      :code.delete(BadFunction.Missing)
 
-  test :cond_clause_error do
-    result = try do
-      cond do
-        !zero(0) -> :ok
+      defmodule BadFunction.Missing do
+        def fun, do: fn -> :another end
       end
-    rescue
-      x in [CondClauseError] -> Exception.message(x)
-    end
 
-    assert result == "no cond clause evaluated to a true value"
-  end
+      :code.purge(BadFunction.Missing)
 
-  test :try_clause_error do
-    f = fn() -> :example end
-    result = try do
       try do
-        f.()
+        fun.()
+      rescue
+        x in [BadFunctionError] ->
+          assert Exception.message(x) =~
+                   ~r/function #Function<[0-9]\.[0-9]*\/0[^>]*> is invalid, likely because it points to an old version of the code/
       else
-        :other ->
-          :ok
+        _ -> flunk("this should not be invoked")
       end
-    rescue
-      x in [TryClauseError] -> Exception.message(x)
     end
 
-    assert result == "no try clause matching: :example"
-  end
+    test "badmatch error" do
+      result =
+        try do
+          [] = Range.to_list(1000_000..1_000_009)
+        rescue
+          x in [MatchError] -> Exception.message(x)
+        end
 
-  test :undefined_function_error_as_erlang_error do
-    result = try do
-      DoNotExist.for_sure()
-    rescue
-      x in [ErlangError] -> Exception.message(x)
+      assert result ==
+               """
+               no match of right hand side value:
+
+                   [1000000, 1000001, 1000002, 1000003, 1000004, 1000005, 1000006, 1000007,
+                    1000008, 1000009]
+               """
+    end
+
+    test "bad key error" do
+      result =
+        try do
+          %{Process.get(:unused, %{}) | foo: :bar}
+        rescue
+          x in [KeyError] -> Exception.message(x)
+        end
+
+      assert result == "key :foo not found"
+
+      result =
+        try do
+          Process.get(:unused, %{}).foo
+        rescue
+          x in [KeyError] -> Exception.message(x)
+        end
+
+      assert result == "key :foo not found in:\n\n    %{}\n"
+    end
+
+    test "bad map error" do
+      result =
+        try do
+          %{Process.get(:unused, 0) | foo: :bar}
+        rescue
+          x in [BadMapError] -> Exception.message(x)
+        end
+
+      assert result == "expected a map, got:\n\n    0\n"
+    end
+
+    test "bad boolean error" do
+      result =
+        try do
+          Process.get(:unused, 1) and true
+        rescue
+          x in [BadBooleanError] -> Exception.message(x)
+        end
+
+      assert result == "expected a boolean on left-side of \"and\", got:\n\n    1\n"
+    end
+
+    test "case clause error" do
+      x = :example
+
+      result =
+        try do
+          case Process.get(:unused, 0) do
+            ^x -> nil
+          end
+        rescue
+          x in [CaseClauseError] -> Exception.message(x)
+        end
+
+      assert result == "no case clause matching:\n\n    0\n"
+    end
+
+    test "cond clause error" do
+      result =
+        try do
+          cond do
+            !Process.get(:unused, 0) -> :ok
+          end
+        rescue
+          x in [CondClauseError] -> Exception.message(x)
+        end
+
+      assert result == "no cond clause evaluated to a truthy value"
+    end
+
+    test "try clause error" do
+      result =
+        try do
+          try do
+            Process.get(:unused, :example)
+          rescue
+            _exception ->
+              :ok
+          else
+            :other ->
+              :ok
+          end
+        rescue
+          x in [TryClauseError] -> Exception.message(x)
+        end
+
+      assert result == "no try clause matching:\n\n    :example\n"
+    end
+
+    test "undefined function error as Erlang error" do
+      result =
+        try do
+          DoNotExist.for_sure()
+        rescue
+          x in [ErlangError] -> Exception.message(x)
+        end
+
+      assert result ==
+               "function DoNotExist.for_sure/0 is undefined (module DoNotExist is not available). " <>
+                 "Make sure the module name is correct and has been specified in full (or that an alias has been defined)"
     end
-
-    assert result == "undefined function: DoNotExist.for_sure/0"
   end
 
   defmacrop exceptions do
     [ErlangError]
   end
 
-  test :with_macros do
-    result = try do
-      DoNotExist.for_sure()
-    rescue
-      x in exceptions -> Exception.message(x)
-    end
+  test "with macros" do
+    result =
+      try do
+        DoNotExist.for_sure()
+      rescue
+        x in exceptions() -> Exception.message(x)
+      end
 
-    assert result == "undefined function: DoNotExist.for_sure/0"
+    assert result ==
+             "function DoNotExist.for_sure/0 is undefined (module DoNotExist is not available). " <>
+               "Make sure the module name is correct and has been specified in full (or that an alias has been defined)"
   end
-
-  defp zero(0), do: 0
 end
diff --git a/lib/elixir/test/elixir/kernel/sigils_test.exs b/lib/elixir/test/elixir/kernel/sigils_test.exs
index 28e9f232771..d1e3b905974 100644
--- a/lib/elixir/test/elixir/kernel/sigils_test.exs
+++ b/lib/elixir/test/elixir/kernel/sigils_test.exs
@@ -1,21 +1,25 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.SigilsTest do
   use ExUnit.Case, async: true
 
-  test :sigil_s do
+  test "sigil s" do
     assert ~s(foo) == "foo"
     assert ~s(f#{:o}o) == "foo"
     assert ~s(f\no) == "f\no"
   end
 
-  test :sigil_s_with_heredoc do
+  test "sigil s with heredoc" do
     assert "  foo\n\n" == ~s"""
-      f#{:o}o\n
-    """
+             f#{:o}o\n
+           """
   end
 
-  test :sigil_S do
+  test "sigil S" do
     assert ~S(foo) == "foo"
     assert ~S[foo] == "foo"
     assert ~S{foo} == "foo"
@@ -25,37 +29,56 @@ defmodule Kernel.SigilsTest do
     assert ~S/foo/ == "foo"
     assert ~S|foo| == "foo"
     assert ~S(f#{o}o) == "f\#{o}o"
+    assert ~S(f\#{o}o) == "f\\\#{o}o"
     assert ~S(f\no) == "f\\no"
   end
 
-  test :sigil_S_with_heredoc do
+  test "sigil S newline" do
+    assert ~S(foo\
+bar) in ["foo\\\nbar", "foo\\\r\nbar"]
+  end
+
+  test "sigil S with heredoc" do
     assert "  f\#{o}o\\n\n" == ~S"""
-      f#{o}o\n
-    """
+             f#{o}o\n
+           """
   end
 
-  test :sigil_c do
-    assert ~c(foo) == 'foo'
-    assert ~c(f#{:o}o) == 'foo'
-    assert ~c(f\no) == 'f\no'
+  test "sigil s/S expand to binary when possible" do
+    assert Macro.expand(quote(do: ~s(foo)), __ENV__) == "foo"
+    assert Macro.expand(quote(do: ~S(foo)), __ENV__) == "foo"
   end
 
-  test :sigil_C do
-    assert ~C(foo) == 'foo'
-    assert ~C[foo] == 'foo'
-    assert ~C{foo} == 'foo'
-    assert ~C'foo' == 'foo'
-    assert ~C"foo" == 'foo'
-    assert ~C|foo| == 'foo'
-    assert ~C(f#{o}o) == 'f\#{o}o'
-    assert ~C(f\no) == 'f\\no'
+  test "sigil c" do
+    assert ~c(foo) == ~c"foo"
+    assert ~c(f#{:o}o) == ~c"foo"
+    assert ~c(f\no) == ~c"f\no"
   end
 
-  test :sigil_w do
+  test "sigil C" do
+    assert ~C(foo) == ~c"foo"
+    assert ~C[foo] == ~c"foo"
+    assert ~C{foo} == ~c"foo"
+    assert ~C'foo' == ~c"foo"
+    assert ~C"foo" == ~c"foo"
+    assert ~C|foo| == ~c"foo"
+    assert ~C(f#{o}o) == ~c"f\#{o}o"
+    assert ~C(f\no) == ~c"f\\no"
+  end
+
+  test "sigil w" do
     assert ~w() == []
+    assert ~w([ , ]) == ["[", ",", "]"]
     assert ~w(foo bar baz) == ["foo", "bar", "baz"]
     assert ~w(foo #{:bar} baz) == ["foo", "bar", "baz"]
 
+    assert ~w(#{""}) == []
+    assert ~w(foo #{""}) == ["foo"]
+    assert ~w(#{" foo bar "}) == ["foo", "bar"]
+
+    assert ~w(foo\ #{:bar}) == ["foo", "bar"]
+    assert ~w(foo\ bar) == ["foo", "bar"]
+
     assert ~w(
       foo
       bar
@@ -64,23 +87,27 @@ defmodule Kernel.SigilsTest do
 
     assert ~w(foo bar baz)s == ["foo", "bar", "baz"]
     assert ~w(foo bar baz)a == [:foo, :bar, :baz]
-    assert ~w(foo bar baz)c == ['foo', 'bar', 'baz']
+    assert ~w(foo bar baz)c == [~c"foo", ~c"bar", ~c"baz"]
 
-    bad_modifier = quote do: ~w(foo bar baz)x
+    bad_modifier = quote(do: ~w(foo bar baz)x)
     assert %ArgumentError{} = catch_error(Code.eval_quoted(bad_modifier))
 
-    assert ~w(Foo Bar)a == [:"Foo", :"Bar"]
+    assert ~w(Foo Bar)a == [:Foo, :Bar]
     assert ~w(Foo.#{Bar}.Baz)a == [:"Foo.Elixir.Bar.Baz"]
     assert ~w(Foo.Bar)s == ["Foo.Bar"]
-    assert ~w(Foo.#{Bar})c == ['Foo.Elixir.Bar']
+    assert ~w(Foo.#{Bar})c == [~c"Foo.Elixir.Bar"]
 
     # Ensure it is fully expanded at compile time
     assert Macro.expand(quote(do: ~w(a b c)a), __ENV__) == [:a, :b, :c]
   end
 
-  test :sigil_W do
+  test "sigil W" do
+    assert ~W() == []
+    assert ~W([ , ]) == ["[", ",", "]"]
     assert ~W(foo #{bar} baz) == ["foo", "\#{bar}", "baz"]
 
+    assert ~W(foo\ bar) == ["foo\\", "bar"]
+
     assert ~W(
       foo
       bar
@@ -89,20 +116,32 @@ defmodule Kernel.SigilsTest do
 
     assert ~W(foo bar baz)s == ["foo", "bar", "baz"]
     assert ~W(foo bar baz)a == [:foo, :bar, :baz]
-    assert ~W(foo bar baz)c == ['foo', 'bar', 'baz']
+    assert ~W(foo bar baz)c == [~c"foo", ~c"bar", ~c"baz"]
 
-    bad_modifier = quote do: ~W(foo bar baz)x
+    bad_modifier = quote(do: ~W(foo bar baz)x)
     assert %ArgumentError{} = catch_error(Code.eval_quoted(bad_modifier))
 
-    assert ~W(Foo #{Bar})a == [:"Foo", :"\#{Bar}"]
+    assert ~W(Foo #{Bar})a == [:Foo, :"\#{Bar}"]
     assert ~W(Foo.Bar.Baz)a == [:"Foo.Bar.Baz"]
   end
 
-  test :sigils_matching do
+  test "sigils matching" do
     assert ~s(f\(oo) == "f(oo"
     assert ~s(fo\)o) == "fo)o"
     assert ~s(f\(o\)o) == "f(o)o"
     assert ~s(f[oo) == "f[oo"
     assert ~s(fo]o) == "fo]o"
   end
+
+  describe "multi-letter sigils" do
+    def sigil_MAT(string, modifiers) do
+      %{matrix: string, modifiers: modifiers}
+    end
+
+    test "sigil MAT" do
+      assert ~MAT"foo" == %{matrix: "foo", modifiers: []}
+      assert ~MAT[foo]i == %{matrix: "foo", modifiers: ~c"i"}
+      assert ~MAT("1")mod == %{matrix: "\"1\"", modifiers: ~c"mod"}
+    end
+  end
 end
diff --git a/lib/elixir/test/elixir/kernel/special_forms_test.exs b/lib/elixir/test/elixir/kernel/special_forms_test.exs
new file mode 100644
index 00000000000..c05a6aac1cf
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/special_forms_test.exs
@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.SpecialFormsTest do
+  use ExUnit.Case, async: true
+
+  doctest Kernel.SpecialForms
+
+  describe "cond" do
+    test "does not leak variables for one clause" do
+      x = 0
+
+      cond do
+        true ->
+          x = 1
+          x
+      end
+
+      assert x == 0
+    end
+
+    test "does not leak variables for one clause with non-boolean as catch-all" do
+      x = 0
+
+      cond do
+        :otherwise ->
+          x = 1
+          x
+      end
+
+      assert x == 0
+    end
+
+    test "does not leak variables for multiple clauses" do
+      x = 0
+
+      cond do
+        List.flatten([]) == [] ->
+          x = 1
+          x
+
+        true ->
+          x = 1
+          x
+      end
+
+      assert x == 0
+    end
+
+    test "does not leak variables from conditions" do
+      x = :not_nil
+
+      result =
+        cond do
+          x = List.first([]) ->
+            x
+
+          true ->
+            x
+        end
+
+      assert result == :not_nil
+    end
+
+    test "does not warn on non-boolean as catch-all" do
+      cond do
+        List.flatten([]) == [] -> :good
+        :otherwise -> :also_good
+      end
+    end
+
+    test "cond_clause error keeps line number in stacktrace" do
+      try do
+        cond do
+          Process.get(:unused, false) -> :ok
+        end
+      rescue
+        _ ->
+          assert [{Kernel.SpecialFormsTest, _, _, meta} | _] = __STACKTRACE__
+          assert meta[:file]
+          assert meta[:line]
+      end
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/string_tokenizer_test.exs b/lib/elixir/test/elixir/kernel/string_tokenizer_test.exs
new file mode 100644
index 00000000000..316b5d1de41
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/string_tokenizer_test.exs
@@ -0,0 +1,197 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.StringTokenizerTest do
+  use ExUnit.Case, async: true
+
+  defp var({var, _, nil}), do: var
+  defp aliases({:__aliases__, _, [alias]}), do: alias
+
+  test "tokenizes vars" do
+    assert Code.string_to_quoted!("_12") |> var() == :_12
+    assert Code.string_to_quoted!("ola") |> var() == :ola
+    assert Code.string_to_quoted!("ólá") |> var() == :ólá
+    assert Code.string_to_quoted!("óLÁ") |> var() == :óLÁ
+    assert Code.string_to_quoted!("ólá?") |> var() == :ólá?
+    assert Code.string_to_quoted!("ólá!") |> var() == :ólá!
+    assert Code.string_to_quoted!("こんにちは世界") |> var() == :こんにちは世界
+    assert {:error, _} = Code.string_to_quoted("v@r")
+    assert {:error, _} = Code.string_to_quoted("1var")
+  end
+
+  test "tokenizes atoms" do
+    assert Code.string_to_quoted!(":_12") == :_12
+    assert Code.string_to_quoted!(":ola") == :ola
+    assert Code.string_to_quoted!(":ólá") == :ólá
+    assert Code.string_to_quoted!(":ólá?") == :ólá?
+    assert Code.string_to_quoted!(":ólá!") == :ólá!
+    assert Code.string_to_quoted!(":ól@") == :ól@
+    assert Code.string_to_quoted!(":ól@!") == :ól@!
+    assert Code.string_to_quoted!(":ó@@!") == :ó@@!
+    assert Code.string_to_quoted!(":Ola") == :Ola
+    assert Code.string_to_quoted!(":Ólá") == :Ólá
+    assert Code.string_to_quoted!(":ÓLÁ") == :ÓLÁ
+    assert Code.string_to_quoted!(":ÓLÁ?") == :ÓLÁ?
+    assert Code.string_to_quoted!(":ÓLÁ!") == :ÓLÁ!
+    assert Code.string_to_quoted!(":ÓL@!") == :ÓL@!
+    assert Code.string_to_quoted!(":Ó@@!") == :Ó@@!
+    assert Code.string_to_quoted!(":こんにちは世界") == :こんにちは世界
+    assert {:error, _} = Code.string_to_quoted(":123")
+    assert {:error, _} = Code.string_to_quoted(":@123")
+  end
+
+  test "tokenizes keywords" do
+    assert Code.string_to_quoted!("[_12: 0]") == [_12: 0]
+    assert Code.string_to_quoted!("[ola: 0]") == [ola: 0]
+    assert Code.string_to_quoted!("[ólá: 0]") == [ólá: 0]
+    assert Code.string_to_quoted!("[ólá?: 0]") == [ólá?: 0]
+    assert Code.string_to_quoted!("[ólá!: 0]") == [ólá!: 0]
+    assert Code.string_to_quoted!("[ól@: 0]") == [ól@: 0]
+    assert Code.string_to_quoted!("[ól@!: 0]") == [ól@!: 0]
+    assert Code.string_to_quoted!("[ó@@!: 0]") == [ó@@!: 0]
+    assert Code.string_to_quoted!("[Ola: 0]") == [Ola: 0]
+    assert Code.string_to_quoted!("[Ólá: 0]") == [Ólá: 0]
+    assert Code.string_to_quoted!("[ÓLÁ: 0]") == [ÓLÁ: 0]
+    assert Code.string_to_quoted!("[ÓLÁ?: 0]") == [ÓLÁ?: 0]
+    assert Code.string_to_quoted!("[ÓLÁ!: 0]") == [ÓLÁ!: 0]
+    assert Code.string_to_quoted!("[ÓL@!: 0]") == [ÓL@!: 0]
+    assert Code.string_to_quoted!("[Ó@@!: 0]") == [Ó@@!: 0]
+    assert Code.string_to_quoted!("[こんにちは世界: 0]") == [こんにちは世界: 0]
+    assert {:error, _} = Code.string_to_quoted("[123: 0]")
+    assert {:error, _} = Code.string_to_quoted("[@123: 0]")
+  end
+
+  test "tokenizes aliases" do
+    assert Code.string_to_quoted!("Ola") |> aliases() == String.to_atom("Ola")
+    assert Code.string_to_quoted!("M_123") |> aliases() == String.to_atom("M_123")
+    assert {:error, _} = Code.string_to_quoted("Óla")
+    assert {:error, _} = Code.string_to_quoted("Olá")
+    assert {:error, _} = Code.string_to_quoted("Ol@")
+    assert {:error, _} = Code.string_to_quoted("Ola?")
+    assert {:error, _} = Code.string_to_quoted("Ola!")
+  end
+
+  test "tokenizes remote calls" do
+    # We chose the atom below because Erlang represents it using nested lists
+    assert {{:., _, [:foo, :บูมเมอแรง]}, _, []} =
+             Code.string_to_quoted!(":foo.บูมเมอแรง()")
+
+    assert {{:., _, [:foo, :บูมเมอแรง]}, _, []} =
+             Code.string_to_quoted!(":foo.\"บูมเมอแรง\"()")
+  end
+
+  describe "script mixing" do
+    test "prevents Restricted codepoints in identifiers" do
+      exception = assert_raise SyntaxError, fn -> Code.string_to_quoted!("_shibㅤ = 1") end
+
+      assert Exception.message(exception) =~
+               "unexpected token: \"ㅤ\" (column 6, code point U+3164)"
+    end
+
+    test "prevents unsafe mixing in identifiers" do
+      exception =
+        assert_raise SyntaxError, fn ->
+          Code.string_to_quoted!("if аdmin_, do: :ok, else: :err")
+        end
+
+      assert Exception.message(exception) =~ "nofile:1:9:"
+      assert Exception.message(exception) =~ "invalid mixed-script identifier found: аdmin"
+
+      for s <- [
+            "\\u0430 а {Cyrillic}",
+            "\\u0064 d {Latin}",
+            "\\u006D m {Latin}",
+            "\\u0069 i {Latin}",
+            "\\u006E n {Latin}",
+            "\\u005F _"
+          ] do
+        assert Exception.message(exception) =~ s
+      end
+
+      # includes suggestion about what to change
+      assert Exception.message(exception) =~ """
+             Hint: You could write the above in a similar way that is accepted by Elixir:
+             """
+
+      assert Exception.message(exception) =~ """
+             "admin_" (code points 0x00061 0x00064 0x0006D 0x00069 0x0006E 0x0005F)
+             """
+
+      # a is in cyrillic
+      assert_raise SyntaxError, ~r/mixed/, fn -> Code.string_to_quoted!("[аdmin: 1]") end
+      assert_raise SyntaxError, ~r/mixed/, fn -> Code.string_to_quoted!("[{:аdmin, 1}]") end
+      assert_raise SyntaxError, ~r/mixed/, fn -> Code.string_to_quoted!("quote do: аdmin(1)") end
+
+      # c is Latin
+      assert_raise SyntaxError, ~r/mixed/, fn -> Code.string_to_quoted!("http_cервер = 1") end
+
+      # T is in cyrillic
+      assert_raise SyntaxError, ~r/mixed/, fn -> Code.string_to_quoted!("[Тシャツ: 1]") end
+    end
+
+    test "allows legitimate script mixing" do
+      # Mixed script with supersets, numbers, and underscores
+      assert Code.eval_string("幻한 = 1") == {1, [幻한: 1]}
+      assert Code.eval_string("幻한1 = 1") == {1, [幻한1: 1]}
+      assert Code.eval_string("__सवव_1? = 1") == {1, [__सवव_1?: 1]}
+
+      # Elixir's normalizations combine scriptsets of the 'from' and 'to' characters,
+      # ex: {Common} MICRO => {Greek} MU == {Common, Greek}; Common intersects w/all
+      assert Code.eval_string("μs = 1") == {1, [μs: 1]}
+
+      # Mixed scripts in variables
+      assert Code.eval_string("http_сервер = 1") == {1, [http_сервер: 1]}
+      assert Code.eval_string("сервер_http = 1") == {1, [сервер_http: 1]}
+
+      # Mixed scripts in atoms
+      assert Code.eval_string(":T_シャツ") == {:T_シャツ, []}
+    end
+
+    test "bidi" do
+      # test that the implementation of String.Tokenizer.Security.unbidify/1 agrees
+      # w/Unicode Bidi Algo (UAX9) for these (identifier-specific, no-bracket) examples
+      #
+      # you can create new examples with: https://util.unicode.org/UnicodeJsps/bidic.jsp?s=foo_%D9%84%D8%A7%D9%85%D8%AF%D8%A7_baz&b=0&u=140&d=2
+      # inspired by (none of these are directly usable for our idents): https://www.unicode.org/Public/UCD/latest/ucd/BidiCharacterTest.txt
+      #
+      # there's a spurious ;A; after the identifier, because the semicolon is dir-neutral, and
+      # deleting it makes these examples hard to read in many/most editors!
+      """
+      foo;A;0066 006F 006F;0 1 2
+      _foo_ ;A;005F 0066 006F 006F 005F;0 1 2 3 4
+      __foo__ ;A;005F 005F 0066 006F 006F 005F 005F;0 1 2 3 4 5 6
+      لامدا_foo ;A;0644 0627 0645 062F 0627 005F 0066 006F 006F;4 3 2 1 0 5 6 7 8
+      foo_لامدا_baz ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627 005F 0062 0061 007A;0 1 2 3 8 7 6 5 4 9 10 11 12
+      foo_لامدا ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627;0 1 2 3 8 7 6 5 4
+      foo_لامدا1 ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627 0031;0 1 2 3 9 8 7 6 5 4
+      foo_لامدا_حدد ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627 005F 062D 062F 062F;0 1 2 3 12 11 10 9 8 7 6 5 4
+      foo_لامدا_حدد1 ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627 005F 062D 062F 062F 0031;0 1 2 3 13 12 11 10 9 8 7 6 5 4
+      foo_لامدا_حدد1_bar ;A; 0066 006F 006F 005F 0644 0627 0645 062F 0627 005F 062D 062F 062F 0031 005F 0062 0061 0072;0 1 2 3 13 12 11 10 9 8 7 6 5 4 14 15 16 17
+      foo_لامدا_حدد1_bar1 ;A;0066 006F 006F 005F 0644 0627 0645 062F 0627 005F 062D 062F 062F 0031 005F 0062 0061 0072 0031;0 1 2 3 13 12 11 10 9 8 7 6 5 4 14 15 16 17 18
+      """
+      |> String.split("\n", trim: true)
+      |> Enum.map(&String.split(&1, ";", trim: true))
+      |> Enum.each(fn
+        [ident, _, bytes, indices | _rest] ->
+          bytes = String.split(bytes, " ", trim: true) |> Enum.map(&String.to_integer(&1, 16))
+          indices = String.split(indices, " ", trim: true) |> Enum.map(&String.to_integer/1)
+          display_ordered = for i <- indices, do: Enum.at(bytes, i)
+          unbidified = String.Tokenizer.Security.unbidify(bytes)
+
+          if display_ordered != unbidified do
+            raise """
+            Failing String.Tokenizer.Security.unbidify/1 case for: '#{ident}'
+              bytes        : #{bytes |> Enum.map(&Integer.to_string(&1, 16)) |> Enum.join(" ")}
+              byte order   : #{bytes |> Enum.intersperse(32)}
+              uax9 order   : #{display_ordered |> Enum.intersperse(32)}
+              uax9 indices : #{indices |> Enum.join(" ")}
+              unbidify/1   : #{unbidified |> Enum.intersperse(32)}
+            """
+          end
+      end)
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/tracers_test.exs b/lib/elixir/test/elixir/kernel/tracers_test.exs
new file mode 100644
index 00000000000..240cb24a9ed
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/tracers_test.exs
@@ -0,0 +1,401 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.TracersTest do
+  use ExUnit.Case
+
+  defp compile_string(string) do
+    string
+    |> Code.string_to_quoted!(columns: true)
+    |> Code.compile_quoted()
+  end
+
+  def trace(event, %Macro.Env{} = env) do
+    for {pid, _} <- Registry.lookup(__MODULE__, :tracers) do
+      send(pid, {event, env})
+    end
+
+    :ok
+  end
+
+  setup_all do
+    start_supervised!({Registry, keys: :duplicate, name: __MODULE__})
+    Code.put_compiler_option(:tracers, [__MODULE__])
+
+    on_exit(fn ->
+      Code.put_compiler_option(:tracers, [])
+    end)
+  end
+
+  setup do
+    Registry.register(__MODULE__, :tracers, :unused)
+    :ok
+  end
+
+  test "traces start and stop" do
+    compile_string("""
+    Foo
+    """)
+
+    assert_received {:start, %{lexical_tracker: pid}} when is_pid(pid)
+    assert_received {:stop, %{lexical_tracker: pid}} when is_pid(pid)
+  end
+
+  test "traces alias references" do
+    compile_string("""
+    Foo
+    """)
+
+    assert_received {{:alias_reference, meta, Foo}, _}
+    assert meta[:line] == 1
+    assert meta[:column] == 1
+  end
+
+  test "traces aliases" do
+    compile_string("""
+    alias Hello.World
+    World
+
+    alias Foo, as: Bar, warn: true
+    Bar
+    """)
+
+    assert_received {{:alias, meta, Hello.World, World, []}, _}
+    assert meta[:line] == 1
+    assert meta[:column] == 1
+    assert_received {{:alias_expansion, meta, World, Hello.World}, _}
+    assert meta[:line] == 2
+    assert meta[:column] == 1
+
+    assert_received {{:alias, meta, Foo, Bar, [as: Bar, warn: true]}, _}
+    assert meta[:line] == 4
+    assert meta[:column] == 1
+    assert_received {{:alias_expansion, meta, Bar, Foo}, _}
+    assert meta[:line] == 5
+    assert meta[:column] == 1
+  end
+
+  test "traces imports" do
+    compile_string("""
+    import Integer, only: [is_odd: 1, parse: 1]
+    true = is_odd(1)
+    {1, ""} = parse("1")
+    """)
+
+    assert_received {{:import, meta, Integer, only: [is_odd: 1, parse: 1]}, _}
+    assert meta[:line] == 1
+    assert meta[:column] == 1
+
+    assert_received {{:imported_macro, meta, Integer, :is_odd, 1}, _}
+    assert meta[:line] == 2
+    assert meta[:column] == 8
+
+    assert_received {{:imported_function, meta, Integer, :parse, 1}, _}
+    assert meta[:line] == 3
+    assert meta[:column] == 11
+
+    refute_received {{:remote_function, _, Integer, :parse, 1}, _}
+  end
+
+  test "traces imports via capture" do
+    compile_string("""
+    import Integer, only: [is_odd: 1, parse: 1]
+    &is_odd/1
+    &parse/1
+    """)
+
+    assert_received {{:import, meta, Integer, only: [is_odd: 1, parse: 1]}, _}
+    assert meta[:line] == 1
+    assert meta[:column] == 1
+
+    assert_received {{:imported_macro, meta, Integer, :is_odd, 1}, _}
+    assert meta[:line] == 2
+    assert meta[:column] == 2
+
+    assert_received {{:imported_function, meta, Integer, :parse, 1}, _}
+    assert meta[:line] == 3
+    assert meta[:column] == 2
+
+    refute_received {{:remote_function, _meta, Integer, :parse, 1}, _}
+  end
+
+  test "traces structs" do
+    compile_string("""
+    %URI{path: "/"}
+    """)
+
+    assert_received {{:struct_expansion, meta, URI, [:path]}, _}
+    assert meta[:line] == 1
+    assert meta[:column] == 1
+  end
+
+  test "traces remote" do
+    compile_string("""
+    require Integer
+    true = Integer.is_odd(1)
+    {1, ""} = Integer.parse("1")
+    "foo" = Atom.to_string(:foo)
+    """)
+
+    assert_received {{:remote_macro, meta, Integer, :is_odd, 1}, _}
+    assert meta[:line] == 2
+    assert meta[:column] == 16
+
+    assert_received {{:remote_function, meta, Integer, :parse, 1}, _}
+    assert meta[:line] == 3
+    assert meta[:column] == 19
+
+    assert_received {{:remote_function, meta, Atom, :to_string, 1}, _}
+    assert meta[:line] == 4
+    assert meta[:column] == 14
+  end
+
+  test "traces remote via captures" do
+    compile_string("""
+    require Integer
+    &Integer.is_odd/1
+    &Integer.parse/1
+    """)
+
+    assert_received {{:remote_macro, meta, Integer, :is_odd, 1}, _}
+    assert meta[:line] == 2
+    assert meta[:column] == 10
+
+    assert_received {{:remote_function, meta, Integer, :parse, 1}, _}
+    assert meta[:line] == 3
+    assert meta[:column] == 10
+  end
+
+  test "traces locals" do
+    compile_string("""
+    defmodule Sample do
+      defmacro foo(arg), do: arg
+      def bar(arg), do: arg
+      def baz(arg), do: foo(arg) + bar(arg)
+    end
+    """)
+
+    assert_received {{:local_macro, meta, :foo, 1}, _}
+    assert meta[:line] == 4
+    assert meta[:column] == 21
+
+    assert_received {{:local_function, meta, :bar, 1}, _}
+    assert meta[:line] == 4
+    assert meta[:column] == 32
+  after
+    :code.purge(Sample)
+    :code.delete(Sample)
+  end
+
+  test "traces locals with capture" do
+    compile_string("""
+    defmodule Sample do
+      defmacro foo(arg), do: arg
+      def bar(arg), do: arg
+      def baz(_), do: {&foo/1, &bar/1}
+    end
+    """)
+
+    assert_received {{:local_macro, meta, :foo, 1}, _}
+    assert meta[:line] == 4
+    assert meta[:column] == 21
+
+    assert_received {{:local_function, meta, :bar, 1}, _}
+    assert meta[:line] == 4
+    assert meta[:column] == 29
+  after
+    :code.purge(Sample)
+    :code.delete(Sample)
+  end
+
+  test "traces modules" do
+    compile_string("""
+    defmodule Sample do
+      :ok
+    end
+    """)
+
+    assert_received {:defmodule, %{module: Sample, function: nil}}
+    assert_received {{:on_module, <<_::binary>>, :none}, %{module: Sample, function: nil}}
+  after
+    :code.purge(Sample)
+    :code.delete(Sample)
+  end
+
+  test "traces dynamic modules" do
+    compile_string("""
+    Module.create(Sample, :ok, __ENV__)
+    """)
+
+    assert_received {:defmodule, %{module: Sample, function: nil}}
+    assert_received {{:on_module, <<_::binary>>, :none}, %{module: Sample, function: nil}}
+  after
+    :code.purge(Sample)
+    :code.delete(Sample)
+  end
+
+  test "traces module attribute expansion" do
+    compile_string("""
+    defmodule TracersModuleAttribute do
+      @module URI
+      @module
+    end
+    """)
+
+    assert_received {{:alias_reference, [line: 3], URI}, %{file: "@module"}}
+  end
+
+  test "traces string interpolation" do
+    compile_string("""
+    arg = 1 + 2
+    "foo\#{arg}"
+    """)
+
+    assert_received {{:remote_macro, meta, Kernel, :to_string, 1}, _env}
+    assert meta[:from_interpolation]
+  end
+
+  test "traces bracket access" do
+    compile_string("""
+    foo = %{bar: 3}
+    foo[:bar]
+    """)
+
+    assert_received {{:remote_function, meta, Access, :get, 2}, _env}
+    assert meta[:from_brackets]
+
+    compile_string("""
+    defmodule TracerBracketAccess do
+      @foo %{bar: 3}
+      def a() do
+        @foo[:bar]
+      end
+    end
+    """)
+
+    assert_received {{:remote_function, meta, Access, :get, 2}, _env}
+    assert meta[:from_brackets]
+
+    compile_string("""
+    %{bar: 3}[:bar]
+    """)
+
+    assert_received {{:remote_function, meta, Access, :get, 2}, _env}
+    assert meta[:from_brackets]
+  end
+
+  test "traces on_load" do
+    compile_string("""
+    defmodule TracerOnLoad do
+      @on_load :init
+      def init, do: :ok
+    end
+    """)
+
+    assert_received {{:local_function, meta, :init, 0}, _}
+    assert meta[:line] == 1
+  end
+
+  def __before_compile__(_), do: :ok
+  def __after_compile__(_, _), do: :ok
+  def __after_verify__(_), do: :ok
+  def __on_definition__(_, _, _, _, _, _), do: :ok
+
+  test "traces compile time attributes" do
+    compile_string("""
+    defmodule TracerCompileAttributes do
+      @before_compile Kernel.TracersTest
+      @after_compile Kernel.TracersTest
+      @on_definition Kernel.TracersTest
+      @after_verify Kernel.TracersTest
+      def hello, do: :world
+    end
+    """)
+
+    assert_received {{:remote_function, meta, __MODULE__, :__before_compile__, 1}, _}
+    assert meta[:line] == 1
+
+    assert_received {{:remote_function, meta, __MODULE__, :__after_compile__, 2}, _}
+    assert meta[:line] == 1
+
+    assert_received {{:remote_function, meta, __MODULE__, :__after_verify__, 1}, _}
+    assert meta[:line] == 1
+
+    assert_received {{:remote_function, meta, __MODULE__, :__on_definition__, 6}, _}
+    assert meta[:line] == 6
+  end
+
+  test "traces super" do
+    compile_string("""
+    defmodule TracerOverridable do
+      def local(x), do: x
+      defoverridable [local: 1]
+      def local(x), do: super(x)
+
+      defmacro macro(x), do: x
+      defoverridable [macro: 1]
+      defmacro macro(x), do: super(x)
+
+      def capture(x), do: x
+      defoverridable [capture: 1]
+      def capture(x), do: tap(x, &super/1)
+
+      def capture_arg(x), do: x
+      defoverridable [capture_arg: 1]
+      def capture_arg(x), do: tap(x, &super(&1))
+    end
+    """)
+
+    assert_received {{:local_function, _, :"local (overridable 1)", 1}, _}
+    assert_received {{:local_function, _, :"macro (overridable 1)", 1}, _}
+    assert_received {{:local_function, _, :"capture (overridable 1)", 1}, _}
+    assert_received {{:local_function, _, :"capture_arg (overridable 1)", 1}, _}
+    refute_received {{:local_function, _, _, _}, _}
+  end
+
+  test "does not trace bind quoted twice" do
+    compile_string("""
+    quote bind_quoted: [foo: List.flatten([])] do
+      foo
+    end
+    """)
+
+    assert_received {{:remote_function, _, List, :flatten, 1}, _}
+    refute_received {{:remote_function, _, List, :flatten, 1}, _}
+  end
+
+  test "does not trace captures twice" do
+    compile_string("""
+    &List.flatten/1
+    """)
+
+    assert_received {{:remote_function, _, List, :flatten, 1}, _}
+    refute_received {{:remote_function, _, List, :flatten, 1}, _}
+  end
+
+  """
+  # Make sure this module is compiled with column information
+  defmodule MacroWithColumn do
+    defmacro some_macro(list) do
+      quote do
+        Enum.map(unquote(list), fn str -> String.upcase(str) end)
+      end
+    end
+  end
+  """
+  |> Code.string_to_quoted!(columns: true)
+  |> Code.compile_quoted()
+
+  test "traces quoted from macro expansion without column information" do
+    compile_string("""
+    require MacroWithColumn
+    MacroWithColumn.some_macro(["hello", "world", "!"])
+    """)
+
+    assert_received {{:alias_reference, meta, Enum}, _env}
+    refute meta[:column]
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel/typespec_test.exs b/lib/elixir/test/elixir/kernel/typespec_test.exs
deleted file mode 100644
index 80908987812..00000000000
--- a/lib/elixir/test/elixir/kernel/typespec_test.exs
+++ /dev/null
@@ -1,549 +0,0 @@
-Code.require_file "../test_helper.exs", __DIR__
-
-defmodule Kernel.TypespecTest do
-  use ExUnit.Case, async: true
-
-  # This macro allows us to focus on the result of the
-  # definition and not on the hassles of handling test
-  # module
-  defmacrop test_module([{:do, block}]) do
-    quote do
-      {:module, _, binary, _} = defmodule TestTypespec do
-        unquote(block)
-      end
-      :code.delete(TestTypespec)
-      :code.purge(TestTypespec)
-      binary
-    end
-  end
-
-  defp types(module) do
-    Kernel.Typespec.beam_types(module)
-    |> Enum.sort
-  end
-
-  @skip_specs [__info__: 1]
-
-  defp specs(module) do
-    Kernel.Typespec.beam_specs(module)
-    |> Enum.reject(fn {sign, _} -> sign in @skip_specs end)
-    |> Enum.sort()
-  end
-
-  defp callbacks(module) do
-    Kernel.Typespec.beam_callbacks(module)
-    |> Enum.sort
-  end
-
-  test "invalid type specification" do
-    assert_raise CompileError, ~r"invalid type specification: mytype = 1", fn ->
-      test_module do
-        @type mytype = 1
-      end
-    end
-  end
-
-  test "invalid function specification" do
-    assert_raise CompileError, ~r"invalid function type specification: myfun = 1", fn ->
-      test_module do
-        @spec myfun = 1
-      end
-    end
-  end
-
-  test "@type with a single type" do
-    module = test_module do
-      @type mytype :: term
-    end
-
-    assert [type: {:mytype, {:type, _, :term, []}, []}] =
-           types(module)
-  end
-
-  test "@type with an atom" do
-    module = test_module do
-      @type mytype :: :atom
-    end
-
-    assert [type: {:mytype, {:atom, _, :atom}, []}] =
-           types(module)
-  end
-
-  test "@type with an atom alias" do
-    module = test_module do
-      @type mytype :: Atom
-    end
-
-    assert [type: {:mytype, {:atom, _, Atom}, []}] =
-           types(module)
-  end
-
-  test "@type with an integer" do
-    module = test_module do
-      @type mytype :: 10
-    end
-    assert [type: {:mytype, {:integer, _, 10}, []}] =
-           types(module)
-  end
-
-  test "@type with a negative integer" do
-    module = test_module do
-      @type mytype :: -10
-    end
-
-    assert [type: {:mytype, {:op, _, :-, {:integer, _, 10}}, []}] =
-           types(module)
-  end
-
-  test "@type with a remote type" do
-    module = test_module do
-      @type mytype :: Remote.Some.type
-      @type mytype_arg :: Remote.type(integer)
-    end
-
-    assert [type: {:mytype, {:remote_type, _, [{:atom, _, Remote.Some}, {:atom, _, :type}, []]}, []},
-            type: {:mytype_arg, {:remote_type, _, [{:atom, _, Remote}, {:atom, _, :type}, [{:type, _, :integer, []}]]}, []}] =
-           types(module)
-  end
-
-  test "@type with a binary" do
-    module = test_module do
-      @type mytype :: binary
-    end
-
-    assert [type: {:mytype, {:type, _, :binary, []}, []}] =
-           types(module)
-  end
-
-  test "@type with an empty binary" do
-    module = test_module do
-      @type mytype :: <<>>
-    end
-
-    assert [type: {:mytype, {:type, _, :binary, [{:integer, _, 0}, {:integer, _, 0}]}, []}] =
-           types(module)
-  end
-
-  test "@type with a binary with a base size" do
-    module = test_module do
-      @type mytype :: <<_ :: 3>>
-    end
-
-    assert [type: {:mytype, {:type, _, :binary, [{:integer, _, 3}, {:integer, _, 0}]}, []}] =
-           types(module)
-  end
-
-  test "@type with a binary with a unit size" do
-    module = test_module do
-      @type mytype :: <<_ :: _ * 8>>
-    end
-
-    assert [type: {:mytype, {:type, _, :binary, [{:integer, _, 0}, {:integer, _, 8}]}, []}] =
-           types(module)
-  end
-
-  test "@type with a range" do
-    module = test_module do
-      @type mytype :: range(1, 10)
-    end
-
-    assert [type: {:mytype, {:type, _, :range, [{:integer, _, 1}, {:integer, _, 10}]}, []}] =
-           types(module)
-  end
-
-  test "@type with a range op" do
-    module = test_module do
-      @type mytype :: 1..10
-    end
-
-    assert [type: {:mytype, {:type, _, :range, [{:integer, _, 1}, {:integer, _, 10}]}, []}] =
-           types(module)
-  end
-
-  test "@type with a map" do
-    module = test_module do
-      @type mytype :: %{hello: :world}
-    end
-
-    assert [type: {:mytype,
-             {:type, _, :map, [
-               {:type, _, :map_field_assoc, {:atom, _, :hello}, {:atom, _, :world}}
-             ]},
-            []}] = types(module)
-  end
-
-  test "@type with a struct" do
-    module = test_module do
-      @type mytype :: %User{hello: :world}
-    end
-
-    assert [type: {:mytype,
-             {:type, _, :map, [
-               {:type, _, :map_field_assoc, {:atom, _, :__struct__}, {:atom, _, User}},
-               {:type, _, :map_field_assoc, {:atom, _, :hello}, {:atom, _, :world}}
-             ]},
-            []}] = types(module)
-  end
-
-  test "@type with a tuple" do
-    module = test_module do
-      @type mytype :: tuple
-      @type mytype1 :: {}
-      @type mytype2 :: {1, 2}
-    end
-
-    assert [type: {:mytype, {:type, _, :tuple, :any}, []},
-            type: {:mytype1, {:type, _, :tuple, []}, []},
-            type: {:mytype2, {:type, _, :tuple, [{:integer, _, 1}, {:integer, _, 2}]}, []}] =
-           types(module)
-  end
-
-  test "@type with list shortcuts" do
-    module = test_module do
-      @type mytype :: []
-      @type mytype1 :: [integer]
-      @type mytype2 :: [integer, ...]
-    end
-
-    assert [type: {:mytype, {:type, _, :nil, []}, []},
-            type: {:mytype1, {:type, _, :list, [{:type, _, :integer, []}]}, []},
-            type: {:mytype2, {:type, _, :nonempty_list, [{:type, _, :integer, []}]}, []}] =
-           types(module)
-  end
-
-  test "@type with a fun" do
-    module = test_module do
-      @type mytype :: (... -> any)
-    end
-
-    assert [type: {:mytype, {:type, _, :fun, []}, []}] =
-           types(module)
-  end
-
-  test "@type with a fun with multiple arguments and return type" do
-    module = test_module do
-      @type mytype :: (integer, integer -> integer)
-    end
-
-    assert [type: {:mytype, {:type, _, :fun, [{:type, _, :product,
-             [{:type, _, :integer, []}, {:type, _, :integer, []}]},
-             {:type, _, :integer, []}]}, []}] =
-           types(module)
-  end
-
-  test "@type with a fun with no arguments and return type" do
-    module = test_module do
-      @type mytype :: (() -> integer)
-    end
-
-    assert [type: {:mytype, {:type, _, :fun, [{:type, _, :product, []},
-             {:type, _, :integer, []}]}, []}] =
-           types(module)
-  end
-
-  test "@type with a fun with any arity and return type" do
-    module = test_module do
-      @type mytype :: (... -> integer)
-    end
-
-    assert [type: {:mytype, {:type, _, :fun, [{:type, _, :any},
-             {:type, _, :integer, []}]}, []}] =
-           types(module)
-  end
-
-  test "@type with a union" do
-    module = test_module do
-      @type mytype :: integer | char_list | atom
-    end
-
-    assert [type: {:mytype, {:type, _, :union, [{:type, _, :integer, []},
-             {:remote_type, _, [{:atom, _, :elixir}, {:atom, _, :char_list}, []]},
-             {:type, _, :atom, []}]}, []}] =
-           types(module)
-  end
-
-  test "@type with keywords" do
-    module = test_module do
-      @type mytype :: [first: integer, step: integer, last: integer]
-    end
-
-    assert [type: {:mytype, {:type, _, :list, [
-      {:type, _, :union, [
-        {:type, _, :tuple, [{:atom, _, :first}, {:type, _, :integer, []}]},
-        {:type, _, :tuple, [{:atom, _, :step}, {:type, _, :integer, []}]},
-        {:type, _, :tuple, [{:atom, _, :last}, {:type, _, :integer, []}]}
-      ]}
-    ]}, []}] = types(module)
-  end
-
-  test "@type with parameters" do
-    module = test_module do
-      @type mytype(x) :: x
-      @type mytype1(x) :: list(x)
-      @type mytype2(x, y) :: {x, y}
-    end
-
-    assert [type: {:mytype, {:var, _, :x}, [{:var, _, :x}]},
-            type: {:mytype1, {:type, _, :list, [{:var, _, :x}]}, [{:var, _, :x}]},
-            type: {:mytype2, {:type, _, :tuple, [{:var, _, :x}, {:var, _, :y}]}, [{:var, _, :x}, {:var, _, :y}]}] =
-           types(module)
-  end
-
-  test "@type with annotations" do
-    module = test_module do
-      @type mytype :: (named :: integer)
-      @type mytype1 :: (a :: integer -> integer)
-    end
-
-    assert [type: {:mytype, {:ann_type, _, [{:var, _, :named}, {:type, _, :integer, []}]}, []},
-            type: {:mytype1, {:type, _, :fun, [{:type, _, :product, [{:ann_type, _, [{:var, _, :a}, {:type, _, :integer, []}]}]}, {:type, _, :integer, []}]}, []}] =
-           types(module)
-  end
-
-  test "@opaque(type)" do
-    module = test_module do
-      @opaque mytype(x) :: x
-    end
-
-    assert [opaque: {:mytype, {:var, _, :x}, [{:var, _, :x}]}] =
-           types(module)
-  end
-
-  test "@type + opaque" do
-    module = test_module do
-      @type mytype :: tuple
-      @opaque mytype1 :: {}
-    end
-
-    assert [opaque: {:mytype1, _, []},
-            type: {:mytype, _, []},] =
-           types(module)
-  end
-
-  test "@type from structs" do
-    module = test_module do
-      defstruct name: nil, age: 0 :: non_neg_integer
-    end
-
-    assert [type: {:t, {:type, _, :map, [
-              {:type, _, :map_field_assoc, {:atom, _, :name}, {:type, _, :term, []}},
-              {:type, _, :map_field_assoc, {:atom, _, :age}, {:type, _, :non_neg_integer, []}},
-              {:type, _, :map_field_assoc, {:atom, _, :__struct__}, {:atom, _, TestTypespec}}
-           ]}, []}] = types(module)
-  end
-
-  test "@type from dynamic structs" do
-    module = test_module do
-      fields = [name: nil, age: 0]
-      defstruct fields
-    end
-
-    assert [type: {:t, {:type, _, :map, [
-              {:type, _, :map_field_assoc, {:atom, _, :name}, {:type, _, :term, []}},
-              {:type, _, :map_field_assoc, {:atom, _, :age}, {:type, _, :term, []}},
-              {:type, _, :map_field_assoc, {:atom, _, :__struct__}, {:atom, _, TestTypespec}}
-           ]}, []}] = types(module)
-  end
-
-  test "@type unquote fragment" do
-    module = test_module do
-      quoted = quote unquote: false do
-        name = :mytype
-        type = :atom
-        @type unquote(name)() :: unquote(type)
-      end
-      Module.eval_quoted(__MODULE__, quoted) |> elem(0)
-    end
-
-    assert [type: {:mytype, {:atom, _, :atom}, []}] =
-           types(module)
-  end
-
-  test "defines_type?" do
-    test_module do
-      @type mytype :: tuple
-      @type mytype(a) :: [a]
-      assert Kernel.Typespec.defines_type?(__MODULE__, :mytype, 0)
-      assert Kernel.Typespec.defines_type?(__MODULE__, :mytype, 1)
-      refute Kernel.Typespec.defines_type?(__MODULE__, :mytype, 2)
-    end
-  end
-
-  test "@spec(spec)" do
-    module = test_module do
-      def myfun1(x), do: x
-      def myfun2(), do: :ok
-      def myfun3(x, y), do: {x, y}
-      def myfun4(x), do: x
-      @spec myfun1(integer) :: integer
-      @spec myfun2() :: integer
-      @spec myfun3(integer, integer) :: {integer, integer}
-      @spec myfun4(x :: integer) :: integer
-    end
-
-    assert [{{:myfun1, 1}, [{:type, _, :fun, [{:type, _, :product, [{:type, _, :integer, []}]}, {:type, _, :integer, []}]}]},
-            {{:myfun2, 0}, [{:type, _, :fun, [{:type, _, :product, []}, {:type, _, :integer, []}]}]},
-            {{:myfun3, 2}, [{:type, _, :fun, [{:type, _, :product, [{:type, _, :integer, []}, {:type, _, :integer, []}]}, {:type, _, :tuple, [{:type, _, :integer, []}, {:type, _, :integer, []}]}]}]},
-            {{:myfun4, 1}, [{:type, _, :fun, [{:type, _, :product, [{:ann_type, _, [{:var, _, :x}, {:type, _, :integer, []}]}]}, {:type, _, :integer, []}]}]}] =
-           specs(module)
-  end
-
-  test "@spec(spec) with guards" do
-    module = test_module do
-      def myfun1(x), do: x
-      @spec myfun1(x) :: boolean when [x: integer]
-
-      def myfun2(x), do: x
-      @spec myfun2(x) :: x when [x: var]
-
-      def myfun3(_x, y), do: y
-      @spec myfun3(x, y) :: y when [y: x, x: var]
-    end
-
-    assert [{{:myfun1, 1}, [{:type, _, :bounded_fun, [{:type, _, :fun, [{:type, _, :product, [{:var, _, :x}]}, {:type, _, :boolean, []}]}, [{:type, _, :constraint, [{:atom, _, :is_subtype}, [{:var, _, :x}, {:type, _, :integer, []}]]}]]}]},
-            {{:myfun2, 1}, [{:type, _, :fun, [{:type, _, :product, [{:var, _, :x}]}, {:var, _, :x}]}]},
-            {{:myfun3, 2}, [{:type, _, :bounded_fun, [{:type, _, :fun, [{:type, _, :product, [{:var, _, :x}, {:var, _, :y}]}, {:var, _, :y}]}, [{:type, _, :constraint, [{:atom, _, :is_subtype}, [{:var, _, :y}, {:var, _, :x}]]}]]}]}] =
-           specs(module)
-  end
-
-  test "@callback(callback)" do
-    module = test_module do
-      @callback myfun(integer) :: integer
-      @callback myfun() :: integer
-      @callback myfun(integer, integer) :: {integer, integer}
-    end
-
-    assert [{{:myfun, 0}, [{:type, _, :fun, [{:type, _, :product, []}, {:type, _, :integer, []}]}]},
-            {{:myfun, 1}, [{:type, _, :fun, [{:type, _, :product, [{:type, _, :integer, []}]}, {:type, _, :integer, []}]}]},
-            {{:myfun, 2}, [{:type, _, :fun, [{:type, _, :product, [{:type, _, :integer, []}, {:type, _, :integer, []}]}, {:type, _, :tuple, [{:type, _, :integer, []}, {:type, _, :integer, []}]}]}]}] =
-           callbacks(module)
-  end
-
-  test "@spec + @callback" do
-    module = test_module do
-      def myfun(x), do: x
-      @spec myfun(integer)   :: integer
-      @spec myfun(char_list) :: char_list
-      @callback cb(integer)  :: integer
-    end
-
-    assert [{{:cb, 1}, [{:type, _, :fun, [{:type, _, :product, [{:type, _, :integer, []}]}, {:type, _, :integer, []}]}]}] =
-           callbacks(module)
-
-    assert [{{:myfun, 1}, [
-             {:type, _, :fun, [{:type, _, :product, [
-               {:remote_type, _, [{:atom, _, :elixir}, {:atom, _, :char_list}, []]}]},
-               {:remote_type, _, [{:atom, _, :elixir}, {:atom, _, :char_list}, []]}]},
-             {:type, _, :fun, [{:type, _, :product, [{:type, _, :integer, []}]}, {:type, _, :integer, []}]}]}] =
-           specs(module)
-  end
-
-  test "block handling" do
-    module = test_module do
-      @spec foo((() -> [ integer ])) :: integer
-      def foo(_), do: 1
-    end
-    assert [{{:foo, 1},
-            [{:type, _, :fun, [{:type, _, :product, [
-                     {:type, _, :fun, [{:type, _, :product, []}, {:type, _, :list, [{:type, _, :integer, []}]}]}]},
-                     {:type, _, :integer, []}]}]}] =
-           specs(module)
-  end
-
-  # Conversion to AST
-
-  test "type_to_ast" do
-    quoted = [
-      (quote do: @type with_ann() :: (t :: atom())),
-      (quote do: @type empty_tuple_type() :: {}),
-      (quote do: @type imm_type_1() :: 1),
-      (quote do: @type imm_type_2() :: :atom),
-      (quote do: @type simple_type() :: integer()),
-      (quote do: @type param_type(p) :: [p]),
-      (quote do: @type union_type() :: integer() | binary() | boolean()),
-      (quote do: @type binary_type1() :: <<_ :: _ * 8>>),
-      (quote do: @type binary_type2() :: <<_ :: 3 * 8>>),
-      (quote do: @type binary_type3() :: <<_ :: 3>>),
-      (quote do: @type tuple_type() :: {integer()}),
-      (quote do: @type ftype() :: (() -> any()) | (() -> integer()) | ((integer() -> integer()))),
-      (quote do: @type cl() :: char_list()),
-      (quote do: @type ab() :: as_boolean(term())),
-      (quote do: @type vaf() :: (... -> any())),
-      (quote do: @type rng() :: 1 .. 10),
-      (quote do: @type opts() :: [first: integer(), step: integer(), last: integer()]),
-      (quote do: @type ops() :: {+1,-1}),
-      (quote do: @type my_map() :: %{hello: :world}),
-      (quote do: @type my_struct() :: %User{hello: :world}),
-    ] |> Enum.sort
-
-    module = test_module do
-      Module.eval_quoted __MODULE__, quote do: (unquote_splicing(quoted))
-    end
-
-    types = types(module)
-
-    Enum.each(Enum.zip(types, quoted), fn {{:type, type}, definition} ->
-      ast = Kernel.Typespec.type_to_ast(type)
-      assert Macro.to_string(quote do: @type unquote(ast)) == Macro.to_string(definition)
-    end)
-  end
-
-  test "type_to_ast for paren_type" do
-    type = {:my_type, {:paren_type, 0, [{:type, 0, :integer, []}]}, []}
-    assert Kernel.Typespec.type_to_ast(type) ==
-      {:::, [], [{:my_type, [], []}, {:integer, [line: 0], []}]}
-  end
-
-  test "spec_to_ast" do
-    quoted = [
-      (quote do: @spec a() :: integer()),
-      (quote do: @spec a(atom()) :: integer() | [{}]),
-      (quote do: @spec a(b) :: integer() when [b: integer()]),
-      (quote do: @spec a(b) :: b when [b: var]),
-      (quote do: @spec a(c :: atom()) :: atom()),
-    ] |> Enum.sort
-
-    module = test_module do
-      def a, do: 1
-      def a(a), do: a
-      Module.eval_quoted __MODULE__, quote do: (unquote_splicing(quoted))
-    end
-
-    specs = Enum.flat_map(specs(module), fn {{_, _}, specs} ->
-       Enum.map(specs, fn spec ->
-         quote do: @spec unquote(Kernel.Typespec.spec_to_ast(:a, spec))
-       end)
-     end) |> Enum.sort
-
-    Enum.each(Enum.zip(specs, quoted), fn {spec, definition} ->
-      assert Macro.to_string(spec) == Macro.to_string(definition)
-    end)
-  end
-
-  test "typedoc retrieval" do
-    {:module, _, binary, _} = defmodule T do
-      @typedoc "A"
-      @type a :: any
-      @typep b :: any
-      @typedoc "C"
-      @opaque c(x, y) :: {x, y}
-      @type d :: any
-      @spec uses_b() :: b
-      def uses_b(), do: nil
-    end
-
-    :code.delete(T)
-    :code.purge(T)
-
-    assert [
-      {{:c, 2}, "C"},
-      {{:a, 0}, "A"}
-    ] = Kernel.Typespec.beam_typedocs(binary)
-  end
-
-  test "retrieval invalid data" do
-    assert Kernel.Typespec.beam_typedocs(Unknown) == nil
-    assert Kernel.Typespec.beam_types(Unknown) == nil
-    assert Kernel.Typespec.beam_specs(Unknown) == nil
-  end
-end
diff --git a/lib/elixir/test/elixir/kernel/warning_test.exs b/lib/elixir/test/elixir/kernel/warning_test.exs
index fbfa7dad5f6..58aa6a047ba 100644
--- a/lib/elixir/test/elixir/kernel/warning_test.exs
+++ b/lib/elixir/test/elixir/kernel/warning_test.exs
@@ -1,493 +1,2314 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Kernel.WarningTest do
   use ExUnit.Case
   import ExUnit.CaptureIO
 
-  defp capture_err(fun) do
-    capture_io(:stderr, fun)
+  defp capture_err(fun) when is_function(fun), do: capture_io(:stderr, fun)
+
+  defp assert_messages_match(messages, output) when is_list(messages) do
+    for message <- messages do
+      assert output =~ message
+    end
   end
 
-  test :unused_variable do
-    assert capture_err(fn ->
-      Code.eval_string """
+  defp assert_warn_eval(messages, source) do
+    captured =
+      capture_err(fn ->
+        quoted = Code.string_to_quoted!(source, columns: true)
+        Code.eval_quoted(quoted)
+      end)
+
+    assert_messages_match(messages, captured)
+  end
+
+  defp assert_warn_quoted(messages, source) do
+    captured =
+      capture_err(fn ->
+        Code.string_to_quoted!(source, columns: true)
+      end)
+
+    assert_messages_match(messages, captured)
+  end
+
+  defp assert_warn_compile(messages, source) do
+    captured =
+      capture_err(fn ->
+        quoted = Code.string_to_quoted!(source, columns: true)
+        Code.compile_quoted(quoted)
+      end)
+
+    assert_messages_match(messages, captured)
+  end
+
+  defp capture_eval(source) do
+    capture_err(fn ->
+      quoted = Code.string_to_quoted!(source, columns: true)
+      Code.eval_quoted(quoted)
+    end)
+  end
+
+  defp capture_compile(source) do
+    capture_err(fn ->
+      quoted = Code.string_to_quoted!(source, columns: true)
+      Code.compile_quoted(quoted)
+    end)
+  end
+
+  defmacro will_warn do
+    quote file: "demo", line: true do
+      %{dup: 1, dup: 2}
+    end
+  end
+
+  test "warnings from macro" do
+    assert_warn_eval(
+      ["demo:64\n", "key :dup will be overridden in map\n"],
+      """
+      import Kernel.WarningTest
+      will_warn()
+      """
+    )
+  end
+
+  test "outdented heredoc" do
+    assert_warn_eval(
+      ["nofile:2:3", "outdented heredoc line"],
+      """
+        '''
+      outdented
+        '''
+      """
+    )
+  end
+
+  test "does not warn on incomplete tokenization" do
+    assert {:error, _} = Code.string_to_quoted(~s[:"foobar" do])
+  end
+
+  describe "unicode identifier security" do
+    test "warns on confusables" do
+      assert_warn_quoted(
+        ["nofile:1:6", "confusable identifier: 'a' looks like 'а' on line 1"],
+        "а=1; a=1"
+      )
+
+      assert_warn_quoted(
+        ["nofile:1:12", "confusable identifier: 'a' looks like 'а' on line 1"],
+        "[{:а, 1}, {:a, 1}]"
+      )
+
+      assert_warn_quoted(
+        ["nofile:1:8", "confusable identifier: 'a' looks like 'а' on line 1"],
+        "[а: 1, a: 1]"
+      )
+
+      assert_warn_quoted(
+        ["nofile:1:18", "confusable identifier: 'a' looks like 'а' on line 1"],
+        "quote do: [а(1), a(1)]"
+      )
+
+      assert_warn_quoted(
+        ["nofile:1:6", "confusable identifier: 'カ' looks like '力' on line 1"],
+        "力=1; カ=1"
+      )
+
+      # by convention, doesn't warn on ascii-only confusables
+      assert capture_eval("x0 = xO = 1") == ""
+      assert capture_eval("l1 = ll = 1") == ""
+
+      # works with a custom atom encoder
+      assert capture_err(fn ->
+               Code.string_to_quoted("[{:а, 1}, {:a, 1}]",
+                 static_atoms_encoder: fn token, _ -> {:ok, {:wrapped, token}} end
+               )
+             end) =~
+               "confusable identifier: 'a' looks like 'а' on line 1"
+    end
+
+    test "warns on LTR-confusables" do
+      # warning outputs in byte order (vs bidi algo display order, uax9), mentions presence of rtl
+      assert_warn_quoted(
+        ["nofile:1:9", "'_1א' looks like '_א1'", "right-to-left characters"],
+        "_א1 and _1א"
+      )
+
+      assert_warn_quoted(
+        [
+          "'a_1א' includes right-to-left characters",
+          "\\u0061 a ltr",
+          "\\u005F _ neutral",
+          "\\u0031 1 weak_number",
+          "\\u05D0 א rtl",
+          "'a_א1' includes right-to-left characters:",
+          "\\u0061 a ltr",
+          "\\u005F _ neutral",
+          "\\u05D0 א rtl",
+          "\\u0031 1 weak_number"
+        ],
+        "a_א1 or a_1א"
+      )
+    end
+  end
+
+  test "operators formed by many of the same character followed by that character" do
+    assert_warn_eval(
+      [
+        "nofile:1:12",
+        "found \"+++\" followed by \"+\", please use a space between \"+++\" and the next \"+\""
+      ],
+      "quote do: 1++++1"
+    )
+  end
+
+  test "identifier that ends in ! followed by the = operator without a space in between" do
+    assert_warn_eval(
+      ["nofile:1:1", "found identifier \"foo!\", ending with \"!\""],
+      "foo!= 1"
+    )
+
+    assert_warn_eval(
+      ["nofile:1:1", "found atom \":foo!\", ending with \"!\""],
+      ":foo!= :foo!"
+    )
+  end
+
+  describe "unnecessary quotes" do
+    test "does not warn of unnecessary quotes in uppercase atoms/keywords" do
+      assert capture_eval(~s/:"Foo"/) == ""
+      assert capture_eval(~s/["Foo": :bar]/) == ""
+      assert capture_eval(~s/:"Foo"/) == ""
+      assert capture_eval(~s/:"foo@bar"/) == ""
+      assert capture_eval(~s/:"héllò"/) == ""
+      assert capture_eval(~s/:"3L1X1R"/) == ""
+    end
+
+    test "warns of unnecessary quotes" do
+      assert_warn_eval(
+        ["nofile:1:1", "found quoted atom \"foo\" but the quotes are not required"],
+        ~s/:"foo"/
+      )
+
+      assert_warn_eval(
+        ["nofile:1:2", "found quoted keyword \"foo\" but the quotes are not required"],
+        ~s/["foo": :bar]/
+      )
+
+      assert_warn_eval(
+        ["nofile:1:9", "found quoted call \"length\" but the quotes are not required"],
+        ~s/[Kernel."length"([])]/
+      )
+    end
+  end
+
+  describe "deprecated single quotes in atoms" do
+    test "warns of single quotes in atoms" do
+      assert_warn_eval(
+        [
+          "nofile:1:1",
+          "single quotes around atoms are deprecated. Use double quotes instead"
+        ],
+        ~s/:'a+b'/
+      )
+    end
+
+    test "warns twice of single and unnecessary atom quotes" do
+      assert_warn_eval(
+        [
+          "nofile:1:1",
+          "single quotes around atoms are deprecated. Use double quotes instead",
+          "nofile:1:1",
+          "found quoted atom \"ab\" but the quotes are not required"
+        ],
+        ~s/:'ab'/
+      )
+    end
+
+    test "warns twice of single and unnecessary call quotes" do
+      assert_warn_eval(
+        [
+          "nofile:1:9",
+          "single quotes around calls are deprecated. Use double quotes instead",
+          "nofile:1:9",
+          "found quoted call \"length\" but the quotes are not required"
+        ],
+        ~s/[Kernel.'length'([])]/
+      )
+    end
+  end
+
+  test "warns on :: as atom" do
+    assert_warn_eval(
+      [
+        "nofile:1:1",
+        "atom ::: must be written between quotes, as in :\"::\", to avoid ambiguity"
+      ],
+      ~s/:::/
+    )
+  end
+
+  test "unused variable" do
+    # Note we use compile_string because eval_string does not emit unused vars warning
+    assert_warn_compile(
+      [
+        "nofile:2:3",
+        "variable \"module\" is unused",
+        "nofile:3:13",
+        "variable \"arg\" is unused",
+        "nofile:5:1",
+        "variable \"file\" is unused"
+      ],
+      """
       defmodule Sample do
+        module = 1
         def hello(arg), do: nil
       end
+      file = 2
+      file = 3
+      file
       """
-    end) =~ "warning: variable arg is unused"
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :unused_function do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "unused variable that could be pinned" do
+    # Note we use compile_string because eval_string does not emit unused vars warning
+    assert_warn_compile(
+      [
+        "nofile:4:12",
+        "variable \"compare_local\" is unused (there is a variable with the same name in the context, use the pin operator (^) to match on it or prefix this variable with underscore if it is not meant to be used)",
+        "nofile:8:7",
+        "variable \"compare_nested\" is unused (there is a variable with the same name in the context, use the pin operator (^) to match on it or prefix this variable with underscore if it is not meant to be used)"
+      ],
+      """
+      defmodule Sample do
+        def test do
+          compare_local = "hello"
+          match?(compare_local, "hello")
+
+          compare_nested = "hello"
+          case "hello" do
+            compare_nested -> true
+            _other -> false
+          end
+        end
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "duplicate pattern" do
+    output =
+      capture_eval("""
+      defmodule Sample do
+        var = quote(do: x)
+        def hello(unquote(var) = unquote(var)), do: unquote(var)
+      end
+      """)
+
+    assert output =~ "this pattern is matched against itself inside a match: x = x"
+  after
+    purge(Sample)
+  end
+
+  test "unused compiler variable" do
+    output =
+      capture_eval("""
+      defmodule Sample do
+        def hello(__MODULE___), do: :ok
+        def world(_R), do: :ok
+      end
+      """)
+
+    assert output =~ "unknown compiler variable \"__MODULE___\""
+    assert output =~ "nofile:2:13"
+    refute output =~ "unknown compiler variable \"_R\""
+  after
+    purge(Sample)
+  end
+
+  test "nested unused variable" do
+    messages = ["undefined variable \"x\"", "variable \"x\" is unused"]
+
+    assert_compile_error(
+      ["nofile:5:1", "nofile:2:11" | messages],
+      """
+      case false do
+        true -> x = 1
+        _ -> 1
+      end
+      x
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:1:12", "nofile:2:1" | messages],
+      """
+      false and (x = 1)
+      x
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:1:10", "nofile:2:1" | messages],
+      """
+      true or (x = 1)
+      x
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:2:3", "nofile:4:1" | messages],
+      """
+      if false do
+        x = 1
+      end
+      x
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:2:12", "nofile:5:1" | messages],
+      """
+      cond do
+        false -> x = 1
+        true -> 1
+      end
+      x
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:2:11", "nofile:6:1" | messages],
+      """
+      receive do
+        :foo -> x = 1
+      after
+        0 -> 1
+      end
+      x
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:1:11", "nofile:2:1" | messages],
+      """
+      false && (x = 1)
+      x
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:1:10", "nofile:2:1" | messages],
+      """
+      true || (x = 1)
+      x
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:2:3", "nofile:4:1" | messages],
+      """
+      with true <- true do
+        x = false
+      end
+      x
+      """
+    )
+
+    assert_compile_error(
+      ["nofile:2:3", "nofile:4:1" | messages],
+      """
+      fn ->
+        x = true
+      end
+      x
+      """
+    )
+  end
+
+  test "unused variable in redefined function in different file" do
+    output =
+      capture_err(fn ->
+        Code.eval_string("""
+        defmodule Sample do
+          defmacro __using__(_) do
+            quote location: :keep do
+              def function(arg)
+            end
+          end
+        end
+        """)
+
+        code = """
+          defmodule RedefineSample do
+            use Sample
+            def function(var123), do: nil
+          end
+        """
+
+        Code.eval_string(code, [], file: "redefine_sample.ex")
+      end)
+
+    assert output =~ "redefine_sample.ex:3: "
+    assert output =~ "variable \"var123\" is unused"
+  after
+    purge(Sample)
+    purge(RedefineSample)
+  end
+
+  test "unused variable because re-declared in a match? pattern" do
+    assert_warn_eval(
+      [
+        "nofile:1:16",
+        "variable \"x\" is unused (there is a variable with the same name in the context,",
+        "variable \"x\" is unused (if the variable is not meant to be used,"
+      ],
+      """
+      fn x -> match?(x, :value) end
+      """
+    )
+  end
+
+  test "useless literal" do
+    message = "code block contains unused literal \"oops\""
+
+    assert_warn_eval(
+      ["nofile:1\n", message],
+      """
+      "oops"
+      :ok
+      """
+    )
+
+    assert_warn_eval(
+      ["nofile:1\n", message],
+      """
+      fn ->
+        "oops"
+        :ok
+      end
+      """
+    )
+
+    assert_warn_eval(
+      ["nofile:1:5\n", message],
+      """
+      try do
+        "oops"
+        :ok
+      after
+        :ok
+      end
+      """
+    )
+  end
+
+  test "useless attr" do
+    assert_warn_eval(
+      [
+        "nofile:4:3",
+        "module attribute @foo in code block has no effect as it is never returned ",
+        "nofile:7:5",
+        "module attribute @bar in code block has no effect as it is never returned "
+      ],
+      """
+      defmodule Sample do
+        @foo 1
+        @bar 1
+        @foo
+
+        def bar do
+          @bar
+          :ok
+        end
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "useless var" do
+    message = "variable foo in code block has no effect as it is never returned "
+
+    assert_warn_eval(
+      ["nofile:2:1", message],
+      """
+      foo = 1
+      foo
+      :ok
+      """
+    )
+
+    assert_warn_eval(
+      ["nofile:3:3", message],
+      """
+      fn ->
+        foo = 1
+        foo
+        :ok
+      end
+      """
+    )
+
+    assert_warn_eval(
+      ["nofile:3:3", message],
+      """
+      try do
+        foo = 1
+        foo
+        :ok
+      after
+        :ok
+      end
+      """
+    )
+
+    assert capture_eval("""
+           node()
+           :ok
+           """) == ""
+  end
+
+  test "underscored variable on match" do
+    assert_warn_eval(
+      ["nofile:1:8", "the underscored variable \"_arg\" appears more than once in a match"],
+      """
+      {_arg, _arg} = {1, 1}
+      """
+    )
+  end
+
+  test "underscored variable on use" do
+    assert_warn_eval(
+      ["nofile:1:12", "the underscored variable \"_var\" is used after being set"],
+      """
+      fn _var -> _var + 1 end
+      """
+    )
+
+    assert capture_eval("""
+           fn var!(_var, Foo) -> var!(_var, Foo) + 1 end
+           """) == ""
+  end
+
+  test "unused function" do
+    assert_warn_eval(
+      ["nofile:2:8: ", "function hello/0 is unused\n"],
+      """
       defmodule Sample1 do
         defp hello, do: nil
       end
       """
-    end) =~ "warning: function hello/0 is unused"
+    )
 
-    assert capture_err(fn ->
-      Code.eval_string """
+    assert_warn_eval(
+      ["nofile:2:8: ", "function hello/1 is unused\n"],
+      """
       defmodule Sample2 do
         defp hello(0), do: hello(1)
         defp hello(1), do: :ok
       end
-      """
-    end) =~ "function hello/1 is unused"
+      """
+    )
+
+    assert_warn_eval(
+      ["nofile:4:8: ", "function c/2 is unused\n"],
+      ~S"""
+      defmodule Sample3 do
+        def a, do: nil
+        def b, do: d(10)
+        defp c(x, y \\ 1), do: [x, y]
+        defp d(x), do: x
+      end
+      """
+    )
+
+    assert_warn_eval(
+      ["nofile:3:8: ", "function b/2 is unused\n"],
+      ~S"""
+      defmodule Sample4 do
+        def a, do: nil
+        defp b(x \\ 1, y \\ 1)
+        defp b(x, y), do: [x, y]
+      end
+      """
+    )
+
+    assert_warn_eval(
+      ["nofile:3:8: ", "function b/0 is unused\n"],
+      ~S"""
+      defmodule Sample5 do
+        def a, do: nil
+        defp b(), do: unquote(1)
+      end
+      """
+    )
+  after
+    purge([Sample1, Sample2, Sample3, Sample4, Sample5])
+  end
+
+  test "unused cyclic functions" do
+    assert_warn_eval(
+      [
+        "nofile:2:8: ",
+        "function a/0 is unused\n",
+        "nofile:3:8: ",
+        "function b/0 is unused\n"
+      ],
+      """
+      defmodule Sample do
+        defp a, do: b()
+        defp b, do: a()
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "unused macro" do
+    assert_warn_eval(
+      ["nofile:2:13: ", "macro hello/0 is unused"],
+      """
+      defmodule Sample do
+        defmacrop hello, do: nil
+      end
+      """
+    )
+
+    assert_warn_eval(
+      ["nofile:2:13: ", "macro hello/0 is unused\n"],
+      ~S"""
+      defmodule Sample2 do
+        defmacrop hello do
+          quote do: unquote(1)
+        end
+      end
+      """
+    )
+  after
+    purge([Sample, Sample2])
+  end
+
+  test "shadowing" do
+    assert capture_eval("""
+           defmodule Sample do
+             def test(x) do
+               case x do
+                 {:file, fid} -> fid
+                 {:path, _}   -> fn(fid) -> fid end
+               end
+             end
+           end
+           """) == ""
+  after
+    purge(Sample)
+  end
+
+  test "unused default args" do
+    assert_warn_eval(
+      [
+        "nofile:3:8: ",
+        "default values for the optional arguments in the private function b/3 are never used"
+      ],
+      ~S"""
+      defmodule Sample1 do
+        def a, do: b(1, 2, 3)
+        defp b(arg1 \\ 1, arg2 \\ 2, arg3 \\ 3), do: [arg1, arg2, arg3]
+      end
+      """
+    )
+
+    assert_warn_eval(
+      [
+        "nofile:3:8: ",
+        "the default value for the last optional argument in the private function b/3 is never used"
+      ],
+      ~S"""
+      defmodule Sample2 do
+        def a, do: b(1, 2)
+        defp b(arg1 \\ 1, arg2 \\ 2, arg3 \\ 3), do: [arg1, arg2, arg3]
+      end
+      """
+    )
+
+    assert_warn_eval(
+      [
+        "nofile:3:8: ",
+        "the default values for the last 2 optional arguments in the private function b/4 are never used"
+      ],
+      ~S"""
+      defmodule Sample3 do
+        def a, do: b(1, 2)
+        defp b(arg1, arg2 \\ 2, arg3 \\ 3, arg4 \\ 4), do: [arg1, arg2, arg3, arg4]
+      end
+      """
+    )
+
+    assert capture_eval(~S"""
+           defmodule Sample4 do
+             def a, do: b(1)
+             defp b(arg1 \\ 1, arg2, arg3 \\ 3), do: [arg1, arg2, arg3]
+           end
+           """) == ""
+
+    assert_warn_eval(
+      [
+        "nofile:3:8: ",
+        "the default value for the last optional argument in the private function b/3 is never used"
+      ],
+      ~S"""
+      defmodule Sample5 do
+        def a, do: b(1, 2)
+        defp b(arg1 \\ 1, arg2 \\ 2, arg3 \\ 3)
+
+        defp b(arg1, arg2, arg3), do: [arg1, arg2, arg3]
+      end
+      """
+    )
+  after
+    purge([Sample1, Sample2, Sample3, Sample4, Sample5])
+  end
+
+  test "unused import" do
+    assert_warn_compile(
+      ["nofile:2:3", "unused import :lists"],
+      """
+      defmodule Sample do
+        import :lists
+        def a, do: nil
+      end
+      """
+    )
+
+    assert_warn_compile(
+      ["nofile:1:1", "unused import :lists"],
+      """
+      import :lists
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "unknown import" do
+    assert_warn_compile(
+      ["nofile:1:1", "cannot import Kernel.invalid/1 because it is undefined or private"],
+      """
+      import(Kernel, only: [invalid: 1])
+      """
+    )
+  end
+
+  test "conditional import" do
+    assert capture_err(fn ->
+             defmodule KernelTest.ConditionalImport do
+               if false do
+                 import Map, only: [new: 0]
+                 def fun, do: new()
+               end
+             end
+           end) == ""
+  after
+    purge(Sample)
+  end
+
+  test "unused import of one of the functions in :only" do
+    assert_warn_compile(
+      [
+        "nofile:2:3",
+        "unused import String.downcase/1",
+        "nofile:2:3",
+        "unused import String.trim/1"
+      ],
+      """
+      defmodule Sample do
+        import String, only: [upcase: 1, downcase: 1, trim: 1]
+        def a, do: upcase("hello")
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "unused import of any of the functions in :only" do
+    assert_warn_compile(
+      ["nofile:1:1", "unused import String"],
+      """
+      import String, only: [upcase: 1, downcase: 1]
+      """
+    )
+  end
+
+  test "unused import inside dynamic module" do
+    import List, only: [flatten: 1], warn: false
+
+    assert capture_err(fn ->
+             defmodule Sample do
+               import String, only: [downcase: 1]
+
+               def world do
+                 flatten([1, 2, 3])
+               end
+             end
+           end) =~ "unused import String"
+  after
+    purge(Sample)
+  end
+
+  def with(a, b, c), do: [a, b, c]
+
+  test "import matches special form" do
+    assert_warn_compile(
+      [
+        "nofile:1:1",
+        "cannot import Kernel.WarningTest.with/3 because it conflicts with Elixir special forms"
+      ],
+      """
+      import Kernel.WarningTest, only: [with: 3]
+      :ok = with true <- true, true <- true, do: :ok
+      """
+    )
+  end
+
+  test "duplicated function on import options" do
+    assert_warn_compile(
+      ["nofile:2:3", "invalid :only option for import, wrap/1 is duplicated"],
+      """
+      defmodule Kernel.WarningsTest.DuplicatedFunctionOnImportOnly do
+        import List, only: [wrap: 1, keyfind: 3, wrap: 1]
+      end
+      """
+    )
+
+    assert_warn_compile(
+      ["nofile:2:3", "invalid :except option for import, wrap/1 is duplicated"],
+      """
+      defmodule Kernel.WarningsTest.DuplicatedFunctionOnImportExcept do
+        import List, except: [wrap: 1, keyfind: 3, wrap: 1]
+      end
+      """
+    )
+  end
+
+  test "conditional alias" do
+    assert capture_err(fn ->
+             defmodule KernelTest.ConditionaAlias do
+               if false do
+                 alias Map, as: M
+                 def fun, do: M.new()
+               end
+             end
+           end) == ""
+  end
+
+  test "unused alias" do
+    assert_warn_compile(
+      ["nofile:2:3", "unused alias List"],
+      """
+      defmodule Sample do
+        alias :lists, as: List
+        def a, do: nil
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "unused alias when also import" do
+    assert_warn_compile(
+      ["nofile:2:3", "unused alias List"],
+      """
+      defmodule Sample do
+        alias :lists, as: List
+        import MapSet
+        new()
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "duplicate map keys" do
+    assert_warn_eval(
+      [
+        "key :a will be overridden in map",
+        "nofile:4:10\n",
+        "key :m will be overridden in map",
+        "nofile:5:10\n",
+        "key 1 will be overridden in map",
+        "nofile:6:10\n"
+      ],
+      """
+      defmodule DuplicateMapKeys do
+        import ExUnit.Assertions
+
+        assert %{a: :b, a: :c} == %{a: :c}
+        assert %{m: :n, m: :o, m: :p} == %{m: :p}
+        assert %{1 => 2, 1 => 3} == %{1 => 3}
+      end
+      """
+    )
+
+    assert map_size(%{System.unique_integer() => 1, System.unique_integer() => 2}) == 2
+  end
+
+  test "length(list) == 0 in guard" do
+    assert_warn_eval(
+      [
+        "nofile:5:24",
+        "do not use \"length(v) == 0\" to check if a list is empty",
+        "Prefer to pattern match on an empty list or use \"v == []\" as a guard"
+      ],
+      """
+      defmodule Sample do
+        def list_case do
+          v = []
+          case v do
+            _ when length(v) == 0 -> :ok
+            _ -> :fail
+          end
+        end
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "length(list) > 0 in guard" do
+    assert_warn_eval(
+      [
+        "nofile:5:24",
+        "do not use \"length(v) > 0\" to check if a list is not empty",
+        "Prefer to pattern match on a non-empty list, such as [_ | _], or use \"v != []\" as a guard"
+      ],
+      """
+      defmodule Sample do
+        def list_case do
+          v = []
+          case v do
+            _ when length(v) > 0 -> :ok
+            _ -> :fail
+          end
+        end
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "late function heads" do
+    assert_warn_eval(
+      [
+        "nofile:4:7\n",
+        "function head for def add/2 must come at the top of its direct implementation"
+      ],
+      """
+      defmodule Sample do
+        def add(a, b), do: a + b
+        @doc "hello"
+        def add(a, b)
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "late function heads do not warn of meta programming" do
+    assert capture_eval("""
+           defmodule Sample1 do
+             defmacro __using__(_) do
+               quote do
+                 def add(a, b), do: a + b
+               end
+             end
+           end
+
+           defmodule Sample2 do
+             use Sample1
+             @doc "hello"
+             def add(a, b)
+           end
+           """) == ""
+
+    assert capture_eval("""
+           defmodule Sample3 do
+            for fun <- [:foo, :bar] do
+              def unquote(fun)(), do: unquote(fun)
+            end
+
+             def foo()
+             def bar()
+           end
+           """) == ""
+  after
+    purge([Sample1, Sample2, Sample3])
+  end
+
+  test "used import via alias" do
+    assert capture_eval("""
+           defmodule Sample1 do
+             import List, only: [flatten: 1]
+
+             defmacro generate do
+               List.duplicate(quote(do: flatten([1, 2, 3])), 100)
+             end
+           end
+
+           defmodule Sample2 do
+             import Sample1
+             generate()
+           end
+           """) == ""
+  after
+    purge([Sample1, Sample2])
+  end
+
+  test "clause not match" do
+    assert_warn_eval(
+      [
+        "nofile:3:7\n",
+        ~r"this clause( for hello/0)? cannot match because a previous clause at line 2 always matches"
+      ],
+      """
+      defmodule Sample do
+        def hello, do: nil
+        def hello, do: nil
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "generated clause not match" do
+    assert_warn_eval(
+      [
+        "nofile:10\n",
+        ~r"this clause( for hello/0)? cannot match because a previous clause at line 10 always matches"
+      ],
+      """
+      defmodule Sample do
+        defmacro __using__(_) do
+          quote do
+            def hello, do: nil
+            def hello, do: nil
+          end
+        end
+      end
+      defmodule UseSample do
+        use Sample
+      end
+      """
+    )
+  after
+    purge(Sample)
+    purge(UseSample)
+  end
+
+  test "deprecated closing sigil delimiter" do
+    assert_warn_eval(["nofile:1:7", "deprecated"], "~S(foo\\))")
+  end
+
+  test "deprecated not left in right" do
+    assert_warn_eval(["nofile:1:7", "deprecated"], "not 1 in [1, 2, 3]")
+  end
+
+  test "clause with defaults should be first" do
+    message = "def hello/1 has multiple clauses and also declares default values"
+
+    assert_warn_eval(
+      ["nofile:3:7\n", message, "the previous clause is defined on line 2"],
+      ~S"""
+      defmodule Sample1 do
+        def hello(arg), do: arg
+        def hello(arg \\ 0), do: arg
+      end
+      """
+    )
+
+    assert_warn_eval(
+      ["nofile:3:7\n", message, "the previous clause is defined on line 2"],
+      ~S"""
+      defmodule Sample2 do
+        def hello(_arg)
+        def hello(arg \\ 0), do: arg
+      end
+      """
+    )
+  after
+    purge([Sample1, Sample2])
+  end
+
+  test "clauses with default should use header" do
+    assert_warn_eval(
+      [
+        "nofile:3:7\n",
+        "def hello/1 has multiple clauses and also declares default values",
+        "the previous clause is defined on line 2"
+      ],
+      ~S"""
+      defmodule Sample do
+        def hello(arg \\ 0), do: arg
+        def hello(arg), do: arg
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "unused with local with overridable" do
+    assert_warn_eval(
+      ["nofile:3:8: ", "function world/0 is unused"],
+      """
+      defmodule Sample do
+        def hello, do: world()
+        defp world, do: :ok
+        defoverridable [hello: 0]
+        def hello, do: :ok
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "undefined module attribute" do
+    assert_warn_eval(
+      [
+        "nofile:2: ",
+        "undefined module attribute @foo, please remove access to @foo or explicitly set it before access"
+      ],
+      """
+      defmodule Sample do
+        @foo
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "parens with module attribute" do
+    assert_warn_eval(
+      [
+        "nofile:3: ",
+        "the @foo() notation (with parentheses) is deprecated, please use @foo (without parentheses) instead"
+      ],
+      """
+      defmodule Sample do
+        @foo 13
+        @foo()
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "undefined module attribute in function" do
+    assert_warn_eval(
+      [
+        "nofile:3: ",
+        "undefined module attribute @foo, please remove access to @foo or explicitly set it before access"
+      ],
+      """
+      defmodule Sample do
+        def hello do
+          @foo
+        end
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "undefined module attribute with file" do
+    assert_warn_eval(
+      [
+        "nofile:2: ",
+        "undefined module attribute @foo, please remove access to @foo or explicitly set it before access"
+      ],
+      """
+      defmodule Sample do
+        @foo
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "parse transform" do
+    assert_warn_eval(
+      ["nofile:1: ", "@compile {:parse_transform, :ms_transform} is deprecated"],
+      """
+      defmodule Sample do
+        @compile {:parse_transform, :ms_transform}
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "@compile inline no warning for unreachable function" do
+    refute capture_eval("""
+           defmodule Sample do
+             @compile {:inline, foo: 1}
+
+             defp foo(_), do: :ok
+           end
+           """) =~ "inlined function foo/1 undefined"
+  after
+    purge(Sample)
+  end
+
+  test "no effect operator" do
+    assert_warn_eval(
+      ["nofile:3:7\n", "use of operator != has no effect"],
+      """
+      defmodule Sample do
+        def a(x) do
+          x != :foo
+          :ok
+        end
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "undefined function for behaviour" do
+    assert_warn_eval(
+      [
+        "nofile:5: ",
+        "function foo/0 required by behaviour Sample1 is not implemented (in module Sample2)"
+      ],
+      """
+      defmodule Sample1 do
+        @callback foo :: term
+      end
+
+      defmodule Sample2 do
+        @behaviour Sample1
+      end
+      """
+    )
+  after
+    purge([Sample1, Sample2])
+  end
+
+  test "undefined macro for behaviour" do
+    assert_warn_eval(
+      [
+        "nofile:5: ",
+        "macro foo/0 required by behaviour Sample1 is not implemented (in module Sample2)"
+      ],
+      """
+      defmodule Sample1 do
+        @macrocallback foo :: Macro.t
+      end
+
+      defmodule Sample2 do
+        @behaviour Sample1
+      end
+      """
+    )
+  after
+    purge([Sample1, Sample2])
+  end
+
+  test "wrong kind for behaviour" do
+    assert_warn_eval(
+      [
+        "nofile:5: ",
+        "function foo/0 required by behaviour Sample1 was implemented as \"defmacro\" but should have been \"def\""
+      ],
+      """
+      defmodule Sample1 do
+        @callback foo :: term
+      end
+
+      defmodule Sample2 do
+        @behaviour Sample1
+        defmacro foo, do: :ok
+      end
+      """
+    )
+  after
+    purge([Sample1, Sample2])
+  end
+
+  test "conflicting behaviour" do
+    assert_warn_eval(
+      [
+        "nofile:9: ",
+        "conflicting behaviours found. Callback function foo/0 is defined by both Sample1 and Sample2 (in module Sample3)"
+      ],
+      """
+      defmodule Sample1 do
+        @callback foo :: term
+      end
+
+      defmodule Sample2 do
+        @callback foo :: term
+      end
+
+      defmodule Sample3 do
+        @behaviour Sample1
+        @behaviour Sample2
+      end
+      """
+    )
+  after
+    purge([Sample1, Sample2, Sample3])
+  end
+
+  test "conflicting behaviour (but one optional callback)" do
+    message =
+      capture_compile("""
+      defmodule Sample1 do
+        @callback foo :: term
+      end
+
+      defmodule Sample2 do
+        @callback foo :: term
+        @callback bar :: term
+        @optional_callbacks foo: 0
+      end
+
+      defmodule Sample3 do
+        @behaviour Sample1
+        @behaviour Sample2
+
+        @impl Sample1
+        def foo, do: 1
+        @impl Sample2
+        def bar, do: 2
+      end
+      """)
+
+    assert message =~
+             "conflicting behaviours found. Callback function foo/0 is defined by both Sample1 and Sample2 (in module Sample3)"
+
+    refute message =~ "module attribute @impl was not set"
+    refute message =~ "this behaviour does not specify such callback"
+  after
+    purge([Sample1, Sample2, Sample3])
+  end
+
+  test "duplicate behaviour" do
+    assert_warn_eval(
+      [
+        "nofile:5: ",
+        "the behaviour Sample1 has been declared twice (conflict in function foo/0 in module Sample2)"
+      ],
+      """
+      defmodule Sample1 do
+        @callback foo :: term
+      end
+
+      defmodule Sample2 do
+        @behaviour Sample1
+        @behaviour Sample1
+      end
+      """
+    )
+  after
+    purge([Sample1, Sample2])
+  end
+
+  test "unknown remote call" do
+    assert capture_compile("""
+           defmodule Sample do
+             def perform(), do: Unknown.call()
+           end
+           """) =~
+             "Unknown.call/0 is undefined (module Unknown is not available or is yet to be defined)"
+  after
+    purge(Sample)
+  end
+
+  test "undefined behaviour" do
+    assert_warn_eval(
+      ["nofile:1: ", "@behaviour UndefinedBehaviour does not exist (in module Sample)"],
+      """
+      defmodule Sample do
+        @behaviour UndefinedBehaviour
+      end
+      """
+    )
+  after
+    purge(Sample)
+  end
+
+  test "empty behaviours" do
+    assert_warn_eval(
+      ["nofile:3: ", "module EmptyBehaviour is not a behaviour (in module Sample)"],
+      """
+      defmodule EmptyBehaviour do
+      end
+      defmodule Sample do
+        @behaviour EmptyBehaviour
+      end
+      """
+    )
+  after
+    purge(Sample)
+    purge(EmptyBehaviour)
+  end
+
+  test "undefined function for protocol" do
+    assert_warn_eval(
+      [
+        "nofile:5: ",
+        "function foo/1 required by protocol Sample1 is not implemented (in module Sample1.Atom)"
+      ],
+      """
+      defprotocol Sample1 do
+        def foo(subject)
+      end
 
-    assert capture_err(fn ->
-      Code.eval_string ~S"""
-      defmodule Sample3 do
-        def a, do: nil
-        def b, do: d(10)
-        defp c(x, y \\ 1), do: [x, y]
-        defp d(x), do: x
+      defimpl Sample1, for: Atom do
       end
       """
-    end) =~ "warning: function c/2 is unused"
+    )
   after
-    purge [Sample1, Sample2, Sample3]
+    purge([Sample1, Sample1.Atom])
   end
 
-  test :unused_cyclic_functions do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "ungrouped def name" do
+    assert_warn_eval(
+      [
+        "nofile:4:7\n",
+        "clauses with the same name should be grouped together, \"def foo/2\" was previously defined (nofile:2)"
+      ],
+      """
       defmodule Sample do
-        defp a, do: b
-        defp b, do: a
+        def foo(x, 1), do: x + 1
+        def foo(), do: nil
+        def foo(x, 2), do: x * 2
       end
       """
-    end) =~ "warning: function a/0 is unused"
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :unused_macro do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "ungrouped def name and arity" do
+    assert_warn_eval(
+      [
+        "nofile:4:7\n",
+        "clauses with the same name and arity (number of arguments) should be grouped together, \"def foo/2\" was previously defined (nofile:2)"
+      ],
+      """
       defmodule Sample do
-        defmacrop hello, do: nil
+        def foo(x, 1), do: x + 1
+        def bar(), do: nil
+        def foo(x, 2), do: x * 2
       end
       """
-    end) =~ "warning: macro hello/0 is unused"
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :shadowing do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "ungrouped defs do not warn of meta programming" do
+    assert capture_eval("""
+           defmodule Sample do
+             for atom <- [:foo, :bar] do
+               def from_string(unquote(to_string(atom))), do: unquote(atom)
+               def to_string(unquote(atom)), do: unquote(to_string(atom))
+             end
+           end
+           """) == ""
+  after
+    purge(Sample)
+  end
+
+  test "warning with overridden file" do
+    assert_warn_eval(
+      ["sample:3:11:", "variable \"x\" is unused"],
+      """
       defmodule Sample do
-        def test(x) do
-          case x do
-            {:file, fid} -> fid
-            {:path, _}   -> fn(fid) -> fid end
-          end
-        end
+        @file "sample"
+        def foo(x), do: :ok
       end
       """
-    end) == ""
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :unused_default_args do
-    assert capture_err(fn ->
-      Code.eval_string ~S"""
-      defmodule Sample1 do
-        def a, do: b(1, 2, 3)
-        defp b(arg1 \\ 1, arg2 \\ 2, arg3 \\ 3), do: [arg1, arg2, arg3]
-      end
-      """
-    end) =~ "warning: default arguments in b/3 are never used"
+  test "warning on unnecessary code point escape" do
+    assert capture_eval("?\\n + ?\\\\") == ""
 
-    assert capture_err(fn ->
-      Code.eval_string ~S"""
-      defmodule Sample2 do
-        def a, do: b(1, 2)
-        defp b(arg1 \\ 1, arg2 \\ 2, arg3 \\ 3), do: [arg1, arg2, arg3]
-      end
-      """
-    end) =~ "warning: the first 2 default arguments in b/3 are never used"
+    assert_warn_eval(
+      ["nofile:1:1", "unknown escape sequence ?\\w, use ?w instead"],
+      "?\\w"
+    )
+  end
 
-    assert capture_err(fn ->
-      Code.eval_string ~S"""
-      defmodule Sample3 do
-        def a, do: b(1)
-        defp b(arg1 \\ 1, arg2 \\ 2, arg3 \\ 3), do: [arg1, arg2, arg3]
-      end
-      """
-    end) =~ "warning: the first default argument in b/3 is never used"
+  test "warning on code point escape" do
+    assert_warn_eval(
+      ["nofile:1:1", "found ? followed by code point 0x20 (space), please use ?\\s instead"],
+      "? "
+    )
 
-    assert capture_err(fn ->
-      Code.eval_string ~S"""
-      defmodule Sample4 do
-        def a, do: b(1)
-        defp b(arg1 \\ 1, arg2, arg3 \\ 3), do: [arg1, arg2, arg3]
-      end
-      """
-    end) == ""
-  after
-    purge [Sample1, Sample2, Sample3, Sample4]
+    assert_warn_eval(
+      ["nofile:1:1", "found ?\\ followed by code point 0x20 (space), please use ?\\s instead"],
+      "?\\ "
+    )
   end
 
-  test :unused_import do
-    assert capture_err(fn ->
-      Code.compile_string """
+  test "duplicated docs in the same clause" do
+    output =
+      capture_eval("""
       defmodule Sample do
-        import :lists, only: [flatten: 1]
-        def a, do: nil
+        @doc "Something"
+        @doc "Another"
+        def foo, do: :ok
       end
-      """
-    end) =~ "warning: unused import :lists"
+      """)
 
-    assert capture_err(fn ->
-      Code.compile_string """
-      import :lists, only: [flatten: 1]
-      """
-    end) =~ "warning: unused import :lists"
+    assert output =~ "redefining @doc attribute previously set at line 2"
+    assert output =~ "nofile:3: Sample (module)"
   after
-    purge [Sample]
+    purge(Sample)
   end
 
-  test :unused_alias do
-    assert capture_err(fn ->
-      Code.compile_string """
-      defmodule Sample do
-        alias :lists, as: List
-        def a, do: nil
+  test "duplicate docs across clauses" do
+    assert capture_eval("""
+           defmodule Sample1 do
+             defmacro __using__(_) do
+               quote do
+                 @doc "hello"
+                 def add(a, 1), do: a + 1
+               end
+             end
+           end
+
+           defmodule Sample2 do
+             use Sample1
+             @doc "world"
+             def add(a, 2), do: a + 2
+           end
+           """) == ""
+
+    assert_warn_eval(
+      ["nofile:4: ", "redefining @doc attribute previously set at line"],
+      """
+      defmodule Sample3 do
+        @doc "hello"
+        def add(a, 1), do: a + 1
+        @doc "world"
+        def add(a, 2), do: a + 2
       end
       """
-    end) =~ "warning: unused alias List"
+    )
   after
-    purge [Sample]
+    purge([Sample1, Sample2, Sample3])
   end
 
-  test :unused_inside_dynamic_module do
-    import List, only: [flatten: 1], warn: false
+  test "reserved doc metadata keys" do
+    {output, diagnostics} =
+      Code.with_diagnostics([log: true], fn ->
+        capture_eval("""
+        defmodule Sample do
+          @typedoc opaque: false
+          @type t :: binary
 
-    assert capture_err(fn ->
-      defmodule Sample do
-        import String, only: [downcase: 1]
+          @doc defaults: 3, since: "1.2.3"
+          def foo(a), do: a
+        end
+        """)
+      end)
+
+    assert output =~ "ignoring reserved documentation metadata key: :opaque"
+    assert output =~ "nofile:2: "
+    assert output =~ "ignoring reserved documentation metadata key: :defaults"
+    assert output =~ "nofile:5: "
+    refute output =~ ":since"
+
+    assert [
+             %{
+               message: "ignoring reserved documentation metadata key: :opaque",
+               position: 2,
+               file: "nofile",
+               severity: :warning
+             },
+             %{
+               message: "ignoring reserved documentation metadata key: :defaults",
+               position: 5,
+               file: "nofile",
+               severity: :warning
+             }
+           ] = diagnostics
+  after
+    purge(Sample)
+  end
+
+  describe "typespecs" do
+    test "unused types" do
+      output =
+        capture_eval("""
+        defmodule Sample do
+          @type pub :: any
+          @opaque op :: any
+          @typep priv :: any
+          @typep priv_args(var1, var2) :: {var1, var2}
+          @typep priv2 :: any
+          @typep priv3 :: priv2 | atom
+
+          @spec my_fun(priv3) :: pub
+          def my_fun(var), do: var
+        end
+        """)
+
+      assert output =~ "nofile:4: "
+      assert output =~ "type priv/0 is unused"
+      assert output =~ "nofile:5: "
+      assert output =~ "type priv_args/2 is unused"
+      refute output =~ "type pub/0 is unused"
+      refute output =~ "type op/0 is unused"
+      refute output =~ "type priv2/0 is unused"
+      refute output =~ "type priv3/0 is unused"
+    after
+      purge(Sample)
+    end
+
+    test "underspecified opaque types" do
+      output =
+        capture_eval("""
+        defmodule Sample do
+          @opaque op1 :: term
+          @opaque op2 :: any
+          @opaque op3 :: atom
+        end
+        """)
+
+      assert output =~ "nofile:2: "
+      assert output =~ "@opaque type op1/0 is underspecified and therefore meaningless"
+      assert output =~ "nofile:3: "
+      assert output =~ "@opaque type op2/0 is underspecified and therefore meaningless"
+      refute output =~ "nofile:4: "
+      refute output =~ "op3"
+    after
+      purge(Sample)
+    end
+
+    test "underscored types variables" do
+      output =
+        capture_eval("""
+        defmodule Sample do
+          @type in_typespec_vars(_var1, _var1) :: atom
+          @type in_typespec(_var2) :: {atom, _var2}
+
+          @spec in_spec(_var3) :: {atom, _var3} when _var3: var
+          def in_spec(a), do: {:ok, a}
+        end
+        """)
+
+      assert output =~ "nofile:2: "
+      assert output =~ ~r/the underscored type variable "_var1" is used more than once/
+      assert output =~ "nofile:3: "
+      assert output =~ ~r/the underscored type variable "_var2" is used more than once/
+      assert output =~ "nofile:5: "
+      assert output =~ ~r/the underscored type variable "_var3" is used more than once/
+    after
+      purge(Sample)
+    end
+
+    test "typedoc on typep" do
+      assert_warn_eval(
+        [
+          "nofile:2: ",
+          "type priv/0 is private, @typedoc's are always discarded for private types"
+        ],
+        """
+        defmodule Sample do
+          @typedoc "Something"
+          @typep priv :: any
+          @spec foo() :: priv
+          def foo(), do: nil
+        end
+        """
+      )
+    after
+      purge(Sample)
+    end
+
+    test "discouraged types" do
+      string_discouraged =
+        "string() type use is discouraged. " <>
+          "For character lists, use charlist() type, for strings, String.t()\n"
+
+      nonempty_string_discouraged =
+        "nonempty_string() type use is discouraged. " <>
+          "For non-empty character lists, use nonempty_charlist() type, for strings, String.t()\n"
+
+      assert_warn_eval(
+        [
+          "nofile:2: ",
+          string_discouraged,
+          "nofile:3: ",
+          nonempty_string_discouraged
+        ],
+        """
+        defmodule Sample do
+          @type foo :: string()
+          @type bar :: nonempty_string()
+        end
+        """
+      )
+    after
+      purge(Sample)
+    end
+
+    test "nested type annotations" do
+      message = "invalid type annotation. Type annotations cannot be nested"
+
+      assert_warn_eval(
+        ["nofile:2: ", message],
+        """
+        defmodule Sample1 do
+          @type my_type :: ann_type :: nested_ann_type :: atom
+        end
+        """
+      )
+
+      purge(Sample1)
+
+      assert_warn_eval(
+        ["nofile:2: ", message],
+        """
+        defmodule Sample2 do
+          @type my_type :: ann_type :: nested_ann_type :: atom | port
+        end
+        """
+      )
+
+      purge(Sample2)
 
-        def world do
-          flatten([1,2,3])
+      assert_warn_eval(
+        ["nofile:2: ", message],
+        """
+        defmodule Sample3 do
+          @spec foo :: {pid, ann_type :: nested_ann_type :: atom}
+          def foo, do: nil
         end
+        """
+      )
+    after
+      purge([Sample1, Sample2, Sample3])
+    end
+
+    test "invalid fun" do
+      assert_warn_eval(
+        [
+          "nofile:2: ",
+          "fun/1 is not valid in typespecs. Either specify fun() or use (... -> return) instead"
+        ],
+        """
+        defmodule InvalidFunType do
+          @type my_type :: fun(integer())
+        end
+        """
+      )
+    end
+
+    test "invalid type annotations" do
+      assert_warn_eval(
+        [
+          "nofile:2: ",
+          "invalid type annotation. The left side of :: must be a variable, got: pid()"
+        ],
+        """
+        defmodule Sample1 do
+          @type my_type :: (pid() :: atom)
+        end
+        """
+      )
+
+      message =
+        "invalid type annotation. The left side of :: must be a variable, got: pid | ann_type. " <>
+          "Note \"left | right :: ann\" is the same as \"(left | right) :: ann\""
+
+      assert_warn_eval(
+        ["nofile:2: ", message],
+        """
+        defmodule Sample2 do
+          @type my_type :: pid | ann_type :: atom
+        end
+        """
+      )
+    after
+      purge([Sample1, Sample2])
+    end
+  end
+
+  test "attribute with no use" do
+    assert_warn_eval(
+      ["nofile:2: ", "module attribute @at was set but never used"],
+      """
+      defmodule Sample do
+        @at "Something"
       end
-    end) =~ "warning: unused import String"
+      """
+    )
   after
-    purge [Sample]
+    purge(Sample)
   end
 
-  test :unused_guard do
-    assert capture_err(fn ->
-      Code.eval_string """
-      defmodule Sample1 do
-        def is_atom_case do
-          v = "bc"
-          case v do
-            _ when is_atom(v) -> :ok
-            _ -> :fail
-          end
-        end
+  test "registered attribute with no use" do
+    assert_warn_eval(
+      ["nofile:3: ", "module attribute @at was set but never used"],
+      """
+      defmodule Sample do
+        Module.register_attribute(__MODULE__, :at, [])
+        @at "Something"
       end
       """
-    end) =~ "nofile:5: warning: the guard for this clause evaluates to 'false'"
+    )
+  after
+    purge(Sample)
+  end
 
-    assert capture_err(fn ->
-      Code.eval_string """
-      defmodule Sample2 do
-        def is_binary_cond do
-          v = "bc"
-          cond do
-            is_binary(v) -> :bin
-            true -> :ok
-          end
-        end
+  test "typedoc with no type" do
+    assert_warn_eval(
+      ["nofile:2: ", "module attribute @typedoc was set but no type follows it"],
+      """
+      defmodule Sample do
+        @typedoc "Something"
       end
       """
-    end) =~ "nofile:6: warning: this clause cannot match because a previous clause at line 5 always matches"
+    )
   after
-    purge [Sample1, Sample2]
+    purge(Sample)
   end
 
-  test :empty_clause do
-    assert capture_err(fn ->
-      Code.eval_string """
-      defmodule Sample1 do
-        def hello
+  test "doc with no function" do
+    assert_warn_eval(
+      ["nofile:2: ", "module attribute @doc was set but no definition follows it"],
+      """
+      defmodule Sample do
+        @doc "Something"
       end
       """
-    end) =~ "warning: empty clause provided for nonexistent function or macro hello/0"
+    )
   after
-    purge [Sample1]
+    purge(Sample)
   end
 
-  test :used_import_via_alias do
-    assert capture_err(fn ->
-      Code.eval_string """
-      defmodule Sample1 do
-        import List, only: [flatten: 1]
+  test "pipe without explicit parentheses" do
+    assert_warn_eval(
+      ["nofile:2:1", "parentheses are required when piping into a function call"],
+      """
+      [5, 6, 7, 3]
+      |> Enum.map_join "", &(Integer.to_string(&1))
+      |> String.to_integer
+      """
+    )
+  end
 
-        defmacro generate do
-          List.duplicate(quote(do: flatten([1,2,3])), 100)
-        end
+  test "keywords without explicit parentheses" do
+    assert_warn_eval(
+      ["nofile:2\n", "missing parentheses for expression following \"label:\" keyword. "],
+      """
+      quote do
+        IO.inspect arg, label: if true, do: "foo", else: "baz"
       end
+      """
+    )
+  end
 
-      defmodule Sample2 do
-        import Sample1
-        generate
+  test "do+end with operator without explicit parentheses" do
+    assert_warn_eval(
+      ["nofile:3\n", "missing parentheses on expression following operator \"||\""],
+      """
+      quote do
+        case do
+        end || raise 1, 2
       end
       """
-    end) == ""
-  after
-    purge [Sample1, Sample2]
+    )
   end
 
-  test :clause_not_match do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "variable is being expanded to function call (on_undefined_variable: warn)" do
+    capture_io(:stderr, fn ->
+      Code.put_compiler_option(:on_undefined_variable, :warn)
+    end)
+
+    output =
+      capture_eval("""
+      self
       defmodule Sample do
-        def hello, do: nil
-        def hello, do: nil
+        def my_node(), do: node
       end
-      """
-    end) =~ "warning: this clause cannot match because a previous clause at line 2 always matches"
+      """)
+
+    assert output =~ "variable \"self\" does not exist and is being expanded to \"self()\""
+    assert output =~ "nofile:1:1"
+    assert output =~ "variable \"node\" does not exist and is being expanded to \"node()\""
+    assert output =~ "nofile:3:22"
   after
-    purge Sample
+    Code.put_compiler_option(:on_undefined_variable, :raise)
+    purge(Sample)
+  end
+
+  defmodule User do
+    defstruct [:name]
   end
 
-  test :clause_with_defaults_should_be_first do
+  test ":__struct__ is ignored when using structs" do
     assert capture_err(fn ->
-      Code.eval_string ~S"""
-      defmodule Sample do
-        def hello(arg), do: nil
-        def hello(arg \\ 0), do: nil
+             code = """
+             assert %Kernel.WarningTest.User{__struct__: Ignored, name: "joe"} ==
+                    %Kernel.WarningTest.User{name: "joe"}
+             """
+
+             Code.eval_string(code, [], __ENV__)
+           end) =~ "key :__struct__ is ignored when using structs"
+
+    assert capture_err(fn ->
+             code = """
+             user = %Kernel.WarningTest.User{name: "meg"}
+             assert %Kernel.WarningTest.User{user | __struct__: Ignored, name: "joe"} ==
+                    %Kernel.WarningTest.User{__struct__: Kernel.WarningTest.User, name: "joe"}
+             """
+
+             Code.eval_string(code, [], __ENV__)
+           end) =~ "key :__struct__ is ignored when using structs"
+  end
+
+  test "catch comes before rescue in try block" do
+    assert_warn_eval(
+      ["nofile:1:1\n", ~s("catch" should always come after "rescue" in try)],
+      """
+      try do
+        :trying
+      catch
+        _ -> :caught
+      rescue
+        _ -> :error
       end
       """
-    end) =~ "warning: clause with defaults should be the first clause in def hello/1"
-  after
-    purge Sample
+    )
   end
 
-  test :unused_with_local_with_overridable do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "catch comes before rescue in def" do
+    assert_warn_eval(
+      ["nofile:2:7\n", ~s("catch" should always come after "rescue" in def)],
+      """
       defmodule Sample do
-        def hello, do: world
-        defp world, do: :ok
-        defoverridable [hello: 0]
-        def hello, do: :ok
+        def foo do
+          :trying
+        catch
+          _, _ -> :caught
+        rescue
+          _ -> :error
+        end
       end
       """
-    end) =~ "warning: function world/0 is unused"
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :used_with_local_with_reattached_overridable do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "unused variable in defguard" do
+    assert_warn_eval(
+      ["nofile:2:21", "variable \"baz\" is unused"],
+      """
       defmodule Sample do
-        def hello, do: world
-        defp world, do: :ok
-        defoverridable [hello: 0, world: 0]
+        defguard foo(bar, baz) when bar
       end
       """
-    end) == ""
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :undefined_module_attribute do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "unused import in defguard" do
+    assert_warn_eval(
+      ["nofile:2:3", "unused import Record\n"],
+      """
       defmodule Sample do
-        @foo
+        import Record
+        defguard is_record(baz) when baz
       end
       """
-    end) =~ "warning: undefined module attribute @foo, please remove access to @foo or explicitly set it to nil before access"
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :undefined_module_attribute_in_function do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "unused private guard" do
+    assert_warn_eval(
+      ["nofile:2:13: ", "macro foo/2 is unused\n"],
+      """
       defmodule Sample do
-        def hello do
-          @foo
-        end
+        defguardp foo(bar, baz) when bar + baz
       end
       """
-    end) =~ "warning: undefined module attribute @foo, please remove access to @foo or explicitly set it to nil before access"
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :undefined_module_attribute_with_file do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "defguard overriding defmacro" do
+    assert_warn_eval(
+      [
+        "nofile:3:12\n",
+        ~r"this clause( for foo/1)? cannot match because a previous clause at line 2 always matches"
+      ],
+      """
       defmodule Sample do
-        @foo
+        defmacro foo(bar), do: bar == :bar
+        defguard foo(baz) when baz == :baz
       end
       """
-    end) =~ "warning: undefined module attribute @foo, please remove access to @foo or explicitly set it to nil before access"
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :in_guard_empty_list do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "defmacro overriding defguard" do
+    assert_warn_eval(
+      [
+        "nofile:3:12\n",
+        ~r"this clause( for foo/1)? cannot match because a previous clause at line 2 always matches"
+      ],
+      """
       defmodule Sample do
-        def a(x) when x in [], do: x
+        defguard foo(baz) when baz == :baz
+        defmacro foo(bar), do: bar == :bar
       end
       """
-    end) =~ "warning: the guard for this clause evaluates to 'false'"
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :no_effect_operator do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "deprecated GenServer super on callbacks" do
+    assert_warn_eval(
+      ["nofile:1: ", "calling super for GenServer callback handle_call/3 is deprecated"],
+      """
       defmodule Sample do
-        def a(x) do
-          x != :foo
-          :ok
+        use GenServer
+
+        def handle_call(a, b, c) do
+          super(a, b, c)
         end
       end
       """
-    end) =~ "warning: use of operator != has no effect"
+    )
   after
-    purge Sample
+    purge(Sample)
   end
 
-  test :undefined_function_for_behaviour do
-    assert capture_err(fn ->
-      Code.eval_string """
-      defmodule Sample1 do
-        use Behaviour
-        defcallback foo
-      end
+  test "super is allowed on GenServer.child_spec/1" do
+    refute capture_eval("""
+           defmodule Sample do
+             use GenServer
 
-      defmodule Sample2 do
-        @behaviour Sample1
-      end
-      """
-    end) =~ "warning: undefined behaviour function foo/0 (for behaviour Sample1)"
+             def child_spec(opts) do
+               super(opts)
+             end
+           end
+           """) =~ "calling super for GenServer callback child_spec/1 is deprecated"
   after
-    purge [Sample1, Sample2, Sample3]
+    purge(Sample)
   end
 
-  test :undefined_macro_for_behaviour do
-    assert capture_err(fn ->
-      Code.eval_string """
-      defmodule Sample1 do
-        use Behaviour
-        defmacrocallback foo
-      end
-
-      defmodule Sample2 do
-        @behaviour Sample1
+  test "def warns if only clause is else" do
+    assert_warn_compile(
+      ["nofile:2:7\n", "\"else\" shouldn't be used as the only clause in \"def\""],
+      """
+      defmodule Sample do
+        def foo do
+          :bar
+        else
+          _other -> :ok
+        end
       end
       """
-    end) =~ "warning: undefined behaviour macro foo/0 (for behaviour Sample1)"
+    )
   after
-    purge [Sample1, Sample2, Sample3]
+    purge(Sample)
   end
 
-  test :undefined_behavior do
-    assert capture_err(fn ->
-      Code.eval_string """
-      defmodule Sample do
-        @behavior Hello
+  test "try warns if only clause is else" do
+    assert_warn_compile(
+      ["nofile:1:1\n", "\"else\" shouldn't be used as the only clause in \"try\""],
+      """
+      try do
+        :ok
+      else
+        other -> other
       end
       """
-    end) =~ "warning: @behavior attribute is not supported, please use @behaviour instead"
-  after
-    purge [Sample]
+    )
   end
 
-  test :undefined_macro_for_protocol do
-    assert capture_err(fn ->
-      Code.eval_string """
-      defprotocol Sample1 do
-        def foo(subject)
-      end
+  test "sigil w/W warns on trailing comma at macro expansion time" do
+    for sigil <- ~w(w W),
+        modifier <- ~w(a s c) do
+      output =
+        capture_err(fn ->
+          {:ok, ast} =
+            "~#{sigil}(foo, bar baz)#{modifier}"
+            |> Code.string_to_quoted()
 
-      defimpl Sample1, for: Atom do
-      end
-      """
-    end) =~ "warning: undefined protocol function foo/1 (for protocol Sample1)"
-  after
-    purge [Sample1, Sample1.Atom]
+          Macro.expand(ast, __ENV__)
+        end)
+
+      assert output =~ "the sigils ~w/~W do not allow trailing commas"
+    end
   end
 
-  test :overidden_def do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "warnings on trailing comma on call" do
+    assert_warn_eval(
+      ["nofile:1:25\n", "trailing commas are not allowed inside function/macro call arguments"],
+      "Keyword.merge([], foo: 1,)"
+    )
+  end
+
+  test "defstruct warns with duplicate keys" do
+    assert_warn_eval(
+      ["nofile:2: Sample", "duplicate key :foo found in struct"],
+      """
       defmodule Sample do
-        def foo(x, 1), do: x + 1
-        def bar(), do: nil
-        def foo(x, 2), do: x * 2
+        defstruct [:foo, :bar, foo: 1]
       end
       """
-    end) =~ "nofile:4: warning: clauses for the same def should be grouped together, def foo/2 was previously defined (nofile:2)"
+    )
   after
-    purge [Sample]
+    purge(Sample)
   end
 
-  test :warning_with_overridden_file do
-    assert capture_err(fn ->
-      Code.eval_string """
-      defmodule Sample do
-        @file "sample"
-        def foo(x), do: :ok
-      end
+  test "deprecate nullary remote zero-arity capture with parens" do
+    assert capture_eval("""
+           import System, only: [pid: 0]
+           &pid/0
+           """) == ""
+
+    assert_warn_eval(
+      [
+        "nofile:1:1\n",
+        "extra parentheses on a remote function capture &System.pid()/0 have been deprecated. Please remove the parentheses: &System.pid/0"
+      ],
       """
-    end) =~ "sample:3: warning: variable x is unused"
-  after
-    purge [Sample]
+      &System.pid()/0
+      """
+    )
   end
 
-  test :typedoc_on_typep do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "deprecate &module.fun/arity captures with complex expressions as modules" do
+    assert_warn_eval(
+      [
+        "nofile:2:",
+        """
+        expected the module in &module.fun/arity to expand to a variable or an atom, got: hd(modules)
+        You can either compute the module name outside of & or convert it to a regular anonymous function.
+        """
+      ],
+      """
       defmodule Sample do
-        @typedoc "Something"
-        @typep priv :: any
-        @spec foo() :: priv
-        def foo(), do: nil
+        def foo(modules), do: &hd(modules).module_info/0
       end
       """
-    end) =~ "nofile:3: warning: type priv/0 is private, @typedoc's are always discarded for private types"
+    )
   after
-    purge [Sample]
+    purge(Sample)
   end
 
-  test :typedoc_with_no_type do
-    assert capture_err(fn ->
-      Code.eval_string """
+  test "deprecate non-quoted variables in bitstring size modifiers" do
+    assert_warn_eval(
+      [
+        "the variable \"a\" is accessed inside size(...) of a bitstring but it was defined outside of the match",
+        "You must precede it with the pin operator"
+      ],
+      """
+      a = "foo"
+      <<a::binary-size(byte_size(a) - 1)>> <> _ = a
+      "fo" = a
+      """
+    )
+  end
+
+  defp assert_compile_error(messages, string) do
+    captured =
+      capture_err(fn ->
+        assert_raise CompileError, fn ->
+          ast = Code.string_to_quoted!(string, columns: true)
+          Code.eval_quoted(ast)
+        end
+      end)
+
+    for message <- List.wrap(messages) do
+      assert captured =~ message
+    end
+  end
+
+  defp purge(list) when is_list(list) do
+    Enum.each(list, &purge/1)
+  end
+
+  test "unused require" do
+    assert_warn_compile(
+      ["nofile:2:3", "unused require Application"],
+      """
       defmodule Sample do
-        @typedoc "Something"
+        require Application
+        def a, do: nil
       end
       """
-    end) =~ "nofile:1: warning: @typedoc provided but no type follows it"
+    )
+
+    assert_warn_compile(
+      ["nofile:1:1", "unused require Logger"],
+      """
+      require Logger
+      """
+    )
   after
-    purge [Sample]
+    purge(Sample)
   end
 
-  defp purge(list) when is_list(list) do
-    Enum.each list, &purge/1
+  test "conditional require" do
+    assert capture_err(fn ->
+             defmodule KernelTest.ConditionalRequire do
+               if false do
+                 require Integer
+                 def fun(x), do: Integer.is_odd(x)
+               end
+             end
+           end) == ""
+  after
+    purge(Sample)
   end
 
   defp purge(module) when is_atom(module) do
-    :code.delete module
-    :code.purge module
+    :code.purge(module)
+    :code.delete(module)
   end
 end
diff --git a/lib/elixir/test/elixir/kernel/with_test.exs b/lib/elixir/test/elixir/kernel/with_test.exs
new file mode 100644
index 00000000000..7da7b49bb9f
--- /dev/null
+++ b/lib/elixir/test/elixir/kernel/with_test.exs
@@ -0,0 +1,176 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Kernel.WithTest do
+  use ExUnit.Case, async: true
+
+  test "basic with" do
+    assert with({:ok, res} <- ok(41), do: res) == 41
+    assert with(res <- four(), do: res + 10) == 14
+  end
+
+  test "matching with" do
+    assert with(_..42//_ <- 1..42, do: :ok) == :ok
+    assert with({:ok, res} <- error(), do: res) == :error
+    assert with({:ok, _} = res <- ok(42), do: elem(res, 1)) == 42
+  end
+
+  test "with guards" do
+    assert with(x when x < 2 <- four(), do: :ok) == 4
+    assert with(x when x > 2 <- four(), do: :ok) == :ok
+    assert with(x when x < 2 when x == 4 <- four(), do: :ok) == :ok
+  end
+
+  test "pin matching with" do
+    key = :ok
+    assert with({^key, res} <- ok(42), do: res) == 42
+  end
+
+  test "pin matching with multiple else" do
+    key = :error
+
+    first_else =
+      with nil <- error() do
+        :ok
+      else
+        ^key -> :pinned
+        _other -> :other
+      end
+
+    assert first_else == :pinned
+
+    second_else =
+      with nil <- ok(42) do
+        :ok
+      else
+        ^key -> :pinned
+        _other -> :other
+      end
+
+    assert second_else == :other
+  end
+
+  test "two levels with" do
+    result =
+      with {:ok, n1} <- ok(11),
+           n2 <- 22,
+           do: n1 + n2
+
+    assert result == 33
+
+    result =
+      with n1 <- 11,
+           {:ok, n2} <- error(),
+           do: n1 + n2
+
+    assert result == :error
+  end
+
+  test "binding inside with" do
+    result =
+      with {:ok, n1} <- ok(11),
+           n2 = n1 + 10,
+           {:ok, n3} <- ok(22),
+           do: n2 + n3
+
+    assert result == 43
+
+    result =
+      with {:ok, n1} <- ok(11),
+           n2 = n1 + 10,
+           {:ok, n3} <- error(),
+           do: n2 + n3
+
+    assert result == :error
+  end
+
+  test "does not leak variables to else" do
+    state = 1
+
+    result =
+      with 1 <- state,
+           state = 2,
+           :ok <- error(),
+           do: state,
+           else: (_ -> state)
+
+    assert result == 1
+    assert state == 1
+  end
+
+  test "with shadowing" do
+    assert with(
+             a <-
+               (
+                 b = 1
+                 _ = b
+                 1
+               ),
+             b <- 2,
+             do: a + b
+           ) == 3
+  end
+
+  test "with extra guards" do
+    var =
+      with %_{} = a <- struct(URI),
+           %_{} <- a do
+        :ok
+      end
+
+    assert var == :ok
+  end
+
+  test "errors in with" do
+    assert_raise RuntimeError, fn ->
+      with({:ok, res} <- oops(), do: res)
+    end
+
+    assert_raise RuntimeError, fn ->
+      with({:ok, res} <- ok(42), oops(), do: res)
+    end
+  end
+
+  test "else conditions" do
+    assert (with {:ok, res} <- four() do
+              res
+            else
+              {:error, error} -> error
+              res -> res + 1
+            end) == 5
+
+    assert (with {:ok, res} <- four() do
+              res
+            else
+              res when res == 4 -> res + 1
+              res -> res
+            end) == 5
+
+    assert with({:ok, res} <- four(), do: res, else: (_ -> :error)) == :error
+  end
+
+  test "else conditions with match error" do
+    assert_raise WithClauseError, "no with clause matching:\n\n    :error\n", fn ->
+      with({:ok, res} <- error(), do: res, else: ({:error, error} -> error))
+    end
+  end
+
+  defp four() do
+    4
+  end
+
+  defp error() do
+    :error
+  end
+
+  defp ok(num) do
+    {:ok, num}
+  end
+
+  defp oops() do
+    raise("oops")
+  end
+end
diff --git a/lib/elixir/test/elixir/kernel_test.exs b/lib/elixir/test/elixir/kernel_test.exs
index eee1a160d58..b4f1033fca5 100644
--- a/lib/elixir/test/elixir/kernel_test.exs
+++ b/lib/elixir/test/elixir/kernel_test.exs
@@ -1,15 +1,111 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule KernelTest do
   use ExUnit.Case, async: true
 
+  # Skip these doctests are they emit warnings
+  doctest Kernel,
+    except:
+      [===: 2, !==: 2, and: 2, or: 2] ++
+        [is_exception: 1, is_exception: 2, is_nil: 1, is_struct: 1, is_non_struct_map: 1]
+
+  def id(arg), do: arg
+  def id(arg1, arg2), do: {arg1, arg2}
+  def empty_map, do: %{}
+
+  defp purge(module) do
+    :code.purge(module)
+    :code.delete(module)
+  end
+
+  defp assert_eval_raise(error, msg, string) do
+    assert_raise error, msg, fn ->
+      Code.eval_string(string)
+    end
+  end
+
+  test "op ambiguity" do
+    max = 1
+    assert max == 1
+    assert max(1, 2) == 2
+  end
+
+  describe "=/2" do
+    test "can be reassigned" do
+      var = 1
+      id(var)
+      var = 2
+      assert var == 2
+    end
+
+    test "can be reassigned inside a list" do
+      _ = [var = 1, 2, 3]
+      id(var)
+      _ = [var = 2, 3, 4]
+      assert var == 2
+    end
+
+    test "can be reassigned inside a keyword list" do
+      _ = [a: var = 1, b: 2]
+      id(var)
+      _ = [b: var = 2, c: 3]
+      assert var == 2
+    end
+
+    test "can be reassigned inside a call" do
+      id(var = 1)
+      id(var)
+      id(var = 2)
+      assert var == 2
+    end
+
+    test "can be reassigned inside a multi-argument call" do
+      id(:arg, var = 1)
+      id(:arg, var)
+      id(:arg, var = 2)
+      assert var == 2
+
+      id(:arg, a: 1, b: var = 2)
+      id(:arg, var)
+      id(:arg, b: 2, c: var = 3)
+      assert var == 3
+    end
+
+    test "++/2 works in matches" do
+      [1, 2] ++ var = [1, 2]
+      assert var == []
+
+      [1, 2] ++ var = [1, 2, 3]
+      assert var == [3]
+
+      ~c"ab" ++ var = ~c"abc"
+      assert var == ~c"c"
+
+      [:a, :b] ++ var = [:a, :b, :c]
+      assert var == [:c]
+    end
+  end
+
   test "=~/2" do
-    assert ("abcd" =~ ~r/c(d)/) == true
-    assert ("abcd" =~ ~r/e/) == false
+    assert "abcd" =~ ~r/c(d)/ == true
+    assert "abcd" =~ ~r/e/ == false
 
     string = "^ab+cd*$"
-    assert (string =~ "ab+") == true
-    assert (string =~ "bb") == false
+    assert string =~ "ab+" == true
+    assert string =~ "bb" == false
+
+    assert "abcd" =~ ~r// == true
+    assert "abcd" =~ "" == true
+
+    assert "" =~ ~r// == true
+    assert "" =~ "" == true
+
+    assert "" =~ "abcd" == false
+    assert "" =~ ~r/abcd/ == false
 
     assert_raise FunctionClauseError, "no function clause matching in Kernel.=~/2", fn ->
       1234 =~ "hello"
@@ -18,6 +114,34 @@ defmodule KernelTest do
     assert_raise FunctionClauseError, "no function clause matching in Kernel.=~/2", fn ->
       1234 =~ ~r"hello"
     end
+
+    assert_raise FunctionClauseError, "no function clause matching in Kernel.=~/2", fn ->
+      1234 =~ ~r"hello"
+    end
+
+    assert_raise FunctionClauseError, "no function clause matching in Kernel.=~/2", fn ->
+      ~r"hello" =~ "hello"
+    end
+
+    assert_raise FunctionClauseError, "no function clause matching in Kernel.=~/2", fn ->
+      ~r"hello" =~ ~r"hello"
+    end
+
+    assert_raise FunctionClauseError, "no function clause matching in Kernel.=~/2", fn ->
+      :abcd =~ ~r//
+    end
+
+    assert_raise FunctionClauseError, "no function clause matching in Kernel.=~/2", fn ->
+      :abcd =~ ""
+    end
+
+    assert_raise FunctionClauseError, "no function clause matching in Regex.match?/2", fn ->
+      "abcd" =~ nil
+    end
+
+    assert_raise FunctionClauseError, "no function clause matching in Regex.match?/2", fn ->
+      "abcd" =~ :abcd
+    end
   end
 
   test "^" do
@@ -29,392 +153,1101 @@ defmodule KernelTest do
     end
   end
 
+  # Note we use `==` in assertions so `assert` does not rewrite `match?/2`.
   test "match?/2" do
-    assert match?(_, List.first(1)) == true
-    assert binding([:x]) == []
-
     a = List.first([0])
     assert match?(b when b > a, 1) == true
-    assert binding([:b]) == []
+    assert binding() == [a: 0]
 
     assert match?(b when b > a, -1) == false
-    assert binding([:b]) == []
+    assert binding() == [a: 0]
+
+    # Does not warn on underscored variables
+    assert match?(_unused, a) == true
   end
 
-  test "nil?/1" do
-    assert nil?(nil) == true
-    assert nil?(0) == false
-    assert nil?(false) == false
+  def exported?, do: not_exported?()
+  defp not_exported?, do: true
+
+  test "function_exported?/3" do
+    assert function_exported?(__MODULE__, :exported?, 0)
+    refute function_exported?(__MODULE__, :not_exported?, 0)
   end
 
-  test "in/2" do
-    assert 2 in [1, 2, 3]
-    assert 2 in 1..3
-    refute 4 in [1, 2, 3]
-    refute 4 in 1..3
+  test "macro_exported?/3" do
+    assert macro_exported?(Kernel, :in, 2) == true
+    assert macro_exported?(Kernel, :def, 1) == true
+    assert macro_exported?(Kernel, :def, 2) == true
+    assert macro_exported?(Kernel, :def, 3) == false
+    assert macro_exported?(Kernel, :no_such_macro, 2) == false
+    assert macro_exported?(:erlang, :abs, 1) == false
+  end
 
-    list = [1, 2, 3]
-    assert 2 in list
-    refute 4 in list
+  test "apply/3 and apply/2" do
+    assert apply(Enum, :reverse, [[1 | [2, 3]]]) == [3, 2, 1]
+    assert apply(fn x -> x * 2 end, [2]) == 4
   end
 
-  @at_list  [4,5]
-  @at_range 6..8
-  def fun_in(x) when x in [0],       do: :list
-  def fun_in(x) when x in 1..3,      do: :range
-  def fun_in(x) when x in @at_list,  do: :at_list
-  def fun_in(x) when x in @at_range, do: :at_range
+  test "binding/0 and binding/1" do
+    x = 1
+    assert binding() == [x: 1]
+
+    x = 2
+    assert binding() == [x: 2]
 
-  test "in/2 in function guard" do
-    assert fun_in(0) == :list
-    assert fun_in(2) == :range
-    assert fun_in(5) == :at_list
-    assert fun_in(8) == :at_range
+    y = 3
+    assert binding() == [x: 2, y: 3]
+
+    var!(x, :foo) = 4
+    assert binding() == [x: 2, y: 3]
+    assert binding(:foo) == [x: 4]
+
+    # No warnings
+    _x = 1
+    assert binding() == [_x: 1, x: 2, y: 3]
   end
 
-  defmacrop case_in(x, y) do
-    quote do
-      case 0 do
-        _ when unquote(x) in unquote(y) -> true
-        _ -> false
-      end
-    end
+  defmodule User do
+    assert is_map(defstruct name: "john")
+    # Ensure we keep the line information around.
+    # It is important for debugging tools, ExDoc, etc.
+    {:v1, :def, anno, _clauses} = Module.get_definition(__MODULE__, {:__struct__, 1})
+    anno[:line] == __ENV__.line - 4
   end
 
-  test "in/2 in case guard" do
-    assert case_in(1, [1,2,3]) == true
-    assert case_in(1, 1..3) == true
-    assert case_in(2, 1..3) == true
-    assert case_in(3, 1..3) == true
-    assert case_in(-3, -1..-3) == true
+  test "struct/1 and struct/2" do
+    assert struct(User) == %User{name: "john"}
+
+    user = struct(User, name: "meg")
+    assert user == %User{name: "meg"}
+    assert struct(user, %{name: "meg"}) == user
+
+    assert struct(user, unknown: "key") == user
+    assert struct(user, %{name: "john"}) == %User{name: "john"}
+    assert struct(user, name: "other", __struct__: Post) == %User{name: "other"}
   end
 
-  test "paren as nil" do
-    assert nil?(()) == true
-    assert ((); ();) == nil
-    assert [ 1, (), 3 ] == [1, nil, 3 ]
-    assert [do: ()] == [do: nil]
-    assert {1, (), 3} == {1, nil, 3}
-    assert (Kernel.&& nil, ()) == nil
-    assert (Kernel.&& nil, ()) == nil
-    assert (() && ()) == nil
-    assert (if(() && ()) do
-      :ok
-    else
-      :error
-    end) == :error
+  test "struct!/1 and struct!/2" do
+    assert struct!(User) == %User{name: "john"}
+
+    user = struct!(User, name: "meg")
+    assert user == %User{name: "meg"}
+
+    assert_raise KeyError, fn ->
+      struct!(user, unknown: "key")
+    end
+
+    assert struct!(user, %{name: "john"}) == %User{name: "john"}
+    assert struct!(user, name: "other", __struct__: Post) == %User{name: "other"}
   end
 
-  test "__info__(:macros)" do
-    assert {:in, 2} in Kernel.__info__(:macros)
+  test "if/2 with invalid keys" do
+    error_message =
+      "invalid or duplicate keys for if, only \"do\" and an optional \"else\" are permitted"
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("if true, foo: 7")
+    end
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("if true, do: 6, boo: 7")
+    end
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("if true, do: 7, do: 6")
+    end
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("if true, do: 8, else: 7, else: 6")
+    end
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("if true, else: 6")
+    end
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("if true, []")
+    end
   end
 
-  test "__info__(:functions)" do
-    assert not ({:__info__, 1} in Kernel.__info__(:functions))
+  test "unless/2 with invalid keys" do
+    error_message =
+      "invalid or duplicate keys for unless, only \"do\" " <>
+        "and an optional \"else\" are permitted"
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("unless true, foo: 7")
+    end
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("unless true, do: 6, boo: 7")
+    end
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("unless true, do: 7, do: 6")
+    end
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("unless true, do: 8, else: 7, else: 6")
+    end
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("unless true, else: 6")
+    end
+
+    assert_raise ArgumentError, error_message, fn ->
+      Code.eval_string("unless true, []")
+    end
   end
 
-  test "macro_exported?/3" do
-    assert macro_exported?(Kernel, :in, 2) == true
-    assert macro_exported?(Kernel, :def, 1) == true
-    assert macro_exported?(Kernel, :def, 2) == true
-    assert macro_exported?(Kernel, :def, 3) == false
-    assert macro_exported?(Kernel, :no_such_macro, 2) == false
+  test "and/2" do
+    assert (true and false) == false
+    assert (true and true) == true
+    assert (true and 0) == 0
+    assert (false and false) == false
+    assert (false and true) == false
+    assert (false and 0) == false
+    assert (false and raise("oops")) == false
+    assert ((x = Process.get(:unused, true)) and not x) == false
+    assert_raise BadBooleanError, fn -> Process.get(:unused, 0) and 1 end
   end
 
-  test "apply/3 and apply/2" do
-    assert apply(Enum, :reverse, [[1|[2, 3]]]) == [3, 2, 1]
-    assert apply(fn x -> x * 2 end, [2]) == 4
+  test "or/2" do
+    assert (true or false) == true
+    assert (true or true) == true
+    assert (true or 0) == true
+    assert (true or raise("foo")) == true
+    assert (false or false) == false
+    assert (false or true) == true
+    assert (false or 0) == 0
+    assert ((x = Process.get(:unused, false)) or not x) == true
+    assert_raise BadBooleanError, fn -> Process.get(:unused, 0) or 1 end
   end
 
-  test "binding/0, binding/1 and binding/2" do
-    x = 1
-    assert binding == [x: 1]
-    assert binding([:x, :y]) == [x: 1]
-    assert binding([:x, :y], nil) == [x: 1]
+  defp delegate_is_struct(arg), do: is_struct(arg)
 
-    x = 2
-    assert binding == [x: 2]
+  defp guarded_is_struct(arg) when is_struct(arg), do: true
+  defp guarded_is_struct(_arg), do: false
 
-    y = 3
-    assert binding == [x: 2, y: 3]
+  defp struct_or_map?(arg) when is_struct(arg) or is_map(arg), do: true
+  defp struct_or_map?(_arg), do: false
 
-    var!(x, :foo) = 2
-    assert binding(:foo) == [x: 2]
-    assert binding([:x, :y], :foo) == [x: 2]
+  test "is_struct/1" do
+    assert delegate_is_struct(%{}) == false
+    assert delegate_is_struct([]) == false
+    assert delegate_is_struct(%Macro.Env{}) == true
+    assert delegate_is_struct(%{__struct__: "foo"}) == false
+    assert guarded_is_struct(%Macro.Env{}) == true
+    assert guarded_is_struct(%{__struct__: "foo"}) == false
+    assert guarded_is_struct([]) == false
+    assert guarded_is_struct(%{}) == false
   end
 
-  defmodule User do
-    defstruct name: "jose"
+  test "is_struct/1 and other match works" do
+    assert struct_or_map?(%Macro.Env{}) == true
+    assert struct_or_map?(%{}) == true
+    assert struct_or_map?(10) == false
   end
 
-  defmodule UserTuple do
-    def __struct__({ UserTuple, :ok }) do
-      %User{}
+  defp delegate_is_struct(arg, name), do: is_struct(arg, name)
+
+  defp guarded_is_struct(arg, name) when is_struct(arg, name), do: true
+  defp guarded_is_struct(_arg, _name), do: false
+
+  defp struct_or_map?(arg, name) when is_struct(arg, name) or is_map(arg), do: true
+  defp struct_or_map?(_arg, _name), do: false
+
+  defp not_atom(), do: "not atom"
+
+  test "is_struct/2" do
+    assert delegate_is_struct(%{}, Macro.Env) == false
+    assert delegate_is_struct([], Macro.Env) == false
+    assert delegate_is_struct(%Macro.Env{}, Macro.Env) == true
+    assert delegate_is_struct(%Macro.Env{}, URI) == false
+    assert guarded_is_struct(%Macro.Env{}, Macro.Env) == true
+    assert guarded_is_struct(%Macro.Env{}, URI) == false
+    assert guarded_is_struct(%{__struct__: "foo"}, "foo") == false
+    assert guarded_is_struct(%{__struct__: "foo"}, Macro.Env) == false
+    assert guarded_is_struct([], Macro.Env) == false
+    assert guarded_is_struct(%{}, Macro.Env) == false
+
+    assert_raise ArgumentError, "argument error", fn ->
+      is_struct(%{}, not_atom())
     end
   end
 
-  test "struct/1 and struct/2" do
-    assert struct(User) == %User{name: "jose"}
+  test "is_struct/2 and other match works" do
+    assert struct_or_map?(%{}, "foo") == false
+    assert struct_or_map?(%{}, Macro.Env) == true
+    assert struct_or_map?(%Macro.Env{}, Macro.Env) == true
+  end
 
-    user = struct(User, name: "eric")
-    assert user == %User{name: "eric"}
+  defp delegate_is_non_struct_map(arg), do: is_non_struct_map(arg)
 
-    assert struct(user, unknown: "key") == user
-    assert struct(user, %{name: "jose"}) == %User{name: "jose"}
-    assert struct(user, name: "other", __struct__: Post) == %User{name: "other"}
+  defp guarded_is_non_struct_map(arg) when is_non_struct_map(arg), do: true
+  defp guarded_is_non_struct_map(_arg), do: false
+
+  defp non_struct_map_or_struct?(arg) when is_non_struct_map(arg) or is_struct(arg), do: true
+  defp non_struct_map_or_struct?(_arg), do: false
+
+  test "is_non_struct_map/1" do
+    assert delegate_is_non_struct_map(%{}) == true
+    assert delegate_is_non_struct_map([]) == false
+    assert delegate_is_non_struct_map(%Macro.Env{}) == false
+    assert delegate_is_non_struct_map(%{__struct__: "foo"}) == true
+    assert guarded_is_non_struct_map(%Macro.Env{}) == false
+    assert guarded_is_non_struct_map(%{__struct__: "foo"}) == true
+    assert guarded_is_non_struct_map([]) == false
+    assert guarded_is_non_struct_map(%{}) == true
+  end
 
-    user_tuple = {UserTuple, :ok}
-    assert struct(user_tuple, name: "eric") == %User{name: "eric"}
+  test "is_non_struct_map/1 and other match works" do
+    assert non_struct_map_or_struct?(%Macro.Env{}) == true
+    assert non_struct_map_or_struct?(%{}) == true
+    assert non_struct_map_or_struct?(10) == false
   end
 
-  defdelegate my_flatten(list), to: List, as: :flatten
-  defdelegate [map(callback, list)], to: :lists, append_first: true
+  defp delegate_is_exception(arg), do: is_exception(arg)
 
-  dynamic = :dynamic_flatten
-  defdelegate unquote(dynamic)(list), to: List, as: :flatten
+  defp guarded_is_exception(arg) when is_exception(arg), do: true
+  defp guarded_is_exception(_arg), do: false
 
-  test "defdelefate/2" do
-    assert my_flatten([[1]]) == [1]
+  defp exception_or_map?(arg) when is_exception(arg) or is_map(arg), do: true
+  defp exception_or_map?(_arg), do: false
+
+  test "is_exception/1" do
+    assert delegate_is_exception(%{}) == false
+    assert delegate_is_exception([]) == false
+    assert delegate_is_exception(%RuntimeError{}) == true
+    assert delegate_is_exception(%{__exception__: "foo"}) == false
+    assert guarded_is_exception(%RuntimeError{}) == true
+    assert guarded_is_exception(%{__exception__: "foo"}) == false
+    assert guarded_is_exception([]) == false
+    assert guarded_is_exception(%{}) == false
   end
 
-  test "defdelegate/2 with :append_first" do
-    assert map([1], fn(x) -> x + 1 end) == [2]
+  test "is_exception/1 and other match works" do
+    assert exception_or_map?(%RuntimeError{}) == true
+    assert exception_or_map?(%{}) == true
+    assert exception_or_map?(10) == false
   end
 
-  test "defdelegate/2 with unquote" do
-    assert dynamic_flatten([[1]]) == [1]
+  defp delegate_is_exception(arg, name), do: is_exception(arg, name)
+
+  defp guarded_is_exception(arg, name) when is_exception(arg, name), do: true
+  defp guarded_is_exception(_arg, _name), do: false
+
+  defp exception_or_map?(arg, name) when is_exception(arg, name) or is_map(arg), do: true
+  defp exception_or_map?(_arg, _name), do: false
+
+  test "is_exception/2" do
+    assert delegate_is_exception(%{}, RuntimeError) == false
+    assert delegate_is_exception([], RuntimeError) == false
+    assert delegate_is_exception(%RuntimeError{}, RuntimeError) == true
+    assert delegate_is_exception(%RuntimeError{}, Macro.Env) == false
+    assert guarded_is_exception(%RuntimeError{}, RuntimeError) == true
+    assert guarded_is_exception(%RuntimeError{}, Macro.Env) == false
+    assert guarded_is_exception(%{__exception__: "foo"}, "foo") == false
+    assert guarded_is_exception(%{__exception__: "foo"}, RuntimeError) == false
+    assert guarded_is_exception([], RuntimeError) == false
+    assert guarded_is_exception(%{}, RuntimeError) == false
+
+    assert_raise ArgumentError, "argument error", fn ->
+      delegate_is_exception(%{}, not_atom())
+    end
   end
 
-  test "get_in/2" do
-    users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
-    assert get_in(users, ["josé", :age]) == 27
-    assert get_in(users, ["dave", :age]) == nil
-    assert get_in(nil, ["josé", :age]) == nil
+  test "is_exception/2 and other match works" do
+    assert exception_or_map?(%{}, "foo") == false
+    assert exception_or_map?(%{}, RuntimeError) == true
+    assert exception_or_map?(%RuntimeError{}, RuntimeError) == true
+  end
 
-    assert_raise FunctionClauseError, fn ->
-      get_in(users, [])
+  test "then/2" do
+    assert 1 |> then(fn x -> x * 2 end) == 2
+  end
+
+  test "if/2 boolean optimization does not leak variables during expansion" do
+    if false do
+      :ok
+    else
+      assert Macro.Env.vars(__ENV__) == []
+    end
+  end
+
+  describe ".." do
+    test "returns 0..-1//1" do
+      assert (..) == 0..-1//1
     end
   end
 
-  test "put_in/3" do
-    users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
+  describe "in/2" do
+    # This test may take a long time on machine with low resources
+    @tag timeout: 120_000
+    test "too large list in guards" do
+      defmodule TooLargeList do
+        @list Enum.map(1..1024, & &1)
+        defguard is_value(value) when value in @list
+      end
+    end
+
+    test "with literals on right side" do
+      assert 2 in [1, 2, 3]
+      assert 2 in 1..3
+      refute 4 in [1, 2, 3]
+      refute 4 in 1..3
+      refute 2 in []
+      refute false in []
+      refute true in []
+    end
 
-    assert put_in(nil, ["josé", :age], 28) ==
-           %{"josé" => %{age: 28}}
+    test "with expressions on right side" do
+      list = [1, 2, 3]
+      empty_list = []
+      assert 2 in list
+      refute 4 in list
 
-    assert put_in(users, ["josé", :age], 28) ==
-           %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      refute 4 in empty_list
+      refute false in empty_list
+      refute true in empty_list
 
-    assert put_in(users, ["dave", :age], 19) ==
-           %{"josé" => %{age: 27}, "eric" => %{age: 23}, "dave" => %{age: 19}}
+      assert 2 in [1 | [2, 3]]
+      assert 3 in [1 | list]
 
-    assert_raise FunctionClauseError, fn ->
-      put_in(users, [], %{})
+      some_call = & &1
+      refute :x in [1, 2 | some_call.([3, 4])]
+      assert :x in [1, 2 | some_call.([3, :x])]
+
+      assert_raise ArgumentError, fn ->
+        :x in [1, 2 | some_call.({3, 4})]
+      end
     end
-  end
 
-  test "put_in/2" do
-    users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
+    @at_list1 [4, 5]
+    @at_range 6..8
+    @at_list2 [13, 14]
+    def fun_in(x) when x in [0], do: :list
+    def fun_in(x) when x in 1..3, do: :range
+    def fun_in(x) when x in @at_list1, do: :at_list
+    def fun_in(x) when x in @at_range, do: :at_range
+    def fun_in(x) when x in [9 | [10, 11]], do: :list_cons
+    def fun_in(x) when x in [12 | @at_list2], do: :list_cons_at
+    def fun_in(x) when x in 21..15//1, do: raise("oops positive")
+    def fun_in(x) when x in 15..21//-1, do: raise("oops negative")
+    def fun_in(x) when x in 15..21//2, do: :range_step_2
+    def fun_in(x) when x in 15..21//1, do: :range_step_1
+    def fun_in(_), do: :none
+
+    test "in function guard" do
+      assert fun_in(0) == :list
+      assert fun_in(1) == :range
+      assert fun_in(2) == :range
+      assert fun_in(3) == :range
+      assert fun_in(5) == :at_list
+      assert fun_in(6) == :at_range
+      assert fun_in(7) == :at_range
+      assert fun_in(8) == :at_range
+      assert fun_in(9) == :list_cons
+      assert fun_in(10) == :list_cons
+      assert fun_in(11) == :list_cons
+      assert fun_in(12) == :list_cons_at
+      assert fun_in(13) == :list_cons_at
+      assert fun_in(14) == :list_cons_at
+      assert fun_in(15) == :range_step_2
+      assert fun_in(16) == :range_step_1
+      assert fun_in(17) == :range_step_2
+      assert fun_in(22) == :none
+
+      assert fun_in(0.0) == :none
+      assert fun_in(1.0) == :none
+      assert fun_in(2.0) == :none
+      assert fun_in(3.0) == :none
+      assert fun_in(6.0) == :none
+      assert fun_in(7.0) == :none
+      assert fun_in(8.0) == :none
+      assert fun_in(9.0) == :none
+      assert fun_in(10.0) == :none
+      assert fun_in(11.0) == :none
+      assert fun_in(12.0) == :none
+      assert fun_in(13.0) == :none
+      assert fun_in(14.0) == :none
+      assert fun_in(15.0) == :none
+      assert fun_in(16.0) == :none
+      assert fun_in(17.0) == :none
+    end
 
-    assert put_in(nil["josé"][:age], 28) ==
-           %{"josé" => %{age: 28}}
+    def dynamic_step_in(x, y, z, w) when x in y..z//w, do: true
+    def dynamic_step_in(_x, _y, _z, _w), do: false
 
-    assert put_in(users["josé"][:age], 28) ==
-           %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+    test "in dynamic range with step function guard" do
+      assert dynamic_step_in(1, 1, 3, 1)
+      assert dynamic_step_in(2, 1, 3, 1)
+      assert dynamic_step_in(3, 1, 3, 1)
 
-    assert put_in(users["dave"][:age], 19) ==
-           %{"josé" => %{age: 27}, "eric" => %{age: 23}, "dave" => %{age: 19}}
+      refute dynamic_step_in(1, 1, 3, -1)
+      refute dynamic_step_in(2, 1, 3, -1)
+      refute dynamic_step_in(3, 1, 3, -1)
 
+      assert dynamic_step_in(1, 3, 1, -1)
+      assert dynamic_step_in(2, 3, 1, -1)
+      assert dynamic_step_in(3, 3, 1, -1)
 
-    assert put_in(users["josé"].age, 28) ==
-           %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      refute dynamic_step_in(1, 3, 1, 1)
+      refute dynamic_step_in(2, 3, 1, 1)
+      refute dynamic_step_in(3, 3, 1, 1)
 
-    assert_raise ArgumentError, fn ->
-      put_in(users["dave"].age, 19)
+      assert dynamic_step_in(1, 1, 3, 2)
+      refute dynamic_step_in(2, 1, 3, 2)
+      assert dynamic_step_in(3, 1, 3, 2)
+      assert dynamic_step_in(3, 1, 4, 2)
+      refute dynamic_step_in(4, 1, 4, 2)
     end
 
-    assert_raise KeyError, fn ->
-      put_in(users["eric"].unknown, "value")
+    defmacrop case_in(x, y) do
+      quote do
+        case 0 do
+          _ when unquote(x) in unquote(y) -> true
+          _ -> false
+        end
+      end
     end
-  end
 
-  test "update_in/3" do
-    users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
+    test "in case guard" do
+      assert case_in(1, [1, 2, 3]) == true
+      assert case_in(1, 1..3) == true
+      assert case_in(2, 1..3) == true
+      assert case_in(3, 1..3) == true
+      assert case_in(-3, -1..-3//-1) == true
+    end
 
-    assert update_in(nil, ["josé", :age], fn nil -> 28 end) ==
-           %{"josé" => %{age: 28}}
+    def map_dot(map) when map.field, do: true
+    def map_dot(_other), do: false
 
-    assert update_in(users, ["josé", :age], &(&1 + 1)) ==
-           %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+    test "map dot guard" do
+      refute map_dot(:foo)
+      refute map_dot(%{})
+      refute map_dot(%{field: false})
+      assert map_dot(%{field: true})
+    end
 
-    assert update_in(users, ["dave", :age], fn nil -> 19 end) ==
-           %{"josé" => %{age: 27}, "eric" => %{age: 23}, "dave" => %{age: 19}}
+    test "performs all side-effects" do
+      assert 1 in [1, send(self(), 2)]
+      assert_received 2
 
-    assert_raise FunctionClauseError, fn ->
-      update_in(users, [], fn _ -> %{} end)
+      assert 1 in [1 | send(self(), [2])]
+      assert_received [2]
+
+      assert 2 in [1 | send(self(), [2])]
+      assert_received [2]
+    end
+
+    test "has proper evaluation order" do
+      a = 1
+      assert 1 in [a = 2, a]
+      # silence unused var warning
+      _ = a
+    end
+
+    test "in module body" do
+      defmodule InSample do
+        @foo [:a, :b]
+        true = :a in @foo
+      end
+    after
+      purge(InSample)
     end
-  end
 
-  test "update_in/2" do
-    users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
+    test "inside and/2" do
+      response = %{code: 200}
 
-    assert update_in(nil["josé"][:age], fn nil -> 28 end) ==
-           %{"josé" => %{age: 28}}
+      if is_map(response) and response.code in 200..299 do
+        :pass
+      end
 
-    assert update_in(users["josé"][:age], &(&1 + 1)) ==
-           %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      # This module definition copies internal variable
+      # defined during in/2 expansion.
+      Module.create(InVarCopy, nil, __ENV__)
+      purge(InVarCopy)
+    end
 
-    assert update_in(users["dave"][:age], fn nil -> 19 end) ==
-           %{"josé" => %{age: 27}, "eric" => %{age: 23}, "dave" => %{age: 19}}
+    test "with a non-literal non-escaped compile-time range in guards" do
+      message = ~r"found unescaped value on the right side of in/2: 1..3"
 
-    assert update_in(users["josé"].age, &(&1 + 1)) ==
-           %{"josé" => %{age: 28}, "eric" => %{age: 23}}
+      assert_eval_raise(ArgumentError, message, """
+      defmodule InErrors do
+        range = 1..3
+        def foo(x) when x in unquote(range), do: :ok
+      end
+      """)
+    end
+
+    test "with a non-compile-time range in guards" do
+      message = ~r/invalid right argument for operator "in", .* got: :hello/
 
-    assert_raise ArgumentError, fn ->
-      update_in(users["dave"].age, &(&1 + 1))
+      assert_eval_raise(ArgumentError, message, """
+      defmodule InErrors do
+        def foo(x) when x in :hello, do: :ok
+      end
+      """)
     end
 
-    assert_raise KeyError, fn ->
-      put_in(users["eric"].unknown, &(&1 + 1))
+    test "with a non-compile-time list cons in guards" do
+      message = ~r/invalid right argument for operator "in", .* got: \[1 | list\(\)\]/
+
+      assert_eval_raise(ArgumentError, message, """
+      defmodule InErrors do
+        def list, do: [1]
+        def foo(x) when x in [1 | list()], do: :ok
+      end
+      """)
     end
-  end
 
-  test "get_and_update_in/3" do
-    users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
+    test "with a compile-time non-list in tail in guards" do
+      message = ~r/invalid right argument for operator "in", .* got: \[1 | 1..3\]/
 
-    assert get_and_update_in(nil, ["josé", :age], fn nil -> {:ok, 28} end) ==
-           {:ok, %{"josé" => %{age: 28}}}
+      assert_eval_raise(ArgumentError, message, """
+      defmodule InErrors do
+        def foo(x) when x in [1 | 1..3], do: :ok
+      end
+      """)
+    end
 
-    assert get_and_update_in(users, ["josé", :age], &{&1, &1 + 1}) ==
-           {27, %{"josé" => %{age: 28}, "eric" => %{age: 23}}}
+    test "with a non-integer range" do
+      message = "ranges (first..last) expect both sides to be integers, got: 0..5.0"
 
-    assert_raise FunctionClauseError, fn ->
-      update_in(users, [], fn _ -> %{} end)
+      assert_raise ArgumentError, message, fn ->
+        last = 5.0
+        1 in 0..last
+      end
     end
-  end
 
-  test "get_and_update_in/2" do
-    users = %{"josé" => %{age: 27}, "eric" => %{age: 23}}
+    test "hoists variables and keeps order" do
+      # Ranges
+      result = expand_to_string(quote(do: rand() in 1..2))
+      assert result =~ "var = rand()"
+
+      assert result =~ """
+             :erlang.andalso(
+               :erlang.is_integer(var),
+               :erlang.andalso(:erlang.>=(var, 1), :erlang.\"=<\"(var, 2))
+             )\
+             """
 
-    assert get_and_update_in(nil["josé"][:age], fn nil -> {:ok, 28} end) ==
-           {:ok, %{"josé" => %{age: 28}}}
+      # Empty list
+      assert expand_to_string(quote(do: :x in [])) =~ "_ = :x\nfalse"
+      assert expand_to_string(quote(do: :x in []), :guard) == "false"
 
-    assert get_and_update_in(users["josé"].age, &{&1, &1 + 1}) ==
-           {27, %{"josé" => %{age: 28}, "eric" => %{age: 23}}}
+      # Lists
+      result = expand_to_string(quote(do: rand() in [1, 2]))
+      assert result =~ "var = rand()"
+      assert result =~ ":erlang.orelse(:erlang.\"=:=\"(var, 1), :erlang.\"=:=\"(var, 2))"
 
-    assert_raise ArgumentError, fn ->
-      get_and_update_in(users["dave"].age, &{&1, &1 + 1})
+      result = expand_to_string(quote(do: rand() in [1 | [2]]))
+      assert result =~ ":lists.member(rand(), [1 | [2]]"
+
+      result = expand_to_string(quote(do: rand() in [1 | some_call()]))
+      assert result =~ ":lists.member(rand(), [1 | some_call()]"
     end
 
-    assert_raise KeyError, fn ->
-      get_and_update_in(users["eric"].unknown, &{&1, &1 + 1})
+    test "is optimized" do
+      assert expand_to_string(quote(do: foo in [])) ==
+               "_ = foo\nfalse"
+
+      assert expand_to_string(quote(do: foo in [1, 2, 3])) == """
+             :erlang.orelse(
+               :erlang.orelse(:erlang.\"=:=\"(foo, 1), :erlang.\"=:=\"(foo, 2)),
+               :erlang.\"=:=\"(foo, 3)
+             )\
+             """
+
+      assert expand_to_string(quote(do: foo in 0..1)) == """
+             :erlang.andalso(
+               :erlang.is_integer(foo),
+               :erlang.andalso(:erlang.>=(foo, 0), :erlang.\"=<\"(foo, 1))
+             )\
+             """
+
+      assert expand_to_string(quote(do: foo in -1..0)) == """
+             :erlang.andalso(
+               :erlang.is_integer(foo),
+               :erlang.andalso(:erlang.>=(foo, -1), :erlang.\"=<\"(foo, 0))
+             )\
+             """
+
+      assert expand_to_string(quote(do: foo in 1..1)) ==
+               ":erlang.\"=:=\"(foo, 1)"
+
+      assert expand_to_string(quote(do: 2 in 1..3)) ==
+               ":erlang.andalso(:erlang.is_integer(2), :erlang.andalso(:erlang.>=(2, 1), :erlang.\"=<\"(2, 3)))"
+    end
+
+    defp expand_to_string(ast, environment_or_context \\ __ENV__)
+
+    defp expand_to_string(ast, context) when is_atom(context) do
+      expand_to_string(ast, %{__ENV__ | context: context})
+    end
+
+    defp expand_to_string(ast, environment) do
+      ast
+      |> Macro.prewalk(&Macro.expand(&1, environment))
+      |> Macro.to_string()
     end
   end
 
-  test "paths" do
-    map = empty_map()
+  describe "__info__" do
+    test ":macros" do
+      assert {:in, 2} in Kernel.__info__(:macros)
+    end
 
-    assert put_in(map[:foo], "bar") == %{foo: "bar"}
-    assert put_in(empty_map()[:foo], "bar") == %{foo: "bar"}
-    assert put_in(KernelTest.empty_map()[:foo], "bar") == %{foo: "bar"}
-    assert put_in(__MODULE__.empty_map()[:foo], "bar") == %{foo: "bar"}
+    test ":functions" do
+      refute {:__info__, 1} in Kernel.__info__(:functions)
+    end
 
-    assert_raise ArgumentError, ~r"access at least one field,", fn ->
-      Code.eval_quoted(quote(do: put_in(map, "bar")), [])
+    test ":struct" do
+      assert Kernel.__info__(:struct) == nil
+      assert [%{field: :scheme, default: nil} | _] = URI.__info__(:struct)
     end
 
-    assert_raise ArgumentError, ~r"must start with a variable, local or remote call", fn ->
-      Code.eval_quoted(quote(do: put_in(map.foo(1, 2)[:bar], "baz")), [])
+    test "others" do
+      assert Kernel.__info__(:module) == Kernel
+      assert is_list(Kernel.__info__(:compile))
+      assert is_list(Kernel.__info__(:attributes))
     end
   end
 
-  def empty_map, do: %{}
+  describe "@" do
+    test "setting attribute with do-block" do
+      exception =
+        catch_error(
+          defmodule UpcaseAttrSample do
+            @foo quote do
+              :ok
+            end
+          end
+        )
+
+      assert exception.message =~ "expected 0 or 1 argument for @foo, got 2"
+      assert exception.message =~ "You probably want to wrap the argument value in parentheses"
+    end
 
-  defmodule PipelineOp do
-    use ExUnit.Case, async: true
+    test "setting attribute with uppercase" do
+      message = "module attributes set via @ cannot start with an uppercase letter"
 
-    test "simple" do
-      assert [1, [2], 3] |> List.flatten == [1, 2, 3]
+      assert_raise ArgumentError, message, fn ->
+        defmodule UpcaseAttrSample do
+          @Upper
+        end
+      end
     end
 
-    test "nested pipelines" do
-      assert [1, [2], 3] |> List.flatten |> Enum.map(&(&1 * 2)) == [2, 4, 6]
+    test "matching attribute" do
+      assert_raise ArgumentError, ~r"invalid usage of module attributes", fn ->
+        defmodule MatchAttributeInModule do
+          @foo = 42
+        end
+      end
+
+      assert_raise ArgumentError, ~r"invalid usage of module attributes", fn ->
+        defmodule MatchAttributeInModule do
+          @foo 16
+          <<_::@foo>> = "ab"
+        end
+      end
+
+      assert_raise ArgumentError, ~r"invalid usage of module attributes", fn ->
+        defmodule MatchAttributeInModule do
+          @foo 16
+          <<_::size(@foo)>> = "ab"
+        end
+      end
     end
+  end
 
-    test "local call" do
-      assert [1, [2], 3] |> List.flatten |> local == [2, 4, 6]
+  describe "defdelegate" do
+    defdelegate my_flatten(list), to: List, as: :flatten
+
+    dynamic = :dynamic_flatten
+    defdelegate unquote(dynamic)(list), to: List, as: :flatten
+
+    test "dispatches to delegated functions" do
+      assert my_flatten([[1]]) == [1]
     end
 
-    test "pipeline with capture" do
-      assert Enum.map([1, 2, 3], &(&1 |> twice |> twice)) == [4, 8, 12]
+    test "with unquote" do
+      assert dynamic_flatten([[1]]) == [1]
     end
 
-    test "non-call" do
-      assert  1  |> (&(&1*2)).() == 2
-      assert [1] |> (&hd(&1)).() == 1
+    test "raises with non-variable arguments" do
+      assert_raise ArgumentError,
+                   "guards are not allowed in defdelegate/2, got: when is_list(term) or is_binary(term)",
+                   fn ->
+                     string = """
+                     defmodule IntDelegateWithGuards do
+                       defdelegate foo(term) when is_list(term) or is_binary(term), to: List
+                     end
+                     """
+
+                     Code.eval_string(string, [], __ENV__)
+                   end
+
+      msg = "defdelegate/2 only accepts function parameters, got: 1"
+
+      assert_raise ArgumentError, msg, fn ->
+        string = """
+        defmodule IntDelegate do
+          defdelegate foo(1), to: List
+        end
+        """
+
+        Code.eval_string(string, [], __ENV__)
+      end
 
-      import CompileAssertion
-      assert_compile_fail ArgumentError, "cannot pipe 1 into 2", "1 |> 2"
+      assert_raise ArgumentError, msg, fn ->
+        string = """
+        defmodule IntOptionDelegate do
+          defdelegate foo(1 \\\\ 1), to: List
+        end
+        """
+
+        Code.eval_string(string, [], __ENV__)
+      end
     end
 
-    defp twice(a), do: a * 2
+    test "raises when :to targeting the delegating module is given without the :as option" do
+      assert_raise ArgumentError,
+                   ~r/defdelegate function is calling itself, which will lead to an infinite loop. You should either change the value of the :to option or specify the :as option/,
+                   fn ->
+                     defmodule ImplAttributes do
+                       defdelegate foo(), to: __MODULE__
+                     end
+                   end
+    end
 
-    defp local(list) do
-      Enum.map(list, &(&1 * 2))
+    defdelegate my_reverse(list \\ []), to: :lists, as: :reverse
+    defdelegate my_get(map \\ %{}, key, default \\ ""), to: Map, as: :get
+
+    test "accepts variable with optional arguments" do
+      assert my_reverse() == []
+      assert my_reverse([1, 2, 3]) == [3, 2, 1]
+
+      assert my_get("foo") == ""
+      assert my_get(%{}, "foo") == ""
+      assert my_get(%{"foo" => "bar"}, "foo") == "bar"
+      assert my_get(%{}, "foo", "not_found") == "not_found"
     end
   end
 
-  defmodule IfScope do
-    use ExUnit.Case, async: true
+  describe "defmodule" do
+    test "expects atoms as module names" do
+      msg = ~r"invalid module name: 3"
 
-    test "variables on nested if" do
-      if true do
-        a = 1
-        if true do
-          b = 2
+      assert_raise ArgumentError, msg, fn ->
+        defmodule 1 + 2, do: :ok
+      end
+    end
+
+    test "does not accept special atoms as module names" do
+      special_atoms = [nil, true, false]
+
+      Enum.each(special_atoms, fn special_atom ->
+        msg = ~r"invalid module name: #{inspect(special_atom)}"
+
+        assert_raise ArgumentError, msg, fn ->
+          defmodule special_atom, do: :ok
         end
+      end)
+    end
+
+    test "does not accept slashes in module names" do
+      assert_raise ArgumentError, ~r(invalid module name: :"foo/bar"), fn ->
+        defmodule :"foo/bar", do: :ok
       end
 
-      assert a == 1
-      assert b == 2
+      assert_raise ArgumentError, ~r(invalid module name: :"foo\\\\bar"), fn ->
+        defmodule :"foo\\bar", do: :ok
+      end
     end
+  end
 
-    test "variables on sibling if" do
-      if true do
-        a = 1
+  describe "access" do
+    defmodule StructAccess do
+      defstruct [:foo, :bar]
+    end
 
-        if true do
-          b = 2
-        end
+    test "get_in/1" do
+      users = %{"john" => %{age: 27}, :meg => %{age: 23}}
+      assert get_in(users["john"][:age]) == 27
+      assert get_in(users["dave"][:age]) == nil
+      assert get_in(users["john"].age) == 27
+      assert get_in(users["dave"].age) == nil
+      assert get_in(users.meg[:age]) == 23
+      assert get_in(users.meg.age) == 23
 
-        if true do
-          c = 3
-        end
+      is_nil = nil
+      assert get_in(is_nil.age) == nil
+
+      assert_raise KeyError, ~r"key :unknown not found", fn -> get_in(users.unknown) end
+      assert_raise KeyError, ~r"key :unknown not found", fn -> get_in(users.meg.unknown) end
+    end
+
+    test "get_in/2" do
+      users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+      assert get_in(users, ["john", :age]) == 27
+      assert get_in(users, ["dave", :age]) == nil
+      assert get_in(nil, ["john", :age]) == nil
+
+      map = %{"fruits" => ["banana", "apple", "orange"]}
+      assert get_in(map, ["fruits", by_index(0)]) == "banana"
+      assert get_in(map, ["fruits", by_index(3)]) == nil
+      assert get_in(map, ["unknown", by_index(3)]) == nil
+    end
+
+    test "put_in/3" do
+      users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+
+      assert put_in(users, ["john", :age], 28) == %{"john" => %{age: 28}, "meg" => %{age: 23}}
+
+      assert_raise ArgumentError, "could not put/update key \"john\" on a nil value", fn ->
+        put_in(nil, ["john", :age], 28)
       end
+    end
 
-      assert a == 1
-      assert b == 2
-      assert c == 3
+    test "put_in/2" do
+      users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+
+      assert put_in(users["john"][:age], 28) == %{"john" => %{age: 28}, "meg" => %{age: 23}}
+
+      assert put_in(users["john"].age, 28) == %{"john" => %{age: 28}, "meg" => %{age: 23}}
+
+      struct = %StructAccess{foo: %StructAccess{}}
+
+      assert put_in(struct.foo.bar, :baz) ==
+               %StructAccess{bar: nil, foo: %StructAccess{bar: :baz, foo: nil}}
+
+      assert_raise BadMapError, fn ->
+        put_in(users["dave"].age, 19)
+      end
+
+      assert_raise KeyError, fn ->
+        put_in(users["meg"].unknown, "value")
+      end
+    end
+
+    test "update_in/3" do
+      users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+
+      assert update_in(users, ["john", :age], &(&1 + 1)) ==
+               %{"john" => %{age: 28}, "meg" => %{age: 23}}
+
+      assert_raise ArgumentError, "could not put/update key \"john\" on a nil value", fn ->
+        update_in(nil, ["john", :age], fn _ -> %{} end)
+      end
+
+      assert_raise UndefinedFunctionError, fn ->
+        pop_in(struct(Sample, []), [:name])
+      end
+    end
+
+    test "update_in/2" do
+      users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+
+      assert update_in(users["john"][:age], &(&1 + 1)) ==
+               %{"john" => %{age: 28}, "meg" => %{age: 23}}
+
+      assert update_in(users["john"].age, &(&1 + 1)) ==
+               %{"john" => %{age: 28}, "meg" => %{age: 23}}
+
+      struct = %StructAccess{foo: %StructAccess{bar: 41}}
+
+      assert update_in(struct.foo.bar, &(&1 + 1)) ==
+               %StructAccess{bar: nil, foo: %StructAccess{bar: 42, foo: nil}}
+
+      assert_raise BadMapError, fn ->
+        update_in(users["dave"].age, &(&1 + 1))
+      end
+
+      assert_raise KeyError, fn ->
+        put_in(users["meg"].unknown, &(&1 + 1))
+      end
+    end
+
+    test "get_and_update_in/3" do
+      users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+
+      assert get_and_update_in(users, ["john", :age], &{&1, &1 + 1}) ==
+               {27, %{"john" => %{age: 28}, "meg" => %{age: 23}}}
+
+      map = %{"fruits" => ["banana", "apple", "orange"]}
+
+      assert get_and_update_in(map, ["fruits", by_index(0)], &{&1, String.reverse(&1)}) ==
+               {"banana", %{"fruits" => ["ananab", "apple", "orange"]}}
+
+      assert get_and_update_in(map, ["fruits", by_index(3)], &{&1, &1}) ==
+               {nil, %{"fruits" => ["banana", "apple", "orange"]}}
+
+      assert get_and_update_in(map, ["unknown", by_index(3)], &{&1, []}) ==
+               {:oops, %{"fruits" => ["banana", "apple", "orange"], "unknown" => []}}
     end
 
-    test "variables counter on nested ifs" do
-      r = (fn() -> 3 end).() # supresses warning at (if r < 0...)
-      r = r - 1
-      r = r - 1
-      r = r - 1
+    test "get_and_update_in/2" do
+      users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+
+      assert get_and_update_in(users["john"].age, &{&1, &1 + 1}) ==
+               {27, %{"john" => %{age: 28}, "meg" => %{age: 23}}}
+
+      struct = %StructAccess{foo: %StructAccess{bar: 41}}
+
+      assert get_and_update_in(struct.foo.bar, &{&1, &1 + 1}) ==
+               {41, %StructAccess{bar: nil, foo: %StructAccess{bar: 42, foo: nil}}}
+
+      assert_raise ArgumentError, "could not put/update key \"john\" on a nil value", fn ->
+        get_and_update_in(nil["john"][:age], fn nil -> {:ok, 28} end)
+      end
+
+      assert_raise BadMapError, fn ->
+        get_and_update_in(users["dave"].age, &{&1, &1 + 1})
+      end
 
-      if true do
-        r = r - 1
-        if r < 0, do: r = 0
+      assert_raise KeyError, fn ->
+        get_and_update_in(users["meg"].unknown, &{&1, &1 + 1})
       end
+    end
+
+    test "pop_in/2" do
+      users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+
+      assert pop_in(users, ["john", :age]) ==
+               {27, %{"john" => %{}, "meg" => %{age: 23}}}
+
+      assert pop_in(users, ["bob", :age]) ==
+               {nil, %{"john" => %{age: 27}, "meg" => %{age: 23}}}
+
+      assert pop_in([], [:foo, :bar]) ==
+               {nil, []}
+    end
+
+    test "pop_in/2 with paths" do
+      map = %{"fruits" => ["banana", "apple", "orange"]}
+
+      assert pop_in(map, ["fruits", by_index(0)]) ==
+               {"banana", %{"fruits" => ["apple", "orange"]}}
+
+      assert pop_in(map, ["fruits", by_index(3)]) == {nil, map}
+
+      map = %{"fruits" => [%{name: "banana"}, %{name: "apple"}]}
+
+      assert pop_in(map, ["fruits", by_index(0), :name]) ==
+               {"banana", %{"fruits" => [%{}, %{name: "apple"}]}}
+
+      assert pop_in(map, ["fruits", by_index(3), :name]) == {nil, map}
+    end
+
+    test "pop_in/1" do
+      users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
+
+      assert pop_in(users["john"]) == {%{age: 27}, %{"meg" => %{age: 23}}}
+
+      assert pop_in(users["john"][:age]) == {27, %{"john" => %{}, "meg" => %{age: 23}}}
+      assert pop_in(users["john"][:name]) == {nil, %{"john" => %{age: 27}, "meg" => %{age: 23}}}
+      assert pop_in(users["bob"][:age]) == {nil, %{"john" => %{age: 27}, "meg" => %{age: 23}}}
+
+      users = %{john: [age: 27], meg: [age: 23]}
+
+      assert pop_in(users.john[:age]) == {27, %{john: [], meg: [age: 23]}}
+      assert pop_in(users.john[:name]) == {nil, %{john: [age: 27], meg: [age: 23]}}
 
-      assert r == 0
+      assert pop_in([][:foo][:bar]) == {nil, []}
+      assert_raise KeyError, fn -> pop_in(users.bob[:age]) end
+    end
+
+    test "pop_in/1,2 with nils" do
+      users = %{"john" => nil, "meg" => %{age: 23}}
+      assert pop_in(users["john"][:age]) == {nil, %{"meg" => %{age: 23}}}
+      assert pop_in(users, ["john", :age]) == {nil, %{"meg" => %{age: 23}}}
+
+      users = %{john: nil, meg: %{age: 23}}
+      assert pop_in(users.john[:age]) == {nil, %{john: nil, meg: %{age: 23}}}
+      assert pop_in(users, [:john, :age]) == {nil, %{meg: %{age: 23}}}
+
+      x = nil
+      assert_raise ArgumentError, fn -> pop_in(x["john"][:age]) end
+      assert_raise ArgumentError, fn -> pop_in(nil["john"][:age]) end
+      assert_raise ArgumentError, fn -> pop_in(nil, ["john", :age]) end
+    end
+
+    test "with dynamic paths" do
+      map = empty_map()
+
+      assert put_in(map[:foo], "bar") == %{foo: "bar"}
+      assert put_in(empty_map()[:foo], "bar") == %{foo: "bar"}
+      assert put_in(KernelTest.empty_map()[:foo], "bar") == %{foo: "bar"}
+      assert put_in(__MODULE__.empty_map()[:foo], "bar") == %{foo: "bar"}
+
+      assert_raise ArgumentError, ~r"access at least one element,", fn ->
+        Code.eval_quoted(quote(do: put_in(map, "bar")), [])
+      end
+
+      assert_raise ArgumentError, ~r"must start with a variable, local or remote call", fn ->
+        Code.eval_quoted(quote(do: put_in(map.foo(1, 2)[:bar], "baz")), [])
+      end
+    end
+
+    def by_index(index) do
+      fn
+        :get, nil, _next ->
+          raise "won't be invoked"
+
+        :get, data, next ->
+          next.(Enum.at(data, index))
+
+        :get_and_update, nil, next ->
+          next.(:oops)
+
+        :get_and_update, data, next ->
+          current = Enum.at(data, index)
+
+          case next.(current) do
+            {get, update} -> {get, List.replace_at(data, index, update)}
+            :pop -> {current, List.delete_at(data, index)}
+          end
+      end
     end
   end
 
-  defmodule Destructure do
-    use ExUnit.Case, async: true
+  describe "pipeline" do
+    test "simple" do
+      assert [1, [2], 3] |> List.flatten() == [1, 2, 3]
+    end
+
+    test "nested" do
+      assert [1, [2], 3] |> List.flatten() |> Enum.map(&(&1 * 2)) == [2, 4, 6]
+    end
+
+    test "local call" do
+      assert [1, [2], 3] |> List.flatten() |> local() == [2, 4, 6]
+    end
+
+    test "with capture" do
+      assert Enum.map([1, 2, 3], &(&1 |> twice() |> twice())) == [4, 8, 12]
+    end
+
+    test "with anonymous functions" do
+      assert 1 |> (&(&1 * 2)).() == 2
+      assert [1] |> (&hd(&1)).() == 1
+    end
+
+    test "reverse associativity" do
+      assert [1, [2], 3] |> (List.flatten() |> Enum.map(&(&1 * 2))) == [2, 4, 6]
+    end
+
+    defp twice(a), do: a * 2
+
+    defp local(list) do
+      Enum.map(list, &(&1 * 2))
+    end
+  end
 
+  describe "destructure" do
     test "less args" do
       destructure [x, y, z], [1, 2, 3, 4, 5]
       assert x == 1
@@ -451,7 +1284,7 @@ defmodule KernelTest do
     end
 
     test "nil values" do
-      destructure [a, b, c], a_nil
+      destructure [a, b, c], a_nil()
       assert a == nil
       assert b == nil
       assert c == nil
@@ -459,12 +1292,312 @@ defmodule KernelTest do
 
     test "invalid match" do
       a = List.first([3])
-      assert_raise CaseClauseError, fn ->
-        destructure [^a, _b, _c], a_list
+
+      assert_raise MatchError, fn ->
+        destructure [^a, _b, _c], a_list()
       end
     end
 
     defp a_list, do: [1, 2, 3]
     defp a_nil, do: nil
   end
+
+  describe "use/2" do
+    import ExUnit.CaptureIO
+
+    defmodule SampleA do
+      defmacro __using__(opts) do
+        prefix = Keyword.get(opts, :prefix, "")
+        IO.puts(prefix <> "A")
+      end
+    end
+
+    defmodule SampleB do
+      defmacro __using__(_) do
+        IO.puts("B")
+      end
+    end
+
+    test "invalid argument is literal" do
+      message = "invalid arguments for use, expected a compile time atom or alias, got: 42"
+
+      assert_raise ArgumentError, message, fn ->
+        Code.eval_string("use 42")
+      end
+    end
+
+    test "invalid argument is variable" do
+      message = "invalid arguments for use, expected a compile time atom or alias, got: variable"
+
+      assert_raise ArgumentError, message, fn ->
+        Code.eval_string("use variable")
+      end
+    end
+
+    test "multi-call" do
+      assert capture_io(fn ->
+               Code.eval_string("use KernelTest.{SampleA, SampleB,}", [], __ENV__)
+             end) == "A\nB\n"
+    end
+
+    test "multi-call with options" do
+      assert capture_io(fn ->
+               Code.eval_string(~S|use KernelTest.{SampleA}, prefix: "-"|, [], __ENV__)
+             end) == "-A\n"
+    end
+
+    test "multi-call with unquote" do
+      assert capture_io(fn ->
+               string = """
+               defmodule TestMod do
+                 def main() do
+                   use KernelTest.{SampleB, unquote(:SampleA)}
+                 end
+               end
+               """
+
+               Code.eval_string(string, [], __ENV__)
+             end) == "B\nA\n"
+    after
+      purge(KernelTest.TestMod)
+    end
+  end
+
+  test "is_map_key/2" do
+    assert is_map_key(Map.new([]), :a) == false
+    assert is_map_key(Map.new(b: 1), :a) == false
+    assert is_map_key(Map.new(a: 1), :a) == true
+
+    assert_raise BadMapError, fn ->
+      is_map_key(Process.get(:unused, []), :a)
+    end
+
+    case Map.new(a: 1) do
+      map when is_map_key(map, :a) -> true
+      _ -> flunk("invalid guard")
+    end
+  end
+
+  test "tap/1" do
+    import ExUnit.CaptureIO
+
+    assert capture_io(fn ->
+             tap("foo", &IO.puts/1)
+           end) == "foo\n"
+
+    assert 1 = tap(1, fn x -> x + 1 end)
+  end
+
+  test "tl/1" do
+    assert tl([:one]) == []
+    assert tl([1, 2, 3]) == [2, 3]
+    assert_raise ArgumentError, fn -> tl(Process.get(:unused, [])) end
+
+    assert tl([:a | :b]) == :b
+    assert tl([:a, :b | :c]) == [:b | :c]
+  end
+
+  test "hd/1" do
+    assert hd([1, 2, 3, 4]) == 1
+    assert_raise ArgumentError, fn -> hd(Process.get(:unused, [])) end
+    assert hd([1 | 2]) == 1
+  end
+
+  test "floor/1" do
+    assert floor(1) === 1
+    assert floor(1.0) === 1
+    assert floor(0) === 0
+    assert floor(0.0) === 0
+    assert floor(-0.0) === 0
+    assert floor(1.123) === 1
+    assert floor(-10.123) === -11
+    assert floor(-10) === -10
+    assert floor(-10.0) === -10
+
+    assert match?(x when floor(x) == 0, 0.2)
+  end
+
+  test "ceil/1" do
+    assert ceil(1) === 1
+    assert ceil(1.0) === 1
+    assert ceil(0) === 0
+    assert ceil(0.0) === 0
+    assert ceil(-0.0) === 0
+    assert ceil(1.123) === 2
+    assert ceil(-10.123) === -10
+    assert ceil(-10) === -10
+    assert ceil(-10.0) === -10
+
+    assert match?(x when ceil(x) == 1, 0.2)
+  end
+
+  test "binary_slice/2" do
+    assert binary_slice("abc", -1..0) == ""
+    assert binary_slice("abc", -5..-5) == ""
+    assert binary_slice("x", 0..0//2) == "x"
+    assert binary_slice("abcde", 1..3//2) == "bd"
+  end
+
+  test "sigil_U/2" do
+    assert ~U[2015-01-13 13:00:07.123Z] == %DateTime{
+             calendar: Calendar.ISO,
+             day: 13,
+             hour: 13,
+             microsecond: {123_000, 3},
+             minute: 0,
+             month: 1,
+             second: 7,
+             std_offset: 0,
+             time_zone: "Etc/UTC",
+             utc_offset: 0,
+             year: 2015,
+             zone_abbr: "UTC"
+           }
+
+    assert_raise ArgumentError, ~r"reason: :invalid_format", fn ->
+      Code.eval_string(~s{~U[2015-01-13 13:00]})
+    end
+
+    assert_raise ArgumentError, ~r"reason: :invalid_format", fn ->
+      Code.eval_string(~s{~U[20150113 130007Z]})
+    end
+
+    assert_raise ArgumentError, ~r"reason: :missing_offset", fn ->
+      Code.eval_string(~s{~U[2015-01-13 13:00:07]})
+    end
+
+    assert_raise ArgumentError, ~r"reason: :non_utc_offset", fn ->
+      Code.eval_string(~s{~U[2015-01-13 13:00:07+00:30]})
+    end
+  end
+
+  describe "dbg/2" do
+    import ExUnit.CaptureIO
+
+    test "prints the given expression and returns its value" do
+      output = capture_io(fn -> assert dbg(List.duplicate(:foo, 3)) == [:foo, :foo, :foo] end)
+      assert output =~ "kernel_test.exs"
+      assert output =~ "KernelTest"
+      assert output =~ "List"
+      assert output =~ "duplicate"
+      assert output =~ ":foo"
+      assert output =~ "3"
+    end
+
+    test "prints the given expression with complex options" do
+      output = capture_io(fn -> assert dbg(123, [] ++ []) == 123 end)
+      assert output =~ "kernel_test.exs"
+    end
+
+    test "doesn't print any colors if :syntax_colors is []" do
+      output =
+        capture_io(fn ->
+          assert dbg(List.duplicate(:foo, 3), syntax_colors: []) == [:foo, :foo, :foo]
+        end)
+
+      assert output =~ "kernel_test.exs"
+      assert output =~ "KernelTest."
+      assert output =~ "List.duplicate(:foo, 3)"
+      assert output =~ "[:foo, :foo, :foo]"
+      refute output =~ "\\e["
+    end
+
+    test "prints binding() if no arguments are given" do
+      my_var = 1
+      my_other_var = :foo
+
+      output = capture_io(fn -> dbg() end)
+
+      assert output =~ "binding()"
+      assert output =~ "my_var:"
+      assert output =~ "my_other_var:"
+    end
+
+    test "is not allowed in guards" do
+      message = "invalid expression in guard, dbg is not allowed in guards"
+
+      assert_raise ArgumentError, Regex.compile!(message), fn ->
+        defmodule DbgGuard do
+          def dbg_guard() when dbg(1), do: true
+        end
+      end
+    end
+
+    test "is not allowed in pattern matches" do
+      message = "invalid expression in match, dbg is not allowed in patterns"
+
+      assert_eval_raise(ArgumentError, Regex.compile!(message), """
+      {:ok, dbg()} = make_ref()
+      """)
+    end
+  end
+
+  describe "to_timeout/1" do
+    test "works with keyword lists" do
+      assert to_timeout(hour: 2) == 1000 * 60 * 60 * 2
+      assert to_timeout(minute: 74) == 1000 * 60 * 74
+      assert to_timeout(second: 1293) == 1_293_000
+      assert to_timeout(millisecond: 1_234_123) == 1_234_123
+
+      assert to_timeout(hour: 2, minute: 30) == 1000 * 60 * 60 * 2 + 1000 * 60 * 30
+      assert to_timeout(minute: 30, hour: 2) == 1000 * 60 * 60 * 2 + 1000 * 60 * 30
+      assert to_timeout(minute: 74, second: 30) == 1000 * 60 * 74 + 1000 * 30
+    end
+
+    test "raises on invalid values with keyword lists" do
+      for unit <- [:hour, :minute, :second, :millisecond],
+          value <- [-1, 1.0, :not_an_int] do
+        message =
+          "timeout component #{inspect(unit)} must be a non-negative integer, " <>
+            "got: #{inspect(value)}"
+
+        assert_raise ArgumentError, message, fn -> to_timeout([{unit, value}]) end
+      end
+    end
+
+    test "raises on invalid keys with keyword lists" do
+      message =
+        "timeout component :not_a_unit is not a valid timeout component, valid values are: " <>
+          ":week, :day, :hour, :minute, :second, :millisecond"
+
+      assert_raise ArgumentError, message, fn -> to_timeout(minute: 3, not_a_unit: 1) end
+    end
+
+    test "raises on duplicated components with keyword lists" do
+      assert_raise ArgumentError, "timeout component :minute is duplicated", fn ->
+        to_timeout(minute: 3, hour: 2, minute: 1)
+      end
+    end
+
+    test "works with durations" do
+      assert to_timeout(Duration.new!(hour: 2)) == 1000 * 60 * 60 * 2
+      assert to_timeout(Duration.new!(minute: 74)) == 1000 * 60 * 74
+      assert to_timeout(Duration.new!(second: 1293)) == 1_293_000
+      assert to_timeout(Duration.new!(microsecond: {1_234_123, 4})) == 1_234
+
+      assert to_timeout(Duration.new!(hour: 2, minute: 30)) == 1000 * 60 * 60 * 2 + 1000 * 60 * 30
+      assert to_timeout(Duration.new!(minute: 30, hour: 2)) == 1000 * 60 * 60 * 2 + 1000 * 60 * 30
+      assert to_timeout(Duration.new!(minute: 74, second: 30)) == 1000 * 60 * 74 + 1000 * 30
+    end
+
+    test "raises on durations with non-zero months or days" do
+      message = "duration with a non-zero month cannot be reliably converted to timeouts"
+
+      assert_raise ArgumentError, message, fn ->
+        to_timeout(Duration.new!(month: 3))
+      end
+
+      message = "duration with a non-zero year cannot be reliably converted to timeouts"
+
+      assert_raise ArgumentError, message, fn ->
+        to_timeout(Duration.new!(year: 1))
+      end
+    end
+
+    test "works with timeouts" do
+      assert to_timeout(1_000) == 1_000
+      assert to_timeout(0) == 0
+      assert to_timeout(:infinity) == :infinity
+    end
+  end
 end
diff --git a/lib/elixir/test/elixir/keyword_test.exs b/lib/elixir/test/elixir/keyword_test.exs
index 4387b6026e3..2a133886cf3 100644
--- a/lib/elixir/test/elixir/keyword_test.exs
+++ b/lib/elixir/test/elixir/keyword_test.exs
@@ -1,8 +1,14 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule KeywordTest do
   use ExUnit.Case, async: true
 
+  doctest Keyword
+
   test "has a literal syntax" do
     assert [B: 1] == [{:B, 1}]
     assert [foo?: :bar] == [{:foo?, :bar}]
@@ -11,238 +17,229 @@ defmodule KeywordTest do
   end
 
   test "is a :: operator on ambiguity" do
-    assert [{:::, _, [{:a, _, _}, {:b, _, _}]}] = quote(do: [a::b])
+    assert [{:"::", _, [{:a, _, _}, {:b, _, _}]}] = quote(do: [a :: b])
   end
 
   test "supports optional comma" do
-    [a: 1,
-     b: 2,
-     c: 3, ]
+    assert Code.eval_string("[a: 1, b: 2, c: 3,]") == {[a: 1, b: 2, c: 3], []}
   end
 
-  test "keyword?/1" do
-    assert Keyword.keyword?([])
-    assert Keyword.keyword?([a: 1])
-    assert Keyword.keyword?([{Foo, 1}])
-    refute Keyword.keyword?([{}])
-    refute Keyword.keyword?(<<>>)
+  test "implements (almost) all functions in Map" do
+    assert Map.__info__(:functions) -- Keyword.__info__(:functions) == [from_struct: 1]
   end
 
-  test "new/0" do
-    assert Keyword.new == []
+  test "get_and_update/3 removes duplicates from the input keyword list" do
+    assert Keyword.get_and_update([a: 1, b: 2, a: 3], :a, fn value -> {value, value + 10} end) ==
+             {1, [a: 11, b: 2]}
   end
 
-  test "new/1" do
-    assert Keyword.new([{:second_key, 2}, {:first_key, 1}]) ==
-           [first_key: 1, second_key: 2]
-  end
+  test "get_and_update/3 raises on bad return value from the argument function" do
+    message = "the given function must return a two-element tuple or :pop, got: 1"
 
-  test "new/2" do
-    assert Keyword.new([:a, :b], fn x -> {x, x} end) ==
-           [b: :b, a: :a]
-  end
-
-  test "get/2 and get/3" do
-    assert Keyword.get(create_keywords, :first_key) == 1
-    assert Keyword.get(create_keywords, :second_key) == 2
-    assert Keyword.get(create_keywords, :other_key) == nil
-    assert Keyword.get(create_empty_keywords, :first_key, "default") == "default"
-  end
+    assert_raise RuntimeError, message, fn ->
+      Keyword.get_and_update([a: 1], :a, fn value -> value end)
+    end
 
-  test "fetch!/2" do
-    assert Keyword.fetch!(create_keywords, :first_key) == 1
+    message = "the given function must return a two-element tuple or :pop, got: nil"
 
-    error = assert_raise KeyError, fn ->
-      Keyword.fetch!(create_keywords, :unknown)
+    assert_raise RuntimeError, message, fn ->
+      Keyword.get_and_update([], :a, fn value -> value end)
     end
+  end
 
-    assert error.key == :unknown
+  test "get_and_update!/3 removes duplicates from the input keyword list" do
+    assert Keyword.get_and_update!([a: 1, b: 2, a: 3], :a, fn value -> {value, value + 10} end) ==
+             {1, [a: 11, b: 2]}
   end
 
-  test "keys/1" do
-    assert Keyword.keys(create_keywords) == [:first_key, :second_key]
-    assert Keyword.keys(create_empty_keywords) == []
+  test "get_and_update!/3 raises on bad return value from the argument function" do
+    message = "the given function must return a two-element tuple or :pop, got: 1"
 
-    assert_raise FunctionClauseError, fn ->
-      Keyword.keys([:foo])
+    assert_raise RuntimeError, message, fn ->
+      Keyword.get_and_update!([a: 1], :a, fn value -> value end)
     end
   end
 
-  test "values/1" do
-    assert Keyword.values(create_keywords) == [1, 2]
-    assert Keyword.values(create_empty_keywords) == []
+  test "update!" do
+    assert Keyword.update!([a: 1, b: 2, a: 3], :a, &(&1 * 2)) == [a: 2, b: 2]
+    assert Keyword.update!([a: 1, b: 2, c: 3], :b, &(&1 * 2)) == [a: 1, b: 4, c: 3]
+  end
 
-    assert_raise FunctionClauseError, fn ->
-      Keyword.values([:foo])
-    end
+  test "replace" do
+    assert Keyword.replace([a: 1, b: 2, a: 3], :a, :new) == [a: :new, b: 2]
+    assert Keyword.replace([a: 1, b: 2, a: 3], :a, 1) == [a: 1, b: 2]
+    assert Keyword.replace([a: 1, b: 2, a: 3, b: 4], :a, 1) == [a: 1, b: 2, b: 4]
+    assert Keyword.replace([a: 1, b: 2, c: 3, b: 4], :b, :new) == [a: 1, b: :new, c: 3]
+    assert Keyword.replace([], :b, :new) == []
+    assert Keyword.replace([a: 1, b: 2, a: 3], :c, :new) == [a: 1, b: 2, a: 3]
   end
 
-  test "delete/2" do
-    assert Keyword.delete(create_keywords, :second_key) == [first_key: 1]
-    assert Keyword.delete(create_keywords, :other_key) == [first_key: 1, second_key: 2]
-    assert Keyword.delete(create_empty_keywords, :other_key) == []
+  test "replace!" do
+    assert Keyword.replace!([a: 1, b: 2, a: 3], :a, :new) == [a: :new, b: 2]
+    assert Keyword.replace!([a: 1, b: 2, a: 3], :a, 1) == [a: 1, b: 2]
+    assert Keyword.replace!([a: 1, b: 2, a: 3, b: 4], :a, 1) == [a: 1, b: 2, b: 4]
+    assert Keyword.replace!([a: 1, b: 2, c: 3, b: 4], :b, :new) == [a: 1, b: :new, c: 3]
 
-    assert_raise FunctionClauseError, fn ->
-      Keyword.delete([:foo], :foo)
+    assert_raise KeyError, "key :b not found in:\n\n    []\n", fn ->
+      Keyword.replace!([], :b, :new)
     end
-  end
-
-  test "delete/3" do
-    keywords = [a: 1, b: 2, c: 3, a: 2]
-    assert Keyword.delete(keywords, :a, 2) == [a: 1, b: 2, c: 3]
-    assert Keyword.delete(keywords, :a, 1) == [b: 2, c: 3, a: 2]
 
-    assert_raise FunctionClauseError, fn ->
-      Keyword.delete([:foo], :foo, 0)
+    assert_raise KeyError, "key :c not found in:\n\n    [a: 1, b: 2, a: 3]\n", fn ->
+      Keyword.replace!([a: 1, b: 2, a: 3], :c, :new)
     end
   end
 
-  test "put/3" do
-    assert Keyword.put(create_empty_keywords, :first_key, 1) == [first_key: 1]
-    assert Keyword.put(create_keywords, :first_key, 3) == [first_key: 3, second_key: 2]
-  end
+  test "merge/2" do
+    assert Keyword.merge([a: 1, b: 2], c: 11, d: 12) == [a: 1, b: 2, c: 11, d: 12]
+    assert Keyword.merge([], c: 11, d: 12) == [c: 11, d: 12]
+    assert Keyword.merge([a: 1, b: 2], []) == [a: 1, b: 2]
 
-  test "put_new/3" do
-    assert Keyword.put_new(create_empty_keywords, :first_key, 1) == [first_key: 1]
-    assert Keyword.put_new(create_keywords, :first_key, 3) == [first_key: 1, second_key: 2]
-  end
+    message = "expected a keyword list as the first argument, got: [1, 2]"
 
-  test "merge/2" do
-    assert Keyword.merge(create_empty_keywords, create_keywords) == [first_key: 1, second_key: 2]
-    assert Keyword.merge(create_keywords, create_empty_keywords) == [first_key: 1, second_key: 2]
-    assert Keyword.merge(create_keywords, create_keywords) == [first_key: 1, second_key: 2]
-    assert Keyword.merge(create_empty_keywords, create_empty_keywords) == []
+    assert_raise ArgumentError, message, fn ->
+      Keyword.merge([1, 2], c: 11, d: 12)
+    end
 
-    assert_raise FunctionClauseError, fn ->
-      Keyword.delete([:foo], [:foo])
+    message = "expected a keyword list as the first argument, got: [1 | 2]"
+
+    assert_raise ArgumentError, message, fn ->
+      Keyword.merge([1 | 2], c: 11, d: 12)
     end
-  end
 
-  test "merge/3" do
-    result = Keyword.merge [a: 1, b: 2], [a: 3, d: 4], fn _k, v1, v2 ->
-      v1 + v2
+    message = "expected a keyword list as the second argument, got: [11, 12, 0]"
+
+    assert_raise ArgumentError, message, fn ->
+      Keyword.merge([a: 1, b: 2], [11, 12, 0])
     end
-    assert result == [a: 4, b: 2, d: 4]
-  end
 
-  test "has_key?/2" do
-    assert Keyword.has_key?([a: 1], :a) == true
-    assert Keyword.has_key?([a: 1], :b) == false
-  end
+    message = "expected a keyword list as the second argument, got: [11 | 12]"
 
-  test "update!/3" do
-    kw = [a: 1, b: 2, a: 3]
-    assert Keyword.update!(kw, :a, &(&1 * 2)) == [a: 2, b: 2]
-    assert_raise KeyError, fn ->
-      Keyword.update!([a: 1], :b, &(&1 * 2))
+    assert_raise ArgumentError, message, fn ->
+      Keyword.merge([a: 1, b: 2], [11 | 12])
     end
-  end
 
-  test "update/4" do
-    kw = [a: 1, b: 2, a: 3]
-    assert Keyword.update(kw, :a, 13, &(&1 * 2)) == [a: 2, b: 2]
-    assert Keyword.update([a: 1], :b, 11, &(&1 * 2)) == [a: 1, b: 11]
-  end
+    # duplicate keys in keywords1 are kept if key is not present in keywords2
+    result = [a: 1, b: 2, a: 3, c: 11, d: 12]
+    assert Keyword.merge([a: 1, b: 2, a: 3], c: 11, d: 12) == result
 
-  defp create_empty_keywords, do: []
-  defp create_keywords, do: [first_key: 1, second_key: 2]
-end
+    result = [b: 2, a: 11]
+    assert Keyword.merge([a: 1, b: 2, a: 3], a: 11) == result
 
-defmodule Keyword.DuplicatedTest do
-  use ExUnit.Case, async: true
+    # duplicate keys in keywords2 are always kept
+    result = [a: 1, b: 2, c: 11, c: 12, d: 13]
+    assert Keyword.merge([a: 1, b: 2], c: 11, c: 12, d: 13) == result
 
-  test "get/2" do
-    assert Keyword.get(create_keywords, :first_key) == 1
-    assert Keyword.get(create_keywords, :second_key) == 2
-    assert Keyword.get(create_keywords, :other_key) == nil
-    assert Keyword.get(create_empty_keywords, :first_key, "default") == "default"
+    # any key in keywords1 is removed if key is present in keyword2
+    result = [a: 1, b: 2, c: 11, c: 12, d: 13]
+    assert Keyword.merge([a: 1, b: 2, c: 3, c: 4], c: 11, c: 12, d: 13) == result
   end
 
-  test "get_values/2" do
-    assert Keyword.get_values(create_keywords, :first_key) == [1, 2]
-    assert Keyword.get_values(create_keywords, :second_key) == [2]
-    assert Keyword.get_values(create_keywords, :other_key) == []
+  test "merge/3" do
+    fun = fn _key, value1, value2 -> value1 + value2 end
 
-    assert_raise FunctionClauseError, fn ->
-      Keyword.get_values([:foo], :foo)
-    end
-  end
+    assert Keyword.merge([a: 1, b: 2], [c: 11, d: 12], fun) == [a: 1, b: 2, c: 11, d: 12]
+    assert Keyword.merge([], [c: 11, d: 12], fun) == [c: 11, d: 12]
+    assert Keyword.merge([a: 1, b: 2], [], fun) == [a: 1, b: 2]
 
-  test "keys/1" do
-    assert Keyword.keys(create_keywords) == [:first_key, :first_key, :second_key]
-    assert Keyword.keys(create_empty_keywords) == []
-  end
+    message = "expected a keyword list as the first argument, got: [1, 2]"
 
-  test "equal?/2" do
-    assert Keyword.equal? [a: 1, b: 2], [b: 2, a: 1]
-    refute Keyword.equal? [a: 1, b: 2], [b: 2, c: 3]
-  end
+    assert_raise ArgumentError, message, fn ->
+      Keyword.merge([1, 2], [c: 11, d: 12], fun)
+    end
 
-  test "values/1" do
-    assert Keyword.values(create_keywords) == [1, 2, 2]
-    assert Keyword.values(create_empty_keywords) == []
-  end
+    message = "expected a keyword list as the first argument, got: [1 | 2]"
 
-  test "delete/2" do
-    assert Keyword.delete(create_keywords, :first_key) == [second_key: 2]
-    assert Keyword.delete(create_keywords, :other_key) == create_keywords
-    assert Keyword.delete(create_empty_keywords, :other_key) == []
-  end
+    assert_raise ArgumentError, message, fn ->
+      Keyword.merge([1 | 2], [c: 11, d: 12], fun)
+    end
 
-  test "delete_first/2" do
-    assert Keyword.delete_first(create_keywords, :first_key) == [first_key: 2, second_key: 2]
-    assert Keyword.delete_first(create_keywords, :other_key) == [first_key: 1, first_key: 2, second_key: 2]
-    assert Keyword.delete_first(create_empty_keywords, :other_key) == []
-  end
+    message = "expected a keyword list as the second argument, got: [{:x, 1}, :y, :z]"
 
-  test "put/3" do
-    assert Keyword.put(create_empty_keywords, :first_key, 1) == [first_key: 1]
-    assert Keyword.put(create_keywords, :first_key, 1) == [first_key: 1, second_key: 2]
-  end
+    assert_raise ArgumentError, message, fn ->
+      Keyword.merge([a: 1, b: 2], [{:x, 1}, :y, :z], fun)
+    end
 
-  test "merge/2" do
-    assert Keyword.merge(create_empty_keywords, create_keywords) == create_keywords
-    assert Keyword.merge(create_keywords, create_empty_keywords) == create_keywords
-    assert Keyword.merge(create_keywords, create_keywords) == create_keywords
-    assert Keyword.merge(create_empty_keywords, create_empty_keywords) == []
-    assert Keyword.merge(create_keywords, [first_key: 0]) == [first_key: 0, second_key: 2]
-    assert Keyword.merge(create_keywords, [first_key: 0, first_key: 3]) == [first_key: 0, first_key: 3, second_key: 2]
-  end
+    message = "expected a keyword list as the second argument, got: [:x | :y]"
 
-  test "merge/3" do
-    result = Keyword.merge [a: 1, b: 2], [a: 3, d: 4], fn _k, v1, v2 ->
-      v1 + v2
+    assert_raise ArgumentError, message, fn ->
+      Keyword.merge([a: 1, b: 2], [:x | :y], fun)
     end
-    assert Keyword.equal?(result, [a: 4, b: 2, d: 4])
-  end
 
-  test "has_key?/2" do
-    assert Keyword.has_key?([a: 1], :a) == true
-    assert Keyword.has_key?([a: 1], :b) == false
-  end
+    message = "expected a keyword list as the second argument, got: [{:x, 1} | :y]"
 
-  test "take/2" do
-    assert Keyword.take([], []) == []
-    assert Keyword.take([a: 0, b: 1, a: 2], []) == []
-    assert Keyword.take([a: 0, b: 1, a: 2], [:a]) == [a: 0, a: 2]
-    assert Keyword.take([a: 0, b: 1, a: 2], [:b]) == [b: 1]
+    assert_raise ArgumentError, message, fn ->
+      Keyword.merge([a: 1, b: 2], [{:x, 1} | :y], fun)
+    end
 
-    assert_raise FunctionClauseError, fn ->
-      Keyword.take([:foo], [:foo])
+    # duplicate keys in keywords1 are left untouched if key is not present in keywords2
+    result = [a: 1, b: 2, a: 3, c: 11, d: 12]
+    assert Keyword.merge([a: 1, b: 2, a: 3], [c: 11, d: 12], fun) == result
+
+    result = [b: 2, a: 12]
+    assert Keyword.merge([a: 1, b: 2, a: 3], [a: 11], fun) == result
+
+    # duplicate keys in keywords2 are always kept
+    result = [a: 1, b: 2, c: 11, c: 12, d: 13]
+    assert Keyword.merge([a: 1, b: 2], [c: 11, c: 12, d: 13], fun) == result
+
+    # every key in keywords1 is replaced with fun result if key is present in keyword2
+    result = [a: 1, b: 2, c: 14, c: 54, d: 13]
+    assert Keyword.merge([a: 1, b: 2, c: 3, c: 4], [c: 11, c: 50, d: 13], fun) == result
+  end
+
+  test "merge/2 and merge/3 behave exactly the same way" do
+    fun = fn _key, _value1, value2 -> value2 end
+
+    args = [
+      {[a: 1, b: 2], [c: 11, d: 12]},
+      {[], [c: 11, d: 12]},
+      {[a: 1, b: 2], []},
+      {[a: 1, b: 2, a: 3], [c: 11, d: 12]},
+      {[a: 1, b: 2, a: 3], [a: 11]},
+      {[a: 1, b: 2], [c: 11, c: 12, d: 13]},
+      {[a: 1, b: 2, c: 3, c: 4], [c: 11, c: 12, d: 13]}
+    ]
+
+    args_error = [
+      {[1, 2], [c: 11, d: 12]},
+      {[1 | 2], [c: 11, d: 12]},
+      {[a: 1, b: 2], [11, 12, 0]},
+      {[a: 1, b: 2], [11 | 12]},
+      {[a: 1, b: 2], [{:x, 1}, :y, :z]},
+      {[a: 1, b: 2], [:x | :y]},
+      {[a: 1, b: 2], [{:x, 1} | :y]}
+    ]
+
+    for {arg1, arg2} <- args do
+      assert Keyword.merge(arg1, arg2) == Keyword.merge(arg1, arg2, fun)
+    end
+
+    for {arg1, arg2} <- args_error do
+      error = assert_raise ArgumentError, fn -> Keyword.merge(arg1, arg2) end
+      assert_raise ArgumentError, error.message, fn -> Keyword.merge(arg1, arg2, fun) end
     end
   end
 
-  test "drop/2" do
-    assert Keyword.drop([], []) == []
-    assert Keyword.drop([a: 0, b: 1, a: 2], []) == [a: 0, b: 1, a: 2]
-    assert Keyword.drop([a: 0, b: 1, a: 2], [:a]) == [b: 1]
-    assert Keyword.drop([a: 0, b: 1, a: 2], [:b]) == [a: 0, a: 2]
+  test "validate/2 raises on invalid arguments" do
+    assert_raise ArgumentError,
+                 "expected a keyword list as first argument, got invalid entry: :three",
+                 fn -> Keyword.validate([:three], one: 1, two: 2) end
 
-    assert_raise FunctionClauseError, fn ->
-      Keyword.drop([:foo], [:foo])
-    end
+    assert_raise ArgumentError,
+                 "expected the second argument to be a list of atoms or tuples, got: 3",
+                 fn -> Keyword.validate([three: 3], [:three, 3, :two]) end
   end
 
-  defp create_empty_keywords, do: []
-  defp create_keywords, do: [first_key: 1, first_key: 2, second_key: 2]
+  test "split_with/2" do
+    assert Keyword.split_with([], fn {_k, v} -> rem(v, 2) == 0 end) == {[], []}
+
+    assert Keyword.split_with([a: "1", a: 1, b: 2], fn {k, _v} -> k in [:a, :b] end) ==
+             {[a: "1", a: 1, b: 2], []}
+
+    assert Keyword.split_with([a: "1", a: 1, b: 2], fn {_k, v} -> v == 5 end) ==
+             {[], [a: "1", a: 1, b: 2]}
+
+    assert Keyword.split_with([a: "1", a: 1, b: 2], fn {k, v} -> k in [:a] and is_integer(v) end) ==
+             {[a: 1], [a: "1", b: 2]}
+  end
 end
diff --git a/lib/elixir/test/elixir/list/chars_test.exs b/lib/elixir/test/elixir/list/chars_test.exs
index 94389bddb95..311496fe919 100644
--- a/lib/elixir/test/elixir/list/chars_test.exs
+++ b/lib/elixir/test/elixir/list/chars_test.exs
@@ -1,37 +1,47 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule List.Chars.AtomTest do
   use ExUnit.Case, async: true
 
-  test :basic do
-    assert to_char_list(:foo) == 'foo'
+  test "basic" do
+    assert to_charlist(:foo) == ~c"foo"
+  end
+
+  test "true false nil" do
+    assert to_charlist(false) == ~c"false"
+    assert to_charlist(true) == ~c"true"
+    assert to_charlist(nil) == ~c""
   end
 end
 
 defmodule List.Chars.BitStringTest do
   use ExUnit.Case, async: true
 
-  test :basic do
-    assert to_char_list("foo") == 'foo'
+  test "basic" do
+    assert to_charlist("foo") == ~c"foo"
   end
 end
 
 defmodule List.Chars.NumberTest do
   use ExUnit.Case, async: true
 
-  test :integer do
-    assert to_char_list(1) == '1'
+  test "integer" do
+    assert to_charlist(1) == ~c"1"
   end
 
-  test :float do
-    assert to_char_list(1.0) == '1.0'
+  test "float" do
+    assert to_charlist(1.0) == ~c"1.0"
   end
 end
 
 defmodule List.Chars.ListTest do
   use ExUnit.Case, async: true
 
-  test :basic do
-    assert to_char_list([ 1, "b", 3 ]) == [1, "b", 3]
+  test "basic" do
+    assert to_charlist([1, "b", 3]) == [1, "b", 3]
   end
 end
diff --git a/lib/elixir/test/elixir/list_test.exs b/lib/elixir/test/elixir/list_test.exs
index 7da04556abc..2d1c283810d 100644
--- a/lib/elixir/test/elixir/list_test.exs
+++ b/lib/elixir/test/elixir/list_test.exs
@@ -1,121 +1,201 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule ListTest do
   use ExUnit.Case, async: true
 
-  test :cons_cell_precedence do
-    assert [1|:lists.flatten([2, 3])] == [1, 2, 3]
+  doctest List
+
+  test "cons cell precedence" do
+    assert [1 | List.flatten([2, 3])] == [1, 2, 3]
   end
 
-  test :optional_comma do
-    assert [1] == [ 1, ]
-    assert [1, 2, 3] == [1, 2, 3, ]
+  test "optional comma" do
+    assert Code.eval_string("[1,]") == {[1], []}
+    assert Code.eval_string("[1, 2, 3,]") == {[1, 2, 3], []}
   end
 
-  test :partial_application do
+  test "partial application" do
     assert (&[&1, 2]).(1) == [1, 2]
     assert (&[&1, &2]).(1, 2) == [1, 2]
     assert (&[&2, &1]).(2, 1) == [1, 2]
-    assert (&[&1|&2]).(1, 2) == [1|2]
-    assert (&[&1, &2|&3]).(1, 2, 3) == [1, 2|3]
+    assert (&[&1 | &2]).(1, 2) == [1 | 2]
+    assert (&[&1, &2 | &3]).(1, 2, 3) == [1, 2 | 3]
+  end
+
+  test "delete/2" do
+    assert List.delete([:a, :b, :c], :a) == [:b, :c]
+    assert List.delete([:a, :b, :c], :d) == [:a, :b, :c]
+    assert List.delete([:a, :b, :b, :c], :b) == [:a, :b, :c]
+    assert List.delete([], :b) == []
   end
 
-  test :wrap do
+  test "wrap/1" do
     assert List.wrap([1, 2, 3]) == [1, 2, 3]
     assert List.wrap(1) == [1]
     assert List.wrap(nil) == []
   end
 
-  test :flatten do
+  test "flatten/1" do
     assert List.flatten([1, 2, 3]) == [1, 2, 3]
     assert List.flatten([1, [2], 3]) == [1, 2, 3]
     assert List.flatten([[1, [2], 3]]) == [1, 2, 3]
 
     assert List.flatten([]) == []
     assert List.flatten([[]]) == []
+    assert List.flatten([[], [[], []]]) == []
   end
 
-  test :flatten_with_tail do
+  test "flatten/2" do
     assert List.flatten([1, 2, 3], [4, 5]) == [1, 2, 3, 4, 5]
     assert List.flatten([1, [2], 3], [4, 5]) == [1, 2, 3, 4, 5]
     assert List.flatten([[1, [2], 3]], [4, 5]) == [1, 2, 3, 4, 5]
+    assert List.flatten([1, [], 2], [3, [], 4]) == [1, 2, 3, [], 4]
   end
 
-  test :foldl do
+  test "foldl/3" do
     assert List.foldl([1, 2, 3], 0, fn x, y -> x + y end) == 6
     assert List.foldl([1, 2, 3], 10, fn x, y -> x + y end) == 16
     assert List.foldl([1, 2, 3, 4], 0, fn x, y -> x - y end) == 2
   end
 
-  test :foldr do
+  test "foldr/3" do
     assert List.foldr([1, 2, 3], 0, fn x, y -> x + y end) == 6
     assert List.foldr([1, 2, 3], 10, fn x, y -> x + y end) == 16
     assert List.foldr([1, 2, 3, 4], 0, fn x, y -> x - y end) == -2
   end
 
-  test :reverse do
-    assert Enum.reverse([1, 2, 3]) == [3, 2, 1]
-  end
-
-  test :duplicate do
+  test "duplicate/2" do
+    assert List.duplicate(1, 0) == []
     assert List.duplicate(1, 3) == [1, 1, 1]
     assert List.duplicate([1], 1) == [[1]]
   end
 
-  test :last do
+  test "first/1" do
+    assert List.first([]) == nil
+    assert List.first([], 1) == 1
+    assert List.first([1]) == 1
+    assert List.first([1, 2, 3]) == 1
+  end
+
+  test "last/1" do
     assert List.last([]) == nil
+    assert List.last([], 1) == 1
     assert List.last([1]) == 1
     assert List.last([1, 2, 3]) == 3
   end
 
-  test :zip do
-    assert List.zip([[1, 4], [2, 5], [3, 6]]) == [{1, 2, 3}, {4, 5, 6}]
-    assert List.zip([[1, 4], [2, 5, 0], [3, 6]]) == [{1, 2, 3}, {4, 5, 6}]
-    assert List.zip([[1], [2, 5], [3, 6]]) == [{1, 2, 3}]
-    assert List.zip([[1, 4], [2, 5], []]) == []
-  end
-
-  test :unzip do
-    assert List.unzip([{1, 2, 3}, {4, 5, 6}]) == [[1, 4], [2, 5], [3, 6]]
-    assert List.unzip([{1, 2, 3}, {4, 5}]) == [[1, 4], [2, 5]]
-    assert List.unzip([[1, 2, 3], [4, 5]]) == [[1, 4], [2, 5]]
-    assert List.unzip([]) == []
-  end
-
-  test :keyfind do
+  test "keyfind/4" do
     assert List.keyfind([a: 1, b: 2], :a, 0) == {:a, 1}
     assert List.keyfind([a: 1, b: 2], 2, 1) == {:b, 2}
     assert List.keyfind([a: 1, b: 2], :c, 0) == nil
   end
 
-  test :keyreplace do
+  test "keyreplace/4" do
     assert List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3}) == [a: 3, b: 2]
     assert List.keyreplace([a: 1], :b, 0, {:b, 2}) == [a: 1]
   end
 
-  test :keysort do
+  test "keysort/2" do
     assert List.keysort([a: 4, b: 3, c: 5], 1) == [b: 3, a: 4, c: 5]
     assert List.keysort([a: 4, c: 1, b: 2], 0) == [a: 4, b: 2, c: 1]
   end
 
-  test :keystore do
+  test "keysort/3 with stable sorting" do
+    collection = [
+      {2, 4},
+      {1, 5},
+      {2, 2},
+      {3, 1},
+      {4, 3}
+    ]
+
+    # Stable sorting
+    assert List.keysort(collection, 0) == [
+             {1, 5},
+             {2, 4},
+             {2, 2},
+             {3, 1},
+             {4, 3}
+           ]
+
+    assert List.keysort(collection, 0) ==
+             List.keysort(collection, 0, :asc)
+
+    assert List.keysort(collection, 0, &</2) == [
+             {1, 5},
+             {2, 2},
+             {2, 4},
+             {3, 1},
+             {4, 3}
+           ]
+
+    assert List.keysort(collection, 0, :desc) == [
+             {4, 3},
+             {3, 1},
+             {2, 4},
+             {2, 2},
+             {1, 5}
+           ]
+  end
+
+  test "keysort/3 with module and stable sorting" do
+    collection = [
+      {~D[2010-01-02], 4},
+      {~D[2010-01-01], 5},
+      {~D[2010-01-02], 2},
+      {~D[2010-01-03], 1},
+      {~D[2010-01-04], 3}
+    ]
+
+    # Stable sorting
+    assert List.keysort(collection, 0, Date) == [
+             {~D[2010-01-01], 5},
+             {~D[2010-01-02], 4},
+             {~D[2010-01-02], 2},
+             {~D[2010-01-03], 1},
+             {~D[2010-01-04], 3}
+           ]
+
+    assert List.keysort(collection, 0, Date) ==
+             List.keysort(collection, 0, {:asc, Date})
+
+    assert List.keysort(collection, 0, {:desc, Date}) == [
+             {~D[2010-01-04], 3},
+             {~D[2010-01-03], 1},
+             {~D[2010-01-02], 4},
+             {~D[2010-01-02], 2},
+             {~D[2010-01-01], 5}
+           ]
+  end
+
+  test "keystore/4" do
     assert List.keystore([a: 1, b: 2], :a, 0, {:a, 3}) == [a: 3, b: 2]
     assert List.keystore([a: 1], :b, 0, {:b, 2}) == [a: 1, b: 2]
   end
 
-  test :keymember? do
+  test "keymember?/3" do
     assert List.keymember?([a: 1, b: 2], :a, 0) == true
     assert List.keymember?([a: 1, b: 2], 2, 1) == true
     assert List.keymember?([a: 1, b: 2], :c, 0) == false
   end
 
-  test :keydelete do
+  test "keydelete/3" do
     assert List.keydelete([a: 1, b: 2], :a, 0) == [{:b, 2}]
     assert List.keydelete([a: 1, b: 2], 2, 1) == [{:a, 1}]
     assert List.keydelete([a: 1, b: 2], :c, 0) == [{:a, 1}, {:b, 2}]
   end
 
-  test :insert_at do
+  test "keytake/3" do
+    assert List.keytake([a: 1, b: 2], :a, 0) == {{:a, 1}, [b: 2]}
+    assert List.keytake([a: 1, b: 2], 2, 1) == {{:b, 2}, [a: 1]}
+    assert List.keytake([a: 1, b: 2], :c, 0) == nil
+  end
+
+  test "insert_at/3" do
     assert List.insert_at([1, 2, 3], 0, 0) == [0, 1, 2, 3]
     assert List.insert_at([1, 2, 3], 3, 0) == [1, 2, 3, 0]
     assert List.insert_at([1, 2, 3], 2, 0) == [1, 2, 0, 3]
@@ -125,7 +205,7 @@ defmodule ListTest do
     assert List.insert_at([1, 2, 3], -10, 0) == [0, 1, 2, 3]
   end
 
-  test :replace_at do
+  test "replace_at/3" do
     assert List.replace_at([1, 2, 3], 0, 0) == [0, 2, 3]
     assert List.replace_at([1, 2, 3], 1, 0) == [1, 0, 3]
     assert List.replace_at([1, 2, 3], 2, 0) == [1, 2, 0]
@@ -134,7 +214,7 @@ defmodule ListTest do
     assert List.replace_at([1, 2, 3], -4, 0) == [1, 2, 3]
   end
 
-  test :update_at do
+  test "update_at/3" do
     assert List.update_at([1, 2, 3], 0, &(&1 + 1)) == [2, 2, 3]
     assert List.update_at([1, 2, 3], 1, &(&1 + 1)) == [1, 3, 3]
     assert List.update_at([1, 2, 3], 2, &(&1 + 1)) == [1, 2, 4]
@@ -143,10 +223,11 @@ defmodule ListTest do
     assert List.update_at([1, 2, 3], -4, &(&1 + 1)) == [1, 2, 3]
   end
 
-  test :delete_at do
-    Enum.each [-1, 0, 1], fn i ->
-      assert [] = List.delete_at([], i)
+  test "delete_at/2" do
+    for index <- [-1, 0, 1] do
+      assert List.delete_at([], index) == []
     end
+
     assert List.delete_at([1, 2, 3], 0) == [2, 3]
     assert List.delete_at([1, 2, 3], 2) == [1, 2]
     assert List.delete_at([1, 2, 3], 3) == [1, 2, 3]
@@ -155,13 +236,193 @@ defmodule ListTest do
     assert List.delete_at([1, 2, 3], -4) == [1, 2, 3]
   end
 
-  test :to_string do
+  test "pop_at/3" do
+    for index <- [-1, 0, 1] do
+      assert List.pop_at([], index) == {nil, []}
+    end
+
+    assert List.pop_at([1], 1, 2) == {2, [1]}
+    assert List.pop_at([1, 2, 3], 0) == {1, [2, 3]}
+    assert List.pop_at([1, 2, 3], 2) == {3, [1, 2]}
+    assert List.pop_at([1, 2, 3], 3) == {nil, [1, 2, 3]}
+    assert List.pop_at([1, 2, 3], -1) == {3, [1, 2]}
+    assert List.pop_at([1, 2, 3], -3) == {1, [2, 3]}
+    assert List.pop_at([1, 2, 3], -4) == {nil, [1, 2, 3]}
+  end
+
+  describe "starts_with?/2" do
+    test "list and prefix are equal" do
+      assert List.starts_with?([], [])
+      assert List.starts_with?([1], [1])
+      assert List.starts_with?([1, 2, 3], [1, 2, 3])
+    end
+
+    test "proper lists" do
+      refute List.starts_with?([1], [1, 2])
+      assert List.starts_with?([1, 2, 3], [1, 2])
+      refute List.starts_with?([1, 2, 3], [1, 2, 3, 4])
+    end
+
+    test "list is empty" do
+      refute List.starts_with?([], [1])
+      refute List.starts_with?([], [1, 2])
+    end
+
+    test "prefix is empty" do
+      assert List.starts_with?([1], [])
+      assert List.starts_with?([1, 2], [])
+      assert List.starts_with?([1, 2, 3], [])
+    end
+
+    test "only accepts proper lists" do
+      message = "no function clause matching in List.starts_with?/2"
+
+      assert_raise FunctionClauseError, message, fn ->
+        List.starts_with?([1 | 2], [1 | 2])
+      end
+    end
+  end
+
+  describe "ends_with?/2" do
+    test "list and prefix are equal" do
+      assert List.ends_with?([], [])
+      assert List.ends_with?([1], [1])
+      assert List.ends_with?([1, 2, 3], [1, 2, 3])
+    end
+
+    test "proper lists" do
+      refute List.ends_with?([2], [1, 2])
+      assert List.ends_with?([1, 2, 3], [2, 3])
+      refute List.ends_with?([2, 3, 4], [1, 2, 3, 4])
+    end
+
+    test "list is empty" do
+      refute List.ends_with?([], [1])
+      refute List.ends_with?([], [1, 2])
+    end
+
+    test "prefix is empty" do
+      assert List.ends_with?([1], [])
+      assert List.ends_with?([1, 2], [])
+      assert List.ends_with?([1, 2, 3], [])
+    end
+
+    test "only accepts proper lists" do
+      assert_raise ArgumentError, ~r/not a list/, fn ->
+        List.ends_with?([1 | 2], [1 | 2])
+      end
+    end
+  end
+
+  test "to_string/1" do
     assert List.to_string([?æ, ?ß]) == "æß"
     assert List.to_string([?a, ?b, ?c]) == "abc"
+    assert List.to_string([]) == ""
+    assert List.to_string([[], []]) == ""
 
-    assert_raise UnicodeConversionError,
-                 "invalid code point 57343", fn ->
+    assert_raise UnicodeConversionError, "invalid code point 57343", fn ->
       List.to_string([0xDFFF])
     end
+
+    assert_raise UnicodeConversionError, "invalid encoding starting at <<216, 0>>", fn ->
+      List.to_string(["a", "b", <<0xD800::size(16)>>])
+    end
+
+    assert_raise ArgumentError, ~r"cannot convert the given list to a string", fn ->
+      List.to_string([:a, :b])
+    end
+  end
+
+  test "to_charlist/1" do
+    assert List.to_charlist([0x00E6, 0x00DF]) == ~c"æß"
+    assert List.to_charlist([0x0061, "bc"]) == ~c"abc"
+    assert List.to_charlist([0x0064, "ee", [~c"p"]]) == ~c"deep"
+
+    assert_raise UnicodeConversionError, "invalid code point 57343", fn ->
+      List.to_charlist([0xDFFF])
+    end
+
+    assert_raise UnicodeConversionError, "invalid encoding starting at <<216, 0>>", fn ->
+      List.to_charlist(["a", "b", <<0xD800::size(16)>>])
+    end
+
+    assert_raise ArgumentError, ~r"cannot convert the given list to a charlist", fn ->
+      List.to_charlist([:a, :b])
+    end
+  end
+
+  describe "myers_difference/2" do
+    test "follows paper implementation" do
+      assert List.myers_difference([], []) == []
+      assert List.myers_difference([], [1, 2, 3]) == [ins: [1, 2, 3]]
+      assert List.myers_difference([1, 2, 3], []) == [del: [1, 2, 3]]
+      assert List.myers_difference([1, 2, 3], [1, 2, 3]) == [eq: [1, 2, 3]]
+      assert List.myers_difference([1, 2, 3], [1, 4, 2, 3]) == [eq: [1], ins: [4], eq: [2, 3]]
+      assert List.myers_difference([1, 4, 2, 3], [1, 2, 3]) == [eq: [1], del: [4], eq: [2, 3]]
+      assert List.myers_difference([1], [[1]]) == [del: [1], ins: [[1]]]
+      assert List.myers_difference([[1]], [1]) == [del: [[1]], ins: [1]]
+    end
+
+    test "rearranges inserts and equals for smaller diffs" do
+      assert List.myers_difference([3, 2, 0, 2], [2, 2, 0, 2]) ==
+               [del: [3], ins: [2], eq: [2, 0, 2]]
+
+      assert List.myers_difference([3, 2, 1, 0, 2], [2, 1, 2, 1, 0, 2]) ==
+               [del: [3], ins: [2, 1], eq: [2, 1, 0, 2]]
+
+      assert List.myers_difference([3, 2, 2, 1, 0, 2], [2, 2, 1, 2, 1, 0, 2]) ==
+               [del: [3], eq: [2, 2, 1], ins: [2, 1], eq: [0, 2]]
+
+      assert List.myers_difference([3, 2, 0, 2], [2, 2, 1, 0, 2]) ==
+               [del: [3], eq: [2], ins: [2, 1], eq: [0, 2]]
+    end
+  end
+
+  test "improper?/1" do
+    assert List.improper?([1 | 2])
+    assert List.improper?([1, 2, 3 | 4])
+    refute List.improper?([])
+    refute List.improper?([1])
+    refute List.improper?([[1]])
+    refute List.improper?([1, 2])
+    refute List.improper?([1, 2, 3])
+
+    assert_raise FunctionClauseError, fn ->
+      List.improper?(%{})
+    end
+  end
+
+  describe "ascii_printable?/2" do
+    test "proper lists without limit" do
+      assert List.ascii_printable?([])
+      assert List.ascii_printable?(~c"abc")
+      refute(List.ascii_printable?(~c"abc" ++ [0]))
+      refute List.ascii_printable?(~c"mañana")
+
+      printable_chars = ~c"\a\b\t\n\v\f\r\e" ++ Enum.to_list(32..126)
+      non_printable_chars = ~c"🌢áéíóúźç©¢🂭"
+
+      assert List.ascii_printable?(printable_chars)
+
+      for char <- printable_chars do
+        assert List.ascii_printable?([char])
+      end
+
+      refute List.ascii_printable?(non_printable_chars)
+
+      for char <- non_printable_chars do
+        refute List.ascii_printable?([char])
+      end
+    end
+
+    test "proper lists with limit" do
+      assert List.ascii_printable?([], 100)
+      assert List.ascii_printable?(~c"abc" ++ [0], 2)
+    end
+
+    test "improper lists" do
+      refute List.ascii_printable?(~c"abc" ++ ?d)
+      assert List.ascii_printable?(~c"abc" ++ ?d, 3)
+    end
   end
 end
diff --git a/lib/elixir/test/elixir/macro/env_test.exs b/lib/elixir/test/elixir/macro/env_test.exs
new file mode 100644
index 00000000000..1a62f3cab85
--- /dev/null
+++ b/lib/elixir/test/elixir/macro/env_test.exs
@@ -0,0 +1,261 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule MacroEnvMacros do
+  defmacro my_macro(arg) do
+    quote do: foo(unquote(arg))
+  end
+
+  @deprecated "this is deprecated"
+  defmacro my_deprecated_macro(arg), do: arg
+end
+
+defmodule Macro.EnvTest do
+  use ExUnit.Case, async: true
+
+  import Macro.Env
+  import ExUnit.CaptureIO
+
+  alias List, as: CustomList, warn: false
+  import MacroEnvMacros, warn: false
+
+  def trace(event, _env) do
+    send(self(), event)
+    :ok
+  end
+
+  def meta, do: [file: "some_file.exs", line: 123]
+  def env, do: %{__ENV__ | tracers: [__MODULE__], line: 456}
+
+  doctest Macro.Env
+
+  test "inspect" do
+    assert inspect(__ENV__) =~ "#Macro.Env<"
+  end
+
+  test "prune_compile_info" do
+    assert %Macro.Env{lexical_tracker: nil, tracers: []} =
+             Macro.Env.prune_compile_info(%{__ENV__ | lexical_tracker: self(), tracers: [Foo]})
+  end
+
+  test "stacktrace" do
+    env = %{__ENV__ | file: "foo", line: 12}
+
+    assert Macro.Env.stacktrace(env) ==
+             [{__MODULE__, :"test stacktrace", 1, [file: ~c"foo", line: 12]}]
+
+    env = %{env | function: nil}
+
+    assert Macro.Env.stacktrace(env) == [
+             {__MODULE__, :__MODULE__, 0, [file: ~c"foo", line: 12]}
+           ]
+
+    env = %{env | module: nil}
+
+    assert Macro.Env.stacktrace(env) ==
+             [{:elixir_compiler, :__FILE__, 1, [file: ~c"foo", line: 12]}]
+  end
+
+  test "context modules" do
+    defmodule Foo.Bar do
+      assert __MODULE__ in __ENV__.context_modules
+    end
+
+    assert Foo.Bar in __ENV__.context_modules
+
+    Code.compile_string("""
+    defmodule Foo.Bar.Compiled do
+      true = __MODULE__ in __ENV__.context_modules
+    end
+    """)
+  end
+
+  test "to_match/1" do
+    quote = quote(do: x in [])
+
+    assert {:__block__, [], [{:=, [], [{:_, [], Kernel}, {:x, [], Macro.EnvTest}]}, false]} =
+             Macro.expand_once(quote, __ENV__)
+
+    assert Macro.expand_once(quote, Macro.Env.to_match(__ENV__)) == false
+  end
+
+  test "prepend_tracer" do
+    assert %Macro.Env{tracers: [MyCustomTracer | _]} =
+             Macro.Env.prepend_tracer(__ENV__, MyCustomTracer)
+  end
+
+  describe "define_import/4" do
+    test "with tracing" do
+      define_import(env(), meta(), List)
+      assert_received {:import, _, List, []}
+
+      define_import(env(), meta(), Integer, only: :macros, trace: false)
+      refute_received {:import, _, Integer, _}
+    end
+
+    test "with errors" do
+      message =
+        "invalid :only option for import, expected value to be an atom :functions, :macros, " <>
+          "or a literal keyword list of function names with arity as values, got: "
+
+      assert define_import(env(), meta(), Integer, only: :unknown) ==
+               {:error, message <> ":unknown"}
+
+      assert define_import(env(), meta(), Integer, only: [:unknown]) ==
+               {:error, message <> "[:unknown]"}
+    end
+
+    test "with warnings" do
+      assert capture_io(:stderr, fn ->
+               define_import(env(), meta(), Integer, only: [is_odd: 1, is_odd: 1])
+             end) =~ "invalid :only option for import, is_odd/1 is duplicated"
+
+      assert {:ok, _env} =
+               define_import(env(), meta(), Integer,
+                 only: [is_odd: 1, is_odd: 1],
+                 emit_warnings: false
+               )
+    end
+  end
+
+  describe "expand_alias/4" do
+    test "with tracing" do
+      {:alias, List} = expand_alias(env(), meta(), [:CustomList])
+      assert_received {:alias_expansion, _, Elixir.CustomList, List}
+
+      {:alias, List} = expand_alias(env(), meta(), [:CustomList], trace: false)
+      refute_received {:alias_expansion, _, Elixir.CustomList, List}
+
+      {:alias, List.Continues} = expand_alias(env(), meta(), [:CustomList, :Continues])
+      assert_received {:alias_expansion, _, Elixir.CustomList, List}
+    end
+  end
+
+  describe "expand_require/6" do
+    test "returns :error for functions and unknown modules" do
+      assert :error = expand_require(env(), meta(), List, :flatten, 1)
+      assert :error = expand_require(env(), meta(), Unknown, :flatten, 1)
+    end
+
+    test "returns :error for unrequired modules" do
+      assert :error = expand_require(env(), meta(), Integer, :is_odd, 1)
+    end
+
+    test "expands required modules" do
+      assert {:macro, Integer, _} =
+               expand_require(env(), [required: true] ++ meta(), Integer, :is_odd, 1)
+
+      assert {:macro, Integer, _} =
+               expand_require(%{env() | requires: [Integer]}, meta(), Integer, :is_odd, 1)
+
+      assert {:macro, Integer, _} =
+               expand_require(%{env() | module: Integer}, meta(), Integer, :is_odd, 1)
+    end
+
+    test "expands with argument" do
+      {:macro, MacroEnvMacros, fun} = expand_require(env(), meta(), MacroEnvMacros, :my_macro, 1)
+      assert fun.([], [quote(do: hello())]) == quote(do: foo(hello()))
+      assert fun.([line: 789], [quote(do: hello())]) == quote(line: 789, do: foo(hello()))
+
+      # do not propagate generated: true to arguments
+      assert {:foo, outer_meta, [{:hello, inner_meta, []}]} =
+               fun.([generated: true], [quote(do: hello())])
+
+      assert outer_meta[:generated]
+      refute inner_meta[:generated]
+    end
+
+    test "with tracing and deprecations" do
+      message = "MacroEnvMacros.my_deprecated_macro/1 is deprecated"
+
+      {:macro, MacroEnvMacros, fun} =
+        expand_require(env(), meta(), MacroEnvMacros, :my_deprecated_macro, 1)
+
+      assert capture_io(:stderr, fn -> fun.([], [quote(do: hello())]) end) =~ message
+      assert_received {:remote_macro, _, MacroEnvMacros, :my_deprecated_macro, 1}
+
+      {:macro, MacroEnvMacros, fun} =
+        expand_require(env(), meta(), MacroEnvMacros, :my_deprecated_macro, 1,
+          trace: false,
+          check_deprecations: false
+        )
+
+      refute capture_io(:stderr, fn -> fun.([], [quote(do: hello())]) end) =~ message
+      refute_received {:remote_macro, _, MacroEnvMacros, :my_deprecated_macro, 1}
+    end
+  end
+
+  describe "expand_import/5" do
+    test "returns tagged :error for unknown imports" do
+      assert {:error, :not_found} = expand_import(env(), meta(), :flatten, 1)
+    end
+
+    test "returns tagged :error for special forms" do
+      assert {:error, :not_found} = expand_import(env(), meta(), :case, 1)
+    end
+
+    test "returns tagged :error for ambiguous" do
+      import Date, warn: false
+      import Time, warn: false
+      assert {:error, {:ambiguous, mods}} = expand_import(__ENV__, meta(), :new, 3)
+      assert Enum.sort(mods) == [Date, Time]
+    end
+
+    test "returns :function tuple" do
+      assert {:function, ExUnit.CaptureIO, :capture_io} =
+               expand_import(env(), meta(), :capture_io, 1)
+    end
+
+    test "expands with argument" do
+      {:macro, MacroEnvMacros, fun} = expand_import(env(), meta(), :my_macro, 1)
+      assert fun.([], [quote(do: hello())]) == quote(do: foo(hello()))
+      assert fun.([line: 789], [quote(do: hello())]) == quote(line: 789, do: foo(hello()))
+
+      # do not propagate generated: true to arguments
+      assert {:foo, outer_meta, [{:hello, inner_meta, []}]} =
+               fun.([generated: true], [quote(do: hello())])
+
+      assert outer_meta[:generated]
+      refute inner_meta[:generated]
+    end
+
+    defmacro allow_locals_example, do: :ok
+
+    test "allow_locals" do
+      {:macro, Macro.EnvTest, fun} =
+        expand_import(env(), meta(), :allow_locals_example, 0)
+
+      assert fun.([], []) == :ok
+
+      assert expand_import(env(), meta(), :allow_locals_example, 0, allow_locals: false) ==
+               {:error, :not_found}
+
+      assert expand_import(env(), meta(), :allow_locals_example, 0,
+               allow_locals: fn -> send(self(), false) end
+             ) ==
+               {:error, :not_found}
+
+      assert_received false
+    end
+
+    test "with tracing and deprecations" do
+      message = "MacroEnvMacros.my_deprecated_macro/1 is deprecated"
+
+      {:macro, MacroEnvMacros, fun} = expand_import(env(), meta(), :my_deprecated_macro, 1)
+
+      assert capture_io(:stderr, fn -> fun.([], [quote(do: hello())]) end) =~ message
+      assert_received {:imported_macro, _, MacroEnvMacros, :my_deprecated_macro, 1}
+
+      {:macro, MacroEnvMacros, fun} =
+        expand_import(env(), meta(), :my_deprecated_macro, 1,
+          trace: false,
+          check_deprecations: false
+        )
+
+      refute capture_io(:stderr, fn -> fun.([], [quote(do: hello())]) end) =~ message
+      refute_received {:imported_macro, _, MacroEnvMacros, :my_deprecated_macro, 1}
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/macro_test.exs b/lib/elixir/test/elixir/macro_test.exs
index 9a1de1c6130..1216af53224 100644
--- a/lib/elixir/test/elixir/macro_test.exs
+++ b/lib/elixir/test/elixir/macro_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule Macro.ExternalTest do
   defmacro external do
@@ -11,520 +15,1899 @@ defmodule Macro.ExternalTest do
   end
 
   defmacro oror(left, right) do
-    quote do: unquote(left) || unquote(right)
+    quote(do: unquote(left) || unquote(right))
+  end
+end
+
+defmodule CustomIf do
+  def if(_cond, _expr) do
+    "custom if result"
   end
 end
 
 defmodule MacroTest do
   use ExUnit.Case, async: true
+  doctest Macro
 
   # Changing the lines above will make compilation
   # fail since we are asserting on the caller lines
   import Macro.ExternalTest
 
-  ## Escape
+  describe "escape/2" do
+    test "returns tuples with size equal to two" do
+      assert Macro.escape({:a, :b}) == {:a, :b}
+    end
 
-  test :escape_handle_tuples_with_size_different_than_two do
-    assert {:{}, [], [:a]} == Macro.escape({:a})
-    assert {:{}, [], [:a, :b, :c]} == Macro.escape({:a, :b, :c})
-    assert {:{}, [], [:a, {:{}, [], [1,2,3]}, :c]} == Macro.escape({:a, {1, 2, 3}, :c})
-  end
+    test "returns lists" do
+      assert Macro.escape([1, 2, 3]) == [1, 2, 3]
+    end
 
-  test :escape_simply_returns_tuples_with_size_equal_to_two do
-    assert {:a, :b} == Macro.escape({:a, :b})
-  end
+    test "escapes tuples with size different than two" do
+      assert Macro.escape({:a}) == {:{}, [], [:a]}
+      assert Macro.escape({:a, :b, :c}) == {:{}, [], [:a, :b, :c]}
+      assert Macro.escape({:a, {1, 2, 3}, :c}) == {:{}, [], [:a, {:{}, [], [1, 2, 3]}, :c]}
 
-  test :escape_simply_returns_any_other_structure do
-    assert [1, 2, 3] == Macro.escape([1, 2, 3])
-  end
+      # False positives
+      assert Macro.escape({:quote, :foo, [:bar]}) == {:{}, [], [:quote, :foo, [:bar]]}
+      assert Macro.escape({:quote, :foo, [:bar, :baz]}) == {:{}, [], [:quote, :foo, [:bar, :baz]]}
+    end
 
-  test :escape_handles_maps do
-    assert {:%{}, [], [a: 1]} = Macro.escape(%{a: 1})
-  end
+    test "escapes maps" do
+      assert Macro.escape(%{a: 1}) == {:%{}, [], [a: 1]}
+    end
 
-  test :escape_works_recursively do
-    assert [1,{:{}, [], [:a,:b,:c]}, 3] == Macro.escape([1, {:a, :b, :c}, 3])
-  end
+    test "escapes bitstring" do
+      assert {:<<>>, [], args} = Macro.escape(<<300::12>>)
+      assert [{:"::", [], [1, {:size, [], [4]}]}, {:"::", [], [",", {:binary, [], nil}]}] = args
+    end
 
-  test :escape_improper do
-    assert [{:|, [], [1,2]}] == Macro.escape([1|2])
-    assert [1,{:|, [], [2,3]}] == Macro.escape([1,2|3])
-  end
+    test "escapes recursively" do
+      assert Macro.escape([1, {:a, :b, :c}, 3]) == [1, {:{}, [], [:a, :b, :c]}, 3]
+    end
 
-  test :escape_with_unquote do
-    contents = quote unquote: false, do: unquote(1)
-    assert Macro.escape(contents, unquote: true) == 1
+    test "escapes improper lists" do
+      assert Macro.escape([1 | 2]) == [{:|, [], [1, 2]}]
+      assert Macro.escape([1, 2 | 3]) == [1, {:|, [], [2, 3]}]
+    end
 
-    contents = quote unquote: false, do: unquote(x)
-    assert Macro.escape(contents, unquote: true) == {:x, [], MacroTest}
-  end
+    test "prunes metadata" do
+      meta = [nothing: :important, counter: 1]
+      assert Macro.escape({:foo, meta, []}) == {:{}, [], [:foo, meta, []]}
+      assert Macro.escape({:foo, meta, []}, prune_metadata: true) == {:{}, [], [:foo, [], []]}
+    end
 
-  defp eval_escaped(contents) do
-    {eval, []} = Code.eval_quoted(Macro.escape(contents, unquote: true))
-    eval
-  end
+    test "with unquote" do
+      contents = quote(unquote: false, do: unquote(1))
+      assert Macro.escape(contents, unquote: true) == 1
 
-  test :escape_with_remote_unquote do
-    contents = quote unquote: false, do: Kernel.unquote(:is_atom)(:ok)
-    assert eval_escaped(contents) == quote(do: Kernel.is_atom(:ok))
-  end
+      contents = quote(unquote: false, do: unquote(x))
+      assert Macro.escape(contents, unquote: true) == {:x, [], MacroTest}
 
-  test :escape_with_nested_unquote do
-    contents = quote do
-      quote do: unquote(x)
+      contents = %{foo: quote(unquote: false, do: unquote(1))}
+      assert Macro.escape(contents, unquote: true) == {:%{}, [], [foo: 1]}
     end
-    assert eval_escaped(contents) == quote do: (quote do: unquote(x))
-  end
 
-  test :escape_with_alias_or_no_args_remote_unquote do
-    contents = quote unquote: false, do: Kernel.unquote(:self)
-    assert eval_escaped(contents) == quote(do: Kernel.self())
+    test "with generated" do
+      assert Macro.escape(%{a: {}}, generated: true) ==
+               {:%{}, [generated: true], [a: {:{}, [], []}]}
+    end
 
-    contents = quote unquote: false, do: x.unquote(Foo)
-    assert eval_escaped(contents) == quote(do: x.unquote(Foo))
-  end
+    defp eval_escaped(contents) do
+      {eval, []} = Code.eval_quoted(Macro.escape(contents, unquote: true))
+      eval
+    end
 
-  test :escape_with_splicing do
-    contents = quote unquote: false, do: [1, 2, 3, 4, 5]
-    assert Macro.escape(contents, unquote: true) == [1, 2, 3, 4, 5]
+    test "with remote unquote" do
+      contents = quote(unquote: false, do: Kernel.unquote(:is_atom)(:ok))
+      assert eval_escaped(contents) == quote(do: Kernel.is_atom(:ok))
+      assert eval_escaped(%{foo: contents}) == %{foo: quote(do: Kernel.is_atom(:ok))}
+    end
 
-    contents = quote unquote: false, do: [1, 2, unquote_splicing([3, 4, 5])]
-    assert eval_escaped(contents) == [1, 2, 3, 4, 5]
+    test "with nested unquote" do
+      contents =
+        quote do
+          quote(do: unquote(x))
+        end
 
-    contents = quote unquote: false, do: [unquote_splicing([1, 2, 3]), 4, 5]
-    assert eval_escaped(contents) == [1, 2, 3, 4, 5]
+      assert eval_escaped(contents) == quote(do: quote(do: unquote(x)))
+    end
 
-    contents = quote unquote: false, do: [unquote_splicing([1, 2, 3]), unquote_splicing([4, 5])]
-    assert eval_escaped(contents) == [1, 2, 3, 4, 5]
+    test "with alias or no arguments remote unquote" do
+      contents = quote(unquote: false, do: Kernel.unquote(:self)())
+      assert eval_escaped(contents) == quote(do: Kernel.self())
 
-    contents = quote unquote: false, do: [1, unquote_splicing([2]), 3, unquote_splicing([4]), 5]
-    assert eval_escaped(contents) == [1, 2, 3, 4, 5]
+      contents = quote(unquote: false, do: x.unquote(Foo))
+      assert eval_escaped(contents) == quote(do: x.unquote(Foo))
+    end
 
-    contents = quote unquote: false, do: [1, unquote_splicing([2]), 3, unquote_splicing([4])|[5]]
-    assert eval_escaped(contents) == [1, 2, 3, 4, 5]
-  end
+    test "with splicing" do
+      contents = quote(unquote: false, do: [1, 2, 3, 4, 5])
+      assert Macro.escape(contents, unquote: true) == [1, 2, 3, 4, 5]
 
-  ## Expansion
+      contents = quote(unquote: false, do: [1, 2, unquote_splicing([3, 4, 5])])
+      assert eval_escaped(contents) == [1, 2, 3, 4, 5]
 
-  test :expand_once do
-    assert {:||, _, _} = Macro.expand_once(quote(do: oror(1, false)), __ENV__)
-  end
+      contents = quote(unquote: false, do: [unquote_splicing([1, 2, 3]), 4, 5])
+      assert eval_escaped(contents) == [1, 2, 3, 4, 5]
 
-  test :expand_once_with_raw_atom do
-    assert Macro.expand_once(quote(do: :foo), __ENV__) == :foo
-  end
+      contents =
+        quote(unquote: false, do: [unquote_splicing([1, 2, 3]), unquote_splicing([4, 5])])
 
-  test :expand_once_with_current_module do
-    assert Macro.expand_once(quote(do: __MODULE__), __ENV__) == __MODULE__
-  end
+      assert eval_escaped(contents) == [1, 2, 3, 4, 5]
 
-  test :expand_once_with_main do
-    assert Macro.expand_once(quote(do: Elixir), __ENV__) == Elixir
-  end
+      contents =
+        quote(unquote: false, do: [1, unquote_splicing([2]), 3, unquote_splicing([4]), 5])
 
-  test :expand_once_with_simple_alias do
-    assert Macro.expand_once(quote(do: Foo), __ENV__) == Foo
-  end
+      assert eval_escaped(contents) == [1, 2, 3, 4, 5]
 
-  test :expand_once_with_current_module_plus_alias do
-    assert Macro.expand_once(quote(do: __MODULE__.Foo), __ENV__) == __MODULE__.Foo
-  end
+      contents =
+        quote(unquote: false, do: [1, unquote_splicing([2]), 3, unquote_splicing([4]) | [5]])
 
-  test :expand_once_with_main_plus_alias do
-    assert Macro.expand_once(quote(do: Elixir.Foo), __ENV__) == Foo
-  end
+      assert eval_escaped(contents) == [1, 2, 3, 4, 5]
 
-  test :expand_once_with_custom_alias do
-    alias Foo, as: Bar
-    assert Macro.expand_once(quote(do: Bar.Baz), __ENV__) == Foo.Baz
-  end
+      contents = %{foo: quote(unquote: false, do: [1, 2, unquote_splicing([3, 4, 5])])}
+      assert eval_escaped(contents) == %{foo: [1, 2, 3, 4, 5]}
+    end
 
-  test :expand_once_with_main_plus_custom_alias do
-    alias Foo, as: Bar, warn: false
-    assert Macro.expand_once(quote(do: Elixir.Bar.Baz), __ENV__) == Elixir.Bar.Baz
-  end
+    test "does not add context to quote" do
+      assert Macro.escape({:quote, [], [[do: :foo]]}) == {:{}, [], [:quote, [], [[do: :foo]]]}
+    end
 
-  test :expand_once_with_op do
-    assert Macro.expand_once(quote(do: Foo.bar.Baz), __ENV__) == (quote do
-      Foo.bar.Baz
-    end)
-  end
+    test "escapes the content of :quote tuples" do
+      assert Macro.escape({:quote, [%{}], [{}]}) ==
+               {:{}, [], [:quote, [{:%{}, [], []}], [{:{}, [], []}]]}
 
-  test :expand_once_with_erlang do
-    assert Macro.expand_once(quote(do: :foo), __ENV__) == :foo
-  end
+      assert Macro.escape([:foo, {:quote, [%{}], [{}]}]) ==
+               [:foo, {:{}, [], [:quote, [{:%{}, [], []}], [{:{}, [], []}]]}]
+    end
 
-  test :expand_once_env do
-    env = %{__ENV__ | line: 0}
-    assert Macro.expand_once(quote(do: __ENV__), env) == {:%{}, [], Map.to_list(env)}
-    assert Macro.expand_once(quote(do: __ENV__.file), env) == env.file
-    assert Macro.expand_once(quote(do: __ENV__.unknown), env) == quote(do: __ENV__.unknown)
-  end
+    @tag :re_import
+    test "escape regex will remove references and replace it by a call to :re.import/1" do
+      assert {
+               :%{},
+               [],
+               [
+                 __struct__: Regex,
+                 re_pattern:
+                   {{:., [], [{:__aliases__, _, [:Regex]}, :__import_pattern__]},
+                    [required: true], [{:{}, [], [:re_exported_pattern | _]}]},
+                 source: "foo",
+                 opts: []
+               ]
+             } = Macro.escape(~r/foo/)
+    end
 
-  defmacro local_macro do
-    :local_macro
-  end
+    @tag :re_import
+    test "escape raises within structs fields" do
+      assert_raise ArgumentError,
+                   ~r"Regex defines custom escaping rules which are not supported in struct defaults",
+                   fn ->
+                     defmodule Test do
+                       defstruct my_regex: ~r/^hi$/
+                     end
+                   end
+    end
 
-  test :expand_once_local_macro do
-    assert Macro.expand_once(quote(do: local_macro), __ENV__) == :local_macro
-  end
+    defmodule EscapedStruct do
+      defstruct [:ast, :ref]
 
-  test :expand_once_checks_vars do
-    local_macro = 1
-    assert local_macro == 1
-    quote = {:local_macro, [], nil}
-    assert Macro.expand_once(quote, __ENV__) == quote
-  end
+      def __escape__(%{ast: ast}), do: ast
+    end
 
-  defp expand_once_and_clean(quoted, env) do
-    cleaner = &Keyword.drop(&1, [:counter])
-    quoted
-    |> Macro.expand_once(env)
-    |> Macro.prewalk(&Macro.update_meta(&1, cleaner))
-  end
+    test "escape struct with custom __escape__ (valid AST)" do
+      struct = %EscapedStruct{ast: {:valid_ast, [], []}, ref: make_ref()}
 
-  test :expand_once_with_imported_macro do
-    temp_var = {:x, [], Kernel}
-    assert expand_once_and_clean(quote(do: 1 || false), __ENV__) == (quote context: Kernel do
-      case 1 do
-        unquote(temp_var) when unquote(temp_var) in [false, nil] -> false
-        unquote(temp_var) -> unquote(temp_var)
-      end
-    end)
-  end
+      assert {:valid_ast, [], []} = Macro.escape(struct)
+    end
 
-  test :expand_once_with_require_macro do
-    temp_var = {:x, [], Kernel}
-    assert expand_once_and_clean(quote(do: Kernel.||(1, false)), __ENV__) == (quote context: Kernel do
-      case 1 do
-        unquote(temp_var) when unquote(temp_var) in [false, nil] -> false
-        unquote(temp_var) -> unquote(temp_var)
-      end
-    end)
-  end
+    test "escape struct with custom __escape__ (shallow invalid AST)" do
+      struct = %EscapedStruct{ast: %{invalid: :ast}, ref: make_ref()}
 
-  test :expand_once_with_not_expandable_expression do
-    expr = quote(do: other(1, 2, 3))
-    assert Macro.expand_once(expr, __ENV__) == expr
+      assert_raise ArgumentError,
+                   "MacroTest.EscapedStruct.__escape__/1 returned invalid AST: %{invalid: :ast}",
+                   fn -> Macro.escape(struct) end
+    end
   end
 
-  @foo 1
-  @bar Macro.expand_once(quote(do: @foo), __ENV__)
+  describe "expand_once/2" do
+    test "with external macro" do
+      assert {:||, _, [1, false]} = Macro.expand_once(quote(do: oror(1, false)), __ENV__)
+    end
+
+    test "with raw atom" do
+      assert Macro.expand_once(quote(do: :foo), __ENV__) == :foo
+    end
+
+    test "with current module" do
+      assert Macro.expand_once(quote(do: __MODULE__), __ENV__) == __MODULE__
+    end
+
+    test "with main" do
+      assert Macro.expand_once(quote(do: Elixir), __ENV__) == Elixir
+    end
+
+    test "with simple alias" do
+      assert Macro.expand_once(quote(do: Foo), __ENV__) == Foo
+    end
+
+    test "with current module plus alias" do
+      assert Macro.expand_once(quote(do: __MODULE__.Foo), __ENV__) == __MODULE__.Foo
+    end
+
+    test "with main plus alias" do
+      assert Macro.expand_once(quote(do: Elixir.Foo), __ENV__) == Foo
+    end
 
-  test :expand_once_with_module_at do
-    assert @bar == 1
+    test "with custom alias" do
+      alias Foo, as: Bar
+      assert Macro.expand_once(quote(do: Bar.Baz), __ENV__) == Foo.Baz
+    end
+
+    test "with main plus custom alias" do
+      alias Foo, as: Bar, warn: false
+      assert Macro.expand_once(quote(do: Elixir.Bar.Baz), __ENV__) == Elixir.Bar.Baz
+    end
+
+    test "with call in alias" do
+      assert Macro.expand_once(quote(do: Foo.bar().Baz), __ENV__) == quote(do: Foo.bar().Baz)
+    end
+
+    test "env" do
+      env = %{__ENV__ | line: 0, lexical_tracker: self()}
+
+      expanded = Macro.expand_once(quote(do: __ENV__), env)
+      assert Macro.validate(expanded) == :ok
+      assert Code.eval_quoted(expanded) == {env, []}
+
+      assert Macro.expand_once(quote(do: __ENV__.file), env) == env.file
+      assert Macro.expand_once(quote(do: __ENV__.unknown), env) == quote(do: __ENV__.unknown)
+
+      expanded = Macro.expand_once(quote(do: __ENV__.versioned_vars), env)
+      assert Macro.validate(expanded) == :ok
+      assert Code.eval_quoted(expanded) == {env.versioned_vars, []}
+    end
+
+    test "env in :match context does not expand" do
+      env = %{__ENV__ | line: 0, lexical_tracker: self(), context: :match}
+
+      expanded = Macro.expand_once(quote(do: __ENV__), env)
+      assert expanded == quote(do: __ENV__)
+
+      expanded = Macro.expand_once(quote(do: __ENV__.file), env)
+      assert expanded == quote(do: __ENV__.file)
+    end
+
+    defmacro local_macro(), do: raise("ignored")
+
+    test "vars" do
+      expr = {:local_macro, [], nil}
+      assert Macro.expand_once(expr, __ENV__) == expr
+    end
+
+    defp expand_once_and_clean(quoted, env) do
+      cleaner = &Keyword.drop(&1, [:counter, :type_check])
+
+      quoted
+      |> Macro.expand_once(env)
+      |> Macro.prewalk(&Macro.update_meta(&1, cleaner))
+    end
+
+    test "with imported macro" do
+      temp_var = {:x, [], Kernel}
+
+      quoted =
+        quote context: Kernel do
+          case 1 do
+            unquote(temp_var) when :"Elixir.Kernel".in(unquote(temp_var), [false, nil]) -> false
+            unquote(temp_var) -> unquote(temp_var)
+          end
+        end
+
+      assert expand_once_and_clean(quote(do: 1 || false), __ENV__) == quoted
+    end
+
+    test "with require macro" do
+      temp_var = {:x, [], Kernel}
+
+      quoted =
+        quote context: Kernel do
+          case 1 do
+            unquote(temp_var) when :"Elixir.Kernel".in(unquote(temp_var), [false, nil]) -> false
+            unquote(temp_var) -> unquote(temp_var)
+          end
+        end
+
+      assert expand_once_and_clean(quote(do: Kernel.||(1, false)), __ENV__) == quoted
+    end
+
+    test "with not expandable expression" do
+      expr = quote(do: other(1, 2, 3))
+      assert Macro.expand_once(expr, __ENV__) == expr
+    end
+
+    test "propagates :generated" do
+      assert {:||, meta, [1, false]} = Macro.expand_once(quote(do: oror(1, false)), __ENV__)
+      refute meta[:generated]
+
+      assert {:||, meta, [1, false]} =
+               Macro.expand_once(quote(generated: true, do: oror(1, false)), __ENV__)
+
+      assert meta[:generated]
+    end
+
+    test "does not propagate :generated to unquoted" do
+      non_generated = quote do: foo()
+
+      assert {:||, outer_meta, [{:foo, inner_meta, []}, false]} =
+               Macro.expand_once(
+                 quote generated: true do
+                   oror(unquote(non_generated), false)
+                 end,
+                 __ENV__
+               )
+
+      assert outer_meta[:generated]
+      refute inner_meta[:generated]
+    end
+
+    defmacro foo_bar(x) do
+      y = quote do: bar(unquote(x))
+
+      quote do: foo(unquote(y))
+    end
+
+    test "propagates :generated to unquote within macro" do
+      non_generated = quote do: baz()
+
+      assert {:foo, foo_meta, [{:bar, bar_meta, [{:baz, baz_meta, []}]}]} =
+               Macro.expand_once(
+                 quote(generated: true, do: foo_bar(unquote(non_generated))),
+                 __ENV__
+               )
+
+      assert foo_meta[:generated]
+      assert bar_meta[:generated]
+      refute baz_meta[:generated]
+    end
+
+    test "does not expand module attributes" do
+      message =
+        "could not call Module.get_attribute/2 because the module #{inspect(__MODULE__)} " <>
+          "is already compiled. Use the Module.__info__/1 callback or Code.fetch_docs/1 instead"
+
+      assert_raise ArgumentError, message, fn ->
+        Macro.expand_once(quote(do: @foo), __ENV__)
+      end
+    end
   end
 
   defp expand_and_clean(quoted, env) do
-    cleaner = &Keyword.drop(&1, [:counter])
+    cleaner = &Keyword.drop(&1, [:counter, :type_check])
+
     quoted
     |> Macro.expand(env)
     |> Macro.prewalk(&Macro.update_meta(&1, cleaner))
   end
 
-  test :expand do
+  test "expand/2" do
     temp_var = {:x, [], Kernel}
-    assert expand_and_clean(quote(do: oror(1, false)), __ENV__) == (quote context: Kernel do
-      case 1 do
-        unquote(temp_var) when unquote(temp_var) in [false, nil] -> false
-        unquote(temp_var) -> unquote(temp_var)
+
+    quoted =
+      quote context: Kernel do
+        case 1 do
+          unquote(temp_var) when :"Elixir.Kernel".in(unquote(temp_var), [false, nil]) -> false
+          unquote(temp_var) -> unquote(temp_var)
+        end
       end
-    end)
+
+    assert expand_and_clean(quote(do: oror(1, false)), __ENV__) == quoted
   end
 
-  test :var do
-    assert Macro.var(:foo, nil) == {:foo, [], nil}
-    assert Macro.var(:foo, Other) == {:foo, [], Other}
+  test "expand_literals/2" do
+    assert Macro.expand_literals(quote(do: Foo), __ENV__) == Foo
+    assert Macro.expand_literals(quote(do: Foo + Bar), __ENV__) == quote(do: Foo + Bar)
+    assert Macro.expand_literals(quote(do: __MODULE__), __ENV__) == __MODULE__
+    assert Macro.expand_literals(quote(do: __MODULE__.Foo), __ENV__) == __MODULE__.Foo
+    assert Macro.expand_literals(quote(do: [Foo, 1 + 2]), __ENV__) == [Foo, quote(do: 1 + 2)]
   end
 
-  ## to_string
+  test "expand_literals/3" do
+    fun = fn node, acc ->
+      expanded = Macro.expand(node, __ENV__)
+      {expanded, [expanded | acc]}
+    end
 
-  test :var_to_string do
-    assert Macro.to_string(quote do: foo) == "foo"
-  end
+    assert Macro.expand_literals(quote(do: Foo), [], fun) == {Foo, [Foo]}
+    assert Macro.expand_literals(quote(do: Foo + Bar), [], fun) == {quote(do: Foo + Bar), []}
+    assert Macro.expand_literals(quote(do: __MODULE__), [], fun) == {__MODULE__, [__MODULE__]}
 
-  test :local_call_to_string do
-    assert Macro.to_string(quote do: foo(1, 2, 3)) == "foo(1, 2, 3)"
-    assert Macro.to_string(quote do: foo([1, 2, 3])) == "foo([1, 2, 3])"
+    assert Macro.expand_literals(quote(do: __MODULE__.Foo), [], fun) ==
+             {__MODULE__.Foo, [__MODULE__.Foo, __MODULE__]}
   end
 
-  test :remote_call_to_string do
-    assert Macro.to_string(quote do: foo.bar(1, 2, 3)) == "foo.bar(1, 2, 3)"
-    assert Macro.to_string(quote do: foo.bar([1, 2, 3])) == "foo.bar([1, 2, 3])"
+  test "var/2" do
+    assert Macro.var(:foo, nil) == {:foo, [], nil}
+    assert Macro.var(:foo, Other) == {:foo, [], Other}
   end
 
-  test :low_atom_remote_call_to_string do
-    assert Macro.to_string(quote do: :foo.bar(1, 2, 3)) == ":foo.bar(1, 2, 3)"
-  end
+  describe "dbg/3" do
+    defmacrop dbg_format_no_newline(ast, options \\ quote(do: [syntax_colors: []])) do
+      quote do
+        ExUnit.CaptureIO.with_io(fn ->
+          try do
+            unquote(Macro.dbg(ast, options, __CALLER__))
+          rescue
+            e -> e
+          end
+        end)
+      end
+    end
 
-  test :big_atom_remote_call_to_string do
-    assert Macro.to_string(quote do: Foo.Bar.bar(1, 2, 3)) == "Foo.Bar.bar(1, 2, 3)"
-  end
+    defmacrop dbg_format(ast, options \\ quote(do: [syntax_colors: []])) do
+      quote do
+        {result, formatted} =
+          dbg_format_no_newline(unquote(ast), unquote(options))
 
-  test :remote_and_fun_call_to_string do
-    assert Macro.to_string(quote do: foo.bar.(1, 2, 3)) == "foo.bar().(1, 2, 3)"
-    assert Macro.to_string(quote do: foo.bar.([1, 2, 3])) == "foo.bar().([1, 2, 3])"
-  end
+        # Make sure there's an empty line after the output.
+        assert String.ends_with?(formatted, "\n\n") or
+                 String.ends_with?(formatted, "\n\n" <> IO.ANSI.reset())
 
-  test :atom_call_to_string do
-    assert Macro.to_string(quote do: :foo.(1, 2, 3)) == ":foo.(1, 2, 3)"
-  end
+        {result, formatted}
+      end
+    end
 
-  test :aliases_call_to_string do
-    assert Macro.to_string(quote do: Foo.Bar.baz(1, 2, 3)) == "Foo.Bar.baz(1, 2, 3)"
-    assert Macro.to_string(quote do: Foo.Bar.baz([1, 2, 3])) == "Foo.Bar.baz([1, 2, 3])"
-  end
+    test "simple expression" do
+      {result, formatted} = dbg_format(1 + 1)
+      assert result == 2
+      assert formatted =~ "1 + 1 #=> 2"
+    end
 
-  test :arrow_to_string do
-    assert Macro.to_string(quote do: foo(1, (2 -> 3))) == "foo(1, (2 -> 3))"
-  end
+    test "variables" do
+      my_var = 1 + 1
+      {result, formatted} = dbg_format(my_var)
+      assert result == 2
+      assert formatted =~ "my_var #=> 2"
+    end
 
-  test :blocks_to_string do
-    assert Macro.to_string(quote do: (1; 2; (:foo; :bar); 3)) <> "\n" == """
-    (
-      1
-      2
-      (
-        :foo
-        :bar
-      )
-      3
-    )
-    """
+    test "function call" do
+      {result, formatted} = dbg_format(Atom.to_string(:foo))
+
+      assert result == "foo"
+      assert formatted =~ ~s[Atom.to_string(:foo) #=> "foo"]
+    end
+
+    test "multiline input" do
+      {result, formatted} =
+        dbg_format(
+          case 1 + 1 do
+            2 -> :two
+            _other -> :math_is_broken
+          end
+        )
+
+      assert result == :two
+
+      assert formatted =~ """
+             case 1 + 1 do
+               2 -> :two
+               _other -> :math_is_broken
+             end #=> :two
+             """
+    end
+
+    defp abc, do: [:a, :b, :c]
+
+    test "pipeline on a single line" do
+      {result, formatted} = dbg_format(abc() |> tl() |> tl |> Kernel.hd())
+      assert result == :c
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             \nabc() #=> [:a, :b, :c]
+             |> tl() #=> [:b, :c]
+             |> tl #=> [:c]
+             |> Kernel.hd() #=> :c
+             """
+
+      # Regression for pipes sometimes erroneously ending with three newlines (one
+      # extra than needed).
+      assert formatted =~ ~r/[^\n]\n\n$/
+    end
+
+    test "pipeline on multiple lines" do
+      {result, formatted} =
+        dbg_format(
+          abc()
+          |> tl()
+          |> tl
+          |> Kernel.hd()
+        )
+
+      assert result == :c
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             \nabc() #=> [:a, :b, :c]
+             |> tl() #=> [:b, :c]
+             |> tl #=> [:c]
+             |> Kernel.hd() #=> :c
+             """
+
+      # Regression for pipes sometimes erroneously ending with three newlines (one
+      # extra than needed).
+      assert formatted =~ ~r/[^\n]\n\n$/
+    end
+
+    test "pipeline on multiple lines that raises" do
+      {result, formatted} =
+        dbg_format_no_newline(
+          abc()
+          |> tl()
+          |> tl()
+          |> tl()
+          |> tl()
+        )
+
+      assert %ArgumentError{} = result
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             abc() #=> [:a, :b, :c]
+             |> tl() #=> [:b, :c]
+             |> tl() #=> [:c]
+             |> tl() #=> []
+             """
+    end
+
+    test "simple boolean expressions" do
+      {result, formatted} = dbg_format(:rand.uniform() < 0.0 and length([]) == 0)
+      assert result == false
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             :rand.uniform() < 0.0 #=> false
+             :rand.uniform() < 0.0 and length([]) == 0 #=> false
+             """
+    end
+
+    test "left-associative operators" do
+      {result, formatted} = dbg_format(List.first([]) || "yes" || raise("foo"))
+      assert result == "yes"
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             List.first([]) #=> nil
+             List.first([]) || "yes" #=> "yes"
+             List.first([]) || "yes" || raise "foo" #=> "yes"
+             """
+    end
+
+    test "composite boolean expressions" do
+      true1 = length([]) == 0
+      true2 = length([]) == 0
+      {result, formatted} = dbg_format((true1 and true2) or (List.first([]) || true1))
+
+      assert result == true
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             true1 #=> true
+             true1 and true2 #=> true
+             (true1 and true2) or (List.first([]) || true1) #=> true
+             """
+    end
+
+    test "boolean expressions that raise" do
+      falsy = length([]) != 0
+      x = 0
+
+      {result, formatted} = dbg_format_no_newline((falsy || x) && 1 / x)
+
+      assert %ArithmeticError{} = result
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             falsy #=> false
+             falsy || x #=> 0
+             """
+    end
+
+    test "block of code" do
+      {result, formatted} =
+        dbg_format(
+          (
+            a = 1
+            b = a + 2
+            a + b
+          )
+        )
+
+      assert result == 4
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             a = 1 #=> 1
+             b = a + 2 #=> 3
+             a + b #=> 4
+             """
+    end
+
+    test "block that raises" do
+      {result, formatted} =
+        dbg_format_no_newline(
+          (
+            a = 1
+            b = a - 1
+            a / b
+          )
+        )
+
+      assert result == %ArithmeticError{}
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             a = 1 #=> 1
+             b = a - 1 #=> 0
+             """
+    end
+
+    test "case" do
+      list = List.flatten([1, 2, 3])
+
+      {result, formatted} =
+        dbg_format(
+          case list do
+            [] -> nil
+            _ -> Enum.sum(list)
+          end
+        )
+
+      assert result == 6
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             Case argument:
+             list #=> [1, 2, 3]
+
+             Case expression (clause #2 matched):
+             case list do
+               [] -> nil
+               _ -> Enum.sum(list)
+             end #=> 6
+             """
+    end
+
+    test "case that raises" do
+      x = true
+
+      {result, formatted} =
+        dbg_format(
+          case true and x do
+            true -> raise "oops"
+            false -> :ok
+          end
+        )
+
+      assert %RuntimeError{} = result
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             Case argument:
+             true and x #=> true
+             """
+    end
+
+    test "case with guards" do
+      {result, formatted} =
+        dbg_format(
+          case 0..100//5 do
+            %{first: first, last: last, step: step} when last > first ->
+              count = div(last - first, step)
+              {:ok, count}
+
+            _ ->
+              :error
+          end
+        )
+
+      assert result == {:ok, 20}
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             Case argument:
+             0..100//5 #=> 0..100//5
+
+             Case expression (clause #1 matched):
+             case 0..100//5 do
+               %{first: first, last: last, step: step} when last > first ->
+                 count = div(last - first, step)
+                 {:ok, count}
+
+               _ ->
+                 :error
+             end #=> {:ok, 20}
+             """
+    end
+
+    test "cond" do
+      map = %{b: 5}
+
+      {result, formatted} =
+        dbg_format(
+          cond do
+            a = map[:a] -> a + 1
+            b = map[:b] -> b * 2
+            true -> nil
+          end
+        )
+
+      assert result == 10
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             Cond clause (clause #2 matched):
+             b = map[:b] #=> 5
+
+             Cond expression:
+             cond do
+               a = map[:a] -> a + 1
+               b = map[:b] -> b * 2
+               true -> nil
+             end #=> 10
+             """
+    end
+
+    test "if expression" do
+      x = true
+      map = %{a: 5, b: 1}
+
+      {result, formatted} =
+        dbg_format(
+          if true and x do
+            map[:a] * 2
+          else
+            map[:b]
+          end
+        )
+
+      assert result == 10
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             If condition:
+             true and x #=> true
+
+             If expression:
+             if true and x do
+               map[:a] * 2
+             else
+               map[:b]
+             end #=> 10
+             """
+    end
+
+    test "if expression that raises" do
+      x = true
+
+      {result, formatted} =
+        dbg_format(
+          if true and x do
+            raise "oops"
+          end
+        )
+
+      assert %RuntimeError{} = result
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             If condition:
+             true and x #=> true
+             """
+    end
+
+    test "if expression without else" do
+      x = true
+      map = %{a: 5, b: 1}
+
+      {result, formatted} =
+        dbg_format(
+          if false and x do
+            map[:a] * 2
+          end
+        )
+
+      assert result == nil
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             If condition:
+             false and x #=> false
+
+             If expression:
+             if false and x do
+               map[:a] * 2
+             end #=> nil
+             """
+    end
+
+    test "custom if definition" do
+      import Kernel, except: [if: 2]
+      import CustomIf, only: [if: 2]
+
+      {result, formatted} =
+        dbg_format(
+          if true do
+            "something"
+          end
+        )
+
+      assert result == "custom if result"
+
+      assert formatted =~ """
+             if true do
+               "something"
+             end #=> "custom if result"
+             """
+    end
+
+    test "with/1 (all clauses match)" do
+      opts = %{width: 10, height: 15}
+
+      {result, formatted} =
+        dbg_format(
+          with {:ok, width} <- Map.fetch(opts, :width),
+               double_width = width * 2,
+               IO.puts("just a side effect"),
+               {:ok, height} <- Map.fetch(opts, :height) do
+            {:ok, double_width * height}
+          end
+        )
+
+      assert result == {:ok, 300}
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             With clauses:
+             Map.fetch(opts, :width) #=> {:ok, 10}
+             width * 2 #=> 20
+             Map.fetch(opts, :height) #=> {:ok, 15}
+
+             With expression:
+             with {:ok, width} <- Map.fetch(opts, :width),
+                  double_width = width * 2,
+                  IO.puts("just a side effect"),
+                  {:ok, height} <- Map.fetch(opts, :height) do
+               {:ok, double_width * height}
+             end #=> {:ok, 300}
+             """
+    end
+
+    test "with/1 (no else)" do
+      opts = %{width: 10}
+
+      {result, formatted} =
+        dbg_format(
+          with {:ok, width} <- Map.fetch(opts, :width),
+               {:ok, height} <- Map.fetch(opts, :height) do
+            {:ok, width * height}
+          end
+        )
+
+      assert result == :error
+
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             With clauses:
+             Map.fetch(opts, :width) #=> {:ok, 10}
+             Map.fetch(opts, :height) #=> :error
+
+             With expression:
+             with {:ok, width} <- Map.fetch(opts, :width),
+                  {:ok, height} <- Map.fetch(opts, :height) do
+               {:ok, width * height}
+             end #=> :error
+             """
+    end
+
+    test "with/1 (else clause)" do
+      opts = %{width: 10}
+
+      {result, formatted} =
+        dbg_format(
+          with {:ok, width} <- Map.fetch(opts, :width),
+               {:ok, height} <- Map.fetch(opts, :height) do
+            width * height
+          else
+            :error -> 0
+          end
+        )
+
+      assert result == 0
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             With clauses:
+             Map.fetch(opts, :width) #=> {:ok, 10}
+             Map.fetch(opts, :height) #=> :error
+
+             With expression:
+             with {:ok, width} <- Map.fetch(opts, :width),
+                  {:ok, height} <- Map.fetch(opts, :height) do
+               width * height
+             else
+               :error -> 0
+             end #=> 0
+             """
+    end
+
+    test "with/1 (guard)" do
+      opts = %{width: 10, height: 0.0}
+
+      {result, formatted} =
+        dbg_format(
+          with {:ok, width} when is_integer(width) <- Map.fetch(opts, :width),
+               {:ok, height} when is_integer(height) <- Map.fetch(opts, :height) do
+            width * height
+          else
+            _ -> nil
+          end
+        )
+
+      assert result == nil
+      assert formatted =~ "macro_test.exs"
+
+      assert formatted =~ """
+             With clauses:
+             Map.fetch(opts, :width) #=> {:ok, 10}
+             Map.fetch(opts, :height) #=> {:ok, 0.0}
+
+             With expression:
+             with {:ok, width} when is_integer(width) <- Map.fetch(opts, :width),
+                  {:ok, height} when is_integer(height) <- Map.fetch(opts, :height) do
+               width * height
+             else
+               _ -> nil
+             end #=> nil
+             """
+    end
+
+    test "with/1 (guard in else)" do
+      opts = %{}
+
+      {result, _formatted} =
+        dbg_format(
+          with {:ok, width} <- Map.fetch(opts, :width) do
+            width
+          else
+            other when is_integer(other) -> :int
+            other when is_atom(other) -> :atom
+          end
+        )
+
+      assert result == :atom
+    end
+
+    test "with/1 respects the WithClauseError" do
+      value = Enum.random([:unexpected])
+
+      error =
+        assert_raise WithClauseError, fn ->
+          ExUnit.CaptureIO.capture_io(fn ->
+            dbg(
+              with :ok <- value do
+                true
+              else
+                :error -> false
+              end
+            )
+          end)
+        end
+
+      assert error.term == :unexpected
+    end
+
+    test "with \"syntax_colors: []\" it doesn't print any color sequences" do
+      {_result, formatted} = dbg_format("hello")
+      refute formatted =~ "\e["
+    end
+
+    test "with \"syntax_colors: [...]\" it forces color sequences" do
+      {_result, formatted} = dbg_format("hello", syntax_colors: [string: :cyan])
+      assert formatted =~ IO.iodata_to_binary(IO.ANSI.format([:cyan, ~s("hello")]))
+    end
+
+    test "forwards options to the underlying inspect calls" do
+      value = ~c"hello"
+      assert {^value, formatted} = dbg_format(value, syntax_colors: [], charlists: :as_lists)
+      assert formatted =~ "value #=> [104, 101, 108, 108, 111]\n"
+    end
+
+    test "with the :print_location option set to false, doesn't print any header" do
+      {result, formatted} = dbg_format("hello", print_location: false)
+      assert result == "hello"
+      refute formatted =~ Path.basename(__ENV__.file)
+    end
   end
 
-  test :if_else_to_string do
-    assert Macro.to_string(quote do: (if foo, do: bar, else: baz)) <> "\n" == """
-    if(foo) do
-      bar
-    else
-      baz
+  describe "to_string/1" do
+    test "converts quoted to string" do
+      assert Macro.to_string(quote do: hello(world)) == "hello(world)"
+    end
+
+    test "converts invalid AST with inspect" do
+      assert Macro.to_string(1..3) == "1..3"
     end
-    """
   end
 
-  test :case_to_string do
-    assert Macro.to_string(quote do: (case foo do true -> 0; false -> (1; 2) end)) <> "\n" == """
-    case(foo) do
-      true ->
-        0
-      false ->
+  describe "to_string/2" do
+    defp macro_to_string(var, fun \\ fn _ast, string -> string end) do
+      module = String.to_atom("Elixir.Macro")
+      module.to_string(var, fun)
+    end
+
+    test "variable" do
+      assert macro_to_string(quote(do: foo)) == "foo"
+    end
+
+    test "local call" do
+      assert macro_to_string(quote(do: foo(1, 2, 3))) == "foo(1, 2, 3)"
+      assert macro_to_string(quote(do: foo([1, 2, 3]))) == "foo([1, 2, 3])"
+    end
+
+    test "remote call" do
+      assert macro_to_string(quote(do: foo.bar(1, 2, 3))) == "foo.bar(1, 2, 3)"
+      assert macro_to_string(quote(do: foo.bar([1, 2, 3]))) == "foo.bar([1, 2, 3])"
+
+      quoted =
+        quote do
+          (foo do
+             :ok
+           end).bar([1, 2, 3])
+        end
+
+      assert macro_to_string(quoted) == "(foo do\n  :ok\nend).bar([1, 2, 3])"
+    end
+
+    test "nullary remote call" do
+      assert macro_to_string(quote do: foo.bar) == "foo.bar"
+      assert macro_to_string(quote do: foo.bar()) == "foo.bar()"
+    end
+
+    test "atom remote call" do
+      assert macro_to_string(quote(do: :foo.bar(1, 2, 3))) == ":foo.bar(1, 2, 3)"
+    end
+
+    test "remote and fun call" do
+      assert macro_to_string(quote(do: foo.bar().(1, 2, 3))) == "foo.bar().(1, 2, 3)"
+      assert macro_to_string(quote(do: foo.bar().([1, 2, 3]))) == "foo.bar().([1, 2, 3])"
+    end
+
+    test "unusual remote atom fun call" do
+      assert macro_to_string(quote(do: Foo."42"())) == ~s/Foo."42"()/
+      assert macro_to_string(quote(do: Foo."Bar"())) == ~s/Foo."Bar"()/
+      assert macro_to_string(quote(do: Foo."bar baz"().""())) == ~s/Foo."bar baz"().""()/
+      assert macro_to_string(quote(do: Foo."%{}"())) == ~s/Foo."%{}"()/
+      assert macro_to_string(quote(do: Foo."..."())) == ~s/Foo."..."()/
+    end
+
+    test "atom fun call" do
+      assert macro_to_string(quote(do: :foo.(1, 2, 3))) == ":foo.(1, 2, 3)"
+    end
+
+    test "aliases call" do
+      assert macro_to_string(quote(do: Elixir)) == "Elixir"
+      assert macro_to_string(quote(do: Foo)) == "Foo"
+      assert macro_to_string(quote(do: Foo.Bar.baz(1, 2, 3))) == "Foo.Bar.baz(1, 2, 3)"
+      assert macro_to_string(quote(do: Foo.Bar.baz([1, 2, 3]))) == "Foo.Bar.baz([1, 2, 3])"
+      assert macro_to_string(quote(do: Foo.bar(<<>>, []))) == "Foo.bar(<<>>, [])"
+    end
+
+    test "keyword call" do
+      assert macro_to_string(quote(do: Foo.bar(foo: :bar))) == "Foo.bar(foo: :bar)"
+      assert macro_to_string(quote(do: Foo.bar("Elixir.Foo": :bar))) == "Foo.bar([{Foo, :bar}])"
+    end
+
+    test "sigil call" do
+      assert macro_to_string(quote(do: ~r"123")) == ~S/~r"123"/
+      assert macro_to_string(quote(do: ~r"\n123")) == ~S/~r"\n123"/
+      assert macro_to_string(quote(do: ~r"12\"3")) == ~S/~r"12\"3"/
+      assert macro_to_string(quote(do: ~r/12\/3/u)) == ~S"~r/12\/3/u"
+      assert macro_to_string(quote(do: ~r{\n123})) == ~S/~r{\n123}/
+      assert macro_to_string(quote(do: ~r((1\)(2\)3))) == ~S/~r((1\)(2\)3)/
+      assert macro_to_string(quote(do: ~r{\n1{1\}23})) == ~S/~r{\n1{1\}23}/
+      assert macro_to_string(quote(do: ~r|12\|3|)) == ~S"~r|12\|3|"
+
+      assert macro_to_string(quote(do: ~r[1#{two}3])) == ~S/~r[1#{two}3]/
+      assert macro_to_string(quote(do: ~r[1[#{two}\]3])) == ~S/~r[1[#{two}\]3]/
+      assert macro_to_string(quote(do: ~r'1#{two}3'u)) == ~S/~r'1#{two}3'u/
+
+      assert macro_to_string(quote(do: ~R"123")) == ~S/~R"123"/
+      assert macro_to_string(quote(do: ~R"123"u)) == ~S/~R"123"u/
+      assert macro_to_string(quote(do: ~R"\n123")) == ~S/~R"\n123"/
+
+      assert macro_to_string(quote(do: ~S["'(123)'"])) == ~S/~S["'(123)'"]/
+      assert macro_to_string(quote(do: ~s"#{"foo"}")) == ~S/~s"#{"foo"}"/
+
+      assert macro_to_string(quote(do: ~HTML[hi])) == ~S/~HTML[hi]/
+
+      assert macro_to_string(
+               quote do
+                 ~s"""
+                 "\""foo"\""
+                 """
+               end
+             ) == ~s[~s"""\n"\\""foo"\\""\n"""]
+
+      assert macro_to_string(
+               quote do
+                 ~s'''
+                 '\''foo'\''
+                 '''
+               end
+             ) == ~s[~s'''\n'\\''foo'\\''\n''']
+
+      assert macro_to_string(
+               quote do
+                 ~s"""
+                 "\"foo\""
+                 """
+               end
+             ) == ~s[~s"""\n"\\"foo\\""\n"""]
+
+      assert macro_to_string(
+               quote do
+                 ~s'''
+                 '\"foo\"'
+                 '''
+               end
+             ) == ~s[~s'''\n'\\"foo\\"'\n''']
+
+      assert macro_to_string(
+               quote do
+                 ~S"""
+                 "123"
+                 """
+               end
+             ) == ~s[~S"""\n"123"\n"""]
+
+      assert macro_to_string(
+               quote do
+                 ~HTML"""
+                 "123"
+                 """
+               end
+             ) == ~s[~HTML"""\n"123"\n"""]
+    end
+
+    test "tuple call" do
+      assert macro_to_string(quote(do: alias(Foo.{Bar, Baz, Bong}))) ==
+               "alias(Foo.{Bar, Baz, Bong})"
+
+      assert macro_to_string(quote(do: foo(Foo.{}))) == "foo(Foo.{})"
+    end
+
+    test "arrow" do
+      assert macro_to_string(quote(do: foo(1, (2 -> 3)))) == "foo(1, (2 -> 3))"
+    end
+
+    test "block" do
+      quoted =
+        quote do
+          1
+          2
+
+          (
+            :foo
+            :bar
+          )
+
+          3
+        end
+
+      expected = """
+      (
         1
         2
+        (
+          :foo
+          :bar
+        )
+        3
+      )
+      """
+
+      assert macro_to_string(quoted) <> "\n" == expected
+    end
+
+    test "not in" do
+      assert macro_to_string(quote(do: false not in [])) == "false not in []"
     end
-    """
-  end
 
-  test :fn_to_string do
-    assert Macro.to_string(quote do: (fn -> 1 + 2 end)) == "fn -> 1 + 2 end"
-    assert Macro.to_string(quote do: (fn(x) -> x + 1 end)) == "fn x -> x + 1 end"
+    test "if else" do
+      expected = """
+      if(foo) do
+        bar
+      else
+        baz
+      end
+      """
 
-    assert Macro.to_string(quote do: (fn(x) -> y = x + 1; y end)) <> "\n" == """
-    fn x ->
-      y = x + 1
-      y
+      assert macro_to_string(quote(do: if(foo, do: bar, else: baz))) <> "\n" == expected
     end
-    """
 
-    assert Macro.to_string(quote do: (fn(x) -> y = x + 1; y; (z) -> z end)) <> "\n" == """
-    fn
-      x ->
+    test "case" do
+      quoted =
+        quote do
+          case foo do
+            true ->
+              0
+
+            false ->
+              1
+              2
+          end
+        end
+
+      expected = """
+      case(foo) do
+        true ->
+          0
+        false ->
+          1
+          2
+      end
+      """
+
+      assert macro_to_string(quoted) <> "\n" == expected
+    end
+
+    test "try" do
+      quoted =
+        quote do
+          try do
+            foo
+          catch
+            _, _ ->
+              2
+          rescue
+            ArgumentError ->
+              1
+          after
+            4
+          else
+            _ ->
+              3
+          end
+        end
+
+      expected = """
+      try do
+        foo
+      rescue
+        ArgumentError ->
+          1
+      catch
+        _, _ ->
+          2
+      else
+        _ ->
+          3
+      after
+        4
+      end
+      """
+
+      assert macro_to_string(quoted) <> "\n" == expected
+    end
+
+    test "fn" do
+      assert macro_to_string(quote(do: fn -> 1 + 2 end)) == "fn -> 1 + 2 end"
+      assert macro_to_string(quote(do: fn x -> x + 1 end)) == "fn x -> x + 1 end"
+
+      quoted =
+        quote do
+          fn x ->
+            y = x + 1
+            y
+          end
+        end
+
+      expected = """
+      fn x ->
         y = x + 1
         y
-      z ->
-        z
+      end
+      """
+
+      assert macro_to_string(quoted) <> "\n" == expected
+
+      quoted =
+        quote do
+          fn
+            x ->
+              y = x + 1
+              y
+
+            z ->
+              z
+          end
+        end
+
+      expected = """
+      fn
+        x ->
+          y = x + 1
+          y
+        z ->
+          z
+      end
+      """
+
+      assert macro_to_string(quoted) <> "\n" == expected
+
+      assert macro_to_string(quote(do: (fn x -> x end).(1))) == "(fn x -> x end).(1)"
+
+      quoted =
+        quote do
+          (fn
+             %{} -> :map
+             _ -> :other
+           end).(1)
+        end
+
+      expected = """
+      (fn
+        %{} ->
+          :map
+        _ ->
+          :other
+      end).(1)
+      """
+
+      assert macro_to_string(quoted) <> "\n" == expected
     end
-    """
-  end
 
-  test :when do
-    assert Macro.to_string(quote do: (() -> x)) == "(() -> x)"
-    assert Macro.to_string(quote do: (x when y -> z)) == "(x when y -> z)"
-    assert Macro.to_string(quote do: (x, y when z -> w)) == "((x, y) when z -> w)"
-    assert Macro.to_string(quote do: ((x, y) when z -> w)) == "((x, y) when z -> w)"
-  end
+    test "range" do
+      assert macro_to_string(quote(do: -1..+2)) == "-1..+2"
+      assert macro_to_string(quote(do: Foo.integer()..3)) == "Foo.integer()..3"
+      assert macro_to_string(quote(do: -1..+2//-3)) == "-1..+2//-3"
+
+      assert macro_to_string(quote(do: Foo.integer()..3//Bar.bat())) ==
+               "Foo.integer()..3//Bar.bat()"
+
+      # invalid AST
+      assert macro_to_string(-1..+2) == "-1..2"
+      assert macro_to_string(-1..+2//-3) == "-1..2//-3"
+    end
+
+    test "when" do
+      assert macro_to_string(quote(do: (-> x))) == "(() -> x)"
+      assert macro_to_string(quote(do: (x when y -> z))) == "(x when y -> z)"
+      assert macro_to_string(quote(do: (x, y when z -> w))) == "((x, y) when z -> w)"
+      assert macro_to_string(quote(do: (x, y when z -> w))) == "((x, y) when z -> w)"
+    end
 
-  test :nested_to_string do
-    assert Macro.to_string(quote do: (defmodule Foo do def foo do 1 + 1 end end)) <> "\n" == """
-    defmodule(Foo) do
-      def(foo) do
-        1 + 1
+    test "nested" do
+      quoted =
+        quote do
+          defmodule Foo do
+            def foo do
+              1 + 1
+            end
+          end
+        end
+
+      expected = """
+      defmodule(Foo) do
+        def(foo) do
+          1 + 1
+        end
       end
+      """
+
+      assert macro_to_string(quoted) <> "\n" == expected
     end
-    """
-  end
 
-  test :op_precedence_to_string do
-    assert Macro.to_string(quote do: (1 + 2) * (3 - 4)) == "(1 + 2) * (3 - 4)"
-    assert Macro.to_string(quote do: ((1 + 2) * 3) - 4) == "(1 + 2) * 3 - 4"
-    assert Macro.to_string(quote do: (1 + 2 + 3) == "(1 + 2 + 3)")
-    assert Macro.to_string(quote do: (1 + 2 - 3) == "(1 + 2 - 3)")
-  end
+    test "operator precedence" do
+      assert macro_to_string(quote(do: (1 + 2) * (3 - 4))) == "(1 + 2) * (3 - 4)"
+      assert macro_to_string(quote(do: (1 + 2) * 3 - 4)) == "(1 + 2) * 3 - 4"
+      assert macro_to_string(quote(do: 1 + 2 + 3)) == "1 + 2 + 3"
+      assert macro_to_string(quote(do: 1 + 2 - 3)) == "1 + 2 - 3"
+    end
 
-  test :containers_to_string do
-    assert Macro.to_string(quote do: {})   == "{}"
-    assert Macro.to_string(quote do: [])   == "[]"
-    assert Macro.to_string(quote do: {1, 2, 3})   == "{1, 2, 3}"
-    assert Macro.to_string(quote do: [ 1, 2, 3 ])   == "[1, 2, 3]"
-    assert Macro.to_string(quote do: %{})  == "%{}"
-    assert Macro.to_string(quote do: %{:foo => :bar})  == "%{foo: :bar}"
-    assert Macro.to_string(quote do: %{{1,2} => [1,2,3]})  == "%{{1, 2} => [1, 2, 3]}"
-    assert Macro.to_string(quote do: %{map | "a" => "b"})  == "%{map | \"a\" => \"b\"}"
-    assert Macro.to_string(quote do: [ 1, 2, 3 ])   == "[1, 2, 3]"
-    assert Macro.to_string(quote do: << 1, 2, 3 >>) == "<<1, 2, 3>>"
-    assert Macro.to_string(quote do: << <<1>> >>) == "<< <<1>> >>"
-  end
+    test "capture operator" do
+      assert macro_to_string(quote(do: &foo/0)) == "&foo/0"
+      assert macro_to_string(quote(do: &Foo.foo/0)) == "&Foo.foo/0"
+      assert macro_to_string(quote(do: &(&1 + &2))) == "&(&1 + &2)"
+      assert macro_to_string(quote(do: & &1)) == "&(&1)"
+      assert macro_to_string(quote(do: & &1.(:x))) == "&(&1.(:x))"
+      assert macro_to_string(quote(do: (& &1).(:x))) == "(&(&1)).(:x)"
+    end
 
-  test :struct_to_string do
-    assert Macro.to_string(quote do: %Test{})  == "%Test{}"
-    assert Macro.to_string(quote do: %Test{foo: 1, bar: 1})  == "%Test{foo: 1, bar: 1}"
-    assert Macro.to_string(quote do: %Test{struct | foo: 2})  == "%Test{struct | foo: 2}"
-    assert Macro.to_string(quote do: %Test{} + 1)  == "%Test{} + 1"
-  end
+    test "containers" do
+      assert macro_to_string(quote(do: {})) == "{}"
+      assert macro_to_string(quote(do: [])) == "[]"
+      assert macro_to_string(quote(do: {1, 2, 3})) == "{1, 2, 3}"
+      assert macro_to_string(quote(do: [1, 2, 3])) == "[1, 2, 3]"
+      assert macro_to_string(quote(do: ["Elixir.Foo": :bar])) == "[{Foo, :bar}]"
+      assert macro_to_string(quote(do: %{})) == "%{}"
+      assert macro_to_string(quote(do: %{:foo => :bar})) == "%{foo: :bar}"
+      assert macro_to_string(quote(do: %{:"Elixir.Foo" => :bar})) == "%{Foo => :bar}"
+      assert macro_to_string(quote(do: %{{1, 2} => [1, 2, 3]})) == "%{{1, 2} => [1, 2, 3]}"
+      assert macro_to_string(quote(do: %{map | "a" => "b"})) == "%{map | \"a\" => \"b\"}"
+      assert macro_to_string(quote(do: [1, 2, 3])) == "[1, 2, 3]"
+    end
 
-  test :binary_ops_to_string do
-    assert Macro.to_string(quote do: 1 + 2)   == "1 + 2"
-    assert Macro.to_string(quote do: [ 1, 2 | 3 ]) == "[1, 2 | 3]"
-    assert Macro.to_string(quote do: [h|t] = [1, 2, 3]) == "[h | t] = [1, 2, 3]"
-    assert Macro.to_string(quote do: (x ++ y) ++ z) == "(x ++ y) ++ z"
-  end
+    test "struct" do
+      assert macro_to_string(quote(do: %Test{})) == "%Test{}"
+      assert macro_to_string(quote(do: %Test{foo: 1, bar: 1})) == "%Test{foo: 1, bar: 1}"
+      assert macro_to_string(quote(do: %Test{struct | foo: 2})) == "%Test{struct | foo: 2}"
+      assert macro_to_string(quote(do: %Test{} + 1)) == "%Test{} + 1"
+      assert macro_to_string(quote(do: %Test{foo(1)} + 2)) == "%Test{foo(1)} + 2"
+    end
 
-  test :unary_ops_to_string do
-    assert Macro.to_string(quote do: not 1) == "not 1"
-    assert Macro.to_string(quote do: not foo) == "not foo"
-    assert Macro.to_string(quote do: -1) == "-1"
-    assert Macro.to_string(quote do: !(foo > bar)) == "!(foo > bar)"
-    assert Macro.to_string(quote do: @foo(bar)) == "@foo(bar)"
-    assert Macro.to_string(quote do: identity(&1)) == "identity(&1)"
-    assert Macro.to_string(quote do: identity(&foo)) == "identity(&foo)"
-  end
+    test "binary operators" do
+      assert macro_to_string(quote(do: 1 + 2)) == "1 + 2"
+      assert macro_to_string(quote(do: [1, 2 | 3])) == "[1, 2 | 3]"
+      assert macro_to_string(quote(do: [h | t] = [1, 2, 3])) == "[h | t] = [1, 2, 3]"
+      assert macro_to_string(quote(do: (x ++ y) ++ z)) == "(x ++ y) ++ z"
+      assert macro_to_string(quote(do: (x +++ y) +++ z)) == "(x +++ y) +++ z"
+    end
 
-  test :access_to_string do
-    assert Macro.to_string(quote do: a[b]) == "a[b]"
-    assert Macro.to_string(quote do: a[1 + 2]) == "a[1 + 2]"
-  end
+    test "unary operators" do
+      assert macro_to_string(quote(do: not 1)) == "not(1)"
+      assert macro_to_string(quote(do: not foo)) == "not(foo)"
+      assert macro_to_string(quote(do: -1)) == "-1"
+      assert macro_to_string(quote(do: +(+1))) == "+(+1)"
+      assert macro_to_string(quote(do: !(foo > bar))) == "!(foo > bar)"
+      assert macro_to_string(quote(do: @foo(bar))) == "@foo(bar)"
+      assert macro_to_string(quote(do: identity(&1))) == "identity(&1)"
+    end
 
-  test :kw_list do
-    assert Macro.to_string(quote do: [a: a, b: b]) == "[a: a, b: b]"
-    assert Macro.to_string(quote do: [a: 1, b: 1 + 2]) == "[a: 1, b: 1 + 2]"
-    assert Macro.to_string(quote do: ["a.b": 1, c: 1 + 2]) == "[\"a.b\": 1, c: 1 + 2]"
-  end
+    test "access" do
+      assert macro_to_string(quote(do: a[b])) == "a[b]"
+      assert macro_to_string(quote(do: a[1 + 2])) == "a[1 + 2]"
+      assert macro_to_string(quote(do: (a || [a: 1])[:a])) == "(a || [a: 1])[:a]"
+      assert macro_to_string(quote(do: Map.put(%{}, :a, 1)[:a])) == "Map.put(%{}, :a, 1)[:a]"
+    end
 
-  test :string_list do
-    assert Macro.to_string(quote do: []) == "[]"
-    assert Macro.to_string(quote do: 'abc') == "'abc'"
-  end
+    test "keyword list" do
+      assert macro_to_string(quote(do: [a: a, b: b])) == "[a: a, b: b]"
+      assert macro_to_string(quote(do: [a: 1, b: 1 + 2])) == "[a: 1, b: 1 + 2]"
+      assert macro_to_string(quote(do: ["a.b": 1, c: 1 + 2])) == "[\"a.b\": 1, c: 1 + 2]"
+    end
 
-  test :last_arg_kw_list do
-    assert Macro.to_string(quote do: foo([])) == "foo([])"
-    assert Macro.to_string(quote do: foo(x: y)) == "foo(x: y)"
-    assert Macro.to_string(quote do: foo(x: 1 + 2)) == "foo(x: 1 + 2)"
-    assert Macro.to_string(quote do: foo(x: y, p: q)) == "foo(x: y, p: q)"
-    assert Macro.to_string(quote do: foo(a, x: y, p: q)) == "foo(a, x: y, p: q)"
+    test "interpolation" do
+      assert macro_to_string(quote(do: "foo#{bar}baz")) == ~S["foo#{bar}baz"]
+    end
 
-    assert Macro.to_string(quote do: {[]}) == "{[]}"
-    assert Macro.to_string(quote do: {[a: b]}) == "{[a: b]}"
-    assert Macro.to_string(quote do: {x, a: b}) == "{x, [a: b]}"
-  end
+    test "bit syntax" do
+      ast = quote(do: <<1::8*4>>)
+      assert macro_to_string(ast) == "<<1::8*4>>"
 
-  test :to_string_with_fun do
-    assert Macro.to_string(quote(do: foo(1, 2, 3)), fn _, string -> ":#{string}:" end) ==
-           ":foo(:1:, :2:, :3:):"
+      ast = quote(do: @type(foo :: <<_::8, _::_*4>>))
+      assert macro_to_string(ast) == "@type(foo :: <<_::8, _::_*4>>)"
 
-    assert Macro.to_string(quote(do: Bar.foo(1, 2, 3)), fn _, string -> ":#{string}:" end) ==
-           "::Bar:.foo(:1:, :2:, :3:):"
-  end
+      ast = quote(do: <<69 - 4::bits-size(8 - 4)-unit(1), 65>>)
+      assert macro_to_string(ast) == "<<69 - 4::bits-size(8 - 4)-unit(1), 65>>"
 
-  ## decompose_call
-
-  test :decompose_call do
-    assert Macro.decompose_call(quote do: foo)        == {:foo, []}
-    assert Macro.decompose_call(quote do: foo())      == {:foo, []}
-    assert Macro.decompose_call(quote do: foo(1, 2, 3)) == {:foo, [1, 2, 3]}
-    assert Macro.decompose_call(quote do: M.N.foo(1, 2, 3)) ==
-           {{:__aliases__, [alias: false], [:M, :N]}, :foo, [1, 2, 3]}
-    assert Macro.decompose_call(quote do: :foo.foo(1, 2, 3)) ==
-           {:foo, :foo, [1, 2, 3]}
-    assert Macro.decompose_call(quote do: 1.(1, 2, 3))  == :error
-    assert Macro.decompose_call(quote do: "some string")  == :error
-  end
+      ast = quote(do: <<(<<65>>), 65>>)
+      assert macro_to_string(ast) == "<<(<<65>>), 65>>"
+
+      ast = quote(do: <<65, (<<65>>)>>)
+      assert macro_to_string(ast) == "<<65, (<<65>>)>>"
 
-  ## env
+      ast = quote(do: for(<<(a::4 <- <<1, 2>>)>>, do: a))
+      assert macro_to_string(ast) == "for(<<(a :: 4 <- <<1, 2>>)>>) do\n  a\nend"
+    end
+
+    test "charlist" do
+      assert macro_to_string(quote(do: [])) == "[]"
+      assert macro_to_string(quote(do: ~c"abc")) == ~S/~c"abc"/
+      assert macro_to_string(quote(do: [?a, ?b, ?c])) == ~S/~c"abc"/
+    end
 
-  test :env_stacktrace do
-    env = %{__ENV__ | file: "foo", line: 12}
-    assert Macro.Env.stacktrace(env) ==
-           [{__MODULE__, :"test env_stacktrace", 1, [file: "foo", line: 12]}]
+    test "string" do
+      assert macro_to_string(quote(do: "")) == ~S/""/
+      assert macro_to_string(quote(do: "abc")) == ~S/"abc"/
+      assert macro_to_string(quote(do: "#{"abc"}")) == ~S/"#{"abc"}"/
+    end
 
-    env = %{env | function: nil}
-    assert Macro.Env.stacktrace(env) ==
-           [{__MODULE__, :__MODULE__, 0, [file: "foo", line: 12]}]
+    test "last arg keyword list" do
+      assert macro_to_string(quote(do: foo([]))) == "foo([])"
+      assert macro_to_string(quote(do: foo(x: y))) == "foo(x: y)"
+      assert macro_to_string(quote(do: foo(x: 1 + 2))) == "foo(x: 1 + 2)"
+      assert macro_to_string(quote(do: foo(x: y, p: q))) == "foo(x: y, p: q)"
+      assert macro_to_string(quote(do: foo(a, x: y, p: q))) == "foo(a, x: y, p: q)"
+
+      assert macro_to_string(quote(do: {[]})) == "{[]}"
+      assert macro_to_string(quote(do: {[a: b]})) == "{[a: b]}"
+      assert macro_to_string(quote(do: {x, a: b})) == "{x, [a: b]}"
+      assert macro_to_string(quote(do: foo(else: a))) == "foo(else: a)"
+      assert macro_to_string(quote(do: foo(catch: a))) == "foo(catch: a)"
+    end
 
-    env = %{env | module: nil}
-    assert Macro.Env.stacktrace(env) ==
-           [{:elixir_compiler, :__FILE__, 1, [file: "foo", line: 12]}]
-  end
+    test "with fun" do
+      assert macro_to_string(quote(do: foo(1, 2, 3)), fn _, string -> ":#{string}:" end) ==
+               ":foo(:1:, :2:, :3:):"
 
-  test :context_modules do
-    defmodule Foo.Bar do
-      assert __MODULE__ in __ENV__.context_modules
+      assert macro_to_string(quote(do: Bar.foo(1, 2, 3)), fn _, string -> ":#{string}:" end) ==
+               "::Bar:.foo(:1:, :2:, :3:):"
     end
   end
 
+  test "validate/1" do
+    ref = make_ref()
+
+    assert Macro.validate(1) == :ok
+    assert Macro.validate(1.0) == :ok
+    assert Macro.validate(:foo) == :ok
+    assert Macro.validate("bar") == :ok
+    assert Macro.validate(<<0::8>>) == :ok
+    assert Macro.validate(self()) == :ok
+    assert Macro.validate({1, 2}) == :ok
+    assert Macro.validate({:foo, [], :baz}) == :ok
+    assert Macro.validate({:foo, [], []}) == :ok
+    assert Macro.validate([1, 2, 3]) == :ok
+
+    assert Macro.validate(<<0::4>>) == {:error, <<0::4>>}
+    assert Macro.validate(ref) == {:error, ref}
+    assert Macro.validate({1, ref}) == {:error, ref}
+    assert Macro.validate({ref, 2}) == {:error, ref}
+    assert Macro.validate([1, ref, 3]) == {:error, ref}
+    assert Macro.validate({:foo, [], 0}) == {:error, {:foo, [], 0}}
+    assert Macro.validate({:foo, 0, []}) == {:error, {:foo, 0, []}}
+  end
+
+  test "decompose_call/1" do
+    assert Macro.decompose_call(quote(do: foo)) == {:foo, []}
+    assert Macro.decompose_call(quote(do: foo())) == {:foo, []}
+    assert Macro.decompose_call(quote(do: foo(1, 2, 3))) == {:foo, [1, 2, 3]}
+
+    assert Macro.decompose_call(quote(do: M.N.foo(1, 2, 3))) ==
+             {{:__aliases__, [alias: false], [:M, :N]}, :foo, [1, 2, 3]}
+
+    assert Macro.decompose_call(quote(do: :foo.foo(1, 2, 3))) == {:foo, :foo, [1, 2, 3]}
+    assert Macro.decompose_call(quote(do: 1.(1, 2, 3))) == :error
+    assert Macro.decompose_call(quote(do: "some string")) == :error
+    assert Macro.decompose_call(quote(do: {:foo, :bar, :baz})) == :error
+    assert Macro.decompose_call(quote(do: {:foo, :bar, :baz, 42})) == :error
+  end
+
   ## pipe/unpipe
 
-  test :pipe do
+  test "pipe/3" do
     assert Macro.pipe(1, quote(do: foo), 0) == quote(do: foo(1))
     assert Macro.pipe(1, quote(do: foo(2)), 0) == quote(do: foo(1, 2))
     assert Macro.pipe(1, quote(do: foo), -1) == quote(do: foo(1))
     assert Macro.pipe(2, quote(do: foo(1)), -1) == quote(do: foo(1, 2))
 
-    assert_raise ArgumentError, "cannot pipe 1 into 2", fn ->
+    assert Macro.pipe(quote(do: %{foo: "bar"}), quote(do: Access.get(:foo)), 0) ==
+             quote(do: Access.get(%{foo: "bar"}, :foo))
+
+    assert_raise ArgumentError, ~r"cannot pipe 1 into 2", fn ->
       Macro.pipe(1, 2, 0)
     end
+
+    assert_raise ArgumentError, ~r"cannot pipe 1 into \{2, 3\}", fn ->
+      Macro.pipe(1, {2, 3}, 0)
+    end
+
+    assert_raise ArgumentError, ~r"cannot pipe 1 into 1 \+ 1, the :\+ operator can", fn ->
+      Macro.pipe(1, quote(do: 1 + 1), 0) == quote(do: foo(1))
+    end
+
+    assert_raise ArgumentError, ~r"cannot pipe 1 into <<1>>", fn ->
+      Macro.pipe(1, quote(do: <<1>>), 0)
+    end
+
+    assert_raise ArgumentError, ~r"cannot pipe 1 into the special form unquote/1", fn ->
+      Macro.pipe(1, quote(do: unquote()), 0)
+    end
+
+    assert_raise ArgumentError, ~r"piping into a unary operator is not supported", fn ->
+      Macro.pipe(1, quote(do: +1), 0)
+    end
+
+    assert_raise ArgumentError, ~r"cannot pipe Macro into Env", fn ->
+      Macro.pipe(Macro, quote(do: Env), 0)
+    end
+
+    assert_raise ArgumentError, ~r"cannot pipe 1 into 2 && 3", fn ->
+      Macro.pipe(1, quote(do: 2 && 3), 0)
+    end
+
+    message = ~r"cannot pipe :foo into an anonymous function without calling"
+
+    assert_raise ArgumentError, message, fn ->
+      Macro.pipe(:foo, quote(do: fn x -> x end), 0)
+    end
+
+    message = ~r"wrong operator precedence when piping into bracket-based access"
+
+    assert_raise ArgumentError, message, fn ->
+      Macro.pipe(:foo, quote(do: %{foo: bar}[:foo]), 0)
+    end
   end
 
-  test :unpipe do
+  test "unpipe/1" do
     assert Macro.unpipe(quote(do: foo)) == quote(do: [{foo, 0}])
     assert Macro.unpipe(quote(do: foo |> bar)) == quote(do: [{foo, 0}, {bar, 0}])
     assert Macro.unpipe(quote(do: foo |> bar |> baz)) == quote(do: [{foo, 0}, {bar, 0}, {baz, 0}])
   end
 
-  ## pre/postwalk
-
-  test :prewalk do
-    assert prewalk({:foo, [], nil}) ==
-           [{:foo, [], nil}]
-
-    assert prewalk({:foo, [], [1, 2, 3]}) ==
-           [{:foo, [], [1, 2, 3]}, 1, 2, 3]
+  ## traverse/pre/postwalk
+
+  test "traverse/4" do
+    assert traverse({:foo, [], nil}) == [{:foo, [], nil}, {:foo, [], nil}]
+
+    assert traverse({:foo, [], [1, 2, 3]}) ==
+             [{:foo, [], [1, 2, 3]}, 1, 1, 2, 2, 3, 3, {:foo, [], [1, 2, 3]}]
+
+    assert traverse({{:., [], [:foo, :bar]}, [], [1, 2, 3]}) ==
+             [
+               {{:., [], [:foo, :bar]}, [], [1, 2, 3]},
+               {:., [], [:foo, :bar]},
+               :foo,
+               :foo,
+               :bar,
+               :bar,
+               {:., [], [:foo, :bar]},
+               1,
+               1,
+               2,
+               2,
+               3,
+               3,
+               {{:., [], [:foo, :bar]}, [], [1, 2, 3]}
+             ]
+
+    assert traverse({[1, 2, 3], [4, 5, 6]}) ==
+             [
+               {[1, 2, 3], [4, 5, 6]},
+               [1, 2, 3],
+               1,
+               1,
+               2,
+               2,
+               3,
+               3,
+               [1, 2, 3],
+               [4, 5, 6],
+               4,
+               4,
+               5,
+               5,
+               6,
+               6,
+               [4, 5, 6],
+               {[1, 2, 3], [4, 5, 6]}
+             ]
+  end
+
+  defp traverse(ast) do
+    Macro.traverse(ast, [], &{&1, [&1 | &2]}, &{&1, [&1 | &2]}) |> elem(1) |> Enum.reverse()
+  end
+
+  test "prewalk/3" do
+    assert prewalk({:foo, [], nil}) == [{:foo, [], nil}]
+
+    assert prewalk({:foo, [], [1, 2, 3]}) == [{:foo, [], [1, 2, 3]}, 1, 2, 3]
 
     assert prewalk({{:., [], [:foo, :bar]}, [], [1, 2, 3]}) ==
-           [{{:., [], [:foo, :bar]}, [], [1, 2, 3]}, {:., [], [:foo, :bar]}, :foo, :bar, 1, 2, 3]
+             [
+               {{:., [], [:foo, :bar]}, [], [1, 2, 3]},
+               {:., [], [:foo, :bar]},
+               :foo,
+               :bar,
+               1,
+               2,
+               3
+             ]
 
     assert prewalk({[1, 2, 3], [4, 5, 6]}) ==
-           [{[1, 2, 3], [4, 5, 6]}, [1, 2, 3], 1, 2, 3, [4, 5, 6], 4, 5, 6]
+             [{[1, 2, 3], [4, 5, 6]}, [1, 2, 3], 1, 2, 3, [4, 5, 6], 4, 5, 6]
   end
 
   defp prewalk(ast) do
-    Macro.prewalk(ast, [], &{&1, [&1|&2]}) |> elem(1) |> Enum.reverse
+    Macro.prewalk(ast, [], &{&1, [&1 | &2]}) |> elem(1) |> Enum.reverse()
   end
 
-  test :postwalk do
-    assert postwalk({:foo, [], nil}) ==
-           [{:foo, [], nil}]
+  test "postwalk/3" do
+    assert postwalk({:foo, [], nil}) == [{:foo, [], nil}]
 
-    assert postwalk({:foo, [], [1, 2, 3]}) ==
-           [1, 2, 3, {:foo, [], [1, 2, 3]}]
+    assert postwalk({:foo, [], [1, 2, 3]}) == [1, 2, 3, {:foo, [], [1, 2, 3]}]
 
     assert postwalk({{:., [], [:foo, :bar]}, [], [1, 2, 3]}) ==
-           [:foo, :bar, {:., [], [:foo, :bar]}, 1, 2, 3, {{:., [], [:foo, :bar]}, [], [1, 2, 3]}]
+             [
+               :foo,
+               :bar,
+               {:., [], [:foo, :bar]},
+               1,
+               2,
+               3,
+               {{:., [], [:foo, :bar]}, [], [1, 2, 3]}
+             ]
 
     assert postwalk({[1, 2, 3], [4, 5, 6]}) ==
-           [1, 2, 3, [1, 2, 3], 4, 5, 6, [4, 5, 6], {[1, 2, 3], [4, 5, 6]}]
+             [1, 2, 3, [1, 2, 3], 4, 5, 6, [4, 5, 6], {[1, 2, 3], [4, 5, 6]}]
+  end
+
+  test "generate_arguments/2" do
+    assert Macro.generate_arguments(0, __MODULE__) == []
+    assert Macro.generate_arguments(1, __MODULE__) == [{:arg1, [], __MODULE__}]
+    assert Macro.generate_arguments(4, __MODULE__) |> length() == 4
   end
 
   defp postwalk(ast) do
-    Macro.postwalk(ast, [], &{&1, [&1|&2]}) |> elem(1) |> Enum.reverse
+    Macro.postwalk(ast, [], &{&1, [&1 | &2]}) |> elem(1) |> Enum.reverse()
+  end
+
+  test "struct_info!/2 expands structs multiple levels deep" do
+    defmodule StructBang do
+      @enforce_keys [:b]
+      defstruct [:a, :b]
+
+      assert Macro.struct_info!(StructBang, __ENV__) == [
+               %{field: :a, default: nil, required: false},
+               %{field: :b, default: nil, required: true}
+             ]
+
+      def within_function do
+        assert Macro.struct_info!(StructBang, __ENV__) == [
+                 %{field: :a, default: nil, required: false},
+                 %{field: :b, default: nil, required: true}
+               ]
+      end
+
+      defmodule Nested do
+        assert Macro.struct_info!(StructBang, __ENV__) == [
+                 %{field: :a, default: nil, required: false},
+                 %{field: :b, default: nil, required: true}
+               ]
+      end
+    end
+
+    assert Macro.struct_info!(StructBang, __ENV__) == [
+             %{field: :a, default: nil, required: false},
+             %{field: :b, default: nil, required: true}
+           ]
+  end
+
+  test "prewalker/1" do
+    ast = quote do: :mod.foo(bar({1, 2}), [3, 4, five])
+    map = Enum.map(Macro.prewalker(ast), & &1)
+
+    assert map == [
+             {{:., [], [:mod, :foo]}, [], [{:bar, [], [{1, 2}]}, [3, 4, {:five, [], MacroTest}]]},
+             {:., [], [:mod, :foo]},
+             :mod,
+             :foo,
+             {:bar, [], [{1, 2}]},
+             {1, 2},
+             1,
+             2,
+             [3, 4, {:five, [], MacroTest}],
+             3,
+             4,
+             {:five, [], MacroTest}
+           ]
+
+    assert map == ast |> Macro.prewalk([], &{&1, [&1 | &2]}) |> elem(1) |> Enum.reverse()
+    assert Enum.zip(Macro.prewalker(ast), []) == Enum.zip(map, [])
+
+    for i <- 0..(length(map) + 1) do
+      assert Enum.take(Macro.prewalker(ast), i) == Enum.take(map, i)
+    end
+  end
+
+  test "postwalker/1" do
+    ast = quote do: :mod.foo(bar({1, 2}), [3, 4, five])
+    map = Enum.map(Macro.postwalker(ast), & &1)
+
+    assert map == [
+             :mod,
+             :foo,
+             {:., [], [:mod, :foo]},
+             1,
+             2,
+             {1, 2},
+             {:bar, [], [{1, 2}]},
+             3,
+             4,
+             {:five, [], MacroTest},
+             [3, 4, {:five, [], MacroTest}],
+             {{:., [], [:mod, :foo]}, [], [{:bar, [], [{1, 2}]}, [3, 4, {:five, [], MacroTest}]]}
+           ]
+
+    assert map == ast |> Macro.postwalk([], &{&1, [&1 | &2]}) |> elem(1) |> Enum.reverse()
+    assert Enum.zip(Macro.postwalker(ast), []) == Enum.zip(map, [])
+
+    for i <- 0..(length(map) + 1) do
+      assert Enum.take(Macro.postwalker(ast), i) == Enum.take(map, i)
+    end
+  end
+
+  test "operator?/2" do
+    assert Macro.operator?(:+, 2)
+    assert Macro.operator?(:+, 1)
+    refute Macro.operator?(:+, 0)
+  end
+
+  test "quoted_literal?/1" do
+    assert Macro.quoted_literal?(quote(do: "foo"))
+    assert Macro.quoted_literal?(quote(do: {"foo", 1}))
+    assert Macro.quoted_literal?(quote(do: %{foo: "bar"}))
+    assert Macro.quoted_literal?(quote(do: %URI{path: "/"}))
+    assert Macro.quoted_literal?(quote(do: <<>>))
+    assert Macro.quoted_literal?(quote(do: <<1, "foo", "bar"::utf16>>))
+    assert Macro.quoted_literal?(quote(do: <<1000::size(8)-unit(4)>>))
+    assert Macro.quoted_literal?(quote(do: <<1000::8*4>>))
+    assert Macro.quoted_literal?(quote(do: <<102::unsigned-big-integer-size(8)>>))
+    refute Macro.quoted_literal?(quote(do: {"foo", var}))
+    refute Macro.quoted_literal?(quote(do: <<"foo"::size(name_size)>>))
+    refute Macro.quoted_literal?(quote(do: <<"foo"::binary-size(name_size)>>))
+    refute Macro.quoted_literal?(quote(do: <<"foo"::custom_modifier()>>))
+    refute Macro.quoted_literal?(quote(do: <<102, rest::binary>>))
+  end
+
+  test "underscore/1" do
+    assert Macro.underscore("foo") == "foo"
+    assert Macro.underscore("foo_bar") == "foo_bar"
+    assert Macro.underscore("Foo") == "foo"
+    assert Macro.underscore("FooBar") == "foo_bar"
+    assert Macro.underscore("FOOBar") == "foo_bar"
+    assert Macro.underscore("FooBAR") == "foo_bar"
+    assert Macro.underscore("FOO_BAR") == "foo_bar"
+    assert Macro.underscore("FoBaZa") == "fo_ba_za"
+    assert Macro.underscore("Foo10") == "foo10"
+    assert Macro.underscore("FOO10") == "foo10"
+    assert Macro.underscore("10Foo") == "10_foo"
+    assert Macro.underscore("FooBar10") == "foo_bar10"
+    assert Macro.underscore("FooBAR10") == "foo_bar10"
+    assert Macro.underscore("Foo10Bar") == "foo10_bar"
+    assert Macro.underscore("Foo.Bar") == "foo/bar"
+    assert Macro.underscore(Foo.Bar) == "foo/bar"
+    assert Macro.underscore("API.V1.User") == "api/v1/user"
+    assert Macro.underscore("") == ""
+  end
+
+  test "camelize/1" do
+    assert Macro.camelize("Foo") == "Foo"
+    assert Macro.camelize("FooBar") == "FooBar"
+    assert Macro.camelize("foo") == "Foo"
+    assert Macro.camelize("foo_bar") == "FooBar"
+    assert Macro.camelize("foo_") == "Foo"
+    assert Macro.camelize("_foo") == "Foo"
+    assert Macro.camelize("foo10") == "Foo10"
+    assert Macro.camelize("_10foo") == "10foo"
+    assert Macro.camelize("foo_10") == "Foo10"
+    assert Macro.camelize("foo__10") == "Foo10"
+    assert Macro.camelize("foo__bar") == "FooBar"
+    assert Macro.camelize("foo/bar") == "Foo.Bar"
+    assert Macro.camelize("Foo.Bar") == "Foo.Bar"
+    assert Macro.camelize("foo1_0") == "Foo10"
+    assert Macro.camelize("foo_123_4_567") == "Foo1234567"
+    assert Macro.camelize("FOO_BAR") == "FOO_BAR"
+    assert Macro.camelize("FOO.BAR") == "FOO.BAR"
+    assert Macro.camelize("") == ""
   end
 end
diff --git a/lib/elixir/test/elixir/map_set_test.exs b/lib/elixir/test/elixir/map_set_test.exs
new file mode 100644
index 00000000000..7203cb79038
--- /dev/null
+++ b/lib/elixir/test/elixir/map_set_test.exs
@@ -0,0 +1,169 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule MapSetTest do
+  use ExUnit.Case, async: true
+
+  doctest MapSet
+
+  test "new/1" do
+    result = MapSet.new(1..5)
+    assert MapSet.equal?(result, Enum.into(1..5, MapSet.new()))
+  end
+
+  test "new/2" do
+    result = MapSet.new(1..5, &(&1 + 2))
+    assert MapSet.equal?(result, Enum.into(3..7, MapSet.new()))
+  end
+
+  test "put/2" do
+    result = MapSet.put(MapSet.new(), 1)
+    assert MapSet.equal?(result, MapSet.new([1]))
+
+    result = MapSet.put(MapSet.new([1, 3, 4]), 2)
+    assert MapSet.equal?(result, MapSet.new(1..4))
+
+    result = MapSet.put(MapSet.new(5..100), 10)
+    assert MapSet.equal?(result, MapSet.new(5..100))
+  end
+
+  test "union/2" do
+    result = MapSet.union(MapSet.new([1, 3, 4]), MapSet.new())
+    assert MapSet.equal?(result, MapSet.new([1, 3, 4]))
+
+    result = MapSet.union(MapSet.new(5..15), MapSet.new(10..25))
+    assert MapSet.equal?(result, MapSet.new(5..25))
+
+    result = MapSet.union(MapSet.new(1..120), MapSet.new(1..100))
+    assert MapSet.equal?(result, MapSet.new(1..120))
+  end
+
+  test "intersection/2" do
+    result = MapSet.intersection(MapSet.new(), MapSet.new(1..21))
+    assert MapSet.equal?(result, MapSet.new())
+
+    result = MapSet.intersection(MapSet.new(1..21), MapSet.new(4..24))
+    assert MapSet.equal?(result, MapSet.new(4..21))
+
+    result = MapSet.intersection(MapSet.new(2..100), MapSet.new(1..120))
+    assert MapSet.equal?(result, MapSet.new(2..100))
+  end
+
+  test "difference/2" do
+    result = MapSet.difference(MapSet.new(2..20), MapSet.new())
+    assert MapSet.equal?(result, MapSet.new(2..20))
+
+    result = MapSet.difference(MapSet.new(2..20), MapSet.new(1..21))
+    assert MapSet.equal?(result, MapSet.new())
+
+    result = MapSet.difference(MapSet.new(1..101), MapSet.new(2..100))
+    assert MapSet.equal?(result, MapSet.new([1, 101]))
+  end
+
+  test "symmetric_difference/2" do
+    result = MapSet.symmetric_difference(MapSet.new(1..5), MapSet.new(3..8))
+    assert MapSet.equal?(result, MapSet.new([1, 2, 6, 7, 8]))
+
+    result = MapSet.symmetric_difference(MapSet.new(), MapSet.new())
+    assert MapSet.equal?(result, MapSet.new())
+
+    result = MapSet.symmetric_difference(MapSet.new(1..5), MapSet.new(1..5))
+    assert MapSet.equal?(result, MapSet.new())
+
+    result = MapSet.symmetric_difference(MapSet.new([1, 2, 3]), MapSet.new())
+    assert MapSet.equal?(result, MapSet.new([1, 2, 3]))
+
+    result = MapSet.symmetric_difference(MapSet.new(), MapSet.new([1, 2, 3]))
+    assert MapSet.equal?(result, MapSet.new([1, 2, 3]))
+  end
+
+  test "disjoint?/2" do
+    assert MapSet.disjoint?(MapSet.new(), MapSet.new())
+    assert MapSet.disjoint?(MapSet.new(1..6), MapSet.new(8..20))
+    refute MapSet.disjoint?(MapSet.new(1..6), MapSet.new(5..15))
+    refute MapSet.disjoint?(MapSet.new(1..120), MapSet.new(1..6))
+  end
+
+  test "subset?/2" do
+    assert MapSet.subset?(MapSet.new(), MapSet.new())
+    assert MapSet.subset?(MapSet.new(1..6), MapSet.new(1..10))
+    assert MapSet.subset?(MapSet.new(1..6), MapSet.new(1..120))
+    refute MapSet.subset?(MapSet.new(1..120), MapSet.new(1..6))
+  end
+
+  test "equal?/2" do
+    assert MapSet.equal?(MapSet.new(), MapSet.new())
+    refute MapSet.equal?(MapSet.new(1..20), MapSet.new(2..21))
+    assert MapSet.equal?(MapSet.new(1..120), MapSet.new(1..120))
+  end
+
+  test "delete/2" do
+    result = MapSet.delete(MapSet.new(), 1)
+    assert MapSet.equal?(result, MapSet.new())
+
+    result = MapSet.delete(MapSet.new(1..4), 5)
+    assert MapSet.equal?(result, MapSet.new(1..4))
+
+    result = MapSet.delete(MapSet.new(1..4), 1)
+    assert MapSet.equal?(result, MapSet.new(2..4))
+
+    result = MapSet.delete(MapSet.new(1..4), 2)
+    assert MapSet.equal?(result, MapSet.new([1, 3, 4]))
+  end
+
+  test "size/1" do
+    assert MapSet.size(MapSet.new()) == 0
+    assert MapSet.size(MapSet.new(5..15)) == 11
+    assert MapSet.size(MapSet.new(2..100)) == 99
+  end
+
+  test "to_list/1" do
+    assert MapSet.to_list(MapSet.new()) == []
+
+    list = MapSet.to_list(MapSet.new(1..20))
+    assert Enum.sort(list) == Enum.to_list(1..20)
+
+    list = MapSet.to_list(MapSet.new(5..120))
+    assert Enum.sort(list) == Enum.to_list(5..120)
+  end
+
+  test "filter/2" do
+    result = MapSet.filter(MapSet.new([1, nil, 2, false]), & &1)
+    assert MapSet.equal?(result, MapSet.new(1..2))
+
+    result = MapSet.filter(MapSet.new(1..10), &(&1 < 2 or &1 > 9))
+    assert MapSet.equal?(result, MapSet.new([1, 10]))
+
+    result = MapSet.filter(MapSet.new(~w(A a B b)), fn x -> String.downcase(x) == x end)
+    assert MapSet.equal?(result, MapSet.new(~w(a b)))
+  end
+
+  test "reject/2" do
+    result = MapSet.reject(MapSet.new(1..10), &(&1 < 8))
+    assert MapSet.equal?(result, MapSet.new(8..10))
+
+    result = MapSet.reject(MapSet.new(["a", :b, 1, 1.0]), &is_integer/1)
+    assert MapSet.equal?(result, MapSet.new(["a", :b, 1.0]))
+
+    result = MapSet.reject(MapSet.new(1..3), fn x -> rem(x, 2) == 0 end)
+    assert MapSet.equal?(result, MapSet.new([1, 3]))
+  end
+
+  test "split_with" do
+    assert MapSet.split_with(MapSet.new(), fn v -> rem(v, 2) == 0 end) ==
+             {MapSet.new(), MapSet.new()}
+
+    assert MapSet.split_with(MapSet.new([1, 2, 3]), fn v -> rem(v, 2) == 0 end) ==
+             {MapSet.new([2]), MapSet.new([1, 3])}
+
+    assert MapSet.split_with(MapSet.new([2, 4, 6]), fn v -> rem(v, 2) == 0 end) ==
+             {MapSet.new([2, 4, 6]), MapSet.new([])}
+  end
+
+  test "inspect" do
+    assert inspect(MapSet.new([?a])) == "MapSet.new([97])"
+  end
+end
diff --git a/lib/elixir/test/elixir/map_test.exs b/lib/elixir/test/elixir/map_test.exs
index a005bf0c5ba..bf9bffd0ddc 100644
--- a/lib/elixir/test/elixir/map_test.exs
+++ b/lib/elixir/test/elixir/map_test.exs
@@ -1,52 +1,23 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule MapTest do
   use ExUnit.Case, async: true
 
-  defp empty_map do
-    %{}
-  end
+  doctest Map
 
-  defp two_items_map do
-    %{a: 1, b: 2}
-  end
-
-  @map %{a: 1, b: 2}
+  @sample %{a: 1, b: 2}
+  defp sample, do: Process.get(:unused, %{a: 1, b: 2})
 
   test "maps in attributes" do
-    assert @map == %{a: 1, b: 2}
+    assert @sample == %{a: 1, b: 2}
   end
 
   test "maps when quoted" do
-    assert (quote do
-      %{foo: 1}
-    end) == {:%{}, [], [{:foo, 1}]}
-
-    assert (quote do
-      %
-        {foo: 1}
-    end) == {:%{}, [], [{:foo, 1}]}
-  end
-
-  test "structs when quoted" do
-    assert (quote do
-      %User{foo: 1}
-    end) == {:%, [], [
-      {:__aliases__, [alias: false], [:User]},
-      {:%{}, [], [{:foo, 1}]}
-    ]}
-
-    assert (quote do
-      %
-        User{foo: 1}
-    end) == {:%, [], [
-      {:__aliases__, [alias: false], [:User]},
-      {:%{}, [], [{:foo, 1}]}
-    ]}
-
-    assert (quote do
-      %unquote(User){foo: 1}
-    end) == {:%, [], [User, {:%{}, [], [{:foo, 1}]}]}
+    assert quote(do: %{foo: 1}) == {:%{}, [], [{:foo, 1}]}
   end
 
   test "maps keywords and atoms" do
@@ -60,76 +31,453 @@ defmodule MapTest do
     assert a == 1
   end
 
+  test "maps with generated variables in key" do
+    assert %{"#{1}" => 1} == %{"1" => 1}
+    assert %{for(x <- 1..3, do: x) => 1} == %{[1, 2, 3] => 1}
+    assert %{with(x = 1, do: x) => 1} == %{1 => 1}
+    assert %{with({:ok, x} <- {:ok, 1}, do: x) => 1} == %{1 => 1}
+
+    assert %{
+             try do
+               raise "error"
+             rescue
+               _ -> 1
+             end => 1
+           } == %{1 => 1}
+
+    assert %{
+             try do
+               throw(1)
+             catch
+               x -> x
+             end => 1
+           } == %{1 => 1}
+
+    assert %{
+             try do
+               a = 1
+               a
+             rescue
+               _ -> 2
+             end => 1
+           } == %{1 => 1}
+
+    assert %{
+             try do
+               1
+             rescue
+               _exception -> flunk("should not be invoked")
+             else
+               a -> a
+             end => 1
+           } == %{1 => 1}
+  end
+
+  test "matching with map as a key" do
+    assert %{%{1 => 2} => x} = %{%{1 => 2} => 3}
+    assert x == 3
+  end
+
   test "is_map/1" do
-    assert is_map empty_map
-    refute is_map(Enum.to_list(empty_map))
+    assert is_map(Map.new())
+    refute is_map(Enum.to_list(%{}))
   end
 
   test "map_size/1" do
-    assert map_size(empty_map) == 0
-    assert map_size(two_items_map) == 2
+    assert map_size(%{}) == 0
+    assert map_size(sample()) == 2
   end
 
-  test "maps with optional comma" do
-    assert %{a: :b,} == %{a: :b}
-    assert %{1 => 2,} == %{1 => 2}
-    assert %{1 => 2, a: :b,} == %{1 => 2, a: :b}
+  test "new/1" do
+    assert Map.new(%{a: 1, b: 2}) == %{a: 1, b: 2}
+    assert Map.new(MapSet.new(a: 1, b: 2, a: 3)) == %{b: 2, a: 3}
+  end
+
+  test "new/2" do
+    transformer = fn {key, value} -> {key, value * 2} end
+    assert Map.new(%{a: 1, b: 2}, transformer) == %{a: 2, b: 4}
+    assert Map.new(MapSet.new(a: 1, b: 2, a: 3), transformer) == %{b: 4, a: 6}
+  end
+
+  test "take/2" do
+    assert Map.take(%{a: 1, b: 2, c: 3}, [:b, :c]) == %{b: 2, c: 3}
+    assert Map.take(%{a: 1, b: 2, c: 3}, []) == %{}
+    assert_raise BadMapError, fn -> Map.take(:foo, []) end
+  end
+
+  test "drop/2" do
+    assert Map.drop(%{a: 1, b: 2, c: 3}, [:b, :c]) == %{a: 1}
+    assert_raise BadMapError, fn -> Map.drop(:foo, []) end
+  end
+
+  test "split/2" do
+    assert Map.split(%{a: 1, b: 2, c: 3}, [:b, :c]) == {%{b: 2, c: 3}, %{a: 1}}
+    assert_raise BadMapError, fn -> Map.split(:foo, []) end
+  end
+
+  test "split_with/2" do
+    assert Map.split_with(%{}, fn {_k, v} -> rem(v, 2) == 0 end) == {%{}, %{}}
+
+    assert Map.split_with(%{a: 1, b: 2, c: 3}, fn {_k, v} -> rem(v, 2) == 0 end) ==
+             {%{b: 2}, %{a: 1, c: 3}}
+
+    assert Map.split_with(%{a: 2, b: 4, c: 6}, fn {_k, v} -> rem(v, 2) == 0 end) ==
+             {%{a: 2, b: 4, c: 6}, %{}}
+
+    assert Map.split_with(%{1 => 1, 2 => 2, 3 => 3}, fn {k, _v} -> rem(k, 2) == 0 end) ==
+             {%{2 => 2}, %{1 => 1, 3 => 3}}
+
+    assert Map.split_with(%{1 => 2, 3 => 4, 5 => 6}, fn {k, _v} -> rem(k, 2) == 0 end) ==
+             {%{}, %{1 => 2, 3 => 4, 5 => 6}}
   end
 
-  test "maps with duplicate keys" do
-    assert %{a: :b, a: :c} == %{a: :c}
-    assert %{1 => 2, 1 => 3} == %{1 => 3}
-    assert %{:a => :b, a: :c} == %{a: :c}
+  test "get_and_update/3" do
+    message = "the given function must return a two-element tuple or :pop, got: 1"
+
+    assert_raise RuntimeError, message, fn ->
+      Map.get_and_update(%{a: 1}, :a, fn value -> value end)
+    end
+  end
+
+  test "get_and_update!/3" do
+    message = "the given function must return a two-element tuple or :pop, got: 1"
+
+    assert_raise RuntimeError, message, fn ->
+      Map.get_and_update!(%{a: 1}, :a, fn value -> value end)
+    end
+  end
+
+  test "maps with optional comma" do
+    assert Code.eval_string("%{a: :b,}") == {%{a: :b}, []}
+    assert Code.eval_string("%{1 => 2,}") == {%{1 => 2}, []}
+    assert Code.eval_string("%{1 => 2, a: :b,}") == {%{1 => 2, a: :b}, []}
   end
 
   test "update maps" do
-    assert %{two_items_map | a: 3} == %{a: 3, b: 2}
+    assert %{sample() | a: 3} == %{a: 3, b: 2}
 
-    assert_raise ArgumentError, fn ->
-      %{two_items_map | c: 3}
+    assert_raise KeyError, fn ->
+      %{sample() | c: 3}
     end
   end
 
-  test "map access" do
-    assert two_items_map.a == 1
+  test "map dot access" do
+    assert sample().a == 1
 
     assert_raise KeyError, fn ->
-      two_items_map.c
+      sample().c
     end
   end
 
-  defmodule ExternalUser do
-    def __struct__ do
-      %{__struct__: ThisDoesNotLeak, name: "josé", age: 27}
+  test "put/3 optimized by the compiler" do
+    map = %{a: 1, b: 2}
+
+    assert Map.put(map, :a, 2) == %{a: 2, b: 2}
+    assert Map.put(map, :c, 3) == %{a: 1, b: 2, c: 3}
+
+    assert Map.put(%{map | a: 2}, :a, 3) == %{a: 3, b: 2}
+    assert Map.put(%{map | a: 2}, :b, 3) == %{a: 2, b: 3}
+
+    assert Map.put(map, :a, 2) |> Map.put(:a, 3) == %{a: 3, b: 2}
+    assert Map.put(map, :a, 2) |> Map.put(:c, 3) == %{a: 2, b: 2, c: 3}
+    assert Map.put(map, :c, 3) |> Map.put(:a, 2) == %{a: 2, b: 2, c: 3}
+    assert Map.put(map, :c, 3) |> Map.put(:c, 4) == %{a: 1, b: 2, c: 4}
+  end
+
+  test "merge/2 with map literals optimized by the compiler" do
+    map = %{a: 1, b: 2}
+
+    assert Map.merge(map, %{a: 2}) == %{a: 2, b: 2}
+    assert Map.merge(map, %{c: 3}) == %{a: 1, b: 2, c: 3}
+    assert Map.merge(%{a: 2}, map) == %{a: 1, b: 2}
+    assert Map.merge(%{c: 3}, map) == %{a: 1, b: 2, c: 3}
+
+    assert Map.merge(%{map | a: 2}, %{a: 3}) == %{a: 3, b: 2}
+    assert Map.merge(%{map | a: 2}, %{b: 3}) == %{a: 2, b: 3}
+    assert Map.merge(%{a: 2}, %{map | a: 3}) == %{a: 3, b: 2}
+    assert Map.merge(%{a: 2}, %{map | b: 3}) == %{a: 1, b: 3}
+
+    assert Map.merge(map, %{a: 2}) |> Map.merge(%{a: 3, c: 3}) == %{a: 3, b: 2, c: 3}
+    assert Map.merge(map, %{c: 3}) |> Map.merge(%{c: 4}) == %{a: 1, b: 2, c: 4}
+    assert Map.merge(map, %{a: 3, c: 3}) |> Map.merge(%{a: 2}) == %{a: 2, b: 2, c: 3}
+  end
+
+  test "merge/3" do
+    # When first map is bigger
+    assert Map.merge(%{a: 1, b: 2, c: 3}, %{c: 4, d: 5}, fn :c, 3, 4 -> :x end) ==
+             %{a: 1, b: 2, c: :x, d: 5}
+
+    # When second map is bigger
+    assert Map.merge(%{b: 2, c: 3}, %{a: 1, c: 4, d: 5}, fn :c, 3, 4 -> :x end) ==
+             %{a: 1, b: 2, c: :x, d: 5}
+  end
+
+  test "replace/3" do
+    map = %{c: 3, b: 2, a: 1}
+    assert Map.replace(map, :b, 10) == %{c: 3, b: 10, a: 1}
+    assert Map.replace(map, :a, 1) == map
+    assert Map.replace(map, :x, 1) == map
+    assert Map.replace(%{}, :x, 1) == %{}
+  end
+
+  test "replace!/3" do
+    map = %{c: 3, b: 2, a: 1}
+    assert Map.replace!(map, :b, 10) == %{c: 3, b: 10, a: 1}
+    assert Map.replace!(map, :a, 1) == map
+
+    assert_raise KeyError, ~r/key :x not found in:\n\n    %{.*a: 1.*}/, fn ->
+      Map.replace!(map, :x, 10)
+    end
+
+    assert_raise KeyError, "key :x not found in:\n\n    %{}\n", fn ->
+      Map.replace!(%{}, :x, 10)
     end
   end
 
-  test "structs" do
-    assert %ExternalUser{} ==
-           %{__struct__: ExternalUser, name: "josé", age: 27}
+  test "intersect/2" do
+    map = %{a: 1, b: 2}
 
-    assert %ExternalUser{name: "valim"} ==
-           %{__struct__: ExternalUser, name: "valim", age: 27}
+    assert Map.intersect(map, %{a: 2}) == %{a: 2}
+    assert Map.intersect(map, %{c: 3}) == %{}
+    assert Map.intersect(%{a: 2}, map) == %{a: 1}
+    assert Map.intersect(%{c: 3}, map) == %{}
+
+    assert Map.intersect(map, %{a: 2}) |> Map.intersect(%{a: 3, c: 3}) == %{a: 3}
+    assert Map.intersect(map, %{c: 3}) |> Map.intersect(%{c: 4}) == %{}
+    assert Map.intersect(map, %{a: 3, c: 3}) |> Map.intersect(%{a: 2}) == %{a: 2}
+  end
 
-    user = %ExternalUser{}
-    assert %ExternalUser{user | name: "valim"} ==
-           %{__struct__: ExternalUser, name: "valim", age: 27}
+  test "intersect/3" do
+    # When first map is bigger
+    assert Map.intersect(%{a: 1, b: 2, c: 3}, %{c: 4, d: 5}, fn :c, 3, 4 -> :x end) ==
+             %{c: :x}
+
+    # When second map is bigger
+    assert Map.intersect(%{b: 2, c: 3}, %{a: 1, c: 4, d: 5}, fn :c, 3, 4 -> :x end) ==
+             %{c: :x}
+  end
+
+  test "implements (almost) all functions in Keyword" do
+    assert Keyword.__info__(:functions) -- Map.__info__(:functions) == [
+             delete: 3,
+             delete_first: 2,
+             get_values: 2,
+             keyword?: 1,
+             pop_first: 2,
+             pop_first: 3,
+             pop_values: 2,
+             validate: 2,
+             validate!: 2
+           ]
+  end
+
+  test "variable keys" do
+    x = :key
+    %{^x => :value} = %{x => :value}
+    assert %{x => :value} == %{key: :value}
+    assert (fn %{^x => :value} -> true end).(%{key: :value})
+
+    map = %{x => :value}
+    assert %{map | x => :new_value} == %{x => :new_value}
+  end
+
+  defmodule ExternalUser do
+    defstruct name: "john", age: 27
+  end
+
+  test "structs" do
+    assert %ExternalUser{} == %{__struct__: ExternalUser, name: "john", age: 27}
+    assert %ExternalUser{name: "meg"} == %{__struct__: ExternalUser, name: "meg", age: 27}
 
     %ExternalUser{name: name} = %ExternalUser{}
-    assert name == "josé"
+    assert name == "john"
+  end
+
+  describe "structs with variable name" do
+    test "extracts the struct module" do
+      %module{name: "john"} = %ExternalUser{name: "john", age: 27}
+      assert module == ExternalUser
+    end
+
+    test "returns the struct on match" do
+      assert Code.eval_string("%struct{} = %ExternalUser{}", [], __ENV__) ==
+               {%ExternalUser{}, [struct: ExternalUser]}
+    end
+
+    test "supports the pin operator" do
+      module = ExternalUser
+      user = %ExternalUser{name: "john", age: 27}
+      %^module{name: "john"} = user
+    end
+
+    test "is supported in case" do
+      user = %ExternalUser{name: "john", age: 27}
+
+      case user do
+        %module{} = %{age: 27} -> assert module == ExternalUser
+      end
+    end
+
+    defp destruct1(%module{}), do: module
+    defp destruct2(%_{}), do: :ok
+
+    test "does not match" do
+      invalid_struct = Process.get(:unused, %{__struct__: "foo"})
+
+      assert_raise CaseClauseError, fn ->
+        case invalid_struct do
+          %module{} -> module
+        end
+      end
+
+      assert_raise CaseClauseError, fn ->
+        case invalid_struct do
+          %_{} -> :ok
+        end
+      end
+
+      assert_raise CaseClauseError, fn ->
+        foo = Process.get(:unused, "foo")
 
-    map = %{}
-    assert_raise BadStructError, "expected a struct named MapTest.ExternalUser, got: %{}", fn ->
-      %ExternalUser{map | name: "valim"}
+        case invalid_struct do
+          %^foo{} -> :ok
+        end
+      end
+
+      assert_raise FunctionClauseError, fn ->
+        destruct1(invalid_struct)
+      end
+
+      assert_raise FunctionClauseError, fn ->
+        destruct2(invalid_struct)
+      end
+
+      assert_raise MatchError, fn ->
+        %module{} = invalid_struct
+        _ = module
+      end
+
+      assert_raise MatchError, fn ->
+        %_{} = invalid_struct
+      end
+
+      assert_raise MatchError, fn ->
+        foo = Process.get(:unused, "foo")
+        %^foo{} = invalid_struct
+      end
     end
   end
 
+  test "structs when using dynamic modules" do
+    defmodule Module.concat(MapTest, DynamicUser) do
+      defstruct [:name, :age]
+
+      def sample do
+        %__MODULE__{}
+      end
+    end
+  end
+
+  test "structs when quoted" do
+    quoted =
+      quote do
+        %User{foo: 1}
+      end
+
+    assert {:%, [], [aliases, {:%{}, [], [{:foo, 1}]}]} = quoted
+    assert aliases == {:__aliases__, [alias: false], [:User]}
+
+    quoted =
+      quote do
+        %unquote(User){foo: 1}
+      end
+
+    assert quoted == {:%, [], [User, {:%{}, [], [{:foo, 1}]}]}
+  end
+
+  test "structs with bitstring defaults" do
+    defmodule WithBitstring do
+      defstruct bitstring: <<255, 127::7>>
+    end
+
+    info = Macro.struct_info!(WithBitstring, __ENV__)
+    assert info == [%{default: <<255, 127::7>>, field: :bitstring, required: false}]
+  end
+
+  test "defstruct can only be used once in a module" do
+    message =
+      "defstruct has already been called for TestMod, " <>
+        "defstruct can only be called once per module"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
+      defmodule TestMod do
+        defstruct [:foo]
+        defstruct [:foo]
+      end
+      """)
+    end
+  end
+
+  test "defstruct allows keys to be enforced" do
+    message = "the following keys must also be given when building struct TestMod: [:foo]"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
+      defmodule TestMod do
+        @enforce_keys :foo
+        defstruct [:foo]
+
+        # Verify it remain set afterwards
+        :foo = @enforce_keys
+
+        def foo do
+          %TestMod{}
+        end
+      end
+      """)
+    end
+  end
+
+  test "defstruct raises on invalid enforce_keys" do
+    message = "keys given to @enforce_keys must be atoms, got: \"foo\""
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
+      defmodule TestMod do
+        @enforce_keys "foo"
+        defstruct [:foo]
+      end
+      """)
+    end
+  end
+
+  test "struct always expands context module" do
+    Code.compiler_options(ignore_module_conflict: true)
+
+    defmodule LocalPoint do
+      defstruct x: 0
+      def new, do: %LocalPoint{}
+    end
+
+    assert LocalPoint.new() == %{__struct__: LocalPoint, x: 0}
+
+    defmodule LocalPoint do
+      defstruct x: 0, y: 0
+      def new, do: %LocalPoint{}
+    end
+
+    assert LocalPoint.new() == %{__struct__: LocalPoint, x: 0, y: 0}
+  after
+    Code.compiler_options(ignore_module_conflict: false)
+  end
+
   defmodule LocalUser do
     defmodule NestedUser do
       defstruct []
     end
 
-    defstruct name: "josé", nested: struct(NestedUser)
+    defstruct name: "john", nested: struct(NestedUser), context: %{}
 
     def new do
       %LocalUser{}
@@ -142,16 +490,18 @@ defmodule MapTest do
     end
   end
 
-  test "local user" do
-    assert LocalUser.new == %LocalUser{name: "josé", nested: %LocalUser.NestedUser{}}
-    assert LocalUser.Context.new == %LocalUser{name: "josé", nested: %LocalUser.NestedUser{}}
+  test "local and nested structs" do
+    assert LocalUser.new() == %LocalUser{name: "john", nested: %LocalUser.NestedUser{}}
+    assert LocalUser.Context.new() == %LocalUser{name: "john", nested: %LocalUser.NestedUser{}}
   end
 
-  defmodule NilUser do
-    defstruct name: nil, contents: %{}
+  defmodule :elixir_struct_from_erlang_module do
+    defstruct [:hello]
+    def world(%:elixir_struct_from_erlang_module{} = struct), do: struct
   end
 
-  test "nil user" do
-    assert %NilUser{} == %{__struct__: NilUser, name: nil, contents: %{}}
+  test "struct from erlang module" do
+    struct = %:elixir_struct_from_erlang_module{}
+    assert :elixir_struct_from_erlang_module.world(struct) == struct
   end
 end
diff --git a/lib/elixir/test/elixir/module/locals_tracker_test.exs b/lib/elixir/test/elixir/module/locals_tracker_test.exs
deleted file mode 100644
index d24f7eb497d..00000000000
--- a/lib/elixir/test/elixir/module/locals_tracker_test.exs
+++ /dev/null
@@ -1,150 +0,0 @@
-Code.require_file "../test_helper.exs", __DIR__
-
-defmodule Module.LocalsTrackerTest do
-  use ExUnit.Case, async: true
-
-  alias Module.LocalsTracker, as: D
-
-  setup do
-    {:ok, [pid: D.start_link]}
-  end
-
-  ## Locals
-
-  test "can add definitions", config do
-    D.add_definition(config[:pid], :def, {:foo, 1})
-    D.add_definition(config[:pid], :defp, {:bar, 1})
-  end
-
-  test "can add locals", config do
-    D.add_definition(config[:pid], :def, {:foo, 1})
-    D.add_local(config[:pid], {:foo, 1}, {:bar, 1})
-  end
-
-  test "public definitions are always reachable", config do
-    D.add_definition(config[:pid], :def, {:public, 1})
-    assert {:public, 1} in D.reachable(config[:pid])
-
-    D.add_definition(config[:pid], :defmacro, {:public, 2})
-    assert {:public, 2} in D.reachable(config[:pid])
-  end
-
-  test "private definitions are never reachable", config do
-    D.add_definition(config[:pid], :defp, {:private, 1})
-    refute {:private, 1} in D.reachable(config[:pid])
-
-    D.add_definition(config[:pid], :defmacrop, {:private, 2})
-    refute {:private, 2} in D.reachable(config[:pid])
-  end
-
-  test "private definitions are reachable when connected to local", config do
-    D.add_definition(config[:pid], :defp, {:private, 1})
-    refute {:private, 1} in D.reachable(config[:pid])
-
-    D.add_local(config[:pid], {:private, 1})
-    assert {:private, 1} in D.reachable(config[:pid])
-  end
-
-  test "private definitions are reachable when connected through a public one", config do
-    D.add_definition(config[:pid], :defp, {:private, 1})
-    refute {:private, 1} in D.reachable(config[:pid])
-
-    D.add_definition(config[:pid], :def, {:public, 1})
-    D.add_local(config[:pid], {:public, 1}, {:private, 1})
-    assert {:private, 1} in D.reachable(config[:pid])
-  end
-
-  @unused [
-    {{:private, 1}, :defp, 0}
-  ]
-
-  test "unused private definitions are marked as so", config do
-    D.add_definition(config[:pid], :def, {:public, 1})
-
-    unused = D.collect_unused_locals(config[:pid], @unused)
-    assert unused == [{:unused_def, {:private, 1}, :defp}]
-
-    D.add_local(config[:pid], {:public, 1}, {:private, 1})
-    unused = D.collect_unused_locals(config[:pid], @unused)
-    refute unused == [{:unused_def, {:private, 1}, :defp}]
-  end
-
-  @unused [
-    {{:private, 3}, :defp, 3}
-  ]
-
-  test "private definitions with unused default arguments", config do
-    D.add_definition(config[:pid], :def, {:public, 1})
-
-    unused = D.collect_unused_locals(config[:pid], @unused)
-    assert unused == [{:unused_def, {:private, 3}, :defp}]
-
-    D.add_local(config[:pid], {:public, 1}, {:private, 3})
-    unused = D.collect_unused_locals(config[:pid], @unused)
-    assert unused == [{:unused_args, {:private, 3}}]
-  end
-
-  test "private definitions with some unused default arguments", config do
-    D.add_definition(config[:pid], :def, {:public, 1})
-    D.add_local(config[:pid], {:public, 1}, {:private, 1})
-    unused = D.collect_unused_locals(config[:pid], @unused)
-    assert unused == [{:unused_args, {:private, 3}, 1}]
-  end
-
-  test "private definitions with all used default arguments", config do
-    D.add_definition(config[:pid], :def, {:public, 1})
-    D.add_local(config[:pid], {:public, 1}, {:private, 0})
-    unused = D.collect_unused_locals(config[:pid], @unused)
-    assert unused == []
-  end
-
-  ## Defaults
-
-  test "can add defaults", config do
-    D.add_definition(config[:pid], :def, {:foo, 4})
-    D.add_defaults(config[:pid], :def, {:foo, 4}, 2)
-  end
-
-  test "defaults are reachable if public", config do
-    D.add_definition(config[:pid], :def, {:foo, 4})
-    D.add_defaults(config[:pid], :def, {:foo, 4}, 2)
-    assert {:foo, 2} in D.reachable(config[:pid])
-    assert {:foo, 3} in D.reachable(config[:pid])
-  end
-
-  test "defaults are not reachable if private", config do
-    D.add_definition(config[:pid], :defp, {:foo, 4})
-    D.add_defaults(config[:pid], :defp, {:foo, 4}, 2)
-    refute {:foo, 2} in D.reachable(config[:pid])
-    refute {:foo, 3} in D.reachable(config[:pid])
-  end
-
-  test "defaults are connected", config do
-    D.add_definition(config[:pid], :defp, {:foo, 4})
-    D.add_defaults(config[:pid], :defp, {:foo, 4}, 2)
-    D.add_local(config[:pid], {:foo, 2})
-    assert {:foo, 2} in D.reachable(config[:pid])
-    assert {:foo, 3} in D.reachable(config[:pid])
-    assert {:foo, 4} in D.reachable(config[:pid])
-  end
-
-  ## Imports
-
-  test "find imports from dispatch", config do
-    D.add_import(config[:pid], nil, Module, {:concat, 1})
-    assert Module in D.imports_with_dispatch(config[:pid], {:concat, 1})
-    refute Module in D.imports_with_dispatch(config[:pid], {:unknown, 1})
-  end
-
-  test "find import conflicts", config do
-    refute {[Module], :conflict, 1} in D.collect_imports_conflicts(config[:pid], [conflict: 1])
-
-    # Calls outside local functions are not triggered
-    D.add_import(config[:pid], nil, Module, {:conflict, 1})
-    refute {[Module], :conflict, 1} in D.collect_imports_conflicts(config[:pid], [conflict: 1])
-
-    D.add_local(config[:pid], {:foo, 2})
-    D.add_import(config[:pid], {:foo, 2}, Module, {:conflict, 1})
-    assert {[Module], :conflict, 1} in D.collect_imports_conflicts(config[:pid], [conflict: 1])
-  end
-end
diff --git a/lib/elixir/test/elixir/module/types/descr_test.exs b/lib/elixir/test/elixir/module/types/descr_test.exs
new file mode 100644
index 00000000000..49d3eed89b7
--- /dev/null
+++ b/lib/elixir/test/elixir/module/types/descr_test.exs
@@ -0,0 +1,2931 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("type_helper.exs", __DIR__)
+
+defmodule NoFieldsStruct do
+  defstruct []
+end
+
+defmodule Decimal do
+  defstruct [:sign, :coef, :exp]
+end
+
+defmodule Module.Types.DescrTest do
+  use ExUnit.Case, async: true
+
+  import Module.Types.Descr, except: [fun: 1]
+  defmacro domain_key(arg) when is_atom(arg), do: [arg]
+
+  defp number(), do: union(integer(), float())
+  defp empty_tuple(), do: tuple([])
+  defp tuple_of_size_at_least(n) when is_integer(n), do: open_tuple(List.duplicate(term(), n))
+  defp tuple_of_size(n) when is_integer(n) and n >= 0, do: tuple(List.duplicate(term(), n))
+  defp list(elem_type, tail_type), do: union(empty_list(), non_empty_list(elem_type, tail_type))
+  defp map_with_default(descr), do: open_map([], if_set(descr))
+
+  describe "union" do
+    test "bitmap" do
+      assert union(integer(), float()) == union(float(), integer())
+    end
+
+    test "term" do
+      assert union(term(), float()) == term()
+      assert union(term(), binary()) == term()
+      assert union(term(), if_set(binary())) == if_set(term())
+    end
+
+    test "none" do
+      assert union(none(), float()) == float()
+      assert union(none(), binary()) == binary()
+    end
+
+    test "atom" do
+      assert union(atom(), atom([:a])) == atom()
+      assert union(atom([:a]), atom([:b])) == atom([:a, :b])
+      assert union(atom([:a]), negation(atom([:b]))) == negation(atom([:b]))
+
+      assert union(negation(atom([:a, :b])), negation(atom([:b, :c])))
+             |> equal?(negation(atom([:b])))
+    end
+
+    test "all primitive types" do
+      all = [
+        atom(),
+        integer(),
+        float(),
+        binary(),
+        open_map(),
+        non_empty_list(term(), term()),
+        empty_list(),
+        tuple(),
+        fun(),
+        pid(),
+        port(),
+        reference()
+      ]
+
+      assert Enum.reduce(all, &union/2) |> equal?(term())
+    end
+
+    test "dynamic" do
+      assert equal?(union(dynamic(), dynamic()), dynamic())
+      assert equal?(union(dynamic(), term()), term())
+      assert equal?(union(term(), dynamic()), term())
+
+      assert equal?(union(dynamic(atom()), atom()), atom())
+      refute equal?(union(dynamic(atom()), atom()), dynamic(atom()))
+
+      assert equal?(union(term(), dynamic(if_set(integer()))), union(term(), dynamic(not_set())))
+      refute equal?(union(term(), dynamic(if_set(integer()))), dynamic(union(term(), not_set())))
+    end
+
+    test "tuple" do
+      assert equal?(union(tuple(), tuple()), tuple())
+
+      t = tuple([integer(), atom()])
+      assert equal?(union(t, t), t)
+
+      assert union(tuple([integer(), atom()]), tuple([float(), atom()]))
+             |> equal?(tuple([union(integer(), float()), atom()]))
+
+      assert union(tuple([integer(), atom()]), tuple([integer(), binary()]))
+             |> equal?(tuple([integer(), union(atom(), binary())]))
+
+      assert open_tuple([atom()])
+             |> union(tuple([atom(), integer()]))
+             |> equal?(open_tuple([atom()]))
+
+      assert tuple([union(integer(), atom())])
+             |> difference(open_tuple([atom()]))
+             |> equal?(tuple([integer()]))
+    end
+
+    test "map" do
+      assert equal?(union(open_map(), open_map()), open_map())
+      assert equal?(union(closed_map(a: integer()), open_map()), open_map())
+      assert equal?(union(closed_map(a: integer()), negation(closed_map(a: integer()))), term())
+
+      a_integer_open = open_map(a: integer())
+      assert equal?(union(closed_map(a: integer()), a_integer_open), a_integer_open)
+
+      # Domain key types
+      atom_to_atom = open_map([{domain_key(:atom), atom()}])
+      atom_to_integer = open_map([{domain_key(:atom), integer()}])
+
+      # Test union identity and different type maps
+      assert union(atom_to_atom, atom_to_atom) == atom_to_atom
+
+      # Test subtype relationships with domain key maps
+      refute open_map([{domain_key(:atom), union(atom(), integer())}])
+             |> subtype?(union(atom_to_atom, atom_to_integer))
+
+      assert union(atom_to_atom, atom_to_integer)
+             |> subtype?(open_map([{domain_key(:atom), union(atom(), integer())}]))
+
+      # Test unions with empty and open maps
+      assert union(empty_map(), open_map([{domain_key(:integer), atom()}]))
+             |> equal?(open_map([{domain_key(:integer), atom()}]))
+
+      assert union(open_map(), open_map([{domain_key(:integer), atom()}]))
+             |> equal?(open_map())
+
+      # Test union of open map and map with domain key
+      assert union(open_map(), open_map([{domain_key(:integer), atom()}]))
+             |> equal?(open_map())
+
+      # Ensure no duplicate, no matter the order
+      assert union(
+               open_map(a: integer()),
+               open_map(a: number(), b: binary())
+             )
+             |> union(open_map(a: integer())) ==
+               union(
+                 open_map(a: number(), b: binary()),
+                 open_map(a: integer())
+               )
+               |> union(open_map(a: integer()))
+    end
+
+    test "list" do
+      assert union(list(term()), list(term())) |> equal?(list(term()))
+      assert union(list(integer()), list(term())) |> equal?(list(term()))
+
+      assert union(difference(list(term()), list(integer())), list(integer()))
+             |> equal?(list(term()))
+    end
+
+    test "fun" do
+      assert equal?(union(fun(), fun()), fun())
+      assert equal?(union(fun(), none_fun(1)), fun())
+
+      dynamic_fun = intersection(fun(), dynamic())
+      assert equal?(union(dynamic_fun, fun()), fun())
+    end
+
+    test "optimizations (maps)" do
+      # The tests are checking the actual implementation, not the semantics.
+      # This is why we are using structural comparisons.
+      # It's fine to remove these if the implementation changes, but breaking
+      # these might have an important impact on compile times.
+
+      # Optimization one: same tags, all but one key are structurally equal
+      assert union(
+               open_map(a: float(), b: atom()),
+               open_map(a: integer(), b: atom())
+             )
+             |> equal?(open_map(a: union(float(), integer()), b: atom()))
+
+      assert union(
+               closed_map(a: float(), b: atom()),
+               closed_map(a: integer(), b: atom())
+             ) == closed_map(a: union(float(), integer()), b: atom())
+
+      # Optimization two: we can tell that one map is a subtype of the other:
+
+      assert union(
+               closed_map(a: term(), b: term()),
+               closed_map(a: float(), b: binary())
+             ) == closed_map(a: term(), b: term())
+
+      assert union(
+               open_map(a: term()),
+               closed_map(a: float(), b: binary())
+             ) == open_map(a: term())
+
+      assert union(
+               closed_map(a: float(), b: binary()),
+               open_map(a: term())
+             ) == open_map(a: term())
+
+      assert union(
+               closed_map(a: term(), b: tuple([term(), term()])),
+               closed_map(a: float(), b: tuple([atom(), binary()]))
+             ) == closed_map(a: term(), b: tuple([term(), term()]))
+    end
+
+    test "optimizations (tuples)" do
+      # Optimization one: same tags, all but one key are structurally equal
+      assert union(
+               open_tuple([float(), atom()]),
+               open_tuple([integer(), atom()])
+             ) == open_tuple([union(float(), integer()), atom()])
+
+      assert union(
+               tuple([float(), atom()]),
+               tuple([integer(), atom()])
+             ) == tuple([union(float(), integer()), atom()])
+
+      # Optimization two: we can tell that one tuple is a subtype of the other:
+
+      assert union(
+               tuple([term(), term()]),
+               tuple([float(), binary()])
+             ) == tuple([term(), term()])
+
+      assert union(
+               open_tuple([term()]),
+               tuple([float(), binary()])
+             ) == open_tuple([term()])
+
+      assert union(
+               tuple([float(), binary()]),
+               open_tuple([term()])
+             ) == open_tuple([term()])
+    end
+  end
+
+  describe "intersection" do
+    test "bitmap" do
+      assert intersection(integer(), union(integer(), float())) == integer()
+      assert intersection(integer(), float()) == none()
+    end
+
+    test "term" do
+      assert intersection(term(), term()) == term()
+      assert intersection(term(), float()) == float()
+      assert intersection(term(), binary()) == binary()
+    end
+
+    test "none" do
+      assert intersection(none(), float()) == none()
+      assert intersection(none(), binary()) == none()
+    end
+
+    test "atom" do
+      assert intersection(atom(), atom()) == atom()
+      assert intersection(atom(), atom([:a])) == atom([:a])
+      assert intersection(atom([:a]), atom([:b])) == none()
+      assert intersection(atom([:a]), negation(atom([:b]))) == atom([:a])
+    end
+
+    test "dynamic" do
+      assert equal?(intersection(dynamic(), dynamic()), dynamic())
+      assert equal?(intersection(dynamic(), term()), dynamic())
+      assert equal?(intersection(term(), dynamic()), dynamic())
+      assert empty?(intersection(dynamic(), none()))
+      assert empty?(intersection(intersection(dynamic(), atom()), integer()))
+
+      assert empty?(intersection(dynamic(not_set()), term()))
+      refute empty?(intersection(dynamic(if_set(integer())), term()))
+
+      # Check for structural equivalence
+      assert intersection(dynamic(not_set()), term()) == none()
+    end
+
+    test "tuple" do
+      assert empty?(intersection(open_tuple([atom()]), open_tuple([integer()])))
+
+      assert intersection(open_tuple([atom()]), tuple([term(), integer()]))
+             |> equal?(tuple([atom(), integer()]))
+
+      assert intersection(tuple([term(), integer()]), tuple([atom(), term()]))
+             |> equal?(tuple([atom(), integer()]))
+    end
+
+    test "map" do
+      assert intersection(open_map(), open_map()) == open_map()
+      assert equal?(intersection(closed_map(a: integer()), open_map()), closed_map(a: integer()))
+
+      assert equal?(
+               intersection(closed_map(a: integer()), open_map(a: integer())),
+               closed_map(a: integer())
+             )
+
+      assert intersection(closed_map(a: integer()), open_map(b: not_set()))
+             |> equal?(closed_map(a: integer()))
+
+      assert intersection(closed_map(a: integer()), open_map(b: if_set(integer())))
+             |> equal?(closed_map(a: integer()))
+
+      assert equal?(
+               intersection(closed_map(a: integer()), closed_map(a: if_set(integer()))),
+               closed_map(a: integer())
+             )
+
+      assert empty?(intersection(closed_map(a: integer()), closed_map(a: atom())))
+    end
+
+    test "map with domain keys" do
+      # %{..., int => t1, atom => t2} and %{int => t3}
+      # intersection is %{int => t1 and t3, atom => none}
+      map1 = open_map([{domain_key(:integer), integer()}, {domain_key(:atom), atom()}])
+      map2 = closed_map([{domain_key(:integer), number()}])
+
+      intersection = intersection(map1, map2)
+
+      expected =
+        closed_map([{domain_key(:integer), integer()}, {domain_key(:atom), none()}])
+
+      assert equal?(intersection, expected)
+
+      # %{..., int => t1, atom => t2} and %{int => t3, pid => t4}
+      # intersection is %{int =>t1 and t3, atom => none, pid => t4}
+      map1 = open_map([{domain_key(:integer), integer()}, {domain_key(:atom), atom()}])
+      map2 = closed_map([{domain_key(:integer), float()}, {domain_key(:pid), binary()}])
+
+      intersection = intersection(map1, map2)
+
+      expected =
+        closed_map([
+          {domain_key(:integer), intersection(integer(), float())},
+          {domain_key(:atom), none()},
+          {domain_key(:pid), binary()}
+        ])
+
+      assert equal?(intersection, expected)
+
+      # %{..., int => t1, string => t3} and %{int => t4}
+      # intersection is %{int => t1 and t4, string => none}
+      map1 = open_map([{domain_key(:integer), integer()}, {domain_key(:binary), binary()}])
+      map2 = closed_map([{domain_key(:integer), float()}])
+
+      intersection = intersection(map1, map2)
+
+      assert equal?(
+               intersection,
+               closed_map([
+                 {domain_key(:integer), intersection(integer(), float())},
+                 {domain_key(:binary), none()}
+               ])
+             )
+
+      assert subtype?(empty_map(), closed_map([{domain_key(:integer), atom()}]))
+
+      t1 = closed_map([{domain_key(:integer), atom()}])
+      t2 = closed_map([{domain_key(:integer), binary()}])
+
+      assert equal?(intersection(t1, t2), empty_map())
+
+      t1 = closed_map([{domain_key(:integer), atom()}])
+      t2 = closed_map([{domain_key(:atom), term()}])
+
+      # their intersection is the empty map
+      refute empty?(intersection(t1, t2))
+      assert equal?(intersection(t1, t2), empty_map())
+    end
+
+    test "list" do
+      assert intersection(list(term()), list(term())) == list(term())
+      assert intersection(list(integer()), list(integer())) == list(integer())
+      assert intersection(list(integer()), list(number())) == list(integer())
+      assert intersection(list(integer()), list(atom())) == empty_list()
+
+      # Empty list intersections
+      assert intersection(empty_list(), list(term())) == empty_list()
+      assert intersection(empty_list(), list(integer())) == empty_list()
+      assert intersection(empty_list(), empty_list()) == empty_list()
+
+      # List with any type
+      assert intersection(list(term()), list(integer())) == list(integer())
+      assert intersection(list(term()), list(integer())) == list(integer())
+
+      # Intersection with more specific types
+      assert intersection(list(integer()), list(atom([:a, :b]))) == empty_list()
+
+      # Intersection with union types
+      assert intersection(list(union(integer(), atom())), list(number())) == list(integer())
+
+      # Intersection with dynamic
+      assert equal?(
+               intersection(dynamic(list(term())), list(integer())),
+               dynamic(list(integer()))
+             )
+
+      assert equal?(intersection(dynamic(list(term())), list(term())), dynamic(list(term())))
+
+      # Nested list intersections
+      assert intersection(list(list(integer())), list(list(number()))) == list(list(integer()))
+      assert intersection(list(list(integer())), list(list(atom()))) == list(empty_list())
+
+      # Intersection with non-list types
+      assert intersection(list(integer()), integer()) == none()
+
+      # Tests for list with last element
+      assert intersection(list(float(), atom()), list(number(), term())) == list(float(), atom())
+
+      assert intersection(list(number(), atom()), list(float(), boolean())) ==
+               list(float(), boolean())
+
+      assert intersection(list(integer(), float()), list(number(), integer())) == empty_list()
+
+      # Empty list with last element
+      assert intersection(empty_list(), list(integer(), atom())) == empty_list()
+      assert intersection(list(integer(), atom()), empty_list()) == empty_list()
+
+      # List with any type and specific last element
+      assert intersection(list(term(), atom()), list(float(), boolean())) ==
+               list(float(), boolean())
+
+      assert intersection(list(term(), term()), list(float(), atom())) == list(float(), atom())
+
+      # Nested lists with last element
+      assert intersection(list(list(integer()), atom()), list(list(number()), boolean())) ==
+               list(list(integer()), boolean())
+
+      assert list(list(integer(), atom()), float())
+             |> intersection(list(list(number(), boolean()), integer())) == empty_list()
+
+      # Union types in last element
+      assert intersection(list(integer(), union(atom(), binary())), list(number(), atom())) ==
+               list(integer(), atom())
+
+      # Dynamic with last element
+      assert intersection(dynamic(list(term(), atom())), list(integer(), boolean()))
+             |> equal?(dynamic(list(integer(), boolean())))
+
+      # Intersection with proper list (should result in empty list)
+      assert intersection(list(integer(), atom()), list(integer())) == empty_list()
+    end
+
+    test "function" do
+      assert not empty?(intersection(negation(none_fun(2)), negation(none_fun(3))))
+    end
+  end
+
+  describe "difference" do
+    test "bitmap" do
+      assert difference(float(), integer()) == float()
+      assert difference(union(float(), integer()), integer()) == float()
+      assert difference(union(float(), integer()), binary()) == union(float(), integer())
+    end
+
+    test "term" do
+      assert difference(float(), term()) == none()
+      assert difference(integer(), term()) == none()
+    end
+
+    test "none" do
+      assert difference(none(), integer()) == none()
+      assert difference(none(), float()) == none()
+
+      assert difference(integer(), none()) == integer()
+      assert difference(float(), none()) == float()
+    end
+
+    test "atom" do
+      assert difference(atom([:a]), atom()) == none()
+      assert difference(atom([:a]), atom([:b])) == atom([:a])
+    end
+
+    test "dynamic" do
+      assert equal?(dynamic(), difference(dynamic(), dynamic()))
+      assert equal?(dynamic(), difference(term(), dynamic()))
+      assert empty?(difference(dynamic(), term()))
+      assert empty?(difference(none(), dynamic()))
+      assert empty?(difference(dynamic(integer()), integer()))
+    end
+
+    test "tuple" do
+      assert empty?(difference(open_tuple([atom()]), open_tuple([term()])))
+      refute empty?(difference(tuple(), empty_tuple()))
+      refute tuple_of_size_at_least(2) |> difference(tuple_of_size(2)) |> empty?()
+      assert tuple_of_size_at_least(2) |> difference(tuple_of_size_at_least(1)) |> empty?()
+      assert tuple_of_size_at_least(3) |> difference(tuple_of_size_at_least(3)) |> empty?()
+      refute tuple_of_size_at_least(2) |> difference(tuple_of_size_at_least(3)) |> empty?()
+      refute tuple([term(), term()]) |> difference(tuple([atom(), term()])) |> empty?()
+      refute tuple([term(), term()]) |> difference(tuple([atom()])) |> empty?()
+      assert tuple([term(), term()]) |> difference(tuple([term(), term()])) |> empty?()
+
+      # {term(), term(), ...} and not ({term(), term(), term(), ...} or {term(), term()})
+      assert tuple_of_size_at_least(2)
+             |> difference(tuple_of_size(2))
+             |> difference(tuple_of_size_at_least(3))
+             |> empty?()
+
+      assert tuple([term(), term()])
+             |> difference(tuple([atom()]))
+             |> difference(open_tuple([term()]))
+             |> difference(empty_tuple())
+             |> empty?()
+
+      refute difference(tuple(), empty_tuple())
+             |> difference(open_tuple([term(), term()]))
+             |> empty?()
+
+      assert difference(open_tuple([term()]), open_tuple([term(), term()]))
+             |> difference(tuple([term()]))
+             |> empty?()
+
+      assert open_tuple([atom()])
+             |> difference(tuple([integer(), integer()]))
+             |> equal?(open_tuple([atom()]))
+
+      assert tuple([union(atom(), integer()), term()])
+             |> difference(open_tuple([atom(), term()]))
+             |> equal?(tuple([integer(), term()]))
+
+      assert tuple([union(atom(), integer()), term()])
+             |> difference(open_tuple([atom(), term()]))
+             |> difference(open_tuple([integer(), term()]))
+             |> empty?()
+
+      assert tuple([term(), union(atom(), integer()), term()])
+             |> difference(open_tuple([term(), integer()]))
+             |> equal?(tuple([term(), atom(), term()]))
+
+      assert difference(tuple(), open_tuple([term(), term()]))
+             |> equal?(union(tuple([term()]), tuple([])))
+    end
+
+    test "map" do
+      assert empty?(difference(open_map(), open_map()))
+      assert empty?(difference(open_map(), term()))
+      assert equal?(difference(open_map(), none()), open_map())
+      assert empty?(difference(closed_map(a: integer()), open_map()))
+      assert empty?(difference(closed_map(a: integer()), closed_map(a: integer())))
+      assert empty?(difference(closed_map(a: integer()), open_map(a: integer())))
+      assert empty?(difference(closed_map(a: integer()), open_map(b: if_set(integer()))))
+
+      assert difference(closed_map(a: integer(), b: if_set(atom())), closed_map(a: integer()))
+             |> difference(closed_map(a: integer(), b: atom()))
+             |> empty?()
+
+      assert difference(open_map(a: atom()), closed_map(b: integer()))
+             |> equal?(open_map(a: atom()))
+
+      refute empty?(difference(open_map(), empty_map()))
+
+      assert difference(open_map(a: integer()), closed_map(b: boolean()))
+             |> equal?(open_map(a: integer()))
+    end
+
+    test "map with domain keys" do
+      # Non-overlapping domain keys
+      t1 = closed_map([{domain_key(:integer), atom()}])
+      t2 = closed_map([{domain_key(:atom), binary()}])
+
+      assert equal?(difference(t1, t2) |> union(empty_map()), t1)
+      assert empty?(difference(t1, t1))
+
+      # %{atom() => t1} and not %{atom() => t2} is not %{atom() => t1 and not t2}
+      t3 = closed_map([{domain_key(:integer), atom()}])
+      t4 = closed_map([{domain_key(:integer), atom([:ok])}])
+      assert subtype?(difference(t3, t4), t3)
+
+      refute difference(t3, t4)
+             |> equal?(closed_map([{domain_key(:integer), difference(atom(), atom([:ok]))}]))
+
+      # Difference with a non-domain key map
+      t5 = closed_map([{domain_key(:integer), union(atom(), integer())}])
+      t6 = closed_map(a: atom())
+      assert equal?(difference(t5, t6), t5)
+
+      # Removing atom keys from a map with defined atom keys
+      a_number = closed_map(a: number())
+      a_number_and_pids = closed_map([{:a, number()}, {domain_key(:atom), pid()}])
+      atom_to_float = closed_map([{domain_key(:atom), float()}])
+      atom_to_term = closed_map([{domain_key(:atom), term()}])
+      atom_to_pid = closed_map([{domain_key(:atom), pid()}])
+      t_diff = difference(a_number, atom_to_float)
+
+      # Removing atom keys that map to float, make the :a key point to integer only.
+      assert map_fetch_key(t_diff, :a) == {false, integer()}
+      # %{a => number, atom => pid} and not %{atom => float} gives numbers on :a
+      assert map_fetch_key(difference(a_number_and_pids, atom_to_float), :a) == {false, number()}
+
+      assert map_fetch_key(t_diff, :foo) == :badkey
+
+      assert subtype?(a_number, atom_to_term)
+      refute subtype?(a_number, atom_to_float)
+
+      # Removing all atom keys from map %{:a => type} means there is nothing left.
+      assert empty?(difference(a_number, atom_to_term))
+      refute empty?(intersection(atom_to_term, a_number))
+      assert empty?(intersection(atom_to_pid, a_number))
+
+      # (%{:a => number} and not %{:a => float}) is %{:a => integer}
+      assert equal?(difference(a_number, atom_to_float), closed_map(a: integer()))
+    end
+
+    test "list" do
+      # Basic list type differences
+      assert difference(list(term()), empty_list()) == non_empty_list(term())
+      assert difference(list(integer()), list(term())) |> empty?()
+
+      assert difference(list(integer()), list(float()))
+             |> equal?(non_empty_list(integer()))
+
+      # All list of integers and floats, minus all lists of integers, is NOT all lists of floats
+      refute difference(list(union(integer(), float())), list(integer()))
+             |> equal?(non_empty_list(float()))
+
+      # Interactions with empty_list()
+      assert difference(empty_list(), list(term())) == none()
+      assert difference(list(integer()), empty_list()) == non_empty_list(integer())
+
+      # Nested list structures
+      assert difference(list(list(integer())), list(list(float())))
+             |> equal?(difference(list(list(integer())), list(empty_list())))
+
+      # Lists with union types
+      refute difference(list(union(integer(), float())), list(integer())) == list(float())
+      refute difference(list(union(atom(), binary())), list(atom())) == list(binary())
+
+      # Tests for list with last element
+      assert difference(list(integer(), atom()), list(number(), term())) |> empty?()
+
+      assert difference(
+               list(atom(), term()),
+               difference(list(atom(), term()), list(atom()))
+             )
+             |> equal?(list(atom()))
+
+      assert difference(list(integer(), float()), list(number(), integer()))
+             |> equal?(non_empty_list(integer(), difference(float(), integer())))
+
+      # Empty list with last element
+      assert difference(empty_list(), list(integer(), atom())) == none()
+
+      assert difference(list(integer(), atom()), empty_list()) ==
+               non_empty_list(integer(), atom())
+
+      # List with any type and specific last element
+      assert difference(list(term(), term()), list(term(), integer()))
+             |> equal?(
+               non_empty_list(term(), negation(union(integer(), non_empty_list(term(), term()))))
+             )
+
+      # Nested lists with last element
+      # "lists of (lists of integers), ending with atom"
+      # minus
+      # "lists of (lists of numbers), ending with boolean"
+      # gives:
+      # "non empty lists of (lists of integers), ending with (atom and not boolean)"
+
+      assert difference(list(list(integer()), atom()), list(list(number()), boolean()))
+             |> equal?(non_empty_list(list(integer()), difference(atom(), boolean())))
+
+      # Union types in last element
+      assert difference(list(integer(), union(atom(), binary())), list(number(), atom()))
+             |> equal?(
+               union(
+                 non_empty_list(integer(), binary()),
+                 non_empty_list(difference(integer(), number()), union(atom(), binary()))
+               )
+             )
+
+      # Dynamic with last element
+      assert equal?(
+               difference(dynamic(list(term(), atom())), list(integer(), term())),
+               dynamic(difference(list(term(), atom()), list(integer(), term())))
+             )
+
+      # Difference with proper list
+      assert difference(list(integer(), atom()), list(integer()))
+             |> equal?(non_empty_list(integer(), atom()))
+    end
+
+    test "fun" do
+      for arity <- [0, 1, 2, 3] do
+        assert empty?(difference(none_fun(arity), none_fun(arity)))
+      end
+
+      assert empty?(difference(fun(), fun()))
+      assert empty?(difference(none_fun(3), fun()))
+      refute empty?(difference(fun(), none_fun(1)))
+      refute empty?(difference(none_fun(2), none_fun(3)))
+      assert empty?(intersection(none_fun(2), none_fun(3)))
+
+      f1f2 = union(none_fun(1), none_fun(2))
+      assert f1f2 |> difference(none_fun(1)) |> difference(none_fun(2)) |> empty?()
+      assert none_fun(1) |> difference(difference(f1f2, none_fun(2))) |> empty?()
+      assert f1f2 |> difference(none_fun(1)) |> equal?(none_fun(2))
+
+      assert fun([integer()], term()) |> difference(fun([none()], term())) |> empty?()
+    end
+  end
+
+  describe "creation" do
+    test "map hoists dynamic" do
+      assert dynamic(open_map(a: integer())) == open_map(a: dynamic(integer()))
+
+      assert dynamic(open_map(a: union(integer(), binary()))) ==
+               open_map(a: dynamic(integer()) |> union(binary()))
+
+      # For domains too
+      t1 = dynamic(open_map([{domain_key(:integer), integer()}]))
+      t2 = open_map([{domain_key(:integer), dynamic(integer())}])
+      assert t1 == t2
+
+      # if_set on dynamic fields also must work
+      t1 = dynamic(open_map(a: if_set(integer())))
+      t2 = open_map(a: if_set(dynamic(integer())))
+      assert t1 == t2
+    end
+  end
+
+  describe "subtype" do
+    test "bitmap" do
+      assert subtype?(integer(), union(integer(), float()))
+      assert subtype?(integer(), integer())
+      assert subtype?(integer(), term())
+      assert subtype?(none(), integer())
+      assert subtype?(integer(), negation(float()))
+    end
+
+    test "atom" do
+      assert subtype?(atom([:a]), atom())
+      assert subtype?(atom([:a]), atom([:a]))
+      assert subtype?(atom([:a]), term())
+      assert subtype?(none(), atom([:a]))
+      assert subtype?(atom([:a]), atom([:a, :b]))
+      assert subtype?(atom([:a]), negation(atom([:b])))
+    end
+
+    test "dynamic" do
+      assert subtype?(dynamic(), term())
+      assert subtype?(dynamic(), dynamic())
+      refute subtype?(term(), dynamic())
+      assert subtype?(intersection(dynamic(), integer()), integer())
+      assert subtype?(integer(), union(dynamic(), integer()))
+    end
+
+    test "tuple" do
+      assert subtype?(empty_tuple(), tuple())
+      assert subtype?(tuple([integer(), atom()]), tuple())
+      refute subtype?(empty_tuple(), open_tuple([term()]))
+      assert subtype?(tuple([integer(), atom()]), tuple([term(), term()]))
+      refute subtype?(tuple([integer(), atom()]), tuple([integer(), integer()]))
+      refute subtype?(tuple([integer(), atom()]), tuple([atom(), atom()]))
+
+      assert subtype?(tuple([integer(), atom()]), open_tuple([integer(), atom()]))
+      refute subtype?(tuple([term()]), open_tuple([term(), term()]))
+      refute subtype?(tuple([integer(), atom()]), open_tuple([integer(), integer()]))
+      refute subtype?(open_tuple([integer(), atom()]), tuple([integer(), integer()]))
+    end
+
+    test "map" do
+      assert subtype?(open_map(), term())
+      assert subtype?(closed_map(a: integer()), open_map())
+      assert subtype?(closed_map(a: integer()), closed_map(a: integer()))
+      assert subtype?(closed_map(a: integer()), open_map(a: integer()))
+      assert subtype?(closed_map(a: integer(), b: atom()), open_map(a: integer()))
+      assert subtype?(closed_map(a: integer()), closed_map(a: union(integer(), atom())))
+
+      # optional
+      refute subtype?(closed_map(a: if_set(integer())), closed_map(a: integer()))
+      assert subtype?(closed_map(a: integer()), closed_map(a: if_set(integer())))
+      refute subtype?(closed_map(a: if_set(term())), closed_map(a: term()))
+      assert subtype?(closed_map(a: term()), closed_map(a: if_set(term())))
+
+      # With domains
+      t1 = closed_map([{domain_key(:integer), number()}])
+      t2 = closed_map([{domain_key(:integer), integer()}])
+
+      assert subtype?(t2, t1)
+
+      t1_minus_t2 = difference(t1, t2)
+      refute empty?(t1_minus_t2)
+
+      assert subtype?(map_with_default(number()), open_map())
+      t = difference(open_map(), map_with_default(number()))
+      refute empty?(t)
+      refute subtype?(open_map(), map_with_default(number()))
+      assert subtype?(map_with_default(integer()), map_with_default(number()))
+      refute subtype?(map_with_default(float()), map_with_default(atom()))
+
+      assert equal?(
+               intersection(map_with_default(number()), map_with_default(float())),
+               map_with_default(float())
+             )
+    end
+
+    test "optional" do
+      refute subtype?(if_set(none()), term())
+      refute subtype?(if_set(term()), term())
+      assert subtype?(if_set(term()), if_set(term()))
+    end
+
+    test "list" do
+      refute subtype?(non_empty_list(integer()), difference(list(number()), list(integer())))
+      assert subtype?(list(term(), boolean()), list(term(), atom()))
+      assert subtype?(list(integer()), list(term()))
+      assert subtype?(list(term()), list(term(), term()))
+    end
+
+    test "fun" do
+      assert equal?(fun([], term()), fun([], term()))
+      refute equal?(fun([], integer()), fun([], atom()))
+      refute subtype?(fun([none()], term()), fun([integer()], integer()))
+
+      # Difference with argument/return type variations
+      int_to_atom = fun([integer()], atom())
+      num_to_atom = fun([number()], atom())
+      int_to_bool = fun([integer()], boolean())
+
+      # number->atom is a subtype of int->atom
+      assert subtype?(num_to_atom, int_to_atom)
+      refute subtype?(int_to_atom, num_to_atom)
+      assert subtype?(int_to_bool, int_to_atom)
+      refute subtype?(int_to_bool, num_to_atom)
+
+      # Multi-arity
+      f1 = fun([integer(), atom()], boolean())
+      f2 = fun([number(), atom()], boolean())
+
+      # (int,atom)->boolean is a subtype of (number,atom)->boolean
+      # since number is a supertype of int
+      assert subtype?(f2, f1)
+      # f1 is not a subtype of f2
+      refute subtype?(f1, f2)
+
+      # Unary functions / Output covariance
+      assert subtype?(fun([], float()), fun([], term()))
+      refute subtype?(fun([], term()), fun([], float()))
+
+      # Contravariance of domain
+      refute subtype?(fun([integer()], boolean()), fun([number()], boolean()))
+      assert subtype?(fun([number()], boolean()), fun([integer()], boolean()))
+
+      # Nested function types
+      higher_order = fun([fun([integer()], atom())], boolean())
+      specific = fun([fun([number()], atom())], boolean())
+
+      assert subtype?(higher_order, specific)
+      refute subtype?(specific, higher_order)
+
+      ## Multi-arity
+      f = fun([none(), integer()], atom())
+      assert subtype?(f, f)
+      assert subtype?(f, fun([none(), integer()], term()))
+      assert subtype?(fun([none(), number()], atom()), f)
+      assert subtype?(fun([tuple(), number()], atom()), f)
+
+      # (none, float -> atom) is not a subtype of (none, integer -> atom)
+      # because float has an empty intersection with integer.
+      # it's only possible to find this out by doing the
+      # intersection one by one.
+      refute subtype?(fun([none(), float()], atom()), f)
+      refute subtype?(fun([pid(), float()], atom()), f)
+      # A function with the wrong arity is refused
+      refute subtype?(fun([none()], atom()), f)
+    end
+  end
+
+  describe "compatible" do
+    test "intersection" do
+      assert compatible?(integer(), intersection(dynamic(), integer()))
+      refute compatible?(intersection(dynamic(), integer()), atom())
+      refute compatible?(atom(), intersection(dynamic(), integer()))
+      refute compatible?(atom(), intersection(dynamic(), atom([:foo, :bar])))
+      assert compatible?(intersection(dynamic(), atom()), atom([:foo, :bar]))
+      assert compatible?(atom([:foo, :bar]), intersection(dynamic(), atom()))
+    end
+
+    test "static" do
+      refute compatible?(atom(), atom([:foo, :bar]))
+      refute compatible?(union(integer(), atom()), integer())
+      refute compatible?(none(), integer())
+      refute compatible?(union(atom(), dynamic()), integer())
+    end
+
+    test "dynamic" do
+      assert compatible?(dynamic(), term())
+      assert compatible?(term(), dynamic())
+      assert compatible?(dynamic(), integer())
+      assert compatible?(integer(), dynamic())
+    end
+
+    test "tuple" do
+      assert compatible?(dynamic(tuple()), tuple([integer(), atom()]))
+    end
+
+    test "map" do
+      assert compatible?(closed_map(a: integer()), open_map())
+      assert compatible?(intersection(dynamic(), open_map()), closed_map(a: integer()))
+    end
+
+    test "list" do
+      assert compatible?(dynamic(), list(term()))
+      assert compatible?(dynamic(list(term())), list(integer()))
+      assert compatible?(dynamic(list(term(), term())), list(integer(), integer()))
+    end
+  end
+
+  describe "empty?" do
+    test "tuple" do
+      assert tuple([none()]) |> empty?()
+      assert open_tuple([integer(), none()]) |> empty?()
+
+      assert intersection(tuple([integer(), atom()]), open_tuple([atom()])) |> empty?()
+      refute open_tuple([integer(), integer()]) |> difference(empty_tuple()) |> empty?()
+      refute open_tuple([integer(), integer()]) |> difference(open_tuple([atom()])) |> empty?()
+      refute open_tuple([term()]) |> difference(tuple([term()])) |> empty?()
+      assert difference(tuple(), empty_tuple()) |> difference(open_tuple([term()])) |> empty?()
+      assert difference(tuple(), open_tuple([term()])) |> difference(empty_tuple()) |> empty?()
+
+      refute open_tuple([term()])
+             |> difference(tuple([term()]))
+             |> difference(tuple([term()]))
+             |> empty?()
+
+      assert tuple([integer(), union(integer(), atom())])
+             |> difference(tuple([integer(), integer()]))
+             |> difference(tuple([integer(), atom()]))
+             |> empty?()
+    end
+
+    test "map" do
+      assert open_map(a: none()) |> empty?()
+      assert closed_map(a: integer(), b: none()) |> empty?()
+      assert intersection(closed_map(b: atom()), open_map(a: integer())) |> empty?()
+    end
+
+    test "fun" do
+      refute empty?(fun())
+      refute empty?(none_fun(1))
+      refute empty?(fun([integer()], atom()))
+
+      assert empty?(intersection(none_fun(1), none_fun(2)))
+      refute empty?(intersection(fun(), none_fun(1)))
+      assert empty?(difference(none_fun(1), union(none_fun(1), none_fun(2))))
+    end
+  end
+
+  describe "function creation" do
+    test "fun_from_non_overlapping_clauses" do
+      assert fun_from_non_overlapping_clauses([{[integer()], atom()}, {[float()], binary()}]) ==
+               intersection(fun([integer()], atom()), fun([float()], binary()))
+    end
+
+    test "fun_from_inferred_clauses" do
+      # No overlap
+      assert fun_from_inferred_clauses([{[integer()], atom()}, {[float()], binary()}])
+             |> equal?(
+               intersection(
+                 fun_from_non_overlapping_clauses([{[integer()], atom()}, {[float()], binary()}]),
+                 fun([number()], dynamic())
+               )
+             )
+
+      # Subsets
+      assert fun_from_inferred_clauses([{[integer()], atom()}, {[number()], binary()}])
+             |> equal?(
+               fun_from_non_overlapping_clauses([
+                 {[integer()], dynamic(union(atom(), binary()))},
+                 {[number()], dynamic(union(atom(), binary()))}
+               ])
+             )
+
+      assert fun_from_inferred_clauses([{[number()], binary()}, {[integer()], atom()}])
+             |> equal?(
+               fun_from_non_overlapping_clauses([
+                 {[integer()], dynamic(union(atom(), binary()))},
+                 {[number()], dynamic(union(atom(), binary()))}
+               ])
+             )
+
+      # Partial
+      assert fun_from_inferred_clauses([
+               {[union(integer(), pid())], atom()},
+               {[union(float(), pid())], binary()}
+             ])
+             |> equal?(
+               fun_from_non_overlapping_clauses([
+                 {[union(integer(), pid())], dynamic(union(atom(), binary()))},
+                 {[union(float(), pid())], dynamic(union(atom(), binary()))}
+               ])
+             )
+
+      # Difference
+      assert fun_from_inferred_clauses([
+               {[integer(), union(pid(), atom())], atom()},
+               {[number(), pid()], binary()}
+             ])
+             |> equal?(
+               fun_from_non_overlapping_clauses([
+                 {[integer(), union(pid(), atom())], dynamic(union(atom(), binary()))},
+                 {[number(), pid()], dynamic(union(atom(), binary()))}
+               ])
+             )
+    end
+  end
+
+  describe "function application" do
+    defp none_fun(arity), do: %{fun: {:union, %{arity => :bdd_top}}}
+
+    test "non funs" do
+      assert fun_apply(term(), [integer()]) == :badfun
+      assert fun_apply(union(integer(), none_fun(1)), [integer()]) == :badfun
+    end
+
+    test "static" do
+      # Full static
+      assert fun_apply(fun(), [integer()]) == {:badarg, [none()]}
+      assert fun_apply(difference(fun(), none_fun(2)), [integer()]) == {:badarg, [none()]}
+
+      # Basic function application scenarios
+      assert fun_apply(fun([integer()], atom()), [integer()]) == {:ok, atom()}
+      assert fun_apply(fun([integer()], atom()), [float()]) == {:badarg, [integer()]}
+      assert fun_apply(fun([integer()], atom()), [term()]) == {:badarg, [integer()]}
+
+      # Return types
+      assert fun_apply(fun([integer()], none()), [integer()]) == {:ok, none()}
+      assert fun_apply(fun([integer()], term()), [integer()]) == {:ok, term()}
+
+      # Dynamic args
+      assert fun_apply(fun([term()], term()), [dynamic()]) == {:ok, term()}
+
+      assert fun_apply(fun([integer()], atom()), [dynamic(integer())])
+             |> elem(1)
+             |> equal?(atom())
+
+      assert fun_apply(fun([integer()], atom()), [dynamic(float())]) == {:badarg, [integer()]}
+      assert fun_apply(fun([integer()], atom()), [dynamic(term())]) == {:ok, dynamic()}
+
+      # Arity mismatches
+      assert fun_apply(fun([integer()], integer()), [term(), term()]) == {:badarity, [1]}
+      assert fun_apply(fun([integer(), atom()], boolean()), [integer()]) == {:badarity, [2]}
+
+      # Function intersection tests (no overlap)
+      fun0 = intersection(fun([integer()], atom()), fun([float()], binary()))
+      assert fun_apply(fun0, [integer()]) == {:ok, atom()}
+      assert fun_apply(fun0, [float()]) == {:ok, binary()}
+      assert fun_apply(fun0, [number()]) == {:ok, union(atom(), binary())}
+
+      assert fun_apply(fun0, [dynamic(integer())]) |> elem(1) |> equal?(atom())
+      assert fun_apply(fun0, [dynamic(float())]) |> elem(1) |> equal?(binary())
+      assert fun_apply(fun0, [dynamic(number())]) |> elem(1) |> equal?(union(atom(), binary()))
+      assert fun_apply(fun0, [dynamic()]) == {:ok, dynamic()}
+
+      # Function intersection tests (overlap)
+      fun1 = intersection(fun([integer()], atom()), fun([number()], term()))
+      assert fun_apply(fun1, [integer()]) == {:ok, atom()}
+      assert fun_apply(fun1, [float()]) == {:ok, term()}
+
+      # Function intersection with unions
+      fun2 =
+        intersection(
+          fun([union(integer(), atom())], term()),
+          fun([union(integer(), pid())], atom())
+        )
+
+      assert fun_apply(fun2, [integer()]) == {:ok, atom()}
+      assert fun_apply(fun2, [atom()]) == {:ok, term()}
+      assert fun_apply(fun2, [pid()]) == {:ok, atom()}
+
+      # Function intersection with same domain, different codomains
+      assert fun([integer()], term())
+             |> intersection(fun([integer()], atom()))
+             |> fun_apply([integer()]) == {:ok, atom()}
+
+      # Function intersection with singleton atoms
+      fun3 = intersection(fun([atom([:ok])], atom([:success])), fun([atom([:ok])], atom([:done])))
+      assert fun_apply(fun3, [atom([:ok])]) == {:ok, none()}
+    end
+
+    test "static with dynamic signature" do
+      assert fun_apply(fun([dynamic()], term()), [dynamic()]) == {:ok, term()}
+      assert fun_apply(fun([integer()], dynamic()), [integer()]) == {:ok, dynamic()}
+
+      assert fun_apply(fun([dynamic()], integer()), [dynamic()]) ==
+               {:ok, union(integer(), dynamic())}
+
+      assert fun_apply(fun([dynamic(), atom()], float()), [dynamic(), atom()]) ==
+               {:ok, union(float(), dynamic())}
+
+      fun = fun([dynamic(integer())], atom())
+      assert fun_apply(fun, [dynamic(integer())]) == {:ok, union(atom(), dynamic())}
+      assert fun_apply(fun, [dynamic(number())]) == {:ok, dynamic()}
+      assert fun_apply(fun, [integer()]) == {:ok, dynamic()}
+      assert fun_apply(fun, [float()]) == {:badarg, [dynamic(integer())]}
+    end
+
+    defp dynamic_fun(args, return), do: dynamic(fun(args, return))
+
+    test "dynamic" do
+      # Full dynamic
+      assert fun_apply(dynamic(), [integer()]) == {:ok, dynamic()}
+      assert fun_apply(dynamic(none_fun(1)), [integer()]) == {:ok, dynamic()}
+      assert fun_apply(difference(dynamic(), none_fun(2)), [integer()]) == {:ok, dynamic()}
+
+      # Basic function application scenarios
+      assert fun_apply(dynamic_fun([integer()], atom()), [integer()]) == {:ok, dynamic(atom())}
+      assert fun_apply(dynamic_fun([integer()], atom()), [float()]) == {:ok, dynamic()}
+      assert fun_apply(dynamic_fun([integer()], atom()), [term()]) == {:ok, dynamic()}
+      assert fun_apply(dynamic_fun([integer()], none()), [integer()]) == {:ok, dynamic(none())}
+      assert fun_apply(dynamic_fun([integer()], term()), [integer()]) == {:ok, dynamic()}
+
+      # Dynamic return and dynamic args
+      assert fun_apply(dynamic_fun([term()], term()), [dynamic()]) == {:ok, dynamic()}
+
+      fun = dynamic_fun([integer()], binary())
+      assert fun_apply(fun, [integer()]) == {:ok, dynamic(binary())}
+      assert fun_apply(fun, [dynamic(integer())]) == {:ok, dynamic(binary())}
+      assert fun_apply(fun, [dynamic(atom())]) == {:ok, dynamic()}
+
+      # Arity mismatches
+      assert fun_apply(dynamic_fun([integer()], integer()), [term(), term()]) == {:badarity, [1]}
+
+      assert fun_apply(dynamic_fun([integer(), atom()], boolean()), [integer()]) ==
+               {:badarity, [2]}
+
+      # Function intersection tests
+      fun0 = intersection(dynamic_fun([integer()], atom()), dynamic_fun([float()], binary()))
+      assert fun_apply(fun0, [integer()]) == {:ok, dynamic(atom())}
+      assert fun_apply(fun0, [float()]) == {:ok, dynamic(binary())}
+      assert fun_apply(fun0, [dynamic(integer())]) == {:ok, dynamic(atom())}
+      assert fun_apply(fun0, [dynamic(float())]) == {:ok, dynamic(binary())}
+      assert fun_apply(fun0, [dynamic(number())]) == {:ok, dynamic(union(binary(), atom()))}
+
+      # Function intersection with subset domain
+      fun1 = intersection(dynamic_fun([integer()], atom()), dynamic_fun([number()], term()))
+      assert fun_apply(fun1, [integer()]) == {:ok, dynamic(atom())}
+      assert fun_apply(fun1, [float()]) == {:ok, dynamic()}
+      assert fun_apply(fun1, [dynamic(integer())]) == {:ok, dynamic(atom())}
+      assert fun_apply(fun1, [dynamic(float())]) == {:ok, dynamic()}
+
+      # Function intersection with same domain, different codomains
+      assert dynamic_fun([integer()], term())
+             |> intersection(dynamic_fun([integer()], atom()))
+             |> fun_apply([integer()]) == {:ok, dynamic(atom())}
+
+      # Function intersection with overlapping domains
+      fun2 =
+        intersection(
+          dynamic_fun([union(integer(), atom())], term()),
+          dynamic_fun([union(integer(), pid())], atom())
+        )
+
+      assert fun_apply(fun2, [integer()]) == {:ok, dynamic(atom())}
+      assert fun_apply(fun2, [atom()]) == {:ok, dynamic()}
+      assert fun_apply(fun2, [pid()]) |> elem(1) |> equal?(dynamic(atom()))
+
+      assert fun_apply(fun2, [dynamic(integer())]) == {:ok, dynamic(atom())}
+      assert fun_apply(fun2, [dynamic(atom())]) == {:ok, dynamic()}
+      assert fun_apply(fun2, [dynamic(pid())]) |> elem(1) |> equal?(dynamic(atom()))
+
+      # Function intersection with singleton atoms
+      fun3 =
+        intersection(
+          dynamic_fun([atom([:ok])], atom([:success])),
+          dynamic_fun([atom([:ok])], atom([:done]))
+        )
+
+      assert fun_apply(fun3, [atom([:ok])]) == {:ok, dynamic(none())}
+    end
+
+    test "static and dynamic" do
+      # Bad arity
+      fun_arities =
+        union(
+          fun([atom()], integer()),
+          dynamic_fun([integer(), float()], binary())
+        )
+
+      assert fun_arities
+             |> fun_apply([atom()])
+             |> elem(1)
+             |> equal?(integer())
+
+      assert fun_arities |> fun_apply([integer(), float()]) == {:badarity, [1]}
+
+      # Bad argument
+      fun_args =
+        union(
+          fun([atom()], integer()),
+          dynamic_fun([integer()], binary())
+        )
+
+      assert fun_args |> fun_apply([atom()]) == {:ok, dynamic()}
+      assert fun_args |> fun_apply([integer()]) == {:badarg, [dynamic(atom())]}
+
+      # Badfun
+      assert union(
+               fun([atom()], integer()),
+               dynamic_fun([integer()], binary()) |> intersection(none_fun(2))
+             )
+             |> fun_apply([atom()])
+             |> elem(1)
+             |> equal?(integer())
+
+      assert union(
+               fun([atom()], integer()) |> intersection(none_fun(2)),
+               dynamic_fun([integer()], binary())
+             )
+             |> fun_apply([integer()]) == {:ok, dynamic(binary())}
+    end
+  end
+
+  describe "projections" do
+    test "truthiness" do
+      for type <- [term(), none(), atom(), boolean(), union(atom([false]), integer())] do
+        assert truthiness(type) == :undefined
+        assert truthiness(dynamic(type)) == :undefined
+      end
+
+      for type <- [atom([false]), atom([nil]), atom([nil, false]), atom([false, nil])] do
+        assert truthiness(type) == :always_false
+        assert truthiness(dynamic(type)) == :always_false
+      end
+
+      for type <-
+            [negation(atom()), atom([true]), negation(atom([false, nil])), atom([:ok]), integer()] do
+        assert truthiness(type) == :always_true
+        assert truthiness(dynamic(type)) == :always_true
+      end
+    end
+
+    test "atom_fetch" do
+      assert atom_fetch(term()) == :error
+      assert atom_fetch(union(term(), dynamic(atom([:foo, :bar])))) == :error
+
+      assert atom_fetch(atom()) == {:infinite, []}
+      assert atom_fetch(dynamic()) == {:infinite, []}
+
+      assert atom_fetch(atom([:foo, :bar])) ==
+               {:finite, [:foo, :bar] |> :sets.from_list(version: 2) |> :sets.to_list()}
+
+      assert atom_fetch(union(atom([:foo, :bar]), dynamic(atom()))) == {:infinite, []}
+      assert atom_fetch(union(atom([:foo, :bar]), dynamic(term()))) == {:infinite, []}
+    end
+
+    test "list_hd" do
+      assert list_hd(none()) == :badnonemptylist
+      assert list_hd(term()) == :badnonemptylist
+      assert list_hd(list(term())) == :badnonemptylist
+      assert list_hd(empty_list()) == :badnonemptylist
+      assert list_hd(non_empty_list(term())) == {:ok, term()}
+      assert list_hd(non_empty_list(integer())) == {:ok, integer()}
+      assert list_hd(difference(list(number()), list(integer()))) == {:ok, number()}
+
+      assert list_hd(dynamic()) == {:ok, dynamic()}
+      assert list_hd(dynamic(list(integer()))) == {:ok, dynamic(integer())}
+      assert list_hd(union(dynamic(), atom())) == :badnonemptylist
+      assert list_hd(union(dynamic(), list(term()))) == :badnonemptylist
+
+      assert list_hd(difference(list(number()), list(number()))) == :badnonemptylist
+      assert list_hd(dynamic(difference(list(number()), list(number())))) == :badnonemptylist
+
+      assert list_hd(union(dynamic(list(float())), non_empty_list(atom()))) ==
+               {:ok, union(dynamic(float()), atom())}
+
+      # If term() is in the tail, it means list(term()) is in the tail
+      # and therefore any term can be returned from hd.
+      assert list_hd(non_empty_list(atom(), term())) == {:ok, term()}
+      assert list_hd(non_empty_list(atom(), negation(list(term(), term())))) == {:ok, atom()}
+    end
+
+    test "list_tl" do
+      assert list_tl(none()) == :badnonemptylist
+      assert list_tl(term()) == :badnonemptylist
+      assert list_tl(empty_list()) == :badnonemptylist
+      assert list_tl(list(integer())) == :badnonemptylist
+      assert list_tl(difference(list(number()), list(number()))) == :badnonemptylist
+
+      assert list_tl(non_empty_list(integer())) == {:ok, list(integer())}
+
+      assert list_tl(non_empty_list(integer(), atom())) ==
+               {:ok, union(atom(), non_empty_list(integer(), atom()))}
+
+      # The tail of either a (non empty) list of integers with an atom tail or a (non empty) list
+      # of tuples with a float tail is either an atom, or a float, or a (possibly empty) list of
+      # integers with an atom tail, or a (possibly empty) list of tuples with a float tail.
+      assert list_tl(union(non_empty_list(integer(), atom()), non_empty_list(tuple(), float()))) ==
+               {:ok,
+                atom()
+                |> union(float())
+                |> union(
+                  union(non_empty_list(integer(), atom()), non_empty_list(tuple(), float()))
+                )}
+
+      assert list_tl(dynamic()) == {:ok, dynamic()}
+      assert list_tl(dynamic(list(integer()))) == {:ok, dynamic(list(integer()))}
+
+      assert list_tl(dynamic(list(integer(), atom()))) ==
+               {:ok, dynamic(union(atom(), list(integer(), atom())))}
+    end
+
+    test "tuple_fetch" do
+      assert tuple_fetch(term(), 0) == :badtuple
+      assert tuple_fetch(integer(), 0) == :badtuple
+      assert tuple_fetch(tuple([none(), atom()]), 1) == :badtuple
+      assert tuple_fetch(tuple([none()]), 0) == :badtuple
+
+      assert tuple_fetch(tuple([integer(), atom()]), 0) == {false, integer()}
+      assert tuple_fetch(tuple([integer(), atom()]), 1) == {false, atom()}
+      assert tuple_fetch(tuple([integer(), atom()]), 2) == :badindex
+
+      assert tuple_fetch(open_tuple([integer(), atom()]), 0) == {false, integer()}
+      assert tuple_fetch(open_tuple([integer(), atom()]), 1) == {false, atom()}
+      assert tuple_fetch(open_tuple([integer(), atom()]), 2) == :badindex
+
+      assert tuple_fetch(tuple([integer(), atom()]), -1) == :badindex
+      assert tuple_fetch(empty_tuple(), 0) == :badindex
+      assert difference(tuple(), tuple()) |> tuple_fetch(0) == :badtuple
+
+      assert tuple([atom()]) |> difference(empty_tuple()) |> tuple_fetch(0) ==
+               {false, atom()}
+
+      assert difference(tuple([union(integer(), atom())]), open_tuple([atom()]))
+             |> tuple_fetch(0) == {false, integer()}
+
+      assert tuple_fetch(union(tuple([integer(), atom()]), dynamic(open_tuple([atom()]))), 1)
+             |> Kernel.then(fn {opt, ty} -> opt and equal?(ty, union(atom(), dynamic())) end)
+
+      assert tuple_fetch(union(tuple([integer()]), tuple([atom()])), 0) ==
+               {false, union(integer(), atom())}
+
+      assert tuple([integer(), atom(), union(atom(), integer())])
+             |> difference(tuple([integer(), term(), atom()]))
+             |> tuple_fetch(2) == {false, integer()}
+
+      assert tuple([integer(), atom(), union(union(atom(), integer()), list(term()))])
+             |> difference(tuple([integer(), term(), atom()]))
+             |> difference(open_tuple([term(), atom(), list(term())]))
+             |> tuple_fetch(2) == {false, integer()}
+
+      assert tuple([integer(), atom(), integer()])
+             |> difference(tuple([integer(), term(), integer()]))
+             |> tuple_fetch(1) == :badtuple
+
+      assert tuple([integer(), atom(), integer()])
+             |> difference(tuple([integer(), term(), atom()]))
+             |> tuple_fetch(2) == {false, integer()}
+
+      assert tuple_fetch(tuple(), 0) == :badindex
+    end
+
+    test "tuple_fetch with dynamic" do
+      assert tuple_fetch(dynamic(), 0) == {true, dynamic()}
+      assert tuple_fetch(dynamic(empty_tuple()), 0) == :badindex
+      assert tuple_fetch(dynamic(tuple([integer(), atom()])), 2) == :badindex
+      assert tuple_fetch(union(dynamic(), integer()), 0) == :badtuple
+
+      assert tuple_fetch(dynamic(tuple()), 0)
+             |> Kernel.then(fn {opt, type} -> opt and equal?(type, dynamic()) end)
+
+      assert tuple_fetch(union(dynamic(), open_tuple([atom()])), 0) ==
+               {true, union(atom(), dynamic())}
+    end
+
+    test "tuple_delete_at" do
+      assert tuple_delete_at(tuple([integer(), atom()]), 3) == :badindex
+      assert tuple_delete_at(tuple([integer(), atom()]), -1) == :badindex
+      assert tuple_delete_at(empty_tuple(), 0) == :badindex
+      assert tuple_delete_at(integer(), 0) == :badtuple
+      assert tuple_delete_at(term(), 0) == :badtuple
+      assert tuple_delete_at(tuple([none()]), 0) == :badtuple
+
+      # Test deleting an element from a closed tuple
+      assert tuple_delete_at(tuple([integer(), atom(), boolean()]), 1) ==
+               tuple([integer(), boolean()])
+
+      # Test deleting the last element from a closed tuple
+      assert tuple_delete_at(tuple([integer(), atom()]), 1) ==
+               tuple([integer()])
+
+      # Test deleting from an open tuple
+      assert tuple_delete_at(open_tuple([integer(), atom(), boolean()]), 1) ==
+               open_tuple([integer(), boolean()])
+
+      # Test deleting from a dynamic tuple
+      assert tuple_delete_at(dynamic(tuple([integer(), atom()])), 1) ==
+               dynamic(tuple([integer()]))
+
+      # Test deleting from a union of tuples
+      assert tuple_delete_at(union(tuple([integer(), atom()]), tuple([float(), binary()])), 1)
+             |> equal?(tuple([union(integer(), float())]))
+
+      # Test deleting from an intersection of tuples
+      assert intersection(tuple([integer(), atom()]), tuple([term(), boolean()]))
+             |> tuple_delete_at(1) == tuple([integer()])
+
+      # Test deleting from a difference of tuples
+      assert difference(tuple([integer(), atom(), boolean()]), tuple([term(), term()]))
+             |> tuple_delete_at(1)
+             |> equal?(tuple([integer(), boolean()]))
+
+      # Test deleting from a complex union involving dynamic
+      assert union(tuple([integer(), atom()]), dynamic(tuple([float(), binary()])))
+             |> tuple_delete_at(1)
+             |> equal?(union(tuple([integer()]), dynamic(tuple([float()]))))
+
+      # Successfully deleting at position `index` in a tuple means that the dynamic
+      # values that succeed are intersected with tuples of size at least `index`
+      assert dynamic(tuple()) |> tuple_delete_at(0) == dynamic(tuple())
+      assert dynamic(term()) |> tuple_delete_at(0) == dynamic(tuple())
+
+      assert dynamic(union(tuple(), integer()))
+             |> tuple_delete_at(1)
+             |> equal?(dynamic(tuple_of_size_at_least(1)))
+    end
+
+    test "tuple_insert_at" do
+      assert tuple_insert_at(tuple([integer(), atom()]), 3, boolean()) == :badindex
+      assert tuple_insert_at(tuple([integer(), atom()]), -1, boolean()) == :badindex
+      assert tuple_insert_at(integer(), 0, boolean()) == :badtuple
+      assert tuple_insert_at(term(), 0, boolean()) == :badtuple
+
+      # Out-of-bounds in a union
+      assert union(tuple([integer(), atom()]), tuple([float()]))
+             |> tuple_insert_at(2, boolean()) == :badindex
+
+      # Test inserting into a closed tuple
+      assert tuple_insert_at(tuple([integer(), atom()]), 1, boolean()) ==
+               tuple([integer(), boolean(), atom()])
+
+      # Test inserting at the beginning of a tuple
+      assert tuple_insert_at(tuple([integer(), atom()]), 0, boolean()) ==
+               tuple([boolean(), integer(), atom()])
+
+      # Test inserting at the end of a tuple
+      assert tuple_insert_at(tuple([integer(), atom()]), 2, boolean()) ==
+               tuple([integer(), atom(), boolean()])
+
+      # Test inserting into an empty tuple
+      assert tuple_insert_at(empty_tuple(), 0, integer()) == tuple([integer()])
+
+      # Test inserting into an open tuple
+      assert tuple_insert_at(open_tuple([integer(), atom()]), 1, boolean()) ==
+               open_tuple([integer(), boolean(), atom()])
+
+      # Test inserting a dynamic type
+      assert tuple_insert_at(tuple([integer(), atom()]), 1, dynamic()) ==
+               dynamic(tuple([integer(), term(), atom()]))
+
+      # Test inserting into a dynamic tuple
+      assert tuple_insert_at(dynamic(tuple([integer(), atom()])), 1, boolean()) ==
+               dynamic(tuple([integer(), boolean(), atom()]))
+
+      # Test inserting into a union of tuples
+      assert tuple_insert_at(union(tuple([integer()]), tuple([atom()])), 0, boolean()) ==
+               union(tuple([boolean(), integer()]), tuple([boolean(), atom()]))
+
+      # Test inserting into a difference of tuples
+      assert difference(tuple([integer(), atom(), boolean()]), tuple([term(), term()]))
+             |> tuple_insert_at(1, float())
+             |> equal?(tuple([integer(), float(), atom(), boolean()]))
+
+      # Test inserting into a complex union involving dynamic
+      assert union(tuple([integer(), atom()]), dynamic(tuple([float(), binary()])))
+             |> tuple_insert_at(1, boolean())
+             |> equal?(
+               union(
+                 tuple([integer(), boolean(), atom()]),
+                 dynamic(tuple([float(), boolean(), binary()]))
+               )
+             )
+
+      # If you successfully intersect at position index in a type, then the dynamic values
+      # that succeed are intersected with tuples of size at least index
+      assert dynamic(union(tuple(), integer()))
+             |> tuple_insert_at(1, boolean())
+             |> equal?(dynamic(open_tuple([term(), boolean()])))
+    end
+
+    test "tuple_values" do
+      assert tuple_values(integer()) == :badtuple
+      assert tuple_values(tuple([none()])) == :badtuple
+      assert tuple_values(tuple([])) == none()
+      assert tuple_values(tuple()) == term()
+      assert tuple_values(open_tuple([integer()])) == term()
+      assert tuple_values(tuple([integer(), atom()])) == union(integer(), atom())
+
+      assert tuple_values(union(tuple([float(), pid()]), tuple([reference()]))) ==
+               union(float(), union(pid(), reference()))
+
+      assert tuple_values(difference(tuple([number(), atom()]), tuple([float(), term()]))) ==
+               union(integer(), atom())
+
+      assert union(tuple([atom([:ok])]), open_tuple([integer()]))
+             |> difference(open_tuple([term(), term()]))
+             |> tuple_values() == union(atom([:ok]), integer())
+
+      assert tuple_values(difference(tuple([number(), atom()]), tuple([float(), atom([:ok])]))) ==
+               union(number(), atom())
+
+      assert tuple_values(dynamic(tuple())) == dynamic()
+      assert tuple_values(dynamic(tuple([integer()]))) == dynamic(integer())
+
+      assert tuple_values(union(dynamic(tuple([integer()])), tuple([atom()]))) ==
+               union(dynamic(integer()), atom())
+
+      assert tuple_values(union(dynamic(tuple()), integer())) == :badtuple
+      assert tuple_values(dynamic(union(integer(), tuple([atom()])))) == dynamic(atom())
+
+      assert tuple_values(union(dynamic(tuple([integer()])), tuple([integer()])))
+             |> equal?(integer())
+    end
+
+    test "map_to_list" do
+      assert map_to_list(:term) == :badmap
+      assert map_to_list(integer()) == :badmap
+      assert map_to_list(union(open_map(), integer())) == :badmap
+      assert map_to_list(none()) == :badmap
+      assert map_to_list(dynamic()) == {:ok, dynamic(list(tuple([term(), term()])))}
+
+      # A non existent map type is refused
+      assert open_map()
+             |> difference(open_map(a: if_set(term()), c: if_set(term())))
+             |> map_to_list() == :badmap
+
+      assert map_to_list(empty_map()) == {:ok, empty_list()}
+      assert map_to_list(open_map()) == {:ok, list(tuple([term(), term()]))}
+
+      assert map_to_list(closed_map(a: integer())) ==
+               {:ok, non_empty_list(tuple([atom([:a]), integer()]))}
+
+      assert map_to_list(closed_map(a: integer(), b: atom())) ==
+               {:ok,
+                non_empty_list(
+                  tuple([atom([:a]), integer()])
+                  |> union(tuple([atom([:b]), atom()]))
+                )}
+
+      assert map_to_list(union(closed_map(a: float()), closed_map(b: pid()))) ==
+               {:ok,
+                non_empty_list(
+                  tuple([atom([:a]), float()])
+                  |> union(tuple([atom([:b]), pid()]))
+                )}
+
+      # Test with domain keys
+      assert map_to_list(closed_map([{domain_key(:integer), binary()}])) ==
+               {:ok, list(tuple([integer(), binary()]))}
+
+      assert map_to_list(closed_map([{domain_key(:tuple), binary()}])) ==
+               {:ok, list(tuple([tuple(), binary()]))}
+
+      # Test with both atom keys and domain keys
+      map_with_both =
+        closed_map([
+          {:a, atom([:ok])},
+          {:b, float()},
+          {domain_key(:integer), binary()},
+          {domain_key(:tuple), pid()}
+        ])
+
+      assert map_to_list(map_with_both) ==
+               {:ok,
+                non_empty_list(
+                  tuple([atom([:a]), atom([:ok])])
+                  |> union(tuple([atom([:b]), float()]))
+                  |> union(tuple([integer(), binary()]))
+                  |> union(tuple([tuple(), pid()]))
+                )}
+
+      # Test open maps - should return list of key-value tuples
+      assert map_to_list(open_map()) == {:ok, list(tuple([term(), term()]))}
+      assert map_to_list(open_map(a: integer())) == {:ok, non_empty_list(tuple([term(), term()]))}
+
+      {:ok, list} = map_to_list(open_map([{domain_key(:integer), binary()}]))
+
+      assert list(
+               Enum.reduce(
+                 [binary(), float(), pid(), port(), reference()] ++
+                   [fun(), atom(), tuple(), open_map(), list(term(), term())],
+                 tuple([integer(), binary()]),
+                 fn domain, acc -> union(acc, tuple([domain, term()])) end
+               )
+             )
+             |> equal?(list)
+
+      # Test with multiple domain keys
+      multiple_domains =
+        closed_map([
+          {domain_key(:integer), atom([:int])},
+          {domain_key(:float), atom([:float])},
+          {domain_key(:atom), binary()},
+          {domain_key(:binary), integer()},
+          {domain_key(:tuple), float()}
+        ])
+
+      assert map_to_list(multiple_domains) ==
+               {:ok,
+                list(
+                  tuple([integer(), atom([:int])])
+                  |> union(tuple([float(), atom([:float])]))
+                  |> union(tuple([atom(), binary()]))
+                  |> union(tuple([binary(), integer()]))
+                  |> union(tuple([tuple(), float()]))
+                )}
+
+      # Test dynamic maps
+      assert map_to_list(dynamic(open_map())) ==
+               {:ok, dynamic(list(tuple([term(), term()])))}
+
+      assert map_to_list(dynamic(closed_map(a: integer()))) ==
+               {:ok, dynamic(non_empty_list(tuple([atom([:a]), integer()])))}
+
+      assert map_to_list(union(dynamic(closed_map(a: integer())), closed_map(b: atom()))) ==
+               {:ok,
+                union(
+                  non_empty_list(tuple([atom([:b]), atom()])),
+                  dynamic(
+                    non_empty_list(
+                      union(
+                        tuple([atom([:a]), integer()]),
+                        tuple([atom([:b]), atom()])
+                      )
+                    )
+                  )
+                )}
+
+      # A static integer is refused
+      assert map_to_list(union(dynamic(open_map()), integer())) == :badmap
+
+      # Test with negations
+      assert map_to_list(
+               difference(closed_map(a: integer(), b: atom()), closed_map(a: integer()))
+             ) ==
+               {:ok,
+                non_empty_list(
+                  tuple([atom([:a]), integer()])
+                  |> union(tuple([atom([:b]), atom()]))
+                )}
+
+      # If a key is removed entirely by a negation, it should not appear in the result
+      assert closed_map(a: if_set(integer()), b: atom())
+             |> difference(closed_map(a: integer(), b: term()))
+             |> map_to_list() ==
+               {:ok, non_empty_list(tuple([atom([:b]), atom()]))}
+    end
+
+    test "domain_to_args" do
+      # take complex tuples, normalize them, and check if they are still equal
+      complex_tuples = [
+        tuple([term(), atom(), number()])
+        |> difference(tuple([atom(), atom(), float()])),
+        # overlapping union and difference producing multiple variants
+        difference(
+          tuple([union(atom(), pid()), union(integer(), float())]),
+          tuple([union(atom(), pid()), float()])
+        )
+      ]
+
+      Enum.each(complex_tuples, fn domain ->
+        args = domain_to_args(domain)
+
+        assert Enum.reduce(args, none(), &union(args_to_domain(&1), &2))
+               |> equal?(domain)
+      end)
+    end
+
+    test "map_fetch_key" do
+      assert map_fetch_key(term(), :a) == :badmap
+      assert map_fetch_key(union(open_map(), integer()), :a) == :badmap
+      assert map_fetch_key(difference(open_map(), open_map()), :a) == :badmap
+
+      assert map_fetch_key(difference(closed_map(a: integer()), closed_map(a: term())), :a) ==
+               :badmap
+
+      assert map_fetch_key(open_map(), :a) == :badkey
+      assert map_fetch_key(open_map(a: not_set()), :a) == :badkey
+      assert map_fetch_key(union(closed_map(a: integer()), closed_map(b: atom())), :a) == :badkey
+
+      assert map_fetch_key(closed_map(a: integer()), :a) == {false, integer()}
+
+      assert map_fetch_key(union(closed_map(a: integer()), closed_map(a: atom())), :a) ==
+               {false, union(integer(), atom())}
+
+      {false, value_type} =
+        open_map(my_map: open_map(foo: integer()))
+        |> intersection(open_map(my_map: open_map(bar: boolean())))
+        |> map_fetch_key(:my_map)
+
+      assert equal?(value_type, open_map(foo: integer(), bar: boolean()))
+
+      {false, value_type} =
+        closed_map(a: union(integer(), atom()))
+        |> difference(open_map(a: integer()))
+        |> map_fetch_key(:a)
+
+      assert equal?(value_type, atom())
+
+      {false, value_type} =
+        closed_map(a: integer(), b: atom())
+        |> difference(closed_map(a: integer(), b: atom([:foo])))
+        |> map_fetch_key(:a)
+
+      assert equal?(value_type, integer())
+
+      {false, value_type} =
+        closed_map(a: integer())
+        |> difference(closed_map(a: atom()))
+        |> map_fetch_key(:a)
+
+      assert equal?(value_type, integer())
+
+      {false, value_type} =
+        open_map(a: integer(), b: atom())
+        |> union(closed_map(a: tuple()))
+        |> map_fetch_key(:a)
+
+      assert equal?(value_type, union(integer(), tuple()))
+
+      {false, value_type} =
+        closed_map(a: atom())
+        |> difference(closed_map(a: atom([:foo, :bar])))
+        |> difference(closed_map(a: atom([:bar])))
+        |> map_fetch_key(:a)
+
+      assert equal?(value_type, intersection(atom(), negation(atom([:foo, :bar]))))
+
+      assert closed_map(a: union(atom([:ok]), pid()), b: integer(), c: tuple())
+             |> difference(open_map(a: atom([:ok]), b: integer()))
+             |> difference(open_map(a: atom(), c: tuple()))
+             |> map_fetch_key(:a) == {false, pid()}
+
+      assert closed_map(a: union(atom([:foo]), pid()), b: integer(), c: tuple())
+             |> difference(open_map(a: atom([:foo]), b: integer()))
+             |> difference(open_map(a: atom(), c: tuple()))
+             |> map_fetch_key(:a) == {false, pid()}
+
+      assert closed_map(a: union(atom([:foo, :bar, :baz]), integer()))
+             |> difference(open_map(a: atom([:foo, :bar])))
+             |> difference(open_map(a: atom([:foo, :baz])))
+             |> map_fetch_key(:a) == {false, integer()}
+    end
+
+    test "map_fetch_key with dynamic" do
+      assert map_fetch_key(dynamic(), :a) == {true, dynamic()}
+      assert map_fetch_key(union(dynamic(), integer()), :a) == :badmap
+      assert map_fetch_key(union(dynamic(open_map(a: integer())), integer()), :a) == :badmap
+      assert map_fetch_key(union(dynamic(integer()), integer()), :a) == :badmap
+
+      assert intersection(dynamic(), open_map(a: integer()))
+             |> map_fetch_key(:a) == {false, intersection(integer(), dynamic())}
+
+      {false, type} = union(dynamic(integer()), open_map(a: integer())) |> map_fetch_key(:a)
+      assert equal?(type, integer())
+
+      assert union(dynamic(integer()), open_map(a: if_set(integer()))) |> map_fetch_key(:a) ==
+               :badkey
+
+      assert union(dynamic(open_map(a: atom())), open_map(a: integer()))
+             |> map_fetch_key(:a) == {false, union(dynamic(atom()), integer())}
+    end
+
+    test "map_fetch_key with domain keys" do
+      integer_to_atom = open_map([{domain_key(:integer), atom()}])
+      assert map_fetch_key(integer_to_atom, :foo) == :badkey
+
+      # the key :a is for sure of type pid and exists in type
+      # %{atom() => pid()} and not %{:a => not_set()}
+      t1 = closed_map([{domain_key(:atom), pid()}])
+      t2 = closed_map(a: not_set())
+      t3 = open_map(a: not_set())
+
+      # Indeed, t2 is equivalent to the empty map
+      assert map_fetch_key(difference(t1, t2), :a) == :badkey
+      assert map_fetch_key(difference(t1, t3), :a) == {false, pid()}
+
+      t4 = closed_map([{domain_key(:pid), atom()}])
+      assert map_fetch_key(difference(t1, t4) |> difference(t3), :a) == {false, pid()}
+
+      assert map_fetch_key(closed_map([{domain_key(:atom), pid()}]), :a) == :badkey
+
+      assert map_fetch_key(dynamic(closed_map([{domain_key(:atom), pid()}])), :a) ==
+               {true, dynamic(pid())}
+
+      assert closed_map([{domain_key(:atom), number()}])
+             |> difference(open_map(a: if_set(integer())))
+             |> map_fetch_key(:a) == {false, float()}
+
+      assert closed_map([{domain_key(:atom), number()}])
+             |> difference(closed_map(b: if_set(integer())))
+             |> map_fetch_key(:a) == :badkey
+    end
+  end
+
+  describe "map_get" do
+    test "with domain keys" do
+      assert map_get(term(), term()) == :badmap
+
+      map_type = closed_map([{domain_key(:tuple), binary()}])
+      assert map_get(map_type, tuple()) == {true, binary()}
+
+      # Type with all domain types
+      # %{:bar => :ok, integer() => :int, float() => :float, atom() => binary(), binary() => integer(), tuple() => float(), map() => pid(), reference() => port(), pid() => boolean()}
+      all_domains =
+        closed_map([
+          {:bar, atom([:ok])},
+          {domain_key(:integer), atom([:int])},
+          {domain_key(:float), atom([:float])},
+          {domain_key(:atom), binary()},
+          {domain_key(:binary), integer()},
+          {domain_key(:tuple), float()},
+          {domain_key(:map), pid()},
+          {domain_key(:reference), port()},
+          {domain_key(:pid), reference()},
+          {domain_key(:port), boolean()}
+        ])
+
+      assert map_get(all_domains, atom([:bar])) == {false, atom([:ok])}
+
+      assert map_get(all_domains, integer()) == {true, atom([:int])}
+      assert map_get(all_domains, number()) == {true, atom([:int, :float])}
+
+      assert map_get(all_domains, empty_list()) == :error
+      assert map_get(all_domains, atom([:foo])) == {true, binary()}
+      assert map_get(all_domains, binary()) == {true, integer()}
+      assert map_get(all_domains, tuple([integer(), atom()])) == {true, float()}
+      assert map_get(all_domains, empty_map()) == {true, pid()}
+
+      # Union
+      assert map_get(all_domains, union(tuple(), empty_map())) ==
+               {true, union(float(), pid())}
+
+      # Removing all maps with tuple keys
+      t_no_tuple = difference(all_domains, closed_map([{domain_key(:tuple), float()}]))
+      t_really_no_tuple = difference(all_domains, open_map([{domain_key(:tuple), float()}]))
+      assert subtype?(all_domains, open_map())
+      # It's only closed maps, so it should not change
+      assert map_get(t_no_tuple, tuple()) == {true, float()}
+      # This time we actually removed all tuple to float keys
+      assert map_get(t_really_no_tuple, tuple()) == :error
+
+      t1 = closed_map([{domain_key(:tuple), integer()}])
+      t2 = closed_map([{domain_key(:tuple), float()}])
+      t3 = union(t1, t2)
+      assert map_get(t3, tuple()) == {true, number()}
+    end
+
+    test "with dynamic" do
+      {_answer, type_selected} = map_get(dynamic(), term())
+      assert equal?(type_selected, dynamic())
+    end
+
+    test "with atom fall back" do
+      map = closed_map([{:a, atom([:a])}, {:b, atom([:b])}, {domain_key(:atom), pid()}])
+
+      assert map_get(map, atom([:a, :b])) ==
+               {false, atom([:a, :b])}
+
+      assert map_get(map, atom([:a, :c])) ==
+               {true, union(atom([:a]), pid())}
+
+      assert map_get(map, atom() |> difference(atom([:a, :b]))) ==
+               {true, pid()}
+
+      assert map_get(map, atom() |> difference(atom([:a]))) ==
+               {true, union(atom([:b]), pid())}
+
+      assert map_get(closed_map(a: atom([:a]), b: atom([:b])), atom()) ==
+               {true, atom([:a, :b])}
+
+      assert map_get(closed_map([{domain_key(:atom), integer()}]), atom([:a, :b])) ==
+               {true, integer()}
+    end
+
+    test "with lists" do
+      # Verify that empty_list() bitmap type maps to :list domain (not :empty_list domain)
+      map_with_list_domain = closed_map([{domain_key(:list), atom([:empty])}])
+
+      # empty_list() should access the :list domain
+      assert map_get(map_with_list_domain, empty_list()) == {true, atom([:empty])}
+
+      # non_empty_list() should also access the :list domain
+      assert map_get(map_with_list_domain, non_empty_list(integer())) ==
+               {true, atom([:empty])}
+
+      # list() should also access the :list domain
+      assert map_get(map_with_list_domain, list(integer())) ==
+               {true, atom([:empty])}
+
+      # If I create a map and instantiate both empty_list() and non_empty_list(integer()), it should return the union of the two types
+      map =
+        closed_map([{domain_key(:list), atom([:empty])}, {domain_key(:list), atom([:non_empty])}])
+
+      assert map_get(map, empty_list()) == {true, atom([:empty, :non_empty])}
+
+      assert map_get(map, non_empty_list(integer())) ==
+               {true, atom([:empty, :non_empty])}
+
+      assert map_get(map, list(integer())) == {true, atom([:empty, :non_empty])}
+    end
+  end
+
+  describe "map_update" do
+    test "with static atom keys" do
+      assert map_update(open_map(key: binary()), atom([:key]), integer()) ==
+               {binary(), open_map(key: integer()), []}
+
+      assert map_update(dynamic(open_map(key: binary())), atom([:key]), integer()) ==
+               {dynamic(binary()), dynamic(open_map(key: integer())), []}
+
+      # Optional fail for static maps
+      assert map_update(open_map(key: if_set(atom([:value]))), atom([:key]), integer()) ==
+               {:error, [badkey: :key]}
+
+      # But optional does not fail for dynamic ones
+      assert map_update(dynamic(open_map(key: if_set(atom([:value])))), atom([:key]), integer()) ==
+               {dynamic(atom([:value])), dynamic(open_map(key: integer())), []}
+
+      {type, descr, []} = map_update(dynamic(), atom([:key]), integer())
+      assert equal?(type, dynamic())
+      assert descr == dynamic(open_map(key: integer()))
+
+      # Empty value fails for static maps
+      assert map_update(closed_map(key: not_set()), atom([:key]), integer()) ==
+               {:error, [badkey: :key]}
+
+      # When putting multiple keys, we don't know which one will be set
+      assert map_update(open_map(key1: atom(), key2: binary()), atom([:key1, :key2]), integer()) ==
+               {union(atom(), binary()),
+                union(
+                  open_map(key1: atom(), key2: integer()),
+                  open_map(key1: integer(), key2: binary())
+                ), []}
+
+      # When putting multiple keys, all have to be set
+      assert map_update(open_map(key1: atom(), key2: binary()), atom([:key1, :key3]), integer()) ==
+               {atom(), open_map(key1: integer(), key2: binary()), [badkey: :key3]}
+
+      {type, descr, []} = map_update(dynamic(open_map()), atom([:key1, :key2]), integer())
+      assert equal?(type, dynamic())
+      assert descr == dynamic(union(open_map(key1: integer()), open_map(key2: integer())))
+
+      # A non-existing map
+      assert open_map()
+             |> difference(open_map(a: if_set(term()), c: if_set(term())))
+             |> map_update(atom([:b]), integer()) == {:error, [badkey: :b]}
+    end
+
+    test "with dynamic atom keys" do
+      assert map_update(closed_map(key: atom([:value])), dynamic(), atom([:new_value])) ==
+               {atom([:value]), closed_map(key: atom([:value, :new_value])), []}
+
+      assert map_update(dynamic(closed_map(key: atom([:value]))), dynamic(), atom([:new_value])) ==
+               {dynamic(atom([:value])), dynamic(closed_map(key: atom([:value, :new_value]))), []}
+
+      # When precise dynamic keys are given, at least one must succeed
+      assert map_update(
+               open_map(key1: atom(), key2: binary()),
+               dynamic(atom([:key1, :key3])),
+               integer()
+             ) == {atom(), open_map(key1: integer(), key2: binary()), []}
+
+      assert map_update(
+               open_map(key1: atom(), key2: binary()),
+               dynamic(atom([:key3, :key4])),
+               integer()
+             ) == {:error, []}
+    end
+
+    test "with domain keys" do
+      map =
+        closed_map([
+          {domain_key(:integer), binary()},
+          {domain_key(:pid), binary()},
+          {domain_key(:port), binary()}
+        ])
+
+      assert map_update(map, none(), integer()) ==
+               {:error, []}
+
+      assert map_update(map, integer(), integer()) ==
+               {binary(),
+                closed_map([
+                  {domain_key(:integer), union(integer(), binary())},
+                  {domain_key(:pid), binary()},
+                  {domain_key(:port), binary()}
+                ]), []}
+
+      assert map_update(map, union(pid(), integer()), integer()) ==
+               {binary(),
+                closed_map([
+                  {domain_key(:integer), union(integer(), binary())},
+                  {domain_key(:pid), union(integer(), binary())},
+                  {domain_key(:port), binary()}
+                ]), []}
+
+      assert map_update(map, union(pid(), reference()), integer()) ==
+               {binary(),
+                closed_map([
+                  {domain_key(:integer), binary()},
+                  {domain_key(:pid), union(integer(), binary())},
+                  {domain_key(:port), binary()}
+                ]), [baddomain: reference()]}
+
+      assert map_update(map, union(pid(), dynamic(union(reference(), integer()))), integer()) ==
+               {binary(),
+                closed_map([
+                  {domain_key(:integer), union(integer(), binary())},
+                  {domain_key(:pid), union(integer(), binary())},
+                  {domain_key(:port), binary()}
+                ]), []}
+
+      assert map_update(map, union(pid(), dynamic(union(reference(), binary()))), integer()) ==
+               {binary(),
+                closed_map([
+                  {domain_key(:integer), binary()},
+                  {domain_key(:pid), union(integer(), binary())},
+                  {domain_key(:port), binary()}
+                ]), []}
+
+      assert map_update(map, dynamic(union(reference(), binary())), integer()) ==
+               {:error, []}
+
+      # Putting dynamic atom over record keys
+      assert map_update(closed_map(key1: binary(), key2: pid()), atom(), integer()) ==
+               {union(binary(), pid()),
+                closed_map(key1: union(integer(), binary()), key2: union(integer(), pid())),
+                [baddomain: atom()]}
+
+      assert map_update(closed_map(key1: binary(), key2: pid()), dynamic(atom()), integer()) ==
+               {union(binary(), pid()),
+                closed_map(key1: union(integer(), binary()), key2: union(integer(), pid())), []}
+
+      # A non-existing map
+      assert open_map()
+             |> difference(open_map(a: if_set(term()), c: if_set(term())))
+             |> map_update(binary(), integer()) == {:error, [baddomain: binary()]}
+    end
+
+    test "with mixed keys" do
+      assert map_update(dynamic(), union(atom([:key]), binary()), integer()) ==
+               {dynamic(), dynamic(open_map()), []}
+
+      # When precise dynamic keys are given, at least one must succeed
+      assert map_update(
+               closed_map([{:key, atom()}, {domain_key(:integer), binary()}]),
+               dynamic(union(atom([:key]), integer())),
+               integer()
+             ) ==
+               {union(atom(), binary()),
+                union(
+                  closed_map([{:key, integer()}, {domain_key(:integer), binary()}]),
+                  closed_map([{:key, atom()}, {domain_key(:integer), union(binary(), integer())}])
+                ), []}
+
+      assert map_update(
+               closed_map([{:key, atom()}, {domain_key(:integer), binary()}]),
+               dynamic(union(atom([:other_key]), pid())),
+               integer()
+             ) == {:error, []}
+
+      # Negated keys
+      assert map_update(
+               closed_map(key1: binary(), key2: binary()),
+               difference(atom(), atom([:key1])),
+               integer()
+             ) ==
+               {binary(), closed_map(key1: binary(), key2: union(integer(), binary())),
+                [baddomain: atom()]}
+
+      assert map_update(
+               closed_map([key1: binary(), key2: binary()] ++ [{domain_key(:atom), pid()}]),
+               difference(atom(), atom([:key1])),
+               integer()
+             ) ==
+               {union(binary(), pid()),
+                closed_map(
+                  [key1: binary(), key2: union(integer(), binary())] ++
+                    [{domain_key(:atom), union(integer(), pid())}]
+                ), []}
+    end
+  end
+
+  describe "map_put" do
+    test "with static atom keys" do
+      assert map_put(open_map(key: binary()), atom([:key]), integer()) ==
+               {:ok, open_map(key: integer())}
+
+      assert map_put(dynamic(open_map(key: binary())), atom([:key]), integer()) ==
+               {:ok, dynamic(open_map(key: integer()))}
+
+      # Optional does not fail on put keys
+      assert map_put(open_map(key: if_set(atom([:value]))), atom([:key]), integer()) ==
+               {:ok, open_map(key: integer())}
+
+      # But optional does not fail for dynamic ones
+      assert map_put(dynamic(open_map(key: if_set(atom([:value])))), atom([:key]), integer()) ==
+               {:ok, dynamic(open_map(key: integer()))}
+
+      assert map_put(dynamic(), atom([:key]), integer()) ==
+               {:ok, dynamic(open_map(key: integer()))}
+
+      # Empty value does not fail for put
+      assert map_put(closed_map(key: not_set()), atom([:key]), integer()) ==
+               {:ok, closed_map(key: integer())}
+
+      # When putting multiple keys, we don't know which one will be set
+      assert map_put(open_map(key1: atom(), key2: binary()), atom([:key1, :key2]), integer()) ==
+               {:ok,
+                union(
+                  open_map(key1: atom(), key2: integer()),
+                  open_map(key1: integer(), key2: binary())
+                )}
+
+      # When putting multiple keys, set even missing keys
+      assert map_put(open_map(key1: atom(), key2: binary()), atom([:key1, :key3]), integer()) ==
+               {:ok,
+                union(
+                  open_map(key1: atom(), key2: binary(), key3: integer()),
+                  open_map(key1: integer(), key2: binary())
+                )}
+
+      assert map_put(dynamic(open_map()), atom([:key1, :key2]), integer()) ==
+               {:ok, dynamic(union(open_map(key1: integer()), open_map(key2: integer())))}
+    end
+
+    test "with dynamic/term as key-value" do
+      assert map_put(closed_map(key: atom([:value])), dynamic(), dynamic()) ==
+               {:ok, dynamic(open_map())}
+
+      assert map_put(closed_map(key: atom([:value])), dynamic(), term()) ==
+               {:ok, open_map()}
+
+      assert map_put(closed_map(key: atom([:value])), term(), dynamic()) ==
+               {:ok, dynamic(open_map())}
+
+      assert map_put(closed_map(key: atom([:value])), term(), term()) ==
+               {:ok, open_map()}
+
+      assert map_put(dynamic(closed_map(key: atom([:value]))), term(), term()) ==
+               {:ok, dynamic(open_map())}
+    end
+
+    test "with dynamic atom keys" do
+      assert map_put(
+               open_map(key1: atom(), key2: binary()),
+               dynamic(atom([:key1, :key3])),
+               integer()
+             ) ==
+               {:ok,
+                union(
+                  open_map(key1: atom(), key2: binary(), key3: integer()),
+                  open_map(key1: integer(), key2: binary())
+                )}
+
+      assert map_put(
+               open_map(key1: atom(), key2: binary()),
+               dynamic(atom([:key3, :key4])),
+               integer()
+             ) ==
+               {:ok,
+                union(
+                  open_map(key1: atom(), key2: binary(), key3: integer()),
+                  open_map(key1: atom(), key2: binary(), key4: integer())
+                )}
+    end
+
+    test "with domain keys" do
+      map =
+        closed_map([
+          {domain_key(:integer), binary()},
+          {domain_key(:pid), binary()},
+          {domain_key(:port), binary()}
+        ])
+
+      assert map_put(map, integer(), integer()) ==
+               {:ok,
+                closed_map([
+                  {domain_key(:integer), union(integer(), binary())},
+                  {domain_key(:pid), binary()},
+                  {domain_key(:port), binary()}
+                ])}
+
+      assert map_put(map, union(pid(), integer()), integer()) ==
+               {:ok,
+                closed_map([
+                  {domain_key(:integer), union(integer(), binary())},
+                  {domain_key(:pid), union(integer(), binary())},
+                  {domain_key(:port), binary()}
+                ])}
+
+      assert map_put(map, union(pid(), reference()), integer()) ==
+               {:ok,
+                closed_map([
+                  {domain_key(:integer), binary()},
+                  {domain_key(:pid), union(integer(), binary())},
+                  {domain_key(:port), binary()},
+                  {domain_key(:reference), integer()}
+                ])}
+
+      assert map_put(map, union(pid(), dynamic(union(reference(), integer()))), integer()) ==
+               {:ok,
+                closed_map([
+                  {domain_key(:integer), union(integer(), binary())},
+                  {domain_key(:pid), union(integer(), binary())},
+                  {domain_key(:port), binary()},
+                  {domain_key(:reference), integer()}
+                ])}
+
+      assert map_put(map, dynamic(union(reference(), binary())), integer()) ==
+               {:ok,
+                closed_map([
+                  {domain_key(:integer), binary()},
+                  {domain_key(:pid), binary()},
+                  {domain_key(:port), binary()},
+                  {domain_key(:reference), integer()},
+                  {domain_key(:binary), integer()}
+                ])}
+
+      # Putting dynamic atom over record keys
+      assert map_put(closed_map(key1: binary(), key2: binary()), atom(), integer()) ==
+               {:ok,
+                closed_map(
+                  [key1: union(integer(), binary()), key2: union(integer(), binary())] ++
+                    [{domain_key(:atom), integer()}]
+                )}
+    end
+
+    test "with mixed keys" do
+      assert map_put(dynamic(), union(atom([:key]), binary()), integer()) ==
+               {:ok, dynamic(open_map())}
+
+      # When precise dynamic keys are given, at least one must succeed
+      assert map_put(
+               closed_map([{:key, atom()}, {domain_key(:integer), binary()}]),
+               dynamic(union(atom([:key]), integer())),
+               integer()
+             ) ==
+               {:ok,
+                union(
+                  closed_map([{:key, integer()}, {domain_key(:integer), binary()}]),
+                  closed_map([{:key, atom()}, {domain_key(:integer), union(binary(), integer())}])
+                )}
+
+      assert map_put(
+               closed_map([{:key, atom()}, {domain_key(:integer), binary()}]),
+               dynamic(union(atom([:other_key]), pid())),
+               integer()
+             ) ==
+               {:ok,
+                union(
+                  closed_map([
+                    {:key, atom()},
+                    {:other_key, integer()},
+                    {domain_key(:integer), binary()}
+                  ]),
+                  closed_map([
+                    {:key, atom()},
+                    {domain_key(:integer), binary()},
+                    {domain_key(:pid), integer()}
+                  ])
+                )}
+
+      # Negated keys
+      assert map_put(
+               closed_map(key1: binary(), key2: binary()),
+               difference(atom(), atom([:key1])),
+               integer()
+             ) ==
+               {:ok,
+                closed_map(
+                  [key1: binary(), key2: union(binary(), integer())] ++
+                    [{domain_key(:atom), integer()}]
+                )}
+
+      assert map_put(
+               closed_map([key1: binary(), key2: binary()] ++ [{domain_key(:atom), pid()}]),
+               difference(atom(), atom([:key1])),
+               integer()
+             ) ==
+               {:ok,
+                closed_map(
+                  [key1: binary(), key2: union(integer(), binary())] ++
+                    [{domain_key(:atom), union(integer(), pid())}]
+                )}
+    end
+  end
+
+  describe "disjoint" do
+    test "optional" do
+      assert disjoint?(term(), if_set(none()))
+      assert disjoint?(term(), if_set(none()) |> union(non_empty_list(none())))
+    end
+
+    test "map" do
+      refute disjoint?(open_map(), open_map(a: integer()))
+    end
+  end
+
+  describe "to_quoted" do
+    test "bitmap" do
+      assert union(integer(), union(float(), binary())) |> to_quoted_string() ==
+               "binary() or float() or integer()"
+    end
+
+    test "none" do
+      assert none() |> to_quoted_string() == "none()"
+      assert dynamic(none()) |> to_quoted_string() == "none()"
+    end
+
+    test "negation" do
+      assert negation(negation(integer())) |> to_quoted_string() == "integer()"
+      assert negation(negation(atom([:foo, :bar]))) |> to_quoted_string() == ":bar or :foo"
+      assert negation(negation(list(term()))) |> to_quoted_string() == "list(term())"
+    end
+
+    test "atom" do
+      assert atom() |> to_quoted_string() == "atom()"
+      assert atom([:a]) |> to_quoted_string() == ":a"
+      assert atom([:a, :b]) |> to_quoted_string() == ":a or :b"
+      assert difference(atom(), atom([:a])) |> to_quoted_string() == "atom() and not :a"
+
+      assert atom([Elixir]) |> to_quoted_string() == "Elixir"
+      assert atom([Foo.Bar]) |> to_quoted_string() == "Foo.Bar"
+    end
+
+    test "boolean" do
+      assert boolean() |> to_quoted_string() == "boolean()"
+      assert atom([true, false, :a]) |> to_quoted_string() == ":a or boolean()"
+      assert atom([true, :a]) |> to_quoted_string() == ":a or true"
+      assert difference(atom(), boolean()) |> to_quoted_string() == "atom() and not boolean()"
+    end
+
+    test "dynamic" do
+      assert dynamic() |> to_quoted_string() == "dynamic()"
+
+      assert dynamic(union(atom(), integer())) |> union(integer()) |> to_quoted_string() ==
+               "dynamic(atom()) or integer()"
+
+      assert intersection(binary(), dynamic()) |> to_quoted_string() == "binary()"
+
+      assert intersection(union(binary(), pid()), dynamic()) |> to_quoted_string() ==
+               "dynamic(binary() or pid())"
+
+      assert intersection(atom(), dynamic()) |> to_quoted_string() == "dynamic(atom())"
+
+      assert union(atom([:foo, :bar]), dynamic()) |> to_quoted_string() ==
+               "dynamic() or :bar or :foo"
+
+      assert intersection(dynamic(), closed_map(a: integer())) |> to_quoted_string() ==
+               "dynamic(%{a: integer()})"
+    end
+
+    test "lists" do
+      assert list(term()) |> to_quoted_string() == "list(term())"
+      assert list(integer()) |> to_quoted_string() == "list(integer())"
+
+      assert list(term()) |> difference(empty_list()) |> to_quoted_string() ==
+               "non_empty_list(term())"
+
+      assert list(term()) |> difference(list(integer())) |> to_quoted_string() ==
+               "non_empty_list(term()) and not non_empty_list(integer())"
+
+      assert list(term())
+             |> difference(list(integer()))
+             |> difference(list(atom()))
+             |> to_quoted_string() ==
+               "non_empty_list(term()) and not (non_empty_list(integer()) or non_empty_list(atom()))"
+
+      assert list(term(), integer()) |> to_quoted_string() ==
+               "empty_list() or non_empty_list(term(), integer())"
+
+      assert difference(list(term(), atom()), list(term(), boolean())) |> to_quoted_string() ==
+               "non_empty_list(term(), atom() and not boolean())"
+
+      assert list(term(), term()) |> to_quoted_string() ==
+               "empty_list() or non_empty_list(term(), term())"
+
+      # Test normalization
+
+      # Remove duplicates
+      assert union(list(integer()), list(integer())) |> to_quoted_string() == "list(integer())"
+
+      # Merge subtypes
+      assert union(list(float(), pid()), list(number(), pid())) |> to_quoted_string() ==
+               "empty_list() or non_empty_list(float() or integer(), pid())"
+
+      # Merge last element types
+      assert union(list(atom([:ok]), integer()), list(atom([:ok]), float()))
+             |> to_quoted_string() ==
+               "empty_list() or non_empty_list(:ok, float() or integer())"
+
+      assert union(dynamic(list(integer(), float())), dynamic(list(integer(), pid())))
+             |> to_quoted_string() ==
+               "dynamic(empty_list() or non_empty_list(integer(), float() or pid()))"
+    end
+
+    test "tuples" do
+      assert tuple([integer(), atom()]) |> to_quoted_string() == "{integer(), atom()}"
+
+      assert tuple([integer(), dynamic(atom())]) |> to_quoted_string() ==
+               "dynamic({integer(), atom()})"
+
+      assert open_tuple([integer(), atom()]) |> to_quoted_string() == "{integer(), atom(), ...}"
+
+      assert union(tuple([integer(), atom()]), open_tuple([atom()])) |> to_quoted_string() ==
+               "{atom(), ...} or {integer(), atom()}"
+
+      assert difference(tuple([integer(), atom()]), open_tuple([atom()])) |> to_quoted_string() ==
+               "{integer(), atom()}"
+
+      assert tuple([closed_map(a: integer()), open_map()]) |> to_quoted_string() ==
+               "{%{a: integer()}, map()}"
+
+      assert union(tuple([integer(), atom()]), tuple([integer(), atom()])) |> to_quoted_string() ==
+               "{integer(), atom()}"
+
+      assert union(tuple([integer(), atom()]), tuple([float(), atom()])) |> to_quoted_string() ==
+               "{float() or integer(), atom()}"
+
+      assert union(tuple([integer(), atom()]), tuple([float(), atom()]))
+             |> union(tuple([pid(), pid(), port()]))
+             |> union(tuple([pid(), pid(), atom()]))
+             |> to_quoted_string() ==
+               "{float() or integer(), atom()} or {pid(), pid(), atom() or port()}"
+
+      assert union(open_tuple([integer()]), open_tuple([float()])) |> to_quoted_string() ==
+               "{float() or integer(), ...}"
+
+      # {:ok, {term(), integer()}} or {:ok, {term(), float()}} or {:exit, :kill} or {:exit, :timeout}
+      assert tuple([atom([:ok]), tuple([term(), empty_list()])])
+             |> union(tuple([atom([:ok]), tuple([term(), open_map()])]))
+             |> union(tuple([atom([:exit]), atom([:kill])]))
+             |> union(tuple([atom([:exit]), atom([:timeout])]))
+             |> to_quoted_string() ==
+               "{:exit, :kill or :timeout} or {:ok, {term(), empty_list() or map()}}"
+
+      # Detection of duplicates
+      assert tuple([atom([:ok]), term()])
+             |> union(tuple([atom([:ok]), term()]))
+             |> to_quoted_string() == "{:ok, term()}"
+
+      assert tuple([closed_map(a: integer(), b: atom()), open_map()])
+             |> union(tuple([closed_map(a: integer(), b: atom()), open_map()]))
+             |> to_quoted_string() ==
+               "{%{a: integer(), b: atom()}, map()}"
+
+      # Nested fusion
+      assert tuple([closed_map(a: integer(), b: atom()), open_map()])
+             |> union(tuple([closed_map(a: float(), b: atom()), open_map()]))
+             |> to_quoted_string() ==
+               "{%{a: float() or integer(), b: atom()}, map()}"
+
+      # Complex simplification of map/tuple combinations. Initial type is:
+      # ```
+      #   dynamic(
+      #     :error or
+      #     ({%Decimal{coef: :inf, exp: integer(), sign: integer()}, binary()} or
+      #       {%Decimal{coef: :NaN, exp: integer(), sign: integer()}, binary()} or
+      #       {%Decimal{coef: integer(), exp: integer(), sign: integer()}, term()} or
+      #       {%Decimal{coef: :inf, exp: integer(), sign: integer()} or
+      #           %Decimal{coef: :NaN, exp: integer(), sign: integer()} or
+      #           %Decimal{coef: integer(), exp: integer(), sign: integer()}, term()})
+      #   )
+      # ```
+      decimal_inf =
+        closed_map(
+          __struct__: atom([Decimal]),
+          coef: atom([:inf]),
+          exp: integer(),
+          sign: integer()
+        )
+
+      decimal_nan =
+        closed_map(
+          __struct__: atom([Decimal]),
+          coef: atom([:NaN]),
+          exp: integer(),
+          sign: integer()
+        )
+
+      decimal_int =
+        closed_map(
+          __struct__: atom([Decimal]),
+          coef: integer(),
+          exp: integer(),
+          sign: integer()
+        )
+
+      assert atom([:error])
+             |> union(
+               tuple([decimal_inf, binary()])
+               |> union(
+                 tuple([decimal_nan, binary()])
+                 |> union(
+                   tuple([decimal_int, term()])
+                   |> union(tuple([union(decimal_inf, union(decimal_nan, decimal_int)), term()]))
+                 )
+               )
+             )
+             |> dynamic()
+             |> to_quoted_string() ==
+               """
+               dynamic(
+                 :error or {%Decimal{sign: integer(), coef: :NaN or :inf or integer(), exp: integer()}, term()}
+               )\
+               """
+    end
+
+    test "function" do
+      assert fun() |> to_quoted_string() == "fun()"
+      assert none_fun(1) |> to_quoted_string() == "(none() -> term())"
+
+      assert none_fun(1)
+             |> intersection(none_fun(2))
+             |> to_quoted_string() == "none()"
+
+      assert fun([integer(), float()], boolean()) |> to_quoted_string() ==
+               "(integer(), float() -> boolean())"
+
+      assert fun([integer()], boolean())
+             |> union(fun([float()], boolean()))
+             |> to_quoted_string() ==
+               "(integer() -> boolean()) or (float() -> boolean())"
+
+      assert fun([integer()], boolean())
+             |> intersection(fun([float()], boolean()))
+             |> to_quoted_string() ==
+               "(integer() -> boolean()) and (float() -> boolean())"
+
+      # Thanks to lazy BDDs, consecutive union of functions come out as the original union
+      assert fun([integer()], integer())
+             |> union(fun([float()], float()))
+             |> union(fun([pid()], pid()))
+             |> to_quoted_string() ==
+               "(integer() -> integer()) or (float() -> float()) or (pid() -> pid())"
+    end
+
+    test "function with optimized intersections" do
+      assert fun([integer()], atom()) |> intersection(none_fun(1)) |> to_quoted_string() ==
+               "(integer() -> atom())"
+
+      assert fun([integer()], atom())
+             |> difference(none_fun(2))
+             |> intersection(none_fun(1))
+             |> to_quoted_string() ==
+               "(integer() -> atom())"
+    end
+
+    test "function with dynamic signatures" do
+      assert fun([dynamic(integer())], float()) |> to_quoted_string() ==
+               "(dynamic(integer()) -> float())"
+
+      assert fun([dynamic(atom())], float()) |> to_quoted_string() ==
+               "(dynamic(atom()) -> float())"
+
+      assert fun([integer(), float()], dynamic(atom())) |> to_quoted_string() ==
+               "(integer(), float() -> dynamic(atom()))"
+
+      domain_part = fun([dynamic(atom()) |> union(integer()), binary()], float())
+
+      assert domain_part |> to_quoted_string() ==
+               "(dynamic(atom()) or integer(), binary() -> float())"
+
+      codomain_part = fun([pid(), float()], dynamic(atom()) |> union(integer()))
+
+      assert codomain_part |> to_quoted_string() ==
+               "(pid(), float() -> dynamic(atom()) or integer())"
+
+      assert union(domain_part, codomain_part) |> to_quoted_string() ==
+               """
+               (dynamic(atom()) or integer(), binary() -> float()) or
+                 (pid(), float() -> dynamic(atom()) or integer())\
+               """
+
+      assert intersection(domain_part, codomain_part) |> to_quoted_string() ==
+               """
+               (dynamic(atom()) or integer(), binary() -> float()) and
+                 (pid(), float() -> dynamic(atom()) or integer())\
+               """
+    end
+
+    test "map as records" do
+      assert empty_map() |> to_quoted_string() == "empty_map()"
+      assert open_map() |> to_quoted_string() == "map()"
+
+      assert closed_map(a: integer()) |> to_quoted_string() == "%{a: integer()}"
+      assert open_map(a: float()) |> to_quoted_string() == "%{..., a: float()}"
+
+      assert closed_map("Elixir.Foo.Bar": integer()) |> to_quoted_string() ==
+               "%{Foo.Bar => integer()}"
+
+      assert open_map("Elixir.Foo.Bar": float()) |> to_quoted_string() ==
+               "%{..., Foo.Bar => float()}"
+
+      assert difference(open_map(), open_map(a: term())) |> to_quoted_string() ==
+               "%{..., a: not_set()}"
+
+      assert closed_map(a: integer(), b: atom()) |> to_quoted_string() ==
+               "%{a: integer(), b: atom()}"
+
+      assert open_map(a: float())
+             |> difference(closed_map(a: float()))
+             |> to_quoted_string() == "%{..., a: float()} and not %{a: float()}"
+
+      assert difference(open_map(), empty_map()) |> to_quoted_string() ==
+               "map() and not empty_map()"
+
+      assert closed_map(foo: union(integer(), not_set())) |> to_quoted_string() ==
+               "%{foo: if_set(integer())}"
+
+      # Test normalization
+      assert open_map(a: integer(), b: atom())
+             |> difference(open_map(b: atom()))
+             |> union(open_map(a: integer()))
+             |> to_quoted_string() == "%{..., a: integer()}"
+
+      assert union(open_map(a: integer()), open_map(a: integer())) |> to_quoted_string() ==
+               "%{..., a: integer()}"
+
+      assert difference(open_map(a: number(), b: atom()), open_map(a: integer()))
+             |> to_quoted_string() == "%{..., a: float(), b: atom()}"
+
+      # Basic map fusion
+      assert union(closed_map(a: integer()), closed_map(a: integer())) |> to_quoted_string() ==
+               "%{a: integer()}"
+
+      assert union(closed_map(a: integer()), closed_map(a: float())) |> to_quoted_string() ==
+               "%{a: float() or integer()}"
+
+      # Nested fusion
+      assert union(closed_map(a: integer(), b: atom()), closed_map(a: float(), b: atom()))
+             |> union(closed_map(x: pid(), y: pid(), z: port()))
+             |> union(closed_map(x: pid(), y: pid(), z: atom()))
+             |> to_quoted_string() ==
+               "%{a: float() or integer(), b: atom()} or %{x: pid(), y: pid(), z: atom() or port()}"
+
+      # Open map fusion
+      assert union(open_map(a: integer()), open_map(a: float())) |> to_quoted_string() ==
+               "%{..., a: float() or integer()}"
+
+      # Fusing complex nested maps with unions
+      assert closed_map(
+               status: atom([:ok]),
+               data: closed_map(value: term(), count: empty_list())
+             )
+             |> union(
+               closed_map(
+                 status: atom([:ok]),
+                 data: closed_map(value: term(), count: open_map())
+               )
+             )
+             |> union(closed_map(status: atom([:error]), reason: atom([:timeout])))
+             |> union(closed_map(status: atom([:error]), reason: atom([:crash])))
+             |> to_quoted_string() ==
+               "%{data: %{count: empty_list() or map(), value: term()}, status: :ok} or\n  %{reason: :crash or :timeout, status: :error}"
+
+      # Difference and union tests
+      assert closed_map(status: atom([:ok]), value: term())
+             |> difference(closed_map(status: atom([:ok]), value: float()))
+             |> union(
+               closed_map(status: atom([:ok]), value: term())
+               |> difference(closed_map(status: atom([:ok]), value: integer()))
+             )
+             |> to_quoted_string() ==
+               "%{status: :ok, value: term()}"
+
+      # Nested map fusion
+      assert closed_map(data: closed_map(x: integer(), y: atom()), meta: open_map())
+             |> union(closed_map(data: closed_map(x: float(), y: atom()), meta: open_map()))
+             |> to_quoted_string() ==
+               "%{data: %{x: float() or integer(), y: atom()}, meta: map()}"
+
+      # Test complex combinations
+      assert intersection(
+               open_map(a: number(), b: atom()),
+               open_map(a: integer(), c: boolean())
+             )
+             |> union(difference(open_map(x: atom()), open_map(x: boolean())))
+             |> to_quoted_string() ==
+               "%{..., a: integer(), b: atom(), c: boolean()} or %{..., x: atom() and not boolean()}"
+
+      assert closed_map(a: number(), b: atom(), c: pid())
+             |> difference(closed_map(a: integer(), b: atom(), c: pid()))
+             |> to_quoted_string() == "%{a: float(), b: atom(), c: pid()}"
+
+      # No simplification compared to above, as it is an open map
+      assert open_map(a: number(), b: atom())
+             |> difference(closed_map(a: integer(), b: atom()))
+             |> to_quoted_string() ==
+               "%{..., a: float() or integer(), b: atom()} and not %{a: integer(), b: atom()}"
+
+      # Remark: this simplification is order dependent. Having the first difference
+      # after the second gives a different result.
+      assert open_map(a: number(), b: atom(), c: union(pid(), port()))
+             |> difference(open_map(a: integer(), b: atom(), c: union(pid(), port())))
+             |> difference(open_map(a: float(), b: atom(), c: pid()))
+             |> to_quoted_string() == "%{..., a: float(), b: atom(), c: port()}"
+
+      assert open_map(a: number(), b: atom(), c: union(pid(), port()))
+             |> difference(open_map(a: float(), b: atom(), c: pid()))
+             |> difference(open_map(a: integer(), b: atom(), c: union(pid(), port())))
+             |> to_quoted_string() == "%{..., a: float(), b: atom(), c: port()}"
+    end
+
+    test "maps as dictionaries" do
+      assert closed_map([{domain_key(:integer), integer()}])
+             |> to_quoted_string() == "%{integer() => integer()}"
+
+      assert closed_map([{domain_key(:integer), not_set()}, {:float, float()}])
+             |> to_quoted_string() == "%{integer() => not_set(), float: float()}"
+    end
+
+    test "structs" do
+      assert open_map(__struct__: atom([URI])) |> to_quoted_string() ==
+               "%{..., __struct__: URI}"
+
+      assert closed_map(__struct__: atom([URI])) |> to_quoted_string() ==
+               "%{__struct__: URI}"
+
+      assert closed_map(__struct__: atom([NoFieldsStruct])) |> to_quoted_string() ==
+               "%NoFieldsStruct{}"
+
+      assert closed_map(__struct__: atom([URI, Another])) |> to_quoted_string() ==
+               "%{__struct__: Another or URI}"
+
+      assert closed_map(__struct__: atom([Decimal]), coef: term(), exp: term(), sign: term())
+             |> to_quoted_string(collapse_structs: false) ==
+               "%Decimal{sign: term(), coef: term(), exp: term()}"
+
+      assert closed_map(__struct__: atom([Decimal]), coef: term(), exp: term(), sign: term())
+             |> to_quoted_string() ==
+               "%Decimal{}"
+
+      assert closed_map(__struct__: atom([Decimal]), coef: term(), exp: term(), sign: integer())
+             |> to_quoted_string() ==
+               "%Decimal{sign: integer()}"
+
+      # Does not fuse structs
+      assert union(closed_map(__struct__: atom([Foo])), closed_map(__struct__: atom([Bar])))
+             |> to_quoted_string() ==
+               "%{__struct__: Bar} or %{__struct__: Foo}"
+
+      # Properly format non_struct_map
+      assert open_map(__struct__: if_set(negation(atom()))) |> to_quoted_string() ==
+               "non_struct_map()"
+    end
+  end
+
+  describe "performance" do
+    test "tuple difference" do
+      # Large difference with no duplicates
+      descr1 =
+        union(
+          atom([:ignored, :reset]),
+          tuple([atom([:font_style]), atom([:italic])])
+        )
+
+      descr2 =
+        union(
+          atom([:ignored, :reset]),
+          union(
+            tuple([atom([:font_style]), atom([:italic])]),
+            Enum.reduce(
+              for elem1 <- 1..5, elem2 <- 1..5 do
+                tuple([atom([:"f#{elem1}"]), atom([:"s#{elem2}"])])
+              end,
+              &union/2
+            )
+          )
+        )
+
+      assert subtype?(descr1, descr2)
+      refute subtype?(descr2, descr1)
+    end
+
+    test "map difference" do
+      # Create a large map with various types
+      map1 =
+        open_map([
+          {:id, integer()},
+          {:name, binary()},
+          {:age, union(integer(), atom())},
+          {:email, binary()},
+          {:active, boolean()},
+          {:tags, list(atom())}
+        ])
+
+      # Create another large map with some differences and many more entries
+      map2 =
+        open_map(
+          [
+            {:id, integer()},
+            {:name, binary()},
+            {:age, integer()},
+            {:email, binary()},
+            {:active, boolean()},
+            {:tags, non_empty_list(atom())},
+            {:meta,
+             open_map([
+               {:created_at, binary()},
+               {:updated_at, binary()},
+               {:status, atom()}
+             ])},
+            {:permissions, tuple([atom(), integer(), atom()])},
+            {:profile,
+             open_map([
+               {:bio, binary()},
+               {:interests, non_empty_list(binary())},
+               {:social_media,
+                open_map([
+                  {:twitter, binary()},
+                  {:instagram, binary()},
+                  {:linkedin, binary()}
+                ])}
+             ])},
+            {:notifications, boolean()}
+          ] ++
+            Enum.map(1..50, fn i ->
+              {:"field_#{i}", atom([:"value_#{i}"])}
+            end)
+        )
+
+      refute subtype?(map1, map2)
+      assert subtype?(map2, map1)
+    end
+
+    test "map intersection and then difference" do
+      actual = open_map(__struct__: atom(), __exception__: atom([true]))
+
+      expected =
+        for i <- 1..50 do
+          name = :"name_#{i}"
+          closed_map([__struct__: atom([name])] ++ [{name, binary()}])
+        end
+        |> Enum.reduce(&union/2)
+
+      common = intersection(actual, expected)
+      difference(actual, common)
+    end
+
+    test "struct difference" do
+      entries =
+        [
+          closed_map(__struct__: atom([MapSet]), map: term()),
+          closed_map(__struct__: atom([Jason.OrderedObject]), values: term()),
+          closed_map(__struct__: atom([GenEvent.Stream]), timeout: term(), manager: term()),
+          closed_map(__struct__: atom([HashDict]), size: term(), root: term()),
+          closed_map(__struct__: atom([HashSet]), size: term(), root: term()),
+          closed_map(
+            __struct__: atom([IO.Stream]),
+            raw: term(),
+            device: term(),
+            line_or_bytes: term()
+          ),
+          closed_map(__struct__: atom([Range]), first: term(), last: term(), step: term()),
+          closed_map(
+            __struct__: atom([Stream]),
+            enum: term(),
+            done: term(),
+            funs: term(),
+            accs: term()
+          ),
+          closed_map(
+            __struct__: atom([Req.Response.Async]),
+            pid: term(),
+            ref: term(),
+            stream_fun: term(),
+            cancel_fun: term()
+          ),
+          closed_map(
+            __struct__: atom([Postgrex.Stream]),
+            options: term(),
+            params: term(),
+            query: term(),
+            conn: term()
+          ),
+          closed_map(
+            __struct__: atom([DBConnection.PrepareStream]),
+            opts: term(),
+            params: term(),
+            query: term(),
+            conn: term()
+          ),
+          closed_map(
+            __struct__: atom([DBConnection.Stream]),
+            opts: term(),
+            params: term(),
+            query: term(),
+            conn: term()
+          ),
+          closed_map(
+            __struct__: atom([Ecto.Adapters.SQL.Stream]),
+            meta: term(),
+            opts: term(),
+            params: term(),
+            statement: term()
+          ),
+          closed_map(
+            __struct__: atom([Date.Range]),
+            first: term(),
+            last: term(),
+            step: term(),
+            first_in_iso_days: term(),
+            last_in_iso_days: term()
+          ),
+          closed_map(
+            __struct__: atom([File.Stream]),
+            node: term(),
+            raw: term(),
+            path: term(),
+            modes: term(),
+            line_or_bytes: term()
+          ),
+          closed_map(
+            __struct__: atom([Phoenix.LiveView.LiveStream]),
+            name: term(),
+            ref: term(),
+            inserts: term(),
+            deletes: term(),
+            reset?: term(),
+            dom_id: term(),
+            consumable?: term()
+          )
+        ]
+
+      range =
+        closed_map(__struct__: atom([Range]), first: integer(), last: integer(), step: integer())
+
+      assert subtype?(range, Enum.reduce(entries, &union/2))
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/module/types/expr_test.exs b/lib/elixir/test/elixir/module/types/expr_test.exs
new file mode 100644
index 00000000000..69fe585da73
--- /dev/null
+++ b/lib/elixir/test/elixir/module/types/expr_test.exs
@@ -0,0 +1,2211 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("type_helper.exs", __DIR__)
+
+defmodule Module.Types.ExprTest do
+  use ExUnit.Case, async: true
+
+  import TypeHelper
+  import Module.Types.Descr
+  defmacro domain_key(arg) when is_atom(arg), do: [arg]
+
+  defmacro generated(x) do
+    quote generated: true do
+      unquote(x).foo()
+    end
+  end
+
+  test "literal" do
+    assert typecheck!(true) == atom([true])
+    assert typecheck!(false) == atom([false])
+    assert typecheck!(:foo) == atom([:foo])
+    assert typecheck!(0) == integer()
+    assert typecheck!(0.0) == float()
+    assert typecheck!("foo") == binary()
+    assert typecheck!([]) == empty_list()
+    assert typecheck!(%{}) == closed_map([])
+  end
+
+  test "generated" do
+    assert typecheck!([x = 1], generated(x)) == dynamic()
+  end
+
+  describe "lists" do
+    test "creating lists" do
+      assert typecheck!([1, 2]) == non_empty_list(integer())
+      assert typecheck!([1, 2 | 3]) == non_empty_list(integer(), integer())
+      assert typecheck!([1, 2 | [3, 4]]) == non_empty_list(integer())
+
+      assert typecheck!([:ok, 123]) == non_empty_list(union(atom([:ok]), integer()))
+      assert typecheck!([:ok | 123]) == non_empty_list(atom([:ok]), integer())
+      assert typecheck!([x], [:ok, x]) == dynamic(non_empty_list(term()))
+      assert typecheck!([x], [:ok | x]) == dynamic(non_empty_list(term(), term()))
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x, y, z],
+               (
+                 List.to_integer([x, y | z])
+                 {x, y, z}
+               )
+             ) == dynamic(tuple([integer(), integer(), list(integer())]))
+    end
+
+    test "hd" do
+      assert typecheck!([x = [123, :foo]], hd(x)) == dynamic(union(atom([:foo]), integer()))
+      assert typecheck!([x = [123 | :foo]], hd(x)) == dynamic(integer())
+
+      assert typeerror!(hd([])) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Kernel.hd/1:
+
+                   hd([])
+
+               given types:
+
+                   empty_list()
+
+               but expected one of:
+
+                   non_empty_list(term(), term())
+               """
+
+      assert typeerror!(hd(123)) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Kernel.hd/1:
+
+                   hd(123)
+
+               given types:
+
+                   integer()
+
+               but expected one of:
+
+                   non_empty_list(term(), term())
+               """
+    end
+
+    test "tl" do
+      assert typecheck!([x = [123, :foo]], tl(x)) == dynamic(list(union(atom([:foo]), integer())))
+
+      assert typecheck!([x = [123 | :foo]], tl(x)) ==
+               dynamic(union(atom([:foo]), non_empty_list(integer(), atom([:foo]))))
+
+      assert typeerror!(tl([])) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Kernel.tl/1:
+
+                   tl([])
+
+               given types:
+
+                   empty_list()
+
+               but expected one of:
+
+                   non_empty_list(term(), term())
+               """
+
+      assert typeerror!(tl(123)) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Kernel.tl/1:
+
+                   tl(123)
+
+               given types:
+
+                   integer()
+
+               but expected one of:
+
+                   non_empty_list(term(), term())
+               """
+    end
+  end
+
+  describe "funs" do
+    test "infers calls" do
+      assert typecheck!(
+               [x],
+               (
+                 x.(1, 2)
+                 x
+               )
+             ) == dynamic(fun(2))
+    end
+
+    test "infers functions" do
+      assert typecheck!(& &1) |> equal?(fun([term()], dynamic()))
+
+      assert typecheck!(fn -> :ok end) |> equal?(fun([], dynamic(atom([:ok]))))
+
+      assert typecheck!(fn
+               <<"ok">>, {} -> :ok
+               <<"error">>, {} -> :error
+               [_ | _], %{} -> :list
+             end)
+             |> equal?(
+               intersection(
+                 fun(
+                   [non_empty_list(term(), term()), open_map()],
+                   dynamic(atom([:list]))
+                 ),
+                 fun(
+                   [binary(), tuple([])],
+                   dynamic(atom([:ok, :error]))
+                 )
+               )
+             )
+    end
+
+    test "application" do
+      assert typecheck!(
+               [map],
+               (fn
+                  %{a: a} = data -> %{data | b: a}
+                  data -> data
+                end).(map)
+             ) == dynamic()
+
+      assert typecheck!(
+               [],
+               [true, false]
+               |> Enum.random()
+               |> then(fn
+                 true -> :ok
+                 _ -> :error
+               end)
+             ) == dynamic(atom([:ok, :error]))
+    end
+
+    test "bad function" do
+      assert typeerror!([%x{}, a1, a2], x.(a1, a2)) == ~l"""
+             expected a 2-arity function on call:
+
+                 x.(a1, a2)
+
+             but got type:
+
+                 dynamic(atom())
+
+             where "x" was given the type:
+
+                 # type: dynamic(atom())
+                 # from: types_test.ex:LINE
+                 %x{}
+             """
+    end
+
+    test "bad arity" do
+      assert typeerror!([a1, a2], (&String.to_integer/1).(a1, a2)) == ~l"""
+             expected a 2-arity function on call:
+
+                 (&String.to_integer/1).(a1, a2)
+
+             but got function with arity 1:
+
+                 (binary() -> integer())
+             """
+    end
+
+    test "bad argument" do
+      assert typeerror!([], (&String.to_integer/1).(:foo))
+             |> strip_ansi() == ~l"""
+             incompatible types given on function application:
+
+                 (&String.to_integer/1).(:foo)
+
+             given types:
+
+                 :foo
+
+             but function has type:
+
+                 (binary() -> integer())
+             """
+
+      assert typeerror!(
+               [x],
+               (if x do
+                  &String.to_integer/1
+                else
+                  &List.to_integer/1
+                end).(:foo)
+             )
+             |> strip_ansi() == ~l"""
+             incompatible types given on function application:
+
+                 (if x do
+                    &String.to_integer/1
+                  else
+                    &List.to_integer/1
+                  end).(:foo)
+
+             given types:
+
+                 :foo
+
+             but function has type:
+
+                 (binary() -> integer()) or (non_empty_list(integer()) -> integer())
+
+             hint: the function has an empty domain and therefore cannot be applied to any argument. \
+             This may happen when you have a union of functions, which means the only valid argument \
+             to said function are types that satisfy all sides of the union (which may be none)
+             """
+    end
+
+    test "bad arguments from inferred type" do
+      assert typeerror!(
+               (
+                 fun = fn %{} -> :map end
+                 fun.(:error)
+               )
+             )
+             |> strip_ansi() == """
+             incompatible types given on function application:
+
+                 fun.(:error)
+
+             given types:
+
+                 :error
+
+             but function has type:
+
+                 (map() -> dynamic(:map))
+             """
+    end
+
+    test "capture printing" do
+      assert typeerror!(123 = &{:ok, &1}) == """
+             the following pattern will never match:
+
+                 123 = &{:ok, &1}
+
+             because the right-hand side has type:
+
+                 (term() -> dynamic({:ok, term()}))
+             """
+    end
+
+    test "works when there are multiple clauses with lists and maps" do
+      type =
+        typecheck!(fn
+          [:oban, :job, _event], _measure, _meta, _opts ->
+            :ok
+
+          [:oban, :notifier, :switch], _measure, %{status: _status}, _opts ->
+            :ok
+
+          [:oban, :peer, :election, :stop], _measure, _meta, _opts ->
+            :ok
+
+          [:oban, :plugin, :exception], _measure, _meta, _opts ->
+            :ok
+
+          [:oban, :plugin, :stop], _measure, _meta, _opts ->
+            :ok
+
+          [:oban, :queue, :shutdown], _measure, %{orphaned: [_ | _]}, _opts ->
+            :ok
+
+          [:oban, :stager, :switch], _measure, %{mode: _mode}, _opts ->
+            :ok
+
+          _event, _measure, _meta, _opts ->
+            :ok
+        end)
+
+      assert subtype?(type, fun([term(), term(), term(), term()], atom([:ok])))
+    end
+  end
+
+  describe "remotes" do
+    test "dynamic calls" do
+      assert typecheck!([%x{}], x.foo_bar()) == dynamic()
+    end
+
+    test "infers atoms" do
+      assert typecheck!(
+               [x],
+               (
+                 x.foo_bar()
+                 x
+               )
+             ) == dynamic(atom())
+
+      assert typecheck!(
+               [x],
+               (
+                 x.foo_bar(123)
+                 x
+               )
+             ) == dynamic(atom())
+
+      assert typecheck!(
+               [x],
+               (
+                 &x.foo_bar/1
+                 x
+               )
+             ) == dynamic(atom())
+    end
+
+    test "infers maps" do
+      assert typecheck!(
+               [x],
+               (
+                 :foo = x.foo_bar
+                 123 = x.baz_bat
+                 x
+               )
+             ) == dynamic(open_map(foo_bar: atom([:foo]), baz_bat: integer()))
+    end
+
+    test "infers args" do
+      assert typecheck!(
+               [x, y],
+               (
+                 z = Integer.to_string(x + y)
+                 {x, y, z}
+               )
+             ) == dynamic(tuple([integer(), integer(), binary()]))
+    end
+
+    test "undefined function warnings" do
+      assert typewarn!(URI.unknown("foo")) ==
+               {dynamic(), "URI.unknown/1 is undefined or private"}
+
+      assert typewarn!(if(:rand.uniform() > 0.5, do: URI.unknown("foo"))) ==
+               {dynamic() |> union(atom([nil])), "URI.unknown/1 is undefined or private"}
+
+      assert typewarn!(try(do: :ok, after: URI.unknown("foo"))) ==
+               {atom([:ok]), "URI.unknown/1 is undefined or private"}
+
+      # Check it also emits over a union
+      assert typewarn!(
+               [x = Atom, y = GenServer, z],
+               (
+                 mod =
+                   cond do
+                     z -> x
+                     true -> y
+                   end
+
+                 mod.to_string(:atom)
+               )
+             ) ==
+               {union(dynamic(), binary()), "GenServer.to_string/1 is undefined or private"}
+    end
+
+    test "calling a function with none()" do
+      assert typeerror!(Integer.to_string(raise "oops")) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Integer.to_string/1:
+
+                   Integer.to_string(raise RuntimeError.exception("oops"))
+
+               given types:
+
+                   none()
+
+               the 1st argument is empty (often represented as none()), \
+               most likely because it is the result of an expression that \
+               always fails, such as a `raise` or a previous invalid call. \
+               This causes any function called with this value to fail
+               """
+    end
+
+    test "calling a nullary function on non atoms" do
+      assert typeerror!([<<x::integer>>], x.foo_bar()) ==
+               ~l"""
+               expected a module (an atom) when invoking foo_bar/0 in expression:
+
+                   x.foo_bar()
+
+               where "x" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-1
+                   <<x::integer>>
+
+               #{hints(:dot)}
+               """
+    end
+
+    test "calling a function on non atoms with arguments" do
+      assert typeerror!([<<x::integer>>], x.foo_bar(1, 2)) ==
+               ~l"""
+               expected a module (an atom) when invoking foo_bar/2 in expression:
+
+                   x.foo_bar(1, 2)
+
+               where "x" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-1
+                   <<x::integer>>
+               """
+
+      assert typeerror!(
+               [<<x::integer>>, y = SomeMod, z],
+               (
+                 mod =
+                   cond do
+                     z -> x
+                     true -> y
+                   end
+
+                 mod.to_string(:atom)
+               )
+             ) ==
+               ~l"""
+               expected a module (an atom) when invoking to_string/1 in expression:
+
+                   mod.to_string(:atom)
+
+               where "mod" was given the type:
+
+                   # type: dynamic(SomeMod) or integer()
+                   # from: types_test.ex:LINE-9
+                   mod =
+                     cond do
+                       z -> x
+                       true -> y
+                     end
+               """
+    end
+
+    test "calling a function with invalid arguments on variables" do
+      assert typeerror!(
+               (
+                 x = List
+                 x.to_tuple(123)
+               )
+             )
+             |> strip_ansi() ==
+               ~l"""
+               incompatible types given to List.to_tuple/1:
+
+                   x.to_tuple(123)
+
+               given types:
+
+                   integer()
+
+               but expected one of:
+
+                   list(term())
+
+               where "x" was given the type:
+
+                   # type: List
+                   # from: types_test.ex:LINE-5
+                   x = List
+               """
+    end
+
+    test "capture a function with non atoms" do
+      assert typeerror!([<<x::integer>>], &x.foo_bar/2) ==
+               ~l"""
+               expected a module (an atom) when invoking foo_bar/2 in expression:
+
+                   &x.foo_bar/2
+
+               but got type:
+
+                   integer()
+
+               where "x" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-1
+                   <<x::integer>>
+               """
+    end
+
+    test "requires all combinations to be compatible (except refinements)" do
+      assert typecheck!(
+               [condition, arg],
+               (
+                 # While the code below may raise, it may also always succeed
+                 # if condition and arg are passed in tandem. Therefore, we
+                 # turn off refinement on dynamic calls.
+                 mod = if condition, do: String, else: List
+                 res = mod.to_integer(arg)
+                 {arg, res}
+               )
+             ) == tuple([dynamic(), integer()])
+
+      assert typeerror!(
+               [condition],
+               (
+                 arg = if condition, do: "foo", else: [?f, ?o, ?o]
+                 mod = if condition, do: String, else: List
+                 mod.to_integer(arg)
+               )
+             )
+             |> strip_ansi() == ~l"""
+             incompatible types given to List.to_integer/1:
+
+                 mod.to_integer(arg)
+                 #=> invoked as List.to_integer/1
+
+             given types:
+
+                 binary() or non_empty_list(integer())
+
+             but expected one of:
+
+                 non_empty_list(integer())
+
+             where "arg" was given the type:
+
+                 # type: binary() or non_empty_list(integer())
+                 # from: types_test.ex:LINE-5
+                 arg =
+                   if condition do
+                     "foo"
+                   else
+                     ~c"foo"
+                   end
+
+             where "mod" was given the type:
+
+                 # type: List or String
+                 # from: types_test.ex:LINE-4
+                 mod =
+                   if condition do
+                     String
+                   else
+                     List
+                   end
+             """
+    end
+  end
+
+  describe "remote capture" do
+    test "strong" do
+      assert typecheck!(&String.to_atom/1) == fun([binary()], atom())
+      assert typecheck!(&:erlang.element/2) == fun([integer(), open_tuple([])], dynamic())
+    end
+
+    test "unknown" do
+      assert typecheck!(&Module.Types.ExprTest.__ex_unit__/1) == dynamic(fun(1))
+      assert typecheck!([x], &x.something/1) == dynamic(fun(1))
+    end
+  end
+
+  describe "binaries" do
+    test "inference" do
+      assert typecheck!(
+               [x, y],
+               (
+                 <<x::float-size(y)>>
+                 {x, y}
+               )
+             ) == dynamic(tuple([union(float(), integer()), integer()]))
+    end
+
+    test "warnings" do
+      assert typeerror!([<<x::binary-size(2)>>], <<x::float>>) ==
+               ~l"""
+               incompatible types in binary construction:
+
+                   <<x::float>>
+
+               got type:
+
+                   binary()
+
+               but expected type:
+
+                   float() or integer()
+
+               where "x" was given the type:
+
+                   # type: binary()
+                   # from: types_test.ex:LINE-1
+                   <<x::binary-size(2)>>
+               """
+
+      assert typeerror!([<<x::binary>>], <<x>>) ==
+               ~l"""
+               incompatible types in binary construction:
+
+                   <<x>>
+
+               got type:
+
+                   binary()
+
+               but expected type:
+
+                   integer()
+
+               where "x" was given the type:
+
+                   # type: binary()
+                   # from: types_test.ex:LINE-1
+                   <<x::binary>>
+
+               #{hints(:inferred_bitstring_spec)}
+               """
+
+      assert typeerror!([<<x>>], <<x::binary>>) ==
+               ~l"""
+               incompatible types in binary construction:
+
+                   <<x::binary>>
+
+               got type:
+
+                   integer()
+
+               but expected type:
+
+                   binary()
+
+               where "x" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-1
+                   <<x>>
+
+               #{hints(:inferred_bitstring_spec)}
+               """
+    end
+
+    test "size ok" do
+      assert typecheck!([<<x, y>>, z], <<z::size(x - y)>>) == binary()
+    end
+
+    test "size error" do
+      assert typeerror!([<<x::binary>>, y], <<y::size(x)>>) ==
+               ~l"""
+               expected an integer in binary size:
+
+                   size(x)
+
+               got type:
+
+                   binary()
+
+               where "x" was given the type:
+
+                   # type: binary()
+                   # from: types_test.ex:LINE-1
+                   <<x::binary>>
+               """
+    end
+  end
+
+  describe "tuples" do
+    test "creating tuples" do
+      assert typecheck!({:ok, 123}) == tuple([atom([:ok]), integer()])
+      assert typecheck!([x], {:ok, x}) == dynamic(tuple([atom([:ok]), term()]))
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x, y],
+               (
+                 {:ok, :error} = {x, y}
+                 {x, y}
+               )
+             ) == dynamic(tuple([atom([:ok]), atom([:error])]))
+    end
+
+    test "elem/2" do
+      assert typecheck!(elem({:ok, 123}, 0)) == atom([:ok])
+      assert typecheck!(elem({:ok, 123}, 1)) == integer()
+      assert typecheck!([x], elem({:ok, x}, 0)) == dynamic(atom([:ok]))
+      assert typecheck!([x], elem({:ok, x}, 1)) == dynamic(term())
+
+      assert typeerror!([<<x::float>>], elem(x, 0)) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Kernel.elem/2:
+
+                   elem(x, 0)
+
+               given types:
+
+                   float(), integer()
+
+               but expected one of:
+
+                   {...}, integer()
+
+               where "x" was given the type:
+
+                   # type: float()
+                   # from: types_test.ex:LINE-1
+                   <<x::float>>
+               """
+
+      assert typeerror!(elem({:ok, 123}, 2)) ==
+               ~l"""
+               expected a tuple with at least 3 elements in Kernel.elem/2:
+
+                   elem({:ok, 123}, 2)
+
+               the given type does not have the given index:
+
+                   {:ok, integer()}
+               """
+    end
+
+    test "Tuple.insert_at/3" do
+      assert typecheck!(Tuple.insert_at({}, 0, "foo")) == tuple([binary()])
+
+      assert typecheck!(Tuple.insert_at({:ok, 123}, 0, "foo")) ==
+               tuple([binary(), atom([:ok]), integer()])
+
+      assert typecheck!(Tuple.insert_at({:ok, 123}, 1, "foo")) ==
+               tuple([atom([:ok]), binary(), integer()])
+
+      assert typecheck!(Tuple.insert_at({:ok, 123}, 2, "foo")) ==
+               tuple([atom([:ok]), integer(), binary()])
+
+      assert typeerror!([<<x::float>>], Tuple.insert_at(x, 0, "foo")) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Tuple.insert_at/3:
+
+                   Tuple.insert_at(x, 0, "foo")
+
+               given types:
+
+                   float(), integer(), binary()
+
+               but expected one of:
+
+                   {...}, integer(), term()
+
+               where "x" was given the type:
+
+                   # type: float()
+                   # from: types_test.ex:LINE-1
+                   <<x::float>>
+               """
+
+      assert typeerror!(Tuple.insert_at({:ok, 123}, 3, "foo")) ==
+               ~l"""
+               expected a tuple with at least 3 elements in Tuple.insert_at/3:
+
+                   Tuple.insert_at({:ok, 123}, 3, "foo")
+
+               the given type does not have the given index:
+
+                   {:ok, integer()}
+               """
+    end
+
+    test "Tuple.delete_at/2" do
+      assert typecheck!(Tuple.delete_at({:ok, 123}, 0)) == tuple([integer()])
+      assert typecheck!(Tuple.delete_at({:ok, 123}, 1)) == tuple([atom([:ok])])
+      assert typecheck!([x], Tuple.delete_at({:ok, x}, 0)) == dynamic(tuple([term()]))
+      assert typecheck!([x], Tuple.delete_at({:ok, x}, 1)) == dynamic(tuple([atom([:ok])]))
+
+      assert typeerror!([<<x::float>>], Tuple.delete_at(x, 0)) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Tuple.delete_at/2:
+
+                   Tuple.delete_at(x, 0)
+
+               given types:
+
+                   float(), integer()
+
+               but expected one of:
+
+                   {...}, integer()
+
+               where "x" was given the type:
+
+                   # type: float()
+                   # from: types_test.ex:LINE-1
+                   <<x::float>>
+               """
+
+      assert typeerror!(Tuple.delete_at({:ok, 123}, 2)) ==
+               ~l"""
+               expected a tuple with at least 3 elements in Tuple.delete_at/2:
+
+                   Tuple.delete_at({:ok, 123}, 2)
+
+               the given type does not have the given index:
+
+                   {:ok, integer()}
+               """
+    end
+
+    test "Tuple.duplicate/2" do
+      assert typecheck!(Tuple.duplicate(123, 0)) == tuple([])
+      assert typecheck!(Tuple.duplicate(123, 1)) == tuple([integer()])
+      assert typecheck!(Tuple.duplicate(123, 2)) == tuple([integer(), integer()])
+      assert typecheck!([x], Tuple.duplicate(x, 2)) == dynamic(tuple([term(), term()]))
+    end
+  end
+
+  describe "maps/structs" do
+    test "creating maps as records" do
+      assert typecheck!(%{foo: :bar}) == closed_map(foo: atom([:bar]))
+      assert typecheck!([x], %{key: x}) == dynamic(closed_map(key: term()))
+    end
+
+    test "creating maps as records with dynamic keys" do
+      assert typecheck!(
+               (
+                 foo = :foo
+                 %{foo => :first, foo => :second}
+               )
+             ) == closed_map(foo: atom([:second]))
+
+      assert typecheck!(
+               (
+                 foo_or_bar =
+                   cond do
+                     :rand.uniform() > 0.5 -> :foo
+                     true -> :bar
+                   end
+
+                 %{foo_or_bar => :first, foo_or_bar => :second}
+               )
+             )
+             |> equal?(
+               closed_map(foo: atom([:second]))
+               |> union(closed_map(bar: atom([:second])))
+               |> union(closed_map(foo: atom([:first]), bar: atom([:second])))
+               |> union(closed_map(bar: atom([:first]), foo: atom([:second])))
+             )
+    end
+
+    test "creating maps as dictionaries" do
+      assert typecheck!(%{123 => 456}) == closed_map([{domain_key(:integer), integer()}])
+
+      # Since key cannot override :foo based on position, we preserve it
+      assert typecheck!([key], %{key => 456, foo: :bar}) ==
+               dynamic(
+                 closed_map([
+                   {to_domain_keys(:term), integer()},
+                   {:foo, atom([:bar])}
+                 ])
+               )
+
+      # Since key can override :foo based on position, we union it
+      assert typecheck!([key], %{:foo => :bar, key => :baz}) ==
+               dynamic(
+                 closed_map([
+                   {to_domain_keys(:term), atom([:baz])},
+                   {:foo, atom([:bar, :baz])}
+                 ])
+               )
+
+      # Since key cannot override :foo based on domain, we preserve it
+      assert typecheck!(
+               [arg],
+               (
+                 key = String.to_integer(arg)
+                 %{:foo => :bar, key => :baz}
+               )
+             ) ==
+               closed_map([
+                 {domain_key(:integer), atom([:baz])},
+                 {:foo, atom([:bar])}
+               ])
+
+      # Multiple keys are fully overridden for simplicity
+      assert typecheck!(
+               [arg],
+               (
+                 foo_or_bar = if String.starts_with?(arg, "0"), do: :foo, else: :bar
+                 key = String.to_integer(arg)
+                 %{foo_or_bar => :old, key => :new}
+               )
+             ) ==
+               union(
+                 closed_map([
+                   {domain_key(:integer), atom([:new])},
+                   {:foo, atom([:old])}
+                 ]),
+                 closed_map([
+                   {domain_key(:integer), atom([:new])},
+                   {:bar, atom([:old])}
+                 ])
+               )
+    end
+
+    test "creating structs" do
+      assert typecheck!(%Point{}) ==
+               closed_map(
+                 __struct__: atom([Point]),
+                 x: atom([nil]),
+                 y: atom([nil]),
+                 z: integer()
+               )
+
+      assert typecheck!(%Point{x: :zero}) ==
+               closed_map(
+                 __struct__: atom([Point]),
+                 x: atom([:zero]),
+                 y: atom([nil]),
+                 z: integer()
+               )
+    end
+
+    test "updating to maps as records" do
+      assert typecheck!([x], %{x | x: :zero}) ==
+               dynamic(open_map(x: atom([:zero])))
+
+      assert typecheck!([x], %{%{x | x: :zero} | y: :one}) ==
+               dynamic(open_map(x: atom([:zero]), y: atom([:one])))
+
+      assert typecheck!(
+               (
+                 foo_or_bar =
+                   cond do
+                     :rand.uniform() > 0.5 -> :key1
+                     true -> :key2
+                   end
+
+                 x = %{key1: :one, key2: :two}
+                 %{x | foo_or_bar => :one!, foo_or_bar => :two!}
+               )
+             )
+             |> equal?(
+               closed_map(key1: atom([:one]), key2: atom([:two!]))
+               |> union(closed_map(key1: atom([:two!]), key2: atom([:one!])))
+               |> union(closed_map(key1: atom([:one!]), key2: atom([:two!])))
+               |> union(closed_map(key1: atom([:two!]), key2: atom([:two])))
+             )
+
+      assert typeerror!([x = :foo], %{x | x: :zero}) == ~l"""
+             expected a map within map update syntax:
+
+                 %{x | x: :zero}
+
+             but got type:
+
+                 dynamic(:foo)
+
+             where "x" was given the type:
+
+                 # type: dynamic(:foo)
+                 # from: types_test.ex:LINE
+                 x = :foo
+             """
+
+      assert typeerror!(
+               (
+                 x = %{}
+                 %{x | x: :zero}
+               )
+             ) == ~l"""
+             expected a map with key :x in map update syntax:
+
+                 %{x | x: :zero}
+
+             but got type:
+
+                 empty_map()
+
+             where "x" was given the type:
+
+                 # type: empty_map()
+                 # from: types_test.ex:LINE-3
+                 x = %{}
+             """
+
+      # Assert we check all possible combinations
+      assert typeerror!(
+               (
+                 foo_or_bar =
+                   cond do
+                     :rand.uniform() > 0.5 -> :foo
+                     true -> :bar
+                   end
+
+                 x = %{foo: :baz}
+                 %{x | foo_or_bar => :bat}
+               )
+             ) == ~l"""
+             expected a map with key :bar in map update syntax:
+
+                 %{x | foo_or_bar => :bat}
+
+             but got type:
+
+                 %{foo: :baz}
+
+             where "foo_or_bar" was given the type:
+
+                 # type: :bar or :foo
+                 # from: types_test.ex:LINE-9
+                 foo_or_bar =
+                   cond do
+                     :rand.uniform() > 0.5 -> :foo
+                     true -> :bar
+                   end
+
+             where "x" was given the type:
+
+                 # type: %{foo: :baz}
+                 # from: types_test.ex:LINE-3
+                 x = %{foo: :baz}
+             """
+
+      # The goal of this assertion is to verify we assert keys,
+      # even if they may be overridden later.
+      assert typeerror!(
+               [key],
+               (
+                 x = %{key: :value}
+                 %{x | :foo => :baz, key => :bat}
+               )
+             ) == ~l"""
+             expected a map with key :foo in map update syntax:
+
+                 %{x | :foo => :baz, key => :bat}
+
+             but got type:
+
+                 %{key: :value}
+
+             where "key" was given the type:
+
+                 # type: dynamic()
+                 # from: types_test.ex:LINE-5
+                 key
+
+             where "x" was given the type:
+
+                 # type: %{key: :value}
+                 # from: types_test.ex:LINE-3
+                 x = %{key: :value}
+             """
+    end
+
+    test "updating structs" do
+      integer_date_type =
+        dynamic(
+          closed_map(
+            __struct__: atom([Date]),
+            day: integer(),
+            calendar: atom(),
+            month: term(),
+            year: term()
+          )
+        )
+
+      # When we know the type
+      assert typecheck!([], %Date{Date.new!(1, 1, 1) | day: 31}) ==
+               integer_date_type
+
+      assert typecheck!([], %Date{%Date{Date.new!(1, 1, 1) | day: 13} | day: 31}) ==
+               integer_date_type
+
+      # When we don't know the type of var
+      assert typeerror!([x], %Date{x | day: 31}) == ~l"""
+             a struct for Date is expected on struct update:
+
+                 %Date{x | day: 31}
+
+             but got type:
+
+                 dynamic()
+
+             where "x" was given the type:
+
+                 # type: dynamic()
+                 # from: types_test.ex:LINE
+                 x
+
+             when defining the variable "x", you must also pattern match on "%Date{}".
+
+             hint: given pattern matching is enough to catch typing errors, you may optionally convert the struct update into a map update. For example, instead of:
+
+                 user = some_function()
+                 %User{user | name: "John Doe"}
+
+             it is enough to write:
+
+                 %User{} = user = some_function()
+                 %{user | name: "John Doe"}
+             """
+
+      # When we don't know the type of capture
+      assert typeerror!([], &%Date{&1 | day: 31}) =~ ~l"""
+             a struct for Date is expected on struct update:
+
+                 %Date{&1 | day: 31}
+
+             but got type:
+
+                 dynamic()
+
+             where "capture" was given the type:
+
+                 # type: dynamic()
+                 # from: types_test.ex:LINE
+                 &1
+
+             instead of using &1, you must define an anonymous function, define a variable and pattern match on "%Date{}".
+             """
+
+      # When we don't know the type of expression
+      assert typeerror!([], %Date{SomeMod.fun() | day: 31}) =~ """
+             a struct for Date is expected on struct update:
+
+                 %Date{SomeMod.fun() | day: 31}
+
+             but got type:
+
+                 dynamic()
+
+             you must assign "SomeMod.fun()" to variable and pattern match on "%Date{}".
+             """
+    end
+
+    test "updating to maps as dictionaries" do
+      assert typecheck!(
+               [key],
+               (
+                 x = %{foo: :bar}
+                 %{x | key => :baz}
+               )
+             ) == closed_map(foo: atom([:bar, :baz]))
+
+      # Override based on position
+      assert typecheck!(
+               [key],
+               (
+                 x = %{foo: :bar, baz: :bat}
+                 %{x | key => :old, foo: :new}
+               )
+             ) == closed_map(foo: atom([:new]), baz: atom([:old, :bat]))
+
+      assert typeerror!(
+               [key],
+               (
+                 x = %{String.to_integer(key) => :old}
+                 %{x | String.to_atom(key) => :new}
+               )
+             ) == ~l"""
+             expected a map with key of type atom() in map update syntax:
+
+                 %{x | String.to_atom(key) => :new}
+
+             but got type:
+
+                 %{integer() => :old}
+
+             where "key" was given the type:
+
+                 # type: binary()
+                 # from: types_test.ex:LINE-3
+                 String.to_integer(key)
+
+             where "x" was given the type:
+
+                 # type: %{integer() => :old}
+                 # from: types_test.ex:LINE-3
+                 x = %{String.to_integer(key) => :old}
+             """
+
+      assert typeerror!(
+               [key],
+               (
+                 x = %{key: :old}
+                 %{x | String.to_atom(key) => :new}
+               )
+             ) == ~l"""
+             expected a map with key of type atom() in map update syntax:
+
+                 %{x | String.to_atom(key) => :new}
+
+             but got type:
+
+                 %{key: :old}
+
+             where "key" was given the type:
+
+                 # type: binary()
+                 # from: types_test.ex:LINE-2
+                 String.to_atom(key)
+
+             where "x" was given the type:
+
+                 # type: %{key: :old}
+                 # from: types_test.ex:LINE-3
+                 x = %{key: :old}
+             """
+    end
+
+    test "nested map" do
+      assert typecheck!([x = %{}], x.foo.bar) == dynamic()
+    end
+
+    test "accessing a field on not a map" do
+      assert typeerror!([<<x::integer>>], x.foo_bar) ==
+               ~l"""
+               expected a map or struct when accessing .foo_bar in expression:
+
+                   x.foo_bar
+
+               where "x" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-1
+                   <<x::integer>>
+
+               #{hints(:dot)}
+               """
+    end
+
+    test "accessing an unknown field on struct with diagnostic" do
+      {type, [diagnostic]} = typediag!(%Point{}.foo_bar)
+      assert type == dynamic()
+      assert diagnostic.span == {__ENV__.line - 2, 56}
+
+      assert diagnostic.message == ~l"""
+             unknown key .foo_bar in expression:
+
+                 %Point{x: nil, y: nil, z: 0}.foo_bar
+
+             the given type does not have the given key:
+
+                 %Point{x: nil, y: nil, z: integer()}
+             """
+    end
+
+    test "accessing an unknown field on struct in a var with diagnostic" do
+      {type, [diagnostic]} = typediag!([x = %URI{}], x.foo_bar)
+      assert type == dynamic()
+      assert diagnostic.span == {__ENV__.line - 2, 63}
+
+      assert diagnostic.message == ~l"""
+             unknown key .foo_bar in expression:
+
+                 x.foo_bar
+
+             the given type does not have the given key:
+
+                 dynamic(%URI{
+                   scheme: term(),
+                   authority: term(),
+                   userinfo: term(),
+                   host: term(),
+                   port: term(),
+                   path: term(),
+                   query: term(),
+                   fragment: term()
+                 })
+
+             where "x" was given the type:
+
+                 # type: dynamic(%URI{})
+                 # from: types_test.ex:LINE-4:43
+                 x = %URI{}
+             """
+
+      assert [%{type: :variable, name: :x}] = diagnostic.details.typing_traces
+    end
+
+    test "inspect struct definition" do
+      assert typeerror!(
+               (
+                 p = %Point{x: 123}
+                 Integer.to_string(p)
+               )
+             )
+             |> strip_ansi() == ~l"""
+             incompatible types given to Integer.to_string/1:
+
+                 Integer.to_string(p)
+
+             given types:
+
+                 %Point{x: integer(), y: nil, z: integer()}
+
+             but expected one of:
+
+                 integer()
+
+             where "p" was given the type:
+
+                 # type: %Point{x: integer(), y: nil, z: integer()}
+                 # from: types_test.ex:LINE-4
+                 p = %Point{..., x: 123}
+             """
+    end
+  end
+
+  describe "comparison" do
+    test "in static mode" do
+      assert typecheck!([x = 123, y = 456.0], x < y) == boolean()
+      assert typecheck!([x = 123, y = 456.0], x == y) == boolean()
+    end
+
+    test "in dynamic mode" do
+      assert typedyn!([x = 123, y = 456.0], x < y) == dynamic(boolean())
+      assert typedyn!([x = 123, y = 456.0], x == y) == dynamic(boolean())
+      assert typedyn!([x = 123, y = 456], x == y) == dynamic(boolean())
+    end
+
+    test "using literals" do
+      assert typecheck!(:foo == :bar) == boolean()
+    end
+
+    test "min/max" do
+      assert typecheck!(min(123, 456.0)) == union(integer(), float())
+      # min/max uses parametric types, which will carry dynamic regardless of being a strong arrow
+      assert typecheck!([x = 123, y = 456.0], min(x, y)) == dynamic(union(integer(), float()))
+      assert typedyn!([x = 123, y = 456.0], min(x, y)) == dynamic(union(integer(), float()))
+    end
+
+    test "warns when comparison is constant" do
+      assert typeerror!([x = :foo, y = 321], min(x, y)) ==
+               ~l"""
+               comparison between distinct types found:
+
+                   min(x, y)
+
+               given types:
+
+                   min(dynamic(:foo), integer())
+
+               where "x" was given the type:
+
+                   # type: dynamic(:foo)
+                   # from: types_test.ex:LINE-1
+                   x = :foo
+
+               where "y" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-1
+                   y = 321
+
+               While Elixir can compare across all types, you are comparing across types \
+               which are always disjoint, and the result is either always true or always false
+               """
+
+      assert typeerror!([x = 123, y = 456.0], x === y) ==
+               ~l"""
+               comparison between distinct types found:
+
+                   x === y
+
+               given types:
+
+                   integer() === float()
+
+               where "x" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-1
+                   x = 123
+
+               where "y" was given the type:
+
+                   # type: float()
+                   # from: types_test.ex:LINE-1
+                   y = 456.0
+
+               While Elixir can compare across all types, you are comparing across types \
+               which are always disjoint, and the result is either always true or always false
+               """
+    end
+
+    test "warns on comparison with struct across dynamic call" do
+      assert typeerror!([x = %Point{}, y = %Point{}, mod = Kernel], mod.<=(x, y)) ==
+               ~l"""
+               comparison with structs found:
+
+                   mod.<=(x, y)
+
+               given types:
+
+                   dynamic(%Point{}) <= dynamic(%Point{})
+
+               where "mod" was given the type:
+
+                   # type: dynamic(Kernel)
+                   # from: types_test.ex:LINE-1
+                   mod = Kernel
+
+               where "x" was given the type:
+
+                   # type: dynamic(%Point{})
+                   # from: types_test.ex:LINE-1
+                   x = %Point{}
+
+               where "y" was given the type:
+
+                   # type: dynamic(%Point{})
+                   # from: types_test.ex:LINE-1
+                   y = %Point{}
+
+               Comparison operators (>, <, >=, <=, min, and max) perform structural and not semantic comparison. Comparing with a struct won't give meaningful results. Structs that can be compared typically define a compare/2 function within their modules that can be used for semantic comparison.
+               """
+
+      assert typeerror!(
+               [x = %Point{}, mod = Kernel, condition],
+               (
+                 y = if condition, do: 456, else: %Point{}
+                 mod.<=(x, y)
+               )
+             ) =~ "comparison with structs found:"
+
+      assert typecheck!(
+               [x = 123, mod = Kernel, condition],
+               (
+                 y = if condition, do: 456, else: %Point{}
+                 mod.<=(x, y)
+               )
+             ) == boolean()
+
+      assert typeerror!(
+               [mod = Kernel, condition],
+               (
+                 x = if condition, do: 123, else: %Point{}
+                 y = if condition, do: 456, else: %Point{}
+                 mod.<=(x, y)
+               )
+             ) =~ "comparison with structs found:"
+    end
+  end
+
+  describe ":erlang rewrites" do
+    test "Kernel.not/1" do
+      assert typecheck!([x], not is_list(x)) == boolean()
+      assert typedyn!([x], not is_list(x)) == dynamic(boolean())
+    end
+
+    test "Kernel.+/2" do
+      assert typeerror!([x = :foo, y = 123], x + y) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Kernel.+/2:
+
+                   x + y
+
+               given types:
+
+                   dynamic(:foo), integer()
+
+               but expected one of:
+
+                   #1
+                   integer(), integer()
+
+                   #2
+                   integer(), float()
+
+                   #3
+                   float(), integer()
+
+                   #4
+                   float(), float()
+
+               where "x" was given the type:
+
+                   # type: dynamic(:foo)
+                   # from: types_test.ex:LINE-1
+                   x = :foo
+
+               where "y" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-1
+                   y = 123
+               """
+    end
+
+    test "Integer.to_string/1" do
+      assert typecheck!([x = 123], Integer.to_string(x)) == binary()
+      assert typedyn!([x = 123], Integer.to_string(x)) == dynamic(binary())
+
+      assert typeerror!([x = :foo], Integer.to_string(x)) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Integer.to_string/1:
+
+                   Integer.to_string(x)
+
+               given types:
+
+                   dynamic(:foo)
+
+               but expected one of:
+
+                   integer()
+
+               where "x" was given the type:
+
+                   # type: dynamic(:foo)
+                   # from: types_test.ex:LINE-1
+                   x = :foo
+               """
+    end
+
+    test "Bitwise.bnot/1" do
+      assert typecheck!([x = 123], Bitwise.bnot(x)) == integer()
+      assert typedyn!([x = 123], Bitwise.bnot(x)) == dynamic(integer())
+
+      assert typeerror!([x = :foo], Bitwise.bnot(x)) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Bitwise.bnot/1:
+
+                   Bitwise.bnot(x)
+
+               given types:
+
+                   dynamic(:foo)
+
+               but expected one of:
+
+                   integer()
+
+               where "x" was given the type:
+
+                   # type: dynamic(:foo)
+                   # from: types_test.ex:LINE-1
+                   x = :foo
+               """
+    end
+  end
+
+  describe "case" do
+    test "does not type check literals" do
+      assert typecheck!(
+               case :dev do
+                 :dev -> :ok
+                 :prod -> :error
+               end
+             ) == atom([:ok, :error])
+    end
+
+    test "resets branches" do
+      assert typecheck!(
+               [x],
+               (
+                 case :rand.uniform() do
+                   y when y < 0.5 -> x.foo
+                   y when y > 0.5 -> x.bar()
+                 end
+
+                 x
+               )
+             ) == dynamic()
+    end
+
+    test "returns unions of all clauses" do
+      assert typecheck!(
+               [x],
+               case x do
+                 :ok -> :ok
+                 :error -> :error
+               end
+             ) == atom([:ok, :error])
+
+      assert typedyn!(
+               [x],
+               case x do
+                 :ok -> :ok
+                 :error -> :error
+               end
+             ) == dynamic(atom([:ok, :error]))
+    end
+
+    test "reports error from clause that will never match" do
+      assert typeerror!(
+               [x],
+               case Atom.to_string(x) do
+                 :error -> :error
+                 x -> x
+               end
+             ) == ~l"""
+             the following clause will never match:
+
+                 :error
+
+             because it attempts to match on the result of:
+
+                 Atom.to_string(x)
+
+             which has type:
+
+                 binary()
+             """
+    end
+
+    test "reports errors from multiple clauses" do
+      {type, [_, _]} =
+        typediag!(
+          [x],
+          case Atom.to_string(x) do
+            :ok -> :ok
+            :error -> :error
+          end
+        )
+
+      assert type == atom([:ok, :error])
+    end
+  end
+
+  describe "conditionals" do
+    test "if does not report on literals" do
+      assert typecheck!(
+               if true do
+                 :ok
+               end
+             ) == atom([:ok, nil])
+    end
+
+    test "and does not report on literals" do
+      assert typecheck!(false and true) == boolean()
+    end
+
+    test "and reports violations" do
+      assert typeerror!([x = 123], x and true) =~ """
+             the following conditional expression will always evaluate to integer():
+
+                 x
+             """
+    end
+  end
+
+  describe "receive" do
+    test "returns unions of all clauses" do
+      assert typecheck!(
+               receive do
+                 :ok -> :ok
+                 :error -> :error
+               after
+                 0 -> :timeout
+               end
+             ) == atom([:ok, :error, :timeout])
+
+      assert typedyn!(
+               receive do
+                 :ok -> :ok
+                 :error -> :error
+               after
+                 0 -> :timeout
+               end
+             ) == dynamic(atom([:ok, :error, :timeout]))
+    end
+
+    test "infers type for timeout" do
+      assert typecheck!(
+               [x],
+               receive do
+               after
+                 x -> x
+               end
+             ) == dynamic(union(integer(), atom([:infinity])))
+    end
+
+    test "resets branches" do
+      assert typecheck!(
+               [x, timeout = :infinity],
+               (
+                 receive do
+                   y when y > 0.5 -> x.foo
+                   _ -> x.bar()
+                 after
+                   timeout -> <<^x::integer>> = :crypto.strong_rand_bytes(1)
+                 end
+
+                 x
+               )
+             ) == dynamic()
+    end
+
+    test "errors on bad timeout" do
+      assert typeerror!(
+               [x = :timeout],
+               receive do
+               after
+                 x -> :ok
+               end
+             ) == ~l"""
+             expected "after" timeout given to receive to be an integer:
+
+                 x
+
+             but got type:
+
+                 dynamic(:timeout)
+
+             where "x" was given the type:
+
+                 # type: dynamic(:timeout)
+                 # from: types_test.ex:LINE-5
+                 x = :timeout
+             """
+
+      # Check for compatibility, not subtyping
+      assert typeerror!(
+               [<<x::integer, y::float>>],
+               receive do
+               after
+                 if(:rand.uniform(), do: x, else: y) -> :ok
+               end
+             ) =~ "expected "
+    after
+      " timeout given to receive to be an integer"
+    end
+  end
+
+  describe "try" do
+    test "returns unions of all clauses" do
+      assert typecheck!(
+               try do
+                 :do
+               rescue
+                 _ -> :rescue
+               catch
+                 :caught -> :caught1
+                 :throw, :caught -> :caught2
+               after
+                 :not_used
+               end
+             ) == atom([:do, :caught1, :caught2, :rescue])
+
+      assert typecheck!(
+               [x],
+               try do
+                 x
+               rescue
+                 _ -> :rescue
+               catch
+                 :caught -> :caught1
+                 :throw, :caught -> :caught2
+               after
+                 :not_used
+               else
+                 :match -> :else1
+                 _ -> :else2
+               end
+             ) == atom([:caught1, :caught2, :rescue, :else1, :else2])
+    end
+
+    test "resets branches (except after)" do
+      assert typecheck!(
+               [x],
+               (
+                 try do
+                   <<^x::float>> = :crypto.strong_rand_bytes(8)
+                 rescue
+                   ArgumentError -> x.foo
+                 catch
+                   _, _ -> x.bar()
+                 after
+                   <<^x::integer>> = :crypto.strong_rand_bytes(8)
+                 end
+
+                 x
+               )
+             ) == dynamic(integer())
+    end
+
+    test "reports error from clause that will never match" do
+      assert typeerror!(
+               [x],
+               try do
+                 Atom.to_string(x)
+               rescue
+                 _ -> :ok
+               else
+                 :error -> :error
+                 x -> x
+               end
+             ) == ~l"""
+             the following clause will never match:
+
+                 :error
+
+             it attempts to match on the result of the try do-block which has incompatible type:
+
+                 binary()
+             """
+    end
+
+    test "warns on undefined exceptions" do
+      assert typewarn!(
+               try do
+                 :ok
+               rescue
+                 e in UnknownError -> e
+               end
+             ) ==
+               {dynamic() |> union(atom([:ok])),
+                "struct UnknownError is undefined (module UnknownError is not available or is yet to be defined). " <>
+                  "Make sure the module name is correct and has been specified in full (or that an alias has been defined)"}
+
+      assert typewarn!(
+               try do
+                 :ok
+               rescue
+                 e in Enumerable -> e
+               end
+             ) ==
+               {dynamic() |> union(atom([:ok])),
+                "struct Enumerable is undefined (there is such module but it does not define a struct)"}
+    end
+
+    test "defines unions of exceptions in rescue" do
+      assert typecheck!(
+               try do
+                 raise "oops"
+               rescue
+                 e in [RuntimeError, ArgumentError] ->
+                   e
+               end
+             ) ==
+               dynamic(
+                 union(
+                   closed_map(
+                     __struct__: atom([ArgumentError]),
+                     __exception__: atom([true]),
+                     message: term()
+                   ),
+                   closed_map(
+                     __struct__: atom([RuntimeError]),
+                     __exception__: atom([true]),
+                     message: term()
+                   )
+                 )
+               )
+    end
+
+    test "generates custom traces" do
+      assert typeerror!(
+               try do
+                 raise "oops"
+               rescue
+                 e ->
+                   Integer.to_string(e)
+               end
+             )
+             |> strip_ansi() == ~l"""
+             incompatible types given to Integer.to_string/1:
+
+                 Integer.to_string(e)
+
+             given types:
+
+                 %{..., __exception__: true, __struct__: atom()}
+
+             but expected one of:
+
+                 integer()
+
+             where "e" was given the type:
+
+                 # type: %{..., __exception__: true, __struct__: atom()}
+                 # from: types_test.ex
+                 rescue e
+
+             hint: when you rescue without specifying exception names, the variable is assigned a type of a struct but all of its fields are unknown. If you are trying to access an exception's :message key, either specify the exception names or use `Exception.message/1`.
+             """
+    end
+
+    test "defines an open map of two fields in anonymous rescue" do
+      assert typecheck!(
+               try do
+                 raise "oops"
+               rescue
+                 e -> e
+               end
+             ) ==
+               open_map(
+                 __struct__: atom(),
+                 __exception__: atom([true])
+               )
+    end
+
+    test "matches on stacktrace" do
+      assert typeerror!(
+               try do
+                 :ok
+               rescue
+                 _ ->
+                   [{_, _, args_or_arity, _} | _] = __STACKTRACE__
+                   args_or_arity.fun()
+               end
+             ) =~ ~l"""
+             expected a module (an atom) when invoking fun/0 in expression:
+
+                 args_or_arity.fun()
+
+             where "args_or_arity" was given the type:
+
+                 # type: integer() or list(term())
+                 # from: types_test.ex:LINE-3
+                 [{_, _, args_or_arity, _} | _] = __STACKTRACE__
+             """
+    end
+  end
+
+  describe "cond" do
+    test "always true" do
+      assert typecheck!(
+               cond do
+                 true -> :ok
+               end
+             ) == atom([:ok])
+
+      assert typecheck!(
+               [x, y],
+               cond do
+                 y -> :y
+                 x -> :x
+               end
+             ) == atom([:x, :y])
+
+      assert typedyn!(
+               [x, y],
+               cond do
+                 y -> :y
+                 x -> :x
+               end
+             ) == dynamic(atom([:x, :y]))
+
+      assert typewarn!(
+               [x, y = {:foo, :bar}],
+               cond do
+                 y -> :y
+                 x -> :x
+               end
+             ) ==
+               {atom([:x, :y]),
+                ~l"""
+                this clause in cond will always match:
+
+                    y
+
+                since it has type:
+
+                    dynamic({:foo, :bar})
+
+                where "y" was given the type:
+
+                    # type: dynamic({:foo, :bar})
+                    # from: types_test.ex:LINE-7
+                    y = {:foo, :bar}
+                """}
+    end
+
+    test "always false" do
+      assert typewarn!(
+               [x, y = false],
+               cond do
+                 y -> :y
+                 x -> :x
+               end
+             ) ==
+               {atom([:x, :y]),
+                ~l"""
+                this clause in cond will never match:
+
+                    y
+
+                since it has type:
+
+                    dynamic(false)
+
+                where "y" was given the type:
+
+                    # type: dynamic(false)
+                    # from: types_test.ex:LINE-7
+                    y = false
+                """}
+    end
+
+    test "resets branches" do
+      assert typecheck!(
+               [x],
+               (
+                 cond do
+                   :rand.uniform() > 0.5 -> x.foo
+                   true -> x.bar()
+                 end
+
+                 x
+               )
+             ) == dynamic()
+    end
+  end
+
+  describe "comprehensions" do
+    test "binary generators" do
+      assert typeerror!([<<x>>], for(<<y <- x>>, do: y)) ==
+               ~l"""
+               expected the right side of <- in a binary generator to be a binary:
+
+                   x
+
+               but got type:
+
+                   integer()
+
+               where "x" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-1
+                   <<x>>
+
+               #{hints(:inferred_bitstring_spec)}
+               """
+
+      # Check for compatibility, not subtyping
+      assert typeerror!(
+               [<<x::integer, y::binary>>],
+               for(<<i <- if(:rand.uniform() > 0.5, do: x, else: y)>>, do: i)
+             ) =~
+               ~l"""
+               expected the right side of <- in a binary generator to be a binary:
+
+                   if :rand.uniform() > 0.5 do
+                     x
+                   else
+                     y
+                   end
+
+               but got type:
+
+                   binary() or integer()
+
+               where "x" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-3
+                   <<x::integer, ...>>
+
+               where "y" was given the type:
+
+                   # type: binary()
+                   # from: types_test.ex:LINE-3
+                   <<..., y::binary>>
+               """
+    end
+
+    test "infers binary generators" do
+      assert typecheck!(
+               [x],
+               (
+                 for <<_ <- x>>, do: :ok
+                 x
+               )
+             ) == dynamic(binary())
+    end
+
+    test ":into" do
+      assert typecheck!([binary], for(<<x <- binary>>, do: x)) == list(integer())
+      assert typecheck!([binary], for(<<x <- binary>>, do: x, into: [])) == list(integer())
+      assert typecheck!([binary], for(<<x <- binary>>, do: x, into: "")) == binary()
+      assert typecheck!([binary, other], for(<<x <- binary>>, do: x, into: other)) == dynamic()
+
+      assert typecheck!([enum], for(x <- enum, do: x)) == list(dynamic())
+      assert typecheck!([enum], for(x <- enum, do: x, into: [])) == list(dynamic())
+      assert typecheck!([enum], for(x <- enum, do: x, into: "")) == binary()
+      assert typecheck!([enum, other], for(x <- enum, do: x, into: other)) == dynamic()
+
+      assert typecheck!(
+               [binary],
+               (
+                 into = if :rand.uniform() > 0.5, do: [], else: "0"
+                 for(<<x::float <- binary>>, do: x, into: into)
+               )
+             ) == union(binary(), list(float()))
+
+      assert typecheck!(
+               [binary, empty_list = []],
+               (
+                 into = if :rand.uniform() > 0.5, do: empty_list, else: "0"
+                 for(<<x::float <- binary>>, do: x, into: into)
+               )
+             ) == dynamic(union(binary(), list(float())))
+    end
+
+    test ":reduce checks" do
+      assert typecheck!(
+               [list],
+               for _ <- list, reduce: :ok do
+                 :ok -> 1
+                 _ -> 2.0
+               end
+             ) == union(atom([:ok]), union(integer(), float()))
+    end
+
+    test ":reduce inference" do
+      assert typecheck!(
+               [list, x],
+               (
+                 123 =
+                   for _ <- list, reduce: x do
+                     x -> x
+                   end
+
+                 x
+               )
+             ) == dynamic(integer())
+    end
+  end
+
+  describe "info" do
+    test "__info__/1" do
+      assert typecheck!(GenServer.__info__(:functions)) == list(tuple([atom(), integer()]))
+
+      assert typewarn!(:string.__info__(:functions)) ==
+               {dynamic(), ":string.__info__/1 is undefined or private"}
+
+      assert typecheck!([x], x.__info__(:functions)) == list(tuple([atom(), integer()]))
+
+      assert typeerror!([x], x.__info__(:whatever)) |> strip_ansi() =~ """
+             incompatible types given to __info__/1:
+
+                 x.__info__(:whatever)
+
+             given types:
+
+                 :whatever
+             """
+    end
+
+    test "__info__/1 for struct information" do
+      assert typecheck!(GenServer.__info__(:struct)) == atom([nil])
+
+      assert typecheck!(URI.__info__(:struct)) ==
+               list(closed_map(default: if_set(term()), field: atom()))
+
+      assert typecheck!([x], x.__info__(:struct)) ==
+               list(closed_map(default: if_set(term()), field: atom())) |> union(atom([nil]))
+    end
+
+    test "behaviour_info/1" do
+      assert typecheck!([x], x.behaviour_info(:callbacks)) == list(tuple([atom(), integer()]))
+
+      assert typecheck!(GenServer.behaviour_info(:callbacks)) == list(tuple([atom(), integer()]))
+
+      assert typewarn!(String.behaviour_info(:callbacks)) ==
+               {dynamic(), "String.behaviour_info/1 is undefined or private"}
+    end
+
+    test "module_info/1" do
+      assert typecheck!([x], x.module_info(:exports)) == list(tuple([atom(), integer()]))
+      assert typecheck!(GenServer.module_info(:exports)) == list(tuple([atom(), integer()]))
+    end
+
+    test "module_info/0" do
+      assert typecheck!([x], x.module_info()) |> subtype?(list(tuple([atom(), term()])))
+      assert typecheck!(GenServer.module_info()) |> subtype?(list(tuple([atom(), term()])))
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/module/types/helpers_test.exs b/lib/elixir/test/elixir/module/types/helpers_test.exs
new file mode 100644
index 00000000000..96fe6509ee4
--- /dev/null
+++ b/lib/elixir/test/elixir/module/types/helpers_test.exs
@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("type_helper.exs", __DIR__)
+
+defmodule Module.Types.HelpersTest do
+  use ExUnit.Case, async: true
+  import Module.Types.Helpers
+
+  test "expr_to_string/1" do
+    assert expr_to_string({1, 2}) == "{1, 2}"
+    assert expr_to_string(quote(do: Foo.bar(arg))) == "Foo.bar(arg)"
+    assert expr_to_string(quote(do: :erlang.band(a, b))) == "Bitwise.band(a, b)"
+    assert expr_to_string(quote(do: :erlang.orelse(a, b))) == "a or b"
+    assert expr_to_string(quote(do: :erlang."=:="(a, b))) == "a === b"
+    assert expr_to_string(quote(do: :erlang.list_to_atom(a))) == "List.to_atom(a)"
+    assert expr_to_string(quote(do: :maps.remove(a, b))) == "Map.delete(b, a)"
+    assert expr_to_string(quote(do: :erlang.element(1, a))) == "elem(a, 0)"
+    assert expr_to_string(quote(do: :erlang.element(:erlang.+(a, 1), b))) == "elem(b, a)"
+  end
+end
diff --git a/lib/elixir/test/elixir/module/types/infer_test.exs b/lib/elixir/test/elixir/module/types/infer_test.exs
new file mode 100644
index 00000000000..ba51903b2d9
--- /dev/null
+++ b/lib/elixir/test/elixir/module/types/infer_test.exs
@@ -0,0 +1,133 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("type_helper.exs", __DIR__)
+
+defmodule Module.Types.InferTest do
+  use ExUnit.Case, async: true
+
+  import Module.Types.Descr
+
+  defmacro infer(config, do: block) do
+    quote do
+      runtime_infer(unquote(config).test, unquote(Macro.escape(block)))
+    end
+  end
+
+  defp runtime_infer(module, block) do
+    {{:module, _, binary, _}, []} =
+      Code.eval_quoted(
+        quote do
+          defmodule unquote(module), do: unquote(block)
+        end,
+        []
+      )
+
+    version = :elixir_erl.checker_version()
+    {:ok, {_, [{~c"ExCk", chunk}]}} = :beam_lib.chunks(binary, [~c"ExCk"])
+    {^version, data} = :erlang.binary_to_term(chunk)
+    for {fun, %{sig: sig}} <- data.exports, into: %{}, do: {fun, sig}
+  end
+
+  test "infer types from patterns", config do
+    types =
+      infer config do
+        def fun1(%y{}, %x{}, x = y, x = Point), do: :ok
+        def fun2(%x{}, %y{}, x = y, x = Point), do: :ok
+        def fun3(%y{}, %x{}, x = y, y = Point), do: :ok
+        def fun4(%x{}, %y{}, x = y, y = Point), do: :ok
+      end
+
+    args = [
+      dynamic(open_map(__struct__: atom([Point]))),
+      dynamic(open_map(__struct__: atom([Point]))),
+      dynamic(atom([Point])),
+      dynamic(atom([Point]))
+    ]
+
+    assert types[{:fun1, 4}] == {:infer, nil, [{args, atom([:ok])}]}
+    assert types[{:fun2, 4}] == {:infer, nil, [{args, atom([:ok])}]}
+    assert types[{:fun3, 4}] == {:infer, nil, [{args, atom([:ok])}]}
+    assert types[{:fun4, 4}] == {:infer, nil, [{args, atom([:ok])}]}
+  end
+
+  test "infer types from expressions", config do
+    types =
+      infer config do
+        def fun(x) do
+          x.foo + x.bar
+        end
+      end
+
+    number = union(integer(), float())
+
+    assert types[{:fun, 1}] ==
+             {:infer, nil, [{[dynamic(open_map(foo: number, bar: number))], dynamic(number)}]}
+  end
+
+  test "infer with Elixir built-in", config do
+    types =
+      infer config do
+        def parse(string), do: Integer.parse(string)
+      end
+
+    assert types[{:parse, 1}] ==
+             {:infer, nil,
+              [{[dynamic()], dynamic(union(atom([:error]), tuple([integer(), term()])))}]}
+  end
+
+  test "merges patterns", config do
+    types =
+      infer config do
+        def fun(:ok), do: :one
+        def fun("two"), do: :two
+        def fun("three"), do: :three
+        def fun("four"), do: :four
+        def fun(:error), do: :five
+      end
+
+    assert types[{:fun, 1}] ==
+             {:infer, [dynamic(union(atom([:ok, :error]), binary()))],
+              [
+                {[dynamic(atom([:ok]))], atom([:one])},
+                {[dynamic(binary())], atom([:two, :three, :four])},
+                {[dynamic(atom([:error]))], atom([:five])}
+              ]}
+  end
+
+  test "infers return types from private functions", config do
+    types =
+      infer config do
+        def pub(x), do: priv(x)
+        defp priv(:ok), do: :ok
+        defp priv(:error), do: :error
+      end
+
+    assert types[{:pub, 1}] ==
+             {:infer, nil, [{[dynamic(atom([:ok, :error]))], dynamic(atom([:ok, :error]))}]}
+
+    assert types[{:priv, 1}] == nil
+  end
+
+  test "infers return types from super functions", config do
+    types =
+      infer config do
+        def pub(:ok), do: :ok
+        def pub(:error), do: :error
+        defoverridable pub: 1
+        def pub(x), do: super(x)
+      end
+
+    assert types[{:pub, 1}] ==
+             {:infer, nil, [{[dynamic(atom([:ok, :error]))], dynamic(atom([:ok, :error]))}]}
+  end
+
+  test "infers return types even with loops", config do
+    types =
+      infer config do
+        def pub(x), do: pub(x)
+      end
+
+    assert types[{:pub, 1}] == {:infer, nil, [{[dynamic()], dynamic()}]}
+  end
+end
diff --git a/lib/elixir/test/elixir/module/types/integration_test.exs b/lib/elixir/test/elixir/module/types/integration_test.exs
new file mode 100644
index 00000000000..6d2b18017f0
--- /dev/null
+++ b/lib/elixir/test/elixir/module/types/integration_test.exs
@@ -0,0 +1,1585 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("type_helper.exs", __DIR__)
+
+defmodule Module.Types.IntegrationTest do
+  use ExUnit.Case
+
+  import ExUnit.CaptureIO
+  import Module.Types.Descr
+
+  defp builtin_protocols do
+    [
+      Collectable,
+      Enumerable,
+      IEx.Info,
+      Inspect,
+      JSON.Encoder,
+      List.Chars,
+      String.Chars
+    ]
+  end
+
+  test "built-in protocols" do
+    builtin_protocols =
+      for app <- ~w[eex elixir ex_unit iex logger mix]a,
+          Application.ensure_loaded(app),
+          module <- Application.spec(app, :modules),
+          Code.ensure_loaded(module),
+          function_exported?(module, :__protocol__, 1),
+          do: module
+
+    # If this test fails, update:
+    # * lib/elixir/scripts/elixir_docs.ex
+    assert Enum.sort(builtin_protocols) == builtin_protocols()
+  end
+
+  setup_all do
+    Application.put_env(:elixir, :ansi_enabled, false)
+
+    on_exit(fn ->
+      Application.put_env(:elixir, :ansi_enabled, true)
+    end)
+  end
+
+  describe "ExCk chunk" do
+    test "writes exports" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          defp a, do: :ok
+          defmacrop b, do: a()
+          def c, do: b()
+          defmacro d, do: b()
+          @deprecated "oops"
+          def e, do: :ok
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          @callback f() :: :ok
+        end
+        """,
+        "c.ex" => """
+        defmodule C do
+          @macrocallback g() :: :ok
+        end
+        """
+      }
+
+      modules = compile_modules(files)
+
+      assert [
+               {{:c, 0}, %{}},
+               {{:e, 0}, %{deprecated: "oops", sig: {:infer, _, _}}}
+             ] = read_chunk(modules[A]).exports
+
+      assert read_chunk(modules[B]).exports == [
+               {{:behaviour_info, 1}, %{sig: :none}}
+             ]
+
+      assert read_chunk(modules[C]).exports == [
+               {{:behaviour_info, 1}, %{sig: :none}}
+             ]
+    end
+
+    test "writes exports with inferred map types" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          defstruct [:x, :y, :z]
+
+          def struct_create_with_atom_keys(x) do
+            infer(y = %A{x: x})
+            {x, y}
+          end
+
+          def map_create_with_atom_keys(x) do
+            infer(%{__struct__: A, x: x, y: nil, z: nil})
+            x
+          end
+
+          def map_update_with_atom_keys(x) do
+            infer(%{x | y: nil})
+            x
+          end
+
+          def map_update_with_unknown_keys(x, key) do
+            infer(%{x | key => 123})
+            x
+          end
+
+          defp infer(%A{x: <<_::binary>>, y: nil}) do
+            :ok
+          end
+        end
+        """
+      }
+
+      modules = compile_modules(files)
+      exports = read_chunk(modules[A]).exports |> Map.new()
+
+      return = fn name, arity ->
+        pair = {name, arity}
+        %{^pair => %{sig: {:infer, nil, [{_, return}]}}} = exports
+        return
+      end
+
+      assert return.(:struct_create_with_atom_keys, 1) ==
+               dynamic(
+                 tuple([
+                   binary(),
+                   closed_map(
+                     __struct__: atom([A]),
+                     x: binary(),
+                     y: atom([nil]),
+                     z: atom([nil])
+                   )
+                 ])
+               )
+
+      assert return.(:map_create_with_atom_keys, 1) == dynamic(binary())
+
+      assert return.(:map_update_with_atom_keys, 1) ==
+               dynamic(
+                 closed_map(
+                   __struct__: atom([A]),
+                   x: binary(),
+                   y: atom([nil]),
+                   z: term()
+                 )
+               )
+
+      assert return.(:map_update_with_unknown_keys, 2) ==
+               dynamic(
+                 closed_map(
+                   __struct__: atom([A]),
+                   x: binary(),
+                   y: atom([nil]),
+                   z: term()
+                 )
+               )
+    end
+
+    test "writes exports with inferred function types" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def captured, do: &to_capture/1
+          defp to_capture(<<"ok">>), do: :ok
+          defp to_capture(<<"error">>), do: :error
+          defp to_capture([_ | _]), do: :list
+        end
+        """
+      }
+
+      modules = compile_modules(files)
+      exports = read_chunk(modules[A]).exports |> Map.new()
+
+      return = fn name, arity ->
+        pair = {name, arity}
+        %{^pair => %{sig: {:infer, nil, [{_, return}]}}} = exports
+        return
+      end
+
+      assert return.(:captured, 0)
+             |> equal?(
+               fun_from_non_overlapping_clauses([
+                 {[binary()], dynamic(atom([:ok, :error]))},
+                 {[non_empty_list(term(), term())], dynamic(atom([:list]))}
+               ])
+             )
+    end
+
+    test "writes exports for implementations" do
+      files = %{
+        "pi.ex" => """
+        defprotocol Itself do
+          @fallback_to_any true
+          def itself(data)
+        end
+
+        defimpl Itself,
+          for: [
+            Atom,
+            BitString,
+            Float,
+            Function,
+            Integer,
+            List,
+            Map,
+            Port,
+            PID,
+            Reference,
+            Tuple,
+            Any,
+            Range,
+            Unknown
+          ] do
+          def itself(data), do: data
+          def this_wont_warn(:ok), do: :ok
+        end
+        """
+      }
+
+      {modules, stderr} = with_io(:stderr, fn -> compile_modules(files) end)
+
+      assert stderr =~
+               "you are implementing a protocol for Unknown but said module is not available"
+
+      refute stderr =~ "this_wont_warn"
+
+      itself_arg = fn mod ->
+        {_, %{sig: {:infer, nil, [{[value], value}]}}} =
+          List.keyfind(read_chunk(modules[mod]).exports, {:itself, 1}, 0)
+
+        value
+      end
+
+      assert itself_arg.(Itself.Atom) == dynamic(atom())
+      assert itself_arg.(Itself.BitString) == dynamic(binary())
+      assert itself_arg.(Itself.Float) == dynamic(float())
+      assert itself_arg.(Itself.Function) == dynamic(fun())
+      assert itself_arg.(Itself.Integer) == dynamic(integer())
+
+      assert itself_arg.(Itself.List) ==
+               dynamic(union(empty_list(), non_empty_list(term(), term())))
+
+      assert itself_arg.(Itself.Map) == dynamic(open_map(__struct__: if_set(negation(atom()))))
+      assert itself_arg.(Itself.Port) == dynamic(port())
+      assert itself_arg.(Itself.PID) == dynamic(pid())
+      assert itself_arg.(Itself.Reference) == dynamic(reference())
+      assert itself_arg.(Itself.Tuple) == dynamic(tuple())
+      assert itself_arg.(Itself.Any) == dynamic(term())
+
+      assert itself_arg.(Itself.Range) ==
+               dynamic(
+                 closed_map(__struct__: atom([Range]), first: term(), last: term(), step: term())
+               )
+
+      assert itself_arg.(Itself.Unknown) == dynamic(open_map(__struct__: atom([Unknown])))
+    end
+  end
+
+  describe "type checking" do
+    test "inferred remote calls" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def fun(:ok), do: :doki
+          def fun(:error), do: :bad
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          def badarg do
+            A.fun(:unknown)
+          end
+
+          def badmatch do
+            :doki = A.fun(:error)
+          end
+        end
+        """
+      }
+
+      warnings = [
+        """
+            warning: incompatible types given to A.fun/1:
+
+                A.fun(:unknown)
+        """,
+        """
+            but expected one of:
+
+                #1
+                dynamic(:ok)
+
+                #2
+                dynamic(:error)
+        """,
+        """
+            warning: the following pattern will never match:
+
+                :doki = A.fun(:error)
+
+            because the right-hand side has type:
+
+                dynamic(:bad)
+        """
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "mismatched locals" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def error(), do: private(raise "oops")
+          def public(x), do: private(List.to_tuple(x))
+          defp private(:ok), do: nil
+        end
+        """
+      }
+
+      warnings = [
+        """
+            warning: incompatible types given to private/1:
+
+                private(raise RuntimeError.exception("oops"))
+
+        """,
+        "the 1st argument is empty (often represented as none())",
+        """
+            typing violation found at:
+            │
+          2 │   def error(), do: private(raise "oops")
+            │                    ~
+            │
+            └─ a.ex:2:20: A.error/0
+        """,
+        """
+            warning: incompatible types given to private/1:
+
+                private(List.to_tuple(x))
+        """,
+        """
+            typing violation found at:
+            │
+          3 │   def public(x), do: private(List.to_tuple(x))
+            │                      ~
+            │
+            └─ a.ex:3:22: A.public/1
+        """
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "unused private clauses" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def public(x) do
+            private(List.to_tuple(x))
+          end
+
+          defp private(nil), do: nil
+          defp private("foo"), do: "foo"
+          defp private({:ok, ok}), do: ok
+          defp private({:error, error}), do: error
+          defp private("bar"), do: "bar"
+        end
+        """
+      }
+
+      warnings = [
+        """
+            warning: this clause of defp private/1 is never used
+            │
+          6 │   defp private(nil), do: nil
+            │        ~
+            │
+            └─ a.ex:6:8: A.private/1
+        """,
+        """
+            warning: this clause of defp private/1 is never used
+            │
+          7 │   defp private("foo"), do: "foo"
+            │        ~
+            │
+            └─ a.ex:7:8: A.private/1
+        """,
+        """
+            warning: this clause of defp private/1 is never used
+            │
+         10 │   defp private("bar"), do: "bar"
+            │        ~
+            │
+            └─ a.ex:10:8: A.private/1
+        """
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "unused overridable private clauses" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          use B
+          def public(x), do: private(x)
+          defp private(x), do: super(List.to_tuple(x))
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          defmacro __using__(_) do
+            quote do
+              defp private({:ok, ok}), do: ok
+              defp private(:error), do: :error
+              defoverridable private: 1
+            end
+          end
+        end
+        """
+      }
+
+      assert_no_warnings(files)
+    end
+
+    test "unused private clauses without warnings" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          use B
+
+          # Not all clauses are invoked, but do not warn since they are generated
+          def public1(x), do: generated(List.to_tuple(x))
+
+          # Avoid false positives caused by inference
+          def public2(x), do: (:ok = raising_private(x))
+
+          defp raising_private(true), do: :ok
+          defp raising_private(false), do: raise "oops"
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          defmacro __using__(_) do
+            quote generated: true do
+              defp generated({:ok, ok}), do: ok
+              defp generated(:error), do: :error
+            end
+          end
+        end
+        """
+      }
+
+      assert_no_warnings(files)
+    end
+
+    test "mismatched implementation" do
+      files = %{
+        "a.ex" => """
+        defprotocol Itself do
+          def itself(data)
+        end
+
+        defimpl Itself, for: Range do
+          def itself(nil), do: nil
+          def itself(range), do: range
+        end
+        """
+      }
+
+      warnings = [
+        """
+            warning: the 1st pattern in clause will never match:
+
+                nil
+
+            because it is expected to receive type:
+
+                dynamic(%Range{})
+
+            hint: defimpl for Range requires its callbacks to match exclusively on %Range{}
+
+            typing violation found at:
+            │
+          6 │   def itself(nil), do: nil
+            │   ~~~~~~~~~~~~~~~~~~~~~~~~
+            │
+            └─ a.ex:6: Itself.Range.itself/1
+        """
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    @tag :require_ast
+    test "no implementation" do
+      files = %{
+        "a.ex" => """
+        defprotocol NoImplProtocol do
+          def callback(data)
+        end
+        """,
+        "b.ex" => """
+        defmodule NoImplProtocol.Caller do
+          def run do
+            NoImplProtocol.callback(:hello)
+          end
+        end
+        """
+      }
+
+      warnings = [
+        """
+            warning: incompatible types given to NoImplProtocol.callback/1:
+
+                NoImplProtocol.callback(:hello)
+
+            given types:
+
+                -:hello-
+
+            but the NoImplProtocol protocol was not yet implemented for any type and therefore will always fail.
+
+            This warning will disappear once you define a implementation. If the protocol is part of a library, you may define a dummy implementation for development/test.
+
+            typing violation found at:
+            │
+          3 │     NoImplProtocol.callback(:hello)
+            │                    ~
+            │
+            └─ b.ex:3:20: NoImplProtocol.Caller.run/0
+        """
+      ]
+
+      assert_warnings(files, warnings, consolidate_protocols: true)
+    end
+
+    @tag :require_ast
+    test "String.Chars protocol dispatch" do
+      files = %{
+        "a.ex" => """
+        defmodule FooBar do
+          def example1(_.._//_ = data), do: to_string(data)
+          def example2(_.._//_ = data), do: "hello \#{data} world"
+        end
+        """
+      }
+
+      warnings = [
+        """
+            warning: incompatible types given to String.Chars.to_string/1:
+
+                to_string(data)
+
+            given types:
+
+                -dynamic(%Range{})-
+
+            but expected a type that implements the String.Chars protocol.
+            You either passed the wrong value or you must:
+
+            1. convert the given value to a string explicitly
+               (use inspect/1 if you want to convert any data structure to a string)
+            2. implement the String.Chars protocol
+
+            where "data" was given the type:
+
+                # type: dynamic(%Range{})
+                # from: a.ex:2:24
+                _.._//_ = data
+
+            hint: the String.Chars protocol is implemented for the following types:
+
+                dynamic(
+                  %Date{} or %DateTime{} or %NaiveDateTime{} or %Time{} or %URI{} or %Version{} or
+                    %Version.Requirement{}
+                ) or atom() or binary() or empty_list() or float() or integer() or non_empty_list(term(), term())
+        """,
+        """
+            warning: incompatible value given to string interpolation:
+
+                data
+
+            it has type:
+
+                -dynamic(%Range{})-
+
+            but expected a type that implements the String.Chars protocol.
+            You either passed the wrong value or you must:
+
+            1. convert the given value to a string explicitly
+               (use inspect/1 if you want to convert any data structure to a string)
+            2. implement the String.Chars protocol
+
+            where "data" was given the type:
+
+                # type: dynamic(%Range{})
+                # from: a.ex:3:24
+                _.._//_ = data
+        """
+      ]
+
+      assert_warnings(files, warnings, consolidate_protocols: true)
+    end
+
+    @tag :require_ast
+    test "Enumerable protocol dispatch" do
+      files = %{
+        "a.ex" => """
+        defmodule FooBar do
+          def example1(%Date{} = date), do: for(x <- date, do: x)
+          def example2(), do: for(i <- [1, 2, 3], into: Date.utc_today(), do: i * 2)
+          def example3(), do: for(i <- [1, 2, 3], into: 456, do: i * 2)
+        end
+        """
+      }
+
+      warnings = [
+        """
+            warning: incompatible value given to for-comprehension:
+
+                x <- date
+
+            it has type:
+
+                -dynamic(%Date{})-
+
+            but expected a type that implements the Enumerable protocol.
+            You either passed the wrong value or you must:
+
+            1. convert the given value to an Enumerable explicitly
+            2. implement the Enumerable protocol
+
+            where "date" was given the type:
+
+                # type: dynamic(%Date{})
+                # from: a.ex:2:24
+                %Date{} = date
+
+            hint: the Enumerable protocol is implemented for the following types:
+
+                dynamic(
+                  %Date.Range{} or %File.Stream{} or %GenEvent.Stream{} or %HashDict{} or %HashSet{} or
+                    %IO.Stream{} or %MapSet{} or %Range{} or %Stream{}
+                ) or empty_list() or fun() or non_empty_list(term(), term()) or non_struct_map()
+        """,
+        """
+            warning: incompatible value given to :into option in for-comprehension:
+
+                into: Date.utc_today()
+
+            it has type:
+
+                -dynamic(%Date{})-
+
+            but expected a type that implements the Collectable protocol.
+            You either passed the wrong value or you forgot to implement the protocol.
+
+            hint: the Collectable protocol is implemented for the following types:
+
+                dynamic(%File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{}) or binary() or
+                  empty_list() or non_empty_list(term(), term()) or non_struct_map()
+        """,
+        """
+            warning: incompatible value given to :into option in for-comprehension:
+
+                into: 456
+
+            it has type:
+
+                -integer()-
+
+            but expected a type that implements the Collectable protocol.
+            You either passed the wrong value or you forgot to implement the protocol.
+
+            hint: the Collectable protocol is implemented for the following types:
+
+                dynamic(%File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{}) or binary() or
+                  empty_list() or non_empty_list(term(), term()) or non_struct_map()
+        """
+      ]
+
+      assert_warnings(files, warnings, consolidate_protocols: true)
+    end
+
+    test "incompatible default argument" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def ok(x = :ok \\\\ nil) do
+            x
+          end
+        end
+        """
+      }
+
+      warnings = [
+        ~S"""
+            warning: incompatible types given as default arguments to ok/1:
+
+                -nil-
+
+            but expected one of:
+
+                dynamic(:ok)
+
+            typing violation found at:
+            │
+          2 │   def ok(x = :ok \\ nil) do
+            │                  ~
+            │
+            └─ a.ex:2:18: A.ok/0
+        """
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "returns diagnostics with source and file" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          @file "generated.ex"
+          def fun(arg) do
+            :ok = List.to_tuple(arg)
+          end
+        end
+        """
+      }
+
+      {_modules, warnings} = with_compile_warnings(files)
+
+      assert [
+               %{
+                 message: "the following pattern will never match" <> _,
+                 file: file,
+                 source: source
+               }
+             ] = warnings.runtime_warnings
+
+      assert String.ends_with?(source, "a.ex")
+      assert Path.type(source) == :absolute
+      assert String.ends_with?(file, "generated.ex")
+      assert Path.type(file) == :absolute
+    after
+      purge(A)
+    end
+
+    @tag :require_ast
+    test "regressions" do
+      files = %{
+        # do not emit false positives from defguard
+        "a.ex" => """
+        defmodule A do
+          defguard is_non_nil_arity_function(fun, arity)
+                   when arity != nil and is_function(fun, arity)
+
+          def check(fun, args) do
+            is_non_nil_arity_function(fun, length(args))
+          end
+        end
+        """,
+        # do not parse binary segments as variables
+        "b.ex" => """
+        defmodule B do
+          def decode(byte) do
+            case byte do
+              enc when enc in [<<0x00>>, <<0x01>>] -> :ok
+            end
+          end
+        end
+        """,
+        # String.Chars protocol dispatch on improper lists
+        "c.ex" => """
+        defmodule C do
+          def example, do: to_string([?a, ?b | "!"])
+        end
+        """
+      }
+
+      assert_no_warnings(files, consolidate_protocols: true)
+    end
+  end
+
+  describe "undefined warnings" do
+    test "handles Erlang modules" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a, do: :not_a_module.no_module()
+          def b, do: :lists.no_func()
+        end
+        """
+      }
+
+      warnings = [
+        ":not_a_module.no_module/0 is undefined (module :not_a_module is not available or is yet to be defined)",
+        "a.ex:2:28: A.a/0",
+        ":lists.no_func/0 is undefined or private",
+        "a.ex:3:21: A.b/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "handles built in functions" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a, do: Kernel.module_info()
+          def b, do: Kernel.module_info(:functions)
+          def c, do: Kernel.__info__(:functions)
+          def d, do: GenServer.behaviour_info(:callbacks)
+          def e, do: Kernel.behaviour_info(:callbacks)
+        end
+        """
+      }
+
+      warnings = [
+        "Kernel.behaviour_info/1 is undefined or private",
+        "a.ex:6:21: A.e/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "handles module body conditionals" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          if function_exported?(List, :flatten, 1) do
+            List.flatten([1, 2, 3])
+          else
+            List.old_flatten([1, 2, 3])
+          end
+
+          if function_exported?(List, :flatten, 1) do
+            def flatten(arg), do: List.flatten(arg)
+          else
+            def flatten(arg), do: List.old_flatten(arg)
+          end
+
+          if function_exported?(List, :flatten, 1) do
+            def flatten2(arg), do: List.old_flatten(arg)
+          else
+            def flatten2(arg), do: List.flatten(arg)
+          end
+        end
+        """
+      }
+
+      warnings = [
+        "List.old_flatten/1 is undefined or private. Did you mean:",
+        "* flatten/1",
+        "* flatten/2",
+        "a.ex:15:33: A.flatten2/1"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "reports missing functions" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a, do: A.no_func()
+          def b, do: A.a()
+
+          @file "external_source.ex"
+          def c, do: &A.no_func/1
+        end
+        """
+      }
+
+      warnings = [
+        "A.no_func/0 is undefined or private",
+        "a.ex:2:16: A.a/0",
+        "A.no_func/1 is undefined or private",
+        "external_source.ex:6:17: A.c/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "reports missing functions respecting arity" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a, do: :ok
+          def b, do: A.a(1)
+
+          @file "external_source.ex"
+          def c, do: A.b(1)
+        end
+        """
+      }
+
+      warnings = [
+        "A.a/1 is undefined or private. Did you mean:",
+        "* a/0",
+        "a.ex:3:16: A.b/0",
+        "A.b/1 is undefined or private. Did you mean:",
+        "* b/0",
+        "external_source.ex:6:16: A.c/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "reports missing modules" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a, do: D.no_module()
+
+          @file "external_source.ex"
+          def c, do: E.no_module()
+
+          def i, do: Io.puts "hello"
+        end
+        """
+      }
+
+      warnings = [
+        "D.no_module/0 is undefined (module D is not available or is yet to be defined)",
+        "a.ex:2:16: A.a/0",
+        "E.no_module/0 is undefined (module E is not available or is yet to be defined)",
+        "external_source.ex:5:16: A.c/0",
+        "Io.puts/1 is undefined (module Io is not available or is yet to be defined)",
+        "a.ex:7:17: A.i/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "reports missing captures" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a, do: &A.no_func/0
+
+          @file "external_source.ex"
+          def c, do: &A.no_func/1
+        end
+        """
+      }
+
+      warnings = [
+        "A.no_func/0 is undefined or private",
+        "a.ex:2:17: A.a/0",
+        "A.no_func/1 is undefined or private",
+        "external_source.ex:5:17: A.c/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "doesn't report missing functions at compile time" do
+      files = %{
+        "a.ex" => """
+        Enum.map([], fn _ -> BadReferencer.no_func4() end)
+
+        if function_exported?(List, :flatten, 1) do
+          List.flatten([1, 2, 3])
+        else
+          List.old_flatten([1, 2, 3])
+        end
+        """
+      }
+
+      assert_no_warnings(files)
+    end
+
+    test "handles multiple modules in one file" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a, do: B.no_func()
+          def b, do: B.a()
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          def a, do: A.no_func()
+          def b, do: A.b()
+        end
+        """
+      }
+
+      warnings = [
+        "B.no_func/0 is undefined or private",
+        "a.ex:2:16: A.a/0",
+        "A.no_func/0 is undefined or private",
+        "b.ex:2:16: B.a/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "groups multiple warnings in one file" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a, do: A.no_func()
+
+          @file "external_source.ex"
+          def b, do: A2.no_func()
+
+          def c, do: A.no_func()
+          def d, do: A2.no_func()
+        end
+        """
+      }
+
+      warnings = [
+        "A2.no_func/0 is undefined (module A2 is not available or is yet to be defined)",
+        "└─ a.ex:8:17: A.d/0",
+        "└─ external_source.ex:5:17: A.b/0",
+        "A.no_func/0 is undefined or private",
+        "└─ a.ex:2:16: A.a/0",
+        "└─ a.ex:7:16: A.c/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "hints exclude deprecated functions" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def to_charlist(a), do: a
+
+          @deprecated "Use String.to_charlist/1 instead"
+          def to_char_list(a), do: a
+
+          def c(a), do: A.to_list(a)
+        end
+        """
+      }
+
+      warnings = [
+        "A.to_list/1 is undefined or private. Did you mean:",
+        "* to_charlist/1",
+        "a.ex:7:19: A.c/1"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "do not warn of module defined in local (runtime) context" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          def a() do
+            defmodule B do
+              def b(), do: :ok
+            end
+
+            B.b()
+          end
+        end
+        """
+      }
+
+      assert_no_warnings(files)
+    end
+
+    test "warn of unrequired module" do
+      files = %{
+        "ab.ex" => """
+        defmodule A do
+          def a(), do: B.b()
+        end
+
+        defmodule B do
+          defmacro b(), do: :ok
+        end
+        """
+      }
+
+      warnings = [
+        "Be sure to require B if you intend to invoke this macro",
+        "ab.ex:2:18: A.a/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "excludes local no_warn_undefined" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          @compile {:no_warn_undefined, [MissingModule, {MissingModule2, :func, 2}]}
+          @compile {:no_warn_undefined, {B, :func, 2}}
+
+          def a, do: MissingModule.func(1)
+          def b, do: MissingModule2.func(1, 2)
+          def c, do: MissingModule2.func(1)
+          def d, do: MissingModule3.func(1, 2)
+          def e, do: B.func(1)
+          def f, do: B.func(1, 2)
+          def g, do: B.func(1, 2, 3)
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          def func(_), do: :ok
+        end
+        """
+      }
+
+      warnings = [
+        "MissingModule2.func/1 is undefined (module MissingModule2 is not available or is yet to be defined)",
+        "a.ex:7:29: A.c/0",
+        "MissingModule3.func/2 is undefined (module MissingModule3 is not available or is yet to be defined)",
+        "a.ex:8:29: A.d/0",
+        "B.func/3 is undefined or private. Did you mean:",
+        "* func/1",
+        "a.ex:11:16: A.g/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "warn of external nested module" do
+      files = %{
+        "a.ex" => """
+        defmodule A.B do
+          def a, do: :ok
+        end
+        defmodule A do
+          alias A.B
+          def a, do: B.a()
+          def b, do: B.a(1)
+          def c, do: B.no_func()
+        end
+        """
+      }
+
+      warnings = [
+        "A.B.a/1 is undefined or private. Did you mean:",
+        "* a/0",
+        " def b, do: B.a(1)",
+        "a.ex:7:16: A.b/0",
+        "A.B.no_func/0 is undefined or private",
+        "def c, do: B.no_func()",
+        "a.ex:8:16: A.c/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "warn of compile time context module defined before calls" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          defmodule B do
+            def a, do: :ok
+          end
+          def a, do: B.a()
+          def b, do: B.a(1)
+          def c, do: B.no_func()
+        end
+        """
+      }
+
+      warnings = [
+        "A.B.a/1 is undefined or private. Did you mean:",
+        "* a/0",
+        " def b, do: B.a(1)",
+        "a.ex:6:16: A.b/0",
+        "A.B.no_func/0 is undefined or private",
+        "def c, do: B.no_func()",
+        "a.ex:7:16: A.c/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "warn of compile time context module defined after calls and aliased" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          alias A.B
+          def a, do: B.a()
+          def b, do: B.a(1)
+          def c, do: B.no_func()
+          defmodule B do
+            def a, do: :ok
+          end
+        end
+        """
+      }
+
+      warnings = [
+        "A.B.a/1 is undefined or private. Did you mean:",
+        "* a/0",
+        " def b, do: B.a(1)",
+        "a.ex:4:16: A.b/0",
+        "A.B.no_func/0 is undefined or private",
+        "def c, do: B.no_func()",
+        "a.ex:5:16: A.c/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "excludes global no_warn_undefined" do
+      no_warn_undefined = Code.get_compiler_option(:no_warn_undefined)
+
+      try do
+        Code.compiler_options(
+          no_warn_undefined: [MissingModule, {MissingModule2, :func, 2}, {B, :func, 2}]
+        )
+
+        files = %{
+          "a.ex" => """
+          defmodule A do
+            @compile {:no_warn_undefined, [MissingModule, {MissingModule2, :func, 2}]}
+            @compile {:no_warn_undefined, {B, :func, 2}}
+
+            def a, do: MissingModule.func(1)
+            def b, do: MissingModule2.func(1, 2)
+            def c, do: MissingModule2.func(1)
+            def d, do: MissingModule3.func(1, 2)
+            def e, do: B.func(1)
+            def f, do: B.func(1, 2)
+            def g, do: B.func(1, 2, 3)
+          end
+          """,
+          "b.ex" => """
+          defmodule B do
+            def func(_), do: :ok
+          end
+          """
+        }
+
+        warnings = [
+          "MissingModule2.func/1 is undefined (module MissingModule2 is not available or is yet to be defined)",
+          "a.ex:7:29: A.c/0",
+          "MissingModule3.func/2 is undefined (module MissingModule3 is not available or is yet to be defined)",
+          "a.ex:8:29: A.d/0",
+          "B.func/3 is undefined or private. Did you mean:",
+          "* func/1",
+          "a.ex:11:16: A.g/0"
+        ]
+
+        assert_warnings(files, warnings)
+      after
+        Code.compiler_options(no_warn_undefined: no_warn_undefined)
+      end
+    end
+
+    test "global no_warn_undefined :all" do
+      no_warn_undefined = Code.get_compiler_option(:no_warn_undefined)
+
+      try do
+        Code.compiler_options(no_warn_undefined: :all)
+
+        files = %{
+          "a.ex" => """
+          defmodule A do
+            def a, do: MissingModule.func(1)
+          end
+          """
+        }
+
+        assert_no_warnings(files)
+      after
+        Code.compiler_options(no_warn_undefined: no_warn_undefined)
+      end
+    end
+
+    test "global no_warn_undefined :all and local exclude" do
+      no_warn_undefined = Code.get_compiler_option(:no_warn_undefined)
+
+      try do
+        Code.compiler_options(no_warn_undefined: :all)
+
+        files = %{
+          "a.ex" => """
+          defmodule A do
+            @compile {:no_warn_undefined, MissingModule}
+
+            def a, do: MissingModule.func(1)
+            def b, do: MissingModule2.func(1, 2)
+          end
+          """
+        }
+
+        assert_no_warnings(files)
+      after
+        Code.compiler_options(no_warn_undefined: no_warn_undefined)
+      end
+    end
+  end
+
+  describe "after_verify" do
+    test "reports functions" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          @after_verify __MODULE__
+
+          def __after_verify__(__MODULE__) do
+            IO.warn "from after_verify", []
+          end
+        end
+        """
+      }
+
+      warning = [
+        "warning: ",
+        "from after_verify"
+      ]
+
+      assert_warnings(files, warning)
+    end
+  end
+
+  describe "deprecated" do
+    test "reports functions" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          @deprecated "oops"
+          def a, do: A.a()
+        end
+        """
+      }
+
+      warnings = [
+        "A.a/0 is deprecated. oops",
+        "a.ex:3:16: A.a/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "reports imported functions" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          @deprecated "oops"
+          def a, do: :ok
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          import A
+          def b, do: a()
+        end
+        """
+      }
+
+      warnings = [
+        "A.a/0 is deprecated. oops",
+        "b.ex:3:14: B.b/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "reports structs" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          @deprecated "oops"
+          defstruct [:x, :y]
+          def match(%A{}), do: :ok
+          def build(:ok), do: %A{}
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          def match(%A{}), do: :ok
+          def build(:ok), do: %A{}
+        end
+        """
+      }
+
+      warnings = [
+        "A.__struct__/0 is deprecated. oops",
+        "└─ a.ex:4:13: A.match/1",
+        "└─ a.ex:5:23: A.build/1",
+        "A.__struct__/0 is deprecated. oops",
+        "└─ b.ex:2:13: B.match/1",
+        "└─ b.ex:3:23: B.build/1"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "reports module body" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          @deprecated "oops"
+          def a, do: :ok
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          require A
+          A.a()
+        end
+        """
+      }
+
+      warnings = [
+        "A.a/0 is deprecated. oops",
+        "b.ex:3:5: B (module)"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "reports macro" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          @deprecated "oops"
+          defmacro a, do: :ok
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          require A
+          def b, do: A.a()
+        end
+        """
+      }
+
+      warnings = [
+        "A.a/0 is deprecated. oops",
+        "b.ex:3:16: B.b/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+
+    test "reports unquote functions" do
+      files = %{
+        "a.ex" => """
+        defmodule A do
+          @deprecated "oops"
+          def a, do: :ok
+        end
+        """,
+        "b.ex" => """
+        defmodule B do
+          def b, do: unquote(&A.a/0)
+        end
+        """
+      }
+
+      warnings = [
+        "A.a/0 is deprecated. oops",
+        "b.ex: B.b/0"
+      ]
+
+      assert_warnings(files, warnings)
+    end
+  end
+
+  defp assert_warnings(files, expected, opts \\ [])
+
+  defp assert_warnings(files, expected, opts) when is_binary(expected) do
+    assert capture_compile_warnings(files, opts) == expected
+  end
+
+  defp assert_warnings(files, expecteds, opts) when is_list(expecteds) do
+    output = capture_compile_warnings(files, opts)
+
+    Enum.each(expecteds, fn expected ->
+      assert output =~ expected
+    end)
+  end
+
+  defp assert_no_warnings(files, opts \\ []) do
+    assert capture_compile_warnings(files, opts) == ""
+  end
+
+  defp capture_compile_warnings(files, opts) do
+    in_tmp(fn ->
+      paths = generate_files(files)
+      capture_io(:stderr, fn -> compile_to_path(paths, opts) end)
+    end)
+  end
+
+  defp with_compile_warnings(files) do
+    in_tmp(fn ->
+      paths = generate_files(files)
+      with_io(:stderr, fn -> compile_to_path(paths, []) end) |> elem(0)
+    end)
+  end
+
+  defp compile_modules(files) do
+    in_tmp(fn ->
+      paths = generate_files(files)
+      {modules, _warnings} = compile_to_path(paths, [])
+
+      Map.new(modules, fn module ->
+        {^module, binary, _filename} = :code.get_object_code(module)
+        {module, binary}
+      end)
+    end)
+  end
+
+  defp compile_to_path(paths, opts) do
+    if opts[:consolidate_protocols] do
+      Code.prepend_path(".")
+
+      result =
+        compile_to_path_with_after_compile(paths, fn ->
+          if Keyword.get(opts, :consolidate_protocols, false) do
+            paths = [".", Application.app_dir(:elixir, "ebin")]
+            protocols = Protocol.extract_protocols(paths)
+
+            for protocol <- protocols do
+              impls = Protocol.extract_impls(protocol, paths)
+              {:ok, binary} = Protocol.consolidate(protocol, impls)
+              File.write!(Atom.to_string(protocol) <> ".beam", binary)
+              purge(protocol)
+            end
+          end
+        end)
+
+      Code.delete_path(".")
+      Enum.each(builtin_protocols(), &purge/1)
+
+      result
+    else
+      compile_to_path_with_after_compile(paths, fn -> :ok end)
+    end
+  end
+
+  defp compile_to_path_with_after_compile(paths, callback) do
+    {:ok, modules, warnings} =
+      Kernel.ParallelCompiler.compile_to_path(paths, ".",
+        return_diagnostics: true,
+        after_compile: callback
+      )
+
+    for module <- modules do
+      purge(module)
+    end
+
+    {modules, warnings}
+  end
+
+  defp generate_files(files) do
+    for {file, contents} <- files do
+      File.write!(file, contents)
+      file
+    end
+  end
+
+  defp read_chunk(binary) do
+    assert {:ok, {_module, [{~c"ExCk", chunk}]}} = :beam_lib.chunks(binary, [~c"ExCk"])
+    assert {:elixir_checker_v4, map} = :erlang.binary_to_term(chunk)
+    map
+  end
+
+  defp purge(mod) do
+    :code.delete(mod)
+    :code.purge(mod)
+  end
+
+  defp in_tmp(fun) do
+    path = PathHelpers.tmp_path("checker")
+
+    File.rm_rf!(path)
+    File.mkdir_p!(path)
+    File.cd!(path, fun)
+  end
+end
diff --git a/lib/elixir/test/elixir/module/types/map_test.exs b/lib/elixir/test/elixir/module/types/map_test.exs
new file mode 100644
index 00000000000..ef7f8778ddc
--- /dev/null
+++ b/lib/elixir/test/elixir/module/types/map_test.exs
@@ -0,0 +1,181 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("type_helper.exs", __DIR__)
+
+defmodule Module.Types.MapTest do
+  # Tests for the Map module
+  use ExUnit.Case, async: true
+
+  import TypeHelper
+  import Module.Types.Descr
+  defmacro domain_key(arg) when is_atom(arg), do: [arg]
+
+  describe "Map.to_list/1" do
+    test "checking" do
+      assert typecheck!([x = %{}], Map.to_list(x)) == dynamic(list(tuple([term(), term()])))
+
+      assert typecheck!(
+               (
+                 x = %{}
+                 Map.to_list(x)
+               )
+             ) == empty_list()
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three}
+                 Map.to_list(x)
+               )
+             ) ==
+               list(tuple([binary(), atom([:three])]))
+
+      assert typecheck!(
+               (
+                 x = %{a: 1, b: "two"}
+                 Map.to_list(x)
+               )
+             ) ==
+               non_empty_list(
+                 union(tuple([atom([:a]), integer()]), tuple([atom([:b]), binary()]))
+               )
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three, a: 1, b: "two"}
+                 Map.to_list(x)
+               )
+             ) ==
+               non_empty_list(
+                 tuple([atom([:a]), integer()])
+                 |> union(tuple([atom([:b]), binary()]))
+                 |> union(tuple([binary(), atom([:three])]))
+               )
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.to_list(x)
+                 x
+               )
+             ) == dynamic(open_map())
+    end
+
+    test "errors" do
+      assert typeerror!([x = []], Map.to_list(x)) =~ "incompatible types given to Map.to_list/1"
+    end
+  end
+
+  describe "Map.keys/1" do
+    test "checking" do
+      assert typecheck!([x = %{}], Map.keys(x)) == dynamic(list(term()))
+
+      assert typecheck!(
+               (
+                 x = %{}
+                 Map.keys(x)
+               )
+             ) == empty_list()
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three}
+                 Map.keys(x)
+               )
+             ) ==
+               list(binary())
+
+      assert typecheck!(
+               (
+                 x = %{a: 1, b: "two"}
+                 Map.keys(x)
+               )
+             ) ==
+               non_empty_list(union(atom([:a]), atom([:b])))
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three, a: 1, b: "two"}
+                 Map.keys(x)
+               )
+             ) ==
+               non_empty_list(
+                 atom([:a])
+                 |> union(atom([:b]))
+                 |> union(binary())
+               )
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.keys(x)
+                 x
+               )
+             ) == dynamic(open_map())
+    end
+
+    test "errors" do
+      assert typeerror!([x = []], Map.keys(x)) =~ "incompatible types given to Map.keys/1"
+    end
+  end
+
+  describe "Map.values/1" do
+    test "checking" do
+      assert typecheck!([x = %{}], Map.values(x)) == dynamic(list(term()))
+
+      assert typecheck!(
+               (
+                 x = %{}
+                 Map.values(x)
+               )
+             ) == empty_list()
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three}
+                 Map.values(x)
+               )
+             ) ==
+               list(atom([:three]))
+
+      assert typecheck!(
+               (
+                 x = %{a: 1, b: "two"}
+                 Map.values(x)
+               )
+             ) ==
+               non_empty_list(union(integer(), binary()))
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three, a: 1, b: "two"}
+                 Map.values(x)
+               )
+             ) ==
+               non_empty_list(
+                 integer()
+                 |> union(binary())
+                 |> union(atom([:three]))
+               )
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.values(x)
+                 x
+               )
+             ) == dynamic(open_map())
+    end
+
+    test "errors" do
+      assert typeerror!([x = []], Map.values(x)) =~ "incompatible types given to Map.values/1"
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/module/types/pattern_test.exs b/lib/elixir/test/elixir/module/types/pattern_test.exs
new file mode 100644
index 00000000000..626c4c91478
--- /dev/null
+++ b/lib/elixir/test/elixir/module/types/pattern_test.exs
@@ -0,0 +1,346 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("type_helper.exs", __DIR__)
+
+defmodule Module.Types.PatternTest do
+  use ExUnit.Case, async: true
+
+  import TypeHelper
+  import Module.Types.Descr
+
+  describe "variables" do
+    test "captures variables from simple assignment in head" do
+      assert typecheck!([x = :foo], x) == dynamic(atom([:foo]))
+      assert typecheck!([:foo = x], x) == dynamic(atom([:foo]))
+    end
+
+    test "captures variables from simple assignment in =" do
+      assert typecheck!(
+               (
+                 x = :foo
+                 x
+               )
+             ) == atom([:foo])
+    end
+
+    test "refines information across patterns" do
+      assert typecheck!([%y{}, %x{}, x = y, x = Point], y) == dynamic(atom([Point]))
+    end
+
+    test "repeated refinements are ignored on reporting" do
+      assert typeerror!([{name, arity}, arity = 123], hd(Atom.to_charlist(name))) |> strip_ansi() ==
+               ~l"""
+               incompatible types given to Kernel.hd/1:
+
+                   hd(Atom.to_charlist(name))
+
+               given types:
+
+                   empty_list() or non_empty_list(integer())
+
+               but expected one of:
+
+                   non_empty_list(term(), term())
+
+               where "name" was given the type:
+
+                   # type: dynamic()
+                   # from: types_test.ex
+                   {name, arity}
+               """
+    end
+
+    test "errors on conflicting refinements" do
+      assert typeerror!([a = b, a = :foo, b = :bar], {a, b}) ==
+               ~l"""
+               the following pattern will never match:
+
+                   a = b
+
+               where "a" was given the type:
+
+                   # type: dynamic(:foo)
+                   # from: types_test.ex:LINE-1
+                   a = :foo
+
+               where "b" was given the type:
+
+                   # type: dynamic(:bar)
+                   # from: types_test.ex:LINE-1
+                   b = :bar
+               """
+    end
+
+    test "can be accessed even if they don't match" do
+      assert typeerror!(
+               (
+                 # This will never match, info should not be "corrupted"
+                 [info | _] = __ENV__.function
+                 info
+               )
+             ) =~ "the following pattern will never match"
+    end
+
+    test "does not check underscore" do
+      assert typecheck!(_ = raise("oops")) == none()
+    end
+  end
+
+  describe "=" do
+    test "precedence does not matter" do
+      uri_type = typecheck!([x = %URI{}], x)
+
+      assert typecheck!(
+               (
+                 x = %URI{} = URI.new!("/")
+                 x
+               )
+             ) == uri_type
+
+      assert typecheck!(
+               (
+                 %URI{} = x = URI.new!("/")
+                 x
+               )
+             ) == uri_type
+    end
+
+    test "refines types" do
+      assert typecheck!(
+               [x, foo = :foo, bar = 123],
+               (
+                 {^foo, ^bar} = x
+                 x
+               )
+             ) == dynamic(tuple([atom([:foo]), integer()]))
+    end
+
+    test "reports incompatible types" do
+      assert typeerror!([x = {:ok, _}], [_ | _] = x) == ~l"""
+             the following pattern will never match:
+
+                 [_ | _] = x
+
+             because the right-hand side has type:
+
+                 dynamic({:ok, term()})
+
+             where "x" was given the type:
+
+                 # type: dynamic({:ok, term()})
+                 # from: types_test.ex:LINE
+                 x = {:ok, _}
+             """
+    end
+  end
+
+  describe "structs" do
+    test "variable name" do
+      assert typecheck!([%x{}], x) == dynamic(atom())
+    end
+
+    test "variable name fields" do
+      assert typecheck!([x = %_{}], x.__struct__) == dynamic(atom())
+      assert typecheck!([x = %_{}], x) == dynamic(open_map(__struct__: atom()))
+
+      assert typecheck!([x = %m{}, m = Point], x) ==
+               dynamic(open_map(__struct__: atom([Point])))
+
+      assert typecheck!([m = Point, x = %m{}], x) ==
+               dynamic(open_map(__struct__: atom([Point])))
+
+      assert typeerror!([m = 123], %^m{} = %Point{}) ==
+               ~l"""
+               expected an atom as struct name:
+
+                   %^m{}
+
+               got type:
+
+                   integer()
+
+               where "m" was given the type:
+
+                   # type: integer()
+                   # from: types_test.ex:LINE-1
+                   m = 123
+               """
+    end
+
+    test "fields in guards" do
+      assert typeerror!([x = %Point{}], x.foo_bar, :ok) ==
+               ~l"""
+               unknown key .foo_bar in expression:
+
+                   x.foo_bar
+
+               the given type does not have the given key:
+
+                   dynamic(%Point{x: term(), y: term(), z: term()})
+
+               where "x" was given the type:
+
+                   # type: dynamic(%Point{})
+                   # from: types_test.ex:LINE-1
+                   x = %Point{}
+               """
+    end
+  end
+
+  describe "maps" do
+    test "fields in patterns" do
+      assert typecheck!([x = %{foo: :bar}], x) == dynamic(open_map(foo: atom([:bar])))
+      assert typecheck!([x = %{123 => 456}], x) == dynamic(open_map())
+      assert typecheck!([x = %{123 => 456, foo: :bar}], x) == dynamic(open_map(foo: atom([:bar])))
+    end
+
+    test "fields in guards" do
+      assert typecheck!([x = %{foo: :bar}], x.bar, x) == dynamic(open_map(foo: atom([:bar])))
+    end
+  end
+
+  describe "tuples" do
+    test "in patterns" do
+      assert typecheck!([x = {:ok, 123}], x) == dynamic(tuple([atom([:ok]), integer()]))
+      assert typecheck!([{:x, y} = {x, :y}], {x, y}) == dynamic(tuple([atom([:x]), atom([:y])]))
+    end
+  end
+
+  describe "lists" do
+    test "in patterns" do
+      assert typecheck!([x = [1, 2, 3]], x) ==
+               dynamic(non_empty_list(integer()))
+
+      assert typecheck!([x = [1, 2, 3 | y], y = :foo], x) ==
+               dynamic(non_empty_list(integer(), atom([:foo])))
+
+      assert typecheck!([x = [1, 2, 3 | y], y = [1.0, 2.0, 3.0]], x) ==
+               dynamic(non_empty_list(union(integer(), float())))
+
+      assert typecheck!([x = [:ok | z]], {x, z}) ==
+               dynamic(tuple([non_empty_list(term(), term()), term()]))
+
+      assert typecheck!([x = [y | z]], {x, y, z}) ==
+               dynamic(tuple([non_empty_list(term(), term()), term(), term()]))
+    end
+
+    test "in patterns through ++" do
+      assert typecheck!([x = [] ++ []], x) == dynamic(empty_list())
+
+      assert typecheck!([x = [] ++ y, y = :foo], x) ==
+               dynamic(atom([:foo]))
+
+      assert typecheck!([x = [1, 2, 3] ++ y, y = :foo], x) ==
+               dynamic(non_empty_list(integer(), atom([:foo])))
+
+      assert typecheck!([x = [1, 2, 3] ++ y, y = [1.0, 2.0, 3.0]], x) ==
+               dynamic(non_empty_list(union(integer(), float())))
+    end
+
+    test "with lists inside tuples inside lists" do
+      assert typecheck!([[node_1 = {[arg]}, node_2 = {[arg]}]], {node_1, node_2, arg})
+             |> equal?(
+               dynamic(
+                 tuple([
+                   tuple([non_empty_list(term())]),
+                   tuple([non_empty_list(term())]),
+                   term()
+                 ])
+               )
+             )
+    end
+  end
+
+  describe "binaries" do
+    test "ok" do
+      assert typecheck!([<<x>>], x) == integer()
+      assert typecheck!([<<x::float>>], x) == float()
+      assert typecheck!([<<x::binary>>], x) == binary()
+      assert typecheck!([<<x::utf8>>], x) == integer()
+    end
+
+    test "nested" do
+      assert typecheck!([<<0, <<x::bitstring>>::binary>>], x) == binary()
+    end
+
+    test "error" do
+      assert typeerror!([<<x::binary-size(2), x::float>>], x) == ~l"""
+             incompatible types assigned to "x":
+
+                 binary() !~ float()
+
+             where "x" was given the types:
+
+                 # type: binary()
+                 # from: types_test.ex:LINE
+                 <<x::binary-size(2), ...>>
+
+                 # type: float()
+                 # from: types_test.ex:LINE
+                 <<..., x::float>>
+             """
+
+      assert typeerror!([<<x::float, x>>], x) == ~l"""
+             incompatible types assigned to "x":
+
+                 float() !~ integer()
+
+             where "x" was given the types:
+
+                 # type: float()
+                 # from: types_test.ex:LINE
+                 <<x::float, ...>>
+
+                 # type: integer()
+                 # from: types_test.ex:LINE
+                 <<..., x>>
+
+             #{hints(:inferred_bitstring_spec)}
+             """
+    end
+
+    test "pin inference" do
+      assert typecheck!(
+               [x, y],
+               (
+                 <<^x>> = y
+                 x
+               )
+             ) == dynamic(integer())
+    end
+
+    test "size ok" do
+      assert typecheck!([<<x, y, _::size(x - y)>>], :ok) == atom([:ok])
+    end
+
+    test "size error" do
+      assert typeerror!([<<x::float, _::size(x)>>], :ok) ==
+               ~l"""
+               expected an integer in binary size:
+
+                   size(x)
+
+               got type:
+
+                   float()
+
+               where "x" was given the type:
+
+                   # type: float()
+                   # from: types_test.ex:LINE-1
+                   <<x::float, ...>>
+               """
+    end
+
+    test "size pin inference" do
+      assert typecheck!(
+               [x, y],
+               (
+                 <<_::size(^x)>> = y
+                 x
+               )
+             ) == dynamic(integer())
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/module/types/type_helper.exs b/lib/elixir/test/elixir/module/types/type_helper.exs
new file mode 100644
index 00000000000..79c4997ebff
--- /dev/null
+++ b/lib/elixir/test/elixir/module/types/type_helper.exs
@@ -0,0 +1,213 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Point do
+  defstruct [:x, :y, z: 0]
+end
+
+defmodule TypeHelper do
+  alias Module.Types
+  alias Module.Types.{Pattern, Expr, Descr}
+
+  @doc """
+  Main helper for checking the given AST type checks without warnings.
+  """
+  defmacro typedyn!(patterns \\ [], guards \\ true, body) do
+    quote do
+      unquote(typecheck(:dynamic, patterns, guards, body, __CALLER__))
+      |> TypeHelper.__typecheck__!()
+    end
+  end
+
+  @doc """
+  Main helper for checking the given AST type checks without warnings.
+  """
+  defmacro typecheck!(patterns \\ [], guards \\ true, body) do
+    quote do
+      unquote(typecheck(:static, patterns, guards, body, __CALLER__))
+      |> TypeHelper.__typecheck__!()
+    end
+  end
+
+  @doc """
+  Main helper for checking the given AST type checks errors.
+  """
+  defmacro typeerror!(patterns \\ [], guards \\ true, body) do
+    [patterns, guards, body] = prune_columns([patterns, guards, body])
+
+    quote do
+      unquote(typecheck(:static, patterns, guards, body, __CALLER__))
+      |> TypeHelper.__typeerror__!()
+    end
+  end
+
+  @doc """
+  Main helper for checking the given AST type warns.
+  """
+  defmacro typewarn!(patterns \\ [], guards \\ true, body) do
+    [patterns, guards, body] = prune_columns([patterns, guards, body])
+
+    quote do
+      unquote(typecheck(:static, patterns, guards, body, __CALLER__))
+      |> TypeHelper.__typewarn__!()
+    end
+  end
+
+  @doc """
+  Main helper for checking the diagnostic of a given AST.
+  """
+  defmacro typediag!(patterns \\ [], guards \\ true, body) do
+    quote do
+      unquote(typecheck(:static, patterns, guards, body, __CALLER__))
+      |> TypeHelper.__typediag__!()
+    end
+  end
+
+  @doc false
+  def __typecheck__!({type, %{warnings: []}}), do: type
+
+  def __typecheck__!({_type, %{warnings: warnings, failed: false}}),
+    do: raise("type checking ok but with warnings: #{inspect(warnings)}")
+
+  def __typecheck__!({_type, %{warnings: warnings, failed: true}}),
+    do: raise("type checking errored with warnings: #{inspect(warnings)}")
+
+  @doc false
+  def __typeerror__!({_type, %{warnings: [{module, warning, _locs} | _], failed: true}}),
+    do: module.format_diagnostic(warning).message
+
+  def __typeerror__!({_type, %{warnings: warnings, failed: false}}),
+    do: raise("type checking with warnings but expected error: #{inspect(warnings)}")
+
+  def __typeerror__!({type, _}),
+    do: raise("type checking ok but expected error: #{Descr.to_quoted_string(type)}")
+
+  @doc false
+  def __typediag__!({type, %{warnings: [_ | _] = warnings}}),
+    do: {type, for({module, arg, _} <- warnings, do: module.format_diagnostic(arg))}
+
+  def __typediag__!({type, %{warnings: []}}),
+    do: raise("type checking without diagnostics: #{Descr.to_quoted_string(type)}")
+
+  @doc false
+  def __typewarn__!({type, %{warnings: [{module, warning, _locs}], failed: false}}),
+    do: {type, module.format_diagnostic(warning).message}
+
+  def __typewarn__!({type, %{warnings: []}}),
+    do: raise("type checking ok without warnings: #{Descr.to_quoted_string(type)}")
+
+  def __typewarn__!({_type, %{warnings: warnings, failed: false}}),
+    do: raise("type checking ok but many warnings: #{inspect(warnings)}")
+
+  def __typewarn__!({_type, %{warnings: warnings, failed: true}}),
+    do: raise("type checking errored with warnings: #{inspect(warnings)}")
+
+  defp typecheck(mode, patterns, guards, body, env) do
+    {patterns, guards, body} = expand_and_unpack(patterns, guards, body, env)
+
+    quote do
+      TypeHelper.__typecheck__(
+        unquote(mode),
+        unquote(Macro.escape(patterns)),
+        unquote(Macro.escape(guards)),
+        unquote(Macro.escape(body))
+      )
+    end
+  end
+
+  def __typecheck__(mode, patterns, guards, body) do
+    stack = new_stack(mode)
+    expected = Enum.map(patterns, fn _ -> Descr.dynamic() end)
+
+    {_trees, context} =
+      Pattern.of_head(patterns, guards, expected, :default, [], stack, new_context())
+
+    Expr.of_expr(body, Descr.term(), :ok, stack, context)
+  end
+
+  defp expand_and_unpack(patterns, guards, body, env) do
+    fun =
+      quote do
+        fn unquote_splicing(patterns) when unquote(guards) -> unquote(body) end
+      end
+
+    {ast, _, _} = :elixir_expand.expand(fun, :elixir_env.env_to_ex(env), env)
+    {:fn, _, [{:->, _, [[{:when, _, args}], body]}]} = ast
+    {patterns, guards} = Enum.split(args, -1)
+    {patterns, guards, body}
+  end
+
+  defp new_stack(mode) do
+    cache = if mode == :infer, do: :none, else: Module.ParallelChecker.test_cache()
+    handler = fn _, fun_arity, _, _ -> raise "no local lookup for: #{inspect(fun_arity)}" end
+    Types.stack(mode, "types_test.ex", TypesTest, {:test, 0}, [], cache, handler)
+  end
+
+  defp new_context() do
+    Types.context()
+  end
+
+  @doc """
+  Interpolate the given hints.
+  """
+  def hints(hints) do
+    hints
+    |> List.wrap()
+    |> Module.Types.Helpers.format_hints()
+    |> IO.iodata_to_binary()
+    |> String.trim()
+  end
+
+  @doc """
+  A string-like sigil that replaces LINE references by actual line.
+  """
+  defmacro sigil_l({:<<>>, meta, parts}, []) do
+    parts =
+      for part <- parts do
+        if is_binary(part) do
+          part
+          |> replace_line(__CALLER__.line)
+          |> :elixir_interpolation.unescape_string()
+        else
+          part
+        end
+      end
+
+    {:<<>>, meta, parts}
+  end
+
+  @strip_ansi [IO.ANSI.green(), IO.ANSI.red(), IO.ANSI.reset()]
+
+  @doc """
+  Strip ansi escapes from message.
+  """
+  def strip_ansi(doc) do
+    String.replace(doc, @strip_ansi, "")
+  end
+
+  defp replace_line(string, line) do
+    [head | rest] = String.split(string, "LINE")
+
+    rest =
+      for part <- rest do
+        case part do
+          <<?-, num, part::binary>> when num in ?0..?9 ->
+            [Integer.to_string(line - num + ?0), part]
+
+          part ->
+            [Integer.to_string(line), part]
+        end
+      end
+
+    IO.iodata_to_binary([head | rest])
+  end
+
+  defp prune_columns(ast) do
+    Macro.prewalk(ast, fn node ->
+      Macro.update_meta(node, &Keyword.delete(&1, :column))
+    end)
+  end
+end
diff --git a/lib/elixir/test/elixir/module_test.exs b/lib/elixir/test/elixir/module_test.exs
index a750e93becd..a167086ad4b 100644
--- a/lib/elixir/test/elixir/module_test.exs
+++ b/lib/elixir/test/elixir/module_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule ModuleTest.ToBeUsed do
   def value, do: 1
@@ -9,19 +13,24 @@ defmodule ModuleTest.ToBeUsed do
     Module.put_attribute(target, :before_compile, __MODULE__)
     Module.put_attribute(target, :after_compile, __MODULE__)
     Module.put_attribute(target, :before_compile, {__MODULE__, :callback})
-    quote do: (def line, do: __ENV__.line)
+    quote(do: def(line, do: __ENV__.line))
   end
 
   defmacro __before_compile__(env) do
-    quote do: (def before_compile, do: unquote(env.vars))
+    quote(do: def(before_compile, do: unquote(Macro.Env.vars(env))))
   end
 
-  defmacro __after_compile__(%Macro.Env{module: ModuleTest.ToUse, vars: []}, bin) when is_binary(bin) do
-    # IO.puts "HELLO"
+  defmacro __after_compile__(%Macro.Env{module: ModuleTest.ToUse} = env, bin)
+           when is_binary(bin) do
+    # Ensure module is not longer tracked as being loaded
+    false = __MODULE__ in :elixir_module.compiler_modules()
+    [] = Macro.Env.vars(env)
+    :ok
   end
 
   defmacro callback(env) do
     value = Module.get_attribute(env.module, :has_callback)
+
     quote do
       def callback_value(true), do: unquote(value)
     end
@@ -29,9 +38,11 @@ defmodule ModuleTest.ToBeUsed do
 end
 
 defmodule ModuleTest.ToUse do
-  32 = __ENV__.line # Moving the next line around can make tests fail
+  # Moving the next line around can make tests fail
+  42 = __ENV__.line
   var = 1
-  var # Not available in callbacks
+  # Not available in callbacks
+  _ = var
   def callback_value(false), do: false
   use ModuleTest.ToBeUsed
 end
@@ -39,77 +50,117 @@ end
 defmodule ModuleTest do
   use ExUnit.Case, async: true
 
-  Module.register_attribute __MODULE__, :register_example, accumulate: true, persist: true
+  doctest Module
+
+  Module.register_attribute(__MODULE__, :register_unset_example, persist: true)
+  Module.register_attribute(__MODULE__, :register_empty_example, accumulate: true, persist: true)
+  Module.register_attribute(__MODULE__, :register_example, accumulate: true, persist: true)
   @register_example :it_works
   @register_example :still_works
 
-  contents = quote do: (def eval_quoted_info, do: {__MODULE__, __ENV__.file, __ENV__.line})
-  Module.eval_quoted __MODULE__, contents, [], file: "sample.ex", line: 13
+  defp purge(module) do
+    :code.purge(module)
+    :code.delete(module)
+  end
 
   defmacrop in_module(block) do
     quote do
-      defmodule Temp, unquote(block)
-      :code.purge(Temp)
-      :code.delete(Temp)
+      defmodule(Temp, unquote(block))
+      purge(Temp)
     end
   end
 
-  ## Eval
-
-  test :eval_quoted do
-    assert eval_quoted_info() == {ModuleTest, "sample.ex", 13}
+  test "module attributes returns value" do
+    in_module do
+      assert @return([:foo, :bar]) == :ok
+      _ = @return
+    end
   end
 
-  test :line_from_macro do
-    assert ModuleTest.ToUse.line == 36
-  end
+  test "raises on write access attempts from __after_compile__/2" do
+    contents =
+      quote do
+        @after_compile __MODULE__
 
-  ## Callbacks
+        def __after_compile__(%Macro.Env{module: module}, bin) when is_binary(bin) do
+          Module.put_attribute(module, :foo, 42)
+        end
+      end
 
-  test :compile_callback_hook do
-    assert ModuleTest.ToUse.callback_value(true) == true
-    assert ModuleTest.ToUse.callback_value(false) == false
+    assert_raise ArgumentError,
+                 "could not call Module.put_attribute/3 because the module ModuleTest.Raise is in read-only mode (@after_compile)",
+                 fn ->
+                   Module.create(ModuleTest.Raise, contents, __ENV__)
+                 end
   end
 
-  test :before_compile_callback_hook do
-    assert ModuleTest.ToUse.before_compile == []
+  test "supports read access to module from __after_compile__/2" do
+    defmodule ModuleTest.NoRaise do
+      @after_compile __MODULE__
+      @foo 42
+
+      def __after_compile__(%Macro.Env{module: module}, bin) when is_binary(bin) do
+        send(self(), Module.get_attribute(module, :foo))
+      end
+    end
+
+    assert_received 42
   end
 
-  test :on_definition do
-    defmodule OnDefinition do
-      @on_definition ModuleTest
+  test "supports @after_verify for inlined modules" do
+    defmodule ModuleTest.AfterVerify do
+      @after_verify __MODULE__
 
-      def hello(foo, bar) do
-        foo + bar
+      def __after_verify__(ModuleTest.AfterVerify) do
+        send(self(), ModuleTest.AfterVerify)
       end
     end
 
-    assert Process.get(ModuleTest.OnDefinition) == :called
+    assert_received ModuleTest.AfterVerify
+  end
+
+  test "in memory modules are tagged as so" do
+    assert :code.which(__MODULE__) == ~c""
+  end
+
+  ## Callbacks
+
+  test "retrieves line from use callsite" do
+    assert ModuleTest.ToUse.line() == 47
+  end
+
+  test "executes custom before_compile callback" do
+    assert ModuleTest.ToUse.callback_value(true) == true
+    assert ModuleTest.ToUse.callback_value(false) == false
+  end
+
+  test "executes default before_compile callback" do
+    assert ModuleTest.ToUse.before_compile() == []
   end
 
   def __on_definition__(env, kind, name, args, guards, expr) do
-    Process.put(env.module, :called)
+    Process.put(env.module, {args, guards, expr})
     assert env.module == ModuleTest.OnDefinition
     assert kind == :def
     assert name == :hello
-    assert [{:foo, _, _}, {:bar, _ , _}] = args
-    assert [] = guards
-    assert {{:., _, [:erlang, :+]}, _, [{:foo, _, nil}, {:bar, _, nil}]} = expr
+    assert Module.defines?(env.module, {:hello, 2})
   end
 
-  test :overridable_inside_before_compile do
-    defmodule OverridableWithBeforeCompile do
-      @before_compile ModuleTest
-    end
-    assert OverridableWithBeforeCompile.constant == 1
-  end
+  test "executes on definition callback" do
+    defmodule OnDefinition do
+      @on_definition ModuleTest
 
-  test :alias_with_raw_atom do
-    defmodule :"Elixir.ModuleTest.RawModule" do
-      def hello, do: :world
-    end
+      def hello(foo, bar)
+
+      assert {[{:foo, _, _}, {:bar, _, _}], [], nil} = Process.get(ModuleTest.OnDefinition)
+
+      def hello(foo, bar) do
+        foo + bar
+      end
 
-    assert RawModule.hello == :world
+      assert {[{:foo, _, _}, {:bar, _, _}], [], [do: {:+, _, [{:foo, _, nil}, {:bar, _, nil}]}]} =
+               Process.get(ModuleTest.OnDefinition)
+    end
   end
 
   defmacro __before_compile__(_) do
@@ -119,29 +170,43 @@ defmodule ModuleTest do
     end
   end
 
-  ## Attributes
+  test "may set overridable inside before_compile callback" do
+    defmodule OverridableWithBeforeCompile do
+      @before_compile ModuleTest
+    end
 
-  test :reserved_attributes do
-    assert List.keyfind(ExUnit.Server.__info__(:attributes), :behaviour, 0) == {:behaviour, [:gen_server]}
+    assert OverridableWithBeforeCompile.constant() == 1
   end
 
-  test :registered_attributes do
-    assert [{:register_example, [:it_works]}, {:register_example, [:still_works]}] ==
-      Enum.filter __MODULE__.__info__(:attributes), &match?({:register_example, _}, &1)
+  describe "__info__(:attributes)" do
+    test "reserved attributes" do
+      assert List.keyfind(ExUnit.Server.__info__(:attributes), :behaviour, 0) ==
+               {:behaviour, [GenServer]}
+    end
+
+    test "registered attributes" do
+      assert Enum.filter(__MODULE__.__info__(:attributes), &match?({:register_example, _}, &1)) ==
+               [{:register_example, [:it_works]}, {:register_example, [:still_works]}]
+    end
+
+    test "registered attributes with no values are not present" do
+      refute List.keyfind(__MODULE__.__info__(:attributes), :register_unset_example, 0)
+      refute List.keyfind(__MODULE__.__info__(:attributes), :register_empty_example, 0)
+    end
   end
 
-  @some_attribute  [1]
+  @some_attribute [1]
   @other_attribute [3, 2, 1]
 
-  test :inside_function_attributes do
-    assert [1] = @some_attribute
-    assert [3, 2, 1] = @other_attribute
+  test "inside function attributes" do
+    assert @some_attribute == [1]
+    assert @other_attribute == [3, 2, 1]
   end
 
   ## Naming
 
-  test :concat do
-    assert Module.concat(Foo, Bar)  == Foo.Bar
+  test "concat" do
+    assert Module.concat(Foo, Bar) == Foo.Bar
     assert Module.concat(Foo, :Bar) == Foo.Bar
     assert Module.concat(Foo, "Bar") == Foo.Bar
     assert Module.concat(Foo, Bar.Baz) == Foo.Bar.Baz
@@ -149,96 +214,472 @@ defmodule ModuleTest do
     assert Module.concat(Bar, nil) == Elixir.Bar
   end
 
-  test :safe_concat do
+  test "safe concat" do
     assert Module.safe_concat(Foo, :Bar) == Foo.Bar
+
     assert_raise ArgumentError, fn ->
-      Module.safe_concat SafeConcat, Doesnt.Exist
+      Module.safe_concat(SafeConcat, Doesnt.Exist)
     end
   end
 
-  test :split do
+  test "split" do
     module = Very.Long.Module.Name.And.Even.Longer
     assert Module.split(module) == ["Very", "Long", "Module", "Name", "And", "Even", "Longer"]
     assert Module.split("Elixir.Very.Long") == ["Very", "Long"]
+
+    assert_raise ArgumentError, "expected an Elixir module, got: :just_an_atom", fn ->
+      Module.split(:just_an_atom)
+    end
+
+    assert_raise ArgumentError, "expected an Elixir module, got: \"Foo\"", fn ->
+      Module.split("Foo")
+    end
+
     assert Module.concat(Module.split(module)) == module
   end
 
-  test :__MODULE__ do
+  test "__MODULE__" do
     assert Code.eval_string("__MODULE__.Foo") |> elem(0) == Foo
   end
 
+  test "__ENV__.file" do
+    assert Path.basename(__ENV__.file) == "module_test.exs"
+  end
+
+  @file "sample.ex"
+  test "@file sets __ENV__.file" do
+    assert __ENV__.file == Path.absname("sample.ex")
+  end
+
+  test "@file raises when invalid" do
+    assert_raise ArgumentError, ~r"@file is a built-in module attribute", fn ->
+      defmodule BadFile do
+        @file :oops
+        def my_fun, do: :ok
+      end
+    end
+  end
+
   ## Creation
 
-  test :defmodule do
-    assert match?({:module, Defmodule, binary, 3} when is_binary(binary), defmodule Defmodule do
-      1 + 2
-    end)
+  test "defmodule" do
+    result =
+      defmodule Defmodule do
+        1 + 2
+      end
+
+    assert {:module, Defmodule, binary, 3} = result
+    assert is_binary(binary)
+  end
+
+  test "defmodule with atom" do
+    result =
+      defmodule :root_defmodule do
+        :ok
+      end
+
+    assert {:module, :root_defmodule, _, _} = result
+  end
+
+  test "does not leak alias from atom" do
+    defmodule :"Elixir.ModuleTest.RawModule" do
+      def hello, do: :world
+    end
+
+    refute __ENV__.aliases[Elixir.ModuleTest]
+    refute __ENV__.aliases[Elixir.RawModule]
+    assert ModuleTest.RawModule.hello() == :world
+  end
+
+  test "does not leak alias from non-atom alias" do
+    defmodule __MODULE__.NonAtomAlias do
+      def hello, do: :world
+    end
+
+    refute __ENV__.aliases[Elixir.ModuleTest]
+    refute __ENV__.aliases[Elixir.NonAtomAlias]
+    assert Elixir.ModuleTest.NonAtomAlias.hello() == :world
   end
 
-  test :defmodule_with_atom do
-    assert match?({:module, :root_defmodule, _, _}, defmodule :root_defmodule do
-      :ok
-    end)
+  test "does not leak alias from Elixir root alias" do
+    defmodule Elixir.ModuleTest.ElixirRootAlias do
+      def hello, do: :world
+    end
+
+    refute __ENV__.aliases[Elixir.ModuleTest]
+    refute __ENV__.aliases[Elixir.ElixirRootAlias]
+    assert Elixir.ModuleTest.ElixirRootAlias.hello() == :world
+  end
+
+  test "does not warn on captured underscored vars" do
+    _unused = 123
+
+    defmodule __MODULE__.NoVarWarning do
+    end
   end
 
-  test :create do
+  @compile {:no_warn_undefined, ModuleCreateSample}
+
+  test "create" do
     contents =
       quote do
         def world, do: true
       end
-    {:module, ModuleCreateSample, _, _} =
-      Module.create(ModuleCreateSample, contents, __ENV__)
-    assert ModuleCreateSample.world
+
+    {:module, ModuleCreateSample, _, _} = Module.create(ModuleCreateSample, contents, __ENV__)
+    assert ModuleCreateSample.world()
   end
 
-  test :create_with_elixir_as_a_name do
+  test "create with a reserved module name" do
     contents =
       quote do
         def world, do: true
       end
-    assert_raise CompileError, fn ->
-      {:module, Elixir, _, _} =
+
+    assert_raise CompileError, ~r/cannot compile module Elixir/, fn ->
+      Code.with_diagnostics(fn ->
         Module.create(Elixir, contents, __ENV__)
+      end)
     end
   end
 
-  test :no_function_in_module_body do
+  @compile {:no_warn_undefined, ModuleTracersSample}
+
+  test "create with propagated tracers" do
+    contents =
+      quote do
+        def world, do: true
+      end
+
+    env = %{__ENV__ | tracers: [:invalid]}
+    {:module, ModuleTracersSample, _, _} = Module.create(ModuleTracersSample, contents, env)
+    assert ModuleTracersSample.world()
+  end
+
+  @compile {:no_warn_undefined, ModuleHygiene}
+
+  test "create with aliases/var hygiene" do
+    contents =
+      quote do
+        alias List, as: L
+
+        def test do
+          L.flatten([1, [2], 3])
+        end
+      end
+
+    Module.create(ModuleHygiene, contents, __ENV__)
+    assert ModuleHygiene.test() == [1, 2, 3]
+  end
+
+  test "ensure function clauses are sorted (to avoid non-determinism in module vsn)" do
+    {_, _, binary, _} =
+      defmodule Ordered do
+        def foo(:foo), do: :bar
+        def baz(:baz), do: :bat
+      end
+
+    {:ok, {ModuleTest.Ordered, [abstract_code: {:raw_abstract_v1, abstract_code}]}} =
+      :beam_lib.chunks(binary, [:abstract_code])
+
+    # We need to traverse functions instead of using :exports as exports are sorted
+    funs = for {:function, _, name, arity, _} <- abstract_code, do: {name, arity}
+    assert funs == [__info__: 1, baz: 1, foo: 1]
+  end
+
+  @compile {:no_warn_undefined, ModuleCreateGenerated}
+
+  test "create with generated true does not emit warnings" do
+    contents =
+      quote generated: true do
+        def world, do: true
+        def world, do: false
+      end
+
+    {:module, ModuleCreateGenerated, _, _} =
+      Module.create(ModuleCreateGenerated, contents, __ENV__)
+
+    assert ModuleCreateGenerated.world()
+  end
+
+  test "uses the debug_info chunk" do
+    {:module, ModuleCreateDebugInfo, binary, _} =
+      Module.create(ModuleCreateDebugInfo, :ok, __ENV__)
+
+    {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} =
+      :beam_lib.chunks(binary, [:debug_info])
+
+    {:ok, map} = backend.debug_info(:elixir_v1, ModuleCreateDebugInfo, data, [])
+    assert map.module == ModuleCreateDebugInfo
+  end
+
+  test "uses the debug_info chunk when explicitly set to true" do
+    {:module, ModuleCreateDebugInfoTrue, binary, _} =
+      Module.create(ModuleCreateDebugInfoTrue, quote(do: @compile({:debug_info, true})), __ENV__)
+
+    {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} =
+      :beam_lib.chunks(binary, [:debug_info])
+
+    {:ok, map} = backend.debug_info(:elixir_v1, ModuleCreateDebugInfoTrue, data, [])
+    assert map.module == ModuleCreateDebugInfoTrue
+  end
+
+  test "uses the debug_info chunk even if debug_info is set to false" do
+    {:module, ModuleCreateNoDebugInfo, binary, _} =
+      Module.create(ModuleCreateNoDebugInfo, quote(do: @compile({:debug_info, false})), __ENV__)
+
+    {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} =
+      :beam_lib.chunks(binary, [:debug_info])
+
+    assert backend.debug_info(:elixir_v1, ModuleCreateNoDebugInfo, data, []) == {:error, :missing}
+  end
+
+  test "compiles to core" do
+    import PathHelpers
+
+    write_beam(
+      defmodule ExampleModule do
+      end
+    )
+
+    {:ok, {ExampleModule, [{~c"Dbgi", dbgi}]}} =
+      ExampleModule |> :code.which() |> :beam_lib.chunks([~c"Dbgi"])
+
+    {:debug_info_v1, backend, data} = :erlang.binary_to_term(dbgi)
+    {:ok, core} = backend.debug_info(:core_v1, ExampleModule, data, [])
+    assert is_tuple(core)
+  end
+
+  test "no function in module body" do
     in_module do
       assert __ENV__.function == nil
     end
   end
 
+  test "does not use ETS tables named after the module" do
+    in_module do
+      assert :ets.info(__MODULE__) == :undefined
+    end
+  end
+
   ## Definitions
 
-  test :defines? do
+  test "defines?" do
     in_module do
-      refute Module.defines? __MODULE__, {:foo, 0}
+      refute Module.defines?(__MODULE__, {:foo, 0})
       def foo(), do: bar()
-      assert Module.defines? __MODULE__, {:foo, 0}
-      assert Module.defines? __MODULE__, {:foo, 0}, :def
+      assert Module.defines?(__MODULE__, {:foo, 0})
+      assert Module.defines?(__MODULE__, {:foo, 0}, :def)
 
-      refute Module.defines? __MODULE__, {:bar, 0}, :defp
+      refute Module.defines?(__MODULE__, {:bar, 0}, :defp)
       defp bar(), do: :ok
-      assert Module.defines? __MODULE__, {:bar, 0}, :defp
+      assert Module.defines?(__MODULE__, {:bar, 0}, :defp)
 
-      refute Module.defines? __MODULE__, {:baz, 0}, :defmacro
+      refute Module.defines?(__MODULE__, {:baz, 0}, :defmacro)
       defmacro baz(), do: :ok
-      assert Module.defines? __MODULE__, {:baz, 0}, :defmacro
+      assert Module.defines?(__MODULE__, {:baz, 0}, :defmacro)
     end
   end
 
-  test :definitions_in do
+  test "definitions in" do
     in_module do
-      def foo(1, 2, 3), do: 4
+      defp bar(), do: :ok
+      def foo(1, 2, 3), do: bar()
+
+      defmacrop macro_bar(), do: 4
+      defmacro macro_foo(1, 2, 3), do: macro_bar()
+
+      assert Module.definitions_in(__MODULE__) |> Enum.sort() ==
+               [{:bar, 0}, {:foo, 3}, {:macro_bar, 0}, {:macro_foo, 3}]
+
+      assert Module.definitions_in(__MODULE__, :def) == [foo: 3]
+      assert Module.definitions_in(__MODULE__, :defp) == [bar: 0]
+      assert Module.definitions_in(__MODULE__, :defmacro) == [macro_foo: 3]
+      assert Module.definitions_in(__MODULE__, :defmacrop) == [macro_bar: 0]
+
+      defoverridable foo: 3
+
+      assert Module.definitions_in(__MODULE__) |> Enum.sort() ==
+               [{:bar, 0}, {:macro_bar, 0}, {:macro_foo, 3}]
+
+      assert Module.definitions_in(__MODULE__, :def) == []
+    end
+  end
+
+  test "get_definition/2 and delete_definition/2" do
+    in_module do
+      def foo(a, b), do: a + b
+
+      assert {:v1, :def, def_meta,
+              [
+                {clause_meta, [{:a, _, nil}, {:b, _, nil}], [],
+                 {{:., _, [:erlang, :+]}, _, [{:a, _, nil}, {:b, _, nil}]}}
+              ]} = Module.get_definition(__MODULE__, {:foo, 2})
+
+      assert [line: _, column: _] = Keyword.take(def_meta, [:line, :column])
+      assert [line: _, column: _] = Keyword.take(clause_meta, [:line, :column])
+      assert {:v1, :def, _, []} = Module.get_definition(__MODULE__, {:foo, 2}, skip_clauses: true)
 
-      assert Module.definitions_in(__MODULE__)        == [foo: 3]
-      assert Module.definitions_in(__MODULE__, :def)  == [foo: 3]
-      assert Module.definitions_in(__MODULE__, :defp) == []
+      assert Module.delete_definition(__MODULE__, {:foo, 2})
+      assert Module.get_definition(__MODULE__, {:foo, 2}) == nil
+      refute Module.delete_definition(__MODULE__, {:foo, 2})
     end
   end
 
-  test :function do
-    assert Module.function(:erlang, :atom_to_list, 1).(:hello) == 'hello'
-    assert is_function Module.function(This, :also_works, 0)
+  test "make_overridable/2 with invalid arguments" do
+    contents =
+      quote do
+        Module.make_overridable(__MODULE__, [{:foo, 256}])
+      end
+
+    message =
+      "each element in tuple list has to be a {function_name :: atom, arity :: 0..255} " <>
+        "tuple, got: {:foo, 256}"
+
+    assert_raise ArgumentError, message, fn ->
+      Module.create(MakeOverridable, contents, __ENV__)
+    end
+  after
+    purge(MakeOverridable)
+  end
+
+  test "raise when called with already compiled module" do
+    message =
+      "could not call Module.get_attribute/2 because the module Enum is already compiled. " <>
+        "Use the Module.__info__/1 callback or Code.fetch_docs/1 instead"
+
+    assert_raise ArgumentError, message, fn ->
+      Module.get_attribute(Enum, :moduledoc)
+    end
+  end
+
+  describe "get_attribute/3" do
+    test "returns a list when the attribute is marked as `accumulate: true`" do
+      in_module do
+        Module.register_attribute(__MODULE__, :value, accumulate: true)
+        assert Module.get_attribute(__MODULE__, :value) == []
+        Module.put_attribute(__MODULE__, :value, 1)
+        assert Module.get_attribute(__MODULE__, :value) == [1]
+        Module.put_attribute(__MODULE__, :value, 2)
+        assert Module.get_attribute(__MODULE__, :value) == [2, 1]
+      end
+    end
+
+    test "returns the value of the attribute if it exists" do
+      in_module do
+        Module.put_attribute(__MODULE__, :attribute, 1)
+        assert Module.get_attribute(__MODULE__, :attribute) == 1
+        assert Module.get_attribute(__MODULE__, :attribute, :default) == 1
+        Module.put_attribute(__MODULE__, :attribute, nil)
+        assert Module.get_attribute(__MODULE__, :attribute, :default) == nil
+      end
+    end
+
+    test "returns the value of the attribute if persisted" do
+      in_module do
+        Module.register_attribute(__MODULE__, :value, persist: true)
+        assert Module.get_attribute(__MODULE__, :value, 123) == 123
+        Module.put_attribute(__MODULE__, :value, 1)
+        assert Module.get_attribute(__MODULE__, :value) == 1
+        Module.put_attribute(__MODULE__, :value, 2)
+        assert Module.get_attribute(__MODULE__, :value) == 2
+        Module.delete_attribute(__MODULE__, :value)
+        assert Module.get_attribute(__MODULE__, :value, 123) == 123
+      end
+    end
+
+    test "returns the passed default if the attribute does not exist" do
+      in_module do
+        assert Module.get_attribute(__MODULE__, :attribute, :default) == :default
+      end
+    end
+  end
+
+  describe "get_last_attribute/3" do
+    test "returns the last set value when the attribute is marked as `accumulate: true`" do
+      in_module do
+        Module.register_attribute(__MODULE__, :value, accumulate: true)
+        Module.put_attribute(__MODULE__, :value, 1)
+        assert Module.get_last_attribute(__MODULE__, :value) == 1
+        Module.put_attribute(__MODULE__, :value, 2)
+        assert Module.get_last_attribute(__MODULE__, :value) == 2
+      end
+    end
+
+    test "returns the value of the non-accumulate attribute if it exists" do
+      in_module do
+        Module.put_attribute(__MODULE__, :attribute, 1)
+        assert Module.get_last_attribute(__MODULE__, :attribute) == 1
+        Module.put_attribute(__MODULE__, :attribute, nil)
+        assert Module.get_last_attribute(__MODULE__, :attribute, :default) == nil
+      end
+    end
+
+    test "returns the passed default if the accumulate attribute has not yet been set" do
+      in_module do
+        Module.register_attribute(__MODULE__, :value, accumulate: true)
+        assert Module.get_last_attribute(__MODULE__, :value) == nil
+        assert Module.get_last_attribute(__MODULE__, :value, :default) == :default
+      end
+    end
+
+    test "returns the passed default if the non-accumulate attribute does not exist" do
+      in_module do
+        assert Module.get_last_attribute(__MODULE__, :value, :default) == :default
+      end
+    end
+  end
+
+  describe "has_attribute?/2 and attributes_in/2" do
+    test "returns true when attribute has been defined" do
+      in_module do
+        @foo 1
+        Module.register_attribute(__MODULE__, :bar, [])
+        Module.register_attribute(__MODULE__, :baz, accumulate: true)
+        Module.put_attribute(__MODULE__, :qux, 2)
+
+        # silence warning
+        _ = @foo
+
+        assert Module.has_attribute?(__MODULE__, :foo)
+        assert :foo in Module.attributes_in(__MODULE__)
+        assert Module.has_attribute?(__MODULE__, :bar)
+        assert :bar in Module.attributes_in(__MODULE__)
+        assert Module.has_attribute?(__MODULE__, :baz)
+        assert :baz in Module.attributes_in(__MODULE__)
+        assert Module.has_attribute?(__MODULE__, :qux)
+        assert :qux in Module.attributes_in(__MODULE__)
+      end
+    end
+
+    test "returns false when attribute has not been defined" do
+      in_module do
+        refute Module.has_attribute?(__MODULE__, :foo)
+      end
+    end
+
+    test "returns false when attribute has been deleted" do
+      in_module do
+        @foo 1
+        Module.delete_attribute(__MODULE__, :foo)
+
+        refute Module.has_attribute?(__MODULE__, :foo)
+      end
+    end
+  end
+
+  test "@on_load" do
+    Process.register(self(), :on_load_test_process)
+
+    defmodule OnLoadTest do
+      @on_load :on_load
+
+      defp on_load do
+        send(:on_load_test_process, :on_loaded)
+        :ok
+      end
+    end
+
+    assert_received :on_loaded
   end
 end
diff --git a/lib/elixir/test/elixir/node_test.exs b/lib/elixir/test/elixir/node_test.exs
deleted file mode 100644
index ff612e4a8cb..00000000000
--- a/lib/elixir/test/elixir/node_test.exs
+++ /dev/null
@@ -1,11 +0,0 @@
-Code.require_file "test_helper.exs", __DIR__
-
-defmodule NodeTest do
-  use ExUnit.Case
-
-  test "start/3 and stop/0" do
-    assert Node.stop == {:error, :not_found}
-    assert {:ok, _} = Node.start(:hello, :shortnames, 15000)
-    assert Node.stop() == :ok
-  end
-end
diff --git a/lib/elixir/test/elixir/option_parser_test.exs b/lib/elixir/test/elixir/option_parser_test.exs
index e4f648f0d97..737a3832e26 100644
--- a/lib/elixir/test/elixir/option_parser_test.exs
+++ b/lib/elixir/test/elixir/option_parser_test.exs
@@ -1,293 +1,658 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule OptionParserTest do
   use ExUnit.Case, async: true
 
-  test "parses boolean option" do
-    assert OptionParser.parse(["--docs"]) == {[docs: true], [], []}
-  end
+  doctest OptionParser
 
-  test "parses alias boolean option as the alias key" do
-    assert OptionParser.parse(["-d"], aliases: [d: :docs])
-           == {[docs: true], [], []}
+  test "parses --key value option" do
+    assert OptionParser.parse(["--source", "form_docs/", "other"], switches: [source: :string]) ==
+             {[source: "form_docs/"], ["other"], []}
   end
 
-  test "parses more than one boolean option" do
-    assert OptionParser.parse(["--docs", "--compile"])
-           == {[docs: true, compile: true], [], []}
+  test "parses --key=value option" do
+    assert OptionParser.parse(["--source=form_docs/", "other"], switches: [source: :string]) ==
+             {[source: "form_docs/"], ["other"], []}
   end
 
-  test "parses more than one boolean options as the alias" do
-    assert OptionParser.parse(["-d", "--compile"], aliases: [d: :docs])
-           == {[docs: true, compile: true], [], []}
+  test "parses overrides options by default" do
+    assert OptionParser.parse(
+             ["--require", "foo", "--require", "bar", "baz"],
+             switches: [require: :string]
+           ) == {[require: "bar"], ["baz"], []}
   end
 
-  test "parses --key value option" do
-    assert OptionParser.parse(["--source", "form_docs/"])
-           == {[source: "form_docs/"], [], []}
-  end
+  test "parses multi-word option" do
+    config = [switches: [hello_world: :boolean]]
+    assert OptionParser.next(["--hello-world"], config) == {:ok, :hello_world, true, []}
+    assert OptionParser.next(["--no-hello-world"], config) == {:ok, :hello_world, false, []}
 
-  test "parses --key=value option" do
-    assert OptionParser.parse(["--source=form_docs/", "other"])
-           == {[source: "form_docs/"], ["other"], []}
-  end
+    assert OptionParser.next(["--no-hello-world"], strict: []) ==
+             {:undefined, "--no-hello-world", nil, []}
 
-  test "parses alias --key value option as the alias" do
-    assert OptionParser.parse(["-s", "from_docs/"], aliases: [s: :source])
-           == {[source: "from_docs/"], [], []}
-  end
+    assert OptionParser.next(["--no-hello_world"], strict: []) ==
+             {:undefined, "--no-hello_world", nil, []}
 
-  test "parses alias --key=value option as the alias" do
-    assert OptionParser.parse(["-s=from_docs/", "other"], aliases: [s: :source])
-           == {[source: "from_docs/"], ["other"], []}
-  end
+    config = [strict: [hello_world: :boolean]]
+    assert OptionParser.next(["--hello-world"], config) == {:ok, :hello_world, true, []}
+    assert OptionParser.next(["--no-hello-world"], config) == {:ok, :hello_world, false, []}
+    assert OptionParser.next(["--hello_world"], config) == {:undefined, "--hello_world", nil, []}
 
-  test "does not interpret undefined options with value as boolean" do
-    assert OptionParser.parse(["--no-bool"])
-           == {[no_bool: true], [], []}
-    assert OptionParser.parse(["--no-bool"], strict: [])
-           == {[], [], [{"--no-bool", nil}]}
-    assert OptionParser.parse(["--no-bool=...", "other"])
-           == {[], ["other"], [{"--no-bool", "..."}]}
+    assert OptionParser.next(["--no-hello_world"], config) ==
+             {:undefined, "--no-hello_world", nil, []}
   end
 
-  test "does not parse -- as an alias" do
-    assert OptionParser.parse(["--s=from_docs/"], aliases: [s: :source])
-           == {[s: "from_docs/"], [], []}
-  end
+  test "parses more than one key-value pair options using switches" do
+    opts = [switches: [source: :string, docs: :string]]
 
-  test "does not parse - as a switch" do
-    assert OptionParser.parse(["-source=from_docs/"], aliases: [s: :source])
-           == {[], [], [{"-source", "from_docs/"}]}
-  end
+    assert OptionParser.parse(["--source", "from_docs/", "--docs", "show"], opts) ==
+             {[source: "from_docs/", docs: "show"], [], []}
 
-  test "parses configured booleans" do
-    assert OptionParser.parse(["--docs=false"], switches: [docs: :boolean])
-           == {[docs: false], [], []}
-    assert OptionParser.parse(["--docs=true"], switches: [docs: :boolean])
-           == {[docs: true], [], []}
-    assert OptionParser.parse(["--docs=other"], switches: [docs: :boolean])
-           == {[], [], [{"--docs", "other"}]}
-    assert OptionParser.parse(["--docs="], switches: [docs: :boolean])
-           == {[], [], [{"--docs", ""}]}
-
-    assert OptionParser.parse(["--docs", "foo"], switches: [docs: :boolean])
-           == {[docs: true], ["foo"], []}
-    assert OptionParser.parse(["--no-docs", "foo"], switches: [docs: :boolean])
-           == {[docs: false], ["foo"], []}
-    assert OptionParser.parse(["--no-docs=foo", "bar"], switches: [docs: :boolean])
-           == {[], ["bar"], [{"--no-docs", "foo"}]}
-    assert OptionParser.parse(["--no-docs=", "bar"], switches: [docs: :boolean])
-           == {[], ["bar"], [{"--no-docs", ""}]}
-  end
+    assert OptionParser.parse(["--source", "from_docs/", "--doc", "show"], opts) ==
+             {[source: "from_docs/", doc: "show"], [], []}
+
+    assert OptionParser.parse(["--source", "from_docs/", "--doc=show"], opts) ==
+             {[source: "from_docs/", doc: "show"], [], []}
 
-  test "does not set unparsed booleans" do
-    assert OptionParser.parse(["foo"], switches: [docs: :boolean])
-           == {[], ["foo"], []}
+    assert OptionParser.parse(["--no-bool"], strict: []) == {[], [], [{"--no-bool", nil}]}
   end
 
-  test "keeps options on configured keep" do
-    args = ["--require", "foo", "--require", "bar", "baz"]
-    assert OptionParser.parse(args, switches: [require: :keep])
-           == {[require: "foo", require: "bar"], ["baz"], []}
+  test "parses more than one key-value pair options using strict" do
+    opts = [strict: [source: :string, docs: :string]]
 
-    assert OptionParser.parse(["--require"], switches: [require: :keep])
-           == {[], [], [{"--require", nil}]}
-  end
+    assert OptionParser.parse(["--source", "from_docs/", "--docs", "show"], opts) ==
+             {[source: "from_docs/", docs: "show"], [], []}
 
-  test "parses configured strings" do
-    assert OptionParser.parse(["--value", "1", "foo"], switches: [value: :string])
-           == {[value: "1"], ["foo"], []}
-    assert OptionParser.parse(["--value=1", "foo"], switches: [value: :string])
-           == {[value: "1"], ["foo"], []}
-    assert OptionParser.parse(["--value"], switches: [value: :string])
-           == {[], [], [{"--value", nil}]}
-    assert OptionParser.parse(["--no-value"], switches: [value: :string])
-           == {[], [], [{"--no-value", nil}]}
-  end
+    assert OptionParser.parse(["--source", "from_docs/", "--doc", "show"], opts) ==
+             {[source: "from_docs/"], ["show"], [{"--doc", nil}]}
+
+    assert OptionParser.parse(["--source", "from_docs/", "--doc=show"], opts) ==
+             {[source: "from_docs/"], [], [{"--doc", nil}]}
 
-  test "parses configured integers" do
-    assert OptionParser.parse(["--value", "1", "foo"], switches: [value: :integer])
-           == {[value: 1], ["foo"], []}
-    assert OptionParser.parse(["--value=1", "foo"], switches: [value: :integer])
-           == {[value: 1], ["foo"], []}
-    assert OptionParser.parse(["--value", "WAT", "foo"], switches: [value: :integer])
-           == {[], ["foo"], [{"--value", "WAT"}]}
+    assert OptionParser.parse(["--no-bool"], strict: []) == {[], [], [{"--no-bool", nil}]}
   end
 
-  test "parses configured integers with keep" do
-    args = ["--value", "1", "--value", "2", "foo"]
-    assert OptionParser.parse(args, switches: [value: [:integer, :keep]])
-           == {[value: 1, value: 2], ["foo"], []}
+  test "collects multiple invalid options" do
+    argv = ["--bad", "opt", "foo", "-o", "bad", "bar"]
+
+    assert OptionParser.parse(argv, switches: [bad: :integer]) ==
+             {[], ["foo", "bar"], [{"--bad", "opt"}]}
+  end
+
+  test "parse/2 raises when using both options: switches and strict" do
+    assert_raise ArgumentError, ":switches and :strict cannot be given together", fn ->
+      OptionParser.parse(["--elixir"], switches: [ex: :string], strict: [elixir: :string])
+    end
+  end
+
+  test "parse/2 raises an exception on invalid switch types/modifiers" do
+    assert_raise ArgumentError, "invalid switch types/modifiers: :bad", fn ->
+      OptionParser.parse(["--elixir"], switches: [ex: :bad])
+    end
+
+    assert_raise ArgumentError, "invalid switch types/modifiers: :bad, :bad_modifier", fn ->
+      OptionParser.parse(["--elixir"], switches: [ex: [:bad, :bad_modifier]])
+    end
+  end
+
+  test "parse!/2 raises an exception for an unknown option using strict" do
+    msg =
+      """
+      1 error found!
+      --doc-bar : Unknown option. Did you mean --docs-bar?
+
+      Supported options:
+        --docs-bar STRING
+        --source STRING\
+      """
+
+    assert_raise OptionParser.ParseError, msg, fn ->
+      argv = ["--source", "from_docs/", "--doc-bar", "show"]
+      OptionParser.parse!(argv, strict: [source: :string, docs_bar: :string])
+    end
+
+    assert_raise OptionParser.ParseError,
+                 """
+                 1 error found!
+                 --foo : Unknown option
+
+                 Supported options:
+                   --docs STRING
+                   --source STRING\
+                 """,
+                 fn ->
+                   argv = ["--source", "from_docs/", "--foo", "show"]
+                   OptionParser.parse!(argv, strict: [source: :string, docs: :string])
+                 end
+  end
+
+  test "parse!/2 raises an exception for an unknown option using strict when it is only off by underscores" do
+    msg =
+      """
+      1 error found!
+      --docs_bar : Unknown option. Did you mean --docs-bar?
+
+      Supported options:
+        --docs-bar STRING
+        --source STRING\
+      """
+
+    assert_raise OptionParser.ParseError, msg, fn ->
+      argv = ["--source", "from_docs/", "--docs_bar", "show"]
+      OptionParser.parse!(argv, strict: [source: :string, docs_bar: :string])
+    end
+  end
+
+  test "parse!/2 raises an exception when an option is of the wrong type" do
+    assert_raise OptionParser.ParseError,
+                 """
+                 1 error found!
+                 --bad : Expected type integer, got "opt"
+
+                 Supported options:
+                   --bad INTEGER\
+                 """,
+                 fn ->
+                   argv = ["--bad", "opt", "foo", "-o", "bad", "bar"]
+                   OptionParser.parse!(argv, switches: [bad: :integer])
+                 end
+  end
+
+  test "parse!/2 lists all supported options and aliases" do
+    expected_suggestion =
+      """
+      1 error found!
+      --verbos : Unknown option. Did you mean --verbose?
+
+      Supported options:
+        --count INTEGER (alias: -c)
+        --debug, --no-debug (alias: -d)
+        --files STRING (alias: -f) (may be given more than once)
+        --name STRING (alias: -n)
+        --verbose, --no-verbose (alias: -v)\
+      """
+
+    assert_raise OptionParser.ParseError, expected_suggestion, fn ->
+      OptionParser.parse!(["--verbos"],
+        strict: [
+          name: :string,
+          count: :integer,
+          verbose: :boolean,
+          debug: :boolean,
+          files: :keep
+        ],
+        aliases: [n: :name, c: :count, v: :verbose, d: :debug, f: :files]
+      )
+    end
+  end
+
+  test "parse_head!/2 raises an exception when an option is of the wrong type" do
+    message =
+      """
+      1 error found!
+      --number : Expected type integer, got "lib"
+
+      Supported options:
+        --number INTEGER\
+      """
+
+    assert_raise OptionParser.ParseError, message, fn ->
+      argv = ["--number", "lib", "test/enum_test.exs"]
+      OptionParser.parse_head!(argv, strict: [number: :integer])
+    end
+  end
+
+  describe "arguments" do
+    test "parses until --" do
+      assert OptionParser.parse(
+               ["--source", "foo", "--", "1", "2", "3"],
+               switches: [source: :string]
+             ) == {[source: "foo"], ["1", "2", "3"], []}
+
+      assert OptionParser.parse_head(
+               ["--source", "foo", "--", "1", "2", "3"],
+               switches: [source: :string]
+             ) == {[source: "foo"], ["1", "2", "3"], []}
+
+      assert OptionParser.parse(
+               ["--source", "foo", "bar", "--", "-x"],
+               switches: [source: :string]
+             ) == {[source: "foo"], ["bar", "-x"], []}
+
+      assert OptionParser.parse_head(
+               ["--source", "foo", "bar", "--", "-x"],
+               switches: [source: :string]
+             ) == {[source: "foo"], ["bar", "--", "-x"], []}
+    end
+
+    test "return separators" do
+      assert OptionParser.parse_head(["--", "foo"],
+               switches: [],
+               return_separator: true
+             ) == {[], ["--", "foo"], []}
+
+      assert OptionParser.parse_head(["--no-halt", "--", "foo"],
+               switches: [halt: :boolean],
+               return_separator: true
+             ) == {[halt: false], ["--", "foo"], []}
+
+      assert OptionParser.parse_head(["foo.exs", "--no-halt", "--", "foo"],
+               switches: [halt: :boolean],
+               return_separator: true
+             ) == {[], ["foo.exs", "--no-halt", "--", "foo"], []}
+    end
+
+    test "parses - as argument" do
+      argv = ["--foo", "-", "-b", "-"]
+      opts = [strict: [foo: :boolean, boo: :string], aliases: [b: :boo]]
+      assert OptionParser.parse(argv, opts) == {[foo: true, boo: "-"], ["-"], []}
+    end
+
+    test "parses until first non-option arguments" do
+      argv = ["--source", "from_docs/", "test/enum_test.exs", "--verbose"]
+
+      assert OptionParser.parse_head(argv, switches: [source: :string]) ==
+               {[source: "from_docs/"], ["test/enum_test.exs", "--verbose"], []}
+    end
+  end
+
+  describe "aliases" do
+    test "supports boolean aliases" do
+      assert OptionParser.parse(["-d"], aliases: [d: :docs], switches: [docs: :boolean]) ==
+               {[docs: true], [], []}
+    end
+
+    test "supports non-boolean aliases" do
+      assert OptionParser.parse(
+               ["-s", "from_docs/"],
+               aliases: [s: :source],
+               switches: [source: :string]
+             ) == {[source: "from_docs/"], [], []}
+    end
+
+    test "supports --key=value aliases" do
+      assert OptionParser.parse(
+               ["-s=from_docs/", "other"],
+               aliases: [s: :source],
+               switches: [source: :string]
+             ) == {[source: "from_docs/"], ["other"], []}
+    end
+
+    test "parses -ab as -a -b" do
+      opts = [aliases: [a: :first, b: :second], switches: [second: :integer]]
+      assert OptionParser.parse(["-ab=1"], opts) == {[first: true, second: 1], [], []}
+      assert OptionParser.parse(["-ab", "1"], opts) == {[first: true, second: 1], [], []}
+
+      opts = [aliases: [a: :first, b: :second], switches: [first: :boolean, second: :boolean]]
+      assert OptionParser.parse(["-ab"], opts) == {[first: true, second: true], [], []}
+      assert OptionParser.parse(["-ab3"], opts) == {[first: true], [], [{"-b", "3"}]}
+      assert OptionParser.parse(["-ab=bar"], opts) == {[first: true], [], [{"-b", "bar"}]}
+      assert OptionParser.parse(["-ab3=bar"], opts) == {[first: true], [], [{"-b", "3=bar"}]}
+      assert OptionParser.parse(["-3ab"], opts) == {[], ["-3ab"], []}
+    end
+  end
+
+  describe "types" do
+    test "parses configured booleans" do
+      assert OptionParser.parse(["--docs=false"], switches: [docs: :boolean]) ==
+               {[docs: false], [], []}
+
+      assert OptionParser.parse(["--docs=true"], switches: [docs: :boolean]) ==
+               {[docs: true], [], []}
+
+      assert OptionParser.parse(["--docs=other"], switches: [docs: :boolean]) ==
+               {[], [], [{"--docs", "other"}]}
+
+      assert OptionParser.parse(["--docs="], switches: [docs: :boolean]) ==
+               {[], [], [{"--docs", ""}]}
+
+      assert OptionParser.parse(["--docs", "foo"], switches: [docs: :boolean]) ==
+               {[docs: true], ["foo"], []}
+
+      assert OptionParser.parse(["--no-docs", "foo"], switches: [docs: :boolean]) ==
+               {[docs: false], ["foo"], []}
+
+      assert OptionParser.parse(["--no-docs=foo", "bar"], switches: [docs: :boolean]) ==
+               {[], ["bar"], [{"--no-docs", "foo"}]}
+
+      assert OptionParser.parse(["--no-docs=", "bar"], switches: [docs: :boolean]) ==
+               {[], ["bar"], [{"--no-docs", ""}]}
+    end
 
-    args = ["--value=1", "foo", "--value=2", "bar"]
-    assert OptionParser.parse(args, switches: [value: [:integer, :keep]])
-           == {[value: 1, value: 2], ["foo", "bar"], []}
-  end
+    test "does not set unparsed booleans" do
+      assert OptionParser.parse(["foo"], switches: [docs: :boolean]) == {[], ["foo"], []}
+    end
 
-  test "parses configured floats" do
-    assert OptionParser.parse(["--value", "1.0", "foo"], switches: [value: :float])
-           == {[value: 1.0], ["foo"], []}
-    assert OptionParser.parse(["--value=1.0", "foo"], switches: [value: :float])
-           == {[value: 1.0], ["foo"], []}
-    assert OptionParser.parse(["--value", "WAT", "foo"], switches: [value: :float])
-           == {[], ["foo"], [{"--value", "WAT"}]}
-  end
+    test "keeps options on configured keep" do
+      argv = ["--require", "foo", "--require", "bar", "baz"]
 
-  test "parses no switches as flags" do
-    assert OptionParser.parse(["--no-docs", "foo"])
-           == {[no_docs: true], ["foo"], []}
-  end
+      assert OptionParser.parse(argv, switches: [require: :keep]) ==
+               {[require: "foo", require: "bar"], ["baz"], []}
 
-  test "overrides options by default" do
-    assert OptionParser.parse(["--require", "foo", "--require", "bar", "baz"])
-           == {[require: "bar"], ["baz"], []}
-  end
+      assert OptionParser.parse(["--require"], switches: [require: :keep]) ==
+               {[], [], [{"--require", nil}]}
+    end
 
-  test "parses mixed options" do
-    args = ["--source", "from_docs/", "--compile", "-x"]
-    assert OptionParser.parse(args, aliases: [x: :x])
-           == {[source: "from_docs/", compile: true, x: true], [], []}
-  end
+    test "parses configured strings" do
+      assert OptionParser.parse(["--value", "1", "foo"], switches: [value: :string]) ==
+               {[value: "1"], ["foo"], []}
 
-  test "stops on first non option arguments" do
-    args = ["--source", "from_docs/", "test/enum_test.exs", "--verbose"]
-    assert OptionParser.parse_head(args)
-           == {[source: "from_docs/"], ["test/enum_test.exs", "--verbose"], []}
-  end
+      assert OptionParser.parse(["--value=1", "foo"], switches: [value: :string]) ==
+               {[value: "1"], ["foo"], []}
 
-  test "stops on --" do
-    options = OptionParser.parse(["--source", "from_docs/", "--", "1", "2", "3"])
-    assert options == {[source: "from_docs/"], ["1", "2", "3"], []}
+      assert OptionParser.parse(["--value"], switches: [value: :string]) ==
+               {[], [], [{"--value", nil}]}
 
-    options = OptionParser.parse_head(["--source", "from_docs/", "--", "1", "2", "3"])
-    assert options == {[source: "from_docs/"], ["1", "2", "3"], []}
+      assert OptionParser.parse(["--no-value"], switches: [value: :string]) ==
+               {[no_value: true], [], []}
+    end
 
-    options = OptionParser.parse(["--no-dash", "foo", "bar", "--", "-x"])
-    assert options == {[no_dash: true], ["foo", "bar", "-x"], []}
+    test "parses configured counters" do
+      assert OptionParser.parse(["--verbose"], switches: [verbose: :count]) ==
+               {[verbose: 1], [], []}
 
-    options = OptionParser.parse_head(["--no-dash", "foo", "bar", "--", "-x"])
-    assert options == {[no_dash: true], ["foo", "bar", "--", "-x"], []}
-  end
+      assert OptionParser.parse(["--verbose", "--verbose"], switches: [verbose: :count]) ==
+               {[verbose: 2], [], []}
 
-  test "goes beyond the first non option arguments" do
-    args = ["--source", "from_docs/", "test/enum_test.exs", "--verbose"]
-    assert OptionParser.parse(args)
-           == {[source: "from_docs/", verbose: true], ["test/enum_test.exs"], []}
-  end
+      argv = ["--verbose", "-v", "-v", "--", "bar"]
+      opts = [aliases: [v: :verbose], strict: [verbose: :count]]
+      assert OptionParser.parse(argv, opts) == {[verbose: 3], ["bar"], []}
+    end
+
+    test "parses configured integers" do
+      assert OptionParser.parse(["--value", "1", "foo"], switches: [value: :integer]) ==
+               {[value: 1], ["foo"], []}
+
+      assert OptionParser.parse(["--value=1", "foo"], switches: [value: :integer]) ==
+               {[value: 1], ["foo"], []}
+
+      assert OptionParser.parse(["--value", "WAT", "foo"], switches: [value: :integer]) ==
+               {[], ["foo"], [{"--value", "WAT"}]}
+    end
+
+    test "parses configured integers with keep" do
+      argv = ["--value", "1", "--value", "2", "foo"]
+
+      assert OptionParser.parse(argv, switches: [value: [:integer, :keep]]) ==
+               {[value: 1, value: 2], ["foo"], []}
+
+      argv = ["--value=1", "foo", "--value=2", "bar"]
+
+      assert OptionParser.parse(argv, switches: [value: [:integer, :keep]]) ==
+               {[value: 1, value: 2], ["foo", "bar"], []}
+    end
+
+    test "parses configured floats" do
+      assert OptionParser.parse(["--value", "1.0", "foo"], switches: [value: :float]) ==
+               {[value: 1.0], ["foo"], []}
+
+      assert OptionParser.parse(["--value=1.0", "foo"], switches: [value: :float]) ==
+               {[value: 1.0], ["foo"], []}
+
+      assert OptionParser.parse(["--value", "WAT", "foo"], switches: [value: :float]) ==
+               {[], ["foo"], [{"--value", "WAT"}]}
+    end
+
+    test "correctly handles negative integers" do
+      opts = [switches: [option: :integer], aliases: [o: :option]]
+      assert OptionParser.parse(["arg1", "-o43"], opts) == {[option: 43], ["arg1"], []}
+      assert OptionParser.parse(["arg1", "-o", "-43"], opts) == {[option: -43], ["arg1"], []}
+      assert OptionParser.parse(["arg1", "--option=-43"], opts) == {[option: -43], ["arg1"], []}
+
+      assert OptionParser.parse(["arg1", "--option", "-43"], opts) ==
+               {[option: -43], ["arg1"], []}
+    end
+
+    test "correctly handles negative floating-point numbers" do
+      opts = [switches: [option: :float], aliases: [o: :option]]
+      assert OptionParser.parse(["arg1", "-o43.2"], opts) == {[option: 43.2], ["arg1"], []}
+      assert OptionParser.parse(["arg1", "-o", "-43.2"], opts) == {[option: -43.2], ["arg1"], []}
+
+      assert OptionParser.parse(["arg1", "--option=-43.2"], switches: [option: :float]) ==
+               {[option: -43.2], ["arg1"], []}
 
-  test "parses more than one key/value options" do
-    assert OptionParser.parse(["--source", "from_docs/", "--docs", "show"])
-           == {[source: "from_docs/", docs: "show"], [], []}
+      assert OptionParser.parse(["arg1", "--option", "-43.2"], opts) ==
+               {[option: -43.2], ["arg1"], []}
+    end
+
+    test "parses configured regexes" do
+      assert {[pattern: regex], ["foo"], []} =
+               OptionParser.parse(["--pattern", "a.*b", "foo"], switches: [pattern: :regex])
+
+      assert Regex.match?(regex, "aXXXb")
+      refute Regex.match?(regex, "xyz")
+
+      assert {[pattern: regex], ["foo"], []} =
+               OptionParser.parse(["--pattern=a.*b", "foo"], switches: [pattern: :regex])
+
+      assert Regex.match?(regex, "aXXXb")
+
+      # Test Unicode support
+      assert {[pattern: regex], ["foo"], []} =
+               OptionParser.parse(["--pattern", "café.*résumé", "foo"],
+                 switches: [pattern: :regex]
+               )
+
+      assert Regex.match?(regex, "café test résumé")
+      refute Regex.match?(regex, "ascii only")
+
+      # Test invalid regex
+      assert OptionParser.parse(["--pattern", "[invalid", "foo"], switches: [pattern: :regex]) ==
+               {[], ["foo"], [{"--pattern", "[invalid"}]}
+    end
+
+    test "parses configured regexes with keep" do
+      argv = ["--pattern", "a.*", "--pattern", "b.*", "foo"]
+
+      assert {[pattern: regex1, pattern: regex2], ["foo"], []} =
+               OptionParser.parse(argv, switches: [pattern: [:regex, :keep]])
+
+      assert Regex.match?(regex1, "aXXX")
+      assert Regex.match?(regex2, "bXXX")
+      refute Regex.match?(regex1, "bXXX")
+      refute Regex.match?(regex2, "aXXX")
+
+      argv = ["--pattern=a.*", "foo", "--pattern=b.*", "bar"]
+
+      assert {[pattern: regex1, pattern: regex2], ["foo", "bar"], []} =
+               OptionParser.parse(argv, switches: [pattern: [:regex, :keep]])
+
+      assert Regex.match?(regex1, "aXXX")
+      assert Regex.match?(regex2, "bXXX")
+    end
+
+    test "correctly handles regex compilation errors" do
+      opts = [switches: [pattern: :regex]]
+
+      # Invalid regex patterns should be treated as errors
+      assert OptionParser.parse(["--pattern", "*invalid"], opts) ==
+               {[], [], [{"--pattern", "*invalid"}]}
+
+      assert OptionParser.parse(["--pattern", "[unclosed"], opts) ==
+               {[], [], [{"--pattern", "[unclosed"}]}
+
+      assert OptionParser.parse(["--pattern", "(?invalid)"], opts) ==
+               {[], [], [{"--pattern", "(?invalid)"}]}
+    end
+
+    test "parse! raises an exception for invalid regex patterns" do
+      assert_raise OptionParser.ParseError,
+                   ~r/Invalid regular expression \"\[invalid\": missing terminating \] for character class at position \d/,
+                   fn ->
+                     OptionParser.parse!(["--pattern", "[invalid"], switches: [pattern: :regex])
+                   end
+
+      assert_raise OptionParser.ParseError,
+                   ~r/Invalid regular expression \"\(\?invalid\)\": unrecognized character after \(\? or \(\?\- at position \d/,
+                   fn ->
+                     OptionParser.parse!(["--pattern", "(?invalid)"], switches: [pattern: :regex])
+                   end
+    end
   end
 
-  test "collects multiple invalid options" do
-    args = ["--bad", "opt", "foo", "-o", "bad", "bar"]
-    assert OptionParser.parse(args, switches: [bad: :integer])
-           == {[], ["foo", "bar"], [{"--bad", "opt"}, {"-o", "bad"}]}
+  describe "next" do
+    test "with strict good options" do
+      config = [strict: [str: :string, int: :integer, bool: :boolean]]
+      assert OptionParser.next(["--str", "hello", "..."], config) == {:ok, :str, "hello", ["..."]}
+      assert OptionParser.next(["--int=13", "..."], config) == {:ok, :int, 13, ["..."]}
+      assert OptionParser.next(["--bool=false", "..."], config) == {:ok, :bool, false, ["..."]}
+      assert OptionParser.next(["--no-bool", "..."], config) == {:ok, :bool, false, ["..."]}
+      assert OptionParser.next(["--bool", "..."], config) == {:ok, :bool, true, ["..."]}
+      assert OptionParser.next(["..."], config) == {:error, ["..."]}
+    end
+
+    test "with strict unknown options" do
+      config = [strict: [bool: :boolean]]
+
+      assert OptionParser.next(["--str", "13", "..."], config) ==
+               {:undefined, "--str", nil, ["13", "..."]}
+
+      assert OptionParser.next(["--int=hello", "..."], config) ==
+               {:undefined, "--int", "hello", ["..."]}
+
+      assert OptionParser.next(["-no-bool=other", "..."], config) ==
+               {:undefined, "-no-bool", "other", ["..."]}
+    end
+
+    test "with strict bad type" do
+      config = [strict: [str: :string, int: :integer, bool: :boolean]]
+      assert OptionParser.next(["--str", "13", "..."], config) == {:ok, :str, "13", ["..."]}
+
+      assert OptionParser.next(["--int=hello", "..."], config) ==
+               {:invalid, "--int", "hello", ["..."]}
+
+      assert OptionParser.next(["--int", "hello", "..."], config) ==
+               {:invalid, "--int", "hello", ["..."]}
+
+      assert OptionParser.next(["--bool=other", "..."], config) ==
+               {:invalid, "--bool", "other", ["..."]}
+    end
+
+    test "with strict missing value" do
+      config = [strict: [str: :string, int: :integer, bool: :boolean]]
+      assert OptionParser.next(["--str"], config) == {:invalid, "--str", nil, []}
+      assert OptionParser.next(["--int"], config) == {:invalid, "--int", nil, []}
+      assert OptionParser.next(["--bool=", "..."], config) == {:invalid, "--bool", "", ["..."]}
+
+      assert OptionParser.next(["--no-bool=", "..."], config) ==
+               {:invalid, "--no-bool", "", ["..."]}
+    end
+  end
+
+  test "split" do
+    assert OptionParser.split(~S[]) == []
+    assert OptionParser.split(~S[foo]) == ["foo"]
+    assert OptionParser.split(~S[foo bar]) == ["foo", "bar"]
+    assert OptionParser.split(~S[  foo  bar  ]) == ["foo", "bar"]
+    assert OptionParser.split(~S[foo\ bar]) == ["foo bar"]
+    assert OptionParser.split(~S[foo" bar"]) == ["foo bar"]
+    assert OptionParser.split(~S[foo\" bar\"]) == ["foo\"", "bar\""]
+    assert OptionParser.split(~S[foo "\ bar\""]) == ["foo", "\\ bar\""]
+    assert OptionParser.split(~S[foo '\"bar"\'\ ']) == ["foo", "\\\"bar\"'\\ "]
+  end
+
+  describe "to_argv" do
+    test "converts options back to switches" do
+      assert OptionParser.to_argv(foo_bar: "baz") == ["--foo-bar", "baz"]
+
+      assert OptionParser.to_argv(bool: true, bool: false, discarded: nil) ==
+               ["--bool", "--no-bool"]
+    end
+
+    test "handles :count switch type" do
+      original = ["--counter", "--counter"]
+      {opts, [], []} = OptionParser.parse(original, switches: [counter: :count])
+      assert original == OptionParser.to_argv(opts, switches: [counter: :count])
+    end
   end
+end
 
-  test "parses more than one key/value options using strict" do
-    assert OptionParser.parse(["--source", "from_docs/", "--docs", "show"],
-                              strict: [source: :string, docs: :string])
-           == {[source: "from_docs/", docs: "show"], [], []}
+defmodule OptionsParserDeprecationsTest do
+  use ExUnit.Case, async: true
 
-    assert OptionParser.parse(["--source", "from_docs/", "--doc", "show"],
-                              strict: [source: :string, docs: :string])
-           == {[source: "from_docs/"], ["show"], [{"--doc", nil}]}
+  def assert_deprecated(fun) do
+    assert ExUnit.CaptureIO.capture_io(:stderr, fun) =~
+             "not passing the :switches or :strict option to OptionParser is deprecated"
+  end
 
-    assert OptionParser.parse(["--source", "from_docs/", "--doc=show"],
-                              strict: [source: :string, docs: :string])
-           == {[source: "from_docs/"], [], [{"--doc", nil}]}
+  test "parses boolean option" do
+    assert_deprecated(fn ->
+      assert OptionParser.parse(["--docs"]) == {[docs: true], [], []}
+    end)
   end
 
-  test "parses - as argument" do
-    assert OptionParser.parse(["-a", "-", "-", "-b", "-"], aliases: [b: :boo])
-           == {[boo: "-"], ["-"], [{"-a", "-"}]}
+  test "parses more than one boolean option" do
+    assert_deprecated(fn ->
+      assert OptionParser.parse(["--docs", "--compile"]) == {[docs: true, compile: true], [], []}
+    end)
+  end
 
-    assert OptionParser.parse(["--foo", "-", "-b", "-"], strict: [foo: :boolean, boo: :string], aliases: [b: :boo])
-           == {[foo: true, boo: "-"], ["-"], []}
+  test "parses more than one boolean options as the alias" do
+    assert_deprecated(fn ->
+      assert OptionParser.parse(["-d", "--compile"], aliases: [d: :docs]) ==
+               {[docs: true, compile: true], [], []}
+    end)
   end
 
-  test "multi-word option" do
-    config = [switches: [hello_world: :boolean]]
-    assert OptionParser.next(["--hello-world"], config)
-           == {:ok, :hello_world, true, []}
-    assert OptionParser.next(["--no-hello-world"], config)
-           == {:ok, :hello_world, false, []}
-
-    assert OptionParser.next(["--hello-world"], [])
-           == {:ok, :hello_world, true, []}
-    assert OptionParser.next(["--no-hello-world"], [])
-           == {:ok, :no_hello_world, true, []}
-    assert OptionParser.next(["--hello_world"], [])
-           == {:invalid, "--hello_world", nil, []}
-    assert OptionParser.next(["--no-hello_world"], [])
-           == {:invalid, "--no-hello_world", nil, []}
-
-    assert OptionParser.next(["--no-hello-world"], strict: [])
-           == {:undefined, "--no-hello-world", nil, []}
-    assert OptionParser.next(["--no-hello_world"], strict: [])
-           == {:undefined, "--no-hello_world", nil, []}
+  test "parses --key value option" do
+    assert_deprecated(fn ->
+      assert OptionParser.parse(["--source", "form_docs/"]) == {[source: "form_docs/"], [], []}
+    end)
+  end
 
-    config = [strict: [hello_world: :boolean]]
-    assert OptionParser.next(["--hello-world"], config)
-           == {:ok, :hello_world, true, []}
-    assert OptionParser.next(["--no-hello-world"], config)
-           == {:ok, :hello_world, false, []}
-    assert OptionParser.next(["--hello_world"], config)
-           == {:undefined, "--hello_world", nil, []}
-    assert OptionParser.next(["--no-hello_world"], config)
-           == {:undefined, "--no-hello_world", nil, []}
+  test "does not interpret undefined options with value as boolean" do
+    assert_deprecated(fn ->
+      assert OptionParser.parse(["--no-bool"]) == {[no_bool: true], [], []}
+    end)
+
+    assert_deprecated(fn ->
+      assert OptionParser.parse(["--no-bool=...", "other"]) == {[no_bool: "..."], ["other"], []}
+    end)
   end
 
-  test "next strict: good options" do
-    config = [strict: [str: :string, int: :integer, bool: :boolean]]
-    assert OptionParser.next(["--str", "hello", "..."], config)
-           == {:ok, :str, "hello", ["..."]}
-    assert OptionParser.next(["--int=13", "..."], config)
-           == {:ok, :int, 13, ["..."]}
-    assert OptionParser.next(["--bool=false", "..."], config)
-           == {:ok, :bool, false, ["..."]}
-    assert OptionParser.next(["--no-bool", "..."], config)
-           == {:ok, :bool, false, ["..."]}
-    assert OptionParser.next(["--bool", "..."], config)
-           == {:ok, :bool, true, ["..."]}
-    assert OptionParser.next(["..."], config)
-           == {:error, ["..."]}
+  test "parses -ab as -a -b" do
+    assert_deprecated(fn ->
+      assert OptionParser.parse(["-ab"], aliases: [a: :first, b: :second]) ==
+               {[first: true, second: true], [], []}
+    end)
   end
 
-  test "next strict: unknown options" do
-    config = [strict: [bool: :boolean]]
-    assert OptionParser.next(["--str", "13", "..."], config)
-           == {:undefined, "--str", nil, ["13", "..."]}
-    assert OptionParser.next(["--int=hello", "..."], config)
-           == {:undefined, "--int", "hello", ["..."]}
-    assert OptionParser.next(["-no-bool=other", "..."], config)
-           == {:undefined, "-no-bool", "other", ["..."]}
+  test "parses mixed options" do
+    argv = ["--source", "from_docs/", "--compile", "-x"]
+
+    assert_deprecated(fn ->
+      assert OptionParser.parse(argv, aliases: [x: :x]) ==
+               {[source: "from_docs/", compile: true, x: true], [], []}
+    end)
   end
 
-  test "next strict: bad type" do
-    config = [strict: [str: :string, int: :integer, bool: :boolean]]
-    assert OptionParser.next(["--str", "13", "..."], config)
-           == {:ok, :str, "13", ["..."]}
-    assert OptionParser.next(["--int=hello", "..."], config)
-           == {:invalid, "--int", "hello", ["..."]}
-    assert OptionParser.next(["--int", "hello", "..."], config)
-           == {:invalid, "--int", "hello", ["..."]}
-    assert OptionParser.next(["--bool=other", "..."], config)
-           == {:invalid, "--bool", "other", ["..."]}
+  test "parses more than one key-value pair options" do
+    assert_deprecated(fn ->
+      assert OptionParser.parse(["--source", "from_docs/", "--docs", "show"]) ==
+               {[source: "from_docs/", docs: "show"], [], []}
+    end)
   end
 
-  test "next strict: missing value" do
-    config = [strict: [str: :string, int: :integer, bool: :boolean]]
-    assert OptionParser.next(["--str"], config)
-           == {:invalid, "--str", nil, []}
-    assert OptionParser.next(["--int"], config)
-           == {:invalid, "--int", nil, []}
-    assert OptionParser.next(["--bool=", "..."], config)
-           == {:invalid, "--bool", "", ["..."]}
-    assert OptionParser.next(["--no-bool=", "..."], config)
-           == {:undefined, "--no-bool", "", ["..."]}
+  test "multi-word option" do
+    assert_deprecated(fn ->
+      assert OptionParser.next(["--hello-world"], []) == {:ok, :hello_world, true, []}
+    end)
+
+    assert_deprecated(fn ->
+      assert OptionParser.next(["--no-hello-world"], []) == {:ok, :no_hello_world, true, []}
+    end)
+
+    assert_deprecated(fn ->
+      assert OptionParser.next(["--hello_world"], []) == {:undefined, "--hello_world", nil, []}
+    end)
+
+    assert_deprecated(fn ->
+      assert OptionParser.next(["--no-hello_world"], []) ==
+               {:undefined, "--no-hello_world", nil, []}
+    end)
   end
 end
diff --git a/lib/elixir/test/elixir/partition_supervisor_test.exs b/lib/elixir/test/elixir/partition_supervisor_test.exs
new file mode 100644
index 00000000000..36c1d34b15a
--- /dev/null
+++ b/lib/elixir/test/elixir/partition_supervisor_test.exs
@@ -0,0 +1,276 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule PartitionSupervisorTest do
+  use ExUnit.Case, async: true
+
+  describe "child_spec" do
+    test "uses the atom name as id" do
+      assert Supervisor.child_spec({PartitionSupervisor, name: Foo}, []) == %{
+               id: Foo,
+               start: {PartitionSupervisor, :start_link, [[name: Foo]]},
+               type: :supervisor
+             }
+    end
+
+    test "uses the via value as id" do
+      via = {:via, Foo, {:bar, :baz}}
+
+      assert Supervisor.child_spec({PartitionSupervisor, name: via}, []) == %{
+               id: {:bar, :baz},
+               start: {PartitionSupervisor, :start_link, [[name: via]]},
+               type: :supervisor
+             }
+    end
+  end
+
+  describe "start_link/1" do
+    test "on success with atom name", config do
+      {:ok, _} =
+        PartitionSupervisor.start_link(
+          child_spec: DynamicSupervisor,
+          name: config.test
+        )
+
+      assert PartitionSupervisor.partitions(config.test) == System.schedulers_online()
+
+      refs =
+        for _ <- 1..100 do
+          ref = make_ref()
+
+          DynamicSupervisor.start_child(
+            {:via, PartitionSupervisor, {config.test, ref}},
+            {Agent, fn -> ref end}
+          )
+
+          ref
+        end
+
+      agents =
+        for {_, pid, _, _} <- PartitionSupervisor.which_children(config.test),
+            {_, pid, _, _} <- DynamicSupervisor.which_children(pid),
+            do: Agent.get(pid, & &1)
+
+      assert Enum.sort(refs) == Enum.sort(agents)
+    end
+
+    test "on success with via name", config do
+      {:ok, _} = Registry.start_link(keys: :unique, name: PartitionRegistry)
+
+      name = {:via, Registry, {PartitionRegistry, config.test}}
+
+      {:ok, _} = PartitionSupervisor.start_link(child_spec: {Agent, fn -> :hello end}, name: name)
+
+      assert PartitionSupervisor.partitions(name) == System.schedulers_online()
+
+      assert Agent.get({:via, PartitionSupervisor, {name, 0}}, & &1) == :hello
+    end
+
+    test "with_arguments", config do
+      {:ok, _} =
+        PartitionSupervisor.start_link(
+          child_spec: {Agent, fn -> raise "unused" end},
+          with_arguments: fn [_fun], partition -> [fn -> partition end] end,
+          partitions: 3,
+          name: config.test
+        )
+
+      assert PartitionSupervisor.partitions(config.test) == 3
+
+      assert Agent.get({:via, PartitionSupervisor, {config.test, 0}}, & &1) == 0
+      assert Agent.get({:via, PartitionSupervisor, {config.test, 1}}, & &1) == 1
+      assert Agent.get({:via, PartitionSupervisor, {config.test, 2}}, & &1) == 2
+
+      assert Agent.get({:via, PartitionSupervisor, {config.test, 3}}, & &1) == 0
+      assert Agent.get({:via, PartitionSupervisor, {config.test, -1}}, & &1) == 1
+    end
+
+    test "raises without name" do
+      assert_raise ArgumentError,
+                   "the :name option must be given to PartitionSupervisor",
+                   fn -> PartitionSupervisor.start_link(child_spec: DynamicSupervisor) end
+    end
+
+    test "raises without child_spec" do
+      assert_raise ArgumentError,
+                   "the :child_spec option must be given to PartitionSupervisor",
+                   fn -> PartitionSupervisor.start_link(name: Foo) end
+    end
+
+    test "raises on bad partitions" do
+      assert_raise ArgumentError,
+                   "the :partitions option must be a positive integer, got: 0",
+                   fn ->
+                     PartitionSupervisor.start_link(
+                       name: Foo,
+                       child_spec: DynamicSupervisor,
+                       partitions: 0
+                     )
+                   end
+    end
+
+    test "raises on bad with_arguments" do
+      assert_raise ArgumentError,
+                   ~r"the :with_arguments option must be a function that receives two arguments",
+                   fn ->
+                     PartitionSupervisor.start_link(
+                       name: Foo,
+                       child_spec: DynamicSupervisor,
+                       with_arguments: 123
+                     )
+                   end
+    end
+
+    test "raises with bad auto_shutdown" do
+      assert_raise ArgumentError,
+                   "the :auto_shutdown option must be :never, got: :any_significant",
+                   fn ->
+                     PartitionSupervisor.start_link(
+                       child_spec: DynamicSupervisor,
+                       name: Foo,
+                       auto_shutdown: :any_significant
+                     )
+                   end
+    end
+  end
+
+  describe "stop/1" do
+    test "is synchronous", config do
+      {:ok, _} =
+        PartitionSupervisor.start_link(
+          child_spec: {Agent, fn -> %{} end},
+          name: config.test
+        )
+
+      assert PartitionSupervisor.stop(config.test) == :ok
+      assert Process.whereis(config.test) == nil
+    end
+  end
+
+  describe "partitions/1" do
+    test "raises noproc for unknown atom partition supervisor" do
+      assert {:noproc, _} = catch_exit(PartitionSupervisor.partitions(:unknown))
+    end
+
+    test "raises noproc for unknown via partition supervisor", config do
+      {:ok, _} = Registry.start_link(keys: :unique, name: config.test)
+      via = {:via, Registry, {config.test, :unknown}}
+      assert {:noproc, _} = catch_exit(PartitionSupervisor.partitions(via))
+    end
+  end
+
+  describe "resize!/1" do
+    test "resizes the number of children", config do
+      {:ok, _} =
+        PartitionSupervisor.start_link(
+          child_spec: {Agent, fn -> %{} end},
+          name: config.test,
+          partitions: 8
+        )
+
+      for range <- [8..0//1, 0..8//1, Enum.shuffle(0..8)], i <- range do
+        PartitionSupervisor.resize!(config.test, i)
+        assert PartitionSupervisor.partitions(config.test) == i
+
+        assert PartitionSupervisor.count_children(config.test) ==
+                 %{active: i, specs: 8, supervisors: 0, workers: 8}
+
+        # Assert that we can still query across all range,
+        # but they are routed properly, as long as we have
+        # a single partition.
+        children =
+          for partition <- 0..7, i != 0, uniq: true do
+            GenServer.whereis({:via, PartitionSupervisor, {config.test, partition}})
+          end
+
+        assert length(children) == i
+      end
+    end
+
+    test "raises on lookup after resizing to zero", config do
+      {:ok, _} =
+        PartitionSupervisor.start_link(
+          child_spec: {Agent, fn -> %{} end},
+          name: config.test,
+          partitions: 8
+        )
+
+      assert PartitionSupervisor.resize!(config.test, 0) == 8
+
+      assert_raise ArgumentError, ~r"has zero partitions", fn ->
+        GenServer.whereis({:via, PartitionSupervisor, {config.test, 0}})
+      end
+
+      assert PartitionSupervisor.resize!(config.test, 8) == 0
+    end
+
+    test "raises if trying to increase the number of partitions", config do
+      {:ok, _} =
+        PartitionSupervisor.start_link(
+          child_spec: {Agent, fn -> %{} end},
+          name: config.test,
+          partitions: 8
+        )
+
+      assert_raise ArgumentError,
+                   "the number of partitions to resize to must be a number between 0 and 8, got: 9",
+                   fn -> PartitionSupervisor.resize!(config.test, 9) end
+    end
+  end
+
+  describe "which_children/1" do
+    test "returns all partitions", config do
+      {:ok, _} =
+        PartitionSupervisor.start_link(
+          child_spec: {Agent, fn -> %{} end},
+          name: config.test
+        )
+
+      assert PartitionSupervisor.partitions(config.test) == System.schedulers_online()
+
+      children =
+        config.test
+        |> PartitionSupervisor.which_children()
+        |> Enum.sort()
+
+      for {child, partition} <- Enum.zip(children, 0..(System.schedulers_online() - 1)) do
+        via = {:via, PartitionSupervisor, {config.test, partition}}
+        assert child == {partition, GenServer.whereis(via), :worker, [Agent]}
+      end
+    end
+  end
+
+  describe "count_children/1" do
+    test "with workers", config do
+      {:ok, _} =
+        PartitionSupervisor.start_link(
+          child_spec: {Agent, fn -> %{} end},
+          name: config.test
+        )
+
+      partitions = System.schedulers_online()
+
+      assert PartitionSupervisor.count_children(config.test) ==
+               %{active: partitions, specs: partitions, supervisors: 0, workers: partitions}
+    end
+
+    test "with supervisors", config do
+      {:ok, _} =
+        PartitionSupervisor.start_link(
+          child_spec: DynamicSupervisor,
+          name: config.test
+        )
+
+      partitions = System.schedulers_online()
+
+      assert PartitionSupervisor.count_children(config.test) ==
+               %{active: partitions, specs: partitions, supervisors: partitions, workers: 0}
+    end
+
+    test "raises noproc for unknown partition supervisor" do
+      assert {:noproc, _} = catch_exit(PartitionSupervisor.count_children(:unknown))
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/path_test.exs b/lib/elixir/test/elixir/path_test.exs
index 4fa577c9fa8..a95aaea74fd 100644
--- a/lib/elixir/test/elixir/path_test.exs
+++ b/lib/elixir/test/elixir/path_test.exs
@@ -1,91 +1,257 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule PathTest do
   use ExUnit.Case, async: true
-  import PathHelpers
+  doctest Path
+
+  if :file.native_name_encoding() == :utf8 do
+    @tag :tmp_dir
+    test "wildcard with UTF-8", config do
+      File.mkdir_p(Path.join(config.tmp_dir, "héllò"))
 
-  if :file.native_name_encoding == :utf8 do
-    test :wildcard_with_utf8 do
-      File.mkdir_p(tmp_path("héllò"))
-      assert Path.wildcard(tmp_path("héllò")) == [tmp_path("héllò")]
+      assert Path.wildcard(Path.join(config.tmp_dir, "héllò")) ==
+               [Path.join(config.tmp_dir, "héllò")]
     after
-      File.rm_rf tmp_path("héllò")
+      File.rm_rf(Path.join(config.tmp_dir, "héllò"))
     end
   end
 
-  test :wildcard do
-    hello = tmp_path("wildcard/.hello")
-    world = tmp_path("wildcard/.hello/world")
+  @tag :tmp_dir
+  test "wildcard/2", config do
+    hello = Path.join(config.tmp_dir, "wildcard/.hello")
+    world = Path.join(config.tmp_dir, "wildcard/.hello/world")
     File.mkdir_p(world)
 
-    assert Path.wildcard(tmp_path("wildcard/*/*")) == []
-    assert Path.wildcard(tmp_path("wildcard/**/*")) == []
-    assert Path.wildcard(tmp_path("wildcard/?hello/world")) == []
+    assert Path.wildcard(Path.join(config.tmp_dir, "wildcard/*/*")) == []
+    assert Path.wildcard(Path.join(config.tmp_dir, "wildcard/**/*")) == []
+    assert Path.wildcard(Path.join(config.tmp_dir, "wildcard/?hello/world")) == []
+
+    assert Path.wildcard(Path.join(config.tmp_dir, "wildcard/*/*"), match_dot: true) ==
+             [world]
+
+    assert Path.wildcard(Path.join(config.tmp_dir, "wildcard/**/*"), match_dot: true) ==
+             [hello, world]
+
+    assert Path.wildcard(Path.join(config.tmp_dir, "wildcard/?hello/world"), match_dot: true) ==
+             [world]
+  after
+    File.rm_rf(Path.join(config.tmp_dir, "wildcard"))
+  end
+
+  @tag :tmp_dir
+  test "wildcard/2 follows ..", config do
+    hello = Path.join(config.tmp_dir, "wildcard/hello")
+    world = Path.join(config.tmp_dir, "wildcard/world")
+    File.mkdir_p(hello)
+    File.touch(world)
+
+    assert Path.wildcard(Path.join(config.tmp_dir, "wildcard/w*/../h*")) == []
 
-    assert Path.wildcard(tmp_path("wildcard/*/*"), match_dot: true) == [world]
-    assert Path.wildcard(tmp_path("wildcard/**/*"), match_dot: true) == [hello, world]
-    assert Path.wildcard(tmp_path("wildcard/?hello/world"), match_dot: true) == [world]
+    assert Path.wildcard(Path.join(config.tmp_dir, "wildcard/h*/../w*")) ==
+             [Path.join(config.tmp_dir, "wildcard/hello/../world")]
   after
-    File.rm_rf tmp_path("wildcard")
+    File.rm_rf(Path.join(config.tmp_dir, "wildcard"))
   end
 
-  if is_win? do
-    test :relative do
-      assert Path.relative("C:/usr/local/bin")    == "usr/local/bin"
+  test "wildcard/2 raises on null byte" do
+    assert_raise ArgumentError, ~r/null byte/, fn -> Path.wildcard("foo\0bar") end
+  end
+
+  describe "Windows" do
+    @describetag :windows
+
+    test "absname/1" do
+      assert Path.absname("//host/path") == "//host/path"
+      assert Path.absname("\\\\host\\path") == "//host/path"
+      assert Path.absname("\\/host\\path") == "//host/path"
+      assert Path.absname("/\\host\\path") == "//host/path"
+
+      assert Path.absname("c:/") == "c:/"
+      assert Path.absname("c:/host/path") == "c:/host/path"
+
+      cwd = File.cwd!()
+      assert Path.absname(cwd |> String.split("/") |> hd()) == cwd
+
+      <<letter, _::binary>> = cwd
+      random = Enum.random(Enum.to_list(?c..?z) -- [letter])
+      assert Path.absname(<<random, ?:>>) == <<random, ?:, ?/>>
+    end
+
+    test "relative/1" do
+      assert Path.relative("C:/usr/local/bin") == "usr/local/bin"
       assert Path.relative("C:\\usr\\local\\bin") == "usr\\local\\bin"
-      assert Path.relative("C:usr\\local\\bin")   == "usr\\local\\bin"
+      assert Path.relative("C:usr\\local\\bin") == "usr\\local\\bin"
 
-      assert Path.relative("/usr/local/bin")   == "usr/local/bin"
-      assert Path.relative("usr/local/bin")    == "usr/local/bin"
+      assert Path.relative("/usr/local/bin") == "usr/local/bin"
+      assert Path.relative("usr/local/bin") == "usr/local/bin"
       assert Path.relative("../usr/local/bin") == "../usr/local/bin"
     end
 
-    test :type do
-      assert Path.type("C:/usr/local/bin")    == :absolute
-      assert Path.type('C:\\usr\\local\\bin') == :absolute
-      assert Path.type("C:usr\\local\\bin")   == :volumerelative
+    test "relative_to/3" do
+      # should give same relative paths for both force true and false
+      for force <- [true, false] do
+        assert Path.relative_to("//usr/local/foo", "//usr/", force: force) == "local/foo"
+
+        assert Path.relative_to("D:/usr/local/foo", "D:/usr/", force: force) == "local/foo"
+        assert Path.relative_to("D:/usr/local/foo", "d:/usr/", force: force) == "local/foo"
+        assert Path.relative_to("d:/usr/local/foo", "D:/usr/", force: force) == "local/foo"
+        assert Path.relative_to("D:/usr/local/foo", "d:/", force: force) == "usr/local/foo"
+        assert Path.relative_to("D:/usr/local/foo", "D:/", force: force) == "usr/local/foo"
+
+        assert Path.relative_to("d:/usr/local/foo/..", "d:/usr/local", force: force) == "."
+        assert Path.relative_to("d:/usr/local/../foo", "d:/usr/foo", force: force) == "."
+        assert Path.relative_to("d:/usr/local/../foo/bar", "d:/usr/foo", force: force) == "bar"
+        assert Path.relative_to("d:/usr/local/../foo/./bar", "d:/usr/foo", force: force) == "bar"
+
+        assert Path.relative_to("d:/usr/local/../foo/bar/..", "d:/usr/foo", force: force) == "."
+        assert Path.relative_to("d:/usr/local/foo/..", "d:/usr/local/..", force: force) == "local"
+        assert Path.relative_to("d:/usr/local/foo/..", "d:/usr/local/.", force: force) == "."
+      end
+
+      # different results for force: true
+      assert Path.relative_to("d:/usr/local/../foo", "d:/usr/local") == "d:/usr/foo"
+      assert Path.relative_to("d:/usr/local/../foo", "d:/usr/local", force: true) == "../foo"
+
+      assert Path.relative_to("d:/usr/local/../foo/../bar", "d:/usr/foo") == "d:/usr/bar"
+      assert Path.relative_to("d:/usr/local/../foo/../bar", "d:/usr/foo", force: true) == "../bar"
+
+      # on different volumes with force: true it should return the original path
+      assert Path.relative_to("d:/usr/local", "c:/usr/local", force: true) == "d:/usr/local"
+      assert Path.relative_to("d:/usr/local", "c:/another/local", force: true) == "d:/usr/local"
+    end
+
+    test "type/1" do
+      assert Path.type("C:/usr/local/bin") == :absolute
+      assert Path.type(~c"C:\\usr\\local\\bin") == :absolute
+      assert Path.type("C:usr\\local\\bin") == :volumerelative
 
-      assert Path.type("/usr/local/bin")   == :volumerelative
-      assert Path.type('usr/local/bin')    == :relative
+      assert Path.type("/usr/local/bin") == :volumerelative
+      assert Path.type(~c"usr/local/bin") == :relative
       assert Path.type("../usr/local/bin") == :relative
+
+      assert Path.type("//host/path") == :absolute
+      assert Path.type("\\\\host\\path") == :absolute
+      assert Path.type("/\\host\\path") == :absolute
+      assert Path.type("\\/host\\path") == :absolute
     end
-  else
-    test :relative do
-      assert Path.relative("/usr/local/bin")   == "usr/local/bin"
-      assert Path.relative("usr/local/bin")    == "usr/local/bin"
+
+    test "split/1" do
+      assert Path.split("C:\\foo\\bar") == ["c:/", "foo", "bar"]
+      assert Path.split("C:/foo/bar") == ["c:/", "foo", "bar"]
+    end
+
+    test "safe_relative/1" do
+      assert Path.safe_relative("local/foo") == {:ok, "local/foo"}
+      assert Path.safe_relative("D:/usr/local/foo") == :error
+      assert Path.safe_relative("d:/usr/local/foo") == :error
+      assert Path.safe_relative("foo/../..") == :error
+    end
+
+    test "safe_relative/2" do
+      assert Path.safe_relative("local/foo/bar", "local") == {:ok, "local/foo/bar"}
+      assert Path.safe_relative("foo/..", "local") == {:ok, ""}
+      assert Path.safe_relative("..", "local/foo") == :error
+      assert Path.safe_relative("d:/usr/local/foo", "D:/") == :error
+      assert Path.safe_relative("D:/usr/local/foo", "d:/") == :error
+    end
+  end
+
+  describe "Unix" do
+    @describetag :unix
+
+    test "relative/1" do
+      assert Path.relative("/usr/local/bin") == "usr/local/bin"
+      assert Path.relative("usr/local/bin") == "usr/local/bin"
       assert Path.relative("../usr/local/bin") == "../usr/local/bin"
-      assert Path.relative(['/usr', ?/, "local/bin"]) == "usr/local/bin"
+      assert Path.relative("/") == "."
+      assert Path.relative(~c"/") == "."
+      assert Path.relative([~c"/usr", ?/, "local/bin"]) == "usr/local/bin"
     end
 
-    test :type do
-      assert Path.type("/usr/local/bin")   == :absolute
-      assert Path.type("usr/local/bin")    == :relative
+    test "relative_to/3" do
+      # subpaths of cwd, should give the same result for both force true and false
+      for force <- [false, true] do
+        assert Path.relative_to("/usr/local/foo", "/usr/local", force: force) == "foo"
+        assert Path.relative_to("/usr/local/foo", "/", force: force) == "usr/local/foo"
+        assert Path.relative_to("/usr/local/foo", "/usr/local/foo", force: force) == "."
+        assert Path.relative_to("/usr/local/foo/", "/usr/local/foo", force: force) == "."
+        assert Path.relative_to("/usr/local/foo", "/usr/local/foo/", force: force) == "."
+
+        assert Path.relative_to("/usr/local/foo/..", "/usr/local", force: force) == "."
+        assert Path.relative_to("/usr/local/../foo", "/usr/foo", force: force) == "."
+        assert Path.relative_to("/usr/local/../foo/bar", "/usr/foo", force: force) == "bar"
+        assert Path.relative_to("/usr/local/../foo/./bar", "/usr/foo", force: force) == "bar"
+        assert Path.relative_to("/usr/local/../foo/bar/..", "/usr/foo", force: force) == "."
+
+        assert Path.relative_to("/usr/local/foo/..", "/usr/local/..", force: force) == "local"
+        assert Path.relative_to("/usr/local/foo/..", "/usr/local/.", force: force) == "."
+      end
+
+      # With relative second argument
+      assert Path.relative_to("/usr/local/foo", "etc") == "/usr/local/foo"
+      assert Path.relative_to("/usr/local/foo", "etc", force: true) == "/usr/local/foo"
+
+      # Different relative paths for force true/false
+      assert Path.relative_to("/usr/local/foo", "/etc") == "/usr/local/foo"
+      assert Path.relative_to("/usr/local/foo", "/etc", force: true) == "../usr/local/foo"
+
+      assert Path.relative_to("/usr/local/../foo", "/usr/local") == "/usr/foo"
+      assert Path.relative_to("/usr/local/../foo", "/usr/local", force: true) == "../foo"
+
+      assert Path.relative_to("/usr/local/../foo/../bar", "/usr/foo") == "/usr/bar"
+      assert Path.relative_to("/usr/local/../foo/../bar", "/usr/foo", force: true) == "../bar"
+
+      # More tests with force: true
+      assert Path.relative_to("/etc", "/usr/local/foo", force: true) == "../../../etc"
+      assert Path.relative_to(~c"/usr/local/foo", "/etc", force: true) == "../usr/local/foo"
+      assert Path.relative_to("/usr/local", "/usr/local/foo", force: true) == ".."
+      assert Path.relative_to("/usr/local/..", "/usr/local", force: true) == ".."
+
+      assert Path.relative_to("/usr/../etc/foo/../../bar", "/log/foo/../../usr/", force: true) ==
+               "../bar"
+    end
+
+    test "type/1" do
+      assert Path.type("/usr/local/bin") == :absolute
+      assert Path.type("usr/local/bin") == :relative
       assert Path.type("../usr/local/bin") == :relative
 
-      assert Path.type('/usr/local/bin')   == :absolute
-      assert Path.type('usr/local/bin')    == :relative
-      assert Path.type('../usr/local/bin') == :relative
+      assert Path.type(~c"/usr/local/bin") == :absolute
+      assert Path.type(~c"usr/local/bin") == :relative
+      assert Path.type(~c"../usr/local/bin") == :relative
 
-      assert Path.type(['/usr/', 'local/bin'])   == :absolute
-      assert Path.type(['usr/', 'local/bin'])    == :relative
-      assert Path.type(['../usr', '/local/bin']) == :relative
+      assert Path.type([~c"/usr/", ~c"local/bin"]) == :absolute
+      assert Path.type([~c"usr/", ~c"local/bin"]) == :relative
+      assert Path.type([~c"../usr", ~c"/local/bin"]) == :relative
     end
   end
 
-  test :relative_to_cwd do
-    assert Path.relative_to_cwd(__ENV__.file) ==
-           Path.relative_to(__ENV__.file, System.cwd!)
+  test "relative_to_cwd/2" do
+    assert Path.relative_to_cwd(__ENV__.file) == Path.relative_to(__ENV__.file, File.cwd!())
+
+    assert Path.relative_to_cwd(to_charlist(__ENV__.file)) ==
+             Path.relative_to(to_charlist(__ENV__.file), to_charlist(File.cwd!()))
 
-    assert Path.relative_to_cwd(to_char_list(__ENV__.file)) ==
-           Path.relative_to(to_char_list(__ENV__.file), to_char_list(System.cwd!))
+    assert Path.relative_to_cwd(Path.dirname(File.cwd!()), force: true) == ".."
+
+    [slash | split_cwd] = Path.split(File.cwd!())
+    relative_to_root = List.duplicate("..", length(split_cwd))
+
+    assert Path.relative_to_cwd(slash) == slash
+    assert Path.relative_to_cwd(slash, force: true) == Path.join(relative_to_root)
   end
 
-  test :absname do
-    assert (Path.absname("/") |> strip_drive_letter_if_windows) == "/"
-    assert (Path.absname("/foo") |> strip_drive_letter_if_windows) == "/foo"
-    assert (Path.absname("/foo/bar") |> strip_drive_letter_if_windows) == "/foo/bar"
-    assert (Path.absname("/foo/bar/") |> strip_drive_letter_if_windows)  == "/foo/bar"
-    assert (Path.absname("/foo/bar/../bar")  |> strip_drive_letter_if_windows) == "/foo/bar/../bar"
+  test "absname/1,2" do
+    assert Path.absname("/") |> strip_drive_letter_if_windows() == "/"
+    assert Path.absname("/foo") |> strip_drive_letter_if_windows() == "/foo"
+    assert Path.absname("/./foo") |> strip_drive_letter_if_windows() == "/foo"
+    assert Path.absname("/foo/bar") |> strip_drive_letter_if_windows() == "/foo/bar"
+    assert Path.absname("/foo/bar/") |> strip_drive_letter_if_windows() == "/foo/bar"
+    assert Path.absname("/foo/bar/../bar") |> strip_drive_letter_if_windows() == "/foo/bar/../bar"
 
     assert Path.absname("bar", "/foo") == "/foo/bar"
     assert Path.absname("bar/", "/foo") == "/foo/bar"
@@ -95,82 +261,116 @@ defmodule PathTest do
     assert Path.absname(["bar/", ?., ?., ["/bar"]], "/foo") == "/foo/bar/../bar"
   end
 
-  test :expand_path_with_user_home do
-    home = System.user_home!
+  test "expand/1,2 with user home" do
+    home = System.user_home!() |> Path.absname()
 
     assert home == Path.expand("~")
-    assert home == Path.expand('~')
-    assert is_binary Path.expand("~/foo")
-    assert is_binary Path.expand('~/foo')
+    assert home == Path.expand(~c"~")
+    assert is_binary(Path.expand("~/foo"))
+    assert is_binary(Path.expand(~c"~/foo"))
 
     assert Path.expand("~/file") == Path.join(home, "file")
     assert Path.expand("~/file", "whatever") == Path.join(home, "file")
-    assert Path.expand("file", Path.expand("~")) == Path.expand("~/file")
+    assert Path.expand("file", Path.expand("~")) == Path.join(home, "file")
     assert Path.expand("file", "~") == Path.join(home, "file")
+    assert Path.expand("~file") == Path.join(File.cwd!(), "~file")
   end
 
-  test :expand_path do
-    assert (Path.expand("/") |> strip_drive_letter_if_windows) == "/"
-    assert (Path.expand("/foo") |> strip_drive_letter_if_windows) == "/foo"
-    assert (Path.expand("/foo/bar") |> strip_drive_letter_if_windows) == "/foo/bar"
-    assert (Path.expand("/foo/bar/") |> strip_drive_letter_if_windows) == "/foo/bar"
-    assert (Path.expand("/foo/bar/.") |> strip_drive_letter_if_windows)== "/foo/bar"
-    assert (Path.expand("/foo/bar/../bar") |> strip_drive_letter_if_windows) == "/foo/bar"
+  test "expand/1,2" do
+    assert Path.expand("/") |> strip_drive_letter_if_windows() == "/"
+    assert Path.expand("/foo/../..") |> strip_drive_letter_if_windows() == "/"
+    assert Path.expand("/foo") |> strip_drive_letter_if_windows() == "/foo"
+    assert Path.expand("/./foo") |> strip_drive_letter_if_windows() == "/foo"
+    assert Path.expand("/../foo") |> strip_drive_letter_if_windows() == "/foo"
+    assert Path.expand("/foo/bar") |> strip_drive_letter_if_windows() == "/foo/bar"
+    assert Path.expand("/foo/bar/") |> strip_drive_letter_if_windows() == "/foo/bar"
+    assert Path.expand("/foo/bar/.") |> strip_drive_letter_if_windows() == "/foo/bar"
+    assert Path.expand("/foo/bar/../bar") |> strip_drive_letter_if_windows() == "/foo/bar"
+
+    assert Path.expand("bar", "/foo") |> strip_drive_letter_if_windows() == "/foo/bar"
+    assert Path.expand("bar/", "/foo") |> strip_drive_letter_if_windows() == "/foo/bar"
+    assert Path.expand("bar/.", "/foo") |> strip_drive_letter_if_windows() == "/foo/bar"
+    assert Path.expand("bar/../bar", "/foo") |> strip_drive_letter_if_windows() == "/foo/bar"
 
-    assert (Path.expand("bar", "/foo") |> strip_drive_letter_if_windows)== "/foo/bar"
-    assert (Path.expand("bar/", "/foo") |> strip_drive_letter_if_windows)== "/foo/bar"
-    assert (Path.expand("bar/.", "/foo") |> strip_drive_letter_if_windows)== "/foo/bar"
-    assert (Path.expand("bar/../bar", "/foo") |> strip_drive_letter_if_windows)== "/foo/bar"
-    assert (Path.expand("../bar/../bar", "/foo/../foo/../foo") |> strip_drive_letter_if_windows) == "/bar"
+    drive_letter =
+      Path.expand("../bar/../bar", "/foo/../foo/../foo") |> strip_drive_letter_if_windows()
 
-    assert (Path.expand(['..', ?/, "bar/../bar"], '/foo/../foo/../foo') |>
-            strip_drive_letter_if_windows) == "/bar"
+    assert drive_letter == "/bar"
+
+    drive_letter =
+      Path.expand([~c"..", ?/, "bar/../bar"], ~c"/foo/../foo/../foo")
+      |> strip_drive_letter_if_windows()
+
+    assert "/bar" == drive_letter
+
+    assert Path.expand("/..") |> strip_drive_letter_if_windows() == "/"
 
     assert Path.expand("bar/../bar", "foo") == Path.expand("foo/bar")
+  end
 
-    assert (Path.expand("/..") |> strip_drive_letter_if_windows) == "/"
+  test "relative_to/3 (with relative paths)" do
+    # on cwd
+    assert Path.relative_to("foo", File.cwd!()) == "foo"
+    assert Path.relative_to("./foo", File.cwd!()) == "foo"
+    assert Path.relative_to("./foo/.", File.cwd!()) == "foo"
+    assert Path.relative_to("./foo/./bar/.", File.cwd!()) == "foo/bar"
+    assert Path.relative_to("../foo/./bar/.", File.cwd!()) == "../foo/bar"
+    assert Path.relative_to("../foo/./bar/..", File.cwd!()) == "../foo"
+    assert Path.relative_to("../foo/../bar/..", File.cwd!()) == ".."
+    assert Path.relative_to("./foo/../bar/..", File.cwd!()) == "."
+
+    # both relative
+    assert Path.relative_to("usr/local/foo", ".") == "usr/local/foo"
+    assert Path.relative_to(".", "usr/local/foo") == "."
+    assert Path.relative_to("usr/local/foo", "usr/local") == "foo"
+    assert Path.relative_to("usr/local/foo", "etc") == "../usr/local/foo"
+    assert Path.relative_to(~c"usr/local/foo", "etc") == "../usr/local/foo"
+    assert Path.relative_to("usr/local/foo", "usr/local") == "foo"
+    assert Path.relative_to(["usr", ?/, ~c"local/foo"], ~c"usr/local") == "foo"
   end
 
-  test :relative_to do
-    assert Path.relative_to("/usr/local/foo", "/usr/local") == "foo"
-    assert Path.relative_to("/usr/local/foo", "/") == "usr/local/foo"
-    assert Path.relative_to("/usr/local/foo", "/etc") == "/usr/local/foo"
-    assert Path.relative_to("/usr/local/foo", "/usr/local/foo") == "/usr/local/foo"
+  test "safe_relative/1" do
+    assert Path.safe_relative("foo/bar") == {:ok, "foo/bar"}
+    assert Path.safe_relative("foo/..") == {:ok, ""}
+    assert Path.safe_relative("./foo") == {:ok, "foo"}
 
-    assert Path.relative_to("usr/local/foo", "usr/local") == "foo"
-    assert Path.relative_to("usr/local/foo", "etc") == "usr/local/foo"
-    assert Path.relative_to('usr/local/foo', "etc") == "usr/local/foo"
+    assert Path.safe_relative("/usr/local/foo") == :error
+    assert Path.safe_relative("foo/../..") == :error
+  end
 
-    assert Path.relative_to("usr/local/foo", "usr/local") == "foo"
-    assert Path.relative_to(["usr", ?/, 'local/foo'], 'usr/local') == "foo"
+  test "safe_relative/2" do
+    assert Path.safe_relative("/usr/local/foo", "/usr/local") == :error
+    assert Path.safe_relative("../../..", "foo/bar") == :error
+    assert Path.safe_relative("../../..", "foo/bar") == :error
+    assert Path.safe_relative("/usr/local/foo", "/") == :error
   end
 
-  test :rootname do
+  test "rootname/2" do
     assert Path.rootname("~/foo/bar.ex", ".ex") == "~/foo/bar"
     assert Path.rootname("~/foo/bar.exs", ".ex") == "~/foo/bar.exs"
     assert Path.rootname("~/foo/bar.old.ex", ".ex") == "~/foo/bar.old"
-    assert Path.rootname([?~, '/foo/bar', ".old.ex"], '.ex') == "~/foo/bar.old"
+    assert Path.rootname([?~, ~c"/foo/bar", ".old.ex"], ~c".ex") == "~/foo/bar.old"
   end
 
-  test :extname do
+  test "extname/1" do
     assert Path.extname("foo.erl") == ".erl"
     assert Path.extname("~/foo/bar") == ""
 
-    assert Path.extname('foo.erl') == ".erl"
-    assert Path.extname('~/foo/bar') == ""
+    assert Path.extname(~c"foo.erl") == ".erl"
+    assert Path.extname(~c"~/foo/bar") == ""
   end
 
-  test :dirname do
+  test "dirname/1" do
     assert Path.dirname("/foo/bar.ex") == "/foo"
     assert Path.dirname("foo/bar.ex") == "foo"
 
     assert Path.dirname("~/foo/bar.ex") == "~/foo"
     assert Path.dirname("/foo/bar/baz/") == "/foo/bar/baz"
 
-    assert Path.dirname([?~, "/foo", '/bar.ex']) == "~/foo"
+    assert Path.dirname([?~, "/foo", ~c"/bar.ex"]) == "~/foo"
   end
 
-  test :basename do
+  test "basename/1,2" do
     assert Path.basename("foo") == "foo"
     assert Path.basename("/foo/bar") == "bar"
     assert Path.basename("/") == ""
@@ -179,38 +379,53 @@ defmodule PathTest do
     assert Path.basename("~/foo/bar.exs", ".ex") == "bar.exs"
     assert Path.basename("~/for/bar.old.ex", ".ex") == "bar.old"
 
-    assert Path.basename([?~, "/for/bar", '.old.ex'], ".ex") == "bar.old"
+    assert Path.basename([?~, "/for/bar", ~c".old.ex"], ".ex") == "bar.old"
   end
 
-  test :join do
+  test "join/1" do
     assert Path.join([""]) == ""
     assert Path.join(["foo"]) == "foo"
     assert Path.join(["/", "foo", "bar"]) == "/foo/bar"
+    assert Path.join(["/", "foo", "bar", "/"]) == "/foo/bar"
     assert Path.join(["~", "foo", "bar"]) == "~/foo/bar"
-    assert Path.join(['/foo/', "/bar/"]) == "/foo/bar"
+    assert Path.join([~c"/foo/", "/bar/"]) == "/foo/bar"
+    assert Path.join(["/", ""]) == "/"
+    assert Path.join(["/", "", "bar"]) == "/bar"
+    assert Path.join([~c"foo", [?b, "a", ?r]]) == "foo/bar"
+    assert Path.join([[?f, ~c"o", "o"]]) == "foo"
   end
 
-  test :join_two do
+  test "join/2" do
     assert Path.join("/foo", "bar") == "/foo/bar"
     assert Path.join("~", "foo") == "~/foo"
 
-    assert Path.join("", "bar") == "/bar"
+    assert Path.join("", "bar") == "bar"
+    assert Path.join("bar", "") == "bar"
+    assert Path.join("", "/bar") == "bar"
+    assert Path.join("/bar", "") == "/bar"
+
+    assert Path.join("foo", "/bar") == "foo/bar"
+    assert Path.join("/foo", "/bar") == "/foo/bar"
     assert Path.join("/foo", "/bar") == "/foo/bar"
-    assert Path.join("/foo", "./bar") == "/foo/bar"
+    assert Path.join("/foo", "./bar") == "/foo/./bar"
+
+    assert Path.join("/foo", "/") == "/foo"
+    assert Path.join("/foo", "/bar/zar/") == "/foo/bar/zar"
 
-    assert Path.join([?/, "foo"], "./bar") == "/foo/bar"
+    assert Path.join([?/, "foo"], "./bar") == "/foo/./bar"
+    assert Path.join(["/foo", "bar"], ["fiz", "buz"]) == "/foobar/fizbuz"
   end
 
-  test :split_with_binary do
+  test "split/1" do
     assert Path.split("") == []
     assert Path.split("foo") == ["foo"]
     assert Path.split("/foo/bar") == ["/", "foo", "bar"]
     assert Path.split([?/, "foo/bar"]) == ["/", "foo", "bar"]
   end
 
-  if is_win? do
-    defp strip_drive_letter_if_windows([_d,?:|rest]), do: rest
-    defp strip_drive_letter_if_windows(<<_d,?:,rest::binary>>), do: rest
+  if PathHelpers.windows?() do
+    defp strip_drive_letter_if_windows([_d, ?: | rest]), do: rest
+    defp strip_drive_letter_if_windows(<<_d, ?:, rest::binary>>), do: rest
   else
     defp strip_drive_letter_if_windows(path), do: path
   end
diff --git a/lib/elixir/test/elixir/port_test.exs b/lib/elixir/test/elixir/port_test.exs
new file mode 100644
index 00000000000..dcefc4dc6bf
--- /dev/null
+++ b/lib/elixir/test/elixir/port_test.exs
@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule PortTest do
+  use ExUnit.Case, async: true
+
+  test "info/1,2 with registered name" do
+    {:ok, port} = :gen_udp.open(0)
+
+    assert Port.info(port, :links) == {:links, [self()]}
+    assert Port.info(port, :registered_name) == {:registered_name, []}
+
+    Process.register(port, __MODULE__)
+
+    assert Port.info(port, :registered_name) == {:registered_name, __MODULE__}
+
+    :ok = :gen_udp.close(port)
+
+    assert Port.info(port, :registered_name) == nil
+    assert Port.info(port) == nil
+  end
+
+  # In contrast with other inlined functions,
+  # it is important to test that monitor/1 is inlined,
+  # this way we gain the monitor receive optimisation.
+  test "monitor/1 is inlined" do
+    assert expand(quote(do: Port.monitor(port())), __ENV__) ==
+             quote(do: :erlang.monitor(:port, port()))
+  end
+
+  defp expand(expr, env) do
+    {expr, _, _} = :elixir_expand.expand(expr, :elixir_env.env_to_ex(env), env)
+    expr
+  end
+end
diff --git a/lib/elixir/test/elixir/process_test.exs b/lib/elixir/test/elixir/process_test.exs
index be5b984f2f2..dcca57ddfc9 100644
--- a/lib/elixir/test/elixir/process_test.exs
+++ b/lib/elixir/test/elixir/process_test.exs
@@ -1,41 +1,201 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule ProcessTest do
   use ExUnit.Case, async: true
 
+  doctest Process
+
+  test "dictionary" do
+    assert Process.put(:foo, :bar) == nil
+    assert Process.put(:foo, :baz) == :bar
+
+    assert Enum.member?(Process.get_keys(), :foo)
+    refute Enum.member?(Process.get_keys(), :bar)
+    refute Enum.member?(Process.get_keys(), :baz)
+    assert Process.get_keys(:bar) == []
+    assert Process.get_keys(:baz) == [:foo]
+
+    assert Process.get(:foo) == :baz
+    assert Process.delete(:foo) == :baz
+    assert Process.get(:foo) == nil
+  end
+
   test "group_leader/2 and group_leader/0" do
-    another = spawn_link(fn -> :timer.sleep(1000) end)
-    assert Process.group_leader(self, another)
-    assert Process.group_leader == another
+    another = spawn_link(fn -> Process.sleep(1000) end)
+    assert Process.group_leader(self(), another)
+    assert Process.group_leader() == another
   end
 
-  test "monitoring functions are inlined by the compiler" do
+  # In contrast with other inlined functions,
+  # it is important to test that monitor/1,2 are inlined,
+  # this way we gain the monitor receive optimisation.
+  test "monitor/1 and monitor/2 are inlined" do
     assert expand(quote(do: Process.monitor(pid())), __ENV__) ==
-           quote(do: :erlang.monitor(:process, pid()))
+             quote(do: :erlang.monitor(:process, pid()))
+
+    assert expand(quote(do: Process.monitor(pid(), alias: :demonitor)), __ENV__) ==
+             quote(do: :erlang.monitor(:process, pid(), alias: :demonitor))
+  end
+
+  test "monitor/2 with monitor options" do
+    pid =
+      spawn(fn ->
+        receive do
+          {:ping, source_alias} -> send(source_alias, :pong)
+        end
+      end)
+
+    ref_and_alias = Process.monitor(pid, alias: :explicit_unalias)
+
+    send(pid, {:ping, ref_and_alias})
+
+    assert_receive :pong
+    assert_receive {:DOWN, ^ref_and_alias, _, _, _}
+  end
+
+  test "sleep/1" do
+    assert Process.sleep(0) == :ok
+  end
+
+  test "sleep/1 with 2^32" do
+    {pid, monitor_ref} = spawn_monitor(fn -> Process.sleep(2 ** 32) end)
+    refute_receive {:DOWN, ^monitor_ref, :process, ^pid, {:timeout_value, _trace}}, 100
+    Process.exit(pid, :kill)
   end
 
   test "info/2" do
-    pid = spawn fn -> end
+    pid = spawn(fn -> Process.sleep(1000) end)
+    assert Process.info(pid, :priority) == {:priority, :normal}
+    assert Process.info(pid, [:priority]) == [priority: :normal]
+
     Process.exit(pid, :kill)
     assert Process.info(pid, :backtrace) == nil
+    assert Process.info(pid, [:backtrace, :status]) == nil
   end
 
   test "info/2 with registered name" do
-    pid = spawn fn -> end
+    pid = spawn(fn -> nil end)
     Process.exit(pid, :kill)
-    assert Process.info(pid, :registered_name) ==
-           nil
+    assert Process.info(pid, :registered_name) == nil
+    assert Process.info(pid, [:registered_name]) == nil
+
+    assert Process.info(self(), :registered_name) == {:registered_name, []}
+    assert Process.info(self(), [:registered_name]) == [registered_name: []]
+
+    Process.register(self(), __MODULE__)
+    assert Process.info(self(), :registered_name) == {:registered_name, __MODULE__}
+    assert Process.info(self(), [:registered_name]) == [registered_name: __MODULE__]
+  end
+
+  test "send_after/3 sends messages once expired" do
+    Process.send_after(self(), :hello, 10)
+    assert_receive :hello
+  end
+
+  test "send_after/4 with absolute time sends message once expired" do
+    time = System.monotonic_time(:millisecond) + 10
+    Process.send_after(self(), :hello, time, abs: true)
+    assert_receive :hello
+  end
+
+  test "send_after/3 returns a timer reference that can be read or cancelled" do
+    timer = Process.send_after(self(), :hello, 100_000)
+    refute_received :hello
+    assert is_integer(Process.read_timer(timer))
+    assert is_integer(Process.cancel_timer(timer))
+
+    timer = Process.send_after(self(), :hello, 0)
+    assert_receive :hello
+    assert Process.read_timer(timer) == false
+    assert Process.cancel_timer(timer) == false
+
+    timer = Process.send_after(self(), :hello, 100_000)
+    assert Process.cancel_timer(timer, async: true)
+    assert_receive {:cancel_timer, ^timer, result}
+    assert is_integer(result)
+  end
+
+  test "exit(pid, :normal) does not cause the target process to exit" do
+    Process.flag(:trap_exit, true)
+
+    pid =
+      spawn_link(fn ->
+        receive do
+          :done -> nil
+        end
+      end)
+
+    true = Process.exit(pid, :normal)
+    refute_receive {:EXIT, ^pid, :normal}, 100
+    assert Process.alive?(pid)
+
+    # now exit the process for real so it doesn't hang around
+    true = Process.exit(pid, :abnormal)
+    assert_receive {:EXIT, ^pid, :abnormal}
+    refute Process.alive?(pid)
+  end
+
+  test "exit(self(), :normal) causes the calling process to exit" do
+    Process.flag(:trap_exit, true)
+    pid = spawn_link(fn -> Process.exit(self(), :normal) end)
+    assert_receive {:EXIT, ^pid, :normal}
+    refute Process.alive?(pid)
+  end
+
+  describe "alias/0, alias/1, and unalias/1" do
+    test "simple alias + unalias flow" do
+      server =
+        spawn(fn ->
+          receive do
+            {:ping, alias} -> send(alias, :pong)
+          end
+        end)
+
+      alias = Process.alias()
+      Process.unalias(alias)
+
+      send(server, {:ping, alias})
+      refute_receive :pong, 20
+    end
+
+    test "with :reply option when aliasing" do
+      server =
+        spawn(fn ->
+          receive do
+            {:ping, alias} ->
+              send(alias, :pong)
+              send(alias, :extra_pong)
+          end
+        end)
+
+      alias = Process.alias([:reply])
+
+      send(server, {:ping, alias})
+      assert_receive :pong
+      refute_receive :extra_pong, 20
+    end
+  end
+
+  describe "set_label/1" do
+    @compile {:no_warn_undefined, :proc_lib}
 
-    assert Process.info(self, :registered_name) ==
-           {:registered_name, []}
+    test "sets a process label, compatible with OTP 27+ `:proc_lib.get_label/1`" do
+      label = {:some_label, :rand.uniform(99999)}
+      assert :ok = Process.set_label(label)
 
-    Process.register(self, __MODULE__)
-    assert Process.info(self, :registered_name) ==
-           {:registered_name, __MODULE__}
+      # TODO: Remove this when we require Erlang/OTP 27+
+      if System.otp_release() >= "27" do
+        assert :proc_lib.get_label(self()) == label
+      end
+    end
   end
 
   defp expand(expr, env) do
-    {expr, _env} = :elixir_exp.expand(expr, env)
+    {expr, _, _} = :elixir_expand.expand(expr, :elixir_env.env_to_ex(env), env)
     expr
   end
 end
diff --git a/lib/elixir/test/elixir/protocol/consolidation_test.exs b/lib/elixir/test/elixir/protocol/consolidation_test.exs
new file mode 100644
index 00000000000..902645a975b
--- /dev/null
+++ b/lib/elixir/test/elixir/protocol/consolidation_test.exs
@@ -0,0 +1,292 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+path = Path.expand("../../ebin", __DIR__)
+File.mkdir_p!(path)
+
+files = Path.wildcard(PathHelpers.fixture_path("consolidation/*"))
+Kernel.ParallelCompiler.compile_to_path(files, path, return_diagnostics: true)
+
+defmodule Protocol.ConsolidationTest do
+  use ExUnit.Case, async: true
+  alias Protocol.ConsolidationTest.{Sample, WithAny, NoImpl}
+
+  defimpl WithAny, for: Map do
+    def ok(map, _opts) do
+      {:ok, map}
+    end
+  end
+
+  defimpl WithAny, for: Any do
+    def ok(any, _opts) do
+      {:ok, any}
+    end
+  end
+
+  defmodule NoImplStruct do
+    defstruct a: 0, b: 0
+  end
+
+  defmodule ImplStruct do
+    @derive [WithAny]
+    defstruct a: 0, b: 0
+
+    defimpl Sample do
+      @compile {:no_warn_undefined, Unknown}
+
+      def ok(struct) do
+        Unknown.undefined(struct)
+      end
+    end
+  end
+
+  Code.append_path(path)
+
+  # Any is ignored because there is no fallback
+  :code.purge(Sample)
+  :code.delete(Sample)
+  {:ok, binary} = Protocol.consolidate(Sample, [Any, ImplStruct])
+  :code.load_binary(Sample, ~c"protocol_test.exs", binary)
+
+  defp sample_binary, do: unquote(binary)
+
+  # Any should be moved to the end
+  :code.purge(WithAny)
+  :code.delete(WithAny)
+  {:ok, binary} = Protocol.consolidate(WithAny, [Any, ImplStruct, Map])
+  :code.load_binary(WithAny, ~c"protocol_test.exs", binary)
+
+  defp with_any_binary, do: unquote(binary)
+
+  # No Any
+  :code.purge(NoImpl)
+  :code.delete(NoImpl)
+  {:ok, binary} = Protocol.consolidate(NoImpl, [])
+  :code.load_binary(NoImpl, ~c"protocol_test.exs", binary)
+
+  defp no_impl_binary, do: unquote(binary)
+
+  test "consolidated?/1" do
+    assert Protocol.consolidated?(WithAny)
+    refute Protocol.consolidated?(Enumerable)
+  end
+
+  test "consolidation warns on new implementations" do
+    output =
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        defimpl WithAny, for: Integer do
+          def ok(_any, _opts), do: :ok
+        end
+      end)
+
+    assert output =~ ~r"the .+WithAny protocol has already been consolidated"
+  after
+    :code.purge(WithAny.Integer)
+    :code.delete(WithAny.Integer)
+  end
+
+  test "consolidation warns on new implementations unless disabled" do
+    Code.put_compiler_option(:ignore_already_consolidated, true)
+
+    defimpl WithAny, for: Integer do
+      def ok(_any), do: :ok
+    end
+  after
+    Code.put_compiler_option(:ignore_already_consolidated, false)
+    :code.purge(WithAny.Integer)
+    :code.delete(WithAny.Integer)
+  end
+
+  test "consolidated implementations without fallback to any" do
+    assert is_nil(Sample.impl_for(:foo))
+    assert is_nil(Sample.impl_for(fn x -> x end))
+    assert is_nil(Sample.impl_for(1))
+    assert is_nil(Sample.impl_for(1.1))
+    assert is_nil(Sample.impl_for([]))
+    assert is_nil(Sample.impl_for([1, 2, 3]))
+    assert is_nil(Sample.impl_for({}))
+    assert is_nil(Sample.impl_for({1, 2, 3}))
+    assert is_nil(Sample.impl_for("foo"))
+    assert is_nil(Sample.impl_for(<<1>>))
+    assert is_nil(Sample.impl_for(self()))
+    assert is_nil(Sample.impl_for(%{}))
+    assert is_nil(Sample.impl_for(hd(:erlang.ports())))
+    assert is_nil(Sample.impl_for(make_ref()))
+
+    assert Sample.impl_for(%ImplStruct{}) == Sample.Protocol.ConsolidationTest.ImplStruct
+    assert Sample.impl_for(%NoImplStruct{}) == nil
+  end
+
+  test "consolidated implementations with fallback to any" do
+    assert WithAny.impl_for(%NoImplStruct{}) == WithAny.Any
+
+    # Derived
+    assert WithAny.impl_for(%ImplStruct{}) ==
+             Protocol.ConsolidationTest.WithAny.Protocol.ConsolidationTest.ImplStruct
+
+    assert WithAny.impl_for(%{__struct__: "foo"}) == WithAny.Map
+    assert WithAny.impl_for(%{}) == WithAny.Map
+    assert WithAny.impl_for(self()) == WithAny.Any
+  end
+
+  test "consolidation keeps docs" do
+    {:ok, {Sample, [{~c"Docs", docs_bin}]}} = :beam_lib.chunks(sample_binary(), [~c"Docs"])
+    {:docs_v1, _, _, _, _, _, docs} = :erlang.binary_to_term(docs_bin)
+    ok_doc = List.keyfind(docs, {:function, :ok, 1}, 0)
+
+    assert {{:function, :ok, 1}, _, ["ok(term)"], %{"en" => "Ok"}, _} = ok_doc
+  end
+
+  @tag :requires_source
+  test "consolidation keeps source" do
+    assert Sample.__info__(:compile)[:source]
+  end
+
+  test "consolidated keeps callbacks" do
+    {:ok, callbacks} = Code.Typespec.fetch_callbacks(sample_binary())
+    assert callbacks != []
+  end
+
+  test "consolidation updates attributes" do
+    assert Sample.__protocol__(:consolidated?)
+    assert Sample.__protocol__(:impls) == {:consolidated, [ImplStruct]}
+    assert WithAny.__protocol__(:consolidated?)
+    assert WithAny.__protocol__(:impls) == {:consolidated, [Any, Map, ImplStruct]}
+    assert NoImpl.__protocol__(:consolidated?)
+    assert NoImpl.__protocol__(:impls) == {:consolidated, []}
+  end
+
+  describe "exports" do
+    import Module.Types.Descr
+    alias Module.Types.Of
+
+    defp exports(binary) do
+      {:ok, {_, [{~c"ExCk", check_bin}]}} = :beam_lib.chunks(binary, [~c"ExCk"])
+      assert {:elixir_checker_v4, contents} = :erlang.binary_to_term(check_bin)
+      Map.new(contents.exports)
+    end
+
+    test "keeps deprecations" do
+      deprecated = [{{:ok, 1}, "Reason"}]
+      assert deprecated == Sample.__info__(:deprecated)
+
+      assert %{{:ok, 1} => %{deprecated: "Reason", sig: _}} = exports(sample_binary())
+    end
+
+    test "defines signatures without fallback to any" do
+      exports = exports(sample_binary())
+
+      assert %{{:impl_for, 1} => %{sig: {:strong, domain, clauses}}} = exports
+      assert domain == [term()]
+
+      assert clauses == [
+               {[Of.impl(ImplStruct)], atom([Sample.Protocol.ConsolidationTest.ImplStruct])},
+               {[negation(Of.impl(ImplStruct))], atom([nil])}
+             ]
+
+      assert %{{:impl_for!, 1} => %{sig: {:strong, domain, clauses}}} = exports
+      assert domain == [Of.impl(ImplStruct)]
+
+      assert clauses == [
+               {[Of.impl(ImplStruct)], atom([Sample.Protocol.ConsolidationTest.ImplStruct])}
+             ]
+
+      assert %{{:ok, 1} => %{sig: {:strong, nil, clauses}}} = exports
+
+      assert clauses == [
+               {[Of.impl(ImplStruct)], dynamic()}
+             ]
+    end
+
+    test "defines signatures with fallback to any" do
+      exports = exports(with_any_binary())
+
+      assert %{
+               {:impl_for, 1} => %{sig: {:strong, domain, clauses}},
+               {:impl_for!, 1} => %{sig: {:strong, domain, clauses}}
+             } = exports
+
+      assert domain == [term()]
+
+      assert clauses == [
+               {[Of.impl(Map)], atom([WithAny.Map])},
+               {[Of.impl(ImplStruct)], atom([WithAny.Protocol.ConsolidationTest.ImplStruct])},
+               {[negation(union(Of.impl(ImplStruct), Of.impl(Map)))], atom([WithAny.Any])}
+             ]
+
+      assert %{{:ok, 2} => %{sig: {:strong, nil, clauses}}} = exports
+
+      assert clauses == [
+               {[term(), term()], dynamic()}
+             ]
+    end
+
+    test "defines signatures without implementation" do
+      exports = exports(no_impl_binary())
+
+      assert %{{:impl_for, 1} => %{sig: {:strong, domain, clauses}}} = exports
+      assert domain == [term()]
+      assert clauses == [{[term()], atom([nil])}]
+
+      assert %{{:impl_for!, 1} => %{sig: {:strong, domain, clauses}}} = exports
+      assert domain == [none()]
+      assert clauses == [{[none()], none()}]
+
+      assert %{{:ok, 1} => %{sig: {:strong, nil, clauses}}} = exports
+      assert clauses == [{[none()], dynamic()}]
+    end
+  end
+
+  test "consolidation errors on missing BEAM files" do
+    import PathHelpers
+
+    write_beam(
+      defmodule ExampleModule do
+      end
+    )
+
+    defprotocol NoBeam do
+      def example(arg)
+    end
+
+    assert Protocol.consolidate(ExampleModule, []) == {:error, :not_a_protocol}
+    assert Protocol.consolidate(NoBeam, []) == {:error, :no_beam_info}
+  end
+
+  test "protocol not implemented" do
+    message =
+      "protocol Protocol.ConsolidationTest.Sample not implemented for Atom. " <>
+        "This protocol is implemented for: Protocol.ConsolidationTest.ImplStruct" <>
+        "\n\nGot value:\n\n    :foo\n"
+
+    assert_raise Protocol.UndefinedError, message, fn ->
+      sample = String.to_atom("Elixir.Protocol.ConsolidationTest.Sample")
+      sample.ok(:foo)
+    end
+  end
+
+  describe "extraction" do
+    test "protocols" do
+      protos = Protocol.extract_protocols([Application.app_dir(:elixir, "ebin")])
+      assert Enumerable in protos
+      assert Inspect in protos
+    end
+
+    test "implementations with charlist path" do
+      protos =
+        Protocol.extract_impls(Enumerable, [to_charlist(Application.app_dir(:elixir, "ebin"))])
+
+      assert List in protos
+      assert Function in protos
+    end
+
+    test "implementations with binary path" do
+      protos = Protocol.extract_impls(Enumerable, [Application.app_dir(:elixir, "ebin")])
+      assert List in protos
+      assert Function in protos
+    end
+  end
+end
diff --git a/lib/elixir/test/elixir/protocol_test.exs b/lib/elixir/test/elixir/protocol_test.exs
index 4392b189946..4319d69c610 100644
--- a/lib/elixir/test/elixir/protocol_test.exs
+++ b/lib/elixir/test/elixir/protocol_test.exs
@@ -1,27 +1,41 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule ProtocolTest do
   use ExUnit.Case, async: true
 
-  defprotocol Sample do
-    @type t :: any
-    @doc "Ok"
-    @spec ok(t) :: boolean
-    def ok(thing)
-  end
+  doctest Protocol
 
-  defprotocol WithAny do
-    @fallback_to_any true
-    @doc "Ok"
-    def ok(thing)
-  end
+  {_, _, sample_binary, _} =
+    defprotocol Sample do
+      @type t :: any
+      @doc "Ok"
+      @deprecated "Reason"
+      @spec ok(t) :: boolean
+      def ok(term)
+    end
+
+  @sample_binary sample_binary
+
+  {_, _, with_any_binary, _} =
+    defprotocol WithAny do
+      @fallback_to_any true
+      @doc "Ok"
+      def ok(term)
+    end
+
+  @with_any_binary with_any_binary
 
   defprotocol Derivable do
-    def ok(a)
-  end
+    @undefined_impl_description "you should try harder"
+
+    @impl true
+    defmacro __deriving__(module, options) do
+      struct = Macro.struct!(module, __CALLER__)
 
-  defimpl Derivable, for: Map do
-    defmacro __deriving__(module, struct, options) do
       quote do
         defimpl Derivable, for: unquote(module) do
           def ok(arg) do
@@ -31,6 +45,10 @@ defmodule ProtocolTest do
       end
     end
 
+    def ok(a)
+  end
+
+  defimpl Derivable, for: Any do
     def ok(arg) do
       {:ok, arg}
     end
@@ -57,63 +75,115 @@ defmodule ProtocolTest do
     defstruct a: 0, b: 0
 
     defimpl Sample do
+      @compile {:no_warn_undefined, Unknown}
+
       def ok(struct) do
         Unknown.undefined(struct)
       end
     end
   end
 
-  test "protocol implementations without any" do
-    assert nil? Sample.impl_for(:foo)
-    assert nil? Sample.impl_for(fn(x) -> x end)
-    assert nil? Sample.impl_for(1)
-    assert nil? Sample.impl_for(1.1)
-    assert nil? Sample.impl_for([])
-    assert nil? Sample.impl_for([1, 2, 3])
-    assert nil? Sample.impl_for({})
-    assert nil? Sample.impl_for({1, 2, 3})
-    assert nil? Sample.impl_for("foo")
-    assert nil? Sample.impl_for(<<1>>)
-    assert nil? Sample.impl_for(%{})
-    assert nil? Sample.impl_for(self)
-    assert nil? Sample.impl_for(hd(:erlang.ports))
-    assert nil? Sample.impl_for(make_ref)
-
-    assert Sample.impl_for(%ImplStruct{}) ==
-           Sample.ProtocolTest.ImplStruct
-    assert Sample.impl_for(%NoImplStruct{}) ==
-           nil
+  defmodule ImplStructExplicitFor do
+    defstruct a: 0, b: 0
+
+    defimpl Sample, for: __MODULE__ do
+      def ok(_struct), do: true
+    end
   end
 
-  test "protocol implementation with any and structs fallback" do
-    assert WithAny.impl_for(%NoImplStruct{})      == WithAny.Any
-    assert WithAny.impl_for(%ImplStruct{})        == WithAny.Map # Derived
+  test "protocol implementations without any" do
+    assert is_nil(Sample.impl_for(:foo))
+    assert is_nil(Sample.impl_for(fn x -> x end))
+    assert is_nil(Sample.impl_for(1))
+    assert is_nil(Sample.impl_for(1.1))
+    assert is_nil(Sample.impl_for([]))
+    assert is_nil(Sample.impl_for([1, 2, 3]))
+    assert is_nil(Sample.impl_for({}))
+    assert is_nil(Sample.impl_for({1, 2, 3}))
+    assert is_nil(Sample.impl_for("foo"))
+    assert is_nil(Sample.impl_for(<<1>>))
+    assert is_nil(Sample.impl_for(%{}))
+    assert is_nil(Sample.impl_for(self()))
+    assert is_nil(Sample.impl_for(hd(:erlang.ports())))
+    assert is_nil(Sample.impl_for(make_ref()))
+
+    assert Sample.impl_for(%ImplStruct{}) == Sample.ProtocolTest.ImplStruct
+    assert Sample.impl_for(%ImplStructExplicitFor{}) == Sample.ProtocolTest.ImplStructExplicitFor
+    assert Sample.impl_for(%NoImplStruct{}) == nil
+    assert is_nil(Sample.impl_for(%{__struct__: nil}))
+  end
+
+  test "protocol implementation with Any and struct fallbacks" do
+    assert WithAny.impl_for(%NoImplStruct{}) == WithAny.Any
+    assert WithAny.impl_for(%{__struct__: nil}) == WithAny.Any
     assert WithAny.impl_for(%{__struct__: "foo"}) == WithAny.Map
-    assert WithAny.impl_for(%{})                  == WithAny.Map
-    assert WithAny.impl_for(self)                 == WithAny.Any
+    assert WithAny.impl_for(%{}) == WithAny.Map
+    assert WithAny.impl_for(self()) == WithAny.Any
+
+    # Derived
+    assert WithAny.impl_for(%ImplStruct{}) == ProtocolTest.WithAny.ProtocolTest.ImplStruct
   end
 
   test "protocol not implemented" do
-    assert_raise Protocol.UndefinedError, "protocol ProtocolTest.Sample not implemented for :foo", fn ->
-      Sample.ok(:foo)
+    message =
+      """
+      protocol ProtocolTest.Sample not implemented for Atom
+
+      Got value:
+
+          :foo
+      """
+
+    assert_raise Protocol.UndefinedError, message, fn ->
+      sample = String.to_atom("Elixir.ProtocolTest.Sample")
+      sample.ok(:foo)
     end
   end
 
-  test "protocol documentation" do
+  test "protocol documentation and deprecated" do
     import PathHelpers
 
-    write_beam(defprotocol SampleDocsProto do
-      @type t :: any
-      @doc "Ok"
-      @spec ok(t) :: boolean
-      def ok(thing)
-    end)
+    write_beam(
+      defprotocol SampleDocsProto do
+        @doc "Ok"
+        @deprecated "Reason"
+        @spec ok(t) :: boolean
+        def ok(term)
+      end
+    )
+
+    write_beam(
+      defimpl SampleDocsProto, for: List do
+        def ok(_), do: true
+      end
+    )
+
+    write_beam(
+      defimpl SampleDocsProto, for: Map do
+        @moduledoc "for map"
+
+        def ok(_), do: true
+      end
+    )
 
-    docs = Code.get_docs(SampleDocsProto, :docs)
-    assert {{:ok, 1}, _, :def, [{:thing, _, nil}], "Ok"} =
-           List.keyfind(docs, {:ok, 1}, 0)
+    {:docs_v1, _, _, _, _, _, docs} = Code.fetch_docs(SampleDocsProto)
+
+    assert {{:type, :t, 0}, _, [], %{"en" => type_doc}, _} = List.keyfind(docs, {:type, :t, 0}, 0)
+    assert type_doc =~ "All the types that implement this protocol"
+
+    assert {{:function, :ok, 1}, _, ["ok(term)"], %{"en" => "Ok"}, _} =
+             List.keyfind(docs, {:function, :ok, 1}, 0)
+
+    deprecated = SampleDocsProto.__info__(:deprecated)
+    assert [{{:ok, 1}, "Reason"}] = deprecated
+
+    {:docs_v1, _, _, _, :hidden, _, _} = Code.fetch_docs(SampleDocsProto.List)
+    {:docs_v1, _, _, _, moduledoc, _, _} = Code.fetch_docs(SampleDocsProto.Map)
+    assert moduledoc == %{"en" => "for map"}
   end
 
+  @compile {:no_warn_undefined, WithAll}
+
   test "protocol keeps underlying UndefinedFunctionError" do
     assert_raise UndefinedFunctionError, fn ->
       WithAll.ok(%ImplStruct{})
@@ -121,34 +191,54 @@ defmodule ProtocolTest do
   end
 
   test "protocol defines callbacks" do
-    assert get_callbacks(Sample, :ok, 1) ==
-      [{:type, 9, :fun, [{:type, 9, :product, [{:type, 9, :t, []}]}, {:type, 9, :boolean, []}]}]
+    assert [{:type, {17, 13}, :fun, args}] = get_callbacks(@sample_binary, :ok, 1)
+
+    assert args == [
+             {:type, {17, 13}, :product, [{:user_type, {17, 16}, :t, []}]},
+             {:type, {17, 22}, :boolean, []}
+           ]
+
+    assert [{:type, 27, :fun, args}] = get_callbacks(@with_any_binary, :ok, 1)
+    assert args == [{:type, 27, :product, [{:user_type, 27, :t, []}]}, {:type, 27, :term, []}]
+  end
 
-    assert get_callbacks(WithAny, :ok, 1) ==
-      [{:type, 16, :fun, [{:type, 16, :product, [{:type, 16, :t, []}]}, {:type, 16, :term, []}]}]
+  test "protocol defines t/0 type with documentation" do
+    assert {:type, {:t, {_, _, :any, []}, []}} = get_type(@sample_binary, :t, 0)
   end
 
-  test "protocol defines attributes" do
-    assert Sample.__info__(:attributes)[:protocol] == [fallback_to_any: false, consolidated: false]
-    assert WithAny.__info__(:attributes)[:protocol] == [fallback_to_any: true, consolidated: false]
+  test "protocol defines functions and attributes" do
+    assert Sample.__protocol__(:module) == Sample
+    assert Sample.__protocol__(:functions) == [ok: 1]
+    refute Sample.__protocol__(:consolidated?)
+    assert Sample.__protocol__(:impls) == :not_consolidated
+    assert Sample.__info__(:attributes)[:__protocol__] == [fallback_to_any: false]
+
+    assert WithAny.__protocol__(:module) == WithAny
+    assert WithAny.__protocol__(:functions) == [ok: 1]
+    refute WithAny.__protocol__(:consolidated?)
+    assert WithAny.__protocol__(:impls) == :not_consolidated
+    assert WithAny.__info__(:attributes)[:__protocol__] == [fallback_to_any: true]
   end
 
   test "defimpl" do
-    defprotocol Attribute do
-      def test(thing)
-    end
+    module = Module.concat(Sample, ImplStruct)
+    assert module.__impl__(:for) == ImplStruct
+    assert module.__impl__(:protocol) == Sample
+    assert module.__info__(:attributes)[:__impl__] == [protocol: Sample, for: ImplStruct]
+  end
 
-    defimpl Attribute, for: ImplStruct do
-      def test(_) do
-        {@protocol, @for}
-      end
-    end
+  test "defimpl with implicit derive" do
+    module = Module.concat(WithAny, ImplStruct)
+    assert module.__impl__(:for) == ImplStruct
+    assert module.__impl__(:protocol) == WithAny
+    assert module.__info__(:attributes)[:__impl__] == [protocol: WithAny, for: ImplStruct]
+  end
 
-    assert Attribute.test(%ImplStruct{}) == {Attribute, ImplStruct}
-    assert Attribute.ProtocolTest.ImplStruct.__impl__(:protocol) == Attribute
-    assert Attribute.ProtocolTest.ImplStruct.__impl__(:for) == ImplStruct
-    assert Attribute.ProtocolTest.ImplStruct.__info__(:attributes)[:impl] ==
-           [protocol: Attribute, for: ImplStruct]
+  test "defimpl with explicit derive" do
+    module = Module.concat(Derivable, ImplStruct)
+    assert module.__impl__(:for) == ImplStruct
+    assert module.__impl__(:protocol) == Derivable
+    assert module.__info__(:attributes)[:__impl__] == [protocol: Derivable, for: ImplStruct]
   end
 
   test "defimpl with multiple for" do
@@ -164,47 +254,67 @@ defmodule ProtocolTest do
     assert Multi.test(:a) == :a
   end
 
-  defp get_callbacks(module, name, arity) do
-    callbacks = for {:callback, info} <- module.__info__(:attributes), do: hd(info)
-    List.keyfind(callbacks, {name, arity}, 0) |> elem(1)
+  test "defimpl without :for option when outside a module" do
+    msg = "defimpl/3 expects a :for option when declared outside a module"
+
+    assert_raise ArgumentError, msg, fn ->
+      ast =
+        quote do
+          defimpl Sample do
+            def ok(_term), do: true
+          end
+        end
+
+      Code.eval_quoted(ast, [], %{__ENV__ | module: nil})
+    end
   end
 
-  test "derives protocol" do
-    struct = %ImplStruct{a: 1, b: 1}
-    assert WithAny.ok(struct) == {:ok, struct}
+  defp get_callbacks(beam, name, arity) do
+    {:ok, callbacks} = Code.Typespec.fetch_callbacks(beam)
+    List.keyfind(callbacks, {name, arity}, 0) |> elem(1)
   end
 
-  test "derived protocol keeps local file/line info" do
-    assert ProtocolTest.WithAny.ProtocolTest.ImplStruct.__info__(:compile)[:source] ==
-           String.to_char_list(__ENV__.file)
+  defp get_type(beam, name, arity) do
+    {:ok, types} = Code.Typespec.fetch_types(beam)
+
+    assert {:value, value} =
+             :lists.search(&match?({_, {^name, _, args}} when length(args) == arity, &1), types)
+
+    value
   end
 
-  test "custom derive implementation" do
+  test "derives protocol implicitly" do
     struct = %ImplStruct{a: 1, b: 1}
-    assert Derivable.ok(struct) == {:ok, struct, %ImplStruct{}, []}
+    assert WithAny.ok(struct) == {:ok, struct}
 
+    struct = %NoImplStruct{a: 1, b: 1}
+    assert WithAny.ok(struct) == {:ok, struct}
+  end
+
+  test "derives protocol explicitly" do
     struct = %ImplStruct{a: 1, b: 1}
     assert Derivable.ok(struct) == {:ok, struct, %ImplStruct{}, []}
 
-    assert_raise Protocol.UndefinedError, fn ->
-      struct = %NoImplStruct{a: 1, b: 1}
-      Derivable.ok(struct)
-    end
+    assert_raise Protocol.UndefinedError,
+                 ~r"protocol ProtocolTest.Derivable not implemented for ProtocolTest.NoImplStruct \(a struct\), you should try harder",
+                 fn ->
+                   struct = %NoImplStruct{a: 1, b: 1}
+                   Derivable.ok(struct)
+                 end
   end
 
-  test "custom derive implementation with options" do
+  test "derives protocol explicitly with options" do
     defmodule AnotherStruct do
       @derive [{Derivable, :ok}]
       @derive [WithAny]
       defstruct a: 0, b: 0
     end
 
-    struct = struct AnotherStruct, a: 1, b: 1
-    assert Derivable.ok(struct) ==
-           {:ok, struct, struct(AnotherStruct), :ok}
+    struct = struct(AnotherStruct, a: 1, b: 1)
+    assert Derivable.ok(struct) == {:ok, struct, struct(AnotherStruct), :ok}
   end
 
-  test "custom derive implementation via API" do
+  test "derive protocol explicitly via API" do
     defmodule InlineStruct do
       defstruct a: 0, b: 0
     end
@@ -212,156 +322,132 @@ defmodule ProtocolTest do
     require Protocol
     assert Protocol.derive(Derivable, InlineStruct, :oops) == :ok
 
-    struct = struct InlineStruct, a: 1, b: 1
-    assert Derivable.ok(struct) ==
-           {:ok, struct, struct(InlineStruct), :oops}
+    struct = struct(InlineStruct, a: 1, b: 1)
+    assert Derivable.ok(struct) == {:ok, struct, struct(InlineStruct), :oops}
   end
 
-  test "cannot derive without a map implementation" do
-    assert_raise ArgumentError,
-        ~r"#{inspect Sample.Map} is not available, cannot derive #{inspect Sample}", fn ->
-      defmodule NotCompiled do
-        @derive [Sample]
-        defstruct hello: :world
-      end
-    end
+  @tag :requires_source
+  test "derived implementation keeps local file/line info" do
+    assert ProtocolTest.WithAny.ProtocolTest.ImplStruct.__info__(:compile)[:source] ==
+             String.to_charlist(__ENV__.file)
   end
-end
 
-path = Path.expand("../ebin", __DIR__)
-File.mkdir_p!(path)
+  describe "warnings" do
+    import ExUnit.CaptureIO
 
-compile = fn {:module, module, binary, _} ->
-  File.write!("#{path}/#{module}.beam", binary)
-end
+    test "with no definitions" do
+      assert capture_io(:stderr, fn ->
+               defprotocol SampleWithNoDefinitions do
+               end
+             end) =~ "protocols must define at least one function, but none was defined"
+    end
 
-defmodule Protocol.ConsolidationTest do
-  use ExUnit.Case, async: true
+    test "when @callbacks and friends are defined inside a protocol" do
+      message =
+        capture_io(:stderr, fn ->
+          defprotocol SampleWithCallbacks do
+            @spec with_specs(any(), keyword()) :: tuple()
+            def with_specs(term, options \\ [])
 
-  compile.(
-    defprotocol Sample do
-      @type t :: any
-      @doc "Ok"
-      @spec ok(t) :: boolean
-      def ok(thing)
-    end
-  )
+            @spec with_specs_and_when(any(), opts) :: tuple() when opts: keyword
+            def with_specs_and_when(term, options \\ [])
 
-  compile.(
-    defprotocol WithAny do
-      @fallback_to_any true
-      @doc "Ok"
-      def ok(thing)
-    end
-  )
+            def without_specs(term, options \\ [])
 
-  defimpl WithAny, for: Map do
-    def ok(map) do
-      {:ok, map}
-    end
-  end
+            @callback foo :: {:ok, term}
+            @callback foo(term) :: {:ok, term}
+            @callback foo(term, keyword) :: {:ok, term, keyword}
 
-  defimpl WithAny, for: Any do
-    def ok(any) do
-      {:ok, any}
-    end
-  end
+            @callback foo_when :: {:ok, x} when x: term
+            @callback foo_when(x) :: {:ok, x} when x: term
+            @callback foo_when(x, opts) :: {:ok, x, opts} when x: term, opts: keyword
 
-  defmodule NoImplStruct do
-    defstruct a: 0, b: 0
-  end
+            @macrocallback bar(term) :: {:ok, term}
+            @macrocallback bar(term, keyword) :: {:ok, term, keyword}
 
-  defmodule ImplStruct do
-    @derive [WithAny]
-    defstruct a: 0, b: 0
+            @optional_callbacks [foo: 1, foo: 2]
+            @optional_callbacks [without_specs: 2]
+          end
+        end)
 
-    defimpl Sample do
-      def ok(struct) do
-        Unknown.undefined(struct)
-      end
-    end
-  end
+      assert message =~
+               "cannot define @callback foo/0 inside protocol, use def/1 to outline your protocol definition"
 
-  Code.append_path(path)
+      assert message =~
+               "cannot define @callback foo/1 inside protocol, use def/1 to outline your protocol definition"
 
-  # Any is ignored because there is no fallback
-  :code.purge(Sample)
-  :code.delete(Sample)
-  {:ok, binary} = Protocol.consolidate(Sample, [Any, ImplStruct])
-  :code.load_binary(Sample, 'protocol_test.exs', binary)
+      assert message =~
+               "cannot define @callback foo/2 inside protocol, use def/1 to outline your protocol definition"
 
-  # Any should be moved to the end
-  :code.purge(WithAny)
-  :code.delete(WithAny)
-  {:ok, binary} = Protocol.consolidate(WithAny, [Any, ImplStruct, Map])
-  :code.load_binary(WithAny, 'protocol_test.exs', binary)
+      assert message =~
+               "cannot define @callback foo_when/0 inside protocol, use def/1 to outline your protocol definition"
 
-  test "consolidated?/1" do
-    assert Protocol.consolidated?(WithAny)
-    refute Protocol.consolidated?(Enumerable)
-  end
+      assert message =~
+               "cannot define @callback foo_when/1 inside protocol, use def/1 to outline your protocol definition"
 
-  test "consolidated implementations without any" do
-    assert nil? Sample.impl_for(:foo)
-    assert nil? Sample.impl_for(fn(x) -> x end)
-    assert nil? Sample.impl_for(1)
-    assert nil? Sample.impl_for(1.1)
-    assert nil? Sample.impl_for([])
-    assert nil? Sample.impl_for([1, 2, 3])
-    assert nil? Sample.impl_for({})
-    assert nil? Sample.impl_for({1, 2, 3})
-    assert nil? Sample.impl_for("foo")
-    assert nil? Sample.impl_for(<<1>>)
-    assert nil? Sample.impl_for(self)
-    assert nil? Sample.impl_for(%{})
-    assert nil? Sample.impl_for(hd(:erlang.ports))
-    assert nil? Sample.impl_for(make_ref)
-
-    assert Sample.impl_for(%ImplStruct{}) ==
-           Sample.Protocol.ConsolidationTest.ImplStruct
-    assert Sample.impl_for(%NoImplStruct{}) ==
-           nil
-  end
+      assert message =~
+               "cannot define @callback foo_when/2 inside protocol, use def/1 to outline your protocol definition"
 
-  test "consolidated implementations with any and tuple fallback" do
-    assert WithAny.impl_for(%NoImplStruct{})      == WithAny.Any
-    assert WithAny.impl_for(%ImplStruct{})        == WithAny.Map # Derived
-    assert WithAny.impl_for(%{__struct__: "foo"}) == WithAny.Map
-    assert WithAny.impl_for(%{})                  == WithAny.Map
-    assert WithAny.impl_for(self)                 == WithAny.Any
-  end
+      assert message =~
+               "cannot define @macrocallback bar/1 inside protocol, use def/1 to outline your protocol definition"
 
-  test "consolidation keeps docs" do
-    docs = Code.get_docs(Sample, :docs)
-    assert {{:ok, 1}, _, :def, [{:thing, _, nil}], "Ok"} =
-           List.keyfind(docs, {:ok, 1}, 0)
-  end
+      assert message =~
+               "cannot define @macrocallback bar/2 inside protocol, use def/1 to outline your protocol definition"
 
-  test "consolidated keeps callbacks" do
-    callbacks = for {:callback, info} <- Sample.__info__(:attributes), do: hd(info)
-    assert callbacks != []
-  end
+      assert message =~
+               "cannot define @optional_callbacks inside protocol, all of the protocol definitions are required"
+    end
 
-  test "consolidation errors on missing beams" do
-    defprotocol NoBeam, do: nil
-    assert Protocol.consolidate(String, [])  == {:error, :not_a_protocol}
-    assert Protocol.consolidate(NoBeam, [])  == {:error, :no_beam_info}
-  end
+    test "when deriving after struct" do
+      assert capture_io(:stderr, fn ->
+               defmodule DeriveTooLate do
+                 defstruct []
+                 @derive [{Derivable, :ok}]
+               end
+             end) =~
+               "module attribute @derive was set after defstruct, all @derive calls must come before defstruct"
+    end
 
-  test "consolidation updates attributes" do
-    assert Sample.__info__(:attributes)[:protocol] == [fallback_to_any: false, consolidated: true]
-    assert WithAny.__info__(:attributes)[:protocol] == [fallback_to_any: true, consolidated: true]
+    test "when deriving with no struct" do
+      assert capture_io(:stderr, fn ->
+               defmodule DeriveNeverUsed do
+                 @derive [{Derivable, :ok}]
+               end
+             end) =~
+               "module attribute @derive was set but never used (it must come before defstruct)"
+    end
   end
 
-  test "consolidation extracts protocols" do
-    protos = Protocol.extract_protocols([:code.lib_dir(:elixir, :ebin)])
-    assert Enumerable in protos
-    assert Inspect in protos
+  describe "errors" do
+    test "cannot derive without any implementation" do
+      assert_raise ArgumentError,
+                   ~r"could not load module #{inspect(Sample.Any)} due to reason :nofile, cannot derive #{inspect(Sample)}",
+                   fn ->
+                     defmodule NotCompiled do
+                       @derive [Sample]
+                       defstruct hello: :world
+                     end
+                   end
+    end
   end
+end
+
+defmodule Protocol.DebugInfoTest do
+  use ExUnit.Case
+
+  test "protocols always keep debug_info" do
+    Code.compiler_options(debug_info: false)
+
+    {:module, _, binary, _} =
+      defprotocol DebugInfoProto do
+        def example(info)
+      end
+
+    assert {:ok, {DebugInfoProto, [debug_info: debug_info]}} =
+             :beam_lib.chunks(binary, [:debug_info])
 
-  test "consolidation extracts implementations" do
-    protos = Protocol.extract_impls(Enumerable, [:code.lib_dir(:elixir, :ebin)])
-    assert List in protos
-    assert Function in protos
+    assert {:debug_info_v1, :elixir_erl, {:elixir_v1, _, _}} = debug_info
+  after
+    Code.compiler_options(debug_info: true)
   end
 end
diff --git a/lib/elixir/test/elixir/range_test.exs b/lib/elixir/test/elixir/range_test.exs
index cde88cc2fb5..9c961343872 100644
--- a/lib/elixir/test/elixir/range_test.exs
+++ b/lib/elixir/test/elixir/range_test.exs
@@ -1,41 +1,246 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule RangeTest do
   use ExUnit.Case, async: true
 
-  test :precedence do
-    assert Enum.to_list(1..3+2) == [1, 2, 3, 4, 5]
-    assert 1..3 |> Enum.to_list == [1, 2, 3]
+  doctest Range
+
+  defp reverse(first..last//step) do
+    last..first//-step
   end
 
-  test :op do
-    assert (1..3).first == 1
-    assert (1..3).last  == 3
+  defp assert_disjoint(r1, r2) do
+    disjoint_assertions(r1, r2, true)
   end
 
-  test :range? do
-    assert Range.range?(1..3)
-    refute Range.range?(0)
+  defp assert_overlap(r1, r2) do
+    disjoint_assertions(r1, r2, false)
   end
 
-  test :enum do
-    refute Enum.empty?(1..1)
+  defp disjoint_assertions(r1, r2, expected) do
+    # The caller should choose pairs of representative ranges, and we take care
+    # here of commuting them.
+    Enum.each([[r1, r2], [r2, r1]], fn [a, b] ->
+      assert Range.disjoint?(a, b) == expected
+      assert Range.disjoint?(reverse(a), b) == expected
+      assert Range.disjoint?(a, reverse(b)) == expected
+      assert Range.disjoint?(reverse(a), reverse(b)) == expected
+    end)
+  end
 
-    assert Enum.member?(1..3, 2)
-    refute Enum.member?(1..3, 0)
-    refute Enum.member?(1..3, 4)
-    refute Enum.member?(3..1, 0)
-    refute Enum.member?(3..1, 4)
+  test "new" do
+    assert Range.new(1, 3) == 1..3//1
+    assert Range.new(1, 3, 2) == 1..3//2
+    assert Range.new(3, 1, -2) == 3..1//-2
 
-    assert Enum.count(1..3) == 3
-    assert Enum.count(3..1) == 3
+    assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+             assert Range.new(3, 1) == 3..1//-1
+           end) =~ "default to a step of -1"
+  end
 
-    assert Enum.map(1..3, &(&1 * 2)) == [2, 4, 6]
-    assert Enum.map(3..1, &(&1 * 2)) == [6, 4, 2]
+  test "fields" do
+    assert (1..3).first == 1
+    assert (1..3).last == 3
+    assert (1..3).step == 1
+    assert (3..1//-1).step == -1
+    assert (1..3//2).step == 2
   end
 
-  test :inspect do
+  test "inspect" do
     assert inspect(1..3) == "1..3"
-    assert inspect(3..1) == "3..1"
+    assert inspect(1..3//2) == "1..3//2"
+
+    assert inspect(3..1//-1) == "3..1//-1"
+    assert inspect(3..1//1) == "3..1//1"
+  end
+
+  test "shift" do
+    assert Range.shift(0..10//2, 2) == 4..14//2
+    assert Range.shift(0..10//2, 0) == 0..10//2
+    assert Range.shift(10..0//-2, 2) == 6..-4//-2
+    assert Range.shift(10..0//-2, -2) == 14..4//-2
+  end
+
+  test "in guard equality" do
+    case {1, 1..1} do
+      {n, range} when range == n..n//1 -> true
+    end
+  end
+
+  test "limits are integer only" do
+    first = 1.0
+    last = 3.0
+    message = "ranges (first..last) expect both sides to be integers, got: 1.0..3.0"
+    assert_raise ArgumentError, message, fn -> first..last end
+
+    first = []
+    last = []
+    message = "ranges (first..last) expect both sides to be integers, got: []..[]"
+    assert_raise ArgumentError, message, fn -> first..last end
+  end
+
+  test "step is a non-zero integer" do
+    step = 1.0
+    message = ~r"the step to be a non-zero integer"
+    assert_raise ArgumentError, message, fn -> 1..3//step end
+
+    step = 0
+    message = ~r"the step to be a non-zero integer"
+    assert_raise ArgumentError, message, fn -> 1..3//step end
+  end
+
+  describe "disjoint?" do
+    test "returns true for disjoint ranges" do
+      assert_disjoint(1..5, 6..9)
+      assert_disjoint(-3..1, 2..3)
+      assert_disjoint(-7..-5, -3..-1)
+
+      assert Range.disjoint?(1..1, 2..2) == true
+      assert Range.disjoint?(2..2, 1..1) == true
+    end
+
+    test "returns false for ranges with common endpoints" do
+      assert_overlap(1..5, 5..9)
+      assert_overlap(-1..0, 0..1)
+      assert_overlap(-7..-5, -5..-1)
+    end
+
+    test "returns false for ranges that overlap" do
+      assert_overlap(1..5, 3..7)
+      assert_overlap(-3..1, -1..3)
+      assert_overlap(-7..-5, -5..-1)
+
+      assert Range.disjoint?(1..1, 1..1) == false
+    end
+  end
+
+  describe "split" do
+    @times 10
+
+    test "increasing ranges" do
+      for _ <- 1..@times do
+        left = Enum.random(-10..10)
+        right = Enum.random(-10..10)
+        input = min(left, right)..max(left, right)//Enum.random(1..3)
+
+        for split <- -3..3 do
+          {left, right} = Range.split(input, split)
+          assert input.first == left.first
+          assert input.last == right.last
+          assert input.step == left.step
+          assert input.step == right.step
+
+          assert Range.size(input) == Range.size(left) + Range.size(right),
+                 "size mismatch: Range.split(#{inspect(input)}, #{split})"
+        end
+      end
+    end
+
+    test "decreasing ranges" do
+      for _ <- 1..@times do
+        left = Enum.random(-10..10)
+        right = Enum.random(-10..10)
+        input = max(left, right)..min(left, right)//-Enum.random(1..3)
+
+        for split <- -3..3 do
+          {left, right} = Range.split(input, split)
+          assert input.first == left.first
+          assert input.last == right.last
+          assert input.step == left.step
+          assert input.step == right.step
+
+          assert Range.size(input) == Range.size(left) + Range.size(right),
+                 "size mismatch: Range.split(#{inspect(input)}, #{split})"
+        end
+      end
+    end
+
+    test "empty increasing ranges" do
+      for _ <- 1..@times,
+          left = Enum.random(-10..10),
+          right = Enum.random(-10..10),
+          left != right do
+        input = min(left, right)..max(left, right)//-Enum.random(1..3)
+
+        for split <- -3..3 do
+          {left, right} = Range.split(input, split)
+          assert input.first == left.first
+          assert input.last == right.last
+          assert input.step == left.step
+          assert input.step == right.step
+
+          assert Range.size(input) == Range.size(left) + Range.size(right),
+                 "size mismatch: Range.split(#{inspect(input)}, #{split})"
+        end
+      end
+    end
+
+    test "empty decreasing ranges" do
+      for _ <- 1..@times,
+          left = Enum.random(-10..10),
+          right = Enum.random(-10..10),
+          left != right do
+        input = max(left, right)..min(left, right)//Enum.random(1..3)
+
+        for split <- -3..3 do
+          {left, right} = Range.split(input, split)
+          assert input.first == left.first
+          assert input.last == right.last
+          assert input.step == left.step
+          assert input.step == right.step
+
+          assert Range.size(input) == Range.size(left) + Range.size(right),
+                 "size mismatch: Range.split(#{inspect(input)}, #{split})"
+        end
+      end
+    end
+  end
+
+  describe "old ranges" do
+    test "enum" do
+      asc = %{__struct__: Range, first: 1, last: 3}
+      desc = %{__struct__: Range, first: 3, last: 1}
+
+      assert Enum.to_list(asc) == [1, 2, 3]
+      assert Enum.member?(asc, 2)
+      assert Enum.count(asc) == 3
+      assert Enum.drop(asc, 1) == [2, 3]
+      assert Enum.slice([1, 2, 3, 4, 5, 6], asc) == [2, 3, 4]
+      # testing private Enum.aggregate
+      assert Enum.max(asc) == 3
+      assert Enum.sum(asc) == 6
+      assert Enum.min_max(asc) == {1, 3}
+      assert Enum.reduce(asc, 0, fn a, b -> a + b end) == 6
+
+      assert Enum.to_list(desc) == [3, 2, 1]
+      assert Enum.member?(desc, 2)
+      assert Enum.count(desc) == 3
+      assert Enum.drop(desc, 1) == [2, 1]
+
+      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               assert Enum.slice([1, 2, 3, 4, 5, 6], desc) == []
+             end) =~ "negative steps are not supported in Enum.slice/2, pass 3..1//1 instead"
+
+      # testing private Enum.aggregate
+      assert Enum.max(desc) == 3
+      assert Enum.sum(desc) == 6
+      assert Enum.min_max(desc) == {1, 3}
+      assert Enum.reduce(desc, 0, fn a, b -> a + b end) == 6
+    end
+
+    test "string" do
+      asc = %{__struct__: Range, first: 1, last: 3}
+      desc = %{__struct__: Range, first: 3, last: 1}
+
+      assert String.slice("elixir", asc) == "lix"
+
+      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               assert String.slice("elixir", desc) == ""
+             end) =~ "negative steps are not supported in String.slice/2, pass 3..1//1 instead"
+    end
   end
 end
diff --git a/lib/elixir/test/elixir/record_test.exs b/lib/elixir/test/elixir/record_test.exs
index 4916b01d56b..90685d5d4bb 100644
--- a/lib/elixir/test/elixir/record_test.exs
+++ b/lib/elixir/test/elixir/record_test.exs
@@ -1,16 +1,31 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule RecordTest do
   use ExUnit.Case, async: true
 
   require Record
+  doctest Record
 
   test "extract/2 extracts information from an Erlang file" do
-    assert Record.extract(:file_info, from_lib: "kernel/include/file.hrl") ==
-           [size: :undefined, type: :undefined, access: :undefined, atime: :undefined,
-            mtime: :undefined, ctime: :undefined, mode: :undefined, links: :undefined,
-            major_device: :undefined, minor_device: :undefined, inode: :undefined,
-            uid: :undefined, gid: :undefined]
+    assert Record.extract(:file_info, from_lib: "kernel/include/file.hrl") == [
+             size: :undefined,
+             type: :undefined,
+             access: :undefined,
+             atime: :undefined,
+             mtime: :undefined,
+             ctime: :undefined,
+             mode: :undefined,
+             links: :undefined,
+             major_device: :undefined,
+             minor_device: :undefined,
+             inode: :undefined,
+             uid: :undefined,
+             gid: :undefined
+           ]
   end
 
   test "extract/2 handles nested records too" do
@@ -24,58 +39,251 @@ defmodule RecordTest do
       defstruct Record.extract(:file_info, from_lib: "kernel/include/file.hrl")
     end
 
-    assert %{__struct__: StructExtract, size: :undefined} =
-           StructExtract.__struct__
+    assert %{__struct__: StructExtract, size: :undefined} = StructExtract.__struct__()
+  end
+
+  test "extract_all/1 extracts all records information from an Erlang file" do
+    all_extract = Record.extract_all(from_lib: "kernel/include/file.hrl")
+    # has been stable over the very long time
+    assert length(all_extract) == 2
+    assert all_extract[:file_info]
+    assert all_extract[:file_descriptor]
   end
 
   # We need indirection to avoid warnings
   defp record?(data, kind) do
-    Record.record?(data, kind)
+    Record.is_record(data, kind)
   end
 
-  test "record?/2" do
-    assert record?({User, "jose", 27}, User)
-    refute record?({User, "jose", 27}, Author)
+  test "is_record/2" do
+    assert record?({User, "meg", 27}, User)
+    refute record?({User, "meg", 27}, Author)
     refute record?(13, Author)
+    refute record?({"user", "meg", 27}, "user")
+    refute record?({}, User)
+    refute record?([], User)
   end
 
   # We need indirection to avoid warnings
   defp record?(data) do
-    Record.record?(data)
+    Record.is_record(data)
   end
 
-  test "record?/1" do
-    assert record?({User, "jose", 27})
-    refute record?({"jose", 27})
+  test "is_record/1" do
+    assert record?({User, "john", 27})
+    refute record?({"john", 27})
     refute record?(13)
+    refute record?({})
+  end
+
+  def record_in_guard?(term) when Record.is_record(term), do: true
+  def record_in_guard?(_), do: false
+
+  def record_in_guard?(term, kind) when Record.is_record(term, kind), do: true
+  def record_in_guard?(_, _), do: false
+
+  test "is_record/1,2 (in guard)" do
+    assert record_in_guard?({User, "john", 27})
+    refute record_in_guard?({"user", "john", 27})
+
+    assert record_in_guard?({User, "john", 27}, User)
+    refute record_in_guard?({"user", "john", 27}, "user")
   end
 
-  Record.defrecord  :timestamp, [:date, :time]
-  Record.defrecord  :user, __MODULE__, name: "José", age: 25
-  Record.defrecordp :file_info, Record.extract(:file_info, from_lib: "kernel/include/file.hrl")
+  Record.defrecord(:timestamp, [:date, :time])
+  Record.defrecord(:user, __MODULE__, name: "john", age: 25)
+
+  Record.defrecordp(:file_info, Record.extract(:file_info, from_lib: "kernel/include/file.hrl"))
+
+  Record.defrecordp(
+    :certificate,
+    :OTPCertificate,
+    Record.extract(:OTPCertificate, from_lib: "public_key/include/public_key.hrl")
+  )
 
-  test "records generates macros that generates tuples" do
+  test "records are tagged" do
+    assert elem(file_info(), 0) == :file_info
+  end
+
+  test "records macros" do
     record = user()
-    assert user(record, :name) == "José"
-    assert user(record, :age)  == 25
+    assert user(record, :name) == "john"
+    assert user(record, :age) == 25
 
-    record = user(record, name: "Eric")
-    assert user(record, :name) == "Eric"
+    record = user(record, name: "meg")
+    assert user(record, :name) == "meg"
 
-    assert elem(record, user(:name)) == "Eric"
+    assert elem(record, user(:name)) == "meg"
     assert elem(record, 0) == RecordTest
 
     user(name: name) = record
-    assert name == "Eric"
+    assert name == "meg"
+
+    assert user(:name) == 1
   end
 
-  test "records with no tag" do
-    assert elem(file_info(), 0) == :file_info
+  test "records with default values" do
+    record = user(_: :_, name: "meg")
+    assert user(record, :name) == "meg"
+    assert user(record, :age) == :_
+    assert match?(user(_: _), user())
+  end
+
+  test "records preserve side-effects order" do
+    user =
+      user(
+        age: send(self(), :age),
+        name: send(self(), :name)
+      )
+
+    assert Process.info(self(), :messages) == {:messages, [:age, :name]}
+
+    _ =
+      user(user,
+        age: send(self(), :update_age),
+        name: send(self(), :update_name)
+      )
+
+    assert Process.info(self(), :messages) ==
+             {:messages, [:age, :name, :update_age, :update_name]}
+  end
+
+  test "nested records preserve side-effects order" do
+    user =
+      user(
+        age:
+          user(
+            age: send(self(), :inner_age),
+            name: send(self(), :inner_name)
+          ),
+        name: send(self(), :name)
+      )
+
+    assert user == {RecordTest, :name, {RecordTest, :inner_name, :inner_age}}
+    assert for(_ <- 1..3, do: assert_receive(_)) == [:inner_age, :inner_name, :name]
+
+    user =
+      user(
+        name: send(self(), :name),
+        age:
+          user(
+            age: send(self(), :inner_age),
+            name: send(self(), :inner_name)
+          )
+      )
+
+    assert user == {RecordTest, :name, {RecordTest, :inner_name, :inner_age}}
+    assert for(_ <- 1..3, do: assert_receive(_)) == [:name, :inner_age, :inner_name]
+  end
+
+  Record.defrecord(
+    :defaults,
+    struct: ~D[2016-01-01],
+    map: %{},
+    tuple_zero: {},
+    tuple_one: {1},
+    tuple_two: {1, 2},
+    tuple_three: {1, 2, 3},
+    list: [1, 2, 3],
+    call: MapSet.new(),
+    string: "abc",
+    binary: <<1, 2, 3>>,
+    charlist: ~c"abc"
+  )
+
+  test "records with literal defaults and on-the-fly record" do
+    assert defaults(defaults()) == [
+             struct: ~D[2016-01-01],
+             map: %{},
+             tuple_zero: {},
+             tuple_one: {1},
+             tuple_two: {1, 2},
+             tuple_three: {1, 2, 3},
+             list: [1, 2, 3],
+             call: MapSet.new(),
+             string: "abc",
+             binary: <<1, 2, 3>>,
+             charlist: ~c"abc"
+           ]
+
+    assert defaults(defaults(), :struct) == ~D[2016-01-01]
+    assert defaults(defaults(), :map) == %{}
+    assert defaults(defaults(), :tuple_zero) == {}
+    assert defaults(defaults(), :tuple_one) == {1}
+    assert defaults(defaults(), :tuple_two) == {1, 2}
+    assert defaults(defaults(), :tuple_three) == {1, 2, 3}
+    assert defaults(defaults(), :list) == [1, 2, 3]
+    assert defaults(defaults(), :call) == MapSet.new()
+    assert defaults(defaults(), :string) == "abc"
+    assert defaults(defaults(), :binary) == <<1, 2, 3>>
+    assert defaults(defaults(), :charlist) == ~c"abc"
+  end
+
+  test "records with literal defaults and record in a variable" do
+    defaults = defaults()
+
+    assert defaults(defaults) == [
+             struct: ~D[2016-01-01],
+             map: %{},
+             tuple_zero: {},
+             tuple_one: {1},
+             tuple_two: {1, 2},
+             tuple_three: {1, 2, 3},
+             list: [1, 2, 3],
+             call: MapSet.new(),
+             string: "abc",
+             binary: <<1, 2, 3>>,
+             charlist: ~c"abc"
+           ]
+
+    assert defaults(defaults, :struct) == ~D[2016-01-01]
+    assert defaults(defaults, :map) == %{}
+    assert defaults(defaults, :tuple_zero) == {}
+    assert defaults(defaults, :tuple_one) == {1}
+    assert defaults(defaults, :tuple_two) == {1, 2}
+    assert defaults(defaults, :tuple_three) == {1, 2, 3}
+    assert defaults(defaults, :list) == [1, 2, 3]
+    assert defaults(defaults, :call) == MapSet.new()
+    assert defaults(defaults, :string) == "abc"
+    assert defaults(defaults, :binary) == <<1, 2, 3>>
+    assert defaults(defaults, :charlist) == ~c"abc"
   end
 
   test "records with dynamic arguments" do
     record = file_info()
     assert file_info(record, :size) == :undefined
+
+    record = user()
+    assert user(record) == [name: "john", age: 25]
+    assert user(user()) == [name: "john", age: 25]
+
+    msg =
+      "expected argument to be a literal atom, literal keyword or a :file_info record, " <>
+        "got runtime: {RecordTest, \"john\", 25}"
+
+    assert_raise ArgumentError, msg, fn ->
+      file_info(record)
+    end
+
+    pretender = {RecordTest, "john"}
+
+    msg =
+      "expected argument to be a RecordTest record with 2 fields, " <>
+        "got: {RecordTest, \"john\"}"
+
+    assert_raise ArgumentError, msg, fn ->
+      user(pretender)
+    end
+
+    pretender = {RecordTest, "john", 25, []}
+
+    msg =
+      "expected argument to be a RecordTest record with 2 fields, " <>
+        "got: {RecordTest, \"john\", 25, []}"
+
+    assert_raise ArgumentError, msg, fn ->
+      user(pretender)
+    end
   end
 
   test "records visibility" do
@@ -83,6 +291,12 @@ defmodule RecordTest do
     refute macro_exported?(__MODULE__, :file_info, 1)
   end
 
+  test "records reflection" do
+    assert %{fields: [:name, :age], kind: :defrecord, name: :user, tag: RecordTest} in @__records__
+
+    assert %{fields: [:date, :time], kind: :defrecord, name: :timestamp, tag: :timestamp} in @__records__
+  end
+
   test "records with no defaults" do
     record = timestamp()
     assert timestamp(record, :date) == nil
@@ -92,4 +306,94 @@ defmodule RecordTest do
     assert timestamp(record, :date) == :foo
     assert timestamp(record, :time) == :bar
   end
+
+  test "records defined multiple times" do
+    msg = "cannot define record :r because a definition r/0 already exists"
+
+    assert_raise ArgumentError, msg, fn ->
+      defmodule M do
+        import Record
+        defrecord :r, [:a]
+        defrecord :r, [:a]
+      end
+    end
+  end
+
+  test "macro and record with the same name defined" do
+    msg = "cannot define record :a because a definition a/1 already exists"
+
+    assert_raise ArgumentError, msg, fn ->
+      defmodule M do
+        defmacro a(_) do
+        end
+
+        require Record
+        Record.defrecord(:a, [:a])
+      end
+    end
+
+    msg = "cannot define record :a because a definition a/2 already exists"
+
+    assert_raise ArgumentError, msg, fn ->
+      defmodule M do
+        defmacro a(_, _) do
+        end
+
+        require Record
+        Record.defrecord(:a, [:a])
+      end
+    end
+  end
+
+  test "docs metadata" do
+    import PathHelpers
+
+    write_beam(
+      defmodule Metadata do
+        Record.defrecord(:user, foo: 0, bar: "baz")
+      end
+    )
+
+    {:docs_v1, 352, :elixir, "text/markdown", _, %{}, docs} = Code.fetch_docs(RecordTest.Metadata)
+    {{:macro, :user, 1}, _meta, _sig, _docs, metadata} = List.keyfind(docs, {:macro, :user, 1}, 0)
+    assert %{record: {:user, [foo: 0, bar: "baz"]}} = metadata
+  end
+
+  describe "warnings" do
+    import ExUnit.CaptureIO
+
+    test "warns on bad record update input" do
+      assert capture_io(:stderr, fn ->
+               defmodule RecordSample do
+                 require Record
+                 Record.defrecord(:user, __MODULE__, name: "john", age: 25)
+
+                 def fun do
+                   user(user(), _: :_, name: "meg")
+                 end
+               end
+             end) =~
+               "updating a record with a default (:_) is equivalent to creating a new record"
+    after
+      purge(RecordSample)
+    end
+
+    test "defrecord warns with duplicate keys" do
+      assert capture_io(:stderr, fn ->
+               Code.eval_string("""
+               defmodule RecordSample do
+                 import Record
+                 defrecord :r, [:foo, :bar, foo: 1]
+               end
+               """)
+             end) =~ "duplicate key :foo found in record"
+    after
+      purge(RecordSample)
+    end
+
+    defp purge(module) when is_atom(module) do
+      :code.purge(module)
+      :code.delete(module)
+    end
+  end
 end
diff --git a/lib/elixir/test/elixir/regex_test.exs b/lib/elixir/test/elixir/regex_test.exs
index 702c7594f66..926c53435c1 100644
--- a/lib/elixir/test/elixir/regex_test.exs
+++ b/lib/elixir/test/elixir/regex_test.exs
@@ -1,47 +1,80 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule RegexTest do
   use ExUnit.Case, async: true
 
-  test :multiline do
-    refute Regex.match?(~r/^b$/, "a\nb\nc")
-    assert Regex.match?(~r/^b$/m, "a\nb\nc")
+  doctest Regex
+
+  test "module attribute" do
+    defmodule ModAttr do
+      @regex ~r/example/
+      def regex, do: @regex
+
+      @bare_regex :erlang.term_to_binary(@regex)
+      def bare_regex, do: :erlang.binary_to_term(@bare_regex)
+
+      # We don't rewrite outside of functions
+      assert @regex.re_pattern == :erlang.binary_to_term(@bare_regex).re_pattern
+    end
+
+    if System.otp_release() >= "28" do
+      assert ModAttr.regex().re_pattern != ModAttr.bare_regex().re_pattern
+    else
+      assert ModAttr.regex().re_pattern == ModAttr.bare_regex().re_pattern
+    end
   end
 
-  test :precedence do
-    assert {"aa", :unknown} |> elem(0) =~ ~r/(a)\1/
+  @tag :re_import
+  test "module attribute in match context" do
+    assert_raise(
+      ArgumentError,
+      ~r/escaped Regex structs are not allowed in match or guards/,
+      fn ->
+        Code.eval_quoted(
+          quote do
+            defmodule ModAttrGuard do
+              @regex ~r/example/
+              def example?(@regex), do: true
+              def example?(_), do: false
+            end
+          end
+        )
+      end
+    )
   end
 
-  test :backreference do
-    assert "aa" =~ ~r/(a)\1/
+  test "multiline" do
+    refute Regex.match?(~r/^b$/, "a\nb\nc")
+    assert Regex.match?(~r/^b$/m, "a\nb\nc")
   end
 
-  test :compile! do
-    assert Regex.regex?(Regex.compile!("foo"))
+  @tag :re_import
+  test "export" do
+    # exported patterns have no structs, so these are structurally equal
+    assert ~r/foo/E == Regex.compile!("foo", [:export])
 
-    assert_raise Regex.CompileError, ~r/position 0$/, fn ->
-      Regex.compile!("*foo")
-    end
-  end
+    assert Regex.match?(~r/foo/E, "foo")
+    refute Regex.match?(~r/foo/E, "Foo")
 
-  test :compile do
-    {:ok, regex} = Regex.compile("foo")
-    assert Regex.regex?(regex)
-    assert {:error, _} = Regex.compile("*foo")
-    assert {:error, _} = Regex.compile("foo", "y")
+    assert Regex.run(~r/c(d)/E, "abcd") == ["cd", "d"]
+    assert Regex.run(~r/e/E, "abcd") == nil
+
+    assert Regex.names(~r/(?<FOO>foo)/E) == ["FOO"]
   end
 
-  test :compile_with_erl_opts do
-    {:ok, regex} = Regex.compile("foo\\sbar", [:dotall, {:newline, :anycrlf}])
-    assert "foo\nbar" =~ regex
+  test "precedence" do
+    assert {"aa", :unknown} |> elem(0) =~ ~r/(a)\1/
   end
 
-  test :regex? do
-    assert Regex.regex?(~r/foo/)
-    refute Regex.regex?(0)
+  test "backreference" do
+    assert "aa" =~ ~r/(a)\1/
   end
 
-  test :source do
+  test "source" do
     src = "foo"
     assert Regex.source(Regex.compile!(src)) == src
     assert Regex.source(~r/#{src}/) == src
@@ -55,53 +88,85 @@ defmodule RegexTest do
     assert Regex.source(~r/#{src}/) == src
   end
 
-  test :literal_source do
+  test "literal source" do
     assert Regex.source(Regex.compile!("foo")) == "foo"
     assert Regex.source(~r"foo") == "foo"
-    assert Regex.re_pattern(Regex.compile!("foo"))
-           == Regex.re_pattern(~r"foo")
 
     assert Regex.source(Regex.compile!("\a\b\d\e\f\n\r\s\t\v")) == "\a\b\d\e\f\n\r\s\t\v"
-    assert Regex.source(~r<\a\b\d\e\f\n\r\s\t\v>) == "\a\\b\\d\\e\f\n\r\\s\t\v"
-    assert Regex.re_pattern(Regex.compile!("\a\b\d\e\f\n\r\s\t\v"))
-           == Regex.re_pattern(~r"\a\010\177\033\f\n\r \t\v")
+    assert Regex.source(~r<\a\b\d\e\f\n\r\s\t\v>) == "\\a\\b\\d\\e\\f\\n\\r\\s\\t\\v"
+  end
+
+  test "Unicode" do
+    assert "olá" =~ ~r"\p{Latin}$"u
+    refute "£" =~ ~r/\p{Lu}/u
 
-    assert Regex.source(Regex.compile!("\a\\b\\d\e\f\n\r\\s\t\v")) == "\a\\b\\d\e\f\n\r\\s\t\v"
-    assert Regex.source(~r<\a\\b\\d\\e\f\n\r\\s\t\v>) == "\a\\\\b\\\\d\\\\e\f\n\r\\\\s\t\v"
-    assert Regex.re_pattern(Regex.compile!("\a\\b\\d\e\f\n\r\\s\t\v"))
-           == Regex.re_pattern(~r"\a\b\d\e\f\n\r\s\t\v")
+    # Non breaking space matches [[:space:]] with Unicode
+    assert <<0xA0::utf8>> =~ ~r/[[:space:]]/u
+    assert <<0xA0::utf8>> =~ ~r/\s/u
+    assert <<?<, 255, ?>>> =~ ~r/<.>/
   end
 
-  test :opts do
-    assert Regex.opts(Regex.compile!("foo", "i")) == "i"
+  test "ungreedy" do
+    assert Regex.run(~r/[\d ]+/, "1 2 3 4 5"), ["1 2 3 4 5"]
+    assert Regex.run(~r/[\d ]?+/, "1 2 3 4 5"), ["1"]
+    assert Regex.run(~r/[\d ]+/U, "1 2 3 4 5"), ["1"]
   end
 
-  test :unicode do
-    assert "josé" =~ ~r"\p{Latin}$"u
-    refute "£" =~ ~r/\p{Lu}/u
+  test "compile/1" do
+    {:ok, %Regex{}} = Regex.compile("foo")
+    assert {:error, _} = Regex.compile("*foo")
+    assert {:error, _} = Regex.compile("foo", "y")
+    assert {:error, _} = Regex.compile("foo", "uy")
+  end
 
-    assert <<?<, 255, ?>>> =~ ~r/<.>/
-    refute <<?<, 255, ?>>> =~ ~r/<.>/u
+  test "compile/1 with Erlang options" do
+    {:ok, regex} = Regex.compile("foo\\sbar", [:dotall, {:newline, :anycrlf}])
+    assert "foo\nbar" =~ regex
+  end
+
+  test "compile!/1" do
+    assert %Regex{} = Regex.compile!("foo")
+
+    assert_raise Regex.CompileError, ~r/position 0$/, fn ->
+      Regex.compile!("*foo")
+    end
+  end
+
+  test "import/1" do
+    # no-op for non-exported regexes
+    regex = ~r/foo/
+    assert Regex.import(regex) == regex
+
+    imported = Regex.import(~r/foo/E)
+
+    assert imported.opts == []
+    assert "foo" =~ imported
+    assert {:re_pattern, _, _, _, _} = imported.re_pattern
   end
 
-  test :names do
+  test "opts/1" do
+    assert Regex.opts(Regex.compile!("foo", "i")) == [:caseless]
+    assert Regex.opts(Regex.compile!("foo", [:ucp])) == [:ucp]
+  end
+
+  test "names/1" do
     assert Regex.names(~r/(?<FOO>foo)/) == ["FOO"]
   end
 
-  test :match? do
+  test "match?/2" do
     assert Regex.match?(~r/foo/, "foo")
     refute Regex.match?(~r/foo/, "FOO")
     assert Regex.match?(~r/foo/i, "FOO")
     assert Regex.match?(~r/\d{1,3}/i, "123")
 
-    assert Regex.match?(~r/foo/,   "afooa")
+    assert Regex.match?(~r/foo/, "afooa")
     refute Regex.match?(~r/^foo/, "afooa")
-    assert Regex.match?(~r/^foo/,  "fooa")
+    assert Regex.match?(~r/^foo/, "fooa")
     refute Regex.match?(~r/foo$/, "afooa")
-    assert Regex.match?(~r/foo$/,  "afoo")
+    assert Regex.match?(~r/foo$/, "afoo")
   end
 
-  test :named_captures do
+  test "named_captures/2" do
     assert Regex.named_captures(~r/(?<foo>c)(?<bar>d)/, "abcd") == %{"bar" => "d", "foo" => "c"}
     assert Regex.named_captures(~r/c(?<foo>d)/, "abcd") == %{"foo" => "d"}
     assert Regex.named_captures(~r/c(?<foo>d)/, "no_match") == nil
@@ -109,61 +174,142 @@ defmodule RegexTest do
     assert Regex.named_captures(~r/c(.)/, "cat") == %{}
   end
 
-  test :sigil_R do
-    assert Regex.match?(~R/f#{1,3}o/, "f#o")
-  end
-
-  test :run do
+  test "run/2" do
     assert Regex.run(~r"c(d)", "abcd") == ["cd", "d"]
     assert Regex.run(~r"e", "abcd") == nil
   end
 
-  test :run_with_all_names do
+  test "run/3 with :all_names as the value of the :capture option" do
     assert Regex.run(~r/c(?<foo>d)/, "abcd", capture: :all_names) == ["d"]
     assert Regex.run(~r/c(?<foo>d)/, "no_match", capture: :all_names) == nil
     assert Regex.run(~r/c(?<foo>d|e)/, "abcd abce", capture: :all_names) == ["d"]
   end
 
-  test :run_with_indexes do
+  test "run/3 with :index as the value of the :return option" do
     assert Regex.run(~r"c(d)", "abcd", return: :index) == [{2, 2}, {3, 1}]
     assert Regex.run(~r"e", "abcd", return: :index) == nil
   end
 
-  test :scan do
+  test "run/3 with :offset" do
+    assert Regex.run(~r"^foo", "foobar", offset: 0) == ["foo"]
+    assert Regex.run(~r"^foo", "foobar", offset: 2) == nil
+    assert Regex.run(~r"^foo", "foobar", offset: 2, return: :index) == nil
+    assert Regex.run(~r"bar", "foobar", offset: 2, return: :index) == [{3, 3}]
+  end
+
+  test "scan/2" do
     assert Regex.scan(~r"c(d|e)", "abcd abce") == [["cd", "d"], ["ce", "e"]]
     assert Regex.scan(~r"c(?:d|e)", "abcd abce") == [["cd"], ["ce"]]
     assert Regex.scan(~r"e", "abcd") == []
   end
 
-  test :scan_with_all_names do
+  test "scan/2 with :all_names as the value of the :capture option" do
     assert Regex.scan(~r/cd/, "abcd", capture: :all_names) == []
     assert Regex.scan(~r/c(?<foo>d)/, "abcd", capture: :all_names) == [["d"]]
     assert Regex.scan(~r/c(?<foo>d)/, "no_match", capture: :all_names) == []
     assert Regex.scan(~r/c(?<foo>d|e)/, "abcd abce", capture: :all_names) == [["d"], ["e"]]
   end
 
-  test :split do
+  test "scan/2 with :offset" do
+    assert Regex.scan(~r"^foo", "foobar", offset: 0) == [["foo"]]
+    assert Regex.scan(~r"^foo", "foobar", offset: 1) == []
+  end
+
+  test "split/2,3" do
     assert Regex.split(~r",", "") == [""]
+    assert Regex.split(~r",", "", trim: true) == []
+    assert Regex.split(~r",", "", trim: true, parts: 2) == []
+
+    assert Regex.split(~r"=", "key=") == ["key", ""]
+    assert Regex.split(~r"=", "=value") == ["", "value"]
+
     assert Regex.split(~r" ", "foo bar baz") == ["foo", "bar", "baz"]
-    assert Regex.split(~r" ", "foo bar baz", parts: 0) == ["foo", "bar", "baz"]
     assert Regex.split(~r" ", "foo bar baz", parts: :infinity) == ["foo", "bar", "baz"]
     assert Regex.split(~r" ", "foo bar baz", parts: 10) == ["foo", "bar", "baz"]
     assert Regex.split(~r" ", "foo bar baz", parts: 2) == ["foo", "bar baz"]
-    assert Regex.split(~r"\s", "foobar") == ["foobar"]
+
     assert Regex.split(~r" ", " foo bar baz ") == ["", "foo", "bar", "baz", ""]
     assert Regex.split(~r" ", " foo bar baz ", trim: true) == ["foo", "bar", "baz"]
-    assert Regex.split(~r"=", "key=") == ["key", ""]
-    assert Regex.split(~r"=", "=value") == ["", "value"]
+    assert Regex.split(~r" ", " foo bar baz ", parts: 2) == ["", "foo bar baz "]
+    assert Regex.split(~r" ", " foo bar baz ", trim: true, parts: 2) == ["foo", "bar baz "]
+
+    assert Regex.split(~r/b\K/, "ababab") == ["ab", "ab", "ab", ""]
+  end
+
+  test "split/3 with the :on option" do
+    assert Regex.split(~r/()abc()/, "xabcxabcx", on: :none) == ["xabcxabcx"]
+
+    parts = ["x", "abc", "x", "abc", "x"]
+    assert Regex.split(~r/()abc()/, "xabcxabcx", on: :all_but_first) == parts
+
+    assert Regex.split(~r/(?<first>)abc(?<last>)/, "xabcxabcx", on: [:first, :last]) == parts
+
+    parts = ["xabc", "xabc", "x"]
+    assert Regex.split(~r/(?<first>)abc(?<last>)/, "xabcxabcx", on: [:last, :first]) == parts
+
+    assert Regex.split(~r/a(?<second>b)c/, "abc", on: [:second]) == ["a", "c"]
+
+    parts = ["a", "c adc a", "c"]
+    assert Regex.split(~r/a(?<second>b)c|a(?<fourth>d)c/, "abc adc abc", on: [:second]) == parts
+
+    assert Regex.split(~r/a(?<second>b)c|a(?<fourth>d)c/, "abc adc abc", on: [:second, :fourth]) ==
+             ["a", "c a", "c a", "c"]
   end
 
-  test :replace do
-    assert Regex.replace(~r(d), "abc", "d") == "abc"
-    assert Regex.replace(~r(b), "abc", "d") == "adc"
-    assert Regex.replace(~r(b), "abc", "[\\0]") == "a[b]c"
+  test "split/3 with the :include_captures option" do
+    assert Regex.split(~r/([ln])/, "Erlang", include_captures: true) == ["Er", "l", "a", "n", "g"]
+    assert Regex.split(~r/([kw])/, "Elixir", include_captures: true) == ["Elixir"]
+
+    assert Regex.split(~r/([Ee]lixir)/, "Elixir", include_captures: true, trim: true) ==
+             ["Elixir"]
+
+    assert Regex.split(~r/([Ee]lixir)/, "Elixir", include_captures: true, trim: false) ==
+             ["", "Elixir", ""]
+
+    assert Regex.split(~r//, "abc", include_captures: true) ==
+             ["", "", "a", "", "b", "", "c", "", ""]
+
+    assert Regex.split(~r/a/, "abc", include_captures: true) == ["", "a", "bc"]
+    assert Regex.split(~r/c/, "abc", include_captures: true) == ["ab", "c", ""]
+
+    assert Regex.split(~r/[Ei]/, "Elixir", include_captures: true, parts: 2) ==
+             ["", "E", "lixir"]
+
+    assert Regex.split(~r/[Ei]/, "Elixir", include_captures: true, parts: 3) ==
+             ["", "E", "l", "i", "xir"]
+
+    assert Regex.split(~r/[Ei]/, "Elixir", include_captures: true, parts: 2, trim: true) ==
+             ["E", "lixir"]
+
+    assert Regex.split(~r/[Ei]/, "Elixir", include_captures: true, parts: 3, trim: true) ==
+             ["E", "l", "i", "xir"]
+
+    assert Regex.split(~r/b\Kc/, "abcabc", include_captures: true) == ["ab", "c", "ab", "c", ""]
+    assert Regex.split(~r/(b\K)/, "abab", include_captures: true) == ["ab", "", "ab", "", ""]
+
+    assert Regex.split(~r/(b\K)/, "abab", include_captures: true, trim: true) == [
+             "ab",
+             "",
+             "ab",
+             ""
+           ]
+  end
+
+  test "replace/3,4" do
+    assert Regex.replace(~r/d/, "abc", "d") == "abc"
+    assert Regex.replace(~r/b/, "abc", "d") == "adc"
+    assert Regex.replace(~r/b/, "abc", "[\\0]") == "a[b]c"
     assert Regex.replace(~r[(b)], "abc", "[\\1]") == "a[b]c"
+    assert Regex.replace(~r[(b)], "abc", "[\\2]") == "a[]c"
+    assert Regex.replace(~r[(b)], "abc", "[\\3]") == "a[]c"
+    assert Regex.replace(~r/b/, "abc", "[\\g{0}]") == "a[b]c"
+    assert Regex.replace(~r[(b)], "abc", "[\\g{1}]") == "a[b]c"
+
+    assert Regex.replace(~r/b/, "abcbe", "d") == "adcde"
+    assert Regex.replace(~r/b/, "abcbe", "d", global: false) == "adcbe"
 
-    assert Regex.replace(~r(b), "abcbe", "d") == "adcde"
-    assert Regex.replace(~r(b), "abcbe", "d", global: false) == "adcbe"
+    assert Regex.replace(~r/ /, "first third", "\\second\\") == "first\\second\\third"
+    assert Regex.replace(~r/ /, "first third", "\\\\second\\\\") == "first\\second\\third"
 
     assert Regex.replace(~r[a(b)c], "abcabc", fn -> "ac" end) == "acac"
     assert Regex.replace(~r[a(b)c], "abcabc", fn "abc" -> "ac" end) == "acac"
@@ -172,7 +318,7 @@ defmodule RegexTest do
     assert Regex.replace(~r[a(b)c], "abcabc", fn "abc", "b" -> "ac" end, global: false) == "acabc"
   end
 
-  test :escape do
+  test "escape" do
     assert matches_escaped?(".")
     refute matches_escaped?(".", "x")
 
@@ -190,10 +336,18 @@ defmodule RegexTest do
 
     assert matches_escaped?("\\A  \\z")
     assert matches_escaped?("  x  ")
-    assert matches_escaped?("  x    x ") # unicode spaces here
+    # Unicode spaces here
+    assert matches_escaped?("  x    x ")
     assert matches_escaped?("# lol")
 
-    assert matches_escaped?("\\A.^$*+?()[{\\| \t\n\xff\\z #hello\x{202F}\x{205F}")
+    assert matches_escaped?("\\A.^$*+?()[{\\| \t\n\x20\\z #hello\u202F\u205F")
+    assert Regex.match?(Regex.compile!("[" <> Regex.escape("!-#") <> "]"), "-")
+
+    assert Regex.escape("{}") == "\\{\\}"
+    assert Regex.escape("[]") == "\\[\\]"
+
+    assert Regex.escape("{foo}") == "\\{foo\\}"
+    assert Regex.escape("[foo]") == "\\[foo\\]"
   end
 
   defp matches_escaped?(string) do
@@ -201,6 +355,6 @@ defmodule RegexTest do
   end
 
   defp matches_escaped?(string, match) do
-    Regex.match? ~r/#{Regex.escape(string)}/simxu, match
+    Regex.match?(~r/#{Regex.escape(string)}/simx, match)
   end
 end
diff --git a/lib/elixir/test/elixir/registry/duplicate_test.exs b/lib/elixir/test/elixir/registry/duplicate_test.exs
new file mode 100644
index 00000000000..00f1c6191a5
--- /dev/null
+++ b/lib/elixir/test/elixir/registry/duplicate_test.exs
@@ -0,0 +1,504 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Registry.DuplicateTest do
+  use ExUnit.Case,
+    async: true,
+    parameterize:
+      for(
+        keys <- [:duplicate, {:duplicate, :pid}, {:duplicate, :key}],
+        partitions <- [1, 8],
+        do: %{keys: keys, partitions: partitions}
+      )
+
+  setup config do
+    keys = config.keys
+    partitions = config.partitions
+
+    listeners =
+      List.wrap(config[:base_listener]) |> Enum.map(&:"#{&1}_#{partitions}_#{inspect(keys)}")
+
+    name = :"#{config.test}_#{partitions}_#{inspect(keys)}"
+    opts = [keys: config.keys, name: name, partitions: partitions, listeners: listeners]
+    {:ok, _} = start_supervised({Registry, opts})
+    %{registry: name, listeners: listeners}
+  end
+
+  test "starts configured number of partitions", %{registry: registry, partitions: partitions} do
+    assert length(Supervisor.which_children(registry)) == partitions
+  end
+
+  test "counts 0 keys in an empty registry", %{registry: registry} do
+    assert 0 == Registry.count(registry)
+  end
+
+  test "counts the number of keys in a registry", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    {:ok, _} = Registry.register(registry, "hello", :value)
+
+    assert 2 == Registry.count(registry)
+  end
+
+  test "has duplicate registrations", %{registry: registry} do
+    {:ok, pid} = Registry.register(registry, "hello", :value)
+    assert is_pid(pid)
+    assert Registry.keys(registry, self()) == ["hello"]
+    assert Registry.values(registry, "hello", self()) == [:value]
+
+    assert {:ok, pid} = Registry.register(registry, "hello", :value)
+    assert is_pid(pid)
+    assert Registry.keys(registry, self()) == ["hello", "hello"]
+    assert Registry.values(registry, "hello", self()) == [:value, :value]
+
+    {:ok, pid} = Registry.register(registry, "world", :value)
+    assert is_pid(pid)
+    assert Registry.keys(registry, self()) |> Enum.sort() == ["hello", "hello", "world"]
+  end
+
+  test "has duplicate registrations across processes", %{registry: registry} do
+    {_, task} = register_task(registry, "hello", :world)
+    assert Registry.keys(registry, self()) == []
+    assert Registry.keys(registry, task) == ["hello"]
+    assert Registry.values(registry, "hello", self()) == []
+    assert Registry.values(registry, "hello", task) == [:world]
+
+    assert {:ok, _pid} = Registry.register(registry, "hello", :value)
+    assert Registry.keys(registry, self()) == ["hello"]
+    assert Registry.values(registry, "hello", self()) == [:value]
+  end
+
+  test "compares using matches", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, 1.0, :value)
+    {:ok, _} = Registry.register(registry, 1, :value)
+    assert Registry.keys(registry, self()) |> Enum.sort() == [1, 1.0]
+  end
+
+  test "dispatches to multiple keys in serial", %{registry: registry} do
+    Process.flag(:trap_exit, true)
+    parent = self()
+
+    fun = fn _ -> raise "will never be invoked" end
+    assert Registry.dispatch(registry, "hello", fun, parallel: false) == :ok
+
+    {:ok, _} = Registry.register(registry, "hello", :value1)
+    {:ok, _} = Registry.register(registry, "hello", :value2)
+    {:ok, _} = Registry.register(registry, "world", :value3)
+
+    fun = fn entries ->
+      assert parent == self()
+      for {pid, value} <- entries, do: send(pid, {:dispatch, value})
+    end
+
+    assert Registry.dispatch(registry, "hello", fun, parallel: false)
+
+    assert_received {:dispatch, :value1}
+    assert_received {:dispatch, :value2}
+    refute_received {:dispatch, :value3}
+
+    fun = fn entries ->
+      assert parent == self()
+      for {pid, value} <- entries, do: send(pid, {:dispatch, value})
+    end
+
+    assert Registry.dispatch(registry, "world", fun, parallel: false)
+
+    refute_received {:dispatch, :value1}
+    refute_received {:dispatch, :value2}
+    assert_received {:dispatch, :value3}
+
+    refute_received {:EXIT, _, _}
+  end
+
+  test "dispatches to multiple keys in parallel", context do
+    %{registry: registry, partitions: partitions} = context
+    Process.flag(:trap_exit, true)
+    parent = self()
+
+    fun = fn _ -> raise "will never be invoked" end
+    assert Registry.dispatch(registry, "hello", fun, parallel: true) == :ok
+
+    {:ok, _} = Registry.register(registry, "hello", :value1)
+    {:ok, _} = Registry.register(registry, "hello", :value2)
+    {:ok, _} = Registry.register(registry, "world", :value3)
+
+    fun = fn entries ->
+      if partitions == 8 do
+        assert parent != self()
+      else
+        assert parent == self()
+      end
+
+      for {pid, value} <- entries, do: send(pid, {:dispatch, value})
+    end
+
+    assert Registry.dispatch(registry, "hello", fun, parallel: true)
+
+    assert_received {:dispatch, :value1}
+    assert_received {:dispatch, :value2}
+    refute_received {:dispatch, :value3}
+
+    fun = fn entries ->
+      if partitions == 8 do
+        assert parent != self()
+      else
+        assert parent == self()
+      end
+
+      for {pid, value} <- entries, do: send(pid, {:dispatch, value})
+    end
+
+    assert Registry.dispatch(registry, "world", fun, parallel: true)
+
+    refute_received {:dispatch, :value1}
+    refute_received {:dispatch, :value2}
+    assert_received {:dispatch, :value3}
+
+    refute_received {:EXIT, _, _}
+  end
+
+  test "unregisters by key", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    {:ok, _} = Registry.register(registry, "world", :value)
+    assert Registry.keys(registry, self()) |> Enum.sort() == ["hello", "hello", "world"]
+
+    :ok = Registry.unregister(registry, "hello")
+    assert Registry.keys(registry, self()) == ["world"]
+
+    :ok = Registry.unregister(registry, "world")
+    assert Registry.keys(registry, self()) == []
+  end
+
+  test "unregisters with no entries", %{registry: registry} do
+    assert Registry.unregister(registry, "hello") == :ok
+  end
+
+  test "unregisters with tricky keys", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, :_, :foo)
+    {:ok, _} = Registry.register(registry, :_, :bar)
+    {:ok, _} = Registry.register(registry, "hello", "a")
+    {:ok, _} = Registry.register(registry, "hello", "b")
+
+    Registry.unregister(registry, :_)
+    assert Registry.keys(registry, self()) |> Enum.sort() == ["hello", "hello"]
+  end
+
+  test "supports match patterns", %{registry: registry} do
+    value1 = {1, :atom, 1}
+    value2 = {2, :atom, 2}
+
+    {:ok, _} = Registry.register(registry, "hello", value1)
+    {:ok, _} = Registry.register(registry, "hello", value2)
+
+    assert Registry.match(registry, "hello", {1, :_, :_}) == [{self(), value1}]
+    assert Registry.match(registry, "hello", {1.0, :_, :_}) == []
+
+    assert Registry.match(registry, "hello", {:_, :atom, :_}) |> Enum.sort() ==
+             [{self(), value1}, {self(), value2}]
+
+    assert Registry.match(registry, "hello", {:"$1", :_, :"$1"}) |> Enum.sort() ==
+             [{self(), value1}, {self(), value2}]
+
+    assert Registry.match(registry, "hello", {2, :_, :_}) == [{self(), value2}]
+    assert Registry.match(registry, "hello", {2.0, :_, :_}) == []
+  end
+
+  test "supports guards", %{registry: registry} do
+    value1 = {1, :atom, 1}
+    value2 = {2, :atom, 2}
+
+    {:ok, _} = Registry.register(registry, "hello", value1)
+    {:ok, _} = Registry.register(registry, "hello", value2)
+
+    assert Registry.match(registry, "hello", {:"$1", :_, :_}, [{:<, :"$1", 2}]) ==
+             [{self(), value1}]
+
+    assert Registry.match(registry, "hello", {:"$1", :_, :_}, [{:>, :"$1", 3}]) == []
+
+    assert Registry.match(registry, "hello", {:"$1", :_, :_}, [{:<, :"$1", 3}]) |> Enum.sort() ==
+             [{self(), value1}, {self(), value2}]
+
+    assert Registry.match(registry, "hello", {:_, :"$1", :_}, [{:is_atom, :"$1"}])
+           |> Enum.sort() == [{self(), value1}, {self(), value2}]
+  end
+
+  test "count_match supports match patterns", %{registry: registry} do
+    value = {1, :atom, 1}
+    {:ok, _} = Registry.register(registry, "hello", value)
+    assert 1 == Registry.count_match(registry, "hello", {1, :_, :_})
+    assert 0 == Registry.count_match(registry, "hello", {1.0, :_, :_})
+    assert 1 == Registry.count_match(registry, "hello", {:_, :atom, :_})
+    assert 1 == Registry.count_match(registry, "hello", {:"$1", :_, :"$1"})
+    assert 1 == Registry.count_match(registry, "hello", :_)
+    assert 0 == Registry.count_match(registry, :_, :_)
+
+    value2 = %{a: "a", b: "b"}
+    {:ok, _} = Registry.register(registry, "world", value2)
+    assert 1 == Registry.count_match(registry, "world", %{b: "b"})
+  end
+
+  test "count_match supports guard conditions", %{registry: registry} do
+    value = {1, :atom, 2}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    assert 1 == Registry.count_match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 1}])
+    assert 0 == Registry.count_match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 2}])
+    assert 1 == Registry.count_match(registry, "hello", {:_, :"$1", :_}, [{:is_atom, :"$1"}])
+  end
+
+  test "unregister_match supports patterns", %{registry: registry} do
+    value1 = {1, :atom, 1}
+    value2 = {2, :atom, 2}
+
+    {:ok, _} = Registry.register(registry, "hello", value1)
+    {:ok, _} = Registry.register(registry, "hello", value2)
+
+    Registry.unregister_match(registry, "hello", {2, :_, :_})
+    assert Registry.lookup(registry, "hello") == [{self(), value1}]
+
+    {:ok, _} = Registry.register(registry, "hello", value2)
+    Registry.unregister_match(registry, "hello", {2.0, :_, :_})
+    assert Registry.lookup(registry, "hello") == [{self(), value1}, {self(), value2}]
+    Registry.unregister_match(registry, "hello", {:_, :atom, :_})
+    assert Registry.lookup(registry, "hello") == []
+  end
+
+  test "unregister_match supports guards", %{registry: registry} do
+    value1 = {1, :atom, 1}
+    value2 = {2, :atom, 2}
+
+    {:ok, _} = Registry.register(registry, "hello", value1)
+    {:ok, _} = Registry.register(registry, "hello", value2)
+
+    Registry.unregister_match(registry, "hello", {:"$1", :_, :_}, [{:<, :"$1", 2}])
+    assert Registry.lookup(registry, "hello") == [{self(), value2}]
+  end
+
+  test "unregister_match supports tricky keys", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, :_, :foo)
+    {:ok, _} = Registry.register(registry, :_, :bar)
+    {:ok, _} = Registry.register(registry, "hello", "a")
+    {:ok, _} = Registry.register(registry, "hello", "b")
+
+    Registry.unregister_match(registry, :_, :foo)
+    assert Registry.lookup(registry, :_) == [{self(), :bar}]
+
+    assert Registry.keys(registry, self()) |> Enum.sort() == [:_, "hello", "hello"]
+  end
+
+  @tag base_listener: :unique_listener
+  test "allows listeners", %{registry: registry, listeners: [listener]} do
+    Process.register(self(), listener)
+    {_, task} = register_task(registry, "hello", :world)
+    assert_received {:register, ^registry, "hello", ^task, :world}
+
+    self = self()
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    assert_received {:register, ^registry, "hello", ^self, :value}
+
+    :ok = Registry.unregister(registry, "hello")
+    assert_received {:unregister, ^registry, "hello", ^self}
+  after
+    Process.unregister(listener)
+  end
+
+  test "links and unlinks on register/unregister", %{registry: registry} do
+    {:ok, pid} = Registry.register(registry, "hello", :value)
+    {:links, links} = Process.info(self(), :links)
+    assert pid in links
+
+    {:ok, pid} = Registry.register(registry, "world", :value)
+    {:links, links} = Process.info(self(), :links)
+    assert pid in links
+
+    :ok = Registry.unregister(registry, "hello")
+    {:links, links} = Process.info(self(), :links)
+    assert pid in links
+
+    :ok = Registry.unregister(registry, "world")
+    {:links, links} = Process.info(self(), :links)
+    refute pid in links
+  end
+
+  test "raises on unknown registry name" do
+    assert_raise ArgumentError, ~r/unknown registry/, fn ->
+      Registry.register(:unknown, "hello", :value)
+    end
+  end
+
+  test "raises if attempt to be used on via", %{registry: registry} do
+    assert_raise ArgumentError, ":via is not supported for duplicate registries", fn ->
+      name = {:via, Registry, {registry, "hello"}}
+      Agent.start_link(fn -> 0 end, name: name)
+    end
+  end
+
+  test "empty list for empty registry", %{registry: registry} do
+    assert Registry.select(registry, [{{:_, :_, :_}, [], [:"$_"]}]) == []
+  end
+
+  test "select all", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    {:ok, _} = Registry.register(registry, "hello", :value)
+
+    assert Registry.select(registry, [{{:"$1", :"$2", :"$3"}, [], [{{:"$1", :"$2", :"$3"}}]}])
+           |> Enum.sort() ==
+             [{"hello", self(), :value}, {"hello", self(), :value}]
+  end
+
+  test "select supports full match specs", %{registry: registry} do
+    value = {1, :atom, 1}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    assert [{"hello", self(), value}] ==
+             Registry.select(registry, [
+               {{"hello", :"$2", :"$3"}, [], [{{"hello", :"$2", :"$3"}}]}
+             ])
+
+    assert [{"hello", self(), value}] ==
+             Registry.select(registry, [
+               {{:"$1", self(), :"$3"}, [], [{{:"$1", self(), :"$3"}}]}
+             ])
+
+    assert [{"hello", self(), value}] ==
+             Registry.select(registry, [
+               {{:"$1", :"$2", value}, [], [{{:"$1", :"$2", {value}}}]}
+             ])
+
+    assert [] ==
+             Registry.select(registry, [
+               {{"world", :"$2", :"$3"}, [], [{{"world", :"$2", :"$3"}}]}
+             ])
+
+    assert [] == Registry.select(registry, [{{:"$1", :"$2", {1.0, :_, :_}}, [], [:"$_"]}])
+
+    assert [{"hello", self(), value}] ==
+             Registry.select(registry, [
+               {{:"$1", :"$2", {:"$3", :atom, :"$4"}}, [],
+                [{{:"$1", :"$2", {{:"$3", :atom, :"$4"}}}}]}
+             ])
+
+    assert [{"hello", self(), {1, :atom, 1}}] ==
+             Registry.select(registry, [
+               {{:"$1", :"$2", {:"$3", :"$4", :"$3"}}, [],
+                [{{:"$1", :"$2", {{:"$3", :"$4", :"$3"}}}}]}
+             ])
+
+    value2 = %{a: "a", b: "b"}
+    {:ok, _} = Registry.register(registry, "world", value2)
+
+    assert [:match] ==
+             Registry.select(registry, [{{"world", self(), %{b: "b"}}, [], [:match]}])
+
+    assert ["hello", "world"] ==
+             Registry.select(registry, [{{:"$1", :_, :_}, [], [:"$1"]}]) |> Enum.sort()
+  end
+
+  test "select supports guard conditions", %{registry: registry} do
+    value = {1, :atom, 2}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    assert [{"hello", self(), {1, :atom, 2}}] ==
+             Registry.select(registry, [
+               {{:"$1", :"$2", {:"$3", :"$4", :"$5"}}, [{:>, :"$5", 1}],
+                [{{:"$1", :"$2", {{:"$3", :"$4", :"$5"}}}}]}
+             ])
+
+    assert [] ==
+             Registry.select(registry, [
+               {{:_, :_, {:_, :_, :"$1"}}, [{:>, :"$1", 2}], [:"$_"]}
+             ])
+
+    assert ["hello"] ==
+             Registry.select(registry, [
+               {{:"$1", :_, {:_, :"$2", :_}}, [{:is_atom, :"$2"}], [:"$1"]}
+             ])
+  end
+
+  test "select allows multiple specs", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    {:ok, _} = Registry.register(registry, "world", :value)
+
+    assert ["hello", "world"] ==
+             Registry.select(registry, [
+               {{"hello", :_, :_}, [], [{:element, 1, :"$_"}]},
+               {{"world", :_, :_}, [], [{:element, 1, :"$_"}]}
+             ])
+             |> Enum.sort()
+  end
+
+  test "count_select supports match specs", %{registry: registry} do
+    value = {1, :atom, 1}
+    {:ok, _} = Registry.register(registry, "hello", value)
+    assert 1 == Registry.count_select(registry, [{{:_, :_, value}, [], [true]}])
+    assert 1 == Registry.count_select(registry, [{{"hello", :_, :_}, [], [true]}])
+    assert 1 == Registry.count_select(registry, [{{:_, :_, {1, :atom, :_}}, [], [true]}])
+    assert 1 == Registry.count_select(registry, [{{:_, :_, {:"$1", :_, :"$1"}}, [], [true]}])
+    assert 0 == Registry.count_select(registry, [{{"hello", :_, nil}, [], [true]}])
+
+    value2 = %{a: "a", b: "b"}
+    {:ok, _} = Registry.register(registry, "world", value2)
+    assert 1 == Registry.count_select(registry, [{{"world", :_, :_}, [], [true]}])
+  end
+
+  test "count_select supports guard conditions", %{registry: registry} do
+    value = {1, :atom, 2}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    assert 1 ==
+             Registry.count_select(registry, [
+               {{:_, :_, {:_, :"$1", :_}}, [{:is_atom, :"$1"}], [true]}
+             ])
+
+    assert 1 ==
+             Registry.count_select(registry, [
+               {{:_, :_, {:_, :_, :"$1"}}, [{:>, :"$1", 1}], [true]}
+             ])
+
+    assert 0 ==
+             Registry.count_select(registry, [
+               {{:_, :_, {:_, :_, :"$1"}}, [{:>, :"$1", 2}], [true]}
+             ])
+  end
+
+  test "count_select allows multiple specs", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    {:ok, _} = Registry.register(registry, "world", :value)
+
+    assert 2 ==
+             Registry.count_select(registry, [
+               {{"hello", :_, :_}, [], [true]},
+               {{"world", :_, :_}, [], [true]}
+             ])
+  end
+
+  test "rejects invalid tuple syntax", %{partitions: partitions} do
+    name = :"test_invalid_tuple_#{partitions}"
+
+    assert_raise ArgumentError, ~r/expected :keys to be given and be one of/, fn ->
+      Registry.start_link(keys: {:duplicate, :invalid}, name: name, partitions: partitions)
+    end
+  end
+
+  test "update_value is not supported", %{registry: registry} do
+    assert_raise ArgumentError, ~r/Registry.update_value\/3 is not supported/, fn ->
+      Registry.update_value(registry, "hello", fn val -> val end)
+    end
+  end
+
+  defp register_task(registry, key, value) do
+    parent = self()
+
+    {:ok, task} =
+      Task.start(fn ->
+        send(parent, Registry.register(registry, key, value))
+        Process.sleep(:infinity)
+      end)
+
+    assert_receive {:ok, owner}
+    {owner, task}
+  end
+end
diff --git a/lib/elixir/test/elixir/registry/unique_test.exs b/lib/elixir/test/elixir/registry/unique_test.exs
new file mode 100644
index 00000000000..3cd37b82120
--- /dev/null
+++ b/lib/elixir/test/elixir/registry/unique_test.exs
@@ -0,0 +1,507 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Registry.UniqueTest do
+  use ExUnit.Case,
+    async: true,
+    parameterize: [
+      %{partitions: 1},
+      %{partitions: 8}
+    ]
+
+  @keys :unique
+
+  setup config do
+    partitions = config.partitions
+    listeners = List.wrap(config[:base_listener]) |> Enum.map(&:"#{&1}_#{partitions}")
+    name = :"#{config.test}_#{partitions}"
+    opts = [keys: @keys, name: name, partitions: partitions, listeners: listeners]
+    {:ok, _} = start_supervised({Registry, opts})
+    %{registry: name, listeners: listeners}
+  end
+
+  test "starts configured number of partitions", %{registry: registry, partitions: partitions} do
+    assert length(Supervisor.which_children(registry)) == partitions
+  end
+
+  test "counts 0 keys in an empty registry", %{registry: registry} do
+    assert 0 == Registry.count(registry)
+  end
+
+  test "counts the number of keys in a registry", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    {:ok, _} = Registry.register(registry, "world", :value)
+
+    assert 2 == Registry.count(registry)
+  end
+
+  test "has unique registrations", %{registry: registry} do
+    {:ok, pid} = Registry.register(registry, "hello", :value)
+    assert is_pid(pid)
+    assert Registry.keys(registry, self()) == ["hello"]
+    assert Registry.values(registry, "hello", self()) == [:value]
+
+    assert {:error, {:already_registered, pid}} = Registry.register(registry, "hello", :value)
+    assert pid == self()
+    assert Registry.keys(registry, self()) == ["hello"]
+    assert Registry.values(registry, "hello", self()) == [:value]
+
+    {:ok, pid} = Registry.register(registry, "world", :value)
+    assert is_pid(pid)
+    assert Registry.keys(registry, self()) |> Enum.sort() == ["hello", "world"]
+  end
+
+  test "has unique registrations across processes", %{registry: registry} do
+    {_, task} = register_task(registry, "hello", :value)
+    Process.link(Process.whereis(registry))
+    assert Registry.keys(registry, task) == ["hello"]
+    assert Registry.values(registry, "hello", task) == [:value]
+
+    assert {:error, {:already_registered, ^task}} =
+             Registry.register(registry, "hello", :recent)
+
+    assert Registry.keys(registry, self()) == []
+    assert Registry.values(registry, "hello", self()) == []
+
+    {:links, links} = Process.info(self(), :links)
+    assert Process.whereis(registry) in links
+  end
+
+  test "has unique registrations even if partition is delayed", %{registry: registry} do
+    {owner, task} = register_task(registry, "hello", :value)
+
+    assert Registry.register(registry, "hello", :other) ==
+             {:error, {:already_registered, task}}
+
+    :sys.suspend(owner)
+    kill_and_assert_down(task)
+    Registry.register(registry, "hello", :other)
+    assert Registry.lookup(registry, "hello") == [{self(), :other}]
+  end
+
+  test "supports match patterns", %{registry: registry} do
+    value = {1, :atom, 1}
+    {:ok, _} = Registry.register(registry, "hello", value)
+    assert Registry.match(registry, "hello", {1, :_, :_}) == [{self(), value}]
+    assert Registry.match(registry, "hello", {1.0, :_, :_}) == []
+    assert Registry.match(registry, "hello", {:_, :atom, :_}) == [{self(), value}]
+    assert Registry.match(registry, "hello", {:"$1", :_, :"$1"}) == [{self(), value}]
+    assert Registry.match(registry, "hello", :_) == [{self(), value}]
+    assert Registry.match(registry, :_, :_) == []
+
+    value2 = %{a: "a", b: "b"}
+    {:ok, _} = Registry.register(registry, "world", value2)
+    assert Registry.match(registry, "world", %{b: "b"}) == [{self(), value2}]
+  end
+
+  test "supports guard conditions", %{registry: registry} do
+    value = {1, :atom, 2}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    assert Registry.match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 1}]) ==
+             [{self(), value}]
+
+    assert Registry.match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 2}]) == []
+
+    assert Registry.match(registry, "hello", {:_, :"$1", :_}, [{:is_atom, :"$1"}]) ==
+             [{self(), value}]
+  end
+
+  test "count_match supports match patterns", %{registry: registry} do
+    value = {1, :atom, 1}
+    {:ok, _} = Registry.register(registry, "hello", value)
+    assert 1 == Registry.count_match(registry, "hello", {1, :_, :_})
+    assert 0 == Registry.count_match(registry, "hello", {1.0, :_, :_})
+    assert 1 == Registry.count_match(registry, "hello", {:_, :atom, :_})
+    assert 1 == Registry.count_match(registry, "hello", {:"$1", :_, :"$1"})
+    assert 1 == Registry.count_match(registry, "hello", :_)
+    assert 0 == Registry.count_match(registry, :_, :_)
+
+    value2 = %{a: "a", b: "b"}
+    {:ok, _} = Registry.register(registry, "world", value2)
+    assert 1 == Registry.count_match(registry, "world", %{b: "b"})
+  end
+
+  test "count_match supports guard conditions", %{registry: registry} do
+    value = {1, :atom, 2}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    assert 1 == Registry.count_match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 1}])
+    assert 0 == Registry.count_match(registry, "hello", {:_, :_, :"$1"}, [{:>, :"$1", 2}])
+    assert 1 == Registry.count_match(registry, "hello", {:_, :"$1", :_}, [{:is_atom, :"$1"}])
+  end
+
+  test "unregister_match supports patterns", %{registry: registry} do
+    value = {1, :atom, 1}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    Registry.unregister_match(registry, "hello", {2, :_, :_})
+    assert Registry.lookup(registry, "hello") == [{self(), value}]
+    Registry.unregister_match(registry, "hello", {1.0, :_, :_})
+    assert Registry.lookup(registry, "hello") == [{self(), value}]
+    Registry.unregister_match(registry, "hello", {:_, :atom, :_})
+    assert Registry.lookup(registry, "hello") == []
+  end
+
+  test "unregister_match supports guards", %{registry: registry} do
+    value = {1, :atom, 1}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    Registry.unregister_match(registry, "hello", {:"$1", :_, :_}, [{:<, :"$1", 2}])
+    assert Registry.lookup(registry, "hello") == []
+  end
+
+  test "unregister_match supports tricky keys", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, :_, :foo)
+    {:ok, _} = Registry.register(registry, "hello", "b")
+
+    Registry.unregister_match(registry, :_, :foo)
+    assert Registry.lookup(registry, :_) == []
+    assert Registry.keys(registry, self()) |> Enum.sort() == ["hello"]
+  end
+
+  test "compares using ===", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, 1.0, :value)
+    {:ok, _} = Registry.register(registry, 1, :value)
+    assert Registry.keys(registry, self()) |> Enum.sort() == [1, 1.0]
+  end
+
+  test "updates current process value", %{registry: registry} do
+    assert Registry.update_value(registry, "hello", &raise/1) == :error
+    register_task(registry, "hello", :value)
+    assert Registry.update_value(registry, "hello", &raise/1) == :error
+
+    Registry.register(registry, "world", 1)
+    assert Registry.lookup(registry, "world") == [{self(), 1}]
+    assert Registry.update_value(registry, "world", &(&1 + 1)) == {2, 1}
+    assert Registry.lookup(registry, "world") == [{self(), 2}]
+  end
+
+  test "dispatches to a single key", %{registry: registry} do
+    fun = fn _ -> raise "will never be invoked" end
+    assert Registry.dispatch(registry, "hello", fun) == :ok
+
+    {:ok, _} = Registry.register(registry, "hello", :value)
+
+    fun = fn [{pid, value}] -> send(pid, {:dispatch, value}) end
+    assert Registry.dispatch(registry, "hello", fun)
+
+    assert_received {:dispatch, :value}
+  end
+
+  test "unregisters process by key", %{registry: registry} do
+    :ok = Registry.unregister(registry, "hello")
+
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    {:ok, _} = Registry.register(registry, "world", :value)
+    assert Registry.keys(registry, self()) |> Enum.sort() == ["hello", "world"]
+
+    :ok = Registry.unregister(registry, "hello")
+    assert Registry.keys(registry, self()) == ["world"]
+
+    :ok = Registry.unregister(registry, "world")
+    assert Registry.keys(registry, self()) == []
+  end
+
+  test "unregisters with no entries", %{registry: registry} do
+    assert Registry.unregister(registry, "hello") == :ok
+  end
+
+  test "unregisters with tricky keys", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, :_, :foo)
+    {:ok, _} = Registry.register(registry, "hello", "b")
+
+    Registry.unregister(registry, :_)
+    assert Registry.lookup(registry, :_) == []
+    assert Registry.keys(registry, self()) |> Enum.sort() == ["hello"]
+  end
+
+  @tag base_listener: :unique_listener
+  test "allows listeners", %{registry: registry, listeners: [listener]} do
+    Process.register(self(), listener)
+    {_, task} = register_task(registry, "hello", :world)
+    assert_received {:register, ^registry, "hello", ^task, :world}
+
+    self = self()
+    {:ok, _} = Registry.register(registry, "world", :value)
+    assert_received {:register, ^registry, "world", ^self, :value}
+
+    :ok = Registry.unregister(registry, "world")
+    assert_received {:unregister, ^registry, "world", ^self}
+  after
+    Process.unregister(listener)
+  end
+
+  test "links and unlinks on register/unregister", %{registry: registry} do
+    {:ok, pid} = Registry.register(registry, "hello", :value)
+    {:links, links} = Process.info(self(), :links)
+    assert pid in links
+
+    {:ok, pid} = Registry.register(registry, "world", :value)
+    {:links, links} = Process.info(self(), :links)
+    assert pid in links
+
+    :ok = Registry.unregister(registry, "hello")
+    {:links, links} = Process.info(self(), :links)
+    assert pid in links
+
+    :ok = Registry.unregister(registry, "world")
+    {:links, links} = Process.info(self(), :links)
+    refute pid in links
+  end
+
+  test "raises on unknown registry name" do
+    assert_raise ArgumentError, ~r/unknown registry/, fn ->
+      Registry.register(:unknown, "hello", :value)
+    end
+  end
+
+  test "via callbacks", %{registry: registry} do
+    name = {:via, Registry, {registry, "hello"}}
+
+    # register_name
+    {:ok, pid} = Agent.start_link(fn -> 0 end, name: name)
+
+    # send
+    assert Agent.update(name, &(&1 + 1)) == :ok
+
+    # whereis_name
+    assert Agent.get(name, & &1) == 1
+
+    # unregister_name
+    assert {:error, _} = Agent.start(fn -> raise "oops" end)
+
+    # errors
+    assert {:error, {:already_started, ^pid}} = Agent.start(fn -> 0 end, name: name)
+  end
+
+  test "uses value provided in via", %{registry: registry} do
+    name = {:via, Registry, {registry, "hello", :value}}
+    {:ok, pid} = Agent.start_link(fn -> 0 end, name: name)
+    assert Registry.lookup(registry, "hello") == [{pid, :value}]
+  end
+
+  test "empty list for empty registry", %{registry: registry} do
+    assert Registry.select(registry, [{{:_, :_, :_}, [], [:"$_"]}]) == []
+  end
+
+  test "select all", %{registry: registry} do
+    name = {:via, Registry, {registry, "hello"}}
+    {:ok, pid} = Agent.start_link(fn -> 0 end, name: name)
+    {:ok, _} = Registry.register(registry, "world", :value)
+
+    assert Registry.select(registry, [{{:"$1", :"$2", :"$3"}, [], [{{:"$1", :"$2", :"$3"}}]}])
+           |> Enum.sort() ==
+             [{"hello", pid, nil}, {"world", self(), :value}]
+  end
+
+  test "select supports full match specs", %{registry: registry} do
+    value = {1, :atom, 1}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    assert [{"hello", self(), value}] ==
+             Registry.select(registry, [
+               {{"hello", :"$2", :"$3"}, [], [{{"hello", :"$2", :"$3"}}]}
+             ])
+
+    assert [{"hello", self(), value}] ==
+             Registry.select(registry, [
+               {{:"$1", self(), :"$3"}, [], [{{:"$1", self(), :"$3"}}]}
+             ])
+
+    assert [{"hello", self(), value}] ==
+             Registry.select(registry, [
+               {{:"$1", :"$2", value}, [], [{{:"$1", :"$2", {value}}}]}
+             ])
+
+    assert [] ==
+             Registry.select(registry, [
+               {{"world", :"$2", :"$3"}, [], [{{"world", :"$2", :"$3"}}]}
+             ])
+
+    assert [] == Registry.select(registry, [{{:"$1", :"$2", {1.0, :_, :_}}, [], [:"$_"]}])
+
+    assert [{"hello", self(), value}] ==
+             Registry.select(registry, [
+               {{:"$1", :"$2", {:"$3", :atom, :"$4"}}, [],
+                [{{:"$1", :"$2", {{:"$3", :atom, :"$4"}}}}]}
+             ])
+
+    assert [{"hello", self(), {1, :atom, 1}}] ==
+             Registry.select(registry, [
+               {{:"$1", :"$2", {:"$3", :"$4", :"$3"}}, [],
+                [{{:"$1", :"$2", {{:"$3", :"$4", :"$3"}}}}]}
+             ])
+
+    value2 = %{a: "a", b: "b"}
+    {:ok, _} = Registry.register(registry, "world", value2)
+
+    assert [:match] ==
+             Registry.select(registry, [{{"world", self(), %{b: "b"}}, [], [:match]}])
+
+    assert ["hello", "world"] ==
+             Registry.select(registry, [{{:"$1", :_, :_}, [], [:"$1"]}]) |> Enum.sort()
+  end
+
+  test "select supports guard conditions", %{registry: registry} do
+    value = {1, :atom, 2}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    assert [{"hello", self(), {1, :atom, 2}}] ==
+             Registry.select(registry, [
+               {{:"$1", :"$2", {:"$3", :"$4", :"$5"}}, [{:>, :"$5", 1}],
+                [{{:"$1", :"$2", {{:"$3", :"$4", :"$5"}}}}]}
+             ])
+
+    assert [] ==
+             Registry.select(registry, [
+               {{:_, :_, {:_, :_, :"$1"}}, [{:>, :"$1", 2}], [:"$_"]}
+             ])
+
+    assert ["hello"] ==
+             Registry.select(registry, [
+               {{:"$1", :_, {:_, :"$2", :_}}, [{:is_atom, :"$2"}], [:"$1"]}
+             ])
+  end
+
+  test "select allows multiple specs", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    {:ok, _} = Registry.register(registry, "world", :value)
+
+    assert ["hello", "world"] ==
+             Registry.select(registry, [
+               {{"hello", :_, :_}, [], [{:element, 1, :"$_"}]},
+               {{"world", :_, :_}, [], [{:element, 1, :"$_"}]}
+             ])
+             |> Enum.sort()
+  end
+
+  test "select raises on incorrect shape of match spec", %{registry: registry} do
+    assert_raise ArgumentError, fn ->
+      Registry.select(registry, [{:_, [], []}])
+    end
+  end
+
+  test "count_select supports match specs", %{registry: registry} do
+    value = {1, :atom, 1}
+    {:ok, _} = Registry.register(registry, "hello", value)
+    assert 1 == Registry.count_select(registry, [{{:_, :_, value}, [], [true]}])
+    assert 1 == Registry.count_select(registry, [{{"hello", :_, :_}, [], [true]}])
+    assert 1 == Registry.count_select(registry, [{{:_, :_, {1, :atom, :_}}, [], [true]}])
+    assert 1 == Registry.count_select(registry, [{{:_, :_, {:"$1", :_, :"$1"}}, [], [true]}])
+    assert 0 == Registry.count_select(registry, [{{"hello", :_, nil}, [], [true]}])
+
+    value2 = %{a: "a", b: "b"}
+    {:ok, _} = Registry.register(registry, "world", value2)
+    assert 1 == Registry.count_select(registry, [{{"world", :_, :_}, [], [true]}])
+  end
+
+  test "count_select supports guard conditions", %{registry: registry} do
+    value = {1, :atom, 2}
+    {:ok, _} = Registry.register(registry, "hello", value)
+
+    assert 1 ==
+             Registry.count_select(registry, [
+               {{:_, :_, {:_, :"$1", :_}}, [{:is_atom, :"$1"}], [true]}
+             ])
+
+    assert 1 ==
+             Registry.count_select(registry, [
+               {{:_, :_, {:_, :_, :"$1"}}, [{:>, :"$1", 1}], [true]}
+             ])
+
+    assert 0 ==
+             Registry.count_select(registry, [
+               {{:_, :_, {:_, :_, :"$1"}}, [{:>, :"$1", 2}], [true]}
+             ])
+  end
+
+  test "count_select allows multiple specs", %{registry: registry} do
+    {:ok, _} = Registry.register(registry, "hello", :value)
+    {:ok, _} = Registry.register(registry, "world", :value)
+
+    assert 2 ==
+             Registry.count_select(registry, [
+               {{"hello", :_, :_}, [], [true]},
+               {{"world", :_, :_}, [], [true]}
+             ])
+  end
+
+  test "count_select raises on incorrect shape of match spec", %{registry: registry} do
+    assert_raise ArgumentError, fn ->
+      Registry.count_select(registry, [{:_, [], []}])
+    end
+  end
+
+  test "doesn't grow ets on already_registered",
+       %{registry: registry, partitions: partitions} do
+    assert sum_pid_entries(registry, partitions) == 0
+
+    {:ok, pid} = Registry.register(registry, "hello", :value)
+    assert is_pid(pid)
+    assert sum_pid_entries(registry, partitions) == 1
+
+    {:ok, pid} = Registry.register(registry, "world", :value)
+    assert is_pid(pid)
+    assert sum_pid_entries(registry, partitions) == 2
+
+    assert {:error, {:already_registered, _pid}} =
+             Registry.register(registry, "hello", :value)
+
+    assert sum_pid_entries(registry, partitions) == 2
+  end
+
+  test "doesn't grow ets on already_registered across processes",
+       %{registry: registry, partitions: partitions} do
+    assert sum_pid_entries(registry, partitions) == 0
+
+    {_, task} = register_task(registry, "hello", :value)
+    Process.link(Process.whereis(registry))
+
+    assert sum_pid_entries(registry, partitions) == 1
+
+    {:ok, pid} = Registry.register(registry, "world", :value)
+    assert is_pid(pid)
+    assert sum_pid_entries(registry, partitions) == 2
+
+    assert {:error, {:already_registered, ^task}} =
+             Registry.register(registry, "hello", :recent)
+
+    assert sum_pid_entries(registry, partitions) == 2
+  end
+
+  defp register_task(registry, key, value) do
+    parent = self()
+
+    {:ok, task} =
+      Task.start(fn ->
+        send(parent, Registry.register(registry, key, value))
+        Process.sleep(:infinity)
+      end)
+
+    assert_receive {:ok, owner}
+    {owner, task}
+  end
+
+  defp kill_and_assert_down(pid) do
+    ref = Process.monitor(pid)
+    Process.exit(pid, :kill)
+    assert_receive {:DOWN, ^ref, _, _, _}
+  end
+
+  defp sum_pid_entries(registry, partitions) do
+    Enum.sum_by(0..(partitions - 1), fn partition ->
+      registry
+      |> Module.concat("PIDPartition#{partition}")
+      |> ets_entries()
+    end)
+  end
+
+  defp ets_entries(table_name) do
+    :ets.all()
+    |> Enum.find_value(fn id -> :ets.info(id, :name) == table_name and :ets.info(id, :size) end)
+  end
+end
diff --git a/lib/elixir/test/elixir/registry_test.exs b/lib/elixir/test/elixir/registry_test.exs
new file mode 100644
index 00000000000..71129cd4c7f
--- /dev/null
+++ b/lib/elixir/test/elixir/registry_test.exs
@@ -0,0 +1,251 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
+
+defmodule Registry.CommonTest do
+  use ExUnit.Case, async: true
+  doctest Registry, except: [:moduledoc]
+end
+
+defmodule Registry.Test do
+  use ExUnit.Case,
+    async: true,
+    parameterize:
+      for(
+        keys <- [:unique, :duplicate, {:duplicate, :pid}, {:duplicate, :key}],
+        partitions <- [1, 8],
+        do: %{keys: keys, partitions: partitions}
+      )
+
+  setup config do
+    keys = config.keys || :unique
+    partitions = config.partitions
+
+    listeners =
+      List.wrap(config[:base_listener]) |> Enum.map(&:"#{&1}_#{partitions}_#{inspect(keys)}")
+
+    name = :"#{config.test}_#{partitions}_#{inspect(keys)}"
+    opts = [keys: keys, name: name, partitions: partitions, listeners: listeners]
+    {:ok, _} = start_supervised({Registry, opts})
+    %{registry: name, listeners: listeners}
+  end
+
+  # Note: those tests relies on internals
+  test "clean up registry on process crash",
+       %{registry: registry, partitions: partitions} do
+    {_, task1} = register_task(registry, "hello", :value)
+    {_, task2} = register_task(registry, "world", :value)
+
+    kill_and_assert_down(task1)
+    kill_and_assert_down(task2)
+
+    # pid might be in different partition to key so need to sync with all
+    # partitions before checking ETS tables are empty.
+    if partitions > 1 do
+      for i <- 0..(partitions - 1) do
+        [{_, _, {partition, _}}] = :ets.lookup(registry, i)
+        GenServer.call(partition, :sync)
+      end
+
+      for i <- 0..(partitions - 1) do
+        [{_, key, {_, pid}}] = :ets.lookup(registry, i)
+        assert :ets.tab2list(key) == []
+        assert :ets.tab2list(pid) == []
+      end
+    else
+      [{-1, {_, _, key, {partition, pid}, _}}] = :ets.lookup(registry, -1)
+      GenServer.call(partition, :sync)
+      assert :ets.tab2list(key) == []
+      assert :ets.tab2list(pid) == []
+    end
+  end
+
+  defp register_task(registry, key, value) do
+    parent = self()
+
+    {:ok, task} =
+      Task.start(fn ->
+        send(parent, Registry.register(registry, key, value))
+        Process.sleep(:infinity)
+      end)
+
+    assert_receive {:ok, owner}
+    {owner, task}
+  end
+
+  defp kill_and_assert_down(pid) do
+    ref = Process.monitor(pid)
+    Process.exit(pid, :kill)
+    assert_receive {:DOWN, ^ref, _, _, _}
+  end
+end
+
+defmodule Registry.LockTest do
+  use ExUnit.Case,
+    async: true,
+    parameterize: [
+      %{keys: :unique, partitions: 1},
+      %{keys: :unique, partitions: 8},
+      %{keys: :duplicate, partitions: 1},
+      %{keys: :duplicate, partitions: 8}
+    ]
+
+  setup config do
+    keys = config.keys
+    partitions = config.partitions
+    name = :"#{config.test}_#{keys}_#{partitions}"
+    opts = [keys: keys, name: name, partitions: partitions]
+    {:ok, _} = start_supervised({Registry, opts})
+    %{registry: name}
+  end
+
+  test "does not lock when using different keys", config do
+    parent = self()
+
+    task1 =
+      Task.async(fn ->
+        Registry.lock(config.registry, 1, fn ->
+          send(parent, :locked1)
+          assert_receive :unlock
+          :done
+        end)
+      end)
+
+    assert_receive :locked1
+
+    task2 =
+      Task.async(fn ->
+        Registry.lock(config.registry, 2, fn ->
+          send(parent, :locked2)
+          assert_receive :unlock
+          :done
+        end)
+      end)
+
+    assert_receive :locked2
+
+    send(task1.pid, :unlock)
+    send(task2.pid, :unlock)
+    assert Task.await(task1) == :done
+    assert Task.await(task2) == :done
+    assert Registry.lock(config.registry, 1, fn -> :done end) == :done
+    assert Registry.lock(config.registry, 2, fn -> :done end) == :done
+  end
+
+  test "locks when using the same key", config do
+    parent = self()
+
+    task1 =
+      Task.async(fn ->
+        Registry.lock(config.registry, :ok, fn ->
+          send(parent, :locked1)
+          assert_receive :unlock
+          :done
+        end)
+      end)
+
+    assert_receive :locked1
+
+    task2 =
+      Task.async(fn ->
+        Registry.lock(config.registry, :ok, fn ->
+          send(parent, :locked2)
+          :done
+        end)
+      end)
+
+    refute_receive :locked2, 100
+
+    send(task1.pid, :unlock)
+    assert Task.await(task1) == :done
+    assert_receive :locked2
+    assert Task.await(task2) == :done
+    assert Registry.lock(config.registry, :ok, fn -> :done end) == :done
+  end
+
+  @tag :capture_log
+  test "locks when the one holding the lock raises", config do
+    parent = self()
+
+    task1 =
+      Task.async(fn ->
+        Registry.lock(config.registry, :ok, fn ->
+          send(parent, :locked)
+          assert_receive :unlock
+          raise "oops"
+        end)
+      end)
+
+    Process.unlink(task1.pid)
+    assert_receive :locked
+
+    task2 =
+      Task.async(fn ->
+        Registry.lock(config.registry, :ok, fn ->
+          :done
+        end)
+      end)
+
+    send(task1.pid, :unlock)
+    assert {:exit, {%RuntimeError{message: "oops"}, [_ | _]}} = Task.yield(task1)
+    assert Task.await(task2) == :done
+    assert Registry.lock(config.registry, :ok, fn -> :done end) == :done
+  end
+
+  test "locks when the one holding the lock terminates", config do
+    parent = self()
+
+    task1 =
+      Task.async(fn ->
+        Registry.lock(config.registry, :ok, fn ->
+          send(parent, :locked)
+          assert_receive :unlock
+          :done
+        end)
+      end)
+
+    assert_receive :locked
+
+    task2 =
+      Task.async(fn ->
+        Registry.lock(config.registry, :ok, fn ->
+          :done
+        end)
+      end)
+
+    assert Task.shutdown(task1, :brutal_kill) == nil
+    assert Task.await(task2) == :done
+    assert Registry.lock(config.registry, :ok, fn -> :done end) == :done
+  end
+
+  test "locks when the one waiting for the lock terminates", config do
+    parent = self()
+
+    task1 =
+      Task.async(fn ->
+        Registry.lock(config.registry, :ok, fn ->
+          send(parent, :locked)
+          assert_receive :unlock
+          :done
+        end)
+      end)
+
+    assert_receive :locked
+
+    task2 =
+      Task.async(fn ->
+        Registry.lock(config.registry, :ok, fn ->
+          :done
+        end)
+      end)
+
+    :erlang.yield()
+    assert Task.shutdown(task2, :brutal_kill) == nil
+
+    send(task1.pid, :unlock)
+    assert Task.await(task1) == :done
+    assert Registry.lock(config.registry, :ok, fn -> :done end) == :done
+  end
+end
diff --git a/lib/elixir/test/elixir/set_test.exs b/lib/elixir/test/elixir/set_test.exs
deleted file mode 100644
index 52545b8a6fd..00000000000
--- a/lib/elixir/test/elixir/set_test.exs
+++ /dev/null
@@ -1,189 +0,0 @@
-Code.require_file "test_helper.exs", __DIR__
-
-# A TestSet implementation used only for testing.
-defmodule TestSet do
-  defstruct list: []
-  def new(list \\ []) when is_list(list) do
-    %TestSet{list: list}
-  end
-
-  def reduce(%TestSet{list: list}, acc, fun) do
-    Enumerable.reduce(list, acc, fun)
-  end
-
-  def member?(%TestSet{list: list}, v) do
-    v in list
-  end
-
-  def size(%TestSet{list: list}) do
-    length(list)
-  end
-end
-
-defmodule SetTest.Common do
-  defmacro __using__(_) do
-    quote location: :keep do
-      defp new_set(list \\ []) do
-        Enum.into list, set_impl.new
-      end
-
-      defp new_set(list, fun) do
-        Enum.into list, set_impl.new, fun
-      end
-
-      defp int_set() do
-        Enum.into [1, 2, 3], set_impl.new
-      end
-
-      test "delete/2" do
-        result = Set.delete(new_set([1, 2, 3]), 2)
-        assert Set.equal?(result, new_set([1, 3]))
-      end
-
-      test "delete/2 with match" do
-        refute Set.member?(Set.delete(int_set, 1), 1)
-        assert Set.member?(Set.delete(int_set, 1.0), 1)
-      end
-
-      test "difference/2" do
-        result = Set.difference(new_set([1, 2, 3]), new_set([3]))
-        assert Set.equal?(result, new_set([1, 2]))
-      end
-
-      test "difference/2 with match" do
-        refute Set.member?(Set.difference(int_set, new_set([1])), 1)
-        assert Set.member?(Set.difference(int_set, new_set([1.0])), 1)
-      end
-
-      test "difference/2 with other set" do
-        result = Set.difference(new_set([1, 2, 3]), TestSet.new([3]))
-        assert Set.equal?(result, new_set([1, 2]))
-      end
-
-      test "disjoint?/2" do
-        assert Set.disjoint?(new_set([1, 2, 3]), new_set([4, 5 ,6]))
-        refute Set.disjoint?(new_set([1, 2, 3]), new_set([3, 4 ,5]))
-      end
-
-      test "disjoint/2 with other set" do
-        assert Set.disjoint?(new_set([1, 2, 3]), TestSet.new([4, 5 ,6]))
-        refute Set.disjoint?(new_set([1, 2, 3]), TestSet.new([3, 4 ,5]))
-      end
-
-      test "equal?/2" do
-        assert Set.equal?(new_set([1, 2, 3]), new_set([3, 2, 1]))
-        refute Set.equal?(new_set([1, 2, 3]), new_set([3.0, 2.0, 1.0]))
-      end
-
-      test "equal?/2 with other set" do
-        assert Set.equal?(new_set([1, 2, 3]), TestSet.new([3, 2, 1]))
-        refute Set.equal?(new_set([1, 2, 3]), TestSet.new([3.0, 2.0, 1.0]))
-      end
-
-      test "intersection/2" do
-        result = Set.intersection(new_set([1, 2, 3]), new_set([2, 3, 4]))
-        assert Set.equal?(result, new_set([2, 3]))
-      end
-
-      test "intersection/2 with match" do
-        assert Set.member?(Set.intersection(int_set, new_set([1])), 1)
-        refute Set.member?(Set.intersection(int_set, new_set([1.0])), 1)
-      end
-
-      test "intersection/2 with other set" do
-        result = Set.intersection(new_set([1, 2, 3]), TestSet.new([2, 3, 4]))
-        assert Set.equal?(result, new_set([2, 3]))
-      end
-
-      test "member?/2" do
-        assert Set.member?(new_set([1, 2, 3]), 2)
-        refute Set.member?(new_set([1, 2, 3]), 4)
-        refute Set.member?(new_set([1, 2, 3]), 1.0)
-      end
-
-      test "put/2" do
-        result = Set.put(new_set([1, 2]), 3)
-        assert Set.equal?(result, new_set([1, 2, 3]))
-      end
-
-      test "put/2 with match" do
-        assert Set.size(Set.put(int_set, 1)) == 3
-        assert Set.size(Set.put(int_set, 1.0)) == 4
-      end
-
-      test "size/1" do
-        assert Set.size(new_set([1, 2, 3])) == 3
-      end
-
-      test "subset?/2" do
-        assert Set.subset?(new_set([1, 2]), new_set([1, 2, 3]))
-        refute Set.subset?(new_set([1, 2, 3]), new_set([1, 2]))
-      end
-
-      test "subset/2 with match?" do
-        assert Set.subset?(new_set([1]), int_set)
-        refute Set.subset?(new_set([1.0]), int_set)
-      end
-
-      test "subset?/2 with other set" do
-        assert Set.subset?(new_set([1, 2]), TestSet.new([1, 2, 3]))
-        refute Set.subset?(new_set([1, 2, 3]), TestSet.new([1, 2]))
-      end
-
-      test "to_list/1" do
-        assert Set.to_list(new_set([1, 2, 3])) |> Enum.sort == [1, 2, 3]
-      end
-
-      test "union/2" do
-        result = Set.union(new_set([1, 2, 3]), new_set([2, 3, 4]))
-        assert Set.equal?(result, new_set([1, 2, 3, 4]))
-      end
-
-      test "union/2 with match" do
-        assert Set.size(Set.union(int_set, new_set([1]))) == 3
-        assert Set.size(Set.union(int_set, new_set([1.0]))) == 4
-      end
-
-      test "union/2 with other set" do
-        result = Set.union(new_set([1, 2, 3]), TestSet.new([2, 3, 4]))
-        assert Set.equal?(result, new_set([1, 2, 3, 4]))
-      end
-
-      test "is enumerable" do
-        assert Enum.member?(int_set, 1)
-        refute Enum.member?(int_set, 1.0)
-        assert Enum.sort(int_set) == [1,2,3]
-      end
-
-      test "is collectable" do
-        assert Set.equal?(new_set([1, 1, 2, 3, 3, 3]), new_set([1, 2, 3]))
-        assert Set.equal?(new_set([1, 1, 2, 3, 3, 3], &(&1 * 2)), new_set([2, 4, 6]))
-        assert Collectable.empty(new_set([1, 2, 3])) == new_set
-      end
-
-      test "is zippable" do
-        set  = new_set(1..8)
-        list = Dict.to_list(set)
-        assert Enum.zip(list, list) == Enum.zip(set, set)
-
-        set  = new_set(1..100)
-        list = Dict.to_list(set)
-        assert Enum.zip(list, list) == Enum.zip(set, set)
-      end
-
-      test "unsupported set" do
-        assert_raise ArgumentError, "unsupported set: :bad_set", fn ->
-          Set.to_list :bad_set
-        end
-      end
-    end
-  end
-end
-
-defmodule Set.HashSetTest do
-  use ExUnit.Case, async: true
-  use SetTest.Common
-
-  doctest Set
-  def set_impl, do: HashSet
-end
diff --git a/lib/elixir/test/elixir/stream_test.exs b/lib/elixir/test/elixir/stream_test.exs
index bc1e3ad64b5..a7444f7f8a8 100644
--- a/lib/elixir/test/elixir/stream_test.exs
+++ b/lib/elixir/test/elixir/stream_test.exs
@@ -1,13 +1,51 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule StreamTest do
   use ExUnit.Case, async: true
 
+  doctest Stream
+
+  defmodule Pdict do
+    defstruct []
+
+    defimpl Collectable do
+      def into(struct) do
+        fun = fn
+          _, {:cont, x} -> Process.put(:stream_cont, [x | Process.get(:stream_cont)])
+          _, :done -> Process.put(:stream_done, true)
+          _, :halt -> Process.put(:stream_halt, true)
+        end
+
+        {struct, fun}
+      end
+    end
+  end
+
+  defmodule HaltAcc do
+    defstruct [:acc]
+
+    defimpl Enumerable do
+      def count(_lazy), do: {:error, __MODULE__}
+
+      def member?(_lazy, _value), do: {:error, __MODULE__}
+
+      def slice(_lazy), do: {:error, __MODULE__}
+
+      def reduce(lazy, _acc, _fun) do
+        {:halted, Enum.to_list(lazy.acc)}
+      end
+    end
+  end
+
   test "streams as enumerables" do
-    stream = Stream.map([1,2,3], &(&1 * 2))
+    stream = Stream.map([1, 2, 3], &(&1 * 2))
 
     # Reduce
-    assert Enum.map(stream, &(&1 + 1)) == [3,5,7]
+    assert Enum.map(stream, &(&1 + 1)) == [3, 5, 7]
     # Member
     assert Enum.member?(stream, 4)
     refute Enum.member?(stream, 1)
@@ -16,203 +54,377 @@ defmodule StreamTest do
   end
 
   test "streams are composable" do
-    stream = Stream.map([1,2,3], &(&1 * 2))
-    assert is_lazy(stream)
+    stream = Stream.map([1, 2, 3], &(&1 * 2))
+    assert lazy?(stream)
 
     stream = Stream.map(stream, &(&1 + 1))
-    assert is_lazy(stream)
-
-    assert Enum.to_list(stream) == [3,5,7]
-  end
-
-  test "chunk/2, chunk/3 and chunk/4" do
-    assert Stream.chunk([1, 2, 3, 4, 5], 2) |> Enum.to_list ==
-           [[1, 2], [3, 4]]
-    assert Stream.chunk([1, 2, 3, 4, 5], 2, 2, [6]) |> Enum.to_list ==
-           [[1, 2], [3, 4], [5, 6]]
-    assert Stream.chunk([1, 2, 3, 4, 5, 6], 3, 2) |> Enum.to_list ==
-           [[1, 2, 3], [3, 4, 5]]
-    assert Stream.chunk([1, 2, 3, 4, 5, 6], 2, 3) |> Enum.to_list ==
-           [[1, 2], [4, 5]]
-    assert Stream.chunk([1, 2, 3, 4, 5, 6], 3, 2, []) |> Enum.to_list ==
-           [[1, 2, 3], [3, 4, 5], [5, 6]]
-    assert Stream.chunk([1, 2, 3, 4, 5, 6], 3, 3, []) |> Enum.to_list ==
-           [[1, 2, 3], [4, 5, 6]]
-    assert Stream.chunk([1, 2, 3, 4, 5], 4, 4, 6..10) |> Enum.to_list ==
-           [[1, 2, 3, 4], [5, 6, 7, 8]]
-  end
-
-  test "chunk/4 is zippable" do
-    stream = Stream.chunk([1, 2, 3, 4, 5, 6], 3, 2, [])
-    list   = Enum.to_list(stream)
+    assert lazy?(stream)
+
+    assert Enum.to_list(stream) == [3, 5, 7]
+  end
+
+  test "chunk_every/2, chunk_every/3 and chunk_every/4" do
+    assert Stream.chunk_every([1, 2, 3, 4, 5], 2) |> Enum.to_list() == [[1, 2], [3, 4], [5]]
+
+    assert Stream.chunk_every([1, 2, 3, 4, 5], 2, 2, [6]) |> Enum.to_list() ==
+             [[1, 2], [3, 4], [5, 6]]
+
+    assert Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard) |> Enum.to_list() ==
+             [[1, 2, 3], [3, 4, 5]]
+
+    assert Stream.chunk_every([1, 2, 3, 4, 5, 6], 2, 3, :discard) |> Enum.to_list() ==
+             [[1, 2], [4, 5]]
+
+    assert Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, []) |> Enum.to_list() ==
+             [[1, 2, 3], [3, 4, 5], [5, 6]]
+
+    assert Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 3, []) |> Enum.to_list() ==
+             [[1, 2, 3], [4, 5, 6]]
+
+    assert Stream.chunk_every([1, 2, 3, 4, 5], 4, 4, 6..10) |> Enum.to_list() ==
+             [[1, 2, 3, 4], [5, 6, 7, 8]]
+  end
+
+  test "chunk_every/4 is zippable" do
+    stream = Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, [])
+    list = Enum.to_list(stream)
     assert Enum.zip(list, list) == Enum.zip(stream, stream)
   end
 
+  test "chunk_every/4 is haltable" do
+    assert 1..10 |> Stream.take(6) |> Stream.chunk_every(4, 4, [7, 8]) |> Enum.to_list() ==
+             [[1, 2, 3, 4], [5, 6, 7, 8]]
+
+    assert 1..10
+           |> Stream.take(6)
+           |> Stream.chunk_every(4, 4, [7, 8])
+           |> Stream.take(3)
+           |> Enum.to_list() == [[1, 2, 3, 4], [5, 6, 7, 8]]
+
+    assert 1..10
+           |> Stream.take(6)
+           |> Stream.chunk_every(4, 4, [7, 8])
+           |> Stream.take(2)
+           |> Enum.to_list() == [[1, 2, 3, 4], [5, 6, 7, 8]]
+
+    assert 1..10
+           |> Stream.take(6)
+           |> Stream.chunk_every(4, 4, [7, 8])
+           |> Stream.take(1)
+           |> Enum.to_list() == [[1, 2, 3, 4]]
+
+    assert 1..6 |> Stream.take(6) |> Stream.chunk_every(4, 4, [7, 8]) |> Enum.to_list() ==
+             [[1, 2, 3, 4], [5, 6, 7, 8]]
+  end
+
   test "chunk_by/2" do
     stream = Stream.chunk_by([1, 2, 2, 3, 4, 4, 6, 7, 7], &(rem(&1, 2) == 1))
 
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) ==
-           [[1], [2, 2], [3], [4, 4, 6], [7, 7]]
-    assert stream |> Stream.take(3) |> Enum.to_list ==
-           [[1], [2, 2], [3]]
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [[1], [2, 2], [3], [4, 4, 6], [7, 7]]
+    assert stream |> Stream.take(3) |> Enum.to_list() == [[1], [2, 2], [3]]
+    assert 1..10 |> Stream.chunk_every(2) |> Enum.take(2) == [[1, 2], [3, 4]]
   end
 
   test "chunk_by/2 is zippable" do
     stream = Stream.chunk_by([1, 2, 2, 3], &(rem(&1, 2) == 1))
-    list   = Enum.to_list(stream)
+    list = Enum.to_list(stream)
     assert Enum.zip(list, list) == Enum.zip(stream, stream)
   end
 
+  test "chunk_while/4" do
+    chunk_fun = fn i, acc ->
+      cond do
+        i > 10 -> {:halt, acc}
+        rem(i, 2) == 0 -> {:cont, Enum.reverse([i | acc]), []}
+        true -> {:cont, [i | acc]}
+      end
+    end
+
+    after_fun = fn
+      [] -> {:cont, []}
+      acc -> {:cont, Enum.reverse(acc), []}
+    end
+
+    assert Stream.chunk_while([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [], chunk_fun, after_fun)
+           |> Enum.to_list() == [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
+
+    assert Stream.chunk_while(0..9, [], chunk_fun, after_fun) |> Enum.to_list() ==
+             [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9]]
+
+    assert Stream.chunk_while(0..10, [], chunk_fun, after_fun) |> Enum.to_list() ==
+             [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
+
+    assert Stream.chunk_while(0..11, [], chunk_fun, after_fun) |> Enum.to_list() ==
+             [[0], [1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
+
+    assert Stream.chunk_while([5, 7, 9, 11], [], chunk_fun, after_fun) |> Enum.to_list() ==
+             [[5, 7, 9]]
+  end
+
+  test "chunk_while/4 with inner halt" do
+    chunk_fun = fn
+      i, [] ->
+        {:cont, [i]}
+
+      i, chunk ->
+        if rem(i, 2) == 0 do
+          {:cont, Enum.reverse(chunk), [i]}
+        else
+          {:cont, [i | chunk]}
+        end
+    end
+
+    after_fun = fn
+      [] -> {:cont, []}
+      chunk -> {:cont, Enum.reverse(chunk), []}
+    end
+
+    assert Stream.chunk_while([1, 2, 3, 4, 5], [], chunk_fun, after_fun) |> Enum.at(0) == [1]
+  end
+
+  test "chunk_while/4 regression case with concat" do
+    result =
+      ["WrongHeader\nJohn Doe", "skipped"]
+      |> Stream.take(1)
+      |> Stream.chunk_while(
+        "",
+        fn element, acc ->
+          {acc, elements} = String.split(acc <> element, "\n") |> List.pop_at(-1)
+          {:cont, elements, acc}
+        end,
+        &{:cont, [&1], []}
+      )
+      |> Stream.concat()
+      |> Enum.to_list()
+
+    assert result == ["WrongHeader", "John Doe"]
+  end
+
   test "concat/1" do
     stream = Stream.concat([1..3, [], [4, 5, 6], [], 7..9])
     assert is_function(stream)
 
-    assert Enum.to_list(stream) == [1,2,3,4,5,6,7,8,9]
-    assert Enum.take(stream, 5) == [1,2,3,4,5]
+    assert Enum.to_list(stream) == [1, 2, 3, 4, 5, 6, 7, 8, 9]
+    assert Enum.take(stream, 5) == [1, 2, 3, 4, 5]
 
     stream = Stream.concat([1..3, [4, 5, 6], Stream.cycle(7..100)])
     assert is_function(stream)
 
-    assert Enum.take(stream, 13) == [1,2,3,4,5,6,7,8,9,10,11,12,13]
+    assert Enum.take(stream, 13) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
   end
 
   test "concat/2" do
     stream = Stream.concat(1..3, 4..6)
     assert is_function(stream)
-    assert Stream.cycle(stream) |> Enum.take(16) == [1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4]
+
+    assert Stream.cycle(stream) |> Enum.take(16) ==
+             [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4]
 
     stream = Stream.concat(1..3, [])
     assert is_function(stream)
-    assert Stream.cycle(stream) |> Enum.take(5) == [1,2,3,1,2]
+    assert Stream.cycle(stream) |> Enum.take(5) == [1, 2, 3, 1, 2]
 
     stream = Stream.concat(1..6, Stream.cycle(7..9))
     assert is_function(stream)
-    assert Stream.drop(stream, 3) |> Enum.take(13) == [4,5,6,7,8,9,7,8,9,7,8,9,7]
+    assert Stream.drop(stream, 3) |> Enum.take(13) == [4, 5, 6, 7, 8, 9, 7, 8, 9, 7, 8, 9, 7]
 
     stream = Stream.concat(Stream.cycle(1..3), Stream.cycle(4..6))
     assert is_function(stream)
-    assert Enum.take(stream, 13) == [1,2,3,1,2,3,1,2,3,1,2,3,1]
+    assert Enum.take(stream, 13) == [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1]
+  end
+
+  test "concat/2 is zippable" do
+    stream = 1..2 |> Stream.take(2) |> Stream.concat(3..4)
+    assert Enum.zip(1..4, [1, 2, 3, 4]) == Enum.zip(1..4, stream)
   end
 
   test "concat/2 does not intercept wrapped lazy enumeration" do
     # concat returns a lazy enumeration that does not halt
     assert Stream.concat([[0], Stream.map([1, 2, 3], & &1), [4]])
            |> Stream.take_while(fn x -> x <= 4 end)
-           |> Enum.to_list == [0, 1, 2, 3, 4]
+           |> Enum.to_list() == [0, 1, 2, 3, 4]
 
     # concat returns a lazy enumeration that does halts
     assert Stream.concat([[0], Stream.take_while(1..6, &(&1 <= 3)), [4]])
            |> Stream.take_while(fn x -> x <= 4 end)
-           |> Enum.to_list == [0, 1, 2, 3, 4]
+           |> Enum.to_list() == [0, 1, 2, 3, 4]
   end
 
   test "cycle/1" do
-    stream = Stream.cycle([1,2,3])
+    stream = Stream.cycle([1, 2, 3])
     assert is_function(stream)
 
-    assert Stream.cycle([1,2,3]) |> Stream.take(5) |> Enum.to_list == [1,2,3,1,2]
-    assert Enum.take(stream, 5) == [1,2,3,1,2]
+    assert_raise ArgumentError, "cannot cycle over an empty enumerable", fn ->
+      Stream.cycle([])
+    end
+
+    assert_raise ArgumentError, "cannot cycle over an empty enumerable", fn ->
+      Stream.cycle(%{}) |> Enum.to_list()
+    end
+
+    assert Stream.cycle([1, 2, 3]) |> Stream.take(5) |> Enum.to_list() == [1, 2, 3, 1, 2]
+    assert Enum.take(stream, 5) == [1, 2, 3, 1, 2]
   end
 
   test "cycle/1 is zippable" do
-    stream = Stream.cycle([1,2,3])
-    assert Enum.zip(1..6, [1,2,3,1,2,3]) == Enum.zip(1..6, stream)
+    stream = Stream.cycle([1, 2, 3])
+    assert Enum.zip(1..6, [1, 2, 3, 1, 2, 3]) == Enum.zip(1..6, stream)
   end
 
   test "cycle/1 with inner stream" do
-    assert [1,2,3] |> Stream.take(2) |> Stream.cycle |> Enum.take(4) ==
-           [1,2,1,2]
+    assert [1, 2, 3] |> Stream.take(2) |> Stream.cycle() |> Enum.take(4) == [1, 2, 1, 2]
+  end
+
+  test "cycle/1 with cycle/1 with cycle/1" do
+    assert [1] |> Stream.cycle() |> Stream.cycle() |> Stream.cycle() |> Enum.take(5) ==
+             [1, 1, 1, 1, 1]
+  end
+
+  test "dedup/1 is lazy" do
+    assert lazy?(Stream.dedup([1, 2, 3]))
+  end
+
+  test "dedup/1" do
+    assert Stream.dedup([1, 1, 2, 1, 1, 2, 1]) |> Enum.to_list() == [1, 2, 1, 2, 1]
+    assert Stream.dedup([2, 1, 1, 2, 1]) |> Enum.to_list() == [2, 1, 2, 1]
+    assert Stream.dedup([1, 2, 3, 4]) |> Enum.to_list() == [1, 2, 3, 4]
+    assert Stream.dedup([1, 1.0, 2.0, 2]) |> Enum.to_list() == [1, 1.0, 2.0, 2]
+    assert Stream.dedup([]) |> Enum.to_list() == []
+
+    assert Stream.dedup([nil, nil, true, {:value, true}]) |> Enum.to_list() ==
+             [nil, true, {:value, true}]
+
+    assert Stream.dedup([nil]) |> Enum.to_list() == [nil]
+  end
+
+  test "dedup_by/2" do
+    assert Stream.dedup_by([{1, :x}, {2, :y}, {2, :z}, {1, :x}], fn {x, _} -> x end)
+           |> Enum.to_list() == [{1, :x}, {2, :y}, {1, :x}]
   end
 
   test "drop/2" do
     stream = Stream.drop(1..10, 5)
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [6,7,8,9,10]
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [6, 7, 8, 9, 10]
 
-    assert Enum.to_list(Stream.drop(1..5, 0)) == [1,2,3,4,5]
+    assert Enum.to_list(Stream.drop(1..5, 0)) == [1, 2, 3, 4, 5]
     assert Enum.to_list(Stream.drop(1..3, 5)) == []
 
     nats = Stream.iterate(1, &(&1 + 1))
-    assert Stream.drop(nats, 2) |> Enum.take(5) == [3,4,5,6,7]
+    assert Stream.drop(nats, 2) |> Enum.take(5) == [3, 4, 5, 6, 7]
   end
 
   test "drop/2 with negative count" do
     stream = Stream.drop(1..10, -5)
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [1,2,3,4,5]
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [1, 2, 3, 4, 5]
 
     stream = Stream.drop(1..10, -5)
-    list   = Enum.to_list(stream)
+    list = Enum.to_list(stream)
     assert Enum.zip(list, list) == Enum.zip(stream, stream)
   end
 
   test "drop/2 with negative count stream entries" do
-    par = self
-    pid = spawn_link fn ->
-      Enum.each Stream.drop(&inbox_stream/2, -3),
-                fn x -> send par, {:stream, x} end
-    end
+    par = self()
 
-    send pid, {:stream, 1}
-    send pid, {:stream, 2}
-    send pid, {:stream, 3}
-    refute_receive {:stream, 1}
+    pid =
+      spawn_link(fn ->
+        Enum.each(Stream.drop(&inbox_stream/2, -3), fn x -> send(par, {:stream, x}) end)
+      end)
 
-    send pid, {:stream, 4}
+    send(pid, {:stream, 1})
+    send(pid, {:stream, 2})
+    send(pid, {:stream, 3})
+    refute_receive {:stream, 1}, 100
+
+    send(pid, {:stream, 4})
     assert_receive {:stream, 1}
 
-    send pid, {:stream, 5}
+    send(pid, {:stream, 5})
     assert_receive {:stream, 2}
-    refute_receive {:stream, 3}
+    refute_receive {:stream, 3}, 100
+  end
+
+  test "drop_every/2" do
+    assert 1..10
+           |> Stream.drop_every(2)
+           |> Enum.to_list() == [2, 4, 6, 8, 10]
+
+    assert 1..10
+           |> Stream.drop_every(3)
+           |> Enum.to_list() == [2, 3, 5, 6, 8, 9]
+
+    assert 1..10
+           |> Stream.drop(2)
+           |> Stream.drop_every(2)
+           |> Stream.drop(1)
+           |> Enum.to_list() == [6, 8, 10]
+
+    assert 1..10
+           |> Stream.drop_every(0)
+           |> Enum.to_list() == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    assert []
+           |> Stream.drop_every(10)
+           |> Enum.to_list() == []
+  end
+
+  test "drop_every/2 without non-negative integer" do
+    assert_raise FunctionClauseError, fn ->
+      Stream.drop_every(1..10, -1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Stream.drop_every(1..10, 3.33)
+    end
   end
 
   test "drop_while/2" do
     stream = Stream.drop_while(1..10, &(&1 <= 5))
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [6,7,8,9,10]
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [6, 7, 8, 9, 10]
 
-    assert Enum.to_list(Stream.drop_while(1..5, &(&1 <= 0))) == [1,2,3,4,5]
+    assert Enum.to_list(Stream.drop_while(1..5, &(&1 <= 0))) == [1, 2, 3, 4, 5]
     assert Enum.to_list(Stream.drop_while(1..3, &(&1 <= 5))) == []
 
     nats = Stream.iterate(1, &(&1 + 1))
-    assert Stream.drop_while(nats, &(&1 <= 5)) |> Enum.take(5) == [6,7,8,9,10]
+    assert Stream.drop_while(nats, &(&1 <= 5)) |> Enum.take(5) == [6, 7, 8, 9, 10]
+  end
+
+  test "duplicate/2" do
+    stream = Stream.duplicate(7, 7)
+
+    assert is_function(stream)
+    assert stream |> Stream.take(5) |> Enum.to_list() == [7, 7, 7, 7, 7]
+    assert Enum.to_list(stream) == [7, 7, 7, 7, 7, 7, 7]
   end
 
   test "each/2" do
     Process.put(:stream_each, [])
 
-    stream = Stream.each([1,2,3], fn x ->
-      Process.put(:stream_each, [x|Process.get(:stream_each)])
-    end)
+    stream =
+      Stream.each([1, 2, 3], fn x ->
+        Process.put(:stream_each, [x | Process.get(:stream_each)])
+      end)
 
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [1,2,3]
-    assert Process.get(:stream_each) == [3,2,1]
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [1, 2, 3]
+    assert Process.get(:stream_each) == [3, 2, 1]
   end
 
   test "filter/2" do
-    stream = Stream.filter([1,2,3], fn(x) -> rem(x, 2) == 0 end)
-    assert is_lazy(stream)
+    stream = Stream.filter([1, 2, 3], fn x -> rem(x, 2) == 0 end)
+    assert lazy?(stream)
     assert Enum.to_list(stream) == [2]
 
     nats = Stream.iterate(1, &(&1 + 1))
-    assert Stream.filter(nats, &(rem(&1, 2) == 0)) |> Enum.take(5) == [2,4,6,8,10]
-  end
-
-  test "filter_map/3" do
-    stream = Stream.filter_map([1,2,3], fn(x) -> rem(x, 2) == 0 end, &(&1 * 2))
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [4]
-
-    nats = Stream.iterate(1, &(&1 + 1))
-    assert Stream.filter_map(nats, &(rem(&1, 2) == 0), &(&1 * 2))
-           |> Enum.take(5) == [4,8,12,16,20]
+    assert Stream.filter(nats, &(rem(&1, 2) == 0)) |> Enum.take(5) == [2, 4, 6, 8, 10]
   end
 
   test "flat_map/2" do
     stream = Stream.flat_map([1, 2, 3], &[&1, &1 * 2])
-    assert is_lazy(stream)
+    assert lazy?(stream)
     assert Enum.to_list(stream) == [1, 2, 2, 4, 3, 6]
 
     nats = Stream.iterate(1, &(&1 + 1))
@@ -222,59 +434,67 @@ defmodule StreamTest do
   test "flat_map/2 does not intercept wrapped lazy enumeration" do
     # flat_map returns a lazy enumeration that does not halt
     assert [1, 2, 3, -1, -2]
-           |> Stream.flat_map(fn x -> Stream.map([x, x+1], & &1) end)
+           |> Stream.flat_map(fn x -> Stream.map([x, x + 1], & &1) end)
            |> Stream.take_while(fn x -> x >= 0 end)
-           |> Enum.to_list == [1, 2, 2, 3, 3, 4]
+           |> Enum.to_list() == [1, 2, 2, 3, 3, 4]
 
     # flat_map returns a lazy enumeration that does halts
     assert [1, 2, 3, -1, -2]
-           |> Stream.flat_map(fn x -> Stream.take_while([x, x+1, x+2], &(&1 <= x + 1)) end)
+           |> Stream.flat_map(fn x -> Stream.take_while([x, x + 1, x + 2], &(&1 <= x + 1)) end)
            |> Stream.take_while(fn x -> x >= 0 end)
-           |> Enum.to_list == [1, 2, 2, 3, 3, 4]
+           |> Enum.to_list() == [1, 2, 2, 3, 3, 4]
 
     # flat_map returns a lazy enumeration that does halts wrapped in an enumerable
     assert [1, 2, 3, -1, -2]
-           |> Stream.flat_map(fn x -> Stream.concat([x], Stream.take_while([x+1, x+2], &(&1 <= x + 1))) end)
+           |> Stream.flat_map(fn x ->
+             Stream.concat([x], Stream.take_while([x + 1, x + 2], &(&1 <= x + 1)))
+           end)
            |> Stream.take_while(fn x -> x >= 0 end)
-           |> Enum.to_list == [1, 2, 2, 3, 3, 4]
+           |> Enum.to_list() == [1, 2, 2, 3, 3, 4]
   end
 
   test "flat_map/2 is zippable" do
-    stream = [1, 2, 3, -1, -2]
-             |> Stream.flat_map(fn x -> Stream.map([x, x+1], & &1) end)
-             |> Stream.take_while(fn x -> x >= 0 end)
-    list   = Enum.to_list(stream)
+    stream =
+      [1, 2, 3, -1, -2]
+      |> Stream.flat_map(fn x -> Stream.map([x, x + 1], & &1) end)
+      |> Stream.take_while(fn x -> x >= 0 end)
+
+    list = Enum.to_list(stream)
     assert Enum.zip(list, list) == Enum.zip(stream, stream)
   end
 
   test "flat_map/2 does not leave inner stream suspended" do
-    stream = Stream.flat_map [1,2,3],
-      fn i ->
-        Stream.resource(fn -> i end,
-                        fn acc -> {acc, acc + 1} end,
-                        fn _ -> Process.put(:stream_flat_map, true) end)
-      end
+    stream =
+      Stream.flat_map([1, 2, 3], fn i ->
+        Stream.resource(fn -> i end, fn acc -> {[acc], acc + 1} end, fn _ ->
+          Process.put(:stream_flat_map, true)
+        end)
+      end)
 
     Process.put(:stream_flat_map, false)
-    assert stream |> Enum.take(3) == [1,2,3]
+    assert stream |> Enum.take(3) == [1, 2, 3]
     assert Process.get(:stream_flat_map)
   end
 
   test "flat_map/2 does not leave outer stream suspended" do
-    stream = Stream.resource(fn -> 1 end,
-                             fn acc -> {acc, acc + 1} end,
-                             fn _ -> Process.put(:stream_flat_map, true) end)
+    stream =
+      Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->
+        Process.put(:stream_flat_map, true)
+      end)
+
     stream = Stream.flat_map(stream, fn i -> [i, i + 1, i + 2] end)
 
     Process.put(:stream_flat_map, false)
-    assert stream |> Enum.take(3) == [1,2,3]
+    assert stream |> Enum.take(3) == [1, 2, 3]
     assert Process.get(:stream_flat_map)
   end
 
   test "flat_map/2 closes on error" do
-    stream = Stream.resource(fn -> 1 end,
-                             fn acc -> {acc, acc + 1} end,
-                             fn _ -> Process.put(:stream_flat_map, true) end)
+    stream =
+      Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->
+        Process.put(:stream_flat_map, true)
+      end)
+
     stream = Stream.flat_map(stream, fn _ -> throw(:error) end)
 
     Process.put(:stream_flat_map, false)
@@ -282,20 +502,58 @@ defmodule StreamTest do
     assert Process.get(:stream_flat_map)
   end
 
+  test "flat_map/2 with inner flat_map/2" do
+    stream =
+      Stream.flat_map(1..5, fn x ->
+        Stream.flat_map([x], fn x ->
+          x..(x * x)
+        end)
+        |> Stream.map(&(&1 * 1))
+      end)
+
+    assert Enum.take(stream, 5) == [1, 2, 3, 4, 3]
+  end
+
+  test "flat_map/2 properly halts both inner and outer stream when inner stream is halted" do
+    # Fixes a bug that, when the inner stream was done,
+    # sending it a halt would cause it to return the
+    # inner stream was halted, forcing flat_map to get
+    # the next value from the outer stream, evaluate it,
+    # get another inner stream, just to halt it.
+    # 2 should never be used
+    assert [1, 2]
+           |> Stream.flat_map(fn 1 -> Stream.repeatedly(fn -> 1 end) end)
+           |> Stream.flat_map(fn 1 -> Stream.repeatedly(fn -> 1 end) end)
+           |> Enum.take(1) == [1]
+  end
+
+  test "interval/1" do
+    stream = Stream.interval(10)
+    {time_us, value} = :timer.tc(fn -> Enum.take(stream, 5) end)
+
+    assert value == [0, 1, 2, 3, 4]
+    assert time_us >= 50000
+  end
+
+  test "interval/1 with infinity" do
+    stream = Stream.interval(:infinity)
+    spawn(Stream, :run, [stream])
+  end
+
   test "into/2 and run/1" do
     Process.put(:stream_cont, [])
     Process.put(:stream_done, false)
     Process.put(:stream_halt, false)
 
-    stream = Stream.into([1, 2, 3], collectable_pdict)
+    stream = Stream.into([1, 2, 3], %Pdict{})
 
-    assert is_lazy(stream)
+    assert lazy?(stream)
     assert Stream.run(stream) == :ok
-    assert Process.get(:stream_cont) == [3,2,1]
+    assert Process.get(:stream_cont) == [3, 2, 1]
     assert Process.get(:stream_done)
     refute Process.get(:stream_halt)
 
-    stream = Stream.into(fn _, _ -> raise "error" end, collectable_pdict)
+    stream = Stream.into(fn _, _ -> raise "error" end, %Pdict{})
     catch_error(Stream.run(stream))
     assert Process.get(:stream_halt)
   end
@@ -305,9 +563,9 @@ defmodule StreamTest do
     Process.put(:stream_done, false)
     Process.put(:stream_halt, false)
 
-    stream = Stream.into([1, 2, 3], collectable_pdict, fn x -> x*2 end)
+    stream = Stream.into([1, 2, 3], %Pdict{}, fn x -> x * 2 end)
 
-    assert is_lazy(stream)
+    assert lazy?(stream)
     assert Enum.to_list(stream) == [1, 2, 3]
     assert Process.get(:stream_cont) == [6, 4, 2]
     assert Process.get(:stream_done)
@@ -319,9 +577,9 @@ defmodule StreamTest do
     Process.put(:stream_done, false)
     Process.put(:stream_halt, false)
 
-    stream = Stream.into([1, 2, 3], collectable_pdict)
+    stream = Stream.into([1, 2, 3], %Pdict{})
 
-    assert is_lazy(stream)
+    assert lazy?(stream)
     assert Enum.take(stream, 1) == [1]
     assert Process.get(:stream_cont) == [1]
     assert Process.get(:stream_done)
@@ -330,29 +588,60 @@ defmodule StreamTest do
 
   test "transform/3" do
     stream = Stream.transform([1, 2, 3], 0, &{[&1, &2], &1 + &2})
-    assert is_lazy(stream)
+    assert lazy?(stream)
     assert Enum.to_list(stream) == [1, 0, 2, 1, 3, 3]
 
     nats = Stream.iterate(1, &(&1 + 1))
     assert Stream.transform(nats, 0, &{[&1, &2], &1 + &2}) |> Enum.take(6) == [1, 0, 2, 1, 3, 3]
   end
 
+  test "transform/3 with early halt" do
+    stream =
+      fn -> throw(:error) end
+      |> Stream.repeatedly()
+      |> Stream.transform(nil, &{[&1, &2], &1})
+
+    assert {:halted, nil} = Enumerable.reduce(stream, {:halt, nil}, fn _, _ -> throw(:error) end)
+  end
+
+  test "transform/3 with early suspend" do
+    stream =
+      Stream.repeatedly(fn -> throw(:error) end)
+      |> Stream.transform(nil, &{[&1, &2], &1})
+
+    assert {:suspended, nil, _} =
+             Enumerable.reduce(stream, {:suspend, nil}, fn _, _ -> throw(:error) end)
+  end
+
   test "transform/3 with halt" do
-    stream = Stream.resource(fn -> 1 end,
-                             fn acc -> {acc, acc + 1} end,
-                             fn _ -> Process.put(:stream_transform, true) end)
-    stream = Stream.transform(stream, 0, fn i, acc -> if acc < 3, do: {[i], acc + 1}, else: {:halt, acc} end)
+    stream =
+      Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->
+        Process.put(:stream_transform, true)
+      end)
+
+    stream =
+      Stream.transform(stream, 0, fn i, acc ->
+        if acc < 3, do: {[i], acc + 1}, else: {:halt, acc}
+      end)
 
     Process.put(:stream_transform, false)
-    assert Enum.to_list(stream) == [1,2,3]
+    assert Enum.to_list(stream) == [1, 2, 3]
     assert Process.get(:stream_transform)
   end
 
+  test "transform/3 (via flat_map) handles multiple returns from suspension" do
+    assert [false]
+           |> Stream.take(1)
+           |> Stream.concat([true])
+           |> Stream.flat_map(&[&1])
+           |> Enum.to_list() == [false, true]
+  end
+
   test "iterate/2" do
-    stream = Stream.iterate(0, &(&1+2))
-    assert Enum.take(stream, 5) == [0,2,4,6,8]
-    stream = Stream.iterate(5, &(&1+2))
-    assert Enum.take(stream, 5) == [5,7,9,11,13]
+    stream = Stream.iterate(0, &(&1 + 2))
+    assert Enum.take(stream, 5) == [0, 2, 4, 6, 8]
+    stream = Stream.iterate(5, &(&1 + 2))
+    assert Enum.take(stream, 5) == [5, 7, 9, 11, 13]
 
     # Only calculate values if needed
     stream = Stream.iterate("HELLO", &raise/1)
@@ -360,49 +649,173 @@ defmodule StreamTest do
   end
 
   test "map/2" do
-    stream = Stream.map([1,2,3], &(&1 * 2))
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [2,4,6]
+    stream = Stream.map([1, 2, 3], &(&1 * 2))
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [2, 4, 6]
 
     nats = Stream.iterate(1, &(&1 + 1))
-    assert Stream.map(nats, &(&1 * 2)) |> Enum.take(5) == [2,4,6,8,10]
+    assert Stream.map(nats, &(&1 * 2)) |> Enum.take(5) == [2, 4, 6, 8, 10]
     assert Stream.map(nats, &(&1 - 2)) |> Stream.map(&(&1 * 2)) |> Enum.take(3) == [-2, 0, 2]
   end
 
+  test "map_every/3" do
+    assert 1..10
+           |> Stream.map_every(2, &(&1 * 2))
+           |> Enum.to_list() == [2, 2, 6, 4, 10, 6, 14, 8, 18, 10]
+
+    assert 1..10
+           |> Stream.map_every(3, &(&1 * 2))
+           |> Enum.to_list() == [2, 2, 3, 8, 5, 6, 14, 8, 9, 20]
+
+    assert 1..10
+           |> Stream.drop(2)
+           |> Stream.map_every(2, &(&1 * 2))
+           |> Stream.drop(1)
+           |> Enum.to_list() == [4, 10, 6, 14, 8, 18, 10]
+
+    assert 1..5
+           |> Stream.map_every(0, &(&1 * 2))
+           |> Enum.to_list() == [1, 2, 3, 4, 5]
+
+    assert []
+           |> Stream.map_every(10, &(&1 * 2))
+           |> Enum.to_list() == []
+
+    assert_raise FunctionClauseError, fn ->
+      Stream.map_every(1..10, -1, &(&1 * 2))
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Stream.map_every(1..10, 3.33, &(&1 * 2))
+    end
+  end
+
   test "reject/2" do
-    stream = Stream.reject([1,2,3], fn(x) -> rem(x, 2) == 0 end)
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [1,3]
+    stream = Stream.reject([1, 2, 3], fn x -> rem(x, 2) == 0 end)
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [1, 3]
 
     nats = Stream.iterate(1, &(&1 + 1))
-    assert Stream.reject(nats, &(rem(&1, 2) == 0)) |> Enum.take(5) == [1,3,5,7,9]
+    assert Stream.reject(nats, &(rem(&1, 2) == 0)) |> Enum.take(5) == [1, 3, 5, 7, 9]
   end
 
   test "repeatedly/1" do
     stream = Stream.repeatedly(fn -> 1 end)
-    assert Enum.take(stream, 5) == [1,1,1,1,1]
-    stream = Stream.repeatedly(&:random.uniform/0)
-    [r1,r2] = Enum.take(stream, 2)
+    assert Enum.take(stream, 5) == [1, 1, 1, 1, 1]
+    stream = Stream.repeatedly(&:rand.uniform/0)
+    [r1, r2] = Enum.take(stream, 2)
     assert r1 != r2
   end
 
-  test "resource/3 closes on errors" do
-    stream = Stream.resource(fn -> 1 end,
-                             fn acc -> {acc, acc + 1} end,
-                             fn _ -> Process.put(:stream_resource, true) end)
+  test "resource/3 closes on outer errors" do
+    stream =
+      Stream.resource(
+        fn -> 1 end,
+        fn
+          2 -> throw(:error)
+          acc -> {[acc], acc + 1}
+        end,
+        fn 2 -> Process.put(:stream_resource, true) end
+      )
 
     Process.put(:stream_resource, false)
-    stream = Stream.map(stream, fn x -> if x > 2, do: throw(:error), else: x end)
     assert catch_throw(Enum.to_list(stream)) == :error
     assert Process.get(:stream_resource)
   end
 
+  test "resource/3 closes with correct accumulator on outer errors with inner single-element list" do
+    stream =
+      Stream.resource(
+        fn -> :start end,
+        fn _ -> {[:error], :end} end,
+        fn acc -> Process.put(:stream_resource, acc) end
+      )
+      |> Stream.map(fn :error -> throw(:error) end)
+
+    Process.put(:stream_resource, nil)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_resource) == :end
+  end
+
+  test "resource/3 closes with correct accumulator on outer errors with inner list" do
+    stream =
+      Stream.resource(
+        fn -> :start end,
+        fn _ -> {[:ok, :error], :end} end,
+        fn acc -> Process.put(:stream_resource, acc) end
+      )
+      |> Stream.map(fn acc -> if acc == :error, do: throw(:error), else: acc end)
+
+    Process.put(:stream_resource, nil)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_resource) == :end
+  end
+
+  test "resource/3 closes with correct accumulator on outer errors with inner enum" do
+    stream =
+      Stream.resource(
+        fn -> 1 end,
+        fn acc -> {acc..(acc + 2), acc + 1} end,
+        fn acc -> Process.put(:stream_resource, acc) end
+      )
+      |> Stream.map(fn x -> if x > 2, do: throw(:error), else: x end)
+
+    Process.put(:stream_resource, nil)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_resource) == 2
+  end
+
   test "resource/3 is zippable" do
-    stream = Stream.resource(fn -> 1 end,
-                             fn 10 -> nil
-                                acc -> {acc, acc + 1}
-                             end,
-                             fn _ -> Process.put(:stream_resource, true) end)
+    transform_fun = fn
+      10 -> {:halt, 10}
+      acc -> {[acc], acc + 1}
+    end
+
+    after_fun = fn _ -> Process.put(:stream_resource, true) end
+    stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)
+
+    list = Enum.to_list(stream)
+    Process.put(:stream_resource, false)
+    assert Enum.zip(list, list) == Enum.zip(stream, stream)
+    assert Process.get(:stream_resource)
+  end
+
+  test "resource/3 returning inner empty list" do
+    transform_fun = fn acc -> if rem(acc, 2) == 0, do: {[], acc + 1}, else: {[acc], acc + 1} end
+    stream = Stream.resource(fn -> 1 end, transform_fun, fn _ -> :ok end)
+
+    assert Enum.take(stream, 5) == [1, 3, 5, 7, 9]
+  end
+
+  test "resource/3 halts with inner list" do
+    transform_fun = fn acc -> {[acc, acc + 1, acc + 2], acc + 1} end
+    after_fun = fn _ -> Process.put(:stream_resource, true) end
+    stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)
+
+    Process.put(:stream_resource, false)
+    assert Enum.take(stream, 5) == [1, 2, 3, 2, 3]
+    assert Process.get(:stream_resource)
+  end
+
+  test "resource/3 closes on errors with inner list" do
+    transform_fun = fn acc -> {[acc, acc + 1, acc + 2], acc + 1} end
+    after_fun = fn _ -> Process.put(:stream_resource, true) end
+    stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)
+
+    Process.put(:stream_resource, false)
+    stream = Stream.map(stream, fn x -> if x > 2, do: throw(:error), else: x end)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_resource)
+  end
+
+  test "resource/3 is zippable with inner list" do
+    transform_fun = fn
+      10 -> {:halt, 10}
+      acc -> {[acc, acc + 1, acc + 2], acc + 1}
+    end
+
+    after_fun = fn _ -> Process.put(:stream_resource, true) end
+    stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)
 
     list = Enum.to_list(stream)
     Process.put(:stream_resource, false)
@@ -410,159 +823,625 @@ defmodule StreamTest do
     assert Process.get(:stream_resource)
   end
 
+  test "resource/3 halts with inner enum" do
+    transform_fun = fn acc -> {acc..(acc + 2), acc + 1} end
+    after_fun = fn _ -> Process.put(:stream_resource, true) end
+    stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)
+
+    Process.put(:stream_resource, false)
+    assert Enum.take(stream, 5) == [1, 2, 3, 2, 3]
+    assert Process.get(:stream_resource)
+  end
+
+  test "resource/3 closes on errors with inner enum" do
+    transform_fun = fn acc -> {acc..(acc + 2), acc + 1} end
+    after_fun = fn _ -> Process.put(:stream_resource, true) end
+    stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)
+
+    Process.put(:stream_resource, false)
+    stream = Stream.map(stream, fn x -> if x > 2, do: throw(:error), else: x end)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_resource)
+  end
+
+  test "resource/3 is zippable with inner enum" do
+    transform_fun = fn
+      10 -> {:halt, 10}
+      acc -> {acc..(acc + 2), acc + 1}
+    end
+
+    after_fun = fn _ -> Process.put(:stream_resource, true) end
+    stream = Stream.resource(fn -> 1 end, transform_fun, after_fun)
+
+    list = Enum.to_list(stream)
+    Process.put(:stream_resource, false)
+    assert Enum.zip(list, list) == Enum.zip(stream, stream)
+    assert Process.get(:stream_resource)
+  end
+
+  test "transform/4" do
+    transform_fun = fn x, acc -> {[x, x + acc], x} end
+    after_fun = fn 10 -> Process.put(:stream_transform, true) end
+    stream = Stream.transform(1..10, fn -> 0 end, transform_fun, after_fun)
+    Process.put(:stream_transform, false)
+
+    assert Enum.to_list(stream) ==
+             [1, 1, 2, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19]
+
+    assert Process.get(:stream_transform)
+  end
+
+  test "transform/4 with early halt" do
+    after_fun = fn nil -> Process.put(:stream_transform, true) end
+
+    stream =
+      fn -> throw(:error) end
+      |> Stream.repeatedly()
+      |> Stream.transform(fn -> nil end, &{[&1, &2], &1}, after_fun)
+
+    Process.put(:stream_transform, false)
+    assert {:halted, nil} = Enumerable.reduce(stream, {:halt, nil}, fn _, _ -> throw(:error) end)
+    assert Process.get(:stream_transform)
+  end
+
+  test "transform/4 with early suspend" do
+    after_fun = fn nil -> Process.put(:stream_transform, true) end
+
+    stream =
+      fn -> throw(:error) end
+      |> Stream.repeatedly()
+      |> Stream.transform(fn -> nil end, &{[&1, &2], &1}, after_fun)
+
+    refute Process.get(:stream_transform)
+
+    assert {:suspended, nil, _} =
+             Enumerable.reduce(stream, {:suspend, nil}, fn _, _ -> throw(:error) end)
+  end
+
+  test "transform/4 closes on outer errors" do
+    transform_fun = fn
+      3, _ -> throw(:error)
+      x, acc -> {[x + acc], x}
+    end
+
+    after_fun = fn 2 -> Process.put(:stream_transform, true) end
+
+    stream = Stream.transform(1..10, fn -> 0 end, transform_fun, after_fun)
+
+    Process.put(:stream_transform, false)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_transform)
+  end
+
+  test "transform/4 closes on nested errors" do
+    transform_fun = fn
+      3, _ -> throw(:error)
+      x, acc -> {[x + acc], x}
+    end
+
+    after_fun = fn _ -> Process.put(:stream_transform_inner, true) end
+    outer_after_fun = fn 0 -> Process.put(:stream_transform_outer, true) end
+
+    stream =
+      1..10
+      |> Stream.transform(fn -> 0 end, transform_fun, after_fun)
+      |> Stream.transform(fn -> 0 end, fn x, acc -> {[x], acc} end, outer_after_fun)
+
+    Process.put(:stream_transform_inner, false)
+    Process.put(:stream_transform_outer, false)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_transform_inner)
+    assert Process.get(:stream_transform_outer)
+  end
+
+  test "transform/4 is zippable" do
+    transform_fun = fn
+      10, acc -> {:halt, acc}
+      x, acc -> {[x + acc], x}
+    end
+
+    after_fun = fn 9 -> Process.put(:stream_transform, true) end
+    stream = Stream.transform(1..20, fn -> 0 end, transform_fun, after_fun)
+
+    list = Enum.to_list(stream)
+    Process.put(:stream_transform, false)
+    assert Enum.zip(list, list) == Enum.zip(stream, stream)
+    assert Process.get(:stream_transform)
+  end
+
+  test "transform/4 halts with inner list" do
+    transform_fun = fn x, acc -> {[x, x + 1, x + 2], acc} end
+    after_fun = fn :acc -> Process.put(:stream_transform, true) end
+    stream = Stream.transform(1..10, fn -> :acc end, transform_fun, after_fun)
+
+    Process.put(:stream_transform, false)
+    assert Enum.take(stream, 5) == [1, 2, 3, 2, 3]
+    assert Process.get(:stream_transform)
+  end
+
+  test "transform/4 closes on errors with inner list" do
+    transform_fun = fn x, acc -> {[x, x + 1, x + 2], acc} end
+    after_fun = fn :acc -> Process.put(:stream_transform, true) end
+    stream = Stream.transform(1..10, fn -> :acc end, transform_fun, after_fun)
+
+    Process.put(:stream_transform, false)
+    stream = Stream.map(stream, fn x -> if x > 2, do: throw(:error), else: x end)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_transform)
+  end
+
+  test "transform/4 is zippable with inner list" do
+    transform_fun = fn
+      10, acc -> {:halt, acc}
+      x, acc -> {[x, x + 1, x + 2], acc}
+    end
+
+    after_fun = fn :inner -> Process.put(:stream_transform, true) end
+
+    stream = Stream.transform(1..20, fn -> :inner end, transform_fun, after_fun)
+
+    list = Enum.to_list(stream)
+    Process.put(:stream_transform, false)
+    assert Enum.zip(list, list) == Enum.zip(stream, stream)
+    assert Process.get(:stream_transform)
+  end
+
+  test "transform/4 halts with inner enum" do
+    transform_fun = fn x, acc -> {x..(x + 2), acc} end
+    after_fun = fn :acc -> Process.put(:stream_transform, true) end
+    stream = Stream.transform(1..10, fn -> :acc end, transform_fun, after_fun)
+
+    Process.put(:stream_transform, false)
+    assert Enum.take(stream, 5) == [1, 2, 3, 2, 3]
+    assert Process.get(:stream_transform)
+  end
+
+  test "transform/4 closes on errors with inner enum" do
+    transform_fun = fn x, acc -> {x..(x + 2), acc} end
+    after_fun = fn :acc -> Process.put(:stream_transform, true) end
+    stream = Stream.transform(1..10, fn -> :acc end, transform_fun, after_fun)
+
+    Process.put(:stream_transform, false)
+    stream = Stream.map(stream, fn x -> if x > 2, do: throw(:error), else: x end)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_transform)
+  end
+
+  test "transform/4 is zippable with inner enum" do
+    transform_fun = fn
+      10, acc -> {:halt, acc}
+      x, acc -> {x..(x + 2), acc}
+    end
+
+    after_fun = fn :inner -> Process.put(:stream_transform, true) end
+    stream = Stream.transform(1..20, fn -> :inner end, transform_fun, after_fun)
+
+    list = Enum.to_list(stream)
+    Process.put(:stream_transform, false)
+    assert Enum.zip(list, list) == Enum.zip(stream, stream)
+    assert Process.get(:stream_transform)
+  end
+
+  test "transform/5 emits last elements on done" do
+    stream =
+      Stream.transform(
+        1..5//2,
+        fn -> 0 end,
+        fn i, _acc -> {i..(i + 1), i + 1} end,
+        fn 6 -> {7..10, 10} end,
+        fn i when is_integer(i) -> Process.put(__MODULE__, i) end
+      )
+
+    assert Enum.to_list(stream) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    assert Process.get(__MODULE__) == 10
+
+    assert Enum.take(stream, 3) == [1, 2, 3]
+    assert Process.get(__MODULE__) == 4
+
+    assert Enum.take(stream, 4) == [1, 2, 3, 4]
+    assert Process.get(__MODULE__) == 4
+
+    assert Enum.take(stream, 7) == [1, 2, 3, 4, 5, 6, 7]
+    assert Process.get(__MODULE__) == 10
+  end
+
+  test "transform/5 emits last elements on inner halt done" do
+    stream =
+      Stream.transform(
+        Stream.take(1..15//2, 3),
+        fn -> 0 end,
+        fn i, _acc -> {i..(i + 1), i + 1} end,
+        fn 6 -> {7..10, 10} end,
+        fn i when is_integer(i) -> Process.put(__MODULE__, i) end
+      )
+
+    assert Enum.to_list(stream) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    assert Process.get(__MODULE__) == 10
+
+    assert Enum.take(stream, 3) == [1, 2, 3]
+    assert Process.get(__MODULE__) == 4
+
+    assert Enum.take(stream, 4) == [1, 2, 3, 4]
+    assert Process.get(__MODULE__) == 4
+
+    assert Enum.take(stream, 7) == [1, 2, 3, 4, 5, 6, 7]
+    assert Process.get(__MODULE__) == 10
+  end
+
+  test "transform/5 does not halt twice" do
+    resource_start = fn -> 0 end
+
+    resource_next = fn current ->
+      if current < 5 do
+        {[current], current + 1}
+      else
+        {:halt, current}
+      end
+    end
+
+    resource_after = fn _ ->
+      send(self(), {:halted, :resource})
+    end
+
+    transform_next = fn current, index -> {[current + 1], index} end
+    transform_last = fn index -> {:halt, index} end
+
+    transform_after = fn _ ->
+      send(self(), {:halted, :transform})
+    end
+
+    Stream.resource(resource_start, resource_next, resource_after)
+    |> Stream.transform(fn -> 1 end, transform_next, transform_last, transform_after)
+    |> Stream.run()
+
+    assert_received {:halted, :resource}
+    assert_received {:halted, :transform}
+    refute_received {:halted, :resource}
+    refute_received {:halted, :transform}
+  end
+
   test "scan/2" do
     stream = Stream.scan(1..5, &(&1 + &2))
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [1,3,6,10,15]
-    assert Stream.scan([], &(&1 + &2)) |> Enum.to_list == []
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [1, 3, 6, 10, 15]
+    assert Stream.scan([], &(&1 + &2)) |> Enum.to_list() == []
   end
 
   test "scan/3" do
     stream = Stream.scan(1..5, 0, &(&1 + &2))
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [1,3,6,10,15]
-    assert Stream.scan([], 0, &(&1 + &2)) |> Enum.to_list == []
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [1, 3, 6, 10, 15]
+    assert Stream.scan([], 0, &(&1 + &2)) |> Enum.to_list() == []
   end
 
   test "take/2" do
     stream = Stream.take(1..1000, 5)
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [1,2,3,4,5]
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [1, 2, 3, 4, 5]
 
     assert Enum.to_list(Stream.take(1..1000, 0)) == []
-    assert Enum.to_list(Stream.take(1..3, 5)) == [1,2,3]
+    assert Enum.to_list(Stream.take([], 5)) == []
+    assert Enum.to_list(Stream.take(1..3, 5)) == [1, 2, 3]
 
     nats = Stream.iterate(1, &(&1 + 1))
-    assert Enum.to_list(Stream.take(nats, 5)) == [1,2,3,4,5]
+    assert Enum.to_list(Stream.take(nats, 5)) == [1, 2, 3, 4, 5]
 
     stream = Stream.drop(1..100, 5)
-    assert Stream.take(stream, 5) |> Enum.to_list == [6,7,8,9,10]
+    assert Stream.take(stream, 5) |> Enum.to_list() == [6, 7, 8, 9, 10]
 
     stream = 1..5 |> Stream.take(10) |> Stream.drop(15)
     assert {[], []} = Enum.split(stream, 5)
 
     stream = 1..20 |> Stream.take(10 + 5) |> Stream.drop(4)
-    assert Enum.to_list(stream) == [5,6,7,8,9,10,11,12,13,14,15]
+    assert Enum.to_list(stream) == [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+  end
+
+  test "take/2 does not consume next element on halt" do
+    assert [false, true]
+           |> Stream.each(&(&1 && raise("oops")))
+           |> Stream.take(1)
+           |> Stream.take_while(& &1)
+           |> Enum.to_list() == []
+  end
+
+  test "take/2 does not consume next element on suspend" do
+    assert [false, true]
+           |> Stream.each(&(&1 && raise("oops")))
+           |> Stream.take(1)
+           |> Stream.flat_map(&[&1])
+           |> Enum.to_list() == [false]
   end
 
   test "take/2 with negative count" do
     Process.put(:stream_each, [])
 
     stream = Stream.take(1..100, -5)
-    assert is_lazy(stream)
+    assert lazy?(stream)
 
-    stream = Stream.each(stream, &Process.put(:stream_each, [&1|Process.get(:stream_each)]))
-    assert Enum.to_list(stream) == [96,97,98,99,100]
-    assert Process.get(:stream_each) == [100,99,98,97,96]
+    stream = Stream.each(stream, &Process.put(:stream_each, [&1 | Process.get(:stream_each)]))
+    assert Enum.to_list(stream) == [96, 97, 98, 99, 100]
+    assert Process.get(:stream_each) == [100, 99, 98, 97, 96]
   end
 
   test "take/2 is zippable" do
     stream = Stream.take(1..1000, 5)
-    list   = Enum.to_list(stream)
+    list = Enum.to_list(stream)
     assert Enum.zip(list, list) == Enum.zip(stream, stream)
   end
 
   test "take_every/2" do
     assert 1..10
            |> Stream.take_every(2)
-           |> Enum.to_list == [1, 3, 5, 7, 9]
+           |> Enum.to_list() == [1, 3, 5, 7, 9]
+
+    assert 1..10
+           |> Stream.take_every(3)
+           |> Enum.to_list() == [1, 4, 7, 10]
 
     assert 1..10
            |> Stream.drop(2)
            |> Stream.take_every(2)
            |> Stream.drop(1)
-           |> Enum.to_list == [5, 7, 9]
+           |> Enum.to_list() == [5, 7, 9]
+
+    assert 1..10
+           |> Stream.take_every(0)
+           |> Enum.to_list() == []
+
+    assert []
+           |> Stream.take_every(10)
+           |> Enum.to_list() == []
+  end
+
+  test "take_every/2 without non-negative integer" do
+    assert_raise FunctionClauseError, fn ->
+      Stream.take_every(1..10, -1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      Stream.take_every(1..10, 3.33)
+    end
   end
 
   test "take_while/2" do
     stream = Stream.take_while(1..1000, &(&1 <= 5))
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [1,2,3,4,5]
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [1, 2, 3, 4, 5]
 
     assert Enum.to_list(Stream.take_while(1..1000, &(&1 <= 0))) == []
-    assert Enum.to_list(Stream.take_while(1..3, &(&1 <= 5))) == [1,2,3]
+    assert Enum.to_list(Stream.take_while(1..3, &(&1 <= 5))) == [1, 2, 3]
 
     nats = Stream.iterate(1, &(&1 + 1))
-    assert Enum.to_list(Stream.take_while(nats, &(&1 <= 5))) == [1,2,3,4,5]
+    assert Enum.to_list(Stream.take_while(nats, &(&1 <= 5))) == [1, 2, 3, 4, 5]
 
     stream = Stream.drop(1..100, 5)
-    assert Stream.take_while(stream, &(&1 < 11)) |> Enum.to_list == [6,7,8,9,10]
+    assert Stream.take_while(stream, &(&1 < 11)) |> Enum.to_list() == [6, 7, 8, 9, 10]
+  end
+
+  test "timer/1" do
+    stream = Stream.timer(10)
+
+    {time_us, value} = :timer.tc(fn -> Enum.to_list(stream) end)
+
+    assert value == [0]
+    # We check for >= 5000 (us) instead of >= 10000 (us)
+    # because the resolution on Windows system is not high
+    # enough and we would get a difference of 9000 from
+    # time to time. So a value halfway is good enough.
+    assert time_us >= 5000
+  end
+
+  test "timer/1 with infinity" do
+    stream = Stream.timer(:infinity)
+    spawn(Stream, :run, [stream])
   end
 
   test "unfold/2" do
-    stream = Stream.unfold(10, fn x -> if x > 0, do: {x, x-1}, else: nil end)
+    stream = Stream.unfold(10, fn x -> if x > 0, do: {x, x - 1} end)
     assert Enum.take(stream, 5) == [10, 9, 8, 7, 6]
-    stream = Stream.unfold(5, fn x -> if x > 0, do: {x, x-1}, else: nil end)
+    stream = Stream.unfold(5, fn x -> if x > 0, do: {x, x - 1} end)
     assert Enum.to_list(stream) == [5, 4, 3, 2, 1]
   end
 
   test "unfold/2 only calculates values if needed" do
-    stream = Stream.unfold(1, fn x -> if x > 0, do: {x, x-1}, else: throw(:boom) end)
+    stream = Stream.unfold(1, fn x -> if x > 0, do: {x, x - 1}, else: throw(:boom) end)
     assert Enum.take(stream, 1) == [1]
 
-    stream = Stream.unfold(5, fn x -> if x > 0, do: {x, x-1}, else: nil end)
+    stream = Stream.unfold(5, fn x -> if x > 0, do: {x, x - 1} end)
     assert Enum.to_list(Stream.take(stream, 2)) == [5, 4]
   end
 
   test "unfold/2 is zippable" do
-    stream = Stream.unfold(10, fn x -> if x > 0, do: {x, x-1}, else: nil end)
-    list   = Enum.to_list(stream)
+    stream = Stream.unfold(10, fn x -> if x > 0, do: {x, x - 1} end)
+    list = Enum.to_list(stream)
     assert Enum.zip(list, list) == Enum.zip(stream, stream)
   end
 
-  test "uniq/1" do
-    assert Stream.uniq([1, 2, 3, 2, 1]) |> Enum.to_list ==
-           [1, 2, 3]
+  test "uniq/1 & uniq/2" do
+    assert Stream.uniq([1, 2, 3, 2, 1]) |> Enum.to_list() == [1, 2, 3]
+  end
 
-    assert Stream.uniq([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end) |> Enum.to_list ==
-           [{1,:x}, {2,:y}]
+  test "uniq_by/2" do
+    assert Stream.uniq_by([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end) |> Enum.to_list() ==
+             [{1, :x}, {2, :y}]
+
+    assert Stream.uniq_by([a: {:tea, 2}, b: {:tea, 2}, c: {:coffee, 1}], fn {_, y} -> y end)
+           |> Enum.to_list() == [a: {:tea, 2}, c: {:coffee, 1}]
   end
 
   test "zip/2" do
     concat = Stream.concat(1..3, 4..6)
-    cycle  = Stream.cycle([:a, :b, :c])
-    assert Stream.zip(concat, cycle) |> Enum.to_list ==
-           [{1,:a},{2,:b},{3,:c},{4,:a},{5,:b},{6,:c}]
+    cycle = Stream.cycle([:a, :b, :c])
+
+    assert Stream.zip(concat, cycle) |> Enum.to_list() ==
+             [{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]
   end
 
-  test "zip/2 does not leave streams suspended" do
-    stream = Stream.resource(fn -> 1 end,
-                             fn acc -> {acc, acc + 1} end,
-                             fn _ -> Process.put(:stream_zip, true) end)
+  test "zip_with/3" do
+    concat = Stream.concat(1..3, 4..6)
+    cycle = Stream.cycle([:a, :b, :c])
+    zip_fun = &List.to_tuple([&1, &2])
+
+    assert Stream.zip_with(concat, cycle, zip_fun) |> Enum.to_list() ==
+             [{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]
+
+    stream = Stream.concat(1..3, 4..6)
+    other_stream = fn _, _ -> {:cont, [1, 2]} end
+    result = Stream.zip_with(stream, other_stream, fn a, b -> a + b end) |> Enum.to_list()
+    assert result == [2, 4]
+  end
+
+  test "zip_with/2" do
+    concat = Stream.concat(1..3, 4..6)
+    cycle = Stream.cycle([:a, :b, :c])
+    zip_fun = &List.to_tuple/1
+
+    assert Stream.zip_with([concat, cycle], zip_fun) |> Enum.to_list() ==
+             [{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]
+
+    assert Stream.chunk_every([0, 1, 2, 3], 2) |> Stream.zip_with(zip_fun) |> Enum.to_list() ==
+             [{0, 2}, {1, 3}]
+
+    stream = %HaltAcc{acc: 1..3}
+    assert Stream.zip_with([1..3, stream], zip_fun) |> Enum.to_list() == [{1, 1}, {2, 2}, {3, 3}]
+
+    range_cycle = Stream.cycle(1..2)
+
+    assert Stream.zip_with([1..3, range_cycle], zip_fun) |> Enum.to_list() == [
+             {1, 1},
+             {2, 2},
+             {3, 1}
+           ]
+  end
+
+  test "zip_with/2 does not leave streams suspended" do
+    zip_with_fun = &List.to_tuple/1
+
+    stream =
+      Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->
+        Process.put(:stream_zip_with, true)
+      end)
+
+    Process.put(:stream_zip_with, false)
+
+    assert Stream.zip_with([[:a, :b, :c], stream], zip_with_fun) |> Enum.to_list() == [
+             a: 1,
+             b: 2,
+             c: 3
+           ]
+
+    assert Process.get(:stream_zip_with)
+
+    Process.put(:stream_zip_with, false)
+
+    assert Stream.zip_with([stream, [:a, :b, :c]], zip_with_fun) |> Enum.to_list() == [
+             {1, :a},
+             {2, :b},
+             {3, :c}
+           ]
+
+    assert Process.get(:stream_zip_with)
+  end
+
+  test "zip_with/2 does not leave streams suspended on halt" do
+    zip_with_fun = &List.to_tuple/1
+
+    stream =
+      Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->
+        Process.put(:stream_zip_with, :done)
+      end)
+
+    assert Stream.zip_with([[:a, :b, :c, :d, :e], stream], zip_with_fun) |> Enum.take(3) == [
+             a: 1,
+             b: 2,
+             c: 3
+           ]
+
+    assert Process.get(:stream_zip_with) == :done
+  end
+
+  test "zip_with/2 closes on inner error" do
+    zip_with_fun = &List.to_tuple/1
+    stream = Stream.into([1, 2, 3], %Pdict{})
+
+    stream =
+      Stream.zip_with([stream, Stream.map([:a, :b, :c], fn _ -> throw(:error) end)], zip_with_fun)
+
+    Process.put(:stream_done, false)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_done)
+  end
+
+  test "zip_with/2 closes on outer error" do
+    zip_with_fun = &List.to_tuple/1
+
+    stream =
+      Stream.zip_with([Stream.into([1, 2, 3], %Pdict{}), [:a, :b, :c]], zip_with_fun)
+      |> Stream.map(fn _ -> throw(:error) end)
+
+    Process.put(:stream_done, false)
+    assert catch_throw(Enum.to_list(stream)) == :error
+    assert Process.get(:stream_done)
+  end
+
+  test "zip/1" do
+    concat = Stream.concat(1..3, 4..6)
+    cycle = Stream.cycle([:a, :b, :c])
+
+    assert Stream.zip([concat, cycle]) |> Enum.to_list() ==
+             [{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]
+
+    assert Stream.chunk_every([0, 1, 2, 3], 2) |> Stream.zip() |> Enum.to_list() ==
+             [{0, 2}, {1, 3}]
+
+    assert Stream.zip([]) |> Enum.to_list() == []
+
+    stream = %HaltAcc{acc: 1..3}
+    assert Stream.zip([1..3, stream]) |> Enum.to_list() == [{1, 1}, {2, 2}, {3, 3}]
+
+    range_cycle = Stream.cycle(1..2)
+    assert Stream.zip([1..3, range_cycle]) |> Enum.to_list() == [{1, 1}, {2, 2}, {3, 1}]
+  end
+
+  test "zip/1 does not leave streams suspended" do
+    stream =
+      Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->
+        Process.put(:stream_zip, true)
+      end)
 
     Process.put(:stream_zip, false)
-    assert Stream.zip([:a, :b, :c], stream) |> Enum.to_list == [a: 1, b: 2, c: 3]
+    assert Stream.zip([[:a, :b, :c], stream]) |> Enum.to_list() == [a: 1, b: 2, c: 3]
     assert Process.get(:stream_zip)
 
     Process.put(:stream_zip, false)
-    assert Stream.zip(stream, [:a, :b, :c]) |> Enum.to_list == [{1, :a}, {2, :b}, {3, :c}]
+    assert Stream.zip([stream, [:a, :b, :c]]) |> Enum.to_list() == [{1, :a}, {2, :b}, {3, :c}]
     assert Process.get(:stream_zip)
   end
 
-  test "zip/2 does not leave streams suspended on halt" do
-    stream = Stream.resource(fn -> 1 end,
-                             fn acc -> {acc, acc + 1} end,
-                             fn _ -> Process.put(:stream_zip, :done) end)
+  test "zip/1 does not leave streams suspended on halt" do
+    stream =
+      Stream.resource(fn -> 1 end, fn acc -> {[acc], acc + 1} end, fn _ ->
+        Process.put(:stream_zip, :done)
+      end)
 
-    assert Stream.zip([:a, :b, :c, :d, :e], stream) |> Enum.take(3) ==
-           [a: 1, b: 2, c: 3]
+    assert Stream.zip([[:a, :b, :c, :d, :e], stream]) |> Enum.take(3) == [a: 1, b: 2, c: 3]
 
     assert Process.get(:stream_zip) == :done
   end
 
-  test "zip/2 closes on inner error" do
-    stream = Stream.into([1, 2, 3], collectable_pdict)
-    stream = Stream.zip(stream, Stream.map([:a, :b, :c], fn _ -> throw(:error) end))
+  test "zip/1 closes on inner error" do
+    stream = Stream.into([1, 2, 3], %Pdict{})
+    stream = Stream.zip([stream, Stream.map([:a, :b, :c], fn _ -> throw(:error) end)])
 
     Process.put(:stream_done, false)
     assert catch_throw(Enum.to_list(stream)) == :error
     assert Process.get(:stream_done)
   end
 
-  test "zip/2 closes on outer error" do
-    stream = Stream.into([1, 2, 3], collectable_pdict)
-             |> Stream.zip([:a, :b, :c])
-             |> Stream.map(fn _ -> throw(:error) end)
+  test "zip/1 closes on outer error" do
+    stream =
+      Stream.zip([Stream.into([1, 2, 3], %Pdict{}), [:a, :b, :c]])
+      |> Stream.map(fn _ -> throw(:error) end)
 
     Process.put(:stream_done, false)
     assert catch_throw(Enum.to_list(stream)) == :error
@@ -570,24 +1449,45 @@ defmodule StreamTest do
   end
 
   test "with_index/2" do
-    stream = Stream.with_index([1,2,3])
-    assert is_lazy(stream)
-    assert Enum.to_list(stream) == [{1,0},{2,1},{3,2}]
+    stream = Stream.with_index([1, 2, 3])
+    assert lazy?(stream)
+    assert Enum.to_list(stream) == [{1, 0}, {2, 1}, {3, 2}]
+
+    stream = Stream.with_index([1, 2, 3], 10)
+    assert Enum.to_list(stream) == [{1, 10}, {2, 11}, {3, 12}]
 
     nats = Stream.iterate(1, &(&1 + 1))
-    assert Stream.with_index(nats) |> Enum.take(3) == [{1,0},{2,1},{3,2}]
+    assert Stream.with_index(nats) |> Enum.take(3) == [{1, 0}, {2, 1}, {3, 2}]
   end
 
-  defp is_lazy(stream) do
-    match?(%Stream{}, stream) or is_function(stream, 2)
+  test "intersperse/2 is lazy" do
+    assert lazy?(Stream.intersperse([], 0))
   end
 
-  defp collectable_pdict do
-    fn
-      _, {:cont, x} -> Process.put(:stream_cont, [x|Process.get(:stream_cont)])
-      _, :done -> Process.put(:stream_done, true)
-      _, :halt -> Process.put(:stream_halt, true)
-    end
+  test "intersperse/2 on an empty list" do
+    assert Enum.to_list(Stream.intersperse([], 0)) == []
+  end
+
+  test "intersperse/2 on a single element list" do
+    assert Enum.to_list(Stream.intersperse([1], 0)) == [1]
+  end
+
+  test "intersperse/2 on a multiple elements list" do
+    assert Enum.to_list(Stream.intersperse(1..3, 0)) == [1, 0, 2, 0, 3]
+  end
+
+  test "intersperse/2 is zippable" do
+    stream = Stream.intersperse(1..10, 0)
+    list = Enum.to_list(stream)
+    assert Enum.zip(list, list) == Enum.zip(stream, stream)
+  end
+
+  test "inspect/1" do
+    "#Stream<[enum: 1..10, funs: " <> _ = Stream.map(1..10, & &1) |> inspect()
+  end
+
+  defp lazy?(stream) do
+    match?(%Stream{}, stream) or is_function(stream, 2)
   end
 
   defp inbox_stream({:suspend, acc}, f) do
@@ -600,8 +1500,8 @@ defmodule StreamTest do
 
   defp inbox_stream({:cont, acc}, f) do
     receive do
-      {:stream, item} ->
-        inbox_stream(f.(item, acc), f)
+      {:stream, element} ->
+        inbox_stream(f.(element, acc), f)
     end
   end
 end
diff --git a/lib/elixir/test/elixir/string/chars_test.exs b/lib/elixir/test/elixir/string/chars_test.exs
index 173439287bb..875820e86b8 100644
--- a/lib/elixir/test/elixir/string/chars_test.exs
+++ b/lib/elixir/test/elixir/string/chars_test.exs
@@ -1,28 +1,34 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule String.Chars.AtomTest do
   use ExUnit.Case, async: true
 
-  test :basic do
+  doctest String.Chars
+
+  test "basic" do
     assert to_string(:foo) == "foo"
   end
 
-  test :empty do
+  test "empty" do
     assert to_string(:"") == ""
   end
 
-  test :true_false_nil do
+  test "true false nil" do
     assert to_string(false) == "false"
     assert to_string(true) == "true"
     assert to_string(nil) == ""
   end
 
-  test :with_uppercase do
+  test "with uppercase" do
     assert to_string(:fOO) == "fOO"
     assert to_string(:FOO) == "FOO"
   end
 
-  test :alias_atom do
+  test "alias atom" do
     assert to_string(Foo.Bar) == "Elixir.Foo.Bar"
   end
 end
@@ -30,7 +36,7 @@ end
 defmodule String.Chars.BitStringTest do
   use ExUnit.Case, async: true
 
-  test :binary do
+  test "binary" do
     assert to_string("foo") == "foo"
     assert to_string(<<?a, ?b, ?c>>) == "abc"
     assert to_string("我今天要学习.") == "我今天要学习."
@@ -40,11 +46,11 @@ end
 defmodule String.Chars.NumberTest do
   use ExUnit.Case, async: true
 
-  test :integer do
+  test "integer" do
     assert to_string(100) == "100"
   end
 
-  test :float do
+  test "float" do
     assert to_string(1.0) == "1.0"
     assert to_string(1.0e10) == "1.0e10"
   end
@@ -53,66 +59,127 @@ end
 defmodule String.Chars.ListTest do
   use ExUnit.Case, async: true
 
-  test :basic do
-    assert to_string([ 1, "b", 3 ]) == <<1, 98, 3>>
+  test "basic" do
+    assert to_string([1, "b", 3]) == <<1, 98, 3>>
   end
 
-  test :printable do
-    assert to_string('abc') == "abc"
+  test "printable" do
+    assert to_string(~c"abc") == "abc"
   end
 
-  test :char_list do
-    assert to_string([0, 1, 2, 3, 255]) ==
-           <<0, 1, 2, 3, 195, 191>>
+  test "charlist" do
+    assert to_string([0, 1, 2, 3, 255]) == <<0, 1, 2, 3, 195, 191>>
 
     assert to_string([0, [1, "hello"], 2, [["bye"]]]) ==
-           <<0, 1, 104, 101, 108, 108, 111, 2, 98, 121, 101>>
+             <<0, 1, 104, 101, 108, 108, 111, 2, 98, 121, 101>>
   end
 
-  test :empty do
+  test "empty" do
     assert to_string([]) == ""
   end
 end
 
+defmodule String.Chars.Version.RequirementTest do
+  use ExUnit.Case, async: true
+
+  test "version requirement" do
+    {:ok, requirement} = Version.parse_requirement("== 2.0.1")
+    assert String.Chars.to_string(requirement) == "== 2.0.1"
+  end
+end
+
+defmodule String.Chars.URITest do
+  use ExUnit.Case, async: true
+
+  test "uri" do
+    uri = URI.parse("http://google.com")
+    assert String.Chars.to_string(uri) == "http://google.com"
+
+    uri_no_host = URI.parse("/foo/bar")
+    assert String.Chars.to_string(uri_no_host) == "/foo/bar"
+  end
+end
+
 defmodule String.Chars.ErrorsTest do
   use ExUnit.Case, async: true
 
-  test :bitstring do
-    assert_raise Protocol.UndefinedError,
-                 "protocol String.Chars not implemented for <<0, 1::size(4)>>, " <>
-                 "cannot convert a bitstring to a string", fn ->
-      to_string(<<1 :: [size(12), integer, signed]>>)
+  defmodule Foo do
+    defstruct foo: "bar"
+  end
+
+  test "bitstring" do
+    message =
+      """
+      protocol String.Chars not implemented for BitString, cannot convert a bitstring to a string
+
+      Got value:
+
+          <<0, 1::size(4)>>
+      """
+
+    assert_raise Protocol.UndefinedError, message, fn ->
+      to_string(<<1::size(12)-integer-signed>>)
     end
   end
 
-  test :tuple do
-    assert_raise Protocol.UndefinedError, "protocol String.Chars not implemented for {1, 2, 3}", fn ->
+  test "tuple" do
+    message = """
+    protocol String.Chars not implemented for Tuple
+
+    Got value:
+
+        {1, 2, 3}
+    """
+
+    assert_raise Protocol.UndefinedError, message, fn ->
       to_string({1, 2, 3})
     end
   end
 
-  test :pid do
-    assert_raise Protocol.UndefinedError, ~r"^protocol String\.Chars not implemented for #PID<.+?>$", fn ->
+  test "PID" do
+    message =
+      ~r"^protocol String\.Chars not implemented for PID\n\nGot value:\n\n    #PID<.+?>$"
+
+    assert_raise Protocol.UndefinedError, message, fn ->
       to_string(self())
     end
   end
 
-  test :ref do
-    assert_raise Protocol.UndefinedError, ~r"^protocol String\.Chars not implemented for #Reference<.+?>$", fn ->
+  test "ref" do
+    message =
+      ~r"^protocol String\.Chars not implemented for Reference\n\nGot value:\n\n    #Reference<.+?>$"
+
+    assert_raise Protocol.UndefinedError, message, fn ->
       to_string(make_ref()) == ""
     end
   end
 
-  test :function do
-    assert_raise Protocol.UndefinedError, ~r"^protocol String\.Chars not implemented for #Function<.+?>$", fn ->
-      to_string(fn -> end)
+  test "function" do
+    message =
+      ~r"^protocol String\.Chars not implemented for Function\n\nGot value:\n\n    #Function<.+?>$"
+
+    assert_raise Protocol.UndefinedError, message, fn ->
+      to_string(fn -> nil end)
     end
   end
 
-  test :port do
-    [port|_] = Port.list
-    assert_raise Protocol.UndefinedError, ~r"^protocol String\.Chars not implemented for #Port<.+?>$", fn ->
+  test "port" do
+    [port | _] = Port.list()
+
+    message =
+      ~r"^protocol String\.Chars not implemented for Port\n\nGot value:\n\n    #Port<.+?>$"
+
+    assert_raise Protocol.UndefinedError, message, fn ->
       to_string(port)
     end
   end
+
+  test "user-defined struct" do
+    message =
+      "protocol String\.Chars not implemented for String.Chars.ErrorsTest.Foo (a struct)\n\nGot value:\n\n    %String.Chars.ErrorsTest.Foo{foo: \"bar\"}\n"
+
+    assert_raise Protocol.UndefinedError, message, fn ->
+      to_string(%Foo{})
+    end
+  end
 end
diff --git a/lib/elixir/test/elixir/string_io_test.exs b/lib/elixir/test/elixir/string_io_test.exs
index da589631d29..46d889ecd39 100644
--- a/lib/elixir/test/elixir/string_io_test.exs
+++ b/lib/elixir/test/elixir/string_io_test.exs
@@ -1,233 +1,404 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule StringIOTest do
   use ExUnit.Case, async: true
 
-  test "start and stop" do
-    {:ok, pid} = StringIO.open("")
-    assert StringIO.close(pid) == {:ok, {"", ""}}
-  end
+  doctest StringIO
 
-  test "start_link and stop" do
+  test "open and close" do
     {:ok, pid} = StringIO.open("")
     assert StringIO.close(pid) == {:ok, {"", ""}}
   end
 
-  test "peek" do
+  test "contents" do
     {:ok, pid} = StringIO.open("abc")
     IO.write(pid, "edf")
     assert StringIO.contents(pid) == {"abc", "edf"}
   end
 
-  ## IO module
-
-  def start(string, opts \\ []) do
-    StringIO.open(string, opts) |> elem(1)
+  test "flush" do
+    {:ok, pid} = StringIO.open("")
+    IO.write(pid, "edf")
+    assert StringIO.flush(pid) == "edf"
+    assert StringIO.contents(pid) == {"", ""}
   end
 
-  def contents(pid) do
-    StringIO.contents(pid)
-  end
+  ## IO module
 
   test "IO.read :line with \\n" do
-    pid = start("abc\n")
+    {:ok, pid} = StringIO.open("abc\n")
     assert IO.read(pid, :line) == "abc\n"
     assert IO.read(pid, :line) == :eof
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
   end
 
   test "IO.read :line with \\rn" do
-    pid = start("abc\r\n")
+    {:ok, pid} = StringIO.open("abc\r\n")
     assert IO.read(pid, :line) == "abc\n"
     assert IO.read(pid, :line) == :eof
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
   end
 
   test "IO.read :line without line break" do
-    pid = start("abc")
+    {:ok, pid} = StringIO.open("abc")
     assert IO.read(pid, :line) == "abc"
     assert IO.read(pid, :line) == :eof
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
+  end
+
+  test "IO.read :line with UTF-8" do
+    {:ok, pid} = StringIO.open("⼊\n")
+    assert IO.read(pid, :line) == "⼊\n"
+    assert IO.read(pid, :line) == :eof
+    assert StringIO.contents(pid) == {"", ""}
   end
 
-  test "IO.read :line with invalid utf8" do
-    pid = start(<< 130, 227, 129, 132, 227, 129, 134 >>)
+  test "IO.read :line with invalid UTF-8" do
+    {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)
     assert IO.read(pid, :line) == {:error, :collect_line}
-    assert contents(pid) == {<< 130, 227, 129, 132, 227, 129, 134 >>, ""}
+    assert StringIO.contents(pid) == {<<130, 227, 129, 132, 227, 129, 134>>, ""}
   end
 
   test "IO.read count" do
-    pid = start("abc")
+    {:ok, pid} = StringIO.open("abc")
     assert IO.read(pid, 2) == "ab"
     assert IO.read(pid, 8) == "c"
     assert IO.read(pid, 1) == :eof
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
   end
 
-  test "IO.read count with utf8" do
-    pid = start("あいう")
+  test "IO.read count with UTF-8" do
+    {:ok, pid} = StringIO.open("あいう")
     assert IO.read(pid, 2) == "あい"
     assert IO.read(pid, 8) == "う"
     assert IO.read(pid, 1) == :eof
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
   end
 
-  test "IO.read count with invalid utf8" do
-    pid = start(<< 130, 227, 129, 132, 227, 129, 134 >>)
+  test "IO.read count with invalid UTF-8" do
+    {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)
     assert IO.read(pid, 2) == {:error, :invalid_unicode}
-    assert contents(pid) == {<< 130, 227, 129, 132, 227, 129, 134 >>, ""}
+    assert StringIO.contents(pid) == {<<130, 227, 129, 132, 227, 129, 134>>, ""}
   end
 
   test "IO.binread :line with \\n" do
-    pid = start("abc\n")
+    {:ok, pid} = StringIO.open("abc\n")
     assert IO.binread(pid, :line) == "abc\n"
     assert IO.binread(pid, :line) == :eof
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
   end
 
   test "IO.binread :line with \\r\\n" do
-    pid = start("abc\r\n")
+    {:ok, pid} = StringIO.open("abc\r\n")
     assert IO.binread(pid, :line) == "abc\n"
     assert IO.binread(pid, :line) == :eof
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
   end
 
   test "IO.binread :line without line break" do
-    pid = start("abc")
+    {:ok, pid} = StringIO.open("abc")
     assert IO.binread(pid, :line) == "abc"
     assert IO.binread(pid, :line) == :eof
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
+  end
+
+  test "IO.binread :line with raw bytes" do
+    {:ok, pid} = StringIO.open(<<181, 255, 194, ?\n>>)
+    assert IO.binread(pid, :line) == <<181, 255, 194, ?\n>>
+    assert IO.binread(pid, :line) == :eof
+    assert StringIO.contents(pid) == {"", ""}
   end
 
   test "IO.binread count" do
-    pid = start("abc")
+    {:ok, pid} = StringIO.open("abc")
     assert IO.binread(pid, 2) == "ab"
     assert IO.binread(pid, 8) == "c"
     assert IO.binread(pid, 1) == :eof
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
   end
 
-  test "IO.binread count with utf8" do
-    pid = start("あいう")
-    assert IO.binread(pid, 2) == << 227, 129 >>
-    assert IO.binread(pid, 8) == << 130, 227, 129, 132, 227, 129, 134 >>
+  test "IO.binread count with UTF-8" do
+    {:ok, pid} = StringIO.open("あいう")
+    assert IO.binread(pid, 2) == <<227, 129>>
+    assert IO.binread(pid, 8) == <<130, 227, 129, 132, 227, 129, 134>>
     assert IO.binread(pid, 1) == :eof
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
   end
 
   test "IO.write" do
-    pid = start("")
+    {:ok, pid} = StringIO.open("")
     assert IO.write(pid, "foo") == :ok
-    assert contents(pid) == {"", "foo"}
+    assert StringIO.contents(pid) == {"", "foo"}
   end
 
-  test "IO.write with utf8" do
-    pid = start("")
+  test "IO.write with UTF-8" do
+    {:ok, pid} = StringIO.open("")
     assert IO.write(pid, "あいう") == :ok
-    assert contents(pid) == {"", "あいう"}
+    assert StringIO.contents(pid) == {"", "あいう"}
+  end
+
+  test "IO.write with non-printable arguments" do
+    {:ok, pid} = StringIO.open("")
+
+    assert_raise ArgumentError, fn ->
+      IO.write(pid, [<<1::1>>])
+    end
+
+    assert_raise ErlangError, ~r/no_translation/, fn ->
+      IO.write(pid, <<222>>)
+    end
   end
 
   test "IO.binwrite" do
-    pid = start("")
+    {:ok, pid} = StringIO.open("")
     assert IO.binwrite(pid, "foo") == :ok
-    assert contents(pid) == {"", "foo"}
+    assert StringIO.contents(pid) == {"", "foo"}
   end
 
-  test "IO.binwrite with utf8" do
-    pid = start("")
+  test "IO.binwrite with UTF-8" do
+    {:ok, pid} = StringIO.open("")
     assert IO.binwrite(pid, "あいう") == :ok
-    assert contents(pid) == {"", "あいう"}
+
+    binary =
+      <<195, 163, 194, 129, 194, 130, 195, 163>> <>
+        <<194, 129, 194, 132, 195, 163, 194, 129, 194, 134>>
+
+    assert StringIO.contents(pid) == {"", binary}
+  end
+
+  test "IO.binwrite with bytes" do
+    {:ok, pid} = StringIO.open("")
+    assert IO.binwrite(pid, <<127, 128>>) == :ok
+    assert StringIO.contents(pid) == {"", <<127, 194, 128>>}
+  end
+
+  test "IO.binwrite with bytes and latin1 encoding" do
+    {:ok, pid} = StringIO.open("", encoding: :latin1)
+    assert IO.binwrite(pid, <<127, 128>>) == :ok
+    assert StringIO.contents(pid) == {"", <<127, 128>>}
   end
 
   test "IO.puts" do
-    pid = start("")
+    {:ok, pid} = StringIO.open("")
     assert IO.puts(pid, "abc") == :ok
-    assert contents(pid) == {"", "abc\n"}
+    assert StringIO.contents(pid) == {"", "abc\n"}
+  end
+
+  test "IO.puts with non-printable arguments" do
+    {:ok, pid} = StringIO.open("")
+
+    assert_raise ArgumentError, fn ->
+      IO.puts(pid, [<<1::1>>])
+    end
   end
 
   test "IO.inspect" do
-    pid = start("")
+    {:ok, pid} = StringIO.open("")
     assert IO.inspect(pid, {}, []) == {}
-    assert contents(pid) == {"", "{}\n"}
+    assert StringIO.contents(pid) == {"", "{}\n"}
   end
 
   test "IO.getn" do
-    pid = start("abc")
+    {:ok, pid} = StringIO.open("abc")
     assert IO.getn(pid, ">", 2) == "ab"
-    assert contents(pid) == {"c", ""}
+    assert StringIO.contents(pid) == {"c", ""}
   end
 
-  test "IO.getn with utf8" do
-    pid = start("あいう")
+  test "IO.getn with UTF-8" do
+    {:ok, pid} = StringIO.open("あいう")
     assert IO.getn(pid, ">", 2) == "あい"
-    assert contents(pid) == {"う", ""}
+    assert StringIO.contents(pid) == {"う", ""}
   end
 
-  test "IO.getn with invalid utf8" do
-    pid = start(<< 130, 227, 129, 132, 227, 129, 134 >>)
+  test "IO.getn with invalid UTF-8" do
+    {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)
     assert IO.getn(pid, ">", 2) == {:error, :invalid_unicode}
-    assert contents(pid) == {<< 130, 227, 129, 132, 227, 129, 134 >>, ""}
+    assert StringIO.contents(pid) == {<<130, 227, 129, 132, 227, 129, 134>>, ""}
   end
 
   test "IO.getn with capture_prompt" do
-    pid = start("abc", capture_prompt: true)
+    {:ok, pid} = StringIO.open("abc", capture_prompt: true)
     assert IO.getn(pid, ">", 2) == "ab"
-    assert contents(pid) == {"c", ">"}
+    assert StringIO.contents(pid) == {"c", ">"}
   end
 
   test "IO.gets with \\n" do
-    pid = start("abc\nd")
+    {:ok, pid} = StringIO.open("abc\nd")
     assert IO.gets(pid, ">") == "abc\n"
-    assert contents(pid) == {"d", ""}
+    assert StringIO.contents(pid) == {"d", ""}
   end
 
   test "IO.gets with \\r\\n" do
-    pid = start("abc\r\nd")
+    {:ok, pid} = StringIO.open("abc\r\nd")
     assert IO.gets(pid, ">") == "abc\n"
-    assert contents(pid) == {"d", ""}
+    assert StringIO.contents(pid) == {"d", ""}
   end
 
   test "IO.gets without line breaks" do
-    pid = start("abc")
+    {:ok, pid} = StringIO.open("abc")
     assert IO.gets(pid, ">") == "abc"
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
   end
 
-  test "IO.gets with invalid utf8" do
-    pid = start(<< 130, 227, 129, 132, 227, 129, 134 >>)
+  test "IO.gets with invalid UTF-8" do
+    {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)
     assert IO.gets(pid, ">") == {:error, :collect_line}
-    assert contents(pid) == {<< 130, 227, 129, 132, 227, 129, 134 >>, ""}
+    assert StringIO.contents(pid) == {<<130, 227, 129, 132, 227, 129, 134>>, ""}
   end
 
   test "IO.gets with capture_prompt" do
-    pid = start("abc\n", capture_prompt: true)
+    {:ok, pid} = StringIO.open("abc\n", capture_prompt: true)
     assert IO.gets(pid, ">") == "abc\n"
-    assert contents(pid) == {"", ">"}
+    assert StringIO.contents(pid) == {"", ">"}
   end
 
   test ":io.get_password" do
-    pid = start("abc\n")
+    {:ok, pid} = StringIO.open("abc\n")
     assert :io.get_password(pid) == "abc\n"
-    assert contents(pid) == {"", ""}
+    assert StringIO.contents(pid) == {"", ""}
   end
 
   test "IO.stream" do
-    pid = start("abc")
-    assert IO.stream(pid, 2) |> Enum.to_list == ["ab", "c"]
-    assert contents(pid) == {"", ""}
+    {:ok, pid} = StringIO.open("abc")
+    assert IO.stream(pid, 2) |> Enum.to_list() == ["ab", "c"]
+    assert StringIO.contents(pid) == {"", ""}
   end
 
-  test "IO.stream with invalid utf8" do
-    pid = start(<< 130, 227, 129, 132, 227, 129, 134 >>)
-    assert_raise IO.StreamError, fn->
-      IO.stream(pid, 2) |> Enum.to_list
+  test "IO.stream with invalid UTF-8" do
+    {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)
+
+    assert_raise IO.StreamError, "error during streaming: :invalid_unicode", fn ->
+      IO.stream(pid, 2) |> Enum.to_list()
     end
-    assert contents(pid) == {<< 130, 227, 129, 132, 227, 129, 134 >>, ""}
+
+    assert StringIO.contents(pid) == {<<130, 227, 129, 132, 227, 129, 134>>, ""}
   end
 
   test "IO.binstream" do
-    pid = start("abc")
-    assert IO.stream(pid, 2) |> Enum.to_list == ["ab", "c"]
-    assert contents(pid) == {"", ""}
+    {:ok, pid} = StringIO.open("abc")
+    assert IO.stream(pid, 2) |> Enum.to_list() == ["ab", "c"]
+    assert StringIO.contents(pid) == {"", ""}
+  end
+
+  defp get_until(pid, encoding, prompt, module, function) do
+    :io.request(pid, {:get_until, encoding, prompt, module, function, []})
+  end
+
+  defmodule GetUntilCallbacks do
+    def until_eof(continuation, :eof) do
+      {:done, continuation, :eof}
+    end
+
+    def until_eof(continuation, content) do
+      {:more, continuation ++ content}
+    end
+
+    def until_eof_then_try_more(~c"magic-stop-prefix" ++ continuation, :eof) do
+      {:done, continuation, :eof}
+    end
+
+    def until_eof_then_try_more(continuation, :eof) do
+      {:more, ~c"magic-stop-prefix" ++ continuation}
+    end
+
+    def until_eof_then_try_more(continuation, content) do
+      {:more, continuation ++ content}
+    end
+
+    def up_to_3_bytes(continuation, :eof) do
+      {:done, continuation, :eof}
+    end
+
+    def up_to_3_bytes(continuation, content) do
+      case continuation ++ content do
+        [a, b, c | tail] -> {:done, [a, b, c], tail}
+        str -> {:more, str}
+      end
+    end
+
+    def up_to_3_bytes_discard_rest(continuation, :eof) do
+      {:done, continuation, :eof}
+    end
+
+    def up_to_3_bytes_discard_rest(continuation, content) do
+      case continuation ++ content do
+        [a, b, c | _tail] -> {:done, [a, b, c], :eof}
+        str -> {:more, str}
+      end
+    end
+  end
+
+  test "get_until with up_to_3_bytes" do
+    {:ok, pid} = StringIO.open("abcdefg")
+    result = get_until(pid, :unicode, "", GetUntilCallbacks, :up_to_3_bytes)
+    assert result == "abc"
+    assert IO.read(pid, :eof) == "defg"
+  end
+
+  test "get_until with up_to_3_bytes_discard_rest" do
+    {:ok, pid} = StringIO.open("abcdefg")
+    result = get_until(pid, :unicode, "", GetUntilCallbacks, :up_to_3_bytes_discard_rest)
+    assert result == "abc"
+    assert IO.read(pid, :eof) == :eof
+  end
+
+  test "get_until with until_eof" do
+    {:ok, pid} = StringIO.open("abc\nd")
+    result = get_until(pid, :unicode, "", GetUntilCallbacks, :until_eof)
+    assert result == "abc\nd"
+  end
+
+  test "get_until with until_eof and \\r\\n" do
+    {:ok, pid} = StringIO.open("abc\r\nd")
+    result = get_until(pid, :unicode, "", GetUntilCallbacks, :until_eof)
+    assert result == "abc\r\nd"
+  end
+
+  test "get_until with until_eof capturing prompt" do
+    {:ok, pid} = StringIO.open("abc\nd", capture_prompt: true)
+    result = get_until(pid, :unicode, ">", GetUntilCallbacks, :until_eof)
+    assert result == "abc\nd"
+    assert StringIO.contents(pid) == {"", ">>>"}
+  end
+
+  test "get_until with until_eof_then_try_more" do
+    {:ok, pid} = StringIO.open("abc\nd")
+    result = get_until(pid, :unicode, "", GetUntilCallbacks, :until_eof_then_try_more)
+    assert result == "abc\nd"
+  end
+
+  test "get_until with invalid UTF-8" do
+    {:ok, pid} = StringIO.open(<<130, 227, 129, 132, 227, 129, 134>>)
+    result = get_until(pid, :unicode, "", GetUntilCallbacks, :until_eof)
+    assert result == :error
+  end
+
+  test "get_until with raw bytes (latin1)" do
+    {:ok, pid} = StringIO.open(<<181, 255, 194, ?\n>>)
+    result = get_until(pid, :latin1, "", GetUntilCallbacks, :until_eof)
+    assert result == <<181, 255, 194, ?\n>>
+  end
+
+  test ":io.erl_scan_form/2" do
+    {:ok, pid} = StringIO.open("1.")
+    result = :io.scan_erl_form(pid, ~c"p>")
+    assert result == {:ok, [{:integer, 1, 1}, {:dot, 1}], 1}
+    assert StringIO.contents(pid) == {"", ""}
+  end
+
+  test ":io.erl_scan_form/2 with capture_prompt" do
+    {:ok, pid} = StringIO.open("1.", capture_prompt: true)
+    result = :io.scan_erl_form(pid, ~c"p>")
+    assert result == {:ok, [{:integer, 1, 1}, {:dot, 1}], 1}
+    assert StringIO.contents(pid) == {"", "p>p>"}
+  end
+
+  test "returns enotsup for files" do
+    {:ok, pid} = StringIO.open("123")
+    assert :file.position(pid, :cur) == {:error, :enotsup}
   end
 end
diff --git a/lib/elixir/test/elixir/string_test.exs b/lib/elixir/test/elixir/string_test.exs
index f6f38e7624d..278d753b3e8 100644
--- a/lib/elixir/test/elixir/string_test.exs
+++ b/lib/elixir/test/elixir/string_test.exs
@@ -1,22 +1,22 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule StringTest do
   use ExUnit.Case, async: true
 
-  test :integer_codepoints do
-    assert ?é == 233
-    assert ?\xE9 == 233
-    assert ?\351 == 233
-  end
+  doctest String
 
-  test :next_codepoint do
+  test "next_codepoint/1" do
     assert String.next_codepoint("ésoj") == {"é", "soj"}
     assert String.next_codepoint(<<255>>) == {<<255>>, ""}
     assert String.next_codepoint("") == nil
   end
 
-  # test cases described in http://mortoray.com/2013/11/27/the-string-type-is-broken/
-  test :unicode do
+  # test cases described in https://mortoray.com/2013/11/27/the-string-type-is-broken/
+  test "Unicode" do
     assert String.reverse("noël") == "lëon"
     assert String.slice("noël", 0..2) == "noë"
     assert String.length("noël") == 4
@@ -26,41 +26,75 @@ defmodule StringTest do
     assert String.reverse("") == ""
 
     assert String.upcase("baffle") == "BAFFLE"
+
+    assert String.equivalent?("noël", "noël")
   end
 
-  test :split do
-    assert String.split("") == [""]
+  test "split/1,2,3" do
+    assert String.split("") == []
     assert String.split("foo bar") == ["foo", "bar"]
     assert String.split(" foo bar") == ["foo", "bar"]
     assert String.split("foo bar ") == ["foo", "bar"]
     assert String.split(" foo bar ") == ["foo", "bar"]
     assert String.split("foo\t\n\v\f\r\sbar\n") == ["foo", "bar"]
-    assert String.split("foo" <> <<31>> <> "bar") == ["foo", "bar"]
     assert String.split("foo" <> <<194, 133>> <> "bar") == ["foo", "bar"]
+    # information separators are not considered whitespace
+    assert String.split("foo\u001Fbar") == ["foo\u001Fbar"]
+    # no-break space is excluded
+    assert String.split("foo\00A0bar") == ["foo\00A0bar"]
+    assert String.split("foo\u202Fbar") == ["foo\u202Fbar"]
 
-    assert String.split("", ",") == [""]
     assert String.split("a,b,c", ",") == ["a", "b", "c"]
     assert String.split("a,b", ".") == ["a,b"]
     assert String.split("1,2 3,4", [" ", ","]) == ["1", "2", "3", "4"]
+
+    assert String.split("", ",") == [""]
     assert String.split(" a b c ", " ") == ["", "a", "b", "c", ""]
+    assert String.split(" a b c ", " ", parts: :infinity) == ["", "a", "b", "c", ""]
+    assert String.split(" a b c ", " ", parts: 1) == [" a b c "]
+    assert String.split(" a b c ", " ", parts: 2) == ["", "a b c "]
 
+    assert String.split("", ",", trim: true) == []
     assert String.split(" a b c ", " ", trim: true) == ["a", "b", "c"]
-    assert String.split(" a b c ", " ", trim: true, parts: 0) == ["a", "b", "c"]
     assert String.split(" a b c ", " ", trim: true, parts: :infinity) == ["a", "b", "c"]
     assert String.split(" a b c ", " ", trim: true, parts: 1) == [" a b c "]
+    assert String.split(" a b c ", " ", trim: true, parts: 2) == ["a", "b c "]
 
-    assert String.split("abé", "") == ["a", "b", "é", ""]
-    assert String.split("abé", "", parts: 0) == ["a", "b", "é", ""]
+    assert String.split("abé", "") == ["", "a", "b", "é", ""]
+    assert String.split("abé", "", parts: :infinity) == ["", "a", "b", "é", ""]
     assert String.split("abé", "", parts: 1) == ["abé"]
-    assert String.split("abé", "", parts: 2) == ["a", "bé"]
-    assert String.split("abé", "", parts: 10) == ["a", "b", "é", ""]
+    assert String.split("abé", "", parts: 2) == ["", "abé"]
+    assert String.split("abé", "", parts: 3) == ["", "a", "bé"]
+    assert String.split("abé", "", parts: 4) == ["", "a", "b", "é"]
+    assert String.split("abé", "", parts: 5) == ["", "a", "b", "é", ""]
+    assert String.split("abé", "", parts: 10) == ["", "a", "b", "é", ""]
     assert String.split("abé", "", trim: true) == ["a", "b", "é"]
-    assert String.split("abé", "", trim: true, parts: 0) == ["a", "b", "é"]
+    assert String.split("abé", "", trim: true, parts: :infinity) == ["a", "b", "é"]
     assert String.split("abé", "", trim: true, parts: 2) == ["a", "bé"]
+    assert String.split("abé", "", trim: true, parts: 3) == ["a", "b", "é"]
+    assert String.split("abé", "", trim: true, parts: 4) == ["a", "b", "é"]
+
+    assert String.split("noël", "") == ["", "n", "o", "ë", "l", ""]
+    assert String.split("x-", "-", parts: 2, trim: true) == ["x"]
+    assert String.split("x-x-", "-", parts: 3, trim: true) == ["x", "x"]
+
+    assert String.split("hello", []) == ["hello"]
+    assert String.split("hello", [], trim: true) == ["hello"]
+    assert String.split("", []) == [""]
+    assert String.split("", [], trim: true) == []
+
+    assert_raise ArgumentError, fn ->
+      String.split("a,b,c", [""])
+    end
+
+    assert_raise ArgumentError, fn ->
+      String.split("a,b,c", [""])
+    end
   end
 
-  test :split_with_regex do
+  test "split/2,3 with regex" do
     assert String.split("", ~r{,}) == [""]
+    assert String.split("", ~r{,}, trim: true) == []
     assert String.split("a,b", ~r{,}) == ["a", "b"]
     assert String.split("a,b,c", ~r{,}) == ["a", "b", "c"]
     assert String.split("a,b,c", ~r{,}, parts: 2) == ["a", "b,c"]
@@ -69,7 +103,52 @@ defmodule StringTest do
     assert String.split("a,b", ~r{\.}) == ["a,b"]
   end
 
-  test :split_at do
+  test "split/2,3 with compiled pattern" do
+    pattern = :binary.compile_pattern("-")
+
+    assert String.split("x-", pattern) == ["x", ""]
+    assert String.split("x-", pattern, parts: 2, trim: true) == ["x"]
+    assert String.split("x-x-", pattern, parts: 3, trim: true) == ["x", "x"]
+  end
+
+  test "split/2,3 with malformed" do
+    assert String.split(<<225, 158, 128, 225, 158, 185, 225>>, "", parts: 1) ==
+             [<<225, 158, 128, 225, 158, 185, 225>>]
+
+    assert String.split(<<225, 158, 128, 225, 158, 185, 225>>, "", parts: 2) ==
+             ["", <<225, 158, 128, 225, 158, 185, 225>>]
+
+    assert String.split(<<225, 158, 128, 225, 158, 185, 225>>, "", parts: 3) ==
+             ["", "កឹ", <<225>>]
+
+    assert String.split(<<225, 158, 128, 225, 158, 185, 225>>, "", parts: 4) ==
+             ["", "កឹ", <<225>>, ""]
+  end
+
+  test "splitter/2,3" do
+    assert String.splitter("a,b,c", ",") |> Enum.to_list() == ["a", "b", "c"]
+    assert String.splitter("a,b", ".") |> Enum.to_list() == ["a,b"]
+    assert String.splitter("1,2 3,4", [" ", ","]) |> Enum.to_list() == ["1", "2", "3", "4"]
+    assert String.splitter("", ",") |> Enum.to_list() == [""]
+
+    assert String.splitter("", ",", trim: true) |> Enum.to_list() == []
+    assert String.splitter(" a b c ", " ", trim: true) |> Enum.to_list() == ["a", "b", "c"]
+    assert String.splitter(" a b c ", " ", trim: true) |> Enum.take(1) == ["a"]
+    assert String.splitter(" a b c ", " ", trim: true) |> Enum.take(2) == ["a", "b"]
+
+    assert String.splitter("hello", []) |> Enum.to_list() == ["hello"]
+    assert String.splitter("hello", [], trim: true) |> Enum.to_list() == ["hello"]
+    assert String.splitter("", []) |> Enum.to_list() == [""]
+    assert String.splitter("", [], trim: true) |> Enum.to_list() == []
+
+    assert String.splitter("1,2 3,4 5", "") |> Enum.take(4) == ["", "1", ",", "2"]
+
+    assert_raise ArgumentError, fn ->
+      String.splitter("a", [""])
+    end
+  end
+
+  test "split_at/2" do
     assert String.split_at("", 0) == {"", ""}
     assert String.split_at("", -1) == {"", ""}
     assert String.split_at("", 1) == {"", ""}
@@ -84,47 +163,108 @@ defmodule StringTest do
     assert String.split_at("abc", -3) == {"", "abc"}
     assert String.split_at("abc", -4) == {"", "abc"}
     assert String.split_at("abc", -1000) == {"", "abc"}
+
+    assert_raise FunctionClauseError, fn ->
+      String.split_at("abc", 0.1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      String.split_at("abc", -0.1)
+    end
+  end
+
+  test "split_at/2 with malformed" do
+    assert String.split_at(<<?a, 195, 10, ?a>>, 2) == {<<?a, 195>>, <<10, ?a>>}
+    assert String.split_at(<<107, 205, 135, 184>>, 1) == {<<107, 205, 135>>, <<184>>}
+
+    assert String.split_at(<<225, 158, 128, 225, 158, 185, 225>>, 0) ==
+             {"", <<225, 158, 128, 225, 158, 185, 225>>}
+
+    assert String.split_at(<<225, 158, 128, 225, 158, 185, 225>>, 1) ==
+             {"កឹ", <<225>>}
+
+    assert String.split_at(<<225, 158, 128, 225, 158, 185, 225>>, 2) ==
+             {<<225, 158, 128, 225, 158, 185, 225>>, ""}
   end
 
-  test :upcase do
-    assert String.upcase("123 abcd 456 efg hij ( %$#) kl mnop @ qrst = -_ uvwxyz") == "123 ABCD 456 EFG HIJ ( %$#) KL MNOP @ QRST = -_ UVWXYZ"
+  test "upcase/1" do
+    assert String.upcase("123 abcd 456 efg hij ( %$#) kl mnop @ qrst = -_ uvwxyz") ==
+             "123 ABCD 456 EFG HIJ ( %$#) KL MNOP @ QRST = -_ UVWXYZ"
+
     assert String.upcase("") == ""
     assert String.upcase("abcD") == "ABCD"
   end
 
-  test :upcase_utf8 do
+  test "upcase/1 with UTF-8" do
     assert String.upcase("& % # àáâ ãäå 1 2 ç æ") == "& % # ÀÁÂ ÃÄÅ 1 2 Ç Æ"
     assert String.upcase("àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ") == "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ"
   end
 
-  test :upcase_utf8_multibyte do
+  test "upcase/1 with UTF-8 multibyte" do
     assert String.upcase("straße") == "STRASSE"
     assert String.upcase("áüÈß") == "ÁÜÈSS"
   end
 
-  test :downcase do
-    assert String.downcase("123 ABcD 456 EfG HIJ ( %$#) KL MNOP @ QRST = -_ UVWXYZ") == "123 abcd 456 efg hij ( %$#) kl mnop @ qrst = -_ uvwxyz"
+  test "upcase/1 with ascii" do
+    assert String.upcase("olá", :ascii) == "OLá"
+  end
+
+  test "upcase/1 with turkic" do
+    assert String.upcase("ıi", :turkic) == "Iİ"
+    assert String.upcase("Iİ", :turkic) == "Iİ"
+  end
+
+  test "downcase/1" do
+    assert String.downcase("123 ABcD 456 EfG HIJ ( %$#) KL MNOP @ QRST = -_ UVWXYZ") ==
+             "123 abcd 456 efg hij ( %$#) kl mnop @ qrst = -_ uvwxyz"
+
     assert String.downcase("abcD") == "abcd"
     assert String.downcase("") == ""
   end
 
-  test :downcase_utf8 do
+  test "downcase/1 with UTF-8" do
     assert String.downcase("& % # ÀÁÂ ÃÄÅ 1 2 Ç Æ") == "& % # àáâ ãäå 1 2 ç æ"
     assert String.downcase("ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ") == "àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ"
     assert String.downcase("áüÈß") == "áüèß"
   end
 
-  test :capitalize do
+  test "downcase/1 with greek final sigma" do
+    assert String.downcase("Σ") == "σ"
+    assert String.downcase("ΣΣ") == "σσ"
+    assert String.downcase("Σ ΣΣ") == "σ σσ"
+    assert String.downcase("ΜΕΣ'ΑΠΟ") == "μεσ'απο"
+    assert String.downcase("ΑΣ'ΤΟΥΣ") == "ασ'τουσ"
+
+    assert String.downcase("Σ", :greek) == "σ"
+    assert String.downcase("Σ ΣΣ", :greek) == "σ σς"
+    assert String.downcase("Σ ΣΑΣ Σ", :greek) == "σ σας σ"
+    assert String.downcase("ΜΕΣ'ΑΠΟ", :greek) == "μεσ'απο"
+    assert String.downcase("ΑΣ'ΤΟΥΣ", :greek) == "ασ'τους"
+  end
+
+  test "downcase/1 with ascii" do
+    assert String.downcase("OLÁ", :ascii) == "olÁ"
+  end
+
+  test "downcase/1 with turkic" do
+    assert String.downcase("Iİ", :turkic) == "ıi"
+    assert String.downcase("İ", :turkic) == "i"
+
+    assert String.downcase("ıi", :turkic) == "ıi"
+    assert String.downcase("i", :turkic) == "i"
+
+    assert String.downcase("İ") == "i̇"
+  end
+
+  test "capitalize/1" do
     assert String.capitalize("") == ""
+    assert String.capitalize("1") == "1"
     assert String.capitalize("abc") == "Abc"
     assert String.capitalize("ABC") == "Abc"
     assert String.capitalize("c b a") == "C b a"
     assert String.capitalize("1ABC") == "1abc"
     assert String.capitalize("_aBc1") == "_abc1"
     assert String.capitalize(" aBc1") == " abc1"
-  end
-
-  test :capitalize_utf8 do
     assert String.capitalize("àáâ") == "Àáâ"
     assert String.capitalize("ÀÁÂ") == "Àáâ"
     assert String.capitalize("âáà") == "Âáà"
@@ -132,128 +272,408 @@ defmodule StringTest do
     assert String.capitalize("òóôõö") == "Òóôõö"
     assert String.capitalize("ÒÓÔÕÖ") == "Òóôõö"
     assert String.capitalize("fin") == "Fin"
+
+    assert String.capitalize("ABC", :ascii) == "Abc"
+    assert String.capitalize("àáâ", :ascii) == "àáâ"
+    assert String.capitalize("aáA", :ascii) == "Aáa"
+
+    assert String.capitalize("iii", :turkic) == "İii"
+    assert String.capitalize("ııı", :turkic) == "Iıı"
+    assert String.capitalize("İii", :turkic) == "İii"
+    assert String.capitalize("Iıı", :turkic) == "Iıı"
+
+    assert String.capitalize(<<138, ?B, ?C>>) == <<138, ?b, ?c>>
+
+    assert String.capitalize(<<225, 158, 128, 225, 158, 185, 225>>) ==
+             <<225, 158, 128, 225, 158, 185, 225>>
   end
 
-  test :rstrip do
-    assert String.rstrip("") == ""
-    assert String.rstrip("   abc  ") == "   abc"
-    assert String.rstrip("   abc a") == "   abc a"
-    assert String.rstrip("a  abc  a\n\n") == "a  abc  a"
-    assert String.rstrip("a  abc  a\t\n\v\f\r\s") == "a  abc  a"
-    assert String.rstrip("a  abc  a " <> <<31>>) == "a  abc  a"
-    assert String.rstrip("a  abc  a" <> <<194, 133>>) == "a  abc  a"
-    assert String.rstrip("   abc aa", ?a) == "   abc "
-    assert String.rstrip("   abc __", ?_) == "   abc "
-    assert String.rstrip("   cat 猫猫", ?猫) == "   cat "
-  end
-
-  test :lstrip do
-    assert String.lstrip("") == ""
-    assert String.lstrip("   abc  ") == "abc  "
-    assert String.lstrip("a  abc  a") == "a  abc  a"
-    assert String.lstrip("\n\na  abc  a") == "a  abc  a"
-    assert String.lstrip("\t\n\v\f\r\sa  abc  a") == "a  abc  a"
-    assert String.lstrip(<<31>> <> " a  abc  a") == "a  abc  a"
-    assert String.lstrip(<<194, 133>> <> "a  abc  a") == "a  abc  a"
-    assert String.lstrip("__  abc  _", ?_) == "  abc  _"
-    assert String.lstrip("猫猫 cat   ", ?猫) == " cat   "
-  end
-
-  test :strip do
-    assert String.strip("") == ""
-    assert String.strip("   abc  ") == "abc"
-    assert String.strip("a  abc  a\n\n") == "a  abc  a"
-    assert String.strip("a  abc  a\t\n\v\f\r\s") == "a  abc  a"
-    assert String.strip("___  abc  ___", ?_) == "  abc  "
-    assert String.strip("猫猫猫  cat  猫猫猫", ?猫) == "  cat  "
-  end
-
-  test :rjust do
-    assert String.rjust("", 5) == "     "
-    assert String.rjust("abc", 5) == "  abc"
-    assert String.rjust("  abc  ", 9) == "    abc  "
-    assert String.rjust("猫", 5) == "    猫"
-    assert String.rjust("abc", 5, ?-) == "--abc"
-    assert String.rjust("abc", 5, ?猫) == "猫猫abc"
-  end
-
-  test :ljust do
-    assert String.ljust("", 5) == "     "
-    assert String.ljust("abc", 5) == "abc  "
-    assert String.ljust("  abc  ", 9) == "  abc    "
-    assert String.ljust("猫", 5) == "猫    "
-    assert String.ljust("abc", 5, ?-) == "abc--"
-    assert String.ljust("abc", 5, ?猫) == "abc猫猫"
-  end
-
-  test :reverse do
+  test "replace_leading/3" do
+    assert String.replace_leading("aa abc   ", "a", "b") == "bb abc   "
+    assert String.replace_leading("__ abc   ", "_", "b") == "bb abc   "
+    assert String.replace_leading("aaaaaaaa ", "a", "b") == "bbbbbbbb "
+    assert String.replace_leading("aaaaaaaa ", "aaa", "b") == "bbaa "
+    assert String.replace_leading("aaaaaaaaa", "a", "b") == "bbbbbbbbb"
+    assert String.replace_leading("]]]]]]", "]", "[]") == "[][][][][][]"
+    assert String.replace_leading("]]]]]]]]", "]", "") == ""
+    assert String.replace_leading("]]]]]] ]", "]", "") == " ]"
+    assert String.replace_leading("猫猫 cat  ", "猫", "й") == "йй cat  "
+    assert String.replace_leading("test", "t", "T") == "Test"
+    assert String.replace_leading("t", "t", "T") == "T"
+    assert String.replace_leading("aaa", "b", "c") == "aaa"
+
+    message = ~r/cannot use an empty string/
+
+    assert_raise ArgumentError, message, fn ->
+      String.replace_leading("foo", "", "bar")
+    end
+
+    assert_raise ArgumentError, message, fn ->
+      String.replace_leading("", "", "bar")
+    end
+  end
+
+  test "replace_trailing/3" do
+    assert String.replace_trailing("   abc aa", "a", "b") == "   abc bb"
+    assert String.replace_trailing("   abc __", "_", "b") == "   abc bb"
+    assert String.replace_trailing(" aaaaaaaa", "a", "b") == " bbbbbbbb"
+    assert String.replace_trailing(" aaaaaaaa", "aaa", "b") == " aabb"
+    assert String.replace_trailing("aaaaaaaaa", "a", "b") == "bbbbbbbbb"
+    assert String.replace_trailing("]]]]]]", "]", "[]") == "[][][][][][]"
+    assert String.replace_trailing("]]]]]]]]", "]", "") == ""
+    assert String.replace_trailing("] ]]]]]]", "]", "") == "] "
+    assert String.replace_trailing("  cat 猫猫", "猫", "й") == "  cat йй"
+    assert String.replace_trailing("test", "t", "T") == "tesT"
+    assert String.replace_trailing("t", "t", "T") == "T"
+    assert String.replace_trailing("aaa", "b", "c") == "aaa"
+
+    message = ~r/cannot use an empty string/
+
+    assert_raise ArgumentError, message, fn ->
+      String.replace_trailing("foo", "", "bar")
+    end
+
+    assert_raise ArgumentError, message, fn ->
+      String.replace_trailing("", "", "bar")
+    end
+  end
+
+  test "trim/1,2" do
+    assert String.trim("") == ""
+    assert String.trim("  abc ") == "abc"
+    assert String.trim("a  abc  a\n\n") == "a  abc  a"
+    assert String.trim("a  abc  a\t\n\v\f\r\s") == "a  abc  a"
+
+    assert String.trim("___  abc  ___", "_") == "  abc  "
+    assert String.trim("猫猫猫cat猫猫猫", "猫猫") == "猫cat猫"
+    # no-break space
+    assert String.trim("\u00A0a  abc  a\u00A0") == "a  abc  a"
+    # whitespace defined as a range
+    assert String.trim("\u2008a  abc  a\u2005") == "a  abc  a"
+  end
+
+  test "trim_leading/1,2" do
+    assert String.trim_leading("") == ""
+    assert String.trim_leading("   abc  ") == "abc  "
+    assert String.trim_leading("a  abc  a") == "a  abc  a"
+    assert String.trim_leading("\n\na  abc  a") == "a  abc  a"
+    assert String.trim_leading("\t\n\v\f\r\sa  abc  a") == "a  abc  a"
+    assert String.trim_leading(<<194, 133, "a  abc  a">>) == "a  abc  a"
+    # information separators are not whitespace
+    assert String.trim_leading("\u001F a  abc  a") == "\u001F a  abc  a"
+    # no-break space
+    assert String.trim_leading("\u00A0 a  abc  a") == "a  abc  a"
+
+    assert String.trim_leading("aa aaa", "aaa") == "aa aaa"
+    assert String.trim_leading("aaa aaa", "aa") == "a aaa"
+    assert String.trim_leading("aa abc   ", "a") == " abc   "
+    assert String.trim_leading("__ abc   ", "_") == " abc   "
+    assert String.trim_leading("aaaaaaaaa ", "a") == " "
+    assert String.trim_leading("aaaaaaaaaa", "a") == ""
+    assert String.trim_leading("]]]]]] ]", "]") == " ]"
+    assert String.trim_leading("猫猫 cat   ", "猫") == " cat   "
+    assert String.trim_leading("test", "t") == "est"
+    assert String.trim_leading("t", "t") == ""
+    assert String.trim_leading("", "t") == ""
+  end
+
+  test "trim_trailing/1,2" do
+    assert String.trim_trailing("") == ""
+    assert String.trim_trailing("1\n") == "1"
+    assert String.trim_trailing("\r\n") == ""
+    assert String.trim_trailing("   abc  ") == "   abc"
+    assert String.trim_trailing("   abc a") == "   abc a"
+    assert String.trim_trailing("a  abc  a\n\n") == "a  abc  a"
+    assert String.trim_trailing("a  abc  a\t\n\v\f\r\s") == "a  abc  a"
+    assert String.trim_trailing(<<"a  abc  a", 194, 133>>) == "a  abc  a"
+    # information separators are not whitespace
+    assert String.trim_trailing("a  abc  a \u001F") == "a  abc  a \u001F"
+    # no-break space
+    assert String.trim_trailing("a  abc  a \u00A0") == "a  abc  a"
+
+    assert String.trim_trailing("aaa aa", "aaa") == "aaa aa"
+    assert String.trim_trailing("aaa aaa", "aa") == "aaa a"
+    assert String.trim_trailing("   abc aa", "a") == "   abc "
+    assert String.trim_trailing("   abc __", "_") == "   abc "
+    assert String.trim_trailing(" aaaaaaaaa", "a") == " "
+    assert String.trim_trailing("aaaaaaaaaa", "a") == ""
+    assert String.trim_trailing("] ]]]]]]", "]") == "] "
+    assert String.trim_trailing("   cat 猫猫", "猫") == "   cat "
+    assert String.trim_trailing("test", "t") == "tes"
+    assert String.trim_trailing("t", "t") == ""
+    assert String.trim_trailing("", "t") == ""
+  end
+
+  test "pad_leading/2,3" do
+    assert String.pad_leading("", 5) == "     "
+    assert String.pad_leading("abc", 5) == "  abc"
+    assert String.pad_leading("  abc  ", 9) == "    abc  "
+    assert String.pad_leading("猫", 5) == "    猫"
+    assert String.pad_leading("-", 0) == "-"
+    assert String.pad_leading("-", 1) == "-"
+
+    assert String.pad_leading("---", 5, "abc") == "ab---"
+    assert String.pad_leading("---", 9, "abc") == "abcabc---"
+
+    assert String.pad_leading("---", 5, ["abc"]) == "abcabc---"
+    assert String.pad_leading("--", 6, ["a", "bc"]) == "abcabc--"
+
+    assert_raise FunctionClauseError, fn ->
+      String.pad_leading("-", -1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      String.pad_leading("-", 1, [])
+    end
+
+    message = "expected a string padding element, got: 10"
+
+    assert_raise ArgumentError, message, fn ->
+      String.pad_leading("-", 3, ["-", 10])
+    end
+  end
+
+  test "pad_trailing/2,3" do
+    assert String.pad_trailing("", 5) == "     "
+    assert String.pad_trailing("abc", 5) == "abc  "
+    assert String.pad_trailing("  abc  ", 9) == "  abc    "
+    assert String.pad_trailing("猫", 5) == "猫    "
+    assert String.pad_trailing("-", 0) == "-"
+    assert String.pad_trailing("-", 1) == "-"
+
+    assert String.pad_trailing("---", 5, "abc") == "---ab"
+    assert String.pad_trailing("---", 9, "abc") == "---abcabc"
+
+    assert String.pad_trailing("---", 5, ["abc"]) == "---abcabc"
+    assert String.pad_trailing("--", 6, ["a", "bc"]) == "--abcabc"
+
+    assert_raise FunctionClauseError, fn ->
+      String.pad_trailing("-", -1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      String.pad_trailing("-", 1, [])
+    end
+
+    message = "expected a string padding element, got: 10"
+
+    assert_raise ArgumentError, message, fn ->
+      String.pad_trailing("-", 3, ["-", 10])
+    end
+  end
+
+  test "reverse/1" do
     assert String.reverse("") == ""
     assert String.reverse("abc") == "cba"
     assert String.reverse("Hello World") == "dlroW olleH"
     assert String.reverse("Hello ∂og") == "go∂ olleH"
     assert String.reverse("Ā̀stute") == "etutsĀ̀"
     assert String.reverse(String.reverse("Hello World")) == "Hello World"
+    assert String.reverse(String.reverse("Hello \r\n World")) == "Hello \r\n World"
   end
 
-  test :replace do
-    assert String.replace("a,b,c", ",", "-") == "a-b-c"
-    assert String.replace("a,b,c", [",", "b"], "-") == "a---c"
+  describe "replace/3" do
+    test "with empty string and string replacement" do
+      assert String.replace("elixir", "", "") == "elixir"
+      assert String.replace("ELIXIR", "", ".") == ".E.L.I.X.I.R."
+      assert String.replace("ELIXIR", "", ".", global: true) == ".E.L.I.X.I.R."
+      assert String.replace("ELIXIR", "", ".", global: false) == ".ELIXIR"
 
-    assert String.replace("a,b,c", ",", "-", global: false) == "a-b,c"
-    assert String.replace("a,b,c", [",", "b"], "-", global: false) == "a-b,c"
-    assert String.replace("ãéã", "é", "e", global: false) == "ãeã"
+      assert_raise ArgumentError, fn ->
+        String.replace("elixir", [""], "")
+      end
+    end
+
+    test "with empty string and string replacement with malformed" do
+      assert String.replace(<<225, 158, 128, 225, 158, 185, 225>>, "", ".") == ".កឹ.\xE1."
+    end
+
+    test "with empty pattern list" do
+      assert String.replace("elixir", [], "anything") == "elixir"
+    end
 
-    assert String.replace("a,b,c", ",", "[]", insert_replaced: 2) == "a[],b[],c"
-    assert String.replace("a,b,c", ",", "[]", insert_replaced: [1, 1]) == "a[,,]b[,,]c"
-    assert String.replace("a,b,c", "b", "[]", insert_replaced: 1, global: false) == "a,[b],c"
+    test "with match pattern and string replacement" do
+      assert String.replace("a,b,c", ",", "-") == "a-b-c"
+      assert String.replace("a,b,c", [",", "b"], "-") == "a---c"
 
-    assert String.replace("a,b,c", ~r/,(.)/, ",\\1\\1") == "a,bb,cc"
-    assert String.replace("a,b,c", ~r/,(.)/, ",\\1\\1", global: false) == "a,bb,c"
+      assert String.replace("a,b,c", ",", "-", global: false) == "a-b,c"
+      assert String.replace("a,b,c", [",", "b"], "-", global: false) == "a-b,c"
+      assert String.replace("ãéã", "é", "e", global: false) == "ãeã"
+    end
+
+    test "with regex and string replacement" do
+      assert String.replace("a,b,c", ~r/,(.)/, ",\\1\\1") == "a,bb,cc"
+      assert String.replace("a,b,c", ~r/,(.)/, ",\\1\\1", global: false) == "a,bb,c"
+    end
+
+    test "with empty string and function replacement" do
+      assert String.replace("elixir", "", fn "" -> "" end) == "elixir"
+      assert String.replace("ELIXIR", "", fn "" -> "." end) == ".E.L.I.X.I.R."
+      assert String.replace("ELIXIR", "", fn "" -> "." end, global: true) == ".E.L.I.X.I.R."
+      assert String.replace("ELIXIR", "", fn "" -> "." end, global: false) == ".ELIXIR"
+
+      assert String.replace("elixir", "", fn "" -> [""] end) == "elixir"
+      assert String.replace("ELIXIR", "", fn "" -> ["."] end) == ".E.L.I.X.I.R."
+      assert String.replace("ELIXIR", "", fn "" -> ["."] end, global: true) == ".E.L.I.X.I.R."
+      assert String.replace("ELIXIR", "", fn "" -> ["."] end, global: false) == ".ELIXIR"
+    end
+
+    test "with match pattern and function replacement" do
+      assert String.replace("a,b,c", ",", fn "," -> "-" end) == "a-b-c"
+      assert String.replace("a,b,c", [",", "b"], fn x -> "[#{x}]" end) == "a[,][b][,]c"
+      assert String.replace("a,b,c", [",", "b"], fn x -> [?[, x, ?]] end) == "a[,][b][,]c"
+
+      assert String.replace("a,b,c", ",", fn "," -> "-" end, global: false) == "a-b,c"
+      assert String.replace("a,b,c", [",", "b"], fn x -> "[#{x}]" end, global: false) == "a[,]b,c"
+      assert String.replace("ãéã", "é", fn "é" -> "e" end, global: false) == "ãeã"
+    end
+
+    test "with regex and function replacement" do
+      assert String.replace("a,b,c", ~r/,(.)/, fn x -> "#{x}#{x}" end) == "a,b,b,c,c"
+      assert String.replace("a,b,c", ~r/,(.)/, fn x -> [x, x] end) == "a,b,b,c,c"
+      assert String.replace("a,b,c", ~r/,(.)/, fn x -> "#{x}#{x}" end, global: false) == "a,b,b,c"
+      assert String.replace("a,b,c", ~r/,(.)/, fn x -> [x, x] end, global: false) == "a,b,b,c"
+    end
   end
 
-  test :duplicate do
+  describe "replace/4" do
+    test "with incorrect params" do
+      assert_raise FunctionClauseError, "no function clause matching in String.replace/4", fn ->
+        String.replace("a,b,c", "a,b,c", ",", "")
+      end
+    end
+  end
+
+  test "duplicate/2" do
     assert String.duplicate("abc", 0) == ""
     assert String.duplicate("abc", 1) == "abc"
     assert String.duplicate("abc", 2) == "abcabc"
     assert String.duplicate("&ã$", 2) == "&ã$&ã$"
+
+    assert_raise ArgumentError, fn ->
+      String.duplicate("abc", -1)
+    end
   end
 
-  test :codepoints do
+  test "codepoints/1" do
     assert String.codepoints("elixir") == ["e", "l", "i", "x", "i", "r"]
-    assert String.codepoints("elixír") == ["e", "l", "i", "x", "í", "r"] # slovak
-    assert String.codepoints("ոգելից ըմպելիք") == ["ո", "գ", "ե", "լ", "ի", "ց", " ", "ը", "մ", "պ", "ե", "լ", "ի", "ք"] # armenian
-    assert String.codepoints("эліксір") == ["э", "л", "і", "к", "с", "і", "р"] # belarussian
-    assert String.codepoints("ελιξήριο") == ["ε", "λ", "ι", "ξ", "ή", "ρ", "ι", "ο"] # greek
-    assert String.codepoints("סם חיים") == ["ס", "ם", " ", "ח", "י", "י", "ם"] # hebraic
-    assert String.codepoints("अमृत") == ["अ", "म", "ृ", "त"] # hindi
-    assert String.codepoints("স্পর্শমণি") == ["স", "্", "প", "র", "্", "শ", "ম", "ণ", "ি"] # bengali
-    assert String.codepoints("સર્વશ્રેષ્ઠ ઇલાજ") == ["સ", "ર", "્", "વ", "શ", "્", "ર", "ે", "ષ", "્", "ઠ", " ", "ઇ", "લ", "ા", "જ"] # gujarati
-    assert String.codepoints("世界中の一番") == ["世", "界", "中", "の", "一", "番"] # japanese
+    # slovak
+    assert String.codepoints("elixír") == ["e", "l", "i", "x", "í", "r"]
+    # armenian
+    assert String.codepoints("ոգելից ըմպելիք") ==
+             ["ո", "գ", "ե", "լ", "ի", "ց", " ", "ը", "մ", "պ", "ե", "լ", "ի", "ք"]
+
+    # belarussian
+    assert String.codepoints("эліксір") == ["э", "л", "і", "к", "с", "і", "р"]
+    # greek
+    assert String.codepoints("ελιξήριο") == ["ε", "λ", "ι", "ξ", "ή", "ρ", "ι", "ο"]
+    # hebraic
+    assert String.codepoints("סם חיים") == ["ס", "ם", " ", "ח", "י", "י", "ם"]
+    # hindi
+    assert String.codepoints("अमृत") == ["अ", "म", "ृ", "त"]
+    # bengali
+    assert String.codepoints("স্পর্শমণি") == ["স", "্", "প", "র", "্", "শ", "ম", "ণ", "ি"]
+    # gujarati
+    assert String.codepoints("સર્વશ્રેષ્ઠ ઇલાજ") ==
+             ["સ", "ર", "્", "વ", "શ", "્", "ર", "ે", "ષ", "્", "ઠ", " ", "ઇ", "લ", "ા", "જ"]
+
+    # japanese
+    assert String.codepoints("世界中の一番") == ["世", "界", "中", "の", "一", "番"]
     assert String.codepoints("がガちゃ") == ["が", "ガ", "ち", "ゃ"]
     assert String.codepoints("") == []
+
     assert String.codepoints("ϖͲϥЫݎߟΈټϘለДШव׆ש؇؊صلټܗݎޥޘ߉ऌ૫ሏᶆ℆ℙℱ ⅚Ⅷ↠∈⌘①ffi") ==
-           ["ϖ", "Ͳ", "ϥ", "Ы", "ݎ", "ߟ", "Έ", "ټ", "Ϙ", "ለ", "Д", "Ш", "व", "׆", "ש", "؇", "؊", "ص", "ل", "ټ", "ܗ", "ݎ", "ޥ", "ޘ", "߉", "ऌ", "૫", "ሏ", "ᶆ", "℆", "ℙ", "ℱ", " ", "⅚", "Ⅷ", "↠", "∈", "⌘", "①", "ffi"]
+             ["ϖ", "Ͳ", "ϥ", "Ы", "ݎ", "ߟ", "Έ"] ++
+               ["ټ", "Ϙ", "ለ", "Д", "Ш", "व"] ++
+               ["׆", "ש", "؇", "؊", "ص", "ل", "ټ"] ++
+               ["ܗ", "ݎ", "ޥ", "ޘ", "߉", "ऌ", "૫"] ++
+               ["ሏ", "ᶆ", "℆", "ℙ", "ℱ", " ", "⅚"] ++ ["Ⅷ", "↠", "∈", "⌘", "①", "ffi"]
+  end
+
+  test "equivalent?/2" do
+    assert String.equivalent?("", "")
+    assert String.equivalent?("elixir", "elixir")
+    assert String.equivalent?("뢴", "뢴")
+    assert String.equivalent?("ṩ", "ṩ")
+    refute String.equivalent?("ELIXIR", "elixir")
+    refute String.equivalent?("døge", "dóge")
   end
 
-  test :graphemes do
+  test "graphemes/1" do
     # Extended
     assert String.graphemes("Ā̀stute") == ["Ā̀", "s", "t", "u", "t", "e"]
     # CLRF
-    assert String.graphemes("\n\r\f") == ["\n\r", "\f"]
+    assert String.graphemes("\r\n\f") == ["\r\n", "\f"]
     # Regional indicator
-    assert String.graphemes("\x{1F1E6}\x{1F1E7}\x{1F1E8}") == ["\x{1F1E6}\x{1F1E7}\x{1F1E8}"]
+    assert String.graphemes("\u{1F1E6}\u{1F1E7}") == ["\u{1F1E6}\u{1F1E7}"]
+    assert String.graphemes("\u{1F1E6}\u{1F1E7}\u{1F1E8}") == ["\u{1F1E6}\u{1F1E7}", "\u{1F1E8}"]
     # Hangul
-    assert String.graphemes("\x{1100}\x{115D}\x{B4A4}") == ["ᄀᅝ뒤"]
+    assert String.graphemes("\u1100\u115D\uB4A4") == ["ᄀᅝ뒤"]
     # Special Marking with Extended
-    assert String.graphemes("a\x{0300}\x{0903}") == ["a\x{0300}\x{0903}"]
+    assert String.graphemes("a\u0300\u0903") == ["a\u0300\u0903"]
   end
 
-  test :next_grapheme do
+  test "next_grapheme/1" do
     assert String.next_grapheme("Ā̀stute") == {"Ā̀", "stute"}
+    assert String.next_grapheme(<<225, 158, 128, 225, 158, 185, 225>>) == {"កឹ", <<225>>}
     assert String.next_grapheme("") == nil
   end
 
-  test :first do
+  describe "randomized" do
+    test "next_grapheme" do
+      for _ <- 1..10 do
+        bin = :crypto.strong_rand_bytes(20)
+
+        try do
+          bin |> Stream.unfold(&String.next_grapheme/1) |> Enum.to_list()
+        rescue
+          # Ignore malformed pictographic sequences
+          _ -> :ok
+        else
+          list ->
+            assert Enum.all?(list, &is_binary/1), "cannot build graphemes for #{inspect(bin)}"
+        end
+      end
+    end
+
+    test "split empty" do
+      for _ <- 1..10 do
+        bin = :crypto.strong_rand_bytes(20)
+
+        try do
+          String.split(bin, "")
+        rescue
+          # Ignore malformed pictographic sequences
+          _ -> :ok
+        else
+          split ->
+            assert Enum.all?(split, &is_binary/1), "cannot split #{inspect(bin)}"
+            assert IO.iodata_to_binary(split) == bin
+        end
+      end
+    end
+
+    test "graphemes" do
+      for _ <- 1..10 do
+        bin = :crypto.strong_rand_bytes(20)
+
+        try do
+          String.graphemes(bin)
+        rescue
+          # Ignore malformed pictographic sequences
+          _ -> :ok
+        else
+          graphemes ->
+            assert Enum.all?(graphemes, &is_binary/1),
+                   "cannot build graphemes for #{inspect(bin)}"
+
+            assert IO.iodata_to_binary(graphemes) == bin
+        end
+      end
+    end
+  end
+
+  test "first/1" do
     assert String.first("elixir") == "e"
     assert String.first("íelixr") == "í"
     assert String.first("եոգլից ըմպելիք") == "ե"
@@ -265,7 +685,7 @@ defmodule StringTest do
     assert String.first("") == nil
   end
 
-  test :last do
+  test "last/1" do
     assert String.last("elixir") == "r"
     assert String.last("elixrí") == "í"
     assert String.last("եոգլից ըմպելիքե") == "ե"
@@ -277,7 +697,7 @@ defmodule StringTest do
     assert String.last("") == nil
   end
 
-  test :length do
+  test "length/1" do
     assert String.length("elixir") == 6
     assert String.length("elixrí") == 6
     assert String.length("եոգլից") == 6
@@ -286,10 +706,11 @@ defmodule StringTest do
     assert String.length("סם ייםח") == 7
     assert String.length("がガちゃ") == 4
     assert String.length("Ā̀stute") == 6
+    assert String.length("👨‍👩‍👧‍👦") == 1
     assert String.length("") == 0
   end
 
-  test :at do
+  test "at/2" do
     assert String.at("л", 0) == "л"
     assert String.at("elixir", 1) == "l"
     assert String.at("がガちゃ", 2) == "ち"
@@ -299,9 +720,17 @@ defmodule StringTest do
     assert String.at("л", -3) == nil
     assert String.at("Ā̀stute", 1) == "s"
     assert String.at("elixir", 6) == nil
+
+    assert_raise FunctionClauseError, fn ->
+      String.at("elixir", 0.1)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      String.at("elixir", -0.1)
+    end
   end
 
-  test :slice do
+  test "slice/3" do
     assert String.slice("elixir", 1, 3) == "lix"
     assert String.slice("あいうえお", 2, 2) == "うえ"
     assert String.slice("ειξήριολ", 2, 3) == "ξήρ"
@@ -311,9 +740,9 @@ defmodule StringTest do
     assert String.slice("elixir", -3, 2) == "xi"
     assert String.slice("あいうえお", -4, 3) == "いうえ"
     assert String.slice("ειξήριολ", -5, 3) == "ήρι"
-    assert String.slice("elixir", -10, 1) == ""
-    assert String.slice("あいうえお", -10, 2) == ""
-    assert String.slice("ειξήριολ", -10, 3) == ""
+    assert String.slice("elixir", -10, 1) == "e"
+    assert String.slice("あいうえお", -10, 2) == "あい"
+    assert String.slice("ειξήριολ", -10, 3) == "ειξ"
     assert String.slice("elixir", 8, 2) == ""
     assert String.slice("あいうえお", 6, 2) == ""
     assert String.slice("ειξήριολ", 8, 1) == ""
@@ -321,13 +750,17 @@ defmodule StringTest do
     assert String.slice("elixir", 0, 0) == ""
     assert String.slice("elixir", 5, 0) == ""
     assert String.slice("elixir", -5, 0) == ""
+    assert String.slice("elixir", -10, 10) == "elixir"
     assert String.slice("", 0, 1) == ""
     assert String.slice("", 1, 1) == ""
+  end
 
-    assert String.slice("elixir", 0..-2) == "elixi"
+  test "slice/2" do
+    assert String.slice("elixir", 0..-2//1) == "elixi"
     assert String.slice("elixir", 1..3) == "lix"
     assert String.slice("elixir", -5..-3) == "lix"
     assert String.slice("elixir", -5..3) == "lix"
+    assert String.slice("elixir", -10..10) == "elixir"
     assert String.slice("あいうえお", 2..3) == "うえ"
     assert String.slice("ειξήριολ", 2..4) == "ξήρ"
     assert String.slice("elixir", 3..6) == "xir"
@@ -342,141 +775,372 @@ defmodule StringTest do
     assert String.slice("ειξήριολ", 9..9) == ""
     assert String.slice("", 0..0) == ""
     assert String.slice("", 1..1) == ""
-    assert String.slice("あいうえお", -2..-4) == ""
-    assert String.slice("あいうえお", -10..-15) == ""
+    assert String.slice("あいうえお", -2..-4//1) == ""
+    assert String.slice("あいうえお", -10..-15//1) == ""
+    assert String.slice("hello あいうえお Unicode", 8..-1//1) == "うえお Unicode"
+    assert String.slice("abc", -1..14) == "c"
+    assert String.slice("a·̀ͯ‿.⁀:", 0..-2//1) == "a·̀ͯ‿.⁀"
+
+    assert_raise FunctionClauseError, fn ->
+      String.slice(nil, 0..1)
+    end
+
+    assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+             assert String.slice("elixir", 0..-2//-1) == "elixi"
+           end) =~ "negative steps are not supported in String.slice/2, pass 0..-2//1 instead"
+  end
+
+  test "slice/2 with steps" do
+    assert String.slice("elixir", 0..-2//2) == "eii"
+    assert String.slice("elixir", 1..3//2) == "lx"
+    assert String.slice("elixir", -5..-3//2) == "lx"
+    assert String.slice("elixir", -5..3//2) == "lx"
+    assert String.slice("あいうえお", 2..3//2) == "う"
+    assert String.slice("ειξήριολ", 2..4//2) == "ξρ"
+    assert String.slice("elixir", 3..6//2) == "xr"
+    assert String.slice("あいうえお", 3..7//2) == "え"
+    assert String.slice("ειξήριολ", 5..8//2) == "ιλ"
+    assert String.slice("elixir", -3..-2//2) == "x"
+    assert String.slice("あいうえお", -4..-2//2) == "いえ"
+    assert String.slice("ειξήριολ", -5..-3//2) == "ήι"
+    assert String.slice("elixir", 8..9//2) == ""
+    assert String.slice("", 0..0//2) == ""
+    assert String.slice("", 1..1//2) == ""
+    assert String.slice("あいうえお", -2..-4//2) == ""
+    assert String.slice("あいうえお", -10..-15//2) == ""
+    assert String.slice("hello あいうえお Unicode", 8..-1//2) == "うおUioe"
+    assert String.slice("abc", -1..14//2) == "c"
+    assert String.slice("a·̀ͯ‿.⁀:", 0..-2//2) == "a‿⁀"
+  end
+
+  test "byte_slice/2" do
+    # ASCII
+    assert String.byte_slice("elixir", 0, 6) == "elixir"
+    assert String.byte_slice("elixir", 0, 5) == "elixi"
+    assert String.byte_slice("elixir", 1, 4) == "lixi"
+    assert String.byte_slice("elixir", 0, 10) == "elixir"
+    assert String.byte_slice("elixir", -3, 10) == "xir"
+    assert String.byte_slice("elixir", -10, 10) == "elixir"
+    assert String.byte_slice("elixir", 1, 0) == ""
+    assert String.byte_slice("elixir", 10, 10) == ""
+
+    # 2 byte
+    assert String.byte_slice("héllò", 1, 4) == "éll"
+    assert String.byte_slice("héllò", 1, 5) == "éll"
+    assert String.byte_slice("héllò", 1, 6) == "éllò"
+    assert String.byte_slice("héllò", 2, 4) == "llò"
+
+    # 3 byte
+    assert String.byte_slice("hかllか", 1, 4) == "かl"
+    assert String.byte_slice("hかllか", 1, 5) == "かll"
+    assert String.byte_slice("hかllか", 1, 6) == "かll"
+    assert String.byte_slice("hかllか", 1, 7) == "かll"
+    assert String.byte_slice("hかllか", 1, 8) == "かllか"
+    assert String.byte_slice("hかllか", 2, 4) == "ll"
+    assert String.byte_slice("hかllか", 2, 5) == "llか"
+
+    # 4 byte
+    assert String.byte_slice("h😍ll😍", 1, 4) == "😍"
+    assert String.byte_slice("h😍ll😍", 1, 5) == "😍l"
+    assert String.byte_slice("h😍ll😍", 1, 6) == "😍ll"
+    assert String.byte_slice("h😍ll😍", 1, 7) == "😍ll"
+    assert String.byte_slice("h😍ll😍", 1, 8) == "😍ll"
+    assert String.byte_slice("h😍ll😍", 1, 9) == "😍ll"
+    assert String.byte_slice("h😍ll😍", 1, 10) == "😍ll😍"
+    assert String.byte_slice("h😍ll😍", 2, 5) == "ll"
+    assert String.byte_slice("h😍ll😍", 2, 6) == "ll😍"
+
+    # Already truncated
+    assert String.byte_slice(<<178, "ll", 178>>, 0, 10) == "ll"
+
+    # Already invalid
+    assert String.byte_slice(<<255, "ll", 255>>, 0, 10) == <<255, "ll", 255>>
   end
 
-  test :valid? do
+  test "valid?/1" do
     assert String.valid?("afds")
     assert String.valid?("øsdfh")
     assert String.valid?("dskfjあska")
+    assert String.valid?(<<0xEF, 0xB7, 0x90>>)
 
-    refute String.valid?(<<0xffff :: 16>>)
-    refute String.valid?("asd" <> <<0xffff :: 16>>)
-  end
+    refute String.valid?(<<0xFFFF::16>>)
+    refute String.valid?("asd" <> <<0xFFFF::16>>)
 
-  test :valid_character? do
-    assert String.valid_character?("a")
-    assert String.valid_character?("ø")
-    assert String.valid_character?("あ")
+    assert String.valid?("afdsafdsafds", :fast_ascii)
+    assert String.valid?("øsdfhøsdfh", :fast_ascii)
+    assert String.valid?("dskfjあskadskfjあska", :fast_ascii)
+    assert String.valid?(<<0xEF, 0xB7, 0x90, 0xEF, 0xB7, 0x90, 0xEF, 0xB7, 0x90>>, :fast_ascii)
 
-    refute String.valid_character?("\x{ffff}")
-    refute String.valid_character?("ab")
+    refute String.valid?(<<0xFFFF::16>>, :fast_ascii)
+    refute String.valid?("asdasdasd" <> <<0xFFFF::16>>, :fast_ascii)
   end
 
-  test :chunk_valid do
-    assert String.chunk("", :valid) == []
+  test "replace_invalid" do
+    assert String.replace_invalid("") === ""
+    assert String.replace_invalid(<<0xFF>>) === "�"
+    assert String.replace_invalid(<<0xFF, 0xFF, 0xFF>>) === "���"
 
-    assert String.chunk("ødskfjあ\011ska", :valid)
-           == ["ødskfjあ\011ska"]
-    assert String.chunk("abc\x{0ffff}def", :valid)
-           == ["abc", <<0x0ffff::utf8>>, "def"]
-    assert String.chunk("\x{0fffe}\x{3ffff}привет\x{0ffff}мир", :valid)
-           == [<<0x0fffe::utf8, 0x3ffff::utf8>>, "привет", <<0x0ffff::utf8>>, "мир"]
-    assert String.chunk("日本\x{0ffff}\x{fdef}ござございます\x{fdd0}", :valid)
-           == ["日本", <<0x0ffff::utf8, 0xfdef::utf8>>, "ござございます", <<0xfdd0::utf8>>]
-  end
+    # Valid ASCII
+    assert String.replace_invalid("hello") === "hello"
 
-  test :chunk_printable do
-    assert String.chunk("", :printable) == []
+    # Valid UTF-8
+    assert String.replace_invalid("こんにちは") === "こんにちは"
+
+    # 2/3 byte truncated "ề"
+    assert String.replace_invalid(<<225, 187>>) === "�"
+    assert String.replace_invalid("nem rán b" <> <<225, 187>> <> " bề") === "nem rán b� bề"
+
+    # 2/4 byte truncated "😔"
+    assert String.replace_invalid(<<240, 159>>) === "�"
+    assert String.replace_invalid("It's so over " <> <<240, 159>>) === "It's so over �"
+
+    # 3/4 byte truncated "😃"
+    assert String.replace_invalid(<<240, 159, 152>>) === "�"
+    assert String.replace_invalid("We're so back " <> <<240, 159, 152>>) === "We're so back �"
 
-    assert String.chunk("ødskfjあska", :printable)
-           == ["ødskfjあska"]
-    assert String.chunk("abc\x{0ffff}def", :printable)
-           == ["abc", <<0x0ffff::utf8>>, "def"]
-    assert String.chunk("\006ab\005cdef\003\000", :printable)
-           == [<<06>>, "ab", <<05>>, "cdef", <<03, 0>>]
+    # 3 byte overlong "e"
+    assert String.replace_invalid(<<0b11100000, 0b10000001, 0b10100101>>) === "���"
   end
 
-  test :starts_with? do
-    ## Normal cases ##
-    assert String.starts_with? "hello", "he"
-    assert String.starts_with? "hello", "hello"
-    assert String.starts_with? "hello", ["hellö", "hell"]
-    assert String.starts_with? "エリクシア", "エリ"
-    refute String.starts_with? "hello", "lo"
-    refute String.starts_with? "hello", "hellö"
-    refute String.starts_with? "hello", ["hellö", "goodbye"]
-    refute String.starts_with? "エリクシア", "仙丹"
+  test "chunk/2 with :valid trait" do
+    assert String.chunk("", :valid) == []
 
-    ## Edge cases ##
-    assert String.starts_with? "", ""
-    assert String.starts_with? "", ["", "a"]
-    assert String.starts_with? "b", ["", "a"]
+    assert String.chunk("ødskfjあ\x11ska", :valid) == ["ødskfjあ\x11ska"]
+  end
 
-    assert String.starts_with? "abc", ""
-    assert String.starts_with? "abc", [""]
+  test "chunk/2 with :printable trait" do
+    assert String.chunk("", :printable) == []
 
-    refute String.starts_with? "", "abc"
-    refute String.starts_with? "", [" "]
+    assert String.chunk("ødskfjあska", :printable) == ["ødskfjあska"]
+    assert String.chunk("abc\u{0FFFF}def", :printable) == ["abc", <<0x0FFFF::utf8>>, "def"]
 
-    ## Sanity checks ##
-    assert String.starts_with? "", ["", ""]
-    assert String.starts_with? "abc", ["", ""]
+    assert String.chunk("\x06ab\x05cdef\x03\0", :printable) ==
+             [<<6>>, "ab", <<5>>, "cdef", <<3, 0>>]
   end
 
-  test :ends_with? do
-    ## Normal cases ##
-    assert String.ends_with? "hello", "lo"
-    assert String.ends_with? "hello", "hello"
-    assert String.ends_with? "hello", ["hell", "lo", "xx"]
-    assert String.ends_with? "hello", ["hellö", "lo"]
-    assert String.ends_with? "エリクシア", "シア"
-    refute String.ends_with? "hello", "he"
-    refute String.ends_with? "hello", "hellö"
-    refute String.ends_with? "hello", ["hel", "goodbye"]
-    refute String.ends_with? "エリクシア", "仙丹"
+  test "starts_with?/2" do
+    assert String.starts_with?("hello", "he")
+    assert String.starts_with?("hello", "hello")
+    refute String.starts_with?("hello", [])
+    assert String.starts_with?("hello", "")
+    assert String.starts_with?("hello", [""])
+    assert String.starts_with?("hello", ["hellö", "hell"])
+    assert String.starts_with?("エリクシア", "エリ")
+    refute String.starts_with?("hello", "lo")
+    refute String.starts_with?("hello", "hellö")
+    refute String.starts_with?("hello", ["hellö", "goodbye"])
+    refute String.starts_with?("エリクシア", "仙丹")
+  end
 
-    ## Edge cases ##
-    assert String.ends_with? "", ""
-    assert String.ends_with? "", ["", "a"]
-    refute String.ends_with? "", ["a", "b"]
+  test "ends_with?/2" do
+    assert String.ends_with?("hello", "lo")
+    assert String.ends_with?("hello", "hello")
+    refute String.ends_with?("hello", [])
+    assert String.ends_with?("hello", ["hell", "lo", "xx"])
+    assert String.ends_with?("hello", ["hellö", "lo"])
+    assert String.ends_with?("エリクシア", "シア")
+    refute String.ends_with?("hello", "he")
+    refute String.ends_with?("hello", "hellö")
+    refute String.ends_with?("hello", ["hel", "goodbye"])
+    refute String.ends_with?("エリクシア", "仙丹")
+  end
 
-    assert String.ends_with? "abc", ""
-    assert String.ends_with? "abc", ["", "x"]
+  test "contains?/2" do
+    assert String.contains?("elixir of life", "of")
+    assert String.contains?("エリクシア", "シ")
+    refute String.contains?("elixir of life", [])
+    assert String.contains?("elixir of life", "")
+    assert String.contains?("elixir of life", [""])
+    assert String.contains?("elixir of life", ["mercury", "life"])
+    refute String.contains?("elixir of life", "death")
+    refute String.contains?("エリクシア", "仙")
+    refute String.contains?("elixir of life", ["death", "mercury", "eternal life"])
+  end
+
+  test "to_charlist/1" do
+    assert String.to_charlist("æß") == [?æ, ?ß]
+    assert String.to_charlist("abc") == [?a, ?b, ?c]
 
-    refute String.ends_with? "", "abc"
-    refute String.ends_with? "", [" "]
+    assert_raise UnicodeConversionError, "invalid encoding starting at <<223, 255>>", fn ->
+      String.to_charlist(<<0xDF, 0xFF>>)
+    end
 
-    ## Sanity checks ##
-    assert String.ends_with? "", ["", ""]
-    assert String.ends_with? "abc", ["", ""]
+    assert_raise UnicodeConversionError, "incomplete encoding starting at <<195>>", fn ->
+      String.to_charlist(<<106, 111, 115, 195>>)
+    end
   end
 
-  test :contains? do
-    ## Normal cases ##
-    assert String.contains? "elixir of life", "of"
-    assert String.contains? "エリクシア", "シ"
-    assert String.contains? "elixir of life", ["mercury", "life"]
-    refute String.contains? "elixir of life", "death"
-    refute String.contains? "エリクシア", "仙"
-    refute String.contains? "elixir of life", ["death", "mercury", "eternal life"]
+  test "to_float/1" do
+    assert String.to_float("3.0") == 3.0
 
-    ## Edge cases ##
-    assert String.contains? "", ""
-    assert String.contains? "abc", ""
-    assert String.contains? "abc", ["", "x"]
+    three = fn -> "3" end
+    assert_raise ArgumentError, fn -> String.to_float(three.()) end
 
-    refute String.contains? "", " "
-    refute String.contains? "", "a"
+    dot_three = fn -> ".3" end
+    assert_raise ArgumentError, fn -> String.to_float(dot_three.()) end
+  end
 
-    ## Sanity checks ##
-    assert String.contains? "", ["", ""]
-    assert String.contains? "abc", ["", ""]
+  test "jaro_distance/2" do
+    assert String.jaro_distance("same", "same") == 1.0
+    assert String.jaro_distance("any", "") == 0.0
+    assert String.jaro_distance("", "any") == 0.0
+    assert String.jaro_distance("martha", "marhta") == 0.9444444444444445
+    assert String.jaro_distance("martha", "marhha") == 0.888888888888889
+    assert String.jaro_distance("marhha", "martha") == 0.888888888888889
+    assert String.jaro_distance("dwayne", "duane") == 0.8222222222222223
+    assert String.jaro_distance("dixon", "dicksonx") == 0.7666666666666666
+    assert String.jaro_distance("xdicksonx", "dixon") == 0.7518518518518519
+    assert String.jaro_distance("shackleford", "shackelford") == 0.9696969696969697
+    assert String.jaro_distance("dunningham", "cunnigham") == 0.8962962962962964
+    assert String.jaro_distance("nichleson", "nichulson") == 0.9259259259259259
+    assert String.jaro_distance("jones", "johnson") == 0.7904761904761904
+    assert String.jaro_distance("massey", "massie") == 0.888888888888889
+    assert String.jaro_distance("abroms", "abrams") == 0.888888888888889
+    assert String.jaro_distance("hardin", "martinez") == 0.7222222222222222
+    assert String.jaro_distance("itman", "smith") == 0.4666666666666666
+    assert String.jaro_distance("jeraldine", "geraldine") == 0.9259259259259259
+    assert String.jaro_distance("michelle", "michael") == 0.8690476190476191
+    assert String.jaro_distance("julies", "julius") == 0.888888888888889
+    assert String.jaro_distance("tanya", "tonya") == 0.8666666666666667
+    assert String.jaro_distance("sean", "susan") == 0.7833333333333333
+    assert String.jaro_distance("jon", "john") == 0.9166666666666666
+    assert String.jaro_distance("jon", "jan") == 0.7777777777777777
+    assert String.jaro_distance("семена", "стремя") == 0.6666666666666666
+    assert String.jaro_distance("Sunday", "Saturday") == 0.7194444444444444
   end
 
-  test :to_char_list do
-    assert String.to_char_list("æß")  == [?æ, ?ß]
-    assert String.to_char_list("abc") == [?a, ?b, ?c]
+  test "myers_difference/2" do
+    assert String.myers_difference("", "abc") == [ins: "abc"]
+    assert String.myers_difference("abc", "") == [del: "abc"]
+    assert String.myers_difference("", "") == []
+    assert String.myers_difference("abc", "abc") == [eq: "abc"]
+    assert String.myers_difference("abc", "aйbc") == [eq: "a", ins: "й", eq: "bc"]
+    assert String.myers_difference("aйbc", "abc") == [eq: "a", del: "й", eq: "bc"]
+  end
 
-    assert_raise UnicodeConversionError,
-                 "invalid encoding starting at <<223, 255>>", fn ->
-      String.to_char_list(<< 0xDF, 0xFF >>)
-    end
+  test "normalize/2" do
+    assert String.normalize("ŝ", :nfd) == "ŝ"
+    assert String.normalize("ḇravô", :nfd) == "ḇravô"
+    assert String.normalize("ṩierra", :nfd) == "ṩierra"
+    assert String.normalize("뢴", :nfd) == "뢴"
+    assert String.normalize("êchǭ", :nfc) == "êchǭ"
+    assert String.normalize("거̄", :nfc) == "거̄"
+    assert String.normalize("뢴", :nfc) == "뢴"
+
+    ## Error cases
+    assert String.normalize(<<15, 216>>, :nfc) == <<15, 216>>
+    assert String.normalize(<<15, 216>>, :nfd) == <<15, 216>>
+    assert String.normalize(<<216, 15>>, :nfc) == <<216, 15>>
+    assert String.normalize(<<216, 15>>, :nfd) == <<216, 15>>
+
+    assert String.normalize(<<15, 216>>, :nfkc) == <<15, 216>>
+    assert String.normalize(<<15, 216>>, :nfkd) == <<15, 216>>
+    assert String.normalize(<<216, 15>>, :nfkc) == <<216, 15>>
+    assert String.normalize(<<216, 15>>, :nfkd) == <<216, 15>>
+
+    ## Cases from NormalizationTest.txt
+
+    # 05B8 05B9 05B1 0591 05C3 05B0 05AC 059F
+    # 05B1 05B8 05B9 0591 05C3 05B0 05AC 059F
+    # HEBREW POINT QAMATS, HEBREW POINT HOLAM, HEBREW POINT HATAF SEGOL,
+    # HEBREW ACCENT ETNAHTA, HEBREW PUNCTUATION SOF PASUQ, HEBREW POINT SHEVA,
+    # HEBREW ACCENT ILUY, HEBREW ACCENT QARNEY PARA
+    assert String.normalize("ֱָֹ֑׃ְ֬֟", :nfc) == "ֱָֹ֑׃ְ֬֟"
+
+    # 095D (exclusion list)
+    # 0922 093C
+    # DEVANAGARI LETTER RHA
+    assert String.normalize("ढ़", :nfc) == "ढ़"
+
+    # 0061 0315 0300 05AE 0340 0062
+    # 00E0 05AE 0300 0315 0062
+    # LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT,
+    # HEBREW ACCENT ZINOR, COMBINING GRAVE TONE MARK, LATIN SMALL LETTER B
+    assert String.normalize("à֮̀̕b", :nfc) == "à֮̀̕b"
+
+    # 0344
+    # 0308 0301
+    # COMBINING GREEK DIALYTIKA TONOS
+    assert String.normalize("\u0344", :nfc) == "\u0308\u0301"
+
+    # 115B9 0334 115AF
+    # 115B9 0334 115AF
+    # SIDDHAM VOWEL SIGN AI, COMBINING TILDE OVERLAY, SIDDHAM VOWEL SIGN AA
+    assert String.normalize("𑖹̴𑖯", :nfc) == "𑖹̴𑖯"
+
+    # HEBREW ACCENT ETNAHTA, HEBREW PUNCTUATION SOF PASUQ, HEBREW POINT SHEVA,
+    # HEBREW ACCENT ILUY, HEBREW ACCENT QARNEY PARA
+    assert String.normalize("ֱָֹ֑׃ְ֬֟", :nfc) == "ֱָֹ֑׃ְ֬֟"
+
+    # 095D (exclusion list)
+    # HEBREW ACCENT ETNAHTA, HEBREW PUNCTUATION SOF PASUQ, HEBREW POINT SHEVA,
+    # HEBREW ACCENT ILUY, HEBREW ACCENT QARNEY PARA
+    assert String.normalize("ֱָֹ֑׃ְ֬֟", :nfc) == "ֱָֹ֑׃ְ֬֟"
+
+    # 095D (exclusion list)
+    # 0922 093C
+    # DEVANAGARI LETTER RHA
+    assert String.normalize("ढ़", :nfc) == "ढ़"
+
+    # 0061 0315 0300 05AE 0340 0062
+    # 00E0 05AE 0300 0315 0062
+    # LATIN SMALL LETTER A, COMBINING COMMA ABOVE RIGHT, COMBINING GRAVE ACCENT,
+    # HEBREW ACCENT ZINOR, COMBINING GRAVE TONE MARK, LATIN SMALL LETTER B
+    assert String.normalize("à֮̀̕b", :nfc) == "à֮̀̕b"
+
+    # 0344
+    # 0308 0301
+    # COMBINING GREEK DIALYTIKA TONOS
+    assert String.normalize("\u0344", :nfc) == "\u0308\u0301"
+
+    # 115B9 0334 115AF
+    # 115B9 0334 115AF
+    # SIDDHAM VOWEL SIGN AI, COMBINING TILDE OVERLAY, SIDDHAM VOWEL SIGN AA
+    assert String.normalize("𑖹̴𑖯", :nfc) == "𑖹̴𑖯"
+
+    # (ff; ff; ff; ff; ff; ) LATIN SMALL LIGATURE FF
+    # FB00;FB00;FB00;0066 0066;0066 0066;
+    assert String.normalize("ff", :nfkd) == "\u0066\u0066"
+
+    # (fl; fl; fl; fl; fl; ) LATIN SMALL LIGATURE FL
+    # FB02;FB02;FB02;0066 006C;0066 006C;
+    assert String.normalize("fl", :nfkd) == "\u0066\u006C"
+
+    # (ſt; ſt; ſt; st; st; ) LATIN SMALL LIGATURE LONG S T
+    # FB05;FB05;FB05;0073 0074;0073 0074;
+    assert String.normalize("ſt", :nfkd) == "\u0073\u0074"
+
+    # (st; st; st; st; st; ) LATIN SMALL LIGATURE ST
+    # FB06;FB06;FB06;0073 0074;0073 0074;
+    assert String.normalize("\u0073\u0074", :nfkc) == "\u0073\u0074"
+
+    # (ﬓ; ﬓ; ﬓ; մն; մն; ) ARMENIAN SMALL LIGATURE MEN NOW
+    # FB13;FB13;FB13;0574 0576;0574 0576;
+    assert String.normalize("\u0574\u0576", :nfkc) == "\u0574\u0576"
+  end
 
-    assert_raise UnicodeConversionError,
-                 "incomplete encoding starting at <<195>>", fn ->
-      String.to_char_list(<< 106, 111, 115, 195 >>)
-    end
+  # Carriage return can be a grapheme cluster if followed by
+  # newline so we test some corner cases here.
+  test "carriage return" do
+    assert String.at("\r\t\v", 0) == "\r"
+    assert String.at("\r\t\v", 1) == "\t"
+    assert String.at("\r\t\v", 2) == "\v"
+    assert String.at("\xFF\r\t\v", 1) == "\r"
+    assert String.at("\r\xFF\t\v", 2) == "\t"
+    assert String.at("\r\t\xFF\v", 3) == "\v"
+
+    assert String.last("\r\t\v") == "\v"
+    assert String.last("\r\xFF\t\xFF\v") == "\v"
+
+    assert String.next_grapheme("\r\t\v") == {"\r", "\t\v"}
+    assert String.next_grapheme("\t\v") == {"\t", "\v"}
+    assert String.next_grapheme("\v") == {"\v", ""}
+
+    assert String.length("\r\t\v") == 3
+    assert String.length("\r\xFF\t\v") == 4
+    assert String.length("\r\t\xFF\v") == 4
+
+    assert String.bag_distance("\r\t\xFF\v", "\xFF\r\n\xFF") == 0.25
+    assert String.split("\r\t\v", "") == ["", "\r", "\t", "\v", ""]
   end
 end
diff --git a/lib/elixir/test/elixir/supervisor/spec_test.exs b/lib/elixir/test/elixir/supervisor/spec_test.exs
deleted file mode 100644
index a15234bcef3..00000000000
--- a/lib/elixir/test/elixir/supervisor/spec_test.exs
+++ /dev/null
@@ -1,85 +0,0 @@
-Code.require_file "../test_helper.exs", __DIR__
-
-defmodule Supervisor.SpecTest do
-  use ExUnit.Case, async: true
-
-  import Supervisor.Spec
-
-  test "worker/3" do
-    assert worker(Foo, [1, 2, 3]) == {
-      Foo,
-      {Foo, :start_link, [1, 2, 3]},
-      :permanent,
-      5000,
-      :worker,
-      [Foo]
-   }
-
-    opts = [id: :sample, function: :start, modules: :dynamic,
-            restart: :temporary, shutdown: :brutal_kill]
-
-    assert worker(Foo, [1, 2, 3], opts) == {
-      :sample,
-      {Foo, :start, [1, 2, 3]},
-      :temporary,
-      :brutal_kill,
-      :worker,
-      :dynamic
-   }
-  end
-
-  test "worker/3 with GenEvent" do
-    assert worker(GenEvent, [[name: :hello]]) == {
-      GenEvent,
-      {GenEvent, :start_link, [[name: :hello]]},
-      :permanent,
-      5000,
-      :worker,
-      :dynamic
-   }
-  end
-
-  test "supervisor/3" do
-    assert supervisor(Foo, [1, 2, 3]) == {
-      Foo,
-      {Foo, :start_link, [1, 2, 3]},
-      :permanent,
-      :infinity,
-      :supervisor,
-      [Foo]
-   }
-
-    opts = [id: :sample, function: :start, modules: :dynamic,
-      restart: :temporary, shutdown: :brutal_kill]
-
-    assert supervisor(Foo, [1, 2, 3], opts) == {
-      :sample,
-      {Foo, :start, [1, 2, 3]},
-      :temporary,
-      :brutal_kill,
-      :supervisor,
-      :dynamic
-   }
-  end
-
-  test "supervise/2" do
-    assert supervise([], strategy: :one_for_one) == {
-      :ok, {{:one_for_one, 5, 5}, []}
-   }
-
-    children = [worker(GenEvent, [])]
-    options  = [strategy: :one_for_all, max_restarts: 1, max_seconds: 1]
-
-    assert supervise(children, options) == {
-      :ok, {{:one_for_all, 1, 1}, children}
-   }
-  end
-
-  test "supervise/2 with duplicated ids" do
-    children = [worker(GenEvent, []), worker(GenEvent, [])]
-
-    assert_raise ArgumentError, fn ->
-      supervise(children, strategy: :one_for_one)
-    end
-  end
-end
diff --git a/lib/elixir/test/elixir/supervisor_test.exs b/lib/elixir/test/elixir/supervisor_test.exs
index eed8887e107..96d452e4420 100644
--- a/lib/elixir/test/elixir/supervisor_test.exs
+++ b/lib/elixir/test/elixir/supervisor_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule SupervisorTest do
   use ExUnit.Case, async: true
@@ -6,43 +10,154 @@ defmodule SupervisorTest do
   defmodule Stack do
     use GenServer
 
-    def start_link(state, opts) do
+    def start_link({state, opts}) do
       GenServer.start_link(__MODULE__, state, opts)
     end
 
-    def handle_call(:pop, _from, [h|t]) do
+    def init(args) do
+      {:ok, args}
+    end
+
+    def handle_call(:pop, _from, [h | t]) do
       {:reply, h, t}
     end
 
     def handle_call(:stop, _from, stack) do
-      # There is a race condition in between genserver terminations.
+      # There is a race condition between genserver terminations.
       # So we will explicitly unregister it here.
       try do
-        self |> Process.info(:registered_name) |> elem(1) |> Process.unregister
+        self() |> Process.info(:registered_name) |> elem(1) |> Process.unregister()
       rescue
         _ -> :ok
       end
+
       {:stop, :normal, :ok, stack}
     end
 
-    def handle_cast({:push, h}, _from, t) do
-      {:noreply, [h|t]}
+    def handle_cast({:push, h}, t) do
+      {:noreply, [h | t]}
     end
   end
 
   defmodule Stack.Sup do
     use Supervisor
 
-    def init({arg, opts}) do
-      children = [worker(Stack, [arg, opts])]
-      supervise(children, strategy: :one_for_one)
+    def init(pair) do
+      Supervisor.init([{Stack, pair}], strategy: :one_for_one)
+    end
+  end
+
+  test "generates child_spec/1" do
+    assert Stack.Sup.child_spec([:hello]) == %{
+             id: Stack.Sup,
+             start: {Stack.Sup, :start_link, [[:hello]]},
+             type: :supervisor
+           }
+
+    defmodule CustomSup do
+      use Supervisor,
+        id: :id,
+        restart: :temporary,
+        start: {:foo, :bar, []}
+
+      def init(arg) do
+        arg
+      end
+    end
+
+    assert CustomSup.child_spec([:hello]) == %{
+             id: :id,
+             restart: :temporary,
+             start: {:foo, :bar, []},
+             type: :supervisor
+           }
+  end
+
+  test "child_spec/2" do
+    assert Supervisor.child_spec(Task, []) ==
+             %{id: Task, restart: :temporary, start: {Task, :start_link, [[]]}}
+
+    assert Supervisor.child_spec({Task, :foo}, []) ==
+             %{id: Task, restart: :temporary, start: {Task, :start_link, [:foo]}}
+
+    assert Supervisor.child_spec(%{id: Task}, []) == %{id: Task}
+
+    assert Supervisor.child_spec(
+             Task,
+             id: :foo,
+             start: {:foo, :bar, []},
+             restart: :permanent,
+             shutdown: :infinity
+           ) == %{id: :foo, start: {:foo, :bar, []}, restart: :permanent, shutdown: :infinity}
+
+    message = ~r"The module SupervisorTest was given as a child.*\nbut it does not implement"m
+
+    assert_raise ArgumentError, message, fn ->
+      Supervisor.child_spec(SupervisorTest, [])
+    end
+
+    message = ~r"The module Unknown was given as a child.*but it does not exist"m
+
+    assert_raise ArgumentError, message, fn ->
+      Supervisor.child_spec(Unknown, [])
+    end
+
+    message = ~r"supervisors expect each child to be one of"
+
+    assert_raise ArgumentError, message, fn ->
+      Supervisor.child_spec("other", [])
+    end
+  end
+
+  test "init/2" do
+    flags = %{intensity: 3, period: 5, strategy: :one_for_one, auto_shutdown: :never}
+    children = [%{id: Task, restart: :temporary, start: {Task, :start_link, [[]]}}]
+    assert Supervisor.init([Task], strategy: :one_for_one) == {:ok, {flags, children}}
+
+    flags = %{intensity: 1, period: 2, strategy: :one_for_all, auto_shutdown: :never}
+    children = [%{id: Task, restart: :temporary, start: {Task, :start_link, [:foo]}}]
+
+    assert Supervisor.init(
+             [{Task, :foo}],
+             strategy: :one_for_all,
+             max_restarts: 1,
+             max_seconds: 2
+           ) == {:ok, {flags, children}}
+
+    assert_raise ArgumentError, "expected :strategy option to be given", fn ->
+      Supervisor.init([], [])
     end
   end
 
-  import Supervisor.Spec
+  test "init/2 with old and new child specs" do
+    flags = %{intensity: 3, period: 5, strategy: :one_for_one, auto_shutdown: :never}
+
+    children = [
+      %{id: Task, restart: :temporary, start: {Task, :start_link, [[]]}},
+      old_spec = {Task, {Task, :start_link, []}, :permanent, 5000, :worker, [Task]}
+    ]
+
+    assert Supervisor.init([Task, old_spec], strategy: :one_for_one) ==
+             {:ok, {flags, children}}
+  end
+
+  test "start_link/2 with via" do
+    Supervisor.start_link([], strategy: :one_for_one, name: {:via, :global, :via_sup})
+    assert Supervisor.which_children({:via, :global, :via_sup}) == []
+  end
+
+  test "start_link/3 with global" do
+    Supervisor.start_link([], strategy: :one_for_one, name: {:global, :global_sup})
+    assert Supervisor.which_children({:global, :global_sup}) == []
+  end
+
+  test "start_link/3 with local" do
+    Supervisor.start_link([], strategy: :one_for_one, name: :my_sup)
+    assert Supervisor.which_children(:my_sup) == []
+  end
 
   test "start_link/2" do
-    children = [worker(Stack, [[:hello], [name: :dyn_stack]])]
+    children = [{Stack, {[:hello], [name: :dyn_stack]}}]
     {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one)
 
     wait_until_registered(:dyn_stack)
@@ -51,32 +166,108 @@ defmodule SupervisorTest do
 
     wait_until_registered(:dyn_stack)
     assert GenServer.call(:dyn_stack, :pop) == :hello
+    Supervisor.stop(pid)
+
+    assert_raise ArgumentError, ~r"expected :name option to be one of the following:", fn ->
+      name = "my_gen_server_name"
+      Supervisor.start_link(children, name: name, strategy: :one_for_one)
+    end
+
+    assert_raise ArgumentError, ~r"expected :name option to be one of the following:", fn ->
+      name = {:invalid_tuple, "my_gen_server_name"}
+      Supervisor.start_link(children, name: name, strategy: :one_for_one)
+    end
+
+    assert_raise ArgumentError, ~r"expected :name option to be one of the following:", fn ->
+      name = {:via, "Via", "my_gen_server_name"}
+      Supervisor.start_link(children, name: name, strategy: :one_for_one)
+    end
+  end
+
+  test "start_link/2 with old and new specs" do
+    children = [
+      {Stack, {[:hello], []}},
+      {:old_stack, {SupervisorTest.Stack, :start_link, [{[:hello], []}]}, :permanent, 5000,
+       :worker, [SupervisorTest.Stack]}
+    ]
 
-    Process.exit(pid, :normal)
+    {:ok, _} = Supervisor.start_link(children, strategy: :one_for_one)
   end
 
   test "start_link/3" do
-    {:ok, pid} = Supervisor.start_link(Stack.Sup, {[:hello], [name: :stat_stack]}, name: :stack_sup)
-    wait_until_registered(:stack_sup)
-
+    {:ok, pid} = Supervisor.start_link(Stack.Sup, {[:hello], [name: :stat_stack]})
+    wait_until_registered(:stat_stack)
     assert GenServer.call(:stat_stack, :pop) == :hello
-    Process.exit(pid, :normal)
+    Supervisor.stop(pid)
   end
 
-  test "*_child functions" do
+  describe "start_child/2" do
+    test "supports old child spec" do
+      {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)
+      child = {Task, {Task, :start_link, [fn -> :ok end]}, :temporary, 5000, :worker, [Task]}
+      assert {:ok, pid} = Supervisor.start_child(pid, child)
+      assert is_pid(pid)
+    end
+
+    test "supports new child spec as tuple" do
+      {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)
+      child = %{id: Task, restart: :temporary, start: {Task, :start_link, [fn -> :ok end]}}
+      assert {:ok, pid} = Supervisor.start_child(pid, child)
+      assert is_pid(pid)
+    end
+
+    test "supports new child spec" do
+      {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)
+      child = {Task, fn -> :timer.sleep(:infinity) end}
+      assert {:ok, pid} = Supervisor.start_child(pid, child)
+      assert is_pid(pid)
+    end
+
+    test "with invalid child spec" do
+      {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)
+
+      assert Supervisor.start_child(pid, %{}) == {:error, :missing_id}
+      assert Supervisor.start_child(pid, {1, 2, 3, 4, 5, 6}) == {:error, {:invalid_mfa, 2}}
+
+      assert Supervisor.start_child(pid, %{id: 1, start: {Task, :foo, :bar}}) ==
+               {:error, {:invalid_mfa, {Task, :foo, :bar}}}
+
+      assert Supervisor.start_child(pid, %{id: 1, start: {Task, :foo, [:bar]}, shutdown: -1}) ==
+               {:error, {:invalid_shutdown, -1}}
+    end
+
+    test "with valid child spec" do
+      Process.flag(:trap_exit, true)
+
+      {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)
+
+      for n <- 0..1 do
+        assert {:ok, child_pid} =
+                 Supervisor.start_child(pid, %{
+                   id: n,
+                   start: {Task, :start_link, [fn -> Process.sleep(:infinity) end]},
+                   shutdown: n
+                 })
+
+        assert_kill(child_pid, :shutdown)
+      end
+    end
+  end
+
+  test "child life cycle" do
     {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)
 
     assert Supervisor.which_children(pid) == []
-    assert Supervisor.count_children(pid) ==
-           %{specs: 0, active: 0, supervisors: 0, workers: 0}
+    assert Supervisor.count_children(pid) == %{specs: 0, active: 0, supervisors: 0, workers: 0}
 
-    {:ok, stack} = Supervisor.start_child(pid, worker(Stack, [[:hello], []]))
+    child_spec = Supervisor.child_spec({Stack, {[:hello], []}}, [])
+    {:ok, stack} = Supervisor.start_child(pid, child_spec)
     assert GenServer.call(stack, :pop) == :hello
 
     assert Supervisor.which_children(pid) ==
-           [{SupervisorTest.Stack, stack, :worker, [SupervisorTest.Stack]}]
-    assert Supervisor.count_children(pid) ==
-           %{specs: 1, active: 1, supervisors: 0, workers: 1}
+             [{SupervisorTest.Stack, stack, :worker, [SupervisorTest.Stack]}]
+
+    assert Supervisor.count_children(pid) == %{specs: 1, active: 1, supervisors: 0, workers: 1}
 
     assert Supervisor.delete_child(pid, Stack) == {:error, :running}
     assert Supervisor.terminate_child(pid, Stack) == :ok
@@ -86,13 +277,18 @@ defmodule SupervisorTest do
 
     assert Supervisor.terminate_child(pid, Stack) == :ok
     assert Supervisor.delete_child(pid, Stack) == :ok
-
-    Process.exit(pid, :normal)
+    Supervisor.stop(pid)
   end
 
   defp wait_until_registered(name) do
-    unless Process.whereis(name) do
+    if !Process.whereis(name) do
       wait_until_registered(name)
     end
   end
+
+  defp assert_kill(pid, reason) do
+    ref = Process.monitor(pid)
+    Process.exit(pid, reason)
+    assert_receive {:DOWN, ^ref, _, _, _}
+  end
 end
diff --git a/lib/elixir/test/elixir/system_test.exs b/lib/elixir/test/elixir/system_test.exs
index 13949d346ec..b6d56dec778 100644
--- a/lib/elixir/test/elixir/system_test.exs
+++ b/lib/elixir/test/elixir/system_test.exs
@@ -1,78 +1,364 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule SystemTest do
   use ExUnit.Case
   import PathHelpers
 
-  test "build_info" do
-    assert is_map System.build_info
-    assert not nil?(System.build_info[:version])
-    assert not nil?(System.build_info[:tag])
-    assert not nil?(System.build_info[:date])
-  end
+  test "build_info/0" do
+    build_info = System.build_info()
+    assert is_map(build_info)
+    assert is_binary(build_info[:build])
+    assert is_binary(build_info[:date])
+    assert is_binary(build_info[:revision])
+    assert is_binary(build_info[:version])
+    assert is_binary(build_info[:otp_release])
+
+    if build_info[:revision] != "" do
+      assert String.length(build_info[:revision]) >= 7
+    end
 
-  test "cwd" do
-    assert is_binary System.cwd
-    assert is_binary System.cwd!
+    version_file = Path.join([__DIR__, "../../../..", "VERSION"]) |> Path.expand()
+    {:ok, version} = File.read(version_file)
+    assert build_info[:version] == String.trim(version)
+    assert build_info[:build] =~ "compiled with Erlang/OTP"
   end
 
-  if :file.native_name_encoding == :utf8 do
-    test "cwd_with_utf8" do
-      File.mkdir_p(tmp_path("héllò"))
+  test "user_home/0" do
+    assert is_binary(System.user_home())
+    assert is_binary(System.user_home!())
+  end
 
-      File.cd!(tmp_path("héllò"), fn ->
-        assert Path.basename(System.cwd!) == "héllò"
-      end)
-    after
-      File.rm_rf tmp_path("héllò")
-    end
+  test "tmp_dir/0" do
+    assert is_binary(System.tmp_dir())
+    assert is_binary(System.tmp_dir!())
   end
 
-  test "user_home" do
-    assert is_binary System.user_home
-    assert is_binary System.user_home!
+  test "endianness/0" do
+    assert System.endianness() in [:little, :big]
+    assert System.endianness() == System.compiled_endianness()
   end
 
-  test "tmp_dir" do
-    assert is_binary System.tmp_dir
-    assert is_binary System.tmp_dir!
+  test "pid/0" do
+    assert is_binary(System.pid())
   end
 
-  test "argv" do
-    list = elixir('-e "IO.inspect System.argv" -- -o opt arg1 arg2 --long-opt 10')
-    {args, _} = Code.eval_string list, []
+  test "argv/0" do
+    list = elixir(~c"-e \"IO.inspect System.argv()\" -- -o opt arg1 arg2 --long-opt 10")
+    {args, _} = Code.eval_string(list, [])
     assert args == ["-o", "opt", "arg1", "arg2", "--long-opt", "10"]
   end
 
   @test_var "SYSTEM_ELIXIR_ENV_TEST_VAR"
 
-  test "env" do
+  test "get_env/put_env/delete_env" do
     assert System.get_env(@test_var) == nil
+    assert System.get_env(@test_var, "SAMPLE") == "SAMPLE"
+    assert System.fetch_env(@test_var) == :error
+
+    message = "could not fetch environment variable #{inspect(@test_var)} because it is not set"
+    assert_raise System.EnvError, message, fn -> System.fetch_env!(@test_var) end
+
     System.put_env(@test_var, "SAMPLE")
+
     assert System.get_env(@test_var) == "SAMPLE"
     assert System.get_env()[@test_var] == "SAMPLE"
+    assert System.fetch_env(@test_var) == {:ok, "SAMPLE"}
+    assert System.fetch_env!(@test_var) == "SAMPLE"
 
     System.delete_env(@test_var)
     assert System.get_env(@test_var) == nil
 
-    System.put_env(%{@test_var => "OTHER_SAMPLE"})
-    assert System.get_env(@test_var) == "OTHER_SAMPLE"
+    assert_raise ArgumentError, ~r[cannot execute System.put_env/2 for key with \"=\"], fn ->
+      System.put_env("FOO=BAR", "BAZ")
+    end
+  end
+
+  test "put_env/2" do
+    System.put_env(%{@test_var => "MAP_STRING"})
+    assert System.get_env(@test_var) == "MAP_STRING"
+
+    System.put_env([{String.to_atom(@test_var), "KW_ATOM"}])
+    assert System.get_env(@test_var) == "KW_ATOM"
+
+    System.put_env([{String.to_atom(@test_var), nil}])
+    assert System.get_env(@test_var) == nil
+  end
+
+  test "cmd/2 raises for null bytes" do
+    assert_raise ArgumentError, ~r"cannot execute System.cmd/3 for program with null byte", fn ->
+      System.cmd("null\0byte", [])
+    end
+  end
+
+  test "cmd/3 raises with non-binary arguments" do
+    assert_raise ArgumentError, ~r"all arguments for System.cmd/3 must be binaries", fn ->
+      System.cmd("ls", [~c"/usr"])
+    end
+  end
+
+  describe "Windows" do
+    @describetag :windows
+
+    test "cmd/2" do
+      assert {"hello\r\n", 0} = System.cmd("cmd", ~w[/c echo hello])
+    end
+
+    test "cmd/3 (with options)" do
+      opts = [
+        into: [],
+        cd: File.cwd!(),
+        env: %{"foo" => "bar", "baz" => nil},
+        arg0: "echo",
+        stderr_to_stdout: true,
+        parallelism: true,
+        use_stdio: true
+      ]
+
+      assert {["hello\r\n"], 0} = System.cmd("cmd", ~w[/c echo hello], opts)
+    end
+
+    @echo "echo-elixir-test"
+    @tag :tmp_dir
+    test "cmd/3 with absolute and relative paths", config do
+      echo = Path.join(config.tmp_dir, @echo)
+      File.mkdir_p!(Path.dirname(echo))
+      File.ln_s!(System.find_executable("cmd"), echo)
+
+      File.cd!(Path.dirname(echo), fn ->
+        # There is a bug in OTP where find_executable is finding
+        # entries on the current directory. If this is the case,
+        # we should avoid the assertion below.
+        if !System.find_executable(@echo) do
+          assert :enoent = catch_error(System.cmd(@echo, ~w[/c echo hello]))
+        end
+
+        assert {"hello\r\n", 0} =
+                 System.cmd(Path.join(File.cwd!(), @echo), ~w[/c echo hello], [{:arg0, "echo"}])
+      end)
+    end
+
+    test "shell/1" do
+      assert {"hello\r\n", 0} = System.shell("echo hello")
+    end
+
+    test "shell/2 (with options)" do
+      opts = [
+        into: [],
+        cd: File.cwd!(),
+        env: %{"foo" => "bar", "baz" => nil},
+        stderr_to_stdout: true,
+        parallelism: true,
+        use_stdio: true
+      ]
+
+      assert {["bar\r\n"], 0} = System.shell("echo %foo%", opts)
+    end
+  end
+
+  describe "Unix" do
+    @describetag :unix
+
+    test "cmd/2" do
+      assert {"hello\n", 0} = System.cmd("echo", ["hello"])
+    end
+
+    test "cmd/3 (with options)" do
+      opts = [
+        into: [],
+        cd: File.cwd!(),
+        env: %{"foo" => "bar", "baz" => nil},
+        arg0: "echo",
+        stderr_to_stdout: true,
+        parallelism: true,
+        use_stdio: true
+      ]
+
+      assert {["hello\n"], 0} = System.cmd("echo", ["hello"], opts)
+    end
+
+    test "cmd/3 (can't use `use_stdio: false, stderr_to_stdout: true`)" do
+      opts = [
+        into: [],
+        cd: File.cwd!(),
+        env: %{"foo" => "bar", "baz" => nil},
+        arg0: "echo",
+        stderr_to_stdout: true,
+        use_stdio: false
+      ]
+
+      message = ~r"cannot use \"stderr_to_stdout: true\" and \"use_stdio: false\""
+
+      assert_raise ArgumentError, message, fn ->
+        System.cmd("echo", ["hello"], opts)
+      end
+    end
+
+    test "cmd/3 by line" do
+      assert {["hello", "world"], 0} =
+               System.cmd("echo", ["hello\nworld"], into: [], lines: 1024)
+
+      assert {["hello", "world"], 0} =
+               System.cmd("echo", ["-n", "hello\nworld"], into: [], lines: 3)
+    end
+
+    @echo "echo-elixir-test"
+    @tag :tmp_dir
+    test "cmd/3 with absolute and relative paths", config do
+      echo = Path.join(config.tmp_dir, @echo)
+      File.mkdir_p!(Path.dirname(echo))
+      File.ln_s!(System.find_executable("echo"), echo)
+
+      File.cd!(Path.dirname(echo), fn ->
+        # There is a bug in OTP where find_executable is finding
+        # entries on the current directory. If this is the case,
+        # we should avoid the assertion below.
+        if !System.find_executable(@echo) do
+          assert :enoent = catch_error(System.cmd(@echo, ["hello"]))
+        end
+
+        assert {"hello\n", 0} =
+                 System.cmd(Path.join(File.cwd!(), @echo), ["hello"], [{:arg0, "echo"}])
+      end)
+    end
+
+    test "shell/1" do
+      assert {"hello\n", 0} = System.shell("echo hello")
+    end
+
+    test "shell/1 with interpolation" do
+      assert {"1\n2\n", 0} = System.shell("x=1; echo $x; echo '2'")
+    end
+
+    test "shell/1 with empty string" do
+      assert {"", 0} = System.shell("")
+      assert {"", 0} = System.shell("  ")
+    end
+
+    @tag timeout: 1_000
+    test "shell/1 returns when command awaits input" do
+      assert {"", 0} = System.shell("cat", close_stdin: true)
+    end
+
+    test "shell/1 with comment" do
+      assert {"1\n", 0} = System.shell("echo '1' # comment")
+    end
+
+    test "shell/2 (with options)" do
+      opts = [
+        into: [],
+        cd: File.cwd!(),
+        env: %{"foo" => "bar", "baz" => nil},
+        stderr_to_stdout: true,
+        use_stdio: true
+      ]
+
+      assert {["bar\n"], 0} = System.shell("echo $foo", opts)
+    end
   end
 
-  test "cmd" do
-    assert is_binary(System.cmd "echo hello")
-    assert is_list(System.cmd 'echo hello')
+  @tag :unix
+  test "vm signals" do
+    assert System.trap_signal(:sigquit, :example, fn -> :ok end) == {:ok, :example}
+    assert System.trap_signal(:sigquit, :example, fn -> :ok end) == {:error, :already_registered}
+    assert {:ok, ref} = System.trap_signal(:sigquit, fn -> :ok end)
+
+    assert System.untrap_signal(:sigquit, :example) == :ok
+    assert System.trap_signal(:sigquit, :example, fn -> :ok end) == {:ok, :example}
+    assert System.trap_signal(:sigquit, ref, fn -> :ok end) == {:error, :already_registered}
+
+    assert System.untrap_signal(:sigusr1, :example) == {:error, :not_found}
+    assert System.untrap_signal(:sigquit, :example) == :ok
+    assert System.untrap_signal(:sigquit, :example) == {:error, :not_found}
+    assert System.untrap_signal(:sigquit, ref) == :ok
+    assert System.untrap_signal(:sigquit, ref) == {:error, :not_found}
+  end
+
+  @tag :unix
+  test "os signals" do
+    parent = self()
+
+    assert System.trap_signal(:sighup, :example, fn ->
+             send(parent, :sighup_called)
+             :ok
+           end) == {:ok, :example}
+
+    {"", 0} = System.cmd("kill", ["-s", "hup", System.pid()])
+
+    assert_receive :sighup_called
+  after
+    System.untrap_signal(:sighup, :example)
   end
 
-  test "find_executable with binary" do
+  test "find_executable/1" do
     assert System.find_executable("erl")
-    assert is_binary System.find_executable("erl")
+    assert is_binary(System.find_executable("erl"))
     assert !System.find_executable("does-not-really-exist-from-elixir")
+
+    message = ~r"cannot execute System.find_executable/1 for program with null byte"
+
+    assert_raise ArgumentError, message, fn ->
+      System.find_executable("null\0byte")
+    end
+  end
+
+  test "monotonic_time/0" do
+    assert is_integer(System.monotonic_time())
+  end
+
+  test "monotonic_time/1" do
+    assert is_integer(System.monotonic_time(:nanosecond))
+    assert abs(System.monotonic_time(:microsecond)) < abs(System.monotonic_time(:nanosecond))
+  end
+
+  test "system_time/0" do
+    assert is_integer(System.system_time())
+  end
+
+  test "system_time/1" do
+    assert is_integer(System.system_time(:nanosecond))
+    assert abs(System.system_time(:microsecond)) < abs(System.system_time(:nanosecond))
+  end
+
+  test "time_offset/0 and time_offset/1" do
+    assert is_integer(System.time_offset())
+    assert is_integer(System.time_offset(:second))
+  end
+
+  test "os_time/0" do
+    assert is_integer(System.os_time())
+  end
+
+  test "os_time/1" do
+    assert is_integer(System.os_time(:nanosecond))
+    assert abs(System.os_time(:microsecond)) < abs(System.os_time(:nanosecond))
+  end
+
+  test "unique_integer/0 and unique_integer/1" do
+    assert is_integer(System.unique_integer())
+    assert System.unique_integer([:positive]) > 0
+
+    assert System.unique_integer([:positive, :monotonic]) <
+             System.unique_integer([:positive, :monotonic])
+  end
+
+  test "convert_time_unit/3" do
+    time = System.monotonic_time(:nanosecond)
+    assert abs(System.convert_time_unit(time, :nanosecond, :microsecond)) < abs(time)
+  end
+
+  test "schedulers/0" do
+    assert System.schedulers() >= 1
+  end
+
+  test "schedulers_online/0" do
+    assert System.schedulers_online() >= 1
   end
 
-  test "find_executable with list" do
-    assert System.find_executable('erl')
-    assert is_list System.find_executable('erl')
-    assert !System.find_executable('does-not-really-exist-from-elixir')
+  test "otp_release/0" do
+    assert is_binary(System.otp_release())
   end
 end
diff --git a/lib/elixir/test/elixir/task/supervisor_test.exs b/lib/elixir/test/elixir/task/supervisor_test.exs
index 154773b9dbf..a16f1486b3e 100644
--- a/lib/elixir/test/elixir/task/supervisor_test.exs
+++ b/lib/elixir/test/elixir/task/supervisor_test.exs
@@ -1,65 +1,224 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Task.SupervisorTest do
-  use ExUnit.Case, async: true
+  use ExUnit.Case
+
+  @moduletag :capture_log
 
   setup do
     {:ok, pid} = Task.Supervisor.start_link()
     {:ok, supervisor: pid}
   end
 
-  setup do
-    :error_logger.tty(false)
-    on_exit fn -> :error_logger.tty(true) end
-    :ok
-  end
-
   def wait_and_send(caller, atom) do
-    send caller, :ready
+    send(caller, :ready)
     receive do: (true -> true)
-    send caller, atom
+    send(caller, atom)
   end
 
-  test "async/1", config do
-    parent = self()
-    fun = fn -> wait_and_send(parent, :done) end
-    task = Task.Supervisor.async(config[:supervisor], fun)
+  def sleep(number) do
+    Process.sleep(number)
+    number
+  end
+
+  test "can be supervised directly", config do
+    modules = [{Task.Supervisor, name: config.test}]
+    assert {:ok, _} = Supervisor.start_link(modules, strategy: :one_for_one)
+    assert Process.whereis(config.test)
+  end
+
+  test "start with spawn_opt" do
+    {:ok, pid} = Task.Supervisor.start_link(spawn_opt: [priority: :high])
+    assert Process.info(pid, :priority) == {:priority, :high}
+  end
+
+  test "multiple supervisors can be supervised and identified with simple child spec" do
+    {:ok, _} = Registry.start_link(keys: :unique, name: TaskSup.Registry)
+
+    children = [
+      {Task.Supervisor, strategy: :one_for_one, name: :simple_name},
+      {Task.Supervisor, strategy: :one_for_one, name: {:global, :global_name}},
+      {Task.Supervisor,
+       strategy: :one_for_one, name: {:via, Registry, {TaskSup.Registry, "via_name"}}}
+    ]
+
+    assert {:ok, supsup} = Supervisor.start_link(children, strategy: :one_for_one)
+
+    assert {:ok, no_name_dynsup} =
+             Supervisor.start_child(supsup, {Task.Supervisor, strategy: :one_for_one})
+
+    assert Task.Supervisor.children(:simple_name) == []
+    assert Task.Supervisor.children({:global, :global_name}) == []
+    assert Task.Supervisor.children({:via, Registry, {TaskSup.Registry, "via_name"}}) == []
+    assert Task.Supervisor.children(no_name_dynsup) == []
+
+    assert Supervisor.start_child(supsup, {Task.Supervisor, strategy: :one_for_one}) ==
+             {:error, {:already_started, no_name_dynsup}}
+  end
+
+  test "counts and returns children", config do
+    assert Task.Supervisor.children(config[:supervisor]) == []
+
+    assert Supervisor.count_children(config[:supervisor]) ==
+             %{active: 0, specs: 0, supervisors: 0, workers: 0}
+
+    assert DynamicSupervisor.count_children(config[:supervisor]) ==
+             %{active: 0, specs: 0, supervisors: 0, workers: 0}
+  end
+
+  describe "async/1" do
+    test "spawns tasks under the supervisor", config do
+      parent = self()
+      fun = fn -> wait_and_send(parent, :done) end
+      task = Task.Supervisor.async(config[:supervisor], fun)
+      assert Task.Supervisor.children(config[:supervisor]) == [task.pid]
+
+      # Assert the struct
+      assert task.__struct__ == Task
+      assert is_pid(task.pid)
+      assert is_reference(task.ref)
+
+      # Assert the link
+      {:links, links} = Process.info(self(), :links)
+      assert task.pid in links
+
+      receive do: (:ready -> :ok)
+
+      # Assert the initial call
+      {:name, fun_name} = Function.info(fun, :name)
+      assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(task.pid)
+
+      # Run the task
+      send(task.pid, true)
+
+      # Assert response and monitoring messages
+      ref = task.ref
+      assert_receive {^ref, :done}
+      assert_receive {:DOWN, ^ref, _, _, :normal}
+    end
+
+    test "with custom shutdown", config do
+      Process.flag(:trap_exit, true)
+      parent = self()
+
+      fun = fn -> wait_and_send(parent, :done) end
+      %{pid: pid} = Task.Supervisor.async(config[:supervisor], fun, shutdown: :brutal_kill)
+
+      Process.exit(config[:supervisor], :shutdown)
+      assert_receive {:DOWN, _, _, ^pid, :killed}
+    end
 
+    test "raises when :max_children is reached" do
+      {:ok, sup} = Task.Supervisor.start_link(max_children: 1)
+      Task.Supervisor.async(sup, fn -> Process.sleep(:infinity) end)
+
+      assert_raise RuntimeError, ~r/reached the maximum number of tasks/, fn ->
+        Task.Supervisor.async(sup, fn -> :ok end)
+      end
+    end
+
+    test "with $callers", config do
+      sup = config[:supervisor]
+      grandparent = self()
+
+      Task.Supervisor.async(sup, fn ->
+        parent = self()
+        assert Process.get(:"$callers") == [grandparent]
+        assert Process.get(:"$ancestors") == [sup, grandparent]
+
+        Task.Supervisor.async(sup, fn ->
+          assert Process.get(:"$callers") == [parent, grandparent]
+          assert Process.get(:"$ancestors") == [sup, grandparent]
+        end)
+        |> Task.await()
+      end)
+      |> Task.await()
+    end
+  end
+
+  test "async/3", config do
+    args = [self(), :done]
+    task = Task.Supervisor.async(config[:supervisor], __MODULE__, :wait_and_send, args)
     assert Task.Supervisor.children(config[:supervisor]) == [task.pid]
 
-    # Assert the struct
+    receive do: (:ready -> :ok)
+    assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(task.pid)
+
+    send(task.pid, true)
     assert task.__struct__ == Task
-    assert is_pid task.pid
-    assert is_reference task.ref
+    assert task.mfa == {__MODULE__, :wait_and_send, 2}
+    assert Task.await(task) == :done
+  end
 
-    # Assert the link
-    {:links, links} = Process.info(self, :links)
-    assert task.pid in links
+  describe "async_nolink/1" do
+    test "spawns a task under the supervisor without linking to the caller", config do
+      parent = self()
+      fun = fn -> wait_and_send(parent, :done) end
+      task = Task.Supervisor.async_nolink(config[:supervisor], fun)
+      assert Task.Supervisor.children(config[:supervisor]) == [task.pid]
 
-    receive do: (:ready -> :ok)
+      # Assert the struct
+      assert task.__struct__ == Task
+      assert is_pid(task.pid)
+      assert is_reference(task.ref)
+      assert task.mfa == {:erlang, :apply, 2}
+
+      # Refute the link
+      {:links, links} = Process.info(self(), :links)
+      refute task.pid in links
+
+      receive do: (:ready -> :ok)
+
+      # Assert the initial call
+      {:name, fun_name} = Function.info(fun, :name)
+      assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(task.pid)
+
+      # Run the task
+      send(task.pid, true)
 
-    # Assert the initial call
-    {:name, fun_name} = :erlang.fun_info(fun, :name)
-    assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(task.pid)
+      # Assert response and monitoring messages
+      ref = task.ref
+      assert_receive {^ref, :done}
+      assert_receive {:DOWN, ^ref, _, _, :normal}
+    end
 
-    # Run the task
-    send task.pid, true
+    test "with custom shutdown", config do
+      Process.flag(:trap_exit, true)
+      parent = self()
 
-    # Assert response and monitoring messages
-    ref = task.ref
-    assert_receive {^ref, :done}
-    assert_receive {:DOWN, ^ref, _, _, :normal}
+      fun = fn -> wait_and_send(parent, :done) end
+      %{pid: pid} = Task.Supervisor.async_nolink(config[:supervisor], fun, shutdown: :brutal_kill)
+
+      Process.exit(config[:supervisor], :shutdown)
+      assert_receive {:DOWN, _, _, ^pid, :killed}
+    end
+
+    test "raises when :max_children is reached" do
+      {:ok, sup} = Task.Supervisor.start_link(max_children: 1)
+
+      Task.Supervisor.async_nolink(sup, fn -> Process.sleep(:infinity) end)
+
+      assert_raise RuntimeError, ~r/reached the maximum number of tasks/, fn ->
+        Task.Supervisor.async_nolink(sup, fn -> :ok end)
+      end
+    end
   end
 
-  test "async/3", config do
-    task = Task.Supervisor.async(config[:supervisor], __MODULE__, :wait_and_send, [self(), :done])
+  test "async_nolink/3", config do
+    args = [self(), :done]
+    task = Task.Supervisor.async_nolink(config[:supervisor], __MODULE__, :wait_and_send, args)
     assert Task.Supervisor.children(config[:supervisor]) == [task.pid]
 
     receive do: (:ready -> :ok)
     assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(task.pid)
 
-    send task.pid, true
+    send(task.pid, true)
     assert task.__struct__ == Task
+    assert task.mfa == {__MODULE__, :wait_and_send, 2}
     assert Task.await(task) == :done
   end
 
@@ -69,57 +228,344 @@ defmodule Task.SupervisorTest do
     {:ok, pid} = Task.Supervisor.start_child(config[:supervisor], fun)
     assert Task.Supervisor.children(config[:supervisor]) == [pid]
 
-    {:links, links} = Process.info(self, :links)
+    {:links, links} = Process.info(self(), :links)
     refute pid in links
 
     receive do: (:ready -> :ok)
-    {:name, fun_name} = :erlang.fun_info(fun, :name)
+    {:name, fun_name} = Function.info(fun, :name)
     assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(pid)
 
-    send pid, true
+    send(pid, true)
     assert_receive :done
   end
 
   test "start_child/3", config do
-    {:ok, pid} = Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, [self(), :done])
+    args = [self(), :done]
+
+    {:ok, pid} =
+      Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, args)
+
     assert Task.Supervisor.children(config[:supervisor]) == [pid]
 
-    {:links, links} = Process.info(self, :links)
+    {:links, links} = Process.info(self(), :links)
     refute pid in links
 
     receive do: (:ready -> :ok)
     assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(pid)
 
-    send pid, true
+    send(pid, true)
+    assert_receive :done
+
+    assert_raise FunctionClauseError, fn ->
+      Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, :illegal_arg)
+    end
+
+    assert_raise FunctionClauseError, fn ->
+      args = [self(), :done]
+      Task.Supervisor.start_child(config[:supervisor], __MODULE__, "wait_and_send", args)
+    end
+  end
+
+  test "start_child/1 with custom shutdown", config do
+    Process.flag(:trap_exit, true)
+    parent = self()
+
+    fun = fn -> wait_and_send(parent, :done) end
+    {:ok, pid} = Task.Supervisor.start_child(config[:supervisor], fun, shutdown: :brutal_kill)
+
+    Process.monitor(pid)
+    Process.exit(config[:supervisor], :shutdown)
+    assert_receive {:DOWN, _, _, ^pid, :killed}
+  end
+
+  test "start_child/1 with custom restart", config do
+    parent = self()
+
+    fun = fn -> wait_and_send(parent, :done) end
+    {:ok, pid} = Task.Supervisor.start_child(config[:supervisor], fun, restart: :permanent)
+
+    assert_receive :ready
+    Process.monitor(pid)
+    Process.exit(pid, :shutdown)
+    assert_receive {:DOWN, _, _, ^pid, :shutdown}
+    assert_receive :ready
+  end
+
+  test "start_child/1 with $callers", config do
+    sup = config[:supervisor]
+    grandparent = self()
+
+    Task.Supervisor.start_child(sup, fn ->
+      parent = self()
+      assert Process.get(:"$callers") == [grandparent]
+      assert Process.get(:"$ancestors") == [sup, grandparent]
+
+      Task.Supervisor.start_child(sup, fn ->
+        assert Process.get(:"$callers") == [parent, grandparent]
+        assert Process.get(:"$ancestors") == [sup, grandparent]
+        send(grandparent, :done)
+      end)
+    end)
+
     assert_receive :done
   end
 
   test "terminate_child/2", config do
-    {:ok, pid} = Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, [self(), :done])
+    args = [self(), :done]
+
+    {:ok, pid} =
+      Task.Supervisor.start_child(config[:supervisor], __MODULE__, :wait_and_send, args)
+
     assert Task.Supervisor.children(config[:supervisor]) == [pid]
     assert Task.Supervisor.terminate_child(config[:supervisor], pid) == :ok
     assert Task.Supervisor.children(config[:supervisor]) == []
-    assert Task.Supervisor.terminate_child(config[:supervisor], pid) == :ok
+    assert Task.Supervisor.terminate_child(config[:supervisor], pid) == {:error, :not_found}
   end
 
-  test "await/1 exits on task throw", config do
-    Process.flag(:trap_exit, true)
-    task = Task.Supervisor.async(config[:supervisor], fn -> throw :unknown end)
-    assert {{{:nocatch, :unknown}, _}, {Task, :await, [^task, 5000]}} =
-           catch_exit(Task.await(task))
+  describe "await/1" do
+    test "demonitors and unalias on timeout", config do
+      task =
+        Task.Supervisor.async(config[:supervisor], fn ->
+          assert_receive :go
+          :done
+        end)
+
+      assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}
+      new_ref = Process.monitor(task.pid)
+      old_ref = task.ref
+
+      send(task.pid, :go)
+      assert_receive {:DOWN, ^new_ref, _, _, _}
+      refute_received {^old_ref, :done}
+      refute_received {:DOWN, ^old_ref, _, _, _}
+    end
+
+    test "exits on task throw", config do
+      Process.flag(:trap_exit, true)
+      task = Task.Supervisor.async(config[:supervisor], fn -> throw(:unknown) end)
+
+      assert {{{:nocatch, :unknown}, _}, {Task, :await, [^task, 5000]}} =
+               catch_exit(Task.await(task))
+    end
+
+    test "exits on task error", config do
+      Process.flag(:trap_exit, true)
+      task = Task.Supervisor.async(config[:supervisor], fn -> raise "oops" end)
+      assert {{%RuntimeError{}, _}, {Task, :await, [^task, 5000]}} = catch_exit(Task.await(task))
+    end
+
+    test "exits on task exit", config do
+      Process.flag(:trap_exit, true)
+      task = Task.Supervisor.async(config[:supervisor], fn -> exit(:unknown) end)
+      assert {:unknown, {Task, :await, [^task, 5000]}} = catch_exit(Task.await(task))
+    end
   end
 
-  test "await/1 exits on task error", config do
-    Process.flag(:trap_exit, true)
-    task = Task.Supervisor.async(config[:supervisor], fn -> raise "oops" end)
-    assert {{%RuntimeError{}, _}, {Task, :await, [^task, 5000]}} =
-           catch_exit(Task.await(task))
+  describe "async_stream" do
+    @opts []
+    test "streams an enumerable with fun", %{supervisor: supervisor} do
+      assert supervisor
+             |> Task.Supervisor.async_stream(1..4, &sleep/1, @opts)
+             |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]
+    end
+
+    test "streams an enumerable with mfa", %{supervisor: supervisor} do
+      assert supervisor
+             |> Task.Supervisor.async_stream(1..4, __MODULE__, :sleep, [], @opts)
+             |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]
+    end
+
+    test "streams an enumerable without leaking tasks", %{supervisor: supervisor} do
+      assert supervisor
+             |> Task.Supervisor.async_stream(1..4, &sleep/1, @opts)
+             |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]
+
+      refute_received _
+    end
+
+    test "streams an enumerable with slowest first", %{supervisor: supervisor} do
+      Process.flag(:trap_exit, true)
+
+      assert supervisor
+             |> Task.Supervisor.async_stream(4..1//-1, &sleep/1, @opts)
+             |> Enum.to_list() == [ok: 4, ok: 3, ok: 2, ok: 1]
+    end
+
+    test "streams an enumerable with exits", %{supervisor: supervisor} do
+      Process.flag(:trap_exit, true)
+
+      assert supervisor
+             |> Task.Supervisor.async_stream(1..4, &yield_and_exit(Integer.to_string(&1)), @opts)
+             |> Enum.to_list() == [exit: "1", exit: "2", exit: "3", exit: "4"]
+    end
+
+    test "shuts down unused tasks", %{supervisor: supervisor} do
+      collection = [0, :infinity, :infinity, :infinity]
+
+      assert supervisor
+             |> Task.Supervisor.async_stream(collection, &sleep/1, @opts)
+             |> Enum.take(1) == [ok: 0]
+
+      assert Process.info(self(), :links) == {:links, [supervisor]}
+    end
+
+    test "shuts down unused tasks without leaking messages", %{supervisor: supervisor} do
+      collection = [0, :infinity, :infinity, :infinity]
+
+      assert supervisor
+             |> Task.Supervisor.async_stream(collection, &sleep/1, @opts)
+             |> Enum.take(1) == [ok: 0]
+
+      refute_received _
+    end
+
+    test "raises an error if :max_children is reached with clean stream shutdown",
+         %{supervisor: unused_supervisor} do
+      {:ok, supervisor} = Task.Supervisor.start_link(max_children: 1)
+      collection = [:infinity, :infinity, :infinity]
+
+      assert_raise RuntimeError, ~r/reached the maximum number of tasks/, fn ->
+        supervisor
+        |> Task.Supervisor.async_stream(collection, &sleep/1, max_concurrency: 2)
+        |> Enum.to_list()
+      end
+
+      {:links, links} = Process.info(self(), :links)
+      assert MapSet.new(links) == MapSet.new([unused_supervisor, supervisor])
+      refute_received _
+    end
+
+    test "with $callers", config do
+      sup = config[:supervisor]
+      grandparent = self()
+
+      Task.Supervisor.async_stream(sup, [1], fn 1 ->
+        parent = self()
+        assert Process.get(:"$callers") == [grandparent]
+        assert Process.get(:"$ancestors") == [sup, grandparent]
+
+        Task.Supervisor.async_stream(sup, [1], fn 1 ->
+          assert Process.get(:"$callers") == [parent, grandparent]
+          assert Process.get(:"$ancestors") == [sup, grandparent]
+          send(grandparent, :done)
+        end)
+        |> Stream.run()
+      end)
+      |> Stream.run()
+
+      assert_receive :done
+    end
+
+    test "consuming from another process", config do
+      parent = self()
+      stream = Task.Supervisor.async_stream(config[:supervisor], [1, 2, 3], &send(parent, &1))
+      Task.start(Stream, :run, [stream])
+      assert_receive 1
+      assert_receive 2
+      assert_receive 3
+    end
+
+    test "with timeout and :zip_input_on_exit set to true", %{supervisor: supervisor} do
+      opts = Keyword.merge(@opts, zip_input_on_exit: true, on_timeout: :kill_task, timeout: 50)
+
+      assert supervisor
+             |> Task.Supervisor.async_stream([1, 100], &sleep/1, opts)
+             |> Enum.to_list() == [ok: 1, exit: {100, :timeout}]
+    end
+
+    test "with outer halt on failure and :zip_input_on_exit", %{supervisor: supervisor} do
+      Process.flag(:trap_exit, true)
+      opts = Keyword.merge(@opts, zip_input_on_exit: true)
+
+      assert supervisor
+             |> Task.Supervisor.async_stream(1..8, &exit/1, opts)
+             |> Enum.take(4) == [exit: {1, 1}, exit: {2, 2}, exit: {3, 3}, exit: {4, 4}]
+    end
+
+    test "does not allow streaming with invalid :shutdown", %{supervisor: supervisor} do
+      message = ":shutdown must be either a positive integer or :brutal_kill"
+
+      assert_raise ArgumentError, message, fn ->
+        Task.Supervisor.async_stream(supervisor, [], fn _ -> :ok end, shutdown: :unknown)
+      end
+    end
   end
 
-  test "await/1 exits on task exit", config do
-    Process.flag(:trap_exit, true)
-    task = Task.Supervisor.async(config[:supervisor], fn -> exit :unknown end)
-    assert {:unknown, {Task, :await, [^task, 5000]}} =
-           catch_exit(Task.await(task))
+  describe "async_stream_nolink" do
+    @opts [max_concurrency: 4]
+
+    test "streams an enumerable with fun", %{supervisor: supervisor} do
+      assert supervisor
+             |> Task.Supervisor.async_stream_nolink(1..4, &sleep/1, @opts)
+             |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]
+    end
+
+    test "streams an enumerable with mfa", %{supervisor: supervisor} do
+      assert supervisor
+             |> Task.Supervisor.async_stream_nolink(1..4, __MODULE__, :sleep, [], @opts)
+             |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]
+    end
+
+    test "streams an enumerable without leaking tasks", %{supervisor: supervisor} do
+      assert supervisor
+             |> Task.Supervisor.async_stream_nolink(1..4, &sleep/1, @opts)
+             |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]
+
+      refute_received _
+    end
+
+    test "streams an enumerable with slowest first", %{supervisor: supervisor} do
+      assert supervisor
+             |> Task.Supervisor.async_stream_nolink(4..1//-1, &sleep/1, @opts)
+             |> Enum.to_list() == [ok: 4, ok: 3, ok: 2, ok: 1]
+    end
+
+    test "streams an enumerable with exits", %{supervisor: supervisor} do
+      assert supervisor
+             |> Task.Supervisor.async_stream_nolink(1..4, &yield_and_exit/1, @opts)
+             |> Enum.to_list() == [exit: 1, exit: 2, exit: 3, exit: 4]
+    end
+
+    test "shuts down unused tasks", %{supervisor: supervisor} do
+      collection = [0, :infinity, :infinity, :infinity]
+
+      assert supervisor
+             |> Task.Supervisor.async_stream_nolink(collection, &sleep/1, @opts)
+             |> Enum.take(1) == [ok: 0]
+
+      assert Process.info(self(), :links) == {:links, [supervisor]}
+    end
+
+    test "shuts down unused tasks without leaking messages", %{supervisor: supervisor} do
+      collection = [0, :infinity, :infinity, :infinity]
+
+      assert supervisor
+             |> Task.Supervisor.async_stream_nolink(collection, &sleep/1, @opts)
+             |> Enum.take(1) == [ok: 0]
+
+      refute_received _
+    end
+
+    test "raises an error if :max_children is reached with clean stream shutdown",
+         %{supervisor: unused_supervisor} do
+      {:ok, supervisor} = Task.Supervisor.start_link(max_children: 1)
+      collection = [:infinity, :infinity, :infinity]
+
+      assert_raise RuntimeError, ~r/reached the maximum number of tasks/, fn ->
+        supervisor
+        |> Task.Supervisor.async_stream_nolink(collection, &sleep/1, max_concurrency: 2)
+        |> Enum.to_list()
+      end
+
+      {:links, links} = Process.info(self(), :links)
+      assert MapSet.new(links) == MapSet.new([unused_supervisor, supervisor])
+      refute_received _
+    end
+  end
+
+  def yield_and_exit(value) do
+    # We call yield first so we give the parent a chance to monitor
+    :erlang.yield()
+    :erlang.exit(value)
   end
 end
diff --git a/lib/elixir/test/elixir/task_test.exs b/lib/elixir/test/elixir/task_test.exs
index a75d80228b7..1b5427543dc 100644
--- a/lib/elixir/test/elixir/task_test.exs
+++ b/lib/elixir/test/elixir/task_test.exs
@@ -1,18 +1,70 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-defmodule TaskTest do
-  use ExUnit.Case, async: true
+Code.require_file("test_helper.exs", __DIR__)
 
-  setup do
-    :error_logger.tty(false)
-    on_exit fn -> :error_logger.tty(true) end
-    :ok
-  end
+defmodule TaskTest do
+  use ExUnit.Case
+  doctest Task
+  @moduletag :capture_log
 
   def wait_and_send(caller, atom) do
-    send caller, :ready
+    send(caller, :ready)
     receive do: (true -> true)
-    send caller, atom
+    send(caller, atom)
+  end
+
+  defp create_task_in_other_process do
+    caller = self()
+    spawn(fn -> send(caller, Task.async(fn -> nil end)) end)
+    receive do: (task -> task)
+  end
+
+  defp create_dummy_task(reason) do
+    {pid, ref} = spawn_monitor(Kernel, :exit, [reason])
+
+    receive do
+      {:DOWN, ^ref, _, _, _} ->
+        %Task{ref: ref, pid: pid, owner: self(), mfa: {__MODULE__, :create_dummy_task, 1}}
+    end
+  end
+
+  def sleep(number) do
+    Process.sleep(number)
+    number
+  end
+
+  def wait_until_down(task) do
+    ref = Process.monitor(task.pid)
+    assert_receive {:DOWN, ^ref, _, _, _}
+  end
+
+  test "can be supervised directly" do
+    assert {:ok, _} = Supervisor.start_link([{Task, fn -> :ok end}], strategy: :one_for_one)
+  end
+
+  test "generates child_spec/1" do
+    defmodule MyTask do
+      use Task
+    end
+
+    assert MyTask.child_spec([:hello]) == %{
+             id: MyTask,
+             restart: :temporary,
+             start: {MyTask, :start_link, [[:hello]]}
+           }
+
+    defmodule CustomTask do
+      use Task, id: :id, restart: :permanent, shutdown: :infinity, start: {:foo, :bar, []}
+    end
+
+    assert CustomTask.child_spec([:hello]) == %{
+             id: :id,
+             restart: :permanent,
+             shutdown: :infinity,
+             start: {:foo, :bar, []}
+           }
   end
 
   test "async/1" do
@@ -22,21 +74,22 @@ defmodule TaskTest do
 
     # Assert the struct
     assert task.__struct__ == Task
-    assert is_pid task.pid
-    assert is_reference task.ref
+    assert is_pid(task.pid)
+    assert is_reference(task.ref)
+    assert task.mfa == {:erlang, :apply, 2}
 
     # Assert the link
-    {:links, links} = Process.info(self, :links)
+    {:links, links} = Process.info(self(), :links)
     assert task.pid in links
 
     receive do: (:ready -> :ok)
 
     # Assert the initial call
-    {:name, fun_name} = :erlang.fun_info(fun, :name)
+    {:name, fun_name} = Function.info(fun, :name)
     assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(task.pid)
 
     # Run the task
-    send task.pid, true
+    send(task.pid, true)
 
     # Assert response and monitoring messages
     ref = task.ref
@@ -47,98 +100,1081 @@ defmodule TaskTest do
   test "async/3" do
     task = Task.async(__MODULE__, :wait_and_send, [self(), :done])
     assert task.__struct__ == Task
+    assert task.mfa == {__MODULE__, :wait_and_send, 2}
 
-    {:links, links} = Process.info(self, :links)
+    {:links, links} = Process.info(self(), :links)
     assert task.pid in links
 
     receive do: (:ready -> :ok)
-
     assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(task.pid)
 
     send(task.pid, true)
-
     assert Task.await(task) === :done
     assert_receive :done
   end
 
+  test "async with $callers" do
+    grandparent = self()
+
+    Task.async(fn ->
+      parent = self()
+      assert Process.get(:"$callers") == [grandparent]
+
+      Task.async(fn ->
+        assert Process.get(:"$callers") == [parent, grandparent]
+      end)
+      |> Task.await()
+    end)
+    |> Task.await()
+  end
+
+  test "start/1" do
+    parent = self()
+    fun = fn -> wait_and_send(parent, :done) end
+    {:ok, pid} = Task.start(fun)
+
+    {:links, links} = Process.info(self(), :links)
+    refute pid in links
+
+    receive do: (:ready -> :ok)
+
+    {:name, fun_name} = Function.info(fun, :name)
+    assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(pid)
+
+    send(pid, true)
+    assert_receive :done
+  end
+
+  test "start/3" do
+    {:ok, pid} = Task.start(__MODULE__, :wait_and_send, [self(), :done])
+
+    {:links, links} = Process.info(self(), :links)
+    refute pid in links
+
+    receive do: (:ready -> :ok)
+
+    assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(pid)
+
+    send(pid, true)
+    assert_receive :done
+  end
+
+  test "completed/1" do
+    task = Task.completed(:done)
+    assert task.__struct__ == Task
+
+    refute task.pid
+
+    assert Task.await(task) == :done
+  end
+
   test "start_link/1" do
     parent = self()
     fun = fn -> wait_and_send(parent, :done) end
     {:ok, pid} = Task.start_link(fun)
 
-    {:links, links} = Process.info(self, :links)
+    {:links, links} = Process.info(self(), :links)
     assert pid in links
 
     receive do: (:ready -> :ok)
 
-    {:name, fun_name} = :erlang.fun_info(fun, :name)
+    {:name, fun_name} = Function.info(fun, :name)
     assert {__MODULE__, fun_name, 0} === :proc_lib.translate_initial_call(pid)
 
-    send pid, true
+    send(pid, true)
     assert_receive :done
   end
 
   test "start_link/3" do
     {:ok, pid} = Task.start_link(__MODULE__, :wait_and_send, [self(), :done])
 
-    {:links, links} = Process.info(self, :links)
+    {:links, links} = Process.info(self(), :links)
     assert pid in links
 
     receive do: (:ready -> :ok)
 
     assert {__MODULE__, :wait_and_send, 2} === :proc_lib.translate_initial_call(pid)
 
-    send pid, true
+    send(pid, true)
     assert_receive :done
   end
 
-  test "await/1 exits on timeout" do
-    task = %Task{ref: make_ref()}
-    assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}
+  test "start_link with $callers" do
+    grandparent = self()
+
+    Task.start_link(fn ->
+      parent = self()
+      assert Process.get(:"$callers") == [grandparent]
+
+      Task.start_link(fn ->
+        assert Process.get(:"$callers") == [parent, grandparent]
+        send(grandparent, :done)
+      end)
+    end)
+
+    assert_receive :done
+  end
+
+  describe "ignore/1" do
+    test "discards on time replies" do
+      task = Task.async(fn -> :ok end)
+      wait_until_down(task)
+      assert Task.ignore(task) == {:ok, :ok}
+      assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}
+    end
+
+    test "discards late replies" do
+      task = Task.async(fn -> assert_receive(:go) && :ok end)
+      assert Task.ignore(task) == nil
+      send(task.pid, :go)
+      wait_until_down(task)
+      assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}
+    end
+
+    test "discards on-time failures" do
+      Process.flag(:trap_exit, true)
+      task = Task.async(fn -> exit(:oops) end)
+      wait_until_down(task)
+      assert Task.ignore(task) == {:exit, :oops}
+      assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}
+    end
+
+    test "discards late failures" do
+      task = Task.async(fn -> assert_receive(:go) && exit(:oops) end)
+      assert Task.ignore(task) == nil
+      send(task.pid, :go)
+      wait_until_down(task)
+      assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}
+    end
+
+    test "exits on :noconnection" do
+      ref = make_ref()
+      task = %Task{ref: ref, pid: self(), owner: self(), mfa: {__MODULE__, :test, 1}}
+      send(self(), {:DOWN, ref, self(), self(), :noconnection})
+      assert catch_exit(Task.ignore(task)) |> elem(0) == {:nodedown, node()}
+    end
+
+    test "can ignore completed tasks" do
+      assert Task.ignore(Task.completed(:done)) == {:ok, :done}
+    end
   end
 
-  test "await/1 exits on normal exit" do
-    task = Task.async(fn -> exit :normal end)
-    assert catch_exit(Task.await(task)) == {:normal, {Task, :await, [task, 5000]}}
+  describe "await/2" do
+    test "demonitors and unalias on timeout" do
+      task =
+        Task.async(fn ->
+          assert_receive :go
+          :done
+        end)
+
+      assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}
+      send(task.pid, :go)
+      ref = task.ref
+
+      wait_until_down(task)
+      refute_received {^ref, :done}
+      refute_received {:DOWN, ^ref, _, _, _}
+    end
+
+    test "exits on timeout" do
+      task = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      assert catch_exit(Task.await(task, 0)) == {:timeout, {Task, :await, [task, 0]}}
+    end
+
+    test "exits on normal exit" do
+      task = Task.async(fn -> exit(:normal) end)
+      assert catch_exit(Task.await(task)) == {:normal, {Task, :await, [task, 5000]}}
+    end
+
+    test "exits on task throw" do
+      Process.flag(:trap_exit, true)
+      task = Task.async(fn -> throw(:unknown) end)
+
+      assert {{{:nocatch, :unknown}, _}, {Task, :await, [^task, 5000]}} =
+               catch_exit(Task.await(task))
+    end
+
+    test "exits on task error" do
+      Process.flag(:trap_exit, true)
+      task = Task.async(fn -> raise "oops" end)
+      assert {{%RuntimeError{}, _}, {Task, :await, [^task, 5000]}} = catch_exit(Task.await(task))
+    end
+
+    @compile {:no_warn_undefined, :module_does_not_exist}
+
+    test "exits on task undef module error" do
+      Process.flag(:trap_exit, true)
+      task = Task.async(&:module_does_not_exist.undef/0)
+
+      assert {exit_status, mfa} = catch_exit(Task.await(task))
+      assert {:undef, [{:module_does_not_exist, :undef, _, _} | _]} = exit_status
+      assert {Task, :await, [^task, 5000]} = mfa
+    end
+
+    @compile {:no_warn_undefined, {TaskTest, :undef, 0}}
+
+    test "exits on task undef function error" do
+      Process.flag(:trap_exit, true)
+      task = Task.async(&TaskTest.undef/0)
+
+      assert {{:undef, [{TaskTest, :undef, _, _} | _]}, {Task, :await, [^task, 5000]}} =
+               catch_exit(Task.await(task))
+    end
+
+    test "exits on task exit" do
+      Process.flag(:trap_exit, true)
+      task = Task.async(fn -> exit(:unknown) end)
+      assert {:unknown, {Task, :await, [^task, 5000]}} = catch_exit(Task.await(task))
+    end
+
+    test "exits on :noconnection" do
+      ref = make_ref()
+      task = %Task{ref: ref, pid: self(), owner: self(), mfa: {__MODULE__, :test, 1}}
+      send(self(), {:DOWN, ref, :process, self(), :noconnection})
+      assert catch_exit(Task.await(task)) |> elem(0) == {:nodedown, node()}
+    end
+
+    test "exits on :noconnection from named monitor" do
+      ref = make_ref()
+      task = %Task{ref: ref, owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      send(self(), {:DOWN, ref, :process, {:name, :node}, :noconnection})
+      assert catch_exit(Task.await(task)) |> elem(0) == {:nodedown, :node}
+    end
+
+    test "raises when invoked from a non-owner process" do
+      task = create_task_in_other_process()
+
+      message =
+        "task #{inspect(task)} must be queried from the owner " <>
+          "but was queried from #{inspect(self())}"
+
+      assert_raise ArgumentError, message, fn -> Task.await(task, 1) end
+    end
+  end
+
+  describe "await_many/2" do
+    test "returns list of replies" do
+      tasks = for val <- [1, 3, 9], do: Task.async(fn -> val end)
+      assert Task.await_many(tasks) == [1, 3, 9]
+    end
+
+    test "returns replies in input order ignoring response order" do
+      refs = [ref_1 = make_ref(), ref_2 = make_ref(), ref_3 = make_ref()]
+
+      tasks =
+        Enum.map(refs, fn ref ->
+          %Task{ref: ref, owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+        end)
+
+      send(self(), {ref_2, 3})
+      send(self(), {ref_3, 9})
+      send(self(), {ref_1, 1})
+      assert Task.await_many(tasks) == [1, 3, 9]
+    end
+
+    test "returns an empty list immediately" do
+      assert Task.await_many([]) == []
+    end
+
+    test "ignores messages from other processes" do
+      other_ref = make_ref()
+      tasks = for val <- [:a, :b], do: Task.async(fn -> val end)
+      send(self(), other_ref)
+      send(self(), {other_ref, :z})
+      send(self(), {:DOWN, other_ref, :process, 1, :goodbye})
+      assert Task.await_many(tasks) == [:a, :b]
+      assert_received ^other_ref
+      assert_received {^other_ref, :z}
+      assert_received {:DOWN, ^other_ref, :process, 1, :goodbye}
+    end
+
+    test "ignores additional messages after reply" do
+      refs = [ref_1 = make_ref(), ref_2 = make_ref()]
+
+      tasks =
+        Enum.map(refs, fn ref ->
+          %Task{ref: ref, owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+        end)
+
+      send(self(), {ref_2, :b})
+      send(self(), {ref_2, :other})
+      send(self(), {ref_1, :a})
+      assert Task.await_many(tasks) == [:a, :b]
+      assert_received {^ref_2, :other}
+    end
+
+    test "exits on timeout" do
+      tasks = [Task.async(fn -> Process.sleep(:infinity) end)]
+      assert catch_exit(Task.await_many(tasks, 0)) == {:timeout, {Task, :await_many, [tasks, 0]}}
+    end
+
+    test "exits with same reason when task exits" do
+      tasks = [Task.async(fn -> exit(:normal) end)]
+      assert catch_exit(Task.await_many(tasks)) == {:normal, {Task, :await_many, [tasks, 5000]}}
+    end
+
+    test "exits immediately when any task exits" do
+      tasks = [
+        Task.async(fn -> Process.sleep(:infinity) end),
+        Task.async(fn -> exit(:normal) end)
+      ]
+
+      assert catch_exit(Task.await_many(tasks)) == {:normal, {Task, :await_many, [tasks, 5000]}}
+    end
+
+    test "exits immediately when any task crashes" do
+      Process.flag(:trap_exit, true)
+
+      tasks = [
+        Task.async(fn -> Process.sleep(:infinity) end),
+        Task.async(fn -> exit(:unknown) end)
+      ]
+
+      assert catch_exit(Task.await_many(tasks)) == {:unknown, {Task, :await_many, [tasks, 5000]}}
+
+      # Make sure all monitors are cleared up afterwards too
+      Enum.each(tasks, &Process.exit(&1.pid, :kill))
+      refute_received {:DOWN, _, _, _, _}
+    end
+
+    test "exits immediately when any task throws" do
+      Process.flag(:trap_exit, true)
+
+      tasks = [
+        Task.async(fn -> Process.sleep(:infinity) end),
+        Task.async(fn -> throw(:unknown) end)
+      ]
+
+      assert {{{:nocatch, :unknown}, _}, {Task, :await_many, [^tasks, 5000]}} =
+               catch_exit(Task.await_many(tasks))
+    end
+
+    test "exits immediately on any task error" do
+      Process.flag(:trap_exit, true)
+
+      tasks = [
+        Task.async(fn -> Process.sleep(:infinity) end),
+        Task.async(fn -> raise "oops" end)
+      ]
+
+      assert {{%RuntimeError{}, _}, {Task, :await_many, [^tasks, 5000]}} =
+               catch_exit(Task.await_many(tasks))
+    end
+
+    test "exits immediately on :noconnection" do
+      tasks = [
+        Task.async(fn -> Process.sleep(:infinity) end),
+        %Task{ref: ref = make_ref(), owner: self(), pid: self(), mfa: {__MODULE__, :test, 1}}
+      ]
+
+      send(self(), {:DOWN, ref, :process, self(), :noconnection})
+      assert catch_exit(Task.await_many(tasks)) |> elem(0) == {:nodedown, node()}
+    end
+
+    test "exits immediately on :noconnection from named monitor" do
+      tasks = [
+        Task.async(fn -> Process.sleep(:infinity) end),
+        %Task{ref: ref = make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      ]
+
+      send(self(), {:DOWN, ref, :process, {:name, :node}, :noconnection})
+      assert catch_exit(Task.await_many(tasks)) |> elem(0) == {:nodedown, :node}
+    end
+
+    test "raises when invoked from a non-owner process" do
+      tasks = [
+        Task.async(fn -> Process.sleep(:infinity) end),
+        bad_task = create_task_in_other_process()
+      ]
+
+      message =
+        "task #{inspect(bad_task)} must be queried from the owner " <>
+          "but was queried from #{inspect(self())}"
+
+      assert_raise ArgumentError, message, fn -> Task.await_many(tasks, 1) end
+    end
+  end
+
+  describe "yield/2" do
+    test "returns {:ok, result} when reply and :DOWN in message queue" do
+      task = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      send(self(), {task.ref, :result})
+      send(self(), {:DOWN, task.ref, :process, self(), :abnormal})
+      assert Task.yield(task, 0) == {:ok, :result}
+      refute_received {:DOWN, _, _, _, _}
+    end
+
+    test "returns nil on timeout" do
+      task = %Task{ref: make_ref(), pid: nil, owner: self(), mfa: {__MODULE__, :test, 1}}
+      assert Task.yield(task, 0) == nil
+    end
+
+    test "return exit on normal exit" do
+      task = Task.async(fn -> exit(:normal) end)
+      assert Task.yield(task) == {:exit, :normal}
+    end
+
+    test "exits on :noconnection" do
+      ref = make_ref()
+      task = %Task{ref: ref, pid: self(), owner: self(), mfa: {__MODULE__, :test, 1}}
+      send(self(), {:DOWN, ref, self(), self(), :noconnection})
+      assert catch_exit(Task.yield(task)) |> elem(0) == {:nodedown, node()}
+    end
+
+    test "raises when invoked from a non-owner process" do
+      task = create_task_in_other_process()
+
+      message =
+        "task #{inspect(task)} must be queried from the owner " <>
+          "but was queried from #{inspect(self())}"
+
+      assert_raise ArgumentError, message, fn -> Task.yield(task, 1) end
+    end
+  end
+
+  describe "yield_many/2" do
+    test "returns {:ok, result} when reply and :DOWN in message queue" do
+      task = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      send(self(), {task.ref, :result})
+      send(self(), {:DOWN, task.ref, :process, self(), :abnormal})
+      assert Task.yield_many([task], 0) == [{task, {:ok, :result}}]
+      refute_received {:DOWN, _, _, _, _}
+    end
+
+    test "returns nil on timeout by default" do
+      task = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      assert Task.yield_many([task], 0) == [{task, nil}]
+    end
+
+    test "shuts down on timeout when configured" do
+      Process.flag(:trap_exit, true)
+      task = Task.async(fn -> Process.sleep(:infinity) end)
+      assert Task.yield_many([task], timeout: 0, on_timeout: :kill_task) == [{task, nil}]
+      refute Process.alive?(task.pid)
+    end
+
+    test "ignores on timeout when configured" do
+      task =
+        Task.async(fn ->
+          receive do
+            :done -> :ok
+          end
+        end)
+
+      assert Task.yield_many([task], timeout: 0, on_timeout: :ignore) == [{task, nil}]
+      assert Process.alive?(task.pid)
+
+      ref = Process.monitor(task.pid)
+      send(task.pid, :done)
+      assert_receive {:DOWN, ^ref, _, _, _}
+
+      assert Task.yield(task, 0) == nil
+    end
+
+    test "return exit on normal exit" do
+      task = Task.async(fn -> exit(:normal) end)
+      assert Task.yield_many([task]) == [{task, {:exit, :normal}}]
+    end
+
+    test "exits on :noconnection" do
+      ref = make_ref()
+      task = %Task{ref: ref, pid: self(), owner: self(), mfa: {__MODULE__, :test, 1}}
+      send(self(), {:DOWN, ref, :process, self(), :noconnection})
+      assert catch_exit(Task.yield_many([task])) |> elem(0) == {:nodedown, node()}
+    end
+
+    test "raises when invoked from a non-owner process" do
+      task = create_task_in_other_process()
+
+      message =
+        "task #{inspect(task)} must be queried from the owner " <>
+          "but was queried from #{inspect(self())}"
+
+      assert_raise ArgumentError, message, fn -> Task.yield_many([task], 1) end
+    end
+
+    test "returns results from multiple tasks" do
+      task1 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      task2 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      task3 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+
+      send(self(), {task1.ref, :result})
+      send(self(), {:DOWN, task3.ref, :process, self(), :normal})
+
+      assert Task.yield_many([task1, task2, task3], 0) ==
+               [{task1, {:ok, :result}}, {task2, nil}, {task3, {:exit, :normal}}]
+    end
+
+    test "returns results from multiple tasks with limit" do
+      task1 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      task2 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      task3 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+
+      send(self(), {task1.ref, :result})
+      send(self(), {:DOWN, task3.ref, :process, self(), :normal})
+
+      assert Task.yield_many([task1, task2, task3], limit: 1, timeout: :infinity) ==
+               [{task1, {:ok, :result}}, {task2, nil}, {task3, nil}]
+
+      assert Task.yield_many([task2, task3], limit: 1, timeout: :infinity) ==
+               [{task2, nil}, {task3, {:exit, :normal}}]
+    end
+
+    test "returns results from multiple tasks with limit and on timeout" do
+      Process.flag(:trap_exit, true)
+      task1 = Task.async(fn -> Process.sleep(:infinity) end)
+      task2 = Task.async(fn -> :done end)
+
+      assert Task.yield_many([task1, task2], timeout: :infinity, on_timeout: :kill_task, limit: 1) ==
+               [{task1, nil}, {task2, {:ok, :done}}]
+
+      assert Process.alive?(task1.pid)
+
+      assert Task.yield_many([task1], timeout: 0, on_timeout: :kill_task, limit: 1) ==
+               [{task1, nil}]
+
+      refute Process.alive?(task1.pid)
+    end
+
+    test "returns results on infinity timeout" do
+      task1 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      task2 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+      task3 = %Task{ref: make_ref(), owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}
+
+      send(self(), {task1.ref, :result})
+      send(self(), {task2.ref, :result})
+      send(self(), {:DOWN, task3.ref, :process, self(), :normal})
+
+      assert Task.yield_many([task1, task2, task3], :infinity) ==
+               [{task1, {:ok, :result}}, {task2, {:ok, :result}}, {task3, {:exit, :normal}}]
+    end
   end
 
-  test "await/1 exits on task throw" do
-    Process.flag(:trap_exit, true)
-    task = Task.async(fn -> throw :unknown end)
-    assert {{{:nocatch, :unknown}, _}, {Task, :await, [^task, 5000]}} =
-           catch_exit(Task.await(task))
+  describe "shutdown/2" do
+    test "returns {:ok, result} when reply and abnormal :DOWN in message queue" do
+      task = create_dummy_task(:abnormal)
+      send(self(), {task.ref, :result})
+      send(self(), {:DOWN, task.ref, :process, task.pid, :abnormal})
+      assert Task.shutdown(task) == {:ok, :result}
+      refute_received {:DOWN, _, _, _, _}
+    end
+
+    test "returns {:ok, result} when reply and normal :DOWN in message queue" do
+      task = create_dummy_task(:normal)
+      send(self(), {task.ref, :result})
+      send(self(), {:DOWN, task.ref, :process, task.pid, :normal})
+      assert Task.shutdown(task) == {:ok, :result}
+      refute_received {:DOWN, _, _, _, _}
+    end
+
+    test "returns {:ok, result} when reply and shut down :DOWN in message queue" do
+      task = create_dummy_task(:shutdown)
+      send(self(), {task.ref, :result})
+      send(self(), {:DOWN, task.ref, :process, task.pid, :shutdown})
+      assert Task.shutdown(task) == {:ok, :result}
+      refute_received {:DOWN, _, _, _, _}
+    end
+
+    test "returns nil on shutting down task" do
+      task = Task.async(:timer, :sleep, [:infinity])
+      assert Task.shutdown(task) == nil
+    end
+
+    test "returns exit on abnormal :DOWN in message queue" do
+      task = create_dummy_task(:abnormal)
+      send(self(), {:DOWN, task.ref, :process, task.pid, :abnormal})
+      assert Task.shutdown(task) == {:exit, :abnormal}
+    end
+
+    test "returns exit on normal :DOWN in message queue" do
+      task = create_dummy_task(:normal)
+      send(self(), {:DOWN, task.ref, :process, task.pid, :normal})
+      assert Task.shutdown(task) == {:exit, :normal}
+    end
+
+    test "returns nil on shutdown :DOWN in message queue" do
+      task = create_dummy_task(:shutdown)
+      send(self(), {:DOWN, task.ref, :process, task.pid, :shutdown})
+      assert Task.shutdown(task) == nil
+    end
+
+    test "returns exit on killed :DOWN in message queue" do
+      task = create_dummy_task(:killed)
+      send(self(), {:DOWN, task.ref, :process, task.pid, :killed})
+      assert Task.shutdown(task) == {:exit, :killed}
+    end
+
+    test "exits on noconnection :DOWN in message queue" do
+      task = create_dummy_task(:noconnection)
+      send(self(), {:DOWN, task.ref, :process, task.pid, :noconnection})
+
+      assert catch_exit(Task.shutdown(task)) ==
+               {{:nodedown, node()}, {Task, :shutdown, [task, 5000]}}
+    end
+
+    test "ignores if task PID is nil" do
+      ref = make_ref()
+      send(self(), {ref, :done})
+
+      assert Task.shutdown(%Task{ref: ref, owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}) ==
+               {:ok, :done}
+
+      ref = make_ref()
+      send(self(), {:DOWN, ref, :process, self(), :done})
+
+      assert Task.shutdown(%Task{ref: ref, owner: self(), pid: nil, mfa: {__MODULE__, :test, 1}}) ==
+               {:exit, :done}
+    end
+
+    test "raises when invoked from a non-owner process" do
+      task = create_task_in_other_process()
+
+      message =
+        "task #{inspect(task)} must be queried from the owner " <>
+          "but was queried from #{inspect(self())}"
+
+      assert_raise ArgumentError, message, fn -> Task.shutdown(task) end
+    end
+
+    test "returns nil on killing task" do
+      caller = self()
+
+      task =
+        Task.async(fn ->
+          Process.flag(:trap_exit, true)
+          wait_and_send(caller, :ready)
+          Process.sleep(:infinity)
+        end)
+
+      receive do: (:ready -> :ok)
+
+      assert Task.shutdown(task, :brutal_kill) == nil
+      refute_received {:DOWN, _, _, _, _}
+    end
+
+    test "returns {:exit, :noproc} if task handled" do
+      task = create_dummy_task(:noproc)
+      assert Task.shutdown(task) == {:exit, :noproc}
+    end
   end
 
-  test "await/1 exits on task error" do
-    Process.flag(:trap_exit, true)
-    task = Task.async(fn -> raise "oops" end)
-    assert {{%RuntimeError{}, _}, {Task, :await, [^task, 5000]}} =
-           catch_exit(Task.await(task))
+  describe "shutdown/2 with :brutal_kill" do
+    test "returns {:ok, result} when reply and abnormal :DOWN in message queue" do
+      task = create_dummy_task(:abnormal)
+      send(self(), {task.ref, :result})
+      send(self(), {:DOWN, task.ref, :process, task.pid, :abnormal})
+      assert Task.shutdown(task, :brutal_kill) == {:ok, :result}
+      refute_received {:DOWN, _, _, _, _}
+    end
+
+    test "returns {:ok, result} when reply and normal :DOWN in message queue" do
+      task = create_dummy_task(:normal)
+      send(self(), {task.ref, :result})
+      send(self(), {:DOWN, task.ref, :process, task.pid, :normal})
+      assert Task.shutdown(task, :brutal_kill) == {:ok, :result}
+      refute_received {:DOWN, _, _, _, _}
+    end
+
+    test "returns {:ok, result} when reply and shut down :DOWN in message queue" do
+      task = create_dummy_task(:shutdown)
+      send(self(), {task.ref, :result})
+      send(self(), {:DOWN, task.ref, :process, task.pid, :shutdown})
+      assert Task.shutdown(task, :brutal_kill) == {:ok, :result}
+      refute_received {:DOWN, _, _, _, _}
+    end
+
+    test "returns nil on killed :DOWN in message queue" do
+      task = create_dummy_task(:killed)
+      send(self(), {:DOWN, task.ref, :process, task.pid, :killed})
+      assert Task.shutdown(task, :brutal_kill) == nil
+    end
+
+    test "returns exit on abnormal :DOWN in message queue" do
+      task = create_dummy_task(:abnormal)
+      send(self(), {:DOWN, task.ref, :process, task.pid, :abnormal})
+      assert Task.shutdown(task, :brutal_kill) == {:exit, :abnormal}
+    end
+
+    test "returns exit on normal :DOWN in message queue" do
+      task = create_dummy_task(:normal)
+      send(self(), {:DOWN, task.ref, :process, task.pid, :normal})
+      assert Task.shutdown(task, :brutal_kill) == {:exit, :normal}
+    end
+
+    test "returns exit on shutdown :DOWN in message queue" do
+      task = create_dummy_task(:shutdown)
+      send(self(), {:DOWN, task.ref, :process, task.pid, :shutdown})
+      assert Task.shutdown(task, :brutal_kill) == {:exit, :shutdown}
+    end
+
+    test "exits on noconnection :DOWN in message queue" do
+      task = create_dummy_task(:noconnection)
+      send(self(), {:DOWN, task.ref, :process, task.pid, :noconnection})
+
+      assert catch_exit(Task.shutdown(task, :brutal_kill)) ==
+               {{:nodedown, node()}, {Task, :shutdown, [task, :brutal_kill]}}
+    end
+
+    test "returns exit on killing task after shutdown timeout" do
+      caller = self()
+
+      task =
+        Task.async(fn ->
+          Process.flag(:trap_exit, true)
+          wait_and_send(caller, :ready)
+          Process.sleep(:infinity)
+        end)
+
+      receive do: (:ready -> :ok)
+      assert Task.shutdown(task, 1) == {:exit, :killed}
+    end
+
+    test "returns {:exit, :noproc} if task handled" do
+      task = create_dummy_task(:noproc)
+      assert Task.shutdown(task, :brutal_kill) == {:exit, :noproc}
+    end
   end
 
-  test "await/1 exits on task exit" do
-    Process.flag(:trap_exit, true)
-    task = Task.async(fn -> exit :unknown end)
-    assert {:unknown, {Task, :await, [^task, 5000]}} =
-           catch_exit(Task.await(task))
+  describe "async_stream/2" do
+    test "timeout" do
+      assert catch_exit([:infinity] |> Task.async_stream(&sleep/1, timeout: 0) |> Enum.to_list()) ==
+               {:timeout, {Task.Supervised, :stream, [0]}}
+
+      refute_received _
+    end
+
+    test "streams an enumerable with ordered: false" do
+      opts = [max_concurrency: 1, ordered: false]
+
+      assert 4..1//-1
+             |> Task.async_stream(&sleep(&1 * 100), opts)
+             |> Enum.to_list() == [ok: 400, ok: 300, ok: 200, ok: 100]
+
+      opts = [max_concurrency: 4, ordered: false]
+
+      assert 4..1//-1
+             |> Task.async_stream(&sleep(&1 * 100), opts)
+             |> Enum.to_list() == [ok: 100, ok: 200, ok: 300, ok: 400]
+    end
+
+    test "streams an enumerable with ordered: false, on_timeout: :kill_task" do
+      opts = [max_concurrency: 4, ordered: false, on_timeout: :kill_task, timeout: 50]
+
+      assert [100, 1, 100, 1]
+             |> Task.async_stream(&sleep/1, opts)
+             |> Enum.to_list() == [ok: 1, ok: 1, exit: :timeout, exit: :timeout]
+
+      refute_received _
+    end
+
+    test "streams an enumerable with infinite timeout" do
+      [ok: :ok] = Task.async_stream([1], fn _ -> :ok end, timeout: :infinity) |> Enum.to_list()
+    end
+
+    test "does not allow streaming with max_concurrency = 0" do
+      assert_raise ArgumentError, ":max_concurrency must be an integer greater than zero", fn ->
+        Task.async_stream([1], fn _ -> :ok end, max_concurrency: 0)
+      end
+    end
+
+    test "does not allow streaming with invalid :on_timeout" do
+      assert_raise ArgumentError, ":on_timeout must be either :exit or :kill_task", fn ->
+        Task.async_stream([1], fn _ -> :ok end, on_timeout: :unknown)
+      end
+    end
+
+    test "does not allow streaming with invalid :timeout" do
+      assert_raise ArgumentError, ":timeout must be either a positive integer or :infinity", fn ->
+        Task.async_stream([1], fn _ -> :ok end, timeout: :unknown)
+      end
+    end
+
+    test "streams with fake down messages on the inbox" do
+      parent = self()
+
+      assert Task.async_stream([:ok], fn :ok ->
+               {:links, links} = Process.info(self(), :links)
+
+               for link <- links do
+                 send(link, {:DOWN, make_ref(), :process, parent, :oops})
+               end
+
+               :ok
+             end)
+             |> Enum.to_list() == [ok: :ok]
+    end
+
+    test "with $callers" do
+      grandparent = self()
+
+      Task.async_stream([1], fn 1 ->
+        parent = self()
+        assert Process.get(:"$callers") == [grandparent]
+
+        Task.async_stream([1], fn 1 ->
+          assert Process.get(:"$callers") == [parent, grandparent]
+          send(grandparent, :done)
+        end)
+        |> Stream.run()
+      end)
+      |> Stream.run()
+
+      assert_receive :done
+    end
+
+    test "consuming from another process" do
+      parent = self()
+      stream = Task.async_stream([1, 2, 3], &send(parent, &1))
+      Task.start(Stream, :run, [stream])
+      assert_receive 1
+      assert_receive 2
+      assert_receive 3
+    end
+
+    test "wrapping a flat_map/concat with a haltable stream" do
+      result =
+        Stream.take([:foo, :bar], 1)
+        |> Stream.concat([1, 2])
+        |> Task.async_stream(& &1)
+        |> Enum.to_list()
+
+      assert result == [ok: :foo, ok: 1, ok: 2]
+    end
   end
 
-  test "await/1 exits on :noconnection" do
-    ref  = make_ref()
-    task = %Task{ref: ref, pid: self()}
-    send self(), {:DOWN, ref, self(), self(), :noconnection}
-    assert catch_exit(Task.await(task)) |> elem(0) == {:nodedown, :nonode@nohost}
+  for {desc, concurrency} <- [==: 4, <: 2, >: 8] do
+    describe "async_stream with max_concurrency #{desc} tasks" do
+      @opts [max_concurrency: concurrency]
+
+      test "streams an enumerable with fun" do
+        assert 1..4
+               |> Task.async_stream(&sleep/1, @opts)
+               |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]
+      end
+
+      test "streams an enumerable with mfa" do
+        assert 1..4
+               |> Task.async_stream(__MODULE__, :sleep, [], @opts)
+               |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]
+      end
+
+      test "streams an enumerable without leaking tasks" do
+        assert 1..4
+               |> Task.async_stream(&sleep/1, @opts)
+               |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]
+
+        refute_received _
+      end
+
+      test "streams an enumerable with slowest first" do
+        Process.flag(:trap_exit, true)
+
+        assert 4..1//-1
+               |> Task.async_stream(&sleep/1, @opts)
+               |> Enum.to_list() == [ok: 4, ok: 3, ok: 2, ok: 1]
+      end
+
+      test "streams an enumerable with exits" do
+        Process.flag(:trap_exit, true)
+
+        assert 1..4
+               |> Task.async_stream(&exit/1, @opts)
+               |> Enum.to_list() == [exit: 1, exit: 2, exit: 3, exit: 4]
+
+        refute_received {:EXIT, _, _}
+      end
+
+      test "shuts down unused tasks" do
+        assert [0, :infinity, :infinity, :infinity]
+               |> Task.async_stream(&sleep/1, @opts)
+               |> Enum.take(1) == [ok: 0]
+
+        assert Process.info(self(), :links) == {:links, []}
+      end
+
+      test "shuts down unused tasks without leaking messages" do
+        assert [0, :infinity, :infinity, :infinity]
+               |> Task.async_stream(&sleep/1, @opts)
+               |> Enum.take(1) == [ok: 0]
+
+        refute_received _
+      end
+
+      test "is zippable on success" do
+        task = 1..4 |> Task.async_stream(&sleep/1, @opts) |> Stream.map(&elem(&1, 1))
+        assert Enum.zip(task, task) == [{1, 1}, {2, 2}, {3, 3}, {4, 4}]
+      end
+
+      test "is zippable on failure" do
+        Process.flag(:trap_exit, true)
+        task = 1..4 |> Task.async_stream(&exit/1, @opts) |> Stream.map(&elem(&1, 1))
+        assert Enum.zip(task, task) == [{1, 1}, {2, 2}, {3, 3}, {4, 4}]
+      end
+
+      test "is zippable with slowest first" do
+        task = 4..1//-1 |> Task.async_stream(&sleep/1, @opts) |> Stream.map(&elem(&1, 1))
+        assert Enum.zip(task, task) == [{4, 4}, {3, 3}, {2, 2}, {1, 1}]
+      end
+
+      test "with inner halt on success" do
+        assert 1..8
+               |> Stream.take(4)
+               |> Task.async_stream(&sleep/1, @opts)
+               |> Enum.to_list() == [ok: 1, ok: 2, ok: 3, ok: 4]
+      end
+
+      test "with inner halt on failure" do
+        Process.flag(:trap_exit, true)
+
+        assert 1..8
+               |> Stream.take(4)
+               |> Task.async_stream(&exit/1, @opts)
+               |> Enum.to_list() == [exit: 1, exit: 2, exit: 3, exit: 4]
+      end
+
+      test "with inner halt and slowest first" do
+        assert 8..1//-1
+               |> Stream.take(4)
+               |> Task.async_stream(&sleep/1, @opts)
+               |> Enum.to_list() == [ok: 8, ok: 7, ok: 6, ok: 5]
+      end
+
+      test "with outer halt on success" do
+        assert 1..8
+               |> Task.async_stream(&sleep/1, @opts)
+               |> Enum.take(4) == [ok: 1, ok: 2, ok: 3, ok: 4]
+      end
+
+      test "with outer halt on failure" do
+        Process.flag(:trap_exit, true)
+
+        assert 1..8
+               |> Task.async_stream(&exit/1, @opts)
+               |> Enum.take(4) == [exit: 1, exit: 2, exit: 3, exit: 4]
+      end
+
+      test "with outer halt and slowest first" do
+        assert 8..1//-1
+               |> Task.async_stream(&sleep/1, @opts)
+               |> Enum.take(4) == [ok: 8, ok: 7, ok: 6, ok: 5]
+      end
+
+      test "terminates inner effect" do
+        stream =
+          1..4
+          |> Task.async_stream(&sleep/1, @opts)
+          |> Stream.transform(fn -> :ok end, fn x, acc -> {[x], acc} end, fn _ ->
+            Process.put(:stream_transform, true)
+          end)
+
+        Process.put(:stream_transform, false)
+        assert Enum.to_list(stream) == [ok: 1, ok: 2, ok: 3, ok: 4]
+        assert Process.get(:stream_transform)
+      end
+
+      test "terminates outer effect" do
+        stream =
+          1..4
+          |> Stream.transform(fn -> :ok end, fn x, acc -> {[x], acc} end, fn _ ->
+            Process.put(:stream_transform, true)
+          end)
+          |> Task.async_stream(&sleep/1, @opts)
+
+        Process.put(:stream_transform, false)
+        assert Enum.to_list(stream) == [ok: 1, ok: 2, ok: 3, ok: 4]
+        assert Process.get(:stream_transform)
+      end
+
+      test "with :on_timeout set to :kill_task" do
+        opts = Keyword.merge(@opts, on_timeout: :kill_task, timeout: 50)
+
+        assert [100, 1, 100, 1]
+               |> Task.async_stream(&sleep/1, opts)
+               |> Enum.to_list() == [exit: :timeout, ok: 1, exit: :timeout, ok: 1]
+
+        refute_received _
+      end
+
+      test "with timeout and :zip_input_on_exit set to true" do
+        opts = Keyword.merge(@opts, zip_input_on_exit: true, on_timeout: :kill_task, timeout: 50)
+
+        assert [1, 100]
+               |> Task.async_stream(&sleep/1, opts)
+               |> Enum.to_list() == [ok: 1, exit: {100, :timeout}]
+      end
+
+      test "with outer halt on failure and :zip_input_on_exit" do
+        Process.flag(:trap_exit, true)
+        opts = Keyword.merge(@opts, zip_input_on_exit: true)
+
+        assert 1..8
+               |> Task.async_stream(&exit/1, opts)
+               |> Enum.take(4) == [exit: {1, 1}, exit: {2, 2}, exit: {3, 3}, exit: {4, 4}]
+      end
+    end
   end
 
-  test "find/2" do
-    task = %Task{ref: make_ref}
-    assert Task.find([task], {make_ref, :ok}) == nil
-    assert Task.find([task], {task.ref, :ok}) == {:ok, task}
+  describe "default :logger reporter" do
+    setup do
+      translator = :logger.get_primary_config().filters[:logger_translator]
+      assert :ok = :logger.remove_primary_filter(:logger_translator)
+      on_exit(fn -> :logger.add_primary_filter(:logger_translator, translator) end)
+    end
 
-    assert Task.find([task], {:DOWN, make_ref, :process, self, :kill}) == nil
-    msg = {:DOWN, task.ref, :process, self, :kill}
-    assert catch_exit(Task.find([task], msg)) ==
-           {:kill, {Task, :find, [[task], msg]}}
+    test "logs a terminated task" do
+      parent = self()
+      {:ok, pid} = Task.start_link(__MODULE__, :task, [parent])
+
+      assert ExUnit.CaptureLog.capture_log(fn ->
+               ref = Process.monitor(pid)
+               send(pid, :go)
+               receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+             end) =~ ~r"""
+             \[error\] \*\* Task #{inspect(pid)} terminating
+             \*\* Started from #{inspect(parent)}
+             \*\* When function  == &TaskTest.task/1
+             \*\*      arguments == \[#PID<\d+\.\d+\.\d+>\]
+             \*\* Reason for termination ==\s
+             \*\* {%RuntimeError{message: "oops"},
+             """
+    end
+
+    test "logs a terminated task with a process label" do
+      fun = fn ->
+        Process.set_label({:any, "term"})
+        raise "oops"
+      end
+
+      parent = self()
+      {:ok, pid} = Task.start_link(__MODULE__, :task, [parent, fun])
+
+      assert ExUnit.CaptureLog.capture_log(fn ->
+               ref = Process.monitor(pid)
+               send(pid, :go)
+               receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+             end) =~ ~r"""
+             \[error\] \*\* Task #PID<\d+\.\d+\.\d+> terminating
+             \*\* Process Label == {:any, "term"}
+             \*\* Started from #PID<\d+\.\d+\.\d+>
+             \*\* When function  == &TaskTest.task/2
+             \*\*      arguments == \[#PID<\d+\.\d+\.\d+>,
+              #Function<.+>\]
+             \*\* Reason for termination ==\s
+             \*\* {%RuntimeError{message: "oops"},
+             """
+    end
   end
 
+  def task(parent, fun \\ fn -> raise "oops" end) do
+    mon = Process.monitor(parent)
+    Process.unlink(parent)
+
+    receive do
+      :go ->
+        fun.()
+
+      {:DOWN, ^mon, _, _, _} ->
+        exit(:shutdown)
+    end
+  end
 end
diff --git a/lib/elixir/test/elixir/test_helper.exs b/lib/elixir/test/elixir/test_helper.exs
index 6edf43dd100..2ce3cd85236 100644
--- a/lib/elixir/test/elixir/test_helper.exs
+++ b/lib/elixir/test/elixir/test_helper.exs
@@ -1,4 +1,6 @@
-ExUnit.start [trace: "--trace" in System.argv]
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
 # Beam files compiled on demand
 path = Path.expand("../../tmp/beams", __DIR__)
@@ -6,7 +8,8 @@ File.rm_rf!(path)
 File.mkdir_p!(path)
 Code.prepend_path(path)
 
-Code.compiler_options debug_info: true
+Application.put_env(:elixir, :ansi_enabled, true)
+Code.compiler_options(debug_info: true, infer_signatures: [:elixir])
 
 defmodule PathHelpers do
   def fixture_path() do
@@ -18,88 +21,131 @@ defmodule PathHelpers do
   end
 
   def fixture_path(extra) do
-    Path.join(fixture_path, extra)
+    Path.join(fixture_path(), extra)
   end
 
   def tmp_path(extra) do
-    Path.join(tmp_path, extra)
+    Path.join(tmp_path(), extra)
   end
 
-  def elixir(args) do
-    runcmd(elixir_executable, args)
+  def elixir(args, executable_extension \\ "") do
+    run_cmd(elixir_executable(executable_extension), args)
   end
 
-  def elixir_executable do
-    executable_path("elixir")
+  def elixir_executable(extension \\ "") do
+    executable_path("elixir", extension)
   end
 
-  def elixirc(args) do
-    runcmd(elixirc_executable, args)
+  def elixirc(args, executable_extension \\ "") do
+    run_cmd(elixirc_executable(executable_extension), args)
   end
 
-  def elixirc_executable do
-    executable_path("elixirc")
+  def elixirc_executable(extension \\ "") do
+    executable_path("elixirc", extension)
+  end
+
+  def iex(args, executable_extension \\ "") do
+    run_cmd(iex_executable(executable_extension), args)
+  end
+
+  def iex_executable(extension \\ "") do
+    executable_path("iex", extension)
   end
 
   def write_beam({:module, name, bin, _} = res) do
     File.mkdir_p!(unquote(path))
     beam_path = Path.join(unquote(path), Atom.to_string(name) <> ".beam")
     File.write!(beam_path, bin)
+
+    :code.purge(name)
+    :code.delete(name)
+
     res
   end
 
-  defp runcmd(executable,args) do
-    :os.cmd :binary.bin_to_list("#{executable} #{IO.chardata_to_string(args)}#{redirect_std_err_on_win}")
+  defp run_cmd(executable, args) do
+    ~c"#{executable} #{IO.chardata_to_string(args)}#{redirect_std_err_on_win()}"
+    |> :os.cmd()
+    |> :unicode.characters_to_binary()
   end
 
-  defp executable_path(name) do
-    Path.expand("../../../../bin/#{name}#{executable_extension}", __DIR__)
+  defp executable_path(name, extension) do
+    Path.expand("../../../../bin/#{name}#{extension}", __DIR__)
   end
 
-  if match? {:win32, _}, :os.type do
-    def is_win?, do: true
+  if match?({:win32, _}, :os.type()) do
+    def windows?, do: true
     def executable_extension, do: ".bat"
     def redirect_std_err_on_win, do: " 2>&1"
   else
-    def is_win?, do: false
+    def windows?, do: false
     def executable_extension, do: ""
     def redirect_std_err_on_win, do: ""
   end
 end
 
-defmodule CompileAssertion do
-  import ExUnit.Assertions
-
-  def assert_compile_fail(exception, string) do
-    case format_rescue(string) do
-      {^exception, _} -> :ok
-      error ->
-        raise ExUnit.AssertionError,
-          left: inspect(elem(error, 0)),
-          right: inspect(exception),
-          message: "Expected match"
+defmodule CodeFormatterHelpers do
+  defmacro assert_same(good, opts \\ []) do
+    quote bind_quoted: [good: good, opts: opts] do
+      assert IO.iodata_to_binary(Code.format_string!(good, opts)) == String.trim(good)
     end
   end
 
-  def assert_compile_fail(exception, message, string) do
-    case format_rescue(string) do
-      {^exception, ^message} -> :ok
-      error ->
-        raise ExUnit.AssertionError,
-          left: "#{inspect elem(error, 0)}[message: #{inspect elem(error, 1)}]",
-          right: "#{inspect exception}[message: #{inspect message}]",
-          message: "Expected match"
+  defmacro assert_format(bad, good, opts \\ []) do
+    quote bind_quoted: [bad: bad, good: good, opts: opts] do
+      result = String.trim(good)
+      assert IO.iodata_to_binary(Code.format_string!(bad, opts)) == result
+      assert IO.iodata_to_binary(Code.format_string!(good, opts)) == result
     end
   end
+end
 
-  defp format_rescue(expr) do
-    result = try do
-      :elixir.eval(to_char_list(expr), [])
-      nil
-    rescue
-      error -> {error.__struct__, Exception.message(error)}
-    end
+epmd_exclude = if match?({:win32, _}, :os.type()), do: [epmd: true], else: []
+os_exclude = if PathHelpers.windows?(), do: [unix: true], else: [windows: true]
+
+{line_exclude, line_include} =
+  if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
 
-    result || flunk(message: "Expected expression to fail")
+distributed_exclude =
+  if Code.ensure_loaded?(:peer) and Node.alive?() do
+    {:ok, _pid, node} = :peer.start(%{name: :secondary})
+    true = :erpc.call(node, :code, :set_path, [:code.get_path()])
+    {:ok, _} = :erpc.call(node, :application, :ensure_all_started, [:elixir])
+    []
+  else
+    [distributed: true]
   end
-end
+
+source_exclude =
+  if :deterministic in :compile.env_compiler_options() do
+    [:requires_source]
+  else
+    []
+  end
+
+Code.require_file("../../scripts/cover_record.exs", __DIR__)
+
+cover_exclude =
+  if CoverageRecorder.maybe_record("elixir") do
+    [:require_ast]
+  else
+    []
+  end
+
+# OTP 28.1+
+re_import_exclude =
+  if Code.ensure_loaded?(:re) and function_exported?(:re, :import, 1) do
+    []
+  else
+    [:re_import]
+  end
+
+ExUnit.start(
+  trace: !!System.get_env("TRACE"),
+  exclude:
+    epmd_exclude ++
+      os_exclude ++
+      line_exclude ++ distributed_exclude ++ source_exclude ++ cover_exclude ++ re_import_exclude,
+  include: line_include,
+  assert_receive_timeout: String.to_integer(System.get_env("ELIXIR_ASSERT_TIMEOUT", "300"))
+)
diff --git a/lib/elixir/test/elixir/tuple_test.exs b/lib/elixir/test/elixir/tuple_test.exs
index 54af5e603b6..dea4d965f6f 100644
--- a/lib/elixir/test/elixir/tuple_test.exs
+++ b/lib/elixir/test/elixir/tuple_test.exs
@@ -1,35 +1,43 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule TupleTest do
   use ExUnit.Case, async: true
 
-  test :elem do
+  doctest Tuple
+
+  # Tuple-related functions in the Kernel module.
+
+  test "Kernel.elem/2" do
     assert elem({:a, :b, :c}, 1) == :b
   end
 
-  test :put_elem do
+  test "Kernel.put_elem/3" do
     assert put_elem({:a, :b, :c}, 1, :d) == {:a, :d, :c}
   end
 
-  test :keywords do
+  test "keyword syntax is supported in tuple literals" do
     assert {1, 2, three: :four} == {1, 2, [three: :four]}
   end
 
-  test :optional_comma do
-    assert {1} == {1,}
-    assert {1, 2, 3} == {1, 2, 3,}
+  test "optional comma is supported in tuple literals" do
+    assert Code.eval_string("{1,}") == {{1}, []}
+    assert Code.eval_string("{1, 2, 3,}") == {{1, 2, 3}, []}
   end
 
-  test :partial_application do
+  test "partial application" do
     assert (&{&1, 2}).(1) == {1, 2}
     assert (&{&1, &2}).(1, 2) == {1, 2}
     assert (&{&2, &1}).(2, 1) == {1, 2}
   end
 
   # Tuple module
-  # We check two variants due to inlining.
+  # We check two variants of each function due to inlining.
 
-  test :duplicate do
+  test "duplicate/2" do
     assert Tuple.duplicate(:foo, 0) == {}
     assert Tuple.duplicate(:foo, 3) == {:foo, :foo, :foo}
 
@@ -38,17 +46,17 @@ defmodule TupleTest do
     assert mod.duplicate(:foo, 3) == {:foo, :foo, :foo}
   end
 
-  test :insert_at do
+  test "insert_at/3" do
     assert Tuple.insert_at({:bar, :baz}, 0, :foo) == {:foo, :bar, :baz}
 
     mod = Tuple
     assert mod.insert_at({:bar, :baz}, 0, :foo) == {:foo, :bar, :baz}
   end
 
-  test :delete_at do
+  test "delete_at/2" do
     assert Tuple.delete_at({:foo, :bar, :baz}, 0) == {:bar, :baz}
 
     mod = Tuple
     assert mod.delete_at({:foo, :bar, :baz}, 0) == {:bar, :baz}
   end
-end
\ No newline at end of file
+end
diff --git a/lib/elixir/test/elixir/typespec_test.exs b/lib/elixir/test/elixir/typespec_test.exs
new file mode 100644
index 00000000000..ab24ce5e115
--- /dev/null
+++ b/lib/elixir/test/elixir/typespec_test.exs
@@ -0,0 +1,1664 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
+
+# Holds tests for both Kernel.Typespec and Code.Typespec
+defmodule TypespecTest do
+  use ExUnit.Case, async: true
+  alias TypespecTest.TypespecSample
+
+  defstruct [:hello]
+
+  defmacrop test_module(do: block) do
+    quote do
+      {:module, _, bytecode, _} =
+        defmodule TypespecSample do
+          unquote(block)
+        end
+
+      :code.purge(TypespecSample)
+      :code.delete(TypespecSample)
+      bytecode
+    end
+  end
+
+  defp types(bytecode) do
+    bytecode
+    |> Code.Typespec.fetch_types()
+    |> elem(1)
+    |> Enum.sort()
+  end
+
+  @skip_specs [__info__: 1]
+
+  defp specs(bytecode) do
+    bytecode
+    |> Code.Typespec.fetch_specs()
+    |> elem(1)
+    |> Enum.reject(fn {sign, _} -> sign in @skip_specs end)
+    |> Enum.sort()
+  end
+
+  defp callbacks(bytecode) do
+    bytecode
+    |> Code.Typespec.fetch_callbacks()
+    |> elem(1)
+    |> Enum.sort()
+  end
+
+  describe "Kernel.Typespec errors" do
+    test "invalid type specification" do
+      assert_raise Kernel.TypespecError, ~r"invalid type specification: my_type = 1", fn ->
+        test_module do
+          @type my_type = 1
+        end
+      end
+    end
+
+    test "unexpected expression in typespec" do
+      assert_raise Kernel.TypespecError, ~r"unexpected expression in typespec: \"foobar\"", fn ->
+        test_module do
+          @type my_type :: "foobar"
+        end
+      end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"unexpected expression in typespec: integer\(\)\(\)",
+                   fn ->
+                     test_module do
+                       @type my_type :: integer()()
+                     end
+                   end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"unexpected expression in typespec: %URI\.t\(\)\{\}",
+                   fn ->
+                     test_module do
+                       @type my_type :: %URI.t(){}
+                     end
+                   end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"unexpected expression in typespec: t\.Foo",
+                   fn ->
+                     test_module do
+                       @type my_type :: t.Foo
+                     end
+                   end
+    end
+
+    test "invalid function specification" do
+      assert_raise Kernel.TypespecError, ~r"invalid type specification: \"not a spec\"", fn ->
+        test_module do
+          @spec "not a spec"
+        end
+      end
+
+      assert_raise Kernel.TypespecError, ~r"invalid type specification: 1 :: 2", fn ->
+        test_module do
+          @spec 1 :: 2
+        end
+      end
+    end
+
+    test "undefined type" do
+      assert_raise Kernel.TypespecError, ~r"type foo/0 undefined", fn ->
+        test_module do
+          @type omg :: foo
+        end
+      end
+
+      assert_raise Kernel.TypespecError, ~r"type foo/2 undefined", fn ->
+        test_module do
+          @type omg :: foo(atom, integer)
+        end
+      end
+
+      assert_raise Kernel.TypespecError, ~r"type bar/0 undefined", fn ->
+        test_module do
+          @spec foo(bar, integer) :: {atom, integer}
+          def foo(var1, var2), do: {var1, var2}
+        end
+      end
+
+      assert_raise Kernel.TypespecError, ~r"type foo/0 undefined", fn ->
+        test_module do
+          @type omg :: __MODULE__.foo()
+        end
+      end
+    end
+
+    test "redefined type" do
+      assert_raise Kernel.TypespecError,
+                   ~r"type foo/0 is already defined in .*test/elixir/typespec_test.exs:138",
+                   fn ->
+                     test_module do
+                       @type foo :: atom
+                       @type foo :: integer
+                     end
+                   end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"type foo/2 is already defined in .*test/elixir/typespec_test.exs:148",
+                   fn ->
+                     test_module do
+                       @type foo :: atom
+                       @type foo(var1, var2) :: {var1, var2}
+                       @type foo(x, y) :: {x, y}
+                     end
+                   end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"type foo/0 is already defined in .*test/elixir/typespec_test.exs:157",
+                   fn ->
+                     test_module do
+                       @type foo :: atom
+                       @typep foo :: integer
+                     end
+                   end
+    end
+
+    test "type variable unused (singleton type variable)" do
+      assert_raise Kernel.TypespecError, ~r"type variable x is used only once", fn ->
+        test_module do
+          @type foo(x) :: integer
+        end
+      end
+    end
+
+    test "type variable starting with underscore" do
+      test_module do
+        assert @type(foo(_hello) :: integer) == :ok
+      end
+    end
+
+    test "type variable named _" do
+      assert_raise Kernel.TypespecError, ~r"type variable '_' is invalid", fn ->
+        test_module do
+          @type foo(_) :: integer
+        end
+      end
+
+      assert_raise Kernel.TypespecError, ~r"type variable '_' is invalid", fn ->
+        test_module do
+          @type foo(_, _) :: integer
+        end
+      end
+    end
+
+    test "spec for undefined function" do
+      assert_compile_error(~r"spec for undefined function omg/0", fn ->
+        test_module do
+          @spec omg :: atom
+        end
+      end)
+    end
+
+    test "spec variable used only once (singleton type variable)" do
+      assert_raise Kernel.TypespecError, ~r"type variable x is used only once", fn ->
+        test_module do
+          @spec foo(x, integer) :: integer when x: var
+          def foo(x, y), do: x + y
+        end
+      end
+    end
+
+    test "spec with ... outside of fn and lists" do
+      assert_raise Kernel.TypespecError, ~r"... in typespecs is only allowed inside lists", fn ->
+        test_module do
+          @spec foo(...) :: :ok
+          def foo(x), do: x
+        end
+      end
+    end
+
+    test "invalid optional callback" do
+      assert_compile_error(~r"invalid optional callback :foo", fn ->
+        test_module do
+          @optional_callbacks :foo
+        end
+      end)
+    end
+
+    test "unknown optional callback" do
+      assert_compile_error(~r"unknown callback foo/1 given as optional callback", fn ->
+        test_module do
+          @optional_callbacks foo: 1
+        end
+      end)
+    end
+
+    test "repeated optional callback" do
+      message = ~r"foo/1 has been specified as optional callback more than once"
+
+      assert_compile_error(message, fn ->
+        test_module do
+          @callback foo(:ok) :: :ok
+          @optional_callbacks foo: 1, foo: 1
+        end
+      end)
+    end
+
+    test "behaviour_info/1 explicitly defined alongside @callback/@macrocallback" do
+      message = ~r"cannot define @callback attribute for foo/1 when behaviour_info/1"
+
+      assert_compile_error(message, fn ->
+        test_module do
+          @callback foo(:ok) :: :ok
+          def behaviour_info(_), do: []
+        end
+      end)
+
+      message = ~r"cannot define @macrocallback attribute for foo/1 when behaviour_info/1"
+
+      assert_compile_error(message, fn ->
+        test_module do
+          @macrocallback foo(:ok) :: :ok
+          def behaviour_info(_), do: []
+        end
+      end)
+    end
+
+    test "default is not supported" do
+      assert_raise ArgumentError, fn ->
+        test_module do
+          @callback hello(num \\ 0 :: integer) :: integer
+        end
+      end
+
+      assert_raise ArgumentError, fn ->
+        test_module do
+          @callback hello(num :: integer \\ 0) :: integer
+        end
+      end
+
+      assert_raise ArgumentError, fn ->
+        test_module do
+          @macrocallback hello(num \\ 0 :: integer) :: Macro.t()
+        end
+      end
+
+      assert_raise ArgumentError, fn ->
+        test_module do
+          @macrocallback hello(num :: integer \\ 0) :: Macro.t()
+        end
+      end
+
+      assert_raise ArgumentError, fn ->
+        test_module do
+          @spec hello(num \\ 0 :: integer) :: integer
+        end
+      end
+
+      assert_raise ArgumentError, fn ->
+        test_module do
+          @spec hello(num :: integer \\ 0) :: integer
+        end
+      end
+    end
+
+    test "@spec shows readable error message when return type is missing" do
+      message = ~r"type specification missing return type: my_fun\(integer\)"
+
+      assert_raise Kernel.TypespecError, message, fn ->
+        test_module do
+          @spec my_fun(integer)
+        end
+      end
+    end
+  end
+
+  describe "Kernel.Typespec definitions" do
+    test "typespec declarations return :ok" do
+      test_module do
+        def foo(), do: nil
+
+        assert @type(foo :: any()) == :ok
+        assert @typep(foop :: any()) == :ok
+        assert @spec(foo() :: nil) == :ok
+        assert @opaque(my_type :: atom) == :ok
+        assert @callback(foo(foop) :: integer) == :ok
+        assert @macrocallback(foo(integer) :: integer) == :ok
+      end
+    end
+
+    test "@type with a single type" do
+      bytecode =
+        test_module do
+          @type my_type :: term
+        end
+
+      assert [type: {:my_type, {:type, _, :term, []}, []}] = types(bytecode)
+    end
+
+    test "@type with an atom/alias" do
+      bytecode =
+        test_module do
+          @type foo :: :foo
+          @type bar :: Bar
+        end
+
+      assert [
+               type: {:bar, {:atom, _, Bar}, []},
+               type: {:foo, {:atom, _, :foo}, []}
+             ] = types(bytecode)
+    end
+
+    test "@type with an integer" do
+      bytecode =
+        test_module do
+          @type pos :: 10
+          @type neg :: -10
+        end
+
+      assert [
+               type: {:neg, {:op, _, :-, {:integer, _, 10}}, []},
+               type: {:pos, {:integer, _, 10}, []}
+             ] = types(bytecode)
+    end
+
+    test "@type with a tuple" do
+      bytecode =
+        test_module do
+          @type tup :: tuple()
+          @type one :: {123}
+        end
+
+      assert [
+               type: {:one, {:type, _, :tuple, [{:integer, _, 123}]}, []},
+               type: {:tup, {:type, _, :tuple, :any}, []}
+             ] = types(bytecode)
+    end
+
+    test "@type with a remote type" do
+      bytecode =
+        test_module do
+          @type my_type :: Remote.Some.type()
+          @type my_type_arg :: Remote.type(integer)
+        end
+
+      assert [type: my_type, type: my_type_arg] = types(bytecode)
+
+      assert {:my_type, type, []} = my_type
+      assert {:remote_type, _, [{:atom, _, Remote.Some}, {:atom, _, :type}, []]} = type
+
+      assert {:my_type_arg, type, []} = my_type_arg
+      assert {:remote_type, _, args} = type
+      assert [{:atom, _, Remote}, {:atom, _, :type}, [{:type, _, :integer, []}]] = args
+    end
+
+    test "@type with a binary" do
+      bytecode =
+        test_module do
+          @type bin :: binary
+          @type empty :: <<>>
+          @type size :: <<_::3>>
+          @type unit :: <<_::_*8>>
+          @type size_and_unit :: <<_::3, _::_*8>>
+          @type size_prod_unit :: <<_::3*8>>
+        end
+
+      assert [
+               type: {:bin, {:type, _, :binary, []}, []},
+               type: {:empty, {:type, _, :binary, [{:integer, _, 0}, {:integer, _, 0}]}, []},
+               type: {:size, {:type, _, :binary, [{:integer, _, 3}, {:integer, _, 0}]}, []},
+               type:
+                 {:size_and_unit, {:type, _, :binary, [{:integer, _, 3}, {:integer, _, 8}]}, []},
+               type:
+                 {:size_prod_unit,
+                  {:type, _, :binary,
+                   [{:op, _, :*, {:integer, _, 3}, {:integer, _, 8}}, {:integer, _, 0}]}, []},
+               type: {:unit, {:type, _, :binary, [{:integer, _, 0}, {:integer, _, 8}]}, []}
+             ] = types(bytecode)
+    end
+
+    test "@type with invalid binary spec" do
+      assert_raise Kernel.TypespecError, ~r"invalid binary specification", fn ->
+        test_module do
+          @type my_type :: <<_::atom()>>
+        end
+      end
+
+      assert_raise Kernel.TypespecError, ~r"invalid binary specification", fn ->
+        test_module do
+          @type my_type :: <<_::integer>>
+        end
+      end
+
+      assert_raise Kernel.TypespecError, ~r"invalid binary specification", fn ->
+        test_module do
+          @type my_type :: <<_::(-4)>>
+        end
+      end
+
+      assert_raise Kernel.TypespecError, ~r"invalid binary specification", fn ->
+        test_module do
+          @type my_type :: <<_::3, _::_*atom>>
+        end
+      end
+
+      assert_raise Kernel.TypespecError, ~r"invalid binary specification", fn ->
+        test_module do
+          @type my_type :: <<_::3, _::_*(-8)>>
+        end
+      end
+
+      assert_raise Kernel.TypespecError, ~r"invalid binary specification", fn ->
+        test_module do
+          @type my_type :: <<_::3, _::_*257>>
+        end
+      end
+    end
+
+    test "@type with a range op" do
+      bytecode =
+        test_module do
+          @type range1 :: 1..10
+          @type range2 :: -1..1
+        end
+
+      assert [
+               {:type, {:range1, {:type, _, :range, range1_args}, []}},
+               {:type, {:range2, {:type, _, :range, range2_args}, []}}
+             ] = types(bytecode)
+
+      assert [{:integer, _, 1}, {:integer, _, 10}] = range1_args
+      assert [{:op, _, :-, {:integer, _, 1}}, {:integer, _, 1}] = range2_args
+    end
+
+    test "@type with invalid range" do
+      assert_raise Kernel.TypespecError, ~r"invalid range specification", fn ->
+        test_module do
+          @type my_type :: atom..10
+        end
+      end
+    end
+
+    test "@type with a keyword map" do
+      bytecode =
+        test_module do
+          @type my_type :: %{hello: :world}
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :map, [arg]} = type
+      assert {:type, _, :map_field_exact, [{:atom, _, :hello}, {:atom, _, :world}]} = arg
+    end
+
+    test "@type with a map" do
+      bytecode =
+        test_module do
+          @type my_type :: %{required(:a) => :b, optional(:c) => :d}
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :map, [arg1, arg2]} = type
+      assert {:type, _, :map_field_exact, [{:atom, _, :a}, {:atom, _, :b}]} = arg1
+      assert {:type, _, :map_field_assoc, [{:atom, _, :c}, {:atom, _, :d}]} = arg2
+    end
+
+    test "@type with a struct" do
+      bytecode =
+        test_module do
+          defstruct hello: nil, other: nil
+          @type my_type :: %TypespecSample{hello: :world}
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :map, [struct, arg1, arg2]} = type
+      assert {:type, _, :map_field_exact, struct_args} = struct
+      assert [{:atom, _, :__struct__}, {:atom, _, TypespecSample}] = struct_args
+      assert {:type, _, :map_field_exact, [{:atom, _, :hello}, {:atom, _, :world}]} = arg1
+      assert {:type, _, :map_field_exact, [{:atom, _, :other}, {:type, _, :term, []}]} = arg2
+    end
+
+    test "@type with an exception struct" do
+      bytecode =
+        test_module do
+          defexception [:message]
+          @type my_type :: %TypespecSample{}
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :map, [struct, arg1, arg2]} = type
+      assert {:type, _, :map_field_exact, struct_args} = struct
+      assert [{:atom, _, :__struct__}, {:atom, _, TypespecSample}] = struct_args
+      assert {:type, _, :map_field_exact, [{:atom, _, :__exception__}, {:atom, _, true}]} = arg1
+      assert {:type, _, :map_field_exact, [{:atom, _, :message}, {:type, _, :term, []}]} = arg2
+    end
+
+    @fields Enum.map(10..42, &{:"f#{&1}", :ok})
+
+    test "@type with a large struct" do
+      bytecode =
+        test_module do
+          defstruct unquote(@fields)
+          @type my_type :: %TypespecSample{unquote_splicing(@fields)}
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :map, [struct, arg1, arg2 | _]} = type
+      assert {:type, _, :map_field_exact, struct_args} = struct
+      assert [{:atom, _, :__struct__}, {:atom, _, TypespecSample}] = struct_args
+      assert {:type, _, :map_field_exact, [{:atom, _, :f10}, {:atom, _, :ok}]} = arg1
+      assert {:type, _, :map_field_exact, [{:atom, _, :f11}, {:atom, _, :ok}]} = arg2
+    end
+
+    test "@type with struct does not @enforce_keys" do
+      bytecode =
+        test_module do
+          @enforce_keys [:other]
+          defstruct hello: nil, other: nil
+          @type my_type :: %TypespecSample{hello: :world}
+        end
+
+      assert [type: {:my_type, _type, []}] = types(bytecode)
+    end
+
+    test "@type with undefined struct" do
+      assert_raise ArgumentError, ~r"ThisModuleDoesNotExist.__struct__/1 is undefined", fn ->
+        test_module do
+          @type my_type :: %ThisModuleDoesNotExist{}
+        end
+      end
+
+      assert_raise ArgumentError, ~r"cannot access struct TypespecTest.TypespecSample", fn ->
+        test_module do
+          @type my_type :: %TypespecSample{}
+        end
+      end
+    end
+
+    test "@type with a struct with undefined field" do
+      assert_raise Kernel.TypespecError,
+                   ~r"undefined field :no_field on struct TypespecTest.TypespecSample",
+                   fn ->
+                     test_module do
+                       defstruct [:hello, :eric]
+                       @type my_type :: %TypespecSample{no_field: :world}
+                     end
+                   end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"undefined field :no_field on struct TypespecTest.TypespecSample",
+                   fn ->
+                     test_module do
+                       defstruct [:hello, :eric]
+                       @type my_type :: %__MODULE__{no_field: :world}
+                     end
+                   end
+    end
+
+    test "@type when overriding Elixir built-in" do
+      assert_raise Kernel.TypespecError, ~r"type struct/0 is a built-in type", fn ->
+        test_module do
+          @type struct :: :oops
+        end
+      end
+    end
+
+    test "@type when overriding Erlang built-in" do
+      assert_raise Kernel.TypespecError, ~r"type list/0 is a built-in type", fn ->
+        test_module do
+          @type list :: :oops
+        end
+      end
+    end
+
+    test "@type with public record" do
+      bytecode =
+        test_module do
+          require Record
+          Record.defrecord(:timestamp, date: 1, time: 2)
+          @type my_type :: record(:timestamp, time: :foo)
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :tuple, [timestamp, term, foo]} = type
+      assert {:atom, 0, :timestamp} = timestamp
+      assert {:ann_type, 0, [{:var, 0, :date}, {:type, 0, :term, []}]} = term
+      assert {:ann_type, 0, [{:var, 0, :time}, {:atom, 0, :foo}]} = foo
+    end
+
+    test "@type with private record" do
+      bytecode =
+        test_module do
+          require Record
+          Record.defrecordp(:timestamp, date: 1, time: 2)
+          @type my_type :: record(:timestamp, time: :foo)
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :tuple, args} = type
+
+      assert [
+               {:atom, 0, :timestamp},
+               {:ann_type, 0, [{:var, 0, :date}, {:type, 0, :term, []}]},
+               {:ann_type, 0, [{:var, 0, :time}, {:atom, 0, :foo}]}
+             ] = args
+    end
+
+    test "@type with named record" do
+      bytecode =
+        test_module do
+          require Record
+          Record.defrecord(:timestamp, :my_timestamp, date: 1, time: 2)
+          @type my_type :: record(:timestamp, time: :foo)
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :tuple, [my_timestamp, term, _foo]} = type
+      assert {:atom, 0, :my_timestamp} = my_timestamp
+      assert {:ann_type, 0, [{:var, 0, :date}, {:type, 0, :term, []}]} = term
+      assert {:ann_type, 0, [{:var, 0, :time}, {:atom, 0, :foo}]}
+    end
+
+    test "@type with undefined record" do
+      assert_raise Kernel.TypespecError, ~r"unknown record :this_record_does_not_exist", fn ->
+        test_module do
+          @type my_type :: record(:this_record_does_not_exist, [])
+        end
+      end
+    end
+
+    test "@type with a record with undefined field" do
+      assert_raise Kernel.TypespecError, ~r"undefined field no_field on record :timestamp", fn ->
+        test_module do
+          require Record
+          Record.defrecord(:timestamp, date: 1, time: 2)
+          @type my_type :: record(:timestamp, no_field: :foo)
+        end
+      end
+    end
+
+    test "@type with a record which declares the name as the type `atom` rather than an atom literal" do
+      assert_raise Kernel.TypespecError, ~r"expected the record name to be an atom literal", fn ->
+        test_module do
+          @type my_type :: record(atom, field: :foo)
+        end
+      end
+    end
+
+    test "@type can be named record" do
+      bytecode =
+        test_module do
+          @type record :: binary
+          @spec foo?(record) :: boolean
+          def foo?(_), do: true
+        end
+
+      assert [type: {:record, {:type, _, :binary, []}, []}] = types(bytecode)
+    end
+
+    test "@type with an invalid map notation" do
+      assert_raise Kernel.TypespecError, ~r"invalid map specification", fn ->
+        test_module do
+          @type content :: %{atom | String.t() => term}
+        end
+      end
+    end
+
+    test "@type with list shortcuts" do
+      bytecode =
+        test_module do
+          @type my_type :: []
+          @type my_type1 :: [integer]
+          @type my_type2 :: [integer, ...]
+        end
+
+      assert [
+               type: {:my_type, {:type, _, nil, []}, []},
+               type: {:my_type1, {:type, _, :list, [{:type, _, :integer, []}]}, []},
+               type: {:my_type2, {:type, _, :nonempty_list, [{:type, _, :integer, []}]}, []}
+             ] = types(bytecode)
+    end
+
+    test "@type with a fun" do
+      bytecode =
+        test_module do
+          @type my_type :: (... -> any)
+        end
+
+      assert [type: {:my_type, {:type, _, :fun, [{:type, _, :any}, {:type, _, :any, []}]}, []}] =
+               types(bytecode)
+    end
+
+    test "@type with a fun with multiple arguments and return type" do
+      bytecode =
+        test_module do
+          @type my_type :: (integer, integer -> integer)
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :fun, [args, return_type]} = type
+      assert {:type, _, :product, [{:type, _, :integer, []}, {:type, _, :integer, []}]} = args
+      assert {:type, _, :integer, []} = return_type
+    end
+
+    test "@type with a fun with no arguments and return type" do
+      bytecode =
+        test_module do
+          @type my_type :: (-> integer)
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :fun, [{:type, _, :product, []}, {:type, _, :integer, []}]} = type
+    end
+
+    test "@type with a fun with any arity and return type" do
+      bytecode =
+        test_module do
+          @type my_type :: (... -> integer)
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :fun, [{:type, _, :any}, {:type, _, :integer, []}]} = type
+    end
+
+    test "@type with a union" do
+      bytecode =
+        test_module do
+          @type my_type :: integer | charlist | atom
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :union, [integer, charlist, atom]} = type
+      assert {:type, _, :integer, []} = integer
+      assert {:remote_type, _, [{:atom, _, :elixir}, {:atom, _, :charlist}, []]} = charlist
+      assert {:type, _, :atom, []} = atom
+    end
+
+    test "@type with keywords" do
+      bytecode =
+        test_module do
+          @type my_type :: [first: integer, step: integer, last: integer]
+        end
+
+      assert [type: {:my_type, type, []}] = types(bytecode)
+      assert {:type, _, :list, [{:type, _, :union, union_types}]} = type
+
+      assert [
+               {:type, _, :tuple, [{:atom, _, :first}, {:type, _, :integer, []}]},
+               {:type, _, :tuple, [{:atom, _, :step}, {:type, _, :integer, []}]},
+               {:type, _, :tuple, [{:atom, _, :last}, {:type, _, :integer, []}]}
+             ] = union_types
+    end
+
+    test "@type with parameters" do
+      bytecode =
+        test_module do
+          @type my_type(x) :: x
+          @type my_type1(x) :: list(x)
+          @type my_type2(x, y) :: {x, y}
+        end
+
+      assert [
+               type: {:my_type, {:var, _, :x}, [{:var, _, :x}]},
+               type: {:my_type1, {:type, _, :list, [{:var, _, :x}]}, [{:var, _, :x}]},
+               type: {:my_type2, my_type2, [{:var, _, :x}, {:var, _, :y}]}
+             ] = types(bytecode)
+
+      assert {:type, _, :tuple, [{:var, _, :x}, {:var, _, :y}]} = my_type2
+    end
+
+    test "@type with annotations" do
+      bytecode =
+        test_module do
+          @type my_type :: named :: integer
+          @type my_type1 :: (a :: integer -> integer)
+        end
+
+      assert [type: {:my_type, my_type, []}, type: {:my_type1, my_type1, []}] = types(bytecode)
+
+      assert {:ann_type, _, [{:var, _, :named}, {:type, _, :integer, []}]} = my_type
+
+      assert {:type, _, :fun, [fun_args, fun_return]} = my_type1
+      assert {:type, _, :product, [{:ann_type, _, [a, {:type, _, :integer, []}]}]} = fun_args
+      assert {:var, _, :a} = a
+      assert {:type, _, :integer, []} = fun_return
+    end
+
+    test "@type unquote fragment" do
+      quoted =
+        quote unquote: false do
+          name = :my_type
+          type = :foo
+          @type unquote(name)() :: unquote(type)
+        end
+
+      bytecode =
+        test_module do
+          Code.eval_quoted(quoted, [], module: __MODULE__)
+        end
+
+      assert [type: {:my_type, {:atom, _, :foo}, []}] = types(bytecode)
+    end
+
+    test "@type with module attributes" do
+      bytecode =
+        test_module do
+          @keyword Keyword
+          @type kw :: @keyword.t
+          @type kw(value) :: @keyword.t(value)
+        end
+
+      assert [type: {:kw, kw, _}, type: {:kw, kw_with_value, [{:var, _, :value}]}] =
+               types(bytecode)
+
+      assert {:remote_type, _, [{:atom, _, Keyword}, {:atom, _, :t}, []]} = kw
+      assert {:remote_type, _, kw_with_value_args} = kw_with_value
+      assert [{:atom, _, Keyword}, {:atom, _, :t}, [{:var, _, :value}]] = kw_with_value_args
+    end
+
+    test "@type with macro in alias" do
+      bytecode =
+        test_module do
+          defmacro module() do
+            quote do: __MODULE__
+          end
+
+          @type my_type :: module().Foo
+        end
+
+      assert [type: {:my_type, {:atom, _, TypespecTest.TypespecSample.Foo}, []}] = types(bytecode)
+    end
+
+    test "@type with a reserved signature" do
+      assert_raise Kernel.TypespecError,
+                   ~r"type required\/1 is a reserved type and it cannot be defined",
+                   fn ->
+                     test_module do
+                       @type required(arg) :: any()
+                     end
+                   end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"type optional\/1 is a reserved type and it cannot be defined",
+                   fn ->
+                     test_module do
+                       @type optional(arg) :: any()
+                     end
+                   end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"type required\/1 is a reserved type and it cannot be defined",
+                   fn ->
+                     test_module do
+                       @typep required(arg) :: any()
+                     end
+                   end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"type optional\/1 is a reserved type and it cannot be defined",
+                   fn ->
+                     test_module do
+                       @typep optional(arg) :: any()
+                     end
+                   end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"type required\/1 is a reserved type and it cannot be defined",
+                   fn ->
+                     test_module do
+                       @opaque required(arg) :: any()
+                     end
+                   end
+
+      assert_raise Kernel.TypespecError,
+                   ~r"type optional\/1 is a reserved type and it cannot be defined",
+                   fn ->
+                     test_module do
+                       @opaque optional(arg) :: any()
+                     end
+                   end
+    end
+
+    test "invalid remote @type with module attribute that does not evaluate to a module" do
+      assert_raise Kernel.TypespecError, ~r/\(@foo is "bar"\)/, fn ->
+        test_module do
+          @foo "bar"
+          @type t :: @foo.t
+        end
+      end
+    end
+
+    test "defines_type?" do
+      test_module do
+        @type my_type :: tuple
+        @type my_type(a) :: [a]
+        assert Kernel.Typespec.defines_type?(__MODULE__, {:my_type, 0})
+        assert Kernel.Typespec.defines_type?(__MODULE__, {:my_type, 1})
+        refute Kernel.Typespec.defines_type?(__MODULE__, {:my_type, 2})
+      end
+    end
+
+    test "spec_to_callback/2" do
+      bytecode =
+        test_module do
+          @spec foo() :: term()
+          def foo(), do: :ok
+          Kernel.Typespec.spec_to_callback(__MODULE__, {:foo, 0})
+        end
+
+      assert specs(bytecode) == callbacks(bytecode)
+    end
+
+    test "@opaque" do
+      bytecode =
+        test_module do
+          @opaque my_type(x) :: x
+        end
+
+      assert [opaque: {:my_type, {:var, _, :x}, [{:var, _, :x}]}] = types(bytecode)
+    end
+
+    test "@spec" do
+      bytecode =
+        test_module do
+          def my_fun1(x), do: x
+          def my_fun2(), do: :ok
+          def my_fun3(x, y), do: {x, y}
+          def my_fun4(x), do: x
+          @spec my_fun1(integer) :: integer
+          @spec my_fun2() :: integer
+          @spec my_fun3(integer, integer) :: {integer, integer}
+          @spec my_fun4(x :: integer) :: integer
+        end
+
+      assert [my_fun1, my_fun2, my_fun3, my_fun4] = specs(bytecode)
+
+      assert {{:my_fun1, 1}, [{:type, _, :fun, args}]} = my_fun1
+      assert [{:type, _, :product, [{:type, _, :integer, []}]}, {:type, _, :integer, []}] = args
+
+      assert {{:my_fun2, 0}, [{:type, _, :fun, args}]} = my_fun2
+      assert [{:type, _, :product, []}, {:type, _, :integer, []}] = args
+
+      assert {{:my_fun3, 2}, [{:type, _, :fun, [arg1, arg2]}]} = my_fun3
+      assert {:type, _, :product, [{:type, _, :integer, []}, {:type, _, :integer, []}]} = arg1
+      assert {:type, _, :tuple, [{:type, _, :integer, []}, {:type, _, :integer, []}]} = arg2
+
+      assert {{:my_fun4, 1}, [{:type, _, :fun, args}]} = my_fun4
+      assert [x, {:type, _, :integer, []}] = args
+      assert {:type, _, :product, [{:ann_type, _, [{:var, _, :x}, {:type, _, :integer, []}]}]} = x
+    end
+
+    test "@spec with vars matching built-ins" do
+      bytecode =
+        test_module do
+          def my_fun1(x), do: x
+          def my_fun2(x), do: x
+          @spec my_fun1(tuple) :: tuple
+          @spec my_fun2(tuple) :: tuple when tuple: {integer, integer}
+        end
+
+      assert [my_fun1, my_fun2] = specs(bytecode)
+
+      assert {{:my_fun1, 1}, [{:type, _, :fun, args}]} = my_fun1
+      assert [{:type, _, :product, [{:type, _, :tuple, :any}]}, {:type, _, :tuple, :any}] = args
+
+      assert {{:my_fun2, 1}, [{:type, _, :bounded_fun, args}]} = my_fun2
+
+      assert [type, _] = args
+
+      assert {:type, _, :fun, [{:type, _, :product, [{:var, _, :tuple}]}, {:var, _, :tuple}]} =
+               type
+    end
+
+    test "@spec with guards" do
+      bytecode =
+        test_module do
+          def my_fun1(x), do: x
+          @spec my_fun1(x) :: boolean when x: integer
+
+          def my_fun2(x), do: x
+          @spec my_fun2(x) :: x when x: var
+
+          def my_fun3(_x, y), do: y
+          @spec my_fun3(x, y) :: y when y: x, x: var
+        end
+
+      assert [my_fun1, my_fun2, my_fun3] = specs(bytecode)
+
+      assert {{:my_fun1, 1}, [{:type, _, :bounded_fun, args}]} = my_fun1
+      assert [{:type, _, :fun, [product, {:type, _, :boolean, []}]}, constraints] = args
+      assert {:type, _, :product, [{:var, _, :x}]} = product
+      assert [{:type, _, :constraint, subtype}] = constraints
+      assert [{:atom, _, :is_subtype}, [{:var, _, :x}, {:type, _, :integer, []}]] = subtype
+
+      assert {{:my_fun2, 1}, [{:type, _, :fun, args}]} = my_fun2
+      assert [{:type, _, :product, [{:var, _, :x}]}, {:var, _, :x}] = args
+
+      assert {{:my_fun3, 2}, [{:type, _, :bounded_fun, args}]} = my_fun3
+      assert [{:type, _, :fun, fun_type}, [{:type, _, :constraint, constraint_type}]] = args
+      assert [{:type, _, :product, [{:var, _, :x}, {:var, _, :y}]}, {:var, _, :y}] = fun_type
+      assert [{:atom, _, :is_subtype}, [{:var, _, :y}, {:var, _, :x}]] = constraint_type
+    end
+
+    test "@type, @opaque, and @typep as module attributes" do
+      defmodule TypeModuleAttributes do
+        @type type1 :: boolean
+        @opaque opaque1 :: boolean
+        @typep typep1 :: boolean
+
+        def type1, do: @type
+        def opaque1, do: @opaque
+        def typep1, do: @typep
+
+        @type type2 :: atom
+        @type type3 :: pid
+        @opaque opaque2 :: atom
+        @opaque opaque3 :: pid
+        @typep typep2 :: atom
+
+        def type2, do: @type
+        def opaque2, do: @opaque
+        def typep2, do: @typep
+
+        # Avoid unused warnings
+        @spec foo(typep1) :: typep2
+        def foo(_x), do: :ok
+      end
+
+      assert [
+               {:type, {:"::", _, [{:type1, _, _}, {:boolean, _, _}]}, {TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.type1()
+
+      assert [
+               {:type, {:"::", _, [{:type3, _, _}, {:pid, _, _}]}, {TypeModuleAttributes, _}},
+               {:type, {:"::", _, [{:type2, _, _}, {:atom, _, _}]}, {TypeModuleAttributes, _}},
+               {:type, {:"::", _, [{:type1, _, _}, {:boolean, _, _}]}, {TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.type2()
+
+      assert [
+               {:opaque, {:"::", _, [{:opaque1, _, _}, {:boolean, _, _}]},
+                {TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.opaque1()
+
+      assert [
+               {:opaque, {:"::", _, [{:opaque3, _, _}, {:pid, _, _}]}, {TypeModuleAttributes, _}},
+               {:opaque, {:"::", _, [{:opaque2, _, _}, {:atom, _, _}]},
+                {TypeModuleAttributes, _}},
+               {:opaque, {:"::", _, [{:opaque1, _, _}, {:boolean, _, _}]},
+                {TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.opaque2()
+
+      assert [
+               {:typep, {:"::", _, [{:typep1, _, _}, {:boolean, _, _}]},
+                {TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.typep1()
+
+      assert [
+               {:typep, {:"::", _, [{:typep2, _, _}, {:atom, _, _}]}, {TypeModuleAttributes, _}},
+               {:typep, {:"::", _, [{:typep1, _, _}, {:boolean, _, _}]},
+                {TypeModuleAttributes, _}}
+             ] = TypeModuleAttributes.typep2()
+    after
+      :code.purge(TypeModuleAttributes)
+      :code.delete(TypeModuleAttributes)
+    end
+
+    test "@spec, @callback, and @macrocallback as module attributes" do
+      defmodule SpecModuleAttributes do
+        @callback callback1 :: integer
+        @macrocallback macrocallback1 :: integer
+
+        @spec spec1 :: boolean
+        def spec1, do: @spec
+
+        @callback callback2 :: var when var: boolean
+        @macrocallback macrocallback2 :: var when var: boolean
+
+        @spec spec2 :: atom
+        def spec2, do: @spec
+
+        @spec spec3 :: pid
+        def spec3, do: :ok
+        def spec4, do: @spec
+
+        def callback, do: @callback
+        def macrocallback, do: @macrocallback
+      end
+
+      assert [
+               {:spec, {:"::", _, [{:spec1, _, _}, {:boolean, _, _}]}, {SpecModuleAttributes, _}}
+             ] = SpecModuleAttributes.spec1()
+
+      assert [
+               {:spec, {:"::", _, [{:spec2, _, _}, {:atom, _, _}]}, {SpecModuleAttributes, _}},
+               {:spec, {:"::", _, [{:spec1, _, _}, {:boolean, _, _}]}, {SpecModuleAttributes, _}}
+             ] = SpecModuleAttributes.spec2()
+
+      assert [
+               {:spec, {:"::", _, [{:spec3, _, _}, {:pid, _, _}]}, {SpecModuleAttributes, _}},
+               {:spec, {:"::", _, [{:spec2, _, _}, {:atom, _, _}]}, {SpecModuleAttributes, _}},
+               {:spec, {:"::", _, [{:spec1, _, _}, {:boolean, _, _}]}, {SpecModuleAttributes, _}}
+             ] = SpecModuleAttributes.spec4()
+
+      assert [
+               {:callback,
+                {:when, _,
+                 [{:"::", _, [{:callback2, _, _}, {:var, _, _}]}, [var: {:boolean, _, _}]]},
+                {SpecModuleAttributes, _}},
+               {:callback, {:"::", _, [{:callback1, _, _}, {:integer, _, _}]},
+                {SpecModuleAttributes, _}}
+             ] = SpecModuleAttributes.callback()
+
+      assert [
+               {:macrocallback,
+                {:when, _,
+                 [{:"::", _, [{:macrocallback2, _, _}, {:var, _, _}]}, [var: {:boolean, _, _}]]},
+                {SpecModuleAttributes, _}},
+               {:macrocallback, {:"::", _, [{:macrocallback1, _, _}, {:integer, _, _}]},
+                {SpecModuleAttributes, _}}
+             ] = SpecModuleAttributes.macrocallback()
+    after
+      :code.purge(SpecModuleAttributes)
+      :code.delete(SpecModuleAttributes)
+    end
+
+    test "@callback" do
+      bytecode =
+        test_module do
+          @callback my_fun(integer) :: integer
+          @callback my_fun(list) :: list
+          @callback my_fun() :: integer
+          @callback my_fun(integer, integer) :: {integer, integer}
+        end
+
+      assert [my_fun_0, my_fun_1, my_fun_2] = callbacks(bytecode)
+
+      assert {{:my_fun, 0}, [{:type, _, :fun, args}]} = my_fun_0
+      assert [{:type, _, :product, []}, {:type, _, :integer, []}] = args
+
+      assert {{:my_fun, 1}, [clause1, clause2]} = my_fun_1
+      assert {:type, _, :fun, args1} = clause1
+      assert [{:type, _, :product, [{:type, _, :integer, []}]}, {:type, _, :integer, []}] = args1
+      assert {:type, _, :fun, args2} = clause2
+      assert [{:type, _, :product, [{:type, _, :list, []}]}, {:type, _, :list, []}] = args2
+
+      assert {{:my_fun, 2}, [{:type, _, :fun, [args_type, return_type]}]} = my_fun_2
+
+      assert {:type, _, :product, [{:type, _, :integer, []}, {:type, _, :integer, []}]} =
+               args_type
+
+      assert {:type, _, :tuple, [{:type, _, :integer, []}, {:type, _, :integer, []}]} =
+               return_type
+    end
+
+    test "block handling" do
+      bytecode =
+        test_module do
+          @spec foo((-> [integer])) :: integer
+          def foo(_), do: 1
+        end
+
+      assert [{{:foo, 1}, [{:type, _, :fun, [args, return]}]}] = specs(bytecode)
+      assert {:type, _, :product, [{:type, _, :fun, fun_args}]} = args
+      assert [{:type, _, :product, []}, {:type, _, :list, [{:type, _, :integer, []}]}] = fun_args
+      assert {:type, _, :integer, []} = return
+    end
+  end
+
+  describe "Code.Typespec" do
+    test "type_to_quoted" do
+      quoted =
+        Enum.sort([
+          quote(do: @type(tuple(arg) :: {:tuple, arg})),
+          quote(do: @type(with_ann() :: t :: atom())),
+          quote(do: @type(a_tuple() :: tuple())),
+          quote(do: @type(empty_tuple() :: {})),
+          quote(do: @type(one_tuple() :: {:foo})),
+          quote(do: @type(two_tuple() :: {:foo, :bar})),
+          quote(do: @type(custom_tuple() :: tuple(:foo))),
+          quote(do: @type(imm_type_1() :: 1)),
+          quote(do: @type(imm_type_2() :: :foo)),
+          quote(do: @type(simple_type() :: integer())),
+          quote(do: @type(param_type(p) :: [p])),
+          quote(do: @type(union_type() :: integer() | binary() | boolean())),
+          quote(do: @type(binary_type1() :: <<_::_*8>>)),
+          quote(do: @type(binary_type2() :: <<_::3>>)),
+          quote(do: @type(binary_type3() :: <<_::3, _::_*8>>)),
+          quote(do: @type(binary_type4() :: <<_::3*8>>)),
+          quote(do: @type(tuple_type() :: {integer()})),
+          quote(do: @type(ftype() :: (-> any()) | (-> integer()) | (integer() -> integer()))),
+          quote(do: @type(cl() :: charlist())),
+          quote(do: @type(st() :: struct())),
+          quote(do: @type(ab() :: as_boolean(term()))),
+          quote(do: @type(kw() :: keyword())),
+          quote(do: @type(kwt() :: keyword(term()))),
+          quote(do: @type(vaf() :: (... -> any()))),
+          quote(do: @type(rng() :: 1..10)),
+          quote(do: @type(opts() :: [first: integer(), step: integer(), last: integer()])),
+          quote(do: @type(ops() :: {+1, -1})),
+          quote(do: @type(map(arg) :: {:map, arg})),
+          quote(do: @type(a_map() :: map())),
+          quote(do: @type(empty_map() :: %{})),
+          quote(do: @type(my_map() :: %{hello: :world})),
+          quote(do: @type(my_req_map() :: %{required(0) => :foo})),
+          quote(do: @type(my_opt_map() :: %{optional(0) => :foo})),
+          quote(do: @type(my_struct() :: %TypespecTest{hello: :world})),
+          quote(do: @type(custom_map() :: map(:foo))),
+          quote(do: @type(list1() :: list())),
+          quote(do: @type(list2() :: [0])),
+          quote(do: @type(list3() :: [...])),
+          quote(do: @type(list4() :: [0, ...])),
+          quote(do: @type(nil_list() :: []))
+        ])
+
+      bytecode =
+        test_module do
+          Code.eval_quoted(quoted, [], module: __MODULE__)
+        end
+
+      types = types(bytecode)
+
+      Enum.each(Enum.zip(types, quoted), fn {{:type, type}, definition} ->
+        ast = Code.Typespec.type_to_quoted(type)
+        assert Macro.to_string(quote(do: @type(unquote(ast)))) == Macro.to_string(definition)
+      end)
+    end
+
+    test "type_to_quoted for paren_type" do
+      type = {:my_type, {:paren_type, 0, [{:type, 0, :integer, []}]}, []}
+
+      assert Code.Typespec.type_to_quoted(type) ==
+               {:"::", [], [{:my_type, [], []}, {:integer, [line: 0], []}]}
+    end
+
+    test "spec_to_quoted" do
+      quoted =
+        Enum.sort([
+          quote(do: @spec(foo() :: integer())),
+          quote(do: @spec(foo() :: union())),
+          quote(do: @spec(foo() :: union(integer()))),
+          quote(do: @spec(foo() :: truly_union())),
+          quote(do: @spec(foo(union()) :: union())),
+          quote(do: @spec(foo(union(integer())) :: union(integer()))),
+          quote(do: @spec(foo(truly_union()) :: truly_union())),
+          quote(do: @spec(foo(atom()) :: integer() | [{}])),
+          quote(do: @spec(foo(arg) :: integer() when [arg: integer()])),
+          quote(do: @spec(foo(arg) :: arg when [arg: var])),
+          quote(do: @spec(foo(arg :: atom()) :: atom()))
+        ])
+
+      bytecode =
+        test_module do
+          @type union :: any()
+          @type union(t) :: t
+          @type truly_union :: list | map | union
+
+          def foo(), do: 1
+          def foo(arg), do: arg
+          Code.eval_quoted(quote(do: (unquote_splicing(quoted))), [], module: __MODULE__)
+        end
+
+      specs =
+        Enum.flat_map(specs(bytecode), fn {{_, _}, specs} ->
+          Enum.map(specs, fn spec ->
+            quote(do: @spec(unquote(Code.Typespec.spec_to_quoted(:foo, spec))))
+          end)
+        end)
+
+      specs_with_quoted = specs |> Enum.sort() |> Enum.zip(quoted)
+
+      Enum.each(specs_with_quoted, fn {spec, definition} ->
+        assert Macro.to_string(spec) == Macro.to_string(definition)
+      end)
+    end
+
+    test "spec_to_quoted with maps with __struct__ key" do
+      defmodule StructA do
+        defstruct [:key]
+      end
+
+      defmodule StructB do
+        defstruct [:key]
+      end
+
+      bytecode =
+        test_module do
+          @spec single_struct(%StructA{}) :: :ok
+          def single_struct(arg), do: {:ok, arg}
+
+          @spec single_struct_key(%{__struct__: StructA}) :: :ok
+          def single_struct_key(arg), do: {:ok, arg}
+
+          @spec single_struct_key_type(%{__struct__: atom()}) :: :ok
+          def single_struct_key_type(arg), do: {:ok, arg}
+
+          @spec union_struct(%StructA{} | %StructB{}) :: :ok
+          def union_struct(arg), do: {:ok, arg}
+
+          @spec union_struct_key(%{__struct__: StructA | StructB}) :: :ok
+          def union_struct_key(arg), do: {:ok, arg}
+
+          @spec union_struct_key_type(%{__struct__: atom() | StructA | binary()}) :: :ok
+          def union_struct_key_type(arg), do: {:ok, arg}
+        end
+
+      [
+        {{:single_struct, 1}, [ast_single_struct]},
+        {{:single_struct_key, 1}, [ast_single_struct_key]},
+        {{:single_struct_key_type, 1}, [ast_single_struct_key_type]},
+        {{:union_struct, 1}, [ast_union_struct]},
+        {{:union_struct_key, 1}, [ast_union_struct_key]},
+        {{:union_struct_key_type, 1}, [ast_union_struct_key_type]}
+      ] = specs(bytecode)
+
+      assert Code.Typespec.spec_to_quoted(:single_struct, ast_single_struct)
+             |> Macro.to_string() ==
+               "single_struct(%TypespecTest.StructA{key: term()}) :: :ok"
+
+      assert Code.Typespec.spec_to_quoted(:single_struct_key, ast_single_struct_key)
+             |> Macro.to_string() ==
+               "single_struct_key(%TypespecTest.StructA{}) :: :ok"
+
+      assert Code.Typespec.spec_to_quoted(:single_struct_key_type, ast_single_struct_key_type)
+             |> Macro.to_string() ==
+               "single_struct_key_type(%{__struct__: atom()}) :: :ok"
+
+      assert Code.Typespec.spec_to_quoted(:union_struct, ast_union_struct) |> Macro.to_string() ==
+               "union_struct(%TypespecTest.StructA{key: term()} | %TypespecTest.StructB{key: term()}) :: :ok"
+
+      assert Code.Typespec.spec_to_quoted(:union_struct_key, ast_union_struct_key)
+             |> Macro.to_string() ==
+               "union_struct_key(%{__struct__: TypespecTest.StructA | TypespecTest.StructB}) :: :ok"
+
+      assert Code.Typespec.spec_to_quoted(:union_struct_key_type, ast_union_struct_key_type)
+             |> Macro.to_string() ==
+               "union_struct_key_type(%{__struct__: atom() | TypespecTest.StructA | binary()}) :: :ok"
+    end
+
+    test "non-variables are given as arguments" do
+      msg = ~r/The type one_bad_variable\/1 has an invalid argument\(s\): String.t\(\)/
+
+      assert_raise Kernel.TypespecError, msg, fn ->
+        test_module do
+          @type one_bad_variable(String.t()) :: String.t()
+        end
+      end
+
+      msg = ~r/The type two_bad_variables\/2 has an invalid argument\(s\): :ok, Enumerable.t\(\)/
+
+      assert_raise Kernel.TypespecError, msg, fn ->
+        test_module do
+          @type two_bad_variables(:ok, Enumerable.t()) :: {:ok, []}
+        end
+      end
+
+      msg = ~r/The type one_bad_one_good\/2 has an invalid argument\(s\): \"\"/
+
+      assert_raise Kernel.TypespecError, msg, fn ->
+        test_module do
+          @type one_bad_one_good(input1, "") :: {:ok, input1}
+        end
+      end
+    end
+
+    test "retrieval invalid data" do
+      assert Code.Typespec.fetch_types(Unknown) == :error
+      assert Code.Typespec.fetch_specs(Unknown) == :error
+    end
+
+    # This is a test that implements all types specified in lib/elixir/pages/typespecs.md
+    test "documented types and their AST" do
+      defmodule SomeStruct do
+        defstruct [:key]
+      end
+
+      quoted =
+        Enum.sort([
+          ##  Basic types
+          quote(do: @type(basic_any() :: any())),
+          quote(do: @type(basic_none() :: none())),
+          quote(do: @type(basic_atom() :: atom())),
+          quote(do: @type(basic_map() :: map())),
+          quote(do: @type(basic_pid() :: pid())),
+          quote(do: @type(basic_port() :: port())),
+          quote(do: @type(basic_reference() :: reference())),
+          quote(do: @type(basic_struct() :: struct())),
+          quote(do: @type(basic_tuple() :: tuple())),
+
+          # Numbers
+          quote(do: @type(basic_float() :: float())),
+          quote(do: @type(basic_integer() :: integer())),
+          quote(do: @type(basic_neg_integer() :: neg_integer())),
+          quote(do: @type(basic_non_neg_integer() :: non_neg_integer())),
+          quote(do: @type(basic_pos_integer() :: pos_integer())),
+
+          # Lists
+          quote(do: @type(basic_list_type() :: list(integer()))),
+          quote(do: @type(basic_nonempty_list_type() :: nonempty_list(integer()))),
+          quote do
+            @type basic_maybe_improper_list_type() :: maybe_improper_list(integer(), atom())
+          end,
+          quote do
+            @type basic_nonempty_improper_list_type() :: nonempty_improper_list(integer(), atom())
+          end,
+          quote do
+            @type basic_nonempty_maybe_improper_list_type() ::
+                    nonempty_maybe_improper_list(integer(), atom())
+          end,
+
+          ## Literals
+          quote(do: @type(literal_atom() :: :atom)),
+          quote(do: @type(literal_integer() :: 1)),
+          quote(do: @type(literal_integers() :: 1..10)),
+          quote(do: @type(literal_empty_bitstring() :: <<>>)),
+          quote(do: @type(literal_size_0() :: <<_::0>>)),
+          quote(do: @type(literal_unit_1() :: <<_::_*1>>)),
+          quote(do: @type(literal_size_1_unit_8() :: <<_::100, _::_*256>>)),
+          quote(do: @type(literal_function_arity_any() :: (... -> integer()))),
+          quote(do: @type(literal_function_arity_0() :: (-> integer()))),
+          quote(do: @type(literal_function_arity_2() :: (integer(), atom() -> integer()))),
+          quote(do: @type(literal_list_type() :: [integer()])),
+          quote(do: @type(literal_empty_list() :: [])),
+          quote(do: @type(literal_list_nonempty() :: [...])),
+          quote(do: @type(literal_nonempty_list_type() :: [atom(), ...])),
+          quote(do: @type(literal_keyword_list_fixed_key() :: [key: integer()])),
+          quote(do: @type(literal_keyword_list_fixed_key2() :: [{:key, integer()}])),
+          quote(do: @type(literal_keyword_list_type_key() :: [{binary(), integer()}])),
+          quote(do: @type(literal_empty_map() :: %{})),
+          quote(do: @type(literal_map_with_key() :: %{key: integer()})),
+          quote(
+            do: @type(literal_map_with_required_key() :: %{required(bitstring()) => integer()})
+          ),
+          quote(
+            do: @type(literal_map_with_optional_key() :: %{optional(bitstring()) => integer()})
+          ),
+          quote(do: @type(literal_struct_all_fields_any_type() :: %SomeStruct{})),
+          quote(do: @type(literal_struct_all_fields_key_type() :: %SomeStruct{key: integer()})),
+          quote(do: @type(literal_empty_tuple() :: {})),
+          quote(do: @type(literal_2_element_tuple() :: {1, 2})),
+
+          ## Built-in types
+          quote(do: @type(built_in_term() :: term())),
+          quote(do: @type(built_in_arity() :: arity())),
+          quote(do: @type(built_in_as_boolean() :: as_boolean(:t))),
+          quote(do: @type(built_in_binary() :: binary())),
+          quote(do: @type(built_in_bitstring() :: bitstring())),
+          quote(do: @type(built_in_boolean() :: boolean())),
+          quote(do: @type(built_in_byte() :: byte())),
+          quote(do: @type(built_in_char() :: char())),
+          quote(do: @type(built_in_charlist() :: charlist())),
+          quote(do: @type(built_in_nonempty_charlist() :: nonempty_charlist())),
+          quote(do: @type(built_in_fun() :: fun())),
+          quote(do: @type(built_in_function() :: function())),
+          quote(do: @type(built_in_identifier() :: identifier())),
+          quote(do: @type(built_in_iodata() :: iodata())),
+          quote(do: @type(built_in_iolist() :: iolist())),
+          quote(do: @type(built_in_keyword() :: keyword())),
+          quote(do: @type(built_in_keyword_value_type() :: keyword(:t))),
+          quote(do: @type(built_in_list() :: list())),
+          quote(do: @type(built_in_nonempty_list() :: nonempty_list())),
+          quote(do: @type(built_in_maybe_improper_list() :: maybe_improper_list())),
+          quote(
+            do: @type(built_in_nonempty_maybe_improper_list() :: nonempty_maybe_improper_list())
+          ),
+          quote(do: @type(built_in_mfa() :: mfa())),
+          quote(do: @type(built_in_module() :: module())),
+          quote(do: @type(built_in_no_return() :: no_return())),
+          quote(do: @type(built_in_node() :: node())),
+          quote(do: @type(built_in_number() :: number())),
+          quote(do: @type(built_in_struct() :: struct())),
+          quote(do: @type(built_in_timeout() :: timeout())),
+
+          ## Remote types
+          quote(do: @type(remote_enum_t0() :: Enum.t())),
+          quote(do: @type(remote_keyword_t1() :: Keyword.t(integer())))
+        ])
+
+      bytecode =
+        test_module do
+          Code.eval_quoted(quoted, [], module: __MODULE__)
+        end
+
+      types = types(bytecode)
+
+      Enum.each(Enum.zip(types, quoted), fn {{:type, type}, definition} ->
+        ast = Code.Typespec.type_to_quoted(type)
+        ast_string = Macro.to_string(quote(do: @type(unquote(ast))))
+
+        case type do
+          # These cases do not translate directly to their own string version.
+          {:basic_list_type, _, _} ->
+            assert ast_string == "@type basic_list_type() :: [integer()]"
+
+          {:basic_nonempty_list_type, _, _} ->
+            assert ast_string == "@type basic_nonempty_list_type() :: [integer(), ...]"
+
+          {:literal_empty_bitstring, _, _} ->
+            assert ast_string == "@type literal_empty_bitstring() :: <<_::0>>"
+
+          {:literal_keyword_list_fixed_key, _, _} ->
+            assert ast_string == "@type literal_keyword_list_fixed_key() :: [{:key, integer()}]"
+
+          {:literal_keyword_list_fixed_key2, _, _} ->
+            assert ast_string == "@type literal_keyword_list_fixed_key2() :: [{:key, integer()}]"
+
+          {:literal_struct_all_fields_any_type, _, _} ->
+            assert ast_string ==
+                     "@type literal_struct_all_fields_any_type() :: %TypespecTest.SomeStruct{key: term()}"
+
+          {:literal_struct_all_fields_key_type, _, _} ->
+            assert ast_string ==
+                     "@type literal_struct_all_fields_key_type() :: %TypespecTest.SomeStruct{key: integer()}"
+
+          {:built_in_nonempty_list, _, _} ->
+            assert ast_string == "@type built_in_nonempty_list() :: [...]"
+
+          _ ->
+            assert ast_string == Macro.to_string(definition)
+        end
+      end)
+    end
+  end
+
+  describe "behaviour_info" do
+    defmodule SampleCallbacks do
+      @callback first(integer) :: integer
+      @callback foo(atom(), binary) :: binary
+      @callback bar(External.hello(), my_var :: binary) :: binary
+      @callback guarded(my_var) :: my_var when my_var: binary
+      @callback orr(atom | integer) :: atom
+      @callback literal(123, {atom}, :foo, [integer], true) :: atom
+      @macrocallback last(integer) :: Macro.t()
+      @macrocallback last() :: atom
+      @optional_callbacks bar: 2, last: 0
+      @optional_callbacks first: 1
+    end
+
+    test "defines callbacks" do
+      expected_callbacks = [
+        "MACRO-last": 1,
+        "MACRO-last": 2,
+        bar: 2,
+        first: 1,
+        foo: 2,
+        guarded: 1,
+        literal: 5,
+        orr: 1
+      ]
+
+      assert Enum.sort(SampleCallbacks.behaviour_info(:callbacks)) == expected_callbacks
+    end
+
+    test "defines optional callbacks" do
+      assert Enum.sort(SampleCallbacks.behaviour_info(:optional_callbacks)) ==
+               ["MACRO-last": 1, bar: 2, first: 1]
+    end
+  end
+
+  @tag tmp_dir: true
+  test "erlang module", c do
+    erlc(c, :typespec_test_mod, """
+    -module(typespec_test_mod).
+    -export([f/1]).
+    -export_type([t/1]).
+
+    -type t(X) :: list(X).
+
+    -spec f(X) -> X.
+    f(X) -> X.
+    """)
+
+    [type: type] = types(:typespec_test_mod)
+
+    assert Code.Typespec.type_to_quoted(type) ==
+             {:"::", [],
+              [
+                {:t, [], [{:x, meta(5, 9), nil}]},
+                [{:x, meta(5, 20), nil}]
+              ]}
+
+    [{{:f, 1}, [spec]}] = specs(:typespec_test_mod)
+
+    assert Code.Typespec.spec_to_quoted(:f, spec) ==
+             {:when, meta(7, 8),
+              [
+                {:"::", meta(7, 8),
+                 [{:f, meta(7, 8), [{:x, meta(7, 9), nil}]}, {:x, meta(7, 15), nil}]},
+                [x: {:var, meta(7, 8), nil}]
+              ]}
+  end
+
+  defp meta(line, column) do
+    [line: line, column: column]
+  end
+
+  defp erlc(context, module, code) do
+    dir = context.tmp_dir
+
+    src_path = Path.join([dir, "#{module}.erl"])
+    src_path |> Path.dirname() |> File.mkdir_p!()
+    File.write!(src_path, code)
+
+    ebin_dir = Path.join(dir, "ebin")
+    File.mkdir_p!(ebin_dir)
+
+    {:ok, module} =
+      :compile.file(String.to_charlist(src_path), [
+        :debug_info,
+        outdir: String.to_charlist(ebin_dir)
+      ])
+
+    true = Code.prepend_path(ebin_dir)
+    {:module, ^module} = :code.load_file(module)
+
+    ExUnit.Callbacks.on_exit(fn ->
+      :code.purge(module)
+      :code.delete(module)
+      File.rm_rf!(dir)
+    end)
+
+    :ok
+  end
+
+  defp assert_compile_error(message, fun) do
+    assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+             assert_raise CompileError, fun
+           end) =~ message
+  end
+end
diff --git a/lib/elixir/test/elixir/uri_test.exs b/lib/elixir/test/elixir/uri_test.exs
index 76126d74766..598d0af870c 100644
--- a/lib/elixir/test/elixir/uri_test.exs
+++ b/lib/elixir/test/elixir/uri_test.exs
@@ -1,202 +1,1048 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule URITest do
   use ExUnit.Case, async: true
 
-  test :encode do
+  doctest URI
+
+  test "encode/1,2" do
     assert URI.encode("4_test.is-s~") == "4_test.is-s~"
+
     assert URI.encode("\r\n&<%>\" ゆ", &URI.char_unreserved?/1) ==
-           "%0D%0A%26%3C%25%3E%22%20%E3%82%86"
+             "%0D%0A%26%3C%25%3E%22%20%E3%82%86"
   end
 
-  test :encode_www_form do
+  test "encode_www_form/1" do
     assert URI.encode_www_form("4test ~1.x") == "4test+~1.x"
     assert URI.encode_www_form("poll:146%") == "poll%3A146%25"
     assert URI.encode_www_form("/\n+/ゆ") == "%2F%0A%2B%2F%E3%82%86"
   end
 
-  test :encode_query do
+  test "encode_query/1,2" do
     assert URI.encode_query([{:foo, :bar}, {:baz, :quux}]) == "foo=bar&baz=quux"
     assert URI.encode_query([{"foo", "bar"}, {"baz", "quux"}]) == "foo=bar&baz=quux"
+
     assert URI.encode_query([{"foo z", :bar}]) == "foo+z=bar"
+    assert URI.encode_query([{"foo z", :bar}], :rfc3986) == "foo%20z=bar"
+    assert URI.encode_query([{"foo z", :bar}], :www_form) == "foo+z=bar"
+
+    assert URI.encode_query([{"foo[]", "+=/?&# Ñ"}]) ==
+             "foo%5B%5D=%2B%3D%2F%3F%26%23+%C3%91"
+
+    assert URI.encode_query([{"foo[]", "+=/?&# Ñ"}], :rfc3986) ==
+             "foo%5B%5D=%2B%3D%2F%3F%26%23%20%C3%91"
+
+    assert URI.encode_query([{"foo[]", "+=/?&# Ñ"}], :www_form) ==
+             "foo%5B%5D=%2B%3D%2F%3F%26%23+%C3%91"
 
     assert_raise ArgumentError, fn ->
-      URI.encode_query([{"foo", 'bar'}])
+      URI.encode_query([{"foo", ~c"bar"}])
+    end
+
+    assert_raise ArgumentError, fn ->
+      URI.encode_query([{~c"foo", "bar"}])
     end
   end
 
-  test :decode_query do
-    assert URI.decode_query("", []) == []
+  test "decode_query/1,2,3" do
     assert URI.decode_query("", %{}) == %{}
 
+    assert URI.decode_query("safe=off", %{"cookie" => "foo"}) ==
+             %{"safe" => "off", "cookie" => "foo"}
+
     assert URI.decode_query("q=search%20query&cookie=ab%26cd&block+buster=") ==
-           %{"block buster" => "", "cookie" => "ab&cd", "q" => "search query"}
+             %{"block buster" => "", "cookie" => "ab&cd", "q" => "search query"}
 
-    assert URI.decode_query("something=weird%3Dhappening") ==
-           %{"something" => "weird=happening"}
+    assert URI.decode_query("q=search%20query&cookie=ab%26cd&block+buster=", %{}, :rfc3986) ==
+             %{"block+buster" => "", "cookie" => "ab&cd", "q" => "search query"}
 
-    assert URI.decode_query("garbage") ==
-           %{"garbage" => nil}
-    assert URI.decode_query("=value") ==
-           %{"" => "value"}
-    assert URI.decode_query("something=weird=happening") ==
-           %{"something" => "weird=happening"}
+    assert URI.decode_query("something=weird%3Dhappening") == %{"something" => "weird=happening"}
+
+    assert URI.decode_query("=") == %{"" => ""}
+    assert URI.decode_query("key") == %{"key" => ""}
+    assert URI.decode_query("key=") == %{"key" => ""}
+    assert URI.decode_query("=value") == %{"" => "value"}
+    assert URI.decode_query("something=weird=happening") == %{"something" => "weird=happening"}
   end
 
-  test :decoder do
-    decoder  = URI.query_decoder("q=search%20query&cookie=ab%26cd&block%20buster=")
+  test "query_decoder/1,2" do
+    decoder = URI.query_decoder("q=search%20query&cookie=ab%26cd&block+buster=")
     expected = [{"q", "search query"}, {"cookie", "ab&cd"}, {"block buster", ""}]
-    assert Enum.map(decoder, &(&1)) == expected
+    assert Enum.map(decoder, & &1) == expected
+
+    decoder = URI.query_decoder("q=search%20query&cookie=ab%26cd&block+buster=", :rfc3986)
+    expected = [{"q", "search query"}, {"cookie", "ab&cd"}, {"block+buster", ""}]
+    assert Enum.map(decoder, & &1) == expected
   end
 
-  test :decode do
+  test "decode/1" do
     assert URI.decode("%0D%0A%26%3C%25%3E%22%20%E3%82%86") == "\r\n&<%>\" ゆ"
     assert URI.decode("%2f%41%4a%55") == "/AJU"
     assert URI.decode("4_t+st.is-s~") == "4_t+st.is-s~"
-
-    assert_raise ArgumentError, ~R/malformed URI/, fn ->
-      URI.decode("% invalid")
-    end
-    assert_raise ArgumentError, ~R/malformed URI/, fn ->
-      URI.decode("invalid%")
-    end
+    assert URI.decode("% invalid") == "% invalid"
+    assert URI.decode("invalid %") == "invalid %"
+    assert URI.decode("%%") == "%%"
   end
 
-  test :decode_www_form do
+  test "decode_www_form/1" do
     assert URI.decode_www_form("%3Eval+ue%2B") == ">val ue+"
     assert URI.decode_www_form("%E3%82%86+") == "ゆ "
+    assert URI.decode_www_form("% invalid") == "% invalid"
+    assert URI.decode_www_form("invalid %") == "invalid %"
+    assert URI.decode_www_form("%%") == "%%"
   end
 
-  test :parse_uri do
-    assert URI.parse(uri = %URI{scheme: "http", host: "foo.com"}) == uri
-  end
+  describe "new/1" do
+    test "empty" do
+      assert URI.new("") == {:ok, %URI{}}
+    end
 
-  test :parse_http do
-    assert %URI{scheme: "http", host: "foo.com", path: "/path/to/something",
-                query: "foo=bar&bar=foo", fragment: "fragment", port: 80,
-                authority: "foo.com", userinfo: nil} ==
-           URI.parse("http://foo.com/path/to/something?foo=bar&bar=foo#fragment")
+    test "errors on bad URIs" do
+      assert URI.new("/>") == {:error, ">"}
+      assert URI.new(":https") == {:error, ":"}
+      assert URI.new("ht\0tps://foo.com") == {:error, "\0"}
+    end
   end
 
-  test :parse_https do
-    assert %URI{scheme: "https", host: "foo.com", authority: "foo.com",
-                query: nil, fragment: nil, port: 443, path: nil, userinfo: nil} ==
-           URI.parse("https://foo.com")
-  end
+  describe "new!/1" do
+    test "returns the given URI if a %URI{} struct is given" do
+      assert URI.new!(uri = %URI{scheme: "http", host: "foo.com"}) == uri
+    end
 
-  test :parse_file do
-    assert %URI{scheme: "file", host: nil, path: "/foo/bar/baz", userinfo: nil,
-                query: nil, fragment: nil, port: nil, authority: nil} ==
-           URI.parse("file:///foo/bar/baz")
-  end
+    test "works with HTTP scheme" do
+      expected_uri = %URI{
+        scheme: "http",
+        host: "foo.com",
+        path: "/path/to/something",
+        query: "foo=bar&bar=foo",
+        fragment: "fragment",
+        port: 80,
+        userinfo: nil
+      }
 
-  test :parse_ftp do
-    assert %URI{scheme: "ftp", host: "private.ftp-servers.example.com",
-                userinfo: "user001:secretpassword", authority: "user001:secretpassword@private.ftp-servers.example.com",
-                path: "/mydirectory/myfile.txt", query: nil, fragment: nil,
-                port: 21} ==
-           URI.parse("ftp://user001:secretpassword@private.ftp-servers.example.com/mydirectory/myfile.txt")
-  end
+      assert URI.new!("http://foo.com/path/to/something?foo=bar&bar=foo#fragment") ==
+               expected_uri
+    end
 
-  test :parse_sftp do
-    assert %URI{scheme: "sftp", host: "private.ftp-servers.example.com",
-                userinfo: "user001:secretpassword", authority: "user001:secretpassword@private.ftp-servers.example.com",
-                path: "/mydirectory/myfile.txt", query: nil, fragment: nil, port: 22} ==
-           URI.parse("sftp://user001:secretpassword@private.ftp-servers.example.com/mydirectory/myfile.txt")
-  end
+    test "works with HTTPS scheme" do
+      expected_uri = %URI{
+        scheme: "https",
+        host: "foo.com",
+        query: nil,
+        fragment: nil,
+        port: 443,
+        path: nil,
+        userinfo: nil
+      }
 
-  test :parse_tftp do
-    assert %URI{scheme: "tftp", host: "private.ftp-servers.example.com",
-                userinfo: "user001:secretpassword", authority: "user001:secretpassword@private.ftp-servers.example.com",
-                path: "/mydirectory/myfile.txt", query: nil, fragment: nil, port: 69} ==
-           URI.parse("tftp://user001:secretpassword@private.ftp-servers.example.com/mydirectory/myfile.txt")
-  end
+      assert URI.new!("https://foo.com") == expected_uri
+    end
+
+    test "works with file scheme" do
+      expected_uri = %URI{
+        scheme: "file",
+        host: "",
+        path: "/foo/bar/baz",
+        userinfo: nil,
+        query: nil,
+        fragment: nil,
+        port: nil
+      }
+
+      assert URI.new!("file:///foo/bar/baz") == expected_uri
+    end
+
+    test "works with FTP scheme" do
+      expected_uri = %URI{
+        scheme: "ftp",
+        host: "private.ftp-server.example.com",
+        userinfo: "user001:password",
+        path: "/my_directory/my_file.txt",
+        query: nil,
+        fragment: nil,
+        port: 21
+      }
+
+      ftp = "ftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt"
+      assert URI.new!(ftp) == expected_uri
+    end
+
+    test "works with SFTP scheme" do
+      expected_uri = %URI{
+        scheme: "sftp",
+        host: "private.ftp-server.example.com",
+        userinfo: "user001:password",
+        path: "/my_directory/my_file.txt",
+        query: nil,
+        fragment: nil,
+        port: 22
+      }
+
+      sftp = "sftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt"
+      assert URI.new!(sftp) == expected_uri
+    end
+
+    test "works with TFTP scheme" do
+      expected_uri = %URI{
+        scheme: "tftp",
+        host: "private.ftp-server.example.com",
+        userinfo: "user001:password",
+        path: "/my_directory/my_file.txt",
+        query: nil,
+        fragment: nil,
+        port: 69
+      }
+
+      tftp = "tftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt"
+      assert URI.new!(tftp) == expected_uri
+    end
+
+    test "works with LDAP scheme" do
+      expected_uri = %URI{
+        scheme: "ldap",
+        host: "",
+        userinfo: nil,
+        path: "/dc=example,dc=com",
+        query: "?sub?(givenName=John)",
+        fragment: nil,
+        port: 389
+      }
+
+      assert URI.new!("ldap:///dc=example,dc=com??sub?(givenName=John)") == expected_uri
+
+      expected_uri = %URI{
+        scheme: "ldap",
+        host: "ldap.example.com",
+        userinfo: nil,
+        path: "/cn=John%20Doe,dc=foo,dc=com",
+        fragment: nil,
+        port: 389,
+        query: nil
+      }
+
+      assert URI.new!("ldap://ldap.example.com/cn=John%20Doe,dc=foo,dc=com") == expected_uri
+    end
 
+    test "can parse IPv6 addresses" do
+      addresses = [
+        # undefined
+        "::",
+        # loopback
+        "::1",
+        # unicast
+        "1080::8:800:200C:417A",
+        # multicast
+        "FF01::101",
+        # link-local
+        "fe80::",
+        # abbreviated
+        "2607:f3f0:2:0:216:3cff:fef0:174a",
+        # mixed hex case
+        "2607:f3F0:2:0:216:3cFf:Fef0:174A",
+        # complete
+        "2051:0db8:2d5a:3521:8313:ffad:1242:8e2e",
+        # embedded IPv4
+        "::00:192.168.10.184"
+      ]
 
-  test :parse_ldap do
-    assert %URI{scheme: "ldap", host: nil, authority: nil, userinfo: nil,
-                path: "/dc=example,dc=com", query: "?sub?(givenName=John)",
-                fragment: nil, port: 389} ==
-           URI.parse("ldap:///dc=example,dc=com??sub?(givenName=John)")
-    assert %URI{scheme: "ldap", host: "ldap.example.com", authority: "ldap.example.com",
-                userinfo: nil, path: "/cn=John%20Doe,dc=example,dc=com", fragment: nil,
-                port: 389, query: nil} ==
-           URI.parse("ldap://ldap.example.com/cn=John%20Doe,dc=example,dc=com")
+      Enum.each(addresses, fn addr ->
+        simple_uri = URI.new!("http://[#{addr}]/")
+        assert simple_uri.host == addr
+
+        userinfo_uri = URI.new!("http://user:pass@[#{addr}]/")
+        assert userinfo_uri.host == addr
+        assert userinfo_uri.userinfo == "user:pass"
+
+        port_uri = URI.new!("http://[#{addr}]:2222/")
+        assert port_uri.host == addr
+        assert port_uri.port == 2222
+
+        userinfo_port_uri = URI.new!("http://user:pass@[#{addr}]:2222/")
+        assert userinfo_port_uri.host == addr
+        assert userinfo_port_uri.userinfo == "user:pass"
+        assert userinfo_port_uri.port == 2222
+      end)
+    end
+
+    test "downcases the scheme" do
+      assert URI.new!("hTtP://google.com").scheme == "http"
+    end
+
+    test "preserves empty fragments" do
+      assert URI.new!("http://example.com#").fragment == ""
+      assert URI.new!("http://example.com/#").fragment == ""
+      assert URI.new!("http://example.com/test#").fragment == ""
+    end
+
+    test "preserves an empty query" do
+      assert URI.new!("http://foo.com/?").query == ""
+    end
+
+    test "without scheme, undefined port after host translates to nil" do
+      assert URI.new!("//https://www.example.com") ==
+               %URI{
+                 scheme: nil,
+                 userinfo: nil,
+                 host: "https",
+                 port: nil,
+                 path: "//www.example.com",
+                 query: nil,
+                 fragment: nil
+               }
+    end
+
+    test "with scheme, undefined port after host translates to nil" do
+      assert URI.new!("myscheme://myhost:/path/info") ==
+               %URI{
+                 scheme: "myscheme",
+                 userinfo: nil,
+                 host: "myhost",
+                 port: nil,
+                 path: "/path/info",
+                 query: nil,
+                 fragment: nil
+               }
+    end
   end
 
-  test :parse_splits_authority do
-    assert %URI{scheme: "http", host: "foo.com", path: nil,
-                query: nil, fragment: nil, port: 4444,
-                authority: "foo:bar@foo.com:4444",
-                userinfo: "foo:bar"} ==
-           URI.parse("http://foo:bar@foo.com:4444")
-    assert %URI{scheme: "https", host: "foo.com", path: nil,
-                query: nil, fragment: nil, port: 443,
-                authority: "foo:bar@foo.com", userinfo: "foo:bar"} ==
-           URI.parse("https://foo:bar@foo.com")
-    assert %URI{scheme: "http", host: "foo.com", path: nil,
-                query: nil, fragment: nil, port: 4444,
-                authority: "foo.com:4444", userinfo: nil} ==
-           URI.parse("http://foo.com:4444")
+  test "http://http://http://@http://http://?http://#http://" do
+    assert URI.parse("http://http://http://@http://http://?http://#http://") ==
+             %URI{
+               scheme: "http",
+               authority: "http:",
+               userinfo: nil,
+               host: "http",
+               port: 80,
+               path: "//http://@http://http://",
+               query: "http://",
+               fragment: "http://"
+             }
+
+    assert URI.new!("http://http://http://@http://http://?http://#http://") ==
+             %URI{
+               scheme: "http",
+               userinfo: nil,
+               host: "http",
+               port: 80,
+               path: "//http://@http://http://",
+               query: "http://",
+               fragment: "http://"
+             }
   end
 
-  test :default_port do
+  test "default_port/1,2" do
     assert URI.default_port("http") == 80
-    assert URI.default_port("unknown") == nil
 
+    try do
+      URI.default_port("http", 8000)
+      assert URI.default_port("http") == 8000
+    after
+      URI.default_port("http", 80)
+    end
+
+    assert URI.default_port("unknown") == nil
     URI.default_port("unknown", 13)
     assert URI.default_port("unknown") == 13
   end
 
-  test :parse_bad_uris do
-    assert URI.parse("https:??@?F?@#>F//23/")
-    assert URI.parse("")
-    assert URI.parse(":https")
-    assert URI.parse("https")
+  test "to_string/1 and Kernel.to_string/1" do
+    assert to_string(URI.new!("http://google.com")) == "http://google.com"
+    assert to_string(URI.new!("http://google.com:443")) == "http://google.com:443"
+    assert to_string(URI.new!("https://google.com:443")) == "https://google.com"
+    assert to_string(URI.new!("file:/path")) == "file:/path"
+    assert to_string(URI.new!("file:///path")) == "file:///path"
+    assert to_string(URI.new!("file://///path")) == "file://///path"
+    assert to_string(URI.new!("http://lol:wut@google.com")) == "http://lol:wut@google.com"
+    assert to_string(URI.new!("http://google.com/elixir")) == "http://google.com/elixir"
+    assert to_string(URI.new!("http://google.com?q=lol")) == "http://google.com?q=lol"
+    assert to_string(URI.new!("http://google.com?q=lol#omg")) == "http://google.com?q=lol#omg"
+    assert to_string(URI.new!("//google.com/elixir")) == "//google.com/elixir"
+    assert to_string(URI.new!("//google.com:8080/elixir")) == "//google.com:8080/elixir"
+    assert to_string(URI.new!("//user:password@google.com/")) == "//user:password@google.com/"
+    assert to_string(URI.new!("http://[2001:db8::]:8080")) == "http://[2001:db8::]:8080"
+    assert to_string(URI.new!("http://[2001:db8::]")) == "http://[2001:db8::]"
+
+    assert URI.to_string(URI.new!("http://google.com")) == "http://google.com"
+    assert URI.to_string(URI.new!("gid:hello/123")) == "gid:hello/123"
+
+    assert URI.to_string(URI.new!("//user:password@google.com/")) ==
+             "//user:password@google.com/"
+
+    assert_raise ArgumentError,
+                 ~r":path in URI must be empty or an absolute path if URL has a :host",
+                 fn -> %URI{host: "foo.com", path: "hello/123"} |> URI.to_string() end
+  end
+
+  describe "merge/2" do
+    test "with valid paths" do
+      assert URI.merge("http://google.com/foo", "http://example.com/baz")
+             |> to_string() == "http://example.com/baz"
+
+      assert URI.merge("http://google.com/foo", "http://example.com/.././bar/../../baz")
+             |> to_string() == "http://example.com/baz"
+
+      assert URI.merge("http://google.com/foo", "//example.com/baz")
+             |> to_string() == "http://example.com/baz"
+
+      assert URI.merge("http://google.com/foo", URI.new!("//example.com/baz"))
+             |> to_string() == "http://example.com/baz"
+
+      assert URI.merge("http://google.com/foo", "//example.com/.././bar/../../../baz")
+             |> to_string() == "http://example.com/baz"
+
+      assert URI.merge("http://example.com", URI.new!("/foo"))
+             |> to_string() == "http://example.com/foo"
+
+      assert URI.merge("http://example.com", URI.new!("/.././bar/../../../baz"))
+             |> to_string() == "http://example.com/baz"
+
+      base = URI.new!("http://example.com/foo/bar")
+      assert URI.merge(base, "") |> to_string() == "http://example.com/foo/bar"
+      assert URI.merge(base, "#fragment") |> to_string() == "http://example.com/foo/bar#fragment"
+      assert URI.merge(base, "?query") |> to_string() == "http://example.com/foo/bar?query"
+      assert URI.merge(base, %URI{}) |> to_string() == "http://example.com/foo/bar"
+
+      assert URI.merge(base, %URI{fragment: "fragment"})
+             |> to_string() == "http://example.com/foo/bar#fragment"
+
+      base = URI.new!("http://example.com")
+      assert URI.merge(base, "/foo") |> to_string() == "http://example.com/foo"
+      assert URI.merge(base, "foo") |> to_string() == "http://example.com/foo"
+
+      base = URI.new!("http://example.com/foo/bar")
+      assert URI.merge(base, "/baz") |> to_string() == "http://example.com/baz"
+      assert URI.merge(base, "baz") |> to_string() == "http://example.com/foo/baz"
+      assert URI.merge(base, "../baz") |> to_string() == "http://example.com/baz"
+      assert URI.merge(base, ".././baz") |> to_string() == "http://example.com/baz"
+      assert URI.merge(base, "./baz") |> to_string() == "http://example.com/foo/baz"
+      assert URI.merge(base, "bar/./baz") |> to_string() == "http://example.com/foo/bar/baz"
+
+      base = URI.new!("http://example.com/foo/bar/")
+      assert URI.merge(base, "/baz") |> to_string() == "http://example.com/baz"
+      assert URI.merge(base, "baz") |> to_string() == "http://example.com/foo/bar/baz"
+      assert URI.merge(base, "../baz") |> to_string() == "http://example.com/foo/baz"
+      assert URI.merge(base, ".././baz") |> to_string() == "http://example.com/foo/baz"
+      assert URI.merge(base, "./baz") |> to_string() == "http://example.com/foo/bar/baz"
+      assert URI.merge(base, "bar/./baz") |> to_string() == "http://example.com/foo/bar/bar/baz"
+
+      base = URI.new!("http://example.com/foo/bar/baz")
+      assert URI.merge(base, "../../foobar") |> to_string() == "http://example.com/foobar"
+      assert URI.merge(base, "../../../foobar") |> to_string() == "http://example.com/foobar"
+
+      assert URI.merge(base, "../../../../../../foobar") |> to_string() ==
+               "http://example.com/foobar"
+
+      base = URI.new!("http://example.com/foo/../bar")
+      assert URI.merge(base, "baz") |> to_string() == "http://example.com/baz"
+
+      base = URI.new!("http://example.com/foo/./bar")
+      assert URI.merge(base, "baz") |> to_string() == "http://example.com/foo/baz"
+
+      base = URI.new!("http://example.com/foo?query1")
+      assert URI.merge(base, "?query2") |> to_string() == "http://example.com/foo?query2"
+      assert URI.merge(base, "") |> to_string() == "http://example.com/foo?query1"
+
+      base = URI.new!("http://example.com/foo#fragment1")
+      assert URI.merge(base, "#fragment2") |> to_string() == "http://example.com/foo#fragment2"
+      assert URI.merge(base, "") |> to_string() == "http://example.com/foo"
+
+      page_url = "https://example.com/guide/"
+      image_url = "https://images.example.com/t/1600x/https://images.example.com/foo.jpg"
+
+      assert URI.merge(URI.new!(page_url), URI.new!(image_url)) |> to_string() ==
+               "https://images.example.com/t/1600x/https://images.example.com/foo.jpg"
+    end
+
+    test "error on relative base" do
+      assert_raise ArgumentError, "you must merge onto an absolute URI", fn ->
+        URI.merge("/relative", "")
+      end
+    end
+
+    test "base without host" do
+      assert URI.merge("tag:example", "foo") |> to_string == "tag:foo"
+      assert URI.merge("tag:example", "#fragment") |> to_string == "tag:example#fragment"
+    end
+
+    test "base without host and path" do
+      assert URI.merge("ex:", "test") |> to_string() == "ex:test"
+      assert URI.merge("ex:", "a/b/c") |> to_string() == "ex:a/b/c"
+      assert URI.merge("ex:", "a/b/./../c") |> to_string() == "ex:a/c"
+      assert URI.merge("ex:", "test?query=value") |> to_string() == "ex:test?query=value"
+      assert URI.merge("mailto:", "user@example.com") |> to_string() == "mailto:user@example.com"
+      assert URI.merge("urn:isbn", "0451450523") |> to_string() == "urn:0451450523"
+    end
+
+    test "with RFC examples" do
+      # These are examples from:
+      #
+      # https://www.rfc-editor.org/rfc/rfc3986#section-5.4.1
+      # https://www.rfc-editor.org/rfc/rfc3986#section-5.4.2
+      #
+      # They are taken verbatim from the above document for easy comparison
+
+      base = "http://a/b/c/d;p?q"
+
+      rel_and_result = %{
+        "g:h" => "g:h",
+        "g" => "http://a/b/c/g",
+        "./g" => "http://a/b/c/g",
+        "g/" => "http://a/b/c/g/",
+        "/g" => "http://a/g",
+        "//g" => "http://g",
+        "?y" => "http://a/b/c/d;p?y",
+        "g?y" => "http://a/b/c/g?y",
+        "#s" => "http://a/b/c/d;p?q#s",
+        "g#s" => "http://a/b/c/g#s",
+        "g?y#s" => "http://a/b/c/g?y#s",
+        ";x" => "http://a/b/c/;x",
+        "g;x" => "http://a/b/c/g;x",
+        "g;x?y#s" => "http://a/b/c/g;x?y#s",
+        "" => "http://a/b/c/d;p?q",
+        "." => "http://a/b/c/",
+        "./" => "http://a/b/c/",
+        ".." => "http://a/b/",
+        "../" => "http://a/b/",
+        "../g" => "http://a/b/g",
+        "../.." => "http://a/",
+        "../../" => "http://a/",
+        "../../g" => "http://a/g",
+        "../../../g" => "http://a/g",
+        "../../../../g" => "http://a/g",
+        "/./g" => "http://a/g",
+        "/../g" => "http://a/g",
+        "g." => "http://a/b/c/g.",
+        ".g" => "http://a/b/c/.g",
+        "g.." => "http://a/b/c/g..",
+        "..g" => "http://a/b/c/..g",
+        "./../g" => "http://a/b/g",
+        "./g/." => "http://a/b/c/g/",
+        "g/./h" => "http://a/b/c/g/h",
+        "g/../h" => "http://a/b/c/h",
+        "g;x=1/./y" => "http://a/b/c/g;x=1/y",
+        "g;x=1/../y" => "http://a/b/c/y",
+        "g?y/./x" => "http://a/b/c/g?y/./x",
+        "g?y/../x" => "http://a/b/c/g?y/../x",
+        "g#s/./x" => "http://a/b/c/g#s/./x",
+        "g#s/../x" => "http://a/b/c/g#s/../x",
+        "http:g" => "http:g"
+      }
+
+      for {rel, result} <- rel_and_result do
+        assert URI.merge(base, rel) |> URI.to_string() == result
+      end
+    end
+
+    test "with W3C examples" do
+      # These examples are from the W3C JSON-LD test suite:
+      #
+      # https://w3c.github.io/json-ld-api/tests/toRdf-manifest#t0124
+      # https://w3c.github.io/json-ld-api/tests/toRdf-manifest#t0125
+      # https://w3c.github.io/json-ld-api/tests/toRdf-manifest#t0123
+
+      base1 = "http://a/bb/ccc/."
+
+      rel_and_result1 = %{
+        "g:h" => "g:h",
+        "g" => "http://a/bb/ccc/g",
+        "./g" => "http://a/bb/ccc/g",
+        "g/" => "http://a/bb/ccc/g/",
+        "/g" => "http://a/g",
+        "//g" => "http://g",
+        "?y" => "http://a/bb/ccc/.?y",
+        "g?y" => "http://a/bb/ccc/g?y",
+        "#s" => "http://a/bb/ccc/.#s",
+        "g#s" => "http://a/bb/ccc/g#s",
+        "g?y#s" => "http://a/bb/ccc/g?y#s",
+        ";x" => "http://a/bb/ccc/;x",
+        "g;x" => "http://a/bb/ccc/g;x",
+        "g;x?y#s" => "http://a/bb/ccc/g;x?y#s",
+        "" => "http://a/bb/ccc/.",
+        "." => "http://a/bb/ccc/",
+        "./" => "http://a/bb/ccc/",
+        ".." => "http://a/bb/",
+        "../" => "http://a/bb/",
+        "../g" => "http://a/bb/g",
+        "../.." => "http://a/",
+        "../../" => "http://a/",
+        "../../g" => "http://a/g",
+        "../../../g" => "http://a/g",
+        "../../../../g" => "http://a/g",
+        "/./g" => "http://a/g",
+        "/../g" => "http://a/g",
+        "g." => "http://a/bb/ccc/g.",
+        ".g" => "http://a/bb/ccc/.g",
+        "g.." => "http://a/bb/ccc/g..",
+        "..g" => "http://a/bb/ccc/..g",
+        "./../g" => "http://a/bb/g",
+        "./g/." => "http://a/bb/ccc/g/",
+        "g/./h" => "http://a/bb/ccc/g/h",
+        "g/../h" => "http://a/bb/ccc/h",
+        "g;x=1/./y" => "http://a/bb/ccc/g;x=1/y",
+        "g;x=1/../y" => "http://a/bb/ccc/y",
+        "g?y/./x" => "http://a/bb/ccc/g?y/./x",
+        "g?y/../x" => "http://a/bb/ccc/g?y/../x",
+        "g#s/./x" => "http://a/bb/ccc/g#s/./x",
+        "g#s/../x" => "http://a/bb/ccc/g#s/../x",
+        "http:g" => "http:g"
+      }
+
+      for {rel, result} <- rel_and_result1 do
+        assert URI.merge(base1, rel) |> URI.to_string() == result
+      end
+
+      base2 = "http://a/bb/ccc/.."
+
+      rel_and_result2 = %{
+        "g:h" => "g:h",
+        "g" => "http://a/bb/ccc/g",
+        "./g" => "http://a/bb/ccc/g",
+        "g/" => "http://a/bb/ccc/g/",
+        "/g" => "http://a/g",
+        "//g" => "http://g",
+        "?y" => "http://a/bb/ccc/..?y",
+        "g?y" => "http://a/bb/ccc/g?y",
+        "#s" => "http://a/bb/ccc/..#s",
+        "g#s" => "http://a/bb/ccc/g#s",
+        "g?y#s" => "http://a/bb/ccc/g?y#s",
+        ";x" => "http://a/bb/ccc/;x",
+        "g;x" => "http://a/bb/ccc/g;x",
+        "g;x?y#s" => "http://a/bb/ccc/g;x?y#s",
+        "" => "http://a/bb/ccc/..",
+        "." => "http://a/bb/ccc/",
+        "./" => "http://a/bb/ccc/",
+        ".." => "http://a/bb/",
+        "../" => "http://a/bb/",
+        "../g" => "http://a/bb/g",
+        "../.." => "http://a/",
+        "../../" => "http://a/",
+        "../../g" => "http://a/g",
+        "../../../g" => "http://a/g",
+        "../../../../g" => "http://a/g",
+        "/./g" => "http://a/g",
+        "/../g" => "http://a/g",
+        "g." => "http://a/bb/ccc/g.",
+        ".g" => "http://a/bb/ccc/.g",
+        "g.." => "http://a/bb/ccc/g..",
+        "..g" => "http://a/bb/ccc/..g",
+        "./../g" => "http://a/bb/g",
+        "./g/." => "http://a/bb/ccc/g/",
+        "g/./h" => "http://a/bb/ccc/g/h",
+        "g/../h" => "http://a/bb/ccc/h",
+        "g;x=1/./y" => "http://a/bb/ccc/g;x=1/y",
+        "g;x=1/../y" => "http://a/bb/ccc/y",
+        "g?y/./x" => "http://a/bb/ccc/g?y/./x",
+        "g?y/../x" => "http://a/bb/ccc/g?y/../x",
+        "g#s/./x" => "http://a/bb/ccc/g#s/./x",
+        "g#s/../x" => "http://a/bb/ccc/g#s/../x",
+        "http:g" => "http:g"
+      }
+
+      for {rel, result} <- rel_and_result2 do
+        assert URI.merge(base2, rel) |> URI.to_string() == result
+      end
+
+      base3 = "http://a/bb/ccc/../d;p?q"
+
+      rel_and_result = %{
+        "g:h" => "g:h",
+        "g" => "http://a/bb/g",
+        "./g" => "http://a/bb/g",
+        "g/" => "http://a/bb/g/",
+        "/g" => "http://a/g",
+        "//g" => "http://g",
+        "?y" => "http://a/bb/ccc/../d;p?y",
+        "g?y" => "http://a/bb/g?y",
+        "#s" => "http://a/bb/ccc/../d;p?q#s",
+        "g#s" => "http://a/bb/g#s",
+        "g?y#s" => "http://a/bb/g?y#s",
+        ";x" => "http://a/bb/;x",
+        "g;x" => "http://a/bb/g;x",
+        "g;x?y#s" => "http://a/bb/g;x?y#s",
+        "" => "http://a/bb/ccc/../d;p?q",
+        "." => "http://a/bb/",
+        "./" => "http://a/bb/",
+        ".." => "http://a/",
+        "../" => "http://a/",
+        "../g" => "http://a/g",
+        "../.." => "http://a/",
+        "../../" => "http://a/",
+        "../../g" => "http://a/g",
+        "../../../g" => "http://a/g",
+        "../../../../g" => "http://a/g",
+        "/./g" => "http://a/g",
+        "/../g" => "http://a/g",
+        "g." => "http://a/bb/g.",
+        ".g" => "http://a/bb/.g",
+        "g.." => "http://a/bb/g..",
+        "..g" => "http://a/bb/..g",
+        "./../g" => "http://a/g",
+        "./g/." => "http://a/bb/g/",
+        "g/./h" => "http://a/bb/g/h",
+        "g/../h" => "http://a/bb/h",
+        "g;x=1/./y" => "http://a/bb/g;x=1/y",
+        "g;x=1/../y" => "http://a/bb/y",
+        "g?y/./x" => "http://a/bb/g?y/./x",
+        "g?y/../x" => "http://a/bb/g?y/../x",
+        "g#s/./x" => "http://a/bb/g#s/./x",
+        "g#s/../x" => "http://a/bb/g#s/../x",
+        "http:g" => "http:g"
+      }
+
+      for {rel, result} <- rel_and_result do
+        assert URI.merge(base3, rel) |> URI.to_string() == result
+      end
+    end
+  end
+
+  test "append_query/2" do
+    assert URI.append_query(URI.parse("http://example.com/?x=1"), "x=2").query == "x=1&x=2"
+    assert URI.append_query(URI.parse("http://example.com/?x=1&"), "x=2").query == "x=1&x=2"
   end
 
-  test :ipv6_addresses do
-    addrs = [
-      "::",                                      # undefined
-      "::1",                                     # loopback
-      "1080::8:800:200C:417A",                   # unicast
-      "FF01::101",                               # multicast
-      "2607:f3f0:2:0:216:3cff:fef0:174a",        # abbreviated
-      "2607:f3F0:2:0:216:3cFf:Fef0:174A",        # mixed hex case
-      "2051:0db8:2d5a:3521:8313:ffad:1242:8e2e", # complete
-      "::00:192.168.10.184"                      # embedded IPv4
-    ]
+  describe "append_path/2" do
+    test "with valid paths" do
+      examples = [
+        {"http://example.com", "/", "http://example.com/"},
+        {"http://example.com/", "/foo", "http://example.com/foo"},
+        {"http://example.com/foo", "/bar", "http://example.com/foo/bar"},
+        {"http://example.com/foo", "/bar/", "http://example.com/foo/bar/"},
+        {"http://example.com/foo", "/bar/baz", "http://example.com/foo/bar/baz"},
+        {"http://example.com/foo?var=1", "/bar/", "http://example.com/foo/bar/?var=1"},
+        {"https://example.com/page/", "/urn:example:page",
+         "https://example.com/page/urn:example:page"}
+      ]
 
-    Enum.each addrs, fn(addr) ->
-      simple_uri = URI.parse("http://[#{addr}]/")
-      assert simple_uri.host == addr
+      for {base_url, path, expected_result} <- examples do
+        result =
+          base_url
+          |> URI.parse()
+          |> URI.append_path(path)
+          |> URI.to_string()
 
-      userinfo_uri = URI.parse("http://user:pass@[#{addr}]/")
-      assert userinfo_uri.host == addr
-      assert userinfo_uri.userinfo == "user:pass"
+        assert result == expected_result, """
+        Path did not append as expected
 
-      port_uri = URI.parse("http://[#{addr}]:2222/")
-      assert port_uri.host == addr
-      assert port_uri.port == 2222
+          base_url: #{inspect(base_url)}
+          path: #{inspect(path)}
 
-      userinfo_port_uri = URI.parse("http://user:pass@[#{addr}]:2222/")
-      assert userinfo_port_uri.host == addr
-      assert userinfo_port_uri.userinfo == "user:pass"
-      assert userinfo_port_uri.port == 2222
+          result:          #{inspect(result)}
+          expected_result: #{inspect(expected_result)}
+        """
+      end
+    end
+
+    test "errors on invalid paths" do
+      base_uri = URI.parse("http://example.com")
+
+      assert_raise ArgumentError,
+                   ~S|path must start with "/", got: "foo"|,
+                   fn ->
+                     URI.append_path(base_uri, "foo")
+                   end
+
+      assert_raise ArgumentError,
+                   ~S|path cannot start with "//", got: "//foo"|,
+                   fn ->
+                     URI.append_path(base_uri, "//foo")
+                   end
     end
   end
 
-  test :downcase_scheme do
-    assert URI.parse("hTtP://google.com").scheme == "http"
+  ## Deprecate API
+
+  describe "authority" do
+    test "to_string" do
+      assert URI.to_string(%URI{authority: "foo@example.com:80"}) ==
+               "//foo@example.com:80"
+
+      assert URI.to_string(%URI{userinfo: "bar", host: "example.org", port: 81}) ==
+               "//bar@example.org:81"
+
+      assert URI.to_string(%URI{
+               authority: "foo@example.com:80",
+               userinfo: "bar",
+               host: "example.org",
+               port: 81
+             }) ==
+               "//bar@example.org:81"
+    end
   end
 
-  test :to_string do
-    assert to_string(URI.parse("http://google.com")) == "http://google.com"
-    assert to_string(URI.parse("http://google.com:443")) == "http://google.com:443"
-    assert to_string(URI.parse("https://google.com:443")) == "https://google.com"
-    assert to_string(URI.parse("http://lol:wut@google.com")) == "http://lol:wut@google.com"
-    assert to_string(URI.parse("http://google.com/elixir")) == "http://google.com/elixir"
-    assert to_string(URI.parse("http://google.com?q=lol")) == "http://google.com?q=lol"
-    assert to_string(URI.parse("http://google.com?q=lol#omg")) == "http://google.com?q=lol#omg"
+  describe "parse/1" do
+    test "returns the given URI if a %URI{} struct is given" do
+      assert URI.parse(uri = %URI{scheme: "http", host: "foo.com"}) == uri
+    end
+
+    test "works with HTTP scheme" do
+      expected_uri = %URI{
+        scheme: "http",
+        host: "foo.com",
+        path: "/path/to/something",
+        query: "foo=bar&bar=foo",
+        fragment: "fragment",
+        port: 80,
+        authority: "foo.com",
+        userinfo: nil
+      }
+
+      assert URI.parse("http://foo.com/path/to/something?foo=bar&bar=foo#fragment") ==
+               expected_uri
+    end
+
+    test "works with HTTPS scheme" do
+      expected_uri = %URI{
+        scheme: "https",
+        host: "foo.com",
+        authority: "foo.com",
+        query: nil,
+        fragment: nil,
+        port: 443,
+        path: nil,
+        userinfo: nil
+      }
+
+      assert URI.parse("https://foo.com") == expected_uri
+    end
+
+    test "works with \"file\" scheme" do
+      expected_uri = %URI{
+        scheme: "file",
+        host: "",
+        path: "/foo/bar/baz",
+        userinfo: nil,
+        query: nil,
+        fragment: nil,
+        port: nil,
+        authority: ""
+      }
+
+      assert URI.parse("file:///foo/bar/baz") == expected_uri
+    end
+
+    test "works with FTP scheme" do
+      expected_uri = %URI{
+        scheme: "ftp",
+        host: "private.ftp-server.example.com",
+        userinfo: "user001:password",
+        authority: "user001:password@private.ftp-server.example.com",
+        path: "/my_directory/my_file.txt",
+        query: nil,
+        fragment: nil,
+        port: 21
+      }
+
+      ftp = "ftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt"
+      assert URI.parse(ftp) == expected_uri
+    end
+
+    test "works with SFTP scheme" do
+      expected_uri = %URI{
+        scheme: "sftp",
+        host: "private.ftp-server.example.com",
+        userinfo: "user001:password",
+        authority: "user001:password@private.ftp-server.example.com",
+        path: "/my_directory/my_file.txt",
+        query: nil,
+        fragment: nil,
+        port: 22
+      }
+
+      sftp = "sftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt"
+      assert URI.parse(sftp) == expected_uri
+    end
+
+    test "works with TFTP scheme" do
+      expected_uri = %URI{
+        scheme: "tftp",
+        host: "private.ftp-server.example.com",
+        userinfo: "user001:password",
+        authority: "user001:password@private.ftp-server.example.com",
+        path: "/my_directory/my_file.txt",
+        query: nil,
+        fragment: nil,
+        port: 69
+      }
+
+      tftp = "tftp://user001:password@private.ftp-server.example.com/my_directory/my_file.txt"
+      assert URI.parse(tftp) == expected_uri
+    end
+
+    test "works with LDAP scheme" do
+      expected_uri = %URI{
+        scheme: "ldap",
+        host: "",
+        authority: "",
+        userinfo: nil,
+        path: "/dc=example,dc=com",
+        query: "?sub?(givenName=John)",
+        fragment: nil,
+        port: 389
+      }
+
+      assert URI.parse("ldap:///dc=example,dc=com??sub?(givenName=John)") == expected_uri
+
+      expected_uri = %URI{
+        scheme: "ldap",
+        host: "ldap.example.com",
+        authority: "ldap.example.com",
+        userinfo: nil,
+        path: "/cn=John%20Doe,dc=foo,dc=com",
+        fragment: nil,
+        port: 389,
+        query: nil
+      }
+
+      assert URI.parse("ldap://ldap.example.com/cn=John%20Doe,dc=foo,dc=com") == expected_uri
+    end
+
+    test "works with WebSocket scheme" do
+      expected_uri = %URI{
+        authority: "ws.example.com",
+        fragment: "content",
+        host: "ws.example.com",
+        path: "/path/to",
+        port: 80,
+        query: "here",
+        scheme: "ws",
+        userinfo: nil
+      }
+
+      assert URI.parse("ws://ws.example.com/path/to?here#content") == expected_uri
+    end
+
+    test "works with WebSocket Secure scheme" do
+      expected_uri = %URI{
+        authority: "ws.example.com",
+        fragment: "content",
+        host: "ws.example.com",
+        path: "/path/to",
+        port: 443,
+        query: "here",
+        scheme: "wss",
+        userinfo: nil
+      }
+
+      assert URI.parse("wss://ws.example.com/path/to?here#content") == expected_uri
+    end
+
+    test "splits authority" do
+      expected_uri = %URI{
+        scheme: "http",
+        host: "foo.com",
+        path: nil,
+        query: nil,
+        fragment: nil,
+        port: 4444,
+        authority: "foo:bar@foo.com:4444",
+        userinfo: "foo:bar"
+      }
+
+      assert URI.parse("http://foo:bar@foo.com:4444") == expected_uri
+
+      expected_uri = %URI{
+        scheme: "https",
+        host: "foo.com",
+        path: nil,
+        query: nil,
+        fragment: nil,
+        port: 443,
+        authority: "foo:bar@foo.com",
+        userinfo: "foo:bar"
+      }
+
+      assert URI.parse("https://foo:bar@foo.com") == expected_uri
+
+      expected_uri = %URI{
+        scheme: "http",
+        host: "foo.com",
+        path: nil,
+        query: nil,
+        fragment: nil,
+        port: 4444,
+        authority: "foo.com:4444",
+        userinfo: nil
+      }
+
+      assert URI.parse("http://foo.com:4444") == expected_uri
+    end
+
+    test "can parse bad URIs" do
+      assert URI.parse("")
+      assert URI.parse("https:??@?F?@#>F//23/")
+
+      assert URI.parse(":https").path == ":https"
+      assert URI.parse("https").path == "https"
+      assert URI.parse("ht\0tps://foo.com").path == "ht\0tps://foo.com"
+    end
+
+    test "can parse IPv6 addresses" do
+      addresses = [
+        # undefined
+        "::",
+        # loopback
+        "::1",
+        # unicast
+        "1080::8:800:200C:417A",
+        # multicast
+        "FF01::101",
+        # link-local
+        "fe80::",
+        # abbreviated
+        "2607:f3f0:2:0:216:3cff:fef0:174a",
+        # mixed hex case
+        "2607:f3F0:2:0:216:3cFf:Fef0:174A",
+        # complete
+        "2051:0db8:2d5a:3521:8313:ffad:1242:8e2e",
+        # embedded IPv4
+        "::00:192.168.10.184"
+      ]
+
+      Enum.each(addresses, fn addr ->
+        simple_uri = URI.parse("http://[#{addr}]/")
+        assert simple_uri.authority == "[#{addr}]"
+        assert simple_uri.host == addr
+
+        userinfo_uri = URI.parse("http://user:pass@[#{addr}]/")
+        assert userinfo_uri.authority == "user:pass@[#{addr}]"
+        assert userinfo_uri.host == addr
+        assert userinfo_uri.userinfo == "user:pass"
+
+        port_uri = URI.parse("http://[#{addr}]:2222/")
+        assert port_uri.authority == "[#{addr}]:2222"
+        assert port_uri.host == addr
+        assert port_uri.port == 2222
+
+        userinfo_port_uri = URI.parse("http://user:pass@[#{addr}]:2222/")
+        assert userinfo_port_uri.authority == "user:pass@[#{addr}]:2222"
+        assert userinfo_port_uri.host == addr
+        assert userinfo_port_uri.userinfo == "user:pass"
+        assert userinfo_port_uri.port == 2222
+      end)
+    end
+
+    test "downcases the scheme" do
+      assert URI.parse("hTtP://google.com").scheme == "http"
+    end
+
+    test "preserves empty fragments" do
+      assert URI.parse("http://example.com#").fragment == ""
+      assert URI.parse("http://example.com/#").fragment == ""
+      assert URI.parse("http://example.com/test#").fragment == ""
+    end
+
+    test "preserves an empty query" do
+      assert URI.parse("http://foo.com/?").query == ""
+    end
+
+    test "merges empty path" do
+      base = URI.parse("http://example.com")
+      assert URI.merge(base, "/foo") |> to_string() == "http://example.com/foo"
+      assert URI.merge(base, "foo") |> to_string() == "http://example.com/foo"
+    end
   end
 end
diff --git a/lib/elixir/test/elixir/version_test.exs b/lib/elixir/test/elixir/version_test.exs
index 04c96b5d08f..208f625f226 100644
--- a/lib/elixir/test/elixir/version_test.exs
+++ b/lib/elixir/test/elixir/version_test.exs
@@ -1,199 +1,348 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule VersionTest do
-  use   ExUnit.Case, async: true
-  alias Version.Parser, as: P
-  alias Version, as: V
-
-  test "compare" do
-    assert :gt == V.compare("1.0.1",     "1.0.0")
-    assert :gt == V.compare("1.1.0",     "1.0.1")
-    assert :gt == V.compare("2.1.1",     "1.2.2")
-    assert :gt == V.compare("1.0.0",     "1.0.0-dev")
-    assert :gt == V.compare("1.2.3-dev", "0.1.2")
-    assert :gt == V.compare("1.0.0-a.b", "1.0.0-a")
-    assert :gt == V.compare("1.0.0-b",   "1.0.0-a.b")
-    assert :gt == V.compare("1.0.0-a",   "1.0.0-0")
-    assert :gt == V.compare("1.0.0-a.b", "1.0.0-a.a")
-
-    assert :lt == V.compare("1.0.0",     "1.0.1")
-    assert :lt == V.compare("1.0.1",     "1.1.0")
-    assert :lt == V.compare("1.2.2",     "2.1.1")
-    assert :lt == V.compare("1.0.0-dev", "1.0.0")
-    assert :lt == V.compare("0.1.2",     "1.2.3-dev")
-    assert :lt == V.compare("1.0.0-a",   "1.0.0-a.b")
-    assert :lt == V.compare("1.0.0-a.b", "1.0.0-b")
-    assert :lt == V.compare("1.0.0-0",   "1.0.0-a")
-    assert :lt == V.compare("1.0.0-a.a", "1.0.0-a.b")
-
-    assert :eq == V.compare("1.0.0",     "1.0.0")
-    assert :eq == V.compare("1.0.0-dev", "1.0.0-dev")
-    assert :eq == V.compare("1.0.0-a",   "1.0.0-a")
-  end
-
-  test "invalid compare" do
-    assert_raise V.InvalidVersionError, fn ->
-      V.compare("1.0", "1.0.0")
+  use ExUnit.Case, async: true
+
+  doctest Version
+
+  alias Version.Parser
+
+  test "compare/2 with valid versions" do
+    assert Version.compare("1.0.1", "1.0.0") == :gt
+    assert Version.compare("1.1.0", "1.0.1") == :gt
+    assert Version.compare("2.1.1", "1.2.2") == :gt
+    assert Version.compare("1.0.0", "1.0.0-dev") == :gt
+    assert Version.compare("1.2.3-dev", "0.1.2") == :gt
+    assert Version.compare("1.0.0-a.b", "1.0.0-a") == :gt
+    assert Version.compare("1.0.0-b", "1.0.0-a.b") == :gt
+    assert Version.compare("1.0.0-a", "1.0.0-0") == :gt
+    assert Version.compare("1.0.0-a.b", "1.0.0-a.a") == :gt
+
+    assert Version.compare("1.0.0", "1.0.1") == :lt
+    assert Version.compare("1.0.1", "1.1.0") == :lt
+    assert Version.compare("1.2.2", "2.1.1") == :lt
+    assert Version.compare("1.0.0-dev", "1.0.0") == :lt
+    assert Version.compare("0.1.2", "1.2.3-dev") == :lt
+    assert Version.compare("1.0.0-a", "1.0.0-a.b") == :lt
+    assert Version.compare("1.0.0-a.b", "1.0.0-b") == :lt
+    assert Version.compare("1.0.0-0", "1.0.0-a") == :lt
+    assert Version.compare("1.0.0-a.a", "1.0.0-a.b") == :lt
+
+    assert Version.compare("1.0.0", "1.0.0") == :eq
+    assert Version.compare("1.0.0-dev", "1.0.0-dev") == :eq
+    assert Version.compare("1.0.0-a", "1.0.0-a") == :eq
+    assert Version.compare("1.5.0-rc.0", "1.5.0-rc0") == :lt
+  end
+
+  test "compare/2 with invalid versions" do
+    assert_raise Version.InvalidVersionError, fn ->
+      Version.compare("1.0", "1.0.0")
     end
 
-    assert_raise V.InvalidVersionError, fn ->
-      V.compare("1.0.0-dev", "1.0")
+    assert_raise Version.InvalidVersionError, fn ->
+      Version.compare("1.0.0-dev", "1.0")
     end
 
-    assert_raise V.InvalidVersionError, fn ->
-      V.compare("foo", "1.0.0-a")
+    assert_raise Version.InvalidVersionError, fn ->
+      Version.compare("foo", "1.0.0-a")
     end
   end
 
   test "lexes specifications properly" do
-    assert P.lexer("== != > >= < <= ~>", []) == [:'==', :'!=', :'>', :'>=', :'<', :'<=', :'~>']
-    assert P.lexer("2.3.0", [])              == [:'==', "2.3.0"]
-    assert P.lexer("!2.3.0", [])             == [:'!=', "2.3.0"]
-    assert P.lexer(">>=", [])                == [:'>', :'>=']
-    assert P.lexer(">2.4.0", [])             == [:'>', "2.4.0"]
-    assert P.lexer("    >     2.4.0", [])    == [:'>', "2.4.0"]
+    assert Parser.lexer("== > >= < <= ~>") |> Enum.reverse() == [:==, :>, :>=, :<, :<=, :~>]
+    assert Parser.lexer("2.3.0") |> Enum.reverse() == [:==, "2.3.0"]
+    assert Parser.lexer(">>=") |> Enum.reverse() == [:>, :>=]
+    assert Parser.lexer(">2.4.0") |> Enum.reverse() == [:>, "2.4.0"]
+    assert Parser.lexer("> 2.4.0") |> Enum.reverse() == [:>, "2.4.0"]
+    assert Parser.lexer("    >     2.4.0") |> Enum.reverse() == [:>, "2.4.0"]
+    assert Parser.lexer(" or 2.1.0") |> Enum.reverse() == [:or, :==, "2.1.0"]
+    assert Parser.lexer(" and 2.1.0") |> Enum.reverse() == [:and, :==, "2.1.0"]
+
+    assert Parser.lexer(">= 2.0.0 and < 2.1.0") |> Enum.reverse() ==
+             [:>=, "2.0.0", :and, :<, "2.1.0"]
+
+    assert Parser.lexer(">= 2.0.0 or < 2.1.0") |> Enum.reverse() ==
+             [:>=, "2.0.0", :or, :<, "2.1.0"]
   end
 
-  test "parse" do
-    assert {:ok, %V{major: 1, minor: 2, patch: 3}} = V.parse("1.2.3")
-    assert {:ok, %V{major: 1, minor: 4, patch: 5}} = V.parse("1.4.5+ignore")
-    assert {:ok, %V{major: 1, minor: 4, patch: 5, pre: ["6-g3318bd5"]}} = V.parse("1.4.5-6-g3318bd5")
-    assert {:ok, %V{major: 1, minor: 4, patch: 5, pre: [6, 7, "eight"]}} = V.parse("1.4.5-6.7.eight")
-    assert {:ok, %V{major: 1, minor: 4, patch: 5, pre: ["6-g3318bd5"]}} = V.parse("1.4.5-6-g3318bd5+ignore")
+  test "parse/1" do
+    assert {:ok, %Version{major: 1, minor: 2, patch: 3}} = Version.parse("1.2.3")
+
+    assert {:ok, %Version{major: 1, minor: 4, patch: 5, build: "ignore"}} =
+             Version.parse("1.4.5+ignore")
+
+    assert {:ok, %Version{major: 0, minor: 0, patch: 1, build: "sha.0702245"}} =
+             Version.parse("0.0.1+sha.0702245")
+
+    assert {:ok, %Version{major: 1, minor: 4, patch: 5, pre: ["6-g3318bd5"]}} =
+             Version.parse("1.4.5-6-g3318bd5")
+
+    assert {:ok, %Version{major: 1, minor: 4, patch: 5, pre: [6, 7, "eight"]}} =
+             Version.parse("1.4.5-6.7.eight")
+
+    assert {:ok, %Version{major: 1, minor: 4, patch: 5, pre: ["6-g3318bd5"]}} =
+             Version.parse("1.4.5-6-g3318bd5+ignore")
+
+    assert Version.parse("foobar") == :error
+    assert Version.parse("2") == :error
+    assert Version.parse("2.") == :error
+    assert Version.parse("2.3") == :error
+    assert Version.parse("2.3.") == :error
+    assert Version.parse("2.3.0-") == :error
+    assert Version.parse("2.3.0+") == :error
+    assert Version.parse("2.3.0.") == :error
+    assert Version.parse("2.3.0.4") == :error
+    assert Version.parse("2.3.-rc.1") == :error
+    assert Version.parse("2.3.+rc.1") == :error
+    assert Version.parse("2.3.0-01") == :error
+    assert Version.parse("2.3.00-1") == :error
+    assert Version.parse("2.3.00") == :error
+    assert Version.parse("2.03.0") == :error
+    assert Version.parse("02.3.0") == :error
+    assert Version.parse("0. 0.0") == :error
+    assert Version.parse("0.1.0-&&pre") == :error
+  end
 
-    assert :error = V.parse("foobar")
-    assert :error = V.parse("2.3")
-    assert :error = V.parse("2")
-    assert :error = V.parse("2.3.0-01")
+  test "to_string/1" do
+    assert Version.parse!("1.0.0") |> Version.to_string() == "1.0.0"
+    assert Version.parse!("1.0.0-dev") |> Version.to_string() == "1.0.0-dev"
+    assert Version.parse!("1.0.0+lol") |> Version.to_string() == "1.0.0+lol"
+    assert Version.parse!("1.0.0-dev+lol") |> Version.to_string() == "1.0.0-dev+lol"
+    assert Version.parse!("1.0.0-dev+lol.4") |> Version.to_string() == "1.0.0-dev+lol.4"
+    assert Version.parse!("1.0.0-0") |> Version.to_string() == "1.0.0-0"
+    assert Version.parse!("1.0.0-rc.0") |> Version.to_string() == "1.0.0-rc.0"
+    assert %Version{major: 1, minor: 0, patch: 0} |> Version.to_string() == "1.0.0"
   end
 
-  test "to_string" do
-    assert V.parse("1.0.0") |> elem(1) |> to_string == "1.0.0"
-    assert V.parse("1.0.0-dev") |> elem(1) |> to_string == "1.0.0-dev"
-    assert V.parse("1.0.0+lol") |> elem(1) |> to_string == "1.0.0+lol"
-    assert V.parse("1.0.0-dev+lol") |> elem(1) |> to_string == "1.0.0-dev+lol"
+  test "to_string/1 via protocol" do
+    assert Version.parse!("1.0.0") |> to_string() == "1.0.0"
   end
 
-  test "invalid match" do
-    assert_raise V.InvalidVersionError, fn ->
-      V.match?("foo", "2.3.0")
+  test "inspect/1" do
+    assert Version.parse!("1.0.0") |> inspect() == "%Version{major: 1, minor: 0, patch: 0}"
+  end
+
+  test "match?/2 with invalid versions" do
+    assert_raise Version.InvalidVersionError, fn ->
+      Version.match?("foo", "2.3.0")
     end
 
-    assert_raise V.InvalidVersionError, fn ->
-      V.match?("2.3", "2.3.0")
+    assert_raise Version.InvalidVersionError, fn ->
+      Version.match?("2.3", "2.3.0")
     end
 
-    assert_raise V.InvalidRequirementError, fn ->
-      V.match?("2.3.0", "foo")
+    assert_raise Version.InvalidRequirementError, fn ->
+      Version.match?("2.3.0", "foo")
     end
 
-    assert_raise V.InvalidRequirementError, fn ->
-      V.match?("2.3.0", "2.3")
+    assert_raise Version.InvalidRequirementError, fn ->
+      Version.match?("2.3.0", "2.3")
     end
   end
 
   test "==" do
-    assert V.match?("2.3.0", "2.3.0")
-    refute V.match?("2.4.0", "2.3.0")
+    assert Version.match?("2.3.0", "2.3.0")
+    refute Version.match?("2.4.0", "2.3.0")
+
+    assert Version.match?("2.3.0", "== 2.3.0")
+    refute Version.match?("2.4.0", "== 2.3.0")
 
-    assert V.match?("2.3.0", "== 2.3.0")
-    refute V.match?("2.4.0", "== 2.3.0")
+    assert Version.match?("1.0.0", "1.0.0")
+    assert Version.match?("1.0.0", "1.0.0")
 
-    assert V.match?("1.0.0", "1.0.0")
-    assert V.match?("1.0.0", "1.0.0")
+    assert Version.match?("1.2.3-alpha", "1.2.3-alpha")
 
-    assert V.match?("1.2.3-alpha", "1.2.3-alpha")
+    assert Version.match?("0.9.3", "== 0.9.3+dev")
 
-    assert V.match?("0.9.3", "== 0.9.3+dev")
+    {:ok, vsn} = Version.parse("2.3.0")
+    assert Version.match?(vsn, "2.3.0")
   end
 
   test "!=" do
-    assert V.match?("2.4.0", "!2.3.0")
-    refute V.match?("2.3.0", "!2.3.0")
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      assert Version.match?("2.4.0", "!2.3.0")
+      refute Version.match?("2.3.0", "!2.3.0")
 
-    assert V.match?("2.4.0", "!= 2.3.0")
-    refute V.match?("2.3.0", "!= 2.3.0")
+      assert Version.match?("2.4.0", "!= 2.3.0")
+      refute Version.match?("2.3.0", "!= 2.3.0")
+    end)
   end
 
   test ">" do
-    assert V.match?("2.4.0", "> 2.3.0")
-    refute V.match?("2.2.0", "> 2.3.0")
-    refute V.match?("2.3.0", "> 2.3.0")
-
-    assert V.match?("1.2.3", "> 1.2.3-alpha")
-    assert V.match?("1.2.3-alpha.1", "> 1.2.3-alpha")
-    assert V.match?("1.2.3-alpha.beta.sigma", "> 1.2.3-alpha.beta")
-    refute V.match?("1.2.3-alpha.10", "< 1.2.3-alpha.1")
-    refute V.match?("0.10.2-dev", "> 0.10.2")
+    assert Version.match?("2.4.0", "> 2.3.0")
+    refute Version.match?("2.2.0", "> 2.3.0")
+    refute Version.match?("2.3.0", "> 2.3.0")
+
+    assert Version.match?("1.2.3", "> 1.2.3-alpha")
+    assert Version.match?("1.2.3-alpha.1", "> 1.2.3-alpha")
+    assert Version.match?("1.2.3-alpha.beta.sigma", "> 1.2.3-alpha.beta")
+    refute Version.match?("1.2.3-alpha.10", "< 1.2.3-alpha.1")
+    refute Version.match?("0.10.2-dev", "> 0.10.2")
+
+    refute Version.match?("1.5.0-rc.0", "> 1.5.0-rc0")
+    assert Version.match?("1.5.0-rc0", "> 1.5.0-rc.0")
   end
 
   test ">=" do
-    assert V.match?("2.4.0", ">= 2.3.0")
-    refute V.match?("2.2.0", ">= 2.3.0")
-    assert V.match?("2.3.0", ">= 2.3.0")
+    assert Version.match?("2.4.0", ">= 2.3.0")
+    refute Version.match?("2.2.0", ">= 2.3.0")
+    assert Version.match?("2.3.0", ">= 2.3.0")
+
+    assert Version.match?("2.0.0", ">= 1.0.0")
+    assert Version.match?("1.0.0", ">= 1.0.0")
 
-    assert V.match?("2.0.0", ">= 1.0.0")
-    assert V.match?("1.0.0", ">= 1.0.0")
+    refute Version.match?("1.5.0-rc.0", ">= 1.5.0-rc0")
+    assert Version.match?("1.5.0-rc0", ">= 1.5.0-rc.0")
   end
 
   test "<" do
-    assert V.match?("2.2.0", "< 2.3.0")
-    refute V.match?("2.4.0", "< 2.3.0")
-    refute V.match?("2.3.0", "< 2.3.0")
+    assert Version.match?("2.2.0", "< 2.3.0")
+    refute Version.match?("2.4.0", "< 2.3.0")
+    refute Version.match?("2.3.0", "< 2.3.0")
 
-    assert V.match?("0.10.2-dev", "< 0.10.2")
+    assert Version.match?("0.10.2-dev", "< 0.10.2")
 
-    refute V.match?("1.0.0", "< 1.0.0-dev")
-    refute V.match?("1.2.3-dev", "< 0.1.2")
+    refute Version.match?("1.0.0", "< 1.0.0-dev")
+    refute Version.match?("1.2.3-dev", "< 0.1.2")
   end
 
   test "<=" do
-    assert V.match?("2.2.0", "<= 2.3.0")
-    refute V.match?("2.4.0", "<= 2.3.0")
-    assert V.match?("2.3.0", "<= 2.3.0")
+    assert Version.match?("2.2.0", "<= 2.3.0")
+    refute Version.match?("2.4.0", "<= 2.3.0")
+    assert Version.match?("2.3.0", "<= 2.3.0")
   end
 
-  test "~>" do
-    assert V.match?("3.0.0", "~> 3.0")
-    assert V.match?("3.2.0", "~> 3.0")
-    refute V.match?("4.0.0", "~> 3.0")
-    refute V.match?("4.4.0", "~> 3.0")
-
-    assert V.match?("3.0.2", "~> 3.0.0")
-    assert V.match?("3.0.0", "~> 3.0.0")
-    refute V.match?("3.1.0", "~> 3.0.0")
-    refute V.match?("3.4.0", "~> 3.0.0")
-
-    assert V.match?("3.6.0", "~> 3.5")
-    assert V.match?("3.5.0", "~> 3.5")
-    refute V.match?("4.0.0", "~> 3.5")
-    refute V.match?("5.0.0", "~> 3.5")
-
-    assert V.match?("3.5.2", "~> 3.5.0")
-    assert V.match?("3.5.4", "~> 3.5.0")
-    refute V.match?("3.6.0", "~> 3.5.0")
-    refute V.match?("3.6.3", "~> 3.5.0")
-
-    assert V.match?("0.9.3", "~> 0.9.3-dev")
-    refute V.match?("0.10.0", "~> 0.9.3-dev")
-
-    refute V.match?("0.3.0-dev", "~> 0.2.0")
+  describe "~>" do
+    test "regular cases" do
+      assert Version.match?("3.0.0", "~> 3.0")
+      assert Version.match?("3.2.0", "~> 3.0")
+      refute Version.match?("4.0.0", "~> 3.0")
+      refute Version.match?("4.4.0", "~> 3.0")
+
+      assert Version.match?("3.0.2", "~> 3.0.0")
+      assert Version.match?("3.0.0", "~> 3.0.0")
+      refute Version.match?("3.1.0", "~> 3.0.0")
+      refute Version.match?("3.4.0", "~> 3.0.0")
+
+      assert Version.match?("3.6.0", "~> 3.5")
+      assert Version.match?("3.5.0", "~> 3.5")
+      refute Version.match?("4.0.0", "~> 3.5")
+      refute Version.match?("5.0.0", "~> 3.5")
+
+      assert Version.match?("3.5.2", "~> 3.5.0")
+      assert Version.match?("3.5.4", "~> 3.5.0")
+      refute Version.match?("3.6.0", "~> 3.5.0")
+      refute Version.match?("3.6.3", "~> 3.5.0")
+
+      assert Version.match?("0.9.3", "~> 0.9.3-dev")
+      refute Version.match?("0.10.0", "~> 0.9.3-dev")
+
+      refute Version.match?("0.3.0-dev", "~> 0.2.0")
+
+      assert Version.match?("1.11.0-dev", "~> 1.11-dev")
+      assert Version.match?("1.11.0", "~> 1.11-dev")
+      assert Version.match?("1.12.0", "~> 1.11-dev")
+      refute Version.match?("1.10.0", "~> 1.11-dev")
+      refute Version.match?("2.0.0", "~> 1.11-dev")
+
+      refute Version.match?("1.5.0-rc.0", "~> 1.5.0-rc0")
+      assert Version.match?("1.5.0-rc0", "~> 1.5.0-rc.0")
+
+      assert_raise Version.InvalidRequirementError, fn ->
+        Version.match?("3.0.0", "~> 3")
+      end
+    end
 
-    assert_raise V.InvalidRequirementError, fn ->
-      V.match?("3.0.0", "~> 3")
+    test "~> will never include pre-release versions of its upper bound" do
+      refute Version.match?("2.2.0-dev", "~> 2.1.0")
+      refute Version.match?("2.2.0-dev", "~> 2.1.0", allow_pre: false)
+      refute Version.match?("2.2.0-dev", "~> 2.1.0-dev")
+      refute Version.match?("2.2.0-dev", "~> 2.1.0-dev", allow_pre: false)
     end
   end
 
+  test "allow_pre" do
+    assert Version.match?("1.1.0", "~> 1.0", allow_pre: true)
+    assert Version.match?("1.1.0", "~> 1.0", allow_pre: false)
+    assert Version.match?("1.1.0-beta", "~> 1.0", allow_pre: true)
+    refute Version.match?("1.1.0-beta", "~> 1.0", allow_pre: false)
+    assert Version.match?("1.0.1-beta", "~> 1.0.0-beta", allow_pre: false)
+
+    assert Version.match?("1.1.0", ">= 1.0.0", allow_pre: true)
+    assert Version.match?("1.1.0", ">= 1.0.0", allow_pre: false)
+    assert Version.match?("1.1.0-beta", ">= 1.0.0", allow_pre: true)
+    refute Version.match?("1.1.0-beta", ">= 1.0.0", allow_pre: false)
+    assert Version.match?("1.1.0-beta", ">= 1.0.0-beta", allow_pre: false)
+  end
+
   test "and" do
-    assert V.match?("0.9.3", "> 0.9.0 and < 0.10.0")
-    refute V.match?("0.10.2", "> 0.9.0 and < 0.10.0")
+    assert Version.match?("0.9.3", "> 0.9.0 and < 0.10.0")
+    refute Version.match?("0.10.2", "> 0.9.0 and < 0.10.0")
   end
 
   test "or" do
-    assert V.match?("0.9.1", "0.9.1 or 0.9.3 or 0.9.5")
-    assert V.match?("0.9.3", "0.9.1 or 0.9.3 or 0.9.5")
-    assert V.match?("0.9.5", "0.9.1 or 0.9.3 or 0.9.5")
+    assert Version.match?("0.9.1", "0.9.1 or 0.9.3 or 0.9.5")
+    assert Version.match?("0.9.3", "0.9.1 or 0.9.3 or 0.9.5")
+    assert Version.match?("0.9.5", "0.9.1 or 0.9.3 or 0.9.5")
+    refute Version.match?("0.9.6", "0.9.1 or 0.9.3 or 0.9.5")
+  end
+
+  test "and/or" do
+    req = "< 0.2.0 and >= 0.1.0 or >= 0.7.0"
+    assert Version.match?("0.1.0", req)
+    assert Version.match?("0.1.5", req)
+    refute Version.match?("0.3.0", req)
+    refute Version.match?("0.6.0", req)
+    assert Version.match?("0.7.0", req)
+    assert Version.match?("0.7.5", req)
+
+    req = ">= 0.7.0 or < 0.2.0 and >= 0.1.0"
+    assert Version.match?("0.1.0", req)
+    assert Version.match?("0.1.5", req)
+    refute Version.match?("0.3.0", req)
+    refute Version.match?("0.6.0", req)
+    assert Version.match?("0.7.0", req)
+    assert Version.match?("0.7.5", req)
+
+    req = "< 0.2.0 and >= 0.1.0 or < 0.8.0 and >= 0.7.0"
+    assert Version.match?("0.1.0", req)
+    assert Version.match?("0.1.5", req)
+    refute Version.match?("0.3.0", req)
+    refute Version.match?("0.6.0", req)
+    assert Version.match?("0.7.0", req)
+    assert Version.match?("0.7.5", req)
+
+    req = "== 0.2.0 or >= 0.3.0 and < 0.4.0 or == 0.7.0"
+    assert Version.match?("0.2.0", req)
+    refute Version.match?("0.2.5", req)
+    assert Version.match?("0.3.0", req)
+    assert Version.match?("0.3.5", req)
+    refute Version.match?("0.4.0", req)
+    assert Version.match?("0.7.0", req)
+  end
+
+  describe "requirement" do
+    test "compile_requirement/1" do
+      {:ok, req} = Version.parse_requirement("1.2.3")
+      assert req == Version.compile_requirement(req)
+
+      assert Version.match?("1.2.3", req)
+      refute Version.match?("1.2.4", req)
 
-    refute V.match?("0.9.6", "0.9.1 or 0.9.3 or 0.9.5")
+      assert Version.parse_requirement("1 . 2 . 3") == :error
+      assert Version.parse_requirement("== >= 1.2.3") == :error
+      assert Version.parse_requirement("1.2.3 and or 4.5.6") == :error
+      assert Version.parse_requirement(">= 1") == :error
+      assert Version.parse_requirement("1.2.3 >=") == :error
+    end
+
+    test "inspect/1" do
+      assert Version.parse_requirement!("1.0.0") |> inspect() ==
+               "Version.parse_requirement!(\"1.0.0\")"
+    end
   end
 end
diff --git a/lib/elixir/test/erlang/atom_test.erl b/lib/elixir/test/erlang/atom_test.erl
index 3b84b90fb44..064e4331703 100644
--- a/lib/elixir/test/erlang/atom_test.erl
+++ b/lib/elixir/test/erlang/atom_test.erl
@@ -1,42 +1,46 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(atom_test).
 -export([kv/1]).
--include("elixir.hrl").
 -include_lib("eunit/include/eunit.hrl").
 
 eval(Content) ->
-  {Value, Binding, _, _} = elixir:eval(Content, []),
+  Quoted = elixir:'string_to_quoted!'(Content, 1, 1, <<"nofile">>, []),
+  {Value, Binding, _} = elixir:eval_forms(Quoted, [], elixir:env_for_eval([])),
   {Value, Binding}.
 
-kv([{Key,nil}]) -> Key.
+kv([{Key, nil}]) -> Key.
 
 atom_with_punctuation_test() ->
-  {foo@bar,[]} = eval(":foo@bar"),
-  {'a?',[]} = eval(":a?"),
-  {'a!',[]} = eval(":a!"),
-  {'||',[]} = eval(":||"),
-  {'...',[]} = eval(":...").
+  {foo@bar, []} = eval(":foo@bar"),
+  {'a?', []} = eval(":a?"),
+  {'a!', []} = eval(":a!"),
+  {'||', []} = eval(":||"),
+  {'...', []} = eval(":...").
 
 atom_quoted_call_test() ->
-  {3,[]} = eval("Kernel.'+'(1, 2)").
+  {3, []} = eval("Kernel.\"+\"(1, 2)").
 
 kv_with_quotes_test() ->
-  {'foo bar',[]} = eval(":atom_test.kv(\"foo bar\": nil)").
+  {'foo bar', []} = eval(":atom_test.kv(\"foo bar\": nil)").
 
 kv_with_interpolation_test() ->
-  {'foo',[]} = eval(":atom_test.kv(\"#{\"foo\"}\": nil)"),
-  {'foo',[]} = eval(":atom_test.kv(\"#{\"fo\"}o\": nil)"),
-  {'foo',_} = eval("a = \"f\"; :atom_test.kv(\"#{a}#{\"o\"}o\": nil)").
+  {'foo', []} = eval(":atom_test.kv(\"#{\"foo\"}\": nil)"),
+  {'foo', []} = eval(":atom_test.kv(\"#{\"fo\"}o\": nil)"),
+  {'foo', _} = eval("a = \"f\"; :atom_test.kv(\"#{a}#{\"o\"}o\": nil)").
 
 quoted_atom_test() ->
-  {foo,[]} = eval(":\"foo\""),
-  {foo,[]} = eval(":'foo'").
+  {'+', []} = eval(":\"+\""),
+  {'foo bar', []} = eval(":\"foo bar\"").
 
 atom_with_interpolation_test() ->
-  {foo,[]} = eval(":\"f#{\"o\"}o\""),
-  {foo,_}  = eval("a=\"foo\"; :\"#{a}\""),
-  {foo,_}  = eval("a=\"oo\"; :\"f#{a}\""),
-  {foo,_}  = eval("a=\"fo\"; :\"#{a}o\""),
-  {fof,_}  = eval("a=\"f\"; :\"#{a}o#{a}\"").
+  {foo, []} = eval(":\"f#{\"o\"}o\""),
+  {foo, _}  = eval("a=\"foo\"; :\"#{a}\""),
+  {foo, _}  = eval("a=\"oo\"; :\"f#{a}\""),
+  {foo, _}  = eval("a=\"fo\"; :\"#{a}o\""),
+  {fof, _}  = eval("a=\"f\"; :\"#{a}o#{a}\"").
 
 quoted_atom_chars_are_escaped_test() ->
-  {'"',[]} = eval(":\"\\\"\"").
+  {'"', []} = eval(":\"\\\"\"").
diff --git a/lib/elixir/test/erlang/control_test.erl b/lib/elixir/test/erlang/control_test.erl
index de7fbac7fac..d4ced5df0a5 100644
--- a/lib/elixir/test/erlang/control_test.erl
+++ b/lib/elixir/test/erlang/control_test.erl
@@ -1,283 +1,265 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(control_test).
--include("elixir.hrl").
 -include_lib("eunit/include/eunit.hrl").
 
-eval(Content) ->
-  {Value, Binding, _, _} = elixir:eval(Content, []),
-  {Value, Binding}.
-
 to_erl(String) ->
-  Forms = elixir:'string_to_quoted!'(String, 1, <<"nofile">>, []),
-  {Expr, _, _} = elixir:quoted_to_erl(Forms, elixir:env_for_eval([])),
+  Forms = elixir:'string_to_quoted!'(String, 1, 1, <<"nofile">>, []),
+  {Expr, _, _, _} = elixir:quoted_to_erl(Forms, elixir:env_for_eval([])),
   Expr.
 
-% Booleans
-
-booleans_test() ->
-  {nil, _} = eval("nil"),
-  {true, _} = eval("true"),
-  {false, _} = eval("false").
-
-% If
-
-if_else_kv_args_test() ->
-  {1, _} = eval("if(true, do: 1)"),
-  {nil, _} = eval("if(false, do: 1)"),
-  {2, _} = eval("if(false, do: 1, else: 2)").
-
-if_else_kv_blocks_test() ->
-  {2, _} = eval("if(false) do\n1\nelse\n2\nend"),
-  {2, _} = eval("if(false) do\n1\n3\nelse\n2\nend"),
-  {2, _} = eval("if(false) do 1 else 2 end"),
-  {2, _} = eval("if(false) do 1;else 2; end"),
-  {3, _} = eval("if(false) do 1;else 2; 3; end").
-
-vars_if_test() ->
-  F = fun() ->
-    {1, [{foo,1}]} = eval("if foo = 1 do; true; else false; end; foo"),
-    eval("defmodule Bar do\ndef foo, do: 1\ndef bar(x) do\nif x do; foo = 2; else foo = foo; end; foo; end\nend"),
-    {1, _} = eval("Bar.bar(false)"),
-    {2, _} = eval("Bar.bar(true)")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Bar']).
-
-multi_assigned_if_test() ->
-  {3, _} = eval("x = 1\nif true do\nx = 2\nx = 3\nelse true\nend\nx"),
-  {3, _} = eval("x = 1\nif true do\n^x = 1\nx = 2\nx = 3\nelse true\nend\nx"),
-  {1, _} = eval("if true do\nx = 1\nelse true\nend\nx"),
-  {nil, _} = eval("if false do\nx = 1\nelse true\nend\nx").
-
-multi_line_if_test() ->
-  {1, _} = eval("if true\ndo\n1\nelse\n2\nend").
-
-% Try
-
-try_test() ->
-  {2, _} = eval("try do\n:foo.bar\ncatch\n:error, :undef -> 2\nend").
-
-try_else_test() ->
-  {true, _} = eval("try do\n1\nelse 2 -> false\n1 -> true\nrescue\nErlangError -> nil\nend"),
-  {true, _} = eval("try do\n1\nelse {x,y} -> false\nx -> true\nrescue\nErlangError -> nil\nend"),
-  {true, _} = eval("try do\n{1,2}\nelse {3,4} -> false\n_ -> true\nrescue\nErlangError -> nil\nend").
-
-% Receive
-
-receive_test() ->
-  {10, _} = eval("send self(), :foo\nreceive do\n:foo -> 10\nend"),
-  {20, _} = eval("send self(), :bar\nreceive do\n:foo -> 10\n_ -> 20\nend"),
-  {30, _} = eval("receive do\nafter 1 -> 30\nend").
-
-vars_receive_test() ->
-  {10, _} = eval("send self(), :foo\nreceive do\n:foo ->\na = 10\n:bar -> nil\nend\na"),
-  {nil, _} = eval("send self(), :bar\nreceive do\n:foo ->\nb = 10\n_ -> 20\nend\nb"),
-  {30, _} = eval("receive do\n:foo -> nil\nafter\n1 -> c = 30\nend\nc"),
-  {30, _} = eval("x = 1\nreceive do\n:foo -> nil\nafter\nx -> c = 30\nend\nc").
-
-% Case
-
-case_test() ->
-  {true, []} = eval("case 1 do\n2 -> false\n1 -> true\nend"),
-  {true, []} = eval("case 1 do\n{x,y} -> false\nx -> true\nend"),
-  {true, []} = eval("case {1,2} do;{3,4} -> false\n_ -> true\nend").
-
-case_with_do_ambiguity_test() ->
-  {true,_} = eval("case Atom.to_char_list(true) do\n_ -> true\nend").
+cond_line_test() ->
+  {'case', 1, _,
+    [{clause, 2, _, _, _},
+     {clause, 3, _, _, _}]
+  } = to_erl("cond do\n  1 -> :ok\n  2 -> :ok\nend").
 
-case_with_match_do_ambiguity_test() ->
-  {true,_} = eval("case x = Atom.to_char_list(true) do\n_ -> true\nend").
-
-case_with_unary_do_ambiguity_test() ->
-  {false,_} = eval("! case Atom.to_char_list(true) do\n_ -> true\nend").
-
-multi_assigned_case_test() ->
-  {3, _} = eval("x = 1\ncase true do\n true ->\nx = 2\nx = 3\n_ -> true\nend\nx"),
-  {3, _} = eval("x = 1\ncase 1 do\n ^x -> x = 2\nx = 3\n_ -> true\nend\nx"),
-  {1, _} = eval("case true do\ntrue -> x = 1\n_ -> true\nend\nx"),
-  {nil, _} = eval("case true do\nfalse -> x = 1\n_ -> true\nend\nx").
-
-vars_case_test() ->
-  F = fun() ->
-    eval("defmodule Bar do\ndef foo, do: 1\ndef bar(x) do\ncase x do\ntrue -> foo = 2\nfalse -> foo = foo\nend\nfoo\nend\nend"),
-    {1, _} = eval("Bar.bar(false)"),
-    {2, _} = eval("Bar.bar(true)")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Bar']).
-
-% Comparison
-
-equal_test() ->
-  {true,_} = eval(":a == :a"),
-  {true,_} = eval("1 == 1"),
-  {true,_} = eval("{1,2} == {1,2}"),
-  {false,_} = eval("1 == 2"),
-  {false,_} = eval("{1,2} == {1,3}").
-
-not_equal_test() ->
-  {false,_} = eval(":a != :a"),
-  {false,_} = eval("1 != 1"),
-  {false,_} = eval("{1,2} != {1,2}"),
-  {true,_} = eval("1 != 2"),
-  {true,_} = eval("{1,2} != {1,3}").
-
-not_exclamation_mark_test() ->
-  {false,_} = eval("! :a"),
-  {false,_} = eval("!true"),
-  {false,_} = eval("!1"),
-  {false,_} = eval("![]"),
-  {true,_} = eval("!nil"),
-  {true,_} = eval("!false").
-
-notnot_exclamation_mark_test() ->
-  {true,_} = eval("!! :a"),
-  {true,_} = eval("!!true"),
-  {true,_} = eval("!!1"),
-  {true,_} = eval("!![]"),
-  {false,_} = eval("!!nil"),
-  {false,_} = eval("!!false").
-
-less_greater_test() ->
-  {true,_} = eval("1 < 2"),
-  {true,_} = eval("1 < :a"),
-  {false,_} = eval("1 < 1.0"),
-  {false,_} = eval("1 < 1"),
-  {true,_} = eval("1 <= 1.0"),
-  {true,_} = eval("1 <= 1"),
-  {true,_} = eval("1 <= :a"),
-  {false,_} = eval("1 > 2"),
-  {false,_} = eval("1 > :a"),
-  {false,_} = eval("1 > 1.0"),
-  {false,_} = eval("1 > 1"),
-  {true,_} = eval("1 >= 1.0"),
-  {true,_} = eval("1 >= 1"),
-  {false,_} = eval("1 >= :a").
-
-integer_and_float_test() ->
-  {true,_} = eval("1 == 1"),
-  {false,_} = eval("1 != 1"),
-  {true,_} = eval("1 == 1.0"),
-  {false,_} = eval("1 != 1.0"),
-  {true,_} = eval("1 === 1"),
-  {false,_} = eval("1 !== 1"),
-  {false,_} = eval("1 === 1.0"),
-  {true,_} = eval("1 !== 1.0").
-
-and_test() ->
-  F = fun() ->
-    eval("defmodule Bar do\ndef foo, do: true\ndef bar, do: false\n def baz(x), do: x == 1\nend"),
-    {true, _} = eval("true and true"),
-    {false, _} = eval("true and false"),
-    {false, _} = eval("false and true"),
-    {false, _} = eval("false and false"),
-    {true, _} = eval("Bar.foo and Bar.foo"),
-    {false, _} = eval("Bar.foo and Bar.bar"),
-    {true, _} = eval("Bar.foo and Bar.baz 1"),
-    {false, _} = eval("Bar.foo and Bar.baz 2"),
-    {true, _} = eval("false and false or true"),
-    {3, _} = eval("Bar.foo and 1 + 2"),
-    {false, _} = eval("Bar.bar and :erlang.error(:bad)"),
-    ?assertError({badarg, 1}, eval("1 and 2"))
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Bar']).
-
-or_test() ->
-  F = fun() ->
-    eval("defmodule Bar do\ndef foo, do: true\ndef bar, do: false\n def baz(x), do: x == 1\nend"),
-    {true, _} = eval("true or true"),
-    {true, _} = eval("true or false"),
-    {true, _} = eval("false or true"),
-    {false, _} = eval("false or false"),
-    {true, _} = eval("Bar.foo or Bar.foo"),
-    {true, _} = eval("Bar.foo or Bar.bar"),
-    {false, _} = eval("Bar.bar or Bar.bar"),
-    {true, _} = eval("Bar.bar or Bar.baz 1"),
-    {false, _} = eval("Bar.bar or Bar.baz 2"),
-    {3, _} = eval("Bar.bar or 1 + 2"),
-    {true, _} = eval("Bar.foo or :erlang.error(:bad)"),
-    ?assertError({badarg, 1}, eval("1 or 2"))
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Bar']).
-
-not_test() ->
-  {false, _} = eval("not true"),
-  {true, _} = eval("not false"),
-  ?assertError(badarg, eval("not 1")).
-
-andand_test() ->
-  F = fun() ->
-    eval("defmodule Bar do\ndef foo, do: true\ndef bar, do: false\n def baz(x), do: x == 1\nend"),
-    {true, _} = eval("Kernel.&&(true, true)"),
-    {true, _} = eval("true && true"),
-    {false, _} = eval("true && false"),
-    {false, _} = eval("false && true"),
-    {false, _} = eval("false && false"),
-    {nil, _} = eval("true && nil"),
-    {nil, _} = eval("nil && true"),
-    {false, _} = eval("false && nil"),
-    {true, _} = eval("Bar.foo && Bar.foo"),
-    {false, _} = eval("Bar.foo && Bar.bar"),
-    {true, _} = eval("Bar.foo && Bar.baz 1"),
-    {false, _} = eval("Bar.foo && Bar.baz 2"),
-    {true, _} = eval("1 == 1 && 2 < 3"),
-    {3, _} = eval("Bar.foo && 1 + 2"),
-    {false, _} = eval("Bar.bar && :erlang.error(:bad)"),
-    {2, _} = eval("1 && 2"),
-    {nil, _} = eval("nil && 2")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Bar']).
-
-andand_with_literal_test() ->
-  {[nil, nil, nil], _} = eval("[nil && 2, nil && 3, nil && 4]").
-
-oror_test() ->
-  F = fun() ->
-    eval("defmodule Bar do\ndef foo, do: true\ndef bar, do: false\n def baz(x), do: x == 1\nend"),
-    {true, _} = eval("Kernel.||(false, true)"),
-    {true, _} = eval("true || true"),
-    {true, _} = eval("true || false"),
-    {true, _} = eval("false || true"),
-    {false, _} = eval("false || false"),
-    {false, _} = eval("nil || false"),
-    {nil, _} = eval("false || nil"),
-    {true, _} = eval("false || nil || true"),
-    {true, _} = eval("Bar.foo || Bar.foo"),
-    {true, _} = eval("Bar.foo || Bar.bar"),
-    {false, _} = eval("Bar.bar || Bar.bar"),
-    {true, _} = eval("Bar.bar || Bar.baz 1"),
-    {false, _} = eval("Bar.bar || Bar.baz 2"),
-    {false, _} = eval("1 == 2 || 2 > 3"),
-    {3, _} = eval("Bar.bar || 1 + 2"),
-    {true, _} = eval("Bar.foo || :erlang.error(:bad)"),
-    {1, _} = eval("1 || 2"),
-    {2, _} = eval("nil || 2"),
-    {true, _} = eval("false && false || true")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Bar']).
+float_match_test() ->
+  {'case', _, _,
+    [{clause, _, [{op, _, '+', {float, _, +0.0}}], [], [{atom, _, pos}]},
+     {clause, _, [{op, _, '-', {float, _, +0.0}}], [], [{atom, _, neg}]}]
+  } = to_erl("case X do\n  +0.0 -> :pos\n  -0.0 -> :neg\nend").
 
 % Optimized
 
 optimized_if_test() ->
   {'case', _, _,
-    [{clause,_,[{atom,_,false}],[],[{atom,_,else}]},
-     {clause,_,[{atom,_,true}],[],[{atom,_,do}]}]
- } = to_erl("if is_list([]), do: :do, else: :else").
+    [{clause, _, [{atom, _, false}], [], [{atom, _, 'else'}]},
+     {clause, _, [{atom, _, true}], [], [{atom, _, do}]}]
+  } = to_erl("if is_list([]), do: :do, else: :else").
 
 optimized_andand_test() ->
   {'case', _, _,
-    [{clause,_,
-      [{var,_,Var}],
-      [[{op,_,'orelse',_,_}]],
-      [{var,_,Var}]},
-    {clause,_,[{var,_,'_'}],[],[{atom,0,done}]}]
- } = to_erl("is_list([]) && :done").
+    [{clause, _,
+      [{var, _, Var}],
+      [[{op, _, 'orelse', _, _}]],
+      [{var, _, Var}]},
+    {clause, _, [{var, _, '_'}], [], [{atom, 1, done}]}]
+  } = to_erl("is_list([]) && :done").
 
 optimized_oror_test() ->
   {'case', _, _,
-    [{clause,1,
-      [{var,1,_}],
-      [[{op,1,'orelse',_,_}]],
-      [{atom,0,done}]},
-    {clause,1,[{var,1,Var}],[],[{var,1,Var}]}]
- } = to_erl("is_list([]) || :done").
+    [{clause, 1,
+      [{var, 1, _}],
+      [[{op, 1, 'orelse', _, _}]],
+      [{atom, 1, done}]},
+    {clause, 1, [{var, 1, Var}], [], [{var, 1, Var}]}]
+  } = to_erl("is_list([]) || :done").
+
+optimized_and_test() ->
+  {'case',_, _,
+   [{clause, _, [{atom, _, false}], [], [{atom, _, false}]},
+    {clause, _, [{atom, _, true}], [], [{atom, _, done}]}]
+  } = to_erl("is_list([]) and :done").
+
+optimized_or_test() ->
+  {'case', _, _,
+    [{clause, _, [{atom, _, false}], [], [{atom, _, done}]},
+     {clause, _, [{atom, _, true}], [], [{atom, _, true}]}]
+  } = to_erl("is_list([]) or :done").
 
 no_after_in_try_test() ->
-  {'try', _, [_], [_], _, []} = to_erl("try do :foo.bar() else _ -> :ok end").
\ No newline at end of file
+  {'try', _, [_], [], [_], []} = to_erl("try do :foo.bar() catch _ -> :ok end").
+
+optimized_inspect_interpolation_test() ->
+    {bin, _,
+     [{bin_element, _,
+       {call, _, {remote, _,{atom, _, 'Elixir.Kernel'}, {atom, _, inspect}}, [_]},
+       default, [binary]}]} = to_erl("\"#{inspect(1)}\"").
+
+optimized_map_put_test() ->
+  {map, _,
+    [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}},
+     {map_field_assoc, _, {atom, _, b}, {integer, _, 2}}]
+  } = to_erl("Map.put(%{a: 1}, :b, 2)").
+
+optimized_map_put_variable_test() ->
+  {block, _,
+    [_,
+     {map, _, {var, _, _},
+       [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}}]
+     }]
+  } = to_erl("x = %{}; Map.put(x, :a, 1)").
+
+optimized_nested_map_put_variable_test() ->
+  {block, _,
+    [_,
+     {map, _, {var, _, _},
+       [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}},
+        {map_field_assoc, _, {atom, _, b}, {integer, _, 2}}]
+     }]
+  } = to_erl("x = %{}; Map.put(Map.put(x, :a, 1), :b, 2)").
+
+optimized_map_merge_test() ->
+  {map, _,
+    [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}},
+     {map_field_assoc, _, {atom, _, b}, {integer, _, 2}},
+     {map_field_assoc, _, {atom, _, c}, {integer, _, 3}}]
+  } = to_erl("Map.merge(%{a: 1, b: 2}, %{c: 3})").
+
+optimized_map_merge_variable_test() ->
+  {block, _,
+    [_,
+     {map, _, {var, _, _},
+       [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}}]
+     }]
+  } = to_erl("x = %{}; Map.merge(x, %{a: 1})").
+
+optimized_map_update_and_merge_test() ->
+  {block, _,
+    [_,
+     {map, _, {var, _, _},
+       [{map_field_exact, _, {atom, _, a}, {integer, _, 2}},
+        {map_field_assoc, _, {atom, _, b}, {integer, _, 3}}]
+     }]
+  } = to_erl("x = %{a: 1}; Map.merge(%{x | a: 2}, %{b: 3})"),
+  {block, _,
+    [_,
+     {call, _, {remote, _, {atom, _, maps}, {atom, _, merge}},
+       [{map, _,
+          [{map_field_assoc, _, {atom, _, a}, {integer, _, 2}}]},
+        {map, _, {var, _, _},
+          [{map_field_exact, _, {atom, _, b}, {integer, _, 3}}]}]
+     }]
+  } = to_erl("x = %{a: 1}; Map.merge(%{a: 2}, %{x | b: 3})").
+
+optimized_nested_map_merge_variable_test() ->
+  {block, _,
+    [_,
+     {map, _, {var, _, _},
+       [{map_field_assoc, _, {atom, _, a}, {integer, _, 1}},
+        {map_field_assoc, _, {atom, _, b}, {integer, _, 2}}]
+     }]
+  } = to_erl("x = %{}; Map.merge(Map.merge(x, %{a: 1}), %{b: 2})").
+
+optimized_map_set_new_test() ->
+  {map, _,
+    [
+      {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.MapSet'}},
+      {map_field_assoc, _,
+        {atom, _, map},
+        {map, _, [
+          {map_field_assoc, _, {integer, _, 1}, {nil, _}},
+          {map_field_assoc, _, {integer, _, 2}, {nil, _}},
+          {map_field_assoc, _, {integer, _, 3}, {nil, _}}
+        ]}
+      }
+    ]
+  } = to_erl("MapSet.new([1, 2, 3])").
+
+not_optimized_map_set_new_with_range_test() ->
+  {call, _,
+    {remote, _, {atom, _, 'Elixir.MapSet'}, {atom, _, new}}, [
+      {map, _, [
+        {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.Range'}},
+        {map_field_assoc, _, {atom, _, first}, {integer, _, 1}},
+        {map_field_assoc, _, {atom, _, last}, {integer, _, 3}},
+        {map_field_assoc, _, {atom, _, step}, {integer, _, 1}}
+      ]}
+    ]
+  } = to_erl("MapSet.new(1..3)").
+
+map_set_new_with_failing_args_test() ->
+  {call, _,
+    {remote, _, {atom, _, 'Elixir.MapSet'}, {atom, _, new}}, [
+      {atom, _, not_an_enumerable}
+    ]
+  } = to_erl("MapSet.new(:not_an_enumerable)").
+
+optimized_date_shift_duration_test() ->
+  {call, _,
+    {remote, _, {atom, _, 'Elixir.Date'}, {atom, _, shift}}, [
+      {atom, _, non_important},
+      {map, _, [
+        {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.Duration'}},
+        {map_field_assoc, _, {atom, _, day}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, hour}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, microsecond}, {tuple, _, [{integer, _, 0}, {integer, _, 0}]}},
+        {map_field_assoc, _, {atom, _, minute}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, month}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, second}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, week}, {integer, _, 1}},
+        {map_field_assoc, _, {atom, _, year}, {integer, _, 0}}
+      ]}
+    ]
+  } = to_erl("Date.shift(:non_important, week: 1)").
+
+not_optimized_date_shift_duration_unsupported_unit_test() ->
+  {call, _,
+    {remote, _, {atom, _, 'Elixir.Date'}, {atom, _, shift}}, [
+      {atom, _, non_important},
+      {cons, _, {tuple, _, [{atom, _, hour}, {integer, _, 1}]}, {nil, _}}
+    ]
+  } = to_erl("Date.shift(:non_important, hour: 1)").
+
+optimized_time_shift_duration_test() ->
+  {call, _,
+    {remote, _, {atom, _, 'Elixir.Time'}, {atom, _, shift}}, [
+      {atom, _, non_important},
+      {map, _, [
+        {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.Duration'}},
+        {map_field_assoc, _, {atom, _, day}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, hour}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, microsecond}, {tuple, _, [{integer, _, 0}, {integer, _, 0}]}},
+        {map_field_assoc, _, {atom, _, minute}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, month}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, second}, {integer, _, 2}},
+        {map_field_assoc, _, {atom, _, week}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, year}, {integer, _, 0}}
+      ]}
+    ]
+  } = to_erl("Time.shift(:non_important, second: 2)").
+
+not_optimized_time_shift_duration_unsupported_unit_test() ->
+  {call, _,
+    {remote, _, {atom, _, 'Elixir.Time'}, {atom, _, shift}}, [
+      {atom, _, non_important},
+      {cons, _, {tuple, _, [{atom, _, day}, {integer, _, 2}]}, {nil, _}}
+    ]
+  } = to_erl("Time.shift(:non_important, day: 2)").
+
+optimized_date_time_shift_duration_test() ->
+  {call, _,
+    {remote, _, {atom, _, 'Elixir.DateTime'}, {atom, _, shift}}, [
+      {atom, _, non_important},
+      {map, _, [
+        {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.Duration'}},
+        {map_field_assoc, _, {atom, _, day}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, hour}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, microsecond}, {tuple, _, [{integer, _, 0}, {integer, _, 0}]}},
+        {map_field_assoc, _, {atom, _, minute}, {integer, _, 3}},
+        {map_field_assoc, _, {atom, _, month}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, second}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, week}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, year}, {integer, _, 0}}
+      ]}
+    ]
+  } = to_erl("DateTime.shift(:non_important, minute: 3)").
+
+non_optimized_date_time_shift_duration_unknown_unit_test() ->
+  {call, _,
+    {remote, _, {atom, _, 'Elixir.DateTime'}, {atom, _, shift}}, [
+      {atom, _, non_important},
+      {cons, _, {tuple, _, [{atom, _, unknown}, {integer, _, 3}]}, {nil, _}}
+    ]
+  } = to_erl("DateTime.shift(:non_important, unknown: 3)").
+
+optimized_naive_date_time_shift_duration_test() ->
+  {call, _,
+    {remote, _, {atom, _, 'Elixir.NaiveDateTime'}, {atom, _, shift}}, [
+      {atom, _, non_important},
+      {map, _, [
+        {map_field_assoc, _, {atom, _, '__struct__'}, {atom, _, 'Elixir.Duration'}},
+        {map_field_assoc, _, {atom, _, day}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, hour}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, microsecond}, {tuple, _, [{integer, _, 0}, {integer, _, 0}]}},
+        {map_field_assoc, _, {atom, _, minute}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, month}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, second}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, week}, {integer, _, 0}},
+        {map_field_assoc, _, {atom, _, year}, {integer, _, 4}}
+      ]}
+    ]
+  } = to_erl("NaiveDateTime.shift(:non_important, year: 4)").
\ No newline at end of file
diff --git a/lib/elixir/test/erlang/function_test.erl b/lib/elixir/test/erlang/function_test.erl
index 8f875a5817b..2d7f8156aa2 100644
--- a/lib/elixir/test/erlang/function_test.erl
+++ b/lib/elixir/test/erlang/function_test.erl
@@ -1,22 +1,27 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(function_test).
 -include_lib("eunit/include/eunit.hrl").
 
 eval(Content) ->
-  {Value, Binding, _, _} = elixir:eval(Content, []),
-  {Value, Binding}.
+  Quoted = elixir:'string_to_quoted!'(Content, 1, 1, <<"nofile">>, []),
+  {Value, Binding, _} = elixir:eval_forms(Quoted, [], elixir:env_for_eval([])),
+  {Value, lists:sort(Binding)}.
 
 function_arg_do_end_test() ->
   {3, _} = eval("if true do\n1 + 2\nend"),
   {nil, _} = eval("if true do end").
 
 function_stab_end_test() ->
-  {_, [{a, Fun1}]} = eval("a = fn -> end"),
-  nil = Fun1(),
-  {_, [{a, Fun2}]} = eval("a = fn() -> end"),
-  nil = Fun2(),
   {_, [{a, Fun3}]} = eval("a = fn -> 1 + 2 end"),
   3 = Fun3().
 
+function_stab_newlines_test() ->
+  {_, [{a, Fun3}]} = eval("a = fn\n->\n1 + 2\nend"),
+  3 = Fun3().
+
 function_stab_many_test() ->
   {_, [{a, Fun}]} = eval("a = fn\n{:foo, x} -> x\n{:bar, x} -> x\nend"),
   1 = Fun({foo, 1}),
@@ -29,47 +34,47 @@ function_stab_inline_test() ->
 
 function_with_args_test() ->
   {Fun, _} = eval("fn(a, b) -> a + b end"),
-  3 = Fun(1,2).
+  3 = Fun(1, 2).
 
 function_with_kv_args_test() ->
   {Fun, _} = eval("fn(a, [other: b, another: c]) -> a + b + c end"),
-  6 = Fun(1,[{other,2}, {another,3}]).
+  6 = Fun(1, [{other, 2}, {another, 3}]).
 
 function_as_closure_test() ->
-  {_, [{a, Res1}|_]} = eval("b = 1; a = fn -> b + 2 end"),
+  {_, [{a, Res1} | _]} = eval("b = 1; a = fn -> b + 2 end"),
   3 = Res1().
 
 function_apply_test() ->
-  {3,_} = eval("a = fn -> 3 end; apply a, []").
+  {3, _} = eval("a = fn -> 3 end; apply a, []").
 
 function_apply_with_args_test() ->
-  {3,_} = eval("a = fn b -> b + 2 end; apply a, [1]").
+  {3, _} = eval("a = fn b -> b + 2 end; apply a, [1]").
 
 function_apply_and_clojure_test() ->
-  {3,_} = eval("b = 1; a = fn -> b + 2 end; apply a, []").
+  {3, _} = eval("b = 1; a = fn -> b + 2 end; apply a, []").
 
 function_parens_test() ->
-  {0,_} = eval("(fn() -> 0 end).()"),
-  {1,_} = eval("(fn(1) -> 1 end).(1)"),
-  {3,_} = eval("(fn(1, 2) -> 3 end).(1, 2)"),
+  {0, _} = eval("(fn() -> 0 end).()"),
+  {1, _} = eval("(fn(1) -> 1 end).(1)"),
+  {3, _} = eval("(fn(1, 2) -> 3 end).(1, 2)"),
 
-  {0,_} = eval("(fn () -> 0 end).()"),
-  {1,_} = eval("(fn (1) -> 1 end).(1)"),
-  {3,_} = eval("(fn (1, 2) -> 3 end).(1, 2)").
+  {0, _} = eval("(fn() -> 0 end).()"),
+  {1, _} = eval("(fn(1) -> 1 end).(1)"),
+  {3, _} = eval("(fn(1, 2) -> 3 end).(1, 2)").
 
 %% Function calls
 
 function_call_test() ->
-  {3, _} = eval("x = fn a, b -> a + b end\nx.(1,2)").
+  {3, _} = eval("x = fn a, b -> a + b end\nx.(1, 2)").
 
 function_call_without_arg_test() ->
   {3, _} = eval("x = fn -> 2 + 1 end\nx.()").
 
 function_call_do_end_test() ->
-  {[1,[{do,2},{else,3}]], _} = eval("x = fn a, b -> [a,b] end\nx.(1) do\n2\nelse 3\nend").
+  {[1, [{do, 2}, {'else', 3}]], _} = eval("x = fn a, b -> [a, b] end\nx.(1) do\n2\nelse 3\nend").
 
 function_call_with_assignment_test() ->
-  {3, [{a,_},{c, 3}]} = eval("a = fn x -> x + 2 end; c = a.(1)").
+  {3, [{a, _}, {c, 3}]} = eval("a = fn x -> x + 2 end; c = a.(1)").
 
 function_calls_with_multiple_expressions_test() ->
   {26, _} = eval("a = fn a, b -> a + b end; a.((3 + 4 - 1), (2 * 10))").
@@ -78,29 +83,29 @@ function_calls_with_multiple_args_with_line_breaks_test() ->
   {5, _} = eval("a = fn a, b -> a + b end; a.(\n3,\n2\n)").
 
 function_calls_with_parenthesis_test() ->
-  {3, [{a,_},{b,1}]} = eval("a = (fn x -> x + 2 end).(b = 1)").
+  {3, [{a, _}, {b, 1}]} = eval("a = (fn x -> x + 2 end).(b = 1)").
 
 function_call_with_a_single_space_test() ->
-  {3, _} = eval("a = fn a, b -> a + b end; a. (1,2)"),
-  {3, _} = eval("a = fn a, b -> a + b end; a .(1,2)").
+  {3, _} = eval("a = fn a, b -> a + b end; a. (1, 2)"),
+  {3, _} = eval("a = fn a, b -> a + b end; a .(1, 2)").
 
 function_call_with_spaces_test() ->
-  {3, _} = eval("a = fn a, b -> a + b end; a . (1,2)").
+  {3, _} = eval("a = fn a, b -> a + b end; a . (1, 2)").
 
 function_call_without_assigning_with_spaces_test() ->
-  {3, _} = eval("(fn a, b -> a + b end) . (1,2)").
+  {3, _} = eval("(fn a, b -> a + b end) . (1, 2)").
 
 function_call_with_assignment_and_spaces_test() ->
-  {3, [{a,_},{c,3}]} = eval("a = fn x -> x + 2 end; c = a . (1)").
+  {3, [{a, _}, {c, 3}]} = eval("a = fn x -> x + 2 end; c = a . (1)").
 
 function_call_with_multiple_spaces_test() ->
-  {3, _} = eval("a = fn a, b -> a + b end; a .         (1,2)").
+  {3, _} = eval("a = fn a, b -> a + b end; a .         (1, 2)").
 
 function_call_with_multiline_test() ->
-  {3, _} = eval("a = fn a, b -> a + b end; a .   \n      (1,2)").
+  {3, _} = eval("a = fn a, b -> a + b end; a .   \n      (1, 2)").
 
 function_call_with_tabs_test() ->
-  {3, _} = eval("a = fn a, b -> a + b end; a .\n\t(1,2)").
+  {3, _} = eval("a = fn a, b -> a + b end; a .\n\t(1, 2)").
 
 function_call_with_args_and_nested_when_test() ->
   {Fun, _} = eval("fn a, b when a == 1 when b == 2 -> a + b end"),
diff --git a/lib/elixir/test/erlang/match_test.erl b/lib/elixir/test/erlang/match_test.erl
deleted file mode 100644
index 317b066dadf..00000000000
--- a/lib/elixir/test/erlang/match_test.erl
+++ /dev/null
@@ -1,118 +0,0 @@
--module(match_test).
--include_lib("eunit/include/eunit.hrl").
-
-eval(Content) -> eval(Content, []).
-
-eval(Content, Initial) ->
-  {Value, Binding, _, _} = elixir:eval(Content, Initial),
-  {Value, Binding}.
-
-no_assignment_test() ->
-  {nil, []} = eval("").
-
-% Var/assignment test
-arithmetic_test() ->
-  ?assertError({badmatch, _}, eval("-1 = 1")).
-
-assignment_test() ->
-  {1, [{a, 1}]} = eval("a = 1").
-
-not_single_assignment_test() ->
-  {2, [{a, 2}]} = eval("a = 1\na = 2\na"),
-  {1, [{a, 1}]} = eval("{a,a} = {1,1}\na"),
-  {2, [{a, 2}]} = eval("a = 1\n{^a,a} = {1,2}\na"),
-  ?assertError({badmatch, _}, eval("{a,a} = {1,2}")),
-  ?assertError({badmatch, _}, eval("{1 = a,a} = {1,2}")),
-  ?assertError({badmatch, _}, eval("{a = 1,a} = {1,2}")),
-  ?assertError({badmatch, _}, eval("a = 0;{a,a} = {1,2}")),
-  ?assertError({badmatch, _}, eval("a = 0;{1 = a,a} = {1,2}")),
-  ?assertError({badmatch, _}, eval("a = 1\n^a = 2")).
-
-duplicated_assignment_on_module_with_tuple_test() ->
-  F = fun() ->
-    eval("defmodule Foo do\ndef v({a, _left}, {a, _right}), do: a\nend"),
-    {1,_} = eval("Foo.v({1, :foo}, {1, :bar})"),
-    ?assertError(function_clause, eval("Foo.v({1, :foo}, {2, :bar})"))
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo']).
-
-duplicated_assignment_on_module_with_list_test() ->
-  F = fun() ->
-    eval("defmodule Foo do\ndef v([ a, _left ], [ a, _right ]), do: a\nend"),
-    {1,_} = eval("Foo.v([ 1, :foo ], [ 1, :bar ])"),
-    ?assertError(function_clause, eval("Foo.v([ 1, :foo ], [ 2, :bar ])"))
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo']).
-
-multiline_assignment_test() ->
-  {1, [{a, 1}]} = eval("a =\n1"),
-  {1, [{a, 1}, {b, 1}]} = eval("a = 1\nb = 1").
-
-multiple_assignment_test() ->
-  {1, [{a, 1}, {b, 1}]} = eval("a = b = 1").
-
-multiple_assignment_with_parens_test() ->
-  {1, [{a, 1}, {b, 1}]} = eval("a = (b = 1)").
-
-multiple_assignment_with_left_parens_test() ->
-  {1, [{a, 1}, {b, 1}]} = eval("(a) = (b = 1)").
-
-multiple_assignment_with_expression_test() ->
-  {-4, [{a, -4}, {b, -4}]} = eval("a = (b = -(2 * 2))").
-
-multiple_assignment_with_binding_expression_test() ->
-  {3, [{a, 3}, {b, 1}]} = eval("a = (2 + b)", [{b, 1}]).
-
-underscore_assignment_test() ->
-  {1, []} = eval("_ = 1").
-
-assignment_precedence_test() ->
-  {_, [{x,{'__block__', _, [1,2,3]}}]} = eval("x = quote do\n1\n2\n3\nend").
-
-% Tuples match
-simple_tuple_test() ->
-  {{}, _} = eval("a = {}"),
-  {{1,2,3}, _} = eval("a = {1, 2, 3}"),
-  {{1,2,3}, _} = eval("a = {1, 1 + 1, 3}"),
-  {{1,{2},3}, _} = eval("a = {1, {2}, 3}").
-
-tuple_match_test() ->
-  {_, _} = eval("{1,2,3} = {1, 2, 3}"),
-  ?assertError({badmatch, _}, eval("{1, 3, 2} = {1, 2, 3}")).
-
-% Lists match
-simple_list_test() ->
-  {[], _} = eval("a = []"),
-  {[1,2,3], _} = eval("a = [1, 2, 3]"),
-  {[1,2,3], _} = eval("a = [1, 1 + 1, 3]"),
-  {[1,[2],3], _} = eval("a = [1, [2], 3]"),
-  {[1,{2},3], _} = eval("a = [1, {2}, 3]").
-
-list_match_test() ->
-  {_, _} = eval("[1, 2, 3] = [1, 2, 3]"),
-  ?assertError({badmatch, _}, eval("[1, 3, 2] = [1, 2, 3]")).
-
-list_vars_test() ->
-  {[3,1], [{x,3}]} = eval("x = 1\n[x = x + 2, x]").
-
-head_and_tail_test() ->
-  {_,[{h,1},{t,[2,3]}]} = eval("[h|t] = [1,2,3]"),
-  {_,[{h,2},{t,[3]}]} = eval("[1,h|t] = [1,2,3]"),
-  {_,[{t,[3]}]} = eval("[1,2|t] = [1,2,3]"),
-  {_,[{h,1}]} = eval("[h|[2,3]] = [1,2,3]"),
-  {_,[{t,[2,3]}]} = eval("[+1|t] = [1,2,3]"),
-  ?assertError({badmatch, _}, eval("[2,h|t] = [1,2,3]")).
-
-% Keyword match
-
-orrdict_match_test() ->
-  {[{a,1},{b,2}], _} = eval("a = [a: 1, b: 2]").
-  
-% Function match
-
-function_clause_test() ->
-  F = fun() ->
-    eval("defmodule Foo do\ndef a([{_k,_}=e|_]), do: e\nend"),
-    {{foo,bar},_} = eval("Foo.a([{:foo,:bar}])")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo']).
\ No newline at end of file
diff --git a/lib/elixir/test/erlang/module_test.erl b/lib/elixir/test/erlang/module_test.erl
deleted file mode 100644
index 1b9b835f2e7..00000000000
--- a/lib/elixir/test/erlang/module_test.erl
+++ /dev/null
@@ -1,112 +0,0 @@
--module(module_test).
--include_lib("eunit/include/eunit.hrl").
-
-eval(Content) ->
-  {Value, Binding, _, _} = elixir:eval(Content, []),
-  {Value, Binding}.
-
-definition_test() ->
-  F = fun() ->
-    eval("defmodule Foo.Bar.Baz, do: nil")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo.Bar.Baz']).
-
-module_vars_test() ->
-  F = fun() ->
-    eval("a = 1; b = 2; c = 3; defmodule Foo do\n1 = a; 2 = b; 3 = c\nend")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo']).
-
-function_test() ->
-  F = fun() ->
-    eval("defmodule Foo.Bar.Baz do\ndef sum(a, b) do\na + b\nend\nend"),
-    3 = 'Elixir.Foo.Bar.Baz':sum(1, 2)
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo.Bar.Baz']).
-
-quote_unquote_splicing_test() ->
-  {{'{}', [], [1,2,3,4,5]}, _} = eval("x = [2,3,4]\nquote do: {1, unquote_splicing(x), 5}").
-
-def_shortcut_test() ->
-  F = fun() ->
-    {1,[]} = eval("defmodule Foo do\ndef version, do: 1\nend\nFoo.version")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo']).
-
-macro_test() ->
-  F = fun() ->
-    {'Elixir.Foo',[]} = eval("defmodule Foo do\ndef version, do: __MODULE__\nend\nFoo.version"),
-    {nil,[]} = eval("__MODULE__")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo']).
-
-macro_line_test() ->
-  F = fun() ->
-    ?assertMatch({2, []}, eval("defmodule Foo do\ndef line, do: __ENV__.line\nend\nFoo.line")),
-    ?assertMatch({1, []}, eval("__ENV__.line"))
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo']).
-
-def_default_test() ->
-  F = fun() ->
-    eval("defmodule Foo do\ndef version(x \\\\ 1), do: x\nend"),
-    ?assertEqual({1, []}, eval("Foo.version")),
-    ?assertEqual({2, []}, eval("Foo.version(2)"))
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo']).
-
-def_left_default_test() ->
-  F = fun() ->
-    eval("defmodule Foo do\ndef version(x \\\\ 1, y), do: x + y\nend"),
-    ?assertEqual({4, []}, eval("Foo.version(3)")),
-    ?assertEqual({5, []}, eval("Foo.version(2, 3)"))
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo']).
-
-def_with_guard_test() ->
-  F = fun() ->
-    eval("defmodule Foo do\ndef v(x) when x < 10, do: true\ndef v(x) when x >= 10, do: false\nend"),
-    {true,_} = eval("Foo.v(0)"),
-    {false,_} = eval("Foo.v(20)")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo']).
-
-do_end_test() ->
-  F = fun() ->
-    eval("defmodule Foo do\ndef a, do: 1\ndefmodule Bar do\ndef b, do: 2\nend\ndef c, do: 3\nend"),
-    {1,_} = eval("Foo.a"),
-    {2,_} = eval("Foo.Bar.b"),
-    {3,_} = eval("Foo.c")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo', 'Elixir.Foo.Bar']).
-
-nesting_test() ->
-  F = fun() ->
-    eval("defmodule Foo do\ndefmodule Elixir.Bar do\ndef b, do: 2\nend\nend"),
-    {2,_} = eval("Bar.b")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo', 'Elixir.Bar']).
-
-dot_alias_test() ->
-  {'Elixir.Foo.Bar.Baz', _} = eval("Foo.Bar.Baz").
-
-dot_dyn_alias_test() ->
-  {'Elixir.Foo.Bar.Baz', _} = eval("a = Foo.Bar; a.Baz").
-
-single_ref_test() ->
-  {'Elixir.Foo', _} = eval("Foo"),
-  {'Elixir.Foo', _} = eval("Elixir.Foo").
-
-nested_ref_test() ->
-  {'Elixir.Foo.Bar.Baz', _} = eval("Foo.Bar.Baz").
-
-module_with_elixir_as_a_name_test() ->
-  ?assertError(#{'__struct__' := 'Elixir.CompileError'}, eval("defmodule Elixir do\nend")).
-
-dynamic_defmodule_test() ->
-  F = fun() ->
-    eval("defmodule Foo do\ndef a(name) do\ndefmodule name, do: (def x, do: 1)\nend\nend"),
-    {_,_} = eval("Foo.a(Bar)"),
-    {1,_} = eval("Bar.x")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo', 'Elixir.Bar']).
\ No newline at end of file
diff --git a/lib/elixir/test/erlang/operators_test.erl b/lib/elixir/test/erlang/operators_test.erl
deleted file mode 100644
index 6ef07a89f14..00000000000
--- a/lib/elixir/test/erlang/operators_test.erl
+++ /dev/null
@@ -1,92 +0,0 @@
--module(operators_test).
--include_lib("eunit/include/eunit.hrl").
-
-eval(Content) ->
-  {Value, Binding, _, _} = elixir:eval(Content, []),
-  {Value, Binding}.
-
-separator_test() ->
-  {334,[]} = eval("3_34"),
-  {600,[]} = eval("2_00+45_5-5_5").
-
-integer_sum_test() ->
-  {3,[]} = eval("1+2"),
-  {6,[]} = eval("1+2+3"),
-  {6,[]} = eval("1+2 +3"),
-  {6,[]} = eval("1 + 2 + 3").
-
-integer_sum_minus_test() ->
-  {-4,[]} = eval("1-2-3"),
-  {0,[]}  = eval("1+2-3"),
-  {0,[]}  = eval("1 + 2 - 3").
-
-integer_mult_test() ->
-  {6,[]} = eval("1*2*3"),
-  {6,[]} = eval("1 * 2 * 3").
-
-integer_div_test() ->
-  {0.5,[]} = eval("1 / 2"),
-  {2.0,[]} = eval("4 / 2").
-
-integer_div_rem_test() ->
-  {2,[]} = eval("div 5, 2"),
-  {1,[]} = eval("rem 5, 2").
-
-integer_mult_div_test() ->
-  {1.0,[]} = eval("2*1/2"),
-  {6.0,[]} = eval("3 * 4 / 2").
-
-integer_without_parens_test() ->
-  {17,[]}  = eval("3 * 5 + 2"),
-  {17,[]}  = eval("2 + 3 * 5"),
-  {6.0,[]} = eval("4 / 4 + 5").
-
-integer_with_parens_test() ->
-  {21,[]}   = eval("3 * (5 + 2)"),
-  {21,[]}   = eval("3 * (((5 + (2))))"),
-  {25,[]}   = eval("(2 + 3) * 5"),
-  {0.25,[]} = eval("4 / (11 + 5)").
-
-integer_with_unary_test() ->
-  {2,[]}    = eval("- 1 * - 2").
-
-integer_eol_test() ->
-  {3,[]} = eval("1 +\n2"),
-  {2,[]} = eval("1 *\n2"),
-  {8,[]} = eval("1 + 2\n3 + 5"),
-  {8,[]} = eval("1 + 2\n\n\n3 + 5"),
-  {8,[]} = eval("1 + 2;\n\n3 + 5"),
-  {8,[]} = eval("1 + (\n2\n) + 3 + 2"),
-  {8,[]} = eval("1 + (\n\n  2\n\n) + 3 + 2"),
-  {3,[]} = eval(";1 + 2"),
-  ?assertError(#{'__struct__' := 'Elixir.SyntaxError'}, eval("1 + 2;\n;\n3 + 5")).
-
-float_with_parens_and_unary_test() ->
-  {-21.0,[]} = eval("-3.0 * (5 + 2)"),
-  {25.0,[]}  = eval("(2 + 3.0) * 5"),
-  {0.25,[]}  = eval("4 / (11.0 + 5)").
-
-operators_precedence_test() ->
-  {2, _}   = eval("max -1, 2"),
-  {5, []}  = eval("abs -10 + 5"),
-  {15, []} = eval("abs(-10) + 5").
-
-operators_variables_precedence_test() ->
-  {30, _} = eval("a = 10\nb= 20\na+b"),
-  {30, _} = eval("a = 10\nb= 20\na + b").
-
-operators_variables_precedence_on_namespaces_test() ->
-  F = fun() ->
-    eval("defmodule Foo do; def l, do: 1; end; defmodule Bar do; def l(_x), do: 1; end"),
-    {3,[]} = eval("1 + Foo.l + 1"),
-    {3,[]} = eval("1 + Foo.l+1"),
-    {2,[]} = eval("1 + Bar.l +1")
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo', 'Elixir.Bar']).
-
-add_add_op_test() ->
-  {[1,2,3,4],[]} = eval("[1,2] ++ [3,4]").
-
-minus_minus_op_test() ->
-  {[1,2],[]} = eval("[1,2,3] -- [3]"),
-  {[1,2,3],[]} = eval("[1,2,3] -- [3] -- [3]").
\ No newline at end of file
diff --git a/lib/elixir/test/erlang/string_test.erl b/lib/elixir/test/erlang/string_test.erl
index aa787110fbb..f74a0fae2d7 100644
--- a/lib/elixir/test/erlang/string_test.erl
+++ b/lib/elixir/test/erlang/string_test.erl
@@ -1,115 +1,129 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(string_test).
--include("elixir.hrl").
+-include("../../src/elixir.hrl").
 -include_lib("eunit/include/eunit.hrl").
 
 eval(Content) ->
-  {Value, Binding, _, _} = elixir:eval(Content, []),
+  Quoted = elixir:'string_to_quoted!'(Content, 1, 1, <<"nofile">>, []),
+  {Value, Binding, _} = elixir:eval_forms(Quoted, [], elixir:env_for_eval([])),
   {Value, Binding}.
 
 extract_interpolations(String) ->
-  element(2, elixir_interpolation:extract(1,
-    #elixir_tokenizer{file = <<"nofile">>}, true, String ++ [$"], $")).
+  case elixir_interpolation:extract(1, 1, #elixir_tokenizer{}, true, String ++ [$"], $") of
+    {error, Error} ->
+      Error;
+    {_, _, Parts, _, _} ->
+      Parts
+   end.
 
 % Interpolations
 
 extract_interpolations_without_interpolation_test() ->
-  [<<"foo">>] = extract_interpolations("foo").
+  ["foo"] = extract_interpolations("foo").
 
 extract_interpolations_with_escaped_interpolation_test() ->
-  [<<"f#{o}o">>] = extract_interpolations("f\\#{o}o").
+  ["f\\#{o}o"] = extract_interpolations("f\\#{o}o"),
+  {1, 10, ["f\\#{o}o"], [], _} =
+    elixir_interpolation:extract(1, 2, #elixir_tokenizer{}, true, "f\\#{o}o\"", $").
 
 extract_interpolations_with_interpolation_test() ->
-  [<<"f">>,
-   {1,[{atom,1,o}]},
-   <<"o">>] = extract_interpolations("f#{:o}o").
+  ["f",
+   {{1, 2, nil}, {1, 6, nil}, [{atom, {1, 4, _}, o}]},
+   "o"] = extract_interpolations("f#{:o}o").
 
 extract_interpolations_with_two_interpolations_test() ->
-  [<<"f">>,
-   {1,[{atom,1,o}]},{1,[{atom,1,o}]},
-   <<"o">>] = extract_interpolations("f#{:o}#{:o}o").
+  ["f",
+   {{1, 2, nil}, {1, 6, nil}, [{atom, {1, 4, _}, o}]},
+   {{1, 7, nil}, {1, 11, nil}, [{atom, {1, 9, _}, o}]},
+   "o"] = extract_interpolations("f#{:o}#{:o}o").
 
 extract_interpolations_with_only_two_interpolations_test() ->
-  [{1,[{atom,1,o}]},
-   {1,[{atom,1,o}]}] = extract_interpolations("#{:o}#{:o}").
+  [{{1, 1, nil}, {1, 5, nil}, [{atom, {1, 3, _}, o}]},
+   {{1, 6, nil}, {1, 10, nil}, [{atom, {1, 8, _}, o}]}] = extract_interpolations("#{:o}#{:o}").
 
 extract_interpolations_with_tuple_inside_interpolation_test() ->
-  [<<"f">>,
-   {1,[{'{',1},{number,1,1},{'}',1}]},
-   <<"o">>] = extract_interpolations("f#{{1}}o").
+  ["f",
+   {{1, 2, nil}, {1, 7, nil}, [{'{', {1, 4, nil}}, {int, {1, 5, 1}, "1"}, {'}', {1, 6, nil}}]},
+   "o"] = extract_interpolations("f#{{1}}o").
 
 extract_interpolations_with_many_expressions_inside_interpolation_test() ->
-  [<<"f">>,
-   {1,[{number,1,1},{eol,1,newline},{number,2,2}]},
-    <<"o">>] = extract_interpolations("f#{1\n2}o").
+  ["f",
+   {{1, 2, nil}, {2, 2, nil}, [{int, {1, 4, 1}, "1"}, {eol, {1, 5, 1}}, {int, {2, 1, 2}, "2"}]},
+    "o"] = extract_interpolations("f#{1\n2}o").
 
 extract_interpolations_with_right_curly_inside_string_inside_interpolation_test() ->
-  [<<"f">>,
-   {1,[{bin_string,1,[<<"f}o">>]}]},
-   <<"o">>] = extract_interpolations("f#{\"f}o\"}o").
+  ["f",
+   {{1, 2, nil}, {1, 9, nil}, [{bin_string, {1, 4, nil}, [<<"f}o">>]}]},
+   "o"] = extract_interpolations("f#{\"f}o\"}o").
 
 extract_interpolations_with_left_curly_inside_string_inside_interpolation_test() ->
-  [<<"f">>,
-   {1,[{bin_string,1,[<<"f{o">>]}]},
-   <<"o">>] = extract_interpolations("f#{\"f{o\"}o").
+  ["f",
+   {{1, 2, nil}, {1, 9, nil}, [{bin_string, {1, 4, nil}, [<<"f{o">>]}]},
+   "o"] = extract_interpolations("f#{\"f{o\"}o").
 
 extract_interpolations_with_escaped_quote_inside_string_inside_interpolation_test() ->
-  [<<"f">>,
-   {1,[{bin_string,1,[<<"f\"o">>]}]},
-   <<"o">>] = extract_interpolations("f#{\"f\\\"o\"}o").
+  ["f",
+   {{1, 2, nil}, {1, 10, nil}, [{bin_string, {1, 4, nil}, [<<"f\"o">>]}]},
+   "o"] = extract_interpolations("f#{\"f\\\"o\"}o").
 
 extract_interpolations_with_less_than_operation_inside_interpolation_test() ->
-  [<<"f">>,
-   {1,[{number,1,1},{rel_op,1,'<'},{number,1,2}]},
-   <<"o">>] = extract_interpolations("f#{1<2}o").
+  ["f",
+   {{1, 2, nil}, {1, 7, nil}, [{int, {1, 4, 1}, "1"}, {rel_op, {1, 5, nil}, '<'}, {int, {1, 6, 2}, "2"}]},
+   "o"] = extract_interpolations("f#{1<2}o").
+
+extract_interpolations_with_an_escaped_character_test() ->
+  ["f",
+   {{1, 2, nil}, {1, 16, nil}, [{char, {1, 4, "?\\a"}, 7}, {rel_op, {1, 8, nil}, '>'}, {char, {1, 10, "?\\a"}, 7}]}
+   ] = extract_interpolations("f#{?\\a > ?\\a   }").
 
 extract_interpolations_with_invalid_expression_inside_interpolation_test() ->
-  {1,"invalid token: ",":1}o\""} = extract_interpolations("f#{:1}o").
+  {[{line, 1}, {column, 4}], "unexpected token: ", _} = extract_interpolations("f#{:1}o").
 
 %% Bin strings
 
-empty_bin_string_test() ->
+empty_test() ->
   {<<"">>, _} = eval("\"\"").
 
-simple_bin_string_test() ->
-  {<<"foo">>, _} = eval("\"foo\"").
-
-bin_string_with_double_quotes_test() ->
+string_with_double_quotes_test() ->
   {<<"f\"o\"o">>, _} = eval("\"f\\\"o\\\"o\"").
 
-bin_string_with_newline_test() ->
+string_with_newline_test() ->
   {<<"f\no">>, _} = eval("\"f\no\"").
 
-bin_string_with_slash_test() ->
+string_with_slash_test() ->
   {<<"f\\o">>, _} = eval("\"f\\\\o\"").
 
-bin_string_with_bell_character_test() ->
+string_with_bell_character_test() ->
   {<<"f\ao">>, _} = eval("\"f\ao\"").
 
-bin_string_with_interpolation_test() ->
+string_with_interpolation_test() ->
   {<<"foo">>, _} = eval("\"f#{\"o\"}o\"").
 
-bin_string_with_another_string_inside_string_inside_interpolation_test() ->
+string_with_another_string_inside_string_inside_interpolation_test() ->
   {<<"fbaro">>, _} = eval("\"f#{\"b#{\"a\"}r\"}o\"").
 
-bin_string_with_another_string_with_curly_inside_interpolation_test() ->
+string_with_another_string_with_curly_inside_interpolation_test() ->
   {<<"fb}ro">>, _} = eval("\"f#{\"b}r\"}o\"").
 
-bin_string_with_atom_with_separator_inside_interpolation_test() ->
+string_with_atom_with_separator_inside_interpolation_test() ->
   {<<"f}o">>, _} = eval("\"f#{\"}\"}o\"").
 
-bin_string_with_lower_case_hex_interpolation_test() ->
+string_with_lower_case_hex_interpolation_test() ->
   {<<"jklmno">>, _} = eval("\"\\x6a\\x6b\\x6c\\x6d\\x6e\\x6f\"").
 
-bin_string_with_upper_case_hex_interpolation_test() ->
+string_with_upper_case_hex_interpolation_test() ->
   {<<"jklmno">>, _} = eval("\"\\x6A\\x6B\\x6C\\x6D\\x6E\\x6F\"").
 
-bin_string_without_interpolation_and_escaped_test() ->
+string_without_interpolation_and_escaped_test() ->
   {<<"f#o">>, _} = eval("\"f\\#o\"").
 
-bin_string_with_escaped_interpolation_test() ->
+string_with_escaped_interpolation_test() ->
   {<<"f#{'o}o">>, _} = eval("\"f\\#{'o}o\"").
 
-bin_string_with_the_end_of_line_slash_test() ->
+string_with_the_end_of_line_slash_test() ->
   {<<"fo">>, _} = eval("\"f\\\no\""),
   {<<"fo">>, _} = eval("\"f\\\r\no\"").
 
@@ -120,57 +134,7 @@ invalid_string_interpolation_test() ->
 unterminated_string_interpolation_test() ->
   ?assertError(#{'__struct__' := 'Elixir.TokenMissingError'}, eval("\"foo")).
 
-%% List strings
-
-empty_list_string_test() ->
-  {[], _} = eval("\'\'").
-
-simple_list_string_test() ->
-  {"foo", _} = eval("'foo'").
-
-list_string_with_double_quotes_test() ->
-  {"f'o'o", _} = eval("'f\\'o\\'o'").
-
-list_string_with_newline_test() ->
-  {"f\no", _} = eval("'f\no'").
-
-list_string_with_slash_test() ->
-  {"f\\o", _} = eval("'f\\\\o'").
-
-list_string_with_bell_character_test() ->
-  {"f\ao", _} = eval("'f\ao'").
-
-list_string_with_interpolation_test() ->
-  {"foo", _} = eval("'f#{\"o\"}o'").
-
-list_string_with_another_string_with_curly_inside_interpolation_test() ->
-  {"fb}ro", _} = eval("'f#{\"b}r\"}o'").
-
-list_string_with_atom_with_separator_inside_interpolation_test() ->
-  {"f}o", _} = eval("'f#{\"}\"}o'").
-
-list_string_with_lower_case_hex_interpolation_test() ->
-  {"JKLMNO", _} = eval("'\\x4a\\x4b\\x4c\\x4d\\x4e\\x4f'").
-
-list_string_with_upper_case_hex_interpolation_test() ->
-  {"JKLMNO", _} = eval("'\\x4A\\x4B\\x4C\\x4D\\x4E\\x4F'").
-
-list_string_without_interpolation_and_escaped_test() ->
-  {"f#o", _} = eval("'f\\#o'").
-
-list_string_with_escaped_interpolation_test() ->
-  {"f#{\"o}o", _} = eval("'f\\#{\"o}o'").
-
-list_string_with_the_end_of_line_slash_test() ->
-  {"fo", _} = eval("'f\\\no'"),
-  {"fo", _} = eval("'f\\\r\no'").
-
 char_test() ->
-  {99,[]} = eval("?1 + ?2"),
-  {10,[]} = eval("?\\n"),
-  {40,[]} = eval("?\\(").
-
-%% Binaries
-
-bitstr_with_integer_test() ->
-  {<<"fdo">>, _} = eval("<< \"f\", 50+50, \"o\" >>").
+  {99, []} = eval("?1 + ?2"),
+  {10, []} = eval("?\\n"),
+  {40, []} = eval("?(").
diff --git a/lib/elixir/test/erlang/test_helper.erl b/lib/elixir/test/erlang/test_helper.erl
index e0890855250..668ae0558e6 100644
--- a/lib/elixir/test/erlang/test_helper.erl
+++ b/lib/elixir/test/erlang/test_helper.erl
@@ -1,19 +1,19 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(test_helper).
--include("elixir.hrl").
 -export([test/0, run_and_remove/2, throw_elixir/1, throw_erlang/1]).
 -define(TESTS, [
   atom_test,
   control_test,
   function_test,
-  match_test,
-  module_test,
-  operators_test,
   string_test,
   tokenizer_test
 ]).
 
 test() ->
-  application:start(elixir),
+  application:ensure_all_started(elixir),
   case eunit:test(?TESTS) of
     error -> erlang:halt(1);
     _Res  -> erlang:halt(0)
@@ -30,8 +30,8 @@ run_and_remove(Fun, Modules) ->
 
 % Throws an error with the Erlang Abstract Form from the Elixir string
 throw_elixir(String) ->
-  Forms = elixir:'string_to_quoted!'(String, 1, <<"nofile">>, []),
-  {Expr, _, _} = elixir:quoted_to_erl(Forms, elixir:env_for_eval([])),
+  Forms = elixir:'string_to_quoted!'(String, 1, 1, <<"nofile">>, []),
+  {Expr, _, _, _} = elixir:quoted_to_erl(Forms, elixir:env_for_eval([])),
   erlang:error(io:format("~p~n", [Expr])).
 
 % Throws an error with the Erlang Abstract Form from the Erlang string
diff --git a/lib/elixir/test/erlang/tokenizer_test.erl b/lib/elixir/test/erlang/tokenizer_test.erl
index 4cd713860e8..5fecbf6aac5 100644
--- a/lib/elixir/test/erlang/tokenizer_test.erl
+++ b/lib/elixir/test/erlang/tokenizer_test.erl
@@ -1,146 +1,295 @@
+%% SPDX-License-Identifier: Apache-2.0
+%% SPDX-FileCopyrightText: 2021 The Elixir Team
+%% SPDX-FileCopyrightText: 2012 Plataformatec
+
 -module(tokenizer_test).
--include("elixir.hrl").
 -include_lib("eunit/include/eunit.hrl").
 
 tokenize(String) ->
-  {ok, _Line, Result} = elixir_tokenizer:tokenize(String, 1, []),
-  Result.
+  tokenize(String, []).
+
+tokenize(String, Opts) ->
+  {ok, _Line, _Column, _Warnings, Result, []} = elixir_tokenizer:tokenize(String, 1, Opts),
+  lists:reverse(Result).
 
 tokenize_error(String) ->
-  {error, Error, _, _} = elixir_tokenizer:tokenize(String, 1, []),
+  {error, Error, _, _, _} = elixir_tokenizer:tokenize(String, 1, []),
   Error.
 
+tokenize_warnings(String) ->
+  {ok, _Line, _Column, Warnings, Result, []} = elixir_tokenizer:tokenize(String, 1, []),
+  {lists:reverse(Result), Warnings}.
+
 type_test() ->
-  [{number,1,1},{type_op,1,'::'},{number,1,3}] = tokenize("1 :: 3"),
-  [{identifier,1,foo},
-   {'.',1},
-   {paren_identifier,1,'::'},
-   {'(',1},
-   {number,1,3},
-   {')',1}] = tokenize("foo.::(3)").
+  [{int, {1, 1, 1}, "1"},
+   {type_op, {1, 3, nil}, '::'},
+   {int, {1, 6, 3}, "3"}] = tokenize("1 :: 3"),
+  [{'true', {1, 1, nil}},
+   {type_op, {1, 5, nil}, '::'},
+   {int, {1, 7, 3}, "3"}] = tokenize("true::3"),
+  [{identifier, {1, 1, _}, name},
+   {'.', {1, 5, nil}},
+   {paren_identifier, {1, 6, _}, '::'},
+   {'(', {1, 8, nil}},
+   {int, {1, 9, 3}, "3"},
+   {')', {1, 10, nil}}] = tokenize("name.::(3)").
 
 arithmetic_test() ->
-  [{number,1,1},{dual_op,1,'+'},{number,1,2},{dual_op,1,'+'},{number,1,3}] = tokenize("1 + 2 + 3").
+  [{int, {1, 1, 1}, "1"},
+   {dual_op, {1, 3, nil}, '+'},
+   {int, {1, 5, 2}, "2"},
+   {dual_op, {1, 7, nil}, '+'},
+   {int, {1, 9, 3}, "3"}] = tokenize("1 + 2 + 3").
 
 op_kw_test() ->
-  [{atom,1,foo},{dual_op,1,'+'},{atom,1,bar}] = tokenize(":foo+:bar").
+  [{atom, {1, 1, _}, foo},
+   {dual_op, {1, 5, nil}, '+'},
+   {atom, {1, 6, _}, bar}] = tokenize(":foo+:bar").
 
 scientific_test() ->
-  [{number, 1, 0.1}] = tokenize("1.0e-1").
+  [{flt, {1, 1, 0.1}, "1.0e-1"}] = tokenize("1.0e-1"),
+  [{flt, {1, 1, 0.1}, "1.0E-1"}] = tokenize("1.0E-1"),
+  [{flt, {1, 1, 1.2345678e-7}, "1_234.567_8e-10"}] = tokenize("1_234.567_8e-10"),
+  {[{line, 1}, {column, 1}], "invalid float number ", "1.0e309"} = tokenize_error("1.0e309").
 
 hex_bin_octal_test() ->
-  [{number,1,255}] = tokenize("0xFF"),
-  [{number,1,255}] = tokenize("0Xff"),
-  [{number,1,63}] = tokenize("077"),
-  [{number,1,63}] = tokenize("077"),
-  [{number,1,3}] = tokenize("0b11"),
-  [{number,1,3}] = tokenize("0B11").
+  [{int, {1, 1, 255}, "0xFF"}] = tokenize("0xFF"),
+  [{int, {1, 1, 255}, "0xF_F"}] = tokenize("0xF_F"),
+  [{int, {1, 1, 63}, "0o77"}] = tokenize("0o77"),
+  [{int, {1, 1, 63}, "0o7_7"}] = tokenize("0o7_7"),
+  [{int, {1, 1, 3}, "0b11"}] = tokenize("0b11"),
+  [{int, {1, 1, 3}, "0b1_1"}] = tokenize("0b1_1").
 
 unquoted_atom_test() ->
-  [{atom, 1, '+'}] = tokenize(":+"),
-  [{atom, 1, '-'}] = tokenize(":-"),
-  [{atom, 1, '*'}] = tokenize(":*"),
-  [{atom, 1, '/'}] = tokenize(":/"),
-  [{atom, 1, '='}] = tokenize(":="),
-  [{atom, 1, '&&'}] = tokenize(":&&").
+  [{atom, {1, 1, _}, '+'}] = tokenize(":+"),
+  [{atom, {1, 1, _}, '-'}] = tokenize(":-"),
+  [{atom, {1, 1, _}, '*'}] = tokenize(":*"),
+  [{atom, {1, 1, _}, '/'}] = tokenize(":/"),
+  [{atom, {1, 1, _}, '='}] = tokenize(":="),
+  [{atom, {1, 1, _}, '&&'}] = tokenize(":&&").
 
 quoted_atom_test() ->
-  [{atom_unsafe, 1, [<<"foo bar">>]}] = tokenize(":\"foo bar\"").
+  [{atom_quoted, {1, 1, $"}, 'foo bar'}] = tokenize(":\"foo bar\"").
 
 oversized_atom_test() ->
-  OversizedAtom = [$:|string:copies("a", 256)],
-  {1, "atom length must be less than system limit", ":"} = tokenize_error(OversizedAtom).
+  OversizedAtom = string:copies("a", 256),
+  {[{line, 1}, {column, 1}], "atom length must be less than system limit: ", OversizedAtom} =
+    tokenize_error([$: | OversizedAtom]).
 
 op_atom_test() ->
-  [{atom,1,f0_1}] = tokenize(":f0_1").
+  [{atom, {1, 1, _}, f0_1}] = tokenize(":f0_1").
 
 kw_test() ->
-  [{kw_identifier, 1, do}] = tokenize("do: "),
-  [{kw_identifier_unsafe, 1, [<<"foo bar">>]}] = tokenize("\"foo bar\": ").
+  [{kw_identifier, {1, 1, _}, do}] = tokenize("do: "),
+  [{kw_identifier, {1, 1, _}, a@}] = tokenize("a@: "),
+  [{kw_identifier, {1, 1, _}, 'A@'}] = tokenize("A@: "),
+  [{kw_identifier, {1, 1, _}, a@b}] = tokenize("a@b: "),
+  [{kw_identifier, {1, 1, _}, 'A@!'}] = tokenize("A@!: "),
+  [{kw_identifier, {1, 1, _}, 'a@!'}] = tokenize("a@!: "),
+  [{kw_identifier, {1, 1, _}, foo}, {bin_string, {1, 6, nil}, [<<"bar">>]}] = tokenize("foo: \"bar\""),
+  [{kw_identifier, {1, 1, _}, '+'}, {bin_string, {1, 6, nil}, [<<"bar">>]}] = tokenize("\"+\": \"bar\"").
 
-integer_test() ->
-  [{number, 1, 123}] = tokenize("123"),
-  [{number, 1, 123},{eol, 1, ';'}] = tokenize("123;"),
-  [{eol, 1, newline}, {number, 3, 123}] = tokenize("\n\n123"),
-  [{number, 1, 123}, {number, 1, 234}] = tokenize("  123  234  ").
+int_test() ->
+  [{int, {1, 1, 123}, "123"}] = tokenize("123"),
+  [{int, {1, 1, 123}, "123"}, {';', {1, 4, 0}}] = tokenize("123;"),
+  [{eol, {1, 1, 2}}, {int, {3, 1, 123}, "123"}] = tokenize("\n\n123"),
+  [{int, {1, 3, 123}, "123"}, {int, {1, 8, 234}, "234"}] = tokenize("  123  234  "),
+  [{int, {1, 1, 7}, "007"}] = tokenize("007"),
+  [{int, {1, 1, 100000}, "0100000"}] = tokenize("0100000").
 
 float_test() ->
-  [{number, 1, 12.3}] = tokenize("12.3"),
-  [{number, 1, 12.3},{eol, 1, ';'}] = tokenize("12.3;"),
-  [{eol, 1, newline}, {number, 3, 12.3}] = tokenize("\n\n12.3"),
-  [{number, 1, 12.3}, {number, 1, 23.4}] = tokenize("  12.3  23.4  ").
-
-comments_test() ->
-  [{number, 1, 1},{eol, 1, newline},{number,2,2}] = tokenize("1 # Comment\n2").
+  [{flt, {1, 1, 12.3}, "12.3"}] = tokenize("12.3"),
+  [{flt, {1, 1, 12.3}, "12.3"}, {';', {1, 5, 0}}] = tokenize("12.3;"),
+  [{eol, {1, 1, 2}}, {flt, {3, 1, 12.3}, "12.3"}] = tokenize("\n\n12.3"),
+  [{flt, {1, 3, 12.3}, "12.3"}, {flt, {1, 9, 23.4}, "23.4"}] = tokenize("  12.3  23.4  "),
+  [{flt, {1, 1, 12.3}, "00_12.3_00"}] = tokenize("00_12.3_00"),
+  OversizedFloat = string:copies("9", 310) ++ ".0",
+  {[{line, 1}, {column, 1}], "invalid float number ", OversizedFloat} = tokenize_error(OversizedFloat).
 
 identifier_test() ->
-  [{identifier,1,abc}] = tokenize("abc "),
-  [{identifier,1,'abc?'}] = tokenize("abc?"),
-  [{identifier,1,'abc!'}] = tokenize("abc!"),
-  [{identifier,1,'a0c!'}] = tokenize("a0c!"),
-  [{paren_identifier,1,'a0c'},{'(',1},{')',1}] = tokenize("a0c()"),
-  [{paren_identifier,1,'a0c!'},{'(',1},{')',1}] = tokenize("a0c!()").
+  [{identifier, {1, 1, _}, abc}] = tokenize("abc "),
+  [{identifier, {1, 1, _}, 'abc?'}] = tokenize("abc?"),
+  [{identifier, {1, 1, _}, 'abc!'}] = tokenize("abc!"),
+  [{identifier, {1, 1, _}, 'a0c!'}] = tokenize("a0c!"),
+  [{paren_identifier, {1, 1, _}, 'a0c'}, {'(', {1, 4, nil}}, {')', {1, 5, nil}}] = tokenize("a0c()"),
+  [{paren_identifier, {1, 1, _}, 'a0c!'}, {'(', {1, 5, nil}}, {')', {1, 6, nil}}] = tokenize("a0c!()").
 
 module_macro_test() ->
-  [{identifier,1,'__MODULE__'}] = tokenize("__MODULE__").
-
-triple_dot_test() ->
-  [{identifier,1,'...'}] = tokenize("..."),
-  [{'.',1},{identifier,1,'..'}] = tokenize(". ..").
+  [{identifier, {1, 1, _}, '__MODULE__'}] = tokenize("__MODULE__").
 
 dot_test() ->
-  [{identifier,1,foo},
-   {'.',1},
-   {identifier,1,bar},
-   {'.',1},
-   {identifier,1,baz}] = tokenize("foo.bar.baz").
+  [{identifier, {1, 1, _}, foo},
+   {'.', {1, 4, nil}},
+   {identifier, {1, 5, _}, bar},
+   {'.', {1, 8, nil}},
+   {identifier, {1, 9, _}, baz}] = tokenize("foo.bar.baz").
 
 dot_keyword_test() ->
- [{identifier,1,foo},
-  {'.',1},
-  {identifier,1,do}] = tokenize("foo.do").
+ [{identifier, {1, 1, _}, foo},
+  {'.', {1, 4, nil}},
+  {identifier, {1, 5, _}, do}] = tokenize("foo.do").
 
 newline_test() ->
- [{identifier,1,foo},
-  {'.',2},
-  {identifier,2,bar}]  = tokenize("foo\n.bar"),
-  [{number,1,1},
-   {two_op,2,'++'},
-   {number,2,2}]  = tokenize("1\n++2").
+  [{identifier, {1, 1, _}, foo},
+   {'.', {2, 1, nil}},
+   {identifier, {2, 2, _}, bar}]  = tokenize("foo\n.bar"),
+  [{int, {1, 1, 1}, "1"},
+   {concat_op, {2, 1, 1}, '++'},
+   {int, {2, 3, 2}, "2"}]  = tokenize("1\n++2").
+
+dot_newline_operator_test() ->
+  [{identifier, {1, 1, _}, foo},
+   {'.', {1, 4, nil}},
+   {identifier, {2, 1, _}, '+'},
+   {int, {2, 2, 1}, "1"}] = tokenize("foo.\n+1"),
+  [{identifier, {1, 1, _}, foo},
+   {'.', {1, 4, nil}},
+   {identifier, {2, 1, _}, '+'},
+   {int, {2, 2, 1}, "1"}] = tokenize("foo.#bar\n+1").
+
+dot_call_operator_test() ->
+  [{identifier, {1, 1, _}, f},
+   {dot_call_op, {1, 2, nil}, '.'},
+   {'(', {1, 3, nil}},
+   {')', {1, 4, nil}}] = tokenize("f.()").
 
 aliases_test() ->
-  [{'aliases',1,['Foo']}] = tokenize("Foo"),
-  [{'aliases',1,['Foo']},
-   {'.',1},
-   {'aliases',1,['Bar']},
-   {'.',1},
-   {'aliases',1,['Baz']}] = tokenize("Foo.Bar.Baz").
+  [{'alias', {1, 1, _}, 'Foo'}] = tokenize("Foo"),
+  [{'alias', {1, 1, _}, 'Foo'},
+   {'.', {1, 4, nil}},
+   {'alias', {1, 5, _}, 'Bar'},
+   {'.', {1, 8, nil}},
+   {'alias', {1, 9, _}, 'Baz'}] = tokenize("Foo.Bar.Baz").
 
 string_test() ->
-  [{bin_string,1,[<<"foo">>]}] = tokenize("\"foo\""),
-  [{list_string,1,[<<"foo">>]}] = tokenize("'foo'").
+  [{bin_string, {1, 1, nil}, [<<"foo">>]}] = tokenize("\"foo\""),
+  [{bin_string, {1, 1, nil}, [<<"f\"">>]}] = tokenize("\"f\\\"\"").
+
+heredoc_test() ->
+  [{bin_heredoc, {1, 1, nil}, 0, [<<"heredoc\n">>]}] = tokenize("\"\"\"\nheredoc\n\"\"\""),
+  [{bin_heredoc, {1, 1, nil}, 1, [<<"heredoc\n">>]}, {';', {3, 5, 0}}] = tokenize("\"\"\"\n heredoc\n \"\"\";").
 
 empty_string_test() ->
-  [{bin_string,1,[<<>>]}] = tokenize("\"\""),
-  [{list_string,1,[<<>>]}] = tokenize("''").
+  [{bin_string, {1, 1, nil}, [<<>>]}] = tokenize("\"\"").
 
-addadd_test() ->
-  [{identifier,1,x},{two_op,1,'++'},{identifier,1,y}] = tokenize("x ++ y").
+concat_test() ->
+  [{identifier, {1, 1, _}, x},
+   {concat_op, {1, 3, nil}, '++'},
+   {identifier, {1, 6, _}, y}] = tokenize("x ++ y"),
+  [{identifier, {1, 1, _}, x},
+   {concat_op, {1, 3, nil}, '+++'},
+   {identifier, {1, 7, _}, y}] = tokenize("x +++ y").
+
+space_test() ->
+  [{op_identifier, {1, 1, _}, foo},
+   {dual_op, {1, 5, nil}, '-'},
+   {int, {1, 6, 2}, "2"}] = tokenize("foo -2"),
+  [{op_identifier, {1, 1, _}, foo},
+   {dual_op, {1, 6, nil}, '-'},
+   {int, {1, 7, 2}, "2"}] = tokenize("foo  -2").
 
 chars_test() ->
-  [{number,1,97}]      = tokenize("?a"),
-  [{number,1,99}]      = tokenize("?c"),
-  [{number,1,7}]       = tokenize("?\\a"),
-  [{number,1,10}]      = tokenize("?\\n"),
-  [{number,1,92}]      = tokenize("?\\\\"),
-  [{number,1,10}]      = tokenize("?\\xa"),
-  [{number,1,26}]      = tokenize("?\\X1a"),
-  [{number,1,6}]       = tokenize("?\\6"),
-  [{number,1,49}]      = tokenize("?\\61"),
-  [{number,1,255}]     = tokenize("?\\377"),
-  [{number,1,10}]      = tokenize("?\\x{a}"),
-  [{number,1,171}]     = tokenize("?\\x{ab}"),
-  [{number,1,2748}]    = tokenize("?\\x{abc}"),
-  [{number,1,43981}]   = tokenize("?\\x{abcd}"),
-  [{number,1,703710}]  = tokenize("?\\x{abcde}"),
-  [{number,1,1092557}] = tokenize("?\\x{10abcd}").
+  [{char, {1, 1, "?a"}, 97}] = tokenize("?a"),
+  [{char, {1, 1, "?c"}, 99}] = tokenize("?c"),
+  [{char, {1, 1, "?\\0"}, 0}]  = tokenize("?\\0"),
+  [{char, {1, 1, "?\\a"}, 7}]  = tokenize("?\\a"),
+  [{char, {1, 1, "?\\n"}, 10}] = tokenize("?\\n"),
+  [{char, {1, 1, "?\\\\"}, 92}] = tokenize("?\\\\").
+
+interpolation_test() ->
+  [{bin_string, {1, 1, nil}, [<<"f">>, {{1, 3, nil},{1, 7, nil}, [{identifier, {1, 5, _}, oo}]}]},
+   {concat_op, {1, 10, nil}, '<>'},
+   {bin_string, {1, 13, nil}, [<<>>]}] = tokenize("\"f#{oo}\" <> \"\"").
+
+escaped_interpolation_test() ->
+  [{bin_string, {1, 1, nil}, [<<"f#{oo}">>]},
+   {concat_op, {1, 11, nil}, '<>'},
+   {bin_string, {1, 14, nil}, [<<>>]}] = tokenize("\"f\\#{oo}\" <> \"\"").
+
+capture_test() ->
+  % Parens precedence
+  [{capture_op, {1, 1, nil}, '&'},
+   {unary_op, {1, 2, nil}, 'not'},
+   {int, {1, 6, 1}, "1"},
+   {',', {1, 7, 0}},
+   {int, {1, 9, 2}, "2"}] = tokenize("&not 1, 2"),
+
+  % Operators
+  [{capture_op, {1, 1, nil}, '&'},
+   {identifier, {1, 2, _}, '||'},
+   {mult_op, {1, 4, nil}, '/'},
+   {int, {1, 5, 2}, "2"}] = tokenize("&||/2"),
+  [{capture_op, {1, 1, nil}, '&'},
+   {identifier, {1, 2, _}, 'or'},
+   {mult_op, {1, 4, nil}, '/'},
+   {int, {1, 5, 2}, "2"}] = tokenize("&or/2"),
+  [{capture_op,{1,1,nil},'&'},
+   {identifier,{1,3,_},'+'},
+   {mult_op,{1,4,nil},'/'},
+   {int,{1,5,1},"1"}] = tokenize("& +/1"),
+  [{capture_op,{1,1,nil},'&'},
+   {identifier,{1,3,_},'&'},
+   {mult_op,{1,4,nil},'/'},
+   {int,{1,5,1},"1"}] = tokenize("& &/1"),
+  [{capture_op,{1,1,nil},'&'},
+   {identifier,{1,3,_},'..//'},
+   {mult_op,{1,7,nil},'/'},
+   {int,{1,8,3},"3"}] = tokenize("& ..///3"),
+  [{capture_op, {1,1,nil}, '&'},
+   {identifier, {1,3,_}, '/'},
+   {mult_op, {1,5,nil}, '/'},
+   {int, {1,6,2}, "2"}] = tokenize("& / /2"),
+  [{capture_op, {1,1,nil}, '&'},
+   {identifier, {1,2,_}, '/'},
+   {mult_op, {1,4,nil}, '/'},
+   {int, {1,5,2}, "2"}] = tokenize("&/ /2"),
+
+  % Only operators
+  [{identifier,{1,1,_},'&'},
+   {mult_op,{1,2,nil},'/'},
+   {int,{1,3,1},"1"}] = tokenize("&/1"),
+  [{identifier,{1,1,_},'+'},
+   {mult_op,{1,2,nil},'/'},
+   {int,{1,3,1},"1"}] = tokenize("+/1"),
+  [{identifier, {1,1,_}, '/'},
+   {mult_op, {1,3,nil}, '/'},
+   {int, {1,4,2}, "2"}] = tokenize("/ /2"),
+  [{identifier, {1,1,_}, '..//'},
+   {mult_op, {1,5,nil}, '/'},
+   {int, {1,6,3}, "3"}] = tokenize("..///3").
+
+vc_merge_conflict_test() ->
+  {[{line, 1}, {column, 1}], "found an unexpected version control marker, please resolve the conflicts: ", "<<<<<<< HEAD"} =
+    tokenize_error("<<<<<<< HEAD\n[1, 2, 3]").
+
+sigil_terminator_test() ->
+  [{sigil, {1, 1, nil}, sigil_r, [<<"foo">>], "", nil, <<"/">>}] = tokenize("~r/foo/"),
+  [{sigil, {1, 1, nil}, sigil_r, [<<"foo">>], "", nil, <<"[">>}] = tokenize("~r[foo]"),
+  [{sigil, {1, 1, nil}, sigil_r, [<<"foo">>], "", nil, <<"\"">>}] = tokenize("~r\"foo\""),
+  [{sigil, {1, 1, nil}, sigil_r, [<<"foo">>], "", nil, <<"/">>},
+   {comp_op, {1, 9, nil}, '=='},
+   {identifier, {1, 12, _}, bar}] = tokenize("~r/foo/ == bar"),
+  [{sigil, {1, 1, nil}, sigil_r, [<<"foo">>], "iu", nil, <<"/">>},
+   {comp_op, {1, 11, nil}, '=='},
+   {identifier, {1, 14, _}, bar}] = tokenize("~r/foo/iu == bar"),
+  [{sigil, {1, 1, nil}, sigil_M, [<<"1 2 3">>], "u8", nil, <<"[">>}] = tokenize("~M[1 2 3]u8").
+
+sigil_heredoc_test() ->
+  [{sigil, {1, 1, nil}, sigil_S, [<<"sigil heredoc\n">>], "", 0, <<"\"\"\"">>}] = tokenize("~S\"\"\"\nsigil heredoc\n\"\"\""),
+  [{sigil, {1, 1, nil}, sigil_S, [<<"sigil heredoc\n">>], "", 0, <<"'''">>}] = tokenize("~S'''\nsigil heredoc\n'''"),
+  [{sigil, {1, 1, nil}, sigil_S, [<<"sigil heredoc\n">>], "", 2, <<"\"\"\"">>}] = tokenize("~S\"\"\"\n  sigil heredoc\n  \"\"\""),
+  [{sigil, {1, 1, nil}, sigil_s, [<<"sigil heredoc\n">>], "", 2, <<"\"\"\"">>}] = tokenize("~s\"\"\"\n  sigil heredoc\n  \"\"\"").
+
+invalid_sigil_delimiter_test() ->
+  {[{line, 1}, {column, 1}], "invalid sigil delimiter: ", Message} = tokenize_error("~s\\"),
+  true = lists:prefix("\"\\\" (column 3, code point U+005C)", lists:flatten(Message)).
+
+deprecated_operators_test() ->
+  {
+    [{xor_op, {1, 1, nil}, '^^^'}, {int, {1, 4, 1}, "1"}],
+    [{{1, 1}, "^^^ is deprecated. It is typically used as xor but it has the wrong precedence, use Bitwise.bxor/2 instead"}]
+  } = tokenize_warnings("^^^1"),
+  {
+    [{unary_op, {1, 1, nil}, '~~~'}, {int, {1, 4, 1}, "1"}],
+    [{{1, 1}, "~~~ is deprecated. Use Bitwise.bnot/1 instead for clarity"}]
+  } = tokenize_warnings("~~~1").
diff --git a/lib/elixir/unicode/GraphemeBreakProperty.txt b/lib/elixir/unicode/GraphemeBreakProperty.txt
deleted file mode 100644
index f13970a2567..00000000000
--- a/lib/elixir/unicode/GraphemeBreakProperty.txt
+++ /dev/null
@@ -1,1252 +0,0 @@
-000D          ; CR # Cc       <control-000D>
-000A          ; LF # Cc       <control-000A>
-0000..0009    ; Control # Cc  [10] <control-0000>..<control-0009>
-000B..000C    ; Control # Cc   [2] <control-000B>..<control-000C>
-000E..001F    ; Control # Cc  [18] <control-000E>..<control-001F>
-007F..009F    ; Control # Cc  [33] <control-007F>..<control-009F>
-00AD          ; Control # Cf       SOFT HYPHEN
-0600..0605    ; Control # Cf   [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE
-061C          ; Control # Cf       ARABIC LETTER MARK
-06DD          ; Control # Cf       ARABIC END OF AYAH
-070F          ; Control # Cf       SYRIAC ABBREVIATION MARK
-180E          ; Control # Cf       MONGOLIAN VOWEL SEPARATOR
-200B          ; Control # Cf       ZERO WIDTH SPACE
-200E..200F    ; Control # Cf   [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT MARK
-2028          ; Control # Zl       LINE SEPARATOR
-2029          ; Control # Zp       PARAGRAPH SEPARATOR
-202A..202E    ; Control # Cf   [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE
-2060..2064    ; Control # Cf   [5] WORD JOINER..INVISIBLE PLUS
-2065          ; Control # Cn       <reserved-2065>
-2066..206F    ; Control # Cf  [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES
-D800..DFFF    ; Control # Cs [2048] <surrogate-D800>..<surrogate-DFFF>
-FEFF          ; Control # Cf       ZERO WIDTH NO-BREAK SPACE
-FFF0..FFF8    ; Control # Cn   [9] <reserved-FFF0>..<reserved-FFF8>
-FFF9..FFFB    ; Control # Cf   [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR
-110BD         ; Control # Cf       KAITHI NUMBER SIGN
-1BCA0..1BCA3  ; Control # Cf   [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP
-1D173..1D17A  ; Control # Cf   [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE
-E0000         ; Control # Cn       <reserved-E0000>
-E0001         ; Control # Cf       LANGUAGE TAG
-E0002..E001F  ; Control # Cn  [30] <reserved-E0002>..<reserved-E001F>
-E0020..E007F  ; Control # Cf  [96] TAG SPACE..CANCEL TAG
-E0080..E00FF  ; Control # Cn [128] <reserved-E0080>..<reserved-E00FF>
-E01F0..E0FFF  ; Control # Cn [3600] <reserved-E01F0>..<reserved-E0FFF>
-0300..036F    ; Extend # Mn [112] COMBINING GRAVE ACCENT..COMBINING LATIN SMALL LETTER X
-0483..0487    ; Extend # Mn   [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE
-0488..0489    ; Extend # Me   [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN
-0591..05BD    ; Extend # Mn  [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG
-05BF          ; Extend # Mn       HEBREW POINT RAFE
-05C1..05C2    ; Extend # Mn   [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT
-05C4..05C5    ; Extend # Mn   [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT
-05C7          ; Extend # Mn       HEBREW POINT QAMATS QATAN
-0610..061A    ; Extend # Mn  [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA
-064B..065F    ; Extend # Mn  [21] ARABIC FATHATAN..ARABIC WAVY HAMZA BELOW
-0670          ; Extend # Mn       ARABIC LETTER SUPERSCRIPT ALEF
-06D6..06DC    ; Extend # Mn   [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN
-06DF..06E4    ; Extend # Mn   [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA
-06E7..06E8    ; Extend # Mn   [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON
-06EA..06ED    ; Extend # Mn   [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM
-0711          ; Extend # Mn       SYRIAC LETTER SUPERSCRIPT ALAPH
-0730..074A    ; Extend # Mn  [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH
-07A6..07B0    ; Extend # Mn  [11] THAANA ABAFILI..THAANA SUKUN
-07EB..07F3    ; Extend # Mn   [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE
-0816..0819    ; Extend # Mn   [4] SAMARITAN MARK IN..SAMARITAN MARK DAGESH
-081B..0823    ; Extend # Mn   [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A
-0825..0827    ; Extend # Mn   [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U
-0829..082D    ; Extend # Mn   [5] SAMARITAN VOWEL SIGN LONG I..SAMARITAN MARK NEQUDAA
-0859..085B    ; Extend # Mn   [3] MANDAIC AFFRICATION MARK..MANDAIC GEMINATION MARK
-08E4..0902    ; Extend # Mn  [31] ARABIC CURLY FATHA..DEVANAGARI SIGN ANUSVARA
-093A          ; Extend # Mn       DEVANAGARI VOWEL SIGN OE
-093C          ; Extend # Mn       DEVANAGARI SIGN NUKTA
-0941..0948    ; Extend # Mn   [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI
-094D          ; Extend # Mn       DEVANAGARI SIGN VIRAMA
-0951..0957    ; Extend # Mn   [7] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI VOWEL SIGN UUE
-0962..0963    ; Extend # Mn   [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL
-0981          ; Extend # Mn       BENGALI SIGN CANDRABINDU
-09BC          ; Extend # Mn       BENGALI SIGN NUKTA
-09BE          ; Extend # Mc       BENGALI VOWEL SIGN AA
-09C1..09C4    ; Extend # Mn   [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR
-09CD          ; Extend # Mn       BENGALI SIGN VIRAMA
-09D7          ; Extend # Mc       BENGALI AU LENGTH MARK
-09E2..09E3    ; Extend # Mn   [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL
-0A01..0A02    ; Extend # Mn   [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI
-0A3C          ; Extend # Mn       GURMUKHI SIGN NUKTA
-0A41..0A42    ; Extend # Mn   [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU
-0A47..0A48    ; Extend # Mn   [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI
-0A4B..0A4D    ; Extend # Mn   [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA
-0A51          ; Extend # Mn       GURMUKHI SIGN UDAAT
-0A70..0A71    ; Extend # Mn   [2] GURMUKHI TIPPI..GURMUKHI ADDAK
-0A75          ; Extend # Mn       GURMUKHI SIGN YAKASH
-0A81..0A82    ; Extend # Mn   [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA
-0ABC          ; Extend # Mn       GUJARATI SIGN NUKTA
-0AC1..0AC5    ; Extend # Mn   [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E
-0AC7..0AC8    ; Extend # Mn   [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI
-0ACD          ; Extend # Mn       GUJARATI SIGN VIRAMA
-0AE2..0AE3    ; Extend # Mn   [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL
-0B01          ; Extend # Mn       ORIYA SIGN CANDRABINDU
-0B3C          ; Extend # Mn       ORIYA SIGN NUKTA
-0B3E          ; Extend # Mc       ORIYA VOWEL SIGN AA
-0B3F          ; Extend # Mn       ORIYA VOWEL SIGN I
-0B41..0B44    ; Extend # Mn   [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR
-0B4D          ; Extend # Mn       ORIYA SIGN VIRAMA
-0B56          ; Extend # Mn       ORIYA AI LENGTH MARK
-0B57          ; Extend # Mc       ORIYA AU LENGTH MARK
-0B62..0B63    ; Extend # Mn   [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL
-0B82          ; Extend # Mn       TAMIL SIGN ANUSVARA
-0BBE          ; Extend # Mc       TAMIL VOWEL SIGN AA
-0BC0          ; Extend # Mn       TAMIL VOWEL SIGN II
-0BCD          ; Extend # Mn       TAMIL SIGN VIRAMA
-0BD7          ; Extend # Mc       TAMIL AU LENGTH MARK
-0C00          ; Extend # Mn       TELUGU SIGN COMBINING CANDRABINDU ABOVE
-0C3E..0C40    ; Extend # Mn   [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II
-0C46..0C48    ; Extend # Mn   [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI
-0C4A..0C4D    ; Extend # Mn   [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA
-0C55..0C56    ; Extend # Mn   [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK
-0C62..0C63    ; Extend # Mn   [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL
-0C81          ; Extend # Mn       KANNADA SIGN CANDRABINDU
-0CBC          ; Extend # Mn       KANNADA SIGN NUKTA
-0CBF          ; Extend # Mn       KANNADA VOWEL SIGN I
-0CC2          ; Extend # Mc       KANNADA VOWEL SIGN UU
-0CC6          ; Extend # Mn       KANNADA VOWEL SIGN E
-0CCC..0CCD    ; Extend # Mn   [2] KANNADA VOWEL SIGN AU..KANNADA SIGN VIRAMA
-0CD5..0CD6    ; Extend # Mc   [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK
-0CE2..0CE3    ; Extend # Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
-0D01          ; Extend # Mn       MALAYALAM SIGN CANDRABINDU
-0D3E          ; Extend # Mc       MALAYALAM VOWEL SIGN AA
-0D41..0D44    ; Extend # Mn   [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR
-0D4D          ; Extend # Mn       MALAYALAM SIGN VIRAMA
-0D57          ; Extend # Mc       MALAYALAM AU LENGTH MARK
-0D62..0D63    ; Extend # Mn   [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL
-0DCA          ; Extend # Mn       SINHALA SIGN AL-LAKUNA
-0DCF          ; Extend # Mc       SINHALA VOWEL SIGN AELA-PILLA
-0DD2..0DD4    ; Extend # Mn   [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA
-0DD6          ; Extend # Mn       SINHALA VOWEL SIGN DIGA PAA-PILLA
-0DDF          ; Extend # Mc       SINHALA VOWEL SIGN GAYANUKITTA
-0E31          ; Extend # Mn       THAI CHARACTER MAI HAN-AKAT
-0E34..0E3A    ; Extend # Mn   [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU
-0E47..0E4E    ; Extend # Mn   [8] THAI CHARACTER MAITAIKHU..THAI CHARACTER YAMAKKAN
-0EB1          ; Extend # Mn       LAO VOWEL SIGN MAI KAN
-0EB4..0EB9    ; Extend # Mn   [6] LAO VOWEL SIGN I..LAO VOWEL SIGN UU
-0EBB..0EBC    ; Extend # Mn   [2] LAO VOWEL SIGN MAI KON..LAO SEMIVOWEL SIGN LO
-0EC8..0ECD    ; Extend # Mn   [6] LAO TONE MAI EK..LAO NIGGAHITA
-0F18..0F19    ; Extend # Mn   [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS
-0F35          ; Extend # Mn       TIBETAN MARK NGAS BZUNG NYI ZLA
-0F37          ; Extend # Mn       TIBETAN MARK NGAS BZUNG SGOR RTAGS
-0F39          ; Extend # Mn       TIBETAN MARK TSA -PHRU
-0F71..0F7E    ; Extend # Mn  [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO
-0F80..0F84    ; Extend # Mn   [5] TIBETAN VOWEL SIGN REVERSED I..TIBETAN MARK HALANTA
-0F86..0F87    ; Extend # Mn   [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS
-0F8D..0F97    ; Extend # Mn  [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA
-0F99..0FBC    ; Extend # Mn  [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA
-0FC6          ; Extend # Mn       TIBETAN SYMBOL PADMA GDAN
-102D..1030    ; Extend # Mn   [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU
-1032..1037    ; Extend # Mn   [6] MYANMAR VOWEL SIGN AI..MYANMAR SIGN DOT BELOW
-1039..103A    ; Extend # Mn   [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT
-103D..103E    ; Extend # Mn   [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA
-1058..1059    ; Extend # Mn   [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL
-105E..1060    ; Extend # Mn   [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA
-1071..1074    ; Extend # Mn   [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE
-1082          ; Extend # Mn       MYANMAR CONSONANT SIGN SHAN MEDIAL WA
-1085..1086    ; Extend # Mn   [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y
-108D          ; Extend # Mn       MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE
-109D          ; Extend # Mn       MYANMAR VOWEL SIGN AITON AI
-135D..135F    ; Extend # Mn   [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK
-1712..1714    ; Extend # Mn   [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN VIRAMA
-1732..1734    ; Extend # Mn   [3] HANUNOO VOWEL SIGN I..HANUNOO SIGN PAMUDPOD
-1752..1753    ; Extend # Mn   [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U
-1772..1773    ; Extend # Mn   [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U
-17B4..17B5    ; Extend # Mn   [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA
-17B7..17BD    ; Extend # Mn   [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA
-17C6          ; Extend # Mn       KHMER SIGN NIKAHIT
-17C9..17D3    ; Extend # Mn  [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT
-17DD          ; Extend # Mn       KHMER SIGN ATTHACAN
-180B..180D    ; Extend # Mn   [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE
-18A9          ; Extend # Mn       MONGOLIAN LETTER ALI GALI DAGALGA
-1920..1922    ; Extend # Mn   [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U
-1927..1928    ; Extend # Mn   [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O
-1932          ; Extend # Mn       LIMBU SMALL LETTER ANUSVARA
-1939..193B    ; Extend # Mn   [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I
-1A17..1A18    ; Extend # Mn   [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U
-1A1B          ; Extend # Mn       BUGINESE VOWEL SIGN AE
-1A56          ; Extend # Mn       TAI THAM CONSONANT SIGN MEDIAL LA
-1A58..1A5E    ; Extend # Mn   [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA
-1A60          ; Extend # Mn       TAI THAM SIGN SAKOT
-1A62          ; Extend # Mn       TAI THAM VOWEL SIGN MAI SAT
-1A65..1A6C    ; Extend # Mn   [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW
-1A73..1A7C    ; Extend # Mn  [10] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN KHUEN-LUE KARAN
-1A7F          ; Extend # Mn       TAI THAM COMBINING CRYPTOGRAMMIC DOT
-1AB0..1ABD    ; Extend # Mn  [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW
-1ABE          ; Extend # Me       COMBINING PARENTHESES OVERLAY
-1B00..1B03    ; Extend # Mn   [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG
-1B34          ; Extend # Mn       BALINESE SIGN REREKAN
-1B36..1B3A    ; Extend # Mn   [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA
-1B3C          ; Extend # Mn       BALINESE VOWEL SIGN LA LENGA
-1B42          ; Extend # Mn       BALINESE VOWEL SIGN PEPET
-1B6B..1B73    ; Extend # Mn   [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG
-1B80..1B81    ; Extend # Mn   [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR
-1BA2..1BA5    ; Extend # Mn   [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU
-1BA8..1BA9    ; Extend # Mn   [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG
-1BAB..1BAD    ; Extend # Mn   [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA
-1BE6          ; Extend # Mn       BATAK SIGN TOMPI
-1BE8..1BE9    ; Extend # Mn   [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE
-1BED          ; Extend # Mn       BATAK VOWEL SIGN KARO O
-1BEF..1BF1    ; Extend # Mn   [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H
-1C2C..1C33    ; Extend # Mn   [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T
-1C36..1C37    ; Extend # Mn   [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA
-1CD0..1CD2    ; Extend # Mn   [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA
-1CD4..1CE0    ; Extend # Mn  [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA
-1CE2..1CE8    ; Extend # Mn   [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL
-1CED          ; Extend # Mn       VEDIC SIGN TIRYAK
-1CF4          ; Extend # Mn       VEDIC TONE CANDRA ABOVE
-1CF8..1CF9    ; Extend # Mn   [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE
-1DC0..1DF5    ; Extend # Mn  [54] COMBINING DOTTED GRAVE ACCENT..COMBINING UP TACK ABOVE
-1DFC..1DFF    ; Extend # Mn   [4] COMBINING DOUBLE INVERTED BREVE BELOW..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW
-200C..200D    ; Extend # Cf   [2] ZERO WIDTH NON-JOINER..ZERO WIDTH JOINER
-20D0..20DC    ; Extend # Mn  [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE
-20DD..20E0    ; Extend # Me   [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH
-20E1          ; Extend # Mn       COMBINING LEFT RIGHT ARROW ABOVE
-20E2..20E4    ; Extend # Me   [3] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING UPWARD POINTING TRIANGLE
-20E5..20F0    ; Extend # Mn  [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE
-2CEF..2CF1    ; Extend # Mn   [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS
-2D7F          ; Extend # Mn       TIFINAGH CONSONANT JOINER
-2DE0..2DFF    ; Extend # Mn  [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS
-302A..302D    ; Extend # Mn   [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK
-302E..302F    ; Extend # Mc   [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK
-3099..309A    ; Extend # Mn   [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
-A66F          ; Extend # Mn       COMBINING CYRILLIC VZMET
-A670..A672    ; Extend # Me   [3] COMBINING CYRILLIC TEN MILLIONS SIGN..COMBINING CYRILLIC THOUSAND MILLIONS SIGN
-A674..A67D    ; Extend # Mn  [10] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC PAYEROK
-A69F          ; Extend # Mn       COMBINING CYRILLIC LETTER IOTIFIED E
-A6F0..A6F1    ; Extend # Mn   [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS
-A802          ; Extend # Mn       SYLOTI NAGRI SIGN DVISVARA
-A806          ; Extend # Mn       SYLOTI NAGRI SIGN HASANTA
-A80B          ; Extend # Mn       SYLOTI NAGRI SIGN ANUSVARA
-A825..A826    ; Extend # Mn   [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E
-A8C4          ; Extend # Mn       SAURASHTRA SIGN VIRAMA
-A8E0..A8F1    ; Extend # Mn  [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA
-A926..A92D    ; Extend # Mn   [8] KAYAH LI VOWEL UE..KAYAH LI TONE CALYA PLOPHU
-A947..A951    ; Extend # Mn  [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R
-A980..A982    ; Extend # Mn   [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR
-A9B3          ; Extend # Mn       JAVANESE SIGN CECAK TELU
-A9B6..A9B9    ; Extend # Mn   [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT
-A9BC          ; Extend # Mn       JAVANESE VOWEL SIGN PEPET
-A9E5          ; Extend # Mn       MYANMAR SIGN SHAN SAW
-AA29..AA2E    ; Extend # Mn   [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE
-AA31..AA32    ; Extend # Mn   [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE
-AA35..AA36    ; Extend # Mn   [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA
-AA43          ; Extend # Mn       CHAM CONSONANT SIGN FINAL NG
-AA4C          ; Extend # Mn       CHAM CONSONANT SIGN FINAL M
-AA7C          ; Extend # Mn       MYANMAR SIGN TAI LAING TONE-2
-AAB0          ; Extend # Mn       TAI VIET MAI KANG
-AAB2..AAB4    ; Extend # Mn   [3] TAI VIET VOWEL I..TAI VIET VOWEL U
-AAB7..AAB8    ; Extend # Mn   [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA
-AABE..AABF    ; Extend # Mn   [2] TAI VIET VOWEL AM..TAI VIET TONE MAI EK
-AAC1          ; Extend # Mn       TAI VIET TONE MAI THO
-AAEC..AAED    ; Extend # Mn   [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI
-AAF6          ; Extend # Mn       MEETEI MAYEK VIRAMA
-ABE5          ; Extend # Mn       MEETEI MAYEK VOWEL SIGN ANAP
-ABE8          ; Extend # Mn       MEETEI MAYEK VOWEL SIGN UNAP
-ABED          ; Extend # Mn       MEETEI MAYEK APUN IYEK
-FB1E          ; Extend # Mn       HEBREW POINT JUDEO-SPANISH VARIKA
-FE00..FE0F    ; Extend # Mn  [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16
-FE20..FE2D    ; Extend # Mn  [14] COMBINING LIGATURE LEFT HALF..COMBINING CONJOINING MACRON BELOW
-FF9E..FF9F    ; Extend # Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
-101FD         ; Extend # Mn       PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE
-102E0         ; Extend # Mn       COPTIC EPACT THOUSANDS MARK
-10376..1037A  ; Extend # Mn   [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII
-10A01..10A03  ; Extend # Mn   [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R
-10A05..10A06  ; Extend # Mn   [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O
-10A0C..10A0F  ; Extend # Mn   [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA
-10A38..10A3A  ; Extend # Mn   [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW
-10A3F         ; Extend # Mn       KHAROSHTHI VIRAMA
-10AE5..10AE6  ; Extend # Mn   [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW
-11001         ; Extend # Mn       BRAHMI SIGN ANUSVARA
-11038..11046  ; Extend # Mn  [15] BRAHMI VOWEL SIGN AA..BRAHMI VIRAMA
-1107F..11081  ; Extend # Mn   [3] BRAHMI NUMBER JOINER..KAITHI SIGN ANUSVARA
-110B3..110B6  ; Extend # Mn   [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI
-110B9..110BA  ; Extend # Mn   [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA
-11100..11102  ; Extend # Mn   [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA
-11127..1112B  ; Extend # Mn   [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU
-1112D..11134  ; Extend # Mn   [8] CHAKMA VOWEL SIGN AI..CHAKMA MAAYYAA
-11173         ; Extend # Mn       MAHAJANI SIGN NUKTA
-11180..11181  ; Extend # Mn   [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA
-111B6..111BE  ; Extend # Mn   [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O
-1122F..11231  ; Extend # Mn   [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI
-11234         ; Extend # Mn       KHOJKI SIGN ANUSVARA
-11236..11237  ; Extend # Mn   [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA
-112DF         ; Extend # Mn       KHUDAWADI SIGN ANUSVARA
-112E3..112EA  ; Extend # Mn   [8] KHUDAWADI VOWEL SIGN U..KHUDAWADI SIGN VIRAMA
-11301         ; Extend # Mn       GRANTHA SIGN CANDRABINDU
-1133C         ; Extend # Mn       GRANTHA SIGN NUKTA
-1133E         ; Extend # Mc       GRANTHA VOWEL SIGN AA
-11340         ; Extend # Mn       GRANTHA VOWEL SIGN II
-11357         ; Extend # Mc       GRANTHA AU LENGTH MARK
-11366..1136C  ; Extend # Mn   [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX
-11370..11374  ; Extend # Mn   [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA
-114B0         ; Extend # Mc       TIRHUTA VOWEL SIGN AA
-114B3..114B8  ; Extend # Mn   [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL
-114BA         ; Extend # Mn       TIRHUTA VOWEL SIGN SHORT E
-114BD         ; Extend # Mc       TIRHUTA VOWEL SIGN SHORT O
-114BF..114C0  ; Extend # Mn   [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA
-114C2..114C3  ; Extend # Mn   [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA
-115AF         ; Extend # Mc       SIDDHAM VOWEL SIGN AA
-115B2..115B5  ; Extend # Mn   [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR
-115BC..115BD  ; Extend # Mn   [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA
-115BF..115C0  ; Extend # Mn   [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA
-11633..1163A  ; Extend # Mn   [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI
-1163D         ; Extend # Mn       MODI SIGN ANUSVARA
-1163F..11640  ; Extend # Mn   [2] MODI SIGN VIRAMA..MODI SIGN ARDHACANDRA
-116AB         ; Extend # Mn       TAKRI SIGN ANUSVARA
-116AD         ; Extend # Mn       TAKRI VOWEL SIGN AA
-116B0..116B5  ; Extend # Mn   [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU
-116B7         ; Extend # Mn       TAKRI SIGN NUKTA
-16AF0..16AF4  ; Extend # Mn   [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE
-16B30..16B36  ; Extend # Mn   [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM
-16F8F..16F92  ; Extend # Mn   [4] MIAO TONE RIGHT..MIAO TONE BELOW
-1BC9D..1BC9E  ; Extend # Mn   [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK
-1D165         ; Extend # Mc       MUSICAL SYMBOL COMBINING STEM
-1D167..1D169  ; Extend # Mn   [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3
-1D16E..1D172  ; Extend # Mc   [5] MUSICAL SYMBOL COMBINING FLAG-1..MUSICAL SYMBOL COMBINING FLAG-5
-1D17B..1D182  ; Extend # Mn   [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE
-1D185..1D18B  ; Extend # Mn   [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE
-1D1AA..1D1AD  ; Extend # Mn   [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO
-1D242..1D244  ; Extend # Mn   [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME
-1E8D0..1E8D6  ; Extend # Mn   [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS
-E0100..E01EF  ; Extend # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256
-1F1E6..1F1FF  ; Regional_Indicator # So  [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z
-0903          ; SpacingMark # Mc       DEVANAGARI SIGN VISARGA
-093B          ; SpacingMark # Mc       DEVANAGARI VOWEL SIGN OOE
-093E..0940    ; SpacingMark # Mc   [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II
-0949..094C    ; SpacingMark # Mc   [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU
-094E..094F    ; SpacingMark # Mc   [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW
-0982..0983    ; SpacingMark # Mc   [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA
-09BF..09C0    ; SpacingMark # Mc   [2] BENGALI VOWEL SIGN I..BENGALI VOWEL SIGN II
-09C7..09C8    ; SpacingMark # Mc   [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI
-09CB..09CC    ; SpacingMark # Mc   [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU
-0A03          ; SpacingMark # Mc       GURMUKHI SIGN VISARGA
-0A3E..0A40    ; SpacingMark # Mc   [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II
-0A83          ; SpacingMark # Mc       GUJARATI SIGN VISARGA
-0ABE..0AC0    ; SpacingMark # Mc   [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II
-0AC9          ; SpacingMark # Mc       GUJARATI VOWEL SIGN CANDRA O
-0ACB..0ACC    ; SpacingMark # Mc   [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU
-0B02..0B03    ; SpacingMark # Mc   [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA
-0B40          ; SpacingMark # Mc       ORIYA VOWEL SIGN II
-0B47..0B48    ; SpacingMark # Mc   [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI
-0B4B..0B4C    ; SpacingMark # Mc   [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU
-0BBF          ; SpacingMark # Mc       TAMIL VOWEL SIGN I
-0BC1..0BC2    ; SpacingMark # Mc   [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU
-0BC6..0BC8    ; SpacingMark # Mc   [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI
-0BCA..0BCC    ; SpacingMark # Mc   [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU
-0C01..0C03    ; SpacingMark # Mc   [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA
-0C41..0C44    ; SpacingMark # Mc   [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR
-0C82..0C83    ; SpacingMark # Mc   [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA
-0CBE          ; SpacingMark # Mc       KANNADA VOWEL SIGN AA
-0CC0..0CC1    ; SpacingMark # Mc   [2] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN U
-0CC3..0CC4    ; SpacingMark # Mc   [2] KANNADA VOWEL SIGN VOCALIC R..KANNADA VOWEL SIGN VOCALIC RR
-0CC7..0CC8    ; SpacingMark # Mc   [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI
-0CCA..0CCB    ; SpacingMark # Mc   [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO
-0D02..0D03    ; SpacingMark # Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
-0D3F..0D40    ; SpacingMark # Mc   [2] MALAYALAM VOWEL SIGN I..MALAYALAM VOWEL SIGN II
-0D46..0D48    ; SpacingMark # Mc   [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI
-0D4A..0D4C    ; SpacingMark # Mc   [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU
-0D82..0D83    ; SpacingMark # Mc   [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA
-0DD0..0DD1    ; SpacingMark # Mc   [2] SINHALA VOWEL SIGN KETTI AEDA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA
-0DD8..0DDE    ; SpacingMark # Mc   [7] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA
-0DF2..0DF3    ; SpacingMark # Mc   [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA
-0E33          ; SpacingMark # Lo       THAI CHARACTER SARA AM
-0EB3          ; SpacingMark # Lo       LAO VOWEL SIGN AM
-0F3E..0F3F    ; SpacingMark # Mc   [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES
-0F7F          ; SpacingMark # Mc       TIBETAN SIGN RNAM BCAD
-1031          ; SpacingMark # Mc       MYANMAR VOWEL SIGN E
-103B..103C    ; SpacingMark # Mc   [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA
-1056..1057    ; SpacingMark # Mc   [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR
-1084          ; SpacingMark # Mc       MYANMAR VOWEL SIGN SHAN E
-17B6          ; SpacingMark # Mc       KHMER VOWEL SIGN AA
-17BE..17C5    ; SpacingMark # Mc   [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU
-17C7..17C8    ; SpacingMark # Mc   [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU
-1923..1926    ; SpacingMark # Mc   [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU
-1929..192B    ; SpacingMark # Mc   [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA
-1930..1931    ; SpacingMark # Mc   [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA
-1933..1938    ; SpacingMark # Mc   [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA
-19B5..19B7    ; SpacingMark # Mc   [3] NEW TAI LUE VOWEL SIGN E..NEW TAI LUE VOWEL SIGN O
-19BA          ; SpacingMark # Mc       NEW TAI LUE VOWEL SIGN AY
-1A19..1A1A    ; SpacingMark # Mc   [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O
-1A55          ; SpacingMark # Mc       TAI THAM CONSONANT SIGN MEDIAL RA
-1A57          ; SpacingMark # Mc       TAI THAM CONSONANT SIGN LA TANG LAI
-1A6D..1A72    ; SpacingMark # Mc   [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI
-1B04          ; SpacingMark # Mc       BALINESE SIGN BISAH
-1B35          ; SpacingMark # Mc       BALINESE VOWEL SIGN TEDUNG
-1B3B          ; SpacingMark # Mc       BALINESE VOWEL SIGN RA REPA TEDUNG
-1B3D..1B41    ; SpacingMark # Mc   [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG
-1B43..1B44    ; SpacingMark # Mc   [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG
-1B82          ; SpacingMark # Mc       SUNDANESE SIGN PANGWISAD
-1BA1          ; SpacingMark # Mc       SUNDANESE CONSONANT SIGN PAMINGKAL
-1BA6..1BA7    ; SpacingMark # Mc   [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG
-1BAA          ; SpacingMark # Mc       SUNDANESE SIGN PAMAAEH
-1BE7          ; SpacingMark # Mc       BATAK VOWEL SIGN E
-1BEA..1BEC    ; SpacingMark # Mc   [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O
-1BEE          ; SpacingMark # Mc       BATAK VOWEL SIGN U
-1BF2..1BF3    ; SpacingMark # Mc   [2] BATAK PANGOLAT..BATAK PANONGONAN
-1C24..1C2B    ; SpacingMark # Mc   [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU
-1C34..1C35    ; SpacingMark # Mc   [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG
-1CE1          ; SpacingMark # Mc       VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA
-1CF2..1CF3    ; SpacingMark # Mc   [2] VEDIC SIGN ARDHAVISARGA..VEDIC SIGN ROTATED ARDHAVISARGA
-A823..A824    ; SpacingMark # Mc   [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I
-A827          ; SpacingMark # Mc       SYLOTI NAGRI VOWEL SIGN OO
-A880..A881    ; SpacingMark # Mc   [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA
-A8B4..A8C3    ; SpacingMark # Mc  [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU
-A952..A953    ; SpacingMark # Mc   [2] REJANG CONSONANT SIGN H..REJANG VIRAMA
-A983          ; SpacingMark # Mc       JAVANESE SIGN WIGNYAN
-A9B4..A9B5    ; SpacingMark # Mc   [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG
-A9BA..A9BB    ; SpacingMark # Mc   [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE
-A9BD..A9C0    ; SpacingMark # Mc   [4] JAVANESE CONSONANT SIGN KERET..JAVANESE PANGKON
-AA2F..AA30    ; SpacingMark # Mc   [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI
-AA33..AA34    ; SpacingMark # Mc   [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA
-AA4D          ; SpacingMark # Mc       CHAM CONSONANT SIGN FINAL H
-AAEB          ; SpacingMark # Mc       MEETEI MAYEK VOWEL SIGN II
-AAEE..AAEF    ; SpacingMark # Mc   [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU
-AAF5          ; SpacingMark # Mc       MEETEI MAYEK VOWEL SIGN VISARGA
-ABE3..ABE4    ; SpacingMark # Mc   [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP
-ABE6..ABE7    ; SpacingMark # Mc   [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP
-ABE9..ABEA    ; SpacingMark # Mc   [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG
-ABEC          ; SpacingMark # Mc       MEETEI MAYEK LUM IYEK
-11000         ; SpacingMark # Mc       BRAHMI SIGN CANDRABINDU
-11002         ; SpacingMark # Mc       BRAHMI SIGN VISARGA
-11082         ; SpacingMark # Mc       KAITHI SIGN VISARGA
-110B0..110B2  ; SpacingMark # Mc   [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II
-110B7..110B8  ; SpacingMark # Mc   [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU
-1112C         ; SpacingMark # Mc       CHAKMA VOWEL SIGN E
-11182         ; SpacingMark # Mc       SHARADA SIGN VISARGA
-111B3..111B5  ; SpacingMark # Mc   [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II
-111BF..111C0  ; SpacingMark # Mc   [2] SHARADA VOWEL SIGN AU..SHARADA SIGN VIRAMA
-1122C..1122E  ; SpacingMark # Mc   [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II
-11232..11233  ; SpacingMark # Mc   [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU
-11235         ; SpacingMark # Mc       KHOJKI SIGN VIRAMA
-112E0..112E2  ; SpacingMark # Mc   [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II
-11302..11303  ; SpacingMark # Mc   [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA
-1133F         ; SpacingMark # Mc       GRANTHA VOWEL SIGN I
-11341..11344  ; SpacingMark # Mc   [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR
-11347..11348  ; SpacingMark # Mc   [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI
-1134B..1134D  ; SpacingMark # Mc   [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA
-11362..11363  ; SpacingMark # Mc   [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL
-114B1..114B2  ; SpacingMark # Mc   [2] TIRHUTA VOWEL SIGN I..TIRHUTA VOWEL SIGN II
-114B9         ; SpacingMark # Mc       TIRHUTA VOWEL SIGN E
-114BB..114BC  ; SpacingMark # Mc   [2] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN O
-114BE         ; SpacingMark # Mc       TIRHUTA VOWEL SIGN AU
-114C1         ; SpacingMark # Mc       TIRHUTA SIGN VISARGA
-115B0..115B1  ; SpacingMark # Mc   [2] SIDDHAM VOWEL SIGN I..SIDDHAM VOWEL SIGN II
-115B8..115BB  ; SpacingMark # Mc   [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU
-115BE         ; SpacingMark # Mc       SIDDHAM SIGN VISARGA
-11630..11632  ; SpacingMark # Mc   [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II
-1163B..1163C  ; SpacingMark # Mc   [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU
-1163E         ; SpacingMark # Mc       MODI SIGN VISARGA
-116AC         ; SpacingMark # Mc       TAKRI SIGN VISARGA
-116AE..116AF  ; SpacingMark # Mc   [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II
-116B6         ; SpacingMark # Mc       TAKRI SIGN VIRAMA
-16F51..16F7E  ; SpacingMark # Mc  [46] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN NG
-1D166         ; SpacingMark # Mc       MUSICAL SYMBOL COMBINING SPRECHGESANG STEM
-1D16D         ; SpacingMark # Mc       MUSICAL SYMBOL COMBINING AUGMENTATION DOT
-1100..115F    ; L # Lo  [96] HANGUL CHOSEONG KIYEOK..HANGUL CHOSEONG FILLER
-A960..A97C    ; L # Lo  [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH
-1160..11A7    ; V # Lo  [72] HANGUL JUNGSEONG FILLER..HANGUL JUNGSEONG O-YAE
-D7B0..D7C6    ; V # Lo  [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E
-11A8..11FF    ; T # Lo  [88] HANGUL JONGSEONG KIYEOK..HANGUL JONGSEONG SSANGNIEUN
-D7CB..D7FB    ; T # Lo  [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH
-AC00          ; LV # Lo       HANGUL SYLLABLE GA
-AC1C          ; LV # Lo       HANGUL SYLLABLE GAE
-AC38          ; LV # Lo       HANGUL SYLLABLE GYA
-AC54          ; LV # Lo       HANGUL SYLLABLE GYAE
-AC70          ; LV # Lo       HANGUL SYLLABLE GEO
-AC8C          ; LV # Lo       HANGUL SYLLABLE GE
-ACA8          ; LV # Lo       HANGUL SYLLABLE GYEO
-ACC4          ; LV # Lo       HANGUL SYLLABLE GYE
-ACE0          ; LV # Lo       HANGUL SYLLABLE GO
-ACFC          ; LV # Lo       HANGUL SYLLABLE GWA
-AD18          ; LV # Lo       HANGUL SYLLABLE GWAE
-AD34          ; LV # Lo       HANGUL SYLLABLE GOE
-AD50          ; LV # Lo       HANGUL SYLLABLE GYO
-AD6C          ; LV # Lo       HANGUL SYLLABLE GU
-AD88          ; LV # Lo       HANGUL SYLLABLE GWEO
-ADA4          ; LV # Lo       HANGUL SYLLABLE GWE
-ADC0          ; LV # Lo       HANGUL SYLLABLE GWI
-ADDC          ; LV # Lo       HANGUL SYLLABLE GYU
-ADF8          ; LV # Lo       HANGUL SYLLABLE GEU
-AE14          ; LV # Lo       HANGUL SYLLABLE GYI
-AE30          ; LV # Lo       HANGUL SYLLABLE GI
-AE4C          ; LV # Lo       HANGUL SYLLABLE GGA
-AE68          ; LV # Lo       HANGUL SYLLABLE GGAE
-AE84          ; LV # Lo       HANGUL SYLLABLE GGYA
-AEA0          ; LV # Lo       HANGUL SYLLABLE GGYAE
-AEBC          ; LV # Lo       HANGUL SYLLABLE GGEO
-AED8          ; LV # Lo       HANGUL SYLLABLE GGE
-AEF4          ; LV # Lo       HANGUL SYLLABLE GGYEO
-AF10          ; LV # Lo       HANGUL SYLLABLE GGYE
-AF2C          ; LV # Lo       HANGUL SYLLABLE GGO
-AF48          ; LV # Lo       HANGUL SYLLABLE GGWA
-AF64          ; LV # Lo       HANGUL SYLLABLE GGWAE
-AF80          ; LV # Lo       HANGUL SYLLABLE GGOE
-AF9C          ; LV # Lo       HANGUL SYLLABLE GGYO
-AFB8          ; LV # Lo       HANGUL SYLLABLE GGU
-AFD4          ; LV # Lo       HANGUL SYLLABLE GGWEO
-AFF0          ; LV # Lo       HANGUL SYLLABLE GGWE
-B00C          ; LV # Lo       HANGUL SYLLABLE GGWI
-B028          ; LV # Lo       HANGUL SYLLABLE GGYU
-B044          ; LV # Lo       HANGUL SYLLABLE GGEU
-B060          ; LV # Lo       HANGUL SYLLABLE GGYI
-B07C          ; LV # Lo       HANGUL SYLLABLE GGI
-B098          ; LV # Lo       HANGUL SYLLABLE NA
-B0B4          ; LV # Lo       HANGUL SYLLABLE NAE
-B0D0          ; LV # Lo       HANGUL SYLLABLE NYA
-B0EC          ; LV # Lo       HANGUL SYLLABLE NYAE
-B108          ; LV # Lo       HANGUL SYLLABLE NEO
-B124          ; LV # Lo       HANGUL SYLLABLE NE
-B140          ; LV # Lo       HANGUL SYLLABLE NYEO
-B15C          ; LV # Lo       HANGUL SYLLABLE NYE
-B178          ; LV # Lo       HANGUL SYLLABLE NO
-B194          ; LV # Lo       HANGUL SYLLABLE NWA
-B1B0          ; LV # Lo       HANGUL SYLLABLE NWAE
-B1CC          ; LV # Lo       HANGUL SYLLABLE NOE
-B1E8          ; LV # Lo       HANGUL SYLLABLE NYO
-B204          ; LV # Lo       HANGUL SYLLABLE NU
-B220          ; LV # Lo       HANGUL SYLLABLE NWEO
-B23C          ; LV # Lo       HANGUL SYLLABLE NWE
-B258          ; LV # Lo       HANGUL SYLLABLE NWI
-B274          ; LV # Lo       HANGUL SYLLABLE NYU
-B290          ; LV # Lo       HANGUL SYLLABLE NEU
-B2AC          ; LV # Lo       HANGUL SYLLABLE NYI
-B2C8          ; LV # Lo       HANGUL SYLLABLE NI
-B2E4          ; LV # Lo       HANGUL SYLLABLE DA
-B300          ; LV # Lo       HANGUL SYLLABLE DAE
-B31C          ; LV # Lo       HANGUL SYLLABLE DYA
-B338          ; LV # Lo       HANGUL SYLLABLE DYAE
-B354          ; LV # Lo       HANGUL SYLLABLE DEO
-B370          ; LV # Lo       HANGUL SYLLABLE DE
-B38C          ; LV # Lo       HANGUL SYLLABLE DYEO
-B3A8          ; LV # Lo       HANGUL SYLLABLE DYE
-B3C4          ; LV # Lo       HANGUL SYLLABLE DO
-B3E0          ; LV # Lo       HANGUL SYLLABLE DWA
-B3FC          ; LV # Lo       HANGUL SYLLABLE DWAE
-B418          ; LV # Lo       HANGUL SYLLABLE DOE
-B434          ; LV # Lo       HANGUL SYLLABLE DYO
-B450          ; LV # Lo       HANGUL SYLLABLE DU
-B46C          ; LV # Lo       HANGUL SYLLABLE DWEO
-B488          ; LV # Lo       HANGUL SYLLABLE DWE
-B4A4          ; LV # Lo       HANGUL SYLLABLE DWI
-B4C0          ; LV # Lo       HANGUL SYLLABLE DYU
-B4DC          ; LV # Lo       HANGUL SYLLABLE DEU
-B4F8          ; LV # Lo       HANGUL SYLLABLE DYI
-B514          ; LV # Lo       HANGUL SYLLABLE DI
-B530          ; LV # Lo       HANGUL SYLLABLE DDA
-B54C          ; LV # Lo       HANGUL SYLLABLE DDAE
-B568          ; LV # Lo       HANGUL SYLLABLE DDYA
-B584          ; LV # Lo       HANGUL SYLLABLE DDYAE
-B5A0          ; LV # Lo       HANGUL SYLLABLE DDEO
-B5BC          ; LV # Lo       HANGUL SYLLABLE DDE
-B5D8          ; LV # Lo       HANGUL SYLLABLE DDYEO
-B5F4          ; LV # Lo       HANGUL SYLLABLE DDYE
-B610          ; LV # Lo       HANGUL SYLLABLE DDO
-B62C          ; LV # Lo       HANGUL SYLLABLE DDWA
-B648          ; LV # Lo       HANGUL SYLLABLE DDWAE
-B664          ; LV # Lo       HANGUL SYLLABLE DDOE
-B680          ; LV # Lo       HANGUL SYLLABLE DDYO
-B69C          ; LV # Lo       HANGUL SYLLABLE DDU
-B6B8          ; LV # Lo       HANGUL SYLLABLE DDWEO
-B6D4          ; LV # Lo       HANGUL SYLLABLE DDWE
-B6F0          ; LV # Lo       HANGUL SYLLABLE DDWI
-B70C          ; LV # Lo       HANGUL SYLLABLE DDYU
-B728          ; LV # Lo       HANGUL SYLLABLE DDEU
-B744          ; LV # Lo       HANGUL SYLLABLE DDYI
-B760          ; LV # Lo       HANGUL SYLLABLE DDI
-B77C          ; LV # Lo       HANGUL SYLLABLE RA
-B798          ; LV # Lo       HANGUL SYLLABLE RAE
-B7B4          ; LV # Lo       HANGUL SYLLABLE RYA
-B7D0          ; LV # Lo       HANGUL SYLLABLE RYAE
-B7EC          ; LV # Lo       HANGUL SYLLABLE REO
-B808          ; LV # Lo       HANGUL SYLLABLE RE
-B824          ; LV # Lo       HANGUL SYLLABLE RYEO
-B840          ; LV # Lo       HANGUL SYLLABLE RYE
-B85C          ; LV # Lo       HANGUL SYLLABLE RO
-B878          ; LV # Lo       HANGUL SYLLABLE RWA
-B894          ; LV # Lo       HANGUL SYLLABLE RWAE
-B8B0          ; LV # Lo       HANGUL SYLLABLE ROE
-B8CC          ; LV # Lo       HANGUL SYLLABLE RYO
-B8E8          ; LV # Lo       HANGUL SYLLABLE RU
-B904          ; LV # Lo       HANGUL SYLLABLE RWEO
-B920          ; LV # Lo       HANGUL SYLLABLE RWE
-B93C          ; LV # Lo       HANGUL SYLLABLE RWI
-B958          ; LV # Lo       HANGUL SYLLABLE RYU
-B974          ; LV # Lo       HANGUL SYLLABLE REU
-B990          ; LV # Lo       HANGUL SYLLABLE RYI
-B9AC          ; LV # Lo       HANGUL SYLLABLE RI
-B9C8          ; LV # Lo       HANGUL SYLLABLE MA
-B9E4          ; LV # Lo       HANGUL SYLLABLE MAE
-BA00          ; LV # Lo       HANGUL SYLLABLE MYA
-BA1C          ; LV # Lo       HANGUL SYLLABLE MYAE
-BA38          ; LV # Lo       HANGUL SYLLABLE MEO
-BA54          ; LV # Lo       HANGUL SYLLABLE ME
-BA70          ; LV # Lo       HANGUL SYLLABLE MYEO
-BA8C          ; LV # Lo       HANGUL SYLLABLE MYE
-BAA8          ; LV # Lo       HANGUL SYLLABLE MO
-BAC4          ; LV # Lo       HANGUL SYLLABLE MWA
-BAE0          ; LV # Lo       HANGUL SYLLABLE MWAE
-BAFC          ; LV # Lo       HANGUL SYLLABLE MOE
-BB18          ; LV # Lo       HANGUL SYLLABLE MYO
-BB34          ; LV # Lo       HANGUL SYLLABLE MU
-BB50          ; LV # Lo       HANGUL SYLLABLE MWEO
-BB6C          ; LV # Lo       HANGUL SYLLABLE MWE
-BB88          ; LV # Lo       HANGUL SYLLABLE MWI
-BBA4          ; LV # Lo       HANGUL SYLLABLE MYU
-BBC0          ; LV # Lo       HANGUL SYLLABLE MEU
-BBDC          ; LV # Lo       HANGUL SYLLABLE MYI
-BBF8          ; LV # Lo       HANGUL SYLLABLE MI
-BC14          ; LV # Lo       HANGUL SYLLABLE BA
-BC30          ; LV # Lo       HANGUL SYLLABLE BAE
-BC4C          ; LV # Lo       HANGUL SYLLABLE BYA
-BC68          ; LV # Lo       HANGUL SYLLABLE BYAE
-BC84          ; LV # Lo       HANGUL SYLLABLE BEO
-BCA0          ; LV # Lo       HANGUL SYLLABLE BE
-BCBC          ; LV # Lo       HANGUL SYLLABLE BYEO
-BCD8          ; LV # Lo       HANGUL SYLLABLE BYE
-BCF4          ; LV # Lo       HANGUL SYLLABLE BO
-BD10          ; LV # Lo       HANGUL SYLLABLE BWA
-BD2C          ; LV # Lo       HANGUL SYLLABLE BWAE
-BD48          ; LV # Lo       HANGUL SYLLABLE BOE
-BD64          ; LV # Lo       HANGUL SYLLABLE BYO
-BD80          ; LV # Lo       HANGUL SYLLABLE BU
-BD9C          ; LV # Lo       HANGUL SYLLABLE BWEO
-BDB8          ; LV # Lo       HANGUL SYLLABLE BWE
-BDD4          ; LV # Lo       HANGUL SYLLABLE BWI
-BDF0          ; LV # Lo       HANGUL SYLLABLE BYU
-BE0C          ; LV # Lo       HANGUL SYLLABLE BEU
-BE28          ; LV # Lo       HANGUL SYLLABLE BYI
-BE44          ; LV # Lo       HANGUL SYLLABLE BI
-BE60          ; LV # Lo       HANGUL SYLLABLE BBA
-BE7C          ; LV # Lo       HANGUL SYLLABLE BBAE
-BE98          ; LV # Lo       HANGUL SYLLABLE BBYA
-BEB4          ; LV # Lo       HANGUL SYLLABLE BBYAE
-BED0          ; LV # Lo       HANGUL SYLLABLE BBEO
-BEEC          ; LV # Lo       HANGUL SYLLABLE BBE
-BF08          ; LV # Lo       HANGUL SYLLABLE BBYEO
-BF24          ; LV # Lo       HANGUL SYLLABLE BBYE
-BF40          ; LV # Lo       HANGUL SYLLABLE BBO
-BF5C          ; LV # Lo       HANGUL SYLLABLE BBWA
-BF78          ; LV # Lo       HANGUL SYLLABLE BBWAE
-BF94          ; LV # Lo       HANGUL SYLLABLE BBOE
-BFB0          ; LV # Lo       HANGUL SYLLABLE BBYO
-BFCC          ; LV # Lo       HANGUL SYLLABLE BBU
-BFE8          ; LV # Lo       HANGUL SYLLABLE BBWEO
-C004          ; LV # Lo       HANGUL SYLLABLE BBWE
-C020          ; LV # Lo       HANGUL SYLLABLE BBWI
-C03C          ; LV # Lo       HANGUL SYLLABLE BBYU
-C058          ; LV # Lo       HANGUL SYLLABLE BBEU
-C074          ; LV # Lo       HANGUL SYLLABLE BBYI
-C090          ; LV # Lo       HANGUL SYLLABLE BBI
-C0AC          ; LV # Lo       HANGUL SYLLABLE SA
-C0C8          ; LV # Lo       HANGUL SYLLABLE SAE
-C0E4          ; LV # Lo       HANGUL SYLLABLE SYA
-C100          ; LV # Lo       HANGUL SYLLABLE SYAE
-C11C          ; LV # Lo       HANGUL SYLLABLE SEO
-C138          ; LV # Lo       HANGUL SYLLABLE SE
-C154          ; LV # Lo       HANGUL SYLLABLE SYEO
-C170          ; LV # Lo       HANGUL SYLLABLE SYE
-C18C          ; LV # Lo       HANGUL SYLLABLE SO
-C1A8          ; LV # Lo       HANGUL SYLLABLE SWA
-C1C4          ; LV # Lo       HANGUL SYLLABLE SWAE
-C1E0          ; LV # Lo       HANGUL SYLLABLE SOE
-C1FC          ; LV # Lo       HANGUL SYLLABLE SYO
-C218          ; LV # Lo       HANGUL SYLLABLE SU
-C234          ; LV # Lo       HANGUL SYLLABLE SWEO
-C250          ; LV # Lo       HANGUL SYLLABLE SWE
-C26C          ; LV # Lo       HANGUL SYLLABLE SWI
-C288          ; LV # Lo       HANGUL SYLLABLE SYU
-C2A4          ; LV # Lo       HANGUL SYLLABLE SEU
-C2C0          ; LV # Lo       HANGUL SYLLABLE SYI
-C2DC          ; LV # Lo       HANGUL SYLLABLE SI
-C2F8          ; LV # Lo       HANGUL SYLLABLE SSA
-C314          ; LV # Lo       HANGUL SYLLABLE SSAE
-C330          ; LV # Lo       HANGUL SYLLABLE SSYA
-C34C          ; LV # Lo       HANGUL SYLLABLE SSYAE
-C368          ; LV # Lo       HANGUL SYLLABLE SSEO
-C384          ; LV # Lo       HANGUL SYLLABLE SSE
-C3A0          ; LV # Lo       HANGUL SYLLABLE SSYEO
-C3BC          ; LV # Lo       HANGUL SYLLABLE SSYE
-C3D8          ; LV # Lo       HANGUL SYLLABLE SSO
-C3F4          ; LV # Lo       HANGUL SYLLABLE SSWA
-C410          ; LV # Lo       HANGUL SYLLABLE SSWAE
-C42C          ; LV # Lo       HANGUL SYLLABLE SSOE
-C448          ; LV # Lo       HANGUL SYLLABLE SSYO
-C464          ; LV # Lo       HANGUL SYLLABLE SSU
-C480          ; LV # Lo       HANGUL SYLLABLE SSWEO
-C49C          ; LV # Lo       HANGUL SYLLABLE SSWE
-C4B8          ; LV # Lo       HANGUL SYLLABLE SSWI
-C4D4          ; LV # Lo       HANGUL SYLLABLE SSYU
-C4F0          ; LV # Lo       HANGUL SYLLABLE SSEU
-C50C          ; LV # Lo       HANGUL SYLLABLE SSYI
-C528          ; LV # Lo       HANGUL SYLLABLE SSI
-C544          ; LV # Lo       HANGUL SYLLABLE A
-C560          ; LV # Lo       HANGUL SYLLABLE AE
-C57C          ; LV # Lo       HANGUL SYLLABLE YA
-C598          ; LV # Lo       HANGUL SYLLABLE YAE
-C5B4          ; LV # Lo       HANGUL SYLLABLE EO
-C5D0          ; LV # Lo       HANGUL SYLLABLE E
-C5EC          ; LV # Lo       HANGUL SYLLABLE YEO
-C608          ; LV # Lo       HANGUL SYLLABLE YE
-C624          ; LV # Lo       HANGUL SYLLABLE O
-C640          ; LV # Lo       HANGUL SYLLABLE WA
-C65C          ; LV # Lo       HANGUL SYLLABLE WAE
-C678          ; LV # Lo       HANGUL SYLLABLE OE
-C694          ; LV # Lo       HANGUL SYLLABLE YO
-C6B0          ; LV # Lo       HANGUL SYLLABLE U
-C6CC          ; LV # Lo       HANGUL SYLLABLE WEO
-C6E8          ; LV # Lo       HANGUL SYLLABLE WE
-C704          ; LV # Lo       HANGUL SYLLABLE WI
-C720          ; LV # Lo       HANGUL SYLLABLE YU
-C73C          ; LV # Lo       HANGUL SYLLABLE EU
-C758          ; LV # Lo       HANGUL SYLLABLE YI
-C774          ; LV # Lo       HANGUL SYLLABLE I
-C790          ; LV # Lo       HANGUL SYLLABLE JA
-C7AC          ; LV # Lo       HANGUL SYLLABLE JAE
-C7C8          ; LV # Lo       HANGUL SYLLABLE JYA
-C7E4          ; LV # Lo       HANGUL SYLLABLE JYAE
-C800          ; LV # Lo       HANGUL SYLLABLE JEO
-C81C          ; LV # Lo       HANGUL SYLLABLE JE
-C838          ; LV # Lo       HANGUL SYLLABLE JYEO
-C854          ; LV # Lo       HANGUL SYLLABLE JYE
-C870          ; LV # Lo       HANGUL SYLLABLE JO
-C88C          ; LV # Lo       HANGUL SYLLABLE JWA
-C8A8          ; LV # Lo       HANGUL SYLLABLE JWAE
-C8C4          ; LV # Lo       HANGUL SYLLABLE JOE
-C8E0          ; LV # Lo       HANGUL SYLLABLE JYO
-C8FC          ; LV # Lo       HANGUL SYLLABLE JU
-C918          ; LV # Lo       HANGUL SYLLABLE JWEO
-C934          ; LV # Lo       HANGUL SYLLABLE JWE
-C950          ; LV # Lo       HANGUL SYLLABLE JWI
-C96C          ; LV # Lo       HANGUL SYLLABLE JYU
-C988          ; LV # Lo       HANGUL SYLLABLE JEU
-C9A4          ; LV # Lo       HANGUL SYLLABLE JYI
-C9C0          ; LV # Lo       HANGUL SYLLABLE JI
-C9DC          ; LV # Lo       HANGUL SYLLABLE JJA
-C9F8          ; LV # Lo       HANGUL SYLLABLE JJAE
-CA14          ; LV # Lo       HANGUL SYLLABLE JJYA
-CA30          ; LV # Lo       HANGUL SYLLABLE JJYAE
-CA4C          ; LV # Lo       HANGUL SYLLABLE JJEO
-CA68          ; LV # Lo       HANGUL SYLLABLE JJE
-CA84          ; LV # Lo       HANGUL SYLLABLE JJYEO
-CAA0          ; LV # Lo       HANGUL SYLLABLE JJYE
-CABC          ; LV # Lo       HANGUL SYLLABLE JJO
-CAD8          ; LV # Lo       HANGUL SYLLABLE JJWA
-CAF4          ; LV # Lo       HANGUL SYLLABLE JJWAE
-CB10          ; LV # Lo       HANGUL SYLLABLE JJOE
-CB2C          ; LV # Lo       HANGUL SYLLABLE JJYO
-CB48          ; LV # Lo       HANGUL SYLLABLE JJU
-CB64          ; LV # Lo       HANGUL SYLLABLE JJWEO
-CB80          ; LV # Lo       HANGUL SYLLABLE JJWE
-CB9C          ; LV # Lo       HANGUL SYLLABLE JJWI
-CBB8          ; LV # Lo       HANGUL SYLLABLE JJYU
-CBD4          ; LV # Lo       HANGUL SYLLABLE JJEU
-CBF0          ; LV # Lo       HANGUL SYLLABLE JJYI
-CC0C          ; LV # Lo       HANGUL SYLLABLE JJI
-CC28          ; LV # Lo       HANGUL SYLLABLE CA
-CC44          ; LV # Lo       HANGUL SYLLABLE CAE
-CC60          ; LV # Lo       HANGUL SYLLABLE CYA
-CC7C          ; LV # Lo       HANGUL SYLLABLE CYAE
-CC98          ; LV # Lo       HANGUL SYLLABLE CEO
-CCB4          ; LV # Lo       HANGUL SYLLABLE CE
-CCD0          ; LV # Lo       HANGUL SYLLABLE CYEO
-CCEC          ; LV # Lo       HANGUL SYLLABLE CYE
-CD08          ; LV # Lo       HANGUL SYLLABLE CO
-CD24          ; LV # Lo       HANGUL SYLLABLE CWA
-CD40          ; LV # Lo       HANGUL SYLLABLE CWAE
-CD5C          ; LV # Lo       HANGUL SYLLABLE COE
-CD78          ; LV # Lo       HANGUL SYLLABLE CYO
-CD94          ; LV # Lo       HANGUL SYLLABLE CU
-CDB0          ; LV # Lo       HANGUL SYLLABLE CWEO
-CDCC          ; LV # Lo       HANGUL SYLLABLE CWE
-CDE8          ; LV # Lo       HANGUL SYLLABLE CWI
-CE04          ; LV # Lo       HANGUL SYLLABLE CYU
-CE20          ; LV # Lo       HANGUL SYLLABLE CEU
-CE3C          ; LV # Lo       HANGUL SYLLABLE CYI
-CE58          ; LV # Lo       HANGUL SYLLABLE CI
-CE74          ; LV # Lo       HANGUL SYLLABLE KA
-CE90          ; LV # Lo       HANGUL SYLLABLE KAE
-CEAC          ; LV # Lo       HANGUL SYLLABLE KYA
-CEC8          ; LV # Lo       HANGUL SYLLABLE KYAE
-CEE4          ; LV # Lo       HANGUL SYLLABLE KEO
-CF00          ; LV # Lo       HANGUL SYLLABLE KE
-CF1C          ; LV # Lo       HANGUL SYLLABLE KYEO
-CF38          ; LV # Lo       HANGUL SYLLABLE KYE
-CF54          ; LV # Lo       HANGUL SYLLABLE KO
-CF70          ; LV # Lo       HANGUL SYLLABLE KWA
-CF8C          ; LV # Lo       HANGUL SYLLABLE KWAE
-CFA8          ; LV # Lo       HANGUL SYLLABLE KOE
-CFC4          ; LV # Lo       HANGUL SYLLABLE KYO
-CFE0          ; LV # Lo       HANGUL SYLLABLE KU
-CFFC          ; LV # Lo       HANGUL SYLLABLE KWEO
-D018          ; LV # Lo       HANGUL SYLLABLE KWE
-D034          ; LV # Lo       HANGUL SYLLABLE KWI
-D050          ; LV # Lo       HANGUL SYLLABLE KYU
-D06C          ; LV # Lo       HANGUL SYLLABLE KEU
-D088          ; LV # Lo       HANGUL SYLLABLE KYI
-D0A4          ; LV # Lo       HANGUL SYLLABLE KI
-D0C0          ; LV # Lo       HANGUL SYLLABLE TA
-D0DC          ; LV # Lo       HANGUL SYLLABLE TAE
-D0F8          ; LV # Lo       HANGUL SYLLABLE TYA
-D114          ; LV # Lo       HANGUL SYLLABLE TYAE
-D130          ; LV # Lo       HANGUL SYLLABLE TEO
-D14C          ; LV # Lo       HANGUL SYLLABLE TE
-D168          ; LV # Lo       HANGUL SYLLABLE TYEO
-D184          ; LV # Lo       HANGUL SYLLABLE TYE
-D1A0          ; LV # Lo       HANGUL SYLLABLE TO
-D1BC          ; LV # Lo       HANGUL SYLLABLE TWA
-D1D8          ; LV # Lo       HANGUL SYLLABLE TWAE
-D1F4          ; LV # Lo       HANGUL SYLLABLE TOE
-D210          ; LV # Lo       HANGUL SYLLABLE TYO
-D22C          ; LV # Lo       HANGUL SYLLABLE TU
-D248          ; LV # Lo       HANGUL SYLLABLE TWEO
-D264          ; LV # Lo       HANGUL SYLLABLE TWE
-D280          ; LV # Lo       HANGUL SYLLABLE TWI
-D29C          ; LV # Lo       HANGUL SYLLABLE TYU
-D2B8          ; LV # Lo       HANGUL SYLLABLE TEU
-D2D4          ; LV # Lo       HANGUL SYLLABLE TYI
-D2F0          ; LV # Lo       HANGUL SYLLABLE TI
-D30C          ; LV # Lo       HANGUL SYLLABLE PA
-D328          ; LV # Lo       HANGUL SYLLABLE PAE
-D344          ; LV # Lo       HANGUL SYLLABLE PYA
-D360          ; LV # Lo       HANGUL SYLLABLE PYAE
-D37C          ; LV # Lo       HANGUL SYLLABLE PEO
-D398          ; LV # Lo       HANGUL SYLLABLE PE
-D3B4          ; LV # Lo       HANGUL SYLLABLE PYEO
-D3D0          ; LV # Lo       HANGUL SYLLABLE PYE
-D3EC          ; LV # Lo       HANGUL SYLLABLE PO
-D408          ; LV # Lo       HANGUL SYLLABLE PWA
-D424          ; LV # Lo       HANGUL SYLLABLE PWAE
-D440          ; LV # Lo       HANGUL SYLLABLE POE
-D45C          ; LV # Lo       HANGUL SYLLABLE PYO
-D478          ; LV # Lo       HANGUL SYLLABLE PU
-D494          ; LV # Lo       HANGUL SYLLABLE PWEO
-D4B0          ; LV # Lo       HANGUL SYLLABLE PWE
-D4CC          ; LV # Lo       HANGUL SYLLABLE PWI
-D4E8          ; LV # Lo       HANGUL SYLLABLE PYU
-D504          ; LV # Lo       HANGUL SYLLABLE PEU
-D520          ; LV # Lo       HANGUL SYLLABLE PYI
-D53C          ; LV # Lo       HANGUL SYLLABLE PI
-D558          ; LV # Lo       HANGUL SYLLABLE HA
-D574          ; LV # Lo       HANGUL SYLLABLE HAE
-D590          ; LV # Lo       HANGUL SYLLABLE HYA
-D5AC          ; LV # Lo       HANGUL SYLLABLE HYAE
-D5C8          ; LV # Lo       HANGUL SYLLABLE HEO
-D5E4          ; LV # Lo       HANGUL SYLLABLE HE
-D600          ; LV # Lo       HANGUL SYLLABLE HYEO
-D61C          ; LV # Lo       HANGUL SYLLABLE HYE
-D638          ; LV # Lo       HANGUL SYLLABLE HO
-D654          ; LV # Lo       HANGUL SYLLABLE HWA
-D670          ; LV # Lo       HANGUL SYLLABLE HWAE
-D68C          ; LV # Lo       HANGUL SYLLABLE HOE
-D6A8          ; LV # Lo       HANGUL SYLLABLE HYO
-D6C4          ; LV # Lo       HANGUL SYLLABLE HU
-D6E0          ; LV # Lo       HANGUL SYLLABLE HWEO
-D6FC          ; LV # Lo       HANGUL SYLLABLE HWE
-D718          ; LV # Lo       HANGUL SYLLABLE HWI
-D734          ; LV # Lo       HANGUL SYLLABLE HYU
-D750          ; LV # Lo       HANGUL SYLLABLE HEU
-D76C          ; LV # Lo       HANGUL SYLLABLE HYI
-D788          ; LV # Lo       HANGUL SYLLABLE HI
-AC01..AC1B    ; LVT # Lo  [27] HANGUL SYLLABLE GAG..HANGUL SYLLABLE GAH
-AC1D..AC37    ; LVT # Lo  [27] HANGUL SYLLABLE GAEG..HANGUL SYLLABLE GAEH
-AC39..AC53    ; LVT # Lo  [27] HANGUL SYLLABLE GYAG..HANGUL SYLLABLE GYAH
-AC55..AC6F    ; LVT # Lo  [27] HANGUL SYLLABLE GYAEG..HANGUL SYLLABLE GYAEH
-AC71..AC8B    ; LVT # Lo  [27] HANGUL SYLLABLE GEOG..HANGUL SYLLABLE GEOH
-AC8D..ACA7    ; LVT # Lo  [27] HANGUL SYLLABLE GEG..HANGUL SYLLABLE GEH
-ACA9..ACC3    ; LVT # Lo  [27] HANGUL SYLLABLE GYEOG..HANGUL SYLLABLE GYEOH
-ACC5..ACDF    ; LVT # Lo  [27] HANGUL SYLLABLE GYEG..HANGUL SYLLABLE GYEH
-ACE1..ACFB    ; LVT # Lo  [27] HANGUL SYLLABLE GOG..HANGUL SYLLABLE GOH
-ACFD..AD17    ; LVT # Lo  [27] HANGUL SYLLABLE GWAG..HANGUL SYLLABLE GWAH
-AD19..AD33    ; LVT # Lo  [27] HANGUL SYLLABLE GWAEG..HANGUL SYLLABLE GWAEH
-AD35..AD4F    ; LVT # Lo  [27] HANGUL SYLLABLE GOEG..HANGUL SYLLABLE GOEH
-AD51..AD6B    ; LVT # Lo  [27] HANGUL SYLLABLE GYOG..HANGUL SYLLABLE GYOH
-AD6D..AD87    ; LVT # Lo  [27] HANGUL SYLLABLE GUG..HANGUL SYLLABLE GUH
-AD89..ADA3    ; LVT # Lo  [27] HANGUL SYLLABLE GWEOG..HANGUL SYLLABLE GWEOH
-ADA5..ADBF    ; LVT # Lo  [27] HANGUL SYLLABLE GWEG..HANGUL SYLLABLE GWEH
-ADC1..ADDB    ; LVT # Lo  [27] HANGUL SYLLABLE GWIG..HANGUL SYLLABLE GWIH
-ADDD..ADF7    ; LVT # Lo  [27] HANGUL SYLLABLE GYUG..HANGUL SYLLABLE GYUH
-ADF9..AE13    ; LVT # Lo  [27] HANGUL SYLLABLE GEUG..HANGUL SYLLABLE GEUH
-AE15..AE2F    ; LVT # Lo  [27] HANGUL SYLLABLE GYIG..HANGUL SYLLABLE GYIH
-AE31..AE4B    ; LVT # Lo  [27] HANGUL SYLLABLE GIG..HANGUL SYLLABLE GIH
-AE4D..AE67    ; LVT # Lo  [27] HANGUL SYLLABLE GGAG..HANGUL SYLLABLE GGAH
-AE69..AE83    ; LVT # Lo  [27] HANGUL SYLLABLE GGAEG..HANGUL SYLLABLE GGAEH
-AE85..AE9F    ; LVT # Lo  [27] HANGUL SYLLABLE GGYAG..HANGUL SYLLABLE GGYAH
-AEA1..AEBB    ; LVT # Lo  [27] HANGUL SYLLABLE GGYAEG..HANGUL SYLLABLE GGYAEH
-AEBD..AED7    ; LVT # Lo  [27] HANGUL SYLLABLE GGEOG..HANGUL SYLLABLE GGEOH
-AED9..AEF3    ; LVT # Lo  [27] HANGUL SYLLABLE GGEG..HANGUL SYLLABLE GGEH
-AEF5..AF0F    ; LVT # Lo  [27] HANGUL SYLLABLE GGYEOG..HANGUL SYLLABLE GGYEOH
-AF11..AF2B    ; LVT # Lo  [27] HANGUL SYLLABLE GGYEG..HANGUL SYLLABLE GGYEH
-AF2D..AF47    ; LVT # Lo  [27] HANGUL SYLLABLE GGOG..HANGUL SYLLABLE GGOH
-AF49..AF63    ; LVT # Lo  [27] HANGUL SYLLABLE GGWAG..HANGUL SYLLABLE GGWAH
-AF65..AF7F    ; LVT # Lo  [27] HANGUL SYLLABLE GGWAEG..HANGUL SYLLABLE GGWAEH
-AF81..AF9B    ; LVT # Lo  [27] HANGUL SYLLABLE GGOEG..HANGUL SYLLABLE GGOEH
-AF9D..AFB7    ; LVT # Lo  [27] HANGUL SYLLABLE GGYOG..HANGUL SYLLABLE GGYOH
-AFB9..AFD3    ; LVT # Lo  [27] HANGUL SYLLABLE GGUG..HANGUL SYLLABLE GGUH
-AFD5..AFEF    ; LVT # Lo  [27] HANGUL SYLLABLE GGWEOG..HANGUL SYLLABLE GGWEOH
-AFF1..B00B    ; LVT # Lo  [27] HANGUL SYLLABLE GGWEG..HANGUL SYLLABLE GGWEH
-B00D..B027    ; LVT # Lo  [27] HANGUL SYLLABLE GGWIG..HANGUL SYLLABLE GGWIH
-B029..B043    ; LVT # Lo  [27] HANGUL SYLLABLE GGYUG..HANGUL SYLLABLE GGYUH
-B045..B05F    ; LVT # Lo  [27] HANGUL SYLLABLE GGEUG..HANGUL SYLLABLE GGEUH
-B061..B07B    ; LVT # Lo  [27] HANGUL SYLLABLE GGYIG..HANGUL SYLLABLE GGYIH
-B07D..B097    ; LVT # Lo  [27] HANGUL SYLLABLE GGIG..HANGUL SYLLABLE GGIH
-B099..B0B3    ; LVT # Lo  [27] HANGUL SYLLABLE NAG..HANGUL SYLLABLE NAH
-B0B5..B0CF    ; LVT # Lo  [27] HANGUL SYLLABLE NAEG..HANGUL SYLLABLE NAEH
-B0D1..B0EB    ; LVT # Lo  [27] HANGUL SYLLABLE NYAG..HANGUL SYLLABLE NYAH
-B0ED..B107    ; LVT # Lo  [27] HANGUL SYLLABLE NYAEG..HANGUL SYLLABLE NYAEH
-B109..B123    ; LVT # Lo  [27] HANGUL SYLLABLE NEOG..HANGUL SYLLABLE NEOH
-B125..B13F    ; LVT # Lo  [27] HANGUL SYLLABLE NEG..HANGUL SYLLABLE NEH
-B141..B15B    ; LVT # Lo  [27] HANGUL SYLLABLE NYEOG..HANGUL SYLLABLE NYEOH
-B15D..B177    ; LVT # Lo  [27] HANGUL SYLLABLE NYEG..HANGUL SYLLABLE NYEH
-B179..B193    ; LVT # Lo  [27] HANGUL SYLLABLE NOG..HANGUL SYLLABLE NOH
-B195..B1AF    ; LVT # Lo  [27] HANGUL SYLLABLE NWAG..HANGUL SYLLABLE NWAH
-B1B1..B1CB    ; LVT # Lo  [27] HANGUL SYLLABLE NWAEG..HANGUL SYLLABLE NWAEH
-B1CD..B1E7    ; LVT # Lo  [27] HANGUL SYLLABLE NOEG..HANGUL SYLLABLE NOEH
-B1E9..B203    ; LVT # Lo  [27] HANGUL SYLLABLE NYOG..HANGUL SYLLABLE NYOH
-B205..B21F    ; LVT # Lo  [27] HANGUL SYLLABLE NUG..HANGUL SYLLABLE NUH
-B221..B23B    ; LVT # Lo  [27] HANGUL SYLLABLE NWEOG..HANGUL SYLLABLE NWEOH
-B23D..B257    ; LVT # Lo  [27] HANGUL SYLLABLE NWEG..HANGUL SYLLABLE NWEH
-B259..B273    ; LVT # Lo  [27] HANGUL SYLLABLE NWIG..HANGUL SYLLABLE NWIH
-B275..B28F    ; LVT # Lo  [27] HANGUL SYLLABLE NYUG..HANGUL SYLLABLE NYUH
-B291..B2AB    ; LVT # Lo  [27] HANGUL SYLLABLE NEUG..HANGUL SYLLABLE NEUH
-B2AD..B2C7    ; LVT # Lo  [27] HANGUL SYLLABLE NYIG..HANGUL SYLLABLE NYIH
-B2C9..B2E3    ; LVT # Lo  [27] HANGUL SYLLABLE NIG..HANGUL SYLLABLE NIH
-B2E5..B2FF    ; LVT # Lo  [27] HANGUL SYLLABLE DAG..HANGUL SYLLABLE DAH
-B301..B31B    ; LVT # Lo  [27] HANGUL SYLLABLE DAEG..HANGUL SYLLABLE DAEH
-B31D..B337    ; LVT # Lo  [27] HANGUL SYLLABLE DYAG..HANGUL SYLLABLE DYAH
-B339..B353    ; LVT # Lo  [27] HANGUL SYLLABLE DYAEG..HANGUL SYLLABLE DYAEH
-B355..B36F    ; LVT # Lo  [27] HANGUL SYLLABLE DEOG..HANGUL SYLLABLE DEOH
-B371..B38B    ; LVT # Lo  [27] HANGUL SYLLABLE DEG..HANGUL SYLLABLE DEH
-B38D..B3A7    ; LVT # Lo  [27] HANGUL SYLLABLE DYEOG..HANGUL SYLLABLE DYEOH
-B3A9..B3C3    ; LVT # Lo  [27] HANGUL SYLLABLE DYEG..HANGUL SYLLABLE DYEH
-B3C5..B3DF    ; LVT # Lo  [27] HANGUL SYLLABLE DOG..HANGUL SYLLABLE DOH
-B3E1..B3FB    ; LVT # Lo  [27] HANGUL SYLLABLE DWAG..HANGUL SYLLABLE DWAH
-B3FD..B417    ; LVT # Lo  [27] HANGUL SYLLABLE DWAEG..HANGUL SYLLABLE DWAEH
-B419..B433    ; LVT # Lo  [27] HANGUL SYLLABLE DOEG..HANGUL SYLLABLE DOEH
-B435..B44F    ; LVT # Lo  [27] HANGUL SYLLABLE DYOG..HANGUL SYLLABLE DYOH
-B451..B46B    ; LVT # Lo  [27] HANGUL SYLLABLE DUG..HANGUL SYLLABLE DUH
-B46D..B487    ; LVT # Lo  [27] HANGUL SYLLABLE DWEOG..HANGUL SYLLABLE DWEOH
-B489..B4A3    ; LVT # Lo  [27] HANGUL SYLLABLE DWEG..HANGUL SYLLABLE DWEH
-B4A5..B4BF    ; LVT # Lo  [27] HANGUL SYLLABLE DWIG..HANGUL SYLLABLE DWIH
-B4C1..B4DB    ; LVT # Lo  [27] HANGUL SYLLABLE DYUG..HANGUL SYLLABLE DYUH
-B4DD..B4F7    ; LVT # Lo  [27] HANGUL SYLLABLE DEUG..HANGUL SYLLABLE DEUH
-B4F9..B513    ; LVT # Lo  [27] HANGUL SYLLABLE DYIG..HANGUL SYLLABLE DYIH
-B515..B52F    ; LVT # Lo  [27] HANGUL SYLLABLE DIG..HANGUL SYLLABLE DIH
-B531..B54B    ; LVT # Lo  [27] HANGUL SYLLABLE DDAG..HANGUL SYLLABLE DDAH
-B54D..B567    ; LVT # Lo  [27] HANGUL SYLLABLE DDAEG..HANGUL SYLLABLE DDAEH
-B569..B583    ; LVT # Lo  [27] HANGUL SYLLABLE DDYAG..HANGUL SYLLABLE DDYAH
-B585..B59F    ; LVT # Lo  [27] HANGUL SYLLABLE DDYAEG..HANGUL SYLLABLE DDYAEH
-B5A1..B5BB    ; LVT # Lo  [27] HANGUL SYLLABLE DDEOG..HANGUL SYLLABLE DDEOH
-B5BD..B5D7    ; LVT # Lo  [27] HANGUL SYLLABLE DDEG..HANGUL SYLLABLE DDEH
-B5D9..B5F3    ; LVT # Lo  [27] HANGUL SYLLABLE DDYEOG..HANGUL SYLLABLE DDYEOH
-B5F5..B60F    ; LVT # Lo  [27] HANGUL SYLLABLE DDYEG..HANGUL SYLLABLE DDYEH
-B611..B62B    ; LVT # Lo  [27] HANGUL SYLLABLE DDOG..HANGUL SYLLABLE DDOH
-B62D..B647    ; LVT # Lo  [27] HANGUL SYLLABLE DDWAG..HANGUL SYLLABLE DDWAH
-B649..B663    ; LVT # Lo  [27] HANGUL SYLLABLE DDWAEG..HANGUL SYLLABLE DDWAEH
-B665..B67F    ; LVT # Lo  [27] HANGUL SYLLABLE DDOEG..HANGUL SYLLABLE DDOEH
-B681..B69B    ; LVT # Lo  [27] HANGUL SYLLABLE DDYOG..HANGUL SYLLABLE DDYOH
-B69D..B6B7    ; LVT # Lo  [27] HANGUL SYLLABLE DDUG..HANGUL SYLLABLE DDUH
-B6B9..B6D3    ; LVT # Lo  [27] HANGUL SYLLABLE DDWEOG..HANGUL SYLLABLE DDWEOH
-B6D5..B6EF    ; LVT # Lo  [27] HANGUL SYLLABLE DDWEG..HANGUL SYLLABLE DDWEH
-B6F1..B70B    ; LVT # Lo  [27] HANGUL SYLLABLE DDWIG..HANGUL SYLLABLE DDWIH
-B70D..B727    ; LVT # Lo  [27] HANGUL SYLLABLE DDYUG..HANGUL SYLLABLE DDYUH
-B729..B743    ; LVT # Lo  [27] HANGUL SYLLABLE DDEUG..HANGUL SYLLABLE DDEUH
-B745..B75F    ; LVT # Lo  [27] HANGUL SYLLABLE DDYIG..HANGUL SYLLABLE DDYIH
-B761..B77B    ; LVT # Lo  [27] HANGUL SYLLABLE DDIG..HANGUL SYLLABLE DDIH
-B77D..B797    ; LVT # Lo  [27] HANGUL SYLLABLE RAG..HANGUL SYLLABLE RAH
-B799..B7B3    ; LVT # Lo  [27] HANGUL SYLLABLE RAEG..HANGUL SYLLABLE RAEH
-B7B5..B7CF    ; LVT # Lo  [27] HANGUL SYLLABLE RYAG..HANGUL SYLLABLE RYAH
-B7D1..B7EB    ; LVT # Lo  [27] HANGUL SYLLABLE RYAEG..HANGUL SYLLABLE RYAEH
-B7ED..B807    ; LVT # Lo  [27] HANGUL SYLLABLE REOG..HANGUL SYLLABLE REOH
-B809..B823    ; LVT # Lo  [27] HANGUL SYLLABLE REG..HANGUL SYLLABLE REH
-B825..B83F    ; LVT # Lo  [27] HANGUL SYLLABLE RYEOG..HANGUL SYLLABLE RYEOH
-B841..B85B    ; LVT # Lo  [27] HANGUL SYLLABLE RYEG..HANGUL SYLLABLE RYEH
-B85D..B877    ; LVT # Lo  [27] HANGUL SYLLABLE ROG..HANGUL SYLLABLE ROH
-B879..B893    ; LVT # Lo  [27] HANGUL SYLLABLE RWAG..HANGUL SYLLABLE RWAH
-B895..B8AF    ; LVT # Lo  [27] HANGUL SYLLABLE RWAEG..HANGUL SYLLABLE RWAEH
-B8B1..B8CB    ; LVT # Lo  [27] HANGUL SYLLABLE ROEG..HANGUL SYLLABLE ROEH
-B8CD..B8E7    ; LVT # Lo  [27] HANGUL SYLLABLE RYOG..HANGUL SYLLABLE RYOH
-B8E9..B903    ; LVT # Lo  [27] HANGUL SYLLABLE RUG..HANGUL SYLLABLE RUH
-B905..B91F    ; LVT # Lo  [27] HANGUL SYLLABLE RWEOG..HANGUL SYLLABLE RWEOH
-B921..B93B    ; LVT # Lo  [27] HANGUL SYLLABLE RWEG..HANGUL SYLLABLE RWEH
-B93D..B957    ; LVT # Lo  [27] HANGUL SYLLABLE RWIG..HANGUL SYLLABLE RWIH
-B959..B973    ; LVT # Lo  [27] HANGUL SYLLABLE RYUG..HANGUL SYLLABLE RYUH
-B975..B98F    ; LVT # Lo  [27] HANGUL SYLLABLE REUG..HANGUL SYLLABLE REUH
-B991..B9AB    ; LVT # Lo  [27] HANGUL SYLLABLE RYIG..HANGUL SYLLABLE RYIH
-B9AD..B9C7    ; LVT # Lo  [27] HANGUL SYLLABLE RIG..HANGUL SYLLABLE RIH
-B9C9..B9E3    ; LVT # Lo  [27] HANGUL SYLLABLE MAG..HANGUL SYLLABLE MAH
-B9E5..B9FF    ; LVT # Lo  [27] HANGUL SYLLABLE MAEG..HANGUL SYLLABLE MAEH
-BA01..BA1B    ; LVT # Lo  [27] HANGUL SYLLABLE MYAG..HANGUL SYLLABLE MYAH
-BA1D..BA37    ; LVT # Lo  [27] HANGUL SYLLABLE MYAEG..HANGUL SYLLABLE MYAEH
-BA39..BA53    ; LVT # Lo  [27] HANGUL SYLLABLE MEOG..HANGUL SYLLABLE MEOH
-BA55..BA6F    ; LVT # Lo  [27] HANGUL SYLLABLE MEG..HANGUL SYLLABLE MEH
-BA71..BA8B    ; LVT # Lo  [27] HANGUL SYLLABLE MYEOG..HANGUL SYLLABLE MYEOH
-BA8D..BAA7    ; LVT # Lo  [27] HANGUL SYLLABLE MYEG..HANGUL SYLLABLE MYEH
-BAA9..BAC3    ; LVT # Lo  [27] HANGUL SYLLABLE MOG..HANGUL SYLLABLE MOH
-BAC5..BADF    ; LVT # Lo  [27] HANGUL SYLLABLE MWAG..HANGUL SYLLABLE MWAH
-BAE1..BAFB    ; LVT # Lo  [27] HANGUL SYLLABLE MWAEG..HANGUL SYLLABLE MWAEH
-BAFD..BB17    ; LVT # Lo  [27] HANGUL SYLLABLE MOEG..HANGUL SYLLABLE MOEH
-BB19..BB33    ; LVT # Lo  [27] HANGUL SYLLABLE MYOG..HANGUL SYLLABLE MYOH
-BB35..BB4F    ; LVT # Lo  [27] HANGUL SYLLABLE MUG..HANGUL SYLLABLE MUH
-BB51..BB6B    ; LVT # Lo  [27] HANGUL SYLLABLE MWEOG..HANGUL SYLLABLE MWEOH
-BB6D..BB87    ; LVT # Lo  [27] HANGUL SYLLABLE MWEG..HANGUL SYLLABLE MWEH
-BB89..BBA3    ; LVT # Lo  [27] HANGUL SYLLABLE MWIG..HANGUL SYLLABLE MWIH
-BBA5..BBBF    ; LVT # Lo  [27] HANGUL SYLLABLE MYUG..HANGUL SYLLABLE MYUH
-BBC1..BBDB    ; LVT # Lo  [27] HANGUL SYLLABLE MEUG..HANGUL SYLLABLE MEUH
-BBDD..BBF7    ; LVT # Lo  [27] HANGUL SYLLABLE MYIG..HANGUL SYLLABLE MYIH
-BBF9..BC13    ; LVT # Lo  [27] HANGUL SYLLABLE MIG..HANGUL SYLLABLE MIH
-BC15..BC2F    ; LVT # Lo  [27] HANGUL SYLLABLE BAG..HANGUL SYLLABLE BAH
-BC31..BC4B    ; LVT # Lo  [27] HANGUL SYLLABLE BAEG..HANGUL SYLLABLE BAEH
-BC4D..BC67    ; LVT # Lo  [27] HANGUL SYLLABLE BYAG..HANGUL SYLLABLE BYAH
-BC69..BC83    ; LVT # Lo  [27] HANGUL SYLLABLE BYAEG..HANGUL SYLLABLE BYAEH
-BC85..BC9F    ; LVT # Lo  [27] HANGUL SYLLABLE BEOG..HANGUL SYLLABLE BEOH
-BCA1..BCBB    ; LVT # Lo  [27] HANGUL SYLLABLE BEG..HANGUL SYLLABLE BEH
-BCBD..BCD7    ; LVT # Lo  [27] HANGUL SYLLABLE BYEOG..HANGUL SYLLABLE BYEOH
-BCD9..BCF3    ; LVT # Lo  [27] HANGUL SYLLABLE BYEG..HANGUL SYLLABLE BYEH
-BCF5..BD0F    ; LVT # Lo  [27] HANGUL SYLLABLE BOG..HANGUL SYLLABLE BOH
-BD11..BD2B    ; LVT # Lo  [27] HANGUL SYLLABLE BWAG..HANGUL SYLLABLE BWAH
-BD2D..BD47    ; LVT # Lo  [27] HANGUL SYLLABLE BWAEG..HANGUL SYLLABLE BWAEH
-BD49..BD63    ; LVT # Lo  [27] HANGUL SYLLABLE BOEG..HANGUL SYLLABLE BOEH
-BD65..BD7F    ; LVT # Lo  [27] HANGUL SYLLABLE BYOG..HANGUL SYLLABLE BYOH
-BD81..BD9B    ; LVT # Lo  [27] HANGUL SYLLABLE BUG..HANGUL SYLLABLE BUH
-BD9D..BDB7    ; LVT # Lo  [27] HANGUL SYLLABLE BWEOG..HANGUL SYLLABLE BWEOH
-BDB9..BDD3    ; LVT # Lo  [27] HANGUL SYLLABLE BWEG..HANGUL SYLLABLE BWEH
-BDD5..BDEF    ; LVT # Lo  [27] HANGUL SYLLABLE BWIG..HANGUL SYLLABLE BWIH
-BDF1..BE0B    ; LVT # Lo  [27] HANGUL SYLLABLE BYUG..HANGUL SYLLABLE BYUH
-BE0D..BE27    ; LVT # Lo  [27] HANGUL SYLLABLE BEUG..HANGUL SYLLABLE BEUH
-BE29..BE43    ; LVT # Lo  [27] HANGUL SYLLABLE BYIG..HANGUL SYLLABLE BYIH
-BE45..BE5F    ; LVT # Lo  [27] HANGUL SYLLABLE BIG..HANGUL SYLLABLE BIH
-BE61..BE7B    ; LVT # Lo  [27] HANGUL SYLLABLE BBAG..HANGUL SYLLABLE BBAH
-BE7D..BE97    ; LVT # Lo  [27] HANGUL SYLLABLE BBAEG..HANGUL SYLLABLE BBAEH
-BE99..BEB3    ; LVT # Lo  [27] HANGUL SYLLABLE BBYAG..HANGUL SYLLABLE BBYAH
-BEB5..BECF    ; LVT # Lo  [27] HANGUL SYLLABLE BBYAEG..HANGUL SYLLABLE BBYAEH
-BED1..BEEB    ; LVT # Lo  [27] HANGUL SYLLABLE BBEOG..HANGUL SYLLABLE BBEOH
-BEED..BF07    ; LVT # Lo  [27] HANGUL SYLLABLE BBEG..HANGUL SYLLABLE BBEH
-BF09..BF23    ; LVT # Lo  [27] HANGUL SYLLABLE BBYEOG..HANGUL SYLLABLE BBYEOH
-BF25..BF3F    ; LVT # Lo  [27] HANGUL SYLLABLE BBYEG..HANGUL SYLLABLE BBYEH
-BF41..BF5B    ; LVT # Lo  [27] HANGUL SYLLABLE BBOG..HANGUL SYLLABLE BBOH
-BF5D..BF77    ; LVT # Lo  [27] HANGUL SYLLABLE BBWAG..HANGUL SYLLABLE BBWAH
-BF79..BF93    ; LVT # Lo  [27] HANGUL SYLLABLE BBWAEG..HANGUL SYLLABLE BBWAEH
-BF95..BFAF    ; LVT # Lo  [27] HANGUL SYLLABLE BBOEG..HANGUL SYLLABLE BBOEH
-BFB1..BFCB    ; LVT # Lo  [27] HANGUL SYLLABLE BBYOG..HANGUL SYLLABLE BBYOH
-BFCD..BFE7    ; LVT # Lo  [27] HANGUL SYLLABLE BBUG..HANGUL SYLLABLE BBUH
-BFE9..C003    ; LVT # Lo  [27] HANGUL SYLLABLE BBWEOG..HANGUL SYLLABLE BBWEOH
-C005..C01F    ; LVT # Lo  [27] HANGUL SYLLABLE BBWEG..HANGUL SYLLABLE BBWEH
-C021..C03B    ; LVT # Lo  [27] HANGUL SYLLABLE BBWIG..HANGUL SYLLABLE BBWIH
-C03D..C057    ; LVT # Lo  [27] HANGUL SYLLABLE BBYUG..HANGUL SYLLABLE BBYUH
-C059..C073    ; LVT # Lo  [27] HANGUL SYLLABLE BBEUG..HANGUL SYLLABLE BBEUH
-C075..C08F    ; LVT # Lo  [27] HANGUL SYLLABLE BBYIG..HANGUL SYLLABLE BBYIH
-C091..C0AB    ; LVT # Lo  [27] HANGUL SYLLABLE BBIG..HANGUL SYLLABLE BBIH
-C0AD..C0C7    ; LVT # Lo  [27] HANGUL SYLLABLE SAG..HANGUL SYLLABLE SAH
-C0C9..C0E3    ; LVT # Lo  [27] HANGUL SYLLABLE SAEG..HANGUL SYLLABLE SAEH
-C0E5..C0FF    ; LVT # Lo  [27] HANGUL SYLLABLE SYAG..HANGUL SYLLABLE SYAH
-C101..C11B    ; LVT # Lo  [27] HANGUL SYLLABLE SYAEG..HANGUL SYLLABLE SYAEH
-C11D..C137    ; LVT # Lo  [27] HANGUL SYLLABLE SEOG..HANGUL SYLLABLE SEOH
-C139..C153    ; LVT # Lo  [27] HANGUL SYLLABLE SEG..HANGUL SYLLABLE SEH
-C155..C16F    ; LVT # Lo  [27] HANGUL SYLLABLE SYEOG..HANGUL SYLLABLE SYEOH
-C171..C18B    ; LVT # Lo  [27] HANGUL SYLLABLE SYEG..HANGUL SYLLABLE SYEH
-C18D..C1A7    ; LVT # Lo  [27] HANGUL SYLLABLE SOG..HANGUL SYLLABLE SOH
-C1A9..C1C3    ; LVT # Lo  [27] HANGUL SYLLABLE SWAG..HANGUL SYLLABLE SWAH
-C1C5..C1DF    ; LVT # Lo  [27] HANGUL SYLLABLE SWAEG..HANGUL SYLLABLE SWAEH
-C1E1..C1FB    ; LVT # Lo  [27] HANGUL SYLLABLE SOEG..HANGUL SYLLABLE SOEH
-C1FD..C217    ; LVT # Lo  [27] HANGUL SYLLABLE SYOG..HANGUL SYLLABLE SYOH
-C219..C233    ; LVT # Lo  [27] HANGUL SYLLABLE SUG..HANGUL SYLLABLE SUH
-C235..C24F    ; LVT # Lo  [27] HANGUL SYLLABLE SWEOG..HANGUL SYLLABLE SWEOH
-C251..C26B    ; LVT # Lo  [27] HANGUL SYLLABLE SWEG..HANGUL SYLLABLE SWEH
-C26D..C287    ; LVT # Lo  [27] HANGUL SYLLABLE SWIG..HANGUL SYLLABLE SWIH
-C289..C2A3    ; LVT # Lo  [27] HANGUL SYLLABLE SYUG..HANGUL SYLLABLE SYUH
-C2A5..C2BF    ; LVT # Lo  [27] HANGUL SYLLABLE SEUG..HANGUL SYLLABLE SEUH
-C2C1..C2DB    ; LVT # Lo  [27] HANGUL SYLLABLE SYIG..HANGUL SYLLABLE SYIH
-C2DD..C2F7    ; LVT # Lo  [27] HANGUL SYLLABLE SIG..HANGUL SYLLABLE SIH
-C2F9..C313    ; LVT # Lo  [27] HANGUL SYLLABLE SSAG..HANGUL SYLLABLE SSAH
-C315..C32F    ; LVT # Lo  [27] HANGUL SYLLABLE SSAEG..HANGUL SYLLABLE SSAEH
-C331..C34B    ; LVT # Lo  [27] HANGUL SYLLABLE SSYAG..HANGUL SYLLABLE SSYAH
-C34D..C367    ; LVT # Lo  [27] HANGUL SYLLABLE SSYAEG..HANGUL SYLLABLE SSYAEH
-C369..C383    ; LVT # Lo  [27] HANGUL SYLLABLE SSEOG..HANGUL SYLLABLE SSEOH
-C385..C39F    ; LVT # Lo  [27] HANGUL SYLLABLE SSEG..HANGUL SYLLABLE SSEH
-C3A1..C3BB    ; LVT # Lo  [27] HANGUL SYLLABLE SSYEOG..HANGUL SYLLABLE SSYEOH
-C3BD..C3D7    ; LVT # Lo  [27] HANGUL SYLLABLE SSYEG..HANGUL SYLLABLE SSYEH
-C3D9..C3F3    ; LVT # Lo  [27] HANGUL SYLLABLE SSOG..HANGUL SYLLABLE SSOH
-C3F5..C40F    ; LVT # Lo  [27] HANGUL SYLLABLE SSWAG..HANGUL SYLLABLE SSWAH
-C411..C42B    ; LVT # Lo  [27] HANGUL SYLLABLE SSWAEG..HANGUL SYLLABLE SSWAEH
-C42D..C447    ; LVT # Lo  [27] HANGUL SYLLABLE SSOEG..HANGUL SYLLABLE SSOEH
-C449..C463    ; LVT # Lo  [27] HANGUL SYLLABLE SSYOG..HANGUL SYLLABLE SSYOH
-C465..C47F    ; LVT # Lo  [27] HANGUL SYLLABLE SSUG..HANGUL SYLLABLE SSUH
-C481..C49B    ; LVT # Lo  [27] HANGUL SYLLABLE SSWEOG..HANGUL SYLLABLE SSWEOH
-C49D..C4B7    ; LVT # Lo  [27] HANGUL SYLLABLE SSWEG..HANGUL SYLLABLE SSWEH
-C4B9..C4D3    ; LVT # Lo  [27] HANGUL SYLLABLE SSWIG..HANGUL SYLLABLE SSWIH
-C4D5..C4EF    ; LVT # Lo  [27] HANGUL SYLLABLE SSYUG..HANGUL SYLLABLE SSYUH
-C4F1..C50B    ; LVT # Lo  [27] HANGUL SYLLABLE SSEUG..HANGUL SYLLABLE SSEUH
-C50D..C527    ; LVT # Lo  [27] HANGUL SYLLABLE SSYIG..HANGUL SYLLABLE SSYIH
-C529..C543    ; LVT # Lo  [27] HANGUL SYLLABLE SSIG..HANGUL SYLLABLE SSIH
-C545..C55F    ; LVT # Lo  [27] HANGUL SYLLABLE AG..HANGUL SYLLABLE AH
-C561..C57B    ; LVT # Lo  [27] HANGUL SYLLABLE AEG..HANGUL SYLLABLE AEH
-C57D..C597    ; LVT # Lo  [27] HANGUL SYLLABLE YAG..HANGUL SYLLABLE YAH
-C599..C5B3    ; LVT # Lo  [27] HANGUL SYLLABLE YAEG..HANGUL SYLLABLE YAEH
-C5B5..C5CF    ; LVT # Lo  [27] HANGUL SYLLABLE EOG..HANGUL SYLLABLE EOH
-C5D1..C5EB    ; LVT # Lo  [27] HANGUL SYLLABLE EG..HANGUL SYLLABLE EH
-C5ED..C607    ; LVT # Lo  [27] HANGUL SYLLABLE YEOG..HANGUL SYLLABLE YEOH
-C609..C623    ; LVT # Lo  [27] HANGUL SYLLABLE YEG..HANGUL SYLLABLE YEH
-C625..C63F    ; LVT # Lo  [27] HANGUL SYLLABLE OG..HANGUL SYLLABLE OH
-C641..C65B    ; LVT # Lo  [27] HANGUL SYLLABLE WAG..HANGUL SYLLABLE WAH
-C65D..C677    ; LVT # Lo  [27] HANGUL SYLLABLE WAEG..HANGUL SYLLABLE WAEH
-C679..C693    ; LVT # Lo  [27] HANGUL SYLLABLE OEG..HANGUL SYLLABLE OEH
-C695..C6AF    ; LVT # Lo  [27] HANGUL SYLLABLE YOG..HANGUL SYLLABLE YOH
-C6B1..C6CB    ; LVT # Lo  [27] HANGUL SYLLABLE UG..HANGUL SYLLABLE UH
-C6CD..C6E7    ; LVT # Lo  [27] HANGUL SYLLABLE WEOG..HANGUL SYLLABLE WEOH
-C6E9..C703    ; LVT # Lo  [27] HANGUL SYLLABLE WEG..HANGUL SYLLABLE WEH
-C705..C71F    ; LVT # Lo  [27] HANGUL SYLLABLE WIG..HANGUL SYLLABLE WIH
-C721..C73B    ; LVT # Lo  [27] HANGUL SYLLABLE YUG..HANGUL SYLLABLE YUH
-C73D..C757    ; LVT # Lo  [27] HANGUL SYLLABLE EUG..HANGUL SYLLABLE EUH
-C759..C773    ; LVT # Lo  [27] HANGUL SYLLABLE YIG..HANGUL SYLLABLE YIH
-C775..C78F    ; LVT # Lo  [27] HANGUL SYLLABLE IG..HANGUL SYLLABLE IH
-C791..C7AB    ; LVT # Lo  [27] HANGUL SYLLABLE JAG..HANGUL SYLLABLE JAH
-C7AD..C7C7    ; LVT # Lo  [27] HANGUL SYLLABLE JAEG..HANGUL SYLLABLE JAEH
-C7C9..C7E3    ; LVT # Lo  [27] HANGUL SYLLABLE JYAG..HANGUL SYLLABLE JYAH
-C7E5..C7FF    ; LVT # Lo  [27] HANGUL SYLLABLE JYAEG..HANGUL SYLLABLE JYAEH
-C801..C81B    ; LVT # Lo  [27] HANGUL SYLLABLE JEOG..HANGUL SYLLABLE JEOH
-C81D..C837    ; LVT # Lo  [27] HANGUL SYLLABLE JEG..HANGUL SYLLABLE JEH
-C839..C853    ; LVT # Lo  [27] HANGUL SYLLABLE JYEOG..HANGUL SYLLABLE JYEOH
-C855..C86F    ; LVT # Lo  [27] HANGUL SYLLABLE JYEG..HANGUL SYLLABLE JYEH
-C871..C88B    ; LVT # Lo  [27] HANGUL SYLLABLE JOG..HANGUL SYLLABLE JOH
-C88D..C8A7    ; LVT # Lo  [27] HANGUL SYLLABLE JWAG..HANGUL SYLLABLE JWAH
-C8A9..C8C3    ; LVT # Lo  [27] HANGUL SYLLABLE JWAEG..HANGUL SYLLABLE JWAEH
-C8C5..C8DF    ; LVT # Lo  [27] HANGUL SYLLABLE JOEG..HANGUL SYLLABLE JOEH
-C8E1..C8FB    ; LVT # Lo  [27] HANGUL SYLLABLE JYOG..HANGUL SYLLABLE JYOH
-C8FD..C917    ; LVT # Lo  [27] HANGUL SYLLABLE JUG..HANGUL SYLLABLE JUH
-C919..C933    ; LVT # Lo  [27] HANGUL SYLLABLE JWEOG..HANGUL SYLLABLE JWEOH
-C935..C94F    ; LVT # Lo  [27] HANGUL SYLLABLE JWEG..HANGUL SYLLABLE JWEH
-C951..C96B    ; LVT # Lo  [27] HANGUL SYLLABLE JWIG..HANGUL SYLLABLE JWIH
-C96D..C987    ; LVT # Lo  [27] HANGUL SYLLABLE JYUG..HANGUL SYLLABLE JYUH
-C989..C9A3    ; LVT # Lo  [27] HANGUL SYLLABLE JEUG..HANGUL SYLLABLE JEUH
-C9A5..C9BF    ; LVT # Lo  [27] HANGUL SYLLABLE JYIG..HANGUL SYLLABLE JYIH
-C9C1..C9DB    ; LVT # Lo  [27] HANGUL SYLLABLE JIG..HANGUL SYLLABLE JIH
-C9DD..C9F7    ; LVT # Lo  [27] HANGUL SYLLABLE JJAG..HANGUL SYLLABLE JJAH
-C9F9..CA13    ; LVT # Lo  [27] HANGUL SYLLABLE JJAEG..HANGUL SYLLABLE JJAEH
-CA15..CA2F    ; LVT # Lo  [27] HANGUL SYLLABLE JJYAG..HANGUL SYLLABLE JJYAH
-CA31..CA4B    ; LVT # Lo  [27] HANGUL SYLLABLE JJYAEG..HANGUL SYLLABLE JJYAEH
-CA4D..CA67    ; LVT # Lo  [27] HANGUL SYLLABLE JJEOG..HANGUL SYLLABLE JJEOH
-CA69..CA83    ; LVT # Lo  [27] HANGUL SYLLABLE JJEG..HANGUL SYLLABLE JJEH
-CA85..CA9F    ; LVT # Lo  [27] HANGUL SYLLABLE JJYEOG..HANGUL SYLLABLE JJYEOH
-CAA1..CABB    ; LVT # Lo  [27] HANGUL SYLLABLE JJYEG..HANGUL SYLLABLE JJYEH
-CABD..CAD7    ; LVT # Lo  [27] HANGUL SYLLABLE JJOG..HANGUL SYLLABLE JJOH
-CAD9..CAF3    ; LVT # Lo  [27] HANGUL SYLLABLE JJWAG..HANGUL SYLLABLE JJWAH
-CAF5..CB0F    ; LVT # Lo  [27] HANGUL SYLLABLE JJWAEG..HANGUL SYLLABLE JJWAEH
-CB11..CB2B    ; LVT # Lo  [27] HANGUL SYLLABLE JJOEG..HANGUL SYLLABLE JJOEH
-CB2D..CB47    ; LVT # Lo  [27] HANGUL SYLLABLE JJYOG..HANGUL SYLLABLE JJYOH
-CB49..CB63    ; LVT # Lo  [27] HANGUL SYLLABLE JJUG..HANGUL SYLLABLE JJUH
-CB65..CB7F    ; LVT # Lo  [27] HANGUL SYLLABLE JJWEOG..HANGUL SYLLABLE JJWEOH
-CB81..CB9B    ; LVT # Lo  [27] HANGUL SYLLABLE JJWEG..HANGUL SYLLABLE JJWEH
-CB9D..CBB7    ; LVT # Lo  [27] HANGUL SYLLABLE JJWIG..HANGUL SYLLABLE JJWIH
-CBB9..CBD3    ; LVT # Lo  [27] HANGUL SYLLABLE JJYUG..HANGUL SYLLABLE JJYUH
-CBD5..CBEF    ; LVT # Lo  [27] HANGUL SYLLABLE JJEUG..HANGUL SYLLABLE JJEUH
-CBF1..CC0B    ; LVT # Lo  [27] HANGUL SYLLABLE JJYIG..HANGUL SYLLABLE JJYIH
-CC0D..CC27    ; LVT # Lo  [27] HANGUL SYLLABLE JJIG..HANGUL SYLLABLE JJIH
-CC29..CC43    ; LVT # Lo  [27] HANGUL SYLLABLE CAG..HANGUL SYLLABLE CAH
-CC45..CC5F    ; LVT # Lo  [27] HANGUL SYLLABLE CAEG..HANGUL SYLLABLE CAEH
-CC61..CC7B    ; LVT # Lo  [27] HANGUL SYLLABLE CYAG..HANGUL SYLLABLE CYAH
-CC7D..CC97    ; LVT # Lo  [27] HANGUL SYLLABLE CYAEG..HANGUL SYLLABLE CYAEH
-CC99..CCB3    ; LVT # Lo  [27] HANGUL SYLLABLE CEOG..HANGUL SYLLABLE CEOH
-CCB5..CCCF    ; LVT # Lo  [27] HANGUL SYLLABLE CEG..HANGUL SYLLABLE CEH
-CCD1..CCEB    ; LVT # Lo  [27] HANGUL SYLLABLE CYEOG..HANGUL SYLLABLE CYEOH
-CCED..CD07    ; LVT # Lo  [27] HANGUL SYLLABLE CYEG..HANGUL SYLLABLE CYEH
-CD09..CD23    ; LVT # Lo  [27] HANGUL SYLLABLE COG..HANGUL SYLLABLE COH
-CD25..CD3F    ; LVT # Lo  [27] HANGUL SYLLABLE CWAG..HANGUL SYLLABLE CWAH
-CD41..CD5B    ; LVT # Lo  [27] HANGUL SYLLABLE CWAEG..HANGUL SYLLABLE CWAEH
-CD5D..CD77    ; LVT # Lo  [27] HANGUL SYLLABLE COEG..HANGUL SYLLABLE COEH
-CD79..CD93    ; LVT # Lo  [27] HANGUL SYLLABLE CYOG..HANGUL SYLLABLE CYOH
-CD95..CDAF    ; LVT # Lo  [27] HANGUL SYLLABLE CUG..HANGUL SYLLABLE CUH
-CDB1..CDCB    ; LVT # Lo  [27] HANGUL SYLLABLE CWEOG..HANGUL SYLLABLE CWEOH
-CDCD..CDE7    ; LVT # Lo  [27] HANGUL SYLLABLE CWEG..HANGUL SYLLABLE CWEH
-CDE9..CE03    ; LVT # Lo  [27] HANGUL SYLLABLE CWIG..HANGUL SYLLABLE CWIH
-CE05..CE1F    ; LVT # Lo  [27] HANGUL SYLLABLE CYUG..HANGUL SYLLABLE CYUH
-CE21..CE3B    ; LVT # Lo  [27] HANGUL SYLLABLE CEUG..HANGUL SYLLABLE CEUH
-CE3D..CE57    ; LVT # Lo  [27] HANGUL SYLLABLE CYIG..HANGUL SYLLABLE CYIH
-CE59..CE73    ; LVT # Lo  [27] HANGUL SYLLABLE CIG..HANGUL SYLLABLE CIH
-CE75..CE8F    ; LVT # Lo  [27] HANGUL SYLLABLE KAG..HANGUL SYLLABLE KAH
-CE91..CEAB    ; LVT # Lo  [27] HANGUL SYLLABLE KAEG..HANGUL SYLLABLE KAEH
-CEAD..CEC7    ; LVT # Lo  [27] HANGUL SYLLABLE KYAG..HANGUL SYLLABLE KYAH
-CEC9..CEE3    ; LVT # Lo  [27] HANGUL SYLLABLE KYAEG..HANGUL SYLLABLE KYAEH
-CEE5..CEFF    ; LVT # Lo  [27] HANGUL SYLLABLE KEOG..HANGUL SYLLABLE KEOH
-CF01..CF1B    ; LVT # Lo  [27] HANGUL SYLLABLE KEG..HANGUL SYLLABLE KEH
-CF1D..CF37    ; LVT # Lo  [27] HANGUL SYLLABLE KYEOG..HANGUL SYLLABLE KYEOH
-CF39..CF53    ; LVT # Lo  [27] HANGUL SYLLABLE KYEG..HANGUL SYLLABLE KYEH
-CF55..CF6F    ; LVT # Lo  [27] HANGUL SYLLABLE KOG..HANGUL SYLLABLE KOH
-CF71..CF8B    ; LVT # Lo  [27] HANGUL SYLLABLE KWAG..HANGUL SYLLABLE KWAH
-CF8D..CFA7    ; LVT # Lo  [27] HANGUL SYLLABLE KWAEG..HANGUL SYLLABLE KWAEH
-CFA9..CFC3    ; LVT # Lo  [27] HANGUL SYLLABLE KOEG..HANGUL SYLLABLE KOEH
-CFC5..CFDF    ; LVT # Lo  [27] HANGUL SYLLABLE KYOG..HANGUL SYLLABLE KYOH
-CFE1..CFFB    ; LVT # Lo  [27] HANGUL SYLLABLE KUG..HANGUL SYLLABLE KUH
-CFFD..D017    ; LVT # Lo  [27] HANGUL SYLLABLE KWEOG..HANGUL SYLLABLE KWEOH
-D019..D033    ; LVT # Lo  [27] HANGUL SYLLABLE KWEG..HANGUL SYLLABLE KWEH
-D035..D04F    ; LVT # Lo  [27] HANGUL SYLLABLE KWIG..HANGUL SYLLABLE KWIH
-D051..D06B    ; LVT # Lo  [27] HANGUL SYLLABLE KYUG..HANGUL SYLLABLE KYUH
-D06D..D087    ; LVT # Lo  [27] HANGUL SYLLABLE KEUG..HANGUL SYLLABLE KEUH
-D089..D0A3    ; LVT # Lo  [27] HANGUL SYLLABLE KYIG..HANGUL SYLLABLE KYIH
-D0A5..D0BF    ; LVT # Lo  [27] HANGUL SYLLABLE KIG..HANGUL SYLLABLE KIH
-D0C1..D0DB    ; LVT # Lo  [27] HANGUL SYLLABLE TAG..HANGUL SYLLABLE TAH
-D0DD..D0F7    ; LVT # Lo  [27] HANGUL SYLLABLE TAEG..HANGUL SYLLABLE TAEH
-D0F9..D113    ; LVT # Lo  [27] HANGUL SYLLABLE TYAG..HANGUL SYLLABLE TYAH
-D115..D12F    ; LVT # Lo  [27] HANGUL SYLLABLE TYAEG..HANGUL SYLLABLE TYAEH
-D131..D14B    ; LVT # Lo  [27] HANGUL SYLLABLE TEOG..HANGUL SYLLABLE TEOH
-D14D..D167    ; LVT # Lo  [27] HANGUL SYLLABLE TEG..HANGUL SYLLABLE TEH
-D169..D183    ; LVT # Lo  [27] HANGUL SYLLABLE TYEOG..HANGUL SYLLABLE TYEOH
-D185..D19F    ; LVT # Lo  [27] HANGUL SYLLABLE TYEG..HANGUL SYLLABLE TYEH
-D1A1..D1BB    ; LVT # Lo  [27] HANGUL SYLLABLE TOG..HANGUL SYLLABLE TOH
-D1BD..D1D7    ; LVT # Lo  [27] HANGUL SYLLABLE TWAG..HANGUL SYLLABLE TWAH
-D1D9..D1F3    ; LVT # Lo  [27] HANGUL SYLLABLE TWAEG..HANGUL SYLLABLE TWAEH
-D1F5..D20F    ; LVT # Lo  [27] HANGUL SYLLABLE TOEG..HANGUL SYLLABLE TOEH
-D211..D22B    ; LVT # Lo  [27] HANGUL SYLLABLE TYOG..HANGUL SYLLABLE TYOH
-D22D..D247    ; LVT # Lo  [27] HANGUL SYLLABLE TUG..HANGUL SYLLABLE TUH
-D249..D263    ; LVT # Lo  [27] HANGUL SYLLABLE TWEOG..HANGUL SYLLABLE TWEOH
-D265..D27F    ; LVT # Lo  [27] HANGUL SYLLABLE TWEG..HANGUL SYLLABLE TWEH
-D281..D29B    ; LVT # Lo  [27] HANGUL SYLLABLE TWIG..HANGUL SYLLABLE TWIH
-D29D..D2B7    ; LVT # Lo  [27] HANGUL SYLLABLE TYUG..HANGUL SYLLABLE TYUH
-D2B9..D2D3    ; LVT # Lo  [27] HANGUL SYLLABLE TEUG..HANGUL SYLLABLE TEUH
-D2D5..D2EF    ; LVT # Lo  [27] HANGUL SYLLABLE TYIG..HANGUL SYLLABLE TYIH
-D2F1..D30B    ; LVT # Lo  [27] HANGUL SYLLABLE TIG..HANGUL SYLLABLE TIH
-D30D..D327    ; LVT # Lo  [27] HANGUL SYLLABLE PAG..HANGUL SYLLABLE PAH
-D329..D343    ; LVT # Lo  [27] HANGUL SYLLABLE PAEG..HANGUL SYLLABLE PAEH
-D345..D35F    ; LVT # Lo  [27] HANGUL SYLLABLE PYAG..HANGUL SYLLABLE PYAH
-D361..D37B    ; LVT # Lo  [27] HANGUL SYLLABLE PYAEG..HANGUL SYLLABLE PYAEH
-D37D..D397    ; LVT # Lo  [27] HANGUL SYLLABLE PEOG..HANGUL SYLLABLE PEOH
-D399..D3B3    ; LVT # Lo  [27] HANGUL SYLLABLE PEG..HANGUL SYLLABLE PEH
-D3B5..D3CF    ; LVT # Lo  [27] HANGUL SYLLABLE PYEOG..HANGUL SYLLABLE PYEOH
-D3D1..D3EB    ; LVT # Lo  [27] HANGUL SYLLABLE PYEG..HANGUL SYLLABLE PYEH
-D3ED..D407    ; LVT # Lo  [27] HANGUL SYLLABLE POG..HANGUL SYLLABLE POH
-D409..D423    ; LVT # Lo  [27] HANGUL SYLLABLE PWAG..HANGUL SYLLABLE PWAH
-D425..D43F    ; LVT # Lo  [27] HANGUL SYLLABLE PWAEG..HANGUL SYLLABLE PWAEH
-D441..D45B    ; LVT # Lo  [27] HANGUL SYLLABLE POEG..HANGUL SYLLABLE POEH
-D45D..D477    ; LVT # Lo  [27] HANGUL SYLLABLE PYOG..HANGUL SYLLABLE PYOH
-D479..D493    ; LVT # Lo  [27] HANGUL SYLLABLE PUG..HANGUL SYLLABLE PUH
-D495..D4AF    ; LVT # Lo  [27] HANGUL SYLLABLE PWEOG..HANGUL SYLLABLE PWEOH
-D4B1..D4CB    ; LVT # Lo  [27] HANGUL SYLLABLE PWEG..HANGUL SYLLABLE PWEH
-D4CD..D4E7    ; LVT # Lo  [27] HANGUL SYLLABLE PWIG..HANGUL SYLLABLE PWIH
-D4E9..D503    ; LVT # Lo  [27] HANGUL SYLLABLE PYUG..HANGUL SYLLABLE PYUH
-D505..D51F    ; LVT # Lo  [27] HANGUL SYLLABLE PEUG..HANGUL SYLLABLE PEUH
-D521..D53B    ; LVT # Lo  [27] HANGUL SYLLABLE PYIG..HANGUL SYLLABLE PYIH
-D53D..D557    ; LVT # Lo  [27] HANGUL SYLLABLE PIG..HANGUL SYLLABLE PIH
-D559..D573    ; LVT # Lo  [27] HANGUL SYLLABLE HAG..HANGUL SYLLABLE HAH
-D575..D58F    ; LVT # Lo  [27] HANGUL SYLLABLE HAEG..HANGUL SYLLABLE HAEH
-D591..D5AB    ; LVT # Lo  [27] HANGUL SYLLABLE HYAG..HANGUL SYLLABLE HYAH
-D5AD..D5C7    ; LVT # Lo  [27] HANGUL SYLLABLE HYAEG..HANGUL SYLLABLE HYAEH
-D5C9..D5E3    ; LVT # Lo  [27] HANGUL SYLLABLE HEOG..HANGUL SYLLABLE HEOH
-D5E5..D5FF    ; LVT # Lo  [27] HANGUL SYLLABLE HEG..HANGUL SYLLABLE HEH
-D601..D61B    ; LVT # Lo  [27] HANGUL SYLLABLE HYEOG..HANGUL SYLLABLE HYEOH
-D61D..D637    ; LVT # Lo  [27] HANGUL SYLLABLE HYEG..HANGUL SYLLABLE HYEH
-D639..D653    ; LVT # Lo  [27] HANGUL SYLLABLE HOG..HANGUL SYLLABLE HOH
-D655..D66F    ; LVT # Lo  [27] HANGUL SYLLABLE HWAG..HANGUL SYLLABLE HWAH
-D671..D68B    ; LVT # Lo  [27] HANGUL SYLLABLE HWAEG..HANGUL SYLLABLE HWAEH
-D68D..D6A7    ; LVT # Lo  [27] HANGUL SYLLABLE HOEG..HANGUL SYLLABLE HOEH
-D6A9..D6C3    ; LVT # Lo  [27] HANGUL SYLLABLE HYOG..HANGUL SYLLABLE HYOH
-D6C5..D6DF    ; LVT # Lo  [27] HANGUL SYLLABLE HUG..HANGUL SYLLABLE HUH
-D6E1..D6FB    ; LVT # Lo  [27] HANGUL SYLLABLE HWEOG..HANGUL SYLLABLE HWEOH
-D6FD..D717    ; LVT # Lo  [27] HANGUL SYLLABLE HWEG..HANGUL SYLLABLE HWEH
-D719..D733    ; LVT # Lo  [27] HANGUL SYLLABLE HWIG..HANGUL SYLLABLE HWIH
-D735..D74F    ; LVT # Lo  [27] HANGUL SYLLABLE HYUG..HANGUL SYLLABLE HYUH
-D751..D76B    ; LVT # Lo  [27] HANGUL SYLLABLE HEUG..HANGUL SYLLABLE HEUH
-D76D..D787    ; LVT # Lo  [27] HANGUL SYLLABLE HYIG..HANGUL SYLLABLE HYIH
-D789..D7A3    ; LVT # Lo  [27] HANGUL SYLLABLE HIG..HANGUL SYLLABLE HIH
diff --git a/lib/elixir/unicode/IdentifierType.txt b/lib/elixir/unicode/IdentifierType.txt
new file mode 100644
index 00000000000..90b6f116f4b
--- /dev/null
+++ b/lib/elixir/unicode/IdentifierType.txt
@@ -0,0 +1,5273 @@
+# IdentifierType.txt
+# Date: 2025-08-04, 21:58:43 GMT
+# © 2025 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use and license, see https://www.unicode.org/terms_of_use.html
+#
+# Unicode Security Mechanisms for UTS #39
+# Version: 17.0.0
+#
+# For documentation and usage, see https://www.unicode.org/reports/tr39
+#
+# Format
+#
+# Field 0: code point
+# Field 1: set of Identifier_Type values
+#          See the "Identifier_Status and Identifier_Type" table of UTS #39:
+#          https://www.unicode.org/reports/tr39/#Identifier_Status_and_Type
+
+#
+# For the purpose of regular expressions, the property Identifier_Type is defined as
+# mapping each code point to a set of enumerated values.
+# The short name of Identifier_Type is ID_Type.
+# The possible values are:
+#   Not_Character, Deprecated, Default_Ignorable, Not_NFKC, Not_XID,
+#   Exclusion, Obsolete, Technical, Uncommon_Use, Limited_Use, Inclusion, Recommended
+# The short name of each value is the same as its long name.
+
+# All code points not explicitly listed for Identifier_Type
+# have the value Not_Character.
+
+# @missing: 0000..10FFFF; Not_Character
+
+# As usual, sets are unordered, with no duplicate values.
+
+
+#	Identifier_Type:	Recommended
+
+0030..0039    ; Recommended                    # 1.1   [10] DIGIT ZERO..DIGIT NINE
+0041..005A    ; Recommended                    # 1.1   [26] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z
+005F          ; Recommended                    # 1.1        LOW LINE
+0061..007A    ; Recommended                    # 1.1   [26] LATIN SMALL LETTER A..LATIN SMALL LETTER Z
+00C0..00D6    ; Recommended                    # 1.1   [23] LATIN CAPITAL LETTER A WITH GRAVE..LATIN CAPITAL LETTER O WITH DIAERESIS
+00D8..00F6    ; Recommended                    # 1.1   [31] LATIN CAPITAL LETTER O WITH STROKE..LATIN SMALL LETTER O WITH DIAERESIS
+00F8..0113    ; Recommended                    # 1.1   [28] LATIN SMALL LETTER O WITH STROKE..LATIN SMALL LETTER E WITH MACRON
+0116..012B    ; Recommended                    # 1.1   [22] LATIN CAPITAL LETTER E WITH DOT ABOVE..LATIN SMALL LETTER I WITH MACRON
+012E..0131    ; Recommended                    # 1.1    [4] LATIN CAPITAL LETTER I WITH OGONEK..LATIN SMALL LETTER DOTLESS I
+0134..0137    ; Recommended                    # 1.1    [4] LATIN CAPITAL LETTER J WITH CIRCUMFLEX..LATIN SMALL LETTER K WITH CEDILLA
+0139..013E    ; Recommended                    # 1.1    [6] LATIN CAPITAL LETTER L WITH ACUTE..LATIN SMALL LETTER L WITH CARON
+0141..0148    ; Recommended                    # 1.1    [8] LATIN CAPITAL LETTER L WITH STROKE..LATIN SMALL LETTER N WITH CARON
+014A..014D    ; Recommended                    # 1.1    [4] LATIN CAPITAL LETTER ENG..LATIN SMALL LETTER O WITH MACRON
+0150..0155    ; Recommended                    # 1.1    [6] LATIN CAPITAL LETTER O WITH DOUBLE ACUTE..LATIN SMALL LETTER R WITH ACUTE
+0158..0161    ; Recommended                    # 1.1   [10] LATIN CAPITAL LETTER R WITH CARON..LATIN SMALL LETTER S WITH CARON
+0164..017E    ; Recommended                    # 1.1   [27] LATIN CAPITAL LETTER T WITH CARON..LATIN SMALL LETTER Z WITH CARON
+0181          ; Recommended                    # 1.1        LATIN CAPITAL LETTER B WITH HOOK
+0186          ; Recommended                    # 1.1        LATIN CAPITAL LETTER OPEN O
+0189..018A    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER AFRICAN D..LATIN CAPITAL LETTER D WITH HOOK
+018E..0192    ; Recommended                    # 1.1    [5] LATIN CAPITAL LETTER REVERSED E..LATIN SMALL LETTER F WITH HOOK
+0194          ; Recommended                    # 1.1        LATIN CAPITAL LETTER GAMMA
+0196..0199    ; Recommended                    # 1.1    [4] LATIN CAPITAL LETTER IOTA..LATIN SMALL LETTER K WITH HOOK
+019D          ; Recommended                    # 1.1        LATIN CAPITAL LETTER N WITH LEFT HOOK
+01A0..01A1    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER O WITH HORN..LATIN SMALL LETTER O WITH HORN
+01AF..01B0    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER U WITH HORN..LATIN SMALL LETTER U WITH HORN
+01B2..01B4    ; Recommended                    # 1.1    [3] LATIN CAPITAL LETTER V WITH HOOK..LATIN SMALL LETTER Y WITH HOOK
+01B7          ; Recommended                    # 1.1        LATIN CAPITAL LETTER EZH
+01CD..01D4    ; Recommended                    # 1.1    [8] LATIN CAPITAL LETTER A WITH CARON..LATIN SMALL LETTER U WITH CARON
+01DD          ; Recommended                    # 1.1        LATIN SMALL LETTER TURNED E
+01E6..01E9    ; Recommended                    # 1.1    [4] LATIN CAPITAL LETTER G WITH CARON..LATIN SMALL LETTER K WITH CARON
+01EE..01EF    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER EZH WITH CARON..LATIN SMALL LETTER EZH WITH CARON
+01F8..01F9    ; Recommended                    # 3.0    [2] LATIN CAPITAL LETTER N WITH GRAVE..LATIN SMALL LETTER N WITH GRAVE
+0218..021B    ; Recommended                    # 3.0    [4] LATIN CAPITAL LETTER S WITH COMMA BELOW..LATIN SMALL LETTER T WITH COMMA BELOW
+0244          ; Recommended                    # 5.0        LATIN CAPITAL LETTER U BAR
+024C..024D    ; Recommended                    # 5.0    [2] LATIN CAPITAL LETTER R WITH STROKE..LATIN SMALL LETTER R WITH STROKE
+0253..0254    ; Recommended                    # 1.1    [2] LATIN SMALL LETTER B WITH HOOK..LATIN SMALL LETTER OPEN O
+0256..0257    ; Recommended                    # 1.1    [2] LATIN SMALL LETTER D WITH TAIL..LATIN SMALL LETTER D WITH HOOK
+0259          ; Recommended                    # 1.1        LATIN SMALL LETTER SCHWA
+025B          ; Recommended                    # 1.1        LATIN SMALL LETTER OPEN E
+0263          ; Recommended                    # 1.1        LATIN SMALL LETTER GAMMA
+0268..0269    ; Recommended                    # 1.1    [2] LATIN SMALL LETTER I WITH STROKE..LATIN SMALL LETTER IOTA
+0272          ; Recommended                    # 1.1        LATIN SMALL LETTER N WITH LEFT HOOK
+0289          ; Recommended                    # 1.1        LATIN SMALL LETTER U BAR
+028B          ; Recommended                    # 1.1        LATIN SMALL LETTER V WITH HOOK
+0292          ; Recommended                    # 1.1        LATIN SMALL LETTER EZH
+0300..0304    ; Recommended                    # 1.1    [5] COMBINING GRAVE ACCENT..COMBINING MACRON
+0306..030C    ; Recommended                    # 1.1    [7] COMBINING BREVE..COMBINING CARON
+031B          ; Recommended                    # 1.1        COMBINING HORN
+0323          ; Recommended                    # 1.1        COMBINING DOT BELOW
+0326..0328    ; Recommended                    # 1.1    [3] COMBINING COMMA BELOW..COMBINING OGONEK
+0331          ; Recommended                    # 1.1        COMBINING MACRON BELOW
+0386          ; Recommended                    # 1.1        GREEK CAPITAL LETTER ALPHA WITH TONOS
+0388..038A    ; Recommended                    # 1.1    [3] GREEK CAPITAL LETTER EPSILON WITH TONOS..GREEK CAPITAL LETTER IOTA WITH TONOS
+038C          ; Recommended                    # 1.1        GREEK CAPITAL LETTER OMICRON WITH TONOS
+038E..03A1    ; Recommended                    # 1.1   [20] GREEK CAPITAL LETTER UPSILON WITH TONOS..GREEK CAPITAL LETTER RHO
+03A3..03CE    ; Recommended                    # 1.1   [44] GREEK CAPITAL LETTER SIGMA..GREEK SMALL LETTER OMEGA WITH TONOS
+0401..040C    ; Recommended                    # 1.1   [12] CYRILLIC CAPITAL LETTER IO..CYRILLIC CAPITAL LETTER KJE
+040E..044F    ; Recommended                    # 1.1   [66] CYRILLIC CAPITAL LETTER SHORT U..CYRILLIC SMALL LETTER YA
+0451..045C    ; Recommended                    # 1.1   [12] CYRILLIC SMALL LETTER IO..CYRILLIC SMALL LETTER KJE
+045E..045F    ; Recommended                    # 1.1    [2] CYRILLIC SMALL LETTER SHORT U..CYRILLIC SMALL LETTER DZHE
+0490..049B    ; Recommended                    # 1.1   [12] CYRILLIC CAPITAL LETTER GHE WITH UPTURN..CYRILLIC SMALL LETTER KA WITH DESCENDER
+049E..04A5    ; Recommended                    # 1.1    [8] CYRILLIC CAPITAL LETTER KA WITH STROKE..CYRILLIC SMALL LIGATURE EN GHE
+04A8..04B7    ; Recommended                    # 1.1   [16] CYRILLIC CAPITAL LETTER ABKHASIAN HA..CYRILLIC SMALL LETTER CHE WITH DESCENDER
+04BA..04C0    ; Recommended                    # 1.1    [7] CYRILLIC CAPITAL LETTER SHHA..CYRILLIC LETTER PALOCHKA
+04CF          ; Recommended                    # 5.0        CYRILLIC SMALL LETTER PALOCHKA
+04D0..04D9    ; Recommended                    # 1.1   [10] CYRILLIC CAPITAL LETTER A WITH BREVE..CYRILLIC SMALL LETTER SCHWA
+04DC..04E9    ; Recommended                    # 1.1   [14] CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS..CYRILLIC SMALL LETTER BARRED O
+04EE..04F5    ; Recommended                    # 1.1    [8] CYRILLIC CAPITAL LETTER U WITH MACRON..CYRILLIC SMALL LETTER CHE WITH DIAERESIS
+04F8..04F9    ; Recommended                    # 1.1    [2] CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS..CYRILLIC SMALL LETTER YERU WITH DIAERESIS
+0524..0525    ; Recommended                    # 5.2    [2] CYRILLIC CAPITAL LETTER PE WITH DESCENDER..CYRILLIC SMALL LETTER PE WITH DESCENDER
+0531..0556    ; Recommended                    # 1.1   [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH
+0561..0586    ; Recommended                    # 1.1   [38] ARMENIAN SMALL LETTER AYB..ARMENIAN SMALL LETTER FEH
+05D0..05EA    ; Recommended                    # 1.1   [27] HEBREW LETTER ALEF..HEBREW LETTER TAV
+0620          ; Recommended                    # 6.0        ARABIC LETTER KASHMIRI YEH
+0621..063A    ; Recommended                    # 1.1   [26] ARABIC LETTER HAMZA..ARABIC LETTER GHAIN
+063D          ; Recommended                    # 5.1        ARABIC LETTER FARSI YEH WITH INVERTED V
+0641..0652    ; Recommended                    # 1.1   [18] ARABIC LETTER FEH..ARABIC SUKUN
+0654..0655    ; Recommended                    # 3.0    [2] ARABIC HAMZA ABOVE..ARABIC HAMZA BELOW
+0660..0669    ; Recommended                    # 1.1   [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE
+0670          ; Recommended                    # 1.1        ARABIC LETTER SUPERSCRIPT ALEF
+0672          ; Recommended                    # 1.1        ARABIC LETTER ALEF WITH WAVY HAMZA ABOVE
+0674          ; Recommended                    # 1.1        ARABIC LETTER HIGH HAMZA
+0679..068F    ; Recommended                    # 1.1   [23] ARABIC LETTER TTEH..ARABIC LETTER DAL WITH THREE DOTS ABOVE DOWNWARDS
+0691..069A    ; Recommended                    # 1.1   [10] ARABIC LETTER RREH..ARABIC LETTER SEEN WITH DOT BELOW AND DOT ABOVE
+069F..06A0    ; Recommended                    # 1.1    [2] ARABIC LETTER TAH WITH THREE DOTS ABOVE..ARABIC LETTER AIN WITH THREE DOTS ABOVE
+06A2          ; Recommended                    # 1.1        ARABIC LETTER FEH WITH DOT MOVED BELOW
+06A4..06AB    ; Recommended                    # 1.1    [8] ARABIC LETTER VEH..ARABIC LETTER KAF WITH RING
+06AD..06B1    ; Recommended                    # 1.1    [5] ARABIC LETTER NG..ARABIC LETTER NGOEH
+06B3          ; Recommended                    # 1.1        ARABIC LETTER GUEH
+06B5..06B7    ; Recommended                    # 1.1    [3] ARABIC LETTER LAM WITH SMALL V..ARABIC LETTER LAM WITH THREE DOTS ABOVE
+06BA..06BE    ; Recommended                    # 1.1    [5] ARABIC LETTER NOON GHUNNA..ARABIC LETTER HEH DOACHASHMEE
+06C0..06CE    ; Recommended                    # 1.1   [15] ARABIC LETTER HEH WITH YEH ABOVE..ARABIC LETTER YEH WITH SMALL V
+06CF          ; Recommended                    # 3.0        ARABIC LETTER WAW WITH DOT ABOVE
+06D0..06D3    ; Recommended                    # 1.1    [4] ARABIC LETTER E..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE
+06D5          ; Recommended                    # 1.1        ARABIC LETTER AE
+06EE..06EF    ; Recommended                    # 4.0    [2] ARABIC LETTER DAL WITH INVERTED V..ARABIC LETTER REH WITH INVERTED V
+06F0..06F9    ; Recommended                    # 1.1   [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE
+06FF          ; Recommended                    # 4.0        ARABIC LETTER HEH WITH INVERTED V
+0751..0752    ; Recommended                    # 4.1    [2] ARABIC LETTER BEH WITH DOT BELOW AND THREE DOTS ABOVE..ARABIC LETTER BEH WITH THREE DOTS POINTING UPWARDS BELOW
+0756          ; Recommended                    # 4.1        ARABIC LETTER BEH WITH SMALL V
+0760          ; Recommended                    # 4.1        ARABIC LETTER FEH WITH TWO DOTS BELOW
+0762..0763    ; Recommended                    # 4.1    [2] ARABIC LETTER KEHEH WITH DOT ABOVE..ARABIC LETTER KEHEH WITH THREE DOTS ABOVE
+0766..0768    ; Recommended                    # 4.1    [3] ARABIC LETTER MEEM WITH DOT BELOW..ARABIC LETTER NOON WITH SMALL TAH
+076A          ; Recommended                    # 4.1        ARABIC LETTER LAM WITH BAR
+076E..0771    ; Recommended                    # 5.1    [4] ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH BELOW..ARABIC LETTER REH WITH SMALL ARABIC LETTER TAH AND TWO DOTS
+0780..07B0    ; Recommended                    # 3.0   [49] THAANA LETTER HAA..THAANA SUKUN
+07B1          ; Recommended                    # 3.2        THAANA LETTER NAA
+088F          ; Recommended                    # 17.0       ARABIC LETTER NOON WITH RING ABOVE
+08A0          ; Recommended                    # 6.1        ARABIC LETTER BEH WITH SMALL V BELOW
+08A2..08A9    ; Recommended                    # 6.1    [8] ARABIC LETTER JEEM WITH TWO DOTS ABOVE..ARABIC LETTER YEH WITH TWO DOTS BELOW AND DOT ABOVE
+08BB..08BD    ; Recommended                    # 9.0    [3] ARABIC LETTER AFRICAN FEH..ARABIC LETTER AFRICAN NOON
+08BE..08C2    ; Recommended                    # 13.0   [5] ARABIC LETTER PEH WITH SMALL V..ARABIC LETTER KEHEH WITH SMALL V
+08C7          ; Recommended                    # 13.0       ARABIC LETTER LAM WITH SMALL ARABIC LETTER TAH ABOVE
+0901..0903    ; Recommended                    # 1.1    [3] DEVANAGARI SIGN CANDRABINDU..DEVANAGARI SIGN VISARGA
+0905..090B    ; Recommended                    # 1.1    [7] DEVANAGARI LETTER A..DEVANAGARI LETTER VOCALIC R
+090D..0928    ; Recommended                    # 1.1   [28] DEVANAGARI LETTER CANDRA E..DEVANAGARI LETTER NA
+092A..0933    ; Recommended                    # 1.1   [10] DEVANAGARI LETTER PA..DEVANAGARI LETTER LLA
+0935..0939    ; Recommended                    # 1.1    [5] DEVANAGARI LETTER VA..DEVANAGARI LETTER HA
+093A..093B    ; Recommended                    # 6.0    [2] DEVANAGARI VOWEL SIGN OE..DEVANAGARI VOWEL SIGN OOE
+093C          ; Recommended                    # 1.1        DEVANAGARI SIGN NUKTA
+093E..0943    ; Recommended                    # 1.1    [6] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN VOCALIC R
+0945..094D    ; Recommended                    # 1.1    [9] DEVANAGARI VOWEL SIGN CANDRA E..DEVANAGARI SIGN VIRAMA
+094F          ; Recommended                    # 6.0        DEVANAGARI VOWEL SIGN AW
+0956..0957    ; Recommended                    # 6.0    [2] DEVANAGARI VOWEL SIGN UE..DEVANAGARI VOWEL SIGN UUE
+0966..096F    ; Recommended                    # 1.1   [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE
+0972          ; Recommended                    # 5.1        DEVANAGARI LETTER CANDRA A
+0973..0977    ; Recommended                    # 6.0    [5] DEVANAGARI LETTER OE..DEVANAGARI LETTER UUE
+097B..097C    ; Recommended                    # 5.0    [2] DEVANAGARI LETTER GGA..DEVANAGARI LETTER JJA
+097E..097F    ; Recommended                    # 5.0    [2] DEVANAGARI LETTER DDDA..DEVANAGARI LETTER BBA
+0981..0983    ; Recommended                    # 1.1    [3] BENGALI SIGN CANDRABINDU..BENGALI SIGN VISARGA
+0985..098B    ; Recommended                    # 1.1    [7] BENGALI LETTER A..BENGALI LETTER VOCALIC R
+098F..0990    ; Recommended                    # 1.1    [2] BENGALI LETTER E..BENGALI LETTER AI
+0993..09A8    ; Recommended                    # 1.1   [22] BENGALI LETTER O..BENGALI LETTER NA
+09AA..09B0    ; Recommended                    # 1.1    [7] BENGALI LETTER PA..BENGALI LETTER RA
+09B2          ; Recommended                    # 1.1        BENGALI LETTER LA
+09B6..09B9    ; Recommended                    # 1.1    [4] BENGALI LETTER SHA..BENGALI LETTER HA
+09BC          ; Recommended                    # 1.1        BENGALI SIGN NUKTA
+09BE..09C4    ; Recommended                    # 1.1    [7] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN VOCALIC RR
+09C7..09C8    ; Recommended                    # 1.1    [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI
+09CB..09CD    ; Recommended                    # 1.1    [3] BENGALI VOWEL SIGN O..BENGALI SIGN VIRAMA
+09CE          ; Recommended                    # 4.1        BENGALI LETTER KHANDA TA
+09E6..09F1    ; Recommended                    # 1.1   [12] BENGALI DIGIT ZERO..BENGALI LETTER RA WITH LOWER DIAGONAL
+0A02          ; Recommended                    # 1.1        GURMUKHI SIGN BINDI
+0A05..0A0A    ; Recommended                    # 1.1    [6] GURMUKHI LETTER A..GURMUKHI LETTER UU
+0A0F..0A10    ; Recommended                    # 1.1    [2] GURMUKHI LETTER EE..GURMUKHI LETTER AI
+0A13..0A28    ; Recommended                    # 1.1   [22] GURMUKHI LETTER OO..GURMUKHI LETTER NA
+0A2A..0A30    ; Recommended                    # 1.1    [7] GURMUKHI LETTER PA..GURMUKHI LETTER RA
+0A32          ; Recommended                    # 1.1        GURMUKHI LETTER LA
+0A35          ; Recommended                    # 1.1        GURMUKHI LETTER VA
+0A38..0A39    ; Recommended                    # 1.1    [2] GURMUKHI LETTER SA..GURMUKHI LETTER HA
+0A3C          ; Recommended                    # 1.1        GURMUKHI SIGN NUKTA
+0A3E..0A42    ; Recommended                    # 1.1    [5] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN UU
+0A47..0A48    ; Recommended                    # 1.1    [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI
+0A4B..0A4D    ; Recommended                    # 1.1    [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA
+0A5C          ; Recommended                    # 1.1        GURMUKHI LETTER RRA
+0A70..0A71    ; Recommended                    # 1.1    [2] GURMUKHI TIPPI..GURMUKHI ADDAK
+0A82..0A83    ; Recommended                    # 1.1    [2] GUJARATI SIGN ANUSVARA..GUJARATI SIGN VISARGA
+0A85..0A8B    ; Recommended                    # 1.1    [7] GUJARATI LETTER A..GUJARATI LETTER VOCALIC R
+0A8C          ; Recommended                    # 4.0        GUJARATI LETTER VOCALIC L
+0A8D          ; Recommended                    # 1.1        GUJARATI VOWEL CANDRA E
+0A8F..0A91    ; Recommended                    # 1.1    [3] GUJARATI LETTER E..GUJARATI VOWEL CANDRA O
+0A93..0AA8    ; Recommended                    # 1.1   [22] GUJARATI LETTER O..GUJARATI LETTER NA
+0AAA..0AB0    ; Recommended                    # 1.1    [7] GUJARATI LETTER PA..GUJARATI LETTER RA
+0AB2..0AB3    ; Recommended                    # 1.1    [2] GUJARATI LETTER LA..GUJARATI LETTER LLA
+0AB5..0AB9    ; Recommended                    # 1.1    [5] GUJARATI LETTER VA..GUJARATI LETTER HA
+0ABC          ; Recommended                    # 1.1        GUJARATI SIGN NUKTA
+0ABE..0AC5    ; Recommended                    # 1.1    [8] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN CANDRA E
+0AC7..0AC9    ; Recommended                    # 1.1    [3] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN CANDRA O
+0ACB..0ACD    ; Recommended                    # 1.1    [3] GUJARATI VOWEL SIGN O..GUJARATI SIGN VIRAMA
+0AE6..0AEF    ; Recommended                    # 1.1   [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE
+0B01..0B03    ; Recommended                    # 1.1    [3] ORIYA SIGN CANDRABINDU..ORIYA SIGN VISARGA
+0B05..0B0B    ; Recommended                    # 1.1    [7] ORIYA LETTER A..ORIYA LETTER VOCALIC R
+0B0F..0B10    ; Recommended                    # 1.1    [2] ORIYA LETTER E..ORIYA LETTER AI
+0B13..0B28    ; Recommended                    # 1.1   [22] ORIYA LETTER O..ORIYA LETTER NA
+0B2A..0B30    ; Recommended                    # 1.1    [7] ORIYA LETTER PA..ORIYA LETTER RA
+0B32..0B33    ; Recommended                    # 1.1    [2] ORIYA LETTER LA..ORIYA LETTER LLA
+0B36..0B39    ; Recommended                    # 1.1    [4] ORIYA LETTER SHA..ORIYA LETTER HA
+0B3C          ; Recommended                    # 1.1        ORIYA SIGN NUKTA
+0B3E..0B43    ; Recommended                    # 1.1    [6] ORIYA VOWEL SIGN AA..ORIYA VOWEL SIGN VOCALIC R
+0B47..0B48    ; Recommended                    # 1.1    [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI
+0B4B..0B4D    ; Recommended                    # 1.1    [3] ORIYA VOWEL SIGN O..ORIYA SIGN VIRAMA
+0B56          ; Recommended                    # 1.1        ORIYA AI LENGTH MARK
+0B5F          ; Recommended                    # 1.1        ORIYA LETTER YYA
+0B71          ; Recommended                    # 4.0        ORIYA LETTER WA
+0B83          ; Recommended                    # 1.1        TAMIL SIGN VISARGA
+0B85..0B8A    ; Recommended                    # 1.1    [6] TAMIL LETTER A..TAMIL LETTER UU
+0B8E..0B90    ; Recommended                    # 1.1    [3] TAMIL LETTER E..TAMIL LETTER AI
+0B92..0B95    ; Recommended                    # 1.1    [4] TAMIL LETTER O..TAMIL LETTER KA
+0B99..0B9A    ; Recommended                    # 1.1    [2] TAMIL LETTER NGA..TAMIL LETTER CA
+0B9C          ; Recommended                    # 1.1        TAMIL LETTER JA
+0B9E..0B9F    ; Recommended                    # 1.1    [2] TAMIL LETTER NYA..TAMIL LETTER TTA
+0BA3..0BA4    ; Recommended                    # 1.1    [2] TAMIL LETTER NNA..TAMIL LETTER TA
+0BA8..0BAA    ; Recommended                    # 1.1    [3] TAMIL LETTER NA..TAMIL LETTER PA
+0BAE..0BB5    ; Recommended                    # 1.1    [8] TAMIL LETTER MA..TAMIL LETTER VA
+0BB6          ; Recommended                    # 4.1        TAMIL LETTER SHA
+0BB7..0BB9    ; Recommended                    # 1.1    [3] TAMIL LETTER SSA..TAMIL LETTER HA
+0BBE..0BC2    ; Recommended                    # 1.1    [5] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN UU
+0BC6..0BC8    ; Recommended                    # 1.1    [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI
+0BCA..0BCD    ; Recommended                    # 1.1    [4] TAMIL VOWEL SIGN O..TAMIL SIGN VIRAMA
+0C02..0C03    ; Recommended                    # 1.1    [2] TELUGU SIGN ANUSVARA..TELUGU SIGN VISARGA
+0C05..0C0B    ; Recommended                    # 1.1    [7] TELUGU LETTER A..TELUGU LETTER VOCALIC R
+0C0E..0C10    ; Recommended                    # 1.1    [3] TELUGU LETTER E..TELUGU LETTER AI
+0C12..0C28    ; Recommended                    # 1.1   [23] TELUGU LETTER O..TELUGU LETTER NA
+0C2A..0C30    ; Recommended                    # 1.1    [7] TELUGU LETTER PA..TELUGU LETTER RA
+0C32..0C33    ; Recommended                    # 1.1    [2] TELUGU LETTER LA..TELUGU LETTER LLA
+0C35..0C39    ; Recommended                    # 1.1    [5] TELUGU LETTER VA..TELUGU LETTER HA
+0C3E..0C44    ; Recommended                    # 1.1    [7] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN VOCALIC RR
+0C46..0C48    ; Recommended                    # 1.1    [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI
+0C4A..0C4D    ; Recommended                    # 1.1    [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA
+0C82..0C83    ; Recommended                    # 1.1    [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA
+0C85..0C8B    ; Recommended                    # 1.1    [7] KANNADA LETTER A..KANNADA LETTER VOCALIC R
+0C8E..0C90    ; Recommended                    # 1.1    [3] KANNADA LETTER E..KANNADA LETTER AI
+0C92..0CA8    ; Recommended                    # 1.1   [23] KANNADA LETTER O..KANNADA LETTER NA
+0CAA..0CB0    ; Recommended                    # 1.1    [7] KANNADA LETTER PA..KANNADA LETTER RA
+0CB2..0CB3    ; Recommended                    # 1.1    [2] KANNADA LETTER LA..KANNADA LETTER LLA
+0CB5..0CB9    ; Recommended                    # 1.1    [5] KANNADA LETTER VA..KANNADA LETTER HA
+0CBE..0CC3    ; Recommended                    # 1.1    [6] KANNADA VOWEL SIGN AA..KANNADA VOWEL SIGN VOCALIC R
+0CC6..0CC8    ; Recommended                    # 1.1    [3] KANNADA VOWEL SIGN E..KANNADA VOWEL SIGN AI
+0CCA..0CCD    ; Recommended                    # 1.1    [4] KANNADA VOWEL SIGN O..KANNADA SIGN VIRAMA
+0CE6..0CEF    ; Recommended                    # 1.1   [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
+0D02..0D03    ; Recommended                    # 1.1    [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
+0D05..0D0B    ; Recommended                    # 1.1    [7] MALAYALAM LETTER A..MALAYALAM LETTER VOCALIC R
+0D0E..0D10    ; Recommended                    # 1.1    [3] MALAYALAM LETTER E..MALAYALAM LETTER AI
+0D12..0D28    ; Recommended                    # 1.1   [23] MALAYALAM LETTER O..MALAYALAM LETTER NA
+0D2A..0D39    ; Recommended                    # 1.1   [16] MALAYALAM LETTER PA..MALAYALAM LETTER HA
+0D3E..0D43    ; Recommended                    # 1.1    [6] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN VOCALIC R
+0D46..0D48    ; Recommended                    # 1.1    [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI
+0D4A..0D4B    ; Recommended                    # 1.1    [2] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN OO
+0D4D          ; Recommended                    # 1.1        MALAYALAM SIGN VIRAMA
+0D57          ; Recommended                    # 1.1        MALAYALAM AU LENGTH MARK
+0D7A..0D7F    ; Recommended                    # 5.1    [6] MALAYALAM LETTER CHILLU NN..MALAYALAM LETTER CHILLU K
+0D82..0D83    ; Recommended                    # 3.0    [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA
+0D85..0D8D    ; Recommended                    # 3.0    [9] SINHALA LETTER AYANNA..SINHALA LETTER IRUYANNA
+0D91..0D96    ; Recommended                    # 3.0    [6] SINHALA LETTER EYANNA..SINHALA LETTER AUYANNA
+0D9A..0D9D    ; Recommended                    # 3.0    [4] SINHALA LETTER ALPAPRAANA KAYANNA..SINHALA LETTER MAHAAPRAANA GAYANNA
+0D9F..0DB1    ; Recommended                    # 3.0   [19] SINHALA LETTER SANYAKA GAYANNA..SINHALA LETTER DANTAJA NAYANNA
+0DB3..0DBB    ; Recommended                    # 3.0    [9] SINHALA LETTER SANYAKA DAYANNA..SINHALA LETTER RAYANNA
+0DBD          ; Recommended                    # 3.0        SINHALA LETTER DANTAJA LAYANNA
+0DC0..0DC6    ; Recommended                    # 3.0    [7] SINHALA LETTER VAYANNA..SINHALA LETTER FAYANNA
+0DCA          ; Recommended                    # 3.0        SINHALA SIGN AL-LAKUNA
+0DCF..0DD4    ; Recommended                    # 3.0    [6] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA
+0DD6          ; Recommended                    # 3.0        SINHALA VOWEL SIGN DIGA PAA-PILLA
+0DD8..0DDE    ; Recommended                    # 3.0    [7] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA
+0DF2          ; Recommended                    # 3.0        SINHALA VOWEL SIGN DIGA GAETTA-PILLA
+0E01..0E32    ; Recommended                    # 1.1   [50] THAI CHARACTER KO KAI..THAI CHARACTER SARA AA
+0E34..0E3A    ; Recommended                    # 1.1    [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU
+0E40..0E4D    ; Recommended                    # 1.1   [14] THAI CHARACTER SARA E..THAI CHARACTER NIKHAHIT
+0E50..0E59    ; Recommended                    # 1.1   [10] THAI DIGIT ZERO..THAI DIGIT NINE
+0E81..0E82    ; Recommended                    # 1.1    [2] LAO LETTER KO..LAO LETTER KHO SUNG
+0E84          ; Recommended                    # 1.1        LAO LETTER KHO TAM
+0E87..0E88    ; Recommended                    # 1.1    [2] LAO LETTER NGO..LAO LETTER CO
+0E8A          ; Recommended                    # 1.1        LAO LETTER SO TAM
+0E8D          ; Recommended                    # 1.1        LAO LETTER NYO
+0E94..0E97    ; Recommended                    # 1.1    [4] LAO LETTER DO..LAO LETTER THO TAM
+0E99..0E9F    ; Recommended                    # 1.1    [7] LAO LETTER NO..LAO LETTER FO SUNG
+0EA1..0EA3    ; Recommended                    # 1.1    [3] LAO LETTER MO..LAO LETTER LO LING
+0EA5          ; Recommended                    # 1.1        LAO LETTER LO LOOT
+0EA7          ; Recommended                    # 1.1        LAO LETTER WO
+0EAA..0EAB    ; Recommended                    # 1.1    [2] LAO LETTER SO SUNG..LAO LETTER HO SUNG
+0EAD..0EAE    ; Recommended                    # 1.1    [2] LAO LETTER O..LAO LETTER HO TAM
+0EB0..0EB2    ; Recommended                    # 1.1    [3] LAO VOWEL SIGN A..LAO VOWEL SIGN AA
+0EB4..0EB9    ; Recommended                    # 1.1    [6] LAO VOWEL SIGN I..LAO VOWEL SIGN UU
+0EBB..0EBD    ; Recommended                    # 1.1    [3] LAO VOWEL SIGN MAI KON..LAO SEMIVOWEL SIGN NYO
+0EC0..0EC4    ; Recommended                    # 1.1    [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
+0EC6          ; Recommended                    # 1.1        LAO KO LA
+0EC8..0ECD    ; Recommended                    # 1.1    [6] LAO TONE MAI EK..LAO NIGGAHITA
+0ED0..0ED9    ; Recommended                    # 1.1   [10] LAO DIGIT ZERO..LAO DIGIT NINE
+0F20..0F29    ; Recommended                    # 2.0   [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE
+0F40..0F42    ; Recommended                    # 2.0    [3] TIBETAN LETTER KA..TIBETAN LETTER GA
+0F44..0F47    ; Recommended                    # 2.0    [4] TIBETAN LETTER NGA..TIBETAN LETTER JA
+0F49..0F4C    ; Recommended                    # 2.0    [4] TIBETAN LETTER NYA..TIBETAN LETTER DDA
+0F4E..0F51    ; Recommended                    # 2.0    [4] TIBETAN LETTER NNA..TIBETAN LETTER DA
+0F53..0F56    ; Recommended                    # 2.0    [4] TIBETAN LETTER NA..TIBETAN LETTER BA
+0F58..0F5B    ; Recommended                    # 2.0    [4] TIBETAN LETTER MA..TIBETAN LETTER DZA
+0F5D..0F68    ; Recommended                    # 2.0   [12] TIBETAN LETTER WA..TIBETAN LETTER A
+0F71..0F72    ; Recommended                    # 2.0    [2] TIBETAN VOWEL SIGN AA..TIBETAN VOWEL SIGN I
+0F74          ; Recommended                    # 2.0        TIBETAN VOWEL SIGN U
+0F7A..0F80    ; Recommended                    # 2.0    [7] TIBETAN VOWEL SIGN E..TIBETAN VOWEL SIGN REVERSED I
+0F84          ; Recommended                    # 2.0        TIBETAN MARK HALANTA
+0F90..0F92    ; Recommended                    # 2.0    [3] TIBETAN SUBJOINED LETTER KA..TIBETAN SUBJOINED LETTER GA
+0F94..0F95    ; Recommended                    # 2.0    [2] TIBETAN SUBJOINED LETTER NGA..TIBETAN SUBJOINED LETTER CA
+0F96          ; Recommended                    # 3.0        TIBETAN SUBJOINED LETTER CHA
+0F97          ; Recommended                    # 2.0        TIBETAN SUBJOINED LETTER JA
+0F99..0F9C    ; Recommended                    # 2.0    [4] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER DDA
+0F9E..0FA1    ; Recommended                    # 2.0    [4] TIBETAN SUBJOINED LETTER NNA..TIBETAN SUBJOINED LETTER DA
+0FA3..0FA6    ; Recommended                    # 2.0    [4] TIBETAN SUBJOINED LETTER NA..TIBETAN SUBJOINED LETTER BA
+0FA8..0FAB    ; Recommended                    # 2.0    [4] TIBETAN SUBJOINED LETTER MA..TIBETAN SUBJOINED LETTER DZA
+0FAD          ; Recommended                    # 2.0        TIBETAN SUBJOINED LETTER WA
+0FB1..0FB7    ; Recommended                    # 2.0    [7] TIBETAN SUBJOINED LETTER YA..TIBETAN SUBJOINED LETTER HA
+0FB8          ; Recommended                    # 3.0        TIBETAN SUBJOINED LETTER A
+0FBA..0FBC    ; Recommended                    # 3.0    [3] TIBETAN SUBJOINED LETTER FIXED-FORM WA..TIBETAN SUBJOINED LETTER FIXED-FORM RA
+1000..1021    ; Recommended                    # 3.0   [34] MYANMAR LETTER KA..MYANMAR LETTER A
+1022          ; Recommended                    # 5.1        MYANMAR LETTER SHAN A
+1023..1027    ; Recommended                    # 3.0    [5] MYANMAR LETTER I..MYANMAR LETTER E
+1028          ; Recommended                    # 5.1        MYANMAR LETTER MON E
+1029..102A    ; Recommended                    # 3.0    [2] MYANMAR LETTER O..MYANMAR LETTER AU
+102B          ; Recommended                    # 5.1        MYANMAR VOWEL SIGN TALL AA
+102C..1032    ; Recommended                    # 3.0    [7] MYANMAR VOWEL SIGN AA..MYANMAR VOWEL SIGN AI
+1033..1035    ; Recommended                    # 5.1    [3] MYANMAR VOWEL SIGN MON II..MYANMAR VOWEL SIGN E ABOVE
+1036..1039    ; Recommended                    # 3.0    [4] MYANMAR SIGN ANUSVARA..MYANMAR SIGN VIRAMA
+103A..103F    ; Recommended                    # 5.1    [6] MYANMAR SIGN ASAT..MYANMAR LETTER GREAT SA
+1040..1049    ; Recommended                    # 3.0   [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE
+105A..1064    ; Recommended                    # 5.1   [11] MYANMAR LETTER MON NGA..MYANMAR TONE MARK SGAW KAREN KE PHO
+1075..108A    ; Recommended                    # 5.1   [22] MYANMAR LETTER SHAN KA..MYANMAR SIGN SHAN TONE-6
+108F          ; Recommended                    # 5.1        MYANMAR SIGN RUMAI PALAUNG TONE-5
+10C7          ; Recommended                    # 6.1        GEORGIAN CAPITAL LETTER YN
+10CD          ; Recommended                    # 6.1        GEORGIAN CAPITAL LETTER AEN
+10D0..10F0    ; Recommended                    # 1.1   [33] GEORGIAN LETTER AN..GEORGIAN LETTER HAE
+1200..1206    ; Recommended                    # 3.0    [7] ETHIOPIC SYLLABLE HA..ETHIOPIC SYLLABLE HO
+1208..1246    ; Recommended                    # 3.0   [63] ETHIOPIC SYLLABLE LA..ETHIOPIC SYLLABLE QO
+1247          ; Recommended                    # 4.1        ETHIOPIC SYLLABLE QOA
+1248          ; Recommended                    # 3.0        ETHIOPIC SYLLABLE QWA
+124A..124D    ; Recommended                    # 3.0    [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SYLLABLE QWE
+1250..1256    ; Recommended                    # 3.0    [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SYLLABLE QHO
+1258          ; Recommended                    # 3.0        ETHIOPIC SYLLABLE QHWA
+125A..125D    ; Recommended                    # 3.0    [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC SYLLABLE QHWE
+1260..1286    ; Recommended                    # 3.0   [39] ETHIOPIC SYLLABLE BA..ETHIOPIC SYLLABLE XO
+1288          ; Recommended                    # 3.0        ETHIOPIC SYLLABLE XWA
+128A..128D    ; Recommended                    # 3.0    [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SYLLABLE XWE
+1290..12AE    ; Recommended                    # 3.0   [31] ETHIOPIC SYLLABLE NA..ETHIOPIC SYLLABLE KO
+12B0          ; Recommended                    # 3.0        ETHIOPIC SYLLABLE KWA
+12B2..12B5    ; Recommended                    # 3.0    [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SYLLABLE KWE
+12B8..12BE    ; Recommended                    # 3.0    [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SYLLABLE KXO
+12C0          ; Recommended                    # 3.0        ETHIOPIC SYLLABLE KXWA
+12C2..12C5    ; Recommended                    # 3.0    [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC SYLLABLE KXWE
+12C8..12CE    ; Recommended                    # 3.0    [7] ETHIOPIC SYLLABLE WA..ETHIOPIC SYLLABLE WO
+12CF          ; Recommended                    # 4.1        ETHIOPIC SYLLABLE WOA
+12D0..12D6    ; Recommended                    # 3.0    [7] ETHIOPIC SYLLABLE PHARYNGEAL A..ETHIOPIC SYLLABLE PHARYNGEAL O
+12D8..12EE    ; Recommended                    # 3.0   [23] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYLLABLE YO
+12EF          ; Recommended                    # 4.1        ETHIOPIC SYLLABLE YOA
+12F0..12F7    ; Recommended                    # 3.0    [8] ETHIOPIC SYLLABLE DA..ETHIOPIC SYLLABLE DWA
+1300..130E    ; Recommended                    # 3.0   [15] ETHIOPIC SYLLABLE JA..ETHIOPIC SYLLABLE GO
+1310          ; Recommended                    # 3.0        ETHIOPIC SYLLABLE GWA
+1312..1315    ; Recommended                    # 3.0    [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SYLLABLE GWE
+1318..131E    ; Recommended                    # 3.0    [7] ETHIOPIC SYLLABLE GGA..ETHIOPIC SYLLABLE GGO
+1320..1346    ; Recommended                    # 3.0   [39] ETHIOPIC SYLLABLE THA..ETHIOPIC SYLLABLE TZO
+1348..1359    ; Recommended                    # 3.0   [18] ETHIOPIC SYLLABLE FA..ETHIOPIC SYLLABLE MYA
+1780..179C    ; Recommended                    # 3.0   [29] KHMER LETTER KA..KHMER LETTER VO
+179F..17A2    ; Recommended                    # 3.0    [4] KHMER LETTER SA..KHMER LETTER QA
+17A5..17A7    ; Recommended                    # 3.0    [3] KHMER INDEPENDENT VOWEL QI..KHMER INDEPENDENT VOWEL QU
+17AA..17B3    ; Recommended                    # 3.0   [10] KHMER INDEPENDENT VOWEL QUUV..KHMER INDEPENDENT VOWEL QAU
+17B6..17CD    ; Recommended                    # 3.0   [24] KHMER VOWEL SIGN AA..KHMER SIGN TOANDAKHIAT
+17D0          ; Recommended                    # 3.0        KHMER SIGN SAMYOK SANNYA
+17D2          ; Recommended                    # 3.0        KHMER SIGN COENG
+17E0..17E9    ; Recommended                    # 3.0   [10] KHMER DIGIT ZERO..KHMER DIGIT NINE
+1C90..1CBA    ; Recommended                    # 11.0  [43] GEORGIAN MTAVRULI CAPITAL LETTER AN..GEORGIAN MTAVRULI CAPITAL LETTER AIN
+1CBD..1CBF    ; Recommended                    # 11.0   [3] GEORGIAN MTAVRULI CAPITAL LETTER AEN..GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN
+1E0C..1E0D    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER D WITH DOT BELOW..LATIN SMALL LETTER D WITH DOT BELOW
+1E12..1E13    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW..LATIN SMALL LETTER D WITH CIRCUMFLEX BELOW
+1E20..1E21    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER G WITH MACRON..LATIN SMALL LETTER G WITH MACRON
+1E24..1E25    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER H WITH DOT BELOW..LATIN SMALL LETTER H WITH DOT BELOW
+1E36..1E37    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER L WITH DOT BELOW..LATIN SMALL LETTER L WITH DOT BELOW
+1E3C..1E3F    ; Recommended                    # 1.1    [4] LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW..LATIN SMALL LETTER M WITH ACUTE
+1E42..1E4B    ; Recommended                    # 1.1   [10] LATIN CAPITAL LETTER M WITH DOT BELOW..LATIN SMALL LETTER N WITH CIRCUMFLEX BELOW
+1E5A..1E5B    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER R WITH DOT BELOW..LATIN SMALL LETTER R WITH DOT BELOW
+1E62..1E63    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER S WITH DOT BELOW..LATIN SMALL LETTER S WITH DOT BELOW
+1E6C..1E6D    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER T WITH DOT BELOW..LATIN SMALL LETTER T WITH DOT BELOW
+1E70..1E71    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW..LATIN SMALL LETTER T WITH CIRCUMFLEX BELOW
+1E8C..1E8D    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER X WITH DIAERESIS..LATIN SMALL LETTER X WITH DIAERESIS
+1E92..1E93    ; Recommended                    # 1.1    [2] LATIN CAPITAL LETTER Z WITH DOT BELOW..LATIN SMALL LETTER Z WITH DOT BELOW
+1E9E          ; Recommended                    # 5.1        LATIN CAPITAL LETTER SHARP S
+1EA0..1EF9    ; Recommended                    # 1.1   [90] LATIN CAPITAL LETTER A WITH DOT BELOW..LATIN SMALL LETTER Y WITH TILDE
+1FA0..1FAF    ; Recommended                    # 1.1   [16] GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI..GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1FB2..1FB4    ; Recommended                    # 1.1    [3] GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI
+1FEC          ; Recommended                    # 1.1        GREEK CAPITAL LETTER RHO WITH DASIA
+3005..3007    ; Recommended                    # 1.1    [3] IDEOGRAPHIC ITERATION MARK..IDEOGRAPHIC NUMBER ZERO
+3041..3094    ; Recommended                    # 1.1   [84] HIRAGANA LETTER SMALL A..HIRAGANA LETTER VU
+3095..3096    ; Recommended                    # 3.2    [2] HIRAGANA LETTER SMALL KA..HIRAGANA LETTER SMALL KE
+309D..309E    ; Recommended                    # 1.1    [2] HIRAGANA ITERATION MARK..HIRAGANA VOICED ITERATION MARK
+30A1..30FA    ; Recommended                    # 1.1   [90] KATAKANA LETTER SMALL A..KATAKANA LETTER VO
+30FC..30FE    ; Recommended                    # 1.1    [3] KATAKANA-HIRAGANA PROLONGED SOUND MARK..KATAKANA VOICED ITERATION MARK
+3447          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3447
+3473          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3473
+34E4          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-34E4
+3577          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3577
+359E          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-359E
+35A1          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-35A1
+35AD          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-35AD
+35BF          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-35BF
+35CE          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-35CE
+35F3          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-35F3
+35FE          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-35FE
+360E          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-360E
+361A          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-361A
+3918          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3918
+3960          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3960
+396E          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-396E
+39CF..39D0    ; Recommended                    # 3.0    [2] CJK UNIFIED IDEOGRAPH-39CF..CJK UNIFIED IDEOGRAPH-39D0
+39DB          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-39DB
+39DF          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-39DF
+39F8          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-39F8
+39FE          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-39FE
+3A18          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3A18
+3A52          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3A52
+3A5C          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3A5C
+3A67          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3A67
+3A73          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3A73
+3B39          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3B39
+3B4E          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3B4E
+3BA3          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3BA3
+3C6E          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3C6E
+3CE0          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3CE0
+3DE7          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3DE7
+3DEB          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3DEB
+3E74          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3E74
+3ED0          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-3ED0
+4056          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4056
+4065          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4065
+406A          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-406A
+40BB          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-40BB
+40DF          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-40DF
+4137          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4137
+415F          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-415F
+4337          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4337
+43AC          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-43AC
+43B1          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-43B1
+43D3          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-43D3
+43DD          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-43DD
+4443          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4443
+44D6          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-44D6
+44EA          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-44EA
+4606          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4606
+464C          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-464C
+4661          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4661
+4723          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4723
+4729          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4729
+477C          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-477C
+478D          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-478D
+47F4          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-47F4
+4882          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4882
+4947          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4947
+497A          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-497A
+497D          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-497D
+4982..4983    ; Recommended                    # 3.0    [2] CJK UNIFIED IDEOGRAPH-4982..CJK UNIFIED IDEOGRAPH-4983
+4985..4986    ; Recommended                    # 3.0    [2] CJK UNIFIED IDEOGRAPH-4985..CJK UNIFIED IDEOGRAPH-4986
+499B          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-499B
+499F          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-499F
+49B6..49B7    ; Recommended                    # 3.0    [2] CJK UNIFIED IDEOGRAPH-49B6..CJK UNIFIED IDEOGRAPH-49B7
+4A12          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4A12
+4AB8          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4AB8
+4C77          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4C77
+4C7D          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4C7D
+4C81          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4C81
+4C85          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4C85
+4C9D..4CA3    ; Recommended                    # 3.0    [7] CJK UNIFIED IDEOGRAPH-4C9D..CJK UNIFIED IDEOGRAPH-4CA3
+4D13..4D19    ; Recommended                    # 3.0    [7] CJK UNIFIED IDEOGRAPH-4D13..CJK UNIFIED IDEOGRAPH-4D19
+4DAE          ; Recommended                    # 3.0        CJK UNIFIED IDEOGRAPH-4DAE
+4E00..4E11    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-4E11
+4E13..4E28    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-4E13..CJK UNIFIED IDEOGRAPH-4E28
+4E2A..4E67    ; Recommended                    # 1.1   [62] CJK UNIFIED IDEOGRAPH-4E2A..CJK UNIFIED IDEOGRAPH-4E67
+4E69..4E78    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-4E69..CJK UNIFIED IDEOGRAPH-4E78
+4E7A..4E95    ; Recommended                    # 1.1   [28] CJK UNIFIED IDEOGRAPH-4E7A..CJK UNIFIED IDEOGRAPH-4E95
+4E97..4EA2    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-4E97..CJK UNIFIED IDEOGRAPH-4EA2
+4EA4..4EBB    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-4EA4..CJK UNIFIED IDEOGRAPH-4EBB
+4EBD..4ECB    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-4EBD..CJK UNIFIED IDEOGRAPH-4ECB
+4ECD..4EE6    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-4ECD..CJK UNIFIED IDEOGRAPH-4EE6
+4EE8..4EF7    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-4EE8..CJK UNIFIED IDEOGRAPH-4EF7
+4EFB          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-4EFB
+4EFD          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-4EFD
+4EFF..4F06    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-4EFF..CJK UNIFIED IDEOGRAPH-4F06
+4F08..4F15    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-4F08..CJK UNIFIED IDEOGRAPH-4F15
+4F17..4F27    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-4F17..CJK UNIFIED IDEOGRAPH-4F27
+4F29..4F30    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-4F29..CJK UNIFIED IDEOGRAPH-4F30
+4F32..4F34    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-4F32..CJK UNIFIED IDEOGRAPH-4F34
+4F36          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-4F36
+4F38..4F3F    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-4F38..CJK UNIFIED IDEOGRAPH-4F3F
+4F41..4F43    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-4F41..CJK UNIFIED IDEOGRAPH-4F43
+4F45..4F70    ; Recommended                    # 1.1   [44] CJK UNIFIED IDEOGRAPH-4F45..CJK UNIFIED IDEOGRAPH-4F70
+4F72..4F8B    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-4F72..CJK UNIFIED IDEOGRAPH-4F8B
+4F8D          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-4F8D
+4F8F..4FA1    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-4F8F..CJK UNIFIED IDEOGRAPH-4FA1
+4FA3..4FBC    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-4FA3..CJK UNIFIED IDEOGRAPH-4FBC
+4FBE..4FC5    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-4FBE..CJK UNIFIED IDEOGRAPH-4FC5
+4FC7          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-4FC7
+4FC9..4FCB    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-4FC9..CJK UNIFIED IDEOGRAPH-4FCB
+4FCD..4FE1    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-4FCD..CJK UNIFIED IDEOGRAPH-4FE1
+4FE3..4FFB    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-4FE3..CJK UNIFIED IDEOGRAPH-4FFB
+4FFE..500F    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-4FFE..CJK UNIFIED IDEOGRAPH-500F
+5011..5033    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-5011..CJK UNIFIED IDEOGRAPH-5033
+5035..5037    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-5035..CJK UNIFIED IDEOGRAPH-5037
+5039..503C    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-5039..CJK UNIFIED IDEOGRAPH-503C
+503E..5041    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-503E..CJK UNIFIED IDEOGRAPH-5041
+5043..5051    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-5043..CJK UNIFIED IDEOGRAPH-5051
+5053..5057    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-5053..CJK UNIFIED IDEOGRAPH-5057
+5059..507B    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-5059..CJK UNIFIED IDEOGRAPH-507B
+507D..5080    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-507D..CJK UNIFIED IDEOGRAPH-5080
+5082..5092    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-5082..CJK UNIFIED IDEOGRAPH-5092
+5094..5096    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-5094..CJK UNIFIED IDEOGRAPH-5096
+5098..509E    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-5098..CJK UNIFIED IDEOGRAPH-509E
+50A2..50B8    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-50A2..CJK UNIFIED IDEOGRAPH-50B8
+50BA..50C2    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-50BA..CJK UNIFIED IDEOGRAPH-50C2
+50C4..50D7    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-50C4..CJK UNIFIED IDEOGRAPH-50D7
+50D9..50DE    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-50D9..CJK UNIFIED IDEOGRAPH-50DE
+50E0          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-50E0
+50E3..50EA    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-50E3..CJK UNIFIED IDEOGRAPH-50EA
+50EC..50F3    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-50EC..CJK UNIFIED IDEOGRAPH-50F3
+50F5..50F6    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-50F5..CJK UNIFIED IDEOGRAPH-50F6
+50F8..511A    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-50F8..CJK UNIFIED IDEOGRAPH-511A
+511C..5127    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-511C..CJK UNIFIED IDEOGRAPH-5127
+5129..512A    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5129..CJK UNIFIED IDEOGRAPH-512A
+512C..5141    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-512C..CJK UNIFIED IDEOGRAPH-5141
+5143..5149    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-5143..CJK UNIFIED IDEOGRAPH-5149
+514B..514E    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-514B..CJK UNIFIED IDEOGRAPH-514E
+5150..5152    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-5150..CJK UNIFIED IDEOGRAPH-5152
+5154..5157    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-5154..CJK UNIFIED IDEOGRAPH-5157
+5159..515F    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-5159..CJK UNIFIED IDEOGRAPH-515F
+5161..5163    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-5161..CJK UNIFIED IDEOGRAPH-5163
+5165..5171    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-5165..CJK UNIFIED IDEOGRAPH-5171
+5173..517D    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-5173..CJK UNIFIED IDEOGRAPH-517D
+517F..5182    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-517F..CJK UNIFIED IDEOGRAPH-5182
+5185..518D    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-5185..CJK UNIFIED IDEOGRAPH-518D
+518F..51A0    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-518F..CJK UNIFIED IDEOGRAPH-51A0
+51A2          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-51A2
+51A4..51AC    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-51A4..CJK UNIFIED IDEOGRAPH-51AC
+51AE..51B7    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-51AE..CJK UNIFIED IDEOGRAPH-51B7
+51B9          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-51B9
+51BB..51C1    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-51BB..CJK UNIFIED IDEOGRAPH-51C1
+51C3..51D1    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-51C3..CJK UNIFIED IDEOGRAPH-51D1
+51D4..51DE    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-51D4..CJK UNIFIED IDEOGRAPH-51DE
+51E0..51EB    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-51E0..CJK UNIFIED IDEOGRAPH-51EB
+51ED          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-51ED
+51EF..51F1    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-51EF..CJK UNIFIED IDEOGRAPH-51F1
+51F3..5252    ; Recommended                    # 1.1   [96] CJK UNIFIED IDEOGRAPH-51F3..CJK UNIFIED IDEOGRAPH-5252
+5254..5265    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-5254..CJK UNIFIED IDEOGRAPH-5265
+5267..5278    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-5267..CJK UNIFIED IDEOGRAPH-5278
+527A..5284    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-527A..CJK UNIFIED IDEOGRAPH-5284
+5286..528D    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-5286..CJK UNIFIED IDEOGRAPH-528D
+528F..52C3    ; Recommended                    # 1.1   [53] CJK UNIFIED IDEOGRAPH-528F..CJK UNIFIED IDEOGRAPH-52C3
+52C5..52C7    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-52C5..CJK UNIFIED IDEOGRAPH-52C7
+52C9..52CB    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-52C9..CJK UNIFIED IDEOGRAPH-52CB
+52CD          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-52CD
+52CF..52D0    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-52CF..CJK UNIFIED IDEOGRAPH-52D0
+52D2..52D3    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-52D2..CJK UNIFIED IDEOGRAPH-52D3
+52D5..52E0    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-52D5..CJK UNIFIED IDEOGRAPH-52E0
+52E2..52E4    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-52E2..CJK UNIFIED IDEOGRAPH-52E4
+52E6..52ED    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-52E6..CJK UNIFIED IDEOGRAPH-52ED
+52EF..5302    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-52EF..CJK UNIFIED IDEOGRAPH-5302
+5305..5317    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-5305..CJK UNIFIED IDEOGRAPH-5317
+5319..531A    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5319..CJK UNIFIED IDEOGRAPH-531A
+531C..531D    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-531C..CJK UNIFIED IDEOGRAPH-531D
+531F..5326    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-531F..CJK UNIFIED IDEOGRAPH-5326
+5328          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-5328
+532A..5331    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-532A..CJK UNIFIED IDEOGRAPH-5331
+5333..5334    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5333..CJK UNIFIED IDEOGRAPH-5334
+5337..5341    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-5337..CJK UNIFIED IDEOGRAPH-5341
+5343..535A    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-5343..CJK UNIFIED IDEOGRAPH-535A
+535C          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-535C
+535E..5369    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-535E..CJK UNIFIED IDEOGRAPH-5369
+536B..536C    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-536B..CJK UNIFIED IDEOGRAPH-536C
+536E..537F    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-536E..CJK UNIFIED IDEOGRAPH-537F
+5381..53A0    ; Recommended                    # 1.1   [32] CJK UNIFIED IDEOGRAPH-5381..CJK UNIFIED IDEOGRAPH-53A0
+53A2..53A9    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-53A2..CJK UNIFIED IDEOGRAPH-53A9
+53AC..53AE    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-53AC..CJK UNIFIED IDEOGRAPH-53AE
+53B0..53B9    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-53B0..CJK UNIFIED IDEOGRAPH-53B9
+53BB..53C4    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-53BB..CJK UNIFIED IDEOGRAPH-53C4
+53C6..53CE    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-53C6..CJK UNIFIED IDEOGRAPH-53CE
+53D0..53DC    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-53D0..CJK UNIFIED IDEOGRAPH-53DC
+53DF..53E6    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-53DF..CJK UNIFIED IDEOGRAPH-53E6
+53E8..53FE    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-53E8..CJK UNIFIED IDEOGRAPH-53FE
+5401..5419    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-5401..CJK UNIFIED IDEOGRAPH-5419
+541B..5421    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-541B..CJK UNIFIED IDEOGRAPH-5421
+5423..544B    ; Recommended                    # 1.1   [41] CJK UNIFIED IDEOGRAPH-5423..CJK UNIFIED IDEOGRAPH-544B
+544D..545C    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-544D..CJK UNIFIED IDEOGRAPH-545C
+545E..5468    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-545E..CJK UNIFIED IDEOGRAPH-5468
+546A..5489    ; Recommended                    # 1.1   [32] CJK UNIFIED IDEOGRAPH-546A..CJK UNIFIED IDEOGRAPH-5489
+548B..54B4    ; Recommended                    # 1.1   [42] CJK UNIFIED IDEOGRAPH-548B..CJK UNIFIED IDEOGRAPH-54B4
+54B6..54F5    ; Recommended                    # 1.1   [64] CJK UNIFIED IDEOGRAPH-54B6..CJK UNIFIED IDEOGRAPH-54F5
+54F7..5514    ; Recommended                    # 1.1   [30] CJK UNIFIED IDEOGRAPH-54F7..CJK UNIFIED IDEOGRAPH-5514
+5516..5517    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5516..CJK UNIFIED IDEOGRAPH-5517
+551A..5546    ; Recommended                    # 1.1   [45] CJK UNIFIED IDEOGRAPH-551A..CJK UNIFIED IDEOGRAPH-5546
+5548..555F    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-5548..CJK UNIFIED IDEOGRAPH-555F
+5561..5579    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-5561..CJK UNIFIED IDEOGRAPH-5579
+557B..55DF    ; Recommended                    # 1.1  [101] CJK UNIFIED IDEOGRAPH-557B..CJK UNIFIED IDEOGRAPH-55DF
+55E1..55F7    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-55E1..CJK UNIFIED IDEOGRAPH-55F7
+55F9..5609    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-55F9..CJK UNIFIED IDEOGRAPH-5609
+560C..561F    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-560C..CJK UNIFIED IDEOGRAPH-561F
+5621..562A    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-5621..CJK UNIFIED IDEOGRAPH-562A
+562C..5636    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-562C..CJK UNIFIED IDEOGRAPH-5636
+5638..563B    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-5638..CJK UNIFIED IDEOGRAPH-563B
+563D..5643    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-563D..CJK UNIFIED IDEOGRAPH-5643
+5645..564A    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-5645..CJK UNIFIED IDEOGRAPH-564A
+564C..5650    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-564C..CJK UNIFIED IDEOGRAPH-5650
+5652..5655    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-5652..CJK UNIFIED IDEOGRAPH-5655
+5657..565E    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-5657..CJK UNIFIED IDEOGRAPH-565E
+5660          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-5660
+5662..5674    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-5662..CJK UNIFIED IDEOGRAPH-5674
+5676..567C    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-5676..CJK UNIFIED IDEOGRAPH-567C
+567E..5687    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-567E..CJK UNIFIED IDEOGRAPH-5687
+5689..568A    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5689..CJK UNIFIED IDEOGRAPH-568A
+568C..5695    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-568C..CJK UNIFIED IDEOGRAPH-5695
+5697..569D    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-5697..CJK UNIFIED IDEOGRAPH-569D
+569F..56B9    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-569F..CJK UNIFIED IDEOGRAPH-56B9
+56BB..56CE    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-56BB..CJK UNIFIED IDEOGRAPH-56CE
+56D0..56D8    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-56D0..CJK UNIFIED IDEOGRAPH-56D8
+56DA..56E5    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-56DA..CJK UNIFIED IDEOGRAPH-56E5
+56E7..56F5    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-56E7..CJK UNIFIED IDEOGRAPH-56F5
+56F7          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-56F7
+56F9..56FA    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-56F9..CJK UNIFIED IDEOGRAPH-56FA
+56FD..5704    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-56FD..CJK UNIFIED IDEOGRAPH-5704
+5706..5710    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-5706..CJK UNIFIED IDEOGRAPH-5710
+5712..5716    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-5712..CJK UNIFIED IDEOGRAPH-5716
+5718..5720    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-5718..CJK UNIFIED IDEOGRAPH-5720
+5722..5723    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5722..CJK UNIFIED IDEOGRAPH-5723
+5725..573C    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-5725..CJK UNIFIED IDEOGRAPH-573C
+573E..5742    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-573E..CJK UNIFIED IDEOGRAPH-5742
+5744..5747    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-5744..CJK UNIFIED IDEOGRAPH-5747
+5749..5754    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-5749..CJK UNIFIED IDEOGRAPH-5754
+5757          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-5757
+5759..5762    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-5759..CJK UNIFIED IDEOGRAPH-5762
+5764..5777    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-5764..CJK UNIFIED IDEOGRAPH-5777
+5779..5780    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-5779..CJK UNIFIED IDEOGRAPH-5780
+5782..5786    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-5782..CJK UNIFIED IDEOGRAPH-5786
+5788..5795    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-5788..CJK UNIFIED IDEOGRAPH-5795
+5797..57A7    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-5797..CJK UNIFIED IDEOGRAPH-57A7
+57A9..57C9    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-57A9..CJK UNIFIED IDEOGRAPH-57C9
+57CB..57D0    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-57CB..CJK UNIFIED IDEOGRAPH-57D0
+57D2..57DA    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-57D2..CJK UNIFIED IDEOGRAPH-57DA
+57DC..5816    ; Recommended                    # 1.1   [59] CJK UNIFIED IDEOGRAPH-57DC..CJK UNIFIED IDEOGRAPH-5816
+5819..584F    ; Recommended                    # 1.1   [55] CJK UNIFIED IDEOGRAPH-5819..CJK UNIFIED IDEOGRAPH-584F
+5851..5855    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-5851..CJK UNIFIED IDEOGRAPH-5855
+5857..585F    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-5857..CJK UNIFIED IDEOGRAPH-585F
+5861..5865    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-5861..CJK UNIFIED IDEOGRAPH-5865
+5868..5876    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-5868..CJK UNIFIED IDEOGRAPH-5876
+5878..5894    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-5878..CJK UNIFIED IDEOGRAPH-5894
+5896..58A9    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-5896..CJK UNIFIED IDEOGRAPH-58A9
+58AB..58B5    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-58AB..CJK UNIFIED IDEOGRAPH-58B5
+58B7..58BF    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-58B7..CJK UNIFIED IDEOGRAPH-58BF
+58C1..58C2    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-58C1..CJK UNIFIED IDEOGRAPH-58C2
+58C5..58CC    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-58C5..CJK UNIFIED IDEOGRAPH-58CC
+58CE..58CF    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-58CE..CJK UNIFIED IDEOGRAPH-58CF
+58D1..58E0    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-58D1..CJK UNIFIED IDEOGRAPH-58E0
+58E2..58E5    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-58E2..CJK UNIFIED IDEOGRAPH-58E5
+58E7..58F4    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-58E7..CJK UNIFIED IDEOGRAPH-58F4
+58F6..5900    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-58F6..CJK UNIFIED IDEOGRAPH-5900
+5902..5904    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-5902..CJK UNIFIED IDEOGRAPH-5904
+5906..5907    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5906..CJK UNIFIED IDEOGRAPH-5907
+5909..5910    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-5909..CJK UNIFIED IDEOGRAPH-5910
+5912          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-5912
+5914..5922    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-5914..CJK UNIFIED IDEOGRAPH-5922
+5924..5932    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-5924..CJK UNIFIED IDEOGRAPH-5932
+5934..5935    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5934..CJK UNIFIED IDEOGRAPH-5935
+5937..5958    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-5937..CJK UNIFIED IDEOGRAPH-5958
+595A          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-595A
+595C..59B6    ; Recommended                    # 1.1   [91] CJK UNIFIED IDEOGRAPH-595C..CJK UNIFIED IDEOGRAPH-59B6
+59B8..59E6    ; Recommended                    # 1.1   [47] CJK UNIFIED IDEOGRAPH-59B8..CJK UNIFIED IDEOGRAPH-59E6
+59E8..5A23    ; Recommended                    # 1.1   [60] CJK UNIFIED IDEOGRAPH-59E8..CJK UNIFIED IDEOGRAPH-5A23
+5A25          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-5A25
+5A27..5A2B    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-5A27..CJK UNIFIED IDEOGRAPH-5A2B
+5A2D..5A2F    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-5A2D..CJK UNIFIED IDEOGRAPH-5A2F
+5A31..5A53    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-5A31..CJK UNIFIED IDEOGRAPH-5A53
+5A55..5A58    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-5A55..CJK UNIFIED IDEOGRAPH-5A58
+5A5A..5A6E    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-5A5A..CJK UNIFIED IDEOGRAPH-5A6E
+5A70          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-5A70
+5A72..5A86    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-5A72..CJK UNIFIED IDEOGRAPH-5A86
+5A88..5A8C    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-5A88..CJK UNIFIED IDEOGRAPH-5A8C
+5A8E..5AAA    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-5A8E..CJK UNIFIED IDEOGRAPH-5AAA
+5AAC..5AD2    ; Recommended                    # 1.1   [39] CJK UNIFIED IDEOGRAPH-5AAC..CJK UNIFIED IDEOGRAPH-5AD2
+5AD4..5AEE    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-5AD4..CJK UNIFIED IDEOGRAPH-5AEE
+5AF1..5B09    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-5AF1..CJK UNIFIED IDEOGRAPH-5B09
+5B0B..5B0C    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5B0B..CJK UNIFIED IDEOGRAPH-5B0C
+5B0E..5B38    ; Recommended                    # 1.1   [43] CJK UNIFIED IDEOGRAPH-5B0E..CJK UNIFIED IDEOGRAPH-5B38
+5B3A..5B45    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-5B3A..CJK UNIFIED IDEOGRAPH-5B45
+5B47..5B4E    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-5B47..CJK UNIFIED IDEOGRAPH-5B4E
+5B50..5B51    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5B50..CJK UNIFIED IDEOGRAPH-5B51
+5B53..5B5F    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-5B53..CJK UNIFIED IDEOGRAPH-5B5F
+5B62..5B6E    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-5B62..CJK UNIFIED IDEOGRAPH-5B6E
+5B70..5B78    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-5B70..CJK UNIFIED IDEOGRAPH-5B78
+5B7A..5B7D    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-5B7A..CJK UNIFIED IDEOGRAPH-5B7D
+5B7F..5B85    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-5B7F..CJK UNIFIED IDEOGRAPH-5B85
+5B87..5B8F    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-5B87..CJK UNIFIED IDEOGRAPH-5B8F
+5B91..5BA8    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-5B91..CJK UNIFIED IDEOGRAPH-5BA8
+5BAA..5BB1    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-5BAA..CJK UNIFIED IDEOGRAPH-5BB1
+5BB3..5BB6    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-5BB3..CJK UNIFIED IDEOGRAPH-5BB6
+5BB8..5BBB    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-5BB8..CJK UNIFIED IDEOGRAPH-5BBB
+5BBD..5BC7    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-5BBD..CJK UNIFIED IDEOGRAPH-5BC7
+5BC9..5BD9    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-5BC9..CJK UNIFIED IDEOGRAPH-5BD9
+5BDB..5BFF    ; Recommended                    # 1.1   [37] CJK UNIFIED IDEOGRAPH-5BDB..CJK UNIFIED IDEOGRAPH-5BFF
+5C01..5C1A    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-5C01..CJK UNIFIED IDEOGRAPH-5C1A
+5C1C..5C22    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-5C1C..CJK UNIFIED IDEOGRAPH-5C22
+5C24..5C25    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5C24..CJK UNIFIED IDEOGRAPH-5C25
+5C27..5C28    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5C27..CJK UNIFIED IDEOGRAPH-5C28
+5C2A..5C35    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-5C2A..CJK UNIFIED IDEOGRAPH-5C35
+5C37..5C59    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-5C37..CJK UNIFIED IDEOGRAPH-5C59
+5C5B..5C84    ; Recommended                    # 1.1   [42] CJK UNIFIED IDEOGRAPH-5C5B..CJK UNIFIED IDEOGRAPH-5C84
+5C86..5CB3    ; Recommended                    # 1.1   [46] CJK UNIFIED IDEOGRAPH-5C86..CJK UNIFIED IDEOGRAPH-5CB3
+5CB5..5CB8    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-5CB5..CJK UNIFIED IDEOGRAPH-5CB8
+5CBA..5CD4    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-5CBA..CJK UNIFIED IDEOGRAPH-5CD4
+5CD6..5CDC    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-5CD6..CJK UNIFIED IDEOGRAPH-5CDC
+5CDE..5CF4    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-5CDE..CJK UNIFIED IDEOGRAPH-5CF4
+5CF6..5D2A    ; Recommended                    # 1.1   [53] CJK UNIFIED IDEOGRAPH-5CF6..CJK UNIFIED IDEOGRAPH-5D2A
+5D2C..5D2E    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-5D2C..CJK UNIFIED IDEOGRAPH-5D2E
+5D30..5D3A    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-5D30..CJK UNIFIED IDEOGRAPH-5D3A
+5D3C..5D52    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-5D3C..CJK UNIFIED IDEOGRAPH-5D52
+5D54..5D56    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-5D54..CJK UNIFIED IDEOGRAPH-5D56
+5D58..5D5F    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-5D58..CJK UNIFIED IDEOGRAPH-5D5F
+5D61..5D82    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-5D61..CJK UNIFIED IDEOGRAPH-5D82
+5D84..5D95    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-5D84..CJK UNIFIED IDEOGRAPH-5D95
+5D97..5DA2    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-5D97..CJK UNIFIED IDEOGRAPH-5DA2
+5DA5..5DAA    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-5DA5..CJK UNIFIED IDEOGRAPH-5DAA
+5DAC..5DB2    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-5DAC..CJK UNIFIED IDEOGRAPH-5DB2
+5DB4..5DB8    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-5DB4..CJK UNIFIED IDEOGRAPH-5DB8
+5DBA..5DC3    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-5DBA..CJK UNIFIED IDEOGRAPH-5DC3
+5DC5..5DD6    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-5DC5..CJK UNIFIED IDEOGRAPH-5DD6
+5DD8..5DD9    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-5DD8..CJK UNIFIED IDEOGRAPH-5DD9
+5DDB          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-5DDB
+5DDD..5DF5    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-5DDD..CJK UNIFIED IDEOGRAPH-5DF5
+5DF7..5E11    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-5DF7..CJK UNIFIED IDEOGRAPH-5E11
+5E13..5E47    ; Recommended                    # 1.1   [53] CJK UNIFIED IDEOGRAPH-5E13..CJK UNIFIED IDEOGRAPH-5E47
+5E49..5E50    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-5E49..CJK UNIFIED IDEOGRAPH-5E50
+5E52..5E91    ; Recommended                    # 1.1   [64] CJK UNIFIED IDEOGRAPH-5E52..CJK UNIFIED IDEOGRAPH-5E91
+5E93..5EB9    ; Recommended                    # 1.1   [39] CJK UNIFIED IDEOGRAPH-5E93..CJK UNIFIED IDEOGRAPH-5EB9
+5EBB..5EBF    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-5EBB..CJK UNIFIED IDEOGRAPH-5EBF
+5EC1..5EEA    ; Recommended                    # 1.1   [42] CJK UNIFIED IDEOGRAPH-5EC1..CJK UNIFIED IDEOGRAPH-5EEA
+5EEC..5EF8    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-5EEC..CJK UNIFIED IDEOGRAPH-5EF8
+5EFA..5F0D    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-5EFA..CJK UNIFIED IDEOGRAPH-5F0D
+5F0F..5F3A    ; Recommended                    # 1.1   [44] CJK UNIFIED IDEOGRAPH-5F0F..CJK UNIFIED IDEOGRAPH-5F3A
+5F3C          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-5F3C
+5F3E..5F8E    ; Recommended                    # 1.1   [81] CJK UNIFIED IDEOGRAPH-5F3E..CJK UNIFIED IDEOGRAPH-5F8E
+5F90..5F99    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-5F90..CJK UNIFIED IDEOGRAPH-5F99
+5F9B..5FA2    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-5F9B..CJK UNIFIED IDEOGRAPH-5FA2
+5FA5..5FAF    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-5FA5..CJK UNIFIED IDEOGRAPH-5FAF
+5FB1..5FC1    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-5FB1..CJK UNIFIED IDEOGRAPH-5FC1
+5FC3..5FCD    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-5FC3..CJK UNIFIED IDEOGRAPH-5FCD
+5FCF..5FDA    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-5FCF..CJK UNIFIED IDEOGRAPH-5FDA
+5FDC..5FE1    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-5FDC..CJK UNIFIED IDEOGRAPH-5FE1
+5FE3..5FEB    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-5FE3..CJK UNIFIED IDEOGRAPH-5FEB
+5FED..5FFB    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-5FED..CJK UNIFIED IDEOGRAPH-5FFB
+5FFD..6022    ; Recommended                    # 1.1   [38] CJK UNIFIED IDEOGRAPH-5FFD..CJK UNIFIED IDEOGRAPH-6022
+6024..6055    ; Recommended                    # 1.1   [50] CJK UNIFIED IDEOGRAPH-6024..CJK UNIFIED IDEOGRAPH-6055
+6057..6060    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-6057..CJK UNIFIED IDEOGRAPH-6060
+6062..6070    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-6062..CJK UNIFIED IDEOGRAPH-6070
+6072..6073    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-6072..CJK UNIFIED IDEOGRAPH-6073
+6075..6090    ; Recommended                    # 1.1   [28] CJK UNIFIED IDEOGRAPH-6075..CJK UNIFIED IDEOGRAPH-6090
+6092          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6092
+6094..60A4    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-6094..CJK UNIFIED IDEOGRAPH-60A4
+60A6..60D1    ; Recommended                    # 1.1   [44] CJK UNIFIED IDEOGRAPH-60A6..CJK UNIFIED IDEOGRAPH-60D1
+60D3..60D5    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-60D3..CJK UNIFIED IDEOGRAPH-60D5
+60D7..60DD    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-60D7..CJK UNIFIED IDEOGRAPH-60DD
+60DF..60E4    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-60DF..CJK UNIFIED IDEOGRAPH-60E4
+60E6..60FC    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-60E6..CJK UNIFIED IDEOGRAPH-60FC
+60FE..6101    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-60FE..CJK UNIFIED IDEOGRAPH-6101
+6103..6106    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-6103..CJK UNIFIED IDEOGRAPH-6106
+6108..6110    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-6108..CJK UNIFIED IDEOGRAPH-6110
+6112..611D    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-6112..CJK UNIFIED IDEOGRAPH-611D
+611F..6130    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-611F..CJK UNIFIED IDEOGRAPH-6130
+6132          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6132
+6134          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6134
+6136..6137    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-6136..CJK UNIFIED IDEOGRAPH-6137
+613A..615F    ; Recommended                    # 1.1   [38] CJK UNIFIED IDEOGRAPH-613A..CJK UNIFIED IDEOGRAPH-615F
+6161..617A    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-6161..CJK UNIFIED IDEOGRAPH-617A
+617C..617E    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-617C..CJK UNIFIED IDEOGRAPH-617E
+6180..6185    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-6180..CJK UNIFIED IDEOGRAPH-6185
+6187..6196    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-6187..CJK UNIFIED IDEOGRAPH-6196
+6198..619B    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-6198..CJK UNIFIED IDEOGRAPH-619B
+619D..61B8    ; Recommended                    # 1.1   [28] CJK UNIFIED IDEOGRAPH-619D..CJK UNIFIED IDEOGRAPH-61B8
+61BA          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-61BA
+61BC..61D2    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-61BC..CJK UNIFIED IDEOGRAPH-61D2
+61D4          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-61D4
+61D6..61EB    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-61D6..CJK UNIFIED IDEOGRAPH-61EB
+61ED..61EE    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-61ED..CJK UNIFIED IDEOGRAPH-61EE
+61F0..6204    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-61F0..CJK UNIFIED IDEOGRAPH-6204
+6206..6234    ; Recommended                    # 1.1   [47] CJK UNIFIED IDEOGRAPH-6206..CJK UNIFIED IDEOGRAPH-6234
+6236..6238    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-6236..CJK UNIFIED IDEOGRAPH-6238
+623A..6256    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-623A..CJK UNIFIED IDEOGRAPH-6256
+6258..628C    ; Recommended                    # 1.1   [53] CJK UNIFIED IDEOGRAPH-6258..CJK UNIFIED IDEOGRAPH-628C
+628E..629C    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-628E..CJK UNIFIED IDEOGRAPH-629C
+629E..62DD    ; Recommended                    # 1.1   [64] CJK UNIFIED IDEOGRAPH-629E..CJK UNIFIED IDEOGRAPH-62DD
+62DF..62E9    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-62DF..CJK UNIFIED IDEOGRAPH-62E9
+62EB..6309    ; Recommended                    # 1.1   [31] CJK UNIFIED IDEOGRAPH-62EB..CJK UNIFIED IDEOGRAPH-6309
+630B..6316    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-630B..CJK UNIFIED IDEOGRAPH-6316
+6318..6330    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-6318..CJK UNIFIED IDEOGRAPH-6330
+6332..6336    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-6332..CJK UNIFIED IDEOGRAPH-6336
+6338..635A    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-6338..CJK UNIFIED IDEOGRAPH-635A
+635C..638A    ; Recommended                    # 1.1   [47] CJK UNIFIED IDEOGRAPH-635C..CJK UNIFIED IDEOGRAPH-638A
+638C..6392    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-638C..CJK UNIFIED IDEOGRAPH-6392
+6394..63D0    ; Recommended                    # 1.1   [61] CJK UNIFIED IDEOGRAPH-6394..CJK UNIFIED IDEOGRAPH-63D0
+63D2..643A    ; Recommended                    # 1.1  [105] CJK UNIFIED IDEOGRAPH-63D2..CJK UNIFIED IDEOGRAPH-643A
+643D..6448    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-643D..CJK UNIFIED IDEOGRAPH-6448
+644A..6459    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-644A..CJK UNIFIED IDEOGRAPH-6459
+645B..647D    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-645B..CJK UNIFIED IDEOGRAPH-647D
+647F..6485    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-647F..CJK UNIFIED IDEOGRAPH-6485
+6487..64A0    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-6487..CJK UNIFIED IDEOGRAPH-64A0
+64A2..64AE    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-64A2..CJK UNIFIED IDEOGRAPH-64AE
+64B0..64B5    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-64B0..CJK UNIFIED IDEOGRAPH-64B5
+64B7..64C7    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-64B7..CJK UNIFIED IDEOGRAPH-64C7
+64C9..64D4    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-64C9..CJK UNIFIED IDEOGRAPH-64D4
+64D6..64ED    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-64D6..CJK UNIFIED IDEOGRAPH-64ED
+64EF..64F4    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-64EF..CJK UNIFIED IDEOGRAPH-64F4
+64F6..64F8    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-64F6..CJK UNIFIED IDEOGRAPH-64F8
+64FA..6501    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-64FA..CJK UNIFIED IDEOGRAPH-6501
+6503..6509    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-6503..CJK UNIFIED IDEOGRAPH-6509
+650B..651E    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-650B..CJK UNIFIED IDEOGRAPH-651E
+6520..6527    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-6520..CJK UNIFIED IDEOGRAPH-6527
+6529..653F    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-6529..CJK UNIFIED IDEOGRAPH-653F
+6541          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6541
+6543..6559    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-6543..CJK UNIFIED IDEOGRAPH-6559
+655B..655E    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-655B..CJK UNIFIED IDEOGRAPH-655E
+6560..657C    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-6560..CJK UNIFIED IDEOGRAPH-657C
+657E..6589    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-657E..CJK UNIFIED IDEOGRAPH-6589
+658B..6599    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-658B..CJK UNIFIED IDEOGRAPH-6599
+659B..65B4    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-659B..CJK UNIFIED IDEOGRAPH-65B4
+65B6..65BD    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-65B6..CJK UNIFIED IDEOGRAPH-65BD
+65BF..65C7    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-65BF..CJK UNIFIED IDEOGRAPH-65C7
+65CA..65D0    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-65CA..CJK UNIFIED IDEOGRAPH-65D0
+65D2..65D7    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-65D2..CJK UNIFIED IDEOGRAPH-65D7
+65D9..65DB    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-65D9..CJK UNIFIED IDEOGRAPH-65DB
+65DD..65E3    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-65DD..CJK UNIFIED IDEOGRAPH-65E3
+65E5..65E9    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-65E5..CJK UNIFIED IDEOGRAPH-65E9
+65EB..65F8    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-65EB..CJK UNIFIED IDEOGRAPH-65F8
+65FA..65FD    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-65FA..CJK UNIFIED IDEOGRAPH-65FD
+65FF..6616    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-65FF..CJK UNIFIED IDEOGRAPH-6616
+6618..662B    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-6618..CJK UNIFIED IDEOGRAPH-662B
+662D..6636    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-662D..CJK UNIFIED IDEOGRAPH-6636
+6639..6647    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-6639..CJK UNIFIED IDEOGRAPH-6647
+6649..664C    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-6649..CJK UNIFIED IDEOGRAPH-664C
+664E..665F    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-664E..CJK UNIFIED IDEOGRAPH-665F
+6661..6662    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-6661..CJK UNIFIED IDEOGRAPH-6662
+6664..6691    ; Recommended                    # 1.1   [46] CJK UNIFIED IDEOGRAPH-6664..CJK UNIFIED IDEOGRAPH-6691
+6693..669B    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-6693..CJK UNIFIED IDEOGRAPH-669B
+669D          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-669D
+669F..66AB    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-669F..CJK UNIFIED IDEOGRAPH-66AB
+66AE..66CF    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-66AE..CJK UNIFIED IDEOGRAPH-66CF
+66D1..66D2    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-66D1..CJK UNIFIED IDEOGRAPH-66D2
+66D4..66D6    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-66D4..CJK UNIFIED IDEOGRAPH-66D6
+66D8..66DE    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-66D8..CJK UNIFIED IDEOGRAPH-66DE
+66E0..66EE    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-66E0..CJK UNIFIED IDEOGRAPH-66EE
+66F0..6701    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-66F0..CJK UNIFIED IDEOGRAPH-6701
+6703..6706    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-6703..CJK UNIFIED IDEOGRAPH-6706
+6708..6718    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-6708..CJK UNIFIED IDEOGRAPH-6718
+671A..6723    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-671A..CJK UNIFIED IDEOGRAPH-6723
+6725..6728    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-6725..CJK UNIFIED IDEOGRAPH-6728
+672A..6766    ; Recommended                    # 1.1   [61] CJK UNIFIED IDEOGRAPH-672A..CJK UNIFIED IDEOGRAPH-6766
+6768..6787    ; Recommended                    # 1.1   [32] CJK UNIFIED IDEOGRAPH-6768..CJK UNIFIED IDEOGRAPH-6787
+6789..6795    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-6789..CJK UNIFIED IDEOGRAPH-6795
+6797..67BC    ; Recommended                    # 1.1   [38] CJK UNIFIED IDEOGRAPH-6797..CJK UNIFIED IDEOGRAPH-67BC
+67BE          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-67BE
+67C0..67D4    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-67C0..CJK UNIFIED IDEOGRAPH-67D4
+67D6          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-67D6
+67D8..67F8    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-67D8..CJK UNIFIED IDEOGRAPH-67F8
+67FA..6800    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-67FA..CJK UNIFIED IDEOGRAPH-6800
+6802..6814    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-6802..CJK UNIFIED IDEOGRAPH-6814
+6816..6826    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-6816..CJK UNIFIED IDEOGRAPH-6826
+6828..682F    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-6828..CJK UNIFIED IDEOGRAPH-682F
+6831..6857    ; Recommended                    # 1.1   [39] CJK UNIFIED IDEOGRAPH-6831..CJK UNIFIED IDEOGRAPH-6857
+6859          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6859
+685B..685D    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-685B..CJK UNIFIED IDEOGRAPH-685D
+685F..6879    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-685F..CJK UNIFIED IDEOGRAPH-6879
+687B..6894    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-687B..CJK UNIFIED IDEOGRAPH-6894
+6896..6898    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-6896..CJK UNIFIED IDEOGRAPH-6898
+689A..68A4    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-689A..CJK UNIFIED IDEOGRAPH-68A4
+68A6..68B7    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-68A6..CJK UNIFIED IDEOGRAPH-68B7
+68B9..68C2    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-68B9..CJK UNIFIED IDEOGRAPH-68C2
+68C4..68D8    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-68C4..CJK UNIFIED IDEOGRAPH-68D8
+68DA..68E1    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-68DA..CJK UNIFIED IDEOGRAPH-68E1
+68E3..68E4    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-68E3..CJK UNIFIED IDEOGRAPH-68E4
+68E6..6908    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-68E6..CJK UNIFIED IDEOGRAPH-6908
+690A..693D    ; Recommended                    # 1.1   [52] CJK UNIFIED IDEOGRAPH-690A..CJK UNIFIED IDEOGRAPH-693D
+693F..694C    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-693F..CJK UNIFIED IDEOGRAPH-694C
+694E..699E    ; Recommended                    # 1.1   [81] CJK UNIFIED IDEOGRAPH-694E..CJK UNIFIED IDEOGRAPH-699E
+69A0..69A1    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-69A0..CJK UNIFIED IDEOGRAPH-69A1
+69A3..69BF    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-69A3..CJK UNIFIED IDEOGRAPH-69BF
+69C1..69D0    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-69C1..CJK UNIFIED IDEOGRAPH-69D0
+69D3..69D4    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-69D3..CJK UNIFIED IDEOGRAPH-69D4
+69D8..6A02    ; Recommended                    # 1.1   [43] CJK UNIFIED IDEOGRAPH-69D8..CJK UNIFIED IDEOGRAPH-6A02
+6A04..6A1B    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-6A04..CJK UNIFIED IDEOGRAPH-6A1B
+6A1D..6A23    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-6A1D..CJK UNIFIED IDEOGRAPH-6A23
+6A25..6A36    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-6A25..CJK UNIFIED IDEOGRAPH-6A36
+6A38..6A49    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-6A38..CJK UNIFIED IDEOGRAPH-6A49
+6A4B..6A5B    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-6A4B..CJK UNIFIED IDEOGRAPH-6A5B
+6A5D..6A6D    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-6A5D..CJK UNIFIED IDEOGRAPH-6A6D
+6A6F          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6A6F
+6A71..6A85    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-6A71..CJK UNIFIED IDEOGRAPH-6A85
+6A87..6A89    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-6A87..CJK UNIFIED IDEOGRAPH-6A89
+6A8B..6A8E    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-6A8B..CJK UNIFIED IDEOGRAPH-6A8E
+6A90..6A98    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-6A90..CJK UNIFIED IDEOGRAPH-6A98
+6A9A..6A9C    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-6A9A..CJK UNIFIED IDEOGRAPH-6A9C
+6A9E..6AB0    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-6A9E..CJK UNIFIED IDEOGRAPH-6AB0
+6AB2..6ABD    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-6AB2..CJK UNIFIED IDEOGRAPH-6ABD
+6ABF          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6ABF
+6AC1..6AC3    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-6AC1..CJK UNIFIED IDEOGRAPH-6AC3
+6AC5..6AC8    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-6AC5..CJK UNIFIED IDEOGRAPH-6AC8
+6ACA..6AD7    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-6ACA..CJK UNIFIED IDEOGRAPH-6AD7
+6AD9..6AE8    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-6AD9..CJK UNIFIED IDEOGRAPH-6AE8
+6AEA..6B0D    ; Recommended                    # 1.1   [36] CJK UNIFIED IDEOGRAPH-6AEA..CJK UNIFIED IDEOGRAPH-6B0D
+6B0F..6B1A    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-6B0F..CJK UNIFIED IDEOGRAPH-6B1A
+6B1C..6B2D    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-6B1C..CJK UNIFIED IDEOGRAPH-6B2D
+6B2F..6B34    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-6B2F..CJK UNIFIED IDEOGRAPH-6B34
+6B36..6B3F    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-6B36..CJK UNIFIED IDEOGRAPH-6B3F
+6B41..6B56    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-6B41..CJK UNIFIED IDEOGRAPH-6B56
+6B59..6B5C    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-6B59..CJK UNIFIED IDEOGRAPH-6B5C
+6B5E..6B67    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-6B5E..CJK UNIFIED IDEOGRAPH-6B67
+6B69..6B6B    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-6B69..CJK UNIFIED IDEOGRAPH-6B6B
+6B6D          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6B6D
+6B6F..6B70    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-6B6F..CJK UNIFIED IDEOGRAPH-6B70
+6B72..6B74    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-6B72..CJK UNIFIED IDEOGRAPH-6B74
+6B76..6B7C    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-6B76..CJK UNIFIED IDEOGRAPH-6B7C
+6B7E..6BB7    ; Recommended                    # 1.1   [58] CJK UNIFIED IDEOGRAPH-6B7E..CJK UNIFIED IDEOGRAPH-6BB7
+6BB9..6BE8    ; Recommended                    # 1.1   [48] CJK UNIFIED IDEOGRAPH-6BB9..CJK UNIFIED IDEOGRAPH-6BE8
+6BEA..6BF0    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-6BEA..CJK UNIFIED IDEOGRAPH-6BF0
+6BF2..6BF3    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-6BF2..CJK UNIFIED IDEOGRAPH-6BF3
+6BF5..6BF9    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-6BF5..CJK UNIFIED IDEOGRAPH-6BF9
+6BFB..6C09    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-6BFB..CJK UNIFIED IDEOGRAPH-6C09
+6C0B..6C1B    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-6C0B..CJK UNIFIED IDEOGRAPH-6C1B
+6C1D..6C2C    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-6C1D..CJK UNIFIED IDEOGRAPH-6C2C
+6C2E..6C3B    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-6C2E..CJK UNIFIED IDEOGRAPH-6C3B
+6C3D..6C44    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-6C3D..CJK UNIFIED IDEOGRAPH-6C44
+6C46..6C6B    ; Recommended                    # 1.1   [38] CJK UNIFIED IDEOGRAPH-6C46..CJK UNIFIED IDEOGRAPH-6C6B
+6C6D          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6C6D
+6C6F..6C9F    ; Recommended                    # 1.1   [49] CJK UNIFIED IDEOGRAPH-6C6F..CJK UNIFIED IDEOGRAPH-6C9F
+6CA1..6CD7    ; Recommended                    # 1.1   [55] CJK UNIFIED IDEOGRAPH-6CA1..CJK UNIFIED IDEOGRAPH-6CD7
+6CD9..6CF3    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-6CD9..CJK UNIFIED IDEOGRAPH-6CF3
+6CF5..6D01    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-6CF5..CJK UNIFIED IDEOGRAPH-6D01
+6D03..6D1B    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-6D03..CJK UNIFIED IDEOGRAPH-6D1B
+6D1D..6D23    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-6D1D..CJK UNIFIED IDEOGRAPH-6D23
+6D25..6D70    ; Recommended                    # 1.1   [76] CJK UNIFIED IDEOGRAPH-6D25..CJK UNIFIED IDEOGRAPH-6D70
+6D72..6D80    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-6D72..CJK UNIFIED IDEOGRAPH-6D80
+6D82..6D95    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-6D82..CJK UNIFIED IDEOGRAPH-6D95
+6D97..6DAF    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-6D97..CJK UNIFIED IDEOGRAPH-6DAF
+6DB2..6DB5    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-6DB2..CJK UNIFIED IDEOGRAPH-6DB5
+6DB7..6DFD    ; Recommended                    # 1.1   [71] CJK UNIFIED IDEOGRAPH-6DB7..CJK UNIFIED IDEOGRAPH-6DFD
+6E00          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6E00
+6E03..6E05    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-6E03..CJK UNIFIED IDEOGRAPH-6E05
+6E07..6E11    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-6E07..CJK UNIFIED IDEOGRAPH-6E11
+6E13..6E17    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-6E13..CJK UNIFIED IDEOGRAPH-6E17
+6E19..6E29    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-6E19..CJK UNIFIED IDEOGRAPH-6E29
+6E2B..6E4B    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-6E2B..CJK UNIFIED IDEOGRAPH-6E4B
+6E4D..6E6B    ; Recommended                    # 1.1   [31] CJK UNIFIED IDEOGRAPH-6E4D..CJK UNIFIED IDEOGRAPH-6E6B
+6E6D..6E7A    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-6E6D..CJK UNIFIED IDEOGRAPH-6E7A
+6E7E..6E8A    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-6E7E..CJK UNIFIED IDEOGRAPH-6E8A
+6E8C..6E94    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-6E8C..CJK UNIFIED IDEOGRAPH-6E94
+6E96..6EDA    ; Recommended                    # 1.1   [69] CJK UNIFIED IDEOGRAPH-6E96..CJK UNIFIED IDEOGRAPH-6EDA
+6EDC..6EE2    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-6EDC..CJK UNIFIED IDEOGRAPH-6EE2
+6EE4..6F03    ; Recommended                    # 1.1   [32] CJK UNIFIED IDEOGRAPH-6EE4..CJK UNIFIED IDEOGRAPH-6F03
+6F05..6F0A    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-6F05..CJK UNIFIED IDEOGRAPH-6F0A
+6F0C..6F41    ; Recommended                    # 1.1   [54] CJK UNIFIED IDEOGRAPH-6F0C..CJK UNIFIED IDEOGRAPH-6F41
+6F43..6F47    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-6F43..CJK UNIFIED IDEOGRAPH-6F47
+6F49          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6F49
+6F4B..6F78    ; Recommended                    # 1.1   [46] CJK UNIFIED IDEOGRAPH-6F4B..CJK UNIFIED IDEOGRAPH-6F78
+6F7A..6F97    ; Recommended                    # 1.1   [30] CJK UNIFIED IDEOGRAPH-6F7A..CJK UNIFIED IDEOGRAPH-6F97
+6F99          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-6F99
+6F9B..6F9E    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-6F9B..CJK UNIFIED IDEOGRAPH-6F9E
+6FA0..6FB6    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-6FA0..CJK UNIFIED IDEOGRAPH-6FB6
+6FB8..6FC4    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-6FB8..CJK UNIFIED IDEOGRAPH-6FC4
+6FC6..6FCF    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-6FC6..CJK UNIFIED IDEOGRAPH-6FCF
+6FD1..6FD2    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-6FD1..CJK UNIFIED IDEOGRAPH-6FD2
+6FD4..6FF4    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-6FD4..CJK UNIFIED IDEOGRAPH-6FF4
+6FF6..6FFC    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-6FF6..CJK UNIFIED IDEOGRAPH-6FFC
+6FFE..700F    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-6FFE..CJK UNIFIED IDEOGRAPH-700F
+7011..7012    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-7011..CJK UNIFIED IDEOGRAPH-7012
+7014..7046    ; Recommended                    # 1.1   [51] CJK UNIFIED IDEOGRAPH-7014..CJK UNIFIED IDEOGRAPH-7046
+7048..704A    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-7048..CJK UNIFIED IDEOGRAPH-704A
+704C..704D    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-704C..CJK UNIFIED IDEOGRAPH-704D
+704F..7071    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-704F..CJK UNIFIED IDEOGRAPH-7071
+7074..707A    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-7074..CJK UNIFIED IDEOGRAPH-707A
+707C..7080    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-707C..CJK UNIFIED IDEOGRAPH-7080
+7082..708C    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-7082..CJK UNIFIED IDEOGRAPH-708C
+708E..7096    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-708E..CJK UNIFIED IDEOGRAPH-7096
+7098..709A    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-7098..CJK UNIFIED IDEOGRAPH-709A
+709C..70A9    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-709C..CJK UNIFIED IDEOGRAPH-70A9
+70AB..70B1    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-70AB..CJK UNIFIED IDEOGRAPH-70B1
+70B3..70B5    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-70B3..CJK UNIFIED IDEOGRAPH-70B5
+70B7..70D4    ; Recommended                    # 1.1   [30] CJK UNIFIED IDEOGRAPH-70B7..CJK UNIFIED IDEOGRAPH-70D4
+70D6..70FD    ; Recommended                    # 1.1   [40] CJK UNIFIED IDEOGRAPH-70D6..CJK UNIFIED IDEOGRAPH-70FD
+70FF..7107    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-70FF..CJK UNIFIED IDEOGRAPH-7107
+7109..7123    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-7109..CJK UNIFIED IDEOGRAPH-7123
+7125..7132    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-7125..CJK UNIFIED IDEOGRAPH-7132
+7135..7156    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-7135..CJK UNIFIED IDEOGRAPH-7156
+7158..716A    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-7158..CJK UNIFIED IDEOGRAPH-716A
+716C          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-716C
+716E..718C    ; Recommended                    # 1.1   [31] CJK UNIFIED IDEOGRAPH-716E..CJK UNIFIED IDEOGRAPH-718C
+718E..7195    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-718E..CJK UNIFIED IDEOGRAPH-7195
+7197..71A5    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-7197..CJK UNIFIED IDEOGRAPH-71A5
+71A7..71AA    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-71A7..CJK UNIFIED IDEOGRAPH-71AA
+71AC..71B5    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-71AC..CJK UNIFIED IDEOGRAPH-71B5
+71B7..71CB    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-71B7..CJK UNIFIED IDEOGRAPH-71CB
+71CD..71D2    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-71CD..CJK UNIFIED IDEOGRAPH-71D2
+71D4..71F2    ; Recommended                    # 1.1   [31] CJK UNIFIED IDEOGRAPH-71D4..CJK UNIFIED IDEOGRAPH-71F2
+71F4..71F9    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-71F4..CJK UNIFIED IDEOGRAPH-71F9
+71FB..720A    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-71FB..CJK UNIFIED IDEOGRAPH-720A
+720C..7210    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-720C..CJK UNIFIED IDEOGRAPH-7210
+7212..7214    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-7212..CJK UNIFIED IDEOGRAPH-7214
+7216          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7216
+7218..721F    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-7218..CJK UNIFIED IDEOGRAPH-721F
+7221..7223    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-7221..CJK UNIFIED IDEOGRAPH-7223
+7226..722E    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-7226..CJK UNIFIED IDEOGRAPH-722E
+7230..7233    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-7230..CJK UNIFIED IDEOGRAPH-7233
+7235..7244    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-7235..CJK UNIFIED IDEOGRAPH-7244
+7246..724D    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-7246..CJK UNIFIED IDEOGRAPH-724D
+724F          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-724F
+7251..7254    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-7251..CJK UNIFIED IDEOGRAPH-7254
+7256..72AA    ; Recommended                    # 1.1   [85] CJK UNIFIED IDEOGRAPH-7256..CJK UNIFIED IDEOGRAPH-72AA
+72AC..72BD    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-72AC..CJK UNIFIED IDEOGRAPH-72BD
+72BF..7301    ; Recommended                    # 1.1   [67] CJK UNIFIED IDEOGRAPH-72BF..CJK UNIFIED IDEOGRAPH-7301
+7303..730F    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-7303..CJK UNIFIED IDEOGRAPH-730F
+7311..7327    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-7311..CJK UNIFIED IDEOGRAPH-7327
+7329..7352    ; Recommended                    # 1.1   [42] CJK UNIFIED IDEOGRAPH-7329..CJK UNIFIED IDEOGRAPH-7352
+7354..739B    ; Recommended                    # 1.1   [72] CJK UNIFIED IDEOGRAPH-7354..CJK UNIFIED IDEOGRAPH-739B
+739D..73C0    ; Recommended                    # 1.1   [36] CJK UNIFIED IDEOGRAPH-739D..CJK UNIFIED IDEOGRAPH-73C0
+73C2..73F2    ; Recommended                    # 1.1   [49] CJK UNIFIED IDEOGRAPH-73C2..CJK UNIFIED IDEOGRAPH-73F2
+73F4..73FA    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-73F4..CJK UNIFIED IDEOGRAPH-73FA
+73FC..7417    ; Recommended                    # 1.1   [28] CJK UNIFIED IDEOGRAPH-73FC..CJK UNIFIED IDEOGRAPH-7417
+7419..7438    ; Recommended                    # 1.1   [32] CJK UNIFIED IDEOGRAPH-7419..CJK UNIFIED IDEOGRAPH-7438
+743A..743D    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-743A..CJK UNIFIED IDEOGRAPH-743D
+743F..7446    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-743F..CJK UNIFIED IDEOGRAPH-7446
+7448          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7448
+744A..7457    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-744A..CJK UNIFIED IDEOGRAPH-7457
+7459..747A    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-7459..CJK UNIFIED IDEOGRAPH-747A
+747C..7483    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-747C..CJK UNIFIED IDEOGRAPH-7483
+7485..7495    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-7485..CJK UNIFIED IDEOGRAPH-7495
+7497..749C    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-7497..CJK UNIFIED IDEOGRAPH-749C
+749E..74C6    ; Recommended                    # 1.1   [41] CJK UNIFIED IDEOGRAPH-749E..CJK UNIFIED IDEOGRAPH-74C6
+74C8          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-74C8
+74CA..74CB    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-74CA..CJK UNIFIED IDEOGRAPH-74CB
+74CD..74EA    ; Recommended                    # 1.1   [30] CJK UNIFIED IDEOGRAPH-74CD..CJK UNIFIED IDEOGRAPH-74EA
+74EC..751F    ; Recommended                    # 1.1   [52] CJK UNIFIED IDEOGRAPH-74EC..CJK UNIFIED IDEOGRAPH-751F
+7521..7540    ; Recommended                    # 1.1   [32] CJK UNIFIED IDEOGRAPH-7521..CJK UNIFIED IDEOGRAPH-7540
+7542..7551    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-7542..CJK UNIFIED IDEOGRAPH-7551
+7553..7554    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-7553..CJK UNIFIED IDEOGRAPH-7554
+7556..755D    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-7556..CJK UNIFIED IDEOGRAPH-755D
+755F..7560    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-755F..CJK UNIFIED IDEOGRAPH-7560
+7562..7570    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-7562..CJK UNIFIED IDEOGRAPH-7570
+7572..757A    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-7572..CJK UNIFIED IDEOGRAPH-757A
+757C..7584    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-757C..CJK UNIFIED IDEOGRAPH-7584
+7586..75A8    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-7586..CJK UNIFIED IDEOGRAPH-75A8
+75AA..75B6    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-75AA..CJK UNIFIED IDEOGRAPH-75B6
+75B8..75DB    ; Recommended                    # 1.1   [36] CJK UNIFIED IDEOGRAPH-75B8..CJK UNIFIED IDEOGRAPH-75DB
+75DD..75ED    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-75DD..CJK UNIFIED IDEOGRAPH-75ED
+75EF..762B    ; Recommended                    # 1.1   [61] CJK UNIFIED IDEOGRAPH-75EF..CJK UNIFIED IDEOGRAPH-762B
+762D..7643    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-762D..CJK UNIFIED IDEOGRAPH-7643
+7646..7650    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-7646..CJK UNIFIED IDEOGRAPH-7650
+7652..7654    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-7652..CJK UNIFIED IDEOGRAPH-7654
+7656..7672    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-7656..CJK UNIFIED IDEOGRAPH-7672
+7674..768C    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-7674..CJK UNIFIED IDEOGRAPH-768C
+768E..76A0    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-768E..CJK UNIFIED IDEOGRAPH-76A0
+76A3..76A4    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-76A3..CJK UNIFIED IDEOGRAPH-76A4
+76A6..76A7    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-76A6..CJK UNIFIED IDEOGRAPH-76A7
+76A9..76B2    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-76A9..CJK UNIFIED IDEOGRAPH-76B2
+76B4..76B5    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-76B4..CJK UNIFIED IDEOGRAPH-76B5
+76B7..76C0    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-76B7..CJK UNIFIED IDEOGRAPH-76C0
+76C2..76CA    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-76C2..CJK UNIFIED IDEOGRAPH-76CA
+76CC..76D8    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-76CC..CJK UNIFIED IDEOGRAPH-76D8
+76DA..76EA    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-76DA..CJK UNIFIED IDEOGRAPH-76EA
+76EC..76FF    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-76EC..CJK UNIFIED IDEOGRAPH-76FF
+7701          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7701
+7703..770D    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-7703..CJK UNIFIED IDEOGRAPH-770D
+770F..7720    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-770F..CJK UNIFIED IDEOGRAPH-7720
+7722..772A    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-7722..CJK UNIFIED IDEOGRAPH-772A
+772C..773E    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-772C..CJK UNIFIED IDEOGRAPH-773E
+7740..7741    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-7740..CJK UNIFIED IDEOGRAPH-7741
+7743..7763    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-7743..CJK UNIFIED IDEOGRAPH-7763
+7765..7795    ; Recommended                    # 1.1   [49] CJK UNIFIED IDEOGRAPH-7765..CJK UNIFIED IDEOGRAPH-7795
+7797..77A3    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-7797..CJK UNIFIED IDEOGRAPH-77A3
+77A5..77BD    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-77A5..CJK UNIFIED IDEOGRAPH-77BD
+77BF..77C0    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-77BF..CJK UNIFIED IDEOGRAPH-77C0
+77C2..77D1    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-77C2..CJK UNIFIED IDEOGRAPH-77D1
+77D3..77DC    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-77D3..CJK UNIFIED IDEOGRAPH-77DC
+77DE..77E3    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-77DE..CJK UNIFIED IDEOGRAPH-77E3
+77E5          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-77E5
+77E7..77F3    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-77E7..CJK UNIFIED IDEOGRAPH-77F3
+77F6..7823    ; Recommended                    # 1.1   [46] CJK UNIFIED IDEOGRAPH-77F6..CJK UNIFIED IDEOGRAPH-7823
+7825..7835    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-7825..CJK UNIFIED IDEOGRAPH-7835
+7837..7841    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-7837..CJK UNIFIED IDEOGRAPH-7841
+7843..7845    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-7843..CJK UNIFIED IDEOGRAPH-7845
+7847..784A    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-7847..CJK UNIFIED IDEOGRAPH-784A
+784C..7875    ; Recommended                    # 1.1   [42] CJK UNIFIED IDEOGRAPH-784C..CJK UNIFIED IDEOGRAPH-7875
+7877..7887    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-7877..CJK UNIFIED IDEOGRAPH-7887
+7889..78C1    ; Recommended                    # 1.1   [57] CJK UNIFIED IDEOGRAPH-7889..CJK UNIFIED IDEOGRAPH-78C1
+78C3..78C6    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-78C3..CJK UNIFIED IDEOGRAPH-78C6
+78C8..78D1    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-78C8..CJK UNIFIED IDEOGRAPH-78D1
+78D3..78EF    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-78D3..CJK UNIFIED IDEOGRAPH-78EF
+78F1..78F7    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-78F1..CJK UNIFIED IDEOGRAPH-78F7
+78F9..78FF    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-78F9..CJK UNIFIED IDEOGRAPH-78FF
+7901..7907    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-7901..CJK UNIFIED IDEOGRAPH-7907
+7909..790C    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-7909..CJK UNIFIED IDEOGRAPH-790C
+790E..7914    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-790E..CJK UNIFIED IDEOGRAPH-7914
+7916..791E    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-7916..CJK UNIFIED IDEOGRAPH-791E
+7921..7931    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-7921..CJK UNIFIED IDEOGRAPH-7931
+7933..7935    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-7933..CJK UNIFIED IDEOGRAPH-7935
+7937..7958    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-7937..CJK UNIFIED IDEOGRAPH-7958
+795A..796B    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-795A..CJK UNIFIED IDEOGRAPH-796B
+796D          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-796D
+796F..7974    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-796F..CJK UNIFIED IDEOGRAPH-7974
+7977..7985    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-7977..CJK UNIFIED IDEOGRAPH-7985
+7988..799D    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-7988..CJK UNIFIED IDEOGRAPH-799D
+799F..79A8    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-799F..CJK UNIFIED IDEOGRAPH-79A8
+79AA..79BB    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-79AA..CJK UNIFIED IDEOGRAPH-79BB
+79BD..79C3    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-79BD..CJK UNIFIED IDEOGRAPH-79C3
+79C5..79C6    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-79C5..CJK UNIFIED IDEOGRAPH-79C6
+79C8..79CB    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-79C8..CJK UNIFIED IDEOGRAPH-79CB
+79CD..79D3    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-79CD..CJK UNIFIED IDEOGRAPH-79D3
+79D5..79D6    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-79D5..CJK UNIFIED IDEOGRAPH-79D6
+79D8..7A00    ; Recommended                    # 1.1   [41] CJK UNIFIED IDEOGRAPH-79D8..CJK UNIFIED IDEOGRAPH-7A00
+7A02..7A06    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-7A02..CJK UNIFIED IDEOGRAPH-7A06
+7A08          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7A08
+7A0A..7A2B    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-7A0A..CJK UNIFIED IDEOGRAPH-7A2B
+7A2D..7A37    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-7A2D..CJK UNIFIED IDEOGRAPH-7A37
+7A39          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7A39
+7A3B..7A63    ; Recommended                    # 1.1   [41] CJK UNIFIED IDEOGRAPH-7A3B..CJK UNIFIED IDEOGRAPH-7A63
+7A65..7A69    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-7A65..CJK UNIFIED IDEOGRAPH-7A69
+7A6B..7A6E    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-7A6B..CJK UNIFIED IDEOGRAPH-7A6E
+7A70..7A81    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-7A70..CJK UNIFIED IDEOGRAPH-7A81
+7A83..7A99    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-7A83..CJK UNIFIED IDEOGRAPH-7A99
+7A9C..7AB8    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-7A9C..CJK UNIFIED IDEOGRAPH-7AB8
+7ABA          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7ABA
+7ABE..7AC1    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-7ABE..CJK UNIFIED IDEOGRAPH-7AC1
+7AC3..7AC5    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-7AC3..CJK UNIFIED IDEOGRAPH-7AC5
+7AC7..7AE8    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-7AC7..CJK UNIFIED IDEOGRAPH-7AE8
+7AEA..7AF4    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-7AEA..CJK UNIFIED IDEOGRAPH-7AF4
+7AF6..7AFB    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-7AF6..CJK UNIFIED IDEOGRAPH-7AFB
+7AFD..7B06    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-7AFD..CJK UNIFIED IDEOGRAPH-7B06
+7B08..7B1E    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-7B08..CJK UNIFIED IDEOGRAPH-7B1E
+7B20..7B26    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-7B20..CJK UNIFIED IDEOGRAPH-7B26
+7B28          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7B28
+7B2A..7B41    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-7B2A..CJK UNIFIED IDEOGRAPH-7B41
+7B43..7B52    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-7B43..CJK UNIFIED IDEOGRAPH-7B52
+7B54..7BA2    ; Recommended                    # 1.1   [79] CJK UNIFIED IDEOGRAPH-7B54..CJK UNIFIED IDEOGRAPH-7BA2
+7BA4          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7BA4
+7BA6..7BAF    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-7BA6..CJK UNIFIED IDEOGRAPH-7BAF
+7BB1          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7BB1
+7BB3..7BF9    ; Recommended                    # 1.1   [71] CJK UNIFIED IDEOGRAPH-7BB3..CJK UNIFIED IDEOGRAPH-7BF9
+7BFB..7C1A    ; Recommended                    # 1.1   [32] CJK UNIFIED IDEOGRAPH-7BFB..CJK UNIFIED IDEOGRAPH-7C1A
+7C1C..7C2D    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-7C1C..CJK UNIFIED IDEOGRAPH-7C2D
+7C30..7C51    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-7C30..CJK UNIFIED IDEOGRAPH-7C51
+7C53..7C54    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-7C53..CJK UNIFIED IDEOGRAPH-7C54
+7C56..7C5C    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-7C56..CJK UNIFIED IDEOGRAPH-7C5C
+7C5E..7C75    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-7C5E..CJK UNIFIED IDEOGRAPH-7C75
+7C77..7C86    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-7C77..CJK UNIFIED IDEOGRAPH-7C86
+7C88..7C92    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-7C88..CJK UNIFIED IDEOGRAPH-7C92
+7C94..7C99    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-7C94..CJK UNIFIED IDEOGRAPH-7C99
+7C9B..7CAB    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-7C9B..CJK UNIFIED IDEOGRAPH-7CAB
+7CAD..7CD2    ; Recommended                    # 1.1   [38] CJK UNIFIED IDEOGRAPH-7CAD..CJK UNIFIED IDEOGRAPH-7CD2
+7CD4..7CD9    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-7CD4..CJK UNIFIED IDEOGRAPH-7CD9
+7CDC..7CE0    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-7CDC..CJK UNIFIED IDEOGRAPH-7CE0
+7CE2          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7CE2
+7CE4          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7CE4
+7CE7..7CFB    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-7CE7..CJK UNIFIED IDEOGRAPH-7CFB
+7CFD..7CFE    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-7CFD..CJK UNIFIED IDEOGRAPH-7CFE
+7D00..7D22    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-7D00..CJK UNIFIED IDEOGRAPH-7D22
+7D24..7D29    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-7D24..CJK UNIFIED IDEOGRAPH-7D29
+7D2B..7D2C    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-7D2B..CJK UNIFIED IDEOGRAPH-7D2C
+7D2E..7D47    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-7D2E..CJK UNIFIED IDEOGRAPH-7D47
+7D49..7D4C    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-7D49..CJK UNIFIED IDEOGRAPH-7D4C
+7D4E..7D59    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-7D4E..CJK UNIFIED IDEOGRAPH-7D59
+7D5B..7D63    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-7D5B..CJK UNIFIED IDEOGRAPH-7D63
+7D65..7D77    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-7D65..CJK UNIFIED IDEOGRAPH-7D77
+7D79..7D81    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-7D79..CJK UNIFIED IDEOGRAPH-7D81
+7D83..7D94    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-7D83..CJK UNIFIED IDEOGRAPH-7D94
+7D96..7D97    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-7D96..CJK UNIFIED IDEOGRAPH-7D97
+7D99..7DA3    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-7D99..CJK UNIFIED IDEOGRAPH-7DA3
+7DA5..7DA7    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-7DA5..CJK UNIFIED IDEOGRAPH-7DA7
+7DA9..7DCC    ; Recommended                    # 1.1   [36] CJK UNIFIED IDEOGRAPH-7DA9..CJK UNIFIED IDEOGRAPH-7DCC
+7DCE..7DD2    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-7DCE..CJK UNIFIED IDEOGRAPH-7DD2
+7DD4..7DE4    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-7DD4..CJK UNIFIED IDEOGRAPH-7DE4
+7DE6..7DEA    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-7DE6..CJK UNIFIED IDEOGRAPH-7DEA
+7DEC..7DFC    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-7DEC..CJK UNIFIED IDEOGRAPH-7DFC
+7E00..7E17    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-7E00..CJK UNIFIED IDEOGRAPH-7E17
+7E19..7E5A    ; Recommended                    # 1.1   [66] CJK UNIFIED IDEOGRAPH-7E19..CJK UNIFIED IDEOGRAPH-7E5A
+7E5C..7E63    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-7E5C..CJK UNIFIED IDEOGRAPH-7E63
+7E65..7E9C    ; Recommended                    # 1.1   [56] CJK UNIFIED IDEOGRAPH-7E65..CJK UNIFIED IDEOGRAPH-7E9C
+7E9E..7F3A    ; Recommended                    # 1.1  [157] CJK UNIFIED IDEOGRAPH-7E9E..CJK UNIFIED IDEOGRAPH-7F3A
+7F3D..7F40    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-7F3D..CJK UNIFIED IDEOGRAPH-7F40
+7F42..7F45    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-7F42..CJK UNIFIED IDEOGRAPH-7F45
+7F47..7F58    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-7F47..CJK UNIFIED IDEOGRAPH-7F58
+7F5A..7F83    ; Recommended                    # 1.1   [42] CJK UNIFIED IDEOGRAPH-7F5A..CJK UNIFIED IDEOGRAPH-7F83
+7F85..7F8F    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-7F85..CJK UNIFIED IDEOGRAPH-7F8F
+7F91..7F96    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-7F91..CJK UNIFIED IDEOGRAPH-7F96
+7F98          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-7F98
+7F9A..7FB3    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-7F9A..CJK UNIFIED IDEOGRAPH-7FB3
+7FB5..7FD5    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-7FB5..CJK UNIFIED IDEOGRAPH-7FD5
+7FD7..7FDC    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-7FD7..CJK UNIFIED IDEOGRAPH-7FDC
+7FDE..7FE3    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-7FDE..CJK UNIFIED IDEOGRAPH-7FE3
+7FE5..8009    ; Recommended                    # 1.1   [37] CJK UNIFIED IDEOGRAPH-7FE5..CJK UNIFIED IDEOGRAPH-8009
+800B..802E    ; Recommended                    # 1.1   [36] CJK UNIFIED IDEOGRAPH-800B..CJK UNIFIED IDEOGRAPH-802E
+8030..803B    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-8030..CJK UNIFIED IDEOGRAPH-803B
+803D..803F    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-803D..CJK UNIFIED IDEOGRAPH-803F
+8041..8065    ; Recommended                    # 1.1   [37] CJK UNIFIED IDEOGRAPH-8041..CJK UNIFIED IDEOGRAPH-8065
+8067..8087    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-8067..CJK UNIFIED IDEOGRAPH-8087
+8089..808D    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-8089..CJK UNIFIED IDEOGRAPH-808D
+808F..8093    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-808F..CJK UNIFIED IDEOGRAPH-8093
+8095..80A5    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-8095..CJK UNIFIED IDEOGRAPH-80A5
+80A9..80B2    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-80A9..CJK UNIFIED IDEOGRAPH-80B2
+80B4..80B8    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-80B4..CJK UNIFIED IDEOGRAPH-80B8
+80BA..80DE    ; Recommended                    # 1.1   [37] CJK UNIFIED IDEOGRAPH-80BA..CJK UNIFIED IDEOGRAPH-80DE
+80E0..8102    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-80E0..CJK UNIFIED IDEOGRAPH-8102
+8105..8133    ; Recommended                    # 1.1   [47] CJK UNIFIED IDEOGRAPH-8105..CJK UNIFIED IDEOGRAPH-8133
+8136..8183    ; Recommended                    # 1.1   [78] CJK UNIFIED IDEOGRAPH-8136..CJK UNIFIED IDEOGRAPH-8183
+8185..818F    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-8185..CJK UNIFIED IDEOGRAPH-818F
+8191..8195    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-8191..CJK UNIFIED IDEOGRAPH-8195
+8197..81CA    ; Recommended                    # 1.1   [52] CJK UNIFIED IDEOGRAPH-8197..CJK UNIFIED IDEOGRAPH-81CA
+81CC..81E3    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-81CC..CJK UNIFIED IDEOGRAPH-81E3
+81E5..81EE    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-81E5..CJK UNIFIED IDEOGRAPH-81EE
+81F1..8212    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-81F1..CJK UNIFIED IDEOGRAPH-8212
+8214..8223    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-8214..CJK UNIFIED IDEOGRAPH-8223
+8225..8240    ; Recommended                    # 1.1   [28] CJK UNIFIED IDEOGRAPH-8225..CJK UNIFIED IDEOGRAPH-8240
+8242..8264    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-8242..CJK UNIFIED IDEOGRAPH-8264
+8266..828B    ; Recommended                    # 1.1   [38] CJK UNIFIED IDEOGRAPH-8266..CJK UNIFIED IDEOGRAPH-828B
+828D..82B1    ; Recommended                    # 1.1   [37] CJK UNIFIED IDEOGRAPH-828D..CJK UNIFIED IDEOGRAPH-82B1
+82B3..82E1    ; Recommended                    # 1.1   [47] CJK UNIFIED IDEOGRAPH-82B3..CJK UNIFIED IDEOGRAPH-82E1
+82E3..82FB    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-82E3..CJK UNIFIED IDEOGRAPH-82FB
+82FD..8309    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-82FD..CJK UNIFIED IDEOGRAPH-8309
+830B..830F    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-830B..CJK UNIFIED IDEOGRAPH-830F
+8311..832F    ; Recommended                    # 1.1   [31] CJK UNIFIED IDEOGRAPH-8311..CJK UNIFIED IDEOGRAPH-832F
+8331..8354    ; Recommended                    # 1.1   [36] CJK UNIFIED IDEOGRAPH-8331..CJK UNIFIED IDEOGRAPH-8354
+8356..83BD    ; Recommended                    # 1.1  [104] CJK UNIFIED IDEOGRAPH-8356..CJK UNIFIED IDEOGRAPH-83BD
+83BF..83E5    ; Recommended                    # 1.1   [39] CJK UNIFIED IDEOGRAPH-83BF..CJK UNIFIED IDEOGRAPH-83E5
+83E7..83EC    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-83E7..CJK UNIFIED IDEOGRAPH-83EC
+83EE..8413    ; Recommended                    # 1.1   [38] CJK UNIFIED IDEOGRAPH-83EE..CJK UNIFIED IDEOGRAPH-8413
+8415          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-8415
+8418..841E    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-8418..CJK UNIFIED IDEOGRAPH-841E
+8420..8457    ; Recommended                    # 1.1   [56] CJK UNIFIED IDEOGRAPH-8420..CJK UNIFIED IDEOGRAPH-8457
+8459..8482    ; Recommended                    # 1.1   [42] CJK UNIFIED IDEOGRAPH-8459..CJK UNIFIED IDEOGRAPH-8482
+8484..8494    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-8484..CJK UNIFIED IDEOGRAPH-8494
+8496..84B6    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-8496..CJK UNIFIED IDEOGRAPH-84B6
+84B8..84C2    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-84B8..CJK UNIFIED IDEOGRAPH-84C2
+84C4..84EC    ; Recommended                    # 1.1   [41] CJK UNIFIED IDEOGRAPH-84C4..CJK UNIFIED IDEOGRAPH-84EC
+84EE..8504    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-84EE..CJK UNIFIED IDEOGRAPH-8504
+8506..850F    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-8506..CJK UNIFIED IDEOGRAPH-850F
+8511..8531    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-8511..CJK UNIFIED IDEOGRAPH-8531
+8534..854B    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-8534..CJK UNIFIED IDEOGRAPH-854B
+854D..854F    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-854D..CJK UNIFIED IDEOGRAPH-854F
+8551..857E    ; Recommended                    # 1.1   [46] CJK UNIFIED IDEOGRAPH-8551..CJK UNIFIED IDEOGRAPH-857E
+8580..8592    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-8580..CJK UNIFIED IDEOGRAPH-8592
+8594..85B1    ; Recommended                    # 1.1   [30] CJK UNIFIED IDEOGRAPH-8594..CJK UNIFIED IDEOGRAPH-85B1
+85B3..85BA    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-85B3..CJK UNIFIED IDEOGRAPH-85BA
+85BC..85CB    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-85BC..CJK UNIFIED IDEOGRAPH-85CB
+85CD..85ED    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-85CD..CJK UNIFIED IDEOGRAPH-85ED
+85EF..85F2    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-85EF..CJK UNIFIED IDEOGRAPH-85F2
+85F4..85FB    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-85F4..CJK UNIFIED IDEOGRAPH-85FB
+85FD..8602    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-85FD..CJK UNIFIED IDEOGRAPH-8602
+8604..860C    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-8604..CJK UNIFIED IDEOGRAPH-860C
+860F          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-860F
+8611..8614    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-8611..CJK UNIFIED IDEOGRAPH-8614
+8616..861C    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-8616..CJK UNIFIED IDEOGRAPH-861C
+861E..8636    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-861E..CJK UNIFIED IDEOGRAPH-8636
+8638..8656    ; Recommended                    # 1.1   [31] CJK UNIFIED IDEOGRAPH-8638..CJK UNIFIED IDEOGRAPH-8656
+8658..8674    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-8658..CJK UNIFIED IDEOGRAPH-8674
+8676..8688    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-8676..CJK UNIFIED IDEOGRAPH-8688
+868A..8691    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-868A..CJK UNIFIED IDEOGRAPH-8691
+8693..869F    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-8693..CJK UNIFIED IDEOGRAPH-869F
+86A1..86A5    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-86A1..CJK UNIFIED IDEOGRAPH-86A5
+86A7..86D4    ; Recommended                    # 1.1   [46] CJK UNIFIED IDEOGRAPH-86A7..CJK UNIFIED IDEOGRAPH-86D4
+86D6..86DF    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-86D6..CJK UNIFIED IDEOGRAPH-86DF
+86E1..86E6    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-86E1..CJK UNIFIED IDEOGRAPH-86E6
+86E8..86FC    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-86E8..CJK UNIFIED IDEOGRAPH-86FC
+86FE..871C    ; Recommended                    # 1.1   [31] CJK UNIFIED IDEOGRAPH-86FE..CJK UNIFIED IDEOGRAPH-871C
+871E..872E    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-871E..CJK UNIFIED IDEOGRAPH-872E
+8730..873C    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-8730..CJK UNIFIED IDEOGRAPH-873C
+873E..8744    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-873E..CJK UNIFIED IDEOGRAPH-8744
+8746..8770    ; Recommended                    # 1.1   [43] CJK UNIFIED IDEOGRAPH-8746..CJK UNIFIED IDEOGRAPH-8770
+8772..878D    ; Recommended                    # 1.1   [28] CJK UNIFIED IDEOGRAPH-8772..CJK UNIFIED IDEOGRAPH-878D
+878F..8798    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-878F..CJK UNIFIED IDEOGRAPH-8798
+879A..87D9    ; Recommended                    # 1.1   [64] CJK UNIFIED IDEOGRAPH-879A..CJK UNIFIED IDEOGRAPH-87D9
+87DB..87EF    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-87DB..CJK UNIFIED IDEOGRAPH-87EF
+87F1..8806    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-87F1..CJK UNIFIED IDEOGRAPH-8806
+8808..8811    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-8808..CJK UNIFIED IDEOGRAPH-8811
+8813..882C    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-8813..CJK UNIFIED IDEOGRAPH-882C
+882E..8839    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-882E..CJK UNIFIED IDEOGRAPH-8839
+883B..8846    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-883B..CJK UNIFIED IDEOGRAPH-8846
+8848..8857    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-8848..CJK UNIFIED IDEOGRAPH-8857
+8859..885B    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-8859..CJK UNIFIED IDEOGRAPH-885B
+885D..885E    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-885D..CJK UNIFIED IDEOGRAPH-885E
+8860..8879    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-8860..CJK UNIFIED IDEOGRAPH-8879
+887B..88E5    ; Recommended                    # 1.1  [107] CJK UNIFIED IDEOGRAPH-887B..CJK UNIFIED IDEOGRAPH-88E5
+88E7..88E8    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-88E7..CJK UNIFIED IDEOGRAPH-88E8
+88EA..88EC    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-88EA..CJK UNIFIED IDEOGRAPH-88EC
+88EE..8902    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-88EE..CJK UNIFIED IDEOGRAPH-8902
+8904..890E    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-8904..CJK UNIFIED IDEOGRAPH-890E
+8910..8923    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-8910..CJK UNIFIED IDEOGRAPH-8923
+8925..8964    ; Recommended                    # 1.1   [64] CJK UNIFIED IDEOGRAPH-8925..CJK UNIFIED IDEOGRAPH-8964
+8966..8974    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-8966..CJK UNIFIED IDEOGRAPH-8974
+8976..897C    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-8976..CJK UNIFIED IDEOGRAPH-897C
+897E..898C    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-897E..CJK UNIFIED IDEOGRAPH-898C
+898E..898F    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-898E..CJK UNIFIED IDEOGRAPH-898F
+8991..8993    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-8991..CJK UNIFIED IDEOGRAPH-8993
+8995..8998    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-8995..CJK UNIFIED IDEOGRAPH-8998
+899A..89AF    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-899A..CJK UNIFIED IDEOGRAPH-89AF
+89B1..89B3    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-89B1..CJK UNIFIED IDEOGRAPH-89B3
+89B5..89BA    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-89B5..CJK UNIFIED IDEOGRAPH-89BA
+89BD..89ED    ; Recommended                    # 1.1   [49] CJK UNIFIED IDEOGRAPH-89BD..CJK UNIFIED IDEOGRAPH-89ED
+89EF..89F4    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-89EF..CJK UNIFIED IDEOGRAPH-89F4
+89F6..89F8    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-89F6..CJK UNIFIED IDEOGRAPH-89F8
+89FA..89FC    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-89FA..CJK UNIFIED IDEOGRAPH-89FC
+89FE..8A04    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-89FE..CJK UNIFIED IDEOGRAPH-8A04
+8A07..8A13    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-8A07..CJK UNIFIED IDEOGRAPH-8A13
+8A15..8A18    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-8A15..CJK UNIFIED IDEOGRAPH-8A18
+8A1A..8A1F    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-8A1A..CJK UNIFIED IDEOGRAPH-8A1F
+8A22..8A2A    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-8A22..CJK UNIFIED IDEOGRAPH-8A2A
+8A2C..8A3C    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-8A2C..CJK UNIFIED IDEOGRAPH-8A3C
+8A3E..8A4A    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-8A3E..CJK UNIFIED IDEOGRAPH-8A4A
+8A4C..8A63    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-8A4C..CJK UNIFIED IDEOGRAPH-8A63
+8A65..8A77    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-8A65..CJK UNIFIED IDEOGRAPH-8A77
+8A79..8A7C    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-8A79..CJK UNIFIED IDEOGRAPH-8A7C
+8A7E..8A87    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-8A7E..CJK UNIFIED IDEOGRAPH-8A87
+8A89..8A9E    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-8A89..CJK UNIFIED IDEOGRAPH-8A9E
+8AA0..8AAE    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-8AA0..CJK UNIFIED IDEOGRAPH-8AAE
+8AB0..8AB6    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-8AB0..CJK UNIFIED IDEOGRAPH-8AB6
+8AB8..8ACF    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-8AB8..CJK UNIFIED IDEOGRAPH-8ACF
+8AD1..8AEB    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-8AD1..CJK UNIFIED IDEOGRAPH-8AEB
+8AED..8B28    ; Recommended                    # 1.1   [60] CJK UNIFIED IDEOGRAPH-8AED..CJK UNIFIED IDEOGRAPH-8B28
+8B2A..8B31    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-8B2A..CJK UNIFIED IDEOGRAPH-8B31
+8B33..8B37    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-8B33..CJK UNIFIED IDEOGRAPH-8B37
+8B39..8B3E    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-8B39..CJK UNIFIED IDEOGRAPH-8B3E
+8B40..8B60    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-8B40..CJK UNIFIED IDEOGRAPH-8B60
+8B63..8B68    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-8B63..CJK UNIFIED IDEOGRAPH-8B68
+8B6A..8B74    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-8B6A..CJK UNIFIED IDEOGRAPH-8B74
+8B76..8B7B    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-8B76..CJK UNIFIED IDEOGRAPH-8B7B
+8B7D..8B80    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-8B7D..CJK UNIFIED IDEOGRAPH-8B80
+8B82..8B86    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-8B82..CJK UNIFIED IDEOGRAPH-8B86
+8B88..8B8C    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-8B88..CJK UNIFIED IDEOGRAPH-8B8C
+8B8E          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-8B8E
+8B90..8B9A    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-8B90..CJK UNIFIED IDEOGRAPH-8B9A
+8B9C..8C37    ; Recommended                    # 1.1  [156] CJK UNIFIED IDEOGRAPH-8B9C..CJK UNIFIED IDEOGRAPH-8C37
+8C39..8C3F    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-8C39..CJK UNIFIED IDEOGRAPH-8C3F
+8C41..8C43    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-8C41..CJK UNIFIED IDEOGRAPH-8C43
+8C45..8C50    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-8C45..CJK UNIFIED IDEOGRAPH-8C50
+8C54..8C57    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-8C54..CJK UNIFIED IDEOGRAPH-8C57
+8C59..8C73    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-8C59..CJK UNIFIED IDEOGRAPH-8C73
+8C75..8C7E    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-8C75..CJK UNIFIED IDEOGRAPH-8C7E
+8C80..8C82    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-8C80..CJK UNIFIED IDEOGRAPH-8C82
+8C84..8C86    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-8C84..CJK UNIFIED IDEOGRAPH-8C86
+8C88..8C8A    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-8C88..CJK UNIFIED IDEOGRAPH-8C8A
+8C8C..8C9A    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-8C8C..CJK UNIFIED IDEOGRAPH-8C9A
+8C9C..8CA5    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-8C9C..CJK UNIFIED IDEOGRAPH-8CA5
+8CA7..8CCA    ; Recommended                    # 1.1   [36] CJK UNIFIED IDEOGRAPH-8CA7..CJK UNIFIED IDEOGRAPH-8CCA
+8CCC..8CD5    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-8CCC..CJK UNIFIED IDEOGRAPH-8CD5
+8CD7          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-8CD7
+8CD9..8CE8    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-8CD9..CJK UNIFIED IDEOGRAPH-8CE8
+8CEA..8CF6    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-8CEA..CJK UNIFIED IDEOGRAPH-8CF6
+8CF8..8D00    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-8CF8..CJK UNIFIED IDEOGRAPH-8D00
+8D02..8D10    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-8D02..CJK UNIFIED IDEOGRAPH-8D10
+8D13..8D7B    ; Recommended                    # 1.1  [105] CJK UNIFIED IDEOGRAPH-8D13..CJK UNIFIED IDEOGRAPH-8D7B
+8D7D..8DA5    ; Recommended                    # 1.1   [41] CJK UNIFIED IDEOGRAPH-8D7D..CJK UNIFIED IDEOGRAPH-8DA5
+8DA7..8DBF    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-8DA7..CJK UNIFIED IDEOGRAPH-8DBF
+8DC1..8DE4    ; Recommended                    # 1.1   [36] CJK UNIFIED IDEOGRAPH-8DC1..CJK UNIFIED IDEOGRAPH-8DE4
+8DE6..8E00    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-8DE6..CJK UNIFIED IDEOGRAPH-8E00
+8E02..8E0A    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-8E02..CJK UNIFIED IDEOGRAPH-8E0A
+8E0C..8E31    ; Recommended                    # 1.1   [38] CJK UNIFIED IDEOGRAPH-8E0C..CJK UNIFIED IDEOGRAPH-8E31
+8E33..8E45    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-8E33..CJK UNIFIED IDEOGRAPH-8E45
+8E47..8E4E    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-8E47..CJK UNIFIED IDEOGRAPH-8E4E
+8E50..8E6D    ; Recommended                    # 1.1   [30] CJK UNIFIED IDEOGRAPH-8E50..CJK UNIFIED IDEOGRAPH-8E6D
+8E6F..8E74    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-8E6F..CJK UNIFIED IDEOGRAPH-8E74
+8E76          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-8E76
+8E78          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-8E78
+8E7A..8E9A    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-8E7A..CJK UNIFIED IDEOGRAPH-8E9A
+8E9C..8EA1    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-8E9C..CJK UNIFIED IDEOGRAPH-8EA1
+8EA3..8EB2    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-8EA3..CJK UNIFIED IDEOGRAPH-8EB2
+8EB4..8EB5    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-8EB4..CJK UNIFIED IDEOGRAPH-8EB5
+8EB8..8EC0    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-8EB8..CJK UNIFIED IDEOGRAPH-8EC0
+8EC2..8EC3    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-8EC2..CJK UNIFIED IDEOGRAPH-8EC3
+8EC5..8ED8    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-8EC5..CJK UNIFIED IDEOGRAPH-8ED8
+8EDA..8EEF    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-8EDA..CJK UNIFIED IDEOGRAPH-8EEF
+8EF1..8F0E    ; Recommended                    # 1.1   [30] CJK UNIFIED IDEOGRAPH-8EF1..CJK UNIFIED IDEOGRAPH-8F0E
+8F10..8F2C    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-8F10..CJK UNIFIED IDEOGRAPH-8F2C
+8F2E..8F39    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-8F2E..CJK UNIFIED IDEOGRAPH-8F39
+8F3B..8F40    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-8F3B..CJK UNIFIED IDEOGRAPH-8F40
+8F42..8F9C    ; Recommended                    # 1.1   [91] CJK UNIFIED IDEOGRAPH-8F42..CJK UNIFIED IDEOGRAPH-8F9C
+8F9E..8FA3    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-8F9E..CJK UNIFIED IDEOGRAPH-8FA3
+8FA5..8FB2    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-8FA5..CJK UNIFIED IDEOGRAPH-8FB2
+8FB4..8FC2    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-8FB4..CJK UNIFIED IDEOGRAPH-8FC2
+8FC4..8FC9    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-8FC4..CJK UNIFIED IDEOGRAPH-8FC9
+8FCB..8FE6    ; Recommended                    # 1.1   [28] CJK UNIFIED IDEOGRAPH-8FCB..CJK UNIFIED IDEOGRAPH-8FE6
+8FE8..9029    ; Recommended                    # 1.1   [66] CJK UNIFIED IDEOGRAPH-8FE8..CJK UNIFIED IDEOGRAPH-9029
+902B          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-902B
+902D..9036    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-902D..CJK UNIFIED IDEOGRAPH-9036
+9038..903F    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-9038..CJK UNIFIED IDEOGRAPH-903F
+9041..9045    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-9041..CJK UNIFIED IDEOGRAPH-9045
+9047..90AA    ; Recommended                    # 1.1  [100] CJK UNIFIED IDEOGRAPH-9047..CJK UNIFIED IDEOGRAPH-90AA
+90AC..90CB    ; Recommended                    # 1.1   [32] CJK UNIFIED IDEOGRAPH-90AC..CJK UNIFIED IDEOGRAPH-90CB
+90CE..90D1    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-90CE..CJK UNIFIED IDEOGRAPH-90D1
+90D3..90F5    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-90D3..CJK UNIFIED IDEOGRAPH-90F5
+90F7..9109    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-90F7..CJK UNIFIED IDEOGRAPH-9109
+910B..913B    ; Recommended                    # 1.1   [49] CJK UNIFIED IDEOGRAPH-910B..CJK UNIFIED IDEOGRAPH-913B
+913E..9158    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-913E..CJK UNIFIED IDEOGRAPH-9158
+915A..917A    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-915A..CJK UNIFIED IDEOGRAPH-917A
+917C..9194    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-917C..CJK UNIFIED IDEOGRAPH-9194
+9196..9197    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9196..CJK UNIFIED IDEOGRAPH-9197
+9199..91A8    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-9199..CJK UNIFIED IDEOGRAPH-91A8
+91AA..91BE    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-91AA..CJK UNIFIED IDEOGRAPH-91BE
+91C0..91C3    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-91C0..CJK UNIFIED IDEOGRAPH-91C3
+91C5..91DF    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-91C5..CJK UNIFIED IDEOGRAPH-91DF
+91E1..91EE    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-91E1..CJK UNIFIED IDEOGRAPH-91EE
+91F0..9212    ; Recommended                    # 1.1   [35] CJK UNIFIED IDEOGRAPH-91F0..CJK UNIFIED IDEOGRAPH-9212
+9214..921E    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-9214..CJK UNIFIED IDEOGRAPH-921E
+9220..9221    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9220..CJK UNIFIED IDEOGRAPH-9221
+9223..9242    ; Recommended                    # 1.1   [32] CJK UNIFIED IDEOGRAPH-9223..CJK UNIFIED IDEOGRAPH-9242
+9244..9268    ; Recommended                    # 1.1   [37] CJK UNIFIED IDEOGRAPH-9244..CJK UNIFIED IDEOGRAPH-9268
+926B..9280    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-926B..CJK UNIFIED IDEOGRAPH-9280
+9282..9283    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9282..CJK UNIFIED IDEOGRAPH-9283
+9285..929D    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-9285..CJK UNIFIED IDEOGRAPH-929D
+929F..92BC    ; Recommended                    # 1.1   [30] CJK UNIFIED IDEOGRAPH-929F..CJK UNIFIED IDEOGRAPH-92BC
+92BE..92D3    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-92BE..CJK UNIFIED IDEOGRAPH-92D3
+92D5..92DA    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-92D5..CJK UNIFIED IDEOGRAPH-92DA
+92DC..92E1    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-92DC..CJK UNIFIED IDEOGRAPH-92E1
+92E3..931B    ; Recommended                    # 1.1   [57] CJK UNIFIED IDEOGRAPH-92E3..CJK UNIFIED IDEOGRAPH-931B
+931D..932F    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-931D..CJK UNIFIED IDEOGRAPH-932F
+9332..9361    ; Recommended                    # 1.1   [48] CJK UNIFIED IDEOGRAPH-9332..CJK UNIFIED IDEOGRAPH-9361
+9363..9367    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-9363..CJK UNIFIED IDEOGRAPH-9367
+9369..936A    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9369..CJK UNIFIED IDEOGRAPH-936A
+936C..936E    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-936C..CJK UNIFIED IDEOGRAPH-936E
+9370..9372    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-9370..CJK UNIFIED IDEOGRAPH-9372
+9374..9377    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-9374..CJK UNIFIED IDEOGRAPH-9377
+9379..937E    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-9379..CJK UNIFIED IDEOGRAPH-937E
+9380          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-9380
+9382..938A    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-9382..CJK UNIFIED IDEOGRAPH-938A
+938C..939B    ; Recommended                    # 1.1   [16] CJK UNIFIED IDEOGRAPH-938C..CJK UNIFIED IDEOGRAPH-939B
+939D..939F    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-939D..CJK UNIFIED IDEOGRAPH-939F
+93A1..93AA    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-93A1..CJK UNIFIED IDEOGRAPH-93AA
+93AC..93BA    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-93AC..CJK UNIFIED IDEOGRAPH-93BA
+93BC..93DF    ; Recommended                    # 1.1   [36] CJK UNIFIED IDEOGRAPH-93BC..CJK UNIFIED IDEOGRAPH-93DF
+93E1..93F2    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-93E1..CJK UNIFIED IDEOGRAPH-93F2
+93F4..9401    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-93F4..CJK UNIFIED IDEOGRAPH-9401
+9403..9416    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-9403..CJK UNIFIED IDEOGRAPH-9416
+9418..941B    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-9418..CJK UNIFIED IDEOGRAPH-941B
+941D          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-941D
+9420..9423    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-9420..CJK UNIFIED IDEOGRAPH-9423
+9425..9442    ; Recommended                    # 1.1   [30] CJK UNIFIED IDEOGRAPH-9425..CJK UNIFIED IDEOGRAPH-9442
+9444..944D    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-9444..CJK UNIFIED IDEOGRAPH-944D
+944F..946B    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-944F..CJK UNIFIED IDEOGRAPH-946B
+946D..947A    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-946D..CJK UNIFIED IDEOGRAPH-947A
+947C..9577    ; Recommended                    # 1.1  [252] CJK UNIFIED IDEOGRAPH-947C..CJK UNIFIED IDEOGRAPH-9577
+957A..957D    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-957A..CJK UNIFIED IDEOGRAPH-957D
+957F..9584    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-957F..CJK UNIFIED IDEOGRAPH-9584
+9586..9596    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-9586..CJK UNIFIED IDEOGRAPH-9596
+9598..95B2    ; Recommended                    # 1.1   [27] CJK UNIFIED IDEOGRAPH-9598..CJK UNIFIED IDEOGRAPH-95B2
+95B5..95B7    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-95B5..CJK UNIFIED IDEOGRAPH-95B7
+95B9..95C0    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-95B9..CJK UNIFIED IDEOGRAPH-95C0
+95C2..95D8    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-95C2..CJK UNIFIED IDEOGRAPH-95D8
+95DA..95DC    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-95DA..CJK UNIFIED IDEOGRAPH-95DC
+95DE..9624    ; Recommended                    # 1.1   [71] CJK UNIFIED IDEOGRAPH-95DE..CJK UNIFIED IDEOGRAPH-9624
+9627..9628    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9627..CJK UNIFIED IDEOGRAPH-9628
+962A..963D    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-962A..CJK UNIFIED IDEOGRAPH-963D
+963F..9655    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-963F..CJK UNIFIED IDEOGRAPH-9655
+9658..9678    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-9658..CJK UNIFIED IDEOGRAPH-9678
+967A          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-967A
+967C..967E    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-967C..CJK UNIFIED IDEOGRAPH-967E
+9680          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-9680
+9683..968B    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-9683..CJK UNIFIED IDEOGRAPH-968B
+968D..9695    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-968D..CJK UNIFIED IDEOGRAPH-9695
+9697..9699    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-9697..CJK UNIFIED IDEOGRAPH-9699
+969B..969C    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-969B..CJK UNIFIED IDEOGRAPH-969C
+969E          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-969E
+96A0..96AA    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-96A0..CJK UNIFIED IDEOGRAPH-96AA
+96AC..96AE    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-96AC..CJK UNIFIED IDEOGRAPH-96AE
+96B0..96B4    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-96B0..CJK UNIFIED IDEOGRAPH-96B4
+96B6..96E3    ; Recommended                    # 1.1   [46] CJK UNIFIED IDEOGRAPH-96B6..CJK UNIFIED IDEOGRAPH-96E3
+96E5          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-96E5
+96E8..96FB    ; Recommended                    # 1.1   [20] CJK UNIFIED IDEOGRAPH-96E8..CJK UNIFIED IDEOGRAPH-96FB
+96FD..9713    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-96FD..CJK UNIFIED IDEOGRAPH-9713
+9715..9716    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9715..CJK UNIFIED IDEOGRAPH-9716
+9718..9719    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9718..CJK UNIFIED IDEOGRAPH-9719
+971C..9732    ; Recommended                    # 1.1   [23] CJK UNIFIED IDEOGRAPH-971C..CJK UNIFIED IDEOGRAPH-9732
+9735..9736    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9735..CJK UNIFIED IDEOGRAPH-9736
+9738..973F    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-9738..CJK UNIFIED IDEOGRAPH-973F
+9742..974C    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-9742..CJK UNIFIED IDEOGRAPH-974C
+974E..9756    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-974E..CJK UNIFIED IDEOGRAPH-9756
+9758..9762    ; Recommended                    # 1.1   [11] CJK UNIFIED IDEOGRAPH-9758..CJK UNIFIED IDEOGRAPH-9762
+9764..9774    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-9764..CJK UNIFIED IDEOGRAPH-9774
+9776..9786    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-9776..CJK UNIFIED IDEOGRAPH-9786
+9788          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-9788
+978A..979A    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-978A..CJK UNIFIED IDEOGRAPH-979A
+979C..97A8    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-979C..CJK UNIFIED IDEOGRAPH-97A8
+97AA..97AF    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-97AA..CJK UNIFIED IDEOGRAPH-97AF
+97B2..97B4    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-97B2..CJK UNIFIED IDEOGRAPH-97B4
+97B6..97BD    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-97B6..CJK UNIFIED IDEOGRAPH-97BD
+97BF          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-97BF
+97C1..97D1    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-97C1..CJK UNIFIED IDEOGRAPH-97D1
+97D3..97FB    ; Recommended                    # 1.1   [41] CJK UNIFIED IDEOGRAPH-97D3..CJK UNIFIED IDEOGRAPH-97FB
+97FD..981E    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-97FD..CJK UNIFIED IDEOGRAPH-981E
+9820..9824    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-9820..CJK UNIFIED IDEOGRAPH-9824
+9826..9829    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-9826..CJK UNIFIED IDEOGRAPH-9829
+982B..9832    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-982B..CJK UNIFIED IDEOGRAPH-9832
+9834..9839    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-9834..CJK UNIFIED IDEOGRAPH-9839
+983B..983D    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-983B..CJK UNIFIED IDEOGRAPH-983D
+983F..9841    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-983F..CJK UNIFIED IDEOGRAPH-9841
+9843..9846    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-9843..CJK UNIFIED IDEOGRAPH-9846
+9848..9855    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-9848..CJK UNIFIED IDEOGRAPH-9855
+9857..9865    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-9857..CJK UNIFIED IDEOGRAPH-9865
+9867          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-9867
+9869..98B6    ; Recommended                    # 1.1   [78] CJK UNIFIED IDEOGRAPH-9869..CJK UNIFIED IDEOGRAPH-98B6
+98B8..98C9    ; Recommended                    # 1.1   [18] CJK UNIFIED IDEOGRAPH-98B8..CJK UNIFIED IDEOGRAPH-98C9
+98CB..98E3    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-98CB..CJK UNIFIED IDEOGRAPH-98E3
+98E5..98EB    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-98E5..CJK UNIFIED IDEOGRAPH-98EB
+98ED..98F0    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-98ED..CJK UNIFIED IDEOGRAPH-98F0
+98F2..98F7    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-98F2..CJK UNIFIED IDEOGRAPH-98F7
+98F9..98FA    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-98F9..CJK UNIFIED IDEOGRAPH-98FA
+98FC..9918    ; Recommended                    # 1.1   [29] CJK UNIFIED IDEOGRAPH-98FC..CJK UNIFIED IDEOGRAPH-9918
+991A..993A    ; Recommended                    # 1.1   [33] CJK UNIFIED IDEOGRAPH-991A..CJK UNIFIED IDEOGRAPH-993A
+993C..9943    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-993C..CJK UNIFIED IDEOGRAPH-9943
+9945..9959    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-9945..CJK UNIFIED IDEOGRAPH-9959
+995B..995C    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-995B..CJK UNIFIED IDEOGRAPH-995C
+995E..99BE    ; Recommended                    # 1.1   [97] CJK UNIFIED IDEOGRAPH-995E..CJK UNIFIED IDEOGRAPH-99BE
+99C0..99DF    ; Recommended                    # 1.1   [32] CJK UNIFIED IDEOGRAPH-99C0..CJK UNIFIED IDEOGRAPH-99DF
+99E1..99E5    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-99E1..CJK UNIFIED IDEOGRAPH-99E5
+99E7..99EA    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-99E7..CJK UNIFIED IDEOGRAPH-99EA
+99EC..99F4    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-99EC..CJK UNIFIED IDEOGRAPH-99F4
+99F6..9A0F    ; Recommended                    # 1.1   [26] CJK UNIFIED IDEOGRAPH-99F6..CJK UNIFIED IDEOGRAPH-9A0F
+9A11..9A16    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-9A11..CJK UNIFIED IDEOGRAPH-9A16
+9A19..9A3A    ; Recommended                    # 1.1   [34] CJK UNIFIED IDEOGRAPH-9A19..CJK UNIFIED IDEOGRAPH-9A3A
+9A3C..9A50    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-9A3C..CJK UNIFIED IDEOGRAPH-9A50
+9A52..9A57    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-9A52..CJK UNIFIED IDEOGRAPH-9A57
+9A59..9A5C    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-9A59..CJK UNIFIED IDEOGRAPH-9A5C
+9A5E..9A62    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-9A5E..CJK UNIFIED IDEOGRAPH-9A62
+9A64..9AA8    ; Recommended                    # 1.1   [69] CJK UNIFIED IDEOGRAPH-9A64..CJK UNIFIED IDEOGRAPH-9AA8
+9AAA..9ABC    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-9AAA..CJK UNIFIED IDEOGRAPH-9ABC
+9ABE..9AC7    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-9ABE..CJK UNIFIED IDEOGRAPH-9AC7
+9AC9..9AD6    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-9AC9..CJK UNIFIED IDEOGRAPH-9AD6
+9AD8..9ADF    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-9AD8..CJK UNIFIED IDEOGRAPH-9ADF
+9AE1..9AE3    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-9AE1..CJK UNIFIED IDEOGRAPH-9AE3
+9AE5..9AE7    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-9AE5..CJK UNIFIED IDEOGRAPH-9AE7
+9AEA..9AEF    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-9AEA..CJK UNIFIED IDEOGRAPH-9AEF
+9AF1..9AFF    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-9AF1..CJK UNIFIED IDEOGRAPH-9AFF
+9B01          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-9B01
+9B03..9B08    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-9B03..CJK UNIFIED IDEOGRAPH-9B08
+9B0A..9B13    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-9B0A..CJK UNIFIED IDEOGRAPH-9B13
+9B15..9B1A    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-9B15..CJK UNIFIED IDEOGRAPH-9B1A
+9B1C..9B33    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-9B1C..CJK UNIFIED IDEOGRAPH-9B33
+9B35..9B3C    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-9B35..CJK UNIFIED IDEOGRAPH-9B3C
+9B3E..9B3F    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9B3E..CJK UNIFIED IDEOGRAPH-9B3F
+9B41..9B4F    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-9B41..CJK UNIFIED IDEOGRAPH-9B4F
+9B51..9B56    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-9B51..CJK UNIFIED IDEOGRAPH-9B56
+9B58..9B61    ; Recommended                    # 1.1   [10] CJK UNIFIED IDEOGRAPH-9B58..CJK UNIFIED IDEOGRAPH-9B61
+9B63..9B71    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-9B63..CJK UNIFIED IDEOGRAPH-9B71
+9B73..9B88    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-9B73..CJK UNIFIED IDEOGRAPH-9B88
+9B8A..9B8B    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9B8A..CJK UNIFIED IDEOGRAPH-9B8B
+9B8D..9B98    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-9B8D..CJK UNIFIED IDEOGRAPH-9B98
+9B9A..9BC1    ; Recommended                    # 1.1   [40] CJK UNIFIED IDEOGRAPH-9B9A..CJK UNIFIED IDEOGRAPH-9BC1
+9BC3..9BF5    ; Recommended                    # 1.1   [51] CJK UNIFIED IDEOGRAPH-9BC3..CJK UNIFIED IDEOGRAPH-9BF5
+9BF7..9BFF    ; Recommended                    # 1.1    [9] CJK UNIFIED IDEOGRAPH-9BF7..CJK UNIFIED IDEOGRAPH-9BFF
+9C02          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-9C02
+9C04..9C41    ; Recommended                    # 1.1   [62] CJK UNIFIED IDEOGRAPH-9C04..CJK UNIFIED IDEOGRAPH-9C41
+9C43..9C4E    ; Recommended                    # 1.1   [12] CJK UNIFIED IDEOGRAPH-9C43..CJK UNIFIED IDEOGRAPH-9C4E
+9C50          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-9C50
+9C52..9C60    ; Recommended                    # 1.1   [15] CJK UNIFIED IDEOGRAPH-9C52..CJK UNIFIED IDEOGRAPH-9C60
+9C62..9C63    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9C62..CJK UNIFIED IDEOGRAPH-9C63
+9C65..9C7A    ; Recommended                    # 1.1   [22] CJK UNIFIED IDEOGRAPH-9C65..CJK UNIFIED IDEOGRAPH-9C7A
+9C7C..9D0B    ; Recommended                    # 1.1  [144] CJK UNIFIED IDEOGRAPH-9C7C..CJK UNIFIED IDEOGRAPH-9D0B
+9D0E..9D10    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-9D0E..CJK UNIFIED IDEOGRAPH-9D10
+9D12..9D26    ; Recommended                    # 1.1   [21] CJK UNIFIED IDEOGRAPH-9D12..CJK UNIFIED IDEOGRAPH-9D26
+9D28..9D34    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-9D28..CJK UNIFIED IDEOGRAPH-9D34
+9D36..9D3B    ; Recommended                    # 1.1    [6] CJK UNIFIED IDEOGRAPH-9D36..CJK UNIFIED IDEOGRAPH-9D3B
+9D3D..9D6C    ; Recommended                    # 1.1   [48] CJK UNIFIED IDEOGRAPH-9D3D..CJK UNIFIED IDEOGRAPH-9D6C
+9D6E..9D94    ; Recommended                    # 1.1   [39] CJK UNIFIED IDEOGRAPH-9D6E..CJK UNIFIED IDEOGRAPH-9D94
+9D96..9DAD    ; Recommended                    # 1.1   [24] CJK UNIFIED IDEOGRAPH-9D96..CJK UNIFIED IDEOGRAPH-9DAD
+9DAF..9DBC    ; Recommended                    # 1.1   [14] CJK UNIFIED IDEOGRAPH-9DAF..CJK UNIFIED IDEOGRAPH-9DBC
+9DBE..9DBF    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9DBE..CJK UNIFIED IDEOGRAPH-9DBF
+9DC1..9DE9    ; Recommended                    # 1.1   [41] CJK UNIFIED IDEOGRAPH-9DC1..CJK UNIFIED IDEOGRAPH-9DE9
+9DEB..9DFB    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-9DEB..CJK UNIFIED IDEOGRAPH-9DFB
+9DFD..9E0D    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-9DFD..CJK UNIFIED IDEOGRAPH-9E0D
+9E0F..9E15    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-9E0F..CJK UNIFIED IDEOGRAPH-9E15
+9E17..9E1B    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-9E17..CJK UNIFIED IDEOGRAPH-9E1B
+9E1D..9E7A    ; Recommended                    # 1.1   [94] CJK UNIFIED IDEOGRAPH-9E1D..CJK UNIFIED IDEOGRAPH-9E7A
+9E7C..9E8E    ; Recommended                    # 1.1   [19] CJK UNIFIED IDEOGRAPH-9E7C..CJK UNIFIED IDEOGRAPH-9E8E
+9E91..9E97    ; Recommended                    # 1.1    [7] CJK UNIFIED IDEOGRAPH-9E91..CJK UNIFIED IDEOGRAPH-9E97
+9E99..9E9D    ; Recommended                    # 1.1    [5] CJK UNIFIED IDEOGRAPH-9E99..CJK UNIFIED IDEOGRAPH-9E9D
+9E9F..9EA1    ; Recommended                    # 1.1    [3] CJK UNIFIED IDEOGRAPH-9E9F..CJK UNIFIED IDEOGRAPH-9EA1
+9EA3..9EAA    ; Recommended                    # 1.1    [8] CJK UNIFIED IDEOGRAPH-9EA3..CJK UNIFIED IDEOGRAPH-9EAA
+9EAD..9EB0    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-9EAD..CJK UNIFIED IDEOGRAPH-9EB0
+9EB2..9EEB    ; Recommended                    # 1.1   [58] CJK UNIFIED IDEOGRAPH-9EB2..CJK UNIFIED IDEOGRAPH-9EEB
+9EED..9EF0    ; Recommended                    # 1.1    [4] CJK UNIFIED IDEOGRAPH-9EED..CJK UNIFIED IDEOGRAPH-9EF0
+9EF2..9F02    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-9EF2..CJK UNIFIED IDEOGRAPH-9F02
+9F04..9F10    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-9F04..CJK UNIFIED IDEOGRAPH-9F10
+9F12..9F13    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9F12..CJK UNIFIED IDEOGRAPH-9F13
+9F15..9F25    ; Recommended                    # 1.1   [17] CJK UNIFIED IDEOGRAPH-9F15..CJK UNIFIED IDEOGRAPH-9F25
+9F27..9F44    ; Recommended                    # 1.1   [30] CJK UNIFIED IDEOGRAPH-9F27..CJK UNIFIED IDEOGRAPH-9F44
+9F46..9F52    ; Recommended                    # 1.1   [13] CJK UNIFIED IDEOGRAPH-9F46..CJK UNIFIED IDEOGRAPH-9F52
+9F54..9F6C    ; Recommended                    # 1.1   [25] CJK UNIFIED IDEOGRAPH-9F54..CJK UNIFIED IDEOGRAPH-9F6C
+9F6E..9FA0    ; Recommended                    # 1.1   [51] CJK UNIFIED IDEOGRAPH-9F6E..CJK UNIFIED IDEOGRAPH-9FA0
+9FA2          ; Recommended                    # 1.1        CJK UNIFIED IDEOGRAPH-9FA2
+9FA4..9FA5    ; Recommended                    # 1.1    [2] CJK UNIFIED IDEOGRAPH-9FA4..CJK UNIFIED IDEOGRAPH-9FA5
+A78D          ; Recommended                    # 6.0        LATIN CAPITAL LETTER TURNED H
+A7AA          ; Recommended                    # 6.1        LATIN CAPITAL LETTER H WITH HOOK
+AA7B          ; Recommended                    # 5.2        MYANMAR SIGN PAO KAREN TONE
+AC00..D7A3    ; Recommended                    # 2.0 [11172] HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH
+11301         ; Recommended                    # 7.0        GRANTHA SIGN CANDRABINDU
+11303         ; Recommended                    # 7.0        GRANTHA SIGN VISARGA
+1133C         ; Recommended                    # 7.0        GRANTHA SIGN NUKTA
+1E7E0..1E7E6  ; Recommended                    # 14.0   [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO
+1E7E8..1E7EB  ; Recommended                    # 14.0   [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE
+1E7ED..1E7EE  ; Recommended                    # 14.0   [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE
+1E7F0..1E7FE  ; Recommended                    # 14.0  [15] ETHIOPIC SYLLABLE GURAGE QWI..ETHIOPIC SYLLABLE GURAGE PWEE
+2070E         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-2070E
+20731         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20731
+20779         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20779
+20C53         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20C53
+20C78         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20C78
+20C96         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20C96
+20CCF         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20CCF
+20CD5         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20CD5
+20D15         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20D15
+20D7C         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20D7C
+20D7F         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20D7F
+20E0E..20E0F  ; Recommended                    # 3.1    [2] CJK UNIFIED IDEOGRAPH-20E0E..CJK UNIFIED IDEOGRAPH-20E0F
+20E77         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20E77
+20E9D         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20E9D
+20EA2         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20EA2
+20ED7         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20ED7
+20EF9..20EFA  ; Recommended                    # 3.1    [2] CJK UNIFIED IDEOGRAPH-20EF9..CJK UNIFIED IDEOGRAPH-20EFA
+20F2D..20F2E  ; Recommended                    # 3.1    [2] CJK UNIFIED IDEOGRAPH-20F2D..CJK UNIFIED IDEOGRAPH-20F2E
+20F4C         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20F4C
+20FB4         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20FB4
+20FBC         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20FBC
+20FEA         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-20FEA
+2105C         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-2105C
+2106F         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-2106F
+21075..21076  ; Recommended                    # 3.1    [2] CJK UNIFIED IDEOGRAPH-21075..CJK UNIFIED IDEOGRAPH-21076
+2107B         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-2107B
+210C1         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-210C1
+210C9         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-210C9
+211D9         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-211D9
+220C7         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-220C7
+227B5         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-227B5
+22AD5         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-22AD5
+22B43         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-22B43
+22BCA         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-22BCA
+22C51         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-22C51
+22C55         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-22C55
+22CC2         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-22CC2
+22D08         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-22D08
+22D4C         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-22D4C
+22D67         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-22D67
+22EB3         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-22EB3
+23CB7         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-23CB7
+244D3         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-244D3
+24DB8         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-24DB8
+24DEA         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-24DEA
+2512B         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-2512B
+26258         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-26258
+267CC         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-267CC
+269F2         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-269F2
+269FA         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-269FA
+27A3E         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-27A3E
+2815D         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-2815D
+28207         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-28207
+282E2         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-282E2
+28CCA         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-28CCA
+28CCD         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-28CCD
+28CD2         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-28CD2
+29D98         ; Recommended                    # 3.1        CJK UNIFIED IDEOGRAPH-29D98
+
+# Total code points: 33773
+
+#	Identifier_Type:	Inclusion
+
+0027          ; Inclusion                      # 1.1        APOSTROPHE
+002D..002E    ; Inclusion                      # 1.1    [2] HYPHEN-MINUS..FULL STOP
+003A          ; Inclusion                      # 1.1        COLON
+00B7          ; Inclusion                      # 1.1        MIDDLE DOT
+02BB..02BC    ; Inclusion                      # 1.1    [2] MODIFIER LETTER TURNED COMMA..MODIFIER LETTER APOSTROPHE
+058A          ; Inclusion                      # 3.0        ARMENIAN HYPHEN
+05F3..05F4    ; Inclusion                      # 1.1    [2] HEBREW PUNCTUATION GERESH..HEBREW PUNCTUATION GERSHAYIM
+06FD..06FE    ; Inclusion                      # 3.0    [2] ARABIC SIGN SINDHI AMPERSAND..ARABIC SIGN SINDHI POSTPOSITION MEN
+0F0B          ; Inclusion                      # 2.0        TIBETAN MARK INTERSYLLABIC TSHEG
+2010          ; Inclusion                      # 1.1        HYPHEN
+2019          ; Inclusion                      # 1.1        RIGHT SINGLE QUOTATION MARK
+2027          ; Inclusion                      # 1.1        HYPHENATION POINT
+30A0          ; Inclusion                      # 3.2        KATAKANA-HIRAGANA DOUBLE HYPHEN
+30FB          ; Inclusion                      # 1.1        KATAKANA MIDDLE DOT
+
+# Total code points: 18
+
+#	Identifier_Type:	Limited_Use
+
+0710..072C    ; Limited_Use                    # 3.0   [29] SYRIAC LETTER ALAPH..SYRIAC LETTER TAW
+072D..072F    ; Limited_Use                    # 4.0    [3] SYRIAC LETTER PERSIAN BHETH..SYRIAC LETTER PERSIAN DHALATH
+0730..073F    ; Limited_Use                    # 3.0   [16] SYRIAC PTHAHA ABOVE..SYRIAC RWAHA
+074D..074F    ; Limited_Use                    # 4.0    [3] SYRIAC LETTER SOGDIAN ZHAIN..SYRIAC LETTER SOGDIAN FE
+07C0..07E7    ; Limited_Use                    # 5.0   [40] NKO DIGIT ZERO..NKO LETTER NYA WOLOSO
+07EB..07F5    ; Limited_Use                    # 5.0   [11] NKO COMBINING SHORT HIGH TONE..NKO LOW TONE APOSTROPHE
+07FD          ; Limited_Use                    # 11.0       NKO DANTAYALAN
+0840..085B    ; Limited_Use                    # 6.0   [28] MANDAIC LETTER HALQA..MANDAIC GEMINATION MARK
+0860..086A    ; Limited_Use                    # 10.0  [11] SYRIAC LETTER MALAYALAM NGA..SYRIAC LETTER MALAYALAM SSA
+13A0..13F4    ; Limited_Use                    # 3.0   [85] CHEROKEE LETTER A..CHEROKEE LETTER YV
+13F5          ; Limited_Use                    # 8.0        CHEROKEE LETTER MV
+13F8..13FD    ; Limited_Use                    # 8.0    [6] CHEROKEE SMALL LETTER YE..CHEROKEE SMALL LETTER MV
+1401..166C    ; Limited_Use                    # 3.0  [620] CANADIAN SYLLABICS E..CANADIAN SYLLABICS CARRIER TTSA
+166F..1676    ; Limited_Use                    # 3.0    [8] CANADIAN SYLLABICS QAI..CANADIAN SYLLABICS NNGAA
+1677..167F    ; Limited_Use                    # 5.2    [9] CANADIAN SYLLABICS WOODS-CREE THWEE..CANADIAN SYLLABICS BLACKFOOT W
+18B0..18F5    ; Limited_Use                    # 5.2   [70] CANADIAN SYLLABICS OY..CANADIAN SYLLABICS CARRIER DENTAL S
+1900..191C    ; Limited_Use                    # 4.0   [29] LIMBU VOWEL-CARRIER LETTER..LIMBU LETTER HA
+191D..191E    ; Limited_Use                    # 7.0    [2] LIMBU LETTER GYAN..LIMBU LETTER TRA
+1920..192B    ; Limited_Use                    # 4.0   [12] LIMBU VOWEL SIGN A..LIMBU SUBJOINED LETTER WA
+1930..193B    ; Limited_Use                    # 4.0   [12] LIMBU SMALL LETTER KA..LIMBU SIGN SA-I
+1946..196D    ; Limited_Use                    # 4.0   [40] LIMBU DIGIT ZERO..TAI LE LETTER AI
+1970..1974    ; Limited_Use                    # 4.0    [5] TAI LE LETTER TONE-2..TAI LE LETTER TONE-6
+1980..19A9    ; Limited_Use                    # 4.1   [42] NEW TAI LUE LETTER HIGH QA..NEW TAI LUE LETTER LOW XVA
+19AA..19AB    ; Limited_Use                    # 5.2    [2] NEW TAI LUE LETTER HIGH SUA..NEW TAI LUE LETTER LOW SUA
+19B0..19C9    ; Limited_Use                    # 4.1   [26] NEW TAI LUE VOWEL SIGN VOWEL SHORTENER..NEW TAI LUE TONE MARK-2
+19D0..19D9    ; Limited_Use                    # 4.1   [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE
+19DA          ; Limited_Use                    # 5.2        NEW TAI LUE THAM DIGIT ONE
+1A20..1A5E    ; Limited_Use                    # 5.2   [63] TAI THAM LETTER HIGH KA..TAI THAM CONSONANT SIGN SA
+1A60..1A7C    ; Limited_Use                    # 5.2   [29] TAI THAM SIGN SAKOT..TAI THAM SIGN KHUEN-LUE KARAN
+1A7F..1A89    ; Limited_Use                    # 5.2   [11] TAI THAM COMBINING CRYPTOGRAMMIC DOT..TAI THAM HORA DIGIT NINE
+1A90..1A99    ; Limited_Use                    # 5.2   [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE
+1AA7          ; Limited_Use                    # 5.2        TAI THAM SIGN MAI YAMOK
+1B00..1B4B    ; Limited_Use                    # 5.0   [76] BALINESE SIGN ULU RICEM..BALINESE LETTER ASYURA SASAK
+1B4C          ; Limited_Use                    # 14.0       BALINESE LETTER ARCHAIC JNYA
+1B50..1B59    ; Limited_Use                    # 5.0   [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE
+1B80..1BAA    ; Limited_Use                    # 5.1   [43] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PAMAAEH
+1BAB..1BAD    ; Limited_Use                    # 6.1    [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA
+1BAE..1BB9    ; Limited_Use                    # 5.1   [12] SUNDANESE LETTER KHA..SUNDANESE DIGIT NINE
+1BBA..1BBF    ; Limited_Use                    # 6.1    [6] SUNDANESE AVAGRAHA..SUNDANESE LETTER FINAL M
+1BC0..1BF3    ; Limited_Use                    # 6.0   [52] BATAK LETTER A..BATAK PANONGONAN
+1C00..1C37    ; Limited_Use                    # 5.1   [56] LEPCHA LETTER KA..LEPCHA SIGN NUKTA
+1C40..1C49    ; Limited_Use                    # 5.1   [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE
+1C4D..1C7D    ; Limited_Use                    # 5.1   [49] LEPCHA LETTER TTA..OL CHIKI AHAD
+2D30..2D65    ; Limited_Use                    # 4.1   [54] TIFINAGH LETTER YA..TIFINAGH LETTER YAZZ
+2D66..2D67    ; Limited_Use                    # 6.1    [2] TIFINAGH LETTER YE..TIFINAGH LETTER YO
+2D7F          ; Limited_Use                    # 6.0        TIFINAGH CONSONANT JOINER
+3105..312C    ; Limited_Use                    # 1.1   [40] BOPOMOFO LETTER B..BOPOMOFO LETTER GN
+312D          ; Limited_Use                    # 5.1        BOPOMOFO LETTER IH
+312F          ; Limited_Use                    # 11.0       BOPOMOFO LETTER NN
+31A0..31B7    ; Limited_Use                    # 3.0   [24] BOPOMOFO LETTER BU..BOPOMOFO FINAL LETTER H
+31B8..31BA    ; Limited_Use                    # 6.0    [3] BOPOMOFO LETTER GH..BOPOMOFO LETTER ZY
+31BB..31BF    ; Limited_Use                    # 13.0   [5] BOPOMOFO FINAL LETTER G..BOPOMOFO LETTER AH
+A000..A48C    ; Limited_Use                    # 3.0 [1165] YI SYLLABLE IT..YI SYLLABLE YYR
+A4D0..A4FD    ; Limited_Use                    # 5.2   [46] LISU LETTER BA..LISU LETTER TONE MYA JEU
+A500..A60C    ; Limited_Use                    # 5.1  [269] VAI SYLLABLE EE..VAI SYLLABLE LENGTHENER
+A613..A629    ; Limited_Use                    # 5.1   [23] VAI SYMBOL FEENG..VAI DIGIT NINE
+A6A0..A6F1    ; Limited_Use                    # 5.2   [82] BAMUM LETTER A..BAMUM COMBINING MARK TUKWENTIS
+A800..A827    ; Limited_Use                    # 4.1   [40] SYLOTI NAGRI LETTER A..SYLOTI NAGRI VOWEL SIGN OO
+A82C          ; Limited_Use                    # 13.0       SYLOTI NAGRI SIGN ALTERNATE HASANTA
+A880..A8C4    ; Limited_Use                    # 5.1   [69] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VIRAMA
+A8C5          ; Limited_Use                    # 9.0        SAURASHTRA SIGN CANDRABINDU
+A8D0..A8D9    ; Limited_Use                    # 5.1   [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE
+A900..A92D    ; Limited_Use                    # 5.1   [46] KAYAH LI DIGIT ZERO..KAYAH LI TONE CALYA PLOPHU
+A980..A9C0    ; Limited_Use                    # 5.2   [65] JAVANESE SIGN PANYANGGA..JAVANESE PANGKON
+A9D0..A9D9    ; Limited_Use                    # 5.2   [10] JAVANESE DIGIT ZERO..JAVANESE DIGIT NINE
+AA00..AA36    ; Limited_Use                    # 5.1   [55] CHAM LETTER A..CHAM CONSONANT SIGN WA
+AA40..AA4D    ; Limited_Use                    # 5.1   [14] CHAM LETTER FINAL K..CHAM CONSONANT SIGN FINAL H
+AA50..AA59    ; Limited_Use                    # 5.1   [10] CHAM DIGIT ZERO..CHAM DIGIT NINE
+AA80..AAC2    ; Limited_Use                    # 5.2   [67] TAI VIET LETTER LOW KO..TAI VIET TONE MAI SONG
+AADB..AADD    ; Limited_Use                    # 5.2    [3] TAI VIET SYMBOL KON..TAI VIET SYMBOL SAM
+AAE0..AAEF    ; Limited_Use                    # 6.1   [16] MEETEI MAYEK LETTER E..MEETEI MAYEK VOWEL SIGN AAU
+AAF2..AAF6    ; Limited_Use                    # 6.1    [5] MEETEI MAYEK ANJI..MEETEI MAYEK VIRAMA
+AB70..ABBF    ; Limited_Use                    # 8.0   [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA
+ABC0..ABEA    ; Limited_Use                    # 5.2   [43] MEETEI MAYEK LETTER KOK..MEETEI MAYEK VOWEL SIGN NUNG
+ABEC..ABED    ; Limited_Use                    # 5.2    [2] MEETEI MAYEK LUM IYEK..MEETEI MAYEK APUN IYEK
+ABF0..ABF9    ; Limited_Use                    # 5.2   [10] MEETEI MAYEK DIGIT ZERO..MEETEI MAYEK DIGIT NINE
+104B0..104D3  ; Limited_Use                    # 9.0   [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA
+104D8..104FB  ; Limited_Use                    # 9.0   [36] OSAGE SMALL LETTER A..OSAGE SMALL LETTER ZHA
+10D00..10D27  ; Limited_Use                    # 11.0  [40] HANIFI ROHINGYA LETTER A..HANIFI ROHINGYA SIGN TASSI
+10D30..10D39  ; Limited_Use                    # 11.0  [10] HANIFI ROHINGYA DIGIT ZERO..HANIFI ROHINGYA DIGIT NINE
+11100..11134  ; Limited_Use                    # 6.1   [53] CHAKMA SIGN CANDRABINDU..CHAKMA MAAYYAA
+11136..1113F  ; Limited_Use                    # 6.1   [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT NINE
+11144..11146  ; Limited_Use                    # 11.0   [3] CHAKMA LETTER LHAA..CHAKMA VOWEL SIGN EI
+11147         ; Limited_Use                    # 13.0       CHAKMA LETTER VAA
+11400..1144A  ; Limited_Use                    # 9.0   [75] NEWA LETTER A..NEWA SIDDHI
+11450..11459  ; Limited_Use                    # 9.0   [10] NEWA DIGIT ZERO..NEWA DIGIT NINE
+1145E         ; Limited_Use                    # 11.0       NEWA SANDHI MARK
+1145F         ; Limited_Use                    # 12.0       NEWA LETTER VEDIC ANUSVARA
+11460..11461  ; Limited_Use                    # 13.0   [2] NEWA SIGN JIHVAMULIYA..NEWA SIGN UPADHMANIYA
+11AB0..11ABF  ; Limited_Use                    # 14.0  [16] CANADIAN SYLLABICS NATTILIK HI..CANADIAN SYLLABICS SPA
+11FB0         ; Limited_Use                    # 13.0       LISU LETTER YHA
+16800..16A38  ; Limited_Use                    # 6.0  [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ
+16F00..16F44  ; Limited_Use                    # 6.1   [69] MIAO LETTER PA..MIAO LETTER HHA
+16F45..16F4A  ; Limited_Use                    # 12.0   [6] MIAO LETTER BRI..MIAO LETTER RTE
+16F4F         ; Limited_Use                    # 12.0       MIAO SIGN CONSONANT MODIFIER BAR
+16F50..16F7E  ; Limited_Use                    # 6.1   [47] MIAO LETTER NASALIZATION..MIAO VOWEL SIGN NG
+16F7F..16F87  ; Limited_Use                    # 12.0   [9] MIAO VOWEL SIGN UOG..MIAO VOWEL SIGN UI
+16F8F..16F9F  ; Limited_Use                    # 6.1   [17] MIAO TONE RIGHT..MIAO LETTER REFORMED TONE-8
+1E100..1E12C  ; Limited_Use                    # 12.0  [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W
+1E130..1E13D  ; Limited_Use                    # 12.0  [14] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER
+1E140..1E149  ; Limited_Use                    # 12.0  [10] NYIAKENG PUACHUE HMONG DIGIT ZERO..NYIAKENG PUACHUE HMONG DIGIT NINE
+1E14E         ; Limited_Use                    # 12.0       NYIAKENG PUACHUE HMONG LOGOGRAM NYAJ
+1E2C0..1E2F9  ; Limited_Use                    # 12.0  [58] WANCHO LETTER AA..WANCHO DIGIT NINE
+1E900..1E94A  ; Limited_Use                    # 9.0   [75] ADLAM CAPITAL LETTER ALIF..ADLAM NUKTA
+1E94B         ; Limited_Use                    # 12.0       ADLAM NASALIZATION MARK
+1E950..1E959  ; Limited_Use                    # 9.0   [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE
+
+# Total code points: 5044
+
+#	Identifier_Type:	Limited_Use Uncommon_Use
+
+A9CF          ; Limited_Use Uncommon_Use       # 5.2        JAVANESE PANGRANGKEP
+
+# Total code points: 1
+
+#	Identifier_Type:	Limited_Use Technical
+
+0740..074A    ; Limited_Use Technical          # 3.0   [11] SYRIAC FEMININE DOT..SYRIAC BARREKH
+1B6B..1B73    ; Limited_Use Technical          # 5.0    [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG
+1DFA          ; Limited_Use Technical          # 14.0       COMBINING DOT BELOW LEFT
+
+# Total code points: 21
+
+#	Identifier_Type:	Limited_Use Obsolete
+
+07E8..07EA    ; Limited_Use Obsolete           # 5.0    [3] NKO LETTER JONA JA..NKO LETTER JONA RA
+07FA          ; Limited_Use Obsolete           # 5.0        NKO LAJANYALAN
+312E          ; Limited_Use Obsolete           # 10.0       BOPOMOFO LETTER O WITH DOT ABOVE
+A610..A612    ; Limited_Use Obsolete           # 5.1    [3] VAI SYLLABLE NDOLE FA..VAI SYLLABLE NDOLE SOO
+A62A..A62B    ; Limited_Use Obsolete           # 5.1    [2] VAI SYLLABLE NDOLE MA..VAI SYLLABLE NDOLE DO
+
+# Total code points: 10
+
+#	Identifier_Type:	Limited_Use Not_XID
+
+02EA..02EB    ; Limited_Use Not_XID            # 3.0    [2] MODIFIER LETTER YIN DEPARTING TONE MARK..MODIFIER LETTER YANG DEPARTING TONE MARK
+0700..070D    ; Limited_Use Not_XID            # 3.0   [14] SYRIAC END OF PARAGRAPH..SYRIAC HARKLEAN ASTERISCUS
+070F          ; Limited_Use Not_XID            # 3.0        SYRIAC ABBREVIATION MARK
+07F6..07F9    ; Limited_Use Not_XID            # 5.0    [4] NKO SYMBOL OO DENNEN..NKO EXCLAMATION MARK
+07FE..07FF    ; Limited_Use Not_XID            # 11.0   [2] NKO DOROME SIGN..NKO TAMAN SIGN
+085E          ; Limited_Use Not_XID            # 6.0        MANDAIC PUNCTUATION
+1400          ; Limited_Use Not_XID            # 5.2        CANADIAN SYLLABICS HYPHEN
+166D..166E    ; Limited_Use Not_XID            # 3.0    [2] CANADIAN SYLLABICS CHI SIGN..CANADIAN SYLLABICS FULL STOP
+1940          ; Limited_Use Not_XID            # 4.0        LIMBU SIGN LOO
+1944..1945    ; Limited_Use Not_XID            # 4.0    [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK
+19DE..19DF    ; Limited_Use Not_XID            # 4.1    [2] NEW TAI LUE SIGN LAE..NEW TAI LUE SIGN LAEV
+1AA0..1AA6    ; Limited_Use Not_XID            # 5.2    [7] TAI THAM SIGN WIANG..TAI THAM SIGN REVERSED ROTATED RANA
+1AA8..1AAD    ; Limited_Use Not_XID            # 5.2    [6] TAI THAM SIGN KAAN..TAI THAM SIGN CAANG
+1B4E..1B4F    ; Limited_Use Not_XID            # 16.0   [2] BALINESE INVERTED CARIK SIKI..BALINESE INVERTED CARIK PAREREN
+1B5A..1B6A    ; Limited_Use Not_XID            # 5.0   [17] BALINESE PANTI..BALINESE MUSICAL SYMBOL DANG GEDE
+1B74..1B7C    ; Limited_Use Not_XID            # 5.0    [9] BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DUG..BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PING
+1B7D..1B7E    ; Limited_Use Not_XID            # 14.0   [2] BALINESE PANTI LANTANG..BALINESE PAMADA LANTANG
+1B7F          ; Limited_Use Not_XID            # 16.0       BALINESE PANTI BAWAK
+1BFC..1BFF    ; Limited_Use Not_XID            # 6.0    [4] BATAK SYMBOL BINDU NA METEK..BATAK SYMBOL BINDU PANGOLAT
+1C3B..1C3F    ; Limited_Use Not_XID            # 5.1    [5] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION TSHOOK
+1C7E..1C7F    ; Limited_Use Not_XID            # 5.1    [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD
+1CC0..1CC7    ; Limited_Use Not_XID            # 6.1    [8] SUNDANESE PUNCTUATION BINDU SURYA..SUNDANESE PUNCTUATION BINDU BA SATANGA
+2D70          ; Limited_Use Not_XID            # 6.0        TIFINAGH SEPARATOR MARK
+A490..A4A1    ; Limited_Use Not_XID            # 3.0   [18] YI RADICAL QOT..YI RADICAL GA
+A4A2..A4A3    ; Limited_Use Not_XID            # 3.2    [2] YI RADICAL ZUP..YI RADICAL CYT
+A4A4..A4B3    ; Limited_Use Not_XID            # 3.0   [16] YI RADICAL DDUR..YI RADICAL JO
+A4B4          ; Limited_Use Not_XID            # 3.2        YI RADICAL NZUP
+A4B5..A4C0    ; Limited_Use Not_XID            # 3.0   [12] YI RADICAL JJY..YI RADICAL SHAT
+A4C1          ; Limited_Use Not_XID            # 3.2        YI RADICAL ZUR
+A4C2..A4C4    ; Limited_Use Not_XID            # 3.0    [3] YI RADICAL SHOP..YI RADICAL ZZIET
+A4C5          ; Limited_Use Not_XID            # 3.2        YI RADICAL NBIE
+A4C6          ; Limited_Use Not_XID            # 3.0        YI RADICAL KE
+A4FE..A4FF    ; Limited_Use Not_XID            # 5.2    [2] LISU PUNCTUATION COMMA..LISU PUNCTUATION FULL STOP
+A60D..A60F    ; Limited_Use Not_XID            # 5.1    [3] VAI COMMA..VAI QUESTION MARK
+A6F2..A6F7    ; Limited_Use Not_XID            # 5.2    [6] BAMUM NJAEMLI..BAMUM QUESTION MARK
+A828..A82B    ; Limited_Use Not_XID            # 4.1    [4] SYLOTI NAGRI POETRY MARK-1..SYLOTI NAGRI POETRY MARK-4
+A8CE..A8CF    ; Limited_Use Not_XID            # 5.1    [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA
+A92F          ; Limited_Use Not_XID            # 5.1        KAYAH LI SIGN SHYA
+A9C1..A9CD    ; Limited_Use Not_XID            # 5.2   [13] JAVANESE LEFT RERENGGAN..JAVANESE TURNED PADA PISELEH
+A9DE..A9DF    ; Limited_Use Not_XID            # 5.2    [2] JAVANESE PADA TIRTA TUMETES..JAVANESE PADA ISEN-ISEN
+AA5C..AA5F    ; Limited_Use Not_XID            # 5.1    [4] CHAM PUNCTUATION SPIRAL..CHAM PUNCTUATION TRIPLE DANDA
+AADE..AADF    ; Limited_Use Not_XID            # 5.2    [2] TAI VIET SYMBOL HO HOI..TAI VIET SYMBOL KOI KOI
+AAF0..AAF1    ; Limited_Use Not_XID            # 6.1    [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM
+ABEB          ; Limited_Use Not_XID            # 5.2        MEETEI MAYEK CHEIKHEI
+11140..11143  ; Limited_Use Not_XID            # 6.1    [4] CHAKMA SECTION MARK..CHAKMA QUESTION MARK
+1144B..1144F  ; Limited_Use Not_XID            # 9.0    [5] NEWA DANDA..NEWA ABBREVIATION SIGN
+1145A         ; Limited_Use Not_XID            # 13.0       NEWA DOUBLE COMMA
+1145B         ; Limited_Use Not_XID            # 9.0        NEWA PLACEHOLDER MARK
+1145D         ; Limited_Use Not_XID            # 9.0        NEWA INSERTION SIGN
+1E14F         ; Limited_Use Not_XID            # 12.0       NYIAKENG PUACHUE HMONG CIRCLED CA
+1E2FF         ; Limited_Use Not_XID            # 12.0       WANCHO NGUN SIGN
+1E95E..1E95F  ; Limited_Use Not_XID            # 9.0    [2] ADLAM INITIAL EXCLAMATION MARK..ADLAM INITIAL QUESTION MARK
+
+# Total code points: 209
+
+#	Identifier_Type:	Uncommon_Use
+
+0114..0115    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER E WITH BREVE..LATIN SMALL LETTER E WITH BREVE
+012C..012D    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER I WITH BREVE..LATIN SMALL LETTER I WITH BREVE
+014E..014F    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER O WITH BREVE..LATIN SMALL LETTER O WITH BREVE
+0156..0157    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER R WITH CEDILLA..LATIN SMALL LETTER R WITH CEDILLA
+0162..0163    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER T WITH CEDILLA..LATIN SMALL LETTER T WITH CEDILLA
+0182..0185    ; Uncommon_Use                   # 1.1    [4] LATIN CAPITAL LETTER B WITH TOPBAR..LATIN SMALL LETTER TONE SIX
+0187..0188    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER C WITH HOOK..LATIN SMALL LETTER C WITH HOOK
+018B..018C    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER D WITH TOPBAR..LATIN SMALL LETTER D WITH TOPBAR
+0193          ; Uncommon_Use                   # 1.1        LATIN CAPITAL LETTER G WITH HOOK
+0195          ; Uncommon_Use                   # 1.1        LATIN SMALL LETTER HV
+019A..019C    ; Uncommon_Use                   # 1.1    [3] LATIN SMALL LETTER L WITH BAR..LATIN CAPITAL LETTER TURNED M
+019E..019F    ; Uncommon_Use                   # 1.1    [2] LATIN SMALL LETTER N WITH LONG RIGHT LEG..LATIN CAPITAL LETTER O WITH MIDDLE TILDE
+01A2..01A9    ; Uncommon_Use                   # 1.1    [8] LATIN CAPITAL LETTER OI..LATIN CAPITAL LETTER ESH
+01AC..01AE    ; Uncommon_Use                   # 1.1    [3] LATIN CAPITAL LETTER T WITH HOOK..LATIN CAPITAL LETTER T WITH RETROFLEX HOOK
+01B1          ; Uncommon_Use                   # 1.1        LATIN CAPITAL LETTER UPSILON
+01B5..01B6    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER Z WITH STROKE..LATIN SMALL LETTER Z WITH STROKE
+01B8          ; Uncommon_Use                   # 1.1        LATIN CAPITAL LETTER EZH REVERSED
+01BC..01BD    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER TONE FIVE..LATIN SMALL LETTER TONE FIVE
+01D5..01DC    ; Uncommon_Use                   # 1.1    [8] LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON..LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE
+01DE..01E5    ; Uncommon_Use                   # 1.1    [8] LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON..LATIN SMALL LETTER G WITH STROKE
+01EA..01ED    ; Uncommon_Use                   # 1.1    [4] LATIN CAPITAL LETTER O WITH OGONEK..LATIN SMALL LETTER O WITH OGONEK AND MACRON
+01F0          ; Uncommon_Use                   # 1.1        LATIN SMALL LETTER J WITH CARON
+01F4..01F5    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER G WITH ACUTE..LATIN SMALL LETTER G WITH ACUTE
+01FA..01FF    ; Uncommon_Use                   # 1.1    [6] LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE..LATIN SMALL LETTER O WITH STROKE AND ACUTE
+021E..021F    ; Uncommon_Use                   # 3.0    [2] LATIN CAPITAL LETTER H WITH CARON..LATIN SMALL LETTER H WITH CARON
+0220          ; Uncommon_Use                   # 3.2        LATIN CAPITAL LETTER N WITH LONG RIGHT LEG
+0221          ; Uncommon_Use                   # 4.0        LATIN SMALL LETTER D WITH CURL
+0222..0233    ; Uncommon_Use                   # 3.0   [18] LATIN CAPITAL LETTER OU..LATIN SMALL LETTER Y WITH MACRON
+0237..0241    ; Uncommon_Use                   # 4.1   [11] LATIN SMALL LETTER DOTLESS J..LATIN CAPITAL LETTER GLOTTAL STOP
+0242..0243    ; Uncommon_Use                   # 5.0    [2] LATIN SMALL LETTER GLOTTAL STOP..LATIN CAPITAL LETTER B WITH STROKE
+0245..024B    ; Uncommon_Use                   # 5.0    [7] LATIN CAPITAL LETTER TURNED V..LATIN SMALL LETTER Q WITH HOOK TAIL
+024E..024F    ; Uncommon_Use                   # 5.0    [2] LATIN CAPITAL LETTER Y WITH STROKE..LATIN SMALL LETTER Y WITH STROKE
+0305          ; Uncommon_Use                   # 1.1        COMBINING OVERLINE
+030D          ; Uncommon_Use                   # 1.1        COMBINING VERTICAL LINE ABOVE
+0316          ; Uncommon_Use                   # 1.1        COMBINING GRAVE ACCENT BELOW
+0321..0322    ; Uncommon_Use                   # 1.1    [2] COMBINING PALATALIZED HOOK BELOW..COMBINING RETROFLEX HOOK BELOW
+0332          ; Uncommon_Use                   # 1.1        COMBINING LOW LINE
+0334          ; Uncommon_Use                   # 1.1        COMBINING TILDE OVERLAY
+0336          ; Uncommon_Use                   # 1.1        COMBINING LONG STROKE OVERLAY
+0358          ; Uncommon_Use                   # 4.1        COMBINING DOT ABOVE RIGHT
+0400          ; Uncommon_Use                   # 3.0        CYRILLIC CAPITAL LETTER IE WITH GRAVE
+040D          ; Uncommon_Use                   # 3.0        CYRILLIC CAPITAL LETTER I WITH GRAVE
+0450          ; Uncommon_Use                   # 3.0        CYRILLIC SMALL LETTER IE WITH GRAVE
+045D          ; Uncommon_Use                   # 3.0        CYRILLIC SMALL LETTER I WITH GRAVE
+048A..048B    ; Uncommon_Use                   # 3.2    [2] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER SHORT I WITH TAIL
+048C..048F    ; Uncommon_Use                   # 3.0    [4] CYRILLIC CAPITAL LETTER SEMISOFT SIGN..CYRILLIC SMALL LETTER ER WITH TICK
+04C1..04C4    ; Uncommon_Use                   # 1.1    [4] CYRILLIC CAPITAL LETTER ZHE WITH BREVE..CYRILLIC SMALL LETTER KA WITH HOOK
+04C5..04C6    ; Uncommon_Use                   # 3.2    [2] CYRILLIC CAPITAL LETTER EL WITH TAIL..CYRILLIC SMALL LETTER EL WITH TAIL
+04C7..04C8    ; Uncommon_Use                   # 1.1    [2] CYRILLIC CAPITAL LETTER EN WITH HOOK..CYRILLIC SMALL LETTER EN WITH HOOK
+04C9..04CA    ; Uncommon_Use                   # 3.2    [2] CYRILLIC CAPITAL LETTER EN WITH TAIL..CYRILLIC SMALL LETTER EN WITH TAIL
+04CB..04CC    ; Uncommon_Use                   # 1.1    [2] CYRILLIC CAPITAL LETTER KHAKASSIAN CHE..CYRILLIC SMALL LETTER KHAKASSIAN CHE
+04CD..04CE    ; Uncommon_Use                   # 3.2    [2] CYRILLIC CAPITAL LETTER EM WITH TAIL..CYRILLIC SMALL LETTER EM WITH TAIL
+04DA..04DB    ; Uncommon_Use                   # 1.1    [2] CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS..CYRILLIC SMALL LETTER SCHWA WITH DIAERESIS
+04EA..04EB    ; Uncommon_Use                   # 1.1    [2] CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS..CYRILLIC SMALL LETTER BARRED O WITH DIAERESIS
+04EC..04ED    ; Uncommon_Use                   # 3.0    [2] CYRILLIC CAPITAL LETTER E WITH DIAERESIS..CYRILLIC SMALL LETTER E WITH DIAERESIS
+04F6..04F7    ; Uncommon_Use                   # 4.1    [2] CYRILLIC CAPITAL LETTER GHE WITH DESCENDER..CYRILLIC SMALL LETTER GHE WITH DESCENDER
+04FA..04FF    ; Uncommon_Use                   # 5.0    [6] CYRILLIC CAPITAL LETTER GHE WITH STROKE AND HOOK..CYRILLIC SMALL LETTER HA WITH STROKE
+0510..0513    ; Uncommon_Use                   # 5.0    [4] CYRILLIC CAPITAL LETTER REVERSED ZE..CYRILLIC SMALL LETTER EL WITH HOOK
+0591..05A1    ; Uncommon_Use                   # 2.0   [17] HEBREW ACCENT ETNAHTA..HEBREW ACCENT PAZER
+05A3..05AF    ; Uncommon_Use                   # 2.0   [13] HEBREW ACCENT MUNAH..HEBREW MARK MASORA CIRCLE
+05B0..05B9    ; Uncommon_Use                   # 1.1   [10] HEBREW POINT SHEVA..HEBREW POINT HOLAM
+05BA          ; Uncommon_Use                   # 5.0        HEBREW POINT HOLAM HASER FOR VAV
+05BB..05BD    ; Uncommon_Use                   # 1.1    [3] HEBREW POINT QUBUTS..HEBREW POINT METEG
+05BF          ; Uncommon_Use                   # 1.1        HEBREW POINT RAFE
+05C1..05C2    ; Uncommon_Use                   # 1.1    [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT
+05C4          ; Uncommon_Use                   # 2.0        HEBREW MARK UPPER DOT
+05EF          ; Uncommon_Use                   # 11.0       HEBREW YOD TRIANGLE
+05F0..05F2    ; Uncommon_Use                   # 1.1    [3] HEBREW LIGATURE YIDDISH DOUBLE VAV..HEBREW LIGATURE YIDDISH DOUBLE YOD
+0610..0615    ; Uncommon_Use                   # 4.0    [6] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL HIGH TAH
+0616..061A    ; Uncommon_Use                   # 5.1    [5] ARABIC SMALL HIGH LIGATURE ALEF WITH LAM WITH YEH..ARABIC SMALL KASRA
+0656..0658    ; Uncommon_Use                   # 4.0    [3] ARABIC SUBSCRIPT ALEF..ARABIC MARK NOON GHUNNA
+0659..065E    ; Uncommon_Use                   # 4.1    [6] ARABIC ZWARAKAY..ARABIC FATHA WITH TWO DOTS
+065F          ; Uncommon_Use                   # 6.0        ARABIC WAVY HAMZA BELOW
+069B..069E    ; Uncommon_Use                   # 1.1    [4] ARABIC LETTER SEEN WITH THREE DOTS BELOW..ARABIC LETTER SAD WITH THREE DOTS ABOVE
+06A1          ; Uncommon_Use                   # 1.1        ARABIC LETTER DOTLESS FEH
+06A3          ; Uncommon_Use                   # 1.1        ARABIC LETTER FEH WITH DOT BELOW
+06B2          ; Uncommon_Use                   # 1.1        ARABIC LETTER GAF WITH TWO DOTS BELOW
+06B4          ; Uncommon_Use                   # 1.1        ARABIC LETTER GAF WITH THREE DOTS ABOVE
+06B8..06B9    ; Uncommon_Use                   # 3.0    [2] ARABIC LETTER LAM WITH THREE DOTS BELOW..ARABIC LETTER NOON WITH DOT BELOW
+06BF          ; Uncommon_Use                   # 3.0        ARABIC LETTER TCHEH WITH DOT ABOVE
+06D6..06DC    ; Uncommon_Use                   # 1.1    [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN
+06DF..06E4    ; Uncommon_Use                   # 1.1    [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA
+06E7..06E8    ; Uncommon_Use                   # 1.1    [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON
+06EA..06ED    ; Uncommon_Use                   # 1.1    [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM
+06FA..06FC    ; Uncommon_Use                   # 3.0    [3] ARABIC LETTER SHEEN WITH DOT BELOW..ARABIC LETTER GHAIN WITH DOT BELOW
+0750          ; Uncommon_Use                   # 4.1        ARABIC LETTER BEH WITH THREE DOTS HORIZONTALLY BELOW
+0753..0755    ; Uncommon_Use                   # 4.1    [3] ARABIC LETTER BEH WITH THREE DOTS POINTING UPWARDS BELOW AND TWO DOTS ABOVE..ARABIC LETTER BEH WITH INVERTED SMALL V BELOW
+0757..075F    ; Uncommon_Use                   # 4.1    [9] ARABIC LETTER HAH WITH TWO DOTS ABOVE..ARABIC LETTER AIN WITH TWO DOTS VERTICALLY ABOVE
+0761          ; Uncommon_Use                   # 4.1        ARABIC LETTER FEH WITH THREE DOTS POINTING UPWARDS BELOW
+0764..0765    ; Uncommon_Use                   # 4.1    [2] ARABIC LETTER KEHEH WITH THREE DOTS POINTING UPWARDS BELOW..ARABIC LETTER MEEM WITH DOT ABOVE
+0769          ; Uncommon_Use                   # 4.1        ARABIC LETTER NOON WITH SMALL V
+076B..076D    ; Uncommon_Use                   # 4.1    [3] ARABIC LETTER REH WITH TWO DOTS VERTICALLY ABOVE..ARABIC LETTER SEEN WITH TWO DOTS VERTICALLY ABOVE
+0772..077D    ; Uncommon_Use                   # 5.1   [12] ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH ABOVE..ARABIC LETTER SEEN WITH EXTENDED ARABIC-INDIC DIGIT FOUR ABOVE
+0889..088D    ; Uncommon_Use                   # 14.0   [5] ARABIC LETTER NOON WITH INVERTED SMALL V..ARABIC LETTER KEHEH WITH TWO DOTS VERTICALLY BELOW
+0897          ; Uncommon_Use                   # 16.0       ARABIC PEPET
+0898..089F    ; Uncommon_Use                   # 14.0   [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA
+08A1          ; Uncommon_Use                   # 7.0        ARABIC LETTER BEH WITH HAMZA ABOVE
+08AA..08AC    ; Uncommon_Use                   # 6.1    [3] ARABIC LETTER REH WITH LOOP..ARABIC LETTER ROHINGYA YEH
+08B2          ; Uncommon_Use                   # 7.0        ARABIC LETTER ZAIN WITH INVERTED V ABOVE
+08B3..08B4    ; Uncommon_Use                   # 8.0    [2] ARABIC LETTER AIN WITH THREE DOTS BELOW..ARABIC LETTER KAF WITH DOT BELOW
+08B6..08BA    ; Uncommon_Use                   # 9.0    [5] ARABIC LETTER BEH WITH SMALL MEEM ABOVE..ARABIC LETTER YEH WITH TWO DOTS BELOW AND SMALL NOON ABOVE
+08C3..08C6    ; Uncommon_Use                   # 13.0   [4] ARABIC LETTER GHAIN WITH THREE DOTS ABOVE..ARABIC LETTER JEEM WITH THREE DOTS BELOW
+08C8          ; Uncommon_Use                   # 14.0       ARABIC LETTER GRAF
+08CA..08D2    ; Uncommon_Use                   # 14.0   [9] ARABIC SMALL HIGH FARSI YEH..ARABIC LARGE ROUND DOT INSIDE CIRCLE BELOW
+08D3          ; Uncommon_Use                   # 11.0       ARABIC SMALL LOW WAW
+08D4..08E1    ; Uncommon_Use                   # 9.0   [14] ARABIC SMALL HIGH WORD AR-RUB..ARABIC SMALL HIGH SIGN SAFHA
+08E3          ; Uncommon_Use                   # 8.0        ARABIC TURNED DAMMA BELOW
+08E4..08FE    ; Uncommon_Use                   # 6.1   [27] ARABIC CURLY FATHA..ARABIC DAMMA WITH DOT
+08FF          ; Uncommon_Use                   # 7.0        ARABIC MARK SIDEWAYS NOON GHUNNA
+0900          ; Uncommon_Use                   # 5.2        DEVANAGARI SIGN INVERTED CANDRABINDU
+0904          ; Uncommon_Use                   # 4.0        DEVANAGARI LETTER SHORT A
+0929          ; Uncommon_Use                   # 1.1        DEVANAGARI LETTER NNNA
+0934          ; Uncommon_Use                   # 1.1        DEVANAGARI LETTER LLLA
+0944          ; Uncommon_Use                   # 1.1        DEVANAGARI VOWEL SIGN VOCALIC RR
+0955          ; Uncommon_Use                   # 5.2        DEVANAGARI VOWEL SIGN CANDRA LONG E
+0979..097A    ; Uncommon_Use                   # 5.2    [2] DEVANAGARI LETTER ZHA..DEVANAGARI LETTER HEAVY YA
+098C          ; Uncommon_Use                   # 1.1        BENGALI LETTER VOCALIC L
+09D7          ; Uncommon_Use                   # 1.1        BENGALI AU LENGTH MARK
+09FE          ; Uncommon_Use                   # 11.0       BENGALI SANDHI MARK
+0A01          ; Uncommon_Use                   # 4.0        GURMUKHI SIGN ADAK BINDI
+0A03          ; Uncommon_Use                   # 4.0        GURMUKHI SIGN VISARGA
+0A51          ; Uncommon_Use                   # 5.1        GURMUKHI SIGN UDAAT
+0A66..0A6F    ; Uncommon_Use                   # 1.1   [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE
+0A72..0A73    ; Uncommon_Use                   # 1.1    [2] GURMUKHI IRI..GURMUKHI URA
+0A75          ; Uncommon_Use                   # 5.1        GURMUKHI SIGN YAKASH
+0A81          ; Uncommon_Use                   # 1.1        GUJARATI SIGN CANDRABINDU
+0AF9          ; Uncommon_Use                   # 8.0        GUJARATI LETTER ZHA
+0AFA..0AFF    ; Uncommon_Use                   # 10.0   [6] GUJARATI SIGN SUKUN..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE
+0B0C          ; Uncommon_Use                   # 1.1        ORIYA LETTER VOCALIC L
+0B35          ; Uncommon_Use                   # 4.0        ORIYA LETTER VA
+0B44          ; Uncommon_Use                   # 5.1        ORIYA VOWEL SIGN VOCALIC RR
+0B55          ; Uncommon_Use                   # 13.0       ORIYA SIGN OVERLINE
+0B57          ; Uncommon_Use                   # 1.1        ORIYA AU LENGTH MARK
+0B62..0B63    ; Uncommon_Use                   # 5.1    [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL
+0B66..0B6F    ; Uncommon_Use                   # 1.1   [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE
+0BD7          ; Uncommon_Use                   # 1.1        TAMIL AU LENGTH MARK
+0BE6          ; Uncommon_Use                   # 4.1        TAMIL DIGIT ZERO
+0BE7..0BEF    ; Uncommon_Use                   # 1.1    [9] TAMIL DIGIT ONE..TAMIL DIGIT NINE
+0C01          ; Uncommon_Use                   # 1.1        TELUGU SIGN CANDRABINDU
+0C04          ; Uncommon_Use                   # 11.0       TELUGU SIGN COMBINING ANUSVARA ABOVE
+0C0C          ; Uncommon_Use                   # 1.1        TELUGU LETTER VOCALIC L
+0C31          ; Uncommon_Use                   # 1.1        TELUGU LETTER RRA
+0C3C          ; Uncommon_Use                   # 14.0       TELUGU SIGN NUKTA
+0C55..0C56    ; Uncommon_Use                   # 1.1    [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK
+0C5A          ; Uncommon_Use                   # 8.0        TELUGU LETTER RRRA
+0C5D          ; Uncommon_Use                   # 14.0       TELUGU LETTER NAKAARA POLLU
+0C62..0C63    ; Uncommon_Use                   # 5.1    [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL
+0C66..0C6F    ; Uncommon_Use                   # 1.1   [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE
+0C80          ; Uncommon_Use                   # 9.0        KANNADA SIGN SPACING CANDRABINDU
+0CBC          ; Uncommon_Use                   # 4.0        KANNADA SIGN NUKTA
+0CC4          ; Uncommon_Use                   # 1.1        KANNADA VOWEL SIGN VOCALIC RR
+0CD5..0CD6    ; Uncommon_Use                   # 1.1    [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK
+0CDD          ; Uncommon_Use                   # 14.0       KANNADA LETTER NAKAARA POLLU
+0CF3          ; Uncommon_Use                   # 15.0       KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT
+0D00          ; Uncommon_Use                   # 10.0       MALAYALAM SIGN COMBINING ANUSVARA ABOVE
+0D0C          ; Uncommon_Use                   # 1.1        MALAYALAM LETTER VOCALIC L
+0D29          ; Uncommon_Use                   # 6.0        MALAYALAM LETTER NNNA
+0D44          ; Uncommon_Use                   # 5.1        MALAYALAM VOWEL SIGN VOCALIC RR
+0D54..0D56    ; Uncommon_Use                   # 9.0    [3] MALAYALAM LETTER CHILLU M..MALAYALAM LETTER CHILLU LLL
+0D62..0D63    ; Uncommon_Use                   # 5.1    [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL
+0D66..0D6F    ; Uncommon_Use                   # 1.1   [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE
+0D8E          ; Uncommon_Use                   # 3.0        SINHALA LETTER IRUUYANNA
+0DE6..0DEF    ; Uncommon_Use                   # 7.0   [10] SINHALA LITH DIGIT ZERO..SINHALA LITH DIGIT NINE
+0E4E          ; Uncommon_Use                   # 1.1        THAI CHARACTER YAMAKKAN
+0E86          ; Uncommon_Use                   # 12.0       LAO LETTER PALI GHA
+0E89          ; Uncommon_Use                   # 12.0       LAO LETTER PALI CHA
+0E8C          ; Uncommon_Use                   # 12.0       LAO LETTER PALI JHA
+0E8E..0E93    ; Uncommon_Use                   # 12.0   [6] LAO LETTER PALI NYA..LAO LETTER PALI NNA
+0E98          ; Uncommon_Use                   # 12.0       LAO LETTER PALI DHA
+0EA0          ; Uncommon_Use                   # 12.0       LAO LETTER PALI BHA
+0EA8..0EA9    ; Uncommon_Use                   # 12.0   [2] LAO LETTER SANSKRIT SHA..LAO LETTER SANSKRIT SSA
+0EAC          ; Uncommon_Use                   # 12.0       LAO LETTER PALI LLA
+0EBA          ; Uncommon_Use                   # 12.0       LAO SIGN PALI VIRAMA
+0ECE          ; Uncommon_Use                   # 15.0       LAO YAMAKKAN
+0EDE..0EDF    ; Uncommon_Use                   # 6.1    [2] LAO LETTER KHMU GO..LAO LETTER KHMU NYO
+0F39          ; Uncommon_Use                   # 2.0        TIBETAN MARK TSA -PHRU
+0F6B..0F6C    ; Uncommon_Use                   # 5.1    [2] TIBETAN LETTER KKA..TIBETAN LETTER RRA
+0FAE..0FB0    ; Uncommon_Use                   # 3.0    [3] TIBETAN SUBJOINED LETTER ZHA..TIBETAN SUBJOINED LETTER -A
+1065..1074    ; Uncommon_Use                   # 5.1   [16] MYANMAR LETTER WESTERN PWO KAREN THA..MYANMAR VOWEL SIGN KAYAH EE
+108B..108E    ; Uncommon_Use                   # 5.1    [4] MYANMAR SIGN SHAN COUNCIL TONE-2..MYANMAR LETTER RUMAI PALAUNG FA
+1090..1099    ; Uncommon_Use                   # 5.1   [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE
+109A..109D    ; Uncommon_Use                   # 5.2    [4] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON AI
+10F7..10F8    ; Uncommon_Use                   # 3.2    [2] GEORGIAN LETTER YN..GEORGIAN LETTER ELIFI
+10FD..10FF    ; Uncommon_Use                   # 6.1    [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN
+1207          ; Uncommon_Use                   # 4.1        ETHIOPIC SYLLABLE HOA
+1287          ; Uncommon_Use                   # 4.1        ETHIOPIC SYLLABLE XOA
+12AF          ; Uncommon_Use                   # 4.1        ETHIOPIC SYLLABLE KOA
+12F8..12FF    ; Uncommon_Use                   # 3.0    [8] ETHIOPIC SYLLABLE DDA..ETHIOPIC SYLLABLE DDWA
+130F          ; Uncommon_Use                   # 4.1        ETHIOPIC SYLLABLE GOA
+131F          ; Uncommon_Use                   # 4.1        ETHIOPIC SYLLABLE GGWAA
+1347          ; Uncommon_Use                   # 4.1        ETHIOPIC SYLLABLE TZOA
+135A          ; Uncommon_Use                   # 3.0        ETHIOPIC SYLLABLE FYA
+135D..135E    ; Uncommon_Use                   # 6.0    [2] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING VOWEL LENGTH MARK
+135F          ; Uncommon_Use                   # 4.1        ETHIOPIC COMBINING GEMINATION MARK
+1380..138F    ; Uncommon_Use                   # 4.1   [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..ETHIOPIC SYLLABLE PWE
+179D..179E    ; Uncommon_Use                   # 3.0    [2] KHMER LETTER SHA..KHMER LETTER SSO
+17A9          ; Uncommon_Use                   # 3.0        KHMER INDEPENDENT VOWEL QUU
+17D7          ; Uncommon_Use                   # 3.0        KHMER SIGN LEK TOO
+1AC1..1ACE    ; Uncommon_Use                   # 14.0  [14] COMBINING LEFT PARENTHESIS ABOVE LEFT..COMBINING LATIN SMALL LETTER INSULAR T
+1C89..1C8A    ; Uncommon_Use                   # 16.0   [2] CYRILLIC CAPITAL LETTER TJE..CYRILLIC SMALL LETTER TJE
+1E02..1E0B    ; Uncommon_Use                   # 1.1   [10] LATIN CAPITAL LETTER B WITH DOT ABOVE..LATIN SMALL LETTER D WITH DOT ABOVE
+1E0E..1E11    ; Uncommon_Use                   # 1.1    [4] LATIN CAPITAL LETTER D WITH LINE BELOW..LATIN SMALL LETTER D WITH CEDILLA
+1E14..1E17    ; Uncommon_Use                   # 1.1    [4] LATIN CAPITAL LETTER E WITH MACRON AND GRAVE..LATIN SMALL LETTER E WITH MACRON AND ACUTE
+1E1C..1E1F    ; Uncommon_Use                   # 1.1    [4] LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE..LATIN SMALL LETTER F WITH DOT ABOVE
+1E22..1E23    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER H WITH DOT ABOVE..LATIN SMALL LETTER H WITH DOT ABOVE
+1E26..1E29    ; Uncommon_Use                   # 1.1    [4] LATIN CAPITAL LETTER H WITH DIAERESIS..LATIN SMALL LETTER H WITH CEDILLA
+1E2E..1E35    ; Uncommon_Use                   # 1.1    [8] LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE..LATIN SMALL LETTER K WITH LINE BELOW
+1E38..1E3B    ; Uncommon_Use                   # 1.1    [4] LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON..LATIN SMALL LETTER L WITH LINE BELOW
+1E40..1E41    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER M WITH DOT ABOVE..LATIN SMALL LETTER M WITH DOT ABOVE
+1E4C..1E59    ; Uncommon_Use                   # 1.1   [14] LATIN CAPITAL LETTER O WITH TILDE AND ACUTE..LATIN SMALL LETTER R WITH DOT ABOVE
+1E5C..1E61    ; Uncommon_Use                   # 1.1    [6] LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON..LATIN SMALL LETTER S WITH DOT ABOVE
+1E64..1E6B    ; Uncommon_Use                   # 1.1    [8] LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE..LATIN SMALL LETTER T WITH DOT ABOVE
+1E6E..1E6F    ; Uncommon_Use                   # 1.1    [2] LATIN CAPITAL LETTER T WITH LINE BELOW..LATIN SMALL LETTER T WITH LINE BELOW
+1E78..1E8B    ; Uncommon_Use                   # 1.1   [20] LATIN CAPITAL LETTER U WITH TILDE AND ACUTE..LATIN SMALL LETTER X WITH DOT ABOVE
+1E8E..1E91    ; Uncommon_Use                   # 1.1    [4] LATIN CAPITAL LETTER Y WITH DOT ABOVE..LATIN SMALL LETTER Z WITH CIRCUMFLEX
+1E94..1E99    ; Uncommon_Use                   # 1.1    [6] LATIN CAPITAL LETTER Z WITH LINE BELOW..LATIN SMALL LETTER Y WITH RING ABOVE
+2054          ; Uncommon_Use                   # 4.0        INVERTED UNDERTIE
+2C68..2C6C    ; Uncommon_Use                   # 5.0    [5] LATIN SMALL LETTER H WITH DESCENDER..LATIN SMALL LETTER Z WITH DESCENDER
+2D80..2D96    ; Uncommon_Use                   # 4.1   [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SYLLABLE GGWE
+2DA0..2DA6    ; Uncommon_Use                   # 4.1    [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SYLLABLE SSO
+2DA8..2DAE    ; Uncommon_Use                   # 4.1    [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SYLLABLE CCO
+2DB0..2DB6    ; Uncommon_Use                   # 4.1    [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SYLLABLE ZZO
+2DB8..2DBE    ; Uncommon_Use                   # 4.1    [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC SYLLABLE CCHO
+2DC0..2DC6    ; Uncommon_Use                   # 4.1    [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SYLLABLE QYO
+2DC8..2DCE    ; Uncommon_Use                   # 4.1    [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SYLLABLE KYO
+2DD0..2DD6    ; Uncommon_Use                   # 4.1    [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SYLLABLE XYO
+2DD8..2DDE    ; Uncommon_Use                   # 4.1    [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SYLLABLE GYO
+3099..309A    ; Uncommon_Use                   # 1.1    [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+3400..3446    ; Uncommon_Use                   # 3.0   [71] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-3446
+3448..3472    ; Uncommon_Use                   # 3.0   [43] CJK UNIFIED IDEOGRAPH-3448..CJK UNIFIED IDEOGRAPH-3472
+3474..34E3    ; Uncommon_Use                   # 3.0  [112] CJK UNIFIED IDEOGRAPH-3474..CJK UNIFIED IDEOGRAPH-34E3
+34E5..3576    ; Uncommon_Use                   # 3.0  [146] CJK UNIFIED IDEOGRAPH-34E5..CJK UNIFIED IDEOGRAPH-3576
+3578..359D    ; Uncommon_Use                   # 3.0   [38] CJK UNIFIED IDEOGRAPH-3578..CJK UNIFIED IDEOGRAPH-359D
+359F..35A0    ; Uncommon_Use                   # 3.0    [2] CJK UNIFIED IDEOGRAPH-359F..CJK UNIFIED IDEOGRAPH-35A0
+35A2..35AC    ; Uncommon_Use                   # 3.0   [11] CJK UNIFIED IDEOGRAPH-35A2..CJK UNIFIED IDEOGRAPH-35AC
+35AE..35BE    ; Uncommon_Use                   # 3.0   [17] CJK UNIFIED IDEOGRAPH-35AE..CJK UNIFIED IDEOGRAPH-35BE
+35C0..35CD    ; Uncommon_Use                   # 3.0   [14] CJK UNIFIED IDEOGRAPH-35C0..CJK UNIFIED IDEOGRAPH-35CD
+35CF..35F2    ; Uncommon_Use                   # 3.0   [36] CJK UNIFIED IDEOGRAPH-35CF..CJK UNIFIED IDEOGRAPH-35F2
+35F4..35FD    ; Uncommon_Use                   # 3.0   [10] CJK UNIFIED IDEOGRAPH-35F4..CJK UNIFIED IDEOGRAPH-35FD
+35FF..360D    ; Uncommon_Use                   # 3.0   [15] CJK UNIFIED IDEOGRAPH-35FF..CJK UNIFIED IDEOGRAPH-360D
+360F..3619    ; Uncommon_Use                   # 3.0   [11] CJK UNIFIED IDEOGRAPH-360F..CJK UNIFIED IDEOGRAPH-3619
+361B..3917    ; Uncommon_Use                   # 3.0  [765] CJK UNIFIED IDEOGRAPH-361B..CJK UNIFIED IDEOGRAPH-3917
+3919..395F    ; Uncommon_Use                   # 3.0   [71] CJK UNIFIED IDEOGRAPH-3919..CJK UNIFIED IDEOGRAPH-395F
+3961..396D    ; Uncommon_Use                   # 3.0   [13] CJK UNIFIED IDEOGRAPH-3961..CJK UNIFIED IDEOGRAPH-396D
+396F..39CE    ; Uncommon_Use                   # 3.0   [96] CJK UNIFIED IDEOGRAPH-396F..CJK UNIFIED IDEOGRAPH-39CE
+39D1..39DA    ; Uncommon_Use                   # 3.0   [10] CJK UNIFIED IDEOGRAPH-39D1..CJK UNIFIED IDEOGRAPH-39DA
+39DC..39DE    ; Uncommon_Use                   # 3.0    [3] CJK UNIFIED IDEOGRAPH-39DC..CJK UNIFIED IDEOGRAPH-39DE
+39E0..39F7    ; Uncommon_Use                   # 3.0   [24] CJK UNIFIED IDEOGRAPH-39E0..CJK UNIFIED IDEOGRAPH-39F7
+39F9..39FD    ; Uncommon_Use                   # 3.0    [5] CJK UNIFIED IDEOGRAPH-39F9..CJK UNIFIED IDEOGRAPH-39FD
+39FF..3A17    ; Uncommon_Use                   # 3.0   [25] CJK UNIFIED IDEOGRAPH-39FF..CJK UNIFIED IDEOGRAPH-3A17
+3A19..3A51    ; Uncommon_Use                   # 3.0   [57] CJK UNIFIED IDEOGRAPH-3A19..CJK UNIFIED IDEOGRAPH-3A51
+3A53..3A5B    ; Uncommon_Use                   # 3.0    [9] CJK UNIFIED IDEOGRAPH-3A53..CJK UNIFIED IDEOGRAPH-3A5B
+3A5D..3A66    ; Uncommon_Use                   # 3.0   [10] CJK UNIFIED IDEOGRAPH-3A5D..CJK UNIFIED IDEOGRAPH-3A66
+3A68..3A72    ; Uncommon_Use                   # 3.0   [11] CJK UNIFIED IDEOGRAPH-3A68..CJK UNIFIED IDEOGRAPH-3A72
+3A74..3B38    ; Uncommon_Use                   # 3.0  [197] CJK UNIFIED IDEOGRAPH-3A74..CJK UNIFIED IDEOGRAPH-3B38
+3B3A..3B4D    ; Uncommon_Use                   # 3.0   [20] CJK UNIFIED IDEOGRAPH-3B3A..CJK UNIFIED IDEOGRAPH-3B4D
+3B4F..3BA2    ; Uncommon_Use                   # 3.0   [84] CJK UNIFIED IDEOGRAPH-3B4F..CJK UNIFIED IDEOGRAPH-3BA2
+3BA4..3C6D    ; Uncommon_Use                   # 3.0  [202] CJK UNIFIED IDEOGRAPH-3BA4..CJK UNIFIED IDEOGRAPH-3C6D
+3C6F..3CDF    ; Uncommon_Use                   # 3.0  [113] CJK UNIFIED IDEOGRAPH-3C6F..CJK UNIFIED IDEOGRAPH-3CDF
+3CE1..3DE6    ; Uncommon_Use                   # 3.0  [262] CJK UNIFIED IDEOGRAPH-3CE1..CJK UNIFIED IDEOGRAPH-3DE6
+3DE8..3DEA    ; Uncommon_Use                   # 3.0    [3] CJK UNIFIED IDEOGRAPH-3DE8..CJK UNIFIED IDEOGRAPH-3DEA
+3DEC..3E73    ; Uncommon_Use                   # 3.0  [136] CJK UNIFIED IDEOGRAPH-3DEC..CJK UNIFIED IDEOGRAPH-3E73
+3E75..3ECF    ; Uncommon_Use                   # 3.0   [91] CJK UNIFIED IDEOGRAPH-3E75..CJK UNIFIED IDEOGRAPH-3ECF
+3ED1..4055    ; Uncommon_Use                   # 3.0  [389] CJK UNIFIED IDEOGRAPH-3ED1..CJK UNIFIED IDEOGRAPH-4055
+4057..4064    ; Uncommon_Use                   # 3.0   [14] CJK UNIFIED IDEOGRAPH-4057..CJK UNIFIED IDEOGRAPH-4064
+4066..4069    ; Uncommon_Use                   # 3.0    [4] CJK UNIFIED IDEOGRAPH-4066..CJK UNIFIED IDEOGRAPH-4069
+406B..40BA    ; Uncommon_Use                   # 3.0   [80] CJK UNIFIED IDEOGRAPH-406B..CJK UNIFIED IDEOGRAPH-40BA
+40BC..40DE    ; Uncommon_Use                   # 3.0   [35] CJK UNIFIED IDEOGRAPH-40BC..CJK UNIFIED IDEOGRAPH-40DE
+40E0..4136    ; Uncommon_Use                   # 3.0   [87] CJK UNIFIED IDEOGRAPH-40E0..CJK UNIFIED IDEOGRAPH-4136
+4138..415E    ; Uncommon_Use                   # 3.0   [39] CJK UNIFIED IDEOGRAPH-4138..CJK UNIFIED IDEOGRAPH-415E
+4160..4336    ; Uncommon_Use                   # 3.0  [471] CJK UNIFIED IDEOGRAPH-4160..CJK UNIFIED IDEOGRAPH-4336
+4338..43AB    ; Uncommon_Use                   # 3.0  [116] CJK UNIFIED IDEOGRAPH-4338..CJK UNIFIED IDEOGRAPH-43AB
+43AD..43B0    ; Uncommon_Use                   # 3.0    [4] CJK UNIFIED IDEOGRAPH-43AD..CJK UNIFIED IDEOGRAPH-43B0
+43B2..43D2    ; Uncommon_Use                   # 3.0   [33] CJK UNIFIED IDEOGRAPH-43B2..CJK UNIFIED IDEOGRAPH-43D2
+43D4..43DC    ; Uncommon_Use                   # 3.0    [9] CJK UNIFIED IDEOGRAPH-43D4..CJK UNIFIED IDEOGRAPH-43DC
+43DE..4442    ; Uncommon_Use                   # 3.0  [101] CJK UNIFIED IDEOGRAPH-43DE..CJK UNIFIED IDEOGRAPH-4442
+4444..44D5    ; Uncommon_Use                   # 3.0  [146] CJK UNIFIED IDEOGRAPH-4444..CJK UNIFIED IDEOGRAPH-44D5
+44D7..44E9    ; Uncommon_Use                   # 3.0   [19] CJK UNIFIED IDEOGRAPH-44D7..CJK UNIFIED IDEOGRAPH-44E9
+44EB..4605    ; Uncommon_Use                   # 3.0  [283] CJK UNIFIED IDEOGRAPH-44EB..CJK UNIFIED IDEOGRAPH-4605
+4607..464B    ; Uncommon_Use                   # 3.0   [69] CJK UNIFIED IDEOGRAPH-4607..CJK UNIFIED IDEOGRAPH-464B
+464D..4660    ; Uncommon_Use                   # 3.0   [20] CJK UNIFIED IDEOGRAPH-464D..CJK UNIFIED IDEOGRAPH-4660
+4662..4722    ; Uncommon_Use                   # 3.0  [193] CJK UNIFIED IDEOGRAPH-4662..CJK UNIFIED IDEOGRAPH-4722
+4724..4728    ; Uncommon_Use                   # 3.0    [5] CJK UNIFIED IDEOGRAPH-4724..CJK UNIFIED IDEOGRAPH-4728
+472A..477B    ; Uncommon_Use                   # 3.0   [82] CJK UNIFIED IDEOGRAPH-472A..CJK UNIFIED IDEOGRAPH-477B
+477D..478C    ; Uncommon_Use                   # 3.0   [16] CJK UNIFIED IDEOGRAPH-477D..CJK UNIFIED IDEOGRAPH-478C
+478E..47F3    ; Uncommon_Use                   # 3.0  [102] CJK UNIFIED IDEOGRAPH-478E..CJK UNIFIED IDEOGRAPH-47F3
+47F5..4881    ; Uncommon_Use                   # 3.0  [141] CJK UNIFIED IDEOGRAPH-47F5..CJK UNIFIED IDEOGRAPH-4881
+4883..4946    ; Uncommon_Use                   # 3.0  [196] CJK UNIFIED IDEOGRAPH-4883..CJK UNIFIED IDEOGRAPH-4946
+4948..4979    ; Uncommon_Use                   # 3.0   [50] CJK UNIFIED IDEOGRAPH-4948..CJK UNIFIED IDEOGRAPH-4979
+497B..497C    ; Uncommon_Use                   # 3.0    [2] CJK UNIFIED IDEOGRAPH-497B..CJK UNIFIED IDEOGRAPH-497C
+497E..4981    ; Uncommon_Use                   # 3.0    [4] CJK UNIFIED IDEOGRAPH-497E..CJK UNIFIED IDEOGRAPH-4981
+4984          ; Uncommon_Use                   # 3.0        CJK UNIFIED IDEOGRAPH-4984
+4987..499A    ; Uncommon_Use                   # 3.0   [20] CJK UNIFIED IDEOGRAPH-4987..CJK UNIFIED IDEOGRAPH-499A
+499C..499E    ; Uncommon_Use                   # 3.0    [3] CJK UNIFIED IDEOGRAPH-499C..CJK UNIFIED IDEOGRAPH-499E
+49A0..49B5    ; Uncommon_Use                   # 3.0   [22] CJK UNIFIED IDEOGRAPH-49A0..CJK UNIFIED IDEOGRAPH-49B5
+49B8..4A11    ; Uncommon_Use                   # 3.0   [90] CJK UNIFIED IDEOGRAPH-49B8..CJK UNIFIED IDEOGRAPH-4A11
+4A13..4AB7    ; Uncommon_Use                   # 3.0  [165] CJK UNIFIED IDEOGRAPH-4A13..CJK UNIFIED IDEOGRAPH-4AB7
+4AB9..4C76    ; Uncommon_Use                   # 3.0  [446] CJK UNIFIED IDEOGRAPH-4AB9..CJK UNIFIED IDEOGRAPH-4C76
+4C78..4C7C    ; Uncommon_Use                   # 3.0    [5] CJK UNIFIED IDEOGRAPH-4C78..CJK UNIFIED IDEOGRAPH-4C7C
+4C7E..4C80    ; Uncommon_Use                   # 3.0    [3] CJK UNIFIED IDEOGRAPH-4C7E..CJK UNIFIED IDEOGRAPH-4C80
+4C82..4C84    ; Uncommon_Use                   # 3.0    [3] CJK UNIFIED IDEOGRAPH-4C82..CJK UNIFIED IDEOGRAPH-4C84
+4C86..4C9C    ; Uncommon_Use                   # 3.0   [23] CJK UNIFIED IDEOGRAPH-4C86..CJK UNIFIED IDEOGRAPH-4C9C
+4CA4..4D12    ; Uncommon_Use                   # 3.0  [111] CJK UNIFIED IDEOGRAPH-4CA4..CJK UNIFIED IDEOGRAPH-4D12
+4D1A..4DAD    ; Uncommon_Use                   # 3.0  [148] CJK UNIFIED IDEOGRAPH-4D1A..CJK UNIFIED IDEOGRAPH-4DAD
+4DAF..4DB5    ; Uncommon_Use                   # 3.0    [7] CJK UNIFIED IDEOGRAPH-4DAF..CJK UNIFIED IDEOGRAPH-4DB5
+4DB6..4DBF    ; Uncommon_Use                   # 13.0  [10] CJK UNIFIED IDEOGRAPH-4DB6..CJK UNIFIED IDEOGRAPH-4DBF
+4E12          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4E12
+4E29          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4E29
+4E68          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4E68
+4E79          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4E79
+4E96          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4E96
+4EA3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4EA3
+4EBC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4EBC
+4ECC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4ECC
+4EE7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4EE7
+4EF8..4EFA    ; Uncommon_Use                   # 1.1    [3] CJK UNIFIED IDEOGRAPH-4EF8..CJK UNIFIED IDEOGRAPH-4EFA
+4EFC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4EFC
+4EFE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4EFE
+4F07          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F07
+4F16          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F16
+4F28          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F28
+4F31          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F31
+4F35          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F35
+4F37          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F37
+4F40          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F40
+4F44          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F44
+4F71          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F71
+4F8C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F8C
+4F8E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4F8E
+4FA2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4FA2
+4FBD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4FBD
+4FC6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4FC6
+4FC8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4FC8
+4FCC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4FCC
+4FE2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-4FE2
+4FFC..4FFD    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-4FFC..CJK UNIFIED IDEOGRAPH-4FFD
+5010          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5010
+5034          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5034
+5038          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5038
+503D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-503D
+5042          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5042
+5052          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5052
+5058          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5058
+507C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-507C
+5081          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5081
+5093          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5093
+5097          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5097
+509F..50A1    ; Uncommon_Use                   # 1.1    [3] CJK UNIFIED IDEOGRAPH-509F..CJK UNIFIED IDEOGRAPH-50A1
+50B9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-50B9
+50C3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-50C3
+50D8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-50D8
+50DF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-50DF
+50E1..50E2    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-50E1..CJK UNIFIED IDEOGRAPH-50E2
+50EB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-50EB
+50F4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-50F4
+50F7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-50F7
+511B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-511B
+5128          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5128
+512B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-512B
+5142          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5142
+514A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-514A
+514F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-514F
+5153          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5153
+5158          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5158
+5160          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5160
+5164          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5164
+5172          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5172
+517E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-517E
+5183..5184    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5183..CJK UNIFIED IDEOGRAPH-5184
+518E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-518E
+51A1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-51A1
+51A3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-51A3
+51AD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-51AD
+51B8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-51B8
+51BA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-51BA
+51C2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-51C2
+51D2..51D3    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-51D2..CJK UNIFIED IDEOGRAPH-51D3
+51DF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-51DF
+51EC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-51EC
+51EE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-51EE
+51F2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-51F2
+5253          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5253
+5266          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5266
+5279          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5279
+5285          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5285
+528E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-528E
+52C4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-52C4
+52C8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-52C8
+52CC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-52CC
+52CE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-52CE
+52D1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-52D1
+52D4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-52D4
+52E1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-52E1
+52E5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-52E5
+52EE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-52EE
+5303..5304    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5303..CJK UNIFIED IDEOGRAPH-5304
+5318          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5318
+531B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-531B
+531E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-531E
+5327          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5327
+5329          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5329
+5332          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5332
+5335..5336    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5335..CJK UNIFIED IDEOGRAPH-5336
+5342          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5342
+535B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-535B
+535D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-535D
+536A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-536A
+536D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-536D
+5380          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5380
+53A1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-53A1
+53AA..53AB    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-53AA..CJK UNIFIED IDEOGRAPH-53AB
+53AF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-53AF
+53BA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-53BA
+53C5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-53C5
+53CF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-53CF
+53DD..53DE    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-53DD..CJK UNIFIED IDEOGRAPH-53DE
+53E7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-53E7
+53FF..5400    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-53FF..CJK UNIFIED IDEOGRAPH-5400
+541A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-541A
+5422          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5422
+544C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-544C
+545D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-545D
+5469          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5469
+548A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-548A
+54B5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-54B5
+54F6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-54F6
+5515          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5515
+5518..5519    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5518..CJK UNIFIED IDEOGRAPH-5519
+5547          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5547
+5560          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5560
+557A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-557A
+55E0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-55E0
+55F8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-55F8
+560A..560B    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-560A..CJK UNIFIED IDEOGRAPH-560B
+5620          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5620
+562B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-562B
+5637          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5637
+563C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-563C
+5644          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5644
+564B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-564B
+5651          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5651
+5656          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5656
+565F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-565F
+5661          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5661
+5675          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5675
+567D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-567D
+5688          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5688
+568B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-568B
+5696          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5696
+569E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-569E
+56BA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-56BA
+56CF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-56CF
+56D9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-56D9
+56E6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-56E6
+56F6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-56F6
+56F8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-56F8
+56FB..56FC    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-56FB..CJK UNIFIED IDEOGRAPH-56FC
+5705          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5705
+5711          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5711
+5717          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5717
+5721          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5721
+5724          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5724
+573D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-573D
+5743          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5743
+5748          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5748
+5755..5756    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5755..CJK UNIFIED IDEOGRAPH-5756
+5758          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5758
+5763          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5763
+5778          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5778
+5781          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5781
+5787          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5787
+5796          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5796
+57A8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-57A8
+57CA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-57CA
+57D1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-57D1
+57DB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-57DB
+5817..5818    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5817..CJK UNIFIED IDEOGRAPH-5818
+5850          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5850
+5856          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5856
+5860          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5860
+5866..5867    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5866..CJK UNIFIED IDEOGRAPH-5867
+5877          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5877
+5895          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5895
+58AA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-58AA
+58B6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-58B6
+58C0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-58C0
+58C3..58C4    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-58C3..CJK UNIFIED IDEOGRAPH-58C4
+58CD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-58CD
+58D0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-58D0
+58E1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-58E1
+58E6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-58E6
+58F5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-58F5
+5901          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5901
+5905          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5905
+5908          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5908
+5911          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5911
+5913          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5913
+5923          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5923
+5933          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5933
+5936          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5936
+5959          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5959
+595B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-595B
+59B7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-59B7
+59E7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-59E7
+5A24          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5A24
+5A26          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5A26
+5A2C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5A2C
+5A30          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5A30
+5A54          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5A54
+5A59          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5A59
+5A6F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5A6F
+5A71          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5A71
+5A87          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5A87
+5A8D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5A8D
+5AAB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5AAB
+5AD3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5AD3
+5AEF..5AF0    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5AEF..CJK UNIFIED IDEOGRAPH-5AF0
+5B0A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B0A
+5B0D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B0D
+5B39          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B39
+5B46          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B46
+5B4F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B4F
+5B52          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B52
+5B60..5B61    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5B60..CJK UNIFIED IDEOGRAPH-5B61
+5B6F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B6F
+5B79          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B79
+5B7E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B7E
+5B86          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B86
+5B90          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5B90
+5BA9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5BA9
+5BB2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5BB2
+5BB7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5BB7
+5BBC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5BBC
+5BC8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5BC8
+5BDA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5BDA
+5C00          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5C00
+5C1B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5C1B
+5C23          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5C23
+5C26          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5C26
+5C29          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5C29
+5C36          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5C36
+5C5A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5C5A
+5C85          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5C85
+5CB4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5CB4
+5CB9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5CB9
+5CD5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5CD5
+5CDD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5CDD
+5CF5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5CF5
+5D2B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5D2B
+5D2F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5D2F
+5D3B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5D3B
+5D53          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5D53
+5D57          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5D57
+5D60          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5D60
+5D83          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5D83
+5D96          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5D96
+5DA3..5DA4    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5DA3..CJK UNIFIED IDEOGRAPH-5DA4
+5DAB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5DAB
+5DB3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5DB3
+5DB9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5DB9
+5DC4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5DC4
+5DD7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5DD7
+5DDA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5DDA
+5DDC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5DDC
+5DF6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5DF6
+5E12          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5E12
+5E48          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5E48
+5E51          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5E51
+5E92          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5E92
+5EBA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5EBA
+5EC0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5EC0
+5EEB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5EEB
+5EF9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5EF9
+5F0E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5F0E
+5F3B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5F3B
+5F3D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5F3D
+5F8F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5F8F
+5F9A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5F9A
+5FA3..5FA4    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-5FA3..CJK UNIFIED IDEOGRAPH-5FA4
+5FB0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5FB0
+5FC2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5FC2
+5FCE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5FCE
+5FDB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5FDB
+5FE2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5FE2
+5FEC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5FEC
+5FFC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-5FFC
+6023          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6023
+6056          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6056
+6061          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6061
+6071          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6071
+6074          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6074
+6091          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6091
+6093          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6093
+60A5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-60A5
+60D2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-60D2
+60D6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-60D6
+60DE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-60DE
+60E5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-60E5
+60FD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-60FD
+6102          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6102
+6107          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6107
+6111          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6111
+611E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-611E
+6131          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6131
+6133          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6133
+6135          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6135
+6138..6139    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-6138..CJK UNIFIED IDEOGRAPH-6139
+6160          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6160
+617B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-617B
+617F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-617F
+6186          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6186
+6197          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6197
+619C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-619C
+61B9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-61B9
+61BB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-61BB
+61D3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-61D3
+61D5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-61D5
+61EC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-61EC
+61EF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-61EF
+6205          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6205
+6235          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6235
+6239          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6239
+6257          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6257
+628D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-628D
+629D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-629D
+62DE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-62DE
+62EA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-62EA
+630A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-630A
+6317          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6317
+6331          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6331
+6337          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6337
+635B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-635B
+638B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-638B
+6393          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6393
+63D1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-63D1
+643B..643C    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-643B..CJK UNIFIED IDEOGRAPH-643C
+6449          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6449
+645A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-645A
+647E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-647E
+6486          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6486
+64A1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-64A1
+64AF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-64AF
+64B6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-64B6
+64C8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-64C8
+64D5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-64D5
+64EE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-64EE
+64F5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-64F5
+64F9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-64F9
+6502          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6502
+650A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-650A
+651F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-651F
+6528          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6528
+6540          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6540
+6542          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6542
+655A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-655A
+655F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-655F
+657D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-657D
+658A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-658A
+659A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-659A
+65B5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-65B5
+65BE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-65BE
+65C8..65C9    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-65C8..CJK UNIFIED IDEOGRAPH-65C9
+65D1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-65D1
+65D8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-65D8
+65DC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-65DC
+65E4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-65E4
+65EA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-65EA
+65F9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-65F9
+65FE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-65FE
+6617          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6617
+662C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-662C
+6637..6638    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-6637..CJK UNIFIED IDEOGRAPH-6638
+6648          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6648
+664D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-664D
+6660          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6660
+6663          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6663
+6692          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6692
+669C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-669C
+669E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-669E
+66AC..66AD    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-66AC..CJK UNIFIED IDEOGRAPH-66AD
+66D0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-66D0
+66D3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-66D3
+66D7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-66D7
+66DF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-66DF
+66EF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-66EF
+6702          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6702
+6707          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6707
+6719          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6719
+6724          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6724
+6729          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6729
+6767          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6767
+6788          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6788
+6796          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6796
+67BD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-67BD
+67BF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-67BF
+67D5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-67D5
+67D7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-67D7
+67F9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-67F9
+6801          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6801
+6815          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6815
+6827          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6827
+6830          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6830
+6858          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6858
+685A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-685A
+685E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-685E
+687A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-687A
+6895          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6895
+6899          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6899
+68A5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-68A5
+68B8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-68B8
+68C3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-68C3
+68D9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-68D9
+68E2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-68E2
+68E5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-68E5
+6909          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6909
+693E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-693E
+694D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-694D
+699F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-699F
+69A2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-69A2
+69C0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-69C0
+69D1..69D2    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-69D1..CJK UNIFIED IDEOGRAPH-69D2
+69D5..69D7    ; Uncommon_Use                   # 1.1    [3] CJK UNIFIED IDEOGRAPH-69D5..CJK UNIFIED IDEOGRAPH-69D7
+6A03          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A03
+6A1C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A1C
+6A24          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A24
+6A37          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A37
+6A4A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A4A
+6A5C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A5C
+6A6E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A6E
+6A70          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A70
+6A86          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A86
+6A8A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A8A
+6A8F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A8F
+6A99          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A99
+6A9D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6A9D
+6AB1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6AB1
+6ABE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6ABE
+6AC0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6AC0
+6AC4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6AC4
+6AC9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6AC9
+6AD8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6AD8
+6AE9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6AE9
+6B0E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B0E
+6B1B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B1B
+6B2E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B2E
+6B35          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B35
+6B40          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B40
+6B57..6B58    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-6B57..CJK UNIFIED IDEOGRAPH-6B58
+6B5D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B5D
+6B68          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B68
+6B6C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B6C
+6B6E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B6E
+6B71          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B71
+6B75          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B75
+6B7D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6B7D
+6BB8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6BB8
+6BE9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6BE9
+6BF1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6BF1
+6BF4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6BF4
+6BFA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6BFA
+6C0A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6C0A
+6C1C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6C1C
+6C2D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6C2D
+6C3C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6C3C
+6C45          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6C45
+6C6C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6C6C
+6C6E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6C6E
+6CA0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6CA0
+6CD8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6CD8
+6CF4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6CF4
+6D02          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6D02
+6D1C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6D1C
+6D24          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6D24
+6D71          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6D71
+6D81          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6D81
+6D96          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6D96
+6DB0..6DB1    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-6DB0..CJK UNIFIED IDEOGRAPH-6DB1
+6DB6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6DB6
+6DFE..6DFF    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-6DFE..CJK UNIFIED IDEOGRAPH-6DFF
+6E01..6E02    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-6E01..CJK UNIFIED IDEOGRAPH-6E02
+6E06          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6E06
+6E12          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6E12
+6E18          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6E18
+6E2A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6E2A
+6E4C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6E4C
+6E6C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6E6C
+6E7B..6E7D    ; Uncommon_Use                   # 1.1    [3] CJK UNIFIED IDEOGRAPH-6E7B..CJK UNIFIED IDEOGRAPH-6E7D
+6E8B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6E8B
+6E95          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6E95
+6EDB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6EDB
+6EE3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6EE3
+6F04          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6F04
+6F0B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6F0B
+6F42          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6F42
+6F48          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6F48
+6F4A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6F4A
+6F79          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6F79
+6F98          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6F98
+6F9A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6F9A
+6F9F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6F9F
+6FB7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6FB7
+6FC5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6FC5
+6FD0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6FD0
+6FD3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6FD3
+6FF5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6FF5
+6FFD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-6FFD
+7010          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7010
+7013          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7013
+7047          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7047
+704B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-704B
+704E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-704E
+7072..7073    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7072..CJK UNIFIED IDEOGRAPH-7073
+707B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-707B
+7081          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7081
+708D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-708D
+7097          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7097
+709B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-709B
+70AA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-70AA
+70B2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-70B2
+70B6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-70B6
+70D5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-70D5
+70FE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-70FE
+7108          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7108
+7124          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7124
+7133..7134    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7133..CJK UNIFIED IDEOGRAPH-7134
+7157          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7157
+716B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-716B
+716D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-716D
+718D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-718D
+7196          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7196
+71A6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-71A6
+71AB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-71AB
+71B6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-71B6
+71CC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-71CC
+71D3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-71D3
+71F3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-71F3
+71FA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-71FA
+720B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-720B
+7211          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7211
+7215          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7215
+7217          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7217
+7220          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7220
+7224..7225    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7224..CJK UNIFIED IDEOGRAPH-7225
+722F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-722F
+7234          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7234
+7245          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7245
+724E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-724E
+7250          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7250
+7255          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7255
+72AB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-72AB
+72BE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-72BE
+7302          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7302
+7310          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7310
+7328          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7328
+7353          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7353
+739C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-739C
+73C1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-73C1
+73F3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-73F3
+73FB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-73FB
+7418          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7418
+7439          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7439
+743E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-743E
+7447          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7447
+7449          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7449
+7458          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7458
+747B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-747B
+7484          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7484
+7496          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7496
+749D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-749D
+74C7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-74C7
+74C9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-74C9
+74CC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-74CC
+74EB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-74EB
+7520          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7520
+7541          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7541
+7552          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7552
+7555          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7555
+755E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-755E
+7561          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7561
+7571          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7571
+757B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-757B
+7585          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7585
+75A9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-75A9
+75B7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-75B7
+75DC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-75DC
+75EE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-75EE
+762C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-762C
+7644..7645    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7644..CJK UNIFIED IDEOGRAPH-7645
+7651          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7651
+7655          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7655
+7673          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7673
+768D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-768D
+76A1..76A2    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-76A1..CJK UNIFIED IDEOGRAPH-76A2
+76A5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-76A5
+76A8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-76A8
+76B3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-76B3
+76B6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-76B6
+76C1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-76C1
+76CB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-76CB
+76D9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-76D9
+76EB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-76EB
+7700          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7700
+7702          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7702
+770E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-770E
+7721          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7721
+772B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-772B
+773F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-773F
+7742          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7742
+7764          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7764
+7796          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7796
+77A4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-77A4
+77BE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-77BE
+77C1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-77C1
+77D2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-77D2
+77DD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-77DD
+77E4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-77E4
+77E6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-77E6
+77F4..77F5    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-77F4..CJK UNIFIED IDEOGRAPH-77F5
+7824          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7824
+7836          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7836
+7842          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7842
+7846          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7846
+784B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-784B
+7876          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7876
+7888          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7888
+78C2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-78C2
+78C7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-78C7
+78D2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-78D2
+78F0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-78F0
+78F8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-78F8
+7900          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7900
+7908          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7908
+790D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-790D
+7915          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7915
+791F..7920    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-791F..CJK UNIFIED IDEOGRAPH-7920
+7932          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7932
+7936          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7936
+7959          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7959
+796C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-796C
+796E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-796E
+7975..7976    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7975..CJK UNIFIED IDEOGRAPH-7976
+7986..7987    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7986..CJK UNIFIED IDEOGRAPH-7987
+799E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-799E
+79A9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-79A9
+79BC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-79BC
+79C4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-79C4
+79C7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-79C7
+79CC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-79CC
+79D4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-79D4
+79D7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-79D7
+7A01          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7A01
+7A07          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7A07
+7A09          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7A09
+7A2C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7A2C
+7A38          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7A38
+7A3A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7A3A
+7A64          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7A64
+7A6A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7A6A
+7A6F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7A6F
+7A82          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7A82
+7A9A..7A9B    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7A9A..CJK UNIFIED IDEOGRAPH-7A9B
+7AB9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7AB9
+7ABB..7ABD    ; Uncommon_Use                   # 1.1    [3] CJK UNIFIED IDEOGRAPH-7ABB..CJK UNIFIED IDEOGRAPH-7ABD
+7AC2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7AC2
+7AC6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7AC6
+7AE9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7AE9
+7AF5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7AF5
+7AFC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7AFC
+7B07          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7B07
+7B1F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7B1F
+7B27          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7B27
+7B29          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7B29
+7B42          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7B42
+7B53          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7B53
+7BA3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7BA3
+7BA5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7BA5
+7BB0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7BB0
+7BB2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7BB2
+7BFA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7BFA
+7C1B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7C1B
+7C2E..7C2F    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7C2E..CJK UNIFIED IDEOGRAPH-7C2F
+7C52          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7C52
+7C55          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7C55
+7C5D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7C5D
+7C76          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7C76
+7C87          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7C87
+7C93          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7C93
+7C9A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7C9A
+7CAC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7CAC
+7CD3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7CD3
+7CDA..7CDB    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7CDA..CJK UNIFIED IDEOGRAPH-7CDB
+7CE1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7CE1
+7CE3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7CE3
+7CE5..7CE6    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7CE5..CJK UNIFIED IDEOGRAPH-7CE6
+7CFC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7CFC
+7CFF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7CFF
+7D23          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D23
+7D2A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D2A
+7D2D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D2D
+7D48          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D48
+7D4D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D4D
+7D5A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D5A
+7D64          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D64
+7D78          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D78
+7D82          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D82
+7D95          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D95
+7D98          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7D98
+7DA4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7DA4
+7DA8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7DA8
+7DCD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7DCD
+7DD3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7DD3
+7DE5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7DE5
+7DEB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7DEB
+7DFD..7DFF    ; Uncommon_Use                   # 1.1    [3] CJK UNIFIED IDEOGRAPH-7DFD..CJK UNIFIED IDEOGRAPH-7DFF
+7E18          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7E18
+7E5B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7E5B
+7E64          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7E64
+7E9D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7E9D
+7F3B..7F3C    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-7F3B..CJK UNIFIED IDEOGRAPH-7F3C
+7F41          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7F41
+7F46          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7F46
+7F59          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7F59
+7F84          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7F84
+7F90          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7F90
+7F97          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7F97
+7F99          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7F99
+7FB4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7FB4
+7FD6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7FD6
+7FDD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7FDD
+7FE4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-7FE4
+800A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-800A
+802F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-802F
+803C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-803C
+8040          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8040
+8066          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8066
+8088          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8088
+808E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-808E
+8094          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8094
+80A6..80A8    ; Uncommon_Use                   # 1.1    [3] CJK UNIFIED IDEOGRAPH-80A6..CJK UNIFIED IDEOGRAPH-80A8
+80B3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-80B3
+80B9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-80B9
+80DF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-80DF
+8103..8104    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-8103..CJK UNIFIED IDEOGRAPH-8104
+8134..8135    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-8134..CJK UNIFIED IDEOGRAPH-8135
+8184          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8184
+8190          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8190
+8196          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8196
+81CB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-81CB
+81E4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-81E4
+81EF..81F0    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-81EF..CJK UNIFIED IDEOGRAPH-81F0
+8213          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8213
+8224          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8224
+8241          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8241
+8265          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8265
+828C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-828C
+82B2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-82B2
+82E2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-82E2
+82FC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-82FC
+830A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-830A
+8310          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8310
+8330          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8330
+8355          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8355
+83BE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-83BE
+83E6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-83E6
+83ED          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-83ED
+8414          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8414
+8416..8417    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-8416..CJK UNIFIED IDEOGRAPH-8417
+841F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-841F
+8458          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8458
+8483          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8483
+8495          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8495
+84B7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-84B7
+84C3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-84C3
+84ED          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-84ED
+8505          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8505
+8510          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8510
+8532..8533    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-8532..CJK UNIFIED IDEOGRAPH-8533
+854C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-854C
+8550          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8550
+857F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-857F
+8593          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8593
+85B2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-85B2
+85BB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-85BB
+85CC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-85CC
+85EE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-85EE
+85F3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-85F3
+85FC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-85FC
+8603          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8603
+860D..860E    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-860D..CJK UNIFIED IDEOGRAPH-860E
+8610          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8610
+8615          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8615
+861D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-861D
+8637          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8637
+8657          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8657
+8675          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8675
+8689          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8689
+8692          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8692
+86A0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-86A0
+86A6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-86A6
+86D5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-86D5
+86E0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-86E0
+86E7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-86E7
+86FD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-86FD
+871D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-871D
+872F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-872F
+873D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-873D
+8745          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8745
+8771          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8771
+878E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-878E
+8799          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8799
+87DA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-87DA
+87F0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-87F0
+8807          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8807
+8812          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8812
+882D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-882D
+883A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-883A
+8847          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8847
+8858          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8858
+885C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-885C
+885F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-885F
+887A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-887A
+88E6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-88E6
+88E9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-88E9
+88ED          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-88ED
+8903          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8903
+890F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-890F
+8924          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8924
+8965          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8965
+8975          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8975
+897D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-897D
+898D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-898D
+8990          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8990
+8994          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8994
+8999          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8999
+89B0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-89B0
+89B4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-89B4
+89BB..89BC    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-89BB..CJK UNIFIED IDEOGRAPH-89BC
+89EE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-89EE
+89F5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-89F5
+89F9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-89F9
+89FD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-89FD
+8A05..8A06    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-8A05..CJK UNIFIED IDEOGRAPH-8A06
+8A14          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8A14
+8A19          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8A19
+8A20..8A21    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-8A20..CJK UNIFIED IDEOGRAPH-8A21
+8A2B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8A2B
+8A3D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8A3D
+8A4B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8A4B
+8A64          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8A64
+8A78          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8A78
+8A7D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8A7D
+8A88          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8A88
+8A9F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8A9F
+8AAF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8AAF
+8AB7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8AB7
+8AD0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8AD0
+8AEC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8AEC
+8B29          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B29
+8B32          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B32
+8B38          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B38
+8B3F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B3F
+8B61..8B62    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-8B61..CJK UNIFIED IDEOGRAPH-8B62
+8B69          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B69
+8B75          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B75
+8B7C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B7C
+8B81          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B81
+8B87          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B87
+8B8D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B8D
+8B8F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B8F
+8B9B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8B9B
+8C38          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8C38
+8C40          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8C40
+8C44          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8C44
+8C51..8C53    ; Uncommon_Use                   # 1.1    [3] CJK UNIFIED IDEOGRAPH-8C51..CJK UNIFIED IDEOGRAPH-8C53
+8C58          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8C58
+8C74          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8C74
+8C7F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8C7F
+8C83          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8C83
+8C87          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8C87
+8C8B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8C8B
+8C9B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8C9B
+8CA6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8CA6
+8CCB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8CCB
+8CD6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8CD6
+8CD8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8CD8
+8CE9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8CE9
+8CF7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8CF7
+8D01          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8D01
+8D11..8D12    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-8D11..CJK UNIFIED IDEOGRAPH-8D12
+8D7C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8D7C
+8DA6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8DA6
+8DC0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8DC0
+8DE5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8DE5
+8E01          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8E01
+8E0B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8E0B
+8E32          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8E32
+8E46          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8E46
+8E4F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8E4F
+8E6E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8E6E
+8E75          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8E75
+8E77          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8E77
+8E79          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8E79
+8E9B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8E9B
+8EA2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8EA2
+8EB3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8EB3
+8EB6..8EB7    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-8EB6..CJK UNIFIED IDEOGRAPH-8EB7
+8EC1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8EC1
+8EC4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8EC4
+8ED9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8ED9
+8EF0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8EF0
+8F0F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8F0F
+8F2D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8F2D
+8F3A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8F3A
+8F41          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8F41
+8F9D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8F9D
+8FA4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8FA4
+8FB3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8FB3
+8FC3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8FC3
+8FCA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8FCA
+8FE7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-8FE7
+902A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-902A
+902C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-902C
+9037          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9037
+9040          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9040
+9046          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9046
+90AB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-90AB
+90CC..90CD    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-90CC..CJK UNIFIED IDEOGRAPH-90CD
+90D2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-90D2
+90F6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-90F6
+910A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-910A
+913C..913D    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-913C..CJK UNIFIED IDEOGRAPH-913D
+9159          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9159
+917B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-917B
+9195          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9195
+9198          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9198
+91A9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-91A9
+91BF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-91BF
+91C4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-91C4
+91E0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-91E0
+91EF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-91EF
+9213          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9213
+921F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-921F
+9222          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9222
+9243          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9243
+9269..926A    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9269..CJK UNIFIED IDEOGRAPH-926A
+9281          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9281
+9284          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9284
+929E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-929E
+92BD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-92BD
+92D4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-92D4
+92DB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-92DB
+92E2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-92E2
+931C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-931C
+9330..9331    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9330..CJK UNIFIED IDEOGRAPH-9331
+9362          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9362
+9368          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9368
+936B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-936B
+936F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-936F
+9373          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9373
+9378          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9378
+937F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-937F
+9381          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9381
+938B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-938B
+939C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-939C
+93A0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-93A0
+93AB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-93AB
+93BB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-93BB
+93E0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-93E0
+93F3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-93F3
+9402          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9402
+9417          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9417
+941C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-941C
+941E..941F    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-941E..CJK UNIFIED IDEOGRAPH-941F
+9424          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9424
+9443          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9443
+944E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-944E
+946C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-946C
+947B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-947B
+9578..9579    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9578..CJK UNIFIED IDEOGRAPH-9579
+957E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-957E
+9585          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9585
+9597          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9597
+95B3..95B4    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-95B3..CJK UNIFIED IDEOGRAPH-95B4
+95B8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-95B8
+95C1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-95C1
+95D9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-95D9
+95DD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-95DD
+9625..9626    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9625..CJK UNIFIED IDEOGRAPH-9626
+9629          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9629
+963E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-963E
+9656..9657    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9656..CJK UNIFIED IDEOGRAPH-9657
+9679          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9679
+967B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-967B
+967F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-967F
+9681..9682    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9681..CJK UNIFIED IDEOGRAPH-9682
+968C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-968C
+9696          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9696
+969A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-969A
+969D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-969D
+969F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-969F
+96AB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-96AB
+96AF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-96AF
+96B5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-96B5
+96E4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-96E4
+96E6..96E7    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-96E6..CJK UNIFIED IDEOGRAPH-96E7
+96FC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-96FC
+9714          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9714
+9717          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9717
+971A..971B    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-971A..CJK UNIFIED IDEOGRAPH-971B
+9733..9734    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9733..CJK UNIFIED IDEOGRAPH-9734
+9737          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9737
+9740..9741    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9740..CJK UNIFIED IDEOGRAPH-9741
+974D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-974D
+9757          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9757
+9763          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9763
+9775          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9775
+9787          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9787
+9789          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9789
+979B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-979B
+97A9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-97A9
+97B0..97B1    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-97B0..CJK UNIFIED IDEOGRAPH-97B1
+97B5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-97B5
+97BE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-97BE
+97C0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-97C0
+97D2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-97D2
+97FC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-97FC
+981F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-981F
+9825          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9825
+982A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-982A
+9833          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9833
+983A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-983A
+983E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-983E
+9842          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9842
+9847          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9847
+9856          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9856
+9866          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9866
+9868          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9868
+98B7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-98B7
+98CA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-98CA
+98E4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-98E4
+98EC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-98EC
+98F1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-98F1
+98F8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-98F8
+98FB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-98FB
+9919          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9919
+993B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-993B
+9944          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9944
+995A          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-995A
+995D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-995D
+99BF          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-99BF
+99E0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-99E0
+99E6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-99E6
+99EB          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-99EB
+99F5          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-99F5
+9A10          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9A10
+9A17..9A18    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9A17..CJK UNIFIED IDEOGRAPH-9A18
+9A3B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9A3B
+9A51          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9A51
+9A58          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9A58
+9A5D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9A5D
+9A63          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9A63
+9AA9          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9AA9
+9ABD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9ABD
+9AC8          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9AC8
+9AD7          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9AD7
+9AE0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9AE0
+9AE4          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9AE4
+9AE8..9AE9    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9AE8..CJK UNIFIED IDEOGRAPH-9AE9
+9AF0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9AF0
+9B00          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B00
+9B02          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B02
+9B09          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B09
+9B14          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B14
+9B1B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B1B
+9B34          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B34
+9B3D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B3D
+9B40          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B40
+9B50          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B50
+9B57          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B57
+9B62          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B62
+9B72          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B72
+9B89          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B89
+9B8C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B8C
+9B99          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9B99
+9BC2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9BC2
+9BF6          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9BF6
+9C00..9C01    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9C00..CJK UNIFIED IDEOGRAPH-9C01
+9C03          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9C03
+9C42          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9C42
+9C4F          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9C4F
+9C51          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9C51
+9C61          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9C61
+9C64          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9C64
+9C7B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9C7B
+9D0C..9D0D    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9D0C..CJK UNIFIED IDEOGRAPH-9D0D
+9D11          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9D11
+9D27          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9D27
+9D35          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9D35
+9D3C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9D3C
+9D6D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9D6D
+9D95          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9D95
+9DAE          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9DAE
+9DBD          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9DBD
+9DC0          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9DC0
+9DEA          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9DEA
+9DFC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9DFC
+9E0E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9E0E
+9E16          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9E16
+9E1C          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9E1C
+9E7B          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9E7B
+9E8F..9E90    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9E8F..CJK UNIFIED IDEOGRAPH-9E90
+9E98          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9E98
+9E9E          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9E9E
+9EA2          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9EA2
+9EAB..9EAC    ; Uncommon_Use                   # 1.1    [2] CJK UNIFIED IDEOGRAPH-9EAB..CJK UNIFIED IDEOGRAPH-9EAC
+9EB1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9EB1
+9EEC          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9EEC
+9EF1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9EF1
+9F03          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9F03
+9F11          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9F11
+9F14          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9F14
+9F26          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9F26
+9F45          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9F45
+9F53          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9F53
+9F6D          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9F6D
+9FA1          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9FA1
+9FA3          ; Uncommon_Use                   # 1.1        CJK UNIFIED IDEOGRAPH-9FA3
+9FA6..9FBB    ; Uncommon_Use                   # 4.1   [22] CJK UNIFIED IDEOGRAPH-9FA6..CJK UNIFIED IDEOGRAPH-9FBB
+9FBC..9FC3    ; Uncommon_Use                   # 5.1    [8] CJK UNIFIED IDEOGRAPH-9FBC..CJK UNIFIED IDEOGRAPH-9FC3
+9FC4..9FCB    ; Uncommon_Use                   # 5.2    [8] CJK UNIFIED IDEOGRAPH-9FC4..CJK UNIFIED IDEOGRAPH-9FCB
+9FCC          ; Uncommon_Use                   # 6.1        CJK UNIFIED IDEOGRAPH-9FCC
+9FCD..9FD5    ; Uncommon_Use                   # 8.0    [9] CJK UNIFIED IDEOGRAPH-9FCD..CJK UNIFIED IDEOGRAPH-9FD5
+9FD6..9FEA    ; Uncommon_Use                   # 10.0  [21] CJK UNIFIED IDEOGRAPH-9FD6..CJK UNIFIED IDEOGRAPH-9FEA
+9FEB..9FEF    ; Uncommon_Use                   # 11.0   [5] CJK UNIFIED IDEOGRAPH-9FEB..CJK UNIFIED IDEOGRAPH-9FEF
+9FF0..9FFC    ; Uncommon_Use                   # 13.0  [13] CJK UNIFIED IDEOGRAPH-9FF0..CJK UNIFIED IDEOGRAPH-9FFC
+9FFD..9FFF    ; Uncommon_Use                   # 14.0   [3] CJK UNIFIED IDEOGRAPH-9FFD..CJK UNIFIED IDEOGRAPH-9FFF
+A66F          ; Uncommon_Use                   # 5.1        COMBINING CYRILLIC VZMET
+A67C..A67D    ; Uncommon_Use                   # 5.1    [2] COMBINING CYRILLIC KAVYKA..COMBINING CYRILLIC PAYEROK
+A78B..A78C    ; Uncommon_Use                   # 5.1    [2] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER SALTILLO
+A78F          ; Uncommon_Use                   # 8.0        LATIN LETTER SINOLOGICAL DOT
+A792..A793    ; Uncommon_Use                   # 6.1    [2] LATIN CAPITAL LETTER C WITH BAR..LATIN SMALL LETTER C WITH BAR
+A7B2..A7B7    ; Uncommon_Use                   # 8.0    [6] LATIN CAPITAL LETTER J WITH CROSSED-TAIL..LATIN SMALL LETTER OMEGA
+A7B8..A7B9    ; Uncommon_Use                   # 11.0   [2] LATIN CAPITAL LETTER U WITH STROKE..LATIN SMALL LETTER U WITH STROKE
+A7C2..A7C3    ; Uncommon_Use                   # 12.0   [2] LATIN CAPITAL LETTER ANGLICANA W..LATIN SMALL LETTER ANGLICANA W
+A7CB..A7CD    ; Uncommon_Use                   # 16.0   [3] LATIN CAPITAL LETTER RAMS HORN..LATIN SMALL LETTER S WITH DIAGONAL STROKE
+A7CE..A7CF    ; Uncommon_Use                   # 17.0   [2] LATIN CAPITAL LETTER PHARYNGEAL VOICED FRICATIVE..LATIN SMALL LETTER PHARYNGEAL VOICED FRICATIVE
+A7DA..A7DC    ; Uncommon_Use                   # 16.0   [3] LATIN CAPITAL LETTER LAMBDA..LATIN CAPITAL LETTER LAMBDA WITH STROKE
+A9E7..A9FE    ; Uncommon_Use                   # 7.0   [24] MYANMAR LETTER TAI LAING NYA..MYANMAR LETTER TAI LAING BHA
+AA60..AA76    ; Uncommon_Use                   # 5.2   [23] MYANMAR LETTER KHAMTI GA..MYANMAR LOGOGRAM KHAMTI HM
+AA7A          ; Uncommon_Use                   # 5.2        MYANMAR LETTER AITON RA
+AA7C..AA7F    ; Uncommon_Use                   # 7.0    [4] MYANMAR SIGN TAI LAING TONE-2..MYANMAR LETTER SHWE PALAUNG SHA
+AB01..AB06    ; Uncommon_Use                   # 6.0    [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC SYLLABLE TTHO
+AB09..AB0E    ; Uncommon_Use                   # 6.0    [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC SYLLABLE DDHO
+AB11..AB16    ; Uncommon_Use                   # 6.0    [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SYLLABLE DZO
+AB20..AB26    ; Uncommon_Use                   # 6.0    [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC SYLLABLE CCHHO
+AB28..AB2E    ; Uncommon_Use                   # 6.0    [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SYLLABLE BBO
+AB60..AB63    ; Uncommon_Use                   # 8.0    [4] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER UO
+AB66..AB67    ; Uncommon_Use                   # 12.0   [2] LATIN SMALL LETTER DZ DIGRAPH WITH RETROFLEX HOOK..LATIN SMALL LETTER TS DIGRAPH WITH RETROFLEX HOOK
+FA0E..FA0F    ; Uncommon_Use                   # 1.1    [2] CJK COMPATIBILITY IDEOGRAPH-FA0E..CJK COMPATIBILITY IDEOGRAPH-FA0F
+FA11          ; Uncommon_Use                   # 1.1        CJK COMPATIBILITY IDEOGRAPH-FA11
+FA13..FA14    ; Uncommon_Use                   # 1.1    [2] CJK COMPATIBILITY IDEOGRAPH-FA13..CJK COMPATIBILITY IDEOGRAPH-FA14
+FA1F          ; Uncommon_Use                   # 1.1        CJK COMPATIBILITY IDEOGRAPH-FA1F
+FA21          ; Uncommon_Use                   # 1.1        CJK COMPATIBILITY IDEOGRAPH-FA21
+FA23..FA24    ; Uncommon_Use                   # 1.1    [2] CJK COMPATIBILITY IDEOGRAPH-FA23..CJK COMPATIBILITY IDEOGRAPH-FA24
+FA27..FA29    ; Uncommon_Use                   # 1.1    [3] CJK COMPATIBILITY IDEOGRAPH-FA27..CJK COMPATIBILITY IDEOGRAPH-FA29
+10780         ; Uncommon_Use                   # 14.0       MODIFIER LETTER SMALL CAPITAL AA
+10EC2..10EC4  ; Uncommon_Use                   # 16.0   [3] ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS VERTICALLY BELOW
+10EC7         ; Uncommon_Use                   # 17.0       ARABIC LETTER YEH WITH FOUR DOTS BELOW
+10EFA         ; Uncommon_Use                   # 17.0       ARABIC DOUBLE VERTICAL BAR BELOW
+10EFC         ; Uncommon_Use                   # 16.0       ARABIC COMBINING ALEF OVERLAY
+10EFD..10EFF  ; Uncommon_Use                   # 15.0   [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA
+1133B         ; Uncommon_Use                   # 11.0       COMBINING BINDU BELOW
+116D0..116E3  ; Uncommon_Use                   # 16.0  [20] MYANMAR PAO DIGIT ZERO..MYANMAR EASTERN PWO KAREN DIGIT NINE
+1AFF0..1AFF3  ; Uncommon_Use                   # 14.0   [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5
+1AFF5..1AFFB  ; Uncommon_Use                   # 14.0   [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5
+1AFFD..1AFFE  ; Uncommon_Use                   # 14.0   [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8
+20000..2070D  ; Uncommon_Use                   # 3.1 [1806] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2070D
+2070F..20730  ; Uncommon_Use                   # 3.1   [34] CJK UNIFIED IDEOGRAPH-2070F..CJK UNIFIED IDEOGRAPH-20730
+20732..20778  ; Uncommon_Use                   # 3.1   [71] CJK UNIFIED IDEOGRAPH-20732..CJK UNIFIED IDEOGRAPH-20778
+2077A..20C52  ; Uncommon_Use                   # 3.1 [1241] CJK UNIFIED IDEOGRAPH-2077A..CJK UNIFIED IDEOGRAPH-20C52
+20C54..20C77  ; Uncommon_Use                   # 3.1   [36] CJK UNIFIED IDEOGRAPH-20C54..CJK UNIFIED IDEOGRAPH-20C77
+20C79..20C95  ; Uncommon_Use                   # 3.1   [29] CJK UNIFIED IDEOGRAPH-20C79..CJK UNIFIED IDEOGRAPH-20C95
+20C97..20CCE  ; Uncommon_Use                   # 3.1   [56] CJK UNIFIED IDEOGRAPH-20C97..CJK UNIFIED IDEOGRAPH-20CCE
+20CD0..20CD4  ; Uncommon_Use                   # 3.1    [5] CJK UNIFIED IDEOGRAPH-20CD0..CJK UNIFIED IDEOGRAPH-20CD4
+20CD6..20D14  ; Uncommon_Use                   # 3.1   [63] CJK UNIFIED IDEOGRAPH-20CD6..CJK UNIFIED IDEOGRAPH-20D14
+20D16..20D7B  ; Uncommon_Use                   # 3.1  [102] CJK UNIFIED IDEOGRAPH-20D16..CJK UNIFIED IDEOGRAPH-20D7B
+20D7D..20D7E  ; Uncommon_Use                   # 3.1    [2] CJK UNIFIED IDEOGRAPH-20D7D..CJK UNIFIED IDEOGRAPH-20D7E
+20D80..20E0D  ; Uncommon_Use                   # 3.1  [142] CJK UNIFIED IDEOGRAPH-20D80..CJK UNIFIED IDEOGRAPH-20E0D
+20E10..20E76  ; Uncommon_Use                   # 3.1  [103] CJK UNIFIED IDEOGRAPH-20E10..CJK UNIFIED IDEOGRAPH-20E76
+20E78..20E9C  ; Uncommon_Use                   # 3.1   [37] CJK UNIFIED IDEOGRAPH-20E78..CJK UNIFIED IDEOGRAPH-20E9C
+20E9E..20EA1  ; Uncommon_Use                   # 3.1    [4] CJK UNIFIED IDEOGRAPH-20E9E..CJK UNIFIED IDEOGRAPH-20EA1
+20EA3..20ED6  ; Uncommon_Use                   # 3.1   [52] CJK UNIFIED IDEOGRAPH-20EA3..CJK UNIFIED IDEOGRAPH-20ED6
+20ED8..20EF8  ; Uncommon_Use                   # 3.1   [33] CJK UNIFIED IDEOGRAPH-20ED8..CJK UNIFIED IDEOGRAPH-20EF8
+20EFB..20F2C  ; Uncommon_Use                   # 3.1   [50] CJK UNIFIED IDEOGRAPH-20EFB..CJK UNIFIED IDEOGRAPH-20F2C
+20F2F..20F4B  ; Uncommon_Use                   # 3.1   [29] CJK UNIFIED IDEOGRAPH-20F2F..CJK UNIFIED IDEOGRAPH-20F4B
+20F4D..20FB3  ; Uncommon_Use                   # 3.1  [103] CJK UNIFIED IDEOGRAPH-20F4D..CJK UNIFIED IDEOGRAPH-20FB3
+20FB5..20FBB  ; Uncommon_Use                   # 3.1    [7] CJK UNIFIED IDEOGRAPH-20FB5..CJK UNIFIED IDEOGRAPH-20FBB
+20FBD..20FE9  ; Uncommon_Use                   # 3.1   [45] CJK UNIFIED IDEOGRAPH-20FBD..CJK UNIFIED IDEOGRAPH-20FE9
+20FEB..2105B  ; Uncommon_Use                   # 3.1  [113] CJK UNIFIED IDEOGRAPH-20FEB..CJK UNIFIED IDEOGRAPH-2105B
+2105D..2106E  ; Uncommon_Use                   # 3.1   [18] CJK UNIFIED IDEOGRAPH-2105D..CJK UNIFIED IDEOGRAPH-2106E
+21070..21074  ; Uncommon_Use                   # 3.1    [5] CJK UNIFIED IDEOGRAPH-21070..CJK UNIFIED IDEOGRAPH-21074
+21077..2107A  ; Uncommon_Use                   # 3.1    [4] CJK UNIFIED IDEOGRAPH-21077..CJK UNIFIED IDEOGRAPH-2107A
+2107C..210C0  ; Uncommon_Use                   # 3.1   [69] CJK UNIFIED IDEOGRAPH-2107C..CJK UNIFIED IDEOGRAPH-210C0
+210C2..210C8  ; Uncommon_Use                   # 3.1    [7] CJK UNIFIED IDEOGRAPH-210C2..CJK UNIFIED IDEOGRAPH-210C8
+210CA..211D8  ; Uncommon_Use                   # 3.1  [271] CJK UNIFIED IDEOGRAPH-210CA..CJK UNIFIED IDEOGRAPH-211D8
+211DA..220C6  ; Uncommon_Use                   # 3.1 [3821] CJK UNIFIED IDEOGRAPH-211DA..CJK UNIFIED IDEOGRAPH-220C6
+220C8..227B4  ; Uncommon_Use                   # 3.1 [1773] CJK UNIFIED IDEOGRAPH-220C8..CJK UNIFIED IDEOGRAPH-227B4
+227B6..22AD4  ; Uncommon_Use                   # 3.1  [799] CJK UNIFIED IDEOGRAPH-227B6..CJK UNIFIED IDEOGRAPH-22AD4
+22AD6..22B42  ; Uncommon_Use                   # 3.1  [109] CJK UNIFIED IDEOGRAPH-22AD6..CJK UNIFIED IDEOGRAPH-22B42
+22B44..22BC9  ; Uncommon_Use                   # 3.1  [134] CJK UNIFIED IDEOGRAPH-22B44..CJK UNIFIED IDEOGRAPH-22BC9
+22BCB..22C50  ; Uncommon_Use                   # 3.1  [134] CJK UNIFIED IDEOGRAPH-22BCB..CJK UNIFIED IDEOGRAPH-22C50
+22C52..22C54  ; Uncommon_Use                   # 3.1    [3] CJK UNIFIED IDEOGRAPH-22C52..CJK UNIFIED IDEOGRAPH-22C54
+22C56..22CC1  ; Uncommon_Use                   # 3.1  [108] CJK UNIFIED IDEOGRAPH-22C56..CJK UNIFIED IDEOGRAPH-22CC1
+22CC3..22D07  ; Uncommon_Use                   # 3.1   [69] CJK UNIFIED IDEOGRAPH-22CC3..CJK UNIFIED IDEOGRAPH-22D07
+22D09..22D4B  ; Uncommon_Use                   # 3.1   [67] CJK UNIFIED IDEOGRAPH-22D09..CJK UNIFIED IDEOGRAPH-22D4B
+22D4D..22D66  ; Uncommon_Use                   # 3.1   [26] CJK UNIFIED IDEOGRAPH-22D4D..CJK UNIFIED IDEOGRAPH-22D66
+22D68..22EB2  ; Uncommon_Use                   # 3.1  [331] CJK UNIFIED IDEOGRAPH-22D68..CJK UNIFIED IDEOGRAPH-22EB2
+22EB4..23CB6  ; Uncommon_Use                   # 3.1 [3587] CJK UNIFIED IDEOGRAPH-22EB4..CJK UNIFIED IDEOGRAPH-23CB6
+23CB8..244D2  ; Uncommon_Use                   # 3.1 [2075] CJK UNIFIED IDEOGRAPH-23CB8..CJK UNIFIED IDEOGRAPH-244D2
+244D4..24DB7  ; Uncommon_Use                   # 3.1 [2276] CJK UNIFIED IDEOGRAPH-244D4..CJK UNIFIED IDEOGRAPH-24DB7
+24DB9..24DE9  ; Uncommon_Use                   # 3.1   [49] CJK UNIFIED IDEOGRAPH-24DB9..CJK UNIFIED IDEOGRAPH-24DE9
+24DEB..2512A  ; Uncommon_Use                   # 3.1  [832] CJK UNIFIED IDEOGRAPH-24DEB..CJK UNIFIED IDEOGRAPH-2512A
+2512C..26257  ; Uncommon_Use                   # 3.1 [4396] CJK UNIFIED IDEOGRAPH-2512C..CJK UNIFIED IDEOGRAPH-26257
+26259..267CB  ; Uncommon_Use                   # 3.1 [1395] CJK UNIFIED IDEOGRAPH-26259..CJK UNIFIED IDEOGRAPH-267CB
+267CD..269F1  ; Uncommon_Use                   # 3.1  [549] CJK UNIFIED IDEOGRAPH-267CD..CJK UNIFIED IDEOGRAPH-269F1
+269F3..269F9  ; Uncommon_Use                   # 3.1    [7] CJK UNIFIED IDEOGRAPH-269F3..CJK UNIFIED IDEOGRAPH-269F9
+269FB..27A3D  ; Uncommon_Use                   # 3.1 [4163] CJK UNIFIED IDEOGRAPH-269FB..CJK UNIFIED IDEOGRAPH-27A3D
+27A3F..2815C  ; Uncommon_Use                   # 3.1 [1822] CJK UNIFIED IDEOGRAPH-27A3F..CJK UNIFIED IDEOGRAPH-2815C
+2815E..28206  ; Uncommon_Use                   # 3.1  [169] CJK UNIFIED IDEOGRAPH-2815E..CJK UNIFIED IDEOGRAPH-28206
+28208..282E1  ; Uncommon_Use                   # 3.1  [218] CJK UNIFIED IDEOGRAPH-28208..CJK UNIFIED IDEOGRAPH-282E1
+282E3..28CC9  ; Uncommon_Use                   # 3.1 [2535] CJK UNIFIED IDEOGRAPH-282E3..CJK UNIFIED IDEOGRAPH-28CC9
+28CCB..28CCC  ; Uncommon_Use                   # 3.1    [2] CJK UNIFIED IDEOGRAPH-28CCB..CJK UNIFIED IDEOGRAPH-28CCC
+28CCE..28CD1  ; Uncommon_Use                   # 3.1    [4] CJK UNIFIED IDEOGRAPH-28CCE..CJK UNIFIED IDEOGRAPH-28CD1
+28CD3..29D97  ; Uncommon_Use                   # 3.1 [4293] CJK UNIFIED IDEOGRAPH-28CD3..CJK UNIFIED IDEOGRAPH-29D97
+29D99..2A6D6  ; Uncommon_Use                   # 3.1 [2366] CJK UNIFIED IDEOGRAPH-29D99..CJK UNIFIED IDEOGRAPH-2A6D6
+2A6D7..2A6DD  ; Uncommon_Use                   # 13.0   [7] CJK UNIFIED IDEOGRAPH-2A6D7..CJK UNIFIED IDEOGRAPH-2A6DD
+2A6DE..2A6DF  ; Uncommon_Use                   # 14.0   [2] CJK UNIFIED IDEOGRAPH-2A6DE..CJK UNIFIED IDEOGRAPH-2A6DF
+2A700..2B734  ; Uncommon_Use                   # 5.2 [4149] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B734
+2B735..2B738  ; Uncommon_Use                   # 14.0   [4] CJK UNIFIED IDEOGRAPH-2B735..CJK UNIFIED IDEOGRAPH-2B738
+2B739         ; Uncommon_Use                   # 15.0       CJK UNIFIED IDEOGRAPH-2B739
+2B73A..2B73F  ; Uncommon_Use                   # 17.0   [6] CJK UNIFIED IDEOGRAPH-2B73A..CJK UNIFIED IDEOGRAPH-2B73F
+2B740..2B81D  ; Uncommon_Use                   # 6.0  [222] CJK UNIFIED IDEOGRAPH-2B740..CJK UNIFIED IDEOGRAPH-2B81D
+2B820..2CEA1  ; Uncommon_Use                   # 8.0 [5762] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEA1
+2CEA2..2CEAD  ; Uncommon_Use                   # 17.0  [12] CJK UNIFIED IDEOGRAPH-2CEA2..CJK UNIFIED IDEOGRAPH-2CEAD
+2CEB0..2EBE0  ; Uncommon_Use                   # 10.0 [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0
+2EBF0..2EE5D  ; Uncommon_Use                   # 15.1 [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D
+30000..3134A  ; Uncommon_Use                   # 13.0 [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A
+31350..323AF  ; Uncommon_Use                   # 15.0 [4192] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-323AF
+323B0..33479  ; Uncommon_Use                   # 17.0 [4298] CJK UNIFIED IDEOGRAPH-323B0..CJK UNIFIED IDEOGRAPH-33479
+
+# Total code points: 83130
+
+#	Identifier_Type:	Uncommon_Use Technical
+
+05C7          ; Uncommon_Use Technical         # 4.1        HEBREW POINT QAMATS QATAN
+0653          ; Uncommon_Use Technical         # 3.0        ARABIC MADDAH ABOVE
+0D8F..0D90    ; Uncommon_Use Technical         # 3.0    [2] SINHALA LETTER ILUYANNA..SINHALA LETTER ILUUYANNA
+0DDF          ; Uncommon_Use Technical         # 3.0        SINHALA VOWEL SIGN GAYANUKITTA
+0DF3          ; Uncommon_Use Technical         # 3.0        SINHALA VOWEL SIGN DIGA GAYANUKITTA
+0FC6          ; Uncommon_Use Technical         # 3.0        TIBETAN SYMBOL PADMA GDAN
+10F9..10FA    ; Uncommon_Use Technical         # 4.1    [2] GEORGIAN LETTER TURNED GAN..GEORGIAN LETTER AIN
+FB1E          ; Uncommon_Use Technical         # 1.1        HEBREW POINT JUDEO-SPANISH VARIKA
+FE2E..FE2F    ; Uncommon_Use Technical         # 8.0    [2] COMBINING CYRILLIC TITLO LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF
+
+# Total code points: 12
+
+#	Identifier_Type:	Uncommon_Use Technical Not_XID
+
+1D1DE..1D1E8  ; Uncommon_Use Technical Not_XID # 8.0   [11] MUSICAL SYMBOL KIEVAN C CLEF..MUSICAL SYMBOL KIEVAN FLAT SIGN
+
+# Total code points: 11
+
+#	Identifier_Type:	Uncommon_Use Exclusion
+
+18A9          ; Uncommon_Use Exclusion         # 3.0        MONGOLIAN LETTER ALI GALI DAGALGA
+16A40..16A5E  ; Uncommon_Use Exclusion         # 7.0   [31] MRO LETTER TA..MRO LETTER TEK
+16A60..16A69  ; Uncommon_Use Exclusion         # 7.0   [10] MRO DIGIT ZERO..MRO DIGIT NINE
+
+# Total code points: 42
+
+#	Identifier_Type:	Uncommon_Use Obsolete
+
+05A2          ; Uncommon_Use Obsolete          # 4.1        HEBREW ACCENT ATNAH HAFUKH
+05C5          ; Uncommon_Use Obsolete          # 4.1        HEBREW MARK LOWER DOT
+0F6A          ; Uncommon_Use Obsolete          # 3.0        TIBETAN LETTER FIXED-FORM RA
+0F82..0F83    ; Uncommon_Use Obsolete          # 2.0    [2] TIBETAN SIGN NYI ZLA NAA DA..TIBETAN SIGN SNA LDAN
+1050..1059    ; Uncommon_Use Obsolete          # 3.0   [10] MYANMAR LETTER SHA..MYANMAR VOWEL SIGN VOCALIC LL
+A69E          ; Uncommon_Use Obsolete          # 8.0        COMBINING CYRILLIC LETTER EF
+A8FD          ; Uncommon_Use Obsolete          # 8.0        DEVANAGARI JAIN OM
+
+# Total code points: 17
+
+#	Identifier_Type:	Uncommon_Use Obsolete Not_XID
+
+A8FC          ; Uncommon_Use Obsolete Not_XID  # 8.0        DEVANAGARI SIGN SIDDHAM
+
+# Total code points: 1
+
+#	Identifier_Type:	Uncommon_Use Not_XID
+
+218A..218B    ; Uncommon_Use Not_XID           # 8.0    [2] TURNED DIGIT TWO..TURNED DIGIT THREE
+2BEC..2BEF    ; Uncommon_Use Not_XID           # 8.0    [4] LEFTWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS..DOWNWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS
+1F54F         ; Uncommon_Use Not_XID           # 8.0        BOWL OF HYGIEIA
+
+# Total code points: 7
+
+#	Identifier_Type:	Technical
+
+0180          ; Technical                      # 1.1        LATIN SMALL LETTER B WITH STROKE
+01C0..01C3    ; Technical                      # 1.1    [4] LATIN LETTER DENTAL CLICK..LATIN LETTER RETROFLEX CLICK
+0200..0217    ; Technical                      # 1.1   [24] LATIN CAPITAL LETTER A WITH DOUBLE GRAVE..LATIN SMALL LETTER U WITH INVERTED BREVE
+0234..0236    ; Technical                      # 4.0    [3] LATIN SMALL LETTER L WITH CURL..LATIN SMALL LETTER T WITH CURL
+0250..0252    ; Technical                      # 1.1    [3] LATIN SMALL LETTER TURNED A..LATIN SMALL LETTER TURNED ALPHA
+0255          ; Technical                      # 1.1        LATIN SMALL LETTER C WITH CURL
+0258          ; Technical                      # 1.1        LATIN SMALL LETTER REVERSED E
+025A          ; Technical                      # 1.1        LATIN SMALL LETTER SCHWA WITH HOOK
+025C..0262    ; Technical                      # 1.1    [7] LATIN SMALL LETTER REVERSED OPEN E..LATIN LETTER SMALL CAPITAL G
+0264..0267    ; Technical                      # 1.1    [4] LATIN SMALL LETTER RAMS HORN..LATIN SMALL LETTER HENG WITH HOOK
+026A..0271    ; Technical                      # 1.1    [8] LATIN LETTER SMALL CAPITAL I..LATIN SMALL LETTER M WITH HOOK
+0273..0276    ; Technical                      # 1.1    [4] LATIN SMALL LETTER N WITH RETROFLEX HOOK..LATIN LETTER SMALL CAPITAL OE
+0278..027B    ; Technical                      # 1.1    [4] LATIN SMALL LETTER PHI..LATIN SMALL LETTER TURNED R WITH HOOK
+027D..0288    ; Technical                      # 1.1   [12] LATIN SMALL LETTER R WITH TAIL..LATIN SMALL LETTER T WITH RETROFLEX HOOK
+028A          ; Technical                      # 1.1        LATIN SMALL LETTER UPSILON
+028C..0291    ; Technical                      # 1.1    [6] LATIN SMALL LETTER TURNED V..LATIN SMALL LETTER Z WITH CURL
+0293..029D    ; Technical                      # 1.1   [11] LATIN SMALL LETTER EZH WITH CURL..LATIN SMALL LETTER J WITH CROSSED-TAIL
+029F..02A8    ; Technical                      # 1.1   [10] LATIN LETTER SMALL CAPITAL L..LATIN SMALL LETTER TC DIGRAPH WITH CURL
+02A9..02AD    ; Technical                      # 3.0    [5] LATIN SMALL LETTER FENG DIGRAPH..LATIN LETTER BIDENTAL PERCUSSIVE
+02AE..02AF    ; Technical                      # 4.0    [2] LATIN SMALL LETTER TURNED H WITH FISHHOOK..LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL
+02B9..02BA    ; Technical                      # 1.1    [2] MODIFIER LETTER PRIME..MODIFIER LETTER DOUBLE PRIME
+02BD..02C1    ; Technical                      # 1.1    [5] MODIFIER LETTER REVERSED COMMA..MODIFIER LETTER REVERSED GLOTTAL STOP
+02C6..02D1    ; Technical                      # 1.1   [12] MODIFIER LETTER CIRCUMFLEX ACCENT..MODIFIER LETTER HALF TRIANGULAR COLON
+02EC          ; Technical                      # 3.0        MODIFIER LETTER VOICING
+02EE          ; Technical                      # 3.0        MODIFIER LETTER DOUBLE APOSTROPHE
+030E..0315    ; Technical                      # 1.1    [8] COMBINING DOUBLE VERTICAL LINE ABOVE..COMBINING COMMA ABOVE RIGHT
+0317..031A    ; Technical                      # 1.1    [4] COMBINING ACUTE ACCENT BELOW..COMBINING LEFT ANGLE ABOVE
+031C..0320    ; Technical                      # 1.1    [5] COMBINING LEFT HALF RING BELOW..COMBINING MINUS SIGN BELOW
+0324..0325    ; Technical                      # 1.1    [2] COMBINING DIAERESIS BELOW..COMBINING RING BELOW
+0329..0330    ; Technical                      # 1.1    [8] COMBINING VERTICAL LINE BELOW..COMBINING TILDE BELOW
+0333          ; Technical                      # 1.1        COMBINING DOUBLE LOW LINE
+0335          ; Technical                      # 1.1        COMBINING SHORT STROKE OVERLAY
+0337..033F    ; Technical                      # 1.1    [9] COMBINING SHORT SOLIDUS OVERLAY..COMBINING DOUBLE OVERLINE
+0342          ; Technical                      # 1.1        COMBINING GREEK PERISPOMENI
+0346..034E    ; Technical                      # 3.0    [9] COMBINING BRIDGE ABOVE..COMBINING UPWARDS ARROW BELOW
+0350..0357    ; Technical                      # 4.0    [8] COMBINING RIGHT ARROWHEAD ABOVE..COMBINING RIGHT HALF RING ABOVE
+0359..035C    ; Technical                      # 4.1    [4] COMBINING ASTERISK BELOW..COMBINING DOUBLE BREVE BELOW
+035D..035F    ; Technical                      # 4.0    [3] COMBINING DOUBLE BREVE..COMBINING DOUBLE MACRON BELOW
+0360..0361    ; Technical                      # 1.1    [2] COMBINING DOUBLE TILDE..COMBINING DOUBLE INVERTED BREVE
+0362          ; Technical                      # 3.0        COMBINING DOUBLE RIGHTWARDS ARROW BELOW
+03CF          ; Technical                      # 5.1        GREEK CAPITAL KAI SYMBOL
+03D7          ; Technical                      # 3.0        GREEK KAI SYMBOL
+0559          ; Technical                      # 1.1        ARMENIAN MODIFIER LETTER LEFT HALF RING
+0560          ; Technical                      # 11.0       ARMENIAN SMALL LETTER TURNED AYB
+0588          ; Technical                      # 11.0       ARMENIAN SMALL LETTER YI WITH STROKE
+0671          ; Technical                      # 1.1        ARABIC LETTER ALEF WASLA
+06E5..06E6    ; Technical                      # 1.1    [2] ARABIC SMALL WAW..ARABIC SMALL YEH
+0870..0887    ; Technical                      # 14.0  [24] ARABIC LETTER ALEF WITH ATTACHED FATHA..ARABIC BASELINE ROUND DOT
+08C9          ; Technical                      # 14.0       ARABIC SMALL FARSI YEH
+0950          ; Technical                      # 1.1        DEVANAGARI OM
+0953..0954    ; Technical                      # 1.1    [2] DEVANAGARI GRAVE ACCENT..DEVANAGARI ACUTE ACCENT
+097D          ; Technical                      # 4.1        DEVANAGARI LETTER GLOTTAL STOP
+0A74          ; Technical                      # 1.1        GURMUKHI EK ONKAR
+0AD0          ; Technical                      # 1.1        GUJARATI OM
+0B82          ; Technical                      # 1.1        TAMIL SIGN ANUSVARA
+0BD0          ; Technical                      # 5.1        TAMIL OM
+0D81          ; Technical                      # 13.0       SINHALA SIGN CANDRABINDU
+0EAF          ; Technical                      # 1.1        LAO ELLIPSIS
+0F00          ; Technical                      # 2.0        TIBETAN SYLLABLE OM
+0F18..0F19    ; Technical                      # 2.0    [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS
+0F35          ; Technical                      # 2.0        TIBETAN MARK NGAS BZUNG NYI ZLA
+0F37          ; Technical                      # 2.0        TIBETAN MARK NGAS BZUNG SGOR RTAGS
+0F3E..0F3F    ; Technical                      # 2.0    [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES
+17CE..17CF    ; Technical                      # 3.0    [2] KHMER SIGN KAKABAT..KHMER SIGN AHSDA
+1ABF..1AC0    ; Technical                      # 13.0   [2] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER TURNED W BELOW
+1ACF..1ADD    ; Technical                      # 17.0  [15] COMBINING DOUBLE CARON..COMBINING DOT-AND-RING BELOW
+1AE0..1AEB    ; Technical                      # 17.0  [12] COMBINING LEFT TACK ABOVE..COMBINING DOUBLE RIGHTWARDS ARROW ABOVE
+1D00..1D2B    ; Technical                      # 4.0   [44] LATIN LETTER SMALL CAPITAL A..CYRILLIC LETTER SMALL CAPITAL EL
+1D2F          ; Technical                      # 4.0        MODIFIER LETTER CAPITAL BARRED B
+1D3B          ; Technical                      # 4.0        MODIFIER LETTER CAPITAL REVERSED N
+1D4E          ; Technical                      # 4.0        MODIFIER LETTER SMALL TURNED I
+1D6B          ; Technical                      # 4.0        LATIN SMALL LETTER UE
+1D6C..1D77    ; Technical                      # 4.1   [12] LATIN SMALL LETTER B WITH MIDDLE TILDE..LATIN SMALL LETTER TURNED G
+1D79..1D9A    ; Technical                      # 4.1   [34] LATIN SMALL LETTER INSULAR G..LATIN SMALL LETTER EZH WITH RETROFLEX HOOK
+1DC4..1DCA    ; Technical                      # 5.0    [7] COMBINING MACRON-ACUTE..COMBINING LATIN SMALL LETTER R BELOW
+1DCB..1DCD    ; Technical                      # 5.1    [3] COMBINING BREVE-MACRON..COMBINING DOUBLE CIRCUMFLEX ABOVE
+1DCF..1DD0    ; Technical                      # 5.1    [2] COMBINING ZIGZAG BELOW..COMBINING IS BELOW
+1DE7..1DF5    ; Technical                      # 7.0   [15] COMBINING LATIN SMALL LETTER ALPHA..COMBINING UP TACK ABOVE
+1DF6..1DF9    ; Technical                      # 10.0   [4] COMBINING KAVYKA ABOVE RIGHT..COMBINING WIDE INVERTED BRIDGE BELOW
+1DFB          ; Technical                      # 9.0        COMBINING DELETION MARK
+1DFC          ; Technical                      # 6.0        COMBINING DOUBLE INVERTED BREVE BELOW
+1DFD          ; Technical                      # 5.2        COMBINING ALMOST EQUAL TO BELOW
+1DFE..1DFF    ; Technical                      # 5.0    [2] COMBINING LEFT ARROWHEAD ABOVE..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW
+1E00..1E01    ; Technical                      # 1.1    [2] LATIN CAPITAL LETTER A WITH RING BELOW..LATIN SMALL LETTER A WITH RING BELOW
+1E18..1E1B    ; Technical                      # 1.1    [4] LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW..LATIN SMALL LETTER E WITH TILDE BELOW
+1E2A..1E2D    ; Technical                      # 1.1    [4] LATIN CAPITAL LETTER H WITH BREVE BELOW..LATIN SMALL LETTER I WITH TILDE BELOW
+1E72..1E77    ; Technical                      # 1.1    [6] LATIN CAPITAL LETTER U WITH DIAERESIS BELOW..LATIN SMALL LETTER U WITH CIRCUMFLEX BELOW
+1E9C..1E9D    ; Technical                      # 5.1    [2] LATIN SMALL LETTER LONG S WITH DIAGONAL STROKE..LATIN SMALL LETTER LONG S WITH HIGH STROKE
+1E9F          ; Technical                      # 5.1        LATIN SMALL LETTER DELTA
+1EFA..1EFF    ; Technical                      # 5.1    [6] LATIN CAPITAL LETTER MIDDLE-WELSH LL..LATIN SMALL LETTER Y WITH LOOP
+203F..2040    ; Technical                      # 1.1    [2] UNDERTIE..CHARACTER TIE
+20D0..20DC    ; Technical                      # 1.1   [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE
+20E1          ; Technical                      # 1.1        COMBINING LEFT RIGHT ARROW ABOVE
+20E5..20EA    ; Technical                      # 3.2    [6] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING LEFTWARDS ARROW OVERLAY
+20EB          ; Technical                      # 4.1        COMBINING LONG DOUBLE SOLIDUS OVERLAY
+20EC..20EF    ; Technical                      # 5.0    [4] COMBINING RIGHTWARDS HARPOON WITH BARB DOWNWARDS..COMBINING RIGHT ARROW BELOW
+20F0          ; Technical                      # 5.1        COMBINING ASTERISK ABOVE
+2118          ; Technical                      # 1.1        SCRIPT CAPITAL P
+212E          ; Technical                      # 1.1        ESTIMATED SYMBOL
+2C60..2C67    ; Technical                      # 5.0    [8] LATIN CAPITAL LETTER L WITH DOUBLE BAR..LATIN CAPITAL LETTER H WITH DESCENDER
+2C77          ; Technical                      # 5.0        LATIN SMALL LETTER TAILLESS PHI
+2C78..2C7B    ; Technical                      # 5.1    [4] LATIN SMALL LETTER E WITH NOTCH..LATIN LETTER SMALL CAPITAL TURNED E
+2D27          ; Technical                      # 6.1        GEORGIAN SMALL LETTER YN
+2D2D          ; Technical                      # 6.1        GEORGIAN SMALL LETTER AEN
+3021..302D    ; Technical                      # 1.1   [13] HANGZHOU NUMERAL ONE..IDEOGRAPHIC ENTERING TONE MARK
+3031..3035    ; Technical                      # 1.1    [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF
+303B..303C    ; Technical                      # 3.2    [2] VERTICAL IDEOGRAPHIC ITERATION MARK..MASU MARK
+A717..A71A    ; Technical                      # 5.0    [4] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOWER RIGHT CORNER ANGLE
+A71B..A71F    ; Technical                      # 5.1    [5] MODIFIER LETTER RAISED UP ARROW..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK
+A788          ; Technical                      # 5.1        MODIFIER LETTER LOW CIRCUMFLEX ACCENT
+A78E          ; Technical                      # 6.0        LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT
+A7AE          ; Technical                      # 9.0        LATIN CAPITAL LETTER SMALL CAPITAL I
+A7AF          ; Technical                      # 11.0       LATIN LETTER SMALL CAPITAL Q
+A7BA..A7BF    ; Technical                      # 12.0   [6] LATIN CAPITAL LETTER GLOTTAL A..LATIN SMALL LETTER GLOTTAL U
+A7C5..A7C6    ; Technical                      # 12.0   [2] LATIN CAPITAL LETTER S WITH HOOK..LATIN CAPITAL LETTER Z WITH PALATAL HOOK
+A7FA          ; Technical                      # 6.0        LATIN LETTER SMALL CAPITAL TURNED M
+AB68          ; Technical                      # 13.0       LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE
+FE20..FE23    ; Technical                      # 1.1    [4] COMBINING LIGATURE LEFT HALF..COMBINING DOUBLE TILDE RIGHT HALF
+FE24..FE26    ; Technical                      # 5.1    [3] COMBINING MACRON LEFT HALF..COMBINING CONJOINING MACRON
+FE27..FE2D    ; Technical                      # 7.0    [7] COMBINING LIGATURE LEFT HALF BELOW..COMBINING CONJOINING MACRON BELOW
+FE73          ; Technical                      # 3.2        ARABIC TAIL FRAGMENT
+10EC5..10EC6  ; Technical                      # 17.0   [2] ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW..ARABIC LETTER THIN NOON
+10EFB         ; Technical                      # 17.0       ARABIC SMALL LOW NOON
+16FF2..16FF6  ; Technical                      # 17.0   [5] CHINESE SMALL SIMPLIFIED ER..YANGQIN SIGN SLOW TWO BEATS
+1CF00..1CF2D  ; Technical                      # 14.0  [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT
+1CF30..1CF46  ; Technical                      # 14.0  [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG
+1D165..1D169  ; Technical                      # 3.1    [5] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING TREMOLO-3
+1D16D..1D172  ; Technical                      # 3.1    [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5
+1D17B..1D182  ; Technical                      # 3.1    [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE
+1D185..1D18B  ; Technical                      # 3.1    [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE
+1D1AA..1D1AD  ; Technical                      # 3.1    [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO
+1DF00..1DF1E  ; Technical                      # 14.0  [31] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER S WITH CURL
+1DF25..1DF2A  ; Technical                      # 15.0   [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK
+
+# Total code points: 682
+
+#	Identifier_Type:	Technical Exclusion
+
+2CF0..2CF1    ; Technical Exclusion            # 5.2    [2] COPTIC COMBINING SPIRITUS ASPER..COPTIC COMBINING SPIRITUS LENIS
+
+# Total code points: 2
+
+#	Identifier_Type:	Technical Obsolete
+
+018D          ; Technical Obsolete             # 1.1        LATIN SMALL LETTER TURNED DELTA
+01AA..01AB    ; Technical Obsolete             # 1.1    [2] LATIN LETTER REVERSED ESH LOOP..LATIN SMALL LETTER T WITH PALATAL HOOK
+01BA..01BB    ; Technical Obsolete             # 1.1    [2] LATIN SMALL LETTER EZH WITH TAIL..LATIN LETTER TWO WITH STROKE
+01BE          ; Technical Obsolete             # 1.1        LATIN LETTER INVERTED GLOTTAL STOP WITH STROKE
+0277          ; Technical Obsolete             # 1.1        LATIN SMALL LETTER CLOSED OMEGA
+027C          ; Technical Obsolete             # 1.1        LATIN SMALL LETTER R WITH LONG LEG
+029E          ; Technical Obsolete             # 1.1        LATIN SMALL LETTER TURNED K
+03F3          ; Technical Obsolete             # 1.1        GREEK LETTER YOT
+03FC          ; Technical Obsolete             # 4.1        GREEK RHO WITH STROKE SYMBOL
+0484..0486    ; Technical Obsolete             # 1.1    [3] COMBINING CYRILLIC PALATALIZATION..COMBINING CYRILLIC PSILI PNEUMATA
+0487          ; Technical Obsolete             # 5.1        COMBINING CYRILLIC POKRYTIE
+0D04          ; Technical Obsolete             # 13.0       MALAYALAM LETTER VEDIC ANUSVARA
+17D1          ; Technical Obsolete             # 3.0        KHMER SIGN VIRIAM
+17DD          ; Technical Obsolete             # 4.0        KHMER SIGN ATTHACAN
+1DC0..1DC3    ; Technical Obsolete             # 4.1    [4] COMBINING DOTTED GRAVE ACCENT..COMBINING SUSPENSION MARK
+1DCE          ; Technical Obsolete             # 5.1        COMBINING OGONEK ABOVE
+1DD1..1DE6    ; Technical Obsolete             # 5.1   [22] COMBINING UR ABOVE..COMBINING LATIN SMALL LETTER Z
+1FB0..1FB1    ; Technical Obsolete             # 1.1    [2] GREEK SMALL LETTER ALPHA WITH VRACHY..GREEK SMALL LETTER ALPHA WITH MACRON
+2180..2182    ; Technical Obsolete             # 1.1    [3] ROMAN NUMERAL ONE THOUSAND C D..ROMAN NUMERAL TEN THOUSAND
+2183          ; Technical Obsolete             # 3.0        ROMAN NUMERAL REVERSED ONE HUNDRED
+302E..302F    ; Technical Obsolete             # 1.1    [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK
+A722..A72F    ; Technical Obsolete             # 5.1   [14] LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF..LATIN SMALL LETTER CUATRILLO WITH COMMA
+1D242..1D244  ; Technical Obsolete             # 4.1    [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME
+
+# Total code points: 70
+
+#	Identifier_Type:	Technical Obsolete Not_XID
+
+2E00..2E0D    ; Technical Obsolete Not_XID     # 4.1   [14] RIGHT ANGLE SUBSTITUTION MARKER..RIGHT RAISED OMISSION BRACKET
+
+# Total code points: 14
+
+#	Identifier_Type:	Technical Not_XID
+
+0375          ; Technical Not_XID              # 1.1        GREEK LOWER NUMERAL SIGN
+0888          ; Technical Not_XID              # 14.0       ARABIC RAISED ROUND DOT
+20DD..20E0    ; Technical Not_XID              # 1.1    [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH
+20E2..20E3    ; Technical Not_XID              # 3.0    [2] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING KEYCAP
+20E4          ; Technical Not_XID              # 3.2        COMBINING ENCLOSING UPWARD POINTING TRIANGLE
+24EB..24FE    ; Technical Not_XID              # 3.2   [20] NEGATIVE CIRCLED NUMBER ELEVEN..DOUBLE CIRCLED NUMBER TEN
+24FF          ; Technical Not_XID              # 4.0        NEGATIVE CIRCLED DIGIT ZERO
+2800..28FF    ; Technical Not_XID              # 3.0  [256] BRAILLE PATTERN BLANK..BRAILLE PATTERN DOTS-12345678
+327F          ; Technical Not_XID              # 1.1        KOREAN STANDARD SYMBOL
+4DC0..4DFF    ; Technical Not_XID              # 4.0   [64] HEXAGRAM FOR THE CREATIVE HEAVEN..HEXAGRAM FOR BEFORE COMPLETION
+A708..A716    ; Technical Not_XID              # 4.1   [15] MODIFIER LETTER EXTRA-HIGH DOTTED TONE BAR..MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR
+FBB2..FBC1    ; Technical Not_XID              # 6.0   [16] ARABIC SYMBOL DOT ABOVE..ARABIC SYMBOL SMALL TAH BELOW
+FBC2          ; Technical Not_XID              # 14.0       ARABIC SYMBOL WASLA ABOVE
+FBC3..FBD2    ; Technical Not_XID              # 17.0  [16] ARABIC LIGATURE JALLA WA-ALAA..ARABIC LIGATURE ALAYHI AR-RAHMAH
+FD3E..FD3F    ; Technical Not_XID              # 1.1    [2] ORNATE LEFT PARENTHESIS..ORNATE RIGHT PARENTHESIS
+FD40..FD4F    ; Technical Not_XID              # 14.0  [16] ARABIC LIGATURE RAHIMAHU ALLAAH..ARABIC LIGATURE RAHIMAHUM ALLAAH
+FD90..FD91    ; Technical Not_XID              # 17.0   [2] ARABIC LIGATURE RAHMATU ALLAAHI ALAYH..ARABIC LIGATURE RAHMATU ALLAAHI ALAYHAA
+FDC8..FDCE    ; Technical Not_XID              # 17.0   [7] ARABIC LIGATURE RAHIMAHU ALLAAH TAAALAA..ARABIC LIGATURE KARRAMA ALLAAHU WAJHAH
+FDCF          ; Technical Not_XID              # 14.0       ARABIC LIGATURE SALAAMUHU ALAYNAA
+FDFD          ; Technical Not_XID              # 4.0        ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM
+FDFE..FDFF    ; Technical Not_XID              # 14.0   [2] ARABIC LIGATURE SUBHAANAHU WA TAAALAA..ARABIC LIGATURE AZZA WA JALL
+FE45..FE46    ; Technical Not_XID              # 3.2    [2] SESAME DOT..WHITE SESAME DOT
+1CF50..1CFC3  ; Technical Not_XID              # 14.0 [116] ZNAMENNY NEUME KRYUK..ZNAMENNY NEUME PAUK
+1D000..1D0F5  ; Technical Not_XID              # 3.1  [246] BYZANTINE MUSICAL SYMBOL PSILI..BYZANTINE MUSICAL SYMBOL GORGON NEO KATO
+1D100..1D126  ; Technical Not_XID              # 3.1   [39] MUSICAL SYMBOL SINGLE BARLINE..MUSICAL SYMBOL DRUM CLEF-2
+1D129         ; Technical Not_XID              # 5.1        MUSICAL SYMBOL MULTIPLE MEASURE REST
+1D12A..1D15D  ; Technical Not_XID              # 3.1   [52] MUSICAL SYMBOL DOUBLE SHARP..MUSICAL SYMBOL WHOLE NOTE
+1D16A..1D16C  ; Technical Not_XID              # 3.1    [3] MUSICAL SYMBOL FINGERED TREMOLO-1..MUSICAL SYMBOL FINGERED TREMOLO-3
+1D183..1D184  ; Technical Not_XID              # 3.1    [2] MUSICAL SYMBOL ARPEGGIATO UP..MUSICAL SYMBOL ARPEGGIATO DOWN
+1D18C..1D1A9  ; Technical Not_XID              # 3.1   [30] MUSICAL SYMBOL RINFORZANDO..MUSICAL SYMBOL DEGREE SLASH
+1D1AE..1D1BA  ; Technical Not_XID              # 3.1   [13] MUSICAL SYMBOL PEDAL MARK..MUSICAL SYMBOL SEMIBREVIS BLACK
+1D1C1..1D1DD  ; Technical Not_XID              # 3.1   [29] MUSICAL SYMBOL LONGA PERFECTA REST..MUSICAL SYMBOL PES SUBPUNCTIS
+1D1E9..1D1EA  ; Technical Not_XID              # 14.0   [2] MUSICAL SYMBOL SORI..MUSICAL SYMBOL KORON
+1D300..1D356  ; Technical Not_XID              # 4.0   [87] MONOGRAM FOR EARTH..TETRAGRAM FOR FOSTERING
+
+# Total code points: 1052
+
+#	Identifier_Type:	Exclusion
+
+03E2..03EF    ; Exclusion                      # 1.1   [14] COPTIC CAPITAL LETTER SHEI..COPTIC SMALL LETTER DEI
+0800..082D    ; Exclusion                      # 5.2   [46] SAMARITAN LETTER ALAF..SAMARITAN MARK NEQUDAA
+1681..169A    ; Exclusion                      # 3.0   [26] OGHAM LETTER BEITH..OGHAM LETTER PEITH
+16A0..16EA    ; Exclusion                      # 3.0   [75] RUNIC LETTER FEHU FEOH FE F..RUNIC LETTER X
+16EE..16F0    ; Exclusion                      # 3.0    [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHOR SYMBOL
+16F1..16F8    ; Exclusion                      # 7.0    [8] RUNIC LETTER K..RUNIC LETTER FRANKS CASKET AESC
+1700..170C    ; Exclusion                      # 3.2   [13] TAGALOG LETTER A..TAGALOG LETTER YA
+170D          ; Exclusion                      # 14.0       TAGALOG LETTER RA
+170E..1714    ; Exclusion                      # 3.2    [7] TAGALOG LETTER LA..TAGALOG SIGN VIRAMA
+1715          ; Exclusion                      # 14.0       TAGALOG SIGN PAMUDPOD
+171F          ; Exclusion                      # 14.0       TAGALOG LETTER ARCHAIC RA
+1720..1734    ; Exclusion                      # 3.2   [21] HANUNOO LETTER A..HANUNOO SIGN PAMUDPOD
+1740..1753    ; Exclusion                      # 3.2   [20] BUHID LETTER A..BUHID VOWEL SIGN U
+1760..176C    ; Exclusion                      # 3.2   [13] TAGBANWA LETTER A..TAGBANWA LETTER YA
+176E..1770    ; Exclusion                      # 3.2    [3] TAGBANWA LETTER LA..TAGBANWA LETTER SA
+1772..1773    ; Exclusion                      # 3.2    [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U
+1810..1819    ; Exclusion                      # 3.0   [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE
+1820..1877    ; Exclusion                      # 3.0   [88] MONGOLIAN LETTER A..MONGOLIAN LETTER MANCHU ZHA
+1878          ; Exclusion                      # 11.0       MONGOLIAN LETTER CHA WITH TWO DOTS
+1880..18A8    ; Exclusion                      # 3.0   [41] MONGOLIAN LETTER ALI GALI ANUSVARA ONE..MONGOLIAN LETTER MANCHU ALI GALI BHA
+18AA          ; Exclusion                      # 5.1        MONGOLIAN LETTER MANCHU ALI GALI LHA
+1A00..1A1B    ; Exclusion                      # 4.1   [28] BUGINESE LETTER KA..BUGINESE VOWEL SIGN AE
+1CFA          ; Exclusion                      # 12.0       VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA
+2C00..2C2E    ; Exclusion                      # 4.1   [47] GLAGOLITIC CAPITAL LETTER AZU..GLAGOLITIC CAPITAL LETTER LATINATE MYSLITE
+2C2F          ; Exclusion                      # 14.0       GLAGOLITIC CAPITAL LETTER CAUDATE CHRIVI
+2C30..2C5E    ; Exclusion                      # 4.1   [47] GLAGOLITIC SMALL LETTER AZU..GLAGOLITIC SMALL LETTER LATINATE MYSLITE
+2C5F          ; Exclusion                      # 14.0       GLAGOLITIC SMALL LETTER CAUDATE CHRIVI
+2C80..2CE4    ; Exclusion                      # 4.1  [101] COPTIC CAPITAL LETTER ALFA..COPTIC SYMBOL KAI
+2CEB..2CEF    ; Exclusion                      # 5.2    [5] COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI..COPTIC COMBINING NI ABOVE
+2CF2..2CF3    ; Exclusion                      # 6.1    [2] COPTIC CAPITAL LETTER BOHAIRIC KHEI..COPTIC SMALL LETTER BOHAIRIC KHEI
+A840..A873    ; Exclusion                      # 5.0   [52] PHAGS-PA LETTER KA..PHAGS-PA LETTER CANDRABINDU
+A930..A953    ; Exclusion                      # 5.1   [36] REJANG LETTER KA..REJANG VIRAMA
+10000..1000B  ; Exclusion                      # 4.0   [12] LINEAR B SYLLABLE B008 A..LINEAR B SYLLABLE B046 JE
+1000D..10026  ; Exclusion                      # 4.0   [26] LINEAR B SYLLABLE B036 JO..LINEAR B SYLLABLE B032 QO
+10028..1003A  ; Exclusion                      # 4.0   [19] LINEAR B SYLLABLE B060 RA..LINEAR B SYLLABLE B042 WO
+1003C..1003D  ; Exclusion                      # 4.0    [2] LINEAR B SYLLABLE B017 ZA..LINEAR B SYLLABLE B074 ZE
+1003F..1004D  ; Exclusion                      # 4.0   [15] LINEAR B SYLLABLE B020 ZO..LINEAR B SYLLABLE B091 TWO
+10050..1005D  ; Exclusion                      # 4.0   [14] LINEAR B SYMBOL B018..LINEAR B SYMBOL B089
+10080..100FA  ; Exclusion                      # 4.0  [123] LINEAR B IDEOGRAM B100 MAN..LINEAR B IDEOGRAM VESSEL B305
+10280..1029C  ; Exclusion                      # 5.1   [29] LYCIAN LETTER A..LYCIAN LETTER X
+102A0..102D0  ; Exclusion                      # 5.1   [49] CARIAN LETTER A..CARIAN LETTER UUU3
+10300..1031E  ; Exclusion                      # 3.1   [31] OLD ITALIC LETTER A..OLD ITALIC LETTER UU
+1031F         ; Exclusion                      # 7.0        OLD ITALIC LETTER ESS
+1032D..1032F  ; Exclusion                      # 10.0   [3] OLD ITALIC LETTER YE..OLD ITALIC LETTER SOUTHERN TSE
+10330..1034A  ; Exclusion                      # 3.1   [27] GOTHIC LETTER AHSA..GOTHIC LETTER NINE HUNDRED
+10350..1037A  ; Exclusion                      # 7.0   [43] OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII
+10380..1039D  ; Exclusion                      # 4.0   [30] UGARITIC LETTER ALPA..UGARITIC LETTER SSU
+103A0..103C3  ; Exclusion                      # 4.1   [36] OLD PERSIAN SIGN A..OLD PERSIAN SIGN HA
+103C8..103CF  ; Exclusion                      # 4.1    [8] OLD PERSIAN SIGN AURAMAZDAA..OLD PERSIAN SIGN BUUMISH
+103D1..103D5  ; Exclusion                      # 4.1    [5] OLD PERSIAN NUMBER ONE..OLD PERSIAN NUMBER HUNDRED
+10400..10425  ; Exclusion                      # 3.1   [38] DESERET CAPITAL LETTER LONG I..DESERET CAPITAL LETTER ENG
+10426..10427  ; Exclusion                      # 4.0    [2] DESERET CAPITAL LETTER OI..DESERET CAPITAL LETTER EW
+10428..1044D  ; Exclusion                      # 3.1   [38] DESERET SMALL LETTER LONG I..DESERET SMALL LETTER ENG
+1044E..1049D  ; Exclusion                      # 4.0   [80] DESERET SMALL LETTER OI..OSMANYA LETTER OO
+104A0..104A9  ; Exclusion                      # 4.0   [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE
+10500..10527  ; Exclusion                      # 7.0   [40] ELBASAN LETTER A..ELBASAN LETTER KHE
+10530..10563  ; Exclusion                      # 7.0   [52] CAUCASIAN ALBANIAN LETTER ALT..CAUCASIAN ALBANIAN LETTER KIW
+10570..1057A  ; Exclusion                      # 14.0  [11] VITHKUQI CAPITAL LETTER A..VITHKUQI CAPITAL LETTER GA
+1057C..1058A  ; Exclusion                      # 14.0  [15] VITHKUQI CAPITAL LETTER HA..VITHKUQI CAPITAL LETTER RE
+1058C..10592  ; Exclusion                      # 14.0   [7] VITHKUQI CAPITAL LETTER SE..VITHKUQI CAPITAL LETTER XE
+10594..10595  ; Exclusion                      # 14.0   [2] VITHKUQI CAPITAL LETTER Y..VITHKUQI CAPITAL LETTER ZE
+10597..105A1  ; Exclusion                      # 14.0  [11] VITHKUQI SMALL LETTER A..VITHKUQI SMALL LETTER GA
+105A3..105B1  ; Exclusion                      # 14.0  [15] VITHKUQI SMALL LETTER HA..VITHKUQI SMALL LETTER RE
+105B3..105B9  ; Exclusion                      # 14.0   [7] VITHKUQI SMALL LETTER SE..VITHKUQI SMALL LETTER XE
+105BB..105BC  ; Exclusion                      # 14.0   [2] VITHKUQI SMALL LETTER Y..VITHKUQI SMALL LETTER ZE
+105C0..105F3  ; Exclusion                      # 16.0  [52] TODHRI LETTER A..TODHRI LETTER OO
+10600..10736  ; Exclusion                      # 7.0  [311] LINEAR A SIGN AB001..LINEAR A SIGN A664
+10740..10755  ; Exclusion                      # 7.0   [22] LINEAR A SIGN A701 A..LINEAR A SIGN A732 JE
+10760..10767  ; Exclusion                      # 7.0    [8] LINEAR A SIGN A800..LINEAR A SIGN A807
+10800..10805  ; Exclusion                      # 4.0    [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA
+10808         ; Exclusion                      # 4.0        CYPRIOT SYLLABLE JO
+1080A..10835  ; Exclusion                      # 4.0   [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO
+10837..10838  ; Exclusion                      # 4.0    [2] CYPRIOT SYLLABLE XA..CYPRIOT SYLLABLE XE
+1083C         ; Exclusion                      # 4.0        CYPRIOT SYLLABLE ZA
+1083F         ; Exclusion                      # 4.0        CYPRIOT SYLLABLE ZO
+10840..10855  ; Exclusion                      # 5.2   [22] IMPERIAL ARAMAIC LETTER ALEPH..IMPERIAL ARAMAIC LETTER TAW
+10860..10876  ; Exclusion                      # 7.0   [23] PALMYRENE LETTER ALEPH..PALMYRENE LETTER TAW
+10880..1089E  ; Exclusion                      # 7.0   [31] NABATAEAN LETTER FINAL ALEPH..NABATAEAN LETTER TAW
+108E0..108F2  ; Exclusion                      # 8.0   [19] HATRAN LETTER ALEPH..HATRAN LETTER QOPH
+108F4..108F5  ; Exclusion                      # 8.0    [2] HATRAN LETTER SHIN..HATRAN LETTER TAW
+10900..10915  ; Exclusion                      # 5.0   [22] PHOENICIAN LETTER ALF..PHOENICIAN LETTER TAU
+10920..10939  ; Exclusion                      # 5.1   [26] LYDIAN LETTER A..LYDIAN LETTER C
+10940..10959  ; Exclusion                      # 17.0  [26] SIDETIC LETTER N01..SIDETIC LETTER N26
+10980..109B7  ; Exclusion                      # 6.1   [56] MEROITIC HIEROGLYPHIC LETTER A..MEROITIC CURSIVE LETTER DA
+109BE..109BF  ; Exclusion                      # 6.1    [2] MEROITIC CURSIVE LOGOGRAM RMT..MEROITIC CURSIVE LOGOGRAM IMN
+10A00..10A03  ; Exclusion                      # 4.1    [4] KHAROSHTHI LETTER A..KHAROSHTHI VOWEL SIGN VOCALIC R
+10A05..10A06  ; Exclusion                      # 4.1    [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O
+10A0C..10A13  ; Exclusion                      # 4.1    [8] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI LETTER GHA
+10A15..10A17  ; Exclusion                      # 4.1    [3] KHAROSHTHI LETTER CA..KHAROSHTHI LETTER JA
+10A19..10A33  ; Exclusion                      # 4.1   [27] KHAROSHTHI LETTER NYA..KHAROSHTHI LETTER TTTHA
+10A34..10A35  ; Exclusion                      # 11.0   [2] KHAROSHTHI LETTER TTTA..KHAROSHTHI LETTER VHA
+10A38..10A3A  ; Exclusion                      # 4.1    [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW
+10A3F         ; Exclusion                      # 4.1        KHAROSHTHI VIRAMA
+10A60..10A7C  ; Exclusion                      # 5.2   [29] OLD SOUTH ARABIAN LETTER HE..OLD SOUTH ARABIAN LETTER THETH
+10A80..10A9C  ; Exclusion                      # 7.0   [29] OLD NORTH ARABIAN LETTER HEH..OLD NORTH ARABIAN LETTER ZAH
+10AC0..10AC7  ; Exclusion                      # 7.0    [8] MANICHAEAN LETTER ALEPH..MANICHAEAN LETTER WAW
+10AC9..10AE6  ; Exclusion                      # 7.0   [30] MANICHAEAN LETTER ZAYIN..MANICHAEAN ABBREVIATION MARK BELOW
+10B00..10B35  ; Exclusion                      # 5.2   [54] AVESTAN LETTER A..AVESTAN LETTER HE
+10B40..10B55  ; Exclusion                      # 5.2   [22] INSCRIPTIONAL PARTHIAN LETTER ALEPH..INSCRIPTIONAL PARTHIAN LETTER TAW
+10B60..10B72  ; Exclusion                      # 5.2   [19] INSCRIPTIONAL PAHLAVI LETTER ALEPH..INSCRIPTIONAL PAHLAVI LETTER TAW
+10B80..10B91  ; Exclusion                      # 7.0   [18] PSALTER PAHLAVI LETTER ALEPH..PSALTER PAHLAVI LETTER TAW
+10C00..10C48  ; Exclusion                      # 5.2   [73] OLD TURKIC LETTER ORKHON A..OLD TURKIC LETTER ORKHON BASH
+10C80..10CB2  ; Exclusion                      # 8.0   [51] OLD HUNGARIAN CAPITAL LETTER A..OLD HUNGARIAN CAPITAL LETTER US
+10CC0..10CF2  ; Exclusion                      # 8.0   [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US
+10D40..10D65  ; Exclusion                      # 16.0  [38] GARAY DIGIT ZERO..GARAY CAPITAL LETTER OLD NA
+10D69..10D6D  ; Exclusion                      # 16.0   [5] GARAY VOWEL SIGN E..GARAY CONSONANT NASALIZATION MARK
+10D6F..10D85  ; Exclusion                      # 16.0  [23] GARAY REDUPLICATION MARK..GARAY SMALL LETTER OLD NA
+10E80..10EA9  ; Exclusion                      # 13.0  [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET
+10EAB..10EAC  ; Exclusion                      # 13.0   [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK
+10EB0..10EB1  ; Exclusion                      # 13.0   [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE
+10F00..10F1C  ; Exclusion                      # 11.0  [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL
+10F27         ; Exclusion                      # 11.0       OLD SOGDIAN LIGATURE AYIN-DALETH
+10F30..10F50  ; Exclusion                      # 11.0  [33] SOGDIAN LETTER ALEPH..SOGDIAN COMBINING STROKE BELOW
+10F70..10F85  ; Exclusion                      # 14.0  [22] OLD UYGHUR LETTER ALEPH..OLD UYGHUR COMBINING TWO DOTS BELOW
+10FB0..10FC4  ; Exclusion                      # 13.0  [21] CHORASMIAN LETTER ALEPH..CHORASMIAN LETTER TAW
+10FE0..10FF6  ; Exclusion                      # 12.0  [23] ELYMAIC LETTER ALEPH..ELYMAIC LIGATURE ZAYIN-YODH
+11000..11046  ; Exclusion                      # 6.0   [71] BRAHMI SIGN CANDRABINDU..BRAHMI VIRAMA
+11066..1106F  ; Exclusion                      # 6.0   [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT NINE
+11070..11075  ; Exclusion                      # 14.0   [6] BRAHMI SIGN OLD TAMIL VIRAMA..BRAHMI LETTER OLD TAMIL LLA
+1107F         ; Exclusion                      # 7.0        BRAHMI NUMBER JOINER
+11080..110BA  ; Exclusion                      # 5.2   [59] KAITHI SIGN CANDRABINDU..KAITHI SIGN NUKTA
+110C2         ; Exclusion                      # 14.0       KAITHI VOWEL SIGN VOCALIC R
+110D0..110E8  ; Exclusion                      # 6.1   [25] SORA SOMPENG LETTER SAH..SORA SOMPENG LETTER MAE
+110F0..110F9  ; Exclusion                      # 6.1   [10] SORA SOMPENG DIGIT ZERO..SORA SOMPENG DIGIT NINE
+11150..11173  ; Exclusion                      # 7.0   [36] MAHAJANI LETTER A..MAHAJANI SIGN NUKTA
+11176         ; Exclusion                      # 7.0        MAHAJANI LIGATURE SHRI
+11180..111C4  ; Exclusion                      # 6.1   [69] SHARADA SIGN CANDRABINDU..SHARADA OM
+111C9..111CC  ; Exclusion                      # 8.0    [4] SHARADA SANDHI MARK..SHARADA EXTRA SHORT VOWEL MARK
+111CE..111CF  ; Exclusion                      # 13.0   [2] SHARADA VOWEL SIGN PRISHTHAMATRA E..SHARADA SIGN INVERTED CANDRABINDU
+111D0..111D9  ; Exclusion                      # 6.1   [10] SHARADA DIGIT ZERO..SHARADA DIGIT NINE
+111DA         ; Exclusion                      # 7.0        SHARADA EKAM
+111DC         ; Exclusion                      # 8.0        SHARADA HEADSTROKE
+11200..11211  ; Exclusion                      # 7.0   [18] KHOJKI LETTER A..KHOJKI LETTER JJA
+11213..11237  ; Exclusion                      # 7.0   [37] KHOJKI LETTER NYA..KHOJKI SIGN SHADDA
+1123E         ; Exclusion                      # 9.0        KHOJKI SIGN SUKUN
+1123F..11241  ; Exclusion                      # 15.0   [3] KHOJKI LETTER QA..KHOJKI VOWEL SIGN VOCALIC R
+11280..11286  ; Exclusion                      # 8.0    [7] MULTANI LETTER A..MULTANI LETTER GA
+11288         ; Exclusion                      # 8.0        MULTANI LETTER GHA
+1128A..1128D  ; Exclusion                      # 8.0    [4] MULTANI LETTER CA..MULTANI LETTER JJA
+1128F..1129D  ; Exclusion                      # 8.0   [15] MULTANI LETTER NYA..MULTANI LETTER BA
+1129F..112A8  ; Exclusion                      # 8.0   [10] MULTANI LETTER BHA..MULTANI LETTER RHA
+112B0..112EA  ; Exclusion                      # 7.0   [59] KHUDAWADI LETTER A..KHUDAWADI SIGN VIRAMA
+112F0..112F9  ; Exclusion                      # 7.0   [10] KHUDAWADI DIGIT ZERO..KHUDAWADI DIGIT NINE
+11300         ; Exclusion                      # 8.0        GRANTHA SIGN COMBINING ANUSVARA ABOVE
+11302         ; Exclusion                      # 7.0        GRANTHA SIGN ANUSVARA
+11305..1130C  ; Exclusion                      # 7.0    [8] GRANTHA LETTER A..GRANTHA LETTER VOCALIC L
+1130F..11310  ; Exclusion                      # 7.0    [2] GRANTHA LETTER EE..GRANTHA LETTER AI
+11313..11328  ; Exclusion                      # 7.0   [22] GRANTHA LETTER OO..GRANTHA LETTER NA
+1132A..11330  ; Exclusion                      # 7.0    [7] GRANTHA LETTER PA..GRANTHA LETTER RA
+11332..11333  ; Exclusion                      # 7.0    [2] GRANTHA LETTER LA..GRANTHA LETTER LLA
+11335..11339  ; Exclusion                      # 7.0    [5] GRANTHA LETTER VA..GRANTHA LETTER HA
+1133D..11344  ; Exclusion                      # 7.0    [8] GRANTHA SIGN AVAGRAHA..GRANTHA VOWEL SIGN VOCALIC RR
+11347..11348  ; Exclusion                      # 7.0    [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI
+1134B..1134D  ; Exclusion                      # 7.0    [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA
+11350         ; Exclusion                      # 8.0        GRANTHA OM
+11357         ; Exclusion                      # 7.0        GRANTHA AU LENGTH MARK
+1135D..11363  ; Exclusion                      # 7.0    [7] GRANTHA SIGN PLUTA..GRANTHA VOWEL SIGN VOCALIC LL
+11366..1136C  ; Exclusion                      # 7.0    [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX
+11370..11374  ; Exclusion                      # 7.0    [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA
+11380..11389  ; Exclusion                      # 16.0  [10] TULU-TIGALARI LETTER A..TULU-TIGALARI LETTER VOCALIC LL
+1138B         ; Exclusion                      # 16.0       TULU-TIGALARI LETTER EE
+1138E         ; Exclusion                      # 16.0       TULU-TIGALARI LETTER AI
+11390..113B5  ; Exclusion                      # 16.0  [38] TULU-TIGALARI LETTER OO..TULU-TIGALARI LETTER LLLA
+113B7..113C0  ; Exclusion                      # 16.0  [10] TULU-TIGALARI SIGN AVAGRAHA..TULU-TIGALARI VOWEL SIGN VOCALIC LL
+113C2         ; Exclusion                      # 16.0       TULU-TIGALARI VOWEL SIGN EE
+113C5         ; Exclusion                      # 16.0       TULU-TIGALARI VOWEL SIGN AI
+113C7..113CA  ; Exclusion                      # 16.0   [4] TULU-TIGALARI VOWEL SIGN OO..TULU-TIGALARI SIGN CANDRA ANUNASIKA
+113CC..113D3  ; Exclusion                      # 16.0   [8] TULU-TIGALARI SIGN ANUSVARA..TULU-TIGALARI SIGN PLUTA
+113E1..113E2  ; Exclusion                      # 16.0   [2] TULU-TIGALARI VEDIC TONE SVARITA..TULU-TIGALARI VEDIC TONE ANUDATTA
+11480..114C5  ; Exclusion                      # 7.0   [70] TIRHUTA ANJI..TIRHUTA GVANG
+114C7         ; Exclusion                      # 7.0        TIRHUTA OM
+114D0..114D9  ; Exclusion                      # 7.0   [10] TIRHUTA DIGIT ZERO..TIRHUTA DIGIT NINE
+11580..115B5  ; Exclusion                      # 7.0   [54] SIDDHAM LETTER A..SIDDHAM VOWEL SIGN VOCALIC RR
+115B8..115C0  ; Exclusion                      # 7.0    [9] SIDDHAM VOWEL SIGN E..SIDDHAM SIGN NUKTA
+115D8..115DD  ; Exclusion                      # 8.0    [6] SIDDHAM LETTER THREE-CIRCLE ALTERNATE I..SIDDHAM VOWEL SIGN ALTERNATE UU
+11600..11640  ; Exclusion                      # 7.0   [65] MODI LETTER A..MODI SIGN ARDHACANDRA
+11644         ; Exclusion                      # 7.0        MODI SIGN HUVA
+11650..11659  ; Exclusion                      # 7.0   [10] MODI DIGIT ZERO..MODI DIGIT NINE
+11680..116B7  ; Exclusion                      # 6.1   [56] TAKRI LETTER A..TAKRI SIGN NUKTA
+116B8         ; Exclusion                      # 12.0       TAKRI LETTER ARCHAIC KHA
+116C0..116C9  ; Exclusion                      # 6.1   [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE
+11700..11719  ; Exclusion                      # 8.0   [26] AHOM LETTER KA..AHOM LETTER JHA
+1171A         ; Exclusion                      # 11.0       AHOM LETTER ALTERNATE BA
+1171D..1172B  ; Exclusion                      # 8.0   [15] AHOM CONSONANT SIGN MEDIAL LA..AHOM SIGN KILLER
+11730..11739  ; Exclusion                      # 8.0   [10] AHOM DIGIT ZERO..AHOM DIGIT NINE
+11740..11746  ; Exclusion                      # 14.0   [7] AHOM LETTER CA..AHOM LETTER LLA
+11800..1183A  ; Exclusion                      # 11.0  [59] DOGRA LETTER A..DOGRA SIGN NUKTA
+118A0..118E9  ; Exclusion                      # 7.0   [74] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI DIGIT NINE
+118FF         ; Exclusion                      # 7.0        WARANG CITI OM
+11900..11906  ; Exclusion                      # 13.0   [7] DIVES AKURU LETTER A..DIVES AKURU LETTER E
+11909         ; Exclusion                      # 13.0       DIVES AKURU LETTER O
+1190C..11913  ; Exclusion                      # 13.0   [8] DIVES AKURU LETTER KA..DIVES AKURU LETTER JA
+11915..11916  ; Exclusion                      # 13.0   [2] DIVES AKURU LETTER NYA..DIVES AKURU LETTER TTA
+11918..11935  ; Exclusion                      # 13.0  [30] DIVES AKURU LETTER DDA..DIVES AKURU VOWEL SIGN E
+11937..11938  ; Exclusion                      # 13.0   [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O
+1193B..11943  ; Exclusion                      # 13.0   [9] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN NUKTA
+11950..11959  ; Exclusion                      # 13.0  [10] DIVES AKURU DIGIT ZERO..DIVES AKURU DIGIT NINE
+119A0..119A7  ; Exclusion                      # 12.0   [8] NANDINAGARI LETTER A..NANDINAGARI LETTER VOCALIC RR
+119AA..119D7  ; Exclusion                      # 12.0  [46] NANDINAGARI LETTER E..NANDINAGARI VOWEL SIGN VOCALIC RR
+119DA..119E1  ; Exclusion                      # 12.0   [8] NANDINAGARI VOWEL SIGN E..NANDINAGARI SIGN AVAGRAHA
+119E3..119E4  ; Exclusion                      # 12.0   [2] NANDINAGARI HEADSTROKE..NANDINAGARI VOWEL SIGN PRISHTHAMATRA E
+11A00..11A3E  ; Exclusion                      # 10.0  [63] ZANABAZAR SQUARE LETTER A..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA
+11A47         ; Exclusion                      # 10.0       ZANABAZAR SQUARE SUBJOINER
+11A50..11A83  ; Exclusion                      # 10.0  [52] SOYOMBO LETTER A..SOYOMBO LETTER KSSA
+11A84..11A85  ; Exclusion                      # 12.0   [2] SOYOMBO SIGN JIHVAMULIYA..SOYOMBO SIGN UPADHMANIYA
+11A86..11A99  ; Exclusion                      # 10.0  [20] SOYOMBO CLUSTER-INITIAL LETTER RA..SOYOMBO SUBJOINER
+11A9D         ; Exclusion                      # 11.0       SOYOMBO MARK PLUTA
+11AC0..11AF8  ; Exclusion                      # 7.0   [57] PAU CIN HAU LETTER PA..PAU CIN HAU GLOTTAL STOP FINAL
+11B60..11B67  ; Exclusion                      # 17.0   [8] SHARADA VOWEL SIGN OE..SHARADA VOWEL SIGN CANDRA O
+11BC0..11BE0  ; Exclusion                      # 16.0  [33] SUNUWAR LETTER DEVI..SUNUWAR LETTER KLOKO
+11BF0..11BF9  ; Exclusion                      # 16.0  [10] SUNUWAR DIGIT ZERO..SUNUWAR DIGIT NINE
+11C00..11C08  ; Exclusion                      # 9.0    [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L
+11C0A..11C36  ; Exclusion                      # 9.0   [45] BHAIKSUKI LETTER E..BHAIKSUKI VOWEL SIGN VOCALIC L
+11C38..11C40  ; Exclusion                      # 9.0    [9] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN AVAGRAHA
+11C50..11C59  ; Exclusion                      # 9.0   [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI DIGIT NINE
+11C72..11C8F  ; Exclusion                      # 9.0   [30] MARCHEN LETTER KA..MARCHEN LETTER A
+11C92..11CA7  ; Exclusion                      # 9.0   [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA
+11CA9..11CB6  ; Exclusion                      # 9.0   [14] MARCHEN SUBJOINED LETTER YA..MARCHEN SIGN CANDRABINDU
+11D00..11D06  ; Exclusion                      # 10.0   [7] MASARAM GONDI LETTER A..MASARAM GONDI LETTER E
+11D08..11D09  ; Exclusion                      # 10.0   [2] MASARAM GONDI LETTER AI..MASARAM GONDI LETTER O
+11D0B..11D36  ; Exclusion                      # 10.0  [44] MASARAM GONDI LETTER AU..MASARAM GONDI VOWEL SIGN VOCALIC R
+11D3A         ; Exclusion                      # 10.0       MASARAM GONDI VOWEL SIGN E
+11D3C..11D3D  ; Exclusion                      # 10.0   [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O
+11D3F..11D47  ; Exclusion                      # 10.0   [9] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI RA-KARA
+11D50..11D59  ; Exclusion                      # 10.0  [10] MASARAM GONDI DIGIT ZERO..MASARAM GONDI DIGIT NINE
+11D60..11D65  ; Exclusion                      # 11.0   [6] GUNJALA GONDI LETTER A..GUNJALA GONDI LETTER UU
+11D67..11D68  ; Exclusion                      # 11.0   [2] GUNJALA GONDI LETTER EE..GUNJALA GONDI LETTER AI
+11D6A..11D8E  ; Exclusion                      # 11.0  [37] GUNJALA GONDI LETTER OO..GUNJALA GONDI VOWEL SIGN UU
+11D90..11D91  ; Exclusion                      # 11.0   [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI
+11D93..11D98  ; Exclusion                      # 11.0   [6] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI OM
+11DA0..11DA9  ; Exclusion                      # 11.0  [10] GUNJALA GONDI DIGIT ZERO..GUNJALA GONDI DIGIT NINE
+11DB0..11DDB  ; Exclusion                      # 17.0  [44] TOLONG SIKI LETTER I..TOLONG SIKI UNGGA
+11DE0..11DE9  ; Exclusion                      # 17.0  [10] TOLONG SIKI DIGIT ZERO..TOLONG SIKI DIGIT NINE
+11EE0..11EF6  ; Exclusion                      # 11.0  [23] MAKASAR LETTER KA..MAKASAR VOWEL SIGN O
+11F00..11F10  ; Exclusion                      # 15.0  [17] KAWI SIGN CANDRABINDU..KAWI LETTER O
+11F12..11F3A  ; Exclusion                      # 15.0  [41] KAWI LETTER KA..KAWI VOWEL SIGN VOCALIC R
+11F3E..11F42  ; Exclusion                      # 15.0   [5] KAWI VOWEL SIGN E..KAWI CONJOINER
+11F50..11F59  ; Exclusion                      # 15.0  [10] KAWI DIGIT ZERO..KAWI DIGIT NINE
+11F5A         ; Exclusion                      # 16.0       KAWI SIGN NUKTA
+12000..1236E  ; Exclusion                      # 5.0  [879] CUNEIFORM SIGN A..CUNEIFORM SIGN ZUM
+1236F..12398  ; Exclusion                      # 7.0   [42] CUNEIFORM SIGN KAP ELAMITE..CUNEIFORM SIGN UM TIMES ME
+12399         ; Exclusion                      # 8.0        CUNEIFORM SIGN U U
+12400..12462  ; Exclusion                      # 5.0   [99] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN OLD ASSYRIAN ONE QUARTER
+12463..1246E  ; Exclusion                      # 7.0   [12] CUNEIFORM NUMERIC SIGN ONE QUARTER GUR..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM
+12480..12543  ; Exclusion                      # 8.0  [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU
+12F90..12FF0  ; Exclusion                      # 14.0  [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114
+13000..1342E  ; Exclusion                      # 5.2 [1071] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH AA032
+1342F         ; Exclusion                      # 15.0       EGYPTIAN HIEROGLYPH V011D
+13440..13455  ; Exclusion                      # 15.0  [22] EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED
+13460..143FA  ; Exclusion                      # 16.0 [3995] EGYPTIAN HIEROGLYPH-13460..EGYPTIAN HIEROGLYPH-143FA
+14400..14646  ; Exclusion                      # 8.0  [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530
+16100..16139  ; Exclusion                      # 16.0  [58] GURUNG KHEMA LETTER A..GURUNG KHEMA DIGIT NINE
+16A70..16ABE  ; Exclusion                      # 14.0  [79] TANGSA LETTER OZ..TANGSA LETTER ZA
+16AC0..16AC9  ; Exclusion                      # 14.0  [10] TANGSA DIGIT ZERO..TANGSA DIGIT NINE
+16AD0..16AED  ; Exclusion                      # 7.0   [30] BASSA VAH LETTER ENNI..BASSA VAH LETTER I
+16AF0..16AF4  ; Exclusion                      # 7.0    [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE
+16B00..16B36  ; Exclusion                      # 7.0   [55] PAHAWH HMONG VOWEL KEEB..PAHAWH HMONG MARK CIM TAUM
+16B40..16B43  ; Exclusion                      # 7.0    [4] PAHAWH HMONG SIGN VOS SEEV..PAHAWH HMONG SIGN IB YAM
+16B50..16B59  ; Exclusion                      # 7.0   [10] PAHAWH HMONG DIGIT ZERO..PAHAWH HMONG DIGIT NINE
+16B63..16B77  ; Exclusion                      # 7.0   [21] PAHAWH HMONG SIGN VOS LUB..PAHAWH HMONG SIGN CIM NRES TOS
+16B7D..16B8F  ; Exclusion                      # 7.0   [19] PAHAWH HMONG CLAN SIGN TSHEEJ..PAHAWH HMONG CLAN SIGN VWJ
+16D40..16D6C  ; Exclusion                      # 16.0  [45] KIRAT RAI SIGN ANUSVARA..KIRAT RAI SIGN SAAT
+16D70..16D79  ; Exclusion                      # 16.0  [10] KIRAT RAI DIGIT ZERO..KIRAT RAI DIGIT NINE
+16E40..16E7F  ; Exclusion                      # 11.0  [64] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN SMALL LETTER Y
+16EA0..16EB8  ; Exclusion                      # 17.0  [25] BERIA ERFE CAPITAL LETTER ARKAB..BERIA ERFE CAPITAL LETTER AY
+16EBB..16ED3  ; Exclusion                      # 17.0  [25] BERIA ERFE SMALL LETTER ARKAB..BERIA ERFE SMALL LETTER AY
+16FE0         ; Exclusion                      # 9.0        TANGUT ITERATION MARK
+16FE1         ; Exclusion                      # 10.0       NUSHU ITERATION MARK
+16FE4         ; Exclusion                      # 13.0       KHITAN SMALL SCRIPT FILLER
+17000..187EC  ; Exclusion                      # 9.0 [6125] TANGUT IDEOGRAPH-17000..TANGUT IDEOGRAPH-187EC
+187ED..187F1  ; Exclusion                      # 11.0   [5] TANGUT IDEOGRAPH-187ED..TANGUT IDEOGRAPH-187F1
+187F2..187F7  ; Exclusion                      # 12.0   [6] TANGUT IDEOGRAPH-187F2..TANGUT IDEOGRAPH-187F7
+187F8..187FF  ; Exclusion                      # 17.0   [8] TANGUT IDEOGRAPH-187F8..TANGUT IDEOGRAPH-187FF
+18800..18AF2  ; Exclusion                      # 9.0  [755] TANGUT COMPONENT-001..TANGUT COMPONENT-755
+18AF3..18CD5  ; Exclusion                      # 13.0 [483] TANGUT COMPONENT-756..KHITAN SMALL SCRIPT CHARACTER-18CD5
+18CFF         ; Exclusion                      # 16.0       KHITAN SMALL SCRIPT CHARACTER-18CFF
+18D00..18D08  ; Exclusion                      # 13.0   [9] TANGUT IDEOGRAPH-18D00..TANGUT IDEOGRAPH-18D08
+18D09..18D1E  ; Exclusion                      # 17.0  [22] TANGUT IDEOGRAPH-18D09..TANGUT IDEOGRAPH-18D1E
+18D80..18DF2  ; Exclusion                      # 17.0 [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883
+1B170..1B2FB  ; Exclusion                      # 10.0 [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB
+1BC00..1BC6A  ; Exclusion                      # 7.0  [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M
+1BC70..1BC7C  ; Exclusion                      # 7.0   [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK
+1BC80..1BC88  ; Exclusion                      # 7.0    [9] DUPLOYAN AFFIX HIGH ACUTE..DUPLOYAN AFFIX HIGH VERTICAL
+1BC90..1BC99  ; Exclusion                      # 7.0   [10] DUPLOYAN AFFIX LOW ACUTE..DUPLOYAN AFFIX LOW ARROW
+1BC9D..1BC9E  ; Exclusion                      # 7.0    [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK
+1DA00..1DA36  ; Exclusion                      # 8.0   [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN
+1DA3B..1DA6C  ; Exclusion                      # 8.0   [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT
+1DA75         ; Exclusion                      # 8.0        SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS
+1DA84         ; Exclusion                      # 8.0        SIGNWRITING LOCATION HEAD NECK
+1DA9B..1DA9F  ; Exclusion                      # 8.0    [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6
+1DAA1..1DAAF  ; Exclusion                      # 8.0   [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16
+1E000..1E006  ; Exclusion                      # 9.0    [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE
+1E008..1E018  ; Exclusion                      # 9.0   [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU
+1E01B..1E021  ; Exclusion                      # 9.0    [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI
+1E023..1E024  ; Exclusion                      # 9.0    [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS
+1E026..1E02A  ; Exclusion                      # 9.0    [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA
+1E290..1E2AE  ; Exclusion                      # 14.0  [31] TOTO LETTER PA..TOTO SIGN RISING TONE
+1E4D0..1E4F9  ; Exclusion                      # 15.0  [42] NAG MUNDARI LETTER O..NAG MUNDARI DIGIT NINE
+1E5D0..1E5FA  ; Exclusion                      # 16.0  [43] OL ONAL LETTER O..OL ONAL DIGIT NINE
+1E6C0..1E6DE  ; Exclusion                      # 17.0  [31] TAI YO LETTER LOW KO..TAI YO LETTER HIGH KVO
+1E6E0..1E6F5  ; Exclusion                      # 17.0  [22] TAI YO LETTER AA..TAI YO SIGN OM
+1E6FE..1E6FF  ; Exclusion                      # 17.0   [2] TAI YO SYMBOL MUEANG..TAI YO XAM LAI
+1E800..1E8C4  ; Exclusion                      # 7.0  [197] MENDE KIKAKUI SYLLABLE M001 KI..MENDE KIKAKUI SYLLABLE M060 NYON
+1E8D0..1E8D6  ; Exclusion                      # 7.0    [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS
+
+# Total code points: 20862
+
+#	Identifier_Type:	Exclusion Not_XID
+
+0830..083E    ; Exclusion Not_XID              # 5.2   [15] SAMARITAN PUNCTUATION NEQUDAA..SAMARITAN PUNCTUATION ANNAAU
+1680          ; Exclusion Not_XID              # 3.0        OGHAM SPACE MARK
+169B..169C    ; Exclusion Not_XID              # 3.0    [2] OGHAM FEATHER MARK..OGHAM REVERSED FEATHER MARK
+16EB..16ED    ; Exclusion Not_XID              # 3.0    [3] RUNIC SINGLE PUNCTUATION..RUNIC CROSS PUNCTUATION
+1735..1736    ; Exclusion Not_XID              # 3.2    [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION
+1800..180A    ; Exclusion Not_XID              # 3.0   [11] MONGOLIAN BIRGA..MONGOLIAN NIRUGU
+1A1E..1A1F    ; Exclusion Not_XID              # 4.1    [2] BUGINESE PALLAWA..BUGINESE END OF SECTION
+2CE5..2CEA    ; Exclusion Not_XID              # 4.1    [6] COPTIC SYMBOL MI RO..COPTIC SYMBOL SHIMA SIMA
+2CF9..2CFF    ; Exclusion Not_XID              # 4.1    [7] COPTIC OLD NUBIAN FULL STOP..COPTIC MORPHOLOGICAL DIVIDER
+2E30          ; Exclusion Not_XID              # 5.1        RING POINT
+2E3C          ; Exclusion Not_XID              # 7.0        STENOGRAPHIC FULL STOP
+A874..A877    ; Exclusion Not_XID              # 5.0    [4] PHAGS-PA SINGLE HEAD MARK..PHAGS-PA MARK DOUBLE SHAD
+A95F          ; Exclusion Not_XID              # 5.1        REJANG SECTION MARK
+10100..10102  ; Exclusion Not_XID              # 4.0    [3] AEGEAN WORD SEPARATOR LINE..AEGEAN CHECK MARK
+10107..10133  ; Exclusion Not_XID              # 4.0   [45] AEGEAN NUMBER ONE..AEGEAN NUMBER NINETY THOUSAND
+10137..1013F  ; Exclusion Not_XID              # 4.0    [9] AEGEAN WEIGHT BASE UNIT..AEGEAN MEASURE THIRD SUBUNIT
+10320..10323  ; Exclusion Not_XID              # 3.1    [4] OLD ITALIC NUMERAL ONE..OLD ITALIC NUMERAL FIFTY
+1039F         ; Exclusion Not_XID              # 4.0        UGARITIC WORD DIVIDER
+103D0         ; Exclusion Not_XID              # 4.1        OLD PERSIAN WORD DIVIDER
+1056F         ; Exclusion Not_XID              # 7.0        CAUCASIAN ALBANIAN CITATION MARK
+10857..1085F  ; Exclusion Not_XID              # 5.2    [9] IMPERIAL ARAMAIC SECTION SIGN..IMPERIAL ARAMAIC NUMBER TEN THOUSAND
+10877..1087F  ; Exclusion Not_XID              # 7.0    [9] PALMYRENE LEFT-POINTING FLEURON..PALMYRENE NUMBER TWENTY
+108A7..108AF  ; Exclusion Not_XID              # 7.0    [9] NABATAEAN NUMBER ONE..NABATAEAN NUMBER ONE HUNDRED
+108FB..108FF  ; Exclusion Not_XID              # 8.0    [5] HATRAN NUMBER ONE..HATRAN NUMBER ONE HUNDRED
+10916..10919  ; Exclusion Not_XID              # 5.0    [4] PHOENICIAN NUMBER ONE..PHOENICIAN NUMBER ONE HUNDRED
+1091A..1091B  ; Exclusion Not_XID              # 5.2    [2] PHOENICIAN NUMBER TWO..PHOENICIAN NUMBER THREE
+1091F         ; Exclusion Not_XID              # 5.0        PHOENICIAN WORD SEPARATOR
+1093F         ; Exclusion Not_XID              # 5.1        LYDIAN TRIANGULAR MARK
+109BC..109BD  ; Exclusion Not_XID              # 8.0    [2] MEROITIC CURSIVE FRACTION ELEVEN TWELFTHS..MEROITIC CURSIVE FRACTION ONE HALF
+109C0..109CF  ; Exclusion Not_XID              # 8.0   [16] MEROITIC CURSIVE NUMBER ONE..MEROITIC CURSIVE NUMBER SEVENTY
+109D2..109FF  ; Exclusion Not_XID              # 8.0   [46] MEROITIC CURSIVE NUMBER ONE HUNDRED..MEROITIC CURSIVE FRACTION TEN TWELFTHS
+10A40..10A47  ; Exclusion Not_XID              # 4.1    [8] KHAROSHTHI DIGIT ONE..KHAROSHTHI NUMBER ONE THOUSAND
+10A48         ; Exclusion Not_XID              # 11.0       KHAROSHTHI FRACTION ONE HALF
+10A50..10A58  ; Exclusion Not_XID              # 4.1    [9] KHAROSHTHI PUNCTUATION DOT..KHAROSHTHI PUNCTUATION LINES
+10A7D..10A7F  ; Exclusion Not_XID              # 5.2    [3] OLD SOUTH ARABIAN NUMBER ONE..OLD SOUTH ARABIAN NUMERIC INDICATOR
+10A9D..10A9F  ; Exclusion Not_XID              # 7.0    [3] OLD NORTH ARABIAN NUMBER ONE..OLD NORTH ARABIAN NUMBER TWENTY
+10AC8         ; Exclusion Not_XID              # 7.0        MANICHAEAN SIGN UD
+10AEB..10AF6  ; Exclusion Not_XID              # 7.0   [12] MANICHAEAN NUMBER ONE..MANICHAEAN PUNCTUATION LINE FILLER
+10B39..10B3F  ; Exclusion Not_XID              # 5.2    [7] AVESTAN ABBREVIATION MARK..LARGE ONE RING OVER TWO RINGS PUNCTUATION
+10B58..10B5F  ; Exclusion Not_XID              # 5.2    [8] INSCRIPTIONAL PARTHIAN NUMBER ONE..INSCRIPTIONAL PARTHIAN NUMBER ONE THOUSAND
+10B78..10B7F  ; Exclusion Not_XID              # 5.2    [8] INSCRIPTIONAL PAHLAVI NUMBER ONE..INSCRIPTIONAL PAHLAVI NUMBER ONE THOUSAND
+10B99..10B9C  ; Exclusion Not_XID              # 7.0    [4] PSALTER PAHLAVI SECTION MARK..PSALTER PAHLAVI FOUR DOTS WITH DOT
+10BA9..10BAF  ; Exclusion Not_XID              # 7.0    [7] PSALTER PAHLAVI NUMBER ONE..PSALTER PAHLAVI NUMBER ONE HUNDRED
+10CFA..10CFF  ; Exclusion Not_XID              # 8.0    [6] OLD HUNGARIAN NUMBER ONE..OLD HUNGARIAN NUMBER ONE THOUSAND
+10D6E         ; Exclusion Not_XID              # 16.0       GARAY HYPHEN
+10D8E..10D8F  ; Exclusion Not_XID              # 16.0   [2] GARAY PLUS SIGN..GARAY MINUS SIGN
+10EAD         ; Exclusion Not_XID              # 13.0       YEZIDI HYPHENATION MARK
+10F1D..10F26  ; Exclusion Not_XID              # 11.0  [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF
+10F51..10F59  ; Exclusion Not_XID              # 11.0   [9] SOGDIAN NUMBER ONE..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT
+10F86..10F89  ; Exclusion Not_XID              # 14.0   [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS
+10FC5..10FCB  ; Exclusion Not_XID              # 13.0   [7] CHORASMIAN NUMBER ONE..CHORASMIAN NUMBER ONE HUNDRED
+11047..1104D  ; Exclusion Not_XID              # 6.0    [7] BRAHMI DANDA..BRAHMI PUNCTUATION LOTUS
+11052..11065  ; Exclusion Not_XID              # 6.0   [20] BRAHMI NUMBER ONE..BRAHMI NUMBER ONE THOUSAND
+110BB..110BC  ; Exclusion Not_XID              # 5.2    [2] KAITHI ABBREVIATION SIGN..KAITHI ENUMERATION SIGN
+110BD         ; Exclusion Not_XID              # 5.2        KAITHI NUMBER SIGN
+110BE..110C1  ; Exclusion Not_XID              # 5.2    [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA
+110CD         ; Exclusion Not_XID              # 11.0       KAITHI NUMBER SIGN ABOVE
+11174..11175  ; Exclusion Not_XID              # 7.0    [2] MAHAJANI ABBREVIATION SIGN..MAHAJANI SECTION MARK
+111C5..111C8  ; Exclusion Not_XID              # 6.1    [4] SHARADA DANDA..SHARADA SEPARATOR
+111CD         ; Exclusion Not_XID              # 7.0        SHARADA SUTRA MARK
+111DB         ; Exclusion Not_XID              # 8.0        SHARADA SIGN SIDDHAM
+111DD..111DF  ; Exclusion Not_XID              # 8.0    [3] SHARADA CONTINUATION SIGN..SHARADA SECTION MARK-2
+11238..1123D  ; Exclusion Not_XID              # 7.0    [6] KHOJKI DANDA..KHOJKI ABBREVIATION SIGN
+112A9         ; Exclusion Not_XID              # 8.0        MULTANI SECTION MARK
+113D4..113D5  ; Exclusion Not_XID              # 16.0   [2] TULU-TIGALARI DANDA..TULU-TIGALARI DOUBLE DANDA
+113D7..113D8  ; Exclusion Not_XID              # 16.0   [2] TULU-TIGALARI SIGN OM PUSHPIKA..TULU-TIGALARI SIGN SHRII PUSHPIKA
+114C6         ; Exclusion Not_XID              # 7.0        TIRHUTA ABBREVIATION SIGN
+115C1..115C9  ; Exclusion Not_XID              # 7.0    [9] SIDDHAM SIGN SIDDHAM..SIDDHAM END OF TEXT MARK
+115CA..115D7  ; Exclusion Not_XID              # 8.0   [14] SIDDHAM SECTION MARK WITH TRIDENT AND U-SHAPED ORNAMENTS..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES
+11641..11643  ; Exclusion Not_XID              # 7.0    [3] MODI DANDA..MODI ABBREVIATION SIGN
+11660..1166C  ; Exclusion Not_XID              # 9.0   [13] MONGOLIAN BIRGA WITH ORNAMENT..MONGOLIAN TURNED SWIRL BIRGA WITH DOUBLE ORNAMENT
+116B9         ; Exclusion Not_XID              # 14.0       TAKRI ABBREVIATION SIGN
+1173A..1173F  ; Exclusion Not_XID              # 8.0    [6] AHOM NUMBER TEN..AHOM SYMBOL VI
+1183B         ; Exclusion Not_XID              # 11.0       DOGRA ABBREVIATION SIGN
+118EA..118F2  ; Exclusion Not_XID              # 7.0    [9] WARANG CITI NUMBER TEN..WARANG CITI NUMBER NINETY
+11944..11946  ; Exclusion Not_XID              # 13.0   [3] DIVES AKURU DOUBLE DANDA..DIVES AKURU END OF TEXT MARK
+119E2         ; Exclusion Not_XID              # 12.0       NANDINAGARI SIGN SIDDHAM
+11A3F..11A46  ; Exclusion Not_XID              # 10.0   [8] ZANABAZAR SQUARE INITIAL HEAD MARK..ZANABAZAR SQUARE CLOSING DOUBLE-LINED HEAD MARK
+11A9A..11A9C  ; Exclusion Not_XID              # 10.0   [3] SOYOMBO MARK TSHEG..SOYOMBO MARK DOUBLE SHAD
+11A9E..11AA2  ; Exclusion Not_XID              # 10.0   [5] SOYOMBO HEAD MARK WITH MOON AND SUN AND TRIPLE FLAME..SOYOMBO TERMINAL MARK-2
+11BE1         ; Exclusion Not_XID              # 16.0       SUNUWAR SIGN PVO
+11C41..11C45  ; Exclusion Not_XID              # 9.0    [5] BHAIKSUKI DANDA..BHAIKSUKI GAP FILLER-2
+11C5A..11C6C  ; Exclusion Not_XID              # 9.0   [19] BHAIKSUKI NUMBER ONE..BHAIKSUKI HUNDREDS UNIT MARK
+11C70..11C71  ; Exclusion Not_XID              # 9.0    [2] MARCHEN HEAD MARK..MARCHEN MARK SHAD
+11EF7..11EF8  ; Exclusion Not_XID              # 11.0   [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION
+11F43..11F4F  ; Exclusion Not_XID              # 15.0  [13] KAWI DANDA..KAWI PUNCTUATION CLOSING SPIRAL
+12470..12473  ; Exclusion Not_XID              # 5.0    [4] CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER..CUNEIFORM PUNCTUATION SIGN DIAGONAL TRICOLON
+12474         ; Exclusion Not_XID              # 7.0        CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON
+12FF1..12FF2  ; Exclusion Not_XID              # 14.0   [2] CYPRO-MINOAN SIGN CM301..CYPRO-MINOAN SIGN CM302
+13430..13438  ; Exclusion Not_XID              # 12.0   [9] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END SEGMENT
+13439..1343F  ; Exclusion Not_XID              # 15.0   [7] EGYPTIAN HIEROGLYPH INSERT AT MIDDLE..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE
+16A6E..16A6F  ; Exclusion Not_XID              # 7.0    [2] MRO DANDA..MRO DOUBLE DANDA
+16AF5         ; Exclusion Not_XID              # 7.0        BASSA VAH FULL STOP
+16B37..16B3F  ; Exclusion Not_XID              # 7.0    [9] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN XYEEM FAIB
+16B44..16B45  ; Exclusion Not_XID              # 7.0    [2] PAHAWH HMONG SIGN XAUS..PAHAWH HMONG SIGN CIM TSOV ROG
+16B5B..16B61  ; Exclusion Not_XID              # 7.0    [7] PAHAWH HMONG NUMBER TENS..PAHAWH HMONG NUMBER TRILLIONS
+16D6D..16D6F  ; Exclusion Not_XID              # 16.0   [3] KIRAT RAI SIGN YUPI..KIRAT RAI DOUBLE DANDA
+16E80..16E9A  ; Exclusion Not_XID              # 11.0  [27] MEDEFAIDRIN DIGIT ZERO..MEDEFAIDRIN EXCLAMATION OH
+1BC9C         ; Exclusion Not_XID              # 7.0        DUPLOYAN SIGN O WITH CROSS
+1BC9F         ; Exclusion Not_XID              # 7.0        DUPLOYAN PUNCTUATION CHINOOK FULL STOP
+1D800..1D9FF  ; Exclusion Not_XID              # 8.0  [512] SIGNWRITING HAND-FIST INDEX..SIGNWRITING HEAD
+1DA37..1DA3A  ; Exclusion Not_XID              # 8.0    [4] SIGNWRITING AIR BLOW SMALL ROTATIONS..SIGNWRITING BREATH EXHALE
+1DA6D..1DA74  ; Exclusion Not_XID              # 8.0    [8] SIGNWRITING SHOULDER HIP SPINE..SIGNWRITING TORSO-FLOORPLANE TWISTING
+1DA76..1DA83  ; Exclusion Not_XID              # 8.0   [14] SIGNWRITING LIMB COMBINATION..SIGNWRITING LOCATION DEPTH
+1DA85..1DA8B  ; Exclusion Not_XID              # 8.0    [7] SIGNWRITING LOCATION TORSO..SIGNWRITING PARENTHESIS
+1E5FF         ; Exclusion Not_XID              # 16.0       OL ONAL ABBREVIATION SIGN
+1E8C7..1E8CF  ; Exclusion Not_XID              # 7.0    [9] MENDE KIKAKUI DIGIT ONE..MENDE KIKAKUI DIGIT NINE
+
+# Total code points: 1142
+
+#	Identifier_Type:	Obsolete
+
+0138          ; Obsolete                       # 1.1        LATIN SMALL LETTER KRA
+01B9          ; Obsolete                       # 1.1        LATIN SMALL LETTER EZH REVERSED
+01BF          ; Obsolete                       # 1.1        LATIN LETTER WYNN
+01F6..01F7    ; Obsolete                       # 3.0    [2] LATIN CAPITAL LETTER HWAIR..LATIN CAPITAL LETTER WYNN
+021C..021D    ; Obsolete                       # 3.0    [2] LATIN CAPITAL LETTER YOGH..LATIN SMALL LETTER YOGH
+0345          ; Obsolete                       # 1.1        COMBINING GREEK YPOGEGRAMMENI
+0363..036F    ; Obsolete                       # 3.2   [13] COMBINING LATIN SMALL LETTER A..COMBINING LATIN SMALL LETTER X
+0370..0373    ; Obsolete                       # 5.1    [4] GREEK CAPITAL LETTER HETA..GREEK SMALL LETTER ARCHAIC SAMPI
+0376..0377    ; Obsolete                       # 5.1    [2] GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA..GREEK SMALL LETTER PAMPHYLIAN DIGAMMA
+037B..037D    ; Obsolete                       # 5.0    [3] GREEK SMALL REVERSED LUNATE SIGMA SYMBOL..GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL
+037F          ; Obsolete                       # 7.0        GREEK CAPITAL LETTER YOT
+03D8..03D9    ; Obsolete                       # 3.2    [2] GREEK LETTER ARCHAIC KOPPA..GREEK SMALL LETTER ARCHAIC KOPPA
+03DA          ; Obsolete                       # 1.1        GREEK LETTER STIGMA
+03DB          ; Obsolete                       # 3.0        GREEK SMALL LETTER STIGMA
+03DC          ; Obsolete                       # 1.1        GREEK LETTER DIGAMMA
+03DD          ; Obsolete                       # 3.0        GREEK SMALL LETTER DIGAMMA
+03DE          ; Obsolete                       # 1.1        GREEK LETTER KOPPA
+03DF          ; Obsolete                       # 3.0        GREEK SMALL LETTER KOPPA
+03E0          ; Obsolete                       # 1.1        GREEK LETTER SAMPI
+03E1          ; Obsolete                       # 3.0        GREEK SMALL LETTER SAMPI
+03F7..03F8    ; Obsolete                       # 4.0    [2] GREEK CAPITAL LETTER SHO..GREEK SMALL LETTER SHO
+03FA..03FB    ; Obsolete                       # 4.0    [2] GREEK CAPITAL LETTER SAN..GREEK SMALL LETTER SAN
+03FD..03FF    ; Obsolete                       # 4.1    [3] GREEK CAPITAL REVERSED LUNATE SIGMA SYMBOL..GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL
+0460..0481    ; Obsolete                       # 1.1   [34] CYRILLIC CAPITAL LETTER OMEGA..CYRILLIC SMALL LETTER KOPPA
+0483          ; Obsolete                       # 1.1        COMBINING CYRILLIC TITLO
+049C..049D    ; Obsolete                       # 1.1    [2] CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE..CYRILLIC SMALL LETTER KA WITH VERTICAL STROKE
+04A6..04A7    ; Obsolete                       # 1.1    [2] CYRILLIC CAPITAL LETTER PE WITH MIDDLE HOOK..CYRILLIC SMALL LETTER PE WITH MIDDLE HOOK
+04B8..04B9    ; Obsolete                       # 1.1    [2] CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE..CYRILLIC SMALL LETTER CHE WITH VERTICAL STROKE
+0500..050F    ; Obsolete                       # 3.2   [16] CYRILLIC CAPITAL LETTER KOMI DE..CYRILLIC SMALL LETTER KOMI TJE
+0514..0523    ; Obsolete                       # 5.1   [16] CYRILLIC CAPITAL LETTER LHA..CYRILLIC SMALL LETTER EN WITH MIDDLE HOOK
+0526..0527    ; Obsolete                       # 6.0    [2] CYRILLIC CAPITAL LETTER SHHA WITH DESCENDER..CYRILLIC SMALL LETTER SHHA WITH DESCENDER
+0528..052F    ; Obsolete                       # 7.0    [8] CYRILLIC CAPITAL LETTER EN WITH LEFT HOOK..CYRILLIC SMALL LETTER EL WITH DESCENDER
+063B..063C    ; Obsolete                       # 5.1    [2] ARABIC LETTER KEHEH WITH TWO DOTS ABOVE..ARABIC LETTER KEHEH WITH THREE DOTS BELOW
+063E..063F    ; Obsolete                       # 5.1    [2] ARABIC LETTER FARSI YEH WITH TWO DOTS ABOVE..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE
+0640          ; Obsolete                       # 1.1        ARABIC TATWEEL
+066E..066F    ; Obsolete                       # 3.2    [2] ARABIC LETTER DOTLESS BEH..ARABIC LETTER DOTLESS QAF
+0690          ; Obsolete                       # 1.1        ARABIC LETTER DAL WITH FOUR DOTS ABOVE
+06AC          ; Obsolete                       # 1.1        ARABIC LETTER KAF WITH DOT ABOVE
+077E..077F    ; Obsolete                       # 5.1    [2] ARABIC LETTER SEEN WITH INVERTED V..ARABIC LETTER KAF WITH TWO DOTS ABOVE
+088E          ; Obsolete                       # 14.0       ARABIC VERTICAL TAIL
+08AD..08B1    ; Obsolete                       # 7.0    [5] ARABIC LETTER LOW ALEF..ARABIC LETTER STRAIGHT WAW
+08B5          ; Obsolete                       # 14.0       ARABIC LETTER QAF WITH DOT BELOW AND NO DOTS ABOVE
+090C          ; Obsolete                       # 1.1        DEVANAGARI LETTER VOCALIC L
+093D          ; Obsolete                       # 1.1        DEVANAGARI SIGN AVAGRAHA
+094E          ; Obsolete                       # 5.2        DEVANAGARI VOWEL SIGN PRISHTHAMATRA E
+0951..0952    ; Obsolete                       # 1.1    [2] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI STRESS SIGN ANUDATTA
+0960..0963    ; Obsolete                       # 1.1    [4] DEVANAGARI LETTER VOCALIC RR..DEVANAGARI VOWEL SIGN VOCALIC LL
+0971          ; Obsolete                       # 5.1        DEVANAGARI SIGN HIGH SPACING DOT
+0978          ; Obsolete                       # 7.0        DEVANAGARI LETTER MARWARI DDA
+0980          ; Obsolete                       # 7.0        BENGALI ANJI
+09BD          ; Obsolete                       # 4.0        BENGALI SIGN AVAGRAHA
+09E0..09E3    ; Obsolete                       # 1.1    [4] BENGALI LETTER VOCALIC RR..BENGALI VOWEL SIGN VOCALIC LL
+09FC          ; Obsolete                       # 10.0       BENGALI LETTER VEDIC ANUSVARA
+0ABD          ; Obsolete                       # 1.1        GUJARATI SIGN AVAGRAHA
+0AE0          ; Obsolete                       # 1.1        GUJARATI LETTER VOCALIC RR
+0AE1..0AE3    ; Obsolete                       # 4.0    [3] GUJARATI LETTER VOCALIC LL..GUJARATI VOWEL SIGN VOCALIC LL
+0B3D          ; Obsolete                       # 1.1        ORIYA SIGN AVAGRAHA
+0B60..0B61    ; Obsolete                       # 1.1    [2] ORIYA LETTER VOCALIC RR..ORIYA LETTER VOCALIC LL
+0C00          ; Obsolete                       # 7.0        TELUGU SIGN COMBINING CANDRABINDU ABOVE
+0C34          ; Obsolete                       # 7.0        TELUGU LETTER LLLA
+0C3D          ; Obsolete                       # 5.1        TELUGU SIGN AVAGRAHA
+0C58..0C59    ; Obsolete                       # 5.1    [2] TELUGU LETTER TSA..TELUGU LETTER DZA
+0C5C          ; Obsolete                       # 17.0       TELUGU ARCHAIC SHRII
+0C60..0C61    ; Obsolete                       # 1.1    [2] TELUGU LETTER VOCALIC RR..TELUGU LETTER VOCALIC LL
+0C81          ; Obsolete                       # 7.0        KANNADA SIGN CANDRABINDU
+0C8C          ; Obsolete                       # 1.1        KANNADA LETTER VOCALIC L
+0CB1          ; Obsolete                       # 1.1        KANNADA LETTER RRA
+0CBD          ; Obsolete                       # 4.0        KANNADA SIGN AVAGRAHA
+0CDC          ; Obsolete                       # 17.0       KANNADA ARCHAIC SHRII
+0CDE          ; Obsolete                       # 1.1        KANNADA LETTER FA
+0CE0..0CE1    ; Obsolete                       # 1.1    [2] KANNADA LETTER VOCALIC RR..KANNADA LETTER VOCALIC LL
+0CE2..0CE3    ; Obsolete                       # 5.0    [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
+0CF1..0CF2    ; Obsolete                       # 5.0    [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA
+0D01          ; Obsolete                       # 7.0        MALAYALAM SIGN CANDRABINDU
+0D3A          ; Obsolete                       # 6.0        MALAYALAM LETTER TTTA
+0D3B..0D3C    ; Obsolete                       # 10.0   [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA
+0D3D          ; Obsolete                       # 5.1        MALAYALAM SIGN AVAGRAHA
+0D4C          ; Obsolete                       # 1.1        MALAYALAM VOWEL SIGN AU
+0D4E          ; Obsolete                       # 6.0        MALAYALAM LETTER DOT REPH
+0D5F          ; Obsolete                       # 8.0        MALAYALAM LETTER ARCHAIC II
+0D60..0D61    ; Obsolete                       # 1.1    [2] MALAYALAM LETTER VOCALIC RR..MALAYALAM LETTER VOCALIC LL
+0D9E          ; Obsolete                       # 3.0        SINHALA LETTER KANTAJA NAASIKYAYA
+0F86..0F8B    ; Obsolete                       # 2.0    [6] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN GRU MED RGYINGS
+0F8C..0F8F    ; Obsolete                       # 6.0    [4] TIBETAN SIGN INVERTED MCHU CAN..TIBETAN SUBJOINED SIGN INVERTED MCHU CAN
+10A0..10C5    ; Obsolete                       # 1.1   [38] GEORGIAN CAPITAL LETTER AN..GEORGIAN CAPITAL LETTER HOE
+10F1..10F6    ; Obsolete                       # 1.1    [6] GEORGIAN LETTER HE..GEORGIAN LETTER FI
+1100..1159    ; Obsolete                       # 1.1   [90] HANGUL CHOSEONG KIYEOK..HANGUL CHOSEONG YEORINHIEUH
+115A..115E    ; Obsolete                       # 5.2    [5] HANGUL CHOSEONG KIYEOK-TIKEUT..HANGUL CHOSEONG TIKEUT-RIEUL
+1161..11A2    ; Obsolete                       # 1.1   [66] HANGUL JUNGSEONG A..HANGUL JUNGSEONG SSANGARAEA
+11A3..11A7    ; Obsolete                       # 5.2    [5] HANGUL JUNGSEONG A-EU..HANGUL JUNGSEONG O-YAE
+11A8..11F9    ; Obsolete                       # 1.1   [82] HANGUL JONGSEONG KIYEOK..HANGUL JONGSEONG YEORINHIEUH
+11FA..11FF    ; Obsolete                       # 5.2    [6] HANGUL JONGSEONG KIYEOK-NIEUN..HANGUL JONGSEONG SSANGNIEUN
+1369..1371    ; Obsolete                       # 3.0    [9] ETHIOPIC DIGIT ONE..ETHIOPIC DIGIT NINE
+17A8          ; Obsolete                       # 3.0        KHMER INDEPENDENT VOWEL QUK
+17D3          ; Obsolete                       # 3.0        KHMER SIGN BATHAMASAT
+17DC          ; Obsolete                       # 3.0        KHMER SIGN AVAKRAHASANYA
+1AB0..1ABD    ; Obsolete                       # 7.0   [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW
+1C80..1C88    ; Obsolete                       # 9.0    [9] CYRILLIC SMALL LETTER ROUNDED VE..CYRILLIC SMALL LETTER UNBLENDED UK
+1CD0..1CD2    ; Obsolete                       # 5.2    [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA
+1CD4..1CF2    ; Obsolete                       # 5.2   [31] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC SIGN ARDHAVISARGA
+1CF3..1CF6    ; Obsolete                       # 6.1    [4] VEDIC SIGN ROTATED ARDHAVISARGA..VEDIC SIGN UPADHMANIYA
+1CF7          ; Obsolete                       # 10.0       VEDIC SIGN ATIKRAMA
+1CF8..1CF9    ; Obsolete                       # 7.0    [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE
+1F00..1F15    ; Obsolete                       # 1.1   [22] GREEK SMALL LETTER ALPHA WITH PSILI..GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA
+1F18..1F1D    ; Obsolete                       # 1.1    [6] GREEK CAPITAL LETTER EPSILON WITH PSILI..GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA
+1F20..1F45    ; Obsolete                       # 1.1   [38] GREEK SMALL LETTER ETA WITH PSILI..GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA
+1F48..1F4D    ; Obsolete                       # 1.1    [6] GREEK CAPITAL LETTER OMICRON WITH PSILI..GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA
+1F50..1F57    ; Obsolete                       # 1.1    [8] GREEK SMALL LETTER UPSILON WITH PSILI..GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI
+1F59          ; Obsolete                       # 1.1        GREEK CAPITAL LETTER UPSILON WITH DASIA
+1F5B          ; Obsolete                       # 1.1        GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA
+1F5D          ; Obsolete                       # 1.1        GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA
+1F5F..1F70    ; Obsolete                       # 1.1   [18] GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI..GREEK SMALL LETTER ALPHA WITH VARIA
+1F72          ; Obsolete                       # 1.1        GREEK SMALL LETTER EPSILON WITH VARIA
+1F74          ; Obsolete                       # 1.1        GREEK SMALL LETTER ETA WITH VARIA
+1F76          ; Obsolete                       # 1.1        GREEK SMALL LETTER IOTA WITH VARIA
+1F78          ; Obsolete                       # 1.1        GREEK SMALL LETTER OMICRON WITH VARIA
+1F7A          ; Obsolete                       # 1.1        GREEK SMALL LETTER UPSILON WITH VARIA
+1F7C          ; Obsolete                       # 1.1        GREEK SMALL LETTER OMEGA WITH VARIA
+1F80..1F9F    ; Obsolete                       # 1.1   [32] GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI..GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1FB6..1FBA    ; Obsolete                       # 1.1    [5] GREEK SMALL LETTER ALPHA WITH PERISPOMENI..GREEK CAPITAL LETTER ALPHA WITH VARIA
+1FBC          ; Obsolete                       # 1.1        GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI
+1FC2..1FC4    ; Obsolete                       # 1.1    [3] GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI
+1FC6..1FC8    ; Obsolete                       # 1.1    [3] GREEK SMALL LETTER ETA WITH PERISPOMENI..GREEK CAPITAL LETTER EPSILON WITH VARIA
+1FCA          ; Obsolete                       # 1.1        GREEK CAPITAL LETTER ETA WITH VARIA
+1FCC          ; Obsolete                       # 1.1        GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
+1FD0..1FD2    ; Obsolete                       # 1.1    [3] GREEK SMALL LETTER IOTA WITH VRACHY..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA
+1FD6..1FDA    ; Obsolete                       # 1.1    [5] GREEK SMALL LETTER IOTA WITH PERISPOMENI..GREEK CAPITAL LETTER IOTA WITH VARIA
+1FE0..1FE2    ; Obsolete                       # 1.1    [3] GREEK SMALL LETTER UPSILON WITH VRACHY..GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA
+1FE4..1FEA    ; Obsolete                       # 1.1    [7] GREEK SMALL LETTER RHO WITH PSILI..GREEK CAPITAL LETTER UPSILON WITH VARIA
+1FF2..1FF4    ; Obsolete                       # 1.1    [3] GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI
+1FF6..1FF8    ; Obsolete                       # 1.1    [3] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMICRON WITH VARIA
+1FFA          ; Obsolete                       # 1.1        GREEK CAPITAL LETTER OMEGA WITH VARIA
+1FFC          ; Obsolete                       # 1.1        GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
+2132          ; Obsolete                       # 1.1        TURNED CAPITAL F
+214E          ; Obsolete                       # 5.0        TURNED SMALL F
+2184          ; Obsolete                       # 5.0        LATIN SMALL LETTER REVERSED C
+2185..2188    ; Obsolete                       # 5.1    [4] ROMAN NUMERAL SIX LATE FORM..ROMAN NUMERAL ONE HUNDRED THOUSAND
+2C6D..2C6F    ; Obsolete                       # 5.1    [3] LATIN CAPITAL LETTER ALPHA..LATIN CAPITAL LETTER TURNED A
+2C70          ; Obsolete                       # 5.2        LATIN CAPITAL LETTER TURNED ALPHA
+2C71..2C73    ; Obsolete                       # 5.1    [3] LATIN SMALL LETTER V WITH RIGHT HOOK..LATIN SMALL LETTER W WITH HOOK
+2C74..2C76    ; Obsolete                       # 5.0    [3] LATIN SMALL LETTER V WITH CURL..LATIN SMALL LETTER HALF H
+2C7E..2C7F    ; Obsolete                       # 5.2    [2] LATIN CAPITAL LETTER S WITH SWASH TAIL..LATIN CAPITAL LETTER Z WITH SWASH TAIL
+2D00..2D25    ; Obsolete                       # 4.1   [38] GEORGIAN SMALL LETTER AN..GEORGIAN SMALL LETTER HOE
+2DE0..2DFF    ; Obsolete                       # 5.1   [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS
+31F0..31FF    ; Obsolete                       # 3.2   [16] KATAKANA LETTER SMALL KU..KATAKANA LETTER SMALL RO
+A640..A65F    ; Obsolete                       # 5.1   [32] CYRILLIC CAPITAL LETTER ZEMLYA..CYRILLIC SMALL LETTER YN
+A660..A661    ; Obsolete                       # 6.0    [2] CYRILLIC CAPITAL LETTER REVERSED TSE..CYRILLIC SMALL LETTER REVERSED TSE
+A662..A66E    ; Obsolete                       # 5.1   [13] CYRILLIC CAPITAL LETTER SOFT DE..CYRILLIC LETTER MULTIOCULAR O
+A674..A67B    ; Obsolete                       # 6.1    [8] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC LETTER OMEGA
+A67F..A697    ; Obsolete                       # 5.1   [25] CYRILLIC PAYEROK..CYRILLIC SMALL LETTER SHWE
+A698..A69B    ; Obsolete                       # 7.0    [4] CYRILLIC CAPITAL LETTER DOUBLE O..CYRILLIC SMALL LETTER CROSSED O
+A69F          ; Obsolete                       # 6.1        COMBINING CYRILLIC LETTER IOTIFIED E
+A730..A76F    ; Obsolete                       # 5.1   [64] LATIN LETTER SMALL CAPITAL F..LATIN SMALL LETTER CON
+A771..A787    ; Obsolete                       # 5.1   [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER INSULAR T
+A790..A791    ; Obsolete                       # 6.0    [2] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN SMALL LETTER N WITH DESCENDER
+A794..A79F    ; Obsolete                       # 7.0   [12] LATIN SMALL LETTER C WITH PALATAL HOOK..LATIN SMALL LETTER VOLAPUK UE
+A7A0..A7A9    ; Obsolete                       # 6.0   [10] LATIN CAPITAL LETTER G WITH OBLIQUE STROKE..LATIN SMALL LETTER S WITH OBLIQUE STROKE
+A7AB..A7AD    ; Obsolete                       # 7.0    [3] LATIN CAPITAL LETTER REVERSED OPEN E..LATIN CAPITAL LETTER L WITH BELT
+A7B0..A7B1    ; Obsolete                       # 7.0    [2] LATIN CAPITAL LETTER TURNED K..LATIN CAPITAL LETTER TURNED T
+A7C0..A7C1    ; Obsolete                       # 14.0   [2] LATIN CAPITAL LETTER OLD POLISH O..LATIN SMALL LETTER OLD POLISH O
+A7C4          ; Obsolete                       # 12.0       LATIN CAPITAL LETTER C WITH PALATAL HOOK
+A7C7..A7CA    ; Obsolete                       # 13.0   [4] LATIN CAPITAL LETTER D WITH SHORT STROKE OVERLAY..LATIN SMALL LETTER S WITH SHORT STROKE OVERLAY
+A7D0..A7D1    ; Obsolete                       # 14.0   [2] LATIN CAPITAL LETTER CLOSED INSULAR G..LATIN SMALL LETTER CLOSED INSULAR G
+A7D2          ; Obsolete                       # 17.0       LATIN CAPITAL LETTER DOUBLE THORN
+A7D3          ; Obsolete                       # 14.0       LATIN SMALL LETTER DOUBLE THORN
+A7D4          ; Obsolete                       # 17.0       LATIN CAPITAL LETTER DOUBLE WYNN
+A7D5..A7D9    ; Obsolete                       # 14.0   [5] LATIN SMALL LETTER DOUBLE WYNN..LATIN SMALL LETTER SIGMOID S
+A7F5..A7F6    ; Obsolete                       # 13.0   [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H
+A7F7          ; Obsolete                       # 7.0        LATIN EPIGRAPHIC LETTER SIDEWAYS I
+A7FB..A7FF    ; Obsolete                       # 5.1    [5] LATIN EPIGRAPHIC LETTER REVERSED F..LATIN EPIGRAPHIC LETTER ARCHAIC M
+A8E0..A8F7    ; Obsolete                       # 5.2   [24] COMBINING DEVANAGARI DIGIT ZERO..DEVANAGARI SIGN CANDRABINDU AVAGRAHA
+A8FB          ; Obsolete                       # 5.2        DEVANAGARI HEADSTROKE
+A8FE..A8FF    ; Obsolete                       # 11.0   [2] DEVANAGARI LETTER AY..DEVANAGARI VOWEL SIGN AY
+A960..A97C    ; Obsolete                       # 5.2   [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH
+A9E0..A9E6    ; Obsolete                       # 7.0    [7] MYANMAR LETTER SHAN GHA..MYANMAR MODIFIER LETTER SHAN REDUPLICATION
+AB30..AB5A    ; Obsolete                       # 7.0   [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LETTER Y WITH SHORT RIGHT LEG
+AB64..AB65    ; Obsolete                       # 7.0    [2] LATIN SMALL LETTER INVERTED ALPHA..GREEK LETTER SMALL CAPITAL OMEGA
+D7B0..D7C6    ; Obsolete                       # 5.2   [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E
+D7CB..D7FB    ; Obsolete                       # 5.2   [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH
+10140..10174  ; Obsolete                       # 4.1   [53] GREEK ACROPHONIC ATTIC ONE QUARTER..GREEK ACROPHONIC STRATIAN FIFTY MNAS
+101FD         ; Obsolete                       # 5.1        PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE
+102E0         ; Obsolete                       # 7.0        COPTIC EPACT THOUSANDS MARK
+16FE3         ; Obsolete                       # 12.0       OLD CHINESE ITERATION MARK
+16FF0..16FF1  ; Obsolete                       # 13.0   [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY
+1B000..1B001  ; Obsolete                       # 6.0    [2] KATAKANA LETTER ARCHAIC E..HIRAGANA LETTER ARCHAIC YE
+1B002..1B11E  ; Obsolete                       # 10.0 [285] HENTAIGANA LETTER A-1..HENTAIGANA LETTER N-MU-MO-2
+1B11F..1B122  ; Obsolete                       # 14.0   [4] HIRAGANA LETTER ARCHAIC WU..KATAKANA LETTER ARCHAIC WU
+1B132         ; Obsolete                       # 15.0       HIRAGANA LETTER SMALL KO
+1B150..1B152  ; Obsolete                       # 12.0   [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO
+1B155         ; Obsolete                       # 15.0       KATAKANA LETTER SMALL KO
+1B164..1B167  ; Obsolete                       # 12.0   [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N
+1E08F         ; Obsolete                       # 15.0       COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
+
+# Total code points: 1639
+
+#	Identifier_Type:	Obsolete Not_XID
+
+0482          ; Obsolete Not_XID               # 1.1        CYRILLIC THOUSANDS SIGN
+0488..0489    ; Obsolete Not_XID               # 3.0    [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN
+05C6          ; Obsolete Not_XID               # 4.1        HEBREW PUNCTUATION NUN HAFUKHA
+17D8          ; Obsolete Not_XID               # 3.0        KHMER SIGN BEYYAL
+1CD3          ; Obsolete Not_XID               # 5.2        VEDIC SIGN NIHSHVASA
+2056          ; Obsolete Not_XID               # 4.1        THREE DOT PUNCTUATION
+2058..205E    ; Obsolete Not_XID               # 4.1    [7] FOUR DOT PUNCTUATION..VERTICAL FOUR DOTS
+2127          ; Obsolete Not_XID               # 1.1        INVERTED OHM SIGN
+214F          ; Obsolete Not_XID               # 5.1        SYMBOL FOR SAMARITAN SOURCE
+2E0E..2E16    ; Obsolete Not_XID               # 4.1    [9] EDITORIAL CORONIS..DOTTED RIGHT-POINTING ANGLE
+2E2A..2E2F    ; Obsolete Not_XID               # 5.1    [6] TWO DOTS OVER ONE DOT PUNCTUATION..VERTICAL TILDE
+2E31          ; Obsolete Not_XID               # 5.2        WORD SEPARATOR MIDDLE DOT
+2E32          ; Obsolete Not_XID               # 6.1        TURNED COMMA
+2E35          ; Obsolete Not_XID               # 6.1        TURNED SEMICOLON
+2E39          ; Obsolete Not_XID               # 6.1        TOP HALF SECTION SIGN
+301E          ; Obsolete Not_XID               # 1.1        DOUBLE PRIME QUOTATION MARK
+A670..A673    ; Obsolete Not_XID               # 5.1    [4] COMBINING CYRILLIC TEN MILLIONS SIGN..SLAVONIC ASTERISK
+A700..A707    ; Obsolete Not_XID               # 4.1    [8] MODIFIER LETTER CHINESE TONE YIN PING..MODIFIER LETTER CHINESE TONE YANG RU
+A8F8..A8FA    ; Obsolete Not_XID               # 5.2    [3] DEVANAGARI SIGN PUSHPIKA..DEVANAGARI CARET
+101D0..101FC  ; Obsolete Not_XID               # 5.1   [45] PHAISTOS DISC SIGN PEDESTRIAN..PHAISTOS DISC SIGN WAVY BAND
+102E1..102FB  ; Obsolete Not_XID               # 7.0   [27] COPTIC EPACT DIGIT ONE..COPTIC EPACT NUMBER NINE HUNDRED
+1D200..1D241  ; Obsolete Not_XID               # 4.1   [66] GREEK VOCAL NOTATION SYMBOL-1..GREEK INSTRUMENTAL NOTATION SYMBOL-54
+1D245         ; Obsolete Not_XID               # 4.1        GREEK MUSICAL LEIMMA
+
+# Total code points: 190
+
+#	Identifier_Type:	Not_XID
+
+0009..000D    ; Not_XID                        # 1.1    [5] <control-0009>..<control-000D>
+0020..0026    ; Not_XID                        # 1.1    [7] SPACE..AMPERSAND
+0028..002C    ; Not_XID                        # 1.1    [5] LEFT PARENTHESIS..COMMA
+002F          ; Not_XID                        # 1.1        SOLIDUS
+003B..0040    ; Not_XID                        # 1.1    [6] SEMICOLON..COMMERCIAL AT
+005B..005E    ; Not_XID                        # 1.1    [4] LEFT SQUARE BRACKET..CIRCUMFLEX ACCENT
+0060          ; Not_XID                        # 1.1        GRAVE ACCENT
+007B..007E    ; Not_XID                        # 1.1    [4] LEFT CURLY BRACKET..TILDE
+0085          ; Not_XID                        # 1.1        <control-0085>
+00A1..00A7    ; Not_XID                        # 1.1    [7] INVERTED EXCLAMATION MARK..SECTION SIGN
+00A9          ; Not_XID                        # 1.1        COPYRIGHT SIGN
+00AB..00AC    ; Not_XID                        # 1.1    [2] LEFT-POINTING DOUBLE ANGLE QUOTATION MARK..NOT SIGN
+00AE          ; Not_XID                        # 1.1        REGISTERED SIGN
+00B0..00B1    ; Not_XID                        # 1.1    [2] DEGREE SIGN..PLUS-MINUS SIGN
+00B6          ; Not_XID                        # 1.1        PILCROW SIGN
+00BB          ; Not_XID                        # 1.1        RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+00BF          ; Not_XID                        # 1.1        INVERTED QUESTION MARK
+00D7          ; Not_XID                        # 1.1        MULTIPLICATION SIGN
+00F7          ; Not_XID                        # 1.1        DIVISION SIGN
+02C2..02C5    ; Not_XID                        # 1.1    [4] MODIFIER LETTER LEFT ARROWHEAD..MODIFIER LETTER DOWN ARROWHEAD
+02D2..02D7    ; Not_XID                        # 1.1    [6] MODIFIER LETTER CENTRED RIGHT HALF RING..MODIFIER LETTER MINUS SIGN
+02DE          ; Not_XID                        # 1.1        MODIFIER LETTER RHOTIC HOOK
+02DF          ; Not_XID                        # 3.0        MODIFIER LETTER CROSS ACCENT
+02E5..02E9    ; Not_XID                        # 1.1    [5] MODIFIER LETTER EXTRA-HIGH TONE BAR..MODIFIER LETTER EXTRA-LOW TONE BAR
+02ED          ; Not_XID                        # 3.0        MODIFIER LETTER UNASPIRATED
+02EF..02FF    ; Not_XID                        # 4.0   [17] MODIFIER LETTER LOW DOWN ARROWHEAD..MODIFIER LETTER LOW LEFT ARROW
+03F6          ; Not_XID                        # 3.2        GREEK REVERSED LUNATE EPSILON SYMBOL
+055A..055F    ; Not_XID                        # 1.1    [6] ARMENIAN APOSTROPHE..ARMENIAN ABBREVIATION MARK
+0589          ; Not_XID                        # 1.1        ARMENIAN FULL STOP
+058D..058E    ; Not_XID                        # 7.0    [2] RIGHT-FACING ARMENIAN ETERNITY SIGN..LEFT-FACING ARMENIAN ETERNITY SIGN
+058F          ; Not_XID                        # 6.1        ARMENIAN DRAM SIGN
+05BE          ; Not_XID                        # 1.1        HEBREW PUNCTUATION MAQAF
+05C0          ; Not_XID                        # 1.1        HEBREW PUNCTUATION PASEQ
+05C3          ; Not_XID                        # 1.1        HEBREW PUNCTUATION SOF PASUQ
+0600..0603    ; Not_XID                        # 4.0    [4] ARABIC NUMBER SIGN..ARABIC SIGN SAFHA
+0604          ; Not_XID                        # 6.1        ARABIC SIGN SAMVAT
+0605          ; Not_XID                        # 7.0        ARABIC NUMBER MARK ABOVE
+0606..060A    ; Not_XID                        # 5.1    [5] ARABIC-INDIC CUBE ROOT..ARABIC-INDIC PER TEN THOUSAND SIGN
+060B          ; Not_XID                        # 4.1        AFGHANI SIGN
+060C          ; Not_XID                        # 1.1        ARABIC COMMA
+060D..060F    ; Not_XID                        # 4.0    [3] ARABIC DATE SEPARATOR..ARABIC SIGN MISRA
+061B          ; Not_XID                        # 1.1        ARABIC SEMICOLON
+061D          ; Not_XID                        # 14.0       ARABIC END OF TEXT MARK
+061E          ; Not_XID                        # 4.1        ARABIC TRIPLE DOT PUNCTUATION MARK
+061F          ; Not_XID                        # 1.1        ARABIC QUESTION MARK
+066A..066D    ; Not_XID                        # 1.1    [4] ARABIC PERCENT SIGN..ARABIC FIVE POINTED STAR
+06D4          ; Not_XID                        # 1.1        ARABIC FULL STOP
+06DD          ; Not_XID                        # 1.1        ARABIC END OF AYAH
+06DE          ; Not_XID                        # 1.1        ARABIC START OF RUB EL HIZB
+06E9          ; Not_XID                        # 1.1        ARABIC PLACE OF SAJDAH
+0890..0891    ; Not_XID                        # 14.0   [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE
+08E2          ; Not_XID                        # 9.0        ARABIC DISPUTED END OF AYAH
+0964..0965    ; Not_XID                        # 1.1    [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA
+0970          ; Not_XID                        # 1.1        DEVANAGARI ABBREVIATION SIGN
+09F2..09FA    ; Not_XID                        # 1.1    [9] BENGALI RUPEE MARK..BENGALI ISSHAR
+09FB          ; Not_XID                        # 5.2        BENGALI GANDA MARK
+09FD          ; Not_XID                        # 10.0       BENGALI ABBREVIATION SIGN
+0A76          ; Not_XID                        # 11.0       GURMUKHI ABBREVIATION SIGN
+0AF0          ; Not_XID                        # 6.1        GUJARATI ABBREVIATION SIGN
+0AF1          ; Not_XID                        # 4.0        GUJARATI RUPEE SIGN
+0B70          ; Not_XID                        # 1.1        ORIYA ISSHAR
+0B72..0B77    ; Not_XID                        # 6.0    [6] ORIYA FRACTION ONE QUARTER..ORIYA FRACTION THREE SIXTEENTHS
+0BF0..0BF2    ; Not_XID                        # 1.1    [3] TAMIL NUMBER TEN..TAMIL NUMBER ONE THOUSAND
+0BF3..0BFA    ; Not_XID                        # 4.0    [8] TAMIL DAY SIGN..TAMIL NUMBER SIGN
+0C77          ; Not_XID                        # 12.0       TELUGU SIGN SIDDHAM
+0C78..0C7F    ; Not_XID                        # 5.1    [8] TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR..TELUGU SIGN TUUMU
+0C84          ; Not_XID                        # 11.0       KANNADA SIGN SIDDHAM
+0D4F          ; Not_XID                        # 9.0        MALAYALAM SIGN PARA
+0D58..0D5E    ; Not_XID                        # 9.0    [7] MALAYALAM FRACTION ONE ONE-HUNDRED-AND-SIXTIETH..MALAYALAM FRACTION ONE FIFTH
+0D70..0D75    ; Not_XID                        # 5.1    [6] MALAYALAM NUMBER TEN..MALAYALAM FRACTION THREE QUARTERS
+0D76..0D78    ; Not_XID                        # 9.0    [3] MALAYALAM FRACTION ONE SIXTEENTH..MALAYALAM FRACTION THREE SIXTEENTHS
+0D79          ; Not_XID                        # 5.1        MALAYALAM DATE MARK
+0DF4          ; Not_XID                        # 3.0        SINHALA PUNCTUATION KUNDDALIYA
+0E3F          ; Not_XID                        # 1.1        THAI CURRENCY SYMBOL BAHT
+0E4F          ; Not_XID                        # 1.1        THAI CHARACTER FONGMAN
+0E5A..0E5B    ; Not_XID                        # 1.1    [2] THAI CHARACTER ANGKHANKHU..THAI CHARACTER KHOMUT
+0F01..0F0A    ; Not_XID                        # 2.0   [10] TIBETAN MARK GTER YIG MGO TRUNCATED A..TIBETAN MARK BKA- SHOG YIG MGO
+0F0D..0F17    ; Not_XID                        # 2.0   [11] TIBETAN MARK SHAD..TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS
+0F1A..0F1F    ; Not_XID                        # 2.0    [6] TIBETAN SIGN RDEL DKAR GCIG..TIBETAN SIGN RDEL DKAR RDEL NAG
+0F2A..0F34    ; Not_XID                        # 2.0   [11] TIBETAN DIGIT HALF ONE..TIBETAN MARK BSDUS RTAGS
+0F36          ; Not_XID                        # 2.0        TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN
+0F38          ; Not_XID                        # 2.0        TIBETAN MARK CHE MGO
+0F3A..0F3D    ; Not_XID                        # 2.0    [4] TIBETAN MARK GUG RTAGS GYON..TIBETAN MARK ANG KHANG GYAS
+0F85          ; Not_XID                        # 2.0        TIBETAN MARK PALUTA
+0FBE..0FC5    ; Not_XID                        # 3.0    [8] TIBETAN KU RU KHA..TIBETAN SYMBOL RDO RJE
+0FC7..0FCC    ; Not_XID                        # 3.0    [6] TIBETAN SYMBOL RDO RJE RGYA GRAM..TIBETAN SYMBOL NOR BU BZHI -KHYIL
+0FCE          ; Not_XID                        # 5.1        TIBETAN SIGN RDEL NAG RDEL DKAR
+0FCF          ; Not_XID                        # 3.0        TIBETAN SIGN RDEL NAG GSUM
+0FD0..0FD1    ; Not_XID                        # 4.1    [2] TIBETAN MARK BSKA- SHOG GI MGO RGYAN..TIBETAN MARK MNYAM YIG GI MGO RGYAN
+0FD2..0FD4    ; Not_XID                        # 5.1    [3] TIBETAN MARK NYIS TSHEG..TIBETAN MARK CLOSING BRDA RNYING YIG MGO SGAB MA
+0FD5..0FD8    ; Not_XID                        # 5.2    [4] RIGHT-FACING SVASTI SIGN..LEFT-FACING SVASTI SIGN WITH DOTS
+0FD9..0FDA    ; Not_XID                        # 6.0    [2] TIBETAN MARK LEADING MCHAN RTAGS..TIBETAN MARK TRAILING MCHAN RTAGS
+104A..104F    ; Not_XID                        # 3.0    [6] MYANMAR SIGN LITTLE SECTION..MYANMAR SYMBOL GENITIVE
+109E..109F    ; Not_XID                        # 5.1    [2] MYANMAR SYMBOL SHAN ONE..MYANMAR SYMBOL SHAN EXCLAMATION
+10FB          ; Not_XID                        # 1.1        GEORGIAN PARAGRAPH SEPARATOR
+1360          ; Not_XID                        # 4.1        ETHIOPIC SECTION MARK
+1361..1368    ; Not_XID                        # 3.0    [8] ETHIOPIC WORDSPACE..ETHIOPIC PARAGRAPH SEPARATOR
+1372..137C    ; Not_XID                        # 3.0   [11] ETHIOPIC NUMBER TEN..ETHIOPIC NUMBER TEN THOUSAND
+1390..1399    ; Not_XID                        # 4.1   [10] ETHIOPIC TONAL MARK YIZET..ETHIOPIC TONAL MARK KURT
+17D4..17D6    ; Not_XID                        # 3.0    [3] KHMER SIGN KHAN..KHMER SIGN CAMNUC PII KUUH
+17D9..17DB    ; Not_XID                        # 3.0    [3] KHMER SIGN PHNAEK MUAN..KHMER CURRENCY SYMBOL RIEL
+17F0..17F9    ; Not_XID                        # 4.0   [10] KHMER SYMBOL LEK ATTAK SON..KHMER SYMBOL LEK ATTAK PRAM-BUON
+19E0..19FF    ; Not_XID                        # 4.0   [32] KHMER SYMBOL PATHAMASAT..KHMER SYMBOL DAP-PRAM ROC
+1ABE          ; Not_XID                        # 7.0        COMBINING PARENTHESES OVERLAY
+2012..2016    ; Not_XID                        # 1.1    [5] FIGURE DASH..DOUBLE VERTICAL LINE
+2018          ; Not_XID                        # 1.1        LEFT SINGLE QUOTATION MARK
+201A..2023    ; Not_XID                        # 1.1   [10] SINGLE LOW-9 QUOTATION MARK..TRIANGULAR BULLET
+2028..2029    ; Not_XID                        # 1.1    [2] LINE SEPARATOR..PARAGRAPH SEPARATOR
+2030..2032    ; Not_XID                        # 1.1    [3] PER MILLE SIGN..PRIME
+2035          ; Not_XID                        # 1.1        REVERSED PRIME
+2038..203B    ; Not_XID                        # 1.1    [4] CARET..REFERENCE MARK
+203D          ; Not_XID                        # 1.1        INTERROBANG
+2041..2046    ; Not_XID                        # 1.1    [6] CARET INSERTION POINT..RIGHT SQUARE BRACKET WITH QUILL
+204A..204D    ; Not_XID                        # 3.0    [4] TIRONIAN SIGN ET..BLACK RIGHTWARDS BULLET
+204E..2052    ; Not_XID                        # 3.2    [5] LOW ASTERISK..COMMERCIAL MINUS SIGN
+2053          ; Not_XID                        # 4.0        SWUNG DASH
+2055          ; Not_XID                        # 4.1        FLOWER PUNCTUATION MARK
+20A0..20A7    ; Not_XID                        # 1.1    [8] EURO-CURRENCY SIGN..PESETA SIGN
+20A9..20AA    ; Not_XID                        # 1.1    [2] WON SIGN..NEW SHEQEL SIGN
+20AB          ; Not_XID                        # 2.0        DONG SIGN
+20AC          ; Not_XID                        # 2.1        EURO SIGN
+20AD..20AF    ; Not_XID                        # 3.0    [3] KIP SIGN..DRACHMA SIGN
+20B0..20B1    ; Not_XID                        # 3.2    [2] GERMAN PENNY SIGN..PESO SIGN
+20B2..20B5    ; Not_XID                        # 4.1    [4] GUARANI SIGN..CEDI SIGN
+20B6..20B8    ; Not_XID                        # 5.2    [3] LIVRE TOURNOIS SIGN..TENGE SIGN
+20B9          ; Not_XID                        # 6.0        INDIAN RUPEE SIGN
+20BA          ; Not_XID                        # 6.2        TURKISH LIRA SIGN
+20BB..20BD    ; Not_XID                        # 7.0    [3] NORDIC MARK SIGN..RUBLE SIGN
+20BE          ; Not_XID                        # 8.0        LARI SIGN
+20BF          ; Not_XID                        # 10.0       BITCOIN SIGN
+20C0          ; Not_XID                        # 14.0       SOM SIGN
+20C1          ; Not_XID                        # 17.0       SAUDI RIYAL SIGN
+2104          ; Not_XID                        # 1.1        CENTRE LINE SYMBOL
+2108          ; Not_XID                        # 1.1        SCRUPLE
+2114          ; Not_XID                        # 1.1        L B BAR SYMBOL
+2117          ; Not_XID                        # 1.1        SOUND RECORDING COPYRIGHT
+211E..211F    ; Not_XID                        # 1.1    [2] PRESCRIPTION TAKE..RESPONSE
+2123          ; Not_XID                        # 1.1        VERSICLE
+2125          ; Not_XID                        # 1.1        OUNCE SIGN
+2129          ; Not_XID                        # 1.1        TURNED GREEK SMALL LETTER IOTA
+213A          ; Not_XID                        # 3.0        ROTATED CAPITAL Q
+2141..2144    ; Not_XID                        # 3.2    [4] TURNED SANS-SERIF CAPITAL G..TURNED SANS-SERIF CAPITAL Y
+214A..214B    ; Not_XID                        # 3.2    [2] PROPERTY LINE..TURNED AMPERSAND
+214C          ; Not_XID                        # 4.1        PER SIGN
+214D          ; Not_XID                        # 5.0        AKTIESELSKAB
+2190..21EA    ; Not_XID                        # 1.1   [91] LEFTWARDS ARROW..UPWARDS WHITE ARROW FROM BAR
+21EB..21F3    ; Not_XID                        # 3.0    [9] UPWARDS WHITE ARROW ON PEDESTAL..UP DOWN WHITE ARROW
+21F4..21FF    ; Not_XID                        # 3.2   [12] RIGHT ARROW WITH SMALL CIRCLE..LEFT RIGHT OPEN-HEADED ARROW
+2200..222B    ; Not_XID                        # 1.1   [44] FOR ALL..INTEGRAL
+222E          ; Not_XID                        # 1.1        CONTOUR INTEGRAL
+2231..22F1    ; Not_XID                        # 1.1  [193] CLOCKWISE INTEGRAL..DOWN RIGHT DIAGONAL ELLIPSIS
+22F2..22FF    ; Not_XID                        # 3.2   [14] ELEMENT OF WITH LONG HORIZONTAL STROKE..Z NOTATION BAG MEMBERSHIP
+2300          ; Not_XID                        # 1.1        DIAMETER SIGN
+2301          ; Not_XID                        # 3.0        ELECTRIC ARROW
+2302..2328    ; Not_XID                        # 1.1   [39] HOUSE..KEYBOARD
+232B..237A    ; Not_XID                        # 1.1   [80] ERASE TO THE LEFT..APL FUNCTIONAL SYMBOL ALPHA
+237B          ; Not_XID                        # 3.0        NOT CHECK MARK
+237C          ; Not_XID                        # 3.2        RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW
+237D..239A    ; Not_XID                        # 3.0   [30] SHOULDERED OPEN BOX..CLEAR SCREEN SYMBOL
+239B..23CE    ; Not_XID                        # 3.2   [52] LEFT PARENTHESIS UPPER HOOK..RETURN SYMBOL
+23CF..23D0    ; Not_XID                        # 4.0    [2] EJECT SYMBOL..VERTICAL LINE EXTENSION
+23D1..23DB    ; Not_XID                        # 4.1   [11] METRICAL BREVE..FUSE
+23DC..23E7    ; Not_XID                        # 5.0   [12] TOP PARENTHESIS..ELECTRICAL INTERSECTION
+23E8          ; Not_XID                        # 5.2        DECIMAL EXPONENT SYMBOL
+23E9..23F3    ; Not_XID                        # 6.0   [11] BLACK RIGHT-POINTING DOUBLE TRIANGLE..HOURGLASS WITH FLOWING SAND
+23F4..23FA    ; Not_XID                        # 7.0    [7] BLACK MEDIUM LEFT-POINTING TRIANGLE..BLACK CIRCLE FOR RECORD
+23FB..23FE    ; Not_XID                        # 9.0    [4] POWER SYMBOL..POWER SLEEP SYMBOL
+23FF          ; Not_XID                        # 10.0       OBSERVER EYE SYMBOL
+2400..2424    ; Not_XID                        # 1.1   [37] SYMBOL FOR NULL..SYMBOL FOR NEWLINE
+2425..2426    ; Not_XID                        # 3.0    [2] SYMBOL FOR DELETE FORM TWO..SYMBOL FOR SUBSTITUTE FORM TWO
+2427..2429    ; Not_XID                        # 16.0   [3] SYMBOL FOR DELETE SQUARE CHECKER BOARD FORM..SYMBOL FOR DELETE MEDIUM SHADE FORM
+2440..244A    ; Not_XID                        # 1.1   [11] OCR HOOK..OCR DOUBLE BACKSLASH
+2500..2595    ; Not_XID                        # 1.1  [150] BOX DRAWINGS LIGHT HORIZONTAL..RIGHT ONE EIGHTH BLOCK
+2596..259F    ; Not_XID                        # 3.2   [10] QUADRANT LOWER LEFT..QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT
+25A0..25EF    ; Not_XID                        # 1.1   [80] BLACK SQUARE..LARGE CIRCLE
+25F0..25F7    ; Not_XID                        # 3.0    [8] WHITE SQUARE WITH UPPER LEFT QUADRANT..WHITE CIRCLE WITH UPPER RIGHT QUADRANT
+25F8..25FF    ; Not_XID                        # 3.2    [8] UPPER LEFT TRIANGLE..LOWER RIGHT TRIANGLE
+2600..2613    ; Not_XID                        # 1.1   [20] BLACK SUN WITH RAYS..SALTIRE
+2614..2615    ; Not_XID                        # 4.0    [2] UMBRELLA WITH RAIN DROPS..HOT BEVERAGE
+2616..2617    ; Not_XID                        # 3.2    [2] WHITE SHOGI PIECE..BLACK SHOGI PIECE
+2618          ; Not_XID                        # 4.1        SHAMROCK
+2619          ; Not_XID                        # 3.0        REVERSED ROTATED FLORAL HEART BULLET
+261A..266F    ; Not_XID                        # 1.1   [86] BLACK LEFT POINTING INDEX..MUSIC SHARP SIGN
+2670..2671    ; Not_XID                        # 3.0    [2] WEST SYRIAC CROSS..EAST SYRIAC CROSS
+2672..267D    ; Not_XID                        # 3.2   [12] UNIVERSAL RECYCLING SYMBOL..PARTIALLY-RECYCLED PAPER SYMBOL
+267E..267F    ; Not_XID                        # 4.1    [2] PERMANENT PAPER SIGN..WHEELCHAIR SYMBOL
+2680..2689    ; Not_XID                        # 3.2   [10] DIE FACE-1..BLACK CIRCLE WITH TWO WHITE DOTS
+268A..2691    ; Not_XID                        # 4.0    [8] MONOGRAM FOR YANG..BLACK FLAG
+2692..269C    ; Not_XID                        # 4.1   [11] HAMMER AND PICK..FLEUR-DE-LIS
+269D          ; Not_XID                        # 5.1        OUTLINED WHITE STAR
+269E..269F    ; Not_XID                        # 5.2    [2] THREE LINES CONVERGING RIGHT..THREE LINES CONVERGING LEFT
+26A0..26A1    ; Not_XID                        # 4.0    [2] WARNING SIGN..HIGH VOLTAGE SIGN
+26A2..26B1    ; Not_XID                        # 4.1   [16] DOUBLED FEMALE SIGN..FUNERAL URN
+26B2          ; Not_XID                        # 5.0        NEUTER
+26B3..26BC    ; Not_XID                        # 5.1   [10] CERES..SESQUIQUADRATE
+26BD..26BF    ; Not_XID                        # 5.2    [3] SOCCER BALL..SQUARED KEY
+26C0..26C3    ; Not_XID                        # 5.1    [4] WHITE DRAUGHTS MAN..BLACK DRAUGHTS KING
+26C4..26CD    ; Not_XID                        # 5.2   [10] SNOWMAN WITHOUT SNOW..DISABLED CAR
+26CE          ; Not_XID                        # 6.0        OPHIUCHUS
+26CF..26E1    ; Not_XID                        # 5.2   [19] PICK..RESTRICTED LEFT ENTRY-2
+26E2          ; Not_XID                        # 6.0        ASTRONOMICAL SYMBOL FOR URANUS
+26E3          ; Not_XID                        # 5.2        HEAVY CIRCLE WITH STROKE AND TWO DOTS ABOVE
+26E4..26E7    ; Not_XID                        # 6.0    [4] PENTAGRAM..INVERTED PENTAGRAM
+26E8..26FF    ; Not_XID                        # 5.2   [24] BLACK CROSS ON SHIELD..WHITE FLAG WITH HORIZONTAL MIDDLE BLACK STRIPE
+2700          ; Not_XID                        # 7.0        BLACK SAFETY SCISSORS
+2701..2704    ; Not_XID                        # 1.1    [4] UPPER BLADE SCISSORS..WHITE SCISSORS
+2705          ; Not_XID                        # 6.0        WHITE HEAVY CHECK MARK
+2706..2709    ; Not_XID                        # 1.1    [4] TELEPHONE LOCATION SIGN..ENVELOPE
+270A..270B    ; Not_XID                        # 6.0    [2] RAISED FIST..RAISED HAND
+270C..2727    ; Not_XID                        # 1.1   [28] VICTORY HAND..WHITE FOUR POINTED STAR
+2728          ; Not_XID                        # 6.0        SPARKLES
+2729..274B    ; Not_XID                        # 1.1   [35] STRESS OUTLINED WHITE STAR..HEAVY EIGHT TEARDROP-SPOKED PROPELLER ASTERISK
+274C          ; Not_XID                        # 6.0        CROSS MARK
+274D          ; Not_XID                        # 1.1        SHADOWED WHITE CIRCLE
+274E          ; Not_XID                        # 6.0        NEGATIVE SQUARED CROSS MARK
+274F..2752    ; Not_XID                        # 1.1    [4] LOWER RIGHT DROP-SHADOWED WHITE SQUARE..UPPER RIGHT SHADOWED WHITE SQUARE
+2753..2755    ; Not_XID                        # 6.0    [3] BLACK QUESTION MARK ORNAMENT..WHITE EXCLAMATION MARK ORNAMENT
+2756          ; Not_XID                        # 1.1        BLACK DIAMOND MINUS WHITE X
+2757          ; Not_XID                        # 5.2        HEAVY EXCLAMATION MARK SYMBOL
+2758..275E    ; Not_XID                        # 1.1    [7] LIGHT VERTICAL BAR..HEAVY DOUBLE COMMA QUOTATION MARK ORNAMENT
+275F..2760    ; Not_XID                        # 6.0    [2] HEAVY LOW SINGLE COMMA QUOTATION MARK ORNAMENT..HEAVY LOW DOUBLE COMMA QUOTATION MARK ORNAMENT
+2761..2767    ; Not_XID                        # 1.1    [7] CURVED STEM PARAGRAPH SIGN ORNAMENT..ROTATED FLORAL HEART BULLET
+2768..2775    ; Not_XID                        # 3.2   [14] MEDIUM LEFT PARENTHESIS ORNAMENT..MEDIUM RIGHT CURLY BRACKET ORNAMENT
+2776..2794    ; Not_XID                        # 1.1   [31] DINGBAT NEGATIVE CIRCLED DIGIT ONE..HEAVY WIDE-HEADED RIGHTWARDS ARROW
+2795..2797    ; Not_XID                        # 6.0    [3] HEAVY PLUS SIGN..HEAVY DIVISION SIGN
+2798..27AF    ; Not_XID                        # 1.1   [24] HEAVY SOUTH EAST ARROW..NOTCHED LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW
+27B0          ; Not_XID                        # 6.0        CURLY LOOP
+27B1..27BE    ; Not_XID                        # 1.1   [14] NOTCHED UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW..OPEN-OUTLINED RIGHTWARDS ARROW
+27BF          ; Not_XID                        # 6.0        DOUBLE CURLY LOOP
+27C0..27C6    ; Not_XID                        # 4.1    [7] THREE DIMENSIONAL ANGLE..RIGHT S-SHAPED BAG DELIMITER
+27C7..27CA    ; Not_XID                        # 5.0    [4] OR WITH DOT INSIDE..VERTICAL BAR WITH HORIZONTAL STROKE
+27CB          ; Not_XID                        # 6.1        MATHEMATICAL RISING DIAGONAL
+27CC          ; Not_XID                        # 5.1        LONG DIVISION
+27CD          ; Not_XID                        # 6.1        MATHEMATICAL FALLING DIAGONAL
+27CE..27CF    ; Not_XID                        # 6.0    [2] SQUARED LOGICAL AND..SQUARED LOGICAL OR
+27D0..27EB    ; Not_XID                        # 3.2   [28] WHITE DIAMOND WITH CENTRED DOT..MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET
+27EC..27EF    ; Not_XID                        # 5.1    [4] MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET..MATHEMATICAL RIGHT FLATTENED PARENTHESIS
+27F0..27FF    ; Not_XID                        # 3.2   [16] UPWARDS QUADRUPLE ARROW..LONG RIGHTWARDS SQUIGGLE ARROW
+2900..2A0B    ; Not_XID                        # 3.2  [268] RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE..SUMMATION WITH INTEGRAL
+2A0D..2A73    ; Not_XID                        # 3.2  [103] FINITE PART INTEGRAL..EQUALS SIGN ABOVE TILDE OPERATOR
+2A77..2ADB    ; Not_XID                        # 3.2  [101] EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW..TRANSVERSAL INTERSECTION
+2ADD..2AFF    ; Not_XID                        # 3.2   [35] NONFORKING..N-ARY WHITE VERTICAL BAR
+2B00..2B0D    ; Not_XID                        # 4.0   [14] NORTH EAST WHITE ARROW..UP DOWN BLACK ARROW
+2B0E..2B13    ; Not_XID                        # 4.1    [6] RIGHTWARDS ARROW WITH TIP DOWNWARDS..SQUARE WITH BOTTOM HALF BLACK
+2B14..2B1A    ; Not_XID                        # 5.0    [7] SQUARE WITH UPPER RIGHT DIAGONAL HALF BLACK..DOTTED SQUARE
+2B1B..2B1F    ; Not_XID                        # 5.1    [5] BLACK LARGE SQUARE..BLACK PENTAGON
+2B20..2B23    ; Not_XID                        # 5.0    [4] WHITE PENTAGON..HORIZONTAL BLACK HEXAGON
+2B24..2B4C    ; Not_XID                        # 5.1   [41] BLACK LARGE CIRCLE..RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR
+2B4D..2B4F    ; Not_XID                        # 7.0    [3] DOWNWARDS TRIANGLE-HEADED ZIGZAG ARROW..SHORT BACKSLANTED SOUTH ARROW
+2B50..2B54    ; Not_XID                        # 5.1    [5] WHITE MEDIUM STAR..WHITE RIGHT-POINTING PENTAGON
+2B55..2B59    ; Not_XID                        # 5.2    [5] HEAVY LARGE CIRCLE..HEAVY CIRCLED SALTIRE
+2B5A..2B73    ; Not_XID                        # 7.0   [26] SLANTED NORTH ARROW WITH HOOKED HEAD..DOWNWARDS TRIANGLE-HEADED ARROW TO BAR
+2B76..2B95    ; Not_XID                        # 7.0   [32] NORTH WEST TRIANGLE-HEADED ARROW TO BAR..RIGHTWARDS BLACK ARROW
+2B96          ; Not_XID                        # 17.0       EQUALS SIGN WITH INFINITY ABOVE
+2B97          ; Not_XID                        # 13.0       SYMBOL FOR TYPE A ELECTRONICS
+2B98..2BB9    ; Not_XID                        # 7.0   [34] THREE-D TOP-LIGHTED LEFTWARDS EQUILATERAL ARROWHEAD..UP ARROWHEAD IN A RECTANGLE BOX
+2BBA..2BBC    ; Not_XID                        # 11.0   [3] OVERLAPPING WHITE SQUARES..OVERLAPPING BLACK SQUARES
+2BBD..2BC8    ; Not_XID                        # 7.0   [12] BALLOT BOX WITH LIGHT X..BLACK MEDIUM RIGHT-POINTING TRIANGLE CENTRED
+2BC9          ; Not_XID                        # 12.0       NEPTUNE FORM TWO
+2BCA..2BD1    ; Not_XID                        # 7.0    [8] TOP HALF BLACK CIRCLE..UNCERTAINTY SIGN
+2BD2          ; Not_XID                        # 10.0       GROUP MARK
+2BD3..2BEB    ; Not_XID                        # 11.0  [25] PLUTO FORM TWO..STAR WITH RIGHT HALF BLACK
+2BF0..2BFE    ; Not_XID                        # 11.0  [15] ERIS FORM ONE..REVERSED RIGHT ANGLE
+2BFF          ; Not_XID                        # 12.0       HELLSCHREIBER PAUSE SYMBOL
+2E17          ; Not_XID                        # 4.1        DOUBLE OBLIQUE HYPHEN
+2E18..2E1B    ; Not_XID                        # 5.1    [4] INVERTED INTERROBANG..TILDE WITH RING ABOVE
+2E1C..2E1D    ; Not_XID                        # 4.1    [2] LEFT LOW PARAPHRASE BRACKET..RIGHT LOW PARAPHRASE BRACKET
+2E1E..2E29    ; Not_XID                        # 5.1   [12] TILDE WITH DOT ABOVE..RIGHT DOUBLE PARENTHESIS
+2E33..2E34    ; Not_XID                        # 6.1    [2] RAISED DOT..RAISED COMMA
+2E36..2E38    ; Not_XID                        # 6.1    [3] DAGGER WITH LEFT GUARD..TURNED DAGGER
+2E3A..2E3B    ; Not_XID                        # 6.1    [2] TWO-EM DASH..THREE-EM DASH
+2E3D..2E42    ; Not_XID                        # 7.0    [6] VERTICAL SIX DOTS..DOUBLE LOW-REVERSED-9 QUOTATION MARK
+2E43..2E44    ; Not_XID                        # 9.0    [2] DASH WITH LEFT UPTURN..DOUBLE SUSPENSION MARK
+2E45..2E49    ; Not_XID                        # 10.0   [5] INVERTED LOW KAVYKA..DOUBLE STACKED COMMA
+2E4A..2E4E    ; Not_XID                        # 11.0   [5] DOTTED SOLIDUS..PUNCTUS ELEVATUS MARK
+2E4F          ; Not_XID                        # 12.0       CORNISH VERSE DIVIDER
+2E50..2E52    ; Not_XID                        # 13.0   [3] CROSS PATTY WITH RIGHT CROSSBAR..TIRONIAN SIGN CAPITAL ET
+2E53..2E5D    ; Not_XID                        # 14.0  [11] MEDIEVAL EXCLAMATION MARK..OBLIQUE HYPHEN
+2E80..2E99    ; Not_XID                        # 3.0   [26] CJK RADICAL REPEAT..CJK RADICAL RAP
+2E9B..2E9E    ; Not_XID                        # 3.0    [4] CJK RADICAL CHOKE..CJK RADICAL DEATH
+2EA0..2EF2    ; Not_XID                        # 3.0   [83] CJK RADICAL CIVILIAN..CJK RADICAL J-SIMPLIFIED TURTLE
+2FF0..2FFB    ; Not_XID                        # 3.0   [12] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER OVERLAID
+2FFC..2FFF    ; Not_XID                        # 15.1   [4] IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER ROTATION
+3001..3004    ; Not_XID                        # 1.1    [4] IDEOGRAPHIC COMMA..JAPANESE INDUSTRIAL STANDARD SYMBOL
+3008..301D    ; Not_XID                        # 1.1   [22] LEFT ANGLE BRACKET..REVERSED DOUBLE PRIME QUOTATION MARK
+301F..3020    ; Not_XID                        # 1.1    [2] LOW DOUBLE PRIME QUOTATION MARK..POSTAL MARK FACE
+3030          ; Not_XID                        # 1.1        WAVY DASH
+3037          ; Not_XID                        # 1.1        IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL
+303D          ; Not_XID                        # 3.2        PART ALTERNATION MARK
+303E          ; Not_XID                        # 3.0        IDEOGRAPHIC VARIATION INDICATOR
+303F          ; Not_XID                        # 1.1        IDEOGRAPHIC HALF FILL SPACE
+3190..3191    ; Not_XID                        # 1.1    [2] IDEOGRAPHIC ANNOTATION LINKING MARK..IDEOGRAPHIC ANNOTATION REVERSE MARK
+31C0..31CF    ; Not_XID                        # 4.1   [16] CJK STROKE T..CJK STROKE N
+31D0..31E3    ; Not_XID                        # 5.1   [20] CJK STROKE H..CJK STROKE Q
+31E4..31E5    ; Not_XID                        # 16.0   [2] CJK STROKE HXG..CJK STROKE SZP
+31EF          ; Not_XID                        # 15.1       IDEOGRAPHIC DESCRIPTION CHARACTER SUBTRACTION
+3248..324F    ; Not_XID                        # 5.2    [8] CIRCLED NUMBER TEN ON BLACK SQUARE..CIRCLED NUMBER EIGHTY ON BLACK SQUARE
+A67E          ; Not_XID                        # 5.1        CYRILLIC KAVYKA
+A720..A721    ; Not_XID                        # 5.0    [2] MODIFIER LETTER STRESS AND HIGH TONE..MODIFIER LETTER STRESS AND LOW TONE
+A789..A78A    ; Not_XID                        # 5.1    [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN
+A830..A839    ; Not_XID                        # 5.2   [10] NORTH INDIC FRACTION ONE QUARTER..NORTH INDIC QUANTITY MARK
+A92E          ; Not_XID                        # 5.1        KAYAH LI SIGN CWI
+AA77..AA79    ; Not_XID                        # 5.2    [3] MYANMAR SYMBOL AITON EXCLAMATION..MYANMAR SYMBOL AITON TWO
+AB5B          ; Not_XID                        # 7.0        MODIFIER BREVE WITH INVERTED BREVE
+AB6A..AB6B    ; Not_XID                        # 13.0   [2] MODIFIER LETTER LEFT TACK..MODIFIER LETTER RIGHT TACK
+FFF9..FFFB    ; Not_XID                        # 3.0    [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR
+FFFC          ; Not_XID                        # 2.1        OBJECT REPLACEMENT CHARACTER
+FFFD          ; Not_XID                        # 1.1        REPLACEMENT CHARACTER
+10175..1018A  ; Not_XID                        # 4.1   [22] GREEK ONE HALF SIGN..GREEK ZERO SIGN
+1018B..1018C  ; Not_XID                        # 7.0    [2] GREEK ONE QUARTER SIGN..GREEK SINUSOID SIGN
+1018D..1018E  ; Not_XID                        # 9.0    [2] GREEK INDICTION SIGN..NOMISMA SIGN
+10190..1019B  ; Not_XID                        # 5.1   [12] ROMAN SEXTANS SIGN..ROMAN CENTURIAL SIGN
+1019C         ; Not_XID                        # 13.0       ASCIA SYMBOL
+101A0         ; Not_XID                        # 7.0        GREEK SYMBOL TAU RHO
+10E60..10E7E  ; Not_XID                        # 5.2   [31] RUMI DIGIT ONE..RUMI FRACTION TWO THIRDS
+10ED0..10ED8  ; Not_XID                        # 17.0   [9] ARABIC BIBLICAL END OF VERSE..ARABIC LIGATURE NAWWARA ALLAAHU MARQADAH
+111E1..111F4  ; Not_XID                        # 7.0   [20] SINHALA ARCHAIC DIGIT ONE..SINHALA ARCHAIC NUMBER ONE THOUSAND
+11B00..11B09  ; Not_XID                        # 15.0  [10] DEVANAGARI HEAD MARK..DEVANAGARI SIGN MINDU
+11FC0..11FF1  ; Not_XID                        # 12.0  [50] TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH..TAMIL SIGN VAKAIYARAA
+11FFF         ; Not_XID                        # 12.0       TAMIL PUNCTUATION END OF TEXT
+16FE2         ; Not_XID                        # 12.0       OLD CHINESE HOOK MARK
+1CC00..1CCD5  ; Not_XID                        # 16.0 [214] UP-POINTING GO-KART..LOWER RIGHT QUADRANT STANDING KNIGHT
+1CCFA..1CCFC  ; Not_XID                        # 17.0   [3] SNAKE SYMBOL..NOSE SYMBOL
+1CD00..1CEB3  ; Not_XID                        # 16.0 [436] BLOCK OCTANT-3..BLACK RIGHT TRIANGLE CARET
+1CEBA..1CED0  ; Not_XID                        # 17.0  [23] FRAGILE SYMBOL..LEUKOTHEA
+1CEE0..1CEF0  ; Not_XID                        # 17.0  [17] GEOMANTIC FIGURE POPULUS..MEDIUM SMALL WHITE CIRCLE WITH HORIZONTAL BAR
+1D2C0..1D2D3  ; Not_XID                        # 15.0  [20] KAKTOVIK NUMERAL ZERO..KAKTOVIK NUMERAL NINETEEN
+1D2E0..1D2F3  ; Not_XID                        # 11.0  [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN
+1D360..1D371  ; Not_XID                        # 5.0   [18] COUNTING ROD UNIT DIGIT ONE..COUNTING ROD TENS DIGIT NINE
+1D372..1D378  ; Not_XID                        # 11.0   [7] IDEOGRAPHIC TALLY MARK ONE..TALLY MARK FIVE
+1EC71..1ECB4  ; Not_XID                        # 11.0  [68] INDIC SIYAQ NUMBER ONE..INDIC SIYAQ ALTERNATE LAKH MARK
+1ED01..1ED3D  ; Not_XID                        # 12.0  [61] OTTOMAN SIYAQ NUMBER ONE..OTTOMAN SIYAQ FRACTION ONE SIXTH
+1EEF0..1EEF1  ; Not_XID                        # 6.1    [2] ARABIC MATHEMATICAL OPERATOR MEEM WITH HAH WITH TATWEEL..ARABIC MATHEMATICAL OPERATOR HAH WITH DAL
+1F000..1F02B  ; Not_XID                        # 5.1   [44] MAHJONG TILE EAST WIND..MAHJONG TILE BACK
+1F030..1F093  ; Not_XID                        # 5.1  [100] DOMINO TILE HORIZONTAL BACK..DOMINO TILE VERTICAL-06-06
+1F0A0..1F0AE  ; Not_XID                        # 6.0   [15] PLAYING CARD BACK..PLAYING CARD KING OF SPADES
+1F0B1..1F0BE  ; Not_XID                        # 6.0   [14] PLAYING CARD ACE OF HEARTS..PLAYING CARD KING OF HEARTS
+1F0BF         ; Not_XID                        # 7.0        PLAYING CARD RED JOKER
+1F0C1..1F0CF  ; Not_XID                        # 6.0   [15] PLAYING CARD ACE OF DIAMONDS..PLAYING CARD BLACK JOKER
+1F0D1..1F0DF  ; Not_XID                        # 6.0   [15] PLAYING CARD ACE OF CLUBS..PLAYING CARD WHITE JOKER
+1F0E0..1F0F5  ; Not_XID                        # 7.0   [22] PLAYING CARD FOOL..PLAYING CARD TRUMP-21
+1F10B..1F10C  ; Not_XID                        # 7.0    [2] DINGBAT CIRCLED SANS-SERIF DIGIT ZERO..DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ZERO
+1F10D..1F10F  ; Not_XID                        # 13.0   [3] CIRCLED ZERO WITH SLASH..CIRCLED DOLLAR SIGN WITH OVERLAID BACKSLASH
+1F12F         ; Not_XID                        # 11.0       COPYLEFT SYMBOL
+1F150..1F156  ; Not_XID                        # 6.0    [7] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER G
+1F157         ; Not_XID                        # 5.2        NEGATIVE CIRCLED LATIN CAPITAL LETTER H
+1F158..1F15E  ; Not_XID                        # 6.0    [7] NEGATIVE CIRCLED LATIN CAPITAL LETTER I..NEGATIVE CIRCLED LATIN CAPITAL LETTER O
+1F15F         ; Not_XID                        # 5.2        NEGATIVE CIRCLED LATIN CAPITAL LETTER P
+1F160..1F169  ; Not_XID                        # 6.0   [10] NEGATIVE CIRCLED LATIN CAPITAL LETTER Q..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z
+1F16D..1F16F  ; Not_XID                        # 13.0   [3] CIRCLED CC..CIRCLED HUMAN FIGURE
+1F170..1F178  ; Not_XID                        # 6.0    [9] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER I
+1F179         ; Not_XID                        # 5.2        NEGATIVE SQUARED LATIN CAPITAL LETTER J
+1F17A         ; Not_XID                        # 6.0        NEGATIVE SQUARED LATIN CAPITAL LETTER K
+1F17B..1F17C  ; Not_XID                        # 5.2    [2] NEGATIVE SQUARED LATIN CAPITAL LETTER L..NEGATIVE SQUARED LATIN CAPITAL LETTER M
+1F17D..1F17E  ; Not_XID                        # 6.0    [2] NEGATIVE SQUARED LATIN CAPITAL LETTER N..NEGATIVE SQUARED LATIN CAPITAL LETTER O
+1F17F         ; Not_XID                        # 5.2        NEGATIVE SQUARED LATIN CAPITAL LETTER P
+1F180..1F189  ; Not_XID                        # 6.0   [10] NEGATIVE SQUARED LATIN CAPITAL LETTER Q..NEGATIVE SQUARED LATIN CAPITAL LETTER Z
+1F18A..1F18D  ; Not_XID                        # 5.2    [4] CROSSED NEGATIVE SQUARED LATIN CAPITAL LETTER P..NEGATIVE SQUARED SA
+1F18E..1F18F  ; Not_XID                        # 6.0    [2] NEGATIVE SQUARED AB..NEGATIVE SQUARED WC
+1F191..1F19A  ; Not_XID                        # 6.0   [10] SQUARED CL..SQUARED VS
+1F19B..1F1AC  ; Not_XID                        # 9.0   [18] SQUARED THREE D..SQUARED VOD
+1F1AD         ; Not_XID                        # 13.0       MASK WORK SYMBOL
+1F1E6..1F1FF  ; Not_XID                        # 6.0   [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z
+1F260..1F265  ; Not_XID                        # 10.0   [6] ROUNDED SYMBOL FOR FU..ROUNDED SYMBOL FOR CAI
+1F300..1F320  ; Not_XID                        # 6.0   [33] CYCLONE..SHOOTING STAR
+1F321..1F32C  ; Not_XID                        # 7.0   [12] THERMOMETER..WIND BLOWING FACE
+1F32D..1F32F  ; Not_XID                        # 8.0    [3] HOT DOG..BURRITO
+1F330..1F335  ; Not_XID                        # 6.0    [6] CHESTNUT..CACTUS
+1F336         ; Not_XID                        # 7.0        HOT PEPPER
+1F337..1F37C  ; Not_XID                        # 6.0   [70] TULIP..BABY BOTTLE
+1F37D         ; Not_XID                        # 7.0        FORK AND KNIFE WITH PLATE
+1F37E..1F37F  ; Not_XID                        # 8.0    [2] BOTTLE WITH POPPING CORK..POPCORN
+1F380..1F393  ; Not_XID                        # 6.0   [20] RIBBON..GRADUATION CAP
+1F394..1F39F  ; Not_XID                        # 7.0   [12] HEART WITH TIP ON THE LEFT..ADMISSION TICKETS
+1F3A0..1F3C4  ; Not_XID                        # 6.0   [37] CAROUSEL HORSE..SURFER
+1F3C5         ; Not_XID                        # 7.0        SPORTS MEDAL
+1F3C6..1F3CA  ; Not_XID                        # 6.0    [5] TROPHY..SWIMMER
+1F3CB..1F3CE  ; Not_XID                        # 7.0    [4] WEIGHT LIFTER..RACING CAR
+1F3CF..1F3D3  ; Not_XID                        # 8.0    [5] CRICKET BAT AND BALL..TABLE TENNIS PADDLE AND BALL
+1F3D4..1F3DF  ; Not_XID                        # 7.0   [12] SNOW CAPPED MOUNTAIN..STADIUM
+1F3E0..1F3F0  ; Not_XID                        # 6.0   [17] HOUSE BUILDING..EUROPEAN CASTLE
+1F3F1..1F3F7  ; Not_XID                        # 7.0    [7] WHITE PENNANT..LABEL
+1F3F8..1F3FF  ; Not_XID                        # 8.0    [8] BADMINTON RACQUET AND SHUTTLECOCK..EMOJI MODIFIER FITZPATRICK TYPE-6
+1F400..1F43E  ; Not_XID                        # 6.0   [63] RAT..PAW PRINTS
+1F43F         ; Not_XID                        # 7.0        CHIPMUNK
+1F440         ; Not_XID                        # 6.0        EYES
+1F441         ; Not_XID                        # 7.0        EYE
+1F442..1F4F7  ; Not_XID                        # 6.0  [182] EAR..CAMERA
+1F4F8         ; Not_XID                        # 7.0        CAMERA WITH FLASH
+1F4F9..1F4FC  ; Not_XID                        # 6.0    [4] VIDEO CAMERA..VIDEOCASSETTE
+1F4FD..1F4FE  ; Not_XID                        # 7.0    [2] FILM PROJECTOR..PORTABLE STEREO
+1F4FF         ; Not_XID                        # 8.0        PRAYER BEADS
+1F500..1F53D  ; Not_XID                        # 6.0   [62] TWISTED RIGHTWARDS ARROWS..DOWN-POINTING SMALL RED TRIANGLE
+1F53E..1F53F  ; Not_XID                        # 7.0    [2] LOWER RIGHT SHADOWED WHITE CIRCLE..UPPER RIGHT SHADOWED WHITE CIRCLE
+1F540..1F543  ; Not_XID                        # 6.1    [4] CIRCLED CROSS POMMEE..NOTCHED LEFT SEMICIRCLE WITH THREE DOTS
+1F544..1F54A  ; Not_XID                        # 7.0    [7] NOTCHED RIGHT SEMICIRCLE WITH THREE DOTS..DOVE OF PEACE
+1F54B..1F54E  ; Not_XID                        # 8.0    [4] KAABA..MENORAH WITH NINE BRANCHES
+1F550..1F567  ; Not_XID                        # 6.0   [24] CLOCK FACE ONE OCLOCK..CLOCK FACE TWELVE-THIRTY
+1F568..1F579  ; Not_XID                        # 7.0   [18] RIGHT SPEAKER..JOYSTICK
+1F57A         ; Not_XID                        # 9.0        MAN DANCING
+1F57B..1F5A3  ; Not_XID                        # 7.0   [41] LEFT HAND TELEPHONE RECEIVER..BLACK DOWN POINTING BACKHAND INDEX
+1F5A4         ; Not_XID                        # 9.0        BLACK HEART
+1F5A5..1F5FA  ; Not_XID                        # 7.0   [86] DESKTOP COMPUTER..WORLD MAP
+1F5FB..1F5FF  ; Not_XID                        # 6.0    [5] MOUNT FUJI..MOYAI
+1F600         ; Not_XID                        # 6.1        GRINNING FACE
+1F601..1F610  ; Not_XID                        # 6.0   [16] GRINNING FACE WITH SMILING EYES..NEUTRAL FACE
+1F611         ; Not_XID                        # 6.1        EXPRESSIONLESS FACE
+1F612..1F614  ; Not_XID                        # 6.0    [3] UNAMUSED FACE..PENSIVE FACE
+1F615         ; Not_XID                        # 6.1        CONFUSED FACE
+1F616         ; Not_XID                        # 6.0        CONFOUNDED FACE
+1F617         ; Not_XID                        # 6.1        KISSING FACE
+1F618         ; Not_XID                        # 6.0        FACE THROWING A KISS
+1F619         ; Not_XID                        # 6.1        KISSING FACE WITH SMILING EYES
+1F61A         ; Not_XID                        # 6.0        KISSING FACE WITH CLOSED EYES
+1F61B         ; Not_XID                        # 6.1        FACE WITH STUCK-OUT TONGUE
+1F61C..1F61E  ; Not_XID                        # 6.0    [3] FACE WITH STUCK-OUT TONGUE AND WINKING EYE..DISAPPOINTED FACE
+1F61F         ; Not_XID                        # 6.1        WORRIED FACE
+1F620..1F625  ; Not_XID                        # 6.0    [6] ANGRY FACE..DISAPPOINTED BUT RELIEVED FACE
+1F626..1F627  ; Not_XID                        # 6.1    [2] FROWNING FACE WITH OPEN MOUTH..ANGUISHED FACE
+1F628..1F62B  ; Not_XID                        # 6.0    [4] FEARFUL FACE..TIRED FACE
+1F62C         ; Not_XID                        # 6.1        GRIMACING FACE
+1F62D         ; Not_XID                        # 6.0        LOUDLY CRYING FACE
+1F62E..1F62F  ; Not_XID                        # 6.1    [2] FACE WITH OPEN MOUTH..HUSHED FACE
+1F630..1F633  ; Not_XID                        # 6.0    [4] FACE WITH OPEN MOUTH AND COLD SWEAT..FLUSHED FACE
+1F634         ; Not_XID                        # 6.1        SLEEPING FACE
+1F635..1F640  ; Not_XID                        # 6.0   [12] DIZZY FACE..WEARY CAT FACE
+1F641..1F642  ; Not_XID                        # 7.0    [2] SLIGHTLY FROWNING FACE..SLIGHTLY SMILING FACE
+1F643..1F644  ; Not_XID                        # 8.0    [2] UPSIDE-DOWN FACE..FACE WITH ROLLING EYES
+1F645..1F64F  ; Not_XID                        # 6.0   [11] FACE WITH NO GOOD GESTURE..PERSON WITH FOLDED HANDS
+1F650..1F67F  ; Not_XID                        # 7.0   [48] NORTH WEST POINTING LEAF..REVERSE CHECKER BOARD
+1F680..1F6C5  ; Not_XID                        # 6.0   [70] ROCKET..LEFT LUGGAGE
+1F6C6..1F6CF  ; Not_XID                        # 7.0   [10] TRIANGLE WITH ROUNDED CORNERS..BED
+1F6D0         ; Not_XID                        # 8.0        PLACE OF WORSHIP
+1F6D1..1F6D2  ; Not_XID                        # 9.0    [2] OCTAGONAL SIGN..SHOPPING TROLLEY
+1F6D3..1F6D4  ; Not_XID                        # 10.0   [2] STUPA..PAGODA
+1F6D5         ; Not_XID                        # 12.0       HINDU TEMPLE
+1F6D6..1F6D7  ; Not_XID                        # 13.0   [2] HUT..ELEVATOR
+1F6D8         ; Not_XID                        # 17.0       LANDSLIDE
+1F6DC         ; Not_XID                        # 15.0       WIRELESS
+1F6DD..1F6DF  ; Not_XID                        # 14.0   [3] PLAYGROUND SLIDE..RING BUOY
+1F6E0..1F6EC  ; Not_XID                        # 7.0   [13] HAMMER AND WRENCH..AIRPLANE ARRIVING
+1F6F0..1F6F3  ; Not_XID                        # 7.0    [4] SATELLITE..PASSENGER SHIP
+1F6F4..1F6F6  ; Not_XID                        # 9.0    [3] SCOOTER..CANOE
+1F6F7..1F6F8  ; Not_XID                        # 10.0   [2] SLED..FLYING SAUCER
+1F6F9         ; Not_XID                        # 11.0       SKATEBOARD
+1F6FA         ; Not_XID                        # 12.0       AUTO RICKSHAW
+1F6FB..1F6FC  ; Not_XID                        # 13.0   [2] PICKUP TRUCK..ROLLER SKATE
+1F700..1F773  ; Not_XID                        # 6.0  [116] ALCHEMICAL SYMBOL FOR QUINTESSENCE..ALCHEMICAL SYMBOL FOR HALF OUNCE
+1F774..1F776  ; Not_XID                        # 15.0   [3] LOT OF FORTUNE..LUNAR ECLIPSE
+1F777..1F77A  ; Not_XID                        # 17.0   [4] VESTA FORM TWO..PARTHENOPE FORM TWO
+1F77B..1F77F  ; Not_XID                        # 15.0   [5] HAUMEA..ORCUS
+1F780..1F7D4  ; Not_XID                        # 7.0   [85] BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE..HEAVY TWELVE POINTED PINWHEEL STAR
+1F7D5..1F7D8  ; Not_XID                        # 11.0   [4] CIRCLED TRIANGLE..NEGATIVE CIRCLED SQUARE
+1F7D9         ; Not_XID                        # 15.0       NINE POINTED WHITE STAR
+1F7E0..1F7EB  ; Not_XID                        # 12.0  [12] LARGE ORANGE CIRCLE..LARGE BROWN SQUARE
+1F7F0         ; Not_XID                        # 14.0       HEAVY EQUALS SIGN
+1F800..1F80B  ; Not_XID                        # 7.0   [12] LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD..DOWNWARDS ARROW WITH LARGE TRIANGLE ARROWHEAD
+1F810..1F847  ; Not_XID                        # 7.0   [56] LEFTWARDS ARROW WITH SMALL EQUILATERAL ARROWHEAD..DOWNWARDS HEAVY ARROW
+1F850..1F859  ; Not_XID                        # 7.0   [10] LEFTWARDS SANS-SERIF ARROW..UP DOWN SANS-SERIF ARROW
+1F860..1F887  ; Not_XID                        # 7.0   [40] WIDE-HEADED LEFTWARDS LIGHT BARB ARROW..WIDE-HEADED SOUTH WEST VERY HEAVY BARB ARROW
+1F890..1F8AD  ; Not_XID                        # 7.0   [30] LEFTWARDS TRIANGLE ARROWHEAD..WHITE ARROW SHAFT WIDTH TWO THIRDS
+1F8B0..1F8B1  ; Not_XID                        # 13.0   [2] ARROW POINTING UPWARDS THEN NORTH WEST..ARROW POINTING RIGHTWARDS THEN CURVING SOUTH WEST
+1F8B2..1F8BB  ; Not_XID                        # 16.0  [10] RIGHTWARDS ARROW WITH LOWER HOOK..SOUTH WEST ARROW FROM BAR
+1F8C0..1F8C1  ; Not_XID                        # 16.0   [2] LEFTWARDS ARROW FROM DOWNWARDS ARROW..RIGHTWARDS ARROW FROM DOWNWARDS ARROW
+1F8D0..1F8D8  ; Not_XID                        # 17.0   [9] LONG RIGHTWARDS ARROW OVER LONG LEFTWARDS ARROW..LONG LEFT RIGHT ARROW WITH DEPENDENT LOBE
+1F900..1F90B  ; Not_XID                        # 10.0  [12] CIRCLED CROSS FORMEE WITH FOUR DOTS..DOWNWARD FACING NOTCHED HOOK WITH DOT
+1F90C         ; Not_XID                        # 13.0       PINCHED FINGERS
+1F90D..1F90F  ; Not_XID                        # 12.0   [3] WHITE HEART..PINCHING HAND
+1F910..1F918  ; Not_XID                        # 8.0    [9] ZIPPER-MOUTH FACE..SIGN OF THE HORNS
+1F919..1F91E  ; Not_XID                        # 9.0    [6] CALL ME HAND..HAND WITH INDEX AND MIDDLE FINGERS CROSSED
+1F91F         ; Not_XID                        # 10.0       I LOVE YOU HAND SIGN
+1F920..1F927  ; Not_XID                        # 9.0    [8] FACE WITH COWBOY HAT..SNEEZING FACE
+1F928..1F92F  ; Not_XID                        # 10.0   [8] FACE WITH ONE EYEBROW RAISED..SHOCKED FACE WITH EXPLODING HEAD
+1F930         ; Not_XID                        # 9.0        PREGNANT WOMAN
+1F931..1F932  ; Not_XID                        # 10.0   [2] BREAST-FEEDING..PALMS UP TOGETHER
+1F933..1F93E  ; Not_XID                        # 9.0   [12] SELFIE..HANDBALL
+1F93F         ; Not_XID                        # 12.0       DIVING MASK
+1F940..1F94B  ; Not_XID                        # 9.0   [12] WILTED FLOWER..MARTIAL ARTS UNIFORM
+1F94C         ; Not_XID                        # 10.0       CURLING STONE
+1F94D..1F94F  ; Not_XID                        # 11.0   [3] LACROSSE STICK AND BALL..FLYING DISC
+1F950..1F95E  ; Not_XID                        # 9.0   [15] CROISSANT..PANCAKES
+1F95F..1F96B  ; Not_XID                        # 10.0  [13] DUMPLING..CANNED FOOD
+1F96C..1F970  ; Not_XID                        # 11.0   [5] LEAFY GREEN..SMILING FACE WITH SMILING EYES AND THREE HEARTS
+1F971         ; Not_XID                        # 12.0       YAWNING FACE
+1F972         ; Not_XID                        # 13.0       SMILING FACE WITH TEAR
+1F973..1F976  ; Not_XID                        # 11.0   [4] FACE WITH PARTY HORN AND PARTY HAT..FREEZING FACE
+1F977..1F978  ; Not_XID                        # 13.0   [2] NINJA..DISGUISED FACE
+1F979         ; Not_XID                        # 14.0       FACE HOLDING BACK TEARS
+1F97A         ; Not_XID                        # 11.0       FACE WITH PLEADING EYES
+1F97B         ; Not_XID                        # 12.0       SARI
+1F97C..1F97F  ; Not_XID                        # 11.0   [4] LAB COAT..FLAT SHOE
+1F980..1F984  ; Not_XID                        # 8.0    [5] CRAB..UNICORN FACE
+1F985..1F991  ; Not_XID                        # 9.0   [13] EAGLE..SQUID
+1F992..1F997  ; Not_XID                        # 10.0   [6] GIRAFFE FACE..CRICKET
+1F998..1F9A2  ; Not_XID                        # 11.0  [11] KANGAROO..SWAN
+1F9A3..1F9A4  ; Not_XID                        # 13.0   [2] MAMMOTH..DODO
+1F9A5..1F9AA  ; Not_XID                        # 12.0   [6] SLOTH..OYSTER
+1F9AB..1F9AD  ; Not_XID                        # 13.0   [3] BEAVER..SEAL
+1F9AE..1F9AF  ; Not_XID                        # 12.0   [2] GUIDE DOG..PROBING CANE
+1F9B0..1F9B9  ; Not_XID                        # 11.0  [10] EMOJI COMPONENT RED HAIR..SUPERVILLAIN
+1F9BA..1F9BF  ; Not_XID                        # 12.0   [6] SAFETY VEST..MECHANICAL LEG
+1F9C0         ; Not_XID                        # 8.0        CHEESE WEDGE
+1F9C1..1F9C2  ; Not_XID                        # 11.0   [2] CUPCAKE..SALT SHAKER
+1F9C3..1F9CA  ; Not_XID                        # 12.0   [8] BEVERAGE BOX..ICE CUBE
+1F9CB         ; Not_XID                        # 13.0       BUBBLE TEA
+1F9CC         ; Not_XID                        # 14.0       TROLL
+1F9CD..1F9CF  ; Not_XID                        # 12.0   [3] STANDING PERSON..DEAF PERSON
+1F9D0..1F9E6  ; Not_XID                        # 10.0  [23] FACE WITH MONOCLE..SOCKS
+1F9E7..1F9FF  ; Not_XID                        # 11.0  [25] RED GIFT ENVELOPE..NAZAR AMULET
+1FA00..1FA53  ; Not_XID                        # 12.0  [84] NEUTRAL CHESS KING..BLACK CHESS KNIGHT-BISHOP
+1FA54..1FA57  ; Not_XID                        # 17.0   [4] WHITE CHESS FERZ..BLACK CHESS ALFIL
+1FA60..1FA6D  ; Not_XID                        # 11.0  [14] XIANGQI RED GENERAL..XIANGQI BLACK SOLDIER
+1FA70..1FA73  ; Not_XID                        # 12.0   [4] BALLET SHOES..SHORTS
+1FA74         ; Not_XID                        # 13.0       THONG SANDAL
+1FA75..1FA77  ; Not_XID                        # 15.0   [3] LIGHT BLUE HEART..PINK HEART
+1FA78..1FA7A  ; Not_XID                        # 12.0   [3] DROP OF BLOOD..STETHOSCOPE
+1FA7B..1FA7C  ; Not_XID                        # 14.0   [2] X-RAY..CRUTCH
+1FA80..1FA82  ; Not_XID                        # 12.0   [3] YO-YO..PARACHUTE
+1FA83..1FA86  ; Not_XID                        # 13.0   [4] BOOMERANG..NESTING DOLLS
+1FA87..1FA88  ; Not_XID                        # 15.0   [2] MARACAS..FLUTE
+1FA89         ; Not_XID                        # 16.0       HARP
+1FA8A         ; Not_XID                        # 17.0       TROMBONE
+1FA8E         ; Not_XID                        # 17.0       TREASURE CHEST
+1FA8F         ; Not_XID                        # 16.0       SHOVEL
+1FA90..1FA95  ; Not_XID                        # 12.0   [6] RINGED PLANET..BANJO
+1FA96..1FAA8  ; Not_XID                        # 13.0  [19] MILITARY HELMET..ROCK
+1FAA9..1FAAC  ; Not_XID                        # 14.0   [4] MIRROR BALL..HAMSA
+1FAAD..1FAAF  ; Not_XID                        # 15.0   [3] FOLDING HAND FAN..KHANDA
+1FAB0..1FAB6  ; Not_XID                        # 13.0   [7] FLY..FEATHER
+1FAB7..1FABA  ; Not_XID                        # 14.0   [4] LOTUS..NEST WITH EGGS
+1FABB..1FABD  ; Not_XID                        # 15.0   [3] HYACINTH..WING
+1FABE         ; Not_XID                        # 16.0       LEAFLESS TREE
+1FABF         ; Not_XID                        # 15.0       GOOSE
+1FAC0..1FAC2  ; Not_XID                        # 13.0   [3] ANATOMICAL HEART..PEOPLE HUGGING
+1FAC3..1FAC5  ; Not_XID                        # 14.0   [3] PREGNANT MAN..PERSON WITH CROWN
+1FAC6         ; Not_XID                        # 16.0       FINGERPRINT
+1FAC8         ; Not_XID                        # 17.0       HAIRY CREATURE
+1FACD         ; Not_XID                        # 17.0       ORCA
+1FACE..1FACF  ; Not_XID                        # 15.0   [2] MOOSE..DONKEY
+1FAD0..1FAD6  ; Not_XID                        # 13.0   [7] BLUEBERRIES..TEAPOT
+1FAD7..1FAD9  ; Not_XID                        # 14.0   [3] POURING LIQUID..JAR
+1FADA..1FADB  ; Not_XID                        # 15.0   [2] GINGER ROOT..PEA POD
+1FADC         ; Not_XID                        # 16.0       ROOT VEGETABLE
+1FADF         ; Not_XID                        # 16.0       SPLATTER
+1FAE0..1FAE7  ; Not_XID                        # 14.0   [8] MELTING FACE..BUBBLES
+1FAE8         ; Not_XID                        # 15.0       SHAKING FACE
+1FAE9         ; Not_XID                        # 16.0       FACE WITH BAGS UNDER EYES
+1FAEA         ; Not_XID                        # 17.0       DISTORTED FACE
+1FAEF         ; Not_XID                        # 17.0       FIGHT CLOUD
+1FAF0..1FAF6  ; Not_XID                        # 14.0   [7] HAND WITH INDEX FINGER AND THUMB CROSSED..HEART HANDS
+1FAF7..1FAF8  ; Not_XID                        # 15.0   [2] LEFTWARDS PUSHING HAND..RIGHTWARDS PUSHING HAND
+1FB00..1FB92  ; Not_XID                        # 13.0 [147] BLOCK SEXTANT-1..UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK
+1FB94..1FBCA  ; Not_XID                        # 13.0  [55] LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK..WHITE UP-POINTING CHEVRON
+1FBCB..1FBEF  ; Not_XID                        # 16.0  [37] WHITE CROSS MARK..TOP LEFT JUSTIFIED LOWER RIGHT QUARTER BLACK CIRCLE
+1FBFA         ; Not_XID                        # 17.0       ALARM BELL SYMBOL
+
+# Total code points: 6487
+
+#	Identifier_Type:	Not_NFKC
+
+00A0          ; Not_NFKC                       # 1.1        NO-BREAK SPACE
+00A8          ; Not_NFKC                       # 1.1        DIAERESIS
+00AA          ; Not_NFKC                       # 1.1        FEMININE ORDINAL INDICATOR
+00AF          ; Not_NFKC                       # 1.1        MACRON
+00B2..00B5    ; Not_NFKC                       # 1.1    [4] SUPERSCRIPT TWO..MICRO SIGN
+00B8..00BA    ; Not_NFKC                       # 1.1    [3] CEDILLA..MASCULINE ORDINAL INDICATOR
+00BC..00BE    ; Not_NFKC                       # 1.1    [3] VULGAR FRACTION ONE QUARTER..VULGAR FRACTION THREE QUARTERS
+0132..0133    ; Not_NFKC                       # 1.1    [2] LATIN CAPITAL LIGATURE IJ..LATIN SMALL LIGATURE IJ
+013F..0140    ; Not_NFKC                       # 1.1    [2] LATIN CAPITAL LETTER L WITH MIDDLE DOT..LATIN SMALL LETTER L WITH MIDDLE DOT
+017F          ; Not_NFKC                       # 1.1        LATIN SMALL LETTER LONG S
+01C4..01CC    ; Not_NFKC                       # 1.1    [9] LATIN CAPITAL LETTER DZ WITH CARON..LATIN SMALL LETTER NJ
+01F1..01F3    ; Not_NFKC                       # 1.1    [3] LATIN CAPITAL LETTER DZ..LATIN SMALL LETTER DZ
+02B0..02B8    ; Not_NFKC                       # 1.1    [9] MODIFIER LETTER SMALL H..MODIFIER LETTER SMALL Y
+02D8..02DD    ; Not_NFKC                       # 1.1    [6] BREVE..DOUBLE ACUTE ACCENT
+02E0..02E4    ; Not_NFKC                       # 1.1    [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP
+0340..0341    ; Not_NFKC                       # 1.1    [2] COMBINING GRAVE TONE MARK..COMBINING ACUTE TONE MARK
+0343..0344    ; Not_NFKC                       # 1.1    [2] COMBINING GREEK KORONIS..COMBINING GREEK DIALYTIKA TONOS
+0374          ; Not_NFKC                       # 1.1        GREEK NUMERAL SIGN
+037A          ; Not_NFKC                       # 1.1        GREEK YPOGEGRAMMENI
+037E          ; Not_NFKC                       # 1.1        GREEK QUESTION MARK
+0384..0385    ; Not_NFKC                       # 1.1    [2] GREEK TONOS..GREEK DIALYTIKA TONOS
+0387          ; Not_NFKC                       # 1.1        GREEK ANO TELEIA
+03D0..03D6    ; Not_NFKC                       # 1.1    [7] GREEK BETA SYMBOL..GREEK PI SYMBOL
+03F0..03F2    ; Not_NFKC                       # 1.1    [3] GREEK KAPPA SYMBOL..GREEK LUNATE SIGMA SYMBOL
+03F4..03F5    ; Not_NFKC                       # 3.1    [2] GREEK CAPITAL THETA SYMBOL..GREEK LUNATE EPSILON SYMBOL
+03F9          ; Not_NFKC                       # 4.0        GREEK CAPITAL LUNATE SIGMA SYMBOL
+0587          ; Not_NFKC                       # 1.1        ARMENIAN SMALL LIGATURE ECH YIWN
+0675..0678    ; Not_NFKC                       # 1.1    [4] ARABIC LETTER HIGH HAMZA ALEF..ARABIC LETTER HIGH HAMZA YEH
+0958..095F    ; Not_NFKC                       # 1.1    [8] DEVANAGARI LETTER QA..DEVANAGARI LETTER YYA
+09DC..09DD    ; Not_NFKC                       # 1.1    [2] BENGALI LETTER RRA..BENGALI LETTER RHA
+09DF          ; Not_NFKC                       # 1.1        BENGALI LETTER YYA
+0A33          ; Not_NFKC                       # 1.1        GURMUKHI LETTER LLA
+0A36          ; Not_NFKC                       # 1.1        GURMUKHI LETTER SHA
+0A59..0A5B    ; Not_NFKC                       # 1.1    [3] GURMUKHI LETTER KHHA..GURMUKHI LETTER ZA
+0A5E          ; Not_NFKC                       # 1.1        GURMUKHI LETTER FA
+0B5C..0B5D    ; Not_NFKC                       # 1.1    [2] ORIYA LETTER RRA..ORIYA LETTER RHA
+0E33          ; Not_NFKC                       # 1.1        THAI CHARACTER SARA AM
+0EB3          ; Not_NFKC                       # 1.1        LAO VOWEL SIGN AM
+0EDC..0EDD    ; Not_NFKC                       # 1.1    [2] LAO HO NO..LAO HO MO
+0F0C          ; Not_NFKC                       # 2.0        TIBETAN MARK DELIMITER TSHEG BSTAR
+0F43          ; Not_NFKC                       # 2.0        TIBETAN LETTER GHA
+0F4D          ; Not_NFKC                       # 2.0        TIBETAN LETTER DDHA
+0F52          ; Not_NFKC                       # 2.0        TIBETAN LETTER DHA
+0F57          ; Not_NFKC                       # 2.0        TIBETAN LETTER BHA
+0F5C          ; Not_NFKC                       # 2.0        TIBETAN LETTER DZHA
+0F69          ; Not_NFKC                       # 2.0        TIBETAN LETTER KSSA
+0F73          ; Not_NFKC                       # 2.0        TIBETAN VOWEL SIGN II
+0F75..0F76    ; Not_NFKC                       # 2.0    [2] TIBETAN VOWEL SIGN UU..TIBETAN VOWEL SIGN VOCALIC R
+0F78          ; Not_NFKC                       # 2.0        TIBETAN VOWEL SIGN VOCALIC L
+0F81          ; Not_NFKC                       # 2.0        TIBETAN VOWEL SIGN REVERSED II
+0F93          ; Not_NFKC                       # 2.0        TIBETAN SUBJOINED LETTER GHA
+0F9D          ; Not_NFKC                       # 2.0        TIBETAN SUBJOINED LETTER DDHA
+0FA2          ; Not_NFKC                       # 2.0        TIBETAN SUBJOINED LETTER DHA
+0FA7          ; Not_NFKC                       # 2.0        TIBETAN SUBJOINED LETTER BHA
+0FAC          ; Not_NFKC                       # 2.0        TIBETAN SUBJOINED LETTER DZHA
+0FB9          ; Not_NFKC                       # 2.0        TIBETAN SUBJOINED LETTER KSSA
+10FC          ; Not_NFKC                       # 4.1        MODIFIER LETTER GEORGIAN NAR
+1D2C..1D2E    ; Not_NFKC                       # 4.0    [3] MODIFIER LETTER CAPITAL A..MODIFIER LETTER CAPITAL B
+1D30..1D3A    ; Not_NFKC                       # 4.0   [11] MODIFIER LETTER CAPITAL D..MODIFIER LETTER CAPITAL N
+1D3C..1D4D    ; Not_NFKC                       # 4.0   [18] MODIFIER LETTER CAPITAL O..MODIFIER LETTER SMALL G
+1D4F..1D6A    ; Not_NFKC                       # 4.0   [28] MODIFIER LETTER SMALL K..GREEK SUBSCRIPT SMALL LETTER CHI
+1D78          ; Not_NFKC                       # 4.1        MODIFIER LETTER CYRILLIC EN
+1D9B..1DBF    ; Not_NFKC                       # 4.1   [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA
+1E9A          ; Not_NFKC                       # 1.1        LATIN SMALL LETTER A WITH RIGHT HALF RING
+1E9B          ; Not_NFKC                       # 2.0        LATIN SMALL LETTER LONG S WITH DOT ABOVE
+1F71          ; Not_NFKC                       # 1.1        GREEK SMALL LETTER ALPHA WITH OXIA
+1F73          ; Not_NFKC                       # 1.1        GREEK SMALL LETTER EPSILON WITH OXIA
+1F75          ; Not_NFKC                       # 1.1        GREEK SMALL LETTER ETA WITH OXIA
+1F77          ; Not_NFKC                       # 1.1        GREEK SMALL LETTER IOTA WITH OXIA
+1F79          ; Not_NFKC                       # 1.1        GREEK SMALL LETTER OMICRON WITH OXIA
+1F7B          ; Not_NFKC                       # 1.1        GREEK SMALL LETTER UPSILON WITH OXIA
+1F7D          ; Not_NFKC                       # 1.1        GREEK SMALL LETTER OMEGA WITH OXIA
+1FBB          ; Not_NFKC                       # 1.1        GREEK CAPITAL LETTER ALPHA WITH OXIA
+1FBD..1FC1    ; Not_NFKC                       # 1.1    [5] GREEK KORONIS..GREEK DIALYTIKA AND PERISPOMENI
+1FC9          ; Not_NFKC                       # 1.1        GREEK CAPITAL LETTER EPSILON WITH OXIA
+1FCB          ; Not_NFKC                       # 1.1        GREEK CAPITAL LETTER ETA WITH OXIA
+1FCD..1FCF    ; Not_NFKC                       # 1.1    [3] GREEK PSILI AND VARIA..GREEK PSILI AND PERISPOMENI
+1FD3          ; Not_NFKC                       # 1.1        GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
+1FDB          ; Not_NFKC                       # 1.1        GREEK CAPITAL LETTER IOTA WITH OXIA
+1FDD..1FDF    ; Not_NFKC                       # 1.1    [3] GREEK DASIA AND VARIA..GREEK DASIA AND PERISPOMENI
+1FE3          ; Not_NFKC                       # 1.1        GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
+1FEB          ; Not_NFKC                       # 1.1        GREEK CAPITAL LETTER UPSILON WITH OXIA
+1FED..1FEF    ; Not_NFKC                       # 1.1    [3] GREEK DIALYTIKA AND VARIA..GREEK VARIA
+1FF9          ; Not_NFKC                       # 1.1        GREEK CAPITAL LETTER OMICRON WITH OXIA
+1FFB          ; Not_NFKC                       # 1.1        GREEK CAPITAL LETTER OMEGA WITH OXIA
+1FFD..1FFE    ; Not_NFKC                       # 1.1    [2] GREEK OXIA..GREEK DASIA
+2000..200A    ; Not_NFKC                       # 1.1   [11] EN QUAD..HAIR SPACE
+2011          ; Not_NFKC                       # 1.1        NON-BREAKING HYPHEN
+2017          ; Not_NFKC                       # 1.1        DOUBLE LOW LINE
+2024..2026    ; Not_NFKC                       # 1.1    [3] ONE DOT LEADER..HORIZONTAL ELLIPSIS
+202F          ; Not_NFKC                       # 3.0        NARROW NO-BREAK SPACE
+2033..2034    ; Not_NFKC                       # 1.1    [2] DOUBLE PRIME..TRIPLE PRIME
+2036..2037    ; Not_NFKC                       # 1.1    [2] REVERSED DOUBLE PRIME..REVERSED TRIPLE PRIME
+203C          ; Not_NFKC                       # 1.1        DOUBLE EXCLAMATION MARK
+203E          ; Not_NFKC                       # 1.1        OVERLINE
+2047          ; Not_NFKC                       # 3.2        DOUBLE QUESTION MARK
+2048..2049    ; Not_NFKC                       # 3.0    [2] QUESTION EXCLAMATION MARK..EXCLAMATION QUESTION MARK
+2057          ; Not_NFKC                       # 3.2        QUADRUPLE PRIME
+205F          ; Not_NFKC                       # 3.2        MEDIUM MATHEMATICAL SPACE
+2070          ; Not_NFKC                       # 1.1        SUPERSCRIPT ZERO
+2071          ; Not_NFKC                       # 3.2        SUPERSCRIPT LATIN SMALL LETTER I
+2074..208E    ; Not_NFKC                       # 1.1   [27] SUPERSCRIPT FOUR..SUBSCRIPT RIGHT PARENTHESIS
+2090..2094    ; Not_NFKC                       # 4.1    [5] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER SCHWA
+2095..209C    ; Not_NFKC                       # 6.0    [8] LATIN SUBSCRIPT SMALL LETTER H..LATIN SUBSCRIPT SMALL LETTER T
+20A8          ; Not_NFKC                       # 1.1        RUPEE SIGN
+2100..2103    ; Not_NFKC                       # 1.1    [4] ACCOUNT OF..DEGREE CELSIUS
+2105..2107    ; Not_NFKC                       # 1.1    [3] CARE OF..EULER CONSTANT
+2109..2113    ; Not_NFKC                       # 1.1   [11] DEGREE FAHRENHEIT..SCRIPT SMALL L
+2115..2116    ; Not_NFKC                       # 1.1    [2] DOUBLE-STRUCK CAPITAL N..NUMERO SIGN
+2119..211D    ; Not_NFKC                       # 1.1    [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R
+2120..2122    ; Not_NFKC                       # 1.1    [3] SERVICE MARK..TRADE MARK SIGN
+2124          ; Not_NFKC                       # 1.1        DOUBLE-STRUCK CAPITAL Z
+2126          ; Not_NFKC                       # 1.1        OHM SIGN
+2128          ; Not_NFKC                       # 1.1        BLACK-LETTER CAPITAL Z
+212A..212D    ; Not_NFKC                       # 1.1    [4] KELVIN SIGN..BLACK-LETTER CAPITAL C
+212F..2131    ; Not_NFKC                       # 1.1    [3] SCRIPT SMALL E..SCRIPT CAPITAL F
+2133..2138    ; Not_NFKC                       # 1.1    [6] SCRIPT CAPITAL M..DALET SYMBOL
+2139          ; Not_NFKC                       # 3.0        INFORMATION SOURCE
+213B          ; Not_NFKC                       # 4.0        FACSIMILE SIGN
+213C          ; Not_NFKC                       # 4.1        DOUBLE-STRUCK SMALL PI
+213D..2140    ; Not_NFKC                       # 3.2    [4] DOUBLE-STRUCK SMALL GAMMA..DOUBLE-STRUCK N-ARY SUMMATION
+2145..2149    ; Not_NFKC                       # 3.2    [5] DOUBLE-STRUCK ITALIC CAPITAL D..DOUBLE-STRUCK ITALIC SMALL J
+2150..2152    ; Not_NFKC                       # 5.2    [3] VULGAR FRACTION ONE SEVENTH..VULGAR FRACTION ONE TENTH
+2153..217F    ; Not_NFKC                       # 1.1   [45] VULGAR FRACTION ONE THIRD..SMALL ROMAN NUMERAL ONE THOUSAND
+2189          ; Not_NFKC                       # 5.2        VULGAR FRACTION ZERO THIRDS
+222C..222D    ; Not_NFKC                       # 1.1    [2] DOUBLE INTEGRAL..TRIPLE INTEGRAL
+222F..2230    ; Not_NFKC                       # 1.1    [2] SURFACE INTEGRAL..VOLUME INTEGRAL
+2460..24EA    ; Not_NFKC                       # 1.1  [139] CIRCLED DIGIT ONE..CIRCLED DIGIT ZERO
+2A0C          ; Not_NFKC                       # 3.2        QUADRUPLE INTEGRAL OPERATOR
+2A74..2A76    ; Not_NFKC                       # 3.2    [3] DOUBLE COLON EQUAL..THREE CONSECUTIVE EQUALS SIGNS
+2ADC          ; Not_NFKC                       # 3.2        FORKING
+2C7C..2C7D    ; Not_NFKC                       # 5.1    [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V
+2D6F          ; Not_NFKC                       # 4.1        TIFINAGH MODIFIER LETTER LABIALIZATION MARK
+2E9F          ; Not_NFKC                       # 3.0        CJK RADICAL MOTHER
+2EF3          ; Not_NFKC                       # 3.0        CJK RADICAL C-SIMPLIFIED TURTLE
+2F00..2FD5    ; Not_NFKC                       # 3.0  [214] KANGXI RADICAL ONE..KANGXI RADICAL FLUTE
+3000          ; Not_NFKC                       # 1.1        IDEOGRAPHIC SPACE
+3036          ; Not_NFKC                       # 1.1        CIRCLED POSTAL MARK
+3038..303A    ; Not_NFKC                       # 3.0    [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY
+309B..309C    ; Not_NFKC                       # 1.1    [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+309F          ; Not_NFKC                       # 3.2        HIRAGANA DIGRAPH YORI
+30FF          ; Not_NFKC                       # 3.2        KATAKANA DIGRAPH KOTO
+3131..3163    ; Not_NFKC                       # 1.1   [51] HANGUL LETTER KIYEOK..HANGUL LETTER I
+3165..318E    ; Not_NFKC                       # 1.1   [42] HANGUL LETTER SSANGNIEUN..HANGUL LETTER ARAEAE
+3192..319F    ; Not_NFKC                       # 1.1   [14] IDEOGRAPHIC ANNOTATION ONE MARK..IDEOGRAPHIC ANNOTATION MAN MARK
+3200..321C    ; Not_NFKC                       # 1.1   [29] PARENTHESIZED HANGUL KIYEOK..PARENTHESIZED HANGUL CIEUC U
+321D..321E    ; Not_NFKC                       # 4.0    [2] PARENTHESIZED KOREAN CHARACTER OJEON..PARENTHESIZED KOREAN CHARACTER O HU
+3220..3243    ; Not_NFKC                       # 1.1   [36] PARENTHESIZED IDEOGRAPH ONE..PARENTHESIZED IDEOGRAPH REACH
+3244..3247    ; Not_NFKC                       # 5.2    [4] CIRCLED IDEOGRAPH QUESTION..CIRCLED IDEOGRAPH KOTO
+3250          ; Not_NFKC                       # 4.0        PARTNERSHIP SIGN
+3251..325F    ; Not_NFKC                       # 3.2   [15] CIRCLED NUMBER TWENTY ONE..CIRCLED NUMBER THIRTY FIVE
+3260..327B    ; Not_NFKC                       # 1.1   [28] CIRCLED HANGUL KIYEOK..CIRCLED HANGUL HIEUH A
+327C..327D    ; Not_NFKC                       # 4.0    [2] CIRCLED KOREAN CHARACTER CHAMKO..CIRCLED KOREAN CHARACTER JUEUI
+327E          ; Not_NFKC                       # 4.1        CIRCLED HANGUL IEUNG U
+3280..32B0    ; Not_NFKC                       # 1.1   [49] CIRCLED IDEOGRAPH ONE..CIRCLED IDEOGRAPH NIGHT
+32B1..32BF    ; Not_NFKC                       # 3.2   [15] CIRCLED NUMBER THIRTY SIX..CIRCLED NUMBER FIFTY
+32C0..32CB    ; Not_NFKC                       # 1.1   [12] IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY..IDEOGRAPHIC TELEGRAPH SYMBOL FOR DECEMBER
+32CC..32CF    ; Not_NFKC                       # 4.0    [4] SQUARE HG..LIMITED LIABILITY SIGN
+32D0..32FE    ; Not_NFKC                       # 1.1   [47] CIRCLED KATAKANA A..CIRCLED KATAKANA WO
+32FF          ; Not_NFKC                       # 12.1       SQUARE ERA NAME REIWA
+3300..3376    ; Not_NFKC                       # 1.1  [119] SQUARE APAATO..SQUARE PC
+3377..337A    ; Not_NFKC                       # 4.0    [4] SQUARE DM..SQUARE IU
+337B..33DD    ; Not_NFKC                       # 1.1   [99] SQUARE ERA NAME HEISEI..SQUARE WB
+33DE..33DF    ; Not_NFKC                       # 4.0    [2] SQUARE V OVER M..SQUARE A OVER M
+33E0..33FE    ; Not_NFKC                       # 1.1   [31] IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ONE..IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY-ONE
+33FF          ; Not_NFKC                       # 4.0        SQUARE GAL
+A69C..A69D    ; Not_NFKC                       # 7.0    [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN
+A770          ; Not_NFKC                       # 5.1        MODIFIER LETTER US
+A7F1          ; Not_NFKC                       # 17.0       MODIFIER LETTER CAPITAL S
+A7F2..A7F4    ; Not_NFKC                       # 14.0   [3] MODIFIER LETTER CAPITAL C..MODIFIER LETTER CAPITAL Q
+A7F8..A7F9    ; Not_NFKC                       # 6.1    [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE
+AB5C..AB5F    ; Not_NFKC                       # 7.0    [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK
+AB69          ; Not_NFKC                       # 13.0       MODIFIER LETTER SMALL TURNED W
+F900..FA0D    ; Not_NFKC                       # 1.1  [270] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA0D
+FA10          ; Not_NFKC                       # 1.1        CJK COMPATIBILITY IDEOGRAPH-FA10
+FA12          ; Not_NFKC                       # 1.1        CJK COMPATIBILITY IDEOGRAPH-FA12
+FA15..FA1E    ; Not_NFKC                       # 1.1   [10] CJK COMPATIBILITY IDEOGRAPH-FA15..CJK COMPATIBILITY IDEOGRAPH-FA1E
+FA20          ; Not_NFKC                       # 1.1        CJK COMPATIBILITY IDEOGRAPH-FA20
+FA22          ; Not_NFKC                       # 1.1        CJK COMPATIBILITY IDEOGRAPH-FA22
+FA25..FA26    ; Not_NFKC                       # 1.1    [2] CJK COMPATIBILITY IDEOGRAPH-FA25..CJK COMPATIBILITY IDEOGRAPH-FA26
+FA2A..FA2D    ; Not_NFKC                       # 1.1    [4] CJK COMPATIBILITY IDEOGRAPH-FA2A..CJK COMPATIBILITY IDEOGRAPH-FA2D
+FA2E..FA2F    ; Not_NFKC                       # 6.1    [2] CJK COMPATIBILITY IDEOGRAPH-FA2E..CJK COMPATIBILITY IDEOGRAPH-FA2F
+FA30..FA6A    ; Not_NFKC                       # 3.2   [59] CJK COMPATIBILITY IDEOGRAPH-FA30..CJK COMPATIBILITY IDEOGRAPH-FA6A
+FA6B..FA6D    ; Not_NFKC                       # 5.2    [3] CJK COMPATIBILITY IDEOGRAPH-FA6B..CJK COMPATIBILITY IDEOGRAPH-FA6D
+FA70..FAD9    ; Not_NFKC                       # 4.1  [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9
+FB00..FB06    ; Not_NFKC                       # 1.1    [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST
+FB13..FB17    ; Not_NFKC                       # 1.1    [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH
+FB1D          ; Not_NFKC                       # 3.0        HEBREW LETTER YOD WITH HIRIQ
+FB1F..FB36    ; Not_NFKC                       # 1.1   [24] HEBREW LIGATURE YIDDISH YOD YOD PATAH..HEBREW LETTER ZAYIN WITH DAGESH
+FB38..FB3C    ; Not_NFKC                       # 1.1    [5] HEBREW LETTER TET WITH DAGESH..HEBREW LETTER LAMED WITH DAGESH
+FB3E          ; Not_NFKC                       # 1.1        HEBREW LETTER MEM WITH DAGESH
+FB40..FB41    ; Not_NFKC                       # 1.1    [2] HEBREW LETTER NUN WITH DAGESH..HEBREW LETTER SAMEKH WITH DAGESH
+FB43..FB44    ; Not_NFKC                       # 1.1    [2] HEBREW LETTER FINAL PE WITH DAGESH..HEBREW LETTER PE WITH DAGESH
+FB46..FBB1    ; Not_NFKC                       # 1.1  [108] HEBREW LETTER TSADI WITH DAGESH..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM
+FBD3..FD3D    ; Not_NFKC                       # 1.1  [363] ARABIC LETTER NG ISOLATED FORM..ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM
+FD50..FD8F    ; Not_NFKC                       # 1.1   [64] ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM..ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM
+FD92..FDC7    ; Not_NFKC                       # 1.1   [54] ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM..ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM
+FDF0..FDFB    ; Not_NFKC                       # 1.1   [12] ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM..ARABIC LIGATURE JALLAJALALOUHOU
+FDFC          ; Not_NFKC                       # 3.2        RIAL SIGN
+FE10..FE19    ; Not_NFKC                       # 4.1   [10] PRESENTATION FORM FOR VERTICAL COMMA..PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS
+FE30..FE44    ; Not_NFKC                       # 1.1   [21] PRESENTATION FORM FOR VERTICAL TWO DOT LEADER..PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET
+FE47..FE48    ; Not_NFKC                       # 4.0    [2] PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET..PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET
+FE49..FE52    ; Not_NFKC                       # 1.1   [10] DASHED OVERLINE..SMALL FULL STOP
+FE54..FE66    ; Not_NFKC                       # 1.1   [19] SMALL SEMICOLON..SMALL EQUALS SIGN
+FE68..FE6B    ; Not_NFKC                       # 1.1    [4] SMALL REVERSE SOLIDUS..SMALL COMMERCIAL AT
+FE70..FE72    ; Not_NFKC                       # 1.1    [3] ARABIC FATHATAN ISOLATED FORM..ARABIC DAMMATAN ISOLATED FORM
+FE74          ; Not_NFKC                       # 1.1        ARABIC KASRATAN ISOLATED FORM
+FE76..FEFC    ; Not_NFKC                       # 1.1  [135] ARABIC FATHA ISOLATED FORM..ARABIC LIGATURE LAM WITH ALEF FINAL FORM
+FF01..FF5E    ; Not_NFKC                       # 1.1   [94] FULLWIDTH EXCLAMATION MARK..FULLWIDTH TILDE
+FF5F..FF60    ; Not_NFKC                       # 3.2    [2] FULLWIDTH LEFT WHITE PARENTHESIS..FULLWIDTH RIGHT WHITE PARENTHESIS
+FF61..FF9F    ; Not_NFKC                       # 1.1   [63] HALFWIDTH IDEOGRAPHIC FULL STOP..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
+FFA1..FFBE    ; Not_NFKC                       # 1.1   [30] HALFWIDTH HANGUL LETTER KIYEOK..HALFWIDTH HANGUL LETTER HIEUH
+FFC2..FFC7    ; Not_NFKC                       # 1.1    [6] HALFWIDTH HANGUL LETTER A..HALFWIDTH HANGUL LETTER E
+FFCA..FFCF    ; Not_NFKC                       # 1.1    [6] HALFWIDTH HANGUL LETTER YEO..HALFWIDTH HANGUL LETTER OE
+FFD2..FFD7    ; Not_NFKC                       # 1.1    [6] HALFWIDTH HANGUL LETTER YO..HALFWIDTH HANGUL LETTER YU
+FFDA..FFDC    ; Not_NFKC                       # 1.1    [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL LETTER I
+FFE0..FFE6    ; Not_NFKC                       # 1.1    [7] FULLWIDTH CENT SIGN..FULLWIDTH WON SIGN
+FFE8..FFEE    ; Not_NFKC                       # 1.1    [7] HALFWIDTH FORMS LIGHT VERTICAL..HALFWIDTH WHITE CIRCLE
+10781..10785  ; Not_NFKC                       # 14.0   [5] MODIFIER LETTER SUPERSCRIPT TRIANGULAR COLON..MODIFIER LETTER SMALL B WITH HOOK
+10787..107B0  ; Not_NFKC                       # 14.0  [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK
+107B2..107BA  ; Not_NFKC                       # 14.0   [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL
+1CCD6..1CCF9  ; Not_NFKC                       # 16.0  [36] OUTLINED LATIN CAPITAL LETTER A..OUTLINED DIGIT NINE
+1D15E..1D164  ; Not_NFKC                       # 3.1    [7] MUSICAL SYMBOL HALF NOTE..MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE
+1D1BB..1D1C0  ; Not_NFKC                       # 3.1    [6] MUSICAL SYMBOL MINIMA..MUSICAL SYMBOL FUSA BLACK
+1D400..1D454  ; Not_NFKC                       # 3.1   [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G
+1D456..1D49C  ; Not_NFKC                       # 3.1   [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A
+1D49E..1D49F  ; Not_NFKC                       # 3.1    [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D
+1D4A2         ; Not_NFKC                       # 3.1        MATHEMATICAL SCRIPT CAPITAL G
+1D4A5..1D4A6  ; Not_NFKC                       # 3.1    [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K
+1D4A9..1D4AC  ; Not_NFKC                       # 3.1    [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q
+1D4AE..1D4B9  ; Not_NFKC                       # 3.1   [12] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT SMALL D
+1D4BB         ; Not_NFKC                       # 3.1        MATHEMATICAL SCRIPT SMALL F
+1D4BD..1D4C0  ; Not_NFKC                       # 3.1    [4] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL K
+1D4C1         ; Not_NFKC                       # 4.0        MATHEMATICAL SCRIPT SMALL L
+1D4C2..1D4C3  ; Not_NFKC                       # 3.1    [2] MATHEMATICAL SCRIPT SMALL M..MATHEMATICAL SCRIPT SMALL N
+1D4C5..1D505  ; Not_NFKC                       # 3.1   [65] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL FRAKTUR CAPITAL B
+1D507..1D50A  ; Not_NFKC                       # 3.1    [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G
+1D50D..1D514  ; Not_NFKC                       # 3.1    [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q
+1D516..1D51C  ; Not_NFKC                       # 3.1    [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y
+1D51E..1D539  ; Not_NFKC                       # 3.1   [28] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B
+1D53B..1D53E  ; Not_NFKC                       # 3.1    [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G
+1D540..1D544  ; Not_NFKC                       # 3.1    [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M
+1D546         ; Not_NFKC                       # 3.1        MATHEMATICAL DOUBLE-STRUCK CAPITAL O
+1D54A..1D550  ; Not_NFKC                       # 3.1    [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y
+1D552..1D6A3  ; Not_NFKC                       # 3.1  [338] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL MONOSPACE SMALL Z
+1D6A4..1D6A5  ; Not_NFKC                       # 4.1    [2] MATHEMATICAL ITALIC SMALL DOTLESS I..MATHEMATICAL ITALIC SMALL DOTLESS J
+1D6A8..1D7C9  ; Not_NFKC                       # 3.1  [290] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC PI SYMBOL
+1D7CA..1D7CB  ; Not_NFKC                       # 5.0    [2] MATHEMATICAL BOLD CAPITAL DIGAMMA..MATHEMATICAL BOLD SMALL DIGAMMA
+1D7CE..1D7FF  ; Not_NFKC                       # 3.1   [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE
+1E030..1E06D  ; Not_NFKC                       # 15.0  [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE
+1EE00..1EE03  ; Not_NFKC                       # 6.1    [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL
+1EE05..1EE1F  ; Not_NFKC                       # 6.1   [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF
+1EE21..1EE22  ; Not_NFKC                       # 6.1    [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM
+1EE24         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL INITIAL HEH
+1EE27         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL INITIAL HAH
+1EE29..1EE32  ; Not_NFKC                       # 6.1   [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF
+1EE34..1EE37  ; Not_NFKC                       # 6.1    [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH
+1EE39         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL INITIAL DAD
+1EE3B         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL INITIAL GHAIN
+1EE42         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL TAILED JEEM
+1EE47         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL TAILED HAH
+1EE49         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL TAILED YEH
+1EE4B         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL TAILED LAM
+1EE4D..1EE4F  ; Not_NFKC                       # 6.1    [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN
+1EE51..1EE52  ; Not_NFKC                       # 6.1    [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF
+1EE54         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL TAILED SHEEN
+1EE57         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL TAILED KHAH
+1EE59         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL TAILED DAD
+1EE5B         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL TAILED GHAIN
+1EE5D         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL TAILED DOTLESS NOON
+1EE5F         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL TAILED DOTLESS QAF
+1EE61..1EE62  ; Not_NFKC                       # 6.1    [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM
+1EE64         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL STRETCHED HEH
+1EE67..1EE6A  ; Not_NFKC                       # 6.1    [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF
+1EE6C..1EE72  ; Not_NFKC                       # 6.1    [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF
+1EE74..1EE77  ; Not_NFKC                       # 6.1    [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH
+1EE79..1EE7C  ; Not_NFKC                       # 6.1    [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH
+1EE7E         ; Not_NFKC                       # 6.1        ARABIC MATHEMATICAL STRETCHED DOTLESS FEH
+1EE80..1EE89  ; Not_NFKC                       # 6.1   [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH
+1EE8B..1EE9B  ; Not_NFKC                       # 6.1   [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN
+1EEA1..1EEA3  ; Not_NFKC                       # 6.1    [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL
+1EEA5..1EEA9  ; Not_NFKC                       # 6.1    [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH
+1EEAB..1EEBB  ; Not_NFKC                       # 6.1   [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN
+1F100..1F10A  ; Not_NFKC                       # 5.2   [11] DIGIT ZERO FULL STOP..DIGIT NINE COMMA
+1F110..1F12E  ; Not_NFKC                       # 5.2   [31] PARENTHESIZED LATIN CAPITAL LETTER A..CIRCLED WZ
+1F130         ; Not_NFKC                       # 6.0        SQUARED LATIN CAPITAL LETTER A
+1F131         ; Not_NFKC                       # 5.2        SQUARED LATIN CAPITAL LETTER B
+1F132..1F13C  ; Not_NFKC                       # 6.0   [11] SQUARED LATIN CAPITAL LETTER C..SQUARED LATIN CAPITAL LETTER M
+1F13D         ; Not_NFKC                       # 5.2        SQUARED LATIN CAPITAL LETTER N
+1F13E         ; Not_NFKC                       # 6.0        SQUARED LATIN CAPITAL LETTER O
+1F13F         ; Not_NFKC                       # 5.2        SQUARED LATIN CAPITAL LETTER P
+1F140..1F141  ; Not_NFKC                       # 6.0    [2] SQUARED LATIN CAPITAL LETTER Q..SQUARED LATIN CAPITAL LETTER R
+1F142         ; Not_NFKC                       # 5.2        SQUARED LATIN CAPITAL LETTER S
+1F143..1F145  ; Not_NFKC                       # 6.0    [3] SQUARED LATIN CAPITAL LETTER T..SQUARED LATIN CAPITAL LETTER V
+1F146         ; Not_NFKC                       # 5.2        SQUARED LATIN CAPITAL LETTER W
+1F147..1F149  ; Not_NFKC                       # 6.0    [3] SQUARED LATIN CAPITAL LETTER X..SQUARED LATIN CAPITAL LETTER Z
+1F14A..1F14E  ; Not_NFKC                       # 5.2    [5] SQUARED HV..SQUARED PPV
+1F14F         ; Not_NFKC                       # 6.0        SQUARED WC
+1F16A..1F16B  ; Not_NFKC                       # 6.1    [2] RAISED MC SIGN..RAISED MD SIGN
+1F16C         ; Not_NFKC                       # 12.0       RAISED MR SIGN
+1F190         ; Not_NFKC                       # 5.2        SQUARE DJ
+1F200         ; Not_NFKC                       # 5.2        SQUARE HIRAGANA HOKA
+1F201..1F202  ; Not_NFKC                       # 6.0    [2] SQUARED KATAKANA KOKO..SQUARED KATAKANA SA
+1F210..1F231  ; Not_NFKC                       # 5.2   [34] SQUARED CJK UNIFIED IDEOGRAPH-624B..SQUARED CJK UNIFIED IDEOGRAPH-6253
+1F232..1F23A  ; Not_NFKC                       # 6.0    [9] SQUARED CJK UNIFIED IDEOGRAPH-7981..SQUARED CJK UNIFIED IDEOGRAPH-55B6
+1F23B         ; Not_NFKC                       # 9.0        SQUARED CJK UNIFIED IDEOGRAPH-914D
+1F240..1F248  ; Not_NFKC                       # 5.2    [9] TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-672C..TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-6557
+1F250..1F251  ; Not_NFKC                       # 6.0    [2] CIRCLED IDEOGRAPH ADVANTAGE..CIRCLED IDEOGRAPH ACCEPT
+1FBF0..1FBF9  ; Not_NFKC                       # 13.0  [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE
+2F800..2FA1D  ; Not_NFKC                       # 3.1  [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D
+
+# Total code points: 4958
+
+#	Identifier_Type:	Default_Ignorable
+
+00AD          ; Default_Ignorable              # 1.1        SOFT HYPHEN
+034F          ; Default_Ignorable              # 3.2        COMBINING GRAPHEME JOINER
+061C          ; Default_Ignorable              # 6.3        ARABIC LETTER MARK
+115F..1160    ; Default_Ignorable              # 1.1    [2] HANGUL CHOSEONG FILLER..HANGUL JUNGSEONG FILLER
+17B4..17B5    ; Default_Ignorable              # 3.0    [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA
+180B..180D    ; Default_Ignorable              # 3.0    [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE
+180E          ; Default_Ignorable              # 3.0        MONGOLIAN VOWEL SEPARATOR
+180F          ; Default_Ignorable              # 14.0       MONGOLIAN FREE VARIATION SELECTOR FOUR
+200B..200F    ; Default_Ignorable              # 1.1    [5] ZERO WIDTH SPACE..RIGHT-TO-LEFT MARK
+202A..202E    ; Default_Ignorable              # 1.1    [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE
+2060..2063    ; Default_Ignorable              # 3.2    [4] WORD JOINER..INVISIBLE SEPARATOR
+2064          ; Default_Ignorable              # 5.1        INVISIBLE PLUS
+2066..2069    ; Default_Ignorable              # 6.3    [4] LEFT-TO-RIGHT ISOLATE..POP DIRECTIONAL ISOLATE
+3164          ; Default_Ignorable              # 1.1        HANGUL FILLER
+FE00..FE0F    ; Default_Ignorable              # 3.2   [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16
+FEFF          ; Default_Ignorable              # 1.1        ZERO WIDTH NO-BREAK SPACE
+FFA0          ; Default_Ignorable              # 1.1        HALFWIDTH HANGUL FILLER
+1BCA0..1BCA3  ; Default_Ignorable              # 7.0    [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP
+1D173..1D17A  ; Default_Ignorable              # 3.1    [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE
+E0020..E007F  ; Default_Ignorable              # 3.1   [96] TAG SPACE..CANCEL TAG
+E0100..E01EF  ; Default_Ignorable              # 4.0  [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256
+
+# Total code points: 398
+
+#	Identifier_Type:	Deprecated
+
+0149          ; Deprecated                     # 1.1        LATIN SMALL LETTER N PRECEDED BY APOSTROPHE
+0673          ; Deprecated                     # 1.1        ARABIC LETTER ALEF WITH WAVY HAMZA BELOW
+0F77          ; Deprecated                     # 2.0        TIBETAN VOWEL SIGN VOCALIC RR
+0F79          ; Deprecated                     # 2.0        TIBETAN VOWEL SIGN VOCALIC LL
+17A3..17A4    ; Deprecated                     # 3.0    [2] KHMER INDEPENDENT VOWEL QAQ..KHMER INDEPENDENT VOWEL QAA
+206A..206F    ; Deprecated                     # 1.1    [6] INHIBIT SYMMETRIC SWAPPING..NOMINAL DIGIT SHAPES
+2329..232A    ; Deprecated                     # 1.1    [2] LEFT-POINTING ANGLE BRACKET..RIGHT-POINTING ANGLE BRACKET
+E0001         ; Deprecated                     # 3.1        LANGUAGE TAG
+
+# Total code points: 15
diff --git a/lib/elixir/unicode/PropList.txt b/lib/elixir/unicode/PropList.txt
new file mode 100644
index 00000000000..e64b4224d72
--- /dev/null
+++ b/lib/elixir/unicode/PropList.txt
@@ -0,0 +1,1944 @@
+# PropList-17.0.0.txt
+# Date: 2025-06-30, 06:19:01 GMT
+# © 2025 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use and license, see https://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+#   For documentation, see https://www.unicode.org/reports/tr44/
+
+# ================================================
+
+0009..000D    ; White_Space # Cc   [5] <control-0009>..<control-000D>
+0020          ; White_Space # Zs       SPACE
+0085          ; White_Space # Cc       <control-0085>
+00A0          ; White_Space # Zs       NO-BREAK SPACE
+1680          ; White_Space # Zs       OGHAM SPACE MARK
+2000..200A    ; White_Space # Zs  [11] EN QUAD..HAIR SPACE
+2028          ; White_Space # Zl       LINE SEPARATOR
+2029          ; White_Space # Zp       PARAGRAPH SEPARATOR
+202F          ; White_Space # Zs       NARROW NO-BREAK SPACE
+205F          ; White_Space # Zs       MEDIUM MATHEMATICAL SPACE
+3000          ; White_Space # Zs       IDEOGRAPHIC SPACE
+
+# Total code points: 25
+
+# ================================================
+
+061C          ; Bidi_Control # Cf       ARABIC LETTER MARK
+200E..200F    ; Bidi_Control # Cf   [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT MARK
+202A..202E    ; Bidi_Control # Cf   [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE
+2066..2069    ; Bidi_Control # Cf   [4] LEFT-TO-RIGHT ISOLATE..POP DIRECTIONAL ISOLATE
+
+# Total code points: 12
+
+# ================================================
+
+200C..200D    ; Join_Control # Cf   [2] ZERO WIDTH NON-JOINER..ZERO WIDTH JOINER
+
+# Total code points: 2
+
+# ================================================
+
+002D          ; Dash # Pd       HYPHEN-MINUS
+058A          ; Dash # Pd       ARMENIAN HYPHEN
+05BE          ; Dash # Pd       HEBREW PUNCTUATION MAQAF
+1400          ; Dash # Pd       CANADIAN SYLLABICS HYPHEN
+1806          ; Dash # Pd       MONGOLIAN TODO SOFT HYPHEN
+2010..2015    ; Dash # Pd   [6] HYPHEN..HORIZONTAL BAR
+2053          ; Dash # Po       SWUNG DASH
+207B          ; Dash # Sm       SUPERSCRIPT MINUS
+208B          ; Dash # Sm       SUBSCRIPT MINUS
+2212          ; Dash # Sm       MINUS SIGN
+2E17          ; Dash # Pd       DOUBLE OBLIQUE HYPHEN
+2E1A          ; Dash # Pd       HYPHEN WITH DIAERESIS
+2E3A..2E3B    ; Dash # Pd   [2] TWO-EM DASH..THREE-EM DASH
+2E40          ; Dash # Pd       DOUBLE HYPHEN
+2E5D          ; Dash # Pd       OBLIQUE HYPHEN
+301C          ; Dash # Pd       WAVE DASH
+3030          ; Dash # Pd       WAVY DASH
+30A0          ; Dash # Pd       KATAKANA-HIRAGANA DOUBLE HYPHEN
+FE31..FE32    ; Dash # Pd   [2] PRESENTATION FORM FOR VERTICAL EM DASH..PRESENTATION FORM FOR VERTICAL EN DASH
+FE58          ; Dash # Pd       SMALL EM DASH
+FE63          ; Dash # Pd       SMALL HYPHEN-MINUS
+FF0D          ; Dash # Pd       FULLWIDTH HYPHEN-MINUS
+10D6E         ; Dash # Pd       GARAY HYPHEN
+10EAD         ; Dash # Pd       YEZIDI HYPHENATION MARK
+
+# Total code points: 31
+
+# ================================================
+
+002D          ; Hyphen # Pd       HYPHEN-MINUS
+00AD          ; Hyphen # Cf       SOFT HYPHEN
+058A          ; Hyphen # Pd       ARMENIAN HYPHEN
+1806          ; Hyphen # Pd       MONGOLIAN TODO SOFT HYPHEN
+2010..2011    ; Hyphen # Pd   [2] HYPHEN..NON-BREAKING HYPHEN
+2E17          ; Hyphen # Pd       DOUBLE OBLIQUE HYPHEN
+30FB          ; Hyphen # Po       KATAKANA MIDDLE DOT
+FE63          ; Hyphen # Pd       SMALL HYPHEN-MINUS
+FF0D          ; Hyphen # Pd       FULLWIDTH HYPHEN-MINUS
+FF65          ; Hyphen # Po       HALFWIDTH KATAKANA MIDDLE DOT
+
+# Total code points: 11
+
+# ================================================
+
+0022          ; Quotation_Mark # Po       QUOTATION MARK
+0027          ; Quotation_Mark # Po       APOSTROPHE
+00AB          ; Quotation_Mark # Pi       LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+00BB          ; Quotation_Mark # Pf       RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+2018          ; Quotation_Mark # Pi       LEFT SINGLE QUOTATION MARK
+2019          ; Quotation_Mark # Pf       RIGHT SINGLE QUOTATION MARK
+201A          ; Quotation_Mark # Ps       SINGLE LOW-9 QUOTATION MARK
+201B..201C    ; Quotation_Mark # Pi   [2] SINGLE HIGH-REVERSED-9 QUOTATION MARK..LEFT DOUBLE QUOTATION MARK
+201D          ; Quotation_Mark # Pf       RIGHT DOUBLE QUOTATION MARK
+201E          ; Quotation_Mark # Ps       DOUBLE LOW-9 QUOTATION MARK
+201F          ; Quotation_Mark # Pi       DOUBLE HIGH-REVERSED-9 QUOTATION MARK
+2039          ; Quotation_Mark # Pi       SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+203A          ; Quotation_Mark # Pf       SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+2E42          ; Quotation_Mark # Ps       DOUBLE LOW-REVERSED-9 QUOTATION MARK
+300C          ; Quotation_Mark # Ps       LEFT CORNER BRACKET
+300D          ; Quotation_Mark # Pe       RIGHT CORNER BRACKET
+300E          ; Quotation_Mark # Ps       LEFT WHITE CORNER BRACKET
+300F          ; Quotation_Mark # Pe       RIGHT WHITE CORNER BRACKET
+301D          ; Quotation_Mark # Ps       REVERSED DOUBLE PRIME QUOTATION MARK
+301E..301F    ; Quotation_Mark # Pe   [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK
+FE41          ; Quotation_Mark # Ps       PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET
+FE42          ; Quotation_Mark # Pe       PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET
+FE43          ; Quotation_Mark # Ps       PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET
+FE44          ; Quotation_Mark # Pe       PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET
+FF02          ; Quotation_Mark # Po       FULLWIDTH QUOTATION MARK
+FF07          ; Quotation_Mark # Po       FULLWIDTH APOSTROPHE
+FF62          ; Quotation_Mark # Ps       HALFWIDTH LEFT CORNER BRACKET
+FF63          ; Quotation_Mark # Pe       HALFWIDTH RIGHT CORNER BRACKET
+
+# Total code points: 30
+
+# ================================================
+
+0021          ; Terminal_Punctuation # Po       EXCLAMATION MARK
+002C          ; Terminal_Punctuation # Po       COMMA
+002E          ; Terminal_Punctuation # Po       FULL STOP
+003A..003B    ; Terminal_Punctuation # Po   [2] COLON..SEMICOLON
+003F          ; Terminal_Punctuation # Po       QUESTION MARK
+037E          ; Terminal_Punctuation # Po       GREEK QUESTION MARK
+0387          ; Terminal_Punctuation # Po       GREEK ANO TELEIA
+0589          ; Terminal_Punctuation # Po       ARMENIAN FULL STOP
+05C3          ; Terminal_Punctuation # Po       HEBREW PUNCTUATION SOF PASUQ
+060C          ; Terminal_Punctuation # Po       ARABIC COMMA
+061B          ; Terminal_Punctuation # Po       ARABIC SEMICOLON
+061D..061F    ; Terminal_Punctuation # Po   [3] ARABIC END OF TEXT MARK..ARABIC QUESTION MARK
+06D4          ; Terminal_Punctuation # Po       ARABIC FULL STOP
+0700..070A    ; Terminal_Punctuation # Po  [11] SYRIAC END OF PARAGRAPH..SYRIAC CONTRACTION
+070C          ; Terminal_Punctuation # Po       SYRIAC HARKLEAN METOBELUS
+07F8..07F9    ; Terminal_Punctuation # Po   [2] NKO COMMA..NKO EXCLAMATION MARK
+0830..0835    ; Terminal_Punctuation # Po   [6] SAMARITAN PUNCTUATION NEQUDAA..SAMARITAN PUNCTUATION SHIYYAALAA
+0837..083E    ; Terminal_Punctuation # Po   [8] SAMARITAN PUNCTUATION MELODIC QITSA..SAMARITAN PUNCTUATION ANNAAU
+085E          ; Terminal_Punctuation # Po       MANDAIC PUNCTUATION
+0964..0965    ; Terminal_Punctuation # Po   [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA
+0E5A..0E5B    ; Terminal_Punctuation # Po   [2] THAI CHARACTER ANGKHANKHU..THAI CHARACTER KHOMUT
+0F08          ; Terminal_Punctuation # Po       TIBETAN MARK SBRUL SHAD
+0F0D..0F12    ; Terminal_Punctuation # Po   [6] TIBETAN MARK SHAD..TIBETAN MARK RGYA GRAM SHAD
+104A..104B    ; Terminal_Punctuation # Po   [2] MYANMAR SIGN LITTLE SECTION..MYANMAR SIGN SECTION
+1361..1368    ; Terminal_Punctuation # Po   [8] ETHIOPIC WORDSPACE..ETHIOPIC PARAGRAPH SEPARATOR
+166E          ; Terminal_Punctuation # Po       CANADIAN SYLLABICS FULL STOP
+16EB..16ED    ; Terminal_Punctuation # Po   [3] RUNIC SINGLE PUNCTUATION..RUNIC CROSS PUNCTUATION
+1735..1736    ; Terminal_Punctuation # Po   [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION
+17D4..17D6    ; Terminal_Punctuation # Po   [3] KHMER SIGN KHAN..KHMER SIGN CAMNUC PII KUUH
+17DA          ; Terminal_Punctuation # Po       KHMER SIGN KOOMUUT
+1802..1805    ; Terminal_Punctuation # Po   [4] MONGOLIAN COMMA..MONGOLIAN FOUR DOTS
+1808..1809    ; Terminal_Punctuation # Po   [2] MONGOLIAN MANCHU COMMA..MONGOLIAN MANCHU FULL STOP
+1944..1945    ; Terminal_Punctuation # Po   [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK
+1AA8..1AAB    ; Terminal_Punctuation # Po   [4] TAI THAM SIGN KAAN..TAI THAM SIGN SATKAANKUU
+1B4E..1B4F    ; Terminal_Punctuation # Po   [2] BALINESE INVERTED CARIK SIKI..BALINESE INVERTED CARIK PAREREN
+1B5A..1B5B    ; Terminal_Punctuation # Po   [2] BALINESE PANTI..BALINESE PAMADA
+1B5D..1B5F    ; Terminal_Punctuation # Po   [3] BALINESE CARIK PAMUNGKAH..BALINESE CARIK PAREREN
+1B7D..1B7F    ; Terminal_Punctuation # Po   [3] BALINESE PANTI LANTANG..BALINESE PANTI BAWAK
+1C3B..1C3F    ; Terminal_Punctuation # Po   [5] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION TSHOOK
+1C7E..1C7F    ; Terminal_Punctuation # Po   [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD
+2024          ; Terminal_Punctuation # Po       ONE DOT LEADER
+203C..203D    ; Terminal_Punctuation # Po   [2] DOUBLE EXCLAMATION MARK..INTERROBANG
+2047..2049    ; Terminal_Punctuation # Po   [3] DOUBLE QUESTION MARK..EXCLAMATION QUESTION MARK
+2CF9..2CFB    ; Terminal_Punctuation # Po   [3] COPTIC OLD NUBIAN FULL STOP..COPTIC OLD NUBIAN INDIRECT QUESTION MARK
+2E2E          ; Terminal_Punctuation # Po       REVERSED QUESTION MARK
+2E3C          ; Terminal_Punctuation # Po       STENOGRAPHIC FULL STOP
+2E41          ; Terminal_Punctuation # Po       REVERSED COMMA
+2E4C          ; Terminal_Punctuation # Po       MEDIEVAL COMMA
+2E4E..2E4F    ; Terminal_Punctuation # Po   [2] PUNCTUS ELEVATUS MARK..CORNISH VERSE DIVIDER
+2E53..2E54    ; Terminal_Punctuation # Po   [2] MEDIEVAL EXCLAMATION MARK..MEDIEVAL QUESTION MARK
+3001..3002    ; Terminal_Punctuation # Po   [2] IDEOGRAPHIC COMMA..IDEOGRAPHIC FULL STOP
+A4FE..A4FF    ; Terminal_Punctuation # Po   [2] LISU PUNCTUATION COMMA..LISU PUNCTUATION FULL STOP
+A60D..A60F    ; Terminal_Punctuation # Po   [3] VAI COMMA..VAI QUESTION MARK
+A6F3..A6F7    ; Terminal_Punctuation # Po   [5] BAMUM FULL STOP..BAMUM QUESTION MARK
+A876..A877    ; Terminal_Punctuation # Po   [2] PHAGS-PA MARK SHAD..PHAGS-PA MARK DOUBLE SHAD
+A8CE..A8CF    ; Terminal_Punctuation # Po   [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA
+A92F          ; Terminal_Punctuation # Po       KAYAH LI SIGN SHYA
+A9C7..A9C9    ; Terminal_Punctuation # Po   [3] JAVANESE PADA PANGKAT..JAVANESE PADA LUNGSI
+AA5D..AA5F    ; Terminal_Punctuation # Po   [3] CHAM PUNCTUATION DANDA..CHAM PUNCTUATION TRIPLE DANDA
+AADF          ; Terminal_Punctuation # Po       TAI VIET SYMBOL KOI KOI
+AAF0..AAF1    ; Terminal_Punctuation # Po   [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM
+ABEB          ; Terminal_Punctuation # Po       MEETEI MAYEK CHEIKHEI
+FE12          ; Terminal_Punctuation # Po       PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC FULL STOP
+FE15..FE16    ; Terminal_Punctuation # Po   [2] PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK..PRESENTATION FORM FOR VERTICAL QUESTION MARK
+FE50..FE52    ; Terminal_Punctuation # Po   [3] SMALL COMMA..SMALL FULL STOP
+FE54..FE57    ; Terminal_Punctuation # Po   [4] SMALL SEMICOLON..SMALL EXCLAMATION MARK
+FF01          ; Terminal_Punctuation # Po       FULLWIDTH EXCLAMATION MARK
+FF0C          ; Terminal_Punctuation # Po       FULLWIDTH COMMA
+FF0E          ; Terminal_Punctuation # Po       FULLWIDTH FULL STOP
+FF1A..FF1B    ; Terminal_Punctuation # Po   [2] FULLWIDTH COLON..FULLWIDTH SEMICOLON
+FF1F          ; Terminal_Punctuation # Po       FULLWIDTH QUESTION MARK
+FF61          ; Terminal_Punctuation # Po       HALFWIDTH IDEOGRAPHIC FULL STOP
+FF64          ; Terminal_Punctuation # Po       HALFWIDTH IDEOGRAPHIC COMMA
+1039F         ; Terminal_Punctuation # Po       UGARITIC WORD DIVIDER
+103D0         ; Terminal_Punctuation # Po       OLD PERSIAN WORD DIVIDER
+10857         ; Terminal_Punctuation # Po       IMPERIAL ARAMAIC SECTION SIGN
+1091F         ; Terminal_Punctuation # Po       PHOENICIAN WORD SEPARATOR
+10A56..10A57  ; Terminal_Punctuation # Po   [2] KHAROSHTHI PUNCTUATION DANDA..KHAROSHTHI PUNCTUATION DOUBLE DANDA
+10AF0..10AF5  ; Terminal_Punctuation # Po   [6] MANICHAEAN PUNCTUATION STAR..MANICHAEAN PUNCTUATION TWO DOTS
+10B3A..10B3F  ; Terminal_Punctuation # Po   [6] TINY TWO DOTS OVER ONE DOT PUNCTUATION..LARGE ONE RING OVER TWO RINGS PUNCTUATION
+10B99..10B9C  ; Terminal_Punctuation # Po   [4] PSALTER PAHLAVI SECTION MARK..PSALTER PAHLAVI FOUR DOTS WITH DOT
+10F55..10F59  ; Terminal_Punctuation # Po   [5] SOGDIAN PUNCTUATION TWO VERTICAL BARS..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT
+10F86..10F89  ; Terminal_Punctuation # Po   [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS
+11047..1104D  ; Terminal_Punctuation # Po   [7] BRAHMI DANDA..BRAHMI PUNCTUATION LOTUS
+110BE..110C1  ; Terminal_Punctuation # Po   [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA
+11141..11143  ; Terminal_Punctuation # Po   [3] CHAKMA DANDA..CHAKMA QUESTION MARK
+111C5..111C6  ; Terminal_Punctuation # Po   [2] SHARADA DANDA..SHARADA DOUBLE DANDA
+111CD         ; Terminal_Punctuation # Po       SHARADA SUTRA MARK
+111DE..111DF  ; Terminal_Punctuation # Po   [2] SHARADA SECTION MARK-1..SHARADA SECTION MARK-2
+11238..1123C  ; Terminal_Punctuation # Po   [5] KHOJKI DANDA..KHOJKI DOUBLE SECTION MARK
+112A9         ; Terminal_Punctuation # Po       MULTANI SECTION MARK
+113D4..113D5  ; Terminal_Punctuation # Po   [2] TULU-TIGALARI DANDA..TULU-TIGALARI DOUBLE DANDA
+1144B..1144D  ; Terminal_Punctuation # Po   [3] NEWA DANDA..NEWA COMMA
+1145A..1145B  ; Terminal_Punctuation # Po   [2] NEWA DOUBLE COMMA..NEWA PLACEHOLDER MARK
+115C2..115C5  ; Terminal_Punctuation # Po   [4] SIDDHAM DANDA..SIDDHAM SEPARATOR BAR
+115C9..115D7  ; Terminal_Punctuation # Po  [15] SIDDHAM END OF TEXT MARK..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES
+11641..11642  ; Terminal_Punctuation # Po   [2] MODI DANDA..MODI DOUBLE DANDA
+1173C..1173E  ; Terminal_Punctuation # Po   [3] AHOM SIGN SMALL SECTION..AHOM SIGN RULAI
+11944         ; Terminal_Punctuation # Po       DIVES AKURU DOUBLE DANDA
+11946         ; Terminal_Punctuation # Po       DIVES AKURU END OF TEXT MARK
+11A42..11A43  ; Terminal_Punctuation # Po   [2] ZANABAZAR SQUARE MARK SHAD..ZANABAZAR SQUARE MARK DOUBLE SHAD
+11A9B..11A9C  ; Terminal_Punctuation # Po   [2] SOYOMBO MARK SHAD..SOYOMBO MARK DOUBLE SHAD
+11AA1..11AA2  ; Terminal_Punctuation # Po   [2] SOYOMBO TERMINAL MARK-1..SOYOMBO TERMINAL MARK-2
+11C41..11C43  ; Terminal_Punctuation # Po   [3] BHAIKSUKI DANDA..BHAIKSUKI WORD SEPARATOR
+11C71         ; Terminal_Punctuation # Po       MARCHEN MARK SHAD
+11EF7..11EF8  ; Terminal_Punctuation # Po   [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION
+11F43..11F44  ; Terminal_Punctuation # Po   [2] KAWI DANDA..KAWI DOUBLE DANDA
+12470..12474  ; Terminal_Punctuation # Po   [5] CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER..CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON
+16A6E..16A6F  ; Terminal_Punctuation # Po   [2] MRO DANDA..MRO DOUBLE DANDA
+16AF5         ; Terminal_Punctuation # Po       BASSA VAH FULL STOP
+16B37..16B39  ; Terminal_Punctuation # Po   [3] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN CIM CHEEM
+16B44         ; Terminal_Punctuation # Po       PAHAWH HMONG SIGN XAUS
+16D6E..16D6F  ; Terminal_Punctuation # Po   [2] KIRAT RAI DANDA..KIRAT RAI DOUBLE DANDA
+16E97..16E98  ; Terminal_Punctuation # Po   [2] MEDEFAIDRIN COMMA..MEDEFAIDRIN FULL STOP
+1BC9F         ; Terminal_Punctuation # Po       DUPLOYAN PUNCTUATION CHINOOK FULL STOP
+1DA87..1DA8A  ; Terminal_Punctuation # Po   [4] SIGNWRITING COMMA..SIGNWRITING COLON
+
+# Total code points: 291
+
+# ================================================
+
+005E          ; Other_Math # Sk       CIRCUMFLEX ACCENT
+03D0..03D2    ; Other_Math # L&   [3] GREEK BETA SYMBOL..GREEK UPSILON WITH HOOK SYMBOL
+03D5          ; Other_Math # L&       GREEK PHI SYMBOL
+03F0..03F1    ; Other_Math # L&   [2] GREEK KAPPA SYMBOL..GREEK RHO SYMBOL
+03F4..03F5    ; Other_Math # L&   [2] GREEK CAPITAL THETA SYMBOL..GREEK LUNATE EPSILON SYMBOL
+2016          ; Other_Math # Po       DOUBLE VERTICAL LINE
+2032..2034    ; Other_Math # Po   [3] PRIME..TRIPLE PRIME
+2040          ; Other_Math # Pc       CHARACTER TIE
+2061..2064    ; Other_Math # Cf   [4] FUNCTION APPLICATION..INVISIBLE PLUS
+207D          ; Other_Math # Ps       SUPERSCRIPT LEFT PARENTHESIS
+207E          ; Other_Math # Pe       SUPERSCRIPT RIGHT PARENTHESIS
+208D          ; Other_Math # Ps       SUBSCRIPT LEFT PARENTHESIS
+208E          ; Other_Math # Pe       SUBSCRIPT RIGHT PARENTHESIS
+20D0..20DC    ; Other_Math # Mn  [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE
+20E1          ; Other_Math # Mn       COMBINING LEFT RIGHT ARROW ABOVE
+20E5..20E6    ; Other_Math # Mn   [2] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING DOUBLE VERTICAL STROKE OVERLAY
+20EB..20EF    ; Other_Math # Mn   [5] COMBINING LONG DOUBLE SOLIDUS OVERLAY..COMBINING RIGHT ARROW BELOW
+2102          ; Other_Math # L&       DOUBLE-STRUCK CAPITAL C
+2107          ; Other_Math # L&       EULER CONSTANT
+210A..2113    ; Other_Math # L&  [10] SCRIPT SMALL G..SCRIPT SMALL L
+2115          ; Other_Math # L&       DOUBLE-STRUCK CAPITAL N
+2119..211D    ; Other_Math # L&   [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R
+2124          ; Other_Math # L&       DOUBLE-STRUCK CAPITAL Z
+2128          ; Other_Math # L&       BLACK-LETTER CAPITAL Z
+2129          ; Other_Math # So       TURNED GREEK SMALL LETTER IOTA
+212C..212D    ; Other_Math # L&   [2] SCRIPT CAPITAL B..BLACK-LETTER CAPITAL C
+212F..2131    ; Other_Math # L&   [3] SCRIPT SMALL E..SCRIPT CAPITAL F
+2133..2134    ; Other_Math # L&   [2] SCRIPT CAPITAL M..SCRIPT SMALL O
+2135..2138    ; Other_Math # Lo   [4] ALEF SYMBOL..DALET SYMBOL
+213C..213F    ; Other_Math # L&   [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STRUCK CAPITAL PI
+2145..2149    ; Other_Math # L&   [5] DOUBLE-STRUCK ITALIC CAPITAL D..DOUBLE-STRUCK ITALIC SMALL J
+2195..2199    ; Other_Math # So   [5] UP DOWN ARROW..SOUTH WEST ARROW
+219C..219F    ; Other_Math # So   [4] LEFTWARDS WAVE ARROW..UPWARDS TWO HEADED ARROW
+21A1..21A2    ; Other_Math # So   [2] DOWNWARDS TWO HEADED ARROW..LEFTWARDS ARROW WITH TAIL
+21A4..21A5    ; Other_Math # So   [2] LEFTWARDS ARROW FROM BAR..UPWARDS ARROW FROM BAR
+21A7          ; Other_Math # So       DOWNWARDS ARROW FROM BAR
+21A9..21AD    ; Other_Math # So   [5] LEFTWARDS ARROW WITH HOOK..LEFT RIGHT WAVE ARROW
+21B0..21B1    ; Other_Math # So   [2] UPWARDS ARROW WITH TIP LEFTWARDS..UPWARDS ARROW WITH TIP RIGHTWARDS
+21B6..21B7    ; Other_Math # So   [2] ANTICLOCKWISE TOP SEMICIRCLE ARROW..CLOCKWISE TOP SEMICIRCLE ARROW
+21BC..21CD    ; Other_Math # So  [18] LEFTWARDS HARPOON WITH BARB UPWARDS..LEFTWARDS DOUBLE ARROW WITH STROKE
+21D0..21D1    ; Other_Math # So   [2] LEFTWARDS DOUBLE ARROW..UPWARDS DOUBLE ARROW
+21D3          ; Other_Math # So       DOWNWARDS DOUBLE ARROW
+21D5..21DB    ; Other_Math # So   [7] UP DOWN DOUBLE ARROW..RIGHTWARDS TRIPLE ARROW
+21DD          ; Other_Math # So       RIGHTWARDS SQUIGGLE ARROW
+21E4..21E5    ; Other_Math # So   [2] LEFTWARDS ARROW TO BAR..RIGHTWARDS ARROW TO BAR
+2308          ; Other_Math # Ps       LEFT CEILING
+2309          ; Other_Math # Pe       RIGHT CEILING
+230A          ; Other_Math # Ps       LEFT FLOOR
+230B          ; Other_Math # Pe       RIGHT FLOOR
+23B4..23B5    ; Other_Math # So   [2] TOP SQUARE BRACKET..BOTTOM SQUARE BRACKET
+23B7          ; Other_Math # So       RADICAL SYMBOL BOTTOM
+23D0          ; Other_Math # So       VERTICAL LINE EXTENSION
+23E2          ; Other_Math # So       WHITE TRAPEZIUM
+25A0..25A1    ; Other_Math # So   [2] BLACK SQUARE..WHITE SQUARE
+25AE..25B6    ; Other_Math # So   [9] BLACK VERTICAL RECTANGLE..BLACK RIGHT-POINTING TRIANGLE
+25BC..25C0    ; Other_Math # So   [5] BLACK DOWN-POINTING TRIANGLE..BLACK LEFT-POINTING TRIANGLE
+25C6..25C7    ; Other_Math # So   [2] BLACK DIAMOND..WHITE DIAMOND
+25CA..25CB    ; Other_Math # So   [2] LOZENGE..WHITE CIRCLE
+25CF..25D3    ; Other_Math # So   [5] BLACK CIRCLE..CIRCLE WITH UPPER HALF BLACK
+25E2          ; Other_Math # So       BLACK LOWER RIGHT TRIANGLE
+25E4          ; Other_Math # So       BLACK UPPER LEFT TRIANGLE
+25E7..25EC    ; Other_Math # So   [6] SQUARE WITH LEFT HALF BLACK..WHITE UP-POINTING TRIANGLE WITH DOT
+2605..2606    ; Other_Math # So   [2] BLACK STAR..WHITE STAR
+2640          ; Other_Math # So       FEMALE SIGN
+2642          ; Other_Math # So       MALE SIGN
+2660..2663    ; Other_Math # So   [4] BLACK SPADE SUIT..BLACK CLUB SUIT
+266D..266E    ; Other_Math # So   [2] MUSIC FLAT SIGN..MUSIC NATURAL SIGN
+27C5          ; Other_Math # Ps       LEFT S-SHAPED BAG DELIMITER
+27C6          ; Other_Math # Pe       RIGHT S-SHAPED BAG DELIMITER
+27E6          ; Other_Math # Ps       MATHEMATICAL LEFT WHITE SQUARE BRACKET
+27E7          ; Other_Math # Pe       MATHEMATICAL RIGHT WHITE SQUARE BRACKET
+27E8          ; Other_Math # Ps       MATHEMATICAL LEFT ANGLE BRACKET
+27E9          ; Other_Math # Pe       MATHEMATICAL RIGHT ANGLE BRACKET
+27EA          ; Other_Math # Ps       MATHEMATICAL LEFT DOUBLE ANGLE BRACKET
+27EB          ; Other_Math # Pe       MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET
+27EC          ; Other_Math # Ps       MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET
+27ED          ; Other_Math # Pe       MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET
+27EE          ; Other_Math # Ps       MATHEMATICAL LEFT FLATTENED PARENTHESIS
+27EF          ; Other_Math # Pe       MATHEMATICAL RIGHT FLATTENED PARENTHESIS
+2983          ; Other_Math # Ps       LEFT WHITE CURLY BRACKET
+2984          ; Other_Math # Pe       RIGHT WHITE CURLY BRACKET
+2985          ; Other_Math # Ps       LEFT WHITE PARENTHESIS
+2986          ; Other_Math # Pe       RIGHT WHITE PARENTHESIS
+2987          ; Other_Math # Ps       Z NOTATION LEFT IMAGE BRACKET
+2988          ; Other_Math # Pe       Z NOTATION RIGHT IMAGE BRACKET
+2989          ; Other_Math # Ps       Z NOTATION LEFT BINDING BRACKET
+298A          ; Other_Math # Pe       Z NOTATION RIGHT BINDING BRACKET
+298B          ; Other_Math # Ps       LEFT SQUARE BRACKET WITH UNDERBAR
+298C          ; Other_Math # Pe       RIGHT SQUARE BRACKET WITH UNDERBAR
+298D          ; Other_Math # Ps       LEFT SQUARE BRACKET WITH TICK IN TOP CORNER
+298E          ; Other_Math # Pe       RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+298F          ; Other_Math # Ps       LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+2990          ; Other_Math # Pe       RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER
+2991          ; Other_Math # Ps       LEFT ANGLE BRACKET WITH DOT
+2992          ; Other_Math # Pe       RIGHT ANGLE BRACKET WITH DOT
+2993          ; Other_Math # Ps       LEFT ARC LESS-THAN BRACKET
+2994          ; Other_Math # Pe       RIGHT ARC GREATER-THAN BRACKET
+2995          ; Other_Math # Ps       DOUBLE LEFT ARC GREATER-THAN BRACKET
+2996          ; Other_Math # Pe       DOUBLE RIGHT ARC LESS-THAN BRACKET
+2997          ; Other_Math # Ps       LEFT BLACK TORTOISE SHELL BRACKET
+2998          ; Other_Math # Pe       RIGHT BLACK TORTOISE SHELL BRACKET
+29D8          ; Other_Math # Ps       LEFT WIGGLY FENCE
+29D9          ; Other_Math # Pe       RIGHT WIGGLY FENCE
+29DA          ; Other_Math # Ps       LEFT DOUBLE WIGGLY FENCE
+29DB          ; Other_Math # Pe       RIGHT DOUBLE WIGGLY FENCE
+29FC          ; Other_Math # Ps       LEFT-POINTING CURVED ANGLE BRACKET
+29FD          ; Other_Math # Pe       RIGHT-POINTING CURVED ANGLE BRACKET
+FE61          ; Other_Math # Po       SMALL ASTERISK
+FE63          ; Other_Math # Pd       SMALL HYPHEN-MINUS
+FE68          ; Other_Math # Po       SMALL REVERSE SOLIDUS
+FF3C          ; Other_Math # Po       FULLWIDTH REVERSE SOLIDUS
+FF3E          ; Other_Math # Sk       FULLWIDTH CIRCUMFLEX ACCENT
+1D400..1D454  ; Other_Math # L&  [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G
+1D456..1D49C  ; Other_Math # L&  [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A
+1D49E..1D49F  ; Other_Math # L&   [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D
+1D4A2         ; Other_Math # L&       MATHEMATICAL SCRIPT CAPITAL G
+1D4A5..1D4A6  ; Other_Math # L&   [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K
+1D4A9..1D4AC  ; Other_Math # L&   [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q
+1D4AE..1D4B9  ; Other_Math # L&  [12] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT SMALL D
+1D4BB         ; Other_Math # L&       MATHEMATICAL SCRIPT SMALL F
+1D4BD..1D4C3  ; Other_Math # L&   [7] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL N
+1D4C5..1D505  ; Other_Math # L&  [65] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL FRAKTUR CAPITAL B
+1D507..1D50A  ; Other_Math # L&   [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G
+1D50D..1D514  ; Other_Math # L&   [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q
+1D516..1D51C  ; Other_Math # L&   [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y
+1D51E..1D539  ; Other_Math # L&  [28] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B
+1D53B..1D53E  ; Other_Math # L&   [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G
+1D540..1D544  ; Other_Math # L&   [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M
+1D546         ; Other_Math # L&       MATHEMATICAL DOUBLE-STRUCK CAPITAL O
+1D54A..1D550  ; Other_Math # L&   [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y
+1D552..1D6A5  ; Other_Math # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J
+1D6A8..1D6C0  ; Other_Math # L&  [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA
+1D6C2..1D6DA  ; Other_Math # L&  [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA
+1D6DC..1D6FA  ; Other_Math # L&  [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA
+1D6FC..1D714  ; Other_Math # L&  [25] MATHEMATICAL ITALIC SMALL ALPHA..MATHEMATICAL ITALIC SMALL OMEGA
+1D716..1D734  ; Other_Math # L&  [31] MATHEMATICAL ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD ITALIC CAPITAL OMEGA
+1D736..1D74E  ; Other_Math # L&  [25] MATHEMATICAL BOLD ITALIC SMALL ALPHA..MATHEMATICAL BOLD ITALIC SMALL OMEGA
+1D750..1D76E  ; Other_Math # L&  [31] MATHEMATICAL BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA
+1D770..1D788  ; Other_Math # L&  [25] MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA
+1D78A..1D7A8  ; Other_Math # L&  [31] MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA
+1D7AA..1D7C2  ; Other_Math # L&  [25] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA
+1D7C4..1D7CB  ; Other_Math # L&   [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA
+1D7CE..1D7FF  ; Other_Math # Nd  [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE
+1EE00..1EE03  ; Other_Math # Lo   [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL
+1EE05..1EE1F  ; Other_Math # Lo  [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF
+1EE21..1EE22  ; Other_Math # Lo   [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM
+1EE24         ; Other_Math # Lo       ARABIC MATHEMATICAL INITIAL HEH
+1EE27         ; Other_Math # Lo       ARABIC MATHEMATICAL INITIAL HAH
+1EE29..1EE32  ; Other_Math # Lo  [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF
+1EE34..1EE37  ; Other_Math # Lo   [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH
+1EE39         ; Other_Math # Lo       ARABIC MATHEMATICAL INITIAL DAD
+1EE3B         ; Other_Math # Lo       ARABIC MATHEMATICAL INITIAL GHAIN
+1EE42         ; Other_Math # Lo       ARABIC MATHEMATICAL TAILED JEEM
+1EE47         ; Other_Math # Lo       ARABIC MATHEMATICAL TAILED HAH
+1EE49         ; Other_Math # Lo       ARABIC MATHEMATICAL TAILED YEH
+1EE4B         ; Other_Math # Lo       ARABIC MATHEMATICAL TAILED LAM
+1EE4D..1EE4F  ; Other_Math # Lo   [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN
+1EE51..1EE52  ; Other_Math # Lo   [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF
+1EE54         ; Other_Math # Lo       ARABIC MATHEMATICAL TAILED SHEEN
+1EE57         ; Other_Math # Lo       ARABIC MATHEMATICAL TAILED KHAH
+1EE59         ; Other_Math # Lo       ARABIC MATHEMATICAL TAILED DAD
+1EE5B         ; Other_Math # Lo       ARABIC MATHEMATICAL TAILED GHAIN
+1EE5D         ; Other_Math # Lo       ARABIC MATHEMATICAL TAILED DOTLESS NOON
+1EE5F         ; Other_Math # Lo       ARABIC MATHEMATICAL TAILED DOTLESS QAF
+1EE61..1EE62  ; Other_Math # Lo   [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM
+1EE64         ; Other_Math # Lo       ARABIC MATHEMATICAL STRETCHED HEH
+1EE67..1EE6A  ; Other_Math # Lo   [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF
+1EE6C..1EE72  ; Other_Math # Lo   [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF
+1EE74..1EE77  ; Other_Math # Lo   [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH
+1EE79..1EE7C  ; Other_Math # Lo   [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH
+1EE7E         ; Other_Math # Lo       ARABIC MATHEMATICAL STRETCHED DOTLESS FEH
+1EE80..1EE89  ; Other_Math # Lo  [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH
+1EE8B..1EE9B  ; Other_Math # Lo  [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN
+1EEA1..1EEA3  ; Other_Math # Lo   [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL
+1EEA5..1EEA9  ; Other_Math # Lo   [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH
+1EEAB..1EEBB  ; Other_Math # Lo  [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN
+
+# Total code points: 1362
+
+# ================================================
+
+0030..0039    ; Hex_Digit # Nd  [10] DIGIT ZERO..DIGIT NINE
+0041..0046    ; Hex_Digit # L&   [6] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER F
+0061..0066    ; Hex_Digit # L&   [6] LATIN SMALL LETTER A..LATIN SMALL LETTER F
+FF10..FF19    ; Hex_Digit # Nd  [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE
+FF21..FF26    ; Hex_Digit # L&   [6] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER F
+FF41..FF46    ; Hex_Digit # L&   [6] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN SMALL LETTER F
+
+# Total code points: 44
+
+# ================================================
+
+0030..0039    ; ASCII_Hex_Digit # Nd  [10] DIGIT ZERO..DIGIT NINE
+0041..0046    ; ASCII_Hex_Digit # L&   [6] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER F
+0061..0066    ; ASCII_Hex_Digit # L&   [6] LATIN SMALL LETTER A..LATIN SMALL LETTER F
+
+# Total code points: 22
+
+# ================================================
+
+0345          ; Other_Alphabetic # Mn       COMBINING GREEK YPOGEGRAMMENI
+0363..036F    ; Other_Alphabetic # Mn  [13] COMBINING LATIN SMALL LETTER A..COMBINING LATIN SMALL LETTER X
+05B0..05BD    ; Other_Alphabetic # Mn  [14] HEBREW POINT SHEVA..HEBREW POINT METEG
+05BF          ; Other_Alphabetic # Mn       HEBREW POINT RAFE
+05C1..05C2    ; Other_Alphabetic # Mn   [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT
+05C4..05C5    ; Other_Alphabetic # Mn   [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT
+05C7          ; Other_Alphabetic # Mn       HEBREW POINT QAMATS QATAN
+0610..061A    ; Other_Alphabetic # Mn  [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA
+064B..0657    ; Other_Alphabetic # Mn  [13] ARABIC FATHATAN..ARABIC INVERTED DAMMA
+0659..065F    ; Other_Alphabetic # Mn   [7] ARABIC ZWARAKAY..ARABIC WAVY HAMZA BELOW
+0670          ; Other_Alphabetic # Mn       ARABIC LETTER SUPERSCRIPT ALEF
+06D6..06DC    ; Other_Alphabetic # Mn   [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN
+06E1..06E4    ; Other_Alphabetic # Mn   [4] ARABIC SMALL HIGH DOTLESS HEAD OF KHAH..ARABIC SMALL HIGH MADDA
+06E7..06E8    ; Other_Alphabetic # Mn   [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON
+06ED          ; Other_Alphabetic # Mn       ARABIC SMALL LOW MEEM
+0711          ; Other_Alphabetic # Mn       SYRIAC LETTER SUPERSCRIPT ALAPH
+0730..073F    ; Other_Alphabetic # Mn  [16] SYRIAC PTHAHA ABOVE..SYRIAC RWAHA
+07A6..07B0    ; Other_Alphabetic # Mn  [11] THAANA ABAFILI..THAANA SUKUN
+0816..0817    ; Other_Alphabetic # Mn   [2] SAMARITAN MARK IN..SAMARITAN MARK IN-ALAF
+081B..0823    ; Other_Alphabetic # Mn   [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A
+0825..0827    ; Other_Alphabetic # Mn   [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U
+0829..082C    ; Other_Alphabetic # Mn   [4] SAMARITAN VOWEL SIGN LONG I..SAMARITAN VOWEL SIGN SUKUN
+0897          ; Other_Alphabetic # Mn       ARABIC PEPET
+08D4..08DF    ; Other_Alphabetic # Mn  [12] ARABIC SMALL HIGH WORD AR-RUB..ARABIC SMALL HIGH WORD WAQFA
+08E3..08E9    ; Other_Alphabetic # Mn   [7] ARABIC TURNED DAMMA BELOW..ARABIC CURLY KASRATAN
+08F0..0902    ; Other_Alphabetic # Mn  [19] ARABIC OPEN FATHATAN..DEVANAGARI SIGN ANUSVARA
+0903          ; Other_Alphabetic # Mc       DEVANAGARI SIGN VISARGA
+093A          ; Other_Alphabetic # Mn       DEVANAGARI VOWEL SIGN OE
+093B          ; Other_Alphabetic # Mc       DEVANAGARI VOWEL SIGN OOE
+093E..0940    ; Other_Alphabetic # Mc   [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II
+0941..0948    ; Other_Alphabetic # Mn   [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI
+0949..094C    ; Other_Alphabetic # Mc   [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU
+094E..094F    ; Other_Alphabetic # Mc   [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW
+0955..0957    ; Other_Alphabetic # Mn   [3] DEVANAGARI VOWEL SIGN CANDRA LONG E..DEVANAGARI VOWEL SIGN UUE
+0962..0963    ; Other_Alphabetic # Mn   [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL
+0981          ; Other_Alphabetic # Mn       BENGALI SIGN CANDRABINDU
+0982..0983    ; Other_Alphabetic # Mc   [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA
+09BE..09C0    ; Other_Alphabetic # Mc   [3] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN II
+09C1..09C4    ; Other_Alphabetic # Mn   [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR
+09C7..09C8    ; Other_Alphabetic # Mc   [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI
+09CB..09CC    ; Other_Alphabetic # Mc   [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU
+09D7          ; Other_Alphabetic # Mc       BENGALI AU LENGTH MARK
+09E2..09E3    ; Other_Alphabetic # Mn   [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL
+0A01..0A02    ; Other_Alphabetic # Mn   [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI
+0A03          ; Other_Alphabetic # Mc       GURMUKHI SIGN VISARGA
+0A3E..0A40    ; Other_Alphabetic # Mc   [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II
+0A41..0A42    ; Other_Alphabetic # Mn   [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU
+0A47..0A48    ; Other_Alphabetic # Mn   [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI
+0A4B..0A4C    ; Other_Alphabetic # Mn   [2] GURMUKHI VOWEL SIGN OO..GURMUKHI VOWEL SIGN AU
+0A51          ; Other_Alphabetic # Mn       GURMUKHI SIGN UDAAT
+0A70..0A71    ; Other_Alphabetic # Mn   [2] GURMUKHI TIPPI..GURMUKHI ADDAK
+0A75          ; Other_Alphabetic # Mn       GURMUKHI SIGN YAKASH
+0A81..0A82    ; Other_Alphabetic # Mn   [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA
+0A83          ; Other_Alphabetic # Mc       GUJARATI SIGN VISARGA
+0ABE..0AC0    ; Other_Alphabetic # Mc   [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II
+0AC1..0AC5    ; Other_Alphabetic # Mn   [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E
+0AC7..0AC8    ; Other_Alphabetic # Mn   [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI
+0AC9          ; Other_Alphabetic # Mc       GUJARATI VOWEL SIGN CANDRA O
+0ACB..0ACC    ; Other_Alphabetic # Mc   [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU
+0AE2..0AE3    ; Other_Alphabetic # Mn   [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL
+0AFA..0AFC    ; Other_Alphabetic # Mn   [3] GUJARATI SIGN SUKUN..GUJARATI SIGN MADDAH
+0B01          ; Other_Alphabetic # Mn       ORIYA SIGN CANDRABINDU
+0B02..0B03    ; Other_Alphabetic # Mc   [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA
+0B3E          ; Other_Alphabetic # Mc       ORIYA VOWEL SIGN AA
+0B3F          ; Other_Alphabetic # Mn       ORIYA VOWEL SIGN I
+0B40          ; Other_Alphabetic # Mc       ORIYA VOWEL SIGN II
+0B41..0B44    ; Other_Alphabetic # Mn   [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR
+0B47..0B48    ; Other_Alphabetic # Mc   [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI
+0B4B..0B4C    ; Other_Alphabetic # Mc   [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU
+0B56          ; Other_Alphabetic # Mn       ORIYA AI LENGTH MARK
+0B57          ; Other_Alphabetic # Mc       ORIYA AU LENGTH MARK
+0B62..0B63    ; Other_Alphabetic # Mn   [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL
+0B82          ; Other_Alphabetic # Mn       TAMIL SIGN ANUSVARA
+0BBE..0BBF    ; Other_Alphabetic # Mc   [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN I
+0BC0          ; Other_Alphabetic # Mn       TAMIL VOWEL SIGN II
+0BC1..0BC2    ; Other_Alphabetic # Mc   [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU
+0BC6..0BC8    ; Other_Alphabetic # Mc   [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI
+0BCA..0BCC    ; Other_Alphabetic # Mc   [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU
+0BD7          ; Other_Alphabetic # Mc       TAMIL AU LENGTH MARK
+0C00          ; Other_Alphabetic # Mn       TELUGU SIGN COMBINING CANDRABINDU ABOVE
+0C01..0C03    ; Other_Alphabetic # Mc   [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA
+0C04          ; Other_Alphabetic # Mn       TELUGU SIGN COMBINING ANUSVARA ABOVE
+0C3E..0C40    ; Other_Alphabetic # Mn   [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II
+0C41..0C44    ; Other_Alphabetic # Mc   [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR
+0C46..0C48    ; Other_Alphabetic # Mn   [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI
+0C4A..0C4C    ; Other_Alphabetic # Mn   [3] TELUGU VOWEL SIGN O..TELUGU VOWEL SIGN AU
+0C55..0C56    ; Other_Alphabetic # Mn   [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK
+0C62..0C63    ; Other_Alphabetic # Mn   [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL
+0C81          ; Other_Alphabetic # Mn       KANNADA SIGN CANDRABINDU
+0C82..0C83    ; Other_Alphabetic # Mc   [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA
+0CBE          ; Other_Alphabetic # Mc       KANNADA VOWEL SIGN AA
+0CBF          ; Other_Alphabetic # Mn       KANNADA VOWEL SIGN I
+0CC0..0CC4    ; Other_Alphabetic # Mc   [5] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN VOCALIC RR
+0CC6          ; Other_Alphabetic # Mn       KANNADA VOWEL SIGN E
+0CC7..0CC8    ; Other_Alphabetic # Mc   [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI
+0CCA..0CCB    ; Other_Alphabetic # Mc   [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO
+0CCC          ; Other_Alphabetic # Mn       KANNADA VOWEL SIGN AU
+0CD5..0CD6    ; Other_Alphabetic # Mc   [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK
+0CE2..0CE3    ; Other_Alphabetic # Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
+0CF3          ; Other_Alphabetic # Mc       KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT
+0D00..0D01    ; Other_Alphabetic # Mn   [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU
+0D02..0D03    ; Other_Alphabetic # Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
+0D3E..0D40    ; Other_Alphabetic # Mc   [3] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN II
+0D41..0D44    ; Other_Alphabetic # Mn   [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR
+0D46..0D48    ; Other_Alphabetic # Mc   [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI
+0D4A..0D4C    ; Other_Alphabetic # Mc   [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU
+0D57          ; Other_Alphabetic # Mc       MALAYALAM AU LENGTH MARK
+0D62..0D63    ; Other_Alphabetic # Mn   [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL
+0D81          ; Other_Alphabetic # Mn       SINHALA SIGN CANDRABINDU
+0D82..0D83    ; Other_Alphabetic # Mc   [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA
+0DCF..0DD1    ; Other_Alphabetic # Mc   [3] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA
+0DD2..0DD4    ; Other_Alphabetic # Mn   [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA
+0DD6          ; Other_Alphabetic # Mn       SINHALA VOWEL SIGN DIGA PAA-PILLA
+0DD8..0DDF    ; Other_Alphabetic # Mc   [8] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN GAYANUKITTA
+0DF2..0DF3    ; Other_Alphabetic # Mc   [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA
+0E31          ; Other_Alphabetic # Mn       THAI CHARACTER MAI HAN-AKAT
+0E34..0E3A    ; Other_Alphabetic # Mn   [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU
+0E4D          ; Other_Alphabetic # Mn       THAI CHARACTER NIKHAHIT
+0EB1          ; Other_Alphabetic # Mn       LAO VOWEL SIGN MAI KAN
+0EB4..0EB9    ; Other_Alphabetic # Mn   [6] LAO VOWEL SIGN I..LAO VOWEL SIGN UU
+0EBB..0EBC    ; Other_Alphabetic # Mn   [2] LAO VOWEL SIGN MAI KON..LAO SEMIVOWEL SIGN LO
+0ECD          ; Other_Alphabetic # Mn       LAO NIGGAHITA
+0F71..0F7E    ; Other_Alphabetic # Mn  [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO
+0F7F          ; Other_Alphabetic # Mc       TIBETAN SIGN RNAM BCAD
+0F80..0F83    ; Other_Alphabetic # Mn   [4] TIBETAN VOWEL SIGN REVERSED I..TIBETAN SIGN SNA LDAN
+0F8D..0F97    ; Other_Alphabetic # Mn  [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA
+0F99..0FBC    ; Other_Alphabetic # Mn  [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA
+102B..102C    ; Other_Alphabetic # Mc   [2] MYANMAR VOWEL SIGN TALL AA..MYANMAR VOWEL SIGN AA
+102D..1030    ; Other_Alphabetic # Mn   [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU
+1031          ; Other_Alphabetic # Mc       MYANMAR VOWEL SIGN E
+1032..1036    ; Other_Alphabetic # Mn   [5] MYANMAR VOWEL SIGN AI..MYANMAR SIGN ANUSVARA
+1038          ; Other_Alphabetic # Mc       MYANMAR SIGN VISARGA
+103B..103C    ; Other_Alphabetic # Mc   [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA
+103D..103E    ; Other_Alphabetic # Mn   [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA
+1056..1057    ; Other_Alphabetic # Mc   [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR
+1058..1059    ; Other_Alphabetic # Mn   [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL
+105E..1060    ; Other_Alphabetic # Mn   [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA
+1062..1064    ; Other_Alphabetic # Mc   [3] MYANMAR VOWEL SIGN SGAW KAREN EU..MYANMAR TONE MARK SGAW KAREN KE PHO
+1067..106D    ; Other_Alphabetic # Mc   [7] MYANMAR VOWEL SIGN WESTERN PWO KAREN EU..MYANMAR SIGN WESTERN PWO KAREN TONE-5
+1071..1074    ; Other_Alphabetic # Mn   [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE
+1082          ; Other_Alphabetic # Mn       MYANMAR CONSONANT SIGN SHAN MEDIAL WA
+1083..1084    ; Other_Alphabetic # Mc   [2] MYANMAR VOWEL SIGN SHAN AA..MYANMAR VOWEL SIGN SHAN E
+1085..1086    ; Other_Alphabetic # Mn   [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y
+1087..108C    ; Other_Alphabetic # Mc   [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3
+108D          ; Other_Alphabetic # Mn       MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE
+108F          ; Other_Alphabetic # Mc       MYANMAR SIGN RUMAI PALAUNG TONE-5
+109A..109C    ; Other_Alphabetic # Mc   [3] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON A
+109D          ; Other_Alphabetic # Mn       MYANMAR VOWEL SIGN AITON AI
+1712..1713    ; Other_Alphabetic # Mn   [2] TAGALOG VOWEL SIGN I..TAGALOG VOWEL SIGN U
+1732..1733    ; Other_Alphabetic # Mn   [2] HANUNOO VOWEL SIGN I..HANUNOO VOWEL SIGN U
+1752..1753    ; Other_Alphabetic # Mn   [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U
+1772..1773    ; Other_Alphabetic # Mn   [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U
+17B6          ; Other_Alphabetic # Mc       KHMER VOWEL SIGN AA
+17B7..17BD    ; Other_Alphabetic # Mn   [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA
+17BE..17C5    ; Other_Alphabetic # Mc   [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU
+17C6          ; Other_Alphabetic # Mn       KHMER SIGN NIKAHIT
+17C7..17C8    ; Other_Alphabetic # Mc   [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU
+1885..1886    ; Other_Alphabetic # Mn   [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA
+18A9          ; Other_Alphabetic # Mn       MONGOLIAN LETTER ALI GALI DAGALGA
+1920..1922    ; Other_Alphabetic # Mn   [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U
+1923..1926    ; Other_Alphabetic # Mc   [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU
+1927..1928    ; Other_Alphabetic # Mn   [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O
+1929..192B    ; Other_Alphabetic # Mc   [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA
+1930..1931    ; Other_Alphabetic # Mc   [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA
+1932          ; Other_Alphabetic # Mn       LIMBU SMALL LETTER ANUSVARA
+1933..1938    ; Other_Alphabetic # Mc   [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA
+1A17..1A18    ; Other_Alphabetic # Mn   [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U
+1A19..1A1A    ; Other_Alphabetic # Mc   [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O
+1A1B          ; Other_Alphabetic # Mn       BUGINESE VOWEL SIGN AE
+1A55          ; Other_Alphabetic # Mc       TAI THAM CONSONANT SIGN MEDIAL RA
+1A56          ; Other_Alphabetic # Mn       TAI THAM CONSONANT SIGN MEDIAL LA
+1A57          ; Other_Alphabetic # Mc       TAI THAM CONSONANT SIGN LA TANG LAI
+1A58..1A5E    ; Other_Alphabetic # Mn   [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA
+1A61          ; Other_Alphabetic # Mc       TAI THAM VOWEL SIGN A
+1A62          ; Other_Alphabetic # Mn       TAI THAM VOWEL SIGN MAI SAT
+1A63..1A64    ; Other_Alphabetic # Mc   [2] TAI THAM VOWEL SIGN AA..TAI THAM VOWEL SIGN TALL AA
+1A65..1A6C    ; Other_Alphabetic # Mn   [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW
+1A6D..1A72    ; Other_Alphabetic # Mc   [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI
+1A73..1A74    ; Other_Alphabetic # Mn   [2] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN MAI KANG
+1ABF..1AC0    ; Other_Alphabetic # Mn   [2] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER TURNED W BELOW
+1ACC..1ACE    ; Other_Alphabetic # Mn   [3] COMBINING LATIN SMALL LETTER INSULAR G..COMBINING LATIN SMALL LETTER INSULAR T
+1B00..1B03    ; Other_Alphabetic # Mn   [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG
+1B04          ; Other_Alphabetic # Mc       BALINESE SIGN BISAH
+1B35          ; Other_Alphabetic # Mc       BALINESE VOWEL SIGN TEDUNG
+1B36..1B3A    ; Other_Alphabetic # Mn   [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA
+1B3B          ; Other_Alphabetic # Mc       BALINESE VOWEL SIGN RA REPA TEDUNG
+1B3C          ; Other_Alphabetic # Mn       BALINESE VOWEL SIGN LA LENGA
+1B3D..1B41    ; Other_Alphabetic # Mc   [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG
+1B42          ; Other_Alphabetic # Mn       BALINESE VOWEL SIGN PEPET
+1B43          ; Other_Alphabetic # Mc       BALINESE VOWEL SIGN PEPET TEDUNG
+1B80..1B81    ; Other_Alphabetic # Mn   [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR
+1B82          ; Other_Alphabetic # Mc       SUNDANESE SIGN PANGWISAD
+1BA1          ; Other_Alphabetic # Mc       SUNDANESE CONSONANT SIGN PAMINGKAL
+1BA2..1BA5    ; Other_Alphabetic # Mn   [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU
+1BA6..1BA7    ; Other_Alphabetic # Mc   [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG
+1BA8..1BA9    ; Other_Alphabetic # Mn   [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG
+1BAC..1BAD    ; Other_Alphabetic # Mn   [2] SUNDANESE CONSONANT SIGN PASANGAN MA..SUNDANESE CONSONANT SIGN PASANGAN WA
+1BE7          ; Other_Alphabetic # Mc       BATAK VOWEL SIGN E
+1BE8..1BE9    ; Other_Alphabetic # Mn   [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE
+1BEA..1BEC    ; Other_Alphabetic # Mc   [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O
+1BED          ; Other_Alphabetic # Mn       BATAK VOWEL SIGN KARO O
+1BEE          ; Other_Alphabetic # Mc       BATAK VOWEL SIGN U
+1BEF..1BF1    ; Other_Alphabetic # Mn   [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H
+1C24..1C2B    ; Other_Alphabetic # Mc   [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU
+1C2C..1C33    ; Other_Alphabetic # Mn   [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T
+1C34..1C35    ; Other_Alphabetic # Mc   [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG
+1C36          ; Other_Alphabetic # Mn       LEPCHA SIGN RAN
+1DD3..1DF4    ; Other_Alphabetic # Mn  [34] COMBINING LATIN SMALL LETTER FLATTENED OPEN A ABOVE..COMBINING LATIN SMALL LETTER U WITH DIAERESIS
+24B6..24E9    ; Other_Alphabetic # So  [52] CIRCLED LATIN CAPITAL LETTER A..CIRCLED LATIN SMALL LETTER Z
+2DE0..2DFF    ; Other_Alphabetic # Mn  [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS
+A674..A67B    ; Other_Alphabetic # Mn   [8] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC LETTER OMEGA
+A69E..A69F    ; Other_Alphabetic # Mn   [2] COMBINING CYRILLIC LETTER EF..COMBINING CYRILLIC LETTER IOTIFIED E
+A802          ; Other_Alphabetic # Mn       SYLOTI NAGRI SIGN DVISVARA
+A80B          ; Other_Alphabetic # Mn       SYLOTI NAGRI SIGN ANUSVARA
+A823..A824    ; Other_Alphabetic # Mc   [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I
+A825..A826    ; Other_Alphabetic # Mn   [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E
+A827          ; Other_Alphabetic # Mc       SYLOTI NAGRI VOWEL SIGN OO
+A880..A881    ; Other_Alphabetic # Mc   [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA
+A8B4..A8C3    ; Other_Alphabetic # Mc  [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU
+A8C5          ; Other_Alphabetic # Mn       SAURASHTRA SIGN CANDRABINDU
+A8FF          ; Other_Alphabetic # Mn       DEVANAGARI VOWEL SIGN AY
+A926..A92A    ; Other_Alphabetic # Mn   [5] KAYAH LI VOWEL UE..KAYAH LI VOWEL O
+A947..A951    ; Other_Alphabetic # Mn  [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R
+A952          ; Other_Alphabetic # Mc       REJANG CONSONANT SIGN H
+A980..A982    ; Other_Alphabetic # Mn   [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR
+A983          ; Other_Alphabetic # Mc       JAVANESE SIGN WIGNYAN
+A9B4..A9B5    ; Other_Alphabetic # Mc   [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG
+A9B6..A9B9    ; Other_Alphabetic # Mn   [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT
+A9BA..A9BB    ; Other_Alphabetic # Mc   [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE
+A9BC..A9BD    ; Other_Alphabetic # Mn   [2] JAVANESE VOWEL SIGN PEPET..JAVANESE CONSONANT SIGN KERET
+A9BE..A9BF    ; Other_Alphabetic # Mc   [2] JAVANESE CONSONANT SIGN PENGKAL..JAVANESE CONSONANT SIGN CAKRA
+A9E5          ; Other_Alphabetic # Mn       MYANMAR SIGN SHAN SAW
+AA29..AA2E    ; Other_Alphabetic # Mn   [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE
+AA2F..AA30    ; Other_Alphabetic # Mc   [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI
+AA31..AA32    ; Other_Alphabetic # Mn   [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE
+AA33..AA34    ; Other_Alphabetic # Mc   [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA
+AA35..AA36    ; Other_Alphabetic # Mn   [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA
+AA43          ; Other_Alphabetic # Mn       CHAM CONSONANT SIGN FINAL NG
+AA4C          ; Other_Alphabetic # Mn       CHAM CONSONANT SIGN FINAL M
+AA4D          ; Other_Alphabetic # Mc       CHAM CONSONANT SIGN FINAL H
+AA7B          ; Other_Alphabetic # Mc       MYANMAR SIGN PAO KAREN TONE
+AA7C          ; Other_Alphabetic # Mn       MYANMAR SIGN TAI LAING TONE-2
+AA7D          ; Other_Alphabetic # Mc       MYANMAR SIGN TAI LAING TONE-5
+AAB0          ; Other_Alphabetic # Mn       TAI VIET MAI KANG
+AAB2..AAB4    ; Other_Alphabetic # Mn   [3] TAI VIET VOWEL I..TAI VIET VOWEL U
+AAB7..AAB8    ; Other_Alphabetic # Mn   [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA
+AABE          ; Other_Alphabetic # Mn       TAI VIET VOWEL AM
+AAEB          ; Other_Alphabetic # Mc       MEETEI MAYEK VOWEL SIGN II
+AAEC..AAED    ; Other_Alphabetic # Mn   [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI
+AAEE..AAEF    ; Other_Alphabetic # Mc   [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU
+AAF5          ; Other_Alphabetic # Mc       MEETEI MAYEK VOWEL SIGN VISARGA
+ABE3..ABE4    ; Other_Alphabetic # Mc   [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP
+ABE5          ; Other_Alphabetic # Mn       MEETEI MAYEK VOWEL SIGN ANAP
+ABE6..ABE7    ; Other_Alphabetic # Mc   [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP
+ABE8          ; Other_Alphabetic # Mn       MEETEI MAYEK VOWEL SIGN UNAP
+ABE9..ABEA    ; Other_Alphabetic # Mc   [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG
+FB1E          ; Other_Alphabetic # Mn       HEBREW POINT JUDEO-SPANISH VARIKA
+10376..1037A  ; Other_Alphabetic # Mn   [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII
+10A01..10A03  ; Other_Alphabetic # Mn   [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R
+10A05..10A06  ; Other_Alphabetic # Mn   [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O
+10A0C..10A0F  ; Other_Alphabetic # Mn   [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA
+10D24..10D27  ; Other_Alphabetic # Mn   [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI
+10D69         ; Other_Alphabetic # Mn       GARAY VOWEL SIGN E
+10EAB..10EAC  ; Other_Alphabetic # Mn   [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK
+10EFA..10EFC  ; Other_Alphabetic # Mn   [3] ARABIC DOUBLE VERTICAL BAR BELOW..ARABIC COMBINING ALEF OVERLAY
+11000         ; Other_Alphabetic # Mc       BRAHMI SIGN CANDRABINDU
+11001         ; Other_Alphabetic # Mn       BRAHMI SIGN ANUSVARA
+11002         ; Other_Alphabetic # Mc       BRAHMI SIGN VISARGA
+11038..11045  ; Other_Alphabetic # Mn  [14] BRAHMI VOWEL SIGN AA..BRAHMI VOWEL SIGN AU
+11073..11074  ; Other_Alphabetic # Mn   [2] BRAHMI VOWEL SIGN OLD TAMIL SHORT E..BRAHMI VOWEL SIGN OLD TAMIL SHORT O
+11080..11081  ; Other_Alphabetic # Mn   [2] KAITHI SIGN CANDRABINDU..KAITHI SIGN ANUSVARA
+11082         ; Other_Alphabetic # Mc       KAITHI SIGN VISARGA
+110B0..110B2  ; Other_Alphabetic # Mc   [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II
+110B3..110B6  ; Other_Alphabetic # Mn   [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI
+110B7..110B8  ; Other_Alphabetic # Mc   [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU
+110C2         ; Other_Alphabetic # Mn       KAITHI VOWEL SIGN VOCALIC R
+11100..11102  ; Other_Alphabetic # Mn   [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA
+11127..1112B  ; Other_Alphabetic # Mn   [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU
+1112C         ; Other_Alphabetic # Mc       CHAKMA VOWEL SIGN E
+1112D..11132  ; Other_Alphabetic # Mn   [6] CHAKMA VOWEL SIGN AI..CHAKMA AU MARK
+11145..11146  ; Other_Alphabetic # Mc   [2] CHAKMA VOWEL SIGN AA..CHAKMA VOWEL SIGN EI
+11180..11181  ; Other_Alphabetic # Mn   [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA
+11182         ; Other_Alphabetic # Mc       SHARADA SIGN VISARGA
+111B3..111B5  ; Other_Alphabetic # Mc   [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II
+111B6..111BE  ; Other_Alphabetic # Mn   [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O
+111BF         ; Other_Alphabetic # Mc       SHARADA VOWEL SIGN AU
+111CE         ; Other_Alphabetic # Mc       SHARADA VOWEL SIGN PRISHTHAMATRA E
+111CF         ; Other_Alphabetic # Mn       SHARADA SIGN INVERTED CANDRABINDU
+1122C..1122E  ; Other_Alphabetic # Mc   [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II
+1122F..11231  ; Other_Alphabetic # Mn   [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI
+11232..11233  ; Other_Alphabetic # Mc   [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU
+11234         ; Other_Alphabetic # Mn       KHOJKI SIGN ANUSVARA
+11237         ; Other_Alphabetic # Mn       KHOJKI SIGN SHADDA
+1123E         ; Other_Alphabetic # Mn       KHOJKI SIGN SUKUN
+11241         ; Other_Alphabetic # Mn       KHOJKI VOWEL SIGN VOCALIC R
+112DF         ; Other_Alphabetic # Mn       KHUDAWADI SIGN ANUSVARA
+112E0..112E2  ; Other_Alphabetic # Mc   [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II
+112E3..112E8  ; Other_Alphabetic # Mn   [6] KHUDAWADI VOWEL SIGN U..KHUDAWADI VOWEL SIGN AU
+11300..11301  ; Other_Alphabetic # Mn   [2] GRANTHA SIGN COMBINING ANUSVARA ABOVE..GRANTHA SIGN CANDRABINDU
+11302..11303  ; Other_Alphabetic # Mc   [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA
+1133E..1133F  ; Other_Alphabetic # Mc   [2] GRANTHA VOWEL SIGN AA..GRANTHA VOWEL SIGN I
+11340         ; Other_Alphabetic # Mn       GRANTHA VOWEL SIGN II
+11341..11344  ; Other_Alphabetic # Mc   [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR
+11347..11348  ; Other_Alphabetic # Mc   [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI
+1134B..1134C  ; Other_Alphabetic # Mc   [2] GRANTHA VOWEL SIGN OO..GRANTHA VOWEL SIGN AU
+11357         ; Other_Alphabetic # Mc       GRANTHA AU LENGTH MARK
+11362..11363  ; Other_Alphabetic # Mc   [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL
+113B8..113BA  ; Other_Alphabetic # Mc   [3] TULU-TIGALARI VOWEL SIGN AA..TULU-TIGALARI VOWEL SIGN II
+113BB..113C0  ; Other_Alphabetic # Mn   [6] TULU-TIGALARI VOWEL SIGN U..TULU-TIGALARI VOWEL SIGN VOCALIC LL
+113C2         ; Other_Alphabetic # Mc       TULU-TIGALARI VOWEL SIGN EE
+113C5         ; Other_Alphabetic # Mc       TULU-TIGALARI VOWEL SIGN AI
+113C7..113CA  ; Other_Alphabetic # Mc   [4] TULU-TIGALARI VOWEL SIGN OO..TULU-TIGALARI SIGN CANDRA ANUNASIKA
+113CC..113CD  ; Other_Alphabetic # Mc   [2] TULU-TIGALARI SIGN ANUSVARA..TULU-TIGALARI SIGN VISARGA
+11435..11437  ; Other_Alphabetic # Mc   [3] NEWA VOWEL SIGN AA..NEWA VOWEL SIGN II
+11438..1143F  ; Other_Alphabetic # Mn   [8] NEWA VOWEL SIGN U..NEWA VOWEL SIGN AI
+11440..11441  ; Other_Alphabetic # Mc   [2] NEWA VOWEL SIGN O..NEWA VOWEL SIGN AU
+11443..11444  ; Other_Alphabetic # Mn   [2] NEWA SIGN CANDRABINDU..NEWA SIGN ANUSVARA
+11445         ; Other_Alphabetic # Mc       NEWA SIGN VISARGA
+114B0..114B2  ; Other_Alphabetic # Mc   [3] TIRHUTA VOWEL SIGN AA..TIRHUTA VOWEL SIGN II
+114B3..114B8  ; Other_Alphabetic # Mn   [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL
+114B9         ; Other_Alphabetic # Mc       TIRHUTA VOWEL SIGN E
+114BA         ; Other_Alphabetic # Mn       TIRHUTA VOWEL SIGN SHORT E
+114BB..114BE  ; Other_Alphabetic # Mc   [4] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN AU
+114BF..114C0  ; Other_Alphabetic # Mn   [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA
+114C1         ; Other_Alphabetic # Mc       TIRHUTA SIGN VISARGA
+115AF..115B1  ; Other_Alphabetic # Mc   [3] SIDDHAM VOWEL SIGN AA..SIDDHAM VOWEL SIGN II
+115B2..115B5  ; Other_Alphabetic # Mn   [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR
+115B8..115BB  ; Other_Alphabetic # Mc   [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU
+115BC..115BD  ; Other_Alphabetic # Mn   [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA
+115BE         ; Other_Alphabetic # Mc       SIDDHAM SIGN VISARGA
+115DC..115DD  ; Other_Alphabetic # Mn   [2] SIDDHAM VOWEL SIGN ALTERNATE U..SIDDHAM VOWEL SIGN ALTERNATE UU
+11630..11632  ; Other_Alphabetic # Mc   [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II
+11633..1163A  ; Other_Alphabetic # Mn   [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI
+1163B..1163C  ; Other_Alphabetic # Mc   [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU
+1163D         ; Other_Alphabetic # Mn       MODI SIGN ANUSVARA
+1163E         ; Other_Alphabetic # Mc       MODI SIGN VISARGA
+11640         ; Other_Alphabetic # Mn       MODI SIGN ARDHACANDRA
+116AB         ; Other_Alphabetic # Mn       TAKRI SIGN ANUSVARA
+116AC         ; Other_Alphabetic # Mc       TAKRI SIGN VISARGA
+116AD         ; Other_Alphabetic # Mn       TAKRI VOWEL SIGN AA
+116AE..116AF  ; Other_Alphabetic # Mc   [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II
+116B0..116B5  ; Other_Alphabetic # Mn   [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU
+1171D         ; Other_Alphabetic # Mn       AHOM CONSONANT SIGN MEDIAL LA
+1171E         ; Other_Alphabetic # Mc       AHOM CONSONANT SIGN MEDIAL RA
+1171F         ; Other_Alphabetic # Mn       AHOM CONSONANT SIGN MEDIAL LIGATING RA
+11720..11721  ; Other_Alphabetic # Mc   [2] AHOM VOWEL SIGN A..AHOM VOWEL SIGN AA
+11722..11725  ; Other_Alphabetic # Mn   [4] AHOM VOWEL SIGN I..AHOM VOWEL SIGN UU
+11726         ; Other_Alphabetic # Mc       AHOM VOWEL SIGN E
+11727..1172A  ; Other_Alphabetic # Mn   [4] AHOM VOWEL SIGN AW..AHOM VOWEL SIGN AM
+1182C..1182E  ; Other_Alphabetic # Mc   [3] DOGRA VOWEL SIGN AA..DOGRA VOWEL SIGN II
+1182F..11837  ; Other_Alphabetic # Mn   [9] DOGRA VOWEL SIGN U..DOGRA SIGN ANUSVARA
+11838         ; Other_Alphabetic # Mc       DOGRA SIGN VISARGA
+11930..11935  ; Other_Alphabetic # Mc   [6] DIVES AKURU VOWEL SIGN AA..DIVES AKURU VOWEL SIGN E
+11937..11938  ; Other_Alphabetic # Mc   [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O
+1193B..1193C  ; Other_Alphabetic # Mn   [2] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN CANDRABINDU
+11940         ; Other_Alphabetic # Mc       DIVES AKURU MEDIAL YA
+11942         ; Other_Alphabetic # Mc       DIVES AKURU MEDIAL RA
+119D1..119D3  ; Other_Alphabetic # Mc   [3] NANDINAGARI VOWEL SIGN AA..NANDINAGARI VOWEL SIGN II
+119D4..119D7  ; Other_Alphabetic # Mn   [4] NANDINAGARI VOWEL SIGN U..NANDINAGARI VOWEL SIGN VOCALIC RR
+119DA..119DB  ; Other_Alphabetic # Mn   [2] NANDINAGARI VOWEL SIGN E..NANDINAGARI VOWEL SIGN AI
+119DC..119DF  ; Other_Alphabetic # Mc   [4] NANDINAGARI VOWEL SIGN O..NANDINAGARI SIGN VISARGA
+119E4         ; Other_Alphabetic # Mc       NANDINAGARI VOWEL SIGN PRISHTHAMATRA E
+11A01..11A0A  ; Other_Alphabetic # Mn  [10] ZANABAZAR SQUARE VOWEL SIGN I..ZANABAZAR SQUARE VOWEL LENGTH MARK
+11A35..11A38  ; Other_Alphabetic # Mn   [4] ZANABAZAR SQUARE SIGN CANDRABINDU..ZANABAZAR SQUARE SIGN ANUSVARA
+11A39         ; Other_Alphabetic # Mc       ZANABAZAR SQUARE SIGN VISARGA
+11A3B..11A3E  ; Other_Alphabetic # Mn   [4] ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA
+11A51..11A56  ; Other_Alphabetic # Mn   [6] SOYOMBO VOWEL SIGN I..SOYOMBO VOWEL SIGN OE
+11A57..11A58  ; Other_Alphabetic # Mc   [2] SOYOMBO VOWEL SIGN AI..SOYOMBO VOWEL SIGN AU
+11A59..11A5B  ; Other_Alphabetic # Mn   [3] SOYOMBO VOWEL SIGN VOCALIC R..SOYOMBO VOWEL LENGTH MARK
+11A8A..11A96  ; Other_Alphabetic # Mn  [13] SOYOMBO FINAL CONSONANT SIGN G..SOYOMBO SIGN ANUSVARA
+11A97         ; Other_Alphabetic # Mc       SOYOMBO SIGN VISARGA
+11B60         ; Other_Alphabetic # Mn       SHARADA VOWEL SIGN OE
+11B61         ; Other_Alphabetic # Mc       SHARADA VOWEL SIGN OOE
+11B62..11B64  ; Other_Alphabetic # Mn   [3] SHARADA VOWEL SIGN UE..SHARADA VOWEL SIGN SHORT E
+11B65         ; Other_Alphabetic # Mc       SHARADA VOWEL SIGN SHORT O
+11B66         ; Other_Alphabetic # Mn       SHARADA VOWEL SIGN CANDRA E
+11B67         ; Other_Alphabetic # Mc       SHARADA VOWEL SIGN CANDRA O
+11C2F         ; Other_Alphabetic # Mc       BHAIKSUKI VOWEL SIGN AA
+11C30..11C36  ; Other_Alphabetic # Mn   [7] BHAIKSUKI VOWEL SIGN I..BHAIKSUKI VOWEL SIGN VOCALIC L
+11C38..11C3D  ; Other_Alphabetic # Mn   [6] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN ANUSVARA
+11C3E         ; Other_Alphabetic # Mc       BHAIKSUKI SIGN VISARGA
+11C92..11CA7  ; Other_Alphabetic # Mn  [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA
+11CA9         ; Other_Alphabetic # Mc       MARCHEN SUBJOINED LETTER YA
+11CAA..11CB0  ; Other_Alphabetic # Mn   [7] MARCHEN SUBJOINED LETTER RA..MARCHEN VOWEL SIGN AA
+11CB1         ; Other_Alphabetic # Mc       MARCHEN VOWEL SIGN I
+11CB2..11CB3  ; Other_Alphabetic # Mn   [2] MARCHEN VOWEL SIGN U..MARCHEN VOWEL SIGN E
+11CB4         ; Other_Alphabetic # Mc       MARCHEN VOWEL SIGN O
+11CB5..11CB6  ; Other_Alphabetic # Mn   [2] MARCHEN SIGN ANUSVARA..MARCHEN SIGN CANDRABINDU
+11D31..11D36  ; Other_Alphabetic # Mn   [6] MASARAM GONDI VOWEL SIGN AA..MASARAM GONDI VOWEL SIGN VOCALIC R
+11D3A         ; Other_Alphabetic # Mn       MASARAM GONDI VOWEL SIGN E
+11D3C..11D3D  ; Other_Alphabetic # Mn   [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O
+11D3F..11D41  ; Other_Alphabetic # Mn   [3] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI SIGN VISARGA
+11D43         ; Other_Alphabetic # Mn       MASARAM GONDI SIGN CANDRA
+11D47         ; Other_Alphabetic # Mn       MASARAM GONDI RA-KARA
+11D8A..11D8E  ; Other_Alphabetic # Mc   [5] GUNJALA GONDI VOWEL SIGN AA..GUNJALA GONDI VOWEL SIGN UU
+11D90..11D91  ; Other_Alphabetic # Mn   [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI
+11D93..11D94  ; Other_Alphabetic # Mc   [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU
+11D95         ; Other_Alphabetic # Mn       GUNJALA GONDI SIGN ANUSVARA
+11D96         ; Other_Alphabetic # Mc       GUNJALA GONDI SIGN VISARGA
+11EF3..11EF4  ; Other_Alphabetic # Mn   [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U
+11EF5..11EF6  ; Other_Alphabetic # Mc   [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O
+11F00..11F01  ; Other_Alphabetic # Mn   [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA
+11F03         ; Other_Alphabetic # Mc       KAWI SIGN VISARGA
+11F34..11F35  ; Other_Alphabetic # Mc   [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA
+11F36..11F3A  ; Other_Alphabetic # Mn   [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R
+11F3E..11F3F  ; Other_Alphabetic # Mc   [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI
+11F40         ; Other_Alphabetic # Mn       KAWI VOWEL SIGN EU
+1611E..16129  ; Other_Alphabetic # Mn  [12] GURUNG KHEMA VOWEL SIGN AA..GURUNG KHEMA VOWEL LENGTH MARK
+1612A..1612C  ; Other_Alphabetic # Mc   [3] GURUNG KHEMA CONSONANT SIGN MEDIAL YA..GURUNG KHEMA CONSONANT SIGN MEDIAL HA
+1612D..1612E  ; Other_Alphabetic # Mn   [2] GURUNG KHEMA SIGN ANUSVARA..GURUNG KHEMA CONSONANT SIGN MEDIAL RA
+16F4F         ; Other_Alphabetic # Mn       MIAO SIGN CONSONANT MODIFIER BAR
+16F51..16F87  ; Other_Alphabetic # Mc  [55] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN UI
+16F8F..16F92  ; Other_Alphabetic # Mn   [4] MIAO TONE RIGHT..MIAO TONE BELOW
+16FF0..16FF1  ; Other_Alphabetic # Mc   [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY
+1BC9E         ; Other_Alphabetic # Mn       DUPLOYAN DOUBLE MARK
+1E000..1E006  ; Other_Alphabetic # Mn   [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE
+1E008..1E018  ; Other_Alphabetic # Mn  [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU
+1E01B..1E021  ; Other_Alphabetic # Mn   [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI
+1E023..1E024  ; Other_Alphabetic # Mn   [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS
+1E026..1E02A  ; Other_Alphabetic # Mn   [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA
+1E08F         ; Other_Alphabetic # Mn       COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
+1E6E3         ; Other_Alphabetic # Mn       TAI YO SIGN UE
+1E6E6         ; Other_Alphabetic # Mn       TAI YO SIGN AU
+1E6EE..1E6EF  ; Other_Alphabetic # Mn   [2] TAI YO SIGN AY..TAI YO SIGN ANG
+1E6F5         ; Other_Alphabetic # Mn       TAI YO SIGN OM
+1E947         ; Other_Alphabetic # Mn       ADLAM HAMZA
+1F130..1F149  ; Other_Alphabetic # So  [26] SQUARED LATIN CAPITAL LETTER A..SQUARED LATIN CAPITAL LETTER Z
+1F150..1F169  ; Other_Alphabetic # So  [26] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z
+1F170..1F189  ; Other_Alphabetic # So  [26] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER Z
+
+# Total code points: 1510
+
+# ================================================
+
+3006          ; Ideographic # Lo       IDEOGRAPHIC CLOSING MARK
+3007          ; Ideographic # Nl       IDEOGRAPHIC NUMBER ZERO
+3021..3029    ; Ideographic # Nl   [9] HANGZHOU NUMERAL ONE..HANGZHOU NUMERAL NINE
+3038..303A    ; Ideographic # Nl   [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY
+3400..4DBF    ; Ideographic # Lo [6592] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-4DBF
+4E00..9FFF    ; Ideographic # Lo [20992] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-9FFF
+F900..FA6D    ; Ideographic # Lo [366] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA6D
+FA70..FAD9    ; Ideographic # Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9
+16FE4         ; Ideographic # Mn       KHITAN SMALL SCRIPT FILLER
+16FF2..16FF3  ; Ideographic # Lm   [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER
+16FF4..16FF6  ; Ideographic # Nl   [3] YANGQIN SIGN SLOW ONE BEAT..YANGQIN SIGN SLOW TWO BEATS
+17000..18CD5  ; Ideographic # Lo [7382] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CD5
+18CFF..18D1E  ; Ideographic # Lo  [32] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D1E
+18D80..18DF2  ; Ideographic # Lo [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883
+1B170..1B2FB  ; Ideographic # Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB
+20000..2A6DF  ; Ideographic # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF
+2A700..2B81D  ; Ideographic # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D
+2B820..2CEAD  ; Ideographic # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD
+2CEB0..2EBE0  ; Ideographic # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0
+2EBF0..2EE5D  ; Ideographic # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D
+2F800..2FA1D  ; Ideographic # Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D
+30000..3134A  ; Ideographic # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A
+31350..33479  ; Ideographic # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479
+
+# Total code points: 110943
+
+# ================================================
+
+005E          ; Diacritic # Sk       CIRCUMFLEX ACCENT
+0060          ; Diacritic # Sk       GRAVE ACCENT
+00A8          ; Diacritic # Sk       DIAERESIS
+00AF          ; Diacritic # Sk       MACRON
+00B4          ; Diacritic # Sk       ACUTE ACCENT
+00B7          ; Diacritic # Po       MIDDLE DOT
+00B8          ; Diacritic # Sk       CEDILLA
+02B0..02C1    ; Diacritic # Lm  [18] MODIFIER LETTER SMALL H..MODIFIER LETTER REVERSED GLOTTAL STOP
+02C2..02C5    ; Diacritic # Sk   [4] MODIFIER LETTER LEFT ARROWHEAD..MODIFIER LETTER DOWN ARROWHEAD
+02C6..02D1    ; Diacritic # Lm  [12] MODIFIER LETTER CIRCUMFLEX ACCENT..MODIFIER LETTER HALF TRIANGULAR COLON
+02D2..02DF    ; Diacritic # Sk  [14] MODIFIER LETTER CENTRED RIGHT HALF RING..MODIFIER LETTER CROSS ACCENT
+02E0..02E4    ; Diacritic # Lm   [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP
+02E5..02EB    ; Diacritic # Sk   [7] MODIFIER LETTER EXTRA-HIGH TONE BAR..MODIFIER LETTER YANG DEPARTING TONE MARK
+02EC          ; Diacritic # Lm       MODIFIER LETTER VOICING
+02ED          ; Diacritic # Sk       MODIFIER LETTER UNASPIRATED
+02EE          ; Diacritic # Lm       MODIFIER LETTER DOUBLE APOSTROPHE
+02EF..02FF    ; Diacritic # Sk  [17] MODIFIER LETTER LOW DOWN ARROWHEAD..MODIFIER LETTER LOW LEFT ARROW
+0300..034E    ; Diacritic # Mn  [79] COMBINING GRAVE ACCENT..COMBINING UPWARDS ARROW BELOW
+0350..0357    ; Diacritic # Mn   [8] COMBINING RIGHT ARROWHEAD ABOVE..COMBINING RIGHT HALF RING ABOVE
+035D..0362    ; Diacritic # Mn   [6] COMBINING DOUBLE BREVE..COMBINING DOUBLE RIGHTWARDS ARROW BELOW
+0374          ; Diacritic # Lm       GREEK NUMERAL SIGN
+0375          ; Diacritic # Sk       GREEK LOWER NUMERAL SIGN
+037A          ; Diacritic # Lm       GREEK YPOGEGRAMMENI
+0384..0385    ; Diacritic # Sk   [2] GREEK TONOS..GREEK DIALYTIKA TONOS
+0483..0487    ; Diacritic # Mn   [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE
+0559          ; Diacritic # Lm       ARMENIAN MODIFIER LETTER LEFT HALF RING
+0591..05BD    ; Diacritic # Mn  [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG
+05BF          ; Diacritic # Mn       HEBREW POINT RAFE
+05C1..05C2    ; Diacritic # Mn   [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT
+05C4..05C5    ; Diacritic # Mn   [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT
+05C7          ; Diacritic # Mn       HEBREW POINT QAMATS QATAN
+064B..0652    ; Diacritic # Mn   [8] ARABIC FATHATAN..ARABIC SUKUN
+0657..0658    ; Diacritic # Mn   [2] ARABIC INVERTED DAMMA..ARABIC MARK NOON GHUNNA
+06DF..06E0    ; Diacritic # Mn   [2] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH UPRIGHT RECTANGULAR ZERO
+06E5..06E6    ; Diacritic # Lm   [2] ARABIC SMALL WAW..ARABIC SMALL YEH
+06EA..06EC    ; Diacritic # Mn   [3] ARABIC EMPTY CENTRE LOW STOP..ARABIC ROUNDED HIGH STOP WITH FILLED CENTRE
+0730..074A    ; Diacritic # Mn  [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH
+07A6..07B0    ; Diacritic # Mn  [11] THAANA ABAFILI..THAANA SUKUN
+07EB..07F3    ; Diacritic # Mn   [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE
+07F4..07F5    ; Diacritic # Lm   [2] NKO HIGH TONE APOSTROPHE..NKO LOW TONE APOSTROPHE
+0818..0819    ; Diacritic # Mn   [2] SAMARITAN MARK OCCLUSION..SAMARITAN MARK DAGESH
+0898..089F    ; Diacritic # Mn   [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA
+08C9          ; Diacritic # Lm       ARABIC SMALL FARSI YEH
+08CA..08D2    ; Diacritic # Mn   [9] ARABIC SMALL HIGH FARSI YEH..ARABIC LARGE ROUND DOT INSIDE CIRCLE BELOW
+08E3..08FE    ; Diacritic # Mn  [28] ARABIC TURNED DAMMA BELOW..ARABIC DAMMA WITH DOT
+093C          ; Diacritic # Mn       DEVANAGARI SIGN NUKTA
+094D          ; Diacritic # Mn       DEVANAGARI SIGN VIRAMA
+0951..0954    ; Diacritic # Mn   [4] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI ACUTE ACCENT
+0971          ; Diacritic # Lm       DEVANAGARI SIGN HIGH SPACING DOT
+09BC          ; Diacritic # Mn       BENGALI SIGN NUKTA
+09CD          ; Diacritic # Mn       BENGALI SIGN VIRAMA
+0A3C          ; Diacritic # Mn       GURMUKHI SIGN NUKTA
+0A4D          ; Diacritic # Mn       GURMUKHI SIGN VIRAMA
+0ABC          ; Diacritic # Mn       GUJARATI SIGN NUKTA
+0ACD          ; Diacritic # Mn       GUJARATI SIGN VIRAMA
+0AFD..0AFF    ; Diacritic # Mn   [3] GUJARATI SIGN THREE-DOT NUKTA ABOVE..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE
+0B3C          ; Diacritic # Mn       ORIYA SIGN NUKTA
+0B4D          ; Diacritic # Mn       ORIYA SIGN VIRAMA
+0B55          ; Diacritic # Mn       ORIYA SIGN OVERLINE
+0BCD          ; Diacritic # Mn       TAMIL SIGN VIRAMA
+0C3C          ; Diacritic # Mn       TELUGU SIGN NUKTA
+0C4D          ; Diacritic # Mn       TELUGU SIGN VIRAMA
+0CBC          ; Diacritic # Mn       KANNADA SIGN NUKTA
+0CCD          ; Diacritic # Mn       KANNADA SIGN VIRAMA
+0D3B..0D3C    ; Diacritic # Mn   [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA
+0D4D          ; Diacritic # Mn       MALAYALAM SIGN VIRAMA
+0DCA          ; Diacritic # Mn       SINHALA SIGN AL-LAKUNA
+0E3A          ; Diacritic # Mn       THAI CHARACTER PHINTHU
+0E47..0E4C    ; Diacritic # Mn   [6] THAI CHARACTER MAITAIKHU..THAI CHARACTER THANTHAKHAT
+0E4E          ; Diacritic # Mn       THAI CHARACTER YAMAKKAN
+0EBA          ; Diacritic # Mn       LAO SIGN PALI VIRAMA
+0EC8..0ECC    ; Diacritic # Mn   [5] LAO TONE MAI EK..LAO CANCELLATION MARK
+0F18..0F19    ; Diacritic # Mn   [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS
+0F35          ; Diacritic # Mn       TIBETAN MARK NGAS BZUNG NYI ZLA
+0F37          ; Diacritic # Mn       TIBETAN MARK NGAS BZUNG SGOR RTAGS
+0F39          ; Diacritic # Mn       TIBETAN MARK TSA -PHRU
+0F3E..0F3F    ; Diacritic # Mc   [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES
+0F82..0F84    ; Diacritic # Mn   [3] TIBETAN SIGN NYI ZLA NAA DA..TIBETAN MARK HALANTA
+0F86..0F87    ; Diacritic # Mn   [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS
+0FC6          ; Diacritic # Mn       TIBETAN SYMBOL PADMA GDAN
+1037          ; Diacritic # Mn       MYANMAR SIGN DOT BELOW
+1039..103A    ; Diacritic # Mn   [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT
+1063..1064    ; Diacritic # Mc   [2] MYANMAR TONE MARK SGAW KAREN HATHI..MYANMAR TONE MARK SGAW KAREN KE PHO
+1069..106D    ; Diacritic # Mc   [5] MYANMAR SIGN WESTERN PWO KAREN TONE-1..MYANMAR SIGN WESTERN PWO KAREN TONE-5
+1087..108C    ; Diacritic # Mc   [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3
+108D          ; Diacritic # Mn       MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE
+108F          ; Diacritic # Mc       MYANMAR SIGN RUMAI PALAUNG TONE-5
+109A..109B    ; Diacritic # Mc   [2] MYANMAR SIGN KHAMTI TONE-1..MYANMAR SIGN KHAMTI TONE-3
+135D..135F    ; Diacritic # Mn   [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK
+1714          ; Diacritic # Mn       TAGALOG SIGN VIRAMA
+1715          ; Diacritic # Mc       TAGALOG SIGN PAMUDPOD
+1734          ; Diacritic # Mc       HANUNOO SIGN PAMUDPOD
+17C9..17D3    ; Diacritic # Mn  [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT
+17DD          ; Diacritic # Mn       KHMER SIGN ATTHACAN
+1939..193B    ; Diacritic # Mn   [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I
+1A60          ; Diacritic # Mn       TAI THAM SIGN SAKOT
+1A75..1A7C    ; Diacritic # Mn   [8] TAI THAM SIGN TONE-1..TAI THAM SIGN KHUEN-LUE KARAN
+1A7F          ; Diacritic # Mn       TAI THAM COMBINING CRYPTOGRAMMIC DOT
+1AB0..1ABD    ; Diacritic # Mn  [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW
+1ABE          ; Diacritic # Me       COMBINING PARENTHESES OVERLAY
+1AC1..1ACB    ; Diacritic # Mn  [11] COMBINING LEFT PARENTHESIS ABOVE LEFT..COMBINING TRIPLE ACUTE ACCENT
+1ACF..1ADD    ; Diacritic # Mn  [15] COMBINING DOUBLE CARON..COMBINING DOT-AND-RING BELOW
+1AE0..1AEB    ; Diacritic # Mn  [12] COMBINING LEFT TACK ABOVE..COMBINING DOUBLE RIGHTWARDS ARROW ABOVE
+1B34          ; Diacritic # Mn       BALINESE SIGN REREKAN
+1B44          ; Diacritic # Mc       BALINESE ADEG ADEG
+1B6B..1B73    ; Diacritic # Mn   [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG
+1BAA          ; Diacritic # Mc       SUNDANESE SIGN PAMAAEH
+1BAB          ; Diacritic # Mn       SUNDANESE SIGN VIRAMA
+1BE6          ; Diacritic # Mn       BATAK SIGN TOMPI
+1BF2..1BF3    ; Diacritic # Mc   [2] BATAK PANGOLAT..BATAK PANONGONAN
+1C36..1C37    ; Diacritic # Mn   [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA
+1C78..1C7D    ; Diacritic # Lm   [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD
+1CD0..1CD2    ; Diacritic # Mn   [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA
+1CD3          ; Diacritic # Po       VEDIC SIGN NIHSHVASA
+1CD4..1CE0    ; Diacritic # Mn  [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA
+1CE1          ; Diacritic # Mc       VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA
+1CE2..1CE8    ; Diacritic # Mn   [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL
+1CED          ; Diacritic # Mn       VEDIC SIGN TIRYAK
+1CF4          ; Diacritic # Mn       VEDIC TONE CANDRA ABOVE
+1CF7          ; Diacritic # Mc       VEDIC SIGN ATIKRAMA
+1CF8..1CF9    ; Diacritic # Mn   [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE
+1D2C..1D6A    ; Diacritic # Lm  [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI
+1D9B..1DBE    ; Diacritic # Lm  [36] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL EZH
+1DC4..1DCF    ; Diacritic # Mn  [12] COMBINING MACRON-ACUTE..COMBINING ZIGZAG BELOW
+1DF5..1DFF    ; Diacritic # Mn  [11] COMBINING UP TACK ABOVE..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW
+1FBD          ; Diacritic # Sk       GREEK KORONIS
+1FBF..1FC1    ; Diacritic # Sk   [3] GREEK PSILI..GREEK DIALYTIKA AND PERISPOMENI
+1FCD..1FCF    ; Diacritic # Sk   [3] GREEK PSILI AND VARIA..GREEK PSILI AND PERISPOMENI
+1FDD..1FDF    ; Diacritic # Sk   [3] GREEK DASIA AND VARIA..GREEK DASIA AND PERISPOMENI
+1FED..1FEF    ; Diacritic # Sk   [3] GREEK DIALYTIKA AND VARIA..GREEK VARIA
+1FFD..1FFE    ; Diacritic # Sk   [2] GREEK OXIA..GREEK DASIA
+2CEF..2CF1    ; Diacritic # Mn   [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS
+2E2F          ; Diacritic # Lm       VERTICAL TILDE
+302A..302D    ; Diacritic # Mn   [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK
+302E..302F    ; Diacritic # Mc   [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK
+3099..309A    ; Diacritic # Mn   [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+309B..309C    ; Diacritic # Sk   [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+30FC          ; Diacritic # Lm       KATAKANA-HIRAGANA PROLONGED SOUND MARK
+A66F          ; Diacritic # Mn       COMBINING CYRILLIC VZMET
+A67C..A67D    ; Diacritic # Mn   [2] COMBINING CYRILLIC KAVYKA..COMBINING CYRILLIC PAYEROK
+A67F          ; Diacritic # Lm       CYRILLIC PAYEROK
+A69C..A69D    ; Diacritic # Lm   [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN
+A6F0..A6F1    ; Diacritic # Mn   [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS
+A700..A716    ; Diacritic # Sk  [23] MODIFIER LETTER CHINESE TONE YIN PING..MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR
+A717..A71F    ; Diacritic # Lm   [9] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK
+A720..A721    ; Diacritic # Sk   [2] MODIFIER LETTER STRESS AND HIGH TONE..MODIFIER LETTER STRESS AND LOW TONE
+A788          ; Diacritic # Lm       MODIFIER LETTER LOW CIRCUMFLEX ACCENT
+A789..A78A    ; Diacritic # Sk   [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN
+A7F1          ; Diacritic # Lm       MODIFIER LETTER CAPITAL S
+A7F8..A7F9    ; Diacritic # Lm   [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE
+A806          ; Diacritic # Mn       SYLOTI NAGRI SIGN HASANTA
+A82C          ; Diacritic # Mn       SYLOTI NAGRI SIGN ALTERNATE HASANTA
+A8C4          ; Diacritic # Mn       SAURASHTRA SIGN VIRAMA
+A8E0..A8F1    ; Diacritic # Mn  [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA
+A92B..A92D    ; Diacritic # Mn   [3] KAYAH LI TONE PLOPHU..KAYAH LI TONE CALYA PLOPHU
+A92E          ; Diacritic # Po       KAYAH LI SIGN CWI
+A953          ; Diacritic # Mc       REJANG VIRAMA
+A9B3          ; Diacritic # Mn       JAVANESE SIGN CECAK TELU
+A9C0          ; Diacritic # Mc       JAVANESE PANGKON
+A9E5          ; Diacritic # Mn       MYANMAR SIGN SHAN SAW
+AA7B          ; Diacritic # Mc       MYANMAR SIGN PAO KAREN TONE
+AA7C          ; Diacritic # Mn       MYANMAR SIGN TAI LAING TONE-2
+AA7D          ; Diacritic # Mc       MYANMAR SIGN TAI LAING TONE-5
+AABF          ; Diacritic # Mn       TAI VIET TONE MAI EK
+AAC0          ; Diacritic # Lo       TAI VIET TONE MAI NUENG
+AAC1          ; Diacritic # Mn       TAI VIET TONE MAI THO
+AAC2          ; Diacritic # Lo       TAI VIET TONE MAI SONG
+AAF6          ; Diacritic # Mn       MEETEI MAYEK VIRAMA
+AB5B          ; Diacritic # Sk       MODIFIER BREVE WITH INVERTED BREVE
+AB5C..AB5F    ; Diacritic # Lm   [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK
+AB69          ; Diacritic # Lm       MODIFIER LETTER SMALL TURNED W
+AB6A..AB6B    ; Diacritic # Sk   [2] MODIFIER LETTER LEFT TACK..MODIFIER LETTER RIGHT TACK
+ABEC          ; Diacritic # Mc       MEETEI MAYEK LUM IYEK
+ABED          ; Diacritic # Mn       MEETEI MAYEK APUN IYEK
+FB1E          ; Diacritic # Mn       HEBREW POINT JUDEO-SPANISH VARIKA
+FE20..FE2F    ; Diacritic # Mn  [16] COMBINING LIGATURE LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF
+FF3E          ; Diacritic # Sk       FULLWIDTH CIRCUMFLEX ACCENT
+FF40          ; Diacritic # Sk       FULLWIDTH GRAVE ACCENT
+FF70          ; Diacritic # Lm       HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK
+FF9E..FF9F    ; Diacritic # Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
+FFE3          ; Diacritic # Sk       FULLWIDTH MACRON
+102E0         ; Diacritic # Mn       COPTIC EPACT THOUSANDS MARK
+10780..10785  ; Diacritic # Lm   [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK
+10787..107B0  ; Diacritic # Lm  [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK
+107B2..107BA  ; Diacritic # Lm   [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL
+10A38..10A3A  ; Diacritic # Mn   [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW
+10A3F         ; Diacritic # Mn       KHAROSHTHI VIRAMA
+10AE5..10AE6  ; Diacritic # Mn   [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW
+10D22..10D23  ; Diacritic # Lo   [2] HANIFI ROHINGYA MARK SAKIN..HANIFI ROHINGYA MARK NA KHONNA
+10D24..10D27  ; Diacritic # Mn   [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI
+10D4E         ; Diacritic # Lm       GARAY VOWEL LENGTH MARK
+10D69..10D6D  ; Diacritic # Mn   [5] GARAY VOWEL SIGN E..GARAY CONSONANT NASALIZATION MARK
+10EFA         ; Diacritic # Mn       ARABIC DOUBLE VERTICAL BAR BELOW
+10EFD..10EFF  ; Diacritic # Mn   [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA
+10F46..10F50  ; Diacritic # Mn  [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW
+10F82..10F85  ; Diacritic # Mn   [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW
+11046         ; Diacritic # Mn       BRAHMI VIRAMA
+11070         ; Diacritic # Mn       BRAHMI SIGN OLD TAMIL VIRAMA
+110B9..110BA  ; Diacritic # Mn   [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA
+11133..11134  ; Diacritic # Mn   [2] CHAKMA VIRAMA..CHAKMA MAAYYAA
+11173         ; Diacritic # Mn       MAHAJANI SIGN NUKTA
+111C0         ; Diacritic # Mc       SHARADA SIGN VIRAMA
+111CA..111CC  ; Diacritic # Mn   [3] SHARADA SIGN NUKTA..SHARADA EXTRA SHORT VOWEL MARK
+11235         ; Diacritic # Mc       KHOJKI SIGN VIRAMA
+11236         ; Diacritic # Mn       KHOJKI SIGN NUKTA
+112E9..112EA  ; Diacritic # Mn   [2] KHUDAWADI SIGN NUKTA..KHUDAWADI SIGN VIRAMA
+1133B..1133C  ; Diacritic # Mn   [2] COMBINING BINDU BELOW..GRANTHA SIGN NUKTA
+1134D         ; Diacritic # Mc       GRANTHA SIGN VIRAMA
+11366..1136C  ; Diacritic # Mn   [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX
+11370..11374  ; Diacritic # Mn   [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA
+113CE         ; Diacritic # Mn       TULU-TIGALARI SIGN VIRAMA
+113CF         ; Diacritic # Mc       TULU-TIGALARI SIGN LOOPED VIRAMA
+113D0         ; Diacritic # Mn       TULU-TIGALARI CONJOINER
+113D2         ; Diacritic # Mn       TULU-TIGALARI GEMINATION MARK
+113D3         ; Diacritic # Lo       TULU-TIGALARI SIGN PLUTA
+113E1..113E2  ; Diacritic # Mn   [2] TULU-TIGALARI VEDIC TONE SVARITA..TULU-TIGALARI VEDIC TONE ANUDATTA
+11442         ; Diacritic # Mn       NEWA SIGN VIRAMA
+11446         ; Diacritic # Mn       NEWA SIGN NUKTA
+114C2..114C3  ; Diacritic # Mn   [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA
+115BF..115C0  ; Diacritic # Mn   [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA
+1163F         ; Diacritic # Mn       MODI SIGN VIRAMA
+116B6         ; Diacritic # Mc       TAKRI SIGN VIRAMA
+116B7         ; Diacritic # Mn       TAKRI SIGN NUKTA
+1172B         ; Diacritic # Mn       AHOM SIGN KILLER
+11839..1183A  ; Diacritic # Mn   [2] DOGRA SIGN VIRAMA..DOGRA SIGN NUKTA
+1193D         ; Diacritic # Mc       DIVES AKURU SIGN HALANTA
+1193E         ; Diacritic # Mn       DIVES AKURU VIRAMA
+11943         ; Diacritic # Mn       DIVES AKURU SIGN NUKTA
+119E0         ; Diacritic # Mn       NANDINAGARI SIGN VIRAMA
+11A34         ; Diacritic # Mn       ZANABAZAR SQUARE SIGN VIRAMA
+11A47         ; Diacritic # Mn       ZANABAZAR SQUARE SUBJOINER
+11A99         ; Diacritic # Mn       SOYOMBO SUBJOINER
+11C3F         ; Diacritic # Mn       BHAIKSUKI SIGN VIRAMA
+11D42         ; Diacritic # Mn       MASARAM GONDI SIGN NUKTA
+11D44..11D45  ; Diacritic # Mn   [2] MASARAM GONDI SIGN HALANTA..MASARAM GONDI VIRAMA
+11D97         ; Diacritic # Mn       GUNJALA GONDI VIRAMA
+11DD9         ; Diacritic # Lm       TOLONG SIKI SIGN SELA
+11F41         ; Diacritic # Mc       KAWI SIGN KILLER
+11F42         ; Diacritic # Mn       KAWI CONJOINER
+11F5A         ; Diacritic # Mn       KAWI SIGN NUKTA
+13447..13455  ; Diacritic # Mn  [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED
+1612F         ; Diacritic # Mn       GURUNG KHEMA SIGN THOLHOMA
+16AF0..16AF4  ; Diacritic # Mn   [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE
+16B30..16B36  ; Diacritic # Mn   [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM
+16D6B..16D6C  ; Diacritic # Lm   [2] KIRAT RAI SIGN VIRAMA..KIRAT RAI SIGN SAAT
+16F8F..16F92  ; Diacritic # Mn   [4] MIAO TONE RIGHT..MIAO TONE BELOW
+16F93..16F9F  ; Diacritic # Lm  [13] MIAO LETTER TONE-2..MIAO LETTER REFORMED TONE-8
+16FF0..16FF1  ; Diacritic # Mc   [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY
+1AFF0..1AFF3  ; Diacritic # Lm   [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5
+1AFF5..1AFFB  ; Diacritic # Lm   [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5
+1AFFD..1AFFE  ; Diacritic # Lm   [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8
+1CF00..1CF2D  ; Diacritic # Mn  [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT
+1CF30..1CF46  ; Diacritic # Mn  [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG
+1D167..1D169  ; Diacritic # Mn   [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3
+1D16D..1D172  ; Diacritic # Mc   [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5
+1D17B..1D182  ; Diacritic # Mn   [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE
+1D185..1D18B  ; Diacritic # Mn   [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE
+1D1AA..1D1AD  ; Diacritic # Mn   [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO
+1E030..1E06D  ; Diacritic # Lm  [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE
+1E130..1E136  ; Diacritic # Mn   [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D
+1E2AE         ; Diacritic # Mn       TOTO SIGN RISING TONE
+1E2EC..1E2EF  ; Diacritic # Mn   [4] WANCHO TONE TUP..WANCHO TONE KOINI
+1E5EE..1E5EF  ; Diacritic # Mn   [2] OL ONAL SIGN MU..OL ONAL SIGN IKIR
+1E8D0..1E8D6  ; Diacritic # Mn   [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS
+1E944..1E946  ; Diacritic # Mn   [3] ADLAM ALIF LENGTHENER..ADLAM GEMINATION MARK
+1E948..1E94A  ; Diacritic # Mn   [3] ADLAM CONSONANT MODIFIER..ADLAM NUKTA
+
+# Total code points: 1247
+
+# ================================================
+
+00B7          ; Extender # Po       MIDDLE DOT
+02D0..02D1    ; Extender # Lm   [2] MODIFIER LETTER TRIANGULAR COLON..MODIFIER LETTER HALF TRIANGULAR COLON
+0640          ; Extender # Lm       ARABIC TATWEEL
+07FA          ; Extender # Lm       NKO LAJANYALAN
+0A71          ; Extender # Mn       GURMUKHI ADDAK
+0AFB          ; Extender # Mn       GUJARATI SIGN SHADDA
+0B55          ; Extender # Mn       ORIYA SIGN OVERLINE
+0E46          ; Extender # Lm       THAI CHARACTER MAIYAMOK
+0EC6          ; Extender # Lm       LAO KO LA
+180A          ; Extender # Po       MONGOLIAN NIRUGU
+1843          ; Extender # Lm       MONGOLIAN LETTER TODO LONG VOWEL SIGN
+1AA7          ; Extender # Lm       TAI THAM SIGN MAI YAMOK
+1C36          ; Extender # Mn       LEPCHA SIGN RAN
+1C7B          ; Extender # Lm       OL CHIKI RELAA
+3005          ; Extender # Lm       IDEOGRAPHIC ITERATION MARK
+3031..3035    ; Extender # Lm   [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF
+309D..309E    ; Extender # Lm   [2] HIRAGANA ITERATION MARK..HIRAGANA VOICED ITERATION MARK
+30FC..30FE    ; Extender # Lm   [3] KATAKANA-HIRAGANA PROLONGED SOUND MARK..KATAKANA VOICED ITERATION MARK
+A015          ; Extender # Lm       YI SYLLABLE WU
+A60C          ; Extender # Lm       VAI SYLLABLE LENGTHENER
+A9CF          ; Extender # Lm       JAVANESE PANGRANGKEP
+A9E6          ; Extender # Lm       MYANMAR MODIFIER LETTER SHAN REDUPLICATION
+AA70          ; Extender # Lm       MYANMAR MODIFIER LETTER KHAMTI REDUPLICATION
+AADD          ; Extender # Lm       TAI VIET SYMBOL SAM
+AAF3..AAF4    ; Extender # Lm   [2] MEETEI MAYEK SYLLABLE REPETITION MARK..MEETEI MAYEK WORD REPETITION MARK
+FF70          ; Extender # Lm       HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK
+10781..10782  ; Extender # Lm   [2] MODIFIER LETTER SUPERSCRIPT TRIANGULAR COLON..MODIFIER LETTER SUPERSCRIPT HALF TRIANGULAR COLON
+10D4E         ; Extender # Lm       GARAY VOWEL LENGTH MARK
+10D6A         ; Extender # Mn       GARAY CONSONANT GEMINATION MARK
+10D6F         ; Extender # Lm       GARAY REDUPLICATION MARK
+11237         ; Extender # Mn       KHOJKI SIGN SHADDA
+1135D         ; Extender # Lo       GRANTHA SIGN PLUTA
+113D2         ; Extender # Mn       TULU-TIGALARI GEMINATION MARK
+113D3         ; Extender # Lo       TULU-TIGALARI SIGN PLUTA
+115C6..115C8  ; Extender # Po   [3] SIDDHAM REPETITION MARK-1..SIDDHAM REPETITION MARK-3
+11A98         ; Extender # Mn       SOYOMBO GEMINATION MARK
+11DD9         ; Extender # Lm       TOLONG SIKI SIGN SELA
+16B42..16B43  ; Extender # Lm   [2] PAHAWH HMONG SIGN VOS NRUA..PAHAWH HMONG SIGN IB YAM
+16FE0..16FE1  ; Extender # Lm   [2] TANGUT ITERATION MARK..NUSHU ITERATION MARK
+16FE3         ; Extender # Lm       OLD CHINESE ITERATION MARK
+16FF2..16FF3  ; Extender # Lm   [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER
+1E13C..1E13D  ; Extender # Lm   [2] NYIAKENG PUACHUE HMONG SIGN XW XW..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER
+1E5EF         ; Extender # Mn       OL ONAL SIGN IKIR
+1E944..1E946  ; Extender # Mn   [3] ADLAM ALIF LENGTHENER..ADLAM GEMINATION MARK
+
+# Total code points: 62
+
+# ================================================
+
+00AA          ; Other_Lowercase # Lo       FEMININE ORDINAL INDICATOR
+00BA          ; Other_Lowercase # Lo       MASCULINE ORDINAL INDICATOR
+02B0..02B8    ; Other_Lowercase # Lm   [9] MODIFIER LETTER SMALL H..MODIFIER LETTER SMALL Y
+02C0..02C1    ; Other_Lowercase # Lm   [2] MODIFIER LETTER GLOTTAL STOP..MODIFIER LETTER REVERSED GLOTTAL STOP
+02E0..02E4    ; Other_Lowercase # Lm   [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP
+0345          ; Other_Lowercase # Mn       COMBINING GREEK YPOGEGRAMMENI
+037A          ; Other_Lowercase # Lm       GREEK YPOGEGRAMMENI
+10FC          ; Other_Lowercase # Lm       MODIFIER LETTER GEORGIAN NAR
+1D2C..1D6A    ; Other_Lowercase # Lm  [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI
+1D78          ; Other_Lowercase # Lm       MODIFIER LETTER CYRILLIC EN
+1D9B..1DBF    ; Other_Lowercase # Lm  [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA
+2071          ; Other_Lowercase # Lm       SUPERSCRIPT LATIN SMALL LETTER I
+207F          ; Other_Lowercase # Lm       SUPERSCRIPT LATIN SMALL LETTER N
+2090..209C    ; Other_Lowercase # Lm  [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T
+2170..217F    ; Other_Lowercase # Nl  [16] SMALL ROMAN NUMERAL ONE..SMALL ROMAN NUMERAL ONE THOUSAND
+24D0..24E9    ; Other_Lowercase # So  [26] CIRCLED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z
+2C7C..2C7D    ; Other_Lowercase # Lm   [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V
+A69C..A69D    ; Other_Lowercase # Lm   [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN
+A770          ; Other_Lowercase # Lm       MODIFIER LETTER US
+A7F1..A7F4    ; Other_Lowercase # Lm   [4] MODIFIER LETTER CAPITAL S..MODIFIER LETTER CAPITAL Q
+A7F8..A7F9    ; Other_Lowercase # Lm   [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE
+AB5C..AB5F    ; Other_Lowercase # Lm   [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK
+AB69          ; Other_Lowercase # Lm       MODIFIER LETTER SMALL TURNED W
+10780         ; Other_Lowercase # Lm       MODIFIER LETTER SMALL CAPITAL AA
+10783..10785  ; Other_Lowercase # Lm   [3] MODIFIER LETTER SMALL AE..MODIFIER LETTER SMALL B WITH HOOK
+10787..107B0  ; Other_Lowercase # Lm  [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK
+107B2..107BA  ; Other_Lowercase # Lm   [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL
+1E030..1E06D  ; Other_Lowercase # Lm  [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE
+
+# Total code points: 312
+
+# ================================================
+
+2160..216F    ; Other_Uppercase # Nl  [16] ROMAN NUMERAL ONE..ROMAN NUMERAL ONE THOUSAND
+24B6..24CF    ; Other_Uppercase # So  [26] CIRCLED LATIN CAPITAL LETTER A..CIRCLED LATIN CAPITAL LETTER Z
+1F130..1F149  ; Other_Uppercase # So  [26] SQUARED LATIN CAPITAL LETTER A..SQUARED LATIN CAPITAL LETTER Z
+1F150..1F169  ; Other_Uppercase # So  [26] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z
+1F170..1F189  ; Other_Uppercase # So  [26] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER Z
+
+# Total code points: 120
+
+# ================================================
+
+FDD0..FDEF    ; Noncharacter_Code_Point # Cn  [32] <noncharacter-FDD0>..<noncharacter-FDEF>
+FFFE..FFFF    ; Noncharacter_Code_Point # Cn   [2] <noncharacter-FFFE>..<noncharacter-FFFF>
+1FFFE..1FFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-1FFFE>..<noncharacter-1FFFF>
+2FFFE..2FFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-2FFFE>..<noncharacter-2FFFF>
+3FFFE..3FFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-3FFFE>..<noncharacter-3FFFF>
+4FFFE..4FFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-4FFFE>..<noncharacter-4FFFF>
+5FFFE..5FFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-5FFFE>..<noncharacter-5FFFF>
+6FFFE..6FFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-6FFFE>..<noncharacter-6FFFF>
+7FFFE..7FFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-7FFFE>..<noncharacter-7FFFF>
+8FFFE..8FFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-8FFFE>..<noncharacter-8FFFF>
+9FFFE..9FFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-9FFFE>..<noncharacter-9FFFF>
+AFFFE..AFFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-AFFFE>..<noncharacter-AFFFF>
+BFFFE..BFFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-BFFFE>..<noncharacter-BFFFF>
+CFFFE..CFFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-CFFFE>..<noncharacter-CFFFF>
+DFFFE..DFFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-DFFFE>..<noncharacter-DFFFF>
+EFFFE..EFFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-EFFFE>..<noncharacter-EFFFF>
+FFFFE..FFFFF  ; Noncharacter_Code_Point # Cn   [2] <noncharacter-FFFFE>..<noncharacter-FFFFF>
+10FFFE..10FFFF; Noncharacter_Code_Point # Cn   [2] <noncharacter-10FFFE>..<noncharacter-10FFFF>
+
+# Total code points: 66
+
+# ================================================
+
+09BE          ; Other_Grapheme_Extend # Mc       BENGALI VOWEL SIGN AA
+09D7          ; Other_Grapheme_Extend # Mc       BENGALI AU LENGTH MARK
+0B3E          ; Other_Grapheme_Extend # Mc       ORIYA VOWEL SIGN AA
+0B57          ; Other_Grapheme_Extend # Mc       ORIYA AU LENGTH MARK
+0BBE          ; Other_Grapheme_Extend # Mc       TAMIL VOWEL SIGN AA
+0BD7          ; Other_Grapheme_Extend # Mc       TAMIL AU LENGTH MARK
+0CC0          ; Other_Grapheme_Extend # Mc       KANNADA VOWEL SIGN II
+0CC2          ; Other_Grapheme_Extend # Mc       KANNADA VOWEL SIGN UU
+0CC7..0CC8    ; Other_Grapheme_Extend # Mc   [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI
+0CCA..0CCB    ; Other_Grapheme_Extend # Mc   [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO
+0CD5..0CD6    ; Other_Grapheme_Extend # Mc   [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK
+0D3E          ; Other_Grapheme_Extend # Mc       MALAYALAM VOWEL SIGN AA
+0D57          ; Other_Grapheme_Extend # Mc       MALAYALAM AU LENGTH MARK
+0DCF          ; Other_Grapheme_Extend # Mc       SINHALA VOWEL SIGN AELA-PILLA
+0DDF          ; Other_Grapheme_Extend # Mc       SINHALA VOWEL SIGN GAYANUKITTA
+1715          ; Other_Grapheme_Extend # Mc       TAGALOG SIGN PAMUDPOD
+1734          ; Other_Grapheme_Extend # Mc       HANUNOO SIGN PAMUDPOD
+1B35          ; Other_Grapheme_Extend # Mc       BALINESE VOWEL SIGN TEDUNG
+1B3B          ; Other_Grapheme_Extend # Mc       BALINESE VOWEL SIGN RA REPA TEDUNG
+1B3D          ; Other_Grapheme_Extend # Mc       BALINESE VOWEL SIGN LA LENGA TEDUNG
+1B43..1B44    ; Other_Grapheme_Extend # Mc   [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG
+1BAA          ; Other_Grapheme_Extend # Mc       SUNDANESE SIGN PAMAAEH
+1BF2..1BF3    ; Other_Grapheme_Extend # Mc   [2] BATAK PANGOLAT..BATAK PANONGONAN
+200C          ; Other_Grapheme_Extend # Cf       ZERO WIDTH NON-JOINER
+302E..302F    ; Other_Grapheme_Extend # Mc   [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK
+A953          ; Other_Grapheme_Extend # Mc       REJANG VIRAMA
+A9C0          ; Other_Grapheme_Extend # Mc       JAVANESE PANGKON
+FF9E..FF9F    ; Other_Grapheme_Extend # Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
+111C0         ; Other_Grapheme_Extend # Mc       SHARADA SIGN VIRAMA
+11235         ; Other_Grapheme_Extend # Mc       KHOJKI SIGN VIRAMA
+1133E         ; Other_Grapheme_Extend # Mc       GRANTHA VOWEL SIGN AA
+1134D         ; Other_Grapheme_Extend # Mc       GRANTHA SIGN VIRAMA
+11357         ; Other_Grapheme_Extend # Mc       GRANTHA AU LENGTH MARK
+113B8         ; Other_Grapheme_Extend # Mc       TULU-TIGALARI VOWEL SIGN AA
+113C2         ; Other_Grapheme_Extend # Mc       TULU-TIGALARI VOWEL SIGN EE
+113C5         ; Other_Grapheme_Extend # Mc       TULU-TIGALARI VOWEL SIGN AI
+113C7..113C9  ; Other_Grapheme_Extend # Mc   [3] TULU-TIGALARI VOWEL SIGN OO..TULU-TIGALARI AU LENGTH MARK
+113CF         ; Other_Grapheme_Extend # Mc       TULU-TIGALARI SIGN LOOPED VIRAMA
+114B0         ; Other_Grapheme_Extend # Mc       TIRHUTA VOWEL SIGN AA
+114BD         ; Other_Grapheme_Extend # Mc       TIRHUTA VOWEL SIGN SHORT O
+115AF         ; Other_Grapheme_Extend # Mc       SIDDHAM VOWEL SIGN AA
+116B6         ; Other_Grapheme_Extend # Mc       TAKRI SIGN VIRAMA
+11930         ; Other_Grapheme_Extend # Mc       DIVES AKURU VOWEL SIGN AA
+1193D         ; Other_Grapheme_Extend # Mc       DIVES AKURU SIGN HALANTA
+11F41         ; Other_Grapheme_Extend # Mc       KAWI SIGN KILLER
+16FF0..16FF1  ; Other_Grapheme_Extend # Mc   [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY
+1D165..1D166  ; Other_Grapheme_Extend # Mc   [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM
+1D16D..1D172  ; Other_Grapheme_Extend # Mc   [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5
+E0020..E007F  ; Other_Grapheme_Extend # Cf  [96] TAG SPACE..CANCEL TAG
+
+# Total code points: 160
+
+# ================================================
+
+2FF0..2FF1    ; IDS_Binary_Operator # So   [2] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO BELOW
+2FF4..2FFD    ; IDS_Binary_Operator # So  [10] IDEOGRAPHIC DESCRIPTION CHARACTER FULL SURROUND..IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LOWER RIGHT
+31EF          ; IDS_Binary_Operator # So       IDEOGRAPHIC DESCRIPTION CHARACTER SUBTRACTION
+
+# Total code points: 13
+
+# ================================================
+
+2FF2..2FF3    ; IDS_Trinary_Operator # So   [2] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO MIDDLE AND RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO MIDDLE AND BELOW
+
+# Total code points: 2
+
+# ================================================
+
+2FFE..2FFF    ; IDS_Unary_Operator # So   [2] IDEOGRAPHIC DESCRIPTION CHARACTER HORIZONTAL REFLECTION..IDEOGRAPHIC DESCRIPTION CHARACTER ROTATION
+
+# Total code points: 2
+
+# ================================================
+
+2E80..2E99    ; Radical # So  [26] CJK RADICAL REPEAT..CJK RADICAL RAP
+2E9B..2EF3    ; Radical # So  [89] CJK RADICAL CHOKE..CJK RADICAL C-SIMPLIFIED TURTLE
+2F00..2FD5    ; Radical # So [214] KANGXI RADICAL ONE..KANGXI RADICAL FLUTE
+
+# Total code points: 329
+
+# ================================================
+
+3400..4DBF    ; Unified_Ideograph # Lo [6592] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-4DBF
+4E00..9FFF    ; Unified_Ideograph # Lo [20992] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-9FFF
+FA0E..FA0F    ; Unified_Ideograph # Lo   [2] CJK COMPATIBILITY IDEOGRAPH-FA0E..CJK COMPATIBILITY IDEOGRAPH-FA0F
+FA11          ; Unified_Ideograph # Lo       CJK COMPATIBILITY IDEOGRAPH-FA11
+FA13..FA14    ; Unified_Ideograph # Lo   [2] CJK COMPATIBILITY IDEOGRAPH-FA13..CJK COMPATIBILITY IDEOGRAPH-FA14
+FA1F          ; Unified_Ideograph # Lo       CJK COMPATIBILITY IDEOGRAPH-FA1F
+FA21          ; Unified_Ideograph # Lo       CJK COMPATIBILITY IDEOGRAPH-FA21
+FA23..FA24    ; Unified_Ideograph # Lo   [2] CJK COMPATIBILITY IDEOGRAPH-FA23..CJK COMPATIBILITY IDEOGRAPH-FA24
+FA27..FA29    ; Unified_Ideograph # Lo   [3] CJK COMPATIBILITY IDEOGRAPH-FA27..CJK COMPATIBILITY IDEOGRAPH-FA29
+20000..2A6DF  ; Unified_Ideograph # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF
+2A700..2B81D  ; Unified_Ideograph # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D
+2B820..2CEAD  ; Unified_Ideograph # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD
+2CEB0..2EBE0  ; Unified_Ideograph # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0
+2EBF0..2EE5D  ; Unified_Ideograph # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D
+30000..3134A  ; Unified_Ideograph # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A
+31350..33479  ; Unified_Ideograph # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479
+
+# Total code points: 101996
+
+# ================================================
+
+034F          ; Other_Default_Ignorable_Code_Point # Mn       COMBINING GRAPHEME JOINER
+115F..1160    ; Other_Default_Ignorable_Code_Point # Lo   [2] HANGUL CHOSEONG FILLER..HANGUL JUNGSEONG FILLER
+17B4..17B5    ; Other_Default_Ignorable_Code_Point # Mn   [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA
+2065          ; Other_Default_Ignorable_Code_Point # Cn       <reserved-2065>
+3164          ; Other_Default_Ignorable_Code_Point # Lo       HANGUL FILLER
+FFA0          ; Other_Default_Ignorable_Code_Point # Lo       HALFWIDTH HANGUL FILLER
+FFF0..FFF8    ; Other_Default_Ignorable_Code_Point # Cn   [9] <reserved-FFF0>..<reserved-FFF8>
+E0000         ; Other_Default_Ignorable_Code_Point # Cn       <reserved-E0000>
+E0002..E001F  ; Other_Default_Ignorable_Code_Point # Cn  [30] <reserved-E0002>..<reserved-E001F>
+E0080..E00FF  ; Other_Default_Ignorable_Code_Point # Cn [128] <reserved-E0080>..<reserved-E00FF>
+E01F0..E0FFF  ; Other_Default_Ignorable_Code_Point # Cn [3600] <reserved-E01F0>..<reserved-E0FFF>
+
+# Total code points: 3776
+
+# ================================================
+
+0149          ; Deprecated # L&       LATIN SMALL LETTER N PRECEDED BY APOSTROPHE
+0673          ; Deprecated # Lo       ARABIC LETTER ALEF WITH WAVY HAMZA BELOW
+0F77          ; Deprecated # Mn       TIBETAN VOWEL SIGN VOCALIC RR
+0F79          ; Deprecated # Mn       TIBETAN VOWEL SIGN VOCALIC LL
+17A3..17A4    ; Deprecated # Lo   [2] KHMER INDEPENDENT VOWEL QAQ..KHMER INDEPENDENT VOWEL QAA
+206A..206F    ; Deprecated # Cf   [6] INHIBIT SYMMETRIC SWAPPING..NOMINAL DIGIT SHAPES
+2329          ; Deprecated # Ps       LEFT-POINTING ANGLE BRACKET
+232A          ; Deprecated # Pe       RIGHT-POINTING ANGLE BRACKET
+E0001         ; Deprecated # Cf       LANGUAGE TAG
+
+# Total code points: 15
+
+# ================================================
+
+0069..006A    ; Soft_Dotted # L&   [2] LATIN SMALL LETTER I..LATIN SMALL LETTER J
+012F          ; Soft_Dotted # L&       LATIN SMALL LETTER I WITH OGONEK
+0249          ; Soft_Dotted # L&       LATIN SMALL LETTER J WITH STROKE
+0268          ; Soft_Dotted # L&       LATIN SMALL LETTER I WITH STROKE
+029D          ; Soft_Dotted # L&       LATIN SMALL LETTER J WITH CROSSED-TAIL
+02B2          ; Soft_Dotted # Lm       MODIFIER LETTER SMALL J
+03F3          ; Soft_Dotted # L&       GREEK LETTER YOT
+0456          ; Soft_Dotted # L&       CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
+0458          ; Soft_Dotted # L&       CYRILLIC SMALL LETTER JE
+1D62          ; Soft_Dotted # Lm       LATIN SUBSCRIPT SMALL LETTER I
+1D96          ; Soft_Dotted # L&       LATIN SMALL LETTER I WITH RETROFLEX HOOK
+1DA4          ; Soft_Dotted # Lm       MODIFIER LETTER SMALL I WITH STROKE
+1DA8          ; Soft_Dotted # Lm       MODIFIER LETTER SMALL J WITH CROSSED-TAIL
+1E2D          ; Soft_Dotted # L&       LATIN SMALL LETTER I WITH TILDE BELOW
+1ECB          ; Soft_Dotted # L&       LATIN SMALL LETTER I WITH DOT BELOW
+2071          ; Soft_Dotted # Lm       SUPERSCRIPT LATIN SMALL LETTER I
+2148..2149    ; Soft_Dotted # L&   [2] DOUBLE-STRUCK ITALIC SMALL I..DOUBLE-STRUCK ITALIC SMALL J
+2C7C          ; Soft_Dotted # Lm       LATIN SUBSCRIPT SMALL LETTER J
+1D422..1D423  ; Soft_Dotted # L&   [2] MATHEMATICAL BOLD SMALL I..MATHEMATICAL BOLD SMALL J
+1D456..1D457  ; Soft_Dotted # L&   [2] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL ITALIC SMALL J
+1D48A..1D48B  ; Soft_Dotted # L&   [2] MATHEMATICAL BOLD ITALIC SMALL I..MATHEMATICAL BOLD ITALIC SMALL J
+1D4BE..1D4BF  ; Soft_Dotted # L&   [2] MATHEMATICAL SCRIPT SMALL I..MATHEMATICAL SCRIPT SMALL J
+1D4F2..1D4F3  ; Soft_Dotted # L&   [2] MATHEMATICAL BOLD SCRIPT SMALL I..MATHEMATICAL BOLD SCRIPT SMALL J
+1D526..1D527  ; Soft_Dotted # L&   [2] MATHEMATICAL FRAKTUR SMALL I..MATHEMATICAL FRAKTUR SMALL J
+1D55A..1D55B  ; Soft_Dotted # L&   [2] MATHEMATICAL DOUBLE-STRUCK SMALL I..MATHEMATICAL DOUBLE-STRUCK SMALL J
+1D58E..1D58F  ; Soft_Dotted # L&   [2] MATHEMATICAL BOLD FRAKTUR SMALL I..MATHEMATICAL BOLD FRAKTUR SMALL J
+1D5C2..1D5C3  ; Soft_Dotted # L&   [2] MATHEMATICAL SANS-SERIF SMALL I..MATHEMATICAL SANS-SERIF SMALL J
+1D5F6..1D5F7  ; Soft_Dotted # L&   [2] MATHEMATICAL SANS-SERIF BOLD SMALL I..MATHEMATICAL SANS-SERIF BOLD SMALL J
+1D62A..1D62B  ; Soft_Dotted # L&   [2] MATHEMATICAL SANS-SERIF ITALIC SMALL I..MATHEMATICAL SANS-SERIF ITALIC SMALL J
+1D65E..1D65F  ; Soft_Dotted # L&   [2] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL I..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL J
+1D692..1D693  ; Soft_Dotted # L&   [2] MATHEMATICAL MONOSPACE SMALL I..MATHEMATICAL MONOSPACE SMALL J
+1DF1A         ; Soft_Dotted # L&       LATIN SMALL LETTER I WITH STROKE AND RETROFLEX HOOK
+1E04C..1E04D  ; Soft_Dotted # Lm   [2] MODIFIER LETTER CYRILLIC SMALL BYELORUSSIAN-UKRAINIAN I..MODIFIER LETTER CYRILLIC SMALL JE
+1E068         ; Soft_Dotted # Lm       CYRILLIC SUBSCRIPT SMALL LETTER BYELORUSSIAN-UKRAINIAN I
+
+# Total code points: 50
+
+# ================================================
+
+0E40..0E44    ; Logical_Order_Exception # Lo   [5] THAI CHARACTER SARA E..THAI CHARACTER SARA AI MAIMALAI
+0EC0..0EC4    ; Logical_Order_Exception # Lo   [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
+19B5..19B7    ; Logical_Order_Exception # Lo   [3] NEW TAI LUE VOWEL SIGN E..NEW TAI LUE VOWEL SIGN O
+19BA          ; Logical_Order_Exception # Lo       NEW TAI LUE VOWEL SIGN AY
+AAB5..AAB6    ; Logical_Order_Exception # Lo   [2] TAI VIET VOWEL E..TAI VIET VOWEL O
+AAB9          ; Logical_Order_Exception # Lo       TAI VIET VOWEL UEA
+AABB..AABC    ; Logical_Order_Exception # Lo   [2] TAI VIET VOWEL AUE..TAI VIET VOWEL AY
+
+# Total code points: 19
+
+# ================================================
+
+1885..1886    ; Other_ID_Start # Mn   [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA
+2118          ; Other_ID_Start # Sm       SCRIPT CAPITAL P
+212E          ; Other_ID_Start # So       ESTIMATED SYMBOL
+309B..309C    ; Other_ID_Start # Sk   [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+
+# Total code points: 6
+
+# ================================================
+
+00B7          ; Other_ID_Continue # Po       MIDDLE DOT
+0387          ; Other_ID_Continue # Po       GREEK ANO TELEIA
+1369..1371    ; Other_ID_Continue # No   [9] ETHIOPIC DIGIT ONE..ETHIOPIC DIGIT NINE
+19DA          ; Other_ID_Continue # No       NEW TAI LUE THAM DIGIT ONE
+200C..200D    ; Other_ID_Continue # Cf   [2] ZERO WIDTH NON-JOINER..ZERO WIDTH JOINER
+30FB          ; Other_ID_Continue # Po       KATAKANA MIDDLE DOT
+FF65          ; Other_ID_Continue # Po       HALFWIDTH KATAKANA MIDDLE DOT
+
+# Total code points: 16
+
+# ================================================
+
+00B2..00B3    ; ID_Compat_Math_Continue # No   [2] SUPERSCRIPT TWO..SUPERSCRIPT THREE
+00B9          ; ID_Compat_Math_Continue # No       SUPERSCRIPT ONE
+2070          ; ID_Compat_Math_Continue # No       SUPERSCRIPT ZERO
+2074..2079    ; ID_Compat_Math_Continue # No   [6] SUPERSCRIPT FOUR..SUPERSCRIPT NINE
+207A..207C    ; ID_Compat_Math_Continue # Sm   [3] SUPERSCRIPT PLUS SIGN..SUPERSCRIPT EQUALS SIGN
+207D          ; ID_Compat_Math_Continue # Ps       SUPERSCRIPT LEFT PARENTHESIS
+207E          ; ID_Compat_Math_Continue # Pe       SUPERSCRIPT RIGHT PARENTHESIS
+2080..2089    ; ID_Compat_Math_Continue # No  [10] SUBSCRIPT ZERO..SUBSCRIPT NINE
+208A..208C    ; ID_Compat_Math_Continue # Sm   [3] SUBSCRIPT PLUS SIGN..SUBSCRIPT EQUALS SIGN
+208D          ; ID_Compat_Math_Continue # Ps       SUBSCRIPT LEFT PARENTHESIS
+208E          ; ID_Compat_Math_Continue # Pe       SUBSCRIPT RIGHT PARENTHESIS
+2202          ; ID_Compat_Math_Continue # Sm       PARTIAL DIFFERENTIAL
+2207          ; ID_Compat_Math_Continue # Sm       NABLA
+221E          ; ID_Compat_Math_Continue # Sm       INFINITY
+1D6C1         ; ID_Compat_Math_Continue # Sm       MATHEMATICAL BOLD NABLA
+1D6DB         ; ID_Compat_Math_Continue # Sm       MATHEMATICAL BOLD PARTIAL DIFFERENTIAL
+1D6FB         ; ID_Compat_Math_Continue # Sm       MATHEMATICAL ITALIC NABLA
+1D715         ; ID_Compat_Math_Continue # Sm       MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL
+1D735         ; ID_Compat_Math_Continue # Sm       MATHEMATICAL BOLD ITALIC NABLA
+1D74F         ; ID_Compat_Math_Continue # Sm       MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL
+1D76F         ; ID_Compat_Math_Continue # Sm       MATHEMATICAL SANS-SERIF BOLD NABLA
+1D789         ; ID_Compat_Math_Continue # Sm       MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL
+1D7A9         ; ID_Compat_Math_Continue # Sm       MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA
+1D7C3         ; ID_Compat_Math_Continue # Sm       MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL
+
+# Total code points: 43
+
+# ================================================
+
+2202          ; ID_Compat_Math_Start # Sm       PARTIAL DIFFERENTIAL
+2207          ; ID_Compat_Math_Start # Sm       NABLA
+221E          ; ID_Compat_Math_Start # Sm       INFINITY
+1D6C1         ; ID_Compat_Math_Start # Sm       MATHEMATICAL BOLD NABLA
+1D6DB         ; ID_Compat_Math_Start # Sm       MATHEMATICAL BOLD PARTIAL DIFFERENTIAL
+1D6FB         ; ID_Compat_Math_Start # Sm       MATHEMATICAL ITALIC NABLA
+1D715         ; ID_Compat_Math_Start # Sm       MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL
+1D735         ; ID_Compat_Math_Start # Sm       MATHEMATICAL BOLD ITALIC NABLA
+1D74F         ; ID_Compat_Math_Start # Sm       MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL
+1D76F         ; ID_Compat_Math_Start # Sm       MATHEMATICAL SANS-SERIF BOLD NABLA
+1D789         ; ID_Compat_Math_Start # Sm       MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL
+1D7A9         ; ID_Compat_Math_Start # Sm       MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA
+1D7C3         ; ID_Compat_Math_Start # Sm       MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL
+
+# Total code points: 13
+
+# ================================================
+
+0021          ; Sentence_Terminal # Po       EXCLAMATION MARK
+002E          ; Sentence_Terminal # Po       FULL STOP
+003F          ; Sentence_Terminal # Po       QUESTION MARK
+0589          ; Sentence_Terminal # Po       ARMENIAN FULL STOP
+061D..061F    ; Sentence_Terminal # Po   [3] ARABIC END OF TEXT MARK..ARABIC QUESTION MARK
+06D4          ; Sentence_Terminal # Po       ARABIC FULL STOP
+0700..0702    ; Sentence_Terminal # Po   [3] SYRIAC END OF PARAGRAPH..SYRIAC SUBLINEAR FULL STOP
+07F9          ; Sentence_Terminal # Po       NKO EXCLAMATION MARK
+0837          ; Sentence_Terminal # Po       SAMARITAN PUNCTUATION MELODIC QITSA
+0839          ; Sentence_Terminal # Po       SAMARITAN PUNCTUATION QITSA
+083D..083E    ; Sentence_Terminal # Po   [2] SAMARITAN PUNCTUATION SOF MASHFAAT..SAMARITAN PUNCTUATION ANNAAU
+0964..0965    ; Sentence_Terminal # Po   [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA
+104A..104B    ; Sentence_Terminal # Po   [2] MYANMAR SIGN LITTLE SECTION..MYANMAR SIGN SECTION
+1362          ; Sentence_Terminal # Po       ETHIOPIC FULL STOP
+1367..1368    ; Sentence_Terminal # Po   [2] ETHIOPIC QUESTION MARK..ETHIOPIC PARAGRAPH SEPARATOR
+166E          ; Sentence_Terminal # Po       CANADIAN SYLLABICS FULL STOP
+1735..1736    ; Sentence_Terminal # Po   [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION
+17D4..17D5    ; Sentence_Terminal # Po   [2] KHMER SIGN KHAN..KHMER SIGN BARIYOOSAN
+1803          ; Sentence_Terminal # Po       MONGOLIAN FULL STOP
+1809          ; Sentence_Terminal # Po       MONGOLIAN MANCHU FULL STOP
+1944..1945    ; Sentence_Terminal # Po   [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK
+1AA8..1AAB    ; Sentence_Terminal # Po   [4] TAI THAM SIGN KAAN..TAI THAM SIGN SATKAANKUU
+1B4E..1B4F    ; Sentence_Terminal # Po   [2] BALINESE INVERTED CARIK SIKI..BALINESE INVERTED CARIK PAREREN
+1B5A..1B5B    ; Sentence_Terminal # Po   [2] BALINESE PANTI..BALINESE PAMADA
+1B5E..1B5F    ; Sentence_Terminal # Po   [2] BALINESE CARIK SIKI..BALINESE CARIK PAREREN
+1B7D..1B7F    ; Sentence_Terminal # Po   [3] BALINESE PANTI LANTANG..BALINESE PANTI BAWAK
+1C3B..1C3C    ; Sentence_Terminal # Po   [2] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION NYET THYOOM TA-ROL
+1C7E..1C7F    ; Sentence_Terminal # Po   [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD
+2024          ; Sentence_Terminal # Po       ONE DOT LEADER
+203C..203D    ; Sentence_Terminal # Po   [2] DOUBLE EXCLAMATION MARK..INTERROBANG
+2047..2049    ; Sentence_Terminal # Po   [3] DOUBLE QUESTION MARK..EXCLAMATION QUESTION MARK
+2CF9..2CFB    ; Sentence_Terminal # Po   [3] COPTIC OLD NUBIAN FULL STOP..COPTIC OLD NUBIAN INDIRECT QUESTION MARK
+2E2E          ; Sentence_Terminal # Po       REVERSED QUESTION MARK
+2E3C          ; Sentence_Terminal # Po       STENOGRAPHIC FULL STOP
+2E53..2E54    ; Sentence_Terminal # Po   [2] MEDIEVAL EXCLAMATION MARK..MEDIEVAL QUESTION MARK
+3002          ; Sentence_Terminal # Po       IDEOGRAPHIC FULL STOP
+A4FF          ; Sentence_Terminal # Po       LISU PUNCTUATION FULL STOP
+A60E..A60F    ; Sentence_Terminal # Po   [2] VAI FULL STOP..VAI QUESTION MARK
+A6F3          ; Sentence_Terminal # Po       BAMUM FULL STOP
+A6F7          ; Sentence_Terminal # Po       BAMUM QUESTION MARK
+A876..A877    ; Sentence_Terminal # Po   [2] PHAGS-PA MARK SHAD..PHAGS-PA MARK DOUBLE SHAD
+A8CE..A8CF    ; Sentence_Terminal # Po   [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA
+A92F          ; Sentence_Terminal # Po       KAYAH LI SIGN SHYA
+A9C8..A9C9    ; Sentence_Terminal # Po   [2] JAVANESE PADA LINGSA..JAVANESE PADA LUNGSI
+AA5D..AA5F    ; Sentence_Terminal # Po   [3] CHAM PUNCTUATION DANDA..CHAM PUNCTUATION TRIPLE DANDA
+AAF0..AAF1    ; Sentence_Terminal # Po   [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM
+ABEB          ; Sentence_Terminal # Po       MEETEI MAYEK CHEIKHEI
+FE12          ; Sentence_Terminal # Po       PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC FULL STOP
+FE15..FE16    ; Sentence_Terminal # Po   [2] PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK..PRESENTATION FORM FOR VERTICAL QUESTION MARK
+FE52          ; Sentence_Terminal # Po       SMALL FULL STOP
+FE56..FE57    ; Sentence_Terminal # Po   [2] SMALL QUESTION MARK..SMALL EXCLAMATION MARK
+FF01          ; Sentence_Terminal # Po       FULLWIDTH EXCLAMATION MARK
+FF0E          ; Sentence_Terminal # Po       FULLWIDTH FULL STOP
+FF1F          ; Sentence_Terminal # Po       FULLWIDTH QUESTION MARK
+FF61          ; Sentence_Terminal # Po       HALFWIDTH IDEOGRAPHIC FULL STOP
+10A56..10A57  ; Sentence_Terminal # Po   [2] KHAROSHTHI PUNCTUATION DANDA..KHAROSHTHI PUNCTUATION DOUBLE DANDA
+10F55..10F59  ; Sentence_Terminal # Po   [5] SOGDIAN PUNCTUATION TWO VERTICAL BARS..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT
+10F86..10F89  ; Sentence_Terminal # Po   [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS
+11047..11048  ; Sentence_Terminal # Po   [2] BRAHMI DANDA..BRAHMI DOUBLE DANDA
+110BE..110C1  ; Sentence_Terminal # Po   [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA
+11141..11143  ; Sentence_Terminal # Po   [3] CHAKMA DANDA..CHAKMA QUESTION MARK
+111C5..111C6  ; Sentence_Terminal # Po   [2] SHARADA DANDA..SHARADA DOUBLE DANDA
+111CD         ; Sentence_Terminal # Po       SHARADA SUTRA MARK
+111DE..111DF  ; Sentence_Terminal # Po   [2] SHARADA SECTION MARK-1..SHARADA SECTION MARK-2
+11238..11239  ; Sentence_Terminal # Po   [2] KHOJKI DANDA..KHOJKI DOUBLE DANDA
+1123B..1123C  ; Sentence_Terminal # Po   [2] KHOJKI SECTION MARK..KHOJKI DOUBLE SECTION MARK
+112A9         ; Sentence_Terminal # Po       MULTANI SECTION MARK
+113D4..113D5  ; Sentence_Terminal # Po   [2] TULU-TIGALARI DANDA..TULU-TIGALARI DOUBLE DANDA
+1144B..1144C  ; Sentence_Terminal # Po   [2] NEWA DANDA..NEWA DOUBLE DANDA
+115C2..115C3  ; Sentence_Terminal # Po   [2] SIDDHAM DANDA..SIDDHAM DOUBLE DANDA
+115C9..115D7  ; Sentence_Terminal # Po  [15] SIDDHAM END OF TEXT MARK..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES
+11641..11642  ; Sentence_Terminal # Po   [2] MODI DANDA..MODI DOUBLE DANDA
+1173C..1173E  ; Sentence_Terminal # Po   [3] AHOM SIGN SMALL SECTION..AHOM SIGN RULAI
+11944         ; Sentence_Terminal # Po       DIVES AKURU DOUBLE DANDA
+11946         ; Sentence_Terminal # Po       DIVES AKURU END OF TEXT MARK
+11A42..11A43  ; Sentence_Terminal # Po   [2] ZANABAZAR SQUARE MARK SHAD..ZANABAZAR SQUARE MARK DOUBLE SHAD
+11A9B..11A9C  ; Sentence_Terminal # Po   [2] SOYOMBO MARK SHAD..SOYOMBO MARK DOUBLE SHAD
+11C41..11C42  ; Sentence_Terminal # Po   [2] BHAIKSUKI DANDA..BHAIKSUKI DOUBLE DANDA
+11EF7..11EF8  ; Sentence_Terminal # Po   [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION
+11F43..11F44  ; Sentence_Terminal # Po   [2] KAWI DANDA..KAWI DOUBLE DANDA
+16A6E..16A6F  ; Sentence_Terminal # Po   [2] MRO DANDA..MRO DOUBLE DANDA
+16AF5         ; Sentence_Terminal # Po       BASSA VAH FULL STOP
+16B37..16B38  ; Sentence_Terminal # Po   [2] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN VOS TSHAB CEEB
+16B44         ; Sentence_Terminal # Po       PAHAWH HMONG SIGN XAUS
+16D6E..16D6F  ; Sentence_Terminal # Po   [2] KIRAT RAI DANDA..KIRAT RAI DOUBLE DANDA
+16E98         ; Sentence_Terminal # Po       MEDEFAIDRIN FULL STOP
+1BC9F         ; Sentence_Terminal # Po       DUPLOYAN PUNCTUATION CHINOOK FULL STOP
+1DA88         ; Sentence_Terminal # Po       SIGNWRITING FULL STOP
+
+# Total code points: 170
+
+# ================================================
+
+180B..180D    ; Variation_Selector # Mn   [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE
+180F          ; Variation_Selector # Mn       MONGOLIAN FREE VARIATION SELECTOR FOUR
+FE00..FE0F    ; Variation_Selector # Mn  [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16
+E0100..E01EF  ; Variation_Selector # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256
+
+# Total code points: 260
+
+# ================================================
+
+0009..000D    ; Pattern_White_Space # Cc   [5] <control-0009>..<control-000D>
+0020          ; Pattern_White_Space # Zs       SPACE
+0085          ; Pattern_White_Space # Cc       <control-0085>
+200E..200F    ; Pattern_White_Space # Cf   [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT MARK
+2028          ; Pattern_White_Space # Zl       LINE SEPARATOR
+2029          ; Pattern_White_Space # Zp       PARAGRAPH SEPARATOR
+
+# Total code points: 11
+
+# ================================================
+
+0021..0023    ; Pattern_Syntax # Po   [3] EXCLAMATION MARK..NUMBER SIGN
+0024          ; Pattern_Syntax # Sc       DOLLAR SIGN
+0025..0027    ; Pattern_Syntax # Po   [3] PERCENT SIGN..APOSTROPHE
+0028          ; Pattern_Syntax # Ps       LEFT PARENTHESIS
+0029          ; Pattern_Syntax # Pe       RIGHT PARENTHESIS
+002A          ; Pattern_Syntax # Po       ASTERISK
+002B          ; Pattern_Syntax # Sm       PLUS SIGN
+002C          ; Pattern_Syntax # Po       COMMA
+002D          ; Pattern_Syntax # Pd       HYPHEN-MINUS
+002E..002F    ; Pattern_Syntax # Po   [2] FULL STOP..SOLIDUS
+003A..003B    ; Pattern_Syntax # Po   [2] COLON..SEMICOLON
+003C..003E    ; Pattern_Syntax # Sm   [3] LESS-THAN SIGN..GREATER-THAN SIGN
+003F..0040    ; Pattern_Syntax # Po   [2] QUESTION MARK..COMMERCIAL AT
+005B          ; Pattern_Syntax # Ps       LEFT SQUARE BRACKET
+005C          ; Pattern_Syntax # Po       REVERSE SOLIDUS
+005D          ; Pattern_Syntax # Pe       RIGHT SQUARE BRACKET
+005E          ; Pattern_Syntax # Sk       CIRCUMFLEX ACCENT
+0060          ; Pattern_Syntax # Sk       GRAVE ACCENT
+007B          ; Pattern_Syntax # Ps       LEFT CURLY BRACKET
+007C          ; Pattern_Syntax # Sm       VERTICAL LINE
+007D          ; Pattern_Syntax # Pe       RIGHT CURLY BRACKET
+007E          ; Pattern_Syntax # Sm       TILDE
+00A1          ; Pattern_Syntax # Po       INVERTED EXCLAMATION MARK
+00A2..00A5    ; Pattern_Syntax # Sc   [4] CENT SIGN..YEN SIGN
+00A6          ; Pattern_Syntax # So       BROKEN BAR
+00A7          ; Pattern_Syntax # Po       SECTION SIGN
+00A9          ; Pattern_Syntax # So       COPYRIGHT SIGN
+00AB          ; Pattern_Syntax # Pi       LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+00AC          ; Pattern_Syntax # Sm       NOT SIGN
+00AE          ; Pattern_Syntax # So       REGISTERED SIGN
+00B0          ; Pattern_Syntax # So       DEGREE SIGN
+00B1          ; Pattern_Syntax # Sm       PLUS-MINUS SIGN
+00B6          ; Pattern_Syntax # Po       PILCROW SIGN
+00BB          ; Pattern_Syntax # Pf       RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+00BF          ; Pattern_Syntax # Po       INVERTED QUESTION MARK
+00D7          ; Pattern_Syntax # Sm       MULTIPLICATION SIGN
+00F7          ; Pattern_Syntax # Sm       DIVISION SIGN
+2010..2015    ; Pattern_Syntax # Pd   [6] HYPHEN..HORIZONTAL BAR
+2016..2017    ; Pattern_Syntax # Po   [2] DOUBLE VERTICAL LINE..DOUBLE LOW LINE
+2018          ; Pattern_Syntax # Pi       LEFT SINGLE QUOTATION MARK
+2019          ; Pattern_Syntax # Pf       RIGHT SINGLE QUOTATION MARK
+201A          ; Pattern_Syntax # Ps       SINGLE LOW-9 QUOTATION MARK
+201B..201C    ; Pattern_Syntax # Pi   [2] SINGLE HIGH-REVERSED-9 QUOTATION MARK..LEFT DOUBLE QUOTATION MARK
+201D          ; Pattern_Syntax # Pf       RIGHT DOUBLE QUOTATION MARK
+201E          ; Pattern_Syntax # Ps       DOUBLE LOW-9 QUOTATION MARK
+201F          ; Pattern_Syntax # Pi       DOUBLE HIGH-REVERSED-9 QUOTATION MARK
+2020..2027    ; Pattern_Syntax # Po   [8] DAGGER..HYPHENATION POINT
+2030..2038    ; Pattern_Syntax # Po   [9] PER MILLE SIGN..CARET
+2039          ; Pattern_Syntax # Pi       SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+203A          ; Pattern_Syntax # Pf       SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+203B..203E    ; Pattern_Syntax # Po   [4] REFERENCE MARK..OVERLINE
+2041..2043    ; Pattern_Syntax # Po   [3] CARET INSERTION POINT..HYPHEN BULLET
+2044          ; Pattern_Syntax # Sm       FRACTION SLASH
+2045          ; Pattern_Syntax # Ps       LEFT SQUARE BRACKET WITH QUILL
+2046          ; Pattern_Syntax # Pe       RIGHT SQUARE BRACKET WITH QUILL
+2047..2051    ; Pattern_Syntax # Po  [11] DOUBLE QUESTION MARK..TWO ASTERISKS ALIGNED VERTICALLY
+2052          ; Pattern_Syntax # Sm       COMMERCIAL MINUS SIGN
+2053          ; Pattern_Syntax # Po       SWUNG DASH
+2055..205E    ; Pattern_Syntax # Po  [10] FLOWER PUNCTUATION MARK..VERTICAL FOUR DOTS
+2190..2194    ; Pattern_Syntax # Sm   [5] LEFTWARDS ARROW..LEFT RIGHT ARROW
+2195..2199    ; Pattern_Syntax # So   [5] UP DOWN ARROW..SOUTH WEST ARROW
+219A..219B    ; Pattern_Syntax # Sm   [2] LEFTWARDS ARROW WITH STROKE..RIGHTWARDS ARROW WITH STROKE
+219C..219F    ; Pattern_Syntax # So   [4] LEFTWARDS WAVE ARROW..UPWARDS TWO HEADED ARROW
+21A0          ; Pattern_Syntax # Sm       RIGHTWARDS TWO HEADED ARROW
+21A1..21A2    ; Pattern_Syntax # So   [2] DOWNWARDS TWO HEADED ARROW..LEFTWARDS ARROW WITH TAIL
+21A3          ; Pattern_Syntax # Sm       RIGHTWARDS ARROW WITH TAIL
+21A4..21A5    ; Pattern_Syntax # So   [2] LEFTWARDS ARROW FROM BAR..UPWARDS ARROW FROM BAR
+21A6          ; Pattern_Syntax # Sm       RIGHTWARDS ARROW FROM BAR
+21A7..21AD    ; Pattern_Syntax # So   [7] DOWNWARDS ARROW FROM BAR..LEFT RIGHT WAVE ARROW
+21AE          ; Pattern_Syntax # Sm       LEFT RIGHT ARROW WITH STROKE
+21AF..21CD    ; Pattern_Syntax # So  [31] DOWNWARDS ZIGZAG ARROW..LEFTWARDS DOUBLE ARROW WITH STROKE
+21CE..21CF    ; Pattern_Syntax # Sm   [2] LEFT RIGHT DOUBLE ARROW WITH STROKE..RIGHTWARDS DOUBLE ARROW WITH STROKE
+21D0..21D1    ; Pattern_Syntax # So   [2] LEFTWARDS DOUBLE ARROW..UPWARDS DOUBLE ARROW
+21D2          ; Pattern_Syntax # Sm       RIGHTWARDS DOUBLE ARROW
+21D3          ; Pattern_Syntax # So       DOWNWARDS DOUBLE ARROW
+21D4          ; Pattern_Syntax # Sm       LEFT RIGHT DOUBLE ARROW
+21D5..21F3    ; Pattern_Syntax # So  [31] UP DOWN DOUBLE ARROW..UP DOWN WHITE ARROW
+21F4..22FF    ; Pattern_Syntax # Sm [268] RIGHT ARROW WITH SMALL CIRCLE..Z NOTATION BAG MEMBERSHIP
+2300..2307    ; Pattern_Syntax # So   [8] DIAMETER SIGN..WAVY LINE
+2308          ; Pattern_Syntax # Ps       LEFT CEILING
+2309          ; Pattern_Syntax # Pe       RIGHT CEILING
+230A          ; Pattern_Syntax # Ps       LEFT FLOOR
+230B          ; Pattern_Syntax # Pe       RIGHT FLOOR
+230C..231F    ; Pattern_Syntax # So  [20] BOTTOM RIGHT CROP..BOTTOM RIGHT CORNER
+2320..2321    ; Pattern_Syntax # Sm   [2] TOP HALF INTEGRAL..BOTTOM HALF INTEGRAL
+2322..2328    ; Pattern_Syntax # So   [7] FROWN..KEYBOARD
+2329          ; Pattern_Syntax # Ps       LEFT-POINTING ANGLE BRACKET
+232A          ; Pattern_Syntax # Pe       RIGHT-POINTING ANGLE BRACKET
+232B..237B    ; Pattern_Syntax # So  [81] ERASE TO THE LEFT..NOT CHECK MARK
+237C          ; Pattern_Syntax # Sm       RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW
+237D..239A    ; Pattern_Syntax # So  [30] SHOULDERED OPEN BOX..CLEAR SCREEN SYMBOL
+239B..23B3    ; Pattern_Syntax # Sm  [25] LEFT PARENTHESIS UPPER HOOK..SUMMATION BOTTOM
+23B4..23DB    ; Pattern_Syntax # So  [40] TOP SQUARE BRACKET..FUSE
+23DC..23E1    ; Pattern_Syntax # Sm   [6] TOP PARENTHESIS..BOTTOM TORTOISE SHELL BRACKET
+23E2..2429    ; Pattern_Syntax # So  [72] WHITE TRAPEZIUM..SYMBOL FOR DELETE MEDIUM SHADE FORM
+242A..243F    ; Pattern_Syntax # Cn  [22] <reserved-242A>..<reserved-243F>
+2440..244A    ; Pattern_Syntax # So  [11] OCR HOOK..OCR DOUBLE BACKSLASH
+244B..245F    ; Pattern_Syntax # Cn  [21] <reserved-244B>..<reserved-245F>
+2500..25B6    ; Pattern_Syntax # So [183] BOX DRAWINGS LIGHT HORIZONTAL..BLACK RIGHT-POINTING TRIANGLE
+25B7          ; Pattern_Syntax # Sm       WHITE RIGHT-POINTING TRIANGLE
+25B8..25C0    ; Pattern_Syntax # So   [9] BLACK RIGHT-POINTING SMALL TRIANGLE..BLACK LEFT-POINTING TRIANGLE
+25C1          ; Pattern_Syntax # Sm       WHITE LEFT-POINTING TRIANGLE
+25C2..25F7    ; Pattern_Syntax # So  [54] BLACK LEFT-POINTING SMALL TRIANGLE..WHITE CIRCLE WITH UPPER RIGHT QUADRANT
+25F8..25FF    ; Pattern_Syntax # Sm   [8] UPPER LEFT TRIANGLE..LOWER RIGHT TRIANGLE
+2600..266E    ; Pattern_Syntax # So [111] BLACK SUN WITH RAYS..MUSIC NATURAL SIGN
+266F          ; Pattern_Syntax # Sm       MUSIC SHARP SIGN
+2670..2767    ; Pattern_Syntax # So [248] WEST SYRIAC CROSS..ROTATED FLORAL HEART BULLET
+2768          ; Pattern_Syntax # Ps       MEDIUM LEFT PARENTHESIS ORNAMENT
+2769          ; Pattern_Syntax # Pe       MEDIUM RIGHT PARENTHESIS ORNAMENT
+276A          ; Pattern_Syntax # Ps       MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT
+276B          ; Pattern_Syntax # Pe       MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT
+276C          ; Pattern_Syntax # Ps       MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT
+276D          ; Pattern_Syntax # Pe       MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT
+276E          ; Pattern_Syntax # Ps       HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT
+276F          ; Pattern_Syntax # Pe       HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT
+2770          ; Pattern_Syntax # Ps       HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT
+2771          ; Pattern_Syntax # Pe       HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT
+2772          ; Pattern_Syntax # Ps       LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT
+2773          ; Pattern_Syntax # Pe       LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT
+2774          ; Pattern_Syntax # Ps       MEDIUM LEFT CURLY BRACKET ORNAMENT
+2775          ; Pattern_Syntax # Pe       MEDIUM RIGHT CURLY BRACKET ORNAMENT
+2794..27BF    ; Pattern_Syntax # So  [44] HEAVY WIDE-HEADED RIGHTWARDS ARROW..DOUBLE CURLY LOOP
+27C0..27C4    ; Pattern_Syntax # Sm   [5] THREE DIMENSIONAL ANGLE..OPEN SUPERSET
+27C5          ; Pattern_Syntax # Ps       LEFT S-SHAPED BAG DELIMITER
+27C6          ; Pattern_Syntax # Pe       RIGHT S-SHAPED BAG DELIMITER
+27C7..27E5    ; Pattern_Syntax # Sm  [31] OR WITH DOT INSIDE..WHITE SQUARE WITH RIGHTWARDS TICK
+27E6          ; Pattern_Syntax # Ps       MATHEMATICAL LEFT WHITE SQUARE BRACKET
+27E7          ; Pattern_Syntax # Pe       MATHEMATICAL RIGHT WHITE SQUARE BRACKET
+27E8          ; Pattern_Syntax # Ps       MATHEMATICAL LEFT ANGLE BRACKET
+27E9          ; Pattern_Syntax # Pe       MATHEMATICAL RIGHT ANGLE BRACKET
+27EA          ; Pattern_Syntax # Ps       MATHEMATICAL LEFT DOUBLE ANGLE BRACKET
+27EB          ; Pattern_Syntax # Pe       MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET
+27EC          ; Pattern_Syntax # Ps       MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET
+27ED          ; Pattern_Syntax # Pe       MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET
+27EE          ; Pattern_Syntax # Ps       MATHEMATICAL LEFT FLATTENED PARENTHESIS
+27EF          ; Pattern_Syntax # Pe       MATHEMATICAL RIGHT FLATTENED PARENTHESIS
+27F0..27FF    ; Pattern_Syntax # Sm  [16] UPWARDS QUADRUPLE ARROW..LONG RIGHTWARDS SQUIGGLE ARROW
+2800..28FF    ; Pattern_Syntax # So [256] BRAILLE PATTERN BLANK..BRAILLE PATTERN DOTS-12345678
+2900..2982    ; Pattern_Syntax # Sm [131] RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE..Z NOTATION TYPE COLON
+2983          ; Pattern_Syntax # Ps       LEFT WHITE CURLY BRACKET
+2984          ; Pattern_Syntax # Pe       RIGHT WHITE CURLY BRACKET
+2985          ; Pattern_Syntax # Ps       LEFT WHITE PARENTHESIS
+2986          ; Pattern_Syntax # Pe       RIGHT WHITE PARENTHESIS
+2987          ; Pattern_Syntax # Ps       Z NOTATION LEFT IMAGE BRACKET
+2988          ; Pattern_Syntax # Pe       Z NOTATION RIGHT IMAGE BRACKET
+2989          ; Pattern_Syntax # Ps       Z NOTATION LEFT BINDING BRACKET
+298A          ; Pattern_Syntax # Pe       Z NOTATION RIGHT BINDING BRACKET
+298B          ; Pattern_Syntax # Ps       LEFT SQUARE BRACKET WITH UNDERBAR
+298C          ; Pattern_Syntax # Pe       RIGHT SQUARE BRACKET WITH UNDERBAR
+298D          ; Pattern_Syntax # Ps       LEFT SQUARE BRACKET WITH TICK IN TOP CORNER
+298E          ; Pattern_Syntax # Pe       RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+298F          ; Pattern_Syntax # Ps       LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+2990          ; Pattern_Syntax # Pe       RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER
+2991          ; Pattern_Syntax # Ps       LEFT ANGLE BRACKET WITH DOT
+2992          ; Pattern_Syntax # Pe       RIGHT ANGLE BRACKET WITH DOT
+2993          ; Pattern_Syntax # Ps       LEFT ARC LESS-THAN BRACKET
+2994          ; Pattern_Syntax # Pe       RIGHT ARC GREATER-THAN BRACKET
+2995          ; Pattern_Syntax # Ps       DOUBLE LEFT ARC GREATER-THAN BRACKET
+2996          ; Pattern_Syntax # Pe       DOUBLE RIGHT ARC LESS-THAN BRACKET
+2997          ; Pattern_Syntax # Ps       LEFT BLACK TORTOISE SHELL BRACKET
+2998          ; Pattern_Syntax # Pe       RIGHT BLACK TORTOISE SHELL BRACKET
+2999..29D7    ; Pattern_Syntax # Sm  [63] DOTTED FENCE..BLACK HOURGLASS
+29D8          ; Pattern_Syntax # Ps       LEFT WIGGLY FENCE
+29D9          ; Pattern_Syntax # Pe       RIGHT WIGGLY FENCE
+29DA          ; Pattern_Syntax # Ps       LEFT DOUBLE WIGGLY FENCE
+29DB          ; Pattern_Syntax # Pe       RIGHT DOUBLE WIGGLY FENCE
+29DC..29FB    ; Pattern_Syntax # Sm  [32] INCOMPLETE INFINITY..TRIPLE PLUS
+29FC          ; Pattern_Syntax # Ps       LEFT-POINTING CURVED ANGLE BRACKET
+29FD          ; Pattern_Syntax # Pe       RIGHT-POINTING CURVED ANGLE BRACKET
+29FE..2AFF    ; Pattern_Syntax # Sm [258] TINY..N-ARY WHITE VERTICAL BAR
+2B00..2B2F    ; Pattern_Syntax # So  [48] NORTH EAST WHITE ARROW..WHITE VERTICAL ELLIPSE
+2B30..2B44    ; Pattern_Syntax # Sm  [21] LEFT ARROW WITH SMALL CIRCLE..RIGHTWARDS ARROW THROUGH SUPERSET
+2B45..2B46    ; Pattern_Syntax # So   [2] LEFTWARDS QUADRUPLE ARROW..RIGHTWARDS QUADRUPLE ARROW
+2B47..2B4C    ; Pattern_Syntax # Sm   [6] REVERSE TILDE OPERATOR ABOVE RIGHTWARDS ARROW..RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR
+2B4D..2B73    ; Pattern_Syntax # So  [39] DOWNWARDS TRIANGLE-HEADED ZIGZAG ARROW..DOWNWARDS TRIANGLE-HEADED ARROW TO BAR
+2B74..2B75    ; Pattern_Syntax # Cn   [2] <reserved-2B74>..<reserved-2B75>
+2B76..2BFF    ; Pattern_Syntax # So [138] NORTH WEST TRIANGLE-HEADED ARROW TO BAR..HELLSCHREIBER PAUSE SYMBOL
+2E00..2E01    ; Pattern_Syntax # Po   [2] RIGHT ANGLE SUBSTITUTION MARKER..RIGHT ANGLE DOTTED SUBSTITUTION MARKER
+2E02          ; Pattern_Syntax # Pi       LEFT SUBSTITUTION BRACKET
+2E03          ; Pattern_Syntax # Pf       RIGHT SUBSTITUTION BRACKET
+2E04          ; Pattern_Syntax # Pi       LEFT DOTTED SUBSTITUTION BRACKET
+2E05          ; Pattern_Syntax # Pf       RIGHT DOTTED SUBSTITUTION BRACKET
+2E06..2E08    ; Pattern_Syntax # Po   [3] RAISED INTERPOLATION MARKER..DOTTED TRANSPOSITION MARKER
+2E09          ; Pattern_Syntax # Pi       LEFT TRANSPOSITION BRACKET
+2E0A          ; Pattern_Syntax # Pf       RIGHT TRANSPOSITION BRACKET
+2E0B          ; Pattern_Syntax # Po       RAISED SQUARE
+2E0C          ; Pattern_Syntax # Pi       LEFT RAISED OMISSION BRACKET
+2E0D          ; Pattern_Syntax # Pf       RIGHT RAISED OMISSION BRACKET
+2E0E..2E16    ; Pattern_Syntax # Po   [9] EDITORIAL CORONIS..DOTTED RIGHT-POINTING ANGLE
+2E17          ; Pattern_Syntax # Pd       DOUBLE OBLIQUE HYPHEN
+2E18..2E19    ; Pattern_Syntax # Po   [2] INVERTED INTERROBANG..PALM BRANCH
+2E1A          ; Pattern_Syntax # Pd       HYPHEN WITH DIAERESIS
+2E1B          ; Pattern_Syntax # Po       TILDE WITH RING ABOVE
+2E1C          ; Pattern_Syntax # Pi       LEFT LOW PARAPHRASE BRACKET
+2E1D          ; Pattern_Syntax # Pf       RIGHT LOW PARAPHRASE BRACKET
+2E1E..2E1F    ; Pattern_Syntax # Po   [2] TILDE WITH DOT ABOVE..TILDE WITH DOT BELOW
+2E20          ; Pattern_Syntax # Pi       LEFT VERTICAL BAR WITH QUILL
+2E21          ; Pattern_Syntax # Pf       RIGHT VERTICAL BAR WITH QUILL
+2E22          ; Pattern_Syntax # Ps       TOP LEFT HALF BRACKET
+2E23          ; Pattern_Syntax # Pe       TOP RIGHT HALF BRACKET
+2E24          ; Pattern_Syntax # Ps       BOTTOM LEFT HALF BRACKET
+2E25          ; Pattern_Syntax # Pe       BOTTOM RIGHT HALF BRACKET
+2E26          ; Pattern_Syntax # Ps       LEFT SIDEWAYS U BRACKET
+2E27          ; Pattern_Syntax # Pe       RIGHT SIDEWAYS U BRACKET
+2E28          ; Pattern_Syntax # Ps       LEFT DOUBLE PARENTHESIS
+2E29          ; Pattern_Syntax # Pe       RIGHT DOUBLE PARENTHESIS
+2E2A..2E2E    ; Pattern_Syntax # Po   [5] TWO DOTS OVER ONE DOT PUNCTUATION..REVERSED QUESTION MARK
+2E2F          ; Pattern_Syntax # Lm       VERTICAL TILDE
+2E30..2E39    ; Pattern_Syntax # Po  [10] RING POINT..TOP HALF SECTION SIGN
+2E3A..2E3B    ; Pattern_Syntax # Pd   [2] TWO-EM DASH..THREE-EM DASH
+2E3C..2E3F    ; Pattern_Syntax # Po   [4] STENOGRAPHIC FULL STOP..CAPITULUM
+2E40          ; Pattern_Syntax # Pd       DOUBLE HYPHEN
+2E41          ; Pattern_Syntax # Po       REVERSED COMMA
+2E42          ; Pattern_Syntax # Ps       DOUBLE LOW-REVERSED-9 QUOTATION MARK
+2E43..2E4F    ; Pattern_Syntax # Po  [13] DASH WITH LEFT UPTURN..CORNISH VERSE DIVIDER
+2E50..2E51    ; Pattern_Syntax # So   [2] CROSS PATTY WITH RIGHT CROSSBAR..CROSS PATTY WITH LEFT CROSSBAR
+2E52..2E54    ; Pattern_Syntax # Po   [3] TIRONIAN SIGN CAPITAL ET..MEDIEVAL QUESTION MARK
+2E55          ; Pattern_Syntax # Ps       LEFT SQUARE BRACKET WITH STROKE
+2E56          ; Pattern_Syntax # Pe       RIGHT SQUARE BRACKET WITH STROKE
+2E57          ; Pattern_Syntax # Ps       LEFT SQUARE BRACKET WITH DOUBLE STROKE
+2E58          ; Pattern_Syntax # Pe       RIGHT SQUARE BRACKET WITH DOUBLE STROKE
+2E59          ; Pattern_Syntax # Ps       TOP HALF LEFT PARENTHESIS
+2E5A          ; Pattern_Syntax # Pe       TOP HALF RIGHT PARENTHESIS
+2E5B          ; Pattern_Syntax # Ps       BOTTOM HALF LEFT PARENTHESIS
+2E5C          ; Pattern_Syntax # Pe       BOTTOM HALF RIGHT PARENTHESIS
+2E5D          ; Pattern_Syntax # Pd       OBLIQUE HYPHEN
+2E5E..2E7F    ; Pattern_Syntax # Cn  [34] <reserved-2E5E>..<reserved-2E7F>
+3001..3003    ; Pattern_Syntax # Po   [3] IDEOGRAPHIC COMMA..DITTO MARK
+3008          ; Pattern_Syntax # Ps       LEFT ANGLE BRACKET
+3009          ; Pattern_Syntax # Pe       RIGHT ANGLE BRACKET
+300A          ; Pattern_Syntax # Ps       LEFT DOUBLE ANGLE BRACKET
+300B          ; Pattern_Syntax # Pe       RIGHT DOUBLE ANGLE BRACKET
+300C          ; Pattern_Syntax # Ps       LEFT CORNER BRACKET
+300D          ; Pattern_Syntax # Pe       RIGHT CORNER BRACKET
+300E          ; Pattern_Syntax # Ps       LEFT WHITE CORNER BRACKET
+300F          ; Pattern_Syntax # Pe       RIGHT WHITE CORNER BRACKET
+3010          ; Pattern_Syntax # Ps       LEFT BLACK LENTICULAR BRACKET
+3011          ; Pattern_Syntax # Pe       RIGHT BLACK LENTICULAR BRACKET
+3012..3013    ; Pattern_Syntax # So   [2] POSTAL MARK..GETA MARK
+3014          ; Pattern_Syntax # Ps       LEFT TORTOISE SHELL BRACKET
+3015          ; Pattern_Syntax # Pe       RIGHT TORTOISE SHELL BRACKET
+3016          ; Pattern_Syntax # Ps       LEFT WHITE LENTICULAR BRACKET
+3017          ; Pattern_Syntax # Pe       RIGHT WHITE LENTICULAR BRACKET
+3018          ; Pattern_Syntax # Ps       LEFT WHITE TORTOISE SHELL BRACKET
+3019          ; Pattern_Syntax # Pe       RIGHT WHITE TORTOISE SHELL BRACKET
+301A          ; Pattern_Syntax # Ps       LEFT WHITE SQUARE BRACKET
+301B          ; Pattern_Syntax # Pe       RIGHT WHITE SQUARE BRACKET
+301C          ; Pattern_Syntax # Pd       WAVE DASH
+301D          ; Pattern_Syntax # Ps       REVERSED DOUBLE PRIME QUOTATION MARK
+301E..301F    ; Pattern_Syntax # Pe   [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK
+3020          ; Pattern_Syntax # So       POSTAL MARK FACE
+3030          ; Pattern_Syntax # Pd       WAVY DASH
+FD3E          ; Pattern_Syntax # Pe       ORNATE LEFT PARENTHESIS
+FD3F          ; Pattern_Syntax # Ps       ORNATE RIGHT PARENTHESIS
+FE45..FE46    ; Pattern_Syntax # Po   [2] SESAME DOT..WHITE SESAME DOT
+
+# Total code points: 2760
+
+# ================================================
+
+0600..0605    ; Prepended_Concatenation_Mark # Cf   [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE
+06DD          ; Prepended_Concatenation_Mark # Cf       ARABIC END OF AYAH
+070F          ; Prepended_Concatenation_Mark # Cf       SYRIAC ABBREVIATION MARK
+0890..0891    ; Prepended_Concatenation_Mark # Cf   [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE
+08E2          ; Prepended_Concatenation_Mark # Cf       ARABIC DISPUTED END OF AYAH
+110BD         ; Prepended_Concatenation_Mark # Cf       KAITHI NUMBER SIGN
+110CD         ; Prepended_Concatenation_Mark # Cf       KAITHI NUMBER SIGN ABOVE
+
+# Total code points: 13
+
+# ================================================
+
+1F1E6..1F1FF  ; Regional_Indicator # So  [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z
+
+# Total code points: 26
+
+# ================================================
+
+0654..0655    ; Modifier_Combining_Mark # Mn   [2] ARABIC HAMZA ABOVE..ARABIC HAMZA BELOW
+0658          ; Modifier_Combining_Mark # Mn       ARABIC MARK NOON GHUNNA
+06DC          ; Modifier_Combining_Mark # Mn       ARABIC SMALL HIGH SEEN
+06E3          ; Modifier_Combining_Mark # Mn       ARABIC SMALL LOW SEEN
+06E7..06E8    ; Modifier_Combining_Mark # Mn   [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON
+08CA..08CB    ; Modifier_Combining_Mark # Mn   [2] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL HIGH YEH BARREE WITH TWO DOTS BELOW
+08CD..08CF    ; Modifier_Combining_Mark # Mn   [3] ARABIC SMALL HIGH ZAH..ARABIC LARGE ROUND DOT BELOW
+08D3          ; Modifier_Combining_Mark # Mn       ARABIC SMALL LOW WAW
+08F3          ; Modifier_Combining_Mark # Mn       ARABIC SMALL HIGH WAW
+
+# Total code points: 14
+
+# EOF
diff --git a/lib/elixir/unicode/PropertyValueAliases.txt b/lib/elixir/unicode/PropertyValueAliases.txt
new file mode 100644
index 00000000000..b92662eda28
--- /dev/null
+++ b/lib/elixir/unicode/PropertyValueAliases.txt
@@ -0,0 +1,1735 @@
+# PropertyValueAliases-17.0.0.txt
+# Date: 2025-06-30, 06:16:21 GMT
+# © 2025 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use and license, see https://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+#   For documentation, see https://www.unicode.org/reports/tr44/
+#
+# This file contains aliases for property values used in the UCD.
+# These names can be used for XML formats of UCD data, for regular-expression
+# property tests, and other programmatic textual descriptions of Unicode data.
+#
+# The names may be translated in appropriate environments, and additional
+# aliases may be useful.
+#
+# FORMAT
+#
+# Each line describes a property value name.
+# This consists of three or more fields, separated by semicolons.
+#
+# First Field: The first field describes the property for which that
+# property value name is used.
+#
+# Second Field: The second field is the short name for the property value.
+# It is typically an abbreviation, but in a number of cases it is simply
+# a duplicate of the "long name" in the third field.
+#
+# Third Field: The third field is the long name for the property value, 
+# typically the formal name used in documentation about the property value.
+#
+# In the case of Canonical_Combining_Class (ccc), there are 4 fields: 
+# The second field is numeric, the third is the short name, and the fourth is the long name.
+#
+# The above are the preferred aliases. Other aliases may be listed in additional fields.
+#
+# Loose matching should be applied to all property names and property values, with
+# the exception of String Property values. With loose matching of property names and
+# values, the case distinctions, whitespace, hyphens, and '_' are ignored.
+# For Numeric Property values, numeric equivalence is applied: thus "01.00"
+# is equivalent to "1".
+#
+# NOTE: Property value names are NOT unique across properties. For example:
+#
+#   AL means Arabic Letter for the Bidi_Class property, and
+#   AL means Above_Left for the Canonical_Combining_Class property, and
+#   AL means Alphabetic for the Line_Break property.
+#
+# In addition, some property names may be the same as some property value names.
+# For example:
+#
+#   sc means the Script property, and
+#   Sc means the General_Category property value Currency_Symbol (Sc)
+#
+# The combination of property value and property name is, however, unique.
+#
+# For more information, see UAX #44, Unicode Character Database, and
+# UTS #18, Unicode Regular Expressions.
+# ================================================
+
+
+# ASCII_Hex_Digit (AHex)
+
+AHex; N                               ; No                               ; F                                ; False
+AHex; Y                               ; Yes                              ; T                                ; True
+
+# Age (age)
+
+age; 1.1                              ; V1_1
+age; 2.0                              ; V2_0
+age; 2.1                              ; V2_1
+age; 3.0                              ; V3_0
+age; 3.1                              ; V3_1
+age; 3.2                              ; V3_2
+age; 4.0                              ; V4_0
+age; 4.1                              ; V4_1
+age; 5.0                              ; V5_0
+age; 5.1                              ; V5_1
+age; 5.2                              ; V5_2
+age; 6.0                              ; V6_0
+age; 6.1                              ; V6_1
+age; 6.2                              ; V6_2
+age; 6.3                              ; V6_3
+age; 7.0                              ; V7_0
+age; 8.0                              ; V8_0
+age; 9.0                              ; V9_0
+age; 10.0                             ; V10_0
+age; 11.0                             ; V11_0
+age; 12.0                             ; V12_0
+age; 12.1                             ; V12_1
+age; 13.0                             ; V13_0
+age; 14.0                             ; V14_0
+age; 15.0                             ; V15_0
+age; 15.1                             ; V15_1
+age; 16.0                             ; V16_0
+age; 17.0                             ; V17_0
+age; NA                               ; Unassigned
+
+# Alphabetic (Alpha)
+
+Alpha; N                              ; No                               ; F                                ; False
+Alpha; Y                              ; Yes                              ; T                                ; True
+
+# Bidi_Class (bc)
+
+bc ; AL                               ; Arabic_Letter
+bc ; AN                               ; Arabic_Number
+bc ; B                                ; Paragraph_Separator
+bc ; BN                               ; Boundary_Neutral
+bc ; CS                               ; Common_Separator
+bc ; EN                               ; European_Number
+bc ; ES                               ; European_Separator
+bc ; ET                               ; European_Terminator
+bc ; FSI                              ; First_Strong_Isolate
+bc ; L                                ; Left_To_Right
+bc ; LRE                              ; Left_To_Right_Embedding
+bc ; LRI                              ; Left_To_Right_Isolate
+bc ; LRO                              ; Left_To_Right_Override
+bc ; NSM                              ; Nonspacing_Mark
+bc ; ON                               ; Other_Neutral
+bc ; PDF                              ; Pop_Directional_Format
+bc ; PDI                              ; Pop_Directional_Isolate
+bc ; R                                ; Right_To_Left
+bc ; RLE                              ; Right_To_Left_Embedding
+bc ; RLI                              ; Right_To_Left_Isolate
+bc ; RLO                              ; Right_To_Left_Override
+bc ; S                                ; Segment_Separator
+bc ; WS                               ; White_Space
+
+# Bidi_Control (Bidi_C)
+
+Bidi_C; N                             ; No                               ; F                                ; False
+Bidi_C; Y                             ; Yes                              ; T                                ; True
+
+# Bidi_Mirrored (Bidi_M)
+
+Bidi_M; N                             ; No                               ; F                                ; False
+Bidi_M; Y                             ; Yes                              ; T                                ; True
+
+# Bidi_Mirroring_Glyph (bmg)
+
+
+# Bidi_Paired_Bracket (bpb)
+
+# @missing: 0000..10FFFF; Bidi_Paired_Bracket; <none>
+
+# Bidi_Paired_Bracket_Type (bpt)
+
+bpt; c                                ; Close
+bpt; n                                ; None
+bpt; o                                ; Open
+# @missing: 0000..10FFFF; Bidi_Paired_Bracket_Type; n
+
+# Block (blk)
+
+blk; Adlam                            ; Adlam
+blk; Aegean_Numbers                   ; Aegean_Numbers
+blk; Ahom                             ; Ahom
+blk; Alchemical                       ; Alchemical_Symbols
+blk; Alphabetic_PF                    ; Alphabetic_Presentation_Forms
+blk; Anatolian_Hieroglyphs            ; Anatolian_Hieroglyphs
+blk; Ancient_Greek_Music              ; Ancient_Greek_Musical_Notation
+blk; Ancient_Greek_Numbers            ; Ancient_Greek_Numbers
+blk; Ancient_Symbols                  ; Ancient_Symbols
+blk; Arabic                           ; Arabic
+blk; Arabic_Ext_A                     ; Arabic_Extended_A
+blk; Arabic_Ext_B                     ; Arabic_Extended_B
+blk; Arabic_Ext_C                     ; Arabic_Extended_C
+blk; Arabic_Math                      ; Arabic_Mathematical_Alphabetic_Symbols
+blk; Arabic_PF_A                      ; Arabic_Presentation_Forms_A      ; Arabic_Presentation_Forms-A
+blk; Arabic_PF_B                      ; Arabic_Presentation_Forms_B
+blk; Arabic_Sup                       ; Arabic_Supplement
+blk; Armenian                         ; Armenian
+blk; Arrows                           ; Arrows
+blk; ASCII                            ; Basic_Latin
+blk; Avestan                          ; Avestan
+blk; Balinese                         ; Balinese
+blk; Bamum                            ; Bamum
+blk; Bamum_Sup                        ; Bamum_Supplement
+blk; Bassa_Vah                        ; Bassa_Vah
+blk; Batak                            ; Batak
+blk; Bengali                          ; Bengali
+blk; Beria_Erfe                       ; Beria_Erfe
+blk; Bhaiksuki                        ; Bhaiksuki
+blk; Block_Elements                   ; Block_Elements
+blk; Bopomofo                         ; Bopomofo
+blk; Bopomofo_Ext                     ; Bopomofo_Extended
+blk; Box_Drawing                      ; Box_Drawing
+blk; Brahmi                           ; Brahmi
+blk; Braille                          ; Braille_Patterns
+blk; Buginese                         ; Buginese
+blk; Buhid                            ; Buhid
+blk; Byzantine_Music                  ; Byzantine_Musical_Symbols
+blk; Carian                           ; Carian
+blk; Caucasian_Albanian               ; Caucasian_Albanian
+blk; Chakma                           ; Chakma
+blk; Cham                             ; Cham
+blk; Cherokee                         ; Cherokee
+blk; Cherokee_Sup                     ; Cherokee_Supplement
+blk; Chess_Symbols                    ; Chess_Symbols
+blk; Chorasmian                       ; Chorasmian
+blk; CJK                              ; CJK_Unified_Ideographs
+blk; CJK_Compat                       ; CJK_Compatibility
+blk; CJK_Compat_Forms                 ; CJK_Compatibility_Forms
+blk; CJK_Compat_Ideographs            ; CJK_Compatibility_Ideographs
+blk; CJK_Compat_Ideographs_Sup        ; CJK_Compatibility_Ideographs_Supplement
+blk; CJK_Ext_A                        ; CJK_Unified_Ideographs_Extension_A
+blk; CJK_Ext_B                        ; CJK_Unified_Ideographs_Extension_B
+blk; CJK_Ext_C                        ; CJK_Unified_Ideographs_Extension_C
+blk; CJK_Ext_D                        ; CJK_Unified_Ideographs_Extension_D
+blk; CJK_Ext_E                        ; CJK_Unified_Ideographs_Extension_E
+blk; CJK_Ext_F                        ; CJK_Unified_Ideographs_Extension_F
+blk; CJK_Ext_G                        ; CJK_Unified_Ideographs_Extension_G
+blk; CJK_Ext_H                        ; CJK_Unified_Ideographs_Extension_H
+blk; CJK_Ext_I                        ; CJK_Unified_Ideographs_Extension_I
+blk; CJK_Ext_J                        ; CJK_Unified_Ideographs_Extension_J
+blk; CJK_Radicals_Sup                 ; CJK_Radicals_Supplement
+blk; CJK_Strokes                      ; CJK_Strokes
+blk; CJK_Symbols                      ; CJK_Symbols_And_Punctuation
+blk; Compat_Jamo                      ; Hangul_Compatibility_Jamo
+blk; Control_Pictures                 ; Control_Pictures
+blk; Coptic                           ; Coptic
+blk; Coptic_Epact_Numbers             ; Coptic_Epact_Numbers
+blk; Counting_Rod                     ; Counting_Rod_Numerals
+blk; Cuneiform                        ; Cuneiform
+blk; Cuneiform_Numbers                ; Cuneiform_Numbers_And_Punctuation
+blk; Currency_Symbols                 ; Currency_Symbols
+blk; Cypriot_Syllabary                ; Cypriot_Syllabary
+blk; Cypro_Minoan                     ; Cypro_Minoan
+blk; Cyrillic                         ; Cyrillic
+blk; Cyrillic_Ext_A                   ; Cyrillic_Extended_A
+blk; Cyrillic_Ext_B                   ; Cyrillic_Extended_B
+blk; Cyrillic_Ext_C                   ; Cyrillic_Extended_C
+blk; Cyrillic_Ext_D                   ; Cyrillic_Extended_D
+blk; Cyrillic_Sup                     ; Cyrillic_Supplement              ; Cyrillic_Supplementary
+blk; Deseret                          ; Deseret
+blk; Devanagari                       ; Devanagari
+blk; Devanagari_Ext                   ; Devanagari_Extended
+blk; Devanagari_Ext_A                 ; Devanagari_Extended_A
+blk; Diacriticals                     ; Combining_Diacritical_Marks
+blk; Diacriticals_Ext                 ; Combining_Diacritical_Marks_Extended
+blk; Diacriticals_For_Symbols         ; Combining_Diacritical_Marks_For_Symbols; Combining_Marks_For_Symbols
+blk; Diacriticals_Sup                 ; Combining_Diacritical_Marks_Supplement
+blk; Dingbats                         ; Dingbats
+blk; Dives_Akuru                      ; Dives_Akuru
+blk; Dogra                            ; Dogra
+blk; Domino                           ; Domino_Tiles
+blk; Duployan                         ; Duployan
+blk; Early_Dynastic_Cuneiform         ; Early_Dynastic_Cuneiform
+blk; Egyptian_Hieroglyph_Format_Controls; Egyptian_Hieroglyph_Format_Controls
+blk; Egyptian_Hieroglyphs             ; Egyptian_Hieroglyphs
+blk; Egyptian_Hieroglyphs_Ext_A       ; Egyptian_Hieroglyphs_Extended_A
+blk; Elbasan                          ; Elbasan
+blk; Elymaic                          ; Elymaic
+blk; Emoticons                        ; Emoticons
+blk; Enclosed_Alphanum                ; Enclosed_Alphanumerics
+blk; Enclosed_Alphanum_Sup            ; Enclosed_Alphanumeric_Supplement
+blk; Enclosed_CJK                     ; Enclosed_CJK_Letters_And_Months
+blk; Enclosed_Ideographic_Sup         ; Enclosed_Ideographic_Supplement
+blk; Ethiopic                         ; Ethiopic
+blk; Ethiopic_Ext                     ; Ethiopic_Extended
+blk; Ethiopic_Ext_A                   ; Ethiopic_Extended_A
+blk; Ethiopic_Ext_B                   ; Ethiopic_Extended_B
+blk; Ethiopic_Sup                     ; Ethiopic_Supplement
+blk; Garay                            ; Garay
+blk; Geometric_Shapes                 ; Geometric_Shapes
+blk; Geometric_Shapes_Ext             ; Geometric_Shapes_Extended
+blk; Georgian                         ; Georgian
+blk; Georgian_Ext                     ; Georgian_Extended
+blk; Georgian_Sup                     ; Georgian_Supplement
+blk; Glagolitic                       ; Glagolitic
+blk; Glagolitic_Sup                   ; Glagolitic_Supplement
+blk; Gothic                           ; Gothic
+blk; Grantha                          ; Grantha
+blk; Greek                            ; Greek_And_Coptic
+blk; Greek_Ext                        ; Greek_Extended
+blk; Gujarati                         ; Gujarati
+blk; Gunjala_Gondi                    ; Gunjala_Gondi
+blk; Gurmukhi                         ; Gurmukhi
+blk; Gurung_Khema                     ; Gurung_Khema
+blk; Half_And_Full_Forms              ; Halfwidth_And_Fullwidth_Forms
+blk; Half_Marks                       ; Combining_Half_Marks
+blk; Hangul                           ; Hangul_Syllables
+blk; Hanifi_Rohingya                  ; Hanifi_Rohingya
+blk; Hanunoo                          ; Hanunoo
+blk; Hatran                           ; Hatran
+blk; Hebrew                           ; Hebrew
+blk; High_PU_Surrogates               ; High_Private_Use_Surrogates
+blk; High_Surrogates                  ; High_Surrogates
+blk; Hiragana                         ; Hiragana
+blk; IDC                              ; Ideographic_Description_Characters
+blk; Ideographic_Symbols              ; Ideographic_Symbols_And_Punctuation
+blk; Imperial_Aramaic                 ; Imperial_Aramaic
+blk; Indic_Number_Forms               ; Common_Indic_Number_Forms
+blk; Indic_Siyaq_Numbers              ; Indic_Siyaq_Numbers
+blk; Inscriptional_Pahlavi            ; Inscriptional_Pahlavi
+blk; Inscriptional_Parthian           ; Inscriptional_Parthian
+blk; IPA_Ext                          ; IPA_Extensions
+blk; Jamo                             ; Hangul_Jamo
+blk; Jamo_Ext_A                       ; Hangul_Jamo_Extended_A
+blk; Jamo_Ext_B                       ; Hangul_Jamo_Extended_B
+blk; Javanese                         ; Javanese
+blk; Kaithi                           ; Kaithi
+blk; Kaktovik_Numerals                ; Kaktovik_Numerals
+blk; Kana_Ext_A                       ; Kana_Extended_A
+blk; Kana_Ext_B                       ; Kana_Extended_B
+blk; Kana_Sup                         ; Kana_Supplement
+blk; Kanbun                           ; Kanbun
+blk; Kangxi                           ; Kangxi_Radicals
+blk; Kannada                          ; Kannada
+blk; Katakana                         ; Katakana
+blk; Katakana_Ext                     ; Katakana_Phonetic_Extensions
+blk; Kawi                             ; Kawi
+blk; Kayah_Li                         ; Kayah_Li
+blk; Kharoshthi                       ; Kharoshthi
+blk; Khitan_Small_Script              ; Khitan_Small_Script
+blk; Khmer                            ; Khmer
+blk; Khmer_Symbols                    ; Khmer_Symbols
+blk; Khojki                           ; Khojki
+blk; Khudawadi                        ; Khudawadi
+blk; Kirat_Rai                        ; Kirat_Rai
+blk; Lao                              ; Lao
+blk; Latin_1_Sup                      ; Latin_1_Supplement               ; Latin_1
+blk; Latin_Ext_A                      ; Latin_Extended_A
+blk; Latin_Ext_Additional             ; Latin_Extended_Additional
+blk; Latin_Ext_B                      ; Latin_Extended_B
+blk; Latin_Ext_C                      ; Latin_Extended_C
+blk; Latin_Ext_D                      ; Latin_Extended_D
+blk; Latin_Ext_E                      ; Latin_Extended_E
+blk; Latin_Ext_F                      ; Latin_Extended_F
+blk; Latin_Ext_G                      ; Latin_Extended_G
+blk; Lepcha                           ; Lepcha
+blk; Letterlike_Symbols               ; Letterlike_Symbols
+blk; Limbu                            ; Limbu
+blk; Linear_A                         ; Linear_A
+blk; Linear_B_Ideograms               ; Linear_B_Ideograms
+blk; Linear_B_Syllabary               ; Linear_B_Syllabary
+blk; Lisu                             ; Lisu
+blk; Lisu_Sup                         ; Lisu_Supplement
+blk; Low_Surrogates                   ; Low_Surrogates
+blk; Lycian                           ; Lycian
+blk; Lydian                           ; Lydian
+blk; Mahajani                         ; Mahajani
+blk; Mahjong                          ; Mahjong_Tiles
+blk; Makasar                          ; Makasar
+blk; Malayalam                        ; Malayalam
+blk; Mandaic                          ; Mandaic
+blk; Manichaean                       ; Manichaean
+blk; Marchen                          ; Marchen
+blk; Masaram_Gondi                    ; Masaram_Gondi
+blk; Math_Alphanum                    ; Mathematical_Alphanumeric_Symbols
+blk; Math_Operators                   ; Mathematical_Operators
+blk; Mayan_Numerals                   ; Mayan_Numerals
+blk; Medefaidrin                      ; Medefaidrin
+blk; Meetei_Mayek                     ; Meetei_Mayek
+blk; Meetei_Mayek_Ext                 ; Meetei_Mayek_Extensions
+blk; Mende_Kikakui                    ; Mende_Kikakui
+blk; Meroitic_Cursive                 ; Meroitic_Cursive
+blk; Meroitic_Hieroglyphs             ; Meroitic_Hieroglyphs
+blk; Miao                             ; Miao
+blk; Misc_Arrows                      ; Miscellaneous_Symbols_And_Arrows
+blk; Misc_Math_Symbols_A              ; Miscellaneous_Mathematical_Symbols_A
+blk; Misc_Math_Symbols_B              ; Miscellaneous_Mathematical_Symbols_B
+blk; Misc_Pictographs                 ; Miscellaneous_Symbols_And_Pictographs
+blk; Misc_Symbols                     ; Miscellaneous_Symbols
+blk; Misc_Symbols_Sup                 ; Miscellaneous_Symbols_Supplement
+blk; Misc_Technical                   ; Miscellaneous_Technical
+blk; Modi                             ; Modi
+blk; Modifier_Letters                 ; Spacing_Modifier_Letters
+blk; Modifier_Tone_Letters            ; Modifier_Tone_Letters
+blk; Mongolian                        ; Mongolian
+blk; Mongolian_Sup                    ; Mongolian_Supplement
+blk; Mro                              ; Mro
+blk; Multani                          ; Multani
+blk; Music                            ; Musical_Symbols
+blk; Myanmar                          ; Myanmar
+blk; Myanmar_Ext_A                    ; Myanmar_Extended_A
+blk; Myanmar_Ext_B                    ; Myanmar_Extended_B
+blk; Myanmar_Ext_C                    ; Myanmar_Extended_C
+blk; Nabataean                        ; Nabataean
+blk; Nag_Mundari                      ; Nag_Mundari
+blk; Nandinagari                      ; Nandinagari
+blk; NB                               ; No_Block
+blk; New_Tai_Lue                      ; New_Tai_Lue
+blk; Newa                             ; Newa
+blk; NKo                              ; NKo
+blk; Number_Forms                     ; Number_Forms
+blk; Nushu                            ; Nushu
+blk; Nyiakeng_Puachue_Hmong           ; Nyiakeng_Puachue_Hmong
+blk; OCR                              ; Optical_Character_Recognition
+blk; Ogham                            ; Ogham
+blk; Ol_Chiki                         ; Ol_Chiki
+blk; Ol_Onal                          ; Ol_Onal
+blk; Old_Hungarian                    ; Old_Hungarian
+blk; Old_Italic                       ; Old_Italic
+blk; Old_North_Arabian                ; Old_North_Arabian
+blk; Old_Permic                       ; Old_Permic
+blk; Old_Persian                      ; Old_Persian
+blk; Old_Sogdian                      ; Old_Sogdian
+blk; Old_South_Arabian                ; Old_South_Arabian
+blk; Old_Turkic                       ; Old_Turkic
+blk; Old_Uyghur                       ; Old_Uyghur
+blk; Oriya                            ; Oriya
+blk; Ornamental_Dingbats              ; Ornamental_Dingbats
+blk; Osage                            ; Osage
+blk; Osmanya                          ; Osmanya
+blk; Ottoman_Siyaq_Numbers            ; Ottoman_Siyaq_Numbers
+blk; Pahawh_Hmong                     ; Pahawh_Hmong
+blk; Palmyrene                        ; Palmyrene
+blk; Pau_Cin_Hau                      ; Pau_Cin_Hau
+blk; Phags_Pa                         ; Phags_Pa
+blk; Phaistos                         ; Phaistos_Disc
+blk; Phoenician                       ; Phoenician
+blk; Phonetic_Ext                     ; Phonetic_Extensions
+blk; Phonetic_Ext_Sup                 ; Phonetic_Extensions_Supplement
+blk; Playing_Cards                    ; Playing_Cards
+blk; Psalter_Pahlavi                  ; Psalter_Pahlavi
+blk; PUA                              ; Private_Use_Area                 ; Private_Use
+blk; Punctuation                      ; General_Punctuation
+blk; Rejang                           ; Rejang
+blk; Rumi                             ; Rumi_Numeral_Symbols
+blk; Runic                            ; Runic
+blk; Samaritan                        ; Samaritan
+blk; Saurashtra                       ; Saurashtra
+blk; Sharada                          ; Sharada
+blk; Sharada_Sup                      ; Sharada_Supplement
+blk; Shavian                          ; Shavian
+blk; Shorthand_Format_Controls        ; Shorthand_Format_Controls
+blk; Siddham                          ; Siddham
+blk; Sidetic                          ; Sidetic
+blk; Sinhala                          ; Sinhala
+blk; Sinhala_Archaic_Numbers          ; Sinhala_Archaic_Numbers
+blk; Small_Forms                      ; Small_Form_Variants
+blk; Small_Kana_Ext                   ; Small_Kana_Extension
+blk; Sogdian                          ; Sogdian
+blk; Sora_Sompeng                     ; Sora_Sompeng
+blk; Soyombo                          ; Soyombo
+blk; Specials                         ; Specials
+blk; Sundanese                        ; Sundanese
+blk; Sundanese_Sup                    ; Sundanese_Supplement
+blk; Sunuwar                          ; Sunuwar
+blk; Sup_Arrows_A                     ; Supplemental_Arrows_A
+blk; Sup_Arrows_B                     ; Supplemental_Arrows_B
+blk; Sup_Arrows_C                     ; Supplemental_Arrows_C
+blk; Sup_Math_Operators               ; Supplemental_Mathematical_Operators
+blk; Sup_PUA_A                        ; Supplementary_Private_Use_Area_A
+blk; Sup_PUA_B                        ; Supplementary_Private_Use_Area_B
+blk; Sup_Punctuation                  ; Supplemental_Punctuation
+blk; Sup_Symbols_And_Pictographs      ; Supplemental_Symbols_And_Pictographs
+blk; Super_And_Sub                    ; Superscripts_And_Subscripts
+blk; Sutton_SignWriting               ; Sutton_SignWriting
+blk; Syloti_Nagri                     ; Syloti_Nagri
+blk; Symbols_And_Pictographs_Ext_A    ; Symbols_And_Pictographs_Extended_A
+blk; Symbols_For_Legacy_Computing     ; Symbols_For_Legacy_Computing
+blk; Symbols_For_Legacy_Computing_Sup ; Symbols_For_Legacy_Computing_Supplement
+blk; Syriac                           ; Syriac
+blk; Syriac_Sup                       ; Syriac_Supplement
+blk; Tagalog                          ; Tagalog
+blk; Tagbanwa                         ; Tagbanwa
+blk; Tags                             ; Tags
+blk; Tai_Le                           ; Tai_Le
+blk; Tai_Tham                         ; Tai_Tham
+blk; Tai_Viet                         ; Tai_Viet
+blk; Tai_Xuan_Jing                    ; Tai_Xuan_Jing_Symbols
+blk; Tai_Yo                           ; Tai_Yo
+blk; Takri                            ; Takri
+blk; Tamil                            ; Tamil
+blk; Tamil_Sup                        ; Tamil_Supplement
+blk; Tangsa                           ; Tangsa
+blk; Tangut                           ; Tangut
+blk; Tangut_Components                ; Tangut_Components
+blk; Tangut_Components_Sup            ; Tangut_Components_Supplement
+blk; Tangut_Sup                       ; Tangut_Supplement
+blk; Telugu                           ; Telugu
+blk; Thaana                           ; Thaana
+blk; Thai                             ; Thai
+blk; Tibetan                          ; Tibetan
+blk; Tifinagh                         ; Tifinagh
+blk; Tirhuta                          ; Tirhuta
+blk; Todhri                           ; Todhri
+blk; Tolong_Siki                      ; Tolong_Siki
+blk; Toto                             ; Toto
+blk; Transport_And_Map                ; Transport_And_Map_Symbols
+blk; Tulu_Tigalari                    ; Tulu_Tigalari
+blk; UCAS                             ; Unified_Canadian_Aboriginal_Syllabics; Canadian_Syllabics
+blk; UCAS_Ext                         ; Unified_Canadian_Aboriginal_Syllabics_Extended
+blk; UCAS_Ext_A                       ; Unified_Canadian_Aboriginal_Syllabics_Extended_A
+blk; Ugaritic                         ; Ugaritic
+blk; Vai                              ; Vai
+blk; Vedic_Ext                        ; Vedic_Extensions
+blk; Vertical_Forms                   ; Vertical_Forms
+blk; Vithkuqi                         ; Vithkuqi
+blk; VS                               ; Variation_Selectors
+blk; VS_Sup                           ; Variation_Selectors_Supplement
+blk; Wancho                           ; Wancho
+blk; Warang_Citi                      ; Warang_Citi
+blk; Yezidi                           ; Yezidi
+blk; Yi_Radicals                      ; Yi_Radicals
+blk; Yi_Syllables                     ; Yi_Syllables
+blk; Yijing                           ; Yijing_Hexagram_Symbols
+blk; Zanabazar_Square                 ; Zanabazar_Square
+blk; Znamenny_Music                   ; Znamenny_Musical_Notation
+
+# Canonical_Combining_Class (ccc)
+
+ccc;   0; NR                         ; Not_Reordered
+ccc;   1; OV                         ; Overlay
+ccc;   6; HANR                       ; Han_Reading
+ccc;   7; NK                         ; Nukta
+ccc;   8; KV                         ; Kana_Voicing
+ccc;   9; VR                         ; Virama
+ccc;  10; CCC10                      ; CCC10
+ccc;  11; CCC11                      ; CCC11
+ccc;  12; CCC12                      ; CCC12
+ccc;  13; CCC13                      ; CCC13
+ccc;  14; CCC14                      ; CCC14
+ccc;  15; CCC15                      ; CCC15
+ccc;  16; CCC16                      ; CCC16
+ccc;  17; CCC17                      ; CCC17
+ccc;  18; CCC18                      ; CCC18
+ccc;  19; CCC19                      ; CCC19
+ccc;  20; CCC20                      ; CCC20
+ccc;  21; CCC21                      ; CCC21
+ccc;  22; CCC22                      ; CCC22
+ccc;  23; CCC23                      ; CCC23
+ccc;  24; CCC24                      ; CCC24
+ccc;  25; CCC25                      ; CCC25
+ccc;  26; CCC26                      ; CCC26
+ccc;  27; CCC27                      ; CCC27
+ccc;  28; CCC28                      ; CCC28
+ccc;  29; CCC29                      ; CCC29
+ccc;  30; CCC30                      ; CCC30
+ccc;  31; CCC31                      ; CCC31
+ccc;  32; CCC32                      ; CCC32
+ccc;  33; CCC33                      ; CCC33
+ccc;  34; CCC34                      ; CCC34
+ccc;  35; CCC35                      ; CCC35
+ccc;  36; CCC36                      ; CCC36
+ccc;  84; CCC84                      ; CCC84
+ccc;  91; CCC91                      ; CCC91
+ccc; 103; CCC103                     ; CCC103
+ccc; 107; CCC107                     ; CCC107
+ccc; 118; CCC118                     ; CCC118
+ccc; 122; CCC122                     ; CCC122
+ccc; 129; CCC129                     ; CCC129
+ccc; 130; CCC130                     ; CCC130
+ccc; 132; CCC132                     ; CCC132
+ccc; 133; CCC133                     ; CCC133 # RESERVED
+ccc; 200; ATBL                       ; Attached_Below_Left
+ccc; 202; ATB                        ; Attached_Below
+ccc; 214; ATA                        ; Attached_Above
+ccc; 216; ATAR                       ; Attached_Above_Right
+ccc; 218; BL                         ; Below_Left
+ccc; 220; B                          ; Below
+ccc; 222; BR                         ; Below_Right
+ccc; 224; L                          ; Left
+ccc; 226; R                          ; Right
+ccc; 228; AL                         ; Above_Left
+ccc; 230; A                          ; Above
+ccc; 232; AR                         ; Above_Right
+ccc; 233; DB                         ; Double_Below
+ccc; 234; DA                         ; Double_Above
+ccc; 240; IS                         ; Iota_Subscript
+
+# Case_Folding (cf)
+
+# @missing: 0000..10FFFF; Case_Folding; <code point>
+
+# Case_Ignorable (CI)
+
+CI ; N                                ; No                               ; F                                ; False
+CI ; Y                                ; Yes                              ; T                                ; True
+
+# Cased (Cased)
+
+Cased; N                              ; No                               ; F                                ; False
+Cased; Y                              ; Yes                              ; T                                ; True
+
+# Changes_When_Casefolded (CWCF)
+
+CWCF; N                               ; No                               ; F                                ; False
+CWCF; Y                               ; Yes                              ; T                                ; True
+
+# Changes_When_Casemapped (CWCM)
+
+CWCM; N                               ; No                               ; F                                ; False
+CWCM; Y                               ; Yes                              ; T                                ; True
+
+# Changes_When_Lowercased (CWL)
+
+CWL; N                                ; No                               ; F                                ; False
+CWL; Y                                ; Yes                              ; T                                ; True
+
+# Changes_When_NFKC_Casefolded (CWKCF)
+
+CWKCF; N                              ; No                               ; F                                ; False
+CWKCF; Y                              ; Yes                              ; T                                ; True
+
+# Changes_When_Titlecased (CWT)
+
+CWT; N                                ; No                               ; F                                ; False
+CWT; Y                                ; Yes                              ; T                                ; True
+
+# Changes_When_Uppercased (CWU)
+
+CWU; N                                ; No                               ; F                                ; False
+CWU; Y                                ; Yes                              ; T                                ; True
+
+# Composition_Exclusion (CE)
+
+CE ; N                                ; No                               ; F                                ; False
+CE ; Y                                ; Yes                              ; T                                ; True
+
+# Dash (Dash)
+
+Dash; N                               ; No                               ; F                                ; False
+Dash; Y                               ; Yes                              ; T                                ; True
+
+# Decomposition_Mapping (dm)
+
+# @missing: 0000..10FFFF; Decomposition_Mapping; <code point>
+
+# Decomposition_Type (dt)
+
+dt ; Can                              ; Canonical                        ; can
+dt ; Com                              ; Compat                           ; com
+dt ; Enc                              ; Circle                           ; enc
+dt ; Fin                              ; Final                            ; fin
+dt ; Font                             ; Font                             ; font
+dt ; Fra                              ; Fraction                         ; fra
+dt ; Init                             ; Initial                          ; init
+dt ; Iso                              ; Isolated                         ; iso
+dt ; Med                              ; Medial                           ; med
+dt ; Nar                              ; Narrow                           ; nar
+dt ; Nb                               ; Nobreak                          ; nb
+dt ; None                             ; None                             ; none
+dt ; Sml                              ; Small                            ; sml
+dt ; Sqr                              ; Square                           ; sqr
+dt ; Sub                              ; Sub                              ; sub
+dt ; Sup                              ; Super                            ; sup
+dt ; Vert                             ; Vertical                         ; vert
+dt ; Wide                             ; Wide                             ; wide
+
+# Default_Ignorable_Code_Point (DI)
+
+DI ; N                                ; No                               ; F                                ; False
+DI ; Y                                ; Yes                              ; T                                ; True
+
+# Deprecated (Dep)
+
+Dep; N                                ; No                               ; F                                ; False
+Dep; Y                                ; Yes                              ; T                                ; True
+
+# Diacritic (Dia)
+
+Dia; N                                ; No                               ; F                                ; False
+Dia; Y                                ; Yes                              ; T                                ; True
+
+# East_Asian_Width (ea)
+
+ea ; A                                ; Ambiguous
+ea ; F                                ; Fullwidth
+ea ; H                                ; Halfwidth
+ea ; N                                ; Neutral
+ea ; Na                               ; Narrow
+ea ; W                                ; Wide
+
+# Emoji (Emoji)
+
+Emoji; N                              ; No                               ; F                                ; False
+Emoji; Y                              ; Yes                              ; T                                ; True
+
+# Emoji_Component (EComp)
+
+EComp; N                              ; No                               ; F                                ; False
+EComp; Y                              ; Yes                              ; T                                ; True
+
+# Emoji_Modifier (EMod)
+
+EMod; N                               ; No                               ; F                                ; False
+EMod; Y                               ; Yes                              ; T                                ; True
+
+# Emoji_Modifier_Base (EBase)
+
+EBase; N                              ; No                               ; F                                ; False
+EBase; Y                              ; Yes                              ; T                                ; True
+
+# Emoji_Presentation (EPres)
+
+EPres; N                              ; No                               ; F                                ; False
+EPres; Y                              ; Yes                              ; T                                ; True
+
+# Equivalent_Unified_Ideograph (EqUIdeo)
+
+
+# Expands_On_NFC (XO_NFC)
+
+XO_NFC; N                             ; No                               ; F                                ; False
+XO_NFC; Y                             ; Yes                              ; T                                ; True
+
+# Expands_On_NFD (XO_NFD)
+
+XO_NFD; N                             ; No                               ; F                                ; False
+XO_NFD; Y                             ; Yes                              ; T                                ; True
+
+# Expands_On_NFKC (XO_NFKC)
+
+XO_NFKC; N                            ; No                               ; F                                ; False
+XO_NFKC; Y                            ; Yes                              ; T                                ; True
+
+# Expands_On_NFKD (XO_NFKD)
+
+XO_NFKD; N                            ; No                               ; F                                ; False
+XO_NFKD; Y                            ; Yes                              ; T                                ; True
+
+# Extended_Pictographic (ExtPict)
+
+ExtPict; N                            ; No                               ; F                                ; False
+ExtPict; Y                            ; Yes                              ; T                                ; True
+
+# Extender (Ext)
+
+Ext; N                                ; No                               ; F                                ; False
+Ext; Y                                ; Yes                              ; T                                ; True
+
+# FC_NFKC_Closure (FC_NFKC)
+
+# @missing: 0000..10FFFF; FC_NFKC_Closure; <code point>
+
+# Full_Composition_Exclusion (Comp_Ex)
+
+Comp_Ex; N                            ; No                               ; F                                ; False
+Comp_Ex; Y                            ; Yes                              ; T                                ; True
+
+# General_Category (gc)
+
+gc ; C                                ; Other                            # Cc | Cf | Cn | Co | Cs
+gc ; Cc                               ; Control                          ; cntrl
+gc ; Cf                               ; Format
+gc ; Cn                               ; Unassigned
+gc ; Co                               ; Private_Use
+gc ; Cs                               ; Surrogate
+gc ; L                                ; Letter                           # Ll | Lm | Lo | Lt | Lu
+gc ; LC                               ; Cased_Letter                     # Ll | Lt | Lu
+gc ; Ll                               ; Lowercase_Letter
+gc ; Lm                               ; Modifier_Letter
+gc ; Lo                               ; Other_Letter
+gc ; Lt                               ; Titlecase_Letter
+gc ; Lu                               ; Uppercase_Letter
+gc ; M                                ; Mark                             ; Combining_Mark                   # Mc | Me | Mn
+gc ; Mc                               ; Spacing_Mark
+gc ; Me                               ; Enclosing_Mark
+gc ; Mn                               ; Nonspacing_Mark
+gc ; N                                ; Number                           # Nd | Nl | No
+gc ; Nd                               ; Decimal_Number                   ; digit
+gc ; Nl                               ; Letter_Number
+gc ; No                               ; Other_Number
+gc ; P                                ; Punctuation                      ; punct                            # Pc | Pd | Pe | Pf | Pi | Po | Ps
+gc ; Pc                               ; Connector_Punctuation
+gc ; Pd                               ; Dash_Punctuation
+gc ; Pe                               ; Close_Punctuation
+gc ; Pf                               ; Final_Punctuation
+gc ; Pi                               ; Initial_Punctuation
+gc ; Po                               ; Other_Punctuation
+gc ; Ps                               ; Open_Punctuation
+gc ; S                                ; Symbol                           # Sc | Sk | Sm | So
+gc ; Sc                               ; Currency_Symbol
+gc ; Sk                               ; Modifier_Symbol
+gc ; Sm                               ; Math_Symbol
+gc ; So                               ; Other_Symbol
+gc ; Z                                ; Separator                        # Zl | Zp | Zs
+gc ; Zl                               ; Line_Separator
+gc ; Zp                               ; Paragraph_Separator
+gc ; Zs                               ; Space_Separator
+# @missing: 0000..10FFFF; General_Category; Unassigned
+
+# Grapheme_Base (Gr_Base)
+
+Gr_Base; N                            ; No                               ; F                                ; False
+Gr_Base; Y                            ; Yes                              ; T                                ; True
+
+# Grapheme_Cluster_Break (GCB)
+
+GCB; CN                               ; Control
+GCB; CR                               ; CR
+GCB; EB                               ; E_Base
+GCB; EBG                              ; E_Base_GAZ
+GCB; EM                               ; E_Modifier
+GCB; EX                               ; Extend
+GCB; GAZ                              ; Glue_After_Zwj
+GCB; L                                ; L
+GCB; LF                               ; LF
+GCB; LV                               ; LV
+GCB; LVT                              ; LVT
+GCB; PP                               ; Prepend
+GCB; RI                               ; Regional_Indicator
+GCB; SM                               ; SpacingMark
+GCB; T                                ; T
+GCB; V                                ; V
+GCB; XX                               ; Other
+GCB; ZWJ                              ; ZWJ
+
+# Grapheme_Extend (Gr_Ext)
+
+Gr_Ext; N                             ; No                               ; F                                ; False
+Gr_Ext; Y                             ; Yes                              ; T                                ; True
+
+# Grapheme_Link (Gr_Link)
+
+Gr_Link; N                            ; No                               ; F                                ; False
+Gr_Link; Y                            ; Yes                              ; T                                ; True
+
+# Hangul_Syllable_Type (hst)
+
+hst; L                                ; Leading_Jamo
+hst; LV                               ; LV_Syllable
+hst; LVT                              ; LVT_Syllable
+hst; NA                               ; Not_Applicable
+hst; T                                ; Trailing_Jamo
+hst; V                                ; Vowel_Jamo
+
+# Hex_Digit (Hex)
+
+Hex; N                                ; No                               ; F                                ; False
+Hex; Y                                ; Yes                              ; T                                ; True
+
+# Hyphen (Hyphen)
+
+Hyphen; N                             ; No                               ; F                                ; False
+Hyphen; Y                             ; Yes                              ; T                                ; True
+
+# IDS_Binary_Operator (IDSB)
+
+IDSB; N                               ; No                               ; F                                ; False
+IDSB; Y                               ; Yes                              ; T                                ; True
+
+# IDS_Trinary_Operator (IDST)
+
+IDST; N                               ; No                               ; F                                ; False
+IDST; Y                               ; Yes                              ; T                                ; True
+
+# IDS_Unary_Operator (IDSU)
+
+IDSU; N                               ; No                               ; F                                ; False
+IDSU; Y                               ; Yes                              ; T                                ; True
+
+# ID_Compat_Math_Continue (ID_Compat_Math_Continue)
+
+ID_Compat_Math_Continue; N            ; No                               ; F                                ; False
+ID_Compat_Math_Continue; Y            ; Yes                              ; T                                ; True
+
+# ID_Compat_Math_Start (ID_Compat_Math_Start)
+
+ID_Compat_Math_Start; N               ; No                               ; F                                ; False
+ID_Compat_Math_Start; Y               ; Yes                              ; T                                ; True
+
+# ID_Continue (IDC)
+
+IDC; N                                ; No                               ; F                                ; False
+IDC; Y                                ; Yes                              ; T                                ; True
+
+# ID_Start (IDS)
+
+IDS; N                                ; No                               ; F                                ; False
+IDS; Y                                ; Yes                              ; T                                ; True
+
+# ISO_Comment (isc)
+
+# @missing: 0000..10FFFF; ISO_Comment; <none>
+
+# Ideographic (Ideo)
+
+Ideo; N                               ; No                               ; F                                ; False
+Ideo; Y                               ; Yes                              ; T                                ; True
+
+# Indic_Conjunct_Break (InCB)
+
+InCB; Consonant                       ; Consonant
+InCB; Extend                          ; Extend
+InCB; Linker                          ; Linker
+InCB; None                            ; None
+
+# Indic_Positional_Category (InPC)
+
+InPC; Bottom                          ; Bottom
+InPC; Bottom_And_Left                 ; Bottom_And_Left
+InPC; Bottom_And_Right                ; Bottom_And_Right
+InPC; Left                            ; Left
+InPC; Left_And_Right                  ; Left_And_Right
+InPC; NA                              ; Not_Applicable
+InPC; Overstruck                      ; Overstruck
+InPC; Right                           ; Right
+InPC; Top                             ; Top
+InPC; Top_And_Bottom                  ; Top_And_Bottom
+InPC; Top_And_Bottom_And_Left         ; Top_And_Bottom_And_Left
+InPC; Top_And_Bottom_And_Right        ; Top_And_Bottom_And_Right
+InPC; Top_And_Left                    ; Top_And_Left
+InPC; Top_And_Left_And_Right          ; Top_And_Left_And_Right
+InPC; Top_And_Right                   ; Top_And_Right
+InPC; Visual_Order_Left               ; Visual_Order_Left
+
+# Indic_Syllabic_Category (InSC)
+
+InSC; Avagraha                        ; Avagraha
+InSC; Bindu                           ; Bindu
+InSC; Brahmi_Joining_Number           ; Brahmi_Joining_Number
+InSC; Cantillation_Mark               ; Cantillation_Mark
+InSC; Consonant                       ; Consonant
+InSC; Consonant_Dead                  ; Consonant_Dead
+InSC; Consonant_Final                 ; Consonant_Final
+InSC; Consonant_Head_Letter           ; Consonant_Head_Letter
+InSC; Consonant_Initial_Postfixed     ; Consonant_Initial_Postfixed
+InSC; Consonant_Killer                ; Consonant_Killer
+InSC; Consonant_Medial                ; Consonant_Medial
+InSC; Consonant_Placeholder           ; Consonant_Placeholder
+InSC; Consonant_Preceding_Repha       ; Consonant_Preceding_Repha
+InSC; Consonant_Prefixed              ; Consonant_Prefixed
+InSC; Consonant_Subjoined             ; Consonant_Subjoined
+InSC; Consonant_Succeeding_Repha      ; Consonant_Succeeding_Repha
+InSC; Consonant_With_Stacker          ; Consonant_With_Stacker
+InSC; Gemination_Mark                 ; Gemination_Mark
+InSC; Invisible_Stacker               ; Invisible_Stacker
+InSC; Joiner                          ; Joiner
+InSC; Modifying_Letter                ; Modifying_Letter
+InSC; Non_Joiner                      ; Non_Joiner
+InSC; Nukta                           ; Nukta
+InSC; Number                          ; Number
+InSC; Number_Joiner                   ; Number_Joiner
+InSC; Other                           ; Other
+InSC; Pure_Killer                     ; Pure_Killer
+InSC; Register_Shifter                ; Register_Shifter
+InSC; Reordering_Killer               ; Reordering_Killer
+InSC; Syllable_Modifier               ; Syllable_Modifier
+InSC; Tone_Letter                     ; Tone_Letter
+InSC; Tone_Mark                       ; Tone_Mark
+InSC; Virama                          ; Virama
+InSC; Visarga                         ; Visarga
+InSC; Vowel                           ; Vowel
+InSC; Vowel_Dependent                 ; Vowel_Dependent
+InSC; Vowel_Independent               ; Vowel_Independent
+
+# Jamo_Short_Name (JSN)
+
+JSN; A                                ; A
+JSN; AE                               ; AE
+JSN; B                                ; B
+JSN; BB                               ; BB
+JSN; BS                               ; BS
+JSN; C                                ; C
+JSN; D                                ; D
+JSN; DD                               ; DD
+JSN; E                                ; E
+JSN; EO                               ; EO
+JSN; EU                               ; EU
+JSN; G                                ; G
+JSN; GG                               ; GG
+JSN; GS                               ; GS
+JSN; H                                ; H
+JSN; I                                ; I
+JSN; J                                ; J
+JSN; JJ                               ; JJ
+JSN; K                                ; K
+JSN; L                                ; L
+JSN; LB                               ; LB
+JSN; LG                               ; LG
+JSN; LH                               ; LH
+JSN; LM                               ; LM
+JSN; LP                               ; LP
+JSN; LS                               ; LS
+JSN; LT                               ; LT
+JSN; M                                ; M
+JSN; N                                ; N
+JSN; NG                               ; NG
+JSN; NH                               ; NH
+JSN; NJ                               ; NJ
+JSN; O                                ; O
+JSN; OE                               ; OE
+JSN; P                                ; P
+JSN; R                                ; R
+JSN; S                                ; S
+JSN; SS                               ; SS
+JSN; T                                ; T
+JSN; U                                ; U
+JSN; WA                               ; WA
+JSN; WAE                              ; WAE
+JSN; WE                               ; WE
+JSN; WEO                              ; WEO
+JSN; WI                               ; WI
+JSN; YA                               ; YA
+JSN; YAE                              ; YAE
+JSN; YE                               ; YE
+JSN; YEO                              ; YEO
+JSN; YI                               ; YI
+JSN; YO                               ; YO
+JSN; YU                               ; YU
+# @missing: 0000..10FFFF; Jamo_Short_Name; <none>
+
+# Join_Control (Join_C)
+
+Join_C; N                             ; No                               ; F                                ; False
+Join_C; Y                             ; Yes                              ; T                                ; True
+
+# Joining_Group (jg)
+
+jg ; African_Feh                      ; African_Feh
+jg ; African_Noon                     ; African_Noon
+jg ; African_Qaf                      ; African_Qaf
+jg ; Ain                              ; Ain
+jg ; Alaph                            ; Alaph
+jg ; Alef                             ; Alef
+jg ; Beh                              ; Beh
+jg ; Beth                             ; Beth
+jg ; Burushaski_Yeh_Barree            ; Burushaski_Yeh_Barree
+jg ; Dal                              ; Dal
+jg ; Dalath_Rish                      ; Dalath_Rish
+jg ; E                                ; E
+jg ; Farsi_Yeh                        ; Farsi_Yeh
+jg ; Fe                               ; Fe
+jg ; Feh                              ; Feh
+jg ; Final_Semkath                    ; Final_Semkath
+jg ; Gaf                              ; Gaf
+jg ; Gamal                            ; Gamal
+jg ; Hah                              ; Hah
+jg ; Hanifi_Rohingya_Kinna_Ya         ; Hanifi_Rohingya_Kinna_Ya
+jg ; Hanifi_Rohingya_Pa               ; Hanifi_Rohingya_Pa
+jg ; He                               ; He
+jg ; Heh                              ; Heh
+jg ; Heh_Goal                         ; Heh_Goal
+jg ; Heth                             ; Heth
+jg ; Kaf                              ; Kaf
+jg ; Kaph                             ; Kaph
+jg ; Kashmiri_Yeh                     ; Kashmiri_Yeh
+jg ; Khaph                            ; Khaph
+jg ; Knotted_Heh                      ; Knotted_Heh
+jg ; Lam                              ; Lam
+jg ; Lamadh                           ; Lamadh
+jg ; Malayalam_Bha                    ; Malayalam_Bha
+jg ; Malayalam_Ja                     ; Malayalam_Ja
+jg ; Malayalam_Lla                    ; Malayalam_Lla
+jg ; Malayalam_Llla                   ; Malayalam_Llla
+jg ; Malayalam_Nga                    ; Malayalam_Nga
+jg ; Malayalam_Nna                    ; Malayalam_Nna
+jg ; Malayalam_Nnna                   ; Malayalam_Nnna
+jg ; Malayalam_Nya                    ; Malayalam_Nya
+jg ; Malayalam_Ra                     ; Malayalam_Ra
+jg ; Malayalam_Ssa                    ; Malayalam_Ssa
+jg ; Malayalam_Tta                    ; Malayalam_Tta
+jg ; Manichaean_Aleph                 ; Manichaean_Aleph
+jg ; Manichaean_Ayin                  ; Manichaean_Ayin
+jg ; Manichaean_Beth                  ; Manichaean_Beth
+jg ; Manichaean_Daleth                ; Manichaean_Daleth
+jg ; Manichaean_Dhamedh               ; Manichaean_Dhamedh
+jg ; Manichaean_Five                  ; Manichaean_Five
+jg ; Manichaean_Gimel                 ; Manichaean_Gimel
+jg ; Manichaean_Heth                  ; Manichaean_Heth
+jg ; Manichaean_Hundred               ; Manichaean_Hundred
+jg ; Manichaean_Kaph                  ; Manichaean_Kaph
+jg ; Manichaean_Lamedh                ; Manichaean_Lamedh
+jg ; Manichaean_Mem                   ; Manichaean_Mem
+jg ; Manichaean_Nun                   ; Manichaean_Nun
+jg ; Manichaean_One                   ; Manichaean_One
+jg ; Manichaean_Pe                    ; Manichaean_Pe
+jg ; Manichaean_Qoph                  ; Manichaean_Qoph
+jg ; Manichaean_Resh                  ; Manichaean_Resh
+jg ; Manichaean_Sadhe                 ; Manichaean_Sadhe
+jg ; Manichaean_Samekh                ; Manichaean_Samekh
+jg ; Manichaean_Taw                   ; Manichaean_Taw
+jg ; Manichaean_Ten                   ; Manichaean_Ten
+jg ; Manichaean_Teth                  ; Manichaean_Teth
+jg ; Manichaean_Thamedh               ; Manichaean_Thamedh
+jg ; Manichaean_Twenty                ; Manichaean_Twenty
+jg ; Manichaean_Waw                   ; Manichaean_Waw
+jg ; Manichaean_Yodh                  ; Manichaean_Yodh
+jg ; Manichaean_Zayin                 ; Manichaean_Zayin
+jg ; Meem                             ; Meem
+jg ; Mim                              ; Mim
+jg ; No_Joining_Group                 ; No_Joining_Group
+jg ; Noon                             ; Noon
+jg ; Nun                              ; Nun
+jg ; Nya                              ; Nya
+jg ; Pe                               ; Pe
+jg ; Qaf                              ; Qaf
+jg ; Qaph                             ; Qaph
+jg ; Reh                              ; Reh
+jg ; Reversed_Pe                      ; Reversed_Pe
+jg ; Rohingya_Yeh                     ; Rohingya_Yeh
+jg ; Sad                              ; Sad
+jg ; Sadhe                            ; Sadhe
+jg ; Seen                             ; Seen
+jg ; Semkath                          ; Semkath
+jg ; Shin                             ; Shin
+jg ; Straight_Waw                     ; Straight_Waw
+jg ; Swash_Kaf                        ; Swash_Kaf
+jg ; Syriac_Waw                       ; Syriac_Waw
+jg ; Tah                              ; Tah
+jg ; Taw                              ; Taw
+jg ; Teh_Marbuta                      ; Teh_Marbuta
+jg ; Teh_Marbuta_Goal                 ; Teh_Marbuta_Goal                 ; Hamza_On_Heh_Goal
+jg ; Teth                             ; Teth
+jg ; Thin_Noon                        ; Thin_Noon
+jg ; Thin_Yeh                         ; Thin_Yeh
+jg ; Vertical_Tail                    ; Vertical_Tail
+jg ; Waw                              ; Waw
+jg ; Yeh                              ; Yeh
+jg ; Yeh_Barree                       ; Yeh_Barree
+jg ; Yeh_With_Tail                    ; Yeh_With_Tail
+jg ; Yudh                             ; Yudh
+jg ; Yudh_He                          ; Yudh_He
+jg ; Zain                             ; Zain
+jg ; Zhain                            ; Zhain
+
+# Joining_Type (jt)
+
+jt ; C                                ; Join_Causing
+jt ; D                                ; Dual_Joining
+jt ; L                                ; Left_Joining
+jt ; R                                ; Right_Joining
+jt ; T                                ; Transparent
+jt ; U                                ; Non_Joining
+
+# Line_Break (lb)
+
+lb ; AI                               ; Ambiguous
+lb ; AK                               ; Aksara
+lb ; AL                               ; Alphabetic
+lb ; AP                               ; Aksara_Prebase
+lb ; AS                               ; Aksara_Start
+lb ; B2                               ; Break_Both
+lb ; BA                               ; Break_After
+lb ; BB                               ; Break_Before
+lb ; BK                               ; Mandatory_Break
+lb ; CB                               ; Contingent_Break
+lb ; CJ                               ; Conditional_Japanese_Starter
+lb ; CL                               ; Close_Punctuation
+lb ; CM                               ; Combining_Mark
+lb ; CP                               ; Close_Parenthesis
+lb ; CR                               ; Carriage_Return
+lb ; EB                               ; E_Base
+lb ; EM                               ; E_Modifier
+lb ; EX                               ; Exclamation
+lb ; GL                               ; Glue
+lb ; H2                               ; H2
+lb ; H3                               ; H3
+lb ; HH                               ; Unambiguous_Hyphen
+lb ; HL                               ; Hebrew_Letter
+lb ; HY                               ; Hyphen
+lb ; ID                               ; Ideographic
+lb ; IN                               ; Inseparable                      ; Inseperable
+lb ; IS                               ; Infix_Numeric
+lb ; JL                               ; JL
+lb ; JT                               ; JT
+lb ; JV                               ; JV
+lb ; LF                               ; Line_Feed
+lb ; NL                               ; Next_Line
+lb ; NS                               ; Nonstarter
+lb ; NU                               ; Numeric
+lb ; OP                               ; Open_Punctuation
+lb ; PO                               ; Postfix_Numeric
+lb ; PR                               ; Prefix_Numeric
+lb ; QU                               ; Quotation
+lb ; RI                               ; Regional_Indicator
+lb ; SA                               ; Complex_Context
+lb ; SG                               ; Surrogate
+lb ; SP                               ; Space
+lb ; SY                               ; Break_Symbols
+lb ; VF                               ; Virama_Final
+lb ; VI                               ; Virama
+lb ; WJ                               ; Word_Joiner
+lb ; XX                               ; Unknown
+lb ; ZW                               ; ZWSpace
+lb ; ZWJ                              ; ZWJ
+
+# Logical_Order_Exception (LOE)
+
+LOE; N                                ; No                               ; F                                ; False
+LOE; Y                                ; Yes                              ; T                                ; True
+
+# Lowercase (Lower)
+
+Lower; N                              ; No                               ; F                                ; False
+Lower; Y                              ; Yes                              ; T                                ; True
+
+# Lowercase_Mapping (lc)
+
+# @missing: 0000..10FFFF; Lowercase_Mapping; <code point>
+
+# Math (Math)
+
+Math; N                               ; No                               ; F                                ; False
+Math; Y                               ; Yes                              ; T                                ; True
+
+# Modifier_Combining_Mark (MCM)
+
+MCM; N                                ; No                               ; F                                ; False
+MCM; Y                                ; Yes                              ; T                                ; True
+
+# NFC_Quick_Check (NFC_QC)
+
+NFC_QC; M                             ; Maybe
+NFC_QC; N                             ; No
+NFC_QC; Y                             ; Yes
+
+# NFD_Quick_Check (NFD_QC)
+
+NFD_QC; N                             ; No
+NFD_QC; Y                             ; Yes
+
+# NFKC_Casefold (NFKC_CF)
+
+
+# NFKC_Quick_Check (NFKC_QC)
+
+NFKC_QC; M                            ; Maybe
+NFKC_QC; N                            ; No
+NFKC_QC; Y                            ; Yes
+
+# NFKC_Simple_Casefold (NFKC_SCF)
+
+
+# NFKD_Quick_Check (NFKD_QC)
+
+NFKD_QC; N                            ; No
+NFKD_QC; Y                            ; Yes
+
+# Name (na)
+
+# @missing: 0000..10FFFF; Name; <none>
+
+# Name_Alias (Name_Alias)
+
+# @missing: 0000..10FFFF; Name_Alias; <none>
+
+# Noncharacter_Code_Point (NChar)
+
+NChar; N                              ; No                               ; F                                ; False
+NChar; Y                              ; Yes                              ; T                                ; True
+
+# Numeric_Type (nt)
+
+nt ; De                               ; Decimal
+nt ; Di                               ; Digit
+nt ; None                             ; None
+nt ; Nu                               ; Numeric
+
+# Numeric_Value (nv)
+
+# @missing: 0000..10FFFF; Numeric_Value; NaN
+
+# Other_Alphabetic (OAlpha)
+
+OAlpha; N                             ; No                               ; F                                ; False
+OAlpha; Y                             ; Yes                              ; T                                ; True
+
+# Other_Default_Ignorable_Code_Point (ODI)
+
+ODI; N                                ; No                               ; F                                ; False
+ODI; Y                                ; Yes                              ; T                                ; True
+
+# Other_Grapheme_Extend (OGr_Ext)
+
+OGr_Ext; N                            ; No                               ; F                                ; False
+OGr_Ext; Y                            ; Yes                              ; T                                ; True
+
+# Other_ID_Continue (OIDC)
+
+OIDC; N                               ; No                               ; F                                ; False
+OIDC; Y                               ; Yes                              ; T                                ; True
+
+# Other_ID_Start (OIDS)
+
+OIDS; N                               ; No                               ; F                                ; False
+OIDS; Y                               ; Yes                              ; T                                ; True
+
+# Other_Lowercase (OLower)
+
+OLower; N                             ; No                               ; F                                ; False
+OLower; Y                             ; Yes                              ; T                                ; True
+
+# Other_Math (OMath)
+
+OMath; N                              ; No                               ; F                                ; False
+OMath; Y                              ; Yes                              ; T                                ; True
+
+# Other_Uppercase (OUpper)
+
+OUpper; N                             ; No                               ; F                                ; False
+OUpper; Y                             ; Yes                              ; T                                ; True
+
+# Pattern_Syntax (Pat_Syn)
+
+Pat_Syn; N                            ; No                               ; F                                ; False
+Pat_Syn; Y                            ; Yes                              ; T                                ; True
+
+# Pattern_White_Space (Pat_WS)
+
+Pat_WS; N                             ; No                               ; F                                ; False
+Pat_WS; Y                             ; Yes                              ; T                                ; True
+
+# Prepended_Concatenation_Mark (PCM)
+
+PCM; N                                ; No                               ; F                                ; False
+PCM; Y                                ; Yes                              ; T                                ; True
+
+# Quotation_Mark (QMark)
+
+QMark; N                              ; No                               ; F                                ; False
+QMark; Y                              ; Yes                              ; T                                ; True
+
+# Radical (Radical)
+
+Radical; N                            ; No                               ; F                                ; False
+Radical; Y                            ; Yes                              ; T                                ; True
+
+# Regional_Indicator (RI)
+
+RI ; N                                ; No                               ; F                                ; False
+RI ; Y                                ; Yes                              ; T                                ; True
+
+# Script (sc)
+
+sc ; Adlm                             ; Adlam
+sc ; Aghb                             ; Caucasian_Albanian
+sc ; Ahom                             ; Ahom
+sc ; Arab                             ; Arabic
+sc ; Armi                             ; Imperial_Aramaic
+sc ; Armn                             ; Armenian
+sc ; Avst                             ; Avestan
+sc ; Bali                             ; Balinese
+sc ; Bamu                             ; Bamum
+sc ; Bass                             ; Bassa_Vah
+sc ; Batk                             ; Batak
+sc ; Beng                             ; Bengali
+sc ; Berf                             ; Beria_Erfe
+sc ; Bhks                             ; Bhaiksuki
+sc ; Bopo                             ; Bopomofo
+sc ; Brah                             ; Brahmi
+sc ; Brai                             ; Braille
+sc ; Bugi                             ; Buginese
+sc ; Buhd                             ; Buhid
+sc ; Cakm                             ; Chakma
+sc ; Cans                             ; Canadian_Aboriginal
+sc ; Cari                             ; Carian
+sc ; Cham                             ; Cham
+sc ; Cher                             ; Cherokee
+sc ; Chrs                             ; Chorasmian
+sc ; Copt                             ; Coptic                           ; Qaac
+sc ; Cpmn                             ; Cypro_Minoan
+sc ; Cprt                             ; Cypriot
+sc ; Cyrl                             ; Cyrillic
+sc ; Deva                             ; Devanagari
+sc ; Diak                             ; Dives_Akuru
+sc ; Dogr                             ; Dogra
+sc ; Dsrt                             ; Deseret
+sc ; Dupl                             ; Duployan
+sc ; Egyp                             ; Egyptian_Hieroglyphs
+sc ; Elba                             ; Elbasan
+sc ; Elym                             ; Elymaic
+sc ; Ethi                             ; Ethiopic
+sc ; Gara                             ; Garay
+sc ; Geor                             ; Georgian
+sc ; Glag                             ; Glagolitic
+sc ; Gong                             ; Gunjala_Gondi
+sc ; Gonm                             ; Masaram_Gondi
+sc ; Goth                             ; Gothic
+sc ; Gran                             ; Grantha
+sc ; Grek                             ; Greek
+sc ; Gujr                             ; Gujarati
+sc ; Gukh                             ; Gurung_Khema
+sc ; Guru                             ; Gurmukhi
+sc ; Hang                             ; Hangul
+sc ; Hani                             ; Han
+sc ; Hano                             ; Hanunoo
+sc ; Hatr                             ; Hatran
+sc ; Hebr                             ; Hebrew
+sc ; Hira                             ; Hiragana
+sc ; Hluw                             ; Anatolian_Hieroglyphs
+sc ; Hmng                             ; Pahawh_Hmong
+sc ; Hmnp                             ; Nyiakeng_Puachue_Hmong
+sc ; Hrkt                             ; Katakana_Or_Hiragana
+sc ; Hung                             ; Old_Hungarian
+sc ; Ital                             ; Old_Italic
+sc ; Java                             ; Javanese
+sc ; Kali                             ; Kayah_Li
+sc ; Kana                             ; Katakana
+sc ; Kawi                             ; Kawi
+sc ; Khar                             ; Kharoshthi
+sc ; Khmr                             ; Khmer
+sc ; Khoj                             ; Khojki
+sc ; Kits                             ; Khitan_Small_Script
+sc ; Knda                             ; Kannada
+sc ; Krai                             ; Kirat_Rai
+sc ; Kthi                             ; Kaithi
+sc ; Lana                             ; Tai_Tham
+sc ; Laoo                             ; Lao
+sc ; Latn                             ; Latin
+sc ; Lepc                             ; Lepcha
+sc ; Limb                             ; Limbu
+sc ; Lina                             ; Linear_A
+sc ; Linb                             ; Linear_B
+sc ; Lisu                             ; Lisu
+sc ; Lyci                             ; Lycian
+sc ; Lydi                             ; Lydian
+sc ; Mahj                             ; Mahajani
+sc ; Maka                             ; Makasar
+sc ; Mand                             ; Mandaic
+sc ; Mani                             ; Manichaean
+sc ; Marc                             ; Marchen
+sc ; Medf                             ; Medefaidrin
+sc ; Mend                             ; Mende_Kikakui
+sc ; Merc                             ; Meroitic_Cursive
+sc ; Mero                             ; Meroitic_Hieroglyphs
+sc ; Mlym                             ; Malayalam
+sc ; Modi                             ; Modi
+sc ; Mong                             ; Mongolian
+sc ; Mroo                             ; Mro
+sc ; Mtei                             ; Meetei_Mayek
+sc ; Mult                             ; Multani
+sc ; Mymr                             ; Myanmar
+sc ; Nagm                             ; Nag_Mundari
+sc ; Nand                             ; Nandinagari
+sc ; Narb                             ; Old_North_Arabian
+sc ; Nbat                             ; Nabataean
+sc ; Newa                             ; Newa
+sc ; Nkoo                             ; Nko
+sc ; Nshu                             ; Nushu
+sc ; Ogam                             ; Ogham
+sc ; Olck                             ; Ol_Chiki
+sc ; Onao                             ; Ol_Onal
+sc ; Orkh                             ; Old_Turkic
+sc ; Orya                             ; Oriya
+sc ; Osge                             ; Osage
+sc ; Osma                             ; Osmanya
+sc ; Ougr                             ; Old_Uyghur
+sc ; Palm                             ; Palmyrene
+sc ; Pauc                             ; Pau_Cin_Hau
+sc ; Perm                             ; Old_Permic
+sc ; Phag                             ; Phags_Pa
+sc ; Phli                             ; Inscriptional_Pahlavi
+sc ; Phlp                             ; Psalter_Pahlavi
+sc ; Phnx                             ; Phoenician
+sc ; Plrd                             ; Miao
+sc ; Prti                             ; Inscriptional_Parthian
+sc ; Rjng                             ; Rejang
+sc ; Rohg                             ; Hanifi_Rohingya
+sc ; Runr                             ; Runic
+sc ; Samr                             ; Samaritan
+sc ; Sarb                             ; Old_South_Arabian
+sc ; Saur                             ; Saurashtra
+sc ; Sgnw                             ; SignWriting
+sc ; Shaw                             ; Shavian
+sc ; Shrd                             ; Sharada
+sc ; Sidd                             ; Siddham
+sc ; Sidt                             ; Sidetic
+sc ; Sind                             ; Khudawadi
+sc ; Sinh                             ; Sinhala
+sc ; Sogd                             ; Sogdian
+sc ; Sogo                             ; Old_Sogdian
+sc ; Sora                             ; Sora_Sompeng
+sc ; Soyo                             ; Soyombo
+sc ; Sund                             ; Sundanese
+sc ; Sunu                             ; Sunuwar
+sc ; Sylo                             ; Syloti_Nagri
+sc ; Syrc                             ; Syriac
+sc ; Tagb                             ; Tagbanwa
+sc ; Takr                             ; Takri
+sc ; Tale                             ; Tai_Le
+sc ; Talu                             ; New_Tai_Lue
+sc ; Taml                             ; Tamil
+sc ; Tang                             ; Tangut
+sc ; Tavt                             ; Tai_Viet
+sc ; Tayo                             ; Tai_Yo
+sc ; Telu                             ; Telugu
+sc ; Tfng                             ; Tifinagh
+sc ; Tglg                             ; Tagalog
+sc ; Thaa                             ; Thaana
+sc ; Thai                             ; Thai
+sc ; Tibt                             ; Tibetan
+sc ; Tirh                             ; Tirhuta
+sc ; Tnsa                             ; Tangsa
+sc ; Todr                             ; Todhri
+sc ; Tols                             ; Tolong_Siki
+sc ; Toto                             ; Toto
+sc ; Tutg                             ; Tulu_Tigalari
+sc ; Ugar                             ; Ugaritic
+sc ; Vaii                             ; Vai
+sc ; Vith                             ; Vithkuqi
+sc ; Wara                             ; Warang_Citi
+sc ; Wcho                             ; Wancho
+sc ; Xpeo                             ; Old_Persian
+sc ; Xsux                             ; Cuneiform
+sc ; Yezi                             ; Yezidi
+sc ; Yiii                             ; Yi
+sc ; Zanb                             ; Zanabazar_Square
+sc ; Zinh                             ; Inherited                        ; Qaai
+sc ; Zyyy                             ; Common
+sc ; Zzzz                             ; Unknown
+
+# Script_Extensions (scx)
+
+
+# Sentence_Break (SB)
+
+SB ; AT                               ; ATerm
+SB ; CL                               ; Close
+SB ; CR                               ; CR
+SB ; EX                               ; Extend
+SB ; FO                               ; Format
+SB ; LE                               ; OLetter
+SB ; LF                               ; LF
+SB ; LO                               ; Lower
+SB ; NU                               ; Numeric
+SB ; SC                               ; SContinue
+SB ; SE                               ; Sep
+SB ; SP                               ; Sp
+SB ; ST                               ; STerm
+SB ; UP                               ; Upper
+SB ; XX                               ; Other
+
+# Sentence_Terminal (STerm)
+
+STerm; N                              ; No                               ; F                                ; False
+STerm; Y                              ; Yes                              ; T                                ; True
+
+# Simple_Case_Folding (scf)
+
+# @missing: 0000..10FFFF; Simple_Case_Folding; <code point>
+
+# Simple_Lowercase_Mapping (slc)
+
+# @missing: 0000..10FFFF; Simple_Lowercase_Mapping; <code point>
+
+# Simple_Titlecase_Mapping (stc)
+
+# @missing: 0000..10FFFF; Simple_Titlecase_Mapping; <code point>
+
+# Simple_Uppercase_Mapping (suc)
+
+# @missing: 0000..10FFFF; Simple_Uppercase_Mapping; <code point>
+
+# Soft_Dotted (SD)
+
+SD ; N                                ; No                               ; F                                ; False
+SD ; Y                                ; Yes                              ; T                                ; True
+
+# Terminal_Punctuation (Term)
+
+Term; N                               ; No                               ; F                                ; False
+Term; Y                               ; Yes                              ; T                                ; True
+
+# Titlecase_Mapping (tc)
+
+# @missing: 0000..10FFFF; Titlecase_Mapping; <code point>
+
+# Unicode_1_Name (na1)
+
+# @missing: 0000..10FFFF; Unicode_1_Name; <none>
+
+# Unified_Ideograph (UIdeo)
+
+UIdeo; N                              ; No                               ; F                                ; False
+UIdeo; Y                              ; Yes                              ; T                                ; True
+
+# Uppercase (Upper)
+
+Upper; N                              ; No                               ; F                                ; False
+Upper; Y                              ; Yes                              ; T                                ; True
+
+# Uppercase_Mapping (uc)
+
+# @missing: 0000..10FFFF; Uppercase_Mapping; <code point>
+
+# Variation_Selector (VS)
+
+VS ; N                                ; No                               ; F                                ; False
+VS ; Y                                ; Yes                              ; T                                ; True
+
+# Vertical_Orientation (vo)
+
+vo ; R                                ; Rotated
+vo ; Tr                               ; Transformed_Rotated
+vo ; Tu                               ; Transformed_Upright
+vo ; U                                ; Upright
+
+# White_Space (WSpace)
+
+WSpace; N                             ; No                               ; F                                ; False
+WSpace; Y                             ; Yes                              ; T                                ; True
+
+# Word_Break (WB)
+
+WB ; CR                               ; CR
+WB ; DQ                               ; Double_Quote
+WB ; EB                               ; E_Base
+WB ; EBG                              ; E_Base_GAZ
+WB ; EM                               ; E_Modifier
+WB ; EX                               ; ExtendNumLet
+WB ; Extend                           ; Extend
+WB ; FO                               ; Format
+WB ; GAZ                              ; Glue_After_Zwj
+WB ; HL                               ; Hebrew_Letter
+WB ; KA                               ; Katakana
+WB ; LE                               ; ALetter
+WB ; LF                               ; LF
+WB ; MB                               ; MidNumLet
+WB ; ML                               ; MidLetter
+WB ; MN                               ; MidNum
+WB ; NL                               ; Newline
+WB ; NU                               ; Numeric
+WB ; RI                               ; Regional_Indicator
+WB ; SQ                               ; Single_Quote
+WB ; WSegSpace                        ; WSegSpace
+WB ; XX                               ; Other
+WB ; ZWJ                              ; ZWJ
+
+# XID_Continue (XIDC)
+
+XIDC; N                               ; No                               ; F                                ; False
+XIDC; Y                               ; Yes                              ; T                                ; True
+
+# XID_Start (XIDS)
+
+XIDS; N                               ; No                               ; F                                ; False
+XIDS; Y                               ; Yes                              ; T                                ; True
+
+# cjkAccountingNumeric (cjkAccountingNumeric)
+
+# @missing: 0000..10FFFF; cjkAccountingNumeric; NaN
+
+# cjkCompatibilityVariant (cjkCompatibilityVariant)
+
+# @missing: 0000..10FFFF; cjkCompatibilityVariant; <code point>
+
+# cjkIICore (cjkIICore)
+
+# @missing: 0000..10FFFF; cjkIICore; <none>
+
+# cjkIRG_GSource (cjkIRG_GSource)
+
+# @missing: 0000..10FFFF; cjkIRG_GSource; <none>
+
+# cjkIRG_HSource (cjkIRG_HSource)
+
+# @missing: 0000..10FFFF; cjkIRG_HSource; <none>
+
+# cjkIRG_JSource (cjkIRG_JSource)
+
+# @missing: 0000..10FFFF; cjkIRG_JSource; <none>
+
+# cjkIRG_KPSource (cjkIRG_KPSource)
+
+# @missing: 0000..10FFFF; cjkIRG_KPSource; <none>
+
+# cjkIRG_KSource (cjkIRG_KSource)
+
+# @missing: 0000..10FFFF; cjkIRG_KSource; <none>
+
+# cjkIRG_MSource (cjkIRG_MSource)
+
+# @missing: 0000..10FFFF; cjkIRG_MSource; <none>
+
+# cjkIRG_SSource (cjkIRG_SSource)
+
+# @missing: 0000..10FFFF; cjkIRG_SSource; <none>
+
+# cjkIRG_TSource (cjkIRG_TSource)
+
+# @missing: 0000..10FFFF; cjkIRG_TSource; <none>
+
+# cjkIRG_UKSource (cjkIRG_UKSource)
+
+# @missing: 0000..10FFFF; cjkIRG_UKSource; <none>
+
+# cjkIRG_USource (cjkIRG_USource)
+
+# @missing: 0000..10FFFF; cjkIRG_USource; <none>
+
+# cjkIRG_VSource (cjkIRG_VSource)
+
+# @missing: 0000..10FFFF; cjkIRG_VSource; <none>
+
+# cjkOtherNumeric (cjkOtherNumeric)
+
+# @missing: 0000..10FFFF; cjkOtherNumeric; NaN
+
+# cjkPrimaryNumeric (cjkPrimaryNumeric)
+
+# @missing: 0000..10FFFF; cjkPrimaryNumeric; NaN
+
+# cjkRSUnicode (cjkRSUnicode)
+
+# @missing: 0000..10FFFF; cjkRSUnicode; <none>
+
+# kEH_Cat (kEH_Cat)
+
+# @missing: 0000..10FFFF; kEH_Cat; <none>
+
+# kEH_Desc (kEH_Desc)
+
+# @missing: 0000..10FFFF; kEH_Desc; <none>
+
+# kEH_HG (kEH_HG)
+
+# @missing: 0000..10FFFF; kEH_HG; <none>
+
+# kEH_IFAO (kEH_IFAO)
+
+# @missing: 0000..10FFFF; kEH_IFAO; <none>
+
+# kEH_JSesh (kEH_JSesh)
+
+# @missing: 0000..10FFFF; kEH_JSesh; <none>
+
+# kEH_NoMirror (kEH_NoMirror)
+
+kEH_NoMirror; N                       ; No                               ; F                                ; False
+kEH_NoMirror; Y                       ; Yes                              ; T                                ; True
+
+# kEH_NoRotate (kEH_NoRotate)
+
+kEH_NoRotate; N                       ; No                               ; F                                ; False
+kEH_NoRotate; Y                       ; Yes                              ; T                                ; True
+
+# kMandarin (cjkMandarin)
+
+# @missing: 0000..10FFFF; kMandarin; <none>
+
+# kTotalStrokes (cjkTotalStrokes)
+
+# @missing: 0000..10FFFF; kTotalStrokes; <none>
+
+# kUnihanCore2020 (cjkUnihanCore2020)
+
+# @missing: 0000..10FFFF; kUnihanCore2020; <none>
+
+# EOF
diff --git a/lib/elixir/unicode/ScriptExtensions.txt b/lib/elixir/unicode/ScriptExtensions.txt
new file mode 100644
index 00000000000..98b8d0fb06e
--- /dev/null
+++ b/lib/elixir/unicode/ScriptExtensions.txt
@@ -0,0 +1,235 @@
+# ScriptExtensions-17.0.0.txt
+# Date: 2025-08-01, 21:42:00 GMT
+# © 2025 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use and license, see https://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+#   For documentation, see https://www.unicode.org/reports/tr44/
+#
+# The Script_Extensions property indicates which characters are commonly used
+# with more than one script, but with a limited number of scripts.
+# For each code point, there is one or more property values.  Each such value is a Script property value.
+# For more information, see:
+#   UAX #24, Unicode Script Property: https://www.unicode.org/reports/tr24/
+#     Especially the sections:
+#       https://www.unicode.org/reports/tr24/#Assignment_Script_Values
+#       https://www.unicode.org/reports/tr24/#Assignment_ScriptX_Values
+#
+# Each Script_Extensions value in this file consists of a set
+# of one or more abbreviated Script property values. The ordering of the
+# values in that set is not material, but for stability in presentation
+# it is given here as alphabetical.
+#
+# All code points not explicitly listed for Script_Extensions
+# have as their value the corresponding Script property value.
+#
+# @missing: 0000..10FFFF; <script>
+00B7          ; Avst Cari Copt Dupl Elba Geor Glag Gong Goth Grek Hani Latn Lydi Mahj Perm Shaw #Po MIDDLE DOT
+02BC          ; Beng Cyrl Deva Latn Lisu Thai Toto #Lm   MODIFIER LETTER APOSTROPHE
+02C7          ; Bopo Latn                      # Lm      CARON
+02C9..02CB    ; Bopo Latn                      # Lm  [3] MODIFIER LETTER MACRON..MODIFIER LETTER GRAVE ACCENT
+02CD          ; Latn Lisu                      # Lm      MODIFIER LETTER LOW MACRON
+02D7          ; Latn Thai                      # Sk      MODIFIER LETTER MINUS SIGN
+02D9          ; Bopo Latn                      # Sk      DOT ABOVE
+0300          ; Cher Copt Cyrl Grek Latn Perm Sunu Tale #Mn COMBINING GRAVE ACCENT
+0301          ; Cher Cyrl Grek Latn Osge Sunu Tale Todr #Mn COMBINING ACUTE ACCENT
+0302          ; Cher Cyrl Latn Tfng            # Mn      COMBINING CIRCUMFLEX ACCENT
+0303          ; Glag Latn Sunu Syrc Thai       # Mn      COMBINING TILDE
+0304          ; Aghb Cher Copt Cyrl Goth Grek Latn Osge Syrc Tfng Todr #Mn COMBINING MACRON
+0305          ; Copt Elba Glag Goth Kana Latn  # Mn      COMBINING OVERLINE
+0306          ; Cyrl Grek Latn Perm Tfng       # Mn      COMBINING BREVE
+0307          ; Copt Dupl Hebr Latn Perm Syrc Tale Tfng Todr #Mn COMBINING DOT ABOVE
+0308          ; Armn Cyrl Dupl Goth Grek Hebr Latn Perm Syrc Tale Tfng #Mn COMBINING DIAERESIS
+0309          ; Latn Tfng                      # Mn      COMBINING HOOK ABOVE
+030A          ; Dupl Latn Syrc                 # Mn      COMBINING RING ABOVE
+030B          ; Cher Cyrl Latn Osge            # Mn      COMBINING DOUBLE ACUTE ACCENT
+030C          ; Cher Latn Tale                 # Mn      COMBINING CARON
+030D          ; Latn Sunu                      # Mn      COMBINING VERTICAL LINE ABOVE
+030E          ; Ethi Latn                      # Mn      COMBINING DOUBLE VERTICAL LINE ABOVE
+0310          ; Latn Sunu                      # Mn      COMBINING CANDRABINDU
+0311          ; Cyrl Latn Todr                 # Mn      COMBINING INVERTED BREVE
+0313          ; Grek Latn Perm Todr            # Mn      COMBINING COMMA ABOVE
+0323          ; Cher Dupl Kana Latn Syrc Tfng  # Mn      COMBINING DOT BELOW
+0324          ; Cher Dupl Latn Syrc            # Mn      COMBINING DIAERESIS BELOW
+0325          ; Latn Syrc                      # Mn      COMBINING RING BELOW
+032D          ; Latn Sunu Syrc                 # Mn      COMBINING CIRCUMFLEX ACCENT BELOW
+032E          ; Latn Syrc                      # Mn      COMBINING BREVE BELOW
+0330          ; Cher Latn Syrc                 # Mn      COMBINING TILDE BELOW
+0331          ; Aghb Cher Goth Latn Sunu Syrc Thai #Mn   COMBINING MACRON BELOW
+0342          ; Grek                           # Mn      COMBINING GREEK PERISPOMENI
+0345          ; Grek                           # Mn      COMBINING GREEK YPOGEGRAMMENI
+0358          ; Latn Osge                      # Mn      COMBINING DOT ABOVE RIGHT
+035E          ; Aghb Latn Todr                 # Mn      COMBINING DOUBLE MACRON
+0363..036F    ; Latn                           # Mn [13] COMBINING LATIN SMALL LETTER A..COMBINING LATIN SMALL LETTER X
+0374          ; Copt Grek                      # Lm      GREEK NUMERAL SIGN
+0375          ; Copt Grek                      # Sk      GREEK LOWER NUMERAL SIGN
+0483          ; Cyrl Perm                      # Mn      COMBINING CYRILLIC TITLO
+0484          ; Cyrl Glag                      # Mn      COMBINING CYRILLIC PALATALIZATION
+0485..0486    ; Cyrl Latn                      # Mn  [2] COMBINING CYRILLIC DASIA PNEUMATA..COMBINING CYRILLIC PSILI PNEUMATA
+0487          ; Cyrl Glag                      # Mn      COMBINING CYRILLIC POKRYTIE
+0589          ; Armn Geor Glag                 # Po      ARMENIAN FULL STOP
+060C          ; Arab Gara Nkoo Rohg Syrc Thaa Yezi #Po   ARABIC COMMA
+061B          ; Arab Gara Nkoo Rohg Syrc Thaa Yezi #Po   ARABIC SEMICOLON
+061C          ; Arab Syrc Thaa                 # Cf      ARABIC LETTER MARK
+061F          ; Adlm Arab Gara Nkoo Rohg Syrc Thaa Yezi #Po ARABIC QUESTION MARK
+0640          ; Adlm Arab Mand Mani Ougr Phlp Rohg Sogd Syrc #Lm ARABIC TATWEEL
+064B..0655    ; Arab Syrc                      # Mn [11] ARABIC FATHATAN..ARABIC HAMZA BELOW
+0660..0669    ; Arab Thaa Yezi                 # Nd [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE
+0670          ; Arab Syrc                      # Mn      ARABIC LETTER SUPERSCRIPT ALEF
+06D4          ; Arab Rohg                      # Po      ARABIC FULL STOP
+0951          ; Beng Deva Gran Gujr Guru Knda Latn Mlym Nand Newa Orya Shrd Taml Telu Tirh #Mn DEVANAGARI STRESS SIGN UDATTA
+0952          ; Beng Deva Gran Gujr Guru Knda Latn Mlym Newa Orya Taml Telu Tirh #Mn DEVANAGARI STRESS SIGN ANUDATTA
+0964          ; Beng Deva Dogr Gong Gonm Gran Gujr Guru Knda Mahj Mlym Nand Onao Orya Sind Sinh Sylo Takr Taml Telu Tirh #Po DEVANAGARI DANDA
+0965          ; Beng Deva Dogr Gong Gonm Gran Gujr Gukh Guru Knda Limb Mahj Mlym Nand Onao Orya Sind Sinh Sylo Takr Taml Telu Tirh #Po DEVANAGARI DOUBLE DANDA
+0966..096F    ; Deva Dogr Kthi Mahj            # Nd [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE
+09E6..09EF    ; Beng Cakm Sylo                 # Nd [10] BENGALI DIGIT ZERO..BENGALI DIGIT NINE
+0A66..0A6F    ; Guru Mult                      # Nd [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE
+0AE6..0AEF    ; Gujr Khoj                      # Nd [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE
+0BE6..0BEF    ; Gran Taml                      # Nd [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE
+0BF0..0BF2    ; Gran Taml                      # No  [3] TAMIL NUMBER TEN..TAMIL NUMBER ONE THOUSAND
+0BF3          ; Gran Taml                      # So      TAMIL DAY SIGN
+0CE6..0CEF    ; Knda Nand Tutg                 # Nd [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
+1040..1049    ; Cakm Mymr Tale                 # Nd [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE
+10FB          ; Geor Glag Latn                 # Po      GEORGIAN PARAGRAPH SEPARATOR
+16EB..16ED    ; Runr                           # Po  [3] RUNIC SINGLE PUNCTUATION..RUNIC CROSS PUNCTUATION
+1735..1736    ; Buhd Hano Tagb Tglg            # Po  [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION
+1802..1803    ; Mong Phag                      # Po  [2] MONGOLIAN COMMA..MONGOLIAN FULL STOP
+1805          ; Mong Phag                      # Po      MONGOLIAN FOUR DOTS
+1CD0          ; Beng Deva Gran Knda            # Mn      VEDIC TONE KARSHANA
+1CD1          ; Deva                           # Mn      VEDIC TONE SHARA
+1CD2          ; Beng Deva Gran Knda            # Mn      VEDIC TONE PRENKHA
+1CD3          ; Deva Gran Knda                 # Po      VEDIC SIGN NIHSHVASA
+1CD4          ; Deva                           # Mn      VEDIC SIGN YAJURVEDIC MIDLINE SVARITA
+1CD5          ; Beng Deva Newa Telu Tirh       # Mn      VEDIC TONE YAJURVEDIC AGGRAVATED INDEPENDENT SVARITA
+1CD6          ; Beng Deva Telu                 # Mn      VEDIC TONE YAJURVEDIC INDEPENDENT SVARITA
+1CD7          ; Deva Newa Shrd                 # Mn      VEDIC TONE YAJURVEDIC KATHAKA INDEPENDENT SVARITA
+1CD8          ; Beng Deva Newa Telu            # Mn      VEDIC TONE CANDRA BELOW
+1CD9          ; Deva Shrd                      # Mn      VEDIC TONE YAJURVEDIC KATHAKA INDEPENDENT SVARITA SCHROEDER
+1CDA          ; Deva Knda Mlym Orya Taml Telu  # Mn      VEDIC TONE DOUBLE SVARITA
+1CDB          ; Deva                           # Mn      VEDIC TONE TRIPLE SVARITA
+1CDC..1CDD    ; Deva Shrd                      # Mn  [2] VEDIC TONE KATHAKA ANUDATTA..VEDIC TONE DOT BELOW
+1CDE..1CDF    ; Deva                           # Mn  [2] VEDIC TONE TWO DOTS BELOW..VEDIC TONE THREE DOTS BELOW
+1CE0          ; Deva Shrd                      # Mn      VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA
+1CE1          ; Beng Deva                      # Mc      VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA
+1CE2          ; Deva Newa Tirh                 # Mn      VEDIC SIGN VISARGA SVARITA
+1CE3..1CE8    ; Deva                           # Mn  [6] VEDIC SIGN VISARGA UDATTA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL
+1CE9          ; Deva Nand Newa                 # Lo      VEDIC SIGN ANUSVARA ANTARGOMUKHA
+1CEA          ; Beng Deva Shrd                 # Lo      VEDIC SIGN ANUSVARA BAHIRGOMUKHA
+1CEB          ; Deva Newa                      # Lo      VEDIC SIGN ANUSVARA VAMAGOMUKHA
+1CEC          ; Deva                           # Lo      VEDIC SIGN ANUSVARA VAMAGOMUKHA WITH TAIL
+1CED          ; Beng Deva Newa Shrd            # Mn      VEDIC SIGN TIRYAK
+1CEE..1CF1    ; Deva                           # Lo  [4] VEDIC SIGN HEXIFORM LONG ANUSVARA..VEDIC SIGN ANUSVARA UBHAYATO MUKHA
+1CF2          ; Beng Deva Gran Knda Mlym Nand Orya Sinh Telu Tirh Tutg #Lo VEDIC SIGN ARDHAVISARGA
+1CF3          ; Deva Gran                      # Lo      VEDIC SIGN ROTATED ARDHAVISARGA
+1CF4          ; Deva Gran Knda Tutg            # Mn      VEDIC TONE CANDRA ABOVE
+1CF5..1CF6    ; Beng Deva                      # Lo  [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN UPADHMANIYA
+1CF7          ; Beng                           # Mc      VEDIC SIGN ATIKRAMA
+1CF8..1CF9    ; Deva Gran                      # Mn  [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE
+1CFA          ; Nand                           # Lo      VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA
+1DC0..1DC1    ; Grek                           # Mn  [2] COMBINING DOTTED GRAVE ACCENT..COMBINING DOTTED ACUTE ACCENT
+1DF8          ; Cyrl Latn Syrc                 # Mn      COMBINING DOT ABOVE LEFT
+1DFA          ; Syrc                           # Mn      COMBINING DOT BELOW LEFT
+202F          ; Latn Mong Phag                 # Zs      NARROW NO-BREAK SPACE
+204F          ; Adlm Arab                      # Po      REVERSED SEMICOLON
+205A          ; Cari Geor Glag Hung Lyci Orkh  # Po      TWO DOT PUNCTUATION
+205D          ; Cari Grek Hung Mero            # Po      TRICOLON
+20F0          ; Deva Gran Latn                 # Mn      COMBINING ASTERISK ABOVE
+2E17          ; Copt Latn                      # Pd      DOUBLE OBLIQUE HYPHEN
+2E30          ; Avst Orkh                      # Po      RING POINT
+2E31          ; Avst Cari Geor Hung Kthi Lydi Samr #Po   WORD SEPARATOR MIDDLE DOT
+2E3C          ; Dupl                           # Po      STENOGRAPHIC FULL STOP
+2E41          ; Adlm Arab Hung                 # Po      REVERSED COMMA
+2E43          ; Cyrl Glag                      # Po      DASH WITH LEFT UPTURN
+2FF0..2FFF    ; Hani Tang                      # So [16] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER ROTATION
+3001          ; Bopo Hang Hani Hira Kana Mong Yiii #Po   IDEOGRAPHIC COMMA
+3002          ; Bopo Hang Hani Hira Kana Mong Phag Yiii #Po IDEOGRAPHIC FULL STOP
+3003          ; Bopo Hang Hani Hira Kana       # Po      DITTO MARK
+3006          ; Hani                           # Lo      IDEOGRAPHIC CLOSING MARK
+3008          ; Bopo Hang Hani Hira Kana Mong Tibt Yiii #Ps LEFT ANGLE BRACKET
+3009          ; Bopo Hang Hani Hira Kana Mong Tibt Yiii #Pe RIGHT ANGLE BRACKET
+300A          ; Bopo Hang Hani Hira Kana Lisu Mong Tibt Yiii #Ps LEFT DOUBLE ANGLE BRACKET
+300B          ; Bopo Hang Hani Hira Kana Lisu Mong Tibt Yiii #Pe RIGHT DOUBLE ANGLE BRACKET
+300C          ; Bopo Hang Hani Hira Kana Yiii  # Ps      LEFT CORNER BRACKET
+300D          ; Bopo Hang Hani Hira Kana Yiii  # Pe      RIGHT CORNER BRACKET
+300E          ; Bopo Hang Hani Hira Kana Yiii  # Ps      LEFT WHITE CORNER BRACKET
+300F          ; Bopo Hang Hani Hira Kana Yiii  # Pe      RIGHT WHITE CORNER BRACKET
+3010          ; Bopo Hang Hani Hira Kana Yiii  # Ps      LEFT BLACK LENTICULAR BRACKET
+3011          ; Bopo Hang Hani Hira Kana Yiii  # Pe      RIGHT BLACK LENTICULAR BRACKET
+3013          ; Bopo Hang Hani Hira Kana       # So      GETA MARK
+3014          ; Bopo Hang Hani Hira Kana Yiii  # Ps      LEFT TORTOISE SHELL BRACKET
+3015          ; Bopo Hang Hani Hira Kana Yiii  # Pe      RIGHT TORTOISE SHELL BRACKET
+3016          ; Bopo Hang Hani Hira Kana Yiii  # Ps      LEFT WHITE LENTICULAR BRACKET
+3017          ; Bopo Hang Hani Hira Kana Yiii  # Pe      RIGHT WHITE LENTICULAR BRACKET
+3018          ; Bopo Hang Hani Hira Kana Yiii  # Ps      LEFT WHITE TORTOISE SHELL BRACKET
+3019          ; Bopo Hang Hani Hira Kana Yiii  # Pe      RIGHT WHITE TORTOISE SHELL BRACKET
+301A          ; Bopo Hang Hani Hira Kana Yiii  # Ps      LEFT WHITE SQUARE BRACKET
+301B          ; Bopo Hang Hani Hira Kana Yiii  # Pe      RIGHT WHITE SQUARE BRACKET
+301C          ; Bopo Hang Hani Hira Kana       # Pd      WAVE DASH
+301D          ; Bopo Hang Hani Hira Kana       # Ps      REVERSED DOUBLE PRIME QUOTATION MARK
+301E..301F    ; Bopo Hang Hani Hira Kana       # Pe  [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK
+302A..302D    ; Bopo Hani                      # Mn  [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK
+3030          ; Bopo Hang Hani Hira Kana       # Pd      WAVY DASH
+3031..3035    ; Hira Kana                      # Lm  [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF
+3037          ; Bopo Hang Hani Hira Kana       # So      IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL
+303C          ; Hani Hira Kana                 # Lo      MASU MARK
+303D          ; Hani Hira Kana                 # Po      PART ALTERNATION MARK
+303E..303F    ; Hani                           # So  [2] IDEOGRAPHIC VARIATION INDICATOR..IDEOGRAPHIC HALF FILL SPACE
+3099..309A    ; Hira Kana                      # Mn  [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+309B..309C    ; Hira Kana                      # Sk  [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+30A0          ; Hira Kana                      # Pd      KATAKANA-HIRAGANA DOUBLE HYPHEN
+30FB          ; Bopo Hang Hani Hira Kana Yiii  # Po      KATAKANA MIDDLE DOT
+30FC          ; Hira Kana                      # Lm      KATAKANA-HIRAGANA PROLONGED SOUND MARK
+3190..3191    ; Hani                           # So  [2] IDEOGRAPHIC ANNOTATION LINKING MARK..IDEOGRAPHIC ANNOTATION REVERSE MARK
+3192..3195    ; Hani                           # No  [4] IDEOGRAPHIC ANNOTATION ONE MARK..IDEOGRAPHIC ANNOTATION FOUR MARK
+3196..319F    ; Hani                           # So [10] IDEOGRAPHIC ANNOTATION TOP MARK..IDEOGRAPHIC ANNOTATION MAN MARK
+31C0..31E5    ; Hani                           # So [38] CJK STROKE T..CJK STROKE SZP
+31EF          ; Hani Tang                      # So      IDEOGRAPHIC DESCRIPTION CHARACTER SUBTRACTION
+3220..3229    ; Hani                           # No [10] PARENTHESIZED IDEOGRAPH ONE..PARENTHESIZED IDEOGRAPH TEN
+322A..3247    ; Hani                           # So [30] PARENTHESIZED IDEOGRAPH MOON..CIRCLED IDEOGRAPH KOTO
+3280..3289    ; Hani                           # No [10] CIRCLED IDEOGRAPH ONE..CIRCLED IDEOGRAPH TEN
+328A..32B0    ; Hani                           # So [39] CIRCLED IDEOGRAPH MOON..CIRCLED IDEOGRAPH NIGHT
+32C0..32CB    ; Hani                           # So [12] IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY..IDEOGRAPHIC TELEGRAPH SYMBOL FOR DECEMBER
+32FF          ; Hani                           # So      SQUARE ERA NAME REIWA
+3358..3370    ; Hani                           # So [25] IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ZERO..IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-FOUR
+337B..337F    ; Hani                           # So  [5] SQUARE ERA NAME HEISEI..SQUARE CORPORATION
+33E0..33FE    ; Hani                           # So [31] IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ONE..IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY-ONE
+A66F          ; Cyrl Glag                      # Mn      COMBINING CYRILLIC VZMET
+A700..A707    ; Hani Latn                      # Sk  [8] MODIFIER LETTER CHINESE TONE YIN PING..MODIFIER LETTER CHINESE TONE YANG RU
+A830..A832    ; Deva Dogr Gujr Guru Khoj Knda Kthi Mahj Mlym Modi Nand Shrd Sind Takr Tirh Tutg #No [3] NORTH INDIC FRACTION ONE QUARTER..NORTH INDIC FRACTION THREE QUARTERS
+A833..A835    ; Deva Dogr Gujr Guru Khoj Knda Kthi Mahj Modi Nand Shrd Sind Takr Tirh Tutg #No [3] NORTH INDIC FRACTION ONE SIXTEENTH..NORTH INDIC FRACTION THREE SIXTEENTHS
+A836..A837    ; Deva Dogr Gujr Guru Khoj Kthi Mahj Modi Sind Takr Tirh #So [2] NORTH INDIC QUARTER MARK..NORTH INDIC PLACEHOLDER MARK
+A838          ; Deva Dogr Gujr Guru Khoj Kthi Mahj Modi Shrd Sind Takr Tirh #Sc NORTH INDIC RUPEE MARK
+A839          ; Deva Dogr Gujr Guru Khoj Kthi Mahj Modi Sind Takr Tirh #So NORTH INDIC QUANTITY MARK
+A8F1          ; Beng Deva Tutg                 # Mn      COMBINING DEVANAGARI SIGN AVAGRAHA
+A8F3          ; Deva Taml                      # Lo      DEVANAGARI SIGN CANDRABINDU VIRAMA
+A92E          ; Kali Latn Mymr                 # Po      KAYAH LI SIGN CWI
+A9CF          ; Bugi Java                      # Lm      JAVANESE PANGRANGKEP
+FD3E          ; Arab Nkoo                      # Pe      ORNATE LEFT PARENTHESIS
+FD3F          ; Arab Nkoo                      # Ps      ORNATE RIGHT PARENTHESIS
+FDF2          ; Arab Thaa                      # Lo      ARABIC LIGATURE ALLAH ISOLATED FORM
+FDFD          ; Arab Thaa                      # So      ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM
+FE45..FE46    ; Bopo Hang Hani Hira Kana       # Po  [2] SESAME DOT..WHITE SESAME DOT
+FF61          ; Bopo Hang Hani Hira Kana Yiii  # Po      HALFWIDTH IDEOGRAPHIC FULL STOP
+FF62          ; Bopo Hang Hani Hira Kana Yiii  # Ps      HALFWIDTH LEFT CORNER BRACKET
+FF63          ; Bopo Hang Hani Hira Kana Yiii  # Pe      HALFWIDTH RIGHT CORNER BRACKET
+FF64..FF65    ; Bopo Hang Hani Hira Kana Yiii  # Po  [2] HALFWIDTH IDEOGRAPHIC COMMA..HALFWIDTH KATAKANA MIDDLE DOT
+FF70          ; Hira Kana                      # Lm      HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK
+FF9E..FF9F    ; Hira Kana                      # Lm  [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
+10100..10101  ; Cpmn Cprt Linb                 # Po  [2] AEGEAN WORD SEPARATOR LINE..AEGEAN WORD SEPARATOR DOT
+10102         ; Cprt Linb                      # Po      AEGEAN CHECK MARK
+10107..10133  ; Cprt Lina Linb                 # No [45] AEGEAN NUMBER ONE..AEGEAN NUMBER NINETY THOUSAND
+10137..1013F  ; Cprt Linb                      # So  [9] AEGEAN WEIGHT BASE UNIT..AEGEAN MEASURE THIRD SUBUNIT
+102E0         ; Arab Copt                      # Mn      COPTIC EPACT THOUSANDS MARK
+102E1..102FB  ; Arab Copt                      # No [27] COPTIC EPACT DIGIT ONE..COPTIC EPACT NUMBER NINE HUNDRED
+10AF2         ; Mani Ougr                      # Po      MANICHAEAN PUNCTUATION DOUBLE DOT WITHIN DOT
+11301         ; Gran Taml                      # Mn      GRANTHA SIGN CANDRABINDU
+11303         ; Gran Taml                      # Mc      GRANTHA SIGN VISARGA
+1133B..1133C  ; Gran Taml                      # Mn  [2] COMBINING BINDU BELOW..GRANTHA SIGN NUKTA
+11FD0..11FD1  ; Gran Taml                      # No  [2] TAMIL FRACTION ONE QUARTER..TAMIL FRACTION ONE HALF-1
+11FD3         ; Gran Taml                      # No      TAMIL FRACTION THREE QUARTERS
+1BCA0..1BCA3  ; Dupl                           # Cf  [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP
+1D360..1D371  ; Hani                           # No [18] COUNTING ROD UNIT DIGIT ONE..COUNTING ROD TENS DIGIT NINE
+1F250..1F251  ; Hani                           # So  [2] CIRCLED IDEOGRAPH ADVANTAGE..CIRCLED IDEOGRAPH ACCEPT
+
+# EOF
diff --git a/lib/elixir/unicode/Scripts.txt b/lib/elixir/unicode/Scripts.txt
new file mode 100644
index 00000000000..5574fdd6ae3
--- /dev/null
+++ b/lib/elixir/unicode/Scripts.txt
@@ -0,0 +1,3182 @@
+# Scripts-17.0.0.txt
+# Date: 2025-07-24, 13:28:55 GMT
+# © 2025 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use and license, see https://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+#   For documentation, see https://www.unicode.org/reports/tr44/
+# For more information, see:
+#   UAX #24, Unicode Script Property: https://www.unicode.org/reports/tr24/
+#     Especially the sections:
+#       https://www.unicode.org/reports/tr24/#Assignment_Script_Values
+#       https://www.unicode.org/reports/tr24/#Assignment_ScriptX_Values
+#
+
+# ================================================
+
+# Property:	Script
+
+#  All code points not explicitly listed for Script
+#  have the value Unknown (Zzzz).
+
+# @missing: 0000..10FFFF; Unknown
+
+# ================================================
+
+0000..001F    ; Common # Cc  [32] <control-0000>..<control-001F>
+0020          ; Common # Zs       SPACE
+0021..0023    ; Common # Po   [3] EXCLAMATION MARK..NUMBER SIGN
+0024          ; Common # Sc       DOLLAR SIGN
+0025..0027    ; Common # Po   [3] PERCENT SIGN..APOSTROPHE
+0028          ; Common # Ps       LEFT PARENTHESIS
+0029          ; Common # Pe       RIGHT PARENTHESIS
+002A          ; Common # Po       ASTERISK
+002B          ; Common # Sm       PLUS SIGN
+002C          ; Common # Po       COMMA
+002D          ; Common # Pd       HYPHEN-MINUS
+002E..002F    ; Common # Po   [2] FULL STOP..SOLIDUS
+0030..0039    ; Common # Nd  [10] DIGIT ZERO..DIGIT NINE
+003A..003B    ; Common # Po   [2] COLON..SEMICOLON
+003C..003E    ; Common # Sm   [3] LESS-THAN SIGN..GREATER-THAN SIGN
+003F..0040    ; Common # Po   [2] QUESTION MARK..COMMERCIAL AT
+005B          ; Common # Ps       LEFT SQUARE BRACKET
+005C          ; Common # Po       REVERSE SOLIDUS
+005D          ; Common # Pe       RIGHT SQUARE BRACKET
+005E          ; Common # Sk       CIRCUMFLEX ACCENT
+005F          ; Common # Pc       LOW LINE
+0060          ; Common # Sk       GRAVE ACCENT
+007B          ; Common # Ps       LEFT CURLY BRACKET
+007C          ; Common # Sm       VERTICAL LINE
+007D          ; Common # Pe       RIGHT CURLY BRACKET
+007E          ; Common # Sm       TILDE
+007F..009F    ; Common # Cc  [33] <control-007F>..<control-009F>
+00A0          ; Common # Zs       NO-BREAK SPACE
+00A1          ; Common # Po       INVERTED EXCLAMATION MARK
+00A2..00A5    ; Common # Sc   [4] CENT SIGN..YEN SIGN
+00A6          ; Common # So       BROKEN BAR
+00A7          ; Common # Po       SECTION SIGN
+00A8          ; Common # Sk       DIAERESIS
+00A9          ; Common # So       COPYRIGHT SIGN
+00AB          ; Common # Pi       LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+00AC          ; Common # Sm       NOT SIGN
+00AD          ; Common # Cf       SOFT HYPHEN
+00AE          ; Common # So       REGISTERED SIGN
+00AF          ; Common # Sk       MACRON
+00B0          ; Common # So       DEGREE SIGN
+00B1          ; Common # Sm       PLUS-MINUS SIGN
+00B2..00B3    ; Common # No   [2] SUPERSCRIPT TWO..SUPERSCRIPT THREE
+00B4          ; Common # Sk       ACUTE ACCENT
+00B5          ; Common # L&       MICRO SIGN
+00B6..00B7    ; Common # Po   [2] PILCROW SIGN..MIDDLE DOT
+00B8          ; Common # Sk       CEDILLA
+00B9          ; Common # No       SUPERSCRIPT ONE
+00BB          ; Common # Pf       RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+00BC..00BE    ; Common # No   [3] VULGAR FRACTION ONE QUARTER..VULGAR FRACTION THREE QUARTERS
+00BF          ; Common # Po       INVERTED QUESTION MARK
+00D7          ; Common # Sm       MULTIPLICATION SIGN
+00F7          ; Common # Sm       DIVISION SIGN
+02B9..02C1    ; Common # Lm   [9] MODIFIER LETTER PRIME..MODIFIER LETTER REVERSED GLOTTAL STOP
+02C2..02C5    ; Common # Sk   [4] MODIFIER LETTER LEFT ARROWHEAD..MODIFIER LETTER DOWN ARROWHEAD
+02C6..02D1    ; Common # Lm  [12] MODIFIER LETTER CIRCUMFLEX ACCENT..MODIFIER LETTER HALF TRIANGULAR COLON
+02D2..02DF    ; Common # Sk  [14] MODIFIER LETTER CENTRED RIGHT HALF RING..MODIFIER LETTER CROSS ACCENT
+02E5..02E9    ; Common # Sk   [5] MODIFIER LETTER EXTRA-HIGH TONE BAR..MODIFIER LETTER EXTRA-LOW TONE BAR
+02EC          ; Common # Lm       MODIFIER LETTER VOICING
+02ED          ; Common # Sk       MODIFIER LETTER UNASPIRATED
+02EE          ; Common # Lm       MODIFIER LETTER DOUBLE APOSTROPHE
+02EF..02FF    ; Common # Sk  [17] MODIFIER LETTER LOW DOWN ARROWHEAD..MODIFIER LETTER LOW LEFT ARROW
+0374          ; Common # Lm       GREEK NUMERAL SIGN
+037E          ; Common # Po       GREEK QUESTION MARK
+0385          ; Common # Sk       GREEK DIALYTIKA TONOS
+0387          ; Common # Po       GREEK ANO TELEIA
+0605          ; Common # Cf       ARABIC NUMBER MARK ABOVE
+060C          ; Common # Po       ARABIC COMMA
+061B          ; Common # Po       ARABIC SEMICOLON
+061F          ; Common # Po       ARABIC QUESTION MARK
+0640          ; Common # Lm       ARABIC TATWEEL
+06DD          ; Common # Cf       ARABIC END OF AYAH
+08E2          ; Common # Cf       ARABIC DISPUTED END OF AYAH
+0964..0965    ; Common # Po   [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA
+0E3F          ; Common # Sc       THAI CURRENCY SYMBOL BAHT
+0FD5..0FD8    ; Common # So   [4] RIGHT-FACING SVASTI SIGN..LEFT-FACING SVASTI SIGN WITH DOTS
+10FB          ; Common # Po       GEORGIAN PARAGRAPH SEPARATOR
+16EB..16ED    ; Common # Po   [3] RUNIC SINGLE PUNCTUATION..RUNIC CROSS PUNCTUATION
+1735..1736    ; Common # Po   [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION
+1802..1803    ; Common # Po   [2] MONGOLIAN COMMA..MONGOLIAN FULL STOP
+1805          ; Common # Po       MONGOLIAN FOUR DOTS
+1CD3          ; Common # Po       VEDIC SIGN NIHSHVASA
+1CE1          ; Common # Mc       VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA
+1CE9..1CEC    ; Common # Lo   [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA..VEDIC SIGN ANUSVARA VAMAGOMUKHA WITH TAIL
+1CEE..1CF3    ; Common # Lo   [6] VEDIC SIGN HEXIFORM LONG ANUSVARA..VEDIC SIGN ROTATED ARDHAVISARGA
+1CF5..1CF6    ; Common # Lo   [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN UPADHMANIYA
+1CF7          ; Common # Mc       VEDIC SIGN ATIKRAMA
+1CFA          ; Common # Lo       VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA
+2000..200A    ; Common # Zs  [11] EN QUAD..HAIR SPACE
+200B          ; Common # Cf       ZERO WIDTH SPACE
+200E..200F    ; Common # Cf   [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT MARK
+2010..2015    ; Common # Pd   [6] HYPHEN..HORIZONTAL BAR
+2016..2017    ; Common # Po   [2] DOUBLE VERTICAL LINE..DOUBLE LOW LINE
+2018          ; Common # Pi       LEFT SINGLE QUOTATION MARK
+2019          ; Common # Pf       RIGHT SINGLE QUOTATION MARK
+201A          ; Common # Ps       SINGLE LOW-9 QUOTATION MARK
+201B..201C    ; Common # Pi   [2] SINGLE HIGH-REVERSED-9 QUOTATION MARK..LEFT DOUBLE QUOTATION MARK
+201D          ; Common # Pf       RIGHT DOUBLE QUOTATION MARK
+201E          ; Common # Ps       DOUBLE LOW-9 QUOTATION MARK
+201F          ; Common # Pi       DOUBLE HIGH-REVERSED-9 QUOTATION MARK
+2020..2027    ; Common # Po   [8] DAGGER..HYPHENATION POINT
+2028          ; Common # Zl       LINE SEPARATOR
+2029          ; Common # Zp       PARAGRAPH SEPARATOR
+202A..202E    ; Common # Cf   [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE
+202F          ; Common # Zs       NARROW NO-BREAK SPACE
+2030..2038    ; Common # Po   [9] PER MILLE SIGN..CARET
+2039          ; Common # Pi       SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+203A          ; Common # Pf       SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+203B..203E    ; Common # Po   [4] REFERENCE MARK..OVERLINE
+203F..2040    ; Common # Pc   [2] UNDERTIE..CHARACTER TIE
+2041..2043    ; Common # Po   [3] CARET INSERTION POINT..HYPHEN BULLET
+2044          ; Common # Sm       FRACTION SLASH
+2045          ; Common # Ps       LEFT SQUARE BRACKET WITH QUILL
+2046          ; Common # Pe       RIGHT SQUARE BRACKET WITH QUILL
+2047..2051    ; Common # Po  [11] DOUBLE QUESTION MARK..TWO ASTERISKS ALIGNED VERTICALLY
+2052          ; Common # Sm       COMMERCIAL MINUS SIGN
+2053          ; Common # Po       SWUNG DASH
+2054          ; Common # Pc       INVERTED UNDERTIE
+2055..205E    ; Common # Po  [10] FLOWER PUNCTUATION MARK..VERTICAL FOUR DOTS
+205F          ; Common # Zs       MEDIUM MATHEMATICAL SPACE
+2060..2064    ; Common # Cf   [5] WORD JOINER..INVISIBLE PLUS
+2066..206F    ; Common # Cf  [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES
+2070          ; Common # No       SUPERSCRIPT ZERO
+2074..2079    ; Common # No   [6] SUPERSCRIPT FOUR..SUPERSCRIPT NINE
+207A..207C    ; Common # Sm   [3] SUPERSCRIPT PLUS SIGN..SUPERSCRIPT EQUALS SIGN
+207D          ; Common # Ps       SUPERSCRIPT LEFT PARENTHESIS
+207E          ; Common # Pe       SUPERSCRIPT RIGHT PARENTHESIS
+2080..2089    ; Common # No  [10] SUBSCRIPT ZERO..SUBSCRIPT NINE
+208A..208C    ; Common # Sm   [3] SUBSCRIPT PLUS SIGN..SUBSCRIPT EQUALS SIGN
+208D          ; Common # Ps       SUBSCRIPT LEFT PARENTHESIS
+208E          ; Common # Pe       SUBSCRIPT RIGHT PARENTHESIS
+20A0..20C1    ; Common # Sc  [34] EURO-CURRENCY SIGN..SAUDI RIYAL SIGN
+2100..2101    ; Common # So   [2] ACCOUNT OF..ADDRESSED TO THE SUBJECT
+2102          ; Common # L&       DOUBLE-STRUCK CAPITAL C
+2103..2106    ; Common # So   [4] DEGREE CELSIUS..CADA UNA
+2107          ; Common # L&       EULER CONSTANT
+2108..2109    ; Common # So   [2] SCRUPLE..DEGREE FAHRENHEIT
+210A..2113    ; Common # L&  [10] SCRIPT SMALL G..SCRIPT SMALL L
+2114          ; Common # So       L B BAR SYMBOL
+2115          ; Common # L&       DOUBLE-STRUCK CAPITAL N
+2116..2117    ; Common # So   [2] NUMERO SIGN..SOUND RECORDING COPYRIGHT
+2118          ; Common # Sm       SCRIPT CAPITAL P
+2119..211D    ; Common # L&   [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R
+211E..2123    ; Common # So   [6] PRESCRIPTION TAKE..VERSICLE
+2124          ; Common # L&       DOUBLE-STRUCK CAPITAL Z
+2125          ; Common # So       OUNCE SIGN
+2127          ; Common # So       INVERTED OHM SIGN
+2128          ; Common # L&       BLACK-LETTER CAPITAL Z
+2129          ; Common # So       TURNED GREEK SMALL LETTER IOTA
+212C..212D    ; Common # L&   [2] SCRIPT CAPITAL B..BLACK-LETTER CAPITAL C
+212E          ; Common # So       ESTIMATED SYMBOL
+212F..2131    ; Common # L&   [3] SCRIPT SMALL E..SCRIPT CAPITAL F
+2133..2134    ; Common # L&   [2] SCRIPT CAPITAL M..SCRIPT SMALL O
+2135..2138    ; Common # Lo   [4] ALEF SYMBOL..DALET SYMBOL
+2139          ; Common # L&       INFORMATION SOURCE
+213A..213B    ; Common # So   [2] ROTATED CAPITAL Q..FACSIMILE SIGN
+213C..213F    ; Common # L&   [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STRUCK CAPITAL PI
+2140..2144    ; Common # Sm   [5] DOUBLE-STRUCK N-ARY SUMMATION..TURNED SANS-SERIF CAPITAL Y
+2145..2149    ; Common # L&   [5] DOUBLE-STRUCK ITALIC CAPITAL D..DOUBLE-STRUCK ITALIC SMALL J
+214A          ; Common # So       PROPERTY LINE
+214B          ; Common # Sm       TURNED AMPERSAND
+214C..214D    ; Common # So   [2] PER SIGN..AKTIESELSKAB
+214F          ; Common # So       SYMBOL FOR SAMARITAN SOURCE
+2150..215F    ; Common # No  [16] VULGAR FRACTION ONE SEVENTH..FRACTION NUMERATOR ONE
+2189          ; Common # No       VULGAR FRACTION ZERO THIRDS
+218A..218B    ; Common # So   [2] TURNED DIGIT TWO..TURNED DIGIT THREE
+2190..2194    ; Common # Sm   [5] LEFTWARDS ARROW..LEFT RIGHT ARROW
+2195..2199    ; Common # So   [5] UP DOWN ARROW..SOUTH WEST ARROW
+219A..219B    ; Common # Sm   [2] LEFTWARDS ARROW WITH STROKE..RIGHTWARDS ARROW WITH STROKE
+219C..219F    ; Common # So   [4] LEFTWARDS WAVE ARROW..UPWARDS TWO HEADED ARROW
+21A0          ; Common # Sm       RIGHTWARDS TWO HEADED ARROW
+21A1..21A2    ; Common # So   [2] DOWNWARDS TWO HEADED ARROW..LEFTWARDS ARROW WITH TAIL
+21A3          ; Common # Sm       RIGHTWARDS ARROW WITH TAIL
+21A4..21A5    ; Common # So   [2] LEFTWARDS ARROW FROM BAR..UPWARDS ARROW FROM BAR
+21A6          ; Common # Sm       RIGHTWARDS ARROW FROM BAR
+21A7..21AD    ; Common # So   [7] DOWNWARDS ARROW FROM BAR..LEFT RIGHT WAVE ARROW
+21AE          ; Common # Sm       LEFT RIGHT ARROW WITH STROKE
+21AF..21CD    ; Common # So  [31] DOWNWARDS ZIGZAG ARROW..LEFTWARDS DOUBLE ARROW WITH STROKE
+21CE..21CF    ; Common # Sm   [2] LEFT RIGHT DOUBLE ARROW WITH STROKE..RIGHTWARDS DOUBLE ARROW WITH STROKE
+21D0..21D1    ; Common # So   [2] LEFTWARDS DOUBLE ARROW..UPWARDS DOUBLE ARROW
+21D2          ; Common # Sm       RIGHTWARDS DOUBLE ARROW
+21D3          ; Common # So       DOWNWARDS DOUBLE ARROW
+21D4          ; Common # Sm       LEFT RIGHT DOUBLE ARROW
+21D5..21F3    ; Common # So  [31] UP DOWN DOUBLE ARROW..UP DOWN WHITE ARROW
+21F4..22FF    ; Common # Sm [268] RIGHT ARROW WITH SMALL CIRCLE..Z NOTATION BAG MEMBERSHIP
+2300..2307    ; Common # So   [8] DIAMETER SIGN..WAVY LINE
+2308          ; Common # Ps       LEFT CEILING
+2309          ; Common # Pe       RIGHT CEILING
+230A          ; Common # Ps       LEFT FLOOR
+230B          ; Common # Pe       RIGHT FLOOR
+230C..231F    ; Common # So  [20] BOTTOM RIGHT CROP..BOTTOM RIGHT CORNER
+2320..2321    ; Common # Sm   [2] TOP HALF INTEGRAL..BOTTOM HALF INTEGRAL
+2322..2328    ; Common # So   [7] FROWN..KEYBOARD
+2329          ; Common # Ps       LEFT-POINTING ANGLE BRACKET
+232A          ; Common # Pe       RIGHT-POINTING ANGLE BRACKET
+232B..237B    ; Common # So  [81] ERASE TO THE LEFT..NOT CHECK MARK
+237C          ; Common # Sm       RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW
+237D..239A    ; Common # So  [30] SHOULDERED OPEN BOX..CLEAR SCREEN SYMBOL
+239B..23B3    ; Common # Sm  [25] LEFT PARENTHESIS UPPER HOOK..SUMMATION BOTTOM
+23B4..23DB    ; Common # So  [40] TOP SQUARE BRACKET..FUSE
+23DC..23E1    ; Common # Sm   [6] TOP PARENTHESIS..BOTTOM TORTOISE SHELL BRACKET
+23E2..2429    ; Common # So  [72] WHITE TRAPEZIUM..SYMBOL FOR DELETE MEDIUM SHADE FORM
+2440..244A    ; Common # So  [11] OCR HOOK..OCR DOUBLE BACKSLASH
+2460..249B    ; Common # No  [60] CIRCLED DIGIT ONE..NUMBER TWENTY FULL STOP
+249C..24E9    ; Common # So  [78] PARENTHESIZED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z
+24EA..24FF    ; Common # No  [22] CIRCLED DIGIT ZERO..NEGATIVE CIRCLED DIGIT ZERO
+2500..25B6    ; Common # So [183] BOX DRAWINGS LIGHT HORIZONTAL..BLACK RIGHT-POINTING TRIANGLE
+25B7          ; Common # Sm       WHITE RIGHT-POINTING TRIANGLE
+25B8..25C0    ; Common # So   [9] BLACK RIGHT-POINTING SMALL TRIANGLE..BLACK LEFT-POINTING TRIANGLE
+25C1          ; Common # Sm       WHITE LEFT-POINTING TRIANGLE
+25C2..25F7    ; Common # So  [54] BLACK LEFT-POINTING SMALL TRIANGLE..WHITE CIRCLE WITH UPPER RIGHT QUADRANT
+25F8..25FF    ; Common # Sm   [8] UPPER LEFT TRIANGLE..LOWER RIGHT TRIANGLE
+2600..266E    ; Common # So [111] BLACK SUN WITH RAYS..MUSIC NATURAL SIGN
+266F          ; Common # Sm       MUSIC SHARP SIGN
+2670..2767    ; Common # So [248] WEST SYRIAC CROSS..ROTATED FLORAL HEART BULLET
+2768          ; Common # Ps       MEDIUM LEFT PARENTHESIS ORNAMENT
+2769          ; Common # Pe       MEDIUM RIGHT PARENTHESIS ORNAMENT
+276A          ; Common # Ps       MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT
+276B          ; Common # Pe       MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT
+276C          ; Common # Ps       MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT
+276D          ; Common # Pe       MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT
+276E          ; Common # Ps       HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT
+276F          ; Common # Pe       HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT
+2770          ; Common # Ps       HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT
+2771          ; Common # Pe       HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT
+2772          ; Common # Ps       LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT
+2773          ; Common # Pe       LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT
+2774          ; Common # Ps       MEDIUM LEFT CURLY BRACKET ORNAMENT
+2775          ; Common # Pe       MEDIUM RIGHT CURLY BRACKET ORNAMENT
+2776..2793    ; Common # No  [30] DINGBAT NEGATIVE CIRCLED DIGIT ONE..DINGBAT NEGATIVE CIRCLED SANS-SERIF NUMBER TEN
+2794..27BF    ; Common # So  [44] HEAVY WIDE-HEADED RIGHTWARDS ARROW..DOUBLE CURLY LOOP
+27C0..27C4    ; Common # Sm   [5] THREE DIMENSIONAL ANGLE..OPEN SUPERSET
+27C5          ; Common # Ps       LEFT S-SHAPED BAG DELIMITER
+27C6          ; Common # Pe       RIGHT S-SHAPED BAG DELIMITER
+27C7..27E5    ; Common # Sm  [31] OR WITH DOT INSIDE..WHITE SQUARE WITH RIGHTWARDS TICK
+27E6          ; Common # Ps       MATHEMATICAL LEFT WHITE SQUARE BRACKET
+27E7          ; Common # Pe       MATHEMATICAL RIGHT WHITE SQUARE BRACKET
+27E8          ; Common # Ps       MATHEMATICAL LEFT ANGLE BRACKET
+27E9          ; Common # Pe       MATHEMATICAL RIGHT ANGLE BRACKET
+27EA          ; Common # Ps       MATHEMATICAL LEFT DOUBLE ANGLE BRACKET
+27EB          ; Common # Pe       MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET
+27EC          ; Common # Ps       MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET
+27ED          ; Common # Pe       MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET
+27EE          ; Common # Ps       MATHEMATICAL LEFT FLATTENED PARENTHESIS
+27EF          ; Common # Pe       MATHEMATICAL RIGHT FLATTENED PARENTHESIS
+27F0..27FF    ; Common # Sm  [16] UPWARDS QUADRUPLE ARROW..LONG RIGHTWARDS SQUIGGLE ARROW
+2900..2982    ; Common # Sm [131] RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE..Z NOTATION TYPE COLON
+2983          ; Common # Ps       LEFT WHITE CURLY BRACKET
+2984          ; Common # Pe       RIGHT WHITE CURLY BRACKET
+2985          ; Common # Ps       LEFT WHITE PARENTHESIS
+2986          ; Common # Pe       RIGHT WHITE PARENTHESIS
+2987          ; Common # Ps       Z NOTATION LEFT IMAGE BRACKET
+2988          ; Common # Pe       Z NOTATION RIGHT IMAGE BRACKET
+2989          ; Common # Ps       Z NOTATION LEFT BINDING BRACKET
+298A          ; Common # Pe       Z NOTATION RIGHT BINDING BRACKET
+298B          ; Common # Ps       LEFT SQUARE BRACKET WITH UNDERBAR
+298C          ; Common # Pe       RIGHT SQUARE BRACKET WITH UNDERBAR
+298D          ; Common # Ps       LEFT SQUARE BRACKET WITH TICK IN TOP CORNER
+298E          ; Common # Pe       RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+298F          ; Common # Ps       LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+2990          ; Common # Pe       RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER
+2991          ; Common # Ps       LEFT ANGLE BRACKET WITH DOT
+2992          ; Common # Pe       RIGHT ANGLE BRACKET WITH DOT
+2993          ; Common # Ps       LEFT ARC LESS-THAN BRACKET
+2994          ; Common # Pe       RIGHT ARC GREATER-THAN BRACKET
+2995          ; Common # Ps       DOUBLE LEFT ARC GREATER-THAN BRACKET
+2996          ; Common # Pe       DOUBLE RIGHT ARC LESS-THAN BRACKET
+2997          ; Common # Ps       LEFT BLACK TORTOISE SHELL BRACKET
+2998          ; Common # Pe       RIGHT BLACK TORTOISE SHELL BRACKET
+2999..29D7    ; Common # Sm  [63] DOTTED FENCE..BLACK HOURGLASS
+29D8          ; Common # Ps       LEFT WIGGLY FENCE
+29D9          ; Common # Pe       RIGHT WIGGLY FENCE
+29DA          ; Common # Ps       LEFT DOUBLE WIGGLY FENCE
+29DB          ; Common # Pe       RIGHT DOUBLE WIGGLY FENCE
+29DC..29FB    ; Common # Sm  [32] INCOMPLETE INFINITY..TRIPLE PLUS
+29FC          ; Common # Ps       LEFT-POINTING CURVED ANGLE BRACKET
+29FD          ; Common # Pe       RIGHT-POINTING CURVED ANGLE BRACKET
+29FE..2AFF    ; Common # Sm [258] TINY..N-ARY WHITE VERTICAL BAR
+2B00..2B2F    ; Common # So  [48] NORTH EAST WHITE ARROW..WHITE VERTICAL ELLIPSE
+2B30..2B44    ; Common # Sm  [21] LEFT ARROW WITH SMALL CIRCLE..RIGHTWARDS ARROW THROUGH SUPERSET
+2B45..2B46    ; Common # So   [2] LEFTWARDS QUADRUPLE ARROW..RIGHTWARDS QUADRUPLE ARROW
+2B47..2B4C    ; Common # Sm   [6] REVERSE TILDE OPERATOR ABOVE RIGHTWARDS ARROW..RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR
+2B4D..2B73    ; Common # So  [39] DOWNWARDS TRIANGLE-HEADED ZIGZAG ARROW..DOWNWARDS TRIANGLE-HEADED ARROW TO BAR
+2B76..2BFF    ; Common # So [138] NORTH WEST TRIANGLE-HEADED ARROW TO BAR..HELLSCHREIBER PAUSE SYMBOL
+2E00..2E01    ; Common # Po   [2] RIGHT ANGLE SUBSTITUTION MARKER..RIGHT ANGLE DOTTED SUBSTITUTION MARKER
+2E02          ; Common # Pi       LEFT SUBSTITUTION BRACKET
+2E03          ; Common # Pf       RIGHT SUBSTITUTION BRACKET
+2E04          ; Common # Pi       LEFT DOTTED SUBSTITUTION BRACKET
+2E05          ; Common # Pf       RIGHT DOTTED SUBSTITUTION BRACKET
+2E06..2E08    ; Common # Po   [3] RAISED INTERPOLATION MARKER..DOTTED TRANSPOSITION MARKER
+2E09          ; Common # Pi       LEFT TRANSPOSITION BRACKET
+2E0A          ; Common # Pf       RIGHT TRANSPOSITION BRACKET
+2E0B          ; Common # Po       RAISED SQUARE
+2E0C          ; Common # Pi       LEFT RAISED OMISSION BRACKET
+2E0D          ; Common # Pf       RIGHT RAISED OMISSION BRACKET
+2E0E..2E16    ; Common # Po   [9] EDITORIAL CORONIS..DOTTED RIGHT-POINTING ANGLE
+2E17          ; Common # Pd       DOUBLE OBLIQUE HYPHEN
+2E18..2E19    ; Common # Po   [2] INVERTED INTERROBANG..PALM BRANCH
+2E1A          ; Common # Pd       HYPHEN WITH DIAERESIS
+2E1B          ; Common # Po       TILDE WITH RING ABOVE
+2E1C          ; Common # Pi       LEFT LOW PARAPHRASE BRACKET
+2E1D          ; Common # Pf       RIGHT LOW PARAPHRASE BRACKET
+2E1E..2E1F    ; Common # Po   [2] TILDE WITH DOT ABOVE..TILDE WITH DOT BELOW
+2E20          ; Common # Pi       LEFT VERTICAL BAR WITH QUILL
+2E21          ; Common # Pf       RIGHT VERTICAL BAR WITH QUILL
+2E22          ; Common # Ps       TOP LEFT HALF BRACKET
+2E23          ; Common # Pe       TOP RIGHT HALF BRACKET
+2E24          ; Common # Ps       BOTTOM LEFT HALF BRACKET
+2E25          ; Common # Pe       BOTTOM RIGHT HALF BRACKET
+2E26          ; Common # Ps       LEFT SIDEWAYS U BRACKET
+2E27          ; Common # Pe       RIGHT SIDEWAYS U BRACKET
+2E28          ; Common # Ps       LEFT DOUBLE PARENTHESIS
+2E29          ; Common # Pe       RIGHT DOUBLE PARENTHESIS
+2E2A..2E2E    ; Common # Po   [5] TWO DOTS OVER ONE DOT PUNCTUATION..REVERSED QUESTION MARK
+2E2F          ; Common # Lm       VERTICAL TILDE
+2E30..2E39    ; Common # Po  [10] RING POINT..TOP HALF SECTION SIGN
+2E3A..2E3B    ; Common # Pd   [2] TWO-EM DASH..THREE-EM DASH
+2E3C..2E3F    ; Common # Po   [4] STENOGRAPHIC FULL STOP..CAPITULUM
+2E40          ; Common # Pd       DOUBLE HYPHEN
+2E41          ; Common # Po       REVERSED COMMA
+2E42          ; Common # Ps       DOUBLE LOW-REVERSED-9 QUOTATION MARK
+2E43..2E4F    ; Common # Po  [13] DASH WITH LEFT UPTURN..CORNISH VERSE DIVIDER
+2E50..2E51    ; Common # So   [2] CROSS PATTY WITH RIGHT CROSSBAR..CROSS PATTY WITH LEFT CROSSBAR
+2E52..2E54    ; Common # Po   [3] TIRONIAN SIGN CAPITAL ET..MEDIEVAL QUESTION MARK
+2E55          ; Common # Ps       LEFT SQUARE BRACKET WITH STROKE
+2E56          ; Common # Pe       RIGHT SQUARE BRACKET WITH STROKE
+2E57          ; Common # Ps       LEFT SQUARE BRACKET WITH DOUBLE STROKE
+2E58          ; Common # Pe       RIGHT SQUARE BRACKET WITH DOUBLE STROKE
+2E59          ; Common # Ps       TOP HALF LEFT PARENTHESIS
+2E5A          ; Common # Pe       TOP HALF RIGHT PARENTHESIS
+2E5B          ; Common # Ps       BOTTOM HALF LEFT PARENTHESIS
+2E5C          ; Common # Pe       BOTTOM HALF RIGHT PARENTHESIS
+2E5D          ; Common # Pd       OBLIQUE HYPHEN
+2FF0..2FFF    ; Common # So  [16] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER ROTATION
+3000          ; Common # Zs       IDEOGRAPHIC SPACE
+3001..3003    ; Common # Po   [3] IDEOGRAPHIC COMMA..DITTO MARK
+3004          ; Common # So       JAPANESE INDUSTRIAL STANDARD SYMBOL
+3006          ; Common # Lo       IDEOGRAPHIC CLOSING MARK
+3008          ; Common # Ps       LEFT ANGLE BRACKET
+3009          ; Common # Pe       RIGHT ANGLE BRACKET
+300A          ; Common # Ps       LEFT DOUBLE ANGLE BRACKET
+300B          ; Common # Pe       RIGHT DOUBLE ANGLE BRACKET
+300C          ; Common # Ps       LEFT CORNER BRACKET
+300D          ; Common # Pe       RIGHT CORNER BRACKET
+300E          ; Common # Ps       LEFT WHITE CORNER BRACKET
+300F          ; Common # Pe       RIGHT WHITE CORNER BRACKET
+3010          ; Common # Ps       LEFT BLACK LENTICULAR BRACKET
+3011          ; Common # Pe       RIGHT BLACK LENTICULAR BRACKET
+3012..3013    ; Common # So   [2] POSTAL MARK..GETA MARK
+3014          ; Common # Ps       LEFT TORTOISE SHELL BRACKET
+3015          ; Common # Pe       RIGHT TORTOISE SHELL BRACKET
+3016          ; Common # Ps       LEFT WHITE LENTICULAR BRACKET
+3017          ; Common # Pe       RIGHT WHITE LENTICULAR BRACKET
+3018          ; Common # Ps       LEFT WHITE TORTOISE SHELL BRACKET
+3019          ; Common # Pe       RIGHT WHITE TORTOISE SHELL BRACKET
+301A          ; Common # Ps       LEFT WHITE SQUARE BRACKET
+301B          ; Common # Pe       RIGHT WHITE SQUARE BRACKET
+301C          ; Common # Pd       WAVE DASH
+301D          ; Common # Ps       REVERSED DOUBLE PRIME QUOTATION MARK
+301E..301F    ; Common # Pe   [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK
+3020          ; Common # So       POSTAL MARK FACE
+3030          ; Common # Pd       WAVY DASH
+3031..3035    ; Common # Lm   [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF
+3036..3037    ; Common # So   [2] CIRCLED POSTAL MARK..IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL
+303C          ; Common # Lo       MASU MARK
+303D          ; Common # Po       PART ALTERNATION MARK
+303E..303F    ; Common # So   [2] IDEOGRAPHIC VARIATION INDICATOR..IDEOGRAPHIC HALF FILL SPACE
+309B..309C    ; Common # Sk   [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+30A0          ; Common # Pd       KATAKANA-HIRAGANA DOUBLE HYPHEN
+30FB          ; Common # Po       KATAKANA MIDDLE DOT
+30FC          ; Common # Lm       KATAKANA-HIRAGANA PROLONGED SOUND MARK
+3190..3191    ; Common # So   [2] IDEOGRAPHIC ANNOTATION LINKING MARK..IDEOGRAPHIC ANNOTATION REVERSE MARK
+3192..3195    ; Common # No   [4] IDEOGRAPHIC ANNOTATION ONE MARK..IDEOGRAPHIC ANNOTATION FOUR MARK
+3196..319F    ; Common # So  [10] IDEOGRAPHIC ANNOTATION TOP MARK..IDEOGRAPHIC ANNOTATION MAN MARK
+31C0..31E5    ; Common # So  [38] CJK STROKE T..CJK STROKE SZP
+31EF          ; Common # So       IDEOGRAPHIC DESCRIPTION CHARACTER SUBTRACTION
+3220..3229    ; Common # No  [10] PARENTHESIZED IDEOGRAPH ONE..PARENTHESIZED IDEOGRAPH TEN
+322A..3247    ; Common # So  [30] PARENTHESIZED IDEOGRAPH MOON..CIRCLED IDEOGRAPH KOTO
+3248..324F    ; Common # No   [8] CIRCLED NUMBER TEN ON BLACK SQUARE..CIRCLED NUMBER EIGHTY ON BLACK SQUARE
+3250          ; Common # So       PARTNERSHIP SIGN
+3251..325F    ; Common # No  [15] CIRCLED NUMBER TWENTY ONE..CIRCLED NUMBER THIRTY FIVE
+327F          ; Common # So       KOREAN STANDARD SYMBOL
+3280..3289    ; Common # No  [10] CIRCLED IDEOGRAPH ONE..CIRCLED IDEOGRAPH TEN
+328A..32B0    ; Common # So  [39] CIRCLED IDEOGRAPH MOON..CIRCLED IDEOGRAPH NIGHT
+32B1..32BF    ; Common # No  [15] CIRCLED NUMBER THIRTY SIX..CIRCLED NUMBER FIFTY
+32C0..32CF    ; Common # So  [16] IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY..LIMITED LIABILITY SIGN
+32FF          ; Common # So       SQUARE ERA NAME REIWA
+3358..33FF    ; Common # So [168] IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ZERO..SQUARE GAL
+4DC0..4DFF    ; Common # So  [64] HEXAGRAM FOR THE CREATIVE HEAVEN..HEXAGRAM FOR BEFORE COMPLETION
+A700..A716    ; Common # Sk  [23] MODIFIER LETTER CHINESE TONE YIN PING..MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR
+A717..A71F    ; Common # Lm   [9] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK
+A720..A721    ; Common # Sk   [2] MODIFIER LETTER STRESS AND HIGH TONE..MODIFIER LETTER STRESS AND LOW TONE
+A788          ; Common # Lm       MODIFIER LETTER LOW CIRCUMFLEX ACCENT
+A789..A78A    ; Common # Sk   [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN
+A830..A835    ; Common # No   [6] NORTH INDIC FRACTION ONE QUARTER..NORTH INDIC FRACTION THREE SIXTEENTHS
+A836..A837    ; Common # So   [2] NORTH INDIC QUARTER MARK..NORTH INDIC PLACEHOLDER MARK
+A838          ; Common # Sc       NORTH INDIC RUPEE MARK
+A839          ; Common # So       NORTH INDIC QUANTITY MARK
+A92E          ; Common # Po       KAYAH LI SIGN CWI
+A9CF          ; Common # Lm       JAVANESE PANGRANGKEP
+AB5B          ; Common # Sk       MODIFIER BREVE WITH INVERTED BREVE
+AB6A..AB6B    ; Common # Sk   [2] MODIFIER LETTER LEFT TACK..MODIFIER LETTER RIGHT TACK
+FD3E          ; Common # Pe       ORNATE LEFT PARENTHESIS
+FD3F          ; Common # Ps       ORNATE RIGHT PARENTHESIS
+FE10..FE16    ; Common # Po   [7] PRESENTATION FORM FOR VERTICAL COMMA..PRESENTATION FORM FOR VERTICAL QUESTION MARK
+FE17          ; Common # Ps       PRESENTATION FORM FOR VERTICAL LEFT WHITE LENTICULAR BRACKET
+FE18          ; Common # Pe       PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET
+FE19          ; Common # Po       PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS
+FE30          ; Common # Po       PRESENTATION FORM FOR VERTICAL TWO DOT LEADER
+FE31..FE32    ; Common # Pd   [2] PRESENTATION FORM FOR VERTICAL EM DASH..PRESENTATION FORM FOR VERTICAL EN DASH
+FE33..FE34    ; Common # Pc   [2] PRESENTATION FORM FOR VERTICAL LOW LINE..PRESENTATION FORM FOR VERTICAL WAVY LOW LINE
+FE35          ; Common # Ps       PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS
+FE36          ; Common # Pe       PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS
+FE37          ; Common # Ps       PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET
+FE38          ; Common # Pe       PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET
+FE39          ; Common # Ps       PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET
+FE3A          ; Common # Pe       PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET
+FE3B          ; Common # Ps       PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET
+FE3C          ; Common # Pe       PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET
+FE3D          ; Common # Ps       PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET
+FE3E          ; Common # Pe       PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET
+FE3F          ; Common # Ps       PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET
+FE40          ; Common # Pe       PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET
+FE41          ; Common # Ps       PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET
+FE42          ; Common # Pe       PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET
+FE43          ; Common # Ps       PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET
+FE44          ; Common # Pe       PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET
+FE45..FE46    ; Common # Po   [2] SESAME DOT..WHITE SESAME DOT
+FE47          ; Common # Ps       PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET
+FE48          ; Common # Pe       PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET
+FE49..FE4C    ; Common # Po   [4] DASHED OVERLINE..DOUBLE WAVY OVERLINE
+FE4D..FE4F    ; Common # Pc   [3] DASHED LOW LINE..WAVY LOW LINE
+FE50..FE52    ; Common # Po   [3] SMALL COMMA..SMALL FULL STOP
+FE54..FE57    ; Common # Po   [4] SMALL SEMICOLON..SMALL EXCLAMATION MARK
+FE58          ; Common # Pd       SMALL EM DASH
+FE59          ; Common # Ps       SMALL LEFT PARENTHESIS
+FE5A          ; Common # Pe       SMALL RIGHT PARENTHESIS
+FE5B          ; Common # Ps       SMALL LEFT CURLY BRACKET
+FE5C          ; Common # Pe       SMALL RIGHT CURLY BRACKET
+FE5D          ; Common # Ps       SMALL LEFT TORTOISE SHELL BRACKET
+FE5E          ; Common # Pe       SMALL RIGHT TORTOISE SHELL BRACKET
+FE5F..FE61    ; Common # Po   [3] SMALL NUMBER SIGN..SMALL ASTERISK
+FE62          ; Common # Sm       SMALL PLUS SIGN
+FE63          ; Common # Pd       SMALL HYPHEN-MINUS
+FE64..FE66    ; Common # Sm   [3] SMALL LESS-THAN SIGN..SMALL EQUALS SIGN
+FE68          ; Common # Po       SMALL REVERSE SOLIDUS
+FE69          ; Common # Sc       SMALL DOLLAR SIGN
+FE6A..FE6B    ; Common # Po   [2] SMALL PERCENT SIGN..SMALL COMMERCIAL AT
+FEFF          ; Common # Cf       ZERO WIDTH NO-BREAK SPACE
+FF01..FF03    ; Common # Po   [3] FULLWIDTH EXCLAMATION MARK..FULLWIDTH NUMBER SIGN
+FF04          ; Common # Sc       FULLWIDTH DOLLAR SIGN
+FF05..FF07    ; Common # Po   [3] FULLWIDTH PERCENT SIGN..FULLWIDTH APOSTROPHE
+FF08          ; Common # Ps       FULLWIDTH LEFT PARENTHESIS
+FF09          ; Common # Pe       FULLWIDTH RIGHT PARENTHESIS
+FF0A          ; Common # Po       FULLWIDTH ASTERISK
+FF0B          ; Common # Sm       FULLWIDTH PLUS SIGN
+FF0C          ; Common # Po       FULLWIDTH COMMA
+FF0D          ; Common # Pd       FULLWIDTH HYPHEN-MINUS
+FF0E..FF0F    ; Common # Po   [2] FULLWIDTH FULL STOP..FULLWIDTH SOLIDUS
+FF10..FF19    ; Common # Nd  [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE
+FF1A..FF1B    ; Common # Po   [2] FULLWIDTH COLON..FULLWIDTH SEMICOLON
+FF1C..FF1E    ; Common # Sm   [3] FULLWIDTH LESS-THAN SIGN..FULLWIDTH GREATER-THAN SIGN
+FF1F..FF20    ; Common # Po   [2] FULLWIDTH QUESTION MARK..FULLWIDTH COMMERCIAL AT
+FF3B          ; Common # Ps       FULLWIDTH LEFT SQUARE BRACKET
+FF3C          ; Common # Po       FULLWIDTH REVERSE SOLIDUS
+FF3D          ; Common # Pe       FULLWIDTH RIGHT SQUARE BRACKET
+FF3E          ; Common # Sk       FULLWIDTH CIRCUMFLEX ACCENT
+FF3F          ; Common # Pc       FULLWIDTH LOW LINE
+FF40          ; Common # Sk       FULLWIDTH GRAVE ACCENT
+FF5B          ; Common # Ps       FULLWIDTH LEFT CURLY BRACKET
+FF5C          ; Common # Sm       FULLWIDTH VERTICAL LINE
+FF5D          ; Common # Pe       FULLWIDTH RIGHT CURLY BRACKET
+FF5E          ; Common # Sm       FULLWIDTH TILDE
+FF5F          ; Common # Ps       FULLWIDTH LEFT WHITE PARENTHESIS
+FF60          ; Common # Pe       FULLWIDTH RIGHT WHITE PARENTHESIS
+FF61          ; Common # Po       HALFWIDTH IDEOGRAPHIC FULL STOP
+FF62          ; Common # Ps       HALFWIDTH LEFT CORNER BRACKET
+FF63          ; Common # Pe       HALFWIDTH RIGHT CORNER BRACKET
+FF64..FF65    ; Common # Po   [2] HALFWIDTH IDEOGRAPHIC COMMA..HALFWIDTH KATAKANA MIDDLE DOT
+FF70          ; Common # Lm       HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK
+FF9E..FF9F    ; Common # Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
+FFE0..FFE1    ; Common # Sc   [2] FULLWIDTH CENT SIGN..FULLWIDTH POUND SIGN
+FFE2          ; Common # Sm       FULLWIDTH NOT SIGN
+FFE3          ; Common # Sk       FULLWIDTH MACRON
+FFE4          ; Common # So       FULLWIDTH BROKEN BAR
+FFE5..FFE6    ; Common # Sc   [2] FULLWIDTH YEN SIGN..FULLWIDTH WON SIGN
+FFE8          ; Common # So       HALFWIDTH FORMS LIGHT VERTICAL
+FFE9..FFEC    ; Common # Sm   [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS ARROW
+FFED..FFEE    ; Common # So   [2] HALFWIDTH BLACK SQUARE..HALFWIDTH WHITE CIRCLE
+FFF9..FFFB    ; Common # Cf   [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR
+FFFC..FFFD    ; Common # So   [2] OBJECT REPLACEMENT CHARACTER..REPLACEMENT CHARACTER
+10100..10102  ; Common # Po   [3] AEGEAN WORD SEPARATOR LINE..AEGEAN CHECK MARK
+10107..10133  ; Common # No  [45] AEGEAN NUMBER ONE..AEGEAN NUMBER NINETY THOUSAND
+10137..1013F  ; Common # So   [9] AEGEAN WEIGHT BASE UNIT..AEGEAN MEASURE THIRD SUBUNIT
+10190..1019C  ; Common # So  [13] ROMAN SEXTANS SIGN..ASCIA SYMBOL
+101D0..101FC  ; Common # So  [45] PHAISTOS DISC SIGN PEDESTRIAN..PHAISTOS DISC SIGN WAVY BAND
+102E1..102FB  ; Common # No  [27] COPTIC EPACT DIGIT ONE..COPTIC EPACT NUMBER NINE HUNDRED
+1BCA0..1BCA3  ; Common # Cf   [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP
+1CC00..1CCEF  ; Common # So [240] UP-POINTING GO-KART..OUTLINED LATIN CAPITAL LETTER Z
+1CCF0..1CCF9  ; Common # Nd  [10] OUTLINED DIGIT ZERO..OUTLINED DIGIT NINE
+1CCFA..1CCFC  ; Common # So   [3] SNAKE SYMBOL..NOSE SYMBOL
+1CD00..1CEB3  ; Common # So [436] BLOCK OCTANT-3..BLACK RIGHT TRIANGLE CARET
+1CEBA..1CED0  ; Common # So  [23] FRAGILE SYMBOL..LEUKOTHEA
+1CEE0..1CEEF  ; Common # So  [16] GEOMANTIC FIGURE POPULUS..GEOMANTIC FIGURE VIA
+1CEF0         ; Common # Sm       MEDIUM SMALL WHITE CIRCLE WITH HORIZONTAL BAR
+1CF50..1CFC3  ; Common # So [116] ZNAMENNY NEUME KRYUK..ZNAMENNY NEUME PAUK
+1D000..1D0F5  ; Common # So [246] BYZANTINE MUSICAL SYMBOL PSILI..BYZANTINE MUSICAL SYMBOL GORGON NEO KATO
+1D100..1D126  ; Common # So  [39] MUSICAL SYMBOL SINGLE BARLINE..MUSICAL SYMBOL DRUM CLEF-2
+1D129..1D164  ; Common # So  [60] MUSICAL SYMBOL MULTIPLE MEASURE REST..MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE
+1D165..1D166  ; Common # Mc   [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM
+1D16A..1D16C  ; Common # So   [3] MUSICAL SYMBOL FINGERED TREMOLO-1..MUSICAL SYMBOL FINGERED TREMOLO-3
+1D16D..1D172  ; Common # Mc   [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5
+1D173..1D17A  ; Common # Cf   [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE
+1D183..1D184  ; Common # So   [2] MUSICAL SYMBOL ARPEGGIATO UP..MUSICAL SYMBOL ARPEGGIATO DOWN
+1D18C..1D1A9  ; Common # So  [30] MUSICAL SYMBOL RINFORZANDO..MUSICAL SYMBOL DEGREE SLASH
+1D1AE..1D1EA  ; Common # So  [61] MUSICAL SYMBOL PEDAL MARK..MUSICAL SYMBOL KORON
+1D2C0..1D2D3  ; Common # No  [20] KAKTOVIK NUMERAL ZERO..KAKTOVIK NUMERAL NINETEEN
+1D2E0..1D2F3  ; Common # No  [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN
+1D300..1D356  ; Common # So  [87] MONOGRAM FOR EARTH..TETRAGRAM FOR FOSTERING
+1D360..1D378  ; Common # No  [25] COUNTING ROD UNIT DIGIT ONE..TALLY MARK FIVE
+1D400..1D454  ; Common # L&  [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G
+1D456..1D49C  ; Common # L&  [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A
+1D49E..1D49F  ; Common # L&   [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D
+1D4A2         ; Common # L&       MATHEMATICAL SCRIPT CAPITAL G
+1D4A5..1D4A6  ; Common # L&   [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K
+1D4A9..1D4AC  ; Common # L&   [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q
+1D4AE..1D4B9  ; Common # L&  [12] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT SMALL D
+1D4BB         ; Common # L&       MATHEMATICAL SCRIPT SMALL F
+1D4BD..1D4C3  ; Common # L&   [7] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL N
+1D4C5..1D505  ; Common # L&  [65] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL FRAKTUR CAPITAL B
+1D507..1D50A  ; Common # L&   [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G
+1D50D..1D514  ; Common # L&   [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q
+1D516..1D51C  ; Common # L&   [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y
+1D51E..1D539  ; Common # L&  [28] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B
+1D53B..1D53E  ; Common # L&   [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G
+1D540..1D544  ; Common # L&   [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M
+1D546         ; Common # L&       MATHEMATICAL DOUBLE-STRUCK CAPITAL O
+1D54A..1D550  ; Common # L&   [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y
+1D552..1D6A5  ; Common # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J
+1D6A8..1D6C0  ; Common # L&  [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA
+1D6C1         ; Common # Sm       MATHEMATICAL BOLD NABLA
+1D6C2..1D6DA  ; Common # L&  [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA
+1D6DB         ; Common # Sm       MATHEMATICAL BOLD PARTIAL DIFFERENTIAL
+1D6DC..1D6FA  ; Common # L&  [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA
+1D6FB         ; Common # Sm       MATHEMATICAL ITALIC NABLA
+1D6FC..1D714  ; Common # L&  [25] MATHEMATICAL ITALIC SMALL ALPHA..MATHEMATICAL ITALIC SMALL OMEGA
+1D715         ; Common # Sm       MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL
+1D716..1D734  ; Common # L&  [31] MATHEMATICAL ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD ITALIC CAPITAL OMEGA
+1D735         ; Common # Sm       MATHEMATICAL BOLD ITALIC NABLA
+1D736..1D74E  ; Common # L&  [25] MATHEMATICAL BOLD ITALIC SMALL ALPHA..MATHEMATICAL BOLD ITALIC SMALL OMEGA
+1D74F         ; Common # Sm       MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL
+1D750..1D76E  ; Common # L&  [31] MATHEMATICAL BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA
+1D76F         ; Common # Sm       MATHEMATICAL SANS-SERIF BOLD NABLA
+1D770..1D788  ; Common # L&  [25] MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA
+1D789         ; Common # Sm       MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL
+1D78A..1D7A8  ; Common # L&  [31] MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA
+1D7A9         ; Common # Sm       MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA
+1D7AA..1D7C2  ; Common # L&  [25] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA
+1D7C3         ; Common # Sm       MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL
+1D7C4..1D7CB  ; Common # L&   [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA
+1D7CE..1D7FF  ; Common # Nd  [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE
+1EC71..1ECAB  ; Common # No  [59] INDIC SIYAQ NUMBER ONE..INDIC SIYAQ NUMBER PREFIXED NINE
+1ECAC         ; Common # So       INDIC SIYAQ PLACEHOLDER
+1ECAD..1ECAF  ; Common # No   [3] INDIC SIYAQ FRACTION ONE QUARTER..INDIC SIYAQ FRACTION THREE QUARTERS
+1ECB0         ; Common # Sc       INDIC SIYAQ RUPEE MARK
+1ECB1..1ECB4  ; Common # No   [4] INDIC SIYAQ NUMBER ALTERNATE ONE..INDIC SIYAQ ALTERNATE LAKH MARK
+1ED01..1ED2D  ; Common # No  [45] OTTOMAN SIYAQ NUMBER ONE..OTTOMAN SIYAQ NUMBER NINETY THOUSAND
+1ED2E         ; Common # So       OTTOMAN SIYAQ MARRATAN
+1ED2F..1ED3D  ; Common # No  [15] OTTOMAN SIYAQ ALTERNATE NUMBER TWO..OTTOMAN SIYAQ FRACTION ONE SIXTH
+1F000..1F02B  ; Common # So  [44] MAHJONG TILE EAST WIND..MAHJONG TILE BACK
+1F030..1F093  ; Common # So [100] DOMINO TILE HORIZONTAL BACK..DOMINO TILE VERTICAL-06-06
+1F0A0..1F0AE  ; Common # So  [15] PLAYING CARD BACK..PLAYING CARD KING OF SPADES
+1F0B1..1F0BF  ; Common # So  [15] PLAYING CARD ACE OF HEARTS..PLAYING CARD RED JOKER
+1F0C1..1F0CF  ; Common # So  [15] PLAYING CARD ACE OF DIAMONDS..PLAYING CARD BLACK JOKER
+1F0D1..1F0F5  ; Common # So  [37] PLAYING CARD ACE OF CLUBS..PLAYING CARD TRUMP-21
+1F100..1F10C  ; Common # No  [13] DIGIT ZERO FULL STOP..DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ZERO
+1F10D..1F1AD  ; Common # So [161] CIRCLED ZERO WITH SLASH..MASK WORK SYMBOL
+1F1E6..1F1FF  ; Common # So  [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z
+1F201..1F202  ; Common # So   [2] SQUARED KATAKANA KOKO..SQUARED KATAKANA SA
+1F210..1F23B  ; Common # So  [44] SQUARED CJK UNIFIED IDEOGRAPH-624B..SQUARED CJK UNIFIED IDEOGRAPH-914D
+1F240..1F248  ; Common # So   [9] TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-672C..TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-6557
+1F250..1F251  ; Common # So   [2] CIRCLED IDEOGRAPH ADVANTAGE..CIRCLED IDEOGRAPH ACCEPT
+1F260..1F265  ; Common # So   [6] ROUNDED SYMBOL FOR FU..ROUNDED SYMBOL FOR CAI
+1F300..1F3FA  ; Common # So [251] CYCLONE..AMPHORA
+1F3FB..1F3FF  ; Common # Sk   [5] EMOJI MODIFIER FITZPATRICK TYPE-1-2..EMOJI MODIFIER FITZPATRICK TYPE-6
+1F400..1F6D8  ; Common # So [729] RAT..LANDSLIDE
+1F6DC..1F6EC  ; Common # So  [17] WIRELESS..AIRPLANE ARRIVING
+1F6F0..1F6FC  ; Common # So  [13] SATELLITE..ROLLER SKATE
+1F700..1F7D9  ; Common # So [218] ALCHEMICAL SYMBOL FOR QUINTESSENCE..NINE POINTED WHITE STAR
+1F7E0..1F7EB  ; Common # So  [12] LARGE ORANGE CIRCLE..LARGE BROWN SQUARE
+1F7F0         ; Common # So       HEAVY EQUALS SIGN
+1F800..1F80B  ; Common # So  [12] LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD..DOWNWARDS ARROW WITH LARGE TRIANGLE ARROWHEAD
+1F810..1F847  ; Common # So  [56] LEFTWARDS ARROW WITH SMALL EQUILATERAL ARROWHEAD..DOWNWARDS HEAVY ARROW
+1F850..1F859  ; Common # So  [10] LEFTWARDS SANS-SERIF ARROW..UP DOWN SANS-SERIF ARROW
+1F860..1F887  ; Common # So  [40] WIDE-HEADED LEFTWARDS LIGHT BARB ARROW..WIDE-HEADED SOUTH WEST VERY HEAVY BARB ARROW
+1F890..1F8AD  ; Common # So  [30] LEFTWARDS TRIANGLE ARROWHEAD..WHITE ARROW SHAFT WIDTH TWO THIRDS
+1F8B0..1F8BB  ; Common # So  [12] ARROW POINTING UPWARDS THEN NORTH WEST..SOUTH WEST ARROW FROM BAR
+1F8C0..1F8C1  ; Common # So   [2] LEFTWARDS ARROW FROM DOWNWARDS ARROW..RIGHTWARDS ARROW FROM DOWNWARDS ARROW
+1F8D0..1F8D8  ; Common # Sm   [9] LONG RIGHTWARDS ARROW OVER LONG LEFTWARDS ARROW..LONG LEFT RIGHT ARROW WITH DEPENDENT LOBE
+1F900..1FA57  ; Common # So [344] CIRCLED CROSS FORMEE WITH FOUR DOTS..BLACK CHESS ALFIL
+1FA60..1FA6D  ; Common # So  [14] XIANGQI RED GENERAL..XIANGQI BLACK SOLDIER
+1FA70..1FA7C  ; Common # So  [13] BALLET SHOES..CRUTCH
+1FA80..1FA8A  ; Common # So  [11] YO-YO..TROMBONE
+1FA8E..1FAC6  ; Common # So  [57] TREASURE CHEST..FINGERPRINT
+1FAC8         ; Common # So       HAIRY CREATURE
+1FACD..1FADC  ; Common # So  [16] ORCA..ROOT VEGETABLE
+1FADF..1FAEA  ; Common # So  [12] SPLATTER..DISTORTED FACE
+1FAEF..1FAF8  ; Common # So  [10] FIGHT CLOUD..RIGHTWARDS PUSHING HAND
+1FB00..1FB92  ; Common # So [147] BLOCK SEXTANT-1..UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK
+1FB94..1FBEF  ; Common # So  [92] LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK..TOP LEFT JUSTIFIED LOWER RIGHT QUARTER BLACK CIRCLE
+1FBF0..1FBF9  ; Common # Nd  [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE
+1FBFA         ; Common # So       ALARM BELL SYMBOL
+E0001         ; Common # Cf       LANGUAGE TAG
+E0020..E007F  ; Common # Cf  [96] TAG SPACE..CANCEL TAG
+
+# Total code points: 9123
+
+# ================================================
+
+0041..005A    ; Latin # L&  [26] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z
+0061..007A    ; Latin # L&  [26] LATIN SMALL LETTER A..LATIN SMALL LETTER Z
+00AA          ; Latin # Lo       FEMININE ORDINAL INDICATOR
+00BA          ; Latin # Lo       MASCULINE ORDINAL INDICATOR
+00C0..00D6    ; Latin # L&  [23] LATIN CAPITAL LETTER A WITH GRAVE..LATIN CAPITAL LETTER O WITH DIAERESIS
+00D8..00F6    ; Latin # L&  [31] LATIN CAPITAL LETTER O WITH STROKE..LATIN SMALL LETTER O WITH DIAERESIS
+00F8..01BA    ; Latin # L& [195] LATIN SMALL LETTER O WITH STROKE..LATIN SMALL LETTER EZH WITH TAIL
+01BB          ; Latin # Lo       LATIN LETTER TWO WITH STROKE
+01BC..01BF    ; Latin # L&   [4] LATIN CAPITAL LETTER TONE FIVE..LATIN LETTER WYNN
+01C0..01C3    ; Latin # Lo   [4] LATIN LETTER DENTAL CLICK..LATIN LETTER RETROFLEX CLICK
+01C4..0293    ; Latin # L& [208] LATIN CAPITAL LETTER DZ WITH CARON..LATIN SMALL LETTER EZH WITH CURL
+0294..0295    ; Latin # Lo   [2] LATIN LETTER GLOTTAL STOP..LATIN LETTER PHARYNGEAL VOICED FRICATIVE
+0296..02AF    ; Latin # L&  [26] LATIN LETTER INVERTED GLOTTAL STOP..LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL
+02B0..02B8    ; Latin # Lm   [9] MODIFIER LETTER SMALL H..MODIFIER LETTER SMALL Y
+02E0..02E4    ; Latin # Lm   [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP
+1D00..1D25    ; Latin # L&  [38] LATIN LETTER SMALL CAPITAL A..LATIN LETTER AIN
+1D2C..1D5C    ; Latin # Lm  [49] MODIFIER LETTER CAPITAL A..MODIFIER LETTER SMALL AIN
+1D62..1D65    ; Latin # Lm   [4] LATIN SUBSCRIPT SMALL LETTER I..LATIN SUBSCRIPT SMALL LETTER V
+1D6B..1D77    ; Latin # L&  [13] LATIN SMALL LETTER UE..LATIN SMALL LETTER TURNED G
+1D79..1D9A    ; Latin # L&  [34] LATIN SMALL LETTER INSULAR G..LATIN SMALL LETTER EZH WITH RETROFLEX HOOK
+1D9B..1DBE    ; Latin # Lm  [36] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL EZH
+1E00..1EFF    ; Latin # L& [256] LATIN CAPITAL LETTER A WITH RING BELOW..LATIN SMALL LETTER Y WITH LOOP
+2071          ; Latin # Lm       SUPERSCRIPT LATIN SMALL LETTER I
+207F          ; Latin # Lm       SUPERSCRIPT LATIN SMALL LETTER N
+2090..209C    ; Latin # Lm  [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T
+212A..212B    ; Latin # L&   [2] KELVIN SIGN..ANGSTROM SIGN
+2132          ; Latin # L&       TURNED CAPITAL F
+214E          ; Latin # L&       TURNED SMALL F
+2160..2182    ; Latin # Nl  [35] ROMAN NUMERAL ONE..ROMAN NUMERAL TEN THOUSAND
+2183..2184    ; Latin # L&   [2] ROMAN NUMERAL REVERSED ONE HUNDRED..LATIN SMALL LETTER REVERSED C
+2185..2188    ; Latin # Nl   [4] ROMAN NUMERAL SIX LATE FORM..ROMAN NUMERAL ONE HUNDRED THOUSAND
+2C60..2C7B    ; Latin # L&  [28] LATIN CAPITAL LETTER L WITH DOUBLE BAR..LATIN LETTER SMALL CAPITAL TURNED E
+2C7C..2C7D    ; Latin # Lm   [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V
+2C7E..2C7F    ; Latin # L&   [2] LATIN CAPITAL LETTER S WITH SWASH TAIL..LATIN CAPITAL LETTER Z WITH SWASH TAIL
+A722..A76F    ; Latin # L&  [78] LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF..LATIN SMALL LETTER CON
+A770          ; Latin # Lm       MODIFIER LETTER US
+A771..A787    ; Latin # L&  [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER INSULAR T
+A78B..A78E    ; Latin # L&   [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT
+A78F          ; Latin # Lo       LATIN LETTER SINOLOGICAL DOT
+A790..A7DC    ; Latin # L&  [77] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER LAMBDA WITH STROKE
+A7F1..A7F4    ; Latin # Lm   [4] MODIFIER LETTER CAPITAL S..MODIFIER LETTER CAPITAL Q
+A7F5..A7F6    ; Latin # L&   [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H
+A7F7          ; Latin # Lo       LATIN EPIGRAPHIC LETTER SIDEWAYS I
+A7F8..A7F9    ; Latin # Lm   [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE
+A7FA          ; Latin # L&       LATIN LETTER SMALL CAPITAL TURNED M
+A7FB..A7FF    ; Latin # Lo   [5] LATIN EPIGRAPHIC LETTER REVERSED F..LATIN EPIGRAPHIC LETTER ARCHAIC M
+AB30..AB5A    ; Latin # L&  [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LETTER Y WITH SHORT RIGHT LEG
+AB5C..AB5F    ; Latin # Lm   [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK
+AB60..AB64    ; Latin # L&   [5] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER INVERTED ALPHA
+AB66..AB68    ; Latin # L&   [3] LATIN SMALL LETTER DZ DIGRAPH WITH RETROFLEX HOOK..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE
+AB69          ; Latin # Lm       MODIFIER LETTER SMALL TURNED W
+FB00..FB06    ; Latin # L&   [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST
+FF21..FF3A    ; Latin # L&  [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER Z
+FF41..FF5A    ; Latin # L&  [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN SMALL LETTER Z
+10780..10785  ; Latin # Lm   [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK
+10787..107B0  ; Latin # Lm  [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK
+107B2..107BA  ; Latin # Lm   [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL
+1DF00..1DF09  ; Latin # L&  [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK
+1DF0A         ; Latin # Lo       LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK
+1DF0B..1DF1E  ; Latin # L&  [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL
+1DF25..1DF2A  ; Latin # L&   [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK
+
+# Total code points: 1492
+
+# ================================================
+
+0370..0373    ; Greek # L&   [4] GREEK CAPITAL LETTER HETA..GREEK SMALL LETTER ARCHAIC SAMPI
+0375          ; Greek # Sk       GREEK LOWER NUMERAL SIGN
+0376..0377    ; Greek # L&   [2] GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA..GREEK SMALL LETTER PAMPHYLIAN DIGAMMA
+037A          ; Greek # Lm       GREEK YPOGEGRAMMENI
+037B..037D    ; Greek # L&   [3] GREEK SMALL REVERSED LUNATE SIGMA SYMBOL..GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL
+037F          ; Greek # L&       GREEK CAPITAL LETTER YOT
+0384          ; Greek # Sk       GREEK TONOS
+0386          ; Greek # L&       GREEK CAPITAL LETTER ALPHA WITH TONOS
+0388..038A    ; Greek # L&   [3] GREEK CAPITAL LETTER EPSILON WITH TONOS..GREEK CAPITAL LETTER IOTA WITH TONOS
+038C          ; Greek # L&       GREEK CAPITAL LETTER OMICRON WITH TONOS
+038E..03A1    ; Greek # L&  [20] GREEK CAPITAL LETTER UPSILON WITH TONOS..GREEK CAPITAL LETTER RHO
+03A3..03E1    ; Greek # L&  [63] GREEK CAPITAL LETTER SIGMA..GREEK SMALL LETTER SAMPI
+03F0..03F5    ; Greek # L&   [6] GREEK KAPPA SYMBOL..GREEK LUNATE EPSILON SYMBOL
+03F6          ; Greek # Sm       GREEK REVERSED LUNATE EPSILON SYMBOL
+03F7..03FF    ; Greek # L&   [9] GREEK CAPITAL LETTER SHO..GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL
+1D26..1D2A    ; Greek # L&   [5] GREEK LETTER SMALL CAPITAL GAMMA..GREEK LETTER SMALL CAPITAL PSI
+1D5D..1D61    ; Greek # Lm   [5] MODIFIER LETTER SMALL BETA..MODIFIER LETTER SMALL CHI
+1D66..1D6A    ; Greek # Lm   [5] GREEK SUBSCRIPT SMALL LETTER BETA..GREEK SUBSCRIPT SMALL LETTER CHI
+1DBF          ; Greek # Lm       MODIFIER LETTER SMALL THETA
+1F00..1F15    ; Greek # L&  [22] GREEK SMALL LETTER ALPHA WITH PSILI..GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA
+1F18..1F1D    ; Greek # L&   [6] GREEK CAPITAL LETTER EPSILON WITH PSILI..GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA
+1F20..1F45    ; Greek # L&  [38] GREEK SMALL LETTER ETA WITH PSILI..GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA
+1F48..1F4D    ; Greek # L&   [6] GREEK CAPITAL LETTER OMICRON WITH PSILI..GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA
+1F50..1F57    ; Greek # L&   [8] GREEK SMALL LETTER UPSILON WITH PSILI..GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI
+1F59          ; Greek # L&       GREEK CAPITAL LETTER UPSILON WITH DASIA
+1F5B          ; Greek # L&       GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA
+1F5D          ; Greek # L&       GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA
+1F5F..1F7D    ; Greek # L&  [31] GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI..GREEK SMALL LETTER OMEGA WITH OXIA
+1F80..1FB4    ; Greek # L&  [53] GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI..GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI
+1FB6..1FBC    ; Greek # L&   [7] GREEK SMALL LETTER ALPHA WITH PERISPOMENI..GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI
+1FBD          ; Greek # Sk       GREEK KORONIS
+1FBE          ; Greek # L&       GREEK PROSGEGRAMMENI
+1FBF..1FC1    ; Greek # Sk   [3] GREEK PSILI..GREEK DIALYTIKA AND PERISPOMENI
+1FC2..1FC4    ; Greek # L&   [3] GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI
+1FC6..1FCC    ; Greek # L&   [7] GREEK SMALL LETTER ETA WITH PERISPOMENI..GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
+1FCD..1FCF    ; Greek # Sk   [3] GREEK PSILI AND VARIA..GREEK PSILI AND PERISPOMENI
+1FD0..1FD3    ; Greek # L&   [4] GREEK SMALL LETTER IOTA WITH VRACHY..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
+1FD6..1FDB    ; Greek # L&   [6] GREEK SMALL LETTER IOTA WITH PERISPOMENI..GREEK CAPITAL LETTER IOTA WITH OXIA
+1FDD..1FDF    ; Greek # Sk   [3] GREEK DASIA AND VARIA..GREEK DASIA AND PERISPOMENI
+1FE0..1FEC    ; Greek # L&  [13] GREEK SMALL LETTER UPSILON WITH VRACHY..GREEK CAPITAL LETTER RHO WITH DASIA
+1FED..1FEF    ; Greek # Sk   [3] GREEK DIALYTIKA AND VARIA..GREEK VARIA
+1FF2..1FF4    ; Greek # L&   [3] GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI
+1FF6..1FFC    ; Greek # L&   [7] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
+1FFD..1FFE    ; Greek # Sk   [2] GREEK OXIA..GREEK DASIA
+2126          ; Greek # L&       OHM SIGN
+AB65          ; Greek # L&       GREEK LETTER SMALL CAPITAL OMEGA
+10140..10174  ; Greek # Nl  [53] GREEK ACROPHONIC ATTIC ONE QUARTER..GREEK ACROPHONIC STRATIAN FIFTY MNAS
+10175..10178  ; Greek # No   [4] GREEK ONE HALF SIGN..GREEK THREE QUARTERS SIGN
+10179..10189  ; Greek # So  [17] GREEK YEAR SIGN..GREEK TRYBLION BASE SIGN
+1018A..1018B  ; Greek # No   [2] GREEK ZERO SIGN..GREEK ONE QUARTER SIGN
+1018C..1018E  ; Greek # So   [3] GREEK SINUSOID SIGN..NOMISMA SIGN
+101A0         ; Greek # So       GREEK SYMBOL TAU RHO
+1D200..1D241  ; Greek # So  [66] GREEK VOCAL NOTATION SYMBOL-1..GREEK INSTRUMENTAL NOTATION SYMBOL-54
+1D242..1D244  ; Greek # Mn   [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME
+1D245         ; Greek # So       GREEK MUSICAL LEIMMA
+
+# Total code points: 518
+
+# ================================================
+
+0400..0481    ; Cyrillic # L& [130] CYRILLIC CAPITAL LETTER IE WITH GRAVE..CYRILLIC SMALL LETTER KOPPA
+0482          ; Cyrillic # So       CYRILLIC THOUSANDS SIGN
+0483..0484    ; Cyrillic # Mn   [2] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC PALATALIZATION
+0487          ; Cyrillic # Mn       COMBINING CYRILLIC POKRYTIE
+0488..0489    ; Cyrillic # Me   [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN
+048A..052F    ; Cyrillic # L& [166] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER EL WITH DESCENDER
+1C80..1C8A    ; Cyrillic # L&  [11] CYRILLIC SMALL LETTER ROUNDED VE..CYRILLIC SMALL LETTER TJE
+1D2B          ; Cyrillic # L&       CYRILLIC LETTER SMALL CAPITAL EL
+1D78          ; Cyrillic # Lm       MODIFIER LETTER CYRILLIC EN
+2DE0..2DFF    ; Cyrillic # Mn  [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS
+A640..A66D    ; Cyrillic # L&  [46] CYRILLIC CAPITAL LETTER ZEMLYA..CYRILLIC SMALL LETTER DOUBLE MONOCULAR O
+A66E          ; Cyrillic # Lo       CYRILLIC LETTER MULTIOCULAR O
+A66F          ; Cyrillic # Mn       COMBINING CYRILLIC VZMET
+A670..A672    ; Cyrillic # Me   [3] COMBINING CYRILLIC TEN MILLIONS SIGN..COMBINING CYRILLIC THOUSAND MILLIONS SIGN
+A673          ; Cyrillic # Po       SLAVONIC ASTERISK
+A674..A67D    ; Cyrillic # Mn  [10] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC PAYEROK
+A67E          ; Cyrillic # Po       CYRILLIC KAVYKA
+A67F          ; Cyrillic # Lm       CYRILLIC PAYEROK
+A680..A69B    ; Cyrillic # L&  [28] CYRILLIC CAPITAL LETTER DWE..CYRILLIC SMALL LETTER CROSSED O
+A69C..A69D    ; Cyrillic # Lm   [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN
+A69E..A69F    ; Cyrillic # Mn   [2] COMBINING CYRILLIC LETTER EF..COMBINING CYRILLIC LETTER IOTIFIED E
+FE2E..FE2F    ; Cyrillic # Mn   [2] COMBINING CYRILLIC TITLO LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF
+1E030..1E06D  ; Cyrillic # Lm  [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE
+1E08F         ; Cyrillic # Mn       COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
+
+# Total code points: 508
+
+# ================================================
+
+0531..0556    ; Armenian # L&  [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH
+0559          ; Armenian # Lm       ARMENIAN MODIFIER LETTER LEFT HALF RING
+055A..055F    ; Armenian # Po   [6] ARMENIAN APOSTROPHE..ARMENIAN ABBREVIATION MARK
+0560..0588    ; Armenian # L&  [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE
+0589          ; Armenian # Po       ARMENIAN FULL STOP
+058A          ; Armenian # Pd       ARMENIAN HYPHEN
+058D..058E    ; Armenian # So   [2] RIGHT-FACING ARMENIAN ETERNITY SIGN..LEFT-FACING ARMENIAN ETERNITY SIGN
+058F          ; Armenian # Sc       ARMENIAN DRAM SIGN
+FB13..FB17    ; Armenian # L&   [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH
+
+# Total code points: 96
+
+# ================================================
+
+0591..05BD    ; Hebrew # Mn  [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG
+05BE          ; Hebrew # Pd       HEBREW PUNCTUATION MAQAF
+05BF          ; Hebrew # Mn       HEBREW POINT RAFE
+05C0          ; Hebrew # Po       HEBREW PUNCTUATION PASEQ
+05C1..05C2    ; Hebrew # Mn   [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT
+05C3          ; Hebrew # Po       HEBREW PUNCTUATION SOF PASUQ
+05C4..05C5    ; Hebrew # Mn   [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT
+05C6          ; Hebrew # Po       HEBREW PUNCTUATION NUN HAFUKHA
+05C7          ; Hebrew # Mn       HEBREW POINT QAMATS QATAN
+05D0..05EA    ; Hebrew # Lo  [27] HEBREW LETTER ALEF..HEBREW LETTER TAV
+05EF..05F2    ; Hebrew # Lo   [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD
+05F3..05F4    ; Hebrew # Po   [2] HEBREW PUNCTUATION GERESH..HEBREW PUNCTUATION GERSHAYIM
+FB1D          ; Hebrew # Lo       HEBREW LETTER YOD WITH HIRIQ
+FB1E          ; Hebrew # Mn       HEBREW POINT JUDEO-SPANISH VARIKA
+FB1F..FB28    ; Hebrew # Lo  [10] HEBREW LIGATURE YIDDISH YOD YOD PATAH..HEBREW LETTER WIDE TAV
+FB29          ; Hebrew # Sm       HEBREW LETTER ALTERNATIVE PLUS SIGN
+FB2A..FB36    ; Hebrew # Lo  [13] HEBREW LETTER SHIN WITH SHIN DOT..HEBREW LETTER ZAYIN WITH DAGESH
+FB38..FB3C    ; Hebrew # Lo   [5] HEBREW LETTER TET WITH DAGESH..HEBREW LETTER LAMED WITH DAGESH
+FB3E          ; Hebrew # Lo       HEBREW LETTER MEM WITH DAGESH
+FB40..FB41    ; Hebrew # Lo   [2] HEBREW LETTER NUN WITH DAGESH..HEBREW LETTER SAMEKH WITH DAGESH
+FB43..FB44    ; Hebrew # Lo   [2] HEBREW LETTER FINAL PE WITH DAGESH..HEBREW LETTER PE WITH DAGESH
+FB46..FB4F    ; Hebrew # Lo  [10] HEBREW LETTER TSADI WITH DAGESH..HEBREW LIGATURE ALEF LAMED
+
+# Total code points: 134
+
+# ================================================
+
+0600..0604    ; Arabic # Cf   [5] ARABIC NUMBER SIGN..ARABIC SIGN SAMVAT
+0606..0608    ; Arabic # Sm   [3] ARABIC-INDIC CUBE ROOT..ARABIC RAY
+0609..060A    ; Arabic # Po   [2] ARABIC-INDIC PER MILLE SIGN..ARABIC-INDIC PER TEN THOUSAND SIGN
+060B          ; Arabic # Sc       AFGHANI SIGN
+060D          ; Arabic # Po       ARABIC DATE SEPARATOR
+060E..060F    ; Arabic # So   [2] ARABIC POETIC VERSE SIGN..ARABIC SIGN MISRA
+0610..061A    ; Arabic # Mn  [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA
+061C          ; Arabic # Cf       ARABIC LETTER MARK
+061D..061E    ; Arabic # Po   [2] ARABIC END OF TEXT MARK..ARABIC TRIPLE DOT PUNCTUATION MARK
+0620..063F    ; Arabic # Lo  [32] ARABIC LETTER KASHMIRI YEH..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE
+0641..064A    ; Arabic # Lo  [10] ARABIC LETTER FEH..ARABIC LETTER YEH
+0656..065F    ; Arabic # Mn  [10] ARABIC SUBSCRIPT ALEF..ARABIC WAVY HAMZA BELOW
+0660..0669    ; Arabic # Nd  [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE
+066A..066D    ; Arabic # Po   [4] ARABIC PERCENT SIGN..ARABIC FIVE POINTED STAR
+066E..066F    ; Arabic # Lo   [2] ARABIC LETTER DOTLESS BEH..ARABIC LETTER DOTLESS QAF
+0671..06D3    ; Arabic # Lo  [99] ARABIC LETTER ALEF WASLA..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE
+06D4          ; Arabic # Po       ARABIC FULL STOP
+06D5          ; Arabic # Lo       ARABIC LETTER AE
+06D6..06DC    ; Arabic # Mn   [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN
+06DE          ; Arabic # So       ARABIC START OF RUB EL HIZB
+06DF..06E4    ; Arabic # Mn   [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA
+06E5..06E6    ; Arabic # Lm   [2] ARABIC SMALL WAW..ARABIC SMALL YEH
+06E7..06E8    ; Arabic # Mn   [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON
+06E9          ; Arabic # So       ARABIC PLACE OF SAJDAH
+06EA..06ED    ; Arabic # Mn   [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM
+06EE..06EF    ; Arabic # Lo   [2] ARABIC LETTER DAL WITH INVERTED V..ARABIC LETTER REH WITH INVERTED V
+06F0..06F9    ; Arabic # Nd  [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE
+06FA..06FC    ; Arabic # Lo   [3] ARABIC LETTER SHEEN WITH DOT BELOW..ARABIC LETTER GHAIN WITH DOT BELOW
+06FD..06FE    ; Arabic # So   [2] ARABIC SIGN SINDHI AMPERSAND..ARABIC SIGN SINDHI POSTPOSITION MEN
+06FF          ; Arabic # Lo       ARABIC LETTER HEH WITH INVERTED V
+0750..077F    ; Arabic # Lo  [48] ARABIC LETTER BEH WITH THREE DOTS HORIZONTALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS ABOVE
+0870..0887    ; Arabic # Lo  [24] ARABIC LETTER ALEF WITH ATTACHED FATHA..ARABIC BASELINE ROUND DOT
+0888          ; Arabic # Sk       ARABIC RAISED ROUND DOT
+0889..088F    ; Arabic # Lo   [7] ARABIC LETTER NOON WITH INVERTED SMALL V..ARABIC LETTER NOON WITH RING ABOVE
+0890..0891    ; Arabic # Cf   [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE
+0897..089F    ; Arabic # Mn   [9] ARABIC PEPET..ARABIC HALF MADDA OVER MADDA
+08A0..08C8    ; Arabic # Lo  [41] ARABIC LETTER BEH WITH SMALL V BELOW..ARABIC LETTER GRAF
+08C9          ; Arabic # Lm       ARABIC SMALL FARSI YEH
+08CA..08E1    ; Arabic # Mn  [24] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL HIGH SIGN SAFHA
+08E3..08FF    ; Arabic # Mn  [29] ARABIC TURNED DAMMA BELOW..ARABIC MARK SIDEWAYS NOON GHUNNA
+FB50..FBB1    ; Arabic # Lo  [98] ARABIC LETTER ALEF WASLA ISOLATED FORM..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM
+FBB2..FBC2    ; Arabic # Sk  [17] ARABIC SYMBOL DOT ABOVE..ARABIC SYMBOL WASLA ABOVE
+FBC3..FBD2    ; Arabic # So  [16] ARABIC LIGATURE JALLA WA-ALAA..ARABIC LIGATURE ALAYHI AR-RAHMAH
+FBD3..FD3D    ; Arabic # Lo [363] ARABIC LETTER NG ISOLATED FORM..ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM
+FD40..FD4F    ; Arabic # So  [16] ARABIC LIGATURE RAHIMAHU ALLAAH..ARABIC LIGATURE RAHIMAHUM ALLAAH
+FD50..FD8F    ; Arabic # Lo  [64] ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM..ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM
+FD90..FD91    ; Arabic # So   [2] ARABIC LIGATURE RAHMATU ALLAAHI ALAYH..ARABIC LIGATURE RAHMATU ALLAAHI ALAYHAA
+FD92..FDC7    ; Arabic # Lo  [54] ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM..ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM
+FDC8..FDCF    ; Arabic # So   [8] ARABIC LIGATURE RAHIMAHU ALLAAH TAAALAA..ARABIC LIGATURE SALAAMUHU ALAYNAA
+FDF0..FDFB    ; Arabic # Lo  [12] ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM..ARABIC LIGATURE JALLAJALALOUHOU
+FDFC          ; Arabic # Sc       RIAL SIGN
+FDFD..FDFF    ; Arabic # So   [3] ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM..ARABIC LIGATURE AZZA WA JALL
+FE70..FE74    ; Arabic # Lo   [5] ARABIC FATHATAN ISOLATED FORM..ARABIC KASRATAN ISOLATED FORM
+FE76..FEFC    ; Arabic # Lo [135] ARABIC FATHA ISOLATED FORM..ARABIC LIGATURE LAM WITH ALEF FINAL FORM
+10E60..10E7E  ; Arabic # No  [31] RUMI DIGIT ONE..RUMI FRACTION TWO THIRDS
+10EC2..10EC4  ; Arabic # Lo   [3] ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS VERTICALLY BELOW
+10EC5         ; Arabic # Lm       ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW
+10EC6..10EC7  ; Arabic # Lo   [2] ARABIC LETTER THIN NOON..ARABIC LETTER YEH WITH FOUR DOTS BELOW
+10ED0         ; Arabic # Po       ARABIC BIBLICAL END OF VERSE
+10ED1..10ED8  ; Arabic # So   [8] ARABIC LIGATURE ALAYHAA AS-SALAATU WAS-SALAAM..ARABIC LIGATURE NAWWARA ALLAAHU MARQADAH
+10EFA..10EFF  ; Arabic # Mn   [6] ARABIC DOUBLE VERTICAL BAR BELOW..ARABIC SMALL LOW WORD MADDA
+1EE00..1EE03  ; Arabic # Lo   [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL
+1EE05..1EE1F  ; Arabic # Lo  [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF
+1EE21..1EE22  ; Arabic # Lo   [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM
+1EE24         ; Arabic # Lo       ARABIC MATHEMATICAL INITIAL HEH
+1EE27         ; Arabic # Lo       ARABIC MATHEMATICAL INITIAL HAH
+1EE29..1EE32  ; Arabic # Lo  [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF
+1EE34..1EE37  ; Arabic # Lo   [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH
+1EE39         ; Arabic # Lo       ARABIC MATHEMATICAL INITIAL DAD
+1EE3B         ; Arabic # Lo       ARABIC MATHEMATICAL INITIAL GHAIN
+1EE42         ; Arabic # Lo       ARABIC MATHEMATICAL TAILED JEEM
+1EE47         ; Arabic # Lo       ARABIC MATHEMATICAL TAILED HAH
+1EE49         ; Arabic # Lo       ARABIC MATHEMATICAL TAILED YEH
+1EE4B         ; Arabic # Lo       ARABIC MATHEMATICAL TAILED LAM
+1EE4D..1EE4F  ; Arabic # Lo   [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN
+1EE51..1EE52  ; Arabic # Lo   [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF
+1EE54         ; Arabic # Lo       ARABIC MATHEMATICAL TAILED SHEEN
+1EE57         ; Arabic # Lo       ARABIC MATHEMATICAL TAILED KHAH
+1EE59         ; Arabic # Lo       ARABIC MATHEMATICAL TAILED DAD
+1EE5B         ; Arabic # Lo       ARABIC MATHEMATICAL TAILED GHAIN
+1EE5D         ; Arabic # Lo       ARABIC MATHEMATICAL TAILED DOTLESS NOON
+1EE5F         ; Arabic # Lo       ARABIC MATHEMATICAL TAILED DOTLESS QAF
+1EE61..1EE62  ; Arabic # Lo   [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM
+1EE64         ; Arabic # Lo       ARABIC MATHEMATICAL STRETCHED HEH
+1EE67..1EE6A  ; Arabic # Lo   [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF
+1EE6C..1EE72  ; Arabic # Lo   [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF
+1EE74..1EE77  ; Arabic # Lo   [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH
+1EE79..1EE7C  ; Arabic # Lo   [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH
+1EE7E         ; Arabic # Lo       ARABIC MATHEMATICAL STRETCHED DOTLESS FEH
+1EE80..1EE89  ; Arabic # Lo  [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH
+1EE8B..1EE9B  ; Arabic # Lo  [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN
+1EEA1..1EEA3  ; Arabic # Lo   [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL
+1EEA5..1EEA9  ; Arabic # Lo   [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH
+1EEAB..1EEBB  ; Arabic # Lo  [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN
+1EEF0..1EEF1  ; Arabic # Sm   [2] ARABIC MATHEMATICAL OPERATOR MEEM WITH HAH WITH TATWEEL..ARABIC MATHEMATICAL OPERATOR HAH WITH DAL
+
+# Total code points: 1413
+
+# ================================================
+
+0700..070D    ; Syriac # Po  [14] SYRIAC END OF PARAGRAPH..SYRIAC HARKLEAN ASTERISCUS
+070F          ; Syriac # Cf       SYRIAC ABBREVIATION MARK
+0710          ; Syriac # Lo       SYRIAC LETTER ALAPH
+0711          ; Syriac # Mn       SYRIAC LETTER SUPERSCRIPT ALAPH
+0712..072F    ; Syriac # Lo  [30] SYRIAC LETTER BETH..SYRIAC LETTER PERSIAN DHALATH
+0730..074A    ; Syriac # Mn  [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH
+074D..074F    ; Syriac # Lo   [3] SYRIAC LETTER SOGDIAN ZHAIN..SYRIAC LETTER SOGDIAN FE
+0860..086A    ; Syriac # Lo  [11] SYRIAC LETTER MALAYALAM NGA..SYRIAC LETTER MALAYALAM SSA
+
+# Total code points: 88
+
+# ================================================
+
+0780..07A5    ; Thaana # Lo  [38] THAANA LETTER HAA..THAANA LETTER WAAVU
+07A6..07B0    ; Thaana # Mn  [11] THAANA ABAFILI..THAANA SUKUN
+07B1          ; Thaana # Lo       THAANA LETTER NAA
+
+# Total code points: 50
+
+# ================================================
+
+0900..0902    ; Devanagari # Mn   [3] DEVANAGARI SIGN INVERTED CANDRABINDU..DEVANAGARI SIGN ANUSVARA
+0903          ; Devanagari # Mc       DEVANAGARI SIGN VISARGA
+0904..0939    ; Devanagari # Lo  [54] DEVANAGARI LETTER SHORT A..DEVANAGARI LETTER HA
+093A          ; Devanagari # Mn       DEVANAGARI VOWEL SIGN OE
+093B          ; Devanagari # Mc       DEVANAGARI VOWEL SIGN OOE
+093C          ; Devanagari # Mn       DEVANAGARI SIGN NUKTA
+093D          ; Devanagari # Lo       DEVANAGARI SIGN AVAGRAHA
+093E..0940    ; Devanagari # Mc   [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II
+0941..0948    ; Devanagari # Mn   [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI
+0949..094C    ; Devanagari # Mc   [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU
+094D          ; Devanagari # Mn       DEVANAGARI SIGN VIRAMA
+094E..094F    ; Devanagari # Mc   [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW
+0950          ; Devanagari # Lo       DEVANAGARI OM
+0955..0957    ; Devanagari # Mn   [3] DEVANAGARI VOWEL SIGN CANDRA LONG E..DEVANAGARI VOWEL SIGN UUE
+0958..0961    ; Devanagari # Lo  [10] DEVANAGARI LETTER QA..DEVANAGARI LETTER VOCALIC LL
+0962..0963    ; Devanagari # Mn   [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL
+0966..096F    ; Devanagari # Nd  [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE
+0970          ; Devanagari # Po       DEVANAGARI ABBREVIATION SIGN
+0971          ; Devanagari # Lm       DEVANAGARI SIGN HIGH SPACING DOT
+0972..097F    ; Devanagari # Lo  [14] DEVANAGARI LETTER CANDRA A..DEVANAGARI LETTER BBA
+A8E0..A8F1    ; Devanagari # Mn  [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA
+A8F2..A8F7    ; Devanagari # Lo   [6] DEVANAGARI SIGN SPACING CANDRABINDU..DEVANAGARI SIGN CANDRABINDU AVAGRAHA
+A8F8..A8FA    ; Devanagari # Po   [3] DEVANAGARI SIGN PUSHPIKA..DEVANAGARI CARET
+A8FB          ; Devanagari # Lo       DEVANAGARI HEADSTROKE
+A8FC          ; Devanagari # Po       DEVANAGARI SIGN SIDDHAM
+A8FD..A8FE    ; Devanagari # Lo   [2] DEVANAGARI JAIN OM..DEVANAGARI LETTER AY
+A8FF          ; Devanagari # Mn       DEVANAGARI VOWEL SIGN AY
+11B00..11B09  ; Devanagari # Po  [10] DEVANAGARI HEAD MARK..DEVANAGARI SIGN MINDU
+
+# Total code points: 164
+
+# ================================================
+
+0980          ; Bengali # Lo       BENGALI ANJI
+0981          ; Bengali # Mn       BENGALI SIGN CANDRABINDU
+0982..0983    ; Bengali # Mc   [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA
+0985..098C    ; Bengali # Lo   [8] BENGALI LETTER A..BENGALI LETTER VOCALIC L
+098F..0990    ; Bengali # Lo   [2] BENGALI LETTER E..BENGALI LETTER AI
+0993..09A8    ; Bengali # Lo  [22] BENGALI LETTER O..BENGALI LETTER NA
+09AA..09B0    ; Bengali # Lo   [7] BENGALI LETTER PA..BENGALI LETTER RA
+09B2          ; Bengali # Lo       BENGALI LETTER LA
+09B6..09B9    ; Bengali # Lo   [4] BENGALI LETTER SHA..BENGALI LETTER HA
+09BC          ; Bengali # Mn       BENGALI SIGN NUKTA
+09BD          ; Bengali # Lo       BENGALI SIGN AVAGRAHA
+09BE..09C0    ; Bengali # Mc   [3] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN II
+09C1..09C4    ; Bengali # Mn   [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR
+09C7..09C8    ; Bengali # Mc   [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI
+09CB..09CC    ; Bengali # Mc   [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU
+09CD          ; Bengali # Mn       BENGALI SIGN VIRAMA
+09CE          ; Bengali # Lo       BENGALI LETTER KHANDA TA
+09D7          ; Bengali # Mc       BENGALI AU LENGTH MARK
+09DC..09DD    ; Bengali # Lo   [2] BENGALI LETTER RRA..BENGALI LETTER RHA
+09DF..09E1    ; Bengali # Lo   [3] BENGALI LETTER YYA..BENGALI LETTER VOCALIC LL
+09E2..09E3    ; Bengali # Mn   [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL
+09E6..09EF    ; Bengali # Nd  [10] BENGALI DIGIT ZERO..BENGALI DIGIT NINE
+09F0..09F1    ; Bengali # Lo   [2] BENGALI LETTER RA WITH MIDDLE DIAGONAL..BENGALI LETTER RA WITH LOWER DIAGONAL
+09F2..09F3    ; Bengali # Sc   [2] BENGALI RUPEE MARK..BENGALI RUPEE SIGN
+09F4..09F9    ; Bengali # No   [6] BENGALI CURRENCY NUMERATOR ONE..BENGALI CURRENCY DENOMINATOR SIXTEEN
+09FA          ; Bengali # So       BENGALI ISSHAR
+09FB          ; Bengali # Sc       BENGALI GANDA MARK
+09FC          ; Bengali # Lo       BENGALI LETTER VEDIC ANUSVARA
+09FD          ; Bengali # Po       BENGALI ABBREVIATION SIGN
+09FE          ; Bengali # Mn       BENGALI SANDHI MARK
+
+# Total code points: 96
+
+# ================================================
+
+0A01..0A02    ; Gurmukhi # Mn   [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI
+0A03          ; Gurmukhi # Mc       GURMUKHI SIGN VISARGA
+0A05..0A0A    ; Gurmukhi # Lo   [6] GURMUKHI LETTER A..GURMUKHI LETTER UU
+0A0F..0A10    ; Gurmukhi # Lo   [2] GURMUKHI LETTER EE..GURMUKHI LETTER AI
+0A13..0A28    ; Gurmukhi # Lo  [22] GURMUKHI LETTER OO..GURMUKHI LETTER NA
+0A2A..0A30    ; Gurmukhi # Lo   [7] GURMUKHI LETTER PA..GURMUKHI LETTER RA
+0A32..0A33    ; Gurmukhi # Lo   [2] GURMUKHI LETTER LA..GURMUKHI LETTER LLA
+0A35..0A36    ; Gurmukhi # Lo   [2] GURMUKHI LETTER VA..GURMUKHI LETTER SHA
+0A38..0A39    ; Gurmukhi # Lo   [2] GURMUKHI LETTER SA..GURMUKHI LETTER HA
+0A3C          ; Gurmukhi # Mn       GURMUKHI SIGN NUKTA
+0A3E..0A40    ; Gurmukhi # Mc   [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II
+0A41..0A42    ; Gurmukhi # Mn   [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU
+0A47..0A48    ; Gurmukhi # Mn   [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI
+0A4B..0A4D    ; Gurmukhi # Mn   [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA
+0A51          ; Gurmukhi # Mn       GURMUKHI SIGN UDAAT
+0A59..0A5C    ; Gurmukhi # Lo   [4] GURMUKHI LETTER KHHA..GURMUKHI LETTER RRA
+0A5E          ; Gurmukhi # Lo       GURMUKHI LETTER FA
+0A66..0A6F    ; Gurmukhi # Nd  [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE
+0A70..0A71    ; Gurmukhi # Mn   [2] GURMUKHI TIPPI..GURMUKHI ADDAK
+0A72..0A74    ; Gurmukhi # Lo   [3] GURMUKHI IRI..GURMUKHI EK ONKAR
+0A75          ; Gurmukhi # Mn       GURMUKHI SIGN YAKASH
+0A76          ; Gurmukhi # Po       GURMUKHI ABBREVIATION SIGN
+
+# Total code points: 80
+
+# ================================================
+
+0A81..0A82    ; Gujarati # Mn   [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA
+0A83          ; Gujarati # Mc       GUJARATI SIGN VISARGA
+0A85..0A8D    ; Gujarati # Lo   [9] GUJARATI LETTER A..GUJARATI VOWEL CANDRA E
+0A8F..0A91    ; Gujarati # Lo   [3] GUJARATI LETTER E..GUJARATI VOWEL CANDRA O
+0A93..0AA8    ; Gujarati # Lo  [22] GUJARATI LETTER O..GUJARATI LETTER NA
+0AAA..0AB0    ; Gujarati # Lo   [7] GUJARATI LETTER PA..GUJARATI LETTER RA
+0AB2..0AB3    ; Gujarati # Lo   [2] GUJARATI LETTER LA..GUJARATI LETTER LLA
+0AB5..0AB9    ; Gujarati # Lo   [5] GUJARATI LETTER VA..GUJARATI LETTER HA
+0ABC          ; Gujarati # Mn       GUJARATI SIGN NUKTA
+0ABD          ; Gujarati # Lo       GUJARATI SIGN AVAGRAHA
+0ABE..0AC0    ; Gujarati # Mc   [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II
+0AC1..0AC5    ; Gujarati # Mn   [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E
+0AC7..0AC8    ; Gujarati # Mn   [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI
+0AC9          ; Gujarati # Mc       GUJARATI VOWEL SIGN CANDRA O
+0ACB..0ACC    ; Gujarati # Mc   [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU
+0ACD          ; Gujarati # Mn       GUJARATI SIGN VIRAMA
+0AD0          ; Gujarati # Lo       GUJARATI OM
+0AE0..0AE1    ; Gujarati # Lo   [2] GUJARATI LETTER VOCALIC RR..GUJARATI LETTER VOCALIC LL
+0AE2..0AE3    ; Gujarati # Mn   [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL
+0AE6..0AEF    ; Gujarati # Nd  [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE
+0AF0          ; Gujarati # Po       GUJARATI ABBREVIATION SIGN
+0AF1          ; Gujarati # Sc       GUJARATI RUPEE SIGN
+0AF9          ; Gujarati # Lo       GUJARATI LETTER ZHA
+0AFA..0AFF    ; Gujarati # Mn   [6] GUJARATI SIGN SUKUN..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE
+
+# Total code points: 91
+
+# ================================================
+
+0B01          ; Oriya # Mn       ORIYA SIGN CANDRABINDU
+0B02..0B03    ; Oriya # Mc   [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA
+0B05..0B0C    ; Oriya # Lo   [8] ORIYA LETTER A..ORIYA LETTER VOCALIC L
+0B0F..0B10    ; Oriya # Lo   [2] ORIYA LETTER E..ORIYA LETTER AI
+0B13..0B28    ; Oriya # Lo  [22] ORIYA LETTER O..ORIYA LETTER NA
+0B2A..0B30    ; Oriya # Lo   [7] ORIYA LETTER PA..ORIYA LETTER RA
+0B32..0B33    ; Oriya # Lo   [2] ORIYA LETTER LA..ORIYA LETTER LLA
+0B35..0B39    ; Oriya # Lo   [5] ORIYA LETTER VA..ORIYA LETTER HA
+0B3C          ; Oriya # Mn       ORIYA SIGN NUKTA
+0B3D          ; Oriya # Lo       ORIYA SIGN AVAGRAHA
+0B3E          ; Oriya # Mc       ORIYA VOWEL SIGN AA
+0B3F          ; Oriya # Mn       ORIYA VOWEL SIGN I
+0B40          ; Oriya # Mc       ORIYA VOWEL SIGN II
+0B41..0B44    ; Oriya # Mn   [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR
+0B47..0B48    ; Oriya # Mc   [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI
+0B4B..0B4C    ; Oriya # Mc   [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU
+0B4D          ; Oriya # Mn       ORIYA SIGN VIRAMA
+0B55..0B56    ; Oriya # Mn   [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK
+0B57          ; Oriya # Mc       ORIYA AU LENGTH MARK
+0B5C..0B5D    ; Oriya # Lo   [2] ORIYA LETTER RRA..ORIYA LETTER RHA
+0B5F..0B61    ; Oriya # Lo   [3] ORIYA LETTER YYA..ORIYA LETTER VOCALIC LL
+0B62..0B63    ; Oriya # Mn   [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL
+0B66..0B6F    ; Oriya # Nd  [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE
+0B70          ; Oriya # So       ORIYA ISSHAR
+0B71          ; Oriya # Lo       ORIYA LETTER WA
+0B72..0B77    ; Oriya # No   [6] ORIYA FRACTION ONE QUARTER..ORIYA FRACTION THREE SIXTEENTHS
+
+# Total code points: 91
+
+# ================================================
+
+0B82          ; Tamil # Mn       TAMIL SIGN ANUSVARA
+0B83          ; Tamil # Lo       TAMIL SIGN VISARGA
+0B85..0B8A    ; Tamil # Lo   [6] TAMIL LETTER A..TAMIL LETTER UU
+0B8E..0B90    ; Tamil # Lo   [3] TAMIL LETTER E..TAMIL LETTER AI
+0B92..0B95    ; Tamil # Lo   [4] TAMIL LETTER O..TAMIL LETTER KA
+0B99..0B9A    ; Tamil # Lo   [2] TAMIL LETTER NGA..TAMIL LETTER CA
+0B9C          ; Tamil # Lo       TAMIL LETTER JA
+0B9E..0B9F    ; Tamil # Lo   [2] TAMIL LETTER NYA..TAMIL LETTER TTA
+0BA3..0BA4    ; Tamil # Lo   [2] TAMIL LETTER NNA..TAMIL LETTER TA
+0BA8..0BAA    ; Tamil # Lo   [3] TAMIL LETTER NA..TAMIL LETTER PA
+0BAE..0BB9    ; Tamil # Lo  [12] TAMIL LETTER MA..TAMIL LETTER HA
+0BBE..0BBF    ; Tamil # Mc   [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN I
+0BC0          ; Tamil # Mn       TAMIL VOWEL SIGN II
+0BC1..0BC2    ; Tamil # Mc   [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU
+0BC6..0BC8    ; Tamil # Mc   [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI
+0BCA..0BCC    ; Tamil # Mc   [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU
+0BCD          ; Tamil # Mn       TAMIL SIGN VIRAMA
+0BD0          ; Tamil # Lo       TAMIL OM
+0BD7          ; Tamil # Mc       TAMIL AU LENGTH MARK
+0BE6..0BEF    ; Tamil # Nd  [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE
+0BF0..0BF2    ; Tamil # No   [3] TAMIL NUMBER TEN..TAMIL NUMBER ONE THOUSAND
+0BF3..0BF8    ; Tamil # So   [6] TAMIL DAY SIGN..TAMIL AS ABOVE SIGN
+0BF9          ; Tamil # Sc       TAMIL RUPEE SIGN
+0BFA          ; Tamil # So       TAMIL NUMBER SIGN
+11FC0..11FD4  ; Tamil # No  [21] TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH..TAMIL FRACTION DOWNSCALING FACTOR KIIZH
+11FD5..11FDC  ; Tamil # So   [8] TAMIL SIGN NEL..TAMIL SIGN MUKKURUNI
+11FDD..11FE0  ; Tamil # Sc   [4] TAMIL SIGN KAACU..TAMIL SIGN VARAAKAN
+11FE1..11FF1  ; Tamil # So  [17] TAMIL SIGN PAARAM..TAMIL SIGN VAKAIYARAA
+11FFF         ; Tamil # Po       TAMIL PUNCTUATION END OF TEXT
+
+# Total code points: 123
+
+# ================================================
+
+0C00          ; Telugu # Mn       TELUGU SIGN COMBINING CANDRABINDU ABOVE
+0C01..0C03    ; Telugu # Mc   [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA
+0C04          ; Telugu # Mn       TELUGU SIGN COMBINING ANUSVARA ABOVE
+0C05..0C0C    ; Telugu # Lo   [8] TELUGU LETTER A..TELUGU LETTER VOCALIC L
+0C0E..0C10    ; Telugu # Lo   [3] TELUGU LETTER E..TELUGU LETTER AI
+0C12..0C28    ; Telugu # Lo  [23] TELUGU LETTER O..TELUGU LETTER NA
+0C2A..0C39    ; Telugu # Lo  [16] TELUGU LETTER PA..TELUGU LETTER HA
+0C3C          ; Telugu # Mn       TELUGU SIGN NUKTA
+0C3D          ; Telugu # Lo       TELUGU SIGN AVAGRAHA
+0C3E..0C40    ; Telugu # Mn   [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II
+0C41..0C44    ; Telugu # Mc   [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR
+0C46..0C48    ; Telugu # Mn   [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI
+0C4A..0C4D    ; Telugu # Mn   [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA
+0C55..0C56    ; Telugu # Mn   [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK
+0C58..0C5A    ; Telugu # Lo   [3] TELUGU LETTER TSA..TELUGU LETTER RRRA
+0C5C..0C5D    ; Telugu # Lo   [2] TELUGU ARCHAIC SHRII..TELUGU LETTER NAKAARA POLLU
+0C60..0C61    ; Telugu # Lo   [2] TELUGU LETTER VOCALIC RR..TELUGU LETTER VOCALIC LL
+0C62..0C63    ; Telugu # Mn   [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL
+0C66..0C6F    ; Telugu # Nd  [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE
+0C77          ; Telugu # Po       TELUGU SIGN SIDDHAM
+0C78..0C7E    ; Telugu # No   [7] TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR..TELUGU FRACTION DIGIT THREE FOR EVEN POWERS OF FOUR
+0C7F          ; Telugu # So       TELUGU SIGN TUUMU
+
+# Total code points: 101
+
+# ================================================
+
+0C80          ; Kannada # Lo       KANNADA SIGN SPACING CANDRABINDU
+0C81          ; Kannada # Mn       KANNADA SIGN CANDRABINDU
+0C82..0C83    ; Kannada # Mc   [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA
+0C84          ; Kannada # Po       KANNADA SIGN SIDDHAM
+0C85..0C8C    ; Kannada # Lo   [8] KANNADA LETTER A..KANNADA LETTER VOCALIC L
+0C8E..0C90    ; Kannada # Lo   [3] KANNADA LETTER E..KANNADA LETTER AI
+0C92..0CA8    ; Kannada # Lo  [23] KANNADA LETTER O..KANNADA LETTER NA
+0CAA..0CB3    ; Kannada # Lo  [10] KANNADA LETTER PA..KANNADA LETTER LLA
+0CB5..0CB9    ; Kannada # Lo   [5] KANNADA LETTER VA..KANNADA LETTER HA
+0CBC          ; Kannada # Mn       KANNADA SIGN NUKTA
+0CBD          ; Kannada # Lo       KANNADA SIGN AVAGRAHA
+0CBE          ; Kannada # Mc       KANNADA VOWEL SIGN AA
+0CBF          ; Kannada # Mn       KANNADA VOWEL SIGN I
+0CC0..0CC4    ; Kannada # Mc   [5] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN VOCALIC RR
+0CC6          ; Kannada # Mn       KANNADA VOWEL SIGN E
+0CC7..0CC8    ; Kannada # Mc   [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI
+0CCA..0CCB    ; Kannada # Mc   [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO
+0CCC..0CCD    ; Kannada # Mn   [2] KANNADA VOWEL SIGN AU..KANNADA SIGN VIRAMA
+0CD5..0CD6    ; Kannada # Mc   [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK
+0CDC..0CDE    ; Kannada # Lo   [3] KANNADA ARCHAIC SHRII..KANNADA LETTER FA
+0CE0..0CE1    ; Kannada # Lo   [2] KANNADA LETTER VOCALIC RR..KANNADA LETTER VOCALIC LL
+0CE2..0CE3    ; Kannada # Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
+0CE6..0CEF    ; Kannada # Nd  [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
+0CF1..0CF2    ; Kannada # Lo   [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA
+0CF3          ; Kannada # Mc       KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT
+
+# Total code points: 92
+
+# ================================================
+
+0D00..0D01    ; Malayalam # Mn   [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU
+0D02..0D03    ; Malayalam # Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
+0D04..0D0C    ; Malayalam # Lo   [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L
+0D0E..0D10    ; Malayalam # Lo   [3] MALAYALAM LETTER E..MALAYALAM LETTER AI
+0D12..0D3A    ; Malayalam # Lo  [41] MALAYALAM LETTER O..MALAYALAM LETTER TTTA
+0D3B..0D3C    ; Malayalam # Mn   [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA
+0D3D          ; Malayalam # Lo       MALAYALAM SIGN AVAGRAHA
+0D3E..0D40    ; Malayalam # Mc   [3] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN II
+0D41..0D44    ; Malayalam # Mn   [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR
+0D46..0D48    ; Malayalam # Mc   [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI
+0D4A..0D4C    ; Malayalam # Mc   [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU
+0D4D          ; Malayalam # Mn       MALAYALAM SIGN VIRAMA
+0D4E          ; Malayalam # Lo       MALAYALAM LETTER DOT REPH
+0D4F          ; Malayalam # So       MALAYALAM SIGN PARA
+0D54..0D56    ; Malayalam # Lo   [3] MALAYALAM LETTER CHILLU M..MALAYALAM LETTER CHILLU LLL
+0D57          ; Malayalam # Mc       MALAYALAM AU LENGTH MARK
+0D58..0D5E    ; Malayalam # No   [7] MALAYALAM FRACTION ONE ONE-HUNDRED-AND-SIXTIETH..MALAYALAM FRACTION ONE FIFTH
+0D5F..0D61    ; Malayalam # Lo   [3] MALAYALAM LETTER ARCHAIC II..MALAYALAM LETTER VOCALIC LL
+0D62..0D63    ; Malayalam # Mn   [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL
+0D66..0D6F    ; Malayalam # Nd  [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE
+0D70..0D78    ; Malayalam # No   [9] MALAYALAM NUMBER TEN..MALAYALAM FRACTION THREE SIXTEENTHS
+0D79          ; Malayalam # So       MALAYALAM DATE MARK
+0D7A..0D7F    ; Malayalam # Lo   [6] MALAYALAM LETTER CHILLU NN..MALAYALAM LETTER CHILLU K
+
+# Total code points: 118
+
+# ================================================
+
+0D81          ; Sinhala # Mn       SINHALA SIGN CANDRABINDU
+0D82..0D83    ; Sinhala # Mc   [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA
+0D85..0D96    ; Sinhala # Lo  [18] SINHALA LETTER AYANNA..SINHALA LETTER AUYANNA
+0D9A..0DB1    ; Sinhala # Lo  [24] SINHALA LETTER ALPAPRAANA KAYANNA..SINHALA LETTER DANTAJA NAYANNA
+0DB3..0DBB    ; Sinhala # Lo   [9] SINHALA LETTER SANYAKA DAYANNA..SINHALA LETTER RAYANNA
+0DBD          ; Sinhala # Lo       SINHALA LETTER DANTAJA LAYANNA
+0DC0..0DC6    ; Sinhala # Lo   [7] SINHALA LETTER VAYANNA..SINHALA LETTER FAYANNA
+0DCA          ; Sinhala # Mn       SINHALA SIGN AL-LAKUNA
+0DCF..0DD1    ; Sinhala # Mc   [3] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA
+0DD2..0DD4    ; Sinhala # Mn   [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA
+0DD6          ; Sinhala # Mn       SINHALA VOWEL SIGN DIGA PAA-PILLA
+0DD8..0DDF    ; Sinhala # Mc   [8] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN GAYANUKITTA
+0DE6..0DEF    ; Sinhala # Nd  [10] SINHALA LITH DIGIT ZERO..SINHALA LITH DIGIT NINE
+0DF2..0DF3    ; Sinhala # Mc   [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA
+0DF4          ; Sinhala # Po       SINHALA PUNCTUATION KUNDDALIYA
+111E1..111F4  ; Sinhala # No  [20] SINHALA ARCHAIC DIGIT ONE..SINHALA ARCHAIC NUMBER ONE THOUSAND
+
+# Total code points: 111
+
+# ================================================
+
+0E01..0E30    ; Thai # Lo  [48] THAI CHARACTER KO KAI..THAI CHARACTER SARA A
+0E31          ; Thai # Mn       THAI CHARACTER MAI HAN-AKAT
+0E32..0E33    ; Thai # Lo   [2] THAI CHARACTER SARA AA..THAI CHARACTER SARA AM
+0E34..0E3A    ; Thai # Mn   [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU
+0E40..0E45    ; Thai # Lo   [6] THAI CHARACTER SARA E..THAI CHARACTER LAKKHANGYAO
+0E46          ; Thai # Lm       THAI CHARACTER MAIYAMOK
+0E47..0E4E    ; Thai # Mn   [8] THAI CHARACTER MAITAIKHU..THAI CHARACTER YAMAKKAN
+0E4F          ; Thai # Po       THAI CHARACTER FONGMAN
+0E50..0E59    ; Thai # Nd  [10] THAI DIGIT ZERO..THAI DIGIT NINE
+0E5A..0E5B    ; Thai # Po   [2] THAI CHARACTER ANGKHANKHU..THAI CHARACTER KHOMUT
+
+# Total code points: 86
+
+# ================================================
+
+0E81..0E82    ; Lao # Lo   [2] LAO LETTER KO..LAO LETTER KHO SUNG
+0E84          ; Lao # Lo       LAO LETTER KHO TAM
+0E86..0E8A    ; Lao # Lo   [5] LAO LETTER PALI GHA..LAO LETTER SO TAM
+0E8C..0EA3    ; Lao # Lo  [24] LAO LETTER PALI JHA..LAO LETTER LO LING
+0EA5          ; Lao # Lo       LAO LETTER LO LOOT
+0EA7..0EB0    ; Lao # Lo  [10] LAO LETTER WO..LAO VOWEL SIGN A
+0EB1          ; Lao # Mn       LAO VOWEL SIGN MAI KAN
+0EB2..0EB3    ; Lao # Lo   [2] LAO VOWEL SIGN AA..LAO VOWEL SIGN AM
+0EB4..0EBC    ; Lao # Mn   [9] LAO VOWEL SIGN I..LAO SEMIVOWEL SIGN LO
+0EBD          ; Lao # Lo       LAO SEMIVOWEL SIGN NYO
+0EC0..0EC4    ; Lao # Lo   [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
+0EC6          ; Lao # Lm       LAO KO LA
+0EC8..0ECE    ; Lao # Mn   [7] LAO TONE MAI EK..LAO YAMAKKAN
+0ED0..0ED9    ; Lao # Nd  [10] LAO DIGIT ZERO..LAO DIGIT NINE
+0EDC..0EDF    ; Lao # Lo   [4] LAO HO NO..LAO LETTER KHMU NYO
+
+# Total code points: 83
+
+# ================================================
+
+0F00          ; Tibetan # Lo       TIBETAN SYLLABLE OM
+0F01..0F03    ; Tibetan # So   [3] TIBETAN MARK GTER YIG MGO TRUNCATED A..TIBETAN MARK GTER YIG MGO -UM GTER TSHEG MA
+0F04..0F12    ; Tibetan # Po  [15] TIBETAN MARK INITIAL YIG MGO MDUN MA..TIBETAN MARK RGYA GRAM SHAD
+0F13          ; Tibetan # So       TIBETAN MARK CARET -DZUD RTAGS ME LONG CAN
+0F14          ; Tibetan # Po       TIBETAN MARK GTER TSHEG
+0F15..0F17    ; Tibetan # So   [3] TIBETAN LOGOTYPE SIGN CHAD RTAGS..TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS
+0F18..0F19    ; Tibetan # Mn   [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS
+0F1A..0F1F    ; Tibetan # So   [6] TIBETAN SIGN RDEL DKAR GCIG..TIBETAN SIGN RDEL DKAR RDEL NAG
+0F20..0F29    ; Tibetan # Nd  [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE
+0F2A..0F33    ; Tibetan # No  [10] TIBETAN DIGIT HALF ONE..TIBETAN DIGIT HALF ZERO
+0F34          ; Tibetan # So       TIBETAN MARK BSDUS RTAGS
+0F35          ; Tibetan # Mn       TIBETAN MARK NGAS BZUNG NYI ZLA
+0F36          ; Tibetan # So       TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN
+0F37          ; Tibetan # Mn       TIBETAN MARK NGAS BZUNG SGOR RTAGS
+0F38          ; Tibetan # So       TIBETAN MARK CHE MGO
+0F39          ; Tibetan # Mn       TIBETAN MARK TSA -PHRU
+0F3A          ; Tibetan # Ps       TIBETAN MARK GUG RTAGS GYON
+0F3B          ; Tibetan # Pe       TIBETAN MARK GUG RTAGS GYAS
+0F3C          ; Tibetan # Ps       TIBETAN MARK ANG KHANG GYON
+0F3D          ; Tibetan # Pe       TIBETAN MARK ANG KHANG GYAS
+0F3E..0F3F    ; Tibetan # Mc   [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES
+0F40..0F47    ; Tibetan # Lo   [8] TIBETAN LETTER KA..TIBETAN LETTER JA
+0F49..0F6C    ; Tibetan # Lo  [36] TIBETAN LETTER NYA..TIBETAN LETTER RRA
+0F71..0F7E    ; Tibetan # Mn  [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO
+0F7F          ; Tibetan # Mc       TIBETAN SIGN RNAM BCAD
+0F80..0F84    ; Tibetan # Mn   [5] TIBETAN VOWEL SIGN REVERSED I..TIBETAN MARK HALANTA
+0F85          ; Tibetan # Po       TIBETAN MARK PALUTA
+0F86..0F87    ; Tibetan # Mn   [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS
+0F88..0F8C    ; Tibetan # Lo   [5] TIBETAN SIGN LCE TSA CAN..TIBETAN SIGN INVERTED MCHU CAN
+0F8D..0F97    ; Tibetan # Mn  [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA
+0F99..0FBC    ; Tibetan # Mn  [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA
+0FBE..0FC5    ; Tibetan # So   [8] TIBETAN KU RU KHA..TIBETAN SYMBOL RDO RJE
+0FC6          ; Tibetan # Mn       TIBETAN SYMBOL PADMA GDAN
+0FC7..0FCC    ; Tibetan # So   [6] TIBETAN SYMBOL RDO RJE RGYA GRAM..TIBETAN SYMBOL NOR BU BZHI -KHYIL
+0FCE..0FCF    ; Tibetan # So   [2] TIBETAN SIGN RDEL NAG RDEL DKAR..TIBETAN SIGN RDEL NAG GSUM
+0FD0..0FD4    ; Tibetan # Po   [5] TIBETAN MARK BSKA- SHOG GI MGO RGYAN..TIBETAN MARK CLOSING BRDA RNYING YIG MGO SGAB MA
+0FD9..0FDA    ; Tibetan # Po   [2] TIBETAN MARK LEADING MCHAN RTAGS..TIBETAN MARK TRAILING MCHAN RTAGS
+
+# Total code points: 207
+
+# ================================================
+
+1000..102A    ; Myanmar # Lo  [43] MYANMAR LETTER KA..MYANMAR LETTER AU
+102B..102C    ; Myanmar # Mc   [2] MYANMAR VOWEL SIGN TALL AA..MYANMAR VOWEL SIGN AA
+102D..1030    ; Myanmar # Mn   [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU
+1031          ; Myanmar # Mc       MYANMAR VOWEL SIGN E
+1032..1037    ; Myanmar # Mn   [6] MYANMAR VOWEL SIGN AI..MYANMAR SIGN DOT BELOW
+1038          ; Myanmar # Mc       MYANMAR SIGN VISARGA
+1039..103A    ; Myanmar # Mn   [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT
+103B..103C    ; Myanmar # Mc   [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA
+103D..103E    ; Myanmar # Mn   [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA
+103F          ; Myanmar # Lo       MYANMAR LETTER GREAT SA
+1040..1049    ; Myanmar # Nd  [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE
+104A..104F    ; Myanmar # Po   [6] MYANMAR SIGN LITTLE SECTION..MYANMAR SYMBOL GENITIVE
+1050..1055    ; Myanmar # Lo   [6] MYANMAR LETTER SHA..MYANMAR LETTER VOCALIC LL
+1056..1057    ; Myanmar # Mc   [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR
+1058..1059    ; Myanmar # Mn   [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL
+105A..105D    ; Myanmar # Lo   [4] MYANMAR LETTER MON NGA..MYANMAR LETTER MON BBE
+105E..1060    ; Myanmar # Mn   [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA
+1061          ; Myanmar # Lo       MYANMAR LETTER SGAW KAREN SHA
+1062..1064    ; Myanmar # Mc   [3] MYANMAR VOWEL SIGN SGAW KAREN EU..MYANMAR TONE MARK SGAW KAREN KE PHO
+1065..1066    ; Myanmar # Lo   [2] MYANMAR LETTER WESTERN PWO KAREN THA..MYANMAR LETTER WESTERN PWO KAREN PWA
+1067..106D    ; Myanmar # Mc   [7] MYANMAR VOWEL SIGN WESTERN PWO KAREN EU..MYANMAR SIGN WESTERN PWO KAREN TONE-5
+106E..1070    ; Myanmar # Lo   [3] MYANMAR LETTER EASTERN PWO KAREN NNA..MYANMAR LETTER EASTERN PWO KAREN GHWA
+1071..1074    ; Myanmar # Mn   [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE
+1075..1081    ; Myanmar # Lo  [13] MYANMAR LETTER SHAN KA..MYANMAR LETTER SHAN HA
+1082          ; Myanmar # Mn       MYANMAR CONSONANT SIGN SHAN MEDIAL WA
+1083..1084    ; Myanmar # Mc   [2] MYANMAR VOWEL SIGN SHAN AA..MYANMAR VOWEL SIGN SHAN E
+1085..1086    ; Myanmar # Mn   [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y
+1087..108C    ; Myanmar # Mc   [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3
+108D          ; Myanmar # Mn       MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE
+108E          ; Myanmar # Lo       MYANMAR LETTER RUMAI PALAUNG FA
+108F          ; Myanmar # Mc       MYANMAR SIGN RUMAI PALAUNG TONE-5
+1090..1099    ; Myanmar # Nd  [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE
+109A..109C    ; Myanmar # Mc   [3] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON A
+109D          ; Myanmar # Mn       MYANMAR VOWEL SIGN AITON AI
+109E..109F    ; Myanmar # So   [2] MYANMAR SYMBOL SHAN ONE..MYANMAR SYMBOL SHAN EXCLAMATION
+A9E0..A9E4    ; Myanmar # Lo   [5] MYANMAR LETTER SHAN GHA..MYANMAR LETTER SHAN BHA
+A9E5          ; Myanmar # Mn       MYANMAR SIGN SHAN SAW
+A9E6          ; Myanmar # Lm       MYANMAR MODIFIER LETTER SHAN REDUPLICATION
+A9E7..A9EF    ; Myanmar # Lo   [9] MYANMAR LETTER TAI LAING NYA..MYANMAR LETTER TAI LAING NNA
+A9F0..A9F9    ; Myanmar # Nd  [10] MYANMAR TAI LAING DIGIT ZERO..MYANMAR TAI LAING DIGIT NINE
+A9FA..A9FE    ; Myanmar # Lo   [5] MYANMAR LETTER TAI LAING LLA..MYANMAR LETTER TAI LAING BHA
+AA60..AA6F    ; Myanmar # Lo  [16] MYANMAR LETTER KHAMTI GA..MYANMAR LETTER KHAMTI FA
+AA70          ; Myanmar # Lm       MYANMAR MODIFIER LETTER KHAMTI REDUPLICATION
+AA71..AA76    ; Myanmar # Lo   [6] MYANMAR LETTER KHAMTI XA..MYANMAR LOGOGRAM KHAMTI HM
+AA77..AA79    ; Myanmar # So   [3] MYANMAR SYMBOL AITON EXCLAMATION..MYANMAR SYMBOL AITON TWO
+AA7A          ; Myanmar # Lo       MYANMAR LETTER AITON RA
+AA7B          ; Myanmar # Mc       MYANMAR SIGN PAO KAREN TONE
+AA7C          ; Myanmar # Mn       MYANMAR SIGN TAI LAING TONE-2
+AA7D          ; Myanmar # Mc       MYANMAR SIGN TAI LAING TONE-5
+AA7E..AA7F    ; Myanmar # Lo   [2] MYANMAR LETTER SHWE PALAUNG CHA..MYANMAR LETTER SHWE PALAUNG SHA
+116D0..116E3  ; Myanmar # Nd  [20] MYANMAR PAO DIGIT ZERO..MYANMAR EASTERN PWO KAREN DIGIT NINE
+
+# Total code points: 243
+
+# ================================================
+
+10A0..10C5    ; Georgian # L&  [38] GEORGIAN CAPITAL LETTER AN..GEORGIAN CAPITAL LETTER HOE
+10C7          ; Georgian # L&       GEORGIAN CAPITAL LETTER YN
+10CD          ; Georgian # L&       GEORGIAN CAPITAL LETTER AEN
+10D0..10FA    ; Georgian # L&  [43] GEORGIAN LETTER AN..GEORGIAN LETTER AIN
+10FC          ; Georgian # Lm       MODIFIER LETTER GEORGIAN NAR
+10FD..10FF    ; Georgian # L&   [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN
+1C90..1CBA    ; Georgian # L&  [43] GEORGIAN MTAVRULI CAPITAL LETTER AN..GEORGIAN MTAVRULI CAPITAL LETTER AIN
+1CBD..1CBF    ; Georgian # L&   [3] GEORGIAN MTAVRULI CAPITAL LETTER AEN..GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN
+2D00..2D25    ; Georgian # L&  [38] GEORGIAN SMALL LETTER AN..GEORGIAN SMALL LETTER HOE
+2D27          ; Georgian # L&       GEORGIAN SMALL LETTER YN
+2D2D          ; Georgian # L&       GEORGIAN SMALL LETTER AEN
+
+# Total code points: 173
+
+# ================================================
+
+1100..11FF    ; Hangul # Lo [256] HANGUL CHOSEONG KIYEOK..HANGUL JONGSEONG SSANGNIEUN
+302E..302F    ; Hangul # Mc   [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK
+3131..318E    ; Hangul # Lo  [94] HANGUL LETTER KIYEOK..HANGUL LETTER ARAEAE
+3200..321E    ; Hangul # So  [31] PARENTHESIZED HANGUL KIYEOK..PARENTHESIZED KOREAN CHARACTER O HU
+3260..327E    ; Hangul # So  [31] CIRCLED HANGUL KIYEOK..CIRCLED HANGUL IEUNG U
+A960..A97C    ; Hangul # Lo  [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH
+AC00..D7A3    ; Hangul # Lo [11172] HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH
+D7B0..D7C6    ; Hangul # Lo  [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E
+D7CB..D7FB    ; Hangul # Lo  [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH
+FFA0..FFBE    ; Hangul # Lo  [31] HALFWIDTH HANGUL FILLER..HALFWIDTH HANGUL LETTER HIEUH
+FFC2..FFC7    ; Hangul # Lo   [6] HALFWIDTH HANGUL LETTER A..HALFWIDTH HANGUL LETTER E
+FFCA..FFCF    ; Hangul # Lo   [6] HALFWIDTH HANGUL LETTER YEO..HALFWIDTH HANGUL LETTER OE
+FFD2..FFD7    ; Hangul # Lo   [6] HALFWIDTH HANGUL LETTER YO..HALFWIDTH HANGUL LETTER YU
+FFDA..FFDC    ; Hangul # Lo   [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL LETTER I
+
+# Total code points: 11739
+
+# ================================================
+
+1200..1248    ; Ethiopic # Lo  [73] ETHIOPIC SYLLABLE HA..ETHIOPIC SYLLABLE QWA
+124A..124D    ; Ethiopic # Lo   [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SYLLABLE QWE
+1250..1256    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SYLLABLE QHO
+1258          ; Ethiopic # Lo       ETHIOPIC SYLLABLE QHWA
+125A..125D    ; Ethiopic # Lo   [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC SYLLABLE QHWE
+1260..1288    ; Ethiopic # Lo  [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYLLABLE XWA
+128A..128D    ; Ethiopic # Lo   [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SYLLABLE XWE
+1290..12B0    ; Ethiopic # Lo  [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYLLABLE KWA
+12B2..12B5    ; Ethiopic # Lo   [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SYLLABLE KWE
+12B8..12BE    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SYLLABLE KXO
+12C0          ; Ethiopic # Lo       ETHIOPIC SYLLABLE KXWA
+12C2..12C5    ; Ethiopic # Lo   [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC SYLLABLE KXWE
+12C8..12D6    ; Ethiopic # Lo  [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYLLABLE PHARYNGEAL O
+12D8..1310    ; Ethiopic # Lo  [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYLLABLE GWA
+1312..1315    ; Ethiopic # Lo   [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SYLLABLE GWE
+1318..135A    ; Ethiopic # Lo  [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SYLLABLE FYA
+135D..135F    ; Ethiopic # Mn   [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK
+1360..1368    ; Ethiopic # Po   [9] ETHIOPIC SECTION MARK..ETHIOPIC PARAGRAPH SEPARATOR
+1369..137C    ; Ethiopic # No  [20] ETHIOPIC DIGIT ONE..ETHIOPIC NUMBER TEN THOUSAND
+1380..138F    ; Ethiopic # Lo  [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..ETHIOPIC SYLLABLE PWE
+1390..1399    ; Ethiopic # So  [10] ETHIOPIC TONAL MARK YIZET..ETHIOPIC TONAL MARK KURT
+2D80..2D96    ; Ethiopic # Lo  [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SYLLABLE GGWE
+2DA0..2DA6    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SYLLABLE SSO
+2DA8..2DAE    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SYLLABLE CCO
+2DB0..2DB6    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SYLLABLE ZZO
+2DB8..2DBE    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC SYLLABLE CCHO
+2DC0..2DC6    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SYLLABLE QYO
+2DC8..2DCE    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SYLLABLE KYO
+2DD0..2DD6    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SYLLABLE XYO
+2DD8..2DDE    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SYLLABLE GYO
+AB01..AB06    ; Ethiopic # Lo   [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC SYLLABLE TTHO
+AB09..AB0E    ; Ethiopic # Lo   [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC SYLLABLE DDHO
+AB11..AB16    ; Ethiopic # Lo   [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SYLLABLE DZO
+AB20..AB26    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC SYLLABLE CCHHO
+AB28..AB2E    ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SYLLABLE BBO
+1E7E0..1E7E6  ; Ethiopic # Lo   [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO
+1E7E8..1E7EB  ; Ethiopic # Lo   [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE
+1E7ED..1E7EE  ; Ethiopic # Lo   [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE
+1E7F0..1E7FE  ; Ethiopic # Lo  [15] ETHIOPIC SYLLABLE GURAGE QWI..ETHIOPIC SYLLABLE GURAGE PWEE
+
+# Total code points: 523
+
+# ================================================
+
+13A0..13F5    ; Cherokee # L&  [86] CHEROKEE LETTER A..CHEROKEE LETTER MV
+13F8..13FD    ; Cherokee # L&   [6] CHEROKEE SMALL LETTER YE..CHEROKEE SMALL LETTER MV
+AB70..ABBF    ; Cherokee # L&  [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA
+
+# Total code points: 172
+
+# ================================================
+
+1400          ; Canadian_Aboriginal # Pd       CANADIAN SYLLABICS HYPHEN
+1401..166C    ; Canadian_Aboriginal # Lo [620] CANADIAN SYLLABICS E..CANADIAN SYLLABICS CARRIER TTSA
+166D          ; Canadian_Aboriginal # So       CANADIAN SYLLABICS CHI SIGN
+166E          ; Canadian_Aboriginal # Po       CANADIAN SYLLABICS FULL STOP
+166F..167F    ; Canadian_Aboriginal # Lo  [17] CANADIAN SYLLABICS QAI..CANADIAN SYLLABICS BLACKFOOT W
+18B0..18F5    ; Canadian_Aboriginal # Lo  [70] CANADIAN SYLLABICS OY..CANADIAN SYLLABICS CARRIER DENTAL S
+11AB0..11ABF  ; Canadian_Aboriginal # Lo  [16] CANADIAN SYLLABICS NATTILIK HI..CANADIAN SYLLABICS SPA
+
+# Total code points: 726
+
+# ================================================
+
+1680          ; Ogham # Zs       OGHAM SPACE MARK
+1681..169A    ; Ogham # Lo  [26] OGHAM LETTER BEITH..OGHAM LETTER PEITH
+169B          ; Ogham # Ps       OGHAM FEATHER MARK
+169C          ; Ogham # Pe       OGHAM REVERSED FEATHER MARK
+
+# Total code points: 29
+
+# ================================================
+
+16A0..16EA    ; Runic # Lo  [75] RUNIC LETTER FEHU FEOH FE F..RUNIC LETTER X
+16EE..16F0    ; Runic # Nl   [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHOR SYMBOL
+16F1..16F8    ; Runic # Lo   [8] RUNIC LETTER K..RUNIC LETTER FRANKS CASKET AESC
+
+# Total code points: 86
+
+# ================================================
+
+1780..17B3    ; Khmer # Lo  [52] KHMER LETTER KA..KHMER INDEPENDENT VOWEL QAU
+17B4..17B5    ; Khmer # Mn   [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA
+17B6          ; Khmer # Mc       KHMER VOWEL SIGN AA
+17B7..17BD    ; Khmer # Mn   [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA
+17BE..17C5    ; Khmer # Mc   [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU
+17C6          ; Khmer # Mn       KHMER SIGN NIKAHIT
+17C7..17C8    ; Khmer # Mc   [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU
+17C9..17D3    ; Khmer # Mn  [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT
+17D4..17D6    ; Khmer # Po   [3] KHMER SIGN KHAN..KHMER SIGN CAMNUC PII KUUH
+17D7          ; Khmer # Lm       KHMER SIGN LEK TOO
+17D8..17DA    ; Khmer # Po   [3] KHMER SIGN BEYYAL..KHMER SIGN KOOMUUT
+17DB          ; Khmer # Sc       KHMER CURRENCY SYMBOL RIEL
+17DC          ; Khmer # Lo       KHMER SIGN AVAKRAHASANYA
+17DD          ; Khmer # Mn       KHMER SIGN ATTHACAN
+17E0..17E9    ; Khmer # Nd  [10] KHMER DIGIT ZERO..KHMER DIGIT NINE
+17F0..17F9    ; Khmer # No  [10] KHMER SYMBOL LEK ATTAK SON..KHMER SYMBOL LEK ATTAK PRAM-BUON
+19E0..19FF    ; Khmer # So  [32] KHMER SYMBOL PATHAMASAT..KHMER SYMBOL DAP-PRAM ROC
+
+# Total code points: 146
+
+# ================================================
+
+1800..1801    ; Mongolian # Po   [2] MONGOLIAN BIRGA..MONGOLIAN ELLIPSIS
+1804          ; Mongolian # Po       MONGOLIAN COLON
+1806          ; Mongolian # Pd       MONGOLIAN TODO SOFT HYPHEN
+1807..180A    ; Mongolian # Po   [4] MONGOLIAN SIBE SYLLABLE BOUNDARY MARKER..MONGOLIAN NIRUGU
+180B..180D    ; Mongolian # Mn   [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE
+180E          ; Mongolian # Cf       MONGOLIAN VOWEL SEPARATOR
+180F          ; Mongolian # Mn       MONGOLIAN FREE VARIATION SELECTOR FOUR
+1810..1819    ; Mongolian # Nd  [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE
+1820..1842    ; Mongolian # Lo  [35] MONGOLIAN LETTER A..MONGOLIAN LETTER CHI
+1843          ; Mongolian # Lm       MONGOLIAN LETTER TODO LONG VOWEL SIGN
+1844..1878    ; Mongolian # Lo  [53] MONGOLIAN LETTER TODO E..MONGOLIAN LETTER CHA WITH TWO DOTS
+1880..1884    ; Mongolian # Lo   [5] MONGOLIAN LETTER ALI GALI ANUSVARA ONE..MONGOLIAN LETTER ALI GALI INVERTED UBADAMA
+1885..1886    ; Mongolian # Mn   [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA
+1887..18A8    ; Mongolian # Lo  [34] MONGOLIAN LETTER ALI GALI A..MONGOLIAN LETTER MANCHU ALI GALI BHA
+18A9          ; Mongolian # Mn       MONGOLIAN LETTER ALI GALI DAGALGA
+18AA          ; Mongolian # Lo       MONGOLIAN LETTER MANCHU ALI GALI LHA
+11660..1166C  ; Mongolian # Po  [13] MONGOLIAN BIRGA WITH ORNAMENT..MONGOLIAN TURNED SWIRL BIRGA WITH DOUBLE ORNAMENT
+
+# Total code points: 168
+
+# ================================================
+
+3041..3096    ; Hiragana # Lo  [86] HIRAGANA LETTER SMALL A..HIRAGANA LETTER SMALL KE
+309D..309E    ; Hiragana # Lm   [2] HIRAGANA ITERATION MARK..HIRAGANA VOICED ITERATION MARK
+309F          ; Hiragana # Lo       HIRAGANA DIGRAPH YORI
+1B001..1B11F  ; Hiragana # Lo [287] HIRAGANA LETTER ARCHAIC YE..HIRAGANA LETTER ARCHAIC WU
+1B132         ; Hiragana # Lo       HIRAGANA LETTER SMALL KO
+1B150..1B152  ; Hiragana # Lo   [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO
+1F200         ; Hiragana # So       SQUARE HIRAGANA HOKA
+
+# Total code points: 381
+
+# ================================================
+
+30A1..30FA    ; Katakana # Lo  [90] KATAKANA LETTER SMALL A..KATAKANA LETTER VO
+30FD..30FE    ; Katakana # Lm   [2] KATAKANA ITERATION MARK..KATAKANA VOICED ITERATION MARK
+30FF          ; Katakana # Lo       KATAKANA DIGRAPH KOTO
+31F0..31FF    ; Katakana # Lo  [16] KATAKANA LETTER SMALL KU..KATAKANA LETTER SMALL RO
+32D0..32FE    ; Katakana # So  [47] CIRCLED KATAKANA A..CIRCLED KATAKANA WO
+3300..3357    ; Katakana # So  [88] SQUARE APAATO..SQUARE WATTO
+FF66..FF6F    ; Katakana # Lo  [10] HALFWIDTH KATAKANA LETTER WO..HALFWIDTH KATAKANA LETTER SMALL TU
+FF71..FF9D    ; Katakana # Lo  [45] HALFWIDTH KATAKANA LETTER A..HALFWIDTH KATAKANA LETTER N
+1AFF0..1AFF3  ; Katakana # Lm   [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5
+1AFF5..1AFFB  ; Katakana # Lm   [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5
+1AFFD..1AFFE  ; Katakana # Lm   [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8
+1B000         ; Katakana # Lo       KATAKANA LETTER ARCHAIC E
+1B120..1B122  ; Katakana # Lo   [3] KATAKANA LETTER ARCHAIC YI..KATAKANA LETTER ARCHAIC WU
+1B155         ; Katakana # Lo       KATAKANA LETTER SMALL KO
+1B164..1B167  ; Katakana # Lo   [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N
+
+# Total code points: 321
+
+# ================================================
+
+02EA..02EB    ; Bopomofo # Sk   [2] MODIFIER LETTER YIN DEPARTING TONE MARK..MODIFIER LETTER YANG DEPARTING TONE MARK
+3105..312F    ; Bopomofo # Lo  [43] BOPOMOFO LETTER B..BOPOMOFO LETTER NN
+31A0..31BF    ; Bopomofo # Lo  [32] BOPOMOFO LETTER BU..BOPOMOFO LETTER AH
+
+# Total code points: 77
+
+# ================================================
+
+2E80..2E99    ; Han # So  [26] CJK RADICAL REPEAT..CJK RADICAL RAP
+2E9B..2EF3    ; Han # So  [89] CJK RADICAL CHOKE..CJK RADICAL C-SIMPLIFIED TURTLE
+2F00..2FD5    ; Han # So [214] KANGXI RADICAL ONE..KANGXI RADICAL FLUTE
+3005          ; Han # Lm       IDEOGRAPHIC ITERATION MARK
+3007          ; Han # Nl       IDEOGRAPHIC NUMBER ZERO
+3021..3029    ; Han # Nl   [9] HANGZHOU NUMERAL ONE..HANGZHOU NUMERAL NINE
+3038..303A    ; Han # Nl   [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY
+303B          ; Han # Lm       VERTICAL IDEOGRAPHIC ITERATION MARK
+3400..4DBF    ; Han # Lo [6592] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-4DBF
+4E00..9FFF    ; Han # Lo [20992] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-9FFF
+F900..FA6D    ; Han # Lo [366] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA6D
+FA70..FAD9    ; Han # Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9
+16FE2         ; Han # Po       OLD CHINESE HOOK MARK
+16FE3         ; Han # Lm       OLD CHINESE ITERATION MARK
+16FF0..16FF1  ; Han # Mc   [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY
+16FF2..16FF3  ; Han # Lm   [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER
+16FF4..16FF6  ; Han # Nl   [3] YANGQIN SIGN SLOW ONE BEAT..YANGQIN SIGN SLOW TWO BEATS
+20000..2A6DF  ; Han # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF
+2A700..2B81D  ; Han # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D
+2B820..2CEAD  ; Han # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD
+2CEB0..2EBE0  ; Han # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0
+2EBF0..2EE5D  ; Han # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D
+2F800..2FA1D  ; Han # Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D
+30000..3134A  ; Han # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A
+31350..33479  ; Han # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479
+
+# Total code points: 103351
+
+# ================================================
+
+A000..A014    ; Yi # Lo  [21] YI SYLLABLE IT..YI SYLLABLE E
+A015          ; Yi # Lm       YI SYLLABLE WU
+A016..A48C    ; Yi # Lo [1143] YI SYLLABLE BIT..YI SYLLABLE YYR
+A490..A4C6    ; Yi # So  [55] YI RADICAL QOT..YI RADICAL KE
+
+# Total code points: 1220
+
+# ================================================
+
+10300..1031F  ; Old_Italic # Lo  [32] OLD ITALIC LETTER A..OLD ITALIC LETTER ESS
+10320..10323  ; Old_Italic # No   [4] OLD ITALIC NUMERAL ONE..OLD ITALIC NUMERAL FIFTY
+1032D..1032F  ; Old_Italic # Lo   [3] OLD ITALIC LETTER YE..OLD ITALIC LETTER SOUTHERN TSE
+
+# Total code points: 39
+
+# ================================================
+
+10330..10340  ; Gothic # Lo  [17] GOTHIC LETTER AHSA..GOTHIC LETTER PAIRTHRA
+10341         ; Gothic # Nl       GOTHIC LETTER NINETY
+10342..10349  ; Gothic # Lo   [8] GOTHIC LETTER RAIDA..GOTHIC LETTER OTHAL
+1034A         ; Gothic # Nl       GOTHIC LETTER NINE HUNDRED
+
+# Total code points: 27
+
+# ================================================
+
+10400..1044F  ; Deseret # L&  [80] DESERET CAPITAL LETTER LONG I..DESERET SMALL LETTER EW
+
+# Total code points: 80
+
+# ================================================
+
+0300..036F    ; Inherited # Mn [112] COMBINING GRAVE ACCENT..COMBINING LATIN SMALL LETTER X
+0485..0486    ; Inherited # Mn   [2] COMBINING CYRILLIC DASIA PNEUMATA..COMBINING CYRILLIC PSILI PNEUMATA
+064B..0655    ; Inherited # Mn  [11] ARABIC FATHATAN..ARABIC HAMZA BELOW
+0670          ; Inherited # Mn       ARABIC LETTER SUPERSCRIPT ALEF
+0951..0954    ; Inherited # Mn   [4] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI ACUTE ACCENT
+1AB0..1ABD    ; Inherited # Mn  [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW
+1ABE          ; Inherited # Me       COMBINING PARENTHESES OVERLAY
+1ABF..1ADD    ; Inherited # Mn  [31] COMBINING LATIN SMALL LETTER W BELOW..COMBINING DOT-AND-RING BELOW
+1AE0..1AEB    ; Inherited # Mn  [12] COMBINING LEFT TACK ABOVE..COMBINING DOUBLE RIGHTWARDS ARROW ABOVE
+1CD0..1CD2    ; Inherited # Mn   [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA
+1CD4..1CE0    ; Inherited # Mn  [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA
+1CE2..1CE8    ; Inherited # Mn   [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL
+1CED          ; Inherited # Mn       VEDIC SIGN TIRYAK
+1CF4          ; Inherited # Mn       VEDIC TONE CANDRA ABOVE
+1CF8..1CF9    ; Inherited # Mn   [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE
+1DC0..1DFF    ; Inherited # Mn  [64] COMBINING DOTTED GRAVE ACCENT..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW
+200C..200D    ; Inherited # Cf   [2] ZERO WIDTH NON-JOINER..ZERO WIDTH JOINER
+20D0..20DC    ; Inherited # Mn  [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE
+20DD..20E0    ; Inherited # Me   [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH
+20E1          ; Inherited # Mn       COMBINING LEFT RIGHT ARROW ABOVE
+20E2..20E4    ; Inherited # Me   [3] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING UPWARD POINTING TRIANGLE
+20E5..20F0    ; Inherited # Mn  [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE
+302A..302D    ; Inherited # Mn   [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK
+3099..309A    ; Inherited # Mn   [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+FE00..FE0F    ; Inherited # Mn  [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16
+FE20..FE2D    ; Inherited # Mn  [14] COMBINING LIGATURE LEFT HALF..COMBINING CONJOINING MACRON BELOW
+101FD         ; Inherited # Mn       PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE
+102E0         ; Inherited # Mn       COPTIC EPACT THOUSANDS MARK
+1133B         ; Inherited # Mn       COMBINING BINDU BELOW
+1CF00..1CF2D  ; Inherited # Mn  [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT
+1CF30..1CF46  ; Inherited # Mn  [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG
+1D167..1D169  ; Inherited # Mn   [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3
+1D17B..1D182  ; Inherited # Mn   [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE
+1D185..1D18B  ; Inherited # Mn   [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE
+1D1AA..1D1AD  ; Inherited # Mn   [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO
+E0100..E01EF  ; Inherited # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256
+
+# Total code points: 684
+
+# ================================================
+
+1700..1711    ; Tagalog # Lo  [18] TAGALOG LETTER A..TAGALOG LETTER HA
+1712..1714    ; Tagalog # Mn   [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN VIRAMA
+1715          ; Tagalog # Mc       TAGALOG SIGN PAMUDPOD
+171F          ; Tagalog # Lo       TAGALOG LETTER ARCHAIC RA
+
+# Total code points: 23
+
+# ================================================
+
+1720..1731    ; Hanunoo # Lo  [18] HANUNOO LETTER A..HANUNOO LETTER HA
+1732..1733    ; Hanunoo # Mn   [2] HANUNOO VOWEL SIGN I..HANUNOO VOWEL SIGN U
+1734          ; Hanunoo # Mc       HANUNOO SIGN PAMUDPOD
+
+# Total code points: 21
+
+# ================================================
+
+1740..1751    ; Buhid # Lo  [18] BUHID LETTER A..BUHID LETTER HA
+1752..1753    ; Buhid # Mn   [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U
+
+# Total code points: 20
+
+# ================================================
+
+1760..176C    ; Tagbanwa # Lo  [13] TAGBANWA LETTER A..TAGBANWA LETTER YA
+176E..1770    ; Tagbanwa # Lo   [3] TAGBANWA LETTER LA..TAGBANWA LETTER SA
+1772..1773    ; Tagbanwa # Mn   [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U
+
+# Total code points: 18
+
+# ================================================
+
+1900..191E    ; Limbu # Lo  [31] LIMBU VOWEL-CARRIER LETTER..LIMBU LETTER TRA
+1920..1922    ; Limbu # Mn   [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U
+1923..1926    ; Limbu # Mc   [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU
+1927..1928    ; Limbu # Mn   [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O
+1929..192B    ; Limbu # Mc   [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA
+1930..1931    ; Limbu # Mc   [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA
+1932          ; Limbu # Mn       LIMBU SMALL LETTER ANUSVARA
+1933..1938    ; Limbu # Mc   [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA
+1939..193B    ; Limbu # Mn   [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I
+1940          ; Limbu # So       LIMBU SIGN LOO
+1944..1945    ; Limbu # Po   [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK
+1946..194F    ; Limbu # Nd  [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE
+
+# Total code points: 68
+
+# ================================================
+
+1950..196D    ; Tai_Le # Lo  [30] TAI LE LETTER KA..TAI LE LETTER AI
+1970..1974    ; Tai_Le # Lo   [5] TAI LE LETTER TONE-2..TAI LE LETTER TONE-6
+
+# Total code points: 35
+
+# ================================================
+
+10000..1000B  ; Linear_B # Lo  [12] LINEAR B SYLLABLE B008 A..LINEAR B SYLLABLE B046 JE
+1000D..10026  ; Linear_B # Lo  [26] LINEAR B SYLLABLE B036 JO..LINEAR B SYLLABLE B032 QO
+10028..1003A  ; Linear_B # Lo  [19] LINEAR B SYLLABLE B060 RA..LINEAR B SYLLABLE B042 WO
+1003C..1003D  ; Linear_B # Lo   [2] LINEAR B SYLLABLE B017 ZA..LINEAR B SYLLABLE B074 ZE
+1003F..1004D  ; Linear_B # Lo  [15] LINEAR B SYLLABLE B020 ZO..LINEAR B SYLLABLE B091 TWO
+10050..1005D  ; Linear_B # Lo  [14] LINEAR B SYMBOL B018..LINEAR B SYMBOL B089
+10080..100FA  ; Linear_B # Lo [123] LINEAR B IDEOGRAM B100 MAN..LINEAR B IDEOGRAM VESSEL B305
+
+# Total code points: 211
+
+# ================================================
+
+10380..1039D  ; Ugaritic # Lo  [30] UGARITIC LETTER ALPA..UGARITIC LETTER SSU
+1039F         ; Ugaritic # Po       UGARITIC WORD DIVIDER
+
+# Total code points: 31
+
+# ================================================
+
+10450..1047F  ; Shavian # Lo  [48] SHAVIAN LETTER PEEP..SHAVIAN LETTER YEW
+
+# Total code points: 48
+
+# ================================================
+
+10480..1049D  ; Osmanya # Lo  [30] OSMANYA LETTER ALEF..OSMANYA LETTER OO
+104A0..104A9  ; Osmanya # Nd  [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE
+
+# Total code points: 40
+
+# ================================================
+
+10800..10805  ; Cypriot # Lo   [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA
+10808         ; Cypriot # Lo       CYPRIOT SYLLABLE JO
+1080A..10835  ; Cypriot # Lo  [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO
+10837..10838  ; Cypriot # Lo   [2] CYPRIOT SYLLABLE XA..CYPRIOT SYLLABLE XE
+1083C         ; Cypriot # Lo       CYPRIOT SYLLABLE ZA
+1083F         ; Cypriot # Lo       CYPRIOT SYLLABLE ZO
+
+# Total code points: 55
+
+# ================================================
+
+2800..28FF    ; Braille # So [256] BRAILLE PATTERN BLANK..BRAILLE PATTERN DOTS-12345678
+
+# Total code points: 256
+
+# ================================================
+
+1A00..1A16    ; Buginese # Lo  [23] BUGINESE LETTER KA..BUGINESE LETTER HA
+1A17..1A18    ; Buginese # Mn   [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U
+1A19..1A1A    ; Buginese # Mc   [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O
+1A1B          ; Buginese # Mn       BUGINESE VOWEL SIGN AE
+1A1E..1A1F    ; Buginese # Po   [2] BUGINESE PALLAWA..BUGINESE END OF SECTION
+
+# Total code points: 30
+
+# ================================================
+
+03E2..03EF    ; Coptic # L&  [14] COPTIC CAPITAL LETTER SHEI..COPTIC SMALL LETTER DEI
+2C80..2CE4    ; Coptic # L& [101] COPTIC CAPITAL LETTER ALFA..COPTIC SYMBOL KAI
+2CE5..2CEA    ; Coptic # So   [6] COPTIC SYMBOL MI RO..COPTIC SYMBOL SHIMA SIMA
+2CEB..2CEE    ; Coptic # L&   [4] COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI..COPTIC SMALL LETTER CRYPTOGRAMMIC GANGIA
+2CEF..2CF1    ; Coptic # Mn   [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS
+2CF2..2CF3    ; Coptic # L&   [2] COPTIC CAPITAL LETTER BOHAIRIC KHEI..COPTIC SMALL LETTER BOHAIRIC KHEI
+2CF9..2CFC    ; Coptic # Po   [4] COPTIC OLD NUBIAN FULL STOP..COPTIC OLD NUBIAN VERSE DIVIDER
+2CFD          ; Coptic # No       COPTIC FRACTION ONE HALF
+2CFE..2CFF    ; Coptic # Po   [2] COPTIC FULL STOP..COPTIC MORPHOLOGICAL DIVIDER
+
+# Total code points: 137
+
+# ================================================
+
+1980..19AB    ; New_Tai_Lue # Lo  [44] NEW TAI LUE LETTER HIGH QA..NEW TAI LUE LETTER LOW SUA
+19B0..19C9    ; New_Tai_Lue # Lo  [26] NEW TAI LUE VOWEL SIGN VOWEL SHORTENER..NEW TAI LUE TONE MARK-2
+19D0..19D9    ; New_Tai_Lue # Nd  [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE
+19DA          ; New_Tai_Lue # No       NEW TAI LUE THAM DIGIT ONE
+19DE..19DF    ; New_Tai_Lue # So   [2] NEW TAI LUE SIGN LAE..NEW TAI LUE SIGN LAEV
+
+# Total code points: 83
+
+# ================================================
+
+2C00..2C5F    ; Glagolitic # L&  [96] GLAGOLITIC CAPITAL LETTER AZU..GLAGOLITIC SMALL LETTER CAUDATE CHRIVI
+1E000..1E006  ; Glagolitic # Mn   [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE
+1E008..1E018  ; Glagolitic # Mn  [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU
+1E01B..1E021  ; Glagolitic # Mn   [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI
+1E023..1E024  ; Glagolitic # Mn   [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS
+1E026..1E02A  ; Glagolitic # Mn   [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA
+
+# Total code points: 134
+
+# ================================================
+
+2D30..2D67    ; Tifinagh # Lo  [56] TIFINAGH LETTER YA..TIFINAGH LETTER YO
+2D6F          ; Tifinagh # Lm       TIFINAGH MODIFIER LETTER LABIALIZATION MARK
+2D70          ; Tifinagh # Po       TIFINAGH SEPARATOR MARK
+2D7F          ; Tifinagh # Mn       TIFINAGH CONSONANT JOINER
+
+# Total code points: 59
+
+# ================================================
+
+A800..A801    ; Syloti_Nagri # Lo   [2] SYLOTI NAGRI LETTER A..SYLOTI NAGRI LETTER I
+A802          ; Syloti_Nagri # Mn       SYLOTI NAGRI SIGN DVISVARA
+A803..A805    ; Syloti_Nagri # Lo   [3] SYLOTI NAGRI LETTER U..SYLOTI NAGRI LETTER O
+A806          ; Syloti_Nagri # Mn       SYLOTI NAGRI SIGN HASANTA
+A807..A80A    ; Syloti_Nagri # Lo   [4] SYLOTI NAGRI LETTER KO..SYLOTI NAGRI LETTER GHO
+A80B          ; Syloti_Nagri # Mn       SYLOTI NAGRI SIGN ANUSVARA
+A80C..A822    ; Syloti_Nagri # Lo  [23] SYLOTI NAGRI LETTER CO..SYLOTI NAGRI LETTER HO
+A823..A824    ; Syloti_Nagri # Mc   [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I
+A825..A826    ; Syloti_Nagri # Mn   [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E
+A827          ; Syloti_Nagri # Mc       SYLOTI NAGRI VOWEL SIGN OO
+A828..A82B    ; Syloti_Nagri # So   [4] SYLOTI NAGRI POETRY MARK-1..SYLOTI NAGRI POETRY MARK-4
+A82C          ; Syloti_Nagri # Mn       SYLOTI NAGRI SIGN ALTERNATE HASANTA
+
+# Total code points: 45
+
+# ================================================
+
+103A0..103C3  ; Old_Persian # Lo  [36] OLD PERSIAN SIGN A..OLD PERSIAN SIGN HA
+103C8..103CF  ; Old_Persian # Lo   [8] OLD PERSIAN SIGN AURAMAZDAA..OLD PERSIAN SIGN BUUMISH
+103D0         ; Old_Persian # Po       OLD PERSIAN WORD DIVIDER
+103D1..103D5  ; Old_Persian # Nl   [5] OLD PERSIAN NUMBER ONE..OLD PERSIAN NUMBER HUNDRED
+
+# Total code points: 50
+
+# ================================================
+
+10A00         ; Kharoshthi # Lo       KHAROSHTHI LETTER A
+10A01..10A03  ; Kharoshthi # Mn   [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R
+10A05..10A06  ; Kharoshthi # Mn   [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O
+10A0C..10A0F  ; Kharoshthi # Mn   [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA
+10A10..10A13  ; Kharoshthi # Lo   [4] KHAROSHTHI LETTER KA..KHAROSHTHI LETTER GHA
+10A15..10A17  ; Kharoshthi # Lo   [3] KHAROSHTHI LETTER CA..KHAROSHTHI LETTER JA
+10A19..10A35  ; Kharoshthi # Lo  [29] KHAROSHTHI LETTER NYA..KHAROSHTHI LETTER VHA
+10A38..10A3A  ; Kharoshthi # Mn   [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW
+10A3F         ; Kharoshthi # Mn       KHAROSHTHI VIRAMA
+10A40..10A48  ; Kharoshthi # No   [9] KHAROSHTHI DIGIT ONE..KHAROSHTHI FRACTION ONE HALF
+10A50..10A58  ; Kharoshthi # Po   [9] KHAROSHTHI PUNCTUATION DOT..KHAROSHTHI PUNCTUATION LINES
+
+# Total code points: 68
+
+# ================================================
+
+1B00..1B03    ; Balinese # Mn   [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG
+1B04          ; Balinese # Mc       BALINESE SIGN BISAH
+1B05..1B33    ; Balinese # Lo  [47] BALINESE LETTER AKARA..BALINESE LETTER HA
+1B34          ; Balinese # Mn       BALINESE SIGN REREKAN
+1B35          ; Balinese # Mc       BALINESE VOWEL SIGN TEDUNG
+1B36..1B3A    ; Balinese # Mn   [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA
+1B3B          ; Balinese # Mc       BALINESE VOWEL SIGN RA REPA TEDUNG
+1B3C          ; Balinese # Mn       BALINESE VOWEL SIGN LA LENGA
+1B3D..1B41    ; Balinese # Mc   [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG
+1B42          ; Balinese # Mn       BALINESE VOWEL SIGN PEPET
+1B43..1B44    ; Balinese # Mc   [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG
+1B45..1B4C    ; Balinese # Lo   [8] BALINESE LETTER KAF SASAK..BALINESE LETTER ARCHAIC JNYA
+1B4E..1B4F    ; Balinese # Po   [2] BALINESE INVERTED CARIK SIKI..BALINESE INVERTED CARIK PAREREN
+1B50..1B59    ; Balinese # Nd  [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE
+1B5A..1B60    ; Balinese # Po   [7] BALINESE PANTI..BALINESE PAMENENG
+1B61..1B6A    ; Balinese # So  [10] BALINESE MUSICAL SYMBOL DONG..BALINESE MUSICAL SYMBOL DANG GEDE
+1B6B..1B73    ; Balinese # Mn   [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG
+1B74..1B7C    ; Balinese # So   [9] BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DUG..BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PING
+1B7D..1B7F    ; Balinese # Po   [3] BALINESE PANTI LANTANG..BALINESE PANTI BAWAK
+
+# Total code points: 127
+
+# ================================================
+
+12000..12399  ; Cuneiform # Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U
+12400..1246E  ; Cuneiform # Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM
+12470..12474  ; Cuneiform # Po   [5] CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER..CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON
+12480..12543  ; Cuneiform # Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU
+
+# Total code points: 1234
+
+# ================================================
+
+10900..10915  ; Phoenician # Lo  [22] PHOENICIAN LETTER ALF..PHOENICIAN LETTER TAU
+10916..1091B  ; Phoenician # No   [6] PHOENICIAN NUMBER ONE..PHOENICIAN NUMBER THREE
+1091F         ; Phoenician # Po       PHOENICIAN WORD SEPARATOR
+
+# Total code points: 29
+
+# ================================================
+
+A840..A873    ; Phags_Pa # Lo  [52] PHAGS-PA LETTER KA..PHAGS-PA LETTER CANDRABINDU
+A874..A877    ; Phags_Pa # Po   [4] PHAGS-PA SINGLE HEAD MARK..PHAGS-PA MARK DOUBLE SHAD
+
+# Total code points: 56
+
+# ================================================
+
+07C0..07C9    ; Nko # Nd  [10] NKO DIGIT ZERO..NKO DIGIT NINE
+07CA..07EA    ; Nko # Lo  [33] NKO LETTER A..NKO LETTER JONA RA
+07EB..07F3    ; Nko # Mn   [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE
+07F4..07F5    ; Nko # Lm   [2] NKO HIGH TONE APOSTROPHE..NKO LOW TONE APOSTROPHE
+07F6          ; Nko # So       NKO SYMBOL OO DENNEN
+07F7..07F9    ; Nko # Po   [3] NKO SYMBOL GBAKURUNEN..NKO EXCLAMATION MARK
+07FA          ; Nko # Lm       NKO LAJANYALAN
+07FD          ; Nko # Mn       NKO DANTAYALAN
+07FE..07FF    ; Nko # Sc   [2] NKO DOROME SIGN..NKO TAMAN SIGN
+
+# Total code points: 62
+
+# ================================================
+
+1B80..1B81    ; Sundanese # Mn   [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR
+1B82          ; Sundanese # Mc       SUNDANESE SIGN PANGWISAD
+1B83..1BA0    ; Sundanese # Lo  [30] SUNDANESE LETTER A..SUNDANESE LETTER HA
+1BA1          ; Sundanese # Mc       SUNDANESE CONSONANT SIGN PAMINGKAL
+1BA2..1BA5    ; Sundanese # Mn   [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU
+1BA6..1BA7    ; Sundanese # Mc   [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG
+1BA8..1BA9    ; Sundanese # Mn   [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG
+1BAA          ; Sundanese # Mc       SUNDANESE SIGN PAMAAEH
+1BAB..1BAD    ; Sundanese # Mn   [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA
+1BAE..1BAF    ; Sundanese # Lo   [2] SUNDANESE LETTER KHA..SUNDANESE LETTER SYA
+1BB0..1BB9    ; Sundanese # Nd  [10] SUNDANESE DIGIT ZERO..SUNDANESE DIGIT NINE
+1BBA..1BBF    ; Sundanese # Lo   [6] SUNDANESE AVAGRAHA..SUNDANESE LETTER FINAL M
+1CC0..1CC7    ; Sundanese # Po   [8] SUNDANESE PUNCTUATION BINDU SURYA..SUNDANESE PUNCTUATION BINDU BA SATANGA
+
+# Total code points: 72
+
+# ================================================
+
+1C00..1C23    ; Lepcha # Lo  [36] LEPCHA LETTER KA..LEPCHA LETTER A
+1C24..1C2B    ; Lepcha # Mc   [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU
+1C2C..1C33    ; Lepcha # Mn   [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T
+1C34..1C35    ; Lepcha # Mc   [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG
+1C36..1C37    ; Lepcha # Mn   [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA
+1C3B..1C3F    ; Lepcha # Po   [5] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION TSHOOK
+1C40..1C49    ; Lepcha # Nd  [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE
+1C4D..1C4F    ; Lepcha # Lo   [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA
+
+# Total code points: 74
+
+# ================================================
+
+1C50..1C59    ; Ol_Chiki # Nd  [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGIT NINE
+1C5A..1C77    ; Ol_Chiki # Lo  [30] OL CHIKI LETTER LA..OL CHIKI LETTER OH
+1C78..1C7D    ; Ol_Chiki # Lm   [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD
+1C7E..1C7F    ; Ol_Chiki # Po   [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD
+
+# Total code points: 48
+
+# ================================================
+
+A500..A60B    ; Vai # Lo [268] VAI SYLLABLE EE..VAI SYLLABLE NG
+A60C          ; Vai # Lm       VAI SYLLABLE LENGTHENER
+A60D..A60F    ; Vai # Po   [3] VAI COMMA..VAI QUESTION MARK
+A610..A61F    ; Vai # Lo  [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL JONG
+A620..A629    ; Vai # Nd  [10] VAI DIGIT ZERO..VAI DIGIT NINE
+A62A..A62B    ; Vai # Lo   [2] VAI SYLLABLE NDOLE MA..VAI SYLLABLE NDOLE DO
+
+# Total code points: 300
+
+# ================================================
+
+A880..A881    ; Saurashtra # Mc   [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA
+A882..A8B3    ; Saurashtra # Lo  [50] SAURASHTRA LETTER A..SAURASHTRA LETTER LLA
+A8B4..A8C3    ; Saurashtra # Mc  [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU
+A8C4..A8C5    ; Saurashtra # Mn   [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA SIGN CANDRABINDU
+A8CE..A8CF    ; Saurashtra # Po   [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA
+A8D0..A8D9    ; Saurashtra # Nd  [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE
+
+# Total code points: 82
+
+# ================================================
+
+A900..A909    ; Kayah_Li # Nd  [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGIT NINE
+A90A..A925    ; Kayah_Li # Lo  [28] KAYAH LI LETTER KA..KAYAH LI LETTER OO
+A926..A92D    ; Kayah_Li # Mn   [8] KAYAH LI VOWEL UE..KAYAH LI TONE CALYA PLOPHU
+A92F          ; Kayah_Li # Po       KAYAH LI SIGN SHYA
+
+# Total code points: 47
+
+# ================================================
+
+A930..A946    ; Rejang # Lo  [23] REJANG LETTER KA..REJANG LETTER A
+A947..A951    ; Rejang # Mn  [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R
+A952..A953    ; Rejang # Mc   [2] REJANG CONSONANT SIGN H..REJANG VIRAMA
+A95F          ; Rejang # Po       REJANG SECTION MARK
+
+# Total code points: 37
+
+# ================================================
+
+10280..1029C  ; Lycian # Lo  [29] LYCIAN LETTER A..LYCIAN LETTER X
+
+# Total code points: 29
+
+# ================================================
+
+102A0..102D0  ; Carian # Lo  [49] CARIAN LETTER A..CARIAN LETTER UUU3
+
+# Total code points: 49
+
+# ================================================
+
+10920..10939  ; Lydian # Lo  [26] LYDIAN LETTER A..LYDIAN LETTER C
+1093F         ; Lydian # Po       LYDIAN TRIANGULAR MARK
+
+# Total code points: 27
+
+# ================================================
+
+AA00..AA28    ; Cham # Lo  [41] CHAM LETTER A..CHAM LETTER HA
+AA29..AA2E    ; Cham # Mn   [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE
+AA2F..AA30    ; Cham # Mc   [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI
+AA31..AA32    ; Cham # Mn   [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE
+AA33..AA34    ; Cham # Mc   [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA
+AA35..AA36    ; Cham # Mn   [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA
+AA40..AA42    ; Cham # Lo   [3] CHAM LETTER FINAL K..CHAM LETTER FINAL NG
+AA43          ; Cham # Mn       CHAM CONSONANT SIGN FINAL NG
+AA44..AA4B    ; Cham # Lo   [8] CHAM LETTER FINAL CH..CHAM LETTER FINAL SS
+AA4C          ; Cham # Mn       CHAM CONSONANT SIGN FINAL M
+AA4D          ; Cham # Mc       CHAM CONSONANT SIGN FINAL H
+AA50..AA59    ; Cham # Nd  [10] CHAM DIGIT ZERO..CHAM DIGIT NINE
+AA5C..AA5F    ; Cham # Po   [4] CHAM PUNCTUATION SPIRAL..CHAM PUNCTUATION TRIPLE DANDA
+
+# Total code points: 83
+
+# ================================================
+
+1A20..1A54    ; Tai_Tham # Lo  [53] TAI THAM LETTER HIGH KA..TAI THAM LETTER GREAT SA
+1A55          ; Tai_Tham # Mc       TAI THAM CONSONANT SIGN MEDIAL RA
+1A56          ; Tai_Tham # Mn       TAI THAM CONSONANT SIGN MEDIAL LA
+1A57          ; Tai_Tham # Mc       TAI THAM CONSONANT SIGN LA TANG LAI
+1A58..1A5E    ; Tai_Tham # Mn   [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA
+1A60          ; Tai_Tham # Mn       TAI THAM SIGN SAKOT
+1A61          ; Tai_Tham # Mc       TAI THAM VOWEL SIGN A
+1A62          ; Tai_Tham # Mn       TAI THAM VOWEL SIGN MAI SAT
+1A63..1A64    ; Tai_Tham # Mc   [2] TAI THAM VOWEL SIGN AA..TAI THAM VOWEL SIGN TALL AA
+1A65..1A6C    ; Tai_Tham # Mn   [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW
+1A6D..1A72    ; Tai_Tham # Mc   [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI
+1A73..1A7C    ; Tai_Tham # Mn  [10] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN KHUEN-LUE KARAN
+1A7F          ; Tai_Tham # Mn       TAI THAM COMBINING CRYPTOGRAMMIC DOT
+1A80..1A89    ; Tai_Tham # Nd  [10] TAI THAM HORA DIGIT ZERO..TAI THAM HORA DIGIT NINE
+1A90..1A99    ; Tai_Tham # Nd  [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE
+1AA0..1AA6    ; Tai_Tham # Po   [7] TAI THAM SIGN WIANG..TAI THAM SIGN REVERSED ROTATED RANA
+1AA7          ; Tai_Tham # Lm       TAI THAM SIGN MAI YAMOK
+1AA8..1AAD    ; Tai_Tham # Po   [6] TAI THAM SIGN KAAN..TAI THAM SIGN CAANG
+
+# Total code points: 127
+
+# ================================================
+
+AA80..AAAF    ; Tai_Viet # Lo  [48] TAI VIET LETTER LOW KO..TAI VIET LETTER HIGH O
+AAB0          ; Tai_Viet # Mn       TAI VIET MAI KANG
+AAB1          ; Tai_Viet # Lo       TAI VIET VOWEL AA
+AAB2..AAB4    ; Tai_Viet # Mn   [3] TAI VIET VOWEL I..TAI VIET VOWEL U
+AAB5..AAB6    ; Tai_Viet # Lo   [2] TAI VIET VOWEL E..TAI VIET VOWEL O
+AAB7..AAB8    ; Tai_Viet # Mn   [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA
+AAB9..AABD    ; Tai_Viet # Lo   [5] TAI VIET VOWEL UEA..TAI VIET VOWEL AN
+AABE..AABF    ; Tai_Viet # Mn   [2] TAI VIET VOWEL AM..TAI VIET TONE MAI EK
+AAC0          ; Tai_Viet # Lo       TAI VIET TONE MAI NUENG
+AAC1          ; Tai_Viet # Mn       TAI VIET TONE MAI THO
+AAC2          ; Tai_Viet # Lo       TAI VIET TONE MAI SONG
+AADB..AADC    ; Tai_Viet # Lo   [2] TAI VIET SYMBOL KON..TAI VIET SYMBOL NUENG
+AADD          ; Tai_Viet # Lm       TAI VIET SYMBOL SAM
+AADE..AADF    ; Tai_Viet # Po   [2] TAI VIET SYMBOL HO HOI..TAI VIET SYMBOL KOI KOI
+
+# Total code points: 72
+
+# ================================================
+
+10B00..10B35  ; Avestan # Lo  [54] AVESTAN LETTER A..AVESTAN LETTER HE
+10B39..10B3F  ; Avestan # Po   [7] AVESTAN ABBREVIATION MARK..LARGE ONE RING OVER TWO RINGS PUNCTUATION
+
+# Total code points: 61
+
+# ================================================
+
+13000..1342F  ; Egyptian_Hieroglyphs # Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D
+13430..1343F  ; Egyptian_Hieroglyphs # Cf  [16] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE
+13440         ; Egyptian_Hieroglyphs # Mn       EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY
+13441..13446  ; Egyptian_Hieroglyphs # Lo   [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN
+13447..13455  ; Egyptian_Hieroglyphs # Mn  [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED
+13460..143FA  ; Egyptian_Hieroglyphs # Lo [3995] EGYPTIAN HIEROGLYPH-13460..EGYPTIAN HIEROGLYPH-143FA
+
+# Total code points: 5105
+
+# ================================================
+
+0800..0815    ; Samaritan # Lo  [22] SAMARITAN LETTER ALAF..SAMARITAN LETTER TAAF
+0816..0819    ; Samaritan # Mn   [4] SAMARITAN MARK IN..SAMARITAN MARK DAGESH
+081A          ; Samaritan # Lm       SAMARITAN MODIFIER LETTER EPENTHETIC YUT
+081B..0823    ; Samaritan # Mn   [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A
+0824          ; Samaritan # Lm       SAMARITAN MODIFIER LETTER SHORT A
+0825..0827    ; Samaritan # Mn   [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U
+0828          ; Samaritan # Lm       SAMARITAN MODIFIER LETTER I
+0829..082D    ; Samaritan # Mn   [5] SAMARITAN VOWEL SIGN LONG I..SAMARITAN MARK NEQUDAA
+0830..083E    ; Samaritan # Po  [15] SAMARITAN PUNCTUATION NEQUDAA..SAMARITAN PUNCTUATION ANNAAU
+
+# Total code points: 61
+
+# ================================================
+
+A4D0..A4F7    ; Lisu # Lo  [40] LISU LETTER BA..LISU LETTER OE
+A4F8..A4FD    ; Lisu # Lm   [6] LISU LETTER TONE MYA TI..LISU LETTER TONE MYA JEU
+A4FE..A4FF    ; Lisu # Po   [2] LISU PUNCTUATION COMMA..LISU PUNCTUATION FULL STOP
+11FB0         ; Lisu # Lo       LISU LETTER YHA
+
+# Total code points: 49
+
+# ================================================
+
+A6A0..A6E5    ; Bamum # Lo  [70] BAMUM LETTER A..BAMUM LETTER KI
+A6E6..A6EF    ; Bamum # Nl  [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM
+A6F0..A6F1    ; Bamum # Mn   [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS
+A6F2..A6F7    ; Bamum # Po   [6] BAMUM NJAEMLI..BAMUM QUESTION MARK
+16800..16A38  ; Bamum # Lo [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ
+
+# Total code points: 657
+
+# ================================================
+
+A980..A982    ; Javanese # Mn   [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR
+A983          ; Javanese # Mc       JAVANESE SIGN WIGNYAN
+A984..A9B2    ; Javanese # Lo  [47] JAVANESE LETTER A..JAVANESE LETTER HA
+A9B3          ; Javanese # Mn       JAVANESE SIGN CECAK TELU
+A9B4..A9B5    ; Javanese # Mc   [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG
+A9B6..A9B9    ; Javanese # Mn   [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT
+A9BA..A9BB    ; Javanese # Mc   [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE
+A9BC..A9BD    ; Javanese # Mn   [2] JAVANESE VOWEL SIGN PEPET..JAVANESE CONSONANT SIGN KERET
+A9BE..A9C0    ; Javanese # Mc   [3] JAVANESE CONSONANT SIGN PENGKAL..JAVANESE PANGKON
+A9C1..A9CD    ; Javanese # Po  [13] JAVANESE LEFT RERENGGAN..JAVANESE TURNED PADA PISELEH
+A9D0..A9D9    ; Javanese # Nd  [10] JAVANESE DIGIT ZERO..JAVANESE DIGIT NINE
+A9DE..A9DF    ; Javanese # Po   [2] JAVANESE PADA TIRTA TUMETES..JAVANESE PADA ISEN-ISEN
+
+# Total code points: 90
+
+# ================================================
+
+AAE0..AAEA    ; Meetei_Mayek # Lo  [11] MEETEI MAYEK LETTER E..MEETEI MAYEK LETTER SSA
+AAEB          ; Meetei_Mayek # Mc       MEETEI MAYEK VOWEL SIGN II
+AAEC..AAED    ; Meetei_Mayek # Mn   [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI
+AAEE..AAEF    ; Meetei_Mayek # Mc   [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU
+AAF0..AAF1    ; Meetei_Mayek # Po   [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM
+AAF2          ; Meetei_Mayek # Lo       MEETEI MAYEK ANJI
+AAF3..AAF4    ; Meetei_Mayek # Lm   [2] MEETEI MAYEK SYLLABLE REPETITION MARK..MEETEI MAYEK WORD REPETITION MARK
+AAF5          ; Meetei_Mayek # Mc       MEETEI MAYEK VOWEL SIGN VISARGA
+AAF6          ; Meetei_Mayek # Mn       MEETEI MAYEK VIRAMA
+ABC0..ABE2    ; Meetei_Mayek # Lo  [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM
+ABE3..ABE4    ; Meetei_Mayek # Mc   [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP
+ABE5          ; Meetei_Mayek # Mn       MEETEI MAYEK VOWEL SIGN ANAP
+ABE6..ABE7    ; Meetei_Mayek # Mc   [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP
+ABE8          ; Meetei_Mayek # Mn       MEETEI MAYEK VOWEL SIGN UNAP
+ABE9..ABEA    ; Meetei_Mayek # Mc   [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG
+ABEB          ; Meetei_Mayek # Po       MEETEI MAYEK CHEIKHEI
+ABEC          ; Meetei_Mayek # Mc       MEETEI MAYEK LUM IYEK
+ABED          ; Meetei_Mayek # Mn       MEETEI MAYEK APUN IYEK
+ABF0..ABF9    ; Meetei_Mayek # Nd  [10] MEETEI MAYEK DIGIT ZERO..MEETEI MAYEK DIGIT NINE
+
+# Total code points: 79
+
+# ================================================
+
+10840..10855  ; Imperial_Aramaic # Lo  [22] IMPERIAL ARAMAIC LETTER ALEPH..IMPERIAL ARAMAIC LETTER TAW
+10857         ; Imperial_Aramaic # Po       IMPERIAL ARAMAIC SECTION SIGN
+10858..1085F  ; Imperial_Aramaic # No   [8] IMPERIAL ARAMAIC NUMBER ONE..IMPERIAL ARAMAIC NUMBER TEN THOUSAND
+
+# Total code points: 31
+
+# ================================================
+
+10A60..10A7C  ; Old_South_Arabian # Lo  [29] OLD SOUTH ARABIAN LETTER HE..OLD SOUTH ARABIAN LETTER THETH
+10A7D..10A7E  ; Old_South_Arabian # No   [2] OLD SOUTH ARABIAN NUMBER ONE..OLD SOUTH ARABIAN NUMBER FIFTY
+10A7F         ; Old_South_Arabian # Po       OLD SOUTH ARABIAN NUMERIC INDICATOR
+
+# Total code points: 32
+
+# ================================================
+
+10B40..10B55  ; Inscriptional_Parthian # Lo  [22] INSCRIPTIONAL PARTHIAN LETTER ALEPH..INSCRIPTIONAL PARTHIAN LETTER TAW
+10B58..10B5F  ; Inscriptional_Parthian # No   [8] INSCRIPTIONAL PARTHIAN NUMBER ONE..INSCRIPTIONAL PARTHIAN NUMBER ONE THOUSAND
+
+# Total code points: 30
+
+# ================================================
+
+10B60..10B72  ; Inscriptional_Pahlavi # Lo  [19] INSCRIPTIONAL PAHLAVI LETTER ALEPH..INSCRIPTIONAL PAHLAVI LETTER TAW
+10B78..10B7F  ; Inscriptional_Pahlavi # No   [8] INSCRIPTIONAL PAHLAVI NUMBER ONE..INSCRIPTIONAL PAHLAVI NUMBER ONE THOUSAND
+
+# Total code points: 27
+
+# ================================================
+
+10C00..10C48  ; Old_Turkic # Lo  [73] OLD TURKIC LETTER ORKHON A..OLD TURKIC LETTER ORKHON BASH
+
+# Total code points: 73
+
+# ================================================
+
+11080..11081  ; Kaithi # Mn   [2] KAITHI SIGN CANDRABINDU..KAITHI SIGN ANUSVARA
+11082         ; Kaithi # Mc       KAITHI SIGN VISARGA
+11083..110AF  ; Kaithi # Lo  [45] KAITHI LETTER A..KAITHI LETTER HA
+110B0..110B2  ; Kaithi # Mc   [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II
+110B3..110B6  ; Kaithi # Mn   [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI
+110B7..110B8  ; Kaithi # Mc   [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU
+110B9..110BA  ; Kaithi # Mn   [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA
+110BB..110BC  ; Kaithi # Po   [2] KAITHI ABBREVIATION SIGN..KAITHI ENUMERATION SIGN
+110BD         ; Kaithi # Cf       KAITHI NUMBER SIGN
+110BE..110C1  ; Kaithi # Po   [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA
+110C2         ; Kaithi # Mn       KAITHI VOWEL SIGN VOCALIC R
+110CD         ; Kaithi # Cf       KAITHI NUMBER SIGN ABOVE
+
+# Total code points: 68
+
+# ================================================
+
+1BC0..1BE5    ; Batak # Lo  [38] BATAK LETTER A..BATAK LETTER U
+1BE6          ; Batak # Mn       BATAK SIGN TOMPI
+1BE7          ; Batak # Mc       BATAK VOWEL SIGN E
+1BE8..1BE9    ; Batak # Mn   [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE
+1BEA..1BEC    ; Batak # Mc   [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O
+1BED          ; Batak # Mn       BATAK VOWEL SIGN KARO O
+1BEE          ; Batak # Mc       BATAK VOWEL SIGN U
+1BEF..1BF1    ; Batak # Mn   [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H
+1BF2..1BF3    ; Batak # Mc   [2] BATAK PANGOLAT..BATAK PANONGONAN
+1BFC..1BFF    ; Batak # Po   [4] BATAK SYMBOL BINDU NA METEK..BATAK SYMBOL BINDU PANGOLAT
+
+# Total code points: 56
+
+# ================================================
+
+11000         ; Brahmi # Mc       BRAHMI SIGN CANDRABINDU
+11001         ; Brahmi # Mn       BRAHMI SIGN ANUSVARA
+11002         ; Brahmi # Mc       BRAHMI SIGN VISARGA
+11003..11037  ; Brahmi # Lo  [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI LETTER OLD TAMIL NNNA
+11038..11046  ; Brahmi # Mn  [15] BRAHMI VOWEL SIGN AA..BRAHMI VIRAMA
+11047..1104D  ; Brahmi # Po   [7] BRAHMI DANDA..BRAHMI PUNCTUATION LOTUS
+11052..11065  ; Brahmi # No  [20] BRAHMI NUMBER ONE..BRAHMI NUMBER ONE THOUSAND
+11066..1106F  ; Brahmi # Nd  [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT NINE
+11070         ; Brahmi # Mn       BRAHMI SIGN OLD TAMIL VIRAMA
+11071..11072  ; Brahmi # Lo   [2] BRAHMI LETTER OLD TAMIL SHORT E..BRAHMI LETTER OLD TAMIL SHORT O
+11073..11074  ; Brahmi # Mn   [2] BRAHMI VOWEL SIGN OLD TAMIL SHORT E..BRAHMI VOWEL SIGN OLD TAMIL SHORT O
+11075         ; Brahmi # Lo       BRAHMI LETTER OLD TAMIL LLA
+1107F         ; Brahmi # Mn       BRAHMI NUMBER JOINER
+
+# Total code points: 115
+
+# ================================================
+
+0840..0858    ; Mandaic # Lo  [25] MANDAIC LETTER HALQA..MANDAIC LETTER AIN
+0859..085B    ; Mandaic # Mn   [3] MANDAIC AFFRICATION MARK..MANDAIC GEMINATION MARK
+085E          ; Mandaic # Po       MANDAIC PUNCTUATION
+
+# Total code points: 29
+
+# ================================================
+
+11100..11102  ; Chakma # Mn   [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA
+11103..11126  ; Chakma # Lo  [36] CHAKMA LETTER AA..CHAKMA LETTER HAA
+11127..1112B  ; Chakma # Mn   [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU
+1112C         ; Chakma # Mc       CHAKMA VOWEL SIGN E
+1112D..11134  ; Chakma # Mn   [8] CHAKMA VOWEL SIGN AI..CHAKMA MAAYYAA
+11136..1113F  ; Chakma # Nd  [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT NINE
+11140..11143  ; Chakma # Po   [4] CHAKMA SECTION MARK..CHAKMA QUESTION MARK
+11144         ; Chakma # Lo       CHAKMA LETTER LHAA
+11145..11146  ; Chakma # Mc   [2] CHAKMA VOWEL SIGN AA..CHAKMA VOWEL SIGN EI
+11147         ; Chakma # Lo       CHAKMA LETTER VAA
+
+# Total code points: 71
+
+# ================================================
+
+109A0..109B7  ; Meroitic_Cursive # Lo  [24] MEROITIC CURSIVE LETTER A..MEROITIC CURSIVE LETTER DA
+109BC..109BD  ; Meroitic_Cursive # No   [2] MEROITIC CURSIVE FRACTION ELEVEN TWELFTHS..MEROITIC CURSIVE FRACTION ONE HALF
+109BE..109BF  ; Meroitic_Cursive # Lo   [2] MEROITIC CURSIVE LOGOGRAM RMT..MEROITIC CURSIVE LOGOGRAM IMN
+109C0..109CF  ; Meroitic_Cursive # No  [16] MEROITIC CURSIVE NUMBER ONE..MEROITIC CURSIVE NUMBER SEVENTY
+109D2..109FF  ; Meroitic_Cursive # No  [46] MEROITIC CURSIVE NUMBER ONE HUNDRED..MEROITIC CURSIVE FRACTION TEN TWELFTHS
+
+# Total code points: 90
+
+# ================================================
+
+10980..1099F  ; Meroitic_Hieroglyphs # Lo  [32] MEROITIC HIEROGLYPHIC LETTER A..MEROITIC HIEROGLYPHIC SYMBOL VIDJ-2
+
+# Total code points: 32
+
+# ================================================
+
+16F00..16F4A  ; Miao # Lo  [75] MIAO LETTER PA..MIAO LETTER RTE
+16F4F         ; Miao # Mn       MIAO SIGN CONSONANT MODIFIER BAR
+16F50         ; Miao # Lo       MIAO LETTER NASALIZATION
+16F51..16F87  ; Miao # Mc  [55] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN UI
+16F8F..16F92  ; Miao # Mn   [4] MIAO TONE RIGHT..MIAO TONE BELOW
+16F93..16F9F  ; Miao # Lm  [13] MIAO LETTER TONE-2..MIAO LETTER REFORMED TONE-8
+
+# Total code points: 149
+
+# ================================================
+
+11180..11181  ; Sharada # Mn   [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA
+11182         ; Sharada # Mc       SHARADA SIGN VISARGA
+11183..111B2  ; Sharada # Lo  [48] SHARADA LETTER A..SHARADA LETTER HA
+111B3..111B5  ; Sharada # Mc   [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II
+111B6..111BE  ; Sharada # Mn   [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O
+111BF..111C0  ; Sharada # Mc   [2] SHARADA VOWEL SIGN AU..SHARADA SIGN VIRAMA
+111C1..111C4  ; Sharada # Lo   [4] SHARADA SIGN AVAGRAHA..SHARADA OM
+111C5..111C8  ; Sharada # Po   [4] SHARADA DANDA..SHARADA SEPARATOR
+111C9..111CC  ; Sharada # Mn   [4] SHARADA SANDHI MARK..SHARADA EXTRA SHORT VOWEL MARK
+111CD         ; Sharada # Po       SHARADA SUTRA MARK
+111CE         ; Sharada # Mc       SHARADA VOWEL SIGN PRISHTHAMATRA E
+111CF         ; Sharada # Mn       SHARADA SIGN INVERTED CANDRABINDU
+111D0..111D9  ; Sharada # Nd  [10] SHARADA DIGIT ZERO..SHARADA DIGIT NINE
+111DA         ; Sharada # Lo       SHARADA EKAM
+111DB         ; Sharada # Po       SHARADA SIGN SIDDHAM
+111DC         ; Sharada # Lo       SHARADA HEADSTROKE
+111DD..111DF  ; Sharada # Po   [3] SHARADA CONTINUATION SIGN..SHARADA SECTION MARK-2
+11B60         ; Sharada # Mn       SHARADA VOWEL SIGN OE
+11B61         ; Sharada # Mc       SHARADA VOWEL SIGN OOE
+11B62..11B64  ; Sharada # Mn   [3] SHARADA VOWEL SIGN UE..SHARADA VOWEL SIGN SHORT E
+11B65         ; Sharada # Mc       SHARADA VOWEL SIGN SHORT O
+11B66         ; Sharada # Mn       SHARADA VOWEL SIGN CANDRA E
+11B67         ; Sharada # Mc       SHARADA VOWEL SIGN CANDRA O
+
+# Total code points: 104
+
+# ================================================
+
+110D0..110E8  ; Sora_Sompeng # Lo  [25] SORA SOMPENG LETTER SAH..SORA SOMPENG LETTER MAE
+110F0..110F9  ; Sora_Sompeng # Nd  [10] SORA SOMPENG DIGIT ZERO..SORA SOMPENG DIGIT NINE
+
+# Total code points: 35
+
+# ================================================
+
+11680..116AA  ; Takri # Lo  [43] TAKRI LETTER A..TAKRI LETTER RRA
+116AB         ; Takri # Mn       TAKRI SIGN ANUSVARA
+116AC         ; Takri # Mc       TAKRI SIGN VISARGA
+116AD         ; Takri # Mn       TAKRI VOWEL SIGN AA
+116AE..116AF  ; Takri # Mc   [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II
+116B0..116B5  ; Takri # Mn   [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU
+116B6         ; Takri # Mc       TAKRI SIGN VIRAMA
+116B7         ; Takri # Mn       TAKRI SIGN NUKTA
+116B8         ; Takri # Lo       TAKRI LETTER ARCHAIC KHA
+116B9         ; Takri # Po       TAKRI ABBREVIATION SIGN
+116C0..116C9  ; Takri # Nd  [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE
+
+# Total code points: 68
+
+# ================================================
+
+10530..10563  ; Caucasian_Albanian # Lo  [52] CAUCASIAN ALBANIAN LETTER ALT..CAUCASIAN ALBANIAN LETTER KIW
+1056F         ; Caucasian_Albanian # Po       CAUCASIAN ALBANIAN CITATION MARK
+
+# Total code points: 53
+
+# ================================================
+
+16AD0..16AED  ; Bassa_Vah # Lo  [30] BASSA VAH LETTER ENNI..BASSA VAH LETTER I
+16AF0..16AF4  ; Bassa_Vah # Mn   [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE
+16AF5         ; Bassa_Vah # Po       BASSA VAH FULL STOP
+
+# Total code points: 36
+
+# ================================================
+
+1BC00..1BC6A  ; Duployan # Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M
+1BC70..1BC7C  ; Duployan # Lo  [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK
+1BC80..1BC88  ; Duployan # Lo   [9] DUPLOYAN AFFIX HIGH ACUTE..DUPLOYAN AFFIX HIGH VERTICAL
+1BC90..1BC99  ; Duployan # Lo  [10] DUPLOYAN AFFIX LOW ACUTE..DUPLOYAN AFFIX LOW ARROW
+1BC9C         ; Duployan # So       DUPLOYAN SIGN O WITH CROSS
+1BC9D..1BC9E  ; Duployan # Mn   [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK
+1BC9F         ; Duployan # Po       DUPLOYAN PUNCTUATION CHINOOK FULL STOP
+
+# Total code points: 143
+
+# ================================================
+
+10500..10527  ; Elbasan # Lo  [40] ELBASAN LETTER A..ELBASAN LETTER KHE
+
+# Total code points: 40
+
+# ================================================
+
+11300..11301  ; Grantha # Mn   [2] GRANTHA SIGN COMBINING ANUSVARA ABOVE..GRANTHA SIGN CANDRABINDU
+11302..11303  ; Grantha # Mc   [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA
+11305..1130C  ; Grantha # Lo   [8] GRANTHA LETTER A..GRANTHA LETTER VOCALIC L
+1130F..11310  ; Grantha # Lo   [2] GRANTHA LETTER EE..GRANTHA LETTER AI
+11313..11328  ; Grantha # Lo  [22] GRANTHA LETTER OO..GRANTHA LETTER NA
+1132A..11330  ; Grantha # Lo   [7] GRANTHA LETTER PA..GRANTHA LETTER RA
+11332..11333  ; Grantha # Lo   [2] GRANTHA LETTER LA..GRANTHA LETTER LLA
+11335..11339  ; Grantha # Lo   [5] GRANTHA LETTER VA..GRANTHA LETTER HA
+1133C         ; Grantha # Mn       GRANTHA SIGN NUKTA
+1133D         ; Grantha # Lo       GRANTHA SIGN AVAGRAHA
+1133E..1133F  ; Grantha # Mc   [2] GRANTHA VOWEL SIGN AA..GRANTHA VOWEL SIGN I
+11340         ; Grantha # Mn       GRANTHA VOWEL SIGN II
+11341..11344  ; Grantha # Mc   [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR
+11347..11348  ; Grantha # Mc   [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI
+1134B..1134D  ; Grantha # Mc   [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA
+11350         ; Grantha # Lo       GRANTHA OM
+11357         ; Grantha # Mc       GRANTHA AU LENGTH MARK
+1135D..11361  ; Grantha # Lo   [5] GRANTHA SIGN PLUTA..GRANTHA LETTER VOCALIC LL
+11362..11363  ; Grantha # Mc   [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL
+11366..1136C  ; Grantha # Mn   [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX
+11370..11374  ; Grantha # Mn   [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA
+
+# Total code points: 85
+
+# ================================================
+
+16B00..16B2F  ; Pahawh_Hmong # Lo  [48] PAHAWH HMONG VOWEL KEEB..PAHAWH HMONG CONSONANT CAU
+16B30..16B36  ; Pahawh_Hmong # Mn   [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM
+16B37..16B3B  ; Pahawh_Hmong # Po   [5] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN VOS FEEM
+16B3C..16B3F  ; Pahawh_Hmong # So   [4] PAHAWH HMONG SIGN XYEEM NTXIV..PAHAWH HMONG SIGN XYEEM FAIB
+16B40..16B43  ; Pahawh_Hmong # Lm   [4] PAHAWH HMONG SIGN VOS SEEV..PAHAWH HMONG SIGN IB YAM
+16B44         ; Pahawh_Hmong # Po       PAHAWH HMONG SIGN XAUS
+16B45         ; Pahawh_Hmong # So       PAHAWH HMONG SIGN CIM TSOV ROG
+16B50..16B59  ; Pahawh_Hmong # Nd  [10] PAHAWH HMONG DIGIT ZERO..PAHAWH HMONG DIGIT NINE
+16B5B..16B61  ; Pahawh_Hmong # No   [7] PAHAWH HMONG NUMBER TENS..PAHAWH HMONG NUMBER TRILLIONS
+16B63..16B77  ; Pahawh_Hmong # Lo  [21] PAHAWH HMONG SIGN VOS LUB..PAHAWH HMONG SIGN CIM NRES TOS
+16B7D..16B8F  ; Pahawh_Hmong # Lo  [19] PAHAWH HMONG CLAN SIGN TSHEEJ..PAHAWH HMONG CLAN SIGN VWJ
+
+# Total code points: 127
+
+# ================================================
+
+11200..11211  ; Khojki # Lo  [18] KHOJKI LETTER A..KHOJKI LETTER JJA
+11213..1122B  ; Khojki # Lo  [25] KHOJKI LETTER NYA..KHOJKI LETTER LLA
+1122C..1122E  ; Khojki # Mc   [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II
+1122F..11231  ; Khojki # Mn   [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI
+11232..11233  ; Khojki # Mc   [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU
+11234         ; Khojki # Mn       KHOJKI SIGN ANUSVARA
+11235         ; Khojki # Mc       KHOJKI SIGN VIRAMA
+11236..11237  ; Khojki # Mn   [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA
+11238..1123D  ; Khojki # Po   [6] KHOJKI DANDA..KHOJKI ABBREVIATION SIGN
+1123E         ; Khojki # Mn       KHOJKI SIGN SUKUN
+1123F..11240  ; Khojki # Lo   [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I
+11241         ; Khojki # Mn       KHOJKI VOWEL SIGN VOCALIC R
+
+# Total code points: 65
+
+# ================================================
+
+10600..10736  ; Linear_A # Lo [311] LINEAR A SIGN AB001..LINEAR A SIGN A664
+10740..10755  ; Linear_A # Lo  [22] LINEAR A SIGN A701 A..LINEAR A SIGN A732 JE
+10760..10767  ; Linear_A # Lo   [8] LINEAR A SIGN A800..LINEAR A SIGN A807
+
+# Total code points: 341
+
+# ================================================
+
+11150..11172  ; Mahajani # Lo  [35] MAHAJANI LETTER A..MAHAJANI LETTER RRA
+11173         ; Mahajani # Mn       MAHAJANI SIGN NUKTA
+11174..11175  ; Mahajani # Po   [2] MAHAJANI ABBREVIATION SIGN..MAHAJANI SECTION MARK
+11176         ; Mahajani # Lo       MAHAJANI LIGATURE SHRI
+
+# Total code points: 39
+
+# ================================================
+
+10AC0..10AC7  ; Manichaean # Lo   [8] MANICHAEAN LETTER ALEPH..MANICHAEAN LETTER WAW
+10AC8         ; Manichaean # So       MANICHAEAN SIGN UD
+10AC9..10AE4  ; Manichaean # Lo  [28] MANICHAEAN LETTER ZAYIN..MANICHAEAN LETTER TAW
+10AE5..10AE6  ; Manichaean # Mn   [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW
+10AEB..10AEF  ; Manichaean # No   [5] MANICHAEAN NUMBER ONE..MANICHAEAN NUMBER ONE HUNDRED
+10AF0..10AF6  ; Manichaean # Po   [7] MANICHAEAN PUNCTUATION STAR..MANICHAEAN PUNCTUATION LINE FILLER
+
+# Total code points: 51
+
+# ================================================
+
+1E800..1E8C4  ; Mende_Kikakui # Lo [197] MENDE KIKAKUI SYLLABLE M001 KI..MENDE KIKAKUI SYLLABLE M060 NYON
+1E8C7..1E8CF  ; Mende_Kikakui # No   [9] MENDE KIKAKUI DIGIT ONE..MENDE KIKAKUI DIGIT NINE
+1E8D0..1E8D6  ; Mende_Kikakui # Mn   [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS
+
+# Total code points: 213
+
+# ================================================
+
+11600..1162F  ; Modi # Lo  [48] MODI LETTER A..MODI LETTER LLA
+11630..11632  ; Modi # Mc   [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II
+11633..1163A  ; Modi # Mn   [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI
+1163B..1163C  ; Modi # Mc   [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU
+1163D         ; Modi # Mn       MODI SIGN ANUSVARA
+1163E         ; Modi # Mc       MODI SIGN VISARGA
+1163F..11640  ; Modi # Mn   [2] MODI SIGN VIRAMA..MODI SIGN ARDHACANDRA
+11641..11643  ; Modi # Po   [3] MODI DANDA..MODI ABBREVIATION SIGN
+11644         ; Modi # Lo       MODI SIGN HUVA
+11650..11659  ; Modi # Nd  [10] MODI DIGIT ZERO..MODI DIGIT NINE
+
+# Total code points: 79
+
+# ================================================
+
+16A40..16A5E  ; Mro # Lo  [31] MRO LETTER TA..MRO LETTER TEK
+16A60..16A69  ; Mro # Nd  [10] MRO DIGIT ZERO..MRO DIGIT NINE
+16A6E..16A6F  ; Mro # Po   [2] MRO DANDA..MRO DOUBLE DANDA
+
+# Total code points: 43
+
+# ================================================
+
+10A80..10A9C  ; Old_North_Arabian # Lo  [29] OLD NORTH ARABIAN LETTER HEH..OLD NORTH ARABIAN LETTER ZAH
+10A9D..10A9F  ; Old_North_Arabian # No   [3] OLD NORTH ARABIAN NUMBER ONE..OLD NORTH ARABIAN NUMBER TWENTY
+
+# Total code points: 32
+
+# ================================================
+
+10880..1089E  ; Nabataean # Lo  [31] NABATAEAN LETTER FINAL ALEPH..NABATAEAN LETTER TAW
+108A7..108AF  ; Nabataean # No   [9] NABATAEAN NUMBER ONE..NABATAEAN NUMBER ONE HUNDRED
+
+# Total code points: 40
+
+# ================================================
+
+10860..10876  ; Palmyrene # Lo  [23] PALMYRENE LETTER ALEPH..PALMYRENE LETTER TAW
+10877..10878  ; Palmyrene # So   [2] PALMYRENE LEFT-POINTING FLEURON..PALMYRENE RIGHT-POINTING FLEURON
+10879..1087F  ; Palmyrene # No   [7] PALMYRENE NUMBER ONE..PALMYRENE NUMBER TWENTY
+
+# Total code points: 32
+
+# ================================================
+
+11AC0..11AF8  ; Pau_Cin_Hau # Lo  [57] PAU CIN HAU LETTER PA..PAU CIN HAU GLOTTAL STOP FINAL
+
+# Total code points: 57
+
+# ================================================
+
+10350..10375  ; Old_Permic # Lo  [38] OLD PERMIC LETTER AN..OLD PERMIC LETTER IA
+10376..1037A  ; Old_Permic # Mn   [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII
+
+# Total code points: 43
+
+# ================================================
+
+10B80..10B91  ; Psalter_Pahlavi # Lo  [18] PSALTER PAHLAVI LETTER ALEPH..PSALTER PAHLAVI LETTER TAW
+10B99..10B9C  ; Psalter_Pahlavi # Po   [4] PSALTER PAHLAVI SECTION MARK..PSALTER PAHLAVI FOUR DOTS WITH DOT
+10BA9..10BAF  ; Psalter_Pahlavi # No   [7] PSALTER PAHLAVI NUMBER ONE..PSALTER PAHLAVI NUMBER ONE HUNDRED
+
+# Total code points: 29
+
+# ================================================
+
+11580..115AE  ; Siddham # Lo  [47] SIDDHAM LETTER A..SIDDHAM LETTER HA
+115AF..115B1  ; Siddham # Mc   [3] SIDDHAM VOWEL SIGN AA..SIDDHAM VOWEL SIGN II
+115B2..115B5  ; Siddham # Mn   [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR
+115B8..115BB  ; Siddham # Mc   [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU
+115BC..115BD  ; Siddham # Mn   [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA
+115BE         ; Siddham # Mc       SIDDHAM SIGN VISARGA
+115BF..115C0  ; Siddham # Mn   [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA
+115C1..115D7  ; Siddham # Po  [23] SIDDHAM SIGN SIDDHAM..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES
+115D8..115DB  ; Siddham # Lo   [4] SIDDHAM LETTER THREE-CIRCLE ALTERNATE I..SIDDHAM LETTER ALTERNATE U
+115DC..115DD  ; Siddham # Mn   [2] SIDDHAM VOWEL SIGN ALTERNATE U..SIDDHAM VOWEL SIGN ALTERNATE UU
+
+# Total code points: 92
+
+# ================================================
+
+112B0..112DE  ; Khudawadi # Lo  [47] KHUDAWADI LETTER A..KHUDAWADI LETTER HA
+112DF         ; Khudawadi # Mn       KHUDAWADI SIGN ANUSVARA
+112E0..112E2  ; Khudawadi # Mc   [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II
+112E3..112EA  ; Khudawadi # Mn   [8] KHUDAWADI VOWEL SIGN U..KHUDAWADI SIGN VIRAMA
+112F0..112F9  ; Khudawadi # Nd  [10] KHUDAWADI DIGIT ZERO..KHUDAWADI DIGIT NINE
+
+# Total code points: 69
+
+# ================================================
+
+11480..114AF  ; Tirhuta # Lo  [48] TIRHUTA ANJI..TIRHUTA LETTER HA
+114B0..114B2  ; Tirhuta # Mc   [3] TIRHUTA VOWEL SIGN AA..TIRHUTA VOWEL SIGN II
+114B3..114B8  ; Tirhuta # Mn   [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL
+114B9         ; Tirhuta # Mc       TIRHUTA VOWEL SIGN E
+114BA         ; Tirhuta # Mn       TIRHUTA VOWEL SIGN SHORT E
+114BB..114BE  ; Tirhuta # Mc   [4] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN AU
+114BF..114C0  ; Tirhuta # Mn   [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA
+114C1         ; Tirhuta # Mc       TIRHUTA SIGN VISARGA
+114C2..114C3  ; Tirhuta # Mn   [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA
+114C4..114C5  ; Tirhuta # Lo   [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA GVANG
+114C6         ; Tirhuta # Po       TIRHUTA ABBREVIATION SIGN
+114C7         ; Tirhuta # Lo       TIRHUTA OM
+114D0..114D9  ; Tirhuta # Nd  [10] TIRHUTA DIGIT ZERO..TIRHUTA DIGIT NINE
+
+# Total code points: 82
+
+# ================================================
+
+118A0..118DF  ; Warang_Citi # L&  [64] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI SMALL LETTER VIYO
+118E0..118E9  ; Warang_Citi # Nd  [10] WARANG CITI DIGIT ZERO..WARANG CITI DIGIT NINE
+118EA..118F2  ; Warang_Citi # No   [9] WARANG CITI NUMBER TEN..WARANG CITI NUMBER NINETY
+118FF         ; Warang_Citi # Lo       WARANG CITI OM
+
+# Total code points: 84
+
+# ================================================
+
+11700..1171A  ; Ahom # Lo  [27] AHOM LETTER KA..AHOM LETTER ALTERNATE BA
+1171D         ; Ahom # Mn       AHOM CONSONANT SIGN MEDIAL LA
+1171E         ; Ahom # Mc       AHOM CONSONANT SIGN MEDIAL RA
+1171F         ; Ahom # Mn       AHOM CONSONANT SIGN MEDIAL LIGATING RA
+11720..11721  ; Ahom # Mc   [2] AHOM VOWEL SIGN A..AHOM VOWEL SIGN AA
+11722..11725  ; Ahom # Mn   [4] AHOM VOWEL SIGN I..AHOM VOWEL SIGN UU
+11726         ; Ahom # Mc       AHOM VOWEL SIGN E
+11727..1172B  ; Ahom # Mn   [5] AHOM VOWEL SIGN AW..AHOM SIGN KILLER
+11730..11739  ; Ahom # Nd  [10] AHOM DIGIT ZERO..AHOM DIGIT NINE
+1173A..1173B  ; Ahom # No   [2] AHOM NUMBER TEN..AHOM NUMBER TWENTY
+1173C..1173E  ; Ahom # Po   [3] AHOM SIGN SMALL SECTION..AHOM SIGN RULAI
+1173F         ; Ahom # So       AHOM SYMBOL VI
+11740..11746  ; Ahom # Lo   [7] AHOM LETTER CA..AHOM LETTER LLA
+
+# Total code points: 65
+
+# ================================================
+
+14400..14646  ; Anatolian_Hieroglyphs # Lo [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530
+
+# Total code points: 583
+
+# ================================================
+
+108E0..108F2  ; Hatran # Lo  [19] HATRAN LETTER ALEPH..HATRAN LETTER QOPH
+108F4..108F5  ; Hatran # Lo   [2] HATRAN LETTER SHIN..HATRAN LETTER TAW
+108FB..108FF  ; Hatran # No   [5] HATRAN NUMBER ONE..HATRAN NUMBER ONE HUNDRED
+
+# Total code points: 26
+
+# ================================================
+
+11280..11286  ; Multani # Lo   [7] MULTANI LETTER A..MULTANI LETTER GA
+11288         ; Multani # Lo       MULTANI LETTER GHA
+1128A..1128D  ; Multani # Lo   [4] MULTANI LETTER CA..MULTANI LETTER JJA
+1128F..1129D  ; Multani # Lo  [15] MULTANI LETTER NYA..MULTANI LETTER BA
+1129F..112A8  ; Multani # Lo  [10] MULTANI LETTER BHA..MULTANI LETTER RHA
+112A9         ; Multani # Po       MULTANI SECTION MARK
+
+# Total code points: 38
+
+# ================================================
+
+10C80..10CB2  ; Old_Hungarian # L&  [51] OLD HUNGARIAN CAPITAL LETTER A..OLD HUNGARIAN CAPITAL LETTER US
+10CC0..10CF2  ; Old_Hungarian # L&  [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US
+10CFA..10CFF  ; Old_Hungarian # No   [6] OLD HUNGARIAN NUMBER ONE..OLD HUNGARIAN NUMBER ONE THOUSAND
+
+# Total code points: 108
+
+# ================================================
+
+1D800..1D9FF  ; SignWriting # So [512] SIGNWRITING HAND-FIST INDEX..SIGNWRITING HEAD
+1DA00..1DA36  ; SignWriting # Mn  [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN
+1DA37..1DA3A  ; SignWriting # So   [4] SIGNWRITING AIR BLOW SMALL ROTATIONS..SIGNWRITING BREATH EXHALE
+1DA3B..1DA6C  ; SignWriting # Mn  [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT
+1DA6D..1DA74  ; SignWriting # So   [8] SIGNWRITING SHOULDER HIP SPINE..SIGNWRITING TORSO-FLOORPLANE TWISTING
+1DA75         ; SignWriting # Mn       SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS
+1DA76..1DA83  ; SignWriting # So  [14] SIGNWRITING LIMB COMBINATION..SIGNWRITING LOCATION DEPTH
+1DA84         ; SignWriting # Mn       SIGNWRITING LOCATION HEAD NECK
+1DA85..1DA86  ; SignWriting # So   [2] SIGNWRITING LOCATION TORSO..SIGNWRITING LOCATION LIMBS DIGITS
+1DA87..1DA8B  ; SignWriting # Po   [5] SIGNWRITING COMMA..SIGNWRITING PARENTHESIS
+1DA9B..1DA9F  ; SignWriting # Mn   [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6
+1DAA1..1DAAF  ; SignWriting # Mn  [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16
+
+# Total code points: 672
+
+# ================================================
+
+1E900..1E943  ; Adlam # L&  [68] ADLAM CAPITAL LETTER ALIF..ADLAM SMALL LETTER SHA
+1E944..1E94A  ; Adlam # Mn   [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA
+1E94B         ; Adlam # Lm       ADLAM NASALIZATION MARK
+1E950..1E959  ; Adlam # Nd  [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE
+1E95E..1E95F  ; Adlam # Po   [2] ADLAM INITIAL EXCLAMATION MARK..ADLAM INITIAL QUESTION MARK
+
+# Total code points: 88
+
+# ================================================
+
+11C00..11C08  ; Bhaiksuki # Lo   [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L
+11C0A..11C2E  ; Bhaiksuki # Lo  [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA
+11C2F         ; Bhaiksuki # Mc       BHAIKSUKI VOWEL SIGN AA
+11C30..11C36  ; Bhaiksuki # Mn   [7] BHAIKSUKI VOWEL SIGN I..BHAIKSUKI VOWEL SIGN VOCALIC L
+11C38..11C3D  ; Bhaiksuki # Mn   [6] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN ANUSVARA
+11C3E         ; Bhaiksuki # Mc       BHAIKSUKI SIGN VISARGA
+11C3F         ; Bhaiksuki # Mn       BHAIKSUKI SIGN VIRAMA
+11C40         ; Bhaiksuki # Lo       BHAIKSUKI SIGN AVAGRAHA
+11C41..11C45  ; Bhaiksuki # Po   [5] BHAIKSUKI DANDA..BHAIKSUKI GAP FILLER-2
+11C50..11C59  ; Bhaiksuki # Nd  [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI DIGIT NINE
+11C5A..11C6C  ; Bhaiksuki # No  [19] BHAIKSUKI NUMBER ONE..BHAIKSUKI HUNDREDS UNIT MARK
+
+# Total code points: 97
+
+# ================================================
+
+11C70..11C71  ; Marchen # Po   [2] MARCHEN HEAD MARK..MARCHEN MARK SHAD
+11C72..11C8F  ; Marchen # Lo  [30] MARCHEN LETTER KA..MARCHEN LETTER A
+11C92..11CA7  ; Marchen # Mn  [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA
+11CA9         ; Marchen # Mc       MARCHEN SUBJOINED LETTER YA
+11CAA..11CB0  ; Marchen # Mn   [7] MARCHEN SUBJOINED LETTER RA..MARCHEN VOWEL SIGN AA
+11CB1         ; Marchen # Mc       MARCHEN VOWEL SIGN I
+11CB2..11CB3  ; Marchen # Mn   [2] MARCHEN VOWEL SIGN U..MARCHEN VOWEL SIGN E
+11CB4         ; Marchen # Mc       MARCHEN VOWEL SIGN O
+11CB5..11CB6  ; Marchen # Mn   [2] MARCHEN SIGN ANUSVARA..MARCHEN SIGN CANDRABINDU
+
+# Total code points: 68
+
+# ================================================
+
+11400..11434  ; Newa # Lo  [53] NEWA LETTER A..NEWA LETTER HA
+11435..11437  ; Newa # Mc   [3] NEWA VOWEL SIGN AA..NEWA VOWEL SIGN II
+11438..1143F  ; Newa # Mn   [8] NEWA VOWEL SIGN U..NEWA VOWEL SIGN AI
+11440..11441  ; Newa # Mc   [2] NEWA VOWEL SIGN O..NEWA VOWEL SIGN AU
+11442..11444  ; Newa # Mn   [3] NEWA SIGN VIRAMA..NEWA SIGN ANUSVARA
+11445         ; Newa # Mc       NEWA SIGN VISARGA
+11446         ; Newa # Mn       NEWA SIGN NUKTA
+11447..1144A  ; Newa # Lo   [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI
+1144B..1144F  ; Newa # Po   [5] NEWA DANDA..NEWA ABBREVIATION SIGN
+11450..11459  ; Newa # Nd  [10] NEWA DIGIT ZERO..NEWA DIGIT NINE
+1145A..1145B  ; Newa # Po   [2] NEWA DOUBLE COMMA..NEWA PLACEHOLDER MARK
+1145D         ; Newa # Po       NEWA INSERTION SIGN
+1145E         ; Newa # Mn       NEWA SANDHI MARK
+1145F..11461  ; Newa # Lo   [3] NEWA LETTER VEDIC ANUSVARA..NEWA SIGN UPADHMANIYA
+
+# Total code points: 97
+
+# ================================================
+
+104B0..104D3  ; Osage # L&  [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA
+104D8..104FB  ; Osage # L&  [36] OSAGE SMALL LETTER A..OSAGE SMALL LETTER ZHA
+
+# Total code points: 72
+
+# ================================================
+
+16FE0         ; Tangut # Lm       TANGUT ITERATION MARK
+17000..18AFF  ; Tangut # Lo [6912] TANGUT IDEOGRAPH-17000..TANGUT COMPONENT-768
+18D00..18D1E  ; Tangut # Lo  [31] TANGUT IDEOGRAPH-18D00..TANGUT IDEOGRAPH-18D1E
+18D80..18DF2  ; Tangut # Lo [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883
+
+# Total code points: 7059
+
+# ================================================
+
+11D00..11D06  ; Masaram_Gondi # Lo   [7] MASARAM GONDI LETTER A..MASARAM GONDI LETTER E
+11D08..11D09  ; Masaram_Gondi # Lo   [2] MASARAM GONDI LETTER AI..MASARAM GONDI LETTER O
+11D0B..11D30  ; Masaram_Gondi # Lo  [38] MASARAM GONDI LETTER AU..MASARAM GONDI LETTER TRA
+11D31..11D36  ; Masaram_Gondi # Mn   [6] MASARAM GONDI VOWEL SIGN AA..MASARAM GONDI VOWEL SIGN VOCALIC R
+11D3A         ; Masaram_Gondi # Mn       MASARAM GONDI VOWEL SIGN E
+11D3C..11D3D  ; Masaram_Gondi # Mn   [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O
+11D3F..11D45  ; Masaram_Gondi # Mn   [7] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI VIRAMA
+11D46         ; Masaram_Gondi # Lo       MASARAM GONDI REPHA
+11D47         ; Masaram_Gondi # Mn       MASARAM GONDI RA-KARA
+11D50..11D59  ; Masaram_Gondi # Nd  [10] MASARAM GONDI DIGIT ZERO..MASARAM GONDI DIGIT NINE
+
+# Total code points: 75
+
+# ================================================
+
+16FE1         ; Nushu # Lm       NUSHU ITERATION MARK
+1B170..1B2FB  ; Nushu # Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB
+
+# Total code points: 397
+
+# ================================================
+
+11A50         ; Soyombo # Lo       SOYOMBO LETTER A
+11A51..11A56  ; Soyombo # Mn   [6] SOYOMBO VOWEL SIGN I..SOYOMBO VOWEL SIGN OE
+11A57..11A58  ; Soyombo # Mc   [2] SOYOMBO VOWEL SIGN AI..SOYOMBO VOWEL SIGN AU
+11A59..11A5B  ; Soyombo # Mn   [3] SOYOMBO VOWEL SIGN VOCALIC R..SOYOMBO VOWEL LENGTH MARK
+11A5C..11A89  ; Soyombo # Lo  [46] SOYOMBO LETTER KA..SOYOMBO CLUSTER-INITIAL LETTER SA
+11A8A..11A96  ; Soyombo # Mn  [13] SOYOMBO FINAL CONSONANT SIGN G..SOYOMBO SIGN ANUSVARA
+11A97         ; Soyombo # Mc       SOYOMBO SIGN VISARGA
+11A98..11A99  ; Soyombo # Mn   [2] SOYOMBO GEMINATION MARK..SOYOMBO SUBJOINER
+11A9A..11A9C  ; Soyombo # Po   [3] SOYOMBO MARK TSHEG..SOYOMBO MARK DOUBLE SHAD
+11A9D         ; Soyombo # Lo       SOYOMBO MARK PLUTA
+11A9E..11AA2  ; Soyombo # Po   [5] SOYOMBO HEAD MARK WITH MOON AND SUN AND TRIPLE FLAME..SOYOMBO TERMINAL MARK-2
+
+# Total code points: 83
+
+# ================================================
+
+11A00         ; Zanabazar_Square # Lo       ZANABAZAR SQUARE LETTER A
+11A01..11A0A  ; Zanabazar_Square # Mn  [10] ZANABAZAR SQUARE VOWEL SIGN I..ZANABAZAR SQUARE VOWEL LENGTH MARK
+11A0B..11A32  ; Zanabazar_Square # Lo  [40] ZANABAZAR SQUARE LETTER KA..ZANABAZAR SQUARE LETTER KSSA
+11A33..11A38  ; Zanabazar_Square # Mn   [6] ZANABAZAR SQUARE FINAL CONSONANT MARK..ZANABAZAR SQUARE SIGN ANUSVARA
+11A39         ; Zanabazar_Square # Mc       ZANABAZAR SQUARE SIGN VISARGA
+11A3A         ; Zanabazar_Square # Lo       ZANABAZAR SQUARE CLUSTER-INITIAL LETTER RA
+11A3B..11A3E  ; Zanabazar_Square # Mn   [4] ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA
+11A3F..11A46  ; Zanabazar_Square # Po   [8] ZANABAZAR SQUARE INITIAL HEAD MARK..ZANABAZAR SQUARE CLOSING DOUBLE-LINED HEAD MARK
+11A47         ; Zanabazar_Square # Mn       ZANABAZAR SQUARE SUBJOINER
+
+# Total code points: 72
+
+# ================================================
+
+11800..1182B  ; Dogra # Lo  [44] DOGRA LETTER A..DOGRA LETTER RRA
+1182C..1182E  ; Dogra # Mc   [3] DOGRA VOWEL SIGN AA..DOGRA VOWEL SIGN II
+1182F..11837  ; Dogra # Mn   [9] DOGRA VOWEL SIGN U..DOGRA SIGN ANUSVARA
+11838         ; Dogra # Mc       DOGRA SIGN VISARGA
+11839..1183A  ; Dogra # Mn   [2] DOGRA SIGN VIRAMA..DOGRA SIGN NUKTA
+1183B         ; Dogra # Po       DOGRA ABBREVIATION SIGN
+
+# Total code points: 60
+
+# ================================================
+
+11D60..11D65  ; Gunjala_Gondi # Lo   [6] GUNJALA GONDI LETTER A..GUNJALA GONDI LETTER UU
+11D67..11D68  ; Gunjala_Gondi # Lo   [2] GUNJALA GONDI LETTER EE..GUNJALA GONDI LETTER AI
+11D6A..11D89  ; Gunjala_Gondi # Lo  [32] GUNJALA GONDI LETTER OO..GUNJALA GONDI LETTER SA
+11D8A..11D8E  ; Gunjala_Gondi # Mc   [5] GUNJALA GONDI VOWEL SIGN AA..GUNJALA GONDI VOWEL SIGN UU
+11D90..11D91  ; Gunjala_Gondi # Mn   [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI
+11D93..11D94  ; Gunjala_Gondi # Mc   [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU
+11D95         ; Gunjala_Gondi # Mn       GUNJALA GONDI SIGN ANUSVARA
+11D96         ; Gunjala_Gondi # Mc       GUNJALA GONDI SIGN VISARGA
+11D97         ; Gunjala_Gondi # Mn       GUNJALA GONDI VIRAMA
+11D98         ; Gunjala_Gondi # Lo       GUNJALA GONDI OM
+11DA0..11DA9  ; Gunjala_Gondi # Nd  [10] GUNJALA GONDI DIGIT ZERO..GUNJALA GONDI DIGIT NINE
+
+# Total code points: 63
+
+# ================================================
+
+11EE0..11EF2  ; Makasar # Lo  [19] MAKASAR LETTER KA..MAKASAR ANGKA
+11EF3..11EF4  ; Makasar # Mn   [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U
+11EF5..11EF6  ; Makasar # Mc   [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O
+11EF7..11EF8  ; Makasar # Po   [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION
+
+# Total code points: 25
+
+# ================================================
+
+16E40..16E7F  ; Medefaidrin # L&  [64] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN SMALL LETTER Y
+16E80..16E96  ; Medefaidrin # No  [23] MEDEFAIDRIN DIGIT ZERO..MEDEFAIDRIN DIGIT THREE ALTERNATE FORM
+16E97..16E9A  ; Medefaidrin # Po   [4] MEDEFAIDRIN COMMA..MEDEFAIDRIN EXCLAMATION OH
+
+# Total code points: 91
+
+# ================================================
+
+10D00..10D23  ; Hanifi_Rohingya # Lo  [36] HANIFI ROHINGYA LETTER A..HANIFI ROHINGYA MARK NA KHONNA
+10D24..10D27  ; Hanifi_Rohingya # Mn   [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI
+10D30..10D39  ; Hanifi_Rohingya # Nd  [10] HANIFI ROHINGYA DIGIT ZERO..HANIFI ROHINGYA DIGIT NINE
+
+# Total code points: 50
+
+# ================================================
+
+10F30..10F45  ; Sogdian # Lo  [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN
+10F46..10F50  ; Sogdian # Mn  [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW
+10F51..10F54  ; Sogdian # No   [4] SOGDIAN NUMBER ONE..SOGDIAN NUMBER ONE HUNDRED
+10F55..10F59  ; Sogdian # Po   [5] SOGDIAN PUNCTUATION TWO VERTICAL BARS..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT
+
+# Total code points: 42
+
+# ================================================
+
+10F00..10F1C  ; Old_Sogdian # Lo  [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL
+10F1D..10F26  ; Old_Sogdian # No  [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF
+10F27         ; Old_Sogdian # Lo       OLD SOGDIAN LIGATURE AYIN-DALETH
+
+# Total code points: 40
+
+# ================================================
+
+10FE0..10FF6  ; Elymaic # Lo  [23] ELYMAIC LETTER ALEPH..ELYMAIC LIGATURE ZAYIN-YODH
+
+# Total code points: 23
+
+# ================================================
+
+119A0..119A7  ; Nandinagari # Lo   [8] NANDINAGARI LETTER A..NANDINAGARI LETTER VOCALIC RR
+119AA..119D0  ; Nandinagari # Lo  [39] NANDINAGARI LETTER E..NANDINAGARI LETTER RRA
+119D1..119D3  ; Nandinagari # Mc   [3] NANDINAGARI VOWEL SIGN AA..NANDINAGARI VOWEL SIGN II
+119D4..119D7  ; Nandinagari # Mn   [4] NANDINAGARI VOWEL SIGN U..NANDINAGARI VOWEL SIGN VOCALIC RR
+119DA..119DB  ; Nandinagari # Mn   [2] NANDINAGARI VOWEL SIGN E..NANDINAGARI VOWEL SIGN AI
+119DC..119DF  ; Nandinagari # Mc   [4] NANDINAGARI VOWEL SIGN O..NANDINAGARI SIGN VISARGA
+119E0         ; Nandinagari # Mn       NANDINAGARI SIGN VIRAMA
+119E1         ; Nandinagari # Lo       NANDINAGARI SIGN AVAGRAHA
+119E2         ; Nandinagari # Po       NANDINAGARI SIGN SIDDHAM
+119E3         ; Nandinagari # Lo       NANDINAGARI HEADSTROKE
+119E4         ; Nandinagari # Mc       NANDINAGARI VOWEL SIGN PRISHTHAMATRA E
+
+# Total code points: 65
+
+# ================================================
+
+1E100..1E12C  ; Nyiakeng_Puachue_Hmong # Lo  [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W
+1E130..1E136  ; Nyiakeng_Puachue_Hmong # Mn   [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D
+1E137..1E13D  ; Nyiakeng_Puachue_Hmong # Lm   [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER
+1E140..1E149  ; Nyiakeng_Puachue_Hmong # Nd  [10] NYIAKENG PUACHUE HMONG DIGIT ZERO..NYIAKENG PUACHUE HMONG DIGIT NINE
+1E14E         ; Nyiakeng_Puachue_Hmong # Lo       NYIAKENG PUACHUE HMONG LOGOGRAM NYAJ
+1E14F         ; Nyiakeng_Puachue_Hmong # So       NYIAKENG PUACHUE HMONG CIRCLED CA
+
+# Total code points: 71
+
+# ================================================
+
+1E2C0..1E2EB  ; Wancho # Lo  [44] WANCHO LETTER AA..WANCHO LETTER YIH
+1E2EC..1E2EF  ; Wancho # Mn   [4] WANCHO TONE TUP..WANCHO TONE KOINI
+1E2F0..1E2F9  ; Wancho # Nd  [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE
+1E2FF         ; Wancho # Sc       WANCHO NGUN SIGN
+
+# Total code points: 59
+
+# ================================================
+
+10FB0..10FC4  ; Chorasmian # Lo  [21] CHORASMIAN LETTER ALEPH..CHORASMIAN LETTER TAW
+10FC5..10FCB  ; Chorasmian # No   [7] CHORASMIAN NUMBER ONE..CHORASMIAN NUMBER ONE HUNDRED
+
+# Total code points: 28
+
+# ================================================
+
+11900..11906  ; Dives_Akuru # Lo   [7] DIVES AKURU LETTER A..DIVES AKURU LETTER E
+11909         ; Dives_Akuru # Lo       DIVES AKURU LETTER O
+1190C..11913  ; Dives_Akuru # Lo   [8] DIVES AKURU LETTER KA..DIVES AKURU LETTER JA
+11915..11916  ; Dives_Akuru # Lo   [2] DIVES AKURU LETTER NYA..DIVES AKURU LETTER TTA
+11918..1192F  ; Dives_Akuru # Lo  [24] DIVES AKURU LETTER DDA..DIVES AKURU LETTER ZA
+11930..11935  ; Dives_Akuru # Mc   [6] DIVES AKURU VOWEL SIGN AA..DIVES AKURU VOWEL SIGN E
+11937..11938  ; Dives_Akuru # Mc   [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O
+1193B..1193C  ; Dives_Akuru # Mn   [2] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN CANDRABINDU
+1193D         ; Dives_Akuru # Mc       DIVES AKURU SIGN HALANTA
+1193E         ; Dives_Akuru # Mn       DIVES AKURU VIRAMA
+1193F         ; Dives_Akuru # Lo       DIVES AKURU PREFIXED NASAL SIGN
+11940         ; Dives_Akuru # Mc       DIVES AKURU MEDIAL YA
+11941         ; Dives_Akuru # Lo       DIVES AKURU INITIAL RA
+11942         ; Dives_Akuru # Mc       DIVES AKURU MEDIAL RA
+11943         ; Dives_Akuru # Mn       DIVES AKURU SIGN NUKTA
+11944..11946  ; Dives_Akuru # Po   [3] DIVES AKURU DOUBLE DANDA..DIVES AKURU END OF TEXT MARK
+11950..11959  ; Dives_Akuru # Nd  [10] DIVES AKURU DIGIT ZERO..DIVES AKURU DIGIT NINE
+
+# Total code points: 72
+
+# ================================================
+
+16FE4         ; Khitan_Small_Script # Mn       KHITAN SMALL SCRIPT FILLER
+18B00..18CD5  ; Khitan_Small_Script # Lo [470] KHITAN SMALL SCRIPT CHARACTER-18B00..KHITAN SMALL SCRIPT CHARACTER-18CD5
+18CFF         ; Khitan_Small_Script # Lo       KHITAN SMALL SCRIPT CHARACTER-18CFF
+
+# Total code points: 472
+
+# ================================================
+
+10E80..10EA9  ; Yezidi # Lo  [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET
+10EAB..10EAC  ; Yezidi # Mn   [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK
+10EAD         ; Yezidi # Pd       YEZIDI HYPHENATION MARK
+10EB0..10EB1  ; Yezidi # Lo   [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE
+
+# Total code points: 47
+
+# ================================================
+
+12F90..12FF0  ; Cypro_Minoan # Lo  [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114
+12FF1..12FF2  ; Cypro_Minoan # Po   [2] CYPRO-MINOAN SIGN CM301..CYPRO-MINOAN SIGN CM302
+
+# Total code points: 99
+
+# ================================================
+
+10F70..10F81  ; Old_Uyghur # Lo  [18] OLD UYGHUR LETTER ALEPH..OLD UYGHUR LETTER LESH
+10F82..10F85  ; Old_Uyghur # Mn   [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW
+10F86..10F89  ; Old_Uyghur # Po   [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS
+
+# Total code points: 26
+
+# ================================================
+
+16A70..16ABE  ; Tangsa # Lo  [79] TANGSA LETTER OZ..TANGSA LETTER ZA
+16AC0..16AC9  ; Tangsa # Nd  [10] TANGSA DIGIT ZERO..TANGSA DIGIT NINE
+
+# Total code points: 89
+
+# ================================================
+
+1E290..1E2AD  ; Toto # Lo  [30] TOTO LETTER PA..TOTO LETTER A
+1E2AE         ; Toto # Mn       TOTO SIGN RISING TONE
+
+# Total code points: 31
+
+# ================================================
+
+10570..1057A  ; Vithkuqi # L&  [11] VITHKUQI CAPITAL LETTER A..VITHKUQI CAPITAL LETTER GA
+1057C..1058A  ; Vithkuqi # L&  [15] VITHKUQI CAPITAL LETTER HA..VITHKUQI CAPITAL LETTER RE
+1058C..10592  ; Vithkuqi # L&   [7] VITHKUQI CAPITAL LETTER SE..VITHKUQI CAPITAL LETTER XE
+10594..10595  ; Vithkuqi # L&   [2] VITHKUQI CAPITAL LETTER Y..VITHKUQI CAPITAL LETTER ZE
+10597..105A1  ; Vithkuqi # L&  [11] VITHKUQI SMALL LETTER A..VITHKUQI SMALL LETTER GA
+105A3..105B1  ; Vithkuqi # L&  [15] VITHKUQI SMALL LETTER HA..VITHKUQI SMALL LETTER RE
+105B3..105B9  ; Vithkuqi # L&   [7] VITHKUQI SMALL LETTER SE..VITHKUQI SMALL LETTER XE
+105BB..105BC  ; Vithkuqi # L&   [2] VITHKUQI SMALL LETTER Y..VITHKUQI SMALL LETTER ZE
+
+# Total code points: 70
+
+# ================================================
+
+11F00..11F01  ; Kawi # Mn   [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA
+11F02         ; Kawi # Lo       KAWI SIGN REPHA
+11F03         ; Kawi # Mc       KAWI SIGN VISARGA
+11F04..11F10  ; Kawi # Lo  [13] KAWI LETTER A..KAWI LETTER O
+11F12..11F33  ; Kawi # Lo  [34] KAWI LETTER KA..KAWI LETTER JNYA
+11F34..11F35  ; Kawi # Mc   [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA
+11F36..11F3A  ; Kawi # Mn   [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R
+11F3E..11F3F  ; Kawi # Mc   [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI
+11F40         ; Kawi # Mn       KAWI VOWEL SIGN EU
+11F41         ; Kawi # Mc       KAWI SIGN KILLER
+11F42         ; Kawi # Mn       KAWI CONJOINER
+11F43..11F4F  ; Kawi # Po  [13] KAWI DANDA..KAWI PUNCTUATION CLOSING SPIRAL
+11F50..11F59  ; Kawi # Nd  [10] KAWI DIGIT ZERO..KAWI DIGIT NINE
+11F5A         ; Kawi # Mn       KAWI SIGN NUKTA
+
+# Total code points: 87
+
+# ================================================
+
+1E4D0..1E4EA  ; Nag_Mundari # Lo  [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL
+1E4EB         ; Nag_Mundari # Lm       NAG MUNDARI SIGN OJOD
+1E4EC..1E4EF  ; Nag_Mundari # Mn   [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH
+1E4F0..1E4F9  ; Nag_Mundari # Nd  [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE
+
+# Total code points: 42
+
+# ================================================
+
+10D40..10D49  ; Garay # Nd  [10] GARAY DIGIT ZERO..GARAY DIGIT NINE
+10D4A..10D4D  ; Garay # Lo   [4] GARAY VOWEL SIGN A..GARAY VOWEL SIGN EE
+10D4E         ; Garay # Lm       GARAY VOWEL LENGTH MARK
+10D4F         ; Garay # Lo       GARAY SUKUN
+10D50..10D65  ; Garay # L&  [22] GARAY CAPITAL LETTER A..GARAY CAPITAL LETTER OLD NA
+10D69..10D6D  ; Garay # Mn   [5] GARAY VOWEL SIGN E..GARAY CONSONANT NASALIZATION MARK
+10D6E         ; Garay # Pd       GARAY HYPHEN
+10D6F         ; Garay # Lm       GARAY REDUPLICATION MARK
+10D70..10D85  ; Garay # L&  [22] GARAY SMALL LETTER A..GARAY SMALL LETTER OLD NA
+10D8E..10D8F  ; Garay # Sm   [2] GARAY PLUS SIGN..GARAY MINUS SIGN
+
+# Total code points: 69
+
+# ================================================
+
+16100..1611D  ; Gurung_Khema # Lo  [30] GURUNG KHEMA LETTER A..GURUNG KHEMA LETTER SA
+1611E..16129  ; Gurung_Khema # Mn  [12] GURUNG KHEMA VOWEL SIGN AA..GURUNG KHEMA VOWEL LENGTH MARK
+1612A..1612C  ; Gurung_Khema # Mc   [3] GURUNG KHEMA CONSONANT SIGN MEDIAL YA..GURUNG KHEMA CONSONANT SIGN MEDIAL HA
+1612D..1612F  ; Gurung_Khema # Mn   [3] GURUNG KHEMA SIGN ANUSVARA..GURUNG KHEMA SIGN THOLHOMA
+16130..16139  ; Gurung_Khema # Nd  [10] GURUNG KHEMA DIGIT ZERO..GURUNG KHEMA DIGIT NINE
+
+# Total code points: 58
+
+# ================================================
+
+16D40..16D42  ; Kirat_Rai # Lm   [3] KIRAT RAI SIGN ANUSVARA..KIRAT RAI SIGN VISARGA
+16D43..16D6A  ; Kirat_Rai # Lo  [40] KIRAT RAI LETTER A..KIRAT RAI VOWEL SIGN AU
+16D6B..16D6C  ; Kirat_Rai # Lm   [2] KIRAT RAI SIGN VIRAMA..KIRAT RAI SIGN SAAT
+16D6D..16D6F  ; Kirat_Rai # Po   [3] KIRAT RAI SIGN YUPI..KIRAT RAI DOUBLE DANDA
+16D70..16D79  ; Kirat_Rai # Nd  [10] KIRAT RAI DIGIT ZERO..KIRAT RAI DIGIT NINE
+
+# Total code points: 58
+
+# ================================================
+
+1E5D0..1E5ED  ; Ol_Onal # Lo  [30] OL ONAL LETTER O..OL ONAL LETTER EG
+1E5EE..1E5EF  ; Ol_Onal # Mn   [2] OL ONAL SIGN MU..OL ONAL SIGN IKIR
+1E5F0         ; Ol_Onal # Lo       OL ONAL SIGN HODDOND
+1E5F1..1E5FA  ; Ol_Onal # Nd  [10] OL ONAL DIGIT ZERO..OL ONAL DIGIT NINE
+1E5FF         ; Ol_Onal # Po       OL ONAL ABBREVIATION SIGN
+
+# Total code points: 44
+
+# ================================================
+
+11BC0..11BE0  ; Sunuwar # Lo  [33] SUNUWAR LETTER DEVI..SUNUWAR LETTER KLOKO
+11BE1         ; Sunuwar # Po       SUNUWAR SIGN PVO
+11BF0..11BF9  ; Sunuwar # Nd  [10] SUNUWAR DIGIT ZERO..SUNUWAR DIGIT NINE
+
+# Total code points: 44
+
+# ================================================
+
+105C0..105F3  ; Todhri # Lo  [52] TODHRI LETTER A..TODHRI LETTER OO
+
+# Total code points: 52
+
+# ================================================
+
+11380..11389  ; Tulu_Tigalari # Lo  [10] TULU-TIGALARI LETTER A..TULU-TIGALARI LETTER VOCALIC LL
+1138B         ; Tulu_Tigalari # Lo       TULU-TIGALARI LETTER EE
+1138E         ; Tulu_Tigalari # Lo       TULU-TIGALARI LETTER AI
+11390..113B5  ; Tulu_Tigalari # Lo  [38] TULU-TIGALARI LETTER OO..TULU-TIGALARI LETTER LLLA
+113B7         ; Tulu_Tigalari # Lo       TULU-TIGALARI SIGN AVAGRAHA
+113B8..113BA  ; Tulu_Tigalari # Mc   [3] TULU-TIGALARI VOWEL SIGN AA..TULU-TIGALARI VOWEL SIGN II
+113BB..113C0  ; Tulu_Tigalari # Mn   [6] TULU-TIGALARI VOWEL SIGN U..TULU-TIGALARI VOWEL SIGN VOCALIC LL
+113C2         ; Tulu_Tigalari # Mc       TULU-TIGALARI VOWEL SIGN EE
+113C5         ; Tulu_Tigalari # Mc       TULU-TIGALARI VOWEL SIGN AI
+113C7..113CA  ; Tulu_Tigalari # Mc   [4] TULU-TIGALARI VOWEL SIGN OO..TULU-TIGALARI SIGN CANDRA ANUNASIKA
+113CC..113CD  ; Tulu_Tigalari # Mc   [2] TULU-TIGALARI SIGN ANUSVARA..TULU-TIGALARI SIGN VISARGA
+113CE         ; Tulu_Tigalari # Mn       TULU-TIGALARI SIGN VIRAMA
+113CF         ; Tulu_Tigalari # Mc       TULU-TIGALARI SIGN LOOPED VIRAMA
+113D0         ; Tulu_Tigalari # Mn       TULU-TIGALARI CONJOINER
+113D1         ; Tulu_Tigalari # Lo       TULU-TIGALARI REPHA
+113D2         ; Tulu_Tigalari # Mn       TULU-TIGALARI GEMINATION MARK
+113D3         ; Tulu_Tigalari # Lo       TULU-TIGALARI SIGN PLUTA
+113D4..113D5  ; Tulu_Tigalari # Po   [2] TULU-TIGALARI DANDA..TULU-TIGALARI DOUBLE DANDA
+113D7..113D8  ; Tulu_Tigalari # Po   [2] TULU-TIGALARI SIGN OM PUSHPIKA..TULU-TIGALARI SIGN SHRII PUSHPIKA
+113E1..113E2  ; Tulu_Tigalari # Mn   [2] TULU-TIGALARI VEDIC TONE SVARITA..TULU-TIGALARI VEDIC TONE ANUDATTA
+
+# Total code points: 80
+
+# ================================================
+
+10940..10959  ; Sidetic # Lo  [26] SIDETIC LETTER N01..SIDETIC LETTER N26
+
+# Total code points: 26
+
+# ================================================
+
+1E6C0..1E6DE  ; Tai_Yo # Lo  [31] TAI YO LETTER LOW KO..TAI YO LETTER HIGH KVO
+1E6E0..1E6E2  ; Tai_Yo # Lo   [3] TAI YO LETTER AA..TAI YO LETTER UE
+1E6E3         ; Tai_Yo # Mn       TAI YO SIGN UE
+1E6E4..1E6E5  ; Tai_Yo # Lo   [2] TAI YO LETTER U..TAI YO LETTER AE
+1E6E6         ; Tai_Yo # Mn       TAI YO SIGN AU
+1E6E7..1E6ED  ; Tai_Yo # Lo   [7] TAI YO LETTER O..TAI YO LETTER AUE
+1E6EE..1E6EF  ; Tai_Yo # Mn   [2] TAI YO SIGN AY..TAI YO SIGN ANG
+1E6F0..1E6F4  ; Tai_Yo # Lo   [5] TAI YO LETTER AN..TAI YO LETTER AP
+1E6F5         ; Tai_Yo # Mn       TAI YO SIGN OM
+1E6FE         ; Tai_Yo # Lo       TAI YO SYMBOL MUEANG
+1E6FF         ; Tai_Yo # Lm       TAI YO XAM LAI
+
+# Total code points: 55
+
+# ================================================
+
+11DB0..11DD8  ; Tolong_Siki # Lo  [41] TOLONG SIKI LETTER I..TOLONG SIKI LETTER RRH
+11DD9         ; Tolong_Siki # Lm       TOLONG SIKI SIGN SELA
+11DDA..11DDB  ; Tolong_Siki # Lo   [2] TOLONG SIKI SIGN HECAKA..TOLONG SIKI UNGGA
+11DE0..11DE9  ; Tolong_Siki # Nd  [10] TOLONG SIKI DIGIT ZERO..TOLONG SIKI DIGIT NINE
+
+# Total code points: 54
+
+# ================================================
+
+16EA0..16EB8  ; Beria_Erfe # L&  [25] BERIA ERFE CAPITAL LETTER ARKAB..BERIA ERFE CAPITAL LETTER AY
+16EBB..16ED3  ; Beria_Erfe # L&  [25] BERIA ERFE SMALL LETTER ARKAB..BERIA ERFE SMALL LETTER AY
+
+# Total code points: 50
+
+# EOF
diff --git a/lib/elixir/unicode/SpecialCasing.txt b/lib/elixir/unicode/SpecialCasing.txt
index 93351c9b08c..1013344a6f2 100644
--- a/lib/elixir/unicode/SpecialCasing.txt
+++ b/lib/elixir/unicode/SpecialCasing.txt
@@ -1,5 +1,79 @@
+# SpecialCasing-17.0.0.txt
+# Date: 2025-07-31, 22:11:55 GMT
+# © 2025 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use and license, see https://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+#   For documentation, see https://www.unicode.org/reports/tr44/
+#
+# Special Casing
+#
+# This file is a supplement to the UnicodeData.txt file. The data in this file, combined with
+# the simple case mappings in UnicodeData.txt, defines the full case mappings
+# Lowercase_Mapping (lc), Titlecase_Mapping (tc), and Uppercase_Mapping (uc).
+# For compatibility, the UnicodeData.txt file only contains simple case mappings
+# for characters where they are one-to-one (and independent of context and language).
+#
+# For historical reasons, this file also provides additional information about the casing
+# of Unicode characters for selected situations when casing is dependent on context or locale.
+#
+# Note that the preferred mechanism for defining tailored casing operations is
+# the Unicode Common Locale Data Repository (CLDR). For more information, see the
+# discussion of case mappings and case algorithms in the Unicode Standard.
+#
+# All code points not listed in this file that do not have simple case mappings
+# in UnicodeData.txt map to themselves.
+# ================================================================================
+# Format
+# ================================================================================
+# The entries in this file are in the following machine-readable format:
+#
+# <code>; <lower>; <title>; <upper>; (<condition_list>;)? # <comment>
+#
+# <code>, <lower>, <title>, and <upper> provide the respective full case mappings
+# of <code>, expressed as character values in hex. If there is more than one character,
+# they are separated by spaces. Other than as used to separate elements, spaces are
+# to be ignored.
+#
+# The <condition_list> is optional. Where present, it consists of one or more language IDs
+# or casing contexts, separated by spaces. In these conditions:
+# - A condition list overrides the normal behavior if all of the listed conditions are true.
+# - The casing context is always the context of the characters in the original string,
+#   NOT in the resulting string.
+# - Case distinctions in the condition list are not significant.
+# - Conditions preceded by "Not_" represent the negation of the condition.
+# The condition list is not represented in the UCD as a formal property.
+#
+# A language ID is defined by BCP 47, with '-' and '_' treated equivalently.
+#
+# A casing context for a character is defined in the
+# "Conformance" / "Default Case Algorithms" section of the core specification.
+#
+# Parsers of this file must be prepared to deal with future additions to this format:
+#  * Additional contexts
+#  * Additional fields
+# ================================================================================
+
+# ================================================================================
+# Unconditional mappings
+# The mappings in this section are not language-sensitive nor context-sensitive.
+#
+# Note that comments provide additional information but
+# do not modify the case mapping algorithms in the core specification, chapter 3.
+# ================================================================================
+
+# The German es-zed is special--the normal mapping is to SS.
+# Note: the titlecase should never occur in practice. It is equal to titlecase(uppercase(<es-zed>))
+
 00DF; 00DF; 0053 0073; 0053 0053; # LATIN SMALL LETTER SHARP S
+
+# Preserve canonical equivalence for I with dot. Turkic is handled below.
+
 0130; 0069 0307; 0130; 0130; # LATIN CAPITAL LETTER I WITH DOT ABOVE
+
+# Ligatures
+
 FB00; FB00; 0046 0066; 0046 0046; # LATIN SMALL LIGATURE FF
 FB01; FB01; 0046 0069; 0046 0049; # LATIN SMALL LIGATURE FI
 FB02; FB02; 0046 006C; 0046 004C; # LATIN SMALL LIGATURE FL
@@ -7,12 +81,16 @@ FB03; FB03; 0046 0066 0069; 0046 0046 0049; # LATIN SMALL LIGATURE FFI
 FB04; FB04; 0046 0066 006C; 0046 0046 004C; # LATIN SMALL LIGATURE FFL
 FB05; FB05; 0053 0074; 0053 0054; # LATIN SMALL LIGATURE LONG S T
 FB06; FB06; 0053 0074; 0053 0054; # LATIN SMALL LIGATURE ST
+
 0587; 0587; 0535 0582; 0535 0552; # ARMENIAN SMALL LIGATURE ECH YIWN
 FB13; FB13; 0544 0576; 0544 0546; # ARMENIAN SMALL LIGATURE MEN NOW
 FB14; FB14; 0544 0565; 0544 0535; # ARMENIAN SMALL LIGATURE MEN ECH
 FB15; FB15; 0544 056B; 0544 053B; # ARMENIAN SMALL LIGATURE MEN INI
 FB16; FB16; 054E 0576; 054E 0546; # ARMENIAN SMALL LIGATURE VEW NOW
 FB17; FB17; 0544 056D; 0544 053D; # ARMENIAN SMALL LIGATURE MEN XEH
+
+# No corresponding uppercase precomposed character
+
 0149; 0149; 02BC 004E; 02BC 004E; # LATIN SMALL LETTER N PRECEDED BY APOSTROPHE
 0390; 0390; 0399 0308 0301; 0399 0308 0301; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
 03B0; 03B0; 03A5 0308 0301; 03A5 0308 0301; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
@@ -38,6 +116,21 @@ FB17; FB17; 0544 056D; 0544 053D; # ARMENIAN SMALL LIGATURE MEN XEH
 1FE6; 1FE6; 03A5 0342; 03A5 0342; # GREEK SMALL LETTER UPSILON WITH PERISPOMENI
 1FE7; 1FE7; 03A5 0308 0342; 03A5 0308 0342; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI
 1FF6; 1FF6; 03A9 0342; 03A9 0342; # GREEK SMALL LETTER OMEGA WITH PERISPOMENI
+
+# IMPORTANT-when iota-subscript (0345) is uppercased or titlecased,
+#  the result will be incorrect unless the iota-subscript is moved to the end
+#  of any sequence of combining marks. Otherwise, the accents will go on the capital iota.
+#  This process can be achieved by first transforming the text to NFC before casing.
+#  E.g. <alpha><iota_subscript><acute> is uppercased to <ALPHA><acute><IOTA>
+
+# The following cases are already in the UnicodeData.txt file, so are only commented here.
+
+# 0345; 0345; 0399; 0399; # COMBINING GREEK YPOGEGRAMMENI
+
+# All letters with YPOGEGRAMMENI (iota-subscript) or PROSGEGRAMMENI (iota adscript)
+# have special uppercases.
+# Note: characters with PROSGEGRAMMENI are actually titlecase, not uppercase!
+
 1F80; 1F80; 1F88; 1F08 0399; # GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI
 1F81; 1F81; 1F89; 1F09 0399; # GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI
 1F82; 1F82; 1F8A; 1F0A 0399; # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI
@@ -92,12 +185,101 @@ FB17; FB17; 0544 056D; 0544 053D; # ARMENIAN SMALL LIGATURE MEN XEH
 1FCC; 1FC3; 1FCC; 0397 0399; # GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
 1FF3; 1FF3; 1FFC; 03A9 0399; # GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI
 1FFC; 1FF3; 1FFC; 03A9 0399; # GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
+
+# Some characters with YPOGEGRAMMENI also have no corresponding titlecases
+
 1FB2; 1FB2; 1FBA 0345; 1FBA 0399; # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI
 1FB4; 1FB4; 0386 0345; 0386 0399; # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI
 1FC2; 1FC2; 1FCA 0345; 1FCA 0399; # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI
 1FC4; 1FC4; 0389 0345; 0389 0399; # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI
 1FF2; 1FF2; 1FFA 0345; 1FFA 0399; # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI
 1FF4; 1FF4; 038F 0345; 038F 0399; # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI
+
 1FB7; 1FB7; 0391 0342 0345; 0391 0342 0399; # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI
 1FC7; 1FC7; 0397 0342 0345; 0397 0342 0399; # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI
 1FF7; 1FF7; 03A9 0342 0345; 03A9 0342 0399; # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI
+
+# ================================================================================
+# Conditional Mappings
+# The remainder of this file provides conditional casing data used to produce
+# full case mappings.
+# ================================================================================
+# Language-Insensitive Mappings
+# These are characters whose full case mappings do not depend on language, but do
+# depend on context (which characters come before or after). For more information
+# see the header of this file and the Unicode Standard.
+# ================================================================================
+
+# Special case for final form of sigma
+
+03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA
+
+# Note: the following cases for non-final are already in the UnicodeData.txt file.
+
+# 03A3; 03C3; 03A3; 03A3; # GREEK CAPITAL LETTER SIGMA
+# 03C3; 03C3; 03A3; 03A3; # GREEK SMALL LETTER SIGMA
+# 03C2; 03C2; 03A3; 03A3; # GREEK SMALL LETTER FINAL SIGMA
+
+# Note: the following cases are not included, since they would case-fold in lowercasing
+
+# 03C3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK SMALL LETTER SIGMA
+# 03C2; 03C3; 03A3; 03A3; Not_Final_Sigma; # GREEK SMALL LETTER FINAL SIGMA
+
+# ================================================================================
+# Language-Sensitive Mappings
+# These are characters whose full case mappings depend on language and perhaps also
+# context (which characters come before or after). For more information
+# see the header of this file and the Unicode Standard.
+# ================================================================================
+
+# Lithuanian
+
+# Lithuanian retains the dot in a lowercase i when followed by accents.
+
+# Remove DOT ABOVE after "i" with upper or titlecase
+
+0307; 0307; ; ; lt After_Soft_Dotted; # COMBINING DOT ABOVE
+
+# Introduce an explicit dot above when lowercasing capital I's and J's
+# whenever there are more accents above.
+# (of the accents used in Lithuanian: grave, acute, tilde above, and ogonek)
+
+0049; 0069 0307; 0049; 0049; lt More_Above; # LATIN CAPITAL LETTER I
+004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J
+012E; 012F 0307; 012E; 012E; lt More_Above; # LATIN CAPITAL LETTER I WITH OGONEK
+00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE
+00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE
+0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE
+
+# ================================================================================
+
+# Turkish and Azeri
+
+# I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
+# The following rules handle those cases.
+
+0130; 0069; 0130; 0130; tr; # LATIN CAPITAL LETTER I WITH DOT ABOVE
+0130; 0069; 0130; 0130; az; # LATIN CAPITAL LETTER I WITH DOT ABOVE
+
+# When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
+# This matches the behavior of the canonically equivalent I-dot_above
+
+0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
+0307; ; 0307; 0307; az After_I; # COMBINING DOT ABOVE
+
+# When lowercasing, unless an I is before a dot_above, it turns into a dotless i.
+
+0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I
+0049; 0131; 0049; 0049; az Not_Before_Dot; # LATIN CAPITAL LETTER I
+
+# When uppercasing, i turns into a dotted capital I
+
+0069; 0069; 0130; 0130; tr; # LATIN SMALL LETTER I
+0069; 0069; 0130; 0130; az; # LATIN SMALL LETTER I
+
+# Note: the following case is already in the UnicodeData.txt file.
+
+# 0131; 0131; 0049; 0049; tr; # LATIN SMALL LETTER DOTLESS I
+
+# EOF
+
diff --git a/lib/elixir/unicode/UnicodeData.txt b/lib/elixir/unicode/UnicodeData.txt
index 31c8a7eaa04..fca68e3e154 100644
--- a/lib/elixir/unicode/UnicodeData.txt
+++ b/lib/elixir/unicode/UnicodeData.txt
@@ -409,7 +409,7 @@
 0198;LATIN CAPITAL LETTER K WITH HOOK;Lu;0;L;;;;;N;LATIN CAPITAL LETTER K HOOK;;;0199;
 0199;LATIN SMALL LETTER K WITH HOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER K HOOK;;0198;;0198
 019A;LATIN SMALL LETTER L WITH BAR;Ll;0;L;;;;;N;LATIN SMALL LETTER BARRED L;;023D;;023D
-019B;LATIN SMALL LETTER LAMBDA WITH STROKE;Ll;0;L;;;;;N;LATIN SMALL LETTER BARRED LAMBDA;;;;
+019B;LATIN SMALL LETTER LAMBDA WITH STROKE;Ll;0;L;;;;;N;LATIN SMALL LETTER BARRED LAMBDA;;A7DC;;A7DC
 019C;LATIN CAPITAL LETTER TURNED M;Lu;0;L;;;;;N;;;;026F;
 019D;LATIN CAPITAL LETTER N WITH LEFT HOOK;Lu;0;L;;;;;N;LATIN CAPITAL LETTER N HOOK;;;0272;
 019E;LATIN SMALL LETTER N WITH LONG RIGHT LEG;Ll;0;L;;;;;N;;;0220;;0220
@@ -610,13 +610,13 @@
 0261;LATIN SMALL LETTER SCRIPT G;Ll;0;L;;;;;N;;;A7AC;;A7AC
 0262;LATIN LETTER SMALL CAPITAL G;Ll;0;L;;;;;N;;;;;
 0263;LATIN SMALL LETTER GAMMA;Ll;0;L;;;;;N;;;0194;;0194
-0264;LATIN SMALL LETTER RAMS HORN;Ll;0;L;;;;;N;LATIN SMALL LETTER BABY GAMMA;;;;
+0264;LATIN SMALL LETTER RAMS HORN;Ll;0;L;;;;;N;LATIN SMALL LETTER BABY GAMMA;;A7CB;;A7CB
 0265;LATIN SMALL LETTER TURNED H;Ll;0;L;;;;;N;;;A78D;;A78D
 0266;LATIN SMALL LETTER H WITH HOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER H HOOK;;A7AA;;A7AA
 0267;LATIN SMALL LETTER HENG WITH HOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER HENG HOOK;;;;
 0268;LATIN SMALL LETTER I WITH STROKE;Ll;0;L;;;;;N;LATIN SMALL LETTER BARRED I;;0197;;0197
 0269;LATIN SMALL LETTER IOTA;Ll;0;L;;;;;N;;;0196;;0196
-026A;LATIN LETTER SMALL CAPITAL I;Ll;0;L;;;;;N;;;;;
+026A;LATIN LETTER SMALL CAPITAL I;Ll;0;L;;;;;N;;;A7AE;;A7AE
 026B;LATIN SMALL LETTER L WITH MIDDLE TILDE;Ll;0;L;;;;;N;;;2C62;;2C62
 026C;LATIN SMALL LETTER L WITH BELT;Ll;0;L;;;;;N;LATIN SMALL LETTER L BELT;;A7AD;;A7AD
 026D;LATIN SMALL LETTER L WITH RETROFLEX HOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER L RETROFLEX HOOK;;;;
@@ -640,7 +640,7 @@
 027F;LATIN SMALL LETTER REVERSED R WITH FISHHOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER REVERSED FISHHOOK R;;;;
 0280;LATIN LETTER SMALL CAPITAL R;Ll;0;L;;;;;N;;;01A6;;01A6
 0281;LATIN LETTER SMALL CAPITAL INVERTED R;Ll;0;L;;;;;N;;;;;
-0282;LATIN SMALL LETTER S WITH HOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER S HOOK;;;;
+0282;LATIN SMALL LETTER S WITH HOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER S HOOK;;A7C5;;A7C5
 0283;LATIN SMALL LETTER ESH;Ll;0;L;;;;;N;;;01A9;;01A9
 0284;LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER DOTLESS J BAR HOOK;;;;
 0285;LATIN SMALL LETTER SQUAT REVERSED ESH;Ll;0;L;;;;;N;;;;;
@@ -659,7 +659,7 @@
 0292;LATIN SMALL LETTER EZH;Ll;0;L;;;;;N;LATIN SMALL LETTER YOGH;;01B7;;01B7
 0293;LATIN SMALL LETTER EZH WITH CURL;Ll;0;L;;;;;N;LATIN SMALL LETTER YOGH CURL;;;;
 0294;LATIN LETTER GLOTTAL STOP;Lo;0;L;;;;;N;;;;;
-0295;LATIN LETTER PHARYNGEAL VOICED FRICATIVE;Ll;0;L;;;;;N;LATIN LETTER REVERSED GLOTTAL STOP;;;;
+0295;LATIN LETTER PHARYNGEAL VOICED FRICATIVE;Lo;0;L;;;;;N;LATIN LETTER REVERSED GLOTTAL STOP;;;;
 0296;LATIN LETTER INVERTED GLOTTAL STOP;Ll;0;L;;;;;N;;;;;
 0297;LATIN LETTER STRETCHED C;Ll;0;L;;;;;N;;;;;
 0298;LATIN LETTER BILABIAL CLICK;Ll;0;L;;;;;N;LATIN LETTER BULLSEYE;;;;
@@ -667,7 +667,7 @@
 029A;LATIN SMALL LETTER CLOSED OPEN E;Ll;0;L;;;;;N;LATIN SMALL LETTER CLOSED EPSILON;;;;
 029B;LATIN LETTER SMALL CAPITAL G WITH HOOK;Ll;0;L;;;;;N;LATIN LETTER SMALL CAPITAL G HOOK;;;;
 029C;LATIN LETTER SMALL CAPITAL H;Ll;0;L;;;;;N;;;;;
-029D;LATIN SMALL LETTER J WITH CROSSED-TAIL;Ll;0;L;;;;;N;LATIN SMALL LETTER CROSSED-TAIL J;;;;
+029D;LATIN SMALL LETTER J WITH CROSSED-TAIL;Ll;0;L;;;;;N;LATIN SMALL LETTER CROSSED-TAIL J;;A7B2;;A7B2
 029E;LATIN SMALL LETTER TURNED K;Ll;0;L;;;;;N;;;A7B0;;A7B0
 029F;LATIN LETTER SMALL CAPITAL L;Ll;0;L;;;;;N;;;;;
 02A0;LATIN SMALL LETTER Q WITH HOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER Q HOOK;;;;
@@ -1362,6 +1362,7 @@
 055D;ARMENIAN COMMA;Po;0;L;;;;;N;;;;;
 055E;ARMENIAN QUESTION MARK;Po;0;L;;;;;N;;;;;
 055F;ARMENIAN ABBREVIATION MARK;Po;0;L;;;;;N;;;;;
+0560;ARMENIAN SMALL LETTER TURNED AYB;Ll;0;L;;;;;N;;;;;
 0561;ARMENIAN SMALL LETTER AYB;Ll;0;L;;;;;N;;;0531;;0531
 0562;ARMENIAN SMALL LETTER BEN;Ll;0;L;;;;;N;;;0532;;0532
 0563;ARMENIAN SMALL LETTER GIM;Ll;0;L;;;;;N;;;0533;;0533
@@ -1401,6 +1402,7 @@
 0585;ARMENIAN SMALL LETTER OH;Ll;0;L;;;;;N;;;0555;;0555
 0586;ARMENIAN SMALL LETTER FEH;Ll;0;L;;;;;N;;;0556;;0556
 0587;ARMENIAN SMALL LIGATURE ECH YIWN;Ll;0;L;<compat> 0565 0582;;;;N;;;;;
+0588;ARMENIAN SMALL LETTER YI WITH STROKE;Ll;0;L;;;;;N;;;;;
 0589;ARMENIAN FULL STOP;Po;0;L;;;;;N;ARMENIAN PERIOD;;;;
 058A;ARMENIAN HYPHEN;Pd;0;ON;;;;;N;;;;;
 058D;RIGHT-FACING ARMENIAN ETERNITY SIGN;So;0;ON;;;;;N;;;;;
@@ -1488,6 +1490,7 @@
 05E8;HEBREW LETTER RESH;Lo;0;R;;;;;N;;;;;
 05E9;HEBREW LETTER SHIN;Lo;0;R;;;;;N;;;;;
 05EA;HEBREW LETTER TAV;Lo;0;R;;;;;N;;;;;
+05EF;HEBREW YOD TRIANGLE;Lo;0;R;;;;;N;;;;;
 05F0;HEBREW LIGATURE YIDDISH DOUBLE VAV;Lo;0;R;;;;;N;HEBREW LETTER DOUBLE VAV;;;;
 05F1;HEBREW LIGATURE YIDDISH VAV YOD;Lo;0;R;;;;;N;HEBREW LETTER VAV YOD;;;;
 05F2;HEBREW LIGATURE YIDDISH DOUBLE YOD;Lo;0;R;;;;;N;HEBREW LETTER DOUBLE YOD;;;;
@@ -1522,6 +1525,7 @@
 061A;ARABIC SMALL KASRA;Mn;32;NSM;;;;;N;;;;;
 061B;ARABIC SEMICOLON;Po;0;AL;;;;;N;;;;;
 061C;ARABIC LETTER MARK;Cf;0;AL;;;;;N;;;;;
+061D;ARABIC END OF TEXT MARK;Po;0;AL;;;;;N;;;;;
 061E;ARABIC TRIPLE DOT PUNCTUATION MARK;Po;0;AL;;;;;N;;;;;
 061F;ARABIC QUESTION MARK;Po;0;AL;;;;;N;;;;;
 0620;ARABIC LETTER KASHMIRI YEH;Lo;0;AL;;;;;N;;;;;
@@ -1982,6 +1986,9 @@
 07F8;NKO COMMA;Po;0;ON;;;;;N;;;;;
 07F9;NKO EXCLAMATION MARK;Po;0;ON;;;;;N;;;;;
 07FA;NKO LAJANYALAN;Lm;0;R;;;;;N;;;;;
+07FD;NKO DANTAYALAN;Mn;220;NSM;;;;;N;;;;;
+07FE;NKO DOROME SIGN;Sc;0;R;;;;;N;;;;;
+07FF;NKO TAMAN SIGN;Sc;0;R;;;;;N;;;;;
 0800;SAMARITAN LETTER ALAF;Lo;0;R;;;;;N;;;;;
 0801;SAMARITAN LETTER BIT;Lo;0;R;;;;;N;;;;;
 0802;SAMARITAN LETTER GAMAN;Lo;0;R;;;;;N;;;;;
@@ -2072,6 +2079,60 @@
 085A;MANDAIC VOCALIZATION MARK;Mn;220;NSM;;;;;N;;;;;
 085B;MANDAIC GEMINATION MARK;Mn;220;NSM;;;;;N;;;;;
 085E;MANDAIC PUNCTUATION;Po;0;R;;;;;N;;;;;
+0860;SYRIAC LETTER MALAYALAM NGA;Lo;0;AL;;;;;N;;;;;
+0861;SYRIAC LETTER MALAYALAM JA;Lo;0;AL;;;;;N;;;;;
+0862;SYRIAC LETTER MALAYALAM NYA;Lo;0;AL;;;;;N;;;;;
+0863;SYRIAC LETTER MALAYALAM TTA;Lo;0;AL;;;;;N;;;;;
+0864;SYRIAC LETTER MALAYALAM NNA;Lo;0;AL;;;;;N;;;;;
+0865;SYRIAC LETTER MALAYALAM NNNA;Lo;0;AL;;;;;N;;;;;
+0866;SYRIAC LETTER MALAYALAM BHA;Lo;0;AL;;;;;N;;;;;
+0867;SYRIAC LETTER MALAYALAM RA;Lo;0;AL;;;;;N;;;;;
+0868;SYRIAC LETTER MALAYALAM LLA;Lo;0;AL;;;;;N;;;;;
+0869;SYRIAC LETTER MALAYALAM LLLA;Lo;0;AL;;;;;N;;;;;
+086A;SYRIAC LETTER MALAYALAM SSA;Lo;0;AL;;;;;N;;;;;
+0870;ARABIC LETTER ALEF WITH ATTACHED FATHA;Lo;0;AL;;;;;N;;;;;
+0871;ARABIC LETTER ALEF WITH ATTACHED TOP RIGHT FATHA;Lo;0;AL;;;;;N;;;;;
+0872;ARABIC LETTER ALEF WITH RIGHT MIDDLE STROKE;Lo;0;AL;;;;;N;;;;;
+0873;ARABIC LETTER ALEF WITH LEFT MIDDLE STROKE;Lo;0;AL;;;;;N;;;;;
+0874;ARABIC LETTER ALEF WITH ATTACHED KASRA;Lo;0;AL;;;;;N;;;;;
+0875;ARABIC LETTER ALEF WITH ATTACHED BOTTOM RIGHT KASRA;Lo;0;AL;;;;;N;;;;;
+0876;ARABIC LETTER ALEF WITH ATTACHED ROUND DOT ABOVE;Lo;0;AL;;;;;N;;;;;
+0877;ARABIC LETTER ALEF WITH ATTACHED RIGHT ROUND DOT;Lo;0;AL;;;;;N;;;;;
+0878;ARABIC LETTER ALEF WITH ATTACHED LEFT ROUND DOT;Lo;0;AL;;;;;N;;;;;
+0879;ARABIC LETTER ALEF WITH ATTACHED ROUND DOT BELOW;Lo;0;AL;;;;;N;;;;;
+087A;ARABIC LETTER ALEF WITH DOT ABOVE;Lo;0;AL;;;;;N;;;;;
+087B;ARABIC LETTER ALEF WITH ATTACHED TOP RIGHT FATHA AND DOT ABOVE;Lo;0;AL;;;;;N;;;;;
+087C;ARABIC LETTER ALEF WITH RIGHT MIDDLE STROKE AND DOT ABOVE;Lo;0;AL;;;;;N;;;;;
+087D;ARABIC LETTER ALEF WITH ATTACHED BOTTOM RIGHT KASRA AND DOT ABOVE;Lo;0;AL;;;;;N;;;;;
+087E;ARABIC LETTER ALEF WITH ATTACHED TOP RIGHT FATHA AND LEFT RING;Lo;0;AL;;;;;N;;;;;
+087F;ARABIC LETTER ALEF WITH RIGHT MIDDLE STROKE AND LEFT RING;Lo;0;AL;;;;;N;;;;;
+0880;ARABIC LETTER ALEF WITH ATTACHED BOTTOM RIGHT KASRA AND LEFT RING;Lo;0;AL;;;;;N;;;;;
+0881;ARABIC LETTER ALEF WITH ATTACHED RIGHT HAMZA;Lo;0;AL;;;;;N;;;;;
+0882;ARABIC LETTER ALEF WITH ATTACHED LEFT HAMZA;Lo;0;AL;;;;;N;;;;;
+0883;ARABIC TATWEEL WITH OVERSTRUCK HAMZA;Lo;0;AL;;;;;N;;;;;
+0884;ARABIC TATWEEL WITH OVERSTRUCK WAW;Lo;0;AL;;;;;N;;;;;
+0885;ARABIC TATWEEL WITH TWO DOTS BELOW;Lo;0;AL;;;;;N;;;;;
+0886;ARABIC LETTER THIN YEH;Lo;0;AL;;;;;N;;;;;
+0887;ARABIC BASELINE ROUND DOT;Lo;0;AL;;;;;N;;;;;
+0888;ARABIC RAISED ROUND DOT;Sk;0;AL;;;;;N;;;;;
+0889;ARABIC LETTER NOON WITH INVERTED SMALL V;Lo;0;AL;;;;;N;;;;;
+088A;ARABIC LETTER HAH WITH INVERTED SMALL V BELOW;Lo;0;AL;;;;;N;;;;;
+088B;ARABIC LETTER TAH WITH DOT BELOW;Lo;0;AL;;;;;N;;;;;
+088C;ARABIC LETTER TAH WITH THREE DOTS BELOW;Lo;0;AL;;;;;N;;;;;
+088D;ARABIC LETTER KEHEH WITH TWO DOTS VERTICALLY BELOW;Lo;0;AL;;;;;N;;;;;
+088E;ARABIC VERTICAL TAIL;Lo;0;AL;;;;;N;;;;;
+088F;ARABIC LETTER NOON WITH RING ABOVE;Lo;0;AL;;;;;N;;;;;
+0890;ARABIC POUND MARK ABOVE;Cf;0;AN;;;;;N;;;;;
+0891;ARABIC PIASTRE MARK ABOVE;Cf;0;AN;;;;;N;;;;;
+0897;ARABIC PEPET;Mn;230;NSM;;;;;N;;;;;
+0898;ARABIC SMALL HIGH WORD AL-JUZ;Mn;230;NSM;;;;;N;;;;;
+0899;ARABIC SMALL LOW WORD ISHMAAM;Mn;220;NSM;;;;;N;;;;;
+089A;ARABIC SMALL LOW WORD IMAALA;Mn;220;NSM;;;;;N;;;;;
+089B;ARABIC SMALL LOW WORD TASHEEL;Mn;220;NSM;;;;;N;;;;;
+089C;ARABIC MADDA WAAJIB;Mn;230;NSM;;;;;N;;;;;
+089D;ARABIC SUPERSCRIPT ALEF MOKHASSAS;Mn;230;NSM;;;;;N;;;;;
+089E;ARABIC DOUBLED MADDA;Mn;230;NSM;;;;;N;;;;;
+089F;ARABIC HALF MADDA OVER MADDA;Mn;230;NSM;;;;;N;;;;;
 08A0;ARABIC LETTER BEH WITH SMALL V BELOW;Lo;0;AL;;;;;N;;;;;
 08A1;ARABIC LETTER BEH WITH HAMZA ABOVE;Lo;0;AL;;;;;N;;;;;
 08A2;ARABIC LETTER JEEM WITH TWO DOTS ABOVE;Lo;0;AL;;;;;N;;;;;
@@ -2091,6 +2152,55 @@
 08B0;ARABIC LETTER GAF WITH INVERTED STROKE;Lo;0;AL;;;;;N;;;;;
 08B1;ARABIC LETTER STRAIGHT WAW;Lo;0;AL;;;;;N;;;;;
 08B2;ARABIC LETTER ZAIN WITH INVERTED V ABOVE;Lo;0;AL;;;;;N;;;;;
+08B3;ARABIC LETTER AIN WITH THREE DOTS BELOW;Lo;0;AL;;;;;N;;;;;
+08B4;ARABIC LETTER KAF WITH DOT BELOW;Lo;0;AL;;;;;N;;;;;
+08B5;ARABIC LETTER QAF WITH DOT BELOW AND NO DOTS ABOVE;Lo;0;AL;;;;;N;;;;;
+08B6;ARABIC LETTER BEH WITH SMALL MEEM ABOVE;Lo;0;AL;;;;;N;;;;;
+08B7;ARABIC LETTER PEH WITH SMALL MEEM ABOVE;Lo;0;AL;;;;;N;;;;;
+08B8;ARABIC LETTER TEH WITH SMALL TEH ABOVE;Lo;0;AL;;;;;N;;;;;
+08B9;ARABIC LETTER REH WITH SMALL NOON ABOVE;Lo;0;AL;;;;;N;;;;;
+08BA;ARABIC LETTER YEH WITH TWO DOTS BELOW AND SMALL NOON ABOVE;Lo;0;AL;;;;;N;;;;;
+08BB;ARABIC LETTER AFRICAN FEH;Lo;0;AL;;;;;N;;;;;
+08BC;ARABIC LETTER AFRICAN QAF;Lo;0;AL;;;;;N;;;;;
+08BD;ARABIC LETTER AFRICAN NOON;Lo;0;AL;;;;;N;;;;;
+08BE;ARABIC LETTER PEH WITH SMALL V;Lo;0;AL;;;;;N;;;;;
+08BF;ARABIC LETTER TEH WITH SMALL V;Lo;0;AL;;;;;N;;;;;
+08C0;ARABIC LETTER TTEH WITH SMALL V;Lo;0;AL;;;;;N;;;;;
+08C1;ARABIC LETTER TCHEH WITH SMALL V;Lo;0;AL;;;;;N;;;;;
+08C2;ARABIC LETTER KEHEH WITH SMALL V;Lo;0;AL;;;;;N;;;;;
+08C3;ARABIC LETTER GHAIN WITH THREE DOTS ABOVE;Lo;0;AL;;;;;N;;;;;
+08C4;ARABIC LETTER AFRICAN QAF WITH THREE DOTS ABOVE;Lo;0;AL;;;;;N;;;;;
+08C5;ARABIC LETTER JEEM WITH THREE DOTS ABOVE;Lo;0;AL;;;;;N;;;;;
+08C6;ARABIC LETTER JEEM WITH THREE DOTS BELOW;Lo;0;AL;;;;;N;;;;;
+08C7;ARABIC LETTER LAM WITH SMALL ARABIC LETTER TAH ABOVE;Lo;0;AL;;;;;N;;;;;
+08C8;ARABIC LETTER GRAF;Lo;0;AL;;;;;N;;;;;
+08C9;ARABIC SMALL FARSI YEH;Lm;0;AL;;;;;N;;;;;
+08CA;ARABIC SMALL HIGH FARSI YEH;Mn;230;NSM;;;;;N;;;;;
+08CB;ARABIC SMALL HIGH YEH BARREE WITH TWO DOTS BELOW;Mn;230;NSM;;;;;N;;;;;
+08CC;ARABIC SMALL HIGH WORD SAH;Mn;230;NSM;;;;;N;;;;;
+08CD;ARABIC SMALL HIGH ZAH;Mn;230;NSM;;;;;N;;;;;
+08CE;ARABIC LARGE ROUND DOT ABOVE;Mn;230;NSM;;;;;N;;;;;
+08CF;ARABIC LARGE ROUND DOT BELOW;Mn;220;NSM;;;;;N;;;;;
+08D0;ARABIC SUKUN BELOW;Mn;220;NSM;;;;;N;;;;;
+08D1;ARABIC LARGE CIRCLE BELOW;Mn;220;NSM;;;;;N;;;;;
+08D2;ARABIC LARGE ROUND DOT INSIDE CIRCLE BELOW;Mn;220;NSM;;;;;N;;;;;
+08D3;ARABIC SMALL LOW WAW;Mn;220;NSM;;;;;N;;;;;
+08D4;ARABIC SMALL HIGH WORD AR-RUB;Mn;230;NSM;;;;;N;;;;;
+08D5;ARABIC SMALL HIGH SAD;Mn;230;NSM;;;;;N;;;;;
+08D6;ARABIC SMALL HIGH AIN;Mn;230;NSM;;;;;N;;;;;
+08D7;ARABIC SMALL HIGH QAF;Mn;230;NSM;;;;;N;;;;;
+08D8;ARABIC SMALL HIGH NOON WITH KASRA;Mn;230;NSM;;;;;N;;;;;
+08D9;ARABIC SMALL LOW NOON WITH KASRA;Mn;230;NSM;;;;;N;;;;;
+08DA;ARABIC SMALL HIGH WORD ATH-THALATHA;Mn;230;NSM;;;;;N;;;;;
+08DB;ARABIC SMALL HIGH WORD AS-SAJDA;Mn;230;NSM;;;;;N;;;;;
+08DC;ARABIC SMALL HIGH WORD AN-NISF;Mn;230;NSM;;;;;N;;;;;
+08DD;ARABIC SMALL HIGH WORD SAKTA;Mn;230;NSM;;;;;N;;;;;
+08DE;ARABIC SMALL HIGH WORD QIF;Mn;230;NSM;;;;;N;;;;;
+08DF;ARABIC SMALL HIGH WORD WAQFA;Mn;230;NSM;;;;;N;;;;;
+08E0;ARABIC SMALL HIGH FOOTNOTE MARKER;Mn;230;NSM;;;;;N;;;;;
+08E1;ARABIC SMALL HIGH SIGN SAFHA;Mn;230;NSM;;;;;N;;;;;
+08E2;ARABIC DISPUTED END OF AYAH;Cf;0;AN;;;;;N;;;;;
+08E3;ARABIC TURNED DAMMA BELOW;Mn;220;NSM;;;;;N;;;;;
 08E4;ARABIC CURLY FATHA;Mn;230;NSM;;;;;N;;;;;
 08E5;ARABIC CURLY DAMMA;Mn;230;NSM;;;;;N;;;;;
 08E6;ARABIC CURLY KASRA;Mn;220;NSM;;;;;N;;;;;
@@ -2340,6 +2450,9 @@
 09F9;BENGALI CURRENCY DENOMINATOR SIXTEEN;No;0;L;;;;16;N;;;;;
 09FA;BENGALI ISSHAR;So;0;L;;;;;N;;;;;
 09FB;BENGALI GANDA MARK;Sc;0;ET;;;;;N;;;;;
+09FC;BENGALI LETTER VEDIC ANUSVARA;Lo;0;L;;;;;N;;;;;
+09FD;BENGALI ABBREVIATION SIGN;Po;0;L;;;;;N;;;;;
+09FE;BENGALI SANDHI MARK;Mn;230;NSM;;;;;N;;;;;
 0A01;GURMUKHI SIGN ADAK BINDI;Mn;0;NSM;;;;;N;;;;;
 0A02;GURMUKHI SIGN BINDI;Mn;0;NSM;;;;;N;;;;;
 0A03;GURMUKHI SIGN VISARGA;Mc;0;L;;;;;N;;;;;
@@ -2419,6 +2532,7 @@
 0A73;GURMUKHI URA;Lo;0;L;;;;;N;;;;;
 0A74;GURMUKHI EK ONKAR;Lo;0;L;;;;;N;;;;;
 0A75;GURMUKHI SIGN YAKASH;Mn;0;NSM;;;;;N;;;;;
+0A76;GURMUKHI ABBREVIATION SIGN;Po;0;L;;;;;N;;;;;
 0A81;GUJARATI SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
 0A82;GUJARATI SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
 0A83;GUJARATI SIGN VISARGA;Mc;0;L;;;;;N;;;;;
@@ -2503,6 +2617,13 @@
 0AEF;GUJARATI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
 0AF0;GUJARATI ABBREVIATION SIGN;Po;0;L;;;;;N;;;;;
 0AF1;GUJARATI RUPEE SIGN;Sc;0;ET;;;;;N;;;;;
+0AF9;GUJARATI LETTER ZHA;Lo;0;L;;;;;N;;;;;
+0AFA;GUJARATI SIGN SUKUN;Mn;0;NSM;;;;;N;;;;;
+0AFB;GUJARATI SIGN SHADDA;Mn;0;NSM;;;;;N;;;;;
+0AFC;GUJARATI SIGN MADDAH;Mn;0;NSM;;;;;N;;;;;
+0AFD;GUJARATI SIGN THREE-DOT NUKTA ABOVE;Mn;0;NSM;;;;;N;;;;;
+0AFE;GUJARATI SIGN CIRCLE NUKTA ABOVE;Mn;0;NSM;;;;;N;;;;;
+0AFF;GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE;Mn;0;NSM;;;;;N;;;;;
 0B01;ORIYA SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
 0B02;ORIYA SIGN ANUSVARA;Mc;0;L;;;;;N;;;;;
 0B03;ORIYA SIGN VISARGA;Mc;0;L;;;;;N;;;;;
@@ -2566,6 +2687,7 @@
 0B4B;ORIYA VOWEL SIGN O;Mc;0;L;0B47 0B3E;;;;N;;;;;
 0B4C;ORIYA VOWEL SIGN AU;Mc;0;L;0B47 0B57;;;;N;;;;;
 0B4D;ORIYA SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;;
+0B55;ORIYA SIGN OVERLINE;Mn;0;NSM;;;;;N;;;;;
 0B56;ORIYA AI LENGTH MARK;Mn;0;NSM;;;;;N;;;;;
 0B57;ORIYA AU LENGTH MARK;Mc;0;L;;;;;N;;;;;
 0B5C;ORIYA LETTER RRA;Lo;0;L;0B21 0B3C;;;;N;;;;;
@@ -2669,6 +2791,7 @@
 0C01;TELUGU SIGN CANDRABINDU;Mc;0;L;;;;;N;;;;;
 0C02;TELUGU SIGN ANUSVARA;Mc;0;L;;;;;N;;;;;
 0C03;TELUGU SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+0C04;TELUGU SIGN COMBINING ANUSVARA ABOVE;Mn;0;NSM;;;;;N;;;;;
 0C05;TELUGU LETTER A;Lo;0;L;;;;;N;;;;;
 0C06;TELUGU LETTER AA;Lo;0;L;;;;;N;;;;;
 0C07;TELUGU LETTER I;Lo;0;L;;;;;N;;;;;
@@ -2719,6 +2842,7 @@
 0C37;TELUGU LETTER SSA;Lo;0;L;;;;;N;;;;;
 0C38;TELUGU LETTER SA;Lo;0;L;;;;;N;;;;;
 0C39;TELUGU LETTER HA;Lo;0;L;;;;;N;;;;;
+0C3C;TELUGU SIGN NUKTA;Mn;7;NSM;;;;;N;;;;;
 0C3D;TELUGU SIGN AVAGRAHA;Lo;0;L;;;;;N;;;;;
 0C3E;TELUGU VOWEL SIGN AA;Mn;0;NSM;;;;;N;;;;;
 0C3F;TELUGU VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
@@ -2738,6 +2862,9 @@
 0C56;TELUGU AI LENGTH MARK;Mn;91;NSM;;;;;N;;;;;
 0C58;TELUGU LETTER TSA;Lo;0;L;;;;;N;;;;;
 0C59;TELUGU LETTER DZA;Lo;0;L;;;;;N;;;;;
+0C5A;TELUGU LETTER RRRA;Lo;0;L;;;;;N;;;;;
+0C5C;TELUGU ARCHAIC SHRII;Lo;0;L;;;;;N;;;;;
+0C5D;TELUGU LETTER NAKAARA POLLU;Lo;0;L;;;;;N;;;;;
 0C60;TELUGU LETTER VOCALIC RR;Lo;0;L;;;;;N;;;;;
 0C61;TELUGU LETTER VOCALIC LL;Lo;0;L;;;;;N;;;;;
 0C62;TELUGU VOWEL SIGN VOCALIC L;Mn;0;NSM;;;;;N;;;;;
@@ -2752,6 +2879,7 @@
 0C6D;TELUGU DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
 0C6E;TELUGU DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
 0C6F;TELUGU DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+0C77;TELUGU SIGN SIDDHAM;Po;0;L;;;;;N;;;;;
 0C78;TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR;No;0;ON;;;;0;N;;;;;
 0C79;TELUGU FRACTION DIGIT ONE FOR ODD POWERS OF FOUR;No;0;ON;;;;1;N;;;;;
 0C7A;TELUGU FRACTION DIGIT TWO FOR ODD POWERS OF FOUR;No;0;ON;;;;2;N;;;;;
@@ -2760,9 +2888,11 @@
 0C7D;TELUGU FRACTION DIGIT TWO FOR EVEN POWERS OF FOUR;No;0;ON;;;;2;N;;;;;
 0C7E;TELUGU FRACTION DIGIT THREE FOR EVEN POWERS OF FOUR;No;0;ON;;;;3;N;;;;;
 0C7F;TELUGU SIGN TUUMU;So;0;L;;;;;N;;;;;
+0C80;KANNADA SIGN SPACING CANDRABINDU;Lo;0;L;;;;;N;;;;;
 0C81;KANNADA SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
 0C82;KANNADA SIGN ANUSVARA;Mc;0;L;;;;;N;;;;;
 0C83;KANNADA SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+0C84;KANNADA SIGN SIDDHAM;Po;0;L;;;;;N;;;;;
 0C85;KANNADA LETTER A;Lo;0;L;;;;;N;;;;;
 0C86;KANNADA LETTER AA;Lo;0;L;;;;;N;;;;;
 0C87;KANNADA LETTER I;Lo;0;L;;;;;N;;;;;
@@ -2830,6 +2960,8 @@
 0CCD;KANNADA SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;;
 0CD5;KANNADA LENGTH MARK;Mc;0;L;;;;;N;;;;;
 0CD6;KANNADA AI LENGTH MARK;Mc;0;L;;;;;N;;;;;
+0CDC;KANNADA ARCHAIC SHRII;Lo;0;L;;;;;N;;;;;
+0CDD;KANNADA LETTER NAKAARA POLLU;Lo;0;L;;;;;N;;;;;
 0CDE;KANNADA LETTER FA;Lo;0;L;;;;;N;;;;;
 0CE0;KANNADA LETTER VOCALIC RR;Lo;0;L;;;;;N;;;;;
 0CE1;KANNADA LETTER VOCALIC LL;Lo;0;L;;;;;N;;;;;
@@ -2847,9 +2979,12 @@
 0CEF;KANNADA DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
 0CF1;KANNADA SIGN JIHVAMULIYA;Lo;0;L;;;;;N;;;;;
 0CF2;KANNADA SIGN UPADHMANIYA;Lo;0;L;;;;;N;;;;;
+0CF3;KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT;Mc;0;L;;;;;N;;;;;
+0D00;MALAYALAM SIGN COMBINING ANUSVARA ABOVE;Mn;0;NSM;;;;;N;;;;;
 0D01;MALAYALAM SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
 0D02;MALAYALAM SIGN ANUSVARA;Mc;0;L;;;;;N;;;;;
 0D03;MALAYALAM SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+0D04;MALAYALAM LETTER VEDIC ANUSVARA;Lo;0;L;;;;;N;;;;;
 0D05;MALAYALAM LETTER A;Lo;0;L;;;;;N;;;;;
 0D06;MALAYALAM LETTER AA;Lo;0;L;;;;;N;;;;;
 0D07;MALAYALAM LETTER I;Lo;0;L;;;;;N;;;;;
@@ -2902,6 +3037,8 @@
 0D38;MALAYALAM LETTER SA;Lo;0;L;;;;;N;;;;;
 0D39;MALAYALAM LETTER HA;Lo;0;L;;;;;N;;;;;
 0D3A;MALAYALAM LETTER TTTA;Lo;0;L;;;;;N;;;;;
+0D3B;MALAYALAM SIGN VERTICAL BAR VIRAMA;Mn;9;NSM;;;;;N;;;;;
+0D3C;MALAYALAM SIGN CIRCULAR VIRAMA;Mn;9;NSM;;;;;N;;;;;
 0D3D;MALAYALAM SIGN AVAGRAHA;Lo;0;L;;;;;N;;;;;
 0D3E;MALAYALAM VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
 0D3F;MALAYALAM VOWEL SIGN I;Mc;0;L;;;;;N;;;;;
@@ -2918,7 +3055,19 @@
 0D4C;MALAYALAM VOWEL SIGN AU;Mc;0;L;0D46 0D57;;;;N;;;;;
 0D4D;MALAYALAM SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;;
 0D4E;MALAYALAM LETTER DOT REPH;Lo;0;L;;;;;N;;;;;
+0D4F;MALAYALAM SIGN PARA;So;0;L;;;;;N;;;;;
+0D54;MALAYALAM LETTER CHILLU M;Lo;0;L;;;;;N;;;;;
+0D55;MALAYALAM LETTER CHILLU Y;Lo;0;L;;;;;N;;;;;
+0D56;MALAYALAM LETTER CHILLU LLL;Lo;0;L;;;;;N;;;;;
 0D57;MALAYALAM AU LENGTH MARK;Mc;0;L;;;;;N;;;;;
+0D58;MALAYALAM FRACTION ONE ONE-HUNDRED-AND-SIXTIETH;No;0;L;;;;1/160;N;;;;;
+0D59;MALAYALAM FRACTION ONE FORTIETH;No;0;L;;;;1/40;N;;;;;
+0D5A;MALAYALAM FRACTION THREE EIGHTIETHS;No;0;L;;;;3/80;N;;;;;
+0D5B;MALAYALAM FRACTION ONE TWENTIETH;No;0;L;;;;1/20;N;;;;;
+0D5C;MALAYALAM FRACTION ONE TENTH;No;0;L;;;;1/10;N;;;;;
+0D5D;MALAYALAM FRACTION THREE TWENTIETHS;No;0;L;;;;3/20;N;;;;;
+0D5E;MALAYALAM FRACTION ONE FIFTH;No;0;L;;;;1/5;N;;;;;
+0D5F;MALAYALAM LETTER ARCHAIC II;Lo;0;L;;;;;N;;;;;
 0D60;MALAYALAM LETTER VOCALIC RR;Lo;0;L;;;;;N;;;;;
 0D61;MALAYALAM LETTER VOCALIC LL;Lo;0;L;;;;;N;;;;;
 0D62;MALAYALAM VOWEL SIGN VOCALIC L;Mn;0;NSM;;;;;N;;;;;
@@ -2939,6 +3088,9 @@
 0D73;MALAYALAM FRACTION ONE QUARTER;No;0;L;;;;1/4;N;;;;;
 0D74;MALAYALAM FRACTION ONE HALF;No;0;L;;;;1/2;N;;;;;
 0D75;MALAYALAM FRACTION THREE QUARTERS;No;0;L;;;;3/4;N;;;;;
+0D76;MALAYALAM FRACTION ONE SIXTEENTH;No;0;L;;;;1/16;N;;;;;
+0D77;MALAYALAM FRACTION ONE EIGHTH;No;0;L;;;;1/8;N;;;;;
+0D78;MALAYALAM FRACTION THREE SIXTEENTHS;No;0;L;;;;3/16;N;;;;;
 0D79;MALAYALAM DATE MARK;So;0;L;;;;;N;;;;;
 0D7A;MALAYALAM LETTER CHILLU NN;Lo;0;L;;;;;N;;;;;
 0D7B;MALAYALAM LETTER CHILLU N;Lo;0;L;;;;;N;;;;;
@@ -2946,6 +3098,7 @@
 0D7D;MALAYALAM LETTER CHILLU L;Lo;0;L;;;;;N;;;;;
 0D7E;MALAYALAM LETTER CHILLU LL;Lo;0;L;;;;;N;;;;;
 0D7F;MALAYALAM LETTER CHILLU K;Lo;0;L;;;;;N;;;;;
+0D81;SINHALA SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
 0D82;SINHALA SIGN ANUSVARAYA;Mc;0;L;;;;;N;;;;;
 0D83;SINHALA SIGN VISARGAYA;Mc;0;L;;;;;N;;;;;
 0D85;SINHALA LETTER AYANNA;Lo;0;L;;;;;N;;;;;
@@ -3126,14 +3279,24 @@
 0E81;LAO LETTER KO;Lo;0;L;;;;;N;;;;;
 0E82;LAO LETTER KHO SUNG;Lo;0;L;;;;;N;;;;;
 0E84;LAO LETTER KHO TAM;Lo;0;L;;;;;N;;;;;
+0E86;LAO LETTER PALI GHA;Lo;0;L;;;;;N;;;;;
 0E87;LAO LETTER NGO;Lo;0;L;;;;;N;;;;;
 0E88;LAO LETTER CO;Lo;0;L;;;;;N;;;;;
+0E89;LAO LETTER PALI CHA;Lo;0;L;;;;;N;;;;;
 0E8A;LAO LETTER SO TAM;Lo;0;L;;;;;N;;;;;
+0E8C;LAO LETTER PALI JHA;Lo;0;L;;;;;N;;;;;
 0E8D;LAO LETTER NYO;Lo;0;L;;;;;N;;;;;
+0E8E;LAO LETTER PALI NYA;Lo;0;L;;;;;N;;;;;
+0E8F;LAO LETTER PALI TTA;Lo;0;L;;;;;N;;;;;
+0E90;LAO LETTER PALI TTHA;Lo;0;L;;;;;N;;;;;
+0E91;LAO LETTER PALI DDA;Lo;0;L;;;;;N;;;;;
+0E92;LAO LETTER PALI DDHA;Lo;0;L;;;;;N;;;;;
+0E93;LAO LETTER PALI NNA;Lo;0;L;;;;;N;;;;;
 0E94;LAO LETTER DO;Lo;0;L;;;;;N;;;;;
 0E95;LAO LETTER TO;Lo;0;L;;;;;N;;;;;
 0E96;LAO LETTER THO SUNG;Lo;0;L;;;;;N;;;;;
 0E97;LAO LETTER THO TAM;Lo;0;L;;;;;N;;;;;
+0E98;LAO LETTER PALI DHA;Lo;0;L;;;;;N;;;;;
 0E99;LAO LETTER NO;Lo;0;L;;;;;N;;;;;
 0E9A;LAO LETTER BO;Lo;0;L;;;;;N;;;;;
 0E9B;LAO LETTER PO;Lo;0;L;;;;;N;;;;;
@@ -3141,13 +3304,17 @@
 0E9D;LAO LETTER FO TAM;Lo;0;L;;;;;N;;;;;
 0E9E;LAO LETTER PHO TAM;Lo;0;L;;;;;N;;;;;
 0E9F;LAO LETTER FO SUNG;Lo;0;L;;;;;N;;;;;
+0EA0;LAO LETTER PALI BHA;Lo;0;L;;;;;N;;;;;
 0EA1;LAO LETTER MO;Lo;0;L;;;;;N;;;;;
 0EA2;LAO LETTER YO;Lo;0;L;;;;;N;;;;;
 0EA3;LAO LETTER LO LING;Lo;0;L;;;;;N;;;;;
 0EA5;LAO LETTER LO LOOT;Lo;0;L;;;;;N;;;;;
 0EA7;LAO LETTER WO;Lo;0;L;;;;;N;;;;;
+0EA8;LAO LETTER SANSKRIT SHA;Lo;0;L;;;;;N;;;;;
+0EA9;LAO LETTER SANSKRIT SSA;Lo;0;L;;;;;N;;;;;
 0EAA;LAO LETTER SO SUNG;Lo;0;L;;;;;N;;;;;
 0EAB;LAO LETTER HO SUNG;Lo;0;L;;;;;N;;;;;
+0EAC;LAO LETTER PALI LLA;Lo;0;L;;;;;N;;;;;
 0EAD;LAO LETTER O;Lo;0;L;;;;;N;;;;;
 0EAE;LAO LETTER HO TAM;Lo;0;L;;;;;N;;;;;
 0EAF;LAO ELLIPSIS;Lo;0;L;;;;;N;;;;;
@@ -3161,6 +3328,7 @@
 0EB7;LAO VOWEL SIGN YY;Mn;0;NSM;;;;;N;;;;;
 0EB8;LAO VOWEL SIGN U;Mn;118;NSM;;;;;N;;;;;
 0EB9;LAO VOWEL SIGN UU;Mn;118;NSM;;;;;N;;;;;
+0EBA;LAO SIGN PALI VIRAMA;Mn;9;NSM;;;;;N;;;;;
 0EBB;LAO VOWEL SIGN MAI KON;Mn;0;NSM;;;;;N;;;;;
 0EBC;LAO SEMIVOWEL SIGN LO;Mn;0;NSM;;;;;N;;;;;
 0EBD;LAO SEMIVOWEL SIGN NYO;Lo;0;L;;;;;N;;;;;
@@ -3176,6 +3344,7 @@
 0ECB;LAO TONE MAI CATAWA;Mn;122;NSM;;;;;N;;;;;
 0ECC;LAO CANCELLATION MARK;Mn;0;NSM;;;;;N;;;;;
 0ECD;LAO NIGGAHITA;Mn;0;NSM;;;;;N;;;;;
+0ECE;LAO YAMAKKAN;Mn;0;NSM;;;;;N;;;;;
 0ED0;LAO DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
 0ED1;LAO DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
 0ED2;LAO DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
@@ -3601,54 +3770,54 @@
 10C5;GEORGIAN CAPITAL LETTER HOE;Lu;0;L;;;;;N;;;;2D25;
 10C7;GEORGIAN CAPITAL LETTER YN;Lu;0;L;;;;;N;;;;2D27;
 10CD;GEORGIAN CAPITAL LETTER AEN;Lu;0;L;;;;;N;;;;2D2D;
-10D0;GEORGIAN LETTER AN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER AN;;;;
-10D1;GEORGIAN LETTER BAN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER BAN;;;;
-10D2;GEORGIAN LETTER GAN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER GAN;;;;
-10D3;GEORGIAN LETTER DON;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER DON;;;;
-10D4;GEORGIAN LETTER EN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER EN;;;;
-10D5;GEORGIAN LETTER VIN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER VIN;;;;
-10D6;GEORGIAN LETTER ZEN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER ZEN;;;;
-10D7;GEORGIAN LETTER TAN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER TAN;;;;
-10D8;GEORGIAN LETTER IN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER IN;;;;
-10D9;GEORGIAN LETTER KAN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER KAN;;;;
-10DA;GEORGIAN LETTER LAS;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER LAS;;;;
-10DB;GEORGIAN LETTER MAN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER MAN;;;;
-10DC;GEORGIAN LETTER NAR;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER NAR;;;;
-10DD;GEORGIAN LETTER ON;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER ON;;;;
-10DE;GEORGIAN LETTER PAR;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER PAR;;;;
-10DF;GEORGIAN LETTER ZHAR;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER ZHAR;;;;
-10E0;GEORGIAN LETTER RAE;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER RAE;;;;
-10E1;GEORGIAN LETTER SAN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER SAN;;;;
-10E2;GEORGIAN LETTER TAR;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER TAR;;;;
-10E3;GEORGIAN LETTER UN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER UN;;;;
-10E4;GEORGIAN LETTER PHAR;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER PHAR;;;;
-10E5;GEORGIAN LETTER KHAR;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER KHAR;;;;
-10E6;GEORGIAN LETTER GHAN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER GHAN;;;;
-10E7;GEORGIAN LETTER QAR;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER QAR;;;;
-10E8;GEORGIAN LETTER SHIN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER SHIN;;;;
-10E9;GEORGIAN LETTER CHIN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER CHIN;;;;
-10EA;GEORGIAN LETTER CAN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER CAN;;;;
-10EB;GEORGIAN LETTER JIL;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER JIL;;;;
-10EC;GEORGIAN LETTER CIL;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER CIL;;;;
-10ED;GEORGIAN LETTER CHAR;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER CHAR;;;;
-10EE;GEORGIAN LETTER XAN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER XAN;;;;
-10EF;GEORGIAN LETTER JHAN;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER JHAN;;;;
-10F0;GEORGIAN LETTER HAE;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER HAE;;;;
-10F1;GEORGIAN LETTER HE;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER HE;;;;
-10F2;GEORGIAN LETTER HIE;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER HIE;;;;
-10F3;GEORGIAN LETTER WE;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER WE;;;;
-10F4;GEORGIAN LETTER HAR;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER HAR;;;;
-10F5;GEORGIAN LETTER HOE;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER HOE;;;;
-10F6;GEORGIAN LETTER FI;Lo;0;L;;;;;N;GEORGIAN SMALL LETTER FI;;;;
-10F7;GEORGIAN LETTER YN;Lo;0;L;;;;;N;;;;;
-10F8;GEORGIAN LETTER ELIFI;Lo;0;L;;;;;N;;;;;
-10F9;GEORGIAN LETTER TURNED GAN;Lo;0;L;;;;;N;;;;;
-10FA;GEORGIAN LETTER AIN;Lo;0;L;;;;;N;;;;;
+10D0;GEORGIAN LETTER AN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER AN;;1C90;;10D0
+10D1;GEORGIAN LETTER BAN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER BAN;;1C91;;10D1
+10D2;GEORGIAN LETTER GAN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER GAN;;1C92;;10D2
+10D3;GEORGIAN LETTER DON;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER DON;;1C93;;10D3
+10D4;GEORGIAN LETTER EN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER EN;;1C94;;10D4
+10D5;GEORGIAN LETTER VIN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER VIN;;1C95;;10D5
+10D6;GEORGIAN LETTER ZEN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER ZEN;;1C96;;10D6
+10D7;GEORGIAN LETTER TAN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER TAN;;1C97;;10D7
+10D8;GEORGIAN LETTER IN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER IN;;1C98;;10D8
+10D9;GEORGIAN LETTER KAN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER KAN;;1C99;;10D9
+10DA;GEORGIAN LETTER LAS;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER LAS;;1C9A;;10DA
+10DB;GEORGIAN LETTER MAN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER MAN;;1C9B;;10DB
+10DC;GEORGIAN LETTER NAR;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER NAR;;1C9C;;10DC
+10DD;GEORGIAN LETTER ON;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER ON;;1C9D;;10DD
+10DE;GEORGIAN LETTER PAR;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER PAR;;1C9E;;10DE
+10DF;GEORGIAN LETTER ZHAR;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER ZHAR;;1C9F;;10DF
+10E0;GEORGIAN LETTER RAE;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER RAE;;1CA0;;10E0
+10E1;GEORGIAN LETTER SAN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER SAN;;1CA1;;10E1
+10E2;GEORGIAN LETTER TAR;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER TAR;;1CA2;;10E2
+10E3;GEORGIAN LETTER UN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER UN;;1CA3;;10E3
+10E4;GEORGIAN LETTER PHAR;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER PHAR;;1CA4;;10E4
+10E5;GEORGIAN LETTER KHAR;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER KHAR;;1CA5;;10E5
+10E6;GEORGIAN LETTER GHAN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER GHAN;;1CA6;;10E6
+10E7;GEORGIAN LETTER QAR;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER QAR;;1CA7;;10E7
+10E8;GEORGIAN LETTER SHIN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER SHIN;;1CA8;;10E8
+10E9;GEORGIAN LETTER CHIN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER CHIN;;1CA9;;10E9
+10EA;GEORGIAN LETTER CAN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER CAN;;1CAA;;10EA
+10EB;GEORGIAN LETTER JIL;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER JIL;;1CAB;;10EB
+10EC;GEORGIAN LETTER CIL;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER CIL;;1CAC;;10EC
+10ED;GEORGIAN LETTER CHAR;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER CHAR;;1CAD;;10ED
+10EE;GEORGIAN LETTER XAN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER XAN;;1CAE;;10EE
+10EF;GEORGIAN LETTER JHAN;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER JHAN;;1CAF;;10EF
+10F0;GEORGIAN LETTER HAE;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER HAE;;1CB0;;10F0
+10F1;GEORGIAN LETTER HE;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER HE;;1CB1;;10F1
+10F2;GEORGIAN LETTER HIE;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER HIE;;1CB2;;10F2
+10F3;GEORGIAN LETTER WE;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER WE;;1CB3;;10F3
+10F4;GEORGIAN LETTER HAR;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER HAR;;1CB4;;10F4
+10F5;GEORGIAN LETTER HOE;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER HOE;;1CB5;;10F5
+10F6;GEORGIAN LETTER FI;Ll;0;L;;;;;N;GEORGIAN SMALL LETTER FI;;1CB6;;10F6
+10F7;GEORGIAN LETTER YN;Ll;0;L;;;;;N;;;1CB7;;10F7
+10F8;GEORGIAN LETTER ELIFI;Ll;0;L;;;;;N;;;1CB8;;10F8
+10F9;GEORGIAN LETTER TURNED GAN;Ll;0;L;;;;;N;;;1CB9;;10F9
+10FA;GEORGIAN LETTER AIN;Ll;0;L;;;;;N;;;1CBA;;10FA
 10FB;GEORGIAN PARAGRAPH SEPARATOR;Po;0;L;;;;;N;;;;;
 10FC;MODIFIER LETTER GEORGIAN NAR;Lm;0;L;<super> 10DC;;;;N;;;;;
-10FD;GEORGIAN LETTER AEN;Lo;0;L;;;;;N;;;;;
-10FE;GEORGIAN LETTER HARD SIGN;Lo;0;L;;;;;N;;;;;
-10FF;GEORGIAN LETTER LABIAL SIGN;Lo;0;L;;;;;N;;;;;
+10FD;GEORGIAN LETTER AEN;Ll;0;L;;;;;N;;;1CBD;;10FD
+10FE;GEORGIAN LETTER HARD SIGN;Ll;0;L;;;;;N;;;1CBE;;10FE
+10FF;GEORGIAN LETTER LABIAL SIGN;Ll;0;L;;;;;N;;;1CBF;;10FF
 1100;HANGUL CHOSEONG KIYEOK;Lo;0;L;;;;;N;;;;;
 1101;HANGUL CHOSEONG SSANGKIYEOK;Lo;0;L;;;;;N;;;;;
 1102;HANGUL CHOSEONG NIEUN;Lo;0;L;;;;;N;;;;;
@@ -4289,91 +4458,98 @@
 1397;ETHIOPIC TONAL MARK HIDET;So;0;ON;;;;;N;;;;;
 1398;ETHIOPIC TONAL MARK DERET-HIDET;So;0;ON;;;;;N;;;;;
 1399;ETHIOPIC TONAL MARK KURT;So;0;ON;;;;;N;;;;;
-13A0;CHEROKEE LETTER A;Lo;0;L;;;;;N;;;;;
-13A1;CHEROKEE LETTER E;Lo;0;L;;;;;N;;;;;
-13A2;CHEROKEE LETTER I;Lo;0;L;;;;;N;;;;;
-13A3;CHEROKEE LETTER O;Lo;0;L;;;;;N;;;;;
-13A4;CHEROKEE LETTER U;Lo;0;L;;;;;N;;;;;
-13A5;CHEROKEE LETTER V;Lo;0;L;;;;;N;;;;;
-13A6;CHEROKEE LETTER GA;Lo;0;L;;;;;N;;;;;
-13A7;CHEROKEE LETTER KA;Lo;0;L;;;;;N;;;;;
-13A8;CHEROKEE LETTER GE;Lo;0;L;;;;;N;;;;;
-13A9;CHEROKEE LETTER GI;Lo;0;L;;;;;N;;;;;
-13AA;CHEROKEE LETTER GO;Lo;0;L;;;;;N;;;;;
-13AB;CHEROKEE LETTER GU;Lo;0;L;;;;;N;;;;;
-13AC;CHEROKEE LETTER GV;Lo;0;L;;;;;N;;;;;
-13AD;CHEROKEE LETTER HA;Lo;0;L;;;;;N;;;;;
-13AE;CHEROKEE LETTER HE;Lo;0;L;;;;;N;;;;;
-13AF;CHEROKEE LETTER HI;Lo;0;L;;;;;N;;;;;
-13B0;CHEROKEE LETTER HO;Lo;0;L;;;;;N;;;;;
-13B1;CHEROKEE LETTER HU;Lo;0;L;;;;;N;;;;;
-13B2;CHEROKEE LETTER HV;Lo;0;L;;;;;N;;;;;
-13B3;CHEROKEE LETTER LA;Lo;0;L;;;;;N;;;;;
-13B4;CHEROKEE LETTER LE;Lo;0;L;;;;;N;;;;;
-13B5;CHEROKEE LETTER LI;Lo;0;L;;;;;N;;;;;
-13B6;CHEROKEE LETTER LO;Lo;0;L;;;;;N;;;;;
-13B7;CHEROKEE LETTER LU;Lo;0;L;;;;;N;;;;;
-13B8;CHEROKEE LETTER LV;Lo;0;L;;;;;N;;;;;
-13B9;CHEROKEE LETTER MA;Lo;0;L;;;;;N;;;;;
-13BA;CHEROKEE LETTER ME;Lo;0;L;;;;;N;;;;;
-13BB;CHEROKEE LETTER MI;Lo;0;L;;;;;N;;;;;
-13BC;CHEROKEE LETTER MO;Lo;0;L;;;;;N;;;;;
-13BD;CHEROKEE LETTER MU;Lo;0;L;;;;;N;;;;;
-13BE;CHEROKEE LETTER NA;Lo;0;L;;;;;N;;;;;
-13BF;CHEROKEE LETTER HNA;Lo;0;L;;;;;N;;;;;
-13C0;CHEROKEE LETTER NAH;Lo;0;L;;;;;N;;;;;
-13C1;CHEROKEE LETTER NE;Lo;0;L;;;;;N;;;;;
-13C2;CHEROKEE LETTER NI;Lo;0;L;;;;;N;;;;;
-13C3;CHEROKEE LETTER NO;Lo;0;L;;;;;N;;;;;
-13C4;CHEROKEE LETTER NU;Lo;0;L;;;;;N;;;;;
-13C5;CHEROKEE LETTER NV;Lo;0;L;;;;;N;;;;;
-13C6;CHEROKEE LETTER QUA;Lo;0;L;;;;;N;;;;;
-13C7;CHEROKEE LETTER QUE;Lo;0;L;;;;;N;;;;;
-13C8;CHEROKEE LETTER QUI;Lo;0;L;;;;;N;;;;;
-13C9;CHEROKEE LETTER QUO;Lo;0;L;;;;;N;;;;;
-13CA;CHEROKEE LETTER QUU;Lo;0;L;;;;;N;;;;;
-13CB;CHEROKEE LETTER QUV;Lo;0;L;;;;;N;;;;;
-13CC;CHEROKEE LETTER SA;Lo;0;L;;;;;N;;;;;
-13CD;CHEROKEE LETTER S;Lo;0;L;;;;;N;;;;;
-13CE;CHEROKEE LETTER SE;Lo;0;L;;;;;N;;;;;
-13CF;CHEROKEE LETTER SI;Lo;0;L;;;;;N;;;;;
-13D0;CHEROKEE LETTER SO;Lo;0;L;;;;;N;;;;;
-13D1;CHEROKEE LETTER SU;Lo;0;L;;;;;N;;;;;
-13D2;CHEROKEE LETTER SV;Lo;0;L;;;;;N;;;;;
-13D3;CHEROKEE LETTER DA;Lo;0;L;;;;;N;;;;;
-13D4;CHEROKEE LETTER TA;Lo;0;L;;;;;N;;;;;
-13D5;CHEROKEE LETTER DE;Lo;0;L;;;;;N;;;;;
-13D6;CHEROKEE LETTER TE;Lo;0;L;;;;;N;;;;;
-13D7;CHEROKEE LETTER DI;Lo;0;L;;;;;N;;;;;
-13D8;CHEROKEE LETTER TI;Lo;0;L;;;;;N;;;;;
-13D9;CHEROKEE LETTER DO;Lo;0;L;;;;;N;;;;;
-13DA;CHEROKEE LETTER DU;Lo;0;L;;;;;N;;;;;
-13DB;CHEROKEE LETTER DV;Lo;0;L;;;;;N;;;;;
-13DC;CHEROKEE LETTER DLA;Lo;0;L;;;;;N;;;;;
-13DD;CHEROKEE LETTER TLA;Lo;0;L;;;;;N;;;;;
-13DE;CHEROKEE LETTER TLE;Lo;0;L;;;;;N;;;;;
-13DF;CHEROKEE LETTER TLI;Lo;0;L;;;;;N;;;;;
-13E0;CHEROKEE LETTER TLO;Lo;0;L;;;;;N;;;;;
-13E1;CHEROKEE LETTER TLU;Lo;0;L;;;;;N;;;;;
-13E2;CHEROKEE LETTER TLV;Lo;0;L;;;;;N;;;;;
-13E3;CHEROKEE LETTER TSA;Lo;0;L;;;;;N;;;;;
-13E4;CHEROKEE LETTER TSE;Lo;0;L;;;;;N;;;;;
-13E5;CHEROKEE LETTER TSI;Lo;0;L;;;;;N;;;;;
-13E6;CHEROKEE LETTER TSO;Lo;0;L;;;;;N;;;;;
-13E7;CHEROKEE LETTER TSU;Lo;0;L;;;;;N;;;;;
-13E8;CHEROKEE LETTER TSV;Lo;0;L;;;;;N;;;;;
-13E9;CHEROKEE LETTER WA;Lo;0;L;;;;;N;;;;;
-13EA;CHEROKEE LETTER WE;Lo;0;L;;;;;N;;;;;
-13EB;CHEROKEE LETTER WI;Lo;0;L;;;;;N;;;;;
-13EC;CHEROKEE LETTER WO;Lo;0;L;;;;;N;;;;;
-13ED;CHEROKEE LETTER WU;Lo;0;L;;;;;N;;;;;
-13EE;CHEROKEE LETTER WV;Lo;0;L;;;;;N;;;;;
-13EF;CHEROKEE LETTER YA;Lo;0;L;;;;;N;;;;;
-13F0;CHEROKEE LETTER YE;Lo;0;L;;;;;N;;;;;
-13F1;CHEROKEE LETTER YI;Lo;0;L;;;;;N;;;;;
-13F2;CHEROKEE LETTER YO;Lo;0;L;;;;;N;;;;;
-13F3;CHEROKEE LETTER YU;Lo;0;L;;;;;N;;;;;
-13F4;CHEROKEE LETTER YV;Lo;0;L;;;;;N;;;;;
+13A0;CHEROKEE LETTER A;Lu;0;L;;;;;N;;;;AB70;
+13A1;CHEROKEE LETTER E;Lu;0;L;;;;;N;;;;AB71;
+13A2;CHEROKEE LETTER I;Lu;0;L;;;;;N;;;;AB72;
+13A3;CHEROKEE LETTER O;Lu;0;L;;;;;N;;;;AB73;
+13A4;CHEROKEE LETTER U;Lu;0;L;;;;;N;;;;AB74;
+13A5;CHEROKEE LETTER V;Lu;0;L;;;;;N;;;;AB75;
+13A6;CHEROKEE LETTER GA;Lu;0;L;;;;;N;;;;AB76;
+13A7;CHEROKEE LETTER KA;Lu;0;L;;;;;N;;;;AB77;
+13A8;CHEROKEE LETTER GE;Lu;0;L;;;;;N;;;;AB78;
+13A9;CHEROKEE LETTER GI;Lu;0;L;;;;;N;;;;AB79;
+13AA;CHEROKEE LETTER GO;Lu;0;L;;;;;N;;;;AB7A;
+13AB;CHEROKEE LETTER GU;Lu;0;L;;;;;N;;;;AB7B;
+13AC;CHEROKEE LETTER GV;Lu;0;L;;;;;N;;;;AB7C;
+13AD;CHEROKEE LETTER HA;Lu;0;L;;;;;N;;;;AB7D;
+13AE;CHEROKEE LETTER HE;Lu;0;L;;;;;N;;;;AB7E;
+13AF;CHEROKEE LETTER HI;Lu;0;L;;;;;N;;;;AB7F;
+13B0;CHEROKEE LETTER HO;Lu;0;L;;;;;N;;;;AB80;
+13B1;CHEROKEE LETTER HU;Lu;0;L;;;;;N;;;;AB81;
+13B2;CHEROKEE LETTER HV;Lu;0;L;;;;;N;;;;AB82;
+13B3;CHEROKEE LETTER LA;Lu;0;L;;;;;N;;;;AB83;
+13B4;CHEROKEE LETTER LE;Lu;0;L;;;;;N;;;;AB84;
+13B5;CHEROKEE LETTER LI;Lu;0;L;;;;;N;;;;AB85;
+13B6;CHEROKEE LETTER LO;Lu;0;L;;;;;N;;;;AB86;
+13B7;CHEROKEE LETTER LU;Lu;0;L;;;;;N;;;;AB87;
+13B8;CHEROKEE LETTER LV;Lu;0;L;;;;;N;;;;AB88;
+13B9;CHEROKEE LETTER MA;Lu;0;L;;;;;N;;;;AB89;
+13BA;CHEROKEE LETTER ME;Lu;0;L;;;;;N;;;;AB8A;
+13BB;CHEROKEE LETTER MI;Lu;0;L;;;;;N;;;;AB8B;
+13BC;CHEROKEE LETTER MO;Lu;0;L;;;;;N;;;;AB8C;
+13BD;CHEROKEE LETTER MU;Lu;0;L;;;;;N;;;;AB8D;
+13BE;CHEROKEE LETTER NA;Lu;0;L;;;;;N;;;;AB8E;
+13BF;CHEROKEE LETTER HNA;Lu;0;L;;;;;N;;;;AB8F;
+13C0;CHEROKEE LETTER NAH;Lu;0;L;;;;;N;;;;AB90;
+13C1;CHEROKEE LETTER NE;Lu;0;L;;;;;N;;;;AB91;
+13C2;CHEROKEE LETTER NI;Lu;0;L;;;;;N;;;;AB92;
+13C3;CHEROKEE LETTER NO;Lu;0;L;;;;;N;;;;AB93;
+13C4;CHEROKEE LETTER NU;Lu;0;L;;;;;N;;;;AB94;
+13C5;CHEROKEE LETTER NV;Lu;0;L;;;;;N;;;;AB95;
+13C6;CHEROKEE LETTER QUA;Lu;0;L;;;;;N;;;;AB96;
+13C7;CHEROKEE LETTER QUE;Lu;0;L;;;;;N;;;;AB97;
+13C8;CHEROKEE LETTER QUI;Lu;0;L;;;;;N;;;;AB98;
+13C9;CHEROKEE LETTER QUO;Lu;0;L;;;;;N;;;;AB99;
+13CA;CHEROKEE LETTER QUU;Lu;0;L;;;;;N;;;;AB9A;
+13CB;CHEROKEE LETTER QUV;Lu;0;L;;;;;N;;;;AB9B;
+13CC;CHEROKEE LETTER SA;Lu;0;L;;;;;N;;;;AB9C;
+13CD;CHEROKEE LETTER S;Lu;0;L;;;;;N;;;;AB9D;
+13CE;CHEROKEE LETTER SE;Lu;0;L;;;;;N;;;;AB9E;
+13CF;CHEROKEE LETTER SI;Lu;0;L;;;;;N;;;;AB9F;
+13D0;CHEROKEE LETTER SO;Lu;0;L;;;;;N;;;;ABA0;
+13D1;CHEROKEE LETTER SU;Lu;0;L;;;;;N;;;;ABA1;
+13D2;CHEROKEE LETTER SV;Lu;0;L;;;;;N;;;;ABA2;
+13D3;CHEROKEE LETTER DA;Lu;0;L;;;;;N;;;;ABA3;
+13D4;CHEROKEE LETTER TA;Lu;0;L;;;;;N;;;;ABA4;
+13D5;CHEROKEE LETTER DE;Lu;0;L;;;;;N;;;;ABA5;
+13D6;CHEROKEE LETTER TE;Lu;0;L;;;;;N;;;;ABA6;
+13D7;CHEROKEE LETTER DI;Lu;0;L;;;;;N;;;;ABA7;
+13D8;CHEROKEE LETTER TI;Lu;0;L;;;;;N;;;;ABA8;
+13D9;CHEROKEE LETTER DO;Lu;0;L;;;;;N;;;;ABA9;
+13DA;CHEROKEE LETTER DU;Lu;0;L;;;;;N;;;;ABAA;
+13DB;CHEROKEE LETTER DV;Lu;0;L;;;;;N;;;;ABAB;
+13DC;CHEROKEE LETTER DLA;Lu;0;L;;;;;N;;;;ABAC;
+13DD;CHEROKEE LETTER TLA;Lu;0;L;;;;;N;;;;ABAD;
+13DE;CHEROKEE LETTER TLE;Lu;0;L;;;;;N;;;;ABAE;
+13DF;CHEROKEE LETTER TLI;Lu;0;L;;;;;N;;;;ABAF;
+13E0;CHEROKEE LETTER TLO;Lu;0;L;;;;;N;;;;ABB0;
+13E1;CHEROKEE LETTER TLU;Lu;0;L;;;;;N;;;;ABB1;
+13E2;CHEROKEE LETTER TLV;Lu;0;L;;;;;N;;;;ABB2;
+13E3;CHEROKEE LETTER TSA;Lu;0;L;;;;;N;;;;ABB3;
+13E4;CHEROKEE LETTER TSE;Lu;0;L;;;;;N;;;;ABB4;
+13E5;CHEROKEE LETTER TSI;Lu;0;L;;;;;N;;;;ABB5;
+13E6;CHEROKEE LETTER TSO;Lu;0;L;;;;;N;;;;ABB6;
+13E7;CHEROKEE LETTER TSU;Lu;0;L;;;;;N;;;;ABB7;
+13E8;CHEROKEE LETTER TSV;Lu;0;L;;;;;N;;;;ABB8;
+13E9;CHEROKEE LETTER WA;Lu;0;L;;;;;N;;;;ABB9;
+13EA;CHEROKEE LETTER WE;Lu;0;L;;;;;N;;;;ABBA;
+13EB;CHEROKEE LETTER WI;Lu;0;L;;;;;N;;;;ABBB;
+13EC;CHEROKEE LETTER WO;Lu;0;L;;;;;N;;;;ABBC;
+13ED;CHEROKEE LETTER WU;Lu;0;L;;;;;N;;;;ABBD;
+13EE;CHEROKEE LETTER WV;Lu;0;L;;;;;N;;;;ABBE;
+13EF;CHEROKEE LETTER YA;Lu;0;L;;;;;N;;;;ABBF;
+13F0;CHEROKEE LETTER YE;Lu;0;L;;;;;N;;;;13F8;
+13F1;CHEROKEE LETTER YI;Lu;0;L;;;;;N;;;;13F9;
+13F2;CHEROKEE LETTER YO;Lu;0;L;;;;;N;;;;13FA;
+13F3;CHEROKEE LETTER YU;Lu;0;L;;;;;N;;;;13FB;
+13F4;CHEROKEE LETTER YV;Lu;0;L;;;;;N;;;;13FC;
+13F5;CHEROKEE LETTER MV;Lu;0;L;;;;;N;;;;13FD;
+13F8;CHEROKEE SMALL LETTER YE;Ll;0;L;;;;;N;;;13F0;;13F0
+13F9;CHEROKEE SMALL LETTER YI;Ll;0;L;;;;;N;;;13F1;;13F1
+13FA;CHEROKEE SMALL LETTER YO;Ll;0;L;;;;;N;;;13F2;;13F2
+13FB;CHEROKEE SMALL LETTER YU;Ll;0;L;;;;;N;;;13F3;;13F3
+13FC;CHEROKEE SMALL LETTER YV;Ll;0;L;;;;;N;;;13F4;;13F4
+13FD;CHEROKEE SMALL LETTER MV;Ll;0;L;;;;;N;;;13F5;;13F5
 1400;CANADIAN SYLLABICS HYPHEN;Pd;0;ON;;;;;N;;;;;
 1401;CANADIAN SYLLABICS E;Lo;0;L;;;;;N;;;;;
 1402;CANADIAN SYLLABICS AAI;Lo;0;L;;;;;N;;;;;
@@ -4995,7 +5171,7 @@
 166A;CANADIAN SYLLABICS CARRIER TTSEE;Lo;0;L;;;;;N;;;;;
 166B;CANADIAN SYLLABICS CARRIER TTSI;Lo;0;L;;;;;N;;;;;
 166C;CANADIAN SYLLABICS CARRIER TTSA;Lo;0;L;;;;;N;;;;;
-166D;CANADIAN SYLLABICS CHI SIGN;Po;0;L;;;;;N;;;;;
+166D;CANADIAN SYLLABICS CHI SIGN;So;0;L;;;;;N;;;;;
 166E;CANADIAN SYLLABICS FULL STOP;Po;0;L;;;;;N;;;;;
 166F;CANADIAN SYLLABICS QAI;Lo;0;L;;;;;N;;;;;
 1670;CANADIAN SYLLABICS NGAI;Lo;0;L;;;;;N;;;;;
@@ -5145,6 +5321,7 @@
 170A;TAGALOG LETTER BA;Lo;0;L;;;;;N;;;;;
 170B;TAGALOG LETTER MA;Lo;0;L;;;;;N;;;;;
 170C;TAGALOG LETTER YA;Lo;0;L;;;;;N;;;;;
+170D;TAGALOG LETTER RA;Lo;0;L;;;;;N;;;;;
 170E;TAGALOG LETTER LA;Lo;0;L;;;;;N;;;;;
 170F;TAGALOG LETTER WA;Lo;0;L;;;;;N;;;;;
 1710;TAGALOG LETTER SA;Lo;0;L;;;;;N;;;;;
@@ -5152,6 +5329,8 @@
 1712;TAGALOG VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
 1713;TAGALOG VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
 1714;TAGALOG SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;;
+1715;TAGALOG SIGN PAMUDPOD;Mc;9;L;;;;;N;;;;;
+171F;TAGALOG LETTER ARCHAIC RA;Lo;0;L;;;;;N;;;;;
 1720;HANUNOO LETTER A;Lo;0;L;;;;;N;;;;;
 1721;HANUNOO LETTER I;Lo;0;L;;;;;N;;;;;
 1722;HANUNOO LETTER U;Lo;0;L;;;;;N;;;;;
@@ -5172,7 +5351,7 @@
 1731;HANUNOO LETTER HA;Lo;0;L;;;;;N;;;;;
 1732;HANUNOO VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
 1733;HANUNOO VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
-1734;HANUNOO SIGN PAMUDPOD;Mn;9;NSM;;;;;N;;;;;
+1734;HANUNOO SIGN PAMUDPOD;Mc;9;L;;;;;N;;;;;
 1735;PHILIPPINE SINGLE PUNCTUATION;Po;0;L;;;;;N;;;;;
 1736;PHILIPPINE DOUBLE PUNCTUATION;Po;0;L;;;;;N;;;;;
 1740;BUHID LETTER A;Lo;0;L;;;;;N;;;;;
@@ -5342,6 +5521,7 @@
 180C;MONGOLIAN FREE VARIATION SELECTOR TWO;Mn;0;NSM;;;;;N;;;;;
 180D;MONGOLIAN FREE VARIATION SELECTOR THREE;Mn;0;NSM;;;;;N;;;;;
 180E;MONGOLIAN VOWEL SEPARATOR;Cf;0;BN;;;;;N;;;;;
+180F;MONGOLIAN FREE VARIATION SELECTOR FOUR;Mn;0;NSM;;;;;N;;;;;
 1810;MONGOLIAN DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
 1811;MONGOLIAN DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
 1812;MONGOLIAN DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
@@ -5440,13 +5620,14 @@
 1875;MONGOLIAN LETTER MANCHU RA;Lo;0;L;;;;;N;;;;;
 1876;MONGOLIAN LETTER MANCHU FA;Lo;0;L;;;;;N;;;;;
 1877;MONGOLIAN LETTER MANCHU ZHA;Lo;0;L;;;;;N;;;;;
+1878;MONGOLIAN LETTER CHA WITH TWO DOTS;Lo;0;L;;;;;N;;;;;
 1880;MONGOLIAN LETTER ALI GALI ANUSVARA ONE;Lo;0;L;;;;;N;;;;;
 1881;MONGOLIAN LETTER ALI GALI VISARGA ONE;Lo;0;L;;;;;N;;;;;
 1882;MONGOLIAN LETTER ALI GALI DAMARU;Lo;0;L;;;;;N;;;;;
 1883;MONGOLIAN LETTER ALI GALI UBADAMA;Lo;0;L;;;;;N;;;;;
 1884;MONGOLIAN LETTER ALI GALI INVERTED UBADAMA;Lo;0;L;;;;;N;;;;;
-1885;MONGOLIAN LETTER ALI GALI BALUDA;Lo;0;L;;;;;N;;;;;
-1886;MONGOLIAN LETTER ALI GALI THREE BALUDA;Lo;0;L;;;;;N;;;;;
+1885;MONGOLIAN LETTER ALI GALI BALUDA;Mn;0;NSM;;;;;N;;;;;
+1886;MONGOLIAN LETTER ALI GALI THREE BALUDA;Mn;0;NSM;;;;;N;;;;;
 1887;MONGOLIAN LETTER ALI GALI A;Lo;0;L;;;;;N;;;;;
 1888;MONGOLIAN LETTER ALI GALI I;Lo;0;L;;;;;N;;;;;
 1889;MONGOLIAN LETTER ALI GALI KA;Lo;0;L;;;;;N;;;;;
@@ -5700,23 +5881,23 @@
 19A9;NEW TAI LUE LETTER LOW XVA;Lo;0;L;;;;;N;;;;;
 19AA;NEW TAI LUE LETTER HIGH SUA;Lo;0;L;;;;;N;;;;;
 19AB;NEW TAI LUE LETTER LOW SUA;Lo;0;L;;;;;N;;;;;
-19B0;NEW TAI LUE VOWEL SIGN VOWEL SHORTENER;Mc;0;L;;;;;N;;;;;
-19B1;NEW TAI LUE VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
-19B2;NEW TAI LUE VOWEL SIGN II;Mc;0;L;;;;;N;;;;;
-19B3;NEW TAI LUE VOWEL SIGN U;Mc;0;L;;;;;N;;;;;
-19B4;NEW TAI LUE VOWEL SIGN UU;Mc;0;L;;;;;N;;;;;
-19B5;NEW TAI LUE VOWEL SIGN E;Mc;0;L;;;;;N;;;;;
-19B6;NEW TAI LUE VOWEL SIGN AE;Mc;0;L;;;;;N;;;;;
-19B7;NEW TAI LUE VOWEL SIGN O;Mc;0;L;;;;;N;;;;;
-19B8;NEW TAI LUE VOWEL SIGN OA;Mc;0;L;;;;;N;;;;;
-19B9;NEW TAI LUE VOWEL SIGN UE;Mc;0;L;;;;;N;;;;;
-19BA;NEW TAI LUE VOWEL SIGN AY;Mc;0;L;;;;;N;;;;;
-19BB;NEW TAI LUE VOWEL SIGN AAY;Mc;0;L;;;;;N;;;;;
-19BC;NEW TAI LUE VOWEL SIGN UY;Mc;0;L;;;;;N;;;;;
-19BD;NEW TAI LUE VOWEL SIGN OY;Mc;0;L;;;;;N;;;;;
-19BE;NEW TAI LUE VOWEL SIGN OAY;Mc;0;L;;;;;N;;;;;
-19BF;NEW TAI LUE VOWEL SIGN UEY;Mc;0;L;;;;;N;;;;;
-19C0;NEW TAI LUE VOWEL SIGN IY;Mc;0;L;;;;;N;;;;;
+19B0;NEW TAI LUE VOWEL SIGN VOWEL SHORTENER;Lo;0;L;;;;;N;;;;;
+19B1;NEW TAI LUE VOWEL SIGN AA;Lo;0;L;;;;;N;;;;;
+19B2;NEW TAI LUE VOWEL SIGN II;Lo;0;L;;;;;N;;;;;
+19B3;NEW TAI LUE VOWEL SIGN U;Lo;0;L;;;;;N;;;;;
+19B4;NEW TAI LUE VOWEL SIGN UU;Lo;0;L;;;;;N;;;;;
+19B5;NEW TAI LUE VOWEL SIGN E;Lo;0;L;;;;;N;;;;;
+19B6;NEW TAI LUE VOWEL SIGN AE;Lo;0;L;;;;;N;;;;;
+19B7;NEW TAI LUE VOWEL SIGN O;Lo;0;L;;;;;N;;;;;
+19B8;NEW TAI LUE VOWEL SIGN OA;Lo;0;L;;;;;N;;;;;
+19B9;NEW TAI LUE VOWEL SIGN UE;Lo;0;L;;;;;N;;;;;
+19BA;NEW TAI LUE VOWEL SIGN AY;Lo;0;L;;;;;N;;;;;
+19BB;NEW TAI LUE VOWEL SIGN AAY;Lo;0;L;;;;;N;;;;;
+19BC;NEW TAI LUE VOWEL SIGN UY;Lo;0;L;;;;;N;;;;;
+19BD;NEW TAI LUE VOWEL SIGN OY;Lo;0;L;;;;;N;;;;;
+19BE;NEW TAI LUE VOWEL SIGN OAY;Lo;0;L;;;;;N;;;;;
+19BF;NEW TAI LUE VOWEL SIGN UEY;Lo;0;L;;;;;N;;;;;
+19C0;NEW TAI LUE VOWEL SIGN IY;Lo;0;L;;;;;N;;;;;
 19C1;NEW TAI LUE LETTER FINAL V;Lo;0;L;;;;;N;;;;;
 19C2;NEW TAI LUE LETTER FINAL NG;Lo;0;L;;;;;N;;;;;
 19C3;NEW TAI LUE LETTER FINAL N;Lo;0;L;;;;;N;;;;;
@@ -5724,8 +5905,8 @@
 19C5;NEW TAI LUE LETTER FINAL K;Lo;0;L;;;;;N;;;;;
 19C6;NEW TAI LUE LETTER FINAL D;Lo;0;L;;;;;N;;;;;
 19C7;NEW TAI LUE LETTER FINAL B;Lo;0;L;;;;;N;;;;;
-19C8;NEW TAI LUE TONE MARK-1;Mc;0;L;;;;;N;;;;;
-19C9;NEW TAI LUE TONE MARK-2;Mc;0;L;;;;;N;;;;;
+19C8;NEW TAI LUE TONE MARK-1;Lo;0;L;;;;;N;;;;;
+19C9;NEW TAI LUE TONE MARK-2;Lo;0;L;;;;;N;;;;;
 19D0;NEW TAI LUE DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
 19D1;NEW TAI LUE DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
 19D2;NEW TAI LUE DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
@@ -5943,6 +6124,49 @@
 1ABC;COMBINING DOUBLE PARENTHESES ABOVE;Mn;230;NSM;;;;;N;;;;;
 1ABD;COMBINING PARENTHESES BELOW;Mn;220;NSM;;;;;N;;;;;
 1ABE;COMBINING PARENTHESES OVERLAY;Me;0;NSM;;;;;N;;;;;
+1ABF;COMBINING LATIN SMALL LETTER W BELOW;Mn;220;NSM;;;;;N;;;;;
+1AC0;COMBINING LATIN SMALL LETTER TURNED W BELOW;Mn;220;NSM;;;;;N;;;;;
+1AC1;COMBINING LEFT PARENTHESIS ABOVE LEFT;Mn;230;NSM;;;;;N;;;;;
+1AC2;COMBINING RIGHT PARENTHESIS ABOVE RIGHT;Mn;230;NSM;;;;;N;;;;;
+1AC3;COMBINING LEFT PARENTHESIS BELOW LEFT;Mn;220;NSM;;;;;N;;;;;
+1AC4;COMBINING RIGHT PARENTHESIS BELOW RIGHT;Mn;220;NSM;;;;;N;;;;;
+1AC5;COMBINING SQUARE BRACKETS ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AC6;COMBINING NUMBER SIGN ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AC7;COMBINING INVERTED DOUBLE ARCH ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AC8;COMBINING PLUS SIGN ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AC9;COMBINING DOUBLE PLUS SIGN ABOVE;Mn;230;NSM;;;;;N;;;;;
+1ACA;COMBINING DOUBLE PLUS SIGN BELOW;Mn;220;NSM;;;;;N;;;;;
+1ACB;COMBINING TRIPLE ACUTE ACCENT;Mn;230;NSM;;;;;N;;;;;
+1ACC;COMBINING LATIN SMALL LETTER INSULAR G;Mn;230;NSM;;;;;N;;;;;
+1ACD;COMBINING LATIN SMALL LETTER INSULAR R;Mn;230;NSM;;;;;N;;;;;
+1ACE;COMBINING LATIN SMALL LETTER INSULAR T;Mn;230;NSM;;;;;N;;;;;
+1ACF;COMBINING DOUBLE CARON;Mn;230;NSM;;;;;N;;;;;
+1AD0;COMBINING VERTICAL-LINE-ACUTE;Mn;230;NSM;;;;;N;;;;;
+1AD1;COMBINING GRAVE-VERTICAL-LINE;Mn;230;NSM;;;;;N;;;;;
+1AD2;COMBINING VERTICAL-LINE-GRAVE;Mn;230;NSM;;;;;N;;;;;
+1AD3;COMBINING ACUTE-VERTICAL-LINE;Mn;230;NSM;;;;;N;;;;;
+1AD4;COMBINING VERTICAL-LINE-MACRON;Mn;230;NSM;;;;;N;;;;;
+1AD5;COMBINING MACRON-VERTICAL-LINE;Mn;230;NSM;;;;;N;;;;;
+1AD6;COMBINING VERTICAL-LINE-ACUTE-GRAVE;Mn;230;NSM;;;;;N;;;;;
+1AD7;COMBINING VERTICAL-LINE-GRAVE-ACUTE;Mn;230;NSM;;;;;N;;;;;
+1AD8;COMBINING MACRON-ACUTE-GRAVE;Mn;230;NSM;;;;;N;;;;;
+1AD9;COMBINING SHARP SIGN;Mn;230;NSM;;;;;N;;;;;
+1ADA;COMBINING FLAT SIGN;Mn;230;NSM;;;;;N;;;;;
+1ADB;COMBINING DOWN TACK ABOVE;Mn;230;NSM;;;;;N;;;;;
+1ADC;COMBINING DIAERESIS WITH RAISED LEFT DOT;Mn;230;NSM;;;;;N;;;;;
+1ADD;COMBINING DOT-AND-RING BELOW;Mn;220;NSM;;;;;N;;;;;
+1AE0;COMBINING LEFT TACK ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AE1;COMBINING RIGHT TACK ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AE2;COMBINING MINUS SIGN ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AE3;COMBINING INVERTED BRIDGE ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AE4;COMBINING SQUARE ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AE5;COMBINING SEAGULL ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AE6;COMBINING DOUBLE ARCH BELOW;Mn;220;NSM;;;;;N;;;;;
+1AE7;COMBINING DOUBLE ARCH ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AE8;COMBINING EQUALS SIGN ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AE9;COMBINING LEFT ANGLE CENTRED ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AEA;COMBINING UPWARDS ARROW ABOVE;Mn;230;NSM;;;;;N;;;;;
+1AEB;COMBINING DOUBLE RIGHTWARDS ARROW ABOVE;Mn;234;NSM;;;;;N;;;;;
 1B00;BALINESE SIGN ULU RICEM;Mn;0;NSM;;;;;N;;;;;
 1B01;BALINESE SIGN ULU CANDRA;Mn;0;NSM;;;;;N;;;;;
 1B02;BALINESE SIGN CECEK;Mn;0;NSM;;;;;N;;;;;
@@ -6019,6 +6243,9 @@
 1B49;BALINESE LETTER VE SASAK;Lo;0;L;;;;;N;;;;;
 1B4A;BALINESE LETTER ZAL SASAK;Lo;0;L;;;;;N;;;;;
 1B4B;BALINESE LETTER ASYURA SASAK;Lo;0;L;;;;;N;;;;;
+1B4C;BALINESE LETTER ARCHAIC JNYA;Lo;0;L;;;;;N;;;;;
+1B4E;BALINESE INVERTED CARIK SIKI;Po;0;L;;;;;N;;;;;
+1B4F;BALINESE INVERTED CARIK PAREREN;Po;0;L;;;;;N;;;;;
 1B50;BALINESE DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
 1B51;BALINESE DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
 1B52;BALINESE DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
@@ -6064,6 +6291,9 @@
 1B7A;BALINESE MUSICAL SYMBOL LEFT-HAND CLOSED PLAK;So;0;L;;;;;N;;;;;
 1B7B;BALINESE MUSICAL SYMBOL LEFT-HAND CLOSED PLUK;So;0;L;;;;;N;;;;;
 1B7C;BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PING;So;0;L;;;;;N;;;;;
+1B7D;BALINESE PANTI LANTANG;Po;0;L;;;;;N;;;;;
+1B7E;BALINESE PAMADA LANTANG;Po;0;L;;;;;N;;;;;
+1B7F;BALINESE PANTI BAWAK;Po;0;L;;;;;N;;;;;
 1B80;SUNDANESE SIGN PANYECEK;Mn;0;NSM;;;;;N;;;;;
 1B81;SUNDANESE SIGN PANGLAYAR;Mn;0;NSM;;;;;N;;;;;
 1B82;SUNDANESE SIGN PANGWISAD;Mc;0;L;;;;;N;;;;;
@@ -6306,6 +6536,63 @@
 1C7D;OL CHIKI AHAD;Lm;0;L;;;;;N;;;;;
 1C7E;OL CHIKI PUNCTUATION MUCAAD;Po;0;L;;;;;N;;;;;
 1C7F;OL CHIKI PUNCTUATION DOUBLE MUCAAD;Po;0;L;;;;;N;;;;;
+1C80;CYRILLIC SMALL LETTER ROUNDED VE;Ll;0;L;;;;;N;;;0412;;0412
+1C81;CYRILLIC SMALL LETTER LONG-LEGGED DE;Ll;0;L;;;;;N;;;0414;;0414
+1C82;CYRILLIC SMALL LETTER NARROW O;Ll;0;L;;;;;N;;;041E;;041E
+1C83;CYRILLIC SMALL LETTER WIDE ES;Ll;0;L;;;;;N;;;0421;;0421
+1C84;CYRILLIC SMALL LETTER TALL TE;Ll;0;L;;;;;N;;;0422;;0422
+1C85;CYRILLIC SMALL LETTER THREE-LEGGED TE;Ll;0;L;;;;;N;;;0422;;0422
+1C86;CYRILLIC SMALL LETTER TALL HARD SIGN;Ll;0;L;;;;;N;;;042A;;042A
+1C87;CYRILLIC SMALL LETTER TALL YAT;Ll;0;L;;;;;N;;;0462;;0462
+1C88;CYRILLIC SMALL LETTER UNBLENDED UK;Ll;0;L;;;;;N;;;A64A;;A64A
+1C89;CYRILLIC CAPITAL LETTER TJE;Lu;0;L;;;;;N;;;;1C8A;
+1C8A;CYRILLIC SMALL LETTER TJE;Ll;0;L;;;;;N;;;1C89;;1C89
+1C90;GEORGIAN MTAVRULI CAPITAL LETTER AN;Lu;0;L;;;;;N;;;;10D0;
+1C91;GEORGIAN MTAVRULI CAPITAL LETTER BAN;Lu;0;L;;;;;N;;;;10D1;
+1C92;GEORGIAN MTAVRULI CAPITAL LETTER GAN;Lu;0;L;;;;;N;;;;10D2;
+1C93;GEORGIAN MTAVRULI CAPITAL LETTER DON;Lu;0;L;;;;;N;;;;10D3;
+1C94;GEORGIAN MTAVRULI CAPITAL LETTER EN;Lu;0;L;;;;;N;;;;10D4;
+1C95;GEORGIAN MTAVRULI CAPITAL LETTER VIN;Lu;0;L;;;;;N;;;;10D5;
+1C96;GEORGIAN MTAVRULI CAPITAL LETTER ZEN;Lu;0;L;;;;;N;;;;10D6;
+1C97;GEORGIAN MTAVRULI CAPITAL LETTER TAN;Lu;0;L;;;;;N;;;;10D7;
+1C98;GEORGIAN MTAVRULI CAPITAL LETTER IN;Lu;0;L;;;;;N;;;;10D8;
+1C99;GEORGIAN MTAVRULI CAPITAL LETTER KAN;Lu;0;L;;;;;N;;;;10D9;
+1C9A;GEORGIAN MTAVRULI CAPITAL LETTER LAS;Lu;0;L;;;;;N;;;;10DA;
+1C9B;GEORGIAN MTAVRULI CAPITAL LETTER MAN;Lu;0;L;;;;;N;;;;10DB;
+1C9C;GEORGIAN MTAVRULI CAPITAL LETTER NAR;Lu;0;L;;;;;N;;;;10DC;
+1C9D;GEORGIAN MTAVRULI CAPITAL LETTER ON;Lu;0;L;;;;;N;;;;10DD;
+1C9E;GEORGIAN MTAVRULI CAPITAL LETTER PAR;Lu;0;L;;;;;N;;;;10DE;
+1C9F;GEORGIAN MTAVRULI CAPITAL LETTER ZHAR;Lu;0;L;;;;;N;;;;10DF;
+1CA0;GEORGIAN MTAVRULI CAPITAL LETTER RAE;Lu;0;L;;;;;N;;;;10E0;
+1CA1;GEORGIAN MTAVRULI CAPITAL LETTER SAN;Lu;0;L;;;;;N;;;;10E1;
+1CA2;GEORGIAN MTAVRULI CAPITAL LETTER TAR;Lu;0;L;;;;;N;;;;10E2;
+1CA3;GEORGIAN MTAVRULI CAPITAL LETTER UN;Lu;0;L;;;;;N;;;;10E3;
+1CA4;GEORGIAN MTAVRULI CAPITAL LETTER PHAR;Lu;0;L;;;;;N;;;;10E4;
+1CA5;GEORGIAN MTAVRULI CAPITAL LETTER KHAR;Lu;0;L;;;;;N;;;;10E5;
+1CA6;GEORGIAN MTAVRULI CAPITAL LETTER GHAN;Lu;0;L;;;;;N;;;;10E6;
+1CA7;GEORGIAN MTAVRULI CAPITAL LETTER QAR;Lu;0;L;;;;;N;;;;10E7;
+1CA8;GEORGIAN MTAVRULI CAPITAL LETTER SHIN;Lu;0;L;;;;;N;;;;10E8;
+1CA9;GEORGIAN MTAVRULI CAPITAL LETTER CHIN;Lu;0;L;;;;;N;;;;10E9;
+1CAA;GEORGIAN MTAVRULI CAPITAL LETTER CAN;Lu;0;L;;;;;N;;;;10EA;
+1CAB;GEORGIAN MTAVRULI CAPITAL LETTER JIL;Lu;0;L;;;;;N;;;;10EB;
+1CAC;GEORGIAN MTAVRULI CAPITAL LETTER CIL;Lu;0;L;;;;;N;;;;10EC;
+1CAD;GEORGIAN MTAVRULI CAPITAL LETTER CHAR;Lu;0;L;;;;;N;;;;10ED;
+1CAE;GEORGIAN MTAVRULI CAPITAL LETTER XAN;Lu;0;L;;;;;N;;;;10EE;
+1CAF;GEORGIAN MTAVRULI CAPITAL LETTER JHAN;Lu;0;L;;;;;N;;;;10EF;
+1CB0;GEORGIAN MTAVRULI CAPITAL LETTER HAE;Lu;0;L;;;;;N;;;;10F0;
+1CB1;GEORGIAN MTAVRULI CAPITAL LETTER HE;Lu;0;L;;;;;N;;;;10F1;
+1CB2;GEORGIAN MTAVRULI CAPITAL LETTER HIE;Lu;0;L;;;;;N;;;;10F2;
+1CB3;GEORGIAN MTAVRULI CAPITAL LETTER WE;Lu;0;L;;;;;N;;;;10F3;
+1CB4;GEORGIAN MTAVRULI CAPITAL LETTER HAR;Lu;0;L;;;;;N;;;;10F4;
+1CB5;GEORGIAN MTAVRULI CAPITAL LETTER HOE;Lu;0;L;;;;;N;;;;10F5;
+1CB6;GEORGIAN MTAVRULI CAPITAL LETTER FI;Lu;0;L;;;;;N;;;;10F6;
+1CB7;GEORGIAN MTAVRULI CAPITAL LETTER YN;Lu;0;L;;;;;N;;;;10F7;
+1CB8;GEORGIAN MTAVRULI CAPITAL LETTER ELIFI;Lu;0;L;;;;;N;;;;10F8;
+1CB9;GEORGIAN MTAVRULI CAPITAL LETTER TURNED GAN;Lu;0;L;;;;;N;;;;10F9;
+1CBA;GEORGIAN MTAVRULI CAPITAL LETTER AIN;Lu;0;L;;;;;N;;;;10FA;
+1CBD;GEORGIAN MTAVRULI CAPITAL LETTER AEN;Lu;0;L;;;;;N;;;;10FD;
+1CBE;GEORGIAN MTAVRULI CAPITAL LETTER HARD SIGN;Lu;0;L;;;;;N;;;;10FE;
+1CBF;GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN;Lu;0;L;;;;;N;;;;10FF;
 1CC0;SUNDANESE PUNCTUATION BINDU SURYA;Po;0;L;;;;;N;;;;;
 1CC1;SUNDANESE PUNCTUATION BINDU PANGLONG;Po;0;L;;;;;N;;;;;
 1CC2;SUNDANESE PUNCTUATION BINDU PURNAMA;Po;0;L;;;;;N;;;;;
@@ -6348,13 +6635,15 @@
 1CEF;VEDIC SIGN LONG ANUSVARA;Lo;0;L;;;;;N;;;;;
 1CF0;VEDIC SIGN RTHANG LONG ANUSVARA;Lo;0;L;;;;;N;;;;;
 1CF1;VEDIC SIGN ANUSVARA UBHAYATO MUKHA;Lo;0;L;;;;;N;;;;;
-1CF2;VEDIC SIGN ARDHAVISARGA;Mc;0;L;;;;;N;;;;;
-1CF3;VEDIC SIGN ROTATED ARDHAVISARGA;Mc;0;L;;;;;N;;;;;
+1CF2;VEDIC SIGN ARDHAVISARGA;Lo;0;L;;;;;N;;;;;
+1CF3;VEDIC SIGN ROTATED ARDHAVISARGA;Lo;0;L;;;;;N;;;;;
 1CF4;VEDIC TONE CANDRA ABOVE;Mn;230;NSM;;;;;N;;;;;
 1CF5;VEDIC SIGN JIHVAMULIYA;Lo;0;L;;;;;N;;;;;
 1CF6;VEDIC SIGN UPADHMANIYA;Lo;0;L;;;;;N;;;;;
+1CF7;VEDIC SIGN ATIKRAMA;Mc;0;L;;;;;N;;;;;
 1CF8;VEDIC TONE RING ABOVE;Mn;230;NSM;;;;;N;;;;;
 1CF9;VEDIC TONE DOUBLE RING ABOVE;Mn;230;NSM;;;;;N;;;;;
+1CFA;VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA;Lo;0;L;;;;;N;;;;;
 1D00;LATIN LETTER SMALL CAPITAL A;Ll;0;L;;;;;N;;;;;
 1D01;LATIN LETTER SMALL CAPITAL AE;Ll;0;L;;;;;N;;;;;
 1D02;LATIN SMALL LETTER TURNED AE;Ll;0;L;;;;;N;;;;;
@@ -6497,7 +6786,7 @@
 1D8B;LATIN SMALL LETTER ESH WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
 1D8C;LATIN SMALL LETTER V WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
 1D8D;LATIN SMALL LETTER X WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
-1D8E;LATIN SMALL LETTER Z WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
+1D8E;LATIN SMALL LETTER Z WITH PALATAL HOOK;Ll;0;L;;;;;N;;;A7C6;;A7C6
 1D8F;LATIN SMALL LETTER A WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
 1D90;LATIN SMALL LETTER ALPHA WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
 1D91;LATIN SMALL LETTER D WITH HOOK AND TAIL;Ll;0;L;;;;;N;;;;;
@@ -6601,6 +6890,12 @@
 1DF3;COMBINING LATIN SMALL LETTER O WITH DIAERESIS;Mn;230;NSM;;;;;N;;;;;
 1DF4;COMBINING LATIN SMALL LETTER U WITH DIAERESIS;Mn;230;NSM;;;;;N;;;;;
 1DF5;COMBINING UP TACK ABOVE;Mn;230;NSM;;;;;N;;;;;
+1DF6;COMBINING KAVYKA ABOVE RIGHT;Mn;232;NSM;;;;;N;;;;;
+1DF7;COMBINING KAVYKA ABOVE LEFT;Mn;228;NSM;;;;;N;;;;;
+1DF8;COMBINING DOT ABOVE LEFT;Mn;228;NSM;;;;;N;;;;;
+1DF9;COMBINING WIDE INVERTED BRIDGE BELOW;Mn;220;NSM;;;;;N;;;;;
+1DFA;COMBINING DOT BELOW LEFT;Mn;218;NSM;;;;;N;;;;;
+1DFB;COMBINING DELETION MARK;Mn;230;NSM;;;;;N;;;;;
 1DFC;COMBINING DOUBLE INVERTED BREVE BELOW;Mn;233;NSM;;;;;N;;;;;
 1DFD;COMBINING ALMOST EQUAL TO BELOW;Mn;220;NSM;;;;;N;;;;;
 1DFE;COMBINING LEFT ARROWHEAD ABOVE;Mn;230;NSM;;;;;N;;;;;
@@ -7277,6 +7572,10 @@
 20BB;NORDIC MARK SIGN;Sc;0;ET;;;;;N;;;;;
 20BC;MANAT SIGN;Sc;0;ET;;;;;N;;;;;
 20BD;RUBLE SIGN;Sc;0;ET;;;;;N;;;;;
+20BE;LARI SIGN;Sc;0;ET;;;;;N;;;;;
+20BF;BITCOIN SIGN;Sc;0;ET;;;;;N;;;;;
+20C0;SOM SIGN;Sc;0;ET;;;;;N;;;;;
+20C1;SAUDI RIYAL SIGN;Sc;0;ET;;;;;N;;;;;
 20D0;COMBINING LEFT HARPOON ABOVE;Mn;230;NSM;;;;;N;NON-SPACING LEFT HARPOON ABOVE;;;;
 20D1;COMBINING RIGHT HARPOON ABOVE;Mn;230;NSM;;;;;N;NON-SPACING RIGHT HARPOON ABOVE;;;;
 20D2;COMBINING LONG VERTICAL LINE OVERLAY;Mn;1;NSM;;;;;N;NON-SPACING LONG VERTICAL BAR OVERLAY;;;;
@@ -7448,6 +7747,8 @@
 2187;ROMAN NUMERAL FIFTY THOUSAND;Nl;0;L;;;;50000;N;;;;;
 2188;ROMAN NUMERAL ONE HUNDRED THOUSAND;Nl;0;L;;;;100000;N;;;;;
 2189;VULGAR FRACTION ZERO THIRDS;No;0;ON;<fraction> 0030 2044 0033;;;0;N;;;;;
+218A;TURNED DIGIT TWO;So;0;ON;;;;;N;;;;;
+218B;TURNED DIGIT THREE;So;0;ON;;;;;N;;;;;
 2190;LEFTWARDS ARROW;Sm;0;ON;;;;;N;LEFT ARROW;;;;
 2191;UPWARDS ARROW;Sm;0;ON;;;;;N;UP ARROW;;;;
 2192;RIGHTWARDS ARROW;Sm;0;ON;;;;;N;RIGHT ARROW;;;;
@@ -7669,7 +7970,7 @@
 226A;MUCH LESS-THAN;Sm;0;ON;;;;;Y;MUCH LESS THAN;;;;
 226B;MUCH GREATER-THAN;Sm;0;ON;;;;;Y;MUCH GREATER THAN;;;;
 226C;BETWEEN;Sm;0;ON;;;;;N;;;;;
-226D;NOT EQUIVALENT TO;Sm;0;ON;224D 0338;;;;N;;;;;
+226D;NOT EQUIVALENT TO;Sm;0;ON;224D 0338;;;;Y;;;;;
 226E;NOT LESS-THAN;Sm;0;ON;003C 0338;;;;Y;NOT LESS THAN;;;;
 226F;NOT GREATER-THAN;Sm;0;ON;003E 0338;;;;Y;NOT GREATER THAN;;;;
 2270;NEITHER LESS-THAN NOR EQUAL TO;Sm;0;ON;2264 0338;;;;Y;NEITHER LESS THAN NOR EQUAL TO;;;;
@@ -8067,6 +8368,11 @@
 23F8;DOUBLE VERTICAL BAR;So;0;ON;;;;;N;;;;;
 23F9;BLACK SQUARE FOR STOP;So;0;ON;;;;;N;;;;;
 23FA;BLACK CIRCLE FOR RECORD;So;0;ON;;;;;N;;;;;
+23FB;POWER SYMBOL;So;0;ON;;;;;N;;;;;
+23FC;POWER ON-OFF SYMBOL;So;0;ON;;;;;N;;;;;
+23FD;POWER ON SYMBOL;So;0;ON;;;;;N;;;;;
+23FE;POWER SLEEP SYMBOL;So;0;ON;;;;;N;;;;;
+23FF;OBSERVER EYE SYMBOL;So;0;ON;;;;;N;;;;;
 2400;SYMBOL FOR NULL;So;0;ON;;;;;N;GRAPHIC FOR NULL;;;;
 2401;SYMBOL FOR START OF HEADING;So;0;ON;;;;;N;GRAPHIC FOR START OF HEADING;;;;
 2402;SYMBOL FOR START OF TEXT;So;0;ON;;;;;N;GRAPHIC FOR START OF TEXT;;;;
@@ -8106,6 +8412,9 @@
 2424;SYMBOL FOR NEWLINE;So;0;ON;;;;;N;GRAPHIC FOR NEWLINE;;;;
 2425;SYMBOL FOR DELETE FORM TWO;So;0;ON;;;;;N;;;;;
 2426;SYMBOL FOR SUBSTITUTE FORM TWO;So;0;ON;;;;;N;;;;;
+2427;SYMBOL FOR DELETE SQUARE CHECKER BOARD FORM;So;0;ON;;;;;N;;;;;
+2428;SYMBOL FOR DELETE RECTANGULAR CHECKER BOARD FORM;So;0;ON;;;;;N;;;;;
+2429;SYMBOL FOR DELETE MEDIUM SHADE FORM;So;0;ON;;;;;N;;;;;
 2440;OCR HOOK;So;0;ON;;;;;N;;;;;
 2441;OCR CHAIR;So;0;ON;;;;;N;;;;;
 2442;OCR FORK;So;0;ON;;;;;N;;;;;
@@ -9462,7 +9771,7 @@
 299E;ANGLE WITH S INSIDE;Sm;0;ON;;;;;Y;;;;;
 299F;ACUTE ANGLE;Sm;0;ON;;;;;Y;;;;;
 29A0;SPHERICAL ANGLE OPENING LEFT;Sm;0;ON;;;;;Y;;;;;
-29A1;SPHERICAL ANGLE OPENING UP;Sm;0;ON;;;;;Y;;;;;
+29A1;SPHERICAL ANGLE OPENING UP;Sm;0;ON;;;;;N;;;;;
 29A2;TURNED ANGLE;Sm;0;ON;;;;;Y;;;;;
 29A3;REVERSED ANGLE;Sm;0;ON;;;;;Y;;;;;
 29A4;ANGLE WITH UNDERBAR;Sm;0;ON;;;;;Y;;;;;
@@ -9961,6 +10270,8 @@
 2B93;NEWLINE RIGHT;So;0;ON;;;;;N;;;;;
 2B94;FOUR CORNER ARROWS CIRCLING ANTICLOCKWISE;So;0;ON;;;;;N;;;;;
 2B95;RIGHTWARDS BLACK ARROW;So;0;ON;;;;;N;;;;;
+2B96;EQUALS SIGN WITH INFINITY ABOVE;So;0;ON;;;;;N;;;;;
+2B97;SYMBOL FOR TYPE A ELECTRONICS;So;0;ON;;;;;N;;;;;
 2B98;THREE-D TOP-LIGHTED LEFTWARDS EQUILATERAL ARROWHEAD;So;0;ON;;;;;N;;;;;
 2B99;THREE-D RIGHT-LIGHTED UPWARDS EQUILATERAL ARROWHEAD;So;0;ON;;;;;N;;;;;
 2B9A;THREE-D TOP-LIGHTED RIGHTWARDS EQUILATERAL ARROWHEAD;So;0;ON;;;;;N;;;;;
@@ -9995,6 +10306,9 @@
 2BB7;RIBBON ARROW RIGHT DOWN;So;0;ON;;;;;N;;;;;
 2BB8;UPWARDS WHITE ARROW FROM BAR WITH HORIZONTAL BAR;So;0;ON;;;;;N;;;;;
 2BB9;UP ARROWHEAD IN A RECTANGLE BOX;So;0;ON;;;;;N;;;;;
+2BBA;OVERLAPPING WHITE SQUARES;So;0;ON;;;;;N;;;;;
+2BBB;OVERLAPPING WHITE AND BLACK SQUARES;So;0;ON;;;;;N;;;;;
+2BBC;OVERLAPPING BLACK SQUARES;So;0;ON;;;;;N;;;;;
 2BBD;BALLOT BOX WITH LIGHT X;So;0;ON;;;;;N;;;;;
 2BBE;CIRCLED X;So;0;ON;;;;;N;;;;;
 2BBF;CIRCLED BOLD X;So;0;ON;;;;;N;;;;;
@@ -10007,6 +10321,7 @@
 2BC6;BLACK MEDIUM DOWN-POINTING TRIANGLE CENTRED;So;0;ON;;;;;N;;;;;
 2BC7;BLACK MEDIUM LEFT-POINTING TRIANGLE CENTRED;So;0;ON;;;;;N;;;;;
 2BC8;BLACK MEDIUM RIGHT-POINTING TRIANGLE CENTRED;So;0;ON;;;;;N;;;;;
+2BC9;NEPTUNE FORM TWO;So;0;ON;;;;;N;;;;;
 2BCA;TOP HALF BLACK CIRCLE;So;0;ON;;;;;N;;;;;
 2BCB;BOTTOM HALF BLACK CIRCLE;So;0;ON;;;;;N;;;;;
 2BCC;LIGHT FOUR POINTED BLACK CUSP;So;0;ON;;;;;N;;;;;
@@ -10015,6 +10330,52 @@
 2BCF;ROTATED WHITE FOUR POINTED CUSP;So;0;ON;;;;;N;;;;;
 2BD0;SQUARE POSITION INDICATOR;So;0;ON;;;;;N;;;;;
 2BD1;UNCERTAINTY SIGN;So;0;ON;;;;;N;;;;;
+2BD2;GROUP MARK;So;0;ON;;;;;N;;;;;
+2BD3;PLUTO FORM TWO;So;0;ON;;;;;N;;;;;
+2BD4;PLUTO FORM THREE;So;0;ON;;;;;N;;;;;
+2BD5;PLUTO FORM FOUR;So;0;ON;;;;;N;;;;;
+2BD6;PLUTO FORM FIVE;So;0;ON;;;;;N;;;;;
+2BD7;TRANSPLUTO;So;0;ON;;;;;N;;;;;
+2BD8;PROSERPINA;So;0;ON;;;;;N;;;;;
+2BD9;ASTRAEA;So;0;ON;;;;;N;;;;;
+2BDA;HYGIEA;So;0;ON;;;;;N;;;;;
+2BDB;PHOLUS;So;0;ON;;;;;N;;;;;
+2BDC;NESSUS;So;0;ON;;;;;N;;;;;
+2BDD;WHITE MOON SELENA;So;0;ON;;;;;N;;;;;
+2BDE;BLACK DIAMOND ON CROSS;So;0;ON;;;;;N;;;;;
+2BDF;TRUE LIGHT MOON ARTA;So;0;ON;;;;;N;;;;;
+2BE0;CUPIDO;So;0;ON;;;;;N;;;;;
+2BE1;HADES;So;0;ON;;;;;N;;;;;
+2BE2;ZEUS;So;0;ON;;;;;N;;;;;
+2BE3;KRONOS;So;0;ON;;;;;N;;;;;
+2BE4;APOLLON;So;0;ON;;;;;N;;;;;
+2BE5;ADMETOS;So;0;ON;;;;;N;;;;;
+2BE6;VULCANUS;So;0;ON;;;;;N;;;;;
+2BE7;POSEIDON;So;0;ON;;;;;N;;;;;
+2BE8;LEFT HALF BLACK STAR;So;0;ON;;;;;N;;;;;
+2BE9;RIGHT HALF BLACK STAR;So;0;ON;;;;;N;;;;;
+2BEA;STAR WITH LEFT HALF BLACK;So;0;ON;;;;;N;;;;;
+2BEB;STAR WITH RIGHT HALF BLACK;So;0;ON;;;;;N;;;;;
+2BEC;LEFTWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS;So;0;ON;;;;;N;;;;;
+2BED;UPWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS;So;0;ON;;;;;N;;;;;
+2BEE;RIGHTWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS;So;0;ON;;;;;N;;;;;
+2BEF;DOWNWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS;So;0;ON;;;;;N;;;;;
+2BF0;ERIS FORM ONE;So;0;ON;;;;;N;;;;;
+2BF1;ERIS FORM TWO;So;0;ON;;;;;N;;;;;
+2BF2;SEDNA;So;0;ON;;;;;N;;;;;
+2BF3;RUSSIAN ASTROLOGICAL SYMBOL VIGINTILE;So;0;ON;;;;;N;;;;;
+2BF4;RUSSIAN ASTROLOGICAL SYMBOL NOVILE;So;0;ON;;;;;N;;;;;
+2BF5;RUSSIAN ASTROLOGICAL SYMBOL QUINTILE;So;0;ON;;;;;N;;;;;
+2BF6;RUSSIAN ASTROLOGICAL SYMBOL BINOVILE;So;0;ON;;;;;N;;;;;
+2BF7;RUSSIAN ASTROLOGICAL SYMBOL SENTAGON;So;0;ON;;;;;N;;;;;
+2BF8;RUSSIAN ASTROLOGICAL SYMBOL TREDECILE;So;0;ON;;;;;N;;;;;
+2BF9;EQUALS SIGN WITH INFINITY BELOW;So;0;ON;;;;;N;;;;;
+2BFA;UNITED SYMBOL;So;0;ON;;;;;N;;;;;
+2BFB;SEPARATED SYMBOL;So;0;ON;;;;;N;;;;;
+2BFC;DOUBLED SYMBOL;So;0;ON;;;;;N;;;;;
+2BFD;PASSED SYMBOL;So;0;ON;;;;;N;;;;;
+2BFE;REVERSED RIGHT ANGLE;So;0;ON;;;;;Y;;;;;
+2BFF;HELLSCHREIBER PAUSE SYMBOL;So;0;ON;;;;;N;;;;;
 2C00;GLAGOLITIC CAPITAL LETTER AZU;Lu;0;L;;;;;N;;;;2C30;
 2C01;GLAGOLITIC CAPITAL LETTER BUKY;Lu;0;L;;;;;N;;;;2C31;
 2C02;GLAGOLITIC CAPITAL LETTER VEDE;Lu;0;L;;;;;N;;;;2C32;
@@ -10062,6 +10423,7 @@
 2C2C;GLAGOLITIC CAPITAL LETTER SHTAPIC;Lu;0;L;;;;;N;;;;2C5C;
 2C2D;GLAGOLITIC CAPITAL LETTER TROKUTASTI A;Lu;0;L;;;;;N;;;;2C5D;
 2C2E;GLAGOLITIC CAPITAL LETTER LATINATE MYSLITE;Lu;0;L;;;;;N;;;;2C5E;
+2C2F;GLAGOLITIC CAPITAL LETTER CAUDATE CHRIVI;Lu;0;L;;;;;N;;;;2C5F;
 2C30;GLAGOLITIC SMALL LETTER AZU;Ll;0;L;;;;;N;;;2C00;;2C00
 2C31;GLAGOLITIC SMALL LETTER BUKY;Ll;0;L;;;;;N;;;2C01;;2C01
 2C32;GLAGOLITIC SMALL LETTER VEDE;Ll;0;L;;;;;N;;;2C02;;2C02
@@ -10109,6 +10471,7 @@
 2C5C;GLAGOLITIC SMALL LETTER SHTAPIC;Ll;0;L;;;;;N;;;2C2C;;2C2C
 2C5D;GLAGOLITIC SMALL LETTER TROKUTASTI A;Ll;0;L;;;;;N;;;2C2D;;2C2D
 2C5E;GLAGOLITIC SMALL LETTER LATINATE MYSLITE;Ll;0;L;;;;;N;;;2C2E;;2C2E
+2C5F;GLAGOLITIC SMALL LETTER CAUDATE CHRIVI;Ll;0;L;;;;;N;;;2C2F;;2C2F
 2C60;LATIN CAPITAL LETTER L WITH DOUBLE BAR;Lu;0;L;;;;;N;;;;2C61;
 2C61;LATIN SMALL LETTER L WITH DOUBLE BAR;Ll;0;L;;;;;N;;;2C60;;2C60
 2C62;LATIN CAPITAL LETTER L WITH MIDDLE TILDE;Lu;0;L;;;;;N;;;;026B;
@@ -10541,6 +10904,33 @@
 2E40;DOUBLE HYPHEN;Pd;0;ON;;;;;N;;;;;
 2E41;REVERSED COMMA;Po;0;ON;;;;;N;;;;;
 2E42;DOUBLE LOW-REVERSED-9 QUOTATION MARK;Ps;0;ON;;;;;N;;;;;
+2E43;DASH WITH LEFT UPTURN;Po;0;ON;;;;;N;;;;;
+2E44;DOUBLE SUSPENSION MARK;Po;0;ON;;;;;N;;;;;
+2E45;INVERTED LOW KAVYKA;Po;0;ON;;;;;N;;;;;
+2E46;INVERTED LOW KAVYKA WITH KAVYKA ABOVE;Po;0;ON;;;;;N;;;;;
+2E47;LOW KAVYKA;Po;0;ON;;;;;N;;;;;
+2E48;LOW KAVYKA WITH DOT;Po;0;ON;;;;;N;;;;;
+2E49;DOUBLE STACKED COMMA;Po;0;ON;;;;;N;;;;;
+2E4A;DOTTED SOLIDUS;Po;0;ON;;;;;N;;;;;
+2E4B;TRIPLE DAGGER;Po;0;ON;;;;;N;;;;;
+2E4C;MEDIEVAL COMMA;Po;0;ON;;;;;N;;;;;
+2E4D;PARAGRAPHUS MARK;Po;0;ON;;;;;N;;;;;
+2E4E;PUNCTUS ELEVATUS MARK;Po;0;ON;;;;;N;;;;;
+2E4F;CORNISH VERSE DIVIDER;Po;0;ON;;;;;N;;;;;
+2E50;CROSS PATTY WITH RIGHT CROSSBAR;So;0;ON;;;;;N;;;;;
+2E51;CROSS PATTY WITH LEFT CROSSBAR;So;0;ON;;;;;N;;;;;
+2E52;TIRONIAN SIGN CAPITAL ET;Po;0;ON;;;;;N;;;;;
+2E53;MEDIEVAL EXCLAMATION MARK;Po;0;ON;;;;;N;;;;;
+2E54;MEDIEVAL QUESTION MARK;Po;0;ON;;;;;N;;;;;
+2E55;LEFT SQUARE BRACKET WITH STROKE;Ps;0;ON;;;;;Y;;;;;
+2E56;RIGHT SQUARE BRACKET WITH STROKE;Pe;0;ON;;;;;Y;;;;;
+2E57;LEFT SQUARE BRACKET WITH DOUBLE STROKE;Ps;0;ON;;;;;Y;;;;;
+2E58;RIGHT SQUARE BRACKET WITH DOUBLE STROKE;Pe;0;ON;;;;;Y;;;;;
+2E59;TOP HALF LEFT PARENTHESIS;Ps;0;ON;;;;;Y;;;;;
+2E5A;TOP HALF RIGHT PARENTHESIS;Pe;0;ON;;;;;Y;;;;;
+2E5B;BOTTOM HALF LEFT PARENTHESIS;Ps;0;ON;;;;;Y;;;;;
+2E5C;BOTTOM HALF RIGHT PARENTHESIS;Pe;0;ON;;;;;Y;;;;;
+2E5D;OBLIQUE HYPHEN;Pd;0;ON;;;;;N;;;;;
 2E80;CJK RADICAL REPEAT;So;0;ON;;;;;N;;;;;
 2E81;CJK RADICAL CLIFF;So;0;ON;;;;;N;;;;;
 2E82;CJK RADICAL SECOND ONE;So;0;ON;;;;;N;;;;;
@@ -10882,6 +11272,10 @@
 2FF9;IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM UPPER RIGHT;So;0;ON;;;;;N;;;;;
 2FFA;IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LOWER LEFT;So;0;ON;;;;;N;;;;;
 2FFB;IDEOGRAPHIC DESCRIPTION CHARACTER OVERLAID;So;0;ON;;;;;N;;;;;
+2FFC;IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM RIGHT;So;0;ON;;;;;N;;;;;
+2FFD;IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LOWER RIGHT;So;0;ON;;;;;N;;;;;
+2FFE;IDEOGRAPHIC DESCRIPTION CHARACTER HORIZONTAL REFLECTION;So;0;ON;;;;;N;;;;;
+2FFF;IDEOGRAPHIC DESCRIPTION CHARACTER ROTATION;So;0;ON;;;;;N;;;;;
 3000;IDEOGRAPHIC SPACE;Zs;0;WS;<wide> 0020;;;;N;;;;;
 3001;IDEOGRAPHIC COMMA;Po;0;ON;;;;;N;;;;;
 3002;IDEOGRAPHIC FULL STOP;Po;0;ON;;;;;N;IDEOGRAPHIC PERIOD;;;;
@@ -11176,6 +11570,8 @@
 312B;BOPOMOFO LETTER NG;Lo;0;L;;;;;N;;;;;
 312C;BOPOMOFO LETTER GN;Lo;0;L;;;;;N;;;;;
 312D;BOPOMOFO LETTER IH;Lo;0;L;;;;;N;;;;;
+312E;BOPOMOFO LETTER O WITH DOT ABOVE;Lo;0;L;;;;;N;;;;;
+312F;BOPOMOFO LETTER NN;Lo;0;L;;;;;N;;;;;
 3131;HANGUL LETTER KIYEOK;Lo;0;L;<compat> 1100;;;;N;HANGUL LETTER GIYEOG;;;;
 3132;HANGUL LETTER SSANGKIYEOK;Lo;0;L;<compat> 1101;;;;N;HANGUL LETTER SSANG GIYEOG;;;;
 3133;HANGUL LETTER KIYEOK-SIOS;Lo;0;L;<compat> 11AA;;;;N;HANGUL LETTER GIYEOG SIOS;;;;
@@ -11313,6 +11709,11 @@
 31B8;BOPOMOFO LETTER GH;Lo;0;L;;;;;N;;;;;
 31B9;BOPOMOFO LETTER LH;Lo;0;L;;;;;N;;;;;
 31BA;BOPOMOFO LETTER ZY;Lo;0;L;;;;;N;;;;;
+31BB;BOPOMOFO FINAL LETTER G;Lo;0;L;;;;;N;;;;;
+31BC;BOPOMOFO LETTER GW;Lo;0;L;;;;;N;;;;;
+31BD;BOPOMOFO LETTER KW;Lo;0;L;;;;;N;;;;;
+31BE;BOPOMOFO LETTER OE;Lo;0;L;;;;;N;;;;;
+31BF;BOPOMOFO LETTER AH;Lo;0;L;;;;;N;;;;;
 31C0;CJK STROKE T;So;0;ON;;;;;N;;;;;
 31C1;CJK STROKE WG;So;0;ON;;;;;N;;;;;
 31C2;CJK STROKE XG;So;0;ON;;;;;N;;;;;
@@ -11349,6 +11750,9 @@
 31E1;CJK STROKE HZZZG;So;0;ON;;;;;N;;;;;
 31E2;CJK STROKE PG;So;0;ON;;;;;N;;;;;
 31E3;CJK STROKE Q;So;0;ON;;;;;N;;;;;
+31E4;CJK STROKE HXG;So;0;ON;;;;;N;;;;;
+31E5;CJK STROKE SZP;So;0;ON;;;;;N;;;;;
+31EF;IDEOGRAPHIC DESCRIPTION CHARACTER SUBTRACTION;So;0;ON;;;;;N;;;;;
 31F0;KATAKANA LETTER SMALL KU;Lo;0;L;;;;;N;;;;;
 31F1;KATAKANA LETTER SMALL SI;Lo;0;L;;;;;N;;;;;
 31F2;KATAKANA LETTER SMALL SU;Lo;0;L;;;;;N;;;;;
@@ -11619,6 +12023,7 @@
 32FC;CIRCLED KATAKANA WI;So;0;L;<circle> 30F0;;;;N;;;;;
 32FD;CIRCLED KATAKANA WE;So;0;L;<circle> 30F1;;;;N;;;;;
 32FE;CIRCLED KATAKANA WO;So;0;L;<circle> 30F2;;;;N;;;;;
+32FF;SQUARE ERA NAME REIWA;So;0;L;<square> 4EE4 548C;;;;N;;;;;
 3300;SQUARE APAATO;So;0;L;<square> 30A2 30D1 30FC 30C8;;;;N;SQUARED APAATO;;;;
 3301;SQUARE ARUHUA;So;0;L;<square> 30A2 30EB 30D5 30A1;;;;N;SQUARED ARUHUA;;;;
 3302;SQUARE ANPEA;So;0;L;<square> 30A2 30F3 30DA 30A2;;;;N;SQUARED ANPEA;;;;
@@ -11876,7 +12281,7 @@
 33FE;IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY-ONE;So;0;L;<compat> 0033 0031 65E5;;;;N;;;;;
 33FF;SQUARE GAL;So;0;ON;<square> 0067 0061 006C;;;;N;;;;;
 3400;<CJK Ideograph Extension A, First>;Lo;0;L;;;;;N;;;;;
-4DB5;<CJK Ideograph Extension A, Last>;Lo;0;L;;;;;N;;;;;
+4DBF;<CJK Ideograph Extension A, Last>;Lo;0;L;;;;;N;;;;;
 4DC0;HEXAGRAM FOR THE CREATIVE HEAVEN;So;0;ON;;;;;N;;;;;
 4DC1;HEXAGRAM FOR THE RECEPTIVE EARTH;So;0;ON;;;;;N;;;;;
 4DC2;HEXAGRAM FOR DIFFICULTY AT THE BEGINNING;So;0;ON;;;;;N;;;;;
@@ -11942,7 +12347,7 @@
 4DFE;HEXAGRAM FOR AFTER COMPLETION;So;0;ON;;;;;N;;;;;
 4DFF;HEXAGRAM FOR BEFORE COMPLETION;So;0;ON;;;;;N;;;;;
 4E00;<CJK Ideograph, First>;Lo;0;L;;;;;N;;;;;
-9FCC;<CJK Ideograph, Last>;Lo;0;L;;;;;N;;;;;
+9FFF;<CJK Ideograph, Last>;Lo;0;L;;;;;N;;;;;
 A000;YI SYLLABLE IT;Lo;0;L;;;;;N;;;;;
 A001;YI SYLLABLE IX;Lo;0;L;;;;;N;;;;;
 A002;YI SYLLABLE I;Lo;0;L;;;;;N;;;;;
@@ -13605,6 +14010,7 @@ A69A;CYRILLIC CAPITAL LETTER CROSSED O;Lu;0;L;;;;;N;;;;A69B;
 A69B;CYRILLIC SMALL LETTER CROSSED O;Ll;0;L;;;;;N;;;A69A;;A69A
 A69C;MODIFIER LETTER CYRILLIC HARD SIGN;Lm;0;L;<super> 044A;;;;N;;;;;
 A69D;MODIFIER LETTER CYRILLIC SOFT SIGN;Lm;0;L;<super> 044C;;;;N;;;;;
+A69E;COMBINING CYRILLIC LETTER EF;Mn;230;NSM;;;;;N;;;;;
 A69F;COMBINING CYRILLIC LETTER IOTIFIED E;Mn;230;NSM;;;;;N;;;;;
 A6A0;BAMUM LETTER A;Lo;0;L;;;;;N;;;;;
 A6A1;BAMUM LETTER KA;Lo;0;L;;;;;N;;;;;
@@ -13837,11 +14243,12 @@ A78B;LATIN CAPITAL LETTER SALTILLO;Lu;0;L;;;;;N;;;;A78C;
 A78C;LATIN SMALL LETTER SALTILLO;Ll;0;L;;;;;N;;;A78B;;A78B
 A78D;LATIN CAPITAL LETTER TURNED H;Lu;0;L;;;;;N;;;;0265;
 A78E;LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT;Ll;0;L;;;;;N;;;;;
+A78F;LATIN LETTER SINOLOGICAL DOT;Lo;0;L;;;;;N;;;;;
 A790;LATIN CAPITAL LETTER N WITH DESCENDER;Lu;0;L;;;;;N;;;;A791;
 A791;LATIN SMALL LETTER N WITH DESCENDER;Ll;0;L;;;;;N;;;A790;;A790
 A792;LATIN CAPITAL LETTER C WITH BAR;Lu;0;L;;;;;N;;;;A793;
 A793;LATIN SMALL LETTER C WITH BAR;Ll;0;L;;;;;N;;;A792;;A792
-A794;LATIN SMALL LETTER C WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
+A794;LATIN SMALL LETTER C WITH PALATAL HOOK;Ll;0;L;;;;;N;;;A7C4;;A7C4
 A795;LATIN SMALL LETTER H WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
 A796;LATIN CAPITAL LETTER B WITH FLOURISH;Lu;0;L;;;;;N;;;;A797;
 A797;LATIN SMALL LETTER B WITH FLOURISH;Ll;0;L;;;;;N;;;A796;;A796
@@ -13867,8 +14274,59 @@ A7AA;LATIN CAPITAL LETTER H WITH HOOK;Lu;0;L;;;;;N;;;;0266;
 A7AB;LATIN CAPITAL LETTER REVERSED OPEN E;Lu;0;L;;;;;N;;;;025C;
 A7AC;LATIN CAPITAL LETTER SCRIPT G;Lu;0;L;;;;;N;;;;0261;
 A7AD;LATIN CAPITAL LETTER L WITH BELT;Lu;0;L;;;;;N;;;;026C;
+A7AE;LATIN CAPITAL LETTER SMALL CAPITAL I;Lu;0;L;;;;;N;;;;026A;
+A7AF;LATIN LETTER SMALL CAPITAL Q;Ll;0;L;;;;;N;;;;;
 A7B0;LATIN CAPITAL LETTER TURNED K;Lu;0;L;;;;;N;;;;029E;
 A7B1;LATIN CAPITAL LETTER TURNED T;Lu;0;L;;;;;N;;;;0287;
+A7B2;LATIN CAPITAL LETTER J WITH CROSSED-TAIL;Lu;0;L;;;;;N;;;;029D;
+A7B3;LATIN CAPITAL LETTER CHI;Lu;0;L;;;;;N;;;;AB53;
+A7B4;LATIN CAPITAL LETTER BETA;Lu;0;L;;;;;N;;;;A7B5;
+A7B5;LATIN SMALL LETTER BETA;Ll;0;L;;;;;N;;;A7B4;;A7B4
+A7B6;LATIN CAPITAL LETTER OMEGA;Lu;0;L;;;;;N;;;;A7B7;
+A7B7;LATIN SMALL LETTER OMEGA;Ll;0;L;;;;;N;;;A7B6;;A7B6
+A7B8;LATIN CAPITAL LETTER U WITH STROKE;Lu;0;L;;;;;N;;;;A7B9;
+A7B9;LATIN SMALL LETTER U WITH STROKE;Ll;0;L;;;;;N;;;A7B8;;A7B8
+A7BA;LATIN CAPITAL LETTER GLOTTAL A;Lu;0;L;;;;;N;;;;A7BB;
+A7BB;LATIN SMALL LETTER GLOTTAL A;Ll;0;L;;;;;N;;;A7BA;;A7BA
+A7BC;LATIN CAPITAL LETTER GLOTTAL I;Lu;0;L;;;;;N;;;;A7BD;
+A7BD;LATIN SMALL LETTER GLOTTAL I;Ll;0;L;;;;;N;;;A7BC;;A7BC
+A7BE;LATIN CAPITAL LETTER GLOTTAL U;Lu;0;L;;;;;N;;;;A7BF;
+A7BF;LATIN SMALL LETTER GLOTTAL U;Ll;0;L;;;;;N;;;A7BE;;A7BE
+A7C0;LATIN CAPITAL LETTER OLD POLISH O;Lu;0;L;;;;;N;;;;A7C1;
+A7C1;LATIN SMALL LETTER OLD POLISH O;Ll;0;L;;;;;N;;;A7C0;;A7C0
+A7C2;LATIN CAPITAL LETTER ANGLICANA W;Lu;0;L;;;;;N;;;;A7C3;
+A7C3;LATIN SMALL LETTER ANGLICANA W;Ll;0;L;;;;;N;;;A7C2;;A7C2
+A7C4;LATIN CAPITAL LETTER C WITH PALATAL HOOK;Lu;0;L;;;;;N;;;;A794;
+A7C5;LATIN CAPITAL LETTER S WITH HOOK;Lu;0;L;;;;;N;;;;0282;
+A7C6;LATIN CAPITAL LETTER Z WITH PALATAL HOOK;Lu;0;L;;;;;N;;;;1D8E;
+A7C7;LATIN CAPITAL LETTER D WITH SHORT STROKE OVERLAY;Lu;0;L;;;;;N;;;;A7C8;
+A7C8;LATIN SMALL LETTER D WITH SHORT STROKE OVERLAY;Ll;0;L;;;;;N;;;A7C7;;A7C7
+A7C9;LATIN CAPITAL LETTER S WITH SHORT STROKE OVERLAY;Lu;0;L;;;;;N;;;;A7CA;
+A7CA;LATIN SMALL LETTER S WITH SHORT STROKE OVERLAY;Ll;0;L;;;;;N;;;A7C9;;A7C9
+A7CB;LATIN CAPITAL LETTER RAMS HORN;Lu;0;L;;;;;N;;;;0264;
+A7CC;LATIN CAPITAL LETTER S WITH DIAGONAL STROKE;Lu;0;L;;;;;N;;;;A7CD;
+A7CD;LATIN SMALL LETTER S WITH DIAGONAL STROKE;Ll;0;L;;;;;N;;;A7CC;;A7CC
+A7CE;LATIN CAPITAL LETTER PHARYNGEAL VOICED FRICATIVE;Lu;0;L;;;;;N;;;;A7CF;
+A7CF;LATIN SMALL LETTER PHARYNGEAL VOICED FRICATIVE;Ll;0;L;;;;;N;;;A7CE;;A7CE
+A7D0;LATIN CAPITAL LETTER CLOSED INSULAR G;Lu;0;L;;;;;N;;;;A7D1;
+A7D1;LATIN SMALL LETTER CLOSED INSULAR G;Ll;0;L;;;;;N;;;A7D0;;A7D0
+A7D2;LATIN CAPITAL LETTER DOUBLE THORN;Lu;0;L;;;;;N;;;;A7D3;
+A7D3;LATIN SMALL LETTER DOUBLE THORN;Ll;0;L;;;;;N;;;A7D2;;A7D2
+A7D4;LATIN CAPITAL LETTER DOUBLE WYNN;Lu;0;L;;;;;N;;;;A7D5;
+A7D5;LATIN SMALL LETTER DOUBLE WYNN;Ll;0;L;;;;;N;;;A7D4;;A7D4
+A7D6;LATIN CAPITAL LETTER MIDDLE SCOTS S;Lu;0;L;;;;;N;;;;A7D7;
+A7D7;LATIN SMALL LETTER MIDDLE SCOTS S;Ll;0;L;;;;;N;;;A7D6;;A7D6
+A7D8;LATIN CAPITAL LETTER SIGMOID S;Lu;0;L;;;;;N;;;;A7D9;
+A7D9;LATIN SMALL LETTER SIGMOID S;Ll;0;L;;;;;N;;;A7D8;;A7D8
+A7DA;LATIN CAPITAL LETTER LAMBDA;Lu;0;L;;;;;N;;;;A7DB;
+A7DB;LATIN SMALL LETTER LAMBDA;Ll;0;L;;;;;N;;;A7DA;;A7DA
+A7DC;LATIN CAPITAL LETTER LAMBDA WITH STROKE;Lu;0;L;;;;;N;;;;019B;
+A7F1;MODIFIER LETTER CAPITAL S;Lm;0;L;<super> 0053;;;;N;;;;;
+A7F2;MODIFIER LETTER CAPITAL C;Lm;0;L;<super> 0043;;;;N;;;;;
+A7F3;MODIFIER LETTER CAPITAL F;Lm;0;L;<super> 0046;;;;N;;;;;
+A7F4;MODIFIER LETTER CAPITAL Q;Lm;0;L;<super> 0051;;;;N;;;;;
+A7F5;LATIN CAPITAL LETTER REVERSED HALF H;Lu;0;L;;;;;N;;;;A7F6;
+A7F6;LATIN SMALL LETTER REVERSED HALF H;Ll;0;L;;;;;N;;;A7F5;;A7F5
 A7F7;LATIN EPIGRAPHIC LETTER SIDEWAYS I;Lo;0;L;;;;;N;;;;;
 A7F8;MODIFIER LETTER CAPITAL H WITH STROKE;Lm;0;L;<super> 0126;;;;N;;;;;
 A7F9;MODIFIER LETTER SMALL LIGATURE OE;Lm;0;L;<super> 0153;;;;N;;;;;
@@ -13922,6 +14380,7 @@ A828;SYLOTI NAGRI POETRY MARK-1;So;0;ON;;;;;N;;;;;
 A829;SYLOTI NAGRI POETRY MARK-2;So;0;ON;;;;;N;;;;;
 A82A;SYLOTI NAGRI POETRY MARK-3;So;0;ON;;;;;N;;;;;
 A82B;SYLOTI NAGRI POETRY MARK-4;So;0;ON;;;;;N;;;;;
+A82C;SYLOTI NAGRI SIGN ALTERNATE HASANTA;Mn;9;NSM;;;;;N;;;;;
 A830;NORTH INDIC FRACTION ONE QUARTER;No;0;L;;;;1/4;N;;;;;
 A831;NORTH INDIC FRACTION ONE HALF;No;0;L;;;;1/2;N;;;;;
 A832;NORTH INDIC FRACTION THREE QUARTERS;No;0;L;;;;3/4;N;;;;;
@@ -14057,6 +14516,7 @@ A8C1;SAURASHTRA VOWEL SIGN O;Mc;0;L;;;;;N;;;;;
 A8C2;SAURASHTRA VOWEL SIGN OO;Mc;0;L;;;;;N;;;;;
 A8C3;SAURASHTRA VOWEL SIGN AU;Mc;0;L;;;;;N;;;;;
 A8C4;SAURASHTRA SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;;
+A8C5;SAURASHTRA SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
 A8CE;SAURASHTRA DANDA;Po;0;L;;;;;N;;;;;
 A8CF;SAURASHTRA DOUBLE DANDA;Po;0;L;;;;;N;;;;;
 A8D0;SAURASHTRA DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
@@ -14097,6 +14557,10 @@ A8F8;DEVANAGARI SIGN PUSHPIKA;Po;0;L;;;;;N;;;;;
 A8F9;DEVANAGARI GAP FILLER;Po;0;L;;;;;N;;;;;
 A8FA;DEVANAGARI CARET;Po;0;L;;;;;N;;;;;
 A8FB;DEVANAGARI HEADSTROKE;Lo;0;L;;;;;N;;;;;
+A8FC;DEVANAGARI SIGN SIDDHAM;Po;0;L;;;;;N;;;;;
+A8FD;DEVANAGARI JAIN OM;Lo;0;L;;;;;N;;;;;
+A8FE;DEVANAGARI LETTER AY;Lo;0;L;;;;;N;;;;;
+A8FF;DEVANAGARI VOWEL SIGN AY;Mn;0;NSM;;;;;N;;;;;
 A900;KAYAH LI DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
 A901;KAYAH LI DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
 A902;KAYAH LI DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
@@ -14272,7 +14736,7 @@ A9B9;JAVANESE VOWEL SIGN SUKU MENDUT;Mn;0;NSM;;;;;N;;;;;
 A9BA;JAVANESE VOWEL SIGN TALING;Mc;0;L;;;;;N;;;;;
 A9BB;JAVANESE VOWEL SIGN DIRGA MURE;Mc;0;L;;;;;N;;;;;
 A9BC;JAVANESE VOWEL SIGN PEPET;Mn;0;NSM;;;;;N;;;;;
-A9BD;JAVANESE CONSONANT SIGN KERET;Mc;0;L;;;;;N;;;;;
+A9BD;JAVANESE CONSONANT SIGN KERET;Mn;0;NSM;;;;;N;;;;;
 A9BE;JAVANESE CONSONANT SIGN PENGKAL;Mc;0;L;;;;;N;;;;;
 A9BF;JAVANESE CONSONANT SIGN CAKRA;Mc;0;L;;;;;N;;;;;
 A9C0;JAVANESE PANGKON;Mc;9;L;;;;;N;;;;;
@@ -14610,7 +15074,7 @@ AB4F;LATIN SMALL LETTER U BAR WITH SHORT RIGHT LEG;Ll;0;L;;;;;N;;;;;
 AB50;LATIN SMALL LETTER UI;Ll;0;L;;;;;N;;;;;
 AB51;LATIN SMALL LETTER TURNED UI;Ll;0;L;;;;;N;;;;;
 AB52;LATIN SMALL LETTER U WITH LEFT HOOK;Ll;0;L;;;;;N;;;;;
-AB53;LATIN SMALL LETTER CHI;Ll;0;L;;;;;N;;;;;
+AB53;LATIN SMALL LETTER CHI;Ll;0;L;;;;;N;;;A7B3;;A7B3
 AB54;LATIN SMALL LETTER CHI WITH LOW RIGHT RING;Ll;0;L;;;;;N;;;;;
 AB55;LATIN SMALL LETTER CHI WITH LOW LEFT SERIF;Ll;0;L;;;;;N;;;;;
 AB56;LATIN SMALL LETTER X WITH LOW RIGHT RING;Ll;0;L;;;;;N;;;;;
@@ -14623,8 +15087,98 @@ AB5C;MODIFIER LETTER SMALL HENG;Lm;0;L;<super> A727;;;;N;;;;;
 AB5D;MODIFIER LETTER SMALL L WITH INVERTED LAZY S;Lm;0;L;<super> AB37;;;;N;;;;;
 AB5E;MODIFIER LETTER SMALL L WITH MIDDLE TILDE;Lm;0;L;<super> 026B;;;;N;;;;;
 AB5F;MODIFIER LETTER SMALL U WITH LEFT HOOK;Lm;0;L;<super> AB52;;;;N;;;;;
+AB60;LATIN SMALL LETTER SAKHA YAT;Ll;0;L;;;;;N;;;;;
+AB61;LATIN SMALL LETTER IOTIFIED E;Ll;0;L;;;;;N;;;;;
+AB62;LATIN SMALL LETTER OPEN OE;Ll;0;L;;;;;N;;;;;
+AB63;LATIN SMALL LETTER UO;Ll;0;L;;;;;N;;;;;
 AB64;LATIN SMALL LETTER INVERTED ALPHA;Ll;0;L;;;;;N;;;;;
 AB65;GREEK LETTER SMALL CAPITAL OMEGA;Ll;0;L;;;;;N;;;;;
+AB66;LATIN SMALL LETTER DZ DIGRAPH WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
+AB67;LATIN SMALL LETTER TS DIGRAPH WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
+AB68;LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE;Ll;0;L;;;;;N;;;;;
+AB69;MODIFIER LETTER SMALL TURNED W;Lm;0;L;<super> 028D;;;;N;;;;;
+AB6A;MODIFIER LETTER LEFT TACK;Sk;0;ON;;;;;N;;;;;
+AB6B;MODIFIER LETTER RIGHT TACK;Sk;0;ON;;;;;N;;;;;
+AB70;CHEROKEE SMALL LETTER A;Ll;0;L;;;;;N;;;13A0;;13A0
+AB71;CHEROKEE SMALL LETTER E;Ll;0;L;;;;;N;;;13A1;;13A1
+AB72;CHEROKEE SMALL LETTER I;Ll;0;L;;;;;N;;;13A2;;13A2
+AB73;CHEROKEE SMALL LETTER O;Ll;0;L;;;;;N;;;13A3;;13A3
+AB74;CHEROKEE SMALL LETTER U;Ll;0;L;;;;;N;;;13A4;;13A4
+AB75;CHEROKEE SMALL LETTER V;Ll;0;L;;;;;N;;;13A5;;13A5
+AB76;CHEROKEE SMALL LETTER GA;Ll;0;L;;;;;N;;;13A6;;13A6
+AB77;CHEROKEE SMALL LETTER KA;Ll;0;L;;;;;N;;;13A7;;13A7
+AB78;CHEROKEE SMALL LETTER GE;Ll;0;L;;;;;N;;;13A8;;13A8
+AB79;CHEROKEE SMALL LETTER GI;Ll;0;L;;;;;N;;;13A9;;13A9
+AB7A;CHEROKEE SMALL LETTER GO;Ll;0;L;;;;;N;;;13AA;;13AA
+AB7B;CHEROKEE SMALL LETTER GU;Ll;0;L;;;;;N;;;13AB;;13AB
+AB7C;CHEROKEE SMALL LETTER GV;Ll;0;L;;;;;N;;;13AC;;13AC
+AB7D;CHEROKEE SMALL LETTER HA;Ll;0;L;;;;;N;;;13AD;;13AD
+AB7E;CHEROKEE SMALL LETTER HE;Ll;0;L;;;;;N;;;13AE;;13AE
+AB7F;CHEROKEE SMALL LETTER HI;Ll;0;L;;;;;N;;;13AF;;13AF
+AB80;CHEROKEE SMALL LETTER HO;Ll;0;L;;;;;N;;;13B0;;13B0
+AB81;CHEROKEE SMALL LETTER HU;Ll;0;L;;;;;N;;;13B1;;13B1
+AB82;CHEROKEE SMALL LETTER HV;Ll;0;L;;;;;N;;;13B2;;13B2
+AB83;CHEROKEE SMALL LETTER LA;Ll;0;L;;;;;N;;;13B3;;13B3
+AB84;CHEROKEE SMALL LETTER LE;Ll;0;L;;;;;N;;;13B4;;13B4
+AB85;CHEROKEE SMALL LETTER LI;Ll;0;L;;;;;N;;;13B5;;13B5
+AB86;CHEROKEE SMALL LETTER LO;Ll;0;L;;;;;N;;;13B6;;13B6
+AB87;CHEROKEE SMALL LETTER LU;Ll;0;L;;;;;N;;;13B7;;13B7
+AB88;CHEROKEE SMALL LETTER LV;Ll;0;L;;;;;N;;;13B8;;13B8
+AB89;CHEROKEE SMALL LETTER MA;Ll;0;L;;;;;N;;;13B9;;13B9
+AB8A;CHEROKEE SMALL LETTER ME;Ll;0;L;;;;;N;;;13BA;;13BA
+AB8B;CHEROKEE SMALL LETTER MI;Ll;0;L;;;;;N;;;13BB;;13BB
+AB8C;CHEROKEE SMALL LETTER MO;Ll;0;L;;;;;N;;;13BC;;13BC
+AB8D;CHEROKEE SMALL LETTER MU;Ll;0;L;;;;;N;;;13BD;;13BD
+AB8E;CHEROKEE SMALL LETTER NA;Ll;0;L;;;;;N;;;13BE;;13BE
+AB8F;CHEROKEE SMALL LETTER HNA;Ll;0;L;;;;;N;;;13BF;;13BF
+AB90;CHEROKEE SMALL LETTER NAH;Ll;0;L;;;;;N;;;13C0;;13C0
+AB91;CHEROKEE SMALL LETTER NE;Ll;0;L;;;;;N;;;13C1;;13C1
+AB92;CHEROKEE SMALL LETTER NI;Ll;0;L;;;;;N;;;13C2;;13C2
+AB93;CHEROKEE SMALL LETTER NO;Ll;0;L;;;;;N;;;13C3;;13C3
+AB94;CHEROKEE SMALL LETTER NU;Ll;0;L;;;;;N;;;13C4;;13C4
+AB95;CHEROKEE SMALL LETTER NV;Ll;0;L;;;;;N;;;13C5;;13C5
+AB96;CHEROKEE SMALL LETTER QUA;Ll;0;L;;;;;N;;;13C6;;13C6
+AB97;CHEROKEE SMALL LETTER QUE;Ll;0;L;;;;;N;;;13C7;;13C7
+AB98;CHEROKEE SMALL LETTER QUI;Ll;0;L;;;;;N;;;13C8;;13C8
+AB99;CHEROKEE SMALL LETTER QUO;Ll;0;L;;;;;N;;;13C9;;13C9
+AB9A;CHEROKEE SMALL LETTER QUU;Ll;0;L;;;;;N;;;13CA;;13CA
+AB9B;CHEROKEE SMALL LETTER QUV;Ll;0;L;;;;;N;;;13CB;;13CB
+AB9C;CHEROKEE SMALL LETTER SA;Ll;0;L;;;;;N;;;13CC;;13CC
+AB9D;CHEROKEE SMALL LETTER S;Ll;0;L;;;;;N;;;13CD;;13CD
+AB9E;CHEROKEE SMALL LETTER SE;Ll;0;L;;;;;N;;;13CE;;13CE
+AB9F;CHEROKEE SMALL LETTER SI;Ll;0;L;;;;;N;;;13CF;;13CF
+ABA0;CHEROKEE SMALL LETTER SO;Ll;0;L;;;;;N;;;13D0;;13D0
+ABA1;CHEROKEE SMALL LETTER SU;Ll;0;L;;;;;N;;;13D1;;13D1
+ABA2;CHEROKEE SMALL LETTER SV;Ll;0;L;;;;;N;;;13D2;;13D2
+ABA3;CHEROKEE SMALL LETTER DA;Ll;0;L;;;;;N;;;13D3;;13D3
+ABA4;CHEROKEE SMALL LETTER TA;Ll;0;L;;;;;N;;;13D4;;13D4
+ABA5;CHEROKEE SMALL LETTER DE;Ll;0;L;;;;;N;;;13D5;;13D5
+ABA6;CHEROKEE SMALL LETTER TE;Ll;0;L;;;;;N;;;13D6;;13D6
+ABA7;CHEROKEE SMALL LETTER DI;Ll;0;L;;;;;N;;;13D7;;13D7
+ABA8;CHEROKEE SMALL LETTER TI;Ll;0;L;;;;;N;;;13D8;;13D8
+ABA9;CHEROKEE SMALL LETTER DO;Ll;0;L;;;;;N;;;13D9;;13D9
+ABAA;CHEROKEE SMALL LETTER DU;Ll;0;L;;;;;N;;;13DA;;13DA
+ABAB;CHEROKEE SMALL LETTER DV;Ll;0;L;;;;;N;;;13DB;;13DB
+ABAC;CHEROKEE SMALL LETTER DLA;Ll;0;L;;;;;N;;;13DC;;13DC
+ABAD;CHEROKEE SMALL LETTER TLA;Ll;0;L;;;;;N;;;13DD;;13DD
+ABAE;CHEROKEE SMALL LETTER TLE;Ll;0;L;;;;;N;;;13DE;;13DE
+ABAF;CHEROKEE SMALL LETTER TLI;Ll;0;L;;;;;N;;;13DF;;13DF
+ABB0;CHEROKEE SMALL LETTER TLO;Ll;0;L;;;;;N;;;13E0;;13E0
+ABB1;CHEROKEE SMALL LETTER TLU;Ll;0;L;;;;;N;;;13E1;;13E1
+ABB2;CHEROKEE SMALL LETTER TLV;Ll;0;L;;;;;N;;;13E2;;13E2
+ABB3;CHEROKEE SMALL LETTER TSA;Ll;0;L;;;;;N;;;13E3;;13E3
+ABB4;CHEROKEE SMALL LETTER TSE;Ll;0;L;;;;;N;;;13E4;;13E4
+ABB5;CHEROKEE SMALL LETTER TSI;Ll;0;L;;;;;N;;;13E5;;13E5
+ABB6;CHEROKEE SMALL LETTER TSO;Ll;0;L;;;;;N;;;13E6;;13E6
+ABB7;CHEROKEE SMALL LETTER TSU;Ll;0;L;;;;;N;;;13E7;;13E7
+ABB8;CHEROKEE SMALL LETTER TSV;Ll;0;L;;;;;N;;;13E8;;13E8
+ABB9;CHEROKEE SMALL LETTER WA;Ll;0;L;;;;;N;;;13E9;;13E9
+ABBA;CHEROKEE SMALL LETTER WE;Ll;0;L;;;;;N;;;13EA;;13EA
+ABBB;CHEROKEE SMALL LETTER WI;Ll;0;L;;;;;N;;;13EB;;13EB
+ABBC;CHEROKEE SMALL LETTER WO;Ll;0;L;;;;;N;;;13EC;;13EC
+ABBD;CHEROKEE SMALL LETTER WU;Ll;0;L;;;;;N;;;13ED;;13ED
+ABBE;CHEROKEE SMALL LETTER WV;Ll;0;L;;;;;N;;;13EE;;13EE
+ABBF;CHEROKEE SMALL LETTER YA;Ll;0;L;;;;;N;;;13EF;;13EF
 ABC0;MEETEI MAYEK LETTER KOK;Lo;0;L;;;;;N;;;;;
 ABC1;MEETEI MAYEK LETTER SAM;Lo;0;L;;;;;N;;;;;
 ABC2;MEETEI MAYEK LETTER LAI;Lo;0;L;;;;;N;;;;;
@@ -15407,6 +15961,23 @@ FBBE;ARABIC SYMBOL TWO DOTS VERTICALLY BELOW;Sk;0;AL;;;;;N;;;;;
 FBBF;ARABIC SYMBOL RING;Sk;0;AL;;;;;N;;;;;
 FBC0;ARABIC SYMBOL SMALL TAH ABOVE;Sk;0;AL;;;;;N;;;;;
 FBC1;ARABIC SYMBOL SMALL TAH BELOW;Sk;0;AL;;;;;N;;;;;
+FBC2;ARABIC SYMBOL WASLA ABOVE;Sk;0;AL;;;;;N;;;;;
+FBC3;ARABIC LIGATURE JALLA WA-ALAA;So;0;ON;;;;;N;;;;;
+FBC4;ARABIC LIGATURE DAAMAT BARAKAATUHUM;So;0;ON;;;;;N;;;;;
+FBC5;ARABIC LIGATURE RAHMATU ALLAAHI TAAALAA ALAYH;So;0;ON;;;;;N;;;;;
+FBC6;ARABIC LIGATURE RAHMATU ALLAAHI ALAYHIM;So;0;ON;;;;;N;;;;;
+FBC7;ARABIC LIGATURE RAHMATU ALLAAHI ALAYHIMAA;So;0;ON;;;;;N;;;;;
+FBC8;ARABIC LIGATURE RAHIMAHUM ALLAAHU TAAALAA;So;0;ON;;;;;N;;;;;
+FBC9;ARABIC LIGATURE RAHIMAHUMAA ALLAAH;So;0;ON;;;;;N;;;;;
+FBCA;ARABIC LIGATURE RAHIMAHUMAA ALLAAHU TAAALAA;So;0;ON;;;;;N;;;;;
+FBCB;ARABIC LIGATURE RADI ALLAAHU TAAALAA ANHUM;So;0;ON;;;;;N;;;;;
+FBCC;ARABIC LIGATURE HAFIZAHU ALLAAH;So;0;ON;;;;;N;;;;;
+FBCD;ARABIC LIGATURE HAFIZAHU ALLAAHU TAAALAA;So;0;ON;;;;;N;;;;;
+FBCE;ARABIC LIGATURE HAFIZAHUM ALLAAHU TAAALAA;So;0;ON;;;;;N;;;;;
+FBCF;ARABIC LIGATURE HAFIZAHUMAA ALLAAHU TAAALAA;So;0;ON;;;;;N;;;;;
+FBD0;ARABIC LIGATURE SALLALLAAHU TAAALAA ALAYHI WA-SALLAM;So;0;ON;;;;;N;;;;;
+FBD1;ARABIC LIGATURE AJJAL ALLAAHU FARAJAHU ASH-SHAREEF;So;0;ON;;;;;N;;;;;
+FBD2;ARABIC LIGATURE ALAYHI AR-RAHMAH;So;0;ON;;;;;N;;;;;
 FBD3;ARABIC LETTER NG ISOLATED FORM;Lo;0;AL;<isolated> 06AD;;;;N;;;;;
 FBD4;ARABIC LETTER NG FINAL FORM;Lo;0;AL;<final> 06AD;;;;N;;;;;
 FBD5;ARABIC LETTER NG INITIAL FORM;Lo;0;AL;<initial> 06AD;;;;N;;;;;
@@ -15772,6 +16343,22 @@ FD3C;ARABIC LIGATURE ALEF WITH FATHATAN FINAL FORM;Lo;0;AL;<final> 0627 064B;;;;
 FD3D;ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM;Lo;0;AL;<isolated> 0627 064B;;;;N;;;;;
 FD3E;ORNATE LEFT PARENTHESIS;Pe;0;ON;;;;;N;;;;;
 FD3F;ORNATE RIGHT PARENTHESIS;Ps;0;ON;;;;;N;;;;;
+FD40;ARABIC LIGATURE RAHIMAHU ALLAAH;So;0;ON;;;;;N;;;;;
+FD41;ARABIC LIGATURE RADI ALLAAHU ANH;So;0;ON;;;;;N;;;;;
+FD42;ARABIC LIGATURE RADI ALLAAHU ANHAA;So;0;ON;;;;;N;;;;;
+FD43;ARABIC LIGATURE RADI ALLAAHU ANHUM;So;0;ON;;;;;N;;;;;
+FD44;ARABIC LIGATURE RADI ALLAAHU ANHUMAA;So;0;ON;;;;;N;;;;;
+FD45;ARABIC LIGATURE RADI ALLAAHU ANHUNNA;So;0;ON;;;;;N;;;;;
+FD46;ARABIC LIGATURE SALLALLAAHU ALAYHI WA-AALIH;So;0;ON;;;;;N;;;;;
+FD47;ARABIC LIGATURE ALAYHI AS-SALAAM;So;0;ON;;;;;N;;;;;
+FD48;ARABIC LIGATURE ALAYHIM AS-SALAAM;So;0;ON;;;;;N;;;;;
+FD49;ARABIC LIGATURE ALAYHIMAA AS-SALAAM;So;0;ON;;;;;N;;;;;
+FD4A;ARABIC LIGATURE ALAYHI AS-SALAATU WAS-SALAAM;So;0;ON;;;;;N;;;;;
+FD4B;ARABIC LIGATURE QUDDISA SIRRAH;So;0;ON;;;;;N;;;;;
+FD4C;ARABIC LIGATURE SALLALLAHU ALAYHI WAAALIHEE WA-SALLAM;So;0;ON;;;;;N;;;;;
+FD4D;ARABIC LIGATURE ALAYHAA AS-SALAAM;So;0;ON;;;;;N;;;;;
+FD4E;ARABIC LIGATURE TABAARAKA WA-TAAALAA;So;0;ON;;;;;N;;;;;
+FD4F;ARABIC LIGATURE RAHIMAHUM ALLAAH;So;0;ON;;;;;N;;;;;
 FD50;ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM;Lo;0;AL;<initial> 062A 062C 0645;;;;N;;;;;
 FD51;ARABIC LIGATURE TEH WITH HAH WITH JEEM FINAL FORM;Lo;0;AL;<final> 062A 062D 062C;;;;N;;;;;
 FD52;ARABIC LIGATURE TEH WITH HAH WITH JEEM INITIAL FORM;Lo;0;AL;<initial> 062A 062D 062C;;;;N;;;;;
@@ -15836,6 +16423,8 @@ FD8C;ARABIC LIGATURE MEEM WITH JEEM WITH HAH INITIAL FORM;Lo;0;AL;<initial> 0645
 FD8D;ARABIC LIGATURE MEEM WITH JEEM WITH MEEM INITIAL FORM;Lo;0;AL;<initial> 0645 062C 0645;;;;N;;;;;
 FD8E;ARABIC LIGATURE MEEM WITH KHAH WITH JEEM INITIAL FORM;Lo;0;AL;<initial> 0645 062E 062C;;;;N;;;;;
 FD8F;ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM;Lo;0;AL;<initial> 0645 062E 0645;;;;N;;;;;
+FD90;ARABIC LIGATURE RAHMATU ALLAAHI ALAYH;So;0;ON;;;;;N;;;;;
+FD91;ARABIC LIGATURE RAHMATU ALLAAHI ALAYHAA;So;0;ON;;;;;N;;;;;
 FD92;ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM;Lo;0;AL;<initial> 0645 062C 062E;;;;N;;;;;
 FD93;ARABIC LIGATURE HEH WITH MEEM WITH JEEM INITIAL FORM;Lo;0;AL;<initial> 0647 0645 062C;;;;N;;;;;
 FD94;ARABIC LIGATURE HEH WITH MEEM WITH MEEM INITIAL FORM;Lo;0;AL;<initial> 0647 0645 0645;;;;N;;;;;
@@ -15890,6 +16479,14 @@ FDC4;ARABIC LIGATURE AIN WITH JEEM WITH MEEM INITIAL FORM;Lo;0;AL;<initial> 0639
 FDC5;ARABIC LIGATURE SAD WITH MEEM WITH MEEM INITIAL FORM;Lo;0;AL;<initial> 0635 0645 0645;;;;N;;;;;
 FDC6;ARABIC LIGATURE SEEN WITH KHAH WITH YEH FINAL FORM;Lo;0;AL;<final> 0633 062E 064A;;;;N;;;;;
 FDC7;ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM;Lo;0;AL;<final> 0646 062C 064A;;;;N;;;;;
+FDC8;ARABIC LIGATURE RAHIMAHU ALLAAH TAAALAA;So;0;ON;;;;;N;;;;;
+FDC9;ARABIC LIGATURE RADI ALLAAHU TAAALAA ANH;So;0;ON;;;;;N;;;;;
+FDCA;ARABIC LIGATURE RADI ALLAAHU TAAALAA ANHAA;So;0;ON;;;;;N;;;;;
+FDCB;ARABIC LIGATURE RADI ALLAAHU TAAALAA ANHUMAA;So;0;ON;;;;;N;;;;;
+FDCC;ARABIC LIGATURE SALLALLAHU ALAYHI WA-ALAA AALIHEE WA-SALLAM;So;0;ON;;;;;N;;;;;
+FDCD;ARABIC LIGATURE AJJAL ALLAAHU TAAALAA FARAJAHU ASH-SHAREEF;So;0;ON;;;;;N;;;;;
+FDCE;ARABIC LIGATURE KARRAMA ALLAAHU WAJHAH;So;0;ON;;;;;N;;;;;
+FDCF;ARABIC LIGATURE SALAAMUHU ALAYNAA;So;0;ON;;;;;N;;;;;
 FDF0;ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM;Lo;0;AL;<isolated> 0635 0644 06D2;;;;N;;;;;
 FDF1;ARABIC LIGATURE QALA USED AS KORANIC STOP SIGN ISOLATED FORM;Lo;0;AL;<isolated> 0642 0644 06D2;;;;N;;;;;
 FDF2;ARABIC LIGATURE ALLAH ISOLATED FORM;Lo;0;AL;<isolated> 0627 0644 0644 0647;;;;N;;;;;
@@ -15904,6 +16501,8 @@ FDFA;ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM;Lo;0;AL;<isolated> 0635 0644 06
 FDFB;ARABIC LIGATURE JALLAJALALOUHOU;Lo;0;AL;<isolated> 062C 0644 0020 062C 0644 0627 0644 0647;;;;N;ARABIC LETTER JALLAJALALOUHOU;;;;
 FDFC;RIAL SIGN;Sc;0;AL;<isolated> 0631 06CC 0627 0644;;;;N;;;;;
 FDFD;ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM;So;0;ON;;;;;N;;;;;
+FDFE;ARABIC LIGATURE SUBHAANAHU WA TAAALAA;So;0;ON;;;;;N;;;;;
+FDFF;ARABIC LIGATURE AZZA WA JALL;So;0;ON;;;;;N;;;;;
 FE00;VARIATION SELECTOR-1;Mn;0;NSM;;;;;N;;;;;
 FE01;VARIATION SELECTOR-2;Mn;0;NSM;;;;;N;;;;;
 FE02;VARIATION SELECTOR-3;Mn;0;NSM;;;;;N;;;;;
@@ -15944,6 +16543,8 @@ FE2A;COMBINING TILDE RIGHT HALF BELOW;Mn;220;NSM;;;;;N;;;;;
 FE2B;COMBINING MACRON LEFT HALF BELOW;Mn;220;NSM;;;;;N;;;;;
 FE2C;COMBINING MACRON RIGHT HALF BELOW;Mn;220;NSM;;;;;N;;;;;
 FE2D;COMBINING CONJOINING MACRON BELOW;Mn;220;NSM;;;;;N;;;;;
+FE2E;COMBINING CYRILLIC TITLO LEFT HALF;Mn;230;NSM;;;;;N;;;;;
+FE2F;COMBINING CYRILLIC TITLO RIGHT HALF;Mn;230;NSM;;;;;N;;;;;
 FE30;PRESENTATION FORM FOR VERTICAL TWO DOT LEADER;Po;0;ON;<vertical> 2025;;;;N;GLYPH FOR VERTICAL TWO DOT LEADER;;;;
 FE31;PRESENTATION FORM FOR VERTICAL EM DASH;Pd;0;ON;<vertical> 2014;;;;N;GLYPH FOR VERTICAL EM DASH;;;;
 FE32;PRESENTATION FORM FOR VERTICAL EN DASH;Pd;0;ON;<vertical> 2013;;;;N;GLYPH FOR VERTICAL EN DASH;;;;
@@ -16718,6 +17319,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1018A;GREEK ZERO SIGN;No;0;ON;;;;0;N;;;;;
 1018B;GREEK ONE QUARTER SIGN;No;0;ON;;;;1/4;N;;;;;
 1018C;GREEK SINUSOID SIGN;So;0;ON;;;;;N;;;;;
+1018D;GREEK INDICTION SIGN;So;0;L;;;;;N;;;;;
+1018E;NOMISMA SIGN;So;0;L;;;;;N;;;;;
 10190;ROMAN SEXTANS SIGN;So;0;ON;;;;;N;;;;;
 10191;ROMAN UNCIA SIGN;So;0;ON;;;;;N;;;;;
 10192;ROMAN SEMUNCIA SIGN;So;0;ON;;;;;N;;;;;
@@ -16730,6 +17333,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 10199;ROMAN DUPONDIUS SIGN;So;0;ON;;;;;N;;;;;
 1019A;ROMAN AS SIGN;So;0;ON;;;;;N;;;;;
 1019B;ROMAN CENTURIAL SIGN;So;0;ON;;;;;N;;;;;
+1019C;ASCIA SYMBOL;So;0;ON;;;;;N;;;;;
 101A0;GREEK SYMBOL TAU RHO;So;0;ON;;;;;N;;;;;
 101D0;PHAISTOS DISC SIGN PEDESTRIAN;So;0;L;;;;;N;;;;;
 101D1;PHAISTOS DISC SIGN PLUMED HEAD;So;0;L;;;;;N;;;;;
@@ -16919,6 +17523,9 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 10321;OLD ITALIC NUMERAL FIVE;No;0;L;;;;5;N;;;;;
 10322;OLD ITALIC NUMERAL TEN;No;0;L;;;;10;N;;;;;
 10323;OLD ITALIC NUMERAL FIFTY;No;0;L;;;;50;N;;;;;
+1032D;OLD ITALIC LETTER YE;Lo;0;L;;;;;N;;;;;
+1032E;OLD ITALIC LETTER NORTHERN TSE;Lo;0;L;;;;;N;;;;;
+1032F;OLD ITALIC LETTER SOUTHERN TSE;Lo;0;L;;;;;N;;;;;
 10330;GOTHIC LETTER AHSA;Lo;0;L;;;;;N;;;;;
 10331;GOTHIC LETTER BAIRKAN;Lo;0;L;;;;;N;;;;;
 10332;GOTHIC LETTER GIBA;Lo;0;L;;;;;N;;;;;
@@ -17238,6 +17845,78 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 104A7;OSMANYA DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
 104A8;OSMANYA DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
 104A9;OSMANYA DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+104B0;OSAGE CAPITAL LETTER A;Lu;0;L;;;;;N;;;;104D8;
+104B1;OSAGE CAPITAL LETTER AI;Lu;0;L;;;;;N;;;;104D9;
+104B2;OSAGE CAPITAL LETTER AIN;Lu;0;L;;;;;N;;;;104DA;
+104B3;OSAGE CAPITAL LETTER AH;Lu;0;L;;;;;N;;;;104DB;
+104B4;OSAGE CAPITAL LETTER BRA;Lu;0;L;;;;;N;;;;104DC;
+104B5;OSAGE CAPITAL LETTER CHA;Lu;0;L;;;;;N;;;;104DD;
+104B6;OSAGE CAPITAL LETTER EHCHA;Lu;0;L;;;;;N;;;;104DE;
+104B7;OSAGE CAPITAL LETTER E;Lu;0;L;;;;;N;;;;104DF;
+104B8;OSAGE CAPITAL LETTER EIN;Lu;0;L;;;;;N;;;;104E0;
+104B9;OSAGE CAPITAL LETTER HA;Lu;0;L;;;;;N;;;;104E1;
+104BA;OSAGE CAPITAL LETTER HYA;Lu;0;L;;;;;N;;;;104E2;
+104BB;OSAGE CAPITAL LETTER I;Lu;0;L;;;;;N;;;;104E3;
+104BC;OSAGE CAPITAL LETTER KA;Lu;0;L;;;;;N;;;;104E4;
+104BD;OSAGE CAPITAL LETTER EHKA;Lu;0;L;;;;;N;;;;104E5;
+104BE;OSAGE CAPITAL LETTER KYA;Lu;0;L;;;;;N;;;;104E6;
+104BF;OSAGE CAPITAL LETTER LA;Lu;0;L;;;;;N;;;;104E7;
+104C0;OSAGE CAPITAL LETTER MA;Lu;0;L;;;;;N;;;;104E8;
+104C1;OSAGE CAPITAL LETTER NA;Lu;0;L;;;;;N;;;;104E9;
+104C2;OSAGE CAPITAL LETTER O;Lu;0;L;;;;;N;;;;104EA;
+104C3;OSAGE CAPITAL LETTER OIN;Lu;0;L;;;;;N;;;;104EB;
+104C4;OSAGE CAPITAL LETTER PA;Lu;0;L;;;;;N;;;;104EC;
+104C5;OSAGE CAPITAL LETTER EHPA;Lu;0;L;;;;;N;;;;104ED;
+104C6;OSAGE CAPITAL LETTER SA;Lu;0;L;;;;;N;;;;104EE;
+104C7;OSAGE CAPITAL LETTER SHA;Lu;0;L;;;;;N;;;;104EF;
+104C8;OSAGE CAPITAL LETTER TA;Lu;0;L;;;;;N;;;;104F0;
+104C9;OSAGE CAPITAL LETTER EHTA;Lu;0;L;;;;;N;;;;104F1;
+104CA;OSAGE CAPITAL LETTER TSA;Lu;0;L;;;;;N;;;;104F2;
+104CB;OSAGE CAPITAL LETTER EHTSA;Lu;0;L;;;;;N;;;;104F3;
+104CC;OSAGE CAPITAL LETTER TSHA;Lu;0;L;;;;;N;;;;104F4;
+104CD;OSAGE CAPITAL LETTER DHA;Lu;0;L;;;;;N;;;;104F5;
+104CE;OSAGE CAPITAL LETTER U;Lu;0;L;;;;;N;;;;104F6;
+104CF;OSAGE CAPITAL LETTER WA;Lu;0;L;;;;;N;;;;104F7;
+104D0;OSAGE CAPITAL LETTER KHA;Lu;0;L;;;;;N;;;;104F8;
+104D1;OSAGE CAPITAL LETTER GHA;Lu;0;L;;;;;N;;;;104F9;
+104D2;OSAGE CAPITAL LETTER ZA;Lu;0;L;;;;;N;;;;104FA;
+104D3;OSAGE CAPITAL LETTER ZHA;Lu;0;L;;;;;N;;;;104FB;
+104D8;OSAGE SMALL LETTER A;Ll;0;L;;;;;N;;;104B0;;104B0
+104D9;OSAGE SMALL LETTER AI;Ll;0;L;;;;;N;;;104B1;;104B1
+104DA;OSAGE SMALL LETTER AIN;Ll;0;L;;;;;N;;;104B2;;104B2
+104DB;OSAGE SMALL LETTER AH;Ll;0;L;;;;;N;;;104B3;;104B3
+104DC;OSAGE SMALL LETTER BRA;Ll;0;L;;;;;N;;;104B4;;104B4
+104DD;OSAGE SMALL LETTER CHA;Ll;0;L;;;;;N;;;104B5;;104B5
+104DE;OSAGE SMALL LETTER EHCHA;Ll;0;L;;;;;N;;;104B6;;104B6
+104DF;OSAGE SMALL LETTER E;Ll;0;L;;;;;N;;;104B7;;104B7
+104E0;OSAGE SMALL LETTER EIN;Ll;0;L;;;;;N;;;104B8;;104B8
+104E1;OSAGE SMALL LETTER HA;Ll;0;L;;;;;N;;;104B9;;104B9
+104E2;OSAGE SMALL LETTER HYA;Ll;0;L;;;;;N;;;104BA;;104BA
+104E3;OSAGE SMALL LETTER I;Ll;0;L;;;;;N;;;104BB;;104BB
+104E4;OSAGE SMALL LETTER KA;Ll;0;L;;;;;N;;;104BC;;104BC
+104E5;OSAGE SMALL LETTER EHKA;Ll;0;L;;;;;N;;;104BD;;104BD
+104E6;OSAGE SMALL LETTER KYA;Ll;0;L;;;;;N;;;104BE;;104BE
+104E7;OSAGE SMALL LETTER LA;Ll;0;L;;;;;N;;;104BF;;104BF
+104E8;OSAGE SMALL LETTER MA;Ll;0;L;;;;;N;;;104C0;;104C0
+104E9;OSAGE SMALL LETTER NA;Ll;0;L;;;;;N;;;104C1;;104C1
+104EA;OSAGE SMALL LETTER O;Ll;0;L;;;;;N;;;104C2;;104C2
+104EB;OSAGE SMALL LETTER OIN;Ll;0;L;;;;;N;;;104C3;;104C3
+104EC;OSAGE SMALL LETTER PA;Ll;0;L;;;;;N;;;104C4;;104C4
+104ED;OSAGE SMALL LETTER EHPA;Ll;0;L;;;;;N;;;104C5;;104C5
+104EE;OSAGE SMALL LETTER SA;Ll;0;L;;;;;N;;;104C6;;104C6
+104EF;OSAGE SMALL LETTER SHA;Ll;0;L;;;;;N;;;104C7;;104C7
+104F0;OSAGE SMALL LETTER TA;Ll;0;L;;;;;N;;;104C8;;104C8
+104F1;OSAGE SMALL LETTER EHTA;Ll;0;L;;;;;N;;;104C9;;104C9
+104F2;OSAGE SMALL LETTER TSA;Ll;0;L;;;;;N;;;104CA;;104CA
+104F3;OSAGE SMALL LETTER EHTSA;Ll;0;L;;;;;N;;;104CB;;104CB
+104F4;OSAGE SMALL LETTER TSHA;Ll;0;L;;;;;N;;;104CC;;104CC
+104F5;OSAGE SMALL LETTER DHA;Ll;0;L;;;;;N;;;104CD;;104CD
+104F6;OSAGE SMALL LETTER U;Ll;0;L;;;;;N;;;104CE;;104CE
+104F7;OSAGE SMALL LETTER WA;Ll;0;L;;;;;N;;;104CF;;104CF
+104F8;OSAGE SMALL LETTER KHA;Ll;0;L;;;;;N;;;104D0;;104D0
+104F9;OSAGE SMALL LETTER GHA;Ll;0;L;;;;;N;;;104D1;;104D1
+104FA;OSAGE SMALL LETTER ZA;Ll;0;L;;;;;N;;;104D2;;104D2
+104FB;OSAGE SMALL LETTER ZHA;Ll;0;L;;;;;N;;;104D3;;104D3
 10500;ELBASAN LETTER A;Lo;0;L;;;;;N;;;;;
 10501;ELBASAN LETTER BE;Lo;0;L;;;;;N;;;;;
 10502;ELBASAN LETTER CE;Lo;0;L;;;;;N;;;;;
@@ -17331,6 +18010,128 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 10562;CAUCASIAN ALBANIAN LETTER PIWR;Lo;0;L;;;;;N;;;;;
 10563;CAUCASIAN ALBANIAN LETTER KIW;Lo;0;L;;;;;N;;;;;
 1056F;CAUCASIAN ALBANIAN CITATION MARK;Po;0;L;;;;;N;;;;;
+10570;VITHKUQI CAPITAL LETTER A;Lu;0;L;;;;;N;;;;10597;
+10571;VITHKUQI CAPITAL LETTER BBE;Lu;0;L;;;;;N;;;;10598;
+10572;VITHKUQI CAPITAL LETTER BE;Lu;0;L;;;;;N;;;;10599;
+10573;VITHKUQI CAPITAL LETTER CE;Lu;0;L;;;;;N;;;;1059A;
+10574;VITHKUQI CAPITAL LETTER CHE;Lu;0;L;;;;;N;;;;1059B;
+10575;VITHKUQI CAPITAL LETTER DE;Lu;0;L;;;;;N;;;;1059C;
+10576;VITHKUQI CAPITAL LETTER DHE;Lu;0;L;;;;;N;;;;1059D;
+10577;VITHKUQI CAPITAL LETTER EI;Lu;0;L;;;;;N;;;;1059E;
+10578;VITHKUQI CAPITAL LETTER E;Lu;0;L;;;;;N;;;;1059F;
+10579;VITHKUQI CAPITAL LETTER FE;Lu;0;L;;;;;N;;;;105A0;
+1057A;VITHKUQI CAPITAL LETTER GA;Lu;0;L;;;;;N;;;;105A1;
+1057C;VITHKUQI CAPITAL LETTER HA;Lu;0;L;;;;;N;;;;105A3;
+1057D;VITHKUQI CAPITAL LETTER HHA;Lu;0;L;;;;;N;;;;105A4;
+1057E;VITHKUQI CAPITAL LETTER I;Lu;0;L;;;;;N;;;;105A5;
+1057F;VITHKUQI CAPITAL LETTER IJE;Lu;0;L;;;;;N;;;;105A6;
+10580;VITHKUQI CAPITAL LETTER JE;Lu;0;L;;;;;N;;;;105A7;
+10581;VITHKUQI CAPITAL LETTER KA;Lu;0;L;;;;;N;;;;105A8;
+10582;VITHKUQI CAPITAL LETTER LA;Lu;0;L;;;;;N;;;;105A9;
+10583;VITHKUQI CAPITAL LETTER LLA;Lu;0;L;;;;;N;;;;105AA;
+10584;VITHKUQI CAPITAL LETTER ME;Lu;0;L;;;;;N;;;;105AB;
+10585;VITHKUQI CAPITAL LETTER NE;Lu;0;L;;;;;N;;;;105AC;
+10586;VITHKUQI CAPITAL LETTER NJE;Lu;0;L;;;;;N;;;;105AD;
+10587;VITHKUQI CAPITAL LETTER O;Lu;0;L;;;;;N;;;;105AE;
+10588;VITHKUQI CAPITAL LETTER PE;Lu;0;L;;;;;N;;;;105AF;
+10589;VITHKUQI CAPITAL LETTER QA;Lu;0;L;;;;;N;;;;105B0;
+1058A;VITHKUQI CAPITAL LETTER RE;Lu;0;L;;;;;N;;;;105B1;
+1058C;VITHKUQI CAPITAL LETTER SE;Lu;0;L;;;;;N;;;;105B3;
+1058D;VITHKUQI CAPITAL LETTER SHE;Lu;0;L;;;;;N;;;;105B4;
+1058E;VITHKUQI CAPITAL LETTER TE;Lu;0;L;;;;;N;;;;105B5;
+1058F;VITHKUQI CAPITAL LETTER THE;Lu;0;L;;;;;N;;;;105B6;
+10590;VITHKUQI CAPITAL LETTER U;Lu;0;L;;;;;N;;;;105B7;
+10591;VITHKUQI CAPITAL LETTER VE;Lu;0;L;;;;;N;;;;105B8;
+10592;VITHKUQI CAPITAL LETTER XE;Lu;0;L;;;;;N;;;;105B9;
+10594;VITHKUQI CAPITAL LETTER Y;Lu;0;L;;;;;N;;;;105BB;
+10595;VITHKUQI CAPITAL LETTER ZE;Lu;0;L;;;;;N;;;;105BC;
+10597;VITHKUQI SMALL LETTER A;Ll;0;L;;;;;N;;;10570;;10570
+10598;VITHKUQI SMALL LETTER BBE;Ll;0;L;;;;;N;;;10571;;10571
+10599;VITHKUQI SMALL LETTER BE;Ll;0;L;;;;;N;;;10572;;10572
+1059A;VITHKUQI SMALL LETTER CE;Ll;0;L;;;;;N;;;10573;;10573
+1059B;VITHKUQI SMALL LETTER CHE;Ll;0;L;;;;;N;;;10574;;10574
+1059C;VITHKUQI SMALL LETTER DE;Ll;0;L;;;;;N;;;10575;;10575
+1059D;VITHKUQI SMALL LETTER DHE;Ll;0;L;;;;;N;;;10576;;10576
+1059E;VITHKUQI SMALL LETTER EI;Ll;0;L;;;;;N;;;10577;;10577
+1059F;VITHKUQI SMALL LETTER E;Ll;0;L;;;;;N;;;10578;;10578
+105A0;VITHKUQI SMALL LETTER FE;Ll;0;L;;;;;N;;;10579;;10579
+105A1;VITHKUQI SMALL LETTER GA;Ll;0;L;;;;;N;;;1057A;;1057A
+105A3;VITHKUQI SMALL LETTER HA;Ll;0;L;;;;;N;;;1057C;;1057C
+105A4;VITHKUQI SMALL LETTER HHA;Ll;0;L;;;;;N;;;1057D;;1057D
+105A5;VITHKUQI SMALL LETTER I;Ll;0;L;;;;;N;;;1057E;;1057E
+105A6;VITHKUQI SMALL LETTER IJE;Ll;0;L;;;;;N;;;1057F;;1057F
+105A7;VITHKUQI SMALL LETTER JE;Ll;0;L;;;;;N;;;10580;;10580
+105A8;VITHKUQI SMALL LETTER KA;Ll;0;L;;;;;N;;;10581;;10581
+105A9;VITHKUQI SMALL LETTER LA;Ll;0;L;;;;;N;;;10582;;10582
+105AA;VITHKUQI SMALL LETTER LLA;Ll;0;L;;;;;N;;;10583;;10583
+105AB;VITHKUQI SMALL LETTER ME;Ll;0;L;;;;;N;;;10584;;10584
+105AC;VITHKUQI SMALL LETTER NE;Ll;0;L;;;;;N;;;10585;;10585
+105AD;VITHKUQI SMALL LETTER NJE;Ll;0;L;;;;;N;;;10586;;10586
+105AE;VITHKUQI SMALL LETTER O;Ll;0;L;;;;;N;;;10587;;10587
+105AF;VITHKUQI SMALL LETTER PE;Ll;0;L;;;;;N;;;10588;;10588
+105B0;VITHKUQI SMALL LETTER QA;Ll;0;L;;;;;N;;;10589;;10589
+105B1;VITHKUQI SMALL LETTER RE;Ll;0;L;;;;;N;;;1058A;;1058A
+105B3;VITHKUQI SMALL LETTER SE;Ll;0;L;;;;;N;;;1058C;;1058C
+105B4;VITHKUQI SMALL LETTER SHE;Ll;0;L;;;;;N;;;1058D;;1058D
+105B5;VITHKUQI SMALL LETTER TE;Ll;0;L;;;;;N;;;1058E;;1058E
+105B6;VITHKUQI SMALL LETTER THE;Ll;0;L;;;;;N;;;1058F;;1058F
+105B7;VITHKUQI SMALL LETTER U;Ll;0;L;;;;;N;;;10590;;10590
+105B8;VITHKUQI SMALL LETTER VE;Ll;0;L;;;;;N;;;10591;;10591
+105B9;VITHKUQI SMALL LETTER XE;Ll;0;L;;;;;N;;;10592;;10592
+105BB;VITHKUQI SMALL LETTER Y;Ll;0;L;;;;;N;;;10594;;10594
+105BC;VITHKUQI SMALL LETTER ZE;Ll;0;L;;;;;N;;;10595;;10595
+105C0;TODHRI LETTER A;Lo;0;L;;;;;N;;;;;
+105C1;TODHRI LETTER AS;Lo;0;L;;;;;N;;;;;
+105C2;TODHRI LETTER BA;Lo;0;L;;;;;N;;;;;
+105C3;TODHRI LETTER MBA;Lo;0;L;;;;;N;;;;;
+105C4;TODHRI LETTER CA;Lo;0;L;;;;;N;;;;;
+105C5;TODHRI LETTER CHA;Lo;0;L;;;;;N;;;;;
+105C6;TODHRI LETTER DA;Lo;0;L;;;;;N;;;;;
+105C7;TODHRI LETTER NDA;Lo;0;L;;;;;N;;;;;
+105C8;TODHRI LETTER DHA;Lo;0;L;;;;;N;;;;;
+105C9;TODHRI LETTER EI;Lo;0;L;105D2 0307;;;;N;;;;;
+105CA;TODHRI LETTER E;Lo;0;L;;;;;N;;;;;
+105CB;TODHRI LETTER FA;Lo;0;L;;;;;N;;;;;
+105CC;TODHRI LETTER GA;Lo;0;L;;;;;N;;;;;
+105CD;TODHRI LETTER NGA;Lo;0;L;;;;;N;;;;;
+105CE;TODHRI LETTER GJA;Lo;0;L;;;;;N;;;;;
+105CF;TODHRI LETTER NGJA;Lo;0;L;;;;;N;;;;;
+105D0;TODHRI LETTER HA;Lo;0;L;;;;;N;;;;;
+105D1;TODHRI LETTER HJA;Lo;0;L;;;;;N;;;;;
+105D2;TODHRI LETTER I;Lo;0;L;;;;;N;;;;;
+105D3;TODHRI LETTER JA;Lo;0;L;;;;;N;;;;;
+105D4;TODHRI LETTER KA;Lo;0;L;;;;;N;;;;;
+105D5;TODHRI LETTER LA;Lo;0;L;;;;;N;;;;;
+105D6;TODHRI LETTER LLA;Lo;0;L;;;;;N;;;;;
+105D7;TODHRI LETTER MA;Lo;0;L;;;;;N;;;;;
+105D8;TODHRI LETTER NA;Lo;0;L;;;;;N;;;;;
+105D9;TODHRI LETTER NJAN;Lo;0;L;;;;;N;;;;;
+105DA;TODHRI LETTER O;Lo;0;L;;;;;N;;;;;
+105DB;TODHRI LETTER PA;Lo;0;L;;;;;N;;;;;
+105DC;TODHRI LETTER QA;Lo;0;L;;;;;N;;;;;
+105DD;TODHRI LETTER RA;Lo;0;L;;;;;N;;;;;
+105DE;TODHRI LETTER RRA;Lo;0;L;;;;;N;;;;;
+105DF;TODHRI LETTER SA;Lo;0;L;;;;;N;;;;;
+105E0;TODHRI LETTER SHA;Lo;0;L;;;;;N;;;;;
+105E1;TODHRI LETTER SHTA;Lo;0;L;;;;;N;;;;;
+105E2;TODHRI LETTER TA;Lo;0;L;;;;;N;;;;;
+105E3;TODHRI LETTER THA;Lo;0;L;;;;;N;;;;;
+105E4;TODHRI LETTER U;Lo;0;L;105DA 0307;;;;N;;;;;
+105E5;TODHRI LETTER VA;Lo;0;L;;;;;N;;;;;
+105E6;TODHRI LETTER XA;Lo;0;L;;;;;N;;;;;
+105E7;TODHRI LETTER NXA;Lo;0;L;;;;;N;;;;;
+105E8;TODHRI LETTER XHA;Lo;0;L;;;;;N;;;;;
+105E9;TODHRI LETTER NXHA;Lo;0;L;;;;;N;;;;;
+105EA;TODHRI LETTER Y;Lo;0;L;;;;;N;;;;;
+105EB;TODHRI LETTER JY;Lo;0;L;;;;;N;;;;;
+105EC;TODHRI LETTER ZA;Lo;0;L;;;;;N;;;;;
+105ED;TODHRI LETTER ZHA;Lo;0;L;;;;;N;;;;;
+105EE;TODHRI LETTER GHA;Lo;0;L;;;;;N;;;;;
+105EF;TODHRI LETTER STA;Lo;0;L;;;;;N;;;;;
+105F0;TODHRI LETTER SKAN;Lo;0;L;;;;;N;;;;;
+105F1;TODHRI LETTER KHA;Lo;0;L;;;;;N;;;;;
+105F2;TODHRI LETTER PSA;Lo;0;L;;;;;N;;;;;
+105F3;TODHRI LETTER OO;Lo;0;L;;;;;N;;;;;
 10600;LINEAR A SIGN AB001;Lo;0;L;;;;;N;;;;;
 10601;LINEAR A SIGN AB002;Lo;0;L;;;;;N;;;;;
 10602;LINEAR A SIGN AB003;Lo;0;L;;;;;N;;;;;
@@ -17672,6 +18473,63 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 10765;LINEAR A SIGN A805;Lo;0;L;;;;;N;;;;;
 10766;LINEAR A SIGN A806;Lo;0;L;;;;;N;;;;;
 10767;LINEAR A SIGN A807;Lo;0;L;;;;;N;;;;;
+10780;MODIFIER LETTER SMALL CAPITAL AA;Lm;0;L;;;;;N;;;;;
+10781;MODIFIER LETTER SUPERSCRIPT TRIANGULAR COLON;Lm;0;L;<super> 02D0;;;;N;;;;;
+10782;MODIFIER LETTER SUPERSCRIPT HALF TRIANGULAR COLON;Lm;0;L;<super> 02D1;;;;N;;;;;
+10783;MODIFIER LETTER SMALL AE;Lm;0;L;<super> 00E6;;;;N;;;;;
+10784;MODIFIER LETTER SMALL CAPITAL B;Lm;0;L;<super> 0299;;;;N;;;;;
+10785;MODIFIER LETTER SMALL B WITH HOOK;Lm;0;L;<super> 0253;;;;N;;;;;
+10787;MODIFIER LETTER SMALL DZ DIGRAPH;Lm;0;L;<super> 02A3;;;;N;;;;;
+10788;MODIFIER LETTER SMALL DZ DIGRAPH WITH RETROFLEX HOOK;Lm;0;L;<super> AB66;;;;N;;;;;
+10789;MODIFIER LETTER SMALL DZ DIGRAPH WITH CURL;Lm;0;L;<super> 02A5;;;;N;;;;;
+1078A;MODIFIER LETTER SMALL DEZH DIGRAPH;Lm;0;L;<super> 02A4;;;;N;;;;;
+1078B;MODIFIER LETTER SMALL D WITH TAIL;Lm;0;L;<super> 0256;;;;N;;;;;
+1078C;MODIFIER LETTER SMALL D WITH HOOK;Lm;0;L;<super> 0257;;;;N;;;;;
+1078D;MODIFIER LETTER SMALL D WITH HOOK AND TAIL;Lm;0;L;<super> 1D91;;;;N;;;;;
+1078E;MODIFIER LETTER SMALL REVERSED E;Lm;0;L;<super> 0258;;;;N;;;;;
+1078F;MODIFIER LETTER SMALL CLOSED REVERSED OPEN E;Lm;0;L;<super> 025E;;;;N;;;;;
+10790;MODIFIER LETTER SMALL FENG DIGRAPH;Lm;0;L;<super> 02A9;;;;N;;;;;
+10791;MODIFIER LETTER SMALL RAMS HORN;Lm;0;L;<super> 0264;;;;N;;;;;
+10792;MODIFIER LETTER SMALL CAPITAL G;Lm;0;L;<super> 0262;;;;N;;;;;
+10793;MODIFIER LETTER SMALL G WITH HOOK;Lm;0;L;<super> 0260;;;;N;;;;;
+10794;MODIFIER LETTER SMALL CAPITAL G WITH HOOK;Lm;0;L;<super> 029B;;;;N;;;;;
+10795;MODIFIER LETTER SMALL H WITH STROKE;Lm;0;L;<super> 0127;;;;N;;;;;
+10796;MODIFIER LETTER SMALL CAPITAL H;Lm;0;L;<super> 029C;;;;N;;;;;
+10797;MODIFIER LETTER SMALL HENG WITH HOOK;Lm;0;L;<super> 0267;;;;N;;;;;
+10798;MODIFIER LETTER SMALL DOTLESS J WITH STROKE AND HOOK;Lm;0;L;<super> 0284;;;;N;;;;;
+10799;MODIFIER LETTER SMALL LS DIGRAPH;Lm;0;L;<super> 02AA;;;;N;;;;;
+1079A;MODIFIER LETTER SMALL LZ DIGRAPH;Lm;0;L;<super> 02AB;;;;N;;;;;
+1079B;MODIFIER LETTER SMALL L WITH BELT;Lm;0;L;<super> 026C;;;;N;;;;;
+1079C;MODIFIER LETTER SMALL CAPITAL L WITH BELT;Lm;0;L;<super> 1DF04;;;;N;;;;;
+1079D;MODIFIER LETTER SMALL L WITH RETROFLEX HOOK AND BELT;Lm;0;L;<super> A78E;;;;N;;;;;
+1079E;MODIFIER LETTER SMALL LEZH;Lm;0;L;<super> 026E;;;;N;;;;;
+1079F;MODIFIER LETTER SMALL LEZH WITH RETROFLEX HOOK;Lm;0;L;<super> 1DF05;;;;N;;;;;
+107A0;MODIFIER LETTER SMALL TURNED Y;Lm;0;L;<super> 028E;;;;N;;;;;
+107A1;MODIFIER LETTER SMALL TURNED Y WITH BELT;Lm;0;L;<super> 1DF06;;;;N;;;;;
+107A2;MODIFIER LETTER SMALL O WITH STROKE;Lm;0;L;<super> 00F8;;;;N;;;;;
+107A3;MODIFIER LETTER SMALL CAPITAL OE;Lm;0;L;<super> 0276;;;;N;;;;;
+107A4;MODIFIER LETTER SMALL CLOSED OMEGA;Lm;0;L;<super> 0277;;;;N;;;;;
+107A5;MODIFIER LETTER SMALL Q;Lm;0;L;<super> 0071;;;;N;;;;;
+107A6;MODIFIER LETTER SMALL TURNED R WITH LONG LEG;Lm;0;L;<super> 027A;;;;N;;;;;
+107A7;MODIFIER LETTER SMALL TURNED R WITH LONG LEG AND RETROFLEX HOOK;Lm;0;L;<super> 1DF08;;;;N;;;;;
+107A8;MODIFIER LETTER SMALL R WITH TAIL;Lm;0;L;<super> 027D;;;;N;;;;;
+107A9;MODIFIER LETTER SMALL R WITH FISHHOOK;Lm;0;L;<super> 027E;;;;N;;;;;
+107AA;MODIFIER LETTER SMALL CAPITAL R;Lm;0;L;<super> 0280;;;;N;;;;;
+107AB;MODIFIER LETTER SMALL TC DIGRAPH WITH CURL;Lm;0;L;<super> 02A8;;;;N;;;;;
+107AC;MODIFIER LETTER SMALL TS DIGRAPH;Lm;0;L;<super> 02A6;;;;N;;;;;
+107AD;MODIFIER LETTER SMALL TS DIGRAPH WITH RETROFLEX HOOK;Lm;0;L;<super> AB67;;;;N;;;;;
+107AE;MODIFIER LETTER SMALL TESH DIGRAPH;Lm;0;L;<super> 02A7;;;;N;;;;;
+107AF;MODIFIER LETTER SMALL T WITH RETROFLEX HOOK;Lm;0;L;<super> 0288;;;;N;;;;;
+107B0;MODIFIER LETTER SMALL V WITH RIGHT HOOK;Lm;0;L;<super> 2C71;;;;N;;;;;
+107B2;MODIFIER LETTER SMALL CAPITAL Y;Lm;0;L;<super> 028F;;;;N;;;;;
+107B3;MODIFIER LETTER GLOTTAL STOP WITH STROKE;Lm;0;L;<super> 02A1;;;;N;;;;;
+107B4;MODIFIER LETTER REVERSED GLOTTAL STOP WITH STROKE;Lm;0;L;<super> 02A2;;;;N;;;;;
+107B5;MODIFIER LETTER BILABIAL CLICK;Lm;0;L;<super> 0298;;;;N;;;;;
+107B6;MODIFIER LETTER DENTAL CLICK;Lm;0;L;<super> 01C0;;;;N;;;;;
+107B7;MODIFIER LETTER LATERAL CLICK;Lm;0;L;<super> 01C1;;;;N;;;;;
+107B8;MODIFIER LETTER ALVEOLAR CLICK;Lm;0;L;<super> 01C2;;;;N;;;;;
+107B9;MODIFIER LETTER RETROFLEX CLICK WITH RETROFLEX HOOK;Lm;0;L;<super> 1DF0A;;;;N;;;;;
+107BA;MODIFIER LETTER SMALL S WITH CURL;Lm;0;L;<super> 1DF1E;;;;N;;;;;
 10800;CYPRIOT SYLLABLE A;Lo;0;R;;;;;N;;;;;
 10801;CYPRIOT SYLLABLE E;Lo;0;R;;;;;N;;;;;
 10802;CYPRIOT SYLLABLE I;Lo;0;R;;;;;N;;;;;
@@ -17830,6 +18688,32 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 108AD;NABATAEAN NUMBER TEN;No;0;R;;;;10;N;;;;;
 108AE;NABATAEAN NUMBER TWENTY;No;0;R;;;;20;N;;;;;
 108AF;NABATAEAN NUMBER ONE HUNDRED;No;0;R;;;;100;N;;;;;
+108E0;HATRAN LETTER ALEPH;Lo;0;R;;;;;N;;;;;
+108E1;HATRAN LETTER BETH;Lo;0;R;;;;;N;;;;;
+108E2;HATRAN LETTER GIMEL;Lo;0;R;;;;;N;;;;;
+108E3;HATRAN LETTER DALETH-RESH;Lo;0;R;;;;;N;;;;;
+108E4;HATRAN LETTER HE;Lo;0;R;;;;;N;;;;;
+108E5;HATRAN LETTER WAW;Lo;0;R;;;;;N;;;;;
+108E6;HATRAN LETTER ZAYN;Lo;0;R;;;;;N;;;;;
+108E7;HATRAN LETTER HETH;Lo;0;R;;;;;N;;;;;
+108E8;HATRAN LETTER TETH;Lo;0;R;;;;;N;;;;;
+108E9;HATRAN LETTER YODH;Lo;0;R;;;;;N;;;;;
+108EA;HATRAN LETTER KAPH;Lo;0;R;;;;;N;;;;;
+108EB;HATRAN LETTER LAMEDH;Lo;0;R;;;;;N;;;;;
+108EC;HATRAN LETTER MEM;Lo;0;R;;;;;N;;;;;
+108ED;HATRAN LETTER NUN;Lo;0;R;;;;;N;;;;;
+108EE;HATRAN LETTER SAMEKH;Lo;0;R;;;;;N;;;;;
+108EF;HATRAN LETTER AYN;Lo;0;R;;;;;N;;;;;
+108F0;HATRAN LETTER PE;Lo;0;R;;;;;N;;;;;
+108F1;HATRAN LETTER SADHE;Lo;0;R;;;;;N;;;;;
+108F2;HATRAN LETTER QOPH;Lo;0;R;;;;;N;;;;;
+108F4;HATRAN LETTER SHIN;Lo;0;R;;;;;N;;;;;
+108F5;HATRAN LETTER TAW;Lo;0;R;;;;;N;;;;;
+108FB;HATRAN NUMBER ONE;No;0;R;;;;1;N;;;;;
+108FC;HATRAN NUMBER FIVE;No;0;R;;;;5;N;;;;;
+108FD;HATRAN NUMBER TEN;No;0;R;;;;10;N;;;;;
+108FE;HATRAN NUMBER TWENTY;No;0;R;;;;20;N;;;;;
+108FF;HATRAN NUMBER ONE HUNDRED;No;0;R;;;;100;N;;;;;
 10900;PHOENICIAN LETTER ALF;Lo;0;R;;;;;N;;;;;
 10901;PHOENICIAN LETTER BET;Lo;0;R;;;;;N;;;;;
 10902;PHOENICIAN LETTER GAML;Lo;0;R;;;;;N;;;;;
@@ -17886,6 +18770,32 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 10938;LYDIAN LETTER NN;Lo;0;R;;;;;N;;;;;
 10939;LYDIAN LETTER C;Lo;0;R;;;;;N;;;;;
 1093F;LYDIAN TRIANGULAR MARK;Po;0;R;;;;;N;;;;;
+10940;SIDETIC LETTER N01;Lo;0;R;;;;;N;;;;;
+10941;SIDETIC LETTER N02;Lo;0;R;;;;;N;;;;;
+10942;SIDETIC LETTER N03;Lo;0;R;;;;;N;;;;;
+10943;SIDETIC LETTER N04;Lo;0;R;;;;;N;;;;;
+10944;SIDETIC LETTER N05;Lo;0;R;;;;;N;;;;;
+10945;SIDETIC LETTER N06;Lo;0;R;;;;;N;;;;;
+10946;SIDETIC LETTER N07;Lo;0;R;;;;;N;;;;;
+10947;SIDETIC LETTER N08;Lo;0;R;;;;;N;;;;;
+10948;SIDETIC LETTER N09;Lo;0;R;;;;;N;;;;;
+10949;SIDETIC LETTER N10;Lo;0;R;;;;;N;;;;;
+1094A;SIDETIC LETTER N11;Lo;0;R;;;;;N;;;;;
+1094B;SIDETIC LETTER N12;Lo;0;R;;;;;N;;;;;
+1094C;SIDETIC LETTER N13;Lo;0;R;;;;;N;;;;;
+1094D;SIDETIC LETTER N14;Lo;0;R;;;;;N;;;;;
+1094E;SIDETIC LETTER N15;Lo;0;R;;;;;N;;;;;
+1094F;SIDETIC LETTER N16;Lo;0;R;;;;;N;;;;;
+10950;SIDETIC LETTER N17;Lo;0;R;;;;;N;;;;;
+10951;SIDETIC LETTER N18;Lo;0;R;;;;;N;;;;;
+10952;SIDETIC LETTER N19;Lo;0;R;;;;;N;;;;;
+10953;SIDETIC LETTER N20;Lo;0;R;;;;;N;;;;;
+10954;SIDETIC LETTER N21;Lo;0;R;;;;;N;;;;;
+10955;SIDETIC LETTER N22;Lo;0;R;;;;;N;;;;;
+10956;SIDETIC LETTER N23;Lo;0;R;;;;;N;;;;;
+10957;SIDETIC LETTER N24;Lo;0;R;;;;;N;;;;;
+10958;SIDETIC LETTER N25;Lo;0;R;;;;;N;;;;;
+10959;SIDETIC LETTER N26;Lo;0;R;;;;;N;;;;;
 10980;MEROITIC HIEROGLYPHIC LETTER A;Lo;0;R;;;;;N;;;;;
 10981;MEROITIC HIEROGLYPHIC LETTER E;Lo;0;R;;;;;N;;;;;
 10982;MEROITIC HIEROGLYPHIC LETTER I;Lo;0;R;;;;;N;;;;;
@@ -17942,8 +18852,72 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 109B5;MEROITIC CURSIVE LETTER TE;Lo;0;R;;;;;N;;;;;
 109B6;MEROITIC CURSIVE LETTER TO;Lo;0;R;;;;;N;;;;;
 109B7;MEROITIC CURSIVE LETTER DA;Lo;0;R;;;;;N;;;;;
+109BC;MEROITIC CURSIVE FRACTION ELEVEN TWELFTHS;No;0;R;;;;11/12;N;;;;;
+109BD;MEROITIC CURSIVE FRACTION ONE HALF;No;0;R;;;;1/2;N;;;;;
 109BE;MEROITIC CURSIVE LOGOGRAM RMT;Lo;0;R;;;;;N;;;;;
 109BF;MEROITIC CURSIVE LOGOGRAM IMN;Lo;0;R;;;;;N;;;;;
+109C0;MEROITIC CURSIVE NUMBER ONE;No;0;R;;;;1;N;;;;;
+109C1;MEROITIC CURSIVE NUMBER TWO;No;0;R;;;;2;N;;;;;
+109C2;MEROITIC CURSIVE NUMBER THREE;No;0;R;;;;3;N;;;;;
+109C3;MEROITIC CURSIVE NUMBER FOUR;No;0;R;;;;4;N;;;;;
+109C4;MEROITIC CURSIVE NUMBER FIVE;No;0;R;;;;5;N;;;;;
+109C5;MEROITIC CURSIVE NUMBER SIX;No;0;R;;;;6;N;;;;;
+109C6;MEROITIC CURSIVE NUMBER SEVEN;No;0;R;;;;7;N;;;;;
+109C7;MEROITIC CURSIVE NUMBER EIGHT;No;0;R;;;;8;N;;;;;
+109C8;MEROITIC CURSIVE NUMBER NINE;No;0;R;;;;9;N;;;;;
+109C9;MEROITIC CURSIVE NUMBER TEN;No;0;R;;;;10;N;;;;;
+109CA;MEROITIC CURSIVE NUMBER TWENTY;No;0;R;;;;20;N;;;;;
+109CB;MEROITIC CURSIVE NUMBER THIRTY;No;0;R;;;;30;N;;;;;
+109CC;MEROITIC CURSIVE NUMBER FORTY;No;0;R;;;;40;N;;;;;
+109CD;MEROITIC CURSIVE NUMBER FIFTY;No;0;R;;;;50;N;;;;;
+109CE;MEROITIC CURSIVE NUMBER SIXTY;No;0;R;;;;60;N;;;;;
+109CF;MEROITIC CURSIVE NUMBER SEVENTY;No;0;R;;;;70;N;;;;;
+109D2;MEROITIC CURSIVE NUMBER ONE HUNDRED;No;0;R;;;;100;N;;;;;
+109D3;MEROITIC CURSIVE NUMBER TWO HUNDRED;No;0;R;;;;200;N;;;;;
+109D4;MEROITIC CURSIVE NUMBER THREE HUNDRED;No;0;R;;;;300;N;;;;;
+109D5;MEROITIC CURSIVE NUMBER FOUR HUNDRED;No;0;R;;;;400;N;;;;;
+109D6;MEROITIC CURSIVE NUMBER FIVE HUNDRED;No;0;R;;;;500;N;;;;;
+109D7;MEROITIC CURSIVE NUMBER SIX HUNDRED;No;0;R;;;;600;N;;;;;
+109D8;MEROITIC CURSIVE NUMBER SEVEN HUNDRED;No;0;R;;;;700;N;;;;;
+109D9;MEROITIC CURSIVE NUMBER EIGHT HUNDRED;No;0;R;;;;800;N;;;;;
+109DA;MEROITIC CURSIVE NUMBER NINE HUNDRED;No;0;R;;;;900;N;;;;;
+109DB;MEROITIC CURSIVE NUMBER ONE THOUSAND;No;0;R;;;;1000;N;;;;;
+109DC;MEROITIC CURSIVE NUMBER TWO THOUSAND;No;0;R;;;;2000;N;;;;;
+109DD;MEROITIC CURSIVE NUMBER THREE THOUSAND;No;0;R;;;;3000;N;;;;;
+109DE;MEROITIC CURSIVE NUMBER FOUR THOUSAND;No;0;R;;;;4000;N;;;;;
+109DF;MEROITIC CURSIVE NUMBER FIVE THOUSAND;No;0;R;;;;5000;N;;;;;
+109E0;MEROITIC CURSIVE NUMBER SIX THOUSAND;No;0;R;;;;6000;N;;;;;
+109E1;MEROITIC CURSIVE NUMBER SEVEN THOUSAND;No;0;R;;;;7000;N;;;;;
+109E2;MEROITIC CURSIVE NUMBER EIGHT THOUSAND;No;0;R;;;;8000;N;;;;;
+109E3;MEROITIC CURSIVE NUMBER NINE THOUSAND;No;0;R;;;;9000;N;;;;;
+109E4;MEROITIC CURSIVE NUMBER TEN THOUSAND;No;0;R;;;;10000;N;;;;;
+109E5;MEROITIC CURSIVE NUMBER TWENTY THOUSAND;No;0;R;;;;20000;N;;;;;
+109E6;MEROITIC CURSIVE NUMBER THIRTY THOUSAND;No;0;R;;;;30000;N;;;;;
+109E7;MEROITIC CURSIVE NUMBER FORTY THOUSAND;No;0;R;;;;40000;N;;;;;
+109E8;MEROITIC CURSIVE NUMBER FIFTY THOUSAND;No;0;R;;;;50000;N;;;;;
+109E9;MEROITIC CURSIVE NUMBER SIXTY THOUSAND;No;0;R;;;;60000;N;;;;;
+109EA;MEROITIC CURSIVE NUMBER SEVENTY THOUSAND;No;0;R;;;;70000;N;;;;;
+109EB;MEROITIC CURSIVE NUMBER EIGHTY THOUSAND;No;0;R;;;;80000;N;;;;;
+109EC;MEROITIC CURSIVE NUMBER NINETY THOUSAND;No;0;R;;;;90000;N;;;;;
+109ED;MEROITIC CURSIVE NUMBER ONE HUNDRED THOUSAND;No;0;R;;;;100000;N;;;;;
+109EE;MEROITIC CURSIVE NUMBER TWO HUNDRED THOUSAND;No;0;R;;;;200000;N;;;;;
+109EF;MEROITIC CURSIVE NUMBER THREE HUNDRED THOUSAND;No;0;R;;;;300000;N;;;;;
+109F0;MEROITIC CURSIVE NUMBER FOUR HUNDRED THOUSAND;No;0;R;;;;400000;N;;;;;
+109F1;MEROITIC CURSIVE NUMBER FIVE HUNDRED THOUSAND;No;0;R;;;;500000;N;;;;;
+109F2;MEROITIC CURSIVE NUMBER SIX HUNDRED THOUSAND;No;0;R;;;;600000;N;;;;;
+109F3;MEROITIC CURSIVE NUMBER SEVEN HUNDRED THOUSAND;No;0;R;;;;700000;N;;;;;
+109F4;MEROITIC CURSIVE NUMBER EIGHT HUNDRED THOUSAND;No;0;R;;;;800000;N;;;;;
+109F5;MEROITIC CURSIVE NUMBER NINE HUNDRED THOUSAND;No;0;R;;;;900000;N;;;;;
+109F6;MEROITIC CURSIVE FRACTION ONE TWELFTH;No;0;R;;;;1/12;N;;;;;
+109F7;MEROITIC CURSIVE FRACTION TWO TWELFTHS;No;0;R;;;;2/12;N;;;;;
+109F8;MEROITIC CURSIVE FRACTION THREE TWELFTHS;No;0;R;;;;3/12;N;;;;;
+109F9;MEROITIC CURSIVE FRACTION FOUR TWELFTHS;No;0;R;;;;4/12;N;;;;;
+109FA;MEROITIC CURSIVE FRACTION FIVE TWELFTHS;No;0;R;;;;5/12;N;;;;;
+109FB;MEROITIC CURSIVE FRACTION SIX TWELFTHS;No;0;R;;;;6/12;N;;;;;
+109FC;MEROITIC CURSIVE FRACTION SEVEN TWELFTHS;No;0;R;;;;7/12;N;;;;;
+109FD;MEROITIC CURSIVE FRACTION EIGHT TWELFTHS;No;0;R;;;;8/12;N;;;;;
+109FE;MEROITIC CURSIVE FRACTION NINE TWELFTHS;No;0;R;;;;9/12;N;;;;;
+109FF;MEROITIC CURSIVE FRACTION TEN TWELFTHS;No;0;R;;;;10/12;N;;;;;
 10A00;KHAROSHTHI LETTER A;Lo;0;R;;;;;N;;;;;
 10A01;KHAROSHTHI VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
 10A02;KHAROSHTHI VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
@@ -17988,6 +18962,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 10A31;KHAROSHTHI LETTER HA;Lo;0;R;;;;;N;;;;;
 10A32;KHAROSHTHI LETTER KKA;Lo;0;R;;;;;N;;;;;
 10A33;KHAROSHTHI LETTER TTTHA;Lo;0;R;;;;;N;;;;;
+10A34;KHAROSHTHI LETTER TTTA;Lo;0;R;;;;;N;;;;;
+10A35;KHAROSHTHI LETTER VHA;Lo;0;R;;;;;N;;;;;
 10A38;KHAROSHTHI SIGN BAR ABOVE;Mn;230;NSM;;;;;N;;;;;
 10A39;KHAROSHTHI SIGN CAUDA;Mn;1;NSM;;;;;N;;;;;
 10A3A;KHAROSHTHI SIGN DOT BELOW;Mn;220;NSM;;;;;N;;;;;
@@ -18000,6 +18976,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 10A45;KHAROSHTHI NUMBER TWENTY;No;0;R;;;;20;N;;;;;
 10A46;KHAROSHTHI NUMBER ONE HUNDRED;No;0;R;;;;100;N;;;;;
 10A47;KHAROSHTHI NUMBER ONE THOUSAND;No;0;R;;;;1000;N;;;;;
+10A48;KHAROSHTHI FRACTION ONE HALF;No;0;R;;;;1/2;N;;;;;
 10A50;KHAROSHTHI PUNCTUATION DOT;Po;0;R;;;;;N;;;;;
 10A51;KHAROSHTHI PUNCTUATION SMALL CIRCLE;Po;0;R;;;;;N;;;;;
 10A52;KHAROSHTHI PUNCTUATION CIRCLE;Po;0;R;;;;;N;;;;;
@@ -18344,6 +19321,233 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 10C46;OLD TURKIC LETTER YENISEI AET;Lo;0;R;;;;;N;;;;;
 10C47;OLD TURKIC LETTER ORKHON OT;Lo;0;R;;;;;N;;;;;
 10C48;OLD TURKIC LETTER ORKHON BASH;Lo;0;R;;;;;N;;;;;
+10C80;OLD HUNGARIAN CAPITAL LETTER A;Lu;0;R;;;;;N;;;;10CC0;
+10C81;OLD HUNGARIAN CAPITAL LETTER AA;Lu;0;R;;;;;N;;;;10CC1;
+10C82;OLD HUNGARIAN CAPITAL LETTER EB;Lu;0;R;;;;;N;;;;10CC2;
+10C83;OLD HUNGARIAN CAPITAL LETTER AMB;Lu;0;R;;;;;N;;;;10CC3;
+10C84;OLD HUNGARIAN CAPITAL LETTER EC;Lu;0;R;;;;;N;;;;10CC4;
+10C85;OLD HUNGARIAN CAPITAL LETTER ENC;Lu;0;R;;;;;N;;;;10CC5;
+10C86;OLD HUNGARIAN CAPITAL LETTER ECS;Lu;0;R;;;;;N;;;;10CC6;
+10C87;OLD HUNGARIAN CAPITAL LETTER ED;Lu;0;R;;;;;N;;;;10CC7;
+10C88;OLD HUNGARIAN CAPITAL LETTER AND;Lu;0;R;;;;;N;;;;10CC8;
+10C89;OLD HUNGARIAN CAPITAL LETTER E;Lu;0;R;;;;;N;;;;10CC9;
+10C8A;OLD HUNGARIAN CAPITAL LETTER CLOSE E;Lu;0;R;;;;;N;;;;10CCA;
+10C8B;OLD HUNGARIAN CAPITAL LETTER EE;Lu;0;R;;;;;N;;;;10CCB;
+10C8C;OLD HUNGARIAN CAPITAL LETTER EF;Lu;0;R;;;;;N;;;;10CCC;
+10C8D;OLD HUNGARIAN CAPITAL LETTER EG;Lu;0;R;;;;;N;;;;10CCD;
+10C8E;OLD HUNGARIAN CAPITAL LETTER EGY;Lu;0;R;;;;;N;;;;10CCE;
+10C8F;OLD HUNGARIAN CAPITAL LETTER EH;Lu;0;R;;;;;N;;;;10CCF;
+10C90;OLD HUNGARIAN CAPITAL LETTER I;Lu;0;R;;;;;N;;;;10CD0;
+10C91;OLD HUNGARIAN CAPITAL LETTER II;Lu;0;R;;;;;N;;;;10CD1;
+10C92;OLD HUNGARIAN CAPITAL LETTER EJ;Lu;0;R;;;;;N;;;;10CD2;
+10C93;OLD HUNGARIAN CAPITAL LETTER EK;Lu;0;R;;;;;N;;;;10CD3;
+10C94;OLD HUNGARIAN CAPITAL LETTER AK;Lu;0;R;;;;;N;;;;10CD4;
+10C95;OLD HUNGARIAN CAPITAL LETTER UNK;Lu;0;R;;;;;N;;;;10CD5;
+10C96;OLD HUNGARIAN CAPITAL LETTER EL;Lu;0;R;;;;;N;;;;10CD6;
+10C97;OLD HUNGARIAN CAPITAL LETTER ELY;Lu;0;R;;;;;N;;;;10CD7;
+10C98;OLD HUNGARIAN CAPITAL LETTER EM;Lu;0;R;;;;;N;;;;10CD8;
+10C99;OLD HUNGARIAN CAPITAL LETTER EN;Lu;0;R;;;;;N;;;;10CD9;
+10C9A;OLD HUNGARIAN CAPITAL LETTER ENY;Lu;0;R;;;;;N;;;;10CDA;
+10C9B;OLD HUNGARIAN CAPITAL LETTER O;Lu;0;R;;;;;N;;;;10CDB;
+10C9C;OLD HUNGARIAN CAPITAL LETTER OO;Lu;0;R;;;;;N;;;;10CDC;
+10C9D;OLD HUNGARIAN CAPITAL LETTER NIKOLSBURG OE;Lu;0;R;;;;;N;;;;10CDD;
+10C9E;OLD HUNGARIAN CAPITAL LETTER RUDIMENTA OE;Lu;0;R;;;;;N;;;;10CDE;
+10C9F;OLD HUNGARIAN CAPITAL LETTER OEE;Lu;0;R;;;;;N;;;;10CDF;
+10CA0;OLD HUNGARIAN CAPITAL LETTER EP;Lu;0;R;;;;;N;;;;10CE0;
+10CA1;OLD HUNGARIAN CAPITAL LETTER EMP;Lu;0;R;;;;;N;;;;10CE1;
+10CA2;OLD HUNGARIAN CAPITAL LETTER ER;Lu;0;R;;;;;N;;;;10CE2;
+10CA3;OLD HUNGARIAN CAPITAL LETTER SHORT ER;Lu;0;R;;;;;N;;;;10CE3;
+10CA4;OLD HUNGARIAN CAPITAL LETTER ES;Lu;0;R;;;;;N;;;;10CE4;
+10CA5;OLD HUNGARIAN CAPITAL LETTER ESZ;Lu;0;R;;;;;N;;;;10CE5;
+10CA6;OLD HUNGARIAN CAPITAL LETTER ET;Lu;0;R;;;;;N;;;;10CE6;
+10CA7;OLD HUNGARIAN CAPITAL LETTER ENT;Lu;0;R;;;;;N;;;;10CE7;
+10CA8;OLD HUNGARIAN CAPITAL LETTER ETY;Lu;0;R;;;;;N;;;;10CE8;
+10CA9;OLD HUNGARIAN CAPITAL LETTER ECH;Lu;0;R;;;;;N;;;;10CE9;
+10CAA;OLD HUNGARIAN CAPITAL LETTER U;Lu;0;R;;;;;N;;;;10CEA;
+10CAB;OLD HUNGARIAN CAPITAL LETTER UU;Lu;0;R;;;;;N;;;;10CEB;
+10CAC;OLD HUNGARIAN CAPITAL LETTER NIKOLSBURG UE;Lu;0;R;;;;;N;;;;10CEC;
+10CAD;OLD HUNGARIAN CAPITAL LETTER RUDIMENTA UE;Lu;0;R;;;;;N;;;;10CED;
+10CAE;OLD HUNGARIAN CAPITAL LETTER EV;Lu;0;R;;;;;N;;;;10CEE;
+10CAF;OLD HUNGARIAN CAPITAL LETTER EZ;Lu;0;R;;;;;N;;;;10CEF;
+10CB0;OLD HUNGARIAN CAPITAL LETTER EZS;Lu;0;R;;;;;N;;;;10CF0;
+10CB1;OLD HUNGARIAN CAPITAL LETTER ENT-SHAPED SIGN;Lu;0;R;;;;;N;;;;10CF1;
+10CB2;OLD HUNGARIAN CAPITAL LETTER US;Lu;0;R;;;;;N;;;;10CF2;
+10CC0;OLD HUNGARIAN SMALL LETTER A;Ll;0;R;;;;;N;;;10C80;;10C80
+10CC1;OLD HUNGARIAN SMALL LETTER AA;Ll;0;R;;;;;N;;;10C81;;10C81
+10CC2;OLD HUNGARIAN SMALL LETTER EB;Ll;0;R;;;;;N;;;10C82;;10C82
+10CC3;OLD HUNGARIAN SMALL LETTER AMB;Ll;0;R;;;;;N;;;10C83;;10C83
+10CC4;OLD HUNGARIAN SMALL LETTER EC;Ll;0;R;;;;;N;;;10C84;;10C84
+10CC5;OLD HUNGARIAN SMALL LETTER ENC;Ll;0;R;;;;;N;;;10C85;;10C85
+10CC6;OLD HUNGARIAN SMALL LETTER ECS;Ll;0;R;;;;;N;;;10C86;;10C86
+10CC7;OLD HUNGARIAN SMALL LETTER ED;Ll;0;R;;;;;N;;;10C87;;10C87
+10CC8;OLD HUNGARIAN SMALL LETTER AND;Ll;0;R;;;;;N;;;10C88;;10C88
+10CC9;OLD HUNGARIAN SMALL LETTER E;Ll;0;R;;;;;N;;;10C89;;10C89
+10CCA;OLD HUNGARIAN SMALL LETTER CLOSE E;Ll;0;R;;;;;N;;;10C8A;;10C8A
+10CCB;OLD HUNGARIAN SMALL LETTER EE;Ll;0;R;;;;;N;;;10C8B;;10C8B
+10CCC;OLD HUNGARIAN SMALL LETTER EF;Ll;0;R;;;;;N;;;10C8C;;10C8C
+10CCD;OLD HUNGARIAN SMALL LETTER EG;Ll;0;R;;;;;N;;;10C8D;;10C8D
+10CCE;OLD HUNGARIAN SMALL LETTER EGY;Ll;0;R;;;;;N;;;10C8E;;10C8E
+10CCF;OLD HUNGARIAN SMALL LETTER EH;Ll;0;R;;;;;N;;;10C8F;;10C8F
+10CD0;OLD HUNGARIAN SMALL LETTER I;Ll;0;R;;;;;N;;;10C90;;10C90
+10CD1;OLD HUNGARIAN SMALL LETTER II;Ll;0;R;;;;;N;;;10C91;;10C91
+10CD2;OLD HUNGARIAN SMALL LETTER EJ;Ll;0;R;;;;;N;;;10C92;;10C92
+10CD3;OLD HUNGARIAN SMALL LETTER EK;Ll;0;R;;;;;N;;;10C93;;10C93
+10CD4;OLD HUNGARIAN SMALL LETTER AK;Ll;0;R;;;;;N;;;10C94;;10C94
+10CD5;OLD HUNGARIAN SMALL LETTER UNK;Ll;0;R;;;;;N;;;10C95;;10C95
+10CD6;OLD HUNGARIAN SMALL LETTER EL;Ll;0;R;;;;;N;;;10C96;;10C96
+10CD7;OLD HUNGARIAN SMALL LETTER ELY;Ll;0;R;;;;;N;;;10C97;;10C97
+10CD8;OLD HUNGARIAN SMALL LETTER EM;Ll;0;R;;;;;N;;;10C98;;10C98
+10CD9;OLD HUNGARIAN SMALL LETTER EN;Ll;0;R;;;;;N;;;10C99;;10C99
+10CDA;OLD HUNGARIAN SMALL LETTER ENY;Ll;0;R;;;;;N;;;10C9A;;10C9A
+10CDB;OLD HUNGARIAN SMALL LETTER O;Ll;0;R;;;;;N;;;10C9B;;10C9B
+10CDC;OLD HUNGARIAN SMALL LETTER OO;Ll;0;R;;;;;N;;;10C9C;;10C9C
+10CDD;OLD HUNGARIAN SMALL LETTER NIKOLSBURG OE;Ll;0;R;;;;;N;;;10C9D;;10C9D
+10CDE;OLD HUNGARIAN SMALL LETTER RUDIMENTA OE;Ll;0;R;;;;;N;;;10C9E;;10C9E
+10CDF;OLD HUNGARIAN SMALL LETTER OEE;Ll;0;R;;;;;N;;;10C9F;;10C9F
+10CE0;OLD HUNGARIAN SMALL LETTER EP;Ll;0;R;;;;;N;;;10CA0;;10CA0
+10CE1;OLD HUNGARIAN SMALL LETTER EMP;Ll;0;R;;;;;N;;;10CA1;;10CA1
+10CE2;OLD HUNGARIAN SMALL LETTER ER;Ll;0;R;;;;;N;;;10CA2;;10CA2
+10CE3;OLD HUNGARIAN SMALL LETTER SHORT ER;Ll;0;R;;;;;N;;;10CA3;;10CA3
+10CE4;OLD HUNGARIAN SMALL LETTER ES;Ll;0;R;;;;;N;;;10CA4;;10CA4
+10CE5;OLD HUNGARIAN SMALL LETTER ESZ;Ll;0;R;;;;;N;;;10CA5;;10CA5
+10CE6;OLD HUNGARIAN SMALL LETTER ET;Ll;0;R;;;;;N;;;10CA6;;10CA6
+10CE7;OLD HUNGARIAN SMALL LETTER ENT;Ll;0;R;;;;;N;;;10CA7;;10CA7
+10CE8;OLD HUNGARIAN SMALL LETTER ETY;Ll;0;R;;;;;N;;;10CA8;;10CA8
+10CE9;OLD HUNGARIAN SMALL LETTER ECH;Ll;0;R;;;;;N;;;10CA9;;10CA9
+10CEA;OLD HUNGARIAN SMALL LETTER U;Ll;0;R;;;;;N;;;10CAA;;10CAA
+10CEB;OLD HUNGARIAN SMALL LETTER UU;Ll;0;R;;;;;N;;;10CAB;;10CAB
+10CEC;OLD HUNGARIAN SMALL LETTER NIKOLSBURG UE;Ll;0;R;;;;;N;;;10CAC;;10CAC
+10CED;OLD HUNGARIAN SMALL LETTER RUDIMENTA UE;Ll;0;R;;;;;N;;;10CAD;;10CAD
+10CEE;OLD HUNGARIAN SMALL LETTER EV;Ll;0;R;;;;;N;;;10CAE;;10CAE
+10CEF;OLD HUNGARIAN SMALL LETTER EZ;Ll;0;R;;;;;N;;;10CAF;;10CAF
+10CF0;OLD HUNGARIAN SMALL LETTER EZS;Ll;0;R;;;;;N;;;10CB0;;10CB0
+10CF1;OLD HUNGARIAN SMALL LETTER ENT-SHAPED SIGN;Ll;0;R;;;;;N;;;10CB1;;10CB1
+10CF2;OLD HUNGARIAN SMALL LETTER US;Ll;0;R;;;;;N;;;10CB2;;10CB2
+10CFA;OLD HUNGARIAN NUMBER ONE;No;0;R;;;;1;N;;;;;
+10CFB;OLD HUNGARIAN NUMBER FIVE;No;0;R;;;;5;N;;;;;
+10CFC;OLD HUNGARIAN NUMBER TEN;No;0;R;;;;10;N;;;;;
+10CFD;OLD HUNGARIAN NUMBER FIFTY;No;0;R;;;;50;N;;;;;
+10CFE;OLD HUNGARIAN NUMBER ONE HUNDRED;No;0;R;;;;100;N;;;;;
+10CFF;OLD HUNGARIAN NUMBER ONE THOUSAND;No;0;R;;;;1000;N;;;;;
+10D00;HANIFI ROHINGYA LETTER A;Lo;0;AL;;;;;N;;;;;
+10D01;HANIFI ROHINGYA LETTER BA;Lo;0;AL;;;;;N;;;;;
+10D02;HANIFI ROHINGYA LETTER PA;Lo;0;AL;;;;;N;;;;;
+10D03;HANIFI ROHINGYA LETTER TA;Lo;0;AL;;;;;N;;;;;
+10D04;HANIFI ROHINGYA LETTER TTA;Lo;0;AL;;;;;N;;;;;
+10D05;HANIFI ROHINGYA LETTER JA;Lo;0;AL;;;;;N;;;;;
+10D06;HANIFI ROHINGYA LETTER CA;Lo;0;AL;;;;;N;;;;;
+10D07;HANIFI ROHINGYA LETTER HA;Lo;0;AL;;;;;N;;;;;
+10D08;HANIFI ROHINGYA LETTER KHA;Lo;0;AL;;;;;N;;;;;
+10D09;HANIFI ROHINGYA LETTER FA;Lo;0;AL;;;;;N;;;;;
+10D0A;HANIFI ROHINGYA LETTER DA;Lo;0;AL;;;;;N;;;;;
+10D0B;HANIFI ROHINGYA LETTER DDA;Lo;0;AL;;;;;N;;;;;
+10D0C;HANIFI ROHINGYA LETTER RA;Lo;0;AL;;;;;N;;;;;
+10D0D;HANIFI ROHINGYA LETTER RRA;Lo;0;AL;;;;;N;;;;;
+10D0E;HANIFI ROHINGYA LETTER ZA;Lo;0;AL;;;;;N;;;;;
+10D0F;HANIFI ROHINGYA LETTER SA;Lo;0;AL;;;;;N;;;;;
+10D10;HANIFI ROHINGYA LETTER SHA;Lo;0;AL;;;;;N;;;;;
+10D11;HANIFI ROHINGYA LETTER KA;Lo;0;AL;;;;;N;;;;;
+10D12;HANIFI ROHINGYA LETTER GA;Lo;0;AL;;;;;N;;;;;
+10D13;HANIFI ROHINGYA LETTER LA;Lo;0;AL;;;;;N;;;;;
+10D14;HANIFI ROHINGYA LETTER MA;Lo;0;AL;;;;;N;;;;;
+10D15;HANIFI ROHINGYA LETTER NA;Lo;0;AL;;;;;N;;;;;
+10D16;HANIFI ROHINGYA LETTER WA;Lo;0;AL;;;;;N;;;;;
+10D17;HANIFI ROHINGYA LETTER KINNA WA;Lo;0;AL;;;;;N;;;;;
+10D18;HANIFI ROHINGYA LETTER YA;Lo;0;AL;;;;;N;;;;;
+10D19;HANIFI ROHINGYA LETTER KINNA YA;Lo;0;AL;;;;;N;;;;;
+10D1A;HANIFI ROHINGYA LETTER NGA;Lo;0;AL;;;;;N;;;;;
+10D1B;HANIFI ROHINGYA LETTER NYA;Lo;0;AL;;;;;N;;;;;
+10D1C;HANIFI ROHINGYA LETTER VA;Lo;0;AL;;;;;N;;;;;
+10D1D;HANIFI ROHINGYA VOWEL A;Lo;0;AL;;;;;N;;;;;
+10D1E;HANIFI ROHINGYA VOWEL I;Lo;0;AL;;;;;N;;;;;
+10D1F;HANIFI ROHINGYA VOWEL U;Lo;0;AL;;;;;N;;;;;
+10D20;HANIFI ROHINGYA VOWEL E;Lo;0;AL;;;;;N;;;;;
+10D21;HANIFI ROHINGYA VOWEL O;Lo;0;AL;;;;;N;;;;;
+10D22;HANIFI ROHINGYA MARK SAKIN;Lo;0;AL;;;;;N;;;;;
+10D23;HANIFI ROHINGYA MARK NA KHONNA;Lo;0;AL;;;;;N;;;;;
+10D24;HANIFI ROHINGYA SIGN HARBAHAY;Mn;230;NSM;;;;;N;;;;;
+10D25;HANIFI ROHINGYA SIGN TAHALA;Mn;230;NSM;;;;;N;;;;;
+10D26;HANIFI ROHINGYA SIGN TANA;Mn;230;NSM;;;;;N;;;;;
+10D27;HANIFI ROHINGYA SIGN TASSI;Mn;230;NSM;;;;;N;;;;;
+10D30;HANIFI ROHINGYA DIGIT ZERO;Nd;0;AN;;0;0;0;N;;;;;
+10D31;HANIFI ROHINGYA DIGIT ONE;Nd;0;AN;;1;1;1;N;;;;;
+10D32;HANIFI ROHINGYA DIGIT TWO;Nd;0;AN;;2;2;2;N;;;;;
+10D33;HANIFI ROHINGYA DIGIT THREE;Nd;0;AN;;3;3;3;N;;;;;
+10D34;HANIFI ROHINGYA DIGIT FOUR;Nd;0;AN;;4;4;4;N;;;;;
+10D35;HANIFI ROHINGYA DIGIT FIVE;Nd;0;AN;;5;5;5;N;;;;;
+10D36;HANIFI ROHINGYA DIGIT SIX;Nd;0;AN;;6;6;6;N;;;;;
+10D37;HANIFI ROHINGYA DIGIT SEVEN;Nd;0;AN;;7;7;7;N;;;;;
+10D38;HANIFI ROHINGYA DIGIT EIGHT;Nd;0;AN;;8;8;8;N;;;;;
+10D39;HANIFI ROHINGYA DIGIT NINE;Nd;0;AN;;9;9;9;N;;;;;
+10D40;GARAY DIGIT ZERO;Nd;0;AN;;0;0;0;N;;;;;
+10D41;GARAY DIGIT ONE;Nd;0;AN;;1;1;1;N;;;;;
+10D42;GARAY DIGIT TWO;Nd;0;AN;;2;2;2;N;;;;;
+10D43;GARAY DIGIT THREE;Nd;0;AN;;3;3;3;N;;;;;
+10D44;GARAY DIGIT FOUR;Nd;0;AN;;4;4;4;N;;;;;
+10D45;GARAY DIGIT FIVE;Nd;0;AN;;5;5;5;N;;;;;
+10D46;GARAY DIGIT SIX;Nd;0;AN;;6;6;6;N;;;;;
+10D47;GARAY DIGIT SEVEN;Nd;0;AN;;7;7;7;N;;;;;
+10D48;GARAY DIGIT EIGHT;Nd;0;AN;;8;8;8;N;;;;;
+10D49;GARAY DIGIT NINE;Nd;0;AN;;9;9;9;N;;;;;
+10D4A;GARAY VOWEL SIGN A;Lo;0;R;;;;;N;;;;;
+10D4B;GARAY VOWEL SIGN I;Lo;0;R;;;;;N;;;;;
+10D4C;GARAY VOWEL SIGN O;Lo;0;R;;;;;N;;;;;
+10D4D;GARAY VOWEL SIGN EE;Lo;0;R;;;;;N;;;;;
+10D4E;GARAY VOWEL LENGTH MARK;Lm;0;R;;;;;N;;;;;
+10D4F;GARAY SUKUN;Lo;0;R;;;;;N;;;;;
+10D50;GARAY CAPITAL LETTER A;Lu;0;R;;;;;N;;;;10D70;
+10D51;GARAY CAPITAL LETTER CA;Lu;0;R;;;;;N;;;;10D71;
+10D52;GARAY CAPITAL LETTER MA;Lu;0;R;;;;;N;;;;10D72;
+10D53;GARAY CAPITAL LETTER KA;Lu;0;R;;;;;N;;;;10D73;
+10D54;GARAY CAPITAL LETTER BA;Lu;0;R;;;;;N;;;;10D74;
+10D55;GARAY CAPITAL LETTER JA;Lu;0;R;;;;;N;;;;10D75;
+10D56;GARAY CAPITAL LETTER SA;Lu;0;R;;;;;N;;;;10D76;
+10D57;GARAY CAPITAL LETTER WA;Lu;0;R;;;;;N;;;;10D77;
+10D58;GARAY CAPITAL LETTER LA;Lu;0;R;;;;;N;;;;10D78;
+10D59;GARAY CAPITAL LETTER GA;Lu;0;R;;;;;N;;;;10D79;
+10D5A;GARAY CAPITAL LETTER DA;Lu;0;R;;;;;N;;;;10D7A;
+10D5B;GARAY CAPITAL LETTER XA;Lu;0;R;;;;;N;;;;10D7B;
+10D5C;GARAY CAPITAL LETTER YA;Lu;0;R;;;;;N;;;;10D7C;
+10D5D;GARAY CAPITAL LETTER TA;Lu;0;R;;;;;N;;;;10D7D;
+10D5E;GARAY CAPITAL LETTER RA;Lu;0;R;;;;;N;;;;10D7E;
+10D5F;GARAY CAPITAL LETTER NYA;Lu;0;R;;;;;N;;;;10D7F;
+10D60;GARAY CAPITAL LETTER FA;Lu;0;R;;;;;N;;;;10D80;
+10D61;GARAY CAPITAL LETTER NA;Lu;0;R;;;;;N;;;;10D81;
+10D62;GARAY CAPITAL LETTER PA;Lu;0;R;;;;;N;;;;10D82;
+10D63;GARAY CAPITAL LETTER HA;Lu;0;R;;;;;N;;;;10D83;
+10D64;GARAY CAPITAL LETTER OLD KA;Lu;0;R;;;;;N;;;;10D84;
+10D65;GARAY CAPITAL LETTER OLD NA;Lu;0;R;;;;;N;;;;10D85;
+10D69;GARAY VOWEL SIGN E;Mn;230;NSM;;;;;N;;;;;
+10D6A;GARAY CONSONANT GEMINATION MARK;Mn;230;NSM;;;;;N;;;;;
+10D6B;GARAY COMBINING DOT ABOVE;Mn;230;NSM;;;;;N;;;;;
+10D6C;GARAY COMBINING DOUBLE DOT ABOVE;Mn;230;NSM;;;;;N;;;;;
+10D6D;GARAY CONSONANT NASALIZATION MARK;Mn;230;NSM;;;;;N;;;;;
+10D6E;GARAY HYPHEN;Pd;0;ON;;;;;N;;;;;
+10D6F;GARAY REDUPLICATION MARK;Lm;0;R;;;;;N;;;;;
+10D70;GARAY SMALL LETTER A;Ll;0;R;;;;;N;;;10D50;;10D50
+10D71;GARAY SMALL LETTER CA;Ll;0;R;;;;;N;;;10D51;;10D51
+10D72;GARAY SMALL LETTER MA;Ll;0;R;;;;;N;;;10D52;;10D52
+10D73;GARAY SMALL LETTER KA;Ll;0;R;;;;;N;;;10D53;;10D53
+10D74;GARAY SMALL LETTER BA;Ll;0;R;;;;;N;;;10D54;;10D54
+10D75;GARAY SMALL LETTER JA;Ll;0;R;;;;;N;;;10D55;;10D55
+10D76;GARAY SMALL LETTER SA;Ll;0;R;;;;;N;;;10D56;;10D56
+10D77;GARAY SMALL LETTER WA;Ll;0;R;;;;;N;;;10D57;;10D57
+10D78;GARAY SMALL LETTER LA;Ll;0;R;;;;;N;;;10D58;;10D58
+10D79;GARAY SMALL LETTER GA;Ll;0;R;;;;;N;;;10D59;;10D59
+10D7A;GARAY SMALL LETTER DA;Ll;0;R;;;;;N;;;10D5A;;10D5A
+10D7B;GARAY SMALL LETTER XA;Ll;0;R;;;;;N;;;10D5B;;10D5B
+10D7C;GARAY SMALL LETTER YA;Ll;0;R;;;;;N;;;10D5C;;10D5C
+10D7D;GARAY SMALL LETTER TA;Ll;0;R;;;;;N;;;10D5D;;10D5D
+10D7E;GARAY SMALL LETTER RA;Ll;0;R;;;;;N;;;10D5E;;10D5E
+10D7F;GARAY SMALL LETTER NYA;Ll;0;R;;;;;N;;;10D5F;;10D5F
+10D80;GARAY SMALL LETTER FA;Ll;0;R;;;;;N;;;10D60;;10D60
+10D81;GARAY SMALL LETTER NA;Ll;0;R;;;;;N;;;10D61;;10D61
+10D82;GARAY SMALL LETTER PA;Ll;0;R;;;;;N;;;10D62;;10D62
+10D83;GARAY SMALL LETTER HA;Ll;0;R;;;;;N;;;10D63;;10D63
+10D84;GARAY SMALL LETTER OLD KA;Ll;0;R;;;;;N;;;10D64;;10D64
+10D85;GARAY SMALL LETTER OLD NA;Ll;0;R;;;;;N;;;10D65;;10D65
+10D8E;GARAY PLUS SIGN;Sm;0;R;;;;;N;;;;;
+10D8F;GARAY MINUS SIGN;Sm;0;R;;;;;N;;;;;
 10E60;RUMI DIGIT ONE;No;0;AN;;;1;1;N;;;;;
 10E61;RUMI DIGIT TWO;No;0;AN;;;2;2;N;;;;;
 10E62;RUMI DIGIT THREE;No;0;AN;;;3;3;N;;;;;
@@ -18375,6 +19579,233 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 10E7C;RUMI FRACTION ONE QUARTER;No;0;AN;;;;1/4;N;;;;;
 10E7D;RUMI FRACTION ONE THIRD;No;0;AN;;;;1/3;N;;;;;
 10E7E;RUMI FRACTION TWO THIRDS;No;0;AN;;;;2/3;N;;;;;
+10E80;YEZIDI LETTER ELIF;Lo;0;R;;;;;N;;;;;
+10E81;YEZIDI LETTER BE;Lo;0;R;;;;;N;;;;;
+10E82;YEZIDI LETTER PE;Lo;0;R;;;;;N;;;;;
+10E83;YEZIDI LETTER PHE;Lo;0;R;;;;;N;;;;;
+10E84;YEZIDI LETTER THE;Lo;0;R;;;;;N;;;;;
+10E85;YEZIDI LETTER SE;Lo;0;R;;;;;N;;;;;
+10E86;YEZIDI LETTER CIM;Lo;0;R;;;;;N;;;;;
+10E87;YEZIDI LETTER CHIM;Lo;0;R;;;;;N;;;;;
+10E88;YEZIDI LETTER CHHIM;Lo;0;R;;;;;N;;;;;
+10E89;YEZIDI LETTER HHA;Lo;0;R;;;;;N;;;;;
+10E8A;YEZIDI LETTER XA;Lo;0;R;;;;;N;;;;;
+10E8B;YEZIDI LETTER DAL;Lo;0;R;;;;;N;;;;;
+10E8C;YEZIDI LETTER ZAL;Lo;0;R;;;;;N;;;;;
+10E8D;YEZIDI LETTER RA;Lo;0;R;;;;;N;;;;;
+10E8E;YEZIDI LETTER RHA;Lo;0;R;;;;;N;;;;;
+10E8F;YEZIDI LETTER ZA;Lo;0;R;;;;;N;;;;;
+10E90;YEZIDI LETTER JA;Lo;0;R;;;;;N;;;;;
+10E91;YEZIDI LETTER SIN;Lo;0;R;;;;;N;;;;;
+10E92;YEZIDI LETTER SHIN;Lo;0;R;;;;;N;;;;;
+10E93;YEZIDI LETTER SAD;Lo;0;R;;;;;N;;;;;
+10E94;YEZIDI LETTER DAD;Lo;0;R;;;;;N;;;;;
+10E95;YEZIDI LETTER TA;Lo;0;R;;;;;N;;;;;
+10E96;YEZIDI LETTER ZE;Lo;0;R;;;;;N;;;;;
+10E97;YEZIDI LETTER EYN;Lo;0;R;;;;;N;;;;;
+10E98;YEZIDI LETTER XHEYN;Lo;0;R;;;;;N;;;;;
+10E99;YEZIDI LETTER FA;Lo;0;R;;;;;N;;;;;
+10E9A;YEZIDI LETTER VA;Lo;0;R;;;;;N;;;;;
+10E9B;YEZIDI LETTER VA ALTERNATE FORM;Lo;0;R;;;;;N;;;;;
+10E9C;YEZIDI LETTER QAF;Lo;0;R;;;;;N;;;;;
+10E9D;YEZIDI LETTER KAF;Lo;0;R;;;;;N;;;;;
+10E9E;YEZIDI LETTER KHAF;Lo;0;R;;;;;N;;;;;
+10E9F;YEZIDI LETTER GAF;Lo;0;R;;;;;N;;;;;
+10EA0;YEZIDI LETTER LAM;Lo;0;R;;;;;N;;;;;
+10EA1;YEZIDI LETTER MIM;Lo;0;R;;;;;N;;;;;
+10EA2;YEZIDI LETTER NUN;Lo;0;R;;;;;N;;;;;
+10EA3;YEZIDI LETTER UM;Lo;0;R;;;;;N;;;;;
+10EA4;YEZIDI LETTER WAW;Lo;0;R;;;;;N;;;;;
+10EA5;YEZIDI LETTER OW;Lo;0;R;;;;;N;;;;;
+10EA6;YEZIDI LETTER EW;Lo;0;R;;;;;N;;;;;
+10EA7;YEZIDI LETTER HAY;Lo;0;R;;;;;N;;;;;
+10EA8;YEZIDI LETTER YOT;Lo;0;R;;;;;N;;;;;
+10EA9;YEZIDI LETTER ET;Lo;0;R;;;;;N;;;;;
+10EAB;YEZIDI COMBINING HAMZA MARK;Mn;230;NSM;;;;;N;;;;;
+10EAC;YEZIDI COMBINING MADDA MARK;Mn;230;NSM;;;;;N;;;;;
+10EAD;YEZIDI HYPHENATION MARK;Pd;0;R;;;;;N;;;;;
+10EB0;YEZIDI LETTER LAM WITH DOT ABOVE;Lo;0;R;;;;;N;;;;;
+10EB1;YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE;Lo;0;R;;;;;N;;;;;
+10EC2;ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW;Lo;0;AL;;;;;N;;;;;
+10EC3;ARABIC LETTER TAH WITH TWO DOTS VERTICALLY BELOW;Lo;0;AL;;;;;N;;;;;
+10EC4;ARABIC LETTER KAF WITH TWO DOTS VERTICALLY BELOW;Lo;0;AL;;;;;N;;;;;
+10EC5;ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW;Lm;0;AL;;;;;N;;;;;
+10EC6;ARABIC LETTER THIN NOON;Lo;0;AL;;;;;N;;;;;
+10EC7;ARABIC LETTER YEH WITH FOUR DOTS BELOW;Lo;0;AL;;;;;N;;;;;
+10ED0;ARABIC BIBLICAL END OF VERSE;Po;0;ON;;;;;N;;;;;
+10ED1;ARABIC LIGATURE ALAYHAA AS-SALAATU WAS-SALAAM;So;0;ON;;;;;N;;;;;
+10ED2;ARABIC LIGATURE ALAYHIM AS-SALAATU WAS-SALAAM;So;0;ON;;;;;N;;;;;
+10ED3;ARABIC LIGATURE ALAYHIMAA AS-SALAATU WAS-SALAAM;So;0;ON;;;;;N;;;;;
+10ED4;ARABIC LIGATURE QADDASA ALLAAHU SIRRAH;So;0;ON;;;;;N;;;;;
+10ED5;ARABIC LIGATURE QUDDISA SIRRUHUM;So;0;ON;;;;;N;;;;;
+10ED6;ARABIC LIGATURE QUDDISA SIRRUHUMAA;So;0;ON;;;;;N;;;;;
+10ED7;ARABIC LIGATURE QUDDISAT ASRAARUHUM;So;0;ON;;;;;N;;;;;
+10ED8;ARABIC LIGATURE NAWWARA ALLAAHU MARQADAH;So;0;ON;;;;;N;;;;;
+10EFA;ARABIC DOUBLE VERTICAL BAR BELOW;Mn;220;NSM;;;;;N;;;;;
+10EFB;ARABIC SMALL LOW NOON;Mn;220;NSM;;;;;N;;;;;
+10EFC;ARABIC COMBINING ALEF OVERLAY;Mn;0;NSM;;;;;N;;;;;
+10EFD;ARABIC SMALL LOW WORD SAKTA;Mn;220;NSM;;;;;N;;;;;
+10EFE;ARABIC SMALL LOW WORD QASR;Mn;220;NSM;;;;;N;;;;;
+10EFF;ARABIC SMALL LOW WORD MADDA;Mn;220;NSM;;;;;N;;;;;
+10F00;OLD SOGDIAN LETTER ALEPH;Lo;0;R;;;;;N;;;;;
+10F01;OLD SOGDIAN LETTER FINAL ALEPH;Lo;0;R;;;;;N;;;;;
+10F02;OLD SOGDIAN LETTER BETH;Lo;0;R;;;;;N;;;;;
+10F03;OLD SOGDIAN LETTER FINAL BETH;Lo;0;R;;;;;N;;;;;
+10F04;OLD SOGDIAN LETTER GIMEL;Lo;0;R;;;;;N;;;;;
+10F05;OLD SOGDIAN LETTER HE;Lo;0;R;;;;;N;;;;;
+10F06;OLD SOGDIAN LETTER FINAL HE;Lo;0;R;;;;;N;;;;;
+10F07;OLD SOGDIAN LETTER WAW;Lo;0;R;;;;;N;;;;;
+10F08;OLD SOGDIAN LETTER ZAYIN;Lo;0;R;;;;;N;;;;;
+10F09;OLD SOGDIAN LETTER HETH;Lo;0;R;;;;;N;;;;;
+10F0A;OLD SOGDIAN LETTER YODH;Lo;0;R;;;;;N;;;;;
+10F0B;OLD SOGDIAN LETTER KAPH;Lo;0;R;;;;;N;;;;;
+10F0C;OLD SOGDIAN LETTER LAMEDH;Lo;0;R;;;;;N;;;;;
+10F0D;OLD SOGDIAN LETTER MEM;Lo;0;R;;;;;N;;;;;
+10F0E;OLD SOGDIAN LETTER NUN;Lo;0;R;;;;;N;;;;;
+10F0F;OLD SOGDIAN LETTER FINAL NUN;Lo;0;R;;;;;N;;;;;
+10F10;OLD SOGDIAN LETTER FINAL NUN WITH VERTICAL TAIL;Lo;0;R;;;;;N;;;;;
+10F11;OLD SOGDIAN LETTER SAMEKH;Lo;0;R;;;;;N;;;;;
+10F12;OLD SOGDIAN LETTER AYIN;Lo;0;R;;;;;N;;;;;
+10F13;OLD SOGDIAN LETTER ALTERNATE AYIN;Lo;0;R;;;;;N;;;;;
+10F14;OLD SOGDIAN LETTER PE;Lo;0;R;;;;;N;;;;;
+10F15;OLD SOGDIAN LETTER SADHE;Lo;0;R;;;;;N;;;;;
+10F16;OLD SOGDIAN LETTER FINAL SADHE;Lo;0;R;;;;;N;;;;;
+10F17;OLD SOGDIAN LETTER FINAL SADHE WITH VERTICAL TAIL;Lo;0;R;;;;;N;;;;;
+10F18;OLD SOGDIAN LETTER RESH-AYIN-DALETH;Lo;0;R;;;;;N;;;;;
+10F19;OLD SOGDIAN LETTER SHIN;Lo;0;R;;;;;N;;;;;
+10F1A;OLD SOGDIAN LETTER TAW;Lo;0;R;;;;;N;;;;;
+10F1B;OLD SOGDIAN LETTER FINAL TAW;Lo;0;R;;;;;N;;;;;
+10F1C;OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL;Lo;0;R;;;;;N;;;;;
+10F1D;OLD SOGDIAN NUMBER ONE;No;0;R;;;;1;N;;;;;
+10F1E;OLD SOGDIAN NUMBER TWO;No;0;R;;;;2;N;;;;;
+10F1F;OLD SOGDIAN NUMBER THREE;No;0;R;;;;3;N;;;;;
+10F20;OLD SOGDIAN NUMBER FOUR;No;0;R;;;;4;N;;;;;
+10F21;OLD SOGDIAN NUMBER FIVE;No;0;R;;;;5;N;;;;;
+10F22;OLD SOGDIAN NUMBER TEN;No;0;R;;;;10;N;;;;;
+10F23;OLD SOGDIAN NUMBER TWENTY;No;0;R;;;;20;N;;;;;
+10F24;OLD SOGDIAN NUMBER THIRTY;No;0;R;;;;30;N;;;;;
+10F25;OLD SOGDIAN NUMBER ONE HUNDRED;No;0;R;;;;100;N;;;;;
+10F26;OLD SOGDIAN FRACTION ONE HALF;No;0;R;;;;1/2;N;;;;;
+10F27;OLD SOGDIAN LIGATURE AYIN-DALETH;Lo;0;R;;;;;N;;;;;
+10F30;SOGDIAN LETTER ALEPH;Lo;0;AL;;;;;N;;;;;
+10F31;SOGDIAN LETTER BETH;Lo;0;AL;;;;;N;;;;;
+10F32;SOGDIAN LETTER GIMEL;Lo;0;AL;;;;;N;;;;;
+10F33;SOGDIAN LETTER HE;Lo;0;AL;;;;;N;;;;;
+10F34;SOGDIAN LETTER WAW;Lo;0;AL;;;;;N;;;;;
+10F35;SOGDIAN LETTER ZAYIN;Lo;0;AL;;;;;N;;;;;
+10F36;SOGDIAN LETTER HETH;Lo;0;AL;;;;;N;;;;;
+10F37;SOGDIAN LETTER YODH;Lo;0;AL;;;;;N;;;;;
+10F38;SOGDIAN LETTER KAPH;Lo;0;AL;;;;;N;;;;;
+10F39;SOGDIAN LETTER LAMEDH;Lo;0;AL;;;;;N;;;;;
+10F3A;SOGDIAN LETTER MEM;Lo;0;AL;;;;;N;;;;;
+10F3B;SOGDIAN LETTER NUN;Lo;0;AL;;;;;N;;;;;
+10F3C;SOGDIAN LETTER SAMEKH;Lo;0;AL;;;;;N;;;;;
+10F3D;SOGDIAN LETTER AYIN;Lo;0;AL;;;;;N;;;;;
+10F3E;SOGDIAN LETTER PE;Lo;0;AL;;;;;N;;;;;
+10F3F;SOGDIAN LETTER SADHE;Lo;0;AL;;;;;N;;;;;
+10F40;SOGDIAN LETTER RESH-AYIN;Lo;0;AL;;;;;N;;;;;
+10F41;SOGDIAN LETTER SHIN;Lo;0;AL;;;;;N;;;;;
+10F42;SOGDIAN LETTER TAW;Lo;0;AL;;;;;N;;;;;
+10F43;SOGDIAN LETTER FETH;Lo;0;AL;;;;;N;;;;;
+10F44;SOGDIAN LETTER LESH;Lo;0;AL;;;;;N;;;;;
+10F45;SOGDIAN INDEPENDENT SHIN;Lo;0;AL;;;;;N;;;;;
+10F46;SOGDIAN COMBINING DOT BELOW;Mn;220;NSM;;;;;N;;;;;
+10F47;SOGDIAN COMBINING TWO DOTS BELOW;Mn;220;NSM;;;;;N;;;;;
+10F48;SOGDIAN COMBINING DOT ABOVE;Mn;230;NSM;;;;;N;;;;;
+10F49;SOGDIAN COMBINING TWO DOTS ABOVE;Mn;230;NSM;;;;;N;;;;;
+10F4A;SOGDIAN COMBINING CURVE ABOVE;Mn;230;NSM;;;;;N;;;;;
+10F4B;SOGDIAN COMBINING CURVE BELOW;Mn;220;NSM;;;;;N;;;;;
+10F4C;SOGDIAN COMBINING HOOK ABOVE;Mn;230;NSM;;;;;N;;;;;
+10F4D;SOGDIAN COMBINING HOOK BELOW;Mn;220;NSM;;;;;N;;;;;
+10F4E;SOGDIAN COMBINING LONG HOOK BELOW;Mn;220;NSM;;;;;N;;;;;
+10F4F;SOGDIAN COMBINING RESH BELOW;Mn;220;NSM;;;;;N;;;;;
+10F50;SOGDIAN COMBINING STROKE BELOW;Mn;220;NSM;;;;;N;;;;;
+10F51;SOGDIAN NUMBER ONE;No;0;AL;;;;1;N;;;;;
+10F52;SOGDIAN NUMBER TEN;No;0;AL;;;;10;N;;;;;
+10F53;SOGDIAN NUMBER TWENTY;No;0;AL;;;;20;N;;;;;
+10F54;SOGDIAN NUMBER ONE HUNDRED;No;0;AL;;;;100;N;;;;;
+10F55;SOGDIAN PUNCTUATION TWO VERTICAL BARS;Po;0;AL;;;;;N;;;;;
+10F56;SOGDIAN PUNCTUATION TWO VERTICAL BARS WITH DOTS;Po;0;AL;;;;;N;;;;;
+10F57;SOGDIAN PUNCTUATION CIRCLE WITH DOT;Po;0;AL;;;;;N;;;;;
+10F58;SOGDIAN PUNCTUATION TWO CIRCLES WITH DOTS;Po;0;AL;;;;;N;;;;;
+10F59;SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT;Po;0;AL;;;;;N;;;;;
+10F70;OLD UYGHUR LETTER ALEPH;Lo;0;R;;;;;N;;;;;
+10F71;OLD UYGHUR LETTER BETH;Lo;0;R;;;;;N;;;;;
+10F72;OLD UYGHUR LETTER GIMEL-HETH;Lo;0;R;;;;;N;;;;;
+10F73;OLD UYGHUR LETTER WAW;Lo;0;R;;;;;N;;;;;
+10F74;OLD UYGHUR LETTER ZAYIN;Lo;0;R;;;;;N;;;;;
+10F75;OLD UYGHUR LETTER FINAL HETH;Lo;0;R;;;;;N;;;;;
+10F76;OLD UYGHUR LETTER YODH;Lo;0;R;;;;;N;;;;;
+10F77;OLD UYGHUR LETTER KAPH;Lo;0;R;;;;;N;;;;;
+10F78;OLD UYGHUR LETTER LAMEDH;Lo;0;R;;;;;N;;;;;
+10F79;OLD UYGHUR LETTER MEM;Lo;0;R;;;;;N;;;;;
+10F7A;OLD UYGHUR LETTER NUN;Lo;0;R;;;;;N;;;;;
+10F7B;OLD UYGHUR LETTER SAMEKH;Lo;0;R;;;;;N;;;;;
+10F7C;OLD UYGHUR LETTER PE;Lo;0;R;;;;;N;;;;;
+10F7D;OLD UYGHUR LETTER SADHE;Lo;0;R;;;;;N;;;;;
+10F7E;OLD UYGHUR LETTER RESH;Lo;0;R;;;;;N;;;;;
+10F7F;OLD UYGHUR LETTER SHIN;Lo;0;R;;;;;N;;;;;
+10F80;OLD UYGHUR LETTER TAW;Lo;0;R;;;;;N;;;;;
+10F81;OLD UYGHUR LETTER LESH;Lo;0;R;;;;;N;;;;;
+10F82;OLD UYGHUR COMBINING DOT ABOVE;Mn;230;NSM;;;;;N;;;;;
+10F83;OLD UYGHUR COMBINING DOT BELOW;Mn;220;NSM;;;;;N;;;;;
+10F84;OLD UYGHUR COMBINING TWO DOTS ABOVE;Mn;230;NSM;;;;;N;;;;;
+10F85;OLD UYGHUR COMBINING TWO DOTS BELOW;Mn;220;NSM;;;;;N;;;;;
+10F86;OLD UYGHUR PUNCTUATION BAR;Po;0;R;;;;;N;;;;;
+10F87;OLD UYGHUR PUNCTUATION TWO BARS;Po;0;R;;;;;N;;;;;
+10F88;OLD UYGHUR PUNCTUATION TWO DOTS;Po;0;R;;;;;N;;;;;
+10F89;OLD UYGHUR PUNCTUATION FOUR DOTS;Po;0;R;;;;;N;;;;;
+10FB0;CHORASMIAN LETTER ALEPH;Lo;0;R;;;;;N;;;;;
+10FB1;CHORASMIAN LETTER SMALL ALEPH;Lo;0;R;;;;;N;;;;;
+10FB2;CHORASMIAN LETTER BETH;Lo;0;R;;;;;N;;;;;
+10FB3;CHORASMIAN LETTER GIMEL;Lo;0;R;;;;;N;;;;;
+10FB4;CHORASMIAN LETTER DALETH;Lo;0;R;;;;;N;;;;;
+10FB5;CHORASMIAN LETTER HE;Lo;0;R;;;;;N;;;;;
+10FB6;CHORASMIAN LETTER WAW;Lo;0;R;;;;;N;;;;;
+10FB7;CHORASMIAN LETTER CURLED WAW;Lo;0;R;;;;;N;;;;;
+10FB8;CHORASMIAN LETTER ZAYIN;Lo;0;R;;;;;N;;;;;
+10FB9;CHORASMIAN LETTER HETH;Lo;0;R;;;;;N;;;;;
+10FBA;CHORASMIAN LETTER YODH;Lo;0;R;;;;;N;;;;;
+10FBB;CHORASMIAN LETTER KAPH;Lo;0;R;;;;;N;;;;;
+10FBC;CHORASMIAN LETTER LAMEDH;Lo;0;R;;;;;N;;;;;
+10FBD;CHORASMIAN LETTER MEM;Lo;0;R;;;;;N;;;;;
+10FBE;CHORASMIAN LETTER NUN;Lo;0;R;;;;;N;;;;;
+10FBF;CHORASMIAN LETTER SAMEKH;Lo;0;R;;;;;N;;;;;
+10FC0;CHORASMIAN LETTER AYIN;Lo;0;R;;;;;N;;;;;
+10FC1;CHORASMIAN LETTER PE;Lo;0;R;;;;;N;;;;;
+10FC2;CHORASMIAN LETTER RESH;Lo;0;R;;;;;N;;;;;
+10FC3;CHORASMIAN LETTER SHIN;Lo;0;R;;;;;N;;;;;
+10FC4;CHORASMIAN LETTER TAW;Lo;0;R;;;;;N;;;;;
+10FC5;CHORASMIAN NUMBER ONE;No;0;R;;;;1;N;;;;;
+10FC6;CHORASMIAN NUMBER TWO;No;0;R;;;;2;N;;;;;
+10FC7;CHORASMIAN NUMBER THREE;No;0;R;;;;3;N;;;;;
+10FC8;CHORASMIAN NUMBER FOUR;No;0;R;;;;4;N;;;;;
+10FC9;CHORASMIAN NUMBER TEN;No;0;R;;;;10;N;;;;;
+10FCA;CHORASMIAN NUMBER TWENTY;No;0;R;;;;20;N;;;;;
+10FCB;CHORASMIAN NUMBER ONE HUNDRED;No;0;R;;;;100;N;;;;;
+10FE0;ELYMAIC LETTER ALEPH;Lo;0;R;;;;;N;;;;;
+10FE1;ELYMAIC LETTER BETH;Lo;0;R;;;;;N;;;;;
+10FE2;ELYMAIC LETTER GIMEL;Lo;0;R;;;;;N;;;;;
+10FE3;ELYMAIC LETTER DALETH;Lo;0;R;;;;;N;;;;;
+10FE4;ELYMAIC LETTER HE;Lo;0;R;;;;;N;;;;;
+10FE5;ELYMAIC LETTER WAW;Lo;0;R;;;;;N;;;;;
+10FE6;ELYMAIC LETTER ZAYIN;Lo;0;R;;;;;N;;;;;
+10FE7;ELYMAIC LETTER HETH;Lo;0;R;;;;;N;;;;;
+10FE8;ELYMAIC LETTER TETH;Lo;0;R;;;;;N;;;;;
+10FE9;ELYMAIC LETTER YODH;Lo;0;R;;;;;N;;;;;
+10FEA;ELYMAIC LETTER KAPH;Lo;0;R;;;;;N;;;;;
+10FEB;ELYMAIC LETTER LAMEDH;Lo;0;R;;;;;N;;;;;
+10FEC;ELYMAIC LETTER MEM;Lo;0;R;;;;;N;;;;;
+10FED;ELYMAIC LETTER NUN;Lo;0;R;;;;;N;;;;;
+10FEE;ELYMAIC LETTER SAMEKH;Lo;0;R;;;;;N;;;;;
+10FEF;ELYMAIC LETTER AYIN;Lo;0;R;;;;;N;;;;;
+10FF0;ELYMAIC LETTER PE;Lo;0;R;;;;;N;;;;;
+10FF1;ELYMAIC LETTER SADHE;Lo;0;R;;;;;N;;;;;
+10FF2;ELYMAIC LETTER QOPH;Lo;0;R;;;;;N;;;;;
+10FF3;ELYMAIC LETTER RESH;Lo;0;R;;;;;N;;;;;
+10FF4;ELYMAIC LETTER SHIN;Lo;0;R;;;;;N;;;;;
+10FF5;ELYMAIC LETTER TAW;Lo;0;R;;;;;N;;;;;
+10FF6;ELYMAIC LIGATURE ZAYIN-YODH;Lo;0;R;;;;;N;;;;;
 11000;BRAHMI SIGN CANDRABINDU;Mc;0;L;;;;;N;;;;;
 11001;BRAHMI SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
 11002;BRAHMI SIGN VISARGA;Mc;0;L;;;;;N;;;;;
@@ -18483,6 +19914,12 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1106D;BRAHMI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
 1106E;BRAHMI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
 1106F;BRAHMI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+11070;BRAHMI SIGN OLD TAMIL VIRAMA;Mn;9;NSM;;;;;N;;;;;
+11071;BRAHMI LETTER OLD TAMIL SHORT E;Lo;0;L;;;;;N;;;;;
+11072;BRAHMI LETTER OLD TAMIL SHORT O;Lo;0;L;;;;;N;;;;;
+11073;BRAHMI VOWEL SIGN OLD TAMIL SHORT E;Mn;0;NSM;;;;;N;;;;;
+11074;BRAHMI VOWEL SIGN OLD TAMIL SHORT O;Mn;0;NSM;;;;;N;;;;;
+11075;BRAHMI LETTER OLD TAMIL LLA;Lo;0;L;;;;;N;;;;;
 1107F;BRAHMI NUMBER JOINER;Mn;9;NSM;;;;;N;;;;;
 11080;KAITHI SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
 11081;KAITHI SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
@@ -18550,6 +19987,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 110BF;KAITHI DOUBLE SECTION MARK;Po;0;L;;;;;N;;;;;
 110C0;KAITHI DANDA;Po;0;L;;;;;N;;;;;
 110C1;KAITHI DOUBLE DANDA;Po;0;L;;;;;N;;;;;
+110C2;KAITHI VOWEL SIGN VOCALIC R;Mn;0;NSM;;;;;N;;;;;
+110CD;KAITHI NUMBER SIGN ABOVE;Cf;0;L;;;;;N;;;;;
 110D0;SORA SOMPENG LETTER SAH;Lo;0;L;;;;;N;;;;;
 110D1;SORA SOMPENG LETTER TAH;Lo;0;L;;;;;N;;;;;
 110D2;SORA SOMPENG LETTER BAH;Lo;0;L;;;;;N;;;;;
@@ -18652,6 +20091,10 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 11141;CHAKMA DANDA;Po;0;L;;;;;N;;;;;
 11142;CHAKMA DOUBLE DANDA;Po;0;L;;;;;N;;;;;
 11143;CHAKMA QUESTION MARK;Po;0;L;;;;;N;;;;;
+11144;CHAKMA LETTER LHAA;Lo;0;L;;;;;N;;;;;
+11145;CHAKMA VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
+11146;CHAKMA VOWEL SIGN EI;Mc;0;L;;;;;N;;;;;
+11147;CHAKMA LETTER VAA;Lo;0;L;;;;;N;;;;;
 11150;MAHAJANI LETTER A;Lo;0;L;;;;;N;;;;;
 11151;MAHAJANI LETTER I;Lo;0;L;;;;;N;;;;;
 11152;MAHAJANI LETTER U;Lo;0;L;;;;;N;;;;;
@@ -18764,7 +20207,13 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 111C6;SHARADA DOUBLE DANDA;Po;0;L;;;;;N;;;;;
 111C7;SHARADA ABBREVIATION SIGN;Po;0;L;;;;;N;;;;;
 111C8;SHARADA SEPARATOR;Po;0;L;;;;;N;;;;;
+111C9;SHARADA SANDHI MARK;Mn;0;NSM;;;;;N;;;;;
+111CA;SHARADA SIGN NUKTA;Mn;7;NSM;;;;;N;;;;;
+111CB;SHARADA VOWEL MODIFIER MARK;Mn;0;NSM;;;;;N;;;;;
+111CC;SHARADA EXTRA SHORT VOWEL MARK;Mn;0;NSM;;;;;N;;;;;
 111CD;SHARADA SUTRA MARK;Po;0;L;;;;;N;;;;;
+111CE;SHARADA VOWEL SIGN PRISHTHAMATRA E;Mc;0;L;;;;;N;;;;;
+111CF;SHARADA SIGN INVERTED CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
 111D0;SHARADA DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
 111D1;SHARADA DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
 111D2;SHARADA DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
@@ -18776,6 +20225,11 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 111D8;SHARADA DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
 111D9;SHARADA DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
 111DA;SHARADA EKAM;Lo;0;L;;;;;N;;;;;
+111DB;SHARADA SIGN SIDDHAM;Po;0;L;;;;;N;;;;;
+111DC;SHARADA HEADSTROKE;Lo;0;L;;;;;N;;;;;
+111DD;SHARADA CONTINUATION SIGN;Po;0;L;;;;;N;;;;;
+111DE;SHARADA SECTION MARK-1;Po;0;L;;;;;N;;;;;
+111DF;SHARADA SECTION MARK-2;Po;0;L;;;;;N;;;;;
 111E1;SINHALA ARCHAIC DIGIT ONE;No;0;L;;;;1;N;;;;;
 111E2;SINHALA ARCHAIC DIGIT TWO;No;0;L;;;;2;N;;;;;
 111E3;SINHALA ARCHAIC DIGIT THREE;No;0;L;;;;3;N;;;;;
@@ -18857,6 +20311,48 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1123B;KHOJKI SECTION MARK;Po;0;L;;;;;N;;;;;
 1123C;KHOJKI DOUBLE SECTION MARK;Po;0;L;;;;;N;;;;;
 1123D;KHOJKI ABBREVIATION SIGN;Po;0;L;;;;;N;;;;;
+1123E;KHOJKI SIGN SUKUN;Mn;0;NSM;;;;;N;;;;;
+1123F;KHOJKI LETTER QA;Lo;0;L;;;;;N;;;;;
+11240;KHOJKI LETTER SHORT I;Lo;0;L;;;;;N;;;;;
+11241;KHOJKI VOWEL SIGN VOCALIC R;Mn;0;NSM;;;;;N;;;;;
+11280;MULTANI LETTER A;Lo;0;L;;;;;N;;;;;
+11281;MULTANI LETTER I;Lo;0;L;;;;;N;;;;;
+11282;MULTANI LETTER U;Lo;0;L;;;;;N;;;;;
+11283;MULTANI LETTER E;Lo;0;L;;;;;N;;;;;
+11284;MULTANI LETTER KA;Lo;0;L;;;;;N;;;;;
+11285;MULTANI LETTER KHA;Lo;0;L;;;;;N;;;;;
+11286;MULTANI LETTER GA;Lo;0;L;;;;;N;;;;;
+11288;MULTANI LETTER GHA;Lo;0;L;;;;;N;;;;;
+1128A;MULTANI LETTER CA;Lo;0;L;;;;;N;;;;;
+1128B;MULTANI LETTER CHA;Lo;0;L;;;;;N;;;;;
+1128C;MULTANI LETTER JA;Lo;0;L;;;;;N;;;;;
+1128D;MULTANI LETTER JJA;Lo;0;L;;;;;N;;;;;
+1128F;MULTANI LETTER NYA;Lo;0;L;;;;;N;;;;;
+11290;MULTANI LETTER TTA;Lo;0;L;;;;;N;;;;;
+11291;MULTANI LETTER TTHA;Lo;0;L;;;;;N;;;;;
+11292;MULTANI LETTER DDA;Lo;0;L;;;;;N;;;;;
+11293;MULTANI LETTER DDDA;Lo;0;L;;;;;N;;;;;
+11294;MULTANI LETTER DDHA;Lo;0;L;;;;;N;;;;;
+11295;MULTANI LETTER NNA;Lo;0;L;;;;;N;;;;;
+11296;MULTANI LETTER TA;Lo;0;L;;;;;N;;;;;
+11297;MULTANI LETTER THA;Lo;0;L;;;;;N;;;;;
+11298;MULTANI LETTER DA;Lo;0;L;;;;;N;;;;;
+11299;MULTANI LETTER DHA;Lo;0;L;;;;;N;;;;;
+1129A;MULTANI LETTER NA;Lo;0;L;;;;;N;;;;;
+1129B;MULTANI LETTER PA;Lo;0;L;;;;;N;;;;;
+1129C;MULTANI LETTER PHA;Lo;0;L;;;;;N;;;;;
+1129D;MULTANI LETTER BA;Lo;0;L;;;;;N;;;;;
+1129F;MULTANI LETTER BHA;Lo;0;L;;;;;N;;;;;
+112A0;MULTANI LETTER MA;Lo;0;L;;;;;N;;;;;
+112A1;MULTANI LETTER YA;Lo;0;L;;;;;N;;;;;
+112A2;MULTANI LETTER RA;Lo;0;L;;;;;N;;;;;
+112A3;MULTANI LETTER LA;Lo;0;L;;;;;N;;;;;
+112A4;MULTANI LETTER VA;Lo;0;L;;;;;N;;;;;
+112A5;MULTANI LETTER SA;Lo;0;L;;;;;N;;;;;
+112A6;MULTANI LETTER HA;Lo;0;L;;;;;N;;;;;
+112A7;MULTANI LETTER RRA;Lo;0;L;;;;;N;;;;;
+112A8;MULTANI LETTER RHA;Lo;0;L;;;;;N;;;;;
+112A9;MULTANI SECTION MARK;Po;0;L;;;;;N;;;;;
 112B0;KHUDAWADI LETTER A;Lo;0;L;;;;;N;;;;;
 112B1;KHUDAWADI LETTER AA;Lo;0;L;;;;;N;;;;;
 112B2;KHUDAWADI LETTER I;Lo;0;L;;;;;N;;;;;
@@ -18926,6 +20422,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 112F7;KHUDAWADI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
 112F8;KHUDAWADI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
 112F9;KHUDAWADI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+11300;GRANTHA SIGN COMBINING ANUSVARA ABOVE;Mn;0;NSM;;;;;N;;;;;
 11301;GRANTHA SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
 11302;GRANTHA SIGN ANUSVARA;Mc;0;L;;;;;N;;;;;
 11303;GRANTHA SIGN VISARGA;Mc;0;L;;;;;N;;;;;
@@ -18975,6 +20472,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 11337;GRANTHA LETTER SSA;Lo;0;L;;;;;N;;;;;
 11338;GRANTHA LETTER SA;Lo;0;L;;;;;N;;;;;
 11339;GRANTHA LETTER HA;Lo;0;L;;;;;N;;;;;
+1133B;COMBINING BINDU BELOW;Mn;7;NSM;;;;;N;;;;;
 1133C;GRANTHA SIGN NUKTA;Mn;7;NSM;;;;;N;;;;;
 1133D;GRANTHA SIGN AVAGRAHA;Lo;0;L;;;;;N;;;;;
 1133E;GRANTHA VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
@@ -18989,6 +20487,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1134B;GRANTHA VOWEL SIGN OO;Mc;0;L;11347 1133E;;;;N;;;;;
 1134C;GRANTHA VOWEL SIGN AU;Mc;0;L;11347 11357;;;;N;;;;;
 1134D;GRANTHA SIGN VIRAMA;Mc;9;L;;;;;N;;;;;
+11350;GRANTHA OM;Lo;0;L;;;;;N;;;;;
 11357;GRANTHA AU LENGTH MARK;Mc;0;L;;;;;N;;;;;
 1135D;GRANTHA SIGN PLUTA;Lo;0;L;;;;;N;;;;;
 1135E;GRANTHA LETTER VEDIC ANUSVARA;Lo;0;L;;;;;N;;;;;
@@ -19009,6 +20508,183 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 11372;COMBINING GRANTHA LETTER NA;Mn;230;NSM;;;;;N;;;;;
 11373;COMBINING GRANTHA LETTER VI;Mn;230;NSM;;;;;N;;;;;
 11374;COMBINING GRANTHA LETTER PA;Mn;230;NSM;;;;;N;;;;;
+11380;TULU-TIGALARI LETTER A;Lo;0;L;;;;;N;;;;;
+11381;TULU-TIGALARI LETTER AA;Lo;0;L;;;;;N;;;;;
+11382;TULU-TIGALARI LETTER I;Lo;0;L;;;;;N;;;;;
+11383;TULU-TIGALARI LETTER II;Lo;0;L;11382 113C9;;;;N;;;;;
+11384;TULU-TIGALARI LETTER U;Lo;0;L;;;;;N;;;;;
+11385;TULU-TIGALARI LETTER UU;Lo;0;L;11384 113BB;;;;N;;;;;
+11386;TULU-TIGALARI LETTER VOCALIC R;Lo;0;L;;;;;N;;;;;
+11387;TULU-TIGALARI LETTER VOCALIC RR;Lo;0;L;;;;;N;;;;;
+11388;TULU-TIGALARI LETTER VOCALIC L;Lo;0;L;;;;;N;;;;;
+11389;TULU-TIGALARI LETTER VOCALIC LL;Lo;0;L;;;;;N;;;;;
+1138B;TULU-TIGALARI LETTER EE;Lo;0;L;;;;;N;;;;;
+1138E;TULU-TIGALARI LETTER AI;Lo;0;L;1138B 113C2;;;;N;;;;;
+11390;TULU-TIGALARI LETTER OO;Lo;0;L;;;;;N;;;;;
+11391;TULU-TIGALARI LETTER AU;Lo;0;L;11390 113C9;;;;N;;;;;
+11392;TULU-TIGALARI LETTER KA;Lo;0;L;;;;;N;;;;;
+11393;TULU-TIGALARI LETTER KHA;Lo;0;L;;;;;N;;;;;
+11394;TULU-TIGALARI LETTER GA;Lo;0;L;;;;;N;;;;;
+11395;TULU-TIGALARI LETTER GHA;Lo;0;L;;;;;N;;;;;
+11396;TULU-TIGALARI LETTER NGA;Lo;0;L;;;;;N;;;;;
+11397;TULU-TIGALARI LETTER CA;Lo;0;L;;;;;N;;;;;
+11398;TULU-TIGALARI LETTER CHA;Lo;0;L;;;;;N;;;;;
+11399;TULU-TIGALARI LETTER JA;Lo;0;L;;;;;N;;;;;
+1139A;TULU-TIGALARI LETTER JHA;Lo;0;L;;;;;N;;;;;
+1139B;TULU-TIGALARI LETTER NYA;Lo;0;L;;;;;N;;;;;
+1139C;TULU-TIGALARI LETTER TTA;Lo;0;L;;;;;N;;;;;
+1139D;TULU-TIGALARI LETTER TTHA;Lo;0;L;;;;;N;;;;;
+1139E;TULU-TIGALARI LETTER DDA;Lo;0;L;;;;;N;;;;;
+1139F;TULU-TIGALARI LETTER DDHA;Lo;0;L;;;;;N;;;;;
+113A0;TULU-TIGALARI LETTER NNA;Lo;0;L;;;;;N;;;;;
+113A1;TULU-TIGALARI LETTER TA;Lo;0;L;;;;;N;;;;;
+113A2;TULU-TIGALARI LETTER THA;Lo;0;L;;;;;N;;;;;
+113A3;TULU-TIGALARI LETTER DA;Lo;0;L;;;;;N;;;;;
+113A4;TULU-TIGALARI LETTER DHA;Lo;0;L;;;;;N;;;;;
+113A5;TULU-TIGALARI LETTER NA;Lo;0;L;;;;;N;;;;;
+113A6;TULU-TIGALARI LETTER PA;Lo;0;L;;;;;N;;;;;
+113A7;TULU-TIGALARI LETTER PHA;Lo;0;L;;;;;N;;;;;
+113A8;TULU-TIGALARI LETTER BA;Lo;0;L;;;;;N;;;;;
+113A9;TULU-TIGALARI LETTER BHA;Lo;0;L;;;;;N;;;;;
+113AA;TULU-TIGALARI LETTER MA;Lo;0;L;;;;;N;;;;;
+113AB;TULU-TIGALARI LETTER YA;Lo;0;L;;;;;N;;;;;
+113AC;TULU-TIGALARI LETTER RA;Lo;0;L;;;;;N;;;;;
+113AD;TULU-TIGALARI LETTER LA;Lo;0;L;;;;;N;;;;;
+113AE;TULU-TIGALARI LETTER VA;Lo;0;L;;;;;N;;;;;
+113AF;TULU-TIGALARI LETTER SHA;Lo;0;L;;;;;N;;;;;
+113B0;TULU-TIGALARI LETTER SSA;Lo;0;L;;;;;N;;;;;
+113B1;TULU-TIGALARI LETTER SA;Lo;0;L;;;;;N;;;;;
+113B2;TULU-TIGALARI LETTER HA;Lo;0;L;;;;;N;;;;;
+113B3;TULU-TIGALARI LETTER LLA;Lo;0;L;;;;;N;;;;;
+113B4;TULU-TIGALARI LETTER RRA;Lo;0;L;;;;;N;;;;;
+113B5;TULU-TIGALARI LETTER LLLA;Lo;0;L;;;;;N;;;;;
+113B7;TULU-TIGALARI SIGN AVAGRAHA;Lo;0;L;;;;;N;;;;;
+113B8;TULU-TIGALARI VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
+113B9;TULU-TIGALARI VOWEL SIGN I;Mc;0;L;;;;;N;;;;;
+113BA;TULU-TIGALARI VOWEL SIGN II;Mc;0;L;;;;;N;;;;;
+113BB;TULU-TIGALARI VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+113BC;TULU-TIGALARI VOWEL SIGN UU;Mn;0;NSM;;;;;N;;;;;
+113BD;TULU-TIGALARI VOWEL SIGN VOCALIC R;Mn;0;NSM;;;;;N;;;;;
+113BE;TULU-TIGALARI VOWEL SIGN VOCALIC RR;Mn;0;NSM;;;;;N;;;;;
+113BF;TULU-TIGALARI VOWEL SIGN VOCALIC L;Mn;0;NSM;;;;;N;;;;;
+113C0;TULU-TIGALARI VOWEL SIGN VOCALIC LL;Mn;0;NSM;;;;;N;;;;;
+113C2;TULU-TIGALARI VOWEL SIGN EE;Mc;0;L;;;;;N;;;;;
+113C5;TULU-TIGALARI VOWEL SIGN AI;Mc;0;L;113C2 113C2;;;;N;;;;;
+113C7;TULU-TIGALARI VOWEL SIGN OO;Mc;0;L;113C2 113B8;;;;N;;;;;
+113C8;TULU-TIGALARI VOWEL SIGN AU;Mc;0;L;113C2 113C9;;;;N;;;;;
+113C9;TULU-TIGALARI AU LENGTH MARK;Mc;0;L;;;;;N;;;;;
+113CA;TULU-TIGALARI SIGN CANDRA ANUNASIKA;Mc;0;L;;;;;N;;;;;
+113CC;TULU-TIGALARI SIGN ANUSVARA;Mc;0;L;;;;;N;;;;;
+113CD;TULU-TIGALARI SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+113CE;TULU-TIGALARI SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;;
+113CF;TULU-TIGALARI SIGN LOOPED VIRAMA;Mc;9;L;;;;;N;;;;;
+113D0;TULU-TIGALARI CONJOINER;Mn;9;NSM;;;;;N;;;;;
+113D1;TULU-TIGALARI REPHA;Lo;0;L;;;;;N;;;;;
+113D2;TULU-TIGALARI GEMINATION MARK;Mn;0;NSM;;;;;N;;;;;
+113D3;TULU-TIGALARI SIGN PLUTA;Lo;0;L;;;;;N;;;;;
+113D4;TULU-TIGALARI DANDA;Po;0;L;;;;;N;;;;;
+113D5;TULU-TIGALARI DOUBLE DANDA;Po;0;L;;;;;N;;;;;
+113D7;TULU-TIGALARI SIGN OM PUSHPIKA;Po;0;L;;;;;N;;;;;
+113D8;TULU-TIGALARI SIGN SHRII PUSHPIKA;Po;0;L;;;;;N;;;;;
+113E1;TULU-TIGALARI VEDIC TONE SVARITA;Mn;0;NSM;;;;;N;;;;;
+113E2;TULU-TIGALARI VEDIC TONE ANUDATTA;Mn;0;NSM;;;;;N;;;;;
+11400;NEWA LETTER A;Lo;0;L;;;;;N;;;;;
+11401;NEWA LETTER AA;Lo;0;L;;;;;N;;;;;
+11402;NEWA LETTER I;Lo;0;L;;;;;N;;;;;
+11403;NEWA LETTER II;Lo;0;L;;;;;N;;;;;
+11404;NEWA LETTER U;Lo;0;L;;;;;N;;;;;
+11405;NEWA LETTER UU;Lo;0;L;;;;;N;;;;;
+11406;NEWA LETTER VOCALIC R;Lo;0;L;;;;;N;;;;;
+11407;NEWA LETTER VOCALIC RR;Lo;0;L;;;;;N;;;;;
+11408;NEWA LETTER VOCALIC L;Lo;0;L;;;;;N;;;;;
+11409;NEWA LETTER VOCALIC LL;Lo;0;L;;;;;N;;;;;
+1140A;NEWA LETTER E;Lo;0;L;;;;;N;;;;;
+1140B;NEWA LETTER AI;Lo;0;L;;;;;N;;;;;
+1140C;NEWA LETTER O;Lo;0;L;;;;;N;;;;;
+1140D;NEWA LETTER AU;Lo;0;L;;;;;N;;;;;
+1140E;NEWA LETTER KA;Lo;0;L;;;;;N;;;;;
+1140F;NEWA LETTER KHA;Lo;0;L;;;;;N;;;;;
+11410;NEWA LETTER GA;Lo;0;L;;;;;N;;;;;
+11411;NEWA LETTER GHA;Lo;0;L;;;;;N;;;;;
+11412;NEWA LETTER NGA;Lo;0;L;;;;;N;;;;;
+11413;NEWA LETTER NGHA;Lo;0;L;;;;;N;;;;;
+11414;NEWA LETTER CA;Lo;0;L;;;;;N;;;;;
+11415;NEWA LETTER CHA;Lo;0;L;;;;;N;;;;;
+11416;NEWA LETTER JA;Lo;0;L;;;;;N;;;;;
+11417;NEWA LETTER JHA;Lo;0;L;;;;;N;;;;;
+11418;NEWA LETTER NYA;Lo;0;L;;;;;N;;;;;
+11419;NEWA LETTER NYHA;Lo;0;L;;;;;N;;;;;
+1141A;NEWA LETTER TTA;Lo;0;L;;;;;N;;;;;
+1141B;NEWA LETTER TTHA;Lo;0;L;;;;;N;;;;;
+1141C;NEWA LETTER DDA;Lo;0;L;;;;;N;;;;;
+1141D;NEWA LETTER DDHA;Lo;0;L;;;;;N;;;;;
+1141E;NEWA LETTER NNA;Lo;0;L;;;;;N;;;;;
+1141F;NEWA LETTER TA;Lo;0;L;;;;;N;;;;;
+11420;NEWA LETTER THA;Lo;0;L;;;;;N;;;;;
+11421;NEWA LETTER DA;Lo;0;L;;;;;N;;;;;
+11422;NEWA LETTER DHA;Lo;0;L;;;;;N;;;;;
+11423;NEWA LETTER NA;Lo;0;L;;;;;N;;;;;
+11424;NEWA LETTER NHA;Lo;0;L;;;;;N;;;;;
+11425;NEWA LETTER PA;Lo;0;L;;;;;N;;;;;
+11426;NEWA LETTER PHA;Lo;0;L;;;;;N;;;;;
+11427;NEWA LETTER BA;Lo;0;L;;;;;N;;;;;
+11428;NEWA LETTER BHA;Lo;0;L;;;;;N;;;;;
+11429;NEWA LETTER MA;Lo;0;L;;;;;N;;;;;
+1142A;NEWA LETTER MHA;Lo;0;L;;;;;N;;;;;
+1142B;NEWA LETTER YA;Lo;0;L;;;;;N;;;;;
+1142C;NEWA LETTER RA;Lo;0;L;;;;;N;;;;;
+1142D;NEWA LETTER RHA;Lo;0;L;;;;;N;;;;;
+1142E;NEWA LETTER LA;Lo;0;L;;;;;N;;;;;
+1142F;NEWA LETTER LHA;Lo;0;L;;;;;N;;;;;
+11430;NEWA LETTER WA;Lo;0;L;;;;;N;;;;;
+11431;NEWA LETTER SHA;Lo;0;L;;;;;N;;;;;
+11432;NEWA LETTER SSA;Lo;0;L;;;;;N;;;;;
+11433;NEWA LETTER SA;Lo;0;L;;;;;N;;;;;
+11434;NEWA LETTER HA;Lo;0;L;;;;;N;;;;;
+11435;NEWA VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
+11436;NEWA VOWEL SIGN I;Mc;0;L;;;;;N;;;;;
+11437;NEWA VOWEL SIGN II;Mc;0;L;;;;;N;;;;;
+11438;NEWA VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+11439;NEWA VOWEL SIGN UU;Mn;0;NSM;;;;;N;;;;;
+1143A;NEWA VOWEL SIGN VOCALIC R;Mn;0;NSM;;;;;N;;;;;
+1143B;NEWA VOWEL SIGN VOCALIC RR;Mn;0;NSM;;;;;N;;;;;
+1143C;NEWA VOWEL SIGN VOCALIC L;Mn;0;NSM;;;;;N;;;;;
+1143D;NEWA VOWEL SIGN VOCALIC LL;Mn;0;NSM;;;;;N;;;;;
+1143E;NEWA VOWEL SIGN E;Mn;0;NSM;;;;;N;;;;;
+1143F;NEWA VOWEL SIGN AI;Mn;0;NSM;;;;;N;;;;;
+11440;NEWA VOWEL SIGN O;Mc;0;L;;;;;N;;;;;
+11441;NEWA VOWEL SIGN AU;Mc;0;L;;;;;N;;;;;
+11442;NEWA SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;;
+11443;NEWA SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
+11444;NEWA SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+11445;NEWA SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+11446;NEWA SIGN NUKTA;Mn;7;NSM;;;;;N;;;;;
+11447;NEWA SIGN AVAGRAHA;Lo;0;L;;;;;N;;;;;
+11448;NEWA SIGN FINAL ANUSVARA;Lo;0;L;;;;;N;;;;;
+11449;NEWA OM;Lo;0;L;;;;;N;;;;;
+1144A;NEWA SIDDHI;Lo;0;L;;;;;N;;;;;
+1144B;NEWA DANDA;Po;0;L;;;;;N;;;;;
+1144C;NEWA DOUBLE DANDA;Po;0;L;;;;;N;;;;;
+1144D;NEWA COMMA;Po;0;L;;;;;N;;;;;
+1144E;NEWA GAP FILLER;Po;0;L;;;;;N;;;;;
+1144F;NEWA ABBREVIATION SIGN;Po;0;L;;;;;N;;;;;
+11450;NEWA DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+11451;NEWA DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+11452;NEWA DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+11453;NEWA DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+11454;NEWA DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+11455;NEWA DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+11456;NEWA DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+11457;NEWA DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+11458;NEWA DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+11459;NEWA DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+1145A;NEWA DOUBLE COMMA;Po;0;L;;;;;N;;;;;
+1145B;NEWA PLACEHOLDER MARK;Po;0;L;;;;;N;;;;;
+1145D;NEWA INSERTION SIGN;Po;0;L;;;;;N;;;;;
+1145E;NEWA SANDHI MARK;Mn;230;NSM;;;;;N;;;;;
+1145F;NEWA LETTER VEDIC ANUSVARA;Lo;0;L;;;;;N;;;;;
+11460;NEWA SIGN JIHVAMULIYA;Lo;0;L;;;;;N;;;;;
+11461;NEWA SIGN UPADHMANIYA;Lo;0;L;;;;;N;;;;;
 11480;TIRHUTA ANJI;Lo;0;L;;;;;N;;;;;
 11481;TIRHUTA LETTER A;Lo;0;L;;;;;N;;;;;
 11482;TIRHUTA LETTER AA;Lo;0;L;;;;;N;;;;;
@@ -19163,6 +20839,26 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 115C7;SIDDHAM REPETITION MARK-2;Po;0;L;;;;;N;;;;;
 115C8;SIDDHAM REPETITION MARK-3;Po;0;L;;;;;N;;;;;
 115C9;SIDDHAM END OF TEXT MARK;Po;0;L;;;;;N;;;;;
+115CA;SIDDHAM SECTION MARK WITH TRIDENT AND U-SHAPED ORNAMENTS;Po;0;L;;;;;N;;;;;
+115CB;SIDDHAM SECTION MARK WITH TRIDENT AND DOTTED CRESCENTS;Po;0;L;;;;;N;;;;;
+115CC;SIDDHAM SECTION MARK WITH RAYS AND DOTTED CRESCENTS;Po;0;L;;;;;N;;;;;
+115CD;SIDDHAM SECTION MARK WITH RAYS AND DOTTED DOUBLE CRESCENTS;Po;0;L;;;;;N;;;;;
+115CE;SIDDHAM SECTION MARK WITH RAYS AND DOTTED TRIPLE CRESCENTS;Po;0;L;;;;;N;;;;;
+115CF;SIDDHAM SECTION MARK DOUBLE RING;Po;0;L;;;;;N;;;;;
+115D0;SIDDHAM SECTION MARK DOUBLE RING WITH RAYS;Po;0;L;;;;;N;;;;;
+115D1;SIDDHAM SECTION MARK WITH DOUBLE CRESCENTS;Po;0;L;;;;;N;;;;;
+115D2;SIDDHAM SECTION MARK WITH TRIPLE CRESCENTS;Po;0;L;;;;;N;;;;;
+115D3;SIDDHAM SECTION MARK WITH QUADRUPLE CRESCENTS;Po;0;L;;;;;N;;;;;
+115D4;SIDDHAM SECTION MARK WITH SEPTUPLE CRESCENTS;Po;0;L;;;;;N;;;;;
+115D5;SIDDHAM SECTION MARK WITH CIRCLES AND RAYS;Po;0;L;;;;;N;;;;;
+115D6;SIDDHAM SECTION MARK WITH CIRCLES AND TWO ENCLOSURES;Po;0;L;;;;;N;;;;;
+115D7;SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES;Po;0;L;;;;;N;;;;;
+115D8;SIDDHAM LETTER THREE-CIRCLE ALTERNATE I;Lo;0;L;;;;;N;;;;;
+115D9;SIDDHAM LETTER TWO-CIRCLE ALTERNATE I;Lo;0;L;;;;;N;;;;;
+115DA;SIDDHAM LETTER TWO-CIRCLE ALTERNATE II;Lo;0;L;;;;;N;;;;;
+115DB;SIDDHAM LETTER ALTERNATE U;Lo;0;L;;;;;N;;;;;
+115DC;SIDDHAM VOWEL SIGN ALTERNATE U;Mn;0;NSM;;;;;N;;;;;
+115DD;SIDDHAM VOWEL SIGN ALTERNATE UU;Mn;0;NSM;;;;;N;;;;;
 11600;MODI LETTER A;Lo;0;L;;;;;N;;;;;
 11601;MODI LETTER AA;Lo;0;L;;;;;N;;;;;
 11602;MODI LETTER I;Lo;0;L;;;;;N;;;;;
@@ -19242,6 +20938,19 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 11657;MODI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
 11658;MODI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
 11659;MODI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+11660;MONGOLIAN BIRGA WITH ORNAMENT;Po;0;ON;;;;;N;;;;;
+11661;MONGOLIAN ROTATED BIRGA;Po;0;ON;;;;;N;;;;;
+11662;MONGOLIAN DOUBLE BIRGA WITH ORNAMENT;Po;0;ON;;;;;N;;;;;
+11663;MONGOLIAN TRIPLE BIRGA WITH ORNAMENT;Po;0;ON;;;;;N;;;;;
+11664;MONGOLIAN BIRGA WITH DOUBLE ORNAMENT;Po;0;ON;;;;;N;;;;;
+11665;MONGOLIAN ROTATED BIRGA WITH ORNAMENT;Po;0;ON;;;;;N;;;;;
+11666;MONGOLIAN ROTATED BIRGA WITH DOUBLE ORNAMENT;Po;0;ON;;;;;N;;;;;
+11667;MONGOLIAN INVERTED BIRGA;Po;0;ON;;;;;N;;;;;
+11668;MONGOLIAN INVERTED BIRGA WITH DOUBLE ORNAMENT;Po;0;ON;;;;;N;;;;;
+11669;MONGOLIAN SWIRL BIRGA;Po;0;ON;;;;;N;;;;;
+1166A;MONGOLIAN SWIRL BIRGA WITH ORNAMENT;Po;0;ON;;;;;N;;;;;
+1166B;MONGOLIAN SWIRL BIRGA WITH DOUBLE ORNAMENT;Po;0;ON;;;;;N;;;;;
+1166C;MONGOLIAN TURNED SWIRL BIRGA WITH DOUBLE ORNAMENT;Po;0;ON;;;;;N;;;;;
 11680;TAKRI LETTER A;Lo;0;L;;;;;N;;;;;
 11681;TAKRI LETTER AA;Lo;0;L;;;;;N;;;;;
 11682;TAKRI LETTER I;Lo;0;L;;;;;N;;;;;
@@ -19298,6 +21007,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 116B5;TAKRI VOWEL SIGN AU;Mn;0;NSM;;;;;N;;;;;
 116B6;TAKRI SIGN VIRAMA;Mc;9;L;;;;;N;;;;;
 116B7;TAKRI SIGN NUKTA;Mn;7;NSM;;;;;N;;;;;
+116B8;TAKRI LETTER ARCHAIC KHA;Lo;0;L;;;;;N;;;;;
+116B9;TAKRI ABBREVIATION SIGN;Po;0;L;;;;;N;;;;;
 116C0;TAKRI DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
 116C1;TAKRI DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
 116C2;TAKRI DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
@@ -19308,6 +21019,151 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 116C7;TAKRI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
 116C8;TAKRI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
 116C9;TAKRI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+116D0;MYANMAR PAO DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+116D1;MYANMAR PAO DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+116D2;MYANMAR PAO DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+116D3;MYANMAR PAO DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+116D4;MYANMAR PAO DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+116D5;MYANMAR PAO DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+116D6;MYANMAR PAO DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+116D7;MYANMAR PAO DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+116D8;MYANMAR PAO DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+116D9;MYANMAR PAO DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+116DA;MYANMAR EASTERN PWO KAREN DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+116DB;MYANMAR EASTERN PWO KAREN DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+116DC;MYANMAR EASTERN PWO KAREN DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+116DD;MYANMAR EASTERN PWO KAREN DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+116DE;MYANMAR EASTERN PWO KAREN DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+116DF;MYANMAR EASTERN PWO KAREN DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+116E0;MYANMAR EASTERN PWO KAREN DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+116E1;MYANMAR EASTERN PWO KAREN DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+116E2;MYANMAR EASTERN PWO KAREN DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+116E3;MYANMAR EASTERN PWO KAREN DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+11700;AHOM LETTER KA;Lo;0;L;;;;;N;;;;;
+11701;AHOM LETTER KHA;Lo;0;L;;;;;N;;;;;
+11702;AHOM LETTER NGA;Lo;0;L;;;;;N;;;;;
+11703;AHOM LETTER NA;Lo;0;L;;;;;N;;;;;
+11704;AHOM LETTER TA;Lo;0;L;;;;;N;;;;;
+11705;AHOM LETTER ALTERNATE TA;Lo;0;L;;;;;N;;;;;
+11706;AHOM LETTER PA;Lo;0;L;;;;;N;;;;;
+11707;AHOM LETTER PHA;Lo;0;L;;;;;N;;;;;
+11708;AHOM LETTER BA;Lo;0;L;;;;;N;;;;;
+11709;AHOM LETTER MA;Lo;0;L;;;;;N;;;;;
+1170A;AHOM LETTER JA;Lo;0;L;;;;;N;;;;;
+1170B;AHOM LETTER CHA;Lo;0;L;;;;;N;;;;;
+1170C;AHOM LETTER THA;Lo;0;L;;;;;N;;;;;
+1170D;AHOM LETTER RA;Lo;0;L;;;;;N;;;;;
+1170E;AHOM LETTER LA;Lo;0;L;;;;;N;;;;;
+1170F;AHOM LETTER SA;Lo;0;L;;;;;N;;;;;
+11710;AHOM LETTER NYA;Lo;0;L;;;;;N;;;;;
+11711;AHOM LETTER HA;Lo;0;L;;;;;N;;;;;
+11712;AHOM LETTER A;Lo;0;L;;;;;N;;;;;
+11713;AHOM LETTER DA;Lo;0;L;;;;;N;;;;;
+11714;AHOM LETTER DHA;Lo;0;L;;;;;N;;;;;
+11715;AHOM LETTER GA;Lo;0;L;;;;;N;;;;;
+11716;AHOM LETTER ALTERNATE GA;Lo;0;L;;;;;N;;;;;
+11717;AHOM LETTER GHA;Lo;0;L;;;;;N;;;;;
+11718;AHOM LETTER BHA;Lo;0;L;;;;;N;;;;;
+11719;AHOM LETTER JHA;Lo;0;L;;;;;N;;;;;
+1171A;AHOM LETTER ALTERNATE BA;Lo;0;L;;;;;N;;;;;
+1171D;AHOM CONSONANT SIGN MEDIAL LA;Mn;0;NSM;;;;;N;;;;;
+1171E;AHOM CONSONANT SIGN MEDIAL RA;Mc;0;L;;;;;N;;;;;
+1171F;AHOM CONSONANT SIGN MEDIAL LIGATING RA;Mn;0;NSM;;;;;N;;;;;
+11720;AHOM VOWEL SIGN A;Mc;0;L;;;;;N;;;;;
+11721;AHOM VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
+11722;AHOM VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
+11723;AHOM VOWEL SIGN II;Mn;0;NSM;;;;;N;;;;;
+11724;AHOM VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+11725;AHOM VOWEL SIGN UU;Mn;0;NSM;;;;;N;;;;;
+11726;AHOM VOWEL SIGN E;Mc;0;L;;;;;N;;;;;
+11727;AHOM VOWEL SIGN AW;Mn;0;NSM;;;;;N;;;;;
+11728;AHOM VOWEL SIGN O;Mn;0;NSM;;;;;N;;;;;
+11729;AHOM VOWEL SIGN AI;Mn;0;NSM;;;;;N;;;;;
+1172A;AHOM VOWEL SIGN AM;Mn;0;NSM;;;;;N;;;;;
+1172B;AHOM SIGN KILLER;Mn;9;NSM;;;;;N;;;;;
+11730;AHOM DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+11731;AHOM DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+11732;AHOM DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+11733;AHOM DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+11734;AHOM DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+11735;AHOM DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+11736;AHOM DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+11737;AHOM DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+11738;AHOM DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+11739;AHOM DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+1173A;AHOM NUMBER TEN;No;0;L;;;;10;N;;;;;
+1173B;AHOM NUMBER TWENTY;No;0;L;;;;20;N;;;;;
+1173C;AHOM SIGN SMALL SECTION;Po;0;L;;;;;N;;;;;
+1173D;AHOM SIGN SECTION;Po;0;L;;;;;N;;;;;
+1173E;AHOM SIGN RULAI;Po;0;L;;;;;N;;;;;
+1173F;AHOM SYMBOL VI;So;0;L;;;;;N;;;;;
+11740;AHOM LETTER CA;Lo;0;L;;;;;N;;;;;
+11741;AHOM LETTER TTA;Lo;0;L;;;;;N;;;;;
+11742;AHOM LETTER TTHA;Lo;0;L;;;;;N;;;;;
+11743;AHOM LETTER DDA;Lo;0;L;;;;;N;;;;;
+11744;AHOM LETTER DDHA;Lo;0;L;;;;;N;;;;;
+11745;AHOM LETTER NNA;Lo;0;L;;;;;N;;;;;
+11746;AHOM LETTER LLA;Lo;0;L;;;;;N;;;;;
+11800;DOGRA LETTER A;Lo;0;L;;;;;N;;;;;
+11801;DOGRA LETTER AA;Lo;0;L;;;;;N;;;;;
+11802;DOGRA LETTER I;Lo;0;L;;;;;N;;;;;
+11803;DOGRA LETTER II;Lo;0;L;;;;;N;;;;;
+11804;DOGRA LETTER U;Lo;0;L;;;;;N;;;;;
+11805;DOGRA LETTER UU;Lo;0;L;;;;;N;;;;;
+11806;DOGRA LETTER E;Lo;0;L;;;;;N;;;;;
+11807;DOGRA LETTER AI;Lo;0;L;;;;;N;;;;;
+11808;DOGRA LETTER O;Lo;0;L;;;;;N;;;;;
+11809;DOGRA LETTER AU;Lo;0;L;;;;;N;;;;;
+1180A;DOGRA LETTER KA;Lo;0;L;;;;;N;;;;;
+1180B;DOGRA LETTER KHA;Lo;0;L;;;;;N;;;;;
+1180C;DOGRA LETTER GA;Lo;0;L;;;;;N;;;;;
+1180D;DOGRA LETTER GHA;Lo;0;L;;;;;N;;;;;
+1180E;DOGRA LETTER NGA;Lo;0;L;;;;;N;;;;;
+1180F;DOGRA LETTER CA;Lo;0;L;;;;;N;;;;;
+11810;DOGRA LETTER CHA;Lo;0;L;;;;;N;;;;;
+11811;DOGRA LETTER JA;Lo;0;L;;;;;N;;;;;
+11812;DOGRA LETTER JHA;Lo;0;L;;;;;N;;;;;
+11813;DOGRA LETTER NYA;Lo;0;L;;;;;N;;;;;
+11814;DOGRA LETTER TTA;Lo;0;L;;;;;N;;;;;
+11815;DOGRA LETTER TTHA;Lo;0;L;;;;;N;;;;;
+11816;DOGRA LETTER DDA;Lo;0;L;;;;;N;;;;;
+11817;DOGRA LETTER DDHA;Lo;0;L;;;;;N;;;;;
+11818;DOGRA LETTER NNA;Lo;0;L;;;;;N;;;;;
+11819;DOGRA LETTER TA;Lo;0;L;;;;;N;;;;;
+1181A;DOGRA LETTER THA;Lo;0;L;;;;;N;;;;;
+1181B;DOGRA LETTER DA;Lo;0;L;;;;;N;;;;;
+1181C;DOGRA LETTER DHA;Lo;0;L;;;;;N;;;;;
+1181D;DOGRA LETTER NA;Lo;0;L;;;;;N;;;;;
+1181E;DOGRA LETTER PA;Lo;0;L;;;;;N;;;;;
+1181F;DOGRA LETTER PHA;Lo;0;L;;;;;N;;;;;
+11820;DOGRA LETTER BA;Lo;0;L;;;;;N;;;;;
+11821;DOGRA LETTER BHA;Lo;0;L;;;;;N;;;;;
+11822;DOGRA LETTER MA;Lo;0;L;;;;;N;;;;;
+11823;DOGRA LETTER YA;Lo;0;L;;;;;N;;;;;
+11824;DOGRA LETTER RA;Lo;0;L;;;;;N;;;;;
+11825;DOGRA LETTER LA;Lo;0;L;;;;;N;;;;;
+11826;DOGRA LETTER VA;Lo;0;L;;;;;N;;;;;
+11827;DOGRA LETTER SHA;Lo;0;L;;;;;N;;;;;
+11828;DOGRA LETTER SSA;Lo;0;L;;;;;N;;;;;
+11829;DOGRA LETTER SA;Lo;0;L;;;;;N;;;;;
+1182A;DOGRA LETTER HA;Lo;0;L;;;;;N;;;;;
+1182B;DOGRA LETTER RRA;Lo;0;L;;;;;N;;;;;
+1182C;DOGRA VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
+1182D;DOGRA VOWEL SIGN I;Mc;0;L;;;;;N;;;;;
+1182E;DOGRA VOWEL SIGN II;Mc;0;L;;;;;N;;;;;
+1182F;DOGRA VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+11830;DOGRA VOWEL SIGN UU;Mn;0;NSM;;;;;N;;;;;
+11831;DOGRA VOWEL SIGN VOCALIC R;Mn;0;NSM;;;;;N;;;;;
+11832;DOGRA VOWEL SIGN VOCALIC RR;Mn;0;NSM;;;;;N;;;;;
+11833;DOGRA VOWEL SIGN E;Mn;0;NSM;;;;;N;;;;;
+11834;DOGRA VOWEL SIGN AI;Mn;0;NSM;;;;;N;;;;;
+11835;DOGRA VOWEL SIGN O;Mn;0;NSM;;;;;N;;;;;
+11836;DOGRA VOWEL SIGN AU;Mn;0;NSM;;;;;N;;;;;
+11837;DOGRA SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+11838;DOGRA SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+11839;DOGRA SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;;
+1183A;DOGRA SIGN NUKTA;Mn;7;NSM;;;;;N;;;;;
+1183B;DOGRA ABBREVIATION SIGN;Po;0;L;;;;;N;;;;;
 118A0;WARANG CITI CAPITAL LETTER NGAA;Lu;0;L;;;;;N;;;;118C0;
 118A1;WARANG CITI CAPITAL LETTER A;Lu;0;L;;;;;N;;;;118C1;
 118A2;WARANG CITI CAPITAL LETTER WI;Lu;0;L;;;;;N;;;;118C2;
@@ -19392,6 +21248,314 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 118F1;WARANG CITI NUMBER EIGHTY;No;0;L;;;;80;N;;;;;
 118F2;WARANG CITI NUMBER NINETY;No;0;L;;;;90;N;;;;;
 118FF;WARANG CITI OM;Lo;0;L;;;;;N;;;;;
+11900;DIVES AKURU LETTER A;Lo;0;L;;;;;N;;;;;
+11901;DIVES AKURU LETTER AA;Lo;0;L;;;;;N;;;;;
+11902;DIVES AKURU LETTER I;Lo;0;L;;;;;N;;;;;
+11903;DIVES AKURU LETTER II;Lo;0;L;;;;;N;;;;;
+11904;DIVES AKURU LETTER U;Lo;0;L;;;;;N;;;;;
+11905;DIVES AKURU LETTER UU;Lo;0;L;;;;;N;;;;;
+11906;DIVES AKURU LETTER E;Lo;0;L;;;;;N;;;;;
+11909;DIVES AKURU LETTER O;Lo;0;L;;;;;N;;;;;
+1190C;DIVES AKURU LETTER KA;Lo;0;L;;;;;N;;;;;
+1190D;DIVES AKURU LETTER KHA;Lo;0;L;;;;;N;;;;;
+1190E;DIVES AKURU LETTER GA;Lo;0;L;;;;;N;;;;;
+1190F;DIVES AKURU LETTER GHA;Lo;0;L;;;;;N;;;;;
+11910;DIVES AKURU LETTER NGA;Lo;0;L;;;;;N;;;;;
+11911;DIVES AKURU LETTER CA;Lo;0;L;;;;;N;;;;;
+11912;DIVES AKURU LETTER CHA;Lo;0;L;;;;;N;;;;;
+11913;DIVES AKURU LETTER JA;Lo;0;L;;;;;N;;;;;
+11915;DIVES AKURU LETTER NYA;Lo;0;L;;;;;N;;;;;
+11916;DIVES AKURU LETTER TTA;Lo;0;L;;;;;N;;;;;
+11918;DIVES AKURU LETTER DDA;Lo;0;L;;;;;N;;;;;
+11919;DIVES AKURU LETTER DDHA;Lo;0;L;;;;;N;;;;;
+1191A;DIVES AKURU LETTER NNA;Lo;0;L;;;;;N;;;;;
+1191B;DIVES AKURU LETTER TA;Lo;0;L;;;;;N;;;;;
+1191C;DIVES AKURU LETTER THA;Lo;0;L;;;;;N;;;;;
+1191D;DIVES AKURU LETTER DA;Lo;0;L;;;;;N;;;;;
+1191E;DIVES AKURU LETTER DHA;Lo;0;L;;;;;N;;;;;
+1191F;DIVES AKURU LETTER NA;Lo;0;L;;;;;N;;;;;
+11920;DIVES AKURU LETTER PA;Lo;0;L;;;;;N;;;;;
+11921;DIVES AKURU LETTER PHA;Lo;0;L;;;;;N;;;;;
+11922;DIVES AKURU LETTER BA;Lo;0;L;;;;;N;;;;;
+11923;DIVES AKURU LETTER BHA;Lo;0;L;;;;;N;;;;;
+11924;DIVES AKURU LETTER MA;Lo;0;L;;;;;N;;;;;
+11925;DIVES AKURU LETTER YA;Lo;0;L;;;;;N;;;;;
+11926;DIVES AKURU LETTER YYA;Lo;0;L;;;;;N;;;;;
+11927;DIVES AKURU LETTER RA;Lo;0;L;;;;;N;;;;;
+11928;DIVES AKURU LETTER LA;Lo;0;L;;;;;N;;;;;
+11929;DIVES AKURU LETTER VA;Lo;0;L;;;;;N;;;;;
+1192A;DIVES AKURU LETTER SHA;Lo;0;L;;;;;N;;;;;
+1192B;DIVES AKURU LETTER SSA;Lo;0;L;;;;;N;;;;;
+1192C;DIVES AKURU LETTER SA;Lo;0;L;;;;;N;;;;;
+1192D;DIVES AKURU LETTER HA;Lo;0;L;;;;;N;;;;;
+1192E;DIVES AKURU LETTER LLA;Lo;0;L;;;;;N;;;;;
+1192F;DIVES AKURU LETTER ZA;Lo;0;L;;;;;N;;;;;
+11930;DIVES AKURU VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
+11931;DIVES AKURU VOWEL SIGN I;Mc;0;L;;;;;N;;;;;
+11932;DIVES AKURU VOWEL SIGN II;Mc;0;L;;;;;N;;;;;
+11933;DIVES AKURU VOWEL SIGN U;Mc;0;L;;;;;N;;;;;
+11934;DIVES AKURU VOWEL SIGN UU;Mc;0;L;;;;;N;;;;;
+11935;DIVES AKURU VOWEL SIGN E;Mc;0;L;;;;;N;;;;;
+11937;DIVES AKURU VOWEL SIGN AI;Mc;0;L;;;;;N;;;;;
+11938;DIVES AKURU VOWEL SIGN O;Mc;0;L;11935 11930;;;;N;;;;;
+1193B;DIVES AKURU SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+1193C;DIVES AKURU SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
+1193D;DIVES AKURU SIGN HALANTA;Mc;9;L;;;;;N;;;;;
+1193E;DIVES AKURU VIRAMA;Mn;9;NSM;;;;;N;;;;;
+1193F;DIVES AKURU PREFIXED NASAL SIGN;Lo;0;L;;;;;N;;;;;
+11940;DIVES AKURU MEDIAL YA;Mc;0;L;;;;;N;;;;;
+11941;DIVES AKURU INITIAL RA;Lo;0;L;;;;;N;;;;;
+11942;DIVES AKURU MEDIAL RA;Mc;0;L;;;;;N;;;;;
+11943;DIVES AKURU SIGN NUKTA;Mn;7;NSM;;;;;N;;;;;
+11944;DIVES AKURU DOUBLE DANDA;Po;0;L;;;;;N;;;;;
+11945;DIVES AKURU GAP FILLER;Po;0;L;;;;;N;;;;;
+11946;DIVES AKURU END OF TEXT MARK;Po;0;L;;;;;N;;;;;
+11950;DIVES AKURU DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+11951;DIVES AKURU DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+11952;DIVES AKURU DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+11953;DIVES AKURU DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+11954;DIVES AKURU DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+11955;DIVES AKURU DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+11956;DIVES AKURU DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+11957;DIVES AKURU DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+11958;DIVES AKURU DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+11959;DIVES AKURU DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+119A0;NANDINAGARI LETTER A;Lo;0;L;;;;;N;;;;;
+119A1;NANDINAGARI LETTER AA;Lo;0;L;;;;;N;;;;;
+119A2;NANDINAGARI LETTER I;Lo;0;L;;;;;N;;;;;
+119A3;NANDINAGARI LETTER II;Lo;0;L;;;;;N;;;;;
+119A4;NANDINAGARI LETTER U;Lo;0;L;;;;;N;;;;;
+119A5;NANDINAGARI LETTER UU;Lo;0;L;;;;;N;;;;;
+119A6;NANDINAGARI LETTER VOCALIC R;Lo;0;L;;;;;N;;;;;
+119A7;NANDINAGARI LETTER VOCALIC RR;Lo;0;L;;;;;N;;;;;
+119AA;NANDINAGARI LETTER E;Lo;0;L;;;;;N;;;;;
+119AB;NANDINAGARI LETTER AI;Lo;0;L;;;;;N;;;;;
+119AC;NANDINAGARI LETTER O;Lo;0;L;;;;;N;;;;;
+119AD;NANDINAGARI LETTER AU;Lo;0;L;;;;;N;;;;;
+119AE;NANDINAGARI LETTER KA;Lo;0;L;;;;;N;;;;;
+119AF;NANDINAGARI LETTER KHA;Lo;0;L;;;;;N;;;;;
+119B0;NANDINAGARI LETTER GA;Lo;0;L;;;;;N;;;;;
+119B1;NANDINAGARI LETTER GHA;Lo;0;L;;;;;N;;;;;
+119B2;NANDINAGARI LETTER NGA;Lo;0;L;;;;;N;;;;;
+119B3;NANDINAGARI LETTER CA;Lo;0;L;;;;;N;;;;;
+119B4;NANDINAGARI LETTER CHA;Lo;0;L;;;;;N;;;;;
+119B5;NANDINAGARI LETTER JA;Lo;0;L;;;;;N;;;;;
+119B6;NANDINAGARI LETTER JHA;Lo;0;L;;;;;N;;;;;
+119B7;NANDINAGARI LETTER NYA;Lo;0;L;;;;;N;;;;;
+119B8;NANDINAGARI LETTER TTA;Lo;0;L;;;;;N;;;;;
+119B9;NANDINAGARI LETTER TTHA;Lo;0;L;;;;;N;;;;;
+119BA;NANDINAGARI LETTER DDA;Lo;0;L;;;;;N;;;;;
+119BB;NANDINAGARI LETTER DDHA;Lo;0;L;;;;;N;;;;;
+119BC;NANDINAGARI LETTER NNA;Lo;0;L;;;;;N;;;;;
+119BD;NANDINAGARI LETTER TA;Lo;0;L;;;;;N;;;;;
+119BE;NANDINAGARI LETTER THA;Lo;0;L;;;;;N;;;;;
+119BF;NANDINAGARI LETTER DA;Lo;0;L;;;;;N;;;;;
+119C0;NANDINAGARI LETTER DHA;Lo;0;L;;;;;N;;;;;
+119C1;NANDINAGARI LETTER NA;Lo;0;L;;;;;N;;;;;
+119C2;NANDINAGARI LETTER PA;Lo;0;L;;;;;N;;;;;
+119C3;NANDINAGARI LETTER PHA;Lo;0;L;;;;;N;;;;;
+119C4;NANDINAGARI LETTER BA;Lo;0;L;;;;;N;;;;;
+119C5;NANDINAGARI LETTER BHA;Lo;0;L;;;;;N;;;;;
+119C6;NANDINAGARI LETTER MA;Lo;0;L;;;;;N;;;;;
+119C7;NANDINAGARI LETTER YA;Lo;0;L;;;;;N;;;;;
+119C8;NANDINAGARI LETTER RA;Lo;0;L;;;;;N;;;;;
+119C9;NANDINAGARI LETTER LA;Lo;0;L;;;;;N;;;;;
+119CA;NANDINAGARI LETTER VA;Lo;0;L;;;;;N;;;;;
+119CB;NANDINAGARI LETTER SHA;Lo;0;L;;;;;N;;;;;
+119CC;NANDINAGARI LETTER SSA;Lo;0;L;;;;;N;;;;;
+119CD;NANDINAGARI LETTER SA;Lo;0;L;;;;;N;;;;;
+119CE;NANDINAGARI LETTER HA;Lo;0;L;;;;;N;;;;;
+119CF;NANDINAGARI LETTER LLA;Lo;0;L;;;;;N;;;;;
+119D0;NANDINAGARI LETTER RRA;Lo;0;L;;;;;N;;;;;
+119D1;NANDINAGARI VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
+119D2;NANDINAGARI VOWEL SIGN I;Mc;0;L;;;;;N;;;;;
+119D3;NANDINAGARI VOWEL SIGN II;Mc;0;L;;;;;N;;;;;
+119D4;NANDINAGARI VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+119D5;NANDINAGARI VOWEL SIGN UU;Mn;0;NSM;;;;;N;;;;;
+119D6;NANDINAGARI VOWEL SIGN VOCALIC R;Mn;0;NSM;;;;;N;;;;;
+119D7;NANDINAGARI VOWEL SIGN VOCALIC RR;Mn;0;NSM;;;;;N;;;;;
+119DA;NANDINAGARI VOWEL SIGN E;Mn;0;NSM;;;;;N;;;;;
+119DB;NANDINAGARI VOWEL SIGN AI;Mn;0;NSM;;;;;N;;;;;
+119DC;NANDINAGARI VOWEL SIGN O;Mc;0;L;;;;;N;;;;;
+119DD;NANDINAGARI VOWEL SIGN AU;Mc;0;L;;;;;N;;;;;
+119DE;NANDINAGARI SIGN ANUSVARA;Mc;0;L;;;;;N;;;;;
+119DF;NANDINAGARI SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+119E0;NANDINAGARI SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;;
+119E1;NANDINAGARI SIGN AVAGRAHA;Lo;0;L;;;;;N;;;;;
+119E2;NANDINAGARI SIGN SIDDHAM;Po;0;L;;;;;N;;;;;
+119E3;NANDINAGARI HEADSTROKE;Lo;0;L;;;;;N;;;;;
+119E4;NANDINAGARI VOWEL SIGN PRISHTHAMATRA E;Mc;0;L;;;;;N;;;;;
+11A00;ZANABAZAR SQUARE LETTER A;Lo;0;L;;;;;N;;;;;
+11A01;ZANABAZAR SQUARE VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
+11A02;ZANABAZAR SQUARE VOWEL SIGN UE;Mn;0;NSM;;;;;N;;;;;
+11A03;ZANABAZAR SQUARE VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+11A04;ZANABAZAR SQUARE VOWEL SIGN E;Mn;0;NSM;;;;;N;;;;;
+11A05;ZANABAZAR SQUARE VOWEL SIGN OE;Mn;0;NSM;;;;;N;;;;;
+11A06;ZANABAZAR SQUARE VOWEL SIGN O;Mn;0;NSM;;;;;N;;;;;
+11A07;ZANABAZAR SQUARE VOWEL SIGN AI;Mn;0;L;;;;;N;;;;;
+11A08;ZANABAZAR SQUARE VOWEL SIGN AU;Mn;0;L;;;;;N;;;;;
+11A09;ZANABAZAR SQUARE VOWEL SIGN REVERSED I;Mn;0;NSM;;;;;N;;;;;
+11A0A;ZANABAZAR SQUARE VOWEL LENGTH MARK;Mn;0;NSM;;;;;N;;;;;
+11A0B;ZANABAZAR SQUARE LETTER KA;Lo;0;L;;;;;N;;;;;
+11A0C;ZANABAZAR SQUARE LETTER KHA;Lo;0;L;;;;;N;;;;;
+11A0D;ZANABAZAR SQUARE LETTER GA;Lo;0;L;;;;;N;;;;;
+11A0E;ZANABAZAR SQUARE LETTER GHA;Lo;0;L;;;;;N;;;;;
+11A0F;ZANABAZAR SQUARE LETTER NGA;Lo;0;L;;;;;N;;;;;
+11A10;ZANABAZAR SQUARE LETTER CA;Lo;0;L;;;;;N;;;;;
+11A11;ZANABAZAR SQUARE LETTER CHA;Lo;0;L;;;;;N;;;;;
+11A12;ZANABAZAR SQUARE LETTER JA;Lo;0;L;;;;;N;;;;;
+11A13;ZANABAZAR SQUARE LETTER NYA;Lo;0;L;;;;;N;;;;;
+11A14;ZANABAZAR SQUARE LETTER TTA;Lo;0;L;;;;;N;;;;;
+11A15;ZANABAZAR SQUARE LETTER TTHA;Lo;0;L;;;;;N;;;;;
+11A16;ZANABAZAR SQUARE LETTER DDA;Lo;0;L;;;;;N;;;;;
+11A17;ZANABAZAR SQUARE LETTER DDHA;Lo;0;L;;;;;N;;;;;
+11A18;ZANABAZAR SQUARE LETTER NNA;Lo;0;L;;;;;N;;;;;
+11A19;ZANABAZAR SQUARE LETTER TA;Lo;0;L;;;;;N;;;;;
+11A1A;ZANABAZAR SQUARE LETTER THA;Lo;0;L;;;;;N;;;;;
+11A1B;ZANABAZAR SQUARE LETTER DA;Lo;0;L;;;;;N;;;;;
+11A1C;ZANABAZAR SQUARE LETTER DHA;Lo;0;L;;;;;N;;;;;
+11A1D;ZANABAZAR SQUARE LETTER NA;Lo;0;L;;;;;N;;;;;
+11A1E;ZANABAZAR SQUARE LETTER PA;Lo;0;L;;;;;N;;;;;
+11A1F;ZANABAZAR SQUARE LETTER PHA;Lo;0;L;;;;;N;;;;;
+11A20;ZANABAZAR SQUARE LETTER BA;Lo;0;L;;;;;N;;;;;
+11A21;ZANABAZAR SQUARE LETTER BHA;Lo;0;L;;;;;N;;;;;
+11A22;ZANABAZAR SQUARE LETTER MA;Lo;0;L;;;;;N;;;;;
+11A23;ZANABAZAR SQUARE LETTER TSA;Lo;0;L;;;;;N;;;;;
+11A24;ZANABAZAR SQUARE LETTER TSHA;Lo;0;L;;;;;N;;;;;
+11A25;ZANABAZAR SQUARE LETTER DZA;Lo;0;L;;;;;N;;;;;
+11A26;ZANABAZAR SQUARE LETTER DZHA;Lo;0;L;;;;;N;;;;;
+11A27;ZANABAZAR SQUARE LETTER ZHA;Lo;0;L;;;;;N;;;;;
+11A28;ZANABAZAR SQUARE LETTER ZA;Lo;0;L;;;;;N;;;;;
+11A29;ZANABAZAR SQUARE LETTER -A;Lo;0;L;;;;;N;;;;;
+11A2A;ZANABAZAR SQUARE LETTER YA;Lo;0;L;;;;;N;;;;;
+11A2B;ZANABAZAR SQUARE LETTER RA;Lo;0;L;;;;;N;;;;;
+11A2C;ZANABAZAR SQUARE LETTER LA;Lo;0;L;;;;;N;;;;;
+11A2D;ZANABAZAR SQUARE LETTER VA;Lo;0;L;;;;;N;;;;;
+11A2E;ZANABAZAR SQUARE LETTER SHA;Lo;0;L;;;;;N;;;;;
+11A2F;ZANABAZAR SQUARE LETTER SSA;Lo;0;L;;;;;N;;;;;
+11A30;ZANABAZAR SQUARE LETTER SA;Lo;0;L;;;;;N;;;;;
+11A31;ZANABAZAR SQUARE LETTER HA;Lo;0;L;;;;;N;;;;;
+11A32;ZANABAZAR SQUARE LETTER KSSA;Lo;0;L;;;;;N;;;;;
+11A33;ZANABAZAR SQUARE FINAL CONSONANT MARK;Mn;0;NSM;;;;;N;;;;;
+11A34;ZANABAZAR SQUARE SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;;
+11A35;ZANABAZAR SQUARE SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
+11A36;ZANABAZAR SQUARE SIGN CANDRABINDU WITH ORNAMENT;Mn;0;NSM;;;;;N;;;;;
+11A37;ZANABAZAR SQUARE SIGN CANDRA WITH ORNAMENT;Mn;0;NSM;;;;;N;;;;;
+11A38;ZANABAZAR SQUARE SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+11A39;ZANABAZAR SQUARE SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+11A3A;ZANABAZAR SQUARE CLUSTER-INITIAL LETTER RA;Lo;0;L;;;;;N;;;;;
+11A3B;ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA;Mn;0;NSM;;;;;N;;;;;
+11A3C;ZANABAZAR SQUARE CLUSTER-FINAL LETTER RA;Mn;0;NSM;;;;;N;;;;;
+11A3D;ZANABAZAR SQUARE CLUSTER-FINAL LETTER LA;Mn;0;NSM;;;;;N;;;;;
+11A3E;ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA;Mn;0;NSM;;;;;N;;;;;
+11A3F;ZANABAZAR SQUARE INITIAL HEAD MARK;Po;0;L;;;;;N;;;;;
+11A40;ZANABAZAR SQUARE CLOSING HEAD MARK;Po;0;L;;;;;N;;;;;
+11A41;ZANABAZAR SQUARE MARK TSHEG;Po;0;L;;;;;N;;;;;
+11A42;ZANABAZAR SQUARE MARK SHAD;Po;0;L;;;;;N;;;;;
+11A43;ZANABAZAR SQUARE MARK DOUBLE SHAD;Po;0;L;;;;;N;;;;;
+11A44;ZANABAZAR SQUARE MARK LONG TSHEG;Po;0;L;;;;;N;;;;;
+11A45;ZANABAZAR SQUARE INITIAL DOUBLE-LINED HEAD MARK;Po;0;L;;;;;N;;;;;
+11A46;ZANABAZAR SQUARE CLOSING DOUBLE-LINED HEAD MARK;Po;0;L;;;;;N;;;;;
+11A47;ZANABAZAR SQUARE SUBJOINER;Mn;9;NSM;;;;;N;;;;;
+11A50;SOYOMBO LETTER A;Lo;0;L;;;;;N;;;;;
+11A51;SOYOMBO VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
+11A52;SOYOMBO VOWEL SIGN UE;Mn;0;NSM;;;;;N;;;;;
+11A53;SOYOMBO VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+11A54;SOYOMBO VOWEL SIGN E;Mn;0;NSM;;;;;N;;;;;
+11A55;SOYOMBO VOWEL SIGN O;Mn;0;NSM;;;;;N;;;;;
+11A56;SOYOMBO VOWEL SIGN OE;Mn;0;NSM;;;;;N;;;;;
+11A57;SOYOMBO VOWEL SIGN AI;Mc;0;L;;;;;N;;;;;
+11A58;SOYOMBO VOWEL SIGN AU;Mc;0;L;;;;;N;;;;;
+11A59;SOYOMBO VOWEL SIGN VOCALIC R;Mn;0;NSM;;;;;N;;;;;
+11A5A;SOYOMBO VOWEL SIGN VOCALIC L;Mn;0;NSM;;;;;N;;;;;
+11A5B;SOYOMBO VOWEL LENGTH MARK;Mn;0;NSM;;;;;N;;;;;
+11A5C;SOYOMBO LETTER KA;Lo;0;L;;;;;N;;;;;
+11A5D;SOYOMBO LETTER KHA;Lo;0;L;;;;;N;;;;;
+11A5E;SOYOMBO LETTER GA;Lo;0;L;;;;;N;;;;;
+11A5F;SOYOMBO LETTER GHA;Lo;0;L;;;;;N;;;;;
+11A60;SOYOMBO LETTER NGA;Lo;0;L;;;;;N;;;;;
+11A61;SOYOMBO LETTER CA;Lo;0;L;;;;;N;;;;;
+11A62;SOYOMBO LETTER CHA;Lo;0;L;;;;;N;;;;;
+11A63;SOYOMBO LETTER JA;Lo;0;L;;;;;N;;;;;
+11A64;SOYOMBO LETTER JHA;Lo;0;L;;;;;N;;;;;
+11A65;SOYOMBO LETTER NYA;Lo;0;L;;;;;N;;;;;
+11A66;SOYOMBO LETTER TTA;Lo;0;L;;;;;N;;;;;
+11A67;SOYOMBO LETTER TTHA;Lo;0;L;;;;;N;;;;;
+11A68;SOYOMBO LETTER DDA;Lo;0;L;;;;;N;;;;;
+11A69;SOYOMBO LETTER DDHA;Lo;0;L;;;;;N;;;;;
+11A6A;SOYOMBO LETTER NNA;Lo;0;L;;;;;N;;;;;
+11A6B;SOYOMBO LETTER TA;Lo;0;L;;;;;N;;;;;
+11A6C;SOYOMBO LETTER THA;Lo;0;L;;;;;N;;;;;
+11A6D;SOYOMBO LETTER DA;Lo;0;L;;;;;N;;;;;
+11A6E;SOYOMBO LETTER DHA;Lo;0;L;;;;;N;;;;;
+11A6F;SOYOMBO LETTER NA;Lo;0;L;;;;;N;;;;;
+11A70;SOYOMBO LETTER PA;Lo;0;L;;;;;N;;;;;
+11A71;SOYOMBO LETTER PHA;Lo;0;L;;;;;N;;;;;
+11A72;SOYOMBO LETTER BA;Lo;0;L;;;;;N;;;;;
+11A73;SOYOMBO LETTER BHA;Lo;0;L;;;;;N;;;;;
+11A74;SOYOMBO LETTER MA;Lo;0;L;;;;;N;;;;;
+11A75;SOYOMBO LETTER TSA;Lo;0;L;;;;;N;;;;;
+11A76;SOYOMBO LETTER TSHA;Lo;0;L;;;;;N;;;;;
+11A77;SOYOMBO LETTER DZA;Lo;0;L;;;;;N;;;;;
+11A78;SOYOMBO LETTER ZHA;Lo;0;L;;;;;N;;;;;
+11A79;SOYOMBO LETTER ZA;Lo;0;L;;;;;N;;;;;
+11A7A;SOYOMBO LETTER -A;Lo;0;L;;;;;N;;;;;
+11A7B;SOYOMBO LETTER YA;Lo;0;L;;;;;N;;;;;
+11A7C;SOYOMBO LETTER RA;Lo;0;L;;;;;N;;;;;
+11A7D;SOYOMBO LETTER LA;Lo;0;L;;;;;N;;;;;
+11A7E;SOYOMBO LETTER VA;Lo;0;L;;;;;N;;;;;
+11A7F;SOYOMBO LETTER SHA;Lo;0;L;;;;;N;;;;;
+11A80;SOYOMBO LETTER SSA;Lo;0;L;;;;;N;;;;;
+11A81;SOYOMBO LETTER SA;Lo;0;L;;;;;N;;;;;
+11A82;SOYOMBO LETTER HA;Lo;0;L;;;;;N;;;;;
+11A83;SOYOMBO LETTER KSSA;Lo;0;L;;;;;N;;;;;
+11A84;SOYOMBO SIGN JIHVAMULIYA;Lo;0;L;;;;;N;;;;;
+11A85;SOYOMBO SIGN UPADHMANIYA;Lo;0;L;;;;;N;;;;;
+11A86;SOYOMBO CLUSTER-INITIAL LETTER RA;Lo;0;L;;;;;N;;;;;
+11A87;SOYOMBO CLUSTER-INITIAL LETTER LA;Lo;0;L;;;;;N;;;;;
+11A88;SOYOMBO CLUSTER-INITIAL LETTER SHA;Lo;0;L;;;;;N;;;;;
+11A89;SOYOMBO CLUSTER-INITIAL LETTER SA;Lo;0;L;;;;;N;;;;;
+11A8A;SOYOMBO FINAL CONSONANT SIGN G;Mn;0;NSM;;;;;N;;;;;
+11A8B;SOYOMBO FINAL CONSONANT SIGN K;Mn;0;NSM;;;;;N;;;;;
+11A8C;SOYOMBO FINAL CONSONANT SIGN NG;Mn;0;NSM;;;;;N;;;;;
+11A8D;SOYOMBO FINAL CONSONANT SIGN D;Mn;0;NSM;;;;;N;;;;;
+11A8E;SOYOMBO FINAL CONSONANT SIGN N;Mn;0;NSM;;;;;N;;;;;
+11A8F;SOYOMBO FINAL CONSONANT SIGN B;Mn;0;NSM;;;;;N;;;;;
+11A90;SOYOMBO FINAL CONSONANT SIGN M;Mn;0;NSM;;;;;N;;;;;
+11A91;SOYOMBO FINAL CONSONANT SIGN R;Mn;0;NSM;;;;;N;;;;;
+11A92;SOYOMBO FINAL CONSONANT SIGN L;Mn;0;NSM;;;;;N;;;;;
+11A93;SOYOMBO FINAL CONSONANT SIGN SH;Mn;0;NSM;;;;;N;;;;;
+11A94;SOYOMBO FINAL CONSONANT SIGN S;Mn;0;NSM;;;;;N;;;;;
+11A95;SOYOMBO FINAL CONSONANT SIGN -A;Mn;0;NSM;;;;;N;;;;;
+11A96;SOYOMBO SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+11A97;SOYOMBO SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+11A98;SOYOMBO GEMINATION MARK;Mn;0;NSM;;;;;N;;;;;
+11A99;SOYOMBO SUBJOINER;Mn;9;NSM;;;;;N;;;;;
+11A9A;SOYOMBO MARK TSHEG;Po;0;L;;;;;N;;;;;
+11A9B;SOYOMBO MARK SHAD;Po;0;L;;;;;N;;;;;
+11A9C;SOYOMBO MARK DOUBLE SHAD;Po;0;L;;;;;N;;;;;
+11A9D;SOYOMBO MARK PLUTA;Lo;0;L;;;;;N;;;;;
+11A9E;SOYOMBO HEAD MARK WITH MOON AND SUN AND TRIPLE FLAME;Po;0;L;;;;;N;;;;;
+11A9F;SOYOMBO HEAD MARK WITH MOON AND SUN AND FLAME;Po;0;L;;;;;N;;;;;
+11AA0;SOYOMBO HEAD MARK WITH MOON AND SUN;Po;0;L;;;;;N;;;;;
+11AA1;SOYOMBO TERMINAL MARK-1;Po;0;L;;;;;N;;;;;
+11AA2;SOYOMBO TERMINAL MARK-2;Po;0;L;;;;;N;;;;;
+11AB0;CANADIAN SYLLABICS NATTILIK HI;Lo;0;L;;;;;N;;;;;
+11AB1;CANADIAN SYLLABICS NATTILIK HII;Lo;0;L;;;;;N;;;;;
+11AB2;CANADIAN SYLLABICS NATTILIK HO;Lo;0;L;;;;;N;;;;;
+11AB3;CANADIAN SYLLABICS NATTILIK HOO;Lo;0;L;;;;;N;;;;;
+11AB4;CANADIAN SYLLABICS NATTILIK HA;Lo;0;L;;;;;N;;;;;
+11AB5;CANADIAN SYLLABICS NATTILIK HAA;Lo;0;L;;;;;N;;;;;
+11AB6;CANADIAN SYLLABICS NATTILIK SHRI;Lo;0;L;;;;;N;;;;;
+11AB7;CANADIAN SYLLABICS NATTILIK SHRII;Lo;0;L;;;;;N;;;;;
+11AB8;CANADIAN SYLLABICS NATTILIK SHRO;Lo;0;L;;;;;N;;;;;
+11AB9;CANADIAN SYLLABICS NATTILIK SHROO;Lo;0;L;;;;;N;;;;;
+11ABA;CANADIAN SYLLABICS NATTILIK SHRA;Lo;0;L;;;;;N;;;;;
+11ABB;CANADIAN SYLLABICS NATTILIK SHRAA;Lo;0;L;;;;;N;;;;;
+11ABC;CANADIAN SYLLABICS SPE;Lo;0;L;;;;;N;;;;;
+11ABD;CANADIAN SYLLABICS SPI;Lo;0;L;;;;;N;;;;;
+11ABE;CANADIAN SYLLABICS SPO;Lo;0;L;;;;;N;;;;;
+11ABF;CANADIAN SYLLABICS SPA;Lo;0;L;;;;;N;;;;;
 11AC0;PAU CIN HAU LETTER PA;Lo;0;L;;;;;N;;;;;
 11AC1;PAU CIN HAU LETTER KA;Lo;0;L;;;;;N;;;;;
 11AC2;PAU CIN HAU LETTER LA;Lo;0;L;;;;;N;;;;;
@@ -19449,6 +21613,589 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 11AF6;PAU CIN HAU LOW-FALLING TONE LONG FINAL;Lo;0;L;;;;;N;;;;;
 11AF7;PAU CIN HAU LOW-FALLING TONE FINAL;Lo;0;L;;;;;N;;;;;
 11AF8;PAU CIN HAU GLOTTAL STOP FINAL;Lo;0;L;;;;;N;;;;;
+11B00;DEVANAGARI HEAD MARK;Po;0;L;;;;;N;;;;;
+11B01;DEVANAGARI HEAD MARK WITH HEADSTROKE;Po;0;L;;;;;N;;;;;
+11B02;DEVANAGARI SIGN BHALE;Po;0;L;;;;;N;;;;;
+11B03;DEVANAGARI SIGN BHALE WITH HOOK;Po;0;L;;;;;N;;;;;
+11B04;DEVANAGARI SIGN EXTENDED BHALE;Po;0;L;;;;;N;;;;;
+11B05;DEVANAGARI SIGN EXTENDED BHALE WITH HOOK;Po;0;L;;;;;N;;;;;
+11B06;DEVANAGARI SIGN WESTERN FIVE-LIKE BHALE;Po;0;L;;;;;N;;;;;
+11B07;DEVANAGARI SIGN WESTERN NINE-LIKE BHALE;Po;0;L;;;;;N;;;;;
+11B08;DEVANAGARI SIGN REVERSED NINE-LIKE BHALE;Po;0;L;;;;;N;;;;;
+11B09;DEVANAGARI SIGN MINDU;Po;0;L;;;;;N;;;;;
+11B60;SHARADA VOWEL SIGN OE;Mn;0;NSM;;;;;N;;;;;
+11B61;SHARADA VOWEL SIGN OOE;Mc;0;L;;;;;N;;;;;
+11B62;SHARADA VOWEL SIGN UE;Mn;0;NSM;;;;;N;;;;;
+11B63;SHARADA VOWEL SIGN UUE;Mn;0;NSM;;;;;N;;;;;
+11B64;SHARADA VOWEL SIGN SHORT E;Mn;0;NSM;;;;;N;;;;;
+11B65;SHARADA VOWEL SIGN SHORT O;Mc;0;L;;;;;N;;;;;
+11B66;SHARADA VOWEL SIGN CANDRA E;Mn;0;NSM;;;;;N;;;;;
+11B67;SHARADA VOWEL SIGN CANDRA O;Mc;0;L;;;;;N;;;;;
+11BC0;SUNUWAR LETTER DEVI;Lo;0;L;;;;;N;;;;;
+11BC1;SUNUWAR LETTER TASLA;Lo;0;L;;;;;N;;;;;
+11BC2;SUNUWAR LETTER EKO;Lo;0;L;;;;;N;;;;;
+11BC3;SUNUWAR LETTER IMAR;Lo;0;L;;;;;N;;;;;
+11BC4;SUNUWAR LETTER REU;Lo;0;L;;;;;N;;;;;
+11BC5;SUNUWAR LETTER UTTHI;Lo;0;L;;;;;N;;;;;
+11BC6;SUNUWAR LETTER KIK;Lo;0;L;;;;;N;;;;;
+11BC7;SUNUWAR LETTER MA;Lo;0;L;;;;;N;;;;;
+11BC8;SUNUWAR LETTER APPHO;Lo;0;L;;;;;N;;;;;
+11BC9;SUNUWAR LETTER PIP;Lo;0;L;;;;;N;;;;;
+11BCA;SUNUWAR LETTER GIL;Lo;0;L;;;;;N;;;;;
+11BCB;SUNUWAR LETTER HAMSO;Lo;0;L;;;;;N;;;;;
+11BCC;SUNUWAR LETTER CARMI;Lo;0;L;;;;;N;;;;;
+11BCD;SUNUWAR LETTER NAH;Lo;0;L;;;;;N;;;;;
+11BCE;SUNUWAR LETTER BUR;Lo;0;L;;;;;N;;;;;
+11BCF;SUNUWAR LETTER JYAH;Lo;0;L;;;;;N;;;;;
+11BD0;SUNUWAR LETTER LOACHA;Lo;0;L;;;;;N;;;;;
+11BD1;SUNUWAR LETTER OTTHI;Lo;0;L;;;;;N;;;;;
+11BD2;SUNUWAR LETTER SHYELE;Lo;0;L;;;;;N;;;;;
+11BD3;SUNUWAR LETTER VARCA;Lo;0;L;;;;;N;;;;;
+11BD4;SUNUWAR LETTER YAT;Lo;0;L;;;;;N;;;;;
+11BD5;SUNUWAR LETTER AVA;Lo;0;L;;;;;N;;;;;
+11BD6;SUNUWAR LETTER AAL;Lo;0;L;;;;;N;;;;;
+11BD7;SUNUWAR LETTER DONGA;Lo;0;L;;;;;N;;;;;
+11BD8;SUNUWAR LETTER THARI;Lo;0;L;;;;;N;;;;;
+11BD9;SUNUWAR LETTER PHAR;Lo;0;L;;;;;N;;;;;
+11BDA;SUNUWAR LETTER NGAR;Lo;0;L;;;;;N;;;;;
+11BDB;SUNUWAR LETTER KHA;Lo;0;L;;;;;N;;;;;
+11BDC;SUNUWAR LETTER SHYER;Lo;0;L;;;;;N;;;;;
+11BDD;SUNUWAR LETTER CHELAP;Lo;0;L;;;;;N;;;;;
+11BDE;SUNUWAR LETTER TENTU;Lo;0;L;;;;;N;;;;;
+11BDF;SUNUWAR LETTER THELE;Lo;0;L;;;;;N;;;;;
+11BE0;SUNUWAR LETTER KLOKO;Lo;0;L;;;;;N;;;;;
+11BE1;SUNUWAR SIGN PVO;Po;0;L;;;;;N;;;;;
+11BF0;SUNUWAR DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+11BF1;SUNUWAR DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+11BF2;SUNUWAR DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+11BF3;SUNUWAR DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+11BF4;SUNUWAR DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+11BF5;SUNUWAR DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+11BF6;SUNUWAR DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+11BF7;SUNUWAR DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+11BF8;SUNUWAR DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+11BF9;SUNUWAR DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+11C00;BHAIKSUKI LETTER A;Lo;0;L;;;;;N;;;;;
+11C01;BHAIKSUKI LETTER AA;Lo;0;L;;;;;N;;;;;
+11C02;BHAIKSUKI LETTER I;Lo;0;L;;;;;N;;;;;
+11C03;BHAIKSUKI LETTER II;Lo;0;L;;;;;N;;;;;
+11C04;BHAIKSUKI LETTER U;Lo;0;L;;;;;N;;;;;
+11C05;BHAIKSUKI LETTER UU;Lo;0;L;;;;;N;;;;;
+11C06;BHAIKSUKI LETTER VOCALIC R;Lo;0;L;;;;;N;;;;;
+11C07;BHAIKSUKI LETTER VOCALIC RR;Lo;0;L;;;;;N;;;;;
+11C08;BHAIKSUKI LETTER VOCALIC L;Lo;0;L;;;;;N;;;;;
+11C0A;BHAIKSUKI LETTER E;Lo;0;L;;;;;N;;;;;
+11C0B;BHAIKSUKI LETTER AI;Lo;0;L;;;;;N;;;;;
+11C0C;BHAIKSUKI LETTER O;Lo;0;L;;;;;N;;;;;
+11C0D;BHAIKSUKI LETTER AU;Lo;0;L;;;;;N;;;;;
+11C0E;BHAIKSUKI LETTER KA;Lo;0;L;;;;;N;;;;;
+11C0F;BHAIKSUKI LETTER KHA;Lo;0;L;;;;;N;;;;;
+11C10;BHAIKSUKI LETTER GA;Lo;0;L;;;;;N;;;;;
+11C11;BHAIKSUKI LETTER GHA;Lo;0;L;;;;;N;;;;;
+11C12;BHAIKSUKI LETTER NGA;Lo;0;L;;;;;N;;;;;
+11C13;BHAIKSUKI LETTER CA;Lo;0;L;;;;;N;;;;;
+11C14;BHAIKSUKI LETTER CHA;Lo;0;L;;;;;N;;;;;
+11C15;BHAIKSUKI LETTER JA;Lo;0;L;;;;;N;;;;;
+11C16;BHAIKSUKI LETTER JHA;Lo;0;L;;;;;N;;;;;
+11C17;BHAIKSUKI LETTER NYA;Lo;0;L;;;;;N;;;;;
+11C18;BHAIKSUKI LETTER TTA;Lo;0;L;;;;;N;;;;;
+11C19;BHAIKSUKI LETTER TTHA;Lo;0;L;;;;;N;;;;;
+11C1A;BHAIKSUKI LETTER DDA;Lo;0;L;;;;;N;;;;;
+11C1B;BHAIKSUKI LETTER DDHA;Lo;0;L;;;;;N;;;;;
+11C1C;BHAIKSUKI LETTER NNA;Lo;0;L;;;;;N;;;;;
+11C1D;BHAIKSUKI LETTER TA;Lo;0;L;;;;;N;;;;;
+11C1E;BHAIKSUKI LETTER THA;Lo;0;L;;;;;N;;;;;
+11C1F;BHAIKSUKI LETTER DA;Lo;0;L;;;;;N;;;;;
+11C20;BHAIKSUKI LETTER DHA;Lo;0;L;;;;;N;;;;;
+11C21;BHAIKSUKI LETTER NA;Lo;0;L;;;;;N;;;;;
+11C22;BHAIKSUKI LETTER PA;Lo;0;L;;;;;N;;;;;
+11C23;BHAIKSUKI LETTER PHA;Lo;0;L;;;;;N;;;;;
+11C24;BHAIKSUKI LETTER BA;Lo;0;L;;;;;N;;;;;
+11C25;BHAIKSUKI LETTER BHA;Lo;0;L;;;;;N;;;;;
+11C26;BHAIKSUKI LETTER MA;Lo;0;L;;;;;N;;;;;
+11C27;BHAIKSUKI LETTER YA;Lo;0;L;;;;;N;;;;;
+11C28;BHAIKSUKI LETTER RA;Lo;0;L;;;;;N;;;;;
+11C29;BHAIKSUKI LETTER LA;Lo;0;L;;;;;N;;;;;
+11C2A;BHAIKSUKI LETTER VA;Lo;0;L;;;;;N;;;;;
+11C2B;BHAIKSUKI LETTER SHA;Lo;0;L;;;;;N;;;;;
+11C2C;BHAIKSUKI LETTER SSA;Lo;0;L;;;;;N;;;;;
+11C2D;BHAIKSUKI LETTER SA;Lo;0;L;;;;;N;;;;;
+11C2E;BHAIKSUKI LETTER HA;Lo;0;L;;;;;N;;;;;
+11C2F;BHAIKSUKI VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
+11C30;BHAIKSUKI VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
+11C31;BHAIKSUKI VOWEL SIGN II;Mn;0;NSM;;;;;N;;;;;
+11C32;BHAIKSUKI VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+11C33;BHAIKSUKI VOWEL SIGN UU;Mn;0;NSM;;;;;N;;;;;
+11C34;BHAIKSUKI VOWEL SIGN VOCALIC R;Mn;0;NSM;;;;;N;;;;;
+11C35;BHAIKSUKI VOWEL SIGN VOCALIC RR;Mn;0;NSM;;;;;N;;;;;
+11C36;BHAIKSUKI VOWEL SIGN VOCALIC L;Mn;0;NSM;;;;;N;;;;;
+11C38;BHAIKSUKI VOWEL SIGN E;Mn;0;NSM;;;;;N;;;;;
+11C39;BHAIKSUKI VOWEL SIGN AI;Mn;0;NSM;;;;;N;;;;;
+11C3A;BHAIKSUKI VOWEL SIGN O;Mn;0;NSM;;;;;N;;;;;
+11C3B;BHAIKSUKI VOWEL SIGN AU;Mn;0;NSM;;;;;N;;;;;
+11C3C;BHAIKSUKI SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
+11C3D;BHAIKSUKI SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+11C3E;BHAIKSUKI SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+11C3F;BHAIKSUKI SIGN VIRAMA;Mn;9;L;;;;;N;;;;;
+11C40;BHAIKSUKI SIGN AVAGRAHA;Lo;0;L;;;;;N;;;;;
+11C41;BHAIKSUKI DANDA;Po;0;L;;;;;N;;;;;
+11C42;BHAIKSUKI DOUBLE DANDA;Po;0;L;;;;;N;;;;;
+11C43;BHAIKSUKI WORD SEPARATOR;Po;0;L;;;;;N;;;;;
+11C44;BHAIKSUKI GAP FILLER-1;Po;0;L;;;;;N;;;;;
+11C45;BHAIKSUKI GAP FILLER-2;Po;0;L;;;;;N;;;;;
+11C50;BHAIKSUKI DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+11C51;BHAIKSUKI DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+11C52;BHAIKSUKI DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+11C53;BHAIKSUKI DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+11C54;BHAIKSUKI DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+11C55;BHAIKSUKI DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+11C56;BHAIKSUKI DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+11C57;BHAIKSUKI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+11C58;BHAIKSUKI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+11C59;BHAIKSUKI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+11C5A;BHAIKSUKI NUMBER ONE;No;0;L;;;;1;N;;;;;
+11C5B;BHAIKSUKI NUMBER TWO;No;0;L;;;;2;N;;;;;
+11C5C;BHAIKSUKI NUMBER THREE;No;0;L;;;;3;N;;;;;
+11C5D;BHAIKSUKI NUMBER FOUR;No;0;L;;;;4;N;;;;;
+11C5E;BHAIKSUKI NUMBER FIVE;No;0;L;;;;5;N;;;;;
+11C5F;BHAIKSUKI NUMBER SIX;No;0;L;;;;6;N;;;;;
+11C60;BHAIKSUKI NUMBER SEVEN;No;0;L;;;;7;N;;;;;
+11C61;BHAIKSUKI NUMBER EIGHT;No;0;L;;;;8;N;;;;;
+11C62;BHAIKSUKI NUMBER NINE;No;0;L;;;;9;N;;;;;
+11C63;BHAIKSUKI NUMBER TEN;No;0;L;;;;10;N;;;;;
+11C64;BHAIKSUKI NUMBER TWENTY;No;0;L;;;;20;N;;;;;
+11C65;BHAIKSUKI NUMBER THIRTY;No;0;L;;;;30;N;;;;;
+11C66;BHAIKSUKI NUMBER FORTY;No;0;L;;;;40;N;;;;;
+11C67;BHAIKSUKI NUMBER FIFTY;No;0;L;;;;50;N;;;;;
+11C68;BHAIKSUKI NUMBER SIXTY;No;0;L;;;;60;N;;;;;
+11C69;BHAIKSUKI NUMBER SEVENTY;No;0;L;;;;70;N;;;;;
+11C6A;BHAIKSUKI NUMBER EIGHTY;No;0;L;;;;80;N;;;;;
+11C6B;BHAIKSUKI NUMBER NINETY;No;0;L;;;;90;N;;;;;
+11C6C;BHAIKSUKI HUNDREDS UNIT MARK;No;0;L;;;;100;N;;;;;
+11C70;MARCHEN HEAD MARK;Po;0;L;;;;;N;;;;;
+11C71;MARCHEN MARK SHAD;Po;0;L;;;;;N;;;;;
+11C72;MARCHEN LETTER KA;Lo;0;L;;;;;N;;;;;
+11C73;MARCHEN LETTER KHA;Lo;0;L;;;;;N;;;;;
+11C74;MARCHEN LETTER GA;Lo;0;L;;;;;N;;;;;
+11C75;MARCHEN LETTER NGA;Lo;0;L;;;;;N;;;;;
+11C76;MARCHEN LETTER CA;Lo;0;L;;;;;N;;;;;
+11C77;MARCHEN LETTER CHA;Lo;0;L;;;;;N;;;;;
+11C78;MARCHEN LETTER JA;Lo;0;L;;;;;N;;;;;
+11C79;MARCHEN LETTER NYA;Lo;0;L;;;;;N;;;;;
+11C7A;MARCHEN LETTER TA;Lo;0;L;;;;;N;;;;;
+11C7B;MARCHEN LETTER THA;Lo;0;L;;;;;N;;;;;
+11C7C;MARCHEN LETTER DA;Lo;0;L;;;;;N;;;;;
+11C7D;MARCHEN LETTER NA;Lo;0;L;;;;;N;;;;;
+11C7E;MARCHEN LETTER PA;Lo;0;L;;;;;N;;;;;
+11C7F;MARCHEN LETTER PHA;Lo;0;L;;;;;N;;;;;
+11C80;MARCHEN LETTER BA;Lo;0;L;;;;;N;;;;;
+11C81;MARCHEN LETTER MA;Lo;0;L;;;;;N;;;;;
+11C82;MARCHEN LETTER TSA;Lo;0;L;;;;;N;;;;;
+11C83;MARCHEN LETTER TSHA;Lo;0;L;;;;;N;;;;;
+11C84;MARCHEN LETTER DZA;Lo;0;L;;;;;N;;;;;
+11C85;MARCHEN LETTER WA;Lo;0;L;;;;;N;;;;;
+11C86;MARCHEN LETTER ZHA;Lo;0;L;;;;;N;;;;;
+11C87;MARCHEN LETTER ZA;Lo;0;L;;;;;N;;;;;
+11C88;MARCHEN LETTER -A;Lo;0;L;;;;;N;;;;;
+11C89;MARCHEN LETTER YA;Lo;0;L;;;;;N;;;;;
+11C8A;MARCHEN LETTER RA;Lo;0;L;;;;;N;;;;;
+11C8B;MARCHEN LETTER LA;Lo;0;L;;;;;N;;;;;
+11C8C;MARCHEN LETTER SHA;Lo;0;L;;;;;N;;;;;
+11C8D;MARCHEN LETTER SA;Lo;0;L;;;;;N;;;;;
+11C8E;MARCHEN LETTER HA;Lo;0;L;;;;;N;;;;;
+11C8F;MARCHEN LETTER A;Lo;0;L;;;;;N;;;;;
+11C92;MARCHEN SUBJOINED LETTER KA;Mn;0;NSM;;;;;N;;;;;
+11C93;MARCHEN SUBJOINED LETTER KHA;Mn;0;NSM;;;;;N;;;;;
+11C94;MARCHEN SUBJOINED LETTER GA;Mn;0;NSM;;;;;N;;;;;
+11C95;MARCHEN SUBJOINED LETTER NGA;Mn;0;NSM;;;;;N;;;;;
+11C96;MARCHEN SUBJOINED LETTER CA;Mn;0;NSM;;;;;N;;;;;
+11C97;MARCHEN SUBJOINED LETTER CHA;Mn;0;NSM;;;;;N;;;;;
+11C98;MARCHEN SUBJOINED LETTER JA;Mn;0;NSM;;;;;N;;;;;
+11C99;MARCHEN SUBJOINED LETTER NYA;Mn;0;NSM;;;;;N;;;;;
+11C9A;MARCHEN SUBJOINED LETTER TA;Mn;0;NSM;;;;;N;;;;;
+11C9B;MARCHEN SUBJOINED LETTER THA;Mn;0;NSM;;;;;N;;;;;
+11C9C;MARCHEN SUBJOINED LETTER DA;Mn;0;NSM;;;;;N;;;;;
+11C9D;MARCHEN SUBJOINED LETTER NA;Mn;0;NSM;;;;;N;;;;;
+11C9E;MARCHEN SUBJOINED LETTER PA;Mn;0;NSM;;;;;N;;;;;
+11C9F;MARCHEN SUBJOINED LETTER PHA;Mn;0;NSM;;;;;N;;;;;
+11CA0;MARCHEN SUBJOINED LETTER BA;Mn;0;NSM;;;;;N;;;;;
+11CA1;MARCHEN SUBJOINED LETTER MA;Mn;0;NSM;;;;;N;;;;;
+11CA2;MARCHEN SUBJOINED LETTER TSA;Mn;0;NSM;;;;;N;;;;;
+11CA3;MARCHEN SUBJOINED LETTER TSHA;Mn;0;NSM;;;;;N;;;;;
+11CA4;MARCHEN SUBJOINED LETTER DZA;Mn;0;NSM;;;;;N;;;;;
+11CA5;MARCHEN SUBJOINED LETTER WA;Mn;0;NSM;;;;;N;;;;;
+11CA6;MARCHEN SUBJOINED LETTER ZHA;Mn;0;NSM;;;;;N;;;;;
+11CA7;MARCHEN SUBJOINED LETTER ZA;Mn;0;NSM;;;;;N;;;;;
+11CA9;MARCHEN SUBJOINED LETTER YA;Mc;0;L;;;;;N;;;;;
+11CAA;MARCHEN SUBJOINED LETTER RA;Mn;0;NSM;;;;;N;;;;;
+11CAB;MARCHEN SUBJOINED LETTER LA;Mn;0;NSM;;;;;N;;;;;
+11CAC;MARCHEN SUBJOINED LETTER SHA;Mn;0;NSM;;;;;N;;;;;
+11CAD;MARCHEN SUBJOINED LETTER SA;Mn;0;NSM;;;;;N;;;;;
+11CAE;MARCHEN SUBJOINED LETTER HA;Mn;0;NSM;;;;;N;;;;;
+11CAF;MARCHEN SUBJOINED LETTER A;Mn;0;NSM;;;;;N;;;;;
+11CB0;MARCHEN VOWEL SIGN AA;Mn;0;NSM;;;;;N;;;;;
+11CB1;MARCHEN VOWEL SIGN I;Mc;0;L;;;;;N;;;;;
+11CB2;MARCHEN VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+11CB3;MARCHEN VOWEL SIGN E;Mn;0;NSM;;;;;N;;;;;
+11CB4;MARCHEN VOWEL SIGN O;Mc;0;L;;;;;N;;;;;
+11CB5;MARCHEN SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+11CB6;MARCHEN SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
+11D00;MASARAM GONDI LETTER A;Lo;0;L;;;;;N;;;;;
+11D01;MASARAM GONDI LETTER AA;Lo;0;L;;;;;N;;;;;
+11D02;MASARAM GONDI LETTER I;Lo;0;L;;;;;N;;;;;
+11D03;MASARAM GONDI LETTER II;Lo;0;L;;;;;N;;;;;
+11D04;MASARAM GONDI LETTER U;Lo;0;L;;;;;N;;;;;
+11D05;MASARAM GONDI LETTER UU;Lo;0;L;;;;;N;;;;;
+11D06;MASARAM GONDI LETTER E;Lo;0;L;;;;;N;;;;;
+11D08;MASARAM GONDI LETTER AI;Lo;0;L;;;;;N;;;;;
+11D09;MASARAM GONDI LETTER O;Lo;0;L;;;;;N;;;;;
+11D0B;MASARAM GONDI LETTER AU;Lo;0;L;;;;;N;;;;;
+11D0C;MASARAM GONDI LETTER KA;Lo;0;L;;;;;N;;;;;
+11D0D;MASARAM GONDI LETTER KHA;Lo;0;L;;;;;N;;;;;
+11D0E;MASARAM GONDI LETTER GA;Lo;0;L;;;;;N;;;;;
+11D0F;MASARAM GONDI LETTER GHA;Lo;0;L;;;;;N;;;;;
+11D10;MASARAM GONDI LETTER NGA;Lo;0;L;;;;;N;;;;;
+11D11;MASARAM GONDI LETTER CA;Lo;0;L;;;;;N;;;;;
+11D12;MASARAM GONDI LETTER CHA;Lo;0;L;;;;;N;;;;;
+11D13;MASARAM GONDI LETTER JA;Lo;0;L;;;;;N;;;;;
+11D14;MASARAM GONDI LETTER JHA;Lo;0;L;;;;;N;;;;;
+11D15;MASARAM GONDI LETTER NYA;Lo;0;L;;;;;N;;;;;
+11D16;MASARAM GONDI LETTER TTA;Lo;0;L;;;;;N;;;;;
+11D17;MASARAM GONDI LETTER TTHA;Lo;0;L;;;;;N;;;;;
+11D18;MASARAM GONDI LETTER DDA;Lo;0;L;;;;;N;;;;;
+11D19;MASARAM GONDI LETTER DDHA;Lo;0;L;;;;;N;;;;;
+11D1A;MASARAM GONDI LETTER NNA;Lo;0;L;;;;;N;;;;;
+11D1B;MASARAM GONDI LETTER TA;Lo;0;L;;;;;N;;;;;
+11D1C;MASARAM GONDI LETTER THA;Lo;0;L;;;;;N;;;;;
+11D1D;MASARAM GONDI LETTER DA;Lo;0;L;;;;;N;;;;;
+11D1E;MASARAM GONDI LETTER DHA;Lo;0;L;;;;;N;;;;;
+11D1F;MASARAM GONDI LETTER NA;Lo;0;L;;;;;N;;;;;
+11D20;MASARAM GONDI LETTER PA;Lo;0;L;;;;;N;;;;;
+11D21;MASARAM GONDI LETTER PHA;Lo;0;L;;;;;N;;;;;
+11D22;MASARAM GONDI LETTER BA;Lo;0;L;;;;;N;;;;;
+11D23;MASARAM GONDI LETTER BHA;Lo;0;L;;;;;N;;;;;
+11D24;MASARAM GONDI LETTER MA;Lo;0;L;;;;;N;;;;;
+11D25;MASARAM GONDI LETTER YA;Lo;0;L;;;;;N;;;;;
+11D26;MASARAM GONDI LETTER RA;Lo;0;L;;;;;N;;;;;
+11D27;MASARAM GONDI LETTER LA;Lo;0;L;;;;;N;;;;;
+11D28;MASARAM GONDI LETTER VA;Lo;0;L;;;;;N;;;;;
+11D29;MASARAM GONDI LETTER SHA;Lo;0;L;;;;;N;;;;;
+11D2A;MASARAM GONDI LETTER SSA;Lo;0;L;;;;;N;;;;;
+11D2B;MASARAM GONDI LETTER SA;Lo;0;L;;;;;N;;;;;
+11D2C;MASARAM GONDI LETTER HA;Lo;0;L;;;;;N;;;;;
+11D2D;MASARAM GONDI LETTER LLA;Lo;0;L;;;;;N;;;;;
+11D2E;MASARAM GONDI LETTER KSSA;Lo;0;L;;;;;N;;;;;
+11D2F;MASARAM GONDI LETTER JNYA;Lo;0;L;;;;;N;;;;;
+11D30;MASARAM GONDI LETTER TRA;Lo;0;L;;;;;N;;;;;
+11D31;MASARAM GONDI VOWEL SIGN AA;Mn;0;NSM;;;;;N;;;;;
+11D32;MASARAM GONDI VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
+11D33;MASARAM GONDI VOWEL SIGN II;Mn;0;NSM;;;;;N;;;;;
+11D34;MASARAM GONDI VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+11D35;MASARAM GONDI VOWEL SIGN UU;Mn;0;NSM;;;;;N;;;;;
+11D36;MASARAM GONDI VOWEL SIGN VOCALIC R;Mn;0;NSM;;;;;N;;;;;
+11D3A;MASARAM GONDI VOWEL SIGN E;Mn;0;NSM;;;;;N;;;;;
+11D3C;MASARAM GONDI VOWEL SIGN AI;Mn;0;NSM;;;;;N;;;;;
+11D3D;MASARAM GONDI VOWEL SIGN O;Mn;0;NSM;;;;;N;;;;;
+11D3F;MASARAM GONDI VOWEL SIGN AU;Mn;0;NSM;;;;;N;;;;;
+11D40;MASARAM GONDI SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+11D41;MASARAM GONDI SIGN VISARGA;Mn;0;NSM;;;;;N;;;;;
+11D42;MASARAM GONDI SIGN NUKTA;Mn;7;NSM;;;;;N;;;;;
+11D43;MASARAM GONDI SIGN CANDRA;Mn;0;NSM;;;;;N;;;;;
+11D44;MASARAM GONDI SIGN HALANTA;Mn;9;NSM;;;;;N;;;;;
+11D45;MASARAM GONDI VIRAMA;Mn;9;NSM;;;;;N;;;;;
+11D46;MASARAM GONDI REPHA;Lo;0;L;;;;;N;;;;;
+11D47;MASARAM GONDI RA-KARA;Mn;0;NSM;;;;;N;;;;;
+11D50;MASARAM GONDI DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+11D51;MASARAM GONDI DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+11D52;MASARAM GONDI DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+11D53;MASARAM GONDI DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+11D54;MASARAM GONDI DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+11D55;MASARAM GONDI DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+11D56;MASARAM GONDI DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+11D57;MASARAM GONDI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+11D58;MASARAM GONDI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+11D59;MASARAM GONDI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+11D60;GUNJALA GONDI LETTER A;Lo;0;L;;;;;N;;;;;
+11D61;GUNJALA GONDI LETTER AA;Lo;0;L;;;;;N;;;;;
+11D62;GUNJALA GONDI LETTER I;Lo;0;L;;;;;N;;;;;
+11D63;GUNJALA GONDI LETTER II;Lo;0;L;;;;;N;;;;;
+11D64;GUNJALA GONDI LETTER U;Lo;0;L;;;;;N;;;;;
+11D65;GUNJALA GONDI LETTER UU;Lo;0;L;;;;;N;;;;;
+11D67;GUNJALA GONDI LETTER EE;Lo;0;L;;;;;N;;;;;
+11D68;GUNJALA GONDI LETTER AI;Lo;0;L;;;;;N;;;;;
+11D6A;GUNJALA GONDI LETTER OO;Lo;0;L;;;;;N;;;;;
+11D6B;GUNJALA GONDI LETTER AU;Lo;0;L;;;;;N;;;;;
+11D6C;GUNJALA GONDI LETTER YA;Lo;0;L;;;;;N;;;;;
+11D6D;GUNJALA GONDI LETTER VA;Lo;0;L;;;;;N;;;;;
+11D6E;GUNJALA GONDI LETTER BA;Lo;0;L;;;;;N;;;;;
+11D6F;GUNJALA GONDI LETTER BHA;Lo;0;L;;;;;N;;;;;
+11D70;GUNJALA GONDI LETTER MA;Lo;0;L;;;;;N;;;;;
+11D71;GUNJALA GONDI LETTER KA;Lo;0;L;;;;;N;;;;;
+11D72;GUNJALA GONDI LETTER KHA;Lo;0;L;;;;;N;;;;;
+11D73;GUNJALA GONDI LETTER TA;Lo;0;L;;;;;N;;;;;
+11D74;GUNJALA GONDI LETTER THA;Lo;0;L;;;;;N;;;;;
+11D75;GUNJALA GONDI LETTER LA;Lo;0;L;;;;;N;;;;;
+11D76;GUNJALA GONDI LETTER GA;Lo;0;L;;;;;N;;;;;
+11D77;GUNJALA GONDI LETTER GHA;Lo;0;L;;;;;N;;;;;
+11D78;GUNJALA GONDI LETTER DA;Lo;0;L;;;;;N;;;;;
+11D79;GUNJALA GONDI LETTER DHA;Lo;0;L;;;;;N;;;;;
+11D7A;GUNJALA GONDI LETTER NA;Lo;0;L;;;;;N;;;;;
+11D7B;GUNJALA GONDI LETTER CA;Lo;0;L;;;;;N;;;;;
+11D7C;GUNJALA GONDI LETTER CHA;Lo;0;L;;;;;N;;;;;
+11D7D;GUNJALA GONDI LETTER TTA;Lo;0;L;;;;;N;;;;;
+11D7E;GUNJALA GONDI LETTER TTHA;Lo;0;L;;;;;N;;;;;
+11D7F;GUNJALA GONDI LETTER LLA;Lo;0;L;;;;;N;;;;;
+11D80;GUNJALA GONDI LETTER JA;Lo;0;L;;;;;N;;;;;
+11D81;GUNJALA GONDI LETTER JHA;Lo;0;L;;;;;N;;;;;
+11D82;GUNJALA GONDI LETTER DDA;Lo;0;L;;;;;N;;;;;
+11D83;GUNJALA GONDI LETTER DDHA;Lo;0;L;;;;;N;;;;;
+11D84;GUNJALA GONDI LETTER NGA;Lo;0;L;;;;;N;;;;;
+11D85;GUNJALA GONDI LETTER PA;Lo;0;L;;;;;N;;;;;
+11D86;GUNJALA GONDI LETTER PHA;Lo;0;L;;;;;N;;;;;
+11D87;GUNJALA GONDI LETTER HA;Lo;0;L;;;;;N;;;;;
+11D88;GUNJALA GONDI LETTER RA;Lo;0;L;;;;;N;;;;;
+11D89;GUNJALA GONDI LETTER SA;Lo;0;L;;;;;N;;;;;
+11D8A;GUNJALA GONDI VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
+11D8B;GUNJALA GONDI VOWEL SIGN I;Mc;0;L;;;;;N;;;;;
+11D8C;GUNJALA GONDI VOWEL SIGN II;Mc;0;L;;;;;N;;;;;
+11D8D;GUNJALA GONDI VOWEL SIGN U;Mc;0;L;;;;;N;;;;;
+11D8E;GUNJALA GONDI VOWEL SIGN UU;Mc;0;L;;;;;N;;;;;
+11D90;GUNJALA GONDI VOWEL SIGN EE;Mn;0;NSM;;;;;N;;;;;
+11D91;GUNJALA GONDI VOWEL SIGN AI;Mn;0;NSM;;;;;N;;;;;
+11D93;GUNJALA GONDI VOWEL SIGN OO;Mc;0;L;;;;;N;;;;;
+11D94;GUNJALA GONDI VOWEL SIGN AU;Mc;0;L;;;;;N;;;;;
+11D95;GUNJALA GONDI SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+11D96;GUNJALA GONDI SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+11D97;GUNJALA GONDI VIRAMA;Mn;9;NSM;;;;;N;;;;;
+11D98;GUNJALA GONDI OM;Lo;0;L;;;;;N;;;;;
+11DA0;GUNJALA GONDI DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+11DA1;GUNJALA GONDI DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+11DA2;GUNJALA GONDI DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+11DA3;GUNJALA GONDI DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+11DA4;GUNJALA GONDI DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+11DA5;GUNJALA GONDI DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+11DA6;GUNJALA GONDI DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+11DA7;GUNJALA GONDI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+11DA8;GUNJALA GONDI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+11DA9;GUNJALA GONDI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+11DB0;TOLONG SIKI LETTER I;Lo;0;L;;;;;N;;;;;
+11DB1;TOLONG SIKI LETTER E;Lo;0;L;;;;;N;;;;;
+11DB2;TOLONG SIKI LETTER U;Lo;0;L;;;;;N;;;;;
+11DB3;TOLONG SIKI LETTER O;Lo;0;L;;;;;N;;;;;
+11DB4;TOLONG SIKI LETTER A;Lo;0;L;;;;;N;;;;;
+11DB5;TOLONG SIKI LETTER AA;Lo;0;L;;;;;N;;;;;
+11DB6;TOLONG SIKI LETTER P;Lo;0;L;;;;;N;;;;;
+11DB7;TOLONG SIKI LETTER PH;Lo;0;L;;;;;N;;;;;
+11DB8;TOLONG SIKI LETTER B;Lo;0;L;;;;;N;;;;;
+11DB9;TOLONG SIKI LETTER BH;Lo;0;L;;;;;N;;;;;
+11DBA;TOLONG SIKI LETTER M;Lo;0;L;;;;;N;;;;;
+11DBB;TOLONG SIKI LETTER T;Lo;0;L;;;;;N;;;;;
+11DBC;TOLONG SIKI LETTER TH;Lo;0;L;;;;;N;;;;;
+11DBD;TOLONG SIKI LETTER D;Lo;0;L;;;;;N;;;;;
+11DBE;TOLONG SIKI LETTER DH;Lo;0;L;;;;;N;;;;;
+11DBF;TOLONG SIKI LETTER N;Lo;0;L;;;;;N;;;;;
+11DC0;TOLONG SIKI LETTER TT;Lo;0;L;;;;;N;;;;;
+11DC1;TOLONG SIKI LETTER TTH;Lo;0;L;;;;;N;;;;;
+11DC2;TOLONG SIKI LETTER DD;Lo;0;L;;;;;N;;;;;
+11DC3;TOLONG SIKI LETTER DDH;Lo;0;L;;;;;N;;;;;
+11DC4;TOLONG SIKI LETTER NN;Lo;0;L;;;;;N;;;;;
+11DC5;TOLONG SIKI LETTER C;Lo;0;L;;;;;N;;;;;
+11DC6;TOLONG SIKI LETTER CH;Lo;0;L;;;;;N;;;;;
+11DC7;TOLONG SIKI LETTER J;Lo;0;L;;;;;N;;;;;
+11DC8;TOLONG SIKI LETTER JH;Lo;0;L;;;;;N;;;;;
+11DC9;TOLONG SIKI LETTER NY;Lo;0;L;;;;;N;;;;;
+11DCA;TOLONG SIKI LETTER K;Lo;0;L;;;;;N;;;;;
+11DCB;TOLONG SIKI LETTER KH;Lo;0;L;;;;;N;;;;;
+11DCC;TOLONG SIKI LETTER G;Lo;0;L;;;;;N;;;;;
+11DCD;TOLONG SIKI LETTER GH;Lo;0;L;;;;;N;;;;;
+11DCE;TOLONG SIKI LETTER NG;Lo;0;L;;;;;N;;;;;
+11DCF;TOLONG SIKI LETTER Y;Lo;0;L;;;;;N;;;;;
+11DD0;TOLONG SIKI LETTER R;Lo;0;L;;;;;N;;;;;
+11DD1;TOLONG SIKI LETTER L;Lo;0;L;;;;;N;;;;;
+11DD2;TOLONG SIKI LETTER V;Lo;0;L;;;;;N;;;;;
+11DD3;TOLONG SIKI LETTER NNY;Lo;0;L;;;;;N;;;;;
+11DD4;TOLONG SIKI LETTER S;Lo;0;L;;;;;N;;;;;
+11DD5;TOLONG SIKI LETTER H;Lo;0;L;;;;;N;;;;;
+11DD6;TOLONG SIKI LETTER X;Lo;0;L;;;;;N;;;;;
+11DD7;TOLONG SIKI LETTER RR;Lo;0;L;;;;;N;;;;;
+11DD8;TOLONG SIKI LETTER RRH;Lo;0;L;;;;;N;;;;;
+11DD9;TOLONG SIKI SIGN SELA;Lm;0;L;;;;;N;;;;;
+11DDA;TOLONG SIKI SIGN HECAKA;Lo;0;L;;;;;N;;;;;
+11DDB;TOLONG SIKI UNGGA;Lo;0;L;;;;;N;;;;;
+11DE0;TOLONG SIKI DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+11DE1;TOLONG SIKI DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+11DE2;TOLONG SIKI DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+11DE3;TOLONG SIKI DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+11DE4;TOLONG SIKI DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+11DE5;TOLONG SIKI DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+11DE6;TOLONG SIKI DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+11DE7;TOLONG SIKI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+11DE8;TOLONG SIKI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+11DE9;TOLONG SIKI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+11EE0;MAKASAR LETTER KA;Lo;0;L;;;;;N;;;;;
+11EE1;MAKASAR LETTER GA;Lo;0;L;;;;;N;;;;;
+11EE2;MAKASAR LETTER NGA;Lo;0;L;;;;;N;;;;;
+11EE3;MAKASAR LETTER PA;Lo;0;L;;;;;N;;;;;
+11EE4;MAKASAR LETTER BA;Lo;0;L;;;;;N;;;;;
+11EE5;MAKASAR LETTER MA;Lo;0;L;;;;;N;;;;;
+11EE6;MAKASAR LETTER TA;Lo;0;L;;;;;N;;;;;
+11EE7;MAKASAR LETTER DA;Lo;0;L;;;;;N;;;;;
+11EE8;MAKASAR LETTER NA;Lo;0;L;;;;;N;;;;;
+11EE9;MAKASAR LETTER CA;Lo;0;L;;;;;N;;;;;
+11EEA;MAKASAR LETTER JA;Lo;0;L;;;;;N;;;;;
+11EEB;MAKASAR LETTER NYA;Lo;0;L;;;;;N;;;;;
+11EEC;MAKASAR LETTER YA;Lo;0;L;;;;;N;;;;;
+11EED;MAKASAR LETTER RA;Lo;0;L;;;;;N;;;;;
+11EEE;MAKASAR LETTER LA;Lo;0;L;;;;;N;;;;;
+11EEF;MAKASAR LETTER VA;Lo;0;L;;;;;N;;;;;
+11EF0;MAKASAR LETTER SA;Lo;0;L;;;;;N;;;;;
+11EF1;MAKASAR LETTER A;Lo;0;L;;;;;N;;;;;
+11EF2;MAKASAR ANGKA;Lo;0;L;;;;;N;;;;;
+11EF3;MAKASAR VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
+11EF4;MAKASAR VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+11EF5;MAKASAR VOWEL SIGN E;Mc;0;L;;;;;N;;;;;
+11EF6;MAKASAR VOWEL SIGN O;Mc;0;L;;;;;N;;;;;
+11EF7;MAKASAR PASSIMBANG;Po;0;L;;;;;N;;;;;
+11EF8;MAKASAR END OF SECTION;Po;0;L;;;;;N;;;;;
+11F00;KAWI SIGN CANDRABINDU;Mn;0;NSM;;;;;N;;;;;
+11F01;KAWI SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+11F02;KAWI SIGN REPHA;Lo;0;L;;;;;N;;;;;
+11F03;KAWI SIGN VISARGA;Mc;0;L;;;;;N;;;;;
+11F04;KAWI LETTER A;Lo;0;L;;;;;N;;;;;
+11F05;KAWI LETTER AA;Lo;0;L;;;;;N;;;;;
+11F06;KAWI LETTER I;Lo;0;L;;;;;N;;;;;
+11F07;KAWI LETTER II;Lo;0;L;;;;;N;;;;;
+11F08;KAWI LETTER U;Lo;0;L;;;;;N;;;;;
+11F09;KAWI LETTER UU;Lo;0;L;;;;;N;;;;;
+11F0A;KAWI LETTER VOCALIC R;Lo;0;L;;;;;N;;;;;
+11F0B;KAWI LETTER VOCALIC RR;Lo;0;L;;;;;N;;;;;
+11F0C;KAWI LETTER VOCALIC L;Lo;0;L;;;;;N;;;;;
+11F0D;KAWI LETTER VOCALIC LL;Lo;0;L;;;;;N;;;;;
+11F0E;KAWI LETTER E;Lo;0;L;;;;;N;;;;;
+11F0F;KAWI LETTER AI;Lo;0;L;;;;;N;;;;;
+11F10;KAWI LETTER O;Lo;0;L;;;;;N;;;;;
+11F12;KAWI LETTER KA;Lo;0;L;;;;;N;;;;;
+11F13;KAWI LETTER KHA;Lo;0;L;;;;;N;;;;;
+11F14;KAWI LETTER GA;Lo;0;L;;;;;N;;;;;
+11F15;KAWI LETTER GHA;Lo;0;L;;;;;N;;;;;
+11F16;KAWI LETTER NGA;Lo;0;L;;;;;N;;;;;
+11F17;KAWI LETTER CA;Lo;0;L;;;;;N;;;;;
+11F18;KAWI LETTER CHA;Lo;0;L;;;;;N;;;;;
+11F19;KAWI LETTER JA;Lo;0;L;;;;;N;;;;;
+11F1A;KAWI LETTER JHA;Lo;0;L;;;;;N;;;;;
+11F1B;KAWI LETTER NYA;Lo;0;L;;;;;N;;;;;
+11F1C;KAWI LETTER TTA;Lo;0;L;;;;;N;;;;;
+11F1D;KAWI LETTER TTHA;Lo;0;L;;;;;N;;;;;
+11F1E;KAWI LETTER DDA;Lo;0;L;;;;;N;;;;;
+11F1F;KAWI LETTER DDHA;Lo;0;L;;;;;N;;;;;
+11F20;KAWI LETTER NNA;Lo;0;L;;;;;N;;;;;
+11F21;KAWI LETTER TA;Lo;0;L;;;;;N;;;;;
+11F22;KAWI LETTER THA;Lo;0;L;;;;;N;;;;;
+11F23;KAWI LETTER DA;Lo;0;L;;;;;N;;;;;
+11F24;KAWI LETTER DHA;Lo;0;L;;;;;N;;;;;
+11F25;KAWI LETTER NA;Lo;0;L;;;;;N;;;;;
+11F26;KAWI LETTER PA;Lo;0;L;;;;;N;;;;;
+11F27;KAWI LETTER PHA;Lo;0;L;;;;;N;;;;;
+11F28;KAWI LETTER BA;Lo;0;L;;;;;N;;;;;
+11F29;KAWI LETTER BHA;Lo;0;L;;;;;N;;;;;
+11F2A;KAWI LETTER MA;Lo;0;L;;;;;N;;;;;
+11F2B;KAWI LETTER YA;Lo;0;L;;;;;N;;;;;
+11F2C;KAWI LETTER RA;Lo;0;L;;;;;N;;;;;
+11F2D;KAWI LETTER LA;Lo;0;L;;;;;N;;;;;
+11F2E;KAWI LETTER WA;Lo;0;L;;;;;N;;;;;
+11F2F;KAWI LETTER SHA;Lo;0;L;;;;;N;;;;;
+11F30;KAWI LETTER SSA;Lo;0;L;;;;;N;;;;;
+11F31;KAWI LETTER SA;Lo;0;L;;;;;N;;;;;
+11F32;KAWI LETTER HA;Lo;0;L;;;;;N;;;;;
+11F33;KAWI LETTER JNYA;Lo;0;L;;;;;N;;;;;
+11F34;KAWI VOWEL SIGN AA;Mc;0;L;;;;;N;;;;;
+11F35;KAWI VOWEL SIGN ALTERNATE AA;Mc;0;L;;;;;N;;;;;
+11F36;KAWI VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
+11F37;KAWI VOWEL SIGN II;Mn;0;NSM;;;;;N;;;;;
+11F38;KAWI VOWEL SIGN U;Mn;0;NSM;;;;;N;;;;;
+11F39;KAWI VOWEL SIGN UU;Mn;0;NSM;;;;;N;;;;;
+11F3A;KAWI VOWEL SIGN VOCALIC R;Mn;0;NSM;;;;;N;;;;;
+11F3E;KAWI VOWEL SIGN E;Mc;0;L;;;;;N;;;;;
+11F3F;KAWI VOWEL SIGN AI;Mc;0;L;;;;;N;;;;;
+11F40;KAWI VOWEL SIGN EU;Mn;0;NSM;;;;;N;;;;;
+11F41;KAWI SIGN KILLER;Mc;9;L;;;;;N;;;;;
+11F42;KAWI CONJOINER;Mn;9;NSM;;;;;N;;;;;
+11F43;KAWI DANDA;Po;0;L;;;;;N;;;;;
+11F44;KAWI DOUBLE DANDA;Po;0;L;;;;;N;;;;;
+11F45;KAWI PUNCTUATION SECTION MARKER;Po;0;L;;;;;N;;;;;
+11F46;KAWI PUNCTUATION ALTERNATE SECTION MARKER;Po;0;L;;;;;N;;;;;
+11F47;KAWI PUNCTUATION FLOWER;Po;0;L;;;;;N;;;;;
+11F48;KAWI PUNCTUATION SPACE FILLER;Po;0;L;;;;;N;;;;;
+11F49;KAWI PUNCTUATION DOT;Po;0;L;;;;;N;;;;;
+11F4A;KAWI PUNCTUATION DOUBLE DOT;Po;0;L;;;;;N;;;;;
+11F4B;KAWI PUNCTUATION TRIPLE DOT;Po;0;L;;;;;N;;;;;
+11F4C;KAWI PUNCTUATION CIRCLE;Po;0;L;;;;;N;;;;;
+11F4D;KAWI PUNCTUATION FILLED CIRCLE;Po;0;L;;;;;N;;;;;
+11F4E;KAWI PUNCTUATION SPIRAL;Po;0;L;;;;;N;;;;;
+11F4F;KAWI PUNCTUATION CLOSING SPIRAL;Po;0;L;;;;;N;;;;;
+11F50;KAWI DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+11F51;KAWI DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+11F52;KAWI DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+11F53;KAWI DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+11F54;KAWI DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+11F55;KAWI DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+11F56;KAWI DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+11F57;KAWI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+11F58;KAWI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+11F59;KAWI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+11F5A;KAWI SIGN NUKTA;Mn;0;NSM;;;;;N;;;;;
+11FB0;LISU LETTER YHA;Lo;0;L;;;;;N;;;;;
+11FC0;TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH;No;0;L;;;;1/320;N;;;;;
+11FC1;TAMIL FRACTION ONE ONE-HUNDRED-AND-SIXTIETH;No;0;L;;;;1/160;N;;;;;
+11FC2;TAMIL FRACTION ONE EIGHTIETH;No;0;L;;;;1/80;N;;;;;
+11FC3;TAMIL FRACTION ONE SIXTY-FOURTH;No;0;L;;;;1/64;N;;;;;
+11FC4;TAMIL FRACTION ONE FORTIETH;No;0;L;;;;1/40;N;;;;;
+11FC5;TAMIL FRACTION ONE THIRTY-SECOND;No;0;L;;;;1/32;N;;;;;
+11FC6;TAMIL FRACTION THREE EIGHTIETHS;No;0;L;;;;3/80;N;;;;;
+11FC7;TAMIL FRACTION THREE SIXTY-FOURTHS;No;0;L;;;;3/64;N;;;;;
+11FC8;TAMIL FRACTION ONE TWENTIETH;No;0;L;;;;1/20;N;;;;;
+11FC9;TAMIL FRACTION ONE SIXTEENTH-1;No;0;L;;;;1/16;N;;;;;
+11FCA;TAMIL FRACTION ONE SIXTEENTH-2;No;0;L;;;;1/16;N;;;;;
+11FCB;TAMIL FRACTION ONE TENTH;No;0;L;;;;1/10;N;;;;;
+11FCC;TAMIL FRACTION ONE EIGHTH;No;0;L;;;;1/8;N;;;;;
+11FCD;TAMIL FRACTION THREE TWENTIETHS;No;0;L;;;;3/20;N;;;;;
+11FCE;TAMIL FRACTION THREE SIXTEENTHS;No;0;L;;;;3/16;N;;;;;
+11FCF;TAMIL FRACTION ONE FIFTH;No;0;L;;;;1/5;N;;;;;
+11FD0;TAMIL FRACTION ONE QUARTER;No;0;L;;;;1/4;N;;;;;
+11FD1;TAMIL FRACTION ONE HALF-1;No;0;L;;;;1/2;N;;;;;
+11FD2;TAMIL FRACTION ONE HALF-2;No;0;L;;;;1/2;N;;;;;
+11FD3;TAMIL FRACTION THREE QUARTERS;No;0;L;;;;3/4;N;;;;;
+11FD4;TAMIL FRACTION DOWNSCALING FACTOR KIIZH;No;0;L;;;;1/320;N;;;;;
+11FD5;TAMIL SIGN NEL;So;0;ON;;;;;N;;;;;
+11FD6;TAMIL SIGN CEVITU;So;0;ON;;;;;N;;;;;
+11FD7;TAMIL SIGN AAZHAAKKU;So;0;ON;;;;;N;;;;;
+11FD8;TAMIL SIGN UZHAKKU;So;0;ON;;;;;N;;;;;
+11FD9;TAMIL SIGN MUUVUZHAKKU;So;0;ON;;;;;N;;;;;
+11FDA;TAMIL SIGN KURUNI;So;0;ON;;;;;N;;;;;
+11FDB;TAMIL SIGN PATHAKKU;So;0;ON;;;;;N;;;;;
+11FDC;TAMIL SIGN MUKKURUNI;So;0;ON;;;;;N;;;;;
+11FDD;TAMIL SIGN KAACU;Sc;0;ET;;;;;N;;;;;
+11FDE;TAMIL SIGN PANAM;Sc;0;ET;;;;;N;;;;;
+11FDF;TAMIL SIGN PON;Sc;0;ET;;;;;N;;;;;
+11FE0;TAMIL SIGN VARAAKAN;Sc;0;ET;;;;;N;;;;;
+11FE1;TAMIL SIGN PAARAM;So;0;ON;;;;;N;;;;;
+11FE2;TAMIL SIGN KUZHI;So;0;ON;;;;;N;;;;;
+11FE3;TAMIL SIGN VELI;So;0;ON;;;;;N;;;;;
+11FE4;TAMIL WET CULTIVATION SIGN;So;0;ON;;;;;N;;;;;
+11FE5;TAMIL DRY CULTIVATION SIGN;So;0;ON;;;;;N;;;;;
+11FE6;TAMIL LAND SIGN;So;0;ON;;;;;N;;;;;
+11FE7;TAMIL SALT PAN SIGN;So;0;ON;;;;;N;;;;;
+11FE8;TAMIL TRADITIONAL CREDIT SIGN;So;0;ON;;;;;N;;;;;
+11FE9;TAMIL TRADITIONAL NUMBER SIGN;So;0;ON;;;;;N;;;;;
+11FEA;TAMIL CURRENT SIGN;So;0;ON;;;;;N;;;;;
+11FEB;TAMIL AND ODD SIGN;So;0;ON;;;;;N;;;;;
+11FEC;TAMIL SPENT SIGN;So;0;ON;;;;;N;;;;;
+11FED;TAMIL TOTAL SIGN;So;0;ON;;;;;N;;;;;
+11FEE;TAMIL IN POSSESSION SIGN;So;0;ON;;;;;N;;;;;
+11FEF;TAMIL STARTING FROM SIGN;So;0;ON;;;;;N;;;;;
+11FF0;TAMIL SIGN MUTHALIYA;So;0;ON;;;;;N;;;;;
+11FF1;TAMIL SIGN VAKAIYARAA;So;0;ON;;;;;N;;;;;
+11FFF;TAMIL PUNCTUATION END OF TEXT;Po;0;L;;;;;N;;;;;
 12000;CUNEIFORM SIGN A;Lo;0;L;;;;;N;;;;;
 12001;CUNEIFORM SIGN A TIMES A;Lo;0;L;;;;;N;;;;;
 12002;CUNEIFORM SIGN A TIMES BAD;Lo;0;L;;;;;N;;;;;
@@ -19505,8 +22252,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 12035;CUNEIFORM SIGN ARAD TIMES KUR;Lo;0;L;;;;;N;;;;;
 12036;CUNEIFORM SIGN ARKAB;Lo;0;L;;;;;N;;;;;
 12037;CUNEIFORM SIGN ASAL2;Lo;0;L;;;;;N;;;;;
-12038;CUNEIFORM SIGN ASH;Lo;0;L;;;;;N;;;;;
-12039;CUNEIFORM SIGN ASH ZIDA TENU;Lo;0;L;;;;;N;;;;;
+12038;CUNEIFORM SIGN ASH;Lo;0;L;;;;1;N;;;;;
+12039;CUNEIFORM SIGN ASH ZIDA TENU;Lo;0;L;;;;1;N;;;;;
 1203A;CUNEIFORM SIGN ASH KABA TENU;Lo;0;L;;;;;N;;;;;
 1203B;CUNEIFORM SIGN ASH OVER ASH TUG2 OVER TUG2 TUG2 OVER TUG2 PAP;Lo;0;L;;;;;N;;;;;
 1203C;CUNEIFORM SIGN ASH OVER ASH OVER ASH;Lo;0;L;;;;;N;;;;;
@@ -19570,7 +22317,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 12076;CUNEIFORM SIGN DIM2;Lo;0;L;;;;;N;;;;;
 12077;CUNEIFORM SIGN DIN;Lo;0;L;;;;;N;;;;;
 12078;CUNEIFORM SIGN DIN KASKAL U GUNU DISH;Lo;0;L;;;;;N;;;;;
-12079;CUNEIFORM SIGN DISH;Lo;0;L;;;;;N;;;;;
+12079;CUNEIFORM SIGN DISH;Lo;0;L;;;;1;N;;;;;
 1207A;CUNEIFORM SIGN DU;Lo;0;L;;;;;N;;;;;
 1207B;CUNEIFORM SIGN DU OVER DU;Lo;0;L;;;;;N;;;;;
 1207C;CUNEIFORM SIGN DU GUNU;Lo;0;L;;;;;N;;;;;
@@ -19999,12 +22746,12 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 12223;CUNEIFORM SIGN MA2;Lo;0;L;;;;;N;;;;;
 12224;CUNEIFORM SIGN MAH;Lo;0;L;;;;;N;;;;;
 12225;CUNEIFORM SIGN MAR;Lo;0;L;;;;;N;;;;;
-12226;CUNEIFORM SIGN MASH;Lo;0;L;;;;;N;;;;;
+12226;CUNEIFORM SIGN MASH;Lo;0;L;;;;1/2;N;;;;;
 12227;CUNEIFORM SIGN MASH2;Lo;0;L;;;;;N;;;;;
 12228;CUNEIFORM SIGN ME;Lo;0;L;;;;;N;;;;;
 12229;CUNEIFORM SIGN MES;Lo;0;L;;;;;N;;;;;
 1222A;CUNEIFORM SIGN MI;Lo;0;L;;;;;N;;;;;
-1222B;CUNEIFORM SIGN MIN;Lo;0;L;;;;;N;;;;;
+1222B;CUNEIFORM SIGN MIN;Lo;0;L;;;;2;N;;;;;
 1222C;CUNEIFORM SIGN MU;Lo;0;L;;;;;N;;;;;
 1222D;CUNEIFORM SIGN MU OVER MU;Lo;0;L;;;;;N;;;;;
 1222E;CUNEIFORM SIGN MUG;Lo;0;L;;;;;N;;;;;
@@ -20228,9 +22975,9 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 12308;CUNEIFORM SIGN TUM;Lo;0;L;;;;;N;;;;;
 12309;CUNEIFORM SIGN TUR;Lo;0;L;;;;;N;;;;;
 1230A;CUNEIFORM SIGN TUR OVER TUR ZA OVER ZA;Lo;0;L;;;;;N;;;;;
-1230B;CUNEIFORM SIGN U;Lo;0;L;;;;;N;;;;;
+1230B;CUNEIFORM SIGN U;Lo;0;L;;;;1;N;;;;;
 1230C;CUNEIFORM SIGN U GUD;Lo;0;L;;;;;N;;;;;
-1230D;CUNEIFORM SIGN U U U;Lo;0;L;;;;;N;;;;;
+1230D;CUNEIFORM SIGN U U U;Lo;0;L;;;;3;N;;;;;
 1230E;CUNEIFORM SIGN U OVER U PA OVER PA GAR OVER GAR;Lo;0;L;;;;;N;;;;;
 1230F;CUNEIFORM SIGN U OVER U SUR OVER SUR;Lo;0;L;;;;;N;;;;;
 12310;CUNEIFORM SIGN U OVER U U REVERSED OVER U REVERSED;Lo;0;L;;;;;N;;;;;
@@ -20370,6 +23117,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 12396;CUNEIFORM SIGN SAG TIMES IGI GUNU;Lo;0;L;;;;;N;;;;;
 12397;CUNEIFORM SIGN TI2;Lo;0;L;;;;;N;;;;;
 12398;CUNEIFORM SIGN UM TIMES ME;Lo;0;L;;;;;N;;;;;
+12399;CUNEIFORM SIGN U U;Lo;0;L;;;;2;N;;;;;
 12400;CUNEIFORM NUMERIC SIGN TWO ASH;Nl;0;L;;;;2;N;;;;;
 12401;CUNEIFORM NUMERIC SIGN THREE ASH;Nl;0;L;;;;3;N;;;;;
 12402;CUNEIFORM NUMERIC SIGN FOUR ASH;Nl;0;L;;;;4;N;;;;;
@@ -20486,6 +23234,301 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 12472;CUNEIFORM PUNCTUATION SIGN DIAGONAL COLON;Po;0;L;;;;;N;;;;;
 12473;CUNEIFORM PUNCTUATION SIGN DIAGONAL TRICOLON;Po;0;L;;;;;N;;;;;
 12474;CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON;Po;0;L;;;;;N;;;;;
+12480;CUNEIFORM SIGN AB TIMES NUN TENU;Lo;0;L;;;;;N;;;;;
+12481;CUNEIFORM SIGN AB TIMES SHU2;Lo;0;L;;;;;N;;;;;
+12482;CUNEIFORM SIGN AD TIMES ESH2;Lo;0;L;;;;;N;;;;;
+12483;CUNEIFORM SIGN BAD TIMES DISH TENU;Lo;0;L;;;;;N;;;;;
+12484;CUNEIFORM SIGN BAHAR2 TIMES AB2;Lo;0;L;;;;;N;;;;;
+12485;CUNEIFORM SIGN BAHAR2 TIMES NI;Lo;0;L;;;;;N;;;;;
+12486;CUNEIFORM SIGN BAHAR2 TIMES ZA;Lo;0;L;;;;;N;;;;;
+12487;CUNEIFORM SIGN BU OVER BU TIMES NA2;Lo;0;L;;;;;N;;;;;
+12488;CUNEIFORM SIGN DA TIMES TAK4;Lo;0;L;;;;;N;;;;;
+12489;CUNEIFORM SIGN DAG TIMES KUR;Lo;0;L;;;;;N;;;;;
+1248A;CUNEIFORM SIGN DIM TIMES IGI;Lo;0;L;;;;;N;;;;;
+1248B;CUNEIFORM SIGN DIM TIMES U U U;Lo;0;L;;;;;N;;;;;
+1248C;CUNEIFORM SIGN DIM2 TIMES UD;Lo;0;L;;;;;N;;;;;
+1248D;CUNEIFORM SIGN DUG TIMES ANSHE;Lo;0;L;;;;;N;;;;;
+1248E;CUNEIFORM SIGN DUG TIMES ASH;Lo;0;L;;;;;N;;;;;
+1248F;CUNEIFORM SIGN DUG TIMES ASH AT LEFT;Lo;0;L;;;;;N;;;;;
+12490;CUNEIFORM SIGN DUG TIMES DIN;Lo;0;L;;;;;N;;;;;
+12491;CUNEIFORM SIGN DUG TIMES DUN;Lo;0;L;;;;;N;;;;;
+12492;CUNEIFORM SIGN DUG TIMES ERIN2;Lo;0;L;;;;;N;;;;;
+12493;CUNEIFORM SIGN DUG TIMES GA;Lo;0;L;;;;;N;;;;;
+12494;CUNEIFORM SIGN DUG TIMES GI;Lo;0;L;;;;;N;;;;;
+12495;CUNEIFORM SIGN DUG TIMES GIR2 GUNU;Lo;0;L;;;;;N;;;;;
+12496;CUNEIFORM SIGN DUG TIMES GISH;Lo;0;L;;;;;N;;;;;
+12497;CUNEIFORM SIGN DUG TIMES HA;Lo;0;L;;;;;N;;;;;
+12498;CUNEIFORM SIGN DUG TIMES HI;Lo;0;L;;;;;N;;;;;
+12499;CUNEIFORM SIGN DUG TIMES IGI GUNU;Lo;0;L;;;;;N;;;;;
+1249A;CUNEIFORM SIGN DUG TIMES KASKAL;Lo;0;L;;;;;N;;;;;
+1249B;CUNEIFORM SIGN DUG TIMES KUR;Lo;0;L;;;;;N;;;;;
+1249C;CUNEIFORM SIGN DUG TIMES KUSHU2;Lo;0;L;;;;;N;;;;;
+1249D;CUNEIFORM SIGN DUG TIMES KUSHU2 PLUS KASKAL;Lo;0;L;;;;;N;;;;;
+1249E;CUNEIFORM SIGN DUG TIMES LAK-020;Lo;0;L;;;;;N;;;;;
+1249F;CUNEIFORM SIGN DUG TIMES LAM;Lo;0;L;;;;;N;;;;;
+124A0;CUNEIFORM SIGN DUG TIMES LAM TIMES KUR;Lo;0;L;;;;;N;;;;;
+124A1;CUNEIFORM SIGN DUG TIMES LUH PLUS GISH;Lo;0;L;;;;;N;;;;;
+124A2;CUNEIFORM SIGN DUG TIMES MASH;Lo;0;L;;;;;N;;;;;
+124A3;CUNEIFORM SIGN DUG TIMES MES;Lo;0;L;;;;;N;;;;;
+124A4;CUNEIFORM SIGN DUG TIMES MI;Lo;0;L;;;;;N;;;;;
+124A5;CUNEIFORM SIGN DUG TIMES NI;Lo;0;L;;;;;N;;;;;
+124A6;CUNEIFORM SIGN DUG TIMES PI;Lo;0;L;;;;;N;;;;;
+124A7;CUNEIFORM SIGN DUG TIMES SHE;Lo;0;L;;;;;N;;;;;
+124A8;CUNEIFORM SIGN DUG TIMES SI GUNU;Lo;0;L;;;;;N;;;;;
+124A9;CUNEIFORM SIGN E2 TIMES KUR;Lo;0;L;;;;;N;;;;;
+124AA;CUNEIFORM SIGN E2 TIMES PAP;Lo;0;L;;;;;N;;;;;
+124AB;CUNEIFORM SIGN ERIN2 X;Lo;0;L;;;;;N;;;;;
+124AC;CUNEIFORM SIGN ESH2 CROSSING ESH2;Lo;0;L;;;;;N;;;;;
+124AD;CUNEIFORM SIGN EZEN SHESHIG TIMES ASH;Lo;0;L;;;;;N;;;;;
+124AE;CUNEIFORM SIGN EZEN SHESHIG TIMES HI;Lo;0;L;;;;;N;;;;;
+124AF;CUNEIFORM SIGN EZEN SHESHIG TIMES IGI GUNU;Lo;0;L;;;;;N;;;;;
+124B0;CUNEIFORM SIGN EZEN SHESHIG TIMES LA;Lo;0;L;;;;;N;;;;;
+124B1;CUNEIFORM SIGN EZEN SHESHIG TIMES LAL;Lo;0;L;;;;;N;;;;;
+124B2;CUNEIFORM SIGN EZEN SHESHIG TIMES ME;Lo;0;L;;;;;N;;;;;
+124B3;CUNEIFORM SIGN EZEN SHESHIG TIMES MES;Lo;0;L;;;;;N;;;;;
+124B4;CUNEIFORM SIGN EZEN SHESHIG TIMES SU;Lo;0;L;;;;;N;;;;;
+124B5;CUNEIFORM SIGN EZEN TIMES SU;Lo;0;L;;;;;N;;;;;
+124B6;CUNEIFORM SIGN GA2 TIMES BAHAR2;Lo;0;L;;;;;N;;;;;
+124B7;CUNEIFORM SIGN GA2 TIMES DIM GUNU;Lo;0;L;;;;;N;;;;;
+124B8;CUNEIFORM SIGN GA2 TIMES DUG TIMES IGI GUNU;Lo;0;L;;;;;N;;;;;
+124B9;CUNEIFORM SIGN GA2 TIMES DUG TIMES KASKAL;Lo;0;L;;;;;N;;;;;
+124BA;CUNEIFORM SIGN GA2 TIMES EREN;Lo;0;L;;;;;N;;;;;
+124BB;CUNEIFORM SIGN GA2 TIMES GA;Lo;0;L;;;;;N;;;;;
+124BC;CUNEIFORM SIGN GA2 TIMES GAR PLUS DI;Lo;0;L;;;;;N;;;;;
+124BD;CUNEIFORM SIGN GA2 TIMES GAR PLUS NE;Lo;0;L;;;;;N;;;;;
+124BE;CUNEIFORM SIGN GA2 TIMES HA PLUS A;Lo;0;L;;;;;N;;;;;
+124BF;CUNEIFORM SIGN GA2 TIMES KUSHU2 PLUS KASKAL;Lo;0;L;;;;;N;;;;;
+124C0;CUNEIFORM SIGN GA2 TIMES LAM;Lo;0;L;;;;;N;;;;;
+124C1;CUNEIFORM SIGN GA2 TIMES LAM TIMES KUR;Lo;0;L;;;;;N;;;;;
+124C2;CUNEIFORM SIGN GA2 TIMES LUH;Lo;0;L;;;;;N;;;;;
+124C3;CUNEIFORM SIGN GA2 TIMES MUSH;Lo;0;L;;;;;N;;;;;
+124C4;CUNEIFORM SIGN GA2 TIMES NE;Lo;0;L;;;;;N;;;;;
+124C5;CUNEIFORM SIGN GA2 TIMES NE PLUS E2;Lo;0;L;;;;;N;;;;;
+124C6;CUNEIFORM SIGN GA2 TIMES NE PLUS GI;Lo;0;L;;;;;N;;;;;
+124C7;CUNEIFORM SIGN GA2 TIMES SHIM;Lo;0;L;;;;;N;;;;;
+124C8;CUNEIFORM SIGN GA2 TIMES ZIZ2;Lo;0;L;;;;;N;;;;;
+124C9;CUNEIFORM SIGN GABA ROTATED NINETY DEGREES;Lo;0;L;;;;;N;;;;;
+124CA;CUNEIFORM SIGN GESHTIN TIMES U;Lo;0;L;;;;;N;;;;;
+124CB;CUNEIFORM SIGN GISH TIMES GISH CROSSING GISH;Lo;0;L;;;;;N;;;;;
+124CC;CUNEIFORM SIGN GU2 TIMES IGI GUNU;Lo;0;L;;;;;N;;;;;
+124CD;CUNEIFORM SIGN GUD PLUS GISH TIMES TAK4;Lo;0;L;;;;;N;;;;;
+124CE;CUNEIFORM SIGN HA TENU GUNU;Lo;0;L;;;;;N;;;;;
+124CF;CUNEIFORM SIGN HI TIMES ASH OVER HI TIMES ASH;Lo;0;L;;;;;N;;;;;
+124D0;CUNEIFORM SIGN KA TIMES BU;Lo;0;L;;;;;N;;;;;
+124D1;CUNEIFORM SIGN KA TIMES KA;Lo;0;L;;;;;N;;;;;
+124D2;CUNEIFORM SIGN KA TIMES U U U;Lo;0;L;;;;;N;;;;;
+124D3;CUNEIFORM SIGN KA TIMES UR;Lo;0;L;;;;;N;;;;;
+124D4;CUNEIFORM SIGN LAGAB TIMES ZU OVER ZU;Lo;0;L;;;;;N;;;;;
+124D5;CUNEIFORM SIGN LAK-003;Lo;0;L;;;;;N;;;;;
+124D6;CUNEIFORM SIGN LAK-021;Lo;0;L;;;;;N;;;;;
+124D7;CUNEIFORM SIGN LAK-025;Lo;0;L;;;;;N;;;;;
+124D8;CUNEIFORM SIGN LAK-030;Lo;0;L;;;;;N;;;;;
+124D9;CUNEIFORM SIGN LAK-050;Lo;0;L;;;;;N;;;;;
+124DA;CUNEIFORM SIGN LAK-051;Lo;0;L;;;;;N;;;;;
+124DB;CUNEIFORM SIGN LAK-062;Lo;0;L;;;;;N;;;;;
+124DC;CUNEIFORM SIGN LAK-079 OVER LAK-079 GUNU;Lo;0;L;;;;;N;;;;;
+124DD;CUNEIFORM SIGN LAK-080;Lo;0;L;;;;;N;;;;;
+124DE;CUNEIFORM SIGN LAK-081 OVER LAK-081;Lo;0;L;;;;;N;;;;;
+124DF;CUNEIFORM SIGN LAK-092;Lo;0;L;;;;;N;;;;;
+124E0;CUNEIFORM SIGN LAK-130;Lo;0;L;;;;;N;;;;;
+124E1;CUNEIFORM SIGN LAK-142;Lo;0;L;;;;;N;;;;;
+124E2;CUNEIFORM SIGN LAK-210;Lo;0;L;;;;;N;;;;;
+124E3;CUNEIFORM SIGN LAK-219;Lo;0;L;;;;;N;;;;;
+124E4;CUNEIFORM SIGN LAK-220;Lo;0;L;;;;;N;;;;;
+124E5;CUNEIFORM SIGN LAK-225;Lo;0;L;;;;;N;;;;;
+124E6;CUNEIFORM SIGN LAK-228;Lo;0;L;;;;;N;;;;;
+124E7;CUNEIFORM SIGN LAK-238;Lo;0;L;;;;;N;;;;;
+124E8;CUNEIFORM SIGN LAK-265;Lo;0;L;;;;;N;;;;;
+124E9;CUNEIFORM SIGN LAK-266;Lo;0;L;;;;;N;;;;;
+124EA;CUNEIFORM SIGN LAK-343;Lo;0;L;;;;;N;;;;;
+124EB;CUNEIFORM SIGN LAK-347;Lo;0;L;;;;;N;;;;;
+124EC;CUNEIFORM SIGN LAK-348;Lo;0;L;;;;;N;;;;;
+124ED;CUNEIFORM SIGN LAK-383;Lo;0;L;;;;;N;;;;;
+124EE;CUNEIFORM SIGN LAK-384;Lo;0;L;;;;;N;;;;;
+124EF;CUNEIFORM SIGN LAK-390;Lo;0;L;;;;;N;;;;;
+124F0;CUNEIFORM SIGN LAK-441;Lo;0;L;;;;;N;;;;;
+124F1;CUNEIFORM SIGN LAK-449;Lo;0;L;;;;;N;;;;;
+124F2;CUNEIFORM SIGN LAK-449 TIMES GU;Lo;0;L;;;;;N;;;;;
+124F3;CUNEIFORM SIGN LAK-449 TIMES IGI;Lo;0;L;;;;;N;;;;;
+124F4;CUNEIFORM SIGN LAK-449 TIMES PAP PLUS LU3;Lo;0;L;;;;;N;;;;;
+124F5;CUNEIFORM SIGN LAK-449 TIMES PAP PLUS PAP PLUS LU3;Lo;0;L;;;;;N;;;;;
+124F6;CUNEIFORM SIGN LAK-449 TIMES U2 PLUS BA;Lo;0;L;;;;;N;;;;;
+124F7;CUNEIFORM SIGN LAK-450;Lo;0;L;;;;;N;;;;;
+124F8;CUNEIFORM SIGN LAK-457;Lo;0;L;;;;;N;;;;;
+124F9;CUNEIFORM SIGN LAK-470;Lo;0;L;;;;;N;;;;;
+124FA;CUNEIFORM SIGN LAK-483;Lo;0;L;;;;;N;;;;;
+124FB;CUNEIFORM SIGN LAK-490;Lo;0;L;;;;;N;;;;;
+124FC;CUNEIFORM SIGN LAK-492;Lo;0;L;;;;;N;;;;;
+124FD;CUNEIFORM SIGN LAK-493;Lo;0;L;;;;;N;;;;;
+124FE;CUNEIFORM SIGN LAK-495;Lo;0;L;;;;;N;;;;;
+124FF;CUNEIFORM SIGN LAK-550;Lo;0;L;;;;;N;;;;;
+12500;CUNEIFORM SIGN LAK-608;Lo;0;L;;;;;N;;;;;
+12501;CUNEIFORM SIGN LAK-617;Lo;0;L;;;;;N;;;;;
+12502;CUNEIFORM SIGN LAK-617 TIMES ASH;Lo;0;L;;;;;N;;;;;
+12503;CUNEIFORM SIGN LAK-617 TIMES BAD;Lo;0;L;;;;;N;;;;;
+12504;CUNEIFORM SIGN LAK-617 TIMES DUN3 GUNU GUNU;Lo;0;L;;;;;N;;;;;
+12505;CUNEIFORM SIGN LAK-617 TIMES KU3;Lo;0;L;;;;;N;;;;;
+12506;CUNEIFORM SIGN LAK-617 TIMES LA;Lo;0;L;;;;;N;;;;;
+12507;CUNEIFORM SIGN LAK-617 TIMES TAR;Lo;0;L;;;;;N;;;;;
+12508;CUNEIFORM SIGN LAK-617 TIMES TE;Lo;0;L;;;;;N;;;;;
+12509;CUNEIFORM SIGN LAK-617 TIMES U2;Lo;0;L;;;;;N;;;;;
+1250A;CUNEIFORM SIGN LAK-617 TIMES UD;Lo;0;L;;;;;N;;;;;
+1250B;CUNEIFORM SIGN LAK-617 TIMES URUDA;Lo;0;L;;;;;N;;;;;
+1250C;CUNEIFORM SIGN LAK-636;Lo;0;L;;;;;N;;;;;
+1250D;CUNEIFORM SIGN LAK-648;Lo;0;L;;;;;N;;;;;
+1250E;CUNEIFORM SIGN LAK-648 TIMES DUB;Lo;0;L;;;;;N;;;;;
+1250F;CUNEIFORM SIGN LAK-648 TIMES GA;Lo;0;L;;;;;N;;;;;
+12510;CUNEIFORM SIGN LAK-648 TIMES IGI;Lo;0;L;;;;;N;;;;;
+12511;CUNEIFORM SIGN LAK-648 TIMES IGI GUNU;Lo;0;L;;;;;N;;;;;
+12512;CUNEIFORM SIGN LAK-648 TIMES NI;Lo;0;L;;;;;N;;;;;
+12513;CUNEIFORM SIGN LAK-648 TIMES PAP PLUS PAP PLUS LU3;Lo;0;L;;;;;N;;;;;
+12514;CUNEIFORM SIGN LAK-648 TIMES SHESH PLUS KI;Lo;0;L;;;;;N;;;;;
+12515;CUNEIFORM SIGN LAK-648 TIMES UD;Lo;0;L;;;;;N;;;;;
+12516;CUNEIFORM SIGN LAK-648 TIMES URUDA;Lo;0;L;;;;;N;;;;;
+12517;CUNEIFORM SIGN LAK-724;Lo;0;L;;;;;N;;;;;
+12518;CUNEIFORM SIGN LAK-749;Lo;0;L;;;;;N;;;;;
+12519;CUNEIFORM SIGN LU2 GUNU TIMES ASH;Lo;0;L;;;;;N;;;;;
+1251A;CUNEIFORM SIGN LU2 TIMES DISH;Lo;0;L;;;;;N;;;;;
+1251B;CUNEIFORM SIGN LU2 TIMES HAL;Lo;0;L;;;;;N;;;;;
+1251C;CUNEIFORM SIGN LU2 TIMES PAP;Lo;0;L;;;;;N;;;;;
+1251D;CUNEIFORM SIGN LU2 TIMES PAP PLUS PAP PLUS LU3;Lo;0;L;;;;;N;;;;;
+1251E;CUNEIFORM SIGN LU2 TIMES TAK4;Lo;0;L;;;;;N;;;;;
+1251F;CUNEIFORM SIGN MI PLUS ZA7;Lo;0;L;;;;;N;;;;;
+12520;CUNEIFORM SIGN MUSH OVER MUSH TIMES GA;Lo;0;L;;;;;N;;;;;
+12521;CUNEIFORM SIGN MUSH OVER MUSH TIMES KAK;Lo;0;L;;;;;N;;;;;
+12522;CUNEIFORM SIGN NINDA2 TIMES DIM GUNU;Lo;0;L;;;;;N;;;;;
+12523;CUNEIFORM SIGN NINDA2 TIMES GISH;Lo;0;L;;;;;N;;;;;
+12524;CUNEIFORM SIGN NINDA2 TIMES GUL;Lo;0;L;;;;;N;;;;;
+12525;CUNEIFORM SIGN NINDA2 TIMES HI;Lo;0;L;;;;;N;;;;;
+12526;CUNEIFORM SIGN NINDA2 TIMES KESH2;Lo;0;L;;;;;N;;;;;
+12527;CUNEIFORM SIGN NINDA2 TIMES LAK-050;Lo;0;L;;;;;N;;;;;
+12528;CUNEIFORM SIGN NINDA2 TIMES MASH;Lo;0;L;;;;;N;;;;;
+12529;CUNEIFORM SIGN NINDA2 TIMES PAP PLUS PAP;Lo;0;L;;;;;N;;;;;
+1252A;CUNEIFORM SIGN NINDA2 TIMES U;Lo;0;L;;;;;N;;;;;
+1252B;CUNEIFORM SIGN NINDA2 TIMES U PLUS U;Lo;0;L;;;;;N;;;;;
+1252C;CUNEIFORM SIGN NINDA2 TIMES URUDA;Lo;0;L;;;;;N;;;;;
+1252D;CUNEIFORM SIGN SAG GUNU TIMES HA;Lo;0;L;;;;;N;;;;;
+1252E;CUNEIFORM SIGN SAG TIMES EN;Lo;0;L;;;;;N;;;;;
+1252F;CUNEIFORM SIGN SAG TIMES SHE AT LEFT;Lo;0;L;;;;;N;;;;;
+12530;CUNEIFORM SIGN SAG TIMES TAK4;Lo;0;L;;;;;N;;;;;
+12531;CUNEIFORM SIGN SHA6 TENU;Lo;0;L;;;;;N;;;;;
+12532;CUNEIFORM SIGN SHE OVER SHE;Lo;0;L;;;;;N;;;;;
+12533;CUNEIFORM SIGN SHE PLUS HUB2;Lo;0;L;;;;;N;;;;;
+12534;CUNEIFORM SIGN SHE PLUS NAM2;Lo;0;L;;;;;N;;;;;
+12535;CUNEIFORM SIGN SHE PLUS SAR;Lo;0;L;;;;;N;;;;;
+12536;CUNEIFORM SIGN SHU2 PLUS DUG TIMES NI;Lo;0;L;;;;;N;;;;;
+12537;CUNEIFORM SIGN SHU2 PLUS E2 TIMES AN;Lo;0;L;;;;;N;;;;;
+12538;CUNEIFORM SIGN SI TIMES TAK4;Lo;0;L;;;;;N;;;;;
+12539;CUNEIFORM SIGN TAK4 PLUS SAG;Lo;0;L;;;;;N;;;;;
+1253A;CUNEIFORM SIGN TUM TIMES GAN2 TENU;Lo;0;L;;;;;N;;;;;
+1253B;CUNEIFORM SIGN TUM TIMES THREE DISH;Lo;0;L;;;;;N;;;;;
+1253C;CUNEIFORM SIGN UR2 INVERTED;Lo;0;L;;;;;N;;;;;
+1253D;CUNEIFORM SIGN UR2 TIMES UD;Lo;0;L;;;;;N;;;;;
+1253E;CUNEIFORM SIGN URU TIMES DARA3;Lo;0;L;;;;;N;;;;;
+1253F;CUNEIFORM SIGN URU TIMES LAK-668;Lo;0;L;;;;;N;;;;;
+12540;CUNEIFORM SIGN URU TIMES LU3;Lo;0;L;;;;;N;;;;;
+12541;CUNEIFORM SIGN ZA7;Lo;0;L;;;;;N;;;;;
+12542;CUNEIFORM SIGN ZU OVER ZU PLUS SAR;Lo;0;L;;;;;N;;;;;
+12543;CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU;Lo;0;L;;;;;N;;;;;
+12F90;CYPRO-MINOAN SIGN CM001;Lo;0;L;;;;;N;;;;;
+12F91;CYPRO-MINOAN SIGN CM002;Lo;0;L;;;;;N;;;;;
+12F92;CYPRO-MINOAN SIGN CM004;Lo;0;L;;;;;N;;;;;
+12F93;CYPRO-MINOAN SIGN CM005;Lo;0;L;;;;;N;;;;;
+12F94;CYPRO-MINOAN SIGN CM006;Lo;0;L;;;;;N;;;;;
+12F95;CYPRO-MINOAN SIGN CM007;Lo;0;L;;;;;N;;;;;
+12F96;CYPRO-MINOAN SIGN CM008;Lo;0;L;;;;;N;;;;;
+12F97;CYPRO-MINOAN SIGN CM009;Lo;0;L;;;;;N;;;;;
+12F98;CYPRO-MINOAN SIGN CM010;Lo;0;L;;;;;N;;;;;
+12F99;CYPRO-MINOAN SIGN CM011;Lo;0;L;;;;;N;;;;;
+12F9A;CYPRO-MINOAN SIGN CM012;Lo;0;L;;;;;N;;;;;
+12F9B;CYPRO-MINOAN SIGN CM012B;Lo;0;L;;;;;N;;;;;
+12F9C;CYPRO-MINOAN SIGN CM013;Lo;0;L;;;;;N;;;;;
+12F9D;CYPRO-MINOAN SIGN CM015;Lo;0;L;;;;;N;;;;;
+12F9E;CYPRO-MINOAN SIGN CM017;Lo;0;L;;;;;N;;;;;
+12F9F;CYPRO-MINOAN SIGN CM019;Lo;0;L;;;;;N;;;;;
+12FA0;CYPRO-MINOAN SIGN CM021;Lo;0;L;;;;;N;;;;;
+12FA1;CYPRO-MINOAN SIGN CM023;Lo;0;L;;;;;N;;;;;
+12FA2;CYPRO-MINOAN SIGN CM024;Lo;0;L;;;;;N;;;;;
+12FA3;CYPRO-MINOAN SIGN CM025;Lo;0;L;;;;;N;;;;;
+12FA4;CYPRO-MINOAN SIGN CM026;Lo;0;L;;;;;N;;;;;
+12FA5;CYPRO-MINOAN SIGN CM027;Lo;0;L;;;;;N;;;;;
+12FA6;CYPRO-MINOAN SIGN CM028;Lo;0;L;;;;;N;;;;;
+12FA7;CYPRO-MINOAN SIGN CM029;Lo;0;L;;;;;N;;;;;
+12FA8;CYPRO-MINOAN SIGN CM030;Lo;0;L;;;;;N;;;;;
+12FA9;CYPRO-MINOAN SIGN CM033;Lo;0;L;;;;;N;;;;;
+12FAA;CYPRO-MINOAN SIGN CM034;Lo;0;L;;;;;N;;;;;
+12FAB;CYPRO-MINOAN SIGN CM035;Lo;0;L;;;;;N;;;;;
+12FAC;CYPRO-MINOAN SIGN CM036;Lo;0;L;;;;;N;;;;;
+12FAD;CYPRO-MINOAN SIGN CM037;Lo;0;L;;;;;N;;;;;
+12FAE;CYPRO-MINOAN SIGN CM038;Lo;0;L;;;;;N;;;;;
+12FAF;CYPRO-MINOAN SIGN CM039;Lo;0;L;;;;;N;;;;;
+12FB0;CYPRO-MINOAN SIGN CM040;Lo;0;L;;;;;N;;;;;
+12FB1;CYPRO-MINOAN SIGN CM041;Lo;0;L;;;;;N;;;;;
+12FB2;CYPRO-MINOAN SIGN CM044;Lo;0;L;;;;;N;;;;;
+12FB3;CYPRO-MINOAN SIGN CM046;Lo;0;L;;;;;N;;;;;
+12FB4;CYPRO-MINOAN SIGN CM047;Lo;0;L;;;;;N;;;;;
+12FB5;CYPRO-MINOAN SIGN CM049;Lo;0;L;;;;;N;;;;;
+12FB6;CYPRO-MINOAN SIGN CM050;Lo;0;L;;;;;N;;;;;
+12FB7;CYPRO-MINOAN SIGN CM051;Lo;0;L;;;;;N;;;;;
+12FB8;CYPRO-MINOAN SIGN CM052;Lo;0;L;;;;;N;;;;;
+12FB9;CYPRO-MINOAN SIGN CM053;Lo;0;L;;;;;N;;;;;
+12FBA;CYPRO-MINOAN SIGN CM054;Lo;0;L;;;;;N;;;;;
+12FBB;CYPRO-MINOAN SIGN CM055;Lo;0;L;;;;;N;;;;;
+12FBC;CYPRO-MINOAN SIGN CM056;Lo;0;L;;;;;N;;;;;
+12FBD;CYPRO-MINOAN SIGN CM058;Lo;0;L;;;;;N;;;;;
+12FBE;CYPRO-MINOAN SIGN CM059;Lo;0;L;;;;;N;;;;;
+12FBF;CYPRO-MINOAN SIGN CM060;Lo;0;L;;;;;N;;;;;
+12FC0;CYPRO-MINOAN SIGN CM061;Lo;0;L;;;;;N;;;;;
+12FC1;CYPRO-MINOAN SIGN CM062;Lo;0;L;;;;;N;;;;;
+12FC2;CYPRO-MINOAN SIGN CM063;Lo;0;L;;;;;N;;;;;
+12FC3;CYPRO-MINOAN SIGN CM064;Lo;0;L;;;;;N;;;;;
+12FC4;CYPRO-MINOAN SIGN CM066;Lo;0;L;;;;;N;;;;;
+12FC5;CYPRO-MINOAN SIGN CM067;Lo;0;L;;;;;N;;;;;
+12FC6;CYPRO-MINOAN SIGN CM068;Lo;0;L;;;;;N;;;;;
+12FC7;CYPRO-MINOAN SIGN CM069;Lo;0;L;;;;;N;;;;;
+12FC8;CYPRO-MINOAN SIGN CM070;Lo;0;L;;;;;N;;;;;
+12FC9;CYPRO-MINOAN SIGN CM071;Lo;0;L;;;;;N;;;;;
+12FCA;CYPRO-MINOAN SIGN CM072;Lo;0;L;;;;;N;;;;;
+12FCB;CYPRO-MINOAN SIGN CM073;Lo;0;L;;;;;N;;;;;
+12FCC;CYPRO-MINOAN SIGN CM074;Lo;0;L;;;;;N;;;;;
+12FCD;CYPRO-MINOAN SIGN CM075;Lo;0;L;;;;;N;;;;;
+12FCE;CYPRO-MINOAN SIGN CM075B;Lo;0;L;;;;;N;;;;;
+12FCF;CYPRO-MINOAN SIGN CM076;Lo;0;L;;;;;N;;;;;
+12FD0;CYPRO-MINOAN SIGN CM078;Lo;0;L;;;;;N;;;;;
+12FD1;CYPRO-MINOAN SIGN CM079;Lo;0;L;;;;;N;;;;;
+12FD2;CYPRO-MINOAN SIGN CM080;Lo;0;L;;;;;N;;;;;
+12FD3;CYPRO-MINOAN SIGN CM081;Lo;0;L;;;;;N;;;;;
+12FD4;CYPRO-MINOAN SIGN CM082;Lo;0;L;;;;;N;;;;;
+12FD5;CYPRO-MINOAN SIGN CM083;Lo;0;L;;;;;N;;;;;
+12FD6;CYPRO-MINOAN SIGN CM084;Lo;0;L;;;;;N;;;;;
+12FD7;CYPRO-MINOAN SIGN CM085;Lo;0;L;;;;;N;;;;;
+12FD8;CYPRO-MINOAN SIGN CM086;Lo;0;L;;;;;N;;;;;
+12FD9;CYPRO-MINOAN SIGN CM087;Lo;0;L;;;;;N;;;;;
+12FDA;CYPRO-MINOAN SIGN CM088;Lo;0;L;;;;;N;;;;;
+12FDB;CYPRO-MINOAN SIGN CM089;Lo;0;L;;;;;N;;;;;
+12FDC;CYPRO-MINOAN SIGN CM090;Lo;0;L;;;;;N;;;;;
+12FDD;CYPRO-MINOAN SIGN CM091;Lo;0;L;;;;;N;;;;;
+12FDE;CYPRO-MINOAN SIGN CM092;Lo;0;L;;;;;N;;;;;
+12FDF;CYPRO-MINOAN SIGN CM094;Lo;0;L;;;;;N;;;;;
+12FE0;CYPRO-MINOAN SIGN CM095;Lo;0;L;;;;;N;;;;;
+12FE1;CYPRO-MINOAN SIGN CM096;Lo;0;L;;;;;N;;;;;
+12FE2;CYPRO-MINOAN SIGN CM097;Lo;0;L;;;;;N;;;;;
+12FE3;CYPRO-MINOAN SIGN CM098;Lo;0;L;;;;;N;;;;;
+12FE4;CYPRO-MINOAN SIGN CM099;Lo;0;L;;;;;N;;;;;
+12FE5;CYPRO-MINOAN SIGN CM100;Lo;0;L;;;;;N;;;;;
+12FE6;CYPRO-MINOAN SIGN CM101;Lo;0;L;;;;;N;;;;;
+12FE7;CYPRO-MINOAN SIGN CM102;Lo;0;L;;;;;N;;;;;
+12FE8;CYPRO-MINOAN SIGN CM103;Lo;0;L;;;;;N;;;;;
+12FE9;CYPRO-MINOAN SIGN CM104;Lo;0;L;;;;;N;;;;;
+12FEA;CYPRO-MINOAN SIGN CM105;Lo;0;L;;;;;N;;;;;
+12FEB;CYPRO-MINOAN SIGN CM107;Lo;0;L;;;;;N;;;;;
+12FEC;CYPRO-MINOAN SIGN CM108;Lo;0;L;;;;;N;;;;;
+12FED;CYPRO-MINOAN SIGN CM109;Lo;0;L;;;;;N;;;;;
+12FEE;CYPRO-MINOAN SIGN CM110;Lo;0;L;;;;;N;;;;;
+12FEF;CYPRO-MINOAN SIGN CM112;Lo;0;L;;;;;N;;;;;
+12FF0;CYPRO-MINOAN SIGN CM114;Lo;0;L;;;;;N;;;;;
+12FF1;CYPRO-MINOAN SIGN CM301;Po;0;L;;;;;N;;;;;
+12FF2;CYPRO-MINOAN SIGN CM302;Po;0;L;;;;;N;;;;;
 13000;EGYPTIAN HIEROGLYPH A001;Lo;0;L;;;;;N;;;;;
 13001;EGYPTIAN HIEROGLYPH A002;Lo;0;L;;;;;N;;;;;
 13002;EGYPTIAN HIEROGLYPH A003;Lo;0;L;;;;;N;;;;;
@@ -21557,6 +24600,4681 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1342C;EGYPTIAN HIEROGLYPH AA030;Lo;0;L;;;;;N;;;;;
 1342D;EGYPTIAN HIEROGLYPH AA031;Lo;0;L;;;;;N;;;;;
 1342E;EGYPTIAN HIEROGLYPH AA032;Lo;0;L;;;;;N;;;;;
+1342F;EGYPTIAN HIEROGLYPH V011D;Lo;0;L;;;;;N;;;;;
+13430;EGYPTIAN HIEROGLYPH VERTICAL JOINER;Cf;0;L;;;;;N;;;;;
+13431;EGYPTIAN HIEROGLYPH HORIZONTAL JOINER;Cf;0;L;;;;;N;;;;;
+13432;EGYPTIAN HIEROGLYPH INSERT AT TOP START;Cf;0;L;;;;;N;;;;;
+13433;EGYPTIAN HIEROGLYPH INSERT AT BOTTOM START;Cf;0;L;;;;;N;;;;;
+13434;EGYPTIAN HIEROGLYPH INSERT AT TOP END;Cf;0;L;;;;;N;;;;;
+13435;EGYPTIAN HIEROGLYPH INSERT AT BOTTOM END;Cf;0;L;;;;;N;;;;;
+13436;EGYPTIAN HIEROGLYPH OVERLAY MIDDLE;Cf;0;L;;;;;N;;;;;
+13437;EGYPTIAN HIEROGLYPH BEGIN SEGMENT;Cf;0;L;;;;;N;;;;;
+13438;EGYPTIAN HIEROGLYPH END SEGMENT;Cf;0;L;;;;;N;;;;;
+13439;EGYPTIAN HIEROGLYPH INSERT AT MIDDLE;Cf;0;L;;;;;N;;;;;
+1343A;EGYPTIAN HIEROGLYPH INSERT AT TOP;Cf;0;L;;;;;N;;;;;
+1343B;EGYPTIAN HIEROGLYPH INSERT AT BOTTOM;Cf;0;L;;;;;N;;;;;
+1343C;EGYPTIAN HIEROGLYPH BEGIN ENCLOSURE;Cf;0;L;;;;;N;;;;;
+1343D;EGYPTIAN HIEROGLYPH END ENCLOSURE;Cf;0;L;;;;;N;;;;;
+1343E;EGYPTIAN HIEROGLYPH BEGIN WALLED ENCLOSURE;Cf;0;L;;;;;N;;;;;
+1343F;EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE;Cf;0;L;;;;;N;;;;;
+13440;EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY;Mn;0;NSM;;;;;N;;;;;
+13441;EGYPTIAN HIEROGLYPH FULL BLANK;Lo;0;L;;;;;N;;;;;
+13442;EGYPTIAN HIEROGLYPH HALF BLANK;Lo;0;L;;;;;N;;;;;
+13443;EGYPTIAN HIEROGLYPH LOST SIGN;Lo;0;L;;;;;N;;;;;
+13444;EGYPTIAN HIEROGLYPH HALF LOST SIGN;Lo;0;L;;;;;N;;;;;
+13445;EGYPTIAN HIEROGLYPH TALL LOST SIGN;Lo;0;L;;;;;N;;;;;
+13446;EGYPTIAN HIEROGLYPH WIDE LOST SIGN;Lo;0;L;;;;;N;;;;;
+13447;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START;Mn;0;NSM;;;;;N;;;;;
+13448;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT BOTTOM START;Mn;0;NSM;;;;;N;;;;;
+13449;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT START;Mn;0;NSM;;;;;N;;;;;
+1344A;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP END;Mn;0;NSM;;;;;N;;;;;
+1344B;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP;Mn;0;NSM;;;;;N;;;;;
+1344C;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT BOTTOM START AND TOP END;Mn;0;NSM;;;;;N;;;;;
+1344D;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT START AND TOP;Mn;0;NSM;;;;;N;;;;;
+1344E;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT BOTTOM END;Mn;0;NSM;;;;;N;;;;;
+1344F;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START AND BOTTOM END;Mn;0;NSM;;;;;N;;;;;
+13450;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT BOTTOM;Mn;0;NSM;;;;;N;;;;;
+13451;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT START AND BOTTOM;Mn;0;NSM;;;;;N;;;;;
+13452;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT END;Mn;0;NSM;;;;;N;;;;;
+13453;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP AND END;Mn;0;NSM;;;;;N;;;;;
+13454;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT BOTTOM AND END;Mn;0;NSM;;;;;N;;;;;
+13455;EGYPTIAN HIEROGLYPH MODIFIER DAMAGED;Mn;0;NSM;;;;;N;;;;;
+13460;EGYPTIAN HIEROGLYPH-13460;Lo;0;L;;;;;N;;;;;
+13461;EGYPTIAN HIEROGLYPH-13461;Lo;0;L;;;;;N;;;;;
+13462;EGYPTIAN HIEROGLYPH-13462;Lo;0;L;;;;;N;;;;;
+13463;EGYPTIAN HIEROGLYPH-13463;Lo;0;L;;;;;N;;;;;
+13464;EGYPTIAN HIEROGLYPH-13464;Lo;0;L;;;;;N;;;;;
+13465;EGYPTIAN HIEROGLYPH-13465;Lo;0;L;;;;;N;;;;;
+13466;EGYPTIAN HIEROGLYPH-13466;Lo;0;L;;;;;N;;;;;
+13467;EGYPTIAN HIEROGLYPH-13467;Lo;0;L;;;;;N;;;;;
+13468;EGYPTIAN HIEROGLYPH-13468;Lo;0;L;;;;;N;;;;;
+13469;EGYPTIAN HIEROGLYPH-13469;Lo;0;L;;;;;N;;;;;
+1346A;EGYPTIAN HIEROGLYPH-1346A;Lo;0;L;;;;;N;;;;;
+1346B;EGYPTIAN HIEROGLYPH-1346B;Lo;0;L;;;;;N;;;;;
+1346C;EGYPTIAN HIEROGLYPH-1346C;Lo;0;L;;;;;N;;;;;
+1346D;EGYPTIAN HIEROGLYPH-1346D;Lo;0;L;;;;;N;;;;;
+1346E;EGYPTIAN HIEROGLYPH-1346E;Lo;0;L;;;;;N;;;;;
+1346F;EGYPTIAN HIEROGLYPH-1346F;Lo;0;L;;;;;N;;;;;
+13470;EGYPTIAN HIEROGLYPH-13470;Lo;0;L;;;;;N;;;;;
+13471;EGYPTIAN HIEROGLYPH-13471;Lo;0;L;;;;;N;;;;;
+13472;EGYPTIAN HIEROGLYPH-13472;Lo;0;L;;;;;N;;;;;
+13473;EGYPTIAN HIEROGLYPH-13473;Lo;0;L;;;;;N;;;;;
+13474;EGYPTIAN HIEROGLYPH-13474;Lo;0;L;;;;;N;;;;;
+13475;EGYPTIAN HIEROGLYPH-13475;Lo;0;L;;;;;N;;;;;
+13476;EGYPTIAN HIEROGLYPH-13476;Lo;0;L;;;;;N;;;;;
+13477;EGYPTIAN HIEROGLYPH-13477;Lo;0;L;;;;;N;;;;;
+13478;EGYPTIAN HIEROGLYPH-13478;Lo;0;L;;;;;N;;;;;
+13479;EGYPTIAN HIEROGLYPH-13479;Lo;0;L;;;;;N;;;;;
+1347A;EGYPTIAN HIEROGLYPH-1347A;Lo;0;L;;;;;N;;;;;
+1347B;EGYPTIAN HIEROGLYPH-1347B;Lo;0;L;;;;;N;;;;;
+1347C;EGYPTIAN HIEROGLYPH-1347C;Lo;0;L;;;;;N;;;;;
+1347D;EGYPTIAN HIEROGLYPH-1347D;Lo;0;L;;;;;N;;;;;
+1347E;EGYPTIAN HIEROGLYPH-1347E;Lo;0;L;;;;;N;;;;;
+1347F;EGYPTIAN HIEROGLYPH-1347F;Lo;0;L;;;;;N;;;;;
+13480;EGYPTIAN HIEROGLYPH-13480;Lo;0;L;;;;;N;;;;;
+13481;EGYPTIAN HIEROGLYPH-13481;Lo;0;L;;;;;N;;;;;
+13482;EGYPTIAN HIEROGLYPH-13482;Lo;0;L;;;;;N;;;;;
+13483;EGYPTIAN HIEROGLYPH-13483;Lo;0;L;;;;;N;;;;;
+13484;EGYPTIAN HIEROGLYPH-13484;Lo;0;L;;;;;N;;;;;
+13485;EGYPTIAN HIEROGLYPH-13485;Lo;0;L;;;;;N;;;;;
+13486;EGYPTIAN HIEROGLYPH-13486;Lo;0;L;;;;;N;;;;;
+13487;EGYPTIAN HIEROGLYPH-13487;Lo;0;L;;;;;N;;;;;
+13488;EGYPTIAN HIEROGLYPH-13488;Lo;0;L;;;;;N;;;;;
+13489;EGYPTIAN HIEROGLYPH-13489;Lo;0;L;;;;;N;;;;;
+1348A;EGYPTIAN HIEROGLYPH-1348A;Lo;0;L;;;;;N;;;;;
+1348B;EGYPTIAN HIEROGLYPH-1348B;Lo;0;L;;;;;N;;;;;
+1348C;EGYPTIAN HIEROGLYPH-1348C;Lo;0;L;;;;;N;;;;;
+1348D;EGYPTIAN HIEROGLYPH-1348D;Lo;0;L;;;;;N;;;;;
+1348E;EGYPTIAN HIEROGLYPH-1348E;Lo;0;L;;;;;N;;;;;
+1348F;EGYPTIAN HIEROGLYPH-1348F;Lo;0;L;;;;;N;;;;;
+13490;EGYPTIAN HIEROGLYPH-13490;Lo;0;L;;;;;N;;;;;
+13491;EGYPTIAN HIEROGLYPH-13491;Lo;0;L;;;;;N;;;;;
+13492;EGYPTIAN HIEROGLYPH-13492;Lo;0;L;;;;;N;;;;;
+13493;EGYPTIAN HIEROGLYPH-13493;Lo;0;L;;;;;N;;;;;
+13494;EGYPTIAN HIEROGLYPH-13494;Lo;0;L;;;;;N;;;;;
+13495;EGYPTIAN HIEROGLYPH-13495;Lo;0;L;;;;;N;;;;;
+13496;EGYPTIAN HIEROGLYPH-13496;Lo;0;L;;;;;N;;;;;
+13497;EGYPTIAN HIEROGLYPH-13497;Lo;0;L;;;;;N;;;;;
+13498;EGYPTIAN HIEROGLYPH-13498;Lo;0;L;;;;;N;;;;;
+13499;EGYPTIAN HIEROGLYPH-13499;Lo;0;L;;;;;N;;;;;
+1349A;EGYPTIAN HIEROGLYPH-1349A;Lo;0;L;;;;;N;;;;;
+1349B;EGYPTIAN HIEROGLYPH-1349B;Lo;0;L;;;;;N;;;;;
+1349C;EGYPTIAN HIEROGLYPH-1349C;Lo;0;L;;;;;N;;;;;
+1349D;EGYPTIAN HIEROGLYPH-1349D;Lo;0;L;;;;;N;;;;;
+1349E;EGYPTIAN HIEROGLYPH-1349E;Lo;0;L;;;;;N;;;;;
+1349F;EGYPTIAN HIEROGLYPH-1349F;Lo;0;L;;;;;N;;;;;
+134A0;EGYPTIAN HIEROGLYPH-134A0;Lo;0;L;;;;;N;;;;;
+134A1;EGYPTIAN HIEROGLYPH-134A1;Lo;0;L;;;;;N;;;;;
+134A2;EGYPTIAN HIEROGLYPH-134A2;Lo;0;L;;;;;N;;;;;
+134A3;EGYPTIAN HIEROGLYPH-134A3;Lo;0;L;;;;;N;;;;;
+134A4;EGYPTIAN HIEROGLYPH-134A4;Lo;0;L;;;;;N;;;;;
+134A5;EGYPTIAN HIEROGLYPH-134A5;Lo;0;L;;;;;N;;;;;
+134A6;EGYPTIAN HIEROGLYPH-134A6;Lo;0;L;;;;;N;;;;;
+134A7;EGYPTIAN HIEROGLYPH-134A7;Lo;0;L;;;;;N;;;;;
+134A8;EGYPTIAN HIEROGLYPH-134A8;Lo;0;L;;;;;N;;;;;
+134A9;EGYPTIAN HIEROGLYPH-134A9;Lo;0;L;;;;;N;;;;;
+134AA;EGYPTIAN HIEROGLYPH-134AA;Lo;0;L;;;;;N;;;;;
+134AB;EGYPTIAN HIEROGLYPH-134AB;Lo;0;L;;;;;N;;;;;
+134AC;EGYPTIAN HIEROGLYPH-134AC;Lo;0;L;;;;;N;;;;;
+134AD;EGYPTIAN HIEROGLYPH-134AD;Lo;0;L;;;;;N;;;;;
+134AE;EGYPTIAN HIEROGLYPH-134AE;Lo;0;L;;;;;N;;;;;
+134AF;EGYPTIAN HIEROGLYPH-134AF;Lo;0;L;;;;;N;;;;;
+134B0;EGYPTIAN HIEROGLYPH-134B0;Lo;0;L;;;;;N;;;;;
+134B1;EGYPTIAN HIEROGLYPH-134B1;Lo;0;L;;;;;N;;;;;
+134B2;EGYPTIAN HIEROGLYPH-134B2;Lo;0;L;;;;;N;;;;;
+134B3;EGYPTIAN HIEROGLYPH-134B3;Lo;0;L;;;;;N;;;;;
+134B4;EGYPTIAN HIEROGLYPH-134B4;Lo;0;L;;;;;N;;;;;
+134B5;EGYPTIAN HIEROGLYPH-134B5;Lo;0;L;;;;;N;;;;;
+134B6;EGYPTIAN HIEROGLYPH-134B6;Lo;0;L;;;;;N;;;;;
+134B7;EGYPTIAN HIEROGLYPH-134B7;Lo;0;L;;;;;N;;;;;
+134B8;EGYPTIAN HIEROGLYPH-134B8;Lo;0;L;;;;;N;;;;;
+134B9;EGYPTIAN HIEROGLYPH-134B9;Lo;0;L;;;;;N;;;;;
+134BA;EGYPTIAN HIEROGLYPH-134BA;Lo;0;L;;;;;N;;;;;
+134BB;EGYPTIAN HIEROGLYPH-134BB;Lo;0;L;;;;;N;;;;;
+134BC;EGYPTIAN HIEROGLYPH-134BC;Lo;0;L;;;;;N;;;;;
+134BD;EGYPTIAN HIEROGLYPH-134BD;Lo;0;L;;;;;N;;;;;
+134BE;EGYPTIAN HIEROGLYPH-134BE;Lo;0;L;;;;;N;;;;;
+134BF;EGYPTIAN HIEROGLYPH-134BF;Lo;0;L;;;;;N;;;;;
+134C0;EGYPTIAN HIEROGLYPH-134C0;Lo;0;L;;;;;N;;;;;
+134C1;EGYPTIAN HIEROGLYPH-134C1;Lo;0;L;;;;;N;;;;;
+134C2;EGYPTIAN HIEROGLYPH-134C2;Lo;0;L;;;;;N;;;;;
+134C3;EGYPTIAN HIEROGLYPH-134C3;Lo;0;L;;;;;N;;;;;
+134C4;EGYPTIAN HIEROGLYPH-134C4;Lo;0;L;;;;;N;;;;;
+134C5;EGYPTIAN HIEROGLYPH-134C5;Lo;0;L;;;;;N;;;;;
+134C6;EGYPTIAN HIEROGLYPH-134C6;Lo;0;L;;;;;N;;;;;
+134C7;EGYPTIAN HIEROGLYPH-134C7;Lo;0;L;;;;;N;;;;;
+134C8;EGYPTIAN HIEROGLYPH-134C8;Lo;0;L;;;;;N;;;;;
+134C9;EGYPTIAN HIEROGLYPH-134C9;Lo;0;L;;;;;N;;;;;
+134CA;EGYPTIAN HIEROGLYPH-134CA;Lo;0;L;;;;;N;;;;;
+134CB;EGYPTIAN HIEROGLYPH-134CB;Lo;0;L;;;;;N;;;;;
+134CC;EGYPTIAN HIEROGLYPH-134CC;Lo;0;L;;;;;N;;;;;
+134CD;EGYPTIAN HIEROGLYPH-134CD;Lo;0;L;;;;;N;;;;;
+134CE;EGYPTIAN HIEROGLYPH-134CE;Lo;0;L;;;;;N;;;;;
+134CF;EGYPTIAN HIEROGLYPH-134CF;Lo;0;L;;;;;N;;;;;
+134D0;EGYPTIAN HIEROGLYPH-134D0;Lo;0;L;;;;;N;;;;;
+134D1;EGYPTIAN HIEROGLYPH-134D1;Lo;0;L;;;;;N;;;;;
+134D2;EGYPTIAN HIEROGLYPH-134D2;Lo;0;L;;;;;N;;;;;
+134D3;EGYPTIAN HIEROGLYPH-134D3;Lo;0;L;;;;;N;;;;;
+134D4;EGYPTIAN HIEROGLYPH-134D4;Lo;0;L;;;;;N;;;;;
+134D5;EGYPTIAN HIEROGLYPH-134D5;Lo;0;L;;;;;N;;;;;
+134D6;EGYPTIAN HIEROGLYPH-134D6;Lo;0;L;;;;;N;;;;;
+134D7;EGYPTIAN HIEROGLYPH-134D7;Lo;0;L;;;;;N;;;;;
+134D8;EGYPTIAN HIEROGLYPH-134D8;Lo;0;L;;;;;N;;;;;
+134D9;EGYPTIAN HIEROGLYPH-134D9;Lo;0;L;;;;;N;;;;;
+134DA;EGYPTIAN HIEROGLYPH-134DA;Lo;0;L;;;;;N;;;;;
+134DB;EGYPTIAN HIEROGLYPH-134DB;Lo;0;L;;;;;N;;;;;
+134DC;EGYPTIAN HIEROGLYPH-134DC;Lo;0;L;;;;;N;;;;;
+134DD;EGYPTIAN HIEROGLYPH-134DD;Lo;0;L;;;;;N;;;;;
+134DE;EGYPTIAN HIEROGLYPH-134DE;Lo;0;L;;;;;N;;;;;
+134DF;EGYPTIAN HIEROGLYPH-134DF;Lo;0;L;;;;;N;;;;;
+134E0;EGYPTIAN HIEROGLYPH-134E0;Lo;0;L;;;;;N;;;;;
+134E1;EGYPTIAN HIEROGLYPH-134E1;Lo;0;L;;;;;N;;;;;
+134E2;EGYPTIAN HIEROGLYPH-134E2;Lo;0;L;;;;;N;;;;;
+134E3;EGYPTIAN HIEROGLYPH-134E3;Lo;0;L;;;;;N;;;;;
+134E4;EGYPTIAN HIEROGLYPH-134E4;Lo;0;L;;;;;N;;;;;
+134E5;EGYPTIAN HIEROGLYPH-134E5;Lo;0;L;;;;;N;;;;;
+134E6;EGYPTIAN HIEROGLYPH-134E6;Lo;0;L;;;;;N;;;;;
+134E7;EGYPTIAN HIEROGLYPH-134E7;Lo;0;L;;;;;N;;;;;
+134E8;EGYPTIAN HIEROGLYPH-134E8;Lo;0;L;;;;;N;;;;;
+134E9;EGYPTIAN HIEROGLYPH-134E9;Lo;0;L;;;;;N;;;;;
+134EA;EGYPTIAN HIEROGLYPH-134EA;Lo;0;L;;;;;N;;;;;
+134EB;EGYPTIAN HIEROGLYPH-134EB;Lo;0;L;;;;;N;;;;;
+134EC;EGYPTIAN HIEROGLYPH-134EC;Lo;0;L;;;;;N;;;;;
+134ED;EGYPTIAN HIEROGLYPH-134ED;Lo;0;L;;;;;N;;;;;
+134EE;EGYPTIAN HIEROGLYPH-134EE;Lo;0;L;;;;;N;;;;;
+134EF;EGYPTIAN HIEROGLYPH-134EF;Lo;0;L;;;;;N;;;;;
+134F0;EGYPTIAN HIEROGLYPH-134F0;Lo;0;L;;;;;N;;;;;
+134F1;EGYPTIAN HIEROGLYPH-134F1;Lo;0;L;;;;;N;;;;;
+134F2;EGYPTIAN HIEROGLYPH-134F2;Lo;0;L;;;;;N;;;;;
+134F3;EGYPTIAN HIEROGLYPH-134F3;Lo;0;L;;;;;N;;;;;
+134F4;EGYPTIAN HIEROGLYPH-134F4;Lo;0;L;;;;;N;;;;;
+134F5;EGYPTIAN HIEROGLYPH-134F5;Lo;0;L;;;;;N;;;;;
+134F6;EGYPTIAN HIEROGLYPH-134F6;Lo;0;L;;;;;N;;;;;
+134F7;EGYPTIAN HIEROGLYPH-134F7;Lo;0;L;;;;;N;;;;;
+134F8;EGYPTIAN HIEROGLYPH-134F8;Lo;0;L;;;;;N;;;;;
+134F9;EGYPTIAN HIEROGLYPH-134F9;Lo;0;L;;;;;N;;;;;
+134FA;EGYPTIAN HIEROGLYPH-134FA;Lo;0;L;;;;;N;;;;;
+134FB;EGYPTIAN HIEROGLYPH-134FB;Lo;0;L;;;;;N;;;;;
+134FC;EGYPTIAN HIEROGLYPH-134FC;Lo;0;L;;;;;N;;;;;
+134FD;EGYPTIAN HIEROGLYPH-134FD;Lo;0;L;;;;;N;;;;;
+134FE;EGYPTIAN HIEROGLYPH-134FE;Lo;0;L;;;;;N;;;;;
+134FF;EGYPTIAN HIEROGLYPH-134FF;Lo;0;L;;;;;N;;;;;
+13500;EGYPTIAN HIEROGLYPH-13500;Lo;0;L;;;;;N;;;;;
+13501;EGYPTIAN HIEROGLYPH-13501;Lo;0;L;;;;;N;;;;;
+13502;EGYPTIAN HIEROGLYPH-13502;Lo;0;L;;;;;N;;;;;
+13503;EGYPTIAN HIEROGLYPH-13503;Lo;0;L;;;;;N;;;;;
+13504;EGYPTIAN HIEROGLYPH-13504;Lo;0;L;;;;;N;;;;;
+13505;EGYPTIAN HIEROGLYPH-13505;Lo;0;L;;;;;N;;;;;
+13506;EGYPTIAN HIEROGLYPH-13506;Lo;0;L;;;;;N;;;;;
+13507;EGYPTIAN HIEROGLYPH-13507;Lo;0;L;;;;;N;;;;;
+13508;EGYPTIAN HIEROGLYPH-13508;Lo;0;L;;;;;N;;;;;
+13509;EGYPTIAN HIEROGLYPH-13509;Lo;0;L;;;;;N;;;;;
+1350A;EGYPTIAN HIEROGLYPH-1350A;Lo;0;L;;;;;N;;;;;
+1350B;EGYPTIAN HIEROGLYPH-1350B;Lo;0;L;;;;;N;;;;;
+1350C;EGYPTIAN HIEROGLYPH-1350C;Lo;0;L;;;;;N;;;;;
+1350D;EGYPTIAN HIEROGLYPH-1350D;Lo;0;L;;;;;N;;;;;
+1350E;EGYPTIAN HIEROGLYPH-1350E;Lo;0;L;;;;;N;;;;;
+1350F;EGYPTIAN HIEROGLYPH-1350F;Lo;0;L;;;;;N;;;;;
+13510;EGYPTIAN HIEROGLYPH-13510;Lo;0;L;;;;;N;;;;;
+13511;EGYPTIAN HIEROGLYPH-13511;Lo;0;L;;;;;N;;;;;
+13512;EGYPTIAN HIEROGLYPH-13512;Lo;0;L;;;;;N;;;;;
+13513;EGYPTIAN HIEROGLYPH-13513;Lo;0;L;;;;;N;;;;;
+13514;EGYPTIAN HIEROGLYPH-13514;Lo;0;L;;;;;N;;;;;
+13515;EGYPTIAN HIEROGLYPH-13515;Lo;0;L;;;;;N;;;;;
+13516;EGYPTIAN HIEROGLYPH-13516;Lo;0;L;;;;;N;;;;;
+13517;EGYPTIAN HIEROGLYPH-13517;Lo;0;L;;;;;N;;;;;
+13518;EGYPTIAN HIEROGLYPH-13518;Lo;0;L;;;;;N;;;;;
+13519;EGYPTIAN HIEROGLYPH-13519;Lo;0;L;;;;;N;;;;;
+1351A;EGYPTIAN HIEROGLYPH-1351A;Lo;0;L;;;;;N;;;;;
+1351B;EGYPTIAN HIEROGLYPH-1351B;Lo;0;L;;;;;N;;;;;
+1351C;EGYPTIAN HIEROGLYPH-1351C;Lo;0;L;;;;;N;;;;;
+1351D;EGYPTIAN HIEROGLYPH-1351D;Lo;0;L;;;;;N;;;;;
+1351E;EGYPTIAN HIEROGLYPH-1351E;Lo;0;L;;;;;N;;;;;
+1351F;EGYPTIAN HIEROGLYPH-1351F;Lo;0;L;;;;;N;;;;;
+13520;EGYPTIAN HIEROGLYPH-13520;Lo;0;L;;;;;N;;;;;
+13521;EGYPTIAN HIEROGLYPH-13521;Lo;0;L;;;;;N;;;;;
+13522;EGYPTIAN HIEROGLYPH-13522;Lo;0;L;;;;;N;;;;;
+13523;EGYPTIAN HIEROGLYPH-13523;Lo;0;L;;;;;N;;;;;
+13524;EGYPTIAN HIEROGLYPH-13524;Lo;0;L;;;;;N;;;;;
+13525;EGYPTIAN HIEROGLYPH-13525;Lo;0;L;;;;;N;;;;;
+13526;EGYPTIAN HIEROGLYPH-13526;Lo;0;L;;;;;N;;;;;
+13527;EGYPTIAN HIEROGLYPH-13527;Lo;0;L;;;;;N;;;;;
+13528;EGYPTIAN HIEROGLYPH-13528;Lo;0;L;;;;;N;;;;;
+13529;EGYPTIAN HIEROGLYPH-13529;Lo;0;L;;;;;N;;;;;
+1352A;EGYPTIAN HIEROGLYPH-1352A;Lo;0;L;;;;;N;;;;;
+1352B;EGYPTIAN HIEROGLYPH-1352B;Lo;0;L;;;;;N;;;;;
+1352C;EGYPTIAN HIEROGLYPH-1352C;Lo;0;L;;;;;N;;;;;
+1352D;EGYPTIAN HIEROGLYPH-1352D;Lo;0;L;;;;;N;;;;;
+1352E;EGYPTIAN HIEROGLYPH-1352E;Lo;0;L;;;;;N;;;;;
+1352F;EGYPTIAN HIEROGLYPH-1352F;Lo;0;L;;;;;N;;;;;
+13530;EGYPTIAN HIEROGLYPH-13530;Lo;0;L;;;;;N;;;;;
+13531;EGYPTIAN HIEROGLYPH-13531;Lo;0;L;;;;;N;;;;;
+13532;EGYPTIAN HIEROGLYPH-13532;Lo;0;L;;;;;N;;;;;
+13533;EGYPTIAN HIEROGLYPH-13533;Lo;0;L;;;;;N;;;;;
+13534;EGYPTIAN HIEROGLYPH-13534;Lo;0;L;;;;;N;;;;;
+13535;EGYPTIAN HIEROGLYPH-13535;Lo;0;L;;;;;N;;;;;
+13536;EGYPTIAN HIEROGLYPH-13536;Lo;0;L;;;;;N;;;;;
+13537;EGYPTIAN HIEROGLYPH-13537;Lo;0;L;;;;;N;;;;;
+13538;EGYPTIAN HIEROGLYPH-13538;Lo;0;L;;;;;N;;;;;
+13539;EGYPTIAN HIEROGLYPH-13539;Lo;0;L;;;;;N;;;;;
+1353A;EGYPTIAN HIEROGLYPH-1353A;Lo;0;L;;;;;N;;;;;
+1353B;EGYPTIAN HIEROGLYPH-1353B;Lo;0;L;;;;;N;;;;;
+1353C;EGYPTIAN HIEROGLYPH-1353C;Lo;0;L;;;;;N;;;;;
+1353D;EGYPTIAN HIEROGLYPH-1353D;Lo;0;L;;;;;N;;;;;
+1353E;EGYPTIAN HIEROGLYPH-1353E;Lo;0;L;;;;;N;;;;;
+1353F;EGYPTIAN HIEROGLYPH-1353F;Lo;0;L;;;;;N;;;;;
+13540;EGYPTIAN HIEROGLYPH-13540;Lo;0;L;;;;;N;;;;;
+13541;EGYPTIAN HIEROGLYPH-13541;Lo;0;L;;;;;N;;;;;
+13542;EGYPTIAN HIEROGLYPH-13542;Lo;0;L;;;;;N;;;;;
+13543;EGYPTIAN HIEROGLYPH-13543;Lo;0;L;;;;;N;;;;;
+13544;EGYPTIAN HIEROGLYPH-13544;Lo;0;L;;;;;N;;;;;
+13545;EGYPTIAN HIEROGLYPH-13545;Lo;0;L;;;;;N;;;;;
+13546;EGYPTIAN HIEROGLYPH-13546;Lo;0;L;;;;;N;;;;;
+13547;EGYPTIAN HIEROGLYPH-13547;Lo;0;L;;;;;N;;;;;
+13548;EGYPTIAN HIEROGLYPH-13548;Lo;0;L;;;;;N;;;;;
+13549;EGYPTIAN HIEROGLYPH-13549;Lo;0;L;;;;;N;;;;;
+1354A;EGYPTIAN HIEROGLYPH-1354A;Lo;0;L;;;;;N;;;;;
+1354B;EGYPTIAN HIEROGLYPH-1354B;Lo;0;L;;;;;N;;;;;
+1354C;EGYPTIAN HIEROGLYPH-1354C;Lo;0;L;;;;;N;;;;;
+1354D;EGYPTIAN HIEROGLYPH-1354D;Lo;0;L;;;;;N;;;;;
+1354E;EGYPTIAN HIEROGLYPH-1354E;Lo;0;L;;;;;N;;;;;
+1354F;EGYPTIAN HIEROGLYPH-1354F;Lo;0;L;;;;;N;;;;;
+13550;EGYPTIAN HIEROGLYPH-13550;Lo;0;L;;;;;N;;;;;
+13551;EGYPTIAN HIEROGLYPH-13551;Lo;0;L;;;;;N;;;;;
+13552;EGYPTIAN HIEROGLYPH-13552;Lo;0;L;;;;;N;;;;;
+13553;EGYPTIAN HIEROGLYPH-13553;Lo;0;L;;;;;N;;;;;
+13554;EGYPTIAN HIEROGLYPH-13554;Lo;0;L;;;;;N;;;;;
+13555;EGYPTIAN HIEROGLYPH-13555;Lo;0;L;;;;;N;;;;;
+13556;EGYPTIAN HIEROGLYPH-13556;Lo;0;L;;;;;N;;;;;
+13557;EGYPTIAN HIEROGLYPH-13557;Lo;0;L;;;;;N;;;;;
+13558;EGYPTIAN HIEROGLYPH-13558;Lo;0;L;;;;;N;;;;;
+13559;EGYPTIAN HIEROGLYPH-13559;Lo;0;L;;;;;N;;;;;
+1355A;EGYPTIAN HIEROGLYPH-1355A;Lo;0;L;;;;;N;;;;;
+1355B;EGYPTIAN HIEROGLYPH-1355B;Lo;0;L;;;;;N;;;;;
+1355C;EGYPTIAN HIEROGLYPH-1355C;Lo;0;L;;;;;N;;;;;
+1355D;EGYPTIAN HIEROGLYPH-1355D;Lo;0;L;;;;;N;;;;;
+1355E;EGYPTIAN HIEROGLYPH-1355E;Lo;0;L;;;;;N;;;;;
+1355F;EGYPTIAN HIEROGLYPH-1355F;Lo;0;L;;;;;N;;;;;
+13560;EGYPTIAN HIEROGLYPH-13560;Lo;0;L;;;;;N;;;;;
+13561;EGYPTIAN HIEROGLYPH-13561;Lo;0;L;;;;;N;;;;;
+13562;EGYPTIAN HIEROGLYPH-13562;Lo;0;L;;;;;N;;;;;
+13563;EGYPTIAN HIEROGLYPH-13563;Lo;0;L;;;;;N;;;;;
+13564;EGYPTIAN HIEROGLYPH-13564;Lo;0;L;;;;;N;;;;;
+13565;EGYPTIAN HIEROGLYPH-13565;Lo;0;L;;;;;N;;;;;
+13566;EGYPTIAN HIEROGLYPH-13566;Lo;0;L;;;;;N;;;;;
+13567;EGYPTIAN HIEROGLYPH-13567;Lo;0;L;;;;;N;;;;;
+13568;EGYPTIAN HIEROGLYPH-13568;Lo;0;L;;;;;N;;;;;
+13569;EGYPTIAN HIEROGLYPH-13569;Lo;0;L;;;;;N;;;;;
+1356A;EGYPTIAN HIEROGLYPH-1356A;Lo;0;L;;;;;N;;;;;
+1356B;EGYPTIAN HIEROGLYPH-1356B;Lo;0;L;;;;;N;;;;;
+1356C;EGYPTIAN HIEROGLYPH-1356C;Lo;0;L;;;;;N;;;;;
+1356D;EGYPTIAN HIEROGLYPH-1356D;Lo;0;L;;;;;N;;;;;
+1356E;EGYPTIAN HIEROGLYPH-1356E;Lo;0;L;;;;;N;;;;;
+1356F;EGYPTIAN HIEROGLYPH-1356F;Lo;0;L;;;;;N;;;;;
+13570;EGYPTIAN HIEROGLYPH-13570;Lo;0;L;;;;;N;;;;;
+13571;EGYPTIAN HIEROGLYPH-13571;Lo;0;L;;;;;N;;;;;
+13572;EGYPTIAN HIEROGLYPH-13572;Lo;0;L;;;;;N;;;;;
+13573;EGYPTIAN HIEROGLYPH-13573;Lo;0;L;;;;;N;;;;;
+13574;EGYPTIAN HIEROGLYPH-13574;Lo;0;L;;;;;N;;;;;
+13575;EGYPTIAN HIEROGLYPH-13575;Lo;0;L;;;;;N;;;;;
+13576;EGYPTIAN HIEROGLYPH-13576;Lo;0;L;;;;;N;;;;;
+13577;EGYPTIAN HIEROGLYPH-13577;Lo;0;L;;;;;N;;;;;
+13578;EGYPTIAN HIEROGLYPH-13578;Lo;0;L;;;;;N;;;;;
+13579;EGYPTIAN HIEROGLYPH-13579;Lo;0;L;;;;;N;;;;;
+1357A;EGYPTIAN HIEROGLYPH-1357A;Lo;0;L;;;;;N;;;;;
+1357B;EGYPTIAN HIEROGLYPH-1357B;Lo;0;L;;;;;N;;;;;
+1357C;EGYPTIAN HIEROGLYPH-1357C;Lo;0;L;;;;;N;;;;;
+1357D;EGYPTIAN HIEROGLYPH-1357D;Lo;0;L;;;;;N;;;;;
+1357E;EGYPTIAN HIEROGLYPH-1357E;Lo;0;L;;;;;N;;;;;
+1357F;EGYPTIAN HIEROGLYPH-1357F;Lo;0;L;;;;;N;;;;;
+13580;EGYPTIAN HIEROGLYPH-13580;Lo;0;L;;;;;N;;;;;
+13581;EGYPTIAN HIEROGLYPH-13581;Lo;0;L;;;;;N;;;;;
+13582;EGYPTIAN HIEROGLYPH-13582;Lo;0;L;;;;;N;;;;;
+13583;EGYPTIAN HIEROGLYPH-13583;Lo;0;L;;;;;N;;;;;
+13584;EGYPTIAN HIEROGLYPH-13584;Lo;0;L;;;;;N;;;;;
+13585;EGYPTIAN HIEROGLYPH-13585;Lo;0;L;;;;;N;;;;;
+13586;EGYPTIAN HIEROGLYPH-13586;Lo;0;L;;;;;N;;;;;
+13587;EGYPTIAN HIEROGLYPH-13587;Lo;0;L;;;;;N;;;;;
+13588;EGYPTIAN HIEROGLYPH-13588;Lo;0;L;;;;;N;;;;;
+13589;EGYPTIAN HIEROGLYPH-13589;Lo;0;L;;;;;N;;;;;
+1358A;EGYPTIAN HIEROGLYPH-1358A;Lo;0;L;;;;;N;;;;;
+1358B;EGYPTIAN HIEROGLYPH-1358B;Lo;0;L;;;;;N;;;;;
+1358C;EGYPTIAN HIEROGLYPH-1358C;Lo;0;L;;;;;N;;;;;
+1358D;EGYPTIAN HIEROGLYPH-1358D;Lo;0;L;;;;;N;;;;;
+1358E;EGYPTIAN HIEROGLYPH-1358E;Lo;0;L;;;;;N;;;;;
+1358F;EGYPTIAN HIEROGLYPH-1358F;Lo;0;L;;;;;N;;;;;
+13590;EGYPTIAN HIEROGLYPH-13590;Lo;0;L;;;;;N;;;;;
+13591;EGYPTIAN HIEROGLYPH-13591;Lo;0;L;;;;;N;;;;;
+13592;EGYPTIAN HIEROGLYPH-13592;Lo;0;L;;;;;N;;;;;
+13593;EGYPTIAN HIEROGLYPH-13593;Lo;0;L;;;;;N;;;;;
+13594;EGYPTIAN HIEROGLYPH-13594;Lo;0;L;;;;;N;;;;;
+13595;EGYPTIAN HIEROGLYPH-13595;Lo;0;L;;;;;N;;;;;
+13596;EGYPTIAN HIEROGLYPH-13596;Lo;0;L;;;;;N;;;;;
+13597;EGYPTIAN HIEROGLYPH-13597;Lo;0;L;;;;;N;;;;;
+13598;EGYPTIAN HIEROGLYPH-13598;Lo;0;L;;;;;N;;;;;
+13599;EGYPTIAN HIEROGLYPH-13599;Lo;0;L;;;;;N;;;;;
+1359A;EGYPTIAN HIEROGLYPH-1359A;Lo;0;L;;;;;N;;;;;
+1359B;EGYPTIAN HIEROGLYPH-1359B;Lo;0;L;;;;;N;;;;;
+1359C;EGYPTIAN HIEROGLYPH-1359C;Lo;0;L;;;;;N;;;;;
+1359D;EGYPTIAN HIEROGLYPH-1359D;Lo;0;L;;;;;N;;;;;
+1359E;EGYPTIAN HIEROGLYPH-1359E;Lo;0;L;;;;;N;;;;;
+1359F;EGYPTIAN HIEROGLYPH-1359F;Lo;0;L;;;;;N;;;;;
+135A0;EGYPTIAN HIEROGLYPH-135A0;Lo;0;L;;;;;N;;;;;
+135A1;EGYPTIAN HIEROGLYPH-135A1;Lo;0;L;;;;;N;;;;;
+135A2;EGYPTIAN HIEROGLYPH-135A2;Lo;0;L;;;;;N;;;;;
+135A3;EGYPTIAN HIEROGLYPH-135A3;Lo;0;L;;;;;N;;;;;
+135A4;EGYPTIAN HIEROGLYPH-135A4;Lo;0;L;;;;;N;;;;;
+135A5;EGYPTIAN HIEROGLYPH-135A5;Lo;0;L;;;;;N;;;;;
+135A6;EGYPTIAN HIEROGLYPH-135A6;Lo;0;L;;;;;N;;;;;
+135A7;EGYPTIAN HIEROGLYPH-135A7;Lo;0;L;;;;;N;;;;;
+135A8;EGYPTIAN HIEROGLYPH-135A8;Lo;0;L;;;;;N;;;;;
+135A9;EGYPTIAN HIEROGLYPH-135A9;Lo;0;L;;;;;N;;;;;
+135AA;EGYPTIAN HIEROGLYPH-135AA;Lo;0;L;;;;;N;;;;;
+135AB;EGYPTIAN HIEROGLYPH-135AB;Lo;0;L;;;;;N;;;;;
+135AC;EGYPTIAN HIEROGLYPH-135AC;Lo;0;L;;;;;N;;;;;
+135AD;EGYPTIAN HIEROGLYPH-135AD;Lo;0;L;;;;;N;;;;;
+135AE;EGYPTIAN HIEROGLYPH-135AE;Lo;0;L;;;;;N;;;;;
+135AF;EGYPTIAN HIEROGLYPH-135AF;Lo;0;L;;;;;N;;;;;
+135B0;EGYPTIAN HIEROGLYPH-135B0;Lo;0;L;;;;;N;;;;;
+135B1;EGYPTIAN HIEROGLYPH-135B1;Lo;0;L;;;;;N;;;;;
+135B2;EGYPTIAN HIEROGLYPH-135B2;Lo;0;L;;;;;N;;;;;
+135B3;EGYPTIAN HIEROGLYPH-135B3;Lo;0;L;;;;;N;;;;;
+135B4;EGYPTIAN HIEROGLYPH-135B4;Lo;0;L;;;;;N;;;;;
+135B5;EGYPTIAN HIEROGLYPH-135B5;Lo;0;L;;;;;N;;;;;
+135B6;EGYPTIAN HIEROGLYPH-135B6;Lo;0;L;;;;;N;;;;;
+135B7;EGYPTIAN HIEROGLYPH-135B7;Lo;0;L;;;;;N;;;;;
+135B8;EGYPTIAN HIEROGLYPH-135B8;Lo;0;L;;;;;N;;;;;
+135B9;EGYPTIAN HIEROGLYPH-135B9;Lo;0;L;;;;;N;;;;;
+135BA;EGYPTIAN HIEROGLYPH-135BA;Lo;0;L;;;;;N;;;;;
+135BB;EGYPTIAN HIEROGLYPH-135BB;Lo;0;L;;;;;N;;;;;
+135BC;EGYPTIAN HIEROGLYPH-135BC;Lo;0;L;;;;;N;;;;;
+135BD;EGYPTIAN HIEROGLYPH-135BD;Lo;0;L;;;;;N;;;;;
+135BE;EGYPTIAN HIEROGLYPH-135BE;Lo;0;L;;;;;N;;;;;
+135BF;EGYPTIAN HIEROGLYPH-135BF;Lo;0;L;;;;;N;;;;;
+135C0;EGYPTIAN HIEROGLYPH-135C0;Lo;0;L;;;;;N;;;;;
+135C1;EGYPTIAN HIEROGLYPH-135C1;Lo;0;L;;;;;N;;;;;
+135C2;EGYPTIAN HIEROGLYPH-135C2;Lo;0;L;;;;;N;;;;;
+135C3;EGYPTIAN HIEROGLYPH-135C3;Lo;0;L;;;;;N;;;;;
+135C4;EGYPTIAN HIEROGLYPH-135C4;Lo;0;L;;;;;N;;;;;
+135C5;EGYPTIAN HIEROGLYPH-135C5;Lo;0;L;;;;;N;;;;;
+135C6;EGYPTIAN HIEROGLYPH-135C6;Lo;0;L;;;;;N;;;;;
+135C7;EGYPTIAN HIEROGLYPH-135C7;Lo;0;L;;;;;N;;;;;
+135C8;EGYPTIAN HIEROGLYPH-135C8;Lo;0;L;;;;;N;;;;;
+135C9;EGYPTIAN HIEROGLYPH-135C9;Lo;0;L;;;;;N;;;;;
+135CA;EGYPTIAN HIEROGLYPH-135CA;Lo;0;L;;;;;N;;;;;
+135CB;EGYPTIAN HIEROGLYPH-135CB;Lo;0;L;;;;;N;;;;;
+135CC;EGYPTIAN HIEROGLYPH-135CC;Lo;0;L;;;;;N;;;;;
+135CD;EGYPTIAN HIEROGLYPH-135CD;Lo;0;L;;;;;N;;;;;
+135CE;EGYPTIAN HIEROGLYPH-135CE;Lo;0;L;;;;;N;;;;;
+135CF;EGYPTIAN HIEROGLYPH-135CF;Lo;0;L;;;;;N;;;;;
+135D0;EGYPTIAN HIEROGLYPH-135D0;Lo;0;L;;;;;N;;;;;
+135D1;EGYPTIAN HIEROGLYPH-135D1;Lo;0;L;;;;;N;;;;;
+135D2;EGYPTIAN HIEROGLYPH-135D2;Lo;0;L;;;;;N;;;;;
+135D3;EGYPTIAN HIEROGLYPH-135D3;Lo;0;L;;;;;N;;;;;
+135D4;EGYPTIAN HIEROGLYPH-135D4;Lo;0;L;;;;;N;;;;;
+135D5;EGYPTIAN HIEROGLYPH-135D5;Lo;0;L;;;;;N;;;;;
+135D6;EGYPTIAN HIEROGLYPH-135D6;Lo;0;L;;;;;N;;;;;
+135D7;EGYPTIAN HIEROGLYPH-135D7;Lo;0;L;;;;;N;;;;;
+135D8;EGYPTIAN HIEROGLYPH-135D8;Lo;0;L;;;;;N;;;;;
+135D9;EGYPTIAN HIEROGLYPH-135D9;Lo;0;L;;;;;N;;;;;
+135DA;EGYPTIAN HIEROGLYPH-135DA;Lo;0;L;;;;;N;;;;;
+135DB;EGYPTIAN HIEROGLYPH-135DB;Lo;0;L;;;;;N;;;;;
+135DC;EGYPTIAN HIEROGLYPH-135DC;Lo;0;L;;;;;N;;;;;
+135DD;EGYPTIAN HIEROGLYPH-135DD;Lo;0;L;;;;;N;;;;;
+135DE;EGYPTIAN HIEROGLYPH-135DE;Lo;0;L;;;;;N;;;;;
+135DF;EGYPTIAN HIEROGLYPH-135DF;Lo;0;L;;;;;N;;;;;
+135E0;EGYPTIAN HIEROGLYPH-135E0;Lo;0;L;;;;;N;;;;;
+135E1;EGYPTIAN HIEROGLYPH-135E1;Lo;0;L;;;;;N;;;;;
+135E2;EGYPTIAN HIEROGLYPH-135E2;Lo;0;L;;;;;N;;;;;
+135E3;EGYPTIAN HIEROGLYPH-135E3;Lo;0;L;;;;;N;;;;;
+135E4;EGYPTIAN HIEROGLYPH-135E4;Lo;0;L;;;;;N;;;;;
+135E5;EGYPTIAN HIEROGLYPH-135E5;Lo;0;L;;;;;N;;;;;
+135E6;EGYPTIAN HIEROGLYPH-135E6;Lo;0;L;;;;;N;;;;;
+135E7;EGYPTIAN HIEROGLYPH-135E7;Lo;0;L;;;;;N;;;;;
+135E8;EGYPTIAN HIEROGLYPH-135E8;Lo;0;L;;;;;N;;;;;
+135E9;EGYPTIAN HIEROGLYPH-135E9;Lo;0;L;;;;;N;;;;;
+135EA;EGYPTIAN HIEROGLYPH-135EA;Lo;0;L;;;;;N;;;;;
+135EB;EGYPTIAN HIEROGLYPH-135EB;Lo;0;L;;;;;N;;;;;
+135EC;EGYPTIAN HIEROGLYPH-135EC;Lo;0;L;;;;;N;;;;;
+135ED;EGYPTIAN HIEROGLYPH-135ED;Lo;0;L;;;;;N;;;;;
+135EE;EGYPTIAN HIEROGLYPH-135EE;Lo;0;L;;;;;N;;;;;
+135EF;EGYPTIAN HIEROGLYPH-135EF;Lo;0;L;;;;;N;;;;;
+135F0;EGYPTIAN HIEROGLYPH-135F0;Lo;0;L;;;;;N;;;;;
+135F1;EGYPTIAN HIEROGLYPH-135F1;Lo;0;L;;;;;N;;;;;
+135F2;EGYPTIAN HIEROGLYPH-135F2;Lo;0;L;;;;;N;;;;;
+135F3;EGYPTIAN HIEROGLYPH-135F3;Lo;0;L;;;;;N;;;;;
+135F4;EGYPTIAN HIEROGLYPH-135F4;Lo;0;L;;;;;N;;;;;
+135F5;EGYPTIAN HIEROGLYPH-135F5;Lo;0;L;;;;;N;;;;;
+135F6;EGYPTIAN HIEROGLYPH-135F6;Lo;0;L;;;;;N;;;;;
+135F7;EGYPTIAN HIEROGLYPH-135F7;Lo;0;L;;;;;N;;;;;
+135F8;EGYPTIAN HIEROGLYPH-135F8;Lo;0;L;;;;;N;;;;;
+135F9;EGYPTIAN HIEROGLYPH-135F9;Lo;0;L;;;;;N;;;;;
+135FA;EGYPTIAN HIEROGLYPH-135FA;Lo;0;L;;;;;N;;;;;
+135FB;EGYPTIAN HIEROGLYPH-135FB;Lo;0;L;;;;;N;;;;;
+135FC;EGYPTIAN HIEROGLYPH-135FC;Lo;0;L;;;;;N;;;;;
+135FD;EGYPTIAN HIEROGLYPH-135FD;Lo;0;L;;;;;N;;;;;
+135FE;EGYPTIAN HIEROGLYPH-135FE;Lo;0;L;;;;;N;;;;;
+135FF;EGYPTIAN HIEROGLYPH-135FF;Lo;0;L;;;;;N;;;;;
+13600;EGYPTIAN HIEROGLYPH-13600;Lo;0;L;;;;;N;;;;;
+13601;EGYPTIAN HIEROGLYPH-13601;Lo;0;L;;;;;N;;;;;
+13602;EGYPTIAN HIEROGLYPH-13602;Lo;0;L;;;;;N;;;;;
+13603;EGYPTIAN HIEROGLYPH-13603;Lo;0;L;;;;;N;;;;;
+13604;EGYPTIAN HIEROGLYPH-13604;Lo;0;L;;;;;N;;;;;
+13605;EGYPTIAN HIEROGLYPH-13605;Lo;0;L;;;;;N;;;;;
+13606;EGYPTIAN HIEROGLYPH-13606;Lo;0;L;;;;;N;;;;;
+13607;EGYPTIAN HIEROGLYPH-13607;Lo;0;L;;;;;N;;;;;
+13608;EGYPTIAN HIEROGLYPH-13608;Lo;0;L;;;;;N;;;;;
+13609;EGYPTIAN HIEROGLYPH-13609;Lo;0;L;;;;;N;;;;;
+1360A;EGYPTIAN HIEROGLYPH-1360A;Lo;0;L;;;;;N;;;;;
+1360B;EGYPTIAN HIEROGLYPH-1360B;Lo;0;L;;;;;N;;;;;
+1360C;EGYPTIAN HIEROGLYPH-1360C;Lo;0;L;;;;;N;;;;;
+1360D;EGYPTIAN HIEROGLYPH-1360D;Lo;0;L;;;;;N;;;;;
+1360E;EGYPTIAN HIEROGLYPH-1360E;Lo;0;L;;;;;N;;;;;
+1360F;EGYPTIAN HIEROGLYPH-1360F;Lo;0;L;;;;;N;;;;;
+13610;EGYPTIAN HIEROGLYPH-13610;Lo;0;L;;;;;N;;;;;
+13611;EGYPTIAN HIEROGLYPH-13611;Lo;0;L;;;;;N;;;;;
+13612;EGYPTIAN HIEROGLYPH-13612;Lo;0;L;;;;;N;;;;;
+13613;EGYPTIAN HIEROGLYPH-13613;Lo;0;L;;;;;N;;;;;
+13614;EGYPTIAN HIEROGLYPH-13614;Lo;0;L;;;;;N;;;;;
+13615;EGYPTIAN HIEROGLYPH-13615;Lo;0;L;;;;;N;;;;;
+13616;EGYPTIAN HIEROGLYPH-13616;Lo;0;L;;;;;N;;;;;
+13617;EGYPTIAN HIEROGLYPH-13617;Lo;0;L;;;;;N;;;;;
+13618;EGYPTIAN HIEROGLYPH-13618;Lo;0;L;;;;;N;;;;;
+13619;EGYPTIAN HIEROGLYPH-13619;Lo;0;L;;;;;N;;;;;
+1361A;EGYPTIAN HIEROGLYPH-1361A;Lo;0;L;;;;;N;;;;;
+1361B;EGYPTIAN HIEROGLYPH-1361B;Lo;0;L;;;;;N;;;;;
+1361C;EGYPTIAN HIEROGLYPH-1361C;Lo;0;L;;;;;N;;;;;
+1361D;EGYPTIAN HIEROGLYPH-1361D;Lo;0;L;;;;;N;;;;;
+1361E;EGYPTIAN HIEROGLYPH-1361E;Lo;0;L;;;;;N;;;;;
+1361F;EGYPTIAN HIEROGLYPH-1361F;Lo;0;L;;;;;N;;;;;
+13620;EGYPTIAN HIEROGLYPH-13620;Lo;0;L;;;;;N;;;;;
+13621;EGYPTIAN HIEROGLYPH-13621;Lo;0;L;;;;;N;;;;;
+13622;EGYPTIAN HIEROGLYPH-13622;Lo;0;L;;;;;N;;;;;
+13623;EGYPTIAN HIEROGLYPH-13623;Lo;0;L;;;;;N;;;;;
+13624;EGYPTIAN HIEROGLYPH-13624;Lo;0;L;;;;;N;;;;;
+13625;EGYPTIAN HIEROGLYPH-13625;Lo;0;L;;;;;N;;;;;
+13626;EGYPTIAN HIEROGLYPH-13626;Lo;0;L;;;;;N;;;;;
+13627;EGYPTIAN HIEROGLYPH-13627;Lo;0;L;;;;;N;;;;;
+13628;EGYPTIAN HIEROGLYPH-13628;Lo;0;L;;;;;N;;;;;
+13629;EGYPTIAN HIEROGLYPH-13629;Lo;0;L;;;;;N;;;;;
+1362A;EGYPTIAN HIEROGLYPH-1362A;Lo;0;L;;;;;N;;;;;
+1362B;EGYPTIAN HIEROGLYPH-1362B;Lo;0;L;;;;;N;;;;;
+1362C;EGYPTIAN HIEROGLYPH-1362C;Lo;0;L;;;;;N;;;;;
+1362D;EGYPTIAN HIEROGLYPH-1362D;Lo;0;L;;;;;N;;;;;
+1362E;EGYPTIAN HIEROGLYPH-1362E;Lo;0;L;;;;;N;;;;;
+1362F;EGYPTIAN HIEROGLYPH-1362F;Lo;0;L;;;;;N;;;;;
+13630;EGYPTIAN HIEROGLYPH-13630;Lo;0;L;;;;;N;;;;;
+13631;EGYPTIAN HIEROGLYPH-13631;Lo;0;L;;;;;N;;;;;
+13632;EGYPTIAN HIEROGLYPH-13632;Lo;0;L;;;;;N;;;;;
+13633;EGYPTIAN HIEROGLYPH-13633;Lo;0;L;;;;;N;;;;;
+13634;EGYPTIAN HIEROGLYPH-13634;Lo;0;L;;;;;N;;;;;
+13635;EGYPTIAN HIEROGLYPH-13635;Lo;0;L;;;;;N;;;;;
+13636;EGYPTIAN HIEROGLYPH-13636;Lo;0;L;;;;;N;;;;;
+13637;EGYPTIAN HIEROGLYPH-13637;Lo;0;L;;;;;N;;;;;
+13638;EGYPTIAN HIEROGLYPH-13638;Lo;0;L;;;;;N;;;;;
+13639;EGYPTIAN HIEROGLYPH-13639;Lo;0;L;;;;;N;;;;;
+1363A;EGYPTIAN HIEROGLYPH-1363A;Lo;0;L;;;;;N;;;;;
+1363B;EGYPTIAN HIEROGLYPH-1363B;Lo;0;L;;;;;N;;;;;
+1363C;EGYPTIAN HIEROGLYPH-1363C;Lo;0;L;;;;;N;;;;;
+1363D;EGYPTIAN HIEROGLYPH-1363D;Lo;0;L;;;;;N;;;;;
+1363E;EGYPTIAN HIEROGLYPH-1363E;Lo;0;L;;;;;N;;;;;
+1363F;EGYPTIAN HIEROGLYPH-1363F;Lo;0;L;;;;;N;;;;;
+13640;EGYPTIAN HIEROGLYPH-13640;Lo;0;L;;;;;N;;;;;
+13641;EGYPTIAN HIEROGLYPH-13641;Lo;0;L;;;;;N;;;;;
+13642;EGYPTIAN HIEROGLYPH-13642;Lo;0;L;;;;;N;;;;;
+13643;EGYPTIAN HIEROGLYPH-13643;Lo;0;L;;;;;N;;;;;
+13644;EGYPTIAN HIEROGLYPH-13644;Lo;0;L;;;;;N;;;;;
+13645;EGYPTIAN HIEROGLYPH-13645;Lo;0;L;;;;;N;;;;;
+13646;EGYPTIAN HIEROGLYPH-13646;Lo;0;L;;;;;N;;;;;
+13647;EGYPTIAN HIEROGLYPH-13647;Lo;0;L;;;;;N;;;;;
+13648;EGYPTIAN HIEROGLYPH-13648;Lo;0;L;;;;;N;;;;;
+13649;EGYPTIAN HIEROGLYPH-13649;Lo;0;L;;;;;N;;;;;
+1364A;EGYPTIAN HIEROGLYPH-1364A;Lo;0;L;;;;;N;;;;;
+1364B;EGYPTIAN HIEROGLYPH-1364B;Lo;0;L;;;;;N;;;;;
+1364C;EGYPTIAN HIEROGLYPH-1364C;Lo;0;L;;;;;N;;;;;
+1364D;EGYPTIAN HIEROGLYPH-1364D;Lo;0;L;;;;;N;;;;;
+1364E;EGYPTIAN HIEROGLYPH-1364E;Lo;0;L;;;;;N;;;;;
+1364F;EGYPTIAN HIEROGLYPH-1364F;Lo;0;L;;;;;N;;;;;
+13650;EGYPTIAN HIEROGLYPH-13650;Lo;0;L;;;;;N;;;;;
+13651;EGYPTIAN HIEROGLYPH-13651;Lo;0;L;;;;;N;;;;;
+13652;EGYPTIAN HIEROGLYPH-13652;Lo;0;L;;;;;N;;;;;
+13653;EGYPTIAN HIEROGLYPH-13653;Lo;0;L;;;;;N;;;;;
+13654;EGYPTIAN HIEROGLYPH-13654;Lo;0;L;;;;;N;;;;;
+13655;EGYPTIAN HIEROGLYPH-13655;Lo;0;L;;;;;N;;;;;
+13656;EGYPTIAN HIEROGLYPH-13656;Lo;0;L;;;;;N;;;;;
+13657;EGYPTIAN HIEROGLYPH-13657;Lo;0;L;;;;;N;;;;;
+13658;EGYPTIAN HIEROGLYPH-13658;Lo;0;L;;;;;N;;;;;
+13659;EGYPTIAN HIEROGLYPH-13659;Lo;0;L;;;;;N;;;;;
+1365A;EGYPTIAN HIEROGLYPH-1365A;Lo;0;L;;;;;N;;;;;
+1365B;EGYPTIAN HIEROGLYPH-1365B;Lo;0;L;;;;;N;;;;;
+1365C;EGYPTIAN HIEROGLYPH-1365C;Lo;0;L;;;;;N;;;;;
+1365D;EGYPTIAN HIEROGLYPH-1365D;Lo;0;L;;;;;N;;;;;
+1365E;EGYPTIAN HIEROGLYPH-1365E;Lo;0;L;;;;;N;;;;;
+1365F;EGYPTIAN HIEROGLYPH-1365F;Lo;0;L;;;;;N;;;;;
+13660;EGYPTIAN HIEROGLYPH-13660;Lo;0;L;;;;;N;;;;;
+13661;EGYPTIAN HIEROGLYPH-13661;Lo;0;L;;;;;N;;;;;
+13662;EGYPTIAN HIEROGLYPH-13662;Lo;0;L;;;;;N;;;;;
+13663;EGYPTIAN HIEROGLYPH-13663;Lo;0;L;;;;;N;;;;;
+13664;EGYPTIAN HIEROGLYPH-13664;Lo;0;L;;;;;N;;;;;
+13665;EGYPTIAN HIEROGLYPH-13665;Lo;0;L;;;;;N;;;;;
+13666;EGYPTIAN HIEROGLYPH-13666;Lo;0;L;;;;;N;;;;;
+13667;EGYPTIAN HIEROGLYPH-13667;Lo;0;L;;;;;N;;;;;
+13668;EGYPTIAN HIEROGLYPH-13668;Lo;0;L;;;;;N;;;;;
+13669;EGYPTIAN HIEROGLYPH-13669;Lo;0;L;;;;;N;;;;;
+1366A;EGYPTIAN HIEROGLYPH-1366A;Lo;0;L;;;;;N;;;;;
+1366B;EGYPTIAN HIEROGLYPH-1366B;Lo;0;L;;;;;N;;;;;
+1366C;EGYPTIAN HIEROGLYPH-1366C;Lo;0;L;;;;;N;;;;;
+1366D;EGYPTIAN HIEROGLYPH-1366D;Lo;0;L;;;;;N;;;;;
+1366E;EGYPTIAN HIEROGLYPH-1366E;Lo;0;L;;;;;N;;;;;
+1366F;EGYPTIAN HIEROGLYPH-1366F;Lo;0;L;;;;;N;;;;;
+13670;EGYPTIAN HIEROGLYPH-13670;Lo;0;L;;;;;N;;;;;
+13671;EGYPTIAN HIEROGLYPH-13671;Lo;0;L;;;;;N;;;;;
+13672;EGYPTIAN HIEROGLYPH-13672;Lo;0;L;;;;;N;;;;;
+13673;EGYPTIAN HIEROGLYPH-13673;Lo;0;L;;;;;N;;;;;
+13674;EGYPTIAN HIEROGLYPH-13674;Lo;0;L;;;;;N;;;;;
+13675;EGYPTIAN HIEROGLYPH-13675;Lo;0;L;;;;;N;;;;;
+13676;EGYPTIAN HIEROGLYPH-13676;Lo;0;L;;;;;N;;;;;
+13677;EGYPTIAN HIEROGLYPH-13677;Lo;0;L;;;;;N;;;;;
+13678;EGYPTIAN HIEROGLYPH-13678;Lo;0;L;;;;;N;;;;;
+13679;EGYPTIAN HIEROGLYPH-13679;Lo;0;L;;;;;N;;;;;
+1367A;EGYPTIAN HIEROGLYPH-1367A;Lo;0;L;;;;;N;;;;;
+1367B;EGYPTIAN HIEROGLYPH-1367B;Lo;0;L;;;;;N;;;;;
+1367C;EGYPTIAN HIEROGLYPH-1367C;Lo;0;L;;;;;N;;;;;
+1367D;EGYPTIAN HIEROGLYPH-1367D;Lo;0;L;;;;;N;;;;;
+1367E;EGYPTIAN HIEROGLYPH-1367E;Lo;0;L;;;;;N;;;;;
+1367F;EGYPTIAN HIEROGLYPH-1367F;Lo;0;L;;;;;N;;;;;
+13680;EGYPTIAN HIEROGLYPH-13680;Lo;0;L;;;;;N;;;;;
+13681;EGYPTIAN HIEROGLYPH-13681;Lo;0;L;;;;;N;;;;;
+13682;EGYPTIAN HIEROGLYPH-13682;Lo;0;L;;;;;N;;;;;
+13683;EGYPTIAN HIEROGLYPH-13683;Lo;0;L;;;;;N;;;;;
+13684;EGYPTIAN HIEROGLYPH-13684;Lo;0;L;;;;;N;;;;;
+13685;EGYPTIAN HIEROGLYPH-13685;Lo;0;L;;;;;N;;;;;
+13686;EGYPTIAN HIEROGLYPH-13686;Lo;0;L;;;;;N;;;;;
+13687;EGYPTIAN HIEROGLYPH-13687;Lo;0;L;;;;;N;;;;;
+13688;EGYPTIAN HIEROGLYPH-13688;Lo;0;L;;;;;N;;;;;
+13689;EGYPTIAN HIEROGLYPH-13689;Lo;0;L;;;;;N;;;;;
+1368A;EGYPTIAN HIEROGLYPH-1368A;Lo;0;L;;;;;N;;;;;
+1368B;EGYPTIAN HIEROGLYPH-1368B;Lo;0;L;;;;;N;;;;;
+1368C;EGYPTIAN HIEROGLYPH-1368C;Lo;0;L;;;;;N;;;;;
+1368D;EGYPTIAN HIEROGLYPH-1368D;Lo;0;L;;;;;N;;;;;
+1368E;EGYPTIAN HIEROGLYPH-1368E;Lo;0;L;;;;;N;;;;;
+1368F;EGYPTIAN HIEROGLYPH-1368F;Lo;0;L;;;;;N;;;;;
+13690;EGYPTIAN HIEROGLYPH-13690;Lo;0;L;;;;;N;;;;;
+13691;EGYPTIAN HIEROGLYPH-13691;Lo;0;L;;;;;N;;;;;
+13692;EGYPTIAN HIEROGLYPH-13692;Lo;0;L;;;;;N;;;;;
+13693;EGYPTIAN HIEROGLYPH-13693;Lo;0;L;;;;;N;;;;;
+13694;EGYPTIAN HIEROGLYPH-13694;Lo;0;L;;;;;N;;;;;
+13695;EGYPTIAN HIEROGLYPH-13695;Lo;0;L;;;;;N;;;;;
+13696;EGYPTIAN HIEROGLYPH-13696;Lo;0;L;;;;;N;;;;;
+13697;EGYPTIAN HIEROGLYPH-13697;Lo;0;L;;;;;N;;;;;
+13698;EGYPTIAN HIEROGLYPH-13698;Lo;0;L;;;;;N;;;;;
+13699;EGYPTIAN HIEROGLYPH-13699;Lo;0;L;;;;;N;;;;;
+1369A;EGYPTIAN HIEROGLYPH-1369A;Lo;0;L;;;;;N;;;;;
+1369B;EGYPTIAN HIEROGLYPH-1369B;Lo;0;L;;;;;N;;;;;
+1369C;EGYPTIAN HIEROGLYPH-1369C;Lo;0;L;;;;;N;;;;;
+1369D;EGYPTIAN HIEROGLYPH-1369D;Lo;0;L;;;;;N;;;;;
+1369E;EGYPTIAN HIEROGLYPH-1369E;Lo;0;L;;;;;N;;;;;
+1369F;EGYPTIAN HIEROGLYPH-1369F;Lo;0;L;;;;;N;;;;;
+136A0;EGYPTIAN HIEROGLYPH-136A0;Lo;0;L;;;;;N;;;;;
+136A1;EGYPTIAN HIEROGLYPH-136A1;Lo;0;L;;;;;N;;;;;
+136A2;EGYPTIAN HIEROGLYPH-136A2;Lo;0;L;;;;;N;;;;;
+136A3;EGYPTIAN HIEROGLYPH-136A3;Lo;0;L;;;;;N;;;;;
+136A4;EGYPTIAN HIEROGLYPH-136A4;Lo;0;L;;;;;N;;;;;
+136A5;EGYPTIAN HIEROGLYPH-136A5;Lo;0;L;;;;;N;;;;;
+136A6;EGYPTIAN HIEROGLYPH-136A6;Lo;0;L;;;;;N;;;;;
+136A7;EGYPTIAN HIEROGLYPH-136A7;Lo;0;L;;;;;N;;;;;
+136A8;EGYPTIAN HIEROGLYPH-136A8;Lo;0;L;;;;;N;;;;;
+136A9;EGYPTIAN HIEROGLYPH-136A9;Lo;0;L;;;;;N;;;;;
+136AA;EGYPTIAN HIEROGLYPH-136AA;Lo;0;L;;;;;N;;;;;
+136AB;EGYPTIAN HIEROGLYPH-136AB;Lo;0;L;;;;;N;;;;;
+136AC;EGYPTIAN HIEROGLYPH-136AC;Lo;0;L;;;;;N;;;;;
+136AD;EGYPTIAN HIEROGLYPH-136AD;Lo;0;L;;;;;N;;;;;
+136AE;EGYPTIAN HIEROGLYPH-136AE;Lo;0;L;;;;;N;;;;;
+136AF;EGYPTIAN HIEROGLYPH-136AF;Lo;0;L;;;;;N;;;;;
+136B0;EGYPTIAN HIEROGLYPH-136B0;Lo;0;L;;;;;N;;;;;
+136B1;EGYPTIAN HIEROGLYPH-136B1;Lo;0;L;;;;;N;;;;;
+136B2;EGYPTIAN HIEROGLYPH-136B2;Lo;0;L;;;;;N;;;;;
+136B3;EGYPTIAN HIEROGLYPH-136B3;Lo;0;L;;;;;N;;;;;
+136B4;EGYPTIAN HIEROGLYPH-136B4;Lo;0;L;;;;;N;;;;;
+136B5;EGYPTIAN HIEROGLYPH-136B5;Lo;0;L;;;;;N;;;;;
+136B6;EGYPTIAN HIEROGLYPH-136B6;Lo;0;L;;;;;N;;;;;
+136B7;EGYPTIAN HIEROGLYPH-136B7;Lo;0;L;;;;;N;;;;;
+136B8;EGYPTIAN HIEROGLYPH-136B8;Lo;0;L;;;;;N;;;;;
+136B9;EGYPTIAN HIEROGLYPH-136B9;Lo;0;L;;;;;N;;;;;
+136BA;EGYPTIAN HIEROGLYPH-136BA;Lo;0;L;;;;;N;;;;;
+136BB;EGYPTIAN HIEROGLYPH-136BB;Lo;0;L;;;;;N;;;;;
+136BC;EGYPTIAN HIEROGLYPH-136BC;Lo;0;L;;;;;N;;;;;
+136BD;EGYPTIAN HIEROGLYPH-136BD;Lo;0;L;;;;;N;;;;;
+136BE;EGYPTIAN HIEROGLYPH-136BE;Lo;0;L;;;;;N;;;;;
+136BF;EGYPTIAN HIEROGLYPH-136BF;Lo;0;L;;;;;N;;;;;
+136C0;EGYPTIAN HIEROGLYPH-136C0;Lo;0;L;;;;;N;;;;;
+136C1;EGYPTIAN HIEROGLYPH-136C1;Lo;0;L;;;;;N;;;;;
+136C2;EGYPTIAN HIEROGLYPH-136C2;Lo;0;L;;;;;N;;;;;
+136C3;EGYPTIAN HIEROGLYPH-136C3;Lo;0;L;;;;;N;;;;;
+136C4;EGYPTIAN HIEROGLYPH-136C4;Lo;0;L;;;;;N;;;;;
+136C5;EGYPTIAN HIEROGLYPH-136C5;Lo;0;L;;;;;N;;;;;
+136C6;EGYPTIAN HIEROGLYPH-136C6;Lo;0;L;;;;;N;;;;;
+136C7;EGYPTIAN HIEROGLYPH-136C7;Lo;0;L;;;;;N;;;;;
+136C8;EGYPTIAN HIEROGLYPH-136C8;Lo;0;L;;;;;N;;;;;
+136C9;EGYPTIAN HIEROGLYPH-136C9;Lo;0;L;;;;;N;;;;;
+136CA;EGYPTIAN HIEROGLYPH-136CA;Lo;0;L;;;;;N;;;;;
+136CB;EGYPTIAN HIEROGLYPH-136CB;Lo;0;L;;;;;N;;;;;
+136CC;EGYPTIAN HIEROGLYPH-136CC;Lo;0;L;;;;;N;;;;;
+136CD;EGYPTIAN HIEROGLYPH-136CD;Lo;0;L;;;;;N;;;;;
+136CE;EGYPTIAN HIEROGLYPH-136CE;Lo;0;L;;;;;N;;;;;
+136CF;EGYPTIAN HIEROGLYPH-136CF;Lo;0;L;;;;;N;;;;;
+136D0;EGYPTIAN HIEROGLYPH-136D0;Lo;0;L;;;;;N;;;;;
+136D1;EGYPTIAN HIEROGLYPH-136D1;Lo;0;L;;;;;N;;;;;
+136D2;EGYPTIAN HIEROGLYPH-136D2;Lo;0;L;;;;;N;;;;;
+136D3;EGYPTIAN HIEROGLYPH-136D3;Lo;0;L;;;;;N;;;;;
+136D4;EGYPTIAN HIEROGLYPH-136D4;Lo;0;L;;;;;N;;;;;
+136D5;EGYPTIAN HIEROGLYPH-136D5;Lo;0;L;;;;;N;;;;;
+136D6;EGYPTIAN HIEROGLYPH-136D6;Lo;0;L;;;;;N;;;;;
+136D7;EGYPTIAN HIEROGLYPH-136D7;Lo;0;L;;;;;N;;;;;
+136D8;EGYPTIAN HIEROGLYPH-136D8;Lo;0;L;;;;;N;;;;;
+136D9;EGYPTIAN HIEROGLYPH-136D9;Lo;0;L;;;;;N;;;;;
+136DA;EGYPTIAN HIEROGLYPH-136DA;Lo;0;L;;;;;N;;;;;
+136DB;EGYPTIAN HIEROGLYPH-136DB;Lo;0;L;;;;;N;;;;;
+136DC;EGYPTIAN HIEROGLYPH-136DC;Lo;0;L;;;;;N;;;;;
+136DD;EGYPTIAN HIEROGLYPH-136DD;Lo;0;L;;;;;N;;;;;
+136DE;EGYPTIAN HIEROGLYPH-136DE;Lo;0;L;;;;;N;;;;;
+136DF;EGYPTIAN HIEROGLYPH-136DF;Lo;0;L;;;;;N;;;;;
+136E0;EGYPTIAN HIEROGLYPH-136E0;Lo;0;L;;;;;N;;;;;
+136E1;EGYPTIAN HIEROGLYPH-136E1;Lo;0;L;;;;;N;;;;;
+136E2;EGYPTIAN HIEROGLYPH-136E2;Lo;0;L;;;;;N;;;;;
+136E3;EGYPTIAN HIEROGLYPH-136E3;Lo;0;L;;;;;N;;;;;
+136E4;EGYPTIAN HIEROGLYPH-136E4;Lo;0;L;;;;;N;;;;;
+136E5;EGYPTIAN HIEROGLYPH-136E5;Lo;0;L;;;;;N;;;;;
+136E6;EGYPTIAN HIEROGLYPH-136E6;Lo;0;L;;;;;N;;;;;
+136E7;EGYPTIAN HIEROGLYPH-136E7;Lo;0;L;;;;;N;;;;;
+136E8;EGYPTIAN HIEROGLYPH-136E8;Lo;0;L;;;;;N;;;;;
+136E9;EGYPTIAN HIEROGLYPH-136E9;Lo;0;L;;;;;N;;;;;
+136EA;EGYPTIAN HIEROGLYPH-136EA;Lo;0;L;;;;;N;;;;;
+136EB;EGYPTIAN HIEROGLYPH-136EB;Lo;0;L;;;;;N;;;;;
+136EC;EGYPTIAN HIEROGLYPH-136EC;Lo;0;L;;;;;N;;;;;
+136ED;EGYPTIAN HIEROGLYPH-136ED;Lo;0;L;;;;;N;;;;;
+136EE;EGYPTIAN HIEROGLYPH-136EE;Lo;0;L;;;;;N;;;;;
+136EF;EGYPTIAN HIEROGLYPH-136EF;Lo;0;L;;;;;N;;;;;
+136F0;EGYPTIAN HIEROGLYPH-136F0;Lo;0;L;;;;;N;;;;;
+136F1;EGYPTIAN HIEROGLYPH-136F1;Lo;0;L;;;;;N;;;;;
+136F2;EGYPTIAN HIEROGLYPH-136F2;Lo;0;L;;;;;N;;;;;
+136F3;EGYPTIAN HIEROGLYPH-136F3;Lo;0;L;;;;;N;;;;;
+136F4;EGYPTIAN HIEROGLYPH-136F4;Lo;0;L;;;;;N;;;;;
+136F5;EGYPTIAN HIEROGLYPH-136F5;Lo;0;L;;;;;N;;;;;
+136F6;EGYPTIAN HIEROGLYPH-136F6;Lo;0;L;;;;;N;;;;;
+136F7;EGYPTIAN HIEROGLYPH-136F7;Lo;0;L;;;;;N;;;;;
+136F8;EGYPTIAN HIEROGLYPH-136F8;Lo;0;L;;;;;N;;;;;
+136F9;EGYPTIAN HIEROGLYPH-136F9;Lo;0;L;;;;;N;;;;;
+136FA;EGYPTIAN HIEROGLYPH-136FA;Lo;0;L;;;;;N;;;;;
+136FB;EGYPTIAN HIEROGLYPH-136FB;Lo;0;L;;;;;N;;;;;
+136FC;EGYPTIAN HIEROGLYPH-136FC;Lo;0;L;;;;;N;;;;;
+136FD;EGYPTIAN HIEROGLYPH-136FD;Lo;0;L;;;;;N;;;;;
+136FE;EGYPTIAN HIEROGLYPH-136FE;Lo;0;L;;;;;N;;;;;
+136FF;EGYPTIAN HIEROGLYPH-136FF;Lo;0;L;;;;;N;;;;;
+13700;EGYPTIAN HIEROGLYPH-13700;Lo;0;L;;;;;N;;;;;
+13701;EGYPTIAN HIEROGLYPH-13701;Lo;0;L;;;;;N;;;;;
+13702;EGYPTIAN HIEROGLYPH-13702;Lo;0;L;;;;;N;;;;;
+13703;EGYPTIAN HIEROGLYPH-13703;Lo;0;L;;;;;N;;;;;
+13704;EGYPTIAN HIEROGLYPH-13704;Lo;0;L;;;;;N;;;;;
+13705;EGYPTIAN HIEROGLYPH-13705;Lo;0;L;;;;;N;;;;;
+13706;EGYPTIAN HIEROGLYPH-13706;Lo;0;L;;;;;N;;;;;
+13707;EGYPTIAN HIEROGLYPH-13707;Lo;0;L;;;;;N;;;;;
+13708;EGYPTIAN HIEROGLYPH-13708;Lo;0;L;;;;;N;;;;;
+13709;EGYPTIAN HIEROGLYPH-13709;Lo;0;L;;;;;N;;;;;
+1370A;EGYPTIAN HIEROGLYPH-1370A;Lo;0;L;;;;;N;;;;;
+1370B;EGYPTIAN HIEROGLYPH-1370B;Lo;0;L;;;;;N;;;;;
+1370C;EGYPTIAN HIEROGLYPH-1370C;Lo;0;L;;;;;N;;;;;
+1370D;EGYPTIAN HIEROGLYPH-1370D;Lo;0;L;;;;;N;;;;;
+1370E;EGYPTIAN HIEROGLYPH-1370E;Lo;0;L;;;;;N;;;;;
+1370F;EGYPTIAN HIEROGLYPH-1370F;Lo;0;L;;;;;N;;;;;
+13710;EGYPTIAN HIEROGLYPH-13710;Lo;0;L;;;;;N;;;;;
+13711;EGYPTIAN HIEROGLYPH-13711;Lo;0;L;;;;;N;;;;;
+13712;EGYPTIAN HIEROGLYPH-13712;Lo;0;L;;;;;N;;;;;
+13713;EGYPTIAN HIEROGLYPH-13713;Lo;0;L;;;;;N;;;;;
+13714;EGYPTIAN HIEROGLYPH-13714;Lo;0;L;;;;;N;;;;;
+13715;EGYPTIAN HIEROGLYPH-13715;Lo;0;L;;;;;N;;;;;
+13716;EGYPTIAN HIEROGLYPH-13716;Lo;0;L;;;;;N;;;;;
+13717;EGYPTIAN HIEROGLYPH-13717;Lo;0;L;;;;;N;;;;;
+13718;EGYPTIAN HIEROGLYPH-13718;Lo;0;L;;;;;N;;;;;
+13719;EGYPTIAN HIEROGLYPH-13719;Lo;0;L;;;;;N;;;;;
+1371A;EGYPTIAN HIEROGLYPH-1371A;Lo;0;L;;;;;N;;;;;
+1371B;EGYPTIAN HIEROGLYPH-1371B;Lo;0;L;;;;;N;;;;;
+1371C;EGYPTIAN HIEROGLYPH-1371C;Lo;0;L;;;;;N;;;;;
+1371D;EGYPTIAN HIEROGLYPH-1371D;Lo;0;L;;;;;N;;;;;
+1371E;EGYPTIAN HIEROGLYPH-1371E;Lo;0;L;;;;;N;;;;;
+1371F;EGYPTIAN HIEROGLYPH-1371F;Lo;0;L;;;;;N;;;;;
+13720;EGYPTIAN HIEROGLYPH-13720;Lo;0;L;;;;;N;;;;;
+13721;EGYPTIAN HIEROGLYPH-13721;Lo;0;L;;;;;N;;;;;
+13722;EGYPTIAN HIEROGLYPH-13722;Lo;0;L;;;;;N;;;;;
+13723;EGYPTIAN HIEROGLYPH-13723;Lo;0;L;;;;;N;;;;;
+13724;EGYPTIAN HIEROGLYPH-13724;Lo;0;L;;;;;N;;;;;
+13725;EGYPTIAN HIEROGLYPH-13725;Lo;0;L;;;;;N;;;;;
+13726;EGYPTIAN HIEROGLYPH-13726;Lo;0;L;;;;;N;;;;;
+13727;EGYPTIAN HIEROGLYPH-13727;Lo;0;L;;;;;N;;;;;
+13728;EGYPTIAN HIEROGLYPH-13728;Lo;0;L;;;;;N;;;;;
+13729;EGYPTIAN HIEROGLYPH-13729;Lo;0;L;;;;;N;;;;;
+1372A;EGYPTIAN HIEROGLYPH-1372A;Lo;0;L;;;;;N;;;;;
+1372B;EGYPTIAN HIEROGLYPH-1372B;Lo;0;L;;;;;N;;;;;
+1372C;EGYPTIAN HIEROGLYPH-1372C;Lo;0;L;;;;;N;;;;;
+1372D;EGYPTIAN HIEROGLYPH-1372D;Lo;0;L;;;;;N;;;;;
+1372E;EGYPTIAN HIEROGLYPH-1372E;Lo;0;L;;;;;N;;;;;
+1372F;EGYPTIAN HIEROGLYPH-1372F;Lo;0;L;;;;;N;;;;;
+13730;EGYPTIAN HIEROGLYPH-13730;Lo;0;L;;;;;N;;;;;
+13731;EGYPTIAN HIEROGLYPH-13731;Lo;0;L;;;;;N;;;;;
+13732;EGYPTIAN HIEROGLYPH-13732;Lo;0;L;;;;;N;;;;;
+13733;EGYPTIAN HIEROGLYPH-13733;Lo;0;L;;;;;N;;;;;
+13734;EGYPTIAN HIEROGLYPH-13734;Lo;0;L;;;;;N;;;;;
+13735;EGYPTIAN HIEROGLYPH-13735;Lo;0;L;;;;;N;;;;;
+13736;EGYPTIAN HIEROGLYPH-13736;Lo;0;L;;;;;N;;;;;
+13737;EGYPTIAN HIEROGLYPH-13737;Lo;0;L;;;;;N;;;;;
+13738;EGYPTIAN HIEROGLYPH-13738;Lo;0;L;;;;;N;;;;;
+13739;EGYPTIAN HIEROGLYPH-13739;Lo;0;L;;;;;N;;;;;
+1373A;EGYPTIAN HIEROGLYPH-1373A;Lo;0;L;;;;;N;;;;;
+1373B;EGYPTIAN HIEROGLYPH-1373B;Lo;0;L;;;;;N;;;;;
+1373C;EGYPTIAN HIEROGLYPH-1373C;Lo;0;L;;;;;N;;;;;
+1373D;EGYPTIAN HIEROGLYPH-1373D;Lo;0;L;;;;;N;;;;;
+1373E;EGYPTIAN HIEROGLYPH-1373E;Lo;0;L;;;;;N;;;;;
+1373F;EGYPTIAN HIEROGLYPH-1373F;Lo;0;L;;;;;N;;;;;
+13740;EGYPTIAN HIEROGLYPH-13740;Lo;0;L;;;;;N;;;;;
+13741;EGYPTIAN HIEROGLYPH-13741;Lo;0;L;;;;;N;;;;;
+13742;EGYPTIAN HIEROGLYPH-13742;Lo;0;L;;;;;N;;;;;
+13743;EGYPTIAN HIEROGLYPH-13743;Lo;0;L;;;;;N;;;;;
+13744;EGYPTIAN HIEROGLYPH-13744;Lo;0;L;;;;;N;;;;;
+13745;EGYPTIAN HIEROGLYPH-13745;Lo;0;L;;;;;N;;;;;
+13746;EGYPTIAN HIEROGLYPH-13746;Lo;0;L;;;;;N;;;;;
+13747;EGYPTIAN HIEROGLYPH-13747;Lo;0;L;;;;;N;;;;;
+13748;EGYPTIAN HIEROGLYPH-13748;Lo;0;L;;;;;N;;;;;
+13749;EGYPTIAN HIEROGLYPH-13749;Lo;0;L;;;;;N;;;;;
+1374A;EGYPTIAN HIEROGLYPH-1374A;Lo;0;L;;;;;N;;;;;
+1374B;EGYPTIAN HIEROGLYPH-1374B;Lo;0;L;;;;;N;;;;;
+1374C;EGYPTIAN HIEROGLYPH-1374C;Lo;0;L;;;;;N;;;;;
+1374D;EGYPTIAN HIEROGLYPH-1374D;Lo;0;L;;;;;N;;;;;
+1374E;EGYPTIAN HIEROGLYPH-1374E;Lo;0;L;;;;;N;;;;;
+1374F;EGYPTIAN HIEROGLYPH-1374F;Lo;0;L;;;;;N;;;;;
+13750;EGYPTIAN HIEROGLYPH-13750;Lo;0;L;;;;;N;;;;;
+13751;EGYPTIAN HIEROGLYPH-13751;Lo;0;L;;;;;N;;;;;
+13752;EGYPTIAN HIEROGLYPH-13752;Lo;0;L;;;;;N;;;;;
+13753;EGYPTIAN HIEROGLYPH-13753;Lo;0;L;;;;;N;;;;;
+13754;EGYPTIAN HIEROGLYPH-13754;Lo;0;L;;;;;N;;;;;
+13755;EGYPTIAN HIEROGLYPH-13755;Lo;0;L;;;;;N;;;;;
+13756;EGYPTIAN HIEROGLYPH-13756;Lo;0;L;;;;;N;;;;;
+13757;EGYPTIAN HIEROGLYPH-13757;Lo;0;L;;;;;N;;;;;
+13758;EGYPTIAN HIEROGLYPH-13758;Lo;0;L;;;;;N;;;;;
+13759;EGYPTIAN HIEROGLYPH-13759;Lo;0;L;;;;;N;;;;;
+1375A;EGYPTIAN HIEROGLYPH-1375A;Lo;0;L;;;;;N;;;;;
+1375B;EGYPTIAN HIEROGLYPH-1375B;Lo;0;L;;;;;N;;;;;
+1375C;EGYPTIAN HIEROGLYPH-1375C;Lo;0;L;;;;;N;;;;;
+1375D;EGYPTIAN HIEROGLYPH-1375D;Lo;0;L;;;;;N;;;;;
+1375E;EGYPTIAN HIEROGLYPH-1375E;Lo;0;L;;;;;N;;;;;
+1375F;EGYPTIAN HIEROGLYPH-1375F;Lo;0;L;;;;;N;;;;;
+13760;EGYPTIAN HIEROGLYPH-13760;Lo;0;L;;;;;N;;;;;
+13761;EGYPTIAN HIEROGLYPH-13761;Lo;0;L;;;;;N;;;;;
+13762;EGYPTIAN HIEROGLYPH-13762;Lo;0;L;;;;;N;;;;;
+13763;EGYPTIAN HIEROGLYPH-13763;Lo;0;L;;;;;N;;;;;
+13764;EGYPTIAN HIEROGLYPH-13764;Lo;0;L;;;;;N;;;;;
+13765;EGYPTIAN HIEROGLYPH-13765;Lo;0;L;;;;;N;;;;;
+13766;EGYPTIAN HIEROGLYPH-13766;Lo;0;L;;;;;N;;;;;
+13767;EGYPTIAN HIEROGLYPH-13767;Lo;0;L;;;;;N;;;;;
+13768;EGYPTIAN HIEROGLYPH-13768;Lo;0;L;;;;;N;;;;;
+13769;EGYPTIAN HIEROGLYPH-13769;Lo;0;L;;;;;N;;;;;
+1376A;EGYPTIAN HIEROGLYPH-1376A;Lo;0;L;;;;;N;;;;;
+1376B;EGYPTIAN HIEROGLYPH-1376B;Lo;0;L;;;;;N;;;;;
+1376C;EGYPTIAN HIEROGLYPH-1376C;Lo;0;L;;;;;N;;;;;
+1376D;EGYPTIAN HIEROGLYPH-1376D;Lo;0;L;;;;;N;;;;;
+1376E;EGYPTIAN HIEROGLYPH-1376E;Lo;0;L;;;;;N;;;;;
+1376F;EGYPTIAN HIEROGLYPH-1376F;Lo;0;L;;;;;N;;;;;
+13770;EGYPTIAN HIEROGLYPH-13770;Lo;0;L;;;;;N;;;;;
+13771;EGYPTIAN HIEROGLYPH-13771;Lo;0;L;;;;;N;;;;;
+13772;EGYPTIAN HIEROGLYPH-13772;Lo;0;L;;;;;N;;;;;
+13773;EGYPTIAN HIEROGLYPH-13773;Lo;0;L;;;;;N;;;;;
+13774;EGYPTIAN HIEROGLYPH-13774;Lo;0;L;;;;;N;;;;;
+13775;EGYPTIAN HIEROGLYPH-13775;Lo;0;L;;;;;N;;;;;
+13776;EGYPTIAN HIEROGLYPH-13776;Lo;0;L;;;;;N;;;;;
+13777;EGYPTIAN HIEROGLYPH-13777;Lo;0;L;;;;;N;;;;;
+13778;EGYPTIAN HIEROGLYPH-13778;Lo;0;L;;;;;N;;;;;
+13779;EGYPTIAN HIEROGLYPH-13779;Lo;0;L;;;;;N;;;;;
+1377A;EGYPTIAN HIEROGLYPH-1377A;Lo;0;L;;;;;N;;;;;
+1377B;EGYPTIAN HIEROGLYPH-1377B;Lo;0;L;;;;;N;;;;;
+1377C;EGYPTIAN HIEROGLYPH-1377C;Lo;0;L;;;;;N;;;;;
+1377D;EGYPTIAN HIEROGLYPH-1377D;Lo;0;L;;;;;N;;;;;
+1377E;EGYPTIAN HIEROGLYPH-1377E;Lo;0;L;;;;;N;;;;;
+1377F;EGYPTIAN HIEROGLYPH-1377F;Lo;0;L;;;;;N;;;;;
+13780;EGYPTIAN HIEROGLYPH-13780;Lo;0;L;;;;;N;;;;;
+13781;EGYPTIAN HIEROGLYPH-13781;Lo;0;L;;;;;N;;;;;
+13782;EGYPTIAN HIEROGLYPH-13782;Lo;0;L;;;;;N;;;;;
+13783;EGYPTIAN HIEROGLYPH-13783;Lo;0;L;;;;;N;;;;;
+13784;EGYPTIAN HIEROGLYPH-13784;Lo;0;L;;;;;N;;;;;
+13785;EGYPTIAN HIEROGLYPH-13785;Lo;0;L;;;;;N;;;;;
+13786;EGYPTIAN HIEROGLYPH-13786;Lo;0;L;;;;;N;;;;;
+13787;EGYPTIAN HIEROGLYPH-13787;Lo;0;L;;;;;N;;;;;
+13788;EGYPTIAN HIEROGLYPH-13788;Lo;0;L;;;;;N;;;;;
+13789;EGYPTIAN HIEROGLYPH-13789;Lo;0;L;;;;;N;;;;;
+1378A;EGYPTIAN HIEROGLYPH-1378A;Lo;0;L;;;;;N;;;;;
+1378B;EGYPTIAN HIEROGLYPH-1378B;Lo;0;L;;;;;N;;;;;
+1378C;EGYPTIAN HIEROGLYPH-1378C;Lo;0;L;;;;;N;;;;;
+1378D;EGYPTIAN HIEROGLYPH-1378D;Lo;0;L;;;;;N;;;;;
+1378E;EGYPTIAN HIEROGLYPH-1378E;Lo;0;L;;;;;N;;;;;
+1378F;EGYPTIAN HIEROGLYPH-1378F;Lo;0;L;;;;;N;;;;;
+13790;EGYPTIAN HIEROGLYPH-13790;Lo;0;L;;;;;N;;;;;
+13791;EGYPTIAN HIEROGLYPH-13791;Lo;0;L;;;;;N;;;;;
+13792;EGYPTIAN HIEROGLYPH-13792;Lo;0;L;;;;;N;;;;;
+13793;EGYPTIAN HIEROGLYPH-13793;Lo;0;L;;;;;N;;;;;
+13794;EGYPTIAN HIEROGLYPH-13794;Lo;0;L;;;;;N;;;;;
+13795;EGYPTIAN HIEROGLYPH-13795;Lo;0;L;;;;;N;;;;;
+13796;EGYPTIAN HIEROGLYPH-13796;Lo;0;L;;;;;N;;;;;
+13797;EGYPTIAN HIEROGLYPH-13797;Lo;0;L;;;;;N;;;;;
+13798;EGYPTIAN HIEROGLYPH-13798;Lo;0;L;;;;;N;;;;;
+13799;EGYPTIAN HIEROGLYPH-13799;Lo;0;L;;;;;N;;;;;
+1379A;EGYPTIAN HIEROGLYPH-1379A;Lo;0;L;;;;;N;;;;;
+1379B;EGYPTIAN HIEROGLYPH-1379B;Lo;0;L;;;;;N;;;;;
+1379C;EGYPTIAN HIEROGLYPH-1379C;Lo;0;L;;;;;N;;;;;
+1379D;EGYPTIAN HIEROGLYPH-1379D;Lo;0;L;;;;;N;;;;;
+1379E;EGYPTIAN HIEROGLYPH-1379E;Lo;0;L;;;;;N;;;;;
+1379F;EGYPTIAN HIEROGLYPH-1379F;Lo;0;L;;;;;N;;;;;
+137A0;EGYPTIAN HIEROGLYPH-137A0;Lo;0;L;;;;;N;;;;;
+137A1;EGYPTIAN HIEROGLYPH-137A1;Lo;0;L;;;;;N;;;;;
+137A2;EGYPTIAN HIEROGLYPH-137A2;Lo;0;L;;;;;N;;;;;
+137A3;EGYPTIAN HIEROGLYPH-137A3;Lo;0;L;;;;;N;;;;;
+137A4;EGYPTIAN HIEROGLYPH-137A4;Lo;0;L;;;;;N;;;;;
+137A5;EGYPTIAN HIEROGLYPH-137A5;Lo;0;L;;;;;N;;;;;
+137A6;EGYPTIAN HIEROGLYPH-137A6;Lo;0;L;;;;;N;;;;;
+137A7;EGYPTIAN HIEROGLYPH-137A7;Lo;0;L;;;;;N;;;;;
+137A8;EGYPTIAN HIEROGLYPH-137A8;Lo;0;L;;;;;N;;;;;
+137A9;EGYPTIAN HIEROGLYPH-137A9;Lo;0;L;;;;;N;;;;;
+137AA;EGYPTIAN HIEROGLYPH-137AA;Lo;0;L;;;;;N;;;;;
+137AB;EGYPTIAN HIEROGLYPH-137AB;Lo;0;L;;;;;N;;;;;
+137AC;EGYPTIAN HIEROGLYPH-137AC;Lo;0;L;;;;;N;;;;;
+137AD;EGYPTIAN HIEROGLYPH-137AD;Lo;0;L;;;;;N;;;;;
+137AE;EGYPTIAN HIEROGLYPH-137AE;Lo;0;L;;;;;N;;;;;
+137AF;EGYPTIAN HIEROGLYPH-137AF;Lo;0;L;;;;;N;;;;;
+137B0;EGYPTIAN HIEROGLYPH-137B0;Lo;0;L;;;;;N;;;;;
+137B1;EGYPTIAN HIEROGLYPH-137B1;Lo;0;L;;;;;N;;;;;
+137B2;EGYPTIAN HIEROGLYPH-137B2;Lo;0;L;;;;;N;;;;;
+137B3;EGYPTIAN HIEROGLYPH-137B3;Lo;0;L;;;;;N;;;;;
+137B4;EGYPTIAN HIEROGLYPH-137B4;Lo;0;L;;;;;N;;;;;
+137B5;EGYPTIAN HIEROGLYPH-137B5;Lo;0;L;;;;;N;;;;;
+137B6;EGYPTIAN HIEROGLYPH-137B6;Lo;0;L;;;;;N;;;;;
+137B7;EGYPTIAN HIEROGLYPH-137B7;Lo;0;L;;;;;N;;;;;
+137B8;EGYPTIAN HIEROGLYPH-137B8;Lo;0;L;;;;;N;;;;;
+137B9;EGYPTIAN HIEROGLYPH-137B9;Lo;0;L;;;;;N;;;;;
+137BA;EGYPTIAN HIEROGLYPH-137BA;Lo;0;L;;;;;N;;;;;
+137BB;EGYPTIAN HIEROGLYPH-137BB;Lo;0;L;;;;;N;;;;;
+137BC;EGYPTIAN HIEROGLYPH-137BC;Lo;0;L;;;;;N;;;;;
+137BD;EGYPTIAN HIEROGLYPH-137BD;Lo;0;L;;;;;N;;;;;
+137BE;EGYPTIAN HIEROGLYPH-137BE;Lo;0;L;;;;;N;;;;;
+137BF;EGYPTIAN HIEROGLYPH-137BF;Lo;0;L;;;;;N;;;;;
+137C0;EGYPTIAN HIEROGLYPH-137C0;Lo;0;L;;;;;N;;;;;
+137C1;EGYPTIAN HIEROGLYPH-137C1;Lo;0;L;;;;;N;;;;;
+137C2;EGYPTIAN HIEROGLYPH-137C2;Lo;0;L;;;;;N;;;;;
+137C3;EGYPTIAN HIEROGLYPH-137C3;Lo;0;L;;;;;N;;;;;
+137C4;EGYPTIAN HIEROGLYPH-137C4;Lo;0;L;;;;;N;;;;;
+137C5;EGYPTIAN HIEROGLYPH-137C5;Lo;0;L;;;;;N;;;;;
+137C6;EGYPTIAN HIEROGLYPH-137C6;Lo;0;L;;;;;N;;;;;
+137C7;EGYPTIAN HIEROGLYPH-137C7;Lo;0;L;;;;;N;;;;;
+137C8;EGYPTIAN HIEROGLYPH-137C8;Lo;0;L;;;;;N;;;;;
+137C9;EGYPTIAN HIEROGLYPH-137C9;Lo;0;L;;;;;N;;;;;
+137CA;EGYPTIAN HIEROGLYPH-137CA;Lo;0;L;;;;;N;;;;;
+137CB;EGYPTIAN HIEROGLYPH-137CB;Lo;0;L;;;;;N;;;;;
+137CC;EGYPTIAN HIEROGLYPH-137CC;Lo;0;L;;;;;N;;;;;
+137CD;EGYPTIAN HIEROGLYPH-137CD;Lo;0;L;;;;;N;;;;;
+137CE;EGYPTIAN HIEROGLYPH-137CE;Lo;0;L;;;;;N;;;;;
+137CF;EGYPTIAN HIEROGLYPH-137CF;Lo;0;L;;;;;N;;;;;
+137D0;EGYPTIAN HIEROGLYPH-137D0;Lo;0;L;;;;;N;;;;;
+137D1;EGYPTIAN HIEROGLYPH-137D1;Lo;0;L;;;;;N;;;;;
+137D2;EGYPTIAN HIEROGLYPH-137D2;Lo;0;L;;;;;N;;;;;
+137D3;EGYPTIAN HIEROGLYPH-137D3;Lo;0;L;;;;;N;;;;;
+137D4;EGYPTIAN HIEROGLYPH-137D4;Lo;0;L;;;;;N;;;;;
+137D5;EGYPTIAN HIEROGLYPH-137D5;Lo;0;L;;;;;N;;;;;
+137D6;EGYPTIAN HIEROGLYPH-137D6;Lo;0;L;;;;;N;;;;;
+137D7;EGYPTIAN HIEROGLYPH-137D7;Lo;0;L;;;;;N;;;;;
+137D8;EGYPTIAN HIEROGLYPH-137D8;Lo;0;L;;;;;N;;;;;
+137D9;EGYPTIAN HIEROGLYPH-137D9;Lo;0;L;;;;;N;;;;;
+137DA;EGYPTIAN HIEROGLYPH-137DA;Lo;0;L;;;;;N;;;;;
+137DB;EGYPTIAN HIEROGLYPH-137DB;Lo;0;L;;;;;N;;;;;
+137DC;EGYPTIAN HIEROGLYPH-137DC;Lo;0;L;;;;;N;;;;;
+137DD;EGYPTIAN HIEROGLYPH-137DD;Lo;0;L;;;;;N;;;;;
+137DE;EGYPTIAN HIEROGLYPH-137DE;Lo;0;L;;;;;N;;;;;
+137DF;EGYPTIAN HIEROGLYPH-137DF;Lo;0;L;;;;;N;;;;;
+137E0;EGYPTIAN HIEROGLYPH-137E0;Lo;0;L;;;;;N;;;;;
+137E1;EGYPTIAN HIEROGLYPH-137E1;Lo;0;L;;;;;N;;;;;
+137E2;EGYPTIAN HIEROGLYPH-137E2;Lo;0;L;;;;;N;;;;;
+137E3;EGYPTIAN HIEROGLYPH-137E3;Lo;0;L;;;;;N;;;;;
+137E4;EGYPTIAN HIEROGLYPH-137E4;Lo;0;L;;;;;N;;;;;
+137E5;EGYPTIAN HIEROGLYPH-137E5;Lo;0;L;;;;;N;;;;;
+137E6;EGYPTIAN HIEROGLYPH-137E6;Lo;0;L;;;;;N;;;;;
+137E7;EGYPTIAN HIEROGLYPH-137E7;Lo;0;L;;;;;N;;;;;
+137E8;EGYPTIAN HIEROGLYPH-137E8;Lo;0;L;;;;;N;;;;;
+137E9;EGYPTIAN HIEROGLYPH-137E9;Lo;0;L;;;;;N;;;;;
+137EA;EGYPTIAN HIEROGLYPH-137EA;Lo;0;L;;;;;N;;;;;
+137EB;EGYPTIAN HIEROGLYPH-137EB;Lo;0;L;;;;;N;;;;;
+137EC;EGYPTIAN HIEROGLYPH-137EC;Lo;0;L;;;;;N;;;;;
+137ED;EGYPTIAN HIEROGLYPH-137ED;Lo;0;L;;;;;N;;;;;
+137EE;EGYPTIAN HIEROGLYPH-137EE;Lo;0;L;;;;;N;;;;;
+137EF;EGYPTIAN HIEROGLYPH-137EF;Lo;0;L;;;;;N;;;;;
+137F0;EGYPTIAN HIEROGLYPH-137F0;Lo;0;L;;;;;N;;;;;
+137F1;EGYPTIAN HIEROGLYPH-137F1;Lo;0;L;;;;;N;;;;;
+137F2;EGYPTIAN HIEROGLYPH-137F2;Lo;0;L;;;;;N;;;;;
+137F3;EGYPTIAN HIEROGLYPH-137F3;Lo;0;L;;;;;N;;;;;
+137F4;EGYPTIAN HIEROGLYPH-137F4;Lo;0;L;;;;;N;;;;;
+137F5;EGYPTIAN HIEROGLYPH-137F5;Lo;0;L;;;;;N;;;;;
+137F6;EGYPTIAN HIEROGLYPH-137F6;Lo;0;L;;;;;N;;;;;
+137F7;EGYPTIAN HIEROGLYPH-137F7;Lo;0;L;;;;;N;;;;;
+137F8;EGYPTIAN HIEROGLYPH-137F8;Lo;0;L;;;;;N;;;;;
+137F9;EGYPTIAN HIEROGLYPH-137F9;Lo;0;L;;;;;N;;;;;
+137FA;EGYPTIAN HIEROGLYPH-137FA;Lo;0;L;;;;;N;;;;;
+137FB;EGYPTIAN HIEROGLYPH-137FB;Lo;0;L;;;;;N;;;;;
+137FC;EGYPTIAN HIEROGLYPH-137FC;Lo;0;L;;;;;N;;;;;
+137FD;EGYPTIAN HIEROGLYPH-137FD;Lo;0;L;;;;;N;;;;;
+137FE;EGYPTIAN HIEROGLYPH-137FE;Lo;0;L;;;;;N;;;;;
+137FF;EGYPTIAN HIEROGLYPH-137FF;Lo;0;L;;;;;N;;;;;
+13800;EGYPTIAN HIEROGLYPH-13800;Lo;0;L;;;;;N;;;;;
+13801;EGYPTIAN HIEROGLYPH-13801;Lo;0;L;;;;;N;;;;;
+13802;EGYPTIAN HIEROGLYPH-13802;Lo;0;L;;;;;N;;;;;
+13803;EGYPTIAN HIEROGLYPH-13803;Lo;0;L;;;;;N;;;;;
+13804;EGYPTIAN HIEROGLYPH-13804;Lo;0;L;;;;;N;;;;;
+13805;EGYPTIAN HIEROGLYPH-13805;Lo;0;L;;;;;N;;;;;
+13806;EGYPTIAN HIEROGLYPH-13806;Lo;0;L;;;;;N;;;;;
+13807;EGYPTIAN HIEROGLYPH-13807;Lo;0;L;;;;;N;;;;;
+13808;EGYPTIAN HIEROGLYPH-13808;Lo;0;L;;;;;N;;;;;
+13809;EGYPTIAN HIEROGLYPH-13809;Lo;0;L;;;;;N;;;;;
+1380A;EGYPTIAN HIEROGLYPH-1380A;Lo;0;L;;;;;N;;;;;
+1380B;EGYPTIAN HIEROGLYPH-1380B;Lo;0;L;;;;;N;;;;;
+1380C;EGYPTIAN HIEROGLYPH-1380C;Lo;0;L;;;;;N;;;;;
+1380D;EGYPTIAN HIEROGLYPH-1380D;Lo;0;L;;;;;N;;;;;
+1380E;EGYPTIAN HIEROGLYPH-1380E;Lo;0;L;;;;;N;;;;;
+1380F;EGYPTIAN HIEROGLYPH-1380F;Lo;0;L;;;;;N;;;;;
+13810;EGYPTIAN HIEROGLYPH-13810;Lo;0;L;;;;;N;;;;;
+13811;EGYPTIAN HIEROGLYPH-13811;Lo;0;L;;;;;N;;;;;
+13812;EGYPTIAN HIEROGLYPH-13812;Lo;0;L;;;;;N;;;;;
+13813;EGYPTIAN HIEROGLYPH-13813;Lo;0;L;;;;;N;;;;;
+13814;EGYPTIAN HIEROGLYPH-13814;Lo;0;L;;;;;N;;;;;
+13815;EGYPTIAN HIEROGLYPH-13815;Lo;0;L;;;;;N;;;;;
+13816;EGYPTIAN HIEROGLYPH-13816;Lo;0;L;;;;;N;;;;;
+13817;EGYPTIAN HIEROGLYPH-13817;Lo;0;L;;;;;N;;;;;
+13818;EGYPTIAN HIEROGLYPH-13818;Lo;0;L;;;;;N;;;;;
+13819;EGYPTIAN HIEROGLYPH-13819;Lo;0;L;;;;;N;;;;;
+1381A;EGYPTIAN HIEROGLYPH-1381A;Lo;0;L;;;;;N;;;;;
+1381B;EGYPTIAN HIEROGLYPH-1381B;Lo;0;L;;;;;N;;;;;
+1381C;EGYPTIAN HIEROGLYPH-1381C;Lo;0;L;;;;;N;;;;;
+1381D;EGYPTIAN HIEROGLYPH-1381D;Lo;0;L;;;;;N;;;;;
+1381E;EGYPTIAN HIEROGLYPH-1381E;Lo;0;L;;;;;N;;;;;
+1381F;EGYPTIAN HIEROGLYPH-1381F;Lo;0;L;;;;;N;;;;;
+13820;EGYPTIAN HIEROGLYPH-13820;Lo;0;L;;;;;N;;;;;
+13821;EGYPTIAN HIEROGLYPH-13821;Lo;0;L;;;;;N;;;;;
+13822;EGYPTIAN HIEROGLYPH-13822;Lo;0;L;;;;;N;;;;;
+13823;EGYPTIAN HIEROGLYPH-13823;Lo;0;L;;;;;N;;;;;
+13824;EGYPTIAN HIEROGLYPH-13824;Lo;0;L;;;;;N;;;;;
+13825;EGYPTIAN HIEROGLYPH-13825;Lo;0;L;;;;;N;;;;;
+13826;EGYPTIAN HIEROGLYPH-13826;Lo;0;L;;;;;N;;;;;
+13827;EGYPTIAN HIEROGLYPH-13827;Lo;0;L;;;;;N;;;;;
+13828;EGYPTIAN HIEROGLYPH-13828;Lo;0;L;;;;;N;;;;;
+13829;EGYPTIAN HIEROGLYPH-13829;Lo;0;L;;;;;N;;;;;
+1382A;EGYPTIAN HIEROGLYPH-1382A;Lo;0;L;;;;;N;;;;;
+1382B;EGYPTIAN HIEROGLYPH-1382B;Lo;0;L;;;;;N;;;;;
+1382C;EGYPTIAN HIEROGLYPH-1382C;Lo;0;L;;;;;N;;;;;
+1382D;EGYPTIAN HIEROGLYPH-1382D;Lo;0;L;;;;;N;;;;;
+1382E;EGYPTIAN HIEROGLYPH-1382E;Lo;0;L;;;;;N;;;;;
+1382F;EGYPTIAN HIEROGLYPH-1382F;Lo;0;L;;;;;N;;;;;
+13830;EGYPTIAN HIEROGLYPH-13830;Lo;0;L;;;;;N;;;;;
+13831;EGYPTIAN HIEROGLYPH-13831;Lo;0;L;;;;;N;;;;;
+13832;EGYPTIAN HIEROGLYPH-13832;Lo;0;L;;;;;N;;;;;
+13833;EGYPTIAN HIEROGLYPH-13833;Lo;0;L;;;;;N;;;;;
+13834;EGYPTIAN HIEROGLYPH-13834;Lo;0;L;;;;;N;;;;;
+13835;EGYPTIAN HIEROGLYPH-13835;Lo;0;L;;;;;N;;;;;
+13836;EGYPTIAN HIEROGLYPH-13836;Lo;0;L;;;;;N;;;;;
+13837;EGYPTIAN HIEROGLYPH-13837;Lo;0;L;;;;;N;;;;;
+13838;EGYPTIAN HIEROGLYPH-13838;Lo;0;L;;;;;N;;;;;
+13839;EGYPTIAN HIEROGLYPH-13839;Lo;0;L;;;;;N;;;;;
+1383A;EGYPTIAN HIEROGLYPH-1383A;Lo;0;L;;;;;N;;;;;
+1383B;EGYPTIAN HIEROGLYPH-1383B;Lo;0;L;;;;;N;;;;;
+1383C;EGYPTIAN HIEROGLYPH-1383C;Lo;0;L;;;;;N;;;;;
+1383D;EGYPTIAN HIEROGLYPH-1383D;Lo;0;L;;;;;N;;;;;
+1383E;EGYPTIAN HIEROGLYPH-1383E;Lo;0;L;;;;;N;;;;;
+1383F;EGYPTIAN HIEROGLYPH-1383F;Lo;0;L;;;;;N;;;;;
+13840;EGYPTIAN HIEROGLYPH-13840;Lo;0;L;;;;;N;;;;;
+13841;EGYPTIAN HIEROGLYPH-13841;Lo;0;L;;;;;N;;;;;
+13842;EGYPTIAN HIEROGLYPH-13842;Lo;0;L;;;;;N;;;;;
+13843;EGYPTIAN HIEROGLYPH-13843;Lo;0;L;;;;;N;;;;;
+13844;EGYPTIAN HIEROGLYPH-13844;Lo;0;L;;;;;N;;;;;
+13845;EGYPTIAN HIEROGLYPH-13845;Lo;0;L;;;;;N;;;;;
+13846;EGYPTIAN HIEROGLYPH-13846;Lo;0;L;;;;;N;;;;;
+13847;EGYPTIAN HIEROGLYPH-13847;Lo;0;L;;;;;N;;;;;
+13848;EGYPTIAN HIEROGLYPH-13848;Lo;0;L;;;;;N;;;;;
+13849;EGYPTIAN HIEROGLYPH-13849;Lo;0;L;;;;;N;;;;;
+1384A;EGYPTIAN HIEROGLYPH-1384A;Lo;0;L;;;;;N;;;;;
+1384B;EGYPTIAN HIEROGLYPH-1384B;Lo;0;L;;;;;N;;;;;
+1384C;EGYPTIAN HIEROGLYPH-1384C;Lo;0;L;;;;;N;;;;;
+1384D;EGYPTIAN HIEROGLYPH-1384D;Lo;0;L;;;;;N;;;;;
+1384E;EGYPTIAN HIEROGLYPH-1384E;Lo;0;L;;;;;N;;;;;
+1384F;EGYPTIAN HIEROGLYPH-1384F;Lo;0;L;;;;;N;;;;;
+13850;EGYPTIAN HIEROGLYPH-13850;Lo;0;L;;;;;N;;;;;
+13851;EGYPTIAN HIEROGLYPH-13851;Lo;0;L;;;;;N;;;;;
+13852;EGYPTIAN HIEROGLYPH-13852;Lo;0;L;;;;;N;;;;;
+13853;EGYPTIAN HIEROGLYPH-13853;Lo;0;L;;;;;N;;;;;
+13854;EGYPTIAN HIEROGLYPH-13854;Lo;0;L;;;;;N;;;;;
+13855;EGYPTIAN HIEROGLYPH-13855;Lo;0;L;;;;;N;;;;;
+13856;EGYPTIAN HIEROGLYPH-13856;Lo;0;L;;;;;N;;;;;
+13857;EGYPTIAN HIEROGLYPH-13857;Lo;0;L;;;;;N;;;;;
+13858;EGYPTIAN HIEROGLYPH-13858;Lo;0;L;;;;;N;;;;;
+13859;EGYPTIAN HIEROGLYPH-13859;Lo;0;L;;;;;N;;;;;
+1385A;EGYPTIAN HIEROGLYPH-1385A;Lo;0;L;;;;;N;;;;;
+1385B;EGYPTIAN HIEROGLYPH-1385B;Lo;0;L;;;;;N;;;;;
+1385C;EGYPTIAN HIEROGLYPH-1385C;Lo;0;L;;;;;N;;;;;
+1385D;EGYPTIAN HIEROGLYPH-1385D;Lo;0;L;;;;;N;;;;;
+1385E;EGYPTIAN HIEROGLYPH-1385E;Lo;0;L;;;;;N;;;;;
+1385F;EGYPTIAN HIEROGLYPH-1385F;Lo;0;L;;;;;N;;;;;
+13860;EGYPTIAN HIEROGLYPH-13860;Lo;0;L;;;;;N;;;;;
+13861;EGYPTIAN HIEROGLYPH-13861;Lo;0;L;;;;;N;;;;;
+13862;EGYPTIAN HIEROGLYPH-13862;Lo;0;L;;;;;N;;;;;
+13863;EGYPTIAN HIEROGLYPH-13863;Lo;0;L;;;;;N;;;;;
+13864;EGYPTIAN HIEROGLYPH-13864;Lo;0;L;;;;;N;;;;;
+13865;EGYPTIAN HIEROGLYPH-13865;Lo;0;L;;;;;N;;;;;
+13866;EGYPTIAN HIEROGLYPH-13866;Lo;0;L;;;;;N;;;;;
+13867;EGYPTIAN HIEROGLYPH-13867;Lo;0;L;;;;;N;;;;;
+13868;EGYPTIAN HIEROGLYPH-13868;Lo;0;L;;;;;N;;;;;
+13869;EGYPTIAN HIEROGLYPH-13869;Lo;0;L;;;;;N;;;;;
+1386A;EGYPTIAN HIEROGLYPH-1386A;Lo;0;L;;;;;N;;;;;
+1386B;EGYPTIAN HIEROGLYPH-1386B;Lo;0;L;;;;;N;;;;;
+1386C;EGYPTIAN HIEROGLYPH-1386C;Lo;0;L;;;;;N;;;;;
+1386D;EGYPTIAN HIEROGLYPH-1386D;Lo;0;L;;;;;N;;;;;
+1386E;EGYPTIAN HIEROGLYPH-1386E;Lo;0;L;;;;;N;;;;;
+1386F;EGYPTIAN HIEROGLYPH-1386F;Lo;0;L;;;;;N;;;;;
+13870;EGYPTIAN HIEROGLYPH-13870;Lo;0;L;;;;;N;;;;;
+13871;EGYPTIAN HIEROGLYPH-13871;Lo;0;L;;;;;N;;;;;
+13872;EGYPTIAN HIEROGLYPH-13872;Lo;0;L;;;;;N;;;;;
+13873;EGYPTIAN HIEROGLYPH-13873;Lo;0;L;;;;;N;;;;;
+13874;EGYPTIAN HIEROGLYPH-13874;Lo;0;L;;;;;N;;;;;
+13875;EGYPTIAN HIEROGLYPH-13875;Lo;0;L;;;;;N;;;;;
+13876;EGYPTIAN HIEROGLYPH-13876;Lo;0;L;;;;;N;;;;;
+13877;EGYPTIAN HIEROGLYPH-13877;Lo;0;L;;;;;N;;;;;
+13878;EGYPTIAN HIEROGLYPH-13878;Lo;0;L;;;;;N;;;;;
+13879;EGYPTIAN HIEROGLYPH-13879;Lo;0;L;;;;;N;;;;;
+1387A;EGYPTIAN HIEROGLYPH-1387A;Lo;0;L;;;;;N;;;;;
+1387B;EGYPTIAN HIEROGLYPH-1387B;Lo;0;L;;;;;N;;;;;
+1387C;EGYPTIAN HIEROGLYPH-1387C;Lo;0;L;;;;;N;;;;;
+1387D;EGYPTIAN HIEROGLYPH-1387D;Lo;0;L;;;;;N;;;;;
+1387E;EGYPTIAN HIEROGLYPH-1387E;Lo;0;L;;;;;N;;;;;
+1387F;EGYPTIAN HIEROGLYPH-1387F;Lo;0;L;;;;;N;;;;;
+13880;EGYPTIAN HIEROGLYPH-13880;Lo;0;L;;;;;N;;;;;
+13881;EGYPTIAN HIEROGLYPH-13881;Lo;0;L;;;;;N;;;;;
+13882;EGYPTIAN HIEROGLYPH-13882;Lo;0;L;;;;;N;;;;;
+13883;EGYPTIAN HIEROGLYPH-13883;Lo;0;L;;;;;N;;;;;
+13884;EGYPTIAN HIEROGLYPH-13884;Lo;0;L;;;;;N;;;;;
+13885;EGYPTIAN HIEROGLYPH-13885;Lo;0;L;;;;;N;;;;;
+13886;EGYPTIAN HIEROGLYPH-13886;Lo;0;L;;;;;N;;;;;
+13887;EGYPTIAN HIEROGLYPH-13887;Lo;0;L;;;;;N;;;;;
+13888;EGYPTIAN HIEROGLYPH-13888;Lo;0;L;;;;;N;;;;;
+13889;EGYPTIAN HIEROGLYPH-13889;Lo;0;L;;;;;N;;;;;
+1388A;EGYPTIAN HIEROGLYPH-1388A;Lo;0;L;;;;;N;;;;;
+1388B;EGYPTIAN HIEROGLYPH-1388B;Lo;0;L;;;;;N;;;;;
+1388C;EGYPTIAN HIEROGLYPH-1388C;Lo;0;L;;;;;N;;;;;
+1388D;EGYPTIAN HIEROGLYPH-1388D;Lo;0;L;;;;;N;;;;;
+1388E;EGYPTIAN HIEROGLYPH-1388E;Lo;0;L;;;;;N;;;;;
+1388F;EGYPTIAN HIEROGLYPH-1388F;Lo;0;L;;;;;N;;;;;
+13890;EGYPTIAN HIEROGLYPH-13890;Lo;0;L;;;;;N;;;;;
+13891;EGYPTIAN HIEROGLYPH-13891;Lo;0;L;;;;;N;;;;;
+13892;EGYPTIAN HIEROGLYPH-13892;Lo;0;L;;;;;N;;;;;
+13893;EGYPTIAN HIEROGLYPH-13893;Lo;0;L;;;;;N;;;;;
+13894;EGYPTIAN HIEROGLYPH-13894;Lo;0;L;;;;;N;;;;;
+13895;EGYPTIAN HIEROGLYPH-13895;Lo;0;L;;;;;N;;;;;
+13896;EGYPTIAN HIEROGLYPH-13896;Lo;0;L;;;;;N;;;;;
+13897;EGYPTIAN HIEROGLYPH-13897;Lo;0;L;;;;;N;;;;;
+13898;EGYPTIAN HIEROGLYPH-13898;Lo;0;L;;;;;N;;;;;
+13899;EGYPTIAN HIEROGLYPH-13899;Lo;0;L;;;;;N;;;;;
+1389A;EGYPTIAN HIEROGLYPH-1389A;Lo;0;L;;;;;N;;;;;
+1389B;EGYPTIAN HIEROGLYPH-1389B;Lo;0;L;;;;;N;;;;;
+1389C;EGYPTIAN HIEROGLYPH-1389C;Lo;0;L;;;;;N;;;;;
+1389D;EGYPTIAN HIEROGLYPH-1389D;Lo;0;L;;;;;N;;;;;
+1389E;EGYPTIAN HIEROGLYPH-1389E;Lo;0;L;;;;;N;;;;;
+1389F;EGYPTIAN HIEROGLYPH-1389F;Lo;0;L;;;;;N;;;;;
+138A0;EGYPTIAN HIEROGLYPH-138A0;Lo;0;L;;;;;N;;;;;
+138A1;EGYPTIAN HIEROGLYPH-138A1;Lo;0;L;;;;;N;;;;;
+138A2;EGYPTIAN HIEROGLYPH-138A2;Lo;0;L;;;;;N;;;;;
+138A3;EGYPTIAN HIEROGLYPH-138A3;Lo;0;L;;;;;N;;;;;
+138A4;EGYPTIAN HIEROGLYPH-138A4;Lo;0;L;;;;;N;;;;;
+138A5;EGYPTIAN HIEROGLYPH-138A5;Lo;0;L;;;;;N;;;;;
+138A6;EGYPTIAN HIEROGLYPH-138A6;Lo;0;L;;;;;N;;;;;
+138A7;EGYPTIAN HIEROGLYPH-138A7;Lo;0;L;;;;;N;;;;;
+138A8;EGYPTIAN HIEROGLYPH-138A8;Lo;0;L;;;;;N;;;;;
+138A9;EGYPTIAN HIEROGLYPH-138A9;Lo;0;L;;;;;N;;;;;
+138AA;EGYPTIAN HIEROGLYPH-138AA;Lo;0;L;;;;;N;;;;;
+138AB;EGYPTIAN HIEROGLYPH-138AB;Lo;0;L;;;;;N;;;;;
+138AC;EGYPTIAN HIEROGLYPH-138AC;Lo;0;L;;;;;N;;;;;
+138AD;EGYPTIAN HIEROGLYPH-138AD;Lo;0;L;;;;;N;;;;;
+138AE;EGYPTIAN HIEROGLYPH-138AE;Lo;0;L;;;;;N;;;;;
+138AF;EGYPTIAN HIEROGLYPH-138AF;Lo;0;L;;;;;N;;;;;
+138B0;EGYPTIAN HIEROGLYPH-138B0;Lo;0;L;;;;;N;;;;;
+138B1;EGYPTIAN HIEROGLYPH-138B1;Lo;0;L;;;;;N;;;;;
+138B2;EGYPTIAN HIEROGLYPH-138B2;Lo;0;L;;;;;N;;;;;
+138B3;EGYPTIAN HIEROGLYPH-138B3;Lo;0;L;;;;;N;;;;;
+138B4;EGYPTIAN HIEROGLYPH-138B4;Lo;0;L;;;;;N;;;;;
+138B5;EGYPTIAN HIEROGLYPH-138B5;Lo;0;L;;;;;N;;;;;
+138B6;EGYPTIAN HIEROGLYPH-138B6;Lo;0;L;;;;;N;;;;;
+138B7;EGYPTIAN HIEROGLYPH-138B7;Lo;0;L;;;;;N;;;;;
+138B8;EGYPTIAN HIEROGLYPH-138B8;Lo;0;L;;;;;N;;;;;
+138B9;EGYPTIAN HIEROGLYPH-138B9;Lo;0;L;;;;;N;;;;;
+138BA;EGYPTIAN HIEROGLYPH-138BA;Lo;0;L;;;;;N;;;;;
+138BB;EGYPTIAN HIEROGLYPH-138BB;Lo;0;L;;;;;N;;;;;
+138BC;EGYPTIAN HIEROGLYPH-138BC;Lo;0;L;;;;;N;;;;;
+138BD;EGYPTIAN HIEROGLYPH-138BD;Lo;0;L;;;;;N;;;;;
+138BE;EGYPTIAN HIEROGLYPH-138BE;Lo;0;L;;;;;N;;;;;
+138BF;EGYPTIAN HIEROGLYPH-138BF;Lo;0;L;;;;;N;;;;;
+138C0;EGYPTIAN HIEROGLYPH-138C0;Lo;0;L;;;;;N;;;;;
+138C1;EGYPTIAN HIEROGLYPH-138C1;Lo;0;L;;;;;N;;;;;
+138C2;EGYPTIAN HIEROGLYPH-138C2;Lo;0;L;;;;;N;;;;;
+138C3;EGYPTIAN HIEROGLYPH-138C3;Lo;0;L;;;;;N;;;;;
+138C4;EGYPTIAN HIEROGLYPH-138C4;Lo;0;L;;;;;N;;;;;
+138C5;EGYPTIAN HIEROGLYPH-138C5;Lo;0;L;;;;;N;;;;;
+138C6;EGYPTIAN HIEROGLYPH-138C6;Lo;0;L;;;;;N;;;;;
+138C7;EGYPTIAN HIEROGLYPH-138C7;Lo;0;L;;;;;N;;;;;
+138C8;EGYPTIAN HIEROGLYPH-138C8;Lo;0;L;;;;;N;;;;;
+138C9;EGYPTIAN HIEROGLYPH-138C9;Lo;0;L;;;;;N;;;;;
+138CA;EGYPTIAN HIEROGLYPH-138CA;Lo;0;L;;;;;N;;;;;
+138CB;EGYPTIAN HIEROGLYPH-138CB;Lo;0;L;;;;;N;;;;;
+138CC;EGYPTIAN HIEROGLYPH-138CC;Lo;0;L;;;;;N;;;;;
+138CD;EGYPTIAN HIEROGLYPH-138CD;Lo;0;L;;;;;N;;;;;
+138CE;EGYPTIAN HIEROGLYPH-138CE;Lo;0;L;;;;;N;;;;;
+138CF;EGYPTIAN HIEROGLYPH-138CF;Lo;0;L;;;;;N;;;;;
+138D0;EGYPTIAN HIEROGLYPH-138D0;Lo;0;L;;;;;N;;;;;
+138D1;EGYPTIAN HIEROGLYPH-138D1;Lo;0;L;;;;;N;;;;;
+138D2;EGYPTIAN HIEROGLYPH-138D2;Lo;0;L;;;;;N;;;;;
+138D3;EGYPTIAN HIEROGLYPH-138D3;Lo;0;L;;;;;N;;;;;
+138D4;EGYPTIAN HIEROGLYPH-138D4;Lo;0;L;;;;;N;;;;;
+138D5;EGYPTIAN HIEROGLYPH-138D5;Lo;0;L;;;;;N;;;;;
+138D6;EGYPTIAN HIEROGLYPH-138D6;Lo;0;L;;;;;N;;;;;
+138D7;EGYPTIAN HIEROGLYPH-138D7;Lo;0;L;;;;;N;;;;;
+138D8;EGYPTIAN HIEROGLYPH-138D8;Lo;0;L;;;;;N;;;;;
+138D9;EGYPTIAN HIEROGLYPH-138D9;Lo;0;L;;;;;N;;;;;
+138DA;EGYPTIAN HIEROGLYPH-138DA;Lo;0;L;;;;;N;;;;;
+138DB;EGYPTIAN HIEROGLYPH-138DB;Lo;0;L;;;;;N;;;;;
+138DC;EGYPTIAN HIEROGLYPH-138DC;Lo;0;L;;;;;N;;;;;
+138DD;EGYPTIAN HIEROGLYPH-138DD;Lo;0;L;;;;;N;;;;;
+138DE;EGYPTIAN HIEROGLYPH-138DE;Lo;0;L;;;;;N;;;;;
+138DF;EGYPTIAN HIEROGLYPH-138DF;Lo;0;L;;;;;N;;;;;
+138E0;EGYPTIAN HIEROGLYPH-138E0;Lo;0;L;;;;;N;;;;;
+138E1;EGYPTIAN HIEROGLYPH-138E1;Lo;0;L;;;;;N;;;;;
+138E2;EGYPTIAN HIEROGLYPH-138E2;Lo;0;L;;;;;N;;;;;
+138E3;EGYPTIAN HIEROGLYPH-138E3;Lo;0;L;;;;;N;;;;;
+138E4;EGYPTIAN HIEROGLYPH-138E4;Lo;0;L;;;;;N;;;;;
+138E5;EGYPTIAN HIEROGLYPH-138E5;Lo;0;L;;;;;N;;;;;
+138E6;EGYPTIAN HIEROGLYPH-138E6;Lo;0;L;;;;;N;;;;;
+138E7;EGYPTIAN HIEROGLYPH-138E7;Lo;0;L;;;;;N;;;;;
+138E8;EGYPTIAN HIEROGLYPH-138E8;Lo;0;L;;;;;N;;;;;
+138E9;EGYPTIAN HIEROGLYPH-138E9;Lo;0;L;;;;;N;;;;;
+138EA;EGYPTIAN HIEROGLYPH-138EA;Lo;0;L;;;;;N;;;;;
+138EB;EGYPTIAN HIEROGLYPH-138EB;Lo;0;L;;;;;N;;;;;
+138EC;EGYPTIAN HIEROGLYPH-138EC;Lo;0;L;;;;;N;;;;;
+138ED;EGYPTIAN HIEROGLYPH-138ED;Lo;0;L;;;;;N;;;;;
+138EE;EGYPTIAN HIEROGLYPH-138EE;Lo;0;L;;;;;N;;;;;
+138EF;EGYPTIAN HIEROGLYPH-138EF;Lo;0;L;;;;;N;;;;;
+138F0;EGYPTIAN HIEROGLYPH-138F0;Lo;0;L;;;;;N;;;;;
+138F1;EGYPTIAN HIEROGLYPH-138F1;Lo;0;L;;;;;N;;;;;
+138F2;EGYPTIAN HIEROGLYPH-138F2;Lo;0;L;;;;;N;;;;;
+138F3;EGYPTIAN HIEROGLYPH-138F3;Lo;0;L;;;;;N;;;;;
+138F4;EGYPTIAN HIEROGLYPH-138F4;Lo;0;L;;;;;N;;;;;
+138F5;EGYPTIAN HIEROGLYPH-138F5;Lo;0;L;;;;;N;;;;;
+138F6;EGYPTIAN HIEROGLYPH-138F6;Lo;0;L;;;;;N;;;;;
+138F7;EGYPTIAN HIEROGLYPH-138F7;Lo;0;L;;;;;N;;;;;
+138F8;EGYPTIAN HIEROGLYPH-138F8;Lo;0;L;;;;;N;;;;;
+138F9;EGYPTIAN HIEROGLYPH-138F9;Lo;0;L;;;;;N;;;;;
+138FA;EGYPTIAN HIEROGLYPH-138FA;Lo;0;L;;;;;N;;;;;
+138FB;EGYPTIAN HIEROGLYPH-138FB;Lo;0;L;;;;;N;;;;;
+138FC;EGYPTIAN HIEROGLYPH-138FC;Lo;0;L;;;;;N;;;;;
+138FD;EGYPTIAN HIEROGLYPH-138FD;Lo;0;L;;;;;N;;;;;
+138FE;EGYPTIAN HIEROGLYPH-138FE;Lo;0;L;;;;;N;;;;;
+138FF;EGYPTIAN HIEROGLYPH-138FF;Lo;0;L;;;;;N;;;;;
+13900;EGYPTIAN HIEROGLYPH-13900;Lo;0;L;;;;;N;;;;;
+13901;EGYPTIAN HIEROGLYPH-13901;Lo;0;L;;;;;N;;;;;
+13902;EGYPTIAN HIEROGLYPH-13902;Lo;0;L;;;;;N;;;;;
+13903;EGYPTIAN HIEROGLYPH-13903;Lo;0;L;;;;;N;;;;;
+13904;EGYPTIAN HIEROGLYPH-13904;Lo;0;L;;;;;N;;;;;
+13905;EGYPTIAN HIEROGLYPH-13905;Lo;0;L;;;;;N;;;;;
+13906;EGYPTIAN HIEROGLYPH-13906;Lo;0;L;;;;;N;;;;;
+13907;EGYPTIAN HIEROGLYPH-13907;Lo;0;L;;;;;N;;;;;
+13908;EGYPTIAN HIEROGLYPH-13908;Lo;0;L;;;;;N;;;;;
+13909;EGYPTIAN HIEROGLYPH-13909;Lo;0;L;;;;;N;;;;;
+1390A;EGYPTIAN HIEROGLYPH-1390A;Lo;0;L;;;;;N;;;;;
+1390B;EGYPTIAN HIEROGLYPH-1390B;Lo;0;L;;;;;N;;;;;
+1390C;EGYPTIAN HIEROGLYPH-1390C;Lo;0;L;;;;;N;;;;;
+1390D;EGYPTIAN HIEROGLYPH-1390D;Lo;0;L;;;;;N;;;;;
+1390E;EGYPTIAN HIEROGLYPH-1390E;Lo;0;L;;;;;N;;;;;
+1390F;EGYPTIAN HIEROGLYPH-1390F;Lo;0;L;;;;;N;;;;;
+13910;EGYPTIAN HIEROGLYPH-13910;Lo;0;L;;;;;N;;;;;
+13911;EGYPTIAN HIEROGLYPH-13911;Lo;0;L;;;;;N;;;;;
+13912;EGYPTIAN HIEROGLYPH-13912;Lo;0;L;;;;;N;;;;;
+13913;EGYPTIAN HIEROGLYPH-13913;Lo;0;L;;;;;N;;;;;
+13914;EGYPTIAN HIEROGLYPH-13914;Lo;0;L;;;;;N;;;;;
+13915;EGYPTIAN HIEROGLYPH-13915;Lo;0;L;;;;;N;;;;;
+13916;EGYPTIAN HIEROGLYPH-13916;Lo;0;L;;;;;N;;;;;
+13917;EGYPTIAN HIEROGLYPH-13917;Lo;0;L;;;;;N;;;;;
+13918;EGYPTIAN HIEROGLYPH-13918;Lo;0;L;;;;;N;;;;;
+13919;EGYPTIAN HIEROGLYPH-13919;Lo;0;L;;;;;N;;;;;
+1391A;EGYPTIAN HIEROGLYPH-1391A;Lo;0;L;;;;;N;;;;;
+1391B;EGYPTIAN HIEROGLYPH-1391B;Lo;0;L;;;;;N;;;;;
+1391C;EGYPTIAN HIEROGLYPH-1391C;Lo;0;L;;;;;N;;;;;
+1391D;EGYPTIAN HIEROGLYPH-1391D;Lo;0;L;;;;;N;;;;;
+1391E;EGYPTIAN HIEROGLYPH-1391E;Lo;0;L;;;;;N;;;;;
+1391F;EGYPTIAN HIEROGLYPH-1391F;Lo;0;L;;;;;N;;;;;
+13920;EGYPTIAN HIEROGLYPH-13920;Lo;0;L;;;;;N;;;;;
+13921;EGYPTIAN HIEROGLYPH-13921;Lo;0;L;;;;;N;;;;;
+13922;EGYPTIAN HIEROGLYPH-13922;Lo;0;L;;;;;N;;;;;
+13923;EGYPTIAN HIEROGLYPH-13923;Lo;0;L;;;;;N;;;;;
+13924;EGYPTIAN HIEROGLYPH-13924;Lo;0;L;;;;;N;;;;;
+13925;EGYPTIAN HIEROGLYPH-13925;Lo;0;L;;;;;N;;;;;
+13926;EGYPTIAN HIEROGLYPH-13926;Lo;0;L;;;;;N;;;;;
+13927;EGYPTIAN HIEROGLYPH-13927;Lo;0;L;;;;;N;;;;;
+13928;EGYPTIAN HIEROGLYPH-13928;Lo;0;L;;;;;N;;;;;
+13929;EGYPTIAN HIEROGLYPH-13929;Lo;0;L;;;;;N;;;;;
+1392A;EGYPTIAN HIEROGLYPH-1392A;Lo;0;L;;;;;N;;;;;
+1392B;EGYPTIAN HIEROGLYPH-1392B;Lo;0;L;;;;;N;;;;;
+1392C;EGYPTIAN HIEROGLYPH-1392C;Lo;0;L;;;;;N;;;;;
+1392D;EGYPTIAN HIEROGLYPH-1392D;Lo;0;L;;;;;N;;;;;
+1392E;EGYPTIAN HIEROGLYPH-1392E;Lo;0;L;;;;;N;;;;;
+1392F;EGYPTIAN HIEROGLYPH-1392F;Lo;0;L;;;;;N;;;;;
+13930;EGYPTIAN HIEROGLYPH-13930;Lo;0;L;;;;;N;;;;;
+13931;EGYPTIAN HIEROGLYPH-13931;Lo;0;L;;;;;N;;;;;
+13932;EGYPTIAN HIEROGLYPH-13932;Lo;0;L;;;;;N;;;;;
+13933;EGYPTIAN HIEROGLYPH-13933;Lo;0;L;;;;;N;;;;;
+13934;EGYPTIAN HIEROGLYPH-13934;Lo;0;L;;;;;N;;;;;
+13935;EGYPTIAN HIEROGLYPH-13935;Lo;0;L;;;;;N;;;;;
+13936;EGYPTIAN HIEROGLYPH-13936;Lo;0;L;;;;;N;;;;;
+13937;EGYPTIAN HIEROGLYPH-13937;Lo;0;L;;;;;N;;;;;
+13938;EGYPTIAN HIEROGLYPH-13938;Lo;0;L;;;;;N;;;;;
+13939;EGYPTIAN HIEROGLYPH-13939;Lo;0;L;;;;;N;;;;;
+1393A;EGYPTIAN HIEROGLYPH-1393A;Lo;0;L;;;;;N;;;;;
+1393B;EGYPTIAN HIEROGLYPH-1393B;Lo;0;L;;;;;N;;;;;
+1393C;EGYPTIAN HIEROGLYPH-1393C;Lo;0;L;;;;;N;;;;;
+1393D;EGYPTIAN HIEROGLYPH-1393D;Lo;0;L;;;;;N;;;;;
+1393E;EGYPTIAN HIEROGLYPH-1393E;Lo;0;L;;;;;N;;;;;
+1393F;EGYPTIAN HIEROGLYPH-1393F;Lo;0;L;;;;;N;;;;;
+13940;EGYPTIAN HIEROGLYPH-13940;Lo;0;L;;;;;N;;;;;
+13941;EGYPTIAN HIEROGLYPH-13941;Lo;0;L;;;;;N;;;;;
+13942;EGYPTIAN HIEROGLYPH-13942;Lo;0;L;;;;;N;;;;;
+13943;EGYPTIAN HIEROGLYPH-13943;Lo;0;L;;;;;N;;;;;
+13944;EGYPTIAN HIEROGLYPH-13944;Lo;0;L;;;;;N;;;;;
+13945;EGYPTIAN HIEROGLYPH-13945;Lo;0;L;;;;;N;;;;;
+13946;EGYPTIAN HIEROGLYPH-13946;Lo;0;L;;;;;N;;;;;
+13947;EGYPTIAN HIEROGLYPH-13947;Lo;0;L;;;;;N;;;;;
+13948;EGYPTIAN HIEROGLYPH-13948;Lo;0;L;;;;;N;;;;;
+13949;EGYPTIAN HIEROGLYPH-13949;Lo;0;L;;;;;N;;;;;
+1394A;EGYPTIAN HIEROGLYPH-1394A;Lo;0;L;;;;;N;;;;;
+1394B;EGYPTIAN HIEROGLYPH-1394B;Lo;0;L;;;;;N;;;;;
+1394C;EGYPTIAN HIEROGLYPH-1394C;Lo;0;L;;;;;N;;;;;
+1394D;EGYPTIAN HIEROGLYPH-1394D;Lo;0;L;;;;;N;;;;;
+1394E;EGYPTIAN HIEROGLYPH-1394E;Lo;0;L;;;;;N;;;;;
+1394F;EGYPTIAN HIEROGLYPH-1394F;Lo;0;L;;;;;N;;;;;
+13950;EGYPTIAN HIEROGLYPH-13950;Lo;0;L;;;;;N;;;;;
+13951;EGYPTIAN HIEROGLYPH-13951;Lo;0;L;;;;;N;;;;;
+13952;EGYPTIAN HIEROGLYPH-13952;Lo;0;L;;;;;N;;;;;
+13953;EGYPTIAN HIEROGLYPH-13953;Lo;0;L;;;;;N;;;;;
+13954;EGYPTIAN HIEROGLYPH-13954;Lo;0;L;;;;;N;;;;;
+13955;EGYPTIAN HIEROGLYPH-13955;Lo;0;L;;;;;N;;;;;
+13956;EGYPTIAN HIEROGLYPH-13956;Lo;0;L;;;;;N;;;;;
+13957;EGYPTIAN HIEROGLYPH-13957;Lo;0;L;;;;;N;;;;;
+13958;EGYPTIAN HIEROGLYPH-13958;Lo;0;L;;;;;N;;;;;
+13959;EGYPTIAN HIEROGLYPH-13959;Lo;0;L;;;;;N;;;;;
+1395A;EGYPTIAN HIEROGLYPH-1395A;Lo;0;L;;;;;N;;;;;
+1395B;EGYPTIAN HIEROGLYPH-1395B;Lo;0;L;;;;;N;;;;;
+1395C;EGYPTIAN HIEROGLYPH-1395C;Lo;0;L;;;;;N;;;;;
+1395D;EGYPTIAN HIEROGLYPH-1395D;Lo;0;L;;;;;N;;;;;
+1395E;EGYPTIAN HIEROGLYPH-1395E;Lo;0;L;;;;;N;;;;;
+1395F;EGYPTIAN HIEROGLYPH-1395F;Lo;0;L;;;;;N;;;;;
+13960;EGYPTIAN HIEROGLYPH-13960;Lo;0;L;;;;;N;;;;;
+13961;EGYPTIAN HIEROGLYPH-13961;Lo;0;L;;;;;N;;;;;
+13962;EGYPTIAN HIEROGLYPH-13962;Lo;0;L;;;;;N;;;;;
+13963;EGYPTIAN HIEROGLYPH-13963;Lo;0;L;;;;;N;;;;;
+13964;EGYPTIAN HIEROGLYPH-13964;Lo;0;L;;;;;N;;;;;
+13965;EGYPTIAN HIEROGLYPH-13965;Lo;0;L;;;;;N;;;;;
+13966;EGYPTIAN HIEROGLYPH-13966;Lo;0;L;;;;;N;;;;;
+13967;EGYPTIAN HIEROGLYPH-13967;Lo;0;L;;;;;N;;;;;
+13968;EGYPTIAN HIEROGLYPH-13968;Lo;0;L;;;;;N;;;;;
+13969;EGYPTIAN HIEROGLYPH-13969;Lo;0;L;;;;;N;;;;;
+1396A;EGYPTIAN HIEROGLYPH-1396A;Lo;0;L;;;;;N;;;;;
+1396B;EGYPTIAN HIEROGLYPH-1396B;Lo;0;L;;;;;N;;;;;
+1396C;EGYPTIAN HIEROGLYPH-1396C;Lo;0;L;;;;;N;;;;;
+1396D;EGYPTIAN HIEROGLYPH-1396D;Lo;0;L;;;;;N;;;;;
+1396E;EGYPTIAN HIEROGLYPH-1396E;Lo;0;L;;;;;N;;;;;
+1396F;EGYPTIAN HIEROGLYPH-1396F;Lo;0;L;;;;;N;;;;;
+13970;EGYPTIAN HIEROGLYPH-13970;Lo;0;L;;;;;N;;;;;
+13971;EGYPTIAN HIEROGLYPH-13971;Lo;0;L;;;;;N;;;;;
+13972;EGYPTIAN HIEROGLYPH-13972;Lo;0;L;;;;;N;;;;;
+13973;EGYPTIAN HIEROGLYPH-13973;Lo;0;L;;;;;N;;;;;
+13974;EGYPTIAN HIEROGLYPH-13974;Lo;0;L;;;;;N;;;;;
+13975;EGYPTIAN HIEROGLYPH-13975;Lo;0;L;;;;;N;;;;;
+13976;EGYPTIAN HIEROGLYPH-13976;Lo;0;L;;;;;N;;;;;
+13977;EGYPTIAN HIEROGLYPH-13977;Lo;0;L;;;;;N;;;;;
+13978;EGYPTIAN HIEROGLYPH-13978;Lo;0;L;;;;;N;;;;;
+13979;EGYPTIAN HIEROGLYPH-13979;Lo;0;L;;;;;N;;;;;
+1397A;EGYPTIAN HIEROGLYPH-1397A;Lo;0;L;;;;;N;;;;;
+1397B;EGYPTIAN HIEROGLYPH-1397B;Lo;0;L;;;;;N;;;;;
+1397C;EGYPTIAN HIEROGLYPH-1397C;Lo;0;L;;;;;N;;;;;
+1397D;EGYPTIAN HIEROGLYPH-1397D;Lo;0;L;;;;;N;;;;;
+1397E;EGYPTIAN HIEROGLYPH-1397E;Lo;0;L;;;;;N;;;;;
+1397F;EGYPTIAN HIEROGLYPH-1397F;Lo;0;L;;;;;N;;;;;
+13980;EGYPTIAN HIEROGLYPH-13980;Lo;0;L;;;;;N;;;;;
+13981;EGYPTIAN HIEROGLYPH-13981;Lo;0;L;;;;;N;;;;;
+13982;EGYPTIAN HIEROGLYPH-13982;Lo;0;L;;;;;N;;;;;
+13983;EGYPTIAN HIEROGLYPH-13983;Lo;0;L;;;;;N;;;;;
+13984;EGYPTIAN HIEROGLYPH-13984;Lo;0;L;;;;;N;;;;;
+13985;EGYPTIAN HIEROGLYPH-13985;Lo;0;L;;;;;N;;;;;
+13986;EGYPTIAN HIEROGLYPH-13986;Lo;0;L;;;;;N;;;;;
+13987;EGYPTIAN HIEROGLYPH-13987;Lo;0;L;;;;;N;;;;;
+13988;EGYPTIAN HIEROGLYPH-13988;Lo;0;L;;;;;N;;;;;
+13989;EGYPTIAN HIEROGLYPH-13989;Lo;0;L;;;;;N;;;;;
+1398A;EGYPTIAN HIEROGLYPH-1398A;Lo;0;L;;;;;N;;;;;
+1398B;EGYPTIAN HIEROGLYPH-1398B;Lo;0;L;;;;;N;;;;;
+1398C;EGYPTIAN HIEROGLYPH-1398C;Lo;0;L;;;;;N;;;;;
+1398D;EGYPTIAN HIEROGLYPH-1398D;Lo;0;L;;;;;N;;;;;
+1398E;EGYPTIAN HIEROGLYPH-1398E;Lo;0;L;;;;;N;;;;;
+1398F;EGYPTIAN HIEROGLYPH-1398F;Lo;0;L;;;;;N;;;;;
+13990;EGYPTIAN HIEROGLYPH-13990;Lo;0;L;;;;;N;;;;;
+13991;EGYPTIAN HIEROGLYPH-13991;Lo;0;L;;;;;N;;;;;
+13992;EGYPTIAN HIEROGLYPH-13992;Lo;0;L;;;;;N;;;;;
+13993;EGYPTIAN HIEROGLYPH-13993;Lo;0;L;;;;;N;;;;;
+13994;EGYPTIAN HIEROGLYPH-13994;Lo;0;L;;;;;N;;;;;
+13995;EGYPTIAN HIEROGLYPH-13995;Lo;0;L;;;;;N;;;;;
+13996;EGYPTIAN HIEROGLYPH-13996;Lo;0;L;;;;;N;;;;;
+13997;EGYPTIAN HIEROGLYPH-13997;Lo;0;L;;;;;N;;;;;
+13998;EGYPTIAN HIEROGLYPH-13998;Lo;0;L;;;;;N;;;;;
+13999;EGYPTIAN HIEROGLYPH-13999;Lo;0;L;;;;;N;;;;;
+1399A;EGYPTIAN HIEROGLYPH-1399A;Lo;0;L;;;;;N;;;;;
+1399B;EGYPTIAN HIEROGLYPH-1399B;Lo;0;L;;;;;N;;;;;
+1399C;EGYPTIAN HIEROGLYPH-1399C;Lo;0;L;;;;;N;;;;;
+1399D;EGYPTIAN HIEROGLYPH-1399D;Lo;0;L;;;;;N;;;;;
+1399E;EGYPTIAN HIEROGLYPH-1399E;Lo;0;L;;;;;N;;;;;
+1399F;EGYPTIAN HIEROGLYPH-1399F;Lo;0;L;;;;;N;;;;;
+139A0;EGYPTIAN HIEROGLYPH-139A0;Lo;0;L;;;;;N;;;;;
+139A1;EGYPTIAN HIEROGLYPH-139A1;Lo;0;L;;;;;N;;;;;
+139A2;EGYPTIAN HIEROGLYPH-139A2;Lo;0;L;;;;;N;;;;;
+139A3;EGYPTIAN HIEROGLYPH-139A3;Lo;0;L;;;;;N;;;;;
+139A4;EGYPTIAN HIEROGLYPH-139A4;Lo;0;L;;;;;N;;;;;
+139A5;EGYPTIAN HIEROGLYPH-139A5;Lo;0;L;;;;;N;;;;;
+139A6;EGYPTIAN HIEROGLYPH-139A6;Lo;0;L;;;;;N;;;;;
+139A7;EGYPTIAN HIEROGLYPH-139A7;Lo;0;L;;;;;N;;;;;
+139A8;EGYPTIAN HIEROGLYPH-139A8;Lo;0;L;;;;;N;;;;;
+139A9;EGYPTIAN HIEROGLYPH-139A9;Lo;0;L;;;;;N;;;;;
+139AA;EGYPTIAN HIEROGLYPH-139AA;Lo;0;L;;;;;N;;;;;
+139AB;EGYPTIAN HIEROGLYPH-139AB;Lo;0;L;;;;;N;;;;;
+139AC;EGYPTIAN HIEROGLYPH-139AC;Lo;0;L;;;;;N;;;;;
+139AD;EGYPTIAN HIEROGLYPH-139AD;Lo;0;L;;;;;N;;;;;
+139AE;EGYPTIAN HIEROGLYPH-139AE;Lo;0;L;;;;;N;;;;;
+139AF;EGYPTIAN HIEROGLYPH-139AF;Lo;0;L;;;;;N;;;;;
+139B0;EGYPTIAN HIEROGLYPH-139B0;Lo;0;L;;;;;N;;;;;
+139B1;EGYPTIAN HIEROGLYPH-139B1;Lo;0;L;;;;;N;;;;;
+139B2;EGYPTIAN HIEROGLYPH-139B2;Lo;0;L;;;;;N;;;;;
+139B3;EGYPTIAN HIEROGLYPH-139B3;Lo;0;L;;;;;N;;;;;
+139B4;EGYPTIAN HIEROGLYPH-139B4;Lo;0;L;;;;;N;;;;;
+139B5;EGYPTIAN HIEROGLYPH-139B5;Lo;0;L;;;;;N;;;;;
+139B6;EGYPTIAN HIEROGLYPH-139B6;Lo;0;L;;;;;N;;;;;
+139B7;EGYPTIAN HIEROGLYPH-139B7;Lo;0;L;;;;;N;;;;;
+139B8;EGYPTIAN HIEROGLYPH-139B8;Lo;0;L;;;;;N;;;;;
+139B9;EGYPTIAN HIEROGLYPH-139B9;Lo;0;L;;;;;N;;;;;
+139BA;EGYPTIAN HIEROGLYPH-139BA;Lo;0;L;;;;;N;;;;;
+139BB;EGYPTIAN HIEROGLYPH-139BB;Lo;0;L;;;;;N;;;;;
+139BC;EGYPTIAN HIEROGLYPH-139BC;Lo;0;L;;;;;N;;;;;
+139BD;EGYPTIAN HIEROGLYPH-139BD;Lo;0;L;;;;;N;;;;;
+139BE;EGYPTIAN HIEROGLYPH-139BE;Lo;0;L;;;;;N;;;;;
+139BF;EGYPTIAN HIEROGLYPH-139BF;Lo;0;L;;;;;N;;;;;
+139C0;EGYPTIAN HIEROGLYPH-139C0;Lo;0;L;;;;;N;;;;;
+139C1;EGYPTIAN HIEROGLYPH-139C1;Lo;0;L;;;;;N;;;;;
+139C2;EGYPTIAN HIEROGLYPH-139C2;Lo;0;L;;;;;N;;;;;
+139C3;EGYPTIAN HIEROGLYPH-139C3;Lo;0;L;;;;;N;;;;;
+139C4;EGYPTIAN HIEROGLYPH-139C4;Lo;0;L;;;;;N;;;;;
+139C5;EGYPTIAN HIEROGLYPH-139C5;Lo;0;L;;;;;N;;;;;
+139C6;EGYPTIAN HIEROGLYPH-139C6;Lo;0;L;;;;;N;;;;;
+139C7;EGYPTIAN HIEROGLYPH-139C7;Lo;0;L;;;;;N;;;;;
+139C8;EGYPTIAN HIEROGLYPH-139C8;Lo;0;L;;;;;N;;;;;
+139C9;EGYPTIAN HIEROGLYPH-139C9;Lo;0;L;;;;;N;;;;;
+139CA;EGYPTIAN HIEROGLYPH-139CA;Lo;0;L;;;;;N;;;;;
+139CB;EGYPTIAN HIEROGLYPH-139CB;Lo;0;L;;;;;N;;;;;
+139CC;EGYPTIAN HIEROGLYPH-139CC;Lo;0;L;;;;;N;;;;;
+139CD;EGYPTIAN HIEROGLYPH-139CD;Lo;0;L;;;;;N;;;;;
+139CE;EGYPTIAN HIEROGLYPH-139CE;Lo;0;L;;;;;N;;;;;
+139CF;EGYPTIAN HIEROGLYPH-139CF;Lo;0;L;;;;;N;;;;;
+139D0;EGYPTIAN HIEROGLYPH-139D0;Lo;0;L;;;;;N;;;;;
+139D1;EGYPTIAN HIEROGLYPH-139D1;Lo;0;L;;;;;N;;;;;
+139D2;EGYPTIAN HIEROGLYPH-139D2;Lo;0;L;;;;;N;;;;;
+139D3;EGYPTIAN HIEROGLYPH-139D3;Lo;0;L;;;;;N;;;;;
+139D4;EGYPTIAN HIEROGLYPH-139D4;Lo;0;L;;;;;N;;;;;
+139D5;EGYPTIAN HIEROGLYPH-139D5;Lo;0;L;;;;;N;;;;;
+139D6;EGYPTIAN HIEROGLYPH-139D6;Lo;0;L;;;;;N;;;;;
+139D7;EGYPTIAN HIEROGLYPH-139D7;Lo;0;L;;;;;N;;;;;
+139D8;EGYPTIAN HIEROGLYPH-139D8;Lo;0;L;;;;;N;;;;;
+139D9;EGYPTIAN HIEROGLYPH-139D9;Lo;0;L;;;;;N;;;;;
+139DA;EGYPTIAN HIEROGLYPH-139DA;Lo;0;L;;;;;N;;;;;
+139DB;EGYPTIAN HIEROGLYPH-139DB;Lo;0;L;;;;;N;;;;;
+139DC;EGYPTIAN HIEROGLYPH-139DC;Lo;0;L;;;;;N;;;;;
+139DD;EGYPTIAN HIEROGLYPH-139DD;Lo;0;L;;;;;N;;;;;
+139DE;EGYPTIAN HIEROGLYPH-139DE;Lo;0;L;;;;;N;;;;;
+139DF;EGYPTIAN HIEROGLYPH-139DF;Lo;0;L;;;;;N;;;;;
+139E0;EGYPTIAN HIEROGLYPH-139E0;Lo;0;L;;;;;N;;;;;
+139E1;EGYPTIAN HIEROGLYPH-139E1;Lo;0;L;;;;;N;;;;;
+139E2;EGYPTIAN HIEROGLYPH-139E2;Lo;0;L;;;;;N;;;;;
+139E3;EGYPTIAN HIEROGLYPH-139E3;Lo;0;L;;;;;N;;;;;
+139E4;EGYPTIAN HIEROGLYPH-139E4;Lo;0;L;;;;;N;;;;;
+139E5;EGYPTIAN HIEROGLYPH-139E5;Lo;0;L;;;;;N;;;;;
+139E6;EGYPTIAN HIEROGLYPH-139E6;Lo;0;L;;;;;N;;;;;
+139E7;EGYPTIAN HIEROGLYPH-139E7;Lo;0;L;;;;;N;;;;;
+139E8;EGYPTIAN HIEROGLYPH-139E8;Lo;0;L;;;;;N;;;;;
+139E9;EGYPTIAN HIEROGLYPH-139E9;Lo;0;L;;;;;N;;;;;
+139EA;EGYPTIAN HIEROGLYPH-139EA;Lo;0;L;;;;;N;;;;;
+139EB;EGYPTIAN HIEROGLYPH-139EB;Lo;0;L;;;;;N;;;;;
+139EC;EGYPTIAN HIEROGLYPH-139EC;Lo;0;L;;;;;N;;;;;
+139ED;EGYPTIAN HIEROGLYPH-139ED;Lo;0;L;;;;;N;;;;;
+139EE;EGYPTIAN HIEROGLYPH-139EE;Lo;0;L;;;;;N;;;;;
+139EF;EGYPTIAN HIEROGLYPH-139EF;Lo;0;L;;;;;N;;;;;
+139F0;EGYPTIAN HIEROGLYPH-139F0;Lo;0;L;;;;;N;;;;;
+139F1;EGYPTIAN HIEROGLYPH-139F1;Lo;0;L;;;;;N;;;;;
+139F2;EGYPTIAN HIEROGLYPH-139F2;Lo;0;L;;;;;N;;;;;
+139F3;EGYPTIAN HIEROGLYPH-139F3;Lo;0;L;;;;;N;;;;;
+139F4;EGYPTIAN HIEROGLYPH-139F4;Lo;0;L;;;;;N;;;;;
+139F5;EGYPTIAN HIEROGLYPH-139F5;Lo;0;L;;;;;N;;;;;
+139F6;EGYPTIAN HIEROGLYPH-139F6;Lo;0;L;;;;;N;;;;;
+139F7;EGYPTIAN HIEROGLYPH-139F7;Lo;0;L;;;;;N;;;;;
+139F8;EGYPTIAN HIEROGLYPH-139F8;Lo;0;L;;;;;N;;;;;
+139F9;EGYPTIAN HIEROGLYPH-139F9;Lo;0;L;;;;;N;;;;;
+139FA;EGYPTIAN HIEROGLYPH-139FA;Lo;0;L;;;;;N;;;;;
+139FB;EGYPTIAN HIEROGLYPH-139FB;Lo;0;L;;;;;N;;;;;
+139FC;EGYPTIAN HIEROGLYPH-139FC;Lo;0;L;;;;;N;;;;;
+139FD;EGYPTIAN HIEROGLYPH-139FD;Lo;0;L;;;;;N;;;;;
+139FE;EGYPTIAN HIEROGLYPH-139FE;Lo;0;L;;;;;N;;;;;
+139FF;EGYPTIAN HIEROGLYPH-139FF;Lo;0;L;;;;;N;;;;;
+13A00;EGYPTIAN HIEROGLYPH-13A00;Lo;0;L;;;;;N;;;;;
+13A01;EGYPTIAN HIEROGLYPH-13A01;Lo;0;L;;;;;N;;;;;
+13A02;EGYPTIAN HIEROGLYPH-13A02;Lo;0;L;;;;;N;;;;;
+13A03;EGYPTIAN HIEROGLYPH-13A03;Lo;0;L;;;;;N;;;;;
+13A04;EGYPTIAN HIEROGLYPH-13A04;Lo;0;L;;;;;N;;;;;
+13A05;EGYPTIAN HIEROGLYPH-13A05;Lo;0;L;;;;;N;;;;;
+13A06;EGYPTIAN HIEROGLYPH-13A06;Lo;0;L;;;;;N;;;;;
+13A07;EGYPTIAN HIEROGLYPH-13A07;Lo;0;L;;;;;N;;;;;
+13A08;EGYPTIAN HIEROGLYPH-13A08;Lo;0;L;;;;;N;;;;;
+13A09;EGYPTIAN HIEROGLYPH-13A09;Lo;0;L;;;;;N;;;;;
+13A0A;EGYPTIAN HIEROGLYPH-13A0A;Lo;0;L;;;;;N;;;;;
+13A0B;EGYPTIAN HIEROGLYPH-13A0B;Lo;0;L;;;;;N;;;;;
+13A0C;EGYPTIAN HIEROGLYPH-13A0C;Lo;0;L;;;;;N;;;;;
+13A0D;EGYPTIAN HIEROGLYPH-13A0D;Lo;0;L;;;;;N;;;;;
+13A0E;EGYPTIAN HIEROGLYPH-13A0E;Lo;0;L;;;;;N;;;;;
+13A0F;EGYPTIAN HIEROGLYPH-13A0F;Lo;0;L;;;;;N;;;;;
+13A10;EGYPTIAN HIEROGLYPH-13A10;Lo;0;L;;;;;N;;;;;
+13A11;EGYPTIAN HIEROGLYPH-13A11;Lo;0;L;;;;;N;;;;;
+13A12;EGYPTIAN HIEROGLYPH-13A12;Lo;0;L;;;;;N;;;;;
+13A13;EGYPTIAN HIEROGLYPH-13A13;Lo;0;L;;;;;N;;;;;
+13A14;EGYPTIAN HIEROGLYPH-13A14;Lo;0;L;;;;;N;;;;;
+13A15;EGYPTIAN HIEROGLYPH-13A15;Lo;0;L;;;;;N;;;;;
+13A16;EGYPTIAN HIEROGLYPH-13A16;Lo;0;L;;;;;N;;;;;
+13A17;EGYPTIAN HIEROGLYPH-13A17;Lo;0;L;;;;;N;;;;;
+13A18;EGYPTIAN HIEROGLYPH-13A18;Lo;0;L;;;;;N;;;;;
+13A19;EGYPTIAN HIEROGLYPH-13A19;Lo;0;L;;;;;N;;;;;
+13A1A;EGYPTIAN HIEROGLYPH-13A1A;Lo;0;L;;;;;N;;;;;
+13A1B;EGYPTIAN HIEROGLYPH-13A1B;Lo;0;L;;;;;N;;;;;
+13A1C;EGYPTIAN HIEROGLYPH-13A1C;Lo;0;L;;;;;N;;;;;
+13A1D;EGYPTIAN HIEROGLYPH-13A1D;Lo;0;L;;;;;N;;;;;
+13A1E;EGYPTIAN HIEROGLYPH-13A1E;Lo;0;L;;;;;N;;;;;
+13A1F;EGYPTIAN HIEROGLYPH-13A1F;Lo;0;L;;;;;N;;;;;
+13A20;EGYPTIAN HIEROGLYPH-13A20;Lo;0;L;;;;;N;;;;;
+13A21;EGYPTIAN HIEROGLYPH-13A21;Lo;0;L;;;;;N;;;;;
+13A22;EGYPTIAN HIEROGLYPH-13A22;Lo;0;L;;;;;N;;;;;
+13A23;EGYPTIAN HIEROGLYPH-13A23;Lo;0;L;;;;;N;;;;;
+13A24;EGYPTIAN HIEROGLYPH-13A24;Lo;0;L;;;;;N;;;;;
+13A25;EGYPTIAN HIEROGLYPH-13A25;Lo;0;L;;;;;N;;;;;
+13A26;EGYPTIAN HIEROGLYPH-13A26;Lo;0;L;;;;;N;;;;;
+13A27;EGYPTIAN HIEROGLYPH-13A27;Lo;0;L;;;;;N;;;;;
+13A28;EGYPTIAN HIEROGLYPH-13A28;Lo;0;L;;;;;N;;;;;
+13A29;EGYPTIAN HIEROGLYPH-13A29;Lo;0;L;;;;;N;;;;;
+13A2A;EGYPTIAN HIEROGLYPH-13A2A;Lo;0;L;;;;;N;;;;;
+13A2B;EGYPTIAN HIEROGLYPH-13A2B;Lo;0;L;;;;;N;;;;;
+13A2C;EGYPTIAN HIEROGLYPH-13A2C;Lo;0;L;;;;;N;;;;;
+13A2D;EGYPTIAN HIEROGLYPH-13A2D;Lo;0;L;;;;;N;;;;;
+13A2E;EGYPTIAN HIEROGLYPH-13A2E;Lo;0;L;;;;;N;;;;;
+13A2F;EGYPTIAN HIEROGLYPH-13A2F;Lo;0;L;;;;;N;;;;;
+13A30;EGYPTIAN HIEROGLYPH-13A30;Lo;0;L;;;;;N;;;;;
+13A31;EGYPTIAN HIEROGLYPH-13A31;Lo;0;L;;;;;N;;;;;
+13A32;EGYPTIAN HIEROGLYPH-13A32;Lo;0;L;;;;;N;;;;;
+13A33;EGYPTIAN HIEROGLYPH-13A33;Lo;0;L;;;;;N;;;;;
+13A34;EGYPTIAN HIEROGLYPH-13A34;Lo;0;L;;;;;N;;;;;
+13A35;EGYPTIAN HIEROGLYPH-13A35;Lo;0;L;;;;;N;;;;;
+13A36;EGYPTIAN HIEROGLYPH-13A36;Lo;0;L;;;;;N;;;;;
+13A37;EGYPTIAN HIEROGLYPH-13A37;Lo;0;L;;;;;N;;;;;
+13A38;EGYPTIAN HIEROGLYPH-13A38;Lo;0;L;;;;;N;;;;;
+13A39;EGYPTIAN HIEROGLYPH-13A39;Lo;0;L;;;;;N;;;;;
+13A3A;EGYPTIAN HIEROGLYPH-13A3A;Lo;0;L;;;;;N;;;;;
+13A3B;EGYPTIAN HIEROGLYPH-13A3B;Lo;0;L;;;;;N;;;;;
+13A3C;EGYPTIAN HIEROGLYPH-13A3C;Lo;0;L;;;;;N;;;;;
+13A3D;EGYPTIAN HIEROGLYPH-13A3D;Lo;0;L;;;;;N;;;;;
+13A3E;EGYPTIAN HIEROGLYPH-13A3E;Lo;0;L;;;;;N;;;;;
+13A3F;EGYPTIAN HIEROGLYPH-13A3F;Lo;0;L;;;;;N;;;;;
+13A40;EGYPTIAN HIEROGLYPH-13A40;Lo;0;L;;;;;N;;;;;
+13A41;EGYPTIAN HIEROGLYPH-13A41;Lo;0;L;;;;;N;;;;;
+13A42;EGYPTIAN HIEROGLYPH-13A42;Lo;0;L;;;;;N;;;;;
+13A43;EGYPTIAN HIEROGLYPH-13A43;Lo;0;L;;;;;N;;;;;
+13A44;EGYPTIAN HIEROGLYPH-13A44;Lo;0;L;;;;;N;;;;;
+13A45;EGYPTIAN HIEROGLYPH-13A45;Lo;0;L;;;;;N;;;;;
+13A46;EGYPTIAN HIEROGLYPH-13A46;Lo;0;L;;;;;N;;;;;
+13A47;EGYPTIAN HIEROGLYPH-13A47;Lo;0;L;;;;;N;;;;;
+13A48;EGYPTIAN HIEROGLYPH-13A48;Lo;0;L;;;;;N;;;;;
+13A49;EGYPTIAN HIEROGLYPH-13A49;Lo;0;L;;;;;N;;;;;
+13A4A;EGYPTIAN HIEROGLYPH-13A4A;Lo;0;L;;;;;N;;;;;
+13A4B;EGYPTIAN HIEROGLYPH-13A4B;Lo;0;L;;;;;N;;;;;
+13A4C;EGYPTIAN HIEROGLYPH-13A4C;Lo;0;L;;;;;N;;;;;
+13A4D;EGYPTIAN HIEROGLYPH-13A4D;Lo;0;L;;;;;N;;;;;
+13A4E;EGYPTIAN HIEROGLYPH-13A4E;Lo;0;L;;;;;N;;;;;
+13A4F;EGYPTIAN HIEROGLYPH-13A4F;Lo;0;L;;;;;N;;;;;
+13A50;EGYPTIAN HIEROGLYPH-13A50;Lo;0;L;;;;;N;;;;;
+13A51;EGYPTIAN HIEROGLYPH-13A51;Lo;0;L;;;;;N;;;;;
+13A52;EGYPTIAN HIEROGLYPH-13A52;Lo;0;L;;;;;N;;;;;
+13A53;EGYPTIAN HIEROGLYPH-13A53;Lo;0;L;;;;;N;;;;;
+13A54;EGYPTIAN HIEROGLYPH-13A54;Lo;0;L;;;;;N;;;;;
+13A55;EGYPTIAN HIEROGLYPH-13A55;Lo;0;L;;;;;N;;;;;
+13A56;EGYPTIAN HIEROGLYPH-13A56;Lo;0;L;;;;;N;;;;;
+13A57;EGYPTIAN HIEROGLYPH-13A57;Lo;0;L;;;;;N;;;;;
+13A58;EGYPTIAN HIEROGLYPH-13A58;Lo;0;L;;;;;N;;;;;
+13A59;EGYPTIAN HIEROGLYPH-13A59;Lo;0;L;;;;;N;;;;;
+13A5A;EGYPTIAN HIEROGLYPH-13A5A;Lo;0;L;;;;;N;;;;;
+13A5B;EGYPTIAN HIEROGLYPH-13A5B;Lo;0;L;;;;;N;;;;;
+13A5C;EGYPTIAN HIEROGLYPH-13A5C;Lo;0;L;;;;;N;;;;;
+13A5D;EGYPTIAN HIEROGLYPH-13A5D;Lo;0;L;;;;;N;;;;;
+13A5E;EGYPTIAN HIEROGLYPH-13A5E;Lo;0;L;;;;;N;;;;;
+13A5F;EGYPTIAN HIEROGLYPH-13A5F;Lo;0;L;;;;;N;;;;;
+13A60;EGYPTIAN HIEROGLYPH-13A60;Lo;0;L;;;;;N;;;;;
+13A61;EGYPTIAN HIEROGLYPH-13A61;Lo;0;L;;;;;N;;;;;
+13A62;EGYPTIAN HIEROGLYPH-13A62;Lo;0;L;;;;;N;;;;;
+13A63;EGYPTIAN HIEROGLYPH-13A63;Lo;0;L;;;;;N;;;;;
+13A64;EGYPTIAN HIEROGLYPH-13A64;Lo;0;L;;;;;N;;;;;
+13A65;EGYPTIAN HIEROGLYPH-13A65;Lo;0;L;;;;;N;;;;;
+13A66;EGYPTIAN HIEROGLYPH-13A66;Lo;0;L;;;;;N;;;;;
+13A67;EGYPTIAN HIEROGLYPH-13A67;Lo;0;L;;;;;N;;;;;
+13A68;EGYPTIAN HIEROGLYPH-13A68;Lo;0;L;;;;;N;;;;;
+13A69;EGYPTIAN HIEROGLYPH-13A69;Lo;0;L;;;;;N;;;;;
+13A6A;EGYPTIAN HIEROGLYPH-13A6A;Lo;0;L;;;;;N;;;;;
+13A6B;EGYPTIAN HIEROGLYPH-13A6B;Lo;0;L;;;;;N;;;;;
+13A6C;EGYPTIAN HIEROGLYPH-13A6C;Lo;0;L;;;;;N;;;;;
+13A6D;EGYPTIAN HIEROGLYPH-13A6D;Lo;0;L;;;;;N;;;;;
+13A6E;EGYPTIAN HIEROGLYPH-13A6E;Lo;0;L;;;;;N;;;;;
+13A6F;EGYPTIAN HIEROGLYPH-13A6F;Lo;0;L;;;;;N;;;;;
+13A70;EGYPTIAN HIEROGLYPH-13A70;Lo;0;L;;;;;N;;;;;
+13A71;EGYPTIAN HIEROGLYPH-13A71;Lo;0;L;;;;;N;;;;;
+13A72;EGYPTIAN HIEROGLYPH-13A72;Lo;0;L;;;;;N;;;;;
+13A73;EGYPTIAN HIEROGLYPH-13A73;Lo;0;L;;;;;N;;;;;
+13A74;EGYPTIAN HIEROGLYPH-13A74;Lo;0;L;;;;;N;;;;;
+13A75;EGYPTIAN HIEROGLYPH-13A75;Lo;0;L;;;;;N;;;;;
+13A76;EGYPTIAN HIEROGLYPH-13A76;Lo;0;L;;;;;N;;;;;
+13A77;EGYPTIAN HIEROGLYPH-13A77;Lo;0;L;;;;;N;;;;;
+13A78;EGYPTIAN HIEROGLYPH-13A78;Lo;0;L;;;;;N;;;;;
+13A79;EGYPTIAN HIEROGLYPH-13A79;Lo;0;L;;;;;N;;;;;
+13A7A;EGYPTIAN HIEROGLYPH-13A7A;Lo;0;L;;;;;N;;;;;
+13A7B;EGYPTIAN HIEROGLYPH-13A7B;Lo;0;L;;;;;N;;;;;
+13A7C;EGYPTIAN HIEROGLYPH-13A7C;Lo;0;L;;;;;N;;;;;
+13A7D;EGYPTIAN HIEROGLYPH-13A7D;Lo;0;L;;;;;N;;;;;
+13A7E;EGYPTIAN HIEROGLYPH-13A7E;Lo;0;L;;;;;N;;;;;
+13A7F;EGYPTIAN HIEROGLYPH-13A7F;Lo;0;L;;;;;N;;;;;
+13A80;EGYPTIAN HIEROGLYPH-13A80;Lo;0;L;;;;;N;;;;;
+13A81;EGYPTIAN HIEROGLYPH-13A81;Lo;0;L;;;;;N;;;;;
+13A82;EGYPTIAN HIEROGLYPH-13A82;Lo;0;L;;;;;N;;;;;
+13A83;EGYPTIAN HIEROGLYPH-13A83;Lo;0;L;;;;;N;;;;;
+13A84;EGYPTIAN HIEROGLYPH-13A84;Lo;0;L;;;;;N;;;;;
+13A85;EGYPTIAN HIEROGLYPH-13A85;Lo;0;L;;;;;N;;;;;
+13A86;EGYPTIAN HIEROGLYPH-13A86;Lo;0;L;;;;;N;;;;;
+13A87;EGYPTIAN HIEROGLYPH-13A87;Lo;0;L;;;;;N;;;;;
+13A88;EGYPTIAN HIEROGLYPH-13A88;Lo;0;L;;;;;N;;;;;
+13A89;EGYPTIAN HIEROGLYPH-13A89;Lo;0;L;;;;;N;;;;;
+13A8A;EGYPTIAN HIEROGLYPH-13A8A;Lo;0;L;;;;;N;;;;;
+13A8B;EGYPTIAN HIEROGLYPH-13A8B;Lo;0;L;;;;;N;;;;;
+13A8C;EGYPTIAN HIEROGLYPH-13A8C;Lo;0;L;;;;;N;;;;;
+13A8D;EGYPTIAN HIEROGLYPH-13A8D;Lo;0;L;;;;;N;;;;;
+13A8E;EGYPTIAN HIEROGLYPH-13A8E;Lo;0;L;;;;;N;;;;;
+13A8F;EGYPTIAN HIEROGLYPH-13A8F;Lo;0;L;;;;;N;;;;;
+13A90;EGYPTIAN HIEROGLYPH-13A90;Lo;0;L;;;;;N;;;;;
+13A91;EGYPTIAN HIEROGLYPH-13A91;Lo;0;L;;;;;N;;;;;
+13A92;EGYPTIAN HIEROGLYPH-13A92;Lo;0;L;;;;;N;;;;;
+13A93;EGYPTIAN HIEROGLYPH-13A93;Lo;0;L;;;;;N;;;;;
+13A94;EGYPTIAN HIEROGLYPH-13A94;Lo;0;L;;;;;N;;;;;
+13A95;EGYPTIAN HIEROGLYPH-13A95;Lo;0;L;;;;;N;;;;;
+13A96;EGYPTIAN HIEROGLYPH-13A96;Lo;0;L;;;;;N;;;;;
+13A97;EGYPTIAN HIEROGLYPH-13A97;Lo;0;L;;;;;N;;;;;
+13A98;EGYPTIAN HIEROGLYPH-13A98;Lo;0;L;;;;;N;;;;;
+13A99;EGYPTIAN HIEROGLYPH-13A99;Lo;0;L;;;;;N;;;;;
+13A9A;EGYPTIAN HIEROGLYPH-13A9A;Lo;0;L;;;;;N;;;;;
+13A9B;EGYPTIAN HIEROGLYPH-13A9B;Lo;0;L;;;;;N;;;;;
+13A9C;EGYPTIAN HIEROGLYPH-13A9C;Lo;0;L;;;;;N;;;;;
+13A9D;EGYPTIAN HIEROGLYPH-13A9D;Lo;0;L;;;;;N;;;;;
+13A9E;EGYPTIAN HIEROGLYPH-13A9E;Lo;0;L;;;;;N;;;;;
+13A9F;EGYPTIAN HIEROGLYPH-13A9F;Lo;0;L;;;;;N;;;;;
+13AA0;EGYPTIAN HIEROGLYPH-13AA0;Lo;0;L;;;;;N;;;;;
+13AA1;EGYPTIAN HIEROGLYPH-13AA1;Lo;0;L;;;;;N;;;;;
+13AA2;EGYPTIAN HIEROGLYPH-13AA2;Lo;0;L;;;;;N;;;;;
+13AA3;EGYPTIAN HIEROGLYPH-13AA3;Lo;0;L;;;;;N;;;;;
+13AA4;EGYPTIAN HIEROGLYPH-13AA4;Lo;0;L;;;;;N;;;;;
+13AA5;EGYPTIAN HIEROGLYPH-13AA5;Lo;0;L;;;;;N;;;;;
+13AA6;EGYPTIAN HIEROGLYPH-13AA6;Lo;0;L;;;;;N;;;;;
+13AA7;EGYPTIAN HIEROGLYPH-13AA7;Lo;0;L;;;;;N;;;;;
+13AA8;EGYPTIAN HIEROGLYPH-13AA8;Lo;0;L;;;;;N;;;;;
+13AA9;EGYPTIAN HIEROGLYPH-13AA9;Lo;0;L;;;;;N;;;;;
+13AAA;EGYPTIAN HIEROGLYPH-13AAA;Lo;0;L;;;;;N;;;;;
+13AAB;EGYPTIAN HIEROGLYPH-13AAB;Lo;0;L;;;;;N;;;;;
+13AAC;EGYPTIAN HIEROGLYPH-13AAC;Lo;0;L;;;;;N;;;;;
+13AAD;EGYPTIAN HIEROGLYPH-13AAD;Lo;0;L;;;;;N;;;;;
+13AAE;EGYPTIAN HIEROGLYPH-13AAE;Lo;0;L;;;;;N;;;;;
+13AAF;EGYPTIAN HIEROGLYPH-13AAF;Lo;0;L;;;;;N;;;;;
+13AB0;EGYPTIAN HIEROGLYPH-13AB0;Lo;0;L;;;;;N;;;;;
+13AB1;EGYPTIAN HIEROGLYPH-13AB1;Lo;0;L;;;;;N;;;;;
+13AB2;EGYPTIAN HIEROGLYPH-13AB2;Lo;0;L;;;;;N;;;;;
+13AB3;EGYPTIAN HIEROGLYPH-13AB3;Lo;0;L;;;;;N;;;;;
+13AB4;EGYPTIAN HIEROGLYPH-13AB4;Lo;0;L;;;;;N;;;;;
+13AB5;EGYPTIAN HIEROGLYPH-13AB5;Lo;0;L;;;;;N;;;;;
+13AB6;EGYPTIAN HIEROGLYPH-13AB6;Lo;0;L;;;;;N;;;;;
+13AB7;EGYPTIAN HIEROGLYPH-13AB7;Lo;0;L;;;;;N;;;;;
+13AB8;EGYPTIAN HIEROGLYPH-13AB8;Lo;0;L;;;;;N;;;;;
+13AB9;EGYPTIAN HIEROGLYPH-13AB9;Lo;0;L;;;;;N;;;;;
+13ABA;EGYPTIAN HIEROGLYPH-13ABA;Lo;0;L;;;;;N;;;;;
+13ABB;EGYPTIAN HIEROGLYPH-13ABB;Lo;0;L;;;;;N;;;;;
+13ABC;EGYPTIAN HIEROGLYPH-13ABC;Lo;0;L;;;;;N;;;;;
+13ABD;EGYPTIAN HIEROGLYPH-13ABD;Lo;0;L;;;;;N;;;;;
+13ABE;EGYPTIAN HIEROGLYPH-13ABE;Lo;0;L;;;;;N;;;;;
+13ABF;EGYPTIAN HIEROGLYPH-13ABF;Lo;0;L;;;;;N;;;;;
+13AC0;EGYPTIAN HIEROGLYPH-13AC0;Lo;0;L;;;;;N;;;;;
+13AC1;EGYPTIAN HIEROGLYPH-13AC1;Lo;0;L;;;;;N;;;;;
+13AC2;EGYPTIAN HIEROGLYPH-13AC2;Lo;0;L;;;;;N;;;;;
+13AC3;EGYPTIAN HIEROGLYPH-13AC3;Lo;0;L;;;;;N;;;;;
+13AC4;EGYPTIAN HIEROGLYPH-13AC4;Lo;0;L;;;;;N;;;;;
+13AC5;EGYPTIAN HIEROGLYPH-13AC5;Lo;0;L;;;;;N;;;;;
+13AC6;EGYPTIAN HIEROGLYPH-13AC6;Lo;0;L;;;;;N;;;;;
+13AC7;EGYPTIAN HIEROGLYPH-13AC7;Lo;0;L;;;;;N;;;;;
+13AC8;EGYPTIAN HIEROGLYPH-13AC8;Lo;0;L;;;;;N;;;;;
+13AC9;EGYPTIAN HIEROGLYPH-13AC9;Lo;0;L;;;;;N;;;;;
+13ACA;EGYPTIAN HIEROGLYPH-13ACA;Lo;0;L;;;;;N;;;;;
+13ACB;EGYPTIAN HIEROGLYPH-13ACB;Lo;0;L;;;;;N;;;;;
+13ACC;EGYPTIAN HIEROGLYPH-13ACC;Lo;0;L;;;;;N;;;;;
+13ACD;EGYPTIAN HIEROGLYPH-13ACD;Lo;0;L;;;;;N;;;;;
+13ACE;EGYPTIAN HIEROGLYPH-13ACE;Lo;0;L;;;;;N;;;;;
+13ACF;EGYPTIAN HIEROGLYPH-13ACF;Lo;0;L;;;;;N;;;;;
+13AD0;EGYPTIAN HIEROGLYPH-13AD0;Lo;0;L;;;;;N;;;;;
+13AD1;EGYPTIAN HIEROGLYPH-13AD1;Lo;0;L;;;;;N;;;;;
+13AD2;EGYPTIAN HIEROGLYPH-13AD2;Lo;0;L;;;;;N;;;;;
+13AD3;EGYPTIAN HIEROGLYPH-13AD3;Lo;0;L;;;;;N;;;;;
+13AD4;EGYPTIAN HIEROGLYPH-13AD4;Lo;0;L;;;;;N;;;;;
+13AD5;EGYPTIAN HIEROGLYPH-13AD5;Lo;0;L;;;;;N;;;;;
+13AD6;EGYPTIAN HIEROGLYPH-13AD6;Lo;0;L;;;;;N;;;;;
+13AD7;EGYPTIAN HIEROGLYPH-13AD7;Lo;0;L;;;;;N;;;;;
+13AD8;EGYPTIAN HIEROGLYPH-13AD8;Lo;0;L;;;;;N;;;;;
+13AD9;EGYPTIAN HIEROGLYPH-13AD9;Lo;0;L;;;;;N;;;;;
+13ADA;EGYPTIAN HIEROGLYPH-13ADA;Lo;0;L;;;;;N;;;;;
+13ADB;EGYPTIAN HIEROGLYPH-13ADB;Lo;0;L;;;;;N;;;;;
+13ADC;EGYPTIAN HIEROGLYPH-13ADC;Lo;0;L;;;;;N;;;;;
+13ADD;EGYPTIAN HIEROGLYPH-13ADD;Lo;0;L;;;;;N;;;;;
+13ADE;EGYPTIAN HIEROGLYPH-13ADE;Lo;0;L;;;;;N;;;;;
+13ADF;EGYPTIAN HIEROGLYPH-13ADF;Lo;0;L;;;;;N;;;;;
+13AE0;EGYPTIAN HIEROGLYPH-13AE0;Lo;0;L;;;;;N;;;;;
+13AE1;EGYPTIAN HIEROGLYPH-13AE1;Lo;0;L;;;;;N;;;;;
+13AE2;EGYPTIAN HIEROGLYPH-13AE2;Lo;0;L;;;;;N;;;;;
+13AE3;EGYPTIAN HIEROGLYPH-13AE3;Lo;0;L;;;;;N;;;;;
+13AE4;EGYPTIAN HIEROGLYPH-13AE4;Lo;0;L;;;;;N;;;;;
+13AE5;EGYPTIAN HIEROGLYPH-13AE5;Lo;0;L;;;;;N;;;;;
+13AE6;EGYPTIAN HIEROGLYPH-13AE6;Lo;0;L;;;;;N;;;;;
+13AE7;EGYPTIAN HIEROGLYPH-13AE7;Lo;0;L;;;;;N;;;;;
+13AE8;EGYPTIAN HIEROGLYPH-13AE8;Lo;0;L;;;;;N;;;;;
+13AE9;EGYPTIAN HIEROGLYPH-13AE9;Lo;0;L;;;;;N;;;;;
+13AEA;EGYPTIAN HIEROGLYPH-13AEA;Lo;0;L;;;;;N;;;;;
+13AEB;EGYPTIAN HIEROGLYPH-13AEB;Lo;0;L;;;;;N;;;;;
+13AEC;EGYPTIAN HIEROGLYPH-13AEC;Lo;0;L;;;;;N;;;;;
+13AED;EGYPTIAN HIEROGLYPH-13AED;Lo;0;L;;;;;N;;;;;
+13AEE;EGYPTIAN HIEROGLYPH-13AEE;Lo;0;L;;;;;N;;;;;
+13AEF;EGYPTIAN HIEROGLYPH-13AEF;Lo;0;L;;;;;N;;;;;
+13AF0;EGYPTIAN HIEROGLYPH-13AF0;Lo;0;L;;;;;N;;;;;
+13AF1;EGYPTIAN HIEROGLYPH-13AF1;Lo;0;L;;;;;N;;;;;
+13AF2;EGYPTIAN HIEROGLYPH-13AF2;Lo;0;L;;;;;N;;;;;
+13AF3;EGYPTIAN HIEROGLYPH-13AF3;Lo;0;L;;;;;N;;;;;
+13AF4;EGYPTIAN HIEROGLYPH-13AF4;Lo;0;L;;;;;N;;;;;
+13AF5;EGYPTIAN HIEROGLYPH-13AF5;Lo;0;L;;;;;N;;;;;
+13AF6;EGYPTIAN HIEROGLYPH-13AF6;Lo;0;L;;;;;N;;;;;
+13AF7;EGYPTIAN HIEROGLYPH-13AF7;Lo;0;L;;;;;N;;;;;
+13AF8;EGYPTIAN HIEROGLYPH-13AF8;Lo;0;L;;;;;N;;;;;
+13AF9;EGYPTIAN HIEROGLYPH-13AF9;Lo;0;L;;;;;N;;;;;
+13AFA;EGYPTIAN HIEROGLYPH-13AFA;Lo;0;L;;;;;N;;;;;
+13AFB;EGYPTIAN HIEROGLYPH-13AFB;Lo;0;L;;;;;N;;;;;
+13AFC;EGYPTIAN HIEROGLYPH-13AFC;Lo;0;L;;;;;N;;;;;
+13AFD;EGYPTIAN HIEROGLYPH-13AFD;Lo;0;L;;;;;N;;;;;
+13AFE;EGYPTIAN HIEROGLYPH-13AFE;Lo;0;L;;;;;N;;;;;
+13AFF;EGYPTIAN HIEROGLYPH-13AFF;Lo;0;L;;;;;N;;;;;
+13B00;EGYPTIAN HIEROGLYPH-13B00;Lo;0;L;;;;;N;;;;;
+13B01;EGYPTIAN HIEROGLYPH-13B01;Lo;0;L;;;;;N;;;;;
+13B02;EGYPTIAN HIEROGLYPH-13B02;Lo;0;L;;;;;N;;;;;
+13B03;EGYPTIAN HIEROGLYPH-13B03;Lo;0;L;;;;;N;;;;;
+13B04;EGYPTIAN HIEROGLYPH-13B04;Lo;0;L;;;;;N;;;;;
+13B05;EGYPTIAN HIEROGLYPH-13B05;Lo;0;L;;;;;N;;;;;
+13B06;EGYPTIAN HIEROGLYPH-13B06;Lo;0;L;;;;;N;;;;;
+13B07;EGYPTIAN HIEROGLYPH-13B07;Lo;0;L;;;;;N;;;;;
+13B08;EGYPTIAN HIEROGLYPH-13B08;Lo;0;L;;;;;N;;;;;
+13B09;EGYPTIAN HIEROGLYPH-13B09;Lo;0;L;;;;;N;;;;;
+13B0A;EGYPTIAN HIEROGLYPH-13B0A;Lo;0;L;;;;;N;;;;;
+13B0B;EGYPTIAN HIEROGLYPH-13B0B;Lo;0;L;;;;;N;;;;;
+13B0C;EGYPTIAN HIEROGLYPH-13B0C;Lo;0;L;;;;;N;;;;;
+13B0D;EGYPTIAN HIEROGLYPH-13B0D;Lo;0;L;;;;;N;;;;;
+13B0E;EGYPTIAN HIEROGLYPH-13B0E;Lo;0;L;;;;;N;;;;;
+13B0F;EGYPTIAN HIEROGLYPH-13B0F;Lo;0;L;;;;;N;;;;;
+13B10;EGYPTIAN HIEROGLYPH-13B10;Lo;0;L;;;;;N;;;;;
+13B11;EGYPTIAN HIEROGLYPH-13B11;Lo;0;L;;;;;N;;;;;
+13B12;EGYPTIAN HIEROGLYPH-13B12;Lo;0;L;;;;;N;;;;;
+13B13;EGYPTIAN HIEROGLYPH-13B13;Lo;0;L;;;;;N;;;;;
+13B14;EGYPTIAN HIEROGLYPH-13B14;Lo;0;L;;;;;N;;;;;
+13B15;EGYPTIAN HIEROGLYPH-13B15;Lo;0;L;;;;;N;;;;;
+13B16;EGYPTIAN HIEROGLYPH-13B16;Lo;0;L;;;;;N;;;;;
+13B17;EGYPTIAN HIEROGLYPH-13B17;Lo;0;L;;;;;N;;;;;
+13B18;EGYPTIAN HIEROGLYPH-13B18;Lo;0;L;;;;;N;;;;;
+13B19;EGYPTIAN HIEROGLYPH-13B19;Lo;0;L;;;;;N;;;;;
+13B1A;EGYPTIAN HIEROGLYPH-13B1A;Lo;0;L;;;;;N;;;;;
+13B1B;EGYPTIAN HIEROGLYPH-13B1B;Lo;0;L;;;;;N;;;;;
+13B1C;EGYPTIAN HIEROGLYPH-13B1C;Lo;0;L;;;;;N;;;;;
+13B1D;EGYPTIAN HIEROGLYPH-13B1D;Lo;0;L;;;;;N;;;;;
+13B1E;EGYPTIAN HIEROGLYPH-13B1E;Lo;0;L;;;;;N;;;;;
+13B1F;EGYPTIAN HIEROGLYPH-13B1F;Lo;0;L;;;;;N;;;;;
+13B20;EGYPTIAN HIEROGLYPH-13B20;Lo;0;L;;;;;N;;;;;
+13B21;EGYPTIAN HIEROGLYPH-13B21;Lo;0;L;;;;;N;;;;;
+13B22;EGYPTIAN HIEROGLYPH-13B22;Lo;0;L;;;;;N;;;;;
+13B23;EGYPTIAN HIEROGLYPH-13B23;Lo;0;L;;;;;N;;;;;
+13B24;EGYPTIAN HIEROGLYPH-13B24;Lo;0;L;;;;;N;;;;;
+13B25;EGYPTIAN HIEROGLYPH-13B25;Lo;0;L;;;;;N;;;;;
+13B26;EGYPTIAN HIEROGLYPH-13B26;Lo;0;L;;;;;N;;;;;
+13B27;EGYPTIAN HIEROGLYPH-13B27;Lo;0;L;;;;;N;;;;;
+13B28;EGYPTIAN HIEROGLYPH-13B28;Lo;0;L;;;;;N;;;;;
+13B29;EGYPTIAN HIEROGLYPH-13B29;Lo;0;L;;;;;N;;;;;
+13B2A;EGYPTIAN HIEROGLYPH-13B2A;Lo;0;L;;;;;N;;;;;
+13B2B;EGYPTIAN HIEROGLYPH-13B2B;Lo;0;L;;;;;N;;;;;
+13B2C;EGYPTIAN HIEROGLYPH-13B2C;Lo;0;L;;;;;N;;;;;
+13B2D;EGYPTIAN HIEROGLYPH-13B2D;Lo;0;L;;;;;N;;;;;
+13B2E;EGYPTIAN HIEROGLYPH-13B2E;Lo;0;L;;;;;N;;;;;
+13B2F;EGYPTIAN HIEROGLYPH-13B2F;Lo;0;L;;;;;N;;;;;
+13B30;EGYPTIAN HIEROGLYPH-13B30;Lo;0;L;;;;;N;;;;;
+13B31;EGYPTIAN HIEROGLYPH-13B31;Lo;0;L;;;;;N;;;;;
+13B32;EGYPTIAN HIEROGLYPH-13B32;Lo;0;L;;;;;N;;;;;
+13B33;EGYPTIAN HIEROGLYPH-13B33;Lo;0;L;;;;;N;;;;;
+13B34;EGYPTIAN HIEROGLYPH-13B34;Lo;0;L;;;;;N;;;;;
+13B35;EGYPTIAN HIEROGLYPH-13B35;Lo;0;L;;;;;N;;;;;
+13B36;EGYPTIAN HIEROGLYPH-13B36;Lo;0;L;;;;;N;;;;;
+13B37;EGYPTIAN HIEROGLYPH-13B37;Lo;0;L;;;;;N;;;;;
+13B38;EGYPTIAN HIEROGLYPH-13B38;Lo;0;L;;;;;N;;;;;
+13B39;EGYPTIAN HIEROGLYPH-13B39;Lo;0;L;;;;;N;;;;;
+13B3A;EGYPTIAN HIEROGLYPH-13B3A;Lo;0;L;;;;;N;;;;;
+13B3B;EGYPTIAN HIEROGLYPH-13B3B;Lo;0;L;;;;;N;;;;;
+13B3C;EGYPTIAN HIEROGLYPH-13B3C;Lo;0;L;;;;;N;;;;;
+13B3D;EGYPTIAN HIEROGLYPH-13B3D;Lo;0;L;;;;;N;;;;;
+13B3E;EGYPTIAN HIEROGLYPH-13B3E;Lo;0;L;;;;;N;;;;;
+13B3F;EGYPTIAN HIEROGLYPH-13B3F;Lo;0;L;;;;;N;;;;;
+13B40;EGYPTIAN HIEROGLYPH-13B40;Lo;0;L;;;;;N;;;;;
+13B41;EGYPTIAN HIEROGLYPH-13B41;Lo;0;L;;;;;N;;;;;
+13B42;EGYPTIAN HIEROGLYPH-13B42;Lo;0;L;;;;;N;;;;;
+13B43;EGYPTIAN HIEROGLYPH-13B43;Lo;0;L;;;;;N;;;;;
+13B44;EGYPTIAN HIEROGLYPH-13B44;Lo;0;L;;;;;N;;;;;
+13B45;EGYPTIAN HIEROGLYPH-13B45;Lo;0;L;;;;;N;;;;;
+13B46;EGYPTIAN HIEROGLYPH-13B46;Lo;0;L;;;;;N;;;;;
+13B47;EGYPTIAN HIEROGLYPH-13B47;Lo;0;L;;;;;N;;;;;
+13B48;EGYPTIAN HIEROGLYPH-13B48;Lo;0;L;;;;;N;;;;;
+13B49;EGYPTIAN HIEROGLYPH-13B49;Lo;0;L;;;;;N;;;;;
+13B4A;EGYPTIAN HIEROGLYPH-13B4A;Lo;0;L;;;;;N;;;;;
+13B4B;EGYPTIAN HIEROGLYPH-13B4B;Lo;0;L;;;;;N;;;;;
+13B4C;EGYPTIAN HIEROGLYPH-13B4C;Lo;0;L;;;;;N;;;;;
+13B4D;EGYPTIAN HIEROGLYPH-13B4D;Lo;0;L;;;;;N;;;;;
+13B4E;EGYPTIAN HIEROGLYPH-13B4E;Lo;0;L;;;;;N;;;;;
+13B4F;EGYPTIAN HIEROGLYPH-13B4F;Lo;0;L;;;;;N;;;;;
+13B50;EGYPTIAN HIEROGLYPH-13B50;Lo;0;L;;;;;N;;;;;
+13B51;EGYPTIAN HIEROGLYPH-13B51;Lo;0;L;;;;;N;;;;;
+13B52;EGYPTIAN HIEROGLYPH-13B52;Lo;0;L;;;;;N;;;;;
+13B53;EGYPTIAN HIEROGLYPH-13B53;Lo;0;L;;;;;N;;;;;
+13B54;EGYPTIAN HIEROGLYPH-13B54;Lo;0;L;;;;;N;;;;;
+13B55;EGYPTIAN HIEROGLYPH-13B55;Lo;0;L;;;;;N;;;;;
+13B56;EGYPTIAN HIEROGLYPH-13B56;Lo;0;L;;;;;N;;;;;
+13B57;EGYPTIAN HIEROGLYPH-13B57;Lo;0;L;;;;;N;;;;;
+13B58;EGYPTIAN HIEROGLYPH-13B58;Lo;0;L;;;;;N;;;;;
+13B59;EGYPTIAN HIEROGLYPH-13B59;Lo;0;L;;;;;N;;;;;
+13B5A;EGYPTIAN HIEROGLYPH-13B5A;Lo;0;L;;;;;N;;;;;
+13B5B;EGYPTIAN HIEROGLYPH-13B5B;Lo;0;L;;;;;N;;;;;
+13B5C;EGYPTIAN HIEROGLYPH-13B5C;Lo;0;L;;;;;N;;;;;
+13B5D;EGYPTIAN HIEROGLYPH-13B5D;Lo;0;L;;;;;N;;;;;
+13B5E;EGYPTIAN HIEROGLYPH-13B5E;Lo;0;L;;;;;N;;;;;
+13B5F;EGYPTIAN HIEROGLYPH-13B5F;Lo;0;L;;;;;N;;;;;
+13B60;EGYPTIAN HIEROGLYPH-13B60;Lo;0;L;;;;;N;;;;;
+13B61;EGYPTIAN HIEROGLYPH-13B61;Lo;0;L;;;;;N;;;;;
+13B62;EGYPTIAN HIEROGLYPH-13B62;Lo;0;L;;;;;N;;;;;
+13B63;EGYPTIAN HIEROGLYPH-13B63;Lo;0;L;;;;;N;;;;;
+13B64;EGYPTIAN HIEROGLYPH-13B64;Lo;0;L;;;;;N;;;;;
+13B65;EGYPTIAN HIEROGLYPH-13B65;Lo;0;L;;;;;N;;;;;
+13B66;EGYPTIAN HIEROGLYPH-13B66;Lo;0;L;;;;;N;;;;;
+13B67;EGYPTIAN HIEROGLYPH-13B67;Lo;0;L;;;;;N;;;;;
+13B68;EGYPTIAN HIEROGLYPH-13B68;Lo;0;L;;;;;N;;;;;
+13B69;EGYPTIAN HIEROGLYPH-13B69;Lo;0;L;;;;;N;;;;;
+13B6A;EGYPTIAN HIEROGLYPH-13B6A;Lo;0;L;;;;;N;;;;;
+13B6B;EGYPTIAN HIEROGLYPH-13B6B;Lo;0;L;;;;;N;;;;;
+13B6C;EGYPTIAN HIEROGLYPH-13B6C;Lo;0;L;;;;;N;;;;;
+13B6D;EGYPTIAN HIEROGLYPH-13B6D;Lo;0;L;;;;;N;;;;;
+13B6E;EGYPTIAN HIEROGLYPH-13B6E;Lo;0;L;;;;;N;;;;;
+13B6F;EGYPTIAN HIEROGLYPH-13B6F;Lo;0;L;;;;;N;;;;;
+13B70;EGYPTIAN HIEROGLYPH-13B70;Lo;0;L;;;;;N;;;;;
+13B71;EGYPTIAN HIEROGLYPH-13B71;Lo;0;L;;;;;N;;;;;
+13B72;EGYPTIAN HIEROGLYPH-13B72;Lo;0;L;;;;;N;;;;;
+13B73;EGYPTIAN HIEROGLYPH-13B73;Lo;0;L;;;;;N;;;;;
+13B74;EGYPTIAN HIEROGLYPH-13B74;Lo;0;L;;;;;N;;;;;
+13B75;EGYPTIAN HIEROGLYPH-13B75;Lo;0;L;;;;;N;;;;;
+13B76;EGYPTIAN HIEROGLYPH-13B76;Lo;0;L;;;;;N;;;;;
+13B77;EGYPTIAN HIEROGLYPH-13B77;Lo;0;L;;;;;N;;;;;
+13B78;EGYPTIAN HIEROGLYPH-13B78;Lo;0;L;;;;;N;;;;;
+13B79;EGYPTIAN HIEROGLYPH-13B79;Lo;0;L;;;;;N;;;;;
+13B7A;EGYPTIAN HIEROGLYPH-13B7A;Lo;0;L;;;;;N;;;;;
+13B7B;EGYPTIAN HIEROGLYPH-13B7B;Lo;0;L;;;;;N;;;;;
+13B7C;EGYPTIAN HIEROGLYPH-13B7C;Lo;0;L;;;;;N;;;;;
+13B7D;EGYPTIAN HIEROGLYPH-13B7D;Lo;0;L;;;;;N;;;;;
+13B7E;EGYPTIAN HIEROGLYPH-13B7E;Lo;0;L;;;;;N;;;;;
+13B7F;EGYPTIAN HIEROGLYPH-13B7F;Lo;0;L;;;;;N;;;;;
+13B80;EGYPTIAN HIEROGLYPH-13B80;Lo;0;L;;;;;N;;;;;
+13B81;EGYPTIAN HIEROGLYPH-13B81;Lo;0;L;;;;;N;;;;;
+13B82;EGYPTIAN HIEROGLYPH-13B82;Lo;0;L;;;;;N;;;;;
+13B83;EGYPTIAN HIEROGLYPH-13B83;Lo;0;L;;;;;N;;;;;
+13B84;EGYPTIAN HIEROGLYPH-13B84;Lo;0;L;;;;;N;;;;;
+13B85;EGYPTIAN HIEROGLYPH-13B85;Lo;0;L;;;;;N;;;;;
+13B86;EGYPTIAN HIEROGLYPH-13B86;Lo;0;L;;;;;N;;;;;
+13B87;EGYPTIAN HIEROGLYPH-13B87;Lo;0;L;;;;;N;;;;;
+13B88;EGYPTIAN HIEROGLYPH-13B88;Lo;0;L;;;;;N;;;;;
+13B89;EGYPTIAN HIEROGLYPH-13B89;Lo;0;L;;;;;N;;;;;
+13B8A;EGYPTIAN HIEROGLYPH-13B8A;Lo;0;L;;;;;N;;;;;
+13B8B;EGYPTIAN HIEROGLYPH-13B8B;Lo;0;L;;;;;N;;;;;
+13B8C;EGYPTIAN HIEROGLYPH-13B8C;Lo;0;L;;;;;N;;;;;
+13B8D;EGYPTIAN HIEROGLYPH-13B8D;Lo;0;L;;;;;N;;;;;
+13B8E;EGYPTIAN HIEROGLYPH-13B8E;Lo;0;L;;;;;N;;;;;
+13B8F;EGYPTIAN HIEROGLYPH-13B8F;Lo;0;L;;;;;N;;;;;
+13B90;EGYPTIAN HIEROGLYPH-13B90;Lo;0;L;;;;;N;;;;;
+13B91;EGYPTIAN HIEROGLYPH-13B91;Lo;0;L;;;;;N;;;;;
+13B92;EGYPTIAN HIEROGLYPH-13B92;Lo;0;L;;;;;N;;;;;
+13B93;EGYPTIAN HIEROGLYPH-13B93;Lo;0;L;;;;;N;;;;;
+13B94;EGYPTIAN HIEROGLYPH-13B94;Lo;0;L;;;;;N;;;;;
+13B95;EGYPTIAN HIEROGLYPH-13B95;Lo;0;L;;;;;N;;;;;
+13B96;EGYPTIAN HIEROGLYPH-13B96;Lo;0;L;;;;;N;;;;;
+13B97;EGYPTIAN HIEROGLYPH-13B97;Lo;0;L;;;;;N;;;;;
+13B98;EGYPTIAN HIEROGLYPH-13B98;Lo;0;L;;;;;N;;;;;
+13B99;EGYPTIAN HIEROGLYPH-13B99;Lo;0;L;;;;;N;;;;;
+13B9A;EGYPTIAN HIEROGLYPH-13B9A;Lo;0;L;;;;;N;;;;;
+13B9B;EGYPTIAN HIEROGLYPH-13B9B;Lo;0;L;;;;;N;;;;;
+13B9C;EGYPTIAN HIEROGLYPH-13B9C;Lo;0;L;;;;;N;;;;;
+13B9D;EGYPTIAN HIEROGLYPH-13B9D;Lo;0;L;;;;;N;;;;;
+13B9E;EGYPTIAN HIEROGLYPH-13B9E;Lo;0;L;;;;;N;;;;;
+13B9F;EGYPTIAN HIEROGLYPH-13B9F;Lo;0;L;;;;;N;;;;;
+13BA0;EGYPTIAN HIEROGLYPH-13BA0;Lo;0;L;;;;;N;;;;;
+13BA1;EGYPTIAN HIEROGLYPH-13BA1;Lo;0;L;;;;;N;;;;;
+13BA2;EGYPTIAN HIEROGLYPH-13BA2;Lo;0;L;;;;;N;;;;;
+13BA3;EGYPTIAN HIEROGLYPH-13BA3;Lo;0;L;;;;;N;;;;;
+13BA4;EGYPTIAN HIEROGLYPH-13BA4;Lo;0;L;;;;;N;;;;;
+13BA5;EGYPTIAN HIEROGLYPH-13BA5;Lo;0;L;;;;;N;;;;;
+13BA6;EGYPTIAN HIEROGLYPH-13BA6;Lo;0;L;;;;;N;;;;;
+13BA7;EGYPTIAN HIEROGLYPH-13BA7;Lo;0;L;;;;;N;;;;;
+13BA8;EGYPTIAN HIEROGLYPH-13BA8;Lo;0;L;;;;;N;;;;;
+13BA9;EGYPTIAN HIEROGLYPH-13BA9;Lo;0;L;;;;;N;;;;;
+13BAA;EGYPTIAN HIEROGLYPH-13BAA;Lo;0;L;;;;;N;;;;;
+13BAB;EGYPTIAN HIEROGLYPH-13BAB;Lo;0;L;;;;;N;;;;;
+13BAC;EGYPTIAN HIEROGLYPH-13BAC;Lo;0;L;;;;;N;;;;;
+13BAD;EGYPTIAN HIEROGLYPH-13BAD;Lo;0;L;;;;;N;;;;;
+13BAE;EGYPTIAN HIEROGLYPH-13BAE;Lo;0;L;;;;;N;;;;;
+13BAF;EGYPTIAN HIEROGLYPH-13BAF;Lo;0;L;;;;;N;;;;;
+13BB0;EGYPTIAN HIEROGLYPH-13BB0;Lo;0;L;;;;;N;;;;;
+13BB1;EGYPTIAN HIEROGLYPH-13BB1;Lo;0;L;;;;;N;;;;;
+13BB2;EGYPTIAN HIEROGLYPH-13BB2;Lo;0;L;;;;;N;;;;;
+13BB3;EGYPTIAN HIEROGLYPH-13BB3;Lo;0;L;;;;;N;;;;;
+13BB4;EGYPTIAN HIEROGLYPH-13BB4;Lo;0;L;;;;;N;;;;;
+13BB5;EGYPTIAN HIEROGLYPH-13BB5;Lo;0;L;;;;;N;;;;;
+13BB6;EGYPTIAN HIEROGLYPH-13BB6;Lo;0;L;;;;;N;;;;;
+13BB7;EGYPTIAN HIEROGLYPH-13BB7;Lo;0;L;;;;;N;;;;;
+13BB8;EGYPTIAN HIEROGLYPH-13BB8;Lo;0;L;;;;;N;;;;;
+13BB9;EGYPTIAN HIEROGLYPH-13BB9;Lo;0;L;;;;;N;;;;;
+13BBA;EGYPTIAN HIEROGLYPH-13BBA;Lo;0;L;;;;;N;;;;;
+13BBB;EGYPTIAN HIEROGLYPH-13BBB;Lo;0;L;;;;;N;;;;;
+13BBC;EGYPTIAN HIEROGLYPH-13BBC;Lo;0;L;;;;;N;;;;;
+13BBD;EGYPTIAN HIEROGLYPH-13BBD;Lo;0;L;;;;;N;;;;;
+13BBE;EGYPTIAN HIEROGLYPH-13BBE;Lo;0;L;;;;;N;;;;;
+13BBF;EGYPTIAN HIEROGLYPH-13BBF;Lo;0;L;;;;;N;;;;;
+13BC0;EGYPTIAN HIEROGLYPH-13BC0;Lo;0;L;;;;;N;;;;;
+13BC1;EGYPTIAN HIEROGLYPH-13BC1;Lo;0;L;;;;;N;;;;;
+13BC2;EGYPTIAN HIEROGLYPH-13BC2;Lo;0;L;;;;;N;;;;;
+13BC3;EGYPTIAN HIEROGLYPH-13BC3;Lo;0;L;;;;;N;;;;;
+13BC4;EGYPTIAN HIEROGLYPH-13BC4;Lo;0;L;;;;;N;;;;;
+13BC5;EGYPTIAN HIEROGLYPH-13BC5;Lo;0;L;;;;;N;;;;;
+13BC6;EGYPTIAN HIEROGLYPH-13BC6;Lo;0;L;;;;;N;;;;;
+13BC7;EGYPTIAN HIEROGLYPH-13BC7;Lo;0;L;;;;;N;;;;;
+13BC8;EGYPTIAN HIEROGLYPH-13BC8;Lo;0;L;;;;;N;;;;;
+13BC9;EGYPTIAN HIEROGLYPH-13BC9;Lo;0;L;;;;;N;;;;;
+13BCA;EGYPTIAN HIEROGLYPH-13BCA;Lo;0;L;;;;;N;;;;;
+13BCB;EGYPTIAN HIEROGLYPH-13BCB;Lo;0;L;;;;;N;;;;;
+13BCC;EGYPTIAN HIEROGLYPH-13BCC;Lo;0;L;;;;;N;;;;;
+13BCD;EGYPTIAN HIEROGLYPH-13BCD;Lo;0;L;;;;;N;;;;;
+13BCE;EGYPTIAN HIEROGLYPH-13BCE;Lo;0;L;;;;;N;;;;;
+13BCF;EGYPTIAN HIEROGLYPH-13BCF;Lo;0;L;;;;;N;;;;;
+13BD0;EGYPTIAN HIEROGLYPH-13BD0;Lo;0;L;;;;;N;;;;;
+13BD1;EGYPTIAN HIEROGLYPH-13BD1;Lo;0;L;;;;;N;;;;;
+13BD2;EGYPTIAN HIEROGLYPH-13BD2;Lo;0;L;;;;;N;;;;;
+13BD3;EGYPTIAN HIEROGLYPH-13BD3;Lo;0;L;;;;;N;;;;;
+13BD4;EGYPTIAN HIEROGLYPH-13BD4;Lo;0;L;;;;;N;;;;;
+13BD5;EGYPTIAN HIEROGLYPH-13BD5;Lo;0;L;;;;;N;;;;;
+13BD6;EGYPTIAN HIEROGLYPH-13BD6;Lo;0;L;;;;;N;;;;;
+13BD7;EGYPTIAN HIEROGLYPH-13BD7;Lo;0;L;;;;;N;;;;;
+13BD8;EGYPTIAN HIEROGLYPH-13BD8;Lo;0;L;;;;;N;;;;;
+13BD9;EGYPTIAN HIEROGLYPH-13BD9;Lo;0;L;;;;;N;;;;;
+13BDA;EGYPTIAN HIEROGLYPH-13BDA;Lo;0;L;;;;;N;;;;;
+13BDB;EGYPTIAN HIEROGLYPH-13BDB;Lo;0;L;;;;;N;;;;;
+13BDC;EGYPTIAN HIEROGLYPH-13BDC;Lo;0;L;;;;;N;;;;;
+13BDD;EGYPTIAN HIEROGLYPH-13BDD;Lo;0;L;;;;;N;;;;;
+13BDE;EGYPTIAN HIEROGLYPH-13BDE;Lo;0;L;;;;;N;;;;;
+13BDF;EGYPTIAN HIEROGLYPH-13BDF;Lo;0;L;;;;;N;;;;;
+13BE0;EGYPTIAN HIEROGLYPH-13BE0;Lo;0;L;;;;;N;;;;;
+13BE1;EGYPTIAN HIEROGLYPH-13BE1;Lo;0;L;;;;;N;;;;;
+13BE2;EGYPTIAN HIEROGLYPH-13BE2;Lo;0;L;;;;;N;;;;;
+13BE3;EGYPTIAN HIEROGLYPH-13BE3;Lo;0;L;;;;;N;;;;;
+13BE4;EGYPTIAN HIEROGLYPH-13BE4;Lo;0;L;;;;;N;;;;;
+13BE5;EGYPTIAN HIEROGLYPH-13BE5;Lo;0;L;;;;;N;;;;;
+13BE6;EGYPTIAN HIEROGLYPH-13BE6;Lo;0;L;;;;;N;;;;;
+13BE7;EGYPTIAN HIEROGLYPH-13BE7;Lo;0;L;;;;;N;;;;;
+13BE8;EGYPTIAN HIEROGLYPH-13BE8;Lo;0;L;;;;;N;;;;;
+13BE9;EGYPTIAN HIEROGLYPH-13BE9;Lo;0;L;;;;;N;;;;;
+13BEA;EGYPTIAN HIEROGLYPH-13BEA;Lo;0;L;;;;;N;;;;;
+13BEB;EGYPTIAN HIEROGLYPH-13BEB;Lo;0;L;;;;;N;;;;;
+13BEC;EGYPTIAN HIEROGLYPH-13BEC;Lo;0;L;;;;;N;;;;;
+13BED;EGYPTIAN HIEROGLYPH-13BED;Lo;0;L;;;;;N;;;;;
+13BEE;EGYPTIAN HIEROGLYPH-13BEE;Lo;0;L;;;;;N;;;;;
+13BEF;EGYPTIAN HIEROGLYPH-13BEF;Lo;0;L;;;;;N;;;;;
+13BF0;EGYPTIAN HIEROGLYPH-13BF0;Lo;0;L;;;;;N;;;;;
+13BF1;EGYPTIAN HIEROGLYPH-13BF1;Lo;0;L;;;;;N;;;;;
+13BF2;EGYPTIAN HIEROGLYPH-13BF2;Lo;0;L;;;;;N;;;;;
+13BF3;EGYPTIAN HIEROGLYPH-13BF3;Lo;0;L;;;;;N;;;;;
+13BF4;EGYPTIAN HIEROGLYPH-13BF4;Lo;0;L;;;;;N;;;;;
+13BF5;EGYPTIAN HIEROGLYPH-13BF5;Lo;0;L;;;;;N;;;;;
+13BF6;EGYPTIAN HIEROGLYPH-13BF6;Lo;0;L;;;;;N;;;;;
+13BF7;EGYPTIAN HIEROGLYPH-13BF7;Lo;0;L;;;;;N;;;;;
+13BF8;EGYPTIAN HIEROGLYPH-13BF8;Lo;0;L;;;;;N;;;;;
+13BF9;EGYPTIAN HIEROGLYPH-13BF9;Lo;0;L;;;;;N;;;;;
+13BFA;EGYPTIAN HIEROGLYPH-13BFA;Lo;0;L;;;;;N;;;;;
+13BFB;EGYPTIAN HIEROGLYPH-13BFB;Lo;0;L;;;;;N;;;;;
+13BFC;EGYPTIAN HIEROGLYPH-13BFC;Lo;0;L;;;;;N;;;;;
+13BFD;EGYPTIAN HIEROGLYPH-13BFD;Lo;0;L;;;;;N;;;;;
+13BFE;EGYPTIAN HIEROGLYPH-13BFE;Lo;0;L;;;;;N;;;;;
+13BFF;EGYPTIAN HIEROGLYPH-13BFF;Lo;0;L;;;;;N;;;;;
+13C00;EGYPTIAN HIEROGLYPH-13C00;Lo;0;L;;;;;N;;;;;
+13C01;EGYPTIAN HIEROGLYPH-13C01;Lo;0;L;;;;;N;;;;;
+13C02;EGYPTIAN HIEROGLYPH-13C02;Lo;0;L;;;;;N;;;;;
+13C03;EGYPTIAN HIEROGLYPH-13C03;Lo;0;L;;;;;N;;;;;
+13C04;EGYPTIAN HIEROGLYPH-13C04;Lo;0;L;;;;;N;;;;;
+13C05;EGYPTIAN HIEROGLYPH-13C05;Lo;0;L;;;;;N;;;;;
+13C06;EGYPTIAN HIEROGLYPH-13C06;Lo;0;L;;;;;N;;;;;
+13C07;EGYPTIAN HIEROGLYPH-13C07;Lo;0;L;;;;;N;;;;;
+13C08;EGYPTIAN HIEROGLYPH-13C08;Lo;0;L;;;;;N;;;;;
+13C09;EGYPTIAN HIEROGLYPH-13C09;Lo;0;L;;;;;N;;;;;
+13C0A;EGYPTIAN HIEROGLYPH-13C0A;Lo;0;L;;;;;N;;;;;
+13C0B;EGYPTIAN HIEROGLYPH-13C0B;Lo;0;L;;;;;N;;;;;
+13C0C;EGYPTIAN HIEROGLYPH-13C0C;Lo;0;L;;;;;N;;;;;
+13C0D;EGYPTIAN HIEROGLYPH-13C0D;Lo;0;L;;;;;N;;;;;
+13C0E;EGYPTIAN HIEROGLYPH-13C0E;Lo;0;L;;;;;N;;;;;
+13C0F;EGYPTIAN HIEROGLYPH-13C0F;Lo;0;L;;;;;N;;;;;
+13C10;EGYPTIAN HIEROGLYPH-13C10;Lo;0;L;;;;;N;;;;;
+13C11;EGYPTIAN HIEROGLYPH-13C11;Lo;0;L;;;;;N;;;;;
+13C12;EGYPTIAN HIEROGLYPH-13C12;Lo;0;L;;;;;N;;;;;
+13C13;EGYPTIAN HIEROGLYPH-13C13;Lo;0;L;;;;;N;;;;;
+13C14;EGYPTIAN HIEROGLYPH-13C14;Lo;0;L;;;;;N;;;;;
+13C15;EGYPTIAN HIEROGLYPH-13C15;Lo;0;L;;;;;N;;;;;
+13C16;EGYPTIAN HIEROGLYPH-13C16;Lo;0;L;;;;;N;;;;;
+13C17;EGYPTIAN HIEROGLYPH-13C17;Lo;0;L;;;;;N;;;;;
+13C18;EGYPTIAN HIEROGLYPH-13C18;Lo;0;L;;;;;N;;;;;
+13C19;EGYPTIAN HIEROGLYPH-13C19;Lo;0;L;;;;;N;;;;;
+13C1A;EGYPTIAN HIEROGLYPH-13C1A;Lo;0;L;;;;;N;;;;;
+13C1B;EGYPTIAN HIEROGLYPH-13C1B;Lo;0;L;;;;;N;;;;;
+13C1C;EGYPTIAN HIEROGLYPH-13C1C;Lo;0;L;;;;;N;;;;;
+13C1D;EGYPTIAN HIEROGLYPH-13C1D;Lo;0;L;;;;;N;;;;;
+13C1E;EGYPTIAN HIEROGLYPH-13C1E;Lo;0;L;;;;;N;;;;;
+13C1F;EGYPTIAN HIEROGLYPH-13C1F;Lo;0;L;;;;;N;;;;;
+13C20;EGYPTIAN HIEROGLYPH-13C20;Lo;0;L;;;;;N;;;;;
+13C21;EGYPTIAN HIEROGLYPH-13C21;Lo;0;L;;;;;N;;;;;
+13C22;EGYPTIAN HIEROGLYPH-13C22;Lo;0;L;;;;;N;;;;;
+13C23;EGYPTIAN HIEROGLYPH-13C23;Lo;0;L;;;;;N;;;;;
+13C24;EGYPTIAN HIEROGLYPH-13C24;Lo;0;L;;;;;N;;;;;
+13C25;EGYPTIAN HIEROGLYPH-13C25;Lo;0;L;;;;;N;;;;;
+13C26;EGYPTIAN HIEROGLYPH-13C26;Lo;0;L;;;;;N;;;;;
+13C27;EGYPTIAN HIEROGLYPH-13C27;Lo;0;L;;;;;N;;;;;
+13C28;EGYPTIAN HIEROGLYPH-13C28;Lo;0;L;;;;;N;;;;;
+13C29;EGYPTIAN HIEROGLYPH-13C29;Lo;0;L;;;;;N;;;;;
+13C2A;EGYPTIAN HIEROGLYPH-13C2A;Lo;0;L;;;;;N;;;;;
+13C2B;EGYPTIAN HIEROGLYPH-13C2B;Lo;0;L;;;;;N;;;;;
+13C2C;EGYPTIAN HIEROGLYPH-13C2C;Lo;0;L;;;;;N;;;;;
+13C2D;EGYPTIAN HIEROGLYPH-13C2D;Lo;0;L;;;;;N;;;;;
+13C2E;EGYPTIAN HIEROGLYPH-13C2E;Lo;0;L;;;;;N;;;;;
+13C2F;EGYPTIAN HIEROGLYPH-13C2F;Lo;0;L;;;;;N;;;;;
+13C30;EGYPTIAN HIEROGLYPH-13C30;Lo;0;L;;;;;N;;;;;
+13C31;EGYPTIAN HIEROGLYPH-13C31;Lo;0;L;;;;;N;;;;;
+13C32;EGYPTIAN HIEROGLYPH-13C32;Lo;0;L;;;;;N;;;;;
+13C33;EGYPTIAN HIEROGLYPH-13C33;Lo;0;L;;;;;N;;;;;
+13C34;EGYPTIAN HIEROGLYPH-13C34;Lo;0;L;;;;;N;;;;;
+13C35;EGYPTIAN HIEROGLYPH-13C35;Lo;0;L;;;;;N;;;;;
+13C36;EGYPTIAN HIEROGLYPH-13C36;Lo;0;L;;;;;N;;;;;
+13C37;EGYPTIAN HIEROGLYPH-13C37;Lo;0;L;;;;;N;;;;;
+13C38;EGYPTIAN HIEROGLYPH-13C38;Lo;0;L;;;;;N;;;;;
+13C39;EGYPTIAN HIEROGLYPH-13C39;Lo;0;L;;;;;N;;;;;
+13C3A;EGYPTIAN HIEROGLYPH-13C3A;Lo;0;L;;;;;N;;;;;
+13C3B;EGYPTIAN HIEROGLYPH-13C3B;Lo;0;L;;;;;N;;;;;
+13C3C;EGYPTIAN HIEROGLYPH-13C3C;Lo;0;L;;;;;N;;;;;
+13C3D;EGYPTIAN HIEROGLYPH-13C3D;Lo;0;L;;;;;N;;;;;
+13C3E;EGYPTIAN HIEROGLYPH-13C3E;Lo;0;L;;;;;N;;;;;
+13C3F;EGYPTIAN HIEROGLYPH-13C3F;Lo;0;L;;;;;N;;;;;
+13C40;EGYPTIAN HIEROGLYPH-13C40;Lo;0;L;;;;;N;;;;;
+13C41;EGYPTIAN HIEROGLYPH-13C41;Lo;0;L;;;;;N;;;;;
+13C42;EGYPTIAN HIEROGLYPH-13C42;Lo;0;L;;;;;N;;;;;
+13C43;EGYPTIAN HIEROGLYPH-13C43;Lo;0;L;;;;;N;;;;;
+13C44;EGYPTIAN HIEROGLYPH-13C44;Lo;0;L;;;;;N;;;;;
+13C45;EGYPTIAN HIEROGLYPH-13C45;Lo;0;L;;;;;N;;;;;
+13C46;EGYPTIAN HIEROGLYPH-13C46;Lo;0;L;;;;;N;;;;;
+13C47;EGYPTIAN HIEROGLYPH-13C47;Lo;0;L;;;;;N;;;;;
+13C48;EGYPTIAN HIEROGLYPH-13C48;Lo;0;L;;;;;N;;;;;
+13C49;EGYPTIAN HIEROGLYPH-13C49;Lo;0;L;;;;;N;;;;;
+13C4A;EGYPTIAN HIEROGLYPH-13C4A;Lo;0;L;;;;;N;;;;;
+13C4B;EGYPTIAN HIEROGLYPH-13C4B;Lo;0;L;;;;;N;;;;;
+13C4C;EGYPTIAN HIEROGLYPH-13C4C;Lo;0;L;;;;;N;;;;;
+13C4D;EGYPTIAN HIEROGLYPH-13C4D;Lo;0;L;;;;;N;;;;;
+13C4E;EGYPTIAN HIEROGLYPH-13C4E;Lo;0;L;;;;;N;;;;;
+13C4F;EGYPTIAN HIEROGLYPH-13C4F;Lo;0;L;;;;;N;;;;;
+13C50;EGYPTIAN HIEROGLYPH-13C50;Lo;0;L;;;;;N;;;;;
+13C51;EGYPTIAN HIEROGLYPH-13C51;Lo;0;L;;;;;N;;;;;
+13C52;EGYPTIAN HIEROGLYPH-13C52;Lo;0;L;;;;;N;;;;;
+13C53;EGYPTIAN HIEROGLYPH-13C53;Lo;0;L;;;;;N;;;;;
+13C54;EGYPTIAN HIEROGLYPH-13C54;Lo;0;L;;;;;N;;;;;
+13C55;EGYPTIAN HIEROGLYPH-13C55;Lo;0;L;;;;;N;;;;;
+13C56;EGYPTIAN HIEROGLYPH-13C56;Lo;0;L;;;;;N;;;;;
+13C57;EGYPTIAN HIEROGLYPH-13C57;Lo;0;L;;;;;N;;;;;
+13C58;EGYPTIAN HIEROGLYPH-13C58;Lo;0;L;;;;;N;;;;;
+13C59;EGYPTIAN HIEROGLYPH-13C59;Lo;0;L;;;;;N;;;;;
+13C5A;EGYPTIAN HIEROGLYPH-13C5A;Lo;0;L;;;;;N;;;;;
+13C5B;EGYPTIAN HIEROGLYPH-13C5B;Lo;0;L;;;;;N;;;;;
+13C5C;EGYPTIAN HIEROGLYPH-13C5C;Lo;0;L;;;;;N;;;;;
+13C5D;EGYPTIAN HIEROGLYPH-13C5D;Lo;0;L;;;;;N;;;;;
+13C5E;EGYPTIAN HIEROGLYPH-13C5E;Lo;0;L;;;;;N;;;;;
+13C5F;EGYPTIAN HIEROGLYPH-13C5F;Lo;0;L;;;;;N;;;;;
+13C60;EGYPTIAN HIEROGLYPH-13C60;Lo;0;L;;;;;N;;;;;
+13C61;EGYPTIAN HIEROGLYPH-13C61;Lo;0;L;;;;;N;;;;;
+13C62;EGYPTIAN HIEROGLYPH-13C62;Lo;0;L;;;;;N;;;;;
+13C63;EGYPTIAN HIEROGLYPH-13C63;Lo;0;L;;;;;N;;;;;
+13C64;EGYPTIAN HIEROGLYPH-13C64;Lo;0;L;;;;;N;;;;;
+13C65;EGYPTIAN HIEROGLYPH-13C65;Lo;0;L;;;;;N;;;;;
+13C66;EGYPTIAN HIEROGLYPH-13C66;Lo;0;L;;;;;N;;;;;
+13C67;EGYPTIAN HIEROGLYPH-13C67;Lo;0;L;;;;;N;;;;;
+13C68;EGYPTIAN HIEROGLYPH-13C68;Lo;0;L;;;;;N;;;;;
+13C69;EGYPTIAN HIEROGLYPH-13C69;Lo;0;L;;;;;N;;;;;
+13C6A;EGYPTIAN HIEROGLYPH-13C6A;Lo;0;L;;;;;N;;;;;
+13C6B;EGYPTIAN HIEROGLYPH-13C6B;Lo;0;L;;;;;N;;;;;
+13C6C;EGYPTIAN HIEROGLYPH-13C6C;Lo;0;L;;;;;N;;;;;
+13C6D;EGYPTIAN HIEROGLYPH-13C6D;Lo;0;L;;;;;N;;;;;
+13C6E;EGYPTIAN HIEROGLYPH-13C6E;Lo;0;L;;;;;N;;;;;
+13C6F;EGYPTIAN HIEROGLYPH-13C6F;Lo;0;L;;;;;N;;;;;
+13C70;EGYPTIAN HIEROGLYPH-13C70;Lo;0;L;;;;;N;;;;;
+13C71;EGYPTIAN HIEROGLYPH-13C71;Lo;0;L;;;;;N;;;;;
+13C72;EGYPTIAN HIEROGLYPH-13C72;Lo;0;L;;;;;N;;;;;
+13C73;EGYPTIAN HIEROGLYPH-13C73;Lo;0;L;;;;;N;;;;;
+13C74;EGYPTIAN HIEROGLYPH-13C74;Lo;0;L;;;;;N;;;;;
+13C75;EGYPTIAN HIEROGLYPH-13C75;Lo;0;L;;;;;N;;;;;
+13C76;EGYPTIAN HIEROGLYPH-13C76;Lo;0;L;;;;;N;;;;;
+13C77;EGYPTIAN HIEROGLYPH-13C77;Lo;0;L;;;;;N;;;;;
+13C78;EGYPTIAN HIEROGLYPH-13C78;Lo;0;L;;;;;N;;;;;
+13C79;EGYPTIAN HIEROGLYPH-13C79;Lo;0;L;;;;;N;;;;;
+13C7A;EGYPTIAN HIEROGLYPH-13C7A;Lo;0;L;;;;;N;;;;;
+13C7B;EGYPTIAN HIEROGLYPH-13C7B;Lo;0;L;;;;;N;;;;;
+13C7C;EGYPTIAN HIEROGLYPH-13C7C;Lo;0;L;;;;;N;;;;;
+13C7D;EGYPTIAN HIEROGLYPH-13C7D;Lo;0;L;;;;;N;;;;;
+13C7E;EGYPTIAN HIEROGLYPH-13C7E;Lo;0;L;;;;;N;;;;;
+13C7F;EGYPTIAN HIEROGLYPH-13C7F;Lo;0;L;;;;;N;;;;;
+13C80;EGYPTIAN HIEROGLYPH-13C80;Lo;0;L;;;;;N;;;;;
+13C81;EGYPTIAN HIEROGLYPH-13C81;Lo;0;L;;;;;N;;;;;
+13C82;EGYPTIAN HIEROGLYPH-13C82;Lo;0;L;;;;;N;;;;;
+13C83;EGYPTIAN HIEROGLYPH-13C83;Lo;0;L;;;;;N;;;;;
+13C84;EGYPTIAN HIEROGLYPH-13C84;Lo;0;L;;;;;N;;;;;
+13C85;EGYPTIAN HIEROGLYPH-13C85;Lo;0;L;;;;;N;;;;;
+13C86;EGYPTIAN HIEROGLYPH-13C86;Lo;0;L;;;;;N;;;;;
+13C87;EGYPTIAN HIEROGLYPH-13C87;Lo;0;L;;;;;N;;;;;
+13C88;EGYPTIAN HIEROGLYPH-13C88;Lo;0;L;;;;;N;;;;;
+13C89;EGYPTIAN HIEROGLYPH-13C89;Lo;0;L;;;;;N;;;;;
+13C8A;EGYPTIAN HIEROGLYPH-13C8A;Lo;0;L;;;;;N;;;;;
+13C8B;EGYPTIAN HIEROGLYPH-13C8B;Lo;0;L;;;;;N;;;;;
+13C8C;EGYPTIAN HIEROGLYPH-13C8C;Lo;0;L;;;;;N;;;;;
+13C8D;EGYPTIAN HIEROGLYPH-13C8D;Lo;0;L;;;;;N;;;;;
+13C8E;EGYPTIAN HIEROGLYPH-13C8E;Lo;0;L;;;;;N;;;;;
+13C8F;EGYPTIAN HIEROGLYPH-13C8F;Lo;0;L;;;;;N;;;;;
+13C90;EGYPTIAN HIEROGLYPH-13C90;Lo;0;L;;;;;N;;;;;
+13C91;EGYPTIAN HIEROGLYPH-13C91;Lo;0;L;;;;;N;;;;;
+13C92;EGYPTIAN HIEROGLYPH-13C92;Lo;0;L;;;;;N;;;;;
+13C93;EGYPTIAN HIEROGLYPH-13C93;Lo;0;L;;;;;N;;;;;
+13C94;EGYPTIAN HIEROGLYPH-13C94;Lo;0;L;;;;;N;;;;;
+13C95;EGYPTIAN HIEROGLYPH-13C95;Lo;0;L;;;;;N;;;;;
+13C96;EGYPTIAN HIEROGLYPH-13C96;Lo;0;L;;;;;N;;;;;
+13C97;EGYPTIAN HIEROGLYPH-13C97;Lo;0;L;;;;;N;;;;;
+13C98;EGYPTIAN HIEROGLYPH-13C98;Lo;0;L;;;;;N;;;;;
+13C99;EGYPTIAN HIEROGLYPH-13C99;Lo;0;L;;;;;N;;;;;
+13C9A;EGYPTIAN HIEROGLYPH-13C9A;Lo;0;L;;;;;N;;;;;
+13C9B;EGYPTIAN HIEROGLYPH-13C9B;Lo;0;L;;;;;N;;;;;
+13C9C;EGYPTIAN HIEROGLYPH-13C9C;Lo;0;L;;;;;N;;;;;
+13C9D;EGYPTIAN HIEROGLYPH-13C9D;Lo;0;L;;;;;N;;;;;
+13C9E;EGYPTIAN HIEROGLYPH-13C9E;Lo;0;L;;;;;N;;;;;
+13C9F;EGYPTIAN HIEROGLYPH-13C9F;Lo;0;L;;;;;N;;;;;
+13CA0;EGYPTIAN HIEROGLYPH-13CA0;Lo;0;L;;;;;N;;;;;
+13CA1;EGYPTIAN HIEROGLYPH-13CA1;Lo;0;L;;;;;N;;;;;
+13CA2;EGYPTIAN HIEROGLYPH-13CA2;Lo;0;L;;;;;N;;;;;
+13CA3;EGYPTIAN HIEROGLYPH-13CA3;Lo;0;L;;;;;N;;;;;
+13CA4;EGYPTIAN HIEROGLYPH-13CA4;Lo;0;L;;;;;N;;;;;
+13CA5;EGYPTIAN HIEROGLYPH-13CA5;Lo;0;L;;;;;N;;;;;
+13CA6;EGYPTIAN HIEROGLYPH-13CA6;Lo;0;L;;;;;N;;;;;
+13CA7;EGYPTIAN HIEROGLYPH-13CA7;Lo;0;L;;;;;N;;;;;
+13CA8;EGYPTIAN HIEROGLYPH-13CA8;Lo;0;L;;;;;N;;;;;
+13CA9;EGYPTIAN HIEROGLYPH-13CA9;Lo;0;L;;;;;N;;;;;
+13CAA;EGYPTIAN HIEROGLYPH-13CAA;Lo;0;L;;;;;N;;;;;
+13CAB;EGYPTIAN HIEROGLYPH-13CAB;Lo;0;L;;;;;N;;;;;
+13CAC;EGYPTIAN HIEROGLYPH-13CAC;Lo;0;L;;;;;N;;;;;
+13CAD;EGYPTIAN HIEROGLYPH-13CAD;Lo;0;L;;;;;N;;;;;
+13CAE;EGYPTIAN HIEROGLYPH-13CAE;Lo;0;L;;;;;N;;;;;
+13CAF;EGYPTIAN HIEROGLYPH-13CAF;Lo;0;L;;;;;N;;;;;
+13CB0;EGYPTIAN HIEROGLYPH-13CB0;Lo;0;L;;;;;N;;;;;
+13CB1;EGYPTIAN HIEROGLYPH-13CB1;Lo;0;L;;;;;N;;;;;
+13CB2;EGYPTIAN HIEROGLYPH-13CB2;Lo;0;L;;;;;N;;;;;
+13CB3;EGYPTIAN HIEROGLYPH-13CB3;Lo;0;L;;;;;N;;;;;
+13CB4;EGYPTIAN HIEROGLYPH-13CB4;Lo;0;L;;;;;N;;;;;
+13CB5;EGYPTIAN HIEROGLYPH-13CB5;Lo;0;L;;;;;N;;;;;
+13CB6;EGYPTIAN HIEROGLYPH-13CB6;Lo;0;L;;;;;N;;;;;
+13CB7;EGYPTIAN HIEROGLYPH-13CB7;Lo;0;L;;;;;N;;;;;
+13CB8;EGYPTIAN HIEROGLYPH-13CB8;Lo;0;L;;;;;N;;;;;
+13CB9;EGYPTIAN HIEROGLYPH-13CB9;Lo;0;L;;;;;N;;;;;
+13CBA;EGYPTIAN HIEROGLYPH-13CBA;Lo;0;L;;;;;N;;;;;
+13CBB;EGYPTIAN HIEROGLYPH-13CBB;Lo;0;L;;;;;N;;;;;
+13CBC;EGYPTIAN HIEROGLYPH-13CBC;Lo;0;L;;;;;N;;;;;
+13CBD;EGYPTIAN HIEROGLYPH-13CBD;Lo;0;L;;;;;N;;;;;
+13CBE;EGYPTIAN HIEROGLYPH-13CBE;Lo;0;L;;;;;N;;;;;
+13CBF;EGYPTIAN HIEROGLYPH-13CBF;Lo;0;L;;;;;N;;;;;
+13CC0;EGYPTIAN HIEROGLYPH-13CC0;Lo;0;L;;;;;N;;;;;
+13CC1;EGYPTIAN HIEROGLYPH-13CC1;Lo;0;L;;;;;N;;;;;
+13CC2;EGYPTIAN HIEROGLYPH-13CC2;Lo;0;L;;;;;N;;;;;
+13CC3;EGYPTIAN HIEROGLYPH-13CC3;Lo;0;L;;;;;N;;;;;
+13CC4;EGYPTIAN HIEROGLYPH-13CC4;Lo;0;L;;;;;N;;;;;
+13CC5;EGYPTIAN HIEROGLYPH-13CC5;Lo;0;L;;;;;N;;;;;
+13CC6;EGYPTIAN HIEROGLYPH-13CC6;Lo;0;L;;;;;N;;;;;
+13CC7;EGYPTIAN HIEROGLYPH-13CC7;Lo;0;L;;;;;N;;;;;
+13CC8;EGYPTIAN HIEROGLYPH-13CC8;Lo;0;L;;;;;N;;;;;
+13CC9;EGYPTIAN HIEROGLYPH-13CC9;Lo;0;L;;;;;N;;;;;
+13CCA;EGYPTIAN HIEROGLYPH-13CCA;Lo;0;L;;;;;N;;;;;
+13CCB;EGYPTIAN HIEROGLYPH-13CCB;Lo;0;L;;;;;N;;;;;
+13CCC;EGYPTIAN HIEROGLYPH-13CCC;Lo;0;L;;;;;N;;;;;
+13CCD;EGYPTIAN HIEROGLYPH-13CCD;Lo;0;L;;;;;N;;;;;
+13CCE;EGYPTIAN HIEROGLYPH-13CCE;Lo;0;L;;;;;N;;;;;
+13CCF;EGYPTIAN HIEROGLYPH-13CCF;Lo;0;L;;;;;N;;;;;
+13CD0;EGYPTIAN HIEROGLYPH-13CD0;Lo;0;L;;;;;N;;;;;
+13CD1;EGYPTIAN HIEROGLYPH-13CD1;Lo;0;L;;;;;N;;;;;
+13CD2;EGYPTIAN HIEROGLYPH-13CD2;Lo;0;L;;;;;N;;;;;
+13CD3;EGYPTIAN HIEROGLYPH-13CD3;Lo;0;L;;;;;N;;;;;
+13CD4;EGYPTIAN HIEROGLYPH-13CD4;Lo;0;L;;;;;N;;;;;
+13CD5;EGYPTIAN HIEROGLYPH-13CD5;Lo;0;L;;;;;N;;;;;
+13CD6;EGYPTIAN HIEROGLYPH-13CD6;Lo;0;L;;;;;N;;;;;
+13CD7;EGYPTIAN HIEROGLYPH-13CD7;Lo;0;L;;;;;N;;;;;
+13CD8;EGYPTIAN HIEROGLYPH-13CD8;Lo;0;L;;;;;N;;;;;
+13CD9;EGYPTIAN HIEROGLYPH-13CD9;Lo;0;L;;;;;N;;;;;
+13CDA;EGYPTIAN HIEROGLYPH-13CDA;Lo;0;L;;;;;N;;;;;
+13CDB;EGYPTIAN HIEROGLYPH-13CDB;Lo;0;L;;;;;N;;;;;
+13CDC;EGYPTIAN HIEROGLYPH-13CDC;Lo;0;L;;;;;N;;;;;
+13CDD;EGYPTIAN HIEROGLYPH-13CDD;Lo;0;L;;;;;N;;;;;
+13CDE;EGYPTIAN HIEROGLYPH-13CDE;Lo;0;L;;;;;N;;;;;
+13CDF;EGYPTIAN HIEROGLYPH-13CDF;Lo;0;L;;;;;N;;;;;
+13CE0;EGYPTIAN HIEROGLYPH-13CE0;Lo;0;L;;;;;N;;;;;
+13CE1;EGYPTIAN HIEROGLYPH-13CE1;Lo;0;L;;;;;N;;;;;
+13CE2;EGYPTIAN HIEROGLYPH-13CE2;Lo;0;L;;;;;N;;;;;
+13CE3;EGYPTIAN HIEROGLYPH-13CE3;Lo;0;L;;;;;N;;;;;
+13CE4;EGYPTIAN HIEROGLYPH-13CE4;Lo;0;L;;;;;N;;;;;
+13CE5;EGYPTIAN HIEROGLYPH-13CE5;Lo;0;L;;;;;N;;;;;
+13CE6;EGYPTIAN HIEROGLYPH-13CE6;Lo;0;L;;;;;N;;;;;
+13CE7;EGYPTIAN HIEROGLYPH-13CE7;Lo;0;L;;;;;N;;;;;
+13CE8;EGYPTIAN HIEROGLYPH-13CE8;Lo;0;L;;;;;N;;;;;
+13CE9;EGYPTIAN HIEROGLYPH-13CE9;Lo;0;L;;;;;N;;;;;
+13CEA;EGYPTIAN HIEROGLYPH-13CEA;Lo;0;L;;;;;N;;;;;
+13CEB;EGYPTIAN HIEROGLYPH-13CEB;Lo;0;L;;;;;N;;;;;
+13CEC;EGYPTIAN HIEROGLYPH-13CEC;Lo;0;L;;;;;N;;;;;
+13CED;EGYPTIAN HIEROGLYPH-13CED;Lo;0;L;;;;;N;;;;;
+13CEE;EGYPTIAN HIEROGLYPH-13CEE;Lo;0;L;;;;;N;;;;;
+13CEF;EGYPTIAN HIEROGLYPH-13CEF;Lo;0;L;;;;;N;;;;;
+13CF0;EGYPTIAN HIEROGLYPH-13CF0;Lo;0;L;;;;;N;;;;;
+13CF1;EGYPTIAN HIEROGLYPH-13CF1;Lo;0;L;;;;;N;;;;;
+13CF2;EGYPTIAN HIEROGLYPH-13CF2;Lo;0;L;;;;;N;;;;;
+13CF3;EGYPTIAN HIEROGLYPH-13CF3;Lo;0;L;;;;;N;;;;;
+13CF4;EGYPTIAN HIEROGLYPH-13CF4;Lo;0;L;;;;;N;;;;;
+13CF5;EGYPTIAN HIEROGLYPH-13CF5;Lo;0;L;;;;;N;;;;;
+13CF6;EGYPTIAN HIEROGLYPH-13CF6;Lo;0;L;;;;;N;;;;;
+13CF7;EGYPTIAN HIEROGLYPH-13CF7;Lo;0;L;;;;;N;;;;;
+13CF8;EGYPTIAN HIEROGLYPH-13CF8;Lo;0;L;;;;;N;;;;;
+13CF9;EGYPTIAN HIEROGLYPH-13CF9;Lo;0;L;;;;;N;;;;;
+13CFA;EGYPTIAN HIEROGLYPH-13CFA;Lo;0;L;;;;;N;;;;;
+13CFB;EGYPTIAN HIEROGLYPH-13CFB;Lo;0;L;;;;;N;;;;;
+13CFC;EGYPTIAN HIEROGLYPH-13CFC;Lo;0;L;;;;;N;;;;;
+13CFD;EGYPTIAN HIEROGLYPH-13CFD;Lo;0;L;;;;;N;;;;;
+13CFE;EGYPTIAN HIEROGLYPH-13CFE;Lo;0;L;;;;;N;;;;;
+13CFF;EGYPTIAN HIEROGLYPH-13CFF;Lo;0;L;;;;;N;;;;;
+13D00;EGYPTIAN HIEROGLYPH-13D00;Lo;0;L;;;;;N;;;;;
+13D01;EGYPTIAN HIEROGLYPH-13D01;Lo;0;L;;;;;N;;;;;
+13D02;EGYPTIAN HIEROGLYPH-13D02;Lo;0;L;;;;;N;;;;;
+13D03;EGYPTIAN HIEROGLYPH-13D03;Lo;0;L;;;;;N;;;;;
+13D04;EGYPTIAN HIEROGLYPH-13D04;Lo;0;L;;;;;N;;;;;
+13D05;EGYPTIAN HIEROGLYPH-13D05;Lo;0;L;;;;;N;;;;;
+13D06;EGYPTIAN HIEROGLYPH-13D06;Lo;0;L;;;;;N;;;;;
+13D07;EGYPTIAN HIEROGLYPH-13D07;Lo;0;L;;;;;N;;;;;
+13D08;EGYPTIAN HIEROGLYPH-13D08;Lo;0;L;;;;;N;;;;;
+13D09;EGYPTIAN HIEROGLYPH-13D09;Lo;0;L;;;;;N;;;;;
+13D0A;EGYPTIAN HIEROGLYPH-13D0A;Lo;0;L;;;;;N;;;;;
+13D0B;EGYPTIAN HIEROGLYPH-13D0B;Lo;0;L;;;;;N;;;;;
+13D0C;EGYPTIAN HIEROGLYPH-13D0C;Lo;0;L;;;;;N;;;;;
+13D0D;EGYPTIAN HIEROGLYPH-13D0D;Lo;0;L;;;;;N;;;;;
+13D0E;EGYPTIAN HIEROGLYPH-13D0E;Lo;0;L;;;;;N;;;;;
+13D0F;EGYPTIAN HIEROGLYPH-13D0F;Lo;0;L;;;;;N;;;;;
+13D10;EGYPTIAN HIEROGLYPH-13D10;Lo;0;L;;;;;N;;;;;
+13D11;EGYPTIAN HIEROGLYPH-13D11;Lo;0;L;;;;;N;;;;;
+13D12;EGYPTIAN HIEROGLYPH-13D12;Lo;0;L;;;;;N;;;;;
+13D13;EGYPTIAN HIEROGLYPH-13D13;Lo;0;L;;;;;N;;;;;
+13D14;EGYPTIAN HIEROGLYPH-13D14;Lo;0;L;;;;;N;;;;;
+13D15;EGYPTIAN HIEROGLYPH-13D15;Lo;0;L;;;;;N;;;;;
+13D16;EGYPTIAN HIEROGLYPH-13D16;Lo;0;L;;;;;N;;;;;
+13D17;EGYPTIAN HIEROGLYPH-13D17;Lo;0;L;;;;;N;;;;;
+13D18;EGYPTIAN HIEROGLYPH-13D18;Lo;0;L;;;;;N;;;;;
+13D19;EGYPTIAN HIEROGLYPH-13D19;Lo;0;L;;;;;N;;;;;
+13D1A;EGYPTIAN HIEROGLYPH-13D1A;Lo;0;L;;;;;N;;;;;
+13D1B;EGYPTIAN HIEROGLYPH-13D1B;Lo;0;L;;;;;N;;;;;
+13D1C;EGYPTIAN HIEROGLYPH-13D1C;Lo;0;L;;;;;N;;;;;
+13D1D;EGYPTIAN HIEROGLYPH-13D1D;Lo;0;L;;;;;N;;;;;
+13D1E;EGYPTIAN HIEROGLYPH-13D1E;Lo;0;L;;;;;N;;;;;
+13D1F;EGYPTIAN HIEROGLYPH-13D1F;Lo;0;L;;;;;N;;;;;
+13D20;EGYPTIAN HIEROGLYPH-13D20;Lo;0;L;;;;;N;;;;;
+13D21;EGYPTIAN HIEROGLYPH-13D21;Lo;0;L;;;;;N;;;;;
+13D22;EGYPTIAN HIEROGLYPH-13D22;Lo;0;L;;;;;N;;;;;
+13D23;EGYPTIAN HIEROGLYPH-13D23;Lo;0;L;;;;;N;;;;;
+13D24;EGYPTIAN HIEROGLYPH-13D24;Lo;0;L;;;;;N;;;;;
+13D25;EGYPTIAN HIEROGLYPH-13D25;Lo;0;L;;;;;N;;;;;
+13D26;EGYPTIAN HIEROGLYPH-13D26;Lo;0;L;;;;;N;;;;;
+13D27;EGYPTIAN HIEROGLYPH-13D27;Lo;0;L;;;;;N;;;;;
+13D28;EGYPTIAN HIEROGLYPH-13D28;Lo;0;L;;;;;N;;;;;
+13D29;EGYPTIAN HIEROGLYPH-13D29;Lo;0;L;;;;;N;;;;;
+13D2A;EGYPTIAN HIEROGLYPH-13D2A;Lo;0;L;;;;;N;;;;;
+13D2B;EGYPTIAN HIEROGLYPH-13D2B;Lo;0;L;;;;;N;;;;;
+13D2C;EGYPTIAN HIEROGLYPH-13D2C;Lo;0;L;;;;;N;;;;;
+13D2D;EGYPTIAN HIEROGLYPH-13D2D;Lo;0;L;;;;;N;;;;;
+13D2E;EGYPTIAN HIEROGLYPH-13D2E;Lo;0;L;;;;;N;;;;;
+13D2F;EGYPTIAN HIEROGLYPH-13D2F;Lo;0;L;;;;;N;;;;;
+13D30;EGYPTIAN HIEROGLYPH-13D30;Lo;0;L;;;;;N;;;;;
+13D31;EGYPTIAN HIEROGLYPH-13D31;Lo;0;L;;;;;N;;;;;
+13D32;EGYPTIAN HIEROGLYPH-13D32;Lo;0;L;;;;;N;;;;;
+13D33;EGYPTIAN HIEROGLYPH-13D33;Lo;0;L;;;;;N;;;;;
+13D34;EGYPTIAN HIEROGLYPH-13D34;Lo;0;L;;;;;N;;;;;
+13D35;EGYPTIAN HIEROGLYPH-13D35;Lo;0;L;;;;;N;;;;;
+13D36;EGYPTIAN HIEROGLYPH-13D36;Lo;0;L;;;;;N;;;;;
+13D37;EGYPTIAN HIEROGLYPH-13D37;Lo;0;L;;;;;N;;;;;
+13D38;EGYPTIAN HIEROGLYPH-13D38;Lo;0;L;;;;;N;;;;;
+13D39;EGYPTIAN HIEROGLYPH-13D39;Lo;0;L;;;;;N;;;;;
+13D3A;EGYPTIAN HIEROGLYPH-13D3A;Lo;0;L;;;;;N;;;;;
+13D3B;EGYPTIAN HIEROGLYPH-13D3B;Lo;0;L;;;;;N;;;;;
+13D3C;EGYPTIAN HIEROGLYPH-13D3C;Lo;0;L;;;;;N;;;;;
+13D3D;EGYPTIAN HIEROGLYPH-13D3D;Lo;0;L;;;;;N;;;;;
+13D3E;EGYPTIAN HIEROGLYPH-13D3E;Lo;0;L;;;;;N;;;;;
+13D3F;EGYPTIAN HIEROGLYPH-13D3F;Lo;0;L;;;;;N;;;;;
+13D40;EGYPTIAN HIEROGLYPH-13D40;Lo;0;L;;;;;N;;;;;
+13D41;EGYPTIAN HIEROGLYPH-13D41;Lo;0;L;;;;;N;;;;;
+13D42;EGYPTIAN HIEROGLYPH-13D42;Lo;0;L;;;;;N;;;;;
+13D43;EGYPTIAN HIEROGLYPH-13D43;Lo;0;L;;;;;N;;;;;
+13D44;EGYPTIAN HIEROGLYPH-13D44;Lo;0;L;;;;;N;;;;;
+13D45;EGYPTIAN HIEROGLYPH-13D45;Lo;0;L;;;;;N;;;;;
+13D46;EGYPTIAN HIEROGLYPH-13D46;Lo;0;L;;;;;N;;;;;
+13D47;EGYPTIAN HIEROGLYPH-13D47;Lo;0;L;;;;;N;;;;;
+13D48;EGYPTIAN HIEROGLYPH-13D48;Lo;0;L;;;;;N;;;;;
+13D49;EGYPTIAN HIEROGLYPH-13D49;Lo;0;L;;;;;N;;;;;
+13D4A;EGYPTIAN HIEROGLYPH-13D4A;Lo;0;L;;;;;N;;;;;
+13D4B;EGYPTIAN HIEROGLYPH-13D4B;Lo;0;L;;;;;N;;;;;
+13D4C;EGYPTIAN HIEROGLYPH-13D4C;Lo;0;L;;;;;N;;;;;
+13D4D;EGYPTIAN HIEROGLYPH-13D4D;Lo;0;L;;;;;N;;;;;
+13D4E;EGYPTIAN HIEROGLYPH-13D4E;Lo;0;L;;;;;N;;;;;
+13D4F;EGYPTIAN HIEROGLYPH-13D4F;Lo;0;L;;;;;N;;;;;
+13D50;EGYPTIAN HIEROGLYPH-13D50;Lo;0;L;;;;;N;;;;;
+13D51;EGYPTIAN HIEROGLYPH-13D51;Lo;0;L;;;;;N;;;;;
+13D52;EGYPTIAN HIEROGLYPH-13D52;Lo;0;L;;;;;N;;;;;
+13D53;EGYPTIAN HIEROGLYPH-13D53;Lo;0;L;;;;;N;;;;;
+13D54;EGYPTIAN HIEROGLYPH-13D54;Lo;0;L;;;;;N;;;;;
+13D55;EGYPTIAN HIEROGLYPH-13D55;Lo;0;L;;;;;N;;;;;
+13D56;EGYPTIAN HIEROGLYPH-13D56;Lo;0;L;;;;;N;;;;;
+13D57;EGYPTIAN HIEROGLYPH-13D57;Lo;0;L;;;;;N;;;;;
+13D58;EGYPTIAN HIEROGLYPH-13D58;Lo;0;L;;;;;N;;;;;
+13D59;EGYPTIAN HIEROGLYPH-13D59;Lo;0;L;;;;;N;;;;;
+13D5A;EGYPTIAN HIEROGLYPH-13D5A;Lo;0;L;;;;;N;;;;;
+13D5B;EGYPTIAN HIEROGLYPH-13D5B;Lo;0;L;;;;;N;;;;;
+13D5C;EGYPTIAN HIEROGLYPH-13D5C;Lo;0;L;;;;;N;;;;;
+13D5D;EGYPTIAN HIEROGLYPH-13D5D;Lo;0;L;;;;;N;;;;;
+13D5E;EGYPTIAN HIEROGLYPH-13D5E;Lo;0;L;;;;;N;;;;;
+13D5F;EGYPTIAN HIEROGLYPH-13D5F;Lo;0;L;;;;;N;;;;;
+13D60;EGYPTIAN HIEROGLYPH-13D60;Lo;0;L;;;;;N;;;;;
+13D61;EGYPTIAN HIEROGLYPH-13D61;Lo;0;L;;;;;N;;;;;
+13D62;EGYPTIAN HIEROGLYPH-13D62;Lo;0;L;;;;;N;;;;;
+13D63;EGYPTIAN HIEROGLYPH-13D63;Lo;0;L;;;;;N;;;;;
+13D64;EGYPTIAN HIEROGLYPH-13D64;Lo;0;L;;;;;N;;;;;
+13D65;EGYPTIAN HIEROGLYPH-13D65;Lo;0;L;;;;;N;;;;;
+13D66;EGYPTIAN HIEROGLYPH-13D66;Lo;0;L;;;;;N;;;;;
+13D67;EGYPTIAN HIEROGLYPH-13D67;Lo;0;L;;;;;N;;;;;
+13D68;EGYPTIAN HIEROGLYPH-13D68;Lo;0;L;;;;;N;;;;;
+13D69;EGYPTIAN HIEROGLYPH-13D69;Lo;0;L;;;;;N;;;;;
+13D6A;EGYPTIAN HIEROGLYPH-13D6A;Lo;0;L;;;;;N;;;;;
+13D6B;EGYPTIAN HIEROGLYPH-13D6B;Lo;0;L;;;;;N;;;;;
+13D6C;EGYPTIAN HIEROGLYPH-13D6C;Lo;0;L;;;;;N;;;;;
+13D6D;EGYPTIAN HIEROGLYPH-13D6D;Lo;0;L;;;;;N;;;;;
+13D6E;EGYPTIAN HIEROGLYPH-13D6E;Lo;0;L;;;;;N;;;;;
+13D6F;EGYPTIAN HIEROGLYPH-13D6F;Lo;0;L;;;;;N;;;;;
+13D70;EGYPTIAN HIEROGLYPH-13D70;Lo;0;L;;;;;N;;;;;
+13D71;EGYPTIAN HIEROGLYPH-13D71;Lo;0;L;;;;;N;;;;;
+13D72;EGYPTIAN HIEROGLYPH-13D72;Lo;0;L;;;;;N;;;;;
+13D73;EGYPTIAN HIEROGLYPH-13D73;Lo;0;L;;;;;N;;;;;
+13D74;EGYPTIAN HIEROGLYPH-13D74;Lo;0;L;;;;;N;;;;;
+13D75;EGYPTIAN HIEROGLYPH-13D75;Lo;0;L;;;;;N;;;;;
+13D76;EGYPTIAN HIEROGLYPH-13D76;Lo;0;L;;;;;N;;;;;
+13D77;EGYPTIAN HIEROGLYPH-13D77;Lo;0;L;;;;;N;;;;;
+13D78;EGYPTIAN HIEROGLYPH-13D78;Lo;0;L;;;;;N;;;;;
+13D79;EGYPTIAN HIEROGLYPH-13D79;Lo;0;L;;;;;N;;;;;
+13D7A;EGYPTIAN HIEROGLYPH-13D7A;Lo;0;L;;;;;N;;;;;
+13D7B;EGYPTIAN HIEROGLYPH-13D7B;Lo;0;L;;;;;N;;;;;
+13D7C;EGYPTIAN HIEROGLYPH-13D7C;Lo;0;L;;;;;N;;;;;
+13D7D;EGYPTIAN HIEROGLYPH-13D7D;Lo;0;L;;;;;N;;;;;
+13D7E;EGYPTIAN HIEROGLYPH-13D7E;Lo;0;L;;;;;N;;;;;
+13D7F;EGYPTIAN HIEROGLYPH-13D7F;Lo;0;L;;;;;N;;;;;
+13D80;EGYPTIAN HIEROGLYPH-13D80;Lo;0;L;;;;;N;;;;;
+13D81;EGYPTIAN HIEROGLYPH-13D81;Lo;0;L;;;;;N;;;;;
+13D82;EGYPTIAN HIEROGLYPH-13D82;Lo;0;L;;;;;N;;;;;
+13D83;EGYPTIAN HIEROGLYPH-13D83;Lo;0;L;;;;;N;;;;;
+13D84;EGYPTIAN HIEROGLYPH-13D84;Lo;0;L;;;;;N;;;;;
+13D85;EGYPTIAN HIEROGLYPH-13D85;Lo;0;L;;;;;N;;;;;
+13D86;EGYPTIAN HIEROGLYPH-13D86;Lo;0;L;;;;;N;;;;;
+13D87;EGYPTIAN HIEROGLYPH-13D87;Lo;0;L;;;;;N;;;;;
+13D88;EGYPTIAN HIEROGLYPH-13D88;Lo;0;L;;;;;N;;;;;
+13D89;EGYPTIAN HIEROGLYPH-13D89;Lo;0;L;;;;;N;;;;;
+13D8A;EGYPTIAN HIEROGLYPH-13D8A;Lo;0;L;;;;;N;;;;;
+13D8B;EGYPTIAN HIEROGLYPH-13D8B;Lo;0;L;;;;;N;;;;;
+13D8C;EGYPTIAN HIEROGLYPH-13D8C;Lo;0;L;;;;;N;;;;;
+13D8D;EGYPTIAN HIEROGLYPH-13D8D;Lo;0;L;;;;;N;;;;;
+13D8E;EGYPTIAN HIEROGLYPH-13D8E;Lo;0;L;;;;;N;;;;;
+13D8F;EGYPTIAN HIEROGLYPH-13D8F;Lo;0;L;;;;;N;;;;;
+13D90;EGYPTIAN HIEROGLYPH-13D90;Lo;0;L;;;;;N;;;;;
+13D91;EGYPTIAN HIEROGLYPH-13D91;Lo;0;L;;;;;N;;;;;
+13D92;EGYPTIAN HIEROGLYPH-13D92;Lo;0;L;;;;;N;;;;;
+13D93;EGYPTIAN HIEROGLYPH-13D93;Lo;0;L;;;;;N;;;;;
+13D94;EGYPTIAN HIEROGLYPH-13D94;Lo;0;L;;;;;N;;;;;
+13D95;EGYPTIAN HIEROGLYPH-13D95;Lo;0;L;;;;;N;;;;;
+13D96;EGYPTIAN HIEROGLYPH-13D96;Lo;0;L;;;;;N;;;;;
+13D97;EGYPTIAN HIEROGLYPH-13D97;Lo;0;L;;;;;N;;;;;
+13D98;EGYPTIAN HIEROGLYPH-13D98;Lo;0;L;;;;;N;;;;;
+13D99;EGYPTIAN HIEROGLYPH-13D99;Lo;0;L;;;;;N;;;;;
+13D9A;EGYPTIAN HIEROGLYPH-13D9A;Lo;0;L;;;;;N;;;;;
+13D9B;EGYPTIAN HIEROGLYPH-13D9B;Lo;0;L;;;;;N;;;;;
+13D9C;EGYPTIAN HIEROGLYPH-13D9C;Lo;0;L;;;;;N;;;;;
+13D9D;EGYPTIAN HIEROGLYPH-13D9D;Lo;0;L;;;;;N;;;;;
+13D9E;EGYPTIAN HIEROGLYPH-13D9E;Lo;0;L;;;;;N;;;;;
+13D9F;EGYPTIAN HIEROGLYPH-13D9F;Lo;0;L;;;;;N;;;;;
+13DA0;EGYPTIAN HIEROGLYPH-13DA0;Lo;0;L;;;;;N;;;;;
+13DA1;EGYPTIAN HIEROGLYPH-13DA1;Lo;0;L;;;;;N;;;;;
+13DA2;EGYPTIAN HIEROGLYPH-13DA2;Lo;0;L;;;;;N;;;;;
+13DA3;EGYPTIAN HIEROGLYPH-13DA3;Lo;0;L;;;;;N;;;;;
+13DA4;EGYPTIAN HIEROGLYPH-13DA4;Lo;0;L;;;;;N;;;;;
+13DA5;EGYPTIAN HIEROGLYPH-13DA5;Lo;0;L;;;;;N;;;;;
+13DA6;EGYPTIAN HIEROGLYPH-13DA6;Lo;0;L;;;;;N;;;;;
+13DA7;EGYPTIAN HIEROGLYPH-13DA7;Lo;0;L;;;;;N;;;;;
+13DA8;EGYPTIAN HIEROGLYPH-13DA8;Lo;0;L;;;;;N;;;;;
+13DA9;EGYPTIAN HIEROGLYPH-13DA9;Lo;0;L;;;;;N;;;;;
+13DAA;EGYPTIAN HIEROGLYPH-13DAA;Lo;0;L;;;;;N;;;;;
+13DAB;EGYPTIAN HIEROGLYPH-13DAB;Lo;0;L;;;;;N;;;;;
+13DAC;EGYPTIAN HIEROGLYPH-13DAC;Lo;0;L;;;;;N;;;;;
+13DAD;EGYPTIAN HIEROGLYPH-13DAD;Lo;0;L;;;;;N;;;;;
+13DAE;EGYPTIAN HIEROGLYPH-13DAE;Lo;0;L;;;;;N;;;;;
+13DAF;EGYPTIAN HIEROGLYPH-13DAF;Lo;0;L;;;;;N;;;;;
+13DB0;EGYPTIAN HIEROGLYPH-13DB0;Lo;0;L;;;;;N;;;;;
+13DB1;EGYPTIAN HIEROGLYPH-13DB1;Lo;0;L;;;;;N;;;;;
+13DB2;EGYPTIAN HIEROGLYPH-13DB2;Lo;0;L;;;;;N;;;;;
+13DB3;EGYPTIAN HIEROGLYPH-13DB3;Lo;0;L;;;;;N;;;;;
+13DB4;EGYPTIAN HIEROGLYPH-13DB4;Lo;0;L;;;;;N;;;;;
+13DB5;EGYPTIAN HIEROGLYPH-13DB5;Lo;0;L;;;;;N;;;;;
+13DB6;EGYPTIAN HIEROGLYPH-13DB6;Lo;0;L;;;;;N;;;;;
+13DB7;EGYPTIAN HIEROGLYPH-13DB7;Lo;0;L;;;;;N;;;;;
+13DB8;EGYPTIAN HIEROGLYPH-13DB8;Lo;0;L;;;;;N;;;;;
+13DB9;EGYPTIAN HIEROGLYPH-13DB9;Lo;0;L;;;;;N;;;;;
+13DBA;EGYPTIAN HIEROGLYPH-13DBA;Lo;0;L;;;;;N;;;;;
+13DBB;EGYPTIAN HIEROGLYPH-13DBB;Lo;0;L;;;;;N;;;;;
+13DBC;EGYPTIAN HIEROGLYPH-13DBC;Lo;0;L;;;;;N;;;;;
+13DBD;EGYPTIAN HIEROGLYPH-13DBD;Lo;0;L;;;;;N;;;;;
+13DBE;EGYPTIAN HIEROGLYPH-13DBE;Lo;0;L;;;;;N;;;;;
+13DBF;EGYPTIAN HIEROGLYPH-13DBF;Lo;0;L;;;;;N;;;;;
+13DC0;EGYPTIAN HIEROGLYPH-13DC0;Lo;0;L;;;;;N;;;;;
+13DC1;EGYPTIAN HIEROGLYPH-13DC1;Lo;0;L;;;;;N;;;;;
+13DC2;EGYPTIAN HIEROGLYPH-13DC2;Lo;0;L;;;;;N;;;;;
+13DC3;EGYPTIAN HIEROGLYPH-13DC3;Lo;0;L;;;;;N;;;;;
+13DC4;EGYPTIAN HIEROGLYPH-13DC4;Lo;0;L;;;;;N;;;;;
+13DC5;EGYPTIAN HIEROGLYPH-13DC5;Lo;0;L;;;;;N;;;;;
+13DC6;EGYPTIAN HIEROGLYPH-13DC6;Lo;0;L;;;;;N;;;;;
+13DC7;EGYPTIAN HIEROGLYPH-13DC7;Lo;0;L;;;;;N;;;;;
+13DC8;EGYPTIAN HIEROGLYPH-13DC8;Lo;0;L;;;;;N;;;;;
+13DC9;EGYPTIAN HIEROGLYPH-13DC9;Lo;0;L;;;;;N;;;;;
+13DCA;EGYPTIAN HIEROGLYPH-13DCA;Lo;0;L;;;;;N;;;;;
+13DCB;EGYPTIAN HIEROGLYPH-13DCB;Lo;0;L;;;;;N;;;;;
+13DCC;EGYPTIAN HIEROGLYPH-13DCC;Lo;0;L;;;;;N;;;;;
+13DCD;EGYPTIAN HIEROGLYPH-13DCD;Lo;0;L;;;;;N;;;;;
+13DCE;EGYPTIAN HIEROGLYPH-13DCE;Lo;0;L;;;;;N;;;;;
+13DCF;EGYPTIAN HIEROGLYPH-13DCF;Lo;0;L;;;;;N;;;;;
+13DD0;EGYPTIAN HIEROGLYPH-13DD0;Lo;0;L;;;;;N;;;;;
+13DD1;EGYPTIAN HIEROGLYPH-13DD1;Lo;0;L;;;;;N;;;;;
+13DD2;EGYPTIAN HIEROGLYPH-13DD2;Lo;0;L;;;;;N;;;;;
+13DD3;EGYPTIAN HIEROGLYPH-13DD3;Lo;0;L;;;;;N;;;;;
+13DD4;EGYPTIAN HIEROGLYPH-13DD4;Lo;0;L;;;;;N;;;;;
+13DD5;EGYPTIAN HIEROGLYPH-13DD5;Lo;0;L;;;;;N;;;;;
+13DD6;EGYPTIAN HIEROGLYPH-13DD6;Lo;0;L;;;;;N;;;;;
+13DD7;EGYPTIAN HIEROGLYPH-13DD7;Lo;0;L;;;;;N;;;;;
+13DD8;EGYPTIAN HIEROGLYPH-13DD8;Lo;0;L;;;;;N;;;;;
+13DD9;EGYPTIAN HIEROGLYPH-13DD9;Lo;0;L;;;;;N;;;;;
+13DDA;EGYPTIAN HIEROGLYPH-13DDA;Lo;0;L;;;;;N;;;;;
+13DDB;EGYPTIAN HIEROGLYPH-13DDB;Lo;0;L;;;;;N;;;;;
+13DDC;EGYPTIAN HIEROGLYPH-13DDC;Lo;0;L;;;;;N;;;;;
+13DDD;EGYPTIAN HIEROGLYPH-13DDD;Lo;0;L;;;;;N;;;;;
+13DDE;EGYPTIAN HIEROGLYPH-13DDE;Lo;0;L;;;;;N;;;;;
+13DDF;EGYPTIAN HIEROGLYPH-13DDF;Lo;0;L;;;;;N;;;;;
+13DE0;EGYPTIAN HIEROGLYPH-13DE0;Lo;0;L;;;;;N;;;;;
+13DE1;EGYPTIAN HIEROGLYPH-13DE1;Lo;0;L;;;;;N;;;;;
+13DE2;EGYPTIAN HIEROGLYPH-13DE2;Lo;0;L;;;;;N;;;;;
+13DE3;EGYPTIAN HIEROGLYPH-13DE3;Lo;0;L;;;;;N;;;;;
+13DE4;EGYPTIAN HIEROGLYPH-13DE4;Lo;0;L;;;;;N;;;;;
+13DE5;EGYPTIAN HIEROGLYPH-13DE5;Lo;0;L;;;;;N;;;;;
+13DE6;EGYPTIAN HIEROGLYPH-13DE6;Lo;0;L;;;;;N;;;;;
+13DE7;EGYPTIAN HIEROGLYPH-13DE7;Lo;0;L;;;;;N;;;;;
+13DE8;EGYPTIAN HIEROGLYPH-13DE8;Lo;0;L;;;;;N;;;;;
+13DE9;EGYPTIAN HIEROGLYPH-13DE9;Lo;0;L;;;;;N;;;;;
+13DEA;EGYPTIAN HIEROGLYPH-13DEA;Lo;0;L;;;;;N;;;;;
+13DEB;EGYPTIAN HIEROGLYPH-13DEB;Lo;0;L;;;;;N;;;;;
+13DEC;EGYPTIAN HIEROGLYPH-13DEC;Lo;0;L;;;;;N;;;;;
+13DED;EGYPTIAN HIEROGLYPH-13DED;Lo;0;L;;;;;N;;;;;
+13DEE;EGYPTIAN HIEROGLYPH-13DEE;Lo;0;L;;;;;N;;;;;
+13DEF;EGYPTIAN HIEROGLYPH-13DEF;Lo;0;L;;;;;N;;;;;
+13DF0;EGYPTIAN HIEROGLYPH-13DF0;Lo;0;L;;;;;N;;;;;
+13DF1;EGYPTIAN HIEROGLYPH-13DF1;Lo;0;L;;;;;N;;;;;
+13DF2;EGYPTIAN HIEROGLYPH-13DF2;Lo;0;L;;;;;N;;;;;
+13DF3;EGYPTIAN HIEROGLYPH-13DF3;Lo;0;L;;;;;N;;;;;
+13DF4;EGYPTIAN HIEROGLYPH-13DF4;Lo;0;L;;;;;N;;;;;
+13DF5;EGYPTIAN HIEROGLYPH-13DF5;Lo;0;L;;;;;N;;;;;
+13DF6;EGYPTIAN HIEROGLYPH-13DF6;Lo;0;L;;;;;N;;;;;
+13DF7;EGYPTIAN HIEROGLYPH-13DF7;Lo;0;L;;;;;N;;;;;
+13DF8;EGYPTIAN HIEROGLYPH-13DF8;Lo;0;L;;;;;N;;;;;
+13DF9;EGYPTIAN HIEROGLYPH-13DF9;Lo;0;L;;;;;N;;;;;
+13DFA;EGYPTIAN HIEROGLYPH-13DFA;Lo;0;L;;;;;N;;;;;
+13DFB;EGYPTIAN HIEROGLYPH-13DFB;Lo;0;L;;;;;N;;;;;
+13DFC;EGYPTIAN HIEROGLYPH-13DFC;Lo;0;L;;;;;N;;;;;
+13DFD;EGYPTIAN HIEROGLYPH-13DFD;Lo;0;L;;;;;N;;;;;
+13DFE;EGYPTIAN HIEROGLYPH-13DFE;Lo;0;L;;;;;N;;;;;
+13DFF;EGYPTIAN HIEROGLYPH-13DFF;Lo;0;L;;;;;N;;;;;
+13E00;EGYPTIAN HIEROGLYPH-13E00;Lo;0;L;;;;;N;;;;;
+13E01;EGYPTIAN HIEROGLYPH-13E01;Lo;0;L;;;;;N;;;;;
+13E02;EGYPTIAN HIEROGLYPH-13E02;Lo;0;L;;;;;N;;;;;
+13E03;EGYPTIAN HIEROGLYPH-13E03;Lo;0;L;;;;;N;;;;;
+13E04;EGYPTIAN HIEROGLYPH-13E04;Lo;0;L;;;;;N;;;;;
+13E05;EGYPTIAN HIEROGLYPH-13E05;Lo;0;L;;;;;N;;;;;
+13E06;EGYPTIAN HIEROGLYPH-13E06;Lo;0;L;;;;;N;;;;;
+13E07;EGYPTIAN HIEROGLYPH-13E07;Lo;0;L;;;;;N;;;;;
+13E08;EGYPTIAN HIEROGLYPH-13E08;Lo;0;L;;;;;N;;;;;
+13E09;EGYPTIAN HIEROGLYPH-13E09;Lo;0;L;;;;;N;;;;;
+13E0A;EGYPTIAN HIEROGLYPH-13E0A;Lo;0;L;;;;;N;;;;;
+13E0B;EGYPTIAN HIEROGLYPH-13E0B;Lo;0;L;;;;;N;;;;;
+13E0C;EGYPTIAN HIEROGLYPH-13E0C;Lo;0;L;;;;;N;;;;;
+13E0D;EGYPTIAN HIEROGLYPH-13E0D;Lo;0;L;;;;;N;;;;;
+13E0E;EGYPTIAN HIEROGLYPH-13E0E;Lo;0;L;;;;;N;;;;;
+13E0F;EGYPTIAN HIEROGLYPH-13E0F;Lo;0;L;;;;;N;;;;;
+13E10;EGYPTIAN HIEROGLYPH-13E10;Lo;0;L;;;;;N;;;;;
+13E11;EGYPTIAN HIEROGLYPH-13E11;Lo;0;L;;;;;N;;;;;
+13E12;EGYPTIAN HIEROGLYPH-13E12;Lo;0;L;;;;;N;;;;;
+13E13;EGYPTIAN HIEROGLYPH-13E13;Lo;0;L;;;;;N;;;;;
+13E14;EGYPTIAN HIEROGLYPH-13E14;Lo;0;L;;;;;N;;;;;
+13E15;EGYPTIAN HIEROGLYPH-13E15;Lo;0;L;;;;;N;;;;;
+13E16;EGYPTIAN HIEROGLYPH-13E16;Lo;0;L;;;;;N;;;;;
+13E17;EGYPTIAN HIEROGLYPH-13E17;Lo;0;L;;;;;N;;;;;
+13E18;EGYPTIAN HIEROGLYPH-13E18;Lo;0;L;;;;;N;;;;;
+13E19;EGYPTIAN HIEROGLYPH-13E19;Lo;0;L;;;;;N;;;;;
+13E1A;EGYPTIAN HIEROGLYPH-13E1A;Lo;0;L;;;;;N;;;;;
+13E1B;EGYPTIAN HIEROGLYPH-13E1B;Lo;0;L;;;;;N;;;;;
+13E1C;EGYPTIAN HIEROGLYPH-13E1C;Lo;0;L;;;;;N;;;;;
+13E1D;EGYPTIAN HIEROGLYPH-13E1D;Lo;0;L;;;;;N;;;;;
+13E1E;EGYPTIAN HIEROGLYPH-13E1E;Lo;0;L;;;;;N;;;;;
+13E1F;EGYPTIAN HIEROGLYPH-13E1F;Lo;0;L;;;;;N;;;;;
+13E20;EGYPTIAN HIEROGLYPH-13E20;Lo;0;L;;;;;N;;;;;
+13E21;EGYPTIAN HIEROGLYPH-13E21;Lo;0;L;;;;;N;;;;;
+13E22;EGYPTIAN HIEROGLYPH-13E22;Lo;0;L;;;;;N;;;;;
+13E23;EGYPTIAN HIEROGLYPH-13E23;Lo;0;L;;;;;N;;;;;
+13E24;EGYPTIAN HIEROGLYPH-13E24;Lo;0;L;;;;;N;;;;;
+13E25;EGYPTIAN HIEROGLYPH-13E25;Lo;0;L;;;;;N;;;;;
+13E26;EGYPTIAN HIEROGLYPH-13E26;Lo;0;L;;;;;N;;;;;
+13E27;EGYPTIAN HIEROGLYPH-13E27;Lo;0;L;;;;;N;;;;;
+13E28;EGYPTIAN HIEROGLYPH-13E28;Lo;0;L;;;;;N;;;;;
+13E29;EGYPTIAN HIEROGLYPH-13E29;Lo;0;L;;;;;N;;;;;
+13E2A;EGYPTIAN HIEROGLYPH-13E2A;Lo;0;L;;;;;N;;;;;
+13E2B;EGYPTIAN HIEROGLYPH-13E2B;Lo;0;L;;;;;N;;;;;
+13E2C;EGYPTIAN HIEROGLYPH-13E2C;Lo;0;L;;;;;N;;;;;
+13E2D;EGYPTIAN HIEROGLYPH-13E2D;Lo;0;L;;;;;N;;;;;
+13E2E;EGYPTIAN HIEROGLYPH-13E2E;Lo;0;L;;;;;N;;;;;
+13E2F;EGYPTIAN HIEROGLYPH-13E2F;Lo;0;L;;;;;N;;;;;
+13E30;EGYPTIAN HIEROGLYPH-13E30;Lo;0;L;;;;;N;;;;;
+13E31;EGYPTIAN HIEROGLYPH-13E31;Lo;0;L;;;;;N;;;;;
+13E32;EGYPTIAN HIEROGLYPH-13E32;Lo;0;L;;;;;N;;;;;
+13E33;EGYPTIAN HIEROGLYPH-13E33;Lo;0;L;;;;;N;;;;;
+13E34;EGYPTIAN HIEROGLYPH-13E34;Lo;0;L;;;;;N;;;;;
+13E35;EGYPTIAN HIEROGLYPH-13E35;Lo;0;L;;;;;N;;;;;
+13E36;EGYPTIAN HIEROGLYPH-13E36;Lo;0;L;;;;;N;;;;;
+13E37;EGYPTIAN HIEROGLYPH-13E37;Lo;0;L;;;;;N;;;;;
+13E38;EGYPTIAN HIEROGLYPH-13E38;Lo;0;L;;;;;N;;;;;
+13E39;EGYPTIAN HIEROGLYPH-13E39;Lo;0;L;;;;;N;;;;;
+13E3A;EGYPTIAN HIEROGLYPH-13E3A;Lo;0;L;;;;;N;;;;;
+13E3B;EGYPTIAN HIEROGLYPH-13E3B;Lo;0;L;;;;;N;;;;;
+13E3C;EGYPTIAN HIEROGLYPH-13E3C;Lo;0;L;;;;;N;;;;;
+13E3D;EGYPTIAN HIEROGLYPH-13E3D;Lo;0;L;;;;;N;;;;;
+13E3E;EGYPTIAN HIEROGLYPH-13E3E;Lo;0;L;;;;;N;;;;;
+13E3F;EGYPTIAN HIEROGLYPH-13E3F;Lo;0;L;;;;;N;;;;;
+13E40;EGYPTIAN HIEROGLYPH-13E40;Lo;0;L;;;;;N;;;;;
+13E41;EGYPTIAN HIEROGLYPH-13E41;Lo;0;L;;;;;N;;;;;
+13E42;EGYPTIAN HIEROGLYPH-13E42;Lo;0;L;;;;;N;;;;;
+13E43;EGYPTIAN HIEROGLYPH-13E43;Lo;0;L;;;;;N;;;;;
+13E44;EGYPTIAN HIEROGLYPH-13E44;Lo;0;L;;;;;N;;;;;
+13E45;EGYPTIAN HIEROGLYPH-13E45;Lo;0;L;;;;;N;;;;;
+13E46;EGYPTIAN HIEROGLYPH-13E46;Lo;0;L;;;;;N;;;;;
+13E47;EGYPTIAN HIEROGLYPH-13E47;Lo;0;L;;;;;N;;;;;
+13E48;EGYPTIAN HIEROGLYPH-13E48;Lo;0;L;;;;;N;;;;;
+13E49;EGYPTIAN HIEROGLYPH-13E49;Lo;0;L;;;;;N;;;;;
+13E4A;EGYPTIAN HIEROGLYPH-13E4A;Lo;0;L;;;;;N;;;;;
+13E4B;EGYPTIAN HIEROGLYPH-13E4B;Lo;0;L;;;;;N;;;;;
+13E4C;EGYPTIAN HIEROGLYPH-13E4C;Lo;0;L;;;;;N;;;;;
+13E4D;EGYPTIAN HIEROGLYPH-13E4D;Lo;0;L;;;;;N;;;;;
+13E4E;EGYPTIAN HIEROGLYPH-13E4E;Lo;0;L;;;;;N;;;;;
+13E4F;EGYPTIAN HIEROGLYPH-13E4F;Lo;0;L;;;;;N;;;;;
+13E50;EGYPTIAN HIEROGLYPH-13E50;Lo;0;L;;;;;N;;;;;
+13E51;EGYPTIAN HIEROGLYPH-13E51;Lo;0;L;;;;;N;;;;;
+13E52;EGYPTIAN HIEROGLYPH-13E52;Lo;0;L;;;;;N;;;;;
+13E53;EGYPTIAN HIEROGLYPH-13E53;Lo;0;L;;;;;N;;;;;
+13E54;EGYPTIAN HIEROGLYPH-13E54;Lo;0;L;;;;;N;;;;;
+13E55;EGYPTIAN HIEROGLYPH-13E55;Lo;0;L;;;;;N;;;;;
+13E56;EGYPTIAN HIEROGLYPH-13E56;Lo;0;L;;;;;N;;;;;
+13E57;EGYPTIAN HIEROGLYPH-13E57;Lo;0;L;;;;;N;;;;;
+13E58;EGYPTIAN HIEROGLYPH-13E58;Lo;0;L;;;;;N;;;;;
+13E59;EGYPTIAN HIEROGLYPH-13E59;Lo;0;L;;;;;N;;;;;
+13E5A;EGYPTIAN HIEROGLYPH-13E5A;Lo;0;L;;;;;N;;;;;
+13E5B;EGYPTIAN HIEROGLYPH-13E5B;Lo;0;L;;;;;N;;;;;
+13E5C;EGYPTIAN HIEROGLYPH-13E5C;Lo;0;L;;;;;N;;;;;
+13E5D;EGYPTIAN HIEROGLYPH-13E5D;Lo;0;L;;;;;N;;;;;
+13E5E;EGYPTIAN HIEROGLYPH-13E5E;Lo;0;L;;;;;N;;;;;
+13E5F;EGYPTIAN HIEROGLYPH-13E5F;Lo;0;L;;;;;N;;;;;
+13E60;EGYPTIAN HIEROGLYPH-13E60;Lo;0;L;;;;;N;;;;;
+13E61;EGYPTIAN HIEROGLYPH-13E61;Lo;0;L;;;;;N;;;;;
+13E62;EGYPTIAN HIEROGLYPH-13E62;Lo;0;L;;;;;N;;;;;
+13E63;EGYPTIAN HIEROGLYPH-13E63;Lo;0;L;;;;;N;;;;;
+13E64;EGYPTIAN HIEROGLYPH-13E64;Lo;0;L;;;;;N;;;;;
+13E65;EGYPTIAN HIEROGLYPH-13E65;Lo;0;L;;;;;N;;;;;
+13E66;EGYPTIAN HIEROGLYPH-13E66;Lo;0;L;;;;;N;;;;;
+13E67;EGYPTIAN HIEROGLYPH-13E67;Lo;0;L;;;;;N;;;;;
+13E68;EGYPTIAN HIEROGLYPH-13E68;Lo;0;L;;;;;N;;;;;
+13E69;EGYPTIAN HIEROGLYPH-13E69;Lo;0;L;;;;;N;;;;;
+13E6A;EGYPTIAN HIEROGLYPH-13E6A;Lo;0;L;;;;;N;;;;;
+13E6B;EGYPTIAN HIEROGLYPH-13E6B;Lo;0;L;;;;;N;;;;;
+13E6C;EGYPTIAN HIEROGLYPH-13E6C;Lo;0;L;;;;;N;;;;;
+13E6D;EGYPTIAN HIEROGLYPH-13E6D;Lo;0;L;;;;;N;;;;;
+13E6E;EGYPTIAN HIEROGLYPH-13E6E;Lo;0;L;;;;;N;;;;;
+13E6F;EGYPTIAN HIEROGLYPH-13E6F;Lo;0;L;;;;;N;;;;;
+13E70;EGYPTIAN HIEROGLYPH-13E70;Lo;0;L;;;;;N;;;;;
+13E71;EGYPTIAN HIEROGLYPH-13E71;Lo;0;L;;;;;N;;;;;
+13E72;EGYPTIAN HIEROGLYPH-13E72;Lo;0;L;;;;;N;;;;;
+13E73;EGYPTIAN HIEROGLYPH-13E73;Lo;0;L;;;;;N;;;;;
+13E74;EGYPTIAN HIEROGLYPH-13E74;Lo;0;L;;;;;N;;;;;
+13E75;EGYPTIAN HIEROGLYPH-13E75;Lo;0;L;;;;;N;;;;;
+13E76;EGYPTIAN HIEROGLYPH-13E76;Lo;0;L;;;;;N;;;;;
+13E77;EGYPTIAN HIEROGLYPH-13E77;Lo;0;L;;;;;N;;;;;
+13E78;EGYPTIAN HIEROGLYPH-13E78;Lo;0;L;;;;;N;;;;;
+13E79;EGYPTIAN HIEROGLYPH-13E79;Lo;0;L;;;;;N;;;;;
+13E7A;EGYPTIAN HIEROGLYPH-13E7A;Lo;0;L;;;;;N;;;;;
+13E7B;EGYPTIAN HIEROGLYPH-13E7B;Lo;0;L;;;;;N;;;;;
+13E7C;EGYPTIAN HIEROGLYPH-13E7C;Lo;0;L;;;;;N;;;;;
+13E7D;EGYPTIAN HIEROGLYPH-13E7D;Lo;0;L;;;;;N;;;;;
+13E7E;EGYPTIAN HIEROGLYPH-13E7E;Lo;0;L;;;;;N;;;;;
+13E7F;EGYPTIAN HIEROGLYPH-13E7F;Lo;0;L;;;;;N;;;;;
+13E80;EGYPTIAN HIEROGLYPH-13E80;Lo;0;L;;;;;N;;;;;
+13E81;EGYPTIAN HIEROGLYPH-13E81;Lo;0;L;;;;;N;;;;;
+13E82;EGYPTIAN HIEROGLYPH-13E82;Lo;0;L;;;;;N;;;;;
+13E83;EGYPTIAN HIEROGLYPH-13E83;Lo;0;L;;;;;N;;;;;
+13E84;EGYPTIAN HIEROGLYPH-13E84;Lo;0;L;;;;;N;;;;;
+13E85;EGYPTIAN HIEROGLYPH-13E85;Lo;0;L;;;;;N;;;;;
+13E86;EGYPTIAN HIEROGLYPH-13E86;Lo;0;L;;;;;N;;;;;
+13E87;EGYPTIAN HIEROGLYPH-13E87;Lo;0;L;;;;;N;;;;;
+13E88;EGYPTIAN HIEROGLYPH-13E88;Lo;0;L;;;;;N;;;;;
+13E89;EGYPTIAN HIEROGLYPH-13E89;Lo;0;L;;;;;N;;;;;
+13E8A;EGYPTIAN HIEROGLYPH-13E8A;Lo;0;L;;;;;N;;;;;
+13E8B;EGYPTIAN HIEROGLYPH-13E8B;Lo;0;L;;;;;N;;;;;
+13E8C;EGYPTIAN HIEROGLYPH-13E8C;Lo;0;L;;;;;N;;;;;
+13E8D;EGYPTIAN HIEROGLYPH-13E8D;Lo;0;L;;;;;N;;;;;
+13E8E;EGYPTIAN HIEROGLYPH-13E8E;Lo;0;L;;;;;N;;;;;
+13E8F;EGYPTIAN HIEROGLYPH-13E8F;Lo;0;L;;;;;N;;;;;
+13E90;EGYPTIAN HIEROGLYPH-13E90;Lo;0;L;;;;;N;;;;;
+13E91;EGYPTIAN HIEROGLYPH-13E91;Lo;0;L;;;;;N;;;;;
+13E92;EGYPTIAN HIEROGLYPH-13E92;Lo;0;L;;;;;N;;;;;
+13E93;EGYPTIAN HIEROGLYPH-13E93;Lo;0;L;;;;;N;;;;;
+13E94;EGYPTIAN HIEROGLYPH-13E94;Lo;0;L;;;;;N;;;;;
+13E95;EGYPTIAN HIEROGLYPH-13E95;Lo;0;L;;;;;N;;;;;
+13E96;EGYPTIAN HIEROGLYPH-13E96;Lo;0;L;;;;;N;;;;;
+13E97;EGYPTIAN HIEROGLYPH-13E97;Lo;0;L;;;;;N;;;;;
+13E98;EGYPTIAN HIEROGLYPH-13E98;Lo;0;L;;;;;N;;;;;
+13E99;EGYPTIAN HIEROGLYPH-13E99;Lo;0;L;;;;;N;;;;;
+13E9A;EGYPTIAN HIEROGLYPH-13E9A;Lo;0;L;;;;;N;;;;;
+13E9B;EGYPTIAN HIEROGLYPH-13E9B;Lo;0;L;;;;;N;;;;;
+13E9C;EGYPTIAN HIEROGLYPH-13E9C;Lo;0;L;;;;;N;;;;;
+13E9D;EGYPTIAN HIEROGLYPH-13E9D;Lo;0;L;;;;;N;;;;;
+13E9E;EGYPTIAN HIEROGLYPH-13E9E;Lo;0;L;;;;;N;;;;;
+13E9F;EGYPTIAN HIEROGLYPH-13E9F;Lo;0;L;;;;;N;;;;;
+13EA0;EGYPTIAN HIEROGLYPH-13EA0;Lo;0;L;;;;;N;;;;;
+13EA1;EGYPTIAN HIEROGLYPH-13EA1;Lo;0;L;;;;;N;;;;;
+13EA2;EGYPTIAN HIEROGLYPH-13EA2;Lo;0;L;;;;;N;;;;;
+13EA3;EGYPTIAN HIEROGLYPH-13EA3;Lo;0;L;;;;;N;;;;;
+13EA4;EGYPTIAN HIEROGLYPH-13EA4;Lo;0;L;;;;;N;;;;;
+13EA5;EGYPTIAN HIEROGLYPH-13EA5;Lo;0;L;;;;;N;;;;;
+13EA6;EGYPTIAN HIEROGLYPH-13EA6;Lo;0;L;;;;;N;;;;;
+13EA7;EGYPTIAN HIEROGLYPH-13EA7;Lo;0;L;;;;;N;;;;;
+13EA8;EGYPTIAN HIEROGLYPH-13EA8;Lo;0;L;;;;;N;;;;;
+13EA9;EGYPTIAN HIEROGLYPH-13EA9;Lo;0;L;;;;;N;;;;;
+13EAA;EGYPTIAN HIEROGLYPH-13EAA;Lo;0;L;;;;;N;;;;;
+13EAB;EGYPTIAN HIEROGLYPH-13EAB;Lo;0;L;;;;;N;;;;;
+13EAC;EGYPTIAN HIEROGLYPH-13EAC;Lo;0;L;;;;;N;;;;;
+13EAD;EGYPTIAN HIEROGLYPH-13EAD;Lo;0;L;;;;;N;;;;;
+13EAE;EGYPTIAN HIEROGLYPH-13EAE;Lo;0;L;;;;;N;;;;;
+13EAF;EGYPTIAN HIEROGLYPH-13EAF;Lo;0;L;;;;;N;;;;;
+13EB0;EGYPTIAN HIEROGLYPH-13EB0;Lo;0;L;;;;;N;;;;;
+13EB1;EGYPTIAN HIEROGLYPH-13EB1;Lo;0;L;;;;;N;;;;;
+13EB2;EGYPTIAN HIEROGLYPH-13EB2;Lo;0;L;;;;;N;;;;;
+13EB3;EGYPTIAN HIEROGLYPH-13EB3;Lo;0;L;;;;;N;;;;;
+13EB4;EGYPTIAN HIEROGLYPH-13EB4;Lo;0;L;;;;;N;;;;;
+13EB5;EGYPTIAN HIEROGLYPH-13EB5;Lo;0;L;;;;;N;;;;;
+13EB6;EGYPTIAN HIEROGLYPH-13EB6;Lo;0;L;;;;;N;;;;;
+13EB7;EGYPTIAN HIEROGLYPH-13EB7;Lo;0;L;;;;;N;;;;;
+13EB8;EGYPTIAN HIEROGLYPH-13EB8;Lo;0;L;;;;;N;;;;;
+13EB9;EGYPTIAN HIEROGLYPH-13EB9;Lo;0;L;;;;;N;;;;;
+13EBA;EGYPTIAN HIEROGLYPH-13EBA;Lo;0;L;;;;;N;;;;;
+13EBB;EGYPTIAN HIEROGLYPH-13EBB;Lo;0;L;;;;;N;;;;;
+13EBC;EGYPTIAN HIEROGLYPH-13EBC;Lo;0;L;;;;;N;;;;;
+13EBD;EGYPTIAN HIEROGLYPH-13EBD;Lo;0;L;;;;;N;;;;;
+13EBE;EGYPTIAN HIEROGLYPH-13EBE;Lo;0;L;;;;;N;;;;;
+13EBF;EGYPTIAN HIEROGLYPH-13EBF;Lo;0;L;;;;;N;;;;;
+13EC0;EGYPTIAN HIEROGLYPH-13EC0;Lo;0;L;;;;;N;;;;;
+13EC1;EGYPTIAN HIEROGLYPH-13EC1;Lo;0;L;;;;;N;;;;;
+13EC2;EGYPTIAN HIEROGLYPH-13EC2;Lo;0;L;;;;;N;;;;;
+13EC3;EGYPTIAN HIEROGLYPH-13EC3;Lo;0;L;;;;;N;;;;;
+13EC4;EGYPTIAN HIEROGLYPH-13EC4;Lo;0;L;;;;;N;;;;;
+13EC5;EGYPTIAN HIEROGLYPH-13EC5;Lo;0;L;;;;;N;;;;;
+13EC6;EGYPTIAN HIEROGLYPH-13EC6;Lo;0;L;;;;;N;;;;;
+13EC7;EGYPTIAN HIEROGLYPH-13EC7;Lo;0;L;;;;;N;;;;;
+13EC8;EGYPTIAN HIEROGLYPH-13EC8;Lo;0;L;;;;;N;;;;;
+13EC9;EGYPTIAN HIEROGLYPH-13EC9;Lo;0;L;;;;;N;;;;;
+13ECA;EGYPTIAN HIEROGLYPH-13ECA;Lo;0;L;;;;;N;;;;;
+13ECB;EGYPTIAN HIEROGLYPH-13ECB;Lo;0;L;;;;;N;;;;;
+13ECC;EGYPTIAN HIEROGLYPH-13ECC;Lo;0;L;;;;;N;;;;;
+13ECD;EGYPTIAN HIEROGLYPH-13ECD;Lo;0;L;;;;;N;;;;;
+13ECE;EGYPTIAN HIEROGLYPH-13ECE;Lo;0;L;;;;;N;;;;;
+13ECF;EGYPTIAN HIEROGLYPH-13ECF;Lo;0;L;;;;;N;;;;;
+13ED0;EGYPTIAN HIEROGLYPH-13ED0;Lo;0;L;;;;;N;;;;;
+13ED1;EGYPTIAN HIEROGLYPH-13ED1;Lo;0;L;;;;;N;;;;;
+13ED2;EGYPTIAN HIEROGLYPH-13ED2;Lo;0;L;;;;;N;;;;;
+13ED3;EGYPTIAN HIEROGLYPH-13ED3;Lo;0;L;;;;;N;;;;;
+13ED4;EGYPTIAN HIEROGLYPH-13ED4;Lo;0;L;;;;;N;;;;;
+13ED5;EGYPTIAN HIEROGLYPH-13ED5;Lo;0;L;;;;;N;;;;;
+13ED6;EGYPTIAN HIEROGLYPH-13ED6;Lo;0;L;;;;;N;;;;;
+13ED7;EGYPTIAN HIEROGLYPH-13ED7;Lo;0;L;;;;;N;;;;;
+13ED8;EGYPTIAN HIEROGLYPH-13ED8;Lo;0;L;;;;;N;;;;;
+13ED9;EGYPTIAN HIEROGLYPH-13ED9;Lo;0;L;;;;;N;;;;;
+13EDA;EGYPTIAN HIEROGLYPH-13EDA;Lo;0;L;;;;;N;;;;;
+13EDB;EGYPTIAN HIEROGLYPH-13EDB;Lo;0;L;;;;;N;;;;;
+13EDC;EGYPTIAN HIEROGLYPH-13EDC;Lo;0;L;;;;;N;;;;;
+13EDD;EGYPTIAN HIEROGLYPH-13EDD;Lo;0;L;;;;;N;;;;;
+13EDE;EGYPTIAN HIEROGLYPH-13EDE;Lo;0;L;;;;;N;;;;;
+13EDF;EGYPTIAN HIEROGLYPH-13EDF;Lo;0;L;;;;;N;;;;;
+13EE0;EGYPTIAN HIEROGLYPH-13EE0;Lo;0;L;;;;;N;;;;;
+13EE1;EGYPTIAN HIEROGLYPH-13EE1;Lo;0;L;;;;;N;;;;;
+13EE2;EGYPTIAN HIEROGLYPH-13EE2;Lo;0;L;;;;;N;;;;;
+13EE3;EGYPTIAN HIEROGLYPH-13EE3;Lo;0;L;;;;;N;;;;;
+13EE4;EGYPTIAN HIEROGLYPH-13EE4;Lo;0;L;;;;;N;;;;;
+13EE5;EGYPTIAN HIEROGLYPH-13EE5;Lo;0;L;;;;;N;;;;;
+13EE6;EGYPTIAN HIEROGLYPH-13EE6;Lo;0;L;;;;;N;;;;;
+13EE7;EGYPTIAN HIEROGLYPH-13EE7;Lo;0;L;;;;;N;;;;;
+13EE8;EGYPTIAN HIEROGLYPH-13EE8;Lo;0;L;;;;;N;;;;;
+13EE9;EGYPTIAN HIEROGLYPH-13EE9;Lo;0;L;;;;;N;;;;;
+13EEA;EGYPTIAN HIEROGLYPH-13EEA;Lo;0;L;;;;;N;;;;;
+13EEB;EGYPTIAN HIEROGLYPH-13EEB;Lo;0;L;;;;;N;;;;;
+13EEC;EGYPTIAN HIEROGLYPH-13EEC;Lo;0;L;;;;;N;;;;;
+13EED;EGYPTIAN HIEROGLYPH-13EED;Lo;0;L;;;;;N;;;;;
+13EEE;EGYPTIAN HIEROGLYPH-13EEE;Lo;0;L;;;;;N;;;;;
+13EEF;EGYPTIAN HIEROGLYPH-13EEF;Lo;0;L;;;;;N;;;;;
+13EF0;EGYPTIAN HIEROGLYPH-13EF0;Lo;0;L;;;;;N;;;;;
+13EF1;EGYPTIAN HIEROGLYPH-13EF1;Lo;0;L;;;;;N;;;;;
+13EF2;EGYPTIAN HIEROGLYPH-13EF2;Lo;0;L;;;;;N;;;;;
+13EF3;EGYPTIAN HIEROGLYPH-13EF3;Lo;0;L;;;;;N;;;;;
+13EF4;EGYPTIAN HIEROGLYPH-13EF4;Lo;0;L;;;;;N;;;;;
+13EF5;EGYPTIAN HIEROGLYPH-13EF5;Lo;0;L;;;;;N;;;;;
+13EF6;EGYPTIAN HIEROGLYPH-13EF6;Lo;0;L;;;;;N;;;;;
+13EF7;EGYPTIAN HIEROGLYPH-13EF7;Lo;0;L;;;;;N;;;;;
+13EF8;EGYPTIAN HIEROGLYPH-13EF8;Lo;0;L;;;;;N;;;;;
+13EF9;EGYPTIAN HIEROGLYPH-13EF9;Lo;0;L;;;;;N;;;;;
+13EFA;EGYPTIAN HIEROGLYPH-13EFA;Lo;0;L;;;;;N;;;;;
+13EFB;EGYPTIAN HIEROGLYPH-13EFB;Lo;0;L;;;;;N;;;;;
+13EFC;EGYPTIAN HIEROGLYPH-13EFC;Lo;0;L;;;;;N;;;;;
+13EFD;EGYPTIAN HIEROGLYPH-13EFD;Lo;0;L;;;;;N;;;;;
+13EFE;EGYPTIAN HIEROGLYPH-13EFE;Lo;0;L;;;;;N;;;;;
+13EFF;EGYPTIAN HIEROGLYPH-13EFF;Lo;0;L;;;;;N;;;;;
+13F00;EGYPTIAN HIEROGLYPH-13F00;Lo;0;L;;;;;N;;;;;
+13F01;EGYPTIAN HIEROGLYPH-13F01;Lo;0;L;;;;;N;;;;;
+13F02;EGYPTIAN HIEROGLYPH-13F02;Lo;0;L;;;;;N;;;;;
+13F03;EGYPTIAN HIEROGLYPH-13F03;Lo;0;L;;;;;N;;;;;
+13F04;EGYPTIAN HIEROGLYPH-13F04;Lo;0;L;;;;;N;;;;;
+13F05;EGYPTIAN HIEROGLYPH-13F05;Lo;0;L;;;;;N;;;;;
+13F06;EGYPTIAN HIEROGLYPH-13F06;Lo;0;L;;;;;N;;;;;
+13F07;EGYPTIAN HIEROGLYPH-13F07;Lo;0;L;;;;;N;;;;;
+13F08;EGYPTIAN HIEROGLYPH-13F08;Lo;0;L;;;;;N;;;;;
+13F09;EGYPTIAN HIEROGLYPH-13F09;Lo;0;L;;;;;N;;;;;
+13F0A;EGYPTIAN HIEROGLYPH-13F0A;Lo;0;L;;;;;N;;;;;
+13F0B;EGYPTIAN HIEROGLYPH-13F0B;Lo;0;L;;;;;N;;;;;
+13F0C;EGYPTIAN HIEROGLYPH-13F0C;Lo;0;L;;;;;N;;;;;
+13F0D;EGYPTIAN HIEROGLYPH-13F0D;Lo;0;L;;;;;N;;;;;
+13F0E;EGYPTIAN HIEROGLYPH-13F0E;Lo;0;L;;;;;N;;;;;
+13F0F;EGYPTIAN HIEROGLYPH-13F0F;Lo;0;L;;;;;N;;;;;
+13F10;EGYPTIAN HIEROGLYPH-13F10;Lo;0;L;;;;;N;;;;;
+13F11;EGYPTIAN HIEROGLYPH-13F11;Lo;0;L;;;;;N;;;;;
+13F12;EGYPTIAN HIEROGLYPH-13F12;Lo;0;L;;;;;N;;;;;
+13F13;EGYPTIAN HIEROGLYPH-13F13;Lo;0;L;;;;;N;;;;;
+13F14;EGYPTIAN HIEROGLYPH-13F14;Lo;0;L;;;;;N;;;;;
+13F15;EGYPTIAN HIEROGLYPH-13F15;Lo;0;L;;;;;N;;;;;
+13F16;EGYPTIAN HIEROGLYPH-13F16;Lo;0;L;;;;;N;;;;;
+13F17;EGYPTIAN HIEROGLYPH-13F17;Lo;0;L;;;;;N;;;;;
+13F18;EGYPTIAN HIEROGLYPH-13F18;Lo;0;L;;;;;N;;;;;
+13F19;EGYPTIAN HIEROGLYPH-13F19;Lo;0;L;;;;;N;;;;;
+13F1A;EGYPTIAN HIEROGLYPH-13F1A;Lo;0;L;;;;;N;;;;;
+13F1B;EGYPTIAN HIEROGLYPH-13F1B;Lo;0;L;;;;;N;;;;;
+13F1C;EGYPTIAN HIEROGLYPH-13F1C;Lo;0;L;;;;;N;;;;;
+13F1D;EGYPTIAN HIEROGLYPH-13F1D;Lo;0;L;;;;;N;;;;;
+13F1E;EGYPTIAN HIEROGLYPH-13F1E;Lo;0;L;;;;;N;;;;;
+13F1F;EGYPTIAN HIEROGLYPH-13F1F;Lo;0;L;;;;;N;;;;;
+13F20;EGYPTIAN HIEROGLYPH-13F20;Lo;0;L;;;;;N;;;;;
+13F21;EGYPTIAN HIEROGLYPH-13F21;Lo;0;L;;;;;N;;;;;
+13F22;EGYPTIAN HIEROGLYPH-13F22;Lo;0;L;;;;;N;;;;;
+13F23;EGYPTIAN HIEROGLYPH-13F23;Lo;0;L;;;;;N;;;;;
+13F24;EGYPTIAN HIEROGLYPH-13F24;Lo;0;L;;;;;N;;;;;
+13F25;EGYPTIAN HIEROGLYPH-13F25;Lo;0;L;;;;;N;;;;;
+13F26;EGYPTIAN HIEROGLYPH-13F26;Lo;0;L;;;;;N;;;;;
+13F27;EGYPTIAN HIEROGLYPH-13F27;Lo;0;L;;;;;N;;;;;
+13F28;EGYPTIAN HIEROGLYPH-13F28;Lo;0;L;;;;;N;;;;;
+13F29;EGYPTIAN HIEROGLYPH-13F29;Lo;0;L;;;;;N;;;;;
+13F2A;EGYPTIAN HIEROGLYPH-13F2A;Lo;0;L;;;;;N;;;;;
+13F2B;EGYPTIAN HIEROGLYPH-13F2B;Lo;0;L;;;;;N;;;;;
+13F2C;EGYPTIAN HIEROGLYPH-13F2C;Lo;0;L;;;;;N;;;;;
+13F2D;EGYPTIAN HIEROGLYPH-13F2D;Lo;0;L;;;;;N;;;;;
+13F2E;EGYPTIAN HIEROGLYPH-13F2E;Lo;0;L;;;;;N;;;;;
+13F2F;EGYPTIAN HIEROGLYPH-13F2F;Lo;0;L;;;;;N;;;;;
+13F30;EGYPTIAN HIEROGLYPH-13F30;Lo;0;L;;;;;N;;;;;
+13F31;EGYPTIAN HIEROGLYPH-13F31;Lo;0;L;;;;;N;;;;;
+13F32;EGYPTIAN HIEROGLYPH-13F32;Lo;0;L;;;;;N;;;;;
+13F33;EGYPTIAN HIEROGLYPH-13F33;Lo;0;L;;;;;N;;;;;
+13F34;EGYPTIAN HIEROGLYPH-13F34;Lo;0;L;;;;;N;;;;;
+13F35;EGYPTIAN HIEROGLYPH-13F35;Lo;0;L;;;;;N;;;;;
+13F36;EGYPTIAN HIEROGLYPH-13F36;Lo;0;L;;;;;N;;;;;
+13F37;EGYPTIAN HIEROGLYPH-13F37;Lo;0;L;;;;;N;;;;;
+13F38;EGYPTIAN HIEROGLYPH-13F38;Lo;0;L;;;;;N;;;;;
+13F39;EGYPTIAN HIEROGLYPH-13F39;Lo;0;L;;;;;N;;;;;
+13F3A;EGYPTIAN HIEROGLYPH-13F3A;Lo;0;L;;;;;N;;;;;
+13F3B;EGYPTIAN HIEROGLYPH-13F3B;Lo;0;L;;;;;N;;;;;
+13F3C;EGYPTIAN HIEROGLYPH-13F3C;Lo;0;L;;;;;N;;;;;
+13F3D;EGYPTIAN HIEROGLYPH-13F3D;Lo;0;L;;;;;N;;;;;
+13F3E;EGYPTIAN HIEROGLYPH-13F3E;Lo;0;L;;;;;N;;;;;
+13F3F;EGYPTIAN HIEROGLYPH-13F3F;Lo;0;L;;;;;N;;;;;
+13F40;EGYPTIAN HIEROGLYPH-13F40;Lo;0;L;;;;;N;;;;;
+13F41;EGYPTIAN HIEROGLYPH-13F41;Lo;0;L;;;;;N;;;;;
+13F42;EGYPTIAN HIEROGLYPH-13F42;Lo;0;L;;;;;N;;;;;
+13F43;EGYPTIAN HIEROGLYPH-13F43;Lo;0;L;;;;;N;;;;;
+13F44;EGYPTIAN HIEROGLYPH-13F44;Lo;0;L;;;;;N;;;;;
+13F45;EGYPTIAN HIEROGLYPH-13F45;Lo;0;L;;;;;N;;;;;
+13F46;EGYPTIAN HIEROGLYPH-13F46;Lo;0;L;;;;;N;;;;;
+13F47;EGYPTIAN HIEROGLYPH-13F47;Lo;0;L;;;;;N;;;;;
+13F48;EGYPTIAN HIEROGLYPH-13F48;Lo;0;L;;;;;N;;;;;
+13F49;EGYPTIAN HIEROGLYPH-13F49;Lo;0;L;;;;;N;;;;;
+13F4A;EGYPTIAN HIEROGLYPH-13F4A;Lo;0;L;;;;;N;;;;;
+13F4B;EGYPTIAN HIEROGLYPH-13F4B;Lo;0;L;;;;;N;;;;;
+13F4C;EGYPTIAN HIEROGLYPH-13F4C;Lo;0;L;;;;;N;;;;;
+13F4D;EGYPTIAN HIEROGLYPH-13F4D;Lo;0;L;;;;;N;;;;;
+13F4E;EGYPTIAN HIEROGLYPH-13F4E;Lo;0;L;;;;;N;;;;;
+13F4F;EGYPTIAN HIEROGLYPH-13F4F;Lo;0;L;;;;;N;;;;;
+13F50;EGYPTIAN HIEROGLYPH-13F50;Lo;0;L;;;;;N;;;;;
+13F51;EGYPTIAN HIEROGLYPH-13F51;Lo;0;L;;;;;N;;;;;
+13F52;EGYPTIAN HIEROGLYPH-13F52;Lo;0;L;;;;;N;;;;;
+13F53;EGYPTIAN HIEROGLYPH-13F53;Lo;0;L;;;;;N;;;;;
+13F54;EGYPTIAN HIEROGLYPH-13F54;Lo;0;L;;;;;N;;;;;
+13F55;EGYPTIAN HIEROGLYPH-13F55;Lo;0;L;;;;;N;;;;;
+13F56;EGYPTIAN HIEROGLYPH-13F56;Lo;0;L;;;;;N;;;;;
+13F57;EGYPTIAN HIEROGLYPH-13F57;Lo;0;L;;;;;N;;;;;
+13F58;EGYPTIAN HIEROGLYPH-13F58;Lo;0;L;;;;;N;;;;;
+13F59;EGYPTIAN HIEROGLYPH-13F59;Lo;0;L;;;;;N;;;;;
+13F5A;EGYPTIAN HIEROGLYPH-13F5A;Lo;0;L;;;;;N;;;;;
+13F5B;EGYPTIAN HIEROGLYPH-13F5B;Lo;0;L;;;;;N;;;;;
+13F5C;EGYPTIAN HIEROGLYPH-13F5C;Lo;0;L;;;;;N;;;;;
+13F5D;EGYPTIAN HIEROGLYPH-13F5D;Lo;0;L;;;;;N;;;;;
+13F5E;EGYPTIAN HIEROGLYPH-13F5E;Lo;0;L;;;;;N;;;;;
+13F5F;EGYPTIAN HIEROGLYPH-13F5F;Lo;0;L;;;;;N;;;;;
+13F60;EGYPTIAN HIEROGLYPH-13F60;Lo;0;L;;;;;N;;;;;
+13F61;EGYPTIAN HIEROGLYPH-13F61;Lo;0;L;;;;;N;;;;;
+13F62;EGYPTIAN HIEROGLYPH-13F62;Lo;0;L;;;;;N;;;;;
+13F63;EGYPTIAN HIEROGLYPH-13F63;Lo;0;L;;;;;N;;;;;
+13F64;EGYPTIAN HIEROGLYPH-13F64;Lo;0;L;;;;;N;;;;;
+13F65;EGYPTIAN HIEROGLYPH-13F65;Lo;0;L;;;;;N;;;;;
+13F66;EGYPTIAN HIEROGLYPH-13F66;Lo;0;L;;;;;N;;;;;
+13F67;EGYPTIAN HIEROGLYPH-13F67;Lo;0;L;;;;;N;;;;;
+13F68;EGYPTIAN HIEROGLYPH-13F68;Lo;0;L;;;;;N;;;;;
+13F69;EGYPTIAN HIEROGLYPH-13F69;Lo;0;L;;;;;N;;;;;
+13F6A;EGYPTIAN HIEROGLYPH-13F6A;Lo;0;L;;;;;N;;;;;
+13F6B;EGYPTIAN HIEROGLYPH-13F6B;Lo;0;L;;;;;N;;;;;
+13F6C;EGYPTIAN HIEROGLYPH-13F6C;Lo;0;L;;;;;N;;;;;
+13F6D;EGYPTIAN HIEROGLYPH-13F6D;Lo;0;L;;;;;N;;;;;
+13F6E;EGYPTIAN HIEROGLYPH-13F6E;Lo;0;L;;;;;N;;;;;
+13F6F;EGYPTIAN HIEROGLYPH-13F6F;Lo;0;L;;;;;N;;;;;
+13F70;EGYPTIAN HIEROGLYPH-13F70;Lo;0;L;;;;;N;;;;;
+13F71;EGYPTIAN HIEROGLYPH-13F71;Lo;0;L;;;;;N;;;;;
+13F72;EGYPTIAN HIEROGLYPH-13F72;Lo;0;L;;;;;N;;;;;
+13F73;EGYPTIAN HIEROGLYPH-13F73;Lo;0;L;;;;;N;;;;;
+13F74;EGYPTIAN HIEROGLYPH-13F74;Lo;0;L;;;;;N;;;;;
+13F75;EGYPTIAN HIEROGLYPH-13F75;Lo;0;L;;;;;N;;;;;
+13F76;EGYPTIAN HIEROGLYPH-13F76;Lo;0;L;;;;;N;;;;;
+13F77;EGYPTIAN HIEROGLYPH-13F77;Lo;0;L;;;;;N;;;;;
+13F78;EGYPTIAN HIEROGLYPH-13F78;Lo;0;L;;;;;N;;;;;
+13F79;EGYPTIAN HIEROGLYPH-13F79;Lo;0;L;;;;;N;;;;;
+13F7A;EGYPTIAN HIEROGLYPH-13F7A;Lo;0;L;;;;;N;;;;;
+13F7B;EGYPTIAN HIEROGLYPH-13F7B;Lo;0;L;;;;;N;;;;;
+13F7C;EGYPTIAN HIEROGLYPH-13F7C;Lo;0;L;;;;;N;;;;;
+13F7D;EGYPTIAN HIEROGLYPH-13F7D;Lo;0;L;;;;;N;;;;;
+13F7E;EGYPTIAN HIEROGLYPH-13F7E;Lo;0;L;;;;;N;;;;;
+13F7F;EGYPTIAN HIEROGLYPH-13F7F;Lo;0;L;;;;;N;;;;;
+13F80;EGYPTIAN HIEROGLYPH-13F80;Lo;0;L;;;;;N;;;;;
+13F81;EGYPTIAN HIEROGLYPH-13F81;Lo;0;L;;;;;N;;;;;
+13F82;EGYPTIAN HIEROGLYPH-13F82;Lo;0;L;;;;;N;;;;;
+13F83;EGYPTIAN HIEROGLYPH-13F83;Lo;0;L;;;;;N;;;;;
+13F84;EGYPTIAN HIEROGLYPH-13F84;Lo;0;L;;;;;N;;;;;
+13F85;EGYPTIAN HIEROGLYPH-13F85;Lo;0;L;;;;;N;;;;;
+13F86;EGYPTIAN HIEROGLYPH-13F86;Lo;0;L;;;;;N;;;;;
+13F87;EGYPTIAN HIEROGLYPH-13F87;Lo;0;L;;;;;N;;;;;
+13F88;EGYPTIAN HIEROGLYPH-13F88;Lo;0;L;;;;;N;;;;;
+13F89;EGYPTIAN HIEROGLYPH-13F89;Lo;0;L;;;;;N;;;;;
+13F8A;EGYPTIAN HIEROGLYPH-13F8A;Lo;0;L;;;;;N;;;;;
+13F8B;EGYPTIAN HIEROGLYPH-13F8B;Lo;0;L;;;;;N;;;;;
+13F8C;EGYPTIAN HIEROGLYPH-13F8C;Lo;0;L;;;;;N;;;;;
+13F8D;EGYPTIAN HIEROGLYPH-13F8D;Lo;0;L;;;;;N;;;;;
+13F8E;EGYPTIAN HIEROGLYPH-13F8E;Lo;0;L;;;;;N;;;;;
+13F8F;EGYPTIAN HIEROGLYPH-13F8F;Lo;0;L;;;;;N;;;;;
+13F90;EGYPTIAN HIEROGLYPH-13F90;Lo;0;L;;;;;N;;;;;
+13F91;EGYPTIAN HIEROGLYPH-13F91;Lo;0;L;;;;;N;;;;;
+13F92;EGYPTIAN HIEROGLYPH-13F92;Lo;0;L;;;;;N;;;;;
+13F93;EGYPTIAN HIEROGLYPH-13F93;Lo;0;L;;;;;N;;;;;
+13F94;EGYPTIAN HIEROGLYPH-13F94;Lo;0;L;;;;;N;;;;;
+13F95;EGYPTIAN HIEROGLYPH-13F95;Lo;0;L;;;;;N;;;;;
+13F96;EGYPTIAN HIEROGLYPH-13F96;Lo;0;L;;;;;N;;;;;
+13F97;EGYPTIAN HIEROGLYPH-13F97;Lo;0;L;;;;;N;;;;;
+13F98;EGYPTIAN HIEROGLYPH-13F98;Lo;0;L;;;;;N;;;;;
+13F99;EGYPTIAN HIEROGLYPH-13F99;Lo;0;L;;;;;N;;;;;
+13F9A;EGYPTIAN HIEROGLYPH-13F9A;Lo;0;L;;;;;N;;;;;
+13F9B;EGYPTIAN HIEROGLYPH-13F9B;Lo;0;L;;;;;N;;;;;
+13F9C;EGYPTIAN HIEROGLYPH-13F9C;Lo;0;L;;;;;N;;;;;
+13F9D;EGYPTIAN HIEROGLYPH-13F9D;Lo;0;L;;;;;N;;;;;
+13F9E;EGYPTIAN HIEROGLYPH-13F9E;Lo;0;L;;;;;N;;;;;
+13F9F;EGYPTIAN HIEROGLYPH-13F9F;Lo;0;L;;;;;N;;;;;
+13FA0;EGYPTIAN HIEROGLYPH-13FA0;Lo;0;L;;;;;N;;;;;
+13FA1;EGYPTIAN HIEROGLYPH-13FA1;Lo;0;L;;;;;N;;;;;
+13FA2;EGYPTIAN HIEROGLYPH-13FA2;Lo;0;L;;;;;N;;;;;
+13FA3;EGYPTIAN HIEROGLYPH-13FA3;Lo;0;L;;;;;N;;;;;
+13FA4;EGYPTIAN HIEROGLYPH-13FA4;Lo;0;L;;;;;N;;;;;
+13FA5;EGYPTIAN HIEROGLYPH-13FA5;Lo;0;L;;;;;N;;;;;
+13FA6;EGYPTIAN HIEROGLYPH-13FA6;Lo;0;L;;;;;N;;;;;
+13FA7;EGYPTIAN HIEROGLYPH-13FA7;Lo;0;L;;;;;N;;;;;
+13FA8;EGYPTIAN HIEROGLYPH-13FA8;Lo;0;L;;;;;N;;;;;
+13FA9;EGYPTIAN HIEROGLYPH-13FA9;Lo;0;L;;;;;N;;;;;
+13FAA;EGYPTIAN HIEROGLYPH-13FAA;Lo;0;L;;;;;N;;;;;
+13FAB;EGYPTIAN HIEROGLYPH-13FAB;Lo;0;L;;;;;N;;;;;
+13FAC;EGYPTIAN HIEROGLYPH-13FAC;Lo;0;L;;;;;N;;;;;
+13FAD;EGYPTIAN HIEROGLYPH-13FAD;Lo;0;L;;;;;N;;;;;
+13FAE;EGYPTIAN HIEROGLYPH-13FAE;Lo;0;L;;;;;N;;;;;
+13FAF;EGYPTIAN HIEROGLYPH-13FAF;Lo;0;L;;;;;N;;;;;
+13FB0;EGYPTIAN HIEROGLYPH-13FB0;Lo;0;L;;;;;N;;;;;
+13FB1;EGYPTIAN HIEROGLYPH-13FB1;Lo;0;L;;;;;N;;;;;
+13FB2;EGYPTIAN HIEROGLYPH-13FB2;Lo;0;L;;;;;N;;;;;
+13FB3;EGYPTIAN HIEROGLYPH-13FB3;Lo;0;L;;;;;N;;;;;
+13FB4;EGYPTIAN HIEROGLYPH-13FB4;Lo;0;L;;;;;N;;;;;
+13FB5;EGYPTIAN HIEROGLYPH-13FB5;Lo;0;L;;;;;N;;;;;
+13FB6;EGYPTIAN HIEROGLYPH-13FB6;Lo;0;L;;;;;N;;;;;
+13FB7;EGYPTIAN HIEROGLYPH-13FB7;Lo;0;L;;;;;N;;;;;
+13FB8;EGYPTIAN HIEROGLYPH-13FB8;Lo;0;L;;;;;N;;;;;
+13FB9;EGYPTIAN HIEROGLYPH-13FB9;Lo;0;L;;;;;N;;;;;
+13FBA;EGYPTIAN HIEROGLYPH-13FBA;Lo;0;L;;;;;N;;;;;
+13FBB;EGYPTIAN HIEROGLYPH-13FBB;Lo;0;L;;;;;N;;;;;
+13FBC;EGYPTIAN HIEROGLYPH-13FBC;Lo;0;L;;;;;N;;;;;
+13FBD;EGYPTIAN HIEROGLYPH-13FBD;Lo;0;L;;;;;N;;;;;
+13FBE;EGYPTIAN HIEROGLYPH-13FBE;Lo;0;L;;;;;N;;;;;
+13FBF;EGYPTIAN HIEROGLYPH-13FBF;Lo;0;L;;;;;N;;;;;
+13FC0;EGYPTIAN HIEROGLYPH-13FC0;Lo;0;L;;;;;N;;;;;
+13FC1;EGYPTIAN HIEROGLYPH-13FC1;Lo;0;L;;;;;N;;;;;
+13FC2;EGYPTIAN HIEROGLYPH-13FC2;Lo;0;L;;;;;N;;;;;
+13FC3;EGYPTIAN HIEROGLYPH-13FC3;Lo;0;L;;;;;N;;;;;
+13FC4;EGYPTIAN HIEROGLYPH-13FC4;Lo;0;L;;;;;N;;;;;
+13FC5;EGYPTIAN HIEROGLYPH-13FC5;Lo;0;L;;;;;N;;;;;
+13FC6;EGYPTIAN HIEROGLYPH-13FC6;Lo;0;L;;;;;N;;;;;
+13FC7;EGYPTIAN HIEROGLYPH-13FC7;Lo;0;L;;;;;N;;;;;
+13FC8;EGYPTIAN HIEROGLYPH-13FC8;Lo;0;L;;;;;N;;;;;
+13FC9;EGYPTIAN HIEROGLYPH-13FC9;Lo;0;L;;;;;N;;;;;
+13FCA;EGYPTIAN HIEROGLYPH-13FCA;Lo;0;L;;;;;N;;;;;
+13FCB;EGYPTIAN HIEROGLYPH-13FCB;Lo;0;L;;;;;N;;;;;
+13FCC;EGYPTIAN HIEROGLYPH-13FCC;Lo;0;L;;;;;N;;;;;
+13FCD;EGYPTIAN HIEROGLYPH-13FCD;Lo;0;L;;;;;N;;;;;
+13FCE;EGYPTIAN HIEROGLYPH-13FCE;Lo;0;L;;;;;N;;;;;
+13FCF;EGYPTIAN HIEROGLYPH-13FCF;Lo;0;L;;;;;N;;;;;
+13FD0;EGYPTIAN HIEROGLYPH-13FD0;Lo;0;L;;;;;N;;;;;
+13FD1;EGYPTIAN HIEROGLYPH-13FD1;Lo;0;L;;;;;N;;;;;
+13FD2;EGYPTIAN HIEROGLYPH-13FD2;Lo;0;L;;;;;N;;;;;
+13FD3;EGYPTIAN HIEROGLYPH-13FD3;Lo;0;L;;;;;N;;;;;
+13FD4;EGYPTIAN HIEROGLYPH-13FD4;Lo;0;L;;;;;N;;;;;
+13FD5;EGYPTIAN HIEROGLYPH-13FD5;Lo;0;L;;;;;N;;;;;
+13FD6;EGYPTIAN HIEROGLYPH-13FD6;Lo;0;L;;;;;N;;;;;
+13FD7;EGYPTIAN HIEROGLYPH-13FD7;Lo;0;L;;;;;N;;;;;
+13FD8;EGYPTIAN HIEROGLYPH-13FD8;Lo;0;L;;;;;N;;;;;
+13FD9;EGYPTIAN HIEROGLYPH-13FD9;Lo;0;L;;;;;N;;;;;
+13FDA;EGYPTIAN HIEROGLYPH-13FDA;Lo;0;L;;;;;N;;;;;
+13FDB;EGYPTIAN HIEROGLYPH-13FDB;Lo;0;L;;;;;N;;;;;
+13FDC;EGYPTIAN HIEROGLYPH-13FDC;Lo;0;L;;;;;N;;;;;
+13FDD;EGYPTIAN HIEROGLYPH-13FDD;Lo;0;L;;;;;N;;;;;
+13FDE;EGYPTIAN HIEROGLYPH-13FDE;Lo;0;L;;;;;N;;;;;
+13FDF;EGYPTIAN HIEROGLYPH-13FDF;Lo;0;L;;;;;N;;;;;
+13FE0;EGYPTIAN HIEROGLYPH-13FE0;Lo;0;L;;;;;N;;;;;
+13FE1;EGYPTIAN HIEROGLYPH-13FE1;Lo;0;L;;;;;N;;;;;
+13FE2;EGYPTIAN HIEROGLYPH-13FE2;Lo;0;L;;;;;N;;;;;
+13FE3;EGYPTIAN HIEROGLYPH-13FE3;Lo;0;L;;;;;N;;;;;
+13FE4;EGYPTIAN HIEROGLYPH-13FE4;Lo;0;L;;;;;N;;;;;
+13FE5;EGYPTIAN HIEROGLYPH-13FE5;Lo;0;L;;;;;N;;;;;
+13FE6;EGYPTIAN HIEROGLYPH-13FE6;Lo;0;L;;;;;N;;;;;
+13FE7;EGYPTIAN HIEROGLYPH-13FE7;Lo;0;L;;;;;N;;;;;
+13FE8;EGYPTIAN HIEROGLYPH-13FE8;Lo;0;L;;;;;N;;;;;
+13FE9;EGYPTIAN HIEROGLYPH-13FE9;Lo;0;L;;;;;N;;;;;
+13FEA;EGYPTIAN HIEROGLYPH-13FEA;Lo;0;L;;;;;N;;;;;
+13FEB;EGYPTIAN HIEROGLYPH-13FEB;Lo;0;L;;;;;N;;;;;
+13FEC;EGYPTIAN HIEROGLYPH-13FEC;Lo;0;L;;;;;N;;;;;
+13FED;EGYPTIAN HIEROGLYPH-13FED;Lo;0;L;;;;;N;;;;;
+13FEE;EGYPTIAN HIEROGLYPH-13FEE;Lo;0;L;;;;;N;;;;;
+13FEF;EGYPTIAN HIEROGLYPH-13FEF;Lo;0;L;;;;;N;;;;;
+13FF0;EGYPTIAN HIEROGLYPH-13FF0;Lo;0;L;;;;;N;;;;;
+13FF1;EGYPTIAN HIEROGLYPH-13FF1;Lo;0;L;;;;;N;;;;;
+13FF2;EGYPTIAN HIEROGLYPH-13FF2;Lo;0;L;;;;;N;;;;;
+13FF3;EGYPTIAN HIEROGLYPH-13FF3;Lo;0;L;;;;;N;;;;;
+13FF4;EGYPTIAN HIEROGLYPH-13FF4;Lo;0;L;;;;;N;;;;;
+13FF5;EGYPTIAN HIEROGLYPH-13FF5;Lo;0;L;;;;;N;;;;;
+13FF6;EGYPTIAN HIEROGLYPH-13FF6;Lo;0;L;;;;;N;;;;;
+13FF7;EGYPTIAN HIEROGLYPH-13FF7;Lo;0;L;;;;;N;;;;;
+13FF8;EGYPTIAN HIEROGLYPH-13FF8;Lo;0;L;;;;;N;;;;;
+13FF9;EGYPTIAN HIEROGLYPH-13FF9;Lo;0;L;;;;;N;;;;;
+13FFA;EGYPTIAN HIEROGLYPH-13FFA;Lo;0;L;;;;;N;;;;;
+13FFB;EGYPTIAN HIEROGLYPH-13FFB;Lo;0;L;;;;;N;;;;;
+13FFC;EGYPTIAN HIEROGLYPH-13FFC;Lo;0;L;;;;;N;;;;;
+13FFD;EGYPTIAN HIEROGLYPH-13FFD;Lo;0;L;;;;;N;;;;;
+13FFE;EGYPTIAN HIEROGLYPH-13FFE;Lo;0;L;;;;;N;;;;;
+13FFF;EGYPTIAN HIEROGLYPH-13FFF;Lo;0;L;;;;;N;;;;;
+14000;EGYPTIAN HIEROGLYPH-14000;Lo;0;L;;;;;N;;;;;
+14001;EGYPTIAN HIEROGLYPH-14001;Lo;0;L;;;;;N;;;;;
+14002;EGYPTIAN HIEROGLYPH-14002;Lo;0;L;;;;;N;;;;;
+14003;EGYPTIAN HIEROGLYPH-14003;Lo;0;L;;;;;N;;;;;
+14004;EGYPTIAN HIEROGLYPH-14004;Lo;0;L;;;;;N;;;;;
+14005;EGYPTIAN HIEROGLYPH-14005;Lo;0;L;;;;;N;;;;;
+14006;EGYPTIAN HIEROGLYPH-14006;Lo;0;L;;;;;N;;;;;
+14007;EGYPTIAN HIEROGLYPH-14007;Lo;0;L;;;;;N;;;;;
+14008;EGYPTIAN HIEROGLYPH-14008;Lo;0;L;;;;;N;;;;;
+14009;EGYPTIAN HIEROGLYPH-14009;Lo;0;L;;;;;N;;;;;
+1400A;EGYPTIAN HIEROGLYPH-1400A;Lo;0;L;;;;;N;;;;;
+1400B;EGYPTIAN HIEROGLYPH-1400B;Lo;0;L;;;;;N;;;;;
+1400C;EGYPTIAN HIEROGLYPH-1400C;Lo;0;L;;;;;N;;;;;
+1400D;EGYPTIAN HIEROGLYPH-1400D;Lo;0;L;;;;;N;;;;;
+1400E;EGYPTIAN HIEROGLYPH-1400E;Lo;0;L;;;;;N;;;;;
+1400F;EGYPTIAN HIEROGLYPH-1400F;Lo;0;L;;;;;N;;;;;
+14010;EGYPTIAN HIEROGLYPH-14010;Lo;0;L;;;;;N;;;;;
+14011;EGYPTIAN HIEROGLYPH-14011;Lo;0;L;;;;;N;;;;;
+14012;EGYPTIAN HIEROGLYPH-14012;Lo;0;L;;;;;N;;;;;
+14013;EGYPTIAN HIEROGLYPH-14013;Lo;0;L;;;;;N;;;;;
+14014;EGYPTIAN HIEROGLYPH-14014;Lo;0;L;;;;;N;;;;;
+14015;EGYPTIAN HIEROGLYPH-14015;Lo;0;L;;;;;N;;;;;
+14016;EGYPTIAN HIEROGLYPH-14016;Lo;0;L;;;;;N;;;;;
+14017;EGYPTIAN HIEROGLYPH-14017;Lo;0;L;;;;;N;;;;;
+14018;EGYPTIAN HIEROGLYPH-14018;Lo;0;L;;;;;N;;;;;
+14019;EGYPTIAN HIEROGLYPH-14019;Lo;0;L;;;;;N;;;;;
+1401A;EGYPTIAN HIEROGLYPH-1401A;Lo;0;L;;;;;N;;;;;
+1401B;EGYPTIAN HIEROGLYPH-1401B;Lo;0;L;;;;;N;;;;;
+1401C;EGYPTIAN HIEROGLYPH-1401C;Lo;0;L;;;;;N;;;;;
+1401D;EGYPTIAN HIEROGLYPH-1401D;Lo;0;L;;;;;N;;;;;
+1401E;EGYPTIAN HIEROGLYPH-1401E;Lo;0;L;;;;;N;;;;;
+1401F;EGYPTIAN HIEROGLYPH-1401F;Lo;0;L;;;;;N;;;;;
+14020;EGYPTIAN HIEROGLYPH-14020;Lo;0;L;;;;;N;;;;;
+14021;EGYPTIAN HIEROGLYPH-14021;Lo;0;L;;;;;N;;;;;
+14022;EGYPTIAN HIEROGLYPH-14022;Lo;0;L;;;;;N;;;;;
+14023;EGYPTIAN HIEROGLYPH-14023;Lo;0;L;;;;;N;;;;;
+14024;EGYPTIAN HIEROGLYPH-14024;Lo;0;L;;;;;N;;;;;
+14025;EGYPTIAN HIEROGLYPH-14025;Lo;0;L;;;;;N;;;;;
+14026;EGYPTIAN HIEROGLYPH-14026;Lo;0;L;;;;;N;;;;;
+14027;EGYPTIAN HIEROGLYPH-14027;Lo;0;L;;;;;N;;;;;
+14028;EGYPTIAN HIEROGLYPH-14028;Lo;0;L;;;;;N;;;;;
+14029;EGYPTIAN HIEROGLYPH-14029;Lo;0;L;;;;;N;;;;;
+1402A;EGYPTIAN HIEROGLYPH-1402A;Lo;0;L;;;;;N;;;;;
+1402B;EGYPTIAN HIEROGLYPH-1402B;Lo;0;L;;;;;N;;;;;
+1402C;EGYPTIAN HIEROGLYPH-1402C;Lo;0;L;;;;;N;;;;;
+1402D;EGYPTIAN HIEROGLYPH-1402D;Lo;0;L;;;;;N;;;;;
+1402E;EGYPTIAN HIEROGLYPH-1402E;Lo;0;L;;;;;N;;;;;
+1402F;EGYPTIAN HIEROGLYPH-1402F;Lo;0;L;;;;;N;;;;;
+14030;EGYPTIAN HIEROGLYPH-14030;Lo;0;L;;;;;N;;;;;
+14031;EGYPTIAN HIEROGLYPH-14031;Lo;0;L;;;;;N;;;;;
+14032;EGYPTIAN HIEROGLYPH-14032;Lo;0;L;;;;;N;;;;;
+14033;EGYPTIAN HIEROGLYPH-14033;Lo;0;L;;;;;N;;;;;
+14034;EGYPTIAN HIEROGLYPH-14034;Lo;0;L;;;;;N;;;;;
+14035;EGYPTIAN HIEROGLYPH-14035;Lo;0;L;;;;;N;;;;;
+14036;EGYPTIAN HIEROGLYPH-14036;Lo;0;L;;;;;N;;;;;
+14037;EGYPTIAN HIEROGLYPH-14037;Lo;0;L;;;;;N;;;;;
+14038;EGYPTIAN HIEROGLYPH-14038;Lo;0;L;;;;;N;;;;;
+14039;EGYPTIAN HIEROGLYPH-14039;Lo;0;L;;;;;N;;;;;
+1403A;EGYPTIAN HIEROGLYPH-1403A;Lo;0;L;;;;;N;;;;;
+1403B;EGYPTIAN HIEROGLYPH-1403B;Lo;0;L;;;;;N;;;;;
+1403C;EGYPTIAN HIEROGLYPH-1403C;Lo;0;L;;;;;N;;;;;
+1403D;EGYPTIAN HIEROGLYPH-1403D;Lo;0;L;;;;;N;;;;;
+1403E;EGYPTIAN HIEROGLYPH-1403E;Lo;0;L;;;;;N;;;;;
+1403F;EGYPTIAN HIEROGLYPH-1403F;Lo;0;L;;;;;N;;;;;
+14040;EGYPTIAN HIEROGLYPH-14040;Lo;0;L;;;;;N;;;;;
+14041;EGYPTIAN HIEROGLYPH-14041;Lo;0;L;;;;;N;;;;;
+14042;EGYPTIAN HIEROGLYPH-14042;Lo;0;L;;;;;N;;;;;
+14043;EGYPTIAN HIEROGLYPH-14043;Lo;0;L;;;;;N;;;;;
+14044;EGYPTIAN HIEROGLYPH-14044;Lo;0;L;;;;;N;;;;;
+14045;EGYPTIAN HIEROGLYPH-14045;Lo;0;L;;;;;N;;;;;
+14046;EGYPTIAN HIEROGLYPH-14046;Lo;0;L;;;;;N;;;;;
+14047;EGYPTIAN HIEROGLYPH-14047;Lo;0;L;;;;;N;;;;;
+14048;EGYPTIAN HIEROGLYPH-14048;Lo;0;L;;;;;N;;;;;
+14049;EGYPTIAN HIEROGLYPH-14049;Lo;0;L;;;;;N;;;;;
+1404A;EGYPTIAN HIEROGLYPH-1404A;Lo;0;L;;;;;N;;;;;
+1404B;EGYPTIAN HIEROGLYPH-1404B;Lo;0;L;;;;;N;;;;;
+1404C;EGYPTIAN HIEROGLYPH-1404C;Lo;0;L;;;;;N;;;;;
+1404D;EGYPTIAN HIEROGLYPH-1404D;Lo;0;L;;;;;N;;;;;
+1404E;EGYPTIAN HIEROGLYPH-1404E;Lo;0;L;;;;;N;;;;;
+1404F;EGYPTIAN HIEROGLYPH-1404F;Lo;0;L;;;;;N;;;;;
+14050;EGYPTIAN HIEROGLYPH-14050;Lo;0;L;;;;;N;;;;;
+14051;EGYPTIAN HIEROGLYPH-14051;Lo;0;L;;;;;N;;;;;
+14052;EGYPTIAN HIEROGLYPH-14052;Lo;0;L;;;;;N;;;;;
+14053;EGYPTIAN HIEROGLYPH-14053;Lo;0;L;;;;;N;;;;;
+14054;EGYPTIAN HIEROGLYPH-14054;Lo;0;L;;;;;N;;;;;
+14055;EGYPTIAN HIEROGLYPH-14055;Lo;0;L;;;;;N;;;;;
+14056;EGYPTIAN HIEROGLYPH-14056;Lo;0;L;;;;;N;;;;;
+14057;EGYPTIAN HIEROGLYPH-14057;Lo;0;L;;;;;N;;;;;
+14058;EGYPTIAN HIEROGLYPH-14058;Lo;0;L;;;;;N;;;;;
+14059;EGYPTIAN HIEROGLYPH-14059;Lo;0;L;;;;;N;;;;;
+1405A;EGYPTIAN HIEROGLYPH-1405A;Lo;0;L;;;;;N;;;;;
+1405B;EGYPTIAN HIEROGLYPH-1405B;Lo;0;L;;;;;N;;;;;
+1405C;EGYPTIAN HIEROGLYPH-1405C;Lo;0;L;;;;;N;;;;;
+1405D;EGYPTIAN HIEROGLYPH-1405D;Lo;0;L;;;;;N;;;;;
+1405E;EGYPTIAN HIEROGLYPH-1405E;Lo;0;L;;;;;N;;;;;
+1405F;EGYPTIAN HIEROGLYPH-1405F;Lo;0;L;;;;;N;;;;;
+14060;EGYPTIAN HIEROGLYPH-14060;Lo;0;L;;;;;N;;;;;
+14061;EGYPTIAN HIEROGLYPH-14061;Lo;0;L;;;;;N;;;;;
+14062;EGYPTIAN HIEROGLYPH-14062;Lo;0;L;;;;;N;;;;;
+14063;EGYPTIAN HIEROGLYPH-14063;Lo;0;L;;;;;N;;;;;
+14064;EGYPTIAN HIEROGLYPH-14064;Lo;0;L;;;;;N;;;;;
+14065;EGYPTIAN HIEROGLYPH-14065;Lo;0;L;;;;;N;;;;;
+14066;EGYPTIAN HIEROGLYPH-14066;Lo;0;L;;;;;N;;;;;
+14067;EGYPTIAN HIEROGLYPH-14067;Lo;0;L;;;;;N;;;;;
+14068;EGYPTIAN HIEROGLYPH-14068;Lo;0;L;;;;;N;;;;;
+14069;EGYPTIAN HIEROGLYPH-14069;Lo;0;L;;;;;N;;;;;
+1406A;EGYPTIAN HIEROGLYPH-1406A;Lo;0;L;;;;;N;;;;;
+1406B;EGYPTIAN HIEROGLYPH-1406B;Lo;0;L;;;;;N;;;;;
+1406C;EGYPTIAN HIEROGLYPH-1406C;Lo;0;L;;;;;N;;;;;
+1406D;EGYPTIAN HIEROGLYPH-1406D;Lo;0;L;;;;;N;;;;;
+1406E;EGYPTIAN HIEROGLYPH-1406E;Lo;0;L;;;;;N;;;;;
+1406F;EGYPTIAN HIEROGLYPH-1406F;Lo;0;L;;;;;N;;;;;
+14070;EGYPTIAN HIEROGLYPH-14070;Lo;0;L;;;;;N;;;;;
+14071;EGYPTIAN HIEROGLYPH-14071;Lo;0;L;;;;;N;;;;;
+14072;EGYPTIAN HIEROGLYPH-14072;Lo;0;L;;;;;N;;;;;
+14073;EGYPTIAN HIEROGLYPH-14073;Lo;0;L;;;;;N;;;;;
+14074;EGYPTIAN HIEROGLYPH-14074;Lo;0;L;;;;;N;;;;;
+14075;EGYPTIAN HIEROGLYPH-14075;Lo;0;L;;;;;N;;;;;
+14076;EGYPTIAN HIEROGLYPH-14076;Lo;0;L;;;;;N;;;;;
+14077;EGYPTIAN HIEROGLYPH-14077;Lo;0;L;;;;;N;;;;;
+14078;EGYPTIAN HIEROGLYPH-14078;Lo;0;L;;;;;N;;;;;
+14079;EGYPTIAN HIEROGLYPH-14079;Lo;0;L;;;;;N;;;;;
+1407A;EGYPTIAN HIEROGLYPH-1407A;Lo;0;L;;;;;N;;;;;
+1407B;EGYPTIAN HIEROGLYPH-1407B;Lo;0;L;;;;;N;;;;;
+1407C;EGYPTIAN HIEROGLYPH-1407C;Lo;0;L;;;;;N;;;;;
+1407D;EGYPTIAN HIEROGLYPH-1407D;Lo;0;L;;;;;N;;;;;
+1407E;EGYPTIAN HIEROGLYPH-1407E;Lo;0;L;;;;;N;;;;;
+1407F;EGYPTIAN HIEROGLYPH-1407F;Lo;0;L;;;;;N;;;;;
+14080;EGYPTIAN HIEROGLYPH-14080;Lo;0;L;;;;;N;;;;;
+14081;EGYPTIAN HIEROGLYPH-14081;Lo;0;L;;;;;N;;;;;
+14082;EGYPTIAN HIEROGLYPH-14082;Lo;0;L;;;;;N;;;;;
+14083;EGYPTIAN HIEROGLYPH-14083;Lo;0;L;;;;;N;;;;;
+14084;EGYPTIAN HIEROGLYPH-14084;Lo;0;L;;;;;N;;;;;
+14085;EGYPTIAN HIEROGLYPH-14085;Lo;0;L;;;;;N;;;;;
+14086;EGYPTIAN HIEROGLYPH-14086;Lo;0;L;;;;;N;;;;;
+14087;EGYPTIAN HIEROGLYPH-14087;Lo;0;L;;;;;N;;;;;
+14088;EGYPTIAN HIEROGLYPH-14088;Lo;0;L;;;;;N;;;;;
+14089;EGYPTIAN HIEROGLYPH-14089;Lo;0;L;;;;;N;;;;;
+1408A;EGYPTIAN HIEROGLYPH-1408A;Lo;0;L;;;;;N;;;;;
+1408B;EGYPTIAN HIEROGLYPH-1408B;Lo;0;L;;;;;N;;;;;
+1408C;EGYPTIAN HIEROGLYPH-1408C;Lo;0;L;;;;;N;;;;;
+1408D;EGYPTIAN HIEROGLYPH-1408D;Lo;0;L;;;;;N;;;;;
+1408E;EGYPTIAN HIEROGLYPH-1408E;Lo;0;L;;;;;N;;;;;
+1408F;EGYPTIAN HIEROGLYPH-1408F;Lo;0;L;;;;;N;;;;;
+14090;EGYPTIAN HIEROGLYPH-14090;Lo;0;L;;;;;N;;;;;
+14091;EGYPTIAN HIEROGLYPH-14091;Lo;0;L;;;;;N;;;;;
+14092;EGYPTIAN HIEROGLYPH-14092;Lo;0;L;;;;;N;;;;;
+14093;EGYPTIAN HIEROGLYPH-14093;Lo;0;L;;;;;N;;;;;
+14094;EGYPTIAN HIEROGLYPH-14094;Lo;0;L;;;;;N;;;;;
+14095;EGYPTIAN HIEROGLYPH-14095;Lo;0;L;;;;;N;;;;;
+14096;EGYPTIAN HIEROGLYPH-14096;Lo;0;L;;;;;N;;;;;
+14097;EGYPTIAN HIEROGLYPH-14097;Lo;0;L;;;;;N;;;;;
+14098;EGYPTIAN HIEROGLYPH-14098;Lo;0;L;;;;;N;;;;;
+14099;EGYPTIAN HIEROGLYPH-14099;Lo;0;L;;;;;N;;;;;
+1409A;EGYPTIAN HIEROGLYPH-1409A;Lo;0;L;;;;;N;;;;;
+1409B;EGYPTIAN HIEROGLYPH-1409B;Lo;0;L;;;;;N;;;;;
+1409C;EGYPTIAN HIEROGLYPH-1409C;Lo;0;L;;;;;N;;;;;
+1409D;EGYPTIAN HIEROGLYPH-1409D;Lo;0;L;;;;;N;;;;;
+1409E;EGYPTIAN HIEROGLYPH-1409E;Lo;0;L;;;;;N;;;;;
+1409F;EGYPTIAN HIEROGLYPH-1409F;Lo;0;L;;;;;N;;;;;
+140A0;EGYPTIAN HIEROGLYPH-140A0;Lo;0;L;;;;;N;;;;;
+140A1;EGYPTIAN HIEROGLYPH-140A1;Lo;0;L;;;;;N;;;;;
+140A2;EGYPTIAN HIEROGLYPH-140A2;Lo;0;L;;;;;N;;;;;
+140A3;EGYPTIAN HIEROGLYPH-140A3;Lo;0;L;;;;;N;;;;;
+140A4;EGYPTIAN HIEROGLYPH-140A4;Lo;0;L;;;;;N;;;;;
+140A5;EGYPTIAN HIEROGLYPH-140A5;Lo;0;L;;;;;N;;;;;
+140A6;EGYPTIAN HIEROGLYPH-140A6;Lo;0;L;;;;;N;;;;;
+140A7;EGYPTIAN HIEROGLYPH-140A7;Lo;0;L;;;;;N;;;;;
+140A8;EGYPTIAN HIEROGLYPH-140A8;Lo;0;L;;;;;N;;;;;
+140A9;EGYPTIAN HIEROGLYPH-140A9;Lo;0;L;;;;;N;;;;;
+140AA;EGYPTIAN HIEROGLYPH-140AA;Lo;0;L;;;;;N;;;;;
+140AB;EGYPTIAN HIEROGLYPH-140AB;Lo;0;L;;;;;N;;;;;
+140AC;EGYPTIAN HIEROGLYPH-140AC;Lo;0;L;;;;;N;;;;;
+140AD;EGYPTIAN HIEROGLYPH-140AD;Lo;0;L;;;;;N;;;;;
+140AE;EGYPTIAN HIEROGLYPH-140AE;Lo;0;L;;;;;N;;;;;
+140AF;EGYPTIAN HIEROGLYPH-140AF;Lo;0;L;;;;;N;;;;;
+140B0;EGYPTIAN HIEROGLYPH-140B0;Lo;0;L;;;;;N;;;;;
+140B1;EGYPTIAN HIEROGLYPH-140B1;Lo;0;L;;;;;N;;;;;
+140B2;EGYPTIAN HIEROGLYPH-140B2;Lo;0;L;;;;;N;;;;;
+140B3;EGYPTIAN HIEROGLYPH-140B3;Lo;0;L;;;;;N;;;;;
+140B4;EGYPTIAN HIEROGLYPH-140B4;Lo;0;L;;;;;N;;;;;
+140B5;EGYPTIAN HIEROGLYPH-140B5;Lo;0;L;;;;;N;;;;;
+140B6;EGYPTIAN HIEROGLYPH-140B6;Lo;0;L;;;;;N;;;;;
+140B7;EGYPTIAN HIEROGLYPH-140B7;Lo;0;L;;;;;N;;;;;
+140B8;EGYPTIAN HIEROGLYPH-140B8;Lo;0;L;;;;;N;;;;;
+140B9;EGYPTIAN HIEROGLYPH-140B9;Lo;0;L;;;;;N;;;;;
+140BA;EGYPTIAN HIEROGLYPH-140BA;Lo;0;L;;;;;N;;;;;
+140BB;EGYPTIAN HIEROGLYPH-140BB;Lo;0;L;;;;;N;;;;;
+140BC;EGYPTIAN HIEROGLYPH-140BC;Lo;0;L;;;;;N;;;;;
+140BD;EGYPTIAN HIEROGLYPH-140BD;Lo;0;L;;;;;N;;;;;
+140BE;EGYPTIAN HIEROGLYPH-140BE;Lo;0;L;;;;;N;;;;;
+140BF;EGYPTIAN HIEROGLYPH-140BF;Lo;0;L;;;;;N;;;;;
+140C0;EGYPTIAN HIEROGLYPH-140C0;Lo;0;L;;;;;N;;;;;
+140C1;EGYPTIAN HIEROGLYPH-140C1;Lo;0;L;;;;;N;;;;;
+140C2;EGYPTIAN HIEROGLYPH-140C2;Lo;0;L;;;;;N;;;;;
+140C3;EGYPTIAN HIEROGLYPH-140C3;Lo;0;L;;;;;N;;;;;
+140C4;EGYPTIAN HIEROGLYPH-140C4;Lo;0;L;;;;;N;;;;;
+140C5;EGYPTIAN HIEROGLYPH-140C5;Lo;0;L;;;;;N;;;;;
+140C6;EGYPTIAN HIEROGLYPH-140C6;Lo;0;L;;;;;N;;;;;
+140C7;EGYPTIAN HIEROGLYPH-140C7;Lo;0;L;;;;;N;;;;;
+140C8;EGYPTIAN HIEROGLYPH-140C8;Lo;0;L;;;;;N;;;;;
+140C9;EGYPTIAN HIEROGLYPH-140C9;Lo;0;L;;;;;N;;;;;
+140CA;EGYPTIAN HIEROGLYPH-140CA;Lo;0;L;;;;;N;;;;;
+140CB;EGYPTIAN HIEROGLYPH-140CB;Lo;0;L;;;;;N;;;;;
+140CC;EGYPTIAN HIEROGLYPH-140CC;Lo;0;L;;;;;N;;;;;
+140CD;EGYPTIAN HIEROGLYPH-140CD;Lo;0;L;;;;;N;;;;;
+140CE;EGYPTIAN HIEROGLYPH-140CE;Lo;0;L;;;;;N;;;;;
+140CF;EGYPTIAN HIEROGLYPH-140CF;Lo;0;L;;;;;N;;;;;
+140D0;EGYPTIAN HIEROGLYPH-140D0;Lo;0;L;;;;;N;;;;;
+140D1;EGYPTIAN HIEROGLYPH-140D1;Lo;0;L;;;;;N;;;;;
+140D2;EGYPTIAN HIEROGLYPH-140D2;Lo;0;L;;;;;N;;;;;
+140D3;EGYPTIAN HIEROGLYPH-140D3;Lo;0;L;;;;;N;;;;;
+140D4;EGYPTIAN HIEROGLYPH-140D4;Lo;0;L;;;;;N;;;;;
+140D5;EGYPTIAN HIEROGLYPH-140D5;Lo;0;L;;;;;N;;;;;
+140D6;EGYPTIAN HIEROGLYPH-140D6;Lo;0;L;;;;;N;;;;;
+140D7;EGYPTIAN HIEROGLYPH-140D7;Lo;0;L;;;;;N;;;;;
+140D8;EGYPTIAN HIEROGLYPH-140D8;Lo;0;L;;;;;N;;;;;
+140D9;EGYPTIAN HIEROGLYPH-140D9;Lo;0;L;;;;;N;;;;;
+140DA;EGYPTIAN HIEROGLYPH-140DA;Lo;0;L;;;;;N;;;;;
+140DB;EGYPTIAN HIEROGLYPH-140DB;Lo;0;L;;;;;N;;;;;
+140DC;EGYPTIAN HIEROGLYPH-140DC;Lo;0;L;;;;;N;;;;;
+140DD;EGYPTIAN HIEROGLYPH-140DD;Lo;0;L;;;;;N;;;;;
+140DE;EGYPTIAN HIEROGLYPH-140DE;Lo;0;L;;;;;N;;;;;
+140DF;EGYPTIAN HIEROGLYPH-140DF;Lo;0;L;;;;;N;;;;;
+140E0;EGYPTIAN HIEROGLYPH-140E0;Lo;0;L;;;;;N;;;;;
+140E1;EGYPTIAN HIEROGLYPH-140E1;Lo;0;L;;;;;N;;;;;
+140E2;EGYPTIAN HIEROGLYPH-140E2;Lo;0;L;;;;;N;;;;;
+140E3;EGYPTIAN HIEROGLYPH-140E3;Lo;0;L;;;;;N;;;;;
+140E4;EGYPTIAN HIEROGLYPH-140E4;Lo;0;L;;;;;N;;;;;
+140E5;EGYPTIAN HIEROGLYPH-140E5;Lo;0;L;;;;;N;;;;;
+140E6;EGYPTIAN HIEROGLYPH-140E6;Lo;0;L;;;;;N;;;;;
+140E7;EGYPTIAN HIEROGLYPH-140E7;Lo;0;L;;;;;N;;;;;
+140E8;EGYPTIAN HIEROGLYPH-140E8;Lo;0;L;;;;;N;;;;;
+140E9;EGYPTIAN HIEROGLYPH-140E9;Lo;0;L;;;;;N;;;;;
+140EA;EGYPTIAN HIEROGLYPH-140EA;Lo;0;L;;;;;N;;;;;
+140EB;EGYPTIAN HIEROGLYPH-140EB;Lo;0;L;;;;;N;;;;;
+140EC;EGYPTIAN HIEROGLYPH-140EC;Lo;0;L;;;;;N;;;;;
+140ED;EGYPTIAN HIEROGLYPH-140ED;Lo;0;L;;;;;N;;;;;
+140EE;EGYPTIAN HIEROGLYPH-140EE;Lo;0;L;;;;;N;;;;;
+140EF;EGYPTIAN HIEROGLYPH-140EF;Lo;0;L;;;;;N;;;;;
+140F0;EGYPTIAN HIEROGLYPH-140F0;Lo;0;L;;;;;N;;;;;
+140F1;EGYPTIAN HIEROGLYPH-140F1;Lo;0;L;;;;;N;;;;;
+140F2;EGYPTIAN HIEROGLYPH-140F2;Lo;0;L;;;;;N;;;;;
+140F3;EGYPTIAN HIEROGLYPH-140F3;Lo;0;L;;;;;N;;;;;
+140F4;EGYPTIAN HIEROGLYPH-140F4;Lo;0;L;;;;;N;;;;;
+140F5;EGYPTIAN HIEROGLYPH-140F5;Lo;0;L;;;;;N;;;;;
+140F6;EGYPTIAN HIEROGLYPH-140F6;Lo;0;L;;;;;N;;;;;
+140F7;EGYPTIAN HIEROGLYPH-140F7;Lo;0;L;;;;;N;;;;;
+140F8;EGYPTIAN HIEROGLYPH-140F8;Lo;0;L;;;;;N;;;;;
+140F9;EGYPTIAN HIEROGLYPH-140F9;Lo;0;L;;;;;N;;;;;
+140FA;EGYPTIAN HIEROGLYPH-140FA;Lo;0;L;;;;;N;;;;;
+140FB;EGYPTIAN HIEROGLYPH-140FB;Lo;0;L;;;;;N;;;;;
+140FC;EGYPTIAN HIEROGLYPH-140FC;Lo;0;L;;;;;N;;;;;
+140FD;EGYPTIAN HIEROGLYPH-140FD;Lo;0;L;;;;;N;;;;;
+140FE;EGYPTIAN HIEROGLYPH-140FE;Lo;0;L;;;;;N;;;;;
+140FF;EGYPTIAN HIEROGLYPH-140FF;Lo;0;L;;;;;N;;;;;
+14100;EGYPTIAN HIEROGLYPH-14100;Lo;0;L;;;;;N;;;;;
+14101;EGYPTIAN HIEROGLYPH-14101;Lo;0;L;;;;;N;;;;;
+14102;EGYPTIAN HIEROGLYPH-14102;Lo;0;L;;;;;N;;;;;
+14103;EGYPTIAN HIEROGLYPH-14103;Lo;0;L;;;;;N;;;;;
+14104;EGYPTIAN HIEROGLYPH-14104;Lo;0;L;;;;;N;;;;;
+14105;EGYPTIAN HIEROGLYPH-14105;Lo;0;L;;;;;N;;;;;
+14106;EGYPTIAN HIEROGLYPH-14106;Lo;0;L;;;;;N;;;;;
+14107;EGYPTIAN HIEROGLYPH-14107;Lo;0;L;;;;;N;;;;;
+14108;EGYPTIAN HIEROGLYPH-14108;Lo;0;L;;;;;N;;;;;
+14109;EGYPTIAN HIEROGLYPH-14109;Lo;0;L;;;;;N;;;;;
+1410A;EGYPTIAN HIEROGLYPH-1410A;Lo;0;L;;;;;N;;;;;
+1410B;EGYPTIAN HIEROGLYPH-1410B;Lo;0;L;;;;;N;;;;;
+1410C;EGYPTIAN HIEROGLYPH-1410C;Lo;0;L;;;;;N;;;;;
+1410D;EGYPTIAN HIEROGLYPH-1410D;Lo;0;L;;;;;N;;;;;
+1410E;EGYPTIAN HIEROGLYPH-1410E;Lo;0;L;;;;;N;;;;;
+1410F;EGYPTIAN HIEROGLYPH-1410F;Lo;0;L;;;;;N;;;;;
+14110;EGYPTIAN HIEROGLYPH-14110;Lo;0;L;;;;;N;;;;;
+14111;EGYPTIAN HIEROGLYPH-14111;Lo;0;L;;;;;N;;;;;
+14112;EGYPTIAN HIEROGLYPH-14112;Lo;0;L;;;;;N;;;;;
+14113;EGYPTIAN HIEROGLYPH-14113;Lo;0;L;;;;;N;;;;;
+14114;EGYPTIAN HIEROGLYPH-14114;Lo;0;L;;;;;N;;;;;
+14115;EGYPTIAN HIEROGLYPH-14115;Lo;0;L;;;;;N;;;;;
+14116;EGYPTIAN HIEROGLYPH-14116;Lo;0;L;;;;;N;;;;;
+14117;EGYPTIAN HIEROGLYPH-14117;Lo;0;L;;;;;N;;;;;
+14118;EGYPTIAN HIEROGLYPH-14118;Lo;0;L;;;;;N;;;;;
+14119;EGYPTIAN HIEROGLYPH-14119;Lo;0;L;;;;;N;;;;;
+1411A;EGYPTIAN HIEROGLYPH-1411A;Lo;0;L;;;;;N;;;;;
+1411B;EGYPTIAN HIEROGLYPH-1411B;Lo;0;L;;;;;N;;;;;
+1411C;EGYPTIAN HIEROGLYPH-1411C;Lo;0;L;;;;;N;;;;;
+1411D;EGYPTIAN HIEROGLYPH-1411D;Lo;0;L;;;;;N;;;;;
+1411E;EGYPTIAN HIEROGLYPH-1411E;Lo;0;L;;;;;N;;;;;
+1411F;EGYPTIAN HIEROGLYPH-1411F;Lo;0;L;;;;;N;;;;;
+14120;EGYPTIAN HIEROGLYPH-14120;Lo;0;L;;;;;N;;;;;
+14121;EGYPTIAN HIEROGLYPH-14121;Lo;0;L;;;;;N;;;;;
+14122;EGYPTIAN HIEROGLYPH-14122;Lo;0;L;;;;;N;;;;;
+14123;EGYPTIAN HIEROGLYPH-14123;Lo;0;L;;;;;N;;;;;
+14124;EGYPTIAN HIEROGLYPH-14124;Lo;0;L;;;;;N;;;;;
+14125;EGYPTIAN HIEROGLYPH-14125;Lo;0;L;;;;;N;;;;;
+14126;EGYPTIAN HIEROGLYPH-14126;Lo;0;L;;;;;N;;;;;
+14127;EGYPTIAN HIEROGLYPH-14127;Lo;0;L;;;;;N;;;;;
+14128;EGYPTIAN HIEROGLYPH-14128;Lo;0;L;;;;;N;;;;;
+14129;EGYPTIAN HIEROGLYPH-14129;Lo;0;L;;;;;N;;;;;
+1412A;EGYPTIAN HIEROGLYPH-1412A;Lo;0;L;;;;;N;;;;;
+1412B;EGYPTIAN HIEROGLYPH-1412B;Lo;0;L;;;;;N;;;;;
+1412C;EGYPTIAN HIEROGLYPH-1412C;Lo;0;L;;;;;N;;;;;
+1412D;EGYPTIAN HIEROGLYPH-1412D;Lo;0;L;;;;;N;;;;;
+1412E;EGYPTIAN HIEROGLYPH-1412E;Lo;0;L;;;;;N;;;;;
+1412F;EGYPTIAN HIEROGLYPH-1412F;Lo;0;L;;;;;N;;;;;
+14130;EGYPTIAN HIEROGLYPH-14130;Lo;0;L;;;;;N;;;;;
+14131;EGYPTIAN HIEROGLYPH-14131;Lo;0;L;;;;;N;;;;;
+14132;EGYPTIAN HIEROGLYPH-14132;Lo;0;L;;;;;N;;;;;
+14133;EGYPTIAN HIEROGLYPH-14133;Lo;0;L;;;;;N;;;;;
+14134;EGYPTIAN HIEROGLYPH-14134;Lo;0;L;;;;;N;;;;;
+14135;EGYPTIAN HIEROGLYPH-14135;Lo;0;L;;;;;N;;;;;
+14136;EGYPTIAN HIEROGLYPH-14136;Lo;0;L;;;;;N;;;;;
+14137;EGYPTIAN HIEROGLYPH-14137;Lo;0;L;;;;;N;;;;;
+14138;EGYPTIAN HIEROGLYPH-14138;Lo;0;L;;;;;N;;;;;
+14139;EGYPTIAN HIEROGLYPH-14139;Lo;0;L;;;;;N;;;;;
+1413A;EGYPTIAN HIEROGLYPH-1413A;Lo;0;L;;;;;N;;;;;
+1413B;EGYPTIAN HIEROGLYPH-1413B;Lo;0;L;;;;;N;;;;;
+1413C;EGYPTIAN HIEROGLYPH-1413C;Lo;0;L;;;;;N;;;;;
+1413D;EGYPTIAN HIEROGLYPH-1413D;Lo;0;L;;;;;N;;;;;
+1413E;EGYPTIAN HIEROGLYPH-1413E;Lo;0;L;;;;;N;;;;;
+1413F;EGYPTIAN HIEROGLYPH-1413F;Lo;0;L;;;;;N;;;;;
+14140;EGYPTIAN HIEROGLYPH-14140;Lo;0;L;;;;;N;;;;;
+14141;EGYPTIAN HIEROGLYPH-14141;Lo;0;L;;;;;N;;;;;
+14142;EGYPTIAN HIEROGLYPH-14142;Lo;0;L;;;;;N;;;;;
+14143;EGYPTIAN HIEROGLYPH-14143;Lo;0;L;;;;;N;;;;;
+14144;EGYPTIAN HIEROGLYPH-14144;Lo;0;L;;;;;N;;;;;
+14145;EGYPTIAN HIEROGLYPH-14145;Lo;0;L;;;;;N;;;;;
+14146;EGYPTIAN HIEROGLYPH-14146;Lo;0;L;;;;;N;;;;;
+14147;EGYPTIAN HIEROGLYPH-14147;Lo;0;L;;;;;N;;;;;
+14148;EGYPTIAN HIEROGLYPH-14148;Lo;0;L;;;;;N;;;;;
+14149;EGYPTIAN HIEROGLYPH-14149;Lo;0;L;;;;;N;;;;;
+1414A;EGYPTIAN HIEROGLYPH-1414A;Lo;0;L;;;;;N;;;;;
+1414B;EGYPTIAN HIEROGLYPH-1414B;Lo;0;L;;;;;N;;;;;
+1414C;EGYPTIAN HIEROGLYPH-1414C;Lo;0;L;;;;;N;;;;;
+1414D;EGYPTIAN HIEROGLYPH-1414D;Lo;0;L;;;;;N;;;;;
+1414E;EGYPTIAN HIEROGLYPH-1414E;Lo;0;L;;;;;N;;;;;
+1414F;EGYPTIAN HIEROGLYPH-1414F;Lo;0;L;;;;;N;;;;;
+14150;EGYPTIAN HIEROGLYPH-14150;Lo;0;L;;;;;N;;;;;
+14151;EGYPTIAN HIEROGLYPH-14151;Lo;0;L;;;;;N;;;;;
+14152;EGYPTIAN HIEROGLYPH-14152;Lo;0;L;;;;;N;;;;;
+14153;EGYPTIAN HIEROGLYPH-14153;Lo;0;L;;;;;N;;;;;
+14154;EGYPTIAN HIEROGLYPH-14154;Lo;0;L;;;;;N;;;;;
+14155;EGYPTIAN HIEROGLYPH-14155;Lo;0;L;;;;;N;;;;;
+14156;EGYPTIAN HIEROGLYPH-14156;Lo;0;L;;;;;N;;;;;
+14157;EGYPTIAN HIEROGLYPH-14157;Lo;0;L;;;;;N;;;;;
+14158;EGYPTIAN HIEROGLYPH-14158;Lo;0;L;;;;;N;;;;;
+14159;EGYPTIAN HIEROGLYPH-14159;Lo;0;L;;;;;N;;;;;
+1415A;EGYPTIAN HIEROGLYPH-1415A;Lo;0;L;;;;;N;;;;;
+1415B;EGYPTIAN HIEROGLYPH-1415B;Lo;0;L;;;;;N;;;;;
+1415C;EGYPTIAN HIEROGLYPH-1415C;Lo;0;L;;;;;N;;;;;
+1415D;EGYPTIAN HIEROGLYPH-1415D;Lo;0;L;;;;;N;;;;;
+1415E;EGYPTIAN HIEROGLYPH-1415E;Lo;0;L;;;;;N;;;;;
+1415F;EGYPTIAN HIEROGLYPH-1415F;Lo;0;L;;;;;N;;;;;
+14160;EGYPTIAN HIEROGLYPH-14160;Lo;0;L;;;;;N;;;;;
+14161;EGYPTIAN HIEROGLYPH-14161;Lo;0;L;;;;;N;;;;;
+14162;EGYPTIAN HIEROGLYPH-14162;Lo;0;L;;;;;N;;;;;
+14163;EGYPTIAN HIEROGLYPH-14163;Lo;0;L;;;;;N;;;;;
+14164;EGYPTIAN HIEROGLYPH-14164;Lo;0;L;;;;;N;;;;;
+14165;EGYPTIAN HIEROGLYPH-14165;Lo;0;L;;;;;N;;;;;
+14166;EGYPTIAN HIEROGLYPH-14166;Lo;0;L;;;;;N;;;;;
+14167;EGYPTIAN HIEROGLYPH-14167;Lo;0;L;;;;;N;;;;;
+14168;EGYPTIAN HIEROGLYPH-14168;Lo;0;L;;;;;N;;;;;
+14169;EGYPTIAN HIEROGLYPH-14169;Lo;0;L;;;;;N;;;;;
+1416A;EGYPTIAN HIEROGLYPH-1416A;Lo;0;L;;;;;N;;;;;
+1416B;EGYPTIAN HIEROGLYPH-1416B;Lo;0;L;;;;;N;;;;;
+1416C;EGYPTIAN HIEROGLYPH-1416C;Lo;0;L;;;;;N;;;;;
+1416D;EGYPTIAN HIEROGLYPH-1416D;Lo;0;L;;;;;N;;;;;
+1416E;EGYPTIAN HIEROGLYPH-1416E;Lo;0;L;;;;;N;;;;;
+1416F;EGYPTIAN HIEROGLYPH-1416F;Lo;0;L;;;;;N;;;;;
+14170;EGYPTIAN HIEROGLYPH-14170;Lo;0;L;;;;;N;;;;;
+14171;EGYPTIAN HIEROGLYPH-14171;Lo;0;L;;;;;N;;;;;
+14172;EGYPTIAN HIEROGLYPH-14172;Lo;0;L;;;;;N;;;;;
+14173;EGYPTIAN HIEROGLYPH-14173;Lo;0;L;;;;;N;;;;;
+14174;EGYPTIAN HIEROGLYPH-14174;Lo;0;L;;;;;N;;;;;
+14175;EGYPTIAN HIEROGLYPH-14175;Lo;0;L;;;;;N;;;;;
+14176;EGYPTIAN HIEROGLYPH-14176;Lo;0;L;;;;;N;;;;;
+14177;EGYPTIAN HIEROGLYPH-14177;Lo;0;L;;;;;N;;;;;
+14178;EGYPTIAN HIEROGLYPH-14178;Lo;0;L;;;;;N;;;;;
+14179;EGYPTIAN HIEROGLYPH-14179;Lo;0;L;;;;;N;;;;;
+1417A;EGYPTIAN HIEROGLYPH-1417A;Lo;0;L;;;;;N;;;;;
+1417B;EGYPTIAN HIEROGLYPH-1417B;Lo;0;L;;;;;N;;;;;
+1417C;EGYPTIAN HIEROGLYPH-1417C;Lo;0;L;;;;;N;;;;;
+1417D;EGYPTIAN HIEROGLYPH-1417D;Lo;0;L;;;;;N;;;;;
+1417E;EGYPTIAN HIEROGLYPH-1417E;Lo;0;L;;;;;N;;;;;
+1417F;EGYPTIAN HIEROGLYPH-1417F;Lo;0;L;;;;;N;;;;;
+14180;EGYPTIAN HIEROGLYPH-14180;Lo;0;L;;;;;N;;;;;
+14181;EGYPTIAN HIEROGLYPH-14181;Lo;0;L;;;;;N;;;;;
+14182;EGYPTIAN HIEROGLYPH-14182;Lo;0;L;;;;;N;;;;;
+14183;EGYPTIAN HIEROGLYPH-14183;Lo;0;L;;;;;N;;;;;
+14184;EGYPTIAN HIEROGLYPH-14184;Lo;0;L;;;;;N;;;;;
+14185;EGYPTIAN HIEROGLYPH-14185;Lo;0;L;;;;;N;;;;;
+14186;EGYPTIAN HIEROGLYPH-14186;Lo;0;L;;;;;N;;;;;
+14187;EGYPTIAN HIEROGLYPH-14187;Lo;0;L;;;;;N;;;;;
+14188;EGYPTIAN HIEROGLYPH-14188;Lo;0;L;;;;;N;;;;;
+14189;EGYPTIAN HIEROGLYPH-14189;Lo;0;L;;;;;N;;;;;
+1418A;EGYPTIAN HIEROGLYPH-1418A;Lo;0;L;;;;;N;;;;;
+1418B;EGYPTIAN HIEROGLYPH-1418B;Lo;0;L;;;;;N;;;;;
+1418C;EGYPTIAN HIEROGLYPH-1418C;Lo;0;L;;;;;N;;;;;
+1418D;EGYPTIAN HIEROGLYPH-1418D;Lo;0;L;;;;;N;;;;;
+1418E;EGYPTIAN HIEROGLYPH-1418E;Lo;0;L;;;;;N;;;;;
+1418F;EGYPTIAN HIEROGLYPH-1418F;Lo;0;L;;;;;N;;;;;
+14190;EGYPTIAN HIEROGLYPH-14190;Lo;0;L;;;;;N;;;;;
+14191;EGYPTIAN HIEROGLYPH-14191;Lo;0;L;;;;;N;;;;;
+14192;EGYPTIAN HIEROGLYPH-14192;Lo;0;L;;;;;N;;;;;
+14193;EGYPTIAN HIEROGLYPH-14193;Lo;0;L;;;;;N;;;;;
+14194;EGYPTIAN HIEROGLYPH-14194;Lo;0;L;;;;;N;;;;;
+14195;EGYPTIAN HIEROGLYPH-14195;Lo;0;L;;;;;N;;;;;
+14196;EGYPTIAN HIEROGLYPH-14196;Lo;0;L;;;;;N;;;;;
+14197;EGYPTIAN HIEROGLYPH-14197;Lo;0;L;;;;;N;;;;;
+14198;EGYPTIAN HIEROGLYPH-14198;Lo;0;L;;;;;N;;;;;
+14199;EGYPTIAN HIEROGLYPH-14199;Lo;0;L;;;;;N;;;;;
+1419A;EGYPTIAN HIEROGLYPH-1419A;Lo;0;L;;;;;N;;;;;
+1419B;EGYPTIAN HIEROGLYPH-1419B;Lo;0;L;;;;;N;;;;;
+1419C;EGYPTIAN HIEROGLYPH-1419C;Lo;0;L;;;;;N;;;;;
+1419D;EGYPTIAN HIEROGLYPH-1419D;Lo;0;L;;;;;N;;;;;
+1419E;EGYPTIAN HIEROGLYPH-1419E;Lo;0;L;;;;;N;;;;;
+1419F;EGYPTIAN HIEROGLYPH-1419F;Lo;0;L;;;;;N;;;;;
+141A0;EGYPTIAN HIEROGLYPH-141A0;Lo;0;L;;;;;N;;;;;
+141A1;EGYPTIAN HIEROGLYPH-141A1;Lo;0;L;;;;;N;;;;;
+141A2;EGYPTIAN HIEROGLYPH-141A2;Lo;0;L;;;;;N;;;;;
+141A3;EGYPTIAN HIEROGLYPH-141A3;Lo;0;L;;;;;N;;;;;
+141A4;EGYPTIAN HIEROGLYPH-141A4;Lo;0;L;;;;;N;;;;;
+141A5;EGYPTIAN HIEROGLYPH-141A5;Lo;0;L;;;;;N;;;;;
+141A6;EGYPTIAN HIEROGLYPH-141A6;Lo;0;L;;;;;N;;;;;
+141A7;EGYPTIAN HIEROGLYPH-141A7;Lo;0;L;;;;;N;;;;;
+141A8;EGYPTIAN HIEROGLYPH-141A8;Lo;0;L;;;;;N;;;;;
+141A9;EGYPTIAN HIEROGLYPH-141A9;Lo;0;L;;;;;N;;;;;
+141AA;EGYPTIAN HIEROGLYPH-141AA;Lo;0;L;;;;;N;;;;;
+141AB;EGYPTIAN HIEROGLYPH-141AB;Lo;0;L;;;;;N;;;;;
+141AC;EGYPTIAN HIEROGLYPH-141AC;Lo;0;L;;;;;N;;;;;
+141AD;EGYPTIAN HIEROGLYPH-141AD;Lo;0;L;;;;;N;;;;;
+141AE;EGYPTIAN HIEROGLYPH-141AE;Lo;0;L;;;;;N;;;;;
+141AF;EGYPTIAN HIEROGLYPH-141AF;Lo;0;L;;;;;N;;;;;
+141B0;EGYPTIAN HIEROGLYPH-141B0;Lo;0;L;;;;;N;;;;;
+141B1;EGYPTIAN HIEROGLYPH-141B1;Lo;0;L;;;;;N;;;;;
+141B2;EGYPTIAN HIEROGLYPH-141B2;Lo;0;L;;;;;N;;;;;
+141B3;EGYPTIAN HIEROGLYPH-141B3;Lo;0;L;;;;;N;;;;;
+141B4;EGYPTIAN HIEROGLYPH-141B4;Lo;0;L;;;;;N;;;;;
+141B5;EGYPTIAN HIEROGLYPH-141B5;Lo;0;L;;;;;N;;;;;
+141B6;EGYPTIAN HIEROGLYPH-141B6;Lo;0;L;;;;;N;;;;;
+141B7;EGYPTIAN HIEROGLYPH-141B7;Lo;0;L;;;;;N;;;;;
+141B8;EGYPTIAN HIEROGLYPH-141B8;Lo;0;L;;;;;N;;;;;
+141B9;EGYPTIAN HIEROGLYPH-141B9;Lo;0;L;;;;;N;;;;;
+141BA;EGYPTIAN HIEROGLYPH-141BA;Lo;0;L;;;;;N;;;;;
+141BB;EGYPTIAN HIEROGLYPH-141BB;Lo;0;L;;;;;N;;;;;
+141BC;EGYPTIAN HIEROGLYPH-141BC;Lo;0;L;;;;;N;;;;;
+141BD;EGYPTIAN HIEROGLYPH-141BD;Lo;0;L;;;;;N;;;;;
+141BE;EGYPTIAN HIEROGLYPH-141BE;Lo;0;L;;;;;N;;;;;
+141BF;EGYPTIAN HIEROGLYPH-141BF;Lo;0;L;;;;;N;;;;;
+141C0;EGYPTIAN HIEROGLYPH-141C0;Lo;0;L;;;;;N;;;;;
+141C1;EGYPTIAN HIEROGLYPH-141C1;Lo;0;L;;;;;N;;;;;
+141C2;EGYPTIAN HIEROGLYPH-141C2;Lo;0;L;;;;;N;;;;;
+141C3;EGYPTIAN HIEROGLYPH-141C3;Lo;0;L;;;;;N;;;;;
+141C4;EGYPTIAN HIEROGLYPH-141C4;Lo;0;L;;;;;N;;;;;
+141C5;EGYPTIAN HIEROGLYPH-141C5;Lo;0;L;;;;;N;;;;;
+141C6;EGYPTIAN HIEROGLYPH-141C6;Lo;0;L;;;;;N;;;;;
+141C7;EGYPTIAN HIEROGLYPH-141C7;Lo;0;L;;;;;N;;;;;
+141C8;EGYPTIAN HIEROGLYPH-141C8;Lo;0;L;;;;;N;;;;;
+141C9;EGYPTIAN HIEROGLYPH-141C9;Lo;0;L;;;;;N;;;;;
+141CA;EGYPTIAN HIEROGLYPH-141CA;Lo;0;L;;;;;N;;;;;
+141CB;EGYPTIAN HIEROGLYPH-141CB;Lo;0;L;;;;;N;;;;;
+141CC;EGYPTIAN HIEROGLYPH-141CC;Lo;0;L;;;;;N;;;;;
+141CD;EGYPTIAN HIEROGLYPH-141CD;Lo;0;L;;;;;N;;;;;
+141CE;EGYPTIAN HIEROGLYPH-141CE;Lo;0;L;;;;;N;;;;;
+141CF;EGYPTIAN HIEROGLYPH-141CF;Lo;0;L;;;;;N;;;;;
+141D0;EGYPTIAN HIEROGLYPH-141D0;Lo;0;L;;;;;N;;;;;
+141D1;EGYPTIAN HIEROGLYPH-141D1;Lo;0;L;;;;;N;;;;;
+141D2;EGYPTIAN HIEROGLYPH-141D2;Lo;0;L;;;;;N;;;;;
+141D3;EGYPTIAN HIEROGLYPH-141D3;Lo;0;L;;;;;N;;;;;
+141D4;EGYPTIAN HIEROGLYPH-141D4;Lo;0;L;;;;;N;;;;;
+141D5;EGYPTIAN HIEROGLYPH-141D5;Lo;0;L;;;;;N;;;;;
+141D6;EGYPTIAN HIEROGLYPH-141D6;Lo;0;L;;;;;N;;;;;
+141D7;EGYPTIAN HIEROGLYPH-141D7;Lo;0;L;;;;;N;;;;;
+141D8;EGYPTIAN HIEROGLYPH-141D8;Lo;0;L;;;;;N;;;;;
+141D9;EGYPTIAN HIEROGLYPH-141D9;Lo;0;L;;;;;N;;;;;
+141DA;EGYPTIAN HIEROGLYPH-141DA;Lo;0;L;;;;;N;;;;;
+141DB;EGYPTIAN HIEROGLYPH-141DB;Lo;0;L;;;;;N;;;;;
+141DC;EGYPTIAN HIEROGLYPH-141DC;Lo;0;L;;;;;N;;;;;
+141DD;EGYPTIAN HIEROGLYPH-141DD;Lo;0;L;;;;;N;;;;;
+141DE;EGYPTIAN HIEROGLYPH-141DE;Lo;0;L;;;;;N;;;;;
+141DF;EGYPTIAN HIEROGLYPH-141DF;Lo;0;L;;;;;N;;;;;
+141E0;EGYPTIAN HIEROGLYPH-141E0;Lo;0;L;;;;;N;;;;;
+141E1;EGYPTIAN HIEROGLYPH-141E1;Lo;0;L;;;;;N;;;;;
+141E2;EGYPTIAN HIEROGLYPH-141E2;Lo;0;L;;;;;N;;;;;
+141E3;EGYPTIAN HIEROGLYPH-141E3;Lo;0;L;;;;;N;;;;;
+141E4;EGYPTIAN HIEROGLYPH-141E4;Lo;0;L;;;;;N;;;;;
+141E5;EGYPTIAN HIEROGLYPH-141E5;Lo;0;L;;;;;N;;;;;
+141E6;EGYPTIAN HIEROGLYPH-141E6;Lo;0;L;;;;;N;;;;;
+141E7;EGYPTIAN HIEROGLYPH-141E7;Lo;0;L;;;;;N;;;;;
+141E8;EGYPTIAN HIEROGLYPH-141E8;Lo;0;L;;;;;N;;;;;
+141E9;EGYPTIAN HIEROGLYPH-141E9;Lo;0;L;;;;;N;;;;;
+141EA;EGYPTIAN HIEROGLYPH-141EA;Lo;0;L;;;;;N;;;;;
+141EB;EGYPTIAN HIEROGLYPH-141EB;Lo;0;L;;;;;N;;;;;
+141EC;EGYPTIAN HIEROGLYPH-141EC;Lo;0;L;;;;;N;;;;;
+141ED;EGYPTIAN HIEROGLYPH-141ED;Lo;0;L;;;;;N;;;;;
+141EE;EGYPTIAN HIEROGLYPH-141EE;Lo;0;L;;;;;N;;;;;
+141EF;EGYPTIAN HIEROGLYPH-141EF;Lo;0;L;;;;;N;;;;;
+141F0;EGYPTIAN HIEROGLYPH-141F0;Lo;0;L;;;;;N;;;;;
+141F1;EGYPTIAN HIEROGLYPH-141F1;Lo;0;L;;;;;N;;;;;
+141F2;EGYPTIAN HIEROGLYPH-141F2;Lo;0;L;;;;;N;;;;;
+141F3;EGYPTIAN HIEROGLYPH-141F3;Lo;0;L;;;;;N;;;;;
+141F4;EGYPTIAN HIEROGLYPH-141F4;Lo;0;L;;;;;N;;;;;
+141F5;EGYPTIAN HIEROGLYPH-141F5;Lo;0;L;;;;;N;;;;;
+141F6;EGYPTIAN HIEROGLYPH-141F6;Lo;0;L;;;;;N;;;;;
+141F7;EGYPTIAN HIEROGLYPH-141F7;Lo;0;L;;;;;N;;;;;
+141F8;EGYPTIAN HIEROGLYPH-141F8;Lo;0;L;;;;;N;;;;;
+141F9;EGYPTIAN HIEROGLYPH-141F9;Lo;0;L;;;;;N;;;;;
+141FA;EGYPTIAN HIEROGLYPH-141FA;Lo;0;L;;;;;N;;;;;
+141FB;EGYPTIAN HIEROGLYPH-141FB;Lo;0;L;;;;;N;;;;;
+141FC;EGYPTIAN HIEROGLYPH-141FC;Lo;0;L;;;;;N;;;;;
+141FD;EGYPTIAN HIEROGLYPH-141FD;Lo;0;L;;;;;N;;;;;
+141FE;EGYPTIAN HIEROGLYPH-141FE;Lo;0;L;;;;;N;;;;;
+141FF;EGYPTIAN HIEROGLYPH-141FF;Lo;0;L;;;;;N;;;;;
+14200;EGYPTIAN HIEROGLYPH-14200;Lo;0;L;;;;;N;;;;;
+14201;EGYPTIAN HIEROGLYPH-14201;Lo;0;L;;;;;N;;;;;
+14202;EGYPTIAN HIEROGLYPH-14202;Lo;0;L;;;;;N;;;;;
+14203;EGYPTIAN HIEROGLYPH-14203;Lo;0;L;;;;;N;;;;;
+14204;EGYPTIAN HIEROGLYPH-14204;Lo;0;L;;;;;N;;;;;
+14205;EGYPTIAN HIEROGLYPH-14205;Lo;0;L;;;;;N;;;;;
+14206;EGYPTIAN HIEROGLYPH-14206;Lo;0;L;;;;;N;;;;;
+14207;EGYPTIAN HIEROGLYPH-14207;Lo;0;L;;;;;N;;;;;
+14208;EGYPTIAN HIEROGLYPH-14208;Lo;0;L;;;;;N;;;;;
+14209;EGYPTIAN HIEROGLYPH-14209;Lo;0;L;;;;;N;;;;;
+1420A;EGYPTIAN HIEROGLYPH-1420A;Lo;0;L;;;;;N;;;;;
+1420B;EGYPTIAN HIEROGLYPH-1420B;Lo;0;L;;;;;N;;;;;
+1420C;EGYPTIAN HIEROGLYPH-1420C;Lo;0;L;;;;;N;;;;;
+1420D;EGYPTIAN HIEROGLYPH-1420D;Lo;0;L;;;;;N;;;;;
+1420E;EGYPTIAN HIEROGLYPH-1420E;Lo;0;L;;;;;N;;;;;
+1420F;EGYPTIAN HIEROGLYPH-1420F;Lo;0;L;;;;;N;;;;;
+14210;EGYPTIAN HIEROGLYPH-14210;Lo;0;L;;;;;N;;;;;
+14211;EGYPTIAN HIEROGLYPH-14211;Lo;0;L;;;;;N;;;;;
+14212;EGYPTIAN HIEROGLYPH-14212;Lo;0;L;;;;;N;;;;;
+14213;EGYPTIAN HIEROGLYPH-14213;Lo;0;L;;;;;N;;;;;
+14214;EGYPTIAN HIEROGLYPH-14214;Lo;0;L;;;;;N;;;;;
+14215;EGYPTIAN HIEROGLYPH-14215;Lo;0;L;;;;;N;;;;;
+14216;EGYPTIAN HIEROGLYPH-14216;Lo;0;L;;;;;N;;;;;
+14217;EGYPTIAN HIEROGLYPH-14217;Lo;0;L;;;;;N;;;;;
+14218;EGYPTIAN HIEROGLYPH-14218;Lo;0;L;;;;;N;;;;;
+14219;EGYPTIAN HIEROGLYPH-14219;Lo;0;L;;;;;N;;;;;
+1421A;EGYPTIAN HIEROGLYPH-1421A;Lo;0;L;;;;;N;;;;;
+1421B;EGYPTIAN HIEROGLYPH-1421B;Lo;0;L;;;;;N;;;;;
+1421C;EGYPTIAN HIEROGLYPH-1421C;Lo;0;L;;;;;N;;;;;
+1421D;EGYPTIAN HIEROGLYPH-1421D;Lo;0;L;;;;;N;;;;;
+1421E;EGYPTIAN HIEROGLYPH-1421E;Lo;0;L;;;;;N;;;;;
+1421F;EGYPTIAN HIEROGLYPH-1421F;Lo;0;L;;;;;N;;;;;
+14220;EGYPTIAN HIEROGLYPH-14220;Lo;0;L;;;;;N;;;;;
+14221;EGYPTIAN HIEROGLYPH-14221;Lo;0;L;;;;;N;;;;;
+14222;EGYPTIAN HIEROGLYPH-14222;Lo;0;L;;;;;N;;;;;
+14223;EGYPTIAN HIEROGLYPH-14223;Lo;0;L;;;;;N;;;;;
+14224;EGYPTIAN HIEROGLYPH-14224;Lo;0;L;;;;;N;;;;;
+14225;EGYPTIAN HIEROGLYPH-14225;Lo;0;L;;;;;N;;;;;
+14226;EGYPTIAN HIEROGLYPH-14226;Lo;0;L;;;;;N;;;;;
+14227;EGYPTIAN HIEROGLYPH-14227;Lo;0;L;;;;;N;;;;;
+14228;EGYPTIAN HIEROGLYPH-14228;Lo;0;L;;;;;N;;;;;
+14229;EGYPTIAN HIEROGLYPH-14229;Lo;0;L;;;;;N;;;;;
+1422A;EGYPTIAN HIEROGLYPH-1422A;Lo;0;L;;;;;N;;;;;
+1422B;EGYPTIAN HIEROGLYPH-1422B;Lo;0;L;;;;;N;;;;;
+1422C;EGYPTIAN HIEROGLYPH-1422C;Lo;0;L;;;;;N;;;;;
+1422D;EGYPTIAN HIEROGLYPH-1422D;Lo;0;L;;;;;N;;;;;
+1422E;EGYPTIAN HIEROGLYPH-1422E;Lo;0;L;;;;;N;;;;;
+1422F;EGYPTIAN HIEROGLYPH-1422F;Lo;0;L;;;;;N;;;;;
+14230;EGYPTIAN HIEROGLYPH-14230;Lo;0;L;;;;;N;;;;;
+14231;EGYPTIAN HIEROGLYPH-14231;Lo;0;L;;;;;N;;;;;
+14232;EGYPTIAN HIEROGLYPH-14232;Lo;0;L;;;;;N;;;;;
+14233;EGYPTIAN HIEROGLYPH-14233;Lo;0;L;;;;;N;;;;;
+14234;EGYPTIAN HIEROGLYPH-14234;Lo;0;L;;;;;N;;;;;
+14235;EGYPTIAN HIEROGLYPH-14235;Lo;0;L;;;;;N;;;;;
+14236;EGYPTIAN HIEROGLYPH-14236;Lo;0;L;;;;;N;;;;;
+14237;EGYPTIAN HIEROGLYPH-14237;Lo;0;L;;;;;N;;;;;
+14238;EGYPTIAN HIEROGLYPH-14238;Lo;0;L;;;;;N;;;;;
+14239;EGYPTIAN HIEROGLYPH-14239;Lo;0;L;;;;;N;;;;;
+1423A;EGYPTIAN HIEROGLYPH-1423A;Lo;0;L;;;;;N;;;;;
+1423B;EGYPTIAN HIEROGLYPH-1423B;Lo;0;L;;;;;N;;;;;
+1423C;EGYPTIAN HIEROGLYPH-1423C;Lo;0;L;;;;;N;;;;;
+1423D;EGYPTIAN HIEROGLYPH-1423D;Lo;0;L;;;;;N;;;;;
+1423E;EGYPTIAN HIEROGLYPH-1423E;Lo;0;L;;;;;N;;;;;
+1423F;EGYPTIAN HIEROGLYPH-1423F;Lo;0;L;;;;;N;;;;;
+14240;EGYPTIAN HIEROGLYPH-14240;Lo;0;L;;;;;N;;;;;
+14241;EGYPTIAN HIEROGLYPH-14241;Lo;0;L;;;;;N;;;;;
+14242;EGYPTIAN HIEROGLYPH-14242;Lo;0;L;;;;;N;;;;;
+14243;EGYPTIAN HIEROGLYPH-14243;Lo;0;L;;;;;N;;;;;
+14244;EGYPTIAN HIEROGLYPH-14244;Lo;0;L;;;;;N;;;;;
+14245;EGYPTIAN HIEROGLYPH-14245;Lo;0;L;;;;;N;;;;;
+14246;EGYPTIAN HIEROGLYPH-14246;Lo;0;L;;;;;N;;;;;
+14247;EGYPTIAN HIEROGLYPH-14247;Lo;0;L;;;;;N;;;;;
+14248;EGYPTIAN HIEROGLYPH-14248;Lo;0;L;;;;;N;;;;;
+14249;EGYPTIAN HIEROGLYPH-14249;Lo;0;L;;;;;N;;;;;
+1424A;EGYPTIAN HIEROGLYPH-1424A;Lo;0;L;;;;;N;;;;;
+1424B;EGYPTIAN HIEROGLYPH-1424B;Lo;0;L;;;;;N;;;;;
+1424C;EGYPTIAN HIEROGLYPH-1424C;Lo;0;L;;;;;N;;;;;
+1424D;EGYPTIAN HIEROGLYPH-1424D;Lo;0;L;;;;;N;;;;;
+1424E;EGYPTIAN HIEROGLYPH-1424E;Lo;0;L;;;;;N;;;;;
+1424F;EGYPTIAN HIEROGLYPH-1424F;Lo;0;L;;;;;N;;;;;
+14250;EGYPTIAN HIEROGLYPH-14250;Lo;0;L;;;;;N;;;;;
+14251;EGYPTIAN HIEROGLYPH-14251;Lo;0;L;;;;;N;;;;;
+14252;EGYPTIAN HIEROGLYPH-14252;Lo;0;L;;;;;N;;;;;
+14253;EGYPTIAN HIEROGLYPH-14253;Lo;0;L;;;;;N;;;;;
+14254;EGYPTIAN HIEROGLYPH-14254;Lo;0;L;;;;;N;;;;;
+14255;EGYPTIAN HIEROGLYPH-14255;Lo;0;L;;;;;N;;;;;
+14256;EGYPTIAN HIEROGLYPH-14256;Lo;0;L;;;;;N;;;;;
+14257;EGYPTIAN HIEROGLYPH-14257;Lo;0;L;;;;;N;;;;;
+14258;EGYPTIAN HIEROGLYPH-14258;Lo;0;L;;;;;N;;;;;
+14259;EGYPTIAN HIEROGLYPH-14259;Lo;0;L;;;;;N;;;;;
+1425A;EGYPTIAN HIEROGLYPH-1425A;Lo;0;L;;;;;N;;;;;
+1425B;EGYPTIAN HIEROGLYPH-1425B;Lo;0;L;;;;;N;;;;;
+1425C;EGYPTIAN HIEROGLYPH-1425C;Lo;0;L;;;;;N;;;;;
+1425D;EGYPTIAN HIEROGLYPH-1425D;Lo;0;L;;;;;N;;;;;
+1425E;EGYPTIAN HIEROGLYPH-1425E;Lo;0;L;;;;;N;;;;;
+1425F;EGYPTIAN HIEROGLYPH-1425F;Lo;0;L;;;;;N;;;;;
+14260;EGYPTIAN HIEROGLYPH-14260;Lo;0;L;;;;;N;;;;;
+14261;EGYPTIAN HIEROGLYPH-14261;Lo;0;L;;;;;N;;;;;
+14262;EGYPTIAN HIEROGLYPH-14262;Lo;0;L;;;;;N;;;;;
+14263;EGYPTIAN HIEROGLYPH-14263;Lo;0;L;;;;;N;;;;;
+14264;EGYPTIAN HIEROGLYPH-14264;Lo;0;L;;;;;N;;;;;
+14265;EGYPTIAN HIEROGLYPH-14265;Lo;0;L;;;;;N;;;;;
+14266;EGYPTIAN HIEROGLYPH-14266;Lo;0;L;;;;;N;;;;;
+14267;EGYPTIAN HIEROGLYPH-14267;Lo;0;L;;;;;N;;;;;
+14268;EGYPTIAN HIEROGLYPH-14268;Lo;0;L;;;;;N;;;;;
+14269;EGYPTIAN HIEROGLYPH-14269;Lo;0;L;;;;;N;;;;;
+1426A;EGYPTIAN HIEROGLYPH-1426A;Lo;0;L;;;;;N;;;;;
+1426B;EGYPTIAN HIEROGLYPH-1426B;Lo;0;L;;;;;N;;;;;
+1426C;EGYPTIAN HIEROGLYPH-1426C;Lo;0;L;;;;;N;;;;;
+1426D;EGYPTIAN HIEROGLYPH-1426D;Lo;0;L;;;;;N;;;;;
+1426E;EGYPTIAN HIEROGLYPH-1426E;Lo;0;L;;;;;N;;;;;
+1426F;EGYPTIAN HIEROGLYPH-1426F;Lo;0;L;;;;;N;;;;;
+14270;EGYPTIAN HIEROGLYPH-14270;Lo;0;L;;;;;N;;;;;
+14271;EGYPTIAN HIEROGLYPH-14271;Lo;0;L;;;;;N;;;;;
+14272;EGYPTIAN HIEROGLYPH-14272;Lo;0;L;;;;;N;;;;;
+14273;EGYPTIAN HIEROGLYPH-14273;Lo;0;L;;;;;N;;;;;
+14274;EGYPTIAN HIEROGLYPH-14274;Lo;0;L;;;;;N;;;;;
+14275;EGYPTIAN HIEROGLYPH-14275;Lo;0;L;;;;;N;;;;;
+14276;EGYPTIAN HIEROGLYPH-14276;Lo;0;L;;;;;N;;;;;
+14277;EGYPTIAN HIEROGLYPH-14277;Lo;0;L;;;;;N;;;;;
+14278;EGYPTIAN HIEROGLYPH-14278;Lo;0;L;;;;;N;;;;;
+14279;EGYPTIAN HIEROGLYPH-14279;Lo;0;L;;;;;N;;;;;
+1427A;EGYPTIAN HIEROGLYPH-1427A;Lo;0;L;;;;;N;;;;;
+1427B;EGYPTIAN HIEROGLYPH-1427B;Lo;0;L;;;;;N;;;;;
+1427C;EGYPTIAN HIEROGLYPH-1427C;Lo;0;L;;;;;N;;;;;
+1427D;EGYPTIAN HIEROGLYPH-1427D;Lo;0;L;;;;;N;;;;;
+1427E;EGYPTIAN HIEROGLYPH-1427E;Lo;0;L;;;;;N;;;;;
+1427F;EGYPTIAN HIEROGLYPH-1427F;Lo;0;L;;;;;N;;;;;
+14280;EGYPTIAN HIEROGLYPH-14280;Lo;0;L;;;;;N;;;;;
+14281;EGYPTIAN HIEROGLYPH-14281;Lo;0;L;;;;;N;;;;;
+14282;EGYPTIAN HIEROGLYPH-14282;Lo;0;L;;;;;N;;;;;
+14283;EGYPTIAN HIEROGLYPH-14283;Lo;0;L;;;;;N;;;;;
+14284;EGYPTIAN HIEROGLYPH-14284;Lo;0;L;;;;;N;;;;;
+14285;EGYPTIAN HIEROGLYPH-14285;Lo;0;L;;;;;N;;;;;
+14286;EGYPTIAN HIEROGLYPH-14286;Lo;0;L;;;;;N;;;;;
+14287;EGYPTIAN HIEROGLYPH-14287;Lo;0;L;;;;;N;;;;;
+14288;EGYPTIAN HIEROGLYPH-14288;Lo;0;L;;;;;N;;;;;
+14289;EGYPTIAN HIEROGLYPH-14289;Lo;0;L;;;;;N;;;;;
+1428A;EGYPTIAN HIEROGLYPH-1428A;Lo;0;L;;;;;N;;;;;
+1428B;EGYPTIAN HIEROGLYPH-1428B;Lo;0;L;;;;;N;;;;;
+1428C;EGYPTIAN HIEROGLYPH-1428C;Lo;0;L;;;;;N;;;;;
+1428D;EGYPTIAN HIEROGLYPH-1428D;Lo;0;L;;;;;N;;;;;
+1428E;EGYPTIAN HIEROGLYPH-1428E;Lo;0;L;;;;;N;;;;;
+1428F;EGYPTIAN HIEROGLYPH-1428F;Lo;0;L;;;;;N;;;;;
+14290;EGYPTIAN HIEROGLYPH-14290;Lo;0;L;;;;;N;;;;;
+14291;EGYPTIAN HIEROGLYPH-14291;Lo;0;L;;;;;N;;;;;
+14292;EGYPTIAN HIEROGLYPH-14292;Lo;0;L;;;;;N;;;;;
+14293;EGYPTIAN HIEROGLYPH-14293;Lo;0;L;;;;;N;;;;;
+14294;EGYPTIAN HIEROGLYPH-14294;Lo;0;L;;;;;N;;;;;
+14295;EGYPTIAN HIEROGLYPH-14295;Lo;0;L;;;;;N;;;;;
+14296;EGYPTIAN HIEROGLYPH-14296;Lo;0;L;;;;;N;;;;;
+14297;EGYPTIAN HIEROGLYPH-14297;Lo;0;L;;;;;N;;;;;
+14298;EGYPTIAN HIEROGLYPH-14298;Lo;0;L;;;;;N;;;;;
+14299;EGYPTIAN HIEROGLYPH-14299;Lo;0;L;;;;;N;;;;;
+1429A;EGYPTIAN HIEROGLYPH-1429A;Lo;0;L;;;;;N;;;;;
+1429B;EGYPTIAN HIEROGLYPH-1429B;Lo;0;L;;;;;N;;;;;
+1429C;EGYPTIAN HIEROGLYPH-1429C;Lo;0;L;;;;;N;;;;;
+1429D;EGYPTIAN HIEROGLYPH-1429D;Lo;0;L;;;;;N;;;;;
+1429E;EGYPTIAN HIEROGLYPH-1429E;Lo;0;L;;;;;N;;;;;
+1429F;EGYPTIAN HIEROGLYPH-1429F;Lo;0;L;;;;;N;;;;;
+142A0;EGYPTIAN HIEROGLYPH-142A0;Lo;0;L;;;;;N;;;;;
+142A1;EGYPTIAN HIEROGLYPH-142A1;Lo;0;L;;;;;N;;;;;
+142A2;EGYPTIAN HIEROGLYPH-142A2;Lo;0;L;;;;;N;;;;;
+142A3;EGYPTIAN HIEROGLYPH-142A3;Lo;0;L;;;;;N;;;;;
+142A4;EGYPTIAN HIEROGLYPH-142A4;Lo;0;L;;;;;N;;;;;
+142A5;EGYPTIAN HIEROGLYPH-142A5;Lo;0;L;;;;;N;;;;;
+142A6;EGYPTIAN HIEROGLYPH-142A6;Lo;0;L;;;;;N;;;;;
+142A7;EGYPTIAN HIEROGLYPH-142A7;Lo;0;L;;;;;N;;;;;
+142A8;EGYPTIAN HIEROGLYPH-142A8;Lo;0;L;;;;;N;;;;;
+142A9;EGYPTIAN HIEROGLYPH-142A9;Lo;0;L;;;;;N;;;;;
+142AA;EGYPTIAN HIEROGLYPH-142AA;Lo;0;L;;;;;N;;;;;
+142AB;EGYPTIAN HIEROGLYPH-142AB;Lo;0;L;;;;;N;;;;;
+142AC;EGYPTIAN HIEROGLYPH-142AC;Lo;0;L;;;;;N;;;;;
+142AD;EGYPTIAN HIEROGLYPH-142AD;Lo;0;L;;;;;N;;;;;
+142AE;EGYPTIAN HIEROGLYPH-142AE;Lo;0;L;;;;;N;;;;;
+142AF;EGYPTIAN HIEROGLYPH-142AF;Lo;0;L;;;;;N;;;;;
+142B0;EGYPTIAN HIEROGLYPH-142B0;Lo;0;L;;;;;N;;;;;
+142B1;EGYPTIAN HIEROGLYPH-142B1;Lo;0;L;;;;;N;;;;;
+142B2;EGYPTIAN HIEROGLYPH-142B2;Lo;0;L;;;;;N;;;;;
+142B3;EGYPTIAN HIEROGLYPH-142B3;Lo;0;L;;;;;N;;;;;
+142B4;EGYPTIAN HIEROGLYPH-142B4;Lo;0;L;;;;;N;;;;;
+142B5;EGYPTIAN HIEROGLYPH-142B5;Lo;0;L;;;;;N;;;;;
+142B6;EGYPTIAN HIEROGLYPH-142B6;Lo;0;L;;;;;N;;;;;
+142B7;EGYPTIAN HIEROGLYPH-142B7;Lo;0;L;;;;;N;;;;;
+142B8;EGYPTIAN HIEROGLYPH-142B8;Lo;0;L;;;;;N;;;;;
+142B9;EGYPTIAN HIEROGLYPH-142B9;Lo;0;L;;;;;N;;;;;
+142BA;EGYPTIAN HIEROGLYPH-142BA;Lo;0;L;;;;;N;;;;;
+142BB;EGYPTIAN HIEROGLYPH-142BB;Lo;0;L;;;;;N;;;;;
+142BC;EGYPTIAN HIEROGLYPH-142BC;Lo;0;L;;;;;N;;;;;
+142BD;EGYPTIAN HIEROGLYPH-142BD;Lo;0;L;;;;;N;;;;;
+142BE;EGYPTIAN HIEROGLYPH-142BE;Lo;0;L;;;;;N;;;;;
+142BF;EGYPTIAN HIEROGLYPH-142BF;Lo;0;L;;;;;N;;;;;
+142C0;EGYPTIAN HIEROGLYPH-142C0;Lo;0;L;;;;;N;;;;;
+142C1;EGYPTIAN HIEROGLYPH-142C1;Lo;0;L;;;;;N;;;;;
+142C2;EGYPTIAN HIEROGLYPH-142C2;Lo;0;L;;;;;N;;;;;
+142C3;EGYPTIAN HIEROGLYPH-142C3;Lo;0;L;;;;;N;;;;;
+142C4;EGYPTIAN HIEROGLYPH-142C4;Lo;0;L;;;;;N;;;;;
+142C5;EGYPTIAN HIEROGLYPH-142C5;Lo;0;L;;;;;N;;;;;
+142C6;EGYPTIAN HIEROGLYPH-142C6;Lo;0;L;;;;;N;;;;;
+142C7;EGYPTIAN HIEROGLYPH-142C7;Lo;0;L;;;;;N;;;;;
+142C8;EGYPTIAN HIEROGLYPH-142C8;Lo;0;L;;;;;N;;;;;
+142C9;EGYPTIAN HIEROGLYPH-142C9;Lo;0;L;;;;;N;;;;;
+142CA;EGYPTIAN HIEROGLYPH-142CA;Lo;0;L;;;;;N;;;;;
+142CB;EGYPTIAN HIEROGLYPH-142CB;Lo;0;L;;;;;N;;;;;
+142CC;EGYPTIAN HIEROGLYPH-142CC;Lo;0;L;;;;;N;;;;;
+142CD;EGYPTIAN HIEROGLYPH-142CD;Lo;0;L;;;;;N;;;;;
+142CE;EGYPTIAN HIEROGLYPH-142CE;Lo;0;L;;;;;N;;;;;
+142CF;EGYPTIAN HIEROGLYPH-142CF;Lo;0;L;;;;;N;;;;;
+142D0;EGYPTIAN HIEROGLYPH-142D0;Lo;0;L;;;;;N;;;;;
+142D1;EGYPTIAN HIEROGLYPH-142D1;Lo;0;L;;;;;N;;;;;
+142D2;EGYPTIAN HIEROGLYPH-142D2;Lo;0;L;;;;;N;;;;;
+142D3;EGYPTIAN HIEROGLYPH-142D3;Lo;0;L;;;;;N;;;;;
+142D4;EGYPTIAN HIEROGLYPH-142D4;Lo;0;L;;;;;N;;;;;
+142D5;EGYPTIAN HIEROGLYPH-142D5;Lo;0;L;;;;;N;;;;;
+142D6;EGYPTIAN HIEROGLYPH-142D6;Lo;0;L;;;;;N;;;;;
+142D7;EGYPTIAN HIEROGLYPH-142D7;Lo;0;L;;;;;N;;;;;
+142D8;EGYPTIAN HIEROGLYPH-142D8;Lo;0;L;;;;;N;;;;;
+142D9;EGYPTIAN HIEROGLYPH-142D9;Lo;0;L;;;;;N;;;;;
+142DA;EGYPTIAN HIEROGLYPH-142DA;Lo;0;L;;;;;N;;;;;
+142DB;EGYPTIAN HIEROGLYPH-142DB;Lo;0;L;;;;;N;;;;;
+142DC;EGYPTIAN HIEROGLYPH-142DC;Lo;0;L;;;;;N;;;;;
+142DD;EGYPTIAN HIEROGLYPH-142DD;Lo;0;L;;;;;N;;;;;
+142DE;EGYPTIAN HIEROGLYPH-142DE;Lo;0;L;;;;;N;;;;;
+142DF;EGYPTIAN HIEROGLYPH-142DF;Lo;0;L;;;;;N;;;;;
+142E0;EGYPTIAN HIEROGLYPH-142E0;Lo;0;L;;;;;N;;;;;
+142E1;EGYPTIAN HIEROGLYPH-142E1;Lo;0;L;;;;;N;;;;;
+142E2;EGYPTIAN HIEROGLYPH-142E2;Lo;0;L;;;;;N;;;;;
+142E3;EGYPTIAN HIEROGLYPH-142E3;Lo;0;L;;;;;N;;;;;
+142E4;EGYPTIAN HIEROGLYPH-142E4;Lo;0;L;;;;;N;;;;;
+142E5;EGYPTIAN HIEROGLYPH-142E5;Lo;0;L;;;;;N;;;;;
+142E6;EGYPTIAN HIEROGLYPH-142E6;Lo;0;L;;;;;N;;;;;
+142E7;EGYPTIAN HIEROGLYPH-142E7;Lo;0;L;;;;;N;;;;;
+142E8;EGYPTIAN HIEROGLYPH-142E8;Lo;0;L;;;;;N;;;;;
+142E9;EGYPTIAN HIEROGLYPH-142E9;Lo;0;L;;;;;N;;;;;
+142EA;EGYPTIAN HIEROGLYPH-142EA;Lo;0;L;;;;;N;;;;;
+142EB;EGYPTIAN HIEROGLYPH-142EB;Lo;0;L;;;;;N;;;;;
+142EC;EGYPTIAN HIEROGLYPH-142EC;Lo;0;L;;;;;N;;;;;
+142ED;EGYPTIAN HIEROGLYPH-142ED;Lo;0;L;;;;;N;;;;;
+142EE;EGYPTIAN HIEROGLYPH-142EE;Lo;0;L;;;;;N;;;;;
+142EF;EGYPTIAN HIEROGLYPH-142EF;Lo;0;L;;;;;N;;;;;
+142F0;EGYPTIAN HIEROGLYPH-142F0;Lo;0;L;;;;;N;;;;;
+142F1;EGYPTIAN HIEROGLYPH-142F1;Lo;0;L;;;;;N;;;;;
+142F2;EGYPTIAN HIEROGLYPH-142F2;Lo;0;L;;;;;N;;;;;
+142F3;EGYPTIAN HIEROGLYPH-142F3;Lo;0;L;;;;;N;;;;;
+142F4;EGYPTIAN HIEROGLYPH-142F4;Lo;0;L;;;;;N;;;;;
+142F5;EGYPTIAN HIEROGLYPH-142F5;Lo;0;L;;;;;N;;;;;
+142F6;EGYPTIAN HIEROGLYPH-142F6;Lo;0;L;;;;;N;;;;;
+142F7;EGYPTIAN HIEROGLYPH-142F7;Lo;0;L;;;;;N;;;;;
+142F8;EGYPTIAN HIEROGLYPH-142F8;Lo;0;L;;;;;N;;;;;
+142F9;EGYPTIAN HIEROGLYPH-142F9;Lo;0;L;;;;;N;;;;;
+142FA;EGYPTIAN HIEROGLYPH-142FA;Lo;0;L;;;;;N;;;;;
+142FB;EGYPTIAN HIEROGLYPH-142FB;Lo;0;L;;;;;N;;;;;
+142FC;EGYPTIAN HIEROGLYPH-142FC;Lo;0;L;;;;;N;;;;;
+142FD;EGYPTIAN HIEROGLYPH-142FD;Lo;0;L;;;;;N;;;;;
+142FE;EGYPTIAN HIEROGLYPH-142FE;Lo;0;L;;;;;N;;;;;
+142FF;EGYPTIAN HIEROGLYPH-142FF;Lo;0;L;;;;;N;;;;;
+14300;EGYPTIAN HIEROGLYPH-14300;Lo;0;L;;;;;N;;;;;
+14301;EGYPTIAN HIEROGLYPH-14301;Lo;0;L;;;;;N;;;;;
+14302;EGYPTIAN HIEROGLYPH-14302;Lo;0;L;;;;;N;;;;;
+14303;EGYPTIAN HIEROGLYPH-14303;Lo;0;L;;;;;N;;;;;
+14304;EGYPTIAN HIEROGLYPH-14304;Lo;0;L;;;;;N;;;;;
+14305;EGYPTIAN HIEROGLYPH-14305;Lo;0;L;;;;;N;;;;;
+14306;EGYPTIAN HIEROGLYPH-14306;Lo;0;L;;;;;N;;;;;
+14307;EGYPTIAN HIEROGLYPH-14307;Lo;0;L;;;;;N;;;;;
+14308;EGYPTIAN HIEROGLYPH-14308;Lo;0;L;;;;;N;;;;;
+14309;EGYPTIAN HIEROGLYPH-14309;Lo;0;L;;;;;N;;;;;
+1430A;EGYPTIAN HIEROGLYPH-1430A;Lo;0;L;;;;;N;;;;;
+1430B;EGYPTIAN HIEROGLYPH-1430B;Lo;0;L;;;;;N;;;;;
+1430C;EGYPTIAN HIEROGLYPH-1430C;Lo;0;L;;;;;N;;;;;
+1430D;EGYPTIAN HIEROGLYPH-1430D;Lo;0;L;;;;;N;;;;;
+1430E;EGYPTIAN HIEROGLYPH-1430E;Lo;0;L;;;;;N;;;;;
+1430F;EGYPTIAN HIEROGLYPH-1430F;Lo;0;L;;;;;N;;;;;
+14310;EGYPTIAN HIEROGLYPH-14310;Lo;0;L;;;;;N;;;;;
+14311;EGYPTIAN HIEROGLYPH-14311;Lo;0;L;;;;;N;;;;;
+14312;EGYPTIAN HIEROGLYPH-14312;Lo;0;L;;;;;N;;;;;
+14313;EGYPTIAN HIEROGLYPH-14313;Lo;0;L;;;;;N;;;;;
+14314;EGYPTIAN HIEROGLYPH-14314;Lo;0;L;;;;;N;;;;;
+14315;EGYPTIAN HIEROGLYPH-14315;Lo;0;L;;;;;N;;;;;
+14316;EGYPTIAN HIEROGLYPH-14316;Lo;0;L;;;;;N;;;;;
+14317;EGYPTIAN HIEROGLYPH-14317;Lo;0;L;;;;;N;;;;;
+14318;EGYPTIAN HIEROGLYPH-14318;Lo;0;L;;;;;N;;;;;
+14319;EGYPTIAN HIEROGLYPH-14319;Lo;0;L;;;;;N;;;;;
+1431A;EGYPTIAN HIEROGLYPH-1431A;Lo;0;L;;;;;N;;;;;
+1431B;EGYPTIAN HIEROGLYPH-1431B;Lo;0;L;;;;;N;;;;;
+1431C;EGYPTIAN HIEROGLYPH-1431C;Lo;0;L;;;;;N;;;;;
+1431D;EGYPTIAN HIEROGLYPH-1431D;Lo;0;L;;;;;N;;;;;
+1431E;EGYPTIAN HIEROGLYPH-1431E;Lo;0;L;;;;;N;;;;;
+1431F;EGYPTIAN HIEROGLYPH-1431F;Lo;0;L;;;;;N;;;;;
+14320;EGYPTIAN HIEROGLYPH-14320;Lo;0;L;;;;;N;;;;;
+14321;EGYPTIAN HIEROGLYPH-14321;Lo;0;L;;;;;N;;;;;
+14322;EGYPTIAN HIEROGLYPH-14322;Lo;0;L;;;;;N;;;;;
+14323;EGYPTIAN HIEROGLYPH-14323;Lo;0;L;;;;;N;;;;;
+14324;EGYPTIAN HIEROGLYPH-14324;Lo;0;L;;;;;N;;;;;
+14325;EGYPTIAN HIEROGLYPH-14325;Lo;0;L;;;;;N;;;;;
+14326;EGYPTIAN HIEROGLYPH-14326;Lo;0;L;;;;;N;;;;;
+14327;EGYPTIAN HIEROGLYPH-14327;Lo;0;L;;;;;N;;;;;
+14328;EGYPTIAN HIEROGLYPH-14328;Lo;0;L;;;;;N;;;;;
+14329;EGYPTIAN HIEROGLYPH-14329;Lo;0;L;;;;;N;;;;;
+1432A;EGYPTIAN HIEROGLYPH-1432A;Lo;0;L;;;;;N;;;;;
+1432B;EGYPTIAN HIEROGLYPH-1432B;Lo;0;L;;;;;N;;;;;
+1432C;EGYPTIAN HIEROGLYPH-1432C;Lo;0;L;;;;;N;;;;;
+1432D;EGYPTIAN HIEROGLYPH-1432D;Lo;0;L;;;;;N;;;;;
+1432E;EGYPTIAN HIEROGLYPH-1432E;Lo;0;L;;;;;N;;;;;
+1432F;EGYPTIAN HIEROGLYPH-1432F;Lo;0;L;;;;;N;;;;;
+14330;EGYPTIAN HIEROGLYPH-14330;Lo;0;L;;;;;N;;;;;
+14331;EGYPTIAN HIEROGLYPH-14331;Lo;0;L;;;;;N;;;;;
+14332;EGYPTIAN HIEROGLYPH-14332;Lo;0;L;;;;;N;;;;;
+14333;EGYPTIAN HIEROGLYPH-14333;Lo;0;L;;;;;N;;;;;
+14334;EGYPTIAN HIEROGLYPH-14334;Lo;0;L;;;;;N;;;;;
+14335;EGYPTIAN HIEROGLYPH-14335;Lo;0;L;;;;;N;;;;;
+14336;EGYPTIAN HIEROGLYPH-14336;Lo;0;L;;;;;N;;;;;
+14337;EGYPTIAN HIEROGLYPH-14337;Lo;0;L;;;;;N;;;;;
+14338;EGYPTIAN HIEROGLYPH-14338;Lo;0;L;;;;;N;;;;;
+14339;EGYPTIAN HIEROGLYPH-14339;Lo;0;L;;;;;N;;;;;
+1433A;EGYPTIAN HIEROGLYPH-1433A;Lo;0;L;;;;;N;;;;;
+1433B;EGYPTIAN HIEROGLYPH-1433B;Lo;0;L;;;;;N;;;;;
+1433C;EGYPTIAN HIEROGLYPH-1433C;Lo;0;L;;;;;N;;;;;
+1433D;EGYPTIAN HIEROGLYPH-1433D;Lo;0;L;;;;;N;;;;;
+1433E;EGYPTIAN HIEROGLYPH-1433E;Lo;0;L;;;;;N;;;;;
+1433F;EGYPTIAN HIEROGLYPH-1433F;Lo;0;L;;;;;N;;;;;
+14340;EGYPTIAN HIEROGLYPH-14340;Lo;0;L;;;;;N;;;;;
+14341;EGYPTIAN HIEROGLYPH-14341;Lo;0;L;;;;;N;;;;;
+14342;EGYPTIAN HIEROGLYPH-14342;Lo;0;L;;;;;N;;;;;
+14343;EGYPTIAN HIEROGLYPH-14343;Lo;0;L;;;;;N;;;;;
+14344;EGYPTIAN HIEROGLYPH-14344;Lo;0;L;;;;;N;;;;;
+14345;EGYPTIAN HIEROGLYPH-14345;Lo;0;L;;;;;N;;;;;
+14346;EGYPTIAN HIEROGLYPH-14346;Lo;0;L;;;;;N;;;;;
+14347;EGYPTIAN HIEROGLYPH-14347;Lo;0;L;;;;;N;;;;;
+14348;EGYPTIAN HIEROGLYPH-14348;Lo;0;L;;;;;N;;;;;
+14349;EGYPTIAN HIEROGLYPH-14349;Lo;0;L;;;;;N;;;;;
+1434A;EGYPTIAN HIEROGLYPH-1434A;Lo;0;L;;;;;N;;;;;
+1434B;EGYPTIAN HIEROGLYPH-1434B;Lo;0;L;;;;;N;;;;;
+1434C;EGYPTIAN HIEROGLYPH-1434C;Lo;0;L;;;;;N;;;;;
+1434D;EGYPTIAN HIEROGLYPH-1434D;Lo;0;L;;;;;N;;;;;
+1434E;EGYPTIAN HIEROGLYPH-1434E;Lo;0;L;;;;;N;;;;;
+1434F;EGYPTIAN HIEROGLYPH-1434F;Lo;0;L;;;;;N;;;;;
+14350;EGYPTIAN HIEROGLYPH-14350;Lo;0;L;;;;;N;;;;;
+14351;EGYPTIAN HIEROGLYPH-14351;Lo;0;L;;;;;N;;;;;
+14352;EGYPTIAN HIEROGLYPH-14352;Lo;0;L;;;;;N;;;;;
+14353;EGYPTIAN HIEROGLYPH-14353;Lo;0;L;;;;;N;;;;;
+14354;EGYPTIAN HIEROGLYPH-14354;Lo;0;L;;;;;N;;;;;
+14355;EGYPTIAN HIEROGLYPH-14355;Lo;0;L;;;;;N;;;;;
+14356;EGYPTIAN HIEROGLYPH-14356;Lo;0;L;;;;;N;;;;;
+14357;EGYPTIAN HIEROGLYPH-14357;Lo;0;L;;;;;N;;;;;
+14358;EGYPTIAN HIEROGLYPH-14358;Lo;0;L;;;;;N;;;;;
+14359;EGYPTIAN HIEROGLYPH-14359;Lo;0;L;;;;;N;;;;;
+1435A;EGYPTIAN HIEROGLYPH-1435A;Lo;0;L;;;;;N;;;;;
+1435B;EGYPTIAN HIEROGLYPH-1435B;Lo;0;L;;;;;N;;;;;
+1435C;EGYPTIAN HIEROGLYPH-1435C;Lo;0;L;;;;;N;;;;;
+1435D;EGYPTIAN HIEROGLYPH-1435D;Lo;0;L;;;;;N;;;;;
+1435E;EGYPTIAN HIEROGLYPH-1435E;Lo;0;L;;;;;N;;;;;
+1435F;EGYPTIAN HIEROGLYPH-1435F;Lo;0;L;;;;;N;;;;;
+14360;EGYPTIAN HIEROGLYPH-14360;Lo;0;L;;;;;N;;;;;
+14361;EGYPTIAN HIEROGLYPH-14361;Lo;0;L;;;;;N;;;;;
+14362;EGYPTIAN HIEROGLYPH-14362;Lo;0;L;;;;;N;;;;;
+14363;EGYPTIAN HIEROGLYPH-14363;Lo;0;L;;;;;N;;;;;
+14364;EGYPTIAN HIEROGLYPH-14364;Lo;0;L;;;;;N;;;;;
+14365;EGYPTIAN HIEROGLYPH-14365;Lo;0;L;;;;;N;;;;;
+14366;EGYPTIAN HIEROGLYPH-14366;Lo;0;L;;;;;N;;;;;
+14367;EGYPTIAN HIEROGLYPH-14367;Lo;0;L;;;;;N;;;;;
+14368;EGYPTIAN HIEROGLYPH-14368;Lo;0;L;;;;;N;;;;;
+14369;EGYPTIAN HIEROGLYPH-14369;Lo;0;L;;;;;N;;;;;
+1436A;EGYPTIAN HIEROGLYPH-1436A;Lo;0;L;;;;;N;;;;;
+1436B;EGYPTIAN HIEROGLYPH-1436B;Lo;0;L;;;;;N;;;;;
+1436C;EGYPTIAN HIEROGLYPH-1436C;Lo;0;L;;;;;N;;;;;
+1436D;EGYPTIAN HIEROGLYPH-1436D;Lo;0;L;;;;;N;;;;;
+1436E;EGYPTIAN HIEROGLYPH-1436E;Lo;0;L;;;;;N;;;;;
+1436F;EGYPTIAN HIEROGLYPH-1436F;Lo;0;L;;;;;N;;;;;
+14370;EGYPTIAN HIEROGLYPH-14370;Lo;0;L;;;;;N;;;;;
+14371;EGYPTIAN HIEROGLYPH-14371;Lo;0;L;;;;;N;;;;;
+14372;EGYPTIAN HIEROGLYPH-14372;Lo;0;L;;;;;N;;;;;
+14373;EGYPTIAN HIEROGLYPH-14373;Lo;0;L;;;;;N;;;;;
+14374;EGYPTIAN HIEROGLYPH-14374;Lo;0;L;;;;;N;;;;;
+14375;EGYPTIAN HIEROGLYPH-14375;Lo;0;L;;;;;N;;;;;
+14376;EGYPTIAN HIEROGLYPH-14376;Lo;0;L;;;;;N;;;;;
+14377;EGYPTIAN HIEROGLYPH-14377;Lo;0;L;;;;;N;;;;;
+14378;EGYPTIAN HIEROGLYPH-14378;Lo;0;L;;;;;N;;;;;
+14379;EGYPTIAN HIEROGLYPH-14379;Lo;0;L;;;;;N;;;;;
+1437A;EGYPTIAN HIEROGLYPH-1437A;Lo;0;L;;;;;N;;;;;
+1437B;EGYPTIAN HIEROGLYPH-1437B;Lo;0;L;;;;;N;;;;;
+1437C;EGYPTIAN HIEROGLYPH-1437C;Lo;0;L;;;;;N;;;;;
+1437D;EGYPTIAN HIEROGLYPH-1437D;Lo;0;L;;;;;N;;;;;
+1437E;EGYPTIAN HIEROGLYPH-1437E;Lo;0;L;;;;;N;;;;;
+1437F;EGYPTIAN HIEROGLYPH-1437F;Lo;0;L;;;;;N;;;;;
+14380;EGYPTIAN HIEROGLYPH-14380;Lo;0;L;;;;;N;;;;;
+14381;EGYPTIAN HIEROGLYPH-14381;Lo;0;L;;;;;N;;;;;
+14382;EGYPTIAN HIEROGLYPH-14382;Lo;0;L;;;;;N;;;;;
+14383;EGYPTIAN HIEROGLYPH-14383;Lo;0;L;;;;;N;;;;;
+14384;EGYPTIAN HIEROGLYPH-14384;Lo;0;L;;;;;N;;;;;
+14385;EGYPTIAN HIEROGLYPH-14385;Lo;0;L;;;;;N;;;;;
+14386;EGYPTIAN HIEROGLYPH-14386;Lo;0;L;;;;;N;;;;;
+14387;EGYPTIAN HIEROGLYPH-14387;Lo;0;L;;;;;N;;;;;
+14388;EGYPTIAN HIEROGLYPH-14388;Lo;0;L;;;;;N;;;;;
+14389;EGYPTIAN HIEROGLYPH-14389;Lo;0;L;;;;;N;;;;;
+1438A;EGYPTIAN HIEROGLYPH-1438A;Lo;0;L;;;;;N;;;;;
+1438B;EGYPTIAN HIEROGLYPH-1438B;Lo;0;L;;;;;N;;;;;
+1438C;EGYPTIAN HIEROGLYPH-1438C;Lo;0;L;;;;;N;;;;;
+1438D;EGYPTIAN HIEROGLYPH-1438D;Lo;0;L;;;;;N;;;;;
+1438E;EGYPTIAN HIEROGLYPH-1438E;Lo;0;L;;;;;N;;;;;
+1438F;EGYPTIAN HIEROGLYPH-1438F;Lo;0;L;;;;;N;;;;;
+14390;EGYPTIAN HIEROGLYPH-14390;Lo;0;L;;;;;N;;;;;
+14391;EGYPTIAN HIEROGLYPH-14391;Lo;0;L;;;;;N;;;;;
+14392;EGYPTIAN HIEROGLYPH-14392;Lo;0;L;;;;;N;;;;;
+14393;EGYPTIAN HIEROGLYPH-14393;Lo;0;L;;;;;N;;;;;
+14394;EGYPTIAN HIEROGLYPH-14394;Lo;0;L;;;;;N;;;;;
+14395;EGYPTIAN HIEROGLYPH-14395;Lo;0;L;;;;;N;;;;;
+14396;EGYPTIAN HIEROGLYPH-14396;Lo;0;L;;;;;N;;;;;
+14397;EGYPTIAN HIEROGLYPH-14397;Lo;0;L;;;;;N;;;;;
+14398;EGYPTIAN HIEROGLYPH-14398;Lo;0;L;;;;;N;;;;;
+14399;EGYPTIAN HIEROGLYPH-14399;Lo;0;L;;;;;N;;;;;
+1439A;EGYPTIAN HIEROGLYPH-1439A;Lo;0;L;;;;;N;;;;;
+1439B;EGYPTIAN HIEROGLYPH-1439B;Lo;0;L;;;;;N;;;;;
+1439C;EGYPTIAN HIEROGLYPH-1439C;Lo;0;L;;;;;N;;;;;
+1439D;EGYPTIAN HIEROGLYPH-1439D;Lo;0;L;;;;;N;;;;;
+1439E;EGYPTIAN HIEROGLYPH-1439E;Lo;0;L;;;;;N;;;;;
+1439F;EGYPTIAN HIEROGLYPH-1439F;Lo;0;L;;;;;N;;;;;
+143A0;EGYPTIAN HIEROGLYPH-143A0;Lo;0;L;;;;;N;;;;;
+143A1;EGYPTIAN HIEROGLYPH-143A1;Lo;0;L;;;;;N;;;;;
+143A2;EGYPTIAN HIEROGLYPH-143A2;Lo;0;L;;;;;N;;;;;
+143A3;EGYPTIAN HIEROGLYPH-143A3;Lo;0;L;;;;;N;;;;;
+143A4;EGYPTIAN HIEROGLYPH-143A4;Lo;0;L;;;;;N;;;;;
+143A5;EGYPTIAN HIEROGLYPH-143A5;Lo;0;L;;;;;N;;;;;
+143A6;EGYPTIAN HIEROGLYPH-143A6;Lo;0;L;;;;;N;;;;;
+143A7;EGYPTIAN HIEROGLYPH-143A7;Lo;0;L;;;;;N;;;;;
+143A8;EGYPTIAN HIEROGLYPH-143A8;Lo;0;L;;;;;N;;;;;
+143A9;EGYPTIAN HIEROGLYPH-143A9;Lo;0;L;;;;;N;;;;;
+143AA;EGYPTIAN HIEROGLYPH-143AA;Lo;0;L;;;;;N;;;;;
+143AB;EGYPTIAN HIEROGLYPH-143AB;Lo;0;L;;;;;N;;;;;
+143AC;EGYPTIAN HIEROGLYPH-143AC;Lo;0;L;;;;;N;;;;;
+143AD;EGYPTIAN HIEROGLYPH-143AD;Lo;0;L;;;;;N;;;;;
+143AE;EGYPTIAN HIEROGLYPH-143AE;Lo;0;L;;;;;N;;;;;
+143AF;EGYPTIAN HIEROGLYPH-143AF;Lo;0;L;;;;;N;;;;;
+143B0;EGYPTIAN HIEROGLYPH-143B0;Lo;0;L;;;;;N;;;;;
+143B1;EGYPTIAN HIEROGLYPH-143B1;Lo;0;L;;;;;N;;;;;
+143B2;EGYPTIAN HIEROGLYPH-143B2;Lo;0;L;;;;;N;;;;;
+143B3;EGYPTIAN HIEROGLYPH-143B3;Lo;0;L;;;;;N;;;;;
+143B4;EGYPTIAN HIEROGLYPH-143B4;Lo;0;L;;;;;N;;;;;
+143B5;EGYPTIAN HIEROGLYPH-143B5;Lo;0;L;;;;;N;;;;;
+143B6;EGYPTIAN HIEROGLYPH-143B6;Lo;0;L;;;;;N;;;;;
+143B7;EGYPTIAN HIEROGLYPH-143B7;Lo;0;L;;;;;N;;;;;
+143B8;EGYPTIAN HIEROGLYPH-143B8;Lo;0;L;;;;;N;;;;;
+143B9;EGYPTIAN HIEROGLYPH-143B9;Lo;0;L;;;;;N;;;;;
+143BA;EGYPTIAN HIEROGLYPH-143BA;Lo;0;L;;;;;N;;;;;
+143BB;EGYPTIAN HIEROGLYPH-143BB;Lo;0;L;;;;;N;;;;;
+143BC;EGYPTIAN HIEROGLYPH-143BC;Lo;0;L;;;;;N;;;;;
+143BD;EGYPTIAN HIEROGLYPH-143BD;Lo;0;L;;;;;N;;;;;
+143BE;EGYPTIAN HIEROGLYPH-143BE;Lo;0;L;;;;;N;;;;;
+143BF;EGYPTIAN HIEROGLYPH-143BF;Lo;0;L;;;;;N;;;;;
+143C0;EGYPTIAN HIEROGLYPH-143C0;Lo;0;L;;;;;N;;;;;
+143C1;EGYPTIAN HIEROGLYPH-143C1;Lo;0;L;;;;;N;;;;;
+143C2;EGYPTIAN HIEROGLYPH-143C2;Lo;0;L;;;;;N;;;;;
+143C3;EGYPTIAN HIEROGLYPH-143C3;Lo;0;L;;;;;N;;;;;
+143C4;EGYPTIAN HIEROGLYPH-143C4;Lo;0;L;;;;;N;;;;;
+143C5;EGYPTIAN HIEROGLYPH-143C5;Lo;0;L;;;;;N;;;;;
+143C6;EGYPTIAN HIEROGLYPH-143C6;Lo;0;L;;;;;N;;;;;
+143C7;EGYPTIAN HIEROGLYPH-143C7;Lo;0;L;;;;;N;;;;;
+143C8;EGYPTIAN HIEROGLYPH-143C8;Lo;0;L;;;;;N;;;;;
+143C9;EGYPTIAN HIEROGLYPH-143C9;Lo;0;L;;;;;N;;;;;
+143CA;EGYPTIAN HIEROGLYPH-143CA;Lo;0;L;;;;;N;;;;;
+143CB;EGYPTIAN HIEROGLYPH-143CB;Lo;0;L;;;;;N;;;;;
+143CC;EGYPTIAN HIEROGLYPH-143CC;Lo;0;L;;;;;N;;;;;
+143CD;EGYPTIAN HIEROGLYPH-143CD;Lo;0;L;;;;;N;;;;;
+143CE;EGYPTIAN HIEROGLYPH-143CE;Lo;0;L;;;;;N;;;;;
+143CF;EGYPTIAN HIEROGLYPH-143CF;Lo;0;L;;;;;N;;;;;
+143D0;EGYPTIAN HIEROGLYPH-143D0;Lo;0;L;;;;;N;;;;;
+143D1;EGYPTIAN HIEROGLYPH-143D1;Lo;0;L;;;;;N;;;;;
+143D2;EGYPTIAN HIEROGLYPH-143D2;Lo;0;L;;;;;N;;;;;
+143D3;EGYPTIAN HIEROGLYPH-143D3;Lo;0;L;;;;;N;;;;;
+143D4;EGYPTIAN HIEROGLYPH-143D4;Lo;0;L;;;;;N;;;;;
+143D5;EGYPTIAN HIEROGLYPH-143D5;Lo;0;L;;;;;N;;;;;
+143D6;EGYPTIAN HIEROGLYPH-143D6;Lo;0;L;;;;;N;;;;;
+143D7;EGYPTIAN HIEROGLYPH-143D7;Lo;0;L;;;;;N;;;;;
+143D8;EGYPTIAN HIEROGLYPH-143D8;Lo;0;L;;;;;N;;;;;
+143D9;EGYPTIAN HIEROGLYPH-143D9;Lo;0;L;;;;;N;;;;;
+143DA;EGYPTIAN HIEROGLYPH-143DA;Lo;0;L;;;;;N;;;;;
+143DB;EGYPTIAN HIEROGLYPH-143DB;Lo;0;L;;;;;N;;;;;
+143DC;EGYPTIAN HIEROGLYPH-143DC;Lo;0;L;;;;;N;;;;;
+143DD;EGYPTIAN HIEROGLYPH-143DD;Lo;0;L;;;;;N;;;;;
+143DE;EGYPTIAN HIEROGLYPH-143DE;Lo;0;L;;;;;N;;;;;
+143DF;EGYPTIAN HIEROGLYPH-143DF;Lo;0;L;;;;;N;;;;;
+143E0;EGYPTIAN HIEROGLYPH-143E0;Lo;0;L;;;;;N;;;;;
+143E1;EGYPTIAN HIEROGLYPH-143E1;Lo;0;L;;;;;N;;;;;
+143E2;EGYPTIAN HIEROGLYPH-143E2;Lo;0;L;;;;;N;;;;;
+143E3;EGYPTIAN HIEROGLYPH-143E3;Lo;0;L;;;;;N;;;;;
+143E4;EGYPTIAN HIEROGLYPH-143E4;Lo;0;L;;;;;N;;;;;
+143E5;EGYPTIAN HIEROGLYPH-143E5;Lo;0;L;;;;;N;;;;;
+143E6;EGYPTIAN HIEROGLYPH-143E6;Lo;0;L;;;;;N;;;;;
+143E7;EGYPTIAN HIEROGLYPH-143E7;Lo;0;L;;;;;N;;;;;
+143E8;EGYPTIAN HIEROGLYPH-143E8;Lo;0;L;;;;;N;;;;;
+143E9;EGYPTIAN HIEROGLYPH-143E9;Lo;0;L;;;;;N;;;;;
+143EA;EGYPTIAN HIEROGLYPH-143EA;Lo;0;L;;;;;N;;;;;
+143EB;EGYPTIAN HIEROGLYPH-143EB;Lo;0;L;;;;;N;;;;;
+143EC;EGYPTIAN HIEROGLYPH-143EC;Lo;0;L;;;;;N;;;;;
+143ED;EGYPTIAN HIEROGLYPH-143ED;Lo;0;L;;;;;N;;;;;
+143EE;EGYPTIAN HIEROGLYPH-143EE;Lo;0;L;;;;;N;;;;;
+143EF;EGYPTIAN HIEROGLYPH-143EF;Lo;0;L;;;;;N;;;;;
+143F0;EGYPTIAN HIEROGLYPH-143F0;Lo;0;L;;;;;N;;;;;
+143F1;EGYPTIAN HIEROGLYPH-143F1;Lo;0;L;;;;;N;;;;;
+143F2;EGYPTIAN HIEROGLYPH-143F2;Lo;0;L;;;;;N;;;;;
+143F3;EGYPTIAN HIEROGLYPH-143F3;Lo;0;L;;;;;N;;;;;
+143F4;EGYPTIAN HIEROGLYPH-143F4;Lo;0;L;;;;;N;;;;;
+143F5;EGYPTIAN HIEROGLYPH-143F5;Lo;0;L;;;;;N;;;;;
+143F6;EGYPTIAN HIEROGLYPH-143F6;Lo;0;L;;;;;N;;;;;
+143F7;EGYPTIAN HIEROGLYPH-143F7;Lo;0;L;;;;;N;;;;;
+143F8;EGYPTIAN HIEROGLYPH-143F8;Lo;0;L;;;;;N;;;;;
+143F9;EGYPTIAN HIEROGLYPH-143F9;Lo;0;L;;;;;N;;;;;
+143FA;EGYPTIAN HIEROGLYPH-143FA;Lo;0;L;;;;;N;;;;;
+14400;ANATOLIAN HIEROGLYPH A001;Lo;0;L;;;;;N;;;;;
+14401;ANATOLIAN HIEROGLYPH A002;Lo;0;L;;;;;N;;;;;
+14402;ANATOLIAN HIEROGLYPH A003;Lo;0;L;;;;;N;;;;;
+14403;ANATOLIAN HIEROGLYPH A004;Lo;0;L;;;;;N;;;;;
+14404;ANATOLIAN HIEROGLYPH A005;Lo;0;L;;;;;N;;;;;
+14405;ANATOLIAN HIEROGLYPH A006;Lo;0;L;;;;;N;;;;;
+14406;ANATOLIAN HIEROGLYPH A007;Lo;0;L;;;;;N;;;;;
+14407;ANATOLIAN HIEROGLYPH A008;Lo;0;L;;;;;N;;;;;
+14408;ANATOLIAN HIEROGLYPH A009;Lo;0;L;;;;;N;;;;;
+14409;ANATOLIAN HIEROGLYPH A010;Lo;0;L;;;;;N;;;;;
+1440A;ANATOLIAN HIEROGLYPH A010A;Lo;0;L;;;;;N;;;;;
+1440B;ANATOLIAN HIEROGLYPH A011;Lo;0;L;;;;;N;;;;;
+1440C;ANATOLIAN HIEROGLYPH A012;Lo;0;L;;;;;N;;;;;
+1440D;ANATOLIAN HIEROGLYPH A013;Lo;0;L;;;;;N;;;;;
+1440E;ANATOLIAN HIEROGLYPH A014;Lo;0;L;;;;;N;;;;;
+1440F;ANATOLIAN HIEROGLYPH A015;Lo;0;L;;;;;N;;;;;
+14410;ANATOLIAN HIEROGLYPH A016;Lo;0;L;;;;;N;;;;;
+14411;ANATOLIAN HIEROGLYPH A017;Lo;0;L;;;;;N;;;;;
+14412;ANATOLIAN HIEROGLYPH A018;Lo;0;L;;;;;N;;;;;
+14413;ANATOLIAN HIEROGLYPH A019;Lo;0;L;;;;;N;;;;;
+14414;ANATOLIAN HIEROGLYPH A020;Lo;0;L;;;;;N;;;;;
+14415;ANATOLIAN HIEROGLYPH A021;Lo;0;L;;;;;N;;;;;
+14416;ANATOLIAN HIEROGLYPH A022;Lo;0;L;;;;;N;;;;;
+14417;ANATOLIAN HIEROGLYPH A023;Lo;0;L;;;;;N;;;;;
+14418;ANATOLIAN HIEROGLYPH A024;Lo;0;L;;;;;N;;;;;
+14419;ANATOLIAN HIEROGLYPH A025;Lo;0;L;;;;;N;;;;;
+1441A;ANATOLIAN HIEROGLYPH A026;Lo;0;L;;;;;N;;;;;
+1441B;ANATOLIAN HIEROGLYPH A026A;Lo;0;L;;;;;N;;;;;
+1441C;ANATOLIAN HIEROGLYPH A027;Lo;0;L;;;;;N;;;;;
+1441D;ANATOLIAN HIEROGLYPH A028;Lo;0;L;;;;;N;;;;;
+1441E;ANATOLIAN HIEROGLYPH A029;Lo;0;L;;;;;N;;;;;
+1441F;ANATOLIAN HIEROGLYPH A030;Lo;0;L;;;;;N;;;;;
+14420;ANATOLIAN HIEROGLYPH A031;Lo;0;L;;;;;N;;;;;
+14421;ANATOLIAN HIEROGLYPH A032;Lo;0;L;;;;;N;;;;;
+14422;ANATOLIAN HIEROGLYPH A033;Lo;0;L;;;;;N;;;;;
+14423;ANATOLIAN HIEROGLYPH A034;Lo;0;L;;;;;N;;;;;
+14424;ANATOLIAN HIEROGLYPH A035;Lo;0;L;;;;;N;;;;;
+14425;ANATOLIAN HIEROGLYPH A036;Lo;0;L;;;;;N;;;;;
+14426;ANATOLIAN HIEROGLYPH A037;Lo;0;L;;;;;N;;;;;
+14427;ANATOLIAN HIEROGLYPH A038;Lo;0;L;;;;;N;;;;;
+14428;ANATOLIAN HIEROGLYPH A039;Lo;0;L;;;;;N;;;;;
+14429;ANATOLIAN HIEROGLYPH A039A;Lo;0;L;;;;;N;;;;;
+1442A;ANATOLIAN HIEROGLYPH A040;Lo;0;L;;;;;N;;;;;
+1442B;ANATOLIAN HIEROGLYPH A041;Lo;0;L;;;;;N;;;;;
+1442C;ANATOLIAN HIEROGLYPH A041A;Lo;0;L;;;;;N;;;;;
+1442D;ANATOLIAN HIEROGLYPH A042;Lo;0;L;;;;;N;;;;;
+1442E;ANATOLIAN HIEROGLYPH A043;Lo;0;L;;;;;N;;;;;
+1442F;ANATOLIAN HIEROGLYPH A044;Lo;0;L;;;;;N;;;;;
+14430;ANATOLIAN HIEROGLYPH A045;Lo;0;L;;;;;N;;;;;
+14431;ANATOLIAN HIEROGLYPH A045A;Lo;0;L;;;;;N;;;;;
+14432;ANATOLIAN HIEROGLYPH A046;Lo;0;L;;;;;N;;;;;
+14433;ANATOLIAN HIEROGLYPH A046A;Lo;0;L;;;;;N;;;;;
+14434;ANATOLIAN HIEROGLYPH A046B;Lo;0;L;;;;;N;;;;;
+14435;ANATOLIAN HIEROGLYPH A047;Lo;0;L;;;;;N;;;;;
+14436;ANATOLIAN HIEROGLYPH A048;Lo;0;L;;;;;N;;;;;
+14437;ANATOLIAN HIEROGLYPH A049;Lo;0;L;;;;;N;;;;;
+14438;ANATOLIAN HIEROGLYPH A050;Lo;0;L;;;;;N;;;;;
+14439;ANATOLIAN HIEROGLYPH A051;Lo;0;L;;;;;N;;;;;
+1443A;ANATOLIAN HIEROGLYPH A052;Lo;0;L;;;;;N;;;;;
+1443B;ANATOLIAN HIEROGLYPH A053;Lo;0;L;;;;;N;;;;;
+1443C;ANATOLIAN HIEROGLYPH A054;Lo;0;L;;;;;N;;;;;
+1443D;ANATOLIAN HIEROGLYPH A055;Lo;0;L;;;;;N;;;;;
+1443E;ANATOLIAN HIEROGLYPH A056;Lo;0;L;;;;;N;;;;;
+1443F;ANATOLIAN HIEROGLYPH A057;Lo;0;L;;;;;N;;;;;
+14440;ANATOLIAN HIEROGLYPH A058;Lo;0;L;;;;;N;;;;;
+14441;ANATOLIAN HIEROGLYPH A059;Lo;0;L;;;;;N;;;;;
+14442;ANATOLIAN HIEROGLYPH A060;Lo;0;L;;;;;N;;;;;
+14443;ANATOLIAN HIEROGLYPH A061;Lo;0;L;;;;;N;;;;;
+14444;ANATOLIAN HIEROGLYPH A062;Lo;0;L;;;;;N;;;;;
+14445;ANATOLIAN HIEROGLYPH A063;Lo;0;L;;;;;N;;;;;
+14446;ANATOLIAN HIEROGLYPH A064;Lo;0;L;;;;;N;;;;;
+14447;ANATOLIAN HIEROGLYPH A065;Lo;0;L;;;;;N;;;;;
+14448;ANATOLIAN HIEROGLYPH A066;Lo;0;L;;;;;N;;;;;
+14449;ANATOLIAN HIEROGLYPH A066A;Lo;0;L;;;;;N;;;;;
+1444A;ANATOLIAN HIEROGLYPH A066B;Lo;0;L;;;;;N;;;;;
+1444B;ANATOLIAN HIEROGLYPH A066C;Lo;0;L;;;;;N;;;;;
+1444C;ANATOLIAN HIEROGLYPH A067;Lo;0;L;;;;;N;;;;;
+1444D;ANATOLIAN HIEROGLYPH A068;Lo;0;L;;;;;N;;;;;
+1444E;ANATOLIAN HIEROGLYPH A069;Lo;0;L;;;;;N;;;;;
+1444F;ANATOLIAN HIEROGLYPH A070;Lo;0;L;;;;;N;;;;;
+14450;ANATOLIAN HIEROGLYPH A071;Lo;0;L;;;;;N;;;;;
+14451;ANATOLIAN HIEROGLYPH A072;Lo;0;L;;;;;N;;;;;
+14452;ANATOLIAN HIEROGLYPH A073;Lo;0;L;;;;;N;;;;;
+14453;ANATOLIAN HIEROGLYPH A074;Lo;0;L;;;;;N;;;;;
+14454;ANATOLIAN HIEROGLYPH A075;Lo;0;L;;;;;N;;;;;
+14455;ANATOLIAN HIEROGLYPH A076;Lo;0;L;;;;;N;;;;;
+14456;ANATOLIAN HIEROGLYPH A077;Lo;0;L;;;;;N;;;;;
+14457;ANATOLIAN HIEROGLYPH A078;Lo;0;L;;;;;N;;;;;
+14458;ANATOLIAN HIEROGLYPH A079;Lo;0;L;;;;;N;;;;;
+14459;ANATOLIAN HIEROGLYPH A080;Lo;0;L;;;;;N;;;;;
+1445A;ANATOLIAN HIEROGLYPH A081;Lo;0;L;;;;;N;;;;;
+1445B;ANATOLIAN HIEROGLYPH A082;Lo;0;L;;;;;N;;;;;
+1445C;ANATOLIAN HIEROGLYPH A083;Lo;0;L;;;;;N;;;;;
+1445D;ANATOLIAN HIEROGLYPH A084;Lo;0;L;;;;;N;;;;;
+1445E;ANATOLIAN HIEROGLYPH A085;Lo;0;L;;;;;N;;;;;
+1445F;ANATOLIAN HIEROGLYPH A086;Lo;0;L;;;;;N;;;;;
+14460;ANATOLIAN HIEROGLYPH A087;Lo;0;L;;;;;N;;;;;
+14461;ANATOLIAN HIEROGLYPH A088;Lo;0;L;;;;;N;;;;;
+14462;ANATOLIAN HIEROGLYPH A089;Lo;0;L;;;;;N;;;;;
+14463;ANATOLIAN HIEROGLYPH A090;Lo;0;L;;;;;N;;;;;
+14464;ANATOLIAN HIEROGLYPH A091;Lo;0;L;;;;;N;;;;;
+14465;ANATOLIAN HIEROGLYPH A092;Lo;0;L;;;;;N;;;;;
+14466;ANATOLIAN HIEROGLYPH A093;Lo;0;L;;;;;N;;;;;
+14467;ANATOLIAN HIEROGLYPH A094;Lo;0;L;;;;;N;;;;;
+14468;ANATOLIAN HIEROGLYPH A095;Lo;0;L;;;;;N;;;;;
+14469;ANATOLIAN HIEROGLYPH A096;Lo;0;L;;;;;N;;;;;
+1446A;ANATOLIAN HIEROGLYPH A097;Lo;0;L;;;;;N;;;;;
+1446B;ANATOLIAN HIEROGLYPH A097A;Lo;0;L;;;;;N;;;;;
+1446C;ANATOLIAN HIEROGLYPH A098;Lo;0;L;;;;;N;;;;;
+1446D;ANATOLIAN HIEROGLYPH A098A;Lo;0;L;;;;;N;;;;;
+1446E;ANATOLIAN HIEROGLYPH A099;Lo;0;L;;;;;N;;;;;
+1446F;ANATOLIAN HIEROGLYPH A100;Lo;0;L;;;;;N;;;;;
+14470;ANATOLIAN HIEROGLYPH A100A;Lo;0;L;;;;;N;;;;;
+14471;ANATOLIAN HIEROGLYPH A101;Lo;0;L;;;;;N;;;;;
+14472;ANATOLIAN HIEROGLYPH A101A;Lo;0;L;;;;;N;;;;;
+14473;ANATOLIAN HIEROGLYPH A102;Lo;0;L;;;;;N;;;;;
+14474;ANATOLIAN HIEROGLYPH A102A;Lo;0;L;;;;;N;;;;;
+14475;ANATOLIAN HIEROGLYPH A103;Lo;0;L;;;;;N;;;;;
+14476;ANATOLIAN HIEROGLYPH A104;Lo;0;L;;;;;N;;;;;
+14477;ANATOLIAN HIEROGLYPH A104A;Lo;0;L;;;;;N;;;;;
+14478;ANATOLIAN HIEROGLYPH A104B;Lo;0;L;;;;;N;;;;;
+14479;ANATOLIAN HIEROGLYPH A104C;Lo;0;L;;;;;N;;;;;
+1447A;ANATOLIAN HIEROGLYPH A105;Lo;0;L;;;;;N;;;;;
+1447B;ANATOLIAN HIEROGLYPH A105A;Lo;0;L;;;;;N;;;;;
+1447C;ANATOLIAN HIEROGLYPH A105B;Lo;0;L;;;;;N;;;;;
+1447D;ANATOLIAN HIEROGLYPH A106;Lo;0;L;;;;;N;;;;;
+1447E;ANATOLIAN HIEROGLYPH A107;Lo;0;L;;;;;N;;;;;
+1447F;ANATOLIAN HIEROGLYPH A107A;Lo;0;L;;;;;N;;;;;
+14480;ANATOLIAN HIEROGLYPH A107B;Lo;0;L;;;;;N;;;;;
+14481;ANATOLIAN HIEROGLYPH A107C;Lo;0;L;;;;;N;;;;;
+14482;ANATOLIAN HIEROGLYPH A108;Lo;0;L;;;;;N;;;;;
+14483;ANATOLIAN HIEROGLYPH A109;Lo;0;L;;;;;N;;;;;
+14484;ANATOLIAN HIEROGLYPH A110;Lo;0;L;;;;;N;;;;;
+14485;ANATOLIAN HIEROGLYPH A110A;Lo;0;L;;;;;N;;;;;
+14486;ANATOLIAN HIEROGLYPH A110B;Lo;0;L;;;;;N;;;;;
+14487;ANATOLIAN HIEROGLYPH A111;Lo;0;L;;;;;N;;;;;
+14488;ANATOLIAN HIEROGLYPH A112;Lo;0;L;;;;;N;;;;;
+14489;ANATOLIAN HIEROGLYPH A113;Lo;0;L;;;;;N;;;;;
+1448A;ANATOLIAN HIEROGLYPH A114;Lo;0;L;;;;;N;;;;;
+1448B;ANATOLIAN HIEROGLYPH A115;Lo;0;L;;;;;N;;;;;
+1448C;ANATOLIAN HIEROGLYPH A115A;Lo;0;L;;;;;N;;;;;
+1448D;ANATOLIAN HIEROGLYPH A116;Lo;0;L;;;;;N;;;;;
+1448E;ANATOLIAN HIEROGLYPH A117;Lo;0;L;;;;;N;;;;;
+1448F;ANATOLIAN HIEROGLYPH A118;Lo;0;L;;;;;N;;;;;
+14490;ANATOLIAN HIEROGLYPH A119;Lo;0;L;;;;;N;;;;;
+14491;ANATOLIAN HIEROGLYPH A120;Lo;0;L;;;;;N;;;;;
+14492;ANATOLIAN HIEROGLYPH A121;Lo;0;L;;;;;N;;;;;
+14493;ANATOLIAN HIEROGLYPH A122;Lo;0;L;;;;;N;;;;;
+14494;ANATOLIAN HIEROGLYPH A123;Lo;0;L;;;;;N;;;;;
+14495;ANATOLIAN HIEROGLYPH A124;Lo;0;L;;;;;N;;;;;
+14496;ANATOLIAN HIEROGLYPH A125;Lo;0;L;;;;;N;;;;;
+14497;ANATOLIAN HIEROGLYPH A125A;Lo;0;L;;;;;N;;;;;
+14498;ANATOLIAN HIEROGLYPH A126;Lo;0;L;;;;;N;;;;;
+14499;ANATOLIAN HIEROGLYPH A127;Lo;0;L;;;;;N;;;;;
+1449A;ANATOLIAN HIEROGLYPH A128;Lo;0;L;;;;;N;;;;;
+1449B;ANATOLIAN HIEROGLYPH A129;Lo;0;L;;;;;N;;;;;
+1449C;ANATOLIAN HIEROGLYPH A130;Lo;0;L;;;;;N;;;;;
+1449D;ANATOLIAN HIEROGLYPH A131;Lo;0;L;;;;;N;;;;;
+1449E;ANATOLIAN HIEROGLYPH A132;Lo;0;L;;;;;N;;;;;
+1449F;ANATOLIAN HIEROGLYPH A133;Lo;0;L;;;;;N;;;;;
+144A0;ANATOLIAN HIEROGLYPH A134;Lo;0;L;;;;;N;;;;;
+144A1;ANATOLIAN HIEROGLYPH A135;Lo;0;L;;;;;N;;;;;
+144A2;ANATOLIAN HIEROGLYPH A135A;Lo;0;L;;;;;N;;;;;
+144A3;ANATOLIAN HIEROGLYPH A136;Lo;0;L;;;;;N;;;;;
+144A4;ANATOLIAN HIEROGLYPH A137;Lo;0;L;;;;;N;;;;;
+144A5;ANATOLIAN HIEROGLYPH A138;Lo;0;L;;;;;N;;;;;
+144A6;ANATOLIAN HIEROGLYPH A139;Lo;0;L;;;;;N;;;;;
+144A7;ANATOLIAN HIEROGLYPH A140;Lo;0;L;;;;;N;;;;;
+144A8;ANATOLIAN HIEROGLYPH A141;Lo;0;L;;;;;N;;;;;
+144A9;ANATOLIAN HIEROGLYPH A142;Lo;0;L;;;;;N;;;;;
+144AA;ANATOLIAN HIEROGLYPH A143;Lo;0;L;;;;;N;;;;;
+144AB;ANATOLIAN HIEROGLYPH A144;Lo;0;L;;;;;N;;;;;
+144AC;ANATOLIAN HIEROGLYPH A145;Lo;0;L;;;;;N;;;;;
+144AD;ANATOLIAN HIEROGLYPH A146;Lo;0;L;;;;;N;;;;;
+144AE;ANATOLIAN HIEROGLYPH A147;Lo;0;L;;;;;N;;;;;
+144AF;ANATOLIAN HIEROGLYPH A148;Lo;0;L;;;;;N;;;;;
+144B0;ANATOLIAN HIEROGLYPH A149;Lo;0;L;;;;;N;;;;;
+144B1;ANATOLIAN HIEROGLYPH A150;Lo;0;L;;;;;N;;;;;
+144B2;ANATOLIAN HIEROGLYPH A151;Lo;0;L;;;;;N;;;;;
+144B3;ANATOLIAN HIEROGLYPH A152;Lo;0;L;;;;;N;;;;;
+144B4;ANATOLIAN HIEROGLYPH A153;Lo;0;L;;;;;N;;;;;
+144B5;ANATOLIAN HIEROGLYPH A154;Lo;0;L;;;;;N;;;;;
+144B6;ANATOLIAN HIEROGLYPH A155;Lo;0;L;;;;;N;;;;;
+144B7;ANATOLIAN HIEROGLYPH A156;Lo;0;L;;;;;N;;;;;
+144B8;ANATOLIAN HIEROGLYPH A157;Lo;0;L;;;;;N;;;;;
+144B9;ANATOLIAN HIEROGLYPH A158;Lo;0;L;;;;;N;;;;;
+144BA;ANATOLIAN HIEROGLYPH A159;Lo;0;L;;;;;N;;;;;
+144BB;ANATOLIAN HIEROGLYPH A160;Lo;0;L;;;;;N;;;;;
+144BC;ANATOLIAN HIEROGLYPH A161;Lo;0;L;;;;;N;;;;;
+144BD;ANATOLIAN HIEROGLYPH A162;Lo;0;L;;;;;N;;;;;
+144BE;ANATOLIAN HIEROGLYPH A163;Lo;0;L;;;;;N;;;;;
+144BF;ANATOLIAN HIEROGLYPH A164;Lo;0;L;;;;;N;;;;;
+144C0;ANATOLIAN HIEROGLYPH A165;Lo;0;L;;;;;N;;;;;
+144C1;ANATOLIAN HIEROGLYPH A166;Lo;0;L;;;;;N;;;;;
+144C2;ANATOLIAN HIEROGLYPH A167;Lo;0;L;;;;;N;;;;;
+144C3;ANATOLIAN HIEROGLYPH A168;Lo;0;L;;;;;N;;;;;
+144C4;ANATOLIAN HIEROGLYPH A169;Lo;0;L;;;;;N;;;;;
+144C5;ANATOLIAN HIEROGLYPH A170;Lo;0;L;;;;;N;;;;;
+144C6;ANATOLIAN HIEROGLYPH A171;Lo;0;L;;;;;N;;;;;
+144C7;ANATOLIAN HIEROGLYPH A172;Lo;0;L;;;;;N;;;;;
+144C8;ANATOLIAN HIEROGLYPH A173;Lo;0;L;;;;;N;;;;;
+144C9;ANATOLIAN HIEROGLYPH A174;Lo;0;L;;;;;N;;;;;
+144CA;ANATOLIAN HIEROGLYPH A175;Lo;0;L;;;;;N;;;;;
+144CB;ANATOLIAN HIEROGLYPH A176;Lo;0;L;;;;;N;;;;;
+144CC;ANATOLIAN HIEROGLYPH A177;Lo;0;L;;;;;N;;;;;
+144CD;ANATOLIAN HIEROGLYPH A178;Lo;0;L;;;;;N;;;;;
+144CE;ANATOLIAN HIEROGLYPH A179;Lo;0;L;;;;;N;;;;;
+144CF;ANATOLIAN HIEROGLYPH A180;Lo;0;L;;;;;N;;;;;
+144D0;ANATOLIAN HIEROGLYPH A181;Lo;0;L;;;;;N;;;;;
+144D1;ANATOLIAN HIEROGLYPH A182;Lo;0;L;;;;;N;;;;;
+144D2;ANATOLIAN HIEROGLYPH A183;Lo;0;L;;;;;N;;;;;
+144D3;ANATOLIAN HIEROGLYPH A184;Lo;0;L;;;;;N;;;;;
+144D4;ANATOLIAN HIEROGLYPH A185;Lo;0;L;;;;;N;;;;;
+144D5;ANATOLIAN HIEROGLYPH A186;Lo;0;L;;;;;N;;;;;
+144D6;ANATOLIAN HIEROGLYPH A187;Lo;0;L;;;;;N;;;;;
+144D7;ANATOLIAN HIEROGLYPH A188;Lo;0;L;;;;;N;;;;;
+144D8;ANATOLIAN HIEROGLYPH A189;Lo;0;L;;;;;N;;;;;
+144D9;ANATOLIAN HIEROGLYPH A190;Lo;0;L;;;;;N;;;;;
+144DA;ANATOLIAN HIEROGLYPH A191;Lo;0;L;;;;;N;;;;;
+144DB;ANATOLIAN HIEROGLYPH A192;Lo;0;L;;;;;N;;;;;
+144DC;ANATOLIAN HIEROGLYPH A193;Lo;0;L;;;;;N;;;;;
+144DD;ANATOLIAN HIEROGLYPH A194;Lo;0;L;;;;;N;;;;;
+144DE;ANATOLIAN HIEROGLYPH A195;Lo;0;L;;;;;N;;;;;
+144DF;ANATOLIAN HIEROGLYPH A196;Lo;0;L;;;;;N;;;;;
+144E0;ANATOLIAN HIEROGLYPH A197;Lo;0;L;;;;;N;;;;;
+144E1;ANATOLIAN HIEROGLYPH A198;Lo;0;L;;;;;N;;;;;
+144E2;ANATOLIAN HIEROGLYPH A199;Lo;0;L;;;;;N;;;;;
+144E3;ANATOLIAN HIEROGLYPH A200;Lo;0;L;;;;;N;;;;;
+144E4;ANATOLIAN HIEROGLYPH A201;Lo;0;L;;;;;N;;;;;
+144E5;ANATOLIAN HIEROGLYPH A202;Lo;0;L;;;;;N;;;;;
+144E6;ANATOLIAN HIEROGLYPH A202A;Lo;0;L;;;;;N;;;;;
+144E7;ANATOLIAN HIEROGLYPH A202B;Lo;0;L;;;;;N;;;;;
+144E8;ANATOLIAN HIEROGLYPH A203;Lo;0;L;;;;;N;;;;;
+144E9;ANATOLIAN HIEROGLYPH A204;Lo;0;L;;;;;N;;;;;
+144EA;ANATOLIAN HIEROGLYPH A205;Lo;0;L;;;;;N;;;;;
+144EB;ANATOLIAN HIEROGLYPH A206;Lo;0;L;;;;;N;;;;;
+144EC;ANATOLIAN HIEROGLYPH A207;Lo;0;L;;;;;N;;;;;
+144ED;ANATOLIAN HIEROGLYPH A207A;Lo;0;L;;;;;N;;;;;
+144EE;ANATOLIAN HIEROGLYPH A208;Lo;0;L;;;;;N;;;;;
+144EF;ANATOLIAN HIEROGLYPH A209;Lo;0;L;;;;;N;;;;;
+144F0;ANATOLIAN HIEROGLYPH A209A;Lo;0;L;;;;;N;;;;;
+144F1;ANATOLIAN HIEROGLYPH A210;Lo;0;L;;;;;N;;;;;
+144F2;ANATOLIAN HIEROGLYPH A211;Lo;0;L;;;;;N;;;;;
+144F3;ANATOLIAN HIEROGLYPH A212;Lo;0;L;;;;;N;;;;;
+144F4;ANATOLIAN HIEROGLYPH A213;Lo;0;L;;;;;N;;;;;
+144F5;ANATOLIAN HIEROGLYPH A214;Lo;0;L;;;;;N;;;;;
+144F6;ANATOLIAN HIEROGLYPH A215;Lo;0;L;;;;;N;;;;;
+144F7;ANATOLIAN HIEROGLYPH A215A;Lo;0;L;;;;;N;;;;;
+144F8;ANATOLIAN HIEROGLYPH A216;Lo;0;L;;;;;N;;;;;
+144F9;ANATOLIAN HIEROGLYPH A216A;Lo;0;L;;;;;N;;;;;
+144FA;ANATOLIAN HIEROGLYPH A217;Lo;0;L;;;;;N;;;;;
+144FB;ANATOLIAN HIEROGLYPH A218;Lo;0;L;;;;;N;;;;;
+144FC;ANATOLIAN HIEROGLYPH A219;Lo;0;L;;;;;N;;;;;
+144FD;ANATOLIAN HIEROGLYPH A220;Lo;0;L;;;;;N;;;;;
+144FE;ANATOLIAN HIEROGLYPH A221;Lo;0;L;;;;;N;;;;;
+144FF;ANATOLIAN HIEROGLYPH A222;Lo;0;L;;;;;N;;;;;
+14500;ANATOLIAN HIEROGLYPH A223;Lo;0;L;;;;;N;;;;;
+14501;ANATOLIAN HIEROGLYPH A224;Lo;0;L;;;;;N;;;;;
+14502;ANATOLIAN HIEROGLYPH A225;Lo;0;L;;;;;N;;;;;
+14503;ANATOLIAN HIEROGLYPH A226;Lo;0;L;;;;;N;;;;;
+14504;ANATOLIAN HIEROGLYPH A227;Lo;0;L;;;;;N;;;;;
+14505;ANATOLIAN HIEROGLYPH A227A;Lo;0;L;;;;;N;;;;;
+14506;ANATOLIAN HIEROGLYPH A228;Lo;0;L;;;;;N;;;;;
+14507;ANATOLIAN HIEROGLYPH A229;Lo;0;L;;;;;N;;;;;
+14508;ANATOLIAN HIEROGLYPH A230;Lo;0;L;;;;;N;;;;;
+14509;ANATOLIAN HIEROGLYPH A231;Lo;0;L;;;;;N;;;;;
+1450A;ANATOLIAN HIEROGLYPH A232;Lo;0;L;;;;;N;;;;;
+1450B;ANATOLIAN HIEROGLYPH A233;Lo;0;L;;;;;N;;;;;
+1450C;ANATOLIAN HIEROGLYPH A234;Lo;0;L;;;;;N;;;;;
+1450D;ANATOLIAN HIEROGLYPH A235;Lo;0;L;;;;;N;;;;;
+1450E;ANATOLIAN HIEROGLYPH A236;Lo;0;L;;;;;N;;;;;
+1450F;ANATOLIAN HIEROGLYPH A237;Lo;0;L;;;;;N;;;;;
+14510;ANATOLIAN HIEROGLYPH A238;Lo;0;L;;;;;N;;;;;
+14511;ANATOLIAN HIEROGLYPH A239;Lo;0;L;;;;;N;;;;;
+14512;ANATOLIAN HIEROGLYPH A240;Lo;0;L;;;;;N;;;;;
+14513;ANATOLIAN HIEROGLYPH A241;Lo;0;L;;;;;N;;;;;
+14514;ANATOLIAN HIEROGLYPH A242;Lo;0;L;;;;;N;;;;;
+14515;ANATOLIAN HIEROGLYPH A243;Lo;0;L;;;;;N;;;;;
+14516;ANATOLIAN HIEROGLYPH A244;Lo;0;L;;;;;N;;;;;
+14517;ANATOLIAN HIEROGLYPH A245;Lo;0;L;;;;;N;;;;;
+14518;ANATOLIAN HIEROGLYPH A246;Lo;0;L;;;;;N;;;;;
+14519;ANATOLIAN HIEROGLYPH A247;Lo;0;L;;;;;N;;;;;
+1451A;ANATOLIAN HIEROGLYPH A248;Lo;0;L;;;;;N;;;;;
+1451B;ANATOLIAN HIEROGLYPH A249;Lo;0;L;;;;;N;;;;;
+1451C;ANATOLIAN HIEROGLYPH A250;Lo;0;L;;;;;N;;;;;
+1451D;ANATOLIAN HIEROGLYPH A251;Lo;0;L;;;;;N;;;;;
+1451E;ANATOLIAN HIEROGLYPH A252;Lo;0;L;;;;;N;;;;;
+1451F;ANATOLIAN HIEROGLYPH A253;Lo;0;L;;;;;N;;;;;
+14520;ANATOLIAN HIEROGLYPH A254;Lo;0;L;;;;;N;;;;;
+14521;ANATOLIAN HIEROGLYPH A255;Lo;0;L;;;;;N;;;;;
+14522;ANATOLIAN HIEROGLYPH A256;Lo;0;L;;;;;N;;;;;
+14523;ANATOLIAN HIEROGLYPH A257;Lo;0;L;;;;;N;;;;;
+14524;ANATOLIAN HIEROGLYPH A258;Lo;0;L;;;;;N;;;;;
+14525;ANATOLIAN HIEROGLYPH A259;Lo;0;L;;;;;N;;;;;
+14526;ANATOLIAN HIEROGLYPH A260;Lo;0;L;;;;;N;;;;;
+14527;ANATOLIAN HIEROGLYPH A261;Lo;0;L;;;;;N;;;;;
+14528;ANATOLIAN HIEROGLYPH A262;Lo;0;L;;;;;N;;;;;
+14529;ANATOLIAN HIEROGLYPH A263;Lo;0;L;;;;;N;;;;;
+1452A;ANATOLIAN HIEROGLYPH A264;Lo;0;L;;;;;N;;;;;
+1452B;ANATOLIAN HIEROGLYPH A265;Lo;0;L;;;;;N;;;;;
+1452C;ANATOLIAN HIEROGLYPH A266;Lo;0;L;;;;;N;;;;;
+1452D;ANATOLIAN HIEROGLYPH A267;Lo;0;L;;;;;N;;;;;
+1452E;ANATOLIAN HIEROGLYPH A267A;Lo;0;L;;;;;N;;;;;
+1452F;ANATOLIAN HIEROGLYPH A268;Lo;0;L;;;;;N;;;;;
+14530;ANATOLIAN HIEROGLYPH A269;Lo;0;L;;;;;N;;;;;
+14531;ANATOLIAN HIEROGLYPH A270;Lo;0;L;;;;;N;;;;;
+14532;ANATOLIAN HIEROGLYPH A271;Lo;0;L;;;;;N;;;;;
+14533;ANATOLIAN HIEROGLYPH A272;Lo;0;L;;;;;N;;;;;
+14534;ANATOLIAN HIEROGLYPH A273;Lo;0;L;;;;;N;;;;;
+14535;ANATOLIAN HIEROGLYPH A274;Lo;0;L;;;;;N;;;;;
+14536;ANATOLIAN HIEROGLYPH A275;Lo;0;L;;;;;N;;;;;
+14537;ANATOLIAN HIEROGLYPH A276;Lo;0;L;;;;;N;;;;;
+14538;ANATOLIAN HIEROGLYPH A277;Lo;0;L;;;;;N;;;;;
+14539;ANATOLIAN HIEROGLYPH A278;Lo;0;L;;;;;N;;;;;
+1453A;ANATOLIAN HIEROGLYPH A279;Lo;0;L;;;;;N;;;;;
+1453B;ANATOLIAN HIEROGLYPH A280;Lo;0;L;;;;;N;;;;;
+1453C;ANATOLIAN HIEROGLYPH A281;Lo;0;L;;;;;N;;;;;
+1453D;ANATOLIAN HIEROGLYPH A282;Lo;0;L;;;;;N;;;;;
+1453E;ANATOLIAN HIEROGLYPH A283;Lo;0;L;;;;;N;;;;;
+1453F;ANATOLIAN HIEROGLYPH A284;Lo;0;L;;;;;N;;;;;
+14540;ANATOLIAN HIEROGLYPH A285;Lo;0;L;;;;;N;;;;;
+14541;ANATOLIAN HIEROGLYPH A286;Lo;0;L;;;;;N;;;;;
+14542;ANATOLIAN HIEROGLYPH A287;Lo;0;L;;;;;N;;;;;
+14543;ANATOLIAN HIEROGLYPH A288;Lo;0;L;;;;;N;;;;;
+14544;ANATOLIAN HIEROGLYPH A289;Lo;0;L;;;;;N;;;;;
+14545;ANATOLIAN HIEROGLYPH A289A;Lo;0;L;;;;;N;;;;;
+14546;ANATOLIAN HIEROGLYPH A290;Lo;0;L;;;;;N;;;;;
+14547;ANATOLIAN HIEROGLYPH A291;Lo;0;L;;;;;N;;;;;
+14548;ANATOLIAN HIEROGLYPH A292;Lo;0;L;;;;;N;;;;;
+14549;ANATOLIAN HIEROGLYPH A293;Lo;0;L;;;;;N;;;;;
+1454A;ANATOLIAN HIEROGLYPH A294;Lo;0;L;;;;;N;;;;;
+1454B;ANATOLIAN HIEROGLYPH A294A;Lo;0;L;;;;;N;;;;;
+1454C;ANATOLIAN HIEROGLYPH A295;Lo;0;L;;;;;N;;;;;
+1454D;ANATOLIAN HIEROGLYPH A296;Lo;0;L;;;;;N;;;;;
+1454E;ANATOLIAN HIEROGLYPH A297;Lo;0;L;;;;;N;;;;;
+1454F;ANATOLIAN HIEROGLYPH A298;Lo;0;L;;;;;N;;;;;
+14550;ANATOLIAN HIEROGLYPH A299;Lo;0;L;;;;;N;;;;;
+14551;ANATOLIAN HIEROGLYPH A299A;Lo;0;L;;;;;N;;;;;
+14552;ANATOLIAN HIEROGLYPH A300;Lo;0;L;;;;;N;;;;;
+14553;ANATOLIAN HIEROGLYPH A301;Lo;0;L;;;;;N;;;;;
+14554;ANATOLIAN HIEROGLYPH A302;Lo;0;L;;;;;N;;;;;
+14555;ANATOLIAN HIEROGLYPH A303;Lo;0;L;;;;;N;;;;;
+14556;ANATOLIAN HIEROGLYPH A304;Lo;0;L;;;;;N;;;;;
+14557;ANATOLIAN HIEROGLYPH A305;Lo;0;L;;;;;N;;;;;
+14558;ANATOLIAN HIEROGLYPH A306;Lo;0;L;;;;;N;;;;;
+14559;ANATOLIAN HIEROGLYPH A307;Lo;0;L;;;;;N;;;;;
+1455A;ANATOLIAN HIEROGLYPH A308;Lo;0;L;;;;;N;;;;;
+1455B;ANATOLIAN HIEROGLYPH A309;Lo;0;L;;;;;N;;;;;
+1455C;ANATOLIAN HIEROGLYPH A309A;Lo;0;L;;;;;N;;;;;
+1455D;ANATOLIAN HIEROGLYPH A310;Lo;0;L;;;;;N;;;;;
+1455E;ANATOLIAN HIEROGLYPH A311;Lo;0;L;;;;;N;;;;;
+1455F;ANATOLIAN HIEROGLYPH A312;Lo;0;L;;;;;N;;;;;
+14560;ANATOLIAN HIEROGLYPH A313;Lo;0;L;;;;;N;;;;;
+14561;ANATOLIAN HIEROGLYPH A314;Lo;0;L;;;;;N;;;;;
+14562;ANATOLIAN HIEROGLYPH A315;Lo;0;L;;;;;N;;;;;
+14563;ANATOLIAN HIEROGLYPH A316;Lo;0;L;;;;;N;;;;;
+14564;ANATOLIAN HIEROGLYPH A317;Lo;0;L;;;;;N;;;;;
+14565;ANATOLIAN HIEROGLYPH A318;Lo;0;L;;;;;N;;;;;
+14566;ANATOLIAN HIEROGLYPH A319;Lo;0;L;;;;;N;;;;;
+14567;ANATOLIAN HIEROGLYPH A320;Lo;0;L;;;;;N;;;;;
+14568;ANATOLIAN HIEROGLYPH A321;Lo;0;L;;;;;N;;;;;
+14569;ANATOLIAN HIEROGLYPH A322;Lo;0;L;;;;;N;;;;;
+1456A;ANATOLIAN HIEROGLYPH A323;Lo;0;L;;;;;N;;;;;
+1456B;ANATOLIAN HIEROGLYPH A324;Lo;0;L;;;;;N;;;;;
+1456C;ANATOLIAN HIEROGLYPH A325;Lo;0;L;;;;;N;;;;;
+1456D;ANATOLIAN HIEROGLYPH A326;Lo;0;L;;;;;N;;;;;
+1456E;ANATOLIAN HIEROGLYPH A327;Lo;0;L;;;;;N;;;;;
+1456F;ANATOLIAN HIEROGLYPH A328;Lo;0;L;;;;;N;;;;;
+14570;ANATOLIAN HIEROGLYPH A329;Lo;0;L;;;;;N;;;;;
+14571;ANATOLIAN HIEROGLYPH A329A;Lo;0;L;;;;;N;;;;;
+14572;ANATOLIAN HIEROGLYPH A330;Lo;0;L;;;;;N;;;;;
+14573;ANATOLIAN HIEROGLYPH A331;Lo;0;L;;;;;N;;;;;
+14574;ANATOLIAN HIEROGLYPH A332A;Lo;0;L;;;;;N;;;;;
+14575;ANATOLIAN HIEROGLYPH A332B;Lo;0;L;;;;;N;;;;;
+14576;ANATOLIAN HIEROGLYPH A332C;Lo;0;L;;;;;N;;;;;
+14577;ANATOLIAN HIEROGLYPH A333;Lo;0;L;;;;;N;;;;;
+14578;ANATOLIAN HIEROGLYPH A334;Lo;0;L;;;;;N;;;;;
+14579;ANATOLIAN HIEROGLYPH A335;Lo;0;L;;;;;N;;;;;
+1457A;ANATOLIAN HIEROGLYPH A336;Lo;0;L;;;;;N;;;;;
+1457B;ANATOLIAN HIEROGLYPH A336A;Lo;0;L;;;;;N;;;;;
+1457C;ANATOLIAN HIEROGLYPH A336B;Lo;0;L;;;;;N;;;;;
+1457D;ANATOLIAN HIEROGLYPH A336C;Lo;0;L;;;;;N;;;;;
+1457E;ANATOLIAN HIEROGLYPH A337;Lo;0;L;;;;;N;;;;;
+1457F;ANATOLIAN HIEROGLYPH A338;Lo;0;L;;;;;N;;;;;
+14580;ANATOLIAN HIEROGLYPH A339;Lo;0;L;;;;;N;;;;;
+14581;ANATOLIAN HIEROGLYPH A340;Lo;0;L;;;;;N;;;;;
+14582;ANATOLIAN HIEROGLYPH A341;Lo;0;L;;;;;N;;;;;
+14583;ANATOLIAN HIEROGLYPH A342;Lo;0;L;;;;;N;;;;;
+14584;ANATOLIAN HIEROGLYPH A343;Lo;0;L;;;;;N;;;;;
+14585;ANATOLIAN HIEROGLYPH A344;Lo;0;L;;;;;N;;;;;
+14586;ANATOLIAN HIEROGLYPH A345;Lo;0;L;;;;;N;;;;;
+14587;ANATOLIAN HIEROGLYPH A346;Lo;0;L;;;;;N;;;;;
+14588;ANATOLIAN HIEROGLYPH A347;Lo;0;L;;;;;N;;;;;
+14589;ANATOLIAN HIEROGLYPH A348;Lo;0;L;;;;;N;;;;;
+1458A;ANATOLIAN HIEROGLYPH A349;Lo;0;L;;;;;N;;;;;
+1458B;ANATOLIAN HIEROGLYPH A350;Lo;0;L;;;;;N;;;;;
+1458C;ANATOLIAN HIEROGLYPH A351;Lo;0;L;;;;;N;;;;;
+1458D;ANATOLIAN HIEROGLYPH A352;Lo;0;L;;;;;N;;;;;
+1458E;ANATOLIAN HIEROGLYPH A353;Lo;0;L;;;;;N;;;;;
+1458F;ANATOLIAN HIEROGLYPH A354;Lo;0;L;;;;;N;;;;;
+14590;ANATOLIAN HIEROGLYPH A355;Lo;0;L;;;;;N;;;;;
+14591;ANATOLIAN HIEROGLYPH A356;Lo;0;L;;;;;N;;;;;
+14592;ANATOLIAN HIEROGLYPH A357;Lo;0;L;;;;;N;;;;;
+14593;ANATOLIAN HIEROGLYPH A358;Lo;0;L;;;;;N;;;;;
+14594;ANATOLIAN HIEROGLYPH A359;Lo;0;L;;;;;N;;;;;
+14595;ANATOLIAN HIEROGLYPH A359A;Lo;0;L;;;;;N;;;;;
+14596;ANATOLIAN HIEROGLYPH A360;Lo;0;L;;;;;N;;;;;
+14597;ANATOLIAN HIEROGLYPH A361;Lo;0;L;;;;;N;;;;;
+14598;ANATOLIAN HIEROGLYPH A362;Lo;0;L;;;;;N;;;;;
+14599;ANATOLIAN HIEROGLYPH A363;Lo;0;L;;;;;N;;;;;
+1459A;ANATOLIAN HIEROGLYPH A364;Lo;0;L;;;;;N;;;;;
+1459B;ANATOLIAN HIEROGLYPH A364A;Lo;0;L;;;;;N;;;;;
+1459C;ANATOLIAN HIEROGLYPH A365;Lo;0;L;;;;;N;;;;;
+1459D;ANATOLIAN HIEROGLYPH A366;Lo;0;L;;;;;N;;;;;
+1459E;ANATOLIAN HIEROGLYPH A367;Lo;0;L;;;;;N;;;;;
+1459F;ANATOLIAN HIEROGLYPH A368;Lo;0;L;;;;;N;;;;;
+145A0;ANATOLIAN HIEROGLYPH A368A;Lo;0;L;;;;;N;;;;;
+145A1;ANATOLIAN HIEROGLYPH A369;Lo;0;L;;;;;N;;;;;
+145A2;ANATOLIAN HIEROGLYPH A370;Lo;0;L;;;;;N;;;;;
+145A3;ANATOLIAN HIEROGLYPH A371;Lo;0;L;;;;;N;;;;;
+145A4;ANATOLIAN HIEROGLYPH A371A;Lo;0;L;;;;;N;;;;;
+145A5;ANATOLIAN HIEROGLYPH A372;Lo;0;L;;;;;N;;;;;
+145A6;ANATOLIAN HIEROGLYPH A373;Lo;0;L;;;;;N;;;;;
+145A7;ANATOLIAN HIEROGLYPH A374;Lo;0;L;;;;;N;;;;;
+145A8;ANATOLIAN HIEROGLYPH A375;Lo;0;L;;;;;N;;;;;
+145A9;ANATOLIAN HIEROGLYPH A376;Lo;0;L;;;;;N;;;;;
+145AA;ANATOLIAN HIEROGLYPH A377;Lo;0;L;;;;;N;;;;;
+145AB;ANATOLIAN HIEROGLYPH A378;Lo;0;L;;;;;N;;;;;
+145AC;ANATOLIAN HIEROGLYPH A379;Lo;0;L;;;;;N;;;;;
+145AD;ANATOLIAN HIEROGLYPH A380;Lo;0;L;;;;;N;;;;;
+145AE;ANATOLIAN HIEROGLYPH A381;Lo;0;L;;;;;N;;;;;
+145AF;ANATOLIAN HIEROGLYPH A381A;Lo;0;L;;;;;N;;;;;
+145B0;ANATOLIAN HIEROGLYPH A382;Lo;0;L;;;;;N;;;;;
+145B1;ANATOLIAN HIEROGLYPH A383 RA OR RI;Lo;0;L;;;;;N;;;;;
+145B2;ANATOLIAN HIEROGLYPH A383A;Lo;0;L;;;;;N;;;;;
+145B3;ANATOLIAN HIEROGLYPH A384;Lo;0;L;;;;;N;;;;;
+145B4;ANATOLIAN HIEROGLYPH A385;Lo;0;L;;;;;N;;;;;
+145B5;ANATOLIAN HIEROGLYPH A386;Lo;0;L;;;;;N;;;;;
+145B6;ANATOLIAN HIEROGLYPH A386A;Lo;0;L;;;;;N;;;;;
+145B7;ANATOLIAN HIEROGLYPH A387;Lo;0;L;;;;;N;;;;;
+145B8;ANATOLIAN HIEROGLYPH A388;Lo;0;L;;;;;N;;;;;
+145B9;ANATOLIAN HIEROGLYPH A389;Lo;0;L;;;;;N;;;;;
+145BA;ANATOLIAN HIEROGLYPH A390;Lo;0;L;;;;;N;;;;;
+145BB;ANATOLIAN HIEROGLYPH A391;Lo;0;L;;;;;N;;;;;
+145BC;ANATOLIAN HIEROGLYPH A392;Lo;0;L;;;;;N;;;;;
+145BD;ANATOLIAN HIEROGLYPH A393 EIGHT;Lo;0;L;;;;;N;;;;;
+145BE;ANATOLIAN HIEROGLYPH A394;Lo;0;L;;;;;N;;;;;
+145BF;ANATOLIAN HIEROGLYPH A395;Lo;0;L;;;;;N;;;;;
+145C0;ANATOLIAN HIEROGLYPH A396;Lo;0;L;;;;;N;;;;;
+145C1;ANATOLIAN HIEROGLYPH A397;Lo;0;L;;;;;N;;;;;
+145C2;ANATOLIAN HIEROGLYPH A398;Lo;0;L;;;;;N;;;;;
+145C3;ANATOLIAN HIEROGLYPH A399;Lo;0;L;;;;;N;;;;;
+145C4;ANATOLIAN HIEROGLYPH A400;Lo;0;L;;;;;N;;;;;
+145C5;ANATOLIAN HIEROGLYPH A401;Lo;0;L;;;;;N;;;;;
+145C6;ANATOLIAN HIEROGLYPH A402;Lo;0;L;;;;;N;;;;;
+145C7;ANATOLIAN HIEROGLYPH A403;Lo;0;L;;;;;N;;;;;
+145C8;ANATOLIAN HIEROGLYPH A404;Lo;0;L;;;;;N;;;;;
+145C9;ANATOLIAN HIEROGLYPH A405;Lo;0;L;;;;;N;;;;;
+145CA;ANATOLIAN HIEROGLYPH A406;Lo;0;L;;;;;N;;;;;
+145CB;ANATOLIAN HIEROGLYPH A407;Lo;0;L;;;;;N;;;;;
+145CC;ANATOLIAN HIEROGLYPH A408;Lo;0;L;;;;;N;;;;;
+145CD;ANATOLIAN HIEROGLYPH A409;Lo;0;L;;;;;N;;;;;
+145CE;ANATOLIAN HIEROGLYPH A410 BEGIN LOGOGRAM MARK;Lo;0;L;;;;;N;;;;;
+145CF;ANATOLIAN HIEROGLYPH A410A END LOGOGRAM MARK;Lo;0;L;;;;;N;;;;;
+145D0;ANATOLIAN HIEROGLYPH A411;Lo;0;L;;;;;N;;;;;
+145D1;ANATOLIAN HIEROGLYPH A412;Lo;0;L;;;;;N;;;;;
+145D2;ANATOLIAN HIEROGLYPH A413;Lo;0;L;;;;;N;;;;;
+145D3;ANATOLIAN HIEROGLYPH A414;Lo;0;L;;;;;N;;;;;
+145D4;ANATOLIAN HIEROGLYPH A415;Lo;0;L;;;;;N;;;;;
+145D5;ANATOLIAN HIEROGLYPH A416;Lo;0;L;;;;;N;;;;;
+145D6;ANATOLIAN HIEROGLYPH A417;Lo;0;L;;;;;N;;;;;
+145D7;ANATOLIAN HIEROGLYPH A418;Lo;0;L;;;;;N;;;;;
+145D8;ANATOLIAN HIEROGLYPH A419;Lo;0;L;;;;;N;;;;;
+145D9;ANATOLIAN HIEROGLYPH A420;Lo;0;L;;;;;N;;;;;
+145DA;ANATOLIAN HIEROGLYPH A421;Lo;0;L;;;;;N;;;;;
+145DB;ANATOLIAN HIEROGLYPH A422;Lo;0;L;;;;;N;;;;;
+145DC;ANATOLIAN HIEROGLYPH A423;Lo;0;L;;;;;N;;;;;
+145DD;ANATOLIAN HIEROGLYPH A424;Lo;0;L;;;;;N;;;;;
+145DE;ANATOLIAN HIEROGLYPH A425;Lo;0;L;;;;;N;;;;;
+145DF;ANATOLIAN HIEROGLYPH A426;Lo;0;L;;;;;N;;;;;
+145E0;ANATOLIAN HIEROGLYPH A427;Lo;0;L;;;;;N;;;;;
+145E1;ANATOLIAN HIEROGLYPH A428;Lo;0;L;;;;;N;;;;;
+145E2;ANATOLIAN HIEROGLYPH A429;Lo;0;L;;;;;N;;;;;
+145E3;ANATOLIAN HIEROGLYPH A430;Lo;0;L;;;;;N;;;;;
+145E4;ANATOLIAN HIEROGLYPH A431;Lo;0;L;;;;;N;;;;;
+145E5;ANATOLIAN HIEROGLYPH A432;Lo;0;L;;;;;N;;;;;
+145E6;ANATOLIAN HIEROGLYPH A433;Lo;0;L;;;;;N;;;;;
+145E7;ANATOLIAN HIEROGLYPH A434;Lo;0;L;;;;;N;;;;;
+145E8;ANATOLIAN HIEROGLYPH A435;Lo;0;L;;;;;N;;;;;
+145E9;ANATOLIAN HIEROGLYPH A436;Lo;0;L;;;;;N;;;;;
+145EA;ANATOLIAN HIEROGLYPH A437;Lo;0;L;;;;;N;;;;;
+145EB;ANATOLIAN HIEROGLYPH A438;Lo;0;L;;;;;N;;;;;
+145EC;ANATOLIAN HIEROGLYPH A439;Lo;0;L;;;;;N;;;;;
+145ED;ANATOLIAN HIEROGLYPH A440;Lo;0;L;;;;;N;;;;;
+145EE;ANATOLIAN HIEROGLYPH A441;Lo;0;L;;;;;N;;;;;
+145EF;ANATOLIAN HIEROGLYPH A442;Lo;0;L;;;;;N;;;;;
+145F0;ANATOLIAN HIEROGLYPH A443;Lo;0;L;;;;;N;;;;;
+145F1;ANATOLIAN HIEROGLYPH A444;Lo;0;L;;;;;N;;;;;
+145F2;ANATOLIAN HIEROGLYPH A445;Lo;0;L;;;;;N;;;;;
+145F3;ANATOLIAN HIEROGLYPH A446;Lo;0;L;;;;;N;;;;;
+145F4;ANATOLIAN HIEROGLYPH A447;Lo;0;L;;;;;N;;;;;
+145F5;ANATOLIAN HIEROGLYPH A448;Lo;0;L;;;;;N;;;;;
+145F6;ANATOLIAN HIEROGLYPH A449;Lo;0;L;;;;;N;;;;;
+145F7;ANATOLIAN HIEROGLYPH A450;Lo;0;L;;;;;N;;;;;
+145F8;ANATOLIAN HIEROGLYPH A450A;Lo;0;L;;;;;N;;;;;
+145F9;ANATOLIAN HIEROGLYPH A451;Lo;0;L;;;;;N;;;;;
+145FA;ANATOLIAN HIEROGLYPH A452;Lo;0;L;;;;;N;;;;;
+145FB;ANATOLIAN HIEROGLYPH A453;Lo;0;L;;;;;N;;;;;
+145FC;ANATOLIAN HIEROGLYPH A454;Lo;0;L;;;;;N;;;;;
+145FD;ANATOLIAN HIEROGLYPH A455;Lo;0;L;;;;;N;;;;;
+145FE;ANATOLIAN HIEROGLYPH A456;Lo;0;L;;;;;N;;;;;
+145FF;ANATOLIAN HIEROGLYPH A457;Lo;0;L;;;;;N;;;;;
+14600;ANATOLIAN HIEROGLYPH A457A;Lo;0;L;;;;;N;;;;;
+14601;ANATOLIAN HIEROGLYPH A458;Lo;0;L;;;;;N;;;;;
+14602;ANATOLIAN HIEROGLYPH A459;Lo;0;L;;;;;N;;;;;
+14603;ANATOLIAN HIEROGLYPH A460;Lo;0;L;;;;;N;;;;;
+14604;ANATOLIAN HIEROGLYPH A461;Lo;0;L;;;;;N;;;;;
+14605;ANATOLIAN HIEROGLYPH A462;Lo;0;L;;;;;N;;;;;
+14606;ANATOLIAN HIEROGLYPH A463;Lo;0;L;;;;;N;;;;;
+14607;ANATOLIAN HIEROGLYPH A464;Lo;0;L;;;;;N;;;;;
+14608;ANATOLIAN HIEROGLYPH A465;Lo;0;L;;;;;N;;;;;
+14609;ANATOLIAN HIEROGLYPH A466;Lo;0;L;;;;;N;;;;;
+1460A;ANATOLIAN HIEROGLYPH A467;Lo;0;L;;;;;N;;;;;
+1460B;ANATOLIAN HIEROGLYPH A468;Lo;0;L;;;;;N;;;;;
+1460C;ANATOLIAN HIEROGLYPH A469;Lo;0;L;;;;;N;;;;;
+1460D;ANATOLIAN HIEROGLYPH A470;Lo;0;L;;;;;N;;;;;
+1460E;ANATOLIAN HIEROGLYPH A471;Lo;0;L;;;;;N;;;;;
+1460F;ANATOLIAN HIEROGLYPH A472;Lo;0;L;;;;;N;;;;;
+14610;ANATOLIAN HIEROGLYPH A473;Lo;0;L;;;;;N;;;;;
+14611;ANATOLIAN HIEROGLYPH A474;Lo;0;L;;;;;N;;;;;
+14612;ANATOLIAN HIEROGLYPH A475;Lo;0;L;;;;;N;;;;;
+14613;ANATOLIAN HIEROGLYPH A476;Lo;0;L;;;;;N;;;;;
+14614;ANATOLIAN HIEROGLYPH A477;Lo;0;L;;;;;N;;;;;
+14615;ANATOLIAN HIEROGLYPH A478;Lo;0;L;;;;;N;;;;;
+14616;ANATOLIAN HIEROGLYPH A479;Lo;0;L;;;;;N;;;;;
+14617;ANATOLIAN HIEROGLYPH A480;Lo;0;L;;;;;N;;;;;
+14618;ANATOLIAN HIEROGLYPH A481;Lo;0;L;;;;;N;;;;;
+14619;ANATOLIAN HIEROGLYPH A482;Lo;0;L;;;;;N;;;;;
+1461A;ANATOLIAN HIEROGLYPH A483;Lo;0;L;;;;;N;;;;;
+1461B;ANATOLIAN HIEROGLYPH A484;Lo;0;L;;;;;N;;;;;
+1461C;ANATOLIAN HIEROGLYPH A485;Lo;0;L;;;;;N;;;;;
+1461D;ANATOLIAN HIEROGLYPH A486;Lo;0;L;;;;;N;;;;;
+1461E;ANATOLIAN HIEROGLYPH A487;Lo;0;L;;;;;N;;;;;
+1461F;ANATOLIAN HIEROGLYPH A488;Lo;0;L;;;;;N;;;;;
+14620;ANATOLIAN HIEROGLYPH A489;Lo;0;L;;;;;N;;;;;
+14621;ANATOLIAN HIEROGLYPH A490;Lo;0;L;;;;;N;;;;;
+14622;ANATOLIAN HIEROGLYPH A491;Lo;0;L;;;;;N;;;;;
+14623;ANATOLIAN HIEROGLYPH A492;Lo;0;L;;;;;N;;;;;
+14624;ANATOLIAN HIEROGLYPH A493;Lo;0;L;;;;;N;;;;;
+14625;ANATOLIAN HIEROGLYPH A494;Lo;0;L;;;;;N;;;;;
+14626;ANATOLIAN HIEROGLYPH A495;Lo;0;L;;;;;N;;;;;
+14627;ANATOLIAN HIEROGLYPH A496;Lo;0;L;;;;;N;;;;;
+14628;ANATOLIAN HIEROGLYPH A497;Lo;0;L;;;;;N;;;;;
+14629;ANATOLIAN HIEROGLYPH A501;Lo;0;L;;;;;N;;;;;
+1462A;ANATOLIAN HIEROGLYPH A502;Lo;0;L;;;;;N;;;;;
+1462B;ANATOLIAN HIEROGLYPH A503;Lo;0;L;;;;;N;;;;;
+1462C;ANATOLIAN HIEROGLYPH A504;Lo;0;L;;;;;N;;;;;
+1462D;ANATOLIAN HIEROGLYPH A505;Lo;0;L;;;;;N;;;;;
+1462E;ANATOLIAN HIEROGLYPH A506;Lo;0;L;;;;;N;;;;;
+1462F;ANATOLIAN HIEROGLYPH A507;Lo;0;L;;;;;N;;;;;
+14630;ANATOLIAN HIEROGLYPH A508;Lo;0;L;;;;;N;;;;;
+14631;ANATOLIAN HIEROGLYPH A509;Lo;0;L;;;;;N;;;;;
+14632;ANATOLIAN HIEROGLYPH A510;Lo;0;L;;;;;N;;;;;
+14633;ANATOLIAN HIEROGLYPH A511;Lo;0;L;;;;;N;;;;;
+14634;ANATOLIAN HIEROGLYPH A512;Lo;0;L;;;;;N;;;;;
+14635;ANATOLIAN HIEROGLYPH A513;Lo;0;L;;;;;N;;;;;
+14636;ANATOLIAN HIEROGLYPH A514;Lo;0;L;;;;;N;;;;;
+14637;ANATOLIAN HIEROGLYPH A515;Lo;0;L;;;;;N;;;;;
+14638;ANATOLIAN HIEROGLYPH A516;Lo;0;L;;;;;N;;;;;
+14639;ANATOLIAN HIEROGLYPH A517;Lo;0;L;;;;;N;;;;;
+1463A;ANATOLIAN HIEROGLYPH A518;Lo;0;L;;;;;N;;;;;
+1463B;ANATOLIAN HIEROGLYPH A519;Lo;0;L;;;;;N;;;;;
+1463C;ANATOLIAN HIEROGLYPH A520;Lo;0;L;;;;;N;;;;;
+1463D;ANATOLIAN HIEROGLYPH A521;Lo;0;L;;;;;N;;;;;
+1463E;ANATOLIAN HIEROGLYPH A522;Lo;0;L;;;;;N;;;;;
+1463F;ANATOLIAN HIEROGLYPH A523;Lo;0;L;;;;;N;;;;;
+14640;ANATOLIAN HIEROGLYPH A524;Lo;0;L;;;;;N;;;;;
+14641;ANATOLIAN HIEROGLYPH A525;Lo;0;L;;;;;N;;;;;
+14642;ANATOLIAN HIEROGLYPH A526;Lo;0;L;;;;;N;;;;;
+14643;ANATOLIAN HIEROGLYPH A527;Lo;0;L;;;;;N;;;;;
+14644;ANATOLIAN HIEROGLYPH A528;Lo;0;L;;;;;N;;;;;
+14645;ANATOLIAN HIEROGLYPH A529;Lo;0;L;;;;;N;;;;;
+14646;ANATOLIAN HIEROGLYPH A530;Lo;0;L;;;;;N;;;;;
+16100;GURUNG KHEMA LETTER A;Lo;0;L;;;;;N;;;;;
+16101;GURUNG KHEMA LETTER KA;Lo;0;L;;;;;N;;;;;
+16102;GURUNG KHEMA LETTER KHA;Lo;0;L;;;;;N;;;;;
+16103;GURUNG KHEMA LETTER GA;Lo;0;L;;;;;N;;;;;
+16104;GURUNG KHEMA LETTER GHA;Lo;0;L;;;;;N;;;;;
+16105;GURUNG KHEMA LETTER NGA;Lo;0;L;;;;;N;;;;;
+16106;GURUNG KHEMA LETTER CA;Lo;0;L;;;;;N;;;;;
+16107;GURUNG KHEMA LETTER CHA;Lo;0;L;;;;;N;;;;;
+16108;GURUNG KHEMA LETTER JA;Lo;0;L;;;;;N;;;;;
+16109;GURUNG KHEMA LETTER JHA;Lo;0;L;;;;;N;;;;;
+1610A;GURUNG KHEMA LETTER HA;Lo;0;L;;;;;N;;;;;
+1610B;GURUNG KHEMA LETTER TTA;Lo;0;L;;;;;N;;;;;
+1610C;GURUNG KHEMA LETTER TTHA;Lo;0;L;;;;;N;;;;;
+1610D;GURUNG KHEMA LETTER DDA;Lo;0;L;;;;;N;;;;;
+1610E;GURUNG KHEMA LETTER DDHA;Lo;0;L;;;;;N;;;;;
+1610F;GURUNG KHEMA LETTER VA;Lo;0;L;;;;;N;;;;;
+16110;GURUNG KHEMA LETTER TA;Lo;0;L;;;;;N;;;;;
+16111;GURUNG KHEMA LETTER THA;Lo;0;L;;;;;N;;;;;
+16112;GURUNG KHEMA LETTER DA;Lo;0;L;;;;;N;;;;;
+16113;GURUNG KHEMA LETTER DHA;Lo;0;L;;;;;N;;;;;
+16114;GURUNG KHEMA LETTER NA;Lo;0;L;;;;;N;;;;;
+16115;GURUNG KHEMA LETTER PA;Lo;0;L;;;;;N;;;;;
+16116;GURUNG KHEMA LETTER PHA;Lo;0;L;;;;;N;;;;;
+16117;GURUNG KHEMA LETTER BA;Lo;0;L;;;;;N;;;;;
+16118;GURUNG KHEMA LETTER BHA;Lo;0;L;;;;;N;;;;;
+16119;GURUNG KHEMA LETTER MA;Lo;0;L;;;;;N;;;;;
+1611A;GURUNG KHEMA LETTER YA;Lo;0;L;;;;;N;;;;;
+1611B;GURUNG KHEMA LETTER RA;Lo;0;L;;;;;N;;;;;
+1611C;GURUNG KHEMA LETTER LA;Lo;0;L;;;;;N;;;;;
+1611D;GURUNG KHEMA LETTER SA;Lo;0;L;;;;;N;;;;;
+1611E;GURUNG KHEMA VOWEL SIGN AA;Mn;0;NSM;;;;;N;;;;;
+1611F;GURUNG KHEMA VOWEL SIGN I;Mn;0;NSM;;;;;N;;;;;
+16120;GURUNG KHEMA VOWEL SIGN II;Mn;0;NSM;;;;;N;;;;;
+16121;GURUNG KHEMA VOWEL SIGN U;Mn;0;NSM;1611E 1611E;;;;N;;;;;
+16122;GURUNG KHEMA VOWEL SIGN UU;Mn;0;NSM;1611E 16129;;;;N;;;;;
+16123;GURUNG KHEMA VOWEL SIGN E;Mn;0;NSM;1611E 1611F;;;;N;;;;;
+16124;GURUNG KHEMA VOWEL SIGN EE;Mn;0;NSM;16129 1611F;;;;N;;;;;
+16125;GURUNG KHEMA VOWEL SIGN AI;Mn;0;NSM;1611E 16120;;;;N;;;;;
+16126;GURUNG KHEMA VOWEL SIGN O;Mn;0;NSM;16121 1611F;;;;N;;;;;
+16127;GURUNG KHEMA VOWEL SIGN OO;Mn;0;NSM;16122 1611F;;;;N;;;;;
+16128;GURUNG KHEMA VOWEL SIGN AU;Mn;0;NSM;16121 16120;;;;N;;;;;
+16129;GURUNG KHEMA VOWEL LENGTH MARK;Mn;0;NSM;;;;;N;;;;;
+1612A;GURUNG KHEMA CONSONANT SIGN MEDIAL YA;Mc;0;L;;;;;N;;;;;
+1612B;GURUNG KHEMA CONSONANT SIGN MEDIAL VA;Mc;0;L;;;;;N;;;;;
+1612C;GURUNG KHEMA CONSONANT SIGN MEDIAL HA;Mc;0;L;;;;;N;;;;;
+1612D;GURUNG KHEMA SIGN ANUSVARA;Mn;0;NSM;;;;;N;;;;;
+1612E;GURUNG KHEMA CONSONANT SIGN MEDIAL RA;Mn;0;NSM;;;;;N;;;;;
+1612F;GURUNG KHEMA SIGN THOLHOMA;Mn;9;NSM;;;;;N;;;;;
+16130;GURUNG KHEMA DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+16131;GURUNG KHEMA DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+16132;GURUNG KHEMA DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+16133;GURUNG KHEMA DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+16134;GURUNG KHEMA DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+16135;GURUNG KHEMA DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+16136;GURUNG KHEMA DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+16137;GURUNG KHEMA DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+16138;GURUNG KHEMA DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+16139;GURUNG KHEMA DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
 16800;BAMUM LETTER PHASE-A NGKUE MFON;Lo;0;L;;;;;N;;;;;
 16801;BAMUM LETTER PHASE-A GBIEE FON;Lo;0;L;;;;;N;;;;;
 16802;BAMUM LETTER PHASE-A PON MFON PIPAEMGBIEE;Lo;0;L;;;;;N;;;;;
@@ -22169,6 +29887,95 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 16A69;MRO DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
 16A6E;MRO DANDA;Po;0;L;;;;;N;;;;;
 16A6F;MRO DOUBLE DANDA;Po;0;L;;;;;N;;;;;
+16A70;TANGSA LETTER OZ;Lo;0;L;;;;;N;;;;;
+16A71;TANGSA LETTER OC;Lo;0;L;;;;;N;;;;;
+16A72;TANGSA LETTER OQ;Lo;0;L;;;;;N;;;;;
+16A73;TANGSA LETTER OX;Lo;0;L;;;;;N;;;;;
+16A74;TANGSA LETTER AZ;Lo;0;L;;;;;N;;;;;
+16A75;TANGSA LETTER AC;Lo;0;L;;;;;N;;;;;
+16A76;TANGSA LETTER AQ;Lo;0;L;;;;;N;;;;;
+16A77;TANGSA LETTER AX;Lo;0;L;;;;;N;;;;;
+16A78;TANGSA LETTER VZ;Lo;0;L;;;;;N;;;;;
+16A79;TANGSA LETTER VC;Lo;0;L;;;;;N;;;;;
+16A7A;TANGSA LETTER VQ;Lo;0;L;;;;;N;;;;;
+16A7B;TANGSA LETTER VX;Lo;0;L;;;;;N;;;;;
+16A7C;TANGSA LETTER EZ;Lo;0;L;;;;;N;;;;;
+16A7D;TANGSA LETTER EC;Lo;0;L;;;;;N;;;;;
+16A7E;TANGSA LETTER EQ;Lo;0;L;;;;;N;;;;;
+16A7F;TANGSA LETTER EX;Lo;0;L;;;;;N;;;;;
+16A80;TANGSA LETTER IZ;Lo;0;L;;;;;N;;;;;
+16A81;TANGSA LETTER IC;Lo;0;L;;;;;N;;;;;
+16A82;TANGSA LETTER IQ;Lo;0;L;;;;;N;;;;;
+16A83;TANGSA LETTER IX;Lo;0;L;;;;;N;;;;;
+16A84;TANGSA LETTER UZ;Lo;0;L;;;;;N;;;;;
+16A85;TANGSA LETTER UC;Lo;0;L;;;;;N;;;;;
+16A86;TANGSA LETTER UQ;Lo;0;L;;;;;N;;;;;
+16A87;TANGSA LETTER UX;Lo;0;L;;;;;N;;;;;
+16A88;TANGSA LETTER AWZ;Lo;0;L;;;;;N;;;;;
+16A89;TANGSA LETTER AWC;Lo;0;L;;;;;N;;;;;
+16A8A;TANGSA LETTER AWQ;Lo;0;L;;;;;N;;;;;
+16A8B;TANGSA LETTER AWX;Lo;0;L;;;;;N;;;;;
+16A8C;TANGSA LETTER UIZ;Lo;0;L;;;;;N;;;;;
+16A8D;TANGSA LETTER UIC;Lo;0;L;;;;;N;;;;;
+16A8E;TANGSA LETTER UIQ;Lo;0;L;;;;;N;;;;;
+16A8F;TANGSA LETTER UIX;Lo;0;L;;;;;N;;;;;
+16A90;TANGSA LETTER FINAL NG;Lo;0;L;;;;;N;;;;;
+16A91;TANGSA LETTER LONG UEX;Lo;0;L;;;;;N;;;;;
+16A92;TANGSA LETTER SHORT UEZ;Lo;0;L;;;;;N;;;;;
+16A93;TANGSA LETTER SHORT AWX;Lo;0;L;;;;;N;;;;;
+16A94;TANGSA LETTER UEC;Lo;0;L;;;;;N;;;;;
+16A95;TANGSA LETTER UEZ;Lo;0;L;;;;;N;;;;;
+16A96;TANGSA LETTER UEQ;Lo;0;L;;;;;N;;;;;
+16A97;TANGSA LETTER UEX;Lo;0;L;;;;;N;;;;;
+16A98;TANGSA LETTER UIUZ;Lo;0;L;;;;;N;;;;;
+16A99;TANGSA LETTER UIUC;Lo;0;L;;;;;N;;;;;
+16A9A;TANGSA LETTER UIUQ;Lo;0;L;;;;;N;;;;;
+16A9B;TANGSA LETTER UIUX;Lo;0;L;;;;;N;;;;;
+16A9C;TANGSA LETTER MZ;Lo;0;L;;;;;N;;;;;
+16A9D;TANGSA LETTER MC;Lo;0;L;;;;;N;;;;;
+16A9E;TANGSA LETTER MQ;Lo;0;L;;;;;N;;;;;
+16A9F;TANGSA LETTER MX;Lo;0;L;;;;;N;;;;;
+16AA0;TANGSA LETTER KA;Lo;0;L;;;;;N;;;;;
+16AA1;TANGSA LETTER KHA;Lo;0;L;;;;;N;;;;;
+16AA2;TANGSA LETTER GA;Lo;0;L;;;;;N;;;;;
+16AA3;TANGSA LETTER NGA;Lo;0;L;;;;;N;;;;;
+16AA4;TANGSA LETTER SA;Lo;0;L;;;;;N;;;;;
+16AA5;TANGSA LETTER YA;Lo;0;L;;;;;N;;;;;
+16AA6;TANGSA LETTER WA;Lo;0;L;;;;;N;;;;;
+16AA7;TANGSA LETTER PA;Lo;0;L;;;;;N;;;;;
+16AA8;TANGSA LETTER NYA;Lo;0;L;;;;;N;;;;;
+16AA9;TANGSA LETTER PHA;Lo;0;L;;;;;N;;;;;
+16AAA;TANGSA LETTER BA;Lo;0;L;;;;;N;;;;;
+16AAB;TANGSA LETTER MA;Lo;0;L;;;;;N;;;;;
+16AAC;TANGSA LETTER NA;Lo;0;L;;;;;N;;;;;
+16AAD;TANGSA LETTER HA;Lo;0;L;;;;;N;;;;;
+16AAE;TANGSA LETTER LA;Lo;0;L;;;;;N;;;;;
+16AAF;TANGSA LETTER HTA;Lo;0;L;;;;;N;;;;;
+16AB0;TANGSA LETTER TA;Lo;0;L;;;;;N;;;;;
+16AB1;TANGSA LETTER DA;Lo;0;L;;;;;N;;;;;
+16AB2;TANGSA LETTER RA;Lo;0;L;;;;;N;;;;;
+16AB3;TANGSA LETTER NHA;Lo;0;L;;;;;N;;;;;
+16AB4;TANGSA LETTER SHA;Lo;0;L;;;;;N;;;;;
+16AB5;TANGSA LETTER CA;Lo;0;L;;;;;N;;;;;
+16AB6;TANGSA LETTER TSA;Lo;0;L;;;;;N;;;;;
+16AB7;TANGSA LETTER GHA;Lo;0;L;;;;;N;;;;;
+16AB8;TANGSA LETTER HTTA;Lo;0;L;;;;;N;;;;;
+16AB9;TANGSA LETTER THA;Lo;0;L;;;;;N;;;;;
+16ABA;TANGSA LETTER XA;Lo;0;L;;;;;N;;;;;
+16ABB;TANGSA LETTER FA;Lo;0;L;;;;;N;;;;;
+16ABC;TANGSA LETTER DHA;Lo;0;L;;;;;N;;;;;
+16ABD;TANGSA LETTER CHA;Lo;0;L;;;;;N;;;;;
+16ABE;TANGSA LETTER ZA;Lo;0;L;;;;;N;;;;;
+16AC0;TANGSA DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+16AC1;TANGSA DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+16AC2;TANGSA DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+16AC3;TANGSA DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+16AC4;TANGSA DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+16AC5;TANGSA DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+16AC6;TANGSA DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+16AC7;TANGSA DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+16AC8;TANGSA DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+16AC9;TANGSA DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
 16AD0;BASSA VAH LETTER ENNI;Lo;0;L;;;;;N;;;;;
 16AD1;BASSA VAH LETTER KA;Lo;0;L;;;;;N;;;;;
 16AD2;BASSA VAH LETTER SE;Lo;0;L;;;;;N;;;;;
@@ -22332,6 +30139,205 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 16B8D;PAHAWH HMONG CLAN SIGN TSWB;Lo;0;L;;;;;N;;;;;
 16B8E;PAHAWH HMONG CLAN SIGN KWM;Lo;0;L;;;;;N;;;;;
 16B8F;PAHAWH HMONG CLAN SIGN VWJ;Lo;0;L;;;;;N;;;;;
+16D40;KIRAT RAI SIGN ANUSVARA;Lm;0;L;;;;;N;;;;;
+16D41;KIRAT RAI SIGN TONPI;Lm;0;L;;;;;N;;;;;
+16D42;KIRAT RAI SIGN VISARGA;Lm;0;L;;;;;N;;;;;
+16D43;KIRAT RAI LETTER A;Lo;0;L;;;;;N;;;;;
+16D44;KIRAT RAI LETTER KA;Lo;0;L;;;;;N;;;;;
+16D45;KIRAT RAI LETTER KHA;Lo;0;L;;;;;N;;;;;
+16D46;KIRAT RAI LETTER GA;Lo;0;L;;;;;N;;;;;
+16D47;KIRAT RAI LETTER GHA;Lo;0;L;;;;;N;;;;;
+16D48;KIRAT RAI LETTER NGA;Lo;0;L;;;;;N;;;;;
+16D49;KIRAT RAI LETTER CA;Lo;0;L;;;;;N;;;;;
+16D4A;KIRAT RAI LETTER CHA;Lo;0;L;;;;;N;;;;;
+16D4B;KIRAT RAI LETTER JA;Lo;0;L;;;;;N;;;;;
+16D4C;KIRAT RAI LETTER JHA;Lo;0;L;;;;;N;;;;;
+16D4D;KIRAT RAI LETTER NYA;Lo;0;L;;;;;N;;;;;
+16D4E;KIRAT RAI LETTER TTA;Lo;0;L;;;;;N;;;;;
+16D4F;KIRAT RAI LETTER TTHA;Lo;0;L;;;;;N;;;;;
+16D50;KIRAT RAI LETTER DDA;Lo;0;L;;;;;N;;;;;
+16D51;KIRAT RAI LETTER DDHA;Lo;0;L;;;;;N;;;;;
+16D52;KIRAT RAI LETTER TA;Lo;0;L;;;;;N;;;;;
+16D53;KIRAT RAI LETTER THA;Lo;0;L;;;;;N;;;;;
+16D54;KIRAT RAI LETTER DA;Lo;0;L;;;;;N;;;;;
+16D55;KIRAT RAI LETTER DHA;Lo;0;L;;;;;N;;;;;
+16D56;KIRAT RAI LETTER NA;Lo;0;L;;;;;N;;;;;
+16D57;KIRAT RAI LETTER PA;Lo;0;L;;;;;N;;;;;
+16D58;KIRAT RAI LETTER PHA;Lo;0;L;;;;;N;;;;;
+16D59;KIRAT RAI LETTER BA;Lo;0;L;;;;;N;;;;;
+16D5A;KIRAT RAI LETTER BHA;Lo;0;L;;;;;N;;;;;
+16D5B;KIRAT RAI LETTER MA;Lo;0;L;;;;;N;;;;;
+16D5C;KIRAT RAI LETTER YA;Lo;0;L;;;;;N;;;;;
+16D5D;KIRAT RAI LETTER RA;Lo;0;L;;;;;N;;;;;
+16D5E;KIRAT RAI LETTER LA;Lo;0;L;;;;;N;;;;;
+16D5F;KIRAT RAI LETTER VA;Lo;0;L;;;;;N;;;;;
+16D60;KIRAT RAI LETTER SA;Lo;0;L;;;;;N;;;;;
+16D61;KIRAT RAI LETTER SHA;Lo;0;L;;;;;N;;;;;
+16D62;KIRAT RAI LETTER HA;Lo;0;L;;;;;N;;;;;
+16D63;KIRAT RAI VOWEL SIGN AA;Lo;0;L;;;;;N;;;;;
+16D64;KIRAT RAI VOWEL SIGN I;Lo;0;L;;;;;N;;;;;
+16D65;KIRAT RAI VOWEL SIGN U;Lo;0;L;;;;;N;;;;;
+16D66;KIRAT RAI VOWEL SIGN UE;Lo;0;L;;;;;N;;;;;
+16D67;KIRAT RAI VOWEL SIGN E;Lo;0;L;;;;;N;;;;;
+16D68;KIRAT RAI VOWEL SIGN AI;Lo;0;L;16D67 16D67;;;;N;;;;;
+16D69;KIRAT RAI VOWEL SIGN O;Lo;0;L;16D63 16D67;;;;N;;;;;
+16D6A;KIRAT RAI VOWEL SIGN AU;Lo;0;L;16D69 16D67;;;;N;;;;;
+16D6B;KIRAT RAI SIGN VIRAMA;Lm;0;L;;;;;N;;;;;
+16D6C;KIRAT RAI SIGN SAAT;Lm;0;L;;;;;N;;;;;
+16D6D;KIRAT RAI SIGN YUPI;Po;0;L;;;;;N;;;;;
+16D6E;KIRAT RAI DANDA;Po;0;L;;;;;N;;;;;
+16D6F;KIRAT RAI DOUBLE DANDA;Po;0;L;;;;;N;;;;;
+16D70;KIRAT RAI DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+16D71;KIRAT RAI DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+16D72;KIRAT RAI DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+16D73;KIRAT RAI DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+16D74;KIRAT RAI DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+16D75;KIRAT RAI DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+16D76;KIRAT RAI DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+16D77;KIRAT RAI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+16D78;KIRAT RAI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+16D79;KIRAT RAI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+16E40;MEDEFAIDRIN CAPITAL LETTER M;Lu;0;L;;;;;N;;;;16E60;
+16E41;MEDEFAIDRIN CAPITAL LETTER S;Lu;0;L;;;;;N;;;;16E61;
+16E42;MEDEFAIDRIN CAPITAL LETTER V;Lu;0;L;;;;;N;;;;16E62;
+16E43;MEDEFAIDRIN CAPITAL LETTER W;Lu;0;L;;;;;N;;;;16E63;
+16E44;MEDEFAIDRIN CAPITAL LETTER ATIU;Lu;0;L;;;;;N;;;;16E64;
+16E45;MEDEFAIDRIN CAPITAL LETTER Z;Lu;0;L;;;;;N;;;;16E65;
+16E46;MEDEFAIDRIN CAPITAL LETTER KP;Lu;0;L;;;;;N;;;;16E66;
+16E47;MEDEFAIDRIN CAPITAL LETTER P;Lu;0;L;;;;;N;;;;16E67;
+16E48;MEDEFAIDRIN CAPITAL LETTER T;Lu;0;L;;;;;N;;;;16E68;
+16E49;MEDEFAIDRIN CAPITAL LETTER G;Lu;0;L;;;;;N;;;;16E69;
+16E4A;MEDEFAIDRIN CAPITAL LETTER F;Lu;0;L;;;;;N;;;;16E6A;
+16E4B;MEDEFAIDRIN CAPITAL LETTER I;Lu;0;L;;;;;N;;;;16E6B;
+16E4C;MEDEFAIDRIN CAPITAL LETTER K;Lu;0;L;;;;;N;;;;16E6C;
+16E4D;MEDEFAIDRIN CAPITAL LETTER A;Lu;0;L;;;;;N;;;;16E6D;
+16E4E;MEDEFAIDRIN CAPITAL LETTER J;Lu;0;L;;;;;N;;;;16E6E;
+16E4F;MEDEFAIDRIN CAPITAL LETTER E;Lu;0;L;;;;;N;;;;16E6F;
+16E50;MEDEFAIDRIN CAPITAL LETTER B;Lu;0;L;;;;;N;;;;16E70;
+16E51;MEDEFAIDRIN CAPITAL LETTER C;Lu;0;L;;;;;N;;;;16E71;
+16E52;MEDEFAIDRIN CAPITAL LETTER U;Lu;0;L;;;;;N;;;;16E72;
+16E53;MEDEFAIDRIN CAPITAL LETTER YU;Lu;0;L;;;;;N;;;;16E73;
+16E54;MEDEFAIDRIN CAPITAL LETTER L;Lu;0;L;;;;;N;;;;16E74;
+16E55;MEDEFAIDRIN CAPITAL LETTER Q;Lu;0;L;;;;;N;;;;16E75;
+16E56;MEDEFAIDRIN CAPITAL LETTER HP;Lu;0;L;;;;;N;;;;16E76;
+16E57;MEDEFAIDRIN CAPITAL LETTER NY;Lu;0;L;;;;;N;;;;16E77;
+16E58;MEDEFAIDRIN CAPITAL LETTER X;Lu;0;L;;;;;N;;;;16E78;
+16E59;MEDEFAIDRIN CAPITAL LETTER D;Lu;0;L;;;;;N;;;;16E79;
+16E5A;MEDEFAIDRIN CAPITAL LETTER OE;Lu;0;L;;;;;N;;;;16E7A;
+16E5B;MEDEFAIDRIN CAPITAL LETTER N;Lu;0;L;;;;;N;;;;16E7B;
+16E5C;MEDEFAIDRIN CAPITAL LETTER R;Lu;0;L;;;;;N;;;;16E7C;
+16E5D;MEDEFAIDRIN CAPITAL LETTER O;Lu;0;L;;;;;N;;;;16E7D;
+16E5E;MEDEFAIDRIN CAPITAL LETTER AI;Lu;0;L;;;;;N;;;;16E7E;
+16E5F;MEDEFAIDRIN CAPITAL LETTER Y;Lu;0;L;;;;;N;;;;16E7F;
+16E60;MEDEFAIDRIN SMALL LETTER M;Ll;0;L;;;;;N;;;16E40;;16E40
+16E61;MEDEFAIDRIN SMALL LETTER S;Ll;0;L;;;;;N;;;16E41;;16E41
+16E62;MEDEFAIDRIN SMALL LETTER V;Ll;0;L;;;;;N;;;16E42;;16E42
+16E63;MEDEFAIDRIN SMALL LETTER W;Ll;0;L;;;;;N;;;16E43;;16E43
+16E64;MEDEFAIDRIN SMALL LETTER ATIU;Ll;0;L;;;;;N;;;16E44;;16E44
+16E65;MEDEFAIDRIN SMALL LETTER Z;Ll;0;L;;;;;N;;;16E45;;16E45
+16E66;MEDEFAIDRIN SMALL LETTER KP;Ll;0;L;;;;;N;;;16E46;;16E46
+16E67;MEDEFAIDRIN SMALL LETTER P;Ll;0;L;;;;;N;;;16E47;;16E47
+16E68;MEDEFAIDRIN SMALL LETTER T;Ll;0;L;;;;;N;;;16E48;;16E48
+16E69;MEDEFAIDRIN SMALL LETTER G;Ll;0;L;;;;;N;;;16E49;;16E49
+16E6A;MEDEFAIDRIN SMALL LETTER F;Ll;0;L;;;;;N;;;16E4A;;16E4A
+16E6B;MEDEFAIDRIN SMALL LETTER I;Ll;0;L;;;;;N;;;16E4B;;16E4B
+16E6C;MEDEFAIDRIN SMALL LETTER K;Ll;0;L;;;;;N;;;16E4C;;16E4C
+16E6D;MEDEFAIDRIN SMALL LETTER A;Ll;0;L;;;;;N;;;16E4D;;16E4D
+16E6E;MEDEFAIDRIN SMALL LETTER J;Ll;0;L;;;;;N;;;16E4E;;16E4E
+16E6F;MEDEFAIDRIN SMALL LETTER E;Ll;0;L;;;;;N;;;16E4F;;16E4F
+16E70;MEDEFAIDRIN SMALL LETTER B;Ll;0;L;;;;;N;;;16E50;;16E50
+16E71;MEDEFAIDRIN SMALL LETTER C;Ll;0;L;;;;;N;;;16E51;;16E51
+16E72;MEDEFAIDRIN SMALL LETTER U;Ll;0;L;;;;;N;;;16E52;;16E52
+16E73;MEDEFAIDRIN SMALL LETTER YU;Ll;0;L;;;;;N;;;16E53;;16E53
+16E74;MEDEFAIDRIN SMALL LETTER L;Ll;0;L;;;;;N;;;16E54;;16E54
+16E75;MEDEFAIDRIN SMALL LETTER Q;Ll;0;L;;;;;N;;;16E55;;16E55
+16E76;MEDEFAIDRIN SMALL LETTER HP;Ll;0;L;;;;;N;;;16E56;;16E56
+16E77;MEDEFAIDRIN SMALL LETTER NY;Ll;0;L;;;;;N;;;16E57;;16E57
+16E78;MEDEFAIDRIN SMALL LETTER X;Ll;0;L;;;;;N;;;16E58;;16E58
+16E79;MEDEFAIDRIN SMALL LETTER D;Ll;0;L;;;;;N;;;16E59;;16E59
+16E7A;MEDEFAIDRIN SMALL LETTER OE;Ll;0;L;;;;;N;;;16E5A;;16E5A
+16E7B;MEDEFAIDRIN SMALL LETTER N;Ll;0;L;;;;;N;;;16E5B;;16E5B
+16E7C;MEDEFAIDRIN SMALL LETTER R;Ll;0;L;;;;;N;;;16E5C;;16E5C
+16E7D;MEDEFAIDRIN SMALL LETTER O;Ll;0;L;;;;;N;;;16E5D;;16E5D
+16E7E;MEDEFAIDRIN SMALL LETTER AI;Ll;0;L;;;;;N;;;16E5E;;16E5E
+16E7F;MEDEFAIDRIN SMALL LETTER Y;Ll;0;L;;;;;N;;;16E5F;;16E5F
+16E80;MEDEFAIDRIN DIGIT ZERO;No;0;L;;;;0;N;;;;;
+16E81;MEDEFAIDRIN DIGIT ONE;No;0;L;;;;1;N;;;;;
+16E82;MEDEFAIDRIN DIGIT TWO;No;0;L;;;;2;N;;;;;
+16E83;MEDEFAIDRIN DIGIT THREE;No;0;L;;;;3;N;;;;;
+16E84;MEDEFAIDRIN DIGIT FOUR;No;0;L;;;;4;N;;;;;
+16E85;MEDEFAIDRIN DIGIT FIVE;No;0;L;;;;5;N;;;;;
+16E86;MEDEFAIDRIN DIGIT SIX;No;0;L;;;;6;N;;;;;
+16E87;MEDEFAIDRIN DIGIT SEVEN;No;0;L;;;;7;N;;;;;
+16E88;MEDEFAIDRIN DIGIT EIGHT;No;0;L;;;;8;N;;;;;
+16E89;MEDEFAIDRIN DIGIT NINE;No;0;L;;;;9;N;;;;;
+16E8A;MEDEFAIDRIN NUMBER TEN;No;0;L;;;;10;N;;;;;
+16E8B;MEDEFAIDRIN NUMBER ELEVEN;No;0;L;;;;11;N;;;;;
+16E8C;MEDEFAIDRIN NUMBER TWELVE;No;0;L;;;;12;N;;;;;
+16E8D;MEDEFAIDRIN NUMBER THIRTEEN;No;0;L;;;;13;N;;;;;
+16E8E;MEDEFAIDRIN NUMBER FOURTEEN;No;0;L;;;;14;N;;;;;
+16E8F;MEDEFAIDRIN NUMBER FIFTEEN;No;0;L;;;;15;N;;;;;
+16E90;MEDEFAIDRIN NUMBER SIXTEEN;No;0;L;;;;16;N;;;;;
+16E91;MEDEFAIDRIN NUMBER SEVENTEEN;No;0;L;;;;17;N;;;;;
+16E92;MEDEFAIDRIN NUMBER EIGHTEEN;No;0;L;;;;18;N;;;;;
+16E93;MEDEFAIDRIN NUMBER NINETEEN;No;0;L;;;;19;N;;;;;
+16E94;MEDEFAIDRIN DIGIT ONE ALTERNATE FORM;No;0;L;;;;1;N;;;;;
+16E95;MEDEFAIDRIN DIGIT TWO ALTERNATE FORM;No;0;L;;;;2;N;;;;;
+16E96;MEDEFAIDRIN DIGIT THREE ALTERNATE FORM;No;0;L;;;;3;N;;;;;
+16E97;MEDEFAIDRIN COMMA;Po;0;L;;;;;N;;;;;
+16E98;MEDEFAIDRIN FULL STOP;Po;0;L;;;;;N;;;;;
+16E99;MEDEFAIDRIN SYMBOL AIVA;Po;0;L;;;;;N;;;;;
+16E9A;MEDEFAIDRIN EXCLAMATION OH;Po;0;L;;;;;N;;;;;
+16EA0;BERIA ERFE CAPITAL LETTER ARKAB;Lu;0;L;;;;;N;;;;16EBB;
+16EA1;BERIA ERFE CAPITAL LETTER BASIGNA;Lu;0;L;;;;;N;;;;16EBC;
+16EA2;BERIA ERFE CAPITAL LETTER DARBAI;Lu;0;L;;;;;N;;;;16EBD;
+16EA3;BERIA ERFE CAPITAL LETTER EH;Lu;0;L;;;;;N;;;;16EBE;
+16EA4;BERIA ERFE CAPITAL LETTER FITKO;Lu;0;L;;;;;N;;;;16EBF;
+16EA5;BERIA ERFE CAPITAL LETTER GOWAY;Lu;0;L;;;;;N;;;;16EC0;
+16EA6;BERIA ERFE CAPITAL LETTER HIRDEABO;Lu;0;L;;;;;N;;;;16EC1;
+16EA7;BERIA ERFE CAPITAL LETTER I;Lu;0;L;;;;;N;;;;16EC2;
+16EA8;BERIA ERFE CAPITAL LETTER DJAI;Lu;0;L;;;;;N;;;;16EC3;
+16EA9;BERIA ERFE CAPITAL LETTER KOBO;Lu;0;L;;;;;N;;;;16EC4;
+16EAA;BERIA ERFE CAPITAL LETTER LAKKO;Lu;0;L;;;;;N;;;;16EC5;
+16EAB;BERIA ERFE CAPITAL LETTER MERI;Lu;0;L;;;;;N;;;;16EC6;
+16EAC;BERIA ERFE CAPITAL LETTER NINI;Lu;0;L;;;;;N;;;;16EC7;
+16EAD;BERIA ERFE CAPITAL LETTER GNA;Lu;0;L;;;;;N;;;;16EC8;
+16EAE;BERIA ERFE CAPITAL LETTER NGAY;Lu;0;L;;;;;N;;;;16EC9;
+16EAF;BERIA ERFE CAPITAL LETTER OI;Lu;0;L;;;;;N;;;;16ECA;
+16EB0;BERIA ERFE CAPITAL LETTER PI;Lu;0;L;;;;;N;;;;16ECB;
+16EB1;BERIA ERFE CAPITAL LETTER ERIGO;Lu;0;L;;;;;N;;;;16ECC;
+16EB2;BERIA ERFE CAPITAL LETTER ERIGO TAMURA;Lu;0;L;;;;;N;;;;16ECD;
+16EB3;BERIA ERFE CAPITAL LETTER SERI;Lu;0;L;;;;;N;;;;16ECE;
+16EB4;BERIA ERFE CAPITAL LETTER SHEP;Lu;0;L;;;;;N;;;;16ECF;
+16EB5;BERIA ERFE CAPITAL LETTER TATASOUE;Lu;0;L;;;;;N;;;;16ED0;
+16EB6;BERIA ERFE CAPITAL LETTER UI;Lu;0;L;;;;;N;;;;16ED1;
+16EB7;BERIA ERFE CAPITAL LETTER WASSE;Lu;0;L;;;;;N;;;;16ED2;
+16EB8;BERIA ERFE CAPITAL LETTER AY;Lu;0;L;;;;;N;;;;16ED3;
+16EBB;BERIA ERFE SMALL LETTER ARKAB;Ll;0;L;;;;;N;;;16EA0;;16EA0
+16EBC;BERIA ERFE SMALL LETTER BASIGNA;Ll;0;L;;;;;N;;;16EA1;;16EA1
+16EBD;BERIA ERFE SMALL LETTER DARBAI;Ll;0;L;;;;;N;;;16EA2;;16EA2
+16EBE;BERIA ERFE SMALL LETTER EH;Ll;0;L;;;;;N;;;16EA3;;16EA3
+16EBF;BERIA ERFE SMALL LETTER FITKO;Ll;0;L;;;;;N;;;16EA4;;16EA4
+16EC0;BERIA ERFE SMALL LETTER GOWAY;Ll;0;L;;;;;N;;;16EA5;;16EA5
+16EC1;BERIA ERFE SMALL LETTER HIRDEABO;Ll;0;L;;;;;N;;;16EA6;;16EA6
+16EC2;BERIA ERFE SMALL LETTER I;Ll;0;L;;;;;N;;;16EA7;;16EA7
+16EC3;BERIA ERFE SMALL LETTER DJAI;Ll;0;L;;;;;N;;;16EA8;;16EA8
+16EC4;BERIA ERFE SMALL LETTER KOBO;Ll;0;L;;;;;N;;;16EA9;;16EA9
+16EC5;BERIA ERFE SMALL LETTER LAKKO;Ll;0;L;;;;;N;;;16EAA;;16EAA
+16EC6;BERIA ERFE SMALL LETTER MERI;Ll;0;L;;;;;N;;;16EAB;;16EAB
+16EC7;BERIA ERFE SMALL LETTER NINI;Ll;0;L;;;;;N;;;16EAC;;16EAC
+16EC8;BERIA ERFE SMALL LETTER GNA;Ll;0;L;;;;;N;;;16EAD;;16EAD
+16EC9;BERIA ERFE SMALL LETTER NGAY;Ll;0;L;;;;;N;;;16EAE;;16EAE
+16ECA;BERIA ERFE SMALL LETTER OI;Ll;0;L;;;;;N;;;16EAF;;16EAF
+16ECB;BERIA ERFE SMALL LETTER PI;Ll;0;L;;;;;N;;;16EB0;;16EB0
+16ECC;BERIA ERFE SMALL LETTER ERIGO;Ll;0;L;;;;;N;;;16EB1;;16EB1
+16ECD;BERIA ERFE SMALL LETTER ERIGO TAMURA;Ll;0;L;;;;;N;;;16EB2;;16EB2
+16ECE;BERIA ERFE SMALL LETTER SERI;Ll;0;L;;;;;N;;;16EB3;;16EB3
+16ECF;BERIA ERFE SMALL LETTER SHEP;Ll;0;L;;;;;N;;;16EB4;;16EB4
+16ED0;BERIA ERFE SMALL LETTER TATASOUE;Ll;0;L;;;;;N;;;16EB5;;16EB5
+16ED1;BERIA ERFE SMALL LETTER UI;Ll;0;L;;;;;N;;;16EB6;;16EB6
+16ED2;BERIA ERFE SMALL LETTER WASSE;Ll;0;L;;;;;N;;;16EB7;;16EB7
+16ED3;BERIA ERFE SMALL LETTER AY;Ll;0;L;;;;;N;;;16EB8;;16EB8
 16F00;MIAO LETTER PA;Lo;0;L;;;;;N;;;;;
 16F01;MIAO LETTER BA;Lo;0;L;;;;;N;;;;;
 16F02;MIAO LETTER YI PA;Lo;0;L;;;;;N;;;;;
@@ -22401,6 +30407,13 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 16F42;MIAO LETTER WA;Lo;0;L;;;;;N;;;;;
 16F43;MIAO LETTER AH;Lo;0;L;;;;;N;;;;;
 16F44;MIAO LETTER HHA;Lo;0;L;;;;;N;;;;;
+16F45;MIAO LETTER BRI;Lo;0;L;;;;;N;;;;;
+16F46;MIAO LETTER SYI;Lo;0;L;;;;;N;;;;;
+16F47;MIAO LETTER DZYI;Lo;0;L;;;;;N;;;;;
+16F48;MIAO LETTER TE;Lo;0;L;;;;;N;;;;;
+16F49;MIAO LETTER TSE;Lo;0;L;;;;;N;;;;;
+16F4A;MIAO LETTER RTE;Lo;0;L;;;;;N;;;;;
+16F4F;MIAO SIGN CONSONANT MODIFIER BAR;Mn;0;NSM;;;;;N;;;;;
 16F50;MIAO LETTER NASALIZATION;Lo;0;L;;;;;N;;;;;
 16F51;MIAO SIGN ASPIRATION;Mc;0;L;;;;;N;;;;;
 16F52;MIAO SIGN REFORMED VOICING;Mc;0;L;;;;;N;;;;;
@@ -22448,6 +30461,15 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 16F7C;MIAO VOWEL SIGN OU;Mc;0;L;;;;;N;;;;;
 16F7D;MIAO VOWEL SIGN N;Mc;0;L;;;;;N;;;;;
 16F7E;MIAO VOWEL SIGN NG;Mc;0;L;;;;;N;;;;;
+16F7F;MIAO VOWEL SIGN UOG;Mc;0;L;;;;;N;;;;;
+16F80;MIAO VOWEL SIGN YUI;Mc;0;L;;;;;N;;;;;
+16F81;MIAO VOWEL SIGN OG;Mc;0;L;;;;;N;;;;;
+16F82;MIAO VOWEL SIGN OER;Mc;0;L;;;;;N;;;;;
+16F83;MIAO VOWEL SIGN VW;Mc;0;L;;;;;N;;;;;
+16F84;MIAO VOWEL SIGN IG;Mc;0;L;;;;;N;;;;;
+16F85;MIAO VOWEL SIGN EA;Mc;0;L;;;;;N;;;;;
+16F86;MIAO VOWEL SIGN IONG;Mc;0;L;;;;;N;;;;;
+16F87;MIAO VOWEL SIGN UI;Mc;0;L;;;;;N;;;;;
 16F8F;MIAO TONE RIGHT;Mn;0;NSM;;;;;N;;;;;
 16F90;MIAO TONE TOP RIGHT;Mn;0;NSM;;;;;N;;;;;
 16F91;MIAO TONE ABOVE;Mn;0;NSM;;;;;N;;;;;
@@ -22465,8 +30487,2085 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 16F9D;MIAO LETTER REFORMED TONE-5;Lm;0;L;;;;;N;;;;;
 16F9E;MIAO LETTER REFORMED TONE-6;Lm;0;L;;;;;N;;;;;
 16F9F;MIAO LETTER REFORMED TONE-8;Lm;0;L;;;;;N;;;;;
+16FE0;TANGUT ITERATION MARK;Lm;0;L;;;;;N;;;;;
+16FE1;NUSHU ITERATION MARK;Lm;0;L;;;;;N;;;;;
+16FE2;OLD CHINESE HOOK MARK;Po;0;ON;;;;;N;;;;;
+16FE3;OLD CHINESE ITERATION MARK;Lm;0;L;;;;;N;;;;;
+16FE4;KHITAN SMALL SCRIPT FILLER;Mn;0;NSM;;;;;N;;;;;
+16FF0;VIETNAMESE ALTERNATE READING MARK CA;Mc;6;L;;;;;N;;;;;
+16FF1;VIETNAMESE ALTERNATE READING MARK NHAY;Mc;6;L;;;;;N;;;;;
+16FF2;CHINESE SMALL SIMPLIFIED ER;Lm;0;L;;;;;N;;;;;
+16FF3;CHINESE SMALL TRADITIONAL ER;Lm;0;L;;;;;N;;;;;
+16FF4;YANGQIN SIGN SLOW ONE BEAT;Nl;0;L;;;;1;N;;;;;
+16FF5;YANGQIN SIGN SLOW THREE HALF BEATS;Nl;0;L;;;;3/2;N;;;;;
+16FF6;YANGQIN SIGN SLOW TWO BEATS;Nl;0;L;;;;2;N;;;;;
+17000;<Tangut Ideograph, First>;Lo;0;L;;;;;N;;;;;
+187FF;<Tangut Ideograph, Last>;Lo;0;L;;;;;N;;;;;
+18800;TANGUT COMPONENT-001;Lo;0;L;;;;;N;;;;;
+18801;TANGUT COMPONENT-002;Lo;0;L;;;;;N;;;;;
+18802;TANGUT COMPONENT-003;Lo;0;L;;;;;N;;;;;
+18803;TANGUT COMPONENT-004;Lo;0;L;;;;;N;;;;;
+18804;TANGUT COMPONENT-005;Lo;0;L;;;;;N;;;;;
+18805;TANGUT COMPONENT-006;Lo;0;L;;;;;N;;;;;
+18806;TANGUT COMPONENT-007;Lo;0;L;;;;;N;;;;;
+18807;TANGUT COMPONENT-008;Lo;0;L;;;;;N;;;;;
+18808;TANGUT COMPONENT-009;Lo;0;L;;;;;N;;;;;
+18809;TANGUT COMPONENT-010;Lo;0;L;;;;;N;;;;;
+1880A;TANGUT COMPONENT-011;Lo;0;L;;;;;N;;;;;
+1880B;TANGUT COMPONENT-012;Lo;0;L;;;;;N;;;;;
+1880C;TANGUT COMPONENT-013;Lo;0;L;;;;;N;;;;;
+1880D;TANGUT COMPONENT-014;Lo;0;L;;;;;N;;;;;
+1880E;TANGUT COMPONENT-015;Lo;0;L;;;;;N;;;;;
+1880F;TANGUT COMPONENT-016;Lo;0;L;;;;;N;;;;;
+18810;TANGUT COMPONENT-017;Lo;0;L;;;;;N;;;;;
+18811;TANGUT COMPONENT-018;Lo;0;L;;;;;N;;;;;
+18812;TANGUT COMPONENT-019;Lo;0;L;;;;;N;;;;;
+18813;TANGUT COMPONENT-020;Lo;0;L;;;;;N;;;;;
+18814;TANGUT COMPONENT-021;Lo;0;L;;;;;N;;;;;
+18815;TANGUT COMPONENT-022;Lo;0;L;;;;;N;;;;;
+18816;TANGUT COMPONENT-023;Lo;0;L;;;;;N;;;;;
+18817;TANGUT COMPONENT-024;Lo;0;L;;;;;N;;;;;
+18818;TANGUT COMPONENT-025;Lo;0;L;;;;;N;;;;;
+18819;TANGUT COMPONENT-026;Lo;0;L;;;;;N;;;;;
+1881A;TANGUT COMPONENT-027;Lo;0;L;;;;;N;;;;;
+1881B;TANGUT COMPONENT-028;Lo;0;L;;;;;N;;;;;
+1881C;TANGUT COMPONENT-029;Lo;0;L;;;;;N;;;;;
+1881D;TANGUT COMPONENT-030;Lo;0;L;;;;;N;;;;;
+1881E;TANGUT COMPONENT-031;Lo;0;L;;;;;N;;;;;
+1881F;TANGUT COMPONENT-032;Lo;0;L;;;;;N;;;;;
+18820;TANGUT COMPONENT-033;Lo;0;L;;;;;N;;;;;
+18821;TANGUT COMPONENT-034;Lo;0;L;;;;;N;;;;;
+18822;TANGUT COMPONENT-035;Lo;0;L;;;;;N;;;;;
+18823;TANGUT COMPONENT-036;Lo;0;L;;;;;N;;;;;
+18824;TANGUT COMPONENT-037;Lo;0;L;;;;;N;;;;;
+18825;TANGUT COMPONENT-038;Lo;0;L;;;;;N;;;;;
+18826;TANGUT COMPONENT-039;Lo;0;L;;;;;N;;;;;
+18827;TANGUT COMPONENT-040;Lo;0;L;;;;;N;;;;;
+18828;TANGUT COMPONENT-041;Lo;0;L;;;;;N;;;;;
+18829;TANGUT COMPONENT-042;Lo;0;L;;;;;N;;;;;
+1882A;TANGUT COMPONENT-043;Lo;0;L;;;;;N;;;;;
+1882B;TANGUT COMPONENT-044;Lo;0;L;;;;;N;;;;;
+1882C;TANGUT COMPONENT-045;Lo;0;L;;;;;N;;;;;
+1882D;TANGUT COMPONENT-046;Lo;0;L;;;;;N;;;;;
+1882E;TANGUT COMPONENT-047;Lo;0;L;;;;;N;;;;;
+1882F;TANGUT COMPONENT-048;Lo;0;L;;;;;N;;;;;
+18830;TANGUT COMPONENT-049;Lo;0;L;;;;;N;;;;;
+18831;TANGUT COMPONENT-050;Lo;0;L;;;;;N;;;;;
+18832;TANGUT COMPONENT-051;Lo;0;L;;;;;N;;;;;
+18833;TANGUT COMPONENT-052;Lo;0;L;;;;;N;;;;;
+18834;TANGUT COMPONENT-053;Lo;0;L;;;;;N;;;;;
+18835;TANGUT COMPONENT-054;Lo;0;L;;;;;N;;;;;
+18836;TANGUT COMPONENT-055;Lo;0;L;;;;;N;;;;;
+18837;TANGUT COMPONENT-056;Lo;0;L;;;;;N;;;;;
+18838;TANGUT COMPONENT-057;Lo;0;L;;;;;N;;;;;
+18839;TANGUT COMPONENT-058;Lo;0;L;;;;;N;;;;;
+1883A;TANGUT COMPONENT-059;Lo;0;L;;;;;N;;;;;
+1883B;TANGUT COMPONENT-060;Lo;0;L;;;;;N;;;;;
+1883C;TANGUT COMPONENT-061;Lo;0;L;;;;;N;;;;;
+1883D;TANGUT COMPONENT-062;Lo;0;L;;;;;N;;;;;
+1883E;TANGUT COMPONENT-063;Lo;0;L;;;;;N;;;;;
+1883F;TANGUT COMPONENT-064;Lo;0;L;;;;;N;;;;;
+18840;TANGUT COMPONENT-065;Lo;0;L;;;;;N;;;;;
+18841;TANGUT COMPONENT-066;Lo;0;L;;;;;N;;;;;
+18842;TANGUT COMPONENT-067;Lo;0;L;;;;;N;;;;;
+18843;TANGUT COMPONENT-068;Lo;0;L;;;;;N;;;;;
+18844;TANGUT COMPONENT-069;Lo;0;L;;;;;N;;;;;
+18845;TANGUT COMPONENT-070;Lo;0;L;;;;;N;;;;;
+18846;TANGUT COMPONENT-071;Lo;0;L;;;;;N;;;;;
+18847;TANGUT COMPONENT-072;Lo;0;L;;;;;N;;;;;
+18848;TANGUT COMPONENT-073;Lo;0;L;;;;;N;;;;;
+18849;TANGUT COMPONENT-074;Lo;0;L;;;;;N;;;;;
+1884A;TANGUT COMPONENT-075;Lo;0;L;;;;;N;;;;;
+1884B;TANGUT COMPONENT-076;Lo;0;L;;;;;N;;;;;
+1884C;TANGUT COMPONENT-077;Lo;0;L;;;;;N;;;;;
+1884D;TANGUT COMPONENT-078;Lo;0;L;;;;;N;;;;;
+1884E;TANGUT COMPONENT-079;Lo;0;L;;;;;N;;;;;
+1884F;TANGUT COMPONENT-080;Lo;0;L;;;;;N;;;;;
+18850;TANGUT COMPONENT-081;Lo;0;L;;;;;N;;;;;
+18851;TANGUT COMPONENT-082;Lo;0;L;;;;;N;;;;;
+18852;TANGUT COMPONENT-083;Lo;0;L;;;;;N;;;;;
+18853;TANGUT COMPONENT-084;Lo;0;L;;;;;N;;;;;
+18854;TANGUT COMPONENT-085;Lo;0;L;;;;;N;;;;;
+18855;TANGUT COMPONENT-086;Lo;0;L;;;;;N;;;;;
+18856;TANGUT COMPONENT-087;Lo;0;L;;;;;N;;;;;
+18857;TANGUT COMPONENT-088;Lo;0;L;;;;;N;;;;;
+18858;TANGUT COMPONENT-089;Lo;0;L;;;;;N;;;;;
+18859;TANGUT COMPONENT-090;Lo;0;L;;;;;N;;;;;
+1885A;TANGUT COMPONENT-091;Lo;0;L;;;;;N;;;;;
+1885B;TANGUT COMPONENT-092;Lo;0;L;;;;;N;;;;;
+1885C;TANGUT COMPONENT-093;Lo;0;L;;;;;N;;;;;
+1885D;TANGUT COMPONENT-094;Lo;0;L;;;;;N;;;;;
+1885E;TANGUT COMPONENT-095;Lo;0;L;;;;;N;;;;;
+1885F;TANGUT COMPONENT-096;Lo;0;L;;;;;N;;;;;
+18860;TANGUT COMPONENT-097;Lo;0;L;;;;;N;;;;;
+18861;TANGUT COMPONENT-098;Lo;0;L;;;;;N;;;;;
+18862;TANGUT COMPONENT-099;Lo;0;L;;;;;N;;;;;
+18863;TANGUT COMPONENT-100;Lo;0;L;;;;;N;;;;;
+18864;TANGUT COMPONENT-101;Lo;0;L;;;;;N;;;;;
+18865;TANGUT COMPONENT-102;Lo;0;L;;;;;N;;;;;
+18866;TANGUT COMPONENT-103;Lo;0;L;;;;;N;;;;;
+18867;TANGUT COMPONENT-104;Lo;0;L;;;;;N;;;;;
+18868;TANGUT COMPONENT-105;Lo;0;L;;;;;N;;;;;
+18869;TANGUT COMPONENT-106;Lo;0;L;;;;;N;;;;;
+1886A;TANGUT COMPONENT-107;Lo;0;L;;;;;N;;;;;
+1886B;TANGUT COMPONENT-108;Lo;0;L;;;;;N;;;;;
+1886C;TANGUT COMPONENT-109;Lo;0;L;;;;;N;;;;;
+1886D;TANGUT COMPONENT-110;Lo;0;L;;;;;N;;;;;
+1886E;TANGUT COMPONENT-111;Lo;0;L;;;;;N;;;;;
+1886F;TANGUT COMPONENT-112;Lo;0;L;;;;;N;;;;;
+18870;TANGUT COMPONENT-113;Lo;0;L;;;;;N;;;;;
+18871;TANGUT COMPONENT-114;Lo;0;L;;;;;N;;;;;
+18872;TANGUT COMPONENT-115;Lo;0;L;;;;;N;;;;;
+18873;TANGUT COMPONENT-116;Lo;0;L;;;;;N;;;;;
+18874;TANGUT COMPONENT-117;Lo;0;L;;;;;N;;;;;
+18875;TANGUT COMPONENT-118;Lo;0;L;;;;;N;;;;;
+18876;TANGUT COMPONENT-119;Lo;0;L;;;;;N;;;;;
+18877;TANGUT COMPONENT-120;Lo;0;L;;;;;N;;;;;
+18878;TANGUT COMPONENT-121;Lo;0;L;;;;;N;;;;;
+18879;TANGUT COMPONENT-122;Lo;0;L;;;;;N;;;;;
+1887A;TANGUT COMPONENT-123;Lo;0;L;;;;;N;;;;;
+1887B;TANGUT COMPONENT-124;Lo;0;L;;;;;N;;;;;
+1887C;TANGUT COMPONENT-125;Lo;0;L;;;;;N;;;;;
+1887D;TANGUT COMPONENT-126;Lo;0;L;;;;;N;;;;;
+1887E;TANGUT COMPONENT-127;Lo;0;L;;;;;N;;;;;
+1887F;TANGUT COMPONENT-128;Lo;0;L;;;;;N;;;;;
+18880;TANGUT COMPONENT-129;Lo;0;L;;;;;N;;;;;
+18881;TANGUT COMPONENT-130;Lo;0;L;;;;;N;;;;;
+18882;TANGUT COMPONENT-131;Lo;0;L;;;;;N;;;;;
+18883;TANGUT COMPONENT-132;Lo;0;L;;;;;N;;;;;
+18884;TANGUT COMPONENT-133;Lo;0;L;;;;;N;;;;;
+18885;TANGUT COMPONENT-134;Lo;0;L;;;;;N;;;;;
+18886;TANGUT COMPONENT-135;Lo;0;L;;;;;N;;;;;
+18887;TANGUT COMPONENT-136;Lo;0;L;;;;;N;;;;;
+18888;TANGUT COMPONENT-137;Lo;0;L;;;;;N;;;;;
+18889;TANGUT COMPONENT-138;Lo;0;L;;;;;N;;;;;
+1888A;TANGUT COMPONENT-139;Lo;0;L;;;;;N;;;;;
+1888B;TANGUT COMPONENT-140;Lo;0;L;;;;;N;;;;;
+1888C;TANGUT COMPONENT-141;Lo;0;L;;;;;N;;;;;
+1888D;TANGUT COMPONENT-142;Lo;0;L;;;;;N;;;;;
+1888E;TANGUT COMPONENT-143;Lo;0;L;;;;;N;;;;;
+1888F;TANGUT COMPONENT-144;Lo;0;L;;;;;N;;;;;
+18890;TANGUT COMPONENT-145;Lo;0;L;;;;;N;;;;;
+18891;TANGUT COMPONENT-146;Lo;0;L;;;;;N;;;;;
+18892;TANGUT COMPONENT-147;Lo;0;L;;;;;N;;;;;
+18893;TANGUT COMPONENT-148;Lo;0;L;;;;;N;;;;;
+18894;TANGUT COMPONENT-149;Lo;0;L;;;;;N;;;;;
+18895;TANGUT COMPONENT-150;Lo;0;L;;;;;N;;;;;
+18896;TANGUT COMPONENT-151;Lo;0;L;;;;;N;;;;;
+18897;TANGUT COMPONENT-152;Lo;0;L;;;;;N;;;;;
+18898;TANGUT COMPONENT-153;Lo;0;L;;;;;N;;;;;
+18899;TANGUT COMPONENT-154;Lo;0;L;;;;;N;;;;;
+1889A;TANGUT COMPONENT-155;Lo;0;L;;;;;N;;;;;
+1889B;TANGUT COMPONENT-156;Lo;0;L;;;;;N;;;;;
+1889C;TANGUT COMPONENT-157;Lo;0;L;;;;;N;;;;;
+1889D;TANGUT COMPONENT-158;Lo;0;L;;;;;N;;;;;
+1889E;TANGUT COMPONENT-159;Lo;0;L;;;;;N;;;;;
+1889F;TANGUT COMPONENT-160;Lo;0;L;;;;;N;;;;;
+188A0;TANGUT COMPONENT-161;Lo;0;L;;;;;N;;;;;
+188A1;TANGUT COMPONENT-162;Lo;0;L;;;;;N;;;;;
+188A2;TANGUT COMPONENT-163;Lo;0;L;;;;;N;;;;;
+188A3;TANGUT COMPONENT-164;Lo;0;L;;;;;N;;;;;
+188A4;TANGUT COMPONENT-165;Lo;0;L;;;;;N;;;;;
+188A5;TANGUT COMPONENT-166;Lo;0;L;;;;;N;;;;;
+188A6;TANGUT COMPONENT-167;Lo;0;L;;;;;N;;;;;
+188A7;TANGUT COMPONENT-168;Lo;0;L;;;;;N;;;;;
+188A8;TANGUT COMPONENT-169;Lo;0;L;;;;;N;;;;;
+188A9;TANGUT COMPONENT-170;Lo;0;L;;;;;N;;;;;
+188AA;TANGUT COMPONENT-171;Lo;0;L;;;;;N;;;;;
+188AB;TANGUT COMPONENT-172;Lo;0;L;;;;;N;;;;;
+188AC;TANGUT COMPONENT-173;Lo;0;L;;;;;N;;;;;
+188AD;TANGUT COMPONENT-174;Lo;0;L;;;;;N;;;;;
+188AE;TANGUT COMPONENT-175;Lo;0;L;;;;;N;;;;;
+188AF;TANGUT COMPONENT-176;Lo;0;L;;;;;N;;;;;
+188B0;TANGUT COMPONENT-177;Lo;0;L;;;;;N;;;;;
+188B1;TANGUT COMPONENT-178;Lo;0;L;;;;;N;;;;;
+188B2;TANGUT COMPONENT-179;Lo;0;L;;;;;N;;;;;
+188B3;TANGUT COMPONENT-180;Lo;0;L;;;;;N;;;;;
+188B4;TANGUT COMPONENT-181;Lo;0;L;;;;;N;;;;;
+188B5;TANGUT COMPONENT-182;Lo;0;L;;;;;N;;;;;
+188B6;TANGUT COMPONENT-183;Lo;0;L;;;;;N;;;;;
+188B7;TANGUT COMPONENT-184;Lo;0;L;;;;;N;;;;;
+188B8;TANGUT COMPONENT-185;Lo;0;L;;;;;N;;;;;
+188B9;TANGUT COMPONENT-186;Lo;0;L;;;;;N;;;;;
+188BA;TANGUT COMPONENT-187;Lo;0;L;;;;;N;;;;;
+188BB;TANGUT COMPONENT-188;Lo;0;L;;;;;N;;;;;
+188BC;TANGUT COMPONENT-189;Lo;0;L;;;;;N;;;;;
+188BD;TANGUT COMPONENT-190;Lo;0;L;;;;;N;;;;;
+188BE;TANGUT COMPONENT-191;Lo;0;L;;;;;N;;;;;
+188BF;TANGUT COMPONENT-192;Lo;0;L;;;;;N;;;;;
+188C0;TANGUT COMPONENT-193;Lo;0;L;;;;;N;;;;;
+188C1;TANGUT COMPONENT-194;Lo;0;L;;;;;N;;;;;
+188C2;TANGUT COMPONENT-195;Lo;0;L;;;;;N;;;;;
+188C3;TANGUT COMPONENT-196;Lo;0;L;;;;;N;;;;;
+188C4;TANGUT COMPONENT-197;Lo;0;L;;;;;N;;;;;
+188C5;TANGUT COMPONENT-198;Lo;0;L;;;;;N;;;;;
+188C6;TANGUT COMPONENT-199;Lo;0;L;;;;;N;;;;;
+188C7;TANGUT COMPONENT-200;Lo;0;L;;;;;N;;;;;
+188C8;TANGUT COMPONENT-201;Lo;0;L;;;;;N;;;;;
+188C9;TANGUT COMPONENT-202;Lo;0;L;;;;;N;;;;;
+188CA;TANGUT COMPONENT-203;Lo;0;L;;;;;N;;;;;
+188CB;TANGUT COMPONENT-204;Lo;0;L;;;;;N;;;;;
+188CC;TANGUT COMPONENT-205;Lo;0;L;;;;;N;;;;;
+188CD;TANGUT COMPONENT-206;Lo;0;L;;;;;N;;;;;
+188CE;TANGUT COMPONENT-207;Lo;0;L;;;;;N;;;;;
+188CF;TANGUT COMPONENT-208;Lo;0;L;;;;;N;;;;;
+188D0;TANGUT COMPONENT-209;Lo;0;L;;;;;N;;;;;
+188D1;TANGUT COMPONENT-210;Lo;0;L;;;;;N;;;;;
+188D2;TANGUT COMPONENT-211;Lo;0;L;;;;;N;;;;;
+188D3;TANGUT COMPONENT-212;Lo;0;L;;;;;N;;;;;
+188D4;TANGUT COMPONENT-213;Lo;0;L;;;;;N;;;;;
+188D5;TANGUT COMPONENT-214;Lo;0;L;;;;;N;;;;;
+188D6;TANGUT COMPONENT-215;Lo;0;L;;;;;N;;;;;
+188D7;TANGUT COMPONENT-216;Lo;0;L;;;;;N;;;;;
+188D8;TANGUT COMPONENT-217;Lo;0;L;;;;;N;;;;;
+188D9;TANGUT COMPONENT-218;Lo;0;L;;;;;N;;;;;
+188DA;TANGUT COMPONENT-219;Lo;0;L;;;;;N;;;;;
+188DB;TANGUT COMPONENT-220;Lo;0;L;;;;;N;;;;;
+188DC;TANGUT COMPONENT-221;Lo;0;L;;;;;N;;;;;
+188DD;TANGUT COMPONENT-222;Lo;0;L;;;;;N;;;;;
+188DE;TANGUT COMPONENT-223;Lo;0;L;;;;;N;;;;;
+188DF;TANGUT COMPONENT-224;Lo;0;L;;;;;N;;;;;
+188E0;TANGUT COMPONENT-225;Lo;0;L;;;;;N;;;;;
+188E1;TANGUT COMPONENT-226;Lo;0;L;;;;;N;;;;;
+188E2;TANGUT COMPONENT-227;Lo;0;L;;;;;N;;;;;
+188E3;TANGUT COMPONENT-228;Lo;0;L;;;;;N;;;;;
+188E4;TANGUT COMPONENT-229;Lo;0;L;;;;;N;;;;;
+188E5;TANGUT COMPONENT-230;Lo;0;L;;;;;N;;;;;
+188E6;TANGUT COMPONENT-231;Lo;0;L;;;;;N;;;;;
+188E7;TANGUT COMPONENT-232;Lo;0;L;;;;;N;;;;;
+188E8;TANGUT COMPONENT-233;Lo;0;L;;;;;N;;;;;
+188E9;TANGUT COMPONENT-234;Lo;0;L;;;;;N;;;;;
+188EA;TANGUT COMPONENT-235;Lo;0;L;;;;;N;;;;;
+188EB;TANGUT COMPONENT-236;Lo;0;L;;;;;N;;;;;
+188EC;TANGUT COMPONENT-237;Lo;0;L;;;;;N;;;;;
+188ED;TANGUT COMPONENT-238;Lo;0;L;;;;;N;;;;;
+188EE;TANGUT COMPONENT-239;Lo;0;L;;;;;N;;;;;
+188EF;TANGUT COMPONENT-240;Lo;0;L;;;;;N;;;;;
+188F0;TANGUT COMPONENT-241;Lo;0;L;;;;;N;;;;;
+188F1;TANGUT COMPONENT-242;Lo;0;L;;;;;N;;;;;
+188F2;TANGUT COMPONENT-243;Lo;0;L;;;;;N;;;;;
+188F3;TANGUT COMPONENT-244;Lo;0;L;;;;;N;;;;;
+188F4;TANGUT COMPONENT-245;Lo;0;L;;;;;N;;;;;
+188F5;TANGUT COMPONENT-246;Lo;0;L;;;;;N;;;;;
+188F6;TANGUT COMPONENT-247;Lo;0;L;;;;;N;;;;;
+188F7;TANGUT COMPONENT-248;Lo;0;L;;;;;N;;;;;
+188F8;TANGUT COMPONENT-249;Lo;0;L;;;;;N;;;;;
+188F9;TANGUT COMPONENT-250;Lo;0;L;;;;;N;;;;;
+188FA;TANGUT COMPONENT-251;Lo;0;L;;;;;N;;;;;
+188FB;TANGUT COMPONENT-252;Lo;0;L;;;;;N;;;;;
+188FC;TANGUT COMPONENT-253;Lo;0;L;;;;;N;;;;;
+188FD;TANGUT COMPONENT-254;Lo;0;L;;;;;N;;;;;
+188FE;TANGUT COMPONENT-255;Lo;0;L;;;;;N;;;;;
+188FF;TANGUT COMPONENT-256;Lo;0;L;;;;;N;;;;;
+18900;TANGUT COMPONENT-257;Lo;0;L;;;;;N;;;;;
+18901;TANGUT COMPONENT-258;Lo;0;L;;;;;N;;;;;
+18902;TANGUT COMPONENT-259;Lo;0;L;;;;;N;;;;;
+18903;TANGUT COMPONENT-260;Lo;0;L;;;;;N;;;;;
+18904;TANGUT COMPONENT-261;Lo;0;L;;;;;N;;;;;
+18905;TANGUT COMPONENT-262;Lo;0;L;;;;;N;;;;;
+18906;TANGUT COMPONENT-263;Lo;0;L;;;;;N;;;;;
+18907;TANGUT COMPONENT-264;Lo;0;L;;;;;N;;;;;
+18908;TANGUT COMPONENT-265;Lo;0;L;;;;;N;;;;;
+18909;TANGUT COMPONENT-266;Lo;0;L;;;;;N;;;;;
+1890A;TANGUT COMPONENT-267;Lo;0;L;;;;;N;;;;;
+1890B;TANGUT COMPONENT-268;Lo;0;L;;;;;N;;;;;
+1890C;TANGUT COMPONENT-269;Lo;0;L;;;;;N;;;;;
+1890D;TANGUT COMPONENT-270;Lo;0;L;;;;;N;;;;;
+1890E;TANGUT COMPONENT-271;Lo;0;L;;;;;N;;;;;
+1890F;TANGUT COMPONENT-272;Lo;0;L;;;;;N;;;;;
+18910;TANGUT COMPONENT-273;Lo;0;L;;;;;N;;;;;
+18911;TANGUT COMPONENT-274;Lo;0;L;;;;;N;;;;;
+18912;TANGUT COMPONENT-275;Lo;0;L;;;;;N;;;;;
+18913;TANGUT COMPONENT-276;Lo;0;L;;;;;N;;;;;
+18914;TANGUT COMPONENT-277;Lo;0;L;;;;;N;;;;;
+18915;TANGUT COMPONENT-278;Lo;0;L;;;;;N;;;;;
+18916;TANGUT COMPONENT-279;Lo;0;L;;;;;N;;;;;
+18917;TANGUT COMPONENT-280;Lo;0;L;;;;;N;;;;;
+18918;TANGUT COMPONENT-281;Lo;0;L;;;;;N;;;;;
+18919;TANGUT COMPONENT-282;Lo;0;L;;;;;N;;;;;
+1891A;TANGUT COMPONENT-283;Lo;0;L;;;;;N;;;;;
+1891B;TANGUT COMPONENT-284;Lo;0;L;;;;;N;;;;;
+1891C;TANGUT COMPONENT-285;Lo;0;L;;;;;N;;;;;
+1891D;TANGUT COMPONENT-286;Lo;0;L;;;;;N;;;;;
+1891E;TANGUT COMPONENT-287;Lo;0;L;;;;;N;;;;;
+1891F;TANGUT COMPONENT-288;Lo;0;L;;;;;N;;;;;
+18920;TANGUT COMPONENT-289;Lo;0;L;;;;;N;;;;;
+18921;TANGUT COMPONENT-290;Lo;0;L;;;;;N;;;;;
+18922;TANGUT COMPONENT-291;Lo;0;L;;;;;N;;;;;
+18923;TANGUT COMPONENT-292;Lo;0;L;;;;;N;;;;;
+18924;TANGUT COMPONENT-293;Lo;0;L;;;;;N;;;;;
+18925;TANGUT COMPONENT-294;Lo;0;L;;;;;N;;;;;
+18926;TANGUT COMPONENT-295;Lo;0;L;;;;;N;;;;;
+18927;TANGUT COMPONENT-296;Lo;0;L;;;;;N;;;;;
+18928;TANGUT COMPONENT-297;Lo;0;L;;;;;N;;;;;
+18929;TANGUT COMPONENT-298;Lo;0;L;;;;;N;;;;;
+1892A;TANGUT COMPONENT-299;Lo;0;L;;;;;N;;;;;
+1892B;TANGUT COMPONENT-300;Lo;0;L;;;;;N;;;;;
+1892C;TANGUT COMPONENT-301;Lo;0;L;;;;;N;;;;;
+1892D;TANGUT COMPONENT-302;Lo;0;L;;;;;N;;;;;
+1892E;TANGUT COMPONENT-303;Lo;0;L;;;;;N;;;;;
+1892F;TANGUT COMPONENT-304;Lo;0;L;;;;;N;;;;;
+18930;TANGUT COMPONENT-305;Lo;0;L;;;;;N;;;;;
+18931;TANGUT COMPONENT-306;Lo;0;L;;;;;N;;;;;
+18932;TANGUT COMPONENT-307;Lo;0;L;;;;;N;;;;;
+18933;TANGUT COMPONENT-308;Lo;0;L;;;;;N;;;;;
+18934;TANGUT COMPONENT-309;Lo;0;L;;;;;N;;;;;
+18935;TANGUT COMPONENT-310;Lo;0;L;;;;;N;;;;;
+18936;TANGUT COMPONENT-311;Lo;0;L;;;;;N;;;;;
+18937;TANGUT COMPONENT-312;Lo;0;L;;;;;N;;;;;
+18938;TANGUT COMPONENT-313;Lo;0;L;;;;;N;;;;;
+18939;TANGUT COMPONENT-314;Lo;0;L;;;;;N;;;;;
+1893A;TANGUT COMPONENT-315;Lo;0;L;;;;;N;;;;;
+1893B;TANGUT COMPONENT-316;Lo;0;L;;;;;N;;;;;
+1893C;TANGUT COMPONENT-317;Lo;0;L;;;;;N;;;;;
+1893D;TANGUT COMPONENT-318;Lo;0;L;;;;;N;;;;;
+1893E;TANGUT COMPONENT-319;Lo;0;L;;;;;N;;;;;
+1893F;TANGUT COMPONENT-320;Lo;0;L;;;;;N;;;;;
+18940;TANGUT COMPONENT-321;Lo;0;L;;;;;N;;;;;
+18941;TANGUT COMPONENT-322;Lo;0;L;;;;;N;;;;;
+18942;TANGUT COMPONENT-323;Lo;0;L;;;;;N;;;;;
+18943;TANGUT COMPONENT-324;Lo;0;L;;;;;N;;;;;
+18944;TANGUT COMPONENT-325;Lo;0;L;;;;;N;;;;;
+18945;TANGUT COMPONENT-326;Lo;0;L;;;;;N;;;;;
+18946;TANGUT COMPONENT-327;Lo;0;L;;;;;N;;;;;
+18947;TANGUT COMPONENT-328;Lo;0;L;;;;;N;;;;;
+18948;TANGUT COMPONENT-329;Lo;0;L;;;;;N;;;;;
+18949;TANGUT COMPONENT-330;Lo;0;L;;;;;N;;;;;
+1894A;TANGUT COMPONENT-331;Lo;0;L;;;;;N;;;;;
+1894B;TANGUT COMPONENT-332;Lo;0;L;;;;;N;;;;;
+1894C;TANGUT COMPONENT-333;Lo;0;L;;;;;N;;;;;
+1894D;TANGUT COMPONENT-334;Lo;0;L;;;;;N;;;;;
+1894E;TANGUT COMPONENT-335;Lo;0;L;;;;;N;;;;;
+1894F;TANGUT COMPONENT-336;Lo;0;L;;;;;N;;;;;
+18950;TANGUT COMPONENT-337;Lo;0;L;;;;;N;;;;;
+18951;TANGUT COMPONENT-338;Lo;0;L;;;;;N;;;;;
+18952;TANGUT COMPONENT-339;Lo;0;L;;;;;N;;;;;
+18953;TANGUT COMPONENT-340;Lo;0;L;;;;;N;;;;;
+18954;TANGUT COMPONENT-341;Lo;0;L;;;;;N;;;;;
+18955;TANGUT COMPONENT-342;Lo;0;L;;;;;N;;;;;
+18956;TANGUT COMPONENT-343;Lo;0;L;;;;;N;;;;;
+18957;TANGUT COMPONENT-344;Lo;0;L;;;;;N;;;;;
+18958;TANGUT COMPONENT-345;Lo;0;L;;;;;N;;;;;
+18959;TANGUT COMPONENT-346;Lo;0;L;;;;;N;;;;;
+1895A;TANGUT COMPONENT-347;Lo;0;L;;;;;N;;;;;
+1895B;TANGUT COMPONENT-348;Lo;0;L;;;;;N;;;;;
+1895C;TANGUT COMPONENT-349;Lo;0;L;;;;;N;;;;;
+1895D;TANGUT COMPONENT-350;Lo;0;L;;;;;N;;;;;
+1895E;TANGUT COMPONENT-351;Lo;0;L;;;;;N;;;;;
+1895F;TANGUT COMPONENT-352;Lo;0;L;;;;;N;;;;;
+18960;TANGUT COMPONENT-353;Lo;0;L;;;;;N;;;;;
+18961;TANGUT COMPONENT-354;Lo;0;L;;;;;N;;;;;
+18962;TANGUT COMPONENT-355;Lo;0;L;;;;;N;;;;;
+18963;TANGUT COMPONENT-356;Lo;0;L;;;;;N;;;;;
+18964;TANGUT COMPONENT-357;Lo;0;L;;;;;N;;;;;
+18965;TANGUT COMPONENT-358;Lo;0;L;;;;;N;;;;;
+18966;TANGUT COMPONENT-359;Lo;0;L;;;;;N;;;;;
+18967;TANGUT COMPONENT-360;Lo;0;L;;;;;N;;;;;
+18968;TANGUT COMPONENT-361;Lo;0;L;;;;;N;;;;;
+18969;TANGUT COMPONENT-362;Lo;0;L;;;;;N;;;;;
+1896A;TANGUT COMPONENT-363;Lo;0;L;;;;;N;;;;;
+1896B;TANGUT COMPONENT-364;Lo;0;L;;;;;N;;;;;
+1896C;TANGUT COMPONENT-365;Lo;0;L;;;;;N;;;;;
+1896D;TANGUT COMPONENT-366;Lo;0;L;;;;;N;;;;;
+1896E;TANGUT COMPONENT-367;Lo;0;L;;;;;N;;;;;
+1896F;TANGUT COMPONENT-368;Lo;0;L;;;;;N;;;;;
+18970;TANGUT COMPONENT-369;Lo;0;L;;;;;N;;;;;
+18971;TANGUT COMPONENT-370;Lo;0;L;;;;;N;;;;;
+18972;TANGUT COMPONENT-371;Lo;0;L;;;;;N;;;;;
+18973;TANGUT COMPONENT-372;Lo;0;L;;;;;N;;;;;
+18974;TANGUT COMPONENT-373;Lo;0;L;;;;;N;;;;;
+18975;TANGUT COMPONENT-374;Lo;0;L;;;;;N;;;;;
+18976;TANGUT COMPONENT-375;Lo;0;L;;;;;N;;;;;
+18977;TANGUT COMPONENT-376;Lo;0;L;;;;;N;;;;;
+18978;TANGUT COMPONENT-377;Lo;0;L;;;;;N;;;;;
+18979;TANGUT COMPONENT-378;Lo;0;L;;;;;N;;;;;
+1897A;TANGUT COMPONENT-379;Lo;0;L;;;;;N;;;;;
+1897B;TANGUT COMPONENT-380;Lo;0;L;;;;;N;;;;;
+1897C;TANGUT COMPONENT-381;Lo;0;L;;;;;N;;;;;
+1897D;TANGUT COMPONENT-382;Lo;0;L;;;;;N;;;;;
+1897E;TANGUT COMPONENT-383;Lo;0;L;;;;;N;;;;;
+1897F;TANGUT COMPONENT-384;Lo;0;L;;;;;N;;;;;
+18980;TANGUT COMPONENT-385;Lo;0;L;;;;;N;;;;;
+18981;TANGUT COMPONENT-386;Lo;0;L;;;;;N;;;;;
+18982;TANGUT COMPONENT-387;Lo;0;L;;;;;N;;;;;
+18983;TANGUT COMPONENT-388;Lo;0;L;;;;;N;;;;;
+18984;TANGUT COMPONENT-389;Lo;0;L;;;;;N;;;;;
+18985;TANGUT COMPONENT-390;Lo;0;L;;;;;N;;;;;
+18986;TANGUT COMPONENT-391;Lo;0;L;;;;;N;;;;;
+18987;TANGUT COMPONENT-392;Lo;0;L;;;;;N;;;;;
+18988;TANGUT COMPONENT-393;Lo;0;L;;;;;N;;;;;
+18989;TANGUT COMPONENT-394;Lo;0;L;;;;;N;;;;;
+1898A;TANGUT COMPONENT-395;Lo;0;L;;;;;N;;;;;
+1898B;TANGUT COMPONENT-396;Lo;0;L;;;;;N;;;;;
+1898C;TANGUT COMPONENT-397;Lo;0;L;;;;;N;;;;;
+1898D;TANGUT COMPONENT-398;Lo;0;L;;;;;N;;;;;
+1898E;TANGUT COMPONENT-399;Lo;0;L;;;;;N;;;;;
+1898F;TANGUT COMPONENT-400;Lo;0;L;;;;;N;;;;;
+18990;TANGUT COMPONENT-401;Lo;0;L;;;;;N;;;;;
+18991;TANGUT COMPONENT-402;Lo;0;L;;;;;N;;;;;
+18992;TANGUT COMPONENT-403;Lo;0;L;;;;;N;;;;;
+18993;TANGUT COMPONENT-404;Lo;0;L;;;;;N;;;;;
+18994;TANGUT COMPONENT-405;Lo;0;L;;;;;N;;;;;
+18995;TANGUT COMPONENT-406;Lo;0;L;;;;;N;;;;;
+18996;TANGUT COMPONENT-407;Lo;0;L;;;;;N;;;;;
+18997;TANGUT COMPONENT-408;Lo;0;L;;;;;N;;;;;
+18998;TANGUT COMPONENT-409;Lo;0;L;;;;;N;;;;;
+18999;TANGUT COMPONENT-410;Lo;0;L;;;;;N;;;;;
+1899A;TANGUT COMPONENT-411;Lo;0;L;;;;;N;;;;;
+1899B;TANGUT COMPONENT-412;Lo;0;L;;;;;N;;;;;
+1899C;TANGUT COMPONENT-413;Lo;0;L;;;;;N;;;;;
+1899D;TANGUT COMPONENT-414;Lo;0;L;;;;;N;;;;;
+1899E;TANGUT COMPONENT-415;Lo;0;L;;;;;N;;;;;
+1899F;TANGUT COMPONENT-416;Lo;0;L;;;;;N;;;;;
+189A0;TANGUT COMPONENT-417;Lo;0;L;;;;;N;;;;;
+189A1;TANGUT COMPONENT-418;Lo;0;L;;;;;N;;;;;
+189A2;TANGUT COMPONENT-419;Lo;0;L;;;;;N;;;;;
+189A3;TANGUT COMPONENT-420;Lo;0;L;;;;;N;;;;;
+189A4;TANGUT COMPONENT-421;Lo;0;L;;;;;N;;;;;
+189A5;TANGUT COMPONENT-422;Lo;0;L;;;;;N;;;;;
+189A6;TANGUT COMPONENT-423;Lo;0;L;;;;;N;;;;;
+189A7;TANGUT COMPONENT-424;Lo;0;L;;;;;N;;;;;
+189A8;TANGUT COMPONENT-425;Lo;0;L;;;;;N;;;;;
+189A9;TANGUT COMPONENT-426;Lo;0;L;;;;;N;;;;;
+189AA;TANGUT COMPONENT-427;Lo;0;L;;;;;N;;;;;
+189AB;TANGUT COMPONENT-428;Lo;0;L;;;;;N;;;;;
+189AC;TANGUT COMPONENT-429;Lo;0;L;;;;;N;;;;;
+189AD;TANGUT COMPONENT-430;Lo;0;L;;;;;N;;;;;
+189AE;TANGUT COMPONENT-431;Lo;0;L;;;;;N;;;;;
+189AF;TANGUT COMPONENT-432;Lo;0;L;;;;;N;;;;;
+189B0;TANGUT COMPONENT-433;Lo;0;L;;;;;N;;;;;
+189B1;TANGUT COMPONENT-434;Lo;0;L;;;;;N;;;;;
+189B2;TANGUT COMPONENT-435;Lo;0;L;;;;;N;;;;;
+189B3;TANGUT COMPONENT-436;Lo;0;L;;;;;N;;;;;
+189B4;TANGUT COMPONENT-437;Lo;0;L;;;;;N;;;;;
+189B5;TANGUT COMPONENT-438;Lo;0;L;;;;;N;;;;;
+189B6;TANGUT COMPONENT-439;Lo;0;L;;;;;N;;;;;
+189B7;TANGUT COMPONENT-440;Lo;0;L;;;;;N;;;;;
+189B8;TANGUT COMPONENT-441;Lo;0;L;;;;;N;;;;;
+189B9;TANGUT COMPONENT-442;Lo;0;L;;;;;N;;;;;
+189BA;TANGUT COMPONENT-443;Lo;0;L;;;;;N;;;;;
+189BB;TANGUT COMPONENT-444;Lo;0;L;;;;;N;;;;;
+189BC;TANGUT COMPONENT-445;Lo;0;L;;;;;N;;;;;
+189BD;TANGUT COMPONENT-446;Lo;0;L;;;;;N;;;;;
+189BE;TANGUT COMPONENT-447;Lo;0;L;;;;;N;;;;;
+189BF;TANGUT COMPONENT-448;Lo;0;L;;;;;N;;;;;
+189C0;TANGUT COMPONENT-449;Lo;0;L;;;;;N;;;;;
+189C1;TANGUT COMPONENT-450;Lo;0;L;;;;;N;;;;;
+189C2;TANGUT COMPONENT-451;Lo;0;L;;;;;N;;;;;
+189C3;TANGUT COMPONENT-452;Lo;0;L;;;;;N;;;;;
+189C4;TANGUT COMPONENT-453;Lo;0;L;;;;;N;;;;;
+189C5;TANGUT COMPONENT-454;Lo;0;L;;;;;N;;;;;
+189C6;TANGUT COMPONENT-455;Lo;0;L;;;;;N;;;;;
+189C7;TANGUT COMPONENT-456;Lo;0;L;;;;;N;;;;;
+189C8;TANGUT COMPONENT-457;Lo;0;L;;;;;N;;;;;
+189C9;TANGUT COMPONENT-458;Lo;0;L;;;;;N;;;;;
+189CA;TANGUT COMPONENT-459;Lo;0;L;;;;;N;;;;;
+189CB;TANGUT COMPONENT-460;Lo;0;L;;;;;N;;;;;
+189CC;TANGUT COMPONENT-461;Lo;0;L;;;;;N;;;;;
+189CD;TANGUT COMPONENT-462;Lo;0;L;;;;;N;;;;;
+189CE;TANGUT COMPONENT-463;Lo;0;L;;;;;N;;;;;
+189CF;TANGUT COMPONENT-464;Lo;0;L;;;;;N;;;;;
+189D0;TANGUT COMPONENT-465;Lo;0;L;;;;;N;;;;;
+189D1;TANGUT COMPONENT-466;Lo;0;L;;;;;N;;;;;
+189D2;TANGUT COMPONENT-467;Lo;0;L;;;;;N;;;;;
+189D3;TANGUT COMPONENT-468;Lo;0;L;;;;;N;;;;;
+189D4;TANGUT COMPONENT-469;Lo;0;L;;;;;N;;;;;
+189D5;TANGUT COMPONENT-470;Lo;0;L;;;;;N;;;;;
+189D6;TANGUT COMPONENT-471;Lo;0;L;;;;;N;;;;;
+189D7;TANGUT COMPONENT-472;Lo;0;L;;;;;N;;;;;
+189D8;TANGUT COMPONENT-473;Lo;0;L;;;;;N;;;;;
+189D9;TANGUT COMPONENT-474;Lo;0;L;;;;;N;;;;;
+189DA;TANGUT COMPONENT-475;Lo;0;L;;;;;N;;;;;
+189DB;TANGUT COMPONENT-476;Lo;0;L;;;;;N;;;;;
+189DC;TANGUT COMPONENT-477;Lo;0;L;;;;;N;;;;;
+189DD;TANGUT COMPONENT-478;Lo;0;L;;;;;N;;;;;
+189DE;TANGUT COMPONENT-479;Lo;0;L;;;;;N;;;;;
+189DF;TANGUT COMPONENT-480;Lo;0;L;;;;;N;;;;;
+189E0;TANGUT COMPONENT-481;Lo;0;L;;;;;N;;;;;
+189E1;TANGUT COMPONENT-482;Lo;0;L;;;;;N;;;;;
+189E2;TANGUT COMPONENT-483;Lo;0;L;;;;;N;;;;;
+189E3;TANGUT COMPONENT-484;Lo;0;L;;;;;N;;;;;
+189E4;TANGUT COMPONENT-485;Lo;0;L;;;;;N;;;;;
+189E5;TANGUT COMPONENT-486;Lo;0;L;;;;;N;;;;;
+189E6;TANGUT COMPONENT-487;Lo;0;L;;;;;N;;;;;
+189E7;TANGUT COMPONENT-488;Lo;0;L;;;;;N;;;;;
+189E8;TANGUT COMPONENT-489;Lo;0;L;;;;;N;;;;;
+189E9;TANGUT COMPONENT-490;Lo;0;L;;;;;N;;;;;
+189EA;TANGUT COMPONENT-491;Lo;0;L;;;;;N;;;;;
+189EB;TANGUT COMPONENT-492;Lo;0;L;;;;;N;;;;;
+189EC;TANGUT COMPONENT-493;Lo;0;L;;;;;N;;;;;
+189ED;TANGUT COMPONENT-494;Lo;0;L;;;;;N;;;;;
+189EE;TANGUT COMPONENT-495;Lo;0;L;;;;;N;;;;;
+189EF;TANGUT COMPONENT-496;Lo;0;L;;;;;N;;;;;
+189F0;TANGUT COMPONENT-497;Lo;0;L;;;;;N;;;;;
+189F1;TANGUT COMPONENT-498;Lo;0;L;;;;;N;;;;;
+189F2;TANGUT COMPONENT-499;Lo;0;L;;;;;N;;;;;
+189F3;TANGUT COMPONENT-500;Lo;0;L;;;;;N;;;;;
+189F4;TANGUT COMPONENT-501;Lo;0;L;;;;;N;;;;;
+189F5;TANGUT COMPONENT-502;Lo;0;L;;;;;N;;;;;
+189F6;TANGUT COMPONENT-503;Lo;0;L;;;;;N;;;;;
+189F7;TANGUT COMPONENT-504;Lo;0;L;;;;;N;;;;;
+189F8;TANGUT COMPONENT-505;Lo;0;L;;;;;N;;;;;
+189F9;TANGUT COMPONENT-506;Lo;0;L;;;;;N;;;;;
+189FA;TANGUT COMPONENT-507;Lo;0;L;;;;;N;;;;;
+189FB;TANGUT COMPONENT-508;Lo;0;L;;;;;N;;;;;
+189FC;TANGUT COMPONENT-509;Lo;0;L;;;;;N;;;;;
+189FD;TANGUT COMPONENT-510;Lo;0;L;;;;;N;;;;;
+189FE;TANGUT COMPONENT-511;Lo;0;L;;;;;N;;;;;
+189FF;TANGUT COMPONENT-512;Lo;0;L;;;;;N;;;;;
+18A00;TANGUT COMPONENT-513;Lo;0;L;;;;;N;;;;;
+18A01;TANGUT COMPONENT-514;Lo;0;L;;;;;N;;;;;
+18A02;TANGUT COMPONENT-515;Lo;0;L;;;;;N;;;;;
+18A03;TANGUT COMPONENT-516;Lo;0;L;;;;;N;;;;;
+18A04;TANGUT COMPONENT-517;Lo;0;L;;;;;N;;;;;
+18A05;TANGUT COMPONENT-518;Lo;0;L;;;;;N;;;;;
+18A06;TANGUT COMPONENT-519;Lo;0;L;;;;;N;;;;;
+18A07;TANGUT COMPONENT-520;Lo;0;L;;;;;N;;;;;
+18A08;TANGUT COMPONENT-521;Lo;0;L;;;;;N;;;;;
+18A09;TANGUT COMPONENT-522;Lo;0;L;;;;;N;;;;;
+18A0A;TANGUT COMPONENT-523;Lo;0;L;;;;;N;;;;;
+18A0B;TANGUT COMPONENT-524;Lo;0;L;;;;;N;;;;;
+18A0C;TANGUT COMPONENT-525;Lo;0;L;;;;;N;;;;;
+18A0D;TANGUT COMPONENT-526;Lo;0;L;;;;;N;;;;;
+18A0E;TANGUT COMPONENT-527;Lo;0;L;;;;;N;;;;;
+18A0F;TANGUT COMPONENT-528;Lo;0;L;;;;;N;;;;;
+18A10;TANGUT COMPONENT-529;Lo;0;L;;;;;N;;;;;
+18A11;TANGUT COMPONENT-530;Lo;0;L;;;;;N;;;;;
+18A12;TANGUT COMPONENT-531;Lo;0;L;;;;;N;;;;;
+18A13;TANGUT COMPONENT-532;Lo;0;L;;;;;N;;;;;
+18A14;TANGUT COMPONENT-533;Lo;0;L;;;;;N;;;;;
+18A15;TANGUT COMPONENT-534;Lo;0;L;;;;;N;;;;;
+18A16;TANGUT COMPONENT-535;Lo;0;L;;;;;N;;;;;
+18A17;TANGUT COMPONENT-536;Lo;0;L;;;;;N;;;;;
+18A18;TANGUT COMPONENT-537;Lo;0;L;;;;;N;;;;;
+18A19;TANGUT COMPONENT-538;Lo;0;L;;;;;N;;;;;
+18A1A;TANGUT COMPONENT-539;Lo;0;L;;;;;N;;;;;
+18A1B;TANGUT COMPONENT-540;Lo;0;L;;;;;N;;;;;
+18A1C;TANGUT COMPONENT-541;Lo;0;L;;;;;N;;;;;
+18A1D;TANGUT COMPONENT-542;Lo;0;L;;;;;N;;;;;
+18A1E;TANGUT COMPONENT-543;Lo;0;L;;;;;N;;;;;
+18A1F;TANGUT COMPONENT-544;Lo;0;L;;;;;N;;;;;
+18A20;TANGUT COMPONENT-545;Lo;0;L;;;;;N;;;;;
+18A21;TANGUT COMPONENT-546;Lo;0;L;;;;;N;;;;;
+18A22;TANGUT COMPONENT-547;Lo;0;L;;;;;N;;;;;
+18A23;TANGUT COMPONENT-548;Lo;0;L;;;;;N;;;;;
+18A24;TANGUT COMPONENT-549;Lo;0;L;;;;;N;;;;;
+18A25;TANGUT COMPONENT-550;Lo;0;L;;;;;N;;;;;
+18A26;TANGUT COMPONENT-551;Lo;0;L;;;;;N;;;;;
+18A27;TANGUT COMPONENT-552;Lo;0;L;;;;;N;;;;;
+18A28;TANGUT COMPONENT-553;Lo;0;L;;;;;N;;;;;
+18A29;TANGUT COMPONENT-554;Lo;0;L;;;;;N;;;;;
+18A2A;TANGUT COMPONENT-555;Lo;0;L;;;;;N;;;;;
+18A2B;TANGUT COMPONENT-556;Lo;0;L;;;;;N;;;;;
+18A2C;TANGUT COMPONENT-557;Lo;0;L;;;;;N;;;;;
+18A2D;TANGUT COMPONENT-558;Lo;0;L;;;;;N;;;;;
+18A2E;TANGUT COMPONENT-559;Lo;0;L;;;;;N;;;;;
+18A2F;TANGUT COMPONENT-560;Lo;0;L;;;;;N;;;;;
+18A30;TANGUT COMPONENT-561;Lo;0;L;;;;;N;;;;;
+18A31;TANGUT COMPONENT-562;Lo;0;L;;;;;N;;;;;
+18A32;TANGUT COMPONENT-563;Lo;0;L;;;;;N;;;;;
+18A33;TANGUT COMPONENT-564;Lo;0;L;;;;;N;;;;;
+18A34;TANGUT COMPONENT-565;Lo;0;L;;;;;N;;;;;
+18A35;TANGUT COMPONENT-566;Lo;0;L;;;;;N;;;;;
+18A36;TANGUT COMPONENT-567;Lo;0;L;;;;;N;;;;;
+18A37;TANGUT COMPONENT-568;Lo;0;L;;;;;N;;;;;
+18A38;TANGUT COMPONENT-569;Lo;0;L;;;;;N;;;;;
+18A39;TANGUT COMPONENT-570;Lo;0;L;;;;;N;;;;;
+18A3A;TANGUT COMPONENT-571;Lo;0;L;;;;;N;;;;;
+18A3B;TANGUT COMPONENT-572;Lo;0;L;;;;;N;;;;;
+18A3C;TANGUT COMPONENT-573;Lo;0;L;;;;;N;;;;;
+18A3D;TANGUT COMPONENT-574;Lo;0;L;;;;;N;;;;;
+18A3E;TANGUT COMPONENT-575;Lo;0;L;;;;;N;;;;;
+18A3F;TANGUT COMPONENT-576;Lo;0;L;;;;;N;;;;;
+18A40;TANGUT COMPONENT-577;Lo;0;L;;;;;N;;;;;
+18A41;TANGUT COMPONENT-578;Lo;0;L;;;;;N;;;;;
+18A42;TANGUT COMPONENT-579;Lo;0;L;;;;;N;;;;;
+18A43;TANGUT COMPONENT-580;Lo;0;L;;;;;N;;;;;
+18A44;TANGUT COMPONENT-581;Lo;0;L;;;;;N;;;;;
+18A45;TANGUT COMPONENT-582;Lo;0;L;;;;;N;;;;;
+18A46;TANGUT COMPONENT-583;Lo;0;L;;;;;N;;;;;
+18A47;TANGUT COMPONENT-584;Lo;0;L;;;;;N;;;;;
+18A48;TANGUT COMPONENT-585;Lo;0;L;;;;;N;;;;;
+18A49;TANGUT COMPONENT-586;Lo;0;L;;;;;N;;;;;
+18A4A;TANGUT COMPONENT-587;Lo;0;L;;;;;N;;;;;
+18A4B;TANGUT COMPONENT-588;Lo;0;L;;;;;N;;;;;
+18A4C;TANGUT COMPONENT-589;Lo;0;L;;;;;N;;;;;
+18A4D;TANGUT COMPONENT-590;Lo;0;L;;;;;N;;;;;
+18A4E;TANGUT COMPONENT-591;Lo;0;L;;;;;N;;;;;
+18A4F;TANGUT COMPONENT-592;Lo;0;L;;;;;N;;;;;
+18A50;TANGUT COMPONENT-593;Lo;0;L;;;;;N;;;;;
+18A51;TANGUT COMPONENT-594;Lo;0;L;;;;;N;;;;;
+18A52;TANGUT COMPONENT-595;Lo;0;L;;;;;N;;;;;
+18A53;TANGUT COMPONENT-596;Lo;0;L;;;;;N;;;;;
+18A54;TANGUT COMPONENT-597;Lo;0;L;;;;;N;;;;;
+18A55;TANGUT COMPONENT-598;Lo;0;L;;;;;N;;;;;
+18A56;TANGUT COMPONENT-599;Lo;0;L;;;;;N;;;;;
+18A57;TANGUT COMPONENT-600;Lo;0;L;;;;;N;;;;;
+18A58;TANGUT COMPONENT-601;Lo;0;L;;;;;N;;;;;
+18A59;TANGUT COMPONENT-602;Lo;0;L;;;;;N;;;;;
+18A5A;TANGUT COMPONENT-603;Lo;0;L;;;;;N;;;;;
+18A5B;TANGUT COMPONENT-604;Lo;0;L;;;;;N;;;;;
+18A5C;TANGUT COMPONENT-605;Lo;0;L;;;;;N;;;;;
+18A5D;TANGUT COMPONENT-606;Lo;0;L;;;;;N;;;;;
+18A5E;TANGUT COMPONENT-607;Lo;0;L;;;;;N;;;;;
+18A5F;TANGUT COMPONENT-608;Lo;0;L;;;;;N;;;;;
+18A60;TANGUT COMPONENT-609;Lo;0;L;;;;;N;;;;;
+18A61;TANGUT COMPONENT-610;Lo;0;L;;;;;N;;;;;
+18A62;TANGUT COMPONENT-611;Lo;0;L;;;;;N;;;;;
+18A63;TANGUT COMPONENT-612;Lo;0;L;;;;;N;;;;;
+18A64;TANGUT COMPONENT-613;Lo;0;L;;;;;N;;;;;
+18A65;TANGUT COMPONENT-614;Lo;0;L;;;;;N;;;;;
+18A66;TANGUT COMPONENT-615;Lo;0;L;;;;;N;;;;;
+18A67;TANGUT COMPONENT-616;Lo;0;L;;;;;N;;;;;
+18A68;TANGUT COMPONENT-617;Lo;0;L;;;;;N;;;;;
+18A69;TANGUT COMPONENT-618;Lo;0;L;;;;;N;;;;;
+18A6A;TANGUT COMPONENT-619;Lo;0;L;;;;;N;;;;;
+18A6B;TANGUT COMPONENT-620;Lo;0;L;;;;;N;;;;;
+18A6C;TANGUT COMPONENT-621;Lo;0;L;;;;;N;;;;;
+18A6D;TANGUT COMPONENT-622;Lo;0;L;;;;;N;;;;;
+18A6E;TANGUT COMPONENT-623;Lo;0;L;;;;;N;;;;;
+18A6F;TANGUT COMPONENT-624;Lo;0;L;;;;;N;;;;;
+18A70;TANGUT COMPONENT-625;Lo;0;L;;;;;N;;;;;
+18A71;TANGUT COMPONENT-626;Lo;0;L;;;;;N;;;;;
+18A72;TANGUT COMPONENT-627;Lo;0;L;;;;;N;;;;;
+18A73;TANGUT COMPONENT-628;Lo;0;L;;;;;N;;;;;
+18A74;TANGUT COMPONENT-629;Lo;0;L;;;;;N;;;;;
+18A75;TANGUT COMPONENT-630;Lo;0;L;;;;;N;;;;;
+18A76;TANGUT COMPONENT-631;Lo;0;L;;;;;N;;;;;
+18A77;TANGUT COMPONENT-632;Lo;0;L;;;;;N;;;;;
+18A78;TANGUT COMPONENT-633;Lo;0;L;;;;;N;;;;;
+18A79;TANGUT COMPONENT-634;Lo;0;L;;;;;N;;;;;
+18A7A;TANGUT COMPONENT-635;Lo;0;L;;;;;N;;;;;
+18A7B;TANGUT COMPONENT-636;Lo;0;L;;;;;N;;;;;
+18A7C;TANGUT COMPONENT-637;Lo;0;L;;;;;N;;;;;
+18A7D;TANGUT COMPONENT-638;Lo;0;L;;;;;N;;;;;
+18A7E;TANGUT COMPONENT-639;Lo;0;L;;;;;N;;;;;
+18A7F;TANGUT COMPONENT-640;Lo;0;L;;;;;N;;;;;
+18A80;TANGUT COMPONENT-641;Lo;0;L;;;;;N;;;;;
+18A81;TANGUT COMPONENT-642;Lo;0;L;;;;;N;;;;;
+18A82;TANGUT COMPONENT-643;Lo;0;L;;;;;N;;;;;
+18A83;TANGUT COMPONENT-644;Lo;0;L;;;;;N;;;;;
+18A84;TANGUT COMPONENT-645;Lo;0;L;;;;;N;;;;;
+18A85;TANGUT COMPONENT-646;Lo;0;L;;;;;N;;;;;
+18A86;TANGUT COMPONENT-647;Lo;0;L;;;;;N;;;;;
+18A87;TANGUT COMPONENT-648;Lo;0;L;;;;;N;;;;;
+18A88;TANGUT COMPONENT-649;Lo;0;L;;;;;N;;;;;
+18A89;TANGUT COMPONENT-650;Lo;0;L;;;;;N;;;;;
+18A8A;TANGUT COMPONENT-651;Lo;0;L;;;;;N;;;;;
+18A8B;TANGUT COMPONENT-652;Lo;0;L;;;;;N;;;;;
+18A8C;TANGUT COMPONENT-653;Lo;0;L;;;;;N;;;;;
+18A8D;TANGUT COMPONENT-654;Lo;0;L;;;;;N;;;;;
+18A8E;TANGUT COMPONENT-655;Lo;0;L;;;;;N;;;;;
+18A8F;TANGUT COMPONENT-656;Lo;0;L;;;;;N;;;;;
+18A90;TANGUT COMPONENT-657;Lo;0;L;;;;;N;;;;;
+18A91;TANGUT COMPONENT-658;Lo;0;L;;;;;N;;;;;
+18A92;TANGUT COMPONENT-659;Lo;0;L;;;;;N;;;;;
+18A93;TANGUT COMPONENT-660;Lo;0;L;;;;;N;;;;;
+18A94;TANGUT COMPONENT-661;Lo;0;L;;;;;N;;;;;
+18A95;TANGUT COMPONENT-662;Lo;0;L;;;;;N;;;;;
+18A96;TANGUT COMPONENT-663;Lo;0;L;;;;;N;;;;;
+18A97;TANGUT COMPONENT-664;Lo;0;L;;;;;N;;;;;
+18A98;TANGUT COMPONENT-665;Lo;0;L;;;;;N;;;;;
+18A99;TANGUT COMPONENT-666;Lo;0;L;;;;;N;;;;;
+18A9A;TANGUT COMPONENT-667;Lo;0;L;;;;;N;;;;;
+18A9B;TANGUT COMPONENT-668;Lo;0;L;;;;;N;;;;;
+18A9C;TANGUT COMPONENT-669;Lo;0;L;;;;;N;;;;;
+18A9D;TANGUT COMPONENT-670;Lo;0;L;;;;;N;;;;;
+18A9E;TANGUT COMPONENT-671;Lo;0;L;;;;;N;;;;;
+18A9F;TANGUT COMPONENT-672;Lo;0;L;;;;;N;;;;;
+18AA0;TANGUT COMPONENT-673;Lo;0;L;;;;;N;;;;;
+18AA1;TANGUT COMPONENT-674;Lo;0;L;;;;;N;;;;;
+18AA2;TANGUT COMPONENT-675;Lo;0;L;;;;;N;;;;;
+18AA3;TANGUT COMPONENT-676;Lo;0;L;;;;;N;;;;;
+18AA4;TANGUT COMPONENT-677;Lo;0;L;;;;;N;;;;;
+18AA5;TANGUT COMPONENT-678;Lo;0;L;;;;;N;;;;;
+18AA6;TANGUT COMPONENT-679;Lo;0;L;;;;;N;;;;;
+18AA7;TANGUT COMPONENT-680;Lo;0;L;;;;;N;;;;;
+18AA8;TANGUT COMPONENT-681;Lo;0;L;;;;;N;;;;;
+18AA9;TANGUT COMPONENT-682;Lo;0;L;;;;;N;;;;;
+18AAA;TANGUT COMPONENT-683;Lo;0;L;;;;;N;;;;;
+18AAB;TANGUT COMPONENT-684;Lo;0;L;;;;;N;;;;;
+18AAC;TANGUT COMPONENT-685;Lo;0;L;;;;;N;;;;;
+18AAD;TANGUT COMPONENT-686;Lo;0;L;;;;;N;;;;;
+18AAE;TANGUT COMPONENT-687;Lo;0;L;;;;;N;;;;;
+18AAF;TANGUT COMPONENT-688;Lo;0;L;;;;;N;;;;;
+18AB0;TANGUT COMPONENT-689;Lo;0;L;;;;;N;;;;;
+18AB1;TANGUT COMPONENT-690;Lo;0;L;;;;;N;;;;;
+18AB2;TANGUT COMPONENT-691;Lo;0;L;;;;;N;;;;;
+18AB3;TANGUT COMPONENT-692;Lo;0;L;;;;;N;;;;;
+18AB4;TANGUT COMPONENT-693;Lo;0;L;;;;;N;;;;;
+18AB5;TANGUT COMPONENT-694;Lo;0;L;;;;;N;;;;;
+18AB6;TANGUT COMPONENT-695;Lo;0;L;;;;;N;;;;;
+18AB7;TANGUT COMPONENT-696;Lo;0;L;;;;;N;;;;;
+18AB8;TANGUT COMPONENT-697;Lo;0;L;;;;;N;;;;;
+18AB9;TANGUT COMPONENT-698;Lo;0;L;;;;;N;;;;;
+18ABA;TANGUT COMPONENT-699;Lo;0;L;;;;;N;;;;;
+18ABB;TANGUT COMPONENT-700;Lo;0;L;;;;;N;;;;;
+18ABC;TANGUT COMPONENT-701;Lo;0;L;;;;;N;;;;;
+18ABD;TANGUT COMPONENT-702;Lo;0;L;;;;;N;;;;;
+18ABE;TANGUT COMPONENT-703;Lo;0;L;;;;;N;;;;;
+18ABF;TANGUT COMPONENT-704;Lo;0;L;;;;;N;;;;;
+18AC0;TANGUT COMPONENT-705;Lo;0;L;;;;;N;;;;;
+18AC1;TANGUT COMPONENT-706;Lo;0;L;;;;;N;;;;;
+18AC2;TANGUT COMPONENT-707;Lo;0;L;;;;;N;;;;;
+18AC3;TANGUT COMPONENT-708;Lo;0;L;;;;;N;;;;;
+18AC4;TANGUT COMPONENT-709;Lo;0;L;;;;;N;;;;;
+18AC5;TANGUT COMPONENT-710;Lo;0;L;;;;;N;;;;;
+18AC6;TANGUT COMPONENT-711;Lo;0;L;;;;;N;;;;;
+18AC7;TANGUT COMPONENT-712;Lo;0;L;;;;;N;;;;;
+18AC8;TANGUT COMPONENT-713;Lo;0;L;;;;;N;;;;;
+18AC9;TANGUT COMPONENT-714;Lo;0;L;;;;;N;;;;;
+18ACA;TANGUT COMPONENT-715;Lo;0;L;;;;;N;;;;;
+18ACB;TANGUT COMPONENT-716;Lo;0;L;;;;;N;;;;;
+18ACC;TANGUT COMPONENT-717;Lo;0;L;;;;;N;;;;;
+18ACD;TANGUT COMPONENT-718;Lo;0;L;;;;;N;;;;;
+18ACE;TANGUT COMPONENT-719;Lo;0;L;;;;;N;;;;;
+18ACF;TANGUT COMPONENT-720;Lo;0;L;;;;;N;;;;;
+18AD0;TANGUT COMPONENT-721;Lo;0;L;;;;;N;;;;;
+18AD1;TANGUT COMPONENT-722;Lo;0;L;;;;;N;;;;;
+18AD2;TANGUT COMPONENT-723;Lo;0;L;;;;;N;;;;;
+18AD3;TANGUT COMPONENT-724;Lo;0;L;;;;;N;;;;;
+18AD4;TANGUT COMPONENT-725;Lo;0;L;;;;;N;;;;;
+18AD5;TANGUT COMPONENT-726;Lo;0;L;;;;;N;;;;;
+18AD6;TANGUT COMPONENT-727;Lo;0;L;;;;;N;;;;;
+18AD7;TANGUT COMPONENT-728;Lo;0;L;;;;;N;;;;;
+18AD8;TANGUT COMPONENT-729;Lo;0;L;;;;;N;;;;;
+18AD9;TANGUT COMPONENT-730;Lo;0;L;;;;;N;;;;;
+18ADA;TANGUT COMPONENT-731;Lo;0;L;;;;;N;;;;;
+18ADB;TANGUT COMPONENT-732;Lo;0;L;;;;;N;;;;;
+18ADC;TANGUT COMPONENT-733;Lo;0;L;;;;;N;;;;;
+18ADD;TANGUT COMPONENT-734;Lo;0;L;;;;;N;;;;;
+18ADE;TANGUT COMPONENT-735;Lo;0;L;;;;;N;;;;;
+18ADF;TANGUT COMPONENT-736;Lo;0;L;;;;;N;;;;;
+18AE0;TANGUT COMPONENT-737;Lo;0;L;;;;;N;;;;;
+18AE1;TANGUT COMPONENT-738;Lo;0;L;;;;;N;;;;;
+18AE2;TANGUT COMPONENT-739;Lo;0;L;;;;;N;;;;;
+18AE3;TANGUT COMPONENT-740;Lo;0;L;;;;;N;;;;;
+18AE4;TANGUT COMPONENT-741;Lo;0;L;;;;;N;;;;;
+18AE5;TANGUT COMPONENT-742;Lo;0;L;;;;;N;;;;;
+18AE6;TANGUT COMPONENT-743;Lo;0;L;;;;;N;;;;;
+18AE7;TANGUT COMPONENT-744;Lo;0;L;;;;;N;;;;;
+18AE8;TANGUT COMPONENT-745;Lo;0;L;;;;;N;;;;;
+18AE9;TANGUT COMPONENT-746;Lo;0;L;;;;;N;;;;;
+18AEA;TANGUT COMPONENT-747;Lo;0;L;;;;;N;;;;;
+18AEB;TANGUT COMPONENT-748;Lo;0;L;;;;;N;;;;;
+18AEC;TANGUT COMPONENT-749;Lo;0;L;;;;;N;;;;;
+18AED;TANGUT COMPONENT-750;Lo;0;L;;;;;N;;;;;
+18AEE;TANGUT COMPONENT-751;Lo;0;L;;;;;N;;;;;
+18AEF;TANGUT COMPONENT-752;Lo;0;L;;;;;N;;;;;
+18AF0;TANGUT COMPONENT-753;Lo;0;L;;;;;N;;;;;
+18AF1;TANGUT COMPONENT-754;Lo;0;L;;;;;N;;;;;
+18AF2;TANGUT COMPONENT-755;Lo;0;L;;;;;N;;;;;
+18AF3;TANGUT COMPONENT-756;Lo;0;L;;;;;N;;;;;
+18AF4;TANGUT COMPONENT-757;Lo;0;L;;;;;N;;;;;
+18AF5;TANGUT COMPONENT-758;Lo;0;L;;;;;N;;;;;
+18AF6;TANGUT COMPONENT-759;Lo;0;L;;;;;N;;;;;
+18AF7;TANGUT COMPONENT-760;Lo;0;L;;;;;N;;;;;
+18AF8;TANGUT COMPONENT-761;Lo;0;L;;;;;N;;;;;
+18AF9;TANGUT COMPONENT-762;Lo;0;L;;;;;N;;;;;
+18AFA;TANGUT COMPONENT-763;Lo;0;L;;;;;N;;;;;
+18AFB;TANGUT COMPONENT-764;Lo;0;L;;;;;N;;;;;
+18AFC;TANGUT COMPONENT-765;Lo;0;L;;;;;N;;;;;
+18AFD;TANGUT COMPONENT-766;Lo;0;L;;;;;N;;;;;
+18AFE;TANGUT COMPONENT-767;Lo;0;L;;;;;N;;;;;
+18AFF;TANGUT COMPONENT-768;Lo;0;L;;;;;N;;;;;
+18B00;KHITAN SMALL SCRIPT CHARACTER-18B00;Lo;0;L;;;;;N;;;;;
+18B01;KHITAN SMALL SCRIPT CHARACTER-18B01;Lo;0;L;;;;;N;;;;;
+18B02;KHITAN SMALL SCRIPT CHARACTER-18B02;Lo;0;L;;;;;N;;;;;
+18B03;KHITAN SMALL SCRIPT CHARACTER-18B03;Lo;0;L;;;;;N;;;;;
+18B04;KHITAN SMALL SCRIPT CHARACTER-18B04;Lo;0;L;;;;;N;;;;;
+18B05;KHITAN SMALL SCRIPT CHARACTER-18B05;Lo;0;L;;;;;N;;;;;
+18B06;KHITAN SMALL SCRIPT CHARACTER-18B06;Lo;0;L;;;;;N;;;;;
+18B07;KHITAN SMALL SCRIPT CHARACTER-18B07;Lo;0;L;;;;;N;;;;;
+18B08;KHITAN SMALL SCRIPT CHARACTER-18B08;Lo;0;L;;;;;N;;;;;
+18B09;KHITAN SMALL SCRIPT CHARACTER-18B09;Lo;0;L;;;;;N;;;;;
+18B0A;KHITAN SMALL SCRIPT CHARACTER-18B0A;Lo;0;L;;;;;N;;;;;
+18B0B;KHITAN SMALL SCRIPT CHARACTER-18B0B;Lo;0;L;;;;;N;;;;;
+18B0C;KHITAN SMALL SCRIPT CHARACTER-18B0C;Lo;0;L;;;;;N;;;;;
+18B0D;KHITAN SMALL SCRIPT CHARACTER-18B0D;Lo;0;L;;;;;N;;;;;
+18B0E;KHITAN SMALL SCRIPT CHARACTER-18B0E;Lo;0;L;;;;;N;;;;;
+18B0F;KHITAN SMALL SCRIPT CHARACTER-18B0F;Lo;0;L;;;;;N;;;;;
+18B10;KHITAN SMALL SCRIPT CHARACTER-18B10;Lo;0;L;;;;;N;;;;;
+18B11;KHITAN SMALL SCRIPT CHARACTER-18B11;Lo;0;L;;;;;N;;;;;
+18B12;KHITAN SMALL SCRIPT CHARACTER-18B12;Lo;0;L;;;;;N;;;;;
+18B13;KHITAN SMALL SCRIPT CHARACTER-18B13;Lo;0;L;;;;;N;;;;;
+18B14;KHITAN SMALL SCRIPT CHARACTER-18B14;Lo;0;L;;;;;N;;;;;
+18B15;KHITAN SMALL SCRIPT CHARACTER-18B15;Lo;0;L;;;;;N;;;;;
+18B16;KHITAN SMALL SCRIPT CHARACTER-18B16;Lo;0;L;;;;;N;;;;;
+18B17;KHITAN SMALL SCRIPT CHARACTER-18B17;Lo;0;L;;;;;N;;;;;
+18B18;KHITAN SMALL SCRIPT CHARACTER-18B18;Lo;0;L;;;;;N;;;;;
+18B19;KHITAN SMALL SCRIPT CHARACTER-18B19;Lo;0;L;;;;;N;;;;;
+18B1A;KHITAN SMALL SCRIPT CHARACTER-18B1A;Lo;0;L;;;;;N;;;;;
+18B1B;KHITAN SMALL SCRIPT CHARACTER-18B1B;Lo;0;L;;;;;N;;;;;
+18B1C;KHITAN SMALL SCRIPT CHARACTER-18B1C;Lo;0;L;;;;;N;;;;;
+18B1D;KHITAN SMALL SCRIPT CHARACTER-18B1D;Lo;0;L;;;;;N;;;;;
+18B1E;KHITAN SMALL SCRIPT CHARACTER-18B1E;Lo;0;L;;;;;N;;;;;
+18B1F;KHITAN SMALL SCRIPT CHARACTER-18B1F;Lo;0;L;;;;;N;;;;;
+18B20;KHITAN SMALL SCRIPT CHARACTER-18B20;Lo;0;L;;;;;N;;;;;
+18B21;KHITAN SMALL SCRIPT CHARACTER-18B21;Lo;0;L;;;;;N;;;;;
+18B22;KHITAN SMALL SCRIPT CHARACTER-18B22;Lo;0;L;;;;;N;;;;;
+18B23;KHITAN SMALL SCRIPT CHARACTER-18B23;Lo;0;L;;;;;N;;;;;
+18B24;KHITAN SMALL SCRIPT CHARACTER-18B24;Lo;0;L;;;;;N;;;;;
+18B25;KHITAN SMALL SCRIPT CHARACTER-18B25;Lo;0;L;;;;;N;;;;;
+18B26;KHITAN SMALL SCRIPT CHARACTER-18B26;Lo;0;L;;;;;N;;;;;
+18B27;KHITAN SMALL SCRIPT CHARACTER-18B27;Lo;0;L;;;;;N;;;;;
+18B28;KHITAN SMALL SCRIPT CHARACTER-18B28;Lo;0;L;;;;;N;;;;;
+18B29;KHITAN SMALL SCRIPT CHARACTER-18B29;Lo;0;L;;;;;N;;;;;
+18B2A;KHITAN SMALL SCRIPT CHARACTER-18B2A;Lo;0;L;;;;;N;;;;;
+18B2B;KHITAN SMALL SCRIPT CHARACTER-18B2B;Lo;0;L;;;;;N;;;;;
+18B2C;KHITAN SMALL SCRIPT CHARACTER-18B2C;Lo;0;L;;;;;N;;;;;
+18B2D;KHITAN SMALL SCRIPT CHARACTER-18B2D;Lo;0;L;;;;;N;;;;;
+18B2E;KHITAN SMALL SCRIPT CHARACTER-18B2E;Lo;0;L;;;;;N;;;;;
+18B2F;KHITAN SMALL SCRIPT CHARACTER-18B2F;Lo;0;L;;;;;N;;;;;
+18B30;KHITAN SMALL SCRIPT CHARACTER-18B30;Lo;0;L;;;;;N;;;;;
+18B31;KHITAN SMALL SCRIPT CHARACTER-18B31;Lo;0;L;;;;;N;;;;;
+18B32;KHITAN SMALL SCRIPT CHARACTER-18B32;Lo;0;L;;;;;N;;;;;
+18B33;KHITAN SMALL SCRIPT CHARACTER-18B33;Lo;0;L;;;;;N;;;;;
+18B34;KHITAN SMALL SCRIPT CHARACTER-18B34;Lo;0;L;;;;;N;;;;;
+18B35;KHITAN SMALL SCRIPT CHARACTER-18B35;Lo;0;L;;;;;N;;;;;
+18B36;KHITAN SMALL SCRIPT CHARACTER-18B36;Lo;0;L;;;;;N;;;;;
+18B37;KHITAN SMALL SCRIPT CHARACTER-18B37;Lo;0;L;;;;;N;;;;;
+18B38;KHITAN SMALL SCRIPT CHARACTER-18B38;Lo;0;L;;;;;N;;;;;
+18B39;KHITAN SMALL SCRIPT CHARACTER-18B39;Lo;0;L;;;;;N;;;;;
+18B3A;KHITAN SMALL SCRIPT CHARACTER-18B3A;Lo;0;L;;;;;N;;;;;
+18B3B;KHITAN SMALL SCRIPT CHARACTER-18B3B;Lo;0;L;;;;;N;;;;;
+18B3C;KHITAN SMALL SCRIPT CHARACTER-18B3C;Lo;0;L;;;;;N;;;;;
+18B3D;KHITAN SMALL SCRIPT CHARACTER-18B3D;Lo;0;L;;;;;N;;;;;
+18B3E;KHITAN SMALL SCRIPT CHARACTER-18B3E;Lo;0;L;;;;;N;;;;;
+18B3F;KHITAN SMALL SCRIPT CHARACTER-18B3F;Lo;0;L;;;;;N;;;;;
+18B40;KHITAN SMALL SCRIPT CHARACTER-18B40;Lo;0;L;;;;;N;;;;;
+18B41;KHITAN SMALL SCRIPT CHARACTER-18B41;Lo;0;L;;;;;N;;;;;
+18B42;KHITAN SMALL SCRIPT CHARACTER-18B42;Lo;0;L;;;;;N;;;;;
+18B43;KHITAN SMALL SCRIPT CHARACTER-18B43;Lo;0;L;;;;;N;;;;;
+18B44;KHITAN SMALL SCRIPT CHARACTER-18B44;Lo;0;L;;;;;N;;;;;
+18B45;KHITAN SMALL SCRIPT CHARACTER-18B45;Lo;0;L;;;;;N;;;;;
+18B46;KHITAN SMALL SCRIPT CHARACTER-18B46;Lo;0;L;;;;;N;;;;;
+18B47;KHITAN SMALL SCRIPT CHARACTER-18B47;Lo;0;L;;;;;N;;;;;
+18B48;KHITAN SMALL SCRIPT CHARACTER-18B48;Lo;0;L;;;;;N;;;;;
+18B49;KHITAN SMALL SCRIPT CHARACTER-18B49;Lo;0;L;;;;;N;;;;;
+18B4A;KHITAN SMALL SCRIPT CHARACTER-18B4A;Lo;0;L;;;;;N;;;;;
+18B4B;KHITAN SMALL SCRIPT CHARACTER-18B4B;Lo;0;L;;;;;N;;;;;
+18B4C;KHITAN SMALL SCRIPT CHARACTER-18B4C;Lo;0;L;;;;;N;;;;;
+18B4D;KHITAN SMALL SCRIPT CHARACTER-18B4D;Lo;0;L;;;;;N;;;;;
+18B4E;KHITAN SMALL SCRIPT CHARACTER-18B4E;Lo;0;L;;;;;N;;;;;
+18B4F;KHITAN SMALL SCRIPT CHARACTER-18B4F;Lo;0;L;;;;;N;;;;;
+18B50;KHITAN SMALL SCRIPT CHARACTER-18B50;Lo;0;L;;;;;N;;;;;
+18B51;KHITAN SMALL SCRIPT CHARACTER-18B51;Lo;0;L;;;;;N;;;;;
+18B52;KHITAN SMALL SCRIPT CHARACTER-18B52;Lo;0;L;;;;;N;;;;;
+18B53;KHITAN SMALL SCRIPT CHARACTER-18B53;Lo;0;L;;;;;N;;;;;
+18B54;KHITAN SMALL SCRIPT CHARACTER-18B54;Lo;0;L;;;;;N;;;;;
+18B55;KHITAN SMALL SCRIPT CHARACTER-18B55;Lo;0;L;;;;;N;;;;;
+18B56;KHITAN SMALL SCRIPT CHARACTER-18B56;Lo;0;L;;;;;N;;;;;
+18B57;KHITAN SMALL SCRIPT CHARACTER-18B57;Lo;0;L;;;;;N;;;;;
+18B58;KHITAN SMALL SCRIPT CHARACTER-18B58;Lo;0;L;;;;;N;;;;;
+18B59;KHITAN SMALL SCRIPT CHARACTER-18B59;Lo;0;L;;;;;N;;;;;
+18B5A;KHITAN SMALL SCRIPT CHARACTER-18B5A;Lo;0;L;;;;;N;;;;;
+18B5B;KHITAN SMALL SCRIPT CHARACTER-18B5B;Lo;0;L;;;;;N;;;;;
+18B5C;KHITAN SMALL SCRIPT CHARACTER-18B5C;Lo;0;L;;;;;N;;;;;
+18B5D;KHITAN SMALL SCRIPT CHARACTER-18B5D;Lo;0;L;;;;;N;;;;;
+18B5E;KHITAN SMALL SCRIPT CHARACTER-18B5E;Lo;0;L;;;;;N;;;;;
+18B5F;KHITAN SMALL SCRIPT CHARACTER-18B5F;Lo;0;L;;;;;N;;;;;
+18B60;KHITAN SMALL SCRIPT CHARACTER-18B60;Lo;0;L;;;;;N;;;;;
+18B61;KHITAN SMALL SCRIPT CHARACTER-18B61;Lo;0;L;;;;;N;;;;;
+18B62;KHITAN SMALL SCRIPT CHARACTER-18B62;Lo;0;L;;;;;N;;;;;
+18B63;KHITAN SMALL SCRIPT CHARACTER-18B63;Lo;0;L;;;;;N;;;;;
+18B64;KHITAN SMALL SCRIPT CHARACTER-18B64;Lo;0;L;;;;;N;;;;;
+18B65;KHITAN SMALL SCRIPT CHARACTER-18B65;Lo;0;L;;;;;N;;;;;
+18B66;KHITAN SMALL SCRIPT CHARACTER-18B66;Lo;0;L;;;;;N;;;;;
+18B67;KHITAN SMALL SCRIPT CHARACTER-18B67;Lo;0;L;;;;;N;;;;;
+18B68;KHITAN SMALL SCRIPT CHARACTER-18B68;Lo;0;L;;;;;N;;;;;
+18B69;KHITAN SMALL SCRIPT CHARACTER-18B69;Lo;0;L;;;;;N;;;;;
+18B6A;KHITAN SMALL SCRIPT CHARACTER-18B6A;Lo;0;L;;;;;N;;;;;
+18B6B;KHITAN SMALL SCRIPT CHARACTER-18B6B;Lo;0;L;;;;;N;;;;;
+18B6C;KHITAN SMALL SCRIPT CHARACTER-18B6C;Lo;0;L;;;;;N;;;;;
+18B6D;KHITAN SMALL SCRIPT CHARACTER-18B6D;Lo;0;L;;;;;N;;;;;
+18B6E;KHITAN SMALL SCRIPT CHARACTER-18B6E;Lo;0;L;;;;;N;;;;;
+18B6F;KHITAN SMALL SCRIPT CHARACTER-18B6F;Lo;0;L;;;;;N;;;;;
+18B70;KHITAN SMALL SCRIPT CHARACTER-18B70;Lo;0;L;;;;;N;;;;;
+18B71;KHITAN SMALL SCRIPT CHARACTER-18B71;Lo;0;L;;;;;N;;;;;
+18B72;KHITAN SMALL SCRIPT CHARACTER-18B72;Lo;0;L;;;;;N;;;;;
+18B73;KHITAN SMALL SCRIPT CHARACTER-18B73;Lo;0;L;;;;;N;;;;;
+18B74;KHITAN SMALL SCRIPT CHARACTER-18B74;Lo;0;L;;;;;N;;;;;
+18B75;KHITAN SMALL SCRIPT CHARACTER-18B75;Lo;0;L;;;;;N;;;;;
+18B76;KHITAN SMALL SCRIPT CHARACTER-18B76;Lo;0;L;;;;;N;;;;;
+18B77;KHITAN SMALL SCRIPT CHARACTER-18B77;Lo;0;L;;;;;N;;;;;
+18B78;KHITAN SMALL SCRIPT CHARACTER-18B78;Lo;0;L;;;;;N;;;;;
+18B79;KHITAN SMALL SCRIPT CHARACTER-18B79;Lo;0;L;;;;;N;;;;;
+18B7A;KHITAN SMALL SCRIPT CHARACTER-18B7A;Lo;0;L;;;;;N;;;;;
+18B7B;KHITAN SMALL SCRIPT CHARACTER-18B7B;Lo;0;L;;;;;N;;;;;
+18B7C;KHITAN SMALL SCRIPT CHARACTER-18B7C;Lo;0;L;;;;;N;;;;;
+18B7D;KHITAN SMALL SCRIPT CHARACTER-18B7D;Lo;0;L;;;;;N;;;;;
+18B7E;KHITAN SMALL SCRIPT CHARACTER-18B7E;Lo;0;L;;;;;N;;;;;
+18B7F;KHITAN SMALL SCRIPT CHARACTER-18B7F;Lo;0;L;;;;;N;;;;;
+18B80;KHITAN SMALL SCRIPT CHARACTER-18B80;Lo;0;L;;;;;N;;;;;
+18B81;KHITAN SMALL SCRIPT CHARACTER-18B81;Lo;0;L;;;;;N;;;;;
+18B82;KHITAN SMALL SCRIPT CHARACTER-18B82;Lo;0;L;;;;;N;;;;;
+18B83;KHITAN SMALL SCRIPT CHARACTER-18B83;Lo;0;L;;;;;N;;;;;
+18B84;KHITAN SMALL SCRIPT CHARACTER-18B84;Lo;0;L;;;;;N;;;;;
+18B85;KHITAN SMALL SCRIPT CHARACTER-18B85;Lo;0;L;;;;;N;;;;;
+18B86;KHITAN SMALL SCRIPT CHARACTER-18B86;Lo;0;L;;;;;N;;;;;
+18B87;KHITAN SMALL SCRIPT CHARACTER-18B87;Lo;0;L;;;;;N;;;;;
+18B88;KHITAN SMALL SCRIPT CHARACTER-18B88;Lo;0;L;;;;;N;;;;;
+18B89;KHITAN SMALL SCRIPT CHARACTER-18B89;Lo;0;L;;;;;N;;;;;
+18B8A;KHITAN SMALL SCRIPT CHARACTER-18B8A;Lo;0;L;;;;;N;;;;;
+18B8B;KHITAN SMALL SCRIPT CHARACTER-18B8B;Lo;0;L;;;;;N;;;;;
+18B8C;KHITAN SMALL SCRIPT CHARACTER-18B8C;Lo;0;L;;;;;N;;;;;
+18B8D;KHITAN SMALL SCRIPT CHARACTER-18B8D;Lo;0;L;;;;;N;;;;;
+18B8E;KHITAN SMALL SCRIPT CHARACTER-18B8E;Lo;0;L;;;;;N;;;;;
+18B8F;KHITAN SMALL SCRIPT CHARACTER-18B8F;Lo;0;L;;;;;N;;;;;
+18B90;KHITAN SMALL SCRIPT CHARACTER-18B90;Lo;0;L;;;;;N;;;;;
+18B91;KHITAN SMALL SCRIPT CHARACTER-18B91;Lo;0;L;;;;;N;;;;;
+18B92;KHITAN SMALL SCRIPT CHARACTER-18B92;Lo;0;L;;;;;N;;;;;
+18B93;KHITAN SMALL SCRIPT CHARACTER-18B93;Lo;0;L;;;;;N;;;;;
+18B94;KHITAN SMALL SCRIPT CHARACTER-18B94;Lo;0;L;;;;;N;;;;;
+18B95;KHITAN SMALL SCRIPT CHARACTER-18B95;Lo;0;L;;;;;N;;;;;
+18B96;KHITAN SMALL SCRIPT CHARACTER-18B96;Lo;0;L;;;;;N;;;;;
+18B97;KHITAN SMALL SCRIPT CHARACTER-18B97;Lo;0;L;;;;;N;;;;;
+18B98;KHITAN SMALL SCRIPT CHARACTER-18B98;Lo;0;L;;;;;N;;;;;
+18B99;KHITAN SMALL SCRIPT CHARACTER-18B99;Lo;0;L;;;;;N;;;;;
+18B9A;KHITAN SMALL SCRIPT CHARACTER-18B9A;Lo;0;L;;;;;N;;;;;
+18B9B;KHITAN SMALL SCRIPT CHARACTER-18B9B;Lo;0;L;;;;;N;;;;;
+18B9C;KHITAN SMALL SCRIPT CHARACTER-18B9C;Lo;0;L;;;;;N;;;;;
+18B9D;KHITAN SMALL SCRIPT CHARACTER-18B9D;Lo;0;L;;;;;N;;;;;
+18B9E;KHITAN SMALL SCRIPT CHARACTER-18B9E;Lo;0;L;;;;;N;;;;;
+18B9F;KHITAN SMALL SCRIPT CHARACTER-18B9F;Lo;0;L;;;;;N;;;;;
+18BA0;KHITAN SMALL SCRIPT CHARACTER-18BA0;Lo;0;L;;;;;N;;;;;
+18BA1;KHITAN SMALL SCRIPT CHARACTER-18BA1;Lo;0;L;;;;;N;;;;;
+18BA2;KHITAN SMALL SCRIPT CHARACTER-18BA2;Lo;0;L;;;;;N;;;;;
+18BA3;KHITAN SMALL SCRIPT CHARACTER-18BA3;Lo;0;L;;;;;N;;;;;
+18BA4;KHITAN SMALL SCRIPT CHARACTER-18BA4;Lo;0;L;;;;;N;;;;;
+18BA5;KHITAN SMALL SCRIPT CHARACTER-18BA5;Lo;0;L;;;;;N;;;;;
+18BA6;KHITAN SMALL SCRIPT CHARACTER-18BA6;Lo;0;L;;;;;N;;;;;
+18BA7;KHITAN SMALL SCRIPT CHARACTER-18BA7;Lo;0;L;;;;;N;;;;;
+18BA8;KHITAN SMALL SCRIPT CHARACTER-18BA8;Lo;0;L;;;;;N;;;;;
+18BA9;KHITAN SMALL SCRIPT CHARACTER-18BA9;Lo;0;L;;;;;N;;;;;
+18BAA;KHITAN SMALL SCRIPT CHARACTER-18BAA;Lo;0;L;;;;;N;;;;;
+18BAB;KHITAN SMALL SCRIPT CHARACTER-18BAB;Lo;0;L;;;;;N;;;;;
+18BAC;KHITAN SMALL SCRIPT CHARACTER-18BAC;Lo;0;L;;;;;N;;;;;
+18BAD;KHITAN SMALL SCRIPT CHARACTER-18BAD;Lo;0;L;;;;;N;;;;;
+18BAE;KHITAN SMALL SCRIPT CHARACTER-18BAE;Lo;0;L;;;;;N;;;;;
+18BAF;KHITAN SMALL SCRIPT CHARACTER-18BAF;Lo;0;L;;;;;N;;;;;
+18BB0;KHITAN SMALL SCRIPT CHARACTER-18BB0;Lo;0;L;;;;;N;;;;;
+18BB1;KHITAN SMALL SCRIPT CHARACTER-18BB1;Lo;0;L;;;;;N;;;;;
+18BB2;KHITAN SMALL SCRIPT CHARACTER-18BB2;Lo;0;L;;;;;N;;;;;
+18BB3;KHITAN SMALL SCRIPT CHARACTER-18BB3;Lo;0;L;;;;;N;;;;;
+18BB4;KHITAN SMALL SCRIPT CHARACTER-18BB4;Lo;0;L;;;;;N;;;;;
+18BB5;KHITAN SMALL SCRIPT CHARACTER-18BB5;Lo;0;L;;;;;N;;;;;
+18BB6;KHITAN SMALL SCRIPT CHARACTER-18BB6;Lo;0;L;;;;;N;;;;;
+18BB7;KHITAN SMALL SCRIPT CHARACTER-18BB7;Lo;0;L;;;;;N;;;;;
+18BB8;KHITAN SMALL SCRIPT CHARACTER-18BB8;Lo;0;L;;;;;N;;;;;
+18BB9;KHITAN SMALL SCRIPT CHARACTER-18BB9;Lo;0;L;;;;;N;;;;;
+18BBA;KHITAN SMALL SCRIPT CHARACTER-18BBA;Lo;0;L;;;;;N;;;;;
+18BBB;KHITAN SMALL SCRIPT CHARACTER-18BBB;Lo;0;L;;;;;N;;;;;
+18BBC;KHITAN SMALL SCRIPT CHARACTER-18BBC;Lo;0;L;;;;;N;;;;;
+18BBD;KHITAN SMALL SCRIPT CHARACTER-18BBD;Lo;0;L;;;;;N;;;;;
+18BBE;KHITAN SMALL SCRIPT CHARACTER-18BBE;Lo;0;L;;;;;N;;;;;
+18BBF;KHITAN SMALL SCRIPT CHARACTER-18BBF;Lo;0;L;;;;;N;;;;;
+18BC0;KHITAN SMALL SCRIPT CHARACTER-18BC0;Lo;0;L;;;;;N;;;;;
+18BC1;KHITAN SMALL SCRIPT CHARACTER-18BC1;Lo;0;L;;;;;N;;;;;
+18BC2;KHITAN SMALL SCRIPT CHARACTER-18BC2;Lo;0;L;;;;;N;;;;;
+18BC3;KHITAN SMALL SCRIPT CHARACTER-18BC3;Lo;0;L;;;;;N;;;;;
+18BC4;KHITAN SMALL SCRIPT CHARACTER-18BC4;Lo;0;L;;;;;N;;;;;
+18BC5;KHITAN SMALL SCRIPT CHARACTER-18BC5;Lo;0;L;;;;;N;;;;;
+18BC6;KHITAN SMALL SCRIPT CHARACTER-18BC6;Lo;0;L;;;;;N;;;;;
+18BC7;KHITAN SMALL SCRIPT CHARACTER-18BC7;Lo;0;L;;;;;N;;;;;
+18BC8;KHITAN SMALL SCRIPT CHARACTER-18BC8;Lo;0;L;;;;;N;;;;;
+18BC9;KHITAN SMALL SCRIPT CHARACTER-18BC9;Lo;0;L;;;;;N;;;;;
+18BCA;KHITAN SMALL SCRIPT CHARACTER-18BCA;Lo;0;L;;;;;N;;;;;
+18BCB;KHITAN SMALL SCRIPT CHARACTER-18BCB;Lo;0;L;;;;;N;;;;;
+18BCC;KHITAN SMALL SCRIPT CHARACTER-18BCC;Lo;0;L;;;;;N;;;;;
+18BCD;KHITAN SMALL SCRIPT CHARACTER-18BCD;Lo;0;L;;;;;N;;;;;
+18BCE;KHITAN SMALL SCRIPT CHARACTER-18BCE;Lo;0;L;;;;;N;;;;;
+18BCF;KHITAN SMALL SCRIPT CHARACTER-18BCF;Lo;0;L;;;;;N;;;;;
+18BD0;KHITAN SMALL SCRIPT CHARACTER-18BD0;Lo;0;L;;;;;N;;;;;
+18BD1;KHITAN SMALL SCRIPT CHARACTER-18BD1;Lo;0;L;;;;;N;;;;;
+18BD2;KHITAN SMALL SCRIPT CHARACTER-18BD2;Lo;0;L;;;;;N;;;;;
+18BD3;KHITAN SMALL SCRIPT CHARACTER-18BD3;Lo;0;L;;;;;N;;;;;
+18BD4;KHITAN SMALL SCRIPT CHARACTER-18BD4;Lo;0;L;;;;;N;;;;;
+18BD5;KHITAN SMALL SCRIPT CHARACTER-18BD5;Lo;0;L;;;;;N;;;;;
+18BD6;KHITAN SMALL SCRIPT CHARACTER-18BD6;Lo;0;L;;;;;N;;;;;
+18BD7;KHITAN SMALL SCRIPT CHARACTER-18BD7;Lo;0;L;;;;;N;;;;;
+18BD8;KHITAN SMALL SCRIPT CHARACTER-18BD8;Lo;0;L;;;;;N;;;;;
+18BD9;KHITAN SMALL SCRIPT CHARACTER-18BD9;Lo;0;L;;;;;N;;;;;
+18BDA;KHITAN SMALL SCRIPT CHARACTER-18BDA;Lo;0;L;;;;;N;;;;;
+18BDB;KHITAN SMALL SCRIPT CHARACTER-18BDB;Lo;0;L;;;;;N;;;;;
+18BDC;KHITAN SMALL SCRIPT CHARACTER-18BDC;Lo;0;L;;;;;N;;;;;
+18BDD;KHITAN SMALL SCRIPT CHARACTER-18BDD;Lo;0;L;;;;;N;;;;;
+18BDE;KHITAN SMALL SCRIPT CHARACTER-18BDE;Lo;0;L;;;;;N;;;;;
+18BDF;KHITAN SMALL SCRIPT CHARACTER-18BDF;Lo;0;L;;;;;N;;;;;
+18BE0;KHITAN SMALL SCRIPT CHARACTER-18BE0;Lo;0;L;;;;;N;;;;;
+18BE1;KHITAN SMALL SCRIPT CHARACTER-18BE1;Lo;0;L;;;;;N;;;;;
+18BE2;KHITAN SMALL SCRIPT CHARACTER-18BE2;Lo;0;L;;;;;N;;;;;
+18BE3;KHITAN SMALL SCRIPT CHARACTER-18BE3;Lo;0;L;;;;;N;;;;;
+18BE4;KHITAN SMALL SCRIPT CHARACTER-18BE4;Lo;0;L;;;;;N;;;;;
+18BE5;KHITAN SMALL SCRIPT CHARACTER-18BE5;Lo;0;L;;;;;N;;;;;
+18BE6;KHITAN SMALL SCRIPT CHARACTER-18BE6;Lo;0;L;;;;;N;;;;;
+18BE7;KHITAN SMALL SCRIPT CHARACTER-18BE7;Lo;0;L;;;;;N;;;;;
+18BE8;KHITAN SMALL SCRIPT CHARACTER-18BE8;Lo;0;L;;;;;N;;;;;
+18BE9;KHITAN SMALL SCRIPT CHARACTER-18BE9;Lo;0;L;;;;;N;;;;;
+18BEA;KHITAN SMALL SCRIPT CHARACTER-18BEA;Lo;0;L;;;;;N;;;;;
+18BEB;KHITAN SMALL SCRIPT CHARACTER-18BEB;Lo;0;L;;;;;N;;;;;
+18BEC;KHITAN SMALL SCRIPT CHARACTER-18BEC;Lo;0;L;;;;;N;;;;;
+18BED;KHITAN SMALL SCRIPT CHARACTER-18BED;Lo;0;L;;;;;N;;;;;
+18BEE;KHITAN SMALL SCRIPT CHARACTER-18BEE;Lo;0;L;;;;;N;;;;;
+18BEF;KHITAN SMALL SCRIPT CHARACTER-18BEF;Lo;0;L;;;;;N;;;;;
+18BF0;KHITAN SMALL SCRIPT CHARACTER-18BF0;Lo;0;L;;;;;N;;;;;
+18BF1;KHITAN SMALL SCRIPT CHARACTER-18BF1;Lo;0;L;;;;;N;;;;;
+18BF2;KHITAN SMALL SCRIPT CHARACTER-18BF2;Lo;0;L;;;;;N;;;;;
+18BF3;KHITAN SMALL SCRIPT CHARACTER-18BF3;Lo;0;L;;;;;N;;;;;
+18BF4;KHITAN SMALL SCRIPT CHARACTER-18BF4;Lo;0;L;;;;;N;;;;;
+18BF5;KHITAN SMALL SCRIPT CHARACTER-18BF5;Lo;0;L;;;;;N;;;;;
+18BF6;KHITAN SMALL SCRIPT CHARACTER-18BF6;Lo;0;L;;;;;N;;;;;
+18BF7;KHITAN SMALL SCRIPT CHARACTER-18BF7;Lo;0;L;;;;;N;;;;;
+18BF8;KHITAN SMALL SCRIPT CHARACTER-18BF8;Lo;0;L;;;;;N;;;;;
+18BF9;KHITAN SMALL SCRIPT CHARACTER-18BF9;Lo;0;L;;;;;N;;;;;
+18BFA;KHITAN SMALL SCRIPT CHARACTER-18BFA;Lo;0;L;;;;;N;;;;;
+18BFB;KHITAN SMALL SCRIPT CHARACTER-18BFB;Lo;0;L;;;;;N;;;;;
+18BFC;KHITAN SMALL SCRIPT CHARACTER-18BFC;Lo;0;L;;;;;N;;;;;
+18BFD;KHITAN SMALL SCRIPT CHARACTER-18BFD;Lo;0;L;;;;;N;;;;;
+18BFE;KHITAN SMALL SCRIPT CHARACTER-18BFE;Lo;0;L;;;;;N;;;;;
+18BFF;KHITAN SMALL SCRIPT CHARACTER-18BFF;Lo;0;L;;;;;N;;;;;
+18C00;KHITAN SMALL SCRIPT CHARACTER-18C00;Lo;0;L;;;;;N;;;;;
+18C01;KHITAN SMALL SCRIPT CHARACTER-18C01;Lo;0;L;;;;;N;;;;;
+18C02;KHITAN SMALL SCRIPT CHARACTER-18C02;Lo;0;L;;;;;N;;;;;
+18C03;KHITAN SMALL SCRIPT CHARACTER-18C03;Lo;0;L;;;;;N;;;;;
+18C04;KHITAN SMALL SCRIPT CHARACTER-18C04;Lo;0;L;;;;;N;;;;;
+18C05;KHITAN SMALL SCRIPT CHARACTER-18C05;Lo;0;L;;;;;N;;;;;
+18C06;KHITAN SMALL SCRIPT CHARACTER-18C06;Lo;0;L;;;;;N;;;;;
+18C07;KHITAN SMALL SCRIPT CHARACTER-18C07;Lo;0;L;;;;;N;;;;;
+18C08;KHITAN SMALL SCRIPT CHARACTER-18C08;Lo;0;L;;;;;N;;;;;
+18C09;KHITAN SMALL SCRIPT CHARACTER-18C09;Lo;0;L;;;;;N;;;;;
+18C0A;KHITAN SMALL SCRIPT CHARACTER-18C0A;Lo;0;L;;;;;N;;;;;
+18C0B;KHITAN SMALL SCRIPT CHARACTER-18C0B;Lo;0;L;;;;;N;;;;;
+18C0C;KHITAN SMALL SCRIPT CHARACTER-18C0C;Lo;0;L;;;;;N;;;;;
+18C0D;KHITAN SMALL SCRIPT CHARACTER-18C0D;Lo;0;L;;;;;N;;;;;
+18C0E;KHITAN SMALL SCRIPT CHARACTER-18C0E;Lo;0;L;;;;;N;;;;;
+18C0F;KHITAN SMALL SCRIPT CHARACTER-18C0F;Lo;0;L;;;;;N;;;;;
+18C10;KHITAN SMALL SCRIPT CHARACTER-18C10;Lo;0;L;;;;;N;;;;;
+18C11;KHITAN SMALL SCRIPT CHARACTER-18C11;Lo;0;L;;;;;N;;;;;
+18C12;KHITAN SMALL SCRIPT CHARACTER-18C12;Lo;0;L;;;;;N;;;;;
+18C13;KHITAN SMALL SCRIPT CHARACTER-18C13;Lo;0;L;;;;;N;;;;;
+18C14;KHITAN SMALL SCRIPT CHARACTER-18C14;Lo;0;L;;;;;N;;;;;
+18C15;KHITAN SMALL SCRIPT CHARACTER-18C15;Lo;0;L;;;;;N;;;;;
+18C16;KHITAN SMALL SCRIPT CHARACTER-18C16;Lo;0;L;;;;;N;;;;;
+18C17;KHITAN SMALL SCRIPT CHARACTER-18C17;Lo;0;L;;;;;N;;;;;
+18C18;KHITAN SMALL SCRIPT CHARACTER-18C18;Lo;0;L;;;;;N;;;;;
+18C19;KHITAN SMALL SCRIPT CHARACTER-18C19;Lo;0;L;;;;;N;;;;;
+18C1A;KHITAN SMALL SCRIPT CHARACTER-18C1A;Lo;0;L;;;;;N;;;;;
+18C1B;KHITAN SMALL SCRIPT CHARACTER-18C1B;Lo;0;L;;;;;N;;;;;
+18C1C;KHITAN SMALL SCRIPT CHARACTER-18C1C;Lo;0;L;;;;;N;;;;;
+18C1D;KHITAN SMALL SCRIPT CHARACTER-18C1D;Lo;0;L;;;;;N;;;;;
+18C1E;KHITAN SMALL SCRIPT CHARACTER-18C1E;Lo;0;L;;;;;N;;;;;
+18C1F;KHITAN SMALL SCRIPT CHARACTER-18C1F;Lo;0;L;;;;;N;;;;;
+18C20;KHITAN SMALL SCRIPT CHARACTER-18C20;Lo;0;L;;;;;N;;;;;
+18C21;KHITAN SMALL SCRIPT CHARACTER-18C21;Lo;0;L;;;;;N;;;;;
+18C22;KHITAN SMALL SCRIPT CHARACTER-18C22;Lo;0;L;;;;;N;;;;;
+18C23;KHITAN SMALL SCRIPT CHARACTER-18C23;Lo;0;L;;;;;N;;;;;
+18C24;KHITAN SMALL SCRIPT CHARACTER-18C24;Lo;0;L;;;;;N;;;;;
+18C25;KHITAN SMALL SCRIPT CHARACTER-18C25;Lo;0;L;;;;;N;;;;;
+18C26;KHITAN SMALL SCRIPT CHARACTER-18C26;Lo;0;L;;;;;N;;;;;
+18C27;KHITAN SMALL SCRIPT CHARACTER-18C27;Lo;0;L;;;;;N;;;;;
+18C28;KHITAN SMALL SCRIPT CHARACTER-18C28;Lo;0;L;;;;;N;;;;;
+18C29;KHITAN SMALL SCRIPT CHARACTER-18C29;Lo;0;L;;;;;N;;;;;
+18C2A;KHITAN SMALL SCRIPT CHARACTER-18C2A;Lo;0;L;;;;;N;;;;;
+18C2B;KHITAN SMALL SCRIPT CHARACTER-18C2B;Lo;0;L;;;;;N;;;;;
+18C2C;KHITAN SMALL SCRIPT CHARACTER-18C2C;Lo;0;L;;;;;N;;;;;
+18C2D;KHITAN SMALL SCRIPT CHARACTER-18C2D;Lo;0;L;;;;;N;;;;;
+18C2E;KHITAN SMALL SCRIPT CHARACTER-18C2E;Lo;0;L;;;;;N;;;;;
+18C2F;KHITAN SMALL SCRIPT CHARACTER-18C2F;Lo;0;L;;;;;N;;;;;
+18C30;KHITAN SMALL SCRIPT CHARACTER-18C30;Lo;0;L;;;;;N;;;;;
+18C31;KHITAN SMALL SCRIPT CHARACTER-18C31;Lo;0;L;;;;;N;;;;;
+18C32;KHITAN SMALL SCRIPT CHARACTER-18C32;Lo;0;L;;;;;N;;;;;
+18C33;KHITAN SMALL SCRIPT CHARACTER-18C33;Lo;0;L;;;;;N;;;;;
+18C34;KHITAN SMALL SCRIPT CHARACTER-18C34;Lo;0;L;;;;;N;;;;;
+18C35;KHITAN SMALL SCRIPT CHARACTER-18C35;Lo;0;L;;;;;N;;;;;
+18C36;KHITAN SMALL SCRIPT CHARACTER-18C36;Lo;0;L;;;;;N;;;;;
+18C37;KHITAN SMALL SCRIPT CHARACTER-18C37;Lo;0;L;;;;;N;;;;;
+18C38;KHITAN SMALL SCRIPT CHARACTER-18C38;Lo;0;L;;;;;N;;;;;
+18C39;KHITAN SMALL SCRIPT CHARACTER-18C39;Lo;0;L;;;;;N;;;;;
+18C3A;KHITAN SMALL SCRIPT CHARACTER-18C3A;Lo;0;L;;;;;N;;;;;
+18C3B;KHITAN SMALL SCRIPT CHARACTER-18C3B;Lo;0;L;;;;;N;;;;;
+18C3C;KHITAN SMALL SCRIPT CHARACTER-18C3C;Lo;0;L;;;;;N;;;;;
+18C3D;KHITAN SMALL SCRIPT CHARACTER-18C3D;Lo;0;L;;;;;N;;;;;
+18C3E;KHITAN SMALL SCRIPT CHARACTER-18C3E;Lo;0;L;;;;;N;;;;;
+18C3F;KHITAN SMALL SCRIPT CHARACTER-18C3F;Lo;0;L;;;;;N;;;;;
+18C40;KHITAN SMALL SCRIPT CHARACTER-18C40;Lo;0;L;;;;;N;;;;;
+18C41;KHITAN SMALL SCRIPT CHARACTER-18C41;Lo;0;L;;;;;N;;;;;
+18C42;KHITAN SMALL SCRIPT CHARACTER-18C42;Lo;0;L;;;;;N;;;;;
+18C43;KHITAN SMALL SCRIPT CHARACTER-18C43;Lo;0;L;;;;;N;;;;;
+18C44;KHITAN SMALL SCRIPT CHARACTER-18C44;Lo;0;L;;;;;N;;;;;
+18C45;KHITAN SMALL SCRIPT CHARACTER-18C45;Lo;0;L;;;;;N;;;;;
+18C46;KHITAN SMALL SCRIPT CHARACTER-18C46;Lo;0;L;;;;;N;;;;;
+18C47;KHITAN SMALL SCRIPT CHARACTER-18C47;Lo;0;L;;;;;N;;;;;
+18C48;KHITAN SMALL SCRIPT CHARACTER-18C48;Lo;0;L;;;;;N;;;;;
+18C49;KHITAN SMALL SCRIPT CHARACTER-18C49;Lo;0;L;;;;;N;;;;;
+18C4A;KHITAN SMALL SCRIPT CHARACTER-18C4A;Lo;0;L;;;;;N;;;;;
+18C4B;KHITAN SMALL SCRIPT CHARACTER-18C4B;Lo;0;L;;;;;N;;;;;
+18C4C;KHITAN SMALL SCRIPT CHARACTER-18C4C;Lo;0;L;;;;;N;;;;;
+18C4D;KHITAN SMALL SCRIPT CHARACTER-18C4D;Lo;0;L;;;;;N;;;;;
+18C4E;KHITAN SMALL SCRIPT CHARACTER-18C4E;Lo;0;L;;;;;N;;;;;
+18C4F;KHITAN SMALL SCRIPT CHARACTER-18C4F;Lo;0;L;;;;;N;;;;;
+18C50;KHITAN SMALL SCRIPT CHARACTER-18C50;Lo;0;L;;;;;N;;;;;
+18C51;KHITAN SMALL SCRIPT CHARACTER-18C51;Lo;0;L;;;;;N;;;;;
+18C52;KHITAN SMALL SCRIPT CHARACTER-18C52;Lo;0;L;;;;;N;;;;;
+18C53;KHITAN SMALL SCRIPT CHARACTER-18C53;Lo;0;L;;;;;N;;;;;
+18C54;KHITAN SMALL SCRIPT CHARACTER-18C54;Lo;0;L;;;;;N;;;;;
+18C55;KHITAN SMALL SCRIPT CHARACTER-18C55;Lo;0;L;;;;;N;;;;;
+18C56;KHITAN SMALL SCRIPT CHARACTER-18C56;Lo;0;L;;;;;N;;;;;
+18C57;KHITAN SMALL SCRIPT CHARACTER-18C57;Lo;0;L;;;;;N;;;;;
+18C58;KHITAN SMALL SCRIPT CHARACTER-18C58;Lo;0;L;;;;;N;;;;;
+18C59;KHITAN SMALL SCRIPT CHARACTER-18C59;Lo;0;L;;;;;N;;;;;
+18C5A;KHITAN SMALL SCRIPT CHARACTER-18C5A;Lo;0;L;;;;;N;;;;;
+18C5B;KHITAN SMALL SCRIPT CHARACTER-18C5B;Lo;0;L;;;;;N;;;;;
+18C5C;KHITAN SMALL SCRIPT CHARACTER-18C5C;Lo;0;L;;;;;N;;;;;
+18C5D;KHITAN SMALL SCRIPT CHARACTER-18C5D;Lo;0;L;;;;;N;;;;;
+18C5E;KHITAN SMALL SCRIPT CHARACTER-18C5E;Lo;0;L;;;;;N;;;;;
+18C5F;KHITAN SMALL SCRIPT CHARACTER-18C5F;Lo;0;L;;;;;N;;;;;
+18C60;KHITAN SMALL SCRIPT CHARACTER-18C60;Lo;0;L;;;;;N;;;;;
+18C61;KHITAN SMALL SCRIPT CHARACTER-18C61;Lo;0;L;;;;;N;;;;;
+18C62;KHITAN SMALL SCRIPT CHARACTER-18C62;Lo;0;L;;;;;N;;;;;
+18C63;KHITAN SMALL SCRIPT CHARACTER-18C63;Lo;0;L;;;;;N;;;;;
+18C64;KHITAN SMALL SCRIPT CHARACTER-18C64;Lo;0;L;;;;;N;;;;;
+18C65;KHITAN SMALL SCRIPT CHARACTER-18C65;Lo;0;L;;;;;N;;;;;
+18C66;KHITAN SMALL SCRIPT CHARACTER-18C66;Lo;0;L;;;;;N;;;;;
+18C67;KHITAN SMALL SCRIPT CHARACTER-18C67;Lo;0;L;;;;;N;;;;;
+18C68;KHITAN SMALL SCRIPT CHARACTER-18C68;Lo;0;L;;;;;N;;;;;
+18C69;KHITAN SMALL SCRIPT CHARACTER-18C69;Lo;0;L;;;;;N;;;;;
+18C6A;KHITAN SMALL SCRIPT CHARACTER-18C6A;Lo;0;L;;;;;N;;;;;
+18C6B;KHITAN SMALL SCRIPT CHARACTER-18C6B;Lo;0;L;;;;;N;;;;;
+18C6C;KHITAN SMALL SCRIPT CHARACTER-18C6C;Lo;0;L;;;;;N;;;;;
+18C6D;KHITAN SMALL SCRIPT CHARACTER-18C6D;Lo;0;L;;;;;N;;;;;
+18C6E;KHITAN SMALL SCRIPT CHARACTER-18C6E;Lo;0;L;;;;;N;;;;;
+18C6F;KHITAN SMALL SCRIPT CHARACTER-18C6F;Lo;0;L;;;;;N;;;;;
+18C70;KHITAN SMALL SCRIPT CHARACTER-18C70;Lo;0;L;;;;;N;;;;;
+18C71;KHITAN SMALL SCRIPT CHARACTER-18C71;Lo;0;L;;;;;N;;;;;
+18C72;KHITAN SMALL SCRIPT CHARACTER-18C72;Lo;0;L;;;;;N;;;;;
+18C73;KHITAN SMALL SCRIPT CHARACTER-18C73;Lo;0;L;;;;;N;;;;;
+18C74;KHITAN SMALL SCRIPT CHARACTER-18C74;Lo;0;L;;;;;N;;;;;
+18C75;KHITAN SMALL SCRIPT CHARACTER-18C75;Lo;0;L;;;;;N;;;;;
+18C76;KHITAN SMALL SCRIPT CHARACTER-18C76;Lo;0;L;;;;;N;;;;;
+18C77;KHITAN SMALL SCRIPT CHARACTER-18C77;Lo;0;L;;;;;N;;;;;
+18C78;KHITAN SMALL SCRIPT CHARACTER-18C78;Lo;0;L;;;;;N;;;;;
+18C79;KHITAN SMALL SCRIPT CHARACTER-18C79;Lo;0;L;;;;;N;;;;;
+18C7A;KHITAN SMALL SCRIPT CHARACTER-18C7A;Lo;0;L;;;;;N;;;;;
+18C7B;KHITAN SMALL SCRIPT CHARACTER-18C7B;Lo;0;L;;;;;N;;;;;
+18C7C;KHITAN SMALL SCRIPT CHARACTER-18C7C;Lo;0;L;;;;;N;;;;;
+18C7D;KHITAN SMALL SCRIPT CHARACTER-18C7D;Lo;0;L;;;;;N;;;;;
+18C7E;KHITAN SMALL SCRIPT CHARACTER-18C7E;Lo;0;L;;;;;N;;;;;
+18C7F;KHITAN SMALL SCRIPT CHARACTER-18C7F;Lo;0;L;;;;;N;;;;;
+18C80;KHITAN SMALL SCRIPT CHARACTER-18C80;Lo;0;L;;;;;N;;;;;
+18C81;KHITAN SMALL SCRIPT CHARACTER-18C81;Lo;0;L;;;;;N;;;;;
+18C82;KHITAN SMALL SCRIPT CHARACTER-18C82;Lo;0;L;;;;;N;;;;;
+18C83;KHITAN SMALL SCRIPT CHARACTER-18C83;Lo;0;L;;;;;N;;;;;
+18C84;KHITAN SMALL SCRIPT CHARACTER-18C84;Lo;0;L;;;;;N;;;;;
+18C85;KHITAN SMALL SCRIPT CHARACTER-18C85;Lo;0;L;;;;;N;;;;;
+18C86;KHITAN SMALL SCRIPT CHARACTER-18C86;Lo;0;L;;;;;N;;;;;
+18C87;KHITAN SMALL SCRIPT CHARACTER-18C87;Lo;0;L;;;;;N;;;;;
+18C88;KHITAN SMALL SCRIPT CHARACTER-18C88;Lo;0;L;;;;;N;;;;;
+18C89;KHITAN SMALL SCRIPT CHARACTER-18C89;Lo;0;L;;;;;N;;;;;
+18C8A;KHITAN SMALL SCRIPT CHARACTER-18C8A;Lo;0;L;;;;;N;;;;;
+18C8B;KHITAN SMALL SCRIPT CHARACTER-18C8B;Lo;0;L;;;;;N;;;;;
+18C8C;KHITAN SMALL SCRIPT CHARACTER-18C8C;Lo;0;L;;;;;N;;;;;
+18C8D;KHITAN SMALL SCRIPT CHARACTER-18C8D;Lo;0;L;;;;;N;;;;;
+18C8E;KHITAN SMALL SCRIPT CHARACTER-18C8E;Lo;0;L;;;;;N;;;;;
+18C8F;KHITAN SMALL SCRIPT CHARACTER-18C8F;Lo;0;L;;;;;N;;;;;
+18C90;KHITAN SMALL SCRIPT CHARACTER-18C90;Lo;0;L;;;;;N;;;;;
+18C91;KHITAN SMALL SCRIPT CHARACTER-18C91;Lo;0;L;;;;;N;;;;;
+18C92;KHITAN SMALL SCRIPT CHARACTER-18C92;Lo;0;L;;;;;N;;;;;
+18C93;KHITAN SMALL SCRIPT CHARACTER-18C93;Lo;0;L;;;;;N;;;;;
+18C94;KHITAN SMALL SCRIPT CHARACTER-18C94;Lo;0;L;;;;;N;;;;;
+18C95;KHITAN SMALL SCRIPT CHARACTER-18C95;Lo;0;L;;;;;N;;;;;
+18C96;KHITAN SMALL SCRIPT CHARACTER-18C96;Lo;0;L;;;;;N;;;;;
+18C97;KHITAN SMALL SCRIPT CHARACTER-18C97;Lo;0;L;;;;;N;;;;;
+18C98;KHITAN SMALL SCRIPT CHARACTER-18C98;Lo;0;L;;;;;N;;;;;
+18C99;KHITAN SMALL SCRIPT CHARACTER-18C99;Lo;0;L;;;;;N;;;;;
+18C9A;KHITAN SMALL SCRIPT CHARACTER-18C9A;Lo;0;L;;;;;N;;;;;
+18C9B;KHITAN SMALL SCRIPT CHARACTER-18C9B;Lo;0;L;;;;;N;;;;;
+18C9C;KHITAN SMALL SCRIPT CHARACTER-18C9C;Lo;0;L;;;;;N;;;;;
+18C9D;KHITAN SMALL SCRIPT CHARACTER-18C9D;Lo;0;L;;;;;N;;;;;
+18C9E;KHITAN SMALL SCRIPT CHARACTER-18C9E;Lo;0;L;;;;;N;;;;;
+18C9F;KHITAN SMALL SCRIPT CHARACTER-18C9F;Lo;0;L;;;;;N;;;;;
+18CA0;KHITAN SMALL SCRIPT CHARACTER-18CA0;Lo;0;L;;;;;N;;;;;
+18CA1;KHITAN SMALL SCRIPT CHARACTER-18CA1;Lo;0;L;;;;;N;;;;;
+18CA2;KHITAN SMALL SCRIPT CHARACTER-18CA2;Lo;0;L;;;;;N;;;;;
+18CA3;KHITAN SMALL SCRIPT CHARACTER-18CA3;Lo;0;L;;;;;N;;;;;
+18CA4;KHITAN SMALL SCRIPT CHARACTER-18CA4;Lo;0;L;;;;;N;;;;;
+18CA5;KHITAN SMALL SCRIPT CHARACTER-18CA5;Lo;0;L;;;;;N;;;;;
+18CA6;KHITAN SMALL SCRIPT CHARACTER-18CA6;Lo;0;L;;;;;N;;;;;
+18CA7;KHITAN SMALL SCRIPT CHARACTER-18CA7;Lo;0;L;;;;;N;;;;;
+18CA8;KHITAN SMALL SCRIPT CHARACTER-18CA8;Lo;0;L;;;;;N;;;;;
+18CA9;KHITAN SMALL SCRIPT CHARACTER-18CA9;Lo;0;L;;;;;N;;;;;
+18CAA;KHITAN SMALL SCRIPT CHARACTER-18CAA;Lo;0;L;;;;;N;;;;;
+18CAB;KHITAN SMALL SCRIPT CHARACTER-18CAB;Lo;0;L;;;;;N;;;;;
+18CAC;KHITAN SMALL SCRIPT CHARACTER-18CAC;Lo;0;L;;;;;N;;;;;
+18CAD;KHITAN SMALL SCRIPT CHARACTER-18CAD;Lo;0;L;;;;;N;;;;;
+18CAE;KHITAN SMALL SCRIPT CHARACTER-18CAE;Lo;0;L;;;;;N;;;;;
+18CAF;KHITAN SMALL SCRIPT CHARACTER-18CAF;Lo;0;L;;;;;N;;;;;
+18CB0;KHITAN SMALL SCRIPT CHARACTER-18CB0;Lo;0;L;;;;;N;;;;;
+18CB1;KHITAN SMALL SCRIPT CHARACTER-18CB1;Lo;0;L;;;;;N;;;;;
+18CB2;KHITAN SMALL SCRIPT CHARACTER-18CB2;Lo;0;L;;;;;N;;;;;
+18CB3;KHITAN SMALL SCRIPT CHARACTER-18CB3;Lo;0;L;;;;;N;;;;;
+18CB4;KHITAN SMALL SCRIPT CHARACTER-18CB4;Lo;0;L;;;;;N;;;;;
+18CB5;KHITAN SMALL SCRIPT CHARACTER-18CB5;Lo;0;L;;;;;N;;;;;
+18CB6;KHITAN SMALL SCRIPT CHARACTER-18CB6;Lo;0;L;;;;;N;;;;;
+18CB7;KHITAN SMALL SCRIPT CHARACTER-18CB7;Lo;0;L;;;;;N;;;;;
+18CB8;KHITAN SMALL SCRIPT CHARACTER-18CB8;Lo;0;L;;;;;N;;;;;
+18CB9;KHITAN SMALL SCRIPT CHARACTER-18CB9;Lo;0;L;;;;;N;;;;;
+18CBA;KHITAN SMALL SCRIPT CHARACTER-18CBA;Lo;0;L;;;;;N;;;;;
+18CBB;KHITAN SMALL SCRIPT CHARACTER-18CBB;Lo;0;L;;;;;N;;;;;
+18CBC;KHITAN SMALL SCRIPT CHARACTER-18CBC;Lo;0;L;;;;;N;;;;;
+18CBD;KHITAN SMALL SCRIPT CHARACTER-18CBD;Lo;0;L;;;;;N;;;;;
+18CBE;KHITAN SMALL SCRIPT CHARACTER-18CBE;Lo;0;L;;;;;N;;;;;
+18CBF;KHITAN SMALL SCRIPT CHARACTER-18CBF;Lo;0;L;;;;;N;;;;;
+18CC0;KHITAN SMALL SCRIPT CHARACTER-18CC0;Lo;0;L;;;;;N;;;;;
+18CC1;KHITAN SMALL SCRIPT CHARACTER-18CC1;Lo;0;L;;;;;N;;;;;
+18CC2;KHITAN SMALL SCRIPT CHARACTER-18CC2;Lo;0;L;;;;;N;;;;;
+18CC3;KHITAN SMALL SCRIPT CHARACTER-18CC3;Lo;0;L;;;;;N;;;;;
+18CC4;KHITAN SMALL SCRIPT CHARACTER-18CC4;Lo;0;L;;;;;N;;;;;
+18CC5;KHITAN SMALL SCRIPT CHARACTER-18CC5;Lo;0;L;;;;;N;;;;;
+18CC6;KHITAN SMALL SCRIPT CHARACTER-18CC6;Lo;0;L;;;;;N;;;;;
+18CC7;KHITAN SMALL SCRIPT CHARACTER-18CC7;Lo;0;L;;;;;N;;;;;
+18CC8;KHITAN SMALL SCRIPT CHARACTER-18CC8;Lo;0;L;;;;;N;;;;;
+18CC9;KHITAN SMALL SCRIPT CHARACTER-18CC9;Lo;0;L;;;;;N;;;;;
+18CCA;KHITAN SMALL SCRIPT CHARACTER-18CCA;Lo;0;L;;;;;N;;;;;
+18CCB;KHITAN SMALL SCRIPT CHARACTER-18CCB;Lo;0;L;;;;;N;;;;;
+18CCC;KHITAN SMALL SCRIPT CHARACTER-18CCC;Lo;0;L;;;;;N;;;;;
+18CCD;KHITAN SMALL SCRIPT CHARACTER-18CCD;Lo;0;L;;;;;N;;;;;
+18CCE;KHITAN SMALL SCRIPT CHARACTER-18CCE;Lo;0;L;;;;;N;;;;;
+18CCF;KHITAN SMALL SCRIPT CHARACTER-18CCF;Lo;0;L;;;;;N;;;;;
+18CD0;KHITAN SMALL SCRIPT CHARACTER-18CD0;Lo;0;L;;;;;N;;;;;
+18CD1;KHITAN SMALL SCRIPT CHARACTER-18CD1;Lo;0;L;;;;;N;;;;;
+18CD2;KHITAN SMALL SCRIPT CHARACTER-18CD2;Lo;0;L;;;;;N;;;;;
+18CD3;KHITAN SMALL SCRIPT CHARACTER-18CD3;Lo;0;L;;;;;N;;;;;
+18CD4;KHITAN SMALL SCRIPT CHARACTER-18CD4;Lo;0;L;;;;;N;;;;;
+18CD5;KHITAN SMALL SCRIPT CHARACTER-18CD5;Lo;0;L;;;;;N;;;;;
+18CFF;KHITAN SMALL SCRIPT CHARACTER-18CFF;Lo;0;L;;;;;N;;;;;
+18D00;<Tangut Ideograph Supplement, First>;Lo;0;L;;;;;N;;;;;
+18D1E;<Tangut Ideograph Supplement, Last>;Lo;0;L;;;;;N;;;;;
+18D80;TANGUT COMPONENT-769;Lo;0;L;;;;;N;;;;;
+18D81;TANGUT COMPONENT-770;Lo;0;L;;;;;N;;;;;
+18D82;TANGUT COMPONENT-771;Lo;0;L;;;;;N;;;;;
+18D83;TANGUT COMPONENT-772;Lo;0;L;;;;;N;;;;;
+18D84;TANGUT COMPONENT-773;Lo;0;L;;;;;N;;;;;
+18D85;TANGUT COMPONENT-774;Lo;0;L;;;;;N;;;;;
+18D86;TANGUT COMPONENT-775;Lo;0;L;;;;;N;;;;;
+18D87;TANGUT COMPONENT-776;Lo;0;L;;;;;N;;;;;
+18D88;TANGUT COMPONENT-777;Lo;0;L;;;;;N;;;;;
+18D89;TANGUT COMPONENT-778;Lo;0;L;;;;;N;;;;;
+18D8A;TANGUT COMPONENT-779;Lo;0;L;;;;;N;;;;;
+18D8B;TANGUT COMPONENT-780;Lo;0;L;;;;;N;;;;;
+18D8C;TANGUT COMPONENT-781;Lo;0;L;;;;;N;;;;;
+18D8D;TANGUT COMPONENT-782;Lo;0;L;;;;;N;;;;;
+18D8E;TANGUT COMPONENT-783;Lo;0;L;;;;;N;;;;;
+18D8F;TANGUT COMPONENT-784;Lo;0;L;;;;;N;;;;;
+18D90;TANGUT COMPONENT-785;Lo;0;L;;;;;N;;;;;
+18D91;TANGUT COMPONENT-786;Lo;0;L;;;;;N;;;;;
+18D92;TANGUT COMPONENT-787;Lo;0;L;;;;;N;;;;;
+18D93;TANGUT COMPONENT-788;Lo;0;L;;;;;N;;;;;
+18D94;TANGUT COMPONENT-789;Lo;0;L;;;;;N;;;;;
+18D95;TANGUT COMPONENT-790;Lo;0;L;;;;;N;;;;;
+18D96;TANGUT COMPONENT-791;Lo;0;L;;;;;N;;;;;
+18D97;TANGUT COMPONENT-792;Lo;0;L;;;;;N;;;;;
+18D98;TANGUT COMPONENT-793;Lo;0;L;;;;;N;;;;;
+18D99;TANGUT COMPONENT-794;Lo;0;L;;;;;N;;;;;
+18D9A;TANGUT COMPONENT-795;Lo;0;L;;;;;N;;;;;
+18D9B;TANGUT COMPONENT-796;Lo;0;L;;;;;N;;;;;
+18D9C;TANGUT COMPONENT-797;Lo;0;L;;;;;N;;;;;
+18D9D;TANGUT COMPONENT-798;Lo;0;L;;;;;N;;;;;
+18D9E;TANGUT COMPONENT-799;Lo;0;L;;;;;N;;;;;
+18D9F;TANGUT COMPONENT-800;Lo;0;L;;;;;N;;;;;
+18DA0;TANGUT COMPONENT-801;Lo;0;L;;;;;N;;;;;
+18DA1;TANGUT COMPONENT-802;Lo;0;L;;;;;N;;;;;
+18DA2;TANGUT COMPONENT-803;Lo;0;L;;;;;N;;;;;
+18DA3;TANGUT COMPONENT-804;Lo;0;L;;;;;N;;;;;
+18DA4;TANGUT COMPONENT-805;Lo;0;L;;;;;N;;;;;
+18DA5;TANGUT COMPONENT-806;Lo;0;L;;;;;N;;;;;
+18DA6;TANGUT COMPONENT-807;Lo;0;L;;;;;N;;;;;
+18DA7;TANGUT COMPONENT-808;Lo;0;L;;;;;N;;;;;
+18DA8;TANGUT COMPONENT-809;Lo;0;L;;;;;N;;;;;
+18DA9;TANGUT COMPONENT-810;Lo;0;L;;;;;N;;;;;
+18DAA;TANGUT COMPONENT-811;Lo;0;L;;;;;N;;;;;
+18DAB;TANGUT COMPONENT-812;Lo;0;L;;;;;N;;;;;
+18DAC;TANGUT COMPONENT-813;Lo;0;L;;;;;N;;;;;
+18DAD;TANGUT COMPONENT-814;Lo;0;L;;;;;N;;;;;
+18DAE;TANGUT COMPONENT-815;Lo;0;L;;;;;N;;;;;
+18DAF;TANGUT COMPONENT-816;Lo;0;L;;;;;N;;;;;
+18DB0;TANGUT COMPONENT-817;Lo;0;L;;;;;N;;;;;
+18DB1;TANGUT COMPONENT-818;Lo;0;L;;;;;N;;;;;
+18DB2;TANGUT COMPONENT-819;Lo;0;L;;;;;N;;;;;
+18DB3;TANGUT COMPONENT-820;Lo;0;L;;;;;N;;;;;
+18DB4;TANGUT COMPONENT-821;Lo;0;L;;;;;N;;;;;
+18DB5;TANGUT COMPONENT-822;Lo;0;L;;;;;N;;;;;
+18DB6;TANGUT COMPONENT-823;Lo;0;L;;;;;N;;;;;
+18DB7;TANGUT COMPONENT-824;Lo;0;L;;;;;N;;;;;
+18DB8;TANGUT COMPONENT-825;Lo;0;L;;;;;N;;;;;
+18DB9;TANGUT COMPONENT-826;Lo;0;L;;;;;N;;;;;
+18DBA;TANGUT COMPONENT-827;Lo;0;L;;;;;N;;;;;
+18DBB;TANGUT COMPONENT-828;Lo;0;L;;;;;N;;;;;
+18DBC;TANGUT COMPONENT-829;Lo;0;L;;;;;N;;;;;
+18DBD;TANGUT COMPONENT-830;Lo;0;L;;;;;N;;;;;
+18DBE;TANGUT COMPONENT-831;Lo;0;L;;;;;N;;;;;
+18DBF;TANGUT COMPONENT-832;Lo;0;L;;;;;N;;;;;
+18DC0;TANGUT COMPONENT-833;Lo;0;L;;;;;N;;;;;
+18DC1;TANGUT COMPONENT-834;Lo;0;L;;;;;N;;;;;
+18DC2;TANGUT COMPONENT-835;Lo;0;L;;;;;N;;;;;
+18DC3;TANGUT COMPONENT-836;Lo;0;L;;;;;N;;;;;
+18DC4;TANGUT COMPONENT-837;Lo;0;L;;;;;N;;;;;
+18DC5;TANGUT COMPONENT-838;Lo;0;L;;;;;N;;;;;
+18DC6;TANGUT COMPONENT-839;Lo;0;L;;;;;N;;;;;
+18DC7;TANGUT COMPONENT-840;Lo;0;L;;;;;N;;;;;
+18DC8;TANGUT COMPONENT-841;Lo;0;L;;;;;N;;;;;
+18DC9;TANGUT COMPONENT-842;Lo;0;L;;;;;N;;;;;
+18DCA;TANGUT COMPONENT-843;Lo;0;L;;;;;N;;;;;
+18DCB;TANGUT COMPONENT-844;Lo;0;L;;;;;N;;;;;
+18DCC;TANGUT COMPONENT-845;Lo;0;L;;;;;N;;;;;
+18DCD;TANGUT COMPONENT-846;Lo;0;L;;;;;N;;;;;
+18DCE;TANGUT COMPONENT-847;Lo;0;L;;;;;N;;;;;
+18DCF;TANGUT COMPONENT-848;Lo;0;L;;;;;N;;;;;
+18DD0;TANGUT COMPONENT-849;Lo;0;L;;;;;N;;;;;
+18DD1;TANGUT COMPONENT-850;Lo;0;L;;;;;N;;;;;
+18DD2;TANGUT COMPONENT-851;Lo;0;L;;;;;N;;;;;
+18DD3;TANGUT COMPONENT-852;Lo;0;L;;;;;N;;;;;
+18DD4;TANGUT COMPONENT-853;Lo;0;L;;;;;N;;;;;
+18DD5;TANGUT COMPONENT-854;Lo;0;L;;;;;N;;;;;
+18DD6;TANGUT COMPONENT-855;Lo;0;L;;;;;N;;;;;
+18DD7;TANGUT COMPONENT-856;Lo;0;L;;;;;N;;;;;
+18DD8;TANGUT COMPONENT-857;Lo;0;L;;;;;N;;;;;
+18DD9;TANGUT COMPONENT-858;Lo;0;L;;;;;N;;;;;
+18DDA;TANGUT COMPONENT-859;Lo;0;L;;;;;N;;;;;
+18DDB;TANGUT COMPONENT-860;Lo;0;L;;;;;N;;;;;
+18DDC;TANGUT COMPONENT-861;Lo;0;L;;;;;N;;;;;
+18DDD;TANGUT COMPONENT-862;Lo;0;L;;;;;N;;;;;
+18DDE;TANGUT COMPONENT-863;Lo;0;L;;;;;N;;;;;
+18DDF;TANGUT COMPONENT-864;Lo;0;L;;;;;N;;;;;
+18DE0;TANGUT COMPONENT-865;Lo;0;L;;;;;N;;;;;
+18DE1;TANGUT COMPONENT-866;Lo;0;L;;;;;N;;;;;
+18DE2;TANGUT COMPONENT-867;Lo;0;L;;;;;N;;;;;
+18DE3;TANGUT COMPONENT-868;Lo;0;L;;;;;N;;;;;
+18DE4;TANGUT COMPONENT-869;Lo;0;L;;;;;N;;;;;
+18DE5;TANGUT COMPONENT-870;Lo;0;L;;;;;N;;;;;
+18DE6;TANGUT COMPONENT-871;Lo;0;L;;;;;N;;;;;
+18DE7;TANGUT COMPONENT-872;Lo;0;L;;;;;N;;;;;
+18DE8;TANGUT COMPONENT-873;Lo;0;L;;;;;N;;;;;
+18DE9;TANGUT COMPONENT-874;Lo;0;L;;;;;N;;;;;
+18DEA;TANGUT COMPONENT-875;Lo;0;L;;;;;N;;;;;
+18DEB;TANGUT COMPONENT-876;Lo;0;L;;;;;N;;;;;
+18DEC;TANGUT COMPONENT-877;Lo;0;L;;;;;N;;;;;
+18DED;TANGUT COMPONENT-878;Lo;0;L;;;;;N;;;;;
+18DEE;TANGUT COMPONENT-879;Lo;0;L;;;;;N;;;;;
+18DEF;TANGUT COMPONENT-880;Lo;0;L;;;;;N;;;;;
+18DF0;TANGUT COMPONENT-881;Lo;0;L;;;;;N;;;;;
+18DF1;TANGUT COMPONENT-882;Lo;0;L;;;;;N;;;;;
+18DF2;TANGUT COMPONENT-883;Lo;0;L;;;;;N;;;;;
+1AFF0;KATAKANA LETTER MINNAN TONE-2;Lm;0;L;;;;;N;;;;;
+1AFF1;KATAKANA LETTER MINNAN TONE-3;Lm;0;L;;;;;N;;;;;
+1AFF2;KATAKANA LETTER MINNAN TONE-4;Lm;0;L;;;;;N;;;;;
+1AFF3;KATAKANA LETTER MINNAN TONE-5;Lm;0;L;;;;;N;;;;;
+1AFF5;KATAKANA LETTER MINNAN TONE-7;Lm;0;L;;;;;N;;;;;
+1AFF6;KATAKANA LETTER MINNAN TONE-8;Lm;0;L;;;;;N;;;;;
+1AFF7;KATAKANA LETTER MINNAN NASALIZED TONE-1;Lm;0;L;;;;;N;;;;;
+1AFF8;KATAKANA LETTER MINNAN NASALIZED TONE-2;Lm;0;L;;;;;N;;;;;
+1AFF9;KATAKANA LETTER MINNAN NASALIZED TONE-3;Lm;0;L;;;;;N;;;;;
+1AFFA;KATAKANA LETTER MINNAN NASALIZED TONE-4;Lm;0;L;;;;;N;;;;;
+1AFFB;KATAKANA LETTER MINNAN NASALIZED TONE-5;Lm;0;L;;;;;N;;;;;
+1AFFD;KATAKANA LETTER MINNAN NASALIZED TONE-7;Lm;0;L;;;;;N;;;;;
+1AFFE;KATAKANA LETTER MINNAN NASALIZED TONE-8;Lm;0;L;;;;;N;;;;;
 1B000;KATAKANA LETTER ARCHAIC E;Lo;0;L;;;;;N;;;;;
 1B001;HIRAGANA LETTER ARCHAIC YE;Lo;0;L;;;;;N;;;;;
+1B002;HENTAIGANA LETTER A-1;Lo;0;L;;;;;N;;;;;
+1B003;HENTAIGANA LETTER A-2;Lo;0;L;;;;;N;;;;;
+1B004;HENTAIGANA LETTER A-3;Lo;0;L;;;;;N;;;;;
+1B005;HENTAIGANA LETTER A-WO;Lo;0;L;;;;;N;;;;;
+1B006;HENTAIGANA LETTER I-1;Lo;0;L;;;;;N;;;;;
+1B007;HENTAIGANA LETTER I-2;Lo;0;L;;;;;N;;;;;
+1B008;HENTAIGANA LETTER I-3;Lo;0;L;;;;;N;;;;;
+1B009;HENTAIGANA LETTER I-4;Lo;0;L;;;;;N;;;;;
+1B00A;HENTAIGANA LETTER U-1;Lo;0;L;;;;;N;;;;;
+1B00B;HENTAIGANA LETTER U-2;Lo;0;L;;;;;N;;;;;
+1B00C;HENTAIGANA LETTER U-3;Lo;0;L;;;;;N;;;;;
+1B00D;HENTAIGANA LETTER U-4;Lo;0;L;;;;;N;;;;;
+1B00E;HENTAIGANA LETTER U-5;Lo;0;L;;;;;N;;;;;
+1B00F;HENTAIGANA LETTER E-2;Lo;0;L;;;;;N;;;;;
+1B010;HENTAIGANA LETTER E-3;Lo;0;L;;;;;N;;;;;
+1B011;HENTAIGANA LETTER E-4;Lo;0;L;;;;;N;;;;;
+1B012;HENTAIGANA LETTER E-5;Lo;0;L;;;;;N;;;;;
+1B013;HENTAIGANA LETTER E-6;Lo;0;L;;;;;N;;;;;
+1B014;HENTAIGANA LETTER O-1;Lo;0;L;;;;;N;;;;;
+1B015;HENTAIGANA LETTER O-2;Lo;0;L;;;;;N;;;;;
+1B016;HENTAIGANA LETTER O-3;Lo;0;L;;;;;N;;;;;
+1B017;HENTAIGANA LETTER KA-1;Lo;0;L;;;;;N;;;;;
+1B018;HENTAIGANA LETTER KA-2;Lo;0;L;;;;;N;;;;;
+1B019;HENTAIGANA LETTER KA-3;Lo;0;L;;;;;N;;;;;
+1B01A;HENTAIGANA LETTER KA-4;Lo;0;L;;;;;N;;;;;
+1B01B;HENTAIGANA LETTER KA-5;Lo;0;L;;;;;N;;;;;
+1B01C;HENTAIGANA LETTER KA-6;Lo;0;L;;;;;N;;;;;
+1B01D;HENTAIGANA LETTER KA-7;Lo;0;L;;;;;N;;;;;
+1B01E;HENTAIGANA LETTER KA-8;Lo;0;L;;;;;N;;;;;
+1B01F;HENTAIGANA LETTER KA-9;Lo;0;L;;;;;N;;;;;
+1B020;HENTAIGANA LETTER KA-10;Lo;0;L;;;;;N;;;;;
+1B021;HENTAIGANA LETTER KA-11;Lo;0;L;;;;;N;;;;;
+1B022;HENTAIGANA LETTER KA-KE;Lo;0;L;;;;;N;;;;;
+1B023;HENTAIGANA LETTER KI-1;Lo;0;L;;;;;N;;;;;
+1B024;HENTAIGANA LETTER KI-2;Lo;0;L;;;;;N;;;;;
+1B025;HENTAIGANA LETTER KI-3;Lo;0;L;;;;;N;;;;;
+1B026;HENTAIGANA LETTER KI-4;Lo;0;L;;;;;N;;;;;
+1B027;HENTAIGANA LETTER KI-5;Lo;0;L;;;;;N;;;;;
+1B028;HENTAIGANA LETTER KI-6;Lo;0;L;;;;;N;;;;;
+1B029;HENTAIGANA LETTER KI-7;Lo;0;L;;;;;N;;;;;
+1B02A;HENTAIGANA LETTER KI-8;Lo;0;L;;;;;N;;;;;
+1B02B;HENTAIGANA LETTER KU-1;Lo;0;L;;;;;N;;;;;
+1B02C;HENTAIGANA LETTER KU-2;Lo;0;L;;;;;N;;;;;
+1B02D;HENTAIGANA LETTER KU-3;Lo;0;L;;;;;N;;;;;
+1B02E;HENTAIGANA LETTER KU-4;Lo;0;L;;;;;N;;;;;
+1B02F;HENTAIGANA LETTER KU-5;Lo;0;L;;;;;N;;;;;
+1B030;HENTAIGANA LETTER KU-6;Lo;0;L;;;;;N;;;;;
+1B031;HENTAIGANA LETTER KU-7;Lo;0;L;;;;;N;;;;;
+1B032;HENTAIGANA LETTER KE-1;Lo;0;L;;;;;N;;;;;
+1B033;HENTAIGANA LETTER KE-2;Lo;0;L;;;;;N;;;;;
+1B034;HENTAIGANA LETTER KE-3;Lo;0;L;;;;;N;;;;;
+1B035;HENTAIGANA LETTER KE-4;Lo;0;L;;;;;N;;;;;
+1B036;HENTAIGANA LETTER KE-5;Lo;0;L;;;;;N;;;;;
+1B037;HENTAIGANA LETTER KE-6;Lo;0;L;;;;;N;;;;;
+1B038;HENTAIGANA LETTER KO-1;Lo;0;L;;;;;N;;;;;
+1B039;HENTAIGANA LETTER KO-2;Lo;0;L;;;;;N;;;;;
+1B03A;HENTAIGANA LETTER KO-3;Lo;0;L;;;;;N;;;;;
+1B03B;HENTAIGANA LETTER KO-KI;Lo;0;L;;;;;N;;;;;
+1B03C;HENTAIGANA LETTER SA-1;Lo;0;L;;;;;N;;;;;
+1B03D;HENTAIGANA LETTER SA-2;Lo;0;L;;;;;N;;;;;
+1B03E;HENTAIGANA LETTER SA-3;Lo;0;L;;;;;N;;;;;
+1B03F;HENTAIGANA LETTER SA-4;Lo;0;L;;;;;N;;;;;
+1B040;HENTAIGANA LETTER SA-5;Lo;0;L;;;;;N;;;;;
+1B041;HENTAIGANA LETTER SA-6;Lo;0;L;;;;;N;;;;;
+1B042;HENTAIGANA LETTER SA-7;Lo;0;L;;;;;N;;;;;
+1B043;HENTAIGANA LETTER SA-8;Lo;0;L;;;;;N;;;;;
+1B044;HENTAIGANA LETTER SI-1;Lo;0;L;;;;;N;;;;;
+1B045;HENTAIGANA LETTER SI-2;Lo;0;L;;;;;N;;;;;
+1B046;HENTAIGANA LETTER SI-3;Lo;0;L;;;;;N;;;;;
+1B047;HENTAIGANA LETTER SI-4;Lo;0;L;;;;;N;;;;;
+1B048;HENTAIGANA LETTER SI-5;Lo;0;L;;;;;N;;;;;
+1B049;HENTAIGANA LETTER SI-6;Lo;0;L;;;;;N;;;;;
+1B04A;HENTAIGANA LETTER SU-1;Lo;0;L;;;;;N;;;;;
+1B04B;HENTAIGANA LETTER SU-2;Lo;0;L;;;;;N;;;;;
+1B04C;HENTAIGANA LETTER SU-3;Lo;0;L;;;;;N;;;;;
+1B04D;HENTAIGANA LETTER SU-4;Lo;0;L;;;;;N;;;;;
+1B04E;HENTAIGANA LETTER SU-5;Lo;0;L;;;;;N;;;;;
+1B04F;HENTAIGANA LETTER SU-6;Lo;0;L;;;;;N;;;;;
+1B050;HENTAIGANA LETTER SU-7;Lo;0;L;;;;;N;;;;;
+1B051;HENTAIGANA LETTER SU-8;Lo;0;L;;;;;N;;;;;
+1B052;HENTAIGANA LETTER SE-1;Lo;0;L;;;;;N;;;;;
+1B053;HENTAIGANA LETTER SE-2;Lo;0;L;;;;;N;;;;;
+1B054;HENTAIGANA LETTER SE-3;Lo;0;L;;;;;N;;;;;
+1B055;HENTAIGANA LETTER SE-4;Lo;0;L;;;;;N;;;;;
+1B056;HENTAIGANA LETTER SE-5;Lo;0;L;;;;;N;;;;;
+1B057;HENTAIGANA LETTER SO-1;Lo;0;L;;;;;N;;;;;
+1B058;HENTAIGANA LETTER SO-2;Lo;0;L;;;;;N;;;;;
+1B059;HENTAIGANA LETTER SO-3;Lo;0;L;;;;;N;;;;;
+1B05A;HENTAIGANA LETTER SO-4;Lo;0;L;;;;;N;;;;;
+1B05B;HENTAIGANA LETTER SO-5;Lo;0;L;;;;;N;;;;;
+1B05C;HENTAIGANA LETTER SO-6;Lo;0;L;;;;;N;;;;;
+1B05D;HENTAIGANA LETTER SO-7;Lo;0;L;;;;;N;;;;;
+1B05E;HENTAIGANA LETTER TA-1;Lo;0;L;;;;;N;;;;;
+1B05F;HENTAIGANA LETTER TA-2;Lo;0;L;;;;;N;;;;;
+1B060;HENTAIGANA LETTER TA-3;Lo;0;L;;;;;N;;;;;
+1B061;HENTAIGANA LETTER TA-4;Lo;0;L;;;;;N;;;;;
+1B062;HENTAIGANA LETTER TI-1;Lo;0;L;;;;;N;;;;;
+1B063;HENTAIGANA LETTER TI-2;Lo;0;L;;;;;N;;;;;
+1B064;HENTAIGANA LETTER TI-3;Lo;0;L;;;;;N;;;;;
+1B065;HENTAIGANA LETTER TI-4;Lo;0;L;;;;;N;;;;;
+1B066;HENTAIGANA LETTER TI-5;Lo;0;L;;;;;N;;;;;
+1B067;HENTAIGANA LETTER TI-6;Lo;0;L;;;;;N;;;;;
+1B068;HENTAIGANA LETTER TI-7;Lo;0;L;;;;;N;;;;;
+1B069;HENTAIGANA LETTER TU-1;Lo;0;L;;;;;N;;;;;
+1B06A;HENTAIGANA LETTER TU-2;Lo;0;L;;;;;N;;;;;
+1B06B;HENTAIGANA LETTER TU-3;Lo;0;L;;;;;N;;;;;
+1B06C;HENTAIGANA LETTER TU-4;Lo;0;L;;;;;N;;;;;
+1B06D;HENTAIGANA LETTER TU-TO;Lo;0;L;;;;;N;;;;;
+1B06E;HENTAIGANA LETTER TE-1;Lo;0;L;;;;;N;;;;;
+1B06F;HENTAIGANA LETTER TE-2;Lo;0;L;;;;;N;;;;;
+1B070;HENTAIGANA LETTER TE-3;Lo;0;L;;;;;N;;;;;
+1B071;HENTAIGANA LETTER TE-4;Lo;0;L;;;;;N;;;;;
+1B072;HENTAIGANA LETTER TE-5;Lo;0;L;;;;;N;;;;;
+1B073;HENTAIGANA LETTER TE-6;Lo;0;L;;;;;N;;;;;
+1B074;HENTAIGANA LETTER TE-7;Lo;0;L;;;;;N;;;;;
+1B075;HENTAIGANA LETTER TE-8;Lo;0;L;;;;;N;;;;;
+1B076;HENTAIGANA LETTER TE-9;Lo;0;L;;;;;N;;;;;
+1B077;HENTAIGANA LETTER TO-1;Lo;0;L;;;;;N;;;;;
+1B078;HENTAIGANA LETTER TO-2;Lo;0;L;;;;;N;;;;;
+1B079;HENTAIGANA LETTER TO-3;Lo;0;L;;;;;N;;;;;
+1B07A;HENTAIGANA LETTER TO-4;Lo;0;L;;;;;N;;;;;
+1B07B;HENTAIGANA LETTER TO-5;Lo;0;L;;;;;N;;;;;
+1B07C;HENTAIGANA LETTER TO-6;Lo;0;L;;;;;N;;;;;
+1B07D;HENTAIGANA LETTER TO-RA;Lo;0;L;;;;;N;;;;;
+1B07E;HENTAIGANA LETTER NA-1;Lo;0;L;;;;;N;;;;;
+1B07F;HENTAIGANA LETTER NA-2;Lo;0;L;;;;;N;;;;;
+1B080;HENTAIGANA LETTER NA-3;Lo;0;L;;;;;N;;;;;
+1B081;HENTAIGANA LETTER NA-4;Lo;0;L;;;;;N;;;;;
+1B082;HENTAIGANA LETTER NA-5;Lo;0;L;;;;;N;;;;;
+1B083;HENTAIGANA LETTER NA-6;Lo;0;L;;;;;N;;;;;
+1B084;HENTAIGANA LETTER NA-7;Lo;0;L;;;;;N;;;;;
+1B085;HENTAIGANA LETTER NA-8;Lo;0;L;;;;;N;;;;;
+1B086;HENTAIGANA LETTER NA-9;Lo;0;L;;;;;N;;;;;
+1B087;HENTAIGANA LETTER NI-1;Lo;0;L;;;;;N;;;;;
+1B088;HENTAIGANA LETTER NI-2;Lo;0;L;;;;;N;;;;;
+1B089;HENTAIGANA LETTER NI-3;Lo;0;L;;;;;N;;;;;
+1B08A;HENTAIGANA LETTER NI-4;Lo;0;L;;;;;N;;;;;
+1B08B;HENTAIGANA LETTER NI-5;Lo;0;L;;;;;N;;;;;
+1B08C;HENTAIGANA LETTER NI-6;Lo;0;L;;;;;N;;;;;
+1B08D;HENTAIGANA LETTER NI-7;Lo;0;L;;;;;N;;;;;
+1B08E;HENTAIGANA LETTER NI-TE;Lo;0;L;;;;;N;;;;;
+1B08F;HENTAIGANA LETTER NU-1;Lo;0;L;;;;;N;;;;;
+1B090;HENTAIGANA LETTER NU-2;Lo;0;L;;;;;N;;;;;
+1B091;HENTAIGANA LETTER NU-3;Lo;0;L;;;;;N;;;;;
+1B092;HENTAIGANA LETTER NE-1;Lo;0;L;;;;;N;;;;;
+1B093;HENTAIGANA LETTER NE-2;Lo;0;L;;;;;N;;;;;
+1B094;HENTAIGANA LETTER NE-3;Lo;0;L;;;;;N;;;;;
+1B095;HENTAIGANA LETTER NE-4;Lo;0;L;;;;;N;;;;;
+1B096;HENTAIGANA LETTER NE-5;Lo;0;L;;;;;N;;;;;
+1B097;HENTAIGANA LETTER NE-6;Lo;0;L;;;;;N;;;;;
+1B098;HENTAIGANA LETTER NE-KO;Lo;0;L;;;;;N;;;;;
+1B099;HENTAIGANA LETTER NO-1;Lo;0;L;;;;;N;;;;;
+1B09A;HENTAIGANA LETTER NO-2;Lo;0;L;;;;;N;;;;;
+1B09B;HENTAIGANA LETTER NO-3;Lo;0;L;;;;;N;;;;;
+1B09C;HENTAIGANA LETTER NO-4;Lo;0;L;;;;;N;;;;;
+1B09D;HENTAIGANA LETTER NO-5;Lo;0;L;;;;;N;;;;;
+1B09E;HENTAIGANA LETTER HA-1;Lo;0;L;;;;;N;;;;;
+1B09F;HENTAIGANA LETTER HA-2;Lo;0;L;;;;;N;;;;;
+1B0A0;HENTAIGANA LETTER HA-3;Lo;0;L;;;;;N;;;;;
+1B0A1;HENTAIGANA LETTER HA-4;Lo;0;L;;;;;N;;;;;
+1B0A2;HENTAIGANA LETTER HA-5;Lo;0;L;;;;;N;;;;;
+1B0A3;HENTAIGANA LETTER HA-6;Lo;0;L;;;;;N;;;;;
+1B0A4;HENTAIGANA LETTER HA-7;Lo;0;L;;;;;N;;;;;
+1B0A5;HENTAIGANA LETTER HA-8;Lo;0;L;;;;;N;;;;;
+1B0A6;HENTAIGANA LETTER HA-9;Lo;0;L;;;;;N;;;;;
+1B0A7;HENTAIGANA LETTER HA-10;Lo;0;L;;;;;N;;;;;
+1B0A8;HENTAIGANA LETTER HA-11;Lo;0;L;;;;;N;;;;;
+1B0A9;HENTAIGANA LETTER HI-1;Lo;0;L;;;;;N;;;;;
+1B0AA;HENTAIGANA LETTER HI-2;Lo;0;L;;;;;N;;;;;
+1B0AB;HENTAIGANA LETTER HI-3;Lo;0;L;;;;;N;;;;;
+1B0AC;HENTAIGANA LETTER HI-4;Lo;0;L;;;;;N;;;;;
+1B0AD;HENTAIGANA LETTER HI-5;Lo;0;L;;;;;N;;;;;
+1B0AE;HENTAIGANA LETTER HI-6;Lo;0;L;;;;;N;;;;;
+1B0AF;HENTAIGANA LETTER HI-7;Lo;0;L;;;;;N;;;;;
+1B0B0;HENTAIGANA LETTER HU-1;Lo;0;L;;;;;N;;;;;
+1B0B1;HENTAIGANA LETTER HU-2;Lo;0;L;;;;;N;;;;;
+1B0B2;HENTAIGANA LETTER HU-3;Lo;0;L;;;;;N;;;;;
+1B0B3;HENTAIGANA LETTER HE-1;Lo;0;L;;;;;N;;;;;
+1B0B4;HENTAIGANA LETTER HE-2;Lo;0;L;;;;;N;;;;;
+1B0B5;HENTAIGANA LETTER HE-3;Lo;0;L;;;;;N;;;;;
+1B0B6;HENTAIGANA LETTER HE-4;Lo;0;L;;;;;N;;;;;
+1B0B7;HENTAIGANA LETTER HE-5;Lo;0;L;;;;;N;;;;;
+1B0B8;HENTAIGANA LETTER HE-6;Lo;0;L;;;;;N;;;;;
+1B0B9;HENTAIGANA LETTER HE-7;Lo;0;L;;;;;N;;;;;
+1B0BA;HENTAIGANA LETTER HO-1;Lo;0;L;;;;;N;;;;;
+1B0BB;HENTAIGANA LETTER HO-2;Lo;0;L;;;;;N;;;;;
+1B0BC;HENTAIGANA LETTER HO-3;Lo;0;L;;;;;N;;;;;
+1B0BD;HENTAIGANA LETTER HO-4;Lo;0;L;;;;;N;;;;;
+1B0BE;HENTAIGANA LETTER HO-5;Lo;0;L;;;;;N;;;;;
+1B0BF;HENTAIGANA LETTER HO-6;Lo;0;L;;;;;N;;;;;
+1B0C0;HENTAIGANA LETTER HO-7;Lo;0;L;;;;;N;;;;;
+1B0C1;HENTAIGANA LETTER HO-8;Lo;0;L;;;;;N;;;;;
+1B0C2;HENTAIGANA LETTER MA-1;Lo;0;L;;;;;N;;;;;
+1B0C3;HENTAIGANA LETTER MA-2;Lo;0;L;;;;;N;;;;;
+1B0C4;HENTAIGANA LETTER MA-3;Lo;0;L;;;;;N;;;;;
+1B0C5;HENTAIGANA LETTER MA-4;Lo;0;L;;;;;N;;;;;
+1B0C6;HENTAIGANA LETTER MA-5;Lo;0;L;;;;;N;;;;;
+1B0C7;HENTAIGANA LETTER MA-6;Lo;0;L;;;;;N;;;;;
+1B0C8;HENTAIGANA LETTER MA-7;Lo;0;L;;;;;N;;;;;
+1B0C9;HENTAIGANA LETTER MI-1;Lo;0;L;;;;;N;;;;;
+1B0CA;HENTAIGANA LETTER MI-2;Lo;0;L;;;;;N;;;;;
+1B0CB;HENTAIGANA LETTER MI-3;Lo;0;L;;;;;N;;;;;
+1B0CC;HENTAIGANA LETTER MI-4;Lo;0;L;;;;;N;;;;;
+1B0CD;HENTAIGANA LETTER MI-5;Lo;0;L;;;;;N;;;;;
+1B0CE;HENTAIGANA LETTER MI-6;Lo;0;L;;;;;N;;;;;
+1B0CF;HENTAIGANA LETTER MI-7;Lo;0;L;;;;;N;;;;;
+1B0D0;HENTAIGANA LETTER MU-1;Lo;0;L;;;;;N;;;;;
+1B0D1;HENTAIGANA LETTER MU-2;Lo;0;L;;;;;N;;;;;
+1B0D2;HENTAIGANA LETTER MU-3;Lo;0;L;;;;;N;;;;;
+1B0D3;HENTAIGANA LETTER MU-4;Lo;0;L;;;;;N;;;;;
+1B0D4;HENTAIGANA LETTER ME-1;Lo;0;L;;;;;N;;;;;
+1B0D5;HENTAIGANA LETTER ME-2;Lo;0;L;;;;;N;;;;;
+1B0D6;HENTAIGANA LETTER ME-MA;Lo;0;L;;;;;N;;;;;
+1B0D7;HENTAIGANA LETTER MO-1;Lo;0;L;;;;;N;;;;;
+1B0D8;HENTAIGANA LETTER MO-2;Lo;0;L;;;;;N;;;;;
+1B0D9;HENTAIGANA LETTER MO-3;Lo;0;L;;;;;N;;;;;
+1B0DA;HENTAIGANA LETTER MO-4;Lo;0;L;;;;;N;;;;;
+1B0DB;HENTAIGANA LETTER MO-5;Lo;0;L;;;;;N;;;;;
+1B0DC;HENTAIGANA LETTER MO-6;Lo;0;L;;;;;N;;;;;
+1B0DD;HENTAIGANA LETTER YA-1;Lo;0;L;;;;;N;;;;;
+1B0DE;HENTAIGANA LETTER YA-2;Lo;0;L;;;;;N;;;;;
+1B0DF;HENTAIGANA LETTER YA-3;Lo;0;L;;;;;N;;;;;
+1B0E0;HENTAIGANA LETTER YA-4;Lo;0;L;;;;;N;;;;;
+1B0E1;HENTAIGANA LETTER YA-5;Lo;0;L;;;;;N;;;;;
+1B0E2;HENTAIGANA LETTER YA-YO;Lo;0;L;;;;;N;;;;;
+1B0E3;HENTAIGANA LETTER YU-1;Lo;0;L;;;;;N;;;;;
+1B0E4;HENTAIGANA LETTER YU-2;Lo;0;L;;;;;N;;;;;
+1B0E5;HENTAIGANA LETTER YU-3;Lo;0;L;;;;;N;;;;;
+1B0E6;HENTAIGANA LETTER YU-4;Lo;0;L;;;;;N;;;;;
+1B0E7;HENTAIGANA LETTER YO-1;Lo;0;L;;;;;N;;;;;
+1B0E8;HENTAIGANA LETTER YO-2;Lo;0;L;;;;;N;;;;;
+1B0E9;HENTAIGANA LETTER YO-3;Lo;0;L;;;;;N;;;;;
+1B0EA;HENTAIGANA LETTER YO-4;Lo;0;L;;;;;N;;;;;
+1B0EB;HENTAIGANA LETTER YO-5;Lo;0;L;;;;;N;;;;;
+1B0EC;HENTAIGANA LETTER YO-6;Lo;0;L;;;;;N;;;;;
+1B0ED;HENTAIGANA LETTER RA-1;Lo;0;L;;;;;N;;;;;
+1B0EE;HENTAIGANA LETTER RA-2;Lo;0;L;;;;;N;;;;;
+1B0EF;HENTAIGANA LETTER RA-3;Lo;0;L;;;;;N;;;;;
+1B0F0;HENTAIGANA LETTER RA-4;Lo;0;L;;;;;N;;;;;
+1B0F1;HENTAIGANA LETTER RI-1;Lo;0;L;;;;;N;;;;;
+1B0F2;HENTAIGANA LETTER RI-2;Lo;0;L;;;;;N;;;;;
+1B0F3;HENTAIGANA LETTER RI-3;Lo;0;L;;;;;N;;;;;
+1B0F4;HENTAIGANA LETTER RI-4;Lo;0;L;;;;;N;;;;;
+1B0F5;HENTAIGANA LETTER RI-5;Lo;0;L;;;;;N;;;;;
+1B0F6;HENTAIGANA LETTER RI-6;Lo;0;L;;;;;N;;;;;
+1B0F7;HENTAIGANA LETTER RI-7;Lo;0;L;;;;;N;;;;;
+1B0F8;HENTAIGANA LETTER RU-1;Lo;0;L;;;;;N;;;;;
+1B0F9;HENTAIGANA LETTER RU-2;Lo;0;L;;;;;N;;;;;
+1B0FA;HENTAIGANA LETTER RU-3;Lo;0;L;;;;;N;;;;;
+1B0FB;HENTAIGANA LETTER RU-4;Lo;0;L;;;;;N;;;;;
+1B0FC;HENTAIGANA LETTER RU-5;Lo;0;L;;;;;N;;;;;
+1B0FD;HENTAIGANA LETTER RU-6;Lo;0;L;;;;;N;;;;;
+1B0FE;HENTAIGANA LETTER RE-1;Lo;0;L;;;;;N;;;;;
+1B0FF;HENTAIGANA LETTER RE-2;Lo;0;L;;;;;N;;;;;
+1B100;HENTAIGANA LETTER RE-3;Lo;0;L;;;;;N;;;;;
+1B101;HENTAIGANA LETTER RE-4;Lo;0;L;;;;;N;;;;;
+1B102;HENTAIGANA LETTER RO-1;Lo;0;L;;;;;N;;;;;
+1B103;HENTAIGANA LETTER RO-2;Lo;0;L;;;;;N;;;;;
+1B104;HENTAIGANA LETTER RO-3;Lo;0;L;;;;;N;;;;;
+1B105;HENTAIGANA LETTER RO-4;Lo;0;L;;;;;N;;;;;
+1B106;HENTAIGANA LETTER RO-5;Lo;0;L;;;;;N;;;;;
+1B107;HENTAIGANA LETTER RO-6;Lo;0;L;;;;;N;;;;;
+1B108;HENTAIGANA LETTER WA-1;Lo;0;L;;;;;N;;;;;
+1B109;HENTAIGANA LETTER WA-2;Lo;0;L;;;;;N;;;;;
+1B10A;HENTAIGANA LETTER WA-3;Lo;0;L;;;;;N;;;;;
+1B10B;HENTAIGANA LETTER WA-4;Lo;0;L;;;;;N;;;;;
+1B10C;HENTAIGANA LETTER WA-5;Lo;0;L;;;;;N;;;;;
+1B10D;HENTAIGANA LETTER WI-1;Lo;0;L;;;;;N;;;;;
+1B10E;HENTAIGANA LETTER WI-2;Lo;0;L;;;;;N;;;;;
+1B10F;HENTAIGANA LETTER WI-3;Lo;0;L;;;;;N;;;;;
+1B110;HENTAIGANA LETTER WI-4;Lo;0;L;;;;;N;;;;;
+1B111;HENTAIGANA LETTER WI-5;Lo;0;L;;;;;N;;;;;
+1B112;HENTAIGANA LETTER WE-1;Lo;0;L;;;;;N;;;;;
+1B113;HENTAIGANA LETTER WE-2;Lo;0;L;;;;;N;;;;;
+1B114;HENTAIGANA LETTER WE-3;Lo;0;L;;;;;N;;;;;
+1B115;HENTAIGANA LETTER WE-4;Lo;0;L;;;;;N;;;;;
+1B116;HENTAIGANA LETTER WO-1;Lo;0;L;;;;;N;;;;;
+1B117;HENTAIGANA LETTER WO-2;Lo;0;L;;;;;N;;;;;
+1B118;HENTAIGANA LETTER WO-3;Lo;0;L;;;;;N;;;;;
+1B119;HENTAIGANA LETTER WO-4;Lo;0;L;;;;;N;;;;;
+1B11A;HENTAIGANA LETTER WO-5;Lo;0;L;;;;;N;;;;;
+1B11B;HENTAIGANA LETTER WO-6;Lo;0;L;;;;;N;;;;;
+1B11C;HENTAIGANA LETTER WO-7;Lo;0;L;;;;;N;;;;;
+1B11D;HENTAIGANA LETTER N-MU-MO-1;Lo;0;L;;;;;N;;;;;
+1B11E;HENTAIGANA LETTER N-MU-MO-2;Lo;0;L;;;;;N;;;;;
+1B11F;HIRAGANA LETTER ARCHAIC WU;Lo;0;L;;;;;N;;;;;
+1B120;KATAKANA LETTER ARCHAIC YI;Lo;0;L;;;;;N;;;;;
+1B121;KATAKANA LETTER ARCHAIC YE;Lo;0;L;;;;;N;;;;;
+1B122;KATAKANA LETTER ARCHAIC WU;Lo;0;L;;;;;N;;;;;
+1B132;HIRAGANA LETTER SMALL KO;Lo;0;L;;;;;N;;;;;
+1B150;HIRAGANA LETTER SMALL WI;Lo;0;L;;;;;N;;;;;
+1B151;HIRAGANA LETTER SMALL WE;Lo;0;L;;;;;N;;;;;
+1B152;HIRAGANA LETTER SMALL WO;Lo;0;L;;;;;N;;;;;
+1B155;KATAKANA LETTER SMALL KO;Lo;0;L;;;;;N;;;;;
+1B164;KATAKANA LETTER SMALL WI;Lo;0;L;;;;;N;;;;;
+1B165;KATAKANA LETTER SMALL WE;Lo;0;L;;;;;N;;;;;
+1B166;KATAKANA LETTER SMALL WO;Lo;0;L;;;;;N;;;;;
+1B167;KATAKANA LETTER SMALL N;Lo;0;L;;;;;N;;;;;
+1B170;NUSHU CHARACTER-1B170;Lo;0;L;;;;;N;;;;;
+1B171;NUSHU CHARACTER-1B171;Lo;0;L;;;;;N;;;;;
+1B172;NUSHU CHARACTER-1B172;Lo;0;L;;;;;N;;;;;
+1B173;NUSHU CHARACTER-1B173;Lo;0;L;;;;;N;;;;;
+1B174;NUSHU CHARACTER-1B174;Lo;0;L;;;;;N;;;;;
+1B175;NUSHU CHARACTER-1B175;Lo;0;L;;;;;N;;;;;
+1B176;NUSHU CHARACTER-1B176;Lo;0;L;;;;;N;;;;;
+1B177;NUSHU CHARACTER-1B177;Lo;0;L;;;;;N;;;;;
+1B178;NUSHU CHARACTER-1B178;Lo;0;L;;;;;N;;;;;
+1B179;NUSHU CHARACTER-1B179;Lo;0;L;;;;;N;;;;;
+1B17A;NUSHU CHARACTER-1B17A;Lo;0;L;;;;;N;;;;;
+1B17B;NUSHU CHARACTER-1B17B;Lo;0;L;;;;;N;;;;;
+1B17C;NUSHU CHARACTER-1B17C;Lo;0;L;;;;;N;;;;;
+1B17D;NUSHU CHARACTER-1B17D;Lo;0;L;;;;;N;;;;;
+1B17E;NUSHU CHARACTER-1B17E;Lo;0;L;;;;;N;;;;;
+1B17F;NUSHU CHARACTER-1B17F;Lo;0;L;;;;;N;;;;;
+1B180;NUSHU CHARACTER-1B180;Lo;0;L;;;;;N;;;;;
+1B181;NUSHU CHARACTER-1B181;Lo;0;L;;;;;N;;;;;
+1B182;NUSHU CHARACTER-1B182;Lo;0;L;;;;;N;;;;;
+1B183;NUSHU CHARACTER-1B183;Lo;0;L;;;;;N;;;;;
+1B184;NUSHU CHARACTER-1B184;Lo;0;L;;;;;N;;;;;
+1B185;NUSHU CHARACTER-1B185;Lo;0;L;;;;;N;;;;;
+1B186;NUSHU CHARACTER-1B186;Lo;0;L;;;;;N;;;;;
+1B187;NUSHU CHARACTER-1B187;Lo;0;L;;;;;N;;;;;
+1B188;NUSHU CHARACTER-1B188;Lo;0;L;;;;;N;;;;;
+1B189;NUSHU CHARACTER-1B189;Lo;0;L;;;;;N;;;;;
+1B18A;NUSHU CHARACTER-1B18A;Lo;0;L;;;;;N;;;;;
+1B18B;NUSHU CHARACTER-1B18B;Lo;0;L;;;;;N;;;;;
+1B18C;NUSHU CHARACTER-1B18C;Lo;0;L;;;;;N;;;;;
+1B18D;NUSHU CHARACTER-1B18D;Lo;0;L;;;;;N;;;;;
+1B18E;NUSHU CHARACTER-1B18E;Lo;0;L;;;;;N;;;;;
+1B18F;NUSHU CHARACTER-1B18F;Lo;0;L;;;;;N;;;;;
+1B190;NUSHU CHARACTER-1B190;Lo;0;L;;;;;N;;;;;
+1B191;NUSHU CHARACTER-1B191;Lo;0;L;;;;;N;;;;;
+1B192;NUSHU CHARACTER-1B192;Lo;0;L;;;;;N;;;;;
+1B193;NUSHU CHARACTER-1B193;Lo;0;L;;;;;N;;;;;
+1B194;NUSHU CHARACTER-1B194;Lo;0;L;;;;;N;;;;;
+1B195;NUSHU CHARACTER-1B195;Lo;0;L;;;;;N;;;;;
+1B196;NUSHU CHARACTER-1B196;Lo;0;L;;;;;N;;;;;
+1B197;NUSHU CHARACTER-1B197;Lo;0;L;;;;;N;;;;;
+1B198;NUSHU CHARACTER-1B198;Lo;0;L;;;;;N;;;;;
+1B199;NUSHU CHARACTER-1B199;Lo;0;L;;;;;N;;;;;
+1B19A;NUSHU CHARACTER-1B19A;Lo;0;L;;;;;N;;;;;
+1B19B;NUSHU CHARACTER-1B19B;Lo;0;L;;;;;N;;;;;
+1B19C;NUSHU CHARACTER-1B19C;Lo;0;L;;;;;N;;;;;
+1B19D;NUSHU CHARACTER-1B19D;Lo;0;L;;;;;N;;;;;
+1B19E;NUSHU CHARACTER-1B19E;Lo;0;L;;;;;N;;;;;
+1B19F;NUSHU CHARACTER-1B19F;Lo;0;L;;;;;N;;;;;
+1B1A0;NUSHU CHARACTER-1B1A0;Lo;0;L;;;;;N;;;;;
+1B1A1;NUSHU CHARACTER-1B1A1;Lo;0;L;;;;;N;;;;;
+1B1A2;NUSHU CHARACTER-1B1A2;Lo;0;L;;;;;N;;;;;
+1B1A3;NUSHU CHARACTER-1B1A3;Lo;0;L;;;;;N;;;;;
+1B1A4;NUSHU CHARACTER-1B1A4;Lo;0;L;;;;;N;;;;;
+1B1A5;NUSHU CHARACTER-1B1A5;Lo;0;L;;;;;N;;;;;
+1B1A6;NUSHU CHARACTER-1B1A6;Lo;0;L;;;;;N;;;;;
+1B1A7;NUSHU CHARACTER-1B1A7;Lo;0;L;;;;;N;;;;;
+1B1A8;NUSHU CHARACTER-1B1A8;Lo;0;L;;;;;N;;;;;
+1B1A9;NUSHU CHARACTER-1B1A9;Lo;0;L;;;;;N;;;;;
+1B1AA;NUSHU CHARACTER-1B1AA;Lo;0;L;;;;;N;;;;;
+1B1AB;NUSHU CHARACTER-1B1AB;Lo;0;L;;;;;N;;;;;
+1B1AC;NUSHU CHARACTER-1B1AC;Lo;0;L;;;;;N;;;;;
+1B1AD;NUSHU CHARACTER-1B1AD;Lo;0;L;;;;;N;;;;;
+1B1AE;NUSHU CHARACTER-1B1AE;Lo;0;L;;;;;N;;;;;
+1B1AF;NUSHU CHARACTER-1B1AF;Lo;0;L;;;;;N;;;;;
+1B1B0;NUSHU CHARACTER-1B1B0;Lo;0;L;;;;;N;;;;;
+1B1B1;NUSHU CHARACTER-1B1B1;Lo;0;L;;;;;N;;;;;
+1B1B2;NUSHU CHARACTER-1B1B2;Lo;0;L;;;;;N;;;;;
+1B1B3;NUSHU CHARACTER-1B1B3;Lo;0;L;;;;;N;;;;;
+1B1B4;NUSHU CHARACTER-1B1B4;Lo;0;L;;;;;N;;;;;
+1B1B5;NUSHU CHARACTER-1B1B5;Lo;0;L;;;;;N;;;;;
+1B1B6;NUSHU CHARACTER-1B1B6;Lo;0;L;;;;;N;;;;;
+1B1B7;NUSHU CHARACTER-1B1B7;Lo;0;L;;;;;N;;;;;
+1B1B8;NUSHU CHARACTER-1B1B8;Lo;0;L;;;;;N;;;;;
+1B1B9;NUSHU CHARACTER-1B1B9;Lo;0;L;;;;;N;;;;;
+1B1BA;NUSHU CHARACTER-1B1BA;Lo;0;L;;;;;N;;;;;
+1B1BB;NUSHU CHARACTER-1B1BB;Lo;0;L;;;;;N;;;;;
+1B1BC;NUSHU CHARACTER-1B1BC;Lo;0;L;;;;;N;;;;;
+1B1BD;NUSHU CHARACTER-1B1BD;Lo;0;L;;;;;N;;;;;
+1B1BE;NUSHU CHARACTER-1B1BE;Lo;0;L;;;;;N;;;;;
+1B1BF;NUSHU CHARACTER-1B1BF;Lo;0;L;;;;;N;;;;;
+1B1C0;NUSHU CHARACTER-1B1C0;Lo;0;L;;;;;N;;;;;
+1B1C1;NUSHU CHARACTER-1B1C1;Lo;0;L;;;;;N;;;;;
+1B1C2;NUSHU CHARACTER-1B1C2;Lo;0;L;;;;;N;;;;;
+1B1C3;NUSHU CHARACTER-1B1C3;Lo;0;L;;;;;N;;;;;
+1B1C4;NUSHU CHARACTER-1B1C4;Lo;0;L;;;;;N;;;;;
+1B1C5;NUSHU CHARACTER-1B1C5;Lo;0;L;;;;;N;;;;;
+1B1C6;NUSHU CHARACTER-1B1C6;Lo;0;L;;;;;N;;;;;
+1B1C7;NUSHU CHARACTER-1B1C7;Lo;0;L;;;;;N;;;;;
+1B1C8;NUSHU CHARACTER-1B1C8;Lo;0;L;;;;;N;;;;;
+1B1C9;NUSHU CHARACTER-1B1C9;Lo;0;L;;;;;N;;;;;
+1B1CA;NUSHU CHARACTER-1B1CA;Lo;0;L;;;;;N;;;;;
+1B1CB;NUSHU CHARACTER-1B1CB;Lo;0;L;;;;;N;;;;;
+1B1CC;NUSHU CHARACTER-1B1CC;Lo;0;L;;;;;N;;;;;
+1B1CD;NUSHU CHARACTER-1B1CD;Lo;0;L;;;;;N;;;;;
+1B1CE;NUSHU CHARACTER-1B1CE;Lo;0;L;;;;;N;;;;;
+1B1CF;NUSHU CHARACTER-1B1CF;Lo;0;L;;;;;N;;;;;
+1B1D0;NUSHU CHARACTER-1B1D0;Lo;0;L;;;;;N;;;;;
+1B1D1;NUSHU CHARACTER-1B1D1;Lo;0;L;;;;;N;;;;;
+1B1D2;NUSHU CHARACTER-1B1D2;Lo;0;L;;;;;N;;;;;
+1B1D3;NUSHU CHARACTER-1B1D3;Lo;0;L;;;;;N;;;;;
+1B1D4;NUSHU CHARACTER-1B1D4;Lo;0;L;;;;;N;;;;;
+1B1D5;NUSHU CHARACTER-1B1D5;Lo;0;L;;;;;N;;;;;
+1B1D6;NUSHU CHARACTER-1B1D6;Lo;0;L;;;;;N;;;;;
+1B1D7;NUSHU CHARACTER-1B1D7;Lo;0;L;;;;;N;;;;;
+1B1D8;NUSHU CHARACTER-1B1D8;Lo;0;L;;;;;N;;;;;
+1B1D9;NUSHU CHARACTER-1B1D9;Lo;0;L;;;;;N;;;;;
+1B1DA;NUSHU CHARACTER-1B1DA;Lo;0;L;;;;;N;;;;;
+1B1DB;NUSHU CHARACTER-1B1DB;Lo;0;L;;;;;N;;;;;
+1B1DC;NUSHU CHARACTER-1B1DC;Lo;0;L;;;;;N;;;;;
+1B1DD;NUSHU CHARACTER-1B1DD;Lo;0;L;;;;;N;;;;;
+1B1DE;NUSHU CHARACTER-1B1DE;Lo;0;L;;;;;N;;;;;
+1B1DF;NUSHU CHARACTER-1B1DF;Lo;0;L;;;;;N;;;;;
+1B1E0;NUSHU CHARACTER-1B1E0;Lo;0;L;;;;;N;;;;;
+1B1E1;NUSHU CHARACTER-1B1E1;Lo;0;L;;;;;N;;;;;
+1B1E2;NUSHU CHARACTER-1B1E2;Lo;0;L;;;;;N;;;;;
+1B1E3;NUSHU CHARACTER-1B1E3;Lo;0;L;;;;;N;;;;;
+1B1E4;NUSHU CHARACTER-1B1E4;Lo;0;L;;;;;N;;;;;
+1B1E5;NUSHU CHARACTER-1B1E5;Lo;0;L;;;;;N;;;;;
+1B1E6;NUSHU CHARACTER-1B1E6;Lo;0;L;;;;;N;;;;;
+1B1E7;NUSHU CHARACTER-1B1E7;Lo;0;L;;;;;N;;;;;
+1B1E8;NUSHU CHARACTER-1B1E8;Lo;0;L;;;;;N;;;;;
+1B1E9;NUSHU CHARACTER-1B1E9;Lo;0;L;;;;;N;;;;;
+1B1EA;NUSHU CHARACTER-1B1EA;Lo;0;L;;;;;N;;;;;
+1B1EB;NUSHU CHARACTER-1B1EB;Lo;0;L;;;;;N;;;;;
+1B1EC;NUSHU CHARACTER-1B1EC;Lo;0;L;;;;;N;;;;;
+1B1ED;NUSHU CHARACTER-1B1ED;Lo;0;L;;;;;N;;;;;
+1B1EE;NUSHU CHARACTER-1B1EE;Lo;0;L;;;;;N;;;;;
+1B1EF;NUSHU CHARACTER-1B1EF;Lo;0;L;;;;;N;;;;;
+1B1F0;NUSHU CHARACTER-1B1F0;Lo;0;L;;;;;N;;;;;
+1B1F1;NUSHU CHARACTER-1B1F1;Lo;0;L;;;;;N;;;;;
+1B1F2;NUSHU CHARACTER-1B1F2;Lo;0;L;;;;;N;;;;;
+1B1F3;NUSHU CHARACTER-1B1F3;Lo;0;L;;;;;N;;;;;
+1B1F4;NUSHU CHARACTER-1B1F4;Lo;0;L;;;;;N;;;;;
+1B1F5;NUSHU CHARACTER-1B1F5;Lo;0;L;;;;;N;;;;;
+1B1F6;NUSHU CHARACTER-1B1F6;Lo;0;L;;;;;N;;;;;
+1B1F7;NUSHU CHARACTER-1B1F7;Lo;0;L;;;;;N;;;;;
+1B1F8;NUSHU CHARACTER-1B1F8;Lo;0;L;;;;;N;;;;;
+1B1F9;NUSHU CHARACTER-1B1F9;Lo;0;L;;;;;N;;;;;
+1B1FA;NUSHU CHARACTER-1B1FA;Lo;0;L;;;;;N;;;;;
+1B1FB;NUSHU CHARACTER-1B1FB;Lo;0;L;;;;;N;;;;;
+1B1FC;NUSHU CHARACTER-1B1FC;Lo;0;L;;;;;N;;;;;
+1B1FD;NUSHU CHARACTER-1B1FD;Lo;0;L;;;;;N;;;;;
+1B1FE;NUSHU CHARACTER-1B1FE;Lo;0;L;;;;;N;;;;;
+1B1FF;NUSHU CHARACTER-1B1FF;Lo;0;L;;;;;N;;;;;
+1B200;NUSHU CHARACTER-1B200;Lo;0;L;;;;;N;;;;;
+1B201;NUSHU CHARACTER-1B201;Lo;0;L;;;;;N;;;;;
+1B202;NUSHU CHARACTER-1B202;Lo;0;L;;;;;N;;;;;
+1B203;NUSHU CHARACTER-1B203;Lo;0;L;;;;;N;;;;;
+1B204;NUSHU CHARACTER-1B204;Lo;0;L;;;;;N;;;;;
+1B205;NUSHU CHARACTER-1B205;Lo;0;L;;;;;N;;;;;
+1B206;NUSHU CHARACTER-1B206;Lo;0;L;;;;;N;;;;;
+1B207;NUSHU CHARACTER-1B207;Lo;0;L;;;;;N;;;;;
+1B208;NUSHU CHARACTER-1B208;Lo;0;L;;;;;N;;;;;
+1B209;NUSHU CHARACTER-1B209;Lo;0;L;;;;;N;;;;;
+1B20A;NUSHU CHARACTER-1B20A;Lo;0;L;;;;;N;;;;;
+1B20B;NUSHU CHARACTER-1B20B;Lo;0;L;;;;;N;;;;;
+1B20C;NUSHU CHARACTER-1B20C;Lo;0;L;;;;;N;;;;;
+1B20D;NUSHU CHARACTER-1B20D;Lo;0;L;;;;;N;;;;;
+1B20E;NUSHU CHARACTER-1B20E;Lo;0;L;;;;;N;;;;;
+1B20F;NUSHU CHARACTER-1B20F;Lo;0;L;;;;;N;;;;;
+1B210;NUSHU CHARACTER-1B210;Lo;0;L;;;;;N;;;;;
+1B211;NUSHU CHARACTER-1B211;Lo;0;L;;;;;N;;;;;
+1B212;NUSHU CHARACTER-1B212;Lo;0;L;;;;;N;;;;;
+1B213;NUSHU CHARACTER-1B213;Lo;0;L;;;;;N;;;;;
+1B214;NUSHU CHARACTER-1B214;Lo;0;L;;;;;N;;;;;
+1B215;NUSHU CHARACTER-1B215;Lo;0;L;;;;;N;;;;;
+1B216;NUSHU CHARACTER-1B216;Lo;0;L;;;;;N;;;;;
+1B217;NUSHU CHARACTER-1B217;Lo;0;L;;;;;N;;;;;
+1B218;NUSHU CHARACTER-1B218;Lo;0;L;;;;;N;;;;;
+1B219;NUSHU CHARACTER-1B219;Lo;0;L;;;;;N;;;;;
+1B21A;NUSHU CHARACTER-1B21A;Lo;0;L;;;;;N;;;;;
+1B21B;NUSHU CHARACTER-1B21B;Lo;0;L;;;;;N;;;;;
+1B21C;NUSHU CHARACTER-1B21C;Lo;0;L;;;;;N;;;;;
+1B21D;NUSHU CHARACTER-1B21D;Lo;0;L;;;;;N;;;;;
+1B21E;NUSHU CHARACTER-1B21E;Lo;0;L;;;;;N;;;;;
+1B21F;NUSHU CHARACTER-1B21F;Lo;0;L;;;;;N;;;;;
+1B220;NUSHU CHARACTER-1B220;Lo;0;L;;;;;N;;;;;
+1B221;NUSHU CHARACTER-1B221;Lo;0;L;;;;;N;;;;;
+1B222;NUSHU CHARACTER-1B222;Lo;0;L;;;;;N;;;;;
+1B223;NUSHU CHARACTER-1B223;Lo;0;L;;;;;N;;;;;
+1B224;NUSHU CHARACTER-1B224;Lo;0;L;;;;;N;;;;;
+1B225;NUSHU CHARACTER-1B225;Lo;0;L;;;;;N;;;;;
+1B226;NUSHU CHARACTER-1B226;Lo;0;L;;;;;N;;;;;
+1B227;NUSHU CHARACTER-1B227;Lo;0;L;;;;;N;;;;;
+1B228;NUSHU CHARACTER-1B228;Lo;0;L;;;;;N;;;;;
+1B229;NUSHU CHARACTER-1B229;Lo;0;L;;;;;N;;;;;
+1B22A;NUSHU CHARACTER-1B22A;Lo;0;L;;;;;N;;;;;
+1B22B;NUSHU CHARACTER-1B22B;Lo;0;L;;;;;N;;;;;
+1B22C;NUSHU CHARACTER-1B22C;Lo;0;L;;;;;N;;;;;
+1B22D;NUSHU CHARACTER-1B22D;Lo;0;L;;;;;N;;;;;
+1B22E;NUSHU CHARACTER-1B22E;Lo;0;L;;;;;N;;;;;
+1B22F;NUSHU CHARACTER-1B22F;Lo;0;L;;;;;N;;;;;
+1B230;NUSHU CHARACTER-1B230;Lo;0;L;;;;;N;;;;;
+1B231;NUSHU CHARACTER-1B231;Lo;0;L;;;;;N;;;;;
+1B232;NUSHU CHARACTER-1B232;Lo;0;L;;;;;N;;;;;
+1B233;NUSHU CHARACTER-1B233;Lo;0;L;;;;;N;;;;;
+1B234;NUSHU CHARACTER-1B234;Lo;0;L;;;;;N;;;;;
+1B235;NUSHU CHARACTER-1B235;Lo;0;L;;;;;N;;;;;
+1B236;NUSHU CHARACTER-1B236;Lo;0;L;;;;;N;;;;;
+1B237;NUSHU CHARACTER-1B237;Lo;0;L;;;;;N;;;;;
+1B238;NUSHU CHARACTER-1B238;Lo;0;L;;;;;N;;;;;
+1B239;NUSHU CHARACTER-1B239;Lo;0;L;;;;;N;;;;;
+1B23A;NUSHU CHARACTER-1B23A;Lo;0;L;;;;;N;;;;;
+1B23B;NUSHU CHARACTER-1B23B;Lo;0;L;;;;;N;;;;;
+1B23C;NUSHU CHARACTER-1B23C;Lo;0;L;;;;;N;;;;;
+1B23D;NUSHU CHARACTER-1B23D;Lo;0;L;;;;;N;;;;;
+1B23E;NUSHU CHARACTER-1B23E;Lo;0;L;;;;;N;;;;;
+1B23F;NUSHU CHARACTER-1B23F;Lo;0;L;;;;;N;;;;;
+1B240;NUSHU CHARACTER-1B240;Lo;0;L;;;;;N;;;;;
+1B241;NUSHU CHARACTER-1B241;Lo;0;L;;;;;N;;;;;
+1B242;NUSHU CHARACTER-1B242;Lo;0;L;;;;;N;;;;;
+1B243;NUSHU CHARACTER-1B243;Lo;0;L;;;;;N;;;;;
+1B244;NUSHU CHARACTER-1B244;Lo;0;L;;;;;N;;;;;
+1B245;NUSHU CHARACTER-1B245;Lo;0;L;;;;;N;;;;;
+1B246;NUSHU CHARACTER-1B246;Lo;0;L;;;;;N;;;;;
+1B247;NUSHU CHARACTER-1B247;Lo;0;L;;;;;N;;;;;
+1B248;NUSHU CHARACTER-1B248;Lo;0;L;;;;;N;;;;;
+1B249;NUSHU CHARACTER-1B249;Lo;0;L;;;;;N;;;;;
+1B24A;NUSHU CHARACTER-1B24A;Lo;0;L;;;;;N;;;;;
+1B24B;NUSHU CHARACTER-1B24B;Lo;0;L;;;;;N;;;;;
+1B24C;NUSHU CHARACTER-1B24C;Lo;0;L;;;;;N;;;;;
+1B24D;NUSHU CHARACTER-1B24D;Lo;0;L;;;;;N;;;;;
+1B24E;NUSHU CHARACTER-1B24E;Lo;0;L;;;;;N;;;;;
+1B24F;NUSHU CHARACTER-1B24F;Lo;0;L;;;;;N;;;;;
+1B250;NUSHU CHARACTER-1B250;Lo;0;L;;;;;N;;;;;
+1B251;NUSHU CHARACTER-1B251;Lo;0;L;;;;;N;;;;;
+1B252;NUSHU CHARACTER-1B252;Lo;0;L;;;;;N;;;;;
+1B253;NUSHU CHARACTER-1B253;Lo;0;L;;;;;N;;;;;
+1B254;NUSHU CHARACTER-1B254;Lo;0;L;;;;;N;;;;;
+1B255;NUSHU CHARACTER-1B255;Lo;0;L;;;;;N;;;;;
+1B256;NUSHU CHARACTER-1B256;Lo;0;L;;;;;N;;;;;
+1B257;NUSHU CHARACTER-1B257;Lo;0;L;;;;;N;;;;;
+1B258;NUSHU CHARACTER-1B258;Lo;0;L;;;;;N;;;;;
+1B259;NUSHU CHARACTER-1B259;Lo;0;L;;;;;N;;;;;
+1B25A;NUSHU CHARACTER-1B25A;Lo;0;L;;;;;N;;;;;
+1B25B;NUSHU CHARACTER-1B25B;Lo;0;L;;;;;N;;;;;
+1B25C;NUSHU CHARACTER-1B25C;Lo;0;L;;;;;N;;;;;
+1B25D;NUSHU CHARACTER-1B25D;Lo;0;L;;;;;N;;;;;
+1B25E;NUSHU CHARACTER-1B25E;Lo;0;L;;;;;N;;;;;
+1B25F;NUSHU CHARACTER-1B25F;Lo;0;L;;;;;N;;;;;
+1B260;NUSHU CHARACTER-1B260;Lo;0;L;;;;;N;;;;;
+1B261;NUSHU CHARACTER-1B261;Lo;0;L;;;;;N;;;;;
+1B262;NUSHU CHARACTER-1B262;Lo;0;L;;;;;N;;;;;
+1B263;NUSHU CHARACTER-1B263;Lo;0;L;;;;;N;;;;;
+1B264;NUSHU CHARACTER-1B264;Lo;0;L;;;;;N;;;;;
+1B265;NUSHU CHARACTER-1B265;Lo;0;L;;;;;N;;;;;
+1B266;NUSHU CHARACTER-1B266;Lo;0;L;;;;;N;;;;;
+1B267;NUSHU CHARACTER-1B267;Lo;0;L;;;;;N;;;;;
+1B268;NUSHU CHARACTER-1B268;Lo;0;L;;;;;N;;;;;
+1B269;NUSHU CHARACTER-1B269;Lo;0;L;;;;;N;;;;;
+1B26A;NUSHU CHARACTER-1B26A;Lo;0;L;;;;;N;;;;;
+1B26B;NUSHU CHARACTER-1B26B;Lo;0;L;;;;;N;;;;;
+1B26C;NUSHU CHARACTER-1B26C;Lo;0;L;;;;;N;;;;;
+1B26D;NUSHU CHARACTER-1B26D;Lo;0;L;;;;;N;;;;;
+1B26E;NUSHU CHARACTER-1B26E;Lo;0;L;;;;;N;;;;;
+1B26F;NUSHU CHARACTER-1B26F;Lo;0;L;;;;;N;;;;;
+1B270;NUSHU CHARACTER-1B270;Lo;0;L;;;;;N;;;;;
+1B271;NUSHU CHARACTER-1B271;Lo;0;L;;;;;N;;;;;
+1B272;NUSHU CHARACTER-1B272;Lo;0;L;;;;;N;;;;;
+1B273;NUSHU CHARACTER-1B273;Lo;0;L;;;;;N;;;;;
+1B274;NUSHU CHARACTER-1B274;Lo;0;L;;;;;N;;;;;
+1B275;NUSHU CHARACTER-1B275;Lo;0;L;;;;;N;;;;;
+1B276;NUSHU CHARACTER-1B276;Lo;0;L;;;;;N;;;;;
+1B277;NUSHU CHARACTER-1B277;Lo;0;L;;;;;N;;;;;
+1B278;NUSHU CHARACTER-1B278;Lo;0;L;;;;;N;;;;;
+1B279;NUSHU CHARACTER-1B279;Lo;0;L;;;;;N;;;;;
+1B27A;NUSHU CHARACTER-1B27A;Lo;0;L;;;;;N;;;;;
+1B27B;NUSHU CHARACTER-1B27B;Lo;0;L;;;;;N;;;;;
+1B27C;NUSHU CHARACTER-1B27C;Lo;0;L;;;;;N;;;;;
+1B27D;NUSHU CHARACTER-1B27D;Lo;0;L;;;;;N;;;;;
+1B27E;NUSHU CHARACTER-1B27E;Lo;0;L;;;;;N;;;;;
+1B27F;NUSHU CHARACTER-1B27F;Lo;0;L;;;;;N;;;;;
+1B280;NUSHU CHARACTER-1B280;Lo;0;L;;;;;N;;;;;
+1B281;NUSHU CHARACTER-1B281;Lo;0;L;;;;;N;;;;;
+1B282;NUSHU CHARACTER-1B282;Lo;0;L;;;;;N;;;;;
+1B283;NUSHU CHARACTER-1B283;Lo;0;L;;;;;N;;;;;
+1B284;NUSHU CHARACTER-1B284;Lo;0;L;;;;;N;;;;;
+1B285;NUSHU CHARACTER-1B285;Lo;0;L;;;;;N;;;;;
+1B286;NUSHU CHARACTER-1B286;Lo;0;L;;;;;N;;;;;
+1B287;NUSHU CHARACTER-1B287;Lo;0;L;;;;;N;;;;;
+1B288;NUSHU CHARACTER-1B288;Lo;0;L;;;;;N;;;;;
+1B289;NUSHU CHARACTER-1B289;Lo;0;L;;;;;N;;;;;
+1B28A;NUSHU CHARACTER-1B28A;Lo;0;L;;;;;N;;;;;
+1B28B;NUSHU CHARACTER-1B28B;Lo;0;L;;;;;N;;;;;
+1B28C;NUSHU CHARACTER-1B28C;Lo;0;L;;;;;N;;;;;
+1B28D;NUSHU CHARACTER-1B28D;Lo;0;L;;;;;N;;;;;
+1B28E;NUSHU CHARACTER-1B28E;Lo;0;L;;;;;N;;;;;
+1B28F;NUSHU CHARACTER-1B28F;Lo;0;L;;;;;N;;;;;
+1B290;NUSHU CHARACTER-1B290;Lo;0;L;;;;;N;;;;;
+1B291;NUSHU CHARACTER-1B291;Lo;0;L;;;;;N;;;;;
+1B292;NUSHU CHARACTER-1B292;Lo;0;L;;;;;N;;;;;
+1B293;NUSHU CHARACTER-1B293;Lo;0;L;;;;;N;;;;;
+1B294;NUSHU CHARACTER-1B294;Lo;0;L;;;;;N;;;;;
+1B295;NUSHU CHARACTER-1B295;Lo;0;L;;;;;N;;;;;
+1B296;NUSHU CHARACTER-1B296;Lo;0;L;;;;;N;;;;;
+1B297;NUSHU CHARACTER-1B297;Lo;0;L;;;;;N;;;;;
+1B298;NUSHU CHARACTER-1B298;Lo;0;L;;;;;N;;;;;
+1B299;NUSHU CHARACTER-1B299;Lo;0;L;;;;;N;;;;;
+1B29A;NUSHU CHARACTER-1B29A;Lo;0;L;;;;;N;;;;;
+1B29B;NUSHU CHARACTER-1B29B;Lo;0;L;;;;;N;;;;;
+1B29C;NUSHU CHARACTER-1B29C;Lo;0;L;;;;;N;;;;;
+1B29D;NUSHU CHARACTER-1B29D;Lo;0;L;;;;;N;;;;;
+1B29E;NUSHU CHARACTER-1B29E;Lo;0;L;;;;;N;;;;;
+1B29F;NUSHU CHARACTER-1B29F;Lo;0;L;;;;;N;;;;;
+1B2A0;NUSHU CHARACTER-1B2A0;Lo;0;L;;;;;N;;;;;
+1B2A1;NUSHU CHARACTER-1B2A1;Lo;0;L;;;;;N;;;;;
+1B2A2;NUSHU CHARACTER-1B2A2;Lo;0;L;;;;;N;;;;;
+1B2A3;NUSHU CHARACTER-1B2A3;Lo;0;L;;;;;N;;;;;
+1B2A4;NUSHU CHARACTER-1B2A4;Lo;0;L;;;;;N;;;;;
+1B2A5;NUSHU CHARACTER-1B2A5;Lo;0;L;;;;;N;;;;;
+1B2A6;NUSHU CHARACTER-1B2A6;Lo;0;L;;;;;N;;;;;
+1B2A7;NUSHU CHARACTER-1B2A7;Lo;0;L;;;;;N;;;;;
+1B2A8;NUSHU CHARACTER-1B2A8;Lo;0;L;;;;;N;;;;;
+1B2A9;NUSHU CHARACTER-1B2A9;Lo;0;L;;;;;N;;;;;
+1B2AA;NUSHU CHARACTER-1B2AA;Lo;0;L;;;;;N;;;;;
+1B2AB;NUSHU CHARACTER-1B2AB;Lo;0;L;;;;;N;;;;;
+1B2AC;NUSHU CHARACTER-1B2AC;Lo;0;L;;;;;N;;;;;
+1B2AD;NUSHU CHARACTER-1B2AD;Lo;0;L;;;;;N;;;;;
+1B2AE;NUSHU CHARACTER-1B2AE;Lo;0;L;;;;;N;;;;;
+1B2AF;NUSHU CHARACTER-1B2AF;Lo;0;L;;;;;N;;;;;
+1B2B0;NUSHU CHARACTER-1B2B0;Lo;0;L;;;;;N;;;;;
+1B2B1;NUSHU CHARACTER-1B2B1;Lo;0;L;;;;;N;;;;;
+1B2B2;NUSHU CHARACTER-1B2B2;Lo;0;L;;;;;N;;;;;
+1B2B3;NUSHU CHARACTER-1B2B3;Lo;0;L;;;;;N;;;;;
+1B2B4;NUSHU CHARACTER-1B2B4;Lo;0;L;;;;;N;;;;;
+1B2B5;NUSHU CHARACTER-1B2B5;Lo;0;L;;;;;N;;;;;
+1B2B6;NUSHU CHARACTER-1B2B6;Lo;0;L;;;;;N;;;;;
+1B2B7;NUSHU CHARACTER-1B2B7;Lo;0;L;;;;;N;;;;;
+1B2B8;NUSHU CHARACTER-1B2B8;Lo;0;L;;;;;N;;;;;
+1B2B9;NUSHU CHARACTER-1B2B9;Lo;0;L;;;;;N;;;;;
+1B2BA;NUSHU CHARACTER-1B2BA;Lo;0;L;;;;;N;;;;;
+1B2BB;NUSHU CHARACTER-1B2BB;Lo;0;L;;;;;N;;;;;
+1B2BC;NUSHU CHARACTER-1B2BC;Lo;0;L;;;;;N;;;;;
+1B2BD;NUSHU CHARACTER-1B2BD;Lo;0;L;;;;;N;;;;;
+1B2BE;NUSHU CHARACTER-1B2BE;Lo;0;L;;;;;N;;;;;
+1B2BF;NUSHU CHARACTER-1B2BF;Lo;0;L;;;;;N;;;;;
+1B2C0;NUSHU CHARACTER-1B2C0;Lo;0;L;;;;;N;;;;;
+1B2C1;NUSHU CHARACTER-1B2C1;Lo;0;L;;;;;N;;;;;
+1B2C2;NUSHU CHARACTER-1B2C2;Lo;0;L;;;;;N;;;;;
+1B2C3;NUSHU CHARACTER-1B2C3;Lo;0;L;;;;;N;;;;;
+1B2C4;NUSHU CHARACTER-1B2C4;Lo;0;L;;;;;N;;;;;
+1B2C5;NUSHU CHARACTER-1B2C5;Lo;0;L;;;;;N;;;;;
+1B2C6;NUSHU CHARACTER-1B2C6;Lo;0;L;;;;;N;;;;;
+1B2C7;NUSHU CHARACTER-1B2C7;Lo;0;L;;;;;N;;;;;
+1B2C8;NUSHU CHARACTER-1B2C8;Lo;0;L;;;;;N;;;;;
+1B2C9;NUSHU CHARACTER-1B2C9;Lo;0;L;;;;;N;;;;;
+1B2CA;NUSHU CHARACTER-1B2CA;Lo;0;L;;;;;N;;;;;
+1B2CB;NUSHU CHARACTER-1B2CB;Lo;0;L;;;;;N;;;;;
+1B2CC;NUSHU CHARACTER-1B2CC;Lo;0;L;;;;;N;;;;;
+1B2CD;NUSHU CHARACTER-1B2CD;Lo;0;L;;;;;N;;;;;
+1B2CE;NUSHU CHARACTER-1B2CE;Lo;0;L;;;;;N;;;;;
+1B2CF;NUSHU CHARACTER-1B2CF;Lo;0;L;;;;;N;;;;;
+1B2D0;NUSHU CHARACTER-1B2D0;Lo;0;L;;;;;N;;;;;
+1B2D1;NUSHU CHARACTER-1B2D1;Lo;0;L;;;;;N;;;;;
+1B2D2;NUSHU CHARACTER-1B2D2;Lo;0;L;;;;;N;;;;;
+1B2D3;NUSHU CHARACTER-1B2D3;Lo;0;L;;;;;N;;;;;
+1B2D4;NUSHU CHARACTER-1B2D4;Lo;0;L;;;;;N;;;;;
+1B2D5;NUSHU CHARACTER-1B2D5;Lo;0;L;;;;;N;;;;;
+1B2D6;NUSHU CHARACTER-1B2D6;Lo;0;L;;;;;N;;;;;
+1B2D7;NUSHU CHARACTER-1B2D7;Lo;0;L;;;;;N;;;;;
+1B2D8;NUSHU CHARACTER-1B2D8;Lo;0;L;;;;;N;;;;;
+1B2D9;NUSHU CHARACTER-1B2D9;Lo;0;L;;;;;N;;;;;
+1B2DA;NUSHU CHARACTER-1B2DA;Lo;0;L;;;;;N;;;;;
+1B2DB;NUSHU CHARACTER-1B2DB;Lo;0;L;;;;;N;;;;;
+1B2DC;NUSHU CHARACTER-1B2DC;Lo;0;L;;;;;N;;;;;
+1B2DD;NUSHU CHARACTER-1B2DD;Lo;0;L;;;;;N;;;;;
+1B2DE;NUSHU CHARACTER-1B2DE;Lo;0;L;;;;;N;;;;;
+1B2DF;NUSHU CHARACTER-1B2DF;Lo;0;L;;;;;N;;;;;
+1B2E0;NUSHU CHARACTER-1B2E0;Lo;0;L;;;;;N;;;;;
+1B2E1;NUSHU CHARACTER-1B2E1;Lo;0;L;;;;;N;;;;;
+1B2E2;NUSHU CHARACTER-1B2E2;Lo;0;L;;;;;N;;;;;
+1B2E3;NUSHU CHARACTER-1B2E3;Lo;0;L;;;;;N;;;;;
+1B2E4;NUSHU CHARACTER-1B2E4;Lo;0;L;;;;;N;;;;;
+1B2E5;NUSHU CHARACTER-1B2E5;Lo;0;L;;;;;N;;;;;
+1B2E6;NUSHU CHARACTER-1B2E6;Lo;0;L;;;;;N;;;;;
+1B2E7;NUSHU CHARACTER-1B2E7;Lo;0;L;;;;;N;;;;;
+1B2E8;NUSHU CHARACTER-1B2E8;Lo;0;L;;;;;N;;;;;
+1B2E9;NUSHU CHARACTER-1B2E9;Lo;0;L;;;;;N;;;;;
+1B2EA;NUSHU CHARACTER-1B2EA;Lo;0;L;;;;;N;;;;;
+1B2EB;NUSHU CHARACTER-1B2EB;Lo;0;L;;;;;N;;;;;
+1B2EC;NUSHU CHARACTER-1B2EC;Lo;0;L;;;;;N;;;;;
+1B2ED;NUSHU CHARACTER-1B2ED;Lo;0;L;;;;;N;;;;;
+1B2EE;NUSHU CHARACTER-1B2EE;Lo;0;L;;;;;N;;;;;
+1B2EF;NUSHU CHARACTER-1B2EF;Lo;0;L;;;;;N;;;;;
+1B2F0;NUSHU CHARACTER-1B2F0;Lo;0;L;;;;;N;;;;;
+1B2F1;NUSHU CHARACTER-1B2F1;Lo;0;L;;;;;N;;;;;
+1B2F2;NUSHU CHARACTER-1B2F2;Lo;0;L;;;;;N;;;;;
+1B2F3;NUSHU CHARACTER-1B2F3;Lo;0;L;;;;;N;;;;;
+1B2F4;NUSHU CHARACTER-1B2F4;Lo;0;L;;;;;N;;;;;
+1B2F5;NUSHU CHARACTER-1B2F5;Lo;0;L;;;;;N;;;;;
+1B2F6;NUSHU CHARACTER-1B2F6;Lo;0;L;;;;;N;;;;;
+1B2F7;NUSHU CHARACTER-1B2F7;Lo;0;L;;;;;N;;;;;
+1B2F8;NUSHU CHARACTER-1B2F8;Lo;0;L;;;;;N;;;;;
+1B2F9;NUSHU CHARACTER-1B2F9;Lo;0;L;;;;;N;;;;;
+1B2FA;NUSHU CHARACTER-1B2FA;Lo;0;L;;;;;N;;;;;
+1B2FB;NUSHU CHARACTER-1B2FB;Lo;0;L;;;;;N;;;;;
 1BC00;DUPLOYAN LETTER H;Lo;0;L;;;;;N;;;;;
 1BC01;DUPLOYAN LETTER X;Lo;0;L;;;;;N;;;;;
 1BC02;DUPLOYAN LETTER P;Lo;0;L;;;;;N;;;;;
@@ -22614,6 +32713,920 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1BCA1;SHORTHAND FORMAT CONTINUING OVERLAP;Cf;0;BN;;;;;N;;;;;
 1BCA2;SHORTHAND FORMAT DOWN STEP;Cf;0;BN;;;;;N;;;;;
 1BCA3;SHORTHAND FORMAT UP STEP;Cf;0;BN;;;;;N;;;;;
+1CC00;UP-POINTING GO-KART;So;0;ON;;;;;N;;;;;
+1CC01;RIGHT-POINTING GO-KART;So;0;ON;;;;;N;;;;;
+1CC02;LEFT-POINTING STICK FIGURE;So;0;ON;;;;;N;;;;;
+1CC03;RIGHT-POINTING STICK FIGURE;So;0;ON;;;;;N;;;;;
+1CC04;DOWN-POINTING STICK FIGURE;So;0;ON;;;;;N;;;;;
+1CC05;LOWER HORIZONTAL RULER SEGMENT;So;0;ON;;;;;N;;;;;
+1CC06;RIGHT VERTICAL RULER SEGMENT;So;0;ON;;;;;N;;;;;
+1CC07;LOWER RIGHT RULER SEGMENT;So;0;ON;;;;;N;;;;;
+1CC08;ANTENNA;So;0;ON;;;;;N;;;;;
+1CC09;HORIZONTAL RESISTOR SEGMENT;So;0;ON;;;;;N;;;;;
+1CC0A;VERTICAL RESISTOR SEGMENT;So;0;ON;;;;;N;;;;;
+1CC0B;LEFT THIRD INDUCTOR;So;0;ON;;;;;N;;;;;
+1CC0C;MIDDLE THIRD INDUCTOR;So;0;ON;;;;;N;;;;;
+1CC0D;RIGHT THIRD INDUCTOR;So;0;ON;;;;;N;;;;;
+1CC0E;LEFT-POINTING DIODE;So;0;ON;;;;;N;;;;;
+1CC0F;RIGHT-POINTING DIODE;So;0;ON;;;;;N;;;;;
+1CC10;NPN TRANSISTOR;So;0;ON;;;;;N;;;;;
+1CC11;PNP TRANSISTOR;So;0;ON;;;;;N;;;;;
+1CC12;RECEPTACLE;So;0;ON;;;;;N;;;;;
+1CC13;HORIZONTAL CAPACITOR;So;0;ON;;;;;N;;;;;
+1CC14;VERTICAL CAPACITOR;So;0;ON;;;;;N;;;;;
+1CC15;LOGIC GATE OR;So;0;ON;;;;;N;;;;;
+1CC16;LOGIC GATE AND;So;0;ON;;;;;N;;;;;
+1CC17;LOGIC GATE INVERTED INPUTS;So;0;ON;;;;;N;;;;;
+1CC18;LOGIC GATE INVERTED OUTPUT;So;0;ON;;;;;N;;;;;
+1CC19;LOGIC GATE BUFFER;So;0;ON;;;;;N;;;;;
+1CC1A;LOGIC GATE BUFFER WITH INVERTED INPUT;So;0;ON;;;;;N;;;;;
+1CC1B;BOX DRAWINGS LIGHT HORIZONTAL AND UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1CC1C;BOX DRAWINGS LIGHT HORIZONTAL AND LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1CC1D;BOX DRAWINGS LIGHT TOP AND UPPER LEFT;So;0;ON;;;;;N;;;;;
+1CC1E;BOX DRAWINGS LIGHT BOTTOM AND LOWER LEFT;So;0;ON;;;;;N;;;;;
+1CC1F;BOX DRAWINGS DOUBLE DIAGONAL UPPER RIGHT TO LOWER LEFT;So;0;ON;;;;;N;;;;;
+1CC20;BOX DRAWINGS DOUBLE DIAGONAL UPPER LEFT TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1CC21;SEPARATED BLOCK QUADRANT-1;So;0;ON;;;;;N;;;;;
+1CC22;SEPARATED BLOCK QUADRANT-2;So;0;ON;;;;;N;;;;;
+1CC23;SEPARATED BLOCK QUADRANT-12;So;0;ON;;;;;N;;;;;
+1CC24;SEPARATED BLOCK QUADRANT-3;So;0;ON;;;;;N;;;;;
+1CC25;SEPARATED BLOCK QUADRANT-13;So;0;ON;;;;;N;;;;;
+1CC26;SEPARATED BLOCK QUADRANT-23;So;0;ON;;;;;N;;;;;
+1CC27;SEPARATED BLOCK QUADRANT-123;So;0;ON;;;;;N;;;;;
+1CC28;SEPARATED BLOCK QUADRANT-4;So;0;ON;;;;;N;;;;;
+1CC29;SEPARATED BLOCK QUADRANT-14;So;0;ON;;;;;N;;;;;
+1CC2A;SEPARATED BLOCK QUADRANT-24;So;0;ON;;;;;N;;;;;
+1CC2B;SEPARATED BLOCK QUADRANT-124;So;0;ON;;;;;N;;;;;
+1CC2C;SEPARATED BLOCK QUADRANT-34;So;0;ON;;;;;N;;;;;
+1CC2D;SEPARATED BLOCK QUADRANT-134;So;0;ON;;;;;N;;;;;
+1CC2E;SEPARATED BLOCK QUADRANT-234;So;0;ON;;;;;N;;;;;
+1CC2F;SEPARATED BLOCK QUADRANT-1234;So;0;ON;;;;;N;;;;;
+1CC30;UPPER LEFT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC31;UPPER CENTRE LEFT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC32;UPPER CENTRE RIGHT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC33;UPPER RIGHT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC34;UPPER MIDDLE LEFT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC35;UPPER LEFT QUARTER CIRCLE;So;0;ON;;;;;N;;;;;
+1CC36;UPPER RIGHT QUARTER CIRCLE;So;0;ON;;;;;N;;;;;
+1CC37;UPPER MIDDLE RIGHT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC38;LOWER MIDDLE LEFT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC39;LOWER LEFT QUARTER CIRCLE;So;0;ON;;;;;N;;;;;
+1CC3A;LOWER RIGHT QUARTER CIRCLE;So;0;ON;;;;;N;;;;;
+1CC3B;LOWER MIDDLE RIGHT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC3C;LOWER LEFT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC3D;LOWER CENTRE LEFT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC3E;LOWER CENTRE RIGHT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC3F;LOWER RIGHT TWELFTH CIRCLE;So;0;ON;;;;;N;;;;;
+1CC40;SPARSE HORIZONTAL FILL;So;0;ON;;;;;N;;;;;
+1CC41;SPARSE VERTICAL FILL;So;0;ON;;;;;N;;;;;
+1CC42;ORTHOGONAL CROSSHATCH FILL;So;0;ON;;;;;N;;;;;
+1CC43;DIAGONAL CROSSHATCH FILL;So;0;ON;;;;;N;;;;;
+1CC44;DENSE VERTICAL FILL;So;0;ON;;;;;N;;;;;
+1CC45;DENSE HORIZONTAL FILL;So;0;ON;;;;;N;;;;;
+1CC46;SPECKLE FILL FRAME-1;So;0;ON;;;;;N;;;;;
+1CC47;SPECKLE FILL FRAME-2;So;0;ON;;;;;N;;;;;
+1CC48;LEFT-FACING BASSINET;So;0;ON;;;;;N;;;;;
+1CC49;RIGHT-FACING BASSINET;So;0;ON;;;;;N;;;;;
+1CC4A;FLYING SAUCER WITH BEAMS;So;0;ON;;;;;N;;;;;
+1CC4B;FLYING SAUCER WITHOUT BEAMS;So;0;ON;;;;;N;;;;;
+1CC4C;ALIEN MONSTER OPEN JAWS;So;0;ON;;;;;N;;;;;
+1CC4D;ALIEN MONSTER CLOSED JAWS;So;0;ON;;;;;N;;;;;
+1CC4E;ALIEN SQUID OPEN TENTACLES;So;0;ON;;;;;N;;;;;
+1CC4F;ALIEN SQUID CLOSED TENTACLES;So;0;ON;;;;;N;;;;;
+1CC50;ALIEN CRAB STEPPING RIGHT;So;0;ON;;;;;N;;;;;
+1CC51;ALIEN CRAB STEPPING LEFT;So;0;ON;;;;;N;;;;;
+1CC52;ALIEN SPIDER CROUCHING;So;0;ON;;;;;N;;;;;
+1CC53;ALIEN SPIDER SPREAD;So;0;ON;;;;;N;;;;;
+1CC54;ALIEN MONSTER STEP-1;So;0;ON;;;;;N;;;;;
+1CC55;ALIEN MONSTER STEP-2;So;0;ON;;;;;N;;;;;
+1CC56;LEFT-POINTING ROCKET SHIP;So;0;ON;;;;;N;;;;;
+1CC57;UP-POINTING ROCKET SHIP;So;0;ON;;;;;N;;;;;
+1CC58;RIGHT-POINTING ROCKET SHIP;So;0;ON;;;;;N;;;;;
+1CC59;DOWN-POINTING ROCKET SHIP;So;0;ON;;;;;N;;;;;
+1CC5A;TOP HALF LEFT-FACING ROBOT;So;0;ON;;;;;N;;;;;
+1CC5B;TOP HALF FORWARD-FACING ROBOT;So;0;ON;;;;;N;;;;;
+1CC5C;TOP HALF RIGHT-FACING ROBOT;So;0;ON;;;;;N;;;;;
+1CC5D;BOTTOM HALF LEFT-FACING ROBOT;So;0;ON;;;;;N;;;;;
+1CC5E;BOTTOM HALF FORWARD-FACING ROBOT;So;0;ON;;;;;N;;;;;
+1CC5F;BOTTOM HALF RIGHT-FACING ROBOT;So;0;ON;;;;;N;;;;;
+1CC60;LEFT-POINTING ATOMIC BOMB;So;0;ON;;;;;N;;;;;
+1CC61;UP-POINTING ATOMIC BOMB;So;0;ON;;;;;N;;;;;
+1CC62;RIGHT-POINTING ATOMIC BOMB;So;0;ON;;;;;N;;;;;
+1CC63;DOWN-POINTING ATOMIC BOMB;So;0;ON;;;;;N;;;;;
+1CC64;MUSHROOM CLOUD;So;0;ON;;;;;N;;;;;
+1CC65;LEFT-POINTING RIFLE;So;0;ON;;;;;N;;;;;
+1CC66;UP-POINTING RIFLE;So;0;ON;;;;;N;;;;;
+1CC67;RIGHT-POINTING RIFLE;So;0;ON;;;;;N;;;;;
+1CC68;DOWN-POINTING RIFLE;So;0;ON;;;;;N;;;;;
+1CC69;EIGHT RAYS INWARD;So;0;ON;;;;;N;;;;;
+1CC6A;EIGHT RAYS OUTWARD;So;0;ON;;;;;N;;;;;
+1CC6B;BLACK LARGE CIRCLE MINUS LEFT QUARTER SECTION;So;0;ON;;;;;N;;;;;
+1CC6C;BLACK LARGE CIRCLE MINUS UPPER QUARTER SECTION;So;0;ON;;;;;N;;;;;
+1CC6D;BLACK LARGE CIRCLE MINUS RIGHT QUARTER SECTION;So;0;ON;;;;;N;;;;;
+1CC6E;BLACK LARGE CIRCLE MINUS LOWER QUARTER SECTION;So;0;ON;;;;;N;;;;;
+1CC6F;BLACK NEUTRAL FACE;So;0;ON;;;;;N;;;;;
+1CC70;LEFT-FACING SNAKE HEAD WITH OPEN MOUTH;So;0;ON;;;;;N;;;;;
+1CC71;UP-FACING SNAKE HEAD WITH OPEN MOUTH;So;0;ON;;;;;N;;;;;
+1CC72;RIGHT-FACING SNAKE HEAD WITH OPEN MOUTH;So;0;ON;;;;;N;;;;;
+1CC73;DOWN-FACING SNAKE HEAD WITH OPEN MOUTH;So;0;ON;;;;;N;;;;;
+1CC74;LEFT-FACING SNAKE HEAD WITH CLOSED MOUTH;So;0;ON;;;;;N;;;;;
+1CC75;UP-FACING SNAKE HEAD WITH CLOSED MOUTH;So;0;ON;;;;;N;;;;;
+1CC76;RIGHT-FACING SNAKE HEAD WITH CLOSED MOUTH;So;0;ON;;;;;N;;;;;
+1CC77;DOWN-FACING SNAKE HEAD WITH CLOSED MOUTH;So;0;ON;;;;;N;;;;;
+1CC78;LEFT-POINTING ENERGY WAVE;So;0;ON;;;;;N;;;;;
+1CC79;UP-POINTING ENERGY WAVE;So;0;ON;;;;;N;;;;;
+1CC7A;RIGHT-POINTING ENERGY WAVE;So;0;ON;;;;;N;;;;;
+1CC7B;DOWN-POINTING ENERGY WAVE;So;0;ON;;;;;N;;;;;
+1CC7C;SQUARE SPIRAL FROM TOP LEFT;So;0;ON;;;;;N;;;;;
+1CC7D;SQUARE SPIRAL FROM TOP RIGHT;So;0;ON;;;;;N;;;;;
+1CC7E;SQUARE SPIRAL FROM BOTTOM RIGHT;So;0;ON;;;;;N;;;;;
+1CC7F;SQUARE SPIRAL FROM BOTTOM LEFT;So;0;ON;;;;;N;;;;;
+1CC80;STRIPED LEFT-POINTING TRIANGLE;So;0;ON;;;;;N;;;;;
+1CC81;STRIPED UP-POINTING TRIANGLE;So;0;ON;;;;;N;;;;;
+1CC82;STRIPED RIGHT-POINTING TRIANGLE;So;0;ON;;;;;N;;;;;
+1CC83;STRIPED DOWN-POINTING TRIANGLE;So;0;ON;;;;;N;;;;;
+1CC84;VERTICAL LADDER;So;0;ON;;;;;N;;;;;
+1CC85;HORIZONTAL LADDER;So;0;ON;;;;;N;;;;;
+1CC86;WHITE LOWER LEFT POINTER;So;0;ON;;;;;N;;;;;
+1CC87;WHITE LOWER RIGHT POINTER;So;0;ON;;;;;N;;;;;
+1CC88;TWO RINGS ALIGNED HORIZONTALLY;So;0;ON;;;;;N;;;;;
+1CC89;SQUARE FOUR CORNER SALTIRES;So;0;ON;;;;;N;;;;;
+1CC8A;SQUARE FOUR CORNER DIAGONALS;So;0;ON;;;;;N;;;;;
+1CC8B;SQUARE FOUR CORNER BLACK TRIANGLES;So;0;ON;;;;;N;;;;;
+1CC8C;SQUARE APERTURE;So;0;ON;;;;;N;;;;;
+1CC8D;INVERSE BLACK DIAMOND;So;0;ON;;;;;N;;;;;
+1CC8E;LEFT AND UPPER ONE EIGHTH BLOCK CONTAINING BLACK SMALL SQUARE;So;0;ON;;;;;N;;;;;
+1CC8F;INVERSE BLACK SMALL SQUARE;So;0;ON;;;;;N;;;;;
+1CC90;VERTICAL LINE WITH FOUR TICK MARKS;So;0;ON;;;;;N;;;;;
+1CC91;HORIZONTAL LINE WITH FOUR TICK MARKS;So;0;ON;;;;;N;;;;;
+1CC92;LEFT-FACING FISH;So;0;ON;;;;;N;;;;;
+1CC93;RIGHT-FACING FISH;So;0;ON;;;;;N;;;;;
+1CC94;LEFT-FACING FISH WITH OPEN MOUTH;So;0;ON;;;;;N;;;;;
+1CC95;RIGHT-FACING FISH WITH OPEN MOUTH;So;0;ON;;;;;N;;;;;
+1CC96;FLAPPING BIRD;So;0;ON;;;;;N;;;;;
+1CC97;LEFT-POINTING RACING CAR;So;0;ON;;;;;N;;;;;
+1CC98;UP-POINTING RACING CAR;So;0;ON;;;;;N;;;;;
+1CC99;RIGHT-POINTING RACING CAR;So;0;ON;;;;;N;;;;;
+1CC9A;DOWN-POINTING RACING CAR;So;0;ON;;;;;N;;;;;
+1CC9B;HORIZONTAL RACING CAR;So;0;ON;;;;;N;;;;;
+1CC9C;VERTICAL RACING CAR;So;0;ON;;;;;N;;;;;
+1CC9D;VERTICAL GO-KART;So;0;ON;;;;;N;;;;;
+1CC9E;LEFT-POINTING TANK;So;0;ON;;;;;N;;;;;
+1CC9F;RIGHT-POINTING TANK;So;0;ON;;;;;N;;;;;
+1CCA0;LEFT-POINTING ROCKET BOOSTER;So;0;ON;;;;;N;;;;;
+1CCA1;RIGHT-POINTING ROCKET BOOSTER;So;0;ON;;;;;N;;;;;
+1CCA2;LEFT-POINTING ROLLER COASTER CAR;So;0;ON;;;;;N;;;;;
+1CCA3;RIGHT-POINTING ROLLER COASTER CAR;So;0;ON;;;;;N;;;;;
+1CCA4;LEFT HALF FLYING SAUCER;So;0;ON;;;;;N;;;;;
+1CCA5;RIGHT HALF FLYING SAUCER;So;0;ON;;;;;N;;;;;
+1CCA6;UPPER LEFT QUADRANT FACE WITH OPEN EYES;So;0;ON;;;;;N;;;;;
+1CCA7;UPPER RIGHT QUADRANT FACE WITH OPEN EYES;So;0;ON;;;;;N;;;;;
+1CCA8;UPPER LEFT QUADRANT FACE WITH CLOSED EYES;So;0;ON;;;;;N;;;;;
+1CCA9;UPPER RIGHT QUADRANT FACE WITH CLOSED EYES;So;0;ON;;;;;N;;;;;
+1CCAA;LOWER LEFT QUADRANT SMILING FACE;So;0;ON;;;;;N;;;;;
+1CCAB;LOWER RIGHT QUADRANT SMILING FACE;So;0;ON;;;;;N;;;;;
+1CCAC;LOWER LEFT QUADRANT NEUTRAL FACE;So;0;ON;;;;;N;;;;;
+1CCAD;LOWER RIGHT QUADRANT NEUTRAL FACE;So;0;ON;;;;;N;;;;;
+1CCAE;LOWER LEFT QUADRANT FACE WITH OPEN MOUTH;So;0;ON;;;;;N;;;;;
+1CCAF;LOWER RIGHT QUADRANT FACE WITH OPEN MOUTH;So;0;ON;;;;;N;;;;;
+1CCB0;LOWER LEFT QUADRANT FROWNING FACE;So;0;ON;;;;;N;;;;;
+1CCB1;LOWER RIGHT QUADRANT FROWNING FACE;So;0;ON;;;;;N;;;;;
+1CCB2;UPPER LEFT QUADRANT TELEVISION;So;0;ON;;;;;N;;;;;
+1CCB3;UPPER RIGHT QUADRANT TELEVISION;So;0;ON;;;;;N;;;;;
+1CCB4;LOWER LEFT QUADRANT TELEVISION;So;0;ON;;;;;N;;;;;
+1CCB5;LOWER RIGHT QUADRANT TELEVISION;So;0;ON;;;;;N;;;;;
+1CCB6;UPPER LEFT QUADRANT MICROCOMPUTER;So;0;ON;;;;;N;;;;;
+1CCB7;UPPER RIGHT QUADRANT MICROCOMPUTER;So;0;ON;;;;;N;;;;;
+1CCB8;LOWER LEFT QUADRANT MICROCOMPUTER;So;0;ON;;;;;N;;;;;
+1CCB9;LOWER RIGHT QUADRANT MICROCOMPUTER;So;0;ON;;;;;N;;;;;
+1CCBA;UPPER LEFT QUADRANT CHESS KING;So;0;ON;;;;;N;;;;;
+1CCBB;UPPER RIGHT QUADRANT CHESS KING;So;0;ON;;;;;N;;;;;
+1CCBC;LOWER LEFT QUADRANT CHESS KING;So;0;ON;;;;;N;;;;;
+1CCBD;LOWER RIGHT QUADRANT CHESS KING;So;0;ON;;;;;N;;;;;
+1CCBE;UPPER LEFT QUADRANT CHESS QUEEN;So;0;ON;;;;;N;;;;;
+1CCBF;UPPER RIGHT QUADRANT CHESS QUEEN;So;0;ON;;;;;N;;;;;
+1CCC0;LOWER LEFT QUADRANT CHESS QUEEN;So;0;ON;;;;;N;;;;;
+1CCC1;LOWER RIGHT QUADRANT CHESS QUEEN;So;0;ON;;;;;N;;;;;
+1CCC2;UPPER LEFT QUADRANT CHESS ROOK;So;0;ON;;;;;N;;;;;
+1CCC3;UPPER RIGHT QUADRANT CHESS ROOK;So;0;ON;;;;;N;;;;;
+1CCC4;LOWER LEFT QUADRANT CHESS ROOK;So;0;ON;;;;;N;;;;;
+1CCC5;LOWER RIGHT QUADRANT CHESS ROOK;So;0;ON;;;;;N;;;;;
+1CCC6;UPPER LEFT QUADRANT CHESS BISHOP;So;0;ON;;;;;N;;;;;
+1CCC7;UPPER RIGHT QUADRANT CHESS BISHOP;So;0;ON;;;;;N;;;;;
+1CCC8;LOWER LEFT QUADRANT CHESS BISHOP;So;0;ON;;;;;N;;;;;
+1CCC9;LOWER RIGHT QUADRANT CHESS BISHOP;So;0;ON;;;;;N;;;;;
+1CCCA;UPPER LEFT QUADRANT CHESS KNIGHT;So;0;ON;;;;;N;;;;;
+1CCCB;UPPER RIGHT QUADRANT CHESS KNIGHT;So;0;ON;;;;;N;;;;;
+1CCCC;LOWER LEFT QUADRANT CHESS KNIGHT;So;0;ON;;;;;N;;;;;
+1CCCD;LOWER RIGHT QUADRANT CHESS KNIGHT;So;0;ON;;;;;N;;;;;
+1CCCE;UPPER LEFT QUADRANT CHESS PAWN;So;0;ON;;;;;N;;;;;
+1CCCF;UPPER RIGHT QUADRANT CHESS PAWN;So;0;ON;;;;;N;;;;;
+1CCD0;LOWER LEFT QUADRANT CHESS PAWN;So;0;ON;;;;;N;;;;;
+1CCD1;LOWER RIGHT QUADRANT CHESS PAWN;So;0;ON;;;;;N;;;;;
+1CCD2;UPPER LEFT QUADRANT STANDING KNIGHT;So;0;ON;;;;;N;;;;;
+1CCD3;UPPER RIGHT QUADRANT STANDING KNIGHT;So;0;ON;;;;;N;;;;;
+1CCD4;LOWER LEFT QUADRANT STANDING KNIGHT;So;0;ON;;;;;N;;;;;
+1CCD5;LOWER RIGHT QUADRANT STANDING KNIGHT;So;0;ON;;;;;N;;;;;
+1CCD6;OUTLINED LATIN CAPITAL LETTER A;So;0;L;<font> 0041;;;;N;;;;;
+1CCD7;OUTLINED LATIN CAPITAL LETTER B;So;0;L;<font> 0042;;;;N;;;;;
+1CCD8;OUTLINED LATIN CAPITAL LETTER C;So;0;L;<font> 0043;;;;N;;;;;
+1CCD9;OUTLINED LATIN CAPITAL LETTER D;So;0;L;<font> 0044;;;;N;;;;;
+1CCDA;OUTLINED LATIN CAPITAL LETTER E;So;0;L;<font> 0045;;;;N;;;;;
+1CCDB;OUTLINED LATIN CAPITAL LETTER F;So;0;L;<font> 0046;;;;N;;;;;
+1CCDC;OUTLINED LATIN CAPITAL LETTER G;So;0;L;<font> 0047;;;;N;;;;;
+1CCDD;OUTLINED LATIN CAPITAL LETTER H;So;0;L;<font> 0048;;;;N;;;;;
+1CCDE;OUTLINED LATIN CAPITAL LETTER I;So;0;L;<font> 0049;;;;N;;;;;
+1CCDF;OUTLINED LATIN CAPITAL LETTER J;So;0;L;<font> 004A;;;;N;;;;;
+1CCE0;OUTLINED LATIN CAPITAL LETTER K;So;0;L;<font> 004B;;;;N;;;;;
+1CCE1;OUTLINED LATIN CAPITAL LETTER L;So;0;L;<font> 004C;;;;N;;;;;
+1CCE2;OUTLINED LATIN CAPITAL LETTER M;So;0;L;<font> 004D;;;;N;;;;;
+1CCE3;OUTLINED LATIN CAPITAL LETTER N;So;0;L;<font> 004E;;;;N;;;;;
+1CCE4;OUTLINED LATIN CAPITAL LETTER O;So;0;L;<font> 004F;;;;N;;;;;
+1CCE5;OUTLINED LATIN CAPITAL LETTER P;So;0;L;<font> 0050;;;;N;;;;;
+1CCE6;OUTLINED LATIN CAPITAL LETTER Q;So;0;L;<font> 0051;;;;N;;;;;
+1CCE7;OUTLINED LATIN CAPITAL LETTER R;So;0;L;<font> 0052;;;;N;;;;;
+1CCE8;OUTLINED LATIN CAPITAL LETTER S;So;0;L;<font> 0053;;;;N;;;;;
+1CCE9;OUTLINED LATIN CAPITAL LETTER T;So;0;L;<font> 0054;;;;N;;;;;
+1CCEA;OUTLINED LATIN CAPITAL LETTER U;So;0;L;<font> 0055;;;;N;;;;;
+1CCEB;OUTLINED LATIN CAPITAL LETTER V;So;0;L;<font> 0056;;;;N;;;;;
+1CCEC;OUTLINED LATIN CAPITAL LETTER W;So;0;L;<font> 0057;;;;N;;;;;
+1CCED;OUTLINED LATIN CAPITAL LETTER X;So;0;L;<font> 0058;;;;N;;;;;
+1CCEE;OUTLINED LATIN CAPITAL LETTER Y;So;0;L;<font> 0059;;;;N;;;;;
+1CCEF;OUTLINED LATIN CAPITAL LETTER Z;So;0;L;<font> 005A;;;;N;;;;;
+1CCF0;OUTLINED DIGIT ZERO;Nd;0;EN;<font> 0030;0;0;0;N;;;;;
+1CCF1;OUTLINED DIGIT ONE;Nd;0;EN;<font> 0031;1;1;1;N;;;;;
+1CCF2;OUTLINED DIGIT TWO;Nd;0;EN;<font> 0032;2;2;2;N;;;;;
+1CCF3;OUTLINED DIGIT THREE;Nd;0;EN;<font> 0033;3;3;3;N;;;;;
+1CCF4;OUTLINED DIGIT FOUR;Nd;0;EN;<font> 0034;4;4;4;N;;;;;
+1CCF5;OUTLINED DIGIT FIVE;Nd;0;EN;<font> 0035;5;5;5;N;;;;;
+1CCF6;OUTLINED DIGIT SIX;Nd;0;EN;<font> 0036;6;6;6;N;;;;;
+1CCF7;OUTLINED DIGIT SEVEN;Nd;0;EN;<font> 0037;7;7;7;N;;;;;
+1CCF8;OUTLINED DIGIT EIGHT;Nd;0;EN;<font> 0038;8;8;8;N;;;;;
+1CCF9;OUTLINED DIGIT NINE;Nd;0;EN;<font> 0039;9;9;9;N;;;;;
+1CCFA;SNAKE SYMBOL;So;0;ON;;;;;N;;;;;
+1CCFB;FLYING SAUCER SYMBOL;So;0;ON;;;;;N;;;;;
+1CCFC;NOSE SYMBOL;So;0;ON;;;;;N;;;;;
+1CD00;BLOCK OCTANT-3;So;0;ON;;;;;N;;;;;
+1CD01;BLOCK OCTANT-23;So;0;ON;;;;;N;;;;;
+1CD02;BLOCK OCTANT-123;So;0;ON;;;;;N;;;;;
+1CD03;BLOCK OCTANT-4;So;0;ON;;;;;N;;;;;
+1CD04;BLOCK OCTANT-14;So;0;ON;;;;;N;;;;;
+1CD05;BLOCK OCTANT-124;So;0;ON;;;;;N;;;;;
+1CD06;BLOCK OCTANT-34;So;0;ON;;;;;N;;;;;
+1CD07;BLOCK OCTANT-134;So;0;ON;;;;;N;;;;;
+1CD08;BLOCK OCTANT-234;So;0;ON;;;;;N;;;;;
+1CD09;BLOCK OCTANT-5;So;0;ON;;;;;N;;;;;
+1CD0A;BLOCK OCTANT-15;So;0;ON;;;;;N;;;;;
+1CD0B;BLOCK OCTANT-25;So;0;ON;;;;;N;;;;;
+1CD0C;BLOCK OCTANT-125;So;0;ON;;;;;N;;;;;
+1CD0D;BLOCK OCTANT-135;So;0;ON;;;;;N;;;;;
+1CD0E;BLOCK OCTANT-235;So;0;ON;;;;;N;;;;;
+1CD0F;BLOCK OCTANT-1235;So;0;ON;;;;;N;;;;;
+1CD10;BLOCK OCTANT-45;So;0;ON;;;;;N;;;;;
+1CD11;BLOCK OCTANT-145;So;0;ON;;;;;N;;;;;
+1CD12;BLOCK OCTANT-245;So;0;ON;;;;;N;;;;;
+1CD13;BLOCK OCTANT-1245;So;0;ON;;;;;N;;;;;
+1CD14;BLOCK OCTANT-345;So;0;ON;;;;;N;;;;;
+1CD15;BLOCK OCTANT-1345;So;0;ON;;;;;N;;;;;
+1CD16;BLOCK OCTANT-2345;So;0;ON;;;;;N;;;;;
+1CD17;BLOCK OCTANT-12345;So;0;ON;;;;;N;;;;;
+1CD18;BLOCK OCTANT-6;So;0;ON;;;;;N;;;;;
+1CD19;BLOCK OCTANT-16;So;0;ON;;;;;N;;;;;
+1CD1A;BLOCK OCTANT-26;So;0;ON;;;;;N;;;;;
+1CD1B;BLOCK OCTANT-126;So;0;ON;;;;;N;;;;;
+1CD1C;BLOCK OCTANT-36;So;0;ON;;;;;N;;;;;
+1CD1D;BLOCK OCTANT-136;So;0;ON;;;;;N;;;;;
+1CD1E;BLOCK OCTANT-236;So;0;ON;;;;;N;;;;;
+1CD1F;BLOCK OCTANT-1236;So;0;ON;;;;;N;;;;;
+1CD20;BLOCK OCTANT-146;So;0;ON;;;;;N;;;;;
+1CD21;BLOCK OCTANT-246;So;0;ON;;;;;N;;;;;
+1CD22;BLOCK OCTANT-1246;So;0;ON;;;;;N;;;;;
+1CD23;BLOCK OCTANT-346;So;0;ON;;;;;N;;;;;
+1CD24;BLOCK OCTANT-1346;So;0;ON;;;;;N;;;;;
+1CD25;BLOCK OCTANT-2346;So;0;ON;;;;;N;;;;;
+1CD26;BLOCK OCTANT-12346;So;0;ON;;;;;N;;;;;
+1CD27;BLOCK OCTANT-56;So;0;ON;;;;;N;;;;;
+1CD28;BLOCK OCTANT-156;So;0;ON;;;;;N;;;;;
+1CD29;BLOCK OCTANT-256;So;0;ON;;;;;N;;;;;
+1CD2A;BLOCK OCTANT-1256;So;0;ON;;;;;N;;;;;
+1CD2B;BLOCK OCTANT-356;So;0;ON;;;;;N;;;;;
+1CD2C;BLOCK OCTANT-1356;So;0;ON;;;;;N;;;;;
+1CD2D;BLOCK OCTANT-2356;So;0;ON;;;;;N;;;;;
+1CD2E;BLOCK OCTANT-12356;So;0;ON;;;;;N;;;;;
+1CD2F;BLOCK OCTANT-456;So;0;ON;;;;;N;;;;;
+1CD30;BLOCK OCTANT-1456;So;0;ON;;;;;N;;;;;
+1CD31;BLOCK OCTANT-2456;So;0;ON;;;;;N;;;;;
+1CD32;BLOCK OCTANT-12456;So;0;ON;;;;;N;;;;;
+1CD33;BLOCK OCTANT-3456;So;0;ON;;;;;N;;;;;
+1CD34;BLOCK OCTANT-13456;So;0;ON;;;;;N;;;;;
+1CD35;BLOCK OCTANT-23456;So;0;ON;;;;;N;;;;;
+1CD36;BLOCK OCTANT-17;So;0;ON;;;;;N;;;;;
+1CD37;BLOCK OCTANT-27;So;0;ON;;;;;N;;;;;
+1CD38;BLOCK OCTANT-127;So;0;ON;;;;;N;;;;;
+1CD39;BLOCK OCTANT-37;So;0;ON;;;;;N;;;;;
+1CD3A;BLOCK OCTANT-137;So;0;ON;;;;;N;;;;;
+1CD3B;BLOCK OCTANT-237;So;0;ON;;;;;N;;;;;
+1CD3C;BLOCK OCTANT-1237;So;0;ON;;;;;N;;;;;
+1CD3D;BLOCK OCTANT-47;So;0;ON;;;;;N;;;;;
+1CD3E;BLOCK OCTANT-147;So;0;ON;;;;;N;;;;;
+1CD3F;BLOCK OCTANT-247;So;0;ON;;;;;N;;;;;
+1CD40;BLOCK OCTANT-1247;So;0;ON;;;;;N;;;;;
+1CD41;BLOCK OCTANT-347;So;0;ON;;;;;N;;;;;
+1CD42;BLOCK OCTANT-1347;So;0;ON;;;;;N;;;;;
+1CD43;BLOCK OCTANT-2347;So;0;ON;;;;;N;;;;;
+1CD44;BLOCK OCTANT-12347;So;0;ON;;;;;N;;;;;
+1CD45;BLOCK OCTANT-157;So;0;ON;;;;;N;;;;;
+1CD46;BLOCK OCTANT-257;So;0;ON;;;;;N;;;;;
+1CD47;BLOCK OCTANT-1257;So;0;ON;;;;;N;;;;;
+1CD48;BLOCK OCTANT-357;So;0;ON;;;;;N;;;;;
+1CD49;BLOCK OCTANT-2357;So;0;ON;;;;;N;;;;;
+1CD4A;BLOCK OCTANT-12357;So;0;ON;;;;;N;;;;;
+1CD4B;BLOCK OCTANT-457;So;0;ON;;;;;N;;;;;
+1CD4C;BLOCK OCTANT-1457;So;0;ON;;;;;N;;;;;
+1CD4D;BLOCK OCTANT-12457;So;0;ON;;;;;N;;;;;
+1CD4E;BLOCK OCTANT-3457;So;0;ON;;;;;N;;;;;
+1CD4F;BLOCK OCTANT-13457;So;0;ON;;;;;N;;;;;
+1CD50;BLOCK OCTANT-23457;So;0;ON;;;;;N;;;;;
+1CD51;BLOCK OCTANT-67;So;0;ON;;;;;N;;;;;
+1CD52;BLOCK OCTANT-167;So;0;ON;;;;;N;;;;;
+1CD53;BLOCK OCTANT-267;So;0;ON;;;;;N;;;;;
+1CD54;BLOCK OCTANT-1267;So;0;ON;;;;;N;;;;;
+1CD55;BLOCK OCTANT-367;So;0;ON;;;;;N;;;;;
+1CD56;BLOCK OCTANT-1367;So;0;ON;;;;;N;;;;;
+1CD57;BLOCK OCTANT-2367;So;0;ON;;;;;N;;;;;
+1CD58;BLOCK OCTANT-12367;So;0;ON;;;;;N;;;;;
+1CD59;BLOCK OCTANT-467;So;0;ON;;;;;N;;;;;
+1CD5A;BLOCK OCTANT-1467;So;0;ON;;;;;N;;;;;
+1CD5B;BLOCK OCTANT-2467;So;0;ON;;;;;N;;;;;
+1CD5C;BLOCK OCTANT-12467;So;0;ON;;;;;N;;;;;
+1CD5D;BLOCK OCTANT-3467;So;0;ON;;;;;N;;;;;
+1CD5E;BLOCK OCTANT-13467;So;0;ON;;;;;N;;;;;
+1CD5F;BLOCK OCTANT-23467;So;0;ON;;;;;N;;;;;
+1CD60;BLOCK OCTANT-123467;So;0;ON;;;;;N;;;;;
+1CD61;BLOCK OCTANT-567;So;0;ON;;;;;N;;;;;
+1CD62;BLOCK OCTANT-1567;So;0;ON;;;;;N;;;;;
+1CD63;BLOCK OCTANT-2567;So;0;ON;;;;;N;;;;;
+1CD64;BLOCK OCTANT-12567;So;0;ON;;;;;N;;;;;
+1CD65;BLOCK OCTANT-3567;So;0;ON;;;;;N;;;;;
+1CD66;BLOCK OCTANT-13567;So;0;ON;;;;;N;;;;;
+1CD67;BLOCK OCTANT-23567;So;0;ON;;;;;N;;;;;
+1CD68;BLOCK OCTANT-123567;So;0;ON;;;;;N;;;;;
+1CD69;BLOCK OCTANT-4567;So;0;ON;;;;;N;;;;;
+1CD6A;BLOCK OCTANT-14567;So;0;ON;;;;;N;;;;;
+1CD6B;BLOCK OCTANT-24567;So;0;ON;;;;;N;;;;;
+1CD6C;BLOCK OCTANT-124567;So;0;ON;;;;;N;;;;;
+1CD6D;BLOCK OCTANT-34567;So;0;ON;;;;;N;;;;;
+1CD6E;BLOCK OCTANT-134567;So;0;ON;;;;;N;;;;;
+1CD6F;BLOCK OCTANT-234567;So;0;ON;;;;;N;;;;;
+1CD70;BLOCK OCTANT-1234567;So;0;ON;;;;;N;;;;;
+1CD71;BLOCK OCTANT-18;So;0;ON;;;;;N;;;;;
+1CD72;BLOCK OCTANT-28;So;0;ON;;;;;N;;;;;
+1CD73;BLOCK OCTANT-128;So;0;ON;;;;;N;;;;;
+1CD74;BLOCK OCTANT-38;So;0;ON;;;;;N;;;;;
+1CD75;BLOCK OCTANT-138;So;0;ON;;;;;N;;;;;
+1CD76;BLOCK OCTANT-238;So;0;ON;;;;;N;;;;;
+1CD77;BLOCK OCTANT-1238;So;0;ON;;;;;N;;;;;
+1CD78;BLOCK OCTANT-48;So;0;ON;;;;;N;;;;;
+1CD79;BLOCK OCTANT-148;So;0;ON;;;;;N;;;;;
+1CD7A;BLOCK OCTANT-248;So;0;ON;;;;;N;;;;;
+1CD7B;BLOCK OCTANT-1248;So;0;ON;;;;;N;;;;;
+1CD7C;BLOCK OCTANT-348;So;0;ON;;;;;N;;;;;
+1CD7D;BLOCK OCTANT-1348;So;0;ON;;;;;N;;;;;
+1CD7E;BLOCK OCTANT-2348;So;0;ON;;;;;N;;;;;
+1CD7F;BLOCK OCTANT-12348;So;0;ON;;;;;N;;;;;
+1CD80;BLOCK OCTANT-58;So;0;ON;;;;;N;;;;;
+1CD81;BLOCK OCTANT-158;So;0;ON;;;;;N;;;;;
+1CD82;BLOCK OCTANT-258;So;0;ON;;;;;N;;;;;
+1CD83;BLOCK OCTANT-1258;So;0;ON;;;;;N;;;;;
+1CD84;BLOCK OCTANT-358;So;0;ON;;;;;N;;;;;
+1CD85;BLOCK OCTANT-1358;So;0;ON;;;;;N;;;;;
+1CD86;BLOCK OCTANT-2358;So;0;ON;;;;;N;;;;;
+1CD87;BLOCK OCTANT-12358;So;0;ON;;;;;N;;;;;
+1CD88;BLOCK OCTANT-458;So;0;ON;;;;;N;;;;;
+1CD89;BLOCK OCTANT-1458;So;0;ON;;;;;N;;;;;
+1CD8A;BLOCK OCTANT-2458;So;0;ON;;;;;N;;;;;
+1CD8B;BLOCK OCTANT-12458;So;0;ON;;;;;N;;;;;
+1CD8C;BLOCK OCTANT-3458;So;0;ON;;;;;N;;;;;
+1CD8D;BLOCK OCTANT-13458;So;0;ON;;;;;N;;;;;
+1CD8E;BLOCK OCTANT-23458;So;0;ON;;;;;N;;;;;
+1CD8F;BLOCK OCTANT-123458;So;0;ON;;;;;N;;;;;
+1CD90;BLOCK OCTANT-168;So;0;ON;;;;;N;;;;;
+1CD91;BLOCK OCTANT-268;So;0;ON;;;;;N;;;;;
+1CD92;BLOCK OCTANT-1268;So;0;ON;;;;;N;;;;;
+1CD93;BLOCK OCTANT-368;So;0;ON;;;;;N;;;;;
+1CD94;BLOCK OCTANT-2368;So;0;ON;;;;;N;;;;;
+1CD95;BLOCK OCTANT-12368;So;0;ON;;;;;N;;;;;
+1CD96;BLOCK OCTANT-468;So;0;ON;;;;;N;;;;;
+1CD97;BLOCK OCTANT-1468;So;0;ON;;;;;N;;;;;
+1CD98;BLOCK OCTANT-12468;So;0;ON;;;;;N;;;;;
+1CD99;BLOCK OCTANT-3468;So;0;ON;;;;;N;;;;;
+1CD9A;BLOCK OCTANT-13468;So;0;ON;;;;;N;;;;;
+1CD9B;BLOCK OCTANT-23468;So;0;ON;;;;;N;;;;;
+1CD9C;BLOCK OCTANT-568;So;0;ON;;;;;N;;;;;
+1CD9D;BLOCK OCTANT-1568;So;0;ON;;;;;N;;;;;
+1CD9E;BLOCK OCTANT-2568;So;0;ON;;;;;N;;;;;
+1CD9F;BLOCK OCTANT-12568;So;0;ON;;;;;N;;;;;
+1CDA0;BLOCK OCTANT-3568;So;0;ON;;;;;N;;;;;
+1CDA1;BLOCK OCTANT-13568;So;0;ON;;;;;N;;;;;
+1CDA2;BLOCK OCTANT-23568;So;0;ON;;;;;N;;;;;
+1CDA3;BLOCK OCTANT-123568;So;0;ON;;;;;N;;;;;
+1CDA4;BLOCK OCTANT-4568;So;0;ON;;;;;N;;;;;
+1CDA5;BLOCK OCTANT-14568;So;0;ON;;;;;N;;;;;
+1CDA6;BLOCK OCTANT-24568;So;0;ON;;;;;N;;;;;
+1CDA7;BLOCK OCTANT-124568;So;0;ON;;;;;N;;;;;
+1CDA8;BLOCK OCTANT-34568;So;0;ON;;;;;N;;;;;
+1CDA9;BLOCK OCTANT-134568;So;0;ON;;;;;N;;;;;
+1CDAA;BLOCK OCTANT-234568;So;0;ON;;;;;N;;;;;
+1CDAB;BLOCK OCTANT-1234568;So;0;ON;;;;;N;;;;;
+1CDAC;BLOCK OCTANT-178;So;0;ON;;;;;N;;;;;
+1CDAD;BLOCK OCTANT-278;So;0;ON;;;;;N;;;;;
+1CDAE;BLOCK OCTANT-1278;So;0;ON;;;;;N;;;;;
+1CDAF;BLOCK OCTANT-378;So;0;ON;;;;;N;;;;;
+1CDB0;BLOCK OCTANT-1378;So;0;ON;;;;;N;;;;;
+1CDB1;BLOCK OCTANT-2378;So;0;ON;;;;;N;;;;;
+1CDB2;BLOCK OCTANT-12378;So;0;ON;;;;;N;;;;;
+1CDB3;BLOCK OCTANT-478;So;0;ON;;;;;N;;;;;
+1CDB4;BLOCK OCTANT-1478;So;0;ON;;;;;N;;;;;
+1CDB5;BLOCK OCTANT-2478;So;0;ON;;;;;N;;;;;
+1CDB6;BLOCK OCTANT-12478;So;0;ON;;;;;N;;;;;
+1CDB7;BLOCK OCTANT-3478;So;0;ON;;;;;N;;;;;
+1CDB8;BLOCK OCTANT-13478;So;0;ON;;;;;N;;;;;
+1CDB9;BLOCK OCTANT-23478;So;0;ON;;;;;N;;;;;
+1CDBA;BLOCK OCTANT-123478;So;0;ON;;;;;N;;;;;
+1CDBB;BLOCK OCTANT-578;So;0;ON;;;;;N;;;;;
+1CDBC;BLOCK OCTANT-1578;So;0;ON;;;;;N;;;;;
+1CDBD;BLOCK OCTANT-2578;So;0;ON;;;;;N;;;;;
+1CDBE;BLOCK OCTANT-12578;So;0;ON;;;;;N;;;;;
+1CDBF;BLOCK OCTANT-3578;So;0;ON;;;;;N;;;;;
+1CDC0;BLOCK OCTANT-13578;So;0;ON;;;;;N;;;;;
+1CDC1;BLOCK OCTANT-23578;So;0;ON;;;;;N;;;;;
+1CDC2;BLOCK OCTANT-123578;So;0;ON;;;;;N;;;;;
+1CDC3;BLOCK OCTANT-4578;So;0;ON;;;;;N;;;;;
+1CDC4;BLOCK OCTANT-14578;So;0;ON;;;;;N;;;;;
+1CDC5;BLOCK OCTANT-24578;So;0;ON;;;;;N;;;;;
+1CDC6;BLOCK OCTANT-124578;So;0;ON;;;;;N;;;;;
+1CDC7;BLOCK OCTANT-34578;So;0;ON;;;;;N;;;;;
+1CDC8;BLOCK OCTANT-134578;So;0;ON;;;;;N;;;;;
+1CDC9;BLOCK OCTANT-234578;So;0;ON;;;;;N;;;;;
+1CDCA;BLOCK OCTANT-1234578;So;0;ON;;;;;N;;;;;
+1CDCB;BLOCK OCTANT-678;So;0;ON;;;;;N;;;;;
+1CDCC;BLOCK OCTANT-1678;So;0;ON;;;;;N;;;;;
+1CDCD;BLOCK OCTANT-2678;So;0;ON;;;;;N;;;;;
+1CDCE;BLOCK OCTANT-12678;So;0;ON;;;;;N;;;;;
+1CDCF;BLOCK OCTANT-3678;So;0;ON;;;;;N;;;;;
+1CDD0;BLOCK OCTANT-13678;So;0;ON;;;;;N;;;;;
+1CDD1;BLOCK OCTANT-23678;So;0;ON;;;;;N;;;;;
+1CDD2;BLOCK OCTANT-123678;So;0;ON;;;;;N;;;;;
+1CDD3;BLOCK OCTANT-4678;So;0;ON;;;;;N;;;;;
+1CDD4;BLOCK OCTANT-14678;So;0;ON;;;;;N;;;;;
+1CDD5;BLOCK OCTANT-24678;So;0;ON;;;;;N;;;;;
+1CDD6;BLOCK OCTANT-124678;So;0;ON;;;;;N;;;;;
+1CDD7;BLOCK OCTANT-34678;So;0;ON;;;;;N;;;;;
+1CDD8;BLOCK OCTANT-134678;So;0;ON;;;;;N;;;;;
+1CDD9;BLOCK OCTANT-234678;So;0;ON;;;;;N;;;;;
+1CDDA;BLOCK OCTANT-1234678;So;0;ON;;;;;N;;;;;
+1CDDB;BLOCK OCTANT-15678;So;0;ON;;;;;N;;;;;
+1CDDC;BLOCK OCTANT-25678;So;0;ON;;;;;N;;;;;
+1CDDD;BLOCK OCTANT-125678;So;0;ON;;;;;N;;;;;
+1CDDE;BLOCK OCTANT-35678;So;0;ON;;;;;N;;;;;
+1CDDF;BLOCK OCTANT-235678;So;0;ON;;;;;N;;;;;
+1CDE0;BLOCK OCTANT-1235678;So;0;ON;;;;;N;;;;;
+1CDE1;BLOCK OCTANT-45678;So;0;ON;;;;;N;;;;;
+1CDE2;BLOCK OCTANT-145678;So;0;ON;;;;;N;;;;;
+1CDE3;BLOCK OCTANT-1245678;So;0;ON;;;;;N;;;;;
+1CDE4;BLOCK OCTANT-1345678;So;0;ON;;;;;N;;;;;
+1CDE5;BLOCK OCTANT-2345678;So;0;ON;;;;;N;;;;;
+1CDE6;TOP HALF STANDING PERSON;So;0;ON;;;;;N;;;;;
+1CDE7;BOTTOM HALF STANDING PERSON;So;0;ON;;;;;N;;;;;
+1CDE8;TOP HALF RIGHT-FACING RUNNER FRAME-1;So;0;ON;;;;;N;;;;;
+1CDE9;BOTTOM HALF RIGHT-FACING RUNNER FRAME-1;So;0;ON;;;;;N;;;;;
+1CDEA;TOP HALF RIGHT-FACING RUNNER FRAME-2;So;0;ON;;;;;N;;;;;
+1CDEB;BOTTOM HALF RIGHT-FACING RUNNER FRAME-2;So;0;ON;;;;;N;;;;;
+1CDEC;TOP HALF LEFT-FACING RUNNER FRAME-1;So;0;ON;;;;;N;;;;;
+1CDED;BOTTOM HALF LEFT-FACING RUNNER FRAME-1;So;0;ON;;;;;N;;;;;
+1CDEE;TOP HALF LEFT-FACING RUNNER FRAME-2;So;0;ON;;;;;N;;;;;
+1CDEF;BOTTOM HALF LEFT-FACING RUNNER FRAME-2;So;0;ON;;;;;N;;;;;
+1CDF0;TOP HALF FORWARD-FACING RUNNER;So;0;ON;;;;;N;;;;;
+1CDF1;BOTTOM HALF FORWARD-FACING RUNNER FRAME-1;So;0;ON;;;;;N;;;;;
+1CDF2;BOTTOM HALF FORWARD-FACING RUNNER FRAME-2;So;0;ON;;;;;N;;;;;
+1CDF3;BOTTOM HALF FORWARD-FACING RUNNER FRAME-3;So;0;ON;;;;;N;;;;;
+1CDF4;BOTTOM HALF FORWARD-FACING RUNNER FRAME-4;So;0;ON;;;;;N;;;;;
+1CDF5;MOON LANDER;So;0;ON;;;;;N;;;;;
+1CDF6;TOP HALF FLAILING ROBOT FRAME-1;So;0;ON;;;;;N;;;;;
+1CDF7;TOP HALF FLAILING ROBOT FRAME-2;So;0;ON;;;;;N;;;;;
+1CDF8;DOWN-POINTING AIRPLANE;So;0;ON;;;;;N;;;;;
+1CDF9;LEFT-POINTING AIRPLANE;So;0;ON;;;;;N;;;;;
+1CDFA;SMALL UP-POINTING AIRPLANE;So;0;ON;;;;;N;;;;;
+1CDFB;UP-POINTING FROG;So;0;ON;;;;;N;;;;;
+1CDFC;DOWN-POINTING FROG;So;0;ON;;;;;N;;;;;
+1CDFD;EXPLOSION FRAME-1;So;0;ON;;;;;N;;;;;
+1CDFE;EXPLOSION FRAME-2;So;0;ON;;;;;N;;;;;
+1CDFF;EXPLOSION FRAME-3;So;0;ON;;;;;N;;;;;
+1CE00;RIGHT HALF AND LEFT HALF WHITE CIRCLE;So;0;ON;;;;;N;;;;;
+1CE01;LOWER HALF AND UPPER HALF WHITE CIRCLE;So;0;ON;;;;;N;;;;;
+1CE02;EXPLOSION AT HORIZON;So;0;ON;;;;;N;;;;;
+1CE03;UPPER HALF HEAVY WHITE SQUARE;So;0;ON;;;;;N;;;;;
+1CE04;LOWER HALF HEAVY WHITE SQUARE;So;0;ON;;;;;N;;;;;
+1CE05;HEAVY WHITE SQUARE CONTAINING BLACK VERY SMALL SQUARE;So;0;ON;;;;;N;;;;;
+1CE06;WHITE VERTICAL RECTANGLE WITH HORIZONTAL BAR;So;0;ON;;;;;N;;;;;
+1CE07;TOP LEFT BLACK LEFT-POINTING SMALL TRIANGLE;So;0;ON;;;;;N;;;;;
+1CE08;FUNNEL;So;0;ON;;;;;N;;;;;
+1CE09;BOX DRAWINGS DOUBLE DIAGONAL LOWER LEFT TO MIDDLE CENTRE TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1CE0A;BOX DRAWINGS DOUBLE DIAGONAL UPPER LEFT TO MIDDLE CENTRE TO UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1CE0B;LEFT HALF WHITE ELLIPSE;So;0;ON;;;;;N;;;;;
+1CE0C;RIGHT HALF WHITE ELLIPSE;So;0;ON;;;;;N;;;;;
+1CE0D;LEFT HALF TRIPLE DASH HORIZONTAL;So;0;ON;;;;;N;;;;;
+1CE0E;RIGHT HALF TRIPLE DASH HORIZONTAL;So;0;ON;;;;;N;;;;;
+1CE0F;HORIZONTAL LINE WITH TICK MARK;So;0;ON;;;;;N;;;;;
+1CE10;LEFT HALF HORIZONTAL LINE WITH THREE TICK MARKS;So;0;ON;;;;;N;;;;;
+1CE11;RIGHT HALF HORIZONTAL LINE WITH THREE TICK MARKS;So;0;ON;;;;;N;;;;;
+1CE12;HORIZONTAL LINE WITH THREE TICK MARKS;So;0;ON;;;;;N;;;;;
+1CE13;LOWER HALF VERTICAL LINE WITH THREE TICK MARKS;So;0;ON;;;;;N;;;;;
+1CE14;UPPER HALF VERTICAL LINE WITH THREE TICK MARKS;So;0;ON;;;;;N;;;;;
+1CE15;VERTICAL LINE WITH THREE TICK MARKS;So;0;ON;;;;;N;;;;;
+1CE16;BOX DRAWINGS LIGHT VERTICAL AND TOP RIGHT;So;0;ON;;;;;N;;;;;
+1CE17;BOX DRAWINGS LIGHT VERTICAL AND BOTTOM RIGHT;So;0;ON;;;;;N;;;;;
+1CE18;BOX DRAWINGS LIGHT VERTICAL AND TOP LEFT;So;0;ON;;;;;N;;;;;
+1CE19;BOX DRAWINGS LIGHT VERTICAL AND BOTTOM LEFT;So;0;ON;;;;;N;;;;;
+1CE1A;LARGE TYPE PIECE UPPER LEFT ARC;So;0;ON;;;;;N;;;;;
+1CE1B;LARGE TYPE PIECE UPPER LEFT CORNER;So;0;ON;;;;;N;;;;;
+1CE1C;LARGE TYPE PIECE UPPER TERMINAL;So;0;ON;;;;;N;;;;;
+1CE1D;LARGE TYPE PIECE UPPER LEFT CROTCH;So;0;ON;;;;;N;;;;;
+1CE1E;LARGE TYPE PIECE LEFT ARM;So;0;ON;;;;;N;;;;;
+1CE1F;LARGE TYPE PIECE CROSSBAR;So;0;ON;;;;;N;;;;;
+1CE20;LARGE TYPE PIECE CROSSBAR WITH LOWER STEM;So;0;ON;;;;;N;;;;;
+1CE21;LARGE TYPE PIECE UPPER HALF VERTEX OF M;So;0;ON;;;;;N;;;;;
+1CE22;LARGE TYPE PIECE DIAGONAL LOWER LEFT;So;0;ON;;;;;N;;;;;
+1CE23;LARGE TYPE PIECE SHORT UPPER TERMINAL;So;0;ON;;;;;N;;;;;
+1CE24;LARGE TYPE PIECE UPPER RIGHT ARC;So;0;ON;;;;;N;;;;;
+1CE25;LARGE TYPE PIECE RIGHT ARM;So;0;ON;;;;;N;;;;;
+1CE26;LARGE TYPE PIECE UPPER RIGHT CROTCH;So;0;ON;;;;;N;;;;;
+1CE27;LARGE TYPE PIECE UPPER RIGHT CORNER;So;0;ON;;;;;N;;;;;
+1CE28;LARGE TYPE PIECE STEM WITH RIGHT CROSSBAR;So;0;ON;;;;;N;;;;;
+1CE29;LARGE TYPE PIECE STEM;So;0;ON;;;;;N;;;;;
+1CE2A;LARGE TYPE PIECE DIAGONAL UPPER RIGHT AND LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1CE2B;LARGE TYPE PIECE DIAGONAL UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1CE2C;LARGE TYPE PIECE DIAGONAL LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1CE2D;LARGE TYPE PIECE SHORT LOWER TERMINAL;So;0;ON;;;;;N;;;;;
+1CE2E;LARGE TYPE PIECE LOWER LEFT AND UPPER LEFT ARC;So;0;ON;;;;;N;;;;;
+1CE2F;LARGE TYPE PIECE CENTRE OF K;So;0;ON;;;;;N;;;;;
+1CE30;LARGE TYPE PIECE LOWER HALF VERTEX OF M;So;0;ON;;;;;N;;;;;
+1CE31;LARGE TYPE PIECE UPPER HALF VERTEX OF W;So;0;ON;;;;;N;;;;;
+1CE32;LARGE TYPE PIECE CENTRE OF X;So;0;ON;;;;;N;;;;;
+1CE33;LARGE TYPE PIECE CENTRE OF Y;So;0;ON;;;;;N;;;;;
+1CE34;LARGE TYPE PIECE CENTRE OF Z WITH CROSSBAR;So;0;ON;;;;;N;;;;;
+1CE35;LARGE TYPE PIECE RAISED UPPER LEFT ARC;So;0;ON;;;;;N;;;;;
+1CE36;LARGE TYPE PIECE STEM WITH LEFT CROSSBAR;So;0;ON;;;;;N;;;;;
+1CE37;LARGE TYPE PIECE LOWER RIGHT AND UPPER RIGHT ARC;So;0;ON;;;;;N;;;;;
+1CE38;LARGE TYPE PIECE DIAGONAL UPPER LEFT AND LOWER LEFT;So;0;ON;;;;;N;;;;;
+1CE39;LARGE TYPE PIECE STEM WITH LEFT JOINT;So;0;ON;;;;;N;;;;;
+1CE3A;LARGE TYPE PIECE STEM WITH CROSSBAR;So;0;ON;;;;;N;;;;;
+1CE3B;LARGE TYPE PIECE DIAGONAL UPPER LEFT;So;0;ON;;;;;N;;;;;
+1CE3C;LARGE TYPE PIECE LOWER TERMINAL;So;0;ON;;;;;N;;;;;
+1CE3D;LARGE TYPE PIECE LOWER LEFT CORNER;So;0;ON;;;;;N;;;;;
+1CE3E;LARGE TYPE PIECE LOWER LEFT ARC;So;0;ON;;;;;N;;;;;
+1CE3F;LARGE TYPE PIECE LOWER LEFT CROTCH;So;0;ON;;;;;N;;;;;
+1CE40;LARGE TYPE PIECE CROSSBAR WITH UPPER STEM;So;0;ON;;;;;N;;;;;
+1CE41;LARGE TYPE PIECE VERTEX OF V;So;0;ON;;;;;N;;;;;
+1CE42;LARGE TYPE PIECE LOWER HALF VERTEX OF W;So;0;ON;;;;;N;;;;;
+1CE43;LARGE TYPE PIECE LOWER RIGHT ARC;So;0;ON;;;;;N;;;;;
+1CE44;LARGE TYPE PIECE LOWER RIGHT CORNER;So;0;ON;;;;;N;;;;;
+1CE45;LARGE TYPE PIECE LOWER RIGHT ARC WITH TAIL;So;0;ON;;;;;N;;;;;
+1CE46;LARGE TYPE PIECE LOWER RIGHT CROTCH;So;0;ON;;;;;N;;;;;
+1CE47;LARGE TYPE PIECE STEM-45;So;0;ON;;;;;N;;;;;
+1CE48;LARGE TYPE PIECE STEM-2345;So;0;ON;;;;;N;;;;;
+1CE49;LARGE TYPE PIECE STEM-4;So;0;ON;;;;;N;;;;;
+1CE4A;LARGE TYPE PIECE STEM-34;So;0;ON;;;;;N;;;;;
+1CE4B;LARGE TYPE PIECE STEM-234;So;0;ON;;;;;N;;;;;
+1CE4C;LARGE TYPE PIECE STEM-1234;So;0;ON;;;;;N;;;;;
+1CE4D;LARGE TYPE PIECE STEM-3;So;0;ON;;;;;N;;;;;
+1CE4E;LARGE TYPE PIECE STEM-23;So;0;ON;;;;;N;;;;;
+1CE4F;LARGE TYPE PIECE STEM-2;So;0;ON;;;;;N;;;;;
+1CE50;LARGE TYPE PIECE STEM-12;So;0;ON;;;;;N;;;;;
+1CE51;SEPARATED BLOCK SEXTANT-1;So;0;ON;;;;;N;;;;;
+1CE52;SEPARATED BLOCK SEXTANT-2;So;0;ON;;;;;N;;;;;
+1CE53;SEPARATED BLOCK SEXTANT-12;So;0;ON;;;;;N;;;;;
+1CE54;SEPARATED BLOCK SEXTANT-3;So;0;ON;;;;;N;;;;;
+1CE55;SEPARATED BLOCK SEXTANT-13;So;0;ON;;;;;N;;;;;
+1CE56;SEPARATED BLOCK SEXTANT-23;So;0;ON;;;;;N;;;;;
+1CE57;SEPARATED BLOCK SEXTANT-123;So;0;ON;;;;;N;;;;;
+1CE58;SEPARATED BLOCK SEXTANT-4;So;0;ON;;;;;N;;;;;
+1CE59;SEPARATED BLOCK SEXTANT-14;So;0;ON;;;;;N;;;;;
+1CE5A;SEPARATED BLOCK SEXTANT-24;So;0;ON;;;;;N;;;;;
+1CE5B;SEPARATED BLOCK SEXTANT-124;So;0;ON;;;;;N;;;;;
+1CE5C;SEPARATED BLOCK SEXTANT-34;So;0;ON;;;;;N;;;;;
+1CE5D;SEPARATED BLOCK SEXTANT-134;So;0;ON;;;;;N;;;;;
+1CE5E;SEPARATED BLOCK SEXTANT-234;So;0;ON;;;;;N;;;;;
+1CE5F;SEPARATED BLOCK SEXTANT-1234;So;0;ON;;;;;N;;;;;
+1CE60;SEPARATED BLOCK SEXTANT-5;So;0;ON;;;;;N;;;;;
+1CE61;SEPARATED BLOCK SEXTANT-15;So;0;ON;;;;;N;;;;;
+1CE62;SEPARATED BLOCK SEXTANT-25;So;0;ON;;;;;N;;;;;
+1CE63;SEPARATED BLOCK SEXTANT-125;So;0;ON;;;;;N;;;;;
+1CE64;SEPARATED BLOCK SEXTANT-35;So;0;ON;;;;;N;;;;;
+1CE65;SEPARATED BLOCK SEXTANT-135;So;0;ON;;;;;N;;;;;
+1CE66;SEPARATED BLOCK SEXTANT-235;So;0;ON;;;;;N;;;;;
+1CE67;SEPARATED BLOCK SEXTANT-1235;So;0;ON;;;;;N;;;;;
+1CE68;SEPARATED BLOCK SEXTANT-45;So;0;ON;;;;;N;;;;;
+1CE69;SEPARATED BLOCK SEXTANT-145;So;0;ON;;;;;N;;;;;
+1CE6A;SEPARATED BLOCK SEXTANT-245;So;0;ON;;;;;N;;;;;
+1CE6B;SEPARATED BLOCK SEXTANT-1245;So;0;ON;;;;;N;;;;;
+1CE6C;SEPARATED BLOCK SEXTANT-345;So;0;ON;;;;;N;;;;;
+1CE6D;SEPARATED BLOCK SEXTANT-1345;So;0;ON;;;;;N;;;;;
+1CE6E;SEPARATED BLOCK SEXTANT-2345;So;0;ON;;;;;N;;;;;
+1CE6F;SEPARATED BLOCK SEXTANT-12345;So;0;ON;;;;;N;;;;;
+1CE70;SEPARATED BLOCK SEXTANT-6;So;0;ON;;;;;N;;;;;
+1CE71;SEPARATED BLOCK SEXTANT-16;So;0;ON;;;;;N;;;;;
+1CE72;SEPARATED BLOCK SEXTANT-26;So;0;ON;;;;;N;;;;;
+1CE73;SEPARATED BLOCK SEXTANT-126;So;0;ON;;;;;N;;;;;
+1CE74;SEPARATED BLOCK SEXTANT-36;So;0;ON;;;;;N;;;;;
+1CE75;SEPARATED BLOCK SEXTANT-136;So;0;ON;;;;;N;;;;;
+1CE76;SEPARATED BLOCK SEXTANT-236;So;0;ON;;;;;N;;;;;
+1CE77;SEPARATED BLOCK SEXTANT-1236;So;0;ON;;;;;N;;;;;
+1CE78;SEPARATED BLOCK SEXTANT-46;So;0;ON;;;;;N;;;;;
+1CE79;SEPARATED BLOCK SEXTANT-146;So;0;ON;;;;;N;;;;;
+1CE7A;SEPARATED BLOCK SEXTANT-246;So;0;ON;;;;;N;;;;;
+1CE7B;SEPARATED BLOCK SEXTANT-1246;So;0;ON;;;;;N;;;;;
+1CE7C;SEPARATED BLOCK SEXTANT-346;So;0;ON;;;;;N;;;;;
+1CE7D;SEPARATED BLOCK SEXTANT-1346;So;0;ON;;;;;N;;;;;
+1CE7E;SEPARATED BLOCK SEXTANT-2346;So;0;ON;;;;;N;;;;;
+1CE7F;SEPARATED BLOCK SEXTANT-12346;So;0;ON;;;;;N;;;;;
+1CE80;SEPARATED BLOCK SEXTANT-56;So;0;ON;;;;;N;;;;;
+1CE81;SEPARATED BLOCK SEXTANT-156;So;0;ON;;;;;N;;;;;
+1CE82;SEPARATED BLOCK SEXTANT-256;So;0;ON;;;;;N;;;;;
+1CE83;SEPARATED BLOCK SEXTANT-1256;So;0;ON;;;;;N;;;;;
+1CE84;SEPARATED BLOCK SEXTANT-356;So;0;ON;;;;;N;;;;;
+1CE85;SEPARATED BLOCK SEXTANT-1356;So;0;ON;;;;;N;;;;;
+1CE86;SEPARATED BLOCK SEXTANT-2356;So;0;ON;;;;;N;;;;;
+1CE87;SEPARATED BLOCK SEXTANT-12356;So;0;ON;;;;;N;;;;;
+1CE88;SEPARATED BLOCK SEXTANT-456;So;0;ON;;;;;N;;;;;
+1CE89;SEPARATED BLOCK SEXTANT-1456;So;0;ON;;;;;N;;;;;
+1CE8A;SEPARATED BLOCK SEXTANT-2456;So;0;ON;;;;;N;;;;;
+1CE8B;SEPARATED BLOCK SEXTANT-12456;So;0;ON;;;;;N;;;;;
+1CE8C;SEPARATED BLOCK SEXTANT-3456;So;0;ON;;;;;N;;;;;
+1CE8D;SEPARATED BLOCK SEXTANT-13456;So;0;ON;;;;;N;;;;;
+1CE8E;SEPARATED BLOCK SEXTANT-23456;So;0;ON;;;;;N;;;;;
+1CE8F;SEPARATED BLOCK SEXTANT-123456;So;0;ON;;;;;N;;;;;
+1CE90;UPPER LEFT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE91;UPPER CENTRE LEFT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE92;UPPER CENTRE RIGHT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE93;UPPER RIGHT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE94;UPPER MIDDLE LEFT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE95;UPPER MIDDLE CENTRE LEFT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE96;UPPER MIDDLE CENTRE RIGHT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE97;UPPER MIDDLE RIGHT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE98;LOWER MIDDLE LEFT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE99;LOWER MIDDLE CENTRE LEFT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE9A;LOWER MIDDLE CENTRE RIGHT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE9B;LOWER MIDDLE RIGHT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE9C;LOWER LEFT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE9D;LOWER CENTRE LEFT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE9E;LOWER CENTRE RIGHT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CE9F;LOWER RIGHT ONE SIXTEENTH BLOCK;So;0;ON;;;;;N;;;;;
+1CEA0;RIGHT HALF LOWER ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEA1;RIGHT THREE QUARTERS LOWER ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEA2;LEFT THREE QUARTERS LOWER ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEA3;LEFT HALF LOWER ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEA4;LOWER HALF LEFT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEA5;LOWER THREE QUARTERS LEFT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEA6;UPPER THREE QUARTERS LEFT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEA7;UPPER HALF LEFT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEA8;LEFT HALF UPPER ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEA9;LEFT THREE QUARTERS UPPER ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEAA;RIGHT THREE QUARTERS UPPER ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEAB;RIGHT HALF UPPER ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEAC;UPPER HALF RIGHT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEAD;UPPER THREE QUARTERS RIGHT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEAE;LOWER THREE QUARTERS RIGHT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEAF;LOWER HALF RIGHT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1CEB0;HORIZONTAL ZIGZAG LINE;So;0;ON;;;;;N;;;;;
+1CEB1;KEYHOLE;So;0;ON;;;;;N;;;;;
+1CEB2;OLD PERSONAL COMPUTER WITH MONITOR IN PORTRAIT ORIENTATION;So;0;ON;;;;;N;;;;;
+1CEB3;BLACK RIGHT TRIANGLE CARET;So;0;ON;;;;;N;;;;;
+1CEBA;FRAGILE SYMBOL;So;0;ON;;;;;N;;;;;
+1CEBB;OFFICE BUILDING SYMBOL;So;0;ON;;;;;N;;;;;
+1CEBC;TREE SYMBOL;So;0;ON;;;;;N;;;;;
+1CEBD;APPLE SYMBOL;So;0;ON;;;;;N;;;;;
+1CEBE;CHERRY SYMBOL;So;0;ON;;;;;N;;;;;
+1CEBF;STRAWBERRY SYMBOL;So;0;ON;;;;;N;;;;;
+1CEC0;HEBE;So;0;ON;;;;;N;;;;;
+1CEC1;IRIS;So;0;ON;;;;;N;;;;;
+1CEC2;FLORA;So;0;ON;;;;;N;;;;;
+1CEC3;METIS;So;0;ON;;;;;N;;;;;
+1CEC4;PARTHENOPE;So;0;ON;;;;;N;;;;;
+1CEC5;VICTORIA;So;0;ON;;;;;N;;;;;
+1CEC6;EGERIA;So;0;ON;;;;;N;;;;;
+1CEC7;IRENE;So;0;ON;;;;;N;;;;;
+1CEC8;EUNOMIA;So;0;ON;;;;;N;;;;;
+1CEC9;PSYCHE;So;0;ON;;;;;N;;;;;
+1CECA;THETIS;So;0;ON;;;;;N;;;;;
+1CECB;MELPOMENE;So;0;ON;;;;;N;;;;;
+1CECC;FORTUNA;So;0;ON;;;;;N;;;;;
+1CECD;ASTRONOMICAL SYMBOL FOR ASTEROID PROSERPINA;So;0;ON;;;;;N;;;;;
+1CECE;BELLONA;So;0;ON;;;;;N;;;;;
+1CECF;AMPHITRITE;So;0;ON;;;;;N;;;;;
+1CED0;LEUKOTHEA;So;0;ON;;;;;N;;;;;
+1CEE0;GEOMANTIC FIGURE POPULUS;So;0;ON;;;;;N;;;;;
+1CEE1;GEOMANTIC FIGURE TRISTITIA;So;0;ON;;;;;N;;;;;
+1CEE2;GEOMANTIC FIGURE ALBUS;So;0;ON;;;;;N;;;;;
+1CEE3;GEOMANTIC FIGURE FORTUNA MAJOR;So;0;ON;;;;;N;;;;;
+1CEE4;GEOMANTIC FIGURE RUBEUS;So;0;ON;;;;;N;;;;;
+1CEE5;GEOMANTIC FIGURE ACQUISITIO;So;0;ON;;;;;N;;;;;
+1CEE6;GEOMANTIC FIGURE CONJUNCTIO;So;0;ON;;;;;N;;;;;
+1CEE7;GEOMANTIC FIGURE CAPUT DRACONIS;So;0;ON;;;;;N;;;;;
+1CEE8;GEOMANTIC FIGURE LAETITIA;So;0;ON;;;;;N;;;;;
+1CEE9;GEOMANTIC FIGURE CARCER;So;0;ON;;;;;N;;;;;
+1CEEA;GEOMANTIC FIGURE AMISSIO;So;0;ON;;;;;N;;;;;
+1CEEB;GEOMANTIC FIGURE PUELLA;So;0;ON;;;;;N;;;;;
+1CEEC;GEOMANTIC FIGURE FORTUNA MINOR;So;0;ON;;;;;N;;;;;
+1CEED;GEOMANTIC FIGURE PUER;So;0;ON;;;;;N;;;;;
+1CEEE;GEOMANTIC FIGURE CAUDA DRACONIS;So;0;ON;;;;;N;;;;;
+1CEEF;GEOMANTIC FIGURE VIA;So;0;ON;;;;;N;;;;;
+1CEF0;MEDIUM SMALL WHITE CIRCLE WITH HORIZONTAL BAR;Sm;0;ON;;;;;N;;;;;
+1CF00;ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF01;ZNAMENNY COMBINING MARK NIZKO S KRYZHEM ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF02;ZNAMENNY COMBINING MARK TSATA ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF03;ZNAMENNY COMBINING MARK GORAZDO NIZKO ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF04;ZNAMENNY COMBINING MARK NIZKO ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF05;ZNAMENNY COMBINING MARK SREDNE ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF06;ZNAMENNY COMBINING MARK MALO POVYSHE ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF07;ZNAMENNY COMBINING MARK POVYSHE ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF08;ZNAMENNY COMBINING MARK VYSOKO ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF09;ZNAMENNY COMBINING MARK MALO POVYSHE S KHOKHLOM ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF0A;ZNAMENNY COMBINING MARK POVYSHE S KHOKHLOM ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF0B;ZNAMENNY COMBINING MARK VYSOKO S KHOKHLOM ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF0C;ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF0D;ZNAMENNY COMBINING MARK NIZKO S KRYZHEM ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF0E;ZNAMENNY COMBINING MARK TSATA ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF0F;ZNAMENNY COMBINING MARK GORAZDO NIZKO ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF10;ZNAMENNY COMBINING MARK NIZKO ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF11;ZNAMENNY COMBINING MARK SREDNE ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF12;ZNAMENNY COMBINING MARK MALO POVYSHE ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF13;ZNAMENNY COMBINING MARK POVYSHE ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF14;ZNAMENNY COMBINING MARK VYSOKO ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF15;ZNAMENNY COMBINING MARK MALO POVYSHE S KHOKHLOM ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF16;ZNAMENNY COMBINING MARK POVYSHE S KHOKHLOM ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF17;ZNAMENNY COMBINING MARK VYSOKO S KHOKHLOM ON RIGHT;Mn;0;NSM;;;;;N;;;;;
+1CF18;ZNAMENNY COMBINING MARK TSATA S KRYZHEM;Mn;0;NSM;;;;;N;;;;;
+1CF19;ZNAMENNY COMBINING MARK MALO POVYSHE S KRYZHEM;Mn;0;NSM;;;;;N;;;;;
+1CF1A;ZNAMENNY COMBINING MARK STRANNO MALO POVYSHE;Mn;0;NSM;;;;;N;;;;;
+1CF1B;ZNAMENNY COMBINING MARK POVYSHE S KRYZHEM;Mn;0;NSM;;;;;N;;;;;
+1CF1C;ZNAMENNY COMBINING MARK POVYSHE STRANNO;Mn;0;NSM;;;;;N;;;;;
+1CF1D;ZNAMENNY COMBINING MARK VYSOKO S KRYZHEM;Mn;0;NSM;;;;;N;;;;;
+1CF1E;ZNAMENNY COMBINING MARK MALO POVYSHE STRANNO;Mn;0;NSM;;;;;N;;;;;
+1CF1F;ZNAMENNY COMBINING MARK GORAZDO VYSOKO;Mn;0;NSM;;;;;N;;;;;
+1CF20;ZNAMENNY COMBINING MARK ZELO;Mn;0;NSM;;;;;N;;;;;
+1CF21;ZNAMENNY COMBINING MARK ON;Mn;0;NSM;;;;;N;;;;;
+1CF22;ZNAMENNY COMBINING MARK RAVNO;Mn;0;NSM;;;;;N;;;;;
+1CF23;ZNAMENNY COMBINING MARK TIKHAYA;Mn;0;NSM;;;;;N;;;;;
+1CF24;ZNAMENNY COMBINING MARK BORZAYA;Mn;0;NSM;;;;;N;;;;;
+1CF25;ZNAMENNY COMBINING MARK UDARKA;Mn;0;NSM;;;;;N;;;;;
+1CF26;ZNAMENNY COMBINING MARK PODVERTKA;Mn;0;NSM;;;;;N;;;;;
+1CF27;ZNAMENNY COMBINING MARK LOMKA;Mn;0;NSM;;;;;N;;;;;
+1CF28;ZNAMENNY COMBINING MARK KUPNAYA;Mn;0;NSM;;;;;N;;;;;
+1CF29;ZNAMENNY COMBINING MARK KACHKA;Mn;0;NSM;;;;;N;;;;;
+1CF2A;ZNAMENNY COMBINING MARK ZEVOK;Mn;0;NSM;;;;;N;;;;;
+1CF2B;ZNAMENNY COMBINING MARK SKOBA;Mn;0;NSM;;;;;N;;;;;
+1CF2C;ZNAMENNY COMBINING MARK RAZSEKA;Mn;0;NSM;;;;;N;;;;;
+1CF2D;ZNAMENNY COMBINING MARK KRYZH ON LEFT;Mn;0;NSM;;;;;N;;;;;
+1CF30;ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO;Mn;0;NSM;;;;;N;;;;;
+1CF31;ZNAMENNY COMBINING TONAL RANGE MARK SVETLO;Mn;0;NSM;;;;;N;;;;;
+1CF32;ZNAMENNY COMBINING TONAL RANGE MARK TRESVETLO;Mn;0;NSM;;;;;N;;;;;
+1CF33;ZNAMENNY COMBINING MARK ZADERZHKA;Mn;0;NSM;;;;;N;;;;;
+1CF34;ZNAMENNY COMBINING MARK DEMESTVENNY ZADERZHKA;Mn;0;NSM;;;;;N;;;;;
+1CF35;ZNAMENNY COMBINING MARK OTSECHKA;Mn;0;NSM;;;;;N;;;;;
+1CF36;ZNAMENNY COMBINING MARK PODCHASHIE;Mn;0;NSM;;;;;N;;;;;
+1CF37;ZNAMENNY COMBINING MARK PODCHASHIE WITH VERTICAL STROKE;Mn;0;NSM;;;;;N;;;;;
+1CF38;ZNAMENNY COMBINING MARK CHASHKA;Mn;0;NSM;;;;;N;;;;;
+1CF39;ZNAMENNY COMBINING MARK CHASHKA POLNAYA;Mn;0;NSM;;;;;N;;;;;
+1CF3A;ZNAMENNY COMBINING MARK OBLACHKO;Mn;0;NSM;;;;;N;;;;;
+1CF3B;ZNAMENNY COMBINING MARK SOROCHYA NOZHKA;Mn;0;NSM;;;;;N;;;;;
+1CF3C;ZNAMENNY COMBINING MARK TOCHKA;Mn;0;NSM;;;;;N;;;;;
+1CF3D;ZNAMENNY COMBINING MARK DVOETOCHIE;Mn;0;NSM;;;;;N;;;;;
+1CF3E;ZNAMENNY COMBINING ATTACHING VERTICAL OMET;Mn;0;NSM;;;;;N;;;;;
+1CF3F;ZNAMENNY COMBINING MARK CURVED OMET;Mn;0;NSM;;;;;N;;;;;
+1CF40;ZNAMENNY COMBINING MARK KRYZH;Mn;0;NSM;;;;;N;;;;;
+1CF41;ZNAMENNY COMBINING LOWER TONAL RANGE INDICATOR;Mn;0;NSM;;;;;N;;;;;
+1CF42;ZNAMENNY PRIZNAK MODIFIER LEVEL-2;Mn;0;NSM;;;;;N;;;;;
+1CF43;ZNAMENNY PRIZNAK MODIFIER LEVEL-3;Mn;0;NSM;;;;;N;;;;;
+1CF44;ZNAMENNY PRIZNAK MODIFIER DIRECTION FLIP;Mn;0;NSM;;;;;N;;;;;
+1CF45;ZNAMENNY PRIZNAK MODIFIER KRYZH;Mn;0;NSM;;;;;N;;;;;
+1CF46;ZNAMENNY PRIZNAK MODIFIER ROG;Mn;0;NSM;;;;;N;;;;;
+1CF50;ZNAMENNY NEUME KRYUK;So;0;L;;;;;N;;;;;
+1CF51;ZNAMENNY NEUME KRYUK TIKHY;So;0;L;;;;;N;;;;;
+1CF52;ZNAMENNY NEUME PARAKLIT;So;0;L;;;;;N;;;;;
+1CF53;ZNAMENNY NEUME DVA V CHELNU;So;0;L;;;;;N;;;;;
+1CF54;ZNAMENNY NEUME KLYUCH;So;0;L;;;;;N;;;;;
+1CF55;ZNAMENNY NEUME ZANOZHEK;So;0;L;;;;;N;;;;;
+1CF56;ZNAMENNY NEUME STOPITSA;So;0;L;;;;;N;;;;;
+1CF57;ZNAMENNY NEUME STOPITSA S OCHKOM;So;0;L;;;;;N;;;;;
+1CF58;ZNAMENNY NEUME PEREVODKA;So;0;L;;;;;N;;;;;
+1CF59;ZNAMENNY NEUME PEREVODKA NEPOSTOYANNAYA;So;0;L;;;;;N;;;;;
+1CF5A;ZNAMENNY NEUME STOPITSA WITH SOROCHYA NOZHKA;So;0;L;;;;;N;;;;;
+1CF5B;ZNAMENNY NEUME CHELYUSTKA;So;0;L;;;;;N;;;;;
+1CF5C;ZNAMENNY NEUME PALKA;So;0;L;;;;;N;;;;;
+1CF5D;ZNAMENNY NEUME ZAPYATAYA;So;0;L;;;;;N;;;;;
+1CF5E;ZNAMENNY NEUME GOLUBCHIK BORZY;So;0;L;;;;;N;;;;;
+1CF5F;ZNAMENNY NEUME GOLUBCHIK TIKHY;So;0;L;;;;;N;;;;;
+1CF60;ZNAMENNY NEUME GOLUBCHIK MRACHNY;So;0;L;;;;;N;;;;;
+1CF61;ZNAMENNY NEUME GOLUBCHIK SVETLY;So;0;L;;;;;N;;;;;
+1CF62;ZNAMENNY NEUME GOLUBCHIK TRESVETLY;So;0;L;;;;;N;;;;;
+1CF63;ZNAMENNY NEUME VRAKHIYA PROSTAYA;So;0;L;;;;;N;;;;;
+1CF64;ZNAMENNY NEUME VRAKHIYA MRACHNAYA;So;0;L;;;;;N;;;;;
+1CF65;ZNAMENNY NEUME VRAKHIYA SVETLAYA;So;0;L;;;;;N;;;;;
+1CF66;ZNAMENNY NEUME VRAKHIYA TRESVETLAYA;So;0;L;;;;;N;;;;;
+1CF67;ZNAMENNY NEUME VRAKHIYA KLYUCHEVAYA PROSTAYA;So;0;L;;;;;N;;;;;
+1CF68;ZNAMENNY NEUME VRAKHIYA KLYUCHEVAYA MRACHNAYA;So;0;L;;;;;N;;;;;
+1CF69;ZNAMENNY NEUME VRAKHIYA KLYUCHEVAYA SVETLAYA;So;0;L;;;;;N;;;;;
+1CF6A;ZNAMENNY NEUME VRAKHIYA KLYUCHEVAYA TRESVETLAYA;So;0;L;;;;;N;;;;;
+1CF6B;ZNAMENNY NEUME DOUBLE ZAPYATAYA;So;0;L;;;;;N;;;;;
+1CF6C;ZNAMENNY NEUME REVERSED CHELYUSTKA;So;0;L;;;;;N;;;;;
+1CF6D;ZNAMENNY NEUME DERBITSA;So;0;L;;;;;N;;;;;
+1CF6E;ZNAMENNY NEUME KHAMILO;So;0;L;;;;;N;;;;;
+1CF6F;ZNAMENNY NEUME CHASHKA;So;0;L;;;;;N;;;;;
+1CF70;ZNAMENNY NEUME PODCHASHIE;So;0;L;;;;;N;;;;;
+1CF71;ZNAMENNY NEUME SKAMEYTSA MRACHNAYA;So;0;L;;;;;N;;;;;
+1CF72;ZNAMENNY NEUME SKAMEYTSA SVETLAYA;So;0;L;;;;;N;;;;;
+1CF73;ZNAMENNY NEUME SKAMEYTSA TRESVETLAYA;So;0;L;;;;;N;;;;;
+1CF74;ZNAMENNY NEUME SKAMEYTSA TIKHAYA;So;0;L;;;;;N;;;;;
+1CF75;ZNAMENNY NEUME DEMESTVENNY KLYUCH;So;0;L;;;;;N;;;;;
+1CF76;ZNAMENNY NEUME SKAMEYTSA KLYUCHEVAYA SVETLAYA;So;0;L;;;;;N;;;;;
+1CF77;ZNAMENNY NEUME SKAMEYTSA KLYUCHENEPOSTOYANNAYA;So;0;L;;;;;N;;;;;
+1CF78;ZNAMENNY NEUME SKAMEYTSA KLYUCHEVAYA TIKHAYA;So;0;L;;;;;N;;;;;
+1CF79;ZNAMENNY NEUME SKAMEYTSA DVOECHELNAYA PROSTAYA;So;0;L;;;;;N;;;;;
+1CF7A;ZNAMENNY NEUME SKAMEYTSA DVOECHELNAYA SVETLAYA;So;0;L;;;;;N;;;;;
+1CF7B;ZNAMENNY NEUME SKAMEYTSA DVOECHELNAYA NEPOSTOYANNAYA;So;0;L;;;;;N;;;;;
+1CF7C;ZNAMENNY NEUME SKAMEYTSA DVOECHELNAYA KLYUCHEVAYA;So;0;L;;;;;N;;;;;
+1CF7D;ZNAMENNY NEUME SLOZHITIE;So;0;L;;;;;N;;;;;
+1CF7E;ZNAMENNY NEUME SLOZHITIE S ZAPYATOY;So;0;L;;;;;N;;;;;
+1CF7F;ZNAMENNY NEUME SLOZHITIE ZAKRYTOE;So;0;L;;;;;N;;;;;
+1CF80;ZNAMENNY NEUME SLOZHITIE S KRYZHEM;So;0;L;;;;;N;;;;;
+1CF81;ZNAMENNY NEUME KRYZH;So;0;L;;;;;N;;;;;
+1CF82;ZNAMENNY NEUME ROG;So;0;L;;;;;N;;;;;
+1CF83;ZNAMENNY NEUME FITA;So;0;L;;;;;N;;;;;
+1CF84;ZNAMENNY NEUME KOBYLA;So;0;L;;;;;N;;;;;
+1CF85;ZNAMENNY NEUME ZMEYTSA;So;0;L;;;;;N;;;;;
+1CF86;ZNAMENNY NEUME STATYA;So;0;L;;;;;N;;;;;
+1CF87;ZNAMENNY NEUME STATYA S ZAPYATOY;So;0;L;;;;;N;;;;;
+1CF88;ZNAMENNY NEUME STATYA S KRYZHEM;So;0;L;;;;;N;;;;;
+1CF89;ZNAMENNY NEUME STATYA S ZAPYATOY I KRYZHEM;So;0;L;;;;;N;;;;;
+1CF8A;ZNAMENNY NEUME STATYA S KRYZHEM I ZAPYATOY;So;0;L;;;;;N;;;;;
+1CF8B;ZNAMENNY NEUME STATYA ZAKRYTAYA;So;0;L;;;;;N;;;;;
+1CF8C;ZNAMENNY NEUME STATYA ZAKRYTAYA S ZAPYATOY;So;0;L;;;;;N;;;;;
+1CF8D;ZNAMENNY NEUME STATYA S ROGOM;So;0;L;;;;;N;;;;;
+1CF8E;ZNAMENNY NEUME STATYA S DVUMYA ZAPYATYMI;So;0;L;;;;;N;;;;;
+1CF8F;ZNAMENNY NEUME STATYA S ZAPYATOY I PODCHASHIEM;So;0;L;;;;;N;;;;;
+1CF90;ZNAMENNY NEUME POLKULIZMY;So;0;L;;;;;N;;;;;
+1CF91;ZNAMENNY NEUME STATYA NEPOSTOYANNAYA;So;0;L;;;;;N;;;;;
+1CF92;ZNAMENNY NEUME STRELA PROSTAYA;So;0;L;;;;;N;;;;;
+1CF93;ZNAMENNY NEUME STRELA MRACHNOTIKHAYA;So;0;L;;;;;N;;;;;
+1CF94;ZNAMENNY NEUME STRELA KRYZHEVAYA;So;0;L;;;;;N;;;;;
+1CF95;ZNAMENNY NEUME STRELA POLUPOVODNAYA;So;0;L;;;;;N;;;;;
+1CF96;ZNAMENNY NEUME STRELA POVODNAYA;So;0;L;;;;;N;;;;;
+1CF97;ZNAMENNY NEUME STRELA NEPOSTOYANNAYA;So;0;L;;;;;N;;;;;
+1CF98;ZNAMENNY NEUME STRELA KLYUCHEPOVODNAYA;So;0;L;;;;;N;;;;;
+1CF99;ZNAMENNY NEUME STRELA KLYUCHENEPOSTOYANNAYA;So;0;L;;;;;N;;;;;
+1CF9A;ZNAMENNY NEUME STRELA TIKHAYA PUTNAYA;So;0;L;;;;;N;;;;;
+1CF9B;ZNAMENNY NEUME STRELA DVOECHELNAYA;So;0;L;;;;;N;;;;;
+1CF9C;ZNAMENNY NEUME STRELA DVOECHELNOKRYZHEVAYA;So;0;L;;;;;N;;;;;
+1CF9D;ZNAMENNY NEUME STRELA DVOECHELNOPOVODNAYA;So;0;L;;;;;N;;;;;
+1CF9E;ZNAMENNY NEUME STRELA DVOECHELNAYA KLYUCHEVAYA;So;0;L;;;;;N;;;;;
+1CF9F;ZNAMENNY NEUME STRELA DVOECHELNOPOVODNAYA KLYUCHEVAYA;So;0;L;;;;;N;;;;;
+1CFA0;ZNAMENNY NEUME STRELA GROMNAYA WITH SINGLE ZAPYATAYA;So;0;L;;;;;N;;;;;
+1CFA1;ZNAMENNY NEUME STRELA GROMOPOVODNAYA WITH SINGLE ZAPYATAYA;So;0;L;;;;;N;;;;;
+1CFA2;ZNAMENNY NEUME STRELA GROMNAYA;So;0;L;;;;;N;;;;;
+1CFA3;ZNAMENNY NEUME STRELA GROMOPOVODNAYA;So;0;L;;;;;N;;;;;
+1CFA4;ZNAMENNY NEUME STRELA GROMOPOVODNAYA WITH DOUBLE ZAPYATAYA;So;0;L;;;;;N;;;;;
+1CFA5;ZNAMENNY NEUME STRELA GROMOKRYZHEVAYA;So;0;L;;;;;N;;;;;
+1CFA6;ZNAMENNY NEUME STRELA GROMOKRYZHEVAYA POVODNAYA;So;0;L;;;;;N;;;;;
+1CFA7;ZNAMENNY NEUME MECHIK;So;0;L;;;;;N;;;;;
+1CFA8;ZNAMENNY NEUME MECHIK POVODNY;So;0;L;;;;;N;;;;;
+1CFA9;ZNAMENNY NEUME MECHIK KLYUCHEVOY;So;0;L;;;;;N;;;;;
+1CFAA;ZNAMENNY NEUME MECHIK KLYUCHEPOVODNY;So;0;L;;;;;N;;;;;
+1CFAB;ZNAMENNY NEUME MECHIK KLYUCHENEPOSTOYANNY;So;0;L;;;;;N;;;;;
+1CFAC;ZNAMENNY NEUME STRELA TRYASOGLASNAYA;So;0;L;;;;;N;;;;;
+1CFAD;ZNAMENNY NEUME STRELA TRYASOPOVODNAYA;So;0;L;;;;;N;;;;;
+1CFAE;ZNAMENNY NEUME STRELA TRYASOSTRELNAYA;So;0;L;;;;;N;;;;;
+1CFAF;ZNAMENNY NEUME OSOKA;So;0;L;;;;;N;;;;;
+1CFB0;ZNAMENNY NEUME OSOKA SVETLAYA;So;0;L;;;;;N;;;;;
+1CFB1;ZNAMENNY NEUME OSOKA TRESVETLAYA;So;0;L;;;;;N;;;;;
+1CFB2;ZNAMENNY NEUME OSOKA KRYUKOVAYA SVETLAYA;So;0;L;;;;;N;;;;;
+1CFB3;ZNAMENNY NEUME OSOKA KLYUCHEVAYA SVETLAYA;So;0;L;;;;;N;;;;;
+1CFB4;ZNAMENNY NEUME OSOKA KLYUCHEVAYA NEPOSTOYANNAYA;So;0;L;;;;;N;;;;;
+1CFB5;ZNAMENNY NEUME STRELA KRYUKOVAYA;So;0;L;;;;;N;;;;;
+1CFB6;ZNAMENNY NEUME STRELA KRYUKOVAYA POVODNAYA;So;0;L;;;;;N;;;;;
+1CFB7;ZNAMENNY NEUME STRELA KRYUKOVAYA GROMNAYA WITH SINGLE ZAPYATAYA;So;0;L;;;;;N;;;;;
+1CFB8;ZNAMENNY NEUME STRELA KRYUKOVAYA GROMOPOVODNAYA WITH SINGLE ZAPYATAYA;So;0;L;;;;;N;;;;;
+1CFB9;ZNAMENNY NEUME STRELA KRYUKOVAYA GROMNAYA;So;0;L;;;;;N;;;;;
+1CFBA;ZNAMENNY NEUME STRELA KRYUKOVAYA GROMOPOVODNAYA;So;0;L;;;;;N;;;;;
+1CFBB;ZNAMENNY NEUME STRELA KRYUKOVAYA GROMOPOVODNAYA WITH DOUBLE ZAPYATAYA;So;0;L;;;;;N;;;;;
+1CFBC;ZNAMENNY NEUME STRELA KRYUKOVAYA GROMOKRYZHEVAYA;So;0;L;;;;;N;;;;;
+1CFBD;ZNAMENNY NEUME STRELA KRYUKOVAYA GROMOKRYZHEVAYA POVODNAYA;So;0;L;;;;;N;;;;;
+1CFBE;ZNAMENNY NEUME STRELA KRYUKOVAYA TRYASKA;So;0;L;;;;;N;;;;;
+1CFBF;ZNAMENNY NEUME KUFISMA;So;0;L;;;;;N;;;;;
+1CFC0;ZNAMENNY NEUME OBLAKO;So;0;L;;;;;N;;;;;
+1CFC1;ZNAMENNY NEUME DUDA;So;0;L;;;;;N;;;;;
+1CFC2;ZNAMENNY NEUME NEMKA;So;0;L;;;;;N;;;;;
+1CFC3;ZNAMENNY NEUME PAUK;So;0;L;;;;;N;;;;;
 1D000;BYZANTINE MUSICAL SYMBOL PSILI;So;0;L;;;;;N;;;;;
 1D001;BYZANTINE MUSICAL SYMBOL DASEIA;So;0;L;;;;;N;;;;;
 1D002;BYZANTINE MUSICAL SYMBOL PERISPOMENI;So;0;L;;;;;N;;;;;
@@ -23080,6 +34093,19 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1D1DB;MUSICAL SYMBOL SCANDICUS FLEXUS;So;0;L;;;;;N;;;;;
 1D1DC;MUSICAL SYMBOL TORCULUS RESUPINUS;So;0;L;;;;;N;;;;;
 1D1DD;MUSICAL SYMBOL PES SUBPUNCTIS;So;0;L;;;;;N;;;;;
+1D1DE;MUSICAL SYMBOL KIEVAN C CLEF;So;0;L;;;;;N;;;;;
+1D1DF;MUSICAL SYMBOL KIEVAN END OF PIECE;So;0;L;;;;;N;;;;;
+1D1E0;MUSICAL SYMBOL KIEVAN FINAL NOTE;So;0;L;;;;;N;;;;;
+1D1E1;MUSICAL SYMBOL KIEVAN RECITATIVE MARK;So;0;L;;;;;N;;;;;
+1D1E2;MUSICAL SYMBOL KIEVAN WHOLE NOTE;So;0;L;;;;;N;;;;;
+1D1E3;MUSICAL SYMBOL KIEVAN HALF NOTE;So;0;L;;;;;N;;;;;
+1D1E4;MUSICAL SYMBOL KIEVAN QUARTER NOTE STEM DOWN;So;0;L;;;;;N;;;;;
+1D1E5;MUSICAL SYMBOL KIEVAN QUARTER NOTE STEM UP;So;0;L;;;;;N;;;;;
+1D1E6;MUSICAL SYMBOL KIEVAN EIGHTH NOTE STEM DOWN;So;0;L;;;;;N;;;;;
+1D1E7;MUSICAL SYMBOL KIEVAN EIGHTH NOTE STEM UP;So;0;L;;;;;N;;;;;
+1D1E8;MUSICAL SYMBOL KIEVAN FLAT SIGN;So;0;L;;;;;N;;;;;
+1D1E9;MUSICAL SYMBOL SORI;So;0;ON;;;;;N;;;;;
+1D1EA;MUSICAL SYMBOL KORON;So;0;ON;;;;;N;;;;;
 1D200;GREEK VOCAL NOTATION SYMBOL-1;So;0;ON;;;;;N;;;;;
 1D201;GREEK VOCAL NOTATION SYMBOL-2;So;0;ON;;;;;N;;;;;
 1D202;GREEK VOCAL NOTATION SYMBOL-3;So;0;ON;;;;;N;;;;;
@@ -23150,6 +34176,46 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1D243;COMBINING GREEK MUSICAL TETRASEME;Mn;230;NSM;;;;;N;;;;;
 1D244;COMBINING GREEK MUSICAL PENTASEME;Mn;230;NSM;;;;;N;;;;;
 1D245;GREEK MUSICAL LEIMMA;So;0;ON;;;;;N;;;;;
+1D2C0;KAKTOVIK NUMERAL ZERO;No;0;L;;;;0;N;;;;;
+1D2C1;KAKTOVIK NUMERAL ONE;No;0;L;;;;1;N;;;;;
+1D2C2;KAKTOVIK NUMERAL TWO;No;0;L;;;;2;N;;;;;
+1D2C3;KAKTOVIK NUMERAL THREE;No;0;L;;;;3;N;;;;;
+1D2C4;KAKTOVIK NUMERAL FOUR;No;0;L;;;;4;N;;;;;
+1D2C5;KAKTOVIK NUMERAL FIVE;No;0;L;;;;5;N;;;;;
+1D2C6;KAKTOVIK NUMERAL SIX;No;0;L;;;;6;N;;;;;
+1D2C7;KAKTOVIK NUMERAL SEVEN;No;0;L;;;;7;N;;;;;
+1D2C8;KAKTOVIK NUMERAL EIGHT;No;0;L;;;;8;N;;;;;
+1D2C9;KAKTOVIK NUMERAL NINE;No;0;L;;;;9;N;;;;;
+1D2CA;KAKTOVIK NUMERAL TEN;No;0;L;;;;10;N;;;;;
+1D2CB;KAKTOVIK NUMERAL ELEVEN;No;0;L;;;;11;N;;;;;
+1D2CC;KAKTOVIK NUMERAL TWELVE;No;0;L;;;;12;N;;;;;
+1D2CD;KAKTOVIK NUMERAL THIRTEEN;No;0;L;;;;13;N;;;;;
+1D2CE;KAKTOVIK NUMERAL FOURTEEN;No;0;L;;;;14;N;;;;;
+1D2CF;KAKTOVIK NUMERAL FIFTEEN;No;0;L;;;;15;N;;;;;
+1D2D0;KAKTOVIK NUMERAL SIXTEEN;No;0;L;;;;16;N;;;;;
+1D2D1;KAKTOVIK NUMERAL SEVENTEEN;No;0;L;;;;17;N;;;;;
+1D2D2;KAKTOVIK NUMERAL EIGHTEEN;No;0;L;;;;18;N;;;;;
+1D2D3;KAKTOVIK NUMERAL NINETEEN;No;0;L;;;;19;N;;;;;
+1D2E0;MAYAN NUMERAL ZERO;No;0;L;;;;0;N;;;;;
+1D2E1;MAYAN NUMERAL ONE;No;0;L;;;;1;N;;;;;
+1D2E2;MAYAN NUMERAL TWO;No;0;L;;;;2;N;;;;;
+1D2E3;MAYAN NUMERAL THREE;No;0;L;;;;3;N;;;;;
+1D2E4;MAYAN NUMERAL FOUR;No;0;L;;;;4;N;;;;;
+1D2E5;MAYAN NUMERAL FIVE;No;0;L;;;;5;N;;;;;
+1D2E6;MAYAN NUMERAL SIX;No;0;L;;;;6;N;;;;;
+1D2E7;MAYAN NUMERAL SEVEN;No;0;L;;;;7;N;;;;;
+1D2E8;MAYAN NUMERAL EIGHT;No;0;L;;;;8;N;;;;;
+1D2E9;MAYAN NUMERAL NINE;No;0;L;;;;9;N;;;;;
+1D2EA;MAYAN NUMERAL TEN;No;0;L;;;;10;N;;;;;
+1D2EB;MAYAN NUMERAL ELEVEN;No;0;L;;;;11;N;;;;;
+1D2EC;MAYAN NUMERAL TWELVE;No;0;L;;;;12;N;;;;;
+1D2ED;MAYAN NUMERAL THIRTEEN;No;0;L;;;;13;N;;;;;
+1D2EE;MAYAN NUMERAL FOURTEEN;No;0;L;;;;14;N;;;;;
+1D2EF;MAYAN NUMERAL FIFTEEN;No;0;L;;;;15;N;;;;;
+1D2F0;MAYAN NUMERAL SIXTEEN;No;0;L;;;;16;N;;;;;
+1D2F1;MAYAN NUMERAL SEVENTEEN;No;0;L;;;;17;N;;;;;
+1D2F2;MAYAN NUMERAL EIGHTEEN;No;0;L;;;;18;N;;;;;
+1D2F3;MAYAN NUMERAL NINETEEN;No;0;L;;;;19;N;;;;;
 1D300;MONOGRAM FOR EARTH;So;0;ON;;;;;N;;;;;
 1D301;DIGRAM FOR HEAVENLY EARTH;So;0;ON;;;;;N;;;;;
 1D302;DIGRAM FOR HUMAN EARTH;So;0;ON;;;;;N;;;;;
@@ -23255,6 +34321,13 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1D36F;COUNTING ROD TENS DIGIT SEVEN;No;0;L;;;;70;N;;;;;
 1D370;COUNTING ROD TENS DIGIT EIGHT;No;0;L;;;;80;N;;;;;
 1D371;COUNTING ROD TENS DIGIT NINE;No;0;L;;;;90;N;;;;;
+1D372;IDEOGRAPHIC TALLY MARK ONE;No;0;L;;;;1;N;;;;;
+1D373;IDEOGRAPHIC TALLY MARK TWO;No;0;L;;;;2;N;;;;;
+1D374;IDEOGRAPHIC TALLY MARK THREE;No;0;L;;;;3;N;;;;;
+1D375;IDEOGRAPHIC TALLY MARK FOUR;No;0;L;;;;4;N;;;;;
+1D376;IDEOGRAPHIC TALLY MARK FIVE;No;0;L;;;;5;N;;;;;
+1D377;TALLY MARK ONE;No;0;L;;;;1;N;;;;;
+1D378;TALLY MARK FIVE;No;0;L;;;;5;N;;;;;
 1D400;MATHEMATICAL BOLD CAPITAL A;Lu;0;L;<font> 0041;;;;N;;;;;
 1D401;MATHEMATICAL BOLD CAPITAL B;Lu;0;L;<font> 0042;;;;N;;;;;
 1D402;MATHEMATICAL BOLD CAPITAL C;Lu;0;L;<font> 0043;;;;N;;;;;
@@ -23934,7 +35007,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1D6BE;MATHEMATICAL BOLD CAPITAL CHI;Lu;0;L;<font> 03A7;;;;N;;;;;
 1D6BF;MATHEMATICAL BOLD CAPITAL PSI;Lu;0;L;<font> 03A8;;;;N;;;;;
 1D6C0;MATHEMATICAL BOLD CAPITAL OMEGA;Lu;0;L;<font> 03A9;;;;N;;;;;
-1D6C1;MATHEMATICAL BOLD NABLA;Sm;0;L;<font> 2207;;;;N;;;;;
+1D6C1;MATHEMATICAL BOLD NABLA;Sm;0;ON;<font> 2207;;;;N;;;;;
 1D6C2;MATHEMATICAL BOLD SMALL ALPHA;Ll;0;L;<font> 03B1;;;;N;;;;;
 1D6C3;MATHEMATICAL BOLD SMALL BETA;Ll;0;L;<font> 03B2;;;;N;;;;;
 1D6C4;MATHEMATICAL BOLD SMALL GAMMA;Ll;0;L;<font> 03B3;;;;N;;;;;
@@ -23992,7 +35065,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1D6F8;MATHEMATICAL ITALIC CAPITAL CHI;Lu;0;L;<font> 03A7;;;;N;;;;;
 1D6F9;MATHEMATICAL ITALIC CAPITAL PSI;Lu;0;L;<font> 03A8;;;;N;;;;;
 1D6FA;MATHEMATICAL ITALIC CAPITAL OMEGA;Lu;0;L;<font> 03A9;;;;N;;;;;
-1D6FB;MATHEMATICAL ITALIC NABLA;Sm;0;L;<font> 2207;;;;N;;;;;
+1D6FB;MATHEMATICAL ITALIC NABLA;Sm;0;ON;<font> 2207;;;;N;;;;;
 1D6FC;MATHEMATICAL ITALIC SMALL ALPHA;Ll;0;L;<font> 03B1;;;;N;;;;;
 1D6FD;MATHEMATICAL ITALIC SMALL BETA;Ll;0;L;<font> 03B2;;;;N;;;;;
 1D6FE;MATHEMATICAL ITALIC SMALL GAMMA;Ll;0;L;<font> 03B3;;;;N;;;;;
@@ -24050,7 +35123,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1D732;MATHEMATICAL BOLD ITALIC CAPITAL CHI;Lu;0;L;<font> 03A7;;;;N;;;;;
 1D733;MATHEMATICAL BOLD ITALIC CAPITAL PSI;Lu;0;L;<font> 03A8;;;;N;;;;;
 1D734;MATHEMATICAL BOLD ITALIC CAPITAL OMEGA;Lu;0;L;<font> 03A9;;;;N;;;;;
-1D735;MATHEMATICAL BOLD ITALIC NABLA;Sm;0;L;<font> 2207;;;;N;;;;;
+1D735;MATHEMATICAL BOLD ITALIC NABLA;Sm;0;ON;<font> 2207;;;;N;;;;;
 1D736;MATHEMATICAL BOLD ITALIC SMALL ALPHA;Ll;0;L;<font> 03B1;;;;N;;;;;
 1D737;MATHEMATICAL BOLD ITALIC SMALL BETA;Ll;0;L;<font> 03B2;;;;N;;;;;
 1D738;MATHEMATICAL BOLD ITALIC SMALL GAMMA;Ll;0;L;<font> 03B3;;;;N;;;;;
@@ -24108,7 +35181,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1D76C;MATHEMATICAL SANS-SERIF BOLD CAPITAL CHI;Lu;0;L;<font> 03A7;;;;N;;;;;
 1D76D;MATHEMATICAL SANS-SERIF BOLD CAPITAL PSI;Lu;0;L;<font> 03A8;;;;N;;;;;
 1D76E;MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA;Lu;0;L;<font> 03A9;;;;N;;;;;
-1D76F;MATHEMATICAL SANS-SERIF BOLD NABLA;Sm;0;L;<font> 2207;;;;N;;;;;
+1D76F;MATHEMATICAL SANS-SERIF BOLD NABLA;Sm;0;ON;<font> 2207;;;;N;;;;;
 1D770;MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA;Ll;0;L;<font> 03B1;;;;N;;;;;
 1D771;MATHEMATICAL SANS-SERIF BOLD SMALL BETA;Ll;0;L;<font> 03B2;;;;N;;;;;
 1D772;MATHEMATICAL SANS-SERIF BOLD SMALL GAMMA;Ll;0;L;<font> 03B3;;;;N;;;;;
@@ -24166,7 +35239,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1D7A6;MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL CHI;Lu;0;L;<font> 03A7;;;;N;;;;;
 1D7A7;MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PSI;Lu;0;L;<font> 03A8;;;;N;;;;;
 1D7A8;MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA;Lu;0;L;<font> 03A9;;;;N;;;;;
-1D7A9;MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA;Sm;0;L;<font> 2207;;;;N;;;;;
+1D7A9;MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA;Sm;0;ON;<font> 2207;;;;N;;;;;
 1D7AA;MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA;Ll;0;L;<font> 03B1;;;;N;;;;;
 1D7AB;MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL BETA;Ll;0;L;<font> 03B2;;;;N;;;;;
 1D7AC;MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL GAMMA;Ll;0;L;<font> 03B3;;;;N;;;;;
@@ -24251,6 +35324,1146 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1D7FD;MATHEMATICAL MONOSPACE DIGIT SEVEN;Nd;0;EN;<font> 0037;7;7;7;N;;;;;
 1D7FE;MATHEMATICAL MONOSPACE DIGIT EIGHT;Nd;0;EN;<font> 0038;8;8;8;N;;;;;
 1D7FF;MATHEMATICAL MONOSPACE DIGIT NINE;Nd;0;EN;<font> 0039;9;9;9;N;;;;;
+1D800;SIGNWRITING HAND-FIST INDEX;So;0;L;;;;;N;;;;;
+1D801;SIGNWRITING HAND-CIRCLE INDEX;So;0;L;;;;;N;;;;;
+1D802;SIGNWRITING HAND-CUP INDEX;So;0;L;;;;;N;;;;;
+1D803;SIGNWRITING HAND-OVAL INDEX;So;0;L;;;;;N;;;;;
+1D804;SIGNWRITING HAND-HINGE INDEX;So;0;L;;;;;N;;;;;
+1D805;SIGNWRITING HAND-ANGLE INDEX;So;0;L;;;;;N;;;;;
+1D806;SIGNWRITING HAND-FIST INDEX BENT;So;0;L;;;;;N;;;;;
+1D807;SIGNWRITING HAND-CIRCLE INDEX BENT;So;0;L;;;;;N;;;;;
+1D808;SIGNWRITING HAND-FIST THUMB UNDER INDEX BENT;So;0;L;;;;;N;;;;;
+1D809;SIGNWRITING HAND-FIST INDEX RAISED KNUCKLE;So;0;L;;;;;N;;;;;
+1D80A;SIGNWRITING HAND-FIST INDEX CUPPED;So;0;L;;;;;N;;;;;
+1D80B;SIGNWRITING HAND-FIST INDEX HINGED;So;0;L;;;;;N;;;;;
+1D80C;SIGNWRITING HAND-FIST INDEX HINGED LOW;So;0;L;;;;;N;;;;;
+1D80D;SIGNWRITING HAND-CIRCLE INDEX HINGE;So;0;L;;;;;N;;;;;
+1D80E;SIGNWRITING HAND-FIST INDEX MIDDLE;So;0;L;;;;;N;;;;;
+1D80F;SIGNWRITING HAND-CIRCLE INDEX MIDDLE;So;0;L;;;;;N;;;;;
+1D810;SIGNWRITING HAND-FIST INDEX MIDDLE BENT;So;0;L;;;;;N;;;;;
+1D811;SIGNWRITING HAND-FIST INDEX MIDDLE RAISED KNUCKLES;So;0;L;;;;;N;;;;;
+1D812;SIGNWRITING HAND-FIST INDEX MIDDLE HINGED;So;0;L;;;;;N;;;;;
+1D813;SIGNWRITING HAND-FIST INDEX UP MIDDLE HINGED;So;0;L;;;;;N;;;;;
+1D814;SIGNWRITING HAND-FIST INDEX HINGED MIDDLE UP;So;0;L;;;;;N;;;;;
+1D815;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED;So;0;L;;;;;N;;;;;
+1D816;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED INDEX BENT;So;0;L;;;;;N;;;;;
+1D817;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED MIDDLE BENT;So;0;L;;;;;N;;;;;
+1D818;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED CUPPED;So;0;L;;;;;N;;;;;
+1D819;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED HINGED;So;0;L;;;;;N;;;;;
+1D81A;SIGNWRITING HAND-FIST INDEX MIDDLE CROSSED;So;0;L;;;;;N;;;;;
+1D81B;SIGNWRITING HAND-CIRCLE INDEX MIDDLE CROSSED;So;0;L;;;;;N;;;;;
+1D81C;SIGNWRITING HAND-FIST MIDDLE BENT OVER INDEX;So;0;L;;;;;N;;;;;
+1D81D;SIGNWRITING HAND-FIST INDEX BENT OVER MIDDLE;So;0;L;;;;;N;;;;;
+1D81E;SIGNWRITING HAND-FIST INDEX MIDDLE THUMB;So;0;L;;;;;N;;;;;
+1D81F;SIGNWRITING HAND-CIRCLE INDEX MIDDLE THUMB;So;0;L;;;;;N;;;;;
+1D820;SIGNWRITING HAND-FIST INDEX MIDDLE STRAIGHT THUMB BENT;So;0;L;;;;;N;;;;;
+1D821;SIGNWRITING HAND-FIST INDEX MIDDLE BENT THUMB STRAIGHT;So;0;L;;;;;N;;;;;
+1D822;SIGNWRITING HAND-FIST INDEX MIDDLE THUMB BENT;So;0;L;;;;;N;;;;;
+1D823;SIGNWRITING HAND-FIST INDEX MIDDLE HINGED SPREAD THUMB SIDE;So;0;L;;;;;N;;;;;
+1D824;SIGNWRITING HAND-FIST INDEX UP MIDDLE HINGED THUMB SIDE;So;0;L;;;;;N;;;;;
+1D825;SIGNWRITING HAND-FIST INDEX UP MIDDLE HINGED THUMB CONJOINED;So;0;L;;;;;N;;;;;
+1D826;SIGNWRITING HAND-FIST INDEX HINGED MIDDLE UP THUMB SIDE;So;0;L;;;;;N;;;;;
+1D827;SIGNWRITING HAND-FIST INDEX MIDDLE UP SPREAD THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D828;SIGNWRITING HAND-FIST INDEX MIDDLE THUMB CUPPED;So;0;L;;;;;N;;;;;
+1D829;SIGNWRITING HAND-FIST INDEX MIDDLE THUMB CIRCLED;So;0;L;;;;;N;;;;;
+1D82A;SIGNWRITING HAND-FIST INDEX MIDDLE THUMB HOOKED;So;0;L;;;;;N;;;;;
+1D82B;SIGNWRITING HAND-FIST INDEX MIDDLE THUMB HINGED;So;0;L;;;;;N;;;;;
+1D82C;SIGNWRITING HAND-FIST THUMB BETWEEN INDEX MIDDLE STRAIGHT;So;0;L;;;;;N;;;;;
+1D82D;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED THUMB SIDE;So;0;L;;;;;N;;;;;
+1D82E;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED THUMB SIDE CONJOINED;So;0;L;;;;;N;;;;;
+1D82F;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED THUMB SIDE BENT;So;0;L;;;;;N;;;;;
+1D830;SIGNWRITING HAND-FIST MIDDLE THUMB HOOKED INDEX UP;So;0;L;;;;;N;;;;;
+1D831;SIGNWRITING HAND-FIST INDEX THUMB HOOKED MIDDLE UP;So;0;L;;;;;N;;;;;
+1D832;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED HINGED THUMB SIDE;So;0;L;;;;;N;;;;;
+1D833;SIGNWRITING HAND-FIST INDEX MIDDLE CROSSED THUMB SIDE;So;0;L;;;;;N;;;;;
+1D834;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D835;SIGNWRITING HAND-FIST INDEX MIDDLE CONJOINED CUPPED THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D836;SIGNWRITING HAND-FIST MIDDLE THUMB CUPPED INDEX UP;So;0;L;;;;;N;;;;;
+1D837;SIGNWRITING HAND-FIST INDEX THUMB CUPPED MIDDLE UP;So;0;L;;;;;N;;;;;
+1D838;SIGNWRITING HAND-FIST MIDDLE THUMB CIRCLED INDEX UP;So;0;L;;;;;N;;;;;
+1D839;SIGNWRITING HAND-FIST MIDDLE THUMB CIRCLED INDEX HINGED;So;0;L;;;;;N;;;;;
+1D83A;SIGNWRITING HAND-FIST INDEX THUMB ANGLED OUT MIDDLE UP;So;0;L;;;;;N;;;;;
+1D83B;SIGNWRITING HAND-FIST INDEX THUMB ANGLED IN MIDDLE UP;So;0;L;;;;;N;;;;;
+1D83C;SIGNWRITING HAND-FIST INDEX THUMB CIRCLED MIDDLE UP;So;0;L;;;;;N;;;;;
+1D83D;SIGNWRITING HAND-FIST INDEX MIDDLE THUMB CONJOINED HINGED;So;0;L;;;;;N;;;;;
+1D83E;SIGNWRITING HAND-FIST INDEX MIDDLE THUMB ANGLED OUT;So;0;L;;;;;N;;;;;
+1D83F;SIGNWRITING HAND-FIST INDEX MIDDLE THUMB ANGLED;So;0;L;;;;;N;;;;;
+1D840;SIGNWRITING HAND-FIST MIDDLE THUMB ANGLED OUT INDEX UP;So;0;L;;;;;N;;;;;
+1D841;SIGNWRITING HAND-FIST MIDDLE THUMB ANGLED OUT INDEX CROSSED;So;0;L;;;;;N;;;;;
+1D842;SIGNWRITING HAND-FIST MIDDLE THUMB ANGLED INDEX UP;So;0;L;;;;;N;;;;;
+1D843;SIGNWRITING HAND-FIST INDEX THUMB HOOKED MIDDLE HINGED;So;0;L;;;;;N;;;;;
+1D844;SIGNWRITING HAND-FLAT FOUR FINGERS;So;0;L;;;;;N;;;;;
+1D845;SIGNWRITING HAND-FLAT FOUR FINGERS BENT;So;0;L;;;;;N;;;;;
+1D846;SIGNWRITING HAND-FLAT FOUR FINGERS HINGED;So;0;L;;;;;N;;;;;
+1D847;SIGNWRITING HAND-FLAT FOUR FINGERS CONJOINED;So;0;L;;;;;N;;;;;
+1D848;SIGNWRITING HAND-FLAT FOUR FINGERS CONJOINED SPLIT;So;0;L;;;;;N;;;;;
+1D849;SIGNWRITING HAND-CLAW FOUR FINGERS CONJOINED;So;0;L;;;;;N;;;;;
+1D84A;SIGNWRITING HAND-FIST FOUR FINGERS CONJOINED BENT;So;0;L;;;;;N;;;;;
+1D84B;SIGNWRITING HAND-HINGE FOUR FINGERS CONJOINED;So;0;L;;;;;N;;;;;
+1D84C;SIGNWRITING HAND-FLAT FIVE FINGERS SPREAD;So;0;L;;;;;N;;;;;
+1D84D;SIGNWRITING HAND-FLAT HEEL FIVE FINGERS SPREAD;So;0;L;;;;;N;;;;;
+1D84E;SIGNWRITING HAND-FLAT FIVE FINGERS SPREAD FOUR BENT;So;0;L;;;;;N;;;;;
+1D84F;SIGNWRITING HAND-FLAT HEEL FIVE FINGERS SPREAD FOUR BENT;So;0;L;;;;;N;;;;;
+1D850;SIGNWRITING HAND-FLAT FIVE FINGERS SPREAD BENT;So;0;L;;;;;N;;;;;
+1D851;SIGNWRITING HAND-FLAT HEEL FIVE FINGERS SPREAD BENT;So;0;L;;;;;N;;;;;
+1D852;SIGNWRITING HAND-FLAT FIVE FINGERS SPREAD THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D853;SIGNWRITING HAND-CUP FIVE FINGERS SPREAD;So;0;L;;;;;N;;;;;
+1D854;SIGNWRITING HAND-CUP FIVE FINGERS SPREAD OPEN;So;0;L;;;;;N;;;;;
+1D855;SIGNWRITING HAND-HINGE FIVE FINGERS SPREAD OPEN;So;0;L;;;;;N;;;;;
+1D856;SIGNWRITING HAND-OVAL FIVE FINGERS SPREAD;So;0;L;;;;;N;;;;;
+1D857;SIGNWRITING HAND-FLAT FIVE FINGERS SPREAD HINGED;So;0;L;;;;;N;;;;;
+1D858;SIGNWRITING HAND-FLAT FIVE FINGERS SPREAD HINGED THUMB SIDE;So;0;L;;;;;N;;;;;
+1D859;SIGNWRITING HAND-FLAT FIVE FINGERS SPREAD HINGED NO THUMB;So;0;L;;;;;N;;;;;
+1D85A;SIGNWRITING HAND-FLAT;So;0;L;;;;;N;;;;;
+1D85B;SIGNWRITING HAND-FLAT BETWEEN PALM FACINGS;So;0;L;;;;;N;;;;;
+1D85C;SIGNWRITING HAND-FLAT HEEL;So;0;L;;;;;N;;;;;
+1D85D;SIGNWRITING HAND-FLAT THUMB SIDE;So;0;L;;;;;N;;;;;
+1D85E;SIGNWRITING HAND-FLAT HEEL THUMB SIDE;So;0;L;;;;;N;;;;;
+1D85F;SIGNWRITING HAND-FLAT THUMB BENT;So;0;L;;;;;N;;;;;
+1D860;SIGNWRITING HAND-FLAT THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D861;SIGNWRITING HAND-FLAT SPLIT INDEX THUMB SIDE;So;0;L;;;;;N;;;;;
+1D862;SIGNWRITING HAND-FLAT SPLIT CENTRE;So;0;L;;;;;N;;;;;
+1D863;SIGNWRITING HAND-FLAT SPLIT CENTRE THUMB SIDE;So;0;L;;;;;N;;;;;
+1D864;SIGNWRITING HAND-FLAT SPLIT CENTRE THUMB SIDE BENT;So;0;L;;;;;N;;;;;
+1D865;SIGNWRITING HAND-FLAT SPLIT LITTLE;So;0;L;;;;;N;;;;;
+1D866;SIGNWRITING HAND-CLAW;So;0;L;;;;;N;;;;;
+1D867;SIGNWRITING HAND-CLAW THUMB SIDE;So;0;L;;;;;N;;;;;
+1D868;SIGNWRITING HAND-CLAW NO THUMB;So;0;L;;;;;N;;;;;
+1D869;SIGNWRITING HAND-CLAW THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D86A;SIGNWRITING HAND-HOOK CURLICUE;So;0;L;;;;;N;;;;;
+1D86B;SIGNWRITING HAND-HOOK;So;0;L;;;;;N;;;;;
+1D86C;SIGNWRITING HAND-CUP OPEN;So;0;L;;;;;N;;;;;
+1D86D;SIGNWRITING HAND-CUP;So;0;L;;;;;N;;;;;
+1D86E;SIGNWRITING HAND-CUP OPEN THUMB SIDE;So;0;L;;;;;N;;;;;
+1D86F;SIGNWRITING HAND-CUP THUMB SIDE;So;0;L;;;;;N;;;;;
+1D870;SIGNWRITING HAND-CUP OPEN NO THUMB;So;0;L;;;;;N;;;;;
+1D871;SIGNWRITING HAND-CUP NO THUMB;So;0;L;;;;;N;;;;;
+1D872;SIGNWRITING HAND-CUP OPEN THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D873;SIGNWRITING HAND-CUP THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D874;SIGNWRITING HAND-CURLICUE OPEN;So;0;L;;;;;N;;;;;
+1D875;SIGNWRITING HAND-CURLICUE;So;0;L;;;;;N;;;;;
+1D876;SIGNWRITING HAND-CIRCLE;So;0;L;;;;;N;;;;;
+1D877;SIGNWRITING HAND-OVAL;So;0;L;;;;;N;;;;;
+1D878;SIGNWRITING HAND-OVAL THUMB SIDE;So;0;L;;;;;N;;;;;
+1D879;SIGNWRITING HAND-OVAL NO THUMB;So;0;L;;;;;N;;;;;
+1D87A;SIGNWRITING HAND-OVAL THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D87B;SIGNWRITING HAND-HINGE OPEN;So;0;L;;;;;N;;;;;
+1D87C;SIGNWRITING HAND-HINGE OPEN THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D87D;SIGNWRITING HAND-HINGE;So;0;L;;;;;N;;;;;
+1D87E;SIGNWRITING HAND-HINGE SMALL;So;0;L;;;;;N;;;;;
+1D87F;SIGNWRITING HAND-HINGE OPEN THUMB SIDE;So;0;L;;;;;N;;;;;
+1D880;SIGNWRITING HAND-HINGE THUMB SIDE;So;0;L;;;;;N;;;;;
+1D881;SIGNWRITING HAND-HINGE OPEN NO THUMB;So;0;L;;;;;N;;;;;
+1D882;SIGNWRITING HAND-HINGE NO THUMB;So;0;L;;;;;N;;;;;
+1D883;SIGNWRITING HAND-HINGE THUMB SIDE TOUCHING INDEX;So;0;L;;;;;N;;;;;
+1D884;SIGNWRITING HAND-HINGE THUMB BETWEEN MIDDLE RING;So;0;L;;;;;N;;;;;
+1D885;SIGNWRITING HAND-ANGLE;So;0;L;;;;;N;;;;;
+1D886;SIGNWRITING HAND-FIST INDEX MIDDLE RING;So;0;L;;;;;N;;;;;
+1D887;SIGNWRITING HAND-CIRCLE INDEX MIDDLE RING;So;0;L;;;;;N;;;;;
+1D888;SIGNWRITING HAND-HINGE INDEX MIDDLE RING;So;0;L;;;;;N;;;;;
+1D889;SIGNWRITING HAND-ANGLE INDEX MIDDLE RING;So;0;L;;;;;N;;;;;
+1D88A;SIGNWRITING HAND-HINGE LITTLE;So;0;L;;;;;N;;;;;
+1D88B;SIGNWRITING HAND-FIST INDEX MIDDLE RING BENT;So;0;L;;;;;N;;;;;
+1D88C;SIGNWRITING HAND-FIST INDEX MIDDLE RING CONJOINED;So;0;L;;;;;N;;;;;
+1D88D;SIGNWRITING HAND-HINGE INDEX MIDDLE RING CONJOINED;So;0;L;;;;;N;;;;;
+1D88E;SIGNWRITING HAND-FIST LITTLE DOWN;So;0;L;;;;;N;;;;;
+1D88F;SIGNWRITING HAND-FIST LITTLE DOWN RIPPLE STRAIGHT;So;0;L;;;;;N;;;;;
+1D890;SIGNWRITING HAND-FIST LITTLE DOWN RIPPLE CURVED;So;0;L;;;;;N;;;;;
+1D891;SIGNWRITING HAND-FIST LITTLE DOWN OTHERS CIRCLED;So;0;L;;;;;N;;;;;
+1D892;SIGNWRITING HAND-FIST LITTLE UP;So;0;L;;;;;N;;;;;
+1D893;SIGNWRITING HAND-FIST THUMB UNDER LITTLE UP;So;0;L;;;;;N;;;;;
+1D894;SIGNWRITING HAND-CIRCLE LITTLE UP;So;0;L;;;;;N;;;;;
+1D895;SIGNWRITING HAND-OVAL LITTLE UP;So;0;L;;;;;N;;;;;
+1D896;SIGNWRITING HAND-ANGLE LITTLE UP;So;0;L;;;;;N;;;;;
+1D897;SIGNWRITING HAND-FIST LITTLE RAISED KNUCKLE;So;0;L;;;;;N;;;;;
+1D898;SIGNWRITING HAND-FIST LITTLE BENT;So;0;L;;;;;N;;;;;
+1D899;SIGNWRITING HAND-FIST LITTLE TOUCHES THUMB;So;0;L;;;;;N;;;;;
+1D89A;SIGNWRITING HAND-FIST LITTLE THUMB;So;0;L;;;;;N;;;;;
+1D89B;SIGNWRITING HAND-HINGE LITTLE THUMB;So;0;L;;;;;N;;;;;
+1D89C;SIGNWRITING HAND-FIST LITTLE INDEX THUMB;So;0;L;;;;;N;;;;;
+1D89D;SIGNWRITING HAND-HINGE LITTLE INDEX THUMB;So;0;L;;;;;N;;;;;
+1D89E;SIGNWRITING HAND-ANGLE LITTLE INDEX THUMB INDEX THUMB OUT;So;0;L;;;;;N;;;;;
+1D89F;SIGNWRITING HAND-ANGLE LITTLE INDEX THUMB INDEX THUMB;So;0;L;;;;;N;;;;;
+1D8A0;SIGNWRITING HAND-FIST LITTLE INDEX;So;0;L;;;;;N;;;;;
+1D8A1;SIGNWRITING HAND-CIRCLE LITTLE INDEX;So;0;L;;;;;N;;;;;
+1D8A2;SIGNWRITING HAND-HINGE LITTLE INDEX;So;0;L;;;;;N;;;;;
+1D8A3;SIGNWRITING HAND-ANGLE LITTLE INDEX;So;0;L;;;;;N;;;;;
+1D8A4;SIGNWRITING HAND-FIST INDEX MIDDLE LITTLE;So;0;L;;;;;N;;;;;
+1D8A5;SIGNWRITING HAND-CIRCLE INDEX MIDDLE LITTLE;So;0;L;;;;;N;;;;;
+1D8A6;SIGNWRITING HAND-HINGE INDEX MIDDLE LITTLE;So;0;L;;;;;N;;;;;
+1D8A7;SIGNWRITING HAND-HINGE RING;So;0;L;;;;;N;;;;;
+1D8A8;SIGNWRITING HAND-ANGLE INDEX MIDDLE LITTLE;So;0;L;;;;;N;;;;;
+1D8A9;SIGNWRITING HAND-FIST INDEX MIDDLE CROSS LITTLE;So;0;L;;;;;N;;;;;
+1D8AA;SIGNWRITING HAND-CIRCLE INDEX MIDDLE CROSS LITTLE;So;0;L;;;;;N;;;;;
+1D8AB;SIGNWRITING HAND-FIST RING DOWN;So;0;L;;;;;N;;;;;
+1D8AC;SIGNWRITING HAND-HINGE RING DOWN INDEX THUMB HOOK MIDDLE;So;0;L;;;;;N;;;;;
+1D8AD;SIGNWRITING HAND-ANGLE RING DOWN MIDDLE THUMB INDEX CROSS;So;0;L;;;;;N;;;;;
+1D8AE;SIGNWRITING HAND-FIST RING UP;So;0;L;;;;;N;;;;;
+1D8AF;SIGNWRITING HAND-FIST RING RAISED KNUCKLE;So;0;L;;;;;N;;;;;
+1D8B0;SIGNWRITING HAND-FIST RING LITTLE;So;0;L;;;;;N;;;;;
+1D8B1;SIGNWRITING HAND-CIRCLE RING LITTLE;So;0;L;;;;;N;;;;;
+1D8B2;SIGNWRITING HAND-OVAL RING LITTLE;So;0;L;;;;;N;;;;;
+1D8B3;SIGNWRITING HAND-ANGLE RING LITTLE;So;0;L;;;;;N;;;;;
+1D8B4;SIGNWRITING HAND-FIST RING MIDDLE;So;0;L;;;;;N;;;;;
+1D8B5;SIGNWRITING HAND-FIST RING MIDDLE CONJOINED;So;0;L;;;;;N;;;;;
+1D8B6;SIGNWRITING HAND-FIST RING MIDDLE RAISED KNUCKLES;So;0;L;;;;;N;;;;;
+1D8B7;SIGNWRITING HAND-FIST RING INDEX;So;0;L;;;;;N;;;;;
+1D8B8;SIGNWRITING HAND-FIST RING THUMB;So;0;L;;;;;N;;;;;
+1D8B9;SIGNWRITING HAND-HOOK RING THUMB;So;0;L;;;;;N;;;;;
+1D8BA;SIGNWRITING HAND-FIST INDEX RING LITTLE;So;0;L;;;;;N;;;;;
+1D8BB;SIGNWRITING HAND-CIRCLE INDEX RING LITTLE;So;0;L;;;;;N;;;;;
+1D8BC;SIGNWRITING HAND-CURLICUE INDEX RING LITTLE ON;So;0;L;;;;;N;;;;;
+1D8BD;SIGNWRITING HAND-HOOK INDEX RING LITTLE OUT;So;0;L;;;;;N;;;;;
+1D8BE;SIGNWRITING HAND-HOOK INDEX RING LITTLE IN;So;0;L;;;;;N;;;;;
+1D8BF;SIGNWRITING HAND-HOOK INDEX RING LITTLE UNDER;So;0;L;;;;;N;;;;;
+1D8C0;SIGNWRITING HAND-CUP INDEX RING LITTLE;So;0;L;;;;;N;;;;;
+1D8C1;SIGNWRITING HAND-HINGE INDEX RING LITTLE;So;0;L;;;;;N;;;;;
+1D8C2;SIGNWRITING HAND-ANGLE INDEX RING LITTLE OUT;So;0;L;;;;;N;;;;;
+1D8C3;SIGNWRITING HAND-ANGLE INDEX RING LITTLE;So;0;L;;;;;N;;;;;
+1D8C4;SIGNWRITING HAND-FIST MIDDLE DOWN;So;0;L;;;;;N;;;;;
+1D8C5;SIGNWRITING HAND-HINGE MIDDLE;So;0;L;;;;;N;;;;;
+1D8C6;SIGNWRITING HAND-FIST MIDDLE UP;So;0;L;;;;;N;;;;;
+1D8C7;SIGNWRITING HAND-CIRCLE MIDDLE UP;So;0;L;;;;;N;;;;;
+1D8C8;SIGNWRITING HAND-FIST MIDDLE RAISED KNUCKLE;So;0;L;;;;;N;;;;;
+1D8C9;SIGNWRITING HAND-FIST MIDDLE UP THUMB SIDE;So;0;L;;;;;N;;;;;
+1D8CA;SIGNWRITING HAND-HOOK MIDDLE THUMB;So;0;L;;;;;N;;;;;
+1D8CB;SIGNWRITING HAND-FIST MIDDLE THUMB LITTLE;So;0;L;;;;;N;;;;;
+1D8CC;SIGNWRITING HAND-FIST MIDDLE LITTLE;So;0;L;;;;;N;;;;;
+1D8CD;SIGNWRITING HAND-FIST MIDDLE RING LITTLE;So;0;L;;;;;N;;;;;
+1D8CE;SIGNWRITING HAND-CIRCLE MIDDLE RING LITTLE;So;0;L;;;;;N;;;;;
+1D8CF;SIGNWRITING HAND-CURLICUE MIDDLE RING LITTLE ON;So;0;L;;;;;N;;;;;
+1D8D0;SIGNWRITING HAND-CUP MIDDLE RING LITTLE;So;0;L;;;;;N;;;;;
+1D8D1;SIGNWRITING HAND-HINGE MIDDLE RING LITTLE;So;0;L;;;;;N;;;;;
+1D8D2;SIGNWRITING HAND-ANGLE MIDDLE RING LITTLE OUT;So;0;L;;;;;N;;;;;
+1D8D3;SIGNWRITING HAND-ANGLE MIDDLE RING LITTLE IN;So;0;L;;;;;N;;;;;
+1D8D4;SIGNWRITING HAND-ANGLE MIDDLE RING LITTLE;So;0;L;;;;;N;;;;;
+1D8D5;SIGNWRITING HAND-CIRCLE MIDDLE RING LITTLE BENT;So;0;L;;;;;N;;;;;
+1D8D6;SIGNWRITING HAND-CLAW MIDDLE RING LITTLE CONJOINED;So;0;L;;;;;N;;;;;
+1D8D7;SIGNWRITING HAND-CLAW MIDDLE RING LITTLE CONJOINED SIDE;So;0;L;;;;;N;;;;;
+1D8D8;SIGNWRITING HAND-HOOK MIDDLE RING LITTLE CONJOINED OUT;So;0;L;;;;;N;;;;;
+1D8D9;SIGNWRITING HAND-HOOK MIDDLE RING LITTLE CONJOINED IN;So;0;L;;;;;N;;;;;
+1D8DA;SIGNWRITING HAND-HOOK MIDDLE RING LITTLE CONJOINED;So;0;L;;;;;N;;;;;
+1D8DB;SIGNWRITING HAND-HINGE INDEX HINGED;So;0;L;;;;;N;;;;;
+1D8DC;SIGNWRITING HAND-FIST INDEX THUMB SIDE;So;0;L;;;;;N;;;;;
+1D8DD;SIGNWRITING HAND-HINGE INDEX THUMB SIDE;So;0;L;;;;;N;;;;;
+1D8DE;SIGNWRITING HAND-FIST INDEX THUMB SIDE THUMB DIAGONAL;So;0;L;;;;;N;;;;;
+1D8DF;SIGNWRITING HAND-FIST INDEX THUMB SIDE THUMB CONJOINED;So;0;L;;;;;N;;;;;
+1D8E0;SIGNWRITING HAND-FIST INDEX THUMB SIDE THUMB BENT;So;0;L;;;;;N;;;;;
+1D8E1;SIGNWRITING HAND-FIST INDEX THUMB SIDE INDEX BENT;So;0;L;;;;;N;;;;;
+1D8E2;SIGNWRITING HAND-FIST INDEX THUMB SIDE BOTH BENT;So;0;L;;;;;N;;;;;
+1D8E3;SIGNWRITING HAND-FIST INDEX THUMB SIDE INDEX HINGE;So;0;L;;;;;N;;;;;
+1D8E4;SIGNWRITING HAND-FIST INDEX THUMB FORWARD INDEX STRAIGHT;So;0;L;;;;;N;;;;;
+1D8E5;SIGNWRITING HAND-FIST INDEX THUMB FORWARD INDEX BENT;So;0;L;;;;;N;;;;;
+1D8E6;SIGNWRITING HAND-FIST INDEX THUMB HOOK;So;0;L;;;;;N;;;;;
+1D8E7;SIGNWRITING HAND-FIST INDEX THUMB CURLICUE;So;0;L;;;;;N;;;;;
+1D8E8;SIGNWRITING HAND-FIST INDEX THUMB CURVE THUMB INSIDE;So;0;L;;;;;N;;;;;
+1D8E9;SIGNWRITING HAND-CLAW INDEX THUMB CURVE THUMB INSIDE;So;0;L;;;;;N;;;;;
+1D8EA;SIGNWRITING HAND-FIST INDEX THUMB CURVE THUMB UNDER;So;0;L;;;;;N;;;;;
+1D8EB;SIGNWRITING HAND-FIST INDEX THUMB CIRCLE;So;0;L;;;;;N;;;;;
+1D8EC;SIGNWRITING HAND-CUP INDEX THUMB;So;0;L;;;;;N;;;;;
+1D8ED;SIGNWRITING HAND-CUP INDEX THUMB OPEN;So;0;L;;;;;N;;;;;
+1D8EE;SIGNWRITING HAND-HINGE INDEX THUMB OPEN;So;0;L;;;;;N;;;;;
+1D8EF;SIGNWRITING HAND-HINGE INDEX THUMB LARGE;So;0;L;;;;;N;;;;;
+1D8F0;SIGNWRITING HAND-HINGE INDEX THUMB;So;0;L;;;;;N;;;;;
+1D8F1;SIGNWRITING HAND-HINGE INDEX THUMB SMALL;So;0;L;;;;;N;;;;;
+1D8F2;SIGNWRITING HAND-ANGLE INDEX THUMB OUT;So;0;L;;;;;N;;;;;
+1D8F3;SIGNWRITING HAND-ANGLE INDEX THUMB IN;So;0;L;;;;;N;;;;;
+1D8F4;SIGNWRITING HAND-ANGLE INDEX THUMB;So;0;L;;;;;N;;;;;
+1D8F5;SIGNWRITING HAND-FIST THUMB;So;0;L;;;;;N;;;;;
+1D8F6;SIGNWRITING HAND-FIST THUMB HEEL;So;0;L;;;;;N;;;;;
+1D8F7;SIGNWRITING HAND-FIST THUMB SIDE DIAGONAL;So;0;L;;;;;N;;;;;
+1D8F8;SIGNWRITING HAND-FIST THUMB SIDE CONJOINED;So;0;L;;;;;N;;;;;
+1D8F9;SIGNWRITING HAND-FIST THUMB SIDE BENT;So;0;L;;;;;N;;;;;
+1D8FA;SIGNWRITING HAND-FIST THUMB FORWARD;So;0;L;;;;;N;;;;;
+1D8FB;SIGNWRITING HAND-FIST THUMB BETWEEN INDEX MIDDLE;So;0;L;;;;;N;;;;;
+1D8FC;SIGNWRITING HAND-FIST THUMB BETWEEN MIDDLE RING;So;0;L;;;;;N;;;;;
+1D8FD;SIGNWRITING HAND-FIST THUMB BETWEEN RING LITTLE;So;0;L;;;;;N;;;;;
+1D8FE;SIGNWRITING HAND-FIST THUMB UNDER TWO FINGERS;So;0;L;;;;;N;;;;;
+1D8FF;SIGNWRITING HAND-FIST THUMB OVER TWO FINGERS;So;0;L;;;;;N;;;;;
+1D900;SIGNWRITING HAND-FIST THUMB UNDER THREE FINGERS;So;0;L;;;;;N;;;;;
+1D901;SIGNWRITING HAND-FIST THUMB UNDER FOUR FINGERS;So;0;L;;;;;N;;;;;
+1D902;SIGNWRITING HAND-FIST THUMB OVER FOUR RAISED KNUCKLES;So;0;L;;;;;N;;;;;
+1D903;SIGNWRITING HAND-FIST;So;0;L;;;;;N;;;;;
+1D904;SIGNWRITING HAND-FIST HEEL;So;0;L;;;;;N;;;;;
+1D905;SIGNWRITING TOUCH SINGLE;So;0;L;;;;;N;;;;;
+1D906;SIGNWRITING TOUCH MULTIPLE;So;0;L;;;;;N;;;;;
+1D907;SIGNWRITING TOUCH BETWEEN;So;0;L;;;;;N;;;;;
+1D908;SIGNWRITING GRASP SINGLE;So;0;L;;;;;N;;;;;
+1D909;SIGNWRITING GRASP MULTIPLE;So;0;L;;;;;N;;;;;
+1D90A;SIGNWRITING GRASP BETWEEN;So;0;L;;;;;N;;;;;
+1D90B;SIGNWRITING STRIKE SINGLE;So;0;L;;;;;N;;;;;
+1D90C;SIGNWRITING STRIKE MULTIPLE;So;0;L;;;;;N;;;;;
+1D90D;SIGNWRITING STRIKE BETWEEN;So;0;L;;;;;N;;;;;
+1D90E;SIGNWRITING BRUSH SINGLE;So;0;L;;;;;N;;;;;
+1D90F;SIGNWRITING BRUSH MULTIPLE;So;0;L;;;;;N;;;;;
+1D910;SIGNWRITING BRUSH BETWEEN;So;0;L;;;;;N;;;;;
+1D911;SIGNWRITING RUB SINGLE;So;0;L;;;;;N;;;;;
+1D912;SIGNWRITING RUB MULTIPLE;So;0;L;;;;;N;;;;;
+1D913;SIGNWRITING RUB BETWEEN;So;0;L;;;;;N;;;;;
+1D914;SIGNWRITING SURFACE SYMBOLS;So;0;L;;;;;N;;;;;
+1D915;SIGNWRITING SURFACE BETWEEN;So;0;L;;;;;N;;;;;
+1D916;SIGNWRITING SQUEEZE LARGE SINGLE;So;0;L;;;;;N;;;;;
+1D917;SIGNWRITING SQUEEZE SMALL SINGLE;So;0;L;;;;;N;;;;;
+1D918;SIGNWRITING SQUEEZE LARGE MULTIPLE;So;0;L;;;;;N;;;;;
+1D919;SIGNWRITING SQUEEZE SMALL MULTIPLE;So;0;L;;;;;N;;;;;
+1D91A;SIGNWRITING SQUEEZE SEQUENTIAL;So;0;L;;;;;N;;;;;
+1D91B;SIGNWRITING FLICK LARGE SINGLE;So;0;L;;;;;N;;;;;
+1D91C;SIGNWRITING FLICK SMALL SINGLE;So;0;L;;;;;N;;;;;
+1D91D;SIGNWRITING FLICK LARGE MULTIPLE;So;0;L;;;;;N;;;;;
+1D91E;SIGNWRITING FLICK SMALL MULTIPLE;So;0;L;;;;;N;;;;;
+1D91F;SIGNWRITING FLICK SEQUENTIAL;So;0;L;;;;;N;;;;;
+1D920;SIGNWRITING SQUEEZE FLICK ALTERNATING;So;0;L;;;;;N;;;;;
+1D921;SIGNWRITING MOVEMENT-HINGE UP DOWN LARGE;So;0;L;;;;;N;;;;;
+1D922;SIGNWRITING MOVEMENT-HINGE UP DOWN SMALL;So;0;L;;;;;N;;;;;
+1D923;SIGNWRITING MOVEMENT-HINGE UP SEQUENTIAL;So;0;L;;;;;N;;;;;
+1D924;SIGNWRITING MOVEMENT-HINGE DOWN SEQUENTIAL;So;0;L;;;;;N;;;;;
+1D925;SIGNWRITING MOVEMENT-HINGE UP DOWN ALTERNATING LARGE;So;0;L;;;;;N;;;;;
+1D926;SIGNWRITING MOVEMENT-HINGE UP DOWN ALTERNATING SMALL;So;0;L;;;;;N;;;;;
+1D927;SIGNWRITING MOVEMENT-HINGE SIDE TO SIDE SCISSORS;So;0;L;;;;;N;;;;;
+1D928;SIGNWRITING MOVEMENT-WALLPLANE FINGER CONTACT;So;0;L;;;;;N;;;;;
+1D929;SIGNWRITING MOVEMENT-FLOORPLANE FINGER CONTACT;So;0;L;;;;;N;;;;;
+1D92A;SIGNWRITING MOVEMENT-WALLPLANE SINGLE STRAIGHT SMALL;So;0;L;;;;;N;;;;;
+1D92B;SIGNWRITING MOVEMENT-WALLPLANE SINGLE STRAIGHT MEDIUM;So;0;L;;;;;N;;;;;
+1D92C;SIGNWRITING MOVEMENT-WALLPLANE SINGLE STRAIGHT LARGE;So;0;L;;;;;N;;;;;
+1D92D;SIGNWRITING MOVEMENT-WALLPLANE SINGLE STRAIGHT LARGEST;So;0;L;;;;;N;;;;;
+1D92E;SIGNWRITING MOVEMENT-WALLPLANE SINGLE WRIST FLEX;So;0;L;;;;;N;;;;;
+1D92F;SIGNWRITING MOVEMENT-WALLPLANE DOUBLE STRAIGHT;So;0;L;;;;;N;;;;;
+1D930;SIGNWRITING MOVEMENT-WALLPLANE DOUBLE WRIST FLEX;So;0;L;;;;;N;;;;;
+1D931;SIGNWRITING MOVEMENT-WALLPLANE DOUBLE ALTERNATING;So;0;L;;;;;N;;;;;
+1D932;SIGNWRITING MOVEMENT-WALLPLANE DOUBLE ALTERNATING WRIST FLEX;So;0;L;;;;;N;;;;;
+1D933;SIGNWRITING MOVEMENT-WALLPLANE CROSS;So;0;L;;;;;N;;;;;
+1D934;SIGNWRITING MOVEMENT-WALLPLANE TRIPLE STRAIGHT MOVEMENT;So;0;L;;;;;N;;;;;
+1D935;SIGNWRITING MOVEMENT-WALLPLANE TRIPLE WRIST FLEX;So;0;L;;;;;N;;;;;
+1D936;SIGNWRITING MOVEMENT-WALLPLANE TRIPLE ALTERNATING;So;0;L;;;;;N;;;;;
+1D937;SIGNWRITING MOVEMENT-WALLPLANE TRIPLE ALTERNATING WRIST FLEX;So;0;L;;;;;N;;;;;
+1D938;SIGNWRITING MOVEMENT-WALLPLANE BEND SMALL;So;0;L;;;;;N;;;;;
+1D939;SIGNWRITING MOVEMENT-WALLPLANE BEND MEDIUM;So;0;L;;;;;N;;;;;
+1D93A;SIGNWRITING MOVEMENT-WALLPLANE BEND LARGE;So;0;L;;;;;N;;;;;
+1D93B;SIGNWRITING MOVEMENT-WALLPLANE CORNER SMALL;So;0;L;;;;;N;;;;;
+1D93C;SIGNWRITING MOVEMENT-WALLPLANE CORNER MEDIUM;So;0;L;;;;;N;;;;;
+1D93D;SIGNWRITING MOVEMENT-WALLPLANE CORNER LARGE;So;0;L;;;;;N;;;;;
+1D93E;SIGNWRITING MOVEMENT-WALLPLANE CORNER ROTATION;So;0;L;;;;;N;;;;;
+1D93F;SIGNWRITING MOVEMENT-WALLPLANE CHECK SMALL;So;0;L;;;;;N;;;;;
+1D940;SIGNWRITING MOVEMENT-WALLPLANE CHECK MEDIUM;So;0;L;;;;;N;;;;;
+1D941;SIGNWRITING MOVEMENT-WALLPLANE CHECK LARGE;So;0;L;;;;;N;;;;;
+1D942;SIGNWRITING MOVEMENT-WALLPLANE BOX SMALL;So;0;L;;;;;N;;;;;
+1D943;SIGNWRITING MOVEMENT-WALLPLANE BOX MEDIUM;So;0;L;;;;;N;;;;;
+1D944;SIGNWRITING MOVEMENT-WALLPLANE BOX LARGE;So;0;L;;;;;N;;;;;
+1D945;SIGNWRITING MOVEMENT-WALLPLANE ZIGZAG SMALL;So;0;L;;;;;N;;;;;
+1D946;SIGNWRITING MOVEMENT-WALLPLANE ZIGZAG MEDIUM;So;0;L;;;;;N;;;;;
+1D947;SIGNWRITING MOVEMENT-WALLPLANE ZIGZAG LARGE;So;0;L;;;;;N;;;;;
+1D948;SIGNWRITING MOVEMENT-WALLPLANE PEAKS SMALL;So;0;L;;;;;N;;;;;
+1D949;SIGNWRITING MOVEMENT-WALLPLANE PEAKS MEDIUM;So;0;L;;;;;N;;;;;
+1D94A;SIGNWRITING MOVEMENT-WALLPLANE PEAKS LARGE;So;0;L;;;;;N;;;;;
+1D94B;SIGNWRITING TRAVEL-WALLPLANE ROTATION-WALLPLANE SINGLE;So;0;L;;;;;N;;;;;
+1D94C;SIGNWRITING TRAVEL-WALLPLANE ROTATION-WALLPLANE DOUBLE;So;0;L;;;;;N;;;;;
+1D94D;SIGNWRITING TRAVEL-WALLPLANE ROTATION-WALLPLANE ALTERNATING;So;0;L;;;;;N;;;;;
+1D94E;SIGNWRITING TRAVEL-WALLPLANE ROTATION-FLOORPLANE SINGLE;So;0;L;;;;;N;;;;;
+1D94F;SIGNWRITING TRAVEL-WALLPLANE ROTATION-FLOORPLANE DOUBLE;So;0;L;;;;;N;;;;;
+1D950;SIGNWRITING TRAVEL-WALLPLANE ROTATION-FLOORPLANE ALTERNATING;So;0;L;;;;;N;;;;;
+1D951;SIGNWRITING TRAVEL-WALLPLANE SHAKING;So;0;L;;;;;N;;;;;
+1D952;SIGNWRITING TRAVEL-WALLPLANE ARM SPIRAL SINGLE;So;0;L;;;;;N;;;;;
+1D953;SIGNWRITING TRAVEL-WALLPLANE ARM SPIRAL DOUBLE;So;0;L;;;;;N;;;;;
+1D954;SIGNWRITING TRAVEL-WALLPLANE ARM SPIRAL TRIPLE;So;0;L;;;;;N;;;;;
+1D955;SIGNWRITING MOVEMENT-DIAGONAL AWAY SMALL;So;0;L;;;;;N;;;;;
+1D956;SIGNWRITING MOVEMENT-DIAGONAL AWAY MEDIUM;So;0;L;;;;;N;;;;;
+1D957;SIGNWRITING MOVEMENT-DIAGONAL AWAY LARGE;So;0;L;;;;;N;;;;;
+1D958;SIGNWRITING MOVEMENT-DIAGONAL AWAY LARGEST;So;0;L;;;;;N;;;;;
+1D959;SIGNWRITING MOVEMENT-DIAGONAL TOWARDS SMALL;So;0;L;;;;;N;;;;;
+1D95A;SIGNWRITING MOVEMENT-DIAGONAL TOWARDS MEDIUM;So;0;L;;;;;N;;;;;
+1D95B;SIGNWRITING MOVEMENT-DIAGONAL TOWARDS LARGE;So;0;L;;;;;N;;;;;
+1D95C;SIGNWRITING MOVEMENT-DIAGONAL TOWARDS LARGEST;So;0;L;;;;;N;;;;;
+1D95D;SIGNWRITING MOVEMENT-DIAGONAL BETWEEN AWAY SMALL;So;0;L;;;;;N;;;;;
+1D95E;SIGNWRITING MOVEMENT-DIAGONAL BETWEEN AWAY MEDIUM;So;0;L;;;;;N;;;;;
+1D95F;SIGNWRITING MOVEMENT-DIAGONAL BETWEEN AWAY LARGE;So;0;L;;;;;N;;;;;
+1D960;SIGNWRITING MOVEMENT-DIAGONAL BETWEEN AWAY LARGEST;So;0;L;;;;;N;;;;;
+1D961;SIGNWRITING MOVEMENT-DIAGONAL BETWEEN TOWARDS SMALL;So;0;L;;;;;N;;;;;
+1D962;SIGNWRITING MOVEMENT-DIAGONAL BETWEEN TOWARDS MEDIUM;So;0;L;;;;;N;;;;;
+1D963;SIGNWRITING MOVEMENT-DIAGONAL BETWEEN TOWARDS LARGE;So;0;L;;;;;N;;;;;
+1D964;SIGNWRITING MOVEMENT-DIAGONAL BETWEEN TOWARDS LARGEST;So;0;L;;;;;N;;;;;
+1D965;SIGNWRITING MOVEMENT-FLOORPLANE SINGLE STRAIGHT SMALL;So;0;L;;;;;N;;;;;
+1D966;SIGNWRITING MOVEMENT-FLOORPLANE SINGLE STRAIGHT MEDIUM;So;0;L;;;;;N;;;;;
+1D967;SIGNWRITING MOVEMENT-FLOORPLANE SINGLE STRAIGHT LARGE;So;0;L;;;;;N;;;;;
+1D968;SIGNWRITING MOVEMENT-FLOORPLANE SINGLE STRAIGHT LARGEST;So;0;L;;;;;N;;;;;
+1D969;SIGNWRITING MOVEMENT-FLOORPLANE SINGLE WRIST FLEX;So;0;L;;;;;N;;;;;
+1D96A;SIGNWRITING MOVEMENT-FLOORPLANE DOUBLE STRAIGHT;So;0;L;;;;;N;;;;;
+1D96B;SIGNWRITING MOVEMENT-FLOORPLANE DOUBLE WRIST FLEX;So;0;L;;;;;N;;;;;
+1D96C;SIGNWRITING MOVEMENT-FLOORPLANE DOUBLE ALTERNATING;So;0;L;;;;;N;;;;;
+1D96D;SIGNWRITING MOVEMENT-FLOORPLANE DOUBLE ALTERNATING WRIST FLEX;So;0;L;;;;;N;;;;;
+1D96E;SIGNWRITING MOVEMENT-FLOORPLANE CROSS;So;0;L;;;;;N;;;;;
+1D96F;SIGNWRITING MOVEMENT-FLOORPLANE TRIPLE STRAIGHT MOVEMENT;So;0;L;;;;;N;;;;;
+1D970;SIGNWRITING MOVEMENT-FLOORPLANE TRIPLE WRIST FLEX;So;0;L;;;;;N;;;;;
+1D971;SIGNWRITING MOVEMENT-FLOORPLANE TRIPLE ALTERNATING MOVEMENT;So;0;L;;;;;N;;;;;
+1D972;SIGNWRITING MOVEMENT-FLOORPLANE TRIPLE ALTERNATING WRIST FLEX;So;0;L;;;;;N;;;;;
+1D973;SIGNWRITING MOVEMENT-FLOORPLANE BEND;So;0;L;;;;;N;;;;;
+1D974;SIGNWRITING MOVEMENT-FLOORPLANE CORNER SMALL;So;0;L;;;;;N;;;;;
+1D975;SIGNWRITING MOVEMENT-FLOORPLANE CORNER MEDIUM;So;0;L;;;;;N;;;;;
+1D976;SIGNWRITING MOVEMENT-FLOORPLANE CORNER LARGE;So;0;L;;;;;N;;;;;
+1D977;SIGNWRITING MOVEMENT-FLOORPLANE CHECK;So;0;L;;;;;N;;;;;
+1D978;SIGNWRITING MOVEMENT-FLOORPLANE BOX SMALL;So;0;L;;;;;N;;;;;
+1D979;SIGNWRITING MOVEMENT-FLOORPLANE BOX MEDIUM;So;0;L;;;;;N;;;;;
+1D97A;SIGNWRITING MOVEMENT-FLOORPLANE BOX LARGE;So;0;L;;;;;N;;;;;
+1D97B;SIGNWRITING MOVEMENT-FLOORPLANE ZIGZAG SMALL;So;0;L;;;;;N;;;;;
+1D97C;SIGNWRITING MOVEMENT-FLOORPLANE ZIGZAG MEDIUM;So;0;L;;;;;N;;;;;
+1D97D;SIGNWRITING MOVEMENT-FLOORPLANE ZIGZAG LARGE;So;0;L;;;;;N;;;;;
+1D97E;SIGNWRITING MOVEMENT-FLOORPLANE PEAKS SMALL;So;0;L;;;;;N;;;;;
+1D97F;SIGNWRITING MOVEMENT-FLOORPLANE PEAKS MEDIUM;So;0;L;;;;;N;;;;;
+1D980;SIGNWRITING MOVEMENT-FLOORPLANE PEAKS LARGE;So;0;L;;;;;N;;;;;
+1D981;SIGNWRITING TRAVEL-FLOORPLANE ROTATION-FLOORPLANE SINGLE;So;0;L;;;;;N;;;;;
+1D982;SIGNWRITING TRAVEL-FLOORPLANE ROTATION-FLOORPLANE DOUBLE;So;0;L;;;;;N;;;;;
+1D983;SIGNWRITING TRAVEL-FLOORPLANE ROTATION-FLOORPLANE ALTERNATING;So;0;L;;;;;N;;;;;
+1D984;SIGNWRITING TRAVEL-FLOORPLANE ROTATION-WALLPLANE SINGLE;So;0;L;;;;;N;;;;;
+1D985;SIGNWRITING TRAVEL-FLOORPLANE ROTATION-WALLPLANE DOUBLE;So;0;L;;;;;N;;;;;
+1D986;SIGNWRITING TRAVEL-FLOORPLANE ROTATION-WALLPLANE ALTERNATING;So;0;L;;;;;N;;;;;
+1D987;SIGNWRITING TRAVEL-FLOORPLANE SHAKING;So;0;L;;;;;N;;;;;
+1D988;SIGNWRITING MOVEMENT-WALLPLANE CURVE QUARTER SMALL;So;0;L;;;;;N;;;;;
+1D989;SIGNWRITING MOVEMENT-WALLPLANE CURVE QUARTER MEDIUM;So;0;L;;;;;N;;;;;
+1D98A;SIGNWRITING MOVEMENT-WALLPLANE CURVE QUARTER LARGE;So;0;L;;;;;N;;;;;
+1D98B;SIGNWRITING MOVEMENT-WALLPLANE CURVE QUARTER LARGEST;So;0;L;;;;;N;;;;;
+1D98C;SIGNWRITING MOVEMENT-WALLPLANE CURVE HALF-CIRCLE SMALL;So;0;L;;;;;N;;;;;
+1D98D;SIGNWRITING MOVEMENT-WALLPLANE CURVE HALF-CIRCLE MEDIUM;So;0;L;;;;;N;;;;;
+1D98E;SIGNWRITING MOVEMENT-WALLPLANE CURVE HALF-CIRCLE LARGE;So;0;L;;;;;N;;;;;
+1D98F;SIGNWRITING MOVEMENT-WALLPLANE CURVE HALF-CIRCLE LARGEST;So;0;L;;;;;N;;;;;
+1D990;SIGNWRITING MOVEMENT-WALLPLANE CURVE THREE-QUARTER CIRCLE SMALL;So;0;L;;;;;N;;;;;
+1D991;SIGNWRITING MOVEMENT-WALLPLANE CURVE THREE-QUARTER CIRCLE MEDIUM;So;0;L;;;;;N;;;;;
+1D992;SIGNWRITING MOVEMENT-WALLPLANE HUMP SMALL;So;0;L;;;;;N;;;;;
+1D993;SIGNWRITING MOVEMENT-WALLPLANE HUMP MEDIUM;So;0;L;;;;;N;;;;;
+1D994;SIGNWRITING MOVEMENT-WALLPLANE HUMP LARGE;So;0;L;;;;;N;;;;;
+1D995;SIGNWRITING MOVEMENT-WALLPLANE LOOP SMALL;So;0;L;;;;;N;;;;;
+1D996;SIGNWRITING MOVEMENT-WALLPLANE LOOP MEDIUM;So;0;L;;;;;N;;;;;
+1D997;SIGNWRITING MOVEMENT-WALLPLANE LOOP LARGE;So;0;L;;;;;N;;;;;
+1D998;SIGNWRITING MOVEMENT-WALLPLANE LOOP SMALL DOUBLE;So;0;L;;;;;N;;;;;
+1D999;SIGNWRITING MOVEMENT-WALLPLANE WAVE CURVE DOUBLE SMALL;So;0;L;;;;;N;;;;;
+1D99A;SIGNWRITING MOVEMENT-WALLPLANE WAVE CURVE DOUBLE MEDIUM;So;0;L;;;;;N;;;;;
+1D99B;SIGNWRITING MOVEMENT-WALLPLANE WAVE CURVE DOUBLE LARGE;So;0;L;;;;;N;;;;;
+1D99C;SIGNWRITING MOVEMENT-WALLPLANE WAVE CURVE TRIPLE SMALL;So;0;L;;;;;N;;;;;
+1D99D;SIGNWRITING MOVEMENT-WALLPLANE WAVE CURVE TRIPLE MEDIUM;So;0;L;;;;;N;;;;;
+1D99E;SIGNWRITING MOVEMENT-WALLPLANE WAVE CURVE TRIPLE LARGE;So;0;L;;;;;N;;;;;
+1D99F;SIGNWRITING MOVEMENT-WALLPLANE CURVE THEN STRAIGHT;So;0;L;;;;;N;;;;;
+1D9A0;SIGNWRITING MOVEMENT-WALLPLANE CURVED CROSS SMALL;So;0;L;;;;;N;;;;;
+1D9A1;SIGNWRITING MOVEMENT-WALLPLANE CURVED CROSS MEDIUM;So;0;L;;;;;N;;;;;
+1D9A2;SIGNWRITING ROTATION-WALLPLANE SINGLE;So;0;L;;;;;N;;;;;
+1D9A3;SIGNWRITING ROTATION-WALLPLANE DOUBLE;So;0;L;;;;;N;;;;;
+1D9A4;SIGNWRITING ROTATION-WALLPLANE ALTERNATE;So;0;L;;;;;N;;;;;
+1D9A5;SIGNWRITING MOVEMENT-WALLPLANE SHAKING;So;0;L;;;;;N;;;;;
+1D9A6;SIGNWRITING MOVEMENT-WALLPLANE CURVE HITTING FRONT WALL;So;0;L;;;;;N;;;;;
+1D9A7;SIGNWRITING MOVEMENT-WALLPLANE HUMP HITTING FRONT WALL;So;0;L;;;;;N;;;;;
+1D9A8;SIGNWRITING MOVEMENT-WALLPLANE LOOP HITTING FRONT WALL;So;0;L;;;;;N;;;;;
+1D9A9;SIGNWRITING MOVEMENT-WALLPLANE WAVE HITTING FRONT WALL;So;0;L;;;;;N;;;;;
+1D9AA;SIGNWRITING ROTATION-WALLPLANE SINGLE HITTING FRONT WALL;So;0;L;;;;;N;;;;;
+1D9AB;SIGNWRITING ROTATION-WALLPLANE DOUBLE HITTING FRONT WALL;So;0;L;;;;;N;;;;;
+1D9AC;SIGNWRITING ROTATION-WALLPLANE ALTERNATING HITTING FRONT WALL;So;0;L;;;;;N;;;;;
+1D9AD;SIGNWRITING MOVEMENT-WALLPLANE CURVE HITTING CHEST;So;0;L;;;;;N;;;;;
+1D9AE;SIGNWRITING MOVEMENT-WALLPLANE HUMP HITTING CHEST;So;0;L;;;;;N;;;;;
+1D9AF;SIGNWRITING MOVEMENT-WALLPLANE LOOP HITTING CHEST;So;0;L;;;;;N;;;;;
+1D9B0;SIGNWRITING MOVEMENT-WALLPLANE WAVE HITTING CHEST;So;0;L;;;;;N;;;;;
+1D9B1;SIGNWRITING ROTATION-WALLPLANE SINGLE HITTING CHEST;So;0;L;;;;;N;;;;;
+1D9B2;SIGNWRITING ROTATION-WALLPLANE DOUBLE HITTING CHEST;So;0;L;;;;;N;;;;;
+1D9B3;SIGNWRITING ROTATION-WALLPLANE ALTERNATING HITTING CHEST;So;0;L;;;;;N;;;;;
+1D9B4;SIGNWRITING MOVEMENT-WALLPLANE WAVE DIAGONAL PATH SMALL;So;0;L;;;;;N;;;;;
+1D9B5;SIGNWRITING MOVEMENT-WALLPLANE WAVE DIAGONAL PATH MEDIUM;So;0;L;;;;;N;;;;;
+1D9B6;SIGNWRITING MOVEMENT-WALLPLANE WAVE DIAGONAL PATH LARGE;So;0;L;;;;;N;;;;;
+1D9B7;SIGNWRITING MOVEMENT-FLOORPLANE CURVE HITTING CEILING SMALL;So;0;L;;;;;N;;;;;
+1D9B8;SIGNWRITING MOVEMENT-FLOORPLANE CURVE HITTING CEILING LARGE;So;0;L;;;;;N;;;;;
+1D9B9;SIGNWRITING MOVEMENT-FLOORPLANE HUMP HITTING CEILING SMALL DOUBLE;So;0;L;;;;;N;;;;;
+1D9BA;SIGNWRITING MOVEMENT-FLOORPLANE HUMP HITTING CEILING LARGE DOUBLE;So;0;L;;;;;N;;;;;
+1D9BB;SIGNWRITING MOVEMENT-FLOORPLANE HUMP HITTING CEILING SMALL TRIPLE;So;0;L;;;;;N;;;;;
+1D9BC;SIGNWRITING MOVEMENT-FLOORPLANE HUMP HITTING CEILING LARGE TRIPLE;So;0;L;;;;;N;;;;;
+1D9BD;SIGNWRITING MOVEMENT-FLOORPLANE LOOP HITTING CEILING SMALL SINGLE;So;0;L;;;;;N;;;;;
+1D9BE;SIGNWRITING MOVEMENT-FLOORPLANE LOOP HITTING CEILING LARGE SINGLE;So;0;L;;;;;N;;;;;
+1D9BF;SIGNWRITING MOVEMENT-FLOORPLANE LOOP HITTING CEILING SMALL DOUBLE;So;0;L;;;;;N;;;;;
+1D9C0;SIGNWRITING MOVEMENT-FLOORPLANE LOOP HITTING CEILING LARGE DOUBLE;So;0;L;;;;;N;;;;;
+1D9C1;SIGNWRITING MOVEMENT-FLOORPLANE WAVE HITTING CEILING SMALL;So;0;L;;;;;N;;;;;
+1D9C2;SIGNWRITING MOVEMENT-FLOORPLANE WAVE HITTING CEILING LARGE;So;0;L;;;;;N;;;;;
+1D9C3;SIGNWRITING ROTATION-FLOORPLANE SINGLE HITTING CEILING;So;0;L;;;;;N;;;;;
+1D9C4;SIGNWRITING ROTATION-FLOORPLANE DOUBLE HITTING CEILING;So;0;L;;;;;N;;;;;
+1D9C5;SIGNWRITING ROTATION-FLOORPLANE ALTERNATING HITTING CEILING;So;0;L;;;;;N;;;;;
+1D9C6;SIGNWRITING MOVEMENT-FLOORPLANE CURVE HITTING FLOOR SMALL;So;0;L;;;;;N;;;;;
+1D9C7;SIGNWRITING MOVEMENT-FLOORPLANE CURVE HITTING FLOOR LARGE;So;0;L;;;;;N;;;;;
+1D9C8;SIGNWRITING MOVEMENT-FLOORPLANE HUMP HITTING FLOOR SMALL DOUBLE;So;0;L;;;;;N;;;;;
+1D9C9;SIGNWRITING MOVEMENT-FLOORPLANE HUMP HITTING FLOOR LARGE DOUBLE;So;0;L;;;;;N;;;;;
+1D9CA;SIGNWRITING MOVEMENT-FLOORPLANE HUMP HITTING FLOOR TRIPLE SMALL TRIPLE;So;0;L;;;;;N;;;;;
+1D9CB;SIGNWRITING MOVEMENT-FLOORPLANE HUMP HITTING FLOOR TRIPLE LARGE TRIPLE;So;0;L;;;;;N;;;;;
+1D9CC;SIGNWRITING MOVEMENT-FLOORPLANE LOOP HITTING FLOOR SMALL SINGLE;So;0;L;;;;;N;;;;;
+1D9CD;SIGNWRITING MOVEMENT-FLOORPLANE LOOP HITTING FLOOR LARGE SINGLE;So;0;L;;;;;N;;;;;
+1D9CE;SIGNWRITING MOVEMENT-FLOORPLANE LOOP HITTING FLOOR SMALL DOUBLE;So;0;L;;;;;N;;;;;
+1D9CF;SIGNWRITING MOVEMENT-FLOORPLANE LOOP HITTING FLOOR LARGE DOUBLE;So;0;L;;;;;N;;;;;
+1D9D0;SIGNWRITING MOVEMENT-FLOORPLANE WAVE HITTING FLOOR SMALL;So;0;L;;;;;N;;;;;
+1D9D1;SIGNWRITING MOVEMENT-FLOORPLANE WAVE HITTING FLOOR LARGE;So;0;L;;;;;N;;;;;
+1D9D2;SIGNWRITING ROTATION-FLOORPLANE SINGLE HITTING FLOOR;So;0;L;;;;;N;;;;;
+1D9D3;SIGNWRITING ROTATION-FLOORPLANE DOUBLE HITTING FLOOR;So;0;L;;;;;N;;;;;
+1D9D4;SIGNWRITING ROTATION-FLOORPLANE ALTERNATING HITTING FLOOR;So;0;L;;;;;N;;;;;
+1D9D5;SIGNWRITING MOVEMENT-FLOORPLANE CURVE SMALL;So;0;L;;;;;N;;;;;
+1D9D6;SIGNWRITING MOVEMENT-FLOORPLANE CURVE MEDIUM;So;0;L;;;;;N;;;;;
+1D9D7;SIGNWRITING MOVEMENT-FLOORPLANE CURVE LARGE;So;0;L;;;;;N;;;;;
+1D9D8;SIGNWRITING MOVEMENT-FLOORPLANE CURVE LARGEST;So;0;L;;;;;N;;;;;
+1D9D9;SIGNWRITING MOVEMENT-FLOORPLANE CURVE COMBINED;So;0;L;;;;;N;;;;;
+1D9DA;SIGNWRITING MOVEMENT-FLOORPLANE HUMP SMALL;So;0;L;;;;;N;;;;;
+1D9DB;SIGNWRITING MOVEMENT-FLOORPLANE LOOP SMALL;So;0;L;;;;;N;;;;;
+1D9DC;SIGNWRITING MOVEMENT-FLOORPLANE WAVE SNAKE;So;0;L;;;;;N;;;;;
+1D9DD;SIGNWRITING MOVEMENT-FLOORPLANE WAVE SMALL;So;0;L;;;;;N;;;;;
+1D9DE;SIGNWRITING MOVEMENT-FLOORPLANE WAVE LARGE;So;0;L;;;;;N;;;;;
+1D9DF;SIGNWRITING ROTATION-FLOORPLANE SINGLE;So;0;L;;;;;N;;;;;
+1D9E0;SIGNWRITING ROTATION-FLOORPLANE DOUBLE;So;0;L;;;;;N;;;;;
+1D9E1;SIGNWRITING ROTATION-FLOORPLANE ALTERNATING;So;0;L;;;;;N;;;;;
+1D9E2;SIGNWRITING MOVEMENT-FLOORPLANE SHAKING PARALLEL;So;0;L;;;;;N;;;;;
+1D9E3;SIGNWRITING MOVEMENT-WALLPLANE ARM CIRCLE SMALL SINGLE;So;0;L;;;;;N;;;;;
+1D9E4;SIGNWRITING MOVEMENT-WALLPLANE ARM CIRCLE MEDIUM SINGLE;So;0;L;;;;;N;;;;;
+1D9E5;SIGNWRITING MOVEMENT-WALLPLANE ARM CIRCLE SMALL DOUBLE;So;0;L;;;;;N;;;;;
+1D9E6;SIGNWRITING MOVEMENT-WALLPLANE ARM CIRCLE MEDIUM DOUBLE;So;0;L;;;;;N;;;;;
+1D9E7;SIGNWRITING MOVEMENT-FLOORPLANE ARM CIRCLE HITTING WALL SMALL SINGLE;So;0;L;;;;;N;;;;;
+1D9E8;SIGNWRITING MOVEMENT-FLOORPLANE ARM CIRCLE HITTING WALL MEDIUM SINGLE;So;0;L;;;;;N;;;;;
+1D9E9;SIGNWRITING MOVEMENT-FLOORPLANE ARM CIRCLE HITTING WALL LARGE SINGLE;So;0;L;;;;;N;;;;;
+1D9EA;SIGNWRITING MOVEMENT-FLOORPLANE ARM CIRCLE HITTING WALL SMALL DOUBLE;So;0;L;;;;;N;;;;;
+1D9EB;SIGNWRITING MOVEMENT-FLOORPLANE ARM CIRCLE HITTING WALL MEDIUM DOUBLE;So;0;L;;;;;N;;;;;
+1D9EC;SIGNWRITING MOVEMENT-FLOORPLANE ARM CIRCLE HITTING WALL LARGE DOUBLE;So;0;L;;;;;N;;;;;
+1D9ED;SIGNWRITING MOVEMENT-WALLPLANE WRIST CIRCLE FRONT SINGLE;So;0;L;;;;;N;;;;;
+1D9EE;SIGNWRITING MOVEMENT-WALLPLANE WRIST CIRCLE FRONT DOUBLE;So;0;L;;;;;N;;;;;
+1D9EF;SIGNWRITING MOVEMENT-FLOORPLANE WRIST CIRCLE HITTING WALL SINGLE;So;0;L;;;;;N;;;;;
+1D9F0;SIGNWRITING MOVEMENT-FLOORPLANE WRIST CIRCLE HITTING WALL DOUBLE;So;0;L;;;;;N;;;;;
+1D9F1;SIGNWRITING MOVEMENT-WALLPLANE FINGER CIRCLES SINGLE;So;0;L;;;;;N;;;;;
+1D9F2;SIGNWRITING MOVEMENT-WALLPLANE FINGER CIRCLES DOUBLE;So;0;L;;;;;N;;;;;
+1D9F3;SIGNWRITING MOVEMENT-FLOORPLANE FINGER CIRCLES HITTING WALL SINGLE;So;0;L;;;;;N;;;;;
+1D9F4;SIGNWRITING MOVEMENT-FLOORPLANE FINGER CIRCLES HITTING WALL DOUBLE;So;0;L;;;;;N;;;;;
+1D9F5;SIGNWRITING DYNAMIC ARROWHEAD SMALL;So;0;L;;;;;N;;;;;
+1D9F6;SIGNWRITING DYNAMIC ARROWHEAD LARGE;So;0;L;;;;;N;;;;;
+1D9F7;SIGNWRITING DYNAMIC FAST;So;0;L;;;;;N;;;;;
+1D9F8;SIGNWRITING DYNAMIC SLOW;So;0;L;;;;;N;;;;;
+1D9F9;SIGNWRITING DYNAMIC TENSE;So;0;L;;;;;N;;;;;
+1D9FA;SIGNWRITING DYNAMIC RELAXED;So;0;L;;;;;N;;;;;
+1D9FB;SIGNWRITING DYNAMIC SIMULTANEOUS;So;0;L;;;;;N;;;;;
+1D9FC;SIGNWRITING DYNAMIC SIMULTANEOUS ALTERNATING;So;0;L;;;;;N;;;;;
+1D9FD;SIGNWRITING DYNAMIC EVERY OTHER TIME;So;0;L;;;;;N;;;;;
+1D9FE;SIGNWRITING DYNAMIC GRADUAL;So;0;L;;;;;N;;;;;
+1D9FF;SIGNWRITING HEAD;So;0;L;;;;;N;;;;;
+1DA00;SIGNWRITING HEAD RIM;Mn;0;NSM;;;;;N;;;;;
+1DA01;SIGNWRITING HEAD MOVEMENT-WALLPLANE STRAIGHT;Mn;0;NSM;;;;;N;;;;;
+1DA02;SIGNWRITING HEAD MOVEMENT-WALLPLANE TILT;Mn;0;NSM;;;;;N;;;;;
+1DA03;SIGNWRITING HEAD MOVEMENT-FLOORPLANE STRAIGHT;Mn;0;NSM;;;;;N;;;;;
+1DA04;SIGNWRITING HEAD MOVEMENT-WALLPLANE CURVE;Mn;0;NSM;;;;;N;;;;;
+1DA05;SIGNWRITING HEAD MOVEMENT-FLOORPLANE CURVE;Mn;0;NSM;;;;;N;;;;;
+1DA06;SIGNWRITING HEAD MOVEMENT CIRCLE;Mn;0;NSM;;;;;N;;;;;
+1DA07;SIGNWRITING FACE DIRECTION POSITION NOSE FORWARD TILTING;Mn;0;NSM;;;;;N;;;;;
+1DA08;SIGNWRITING FACE DIRECTION POSITION NOSE UP OR DOWN;Mn;0;NSM;;;;;N;;;;;
+1DA09;SIGNWRITING FACE DIRECTION POSITION NOSE UP OR DOWN TILTING;Mn;0;NSM;;;;;N;;;;;
+1DA0A;SIGNWRITING EYEBROWS STRAIGHT UP;Mn;0;NSM;;;;;N;;;;;
+1DA0B;SIGNWRITING EYEBROWS STRAIGHT NEUTRAL;Mn;0;NSM;;;;;N;;;;;
+1DA0C;SIGNWRITING EYEBROWS STRAIGHT DOWN;Mn;0;NSM;;;;;N;;;;;
+1DA0D;SIGNWRITING DREAMY EYEBROWS NEUTRAL DOWN;Mn;0;NSM;;;;;N;;;;;
+1DA0E;SIGNWRITING DREAMY EYEBROWS DOWN NEUTRAL;Mn;0;NSM;;;;;N;;;;;
+1DA0F;SIGNWRITING DREAMY EYEBROWS UP NEUTRAL;Mn;0;NSM;;;;;N;;;;;
+1DA10;SIGNWRITING DREAMY EYEBROWS NEUTRAL UP;Mn;0;NSM;;;;;N;;;;;
+1DA11;SIGNWRITING FOREHEAD NEUTRAL;Mn;0;NSM;;;;;N;;;;;
+1DA12;SIGNWRITING FOREHEAD CONTACT;Mn;0;NSM;;;;;N;;;;;
+1DA13;SIGNWRITING FOREHEAD WRINKLED;Mn;0;NSM;;;;;N;;;;;
+1DA14;SIGNWRITING EYES OPEN;Mn;0;NSM;;;;;N;;;;;
+1DA15;SIGNWRITING EYES SQUEEZED;Mn;0;NSM;;;;;N;;;;;
+1DA16;SIGNWRITING EYES CLOSED;Mn;0;NSM;;;;;N;;;;;
+1DA17;SIGNWRITING EYE BLINK SINGLE;Mn;0;NSM;;;;;N;;;;;
+1DA18;SIGNWRITING EYE BLINK MULTIPLE;Mn;0;NSM;;;;;N;;;;;
+1DA19;SIGNWRITING EYES HALF OPEN;Mn;0;NSM;;;;;N;;;;;
+1DA1A;SIGNWRITING EYES WIDE OPEN;Mn;0;NSM;;;;;N;;;;;
+1DA1B;SIGNWRITING EYES HALF CLOSED;Mn;0;NSM;;;;;N;;;;;
+1DA1C;SIGNWRITING EYES WIDENING MOVEMENT;Mn;0;NSM;;;;;N;;;;;
+1DA1D;SIGNWRITING EYE WINK;Mn;0;NSM;;;;;N;;;;;
+1DA1E;SIGNWRITING EYELASHES UP;Mn;0;NSM;;;;;N;;;;;
+1DA1F;SIGNWRITING EYELASHES DOWN;Mn;0;NSM;;;;;N;;;;;
+1DA20;SIGNWRITING EYELASHES FLUTTERING;Mn;0;NSM;;;;;N;;;;;
+1DA21;SIGNWRITING EYEGAZE-WALLPLANE STRAIGHT;Mn;0;NSM;;;;;N;;;;;
+1DA22;SIGNWRITING EYEGAZE-WALLPLANE STRAIGHT DOUBLE;Mn;0;NSM;;;;;N;;;;;
+1DA23;SIGNWRITING EYEGAZE-WALLPLANE STRAIGHT ALTERNATING;Mn;0;NSM;;;;;N;;;;;
+1DA24;SIGNWRITING EYEGAZE-FLOORPLANE STRAIGHT;Mn;0;NSM;;;;;N;;;;;
+1DA25;SIGNWRITING EYEGAZE-FLOORPLANE STRAIGHT DOUBLE;Mn;0;NSM;;;;;N;;;;;
+1DA26;SIGNWRITING EYEGAZE-FLOORPLANE STRAIGHT ALTERNATING;Mn;0;NSM;;;;;N;;;;;
+1DA27;SIGNWRITING EYEGAZE-WALLPLANE CURVED;Mn;0;NSM;;;;;N;;;;;
+1DA28;SIGNWRITING EYEGAZE-FLOORPLANE CURVED;Mn;0;NSM;;;;;N;;;;;
+1DA29;SIGNWRITING EYEGAZE-WALLPLANE CIRCLING;Mn;0;NSM;;;;;N;;;;;
+1DA2A;SIGNWRITING CHEEKS PUFFED;Mn;0;NSM;;;;;N;;;;;
+1DA2B;SIGNWRITING CHEEKS NEUTRAL;Mn;0;NSM;;;;;N;;;;;
+1DA2C;SIGNWRITING CHEEKS SUCKED;Mn;0;NSM;;;;;N;;;;;
+1DA2D;SIGNWRITING TENSE CHEEKS HIGH;Mn;0;NSM;;;;;N;;;;;
+1DA2E;SIGNWRITING TENSE CHEEKS MIDDLE;Mn;0;NSM;;;;;N;;;;;
+1DA2F;SIGNWRITING TENSE CHEEKS LOW;Mn;0;NSM;;;;;N;;;;;
+1DA30;SIGNWRITING EARS;Mn;0;NSM;;;;;N;;;;;
+1DA31;SIGNWRITING NOSE NEUTRAL;Mn;0;NSM;;;;;N;;;;;
+1DA32;SIGNWRITING NOSE CONTACT;Mn;0;NSM;;;;;N;;;;;
+1DA33;SIGNWRITING NOSE WRINKLES;Mn;0;NSM;;;;;N;;;;;
+1DA34;SIGNWRITING NOSE WIGGLES;Mn;0;NSM;;;;;N;;;;;
+1DA35;SIGNWRITING AIR BLOWING OUT;Mn;0;NSM;;;;;N;;;;;
+1DA36;SIGNWRITING AIR SUCKING IN;Mn;0;NSM;;;;;N;;;;;
+1DA37;SIGNWRITING AIR BLOW SMALL ROTATIONS;So;0;L;;;;;N;;;;;
+1DA38;SIGNWRITING AIR SUCK SMALL ROTATIONS;So;0;L;;;;;N;;;;;
+1DA39;SIGNWRITING BREATH INHALE;So;0;L;;;;;N;;;;;
+1DA3A;SIGNWRITING BREATH EXHALE;So;0;L;;;;;N;;;;;
+1DA3B;SIGNWRITING MOUTH CLOSED NEUTRAL;Mn;0;NSM;;;;;N;;;;;
+1DA3C;SIGNWRITING MOUTH CLOSED FORWARD;Mn;0;NSM;;;;;N;;;;;
+1DA3D;SIGNWRITING MOUTH CLOSED CONTACT;Mn;0;NSM;;;;;N;;;;;
+1DA3E;SIGNWRITING MOUTH SMILE;Mn;0;NSM;;;;;N;;;;;
+1DA3F;SIGNWRITING MOUTH SMILE WRINKLED;Mn;0;NSM;;;;;N;;;;;
+1DA40;SIGNWRITING MOUTH SMILE OPEN;Mn;0;NSM;;;;;N;;;;;
+1DA41;SIGNWRITING MOUTH FROWN;Mn;0;NSM;;;;;N;;;;;
+1DA42;SIGNWRITING MOUTH FROWN WRINKLED;Mn;0;NSM;;;;;N;;;;;
+1DA43;SIGNWRITING MOUTH FROWN OPEN;Mn;0;NSM;;;;;N;;;;;
+1DA44;SIGNWRITING MOUTH OPEN CIRCLE;Mn;0;NSM;;;;;N;;;;;
+1DA45;SIGNWRITING MOUTH OPEN FORWARD;Mn;0;NSM;;;;;N;;;;;
+1DA46;SIGNWRITING MOUTH OPEN WRINKLED;Mn;0;NSM;;;;;N;;;;;
+1DA47;SIGNWRITING MOUTH OPEN OVAL;Mn;0;NSM;;;;;N;;;;;
+1DA48;SIGNWRITING MOUTH OPEN OVAL WRINKLED;Mn;0;NSM;;;;;N;;;;;
+1DA49;SIGNWRITING MOUTH OPEN OVAL YAWN;Mn;0;NSM;;;;;N;;;;;
+1DA4A;SIGNWRITING MOUTH OPEN RECTANGLE;Mn;0;NSM;;;;;N;;;;;
+1DA4B;SIGNWRITING MOUTH OPEN RECTANGLE WRINKLED;Mn;0;NSM;;;;;N;;;;;
+1DA4C;SIGNWRITING MOUTH OPEN RECTANGLE YAWN;Mn;0;NSM;;;;;N;;;;;
+1DA4D;SIGNWRITING MOUTH KISS;Mn;0;NSM;;;;;N;;;;;
+1DA4E;SIGNWRITING MOUTH KISS FORWARD;Mn;0;NSM;;;;;N;;;;;
+1DA4F;SIGNWRITING MOUTH KISS WRINKLED;Mn;0;NSM;;;;;N;;;;;
+1DA50;SIGNWRITING MOUTH TENSE;Mn;0;NSM;;;;;N;;;;;
+1DA51;SIGNWRITING MOUTH TENSE FORWARD;Mn;0;NSM;;;;;N;;;;;
+1DA52;SIGNWRITING MOUTH TENSE SUCKED;Mn;0;NSM;;;;;N;;;;;
+1DA53;SIGNWRITING LIPS PRESSED TOGETHER;Mn;0;NSM;;;;;N;;;;;
+1DA54;SIGNWRITING LIP LOWER OVER UPPER;Mn;0;NSM;;;;;N;;;;;
+1DA55;SIGNWRITING LIP UPPER OVER LOWER;Mn;0;NSM;;;;;N;;;;;
+1DA56;SIGNWRITING MOUTH CORNERS;Mn;0;NSM;;;;;N;;;;;
+1DA57;SIGNWRITING MOUTH WRINKLES SINGLE;Mn;0;NSM;;;;;N;;;;;
+1DA58;SIGNWRITING MOUTH WRINKLES DOUBLE;Mn;0;NSM;;;;;N;;;;;
+1DA59;SIGNWRITING TONGUE STICKING OUT FAR;Mn;0;NSM;;;;;N;;;;;
+1DA5A;SIGNWRITING TONGUE LICKING LIPS;Mn;0;NSM;;;;;N;;;;;
+1DA5B;SIGNWRITING TONGUE TIP BETWEEN LIPS;Mn;0;NSM;;;;;N;;;;;
+1DA5C;SIGNWRITING TONGUE TIP TOUCHING INSIDE MOUTH;Mn;0;NSM;;;;;N;;;;;
+1DA5D;SIGNWRITING TONGUE INSIDE MOUTH RELAXED;Mn;0;NSM;;;;;N;;;;;
+1DA5E;SIGNWRITING TONGUE MOVES AGAINST CHEEK;Mn;0;NSM;;;;;N;;;;;
+1DA5F;SIGNWRITING TONGUE CENTRE STICKING OUT;Mn;0;NSM;;;;;N;;;;;
+1DA60;SIGNWRITING TONGUE CENTRE INSIDE MOUTH;Mn;0;NSM;;;;;N;;;;;
+1DA61;SIGNWRITING TEETH;Mn;0;NSM;;;;;N;;;;;
+1DA62;SIGNWRITING TEETH MOVEMENT;Mn;0;NSM;;;;;N;;;;;
+1DA63;SIGNWRITING TEETH ON TONGUE;Mn;0;NSM;;;;;N;;;;;
+1DA64;SIGNWRITING TEETH ON TONGUE MOVEMENT;Mn;0;NSM;;;;;N;;;;;
+1DA65;SIGNWRITING TEETH ON LIPS;Mn;0;NSM;;;;;N;;;;;
+1DA66;SIGNWRITING TEETH ON LIPS MOVEMENT;Mn;0;NSM;;;;;N;;;;;
+1DA67;SIGNWRITING TEETH BITE LIPS;Mn;0;NSM;;;;;N;;;;;
+1DA68;SIGNWRITING MOVEMENT-WALLPLANE JAW;Mn;0;NSM;;;;;N;;;;;
+1DA69;SIGNWRITING MOVEMENT-FLOORPLANE JAW;Mn;0;NSM;;;;;N;;;;;
+1DA6A;SIGNWRITING NECK;Mn;0;NSM;;;;;N;;;;;
+1DA6B;SIGNWRITING HAIR;Mn;0;NSM;;;;;N;;;;;
+1DA6C;SIGNWRITING EXCITEMENT;Mn;0;NSM;;;;;N;;;;;
+1DA6D;SIGNWRITING SHOULDER HIP SPINE;So;0;L;;;;;N;;;;;
+1DA6E;SIGNWRITING SHOULDER HIP POSITIONS;So;0;L;;;;;N;;;;;
+1DA6F;SIGNWRITING WALLPLANE SHOULDER HIP MOVE;So;0;L;;;;;N;;;;;
+1DA70;SIGNWRITING FLOORPLANE SHOULDER HIP MOVE;So;0;L;;;;;N;;;;;
+1DA71;SIGNWRITING SHOULDER TILTING FROM WAIST;So;0;L;;;;;N;;;;;
+1DA72;SIGNWRITING TORSO-WALLPLANE STRAIGHT STRETCH;So;0;L;;;;;N;;;;;
+1DA73;SIGNWRITING TORSO-WALLPLANE CURVED BEND;So;0;L;;;;;N;;;;;
+1DA74;SIGNWRITING TORSO-FLOORPLANE TWISTING;So;0;L;;;;;N;;;;;
+1DA75;SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS;Mn;0;NSM;;;;;N;;;;;
+1DA76;SIGNWRITING LIMB COMBINATION;So;0;L;;;;;N;;;;;
+1DA77;SIGNWRITING LIMB LENGTH-1;So;0;L;;;;;N;;;;;
+1DA78;SIGNWRITING LIMB LENGTH-2;So;0;L;;;;;N;;;;;
+1DA79;SIGNWRITING LIMB LENGTH-3;So;0;L;;;;;N;;;;;
+1DA7A;SIGNWRITING LIMB LENGTH-4;So;0;L;;;;;N;;;;;
+1DA7B;SIGNWRITING LIMB LENGTH-5;So;0;L;;;;;N;;;;;
+1DA7C;SIGNWRITING LIMB LENGTH-6;So;0;L;;;;;N;;;;;
+1DA7D;SIGNWRITING LIMB LENGTH-7;So;0;L;;;;;N;;;;;
+1DA7E;SIGNWRITING FINGER;So;0;L;;;;;N;;;;;
+1DA7F;SIGNWRITING LOCATION-WALLPLANE SPACE;So;0;L;;;;;N;;;;;
+1DA80;SIGNWRITING LOCATION-FLOORPLANE SPACE;So;0;L;;;;;N;;;;;
+1DA81;SIGNWRITING LOCATION HEIGHT;So;0;L;;;;;N;;;;;
+1DA82;SIGNWRITING LOCATION WIDTH;So;0;L;;;;;N;;;;;
+1DA83;SIGNWRITING LOCATION DEPTH;So;0;L;;;;;N;;;;;
+1DA84;SIGNWRITING LOCATION HEAD NECK;Mn;0;NSM;;;;;N;;;;;
+1DA85;SIGNWRITING LOCATION TORSO;So;0;L;;;;;N;;;;;
+1DA86;SIGNWRITING LOCATION LIMBS DIGITS;So;0;L;;;;;N;;;;;
+1DA87;SIGNWRITING COMMA;Po;0;L;;;;;N;;;;;
+1DA88;SIGNWRITING FULL STOP;Po;0;L;;;;;N;;;;;
+1DA89;SIGNWRITING SEMICOLON;Po;0;L;;;;;N;;;;;
+1DA8A;SIGNWRITING COLON;Po;0;L;;;;;N;;;;;
+1DA8B;SIGNWRITING PARENTHESIS;Po;0;L;;;;;N;;;;;
+1DA9B;SIGNWRITING FILL MODIFIER-2;Mn;0;NSM;;;;;N;;;;;
+1DA9C;SIGNWRITING FILL MODIFIER-3;Mn;0;NSM;;;;;N;;;;;
+1DA9D;SIGNWRITING FILL MODIFIER-4;Mn;0;NSM;;;;;N;;;;;
+1DA9E;SIGNWRITING FILL MODIFIER-5;Mn;0;NSM;;;;;N;;;;;
+1DA9F;SIGNWRITING FILL MODIFIER-6;Mn;0;NSM;;;;;N;;;;;
+1DAA1;SIGNWRITING ROTATION MODIFIER-2;Mn;0;NSM;;;;;N;;;;;
+1DAA2;SIGNWRITING ROTATION MODIFIER-3;Mn;0;NSM;;;;;N;;;;;
+1DAA3;SIGNWRITING ROTATION MODIFIER-4;Mn;0;NSM;;;;;N;;;;;
+1DAA4;SIGNWRITING ROTATION MODIFIER-5;Mn;0;NSM;;;;;N;;;;;
+1DAA5;SIGNWRITING ROTATION MODIFIER-6;Mn;0;NSM;;;;;N;;;;;
+1DAA6;SIGNWRITING ROTATION MODIFIER-7;Mn;0;NSM;;;;;N;;;;;
+1DAA7;SIGNWRITING ROTATION MODIFIER-8;Mn;0;NSM;;;;;N;;;;;
+1DAA8;SIGNWRITING ROTATION MODIFIER-9;Mn;0;NSM;;;;;N;;;;;
+1DAA9;SIGNWRITING ROTATION MODIFIER-10;Mn;0;NSM;;;;;N;;;;;
+1DAAA;SIGNWRITING ROTATION MODIFIER-11;Mn;0;NSM;;;;;N;;;;;
+1DAAB;SIGNWRITING ROTATION MODIFIER-12;Mn;0;NSM;;;;;N;;;;;
+1DAAC;SIGNWRITING ROTATION MODIFIER-13;Mn;0;NSM;;;;;N;;;;;
+1DAAD;SIGNWRITING ROTATION MODIFIER-14;Mn;0;NSM;;;;;N;;;;;
+1DAAE;SIGNWRITING ROTATION MODIFIER-15;Mn;0;NSM;;;;;N;;;;;
+1DAAF;SIGNWRITING ROTATION MODIFIER-16;Mn;0;NSM;;;;;N;;;;;
+1DF00;LATIN SMALL LETTER FENG DIGRAPH WITH TRILL;Ll;0;L;;;;;N;;;;;
+1DF01;LATIN SMALL LETTER REVERSED SCRIPT G;Ll;0;L;;;;;N;;;;;
+1DF02;LATIN LETTER SMALL CAPITAL TURNED G;Ll;0;L;;;;;N;;;;;
+1DF03;LATIN SMALL LETTER REVERSED K;Ll;0;L;;;;;N;;;;;
+1DF04;LATIN LETTER SMALL CAPITAL L WITH BELT;Ll;0;L;;;;;N;;;;;
+1DF05;LATIN SMALL LETTER LEZH WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
+1DF06;LATIN SMALL LETTER TURNED Y WITH BELT;Ll;0;L;;;;;N;;;;;
+1DF07;LATIN SMALL LETTER REVERSED ENG;Ll;0;L;;;;;N;;;;;
+1DF08;LATIN SMALL LETTER TURNED R WITH LONG LEG AND RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
+1DF09;LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
+1DF0A;LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK;Lo;0;L;;;;;N;;;;;
+1DF0B;LATIN SMALL LETTER ESH WITH DOUBLE BAR;Ll;0;L;;;;;N;;;;;
+1DF0C;LATIN SMALL LETTER ESH WITH DOUBLE BAR AND CURL;Ll;0;L;;;;;N;;;;;
+1DF0D;LATIN SMALL LETTER TURNED T WITH CURL;Ll;0;L;;;;;N;;;;;
+1DF0E;LATIN LETTER INVERTED GLOTTAL STOP WITH CURL;Ll;0;L;;;;;N;;;;;
+1DF0F;LATIN LETTER STRETCHED C WITH CURL;Ll;0;L;;;;;N;;;;;
+1DF10;LATIN LETTER SMALL CAPITAL TURNED K;Ll;0;L;;;;;N;;;;;
+1DF11;LATIN SMALL LETTER L WITH FISHHOOK;Ll;0;L;;;;;N;;;;;
+1DF12;LATIN SMALL LETTER DEZH DIGRAPH WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
+1DF13;LATIN SMALL LETTER L WITH BELT AND PALATAL HOOK;Ll;0;L;;;;;N;;;;;
+1DF14;LATIN SMALL LETTER ENG WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
+1DF15;LATIN SMALL LETTER TURNED R WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
+1DF16;LATIN SMALL LETTER R WITH FISHHOOK AND PALATAL HOOK;Ll;0;L;;;;;N;;;;;
+1DF17;LATIN SMALL LETTER TESH DIGRAPH WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
+1DF18;LATIN SMALL LETTER EZH WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;;
+1DF19;LATIN SMALL LETTER DEZH DIGRAPH WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
+1DF1A;LATIN SMALL LETTER I WITH STROKE AND RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
+1DF1B;LATIN SMALL LETTER O WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
+1DF1C;LATIN SMALL LETTER TESH DIGRAPH WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
+1DF1D;LATIN SMALL LETTER C WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;;
+1DF1E;LATIN SMALL LETTER S WITH CURL;Ll;0;L;;;;;N;;;;;
+1DF25;LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;;
+1DF26;LATIN SMALL LETTER L WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;;
+1DF27;LATIN SMALL LETTER N WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;;
+1DF28;LATIN SMALL LETTER R WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;;
+1DF29;LATIN SMALL LETTER S WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;;
+1DF2A;LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;;
+1E000;COMBINING GLAGOLITIC LETTER AZU;Mn;230;NSM;;;;;N;;;;;
+1E001;COMBINING GLAGOLITIC LETTER BUKY;Mn;230;NSM;;;;;N;;;;;
+1E002;COMBINING GLAGOLITIC LETTER VEDE;Mn;230;NSM;;;;;N;;;;;
+1E003;COMBINING GLAGOLITIC LETTER GLAGOLI;Mn;230;NSM;;;;;N;;;;;
+1E004;COMBINING GLAGOLITIC LETTER DOBRO;Mn;230;NSM;;;;;N;;;;;
+1E005;COMBINING GLAGOLITIC LETTER YESTU;Mn;230;NSM;;;;;N;;;;;
+1E006;COMBINING GLAGOLITIC LETTER ZHIVETE;Mn;230;NSM;;;;;N;;;;;
+1E008;COMBINING GLAGOLITIC LETTER ZEMLJA;Mn;230;NSM;;;;;N;;;;;
+1E009;COMBINING GLAGOLITIC LETTER IZHE;Mn;230;NSM;;;;;N;;;;;
+1E00A;COMBINING GLAGOLITIC LETTER INITIAL IZHE;Mn;230;NSM;;;;;N;;;;;
+1E00B;COMBINING GLAGOLITIC LETTER I;Mn;230;NSM;;;;;N;;;;;
+1E00C;COMBINING GLAGOLITIC LETTER DJERVI;Mn;230;NSM;;;;;N;;;;;
+1E00D;COMBINING GLAGOLITIC LETTER KAKO;Mn;230;NSM;;;;;N;;;;;
+1E00E;COMBINING GLAGOLITIC LETTER LJUDIJE;Mn;230;NSM;;;;;N;;;;;
+1E00F;COMBINING GLAGOLITIC LETTER MYSLITE;Mn;230;NSM;;;;;N;;;;;
+1E010;COMBINING GLAGOLITIC LETTER NASHI;Mn;230;NSM;;;;;N;;;;;
+1E011;COMBINING GLAGOLITIC LETTER ONU;Mn;230;NSM;;;;;N;;;;;
+1E012;COMBINING GLAGOLITIC LETTER POKOJI;Mn;230;NSM;;;;;N;;;;;
+1E013;COMBINING GLAGOLITIC LETTER RITSI;Mn;230;NSM;;;;;N;;;;;
+1E014;COMBINING GLAGOLITIC LETTER SLOVO;Mn;230;NSM;;;;;N;;;;;
+1E015;COMBINING GLAGOLITIC LETTER TVRIDO;Mn;230;NSM;;;;;N;;;;;
+1E016;COMBINING GLAGOLITIC LETTER UKU;Mn;230;NSM;;;;;N;;;;;
+1E017;COMBINING GLAGOLITIC LETTER FRITU;Mn;230;NSM;;;;;N;;;;;
+1E018;COMBINING GLAGOLITIC LETTER HERU;Mn;230;NSM;;;;;N;;;;;
+1E01B;COMBINING GLAGOLITIC LETTER SHTA;Mn;230;NSM;;;;;N;;;;;
+1E01C;COMBINING GLAGOLITIC LETTER TSI;Mn;230;NSM;;;;;N;;;;;
+1E01D;COMBINING GLAGOLITIC LETTER CHRIVI;Mn;230;NSM;;;;;N;;;;;
+1E01E;COMBINING GLAGOLITIC LETTER SHA;Mn;230;NSM;;;;;N;;;;;
+1E01F;COMBINING GLAGOLITIC LETTER YERU;Mn;230;NSM;;;;;N;;;;;
+1E020;COMBINING GLAGOLITIC LETTER YERI;Mn;230;NSM;;;;;N;;;;;
+1E021;COMBINING GLAGOLITIC LETTER YATI;Mn;230;NSM;;;;;N;;;;;
+1E023;COMBINING GLAGOLITIC LETTER YU;Mn;230;NSM;;;;;N;;;;;
+1E024;COMBINING GLAGOLITIC LETTER SMALL YUS;Mn;230;NSM;;;;;N;;;;;
+1E026;COMBINING GLAGOLITIC LETTER YO;Mn;230;NSM;;;;;N;;;;;
+1E027;COMBINING GLAGOLITIC LETTER IOTATED SMALL YUS;Mn;230;NSM;;;;;N;;;;;
+1E028;COMBINING GLAGOLITIC LETTER BIG YUS;Mn;230;NSM;;;;;N;;;;;
+1E029;COMBINING GLAGOLITIC LETTER IOTATED BIG YUS;Mn;230;NSM;;;;;N;;;;;
+1E02A;COMBINING GLAGOLITIC LETTER FITA;Mn;230;NSM;;;;;N;;;;;
+1E030;MODIFIER LETTER CYRILLIC SMALL A;Lm;0;L;<super> 0430;;;;N;;;;;
+1E031;MODIFIER LETTER CYRILLIC SMALL BE;Lm;0;L;<super> 0431;;;;N;;;;;
+1E032;MODIFIER LETTER CYRILLIC SMALL VE;Lm;0;L;<super> 0432;;;;N;;;;;
+1E033;MODIFIER LETTER CYRILLIC SMALL GHE;Lm;0;L;<super> 0433;;;;N;;;;;
+1E034;MODIFIER LETTER CYRILLIC SMALL DE;Lm;0;L;<super> 0434;;;;N;;;;;
+1E035;MODIFIER LETTER CYRILLIC SMALL IE;Lm;0;L;<super> 0435;;;;N;;;;;
+1E036;MODIFIER LETTER CYRILLIC SMALL ZHE;Lm;0;L;<super> 0436;;;;N;;;;;
+1E037;MODIFIER LETTER CYRILLIC SMALL ZE;Lm;0;L;<super> 0437;;;;N;;;;;
+1E038;MODIFIER LETTER CYRILLIC SMALL I;Lm;0;L;<super> 0438;;;;N;;;;;
+1E039;MODIFIER LETTER CYRILLIC SMALL KA;Lm;0;L;<super> 043A;;;;N;;;;;
+1E03A;MODIFIER LETTER CYRILLIC SMALL EL;Lm;0;L;<super> 043B;;;;N;;;;;
+1E03B;MODIFIER LETTER CYRILLIC SMALL EM;Lm;0;L;<super> 043C;;;;N;;;;;
+1E03C;MODIFIER LETTER CYRILLIC SMALL O;Lm;0;L;<super> 043E;;;;N;;;;;
+1E03D;MODIFIER LETTER CYRILLIC SMALL PE;Lm;0;L;<super> 043F;;;;N;;;;;
+1E03E;MODIFIER LETTER CYRILLIC SMALL ER;Lm;0;L;<super> 0440;;;;N;;;;;
+1E03F;MODIFIER LETTER CYRILLIC SMALL ES;Lm;0;L;<super> 0441;;;;N;;;;;
+1E040;MODIFIER LETTER CYRILLIC SMALL TE;Lm;0;L;<super> 0442;;;;N;;;;;
+1E041;MODIFIER LETTER CYRILLIC SMALL U;Lm;0;L;<super> 0443;;;;N;;;;;
+1E042;MODIFIER LETTER CYRILLIC SMALL EF;Lm;0;L;<super> 0444;;;;N;;;;;
+1E043;MODIFIER LETTER CYRILLIC SMALL HA;Lm;0;L;<super> 0445;;;;N;;;;;
+1E044;MODIFIER LETTER CYRILLIC SMALL TSE;Lm;0;L;<super> 0446;;;;N;;;;;
+1E045;MODIFIER LETTER CYRILLIC SMALL CHE;Lm;0;L;<super> 0447;;;;N;;;;;
+1E046;MODIFIER LETTER CYRILLIC SMALL SHA;Lm;0;L;<super> 0448;;;;N;;;;;
+1E047;MODIFIER LETTER CYRILLIC SMALL YERU;Lm;0;L;<super> 044B;;;;N;;;;;
+1E048;MODIFIER LETTER CYRILLIC SMALL E;Lm;0;L;<super> 044D;;;;N;;;;;
+1E049;MODIFIER LETTER CYRILLIC SMALL YU;Lm;0;L;<super> 044E;;;;N;;;;;
+1E04A;MODIFIER LETTER CYRILLIC SMALL DZZE;Lm;0;L;<super> A689;;;;N;;;;;
+1E04B;MODIFIER LETTER CYRILLIC SMALL SCHWA;Lm;0;L;<super> 04D9;;;;N;;;;;
+1E04C;MODIFIER LETTER CYRILLIC SMALL BYELORUSSIAN-UKRAINIAN I;Lm;0;L;<super> 0456;;;;N;;;;;
+1E04D;MODIFIER LETTER CYRILLIC SMALL JE;Lm;0;L;<super> 0458;;;;N;;;;;
+1E04E;MODIFIER LETTER CYRILLIC SMALL BARRED O;Lm;0;L;<super> 04E9;;;;N;;;;;
+1E04F;MODIFIER LETTER CYRILLIC SMALL STRAIGHT U;Lm;0;L;<super> 04AF;;;;N;;;;;
+1E050;MODIFIER LETTER CYRILLIC SMALL PALOCHKA;Lm;0;L;<super> 04CF;;;;N;;;;;
+1E051;CYRILLIC SUBSCRIPT SMALL LETTER A;Lm;0;L;<sub> 0430;;;;N;;;;;
+1E052;CYRILLIC SUBSCRIPT SMALL LETTER BE;Lm;0;L;<sub> 0431;;;;N;;;;;
+1E053;CYRILLIC SUBSCRIPT SMALL LETTER VE;Lm;0;L;<sub> 0432;;;;N;;;;;
+1E054;CYRILLIC SUBSCRIPT SMALL LETTER GHE;Lm;0;L;<sub> 0433;;;;N;;;;;
+1E055;CYRILLIC SUBSCRIPT SMALL LETTER DE;Lm;0;L;<sub> 0434;;;;N;;;;;
+1E056;CYRILLIC SUBSCRIPT SMALL LETTER IE;Lm;0;L;<sub> 0435;;;;N;;;;;
+1E057;CYRILLIC SUBSCRIPT SMALL LETTER ZHE;Lm;0;L;<sub> 0436;;;;N;;;;;
+1E058;CYRILLIC SUBSCRIPT SMALL LETTER ZE;Lm;0;L;<sub> 0437;;;;N;;;;;
+1E059;CYRILLIC SUBSCRIPT SMALL LETTER I;Lm;0;L;<sub> 0438;;;;N;;;;;
+1E05A;CYRILLIC SUBSCRIPT SMALL LETTER KA;Lm;0;L;<sub> 043A;;;;N;;;;;
+1E05B;CYRILLIC SUBSCRIPT SMALL LETTER EL;Lm;0;L;<sub> 043B;;;;N;;;;;
+1E05C;CYRILLIC SUBSCRIPT SMALL LETTER O;Lm;0;L;<sub> 043E;;;;N;;;;;
+1E05D;CYRILLIC SUBSCRIPT SMALL LETTER PE;Lm;0;L;<sub> 043F;;;;N;;;;;
+1E05E;CYRILLIC SUBSCRIPT SMALL LETTER ES;Lm;0;L;<sub> 0441;;;;N;;;;;
+1E05F;CYRILLIC SUBSCRIPT SMALL LETTER U;Lm;0;L;<sub> 0443;;;;N;;;;;
+1E060;CYRILLIC SUBSCRIPT SMALL LETTER EF;Lm;0;L;<sub> 0444;;;;N;;;;;
+1E061;CYRILLIC SUBSCRIPT SMALL LETTER HA;Lm;0;L;<sub> 0445;;;;N;;;;;
+1E062;CYRILLIC SUBSCRIPT SMALL LETTER TSE;Lm;0;L;<sub> 0446;;;;N;;;;;
+1E063;CYRILLIC SUBSCRIPT SMALL LETTER CHE;Lm;0;L;<sub> 0447;;;;N;;;;;
+1E064;CYRILLIC SUBSCRIPT SMALL LETTER SHA;Lm;0;L;<sub> 0448;;;;N;;;;;
+1E065;CYRILLIC SUBSCRIPT SMALL LETTER HARD SIGN;Lm;0;L;<sub> 044A;;;;N;;;;;
+1E066;CYRILLIC SUBSCRIPT SMALL LETTER YERU;Lm;0;L;<sub> 044B;;;;N;;;;;
+1E067;CYRILLIC SUBSCRIPT SMALL LETTER GHE WITH UPTURN;Lm;0;L;<sub> 0491;;;;N;;;;;
+1E068;CYRILLIC SUBSCRIPT SMALL LETTER BYELORUSSIAN-UKRAINIAN I;Lm;0;L;<sub> 0456;;;;N;;;;;
+1E069;CYRILLIC SUBSCRIPT SMALL LETTER DZE;Lm;0;L;<sub> 0455;;;;N;;;;;
+1E06A;CYRILLIC SUBSCRIPT SMALL LETTER DZHE;Lm;0;L;<sub> 045F;;;;N;;;;;
+1E06B;MODIFIER LETTER CYRILLIC SMALL ES WITH DESCENDER;Lm;0;L;<super> 04AB;;;;N;;;;;
+1E06C;MODIFIER LETTER CYRILLIC SMALL YERU WITH BACK YER;Lm;0;L;<super> A651;;;;N;;;;;
+1E06D;MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE;Lm;0;L;<super> 04B1;;;;N;;;;;
+1E08F;COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I;Mn;230;NSM;;;;;N;;;;;
+1E100;NYIAKENG PUACHUE HMONG LETTER MA;Lo;0;L;;;;;N;;;;;
+1E101;NYIAKENG PUACHUE HMONG LETTER TSA;Lo;0;L;;;;;N;;;;;
+1E102;NYIAKENG PUACHUE HMONG LETTER NTA;Lo;0;L;;;;;N;;;;;
+1E103;NYIAKENG PUACHUE HMONG LETTER TA;Lo;0;L;;;;;N;;;;;
+1E104;NYIAKENG PUACHUE HMONG LETTER HA;Lo;0;L;;;;;N;;;;;
+1E105;NYIAKENG PUACHUE HMONG LETTER NA;Lo;0;L;;;;;N;;;;;
+1E106;NYIAKENG PUACHUE HMONG LETTER XA;Lo;0;L;;;;;N;;;;;
+1E107;NYIAKENG PUACHUE HMONG LETTER NKA;Lo;0;L;;;;;N;;;;;
+1E108;NYIAKENG PUACHUE HMONG LETTER CA;Lo;0;L;;;;;N;;;;;
+1E109;NYIAKENG PUACHUE HMONG LETTER LA;Lo;0;L;;;;;N;;;;;
+1E10A;NYIAKENG PUACHUE HMONG LETTER SA;Lo;0;L;;;;;N;;;;;
+1E10B;NYIAKENG PUACHUE HMONG LETTER ZA;Lo;0;L;;;;;N;;;;;
+1E10C;NYIAKENG PUACHUE HMONG LETTER NCA;Lo;0;L;;;;;N;;;;;
+1E10D;NYIAKENG PUACHUE HMONG LETTER NTSA;Lo;0;L;;;;;N;;;;;
+1E10E;NYIAKENG PUACHUE HMONG LETTER KA;Lo;0;L;;;;;N;;;;;
+1E10F;NYIAKENG PUACHUE HMONG LETTER DA;Lo;0;L;;;;;N;;;;;
+1E110;NYIAKENG PUACHUE HMONG LETTER NYA;Lo;0;L;;;;;N;;;;;
+1E111;NYIAKENG PUACHUE HMONG LETTER NRA;Lo;0;L;;;;;N;;;;;
+1E112;NYIAKENG PUACHUE HMONG LETTER VA;Lo;0;L;;;;;N;;;;;
+1E113;NYIAKENG PUACHUE HMONG LETTER NTXA;Lo;0;L;;;;;N;;;;;
+1E114;NYIAKENG PUACHUE HMONG LETTER TXA;Lo;0;L;;;;;N;;;;;
+1E115;NYIAKENG PUACHUE HMONG LETTER FA;Lo;0;L;;;;;N;;;;;
+1E116;NYIAKENG PUACHUE HMONG LETTER RA;Lo;0;L;;;;;N;;;;;
+1E117;NYIAKENG PUACHUE HMONG LETTER QA;Lo;0;L;;;;;N;;;;;
+1E118;NYIAKENG PUACHUE HMONG LETTER YA;Lo;0;L;;;;;N;;;;;
+1E119;NYIAKENG PUACHUE HMONG LETTER NQA;Lo;0;L;;;;;N;;;;;
+1E11A;NYIAKENG PUACHUE HMONG LETTER PA;Lo;0;L;;;;;N;;;;;
+1E11B;NYIAKENG PUACHUE HMONG LETTER XYA;Lo;0;L;;;;;N;;;;;
+1E11C;NYIAKENG PUACHUE HMONG LETTER NPA;Lo;0;L;;;;;N;;;;;
+1E11D;NYIAKENG PUACHUE HMONG LETTER DLA;Lo;0;L;;;;;N;;;;;
+1E11E;NYIAKENG PUACHUE HMONG LETTER NPLA;Lo;0;L;;;;;N;;;;;
+1E11F;NYIAKENG PUACHUE HMONG LETTER HAH;Lo;0;L;;;;;N;;;;;
+1E120;NYIAKENG PUACHUE HMONG LETTER MLA;Lo;0;L;;;;;N;;;;;
+1E121;NYIAKENG PUACHUE HMONG LETTER PLA;Lo;0;L;;;;;N;;;;;
+1E122;NYIAKENG PUACHUE HMONG LETTER GA;Lo;0;L;;;;;N;;;;;
+1E123;NYIAKENG PUACHUE HMONG LETTER RRA;Lo;0;L;;;;;N;;;;;
+1E124;NYIAKENG PUACHUE HMONG LETTER A;Lo;0;L;;;;;N;;;;;
+1E125;NYIAKENG PUACHUE HMONG LETTER AA;Lo;0;L;;;;;N;;;;;
+1E126;NYIAKENG PUACHUE HMONG LETTER I;Lo;0;L;;;;;N;;;;;
+1E127;NYIAKENG PUACHUE HMONG LETTER U;Lo;0;L;;;;;N;;;;;
+1E128;NYIAKENG PUACHUE HMONG LETTER O;Lo;0;L;;;;;N;;;;;
+1E129;NYIAKENG PUACHUE HMONG LETTER OO;Lo;0;L;;;;;N;;;;;
+1E12A;NYIAKENG PUACHUE HMONG LETTER E;Lo;0;L;;;;;N;;;;;
+1E12B;NYIAKENG PUACHUE HMONG LETTER EE;Lo;0;L;;;;;N;;;;;
+1E12C;NYIAKENG PUACHUE HMONG LETTER W;Lo;0;L;;;;;N;;;;;
+1E130;NYIAKENG PUACHUE HMONG TONE-B;Mn;230;NSM;;;;;N;;;;;
+1E131;NYIAKENG PUACHUE HMONG TONE-M;Mn;230;NSM;;;;;N;;;;;
+1E132;NYIAKENG PUACHUE HMONG TONE-J;Mn;230;NSM;;;;;N;;;;;
+1E133;NYIAKENG PUACHUE HMONG TONE-V;Mn;230;NSM;;;;;N;;;;;
+1E134;NYIAKENG PUACHUE HMONG TONE-S;Mn;230;NSM;;;;;N;;;;;
+1E135;NYIAKENG PUACHUE HMONG TONE-G;Mn;230;NSM;;;;;N;;;;;
+1E136;NYIAKENG PUACHUE HMONG TONE-D;Mn;230;NSM;;;;;N;;;;;
+1E137;NYIAKENG PUACHUE HMONG SIGN FOR PERSON;Lm;0;L;;;;;N;;;;;
+1E138;NYIAKENG PUACHUE HMONG SIGN FOR THING;Lm;0;L;;;;;N;;;;;
+1E139;NYIAKENG PUACHUE HMONG SIGN FOR LOCATION;Lm;0;L;;;;;N;;;;;
+1E13A;NYIAKENG PUACHUE HMONG SIGN FOR ANIMAL;Lm;0;L;;;;;N;;;;;
+1E13B;NYIAKENG PUACHUE HMONG SIGN FOR INVERTEBRATE;Lm;0;L;;;;;N;;;;;
+1E13C;NYIAKENG PUACHUE HMONG SIGN XW XW;Lm;0;L;;;;;N;;;;;
+1E13D;NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER;Lm;0;L;;;;;N;;;;;
+1E140;NYIAKENG PUACHUE HMONG DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+1E141;NYIAKENG PUACHUE HMONG DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+1E142;NYIAKENG PUACHUE HMONG DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+1E143;NYIAKENG PUACHUE HMONG DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+1E144;NYIAKENG PUACHUE HMONG DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+1E145;NYIAKENG PUACHUE HMONG DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+1E146;NYIAKENG PUACHUE HMONG DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+1E147;NYIAKENG PUACHUE HMONG DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+1E148;NYIAKENG PUACHUE HMONG DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+1E149;NYIAKENG PUACHUE HMONG DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+1E14E;NYIAKENG PUACHUE HMONG LOGOGRAM NYAJ;Lo;0;L;;;;;N;;;;;
+1E14F;NYIAKENG PUACHUE HMONG CIRCLED CA;So;0;L;;;;;N;;;;;
+1E290;TOTO LETTER PA;Lo;0;L;;;;;N;;;;;
+1E291;TOTO LETTER BA;Lo;0;L;;;;;N;;;;;
+1E292;TOTO LETTER TA;Lo;0;L;;;;;N;;;;;
+1E293;TOTO LETTER DA;Lo;0;L;;;;;N;;;;;
+1E294;TOTO LETTER KA;Lo;0;L;;;;;N;;;;;
+1E295;TOTO LETTER GA;Lo;0;L;;;;;N;;;;;
+1E296;TOTO LETTER MA;Lo;0;L;;;;;N;;;;;
+1E297;TOTO LETTER NA;Lo;0;L;;;;;N;;;;;
+1E298;TOTO LETTER NGA;Lo;0;L;;;;;N;;;;;
+1E299;TOTO LETTER SA;Lo;0;L;;;;;N;;;;;
+1E29A;TOTO LETTER CHA;Lo;0;L;;;;;N;;;;;
+1E29B;TOTO LETTER YA;Lo;0;L;;;;;N;;;;;
+1E29C;TOTO LETTER WA;Lo;0;L;;;;;N;;;;;
+1E29D;TOTO LETTER JA;Lo;0;L;;;;;N;;;;;
+1E29E;TOTO LETTER HA;Lo;0;L;;;;;N;;;;;
+1E29F;TOTO LETTER RA;Lo;0;L;;;;;N;;;;;
+1E2A0;TOTO LETTER LA;Lo;0;L;;;;;N;;;;;
+1E2A1;TOTO LETTER I;Lo;0;L;;;;;N;;;;;
+1E2A2;TOTO LETTER BREATHY I;Lo;0;L;;;;;N;;;;;
+1E2A3;TOTO LETTER IU;Lo;0;L;;;;;N;;;;;
+1E2A4;TOTO LETTER BREATHY IU;Lo;0;L;;;;;N;;;;;
+1E2A5;TOTO LETTER U;Lo;0;L;;;;;N;;;;;
+1E2A6;TOTO LETTER E;Lo;0;L;;;;;N;;;;;
+1E2A7;TOTO LETTER BREATHY E;Lo;0;L;;;;;N;;;;;
+1E2A8;TOTO LETTER EO;Lo;0;L;;;;;N;;;;;
+1E2A9;TOTO LETTER BREATHY EO;Lo;0;L;;;;;N;;;;;
+1E2AA;TOTO LETTER O;Lo;0;L;;;;;N;;;;;
+1E2AB;TOTO LETTER AE;Lo;0;L;;;;;N;;;;;
+1E2AC;TOTO LETTER BREATHY AE;Lo;0;L;;;;;N;;;;;
+1E2AD;TOTO LETTER A;Lo;0;L;;;;;N;;;;;
+1E2AE;TOTO SIGN RISING TONE;Mn;230;NSM;;;;;N;;;;;
+1E2C0;WANCHO LETTER AA;Lo;0;L;;;;;N;;;;;
+1E2C1;WANCHO LETTER A;Lo;0;L;;;;;N;;;;;
+1E2C2;WANCHO LETTER BA;Lo;0;L;;;;;N;;;;;
+1E2C3;WANCHO LETTER CA;Lo;0;L;;;;;N;;;;;
+1E2C4;WANCHO LETTER DA;Lo;0;L;;;;;N;;;;;
+1E2C5;WANCHO LETTER GA;Lo;0;L;;;;;N;;;;;
+1E2C6;WANCHO LETTER YA;Lo;0;L;;;;;N;;;;;
+1E2C7;WANCHO LETTER PHA;Lo;0;L;;;;;N;;;;;
+1E2C8;WANCHO LETTER LA;Lo;0;L;;;;;N;;;;;
+1E2C9;WANCHO LETTER NA;Lo;0;L;;;;;N;;;;;
+1E2CA;WANCHO LETTER PA;Lo;0;L;;;;;N;;;;;
+1E2CB;WANCHO LETTER TA;Lo;0;L;;;;;N;;;;;
+1E2CC;WANCHO LETTER THA;Lo;0;L;;;;;N;;;;;
+1E2CD;WANCHO LETTER FA;Lo;0;L;;;;;N;;;;;
+1E2CE;WANCHO LETTER SA;Lo;0;L;;;;;N;;;;;
+1E2CF;WANCHO LETTER SHA;Lo;0;L;;;;;N;;;;;
+1E2D0;WANCHO LETTER JA;Lo;0;L;;;;;N;;;;;
+1E2D1;WANCHO LETTER ZA;Lo;0;L;;;;;N;;;;;
+1E2D2;WANCHO LETTER WA;Lo;0;L;;;;;N;;;;;
+1E2D3;WANCHO LETTER VA;Lo;0;L;;;;;N;;;;;
+1E2D4;WANCHO LETTER KA;Lo;0;L;;;;;N;;;;;
+1E2D5;WANCHO LETTER O;Lo;0;L;;;;;N;;;;;
+1E2D6;WANCHO LETTER AU;Lo;0;L;;;;;N;;;;;
+1E2D7;WANCHO LETTER RA;Lo;0;L;;;;;N;;;;;
+1E2D8;WANCHO LETTER MA;Lo;0;L;;;;;N;;;;;
+1E2D9;WANCHO LETTER KHA;Lo;0;L;;;;;N;;;;;
+1E2DA;WANCHO LETTER HA;Lo;0;L;;;;;N;;;;;
+1E2DB;WANCHO LETTER E;Lo;0;L;;;;;N;;;;;
+1E2DC;WANCHO LETTER I;Lo;0;L;;;;;N;;;;;
+1E2DD;WANCHO LETTER NGA;Lo;0;L;;;;;N;;;;;
+1E2DE;WANCHO LETTER U;Lo;0;L;;;;;N;;;;;
+1E2DF;WANCHO LETTER LLHA;Lo;0;L;;;;;N;;;;;
+1E2E0;WANCHO LETTER TSA;Lo;0;L;;;;;N;;;;;
+1E2E1;WANCHO LETTER TRA;Lo;0;L;;;;;N;;;;;
+1E2E2;WANCHO LETTER ONG;Lo;0;L;;;;;N;;;;;
+1E2E3;WANCHO LETTER AANG;Lo;0;L;;;;;N;;;;;
+1E2E4;WANCHO LETTER ANG;Lo;0;L;;;;;N;;;;;
+1E2E5;WANCHO LETTER ING;Lo;0;L;;;;;N;;;;;
+1E2E6;WANCHO LETTER ON;Lo;0;L;;;;;N;;;;;
+1E2E7;WANCHO LETTER EN;Lo;0;L;;;;;N;;;;;
+1E2E8;WANCHO LETTER AAN;Lo;0;L;;;;;N;;;;;
+1E2E9;WANCHO LETTER NYA;Lo;0;L;;;;;N;;;;;
+1E2EA;WANCHO LETTER UEN;Lo;0;L;;;;;N;;;;;
+1E2EB;WANCHO LETTER YIH;Lo;0;L;;;;;N;;;;;
+1E2EC;WANCHO TONE TUP;Mn;230;NSM;;;;;N;;;;;
+1E2ED;WANCHO TONE TUPNI;Mn;230;NSM;;;;;N;;;;;
+1E2EE;WANCHO TONE KOI;Mn;230;NSM;;;;;N;;;;;
+1E2EF;WANCHO TONE KOINI;Mn;230;NSM;;;;;N;;;;;
+1E2F0;WANCHO DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+1E2F1;WANCHO DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+1E2F2;WANCHO DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+1E2F3;WANCHO DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+1E2F4;WANCHO DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+1E2F5;WANCHO DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+1E2F6;WANCHO DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+1E2F7;WANCHO DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+1E2F8;WANCHO DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+1E2F9;WANCHO DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+1E2FF;WANCHO NGUN SIGN;Sc;0;ET;;;;;N;;;;;
+1E4D0;NAG MUNDARI LETTER O;Lo;0;L;;;;;N;;;;;
+1E4D1;NAG MUNDARI LETTER OP;Lo;0;L;;;;;N;;;;;
+1E4D2;NAG MUNDARI LETTER OL;Lo;0;L;;;;;N;;;;;
+1E4D3;NAG MUNDARI LETTER OY;Lo;0;L;;;;;N;;;;;
+1E4D4;NAG MUNDARI LETTER ONG;Lo;0;L;;;;;N;;;;;
+1E4D5;NAG MUNDARI LETTER A;Lo;0;L;;;;;N;;;;;
+1E4D6;NAG MUNDARI LETTER AJ;Lo;0;L;;;;;N;;;;;
+1E4D7;NAG MUNDARI LETTER AB;Lo;0;L;;;;;N;;;;;
+1E4D8;NAG MUNDARI LETTER ANY;Lo;0;L;;;;;N;;;;;
+1E4D9;NAG MUNDARI LETTER AH;Lo;0;L;;;;;N;;;;;
+1E4DA;NAG MUNDARI LETTER I;Lo;0;L;;;;;N;;;;;
+1E4DB;NAG MUNDARI LETTER IS;Lo;0;L;;;;;N;;;;;
+1E4DC;NAG MUNDARI LETTER IDD;Lo;0;L;;;;;N;;;;;
+1E4DD;NAG MUNDARI LETTER IT;Lo;0;L;;;;;N;;;;;
+1E4DE;NAG MUNDARI LETTER IH;Lo;0;L;;;;;N;;;;;
+1E4DF;NAG MUNDARI LETTER U;Lo;0;L;;;;;N;;;;;
+1E4E0;NAG MUNDARI LETTER UC;Lo;0;L;;;;;N;;;;;
+1E4E1;NAG MUNDARI LETTER UD;Lo;0;L;;;;;N;;;;;
+1E4E2;NAG MUNDARI LETTER UK;Lo;0;L;;;;;N;;;;;
+1E4E3;NAG MUNDARI LETTER UR;Lo;0;L;;;;;N;;;;;
+1E4E4;NAG MUNDARI LETTER E;Lo;0;L;;;;;N;;;;;
+1E4E5;NAG MUNDARI LETTER ENN;Lo;0;L;;;;;N;;;;;
+1E4E6;NAG MUNDARI LETTER EG;Lo;0;L;;;;;N;;;;;
+1E4E7;NAG MUNDARI LETTER EM;Lo;0;L;;;;;N;;;;;
+1E4E8;NAG MUNDARI LETTER EN;Lo;0;L;;;;;N;;;;;
+1E4E9;NAG MUNDARI LETTER ETT;Lo;0;L;;;;;N;;;;;
+1E4EA;NAG MUNDARI LETTER ELL;Lo;0;L;;;;;N;;;;;
+1E4EB;NAG MUNDARI SIGN OJOD;Lm;0;L;;;;;N;;;;;
+1E4EC;NAG MUNDARI SIGN MUHOR;Mn;232;NSM;;;;;N;;;;;
+1E4ED;NAG MUNDARI SIGN TOYOR;Mn;232;NSM;;;;;N;;;;;
+1E4EE;NAG MUNDARI SIGN IKIR;Mn;220;NSM;;;;;N;;;;;
+1E4EF;NAG MUNDARI SIGN SUTUH;Mn;230;NSM;;;;;N;;;;;
+1E4F0;NAG MUNDARI DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+1E4F1;NAG MUNDARI DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+1E4F2;NAG MUNDARI DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+1E4F3;NAG MUNDARI DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+1E4F4;NAG MUNDARI DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+1E4F5;NAG MUNDARI DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+1E4F6;NAG MUNDARI DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+1E4F7;NAG MUNDARI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+1E4F8;NAG MUNDARI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+1E4F9;NAG MUNDARI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+1E5D0;OL ONAL LETTER O;Lo;0;L;;;;;N;;;;;
+1E5D1;OL ONAL LETTER OM;Lo;0;L;;;;;N;;;;;
+1E5D2;OL ONAL LETTER ONG;Lo;0;L;;;;;N;;;;;
+1E5D3;OL ONAL LETTER ORR;Lo;0;L;;;;;N;;;;;
+1E5D4;OL ONAL LETTER OO;Lo;0;L;;;;;N;;;;;
+1E5D5;OL ONAL LETTER OY;Lo;0;L;;;;;N;;;;;
+1E5D6;OL ONAL LETTER A;Lo;0;L;;;;;N;;;;;
+1E5D7;OL ONAL LETTER AD;Lo;0;L;;;;;N;;;;;
+1E5D8;OL ONAL LETTER AB;Lo;0;L;;;;;N;;;;;
+1E5D9;OL ONAL LETTER AH;Lo;0;L;;;;;N;;;;;
+1E5DA;OL ONAL LETTER AL;Lo;0;L;;;;;N;;;;;
+1E5DB;OL ONAL LETTER AW;Lo;0;L;;;;;N;;;;;
+1E5DC;OL ONAL LETTER I;Lo;0;L;;;;;N;;;;;
+1E5DD;OL ONAL LETTER IT;Lo;0;L;;;;;N;;;;;
+1E5DE;OL ONAL LETTER IP;Lo;0;L;;;;;N;;;;;
+1E5DF;OL ONAL LETTER ITT;Lo;0;L;;;;;N;;;;;
+1E5E0;OL ONAL LETTER ID;Lo;0;L;;;;;N;;;;;
+1E5E1;OL ONAL LETTER IN;Lo;0;L;;;;;N;;;;;
+1E5E2;OL ONAL LETTER U;Lo;0;L;;;;;N;;;;;
+1E5E3;OL ONAL LETTER UK;Lo;0;L;;;;;N;;;;;
+1E5E4;OL ONAL LETTER UDD;Lo;0;L;;;;;N;;;;;
+1E5E5;OL ONAL LETTER UJ;Lo;0;L;;;;;N;;;;;
+1E5E6;OL ONAL LETTER UNY;Lo;0;L;;;;;N;;;;;
+1E5E7;OL ONAL LETTER UR;Lo;0;L;;;;;N;;;;;
+1E5E8;OL ONAL LETTER E;Lo;0;L;;;;;N;;;;;
+1E5E9;OL ONAL LETTER ES;Lo;0;L;;;;;N;;;;;
+1E5EA;OL ONAL LETTER EH;Lo;0;L;;;;;N;;;;;
+1E5EB;OL ONAL LETTER EC;Lo;0;L;;;;;N;;;;;
+1E5EC;OL ONAL LETTER ENN;Lo;0;L;;;;;N;;;;;
+1E5ED;OL ONAL LETTER EG;Lo;0;L;;;;;N;;;;;
+1E5EE;OL ONAL SIGN MU;Mn;230;NSM;;;;;N;;;;;
+1E5EF;OL ONAL SIGN IKIR;Mn;220;NSM;;;;;N;;;;;
+1E5F0;OL ONAL SIGN HODDOND;Lo;0;L;;;;;N;;;;;
+1E5F1;OL ONAL DIGIT ZERO;Nd;0;L;;0;0;0;N;;;;;
+1E5F2;OL ONAL DIGIT ONE;Nd;0;L;;1;1;1;N;;;;;
+1E5F3;OL ONAL DIGIT TWO;Nd;0;L;;2;2;2;N;;;;;
+1E5F4;OL ONAL DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;
+1E5F5;OL ONAL DIGIT FOUR;Nd;0;L;;4;4;4;N;;;;;
+1E5F6;OL ONAL DIGIT FIVE;Nd;0;L;;5;5;5;N;;;;;
+1E5F7;OL ONAL DIGIT SIX;Nd;0;L;;6;6;6;N;;;;;
+1E5F8;OL ONAL DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;;
+1E5F9;OL ONAL DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;;
+1E5FA;OL ONAL DIGIT NINE;Nd;0;L;;9;9;9;N;;;;;
+1E5FF;OL ONAL ABBREVIATION SIGN;Po;0;L;;;;;N;;;;;
+1E6C0;TAI YO LETTER LOW KO;Lo;0;L;;;;;N;;;;;
+1E6C1;TAI YO LETTER HIGH KO;Lo;0;L;;;;;N;;;;;
+1E6C2;TAI YO LETTER LOW KHO;Lo;0;L;;;;;N;;;;;
+1E6C3;TAI YO LETTER HIGH KHO;Lo;0;L;;;;;N;;;;;
+1E6C4;TAI YO LETTER GO;Lo;0;L;;;;;N;;;;;
+1E6C5;TAI YO LETTER NGO;Lo;0;L;;;;;N;;;;;
+1E6C6;TAI YO LETTER CO;Lo;0;L;;;;;N;;;;;
+1E6C7;TAI YO LETTER LOW XO;Lo;0;L;;;;;N;;;;;
+1E6C8;TAI YO LETTER HIGH XO;Lo;0;L;;;;;N;;;;;
+1E6C9;TAI YO LETTER LOW NYO;Lo;0;L;;;;;N;;;;;
+1E6CA;TAI YO LETTER HIGH NYO;Lo;0;L;;;;;N;;;;;
+1E6CB;TAI YO LETTER DO;Lo;0;L;;;;;N;;;;;
+1E6CC;TAI YO LETTER LOW TO;Lo;0;L;;;;;N;;;;;
+1E6CD;TAI YO LETTER HIGH TO;Lo;0;L;;;;;N;;;;;
+1E6CE;TAI YO LETTER THO;Lo;0;L;;;;;N;;;;;
+1E6CF;TAI YO LETTER NO;Lo;0;L;;;;;N;;;;;
+1E6D0;TAI YO LETTER BO;Lo;0;L;;;;;N;;;;;
+1E6D1;TAI YO LETTER LOW PO;Lo;0;L;;;;;N;;;;;
+1E6D2;TAI YO LETTER HIGH PO;Lo;0;L;;;;;N;;;;;
+1E6D3;TAI YO LETTER PHO;Lo;0;L;;;;;N;;;;;
+1E6D4;TAI YO LETTER LOW FO;Lo;0;L;;;;;N;;;;;
+1E6D5;TAI YO LETTER HIGH FO;Lo;0;L;;;;;N;;;;;
+1E6D6;TAI YO LETTER MO;Lo;0;L;;;;;N;;;;;
+1E6D7;TAI YO LETTER YO;Lo;0;L;;;;;N;;;;;
+1E6D8;TAI YO LETTER LO;Lo;0;L;;;;;N;;;;;
+1E6D9;TAI YO LETTER VO;Lo;0;L;;;;;N;;;;;
+1E6DA;TAI YO LETTER LOW HO;Lo;0;L;;;;;N;;;;;
+1E6DB;TAI YO LETTER HIGH HO;Lo;0;L;;;;;N;;;;;
+1E6DC;TAI YO LETTER QO;Lo;0;L;;;;;N;;;;;
+1E6DD;TAI YO LETTER LOW KVO;Lo;0;L;;;;;N;;;;;
+1E6DE;TAI YO LETTER HIGH KVO;Lo;0;L;;;;;N;;;;;
+1E6E0;TAI YO LETTER AA;Lo;0;L;;;;;N;;;;;
+1E6E1;TAI YO LETTER I;Lo;0;L;;;;;N;;;;;
+1E6E2;TAI YO LETTER UE;Lo;0;L;;;;;N;;;;;
+1E6E3;TAI YO SIGN UE;Mn;230;NSM;;;;;N;;;;;
+1E6E4;TAI YO LETTER U;Lo;0;L;;;;;N;;;;;
+1E6E5;TAI YO LETTER AE;Lo;0;L;;;;;N;;;;;
+1E6E6;TAI YO SIGN AU;Mn;230;NSM;;;;;N;;;;;
+1E6E7;TAI YO LETTER O;Lo;0;L;;;;;N;;;;;
+1E6E8;TAI YO LETTER E;Lo;0;L;;;;;N;;;;;
+1E6E9;TAI YO LETTER IA;Lo;0;L;;;;;N;;;;;
+1E6EA;TAI YO LETTER UEA;Lo;0;L;;;;;N;;;;;
+1E6EB;TAI YO LETTER UA;Lo;0;L;;;;;N;;;;;
+1E6EC;TAI YO LETTER OO;Lo;0;L;;;;;N;;;;;
+1E6ED;TAI YO LETTER AUE;Lo;0;L;;;;;N;;;;;
+1E6EE;TAI YO SIGN AY;Mn;230;NSM;;;;;N;;;;;
+1E6EF;TAI YO SIGN ANG;Mn;230;NSM;;;;;N;;;;;
+1E6F0;TAI YO LETTER AN;Lo;0;L;;;;;N;;;;;
+1E6F1;TAI YO LETTER AM;Lo;0;L;;;;;N;;;;;
+1E6F2;TAI YO LETTER AK;Lo;0;L;;;;;N;;;;;
+1E6F3;TAI YO LETTER AT;Lo;0;L;;;;;N;;;;;
+1E6F4;TAI YO LETTER AP;Lo;0;L;;;;;N;;;;;
+1E6F5;TAI YO SIGN OM;Mn;230;NSM;;;;;N;;;;;
+1E6FE;TAI YO SYMBOL MUEANG;Lo;0;L;;;;;N;;;;;
+1E6FF;TAI YO XAM LAI;Lm;0;L;;;;;N;;;;;
+1E7E0;ETHIOPIC SYLLABLE HHYA;Lo;0;L;;;;;N;;;;;
+1E7E1;ETHIOPIC SYLLABLE HHYU;Lo;0;L;;;;;N;;;;;
+1E7E2;ETHIOPIC SYLLABLE HHYI;Lo;0;L;;;;;N;;;;;
+1E7E3;ETHIOPIC SYLLABLE HHYAA;Lo;0;L;;;;;N;;;;;
+1E7E4;ETHIOPIC SYLLABLE HHYEE;Lo;0;L;;;;;N;;;;;
+1E7E5;ETHIOPIC SYLLABLE HHYE;Lo;0;L;;;;;N;;;;;
+1E7E6;ETHIOPIC SYLLABLE HHYO;Lo;0;L;;;;;N;;;;;
+1E7E8;ETHIOPIC SYLLABLE GURAGE HHWA;Lo;0;L;;;;;N;;;;;
+1E7E9;ETHIOPIC SYLLABLE HHWI;Lo;0;L;;;;;N;;;;;
+1E7EA;ETHIOPIC SYLLABLE HHWEE;Lo;0;L;;;;;N;;;;;
+1E7EB;ETHIOPIC SYLLABLE HHWE;Lo;0;L;;;;;N;;;;;
+1E7ED;ETHIOPIC SYLLABLE GURAGE MWI;Lo;0;L;;;;;N;;;;;
+1E7EE;ETHIOPIC SYLLABLE GURAGE MWEE;Lo;0;L;;;;;N;;;;;
+1E7F0;ETHIOPIC SYLLABLE GURAGE QWI;Lo;0;L;;;;;N;;;;;
+1E7F1;ETHIOPIC SYLLABLE GURAGE QWEE;Lo;0;L;;;;;N;;;;;
+1E7F2;ETHIOPIC SYLLABLE GURAGE QWE;Lo;0;L;;;;;N;;;;;
+1E7F3;ETHIOPIC SYLLABLE GURAGE BWI;Lo;0;L;;;;;N;;;;;
+1E7F4;ETHIOPIC SYLLABLE GURAGE BWEE;Lo;0;L;;;;;N;;;;;
+1E7F5;ETHIOPIC SYLLABLE GURAGE KWI;Lo;0;L;;;;;N;;;;;
+1E7F6;ETHIOPIC SYLLABLE GURAGE KWEE;Lo;0;L;;;;;N;;;;;
+1E7F7;ETHIOPIC SYLLABLE GURAGE KWE;Lo;0;L;;;;;N;;;;;
+1E7F8;ETHIOPIC SYLLABLE GURAGE GWI;Lo;0;L;;;;;N;;;;;
+1E7F9;ETHIOPIC SYLLABLE GURAGE GWEE;Lo;0;L;;;;;N;;;;;
+1E7FA;ETHIOPIC SYLLABLE GURAGE GWE;Lo;0;L;;;;;N;;;;;
+1E7FB;ETHIOPIC SYLLABLE GURAGE FWI;Lo;0;L;;;;;N;;;;;
+1E7FC;ETHIOPIC SYLLABLE GURAGE FWEE;Lo;0;L;;;;;N;;;;;
+1E7FD;ETHIOPIC SYLLABLE GURAGE PWI;Lo;0;L;;;;;N;;;;;
+1E7FE;ETHIOPIC SYLLABLE GURAGE PWEE;Lo;0;L;;;;;N;;;;;
 1E800;MENDE KIKAKUI SYLLABLE M001 KI;Lo;0;R;;;;;N;;;;;
 1E801;MENDE KIKAKUI SYLLABLE M002 KA;Lo;0;R;;;;;N;;;;;
 1E802;MENDE KIKAKUI SYLLABLE M003 KU;Lo;0;R;;;;;N;;;;;
@@ -24464,6 +36677,223 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1E8D4;MENDE KIKAKUI COMBINING NUMBER TEN THOUSANDS;Mn;220;NSM;;;;;N;;;;;
 1E8D5;MENDE KIKAKUI COMBINING NUMBER HUNDRED THOUSANDS;Mn;220;NSM;;;;;N;;;;;
 1E8D6;MENDE KIKAKUI COMBINING NUMBER MILLIONS;Mn;220;NSM;;;;;N;;;;;
+1E900;ADLAM CAPITAL LETTER ALIF;Lu;0;R;;;;;N;;;;1E922;
+1E901;ADLAM CAPITAL LETTER DAALI;Lu;0;R;;;;;N;;;;1E923;
+1E902;ADLAM CAPITAL LETTER LAAM;Lu;0;R;;;;;N;;;;1E924;
+1E903;ADLAM CAPITAL LETTER MIIM;Lu;0;R;;;;;N;;;;1E925;
+1E904;ADLAM CAPITAL LETTER BA;Lu;0;R;;;;;N;;;;1E926;
+1E905;ADLAM CAPITAL LETTER SINNYIIYHE;Lu;0;R;;;;;N;;;;1E927;
+1E906;ADLAM CAPITAL LETTER PE;Lu;0;R;;;;;N;;;;1E928;
+1E907;ADLAM CAPITAL LETTER BHE;Lu;0;R;;;;;N;;;;1E929;
+1E908;ADLAM CAPITAL LETTER RA;Lu;0;R;;;;;N;;;;1E92A;
+1E909;ADLAM CAPITAL LETTER E;Lu;0;R;;;;;N;;;;1E92B;
+1E90A;ADLAM CAPITAL LETTER FA;Lu;0;R;;;;;N;;;;1E92C;
+1E90B;ADLAM CAPITAL LETTER I;Lu;0;R;;;;;N;;;;1E92D;
+1E90C;ADLAM CAPITAL LETTER O;Lu;0;R;;;;;N;;;;1E92E;
+1E90D;ADLAM CAPITAL LETTER DHA;Lu;0;R;;;;;N;;;;1E92F;
+1E90E;ADLAM CAPITAL LETTER YHE;Lu;0;R;;;;;N;;;;1E930;
+1E90F;ADLAM CAPITAL LETTER WAW;Lu;0;R;;;;;N;;;;1E931;
+1E910;ADLAM CAPITAL LETTER NUN;Lu;0;R;;;;;N;;;;1E932;
+1E911;ADLAM CAPITAL LETTER KAF;Lu;0;R;;;;;N;;;;1E933;
+1E912;ADLAM CAPITAL LETTER YA;Lu;0;R;;;;;N;;;;1E934;
+1E913;ADLAM CAPITAL LETTER U;Lu;0;R;;;;;N;;;;1E935;
+1E914;ADLAM CAPITAL LETTER JIIM;Lu;0;R;;;;;N;;;;1E936;
+1E915;ADLAM CAPITAL LETTER CHI;Lu;0;R;;;;;N;;;;1E937;
+1E916;ADLAM CAPITAL LETTER HA;Lu;0;R;;;;;N;;;;1E938;
+1E917;ADLAM CAPITAL LETTER QAAF;Lu;0;R;;;;;N;;;;1E939;
+1E918;ADLAM CAPITAL LETTER GA;Lu;0;R;;;;;N;;;;1E93A;
+1E919;ADLAM CAPITAL LETTER NYA;Lu;0;R;;;;;N;;;;1E93B;
+1E91A;ADLAM CAPITAL LETTER TU;Lu;0;R;;;;;N;;;;1E93C;
+1E91B;ADLAM CAPITAL LETTER NHA;Lu;0;R;;;;;N;;;;1E93D;
+1E91C;ADLAM CAPITAL LETTER VA;Lu;0;R;;;;;N;;;;1E93E;
+1E91D;ADLAM CAPITAL LETTER KHA;Lu;0;R;;;;;N;;;;1E93F;
+1E91E;ADLAM CAPITAL LETTER GBE;Lu;0;R;;;;;N;;;;1E940;
+1E91F;ADLAM CAPITAL LETTER ZAL;Lu;0;R;;;;;N;;;;1E941;
+1E920;ADLAM CAPITAL LETTER KPO;Lu;0;R;;;;;N;;;;1E942;
+1E921;ADLAM CAPITAL LETTER SHA;Lu;0;R;;;;;N;;;;1E943;
+1E922;ADLAM SMALL LETTER ALIF;Ll;0;R;;;;;N;;;1E900;;1E900
+1E923;ADLAM SMALL LETTER DAALI;Ll;0;R;;;;;N;;;1E901;;1E901
+1E924;ADLAM SMALL LETTER LAAM;Ll;0;R;;;;;N;;;1E902;;1E902
+1E925;ADLAM SMALL LETTER MIIM;Ll;0;R;;;;;N;;;1E903;;1E903
+1E926;ADLAM SMALL LETTER BA;Ll;0;R;;;;;N;;;1E904;;1E904
+1E927;ADLAM SMALL LETTER SINNYIIYHE;Ll;0;R;;;;;N;;;1E905;;1E905
+1E928;ADLAM SMALL LETTER PE;Ll;0;R;;;;;N;;;1E906;;1E906
+1E929;ADLAM SMALL LETTER BHE;Ll;0;R;;;;;N;;;1E907;;1E907
+1E92A;ADLAM SMALL LETTER RA;Ll;0;R;;;;;N;;;1E908;;1E908
+1E92B;ADLAM SMALL LETTER E;Ll;0;R;;;;;N;;;1E909;;1E909
+1E92C;ADLAM SMALL LETTER FA;Ll;0;R;;;;;N;;;1E90A;;1E90A
+1E92D;ADLAM SMALL LETTER I;Ll;0;R;;;;;N;;;1E90B;;1E90B
+1E92E;ADLAM SMALL LETTER O;Ll;0;R;;;;;N;;;1E90C;;1E90C
+1E92F;ADLAM SMALL LETTER DHA;Ll;0;R;;;;;N;;;1E90D;;1E90D
+1E930;ADLAM SMALL LETTER YHE;Ll;0;R;;;;;N;;;1E90E;;1E90E
+1E931;ADLAM SMALL LETTER WAW;Ll;0;R;;;;;N;;;1E90F;;1E90F
+1E932;ADLAM SMALL LETTER NUN;Ll;0;R;;;;;N;;;1E910;;1E910
+1E933;ADLAM SMALL LETTER KAF;Ll;0;R;;;;;N;;;1E911;;1E911
+1E934;ADLAM SMALL LETTER YA;Ll;0;R;;;;;N;;;1E912;;1E912
+1E935;ADLAM SMALL LETTER U;Ll;0;R;;;;;N;;;1E913;;1E913
+1E936;ADLAM SMALL LETTER JIIM;Ll;0;R;;;;;N;;;1E914;;1E914
+1E937;ADLAM SMALL LETTER CHI;Ll;0;R;;;;;N;;;1E915;;1E915
+1E938;ADLAM SMALL LETTER HA;Ll;0;R;;;;;N;;;1E916;;1E916
+1E939;ADLAM SMALL LETTER QAAF;Ll;0;R;;;;;N;;;1E917;;1E917
+1E93A;ADLAM SMALL LETTER GA;Ll;0;R;;;;;N;;;1E918;;1E918
+1E93B;ADLAM SMALL LETTER NYA;Ll;0;R;;;;;N;;;1E919;;1E919
+1E93C;ADLAM SMALL LETTER TU;Ll;0;R;;;;;N;;;1E91A;;1E91A
+1E93D;ADLAM SMALL LETTER NHA;Ll;0;R;;;;;N;;;1E91B;;1E91B
+1E93E;ADLAM SMALL LETTER VA;Ll;0;R;;;;;N;;;1E91C;;1E91C
+1E93F;ADLAM SMALL LETTER KHA;Ll;0;R;;;;;N;;;1E91D;;1E91D
+1E940;ADLAM SMALL LETTER GBE;Ll;0;R;;;;;N;;;1E91E;;1E91E
+1E941;ADLAM SMALL LETTER ZAL;Ll;0;R;;;;;N;;;1E91F;;1E91F
+1E942;ADLAM SMALL LETTER KPO;Ll;0;R;;;;;N;;;1E920;;1E920
+1E943;ADLAM SMALL LETTER SHA;Ll;0;R;;;;;N;;;1E921;;1E921
+1E944;ADLAM ALIF LENGTHENER;Mn;230;NSM;;;;;N;;;;;
+1E945;ADLAM VOWEL LENGTHENER;Mn;230;NSM;;;;;N;;;;;
+1E946;ADLAM GEMINATION MARK;Mn;230;NSM;;;;;N;;;;;
+1E947;ADLAM HAMZA;Mn;230;NSM;;;;;N;;;;;
+1E948;ADLAM CONSONANT MODIFIER;Mn;230;NSM;;;;;N;;;;;
+1E949;ADLAM GEMINATE CONSONANT MODIFIER;Mn;230;NSM;;;;;N;;;;;
+1E94A;ADLAM NUKTA;Mn;7;NSM;;;;;N;;;;;
+1E94B;ADLAM NASALIZATION MARK;Lm;0;R;;;;;N;;;;;
+1E950;ADLAM DIGIT ZERO;Nd;0;R;;0;0;0;N;;;;;
+1E951;ADLAM DIGIT ONE;Nd;0;R;;1;1;1;N;;;;;
+1E952;ADLAM DIGIT TWO;Nd;0;R;;2;2;2;N;;;;;
+1E953;ADLAM DIGIT THREE;Nd;0;R;;3;3;3;N;;;;;
+1E954;ADLAM DIGIT FOUR;Nd;0;R;;4;4;4;N;;;;;
+1E955;ADLAM DIGIT FIVE;Nd;0;R;;5;5;5;N;;;;;
+1E956;ADLAM DIGIT SIX;Nd;0;R;;6;6;6;N;;;;;
+1E957;ADLAM DIGIT SEVEN;Nd;0;R;;7;7;7;N;;;;;
+1E958;ADLAM DIGIT EIGHT;Nd;0;R;;8;8;8;N;;;;;
+1E959;ADLAM DIGIT NINE;Nd;0;R;;9;9;9;N;;;;;
+1E95E;ADLAM INITIAL EXCLAMATION MARK;Po;0;R;;;;;N;;;;;
+1E95F;ADLAM INITIAL QUESTION MARK;Po;0;R;;;;;N;;;;;
+1EC71;INDIC SIYAQ NUMBER ONE;No;0;AL;;;;1;N;;;;;
+1EC72;INDIC SIYAQ NUMBER TWO;No;0;AL;;;;2;N;;;;;
+1EC73;INDIC SIYAQ NUMBER THREE;No;0;AL;;;;3;N;;;;;
+1EC74;INDIC SIYAQ NUMBER FOUR;No;0;AL;;;;4;N;;;;;
+1EC75;INDIC SIYAQ NUMBER FIVE;No;0;AL;;;;5;N;;;;;
+1EC76;INDIC SIYAQ NUMBER SIX;No;0;AL;;;;6;N;;;;;
+1EC77;INDIC SIYAQ NUMBER SEVEN;No;0;AL;;;;7;N;;;;;
+1EC78;INDIC SIYAQ NUMBER EIGHT;No;0;AL;;;;8;N;;;;;
+1EC79;INDIC SIYAQ NUMBER NINE;No;0;AL;;;;9;N;;;;;
+1EC7A;INDIC SIYAQ NUMBER TEN;No;0;AL;;;;10;N;;;;;
+1EC7B;INDIC SIYAQ NUMBER TWENTY;No;0;AL;;;;20;N;;;;;
+1EC7C;INDIC SIYAQ NUMBER THIRTY;No;0;AL;;;;30;N;;;;;
+1EC7D;INDIC SIYAQ NUMBER FORTY;No;0;AL;;;;40;N;;;;;
+1EC7E;INDIC SIYAQ NUMBER FIFTY;No;0;AL;;;;50;N;;;;;
+1EC7F;INDIC SIYAQ NUMBER SIXTY;No;0;AL;;;;60;N;;;;;
+1EC80;INDIC SIYAQ NUMBER SEVENTY;No;0;AL;;;;70;N;;;;;
+1EC81;INDIC SIYAQ NUMBER EIGHTY;No;0;AL;;;;80;N;;;;;
+1EC82;INDIC SIYAQ NUMBER NINETY;No;0;AL;;;;90;N;;;;;
+1EC83;INDIC SIYAQ NUMBER ONE HUNDRED;No;0;AL;;;;100;N;;;;;
+1EC84;INDIC SIYAQ NUMBER TWO HUNDRED;No;0;AL;;;;200;N;;;;;
+1EC85;INDIC SIYAQ NUMBER THREE HUNDRED;No;0;AL;;;;300;N;;;;;
+1EC86;INDIC SIYAQ NUMBER FOUR HUNDRED;No;0;AL;;;;400;N;;;;;
+1EC87;INDIC SIYAQ NUMBER FIVE HUNDRED;No;0;AL;;;;500;N;;;;;
+1EC88;INDIC SIYAQ NUMBER SIX HUNDRED;No;0;AL;;;;600;N;;;;;
+1EC89;INDIC SIYAQ NUMBER SEVEN HUNDRED;No;0;AL;;;;700;N;;;;;
+1EC8A;INDIC SIYAQ NUMBER EIGHT HUNDRED;No;0;AL;;;;800;N;;;;;
+1EC8B;INDIC SIYAQ NUMBER NINE HUNDRED;No;0;AL;;;;900;N;;;;;
+1EC8C;INDIC SIYAQ NUMBER ONE THOUSAND;No;0;AL;;;;1000;N;;;;;
+1EC8D;INDIC SIYAQ NUMBER TWO THOUSAND;No;0;AL;;;;2000;N;;;;;
+1EC8E;INDIC SIYAQ NUMBER THREE THOUSAND;No;0;AL;;;;3000;N;;;;;
+1EC8F;INDIC SIYAQ NUMBER FOUR THOUSAND;No;0;AL;;;;4000;N;;;;;
+1EC90;INDIC SIYAQ NUMBER FIVE THOUSAND;No;0;AL;;;;5000;N;;;;;
+1EC91;INDIC SIYAQ NUMBER SIX THOUSAND;No;0;AL;;;;6000;N;;;;;
+1EC92;INDIC SIYAQ NUMBER SEVEN THOUSAND;No;0;AL;;;;7000;N;;;;;
+1EC93;INDIC SIYAQ NUMBER EIGHT THOUSAND;No;0;AL;;;;8000;N;;;;;
+1EC94;INDIC SIYAQ NUMBER NINE THOUSAND;No;0;AL;;;;9000;N;;;;;
+1EC95;INDIC SIYAQ NUMBER TEN THOUSAND;No;0;AL;;;;10000;N;;;;;
+1EC96;INDIC SIYAQ NUMBER TWENTY THOUSAND;No;0;AL;;;;20000;N;;;;;
+1EC97;INDIC SIYAQ NUMBER THIRTY THOUSAND;No;0;AL;;;;30000;N;;;;;
+1EC98;INDIC SIYAQ NUMBER FORTY THOUSAND;No;0;AL;;;;40000;N;;;;;
+1EC99;INDIC SIYAQ NUMBER FIFTY THOUSAND;No;0;AL;;;;50000;N;;;;;
+1EC9A;INDIC SIYAQ NUMBER SIXTY THOUSAND;No;0;AL;;;;60000;N;;;;;
+1EC9B;INDIC SIYAQ NUMBER SEVENTY THOUSAND;No;0;AL;;;;70000;N;;;;;
+1EC9C;INDIC SIYAQ NUMBER EIGHTY THOUSAND;No;0;AL;;;;80000;N;;;;;
+1EC9D;INDIC SIYAQ NUMBER NINETY THOUSAND;No;0;AL;;;;90000;N;;;;;
+1EC9E;INDIC SIYAQ NUMBER LAKH;No;0;AL;;;;100000;N;;;;;
+1EC9F;INDIC SIYAQ NUMBER LAKHAN;No;0;AL;;;;200000;N;;;;;
+1ECA0;INDIC SIYAQ LAKH MARK;No;0;AL;;;;100000;N;;;;;
+1ECA1;INDIC SIYAQ NUMBER KAROR;No;0;AL;;;;10000000;N;;;;;
+1ECA2;INDIC SIYAQ NUMBER KARORAN;No;0;AL;;;;20000000;N;;;;;
+1ECA3;INDIC SIYAQ NUMBER PREFIXED ONE;No;0;AL;;;;1;N;;;;;
+1ECA4;INDIC SIYAQ NUMBER PREFIXED TWO;No;0;AL;;;;2;N;;;;;
+1ECA5;INDIC SIYAQ NUMBER PREFIXED THREE;No;0;AL;;;;3;N;;;;;
+1ECA6;INDIC SIYAQ NUMBER PREFIXED FOUR;No;0;AL;;;;4;N;;;;;
+1ECA7;INDIC SIYAQ NUMBER PREFIXED FIVE;No;0;AL;;;;5;N;;;;;
+1ECA8;INDIC SIYAQ NUMBER PREFIXED SIX;No;0;AL;;;;6;N;;;;;
+1ECA9;INDIC SIYAQ NUMBER PREFIXED SEVEN;No;0;AL;;;;7;N;;;;;
+1ECAA;INDIC SIYAQ NUMBER PREFIXED EIGHT;No;0;AL;;;;8;N;;;;;
+1ECAB;INDIC SIYAQ NUMBER PREFIXED NINE;No;0;AL;;;;9;N;;;;;
+1ECAC;INDIC SIYAQ PLACEHOLDER;So;0;AL;;;;;N;;;;;
+1ECAD;INDIC SIYAQ FRACTION ONE QUARTER;No;0;AL;;;;1/4;N;;;;;
+1ECAE;INDIC SIYAQ FRACTION ONE HALF;No;0;AL;;;;1/2;N;;;;;
+1ECAF;INDIC SIYAQ FRACTION THREE QUARTERS;No;0;AL;;;;3/4;N;;;;;
+1ECB0;INDIC SIYAQ RUPEE MARK;Sc;0;AL;;;;;N;;;;;
+1ECB1;INDIC SIYAQ NUMBER ALTERNATE ONE;No;0;AL;;;;1;N;;;;;
+1ECB2;INDIC SIYAQ NUMBER ALTERNATE TWO;No;0;AL;;;;2;N;;;;;
+1ECB3;INDIC SIYAQ NUMBER ALTERNATE TEN THOUSAND;No;0;AL;;;;10000;N;;;;;
+1ECB4;INDIC SIYAQ ALTERNATE LAKH MARK;No;0;AL;;;;100000;N;;;;;
+1ED01;OTTOMAN SIYAQ NUMBER ONE;No;0;AL;;;;1;N;;;;;
+1ED02;OTTOMAN SIYAQ NUMBER TWO;No;0;AL;;;;2;N;;;;;
+1ED03;OTTOMAN SIYAQ NUMBER THREE;No;0;AL;;;;3;N;;;;;
+1ED04;OTTOMAN SIYAQ NUMBER FOUR;No;0;AL;;;;4;N;;;;;
+1ED05;OTTOMAN SIYAQ NUMBER FIVE;No;0;AL;;;;5;N;;;;;
+1ED06;OTTOMAN SIYAQ NUMBER SIX;No;0;AL;;;;6;N;;;;;
+1ED07;OTTOMAN SIYAQ NUMBER SEVEN;No;0;AL;;;;7;N;;;;;
+1ED08;OTTOMAN SIYAQ NUMBER EIGHT;No;0;AL;;;;8;N;;;;;
+1ED09;OTTOMAN SIYAQ NUMBER NINE;No;0;AL;;;;9;N;;;;;
+1ED0A;OTTOMAN SIYAQ NUMBER TEN;No;0;AL;;;;10;N;;;;;
+1ED0B;OTTOMAN SIYAQ NUMBER TWENTY;No;0;AL;;;;20;N;;;;;
+1ED0C;OTTOMAN SIYAQ NUMBER THIRTY;No;0;AL;;;;30;N;;;;;
+1ED0D;OTTOMAN SIYAQ NUMBER FORTY;No;0;AL;;;;40;N;;;;;
+1ED0E;OTTOMAN SIYAQ NUMBER FIFTY;No;0;AL;;;;50;N;;;;;
+1ED0F;OTTOMAN SIYAQ NUMBER SIXTY;No;0;AL;;;;60;N;;;;;
+1ED10;OTTOMAN SIYAQ NUMBER SEVENTY;No;0;AL;;;;70;N;;;;;
+1ED11;OTTOMAN SIYAQ NUMBER EIGHTY;No;0;AL;;;;80;N;;;;;
+1ED12;OTTOMAN SIYAQ NUMBER NINETY;No;0;AL;;;;90;N;;;;;
+1ED13;OTTOMAN SIYAQ NUMBER ONE HUNDRED;No;0;AL;;;;100;N;;;;;
+1ED14;OTTOMAN SIYAQ NUMBER TWO HUNDRED;No;0;AL;;;;200;N;;;;;
+1ED15;OTTOMAN SIYAQ NUMBER THREE HUNDRED;No;0;AL;;;;300;N;;;;;
+1ED16;OTTOMAN SIYAQ NUMBER FOUR HUNDRED;No;0;AL;;;;400;N;;;;;
+1ED17;OTTOMAN SIYAQ NUMBER FIVE HUNDRED;No;0;AL;;;;500;N;;;;;
+1ED18;OTTOMAN SIYAQ NUMBER SIX HUNDRED;No;0;AL;;;;600;N;;;;;
+1ED19;OTTOMAN SIYAQ NUMBER SEVEN HUNDRED;No;0;AL;;;;700;N;;;;;
+1ED1A;OTTOMAN SIYAQ NUMBER EIGHT HUNDRED;No;0;AL;;;;800;N;;;;;
+1ED1B;OTTOMAN SIYAQ NUMBER NINE HUNDRED;No;0;AL;;;;900;N;;;;;
+1ED1C;OTTOMAN SIYAQ NUMBER ONE THOUSAND;No;0;AL;;;;1000;N;;;;;
+1ED1D;OTTOMAN SIYAQ NUMBER TWO THOUSAND;No;0;AL;;;;2000;N;;;;;
+1ED1E;OTTOMAN SIYAQ NUMBER THREE THOUSAND;No;0;AL;;;;3000;N;;;;;
+1ED1F;OTTOMAN SIYAQ NUMBER FOUR THOUSAND;No;0;AL;;;;4000;N;;;;;
+1ED20;OTTOMAN SIYAQ NUMBER FIVE THOUSAND;No;0;AL;;;;5000;N;;;;;
+1ED21;OTTOMAN SIYAQ NUMBER SIX THOUSAND;No;0;AL;;;;6000;N;;;;;
+1ED22;OTTOMAN SIYAQ NUMBER SEVEN THOUSAND;No;0;AL;;;;7000;N;;;;;
+1ED23;OTTOMAN SIYAQ NUMBER EIGHT THOUSAND;No;0;AL;;;;8000;N;;;;;
+1ED24;OTTOMAN SIYAQ NUMBER NINE THOUSAND;No;0;AL;;;;9000;N;;;;;
+1ED25;OTTOMAN SIYAQ NUMBER TEN THOUSAND;No;0;AL;;;;10000;N;;;;;
+1ED26;OTTOMAN SIYAQ NUMBER TWENTY THOUSAND;No;0;AL;;;;20000;N;;;;;
+1ED27;OTTOMAN SIYAQ NUMBER THIRTY THOUSAND;No;0;AL;;;;30000;N;;;;;
+1ED28;OTTOMAN SIYAQ NUMBER FORTY THOUSAND;No;0;AL;;;;40000;N;;;;;
+1ED29;OTTOMAN SIYAQ NUMBER FIFTY THOUSAND;No;0;AL;;;;50000;N;;;;;
+1ED2A;OTTOMAN SIYAQ NUMBER SIXTY THOUSAND;No;0;AL;;;;60000;N;;;;;
+1ED2B;OTTOMAN SIYAQ NUMBER SEVENTY THOUSAND;No;0;AL;;;;70000;N;;;;;
+1ED2C;OTTOMAN SIYAQ NUMBER EIGHTY THOUSAND;No;0;AL;;;;80000;N;;;;;
+1ED2D;OTTOMAN SIYAQ NUMBER NINETY THOUSAND;No;0;AL;;;;90000;N;;;;;
+1ED2E;OTTOMAN SIYAQ MARRATAN;So;0;AL;;;;;N;;;;;
+1ED2F;OTTOMAN SIYAQ ALTERNATE NUMBER TWO;No;0;AL;;;;2;N;;;;;
+1ED30;OTTOMAN SIYAQ ALTERNATE NUMBER THREE;No;0;AL;;;;3;N;;;;;
+1ED31;OTTOMAN SIYAQ ALTERNATE NUMBER FOUR;No;0;AL;;;;4;N;;;;;
+1ED32;OTTOMAN SIYAQ ALTERNATE NUMBER FIVE;No;0;AL;;;;5;N;;;;;
+1ED33;OTTOMAN SIYAQ ALTERNATE NUMBER SIX;No;0;AL;;;;6;N;;;;;
+1ED34;OTTOMAN SIYAQ ALTERNATE NUMBER SEVEN;No;0;AL;;;;7;N;;;;;
+1ED35;OTTOMAN SIYAQ ALTERNATE NUMBER EIGHT;No;0;AL;;;;8;N;;;;;
+1ED36;OTTOMAN SIYAQ ALTERNATE NUMBER NINE;No;0;AL;;;;9;N;;;;;
+1ED37;OTTOMAN SIYAQ ALTERNATE NUMBER TEN;No;0;AL;;;;10;N;;;;;
+1ED38;OTTOMAN SIYAQ ALTERNATE NUMBER FOUR HUNDRED;No;0;AL;;;;400;N;;;;;
+1ED39;OTTOMAN SIYAQ ALTERNATE NUMBER SIX HUNDRED;No;0;AL;;;;600;N;;;;;
+1ED3A;OTTOMAN SIYAQ ALTERNATE NUMBER TWO THOUSAND;No;0;AL;;;;2000;N;;;;;
+1ED3B;OTTOMAN SIYAQ ALTERNATE NUMBER TEN THOUSAND;No;0;AL;;;;10000;N;;;;;
+1ED3C;OTTOMAN SIYAQ FRACTION ONE HALF;No;0;AL;;;;1/2;N;;;;;
+1ED3D;OTTOMAN SIYAQ FRACTION ONE SIXTH;No;0;AL;;;;1/6;N;;;;;
 1EE00;ARABIC MATHEMATICAL ALEF;Lo;0;AL;<font> 0627;;;;N;;;;;
 1EE01;ARABIC MATHEMATICAL BEH;Lo;0;AL;<font> 0628;;;;N;;;;;
 1EE02;ARABIC MATHEMATICAL JEEM;Lo;0;AL;<font> 062C;;;;N;;;;;
@@ -24846,6 +37276,9 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F10A;DIGIT NINE COMMA;No;0;EN;<compat> 0039 002C;;9;9;N;;;;;
 1F10B;DINGBAT CIRCLED SANS-SERIF DIGIT ZERO;No;0;ON;;;;0;N;;;;;
 1F10C;DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ZERO;No;0;ON;;;;0;N;;;;;
+1F10D;CIRCLED ZERO WITH SLASH;So;0;ON;;;;;N;;;;;
+1F10E;CIRCLED ANTICLOCKWISE ARROW;So;0;ON;;;;;N;;;;;
+1F10F;CIRCLED DOLLAR SIGN WITH OVERLAID BACKSLASH;So;0;ON;;;;;N;;;;;
 1F110;PARENTHESIZED LATIN CAPITAL LETTER A;So;0;L;<compat> 0028 0041 0029;;;;N;;;;;
 1F111;PARENTHESIZED LATIN CAPITAL LETTER B;So;0;L;<compat> 0028 0042 0029;;;;N;;;;;
 1F112;PARENTHESIZED LATIN CAPITAL LETTER C;So;0;L;<compat> 0028 0043 0029;;;;N;;;;;
@@ -24877,6 +37310,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F12C;CIRCLED ITALIC LATIN CAPITAL LETTER R;So;0;L;<circle> 0052;;;;N;;;;;
 1F12D;CIRCLED CD;So;0;L;<circle> 0043 0044;;;;N;;;;;
 1F12E;CIRCLED WZ;So;0;L;<circle> 0057 005A;;;;N;;;;;
+1F12F;COPYLEFT SYMBOL;So;0;ON;;;;;N;;;;;
 1F130;SQUARED LATIN CAPITAL LETTER A;So;0;L;<square> 0041;;;;N;;;;;
 1F131;SQUARED LATIN CAPITAL LETTER B;So;0;L;<square> 0042;;;;N;;;;;
 1F132;SQUARED LATIN CAPITAL LETTER C;So;0;L;<square> 0043;;;;N;;;;;
@@ -24937,6 +37371,10 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F169;NEGATIVE CIRCLED LATIN CAPITAL LETTER Z;So;0;L;;;;;N;;;;;
 1F16A;RAISED MC SIGN;So;0;ON;<super> 004D 0043;;;;N;;;;;
 1F16B;RAISED MD SIGN;So;0;ON;<super> 004D 0044;;;;N;;;;;
+1F16C;RAISED MR SIGN;So;0;ON;<super> 004D 0052;;;;N;;;;;
+1F16D;CIRCLED CC;So;0;ON;;;;;N;;;;;
+1F16E;CIRCLED C WITH OVERLAID BACKSLASH;So;0;ON;;;;;N;;;;;
+1F16F;CIRCLED HUMAN FIGURE;So;0;ON;;;;;N;;;;;
 1F170;NEGATIVE SQUARED LATIN CAPITAL LETTER A;So;0;L;;;;;N;;;;;
 1F171;NEGATIVE SQUARED LATIN CAPITAL LETTER B;So;0;L;;;;;N;;;;;
 1F172;NEGATIVE SQUARED LATIN CAPITAL LETTER C;So;0;L;;;;;N;;;;;
@@ -24980,6 +37418,25 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F198;SQUARED SOS;So;0;L;;;;;N;;;;;
 1F199;SQUARED UP WITH EXCLAMATION MARK;So;0;L;;;;;N;;;;;
 1F19A;SQUARED VS;So;0;L;;;;;N;;;;;
+1F19B;SQUARED THREE D;So;0;L;;;;;N;;;;;
+1F19C;SQUARED SECOND SCREEN;So;0;L;;;;;N;;;;;
+1F19D;SQUARED TWO K;So;0;L;;;;;N;;;;;
+1F19E;SQUARED FOUR K;So;0;L;;;;;N;;;;;
+1F19F;SQUARED EIGHT K;So;0;L;;;;;N;;;;;
+1F1A0;SQUARED FIVE POINT ONE;So;0;L;;;;;N;;;;;
+1F1A1;SQUARED SEVEN POINT ONE;So;0;L;;;;;N;;;;;
+1F1A2;SQUARED TWENTY-TWO POINT TWO;So;0;L;;;;;N;;;;;
+1F1A3;SQUARED SIXTY P;So;0;L;;;;;N;;;;;
+1F1A4;SQUARED ONE HUNDRED TWENTY P;So;0;L;;;;;N;;;;;
+1F1A5;SQUARED LATIN SMALL LETTER D;So;0;L;;;;;N;;;;;
+1F1A6;SQUARED HC;So;0;L;;;;;N;;;;;
+1F1A7;SQUARED HDR;So;0;L;;;;;N;;;;;
+1F1A8;SQUARED HI-RES;So;0;L;;;;;N;;;;;
+1F1A9;SQUARED LOSSLESS;So;0;L;;;;;N;;;;;
+1F1AA;SQUARED SHV;So;0;L;;;;;N;;;;;
+1F1AB;SQUARED UHD;So;0;L;;;;;N;;;;;
+1F1AC;SQUARED VOD;So;0;L;;;;;N;;;;;
+1F1AD;MASK WORK SYMBOL;So;0;ON;;;;;N;;;;;
 1F1E6;REGIONAL INDICATOR SYMBOL LETTER A;So;0;L;;;;;N;;;;;
 1F1E7;REGIONAL INDICATOR SYMBOL LETTER B;So;0;L;;;;;N;;;;;
 1F1E8;REGIONAL INDICATOR SYMBOL LETTER C;So;0;L;;;;;N;;;;;
@@ -25052,6 +37509,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F238;SQUARED CJK UNIFIED IDEOGRAPH-7533;So;0;L;<square> 7533;;;;N;;;;;
 1F239;SQUARED CJK UNIFIED IDEOGRAPH-5272;So;0;L;<square> 5272;;;;N;;;;;
 1F23A;SQUARED CJK UNIFIED IDEOGRAPH-55B6;So;0;L;<square> 55B6;;;;N;;;;;
+1F23B;SQUARED CJK UNIFIED IDEOGRAPH-914D;So;0;L;<square> 914D;;;;N;;;;;
 1F240;TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-672C;So;0;L;<compat> 3014 672C 3015;;;;N;;;;;
 1F241;TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-4E09;So;0;L;<compat> 3014 4E09 3015;;;;N;;;;;
 1F242;TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-4E8C;So;0;L;<compat> 3014 4E8C 3015;;;;N;;;;;
@@ -25063,6 +37521,12 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F248;TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-6557;So;0;L;<compat> 3014 6557 3015;;;;N;;;;;
 1F250;CIRCLED IDEOGRAPH ADVANTAGE;So;0;L;<circle> 5F97;;;;N;;;;;
 1F251;CIRCLED IDEOGRAPH ACCEPT;So;0;L;<circle> 53EF;;;;N;;;;;
+1F260;ROUNDED SYMBOL FOR FU;So;0;ON;;;;;N;;;;;
+1F261;ROUNDED SYMBOL FOR LU;So;0;ON;;;;;N;;;;;
+1F262;ROUNDED SYMBOL FOR SHOU;So;0;ON;;;;;N;;;;;
+1F263;ROUNDED SYMBOL FOR XI;So;0;ON;;;;;N;;;;;
+1F264;ROUNDED SYMBOL FOR SHUANGXI;So;0;ON;;;;;N;;;;;
+1F265;ROUNDED SYMBOL FOR CAI;So;0;ON;;;;;N;;;;;
 1F300;CYCLONE;So;0;ON;;;;;N;;;;;
 1F301;FOGGY;So;0;ON;;;;;N;;;;;
 1F302;CLOSED UMBRELLA;So;0;ON;;;;;N;;;;;
@@ -25108,6 +37572,9 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F32A;CLOUD WITH TORNADO;So;0;ON;;;;;N;;;;;
 1F32B;FOG;So;0;ON;;;;;N;;;;;
 1F32C;WIND BLOWING FACE;So;0;ON;;;;;N;;;;;
+1F32D;HOT DOG;So;0;ON;;;;;N;;;;;
+1F32E;TACO;So;0;ON;;;;;N;;;;;
+1F32F;BURRITO;So;0;ON;;;;;N;;;;;
 1F330;CHESTNUT;So;0;ON;;;;;N;;;;;
 1F331;SEEDLING;So;0;ON;;;;;N;;;;;
 1F332;EVERGREEN TREE;So;0;ON;;;;;N;;;;;
@@ -25186,6 +37653,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F37B;CLINKING BEER MUGS;So;0;ON;;;;;N;;;;;
 1F37C;BABY BOTTLE;So;0;ON;;;;;N;;;;;
 1F37D;FORK AND KNIFE WITH PLATE;So;0;ON;;;;;N;;;;;
+1F37E;BOTTLE WITH POPPING CORK;So;0;ON;;;;;N;;;;;
+1F37F;POPCORN;So;0;ON;;;;;N;;;;;
 1F380;RIBBON;So;0;ON;;;;;N;;;;;
 1F381;WRAPPED PRESENT;So;0;ON;;;;;N;;;;;
 1F382;BIRTHDAY CAKE;So;0;ON;;;;;N;;;;;
@@ -25265,6 +37734,11 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F3CC;GOLFER;So;0;ON;;;;;N;;;;;
 1F3CD;RACING MOTORCYCLE;So;0;ON;;;;;N;;;;;
 1F3CE;RACING CAR;So;0;ON;;;;;N;;;;;
+1F3CF;CRICKET BAT AND BALL;So;0;ON;;;;;N;;;;;
+1F3D0;VOLLEYBALL;So;0;ON;;;;;N;;;;;
+1F3D1;FIELD HOCKEY STICK AND BALL;So;0;ON;;;;;N;;;;;
+1F3D2;ICE HOCKEY STICK AND PUCK;So;0;ON;;;;;N;;;;;
+1F3D3;TABLE TENNIS PADDLE AND BALL;So;0;ON;;;;;N;;;;;
 1F3D4;SNOW CAPPED MOUNTAIN;So;0;ON;;;;;N;;;;;
 1F3D5;CAMPING;So;0;ON;;;;;N;;;;;
 1F3D6;BEACH WITH UMBRELLA;So;0;ON;;;;;N;;;;;
@@ -25301,6 +37775,14 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F3F5;ROSETTE;So;0;ON;;;;;N;;;;;
 1F3F6;BLACK ROSETTE;So;0;ON;;;;;N;;;;;
 1F3F7;LABEL;So;0;ON;;;;;N;;;;;
+1F3F8;BADMINTON RACQUET AND SHUTTLECOCK;So;0;ON;;;;;N;;;;;
+1F3F9;BOW AND ARROW;So;0;ON;;;;;N;;;;;
+1F3FA;AMPHORA;So;0;ON;;;;;N;;;;;
+1F3FB;EMOJI MODIFIER FITZPATRICK TYPE-1-2;Sk;0;ON;;;;;N;;;;;
+1F3FC;EMOJI MODIFIER FITZPATRICK TYPE-3;Sk;0;ON;;;;;N;;;;;
+1F3FD;EMOJI MODIFIER FITZPATRICK TYPE-4;Sk;0;ON;;;;;N;;;;;
+1F3FE;EMOJI MODIFIER FITZPATRICK TYPE-5;Sk;0;ON;;;;;N;;;;;
+1F3FF;EMOJI MODIFIER FITZPATRICK TYPE-6;Sk;0;ON;;;;;N;;;;;
 1F400;RAT;So;0;ON;;;;;N;;;;;
 1F401;MOUSE;So;0;ON;;;;;N;;;;;
 1F402;OX;So;0;ON;;;;;N;;;;;
@@ -25556,6 +38038,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F4FC;VIDEOCASSETTE;So;0;ON;;;;;N;;;;;
 1F4FD;FILM PROJECTOR;So;0;ON;;;;;N;;;;;
 1F4FE;PORTABLE STEREO;So;0;ON;;;;;N;;;;;
+1F4FF;PRAYER BEADS;So;0;ON;;;;;N;;;;;
 1F500;TWISTED RIGHTWARDS ARROWS;So;0;ON;;;;;N;;;;;
 1F501;CLOCKWISE RIGHTWARDS AND LEFTWARDS OPEN CIRCLE ARROWS;So;0;ON;;;;;N;;;;;
 1F502;CLOCKWISE RIGHTWARDS AND LEFTWARDS OPEN CIRCLE ARROWS WITH CIRCLED ONE OVERLAY;So;0;ON;;;;;N;;;;;
@@ -25631,6 +38114,11 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F548;CELTIC CROSS;So;0;ON;;;;;N;;;;;
 1F549;OM SYMBOL;So;0;ON;;;;;N;;;;;
 1F54A;DOVE OF PEACE;So;0;ON;;;;;N;;;;;
+1F54B;KAABA;So;0;ON;;;;;N;;;;;
+1F54C;MOSQUE;So;0;ON;;;;;N;;;;;
+1F54D;SYNAGOGUE;So;0;ON;;;;;N;;;;;
+1F54E;MENORAH WITH NINE BRANCHES;So;0;ON;;;;;N;;;;;
+1F54F;BOWL OF HYGIEIA;So;0;ON;;;;;N;;;;;
 1F550;CLOCK FACE ONE OCLOCK;So;0;ON;;;;;N;;;;;
 1F551;CLOCK FACE TWO OCLOCK;So;0;ON;;;;;N;;;;;
 1F552;CLOCK FACE THREE OCLOCK;So;0;ON;;;;;N;;;;;
@@ -25673,6 +38161,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F577;SPIDER;So;0;ON;;;;;N;;;;;
 1F578;SPIDER WEB;So;0;ON;;;;;N;;;;;
 1F579;JOYSTICK;So;0;ON;;;;;N;;;;;
+1F57A;MAN DANCING;So;0;ON;;;;;N;;;;;
 1F57B;LEFT HAND TELEPHONE RECEIVER;So;0;ON;;;;;N;;;;;
 1F57C;TELEPHONE RECEIVER WITH PAGE;So;0;ON;;;;;N;;;;;
 1F57D;RIGHT HAND TELEPHONE RECEIVER;So;0;ON;;;;;N;;;;;
@@ -25714,6 +38203,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F5A1;SIDEWAYS BLACK DOWN POINTING INDEX;So;0;ON;;;;;N;;;;;
 1F5A2;BLACK UP POINTING BACKHAND INDEX;So;0;ON;;;;;N;;;;;
 1F5A3;BLACK DOWN POINTING BACKHAND INDEX;So;0;ON;;;;;N;;;;;
+1F5A4;BLACK HEART;So;0;ON;;;;;N;;;;;
 1F5A5;DESKTOP COMPUTER;So;0;ON;;;;;N;;;;;
 1F5A6;KEYBOARD AND MOUSE;So;0;ON;;;;;N;;;;;
 1F5A7;THREE NETWORKED COMPUTERS;So;0;ON;;;;;N;;;;;
@@ -25872,6 +38362,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F640;WEARY CAT FACE;So;0;ON;;;;;N;;;;;
 1F641;SLIGHTLY FROWNING FACE;So;0;ON;;;;;N;;;;;
 1F642;SLIGHTLY SMILING FACE;So;0;ON;;;;;N;;;;;
+1F643;UPSIDE-DOWN FACE;So;0;ON;;;;;N;;;;;
+1F644;FACE WITH ROLLING EYES;So;0;ON;;;;;N;;;;;
 1F645;FACE WITH NO GOOD GESTURE;So;0;ON;;;;;N;;;;;
 1F646;FACE WITH OK GESTURE;So;0;ON;;;;;N;;;;;
 1F647;PERSON BOWING DEEPLY;So;0;ON;;;;;N;;;;;
@@ -26011,6 +38503,19 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F6CD;SHOPPING BAGS;So;0;ON;;;;;N;;;;;
 1F6CE;BELLHOP BELL;So;0;ON;;;;;N;;;;;
 1F6CF;BED;So;0;ON;;;;;N;;;;;
+1F6D0;PLACE OF WORSHIP;So;0;ON;;;;;N;;;;;
+1F6D1;OCTAGONAL SIGN;So;0;ON;;;;;N;;;;;
+1F6D2;SHOPPING TROLLEY;So;0;ON;;;;;N;;;;;
+1F6D3;STUPA;So;0;ON;;;;;N;;;;;
+1F6D4;PAGODA;So;0;ON;;;;;N;;;;;
+1F6D5;HINDU TEMPLE;So;0;ON;;;;;N;;;;;
+1F6D6;HUT;So;0;ON;;;;;N;;;;;
+1F6D7;ELEVATOR;So;0;ON;;;;;N;;;;;
+1F6D8;LANDSLIDE;So;0;ON;;;;;N;;;;;
+1F6DC;WIRELESS;So;0;ON;;;;;N;;;;;
+1F6DD;PLAYGROUND SLIDE;So;0;ON;;;;;N;;;;;
+1F6DE;WHEEL;So;0;ON;;;;;N;;;;;
+1F6DF;RING BUOY;So;0;ON;;;;;N;;;;;
 1F6E0;HAMMER AND WRENCH;So;0;ON;;;;;N;;;;;
 1F6E1;SHIELD;So;0;ON;;;;;N;;;;;
 1F6E2;OIL DRUM;So;0;ON;;;;;N;;;;;
@@ -26028,6 +38533,15 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F6F1;ONCOMING FIRE ENGINE;So;0;ON;;;;;N;;;;;
 1F6F2;DIESEL LOCOMOTIVE;So;0;ON;;;;;N;;;;;
 1F6F3;PASSENGER SHIP;So;0;ON;;;;;N;;;;;
+1F6F4;SCOOTER;So;0;ON;;;;;N;;;;;
+1F6F5;MOTOR SCOOTER;So;0;ON;;;;;N;;;;;
+1F6F6;CANOE;So;0;ON;;;;;N;;;;;
+1F6F7;SLED;So;0;ON;;;;;N;;;;;
+1F6F8;FLYING SAUCER;So;0;ON;;;;;N;;;;;
+1F6F9;SKATEBOARD;So;0;ON;;;;;N;;;;;
+1F6FA;AUTO RICKSHAW;So;0;ON;;;;;N;;;;;
+1F6FB;PICKUP TRUCK;So;0;ON;;;;;N;;;;;
+1F6FC;ROLLER SKATE;So;0;ON;;;;;N;;;;;
 1F700;ALCHEMICAL SYMBOL FOR QUINTESSENCE;So;0;ON;;;;;N;;;;;
 1F701;ALCHEMICAL SYMBOL FOR AIR;So;0;ON;;;;;N;;;;;
 1F702;ALCHEMICAL SYMBOL FOR FIRE;So;0;ON;;;;;N;;;;;
@@ -26144,6 +38658,18 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F771;ALCHEMICAL SYMBOL FOR MONTH;So;0;ON;;;;;N;;;;;
 1F772;ALCHEMICAL SYMBOL FOR HALF DRAM;So;0;ON;;;;;N;;;;;
 1F773;ALCHEMICAL SYMBOL FOR HALF OUNCE;So;0;ON;;;;;N;;;;;
+1F774;LOT OF FORTUNE;So;0;ON;;;;;N;;;;;
+1F775;OCCULTATION;So;0;ON;;;;;N;;;;;
+1F776;LUNAR ECLIPSE;So;0;ON;;;;;N;;;;;
+1F777;VESTA FORM TWO;So;0;ON;;;;;N;;;;;
+1F778;ASTRAEA FORM TWO;So;0;ON;;;;;N;;;;;
+1F779;HYGIEA FORM TWO;So;0;ON;;;;;N;;;;;
+1F77A;PARTHENOPE FORM TWO;So;0;ON;;;;;N;;;;;
+1F77B;HAUMEA;So;0;ON;;;;;N;;;;;
+1F77C;MAKEMAKE;So;0;ON;;;;;N;;;;;
+1F77D;GONGGONG;So;0;ON;;;;;N;;;;;
+1F77E;QUAOAR;So;0;ON;;;;;N;;;;;
+1F77F;ORCUS;So;0;ON;;;;;N;;;;;
 1F780;BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE;So;0;ON;;;;;N;;;;;
 1F781;BLACK UP-POINTING ISOSCELES RIGHT TRIANGLE;So;0;ON;;;;;N;;;;;
 1F782;BLACK RIGHT-POINTING ISOSCELES RIGHT TRIANGLE;So;0;ON;;;;;N;;;;;
@@ -26229,6 +38755,24 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F7D2;LIGHT TWELVE POINTED BLACK STAR;So;0;ON;;;;;N;;;;;
 1F7D3;HEAVY TWELVE POINTED BLACK STAR;So;0;ON;;;;;N;;;;;
 1F7D4;HEAVY TWELVE POINTED PINWHEEL STAR;So;0;ON;;;;;N;;;;;
+1F7D5;CIRCLED TRIANGLE;So;0;ON;;;;;N;;;;;
+1F7D6;NEGATIVE CIRCLED TRIANGLE;So;0;ON;;;;;N;;;;;
+1F7D7;CIRCLED SQUARE;So;0;ON;;;;;N;;;;;
+1F7D8;NEGATIVE CIRCLED SQUARE;So;0;ON;;;;;N;;;;;
+1F7D9;NINE POINTED WHITE STAR;So;0;ON;;;;;N;;;;;
+1F7E0;LARGE ORANGE CIRCLE;So;0;ON;;;;;N;;;;;
+1F7E1;LARGE YELLOW CIRCLE;So;0;ON;;;;;N;;;;;
+1F7E2;LARGE GREEN CIRCLE;So;0;ON;;;;;N;;;;;
+1F7E3;LARGE PURPLE CIRCLE;So;0;ON;;;;;N;;;;;
+1F7E4;LARGE BROWN CIRCLE;So;0;ON;;;;;N;;;;;
+1F7E5;LARGE RED SQUARE;So;0;ON;;;;;N;;;;;
+1F7E6;LARGE BLUE SQUARE;So;0;ON;;;;;N;;;;;
+1F7E7;LARGE ORANGE SQUARE;So;0;ON;;;;;N;;;;;
+1F7E8;LARGE YELLOW SQUARE;So;0;ON;;;;;N;;;;;
+1F7E9;LARGE GREEN SQUARE;So;0;ON;;;;;N;;;;;
+1F7EA;LARGE PURPLE SQUARE;So;0;ON;;;;;N;;;;;
+1F7EB;LARGE BROWN SQUARE;So;0;ON;;;;;N;;;;;
+1F7F0;HEAVY EQUALS SIGN;So;0;ON;;;;;N;;;;;
 1F800;LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD;So;0;ON;;;;;N;;;;;
 1F801;UPWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD;So;0;ON;;;;;N;;;;;
 1F802;RIGHTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD;So;0;ON;;;;;N;;;;;
@@ -26377,12 +38921,769 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 1F8AB;RIGHTWARDS FRONT-TILTED SHADOWED WHITE ARROW;So;0;ON;;;;;N;;;;;
 1F8AC;WHITE ARROW SHAFT WIDTH ONE;So;0;ON;;;;;N;;;;;
 1F8AD;WHITE ARROW SHAFT WIDTH TWO THIRDS;So;0;ON;;;;;N;;;;;
+1F8B0;ARROW POINTING UPWARDS THEN NORTH WEST;So;0;ON;;;;;N;;;;;
+1F8B1;ARROW POINTING RIGHTWARDS THEN CURVING SOUTH WEST;So;0;ON;;;;;N;;;;;
+1F8B2;RIGHTWARDS ARROW WITH LOWER HOOK;So;0;ON;;;;;N;;;;;
+1F8B3;DOWNWARDS BLACK ARROW TO BAR;So;0;ON;;;;;N;;;;;
+1F8B4;NEGATIVE SQUARED LEFTWARDS ARROW;So;0;ON;;;;;N;;;;;
+1F8B5;NEGATIVE SQUARED UPWARDS ARROW;So;0;ON;;;;;N;;;;;
+1F8B6;NEGATIVE SQUARED RIGHTWARDS ARROW;So;0;ON;;;;;N;;;;;
+1F8B7;NEGATIVE SQUARED DOWNWARDS ARROW;So;0;ON;;;;;N;;;;;
+1F8B8;NORTH WEST ARROW FROM BAR;So;0;ON;;;;;N;;;;;
+1F8B9;NORTH EAST ARROW FROM BAR;So;0;ON;;;;;N;;;;;
+1F8BA;SOUTH EAST ARROW FROM BAR;So;0;ON;;;;;N;;;;;
+1F8BB;SOUTH WEST ARROW FROM BAR;So;0;ON;;;;;N;;;;;
+1F8C0;LEFTWARDS ARROW FROM DOWNWARDS ARROW;So;0;ON;;;;;N;;;;;
+1F8C1;RIGHTWARDS ARROW FROM DOWNWARDS ARROW;So;0;ON;;;;;N;;;;;
+1F8D0;LONG RIGHTWARDS ARROW OVER LONG LEFTWARDS ARROW;Sm;0;ON;;;;;N;;;;;
+1F8D1;LONG RIGHTWARDS HARPOON OVER LONG LEFTWARDS HARPOON;Sm;0;ON;;;;;N;;;;;
+1F8D2;LONG RIGHTWARDS HARPOON ABOVE SHORT LEFTWARDS HARPOON;Sm;0;ON;;;;;N;;;;;
+1F8D3;SHORT RIGHTWARDS HARPOON ABOVE LONG LEFTWARDS HARPOON;Sm;0;ON;;;;;N;;;;;
+1F8D4;LONG LEFTWARDS HARPOON ABOVE SHORT RIGHTWARDS HARPOON;Sm;0;ON;;;;;N;;;;;
+1F8D5;SHORT LEFTWARDS HARPOON ABOVE LONG RIGHTWARDS HARPOON;Sm;0;ON;;;;;N;;;;;
+1F8D6;LONG RIGHTWARDS ARROW THROUGH X;Sm;0;ON;;;;;N;;;;;
+1F8D7;LONG RIGHTWARDS ARROW WITH DOUBLE SLASH;Sm;0;ON;;;;;N;;;;;
+1F8D8;LONG LEFT RIGHT ARROW WITH DEPENDENT LOBE;Sm;0;ON;;;;;N;;;;;
+1F900;CIRCLED CROSS FORMEE WITH FOUR DOTS;So;0;ON;;;;;N;;;;;
+1F901;CIRCLED CROSS FORMEE WITH TWO DOTS;So;0;ON;;;;;N;;;;;
+1F902;CIRCLED CROSS FORMEE;So;0;ON;;;;;N;;;;;
+1F903;LEFT HALF CIRCLE WITH FOUR DOTS;So;0;ON;;;;;N;;;;;
+1F904;LEFT HALF CIRCLE WITH THREE DOTS;So;0;ON;;;;;N;;;;;
+1F905;LEFT HALF CIRCLE WITH TWO DOTS;So;0;ON;;;;;N;;;;;
+1F906;LEFT HALF CIRCLE WITH DOT;So;0;ON;;;;;N;;;;;
+1F907;LEFT HALF CIRCLE;So;0;ON;;;;;N;;;;;
+1F908;DOWNWARD FACING HOOK;So;0;ON;;;;;N;;;;;
+1F909;DOWNWARD FACING NOTCHED HOOK;So;0;ON;;;;;N;;;;;
+1F90A;DOWNWARD FACING HOOK WITH DOT;So;0;ON;;;;;N;;;;;
+1F90B;DOWNWARD FACING NOTCHED HOOK WITH DOT;So;0;ON;;;;;N;;;;;
+1F90C;PINCHED FINGERS;So;0;ON;;;;;N;;;;;
+1F90D;WHITE HEART;So;0;ON;;;;;N;;;;;
+1F90E;BROWN HEART;So;0;ON;;;;;N;;;;;
+1F90F;PINCHING HAND;So;0;ON;;;;;N;;;;;
+1F910;ZIPPER-MOUTH FACE;So;0;ON;;;;;N;;;;;
+1F911;MONEY-MOUTH FACE;So;0;ON;;;;;N;;;;;
+1F912;FACE WITH THERMOMETER;So;0;ON;;;;;N;;;;;
+1F913;NERD FACE;So;0;ON;;;;;N;;;;;
+1F914;THINKING FACE;So;0;ON;;;;;N;;;;;
+1F915;FACE WITH HEAD-BANDAGE;So;0;ON;;;;;N;;;;;
+1F916;ROBOT FACE;So;0;ON;;;;;N;;;;;
+1F917;HUGGING FACE;So;0;ON;;;;;N;;;;;
+1F918;SIGN OF THE HORNS;So;0;ON;;;;;N;;;;;
+1F919;CALL ME HAND;So;0;ON;;;;;N;;;;;
+1F91A;RAISED BACK OF HAND;So;0;ON;;;;;N;;;;;
+1F91B;LEFT-FACING FIST;So;0;ON;;;;;N;;;;;
+1F91C;RIGHT-FACING FIST;So;0;ON;;;;;N;;;;;
+1F91D;HANDSHAKE;So;0;ON;;;;;N;;;;;
+1F91E;HAND WITH INDEX AND MIDDLE FINGERS CROSSED;So;0;ON;;;;;N;;;;;
+1F91F;I LOVE YOU HAND SIGN;So;0;ON;;;;;N;;;;;
+1F920;FACE WITH COWBOY HAT;So;0;ON;;;;;N;;;;;
+1F921;CLOWN FACE;So;0;ON;;;;;N;;;;;
+1F922;NAUSEATED FACE;So;0;ON;;;;;N;;;;;
+1F923;ROLLING ON THE FLOOR LAUGHING;So;0;ON;;;;;N;;;;;
+1F924;DROOLING FACE;So;0;ON;;;;;N;;;;;
+1F925;LYING FACE;So;0;ON;;;;;N;;;;;
+1F926;FACE PALM;So;0;ON;;;;;N;;;;;
+1F927;SNEEZING FACE;So;0;ON;;;;;N;;;;;
+1F928;FACE WITH ONE EYEBROW RAISED;So;0;ON;;;;;N;;;;;
+1F929;GRINNING FACE WITH STAR EYES;So;0;ON;;;;;N;;;;;
+1F92A;GRINNING FACE WITH ONE LARGE AND ONE SMALL EYE;So;0;ON;;;;;N;;;;;
+1F92B;FACE WITH FINGER COVERING CLOSED LIPS;So;0;ON;;;;;N;;;;;
+1F92C;SERIOUS FACE WITH SYMBOLS COVERING MOUTH;So;0;ON;;;;;N;;;;;
+1F92D;SMILING FACE WITH SMILING EYES AND HAND COVERING MOUTH;So;0;ON;;;;;N;;;;;
+1F92E;FACE WITH OPEN MOUTH VOMITING;So;0;ON;;;;;N;;;;;
+1F92F;SHOCKED FACE WITH EXPLODING HEAD;So;0;ON;;;;;N;;;;;
+1F930;PREGNANT WOMAN;So;0;ON;;;;;N;;;;;
+1F931;BREAST-FEEDING;So;0;ON;;;;;N;;;;;
+1F932;PALMS UP TOGETHER;So;0;ON;;;;;N;;;;;
+1F933;SELFIE;So;0;ON;;;;;N;;;;;
+1F934;PRINCE;So;0;ON;;;;;N;;;;;
+1F935;MAN IN TUXEDO;So;0;ON;;;;;N;;;;;
+1F936;MOTHER CHRISTMAS;So;0;ON;;;;;N;;;;;
+1F937;SHRUG;So;0;ON;;;;;N;;;;;
+1F938;PERSON DOING CARTWHEEL;So;0;ON;;;;;N;;;;;
+1F939;JUGGLING;So;0;ON;;;;;N;;;;;
+1F93A;FENCER;So;0;ON;;;;;N;;;;;
+1F93B;MODERN PENTATHLON;So;0;ON;;;;;N;;;;;
+1F93C;WRESTLERS;So;0;ON;;;;;N;;;;;
+1F93D;WATER POLO;So;0;ON;;;;;N;;;;;
+1F93E;HANDBALL;So;0;ON;;;;;N;;;;;
+1F93F;DIVING MASK;So;0;ON;;;;;N;;;;;
+1F940;WILTED FLOWER;So;0;ON;;;;;N;;;;;
+1F941;DRUM WITH DRUMSTICKS;So;0;ON;;;;;N;;;;;
+1F942;CLINKING GLASSES;So;0;ON;;;;;N;;;;;
+1F943;TUMBLER GLASS;So;0;ON;;;;;N;;;;;
+1F944;SPOON;So;0;ON;;;;;N;;;;;
+1F945;GOAL NET;So;0;ON;;;;;N;;;;;
+1F946;RIFLE;So;0;ON;;;;;N;;;;;
+1F947;FIRST PLACE MEDAL;So;0;ON;;;;;N;;;;;
+1F948;SECOND PLACE MEDAL;So;0;ON;;;;;N;;;;;
+1F949;THIRD PLACE MEDAL;So;0;ON;;;;;N;;;;;
+1F94A;BOXING GLOVE;So;0;ON;;;;;N;;;;;
+1F94B;MARTIAL ARTS UNIFORM;So;0;ON;;;;;N;;;;;
+1F94C;CURLING STONE;So;0;ON;;;;;N;;;;;
+1F94D;LACROSSE STICK AND BALL;So;0;ON;;;;;N;;;;;
+1F94E;SOFTBALL;So;0;ON;;;;;N;;;;;
+1F94F;FLYING DISC;So;0;ON;;;;;N;;;;;
+1F950;CROISSANT;So;0;ON;;;;;N;;;;;
+1F951;AVOCADO;So;0;ON;;;;;N;;;;;
+1F952;CUCUMBER;So;0;ON;;;;;N;;;;;
+1F953;BACON;So;0;ON;;;;;N;;;;;
+1F954;POTATO;So;0;ON;;;;;N;;;;;
+1F955;CARROT;So;0;ON;;;;;N;;;;;
+1F956;BAGUETTE BREAD;So;0;ON;;;;;N;;;;;
+1F957;GREEN SALAD;So;0;ON;;;;;N;;;;;
+1F958;SHALLOW PAN OF FOOD;So;0;ON;;;;;N;;;;;
+1F959;STUFFED FLATBREAD;So;0;ON;;;;;N;;;;;
+1F95A;EGG;So;0;ON;;;;;N;;;;;
+1F95B;GLASS OF MILK;So;0;ON;;;;;N;;;;;
+1F95C;PEANUTS;So;0;ON;;;;;N;;;;;
+1F95D;KIWIFRUIT;So;0;ON;;;;;N;;;;;
+1F95E;PANCAKES;So;0;ON;;;;;N;;;;;
+1F95F;DUMPLING;So;0;ON;;;;;N;;;;;
+1F960;FORTUNE COOKIE;So;0;ON;;;;;N;;;;;
+1F961;TAKEOUT BOX;So;0;ON;;;;;N;;;;;
+1F962;CHOPSTICKS;So;0;ON;;;;;N;;;;;
+1F963;BOWL WITH SPOON;So;0;ON;;;;;N;;;;;
+1F964;CUP WITH STRAW;So;0;ON;;;;;N;;;;;
+1F965;COCONUT;So;0;ON;;;;;N;;;;;
+1F966;BROCCOLI;So;0;ON;;;;;N;;;;;
+1F967;PIE;So;0;ON;;;;;N;;;;;
+1F968;PRETZEL;So;0;ON;;;;;N;;;;;
+1F969;CUT OF MEAT;So;0;ON;;;;;N;;;;;
+1F96A;SANDWICH;So;0;ON;;;;;N;;;;;
+1F96B;CANNED FOOD;So;0;ON;;;;;N;;;;;
+1F96C;LEAFY GREEN;So;0;ON;;;;;N;;;;;
+1F96D;MANGO;So;0;ON;;;;;N;;;;;
+1F96E;MOON CAKE;So;0;ON;;;;;N;;;;;
+1F96F;BAGEL;So;0;ON;;;;;N;;;;;
+1F970;SMILING FACE WITH SMILING EYES AND THREE HEARTS;So;0;ON;;;;;N;;;;;
+1F971;YAWNING FACE;So;0;ON;;;;;N;;;;;
+1F972;SMILING FACE WITH TEAR;So;0;ON;;;;;N;;;;;
+1F973;FACE WITH PARTY HORN AND PARTY HAT;So;0;ON;;;;;N;;;;;
+1F974;FACE WITH UNEVEN EYES AND WAVY MOUTH;So;0;ON;;;;;N;;;;;
+1F975;OVERHEATED FACE;So;0;ON;;;;;N;;;;;
+1F976;FREEZING FACE;So;0;ON;;;;;N;;;;;
+1F977;NINJA;So;0;ON;;;;;N;;;;;
+1F978;DISGUISED FACE;So;0;ON;;;;;N;;;;;
+1F979;FACE HOLDING BACK TEARS;So;0;ON;;;;;N;;;;;
+1F97A;FACE WITH PLEADING EYES;So;0;ON;;;;;N;;;;;
+1F97B;SARI;So;0;ON;;;;;N;;;;;
+1F97C;LAB COAT;So;0;ON;;;;;N;;;;;
+1F97D;GOGGLES;So;0;ON;;;;;N;;;;;
+1F97E;HIKING BOOT;So;0;ON;;;;;N;;;;;
+1F97F;FLAT SHOE;So;0;ON;;;;;N;;;;;
+1F980;CRAB;So;0;ON;;;;;N;;;;;
+1F981;LION FACE;So;0;ON;;;;;N;;;;;
+1F982;SCORPION;So;0;ON;;;;;N;;;;;
+1F983;TURKEY;So;0;ON;;;;;N;;;;;
+1F984;UNICORN FACE;So;0;ON;;;;;N;;;;;
+1F985;EAGLE;So;0;ON;;;;;N;;;;;
+1F986;DUCK;So;0;ON;;;;;N;;;;;
+1F987;BAT;So;0;ON;;;;;N;;;;;
+1F988;SHARK;So;0;ON;;;;;N;;;;;
+1F989;OWL;So;0;ON;;;;;N;;;;;
+1F98A;FOX FACE;So;0;ON;;;;;N;;;;;
+1F98B;BUTTERFLY;So;0;ON;;;;;N;;;;;
+1F98C;DEER;So;0;ON;;;;;N;;;;;
+1F98D;GORILLA;So;0;ON;;;;;N;;;;;
+1F98E;LIZARD;So;0;ON;;;;;N;;;;;
+1F98F;RHINOCEROS;So;0;ON;;;;;N;;;;;
+1F990;SHRIMP;So;0;ON;;;;;N;;;;;
+1F991;SQUID;So;0;ON;;;;;N;;;;;
+1F992;GIRAFFE FACE;So;0;ON;;;;;N;;;;;
+1F993;ZEBRA FACE;So;0;ON;;;;;N;;;;;
+1F994;HEDGEHOG;So;0;ON;;;;;N;;;;;
+1F995;SAUROPOD;So;0;ON;;;;;N;;;;;
+1F996;T-REX;So;0;ON;;;;;N;;;;;
+1F997;CRICKET;So;0;ON;;;;;N;;;;;
+1F998;KANGAROO;So;0;ON;;;;;N;;;;;
+1F999;LLAMA;So;0;ON;;;;;N;;;;;
+1F99A;PEACOCK;So;0;ON;;;;;N;;;;;
+1F99B;HIPPOPOTAMUS;So;0;ON;;;;;N;;;;;
+1F99C;PARROT;So;0;ON;;;;;N;;;;;
+1F99D;RACCOON;So;0;ON;;;;;N;;;;;
+1F99E;LOBSTER;So;0;ON;;;;;N;;;;;
+1F99F;MOSQUITO;So;0;ON;;;;;N;;;;;
+1F9A0;MICROBE;So;0;ON;;;;;N;;;;;
+1F9A1;BADGER;So;0;ON;;;;;N;;;;;
+1F9A2;SWAN;So;0;ON;;;;;N;;;;;
+1F9A3;MAMMOTH;So;0;ON;;;;;N;;;;;
+1F9A4;DODO;So;0;ON;;;;;N;;;;;
+1F9A5;SLOTH;So;0;ON;;;;;N;;;;;
+1F9A6;OTTER;So;0;ON;;;;;N;;;;;
+1F9A7;ORANGUTAN;So;0;ON;;;;;N;;;;;
+1F9A8;SKUNK;So;0;ON;;;;;N;;;;;
+1F9A9;FLAMINGO;So;0;ON;;;;;N;;;;;
+1F9AA;OYSTER;So;0;ON;;;;;N;;;;;
+1F9AB;BEAVER;So;0;ON;;;;;N;;;;;
+1F9AC;BISON;So;0;ON;;;;;N;;;;;
+1F9AD;SEAL;So;0;ON;;;;;N;;;;;
+1F9AE;GUIDE DOG;So;0;ON;;;;;N;;;;;
+1F9AF;PROBING CANE;So;0;ON;;;;;N;;;;;
+1F9B0;EMOJI COMPONENT RED HAIR;So;0;ON;;;;;N;;;;;
+1F9B1;EMOJI COMPONENT CURLY HAIR;So;0;ON;;;;;N;;;;;
+1F9B2;EMOJI COMPONENT BALD;So;0;ON;;;;;N;;;;;
+1F9B3;EMOJI COMPONENT WHITE HAIR;So;0;ON;;;;;N;;;;;
+1F9B4;BONE;So;0;ON;;;;;N;;;;;
+1F9B5;LEG;So;0;ON;;;;;N;;;;;
+1F9B6;FOOT;So;0;ON;;;;;N;;;;;
+1F9B7;TOOTH;So;0;ON;;;;;N;;;;;
+1F9B8;SUPERHERO;So;0;ON;;;;;N;;;;;
+1F9B9;SUPERVILLAIN;So;0;ON;;;;;N;;;;;
+1F9BA;SAFETY VEST;So;0;ON;;;;;N;;;;;
+1F9BB;EAR WITH HEARING AID;So;0;ON;;;;;N;;;;;
+1F9BC;MOTORIZED WHEELCHAIR;So;0;ON;;;;;N;;;;;
+1F9BD;MANUAL WHEELCHAIR;So;0;ON;;;;;N;;;;;
+1F9BE;MECHANICAL ARM;So;0;ON;;;;;N;;;;;
+1F9BF;MECHANICAL LEG;So;0;ON;;;;;N;;;;;
+1F9C0;CHEESE WEDGE;So;0;ON;;;;;N;;;;;
+1F9C1;CUPCAKE;So;0;ON;;;;;N;;;;;
+1F9C2;SALT SHAKER;So;0;ON;;;;;N;;;;;
+1F9C3;BEVERAGE BOX;So;0;ON;;;;;N;;;;;
+1F9C4;GARLIC;So;0;ON;;;;;N;;;;;
+1F9C5;ONION;So;0;ON;;;;;N;;;;;
+1F9C6;FALAFEL;So;0;ON;;;;;N;;;;;
+1F9C7;WAFFLE;So;0;ON;;;;;N;;;;;
+1F9C8;BUTTER;So;0;ON;;;;;N;;;;;
+1F9C9;MATE DRINK;So;0;ON;;;;;N;;;;;
+1F9CA;ICE CUBE;So;0;ON;;;;;N;;;;;
+1F9CB;BUBBLE TEA;So;0;ON;;;;;N;;;;;
+1F9CC;TROLL;So;0;ON;;;;;N;;;;;
+1F9CD;STANDING PERSON;So;0;ON;;;;;N;;;;;
+1F9CE;KNEELING PERSON;So;0;ON;;;;;N;;;;;
+1F9CF;DEAF PERSON;So;0;ON;;;;;N;;;;;
+1F9D0;FACE WITH MONOCLE;So;0;ON;;;;;N;;;;;
+1F9D1;ADULT;So;0;ON;;;;;N;;;;;
+1F9D2;CHILD;So;0;ON;;;;;N;;;;;
+1F9D3;OLDER ADULT;So;0;ON;;;;;N;;;;;
+1F9D4;BEARDED PERSON;So;0;ON;;;;;N;;;;;
+1F9D5;PERSON WITH HEADSCARF;So;0;ON;;;;;N;;;;;
+1F9D6;PERSON IN STEAMY ROOM;So;0;ON;;;;;N;;;;;
+1F9D7;PERSON CLIMBING;So;0;ON;;;;;N;;;;;
+1F9D8;PERSON IN LOTUS POSITION;So;0;ON;;;;;N;;;;;
+1F9D9;MAGE;So;0;ON;;;;;N;;;;;
+1F9DA;FAIRY;So;0;ON;;;;;N;;;;;
+1F9DB;VAMPIRE;So;0;ON;;;;;N;;;;;
+1F9DC;MERPERSON;So;0;ON;;;;;N;;;;;
+1F9DD;ELF;So;0;ON;;;;;N;;;;;
+1F9DE;GENIE;So;0;ON;;;;;N;;;;;
+1F9DF;ZOMBIE;So;0;ON;;;;;N;;;;;
+1F9E0;BRAIN;So;0;ON;;;;;N;;;;;
+1F9E1;ORANGE HEART;So;0;ON;;;;;N;;;;;
+1F9E2;BILLED CAP;So;0;ON;;;;;N;;;;;
+1F9E3;SCARF;So;0;ON;;;;;N;;;;;
+1F9E4;GLOVES;So;0;ON;;;;;N;;;;;
+1F9E5;COAT;So;0;ON;;;;;N;;;;;
+1F9E6;SOCKS;So;0;ON;;;;;N;;;;;
+1F9E7;RED GIFT ENVELOPE;So;0;ON;;;;;N;;;;;
+1F9E8;FIRECRACKER;So;0;ON;;;;;N;;;;;
+1F9E9;JIGSAW PUZZLE PIECE;So;0;ON;;;;;N;;;;;
+1F9EA;TEST TUBE;So;0;ON;;;;;N;;;;;
+1F9EB;PETRI DISH;So;0;ON;;;;;N;;;;;
+1F9EC;DNA DOUBLE HELIX;So;0;ON;;;;;N;;;;;
+1F9ED;COMPASS;So;0;ON;;;;;N;;;;;
+1F9EE;ABACUS;So;0;ON;;;;;N;;;;;
+1F9EF;FIRE EXTINGUISHER;So;0;ON;;;;;N;;;;;
+1F9F0;TOOLBOX;So;0;ON;;;;;N;;;;;
+1F9F1;BRICK;So;0;ON;;;;;N;;;;;
+1F9F2;MAGNET;So;0;ON;;;;;N;;;;;
+1F9F3;LUGGAGE;So;0;ON;;;;;N;;;;;
+1F9F4;LOTION BOTTLE;So;0;ON;;;;;N;;;;;
+1F9F5;SPOOL OF THREAD;So;0;ON;;;;;N;;;;;
+1F9F6;BALL OF YARN;So;0;ON;;;;;N;;;;;
+1F9F7;SAFETY PIN;So;0;ON;;;;;N;;;;;
+1F9F8;TEDDY BEAR;So;0;ON;;;;;N;;;;;
+1F9F9;BROOM;So;0;ON;;;;;N;;;;;
+1F9FA;BASKET;So;0;ON;;;;;N;;;;;
+1F9FB;ROLL OF PAPER;So;0;ON;;;;;N;;;;;
+1F9FC;BAR OF SOAP;So;0;ON;;;;;N;;;;;
+1F9FD;SPONGE;So;0;ON;;;;;N;;;;;
+1F9FE;RECEIPT;So;0;ON;;;;;N;;;;;
+1F9FF;NAZAR AMULET;So;0;ON;;;;;N;;;;;
+1FA00;NEUTRAL CHESS KING;So;0;ON;;;;;N;;;;;
+1FA01;NEUTRAL CHESS QUEEN;So;0;ON;;;;;N;;;;;
+1FA02;NEUTRAL CHESS ROOK;So;0;ON;;;;;N;;;;;
+1FA03;NEUTRAL CHESS BISHOP;So;0;ON;;;;;N;;;;;
+1FA04;NEUTRAL CHESS KNIGHT;So;0;ON;;;;;N;;;;;
+1FA05;NEUTRAL CHESS PAWN;So;0;ON;;;;;N;;;;;
+1FA06;WHITE CHESS KNIGHT ROTATED FORTY-FIVE DEGREES;So;0;ON;;;;;N;;;;;
+1FA07;BLACK CHESS KNIGHT ROTATED FORTY-FIVE DEGREES;So;0;ON;;;;;N;;;;;
+1FA08;NEUTRAL CHESS KNIGHT ROTATED FORTY-FIVE DEGREES;So;0;ON;;;;;N;;;;;
+1FA09;WHITE CHESS KING ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA0A;WHITE CHESS QUEEN ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA0B;WHITE CHESS ROOK ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA0C;WHITE CHESS BISHOP ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA0D;WHITE CHESS KNIGHT ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA0E;WHITE CHESS PAWN ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA0F;BLACK CHESS KING ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA10;BLACK CHESS QUEEN ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA11;BLACK CHESS ROOK ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA12;BLACK CHESS BISHOP ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA13;BLACK CHESS KNIGHT ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA14;BLACK CHESS PAWN ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA15;NEUTRAL CHESS KING ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA16;NEUTRAL CHESS QUEEN ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA17;NEUTRAL CHESS ROOK ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA18;NEUTRAL CHESS BISHOP ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA19;NEUTRAL CHESS KNIGHT ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA1A;NEUTRAL CHESS PAWN ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA1B;WHITE CHESS KNIGHT ROTATED ONE HUNDRED THIRTY-FIVE DEGREES;So;0;ON;;;;;N;;;;;
+1FA1C;BLACK CHESS KNIGHT ROTATED ONE HUNDRED THIRTY-FIVE DEGREES;So;0;ON;;;;;N;;;;;
+1FA1D;NEUTRAL CHESS KNIGHT ROTATED ONE HUNDRED THIRTY-FIVE DEGREES;So;0;ON;;;;;N;;;;;
+1FA1E;WHITE CHESS TURNED KING;So;0;ON;;;;;N;;;;;
+1FA1F;WHITE CHESS TURNED QUEEN;So;0;ON;;;;;N;;;;;
+1FA20;WHITE CHESS TURNED ROOK;So;0;ON;;;;;N;;;;;
+1FA21;WHITE CHESS TURNED BISHOP;So;0;ON;;;;;N;;;;;
+1FA22;WHITE CHESS TURNED KNIGHT;So;0;ON;;;;;N;;;;;
+1FA23;WHITE CHESS TURNED PAWN;So;0;ON;;;;;N;;;;;
+1FA24;BLACK CHESS TURNED KING;So;0;ON;;;;;N;;;;;
+1FA25;BLACK CHESS TURNED QUEEN;So;0;ON;;;;;N;;;;;
+1FA26;BLACK CHESS TURNED ROOK;So;0;ON;;;;;N;;;;;
+1FA27;BLACK CHESS TURNED BISHOP;So;0;ON;;;;;N;;;;;
+1FA28;BLACK CHESS TURNED KNIGHT;So;0;ON;;;;;N;;;;;
+1FA29;BLACK CHESS TURNED PAWN;So;0;ON;;;;;N;;;;;
+1FA2A;NEUTRAL CHESS TURNED KING;So;0;ON;;;;;N;;;;;
+1FA2B;NEUTRAL CHESS TURNED QUEEN;So;0;ON;;;;;N;;;;;
+1FA2C;NEUTRAL CHESS TURNED ROOK;So;0;ON;;;;;N;;;;;
+1FA2D;NEUTRAL CHESS TURNED BISHOP;So;0;ON;;;;;N;;;;;
+1FA2E;NEUTRAL CHESS TURNED KNIGHT;So;0;ON;;;;;N;;;;;
+1FA2F;NEUTRAL CHESS TURNED PAWN;So;0;ON;;;;;N;;;;;
+1FA30;WHITE CHESS KNIGHT ROTATED TWO HUNDRED TWENTY-FIVE DEGREES;So;0;ON;;;;;N;;;;;
+1FA31;BLACK CHESS KNIGHT ROTATED TWO HUNDRED TWENTY-FIVE DEGREES;So;0;ON;;;;;N;;;;;
+1FA32;NEUTRAL CHESS KNIGHT ROTATED TWO HUNDRED TWENTY-FIVE DEGREES;So;0;ON;;;;;N;;;;;
+1FA33;WHITE CHESS KING ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA34;WHITE CHESS QUEEN ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA35;WHITE CHESS ROOK ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA36;WHITE CHESS BISHOP ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA37;WHITE CHESS KNIGHT ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA38;WHITE CHESS PAWN ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA39;BLACK CHESS KING ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA3A;BLACK CHESS QUEEN ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA3B;BLACK CHESS ROOK ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA3C;BLACK CHESS BISHOP ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA3D;BLACK CHESS KNIGHT ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA3E;BLACK CHESS PAWN ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA3F;NEUTRAL CHESS KING ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA40;NEUTRAL CHESS QUEEN ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA41;NEUTRAL CHESS ROOK ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA42;NEUTRAL CHESS BISHOP ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA43;NEUTRAL CHESS KNIGHT ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA44;NEUTRAL CHESS PAWN ROTATED TWO HUNDRED SEVENTY DEGREES;So;0;ON;;;;;N;;;;;
+1FA45;WHITE CHESS KNIGHT ROTATED THREE HUNDRED FIFTEEN DEGREES;So;0;ON;;;;;N;;;;;
+1FA46;BLACK CHESS KNIGHT ROTATED THREE HUNDRED FIFTEEN DEGREES;So;0;ON;;;;;N;;;;;
+1FA47;NEUTRAL CHESS KNIGHT ROTATED THREE HUNDRED FIFTEEN DEGREES;So;0;ON;;;;;N;;;;;
+1FA48;WHITE CHESS EQUIHOPPER;So;0;ON;;;;;N;;;;;
+1FA49;BLACK CHESS EQUIHOPPER;So;0;ON;;;;;N;;;;;
+1FA4A;NEUTRAL CHESS EQUIHOPPER;So;0;ON;;;;;N;;;;;
+1FA4B;WHITE CHESS EQUIHOPPER ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA4C;BLACK CHESS EQUIHOPPER ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA4D;NEUTRAL CHESS EQUIHOPPER ROTATED NINETY DEGREES;So;0;ON;;;;;N;;;;;
+1FA4E;WHITE CHESS KNIGHT-QUEEN;So;0;ON;;;;;N;;;;;
+1FA4F;WHITE CHESS KNIGHT-ROOK;So;0;ON;;;;;N;;;;;
+1FA50;WHITE CHESS KNIGHT-BISHOP;So;0;ON;;;;;N;;;;;
+1FA51;BLACK CHESS KNIGHT-QUEEN;So;0;ON;;;;;N;;;;;
+1FA52;BLACK CHESS KNIGHT-ROOK;So;0;ON;;;;;N;;;;;
+1FA53;BLACK CHESS KNIGHT-BISHOP;So;0;ON;;;;;N;;;;;
+1FA54;WHITE CHESS FERZ;So;0;ON;;;;;N;;;;;
+1FA55;WHITE CHESS ALFIL;So;0;ON;;;;;N;;;;;
+1FA56;BLACK CHESS FERZ;So;0;ON;;;;;N;;;;;
+1FA57;BLACK CHESS ALFIL;So;0;ON;;;;;N;;;;;
+1FA60;XIANGQI RED GENERAL;So;0;ON;;;;;N;;;;;
+1FA61;XIANGQI RED MANDARIN;So;0;ON;;;;;N;;;;;
+1FA62;XIANGQI RED ELEPHANT;So;0;ON;;;;;N;;;;;
+1FA63;XIANGQI RED HORSE;So;0;ON;;;;;N;;;;;
+1FA64;XIANGQI RED CHARIOT;So;0;ON;;;;;N;;;;;
+1FA65;XIANGQI RED CANNON;So;0;ON;;;;;N;;;;;
+1FA66;XIANGQI RED SOLDIER;So;0;ON;;;;;N;;;;;
+1FA67;XIANGQI BLACK GENERAL;So;0;ON;;;;;N;;;;;
+1FA68;XIANGQI BLACK MANDARIN;So;0;ON;;;;;N;;;;;
+1FA69;XIANGQI BLACK ELEPHANT;So;0;ON;;;;;N;;;;;
+1FA6A;XIANGQI BLACK HORSE;So;0;ON;;;;;N;;;;;
+1FA6B;XIANGQI BLACK CHARIOT;So;0;ON;;;;;N;;;;;
+1FA6C;XIANGQI BLACK CANNON;So;0;ON;;;;;N;;;;;
+1FA6D;XIANGQI BLACK SOLDIER;So;0;ON;;;;;N;;;;;
+1FA70;BALLET SHOES;So;0;ON;;;;;N;;;;;
+1FA71;ONE-PIECE SWIMSUIT;So;0;ON;;;;;N;;;;;
+1FA72;BRIEFS;So;0;ON;;;;;N;;;;;
+1FA73;SHORTS;So;0;ON;;;;;N;;;;;
+1FA74;THONG SANDAL;So;0;ON;;;;;N;;;;;
+1FA75;LIGHT BLUE HEART;So;0;ON;;;;;N;;;;;
+1FA76;GREY HEART;So;0;ON;;;;;N;;;;;
+1FA77;PINK HEART;So;0;ON;;;;;N;;;;;
+1FA78;DROP OF BLOOD;So;0;ON;;;;;N;;;;;
+1FA79;ADHESIVE BANDAGE;So;0;ON;;;;;N;;;;;
+1FA7A;STETHOSCOPE;So;0;ON;;;;;N;;;;;
+1FA7B;X-RAY;So;0;ON;;;;;N;;;;;
+1FA7C;CRUTCH;So;0;ON;;;;;N;;;;;
+1FA80;YO-YO;So;0;ON;;;;;N;;;;;
+1FA81;KITE;So;0;ON;;;;;N;;;;;
+1FA82;PARACHUTE;So;0;ON;;;;;N;;;;;
+1FA83;BOOMERANG;So;0;ON;;;;;N;;;;;
+1FA84;MAGIC WAND;So;0;ON;;;;;N;;;;;
+1FA85;PINATA;So;0;ON;;;;;N;;;;;
+1FA86;NESTING DOLLS;So;0;ON;;;;;N;;;;;
+1FA87;MARACAS;So;0;ON;;;;;N;;;;;
+1FA88;FLUTE;So;0;ON;;;;;N;;;;;
+1FA89;HARP;So;0;ON;;;;;N;;;;;
+1FA8A;TROMBONE;So;0;ON;;;;;N;;;;;
+1FA8E;TREASURE CHEST;So;0;ON;;;;;N;;;;;
+1FA8F;SHOVEL;So;0;ON;;;;;N;;;;;
+1FA90;RINGED PLANET;So;0;ON;;;;;N;;;;;
+1FA91;CHAIR;So;0;ON;;;;;N;;;;;
+1FA92;RAZOR;So;0;ON;;;;;N;;;;;
+1FA93;AXE;So;0;ON;;;;;N;;;;;
+1FA94;DIYA LAMP;So;0;ON;;;;;N;;;;;
+1FA95;BANJO;So;0;ON;;;;;N;;;;;
+1FA96;MILITARY HELMET;So;0;ON;;;;;N;;;;;
+1FA97;ACCORDION;So;0;ON;;;;;N;;;;;
+1FA98;LONG DRUM;So;0;ON;;;;;N;;;;;
+1FA99;COIN;So;0;ON;;;;;N;;;;;
+1FA9A;CARPENTRY SAW;So;0;ON;;;;;N;;;;;
+1FA9B;SCREWDRIVER;So;0;ON;;;;;N;;;;;
+1FA9C;LADDER;So;0;ON;;;;;N;;;;;
+1FA9D;HOOK;So;0;ON;;;;;N;;;;;
+1FA9E;MIRROR;So;0;ON;;;;;N;;;;;
+1FA9F;WINDOW;So;0;ON;;;;;N;;;;;
+1FAA0;PLUNGER;So;0;ON;;;;;N;;;;;
+1FAA1;SEWING NEEDLE;So;0;ON;;;;;N;;;;;
+1FAA2;KNOT;So;0;ON;;;;;N;;;;;
+1FAA3;BUCKET;So;0;ON;;;;;N;;;;;
+1FAA4;MOUSE TRAP;So;0;ON;;;;;N;;;;;
+1FAA5;TOOTHBRUSH;So;0;ON;;;;;N;;;;;
+1FAA6;HEADSTONE;So;0;ON;;;;;N;;;;;
+1FAA7;PLACARD;So;0;ON;;;;;N;;;;;
+1FAA8;ROCK;So;0;ON;;;;;N;;;;;
+1FAA9;MIRROR BALL;So;0;ON;;;;;N;;;;;
+1FAAA;IDENTIFICATION CARD;So;0;ON;;;;;N;;;;;
+1FAAB;LOW BATTERY;So;0;ON;;;;;N;;;;;
+1FAAC;HAMSA;So;0;ON;;;;;N;;;;;
+1FAAD;FOLDING HAND FAN;So;0;ON;;;;;N;;;;;
+1FAAE;HAIR PICK;So;0;ON;;;;;N;;;;;
+1FAAF;KHANDA;So;0;ON;;;;;N;;;;;
+1FAB0;FLY;So;0;ON;;;;;N;;;;;
+1FAB1;WORM;So;0;ON;;;;;N;;;;;
+1FAB2;BEETLE;So;0;ON;;;;;N;;;;;
+1FAB3;COCKROACH;So;0;ON;;;;;N;;;;;
+1FAB4;POTTED PLANT;So;0;ON;;;;;N;;;;;
+1FAB5;WOOD;So;0;ON;;;;;N;;;;;
+1FAB6;FEATHER;So;0;ON;;;;;N;;;;;
+1FAB7;LOTUS;So;0;ON;;;;;N;;;;;
+1FAB8;CORAL;So;0;ON;;;;;N;;;;;
+1FAB9;EMPTY NEST;So;0;ON;;;;;N;;;;;
+1FABA;NEST WITH EGGS;So;0;ON;;;;;N;;;;;
+1FABB;HYACINTH;So;0;ON;;;;;N;;;;;
+1FABC;JELLYFISH;So;0;ON;;;;;N;;;;;
+1FABD;WING;So;0;ON;;;;;N;;;;;
+1FABE;LEAFLESS TREE;So;0;ON;;;;;N;;;;;
+1FABF;GOOSE;So;0;ON;;;;;N;;;;;
+1FAC0;ANATOMICAL HEART;So;0;ON;;;;;N;;;;;
+1FAC1;LUNGS;So;0;ON;;;;;N;;;;;
+1FAC2;PEOPLE HUGGING;So;0;ON;;;;;N;;;;;
+1FAC3;PREGNANT MAN;So;0;ON;;;;;N;;;;;
+1FAC4;PREGNANT PERSON;So;0;ON;;;;;N;;;;;
+1FAC5;PERSON WITH CROWN;So;0;ON;;;;;N;;;;;
+1FAC6;FINGERPRINT;So;0;ON;;;;;N;;;;;
+1FAC8;HAIRY CREATURE;So;0;ON;;;;;N;;;;;
+1FACD;ORCA;So;0;ON;;;;;N;;;;;
+1FACE;MOOSE;So;0;ON;;;;;N;;;;;
+1FACF;DONKEY;So;0;ON;;;;;N;;;;;
+1FAD0;BLUEBERRIES;So;0;ON;;;;;N;;;;;
+1FAD1;BELL PEPPER;So;0;ON;;;;;N;;;;;
+1FAD2;OLIVE;So;0;ON;;;;;N;;;;;
+1FAD3;FLATBREAD;So;0;ON;;;;;N;;;;;
+1FAD4;TAMALE;So;0;ON;;;;;N;;;;;
+1FAD5;FONDUE;So;0;ON;;;;;N;;;;;
+1FAD6;TEAPOT;So;0;ON;;;;;N;;;;;
+1FAD7;POURING LIQUID;So;0;ON;;;;;N;;;;;
+1FAD8;BEANS;So;0;ON;;;;;N;;;;;
+1FAD9;JAR;So;0;ON;;;;;N;;;;;
+1FADA;GINGER ROOT;So;0;ON;;;;;N;;;;;
+1FADB;PEA POD;So;0;ON;;;;;N;;;;;
+1FADC;ROOT VEGETABLE;So;0;ON;;;;;N;;;;;
+1FADF;SPLATTER;So;0;ON;;;;;N;;;;;
+1FAE0;MELTING FACE;So;0;ON;;;;;N;;;;;
+1FAE1;SALUTING FACE;So;0;ON;;;;;N;;;;;
+1FAE2;FACE WITH OPEN EYES AND HAND OVER MOUTH;So;0;ON;;;;;N;;;;;
+1FAE3;FACE WITH PEEKING EYE;So;0;ON;;;;;N;;;;;
+1FAE4;FACE WITH DIAGONAL MOUTH;So;0;ON;;;;;N;;;;;
+1FAE5;DOTTED LINE FACE;So;0;ON;;;;;N;;;;;
+1FAE6;BITING LIP;So;0;ON;;;;;N;;;;;
+1FAE7;BUBBLES;So;0;ON;;;;;N;;;;;
+1FAE8;SHAKING FACE;So;0;ON;;;;;N;;;;;
+1FAE9;FACE WITH BAGS UNDER EYES;So;0;ON;;;;;N;;;;;
+1FAEA;DISTORTED FACE;So;0;ON;;;;;N;;;;;
+1FAEF;FIGHT CLOUD;So;0;ON;;;;;N;;;;;
+1FAF0;HAND WITH INDEX FINGER AND THUMB CROSSED;So;0;ON;;;;;N;;;;;
+1FAF1;RIGHTWARDS HAND;So;0;ON;;;;;N;;;;;
+1FAF2;LEFTWARDS HAND;So;0;ON;;;;;N;;;;;
+1FAF3;PALM DOWN HAND;So;0;ON;;;;;N;;;;;
+1FAF4;PALM UP HAND;So;0;ON;;;;;N;;;;;
+1FAF5;INDEX POINTING AT THE VIEWER;So;0;ON;;;;;N;;;;;
+1FAF6;HEART HANDS;So;0;ON;;;;;N;;;;;
+1FAF7;LEFTWARDS PUSHING HAND;So;0;ON;;;;;N;;;;;
+1FAF8;RIGHTWARDS PUSHING HAND;So;0;ON;;;;;N;;;;;
+1FB00;BLOCK SEXTANT-1;So;0;ON;;;;;N;;;;;
+1FB01;BLOCK SEXTANT-2;So;0;ON;;;;;N;;;;;
+1FB02;BLOCK SEXTANT-12;So;0;ON;;;;;N;;;;;
+1FB03;BLOCK SEXTANT-3;So;0;ON;;;;;N;;;;;
+1FB04;BLOCK SEXTANT-13;So;0;ON;;;;;N;;;;;
+1FB05;BLOCK SEXTANT-23;So;0;ON;;;;;N;;;;;
+1FB06;BLOCK SEXTANT-123;So;0;ON;;;;;N;;;;;
+1FB07;BLOCK SEXTANT-4;So;0;ON;;;;;N;;;;;
+1FB08;BLOCK SEXTANT-14;So;0;ON;;;;;N;;;;;
+1FB09;BLOCK SEXTANT-24;So;0;ON;;;;;N;;;;;
+1FB0A;BLOCK SEXTANT-124;So;0;ON;;;;;N;;;;;
+1FB0B;BLOCK SEXTANT-34;So;0;ON;;;;;N;;;;;
+1FB0C;BLOCK SEXTANT-134;So;0;ON;;;;;N;;;;;
+1FB0D;BLOCK SEXTANT-234;So;0;ON;;;;;N;;;;;
+1FB0E;BLOCK SEXTANT-1234;So;0;ON;;;;;N;;;;;
+1FB0F;BLOCK SEXTANT-5;So;0;ON;;;;;N;;;;;
+1FB10;BLOCK SEXTANT-15;So;0;ON;;;;;N;;;;;
+1FB11;BLOCK SEXTANT-25;So;0;ON;;;;;N;;;;;
+1FB12;BLOCK SEXTANT-125;So;0;ON;;;;;N;;;;;
+1FB13;BLOCK SEXTANT-35;So;0;ON;;;;;N;;;;;
+1FB14;BLOCK SEXTANT-235;So;0;ON;;;;;N;;;;;
+1FB15;BLOCK SEXTANT-1235;So;0;ON;;;;;N;;;;;
+1FB16;BLOCK SEXTANT-45;So;0;ON;;;;;N;;;;;
+1FB17;BLOCK SEXTANT-145;So;0;ON;;;;;N;;;;;
+1FB18;BLOCK SEXTANT-245;So;0;ON;;;;;N;;;;;
+1FB19;BLOCK SEXTANT-1245;So;0;ON;;;;;N;;;;;
+1FB1A;BLOCK SEXTANT-345;So;0;ON;;;;;N;;;;;
+1FB1B;BLOCK SEXTANT-1345;So;0;ON;;;;;N;;;;;
+1FB1C;BLOCK SEXTANT-2345;So;0;ON;;;;;N;;;;;
+1FB1D;BLOCK SEXTANT-12345;So;0;ON;;;;;N;;;;;
+1FB1E;BLOCK SEXTANT-6;So;0;ON;;;;;N;;;;;
+1FB1F;BLOCK SEXTANT-16;So;0;ON;;;;;N;;;;;
+1FB20;BLOCK SEXTANT-26;So;0;ON;;;;;N;;;;;
+1FB21;BLOCK SEXTANT-126;So;0;ON;;;;;N;;;;;
+1FB22;BLOCK SEXTANT-36;So;0;ON;;;;;N;;;;;
+1FB23;BLOCK SEXTANT-136;So;0;ON;;;;;N;;;;;
+1FB24;BLOCK SEXTANT-236;So;0;ON;;;;;N;;;;;
+1FB25;BLOCK SEXTANT-1236;So;0;ON;;;;;N;;;;;
+1FB26;BLOCK SEXTANT-46;So;0;ON;;;;;N;;;;;
+1FB27;BLOCK SEXTANT-146;So;0;ON;;;;;N;;;;;
+1FB28;BLOCK SEXTANT-1246;So;0;ON;;;;;N;;;;;
+1FB29;BLOCK SEXTANT-346;So;0;ON;;;;;N;;;;;
+1FB2A;BLOCK SEXTANT-1346;So;0;ON;;;;;N;;;;;
+1FB2B;BLOCK SEXTANT-2346;So;0;ON;;;;;N;;;;;
+1FB2C;BLOCK SEXTANT-12346;So;0;ON;;;;;N;;;;;
+1FB2D;BLOCK SEXTANT-56;So;0;ON;;;;;N;;;;;
+1FB2E;BLOCK SEXTANT-156;So;0;ON;;;;;N;;;;;
+1FB2F;BLOCK SEXTANT-256;So;0;ON;;;;;N;;;;;
+1FB30;BLOCK SEXTANT-1256;So;0;ON;;;;;N;;;;;
+1FB31;BLOCK SEXTANT-356;So;0;ON;;;;;N;;;;;
+1FB32;BLOCK SEXTANT-1356;So;0;ON;;;;;N;;;;;
+1FB33;BLOCK SEXTANT-2356;So;0;ON;;;;;N;;;;;
+1FB34;BLOCK SEXTANT-12356;So;0;ON;;;;;N;;;;;
+1FB35;BLOCK SEXTANT-456;So;0;ON;;;;;N;;;;;
+1FB36;BLOCK SEXTANT-1456;So;0;ON;;;;;N;;;;;
+1FB37;BLOCK SEXTANT-2456;So;0;ON;;;;;N;;;;;
+1FB38;BLOCK SEXTANT-12456;So;0;ON;;;;;N;;;;;
+1FB39;BLOCK SEXTANT-3456;So;0;ON;;;;;N;;;;;
+1FB3A;BLOCK SEXTANT-13456;So;0;ON;;;;;N;;;;;
+1FB3B;BLOCK SEXTANT-23456;So;0;ON;;;;;N;;;;;
+1FB3C;LOWER LEFT BLOCK DIAGONAL LOWER MIDDLE LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FB3D;LOWER LEFT BLOCK DIAGONAL LOWER MIDDLE LEFT TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FB3E;LOWER LEFT BLOCK DIAGONAL UPPER MIDDLE LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FB3F;LOWER LEFT BLOCK DIAGONAL UPPER MIDDLE LEFT TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FB40;LOWER LEFT BLOCK DIAGONAL UPPER LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FB41;LOWER RIGHT BLOCK DIAGONAL UPPER MIDDLE LEFT TO UPPER CENTRE;So;0;ON;;;;;N;;;;;
+1FB42;LOWER RIGHT BLOCK DIAGONAL UPPER MIDDLE LEFT TO UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1FB43;LOWER RIGHT BLOCK DIAGONAL LOWER MIDDLE LEFT TO UPPER CENTRE;So;0;ON;;;;;N;;;;;
+1FB44;LOWER RIGHT BLOCK DIAGONAL LOWER MIDDLE LEFT TO UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1FB45;LOWER RIGHT BLOCK DIAGONAL LOWER LEFT TO UPPER CENTRE;So;0;ON;;;;;N;;;;;
+1FB46;LOWER RIGHT BLOCK DIAGONAL LOWER MIDDLE LEFT TO UPPER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB47;LOWER RIGHT BLOCK DIAGONAL LOWER CENTRE TO LOWER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB48;LOWER RIGHT BLOCK DIAGONAL LOWER LEFT TO LOWER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB49;LOWER RIGHT BLOCK DIAGONAL LOWER CENTRE TO UPPER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB4A;LOWER RIGHT BLOCK DIAGONAL LOWER LEFT TO UPPER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB4B;LOWER RIGHT BLOCK DIAGONAL LOWER CENTRE TO UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1FB4C;LOWER LEFT BLOCK DIAGONAL UPPER CENTRE TO UPPER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB4D;LOWER LEFT BLOCK DIAGONAL UPPER LEFT TO UPPER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB4E;LOWER LEFT BLOCK DIAGONAL UPPER CENTRE TO LOWER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB4F;LOWER LEFT BLOCK DIAGONAL UPPER LEFT TO LOWER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB50;LOWER LEFT BLOCK DIAGONAL UPPER CENTRE TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FB51;LOWER LEFT BLOCK DIAGONAL UPPER MIDDLE LEFT TO LOWER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB52;UPPER RIGHT BLOCK DIAGONAL LOWER MIDDLE LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FB53;UPPER RIGHT BLOCK DIAGONAL LOWER MIDDLE LEFT TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FB54;UPPER RIGHT BLOCK DIAGONAL UPPER MIDDLE LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FB55;UPPER RIGHT BLOCK DIAGONAL UPPER MIDDLE LEFT TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FB56;UPPER RIGHT BLOCK DIAGONAL UPPER LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FB57;UPPER LEFT BLOCK DIAGONAL UPPER MIDDLE LEFT TO UPPER CENTRE;So;0;ON;;;;;N;;;;;
+1FB58;UPPER LEFT BLOCK DIAGONAL UPPER MIDDLE LEFT TO UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1FB59;UPPER LEFT BLOCK DIAGONAL LOWER MIDDLE LEFT TO UPPER CENTRE;So;0;ON;;;;;N;;;;;
+1FB5A;UPPER LEFT BLOCK DIAGONAL LOWER MIDDLE LEFT TO UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1FB5B;UPPER LEFT BLOCK DIAGONAL LOWER LEFT TO UPPER CENTRE;So;0;ON;;;;;N;;;;;
+1FB5C;UPPER LEFT BLOCK DIAGONAL LOWER MIDDLE LEFT TO UPPER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB5D;UPPER LEFT BLOCK DIAGONAL LOWER CENTRE TO LOWER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB5E;UPPER LEFT BLOCK DIAGONAL LOWER LEFT TO LOWER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB5F;UPPER LEFT BLOCK DIAGONAL LOWER CENTRE TO UPPER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB60;UPPER LEFT BLOCK DIAGONAL LOWER LEFT TO UPPER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB61;UPPER LEFT BLOCK DIAGONAL LOWER CENTRE TO UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1FB62;UPPER RIGHT BLOCK DIAGONAL UPPER CENTRE TO UPPER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB63;UPPER RIGHT BLOCK DIAGONAL UPPER LEFT TO UPPER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB64;UPPER RIGHT BLOCK DIAGONAL UPPER CENTRE TO LOWER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB65;UPPER RIGHT BLOCK DIAGONAL UPPER LEFT TO LOWER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB66;UPPER RIGHT BLOCK DIAGONAL UPPER CENTRE TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FB67;UPPER RIGHT BLOCK DIAGONAL UPPER MIDDLE LEFT TO LOWER MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FB68;UPPER AND RIGHT AND LOWER TRIANGULAR THREE QUARTERS BLOCK;So;0;ON;;;;;N;;;;;
+1FB69;LEFT AND LOWER AND RIGHT TRIANGULAR THREE QUARTERS BLOCK;So;0;ON;;;;;N;;;;;
+1FB6A;UPPER AND LEFT AND LOWER TRIANGULAR THREE QUARTERS BLOCK;So;0;ON;;;;;N;;;;;
+1FB6B;LEFT AND UPPER AND RIGHT TRIANGULAR THREE QUARTERS BLOCK;So;0;ON;;;;;N;;;;;
+1FB6C;LEFT TRIANGULAR ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1FB6D;UPPER TRIANGULAR ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1FB6E;RIGHT TRIANGULAR ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1FB6F;LOWER TRIANGULAR ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1FB70;VERTICAL ONE EIGHTH BLOCK-2;So;0;ON;;;;;N;;;;;
+1FB71;VERTICAL ONE EIGHTH BLOCK-3;So;0;ON;;;;;N;;;;;
+1FB72;VERTICAL ONE EIGHTH BLOCK-4;So;0;ON;;;;;N;;;;;
+1FB73;VERTICAL ONE EIGHTH BLOCK-5;So;0;ON;;;;;N;;;;;
+1FB74;VERTICAL ONE EIGHTH BLOCK-6;So;0;ON;;;;;N;;;;;
+1FB75;VERTICAL ONE EIGHTH BLOCK-7;So;0;ON;;;;;N;;;;;
+1FB76;HORIZONTAL ONE EIGHTH BLOCK-2;So;0;ON;;;;;N;;;;;
+1FB77;HORIZONTAL ONE EIGHTH BLOCK-3;So;0;ON;;;;;N;;;;;
+1FB78;HORIZONTAL ONE EIGHTH BLOCK-4;So;0;ON;;;;;N;;;;;
+1FB79;HORIZONTAL ONE EIGHTH BLOCK-5;So;0;ON;;;;;N;;;;;
+1FB7A;HORIZONTAL ONE EIGHTH BLOCK-6;So;0;ON;;;;;N;;;;;
+1FB7B;HORIZONTAL ONE EIGHTH BLOCK-7;So;0;ON;;;;;N;;;;;
+1FB7C;LEFT AND LOWER ONE EIGHTH BLOCK;So;0;ON;;;;;N;;;;;
+1FB7D;LEFT AND UPPER ONE EIGHTH BLOCK;So;0;ON;;;;;N;;;;;
+1FB7E;RIGHT AND UPPER ONE EIGHTH BLOCK;So;0;ON;;;;;N;;;;;
+1FB7F;RIGHT AND LOWER ONE EIGHTH BLOCK;So;0;ON;;;;;N;;;;;
+1FB80;UPPER AND LOWER ONE EIGHTH BLOCK;So;0;ON;;;;;N;;;;;
+1FB81;HORIZONTAL ONE EIGHTH BLOCK-1358;So;0;ON;;;;;N;;;;;
+1FB82;UPPER ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1FB83;UPPER THREE EIGHTHS BLOCK;So;0;ON;;;;;N;;;;;
+1FB84;UPPER FIVE EIGHTHS BLOCK;So;0;ON;;;;;N;;;;;
+1FB85;UPPER THREE QUARTERS BLOCK;So;0;ON;;;;;N;;;;;
+1FB86;UPPER SEVEN EIGHTHS BLOCK;So;0;ON;;;;;N;;;;;
+1FB87;RIGHT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1FB88;RIGHT THREE EIGHTHS BLOCK;So;0;ON;;;;;N;;;;;
+1FB89;RIGHT FIVE EIGHTHS BLOCK;So;0;ON;;;;;N;;;;;
+1FB8A;RIGHT THREE QUARTERS BLOCK;So;0;ON;;;;;N;;;;;
+1FB8B;RIGHT SEVEN EIGHTHS BLOCK;So;0;ON;;;;;N;;;;;
+1FB8C;LEFT HALF MEDIUM SHADE;So;0;ON;;;;;N;;;;;
+1FB8D;RIGHT HALF MEDIUM SHADE;So;0;ON;;;;;N;;;;;
+1FB8E;UPPER HALF MEDIUM SHADE;So;0;ON;;;;;N;;;;;
+1FB8F;LOWER HALF MEDIUM SHADE;So;0;ON;;;;;N;;;;;
+1FB90;INVERSE MEDIUM SHADE;So;0;ON;;;;;N;;;;;
+1FB91;UPPER HALF BLOCK AND LOWER HALF INVERSE MEDIUM SHADE;So;0;ON;;;;;N;;;;;
+1FB92;UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK;So;0;ON;;;;;N;;;;;
+1FB94;LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK;So;0;ON;;;;;N;;;;;
+1FB95;CHECKER BOARD FILL;So;0;ON;;;;;N;;;;;
+1FB96;INVERSE CHECKER BOARD FILL;So;0;ON;;;;;N;;;;;
+1FB97;HEAVY HORIZONTAL FILL;So;0;ON;;;;;N;;;;;
+1FB98;UPPER LEFT TO LOWER RIGHT FILL;So;0;ON;;;;;N;;;;;
+1FB99;UPPER RIGHT TO LOWER LEFT FILL;So;0;ON;;;;;N;;;;;
+1FB9A;UPPER AND LOWER TRIANGULAR HALF BLOCK;So;0;ON;;;;;N;;;;;
+1FB9B;LEFT AND RIGHT TRIANGULAR HALF BLOCK;So;0;ON;;;;;N;;;;;
+1FB9C;UPPER LEFT TRIANGULAR MEDIUM SHADE;So;0;ON;;;;;N;;;;;
+1FB9D;UPPER RIGHT TRIANGULAR MEDIUM SHADE;So;0;ON;;;;;N;;;;;
+1FB9E;LOWER RIGHT TRIANGULAR MEDIUM SHADE;So;0;ON;;;;;N;;;;;
+1FB9F;LOWER LEFT TRIANGULAR MEDIUM SHADE;So;0;ON;;;;;N;;;;;
+1FBA0;BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE LEFT;So;0;ON;;;;;N;;;;;
+1FBA1;BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FBA2;BOX DRAWINGS LIGHT DIAGONAL MIDDLE LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBA3;BOX DRAWINGS LIGHT DIAGONAL MIDDLE RIGHT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBA4;BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBA5;BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE RIGHT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBA6;BOX DRAWINGS LIGHT DIAGONAL MIDDLE LEFT TO LOWER CENTRE TO MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FBA7;BOX DRAWINGS LIGHT DIAGONAL MIDDLE LEFT TO UPPER CENTRE TO MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FBA8;BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE LEFT AND MIDDLE RIGHT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBA9;BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE RIGHT AND MIDDLE LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBAA;BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE RIGHT TO LOWER CENTRE TO MIDDLE LEFT;So;0;ON;;;;;N;;;;;
+1FBAB;BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE LEFT TO LOWER CENTRE TO MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FBAC;BOX DRAWINGS LIGHT DIAGONAL MIDDLE LEFT TO UPPER CENTRE TO MIDDLE RIGHT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBAD;BOX DRAWINGS LIGHT DIAGONAL MIDDLE RIGHT TO UPPER CENTRE TO MIDDLE LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBAE;BOX DRAWINGS LIGHT DIAGONAL DIAMOND;So;0;ON;;;;;N;;;;;
+1FBAF;BOX DRAWINGS LIGHT HORIZONTAL WITH VERTICAL STROKE;So;0;ON;;;;;N;;;;;
+1FBB0;ARROWHEAD-SHAPED POINTER;So;0;ON;;;;;N;;;;;
+1FBB1;INVERSE CHECK MARK;So;0;ON;;;;;N;;;;;
+1FBB2;LEFT HALF RUNNING MAN;So;0;ON;;;;;N;;;;;
+1FBB3;RIGHT HALF RUNNING MAN;So;0;ON;;;;;N;;;;;
+1FBB4;INVERSE DOWNWARDS ARROW WITH TIP LEFTWARDS;So;0;ON;;;;;N;;;;;
+1FBB5;LEFTWARDS ARROW AND UPPER AND LOWER ONE EIGHTH BLOCK;So;0;ON;;;;;N;;;;;
+1FBB6;RIGHTWARDS ARROW AND UPPER AND LOWER ONE EIGHTH BLOCK;So;0;ON;;;;;N;;;;;
+1FBB7;DOWNWARDS ARROW AND RIGHT ONE EIGHTH BLOCK;So;0;ON;;;;;N;;;;;
+1FBB8;UPWARDS ARROW AND RIGHT ONE EIGHTH BLOCK;So;0;ON;;;;;N;;;;;
+1FBB9;LEFT HALF FOLDER;So;0;ON;;;;;N;;;;;
+1FBBA;RIGHT HALF FOLDER;So;0;ON;;;;;N;;;;;
+1FBBB;VOIDED GREEK CROSS;So;0;ON;;;;;N;;;;;
+1FBBC;RIGHT OPEN SQUARED DOT;So;0;ON;;;;;N;;;;;
+1FBBD;NEGATIVE DIAGONAL CROSS;So;0;ON;;;;;N;;;;;
+1FBBE;NEGATIVE DIAGONAL MIDDLE RIGHT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBBF;NEGATIVE DIAGONAL DIAMOND;So;0;ON;;;;;N;;;;;
+1FBC0;WHITE HEAVY SALTIRE WITH ROUNDED CORNERS;So;0;ON;;;;;N;;;;;
+1FBC1;LEFT THIRD WHITE RIGHT POINTING INDEX;So;0;ON;;;;;N;;;;;
+1FBC2;MIDDLE THIRD WHITE RIGHT POINTING INDEX;So;0;ON;;;;;N;;;;;
+1FBC3;RIGHT THIRD WHITE RIGHT POINTING INDEX;So;0;ON;;;;;N;;;;;
+1FBC4;NEGATIVE SQUARED QUESTION MARK;So;0;ON;;;;;N;;;;;
+1FBC5;STICK FIGURE;So;0;ON;;;;;N;;;;;
+1FBC6;STICK FIGURE WITH ARMS RAISED;So;0;ON;;;;;N;;;;;
+1FBC7;STICK FIGURE LEANING LEFT;So;0;ON;;;;;N;;;;;
+1FBC8;STICK FIGURE LEANING RIGHT;So;0;ON;;;;;N;;;;;
+1FBC9;STICK FIGURE WITH DRESS;So;0;ON;;;;;N;;;;;
+1FBCA;WHITE UP-POINTING CHEVRON;So;0;ON;;;;;N;;;;;
+1FBCB;WHITE CROSS MARK;So;0;ON;;;;;N;;;;;
+1FBCC;RAISED SMALL LEFT SQUARE BRACKET;So;0;ON;;;;;N;;;;;
+1FBCD;BLACK SMALL UP-POINTING CHEVRON;So;0;ON;;;;;N;;;;;
+1FBCE;LEFT TWO THIRDS BLOCK;So;0;ON;;;;;N;;;;;
+1FBCF;LEFT ONE THIRD BLOCK;So;0;ON;;;;;N;;;;;
+1FBD0;BOX DRAWINGS LIGHT DIAGONAL MIDDLE RIGHT TO LOWER LEFT;So;0;ON;;;;;N;;;;;
+1FBD1;BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO MIDDLE LEFT;So;0;ON;;;;;N;;;;;
+1FBD2;BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO MIDDLE RIGHT;So;0;ON;;;;;N;;;;;
+1FBD3;BOX DRAWINGS LIGHT DIAGONAL MIDDLE LEFT TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FBD4;BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBD5;BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FBD6;BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER CENTRE;So;0;ON;;;;;N;;;;;
+1FBD7;BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO LOWER LEFT;So;0;ON;;;;;N;;;;;
+1FBD8;BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO MIDDLE CENTRE TO UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1FBD9;BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO MIDDLE CENTRE TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FBDA;BOX DRAWINGS LIGHT DIAGONAL LOWER LEFT TO MIDDLE CENTRE TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FBDB;BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO MIDDLE CENTRE TO LOWER LEFT;So;0;ON;;;;;N;;;;;
+1FBDC;BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER CENTRE TO UPPER RIGHT;So;0;ON;;;;;N;;;;;
+1FBDD;BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO MIDDLE LEFT TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FBDE;BOX DRAWINGS LIGHT DIAGONAL LOWER LEFT TO UPPER CENTRE TO LOWER RIGHT;So;0;ON;;;;;N;;;;;
+1FBDF;BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO MIDDLE RIGHT TO LOWER LEFT;So;0;ON;;;;;N;;;;;
+1FBE0;TOP JUSTIFIED LOWER HALF WHITE CIRCLE;So;0;ON;;;;;N;;;;;
+1FBE1;RIGHT JUSTIFIED LEFT HALF WHITE CIRCLE;So;0;ON;;;;;N;;;;;
+1FBE2;BOTTOM JUSTIFIED UPPER HALF WHITE CIRCLE;So;0;ON;;;;;N;;;;;
+1FBE3;LEFT JUSTIFIED RIGHT HALF WHITE CIRCLE;So;0;ON;;;;;N;;;;;
+1FBE4;UPPER CENTRE ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1FBE5;LOWER CENTRE ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1FBE6;MIDDLE LEFT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1FBE7;MIDDLE RIGHT ONE QUARTER BLOCK;So;0;ON;;;;;N;;;;;
+1FBE8;TOP JUSTIFIED LOWER HALF BLACK CIRCLE;So;0;ON;;;;;N;;;;;
+1FBE9;RIGHT JUSTIFIED LEFT HALF BLACK CIRCLE;So;0;ON;;;;;N;;;;;
+1FBEA;BOTTOM JUSTIFIED UPPER HALF BLACK CIRCLE;So;0;ON;;;;;N;;;;;
+1FBEB;LEFT JUSTIFIED RIGHT HALF BLACK CIRCLE;So;0;ON;;;;;N;;;;;
+1FBEC;TOP RIGHT JUSTIFIED LOWER LEFT QUARTER BLACK CIRCLE;So;0;ON;;;;;N;;;;;
+1FBED;BOTTOM LEFT JUSTIFIED UPPER RIGHT QUARTER BLACK CIRCLE;So;0;ON;;;;;N;;;;;
+1FBEE;BOTTOM RIGHT JUSTIFIED UPPER LEFT QUARTER BLACK CIRCLE;So;0;ON;;;;;N;;;;;
+1FBEF;TOP LEFT JUSTIFIED LOWER RIGHT QUARTER BLACK CIRCLE;So;0;ON;;;;;N;;;;;
+1FBF0;SEGMENTED DIGIT ZERO;Nd;0;EN;<font> 0030;0;0;0;N;;;;;
+1FBF1;SEGMENTED DIGIT ONE;Nd;0;EN;<font> 0031;1;1;1;N;;;;;
+1FBF2;SEGMENTED DIGIT TWO;Nd;0;EN;<font> 0032;2;2;2;N;;;;;
+1FBF3;SEGMENTED DIGIT THREE;Nd;0;EN;<font> 0033;3;3;3;N;;;;;
+1FBF4;SEGMENTED DIGIT FOUR;Nd;0;EN;<font> 0034;4;4;4;N;;;;;
+1FBF5;SEGMENTED DIGIT FIVE;Nd;0;EN;<font> 0035;5;5;5;N;;;;;
+1FBF6;SEGMENTED DIGIT SIX;Nd;0;EN;<font> 0036;6;6;6;N;;;;;
+1FBF7;SEGMENTED DIGIT SEVEN;Nd;0;EN;<font> 0037;7;7;7;N;;;;;
+1FBF8;SEGMENTED DIGIT EIGHT;Nd;0;EN;<font> 0038;8;8;8;N;;;;;
+1FBF9;SEGMENTED DIGIT NINE;Nd;0;EN;<font> 0039;9;9;9;N;;;;;
+1FBFA;ALARM BELL SYMBOL;So;0;ON;;;;;N;;;;;
 20000;<CJK Ideograph Extension B, First>;Lo;0;L;;;;;N;;;;;
-2A6D6;<CJK Ideograph Extension B, Last>;Lo;0;L;;;;;N;;;;;
+2A6DF;<CJK Ideograph Extension B, Last>;Lo;0;L;;;;;N;;;;;
 2A700;<CJK Ideograph Extension C, First>;Lo;0;L;;;;;N;;;;;
-2B734;<CJK Ideograph Extension C, Last>;Lo;0;L;;;;;N;;;;;
+2B73F;<CJK Ideograph Extension C, Last>;Lo;0;L;;;;;N;;;;;
 2B740;<CJK Ideograph Extension D, First>;Lo;0;L;;;;;N;;;;;
 2B81D;<CJK Ideograph Extension D, Last>;Lo;0;L;;;;;N;;;;;
+2B820;<CJK Ideograph Extension E, First>;Lo;0;L;;;;;N;;;;;
+2CEAD;<CJK Ideograph Extension E, Last>;Lo;0;L;;;;;N;;;;;
+2CEB0;<CJK Ideograph Extension F, First>;Lo;0;L;;;;;N;;;;;
+2EBE0;<CJK Ideograph Extension F, Last>;Lo;0;L;;;;;N;;;;;
+2EBF0;<CJK Ideograph Extension I, First>;Lo;0;L;;;;;N;;;;;
+2EE5D;<CJK Ideograph Extension I, Last>;Lo;0;L;;;;;N;;;;;
 2F800;CJK COMPATIBILITY IDEOGRAPH-2F800;Lo;0;L;4E3D;;;;N;;;;;
 2F801;CJK COMPATIBILITY IDEOGRAPH-2F801;Lo;0;L;4E38;;;;N;;;;;
 2F802;CJK COMPATIBILITY IDEOGRAPH-2F802;Lo;0;L;4E41;;;;N;;;;;
@@ -26925,6 +40226,12 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;;
 2FA1B;CJK COMPATIBILITY IDEOGRAPH-2FA1B;Lo;0;L;9F16;;;;N;;;;;
 2FA1C;CJK COMPATIBILITY IDEOGRAPH-2FA1C;Lo;0;L;9F3B;;;;N;;;;;
 2FA1D;CJK COMPATIBILITY IDEOGRAPH-2FA1D;Lo;0;L;2A600;;;;N;;;;;
+30000;<CJK Ideograph Extension G, First>;Lo;0;L;;;;;N;;;;;
+3134A;<CJK Ideograph Extension G, Last>;Lo;0;L;;;;;N;;;;;
+31350;<CJK Ideograph Extension H, First>;Lo;0;L;;;;;N;;;;;
+323AF;<CJK Ideograph Extension H, Last>;Lo;0;L;;;;;N;;;;;
+323B0;<CJK Ideograph Extension J, First>;Lo;0;L;;;;;N;;;;;
+33479;<CJK Ideograph Extension J, Last>;Lo;0;L;;;;;N;;;;;
 E0001;LANGUAGE TAG;Cf;0;BN;;;;;N;;;;;
 E0020;TAG SPACE;Cf;0;BN;;;;;N;;;;;
 E0021;TAG EXCLAMATION MARK;Cf;0;BN;;;;;N;;;;;
diff --git a/lib/elixir/unicode/confusables.txt b/lib/elixir/unicode/confusables.txt
new file mode 100644
index 00000000000..d52b6278a42
--- /dev/null
+++ b/lib/elixir/unicode/confusables.txt
@@ -0,0 +1,9994 @@
+# confusables.txt
+# Date: 2025-07-22, 05:49:37 GMT
+# © 2025 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use and license, see https://www.unicode.org/terms_of_use.html
+#
+# Unicode Security Mechanisms for UTS #39
+# Version: 17.0.0
+#
+# For documentation and usage, see https://www.unicode.org/reports/tr39
+#
+05AD ;	0596 ;	MA	# ( ֭ → ֖ ) HEBREW ACCENT DEHI → HEBREW ACCENT TIPEHA	# 
+
+05AE ;	0598 ;	MA	# ( ֮ → ֘ ) HEBREW ACCENT ZINOR → HEBREW ACCENT ZARQA	# 
+
+05A8 ;	0599 ;	MA	# ( ֨ → ֙ ) HEBREW ACCENT QADMA → HEBREW ACCENT PASHTA	# 
+
+05A4 ;	059A ;	MA	# ( ֤ → ֚ ) HEBREW ACCENT MAHAPAKH → HEBREW ACCENT YETIV	# 
+
+1AB4 ;	06DB ;	MA	# ( ᪴ → ۛ ) COMBINING TRIPLE DOT → ARABIC SMALL HIGH THREE DOTS	# 
+20DB ;	06DB ;	MA	# ( ⃛ → ۛ ) COMBINING THREE DOTS ABOVE → ARABIC SMALL HIGH THREE DOTS	# →᪴→
+
+0619 ;	0313 ;	MA	# ( ؙ → ̓ ) ARABIC SMALL DAMMA → COMBINING COMMA ABOVE	# →ُ→
+08F3 ;	0313 ;	MA	# ( ࣳ → ̓ ) ARABIC SMALL HIGH WAW → COMBINING COMMA ABOVE	# →ُ→
+0343 ;	0313 ;	MA	# ( ̓ → ̓ ) COMBINING GREEK KORONIS → COMBINING COMMA ABOVE	# 
+0315 ;	0313 ;	MA	# ( ̕ → ̓ ) COMBINING COMMA ABOVE RIGHT → COMBINING COMMA ABOVE	# 
+064F ;	0313 ;	MA	# ( ُ → ̓ ) ARABIC DAMMA → COMBINING COMMA ABOVE	# 
+
+065D ;	0314 ;	MA	# ( ٝ → ̔ ) ARABIC REVERSED DAMMA → COMBINING REVERSED COMMA ABOVE	# 
+
+059C ;	0301 ;	MA	# ( ֜ → ́ ) HEBREW ACCENT GERESH → COMBINING ACUTE ACCENT	# 
+059D ;	0301 ;	MA	# ( ֝ → ́ ) HEBREW ACCENT GERESH MUQDAM → COMBINING ACUTE ACCENT	# →֜→
+0618 ;	0301 ;	MA	# ( ؘ → ́ ) ARABIC SMALL FATHA → COMBINING ACUTE ACCENT	# →َ→
+0747 ;	0301 ;	MA	# ( ݇ → ́ ) SYRIAC OBLIQUE LINE ABOVE → COMBINING ACUTE ACCENT	# 
+0341 ;	0301 ;	MA	# ( ́ → ́ ) COMBINING ACUTE TONE MARK → COMBINING ACUTE ACCENT	# 
+0954 ;	0301 ;	MA	# ( ॔ → ́ ) DEVANAGARI ACUTE ACCENT → COMBINING ACUTE ACCENT	# 
+064E ;	0301 ;	MA	# ( َ → ́ ) ARABIC FATHA → COMBINING ACUTE ACCENT	# 
+
+0340 ;	0300 ;	MA	# ( ̀ → ̀ ) COMBINING GRAVE TONE MARK → COMBINING GRAVE ACCENT	# 
+0953 ;	0300 ;	MA	# ( ॓ → ̀ ) DEVANAGARI GRAVE ACCENT → COMBINING GRAVE ACCENT	# 
+
+030C ;	0306 ;	MA	# ( ̌ → ̆ ) COMBINING CARON → COMBINING BREVE	# 
+A67C ;	0306 ;	MA	# ( ꙼ → ̆ ) COMBINING CYRILLIC KAVYKA → COMBINING BREVE	# 
+0658 ;	0306 ;	MA	# ( ٘ → ̆ ) ARABIC MARK NOON GHUNNA → COMBINING BREVE	# 
+065A ;	0306 ;	MA	# ( ٚ → ̆ ) ARABIC VOWEL SIGN SMALL V ABOVE → COMBINING BREVE	# →̌→
+036E ;	0306 ;	MA	# ( ͮ → ̆ ) COMBINING LATIN SMALL LETTER V → COMBINING BREVE	# →̌→
+0945 ;	0306 ;	MA	# ( ॅ → ̆ ) DEVANAGARI VOWEL SIGN CANDRA E → COMBINING BREVE	# 
+11B66 ;	0306 ;	MA	# ( 𑭦 → ̆ ) SHARADA VOWEL SIGN CANDRA E → COMBINING BREVE	# →ॅ→
+
+06E8 ;	0306 0307 ;	MA	# ( ۨ → ̆̇ ) ARABIC SMALL HIGH NOON → COMBINING BREVE, COMBINING DOT ABOVE	# →̐→
+0310 ;	0306 0307 ;	MA	# ( ̐ → ̆̇ ) COMBINING CANDRABINDU → COMBINING BREVE, COMBINING DOT ABOVE	# 
+0901 ;	0306 0307 ;	MA	# ( ँ → ̆̇ ) DEVANAGARI SIGN CANDRABINDU → COMBINING BREVE, COMBINING DOT ABOVE	# →̐→
+0981 ;	0306 0307 ;	MA	# ( ঁ → ̆̇ ) BENGALI SIGN CANDRABINDU → COMBINING BREVE, COMBINING DOT ABOVE	# →̐→
+0A81 ;	0306 0307 ;	MA	# ( ઁ → ̆̇ ) GUJARATI SIGN CANDRABINDU → COMBINING BREVE, COMBINING DOT ABOVE	# →̐→
+0B01 ;	0306 0307 ;	MA	# ( ଁ → ̆̇ ) ORIYA SIGN CANDRABINDU → COMBINING BREVE, COMBINING DOT ABOVE	# →̐→
+0C00 ;	0306 0307 ;	MA	# ( ఀ → ̆̇ ) TELUGU SIGN COMBINING CANDRABINDU ABOVE → COMBINING BREVE, COMBINING DOT ABOVE	# →ँ→→̐→
+0C81 ;	0306 0307 ;	MA	# ( ಁ → ̆̇ ) KANNADA SIGN CANDRABINDU → COMBINING BREVE, COMBINING DOT ABOVE	# →ँ→→̐→
+0D01 ;	0306 0307 ;	MA	# ( ഁ → ̆̇ ) MALAYALAM SIGN CANDRABINDU → COMBINING BREVE, COMBINING DOT ABOVE	# →ँ→→̐→
+114BF ;	0306 0307 ;	MA	# ( 𑒿 → ̆̇ ) TIRHUTA SIGN CANDRABINDU → COMBINING BREVE, COMBINING DOT ABOVE	# →ঁ→→̐→
+
+1CD0 ;	0302 ;	MA	# ( ᳐ → ̂ ) VEDIC TONE KARSHANA → COMBINING CIRCUMFLEX ACCENT	# 
+0311 ;	0302 ;	MA	# ( ̑ → ̂ ) COMBINING INVERTED BREVE → COMBINING CIRCUMFLEX ACCENT	# 
+065B ;	0302 ;	MA	# ( ٛ → ̂ ) ARABIC VOWEL SIGN INVERTED SMALL V ABOVE → COMBINING CIRCUMFLEX ACCENT	# 
+07EE ;	0302 ;	MA	# ( ߮ → ̂ ) NKO COMBINING LONG DESCENDING TONE → COMBINING CIRCUMFLEX ACCENT	# 
+A6F0 ;	0302 ;	MA	# ( ꛰ → ̂ ) BAMUM COMBINING MARK KOQNDON → COMBINING CIRCUMFLEX ACCENT	# 
+
+05AF ;	030A ;	MA	# ( ֯ → ̊ ) HEBREW MARK MASORA CIRCLE → COMBINING RING ABOVE	# 
+06DF ;	030A ;	MA	# ( ۟ → ̊ ) ARABIC SMALL HIGH ROUNDED ZERO → COMBINING RING ABOVE	# →ْ→
+17D3 ;	030A ;	MA	# ( ៓ → ̊ ) KHMER SIGN BATHAMASAT → COMBINING RING ABOVE	# 
+309A ;	030A ;	MA	# ( ゚ → ̊ ) COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK → COMBINING RING ABOVE	# 
+0652 ;	030A ;	MA	# ( ْ → ̊ ) ARABIC SUKUN → COMBINING RING ABOVE	# 
+0B82 ;	030A ;	MA	# ( ஂ → ̊ ) TAMIL SIGN ANUSVARA → COMBINING RING ABOVE	# 
+1036 ;	030A ;	MA	# ( ံ → ̊ ) MYANMAR SIGN ANUSVARA → COMBINING RING ABOVE	# 
+17C6 ;	030A ;	MA	# ( ំ → ̊ ) KHMER SIGN NIKAHIT → COMBINING RING ABOVE	# 
+11300 ;	030A ;	MA	# ( 𑌀 → ̊ ) GRANTHA SIGN COMBINING ANUSVARA ABOVE → COMBINING RING ABOVE	# →ஂ→
+0E4D ;	030A ;	MA	# ( ํ → ̊ ) THAI CHARACTER NIKHAHIT → COMBINING RING ABOVE	# 
+0ECD ;	030A ;	MA	# ( ໍ → ̊ ) LAO NIGGAHITA → COMBINING RING ABOVE	# 
+0366 ;	030A ;	MA	# ( ͦ → ̊ ) COMBINING LATIN SMALL LETTER O → COMBINING RING ABOVE	# 
+2DEA ;	030A ;	MA	# ( ⷪ → ̊ ) COMBINING CYRILLIC LETTER O → COMBINING RING ABOVE	# →ͦ→
+
+08EB ;	0308 ;	MA	# ( ࣫ → ̈ ) ARABIC TONE TWO DOTS ABOVE → COMBINING DIAERESIS	# 
+07F3 ;	0308 ;	MA	# ( ߳ → ̈ ) NKO COMBINING DOUBLE DOT ABOVE → COMBINING DIAERESIS	# 
+
+064B ;	030B ;	MA	# ( ً → ̋ ) ARABIC FATHATAN → COMBINING DOUBLE ACUTE ACCENT	# 
+08F0 ;	030B ;	MA	# ( ࣰ → ̋ ) ARABIC OPEN FATHATAN → COMBINING DOUBLE ACUTE ACCENT	# →ً→
+
+0342 ;	0303 ;	MA	# ( ͂ → ̃ ) COMBINING GREEK PERISPOMENI → COMBINING TILDE	# 
+0653 ;	0303 ;	MA	# ( ٓ → ̃ ) ARABIC MADDAH ABOVE → COMBINING TILDE	# 
+
+05C4 ;	0307 ;	MA	# ( ׄ → ̇ ) HEBREW MARK UPPER DOT → COMBINING DOT ABOVE	# 
+06EC ;	0307 ;	MA	# ( ۬ → ̇ ) ARABIC ROUNDED HIGH STOP WITH FILLED CENTRE → COMBINING DOT ABOVE	# 
+0740 ;	0307 ;	MA	# ( ݀ → ̇ ) SYRIAC FEMININE DOT → COMBINING DOT ABOVE	# →݁→
+08EA ;	0307 ;	MA	# ( ࣪ → ̇ ) ARABIC TONE ONE DOT ABOVE → COMBINING DOT ABOVE	# 
+0741 ;	0307 ;	MA	# ( ݁ → ̇ ) SYRIAC QUSHSHAYA → COMBINING DOT ABOVE	# 
+0358 ;	0307 ;	MA	# ( ͘ → ̇ ) COMBINING DOT ABOVE RIGHT → COMBINING DOT ABOVE	# 
+05B9 ;	0307 ;	MA	# ( ֹ → ̇ ) HEBREW POINT HOLAM → COMBINING DOT ABOVE	# 
+05BA ;	0307 ;	MA	# ( ֺ → ̇ ) HEBREW POINT HOLAM HASER FOR VAV → COMBINING DOT ABOVE	# →ׁ→
+05C2 ;	0307 ;	MA	# ( ׂ → ̇ ) HEBREW POINT SIN DOT → COMBINING DOT ABOVE	# 
+05C1 ;	0307 ;	MA	# ( ׁ → ̇ ) HEBREW POINT SHIN DOT → COMBINING DOT ABOVE	# 
+07ED ;	0307 ;	MA	# ( ߭ → ̇ ) NKO COMBINING SHORT RISING TONE → COMBINING DOT ABOVE	# 
+0902 ;	0307 ;	MA	# ( ं → ̇ ) DEVANAGARI SIGN ANUSVARA → COMBINING DOT ABOVE	# 
+0A02 ;	0307 ;	MA	# ( ਂ → ̇ ) GURMUKHI SIGN BINDI → COMBINING DOT ABOVE	# 
+0A82 ;	0307 ;	MA	# ( ં → ̇ ) GUJARATI SIGN ANUSVARA → COMBINING DOT ABOVE	# 
+0BCD ;	0307 ;	MA	# ( ் → ̇ ) TAMIL SIGN VIRAMA → COMBINING DOT ABOVE	# 
+
+0337 ;	0338 ;	MA	# ( ̷ → ̸ ) COMBINING SHORT SOLIDUS OVERLAY → COMBINING LONG SOLIDUS OVERLAY	# 
+
+1AB7 ;	0328 ;	MA	# ( ᪷ → ̨ ) COMBINING OPEN MARK BELOW → COMBINING OGONEK	# 
+0322 ;	0328 ;	MA	# ( ̢ → ̨ ) COMBINING RETROFLEX HOOK BELOW → COMBINING OGONEK	# 
+0345 ;	0328 ;	MA	# ( ͅ → ̨ ) COMBINING GREEK YPOGEGRAMMENI → COMBINING OGONEK	# 
+
+1CD2 ;	0304 ;	MA	# ( ᳒ → ̄ ) VEDIC TONE PRENKHA → COMBINING MACRON	# 
+0305 ;	0304 ;	MA	# ( ̅ → ̄ ) COMBINING OVERLINE → COMBINING MACRON	# 
+0659 ;	0304 ;	MA	# ( ٙ → ̄ ) ARABIC ZWARAKAY → COMBINING MACRON	# 
+07EB ;	0304 ;	MA	# ( ߫ → ̄ ) NKO COMBINING SHORT HIGH TONE → COMBINING MACRON	# 
+A6F1 ;	0304 ;	MA	# ( ꛱ → ̄ ) BAMUM COMBINING MARK TUKWENTIS → COMBINING MACRON	# 
+1AE2 ;	0304 ;	MA	# ( ᫢ → ̄ ) COMBINING MINUS SIGN ABOVE → COMBINING MACRON	# 
+
+1AE8 ;	0304 0304 ;	MA	# ( ᫨ → ̄̄ ) COMBINING EQUALS SIGN ABOVE → COMBINING MACRON, COMBINING MACRON	# 
+
+1CDA ;	030E ;	MA	# ( ᳚ → ̎ ) VEDIC TONE DOUBLE SVARITA → COMBINING DOUBLE VERTICAL LINE ABOVE	# 
+
+0657 ;	0312 ;	MA	# ( ٗ → ̒ ) ARABIC INVERTED DAMMA → COMBINING TURNED COMMA ABOVE	# 
+
+0357 ;	0350 ;	MA	# ( ͗ → ͐ ) COMBINING RIGHT HALF RING ABOVE → COMBINING RIGHT ARROWHEAD ABOVE	# →ࣿ→→ࣸ→
+08FF ;	0350 ;	MA	# ( ࣿ → ͐ ) ARABIC MARK SIDEWAYS NOON GHUNNA → COMBINING RIGHT ARROWHEAD ABOVE	# →ࣸ→
+08F8 ;	0350 ;	MA	# ( ࣸ → ͐ ) ARABIC RIGHT ARROWHEAD ABOVE → COMBINING RIGHT ARROWHEAD ABOVE	# 
+
+0900 ;	0352 ;	MA	# ( ऀ → ͒ ) DEVANAGARI SIGN INVERTED CANDRABINDU → COMBINING FERMATA	# 
+
+1AD9 ;	1AC6 ;	MA	# ( ᫙ → ᫆ ) COMBINING SHARP SIGN → COMBINING NUMBER SIGN ABOVE	# 
+
+1E6EE ;	1AC8 ;	MA	# ( 𞛮 → ᫈ ) TAI YO SIGN AY → COMBINING PLUS SIGN ABOVE	# 
+
+1CED ;	0316 ;	MA	# ( ᳭ → ̖ ) VEDIC SIGN TIRYAK → COMBINING GRAVE ACCENT BELOW	# 
+
+1CDC ;	0329 ;	MA	# ( ᳜ → ̩ ) VEDIC TONE KATHAKA ANUDATTA → COMBINING VERTICAL LINE BELOW	# 
+0656 ;	0329 ;	MA	# ( ٖ → ̩ ) ARABIC SUBSCRIPT ALEF → COMBINING VERTICAL LINE BELOW	# 
+
+1CD5 ;	032B ;	MA	# ( ᳕ → ̫ ) VEDIC TONE YAJURVEDIC AGGRAVATED INDEPENDENT SVARITA → COMBINING INVERTED DOUBLE ARCH BELOW	# 
+
+0347 ;	0333 ;	MA	# ( ͇ → ̳ ) COMBINING EQUALS SIGN BELOW → COMBINING DOUBLE LOW LINE	# 
+
+08F9 ;	0354 ;	MA	# ( ࣹ → ͔ ) ARABIC LEFT ARROWHEAD BELOW → COMBINING LEFT ARROWHEAD BELOW	# 
+
+08FA ;	0355 ;	MA	# ( ࣺ → ͕ ) ARABIC RIGHT ARROWHEAD BELOW → COMBINING RIGHT ARROWHEAD BELOW	# 
+
+309B ;	FF9E ;	MA	#* ( ゛ → ﾞ ) KATAKANA-HIRAGANA VOICED SOUND MARK → HALFWIDTH KATAKANA VOICED SOUND MARK	# 
+
+309C ;	FF9F ;	MA	#* ( ゜ → ﾟ ) KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK → HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK	# 
+
+0336 ;	0335 ;	MA	# ( ̶ → ̵ ) COMBINING LONG STROKE OVERLAY → COMBINING SHORT STROKE OVERLAY	# 
+
+302C ;	0309 ;	MA	# ( 〬 → ̉ ) IDEOGRAPHIC DEPARTING TONE MARK → COMBINING HOOK ABOVE	# 
+
+05C5 ;	0323 ;	MA	# ( ׅ → ̣ ) HEBREW MARK LOWER DOT → COMBINING DOT BELOW	# 
+08ED ;	0323 ;	MA	# ( ࣭ → ̣ ) ARABIC TONE ONE DOT BELOW → COMBINING DOT BELOW	# 
+1CDD ;	0323 ;	MA	# ( ᳝ → ̣ ) VEDIC TONE DOT BELOW → COMBINING DOT BELOW	# 
+05B4 ;	0323 ;	MA	# ( ִ → ̣ ) HEBREW POINT HIRIQ → COMBINING DOT BELOW	# 
+065C ;	0323 ;	MA	# ( ٜ → ̣ ) ARABIC VOWEL SIGN DOT BELOW → COMBINING DOT BELOW	# 
+093C ;	0323 ;	MA	# ( ़ → ̣ ) DEVANAGARI SIGN NUKTA → COMBINING DOT BELOW	# 
+09BC ;	0323 ;	MA	# ( ় → ̣ ) BENGALI SIGN NUKTA → COMBINING DOT BELOW	# 
+0A3C ;	0323 ;	MA	# ( ਼ → ̣ ) GURMUKHI SIGN NUKTA → COMBINING DOT BELOW	# 
+0ABC ;	0323 ;	MA	# ( ઼ → ̣ ) GUJARATI SIGN NUKTA → COMBINING DOT BELOW	# 
+0B3C ;	0323 ;	MA	# ( ଼ → ̣ ) ORIYA SIGN NUKTA → COMBINING DOT BELOW	# 
+111CA ;	0323 ;	MA	# ( 𑇊 → ̣ ) SHARADA SIGN NUKTA → COMBINING DOT BELOW	# →़→
+114C3 ;	0323 ;	MA	# ( 𑓃 → ̣ ) TIRHUTA SIGN NUKTA → COMBINING DOT BELOW	# →়→
+10A3A ;	0323 ;	MA	# ( 𐨺 → ̣ ) KHAROSHTHI SIGN DOT BELOW → COMBINING DOT BELOW	# 
+
+08EE ;	0324 ;	MA	# ( ࣮ → ̤ ) ARABIC TONE TWO DOTS BELOW → COMBINING DIAERESIS BELOW	# 
+1CDE ;	0324 ;	MA	# ( ᳞ → ̤ ) VEDIC TONE TWO DOTS BELOW → COMBINING DIAERESIS BELOW	# 
+
+0F37 ;	0325 ;	MA	# ( ༷ → ̥ ) TIBETAN MARK NGAS BZUNG SGOR RTAGS → COMBINING RING BELOW	# 
+302D ;	0325 ;	MA	# ( 〭 → ̥ ) IDEOGRAPHIC ENTERING TONE MARK → COMBINING RING BELOW	# 
+
+0327 ;	0326 ;	MA	# ( ̧ → ̦ ) COMBINING CEDILLA → COMBINING COMMA BELOW	# →̡→
+0321 ;	0326 ;	MA	# ( ̡ → ̦ ) COMBINING PALATALIZED HOOK BELOW → COMBINING COMMA BELOW	# 
+0339 ;	0326 ;	MA	# ( ̹ → ̦ ) COMBINING RIGHT HALF RING BELOW → COMBINING COMMA BELOW	# →̧→→̡→
+
+1CD9 ;	032D ;	MA	# ( ᳙ → ̭ ) VEDIC TONE YAJURVEDIC KATHAKA INDEPENDENT SVARITA SCHROEDER → COMBINING CIRCUMFLEX ACCENT BELOW	# 
+
+1CD8 ;	032E ;	MA	# ( ᳘ → ̮ ) VEDIC TONE CANDRA BELOW → COMBINING BREVE BELOW	# 
+
+0952 ;	0331 ;	MA	# ( ॒ → ̱ ) DEVANAGARI STRESS SIGN ANUDATTA → COMBINING MACRON BELOW	# 
+0320 ;	0331 ;	MA	# ( ̠ → ̱ ) COMBINING MINUS SIGN BELOW → COMBINING MACRON BELOW	# 
+
+08F1 ;	064C ;	MA	# ( ࣱ → ٌ ) ARABIC OPEN DAMMATAN → ARABIC DAMMATAN	# 
+08E8 ;	064C ;	MA	# ( ࣨ → ٌ ) ARABIC CURLY DAMMATAN → ARABIC DAMMATAN	# 
+08E5 ;	064C ;	MA	# ( ࣥ → ٌ ) ARABIC CURLY DAMMA → ARABIC DAMMATAN	# 
+
+FC5E ;	FE72 0651 ;	MA	#* ( ‎ﱞ‎ → ‎ﹲّ‎ ) ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM → ARABIC DAMMATAN ISOLATED FORM, ARABIC SHADDA	# 
+
+08F2 ;	064D ;	MA	# ( ࣲ → ٍ ) ARABIC OPEN KASRATAN → ARABIC KASRATAN	# 
+
+FC5F ;	FE74 0651 ;	MA	#* ( ‎ﱟ‎ → ‎ﹴّ‎ ) ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM → ARABIC KASRATAN ISOLATED FORM, ARABIC SHADDA	# 
+
+FCF2 ;	FE77 0651 ;	MA	# ( ‎ﳲ‎ → ‎ﹷّ‎ ) ARABIC LIGATURE SHADDA WITH FATHA MEDIAL FORM → ARABIC FATHA MEDIAL FORM, ARABIC SHADDA	# 
+
+FC60 ;	FE76 0651 ;	MA	#* ( ‎ﱠ‎ → ‎ﹶّ‎ ) ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM → ARABIC FATHA ISOLATED FORM, ARABIC SHADDA	# 
+
+FCF3 ;	FE79 0651 ;	MA	# ( ‎ﳳ‎ → ‎ﹹّ‎ ) ARABIC LIGATURE SHADDA WITH DAMMA MEDIAL FORM → ARABIC DAMMA MEDIAL FORM, ARABIC SHADDA	# 
+
+FC61 ;	FE78 0651 ;	MA	#* ( ‎ﱡ‎ → ‎ﹸّ‎ ) ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM → ARABIC DAMMA ISOLATED FORM, ARABIC SHADDA	# 
+
+061A ;	0650 ;	MA	# ( ؚ → ِ ) ARABIC SMALL KASRA → ARABIC KASRA	# 
+0317 ;	0650 ;	MA	# ( ̗ → ِ ) COMBINING ACUTE ACCENT BELOW → ARABIC KASRA	# 
+
+FCF4 ;	FE7B 0651 ;	MA	# ( ‎ﳴ‎ → ‎ﹻّ‎ ) ARABIC LIGATURE SHADDA WITH KASRA MEDIAL FORM → ARABIC KASRA MEDIAL FORM, ARABIC SHADDA	# 
+
+FC62 ;	FE7A 0651 ;	MA	#* ( ‎ﱢ‎ → ‎ﹺّ‎ ) ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM → ARABIC KASRA ISOLATED FORM, ARABIC SHADDA	# 
+
+FC63 ;	FE7C 0670 ;	MA	#* ( ‎ﱣ‎ → ‎ﹼٰ‎ ) ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM → ARABIC SHADDA ISOLATED FORM, ARABIC LETTER SUPERSCRIPT ALEF	# 
+
+065F ;	0655 ;	MA	# ( ٟ → ٕ ) ARABIC WAVY HAMZA BELOW → ARABIC HAMZA BELOW	# 
+
+030D ;	0670 ;	MA	# ( ̍ → ٰ ) COMBINING VERTICAL LINE ABOVE → ARABIC LETTER SUPERSCRIPT ALEF	# 
+
+0742 ;	073C ;	MA	# ( ݂ → ܼ ) SYRIAC RUKKAKHA → SYRIAC HBASA-ESASA DOTTED	# 
+
+0A03 ;	0983 ;	MA	# ( ਃ → ঃ ) GURMUKHI SIGN VISARGA → BENGALI SIGN VISARGA	# 
+0C03 ;	0983 ;	MA	# ( ః → ঃ ) TELUGU SIGN VISARGA → BENGALI SIGN VISARGA	# →ਃ→
+0C83 ;	0983 ;	MA	# ( ಃ → ঃ ) KANNADA SIGN VISARGA → BENGALI SIGN VISARGA	# →ః→→ਃ→
+0D03 ;	0983 ;	MA	# ( ഃ → ঃ ) MALAYALAM SIGN VISARGA → BENGALI SIGN VISARGA	# →ಃ→→ః→→ਃ→
+0D83 ;	0983 ;	MA	# ( ඃ → ঃ ) SINHALA SIGN VISARGAYA → BENGALI SIGN VISARGA	# →ഃ→→ಃ→→ః→→ਃ→
+1038 ;	0983 ;	MA	# ( း → ঃ ) MYANMAR SIGN VISARGA → BENGALI SIGN VISARGA	# →ඃ→→ഃ→→ಃ→→ః→→ਃ→
+114C1 ;	0983 ;	MA	# ( 𑓁 → ঃ ) TIRHUTA SIGN VISARGA → BENGALI SIGN VISARGA	# 
+
+17CB ;	0E48 ;	MA	# ( ់ → ่ ) KHMER SIGN BANTOC → THAI CHARACTER MAI EK	# 
+0EC8 ;	0E48 ;	MA	# ( ່ → ่ ) LAO TONE MAI EK → THAI CHARACTER MAI EK	# 
+
+0EC9 ;	0E49 ;	MA	# ( ້ → ้ ) LAO TONE MAI THO → THAI CHARACTER MAI THO	# 
+
+0ECA ;	0E4A ;	MA	# ( ໊ → ๊ ) LAO TONE MAI TI → THAI CHARACTER MAI TRI	# 
+
+0ECB ;	0E4B ;	MA	# ( ໋ → ๋ ) LAO TONE MAI CATAWA → THAI CHARACTER MAI CHATTAWA	# 
+
+A66F ;	20E9 ;	MA	# ( ꙯ → ⃩ ) COMBINING CYRILLIC VZMET → COMBINING WIDE BRIDGE ABOVE	# 
+
+2028 ;	0020 ;	MA	#* (  →   ) LINE SEPARATOR → SPACE	# 
+2029 ;	0020 ;	MA	#* (  →   ) PARAGRAPH SEPARATOR → SPACE	# 
+1680 ;	0020 ;	MA	#* (   →   ) OGHAM SPACE MARK → SPACE	# 
+2000 ;	0020 ;	MA	#* (   →   ) EN QUAD → SPACE	# 
+2001 ;	0020 ;	MA	#* (   →   ) EM QUAD → SPACE	# 
+2002 ;	0020 ;	MA	#* (   →   ) EN SPACE → SPACE	# 
+2003 ;	0020 ;	MA	#* (   →   ) EM SPACE → SPACE	# 
+2004 ;	0020 ;	MA	#* (   →   ) THREE-PER-EM SPACE → SPACE	# 
+2005 ;	0020 ;	MA	#* (   →   ) FOUR-PER-EM SPACE → SPACE	# 
+2006 ;	0020 ;	MA	#* (   →   ) SIX-PER-EM SPACE → SPACE	# 
+2008 ;	0020 ;	MA	#* (   →   ) PUNCTUATION SPACE → SPACE	# 
+2009 ;	0020 ;	MA	#* (   →   ) THIN SPACE → SPACE	# 
+200A ;	0020 ;	MA	#* (   →   ) HAIR SPACE → SPACE	# 
+205F ;	0020 ;	MA	#* (   →   ) MEDIUM MATHEMATICAL SPACE → SPACE	# 
+00A0 ;	0020 ;	MA	#* (   →   ) NO-BREAK SPACE → SPACE	# 
+2007 ;	0020 ;	MA	#* (   →   ) FIGURE SPACE → SPACE	# 
+202F ;	0020 ;	MA	#* (   →   ) NARROW NO-BREAK SPACE → SPACE	# 
+
+07FA ;	005F ;	MA	# ( ‎ߺ‎ → _ ) NKO LAJANYALAN → LOW LINE	# 
+FE4D ;	005F ;	MA	# ( ﹍ → _ ) DASHED LOW LINE → LOW LINE	# 
+FE4E ;	005F ;	MA	# ( ﹎ → _ ) CENTRELINE LOW LINE → LOW LINE	# 
+FE4F ;	005F ;	MA	# ( ﹏ → _ ) WAVY LOW LINE → LOW LINE	# 
+
+2010 ;	002D ;	MA	#* ( ‐ → - ) HYPHEN → HYPHEN-MINUS	# 
+2011 ;	002D ;	MA	#* ( ‑ → - ) NON-BREAKING HYPHEN → HYPHEN-MINUS	# 
+2012 ;	002D ;	MA	#* ( ‒ → - ) FIGURE DASH → HYPHEN-MINUS	# 
+2013 ;	002D ;	MA	#* ( – → - ) EN DASH → HYPHEN-MINUS	# 
+FE58 ;	002D ;	MA	#* ( ﹘ → - ) SMALL EM DASH → HYPHEN-MINUS	# 
+06D4 ;	002D ;	MA	#* ( ‎۔‎ → - ) ARABIC FULL STOP → HYPHEN-MINUS	# →‐→
+2043 ;	002D ;	MA	#* ( ⁃ → - ) HYPHEN BULLET → HYPHEN-MINUS	# →‐→
+02D7 ;	002D ;	MA	#* ( ˗ → - ) MODIFIER LETTER MINUS SIGN → HYPHEN-MINUS	# 
+2212 ;	002D ;	MA	#* ( − → - ) MINUS SIGN → HYPHEN-MINUS	# 
+2796 ;	002D ;	MA	#* ( ➖ → - ) HEAVY MINUS SIGN → HYPHEN-MINUS	# →−→
+2CBB ;	002D ;	MA	# ( ⲻ → - ) COPTIC SMALL LETTER DIALECT-P NI → HYPHEN-MINUS	# →−→
+2CBA ;	002D ;	MA	# ( Ⲻ → - ) COPTIC CAPITAL LETTER DIALECT-P NI → HYPHEN-MINUS	# →‒→
+
+2A29 ;	002D 0313 ;	MA	#* ( ⨩ → -̓ ) MINUS SIGN WITH COMMA ABOVE → HYPHEN-MINUS, COMBINING COMMA ABOVE	# →−̓→
+
+2E1A ;	002D 0308 ;	MA	#* ( ⸚ → -̈ ) HYPHEN WITH DIAERESIS → HYPHEN-MINUS, COMBINING DIAERESIS	# 
+
+FB29 ;	002D 0307 ;	MA	#* ( ﬩ → -̇ ) HEBREW LETTER ALTERNATIVE PLUS SIGN → HYPHEN-MINUS, COMBINING DOT ABOVE	# →∸→→−̇→
+2238 ;	002D 0307 ;	MA	#* ( ∸ → -̇ ) DOT MINUS → HYPHEN-MINUS, COMBINING DOT ABOVE	# →−̇→
+2CB3 ;	002D 0307 ;	MA	# ( ⲳ → -̇ ) COPTIC SMALL LETTER DIALECT-P ALEF → HYPHEN-MINUS, COMBINING DOT ABOVE	# →﬩→→∸→→−̇→
+2CB2 ;	002D 0307 ;	MA	# ( Ⲳ → -̇ ) COPTIC CAPITAL LETTER DIALECT-P ALEF → HYPHEN-MINUS, COMBINING DOT ABOVE	# →﬩→→∸→→−̇→
+
+2A2A ;	002D 0323 ;	MA	#* ( ⨪ → -̣ ) MINUS SIGN WITH DOT BELOW → HYPHEN-MINUS, COMBINING DOT BELOW	# →−̣→
+
+A4FE ;	002D 002E ;	MA	#* ( ꓾ → -. ) LISU PUNCTUATION COMMA → HYPHEN-MINUS, FULL STOP	# 
+
+FF5E ;	301C ;	MA	#* ( ～ → 〜 ) FULLWIDTH TILDE → WAVE DASH	# 
+
+060D ;	002C ;	MA	#* ( ‎؍‎ → , ) ARABIC DATE SEPARATOR → COMMA	# →‎٫‎→
+066B ;	002C ;	MA	#* ( ‎٫‎ → , ) ARABIC DECIMAL SEPARATOR → COMMA	# 
+201A ;	002C ;	MA	#* ( ‚ → , ) SINGLE LOW-9 QUOTATION MARK → COMMA	# 
+00B8 ;	002C ;	MA	#* ( ¸ → , ) CEDILLA → COMMA	# 
+A4F9 ;	002C ;	MA	# ( ꓹ → , ) LISU LETTER TONE NA PO → COMMA	# 
+
+2E32 ;	060C ;	MA	#* ( ⸲ → ، ) TURNED COMMA → ARABIC COMMA	# 
+066C ;	060C ;	MA	#* ( ‎٬‎ → ، ) ARABIC THOUSANDS SEPARATOR → ARABIC COMMA	# 
+
+037E ;	003B ;	MA	#* ( ; → ; ) GREEK QUESTION MARK → SEMICOLON	# 
+
+2E35 ;	061B ;	MA	#* ( ⸵ → ‎؛‎ ) TURNED SEMICOLON → ARABIC SEMICOLON	# 
+
+0903 ;	003A ;	MA	# ( ः → : ) DEVANAGARI SIGN VISARGA → COLON	# 
+0A83 ;	003A ;	MA	# ( ઃ → : ) GUJARATI SIGN VISARGA → COLON	# 
+FF1A ;	003A ;	MA	#* ( ： → : ) FULLWIDTH COLON → COLON	# →︰→
+0589 ;	003A ;	MA	#* ( ։ → : ) ARMENIAN FULL STOP → COLON	# 
+0703 ;	003A ;	MA	#* ( ‎܃‎ → : ) SYRIAC SUPRALINEAR COLON → COLON	# 
+0704 ;	003A ;	MA	#* ( ‎܄‎ → : ) SYRIAC SUBLINEAR COLON → COLON	# 
+16EC ;	003A ;	MA	#* ( ᛬ → : ) RUNIC MULTIPLE PUNCTUATION → COLON	# 
+FE30 ;	003A ;	MA	#* ( ︰ → : ) PRESENTATION FORM FOR VERTICAL TWO DOT LEADER → COLON	# 
+1803 ;	003A ;	MA	#* ( ᠃ → : ) MONGOLIAN FULL STOP → COLON	# 
+1809 ;	003A ;	MA	#* ( ᠉ → : ) MONGOLIAN MANCHU FULL STOP → COLON	# 
+205A ;	003A ;	MA	#* ( ⁚ → : ) TWO DOT PUNCTUATION → COLON	# 
+05C3 ;	003A ;	MA	#* ( ‎׃‎ → : ) HEBREW PUNCTUATION SOF PASUQ → COLON	# 
+02F8 ;	003A ;	MA	#* ( ˸ → : ) MODIFIER LETTER RAISED COLON → COLON	# 
+A789 ;	003A ;	MA	#* ( ꞉ → : ) MODIFIER LETTER COLON → COLON	# 
+2236 ;	003A ;	MA	#* ( ∶ → : ) RATIO → COLON	# 
+02D0 ;	003A ;	MA	# ( ː → : ) MODIFIER LETTER TRIANGULAR COLON → COLON	# 
+A4FD ;	003A ;	MA	# ( ꓽ → : ) LISU LETTER TONE MYA JEU → COLON	# 
+11DD9 ;	003A ;	MA	# ( 𑷙 → : ) TOLONG SIKI SIGN SELA → COLON	# 
+
+2A74 ;	003A 003A 003D ;	MA	#* ( ⩴ → ::= ) DOUBLE COLON EQUAL → COLON, COLON, EQUALS SIGN	# 
+
+29F4 ;	003A 2192 ;	MA	#* ( ⧴ → :→ ) RULE-DELAYED → COLON, RIGHTWARDS ARROW	# 
+
+FF01 ;	0021 ;	MA	#* ( ！ → ! ) FULLWIDTH EXCLAMATION MARK → EXCLAMATION MARK	# →ǃ→
+01C3 ;	0021 ;	MA	# ( ǃ → ! ) LATIN LETTER RETROFLEX CLICK → EXCLAMATION MARK	# 
+2D51 ;	0021 ;	MA	# ( ⵑ → ! ) TIFINAGH LETTER TUAREG YANG → EXCLAMATION MARK	# 
+
+203C ;	0021 0021 ;	MA	#* ( ‼ → !! ) DOUBLE EXCLAMATION MARK → EXCLAMATION MARK, EXCLAMATION MARK	# 
+
+2049 ;	0021 003F ;	MA	#* ( ⁉ → !? ) EXCLAMATION QUESTION MARK → EXCLAMATION MARK, QUESTION MARK	# 
+
+0294 ;	003F ;	MA	# ( ʔ → ? ) LATIN LETTER GLOTTAL STOP → QUESTION MARK	# 
+0241 ;	003F ;	MA	# ( Ɂ → ? ) LATIN CAPITAL LETTER GLOTTAL STOP → QUESTION MARK	# →ʔ→
+097D ;	003F ;	MA	# ( ॽ → ? ) DEVANAGARI LETTER GLOTTAL STOP → QUESTION MARK	# 
+13AE ;	003F ;	MA	# ( Ꭾ → ? ) CHEROKEE LETTER HE → QUESTION MARK	# →Ɂ→→ʔ→
+A6EB ;	003F ;	MA	# ( ꛫ → ? ) BAMUM LETTER NTUU → QUESTION MARK	# →ʔ→
+
+2048 ;	003F 0021 ;	MA	#* ( ⁈ → ?! ) QUESTION EXCLAMATION MARK → QUESTION MARK, EXCLAMATION MARK	# 
+
+2047 ;	003F 003F ;	MA	#* ( ⁇ → ?? ) DOUBLE QUESTION MARK → QUESTION MARK, QUESTION MARK	# 
+
+2E2E ;	061F ;	MA	#* ( ⸮ → ‎؟‎ ) REVERSED QUESTION MARK → ARABIC QUESTION MARK	# 
+
+1D16D ;	002E ;	MA	# ( 𝅭 → . ) MUSICAL SYMBOL COMBINING AUGMENTATION DOT → FULL STOP	# 
+2024 ;	002E ;	MA	#* ( ․ → . ) ONE DOT LEADER → FULL STOP	# 
+0701 ;	002E ;	MA	#* ( ‎܁‎ → . ) SYRIAC SUPRALINEAR FULL STOP → FULL STOP	# 
+0702 ;	002E ;	MA	#* ( ‎܂‎ → . ) SYRIAC SUBLINEAR FULL STOP → FULL STOP	# 
+A60E ;	002E ;	MA	#* ( ꘎ → . ) VAI FULL STOP → FULL STOP	# 
+10A50 ;	002E ;	MA	#* ( ‎𐩐‎ → . ) KHAROSHTHI PUNCTUATION DOT → FULL STOP	# 
+0660 ;	002E ;	MA	# ( ‎٠‎ → . ) ARABIC-INDIC DIGIT ZERO → FULL STOP	# 
+06F0 ;	002E ;	MA	# ( ۰ → . ) EXTENDED ARABIC-INDIC DIGIT ZERO → FULL STOP	# →‎٠‎→
+A4F8 ;	002E ;	MA	# ( ꓸ → . ) LISU LETTER TONE MYA TI → FULL STOP	# 
+
+A4FB ;	002E 002C ;	MA	# ( ꓻ → ., ) LISU LETTER TONE MYA BO → FULL STOP, COMMA	# 
+
+2025 ;	002E 002E ;	MA	#* ( ‥ → .. ) TWO DOT LEADER → FULL STOP, FULL STOP	# 
+A4FA ;	002E 002E ;	MA	# ( ꓺ → .. ) LISU LETTER TONE MYA CYA → FULL STOP, FULL STOP	# 
+
+2026 ;	002E 002E 002E ;	MA	#* ( … → ... ) HORIZONTAL ELLIPSIS → FULL STOP, FULL STOP, FULL STOP	# 
+
+A6F4 ;	A6F3 A6F3 ;	MA	#* ( ꛴ → ꛳꛳ ) BAMUM COLON → BAMUM FULL STOP, BAMUM FULL STOP	# 
+
+30FB ;	00B7 ;	MA	# ( ・ → · ) KATAKANA MIDDLE DOT → MIDDLE DOT	# →•→
+FF65 ;	00B7 ;	MA	# ( ･ → · ) HALFWIDTH KATAKANA MIDDLE DOT → MIDDLE DOT	# →•→
+16EB ;	00B7 ;	MA	#* ( ᛫ → · ) RUNIC SINGLE PUNCTUATION → MIDDLE DOT	# 
+0387 ;	00B7 ;	MA	# ( · → · ) GREEK ANO TELEIA → MIDDLE DOT	# 
+2E31 ;	00B7 ;	MA	#* ( ⸱ → · ) WORD SEPARATOR MIDDLE DOT → MIDDLE DOT	# 
+10101 ;	00B7 ;	MA	#* ( 𐄁 → · ) AEGEAN WORD SEPARATOR DOT → MIDDLE DOT	# 
+2022 ;	00B7 ;	MA	#* ( • → · ) BULLET → MIDDLE DOT	# 
+2027 ;	00B7 ;	MA	#* ( ‧ → · ) HYPHENATION POINT → MIDDLE DOT	# 
+2219 ;	00B7 ;	MA	#* ( ∙ → · ) BULLET OPERATOR → MIDDLE DOT	# 
+22C5 ;	00B7 ;	MA	#* ( ⋅ → · ) DOT OPERATOR → MIDDLE DOT	# 
+A78F ;	00B7 ;	MA	# ( ꞏ → · ) LATIN LETTER SINOLOGICAL DOT → MIDDLE DOT	# 
+1427 ;	00B7 ;	MA	# ( ᐧ → · ) CANADIAN SYLLABICS FINAL MIDDLE DOT → MIDDLE DOT	# 
+
+22EF ;	00B7 00B7 00B7 ;	MA	#* ( ⋯ → ··· ) MIDLINE HORIZONTAL ELLIPSIS → MIDDLE DOT, MIDDLE DOT, MIDDLE DOT	# 
+2D48 ;	00B7 00B7 00B7 ;	MA	# ( ⵈ → ··· ) TIFINAGH LETTER TUAREG YAQ → MIDDLE DOT, MIDDLE DOT, MIDDLE DOT	# →⋯→
+
+1444 ;	00B7 003C ;	MA	# ( ᑄ → ·< ) CANADIAN SYLLABICS PWA → MIDDLE DOT, LESS-THAN SIGN	# →ᐧᐸ→
+
+22D7 ;	00B7 003E ;	MA	#* ( ⋗ → ·> ) GREATER-THAN WITH DOT → MIDDLE DOT, GREATER-THAN SIGN	# →ᑀ→→ᐧᐳ→
+1437 ;	00B7 003E ;	MA	# ( ᐷ → ·> ) CANADIAN SYLLABICS CARRIER HI → MIDDLE DOT, GREATER-THAN SIGN	# →ᑀ→→ᐧᐳ→
+1440 ;	00B7 003E ;	MA	# ( ᑀ → ·> ) CANADIAN SYLLABICS PWO → MIDDLE DOT, GREATER-THAN SIGN	# →ᐧᐳ→
+
+152F ;	00B7 0034 ;	MA	# ( ᔯ → ·4 ) CANADIAN SYLLABICS YWE → MIDDLE DOT, DIGIT FOUR	# →ᐧ4→
+
+147E ;	00B7 0062 ;	MA	# ( ᑾ → ·b ) CANADIAN SYLLABICS KWA → MIDDLE DOT, LATIN SMALL LETTER B	# →ᐧᑲ→
+
+1480 ;	00B7 0062 0307 ;	MA	# ( ᒀ → ·ḃ ) CANADIAN SYLLABICS KWAA → MIDDLE DOT, LATIN SMALL LETTER B, COMBINING DOT ABOVE	# →ᐧᑳ→
+
+147A ;	00B7 0064 ;	MA	# ( ᑺ → ·d ) CANADIAN SYLLABICS KWO → MIDDLE DOT, LATIN SMALL LETTER D	# →ᐧᑯ→
+
+1498 ;	00B7 004A ;	MA	# ( ᒘ → ·J ) CANADIAN SYLLABICS CWO → MIDDLE DOT, LATIN CAPITAL LETTER J	# →ᐧᒍ→
+
+14B6 ;	00B7 004C ;	MA	# ( ᒶ → ·L ) CANADIAN SYLLABICS MWA → MIDDLE DOT, LATIN CAPITAL LETTER L	# →ᐧL→
+
+1476 ;	00B7 0050 ;	MA	# ( ᑶ → ·P ) CANADIAN SYLLABICS KWI → MIDDLE DOT, LATIN CAPITAL LETTER P	# →ᐧᑭ→
+
+1457 ;	00B7 0055 ;	MA	# ( ᑗ → ·U ) CANADIAN SYLLABICS TWE → MIDDLE DOT, LATIN CAPITAL LETTER U	# →ᐧᑌ→→·ᑌ→
+
+143A ;	00B7 0056 ;	MA	# ( ᐺ → ·V ) CANADIAN SYLLABICS PWE → MIDDLE DOT, LATIN CAPITAL LETTER V	# →ᐧᐯ→
+
+143C ;	00B7 0245 ;	MA	# ( ᐼ → ·Ʌ ) CANADIAN SYLLABICS PWI → MIDDLE DOT, LATIN CAPITAL LETTER TURNED V	# →ᐧᐱ→→·ᐱ→
+
+14AE ;	00B7 0393 ;	MA	# ( ᒮ → ·Γ ) CANADIAN SYLLABICS MWI → MIDDLE DOT, GREEK CAPITAL LETTER GAMMA	# →ᐧᒥ→→·ᒥ→
+
+140E ;	00B7 0394 ;	MA	# ( ᐎ → ·Δ ) CANADIAN SYLLABICS WI → MIDDLE DOT, GREEK CAPITAL LETTER DELTA	# →ᐧᐃ→
+
+1459 ;	00B7 0548 ;	MA	# ( ᑙ → ·Ո ) CANADIAN SYLLABICS TWI → MIDDLE DOT, ARMENIAN CAPITAL LETTER VO	# →ᐧᑎ→→·ᑎ→
+
+140C ;	00B7 1401 ;	MA	# ( ᐌ → ·ᐁ ) CANADIAN SYLLABICS WE → MIDDLE DOT, CANADIAN SYLLABICS E	# →ᐧᐁ→
+
+1410 ;	00B7 1404 ;	MA	# ( ᐐ → ·ᐄ ) CANADIAN SYLLABICS WII → MIDDLE DOT, CANADIAN SYLLABICS II	# →ᐧᐄ→
+
+1412 ;	00B7 1405 ;	MA	# ( ᐒ → ·ᐅ ) CANADIAN SYLLABICS WO → MIDDLE DOT, CANADIAN SYLLABICS O	# →ᐧᐅ→
+
+1414 ;	00B7 1406 ;	MA	# ( ᐔ → ·ᐆ ) CANADIAN SYLLABICS WOO → MIDDLE DOT, CANADIAN SYLLABICS OO	# →ᐧᐆ→
+
+1417 ;	00B7 140A ;	MA	# ( ᐗ → ·ᐊ ) CANADIAN SYLLABICS WA → MIDDLE DOT, CANADIAN SYLLABICS A	# →ᐧᐊ→
+
+1419 ;	00B7 140B ;	MA	# ( ᐙ → ·ᐋ ) CANADIAN SYLLABICS WAA → MIDDLE DOT, CANADIAN SYLLABICS AA	# →ᐧᐋ→
+
+143E ;	00B7 1432 ;	MA	# ( ᐾ → ·ᐲ ) CANADIAN SYLLABICS PWII → MIDDLE DOT, CANADIAN SYLLABICS PII	# →ᐧᐲ→
+
+1442 ;	00B7 1434 ;	MA	# ( ᑂ → ·ᐴ ) CANADIAN SYLLABICS PWOO → MIDDLE DOT, CANADIAN SYLLABICS POO	# →ᐧᐴ→
+
+1446 ;	00B7 1439 ;	MA	# ( ᑆ → ·ᐹ ) CANADIAN SYLLABICS PWAA → MIDDLE DOT, CANADIAN SYLLABICS PAA	# →ᐧᐹ→
+
+145B ;	00B7 144F ;	MA	# ( ᑛ → ·ᑏ ) CANADIAN SYLLABICS TWII → MIDDLE DOT, CANADIAN SYLLABICS TII	# →ᐧᑏ→
+
+1454 ;	00B7 1450 ;	MA	# ( ᑔ → ·ᑐ ) CANADIAN SYLLABICS CARRIER DI → MIDDLE DOT, CANADIAN SYLLABICS TO	# →ᑝ→→ᐧᑐ→
+145D ;	00B7 1450 ;	MA	# ( ᑝ → ·ᑐ ) CANADIAN SYLLABICS TWO → MIDDLE DOT, CANADIAN SYLLABICS TO	# →ᐧᑐ→
+
+145F ;	00B7 1451 ;	MA	# ( ᑟ → ·ᑑ ) CANADIAN SYLLABICS TWOO → MIDDLE DOT, CANADIAN SYLLABICS TOO	# →ᐧᑑ→
+
+1461 ;	00B7 1455 ;	MA	# ( ᑡ → ·ᑕ ) CANADIAN SYLLABICS TWA → MIDDLE DOT, CANADIAN SYLLABICS TA	# →ᐧᑕ→
+
+1463 ;	00B7 1456 ;	MA	# ( ᑣ → ·ᑖ ) CANADIAN SYLLABICS TWAA → MIDDLE DOT, CANADIAN SYLLABICS TAA	# →ᐧᑖ→
+
+1474 ;	00B7 146B ;	MA	# ( ᑴ → ·ᑫ ) CANADIAN SYLLABICS KWE → MIDDLE DOT, CANADIAN SYLLABICS KE	# →ᐧᑫ→
+
+1478 ;	00B7 146E ;	MA	# ( ᑸ → ·ᑮ ) CANADIAN SYLLABICS KWII → MIDDLE DOT, CANADIAN SYLLABICS KII	# →ᐧᑮ→
+
+147C ;	00B7 1470 ;	MA	# ( ᑼ → ·ᑰ ) CANADIAN SYLLABICS KWOO → MIDDLE DOT, CANADIAN SYLLABICS KOO	# →ᐧᑰ→
+
+1492 ;	00B7 1489 ;	MA	# ( ᒒ → ·ᒉ ) CANADIAN SYLLABICS CWE → MIDDLE DOT, CANADIAN SYLLABICS CE	# →ᐧᒉ→
+
+1494 ;	00B7 148B ;	MA	# ( ᒔ → ·ᒋ ) CANADIAN SYLLABICS CWI → MIDDLE DOT, CANADIAN SYLLABICS CI	# →ᐧᒋ→
+
+1496 ;	00B7 148C ;	MA	# ( ᒖ → ·ᒌ ) CANADIAN SYLLABICS CWII → MIDDLE DOT, CANADIAN SYLLABICS CII	# →ᐧᒌ→
+
+149A ;	00B7 148E ;	MA	# ( ᒚ → ·ᒎ ) CANADIAN SYLLABICS CWOO → MIDDLE DOT, CANADIAN SYLLABICS COO	# →ᐧᒎ→
+
+149C ;	00B7 1490 ;	MA	# ( ᒜ → ·ᒐ ) CANADIAN SYLLABICS CWA → MIDDLE DOT, CANADIAN SYLLABICS CA	# →ᐧᒐ→
+
+149E ;	00B7 1491 ;	MA	# ( ᒞ → ·ᒑ ) CANADIAN SYLLABICS CWAA → MIDDLE DOT, CANADIAN SYLLABICS CAA	# →ᐧᒑ→
+
+14AC ;	00B7 14A3 ;	MA	# ( ᒬ → ·ᒣ ) CANADIAN SYLLABICS MWE → MIDDLE DOT, CANADIAN SYLLABICS ME	# →ᐧᒣ→
+
+14B0 ;	00B7 14A6 ;	MA	# ( ᒰ → ·ᒦ ) CANADIAN SYLLABICS MWII → MIDDLE DOT, CANADIAN SYLLABICS MII	# →ᐧᒦ→
+
+14B2 ;	00B7 14A7 ;	MA	# ( ᒲ → ·ᒧ ) CANADIAN SYLLABICS MWO → MIDDLE DOT, CANADIAN SYLLABICS MO	# →ᐧᒧ→
+
+14B4 ;	00B7 14A8 ;	MA	# ( ᒴ → ·ᒨ ) CANADIAN SYLLABICS MWOO → MIDDLE DOT, CANADIAN SYLLABICS MOO	# →ᐧᒨ→
+
+14B8 ;	00B7 14AB ;	MA	# ( ᒸ → ·ᒫ ) CANADIAN SYLLABICS MWAA → MIDDLE DOT, CANADIAN SYLLABICS MAA	# →ᐧᒫ→
+
+14C9 ;	00B7 14C0 ;	MA	# ( ᓉ → ·ᓀ ) CANADIAN SYLLABICS NWE → MIDDLE DOT, CANADIAN SYLLABICS NE	# →ᐧᓀ→
+
+18C6 ;	00B7 14C2 ;	MA	# ( ᣆ → ·ᓂ ) CANADIAN SYLLABICS NWI → MIDDLE DOT, CANADIAN SYLLABICS NI	# →ᐧᓂ→
+
+18C8 ;	00B7 14C3 ;	MA	# ( ᣈ → ·ᓃ ) CANADIAN SYLLABICS NWII → MIDDLE DOT, CANADIAN SYLLABICS NII	# →ᐧᓃ→
+
+18CA ;	00B7 14C4 ;	MA	# ( ᣊ → ·ᓄ ) CANADIAN SYLLABICS NWO → MIDDLE DOT, CANADIAN SYLLABICS NO	# →ᐧᓄ→
+
+18CC ;	00B7 14C5 ;	MA	# ( ᣌ → ·ᓅ ) CANADIAN SYLLABICS NWOO → MIDDLE DOT, CANADIAN SYLLABICS NOO	# →ᐧᓅ→
+
+14CB ;	00B7 14C7 ;	MA	# ( ᓋ → ·ᓇ ) CANADIAN SYLLABICS NWA → MIDDLE DOT, CANADIAN SYLLABICS NA	# →ᐧᓇ→
+
+14CD ;	00B7 14C8 ;	MA	# ( ᓍ → ·ᓈ ) CANADIAN SYLLABICS NWAA → MIDDLE DOT, CANADIAN SYLLABICS NAA	# →ᐧᓈ→
+
+14DC ;	00B7 14D3 ;	MA	# ( ᓜ → ·ᓓ ) CANADIAN SYLLABICS LWE → MIDDLE DOT, CANADIAN SYLLABICS LE	# →ᐧᓓ→
+
+14DE ;	00B7 14D5 ;	MA	# ( ᓞ → ·ᓕ ) CANADIAN SYLLABICS LWI → MIDDLE DOT, CANADIAN SYLLABICS LI	# →ᐧᓕ→
+
+14E0 ;	00B7 14D6 ;	MA	# ( ᓠ → ·ᓖ ) CANADIAN SYLLABICS LWII → MIDDLE DOT, CANADIAN SYLLABICS LII	# →ᐧᓖ→
+
+14E2 ;	00B7 14D7 ;	MA	# ( ᓢ → ·ᓗ ) CANADIAN SYLLABICS LWO → MIDDLE DOT, CANADIAN SYLLABICS LO	# →ᐧᓗ→
+
+14E4 ;	00B7 14D8 ;	MA	# ( ᓤ → ·ᓘ ) CANADIAN SYLLABICS LWOO → MIDDLE DOT, CANADIAN SYLLABICS LOO	# →ᐧᓘ→
+
+14E6 ;	00B7 14DA ;	MA	# ( ᓦ → ·ᓚ ) CANADIAN SYLLABICS LWA → MIDDLE DOT, CANADIAN SYLLABICS LA	# →ᐧᓚ→
+
+14E8 ;	00B7 14DB ;	MA	# ( ᓨ → ·ᓛ ) CANADIAN SYLLABICS LWAA → MIDDLE DOT, CANADIAN SYLLABICS LAA	# →ᐧᓛ→
+
+14F6 ;	00B7 14ED ;	MA	# ( ᓶ → ·ᓭ ) CANADIAN SYLLABICS SWE → MIDDLE DOT, CANADIAN SYLLABICS SE	# →ᐧᓭ→
+
+14F8 ;	00B7 14EF ;	MA	# ( ᓸ → ·ᓯ ) CANADIAN SYLLABICS SWI → MIDDLE DOT, CANADIAN SYLLABICS SI	# →ᐧᓯ→
+
+14FA ;	00B7 14F0 ;	MA	# ( ᓺ → ·ᓰ ) CANADIAN SYLLABICS SWII → MIDDLE DOT, CANADIAN SYLLABICS SII	# →ᐧᓰ→
+
+14FC ;	00B7 14F1 ;	MA	# ( ᓼ → ·ᓱ ) CANADIAN SYLLABICS SWO → MIDDLE DOT, CANADIAN SYLLABICS SO	# →ᐧᓱ→
+
+14FE ;	00B7 14F2 ;	MA	# ( ᓾ → ·ᓲ ) CANADIAN SYLLABICS SWOO → MIDDLE DOT, CANADIAN SYLLABICS SOO	# →ᐧᓲ→
+
+1500 ;	00B7 14F4 ;	MA	# ( ᔀ → ·ᓴ ) CANADIAN SYLLABICS SWA → MIDDLE DOT, CANADIAN SYLLABICS SA	# →ᐧᓴ→
+
+1502 ;	00B7 14F5 ;	MA	# ( ᔂ → ·ᓵ ) CANADIAN SYLLABICS SWAA → MIDDLE DOT, CANADIAN SYLLABICS SAA	# →ᐧᓵ→
+
+1517 ;	00B7 1510 ;	MA	# ( ᔗ → ·ᔐ ) CANADIAN SYLLABICS SHWE → MIDDLE DOT, CANADIAN SYLLABICS SHE	# →ᐧᔐ→
+
+1519 ;	00B7 1511 ;	MA	# ( ᔙ → ·ᔑ ) CANADIAN SYLLABICS SHWI → MIDDLE DOT, CANADIAN SYLLABICS SHI	# →ᐧᔑ→
+
+151B ;	00B7 1512 ;	MA	# ( ᔛ → ·ᔒ ) CANADIAN SYLLABICS SHWII → MIDDLE DOT, CANADIAN SYLLABICS SHII	# →ᐧᔒ→
+
+151D ;	00B7 1513 ;	MA	# ( ᔝ → ·ᔓ ) CANADIAN SYLLABICS SHWO → MIDDLE DOT, CANADIAN SYLLABICS SHO	# →ᐧᔓ→
+
+151F ;	00B7 1514 ;	MA	# ( ᔟ → ·ᔔ ) CANADIAN SYLLABICS SHWOO → MIDDLE DOT, CANADIAN SYLLABICS SHOO	# →ᐧᔔ→
+
+1521 ;	00B7 1515 ;	MA	# ( ᔡ → ·ᔕ ) CANADIAN SYLLABICS SHWA → MIDDLE DOT, CANADIAN SYLLABICS SHA	# →ᐧᔕ→
+
+1523 ;	00B7 1516 ;	MA	# ( ᔣ → ·ᔖ ) CANADIAN SYLLABICS SHWAA → MIDDLE DOT, CANADIAN SYLLABICS SHAA	# →ᐧᔖ→
+
+1531 ;	00B7 1528 ;	MA	# ( ᔱ → ·ᔨ ) CANADIAN SYLLABICS YWI → MIDDLE DOT, CANADIAN SYLLABICS YI	# →ᐧᔨ→
+
+1533 ;	00B7 1529 ;	MA	# ( ᔳ → ·ᔩ ) CANADIAN SYLLABICS YWII → MIDDLE DOT, CANADIAN SYLLABICS YII	# →ᐧᔩ→
+
+1535 ;	00B7 152A ;	MA	# ( ᔵ → ·ᔪ ) CANADIAN SYLLABICS YWO → MIDDLE DOT, CANADIAN SYLLABICS YO	# →ᐧᔪ→
+
+1537 ;	00B7 152B ;	MA	# ( ᔷ → ·ᔫ ) CANADIAN SYLLABICS YWOO → MIDDLE DOT, CANADIAN SYLLABICS YOO	# →ᐧᔫ→
+
+1539 ;	00B7 152D ;	MA	# ( ᔹ → ·ᔭ ) CANADIAN SYLLABICS YWA → MIDDLE DOT, CANADIAN SYLLABICS YA	# →ᐧᔭ→
+
+153B ;	00B7 152E ;	MA	# ( ᔻ → ·ᔮ ) CANADIAN SYLLABICS YWAA → MIDDLE DOT, CANADIAN SYLLABICS YAA	# →ᐧᔮ→
+
+18CE ;	00B7 1543 ;	MA	# ( ᣎ → ·ᕃ ) CANADIAN SYLLABICS RWEE → MIDDLE DOT, CANADIAN SYLLABICS R-CREE RE	# →ᐧᕃ→
+
+18CF ;	00B7 1546 ;	MA	# ( ᣏ → ·ᕆ ) CANADIAN SYLLABICS RWI → MIDDLE DOT, CANADIAN SYLLABICS RI	# →ᐧᕆ→
+
+18D0 ;	00B7 1547 ;	MA	# ( ᣐ → ·ᕇ ) CANADIAN SYLLABICS RWII → MIDDLE DOT, CANADIAN SYLLABICS RII	# →ᐧᕇ→
+
+18D1 ;	00B7 1548 ;	MA	# ( ᣑ → ·ᕈ ) CANADIAN SYLLABICS RWO → MIDDLE DOT, CANADIAN SYLLABICS RO	# →ᐧᕈ→
+
+18D2 ;	00B7 1549 ;	MA	# ( ᣒ → ·ᕉ ) CANADIAN SYLLABICS RWOO → MIDDLE DOT, CANADIAN SYLLABICS ROO	# →ᐧᕉ→
+
+18D3 ;	00B7 154B ;	MA	# ( ᣓ → ·ᕋ ) CANADIAN SYLLABICS RWA → MIDDLE DOT, CANADIAN SYLLABICS RA	# →ᐧᕋ→
+
+154E ;	00B7 154C ;	MA	# ( ᕎ → ·ᕌ ) CANADIAN SYLLABICS RWAA → MIDDLE DOT, CANADIAN SYLLABICS RAA	# →ᐧᕌ→
+
+155B ;	00B7 155A ;	MA	# ( ᕛ → ·ᕚ ) CANADIAN SYLLABICS FWAA → MIDDLE DOT, CANADIAN SYLLABICS FAA	# →ᐧᕚ→
+
+1568 ;	00B7 1567 ;	MA	# ( ᕨ → ·ᕧ ) CANADIAN SYLLABICS THWAA → MIDDLE DOT, CANADIAN SYLLABICS THAA	# →ᐧᕧ→
+
+18B3 ;	00B7 18B1 ;	MA	# ( ᢳ → ·ᢱ ) CANADIAN SYLLABICS WAY → MIDDLE DOT, CANADIAN SYLLABICS AY	# →ᐧᢱ→
+
+18B6 ;	00B7 18B4 ;	MA	# ( ᢶ → ·ᢴ ) CANADIAN SYLLABICS PWOY → MIDDLE DOT, CANADIAN SYLLABICS POY	# →ᐧᢴ→
+
+18B9 ;	00B7 18B8 ;	MA	# ( ᢹ → ·ᢸ ) CANADIAN SYLLABICS KWAY → MIDDLE DOT, CANADIAN SYLLABICS KAY	# →ᐧᢸ→
+
+18C2 ;	00B7 18C0 ;	MA	# ( ᣂ → ·ᣀ ) CANADIAN SYLLABICS SHWOY → MIDDLE DOT, CANADIAN SYLLABICS SHOY	# →ᐧᣀ→
+
+A830 ;	0964 ;	MA	#* ( ꠰ → । ) NORTH INDIC FRACTION ONE QUARTER → DEVANAGARI DANDA	# 
+
+0965 ;	0964 0964 ;	MA	#* ( ॥ → ।। ) DEVANAGARI DOUBLE DANDA → DEVANAGARI DANDA, DEVANAGARI DANDA	# 
+
+1C3C ;	1C3B 1C3B ;	MA	#* ( ᰼ → ᰻᰻ ) LEPCHA PUNCTUATION NYET THYOOM TA-ROL → LEPCHA PUNCTUATION TA-ROL, LEPCHA PUNCTUATION TA-ROL	# 
+
+104B ;	104A 104A ;	MA	#* ( ။ → ၊၊ ) MYANMAR SIGN SECTION → MYANMAR SIGN LITTLE SECTION, MYANMAR SIGN LITTLE SECTION	# 
+
+1AA9 ;	1AA8 1AA8 ;	MA	#* ( ᪩ → ᪨᪨ ) TAI THAM SIGN KAANKUU → TAI THAM SIGN KAAN, TAI THAM SIGN KAAN	# 
+
+1AAB ;	1AAA 1AA8 ;	MA	#* ( ᪫ → ᪪᪨ ) TAI THAM SIGN SATKAANKUU → TAI THAM SIGN SATKAAN, TAI THAM SIGN KAAN	# 
+
+1B5F ;	1B5E 1B5E ;	MA	#* ( ᭟ → ᭞᭞ ) BALINESE CARIK PAREREN → BALINESE CARIK SIKI, BALINESE CARIK SIKI	# 
+
+10A57 ;	10A56 10A56 ;	MA	#* ( ‎𐩗‎ → ‎𐩖𐩖‎ ) KHAROSHTHI PUNCTUATION DOUBLE DANDA → KHAROSHTHI PUNCTUATION DANDA, KHAROSHTHI PUNCTUATION DANDA	# 
+
+1144C ;	1144B 1144B ;	MA	#* ( 𑑌 → 𑑋𑑋 ) NEWA DOUBLE DANDA → NEWA DANDA, NEWA DANDA	# 
+
+11642 ;	11641 11641 ;	MA	#* ( 𑙂 → 𑙁𑙁 ) MODI DOUBLE DANDA → MODI DANDA, MODI DANDA	# 
+
+11C42 ;	11C41 11C41 ;	MA	#* ( 𑱂 → 𑱁𑱁 ) BHAIKSUKI DOUBLE DANDA → BHAIKSUKI DANDA, BHAIKSUKI DANDA	# 
+
+1C7F ;	1C7E 1C7E ;	MA	#* ( ᱿ → ᱾᱾ ) OL CHIKI PUNCTUATION DOUBLE MUCAAD → OL CHIKI PUNCTUATION MUCAAD, OL CHIKI PUNCTUATION MUCAAD	# 
+
+055D ;	0027 ;	MA	#* ( ՝ → ' ) ARMENIAN COMMA → APOSTROPHE	# →ˋ→→｀→→‘→
+FF07 ;	0027 ;	MA	#* ( ＇ → ' ) FULLWIDTH APOSTROPHE → APOSTROPHE	# →’→
+2018 ;	0027 ;	MA	#* ( ‘ → ' ) LEFT SINGLE QUOTATION MARK → APOSTROPHE	# 
+2019 ;	0027 ;	MA	#* ( ’ → ' ) RIGHT SINGLE QUOTATION MARK → APOSTROPHE	# 
+201B ;	0027 ;	MA	#* ( ‛ → ' ) SINGLE HIGH-REVERSED-9 QUOTATION MARK → APOSTROPHE	# →′→
+05F3 ;	0027 ;	MA	#* ( ‎׳‎ → ' ) HEBREW PUNCTUATION GERESH → APOSTROPHE	# 
+2032 ;	0027 ;	MA	#* ( ′ → ' ) PRIME → APOSTROPHE	# 
+2035 ;	0027 ;	MA	#* ( ‵ → ' ) REVERSED PRIME → APOSTROPHE	# →ʽ→→‘→
+055A ;	0027 ;	MA	#* ( ՚ → ' ) ARMENIAN APOSTROPHE → APOSTROPHE	# →’→
+0060 ;	0027 ;	MA	#* ( ` → ' ) GRAVE ACCENT → APOSTROPHE	# →ˋ→→｀→→‘→
+1FEF ;	0027 ;	MA	#* ( ` → ' ) GREEK VARIA → APOSTROPHE	# →ˋ→→｀→→‘→
+FF40 ;	0027 ;	MA	#* ( ｀ → ' ) FULLWIDTH GRAVE ACCENT → APOSTROPHE	# →‘→
+00B4 ;	0027 ;	MA	#* ( ´ → ' ) ACUTE ACCENT → APOSTROPHE	# →΄→→ʹ→
+0384 ;	0027 ;	MA	#* ( ΄ → ' ) GREEK TONOS → APOSTROPHE	# →ʹ→
+1FFD ;	0027 ;	MA	#* ( ´ → ' ) GREEK OXIA → APOSTROPHE	# →´→→΄→→ʹ→
+1FBD ;	0027 ;	MA	#* ( ᾽ → ' ) GREEK KORONIS → APOSTROPHE	# →’→
+1FBF ;	0027 ;	MA	#* ( ᾿ → ' ) GREEK PSILI → APOSTROPHE	# →’→
+1FFE ;	0027 ;	MA	#* ( ῾ → ' ) GREEK DASIA → APOSTROPHE	# →‛→→′→
+02B9 ;	0027 ;	MA	# ( ʹ → ' ) MODIFIER LETTER PRIME → APOSTROPHE	# 
+0374 ;	0027 ;	MA	# ( ʹ → ' ) GREEK NUMERAL SIGN → APOSTROPHE	# →′→
+02C8 ;	0027 ;	MA	# ( ˈ → ' ) MODIFIER LETTER VERTICAL LINE → APOSTROPHE	# 
+02CA ;	0027 ;	MA	# ( ˊ → ' ) MODIFIER LETTER ACUTE ACCENT → APOSTROPHE	# →΄→→ʹ→
+02CB ;	0027 ;	MA	# ( ˋ → ' ) MODIFIER LETTER GRAVE ACCENT → APOSTROPHE	# →｀→→‘→
+02F4 ;	0027 ;	MA	#* ( ˴ → ' ) MODIFIER LETTER MIDDLE GRAVE ACCENT → APOSTROPHE	# →ˋ→→｀→→‘→
+02BB ;	0027 ;	MA	# ( ʻ → ' ) MODIFIER LETTER TURNED COMMA → APOSTROPHE	# →‘→
+02BD ;	0027 ;	MA	# ( ʽ → ' ) MODIFIER LETTER REVERSED COMMA → APOSTROPHE	# →‘→
+02BC ;	0027 ;	MA	# ( ʼ → ' ) MODIFIER LETTER APOSTROPHE → APOSTROPHE	# →′→
+02BE ;	0027 ;	MA	# ( ʾ → ' ) MODIFIER LETTER RIGHT HALF RING → APOSTROPHE	# →ʼ→→′→
+A78C ;	0027 ;	MA	# ( ꞌ → ' ) LATIN SMALL LETTER SALTILLO → APOSTROPHE	# 
+05D9 ;	0027 ;	MA	# ( ‎י‎ → ' ) HEBREW LETTER YOD → APOSTROPHE	# 
+07F4 ;	0027 ;	MA	# ( ‎ߴ‎ → ' ) NKO HIGH TONE APOSTROPHE → APOSTROPHE	# →’→
+07F5 ;	0027 ;	MA	# ( ‎ߵ‎ → ' ) NKO LOW TONE APOSTROPHE → APOSTROPHE	# →‘→
+144A ;	0027 ;	MA	# ( ᑊ → ' ) CANADIAN SYLLABICS WEST-CREE P → APOSTROPHE	# →ˈ→
+16CC ;	0027 ;	MA	# ( ᛌ → ' ) RUNIC LETTER SHORT-TWIG-SOL S → APOSTROPHE	# 
+16F51 ;	0027 ;	MA	# ( 𖽑 → ' ) MIAO SIGN ASPIRATION → APOSTROPHE	# →ʼ→→′→
+16F52 ;	0027 ;	MA	# ( 𖽒 → ' ) MIAO SIGN REFORMED VOICING → APOSTROPHE	# →ʻ→→‘→
+
+1CD3 ;	0027 0027 ;	MA	#* ( ᳓ → '' ) VEDIC SIGN NIHSHVASA → APOSTROPHE, APOSTROPHE	# →″→→"→
+0022 ;	0027 0027 ;	MA	#* ( " → '' ) QUOTATION MARK → APOSTROPHE, APOSTROPHE	# 
+FF02 ;	0027 0027 ;	MA	#* ( ＂ → '' ) FULLWIDTH QUOTATION MARK → APOSTROPHE, APOSTROPHE	# →”→→"→
+201C ;	0027 0027 ;	MA	#* ( “ → '' ) LEFT DOUBLE QUOTATION MARK → APOSTROPHE, APOSTROPHE	# →"→
+201D ;	0027 0027 ;	MA	#* ( ” → '' ) RIGHT DOUBLE QUOTATION MARK → APOSTROPHE, APOSTROPHE	# →"→
+201F ;	0027 0027 ;	MA	#* ( ‟ → '' ) DOUBLE HIGH-REVERSED-9 QUOTATION MARK → APOSTROPHE, APOSTROPHE	# →“→→"→
+05F4 ;	0027 0027 ;	MA	#* ( ‎״‎ → '' ) HEBREW PUNCTUATION GERSHAYIM → APOSTROPHE, APOSTROPHE	# →"→
+2033 ;	0027 0027 ;	MA	#* ( ″ → '' ) DOUBLE PRIME → APOSTROPHE, APOSTROPHE	# →"→
+2036 ;	0027 0027 ;	MA	#* ( ‶ → '' ) REVERSED DOUBLE PRIME → APOSTROPHE, APOSTROPHE	# →‵‵→
+3003 ;	0027 0027 ;	MA	#* ( 〃 → '' ) DITTO MARK → APOSTROPHE, APOSTROPHE	# →″→→"→
+02DD ;	0027 0027 ;	MA	#* ( ˝ → '' ) DOUBLE ACUTE ACCENT → APOSTROPHE, APOSTROPHE	# →"→
+02BA ;	0027 0027 ;	MA	# ( ʺ → '' ) MODIFIER LETTER DOUBLE PRIME → APOSTROPHE, APOSTROPHE	# →"→
+02F6 ;	0027 0027 ;	MA	#* ( ˶ → '' ) MODIFIER LETTER MIDDLE DOUBLE ACUTE ACCENT → APOSTROPHE, APOSTROPHE	# →˝→→"→
+02EE ;	0027 0027 ;	MA	# ( ˮ → '' ) MODIFIER LETTER DOUBLE APOSTROPHE → APOSTROPHE, APOSTROPHE	# →″→→"→
+05F2 ;	0027 0027 ;	MA	# ( ‎ײ‎ → '' ) HEBREW LIGATURE YIDDISH DOUBLE YOD → APOSTROPHE, APOSTROPHE	# →‎יי‎→
+
+2034 ;	0027 0027 0027 ;	MA	#* ( ‴ → ''' ) TRIPLE PRIME → APOSTROPHE, APOSTROPHE, APOSTROPHE	# →′′′→
+2037 ;	0027 0027 0027 ;	MA	#* ( ‷ → ''' ) REVERSED TRIPLE PRIME → APOSTROPHE, APOSTROPHE, APOSTROPHE	# →‵‵‵→
+
+2057 ;	0027 0027 0027 0027 ;	MA	#* ( ⁗ → '''' ) QUADRUPLE PRIME → APOSTROPHE, APOSTROPHE, APOSTROPHE, APOSTROPHE	# →′′′′→
+
+0181 ;	0027 0042 ;	MA	# ( Ɓ → 'B ) LATIN CAPITAL LETTER B WITH HOOK → APOSTROPHE, LATIN CAPITAL LETTER B	# →ʽB→
+
+018A ;	0027 0044 ;	MA	# ( Ɗ → 'D ) LATIN CAPITAL LETTER D WITH HOOK → APOSTROPHE, LATIN CAPITAL LETTER D	# →ʽD→
+
+0149 ;	0027 006E ;	MA	# ( ʼn → 'n ) LATIN SMALL LETTER N PRECEDED BY APOSTROPHE → APOSTROPHE, LATIN SMALL LETTER N	# →ʼn→
+
+01A4 ;	0027 0050 ;	MA	# ( Ƥ → 'P ) LATIN CAPITAL LETTER P WITH HOOK → APOSTROPHE, LATIN CAPITAL LETTER P	# →ʽP→
+
+01AC ;	0027 0054 ;	MA	# ( Ƭ → 'T ) LATIN CAPITAL LETTER T WITH HOOK → APOSTROPHE, LATIN CAPITAL LETTER T	# →ʽT→
+
+01B3 ;	0027 0059 ;	MA	# ( Ƴ → 'Y ) LATIN CAPITAL LETTER Y WITH HOOK → APOSTROPHE, LATIN CAPITAL LETTER Y	# →ʽY→
+
+FF3B ;	0028 ;	MA	#* ( ［ → ( ) FULLWIDTH LEFT SQUARE BRACKET → LEFT PARENTHESIS	# →〔→
+2768 ;	0028 ;	MA	#* ( ❨ → ( ) MEDIUM LEFT PARENTHESIS ORNAMENT → LEFT PARENTHESIS	# 
+2772 ;	0028 ;	MA	#* ( ❲ → ( ) LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT → LEFT PARENTHESIS	# →〔→
+3014 ;	0028 ;	MA	#* ( 〔 → ( ) LEFT TORTOISE SHELL BRACKET → LEFT PARENTHESIS	# 
+FD3E ;	0028 ;	MA	#* ( ﴾ → ( ) ORNATE LEFT PARENTHESIS → LEFT PARENTHESIS	# 
+
+2E28 ;	0028 0028 ;	MA	#* ( ⸨ → (( ) LEFT DOUBLE PARENTHESIS → LEFT PARENTHESIS, LEFT PARENTHESIS	# 
+
+3220 ;	0028 30FC 0029 ;	MA	#* ( ㈠ → (ー) ) PARENTHESIZED IDEOGRAPH ONE → LEFT PARENTHESIS, KATAKANA-HIRAGANA PROLONGED SOUND MARK, RIGHT PARENTHESIS	# →(一)→
+
+2475 ;	0028 0032 0029 ;	MA	#* ( ⑵ → (2) ) PARENTHESIZED DIGIT TWO → LEFT PARENTHESIS, DIGIT TWO, RIGHT PARENTHESIS	# 
+
+2487 ;	0028 0032 004F 0029 ;	MA	#* ( ⒇ → (2O) ) PARENTHESIZED NUMBER TWENTY → LEFT PARENTHESIS, DIGIT TWO, LATIN CAPITAL LETTER O, RIGHT PARENTHESIS	# →(20)→
+
+2476 ;	0028 0033 0029 ;	MA	#* ( ⑶ → (3) ) PARENTHESIZED DIGIT THREE → LEFT PARENTHESIS, DIGIT THREE, RIGHT PARENTHESIS	# 
+
+2477 ;	0028 0034 0029 ;	MA	#* ( ⑷ → (4) ) PARENTHESIZED DIGIT FOUR → LEFT PARENTHESIS, DIGIT FOUR, RIGHT PARENTHESIS	# 
+
+2478 ;	0028 0035 0029 ;	MA	#* ( ⑸ → (5) ) PARENTHESIZED DIGIT FIVE → LEFT PARENTHESIS, DIGIT FIVE, RIGHT PARENTHESIS	# 
+
+2479 ;	0028 0036 0029 ;	MA	#* ( ⑹ → (6) ) PARENTHESIZED DIGIT SIX → LEFT PARENTHESIS, DIGIT SIX, RIGHT PARENTHESIS	# 
+
+247A ;	0028 0037 0029 ;	MA	#* ( ⑺ → (7) ) PARENTHESIZED DIGIT SEVEN → LEFT PARENTHESIS, DIGIT SEVEN, RIGHT PARENTHESIS	# 
+
+247B ;	0028 0038 0029 ;	MA	#* ( ⑻ → (8) ) PARENTHESIZED DIGIT EIGHT → LEFT PARENTHESIS, DIGIT EIGHT, RIGHT PARENTHESIS	# 
+
+247C ;	0028 0039 0029 ;	MA	#* ( ⑼ → (9) ) PARENTHESIZED DIGIT NINE → LEFT PARENTHESIS, DIGIT NINE, RIGHT PARENTHESIS	# 
+
+249C ;	0028 0061 0029 ;	MA	#* ( ⒜ → (a) ) PARENTHESIZED LATIN SMALL LETTER A → LEFT PARENTHESIS, LATIN SMALL LETTER A, RIGHT PARENTHESIS	# 
+
+1F110 ;	0028 0041 0029 ;	MA	#* ( 🄐 → (A) ) PARENTHESIZED LATIN CAPITAL LETTER A → LEFT PARENTHESIS, LATIN CAPITAL LETTER A, RIGHT PARENTHESIS	# 
+
+249D ;	0028 0062 0029 ;	MA	#* ( ⒝ → (b) ) PARENTHESIZED LATIN SMALL LETTER B → LEFT PARENTHESIS, LATIN SMALL LETTER B, RIGHT PARENTHESIS	# 
+
+1F111 ;	0028 0042 0029 ;	MA	#* ( 🄑 → (B) ) PARENTHESIZED LATIN CAPITAL LETTER B → LEFT PARENTHESIS, LATIN CAPITAL LETTER B, RIGHT PARENTHESIS	# 
+
+249E ;	0028 0063 0029 ;	MA	#* ( ⒞ → (c) ) PARENTHESIZED LATIN SMALL LETTER C → LEFT PARENTHESIS, LATIN SMALL LETTER C, RIGHT PARENTHESIS	# 
+
+1F112 ;	0028 0043 0029 ;	MA	#* ( 🄒 → (C) ) PARENTHESIZED LATIN CAPITAL LETTER C → LEFT PARENTHESIS, LATIN CAPITAL LETTER C, RIGHT PARENTHESIS	# 
+
+249F ;	0028 0064 0029 ;	MA	#* ( ⒟ → (d) ) PARENTHESIZED LATIN SMALL LETTER D → LEFT PARENTHESIS, LATIN SMALL LETTER D, RIGHT PARENTHESIS	# 
+
+1F113 ;	0028 0044 0029 ;	MA	#* ( 🄓 → (D) ) PARENTHESIZED LATIN CAPITAL LETTER D → LEFT PARENTHESIS, LATIN CAPITAL LETTER D, RIGHT PARENTHESIS	# 
+
+24A0 ;	0028 0065 0029 ;	MA	#* ( ⒠ → (e) ) PARENTHESIZED LATIN SMALL LETTER E → LEFT PARENTHESIS, LATIN SMALL LETTER E, RIGHT PARENTHESIS	# 
+
+1F114 ;	0028 0045 0029 ;	MA	#* ( 🄔 → (E) ) PARENTHESIZED LATIN CAPITAL LETTER E → LEFT PARENTHESIS, LATIN CAPITAL LETTER E, RIGHT PARENTHESIS	# 
+
+24A1 ;	0028 0066 0029 ;	MA	#* ( ⒡ → (f) ) PARENTHESIZED LATIN SMALL LETTER F → LEFT PARENTHESIS, LATIN SMALL LETTER F, RIGHT PARENTHESIS	# 
+
+1F115 ;	0028 0046 0029 ;	MA	#* ( 🄕 → (F) ) PARENTHESIZED LATIN CAPITAL LETTER F → LEFT PARENTHESIS, LATIN CAPITAL LETTER F, RIGHT PARENTHESIS	# 
+
+24A2 ;	0028 0067 0029 ;	MA	#* ( ⒢ → (g) ) PARENTHESIZED LATIN SMALL LETTER G → LEFT PARENTHESIS, LATIN SMALL LETTER G, RIGHT PARENTHESIS	# 
+
+1F116 ;	0028 0047 0029 ;	MA	#* ( 🄖 → (G) ) PARENTHESIZED LATIN CAPITAL LETTER G → LEFT PARENTHESIS, LATIN CAPITAL LETTER G, RIGHT PARENTHESIS	# 
+
+24A3 ;	0028 0068 0029 ;	MA	#* ( ⒣ → (h) ) PARENTHESIZED LATIN SMALL LETTER H → LEFT PARENTHESIS, LATIN SMALL LETTER H, RIGHT PARENTHESIS	# 
+
+1F117 ;	0028 0048 0029 ;	MA	#* ( 🄗 → (H) ) PARENTHESIZED LATIN CAPITAL LETTER H → LEFT PARENTHESIS, LATIN CAPITAL LETTER H, RIGHT PARENTHESIS	# 
+
+24A4 ;	0028 0069 0029 ;	MA	#* ( ⒤ → (i) ) PARENTHESIZED LATIN SMALL LETTER I → LEFT PARENTHESIS, LATIN SMALL LETTER I, RIGHT PARENTHESIS	# 
+
+24A5 ;	0028 006A 0029 ;	MA	#* ( ⒥ → (j) ) PARENTHESIZED LATIN SMALL LETTER J → LEFT PARENTHESIS, LATIN SMALL LETTER J, RIGHT PARENTHESIS	# 
+
+1F119 ;	0028 004A 0029 ;	MA	#* ( 🄙 → (J) ) PARENTHESIZED LATIN CAPITAL LETTER J → LEFT PARENTHESIS, LATIN CAPITAL LETTER J, RIGHT PARENTHESIS	# 
+
+24A6 ;	0028 006B 0029 ;	MA	#* ( ⒦ → (k) ) PARENTHESIZED LATIN SMALL LETTER K → LEFT PARENTHESIS, LATIN SMALL LETTER K, RIGHT PARENTHESIS	# 
+
+1F11A ;	0028 004B 0029 ;	MA	#* ( 🄚 → (K) ) PARENTHESIZED LATIN CAPITAL LETTER K → LEFT PARENTHESIS, LATIN CAPITAL LETTER K, RIGHT PARENTHESIS	# 
+
+2474 ;	0028 006C 0029 ;	MA	#* ( ⑴ → (l) ) PARENTHESIZED DIGIT ONE → LEFT PARENTHESIS, LATIN SMALL LETTER L, RIGHT PARENTHESIS	# →(1)→
+1F118 ;	0028 006C 0029 ;	MA	#* ( 🄘 → (l) ) PARENTHESIZED LATIN CAPITAL LETTER I → LEFT PARENTHESIS, LATIN SMALL LETTER L, RIGHT PARENTHESIS	# →(I)→
+24A7 ;	0028 006C 0029 ;	MA	#* ( ⒧ → (l) ) PARENTHESIZED LATIN SMALL LETTER L → LEFT PARENTHESIS, LATIN SMALL LETTER L, RIGHT PARENTHESIS	# 
+
+1F11B ;	0028 004C 0029 ;	MA	#* ( 🄛 → (L) ) PARENTHESIZED LATIN CAPITAL LETTER L → LEFT PARENTHESIS, LATIN CAPITAL LETTER L, RIGHT PARENTHESIS	# 
+
+247F ;	0028 006C 0032 0029 ;	MA	#* ( ⑿ → (l2) ) PARENTHESIZED NUMBER TWELVE → LEFT PARENTHESIS, LATIN SMALL LETTER L, DIGIT TWO, RIGHT PARENTHESIS	# →(12)→
+
+2480 ;	0028 006C 0033 0029 ;	MA	#* ( ⒀ → (l3) ) PARENTHESIZED NUMBER THIRTEEN → LEFT PARENTHESIS, LATIN SMALL LETTER L, DIGIT THREE, RIGHT PARENTHESIS	# →(13)→
+
+2481 ;	0028 006C 0034 0029 ;	MA	#* ( ⒁ → (l4) ) PARENTHESIZED NUMBER FOURTEEN → LEFT PARENTHESIS, LATIN SMALL LETTER L, DIGIT FOUR, RIGHT PARENTHESIS	# →(14)→
+
+2482 ;	0028 006C 0035 0029 ;	MA	#* ( ⒂ → (l5) ) PARENTHESIZED NUMBER FIFTEEN → LEFT PARENTHESIS, LATIN SMALL LETTER L, DIGIT FIVE, RIGHT PARENTHESIS	# →(15)→
+
+2483 ;	0028 006C 0036 0029 ;	MA	#* ( ⒃ → (l6) ) PARENTHESIZED NUMBER SIXTEEN → LEFT PARENTHESIS, LATIN SMALL LETTER L, DIGIT SIX, RIGHT PARENTHESIS	# →(16)→
+
+2484 ;	0028 006C 0037 0029 ;	MA	#* ( ⒄ → (l7) ) PARENTHESIZED NUMBER SEVENTEEN → LEFT PARENTHESIS, LATIN SMALL LETTER L, DIGIT SEVEN, RIGHT PARENTHESIS	# →(17)→
+
+2485 ;	0028 006C 0038 0029 ;	MA	#* ( ⒅ → (l8) ) PARENTHESIZED NUMBER EIGHTEEN → LEFT PARENTHESIS, LATIN SMALL LETTER L, DIGIT EIGHT, RIGHT PARENTHESIS	# →(18)→
+
+2486 ;	0028 006C 0039 0029 ;	MA	#* ( ⒆ → (l9) ) PARENTHESIZED NUMBER NINETEEN → LEFT PARENTHESIS, LATIN SMALL LETTER L, DIGIT NINE, RIGHT PARENTHESIS	# →(19)→
+
+247E ;	0028 006C 006C 0029 ;	MA	#* ( ⑾ → (ll) ) PARENTHESIZED NUMBER ELEVEN → LEFT PARENTHESIS, LATIN SMALL LETTER L, LATIN SMALL LETTER L, RIGHT PARENTHESIS	# →(11)→
+
+247D ;	0028 006C 004F 0029 ;	MA	#* ( ⑽ → (lO) ) PARENTHESIZED NUMBER TEN → LEFT PARENTHESIS, LATIN SMALL LETTER L, LATIN CAPITAL LETTER O, RIGHT PARENTHESIS	# →(10)→
+
+1F11C ;	0028 004D 0029 ;	MA	#* ( 🄜 → (M) ) PARENTHESIZED LATIN CAPITAL LETTER M → LEFT PARENTHESIS, LATIN CAPITAL LETTER M, RIGHT PARENTHESIS	# 
+
+24A9 ;	0028 006E 0029 ;	MA	#* ( ⒩ → (n) ) PARENTHESIZED LATIN SMALL LETTER N → LEFT PARENTHESIS, LATIN SMALL LETTER N, RIGHT PARENTHESIS	# 
+
+1F11D ;	0028 004E 0029 ;	MA	#* ( 🄝 → (N) ) PARENTHESIZED LATIN CAPITAL LETTER N → LEFT PARENTHESIS, LATIN CAPITAL LETTER N, RIGHT PARENTHESIS	# 
+
+24AA ;	0028 006F 0029 ;	MA	#* ( ⒪ → (o) ) PARENTHESIZED LATIN SMALL LETTER O → LEFT PARENTHESIS, LATIN SMALL LETTER O, RIGHT PARENTHESIS	# 
+
+1F11E ;	0028 004F 0029 ;	MA	#* ( 🄞 → (O) ) PARENTHESIZED LATIN CAPITAL LETTER O → LEFT PARENTHESIS, LATIN CAPITAL LETTER O, RIGHT PARENTHESIS	# 
+
+24AB ;	0028 0070 0029 ;	MA	#* ( ⒫ → (p) ) PARENTHESIZED LATIN SMALL LETTER P → LEFT PARENTHESIS, LATIN SMALL LETTER P, RIGHT PARENTHESIS	# 
+
+1F11F ;	0028 0050 0029 ;	MA	#* ( 🄟 → (P) ) PARENTHESIZED LATIN CAPITAL LETTER P → LEFT PARENTHESIS, LATIN CAPITAL LETTER P, RIGHT PARENTHESIS	# 
+
+24AC ;	0028 0071 0029 ;	MA	#* ( ⒬ → (q) ) PARENTHESIZED LATIN SMALL LETTER Q → LEFT PARENTHESIS, LATIN SMALL LETTER Q, RIGHT PARENTHESIS	# 
+
+1F120 ;	0028 0051 0029 ;	MA	#* ( 🄠 → (Q) ) PARENTHESIZED LATIN CAPITAL LETTER Q → LEFT PARENTHESIS, LATIN CAPITAL LETTER Q, RIGHT PARENTHESIS	# 
+
+24AD ;	0028 0072 0029 ;	MA	#* ( ⒭ → (r) ) PARENTHESIZED LATIN SMALL LETTER R → LEFT PARENTHESIS, LATIN SMALL LETTER R, RIGHT PARENTHESIS	# 
+
+1F121 ;	0028 0052 0029 ;	MA	#* ( 🄡 → (R) ) PARENTHESIZED LATIN CAPITAL LETTER R → LEFT PARENTHESIS, LATIN CAPITAL LETTER R, RIGHT PARENTHESIS	# 
+
+24A8 ;	0028 0072 006E 0029 ;	MA	#* ( ⒨ → (rn) ) PARENTHESIZED LATIN SMALL LETTER M → LEFT PARENTHESIS, LATIN SMALL LETTER R, LATIN SMALL LETTER N, RIGHT PARENTHESIS	# →(m)→
+
+24AE ;	0028 0073 0029 ;	MA	#* ( ⒮ → (s) ) PARENTHESIZED LATIN SMALL LETTER S → LEFT PARENTHESIS, LATIN SMALL LETTER S, RIGHT PARENTHESIS	# 
+
+1F122 ;	0028 0053 0029 ;	MA	#* ( 🄢 → (S) ) PARENTHESIZED LATIN CAPITAL LETTER S → LEFT PARENTHESIS, LATIN CAPITAL LETTER S, RIGHT PARENTHESIS	# 
+1F12A ;	0028 0053 0029 ;	MA	#* ( 🄪 → (S) ) TORTOISE SHELL BRACKETED LATIN CAPITAL LETTER S → LEFT PARENTHESIS, LATIN CAPITAL LETTER S, RIGHT PARENTHESIS	# →〔S〕→
+
+24AF ;	0028 0074 0029 ;	MA	#* ( ⒯ → (t) ) PARENTHESIZED LATIN SMALL LETTER T → LEFT PARENTHESIS, LATIN SMALL LETTER T, RIGHT PARENTHESIS	# 
+
+1F123 ;	0028 0054 0029 ;	MA	#* ( 🄣 → (T) ) PARENTHESIZED LATIN CAPITAL LETTER T → LEFT PARENTHESIS, LATIN CAPITAL LETTER T, RIGHT PARENTHESIS	# 
+
+24B0 ;	0028 0075 0029 ;	MA	#* ( ⒰ → (u) ) PARENTHESIZED LATIN SMALL LETTER U → LEFT PARENTHESIS, LATIN SMALL LETTER U, RIGHT PARENTHESIS	# 
+
+1F124 ;	0028 0055 0029 ;	MA	#* ( 🄤 → (U) ) PARENTHESIZED LATIN CAPITAL LETTER U → LEFT PARENTHESIS, LATIN CAPITAL LETTER U, RIGHT PARENTHESIS	# 
+
+24B1 ;	0028 0076 0029 ;	MA	#* ( ⒱ → (v) ) PARENTHESIZED LATIN SMALL LETTER V → LEFT PARENTHESIS, LATIN SMALL LETTER V, RIGHT PARENTHESIS	# 
+
+1F125 ;	0028 0056 0029 ;	MA	#* ( 🄥 → (V) ) PARENTHESIZED LATIN CAPITAL LETTER V → LEFT PARENTHESIS, LATIN CAPITAL LETTER V, RIGHT PARENTHESIS	# 
+
+24B2 ;	0028 0077 0029 ;	MA	#* ( ⒲ → (w) ) PARENTHESIZED LATIN SMALL LETTER W → LEFT PARENTHESIS, LATIN SMALL LETTER W, RIGHT PARENTHESIS	# 
+
+1F126 ;	0028 0057 0029 ;	MA	#* ( 🄦 → (W) ) PARENTHESIZED LATIN CAPITAL LETTER W → LEFT PARENTHESIS, LATIN CAPITAL LETTER W, RIGHT PARENTHESIS	# 
+
+24B3 ;	0028 0078 0029 ;	MA	#* ( ⒳ → (x) ) PARENTHESIZED LATIN SMALL LETTER X → LEFT PARENTHESIS, LATIN SMALL LETTER X, RIGHT PARENTHESIS	# 
+
+1F127 ;	0028 0058 0029 ;	MA	#* ( 🄧 → (X) ) PARENTHESIZED LATIN CAPITAL LETTER X → LEFT PARENTHESIS, LATIN CAPITAL LETTER X, RIGHT PARENTHESIS	# 
+
+24B4 ;	0028 0079 0029 ;	MA	#* ( ⒴ → (y) ) PARENTHESIZED LATIN SMALL LETTER Y → LEFT PARENTHESIS, LATIN SMALL LETTER Y, RIGHT PARENTHESIS	# 
+
+1F128 ;	0028 0059 0029 ;	MA	#* ( 🄨 → (Y) ) PARENTHESIZED LATIN CAPITAL LETTER Y → LEFT PARENTHESIS, LATIN CAPITAL LETTER Y, RIGHT PARENTHESIS	# 
+
+24B5 ;	0028 007A 0029 ;	MA	#* ( ⒵ → (z) ) PARENTHESIZED LATIN SMALL LETTER Z → LEFT PARENTHESIS, LATIN SMALL LETTER Z, RIGHT PARENTHESIS	# 
+
+1F129 ;	0028 005A 0029 ;	MA	#* ( 🄩 → (Z) ) PARENTHESIZED LATIN CAPITAL LETTER Z → LEFT PARENTHESIS, LATIN CAPITAL LETTER Z, RIGHT PARENTHESIS	# 
+
+3200 ;	0028 1100 0029 ;	MA	#* ( ㈀ → (ᄀ) ) PARENTHESIZED HANGUL KIYEOK → LEFT PARENTHESIS, HANGUL CHOSEONG KIYEOK, RIGHT PARENTHESIS	# 
+
+320E ;	0028 AC00 0029 ;	MA	#* ( ㈎ → (가) ) PARENTHESIZED HANGUL KIYEOK A → LEFT PARENTHESIS, HANGUL SYLLABLE GA, RIGHT PARENTHESIS	# 
+
+3201 ;	0028 1102 0029 ;	MA	#* ( ㈁ → (ᄂ) ) PARENTHESIZED HANGUL NIEUN → LEFT PARENTHESIS, HANGUL CHOSEONG NIEUN, RIGHT PARENTHESIS	# 
+
+320F ;	0028 B098 0029 ;	MA	#* ( ㈏ → (나) ) PARENTHESIZED HANGUL NIEUN A → LEFT PARENTHESIS, HANGUL SYLLABLE NA, RIGHT PARENTHESIS	# 
+
+3202 ;	0028 1103 0029 ;	MA	#* ( ㈂ → (ᄃ) ) PARENTHESIZED HANGUL TIKEUT → LEFT PARENTHESIS, HANGUL CHOSEONG TIKEUT, RIGHT PARENTHESIS	# 
+
+3210 ;	0028 B2E4 0029 ;	MA	#* ( ㈐ → (다) ) PARENTHESIZED HANGUL TIKEUT A → LEFT PARENTHESIS, HANGUL SYLLABLE DA, RIGHT PARENTHESIS	# 
+
+3203 ;	0028 1105 0029 ;	MA	#* ( ㈃ → (ᄅ) ) PARENTHESIZED HANGUL RIEUL → LEFT PARENTHESIS, HANGUL CHOSEONG RIEUL, RIGHT PARENTHESIS	# 
+
+3211 ;	0028 B77C 0029 ;	MA	#* ( ㈑ → (라) ) PARENTHESIZED HANGUL RIEUL A → LEFT PARENTHESIS, HANGUL SYLLABLE RA, RIGHT PARENTHESIS	# 
+
+3204 ;	0028 1106 0029 ;	MA	#* ( ㈄ → (ᄆ) ) PARENTHESIZED HANGUL MIEUM → LEFT PARENTHESIS, HANGUL CHOSEONG MIEUM, RIGHT PARENTHESIS	# 
+
+3212 ;	0028 B9C8 0029 ;	MA	#* ( ㈒ → (마) ) PARENTHESIZED HANGUL MIEUM A → LEFT PARENTHESIS, HANGUL SYLLABLE MA, RIGHT PARENTHESIS	# 
+
+3205 ;	0028 1107 0029 ;	MA	#* ( ㈅ → (ᄇ) ) PARENTHESIZED HANGUL PIEUP → LEFT PARENTHESIS, HANGUL CHOSEONG PIEUP, RIGHT PARENTHESIS	# 
+
+3213 ;	0028 BC14 0029 ;	MA	#* ( ㈓ → (바) ) PARENTHESIZED HANGUL PIEUP A → LEFT PARENTHESIS, HANGUL SYLLABLE BA, RIGHT PARENTHESIS	# 
+
+3206 ;	0028 1109 0029 ;	MA	#* ( ㈆ → (ᄉ) ) PARENTHESIZED HANGUL SIOS → LEFT PARENTHESIS, HANGUL CHOSEONG SIOS, RIGHT PARENTHESIS	# 
+
+3214 ;	0028 C0AC 0029 ;	MA	#* ( ㈔ → (사) ) PARENTHESIZED HANGUL SIOS A → LEFT PARENTHESIS, HANGUL SYLLABLE SA, RIGHT PARENTHESIS	# 
+
+3207 ;	0028 110B 0029 ;	MA	#* ( ㈇ → (ᄋ) ) PARENTHESIZED HANGUL IEUNG → LEFT PARENTHESIS, HANGUL CHOSEONG IEUNG, RIGHT PARENTHESIS	# 
+
+3215 ;	0028 C544 0029 ;	MA	#* ( ㈕ → (아) ) PARENTHESIZED HANGUL IEUNG A → LEFT PARENTHESIS, HANGUL SYLLABLE A, RIGHT PARENTHESIS	# 
+
+321D ;	0028 C624 C804 0029 ;	MA	#* ( ㈝ → (오전) ) PARENTHESIZED KOREAN CHARACTER OJEON → LEFT PARENTHESIS, HANGUL SYLLABLE O, HANGUL SYLLABLE JEON, RIGHT PARENTHESIS	# 
+
+321E ;	0028 C624 D6C4 0029 ;	MA	#* ( ㈞ → (오후) ) PARENTHESIZED KOREAN CHARACTER O HU → LEFT PARENTHESIS, HANGUL SYLLABLE O, HANGUL SYLLABLE HU, RIGHT PARENTHESIS	# 
+
+3208 ;	0028 110C 0029 ;	MA	#* ( ㈈ → (ᄌ) ) PARENTHESIZED HANGUL CIEUC → LEFT PARENTHESIS, HANGUL CHOSEONG CIEUC, RIGHT PARENTHESIS	# 
+
+3216 ;	0028 C790 0029 ;	MA	#* ( ㈖ → (자) ) PARENTHESIZED HANGUL CIEUC A → LEFT PARENTHESIS, HANGUL SYLLABLE JA, RIGHT PARENTHESIS	# 
+
+321C ;	0028 C8FC 0029 ;	MA	#* ( ㈜ → (주) ) PARENTHESIZED HANGUL CIEUC U → LEFT PARENTHESIS, HANGUL SYLLABLE JU, RIGHT PARENTHESIS	# 
+
+3209 ;	0028 110E 0029 ;	MA	#* ( ㈉ → (ᄎ) ) PARENTHESIZED HANGUL CHIEUCH → LEFT PARENTHESIS, HANGUL CHOSEONG CHIEUCH, RIGHT PARENTHESIS	# 
+
+3217 ;	0028 CC28 0029 ;	MA	#* ( ㈗ → (차) ) PARENTHESIZED HANGUL CHIEUCH A → LEFT PARENTHESIS, HANGUL SYLLABLE CA, RIGHT PARENTHESIS	# 
+
+320A ;	0028 110F 0029 ;	MA	#* ( ㈊ → (ᄏ) ) PARENTHESIZED HANGUL KHIEUKH → LEFT PARENTHESIS, HANGUL CHOSEONG KHIEUKH, RIGHT PARENTHESIS	# 
+
+3218 ;	0028 CE74 0029 ;	MA	#* ( ㈘ → (카) ) PARENTHESIZED HANGUL KHIEUKH A → LEFT PARENTHESIS, HANGUL SYLLABLE KA, RIGHT PARENTHESIS	# 
+
+320B ;	0028 1110 0029 ;	MA	#* ( ㈋ → (ᄐ) ) PARENTHESIZED HANGUL THIEUTH → LEFT PARENTHESIS, HANGUL CHOSEONG THIEUTH, RIGHT PARENTHESIS	# 
+
+3219 ;	0028 D0C0 0029 ;	MA	#* ( ㈙ → (타) ) PARENTHESIZED HANGUL THIEUTH A → LEFT PARENTHESIS, HANGUL SYLLABLE TA, RIGHT PARENTHESIS	# 
+
+320C ;	0028 1111 0029 ;	MA	#* ( ㈌ → (ᄑ) ) PARENTHESIZED HANGUL PHIEUPH → LEFT PARENTHESIS, HANGUL CHOSEONG PHIEUPH, RIGHT PARENTHESIS	# 
+
+321A ;	0028 D30C 0029 ;	MA	#* ( ㈚ → (파) ) PARENTHESIZED HANGUL PHIEUPH A → LEFT PARENTHESIS, HANGUL SYLLABLE PA, RIGHT PARENTHESIS	# 
+
+320D ;	0028 1112 0029 ;	MA	#* ( ㈍ → (ᄒ) ) PARENTHESIZED HANGUL HIEUH → LEFT PARENTHESIS, HANGUL CHOSEONG HIEUH, RIGHT PARENTHESIS	# 
+
+321B ;	0028 D558 0029 ;	MA	#* ( ㈛ → (하) ) PARENTHESIZED HANGUL HIEUH A → LEFT PARENTHESIS, HANGUL SYLLABLE HA, RIGHT PARENTHESIS	# 
+
+3226 ;	0028 4E03 0029 ;	MA	#* ( ㈦ → (七) ) PARENTHESIZED IDEOGRAPH SEVEN → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-4E03, RIGHT PARENTHESIS	# 
+
+3222 ;	0028 4E09 0029 ;	MA	#* ( ㈢ → (三) ) PARENTHESIZED IDEOGRAPH THREE → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-4E09, RIGHT PARENTHESIS	# 
+1F241 ;	0028 4E09 0029 ;	MA	#* ( 🉁 → (三) ) TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-4E09 → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-4E09, RIGHT PARENTHESIS	# →〔三〕→
+
+3228 ;	0028 4E5D 0029 ;	MA	#* ( ㈨ → (九) ) PARENTHESIZED IDEOGRAPH NINE → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-4E5D, RIGHT PARENTHESIS	# 
+
+3221 ;	0028 4E8C 0029 ;	MA	#* ( ㈡ → (二) ) PARENTHESIZED IDEOGRAPH TWO → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-4E8C, RIGHT PARENTHESIS	# 
+1F242 ;	0028 4E8C 0029 ;	MA	#* ( 🉂 → (二) ) TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-4E8C → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-4E8C, RIGHT PARENTHESIS	# →〔二〕→
+
+3224 ;	0028 4E94 0029 ;	MA	#* ( ㈤ → (五) ) PARENTHESIZED IDEOGRAPH FIVE → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-4E94, RIGHT PARENTHESIS	# 
+
+3239 ;	0028 4EE3 0029 ;	MA	#* ( ㈹ → (代) ) PARENTHESIZED IDEOGRAPH REPRESENT → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-4EE3, RIGHT PARENTHESIS	# 
+
+323D ;	0028 4F01 0029 ;	MA	#* ( ㈽ → (企) ) PARENTHESIZED IDEOGRAPH ENTERPRISE → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-4F01, RIGHT PARENTHESIS	# 
+
+3241 ;	0028 4F11 0029 ;	MA	#* ( ㉁ → (休) ) PARENTHESIZED IDEOGRAPH REST → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-4F11, RIGHT PARENTHESIS	# 
+
+3227 ;	0028 516B 0029 ;	MA	#* ( ㈧ → (八) ) PARENTHESIZED IDEOGRAPH EIGHT → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-516B, RIGHT PARENTHESIS	# 
+
+3225 ;	0028 516D 0029 ;	MA	#* ( ㈥ → (六) ) PARENTHESIZED IDEOGRAPH SIX → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-516D, RIGHT PARENTHESIS	# 
+
+3238 ;	0028 52B4 0029 ;	MA	#* ( ㈸ → (労) ) PARENTHESIZED IDEOGRAPH LABOR → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-52B4, RIGHT PARENTHESIS	# 
+
+1F247 ;	0028 52DD 0029 ;	MA	#* ( 🉇 → (勝) ) TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-52DD → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-52DD, RIGHT PARENTHESIS	# →〔勝〕→
+
+3229 ;	0028 5341 0029 ;	MA	#* ( ㈩ → (十) ) PARENTHESIZED IDEOGRAPH TEN → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-5341, RIGHT PARENTHESIS	# 
+
+323F ;	0028 5354 0029 ;	MA	#* ( ㈿ → (協) ) PARENTHESIZED IDEOGRAPH ALLIANCE → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-5354, RIGHT PARENTHESIS	# 
+
+3234 ;	0028 540D 0029 ;	MA	#* ( ㈴ → (名) ) PARENTHESIZED IDEOGRAPH NAME → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-540D, RIGHT PARENTHESIS	# 
+
+323A ;	0028 547C 0029 ;	MA	#* ( ㈺ → (呼) ) PARENTHESIZED IDEOGRAPH CALL → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-547C, RIGHT PARENTHESIS	# 
+
+3223 ;	0028 56DB 0029 ;	MA	#* ( ㈣ → (四) ) PARENTHESIZED IDEOGRAPH FOUR → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-56DB, RIGHT PARENTHESIS	# 
+
+322F ;	0028 571F 0029 ;	MA	#* ( ㈯ → (土) ) PARENTHESIZED IDEOGRAPH EARTH → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-571F, RIGHT PARENTHESIS	# 
+
+323B ;	0028 5B66 0029 ;	MA	#* ( ㈻ → (学) ) PARENTHESIZED IDEOGRAPH STUDY → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-5B66, RIGHT PARENTHESIS	# 
+
+1F243 ;	0028 5B89 0029 ;	MA	#* ( 🉃 → (安) ) TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-5B89 → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-5B89, RIGHT PARENTHESIS	# →〔安〕→
+
+1F245 ;	0028 6253 0029 ;	MA	#* ( 🉅 → (打) ) TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-6253 → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-6253, RIGHT PARENTHESIS	# →〔打〕→
+
+1F248 ;	0028 6557 0029 ;	MA	#* ( 🉈 → (敗) ) TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-6557 → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-6557, RIGHT PARENTHESIS	# →〔敗〕→
+
+3230 ;	0028 65E5 0029 ;	MA	#* ( ㈰ → (日) ) PARENTHESIZED IDEOGRAPH SUN → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-65E5, RIGHT PARENTHESIS	# 
+
+322A ;	0028 6708 0029 ;	MA	#* ( ㈪ → (月) ) PARENTHESIZED IDEOGRAPH MOON → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-6708, RIGHT PARENTHESIS	# 
+
+3232 ;	0028 6709 0029 ;	MA	#* ( ㈲ → (有) ) PARENTHESIZED IDEOGRAPH HAVE → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-6709, RIGHT PARENTHESIS	# 
+
+322D ;	0028 6728 0029 ;	MA	#* ( ㈭ → (木) ) PARENTHESIZED IDEOGRAPH WOOD → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-6728, RIGHT PARENTHESIS	# 
+
+1F240 ;	0028 672C 0029 ;	MA	#* ( 🉀 → (本) ) TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-672C → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-672C, RIGHT PARENTHESIS	# →〔本〕→
+
+3231 ;	0028 682A 0029 ;	MA	#* ( ㈱ → (株) ) PARENTHESIZED IDEOGRAPH STOCK → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-682A, RIGHT PARENTHESIS	# 
+
+322C ;	0028 6C34 0029 ;	MA	#* ( ㈬ → (水) ) PARENTHESIZED IDEOGRAPH WATER → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-6C34, RIGHT PARENTHESIS	# 
+
+322B ;	0028 706B 0029 ;	MA	#* ( ㈫ → (火) ) PARENTHESIZED IDEOGRAPH FIRE → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-706B, RIGHT PARENTHESIS	# 
+
+1F244 ;	0028 70B9 0029 ;	MA	#* ( 🉄 → (点) ) TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-70B9 → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-70B9, RIGHT PARENTHESIS	# →〔点〕→
+
+3235 ;	0028 7279 0029 ;	MA	#* ( ㈵ → (特) ) PARENTHESIZED IDEOGRAPH SPECIAL → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-7279, RIGHT PARENTHESIS	# 
+
+1F246 ;	0028 76D7 0029 ;	MA	#* ( 🉆 → (盗) ) TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-76D7 → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-76D7, RIGHT PARENTHESIS	# →〔盗〕→
+
+323C ;	0028 76E3 0029 ;	MA	#* ( ㈼ → (監) ) PARENTHESIZED IDEOGRAPH SUPERVISE → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-76E3, RIGHT PARENTHESIS	# 
+
+3233 ;	0028 793E 0029 ;	MA	#* ( ㈳ → (社) ) PARENTHESIZED IDEOGRAPH SOCIETY → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-793E, RIGHT PARENTHESIS	# 
+
+3237 ;	0028 795D 0029 ;	MA	#* ( ㈷ → (祝) ) PARENTHESIZED IDEOGRAPH CONGRATULATION → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-795D, RIGHT PARENTHESIS	# 
+
+3240 ;	0028 796D 0029 ;	MA	#* ( ㉀ → (祭) ) PARENTHESIZED IDEOGRAPH FESTIVAL → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-796D, RIGHT PARENTHESIS	# 
+
+3242 ;	0028 81EA 0029 ;	MA	#* ( ㉂ → (自) ) PARENTHESIZED IDEOGRAPH SELF → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-81EA, RIGHT PARENTHESIS	# 
+
+3243 ;	0028 81F3 0029 ;	MA	#* ( ㉃ → (至) ) PARENTHESIZED IDEOGRAPH REACH → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-81F3, RIGHT PARENTHESIS	# 
+
+3236 ;	0028 8CA1 0029 ;	MA	#* ( ㈶ → (財) ) PARENTHESIZED IDEOGRAPH FINANCIAL → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-8CA1, RIGHT PARENTHESIS	# 
+
+323E ;	0028 8CC7 0029 ;	MA	#* ( ㈾ → (資) ) PARENTHESIZED IDEOGRAPH RESOURCE → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-8CC7, RIGHT PARENTHESIS	# 
+
+322E ;	0028 91D1 0029 ;	MA	#* ( ㈮ → (金) ) PARENTHESIZED IDEOGRAPH METAL → LEFT PARENTHESIS, CJK UNIFIED IDEOGRAPH-91D1, RIGHT PARENTHESIS	# 
+
+FF3D ;	0029 ;	MA	#* ( ］ → ) ) FULLWIDTH RIGHT SQUARE BRACKET → RIGHT PARENTHESIS	# →〕→
+2769 ;	0029 ;	MA	#* ( ❩ → ) ) MEDIUM RIGHT PARENTHESIS ORNAMENT → RIGHT PARENTHESIS	# 
+2773 ;	0029 ;	MA	#* ( ❳ → ) ) LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT → RIGHT PARENTHESIS	# →〕→
+3015 ;	0029 ;	MA	#* ( 〕 → ) ) RIGHT TORTOISE SHELL BRACKET → RIGHT PARENTHESIS	# 
+FD3F ;	0029 ;	MA	#* ( ﴿ → ) ) ORNATE RIGHT PARENTHESIS → RIGHT PARENTHESIS	# 
+
+2E29 ;	0029 0029 ;	MA	#* ( ⸩ → )) ) RIGHT DOUBLE PARENTHESIS → RIGHT PARENTHESIS, RIGHT PARENTHESIS	# 
+
+2774 ;	007B ;	MA	#* ( ❴ → { ) MEDIUM LEFT CURLY BRACKET ORNAMENT → LEFT CURLY BRACKET	# 
+1D114 ;	007B ;	MA	#* ( 𝄔 → { ) MUSICAL SYMBOL BRACE → LEFT CURLY BRACKET	# 
+
+2775 ;	007D ;	MA	#* ( ❵ → } ) MEDIUM RIGHT CURLY BRACKET ORNAMENT → RIGHT CURLY BRACKET	# 
+
+301A ;	27E6 ;	MA	#* ( 〚 → ⟦ ) LEFT WHITE SQUARE BRACKET → MATHEMATICAL LEFT WHITE SQUARE BRACKET	# 
+
+301B ;	27E7 ;	MA	#* ( 〛 → ⟧ ) RIGHT WHITE SQUARE BRACKET → MATHEMATICAL RIGHT WHITE SQUARE BRACKET	# 
+
+27E8 ;	276C ;	MA	#* ( ⟨ → ❬ ) MATHEMATICAL LEFT ANGLE BRACKET → MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT	# →〈→
+2329 ;	276C ;	MA	#* ( 〈 → ❬ ) LEFT-POINTING ANGLE BRACKET → MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT	# →〈→
+3008 ;	276C ;	MA	#* ( 〈 → ❬ ) LEFT ANGLE BRACKET → MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT	# 
+31DB ;	276C ;	MA	#* ( ㇛ → ❬ ) CJK STROKE PD → MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT	# →⟨→→〈→
+304F ;	276C ;	MA	# ( く → ❬ ) HIRAGANA LETTER KU → MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT	# →㇛→→⟨→→〈→
+21FE8 ;	276C ;	MA	# ( 𡿨 → ❬ ) CJK UNIFIED IDEOGRAPH-21FE8 → MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT	# →㇛→→⟨→→〈→
+
+27E9 ;	276D ;	MA	#* ( ⟩ → ❭ ) MATHEMATICAL RIGHT ANGLE BRACKET → MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT	# →〉→
+232A ;	276D ;	MA	#* ( 〉 → ❭ ) RIGHT-POINTING ANGLE BRACKET → MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT	# →〉→
+3009 ;	276D ;	MA	#* ( 〉 → ❭ ) RIGHT ANGLE BRACKET → MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT	# 
+
+FF3E ;	FE3F ;	MA	#* ( ＾ → ︿ ) FULLWIDTH CIRCUMFLEX ACCENT → PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET	# 
+
+2E3F ;	00B6 ;	MA	#* ( ⸿ → ¶ ) CAPITULUM → PILCROW SIGN	# 
+
+204E ;	002A ;	MA	#* ( ⁎ → * ) LOW ASTERISK → ASTERISK	# 
+066D ;	002A ;	MA	#* ( ‎٭‎ → * ) ARABIC FIVE POINTED STAR → ASTERISK	# 
+2217 ;	002A ;	MA	#* ( ∗ → * ) ASTERISK OPERATOR → ASTERISK	# 
+1031F ;	002A ;	MA	# ( 𐌟 → * ) OLD ITALIC LETTER ESS → ASTERISK	# 
+
+1735 ;	002F ;	MA	#* ( ᜵ → / ) PHILIPPINE SINGLE PUNCTUATION → SOLIDUS	# 
+2041 ;	002F ;	MA	#* ( ⁁ → / ) CARET INSERTION POINT → SOLIDUS	# 
+2215 ;	002F ;	MA	#* ( ∕ → / ) DIVISION SLASH → SOLIDUS	# 
+2044 ;	002F ;	MA	#* ( ⁄ → / ) FRACTION SLASH → SOLIDUS	# 
+2571 ;	002F ;	MA	#* ( ╱ → / ) BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT → SOLIDUS	# 
+27CB ;	002F ;	MA	#* ( ⟋ → / ) MATHEMATICAL RISING DIAGONAL → SOLIDUS	# 
+29F8 ;	002F ;	MA	#* ( ⧸ → / ) BIG SOLIDUS → SOLIDUS	# 
+1D23A ;	002F ;	MA	#* ( 𝈺 → / ) GREEK INSTRUMENTAL NOTATION SYMBOL-47 → SOLIDUS	# 
+31D3 ;	002F ;	MA	#* ( ㇓ → / ) CJK STROKE SP → SOLIDUS	# →⼃→
+3033 ;	002F ;	MA	# ( 〳 → / ) VERTICAL KANA REPEAT MARK UPPER HALF → SOLIDUS	# 
+2CC7 ;	002F ;	MA	# ( ⳇ → / ) COPTIC SMALL LETTER OLD COPTIC ESH → SOLIDUS	# 
+2CC6 ;	002F ;	MA	# ( Ⳇ → / ) COPTIC CAPITAL LETTER OLD COPTIC ESH → SOLIDUS	# 
+30CE ;	002F ;	MA	# ( ノ → / ) KATAKANA LETTER NO → SOLIDUS	# →⼃→
+4E3F ;	002F ;	MA	# ( 丿 → / ) CJK UNIFIED IDEOGRAPH-4E3F → SOLIDUS	# →⼃→
+2F03 ;	002F ;	MA	#* ( ⼃ → / ) KANGXI RADICAL SLASH → SOLIDUS	# 
+
+29F6 ;	002F 0304 ;	MA	#* ( ⧶ → /̄ ) SOLIDUS WITH OVERBAR → SOLIDUS, COMBINING MACRON	# 
+
+2AFD ;	002F 002F ;	MA	#* ( ⫽ → // ) DOUBLE SOLIDUS OPERATOR → SOLIDUS, SOLIDUS	# 
+
+2AFB ;	002F 002F 002F ;	MA	#* ( ⫻ → /// ) TRIPLE SOLIDUS BINARY RELATION → SOLIDUS, SOLIDUS, SOLIDUS	# 
+
+FF3C ;	005C ;	MA	#* ( ＼ → \ ) FULLWIDTH REVERSE SOLIDUS → REVERSE SOLIDUS	# →∖→
+FE68 ;	005C ;	MA	#* ( ﹨ → \ ) SMALL REVERSE SOLIDUS → REVERSE SOLIDUS	# →∖→
+2216 ;	005C ;	MA	#* ( ∖ → \ ) SET MINUS → REVERSE SOLIDUS	# 
+27CD ;	005C ;	MA	#* ( ⟍ → \ ) MATHEMATICAL FALLING DIAGONAL → REVERSE SOLIDUS	# 
+29F5 ;	005C ;	MA	#* ( ⧵ → \ ) REVERSE SOLIDUS OPERATOR → REVERSE SOLIDUS	# 
+29F9 ;	005C ;	MA	#* ( ⧹ → \ ) BIG REVERSE SOLIDUS → REVERSE SOLIDUS	# 
+1D20F ;	005C ;	MA	#* ( 𝈏 → \ ) GREEK VOCAL NOTATION SYMBOL-16 → REVERSE SOLIDUS	# 
+1D23B ;	005C ;	MA	#* ( 𝈻 → \ ) GREEK INSTRUMENTAL NOTATION SYMBOL-48 → REVERSE SOLIDUS	# →𝈏→
+31D4 ;	005C ;	MA	#* ( ㇔ → \ ) CJK STROKE D → REVERSE SOLIDUS	# →⼂→
+4E36 ;	005C ;	MA	# ( 丶 → \ ) CJK UNIFIED IDEOGRAPH-4E36 → REVERSE SOLIDUS	# →⼂→
+2F02 ;	005C ;	MA	#* ( ⼂ → \ ) KANGXI RADICAL DOT → REVERSE SOLIDUS	# 
+
+2CF9 ;	005C 005C ;	MA	#* ( ⳹ → \\ ) COPTIC OLD NUBIAN FULL STOP → REVERSE SOLIDUS, REVERSE SOLIDUS	# 
+244A ;	005C 005C ;	MA	#* ( ⑊ → \\ ) OCR DOUBLE BACKSLASH → REVERSE SOLIDUS, REVERSE SOLIDUS	# 
+
+27C8 ;	005C 1455 ;	MA	#* ( ⟈ → \ᑕ ) REVERSE SOLIDUS PRECEDING SUBSET → REVERSE SOLIDUS, CANADIAN SYLLABICS TA	# →\⊂→
+
+A778 ;	0026 ;	MA	# ( ꝸ → & ) LATIN SMALL LETTER UM → AMPERSAND	# 
+
+0AF0 ;	0970 ;	MA	#* ( ૰ → ॰ ) GUJARATI ABBREVIATION SIGN → DEVANAGARI ABBREVIATION SIGN	# 
+110BB ;	0970 ;	MA	#* ( 𑂻 → ॰ ) KAITHI ABBREVIATION SIGN → DEVANAGARI ABBREVIATION SIGN	# 
+111C7 ;	0970 ;	MA	#* ( 𑇇 → ॰ ) SHARADA ABBREVIATION SIGN → DEVANAGARI ABBREVIATION SIGN	# 
+26AC ;	0970 ;	MA	#* ( ⚬ → ॰ ) MEDIUM SMALL WHITE CIRCLE → DEVANAGARI ABBREVIATION SIGN	# 
+
+111DB ;	A8FC ;	MA	#* ( 𑇛 → ꣼ ) SHARADA SIGN SIDDHAM → DEVANAGARI SIGN SIDDHAM	# 
+
+17D9 ;	0E4F ;	MA	#* ( ៙ → ๏ ) KHMER SIGN PHNAEK MUAN → THAI CHARACTER FONGMAN	# 
+
+17D5 ;	0E5A ;	MA	#* ( ៕ → ๚ ) KHMER SIGN BARIYOOSAN → THAI CHARACTER ANGKHANKHU	# 
+
+17DA ;	0E5B ;	MA	#* ( ៚ → ๛ ) KHMER SIGN KOOMUUT → THAI CHARACTER KHOMUT	# 
+
+0F0C ;	0F0B ;	MA	#* ( ༌ → ་ ) TIBETAN MARK DELIMITER TSHEG BSTAR → TIBETAN MARK INTERSYLLABIC TSHEG	# 
+
+0F0E ;	0F0D 0F0D ;	MA	#* ( ༎ → །། ) TIBETAN MARK NYIS SHAD → TIBETAN MARK SHAD, TIBETAN MARK SHAD	# 
+
+02C4 ;	005E ;	MA	#* ( ˄ → ^ ) MODIFIER LETTER UP ARROWHEAD → CIRCUMFLEX ACCENT	# 
+02C6 ;	005E ;	MA	# ( ˆ → ^ ) MODIFIER LETTER CIRCUMFLEX ACCENT → CIRCUMFLEX ACCENT	# 
+
+A67E ;	02C7 ;	MA	#* ( ꙾ → ˇ ) CYRILLIC KAVYKA → CARON	# →˘→
+02D8 ;	02C7 ;	MA	#* ( ˘ → ˇ ) BREVE → CARON	# 
+
+203E ;	02C9 ;	MA	#* ( ‾ → ˉ ) OVERLINE → MODIFIER LETTER MACRON	# 
+FE49 ;	02C9 ;	MA	#* ( ﹉ → ˉ ) DASHED OVERLINE → MODIFIER LETTER MACRON	# →‾→
+FE4A ;	02C9 ;	MA	#* ( ﹊ → ˉ ) CENTRELINE OVERLINE → MODIFIER LETTER MACRON	# →‾→
+FE4B ;	02C9 ;	MA	#* ( ﹋ → ˉ ) WAVY OVERLINE → MODIFIER LETTER MACRON	# →‾→
+FE4C ;	02C9 ;	MA	#* ( ﹌ → ˉ ) DOUBLE WAVY OVERLINE → MODIFIER LETTER MACRON	# →‾→
+00AF ;	02C9 ;	MA	#* ( ¯ → ˉ ) MACRON → MODIFIER LETTER MACRON	# 
+FFE3 ;	02C9 ;	MA	#* ( ￣ → ˉ ) FULLWIDTH MACRON → MODIFIER LETTER MACRON	# →‾→
+2594 ;	02C9 ;	MA	#* ( ▔ → ˉ ) UPPER ONE EIGHTH BLOCK → MODIFIER LETTER MACRON	# →¯→
+
+044A ;	02C9 0062 ;	MA	# ( ъ → ˉb ) CYRILLIC SMALL LETTER HARD SIGN → MODIFIER LETTER MACRON, LATIN SMALL LETTER B	# →¯b→
+
+A651 ;	02C9 0062 0069 ;	MA	# ( ꙑ → ˉbi ) CYRILLIC SMALL LETTER YERU WITH BACK YER → MODIFIER LETTER MACRON, LATIN SMALL LETTER B, LATIN SMALL LETTER I	# →ъı→
+
+0375 ;	02CF ;	MA	#* ( ͵ → ˏ ) GREEK LOWER NUMERAL SIGN → MODIFIER LETTER LOW ACUTE ACCENT	# 
+
+02FB ;	02EA ;	MA	#* ( ˻ → ˪ ) MODIFIER LETTER BEGIN LOW TONE → MODIFIER LETTER YIN DEPARTING TONE MARK	# 
+A716 ;	02EA ;	MA	#* ( ꜖ → ˪ ) MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR → MODIFIER LETTER YIN DEPARTING TONE MARK	# 
+
+A714 ;	02EB ;	MA	#* ( ꜔ → ˫ ) MODIFIER LETTER MID LEFT-STEM TONE BAR → MODIFIER LETTER YANG DEPARTING TONE MARK	# 
+
+3002 ;	02F3 ;	MA	#* ( 。 → ˳ ) IDEOGRAPHIC FULL STOP → MODIFIER LETTER LOW RING	# 
+
+2E30 ;	00B0 ;	MA	#* ( ⸰ → ° ) RING POINT → DEGREE SIGN	# →∘→
+02DA ;	00B0 ;	MA	#* ( ˚ → ° ) RING ABOVE → DEGREE SIGN	# 
+2218 ;	00B0 ;	MA	#* ( ∘ → ° ) RING OPERATOR → DEGREE SIGN	# 
+25CB ;	00B0 ;	MA	#* ( ○ → ° ) WHITE CIRCLE → DEGREE SIGN	# →◦→→∘→
+25E6 ;	00B0 ;	MA	#* ( ◦ → ° ) WHITE BULLET → DEGREE SIGN	# →∘→
+
+235C ;	00B0 0332 ;	MA	#* ( ⍜ → °̲ ) APL FUNCTIONAL SYMBOL CIRCLE UNDERBAR → DEGREE SIGN, COMBINING LOW LINE	# →○̲→
+10ED0 ;	00B0 0332 ;	MA	#* ( 𐻐 → °̲ ) ARABIC BIBLICAL END OF VERSE → DEGREE SIGN, COMBINING LOW LINE	# →⍜→→○̲→
+
+2364 ;	00B0 0308 ;	MA	#* ( ⍤ → °̈ ) APL FUNCTIONAL SYMBOL JOT DIAERESIS → DEGREE SIGN, COMBINING DIAERESIS	# →◦̈→→∘̈→
+
+2103 ;	00B0 0043 ;	MA	#* ( ℃ → °C ) DEGREE CELSIUS → DEGREE SIGN, LATIN CAPITAL LETTER C	# 
+
+2109 ;	00B0 0046 ;	MA	#* ( ℉ → °F ) DEGREE FAHRENHEIT → DEGREE SIGN, LATIN CAPITAL LETTER F	# 
+
+0BF5 ;	0BF3 ;	MA	#* ( ௵ → ௳ ) TAMIL YEAR SIGN → TAMIL DAY SIGN	# 
+
+0F1B ;	0F1A 0F1A ;	MA	#* ( ༛ → ༚༚ ) TIBETAN SIGN RDEL DKAR GNYIS → TIBETAN SIGN RDEL DKAR GCIG, TIBETAN SIGN RDEL DKAR GCIG	# 
+
+0F1F ;	0F1A 0F1D ;	MA	#* ( ༟ → ༚༝ ) TIBETAN SIGN RDEL DKAR RDEL NAG → TIBETAN SIGN RDEL DKAR GCIG, TIBETAN SIGN RDEL NAG GCIG	# 
+
+0FCE ;	0F1D 0F1A ;	MA	#* ( ࿎ → ༝༚ ) TIBETAN SIGN RDEL NAG RDEL DKAR → TIBETAN SIGN RDEL NAG GCIG, TIBETAN SIGN RDEL DKAR GCIG	# 
+
+0F1E ;	0F1D 0F1D ;	MA	#* ( ༞ → ༝༝ ) TIBETAN SIGN RDEL NAG GNYIS → TIBETAN SIGN RDEL NAG GCIG, TIBETAN SIGN RDEL NAG GCIG	# 
+
+24B8 ;	00A9 ;	MA	#* ( Ⓒ → © ) CIRCLED LATIN CAPITAL LETTER C → COPYRIGHT SIGN	# 
+
+24C7 ;	00AE ;	MA	#* ( Ⓡ → ® ) CIRCLED LATIN CAPITAL LETTER R → REGISTERED SIGN	# 
+
+24C5 ;	2117 ;	MA	#* ( Ⓟ → ℗ ) CIRCLED LATIN CAPITAL LETTER P → SOUND RECORDING COPYRIGHT	# 
+
+1D21B ;	2144 ;	MA	#* ( 𝈛 → ⅄ ) GREEK VOCAL NOTATION SYMBOL-53 → TURNED SANS-SERIF CAPITAL Y	# 
+
+2BEC ;	219E ;	MA	#* ( ⯬ → ↞ ) LEFTWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS → LEFTWARDS TWO HEADED ARROW	# 
+
+2BED ;	219F ;	MA	#* ( ⯭ → ↟ ) UPWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS → UPWARDS TWO HEADED ARROW	# 
+
+2BEE ;	21A0 ;	MA	#* ( ⯮ → ↠ ) RIGHTWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS → RIGHTWARDS TWO HEADED ARROW	# 
+
+2BEF ;	21A1 ;	MA	#* ( ⯯ → ↡ ) DOWNWARDS TWO-HEADED ARROW WITH TRIANGLE ARROWHEADS → DOWNWARDS TWO HEADED ARROW	# 
+
+21B5 ;	21B2 ;	MA	#* ( ↵ → ↲ ) DOWNWARDS ARROW WITH CORNER LEFTWARDS → DOWNWARDS ARROW WITH TIP LEFTWARDS	# 
+
+2965 ;	21C3 21C2 ;	MA	#* ( ⥥ → ⇃⇂ ) DOWNWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT → DOWNWARDS HARPOON WITH BARB LEFTWARDS, DOWNWARDS HARPOON WITH BARB RIGHTWARDS	# 
+
+296F ;	21C3 16DA ;	MA	#* ( ⥯ → ⇃ᛚ ) DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT → DOWNWARDS HARPOON WITH BARB LEFTWARDS, RUNIC LETTER LAUKAZ LAGU LOGR L	# →⇃↾→
+
+1D6DB ;	2202 ;	MA	#* ( 𝛛 → ∂ ) MATHEMATICAL BOLD PARTIAL DIFFERENTIAL → PARTIAL DIFFERENTIAL	# 
+1D715 ;	2202 ;	MA	#* ( 𝜕 → ∂ ) MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL → PARTIAL DIFFERENTIAL	# 
+1D74F ;	2202 ;	MA	#* ( 𝝏 → ∂ ) MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL → PARTIAL DIFFERENTIAL	# 
+1D789 ;	2202 ;	MA	#* ( 𝞉 → ∂ ) MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL → PARTIAL DIFFERENTIAL	# 
+1D7C3 ;	2202 ;	MA	#* ( 𝟃 → ∂ ) MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL → PARTIAL DIFFERENTIAL	# 
+1E8CC ;	2202 ;	MA	#* ( ‎𞣌‎ → ∂ ) MENDE KIKAKUI DIGIT SIX → PARTIAL DIFFERENTIAL	# 
+
+1E8CD ;	2202 0335 ;	MA	#* ( ‎𞣍‎ → ∂̵ ) MENDE KIKAKUI DIGIT SEVEN → PARTIAL DIFFERENTIAL, COMBINING SHORT STROKE OVERLAY	# →ð→
+00F0 ;	2202 0335 ;	MA	# ( ð → ∂̵ ) LATIN SMALL LETTER ETH → PARTIAL DIFFERENTIAL, COMBINING SHORT STROKE OVERLAY	# 
+
+2300 ;	2205 ;	MA	#* ( ⌀ → ∅ ) DIAMETER SIGN → EMPTY SET	# 
+
+1D6C1 ;	2207 ;	MA	#* ( 𝛁 → ∇ ) MATHEMATICAL BOLD NABLA → NABLA	# 
+1D6FB ;	2207 ;	MA	#* ( 𝛻 → ∇ ) MATHEMATICAL ITALIC NABLA → NABLA	# 
+1D735 ;	2207 ;	MA	#* ( 𝜵 → ∇ ) MATHEMATICAL BOLD ITALIC NABLA → NABLA	# 
+1D76F ;	2207 ;	MA	#* ( 𝝯 → ∇ ) MATHEMATICAL SANS-SERIF BOLD NABLA → NABLA	# 
+1D7A9 ;	2207 ;	MA	#* ( 𝞩 → ∇ ) MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA → NABLA	# 
+118A8 ;	2207 ;	MA	# ( 𑢨 → ∇ ) WARANG CITI CAPITAL LETTER E → NABLA	# 
+
+2362 ;	2207 0308 ;	MA	#* ( ⍢ → ∇̈ ) APL FUNCTIONAL SYMBOL DEL DIAERESIS → NABLA, COMBINING DIAERESIS	# 
+
+236B ;	2207 0334 ;	MA	#* ( ⍫ → ∇̴ ) APL FUNCTIONAL SYMBOL DEL TILDE → NABLA, COMBINING TILDE OVERLAY	# 
+
+2588 ;	220E ;	MA	#* ( █ → ∎ ) FULL BLOCK → END OF PROOF	# →■→
+25A0 ;	220E ;	MA	#* ( ■ → ∎ ) BLACK SQUARE → END OF PROOF	# 
+
+2A3F ;	2210 ;	MA	#* ( ⨿ → ∐ ) AMALGAMATION OR COPRODUCT → N-ARY COPRODUCT	# 
+
+16ED ;	002B ;	MA	#* ( ᛭ → + ) RUNIC CROSS PUNCTUATION → PLUS SIGN	# 
+2795 ;	002B ;	MA	#* ( ➕ → + ) HEAVY PLUS SIGN → PLUS SIGN	# 
+1029B ;	002B ;	MA	# ( 𐊛 → + ) LYCIAN LETTER H → PLUS SIGN	# 
+1E6E9 ;	002B ;	MA	# ( 𞛩 → + ) TAI YO LETTER IA → PLUS SIGN	# 
+
+2A23 ;	002B 0302 ;	MA	#* ( ⨣ → +̂ ) PLUS SIGN WITH CIRCUMFLEX ACCENT ABOVE → PLUS SIGN, COMBINING CIRCUMFLEX ACCENT	# 
+
+2A22 ;	002B 030A ;	MA	#* ( ⨢ → +̊ ) PLUS SIGN WITH SMALL CIRCLE ABOVE → PLUS SIGN, COMBINING RING ABOVE	# 
+
+2A24 ;	002B 0303 ;	MA	#* ( ⨤ → +̃ ) PLUS SIGN WITH TILDE ABOVE → PLUS SIGN, COMBINING TILDE	# 
+
+2214 ;	002B 0307 ;	MA	#* ( ∔ → +̇ ) DOT PLUS → PLUS SIGN, COMBINING DOT ABOVE	# 
+
+2A25 ;	002B 0323 ;	MA	#* ( ⨥ → +̣ ) PLUS SIGN WITH DOT BELOW → PLUS SIGN, COMBINING DOT BELOW	# 
+
+2A26 ;	002B 0330 ;	MA	#* ( ⨦ → +̰ ) PLUS SIGN WITH TILDE BELOW → PLUS SIGN, COMBINING TILDE BELOW	# 
+
+2A27 ;	002B 2082 ;	MA	#* ( ⨧ → +₂ ) PLUS SIGN WITH SUBSCRIPT TWO → PLUS SIGN, SUBSCRIPT TWO	# 
+
+2797 ;	00F7 ;	MA	#* ( ➗ → ÷ ) HEAVY DIVISION SIGN → DIVISION SIGN	# 
+
+2039 ;	003C ;	MA	#* ( ‹ → < ) SINGLE LEFT-POINTING ANGLE QUOTATION MARK → LESS-THAN SIGN	# 
+276E ;	003C ;	MA	#* ( ❮ → < ) HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT → LESS-THAN SIGN	# →‹→
+02C2 ;	003C ;	MA	#* ( ˂ → < ) MODIFIER LETTER LEFT ARROWHEAD → LESS-THAN SIGN	# 
+1D236 ;	003C ;	MA	#* ( 𝈶 → < ) GREEK INSTRUMENTAL NOTATION SYMBOL-40 → LESS-THAN SIGN	# 
+1438 ;	003C ;	MA	# ( ᐸ → < ) CANADIAN SYLLABICS PA → LESS-THAN SIGN	# 
+16B2 ;	003C ;	MA	# ( ᚲ → < ) RUNIC LETTER KAUNA → LESS-THAN SIGN	# 
+
+22D6 ;	003C 00B7 ;	MA	#* ( ⋖ → <· ) LESS-THAN WITH DOT → LESS-THAN SIGN, MIDDLE DOT	# →ᑅ→→ᐸᐧ→
+2CB5 ;	003C 00B7 ;	MA	# ( ⲵ → <· ) COPTIC SMALL LETTER OLD COPTIC AIN → LESS-THAN SIGN, MIDDLE DOT	# →⋖→→ᑅ→→ᐸᐧ→
+2CB4 ;	003C 00B7 ;	MA	# ( Ⲵ → <· ) COPTIC CAPITAL LETTER OLD COPTIC AIN → LESS-THAN SIGN, MIDDLE DOT	# →ᑅ→→ᐸᐧ→
+1445 ;	003C 00B7 ;	MA	# ( ᑅ → <· ) CANADIAN SYLLABICS WEST-CREE PWA → LESS-THAN SIGN, MIDDLE DOT	# →ᐸᐧ→
+
+226A ;	003C 003C ;	MA	#* ( ≪ → << ) MUCH LESS-THAN → LESS-THAN SIGN, LESS-THAN SIGN	# 
+
+22D8 ;	003C 003C 003C ;	MA	#* ( ⋘ → <<< ) VERY MUCH LESS-THAN → LESS-THAN SIGN, LESS-THAN SIGN, LESS-THAN SIGN	# 
+
+1400 ;	003D ;	MA	#* ( ᐀ → = ) CANADIAN SYLLABICS HYPHEN → EQUALS SIGN	# 
+2E40 ;	003D ;	MA	#* ( ⹀ → = ) DOUBLE HYPHEN → EQUALS SIGN	# 
+30A0 ;	003D ;	MA	#* ( ゠ → = ) KATAKANA-HIRAGANA DOUBLE HYPHEN → EQUALS SIGN	# 
+A4FF ;	003D ;	MA	#* ( ꓿ → = ) LISU PUNCTUATION FULL STOP → EQUALS SIGN	# 
+
+225A ;	003D 0306 ;	MA	#* ( ≚ → =̆ ) EQUIANGULAR TO → EQUALS SIGN, COMBINING BREVE	# →=̌→
+
+2259 ;	003D 0302 ;	MA	#* ( ≙ → =̂ ) ESTIMATES → EQUALS SIGN, COMBINING CIRCUMFLEX ACCENT	# 
+
+2257 ;	003D 030A ;	MA	#* ( ≗ → =̊ ) RING EQUAL TO → EQUALS SIGN, COMBINING RING ABOVE	# 
+
+2250 ;	003D 0307 ;	MA	#* ( ≐ → =̇ ) APPROACHES THE LIMIT → EQUALS SIGN, COMBINING DOT ABOVE	# 
+
+2251 ;	003D 0307 0323 ;	MA	#* ( ≑ → =̣̇ ) GEOMETRICALLY EQUAL TO → EQUALS SIGN, COMBINING DOT ABOVE, COMBINING DOT BELOW	# →≐̣→
+
+2B96 ;	003D 1AB2 ;	MA	#* ( ⮖ → =᪲ ) EQUALS SIGN WITH INFINITY ABOVE → EQUALS SIGN, COMBINING INFINITY	# 
+
+2A6E ;	003D 20F0 ;	MA	#* ( ⩮ → =⃰ ) EQUALS WITH ASTERISK → EQUALS SIGN, COMBINING ASTERISK ABOVE	# 
+
+2A75 ;	003D 003D ;	MA	#* ( ⩵ → == ) TWO CONSECUTIVE EQUALS SIGNS → EQUALS SIGN, EQUALS SIGN	# 
+
+2A76 ;	003D 003D 003D ;	MA	#* ( ⩶ → === ) THREE CONSECUTIVE EQUALS SIGNS → EQUALS SIGN, EQUALS SIGN, EQUALS SIGN	# 
+
+225E ;	003D 036B ;	MA	#* ( ≞ → =ͫ ) MEASURED BY → EQUALS SIGN, COMBINING LATIN SMALL LETTER M	# 
+
+203A ;	003E ;	MA	#* ( › → > ) SINGLE RIGHT-POINTING ANGLE QUOTATION MARK → GREATER-THAN SIGN	# 
+276F ;	003E ;	MA	#* ( ❯ → > ) HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT → GREATER-THAN SIGN	# →›→
+02C3 ;	003E ;	MA	#* ( ˃ → > ) MODIFIER LETTER RIGHT ARROWHEAD → GREATER-THAN SIGN	# 
+1D237 ;	003E ;	MA	#* ( 𝈷 → > ) GREEK INSTRUMENTAL NOTATION SYMBOL-42 → GREATER-THAN SIGN	# 
+1433 ;	003E ;	MA	# ( ᐳ → > ) CANADIAN SYLLABICS PO → GREATER-THAN SIGN	# 
+16F3F ;	003E ;	MA	# ( 𖼿 → > ) MIAO LETTER ARCHAIC ZZA → GREATER-THAN SIGN	# 
+
+1441 ;	003E 00B7 ;	MA	# ( ᑁ → >· ) CANADIAN SYLLABICS WEST-CREE PWO → GREATER-THAN SIGN, MIDDLE DOT	# →ᐳᐧ→
+
+2AA5 ;	003E 003C ;	MA	#* ( ⪥ → >< ) GREATER-THAN BESIDE LESS-THAN → GREATER-THAN SIGN, LESS-THAN SIGN	# 
+
+226B ;	003E 003E ;	MA	#* ( ≫ → >> ) MUCH GREATER-THAN → GREATER-THAN SIGN, GREATER-THAN SIGN	# 
+2A20 ;	003E 003E ;	MA	#* ( ⨠ → >> ) Z NOTATION SCHEMA PIPING → GREATER-THAN SIGN, GREATER-THAN SIGN	# →≫→
+
+22D9 ;	003E 003E 003E ;	MA	#* ( ⋙ → >>> ) VERY MUCH GREATER-THAN → GREATER-THAN SIGN, GREATER-THAN SIGN, GREATER-THAN SIGN	# 
+
+2053 ;	007E ;	MA	#* ( ⁓ → ~ ) SWUNG DASH → TILDE	# 
+02DC ;	007E ;	MA	#* ( ˜ → ~ ) SMALL TILDE → TILDE	# 
+1FC0 ;	007E ;	MA	#* ( ῀ → ~ ) GREEK PERISPOMENI → TILDE	# →˜→
+223C ;	007E ;	MA	#* ( ∼ → ~ ) TILDE OPERATOR → TILDE	# 
+
+2368 ;	007E 0308 ;	MA	#* ( ⍨ → ~̈ ) APL FUNCTIONAL SYMBOL TILDE DIAERESIS → TILDE, COMBINING DIAERESIS	# 
+
+2E1E ;	007E 0307 ;	MA	#* ( ⸞ → ~̇ ) TILDE WITH DOT ABOVE → TILDE, COMBINING DOT ABOVE	# →⩪→→∼̇→→⁓̇→
+2A6A ;	007E 0307 ;	MA	#* ( ⩪ → ~̇ ) TILDE OPERATOR WITH DOT ABOVE → TILDE, COMBINING DOT ABOVE	# →∼̇→→⁓̇→
+
+2E1F ;	007E 0323 ;	MA	#* ( ⸟ → ~̣ ) TILDE WITH DOT BELOW → TILDE, COMBINING DOT BELOW	# 
+
+1E8C8 ;	2220 ;	MA	#* ( ‎𞣈‎ → ∠ ) MENDE KIKAKUI DIGIT TWO → ANGLE	# 
+
+22C0 ;	2227 ;	MA	#* ( ⋀ → ∧ ) N-ARY LOGICAL AND → LOGICAL AND	# 
+
+222F ;	222E 222E ;	MA	#* ( ∯ → ∮∮ ) SURFACE INTEGRAL → CONTOUR INTEGRAL, CONTOUR INTEGRAL	# 
+
+2230 ;	222E 222E 222E ;	MA	#* ( ∰ → ∮∮∮ ) VOLUME INTEGRAL → CONTOUR INTEGRAL, CONTOUR INTEGRAL, CONTOUR INTEGRAL	# 
+
+2E2B ;	2234 ;	MA	#* ( ⸫ → ∴ ) ONE DOT OVER TWO DOTS PUNCTUATION → THEREFORE	# 
+
+2E2A ;	2235 ;	MA	#* ( ⸪ → ∵ ) TWO DOTS OVER ONE DOT PUNCTUATION → BECAUSE	# 
+
+2E2C ;	2237 ;	MA	#* ( ⸬ → ∷ ) SQUARED FOUR DOT PUNCTUATION → PROPORTION	# 
+
+111DE ;	2248 ;	MA	#* ( 𑇞 → ≈ ) SHARADA SECTION MARK-1 → ALMOST EQUAL TO	# 
+
+264E ;	224F ;	MA	#* ( ♎ → ≏ ) LIBRA → DIFFERENCE BETWEEN	# 
+1F75E ;	224F ;	MA	#* ( 🝞 → ≏ ) ALCHEMICAL SYMBOL FOR SUBLIMATION → DIFFERENCE BETWEEN	# →♎→
+
+2263 ;	2261 ;	MA	#* ( ≣ → ≡ ) STRICTLY EQUIVALENT TO → IDENTICAL TO	# 
+2CB7 ;	2261 ;	MA	# ( ⲷ → ≡ ) COPTIC SMALL LETTER CRYPTOGRAMMIC EIE → IDENTICAL TO	# 
+
+2A03 ;	228D ;	MA	#* ( ⨃ → ⊍ ) N-ARY UNION OPERATOR WITH DOT → MULTISET MULTIPLICATION	# 
+
+2A04 ;	228E ;	MA	#* ( ⨄ → ⊎ ) N-ARY UNION OPERATOR WITH PLUS → MULTISET UNION	# 
+
+1D238 ;	228F ;	MA	#* ( 𝈸 → ⊏ ) GREEK INSTRUMENTAL NOTATION SYMBOL-43 → SQUARE IMAGE OF	# 
+
+1D239 ;	2290 ;	MA	#* ( 𝈹 → ⊐ ) GREEK INSTRUMENTAL NOTATION SYMBOL-45 → SQUARE ORIGINAL OF	# 
+
+2A05 ;	2293 ;	MA	#* ( ⨅ → ⊓ ) N-ARY SQUARE INTERSECTION OPERATOR → SQUARE CAP	# 
+
+2A06 ;	2294 ;	MA	#* ( ⨆ → ⊔ ) N-ARY SQUARE UNION OPERATOR → SQUARE CUP	# 
+
+2A02 ;	2297 ;	MA	#* ( ⨂ → ⊗ ) N-ARY CIRCLED TIMES OPERATOR → CIRCLED TIMES	# 
+
+235F ;	229B ;	MA	#* ( ⍟ → ⊛ ) APL FUNCTIONAL SYMBOL CIRCLE STAR → CIRCLED ASTERISK OPERATOR	# 
+
+1F771 ;	22A0 ;	MA	#* ( 🝱 → ⊠ ) ALCHEMICAL SYMBOL FOR MONTH → SQUARED TIMES	# 
+
+1F755 ;	22A1 ;	MA	#* ( 🝕 → ⊡ ) ALCHEMICAL SYMBOL FOR URINE → SQUARED DOT OPERATOR	# 
+
+25C1 ;	22B2 ;	MA	#* ( ◁ → ⊲ ) WHITE LEFT-POINTING TRIANGLE → NORMAL SUBGROUP OF	# 
+
+25B7 ;	22B3 ;	MA	#* ( ▷ → ⊳ ) WHITE RIGHT-POINTING TRIANGLE → CONTAINS AS NORMAL SUBGROUP	# 
+
+2363 ;	22C6 0308 ;	MA	#* ( ⍣ → ⋆̈ ) APL FUNCTIONAL SYMBOL STAR DIAERESIS → STAR OPERATOR, COMBINING DIAERESIS	# 
+
+FE34 ;	2307 ;	MA	# ( ︴ → ⌇ ) PRESENTATION FORM FOR VERTICAL WAVY LOW LINE → WAVY LINE	# 
+
+25E0 ;	2312 ;	MA	#* ( ◠ → ⌒ ) UPPER HALF CIRCLE → ARC	# 
+
+2A3D ;	2319 ;	MA	#* ( ⨽ → ⌙ ) RIGHTHAND INTERIOR PRODUCT → TURNED NOT SIGN	# 
+
+2325 ;	2324 ;	MA	#* ( ⌥ → ⌤ ) OPTION KEY → UP ARROWHEAD BETWEEN TWO HORIZONTAL BARS	# 
+
+29C7 ;	233B ;	MA	#* ( ⧇ → ⌻ ) SQUARED SMALL CIRCLE → APL FUNCTIONAL SYMBOL QUAD JOT	# 
+
+25CE ;	233E ;	MA	#* ( ◎ → ⌾ ) BULLSEYE → APL FUNCTIONAL SYMBOL CIRCLE JOT	# →⦾→
+29BE ;	233E ;	MA	#* ( ⦾ → ⌾ ) CIRCLED WHITE BULLET → APL FUNCTIONAL SYMBOL CIRCLE JOT	# 
+
+29C5 ;	2342 ;	MA	#* ( ⧅ → ⍂ ) SQUARED FALLING DIAGONAL SLASH → APL FUNCTIONAL SYMBOL QUAD BACKSLASH	# 
+
+29B0 ;	2349 ;	MA	#* ( ⦰ → ⍉ ) REVERSED EMPTY SET → APL FUNCTIONAL SYMBOL CIRCLE BACKSLASH	# 
+
+23C3 ;	234B ;	MA	#* ( ⏃ → ⍋ ) DENTISTRY SYMBOL LIGHT VERTICAL WITH TRIANGLE → APL FUNCTIONAL SYMBOL DELTA STILE	# 
+
+23C2 ;	234E ;	MA	#* ( ⏂ → ⍎ ) DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH CIRCLE → APL FUNCTIONAL SYMBOL DOWN TACK JOT	# 
+
+23C1 ;	2355 ;	MA	#* ( ⏁ → ⍕ ) DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH CIRCLE → APL FUNCTIONAL SYMBOL UP TACK JOT	# 
+
+23C6 ;	236D ;	MA	#* ( ⏆ → ⍭ ) DENTISTRY SYMBOL LIGHT VERTICAL AND WAVE → APL FUNCTIONAL SYMBOL STILE TILDE	# 
+
+2638 ;	2388 ;	MA	#* ( ☸ → ⎈ ) WHEEL OF DHARMA → HELM SYMBOL	# 
+
+FE35 ;	23DC ;	MA	#* ( ︵ → ⏜ ) PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS → TOP PARENTHESIS	# 
+
+FE36 ;	23DD ;	MA	#* ( ︶ → ⏝ ) PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS → BOTTOM PARENTHESIS	# 
+
+FE37 ;	23DE ;	MA	#* ( ︷ → ⏞ ) PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET → TOP CURLY BRACKET	# 
+
+FE38 ;	23DF ;	MA	#* ( ︸ → ⏟ ) PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET → BOTTOM CURLY BRACKET	# 
+
+FE39 ;	23E0 ;	MA	#* ( ︹ → ⏠ ) PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET → TOP TORTOISE SHELL BRACKET	# 
+
+FE3A ;	23E1 ;	MA	#* ( ︺ → ⏡ ) PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET → BOTTOM TORTOISE SHELL BRACKET	# 
+
+25B1 ;	23E5 ;	MA	#* ( ▱ → ⏥ ) WHITE PARALLELOGRAM → FLATNESS	# 
+
+23FC ;	23FB ;	MA	#* ( ⏼ → ⏻ ) POWER ON-OFF SYMBOL → POWER SYMBOL	# 
+
+FE31 ;	2502 ;	MA	#* ( ︱ → │ ) PRESENTATION FORM FOR VERTICAL EM DASH → BOX DRAWINGS LIGHT VERTICAL	# →｜→
+FF5C ;	2502 ;	MA	#* ( ｜ → │ ) FULLWIDTH VERTICAL LINE → BOX DRAWINGS LIGHT VERTICAL	# 
+2503 ;	2502 ;	MA	#* ( ┃ → │ ) BOX DRAWINGS HEAVY VERTICAL → BOX DRAWINGS LIGHT VERTICAL	# 
+
+250F ;	250C ;	MA	#* ( ┏ → ┌ ) BOX DRAWINGS HEAVY DOWN AND RIGHT → BOX DRAWINGS LIGHT DOWN AND RIGHT	# 
+
+2523 ;	251C ;	MA	#* ( ┣ → ├ ) BOX DRAWINGS HEAVY VERTICAL AND RIGHT → BOX DRAWINGS LIGHT VERTICAL AND RIGHT	# 
+
+2590 ;	258C ;	MA	#* ( ▐ → ▌ ) RIGHT HALF BLOCK → LEFT HALF BLOCK	# 
+
+2597 ;	2596 ;	MA	#* ( ▗ → ▖ ) QUADRANT LOWER RIGHT → QUADRANT LOWER LEFT	# 
+
+259D ;	2598 ;	MA	#* ( ▝ → ▘ ) QUADRANT UPPER RIGHT → QUADRANT UPPER LEFT	# 
+
+2610 ;	25A1 ;	MA	#* ( ☐ → □ ) BALLOT BOX → WHITE SQUARE	# 
+
+FFED ;	25AA ;	MA	#* ( ￭ → ▪ ) HALFWIDTH BLACK SQUARE → BLACK SMALL SQUARE	# 
+
+25B8 ;	25B6 ;	MA	#* ( ▸ → ▶ ) BLACK RIGHT-POINTING SMALL TRIANGLE → BLACK RIGHT-POINTING TRIANGLE	# →►→
+25BA ;	25B6 ;	MA	#* ( ► → ▶ ) BLACK RIGHT-POINTING POINTER → BLACK RIGHT-POINTING TRIANGLE	# 
+
+2CE9 ;	2627 ;	MA	#* ( ⳩ → ☧ ) COPTIC SYMBOL KHI RO → CHI RHO	# 
+
+1F70A ;	2629 ;	MA	#* ( 🜊 → ☩ ) ALCHEMICAL SYMBOL FOR VINEGAR → CROSS OF JERUSALEM	# 
+
+1F312 ;	263D ;	MA	#* ( 🌒 → ☽ ) WAXING CRESCENT MOON SYMBOL → FIRST QUARTER MOON	# 
+1F319 ;	263D ;	MA	#* ( 🌙 → ☽ ) CRESCENT MOON → FIRST QUARTER MOON	# 
+
+23FE ;	263E ;	MA	#* ( ⏾ → ☾ ) POWER SLEEP SYMBOL → LAST QUARTER MOON	# 
+1F318 ;	263E ;	MA	#* ( 🌘 → ☾ ) WANING CRESCENT MOON SYMBOL → LAST QUARTER MOON	# 
+
+29D9 ;	299A ;	MA	#* ( ⧙ → ⦚ ) RIGHT WIGGLY FENCE → VERTICAL ZIGZAG LINE	# 
+
+1F73A ;	29DF ;	MA	#* ( 🜺 → ⧟ ) ALCHEMICAL SYMBOL FOR ARSENIC → DOUBLE-ENDED MULTIMAP	# 
+
+2A3E ;	2A1F ;	MA	#* ( ⨾ → ⨟ ) Z NOTATION RELATIONAL COMPOSITION → Z NOTATION SCHEMA COMPOSITION	# 
+
+2669 ;	1D158 1D165 ;	MA	#* ( ♩ → 𝅘𝅥 ) QUARTER NOTE → MUSICAL SYMBOL NOTEHEAD BLACK, MUSICAL SYMBOL COMBINING STEM	# 
+
+266A ;	1D158 1D165 1D16E ;	MA	#* ( ♪ → 𝅘𝅥𝅮 ) EIGHTH NOTE → MUSICAL SYMBOL NOTEHEAD BLACK, MUSICAL SYMBOL COMBINING STEM, MUSICAL SYMBOL COMBINING FLAG-1	# 
+
+24EA ;	1F10D ;	MA	#* ( ⓪ → 🄍 ) CIRCLED DIGIT ZERO → CIRCLED ZERO WITH SLASH	# 
+
+21BA ;	1F10E ;	MA	#* ( ↺ → 🄎 ) ANTICLOCKWISE OPEN CIRCLE ARROW → CIRCLED ANTICLOCKWISE ARROW	# 
+
+1CCFB ;	1F6F8 ;	MA	#* ( 𜳻 → 🛸 ) FLYING SAUCER SYMBOL → FLYING SAUCER	# 
+
+02D9 ;	0971 ;	MA	#* ( ˙ → ॱ ) DOT ABOVE → DEVANAGARI SIGN HIGH SPACING DOT	# 
+0D4E ;	0971 ;	MA	# ( ൎ → ॱ ) MALAYALAM LETTER DOT REPH → DEVANAGARI SIGN HIGH SPACING DOT	# →˙→
+
+FF0D ;	30FC ;	MA	#* ( － → ー ) FULLWIDTH HYPHEN-MINUS → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# 
+2014 ;	30FC ;	MA	#* ( — → ー ) EM DASH → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →一→
+2015 ;	30FC ;	MA	#* ( ― → ー ) HORIZONTAL BAR → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →—→→一→
+2500 ;	30FC ;	MA	#* ( ─ → ー ) BOX DRAWINGS LIGHT HORIZONTAL → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →━→→—→→一→
+2501 ;	30FC ;	MA	#* ( ━ → ー ) BOX DRAWINGS HEAVY HORIZONTAL → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →—→→一→
+31D0 ;	30FC ;	MA	#* ( ㇐ → ー ) CJK STROKE H → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →一→
+A7F7 ;	30FC ;	MA	# ( ꟷ → ー ) LATIN EPIGRAPHIC LETTER SIDEWAYS I → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →—→→一→
+1173 ;	30FC ;	MA	# ( ᅳ → ー ) HANGUL JUNGSEONG EU → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →ㅡ→→—→→一→
+3161 ;	30FC ;	MA	# ( ㅡ → ー ) HANGUL LETTER EU → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →—→→一→
+4E00 ;	30FC ;	MA	# ( 一 → ー ) CJK UNIFIED IDEOGRAPH-4E00 → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# 
+2F00 ;	30FC ;	MA	#* ( ⼀ → ー ) KANGXI RADICAL ONE → KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →一→
+
+1196 ;	30FC 30FC ;	MA	# ( ᆖ → ーー ) HANGUL JUNGSEONG EU-EU → KATAKANA-HIRAGANA PROLONGED SOUND MARK, KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →ᅳᅳ→
+
+D7B9 ;	30FC 1161 ;	MA	# ( ힹ → ーᅡ ) HANGUL JUNGSEONG EU-A → KATAKANA-HIRAGANA PROLONGED SOUND MARK, HANGUL JUNGSEONG A	# →ᅳᅡ→
+
+D7BA ;	30FC 1165 ;	MA	# ( ힺ → ーᅥ ) HANGUL JUNGSEONG EU-EO → KATAKANA-HIRAGANA PROLONGED SOUND MARK, HANGUL JUNGSEONG EO	# →ᅳᅥ→
+
+D7BB ;	30FC 1165 4E28 ;	MA	# ( ힻ → ーᅥ丨 ) HANGUL JUNGSEONG EU-E → KATAKANA-HIRAGANA PROLONGED SOUND MARK, HANGUL JUNGSEONG EO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅳᅥᅵ→
+
+D7BC ;	30FC 1169 ;	MA	# ( ힼ → ーᅩ ) HANGUL JUNGSEONG EU-O → KATAKANA-HIRAGANA PROLONGED SOUND MARK, HANGUL JUNGSEONG O	# →ᅳᅩ→
+
+1195 ;	30FC 116E ;	MA	# ( ᆕ → ーᅮ ) HANGUL JUNGSEONG EU-U → KATAKANA-HIRAGANA PROLONGED SOUND MARK, HANGUL JUNGSEONG U	# →ᅳᅮ→
+
+1174 ;	30FC 4E28 ;	MA	# ( ᅴ → ー丨 ) HANGUL JUNGSEONG YI → KATAKANA-HIRAGANA PROLONGED SOUND MARK, CJK UNIFIED IDEOGRAPH-4E28	# →ᅳᅵ→
+3162 ;	30FC 4E28 ;	MA	# ( ㅢ → ー丨 ) HANGUL LETTER YI → KATAKANA-HIRAGANA PROLONGED SOUND MARK, CJK UNIFIED IDEOGRAPH-4E28	# →ᅴ→→ᅳᅵ→
+
+1197 ;	30FC 4E28 116E ;	MA	# ( ᆗ → ー丨ᅮ ) HANGUL JUNGSEONG YI-U → KATAKANA-HIRAGANA PROLONGED SOUND MARK, CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG U	# →ᅳᅵᅮ→
+
+1F10F ;	0024 20E0 ;	MA	#* ( 🄏 → $⃠ ) CIRCLED DOLLAR SIGN WITH OVERLAID BACKSLASH → DOLLAR SIGN, COMBINING ENCLOSING CIRCLE BACKSLASH	# 
+
+20A4 ;	00A3 ;	MA	#* ( ₤ → £ ) LIRA SIGN → POUND SIGN	# 
+
+3012 ;	20B8 ;	MA	#* ( 〒 → ₸ ) POSTAL MARK → TENGE SIGN	# 
+3036 ;	20B8 ;	MA	#* ( 〶 → ₸ ) CIRCLED POSTAL MARK → TENGE SIGN	# →〒→
+
+1B5C ;	1B50 ;	MA	#* ( ᭜ → ᭐ ) BALINESE WINDU → BALINESE DIGIT ZERO	# 
+
+A9C6 ;	A9D0 ;	MA	#* ( ꧆ → ꧐ ) JAVANESE PADA WINDU → JAVANESE DIGIT ZERO	# 
+
+114D1 ;	09E7 ;	MA	# ( 𑓑 → ১ ) TIRHUTA DIGIT ONE → BENGALI DIGIT ONE	# 
+
+0CE7 ;	0C67 ;	MA	# ( ೧ → ౧ ) KANNADA DIGIT ONE → TELUGU DIGIT ONE	# 
+
+1065 ;	1041 ;	MA	# ( ၥ → ၁ ) MYANMAR LETTER WESTERN PWO KAREN THA → MYANMAR DIGIT ONE	# 
+
+2460 ;	2780 ;	MA	#* ( ① → ➀ ) CIRCLED DIGIT ONE → DINGBAT CIRCLED SANS-SERIF DIGIT ONE	# 
+
+2469 ;	2789 ;	MA	#* ( ⑩ → ➉ ) CIRCLED NUMBER TEN → DINGBAT CIRCLED SANS-SERIF NUMBER TEN	# 
+
+23E8 ;	2081 2080 ;	MA	#* ( ⏨ → ₁₀ ) DECIMAL EXPONENT SYMBOL → SUBSCRIPT ONE, SUBSCRIPT ZERO	# 
+
+1CCF2 ;	0032 ;	MA	# ( 𜳲 → 2 ) OUTLINED DIGIT TWO → DIGIT TWO	# 
+1D7D0 ;	0032 ;	MA	# ( 𝟐 → 2 ) MATHEMATICAL BOLD DIGIT TWO → DIGIT TWO	# 
+1D7DA ;	0032 ;	MA	# ( 𝟚 → 2 ) MATHEMATICAL DOUBLE-STRUCK DIGIT TWO → DIGIT TWO	# 
+1D7E4 ;	0032 ;	MA	# ( 𝟤 → 2 ) MATHEMATICAL SANS-SERIF DIGIT TWO → DIGIT TWO	# 
+1D7EE ;	0032 ;	MA	# ( 𝟮 → 2 ) MATHEMATICAL SANS-SERIF BOLD DIGIT TWO → DIGIT TWO	# 
+1D7F8 ;	0032 ;	MA	# ( 𝟸 → 2 ) MATHEMATICAL MONOSPACE DIGIT TWO → DIGIT TWO	# 
+1FBF2 ;	0032 ;	MA	# ( 🯲 → 2 ) SEGMENTED DIGIT TWO → DIGIT TWO	# 
+A75A ;	0032 ;	MA	# ( Ꝛ → 2 ) LATIN CAPITAL LETTER R ROTUNDA → DIGIT TWO	# 
+01A7 ;	0032 ;	MA	# ( Ƨ → 2 ) LATIN CAPITAL LETTER TONE TWO → DIGIT TWO	# 
+03E8 ;	0032 ;	MA	# ( Ϩ → 2 ) COPTIC CAPITAL LETTER HORI → DIGIT TWO	# →Ƨ→
+A644 ;	0032 ;	MA	# ( Ꙅ → 2 ) CYRILLIC CAPITAL LETTER REVERSED DZE → DIGIT TWO	# →Ƨ→
+14BF ;	0032 ;	MA	# ( ᒿ → 2 ) CANADIAN SYLLABICS SAYISI M → DIGIT TWO	# 
+A6EF ;	0032 ;	MA	# ( ꛯ → 2 ) BAMUM LETTER KOGHOM → DIGIT TWO	# →Ƨ→
+
+A9CF ;	0662 ;	MA	# ( ꧏ → ‎٢‎ ) JAVANESE PANGRANGKEP → ARABIC-INDIC DIGIT TWO	# 
+06F2 ;	0662 ;	MA	# ( ۲ → ‎٢‎ ) EXTENDED ARABIC-INDIC DIGIT TWO → ARABIC-INDIC DIGIT TWO	# 
+
+0AE8 ;	0968 ;	MA	# ( ૨ → २ ) GUJARATI DIGIT TWO → DEVANAGARI DIGIT TWO	# 
+0AB0 ;	0968 ;	MA	# ( ર → २ ) GUJARATI LETTER RA → DEVANAGARI DIGIT TWO	# →૨→
+
+114D2 ;	09E8 ;	MA	# ( 𑓒 → ২ ) TIRHUTA DIGIT TWO → BENGALI DIGIT TWO	# 
+
+0CE8 ;	0C68 ;	MA	# ( ೨ → ౨ ) KANNADA DIGIT TWO → TELUGU DIGIT TWO	# 
+
+2461 ;	2781 ;	MA	#* ( ② → ➁ ) CIRCLED DIGIT TWO → DINGBAT CIRCLED SANS-SERIF DIGIT TWO	# 
+
+01BB ;	0032 0335 ;	MA	# ( ƻ → 2̵ ) LATIN LETTER TWO WITH STROKE → DIGIT TWO, COMBINING SHORT STROKE OVERLAY	# 
+
+1F103 ;	0032 002C ;	MA	#* ( 🄃 → 2, ) DIGIT TWO COMMA → DIGIT TWO, COMMA	# 
+
+2489 ;	0032 002E ;	MA	#* ( ⒉ → 2. ) DIGIT TWO FULL STOP → DIGIT TWO, FULL STOP	# 
+
+33F5 ;	0032 0032 65E5 ;	MA	#* ( ㏵ → 22日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-TWO → DIGIT TWO, DIGIT TWO, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+336E ;	0032 0032 70B9 ;	MA	#* ( ㍮ → 22点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-TWO → DIGIT TWO, DIGIT TWO, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+33F6 ;	0032 0033 65E5 ;	MA	#* ( ㏶ → 23日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-THREE → DIGIT TWO, DIGIT THREE, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+336F ;	0032 0033 70B9 ;	MA	#* ( ㍯ → 23点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-THREE → DIGIT TWO, DIGIT THREE, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+33F7 ;	0032 0034 65E5 ;	MA	#* ( ㏷ → 24日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-FOUR → DIGIT TWO, DIGIT FOUR, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+3370 ;	0032 0034 70B9 ;	MA	#* ( ㍰ → 24点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-FOUR → DIGIT TWO, DIGIT FOUR, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+33F8 ;	0032 0035 65E5 ;	MA	#* ( ㏸ → 25日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-FIVE → DIGIT TWO, DIGIT FIVE, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+33F9 ;	0032 0036 65E5 ;	MA	#* ( ㏹ → 26日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-SIX → DIGIT TWO, DIGIT SIX, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+33FA ;	0032 0037 65E5 ;	MA	#* ( ㏺ → 27日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-SEVEN → DIGIT TWO, DIGIT SEVEN, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+33FB ;	0032 0038 65E5 ;	MA	#* ( ㏻ → 28日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-EIGHT → DIGIT TWO, DIGIT EIGHT, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+33FC ;	0032 0039 65E5 ;	MA	#* ( ㏼ → 29日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-NINE → DIGIT TWO, DIGIT NINE, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+33F4 ;	0032 006C 65E5 ;	MA	#* ( ㏴ → 2l日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-ONE → DIGIT TWO, LATIN SMALL LETTER L, CJK UNIFIED IDEOGRAPH-65E5	# →21日→
+
+336D ;	0032 006C 70B9 ;	MA	#* ( ㍭ → 2l点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-ONE → DIGIT TWO, LATIN SMALL LETTER L, CJK UNIFIED IDEOGRAPH-70B9	# →21点→
+
+249B ;	0032 004F 002E ;	MA	#* ( ⒛ → 2O. ) NUMBER TWENTY FULL STOP → DIGIT TWO, LATIN CAPITAL LETTER O, FULL STOP	# →20.→
+
+33F3 ;	0032 004F 65E5 ;	MA	#* ( ㏳ → 2O日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY → DIGIT TWO, LATIN CAPITAL LETTER O, CJK UNIFIED IDEOGRAPH-65E5	# →20日→
+
+336C ;	0032 004F 70B9 ;	MA	#* ( ㍬ → 2O点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY → DIGIT TWO, LATIN CAPITAL LETTER O, CJK UNIFIED IDEOGRAPH-70B9	# →20点→
+
+0DE9 ;	0DE8 0DCF ;	MA	# ( ෩ → ෨ා ) SINHALA LITH DIGIT THREE → SINHALA LITH DIGIT TWO, SINHALA VOWEL SIGN AELA-PILLA	# 
+
+0DEF ;	0DE8 0DD3 ;	MA	# ( ෯ → ෨ී ) SINHALA LITH DIGIT NINE → SINHALA LITH DIGIT TWO, SINHALA VOWEL SIGN DIGA IS-PILLA	# 
+
+33E1 ;	0032 65E5 ;	MA	#* ( ㏡ → 2日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWO → DIGIT TWO, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+32C1 ;	0032 6708 ;	MA	#* ( ㋁ → 2月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR FEBRUARY → DIGIT TWO, CJK UNIFIED IDEOGRAPH-6708	# 
+
+335A ;	0032 70B9 ;	MA	#* ( ㍚ → 2点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWO → DIGIT TWO, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+1D206 ;	0033 ;	MA	#* ( 𝈆 → 3 ) GREEK VOCAL NOTATION SYMBOL-7 → DIGIT THREE	# 
+0969 ;	0033 ;	MA	# ( ३ → 3 ) DEVANAGARI DIGIT THREE → DIGIT THREE	# →૩→
+0AE9 ;	0033 ;	MA	# ( ૩ → 3 ) GUJARATI DIGIT THREE → DIGIT THREE	# 
+1CCF3 ;	0033 ;	MA	# ( 𜳳 → 3 ) OUTLINED DIGIT THREE → DIGIT THREE	# 
+1D7D1 ;	0033 ;	MA	# ( 𝟑 → 3 ) MATHEMATICAL BOLD DIGIT THREE → DIGIT THREE	# 
+1D7DB ;	0033 ;	MA	# ( 𝟛 → 3 ) MATHEMATICAL DOUBLE-STRUCK DIGIT THREE → DIGIT THREE	# 
+1D7E5 ;	0033 ;	MA	# ( 𝟥 → 3 ) MATHEMATICAL SANS-SERIF DIGIT THREE → DIGIT THREE	# 
+1D7EF ;	0033 ;	MA	# ( 𝟯 → 3 ) MATHEMATICAL SANS-SERIF BOLD DIGIT THREE → DIGIT THREE	# 
+1D7F9 ;	0033 ;	MA	# ( 𝟹 → 3 ) MATHEMATICAL MONOSPACE DIGIT THREE → DIGIT THREE	# 
+1FBF3 ;	0033 ;	MA	# ( 🯳 → 3 ) SEGMENTED DIGIT THREE → DIGIT THREE	# 
+A7AB ;	0033 ;	MA	# ( Ɜ → 3 ) LATIN CAPITAL LETTER REVERSED OPEN E → DIGIT THREE	# 
+021C ;	0033 ;	MA	# ( Ȝ → 3 ) LATIN CAPITAL LETTER YOGH → DIGIT THREE	# →Ʒ→
+01B7 ;	0033 ;	MA	# ( Ʒ → 3 ) LATIN CAPITAL LETTER EZH → DIGIT THREE	# 
+A76A ;	0033 ;	MA	# ( Ꝫ → 3 ) LATIN CAPITAL LETTER ET → DIGIT THREE	# 
+2C9C ;	0033 ;	MA	# ( Ⲝ → 3 ) COPTIC CAPITAL LETTER KSI → DIGIT THREE	# →Ʒ→
+2CC4 ;	0033 ;	MA	# ( Ⳅ → 3 ) COPTIC CAPITAL LETTER OLD COPTIC SHEI → DIGIT THREE	# →Ʒ→
+2CCC ;	0033 ;	MA	# ( Ⳍ → 3 ) COPTIC CAPITAL LETTER OLD COPTIC HORI → DIGIT THREE	# →Ȝ→→Ʒ→
+0417 ;	0033 ;	MA	# ( З → 3 ) CYRILLIC CAPITAL LETTER ZE → DIGIT THREE	# 
+04E0 ;	0033 ;	MA	# ( Ӡ → 3 ) CYRILLIC CAPITAL LETTER ABKHASIAN DZE → DIGIT THREE	# →Ʒ→
+16F3B ;	0033 ;	MA	# ( 𖼻 → 3 ) MIAO LETTER ZA → DIGIT THREE	# →Ʒ→
+118CA ;	0033 ;	MA	# ( 𑣊 → 3 ) WARANG CITI SMALL LETTER ANG → DIGIT THREE	# 
+
+06F3 ;	0663 ;	MA	# ( ۳ → ‎٣‎ ) EXTENDED ARABIC-INDIC DIGIT THREE → ARABIC-INDIC DIGIT THREE	# 
+1E8C9 ;	0663 ;	MA	#* ( ‎𞣉‎ → ‎٣‎ ) MENDE KIKAKUI DIGIT THREE → ARABIC-INDIC DIGIT THREE	# 
+
+2462 ;	2782 ;	MA	#* ( ③ → ➂ ) CIRCLED DIGIT THREE → DINGBAT CIRCLED SANS-SERIF DIGIT THREE	# 
+
+0498 ;	0033 0326 ;	MA	# ( Ҙ → 3̦ ) CYRILLIC CAPITAL LETTER ZE WITH DESCENDER → DIGIT THREE, COMBINING COMMA BELOW	# →З̧→
+
+1F104 ;	0033 002C ;	MA	#* ( 🄄 → 3, ) DIGIT THREE COMMA → DIGIT THREE, COMMA	# 
+
+248A ;	0033 002E ;	MA	#* ( ⒊ → 3. ) DIGIT THREE FULL STOP → DIGIT THREE, FULL STOP	# 
+
+33FE ;	0033 006C 65E5 ;	MA	#* ( ㏾ → 3l日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY-ONE → DIGIT THREE, LATIN SMALL LETTER L, CJK UNIFIED IDEOGRAPH-65E5	# →31日→
+
+33FD ;	0033 004F 65E5 ;	MA	#* ( ㏽ → 3O日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY → DIGIT THREE, LATIN CAPITAL LETTER O, CJK UNIFIED IDEOGRAPH-65E5	# →30日→
+
+33E2 ;	0033 65E5 ;	MA	#* ( ㏢ → 3日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THREE → DIGIT THREE, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+32C2 ;	0033 6708 ;	MA	#* ( ㋂ → 3月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR MARCH → DIGIT THREE, CJK UNIFIED IDEOGRAPH-6708	# 
+
+335B ;	0033 70B9 ;	MA	#* ( ㍛ → 3点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR THREE → DIGIT THREE, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+1CCF4 ;	0034 ;	MA	# ( 𜳴 → 4 ) OUTLINED DIGIT FOUR → DIGIT FOUR	# 
+1D7D2 ;	0034 ;	MA	# ( 𝟒 → 4 ) MATHEMATICAL BOLD DIGIT FOUR → DIGIT FOUR	# 
+1D7DC ;	0034 ;	MA	# ( 𝟜 → 4 ) MATHEMATICAL DOUBLE-STRUCK DIGIT FOUR → DIGIT FOUR	# 
+1D7E6 ;	0034 ;	MA	# ( 𝟦 → 4 ) MATHEMATICAL SANS-SERIF DIGIT FOUR → DIGIT FOUR	# 
+1D7F0 ;	0034 ;	MA	# ( 𝟰 → 4 ) MATHEMATICAL SANS-SERIF BOLD DIGIT FOUR → DIGIT FOUR	# 
+1D7FA ;	0034 ;	MA	# ( 𝟺 → 4 ) MATHEMATICAL MONOSPACE DIGIT FOUR → DIGIT FOUR	# 
+1FBF4 ;	0034 ;	MA	# ( 🯴 → 4 ) SEGMENTED DIGIT FOUR → DIGIT FOUR	# 
+13CE ;	0034 ;	MA	# ( Ꮞ → 4 ) CHEROKEE LETTER SE → DIGIT FOUR	# 
+118AF ;	0034 ;	MA	# ( 𑢯 → 4 ) WARANG CITI CAPITAL LETTER UC → DIGIT FOUR	# 
+
+06F4 ;	0664 ;	MA	# ( ۴ → ‎٤‎ ) EXTENDED ARABIC-INDIC DIGIT FOUR → ARABIC-INDIC DIGIT FOUR	# 
+
+0AEA ;	096A ;	MA	# ( ૪ → ४ ) GUJARATI DIGIT FOUR → DEVANAGARI DIGIT FOUR	# 
+
+2463 ;	2783 ;	MA	#* ( ④ → ➃ ) CIRCLED DIGIT FOUR → DINGBAT CIRCLED SANS-SERIF DIGIT FOUR	# 
+
+1F105 ;	0034 002C ;	MA	#* ( 🄅 → 4, ) DIGIT FOUR COMMA → DIGIT FOUR, COMMA	# 
+
+248B ;	0034 002E ;	MA	#* ( ⒋ → 4. ) DIGIT FOUR FULL STOP → DIGIT FOUR, FULL STOP	# 
+
+1530 ;	0034 00B7 ;	MA	# ( ᔰ → 4· ) CANADIAN SYLLABICS WEST-CREE YWE → DIGIT FOUR, MIDDLE DOT	# →4ᐧ→
+
+33E3 ;	0034 65E5 ;	MA	#* ( ㏣ → 4日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FOUR → DIGIT FOUR, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+32C3 ;	0034 6708 ;	MA	#* ( ㋃ → 4月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR APRIL → DIGIT FOUR, CJK UNIFIED IDEOGRAPH-6708	# 
+
+335C ;	0034 70B9 ;	MA	#* ( ㍜ → 4点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FOUR → DIGIT FOUR, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+1CCF5 ;	0035 ;	MA	# ( 𜳵 → 5 ) OUTLINED DIGIT FIVE → DIGIT FIVE	# 
+1D7D3 ;	0035 ;	MA	# ( 𝟓 → 5 ) MATHEMATICAL BOLD DIGIT FIVE → DIGIT FIVE	# 
+1D7DD ;	0035 ;	MA	# ( 𝟝 → 5 ) MATHEMATICAL DOUBLE-STRUCK DIGIT FIVE → DIGIT FIVE	# 
+1D7E7 ;	0035 ;	MA	# ( 𝟧 → 5 ) MATHEMATICAL SANS-SERIF DIGIT FIVE → DIGIT FIVE	# 
+1D7F1 ;	0035 ;	MA	# ( 𝟱 → 5 ) MATHEMATICAL SANS-SERIF BOLD DIGIT FIVE → DIGIT FIVE	# 
+1D7FB ;	0035 ;	MA	# ( 𝟻 → 5 ) MATHEMATICAL MONOSPACE DIGIT FIVE → DIGIT FIVE	# 
+1FBF5 ;	0035 ;	MA	# ( 🯵 → 5 ) SEGMENTED DIGIT FIVE → DIGIT FIVE	# 
+01BC ;	0035 ;	MA	# ( Ƽ → 5 ) LATIN CAPITAL LETTER TONE FIVE → DIGIT FIVE	# 
+118BB ;	0035 ;	MA	# ( 𑢻 → 5 ) WARANG CITI CAPITAL LETTER HORR → DIGIT FIVE	# 
+
+2464 ;	2784 ;	MA	#* ( ⑤ → ➄ ) CIRCLED DIGIT FIVE → DINGBAT CIRCLED SANS-SERIF DIGIT FIVE	# 
+
+1F106 ;	0035 002C ;	MA	#* ( 🄆 → 5, ) DIGIT FIVE COMMA → DIGIT FIVE, COMMA	# 
+
+248C ;	0035 002E ;	MA	#* ( ⒌ → 5. ) DIGIT FIVE FULL STOP → DIGIT FIVE, FULL STOP	# 
+
+33E4 ;	0035 65E5 ;	MA	#* ( ㏤ → 5日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FIVE → DIGIT FIVE, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+32C4 ;	0035 6708 ;	MA	#* ( ㋄ → 5月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR MAY → DIGIT FIVE, CJK UNIFIED IDEOGRAPH-6708	# 
+
+335D ;	0035 70B9 ;	MA	#* ( ㍝ → 5点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FIVE → DIGIT FIVE, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+1CCF6 ;	0036 ;	MA	# ( 𜳶 → 6 ) OUTLINED DIGIT SIX → DIGIT SIX	# 
+1D7D4 ;	0036 ;	MA	# ( 𝟔 → 6 ) MATHEMATICAL BOLD DIGIT SIX → DIGIT SIX	# 
+1D7DE ;	0036 ;	MA	# ( 𝟞 → 6 ) MATHEMATICAL DOUBLE-STRUCK DIGIT SIX → DIGIT SIX	# 
+1D7E8 ;	0036 ;	MA	# ( 𝟨 → 6 ) MATHEMATICAL SANS-SERIF DIGIT SIX → DIGIT SIX	# 
+1D7F2 ;	0036 ;	MA	# ( 𝟲 → 6 ) MATHEMATICAL SANS-SERIF BOLD DIGIT SIX → DIGIT SIX	# 
+1D7FC ;	0036 ;	MA	# ( 𝟼 → 6 ) MATHEMATICAL MONOSPACE DIGIT SIX → DIGIT SIX	# 
+1FBF6 ;	0036 ;	MA	# ( 🯶 → 6 ) SEGMENTED DIGIT SIX → DIGIT SIX	# 
+2CD3 ;	0036 ;	MA	# ( ⳓ → 6 ) COPTIC SMALL LETTER OLD COPTIC HEI → DIGIT SIX	# 
+2CD2 ;	0036 ;	MA	# ( Ⳓ → 6 ) COPTIC CAPITAL LETTER OLD COPTIC HEI → DIGIT SIX	# 
+03EC ;	0036 ;	MA	# ( Ϭ → 6 ) COPTIC CAPITAL LETTER SHIMA → DIGIT SIX	# 
+2CDC ;	0036 ;	MA	# ( Ⳝ → 6 ) COPTIC CAPITAL LETTER OLD NUBIAN SHIMA → DIGIT SIX	# →Ϭ→
+0431 ;	0036 ;	MA	# ( б → 6 ) CYRILLIC SMALL LETTER BE → DIGIT SIX	# 
+13EE ;	0036 ;	MA	# ( Ꮾ → 6 ) CHEROKEE LETTER WV → DIGIT SIX	# 
+118D5 ;	0036 ;	MA	# ( 𑣕 → 6 ) WARANG CITI SMALL LETTER AT → DIGIT SIX	# 
+
+06F6 ;	0666 ;	MA	# ( ۶ → ‎٦‎ ) EXTENDED ARABIC-INDIC DIGIT SIX → ARABIC-INDIC DIGIT SIX	# 
+
+114D6 ;	09EC ;	MA	# ( 𑓖 → ৬ ) TIRHUTA DIGIT SIX → BENGALI DIGIT SIX	# 
+
+2465 ;	2785 ;	MA	#* ( ⑥ → ➅ ) CIRCLED DIGIT SIX → DINGBAT CIRCLED SANS-SERIF DIGIT SIX	# 
+
+1F107 ;	0036 002C ;	MA	#* ( 🄇 → 6, ) DIGIT SIX COMMA → DIGIT SIX, COMMA	# 
+
+248D ;	0036 002E ;	MA	#* ( ⒍ → 6. ) DIGIT SIX FULL STOP → DIGIT SIX, FULL STOP	# 
+
+33E5 ;	0036 65E5 ;	MA	#* ( ㏥ → 6日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SIX → DIGIT SIX, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+32C5 ;	0036 6708 ;	MA	#* ( ㋅ → 6月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR JUNE → DIGIT SIX, CJK UNIFIED IDEOGRAPH-6708	# 
+
+335E ;	0036 70B9 ;	MA	#* ( ㍞ → 6点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SIX → DIGIT SIX, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+1D212 ;	0037 ;	MA	#* ( 𝈒 → 7 ) GREEK VOCAL NOTATION SYMBOL-19 → DIGIT SEVEN	# 
+1CCF7 ;	0037 ;	MA	# ( 𜳷 → 7 ) OUTLINED DIGIT SEVEN → DIGIT SEVEN	# 
+1D7D5 ;	0037 ;	MA	# ( 𝟕 → 7 ) MATHEMATICAL BOLD DIGIT SEVEN → DIGIT SEVEN	# 
+1D7DF ;	0037 ;	MA	# ( 𝟟 → 7 ) MATHEMATICAL DOUBLE-STRUCK DIGIT SEVEN → DIGIT SEVEN	# 
+1D7E9 ;	0037 ;	MA	# ( 𝟩 → 7 ) MATHEMATICAL SANS-SERIF DIGIT SEVEN → DIGIT SEVEN	# 
+1D7F3 ;	0037 ;	MA	# ( 𝟳 → 7 ) MATHEMATICAL SANS-SERIF BOLD DIGIT SEVEN → DIGIT SEVEN	# 
+1D7FD ;	0037 ;	MA	# ( 𝟽 → 7 ) MATHEMATICAL MONOSPACE DIGIT SEVEN → DIGIT SEVEN	# 
+1FBF7 ;	0037 ;	MA	# ( 🯷 → 7 ) SEGMENTED DIGIT SEVEN → DIGIT SEVEN	# 
+104D2 ;	0037 ;	MA	# ( 𐓒 → 7 ) OSAGE CAPITAL LETTER ZA → DIGIT SEVEN	# 
+118C6 ;	0037 ;	MA	# ( 𑣆 → 7 ) WARANG CITI SMALL LETTER II → DIGIT SEVEN	# 
+
+2466 ;	2786 ;	MA	#* ( ⑦ → ➆ ) CIRCLED DIGIT SEVEN → DINGBAT CIRCLED SANS-SERIF DIGIT SEVEN	# 
+
+1F108 ;	0037 002C ;	MA	#* ( 🄈 → 7, ) DIGIT SEVEN COMMA → DIGIT SEVEN, COMMA	# 
+
+248E ;	0037 002E ;	MA	#* ( ⒎ → 7. ) DIGIT SEVEN FULL STOP → DIGIT SEVEN, FULL STOP	# 
+
+33E6 ;	0037 65E5 ;	MA	#* ( ㏦ → 7日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SEVEN → DIGIT SEVEN, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+32C6 ;	0037 6708 ;	MA	#* ( ㋆ → 7月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR JULY → DIGIT SEVEN, CJK UNIFIED IDEOGRAPH-6708	# 
+
+335F ;	0037 70B9 ;	MA	#* ( ㍟ → 7点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SEVEN → DIGIT SEVEN, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+0B03 ;	0038 ;	MA	# ( ଃ → 8 ) ORIYA SIGN VISARGA → DIGIT EIGHT	# 
+09EA ;	0038 ;	MA	# ( ৪ → 8 ) BENGALI DIGIT FOUR → DIGIT EIGHT	# 
+0A6A ;	0038 ;	MA	# ( ੪ → 8 ) GURMUKHI DIGIT FOUR → DIGIT EIGHT	# 
+1E8CB ;	0038 ;	MA	#* ( ‎𞣋‎ → 8 ) MENDE KIKAKUI DIGIT FIVE → DIGIT EIGHT	# 
+1CCF8 ;	0038 ;	MA	# ( 𜳸 → 8 ) OUTLINED DIGIT EIGHT → DIGIT EIGHT	# 
+1D7D6 ;	0038 ;	MA	# ( 𝟖 → 8 ) MATHEMATICAL BOLD DIGIT EIGHT → DIGIT EIGHT	# 
+1D7E0 ;	0038 ;	MA	# ( 𝟠 → 8 ) MATHEMATICAL DOUBLE-STRUCK DIGIT EIGHT → DIGIT EIGHT	# 
+1D7EA ;	0038 ;	MA	# ( 𝟪 → 8 ) MATHEMATICAL SANS-SERIF DIGIT EIGHT → DIGIT EIGHT	# 
+1D7F4 ;	0038 ;	MA	# ( 𝟴 → 8 ) MATHEMATICAL SANS-SERIF BOLD DIGIT EIGHT → DIGIT EIGHT	# 
+1D7FE ;	0038 ;	MA	# ( 𝟾 → 8 ) MATHEMATICAL MONOSPACE DIGIT EIGHT → DIGIT EIGHT	# 
+1FBF8 ;	0038 ;	MA	# ( 🯸 → 8 ) SEGMENTED DIGIT EIGHT → DIGIT EIGHT	# 
+0223 ;	0038 ;	MA	# ( ȣ → 8 ) LATIN SMALL LETTER OU → DIGIT EIGHT	# 
+0222 ;	0038 ;	MA	# ( Ȣ → 8 ) LATIN CAPITAL LETTER OU → DIGIT EIGHT	# 
+1031A ;	0038 ;	MA	# ( 𐌚 → 8 ) OLD ITALIC LETTER EF → DIGIT EIGHT	# 
+
+0AEE ;	096E ;	MA	# ( ૮ → ८ ) GUJARATI DIGIT EIGHT → DEVANAGARI DIGIT EIGHT	# 
+
+2467 ;	2787 ;	MA	#* ( ⑧ → ➇ ) CIRCLED DIGIT EIGHT → DINGBAT CIRCLED SANS-SERIF DIGIT EIGHT	# 
+
+1F109 ;	0038 002C ;	MA	#* ( 🄉 → 8, ) DIGIT EIGHT COMMA → DIGIT EIGHT, COMMA	# 
+
+248F ;	0038 002E ;	MA	#* ( ⒏ → 8. ) DIGIT EIGHT FULL STOP → DIGIT EIGHT, FULL STOP	# 
+
+33E7 ;	0038 65E5 ;	MA	#* ( ㏧ → 8日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY EIGHT → DIGIT EIGHT, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+32C7 ;	0038 6708 ;	MA	#* ( ㋇ → 8月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR AUGUST → DIGIT EIGHT, CJK UNIFIED IDEOGRAPH-6708	# 
+
+3360 ;	0038 70B9 ;	MA	#* ( ㍠ → 8点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR EIGHT → DIGIT EIGHT, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+0A67 ;	0039 ;	MA	# ( ੧ → 9 ) GURMUKHI DIGIT ONE → DIGIT NINE	# 
+0B68 ;	0039 ;	MA	# ( ୨ → 9 ) ORIYA DIGIT TWO → DIGIT NINE	# 
+09ED ;	0039 ;	MA	# ( ৭ → 9 ) BENGALI DIGIT SEVEN → DIGIT NINE	# 
+0D6D ;	0039 ;	MA	# ( ൭ → 9 ) MALAYALAM DIGIT SEVEN → DIGIT NINE	# 
+1CCF9 ;	0039 ;	MA	# ( 𜳹 → 9 ) OUTLINED DIGIT NINE → DIGIT NINE	# 
+1D7D7 ;	0039 ;	MA	# ( 𝟗 → 9 ) MATHEMATICAL BOLD DIGIT NINE → DIGIT NINE	# 
+1D7E1 ;	0039 ;	MA	# ( 𝟡 → 9 ) MATHEMATICAL DOUBLE-STRUCK DIGIT NINE → DIGIT NINE	# 
+1D7EB ;	0039 ;	MA	# ( 𝟫 → 9 ) MATHEMATICAL SANS-SERIF DIGIT NINE → DIGIT NINE	# 
+1D7F5 ;	0039 ;	MA	# ( 𝟵 → 9 ) MATHEMATICAL SANS-SERIF BOLD DIGIT NINE → DIGIT NINE	# 
+1D7FF ;	0039 ;	MA	# ( 𝟿 → 9 ) MATHEMATICAL MONOSPACE DIGIT NINE → DIGIT NINE	# 
+1FBF9 ;	0039 ;	MA	# ( 🯹 → 9 ) SEGMENTED DIGIT NINE → DIGIT NINE	# 
+A76E ;	0039 ;	MA	# ( Ꝯ → 9 ) LATIN CAPITAL LETTER CON → DIGIT NINE	# 
+2CCB ;	0039 ;	MA	# ( ⳋ → 9 ) COPTIC SMALL LETTER DIALECT-P HORI → DIGIT NINE	# 
+2CCA ;	0039 ;	MA	# ( Ⳋ → 9 ) COPTIC CAPITAL LETTER DIALECT-P HORI → DIGIT NINE	# 
+118CC ;	0039 ;	MA	# ( 𑣌 → 9 ) WARANG CITI SMALL LETTER KO → DIGIT NINE	# 
+118AC ;	0039 ;	MA	# ( 𑢬 → 9 ) WARANG CITI CAPITAL LETTER KO → DIGIT NINE	# 
+118D6 ;	0039 ;	MA	# ( 𑣖 → 9 ) WARANG CITI SMALL LETTER AM → DIGIT NINE	# 
+
+0967 ;	0669 ;	MA	# ( १ → ‎٩‎ ) DEVANAGARI DIGIT ONE → ARABIC-INDIC DIGIT NINE	# 
+118E4 ;	0669 ;	MA	# ( 𑣤 → ‎٩‎ ) WARANG CITI DIGIT FOUR → ARABIC-INDIC DIGIT NINE	# 
+06F9 ;	0669 ;	MA	# ( ۹ → ‎٩‎ ) EXTENDED ARABIC-INDIC DIGIT NINE → ARABIC-INDIC DIGIT NINE	# 
+
+0CEF ;	0C6F ;	MA	# ( ೯ → ౯ ) KANNADA DIGIT NINE → TELUGU DIGIT NINE	# 
+
+2468 ;	2788 ;	MA	#* ( ⑨ → ➈ ) CIRCLED DIGIT NINE → DINGBAT CIRCLED SANS-SERIF DIGIT NINE	# 
+
+1F10A ;	0039 002C ;	MA	#* ( 🄊 → 9, ) DIGIT NINE COMMA → DIGIT NINE, COMMA	# 
+
+2490 ;	0039 002E ;	MA	#* ( ⒐ → 9. ) DIGIT NINE FULL STOP → DIGIT NINE, FULL STOP	# 
+
+33E8 ;	0039 65E5 ;	MA	#* ( ㏨ → 9日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY NINE → DIGIT NINE, CJK UNIFIED IDEOGRAPH-65E5	# 
+
+32C8 ;	0039 6708 ;	MA	#* ( ㋈ → 9月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR SEPTEMBER → DIGIT NINE, CJK UNIFIED IDEOGRAPH-6708	# 
+
+3361 ;	0039 70B9 ;	MA	#* ( ㍡ → 9点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR NINE → DIGIT NINE, CJK UNIFIED IDEOGRAPH-70B9	# 
+
+237A ;	0061 ;	MA	#* ( ⍺ → a ) APL FUNCTIONAL SYMBOL ALPHA → LATIN SMALL LETTER A	# →α→
+FF41 ;	0061 ;	MA	# ( ａ → a ) FULLWIDTH LATIN SMALL LETTER A → LATIN SMALL LETTER A	# →а→
+1D41A ;	0061 ;	MA	# ( 𝐚 → a ) MATHEMATICAL BOLD SMALL A → LATIN SMALL LETTER A	# 
+1D44E ;	0061 ;	MA	# ( 𝑎 → a ) MATHEMATICAL ITALIC SMALL A → LATIN SMALL LETTER A	# 
+1D482 ;	0061 ;	MA	# ( 𝒂 → a ) MATHEMATICAL BOLD ITALIC SMALL A → LATIN SMALL LETTER A	# 
+1D4B6 ;	0061 ;	MA	# ( 𝒶 → a ) MATHEMATICAL SCRIPT SMALL A → LATIN SMALL LETTER A	# 
+1D4EA ;	0061 ;	MA	# ( 𝓪 → a ) MATHEMATICAL BOLD SCRIPT SMALL A → LATIN SMALL LETTER A	# 
+1D51E ;	0061 ;	MA	# ( 𝔞 → a ) MATHEMATICAL FRAKTUR SMALL A → LATIN SMALL LETTER A	# 
+1D552 ;	0061 ;	MA	# ( 𝕒 → a ) MATHEMATICAL DOUBLE-STRUCK SMALL A → LATIN SMALL LETTER A	# 
+1D586 ;	0061 ;	MA	# ( 𝖆 → a ) MATHEMATICAL BOLD FRAKTUR SMALL A → LATIN SMALL LETTER A	# 
+1D5BA ;	0061 ;	MA	# ( 𝖺 → a ) MATHEMATICAL SANS-SERIF SMALL A → LATIN SMALL LETTER A	# 
+1D5EE ;	0061 ;	MA	# ( 𝗮 → a ) MATHEMATICAL SANS-SERIF BOLD SMALL A → LATIN SMALL LETTER A	# 
+1D622 ;	0061 ;	MA	# ( 𝘢 → a ) MATHEMATICAL SANS-SERIF ITALIC SMALL A → LATIN SMALL LETTER A	# 
+1D656 ;	0061 ;	MA	# ( 𝙖 → a ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL A → LATIN SMALL LETTER A	# 
+1D68A ;	0061 ;	MA	# ( 𝚊 → a ) MATHEMATICAL MONOSPACE SMALL A → LATIN SMALL LETTER A	# 
+0251 ;	0061 ;	MA	# ( ɑ → a ) LATIN SMALL LETTER ALPHA → LATIN SMALL LETTER A	# 
+03B1 ;	0061 ;	MA	# ( α → a ) GREEK SMALL LETTER ALPHA → LATIN SMALL LETTER A	# 
+1D6C2 ;	0061 ;	MA	# ( 𝛂 → a ) MATHEMATICAL BOLD SMALL ALPHA → LATIN SMALL LETTER A	# →α→
+1D6FC ;	0061 ;	MA	# ( 𝛼 → a ) MATHEMATICAL ITALIC SMALL ALPHA → LATIN SMALL LETTER A	# →α→
+1D736 ;	0061 ;	MA	# ( 𝜶 → a ) MATHEMATICAL BOLD ITALIC SMALL ALPHA → LATIN SMALL LETTER A	# →α→
+1D770 ;	0061 ;	MA	# ( 𝝰 → a ) MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA → LATIN SMALL LETTER A	# →α→
+1D7AA ;	0061 ;	MA	# ( 𝞪 → a ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA → LATIN SMALL LETTER A	# →α→
+0430 ;	0061 ;	MA	# ( а → a ) CYRILLIC SMALL LETTER A → LATIN SMALL LETTER A	# 
+
+2DF6 ;	0363 ;	MA	# ( ⷶ → ͣ ) COMBINING CYRILLIC LETTER A → COMBINING LATIN SMALL LETTER A	# 
+
+FF21 ;	0041 ;	MA	# ( Ａ → A ) FULLWIDTH LATIN CAPITAL LETTER A → LATIN CAPITAL LETTER A	# →А→
+1CCD6 ;	0041 ;	MA	#* ( 𜳖 → A ) OUTLINED LATIN CAPITAL LETTER A → LATIN CAPITAL LETTER A	# 
+1D400 ;	0041 ;	MA	# ( 𝐀 → A ) MATHEMATICAL BOLD CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D434 ;	0041 ;	MA	# ( 𝐴 → A ) MATHEMATICAL ITALIC CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D468 ;	0041 ;	MA	# ( 𝑨 → A ) MATHEMATICAL BOLD ITALIC CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D49C ;	0041 ;	MA	# ( 𝒜 → A ) MATHEMATICAL SCRIPT CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D4D0 ;	0041 ;	MA	# ( 𝓐 → A ) MATHEMATICAL BOLD SCRIPT CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D504 ;	0041 ;	MA	# ( 𝔄 → A ) MATHEMATICAL FRAKTUR CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D538 ;	0041 ;	MA	# ( 𝔸 → A ) MATHEMATICAL DOUBLE-STRUCK CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D56C ;	0041 ;	MA	# ( 𝕬 → A ) MATHEMATICAL BOLD FRAKTUR CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D5A0 ;	0041 ;	MA	# ( 𝖠 → A ) MATHEMATICAL SANS-SERIF CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D5D4 ;	0041 ;	MA	# ( 𝗔 → A ) MATHEMATICAL SANS-SERIF BOLD CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D608 ;	0041 ;	MA	# ( 𝘈 → A ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D63C ;	0041 ;	MA	# ( 𝘼 → A ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL A → LATIN CAPITAL LETTER A	# 
+1D670 ;	0041 ;	MA	# ( 𝙰 → A ) MATHEMATICAL MONOSPACE CAPITAL A → LATIN CAPITAL LETTER A	# 
+0391 ;	0041 ;	MA	# ( Α → A ) GREEK CAPITAL LETTER ALPHA → LATIN CAPITAL LETTER A	# 
+1D6A8 ;	0041 ;	MA	# ( 𝚨 → A ) MATHEMATICAL BOLD CAPITAL ALPHA → LATIN CAPITAL LETTER A	# →𝐀→
+1D6E2 ;	0041 ;	MA	# ( 𝛢 → A ) MATHEMATICAL ITALIC CAPITAL ALPHA → LATIN CAPITAL LETTER A	# →Α→
+1D71C ;	0041 ;	MA	# ( 𝜜 → A ) MATHEMATICAL BOLD ITALIC CAPITAL ALPHA → LATIN CAPITAL LETTER A	# →Α→
+1D756 ;	0041 ;	MA	# ( 𝝖 → A ) MATHEMATICAL SANS-SERIF BOLD CAPITAL ALPHA → LATIN CAPITAL LETTER A	# →Α→
+1D790 ;	0041 ;	MA	# ( 𝞐 → A ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ALPHA → LATIN CAPITAL LETTER A	# →Α→
+0410 ;	0041 ;	MA	# ( А → A ) CYRILLIC CAPITAL LETTER A → LATIN CAPITAL LETTER A	# 
+13AA ;	0041 ;	MA	# ( Ꭺ → A ) CHEROKEE LETTER GO → LATIN CAPITAL LETTER A	# 
+15C5 ;	0041 ;	MA	# ( ᗅ → A ) CANADIAN SYLLABICS CARRIER GHO → LATIN CAPITAL LETTER A	# 
+A4EE ;	0041 ;	MA	# ( ꓮ → A ) LISU LETTER A → LATIN CAPITAL LETTER A	# 
+16F40 ;	0041 ;	MA	# ( 𖽀 → A ) MIAO LETTER ZZYA → LATIN CAPITAL LETTER A	# 
+102A0 ;	0041 ;	MA	# ( 𐊠 → A ) CARIAN LETTER A → LATIN CAPITAL LETTER A	# 
+
+2376 ;	0061 0332 ;	MA	#* ( ⍶ → a̲ ) APL FUNCTIONAL SYMBOL ALPHA UNDERBAR → LATIN SMALL LETTER A, COMBINING LOW LINE	# →α̲→→ɑ̲→
+
+01CE ;	0103 ;	MA	# ( ǎ → ă ) LATIN SMALL LETTER A WITH CARON → LATIN SMALL LETTER A WITH BREVE	# 
+
+01CD ;	0102 ;	MA	# ( Ǎ → Ă ) LATIN CAPITAL LETTER A WITH CARON → LATIN CAPITAL LETTER A WITH BREVE	# 
+
+0227 ;	00E5 ;	MA	# ( ȧ → å ) LATIN SMALL LETTER A WITH DOT ABOVE → LATIN SMALL LETTER A WITH RING ABOVE	# 
+
+0226 ;	00C5 ;	MA	# ( Ȧ → Å ) LATIN CAPITAL LETTER A WITH DOT ABOVE → LATIN CAPITAL LETTER A WITH RING ABOVE	# 
+
+1E9A ;	1EA3 ;	MA	# ( ẚ → ả ) LATIN SMALL LETTER A WITH RIGHT HALF RING → LATIN SMALL LETTER A WITH HOOK ABOVE	# 
+
+2100 ;	0061 002F 0063 ;	MA	#* ( ℀ → a/c ) ACCOUNT OF → LATIN SMALL LETTER A, SOLIDUS, LATIN SMALL LETTER C	# 
+
+2101 ;	0061 002F 0073 ;	MA	#* ( ℁ → a/s ) ADDRESSED TO THE SUBJECT → LATIN SMALL LETTER A, SOLIDUS, LATIN SMALL LETTER S	# 
+
+A733 ;	0061 0061 ;	MA	# ( ꜳ → aa ) LATIN SMALL LETTER AA → LATIN SMALL LETTER A, LATIN SMALL LETTER A	# 
+
+A732 ;	0041 0041 ;	MA	# ( Ꜳ → AA ) LATIN CAPITAL LETTER AA → LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER A	# 
+
+00E6 ;	0061 0065 ;	MA	# ( æ → ae ) LATIN SMALL LETTER AE → LATIN SMALL LETTER A, LATIN SMALL LETTER E	# 
+04D5 ;	0061 0065 ;	MA	# ( ӕ → ae ) CYRILLIC SMALL LIGATURE A IE → LATIN SMALL LETTER A, LATIN SMALL LETTER E	# →ае→
+
+00C6 ;	0041 0045 ;	MA	# ( Æ → AE ) LATIN CAPITAL LETTER AE → LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER E	# 
+04D4 ;	0041 0045 ;	MA	# ( Ӕ → AE ) CYRILLIC CAPITAL LIGATURE A IE → LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER E	# →Æ→
+
+A735 ;	0061 006F ;	MA	# ( ꜵ → ao ) LATIN SMALL LETTER AO → LATIN SMALL LETTER A, LATIN SMALL LETTER O	# 
+
+A734 ;	0041 004F ;	MA	# ( Ꜵ → AO ) LATIN CAPITAL LETTER AO → LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER O	# 
+
+1F707 ;	0041 0052 ;	MA	#* ( 🜇 → AR ) ALCHEMICAL SYMBOL FOR AQUA REGIA-2 → LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER R	# 
+
+A737 ;	0061 0075 ;	MA	# ( ꜷ → au ) LATIN SMALL LETTER AU → LATIN SMALL LETTER A, LATIN SMALL LETTER U	# 
+
+A736 ;	0041 0055 ;	MA	# ( Ꜷ → AU ) LATIN CAPITAL LETTER AU → LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER U	# 
+
+A739 ;	0061 0076 ;	MA	# ( ꜹ → av ) LATIN SMALL LETTER AV → LATIN SMALL LETTER A, LATIN SMALL LETTER V	# 
+A73B ;	0061 0076 ;	MA	# ( ꜻ → av ) LATIN SMALL LETTER AV WITH HORIZONTAL BAR → LATIN SMALL LETTER A, LATIN SMALL LETTER V	# 
+
+A738 ;	0041 0056 ;	MA	# ( Ꜹ → AV ) LATIN CAPITAL LETTER AV → LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER V	# 
+A73A ;	0041 0056 ;	MA	# ( Ꜻ → AV ) LATIN CAPITAL LETTER AV WITH HORIZONTAL BAR → LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER V	# 
+
+A73D ;	0061 0079 ;	MA	# ( ꜽ → ay ) LATIN SMALL LETTER AY → LATIN SMALL LETTER A, LATIN SMALL LETTER Y	# 
+
+A73C ;	0041 0059 ;	MA	# ( Ꜽ → AY ) LATIN CAPITAL LETTER AY → LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER Y	# 
+
+AB7A ;	1D00 ;	MA	# ( ꭺ → ᴀ ) CHEROKEE SMALL LETTER GO → LATIN LETTER SMALL CAPITAL A	# 
+
+2200 ;	2C6F ;	MA	#* ( ∀ → Ɐ ) FOR ALL → LATIN CAPITAL LETTER TURNED A	# 
+1D217 ;	2C6F ;	MA	#* ( 𝈗 → Ɐ ) GREEK VOCAL NOTATION SYMBOL-24 → LATIN CAPITAL LETTER TURNED A	# 
+15C4 ;	2C6F ;	MA	# ( ᗄ → Ɐ ) CANADIAN SYLLABICS CARRIER GHU → LATIN CAPITAL LETTER TURNED A	# →∀→
+A4EF ;	2C6F ;	MA	# ( ꓯ → Ɐ ) LISU LETTER AE → LATIN CAPITAL LETTER TURNED A	# 
+
+1041F ;	2C70 ;	MA	# ( 𐐟 → Ɒ ) DESERET CAPITAL LETTER ESH → LATIN CAPITAL LETTER TURNED ALPHA	# 
+
+1D41B ;	0062 ;	MA	# ( 𝐛 → b ) MATHEMATICAL BOLD SMALL B → LATIN SMALL LETTER B	# 
+1D44F ;	0062 ;	MA	# ( 𝑏 → b ) MATHEMATICAL ITALIC SMALL B → LATIN SMALL LETTER B	# 
+1D483 ;	0062 ;	MA	# ( 𝒃 → b ) MATHEMATICAL BOLD ITALIC SMALL B → LATIN SMALL LETTER B	# 
+1D4B7 ;	0062 ;	MA	# ( 𝒷 → b ) MATHEMATICAL SCRIPT SMALL B → LATIN SMALL LETTER B	# 
+1D4EB ;	0062 ;	MA	# ( 𝓫 → b ) MATHEMATICAL BOLD SCRIPT SMALL B → LATIN SMALL LETTER B	# 
+1D51F ;	0062 ;	MA	# ( 𝔟 → b ) MATHEMATICAL FRAKTUR SMALL B → LATIN SMALL LETTER B	# 
+1D553 ;	0062 ;	MA	# ( 𝕓 → b ) MATHEMATICAL DOUBLE-STRUCK SMALL B → LATIN SMALL LETTER B	# 
+1D587 ;	0062 ;	MA	# ( 𝖇 → b ) MATHEMATICAL BOLD FRAKTUR SMALL B → LATIN SMALL LETTER B	# 
+1D5BB ;	0062 ;	MA	# ( 𝖻 → b ) MATHEMATICAL SANS-SERIF SMALL B → LATIN SMALL LETTER B	# 
+1D5EF ;	0062 ;	MA	# ( 𝗯 → b ) MATHEMATICAL SANS-SERIF BOLD SMALL B → LATIN SMALL LETTER B	# 
+1D623 ;	0062 ;	MA	# ( 𝘣 → b ) MATHEMATICAL SANS-SERIF ITALIC SMALL B → LATIN SMALL LETTER B	# 
+1D657 ;	0062 ;	MA	# ( 𝙗 → b ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL B → LATIN SMALL LETTER B	# 
+1D68B ;	0062 ;	MA	# ( 𝚋 → b ) MATHEMATICAL MONOSPACE SMALL B → LATIN SMALL LETTER B	# 
+0184 ;	0062 ;	MA	# ( Ƅ → b ) LATIN CAPITAL LETTER TONE SIX → LATIN SMALL LETTER B	# 
+042C ;	0062 ;	MA	# ( Ь → b ) CYRILLIC CAPITAL LETTER SOFT SIGN → LATIN SMALL LETTER B	# →Ƅ→
+13CF ;	0062 ;	MA	# ( Ꮟ → b ) CHEROKEE LETTER SI → LATIN SMALL LETTER B	# 
+1472 ;	0062 ;	MA	# ( ᑲ → b ) CANADIAN SYLLABICS KA → LATIN SMALL LETTER B	# 
+15AF ;	0062 ;	MA	# ( ᖯ → b ) CANADIAN SYLLABICS AIVILIK B → LATIN SMALL LETTER B	# 
+16EB6 ;	0062 ;	MA	# ( 𖺶 → b ) BERIA ERFE CAPITAL LETTER UI → LATIN SMALL LETTER B	# →Ь→→Ƅ→
+
+FF22 ;	0042 ;	MA	# ( Ｂ → B ) FULLWIDTH LATIN CAPITAL LETTER B → LATIN CAPITAL LETTER B	# →Β→
+212C ;	0042 ;	MA	# ( ℬ → B ) SCRIPT CAPITAL B → LATIN CAPITAL LETTER B	# 
+1CCD7 ;	0042 ;	MA	#* ( 𜳗 → B ) OUTLINED LATIN CAPITAL LETTER B → LATIN CAPITAL LETTER B	# 
+1D401 ;	0042 ;	MA	# ( 𝐁 → B ) MATHEMATICAL BOLD CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D435 ;	0042 ;	MA	# ( 𝐵 → B ) MATHEMATICAL ITALIC CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D469 ;	0042 ;	MA	# ( 𝑩 → B ) MATHEMATICAL BOLD ITALIC CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D4D1 ;	0042 ;	MA	# ( 𝓑 → B ) MATHEMATICAL BOLD SCRIPT CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D505 ;	0042 ;	MA	# ( 𝔅 → B ) MATHEMATICAL FRAKTUR CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D539 ;	0042 ;	MA	# ( 𝔹 → B ) MATHEMATICAL DOUBLE-STRUCK CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D56D ;	0042 ;	MA	# ( 𝕭 → B ) MATHEMATICAL BOLD FRAKTUR CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D5A1 ;	0042 ;	MA	# ( 𝖡 → B ) MATHEMATICAL SANS-SERIF CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D5D5 ;	0042 ;	MA	# ( 𝗕 → B ) MATHEMATICAL SANS-SERIF BOLD CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D609 ;	0042 ;	MA	# ( 𝘉 → B ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D63D ;	0042 ;	MA	# ( 𝘽 → B ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL B → LATIN CAPITAL LETTER B	# 
+1D671 ;	0042 ;	MA	# ( 𝙱 → B ) MATHEMATICAL MONOSPACE CAPITAL B → LATIN CAPITAL LETTER B	# 
+A7B4 ;	0042 ;	MA	# ( Ꞵ → B ) LATIN CAPITAL LETTER BETA → LATIN CAPITAL LETTER B	# 
+0392 ;	0042 ;	MA	# ( Β → B ) GREEK CAPITAL LETTER BETA → LATIN CAPITAL LETTER B	# 
+1D6A9 ;	0042 ;	MA	# ( 𝚩 → B ) MATHEMATICAL BOLD CAPITAL BETA → LATIN CAPITAL LETTER B	# →Β→
+1D6E3 ;	0042 ;	MA	# ( 𝛣 → B ) MATHEMATICAL ITALIC CAPITAL BETA → LATIN CAPITAL LETTER B	# →Β→
+1D71D ;	0042 ;	MA	# ( 𝜝 → B ) MATHEMATICAL BOLD ITALIC CAPITAL BETA → LATIN CAPITAL LETTER B	# →Β→
+1D757 ;	0042 ;	MA	# ( 𝝗 → B ) MATHEMATICAL SANS-SERIF BOLD CAPITAL BETA → LATIN CAPITAL LETTER B	# →Β→
+1D791 ;	0042 ;	MA	# ( 𝞑 → B ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL BETA → LATIN CAPITAL LETTER B	# →Β→
+2C82 ;	0042 ;	MA	# ( Ⲃ → B ) COPTIC CAPITAL LETTER VIDA → LATIN CAPITAL LETTER B	# 
+0412 ;	0042 ;	MA	# ( В → B ) CYRILLIC CAPITAL LETTER VE → LATIN CAPITAL LETTER B	# 
+13F4 ;	0042 ;	MA	# ( Ᏼ → B ) CHEROKEE LETTER YV → LATIN CAPITAL LETTER B	# 
+15F7 ;	0042 ;	MA	# ( ᗷ → B ) CANADIAN SYLLABICS CARRIER KHE → LATIN CAPITAL LETTER B	# 
+A4D0 ;	0042 ;	MA	# ( ꓐ → B ) LISU LETTER BA → LATIN CAPITAL LETTER B	# 
+10282 ;	0042 ;	MA	# ( 𐊂 → B ) LYCIAN LETTER B → LATIN CAPITAL LETTER B	# 
+102A1 ;	0042 ;	MA	# ( 𐊡 → B ) CARIAN LETTER P2 → LATIN CAPITAL LETTER B	# 
+10301 ;	0042 ;	MA	# ( 𐌁 → B ) OLD ITALIC LETTER BE → LATIN CAPITAL LETTER B	# 
+
+0253 ;	0062 0314 ;	MA	# ( ɓ → b̔ ) LATIN SMALL LETTER B WITH HOOK → LATIN SMALL LETTER B, COMBINING REVERSED COMMA ABOVE	# 
+
+1473 ;	0062 0307 ;	MA	# ( ᑳ → ḃ ) CANADIAN SYLLABICS KAA → LATIN SMALL LETTER B, COMBINING DOT ABOVE	# 
+
+0183 ;	0062 0304 ;	MA	# ( ƃ → b̄ ) LATIN SMALL LETTER B WITH TOPBAR → LATIN SMALL LETTER B, COMBINING MACRON	# 
+0182 ;	0062 0304 ;	MA	# ( Ƃ → b̄ ) LATIN CAPITAL LETTER B WITH TOPBAR → LATIN SMALL LETTER B, COMBINING MACRON	# 
+0411 ;	0062 0304 ;	MA	# ( Б → b̄ ) CYRILLIC CAPITAL LETTER BE → LATIN SMALL LETTER B, COMBINING MACRON	# →Ƃ→
+
+0180 ;	0062 0335 ;	MA	# ( ƀ → b̵ ) LATIN SMALL LETTER B WITH STROKE → LATIN SMALL LETTER B, COMBINING SHORT STROKE OVERLAY	# 
+048D ;	0062 0335 ;	MA	# ( ҍ → b̵ ) CYRILLIC SMALL LETTER SEMISOFT SIGN → LATIN SMALL LETTER B, COMBINING SHORT STROKE OVERLAY	# →ѣ→→Ь̵→
+048C ;	0062 0335 ;	MA	# ( Ҍ → b̵ ) CYRILLIC CAPITAL LETTER SEMISOFT SIGN → LATIN SMALL LETTER B, COMBINING SHORT STROKE OVERLAY	# →Ѣ→→Ь̵→
+0463 ;	0062 0335 ;	MA	# ( ѣ → b̵ ) CYRILLIC SMALL LETTER YAT → LATIN SMALL LETTER B, COMBINING SHORT STROKE OVERLAY	# →Ь̵→
+0462 ;	0062 0335 ;	MA	# ( Ѣ → b̵ ) CYRILLIC CAPITAL LETTER YAT → LATIN SMALL LETTER B, COMBINING SHORT STROKE OVERLAY	# →Ь̵→
+
+147F ;	0062 00B7 ;	MA	# ( ᑿ → b· ) CANADIAN SYLLABICS WEST-CREE KWA → LATIN SMALL LETTER B, MIDDLE DOT	# →ᑲᐧ→
+
+1481 ;	0062 0307 00B7 ;	MA	# ( ᒁ → ḃ· ) CANADIAN SYLLABICS WEST-CREE KWAA → LATIN SMALL LETTER B, COMBINING DOT ABOVE, MIDDLE DOT	# →ᑳᐧ→
+
+1488 ;	0062 0027 ;	MA	# ( ᒈ → b' ) CANADIAN SYLLABICS SOUTH-SLAVEY KAH → LATIN SMALL LETTER B, APOSTROPHE	# →ᑲᑊ→
+
+042B ;	0062 006C ;	MA	# ( Ы → bl ) CYRILLIC CAPITAL LETTER YERU → LATIN SMALL LETTER B, LATIN SMALL LETTER L	# →ЬІ→→Ь1→
+
+2C83 ;	0299 ;	MA	# ( ⲃ → ʙ ) COPTIC SMALL LETTER VIDA → LATIN LETTER SMALL CAPITAL B	# →в→
+0432 ;	0299 ;	MA	# ( в → ʙ ) CYRILLIC SMALL LETTER VE → LATIN LETTER SMALL CAPITAL B	# 
+13FC ;	0299 ;	MA	# ( ᏼ → ʙ ) CHEROKEE SMALL LETTER YV → LATIN LETTER SMALL CAPITAL B	# 
+
+FF43 ;	0063 ;	MA	# ( ｃ → c ) FULLWIDTH LATIN SMALL LETTER C → LATIN SMALL LETTER C	# →с→
+217D ;	0063 ;	MA	# ( ⅽ → c ) SMALL ROMAN NUMERAL ONE HUNDRED → LATIN SMALL LETTER C	# 
+1D41C ;	0063 ;	MA	# ( 𝐜 → c ) MATHEMATICAL BOLD SMALL C → LATIN SMALL LETTER C	# 
+1D450 ;	0063 ;	MA	# ( 𝑐 → c ) MATHEMATICAL ITALIC SMALL C → LATIN SMALL LETTER C	# 
+1D484 ;	0063 ;	MA	# ( 𝒄 → c ) MATHEMATICAL BOLD ITALIC SMALL C → LATIN SMALL LETTER C	# 
+1D4B8 ;	0063 ;	MA	# ( 𝒸 → c ) MATHEMATICAL SCRIPT SMALL C → LATIN SMALL LETTER C	# 
+1D4EC ;	0063 ;	MA	# ( 𝓬 → c ) MATHEMATICAL BOLD SCRIPT SMALL C → LATIN SMALL LETTER C	# 
+1D520 ;	0063 ;	MA	# ( 𝔠 → c ) MATHEMATICAL FRAKTUR SMALL C → LATIN SMALL LETTER C	# 
+1D554 ;	0063 ;	MA	# ( 𝕔 → c ) MATHEMATICAL DOUBLE-STRUCK SMALL C → LATIN SMALL LETTER C	# 
+1D588 ;	0063 ;	MA	# ( 𝖈 → c ) MATHEMATICAL BOLD FRAKTUR SMALL C → LATIN SMALL LETTER C	# 
+1D5BC ;	0063 ;	MA	# ( 𝖼 → c ) MATHEMATICAL SANS-SERIF SMALL C → LATIN SMALL LETTER C	# 
+1D5F0 ;	0063 ;	MA	# ( 𝗰 → c ) MATHEMATICAL SANS-SERIF BOLD SMALL C → LATIN SMALL LETTER C	# 
+1D624 ;	0063 ;	MA	# ( 𝘤 → c ) MATHEMATICAL SANS-SERIF ITALIC SMALL C → LATIN SMALL LETTER C	# 
+1D658 ;	0063 ;	MA	# ( 𝙘 → c ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL C → LATIN SMALL LETTER C	# 
+1D68C ;	0063 ;	MA	# ( 𝚌 → c ) MATHEMATICAL MONOSPACE SMALL C → LATIN SMALL LETTER C	# 
+1D04 ;	0063 ;	MA	# ( ᴄ → c ) LATIN LETTER SMALL CAPITAL C → LATIN SMALL LETTER C	# 
+03F2 ;	0063 ;	MA	# ( ϲ → c ) GREEK LUNATE SIGMA SYMBOL → LATIN SMALL LETTER C	# 
+2CA5 ;	0063 ;	MA	# ( ⲥ → c ) COPTIC SMALL LETTER SIMA → LATIN SMALL LETTER C	# →ϲ→
+0441 ;	0063 ;	MA	# ( с → c ) CYRILLIC SMALL LETTER ES → LATIN SMALL LETTER C	# 
+1004 ;	0063 ;	MA	# ( င → c ) MYANMAR LETTER NGA → LATIN SMALL LETTER C	# 
+105A ;	0063 ;	MA	# ( ၚ → c ) MYANMAR LETTER MON NGA → LATIN SMALL LETTER C	# →င→
+ABAF ;	0063 ;	MA	# ( ꮯ → c ) CHEROKEE SMALL LETTER TLI → LATIN SMALL LETTER C	# →ᴄ→
+1043D ;	0063 ;	MA	# ( 𐐽 → c ) DESERET SMALL LETTER CHEE → LATIN SMALL LETTER C	# 
+
+2DED ;	0368 ;	MA	# ( ⷭ → ͨ ) COMBINING CYRILLIC LETTER ES → COMBINING LATIN SMALL LETTER C	# 
+
+1F74C ;	0043 ;	MA	#* ( 🝌 → C ) ALCHEMICAL SYMBOL FOR CALX → LATIN CAPITAL LETTER C	# 
+118E9 ;	0043 ;	MA	# ( 𑣩 → C ) WARANG CITI DIGIT NINE → LATIN CAPITAL LETTER C	# 
+118F2 ;	0043 ;	MA	#* ( 𑣲 → C ) WARANG CITI NUMBER NINETY → LATIN CAPITAL LETTER C	# 
+FF23 ;	0043 ;	MA	# ( Ｃ → C ) FULLWIDTH LATIN CAPITAL LETTER C → LATIN CAPITAL LETTER C	# →С→
+216D ;	0043 ;	MA	# ( Ⅽ → C ) ROMAN NUMERAL ONE HUNDRED → LATIN CAPITAL LETTER C	# 
+2102 ;	0043 ;	MA	# ( ℂ → C ) DOUBLE-STRUCK CAPITAL C → LATIN CAPITAL LETTER C	# 
+212D ;	0043 ;	MA	# ( ℭ → C ) BLACK-LETTER CAPITAL C → LATIN CAPITAL LETTER C	# 
+1CCD8 ;	0043 ;	MA	#* ( 𜳘 → C ) OUTLINED LATIN CAPITAL LETTER C → LATIN CAPITAL LETTER C	# 
+1D402 ;	0043 ;	MA	# ( 𝐂 → C ) MATHEMATICAL BOLD CAPITAL C → LATIN CAPITAL LETTER C	# 
+1D436 ;	0043 ;	MA	# ( 𝐶 → C ) MATHEMATICAL ITALIC CAPITAL C → LATIN CAPITAL LETTER C	# 
+1D46A ;	0043 ;	MA	# ( 𝑪 → C ) MATHEMATICAL BOLD ITALIC CAPITAL C → LATIN CAPITAL LETTER C	# 
+1D49E ;	0043 ;	MA	# ( 𝒞 → C ) MATHEMATICAL SCRIPT CAPITAL C → LATIN CAPITAL LETTER C	# 
+1D4D2 ;	0043 ;	MA	# ( 𝓒 → C ) MATHEMATICAL BOLD SCRIPT CAPITAL C → LATIN CAPITAL LETTER C	# 
+1D56E ;	0043 ;	MA	# ( 𝕮 → C ) MATHEMATICAL BOLD FRAKTUR CAPITAL C → LATIN CAPITAL LETTER C	# 
+1D5A2 ;	0043 ;	MA	# ( 𝖢 → C ) MATHEMATICAL SANS-SERIF CAPITAL C → LATIN CAPITAL LETTER C	# 
+1D5D6 ;	0043 ;	MA	# ( 𝗖 → C ) MATHEMATICAL SANS-SERIF BOLD CAPITAL C → LATIN CAPITAL LETTER C	# 
+1D60A ;	0043 ;	MA	# ( 𝘊 → C ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL C → LATIN CAPITAL LETTER C	# 
+1D63E ;	0043 ;	MA	# ( 𝘾 → C ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL C → LATIN CAPITAL LETTER C	# 
+1D672 ;	0043 ;	MA	# ( 𝙲 → C ) MATHEMATICAL MONOSPACE CAPITAL C → LATIN CAPITAL LETTER C	# 
+03F9 ;	0043 ;	MA	# ( Ϲ → C ) GREEK CAPITAL LUNATE SIGMA SYMBOL → LATIN CAPITAL LETTER C	# 
+2CA4 ;	0043 ;	MA	# ( Ⲥ → C ) COPTIC CAPITAL LETTER SIMA → LATIN CAPITAL LETTER C	# →Ϲ→
+0421 ;	0043 ;	MA	# ( С → C ) CYRILLIC CAPITAL LETTER ES → LATIN CAPITAL LETTER C	# 
+13DF ;	0043 ;	MA	# ( Ꮯ → C ) CHEROKEE LETTER TLI → LATIN CAPITAL LETTER C	# 
+A4DA ;	0043 ;	MA	# ( ꓚ → C ) LISU LETTER CA → LATIN CAPITAL LETTER C	# 
+102A2 ;	0043 ;	MA	# ( 𐊢 → C ) CARIAN LETTER D → LATIN CAPITAL LETTER C	# 
+10302 ;	0043 ;	MA	# ( 𐌂 → C ) OLD ITALIC LETTER KE → LATIN CAPITAL LETTER C	# 
+10415 ;	0043 ;	MA	# ( 𐐕 → C ) DESERET CAPITAL LETTER CHEE → LATIN CAPITAL LETTER C	# 
+1051C ;	0043 ;	MA	# ( 𐔜 → C ) ELBASAN LETTER SHE → LATIN CAPITAL LETTER C	# 
+
+00A2 ;	0063 0338 ;	MA	#* ( ¢ → c̸ ) CENT SIGN → LATIN SMALL LETTER C, COMBINING LONG SOLIDUS OVERLAY	# 
+023C ;	0063 0338 ;	MA	# ( ȼ → c̸ ) LATIN SMALL LETTER C WITH STROKE → LATIN SMALL LETTER C, COMBINING LONG SOLIDUS OVERLAY	# →¢→
+
+20A1 ;	0043 20EB ;	MA	#* ( ₡ → C⃫ ) COLON SIGN → LATIN CAPITAL LETTER C, COMBINING LONG DOUBLE SOLIDUS OVERLAY	# 
+
+1F16E ;	0043 20E0 ;	MA	#* ( 🅮 → C⃠ ) CIRCLED C WITH OVERLAID BACKSLASH → LATIN CAPITAL LETTER C, COMBINING ENCLOSING CIRCLE BACKSLASH	# 
+
+00E7 ;	0063 0326 ;	MA	# ( ç → c̦ ) LATIN SMALL LETTER C WITH CEDILLA → LATIN SMALL LETTER C, COMBINING COMMA BELOW	# →ҫ→→с̡→
+04AB ;	0063 0326 ;	MA	# ( ҫ → c̦ ) CYRILLIC SMALL LETTER ES WITH DESCENDER → LATIN SMALL LETTER C, COMBINING COMMA BELOW	# →с̡→
+
+00C7 ;	0043 0326 ;	MA	# ( Ç → C̦ ) LATIN CAPITAL LETTER C WITH CEDILLA → LATIN CAPITAL LETTER C, COMBINING COMMA BELOW	# →Ҫ→→С̡→
+04AA ;	0043 0326 ;	MA	# ( Ҫ → C̦ ) CYRILLIC CAPITAL LETTER ES WITH DESCENDER → LATIN CAPITAL LETTER C, COMBINING COMMA BELOW	# →С̡→
+
+0187 ;	0043 0027 ;	MA	# ( Ƈ → C' ) LATIN CAPITAL LETTER C WITH HOOK → LATIN CAPITAL LETTER C, APOSTROPHE	# →Cʽ→
+
+2105 ;	0063 002F 006F ;	MA	#* ( ℅ → c/o ) CARE OF → LATIN SMALL LETTER C, SOLIDUS, LATIN SMALL LETTER O	# 
+
+2106 ;	0063 002F 0075 ;	MA	#* ( ℆ → c/u ) CADA UNA → LATIN SMALL LETTER C, SOLIDUS, LATIN SMALL LETTER U	# 
+
+1F16D ;	33C4 0009 20DD ;	MA	#* ( 🅭 →  ) CIRCLED CC → SQUARE CC, <CHARACTER TABULATION>, COMBINING ENCLOSING CIRCLE	# 
+
+22F4 ;	A793 ;	MA	#* ( ⋴ → ꞓ ) SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE → LATIN SMALL LETTER C WITH BAR	# →ɛ→→є→
+025B ;	A793 ;	MA	# ( ɛ → ꞓ ) LATIN SMALL LETTER OPEN E → LATIN SMALL LETTER C WITH BAR	# →є→
+03B5 ;	A793 ;	MA	# ( ε → ꞓ ) GREEK SMALL LETTER EPSILON → LATIN SMALL LETTER C WITH BAR	# →є→
+03F5 ;	A793 ;	MA	# ( ϵ → ꞓ ) GREEK LUNATE EPSILON SYMBOL → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+1D6C6 ;	A793 ;	MA	# ( 𝛆 → ꞓ ) MATHEMATICAL BOLD SMALL EPSILON → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+1D6DC ;	A793 ;	MA	# ( 𝛜 → ꞓ ) MATHEMATICAL BOLD EPSILON SYMBOL → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+1D700 ;	A793 ;	MA	# ( 𝜀 → ꞓ ) MATHEMATICAL ITALIC SMALL EPSILON → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+1D716 ;	A793 ;	MA	# ( 𝜖 → ꞓ ) MATHEMATICAL ITALIC EPSILON SYMBOL → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+1D73A ;	A793 ;	MA	# ( 𝜺 → ꞓ ) MATHEMATICAL BOLD ITALIC SMALL EPSILON → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+1D750 ;	A793 ;	MA	# ( 𝝐 → ꞓ ) MATHEMATICAL BOLD ITALIC EPSILON SYMBOL → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+1D774 ;	A793 ;	MA	# ( 𝝴 → ꞓ ) MATHEMATICAL SANS-SERIF BOLD SMALL EPSILON → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+1D78A ;	A793 ;	MA	# ( 𝞊 → ꞓ ) MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+1D7AE ;	A793 ;	MA	# ( 𝞮 → ꞓ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL EPSILON → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+1D7C4 ;	A793 ;	MA	# ( 𝟄 → ꞓ ) MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+2C89 ;	A793 ;	MA	# ( ⲉ → ꞓ ) COPTIC SMALL LETTER EIE → LATIN SMALL LETTER C WITH BAR	# →є→
+0454 ;	A793 ;	MA	# ( є → ꞓ ) CYRILLIC SMALL LETTER UKRAINIAN IE → LATIN SMALL LETTER C WITH BAR	# 
+0511 ;	A793 ;	MA	# ( ԑ → ꞓ ) CYRILLIC SMALL LETTER REVERSED ZE → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+AB9B ;	A793 ;	MA	# ( ꮛ → ꞓ ) CHEROKEE SMALL LETTER QUV → LATIN SMALL LETTER C WITH BAR	# →ɛ→→є→
+118CE ;	A793 ;	MA	# ( 𑣎 → ꞓ ) WARANG CITI SMALL LETTER YUJ → LATIN SMALL LETTER C WITH BAR	# →ε→→є→
+10429 ;	A793 ;	MA	# ( 𐐩 → ꞓ ) DESERET SMALL LETTER LONG E → LATIN SMALL LETTER C WITH BAR	# →ɛ→→є→
+
+20AC ;	A792 ;	MA	#* ( € → Ꞓ ) EURO SIGN → LATIN CAPITAL LETTER C WITH BAR	# →Є→
+2C88 ;	A792 ;	MA	# ( Ⲉ → Ꞓ ) COPTIC CAPITAL LETTER EIE → LATIN CAPITAL LETTER C WITH BAR	# →Є→
+0404 ;	A792 ;	MA	# ( Є → Ꞓ ) CYRILLIC CAPITAL LETTER UKRAINIAN IE → LATIN CAPITAL LETTER C WITH BAR	# 
+
+2377 ;	A793 0332 ;	MA	#* ( ⍷ → ꞓ̲ ) APL FUNCTIONAL SYMBOL EPSILON UNDERBAR → LATIN SMALL LETTER C WITH BAR, COMBINING LOW LINE	# →ε̲→
+
+037D ;	A73F ;	MA	# ( ͽ → ꜿ ) GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL → LATIN SMALL LETTER REVERSED C WITH DOT	# 
+
+03FF ;	A73E ;	MA	# ( Ͽ → Ꜿ ) GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL → LATIN CAPITAL LETTER REVERSED C WITH DOT	# 
+
+217E ;	0064 ;	MA	# ( ⅾ → d ) SMALL ROMAN NUMERAL FIVE HUNDRED → LATIN SMALL LETTER D	# 
+2146 ;	0064 ;	MA	# ( ⅆ → d ) DOUBLE-STRUCK ITALIC SMALL D → LATIN SMALL LETTER D	# 
+1D41D ;	0064 ;	MA	# ( 𝐝 → d ) MATHEMATICAL BOLD SMALL D → LATIN SMALL LETTER D	# 
+1D451 ;	0064 ;	MA	# ( 𝑑 → d ) MATHEMATICAL ITALIC SMALL D → LATIN SMALL LETTER D	# 
+1D485 ;	0064 ;	MA	# ( 𝒅 → d ) MATHEMATICAL BOLD ITALIC SMALL D → LATIN SMALL LETTER D	# 
+1D4B9 ;	0064 ;	MA	# ( 𝒹 → d ) MATHEMATICAL SCRIPT SMALL D → LATIN SMALL LETTER D	# 
+1D4ED ;	0064 ;	MA	# ( 𝓭 → d ) MATHEMATICAL BOLD SCRIPT SMALL D → LATIN SMALL LETTER D	# 
+1D521 ;	0064 ;	MA	# ( 𝔡 → d ) MATHEMATICAL FRAKTUR SMALL D → LATIN SMALL LETTER D	# 
+1D555 ;	0064 ;	MA	# ( 𝕕 → d ) MATHEMATICAL DOUBLE-STRUCK SMALL D → LATIN SMALL LETTER D	# 
+1D589 ;	0064 ;	MA	# ( 𝖉 → d ) MATHEMATICAL BOLD FRAKTUR SMALL D → LATIN SMALL LETTER D	# 
+1D5BD ;	0064 ;	MA	# ( 𝖽 → d ) MATHEMATICAL SANS-SERIF SMALL D → LATIN SMALL LETTER D	# 
+1D5F1 ;	0064 ;	MA	# ( 𝗱 → d ) MATHEMATICAL SANS-SERIF BOLD SMALL D → LATIN SMALL LETTER D	# 
+1D625 ;	0064 ;	MA	# ( 𝘥 → d ) MATHEMATICAL SANS-SERIF ITALIC SMALL D → LATIN SMALL LETTER D	# 
+1D659 ;	0064 ;	MA	# ( 𝙙 → d ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL D → LATIN SMALL LETTER D	# 
+1D68D ;	0064 ;	MA	# ( 𝚍 → d ) MATHEMATICAL MONOSPACE SMALL D → LATIN SMALL LETTER D	# 
+0501 ;	0064 ;	MA	# ( ԁ → d ) CYRILLIC SMALL LETTER KOMI DE → LATIN SMALL LETTER D	# 
+13E7 ;	0064 ;	MA	# ( Ꮷ → d ) CHEROKEE LETTER TSU → LATIN SMALL LETTER D	# 
+146F ;	0064 ;	MA	# ( ᑯ → d ) CANADIAN SYLLABICS KO → LATIN SMALL LETTER D	# 
+A4D2 ;	0064 ;	MA	# ( ꓒ → d ) LISU LETTER PHA → LATIN SMALL LETTER D	# 
+
+216E ;	0044 ;	MA	# ( Ⅾ → D ) ROMAN NUMERAL FIVE HUNDRED → LATIN CAPITAL LETTER D	# 
+2145 ;	0044 ;	MA	# ( ⅅ → D ) DOUBLE-STRUCK ITALIC CAPITAL D → LATIN CAPITAL LETTER D	# 
+1CCD9 ;	0044 ;	MA	#* ( 𜳙 → D ) OUTLINED LATIN CAPITAL LETTER D → LATIN CAPITAL LETTER D	# 
+1D403 ;	0044 ;	MA	# ( 𝐃 → D ) MATHEMATICAL BOLD CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D437 ;	0044 ;	MA	# ( 𝐷 → D ) MATHEMATICAL ITALIC CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D46B ;	0044 ;	MA	# ( 𝑫 → D ) MATHEMATICAL BOLD ITALIC CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D49F ;	0044 ;	MA	# ( 𝒟 → D ) MATHEMATICAL SCRIPT CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D4D3 ;	0044 ;	MA	# ( 𝓓 → D ) MATHEMATICAL BOLD SCRIPT CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D507 ;	0044 ;	MA	# ( 𝔇 → D ) MATHEMATICAL FRAKTUR CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D53B ;	0044 ;	MA	# ( 𝔻 → D ) MATHEMATICAL DOUBLE-STRUCK CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D56F ;	0044 ;	MA	# ( 𝕯 → D ) MATHEMATICAL BOLD FRAKTUR CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D5A3 ;	0044 ;	MA	# ( 𝖣 → D ) MATHEMATICAL SANS-SERIF CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D5D7 ;	0044 ;	MA	# ( 𝗗 → D ) MATHEMATICAL SANS-SERIF BOLD CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D60B ;	0044 ;	MA	# ( 𝘋 → D ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D63F ;	0044 ;	MA	# ( 𝘿 → D ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL D → LATIN CAPITAL LETTER D	# 
+1D673 ;	0044 ;	MA	# ( 𝙳 → D ) MATHEMATICAL MONOSPACE CAPITAL D → LATIN CAPITAL LETTER D	# 
+13A0 ;	0044 ;	MA	# ( Ꭰ → D ) CHEROKEE LETTER A → LATIN CAPITAL LETTER D	# 
+15DE ;	0044 ;	MA	# ( ᗞ → D ) CANADIAN SYLLABICS CARRIER THE → LATIN CAPITAL LETTER D	# 
+15EA ;	0044 ;	MA	# ( ᗪ → D ) CANADIAN SYLLABICS CARRIER PE → LATIN CAPITAL LETTER D	# →ᗞ→
+A4D3 ;	0044 ;	MA	# ( ꓓ → D ) LISU LETTER DA → LATIN CAPITAL LETTER D	# 
+
+0257 ;	0064 0314 ;	MA	# ( ɗ → d̔ ) LATIN SMALL LETTER D WITH HOOK → LATIN SMALL LETTER D, COMBINING REVERSED COMMA ABOVE	# 
+
+0256 ;	0064 0328 ;	MA	# ( ɖ → d̨ ) LATIN SMALL LETTER D WITH TAIL → LATIN SMALL LETTER D, COMBINING OGONEK	# →d̢→
+
+018C ;	0064 0304 ;	MA	# ( ƌ → d̄ ) LATIN SMALL LETTER D WITH TOPBAR → LATIN SMALL LETTER D, COMBINING MACRON	# 
+
+0111 ;	0064 0335 ;	MA	# ( đ → d̵ ) LATIN SMALL LETTER D WITH STROKE → LATIN SMALL LETTER D, COMBINING SHORT STROKE OVERLAY	# 
+
+0110 ;	0044 0335 ;	MA	# ( Đ → D̵ ) LATIN CAPITAL LETTER D WITH STROKE → LATIN CAPITAL LETTER D, COMBINING SHORT STROKE OVERLAY	# 
+00D0 ;	0044 0335 ;	MA	# ( Ð → D̵ ) LATIN CAPITAL LETTER ETH → LATIN CAPITAL LETTER D, COMBINING SHORT STROKE OVERLAY	# →Đ→
+0189 ;	0044 0335 ;	MA	# ( Ɖ → D̵ ) LATIN CAPITAL LETTER AFRICAN D → LATIN CAPITAL LETTER D, COMBINING SHORT STROKE OVERLAY	# →Đ→
+
+20AB ;	0064 0335 0331 ;	MA	#* ( ₫ → ḏ̵ ) DONG SIGN → LATIN SMALL LETTER D, COMBINING SHORT STROKE OVERLAY, COMBINING MACRON BELOW	# →đ̱→
+
+A77A ;	A779 ;	MA	# ( ꝺ → Ꝺ ) LATIN SMALL LETTER INSULAR D → LATIN CAPITAL LETTER INSULAR D	# 
+
+147B ;	0064 00B7 ;	MA	# ( ᑻ → d· ) CANADIAN SYLLABICS WEST-CREE KWO → LATIN SMALL LETTER D, MIDDLE DOT	# →ᑯᐧ→
+
+1487 ;	0064 0027 ;	MA	# ( ᒇ → d' ) CANADIAN SYLLABICS SOUTH-SLAVEY KOH → LATIN SMALL LETTER D, APOSTROPHE	# →ᑯᑊ→
+
+02A4 ;	0064 021D ;	MA	# ( ʤ → dȝ ) LATIN SMALL LETTER DEZH DIGRAPH → LATIN SMALL LETTER D, LATIN SMALL LETTER YOGH	# →dʒ→
+
+01F3 ;	0064 007A ;	MA	# ( dz → dz ) LATIN SMALL LETTER DZ → LATIN SMALL LETTER D, LATIN SMALL LETTER Z	# 
+02A3 ;	0064 007A ;	MA	# ( ʣ → dz ) LATIN SMALL LETTER DZ DIGRAPH → LATIN SMALL LETTER D, LATIN SMALL LETTER Z	# 
+
+01F2 ;	0044 007A ;	MA	# ( Dz → Dz ) LATIN CAPITAL LETTER D WITH SMALL LETTER Z → LATIN CAPITAL LETTER D, LATIN SMALL LETTER Z	# 
+
+01F1 ;	0044 005A ;	MA	# ( DZ → DZ ) LATIN CAPITAL LETTER DZ → LATIN CAPITAL LETTER D, LATIN CAPITAL LETTER Z	# 
+
+01C6 ;	0064 017E ;	MA	# ( dž → dž ) LATIN SMALL LETTER DZ WITH CARON → LATIN SMALL LETTER D, LATIN SMALL LETTER Z WITH CARON	# 
+
+01C5 ;	0044 017E ;	MA	# ( Dž → Dž ) LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON → LATIN CAPITAL LETTER D, LATIN SMALL LETTER Z WITH CARON	# 
+
+01C4 ;	0044 017D ;	MA	# ( DŽ → DŽ ) LATIN CAPITAL LETTER DZ WITH CARON → LATIN CAPITAL LETTER D, LATIN CAPITAL LETTER Z WITH CARON	# 
+
+02A5 ;	0064 0291 ;	MA	# ( ʥ → dʑ ) LATIN SMALL LETTER DZ DIGRAPH WITH CURL → LATIN SMALL LETTER D, LATIN SMALL LETTER Z WITH CURL	# 
+
+AB70 ;	1D05 ;	MA	# ( ꭰ → ᴅ ) CHEROKEE SMALL LETTER A → LATIN LETTER SMALL CAPITAL D	# 
+
+2E39 ;	1E9F ;	MA	#* ( ⸹ → ẟ ) TOP HALF SECTION SIGN → LATIN SMALL LETTER DELTA	# →δ→
+03B4 ;	1E9F ;	MA	# ( δ → ẟ ) GREEK SMALL LETTER DELTA → LATIN SMALL LETTER DELTA	# 
+1D6C5 ;	1E9F ;	MA	# ( 𝛅 → ẟ ) MATHEMATICAL BOLD SMALL DELTA → LATIN SMALL LETTER DELTA	# →δ→
+1D6FF ;	1E9F ;	MA	# ( 𝛿 → ẟ ) MATHEMATICAL ITALIC SMALL DELTA → LATIN SMALL LETTER DELTA	# →δ→
+1D739 ;	1E9F ;	MA	# ( 𝜹 → ẟ ) MATHEMATICAL BOLD ITALIC SMALL DELTA → LATIN SMALL LETTER DELTA	# →δ→
+1D773 ;	1E9F ;	MA	# ( 𝝳 → ẟ ) MATHEMATICAL SANS-SERIF BOLD SMALL DELTA → LATIN SMALL LETTER DELTA	# →δ→
+1D7AD ;	1E9F ;	MA	# ( 𝞭 → ẟ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL DELTA → LATIN SMALL LETTER DELTA	# →δ→
+2CDD ;	1E9F ;	MA	# ( ⳝ → ẟ ) COPTIC SMALL LETTER OLD NUBIAN SHIMA → LATIN SMALL LETTER DELTA	# →δ→
+056E ;	1E9F ;	MA	# ( ծ → ẟ ) ARMENIAN SMALL LETTER CA → LATIN SMALL LETTER DELTA	# →δ→
+1577 ;	1E9F ;	MA	# ( ᕷ → ẟ ) CANADIAN SYLLABICS NUNAVIK HO → LATIN SMALL LETTER DELTA	# →δ→
+
+212E ;	0065 ;	MA	# ( ℮ → e ) ESTIMATED SYMBOL → LATIN SMALL LETTER E	# 
+FF45 ;	0065 ;	MA	# ( ｅ → e ) FULLWIDTH LATIN SMALL LETTER E → LATIN SMALL LETTER E	# →е→
+212F ;	0065 ;	MA	# ( ℯ → e ) SCRIPT SMALL E → LATIN SMALL LETTER E	# 
+2147 ;	0065 ;	MA	# ( ⅇ → e ) DOUBLE-STRUCK ITALIC SMALL E → LATIN SMALL LETTER E	# 
+1D41E ;	0065 ;	MA	# ( 𝐞 → e ) MATHEMATICAL BOLD SMALL E → LATIN SMALL LETTER E	# 
+1D452 ;	0065 ;	MA	# ( 𝑒 → e ) MATHEMATICAL ITALIC SMALL E → LATIN SMALL LETTER E	# 
+1D486 ;	0065 ;	MA	# ( 𝒆 → e ) MATHEMATICAL BOLD ITALIC SMALL E → LATIN SMALL LETTER E	# 
+1D4EE ;	0065 ;	MA	# ( 𝓮 → e ) MATHEMATICAL BOLD SCRIPT SMALL E → LATIN SMALL LETTER E	# 
+1D522 ;	0065 ;	MA	# ( 𝔢 → e ) MATHEMATICAL FRAKTUR SMALL E → LATIN SMALL LETTER E	# 
+1D556 ;	0065 ;	MA	# ( 𝕖 → e ) MATHEMATICAL DOUBLE-STRUCK SMALL E → LATIN SMALL LETTER E	# 
+1D58A ;	0065 ;	MA	# ( 𝖊 → e ) MATHEMATICAL BOLD FRAKTUR SMALL E → LATIN SMALL LETTER E	# 
+1D5BE ;	0065 ;	MA	# ( 𝖾 → e ) MATHEMATICAL SANS-SERIF SMALL E → LATIN SMALL LETTER E	# 
+1D5F2 ;	0065 ;	MA	# ( 𝗲 → e ) MATHEMATICAL SANS-SERIF BOLD SMALL E → LATIN SMALL LETTER E	# 
+1D626 ;	0065 ;	MA	# ( 𝘦 → e ) MATHEMATICAL SANS-SERIF ITALIC SMALL E → LATIN SMALL LETTER E	# 
+1D65A ;	0065 ;	MA	# ( 𝙚 → e ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL E → LATIN SMALL LETTER E	# 
+1D68E ;	0065 ;	MA	# ( 𝚎 → e ) MATHEMATICAL MONOSPACE SMALL E → LATIN SMALL LETTER E	# 
+AB32 ;	0065 ;	MA	# ( ꬲ → e ) LATIN SMALL LETTER BLACKLETTER E → LATIN SMALL LETTER E	# 
+0435 ;	0065 ;	MA	# ( е → e ) CYRILLIC SMALL LETTER IE → LATIN SMALL LETTER E	# 
+04BD ;	0065 ;	MA	# ( ҽ → e ) CYRILLIC SMALL LETTER ABKHASIAN CHE → LATIN SMALL LETTER E	# 
+
+2DF7 ;	0364 ;	MA	# ( ⷷ → ͤ ) COMBINING CYRILLIC LETTER IE → COMBINING LATIN SMALL LETTER E	# 
+
+22FF ;	0045 ;	MA	#* ( ⋿ → E ) Z NOTATION BAG MEMBERSHIP → LATIN CAPITAL LETTER E	# 
+FF25 ;	0045 ;	MA	# ( Ｅ → E ) FULLWIDTH LATIN CAPITAL LETTER E → LATIN CAPITAL LETTER E	# →Ε→
+2130 ;	0045 ;	MA	# ( ℰ → E ) SCRIPT CAPITAL E → LATIN CAPITAL LETTER E	# 
+1CCDA ;	0045 ;	MA	#* ( 𜳚 → E ) OUTLINED LATIN CAPITAL LETTER E → LATIN CAPITAL LETTER E	# 
+1D404 ;	0045 ;	MA	# ( 𝐄 → E ) MATHEMATICAL BOLD CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D438 ;	0045 ;	MA	# ( 𝐸 → E ) MATHEMATICAL ITALIC CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D46C ;	0045 ;	MA	# ( 𝑬 → E ) MATHEMATICAL BOLD ITALIC CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D4D4 ;	0045 ;	MA	# ( 𝓔 → E ) MATHEMATICAL BOLD SCRIPT CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D508 ;	0045 ;	MA	# ( 𝔈 → E ) MATHEMATICAL FRAKTUR CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D53C ;	0045 ;	MA	# ( 𝔼 → E ) MATHEMATICAL DOUBLE-STRUCK CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D570 ;	0045 ;	MA	# ( 𝕰 → E ) MATHEMATICAL BOLD FRAKTUR CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D5A4 ;	0045 ;	MA	# ( 𝖤 → E ) MATHEMATICAL SANS-SERIF CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D5D8 ;	0045 ;	MA	# ( 𝗘 → E ) MATHEMATICAL SANS-SERIF BOLD CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D60C ;	0045 ;	MA	# ( 𝘌 → E ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D640 ;	0045 ;	MA	# ( 𝙀 → E ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL E → LATIN CAPITAL LETTER E	# 
+1D674 ;	0045 ;	MA	# ( 𝙴 → E ) MATHEMATICAL MONOSPACE CAPITAL E → LATIN CAPITAL LETTER E	# 
+0395 ;	0045 ;	MA	# ( Ε → E ) GREEK CAPITAL LETTER EPSILON → LATIN CAPITAL LETTER E	# 
+1D6AC ;	0045 ;	MA	# ( 𝚬 → E ) MATHEMATICAL BOLD CAPITAL EPSILON → LATIN CAPITAL LETTER E	# →𝐄→
+1D6E6 ;	0045 ;	MA	# ( 𝛦 → E ) MATHEMATICAL ITALIC CAPITAL EPSILON → LATIN CAPITAL LETTER E	# →Ε→
+1D720 ;	0045 ;	MA	# ( 𝜠 → E ) MATHEMATICAL BOLD ITALIC CAPITAL EPSILON → LATIN CAPITAL LETTER E	# →Ε→
+1D75A ;	0045 ;	MA	# ( 𝝚 → E ) MATHEMATICAL SANS-SERIF BOLD CAPITAL EPSILON → LATIN CAPITAL LETTER E	# →Ε→
+1D794 ;	0045 ;	MA	# ( 𝞔 → E ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL EPSILON → LATIN CAPITAL LETTER E	# →Ε→
+0415 ;	0045 ;	MA	# ( Е → E ) CYRILLIC CAPITAL LETTER IE → LATIN CAPITAL LETTER E	# 
+2D39 ;	0045 ;	MA	# ( ⴹ → E ) TIFINAGH LETTER YADD → LATIN CAPITAL LETTER E	# 
+13AC ;	0045 ;	MA	# ( Ꭼ → E ) CHEROKEE LETTER GV → LATIN CAPITAL LETTER E	# 
+A4F0 ;	0045 ;	MA	# ( ꓰ → E ) LISU LETTER E → LATIN CAPITAL LETTER E	# 
+118A6 ;	0045 ;	MA	# ( 𑢦 → E ) WARANG CITI CAPITAL LETTER II → LATIN CAPITAL LETTER E	# 
+118AE ;	0045 ;	MA	# ( 𑢮 → E ) WARANG CITI CAPITAL LETTER YUJ → LATIN CAPITAL LETTER E	# 
+10286 ;	0045 ;	MA	# ( 𐊆 → E ) LYCIAN LETTER I → LATIN CAPITAL LETTER E	# 
+
+011B ;	0115 ;	MA	# ( ě → ĕ ) LATIN SMALL LETTER E WITH CARON → LATIN SMALL LETTER E WITH BREVE	# 
+
+011A ;	0114 ;	MA	# ( Ě → Ĕ ) LATIN CAPITAL LETTER E WITH CARON → LATIN CAPITAL LETTER E WITH BREVE	# 
+
+0247 ;	0065 0338 ;	MA	# ( ɇ → e̸ ) LATIN SMALL LETTER E WITH STROKE → LATIN SMALL LETTER E, COMBINING LONG SOLIDUS OVERLAY	# →e̷→
+
+0246 ;	0045 0338 ;	MA	# ( Ɇ → E̸ ) LATIN CAPITAL LETTER E WITH STROKE → LATIN CAPITAL LETTER E, COMBINING LONG SOLIDUS OVERLAY	# 
+
+04BF ;	0065 0328 ;	MA	# ( ҿ → ę ) CYRILLIC SMALL LETTER ABKHASIAN CHE WITH DESCENDER → LATIN SMALL LETTER E, COMBINING OGONEK	# →ҽ̢→
+
+AB7C ;	1D07 ;	MA	# ( ꭼ → ᴇ ) CHEROKEE SMALL LETTER GV → LATIN LETTER SMALL CAPITAL E	# 
+
+0259 ;	01DD ;	MA	# ( ə → ǝ ) LATIN SMALL LETTER SCHWA → LATIN SMALL LETTER TURNED E	# 
+04D9 ;	01DD ;	MA	# ( ә → ǝ ) CYRILLIC SMALL LETTER SCHWA → LATIN SMALL LETTER TURNED E	# 
+
+2203 ;	018E ;	MA	#* ( ∃ → Ǝ ) THERE EXISTS → LATIN CAPITAL LETTER REVERSED E	# 
+2D3A ;	018E ;	MA	# ( ⴺ → Ǝ ) TIFINAGH LETTER YADDH → LATIN CAPITAL LETTER REVERSED E	# 
+A4F1 ;	018E ;	MA	# ( ꓱ → Ǝ ) LISU LETTER EU → LATIN CAPITAL LETTER REVERSED E	# 
+
+025A ;	01DD 02DE ;	MA	# ( ɚ → ǝ˞ ) LATIN SMALL LETTER SCHWA WITH HOOK → LATIN SMALL LETTER TURNED E, MODIFIER LETTER RHOTIC HOOK	# →ə˞→
+
+1D14 ;	01DD 006F ;	MA	# ( ᴔ → ǝo ) LATIN SMALL LETTER TURNED OE → LATIN SMALL LETTER TURNED E, LATIN SMALL LETTER O	# →əo→
+
+AB41 ;	01DD 006F 0338 ;	MA	# ( ꭁ → ǝo̸ ) LATIN SMALL LETTER TURNED OE WITH STROKE → LATIN SMALL LETTER TURNED E, LATIN SMALL LETTER O, COMBINING LONG SOLIDUS OVERLAY	# →ǝø→
+
+AB42 ;	01DD 006F 0335 ;	MA	# ( ꭂ → ǝo̵ ) LATIN SMALL LETTER TURNED OE WITH HORIZONTAL STROKE → LATIN SMALL LETTER TURNED E, LATIN SMALL LETTER O, COMBINING SHORT STROKE OVERLAY	# →ǝɵ→
+
+04D8 ;	018F ;	MA	# ( Ә → Ə ) CYRILLIC CAPITAL LETTER SCHWA → LATIN CAPITAL LETTER SCHWA	# 
+
+1D221 ;	0190 ;	MA	#* ( 𝈡 → Ɛ ) GREEK INSTRUMENTAL NOTATION SYMBOL-7 → LATIN CAPITAL LETTER OPEN E	# 
+2107 ;	0190 ;	MA	# ( ℇ → Ɛ ) EULER CONSTANT → LATIN CAPITAL LETTER OPEN E	# 
+0510 ;	0190 ;	MA	# ( Ԑ → Ɛ ) CYRILLIC CAPITAL LETTER REVERSED ZE → LATIN CAPITAL LETTER OPEN E	# 
+13CB ;	0190 ;	MA	# ( Ꮛ → Ɛ ) CHEROKEE LETTER QUV → LATIN CAPITAL LETTER OPEN E	# 
+16F2D ;	0190 ;	MA	# ( 𖼭 → Ɛ ) MIAO LETTER NYHA → LATIN CAPITAL LETTER OPEN E	# 
+10401 ;	0190 ;	MA	# ( 𐐁 → Ɛ ) DESERET CAPITAL LETTER LONG E → LATIN CAPITAL LETTER OPEN E	# 
+
+1D9F ;	1D4B ;	MA	# ( ᶟ → ᵋ ) MODIFIER LETTER SMALL REVERSED OPEN E → MODIFIER LETTER SMALL OPEN E	# 
+
+1D08 ;	025C ;	MA	# ( ᴈ → ɜ ) LATIN SMALL LETTER TURNED OPEN E → LATIN SMALL LETTER REVERSED OPEN E	# 
+0437 ;	025C ;	MA	# ( з → ɜ ) CYRILLIC SMALL LETTER ZE → LATIN SMALL LETTER REVERSED OPEN E	# 
+
+0499 ;	025C 0326 ;	MA	# ( ҙ → ɜ̦ ) CYRILLIC SMALL LETTER ZE WITH DESCENDER → LATIN SMALL LETTER REVERSED OPEN E, COMBINING COMMA BELOW	# →з̡→
+
+10442 ;	025E ;	MA	# ( 𐑂 → ɞ ) DESERET SMALL LETTER VEE → LATIN SMALL LETTER CLOSED REVERSED OPEN E	# 
+
+A79D ;	029A ;	MA	# ( ꞝ → ʚ ) LATIN SMALL LETTER VOLAPUK OE → LATIN SMALL LETTER CLOSED OPEN E	# 
+1042A ;	029A ;	MA	# ( 𐐪 → ʚ ) DESERET SMALL LETTER LONG A → LATIN SMALL LETTER CLOSED OPEN E	# 
+
+1D41F ;	0066 ;	MA	# ( 𝐟 → f ) MATHEMATICAL BOLD SMALL F → LATIN SMALL LETTER F	# 
+1D453 ;	0066 ;	MA	# ( 𝑓 → f ) MATHEMATICAL ITALIC SMALL F → LATIN SMALL LETTER F	# 
+1D487 ;	0066 ;	MA	# ( 𝒇 → f ) MATHEMATICAL BOLD ITALIC SMALL F → LATIN SMALL LETTER F	# 
+1D4BB ;	0066 ;	MA	# ( 𝒻 → f ) MATHEMATICAL SCRIPT SMALL F → LATIN SMALL LETTER F	# 
+1D4EF ;	0066 ;	MA	# ( 𝓯 → f ) MATHEMATICAL BOLD SCRIPT SMALL F → LATIN SMALL LETTER F	# 
+1D523 ;	0066 ;	MA	# ( 𝔣 → f ) MATHEMATICAL FRAKTUR SMALL F → LATIN SMALL LETTER F	# 
+1D557 ;	0066 ;	MA	# ( 𝕗 → f ) MATHEMATICAL DOUBLE-STRUCK SMALL F → LATIN SMALL LETTER F	# 
+1D58B ;	0066 ;	MA	# ( 𝖋 → f ) MATHEMATICAL BOLD FRAKTUR SMALL F → LATIN SMALL LETTER F	# 
+1D5BF ;	0066 ;	MA	# ( 𝖿 → f ) MATHEMATICAL SANS-SERIF SMALL F → LATIN SMALL LETTER F	# 
+1D5F3 ;	0066 ;	MA	# ( 𝗳 → f ) MATHEMATICAL SANS-SERIF BOLD SMALL F → LATIN SMALL LETTER F	# 
+1D627 ;	0066 ;	MA	# ( 𝘧 → f ) MATHEMATICAL SANS-SERIF ITALIC SMALL F → LATIN SMALL LETTER F	# 
+1D65B ;	0066 ;	MA	# ( 𝙛 → f ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL F → LATIN SMALL LETTER F	# 
+1D68F ;	0066 ;	MA	# ( 𝚏 → f ) MATHEMATICAL MONOSPACE SMALL F → LATIN SMALL LETTER F	# 
+AB35 ;	0066 ;	MA	# ( ꬵ → f ) LATIN SMALL LETTER LENIS F → LATIN SMALL LETTER F	# 
+A799 ;	0066 ;	MA	# ( ꞙ → f ) LATIN SMALL LETTER F WITH STROKE → LATIN SMALL LETTER F	# 
+0192 ;	0066 ;	MA	# ( ƒ → f ) LATIN SMALL LETTER F WITH HOOK → LATIN SMALL LETTER F	# 
+017F ;	0066 ;	MA	# ( ſ → f ) LATIN SMALL LETTER LONG S → LATIN SMALL LETTER F	# 
+1E9D ;	0066 ;	MA	# ( ẝ → f ) LATIN SMALL LETTER LONG S WITH HIGH STROKE → LATIN SMALL LETTER F	# 
+0584 ;	0066 ;	MA	# ( ք → f ) ARMENIAN SMALL LETTER KEH → LATIN SMALL LETTER F	# 
+
+1D213 ;	0046 ;	MA	#* ( 𝈓 → F ) GREEK VOCAL NOTATION SYMBOL-20 → LATIN CAPITAL LETTER F	# →Ϝ→
+2131 ;	0046 ;	MA	# ( ℱ → F ) SCRIPT CAPITAL F → LATIN CAPITAL LETTER F	# 
+1CCDB ;	0046 ;	MA	#* ( 𜳛 → F ) OUTLINED LATIN CAPITAL LETTER F → LATIN CAPITAL LETTER F	# 
+1D405 ;	0046 ;	MA	# ( 𝐅 → F ) MATHEMATICAL BOLD CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D439 ;	0046 ;	MA	# ( 𝐹 → F ) MATHEMATICAL ITALIC CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D46D ;	0046 ;	MA	# ( 𝑭 → F ) MATHEMATICAL BOLD ITALIC CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D4D5 ;	0046 ;	MA	# ( 𝓕 → F ) MATHEMATICAL BOLD SCRIPT CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D509 ;	0046 ;	MA	# ( 𝔉 → F ) MATHEMATICAL FRAKTUR CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D53D ;	0046 ;	MA	# ( 𝔽 → F ) MATHEMATICAL DOUBLE-STRUCK CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D571 ;	0046 ;	MA	# ( 𝕱 → F ) MATHEMATICAL BOLD FRAKTUR CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D5A5 ;	0046 ;	MA	# ( 𝖥 → F ) MATHEMATICAL SANS-SERIF CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D5D9 ;	0046 ;	MA	# ( 𝗙 → F ) MATHEMATICAL SANS-SERIF BOLD CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D60D ;	0046 ;	MA	# ( 𝘍 → F ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D641 ;	0046 ;	MA	# ( 𝙁 → F ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL F → LATIN CAPITAL LETTER F	# 
+1D675 ;	0046 ;	MA	# ( 𝙵 → F ) MATHEMATICAL MONOSPACE CAPITAL F → LATIN CAPITAL LETTER F	# 
+A798 ;	0046 ;	MA	# ( Ꞙ → F ) LATIN CAPITAL LETTER F WITH STROKE → LATIN CAPITAL LETTER F	# 
+03DC ;	0046 ;	MA	# ( Ϝ → F ) GREEK LETTER DIGAMMA → LATIN CAPITAL LETTER F	# 
+1D7CA ;	0046 ;	MA	# ( 𝟊 → F ) MATHEMATICAL BOLD CAPITAL DIGAMMA → LATIN CAPITAL LETTER F	# →Ϝ→
+15B4 ;	0046 ;	MA	# ( ᖴ → F ) CANADIAN SYLLABICS BLACKFOOT WE → LATIN CAPITAL LETTER F	# 
+A4DD ;	0046 ;	MA	# ( ꓝ → F ) LISU LETTER TSA → LATIN CAPITAL LETTER F	# 
+118C2 ;	0046 ;	MA	# ( 𑣂 → F ) WARANG CITI SMALL LETTER WI → LATIN CAPITAL LETTER F	# 
+118A2 ;	0046 ;	MA	# ( 𑢢 → F ) WARANG CITI CAPITAL LETTER WI → LATIN CAPITAL LETTER F	# 
+10287 ;	0046 ;	MA	# ( 𐊇 → F ) LYCIAN LETTER W → LATIN CAPITAL LETTER F	# 
+102A5 ;	0046 ;	MA	# ( 𐊥 → F ) CARIAN LETTER R → LATIN CAPITAL LETTER F	# 
+10525 ;	0046 ;	MA	# ( 𐔥 → F ) ELBASAN LETTER GHE → LATIN CAPITAL LETTER F	# 
+
+0191 ;	0046 0326 ;	MA	# ( Ƒ → F̦ ) LATIN CAPITAL LETTER F WITH HOOK → LATIN CAPITAL LETTER F, COMBINING COMMA BELOW	# →F̡→
+
+1D6E ;	0066 0334 ;	MA	# ( ᵮ → f̴ ) LATIN SMALL LETTER F WITH MIDDLE TILDE → LATIN SMALL LETTER F, COMBINING TILDE OVERLAY	# 
+
+213B ;	0046 0041 0058 ;	MA	#* ( ℻ → FAX ) FACSIMILE SIGN → LATIN CAPITAL LETTER F, LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER X	# 
+
+FB00 ;	0066 0066 ;	MA	# ( ff → ff ) LATIN SMALL LIGATURE FF → LATIN SMALL LETTER F, LATIN SMALL LETTER F	# 
+
+FB03 ;	0066 0066 0069 ;	MA	# ( ffi → ffi ) LATIN SMALL LIGATURE FFI → LATIN SMALL LETTER F, LATIN SMALL LETTER F, LATIN SMALL LETTER I	# 
+
+FB04 ;	0066 0066 006C ;	MA	# ( ffl → ffl ) LATIN SMALL LIGATURE FFL → LATIN SMALL LETTER F, LATIN SMALL LETTER F, LATIN SMALL LETTER L	# 
+
+FB01 ;	0066 0069 ;	MA	# ( fi → fi ) LATIN SMALL LIGATURE FI → LATIN SMALL LETTER F, LATIN SMALL LETTER I	# 
+
+FB02 ;	0066 006C ;	MA	# ( fl → fl ) LATIN SMALL LIGATURE FL → LATIN SMALL LETTER F, LATIN SMALL LETTER L	# 
+
+02A9 ;	0066 006E 0329 ;	MA	# ( ʩ → fn̩ ) LATIN SMALL LETTER FENG DIGRAPH → LATIN SMALL LETTER F, LATIN SMALL LETTER N, COMBINING VERTICAL LINE BELOW	# →fŋ→
+
+15B5 ;	2132 ;	MA	# ( ᖵ → Ⅎ ) CANADIAN SYLLABICS BLACKFOOT WI → TURNED CAPITAL F	# 
+A4DE ;	2132 ;	MA	# ( ꓞ → Ⅎ ) LISU LETTER TSHA → TURNED CAPITAL F	# 
+
+1D230 ;	A7FB ;	MA	#* ( 𝈰 → ꟻ ) GREEK INSTRUMENTAL NOTATION SYMBOL-30 → LATIN EPIGRAPHIC LETTER REVERSED F	# 
+15B7 ;	A7FB ;	MA	# ( ᖷ → ꟻ ) CANADIAN SYLLABICS BLACKFOOT WA → LATIN EPIGRAPHIC LETTER REVERSED F	# 
+
+FF47 ;	0067 ;	MA	# ( ｇ → g ) FULLWIDTH LATIN SMALL LETTER G → LATIN SMALL LETTER G	# →ɡ→
+210A ;	0067 ;	MA	# ( ℊ → g ) SCRIPT SMALL G → LATIN SMALL LETTER G	# 
+1D420 ;	0067 ;	MA	# ( 𝐠 → g ) MATHEMATICAL BOLD SMALL G → LATIN SMALL LETTER G	# 
+1D454 ;	0067 ;	MA	# ( 𝑔 → g ) MATHEMATICAL ITALIC SMALL G → LATIN SMALL LETTER G	# 
+1D488 ;	0067 ;	MA	# ( 𝒈 → g ) MATHEMATICAL BOLD ITALIC SMALL G → LATIN SMALL LETTER G	# 
+1D4F0 ;	0067 ;	MA	# ( 𝓰 → g ) MATHEMATICAL BOLD SCRIPT SMALL G → LATIN SMALL LETTER G	# 
+1D524 ;	0067 ;	MA	# ( 𝔤 → g ) MATHEMATICAL FRAKTUR SMALL G → LATIN SMALL LETTER G	# 
+1D558 ;	0067 ;	MA	# ( 𝕘 → g ) MATHEMATICAL DOUBLE-STRUCK SMALL G → LATIN SMALL LETTER G	# 
+1D58C ;	0067 ;	MA	# ( 𝖌 → g ) MATHEMATICAL BOLD FRAKTUR SMALL G → LATIN SMALL LETTER G	# 
+1D5C0 ;	0067 ;	MA	# ( 𝗀 → g ) MATHEMATICAL SANS-SERIF SMALL G → LATIN SMALL LETTER G	# 
+1D5F4 ;	0067 ;	MA	# ( 𝗴 → g ) MATHEMATICAL SANS-SERIF BOLD SMALL G → LATIN SMALL LETTER G	# 
+1D628 ;	0067 ;	MA	# ( 𝘨 → g ) MATHEMATICAL SANS-SERIF ITALIC SMALL G → LATIN SMALL LETTER G	# 
+1D65C ;	0067 ;	MA	# ( 𝙜 → g ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL G → LATIN SMALL LETTER G	# 
+1D690 ;	0067 ;	MA	# ( 𝚐 → g ) MATHEMATICAL MONOSPACE SMALL G → LATIN SMALL LETTER G	# 
+0261 ;	0067 ;	MA	# ( ɡ → g ) LATIN SMALL LETTER SCRIPT G → LATIN SMALL LETTER G	# 
+1D83 ;	0067 ;	MA	# ( ᶃ → g ) LATIN SMALL LETTER G WITH PALATAL HOOK → LATIN SMALL LETTER G	# 
+018D ;	0067 ;	MA	# ( ƍ → g ) LATIN SMALL LETTER TURNED DELTA → LATIN SMALL LETTER G	# 
+0581 ;	0067 ;	MA	# ( ց → g ) ARMENIAN SMALL LETTER CO → LATIN SMALL LETTER G	# 
+
+1CCDC ;	0047 ;	MA	#* ( 𜳜 → G ) OUTLINED LATIN CAPITAL LETTER G → LATIN CAPITAL LETTER G	# 
+1D406 ;	0047 ;	MA	# ( 𝐆 → G ) MATHEMATICAL BOLD CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D43A ;	0047 ;	MA	# ( 𝐺 → G ) MATHEMATICAL ITALIC CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D46E ;	0047 ;	MA	# ( 𝑮 → G ) MATHEMATICAL BOLD ITALIC CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D4A2 ;	0047 ;	MA	# ( 𝒢 → G ) MATHEMATICAL SCRIPT CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D4D6 ;	0047 ;	MA	# ( 𝓖 → G ) MATHEMATICAL BOLD SCRIPT CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D50A ;	0047 ;	MA	# ( 𝔊 → G ) MATHEMATICAL FRAKTUR CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D53E ;	0047 ;	MA	# ( 𝔾 → G ) MATHEMATICAL DOUBLE-STRUCK CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D572 ;	0047 ;	MA	# ( 𝕲 → G ) MATHEMATICAL BOLD FRAKTUR CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D5A6 ;	0047 ;	MA	# ( 𝖦 → G ) MATHEMATICAL SANS-SERIF CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D5DA ;	0047 ;	MA	# ( 𝗚 → G ) MATHEMATICAL SANS-SERIF BOLD CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D60E ;	0047 ;	MA	# ( 𝘎 → G ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D642 ;	0047 ;	MA	# ( 𝙂 → G ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL G → LATIN CAPITAL LETTER G	# 
+1D676 ;	0047 ;	MA	# ( 𝙶 → G ) MATHEMATICAL MONOSPACE CAPITAL G → LATIN CAPITAL LETTER G	# 
+050C ;	0047 ;	MA	# ( Ԍ → G ) CYRILLIC CAPITAL LETTER KOMI SJE → LATIN CAPITAL LETTER G	# 
+13C0 ;	0047 ;	MA	# ( Ꮐ → G ) CHEROKEE LETTER NAH → LATIN CAPITAL LETTER G	# 
+13F3 ;	0047 ;	MA	# ( Ᏻ → G ) CHEROKEE LETTER YU → LATIN CAPITAL LETTER G	# 
+A4D6 ;	0047 ;	MA	# ( ꓖ → G ) LISU LETTER GA → LATIN CAPITAL LETTER G	# 
+
+1DA2 ;	1D4D ;	MA	# ( ᶢ → ᵍ ) MODIFIER LETTER SMALL SCRIPT G → MODIFIER LETTER SMALL G	# 
+
+0260 ;	0067 0314 ;	MA	# ( ɠ → g̔ ) LATIN SMALL LETTER G WITH HOOK → LATIN SMALL LETTER G, COMBINING REVERSED COMMA ABOVE	# 
+
+01E7 ;	011F ;	MA	# ( ǧ → ğ ) LATIN SMALL LETTER G WITH CARON → LATIN SMALL LETTER G WITH BREVE	# 
+
+01E6 ;	011E ;	MA	# ( Ǧ → Ğ ) LATIN CAPITAL LETTER G WITH CARON → LATIN CAPITAL LETTER G WITH BREVE	# 
+
+01F5 ;	0123 ;	MA	# ( ǵ → ģ ) LATIN SMALL LETTER G WITH ACUTE → LATIN SMALL LETTER G WITH CEDILLA	# 
+
+01E5 ;	0067 0335 ;	MA	# ( ǥ → g̵ ) LATIN SMALL LETTER G WITH STROKE → LATIN SMALL LETTER G, COMBINING SHORT STROKE OVERLAY	# 
+
+01E4 ;	0047 0335 ;	MA	# ( Ǥ → G̵ ) LATIN CAPITAL LETTER G WITH STROKE → LATIN CAPITAL LETTER G, COMBINING SHORT STROKE OVERLAY	# 
+
+0193 ;	0047 0027 ;	MA	# ( Ɠ → G' ) LATIN CAPITAL LETTER G WITH HOOK → LATIN CAPITAL LETTER G, APOSTROPHE	# →Gʽ→
+
+050D ;	0262 ;	MA	# ( ԍ → ɢ ) CYRILLIC SMALL LETTER KOMI SJE → LATIN LETTER SMALL CAPITAL G	# 
+AB90 ;	0262 ;	MA	# ( ꮐ → ɢ ) CHEROKEE SMALL LETTER NAH → LATIN LETTER SMALL CAPITAL G	# 
+13FB ;	0262 ;	MA	# ( ᏻ → ɢ ) CHEROKEE SMALL LETTER YU → LATIN LETTER SMALL CAPITAL G	# 
+
+FF48 ;	0068 ;	MA	# ( ｈ → h ) FULLWIDTH LATIN SMALL LETTER H → LATIN SMALL LETTER H	# →һ→
+210E ;	0068 ;	MA	# ( ℎ → h ) PLANCK CONSTANT → LATIN SMALL LETTER H	# 
+1D421 ;	0068 ;	MA	# ( 𝐡 → h ) MATHEMATICAL BOLD SMALL H → LATIN SMALL LETTER H	# 
+1D489 ;	0068 ;	MA	# ( 𝒉 → h ) MATHEMATICAL BOLD ITALIC SMALL H → LATIN SMALL LETTER H	# 
+1D4BD ;	0068 ;	MA	# ( 𝒽 → h ) MATHEMATICAL SCRIPT SMALL H → LATIN SMALL LETTER H	# 
+1D4F1 ;	0068 ;	MA	# ( 𝓱 → h ) MATHEMATICAL BOLD SCRIPT SMALL H → LATIN SMALL LETTER H	# 
+1D525 ;	0068 ;	MA	# ( 𝔥 → h ) MATHEMATICAL FRAKTUR SMALL H → LATIN SMALL LETTER H	# 
+1D559 ;	0068 ;	MA	# ( 𝕙 → h ) MATHEMATICAL DOUBLE-STRUCK SMALL H → LATIN SMALL LETTER H	# 
+1D58D ;	0068 ;	MA	# ( 𝖍 → h ) MATHEMATICAL BOLD FRAKTUR SMALL H → LATIN SMALL LETTER H	# 
+1D5C1 ;	0068 ;	MA	# ( 𝗁 → h ) MATHEMATICAL SANS-SERIF SMALL H → LATIN SMALL LETTER H	# 
+1D5F5 ;	0068 ;	MA	# ( 𝗵 → h ) MATHEMATICAL SANS-SERIF BOLD SMALL H → LATIN SMALL LETTER H	# 
+1D629 ;	0068 ;	MA	# ( 𝘩 → h ) MATHEMATICAL SANS-SERIF ITALIC SMALL H → LATIN SMALL LETTER H	# 
+1D65D ;	0068 ;	MA	# ( 𝙝 → h ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL H → LATIN SMALL LETTER H	# 
+1D691 ;	0068 ;	MA	# ( 𝚑 → h ) MATHEMATICAL MONOSPACE SMALL H → LATIN SMALL LETTER H	# 
+04BB ;	0068 ;	MA	# ( һ → h ) CYRILLIC SMALL LETTER SHHA → LATIN SMALL LETTER H	# 
+0570 ;	0068 ;	MA	# ( հ → h ) ARMENIAN SMALL LETTER HO → LATIN SMALL LETTER H	# 
+13C2 ;	0068 ;	MA	# ( Ꮒ → h ) CHEROKEE LETTER NI → LATIN SMALL LETTER H	# 
+
+FF28 ;	0048 ;	MA	# ( Ｈ → H ) FULLWIDTH LATIN CAPITAL LETTER H → LATIN CAPITAL LETTER H	# →Η→
+210B ;	0048 ;	MA	# ( ℋ → H ) SCRIPT CAPITAL H → LATIN CAPITAL LETTER H	# 
+210C ;	0048 ;	MA	# ( ℌ → H ) BLACK-LETTER CAPITAL H → LATIN CAPITAL LETTER H	# 
+210D ;	0048 ;	MA	# ( ℍ → H ) DOUBLE-STRUCK CAPITAL H → LATIN CAPITAL LETTER H	# 
+1CCDD ;	0048 ;	MA	#* ( 𜳝 → H ) OUTLINED LATIN CAPITAL LETTER H → LATIN CAPITAL LETTER H	# 
+1D407 ;	0048 ;	MA	# ( 𝐇 → H ) MATHEMATICAL BOLD CAPITAL H → LATIN CAPITAL LETTER H	# 
+1D43B ;	0048 ;	MA	# ( 𝐻 → H ) MATHEMATICAL ITALIC CAPITAL H → LATIN CAPITAL LETTER H	# 
+1D46F ;	0048 ;	MA	# ( 𝑯 → H ) MATHEMATICAL BOLD ITALIC CAPITAL H → LATIN CAPITAL LETTER H	# 
+1D4D7 ;	0048 ;	MA	# ( 𝓗 → H ) MATHEMATICAL BOLD SCRIPT CAPITAL H → LATIN CAPITAL LETTER H	# 
+1D573 ;	0048 ;	MA	# ( 𝕳 → H ) MATHEMATICAL BOLD FRAKTUR CAPITAL H → LATIN CAPITAL LETTER H	# 
+1D5A7 ;	0048 ;	MA	# ( 𝖧 → H ) MATHEMATICAL SANS-SERIF CAPITAL H → LATIN CAPITAL LETTER H	# 
+1D5DB ;	0048 ;	MA	# ( 𝗛 → H ) MATHEMATICAL SANS-SERIF BOLD CAPITAL H → LATIN CAPITAL LETTER H	# 
+1D60F ;	0048 ;	MA	# ( 𝘏 → H ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL H → LATIN CAPITAL LETTER H	# 
+1D643 ;	0048 ;	MA	# ( 𝙃 → H ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL H → LATIN CAPITAL LETTER H	# 
+1D677 ;	0048 ;	MA	# ( 𝙷 → H ) MATHEMATICAL MONOSPACE CAPITAL H → LATIN CAPITAL LETTER H	# 
+0397 ;	0048 ;	MA	# ( Η → H ) GREEK CAPITAL LETTER ETA → LATIN CAPITAL LETTER H	# 
+1D6AE ;	0048 ;	MA	# ( 𝚮 → H ) MATHEMATICAL BOLD CAPITAL ETA → LATIN CAPITAL LETTER H	# →Η→
+1D6E8 ;	0048 ;	MA	# ( 𝛨 → H ) MATHEMATICAL ITALIC CAPITAL ETA → LATIN CAPITAL LETTER H	# →Η→
+1D722 ;	0048 ;	MA	# ( 𝜢 → H ) MATHEMATICAL BOLD ITALIC CAPITAL ETA → LATIN CAPITAL LETTER H	# →𝑯→
+1D75C ;	0048 ;	MA	# ( 𝝜 → H ) MATHEMATICAL SANS-SERIF BOLD CAPITAL ETA → LATIN CAPITAL LETTER H	# →Η→
+1D796 ;	0048 ;	MA	# ( 𝞖 → H ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ETA → LATIN CAPITAL LETTER H	# →Η→
+2C8E ;	0048 ;	MA	# ( Ⲏ → H ) COPTIC CAPITAL LETTER HATE → LATIN CAPITAL LETTER H	# →Η→
+041D ;	0048 ;	MA	# ( Н → H ) CYRILLIC CAPITAL LETTER EN → LATIN CAPITAL LETTER H	# 
+13BB ;	0048 ;	MA	# ( Ꮋ → H ) CHEROKEE LETTER MI → LATIN CAPITAL LETTER H	# 
+157C ;	0048 ;	MA	# ( ᕼ → H ) CANADIAN SYLLABICS NUNAVUT H → LATIN CAPITAL LETTER H	# 
+A4E7 ;	0048 ;	MA	# ( ꓧ → H ) LISU LETTER XA → LATIN CAPITAL LETTER H	# 
+102CF ;	0048 ;	MA	# ( 𐋏 → H ) CARIAN LETTER E2 → LATIN CAPITAL LETTER H	# 
+
+1D78 ;	1D34 ;	MA	# ( ᵸ → ᴴ ) MODIFIER LETTER CYRILLIC EN → MODIFIER LETTER CAPITAL H	# 
+
+0266 ;	0068 0314 ;	MA	# ( ɦ → h̔ ) LATIN SMALL LETTER H WITH HOOK → LATIN SMALL LETTER H, COMBINING REVERSED COMMA ABOVE	# 
+A695 ;	0068 0314 ;	MA	# ( ꚕ → h̔ ) CYRILLIC SMALL LETTER HWE → LATIN SMALL LETTER H, COMBINING REVERSED COMMA ABOVE	# →ɦ→
+13F2 ;	0068 0314 ;	MA	# ( Ᏺ → h̔ ) CHEROKEE LETTER YO → LATIN SMALL LETTER H, COMBINING REVERSED COMMA ABOVE	# 
+
+2C67 ;	0048 0329 ;	MA	# ( Ⱨ → H̩ ) LATIN CAPITAL LETTER H WITH DESCENDER → LATIN CAPITAL LETTER H, COMBINING VERTICAL LINE BELOW	# →Ң→→Н̩→
+04A2 ;	0048 0329 ;	MA	# ( Ң → H̩ ) CYRILLIC CAPITAL LETTER EN WITH DESCENDER → LATIN CAPITAL LETTER H, COMBINING VERTICAL LINE BELOW	# →Н̩→
+
+0127 ;	0068 0335 ;	MA	# ( ħ → h̵ ) LATIN SMALL LETTER H WITH STROKE → LATIN SMALL LETTER H, COMBINING SHORT STROKE OVERLAY	# 
+210F ;	0068 0335 ;	MA	# ( ℏ → h̵ ) PLANCK CONSTANT OVER TWO PI → LATIN SMALL LETTER H, COMBINING SHORT STROKE OVERLAY	# →ħ→
+045B ;	0068 0335 ;	MA	# ( ћ → h̵ ) CYRILLIC SMALL LETTER TSHE → LATIN SMALL LETTER H, COMBINING SHORT STROKE OVERLAY	# →ħ→
+
+0126 ;	0048 0335 ;	MA	# ( Ħ → H̵ ) LATIN CAPITAL LETTER H WITH STROKE → LATIN CAPITAL LETTER H, COMBINING SHORT STROKE OVERLAY	# 
+
+04C9 ;	0048 0326 ;	MA	# ( Ӊ → H̦ ) CYRILLIC CAPITAL LETTER EN WITH TAIL → LATIN CAPITAL LETTER H, COMBINING COMMA BELOW	# →Н̡→
+04C7 ;	0048 0326 ;	MA	# ( Ӈ → H̦ ) CYRILLIC CAPITAL LETTER EN WITH HOOK → LATIN CAPITAL LETTER H, COMBINING COMMA BELOW	# →Н̡→
+
+2C8F ;	029C ;	MA	# ( ⲏ → ʜ ) COPTIC SMALL LETTER HATE → LATIN LETTER SMALL CAPITAL H	# →н→
+043D ;	029C ;	MA	# ( н → ʜ ) CYRILLIC SMALL LETTER EN → LATIN LETTER SMALL CAPITAL H	# 
+AB8B ;	029C ;	MA	# ( ꮋ → ʜ ) CHEROKEE SMALL LETTER MI → LATIN LETTER SMALL CAPITAL H	# 
+
+04A3 ;	029C 0329 ;	MA	# ( ң → ʜ̩ ) CYRILLIC SMALL LETTER EN WITH DESCENDER → LATIN LETTER SMALL CAPITAL H, COMBINING VERTICAL LINE BELOW	# →н̩→
+
+04CA ;	029C 0326 ;	MA	# ( ӊ → ʜ̦ ) CYRILLIC SMALL LETTER EN WITH TAIL → LATIN LETTER SMALL CAPITAL H, COMBINING COMMA BELOW	# →н̡→
+04C8 ;	029C 0326 ;	MA	# ( ӈ → ʜ̦ ) CYRILLIC SMALL LETTER EN WITH HOOK → LATIN LETTER SMALL CAPITAL H, COMBINING COMMA BELOW	# →н̡→
+
+050A ;	01F6 ;	MA	# ( Ԋ → Ƕ ) CYRILLIC CAPITAL LETTER KOMI NJE → LATIN CAPITAL LETTER HWAIR	# 
+
+AB80 ;	2C76 ;	MA	# ( ꮀ → ⱶ ) CHEROKEE SMALL LETTER HO → LATIN SMALL LETTER HALF H	# 
+
+0370 ;	2C75 ;	MA	# ( Ͱ → Ⱶ ) GREEK CAPITAL LETTER HETA → LATIN CAPITAL LETTER HALF H	# →Ꮀ→
+13A8 ;	2C75 ;	MA	# ( Ꭸ → Ⱶ ) CHEROKEE LETTER GE → LATIN CAPITAL LETTER HALF H	# →Ͱ→→Ꮀ→
+13B0 ;	2C75 ;	MA	# ( Ꮀ → Ⱶ ) CHEROKEE LETTER HO → LATIN CAPITAL LETTER HALF H	# 
+A6B1 ;	2C75 ;	MA	# ( ꚱ → Ⱶ ) BAMUM LETTER NDAA → LATIN CAPITAL LETTER HALF H	# →Ͱ→→Ꮀ→
+
+A795 ;	A727 ;	MA	# ( ꞕ → ꜧ ) LATIN SMALL LETTER H WITH PALATAL HOOK → LATIN SMALL LETTER HENG	# 
+
+02DB ;	0069 ;	MA	#* ( ˛ → i ) OGONEK → LATIN SMALL LETTER I	# →ͺ→→ι→→ι→
+2373 ;	0069 ;	MA	#* ( ⍳ → i ) APL FUNCTIONAL SYMBOL IOTA → LATIN SMALL LETTER I	# →ɩ→
+FF49 ;	0069 ;	MA	# ( ｉ → i ) FULLWIDTH LATIN SMALL LETTER I → LATIN SMALL LETTER I	# →і→
+2170 ;	0069 ;	MA	# ( ⅰ → i ) SMALL ROMAN NUMERAL ONE → LATIN SMALL LETTER I	# 
+2139 ;	0069 ;	MA	# ( ℹ → i ) INFORMATION SOURCE → LATIN SMALL LETTER I	# 
+2148 ;	0069 ;	MA	# ( ⅈ → i ) DOUBLE-STRUCK ITALIC SMALL I → LATIN SMALL LETTER I	# 
+1D422 ;	0069 ;	MA	# ( 𝐢 → i ) MATHEMATICAL BOLD SMALL I → LATIN SMALL LETTER I	# 
+1D456 ;	0069 ;	MA	# ( 𝑖 → i ) MATHEMATICAL ITALIC SMALL I → LATIN SMALL LETTER I	# 
+1D48A ;	0069 ;	MA	# ( 𝒊 → i ) MATHEMATICAL BOLD ITALIC SMALL I → LATIN SMALL LETTER I	# 
+1D4BE ;	0069 ;	MA	# ( 𝒾 → i ) MATHEMATICAL SCRIPT SMALL I → LATIN SMALL LETTER I	# 
+1D4F2 ;	0069 ;	MA	# ( 𝓲 → i ) MATHEMATICAL BOLD SCRIPT SMALL I → LATIN SMALL LETTER I	# 
+1D526 ;	0069 ;	MA	# ( 𝔦 → i ) MATHEMATICAL FRAKTUR SMALL I → LATIN SMALL LETTER I	# 
+1D55A ;	0069 ;	MA	# ( 𝕚 → i ) MATHEMATICAL DOUBLE-STRUCK SMALL I → LATIN SMALL LETTER I	# 
+1D58E ;	0069 ;	MA	# ( 𝖎 → i ) MATHEMATICAL BOLD FRAKTUR SMALL I → LATIN SMALL LETTER I	# 
+1D5C2 ;	0069 ;	MA	# ( 𝗂 → i ) MATHEMATICAL SANS-SERIF SMALL I → LATIN SMALL LETTER I	# 
+1D5F6 ;	0069 ;	MA	# ( 𝗶 → i ) MATHEMATICAL SANS-SERIF BOLD SMALL I → LATIN SMALL LETTER I	# 
+1D62A ;	0069 ;	MA	# ( 𝘪 → i ) MATHEMATICAL SANS-SERIF ITALIC SMALL I → LATIN SMALL LETTER I	# 
+1D65E ;	0069 ;	MA	# ( 𝙞 → i ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL I → LATIN SMALL LETTER I	# 
+1D692 ;	0069 ;	MA	# ( 𝚒 → i ) MATHEMATICAL MONOSPACE SMALL I → LATIN SMALL LETTER I	# 
+0131 ;	0069 ;	MA	# ( ı → i ) LATIN SMALL LETTER DOTLESS I → LATIN SMALL LETTER I	# 
+1D6A4 ;	0069 ;	MA	# ( 𝚤 → i ) MATHEMATICAL ITALIC SMALL DOTLESS I → LATIN SMALL LETTER I	# →ı→
+026A ;	0069 ;	MA	# ( ɪ → i ) LATIN LETTER SMALL CAPITAL I → LATIN SMALL LETTER I	# →ı→
+0269 ;	0069 ;	MA	# ( ɩ → i ) LATIN SMALL LETTER IOTA → LATIN SMALL LETTER I	# 
+03B9 ;	0069 ;	MA	# ( ι → i ) GREEK SMALL LETTER IOTA → LATIN SMALL LETTER I	# 
+1FBE ;	0069 ;	MA	# ( ι → i ) GREEK PROSGEGRAMMENI → LATIN SMALL LETTER I	# →ι→
+037A ;	0069 ;	MA	#* ( ͺ → i ) GREEK YPOGEGRAMMENI → LATIN SMALL LETTER I	# →ι→→ι→
+1D6CA ;	0069 ;	MA	# ( 𝛊 → i ) MATHEMATICAL BOLD SMALL IOTA → LATIN SMALL LETTER I	# →ι→
+1D704 ;	0069 ;	MA	# ( 𝜄 → i ) MATHEMATICAL ITALIC SMALL IOTA → LATIN SMALL LETTER I	# →ι→
+1D73E ;	0069 ;	MA	# ( 𝜾 → i ) MATHEMATICAL BOLD ITALIC SMALL IOTA → LATIN SMALL LETTER I	# →ι→
+1D778 ;	0069 ;	MA	# ( 𝝸 → i ) MATHEMATICAL SANS-SERIF BOLD SMALL IOTA → LATIN SMALL LETTER I	# →ι→
+1D7B2 ;	0069 ;	MA	# ( 𝞲 → i ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL IOTA → LATIN SMALL LETTER I	# →ι→
+2C93 ;	0069 ;	MA	# ( ⲓ → i ) COPTIC SMALL LETTER IAUDA → LATIN SMALL LETTER I	# →ı→
+0456 ;	0069 ;	MA	# ( і → i ) CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I → LATIN SMALL LETTER I	# 
+A647 ;	0069 ;	MA	# ( ꙇ → i ) CYRILLIC SMALL LETTER IOTA → LATIN SMALL LETTER I	# →ι→
+0582 ;	0069 ;	MA	# ( ւ → i ) ARMENIAN SMALL LETTER YIWN → LATIN SMALL LETTER I	# →ı→
+AB75 ;	0069 ;	MA	# ( ꭵ → i ) CHEROKEE SMALL LETTER V → LATIN SMALL LETTER I	# 
+13A5 ;	0069 ;	MA	# ( Ꭵ → i ) CHEROKEE LETTER V → LATIN SMALL LETTER I	# 
+118C3 ;	0069 ;	MA	# ( 𑣃 → i ) WARANG CITI SMALL LETTER YU → LATIN SMALL LETTER I	# →ι→
+
+24DB ;	24BE ;	MA	#* ( ⓛ → Ⓘ ) CIRCLED LATIN SMALL LETTER L → CIRCLED LATIN CAPITAL LETTER I	# 
+
+2378 ;	0069 0332 ;	MA	#* ( ⍸ → i̲ ) APL FUNCTIONAL SYMBOL IOTA UNDERBAR → LATIN SMALL LETTER I, COMBINING LOW LINE	# →ι̲→
+
+01D0 ;	012D ;	MA	# ( ǐ → ĭ ) LATIN SMALL LETTER I WITH CARON → LATIN SMALL LETTER I WITH BREVE	# 
+
+01CF ;	012C ;	MA	# ( Ǐ → Ĭ ) LATIN CAPITAL LETTER I WITH CARON → LATIN CAPITAL LETTER I WITH BREVE	# 
+
+0268 ;	0069 0335 ;	MA	# ( ɨ → i̵ ) LATIN SMALL LETTER I WITH STROKE → LATIN SMALL LETTER I, COMBINING SHORT STROKE OVERLAY	# 
+1D7B ;	0069 0335 ;	MA	# ( ᵻ → i̵ ) LATIN SMALL CAPITAL LETTER I WITH STROKE → LATIN SMALL LETTER I, COMBINING SHORT STROKE OVERLAY	# →ɪ̵→
+1D7C ;	0069 0335 ;	MA	# ( ᵼ → i̵ ) LATIN SMALL LETTER IOTA WITH STROKE → LATIN SMALL LETTER I, COMBINING SHORT STROKE OVERLAY	# →ɩ̵→
+
+2171 ;	0069 0069 ;	MA	# ( ⅱ → ii ) SMALL ROMAN NUMERAL TWO → LATIN SMALL LETTER I, LATIN SMALL LETTER I	# 
+
+2172 ;	0069 0069 0069 ;	MA	# ( ⅲ → iii ) SMALL ROMAN NUMERAL THREE → LATIN SMALL LETTER I, LATIN SMALL LETTER I, LATIN SMALL LETTER I	# 
+
+0133 ;	0069 006A ;	MA	# ( ij → ij ) LATIN SMALL LIGATURE IJ → LATIN SMALL LETTER I, LATIN SMALL LETTER J	# 
+
+2173 ;	0069 0076 ;	MA	# ( ⅳ → iv ) SMALL ROMAN NUMERAL FOUR → LATIN SMALL LETTER I, LATIN SMALL LETTER V	# 
+
+2178 ;	0069 0078 ;	MA	# ( ⅸ → ix ) SMALL ROMAN NUMERAL NINE → LATIN SMALL LETTER I, LATIN SMALL LETTER X	# 
+
+FF4A ;	006A ;	MA	# ( ｊ → j ) FULLWIDTH LATIN SMALL LETTER J → LATIN SMALL LETTER J	# →ϳ→
+2149 ;	006A ;	MA	# ( ⅉ → j ) DOUBLE-STRUCK ITALIC SMALL J → LATIN SMALL LETTER J	# 
+1D423 ;	006A ;	MA	# ( 𝐣 → j ) MATHEMATICAL BOLD SMALL J → LATIN SMALL LETTER J	# 
+1D457 ;	006A ;	MA	# ( 𝑗 → j ) MATHEMATICAL ITALIC SMALL J → LATIN SMALL LETTER J	# 
+1D48B ;	006A ;	MA	# ( 𝒋 → j ) MATHEMATICAL BOLD ITALIC SMALL J → LATIN SMALL LETTER J	# 
+1D4BF ;	006A ;	MA	# ( 𝒿 → j ) MATHEMATICAL SCRIPT SMALL J → LATIN SMALL LETTER J	# 
+1D4F3 ;	006A ;	MA	# ( 𝓳 → j ) MATHEMATICAL BOLD SCRIPT SMALL J → LATIN SMALL LETTER J	# 
+1D527 ;	006A ;	MA	# ( 𝔧 → j ) MATHEMATICAL FRAKTUR SMALL J → LATIN SMALL LETTER J	# 
+1D55B ;	006A ;	MA	# ( 𝕛 → j ) MATHEMATICAL DOUBLE-STRUCK SMALL J → LATIN SMALL LETTER J	# 
+1D58F ;	006A ;	MA	# ( 𝖏 → j ) MATHEMATICAL BOLD FRAKTUR SMALL J → LATIN SMALL LETTER J	# 
+1D5C3 ;	006A ;	MA	# ( 𝗃 → j ) MATHEMATICAL SANS-SERIF SMALL J → LATIN SMALL LETTER J	# 
+1D5F7 ;	006A ;	MA	# ( 𝗷 → j ) MATHEMATICAL SANS-SERIF BOLD SMALL J → LATIN SMALL LETTER J	# 
+1D62B ;	006A ;	MA	# ( 𝘫 → j ) MATHEMATICAL SANS-SERIF ITALIC SMALL J → LATIN SMALL LETTER J	# 
+1D65F ;	006A ;	MA	# ( 𝙟 → j ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL J → LATIN SMALL LETTER J	# 
+1D693 ;	006A ;	MA	# ( 𝚓 → j ) MATHEMATICAL MONOSPACE SMALL J → LATIN SMALL LETTER J	# 
+03F3 ;	006A ;	MA	# ( ϳ → j ) GREEK LETTER YOT → LATIN SMALL LETTER J	# 
+0458 ;	006A ;	MA	# ( ј → j ) CYRILLIC SMALL LETTER JE → LATIN SMALL LETTER J	# 
+
+FF2A ;	004A ;	MA	# ( Ｊ → J ) FULLWIDTH LATIN CAPITAL LETTER J → LATIN CAPITAL LETTER J	# →Ј→
+1CCDF ;	004A ;	MA	#* ( 𜳟 → J ) OUTLINED LATIN CAPITAL LETTER J → LATIN CAPITAL LETTER J	# 
+1D409 ;	004A ;	MA	# ( 𝐉 → J ) MATHEMATICAL BOLD CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D43D ;	004A ;	MA	# ( 𝐽 → J ) MATHEMATICAL ITALIC CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D471 ;	004A ;	MA	# ( 𝑱 → J ) MATHEMATICAL BOLD ITALIC CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D4A5 ;	004A ;	MA	# ( 𝒥 → J ) MATHEMATICAL SCRIPT CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D4D9 ;	004A ;	MA	# ( 𝓙 → J ) MATHEMATICAL BOLD SCRIPT CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D50D ;	004A ;	MA	# ( 𝔍 → J ) MATHEMATICAL FRAKTUR CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D541 ;	004A ;	MA	# ( 𝕁 → J ) MATHEMATICAL DOUBLE-STRUCK CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D575 ;	004A ;	MA	# ( 𝕵 → J ) MATHEMATICAL BOLD FRAKTUR CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D5A9 ;	004A ;	MA	# ( 𝖩 → J ) MATHEMATICAL SANS-SERIF CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D5DD ;	004A ;	MA	# ( 𝗝 → J ) MATHEMATICAL SANS-SERIF BOLD CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D611 ;	004A ;	MA	# ( 𝘑 → J ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D645 ;	004A ;	MA	# ( 𝙅 → J ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL J → LATIN CAPITAL LETTER J	# 
+1D679 ;	004A ;	MA	# ( 𝙹 → J ) MATHEMATICAL MONOSPACE CAPITAL J → LATIN CAPITAL LETTER J	# 
+A7B2 ;	004A ;	MA	# ( Ʝ → J ) LATIN CAPITAL LETTER J WITH CROSSED-TAIL → LATIN CAPITAL LETTER J	# 
+037F ;	004A ;	MA	# ( Ϳ → J ) GREEK CAPITAL LETTER YOT → LATIN CAPITAL LETTER J	# 
+0408 ;	004A ;	MA	# ( Ј → J ) CYRILLIC CAPITAL LETTER JE → LATIN CAPITAL LETTER J	# 
+13AB ;	004A ;	MA	# ( Ꭻ → J ) CHEROKEE LETTER GU → LATIN CAPITAL LETTER J	# 
+148D ;	004A ;	MA	# ( ᒍ → J ) CANADIAN SYLLABICS CO → LATIN CAPITAL LETTER J	# 
+A4D9 ;	004A ;	MA	# ( ꓙ → J ) LISU LETTER JA → LATIN CAPITAL LETTER J	# 
+
+0249 ;	006A 0335 ;	MA	# ( ɉ → j̵ ) LATIN SMALL LETTER J WITH STROKE → LATIN SMALL LETTER J, COMBINING SHORT STROKE OVERLAY	# 
+
+0248 ;	004A 0335 ;	MA	# ( Ɉ → J̵ ) LATIN CAPITAL LETTER J WITH STROKE → LATIN CAPITAL LETTER J, COMBINING SHORT STROKE OVERLAY	# 
+
+1499 ;	004A 00B7 ;	MA	# ( ᒙ → J· ) CANADIAN SYLLABICS WEST-CREE CWO → LATIN CAPITAL LETTER J, MIDDLE DOT	# →ᒍᐧ→
+
+1D6A5 ;	0237 ;	MA	# ( 𝚥 → ȷ ) MATHEMATICAL ITALIC SMALL DOTLESS J → LATIN SMALL LETTER DOTLESS J	# 
+0575 ;	0237 ;	MA	# ( յ → ȷ ) ARMENIAN SMALL LETTER YI → LATIN SMALL LETTER DOTLESS J	# 
+
+AB7B ;	1D0A ;	MA	# ( ꭻ → ᴊ ) CHEROKEE SMALL LETTER GU → LATIN LETTER SMALL CAPITAL J	# 
+
+1D424 ;	006B ;	MA	# ( 𝐤 → k ) MATHEMATICAL BOLD SMALL K → LATIN SMALL LETTER K	# 
+1D458 ;	006B ;	MA	# ( 𝑘 → k ) MATHEMATICAL ITALIC SMALL K → LATIN SMALL LETTER K	# 
+1D48C ;	006B ;	MA	# ( 𝒌 → k ) MATHEMATICAL BOLD ITALIC SMALL K → LATIN SMALL LETTER K	# 
+1D4C0 ;	006B ;	MA	# ( 𝓀 → k ) MATHEMATICAL SCRIPT SMALL K → LATIN SMALL LETTER K	# 
+1D4F4 ;	006B ;	MA	# ( 𝓴 → k ) MATHEMATICAL BOLD SCRIPT SMALL K → LATIN SMALL LETTER K	# 
+1D528 ;	006B ;	MA	# ( 𝔨 → k ) MATHEMATICAL FRAKTUR SMALL K → LATIN SMALL LETTER K	# 
+1D55C ;	006B ;	MA	# ( 𝕜 → k ) MATHEMATICAL DOUBLE-STRUCK SMALL K → LATIN SMALL LETTER K	# 
+1D590 ;	006B ;	MA	# ( 𝖐 → k ) MATHEMATICAL BOLD FRAKTUR SMALL K → LATIN SMALL LETTER K	# 
+1D5C4 ;	006B ;	MA	# ( 𝗄 → k ) MATHEMATICAL SANS-SERIF SMALL K → LATIN SMALL LETTER K	# 
+1D5F8 ;	006B ;	MA	# ( 𝗸 → k ) MATHEMATICAL SANS-SERIF BOLD SMALL K → LATIN SMALL LETTER K	# 
+1D62C ;	006B ;	MA	# ( 𝘬 → k ) MATHEMATICAL SANS-SERIF ITALIC SMALL K → LATIN SMALL LETTER K	# 
+1D660 ;	006B ;	MA	# ( 𝙠 → k ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL K → LATIN SMALL LETTER K	# 
+1D694 ;	006B ;	MA	# ( 𝚔 → k ) MATHEMATICAL MONOSPACE SMALL K → LATIN SMALL LETTER K	# 
+
+212A ;	004B ;	MA	# ( K → K ) KELVIN SIGN → LATIN CAPITAL LETTER K	# 
+FF2B ;	004B ;	MA	# ( Ｋ → K ) FULLWIDTH LATIN CAPITAL LETTER K → LATIN CAPITAL LETTER K	# →Κ→
+1CCE0 ;	004B ;	MA	#* ( 𜳠 → K ) OUTLINED LATIN CAPITAL LETTER K → LATIN CAPITAL LETTER K	# 
+1D40A ;	004B ;	MA	# ( 𝐊 → K ) MATHEMATICAL BOLD CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D43E ;	004B ;	MA	# ( 𝐾 → K ) MATHEMATICAL ITALIC CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D472 ;	004B ;	MA	# ( 𝑲 → K ) MATHEMATICAL BOLD ITALIC CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D4A6 ;	004B ;	MA	# ( 𝒦 → K ) MATHEMATICAL SCRIPT CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D4DA ;	004B ;	MA	# ( 𝓚 → K ) MATHEMATICAL BOLD SCRIPT CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D50E ;	004B ;	MA	# ( 𝔎 → K ) MATHEMATICAL FRAKTUR CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D542 ;	004B ;	MA	# ( 𝕂 → K ) MATHEMATICAL DOUBLE-STRUCK CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D576 ;	004B ;	MA	# ( 𝕶 → K ) MATHEMATICAL BOLD FRAKTUR CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D5AA ;	004B ;	MA	# ( 𝖪 → K ) MATHEMATICAL SANS-SERIF CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D5DE ;	004B ;	MA	# ( 𝗞 → K ) MATHEMATICAL SANS-SERIF BOLD CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D612 ;	004B ;	MA	# ( 𝘒 → K ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D646 ;	004B ;	MA	# ( 𝙆 → K ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL K → LATIN CAPITAL LETTER K	# 
+1D67A ;	004B ;	MA	# ( 𝙺 → K ) MATHEMATICAL MONOSPACE CAPITAL K → LATIN CAPITAL LETTER K	# 
+039A ;	004B ;	MA	# ( Κ → K ) GREEK CAPITAL LETTER KAPPA → LATIN CAPITAL LETTER K	# 
+1D6B1 ;	004B ;	MA	# ( 𝚱 → K ) MATHEMATICAL BOLD CAPITAL KAPPA → LATIN CAPITAL LETTER K	# →Κ→
+1D6EB ;	004B ;	MA	# ( 𝛫 → K ) MATHEMATICAL ITALIC CAPITAL KAPPA → LATIN CAPITAL LETTER K	# →𝐾→
+1D725 ;	004B ;	MA	# ( 𝜥 → K ) MATHEMATICAL BOLD ITALIC CAPITAL KAPPA → LATIN CAPITAL LETTER K	# →𝑲→
+1D75F ;	004B ;	MA	# ( 𝝟 → K ) MATHEMATICAL SANS-SERIF BOLD CAPITAL KAPPA → LATIN CAPITAL LETTER K	# →Κ→
+1D799 ;	004B ;	MA	# ( 𝞙 → K ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL KAPPA → LATIN CAPITAL LETTER K	# →Κ→
+2C94 ;	004B ;	MA	# ( Ⲕ → K ) COPTIC CAPITAL LETTER KAPA → LATIN CAPITAL LETTER K	# →Κ→
+041A ;	004B ;	MA	# ( К → K ) CYRILLIC CAPITAL LETTER KA → LATIN CAPITAL LETTER K	# 
+13E6 ;	004B ;	MA	# ( Ꮶ → K ) CHEROKEE LETTER TSO → LATIN CAPITAL LETTER K	# 
+16D5 ;	004B ;	MA	# ( ᛕ → K ) RUNIC LETTER OPEN-P → LATIN CAPITAL LETTER K	# 
+A4D7 ;	004B ;	MA	# ( ꓗ → K ) LISU LETTER KA → LATIN CAPITAL LETTER K	# 
+10518 ;	004B ;	MA	# ( 𐔘 → K ) ELBASAN LETTER QE → LATIN CAPITAL LETTER K	# 
+
+0199 ;	006B 0314 ;	MA	# ( ƙ → k̔ ) LATIN SMALL LETTER K WITH HOOK → LATIN SMALL LETTER K, COMBINING REVERSED COMMA ABOVE	# 
+
+2C69 ;	004B 0329 ;	MA	# ( Ⱪ → K̩ ) LATIN CAPITAL LETTER K WITH DESCENDER → LATIN CAPITAL LETTER K, COMBINING VERTICAL LINE BELOW	# →Қ→→К̩→
+049A ;	004B 0329 ;	MA	# ( Қ → K̩ ) CYRILLIC CAPITAL LETTER KA WITH DESCENDER → LATIN CAPITAL LETTER K, COMBINING VERTICAL LINE BELOW	# →К̩→
+
+20AD ;	004B 0335 ;	MA	#* ( ₭ → K̵ ) KIP SIGN → LATIN CAPITAL LETTER K, COMBINING SHORT STROKE OVERLAY	# →K̶→
+A740 ;	004B 0335 ;	MA	# ( Ꝁ → K̵ ) LATIN CAPITAL LETTER K WITH STROKE → LATIN CAPITAL LETTER K, COMBINING SHORT STROKE OVERLAY	# →Ҟ→→К̵→
+049E ;	004B 0335 ;	MA	# ( Ҟ → K̵ ) CYRILLIC CAPITAL LETTER KA WITH STROKE → LATIN CAPITAL LETTER K, COMBINING SHORT STROKE OVERLAY	# →К̵→
+
+0198 ;	004B 0027 ;	MA	# ( Ƙ → K' ) LATIN CAPITAL LETTER K WITH HOOK → LATIN CAPITAL LETTER K, APOSTROPHE	# →Kʽ→
+
+05C0 ;	006C ;	MA	#* ( ‎׀‎ → l ) HEBREW PUNCTUATION PASEQ → LATIN SMALL LETTER L	# →|→
+007C ;	006C ;	MA	#* ( | → l ) VERTICAL LINE → LATIN SMALL LETTER L	# 
+2223 ;	006C ;	MA	#* ( ∣ → l ) DIVIDES → LATIN SMALL LETTER L	# →ǀ→
+23FD ;	006C ;	MA	#* ( ⏽ → l ) POWER ON SYMBOL → LATIN SMALL LETTER L	# →I→
+FFE8 ;	006C ;	MA	#* ( ￨ → l ) HALFWIDTH FORMS LIGHT VERTICAL → LATIN SMALL LETTER L	# →|→
+0031 ;	006C ;	MA	# ( 1 → l ) DIGIT ONE → LATIN SMALL LETTER L	# 
+0661 ;	006C ;	MA	# ( ‎١‎ → l ) ARABIC-INDIC DIGIT ONE → LATIN SMALL LETTER L	# →1→
+06F1 ;	006C ;	MA	# ( ۱ → l ) EXTENDED ARABIC-INDIC DIGIT ONE → LATIN SMALL LETTER L	# →1→
+10320 ;	006C ;	MA	#* ( 𐌠 → l ) OLD ITALIC NUMERAL ONE → LATIN SMALL LETTER L	# →𐌉→→I→
+1E8C7 ;	006C ;	MA	#* ( ‎𞣇‎ → l ) MENDE KIKAKUI DIGIT ONE → LATIN SMALL LETTER L	# 
+1CCF1 ;	006C ;	MA	# ( 𜳱 → l ) OUTLINED DIGIT ONE → LATIN SMALL LETTER L	# →1→
+1D7CF ;	006C ;	MA	# ( 𝟏 → l ) MATHEMATICAL BOLD DIGIT ONE → LATIN SMALL LETTER L	# →1→
+1D7D9 ;	006C ;	MA	# ( 𝟙 → l ) MATHEMATICAL DOUBLE-STRUCK DIGIT ONE → LATIN SMALL LETTER L	# →1→
+1D7E3 ;	006C ;	MA	# ( 𝟣 → l ) MATHEMATICAL SANS-SERIF DIGIT ONE → LATIN SMALL LETTER L	# →1→
+1D7ED ;	006C ;	MA	# ( 𝟭 → l ) MATHEMATICAL SANS-SERIF BOLD DIGIT ONE → LATIN SMALL LETTER L	# →1→
+1D7F7 ;	006C ;	MA	# ( 𝟷 → l ) MATHEMATICAL MONOSPACE DIGIT ONE → LATIN SMALL LETTER L	# →1→
+1FBF1 ;	006C ;	MA	# ( 🯱 → l ) SEGMENTED DIGIT ONE → LATIN SMALL LETTER L	# →1→
+0049 ;	006C ;	MA	# ( I → l ) LATIN CAPITAL LETTER I → LATIN SMALL LETTER L	# 
+FF29 ;	006C ;	MA	# ( Ｉ → l ) FULLWIDTH LATIN CAPITAL LETTER I → LATIN SMALL LETTER L	# →Ӏ→
+2160 ;	006C ;	MA	# ( Ⅰ → l ) ROMAN NUMERAL ONE → LATIN SMALL LETTER L	# →Ӏ→
+2110 ;	006C ;	MA	# ( ℐ → l ) SCRIPT CAPITAL I → LATIN SMALL LETTER L	# →I→
+2111 ;	006C ;	MA	# ( ℑ → l ) BLACK-LETTER CAPITAL I → LATIN SMALL LETTER L	# →I→
+1CCDE ;	006C ;	MA	#* ( 𜳞 → l ) OUTLINED LATIN CAPITAL LETTER I → LATIN SMALL LETTER L	# →I→
+1D408 ;	006C ;	MA	# ( 𝐈 → l ) MATHEMATICAL BOLD CAPITAL I → LATIN SMALL LETTER L	# →I→
+1D43C ;	006C ;	MA	# ( 𝐼 → l ) MATHEMATICAL ITALIC CAPITAL I → LATIN SMALL LETTER L	# →I→
+1D470 ;	006C ;	MA	# ( 𝑰 → l ) MATHEMATICAL BOLD ITALIC CAPITAL I → LATIN SMALL LETTER L	# →I→
+1D4D8 ;	006C ;	MA	# ( 𝓘 → l ) MATHEMATICAL BOLD SCRIPT CAPITAL I → LATIN SMALL LETTER L	# →I→
+1D540 ;	006C ;	MA	# ( 𝕀 → l ) MATHEMATICAL DOUBLE-STRUCK CAPITAL I → LATIN SMALL LETTER L	# →I→
+1D574 ;	006C ;	MA	# ( 𝕴 → l ) MATHEMATICAL BOLD FRAKTUR CAPITAL I → LATIN SMALL LETTER L	# →I→
+1D5A8 ;	006C ;	MA	# ( 𝖨 → l ) MATHEMATICAL SANS-SERIF CAPITAL I → LATIN SMALL LETTER L	# →I→
+1D5DC ;	006C ;	MA	# ( 𝗜 → l ) MATHEMATICAL SANS-SERIF BOLD CAPITAL I → LATIN SMALL LETTER L	# →I→
+1D610 ;	006C ;	MA	# ( 𝘐 → l ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL I → LATIN SMALL LETTER L	# →I→
+1D644 ;	006C ;	MA	# ( 𝙄 → l ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL I → LATIN SMALL LETTER L	# →I→
+1D678 ;	006C ;	MA	# ( 𝙸 → l ) MATHEMATICAL MONOSPACE CAPITAL I → LATIN SMALL LETTER L	# →I→
+0196 ;	006C ;	MA	# ( Ɩ → l ) LATIN CAPITAL LETTER IOTA → LATIN SMALL LETTER L	# 
+FF4C ;	006C ;	MA	# ( ｌ → l ) FULLWIDTH LATIN SMALL LETTER L → LATIN SMALL LETTER L	# →Ⅰ→→Ӏ→
+217C ;	006C ;	MA	# ( ⅼ → l ) SMALL ROMAN NUMERAL FIFTY → LATIN SMALL LETTER L	# 
+2113 ;	006C ;	MA	# ( ℓ → l ) SCRIPT SMALL L → LATIN SMALL LETTER L	# 
+1D425 ;	006C ;	MA	# ( 𝐥 → l ) MATHEMATICAL BOLD SMALL L → LATIN SMALL LETTER L	# 
+1D459 ;	006C ;	MA	# ( 𝑙 → l ) MATHEMATICAL ITALIC SMALL L → LATIN SMALL LETTER L	# 
+1D48D ;	006C ;	MA	# ( 𝒍 → l ) MATHEMATICAL BOLD ITALIC SMALL L → LATIN SMALL LETTER L	# 
+1D4C1 ;	006C ;	MA	# ( 𝓁 → l ) MATHEMATICAL SCRIPT SMALL L → LATIN SMALL LETTER L	# 
+1D4F5 ;	006C ;	MA	# ( 𝓵 → l ) MATHEMATICAL BOLD SCRIPT SMALL L → LATIN SMALL LETTER L	# 
+1D529 ;	006C ;	MA	# ( 𝔩 → l ) MATHEMATICAL FRAKTUR SMALL L → LATIN SMALL LETTER L	# 
+1D55D ;	006C ;	MA	# ( 𝕝 → l ) MATHEMATICAL DOUBLE-STRUCK SMALL L → LATIN SMALL LETTER L	# 
+1D591 ;	006C ;	MA	# ( 𝖑 → l ) MATHEMATICAL BOLD FRAKTUR SMALL L → LATIN SMALL LETTER L	# 
+1D5C5 ;	006C ;	MA	# ( 𝗅 → l ) MATHEMATICAL SANS-SERIF SMALL L → LATIN SMALL LETTER L	# 
+1D5F9 ;	006C ;	MA	# ( 𝗹 → l ) MATHEMATICAL SANS-SERIF BOLD SMALL L → LATIN SMALL LETTER L	# 
+1D62D ;	006C ;	MA	# ( 𝘭 → l ) MATHEMATICAL SANS-SERIF ITALIC SMALL L → LATIN SMALL LETTER L	# 
+1D661 ;	006C ;	MA	# ( 𝙡 → l ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL L → LATIN SMALL LETTER L	# 
+1D695 ;	006C ;	MA	# ( 𝚕 → l ) MATHEMATICAL MONOSPACE SMALL L → LATIN SMALL LETTER L	# 
+01C0 ;	006C ;	MA	# ( ǀ → l ) LATIN LETTER DENTAL CLICK → LATIN SMALL LETTER L	# 
+0399 ;	006C ;	MA	# ( Ι → l ) GREEK CAPITAL LETTER IOTA → LATIN SMALL LETTER L	# 
+1D6B0 ;	006C ;	MA	# ( 𝚰 → l ) MATHEMATICAL BOLD CAPITAL IOTA → LATIN SMALL LETTER L	# →Ι→
+1D6EA ;	006C ;	MA	# ( 𝛪 → l ) MATHEMATICAL ITALIC CAPITAL IOTA → LATIN SMALL LETTER L	# →Ι→
+1D724 ;	006C ;	MA	# ( 𝜤 → l ) MATHEMATICAL BOLD ITALIC CAPITAL IOTA → LATIN SMALL LETTER L	# →Ι→
+1D75E ;	006C ;	MA	# ( 𝝞 → l ) MATHEMATICAL SANS-SERIF BOLD CAPITAL IOTA → LATIN SMALL LETTER L	# →Ι→
+1D798 ;	006C ;	MA	# ( 𝞘 → l ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL IOTA → LATIN SMALL LETTER L	# →Ι→
+2C92 ;	006C ;	MA	# ( Ⲓ → l ) COPTIC CAPITAL LETTER IAUDA → LATIN SMALL LETTER L	# →Ӏ→
+0406 ;	006C ;	MA	# ( І → l ) CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I → LATIN SMALL LETTER L	# 
+04CF ;	006C ;	MA	# ( ӏ → l ) CYRILLIC SMALL LETTER PALOCHKA → LATIN SMALL LETTER L	# →I→
+04C0 ;	006C ;	MA	# ( Ӏ → l ) CYRILLIC LETTER PALOCHKA → LATIN SMALL LETTER L	# 
+05D5 ;	006C ;	MA	# ( ‎ו‎ → l ) HEBREW LETTER VAV → LATIN SMALL LETTER L	# 
+05DF ;	006C ;	MA	# ( ‎ן‎ → l ) HEBREW LETTER FINAL NUN → LATIN SMALL LETTER L	# 
+0627 ;	006C ;	MA	# ( ‎ا‎ → l ) ARABIC LETTER ALEF → LATIN SMALL LETTER L	# →1→
+1EE00 ;	006C ;	MA	# ( ‎𞸀‎ → l ) ARABIC MATHEMATICAL ALEF → LATIN SMALL LETTER L	# →‎ا‎→→1→
+1EE80 ;	006C ;	MA	# ( ‎𞺀‎ → l ) ARABIC MATHEMATICAL LOOPED ALEF → LATIN SMALL LETTER L	# →‎ا‎→→1→
+FE8E ;	006C ;	MA	# ( ‎ﺎ‎ → l ) ARABIC LETTER ALEF FINAL FORM → LATIN SMALL LETTER L	# →‎ا‎→→1→
+FE8D ;	006C ;	MA	# ( ‎ﺍ‎ → l ) ARABIC LETTER ALEF ISOLATED FORM → LATIN SMALL LETTER L	# →‎ا‎→→1→
+07CA ;	006C ;	MA	# ( ‎ߊ‎ → l ) NKO LETTER A → LATIN SMALL LETTER L	# →∣→→ǀ→
+2D4F ;	006C ;	MA	# ( ⵏ → l ) TIFINAGH LETTER YAN → LATIN SMALL LETTER L	# →Ӏ→
+16C1 ;	006C ;	MA	# ( ᛁ → l ) RUNIC LETTER ISAZ IS ISS I → LATIN SMALL LETTER L	# →I→
+A4F2 ;	006C ;	MA	# ( ꓲ → l ) LISU LETTER I → LATIN SMALL LETTER L	# →I→
+16F28 ;	006C ;	MA	# ( 𖼨 → l ) MIAO LETTER GHA → LATIN SMALL LETTER L	# →I→
+1028A ;	006C ;	MA	# ( 𐊊 → l ) LYCIAN LETTER J → LATIN SMALL LETTER L	# →I→
+10309 ;	006C ;	MA	# ( 𐌉 → l ) OLD ITALIC LETTER I → LATIN SMALL LETTER L	# →I→
+11DDA ;	006C ;	MA	# ( 𑷚 → l ) TOLONG SIKI SIGN HECAKA → LATIN SMALL LETTER L	# →|→
+11DE1 ;	006C ;	MA	# ( 𑷡 → l ) TOLONG SIKI DIGIT ONE → LATIN SMALL LETTER L	# →|→
+16EAA ;	006C ;	MA	# ( 𖺪 → l ) BERIA ERFE CAPITAL LETTER LAKKO → LATIN SMALL LETTER L	# →I→
+
+1D22A ;	004C ;	MA	#* ( 𝈪 → L ) GREEK INSTRUMENTAL NOTATION SYMBOL-23 → LATIN CAPITAL LETTER L	# 
+216C ;	004C ;	MA	# ( Ⅼ → L ) ROMAN NUMERAL FIFTY → LATIN CAPITAL LETTER L	# 
+2112 ;	004C ;	MA	# ( ℒ → L ) SCRIPT CAPITAL L → LATIN CAPITAL LETTER L	# 
+1CCE1 ;	004C ;	MA	#* ( 𜳡 → L ) OUTLINED LATIN CAPITAL LETTER L → LATIN CAPITAL LETTER L	# 
+1D40B ;	004C ;	MA	# ( 𝐋 → L ) MATHEMATICAL BOLD CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D43F ;	004C ;	MA	# ( 𝐿 → L ) MATHEMATICAL ITALIC CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D473 ;	004C ;	MA	# ( 𝑳 → L ) MATHEMATICAL BOLD ITALIC CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D4DB ;	004C ;	MA	# ( 𝓛 → L ) MATHEMATICAL BOLD SCRIPT CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D50F ;	004C ;	MA	# ( 𝔏 → L ) MATHEMATICAL FRAKTUR CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D543 ;	004C ;	MA	# ( 𝕃 → L ) MATHEMATICAL DOUBLE-STRUCK CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D577 ;	004C ;	MA	# ( 𝕷 → L ) MATHEMATICAL BOLD FRAKTUR CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D5AB ;	004C ;	MA	# ( 𝖫 → L ) MATHEMATICAL SANS-SERIF CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D5DF ;	004C ;	MA	# ( 𝗟 → L ) MATHEMATICAL SANS-SERIF BOLD CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D613 ;	004C ;	MA	# ( 𝘓 → L ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D647 ;	004C ;	MA	# ( 𝙇 → L ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL L → LATIN CAPITAL LETTER L	# 
+1D67B ;	004C ;	MA	# ( 𝙻 → L ) MATHEMATICAL MONOSPACE CAPITAL L → LATIN CAPITAL LETTER L	# 
+2CD0 ;	004C ;	MA	# ( Ⳑ → L ) COPTIC CAPITAL LETTER L-SHAPED HA → LATIN CAPITAL LETTER L	# 
+13DE ;	004C ;	MA	# ( Ꮮ → L ) CHEROKEE LETTER TLE → LATIN CAPITAL LETTER L	# 
+14AA ;	004C ;	MA	# ( ᒪ → L ) CANADIAN SYLLABICS MA → LATIN CAPITAL LETTER L	# 
+A4E1 ;	004C ;	MA	# ( ꓡ → L ) LISU LETTER LA → LATIN CAPITAL LETTER L	# 
+16F16 ;	004C ;	MA	# ( 𖼖 → L ) MIAO LETTER LA → LATIN CAPITAL LETTER L	# 
+118A3 ;	004C ;	MA	# ( 𑢣 → L ) WARANG CITI CAPITAL LETTER YU → LATIN CAPITAL LETTER L	# 
+118B2 ;	004C ;	MA	# ( 𑢲 → L ) WARANG CITI CAPITAL LETTER TTE → LATIN CAPITAL LETTER L	# 
+1041B ;	004C ;	MA	# ( 𐐛 → L ) DESERET CAPITAL LETTER ETH → LATIN CAPITAL LETTER L	# 
+10526 ;	004C ;	MA	# ( 𐔦 → L ) ELBASAN LETTER GHAMMA → LATIN CAPITAL LETTER L	# 
+
+FD3C ;	006C 030B ;	MA	# ( ‎ﴼ‎ → l̋ ) ARABIC LIGATURE ALEF WITH FATHATAN FINAL FORM → LATIN SMALL LETTER L, COMBINING DOUBLE ACUTE ACCENT	# →‎اً‎→
+FD3D ;	006C 030B ;	MA	# ( ‎ﴽ‎ → l̋ ) ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM → LATIN SMALL LETTER L, COMBINING DOUBLE ACUTE ACCENT	# →‎اً‎→
+
+0142 ;	006C 0338 ;	MA	# ( ł → l̸ ) LATIN SMALL LETTER L WITH STROKE → LATIN SMALL LETTER L, COMBINING LONG SOLIDUS OVERLAY	# →l̷→
+
+0141 ;	004C 0338 ;	MA	# ( Ł → L̸ ) LATIN CAPITAL LETTER L WITH STROKE → LATIN CAPITAL LETTER L, COMBINING LONG SOLIDUS OVERLAY	# →L̷→
+
+026D ;	006C 0328 ;	MA	# ( ɭ → l̨ ) LATIN SMALL LETTER L WITH RETROFLEX HOOK → LATIN SMALL LETTER L, COMBINING OGONEK	# →l̢→
+
+0197 ;	006C 0335 ;	MA	# ( Ɨ → l̵ ) LATIN CAPITAL LETTER I WITH STROKE → LATIN SMALL LETTER L, COMBINING SHORT STROKE OVERLAY	# →ƚ→
+019A ;	006C 0335 ;	MA	# ( ƚ → l̵ ) LATIN SMALL LETTER L WITH BAR → LATIN SMALL LETTER L, COMBINING SHORT STROKE OVERLAY	# 
+
+026B ;	006C 0334 ;	MA	# ( ɫ → l̴ ) LATIN SMALL LETTER L WITH MIDDLE TILDE → LATIN SMALL LETTER L, COMBINING TILDE OVERLAY	# 
+
+0625 ;	006C 0655 ;	MA	# ( ‎إ‎ → lٕ ) ARABIC LETTER ALEF WITH HAMZA BELOW → LATIN SMALL LETTER L, ARABIC HAMZA BELOW	# →‎ٳ‎→→‎اٟ‎→
+FE88 ;	006C 0655 ;	MA	# ( ‎ﺈ‎ → lٕ ) ARABIC LETTER ALEF WITH HAMZA BELOW FINAL FORM → LATIN SMALL LETTER L, ARABIC HAMZA BELOW	# →‎إ‎→→‎ٳ‎→→‎اٟ‎→
+FE87 ;	006C 0655 ;	MA	# ( ‎ﺇ‎ → lٕ ) ARABIC LETTER ALEF WITH HAMZA BELOW ISOLATED FORM → LATIN SMALL LETTER L, ARABIC HAMZA BELOW	# →‎إ‎→→‎ٳ‎→→‎اٟ‎→
+0673 ;	006C 0655 ;	MA	# ( ‎ٳ‎ → lٕ ) ARABIC LETTER ALEF WITH WAVY HAMZA BELOW → LATIN SMALL LETTER L, ARABIC HAMZA BELOW	# →‎اٟ‎→
+
+0140 ;	006C 00B7 ;	MA	# ( ŀ → l· ) LATIN SMALL LETTER L WITH MIDDLE DOT → LATIN SMALL LETTER L, MIDDLE DOT	# 
+013F ;	006C 00B7 ;	MA	# ( Ŀ → l· ) LATIN CAPITAL LETTER L WITH MIDDLE DOT → LATIN SMALL LETTER L, MIDDLE DOT	# →L·→→ᒪ·→→ᒪᐧ→→ᒷ→→1ᐧ→
+14B7 ;	006C 00B7 ;	MA	# ( ᒷ → l· ) CANADIAN SYLLABICS WEST-CREE MWA → LATIN SMALL LETTER L, MIDDLE DOT	# →1ᐧ→
+
+1F102 ;	006C 002C ;	MA	#* ( 🄂 → l, ) DIGIT ONE COMMA → LATIN SMALL LETTER L, COMMA	# →1,→
+
+2488 ;	006C 002E ;	MA	#* ( ⒈ → l. ) DIGIT ONE FULL STOP → LATIN SMALL LETTER L, FULL STOP	# →1.→
+
+05F1 ;	006C 0027 ;	MA	# ( ‎ױ‎ → l' ) HEBREW LIGATURE YIDDISH VAV YOD → LATIN SMALL LETTER L, APOSTROPHE	# →‎וי‎→
+
+2493 ;	006C 0032 002E ;	MA	#* ( ⒓ → l2. ) NUMBER TWELVE FULL STOP → LATIN SMALL LETTER L, DIGIT TWO, FULL STOP	# →12.→
+
+33EB ;	006C 0032 65E5 ;	MA	#* ( ㏫ → l2日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWELVE → LATIN SMALL LETTER L, DIGIT TWO, CJK UNIFIED IDEOGRAPH-65E5	# →12日→
+
+32CB ;	006C 0032 6708 ;	MA	#* ( ㋋ → l2月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DECEMBER → LATIN SMALL LETTER L, DIGIT TWO, CJK UNIFIED IDEOGRAPH-6708	# →12月→
+
+3364 ;	006C 0032 70B9 ;	MA	#* ( ㍤ → l2点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWELVE → LATIN SMALL LETTER L, DIGIT TWO, CJK UNIFIED IDEOGRAPH-70B9	# →12点→
+
+2494 ;	006C 0033 002E ;	MA	#* ( ⒔ → l3. ) NUMBER THIRTEEN FULL STOP → LATIN SMALL LETTER L, DIGIT THREE, FULL STOP	# →13.→
+
+33EC ;	006C 0033 65E5 ;	MA	#* ( ㏬ → l3日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTEEN → LATIN SMALL LETTER L, DIGIT THREE, CJK UNIFIED IDEOGRAPH-65E5	# →13日→
+
+3365 ;	006C 0033 70B9 ;	MA	#* ( ㍥ → l3点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR THIRTEEN → LATIN SMALL LETTER L, DIGIT THREE, CJK UNIFIED IDEOGRAPH-70B9	# →13点→
+
+2495 ;	006C 0034 002E ;	MA	#* ( ⒕ → l4. ) NUMBER FOURTEEN FULL STOP → LATIN SMALL LETTER L, DIGIT FOUR, FULL STOP	# →14.→
+
+33ED ;	006C 0034 65E5 ;	MA	#* ( ㏭ → l4日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FOURTEEN → LATIN SMALL LETTER L, DIGIT FOUR, CJK UNIFIED IDEOGRAPH-65E5	# →14日→
+
+3366 ;	006C 0034 70B9 ;	MA	#* ( ㍦ → l4点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FOURTEEN → LATIN SMALL LETTER L, DIGIT FOUR, CJK UNIFIED IDEOGRAPH-70B9	# →14点→
+
+2496 ;	006C 0035 002E ;	MA	#* ( ⒖ → l5. ) NUMBER FIFTEEN FULL STOP → LATIN SMALL LETTER L, DIGIT FIVE, FULL STOP	# →15.→
+
+33EE ;	006C 0035 65E5 ;	MA	#* ( ㏮ → l5日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FIFTEEN → LATIN SMALL LETTER L, DIGIT FIVE, CJK UNIFIED IDEOGRAPH-65E5	# →15日→
+
+3367 ;	006C 0035 70B9 ;	MA	#* ( ㍧ → l5点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FIFTEEN → LATIN SMALL LETTER L, DIGIT FIVE, CJK UNIFIED IDEOGRAPH-70B9	# →15点→
+
+2497 ;	006C 0036 002E ;	MA	#* ( ⒗ → l6. ) NUMBER SIXTEEN FULL STOP → LATIN SMALL LETTER L, DIGIT SIX, FULL STOP	# →16.→
+
+33EF ;	006C 0036 65E5 ;	MA	#* ( ㏯ → l6日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SIXTEEN → LATIN SMALL LETTER L, DIGIT SIX, CJK UNIFIED IDEOGRAPH-65E5	# →16日→
+
+3368 ;	006C 0036 70B9 ;	MA	#* ( ㍨ → l6点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SIXTEEN → LATIN SMALL LETTER L, DIGIT SIX, CJK UNIFIED IDEOGRAPH-70B9	# →16点→
+
+2498 ;	006C 0037 002E ;	MA	#* ( ⒘ → l7. ) NUMBER SEVENTEEN FULL STOP → LATIN SMALL LETTER L, DIGIT SEVEN, FULL STOP	# →17.→
+
+33F0 ;	006C 0037 65E5 ;	MA	#* ( ㏰ → l7日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SEVENTEEN → LATIN SMALL LETTER L, DIGIT SEVEN, CJK UNIFIED IDEOGRAPH-65E5	# →17日→
+
+3369 ;	006C 0037 70B9 ;	MA	#* ( ㍩ → l7点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SEVENTEEN → LATIN SMALL LETTER L, DIGIT SEVEN, CJK UNIFIED IDEOGRAPH-70B9	# →17点→
+
+2499 ;	006C 0038 002E ;	MA	#* ( ⒙ → l8. ) NUMBER EIGHTEEN FULL STOP → LATIN SMALL LETTER L, DIGIT EIGHT, FULL STOP	# →18.→
+
+33F1 ;	006C 0038 65E5 ;	MA	#* ( ㏱ → l8日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY EIGHTEEN → LATIN SMALL LETTER L, DIGIT EIGHT, CJK UNIFIED IDEOGRAPH-65E5	# →18日→
+
+336A ;	006C 0038 70B9 ;	MA	#* ( ㍪ → l8点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR EIGHTEEN → LATIN SMALL LETTER L, DIGIT EIGHT, CJK UNIFIED IDEOGRAPH-70B9	# →18点→
+
+249A ;	006C 0039 002E ;	MA	#* ( ⒚ → l9. ) NUMBER NINETEEN FULL STOP → LATIN SMALL LETTER L, DIGIT NINE, FULL STOP	# →19.→
+
+33F2 ;	006C 0039 65E5 ;	MA	#* ( ㏲ → l9日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY NINETEEN → LATIN SMALL LETTER L, DIGIT NINE, CJK UNIFIED IDEOGRAPH-65E5	# →19日→
+
+336B ;	006C 0039 70B9 ;	MA	#* ( ㍫ → l9点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR NINETEEN → LATIN SMALL LETTER L, DIGIT NINE, CJK UNIFIED IDEOGRAPH-70B9	# →19点→
+
+01C9 ;	006C 006A ;	MA	# ( lj → lj ) LATIN SMALL LETTER LJ → LATIN SMALL LETTER L, LATIN SMALL LETTER J	# 
+
+0132 ;	006C 004A ;	MA	# ( IJ → lJ ) LATIN CAPITAL LIGATURE IJ → LATIN SMALL LETTER L, LATIN CAPITAL LETTER J	# →IJ→
+
+01C8 ;	004C 006A ;	MA	# ( Lj → Lj ) LATIN CAPITAL LETTER L WITH SMALL LETTER J → LATIN CAPITAL LETTER L, LATIN SMALL LETTER J	# 
+
+01C7 ;	004C 004A ;	MA	# ( LJ → LJ ) LATIN CAPITAL LETTER LJ → LATIN CAPITAL LETTER L, LATIN CAPITAL LETTER J	# 
+
+2016 ;	006C 006C ;	MA	#* ( ‖ → ll ) DOUBLE VERTICAL LINE → LATIN SMALL LETTER L, LATIN SMALL LETTER L	# →∥→→||→
+2225 ;	006C 006C ;	MA	#* ( ∥ → ll ) PARALLEL TO → LATIN SMALL LETTER L, LATIN SMALL LETTER L	# →||→
+2161 ;	006C 006C ;	MA	# ( Ⅱ → ll ) ROMAN NUMERAL TWO → LATIN SMALL LETTER L, LATIN SMALL LETTER L	# →II→
+01C1 ;	006C 006C ;	MA	# ( ǁ → ll ) LATIN LETTER LATERAL CLICK → LATIN SMALL LETTER L, LATIN SMALL LETTER L	# →‖→→∥→→||→
+05F0 ;	006C 006C ;	MA	# ( ‎װ‎ → ll ) HEBREW LIGATURE YIDDISH DOUBLE VAV → LATIN SMALL LETTER L, LATIN SMALL LETTER L	# →‎וו‎→
+
+10199 ;	006C 0335 006C 0335 ;	MA	#* ( 𐆙 → l̵l̵ ) ROMAN DUPONDIUS SIGN → LATIN SMALL LETTER L, COMBINING SHORT STROKE OVERLAY, LATIN SMALL LETTER L, COMBINING SHORT STROKE OVERLAY	# →I̶I̶→
+
+2492 ;	006C 006C 002E ;	MA	#* ( ⒒ → ll. ) NUMBER ELEVEN FULL STOP → LATIN SMALL LETTER L, LATIN SMALL LETTER L, FULL STOP	# →11.→
+
+2162 ;	006C 006C 006C ;	MA	# ( Ⅲ → lll ) ROMAN NUMERAL THREE → LATIN SMALL LETTER L, LATIN SMALL LETTER L, LATIN SMALL LETTER L	# →III→
+
+10198 ;	006C 0335 006C 0335 0053 0335 ;	MA	#* ( 𐆘 → l̵l̵S̵ ) ROMAN SESTERTIUS SIGN → LATIN SMALL LETTER L, COMBINING SHORT STROKE OVERLAY, LATIN SMALL LETTER L, COMBINING SHORT STROKE OVERLAY, LATIN CAPITAL LETTER S, COMBINING SHORT STROKE OVERLAY	# →I̶I̶S̶→
+
+33EA ;	006C 006C 65E5 ;	MA	#* ( ㏪ → ll日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ELEVEN → LATIN SMALL LETTER L, LATIN SMALL LETTER L, CJK UNIFIED IDEOGRAPH-65E5	# →11日→
+
+32CA ;	006C 006C 6708 ;	MA	#* ( ㋊ → ll月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR NOVEMBER → LATIN SMALL LETTER L, LATIN SMALL LETTER L, CJK UNIFIED IDEOGRAPH-6708	# →11月→
+
+3363 ;	006C 006C 70B9 ;	MA	#* ( ㍣ → ll点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ELEVEN → LATIN SMALL LETTER L, LATIN SMALL LETTER L, CJK UNIFIED IDEOGRAPH-70B9	# →11点→
+
+042E ;	006C 004F ;	MA	# ( Ю → lO ) CYRILLIC CAPITAL LETTER YU → LATIN SMALL LETTER L, LATIN CAPITAL LETTER O	# →IO→
+
+2491 ;	006C 004F 002E ;	MA	#* ( ⒑ → lO. ) NUMBER TEN FULL STOP → LATIN SMALL LETTER L, LATIN CAPITAL LETTER O, FULL STOP	# →10.→
+
+33E9 ;	006C 004F 65E5 ;	MA	#* ( ㏩ → lO日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TEN → LATIN SMALL LETTER L, LATIN CAPITAL LETTER O, CJK UNIFIED IDEOGRAPH-65E5	# →10日→
+
+32C9 ;	006C 004F 6708 ;	MA	#* ( ㋉ → lO月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR OCTOBER → LATIN SMALL LETTER L, LATIN CAPITAL LETTER O, CJK UNIFIED IDEOGRAPH-6708	# →10月→
+
+3362 ;	006C 004F 70B9 ;	MA	#* ( ㍢ → lO点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TEN → LATIN SMALL LETTER L, LATIN CAPITAL LETTER O, CJK UNIFIED IDEOGRAPH-70B9	# →10点→
+
+02AA ;	006C 0073 ;	MA	# ( ʪ → ls ) LATIN SMALL LETTER LS DIGRAPH → LATIN SMALL LETTER L, LATIN SMALL LETTER S	# 
+
+20B6 ;	006C 0074 ;	MA	#* ( ₶ → lt ) LIVRE TOURNOIS SIGN → LATIN SMALL LETTER L, LATIN SMALL LETTER T	# 
+
+2163 ;	006C 0056 ;	MA	# ( Ⅳ → lV ) ROMAN NUMERAL FOUR → LATIN SMALL LETTER L, LATIN CAPITAL LETTER V	# →IV→
+
+2168 ;	006C 0058 ;	MA	# ( Ⅸ → lX ) ROMAN NUMERAL NINE → LATIN SMALL LETTER L, LATIN CAPITAL LETTER X	# →IX→
+
+026E ;	006C 021D ;	MA	# ( ɮ → lȝ ) LATIN SMALL LETTER LEZH → LATIN SMALL LETTER L, LATIN SMALL LETTER YOGH	# →lʒ→
+
+02AB ;	006C 007A ;	MA	# ( ʫ → lz ) LATIN SMALL LETTER LZ DIGRAPH → LATIN SMALL LETTER L, LATIN SMALL LETTER Z	# 
+
+0675 ;	006C 0674 ;	MA	# ( ‎ٵ‎ → ‎lٴ‎ ) ARABIC LETTER HIGH HAMZA ALEF → LATIN SMALL LETTER L, ARABIC LETTER HIGH HAMZA	# →‎اٴ‎→
+0623 ;	006C 0674 ;	MA	# ( ‎أ‎ → ‎lٴ‎ ) ARABIC LETTER ALEF WITH HAMZA ABOVE → LATIN SMALL LETTER L, ARABIC LETTER HIGH HAMZA	# →‎ٵ‎→→‎اٴ‎→
+FE84 ;	006C 0674 ;	MA	# ( ‎ﺄ‎ → ‎lٴ‎ ) ARABIC LETTER ALEF WITH HAMZA ABOVE FINAL FORM → LATIN SMALL LETTER L, ARABIC LETTER HIGH HAMZA	# →‎أ‎→→‎ٵ‎→→‎اٴ‎→
+FE83 ;	006C 0674 ;	MA	# ( ‎ﺃ‎ → ‎lٴ‎ ) ARABIC LETTER ALEF WITH HAMZA ABOVE ISOLATED FORM → LATIN SMALL LETTER L, ARABIC LETTER HIGH HAMZA	# →‎ٵ‎→→‎اٴ‎→
+0672 ;	006C 0674 ;	MA	# ( ‎ٲ‎ → ‎lٴ‎ ) ARABIC LETTER ALEF WITH WAVY HAMZA ABOVE → LATIN SMALL LETTER L, ARABIC LETTER HIGH HAMZA	# →‎أ‎→→‎ٵ‎→→‎اٴ‎→
+
+FDF3 ;	006C 0643 0628 0631 ;	MA	# ( ‎ﷳ‎ → ‎lكبر‎ ) ARABIC LIGATURE AKBAR ISOLATED FORM → LATIN SMALL LETTER L, ARABIC LETTER KAF, ARABIC LETTER BEH, ARABIC LETTER REH	# →‎اكبر‎→
+
+FDF2 ;	006C 0644 0644 0651 0670 006F ;	MA	# ( ‎ﷲ‎ → ‎lللّٰo‎ ) ARABIC LIGATURE ALLAH ISOLATED FORM → LATIN SMALL LETTER L, ARABIC LETTER LAM, ARABIC LETTER LAM, ARABIC SHADDA, ARABIC LETTER SUPERSCRIPT ALEF, LATIN SMALL LETTER O	# →‎اللّٰه‎→
+
+33E0 ;	006C 65E5 ;	MA	#* ( ㏠ → l日 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ONE → LATIN SMALL LETTER L, CJK UNIFIED IDEOGRAPH-65E5	# →1日→
+
+32C0 ;	006C 6708 ;	MA	#* ( ㋀ → l月 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY → LATIN SMALL LETTER L, CJK UNIFIED IDEOGRAPH-6708	# →1月→
+
+3359 ;	006C 70B9 ;	MA	#* ( ㍙ → l点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ONE → LATIN SMALL LETTER L, CJK UNIFIED IDEOGRAPH-70B9	# →1点→
+
+2CD1 ;	029F ;	MA	# ( ⳑ → ʟ ) COPTIC SMALL LETTER L-SHAPED HA → LATIN LETTER SMALL CAPITAL L	# 
+ABAE ;	029F ;	MA	# ( ꮮ → ʟ ) CHEROKEE SMALL LETTER TLE → LATIN LETTER SMALL CAPITAL L	# 
+10443 ;	029F ;	MA	# ( 𐑃 → ʟ ) DESERET SMALL LETTER ETH → LATIN LETTER SMALL CAPITAL L	# 
+
+FF2D ;	004D ;	MA	# ( Ｍ → M ) FULLWIDTH LATIN CAPITAL LETTER M → LATIN CAPITAL LETTER M	# →Μ→
+216F ;	004D ;	MA	# ( Ⅿ → M ) ROMAN NUMERAL ONE THOUSAND → LATIN CAPITAL LETTER M	# 
+2133 ;	004D ;	MA	# ( ℳ → M ) SCRIPT CAPITAL M → LATIN CAPITAL LETTER M	# 
+1CCE2 ;	004D ;	MA	#* ( 𜳢 → M ) OUTLINED LATIN CAPITAL LETTER M → LATIN CAPITAL LETTER M	# 
+1D40C ;	004D ;	MA	# ( 𝐌 → M ) MATHEMATICAL BOLD CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D440 ;	004D ;	MA	# ( 𝑀 → M ) MATHEMATICAL ITALIC CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D474 ;	004D ;	MA	# ( 𝑴 → M ) MATHEMATICAL BOLD ITALIC CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D4DC ;	004D ;	MA	# ( 𝓜 → M ) MATHEMATICAL BOLD SCRIPT CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D510 ;	004D ;	MA	# ( 𝔐 → M ) MATHEMATICAL FRAKTUR CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D544 ;	004D ;	MA	# ( 𝕄 → M ) MATHEMATICAL DOUBLE-STRUCK CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D578 ;	004D ;	MA	# ( 𝕸 → M ) MATHEMATICAL BOLD FRAKTUR CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D5AC ;	004D ;	MA	# ( 𝖬 → M ) MATHEMATICAL SANS-SERIF CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D5E0 ;	004D ;	MA	# ( 𝗠 → M ) MATHEMATICAL SANS-SERIF BOLD CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D614 ;	004D ;	MA	# ( 𝘔 → M ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D648 ;	004D ;	MA	# ( 𝙈 → M ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL M → LATIN CAPITAL LETTER M	# 
+1D67C ;	004D ;	MA	# ( 𝙼 → M ) MATHEMATICAL MONOSPACE CAPITAL M → LATIN CAPITAL LETTER M	# 
+039C ;	004D ;	MA	# ( Μ → M ) GREEK CAPITAL LETTER MU → LATIN CAPITAL LETTER M	# 
+1D6B3 ;	004D ;	MA	# ( 𝚳 → M ) MATHEMATICAL BOLD CAPITAL MU → LATIN CAPITAL LETTER M	# →𝐌→
+1D6ED ;	004D ;	MA	# ( 𝛭 → M ) MATHEMATICAL ITALIC CAPITAL MU → LATIN CAPITAL LETTER M	# →𝑀→
+1D727 ;	004D ;	MA	# ( 𝜧 → M ) MATHEMATICAL BOLD ITALIC CAPITAL MU → LATIN CAPITAL LETTER M	# →𝑴→
+1D761 ;	004D ;	MA	# ( 𝝡 → M ) MATHEMATICAL SANS-SERIF BOLD CAPITAL MU → LATIN CAPITAL LETTER M	# →Μ→
+1D79B ;	004D ;	MA	# ( 𝞛 → M ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL MU → LATIN CAPITAL LETTER M	# →Μ→
+03FA ;	004D ;	MA	# ( Ϻ → M ) GREEK CAPITAL LETTER SAN → LATIN CAPITAL LETTER M	# 
+2C98 ;	004D ;	MA	# ( Ⲙ → M ) COPTIC CAPITAL LETTER MI → LATIN CAPITAL LETTER M	# 
+041C ;	004D ;	MA	# ( М → M ) CYRILLIC CAPITAL LETTER EM → LATIN CAPITAL LETTER M	# 
+13B7 ;	004D ;	MA	# ( Ꮇ → M ) CHEROKEE LETTER LU → LATIN CAPITAL LETTER M	# 
+15F0 ;	004D ;	MA	# ( ᗰ → M ) CANADIAN SYLLABICS CARRIER GO → LATIN CAPITAL LETTER M	# 
+16D6 ;	004D ;	MA	# ( ᛖ → M ) RUNIC LETTER EHWAZ EH E → LATIN CAPITAL LETTER M	# 
+A4DF ;	004D ;	MA	# ( ꓟ → M ) LISU LETTER MA → LATIN CAPITAL LETTER M	# 
+102B0 ;	004D ;	MA	# ( 𐊰 → M ) CARIAN LETTER S → LATIN CAPITAL LETTER M	# 
+10311 ;	004D ;	MA	# ( 𐌑 → M ) OLD ITALIC LETTER SHE → LATIN CAPITAL LETTER M	# 
+
+04CD ;	004D 0326 ;	MA	# ( Ӎ → M̦ ) CYRILLIC CAPITAL LETTER EM WITH TAIL → LATIN CAPITAL LETTER M, COMBINING COMMA BELOW	# →М̡→
+
+1F76B ;	004D 0042 ;	MA	#* ( 🝫 → MB ) ALCHEMICAL SYMBOL FOR BATH OF MARY → LATIN CAPITAL LETTER M, LATIN CAPITAL LETTER B	# 
+
+2DE8 ;	1DDF ;	MA	# ( ⷨ → ᷟ ) COMBINING CYRILLIC LETTER EM → COMBINING LATIN LETTER SMALL CAPITAL M	# 
+
+1D427 ;	006E ;	MA	# ( 𝐧 → n ) MATHEMATICAL BOLD SMALL N → LATIN SMALL LETTER N	# 
+1D45B ;	006E ;	MA	# ( 𝑛 → n ) MATHEMATICAL ITALIC SMALL N → LATIN SMALL LETTER N	# 
+1D48F ;	006E ;	MA	# ( 𝒏 → n ) MATHEMATICAL BOLD ITALIC SMALL N → LATIN SMALL LETTER N	# 
+1D4C3 ;	006E ;	MA	# ( 𝓃 → n ) MATHEMATICAL SCRIPT SMALL N → LATIN SMALL LETTER N	# 
+1D4F7 ;	006E ;	MA	# ( 𝓷 → n ) MATHEMATICAL BOLD SCRIPT SMALL N → LATIN SMALL LETTER N	# 
+1D52B ;	006E ;	MA	# ( 𝔫 → n ) MATHEMATICAL FRAKTUR SMALL N → LATIN SMALL LETTER N	# 
+1D55F ;	006E ;	MA	# ( 𝕟 → n ) MATHEMATICAL DOUBLE-STRUCK SMALL N → LATIN SMALL LETTER N	# 
+1D593 ;	006E ;	MA	# ( 𝖓 → n ) MATHEMATICAL BOLD FRAKTUR SMALL N → LATIN SMALL LETTER N	# 
+1D5C7 ;	006E ;	MA	# ( 𝗇 → n ) MATHEMATICAL SANS-SERIF SMALL N → LATIN SMALL LETTER N	# 
+1D5FB ;	006E ;	MA	# ( 𝗻 → n ) MATHEMATICAL SANS-SERIF BOLD SMALL N → LATIN SMALL LETTER N	# 
+1D62F ;	006E ;	MA	# ( 𝘯 → n ) MATHEMATICAL SANS-SERIF ITALIC SMALL N → LATIN SMALL LETTER N	# 
+1D663 ;	006E ;	MA	# ( 𝙣 → n ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL N → LATIN SMALL LETTER N	# 
+1D697 ;	006E ;	MA	# ( 𝚗 → n ) MATHEMATICAL MONOSPACE SMALL N → LATIN SMALL LETTER N	# 
+0578 ;	006E ;	MA	# ( ո → n ) ARMENIAN SMALL LETTER VO → LATIN SMALL LETTER N	# 
+057C ;	006E ;	MA	# ( ռ → n ) ARMENIAN SMALL LETTER RA → LATIN SMALL LETTER N	# 
+
+FF2E ;	004E ;	MA	# ( Ｎ → N ) FULLWIDTH LATIN CAPITAL LETTER N → LATIN CAPITAL LETTER N	# →Ν→
+2115 ;	004E ;	MA	# ( ℕ → N ) DOUBLE-STRUCK CAPITAL N → LATIN CAPITAL LETTER N	# 
+1CCE3 ;	004E ;	MA	#* ( 𜳣 → N ) OUTLINED LATIN CAPITAL LETTER N → LATIN CAPITAL LETTER N	# 
+1D40D ;	004E ;	MA	# ( 𝐍 → N ) MATHEMATICAL BOLD CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D441 ;	004E ;	MA	# ( 𝑁 → N ) MATHEMATICAL ITALIC CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D475 ;	004E ;	MA	# ( 𝑵 → N ) MATHEMATICAL BOLD ITALIC CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D4A9 ;	004E ;	MA	# ( 𝒩 → N ) MATHEMATICAL SCRIPT CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D4DD ;	004E ;	MA	# ( 𝓝 → N ) MATHEMATICAL BOLD SCRIPT CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D511 ;	004E ;	MA	# ( 𝔑 → N ) MATHEMATICAL FRAKTUR CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D579 ;	004E ;	MA	# ( 𝕹 → N ) MATHEMATICAL BOLD FRAKTUR CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D5AD ;	004E ;	MA	# ( 𝖭 → N ) MATHEMATICAL SANS-SERIF CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D5E1 ;	004E ;	MA	# ( 𝗡 → N ) MATHEMATICAL SANS-SERIF BOLD CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D615 ;	004E ;	MA	# ( 𝘕 → N ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D649 ;	004E ;	MA	# ( 𝙉 → N ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL N → LATIN CAPITAL LETTER N	# 
+1D67D ;	004E ;	MA	# ( 𝙽 → N ) MATHEMATICAL MONOSPACE CAPITAL N → LATIN CAPITAL LETTER N	# 
+039D ;	004E ;	MA	# ( Ν → N ) GREEK CAPITAL LETTER NU → LATIN CAPITAL LETTER N	# 
+1D6B4 ;	004E ;	MA	# ( 𝚴 → N ) MATHEMATICAL BOLD CAPITAL NU → LATIN CAPITAL LETTER N	# →𝐍→
+1D6EE ;	004E ;	MA	# ( 𝛮 → N ) MATHEMATICAL ITALIC CAPITAL NU → LATIN CAPITAL LETTER N	# →𝑁→
+1D728 ;	004E ;	MA	# ( 𝜨 → N ) MATHEMATICAL BOLD ITALIC CAPITAL NU → LATIN CAPITAL LETTER N	# →𝑵→
+1D762 ;	004E ;	MA	# ( 𝝢 → N ) MATHEMATICAL SANS-SERIF BOLD CAPITAL NU → LATIN CAPITAL LETTER N	# →Ν→
+1D79C ;	004E ;	MA	# ( 𝞜 → N ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL NU → LATIN CAPITAL LETTER N	# →Ν→
+2C9A ;	004E ;	MA	# ( Ⲛ → N ) COPTIC CAPITAL LETTER NI → LATIN CAPITAL LETTER N	# 
+A4E0 ;	004E ;	MA	# ( ꓠ → N ) LISU LETTER NA → LATIN CAPITAL LETTER N	# 
+10513 ;	004E ;	MA	# ( 𐔓 → N ) ELBASAN LETTER NE → LATIN CAPITAL LETTER N	# 
+
+1018E ;	004E 030A ;	MA	#* ( 𐆎 → N̊ ) NOMISMA SIGN → LATIN CAPITAL LETTER N, COMBINING RING ABOVE	# →Νͦ→
+
+0273 ;	006E 0328 ;	MA	# ( ɳ → n̨ ) LATIN SMALL LETTER N WITH RETROFLEX HOOK → LATIN SMALL LETTER N, COMBINING OGONEK	# →n̢→
+
+019E ;	006E 0329 ;	MA	# ( ƞ → n̩ ) LATIN SMALL LETTER N WITH LONG RIGHT LEG → LATIN SMALL LETTER N, COMBINING VERTICAL LINE BELOW	# 
+014B ;	006E 0329 ;	MA	# ( ŋ → n̩ ) LATIN SMALL LETTER ENG → LATIN SMALL LETTER N, COMBINING VERTICAL LINE BELOW	# →η→→ƞ→
+03B7 ;	006E 0329 ;	MA	# ( η → n̩ ) GREEK SMALL LETTER ETA → LATIN SMALL LETTER N, COMBINING VERTICAL LINE BELOW	# →ƞ→
+1D6C8 ;	006E 0329 ;	MA	# ( 𝛈 → n̩ ) MATHEMATICAL BOLD SMALL ETA → LATIN SMALL LETTER N, COMBINING VERTICAL LINE BELOW	# →η→→ƞ→
+1D702 ;	006E 0329 ;	MA	# ( 𝜂 → n̩ ) MATHEMATICAL ITALIC SMALL ETA → LATIN SMALL LETTER N, COMBINING VERTICAL LINE BELOW	# →η→→ƞ→
+1D73C ;	006E 0329 ;	MA	# ( 𝜼 → n̩ ) MATHEMATICAL BOLD ITALIC SMALL ETA → LATIN SMALL LETTER N, COMBINING VERTICAL LINE BELOW	# →η→→ƞ→
+1D776 ;	006E 0329 ;	MA	# ( 𝝶 → n̩ ) MATHEMATICAL SANS-SERIF BOLD SMALL ETA → LATIN SMALL LETTER N, COMBINING VERTICAL LINE BELOW	# →η→→ƞ→
+1D7B0 ;	006E 0329 ;	MA	# ( 𝞰 → n̩ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ETA → LATIN SMALL LETTER N, COMBINING VERTICAL LINE BELOW	# →η→→ƞ→
+0572 ;	006E 0329 ;	MA	# ( ղ → n̩ ) ARMENIAN SMALL LETTER GHAD → LATIN SMALL LETTER N, COMBINING VERTICAL LINE BELOW	# →η→→ƞ→
+
+019D ;	004E 0326 ;	MA	# ( Ɲ → N̦ ) LATIN CAPITAL LETTER N WITH LEFT HOOK → LATIN CAPITAL LETTER N, COMBINING COMMA BELOW	# →N̡→
+
+1D70 ;	006E 0334 ;	MA	# ( ᵰ → n̴ ) LATIN SMALL LETTER N WITH MIDDLE TILDE → LATIN SMALL LETTER N, COMBINING TILDE OVERLAY	# 
+
+01CC ;	006E 006A ;	MA	# ( nj → nj ) LATIN SMALL LETTER NJ → LATIN SMALL LETTER N, LATIN SMALL LETTER J	# 
+
+01CB ;	004E 006A ;	MA	# ( Nj → Nj ) LATIN CAPITAL LETTER N WITH SMALL LETTER J → LATIN CAPITAL LETTER N, LATIN SMALL LETTER J	# 
+
+01CA ;	004E 004A ;	MA	# ( NJ → NJ ) LATIN CAPITAL LETTER NJ → LATIN CAPITAL LETTER N, LATIN CAPITAL LETTER J	# 
+
+2116 ;	004E 006F ;	MA	#* ( № → No ) NUMERO SIGN → LATIN CAPITAL LETTER N, LATIN SMALL LETTER O	# 
+
+2C9B ;	0274 ;	MA	# ( ⲛ → ɴ ) COPTIC SMALL LETTER NI → LATIN LETTER SMALL CAPITAL N	# 
+
+0377 ;	1D0E ;	MA	# ( ͷ → ᴎ ) GREEK SMALL LETTER PAMPHYLIAN DIGAMMA → LATIN LETTER SMALL CAPITAL REVERSED N	# →и→
+0438 ;	1D0E ;	MA	# ( и → ᴎ ) CYRILLIC SMALL LETTER I → LATIN LETTER SMALL CAPITAL REVERSED N	# 
+1044D ;	1D0E ;	MA	# ( 𐑍 → ᴎ ) DESERET SMALL LETTER ENG → LATIN LETTER SMALL CAPITAL REVERSED N	# →и→
+
+0146 ;	0272 ;	MA	# ( ņ → ɲ ) LATIN SMALL LETTER N WITH CEDILLA → LATIN SMALL LETTER N WITH LEFT HOOK	# 
+
+0C02 ;	006F ;	MA	# ( ం → o ) TELUGU SIGN ANUSVARA → LATIN SMALL LETTER O	# 
+0C82 ;	006F ;	MA	# ( ಂ → o ) KANNADA SIGN ANUSVARA → LATIN SMALL LETTER O	# 
+0D02 ;	006F ;	MA	# ( ം → o ) MALAYALAM SIGN ANUSVARA → LATIN SMALL LETTER O	# 
+0D82 ;	006F ;	MA	# ( ං → o ) SINHALA SIGN ANUSVARAYA → LATIN SMALL LETTER O	# 
+0966 ;	006F ;	MA	# ( ० → o ) DEVANAGARI DIGIT ZERO → LATIN SMALL LETTER O	# 
+09E6 ;	006F ;	MA	# ( ০ → o ) BENGALI DIGIT ZERO → LATIN SMALL LETTER O	# 
+0A66 ;	006F ;	MA	# ( ੦ → o ) GURMUKHI DIGIT ZERO → LATIN SMALL LETTER O	# 
+0AE6 ;	006F ;	MA	# ( ૦ → o ) GUJARATI DIGIT ZERO → LATIN SMALL LETTER O	# 
+0B66 ;	006F ;	MA	# ( ୦ → o ) ORIYA DIGIT ZERO → LATIN SMALL LETTER O	# 
+0BE6 ;	006F ;	MA	# ( ௦ → o ) TAMIL DIGIT ZERO → LATIN SMALL LETTER O	# 
+0C66 ;	006F ;	MA	# ( ౦ → o ) TELUGU DIGIT ZERO → LATIN SMALL LETTER O	# 
+0D66 ;	006F ;	MA	# ( ൦ → o ) MALAYALAM DIGIT ZERO → LATIN SMALL LETTER O	# 
+0E50 ;	006F ;	MA	# ( ๐ → o ) THAI DIGIT ZERO → LATIN SMALL LETTER O	# 
+0ED0 ;	006F ;	MA	# ( ໐ → o ) LAO DIGIT ZERO → LATIN SMALL LETTER O	# 
+1040 ;	006F ;	MA	# ( ၀ → o ) MYANMAR DIGIT ZERO → LATIN SMALL LETTER O	# 
+17E0 ;	006F ;	MA	# ( ០ → o ) KHMER DIGIT ZERO → LATIN SMALL LETTER O	# 
+114D0 ;	006F ;	MA	# ( 𑓐 → o ) TIRHUTA DIGIT ZERO → LATIN SMALL LETTER O	# →০→
+0665 ;	006F ;	MA	# ( ‎٥‎ → o ) ARABIC-INDIC DIGIT FIVE → LATIN SMALL LETTER O	# 
+06F5 ;	006F ;	MA	# ( ۵ → o ) EXTENDED ARABIC-INDIC DIGIT FIVE → LATIN SMALL LETTER O	# →‎٥‎→
+FF4F ;	006F ;	MA	# ( ｏ → o ) FULLWIDTH LATIN SMALL LETTER O → LATIN SMALL LETTER O	# →о→
+2134 ;	006F ;	MA	# ( ℴ → o ) SCRIPT SMALL O → LATIN SMALL LETTER O	# 
+1D428 ;	006F ;	MA	# ( 𝐨 → o ) MATHEMATICAL BOLD SMALL O → LATIN SMALL LETTER O	# 
+1D45C ;	006F ;	MA	# ( 𝑜 → o ) MATHEMATICAL ITALIC SMALL O → LATIN SMALL LETTER O	# 
+1D490 ;	006F ;	MA	# ( 𝒐 → o ) MATHEMATICAL BOLD ITALIC SMALL O → LATIN SMALL LETTER O	# 
+1D4F8 ;	006F ;	MA	# ( 𝓸 → o ) MATHEMATICAL BOLD SCRIPT SMALL O → LATIN SMALL LETTER O	# 
+1D52C ;	006F ;	MA	# ( 𝔬 → o ) MATHEMATICAL FRAKTUR SMALL O → LATIN SMALL LETTER O	# 
+1D560 ;	006F ;	MA	# ( 𝕠 → o ) MATHEMATICAL DOUBLE-STRUCK SMALL O → LATIN SMALL LETTER O	# 
+1D594 ;	006F ;	MA	# ( 𝖔 → o ) MATHEMATICAL BOLD FRAKTUR SMALL O → LATIN SMALL LETTER O	# 
+1D5C8 ;	006F ;	MA	# ( 𝗈 → o ) MATHEMATICAL SANS-SERIF SMALL O → LATIN SMALL LETTER O	# 
+1D5FC ;	006F ;	MA	# ( 𝗼 → o ) MATHEMATICAL SANS-SERIF BOLD SMALL O → LATIN SMALL LETTER O	# 
+1D630 ;	006F ;	MA	# ( 𝘰 → o ) MATHEMATICAL SANS-SERIF ITALIC SMALL O → LATIN SMALL LETTER O	# 
+1D664 ;	006F ;	MA	# ( 𝙤 → o ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL O → LATIN SMALL LETTER O	# 
+1D698 ;	006F ;	MA	# ( 𝚘 → o ) MATHEMATICAL MONOSPACE SMALL O → LATIN SMALL LETTER O	# 
+1D0F ;	006F ;	MA	# ( ᴏ → o ) LATIN LETTER SMALL CAPITAL O → LATIN SMALL LETTER O	# 
+1D11 ;	006F ;	MA	# ( ᴑ → o ) LATIN SMALL LETTER SIDEWAYS O → LATIN SMALL LETTER O	# 
+AB3D ;	006F ;	MA	# ( ꬽ → o ) LATIN SMALL LETTER BLACKLETTER O → LATIN SMALL LETTER O	# 
+03BF ;	006F ;	MA	# ( ο → o ) GREEK SMALL LETTER OMICRON → LATIN SMALL LETTER O	# 
+1D6D0 ;	006F ;	MA	# ( 𝛐 → o ) MATHEMATICAL BOLD SMALL OMICRON → LATIN SMALL LETTER O	# →𝐨→
+1D70A ;	006F ;	MA	# ( 𝜊 → o ) MATHEMATICAL ITALIC SMALL OMICRON → LATIN SMALL LETTER O	# →𝑜→
+1D744 ;	006F ;	MA	# ( 𝝄 → o ) MATHEMATICAL BOLD ITALIC SMALL OMICRON → LATIN SMALL LETTER O	# →𝒐→
+1D77E ;	006F ;	MA	# ( 𝝾 → o ) MATHEMATICAL SANS-SERIF BOLD SMALL OMICRON → LATIN SMALL LETTER O	# →ο→
+1D7B8 ;	006F ;	MA	# ( 𝞸 → o ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMICRON → LATIN SMALL LETTER O	# →ο→
+03C3 ;	006F ;	MA	# ( σ → o ) GREEK SMALL LETTER SIGMA → LATIN SMALL LETTER O	# 
+1D6D4 ;	006F ;	MA	# ( 𝛔 → o ) MATHEMATICAL BOLD SMALL SIGMA → LATIN SMALL LETTER O	# →σ→
+1D70E ;	006F ;	MA	# ( 𝜎 → o ) MATHEMATICAL ITALIC SMALL SIGMA → LATIN SMALL LETTER O	# →σ→
+1D748 ;	006F ;	MA	# ( 𝝈 → o ) MATHEMATICAL BOLD ITALIC SMALL SIGMA → LATIN SMALL LETTER O	# →σ→
+1D782 ;	006F ;	MA	# ( 𝞂 → o ) MATHEMATICAL SANS-SERIF BOLD SMALL SIGMA → LATIN SMALL LETTER O	# →σ→
+1D7BC ;	006F ;	MA	# ( 𝞼 → o ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL SIGMA → LATIN SMALL LETTER O	# →σ→
+2C9F ;	006F ;	MA	# ( ⲟ → o ) COPTIC SMALL LETTER O → LATIN SMALL LETTER O	# 
+03ED ;	006F ;	MA	# ( ϭ → o ) COPTIC SMALL LETTER SHIMA → LATIN SMALL LETTER O	# →σ→
+043E ;	006F ;	MA	# ( о → o ) CYRILLIC SMALL LETTER O → LATIN SMALL LETTER O	# 
+10FF ;	006F ;	MA	# ( ჿ → o ) GEORGIAN LETTER LABIAL SIGN → LATIN SMALL LETTER O	# 
+0585 ;	006F ;	MA	# ( օ → o ) ARMENIAN SMALL LETTER OH → LATIN SMALL LETTER O	# 
+05E1 ;	006F ;	MA	# ( ‎ס‎ → o ) HEBREW LETTER SAMEKH → LATIN SMALL LETTER O	# 
+0647 ;	006F ;	MA	# ( ‎ه‎ → o ) ARABIC LETTER HEH → LATIN SMALL LETTER O	# 
+1EE24 ;	006F ;	MA	# ( ‎𞸤‎ → o ) ARABIC MATHEMATICAL INITIAL HEH → LATIN SMALL LETTER O	# →‎ه‎→
+1EE64 ;	006F ;	MA	# ( ‎𞹤‎ → o ) ARABIC MATHEMATICAL STRETCHED HEH → LATIN SMALL LETTER O	# →‎ه‎→
+1EE84 ;	006F ;	MA	# ( ‎𞺄‎ → o ) ARABIC MATHEMATICAL LOOPED HEH → LATIN SMALL LETTER O	# →‎ه‎→
+FEEB ;	006F ;	MA	# ( ‎ﻫ‎ → o ) ARABIC LETTER HEH INITIAL FORM → LATIN SMALL LETTER O	# →‎ه‎→
+FEEC ;	006F ;	MA	# ( ‎ﻬ‎ → o ) ARABIC LETTER HEH MEDIAL FORM → LATIN SMALL LETTER O	# →‎ه‎→
+FEEA ;	006F ;	MA	# ( ‎ﻪ‎ → o ) ARABIC LETTER HEH FINAL FORM → LATIN SMALL LETTER O	# →‎ه‎→
+FEE9 ;	006F ;	MA	# ( ‎ﻩ‎ → o ) ARABIC LETTER HEH ISOLATED FORM → LATIN SMALL LETTER O	# →‎ه‎→
+06BE ;	006F ;	MA	# ( ‎ھ‎ → o ) ARABIC LETTER HEH DOACHASHMEE → LATIN SMALL LETTER O	# →‎ه‎→
+FBAC ;	006F ;	MA	# ( ‎ﮬ‎ → o ) ARABIC LETTER HEH DOACHASHMEE INITIAL FORM → LATIN SMALL LETTER O	# →‎ﻫ‎→→‎ه‎→
+FBAD ;	006F ;	MA	# ( ‎ﮭ‎ → o ) ARABIC LETTER HEH DOACHASHMEE MEDIAL FORM → LATIN SMALL LETTER O	# →‎ﻬ‎→→‎ه‎→
+FBAB ;	006F ;	MA	# ( ‎ﮫ‎ → o ) ARABIC LETTER HEH DOACHASHMEE FINAL FORM → LATIN SMALL LETTER O	# →‎ﻪ‎→→‎ه‎→
+FBAA ;	006F ;	MA	# ( ‎ﮪ‎ → o ) ARABIC LETTER HEH DOACHASHMEE ISOLATED FORM → LATIN SMALL LETTER O	# →‎ه‎→
+06C1 ;	006F ;	MA	# ( ‎ہ‎ → o ) ARABIC LETTER HEH GOAL → LATIN SMALL LETTER O	# →‎ه‎→
+FBA8 ;	006F ;	MA	# ( ‎ﮨ‎ → o ) ARABIC LETTER HEH GOAL INITIAL FORM → LATIN SMALL LETTER O	# →‎ہ‎→→‎ه‎→
+FBA9 ;	006F ;	MA	# ( ‎ﮩ‎ → o ) ARABIC LETTER HEH GOAL MEDIAL FORM → LATIN SMALL LETTER O	# →‎ہ‎→→‎ه‎→
+FBA7 ;	006F ;	MA	# ( ‎ﮧ‎ → o ) ARABIC LETTER HEH GOAL FINAL FORM → LATIN SMALL LETTER O	# →‎ہ‎→→‎ه‎→
+FBA6 ;	006F ;	MA	# ( ‎ﮦ‎ → o ) ARABIC LETTER HEH GOAL ISOLATED FORM → LATIN SMALL LETTER O	# →‎ه‎→
+06D5 ;	006F ;	MA	# ( ‎ە‎ → o ) ARABIC LETTER AE → LATIN SMALL LETTER O	# →‎ه‎→
+0D20 ;	006F ;	MA	# ( ഠ → o ) MALAYALAM LETTER TTHA → LATIN SMALL LETTER O	# 
+101D ;	006F ;	MA	# ( ဝ → o ) MYANMAR LETTER WA → LATIN SMALL LETTER O	# 
+104EA ;	006F ;	MA	# ( 𐓪 → o ) OSAGE SMALL LETTER O → LATIN SMALL LETTER O	# 
+118C8 ;	006F ;	MA	# ( 𑣈 → o ) WARANG CITI SMALL LETTER E → LATIN SMALL LETTER O	# 
+118D7 ;	006F ;	MA	# ( 𑣗 → o ) WARANG CITI SMALL LETTER BU → LATIN SMALL LETTER O	# 
+1042C ;	006F ;	MA	# ( 𐐬 → o ) DESERET SMALL LETTER LONG O → LATIN SMALL LETTER O	# 
+
+0030 ;	004F ;	MA	# ( 0 → O ) DIGIT ZERO → LATIN CAPITAL LETTER O	# 
+07C0 ;	004F ;	MA	# ( ‎߀‎ → O ) NKO DIGIT ZERO → LATIN CAPITAL LETTER O	# →0→
+0CE6 ;	004F ;	MA	# ( ೦ → O ) KANNADA DIGIT ZERO → LATIN CAPITAL LETTER O	# 
+3007 ;	004F ;	MA	# ( 〇 → O ) IDEOGRAPHIC NUMBER ZERO → LATIN CAPITAL LETTER O	# 
+118E0 ;	004F ;	MA	# ( 𑣠 → O ) WARANG CITI DIGIT ZERO → LATIN CAPITAL LETTER O	# →0→
+1CCF0 ;	004F ;	MA	# ( 𜳰 → O ) OUTLINED DIGIT ZERO → LATIN CAPITAL LETTER O	# →0→
+1D7CE ;	004F ;	MA	# ( 𝟎 → O ) MATHEMATICAL BOLD DIGIT ZERO → LATIN CAPITAL LETTER O	# →0→
+1D7D8 ;	004F ;	MA	# ( 𝟘 → O ) MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO → LATIN CAPITAL LETTER O	# →0→
+1D7E2 ;	004F ;	MA	# ( 𝟢 → O ) MATHEMATICAL SANS-SERIF DIGIT ZERO → LATIN CAPITAL LETTER O	# →0→
+1D7EC ;	004F ;	MA	# ( 𝟬 → O ) MATHEMATICAL SANS-SERIF BOLD DIGIT ZERO → LATIN CAPITAL LETTER O	# →0→
+1D7F6 ;	004F ;	MA	# ( 𝟶 → O ) MATHEMATICAL MONOSPACE DIGIT ZERO → LATIN CAPITAL LETTER O	# →0→
+1FBF0 ;	004F ;	MA	# ( 🯰 → O ) SEGMENTED DIGIT ZERO → LATIN CAPITAL LETTER O	# →0→
+FF2F ;	004F ;	MA	# ( Ｏ → O ) FULLWIDTH LATIN CAPITAL LETTER O → LATIN CAPITAL LETTER O	# →О→
+1CCE4 ;	004F ;	MA	#* ( 𜳤 → O ) OUTLINED LATIN CAPITAL LETTER O → LATIN CAPITAL LETTER O	# 
+1D40E ;	004F ;	MA	# ( 𝐎 → O ) MATHEMATICAL BOLD CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D442 ;	004F ;	MA	# ( 𝑂 → O ) MATHEMATICAL ITALIC CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D476 ;	004F ;	MA	# ( 𝑶 → O ) MATHEMATICAL BOLD ITALIC CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D4AA ;	004F ;	MA	# ( 𝒪 → O ) MATHEMATICAL SCRIPT CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D4DE ;	004F ;	MA	# ( 𝓞 → O ) MATHEMATICAL BOLD SCRIPT CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D512 ;	004F ;	MA	# ( 𝔒 → O ) MATHEMATICAL FRAKTUR CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D546 ;	004F ;	MA	# ( 𝕆 → O ) MATHEMATICAL DOUBLE-STRUCK CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D57A ;	004F ;	MA	# ( 𝕺 → O ) MATHEMATICAL BOLD FRAKTUR CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D5AE ;	004F ;	MA	# ( 𝖮 → O ) MATHEMATICAL SANS-SERIF CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D5E2 ;	004F ;	MA	# ( 𝗢 → O ) MATHEMATICAL SANS-SERIF BOLD CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D616 ;	004F ;	MA	# ( 𝘖 → O ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D64A ;	004F ;	MA	# ( 𝙊 → O ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL O → LATIN CAPITAL LETTER O	# 
+1D67E ;	004F ;	MA	# ( 𝙾 → O ) MATHEMATICAL MONOSPACE CAPITAL O → LATIN CAPITAL LETTER O	# 
+039F ;	004F ;	MA	# ( Ο → O ) GREEK CAPITAL LETTER OMICRON → LATIN CAPITAL LETTER O	# 
+1D6B6 ;	004F ;	MA	# ( 𝚶 → O ) MATHEMATICAL BOLD CAPITAL OMICRON → LATIN CAPITAL LETTER O	# →𝐎→
+1D6F0 ;	004F ;	MA	# ( 𝛰 → O ) MATHEMATICAL ITALIC CAPITAL OMICRON → LATIN CAPITAL LETTER O	# →𝑂→
+1D72A ;	004F ;	MA	# ( 𝜪 → O ) MATHEMATICAL BOLD ITALIC CAPITAL OMICRON → LATIN CAPITAL LETTER O	# →𝑶→
+1D764 ;	004F ;	MA	# ( 𝝤 → O ) MATHEMATICAL SANS-SERIF BOLD CAPITAL OMICRON → LATIN CAPITAL LETTER O	# →Ο→
+1D79E ;	004F ;	MA	# ( 𝞞 → O ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMICRON → LATIN CAPITAL LETTER O	# →Ο→
+2C9E ;	004F ;	MA	# ( Ⲟ → O ) COPTIC CAPITAL LETTER O → LATIN CAPITAL LETTER O	# 
+041E ;	004F ;	MA	# ( О → O ) CYRILLIC CAPITAL LETTER O → LATIN CAPITAL LETTER O	# 
+0555 ;	004F ;	MA	# ( Օ → O ) ARMENIAN CAPITAL LETTER OH → LATIN CAPITAL LETTER O	# 
+2D54 ;	004F ;	MA	# ( ⵔ → O ) TIFINAGH LETTER YAR → LATIN CAPITAL LETTER O	# 
+12D0 ;	004F ;	MA	# ( ዐ → O ) ETHIOPIC SYLLABLE PHARYNGEAL A → LATIN CAPITAL LETTER O	# →Օ→
+0B20 ;	004F ;	MA	# ( ଠ → O ) ORIYA LETTER TTHA → LATIN CAPITAL LETTER O	# 
+104C2 ;	004F ;	MA	# ( 𐓂 → O ) OSAGE CAPITAL LETTER O → LATIN CAPITAL LETTER O	# 
+A4F3 ;	004F ;	MA	# ( ꓳ → O ) LISU LETTER O → LATIN CAPITAL LETTER O	# 
+118B5 ;	004F ;	MA	# ( 𑢵 → O ) WARANG CITI CAPITAL LETTER AT → LATIN CAPITAL LETTER O	# 
+10292 ;	004F ;	MA	# ( 𐊒 → O ) LYCIAN LETTER U → LATIN CAPITAL LETTER O	# 
+102AB ;	004F ;	MA	# ( 𐊫 → O ) CARIAN LETTER O → LATIN CAPITAL LETTER O	# 
+10404 ;	004F ;	MA	# ( 𐐄 → O ) DESERET CAPITAL LETTER LONG O → LATIN CAPITAL LETTER O	# 
+10516 ;	004F ;	MA	# ( 𐔖 → O ) ELBASAN LETTER O → LATIN CAPITAL LETTER O	# 
+11DE0 ;	004F ;	MA	# ( 𑷠 → O ) TOLONG SIKI DIGIT ZERO → LATIN CAPITAL LETTER O	# →0→
+
+2070 ;	00BA ;	MA	#* ( ⁰ → º ) SUPERSCRIPT ZERO → MASCULINE ORDINAL INDICATOR	# 
+1D52 ;	00BA ;	MA	# ( ᵒ → º ) MODIFIER LETTER SMALL O → MASCULINE ORDINAL INDICATOR	# →⁰→
+
+01D2 ;	014F ;	MA	# ( ǒ → ŏ ) LATIN SMALL LETTER O WITH CARON → LATIN SMALL LETTER O WITH BREVE	# 
+
+01D1 ;	014E ;	MA	# ( Ǒ → Ŏ ) LATIN CAPITAL LETTER O WITH CARON → LATIN CAPITAL LETTER O WITH BREVE	# 
+
+06FF ;	006F 0302 ;	MA	# ( ‎ۿ‎ → ô ) ARABIC LETTER HEH WITH INVERTED V → LATIN SMALL LETTER O, COMBINING CIRCUMFLEX ACCENT	# →‎ھٛ‎→
+
+0150 ;	00D6 ;	MA	# ( Ő → Ö ) LATIN CAPITAL LETTER O WITH DOUBLE ACUTE → LATIN CAPITAL LETTER O WITH DIAERESIS	# 
+
+00F8 ;	006F 0338 ;	MA	# ( ø → o̸ ) LATIN SMALL LETTER O WITH STROKE → LATIN SMALL LETTER O, COMBINING LONG SOLIDUS OVERLAY	# →o̷→
+AB3E ;	006F 0338 ;	MA	# ( ꬾ → o̸ ) LATIN SMALL LETTER BLACKLETTER O WITH STROKE → LATIN SMALL LETTER O, COMBINING LONG SOLIDUS OVERLAY	# →ø→→o̷→
+
+00D8 ;	004F 0338 ;	MA	# ( Ø → O̸ ) LATIN CAPITAL LETTER O WITH STROKE → LATIN CAPITAL LETTER O, COMBINING LONG SOLIDUS OVERLAY	# 
+2D41 ;	004F 0338 ;	MA	# ( ⵁ → O̸ ) TIFINAGH LETTER BERBER ACADEMY YAH → LATIN CAPITAL LETTER O, COMBINING LONG SOLIDUS OVERLAY	# →Ø→
+
+01FE ;	004F 0338 0301 ;	MA	# ( Ǿ → Ó̸ ) LATIN CAPITAL LETTER O WITH STROKE AND ACUTE → LATIN CAPITAL LETTER O, COMBINING LONG SOLIDUS OVERLAY, COMBINING ACUTE ACCENT	# 
+
+0275 ;	006F 0335 ;	MA	# ( ɵ → o̵ ) LATIN SMALL LETTER BARRED O → LATIN SMALL LETTER O, COMBINING SHORT STROKE OVERLAY	# 
+A74B ;	006F 0335 ;	MA	# ( ꝋ → o̵ ) LATIN SMALL LETTER O WITH LONG STROKE OVERLAY → LATIN SMALL LETTER O, COMBINING SHORT STROKE OVERLAY	# →o̶→
+2C91 ;	006F 0335 ;	MA	# ( ⲑ → o̵ ) COPTIC SMALL LETTER THETHE → LATIN SMALL LETTER O, COMBINING SHORT STROKE OVERLAY	# →ɵ→
+04E9 ;	006F 0335 ;	MA	# ( ө → o̵ ) CYRILLIC SMALL LETTER BARRED O → LATIN SMALL LETTER O, COMBINING SHORT STROKE OVERLAY	# →ѳ→
+0473 ;	006F 0335 ;	MA	# ( ѳ → o̵ ) CYRILLIC SMALL LETTER FITA → LATIN SMALL LETTER O, COMBINING SHORT STROKE OVERLAY	# 
+AB8E ;	006F 0335 ;	MA	# ( ꮎ → o̵ ) CHEROKEE SMALL LETTER NA → LATIN SMALL LETTER O, COMBINING SHORT STROKE OVERLAY	# →ɵ→
+ABBB ;	006F 0335 ;	MA	# ( ꮻ → o̵ ) CHEROKEE SMALL LETTER WI → LATIN SMALL LETTER O, COMBINING SHORT STROKE OVERLAY	# →ѳ→
+
+2296 ;	004F 0335 ;	MA	#* ( ⊖ → O̵ ) CIRCLED MINUS → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+229D ;	004F 0335 ;	MA	#* ( ⊝ → O̵ ) CIRCLED DASH → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →⊖→→θ→→Ꮎ→
+236C ;	004F 0335 ;	MA	#* ( ⍬ → O̵ ) APL FUNCTIONAL SYMBOL ZILDE → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D21A ;	004F 0335 ;	MA	#* ( 𝈚 → O̵ ) GREEK VOCAL NOTATION SYMBOL-52 → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Ꝋ→→O̶→
+1F714 ;	004F 0335 ;	MA	#* ( 🜔 → O̵ ) ALCHEMICAL SYMBOL FOR SALT → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Ɵ→→O̶→
+019F ;	004F 0335 ;	MA	# ( Ɵ → O̵ ) LATIN CAPITAL LETTER O WITH MIDDLE TILDE → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →O̶→
+A74A ;	004F 0335 ;	MA	# ( Ꝋ → O̵ ) LATIN CAPITAL LETTER O WITH LONG STROKE OVERLAY → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →O̶→
+03B8 ;	004F 0335 ;	MA	# ( θ → O̵ ) GREEK SMALL LETTER THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Ꮎ→
+03D1 ;	004F 0335 ;	MA	# ( ϑ → O̵ ) GREEK THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D6C9 ;	004F 0335 ;	MA	# ( 𝛉 → O̵ ) MATHEMATICAL BOLD SMALL THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D6DD ;	004F 0335 ;	MA	# ( 𝛝 → O̵ ) MATHEMATICAL BOLD THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D703 ;	004F 0335 ;	MA	# ( 𝜃 → O̵ ) MATHEMATICAL ITALIC SMALL THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D717 ;	004F 0335 ;	MA	# ( 𝜗 → O̵ ) MATHEMATICAL ITALIC THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D73D ;	004F 0335 ;	MA	# ( 𝜽 → O̵ ) MATHEMATICAL BOLD ITALIC SMALL THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D751 ;	004F 0335 ;	MA	# ( 𝝑 → O̵ ) MATHEMATICAL BOLD ITALIC THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D777 ;	004F 0335 ;	MA	# ( 𝝷 → O̵ ) MATHEMATICAL SANS-SERIF BOLD SMALL THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D78B ;	004F 0335 ;	MA	# ( 𝞋 → O̵ ) MATHEMATICAL SANS-SERIF BOLD THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D7B1 ;	004F 0335 ;	MA	# ( 𝞱 → O̵ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+1D7C5 ;	004F 0335 ;	MA	# ( 𝟅 → O̵ ) MATHEMATICAL SANS-SERIF BOLD ITALIC THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →θ→→Ꮎ→
+0398 ;	004F 0335 ;	MA	# ( Θ → O̵ ) GREEK CAPITAL LETTER THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Ꮎ→
+03F4 ;	004F 0335 ;	MA	# ( ϴ → O̵ ) GREEK CAPITAL THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Ѳ→→О̵→
+1D6AF ;	004F 0335 ;	MA	# ( 𝚯 → O̵ ) MATHEMATICAL BOLD CAPITAL THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Θ→→Ꮎ→
+1D6B9 ;	004F 0335 ;	MA	# ( 𝚹 → O̵ ) MATHEMATICAL BOLD CAPITAL THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Θ→→Ꮎ→
+1D6E9 ;	004F 0335 ;	MA	# ( 𝛩 → O̵ ) MATHEMATICAL ITALIC CAPITAL THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Θ→→Ꮎ→
+1D6F3 ;	004F 0335 ;	MA	# ( 𝛳 → O̵ ) MATHEMATICAL ITALIC CAPITAL THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Θ→→Ꮎ→
+1D723 ;	004F 0335 ;	MA	# ( 𝜣 → O̵ ) MATHEMATICAL BOLD ITALIC CAPITAL THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Θ→→Ꮎ→
+1D72D ;	004F 0335 ;	MA	# ( 𝜭 → O̵ ) MATHEMATICAL BOLD ITALIC CAPITAL THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Θ→→Ꮎ→
+1D75D ;	004F 0335 ;	MA	# ( 𝝝 → O̵ ) MATHEMATICAL SANS-SERIF BOLD CAPITAL THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Θ→→Ꮎ→
+1D767 ;	004F 0335 ;	MA	# ( 𝝧 → O̵ ) MATHEMATICAL SANS-SERIF BOLD CAPITAL THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Θ→→Ꮎ→
+1D797 ;	004F 0335 ;	MA	# ( 𝞗 → O̵ ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL THETA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Θ→→Ꮎ→
+1D7A1 ;	004F 0335 ;	MA	# ( 𝞡 → O̵ ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL THETA SYMBOL → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Θ→→Ꮎ→
+2C90 ;	004F 0335 ;	MA	# ( Ⲑ → O̵ ) COPTIC CAPITAL LETTER THETHE → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →ϴ→→Ѳ→→О̵→
+04E8 ;	004F 0335 ;	MA	# ( Ө → O̵ ) CYRILLIC CAPITAL LETTER BARRED O → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Ѳ→→О̵→
+0472 ;	004F 0335 ;	MA	# ( Ѳ → O̵ ) CYRILLIC CAPITAL LETTER FITA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →О̵→
+2D31 ;	004F 0335 ;	MA	# ( ⴱ → O̵ ) TIFINAGH LETTER YAB → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Ɵ→→O̶→
+13BE ;	004F 0335 ;	MA	# ( Ꮎ → O̵ ) CHEROKEE LETTER NA → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# 
+13EB ;	004F 0335 ;	MA	# ( Ꮻ → O̵ ) CHEROKEE LETTER WI → LATIN CAPITAL LETTER O, COMBINING SHORT STROKE OVERLAY	# →Ѳ→→О̵→
+
+AB74 ;	006F 031B ;	MA	# ( ꭴ → ơ ) CHEROKEE SMALL LETTER U → LATIN SMALL LETTER O, COMBINING HORN	# 
+
+FCD9 ;	006F 0670 ;	MA	# ( ‎ﳙ‎ → oٰ ) ARABIC LIGATURE HEH WITH SUPERSCRIPT ALEF INITIAL FORM → LATIN SMALL LETTER O, ARABIC LETTER SUPERSCRIPT ALEF	# →‎هٰ‎→
+
+1F101 ;	004F 002C ;	MA	#* ( 🄁 → O, ) DIGIT ZERO COMMA → LATIN CAPITAL LETTER O, COMMA	# →0,→
+
+1F100 ;	004F 002E ;	MA	#* ( 🄀 → O. ) DIGIT ZERO FULL STOP → LATIN CAPITAL LETTER O, FULL STOP	# →0.→
+
+01A1 ;	006F 0027 ;	MA	# ( ơ → o' ) LATIN SMALL LETTER O WITH HORN → LATIN SMALL LETTER O, APOSTROPHE	# →oʼ→
+
+01A0 ;	004F 0027 ;	MA	# ( Ơ → O' ) LATIN CAPITAL LETTER O WITH HORN → LATIN CAPITAL LETTER O, APOSTROPHE	# →Oʼ→
+13A4 ;	004F 0027 ;	MA	# ( Ꭴ → O' ) CHEROKEE LETTER U → LATIN CAPITAL LETTER O, APOSTROPHE	# →Ơ→→Oʼ→
+
+0025 ;	00BA 002F 2080 ;	MA	#* ( % → º/₀ ) PERCENT SIGN → MASCULINE ORDINAL INDICATOR, SOLIDUS, SUBSCRIPT ZERO	# →⁰/₀→
+066A ;	00BA 002F 2080 ;	MA	#* ( ٪ → º/₀ ) ARABIC PERCENT SIGN → MASCULINE ORDINAL INDICATOR, SOLIDUS, SUBSCRIPT ZERO	# →%→→⁰/₀→
+2052 ;	00BA 002F 2080 ;	MA	#* ( ⁒ → º/₀ ) COMMERCIAL MINUS SIGN → MASCULINE ORDINAL INDICATOR, SOLIDUS, SUBSCRIPT ZERO	# →%→→⁰/₀→
+
+2030 ;	00BA 002F 2080 2080 ;	MA	#* ( ‰ → º/₀₀ ) PER MILLE SIGN → MASCULINE ORDINAL INDICATOR, SOLIDUS, SUBSCRIPT ZERO, SUBSCRIPT ZERO	# →⁰/₀₀→
+0609 ;	00BA 002F 2080 2080 ;	MA	#* ( ؉ → º/₀₀ ) ARABIC-INDIC PER MILLE SIGN → MASCULINE ORDINAL INDICATOR, SOLIDUS, SUBSCRIPT ZERO, SUBSCRIPT ZERO	# →‰→→⁰/₀₀→
+
+2031 ;	00BA 002F 2080 2080 2080 ;	MA	#* ( ‱ → º/₀₀₀ ) PER TEN THOUSAND SIGN → MASCULINE ORDINAL INDICATOR, SOLIDUS, SUBSCRIPT ZERO, SUBSCRIPT ZERO, SUBSCRIPT ZERO	# →⁰/₀₀₀→
+060A ;	00BA 002F 2080 2080 2080 ;	MA	#* ( ؊ → º/₀₀₀ ) ARABIC-INDIC PER TEN THOUSAND SIGN → MASCULINE ORDINAL INDICATOR, SOLIDUS, SUBSCRIPT ZERO, SUBSCRIPT ZERO, SUBSCRIPT ZERO	# →‱→→⁰/₀₀₀→
+
+0153 ;	006F 0065 ;	MA	# ( œ → oe ) LATIN SMALL LIGATURE OE → LATIN SMALL LETTER O, LATIN SMALL LETTER E	# 
+
+0152 ;	004F 0045 ;	MA	# ( Œ → OE ) LATIN CAPITAL LIGATURE OE → LATIN CAPITAL LETTER O, LATIN CAPITAL LETTER E	# 
+
+0276 ;	006F 1D07 ;	MA	# ( ɶ → oᴇ ) LATIN LETTER SMALL CAPITAL OE → LATIN SMALL LETTER O, LATIN LETTER SMALL CAPITAL E	# 
+
+221E ;	006F 006F ;	MA	#* ( ∞ → oo ) INFINITY → LATIN SMALL LETTER O, LATIN SMALL LETTER O	# →ꝏ→
+A74F ;	006F 006F ;	MA	# ( ꝏ → oo ) LATIN SMALL LETTER OO → LATIN SMALL LETTER O, LATIN SMALL LETTER O	# 
+A699 ;	006F 006F ;	MA	# ( ꚙ → oo ) CYRILLIC SMALL LETTER DOUBLE O → LATIN SMALL LETTER O, LATIN SMALL LETTER O	# 
+
+A74E ;	004F 004F ;	MA	# ( Ꝏ → OO ) LATIN CAPITAL LETTER OO → LATIN CAPITAL LETTER O, LATIN CAPITAL LETTER O	# 
+A698 ;	004F 004F ;	MA	# ( Ꚙ → OO ) CYRILLIC CAPITAL LETTER DOUBLE O → LATIN CAPITAL LETTER O, LATIN CAPITAL LETTER O	# 
+
+FCD7 ;	006F 062C ;	MA	# ( ‎ﳗ‎ → ‎oج‎ ) ARABIC LIGATURE HEH WITH JEEM INITIAL FORM → LATIN SMALL LETTER O, ARABIC LETTER JEEM	# →‎هج‎→
+FC51 ;	006F 062C ;	MA	# ( ‎ﱑ‎ → ‎oج‎ ) ARABIC LIGATURE HEH WITH JEEM ISOLATED FORM → LATIN SMALL LETTER O, ARABIC LETTER JEEM	# →‎هج‎→
+
+FCD8 ;	006F 0645 ;	MA	# ( ‎ﳘ‎ → ‎oم‎ ) ARABIC LIGATURE HEH WITH MEEM INITIAL FORM → LATIN SMALL LETTER O, ARABIC LETTER MEEM	# →‎هم‎→
+FC52 ;	006F 0645 ;	MA	# ( ‎ﱒ‎ → ‎oم‎ ) ARABIC LIGATURE HEH WITH MEEM ISOLATED FORM → LATIN SMALL LETTER O, ARABIC LETTER MEEM	# →‎هم‎→
+
+FD93 ;	006F 0645 062C ;	MA	# ( ‎ﶓ‎ → ‎oمج‎ ) ARABIC LIGATURE HEH WITH MEEM WITH JEEM INITIAL FORM → LATIN SMALL LETTER O, ARABIC LETTER MEEM, ARABIC LETTER JEEM	# →‎همج‎→
+
+FD94 ;	006F 0645 0645 ;	MA	# ( ‎ﶔ‎ → ‎oمم‎ ) ARABIC LIGATURE HEH WITH MEEM WITH MEEM INITIAL FORM → LATIN SMALL LETTER O, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# →‎همم‎→
+
+FC53 ;	006F 0649 ;	MA	# ( ‎ﱓ‎ → ‎oى‎ ) ARABIC LIGATURE HEH WITH ALEF MAKSURA ISOLATED FORM → LATIN SMALL LETTER O, ARABIC LETTER ALEF MAKSURA	# →‎هى‎→
+FC54 ;	006F 0649 ;	MA	# ( ‎ﱔ‎ → ‎oى‎ ) ARABIC LIGATURE HEH WITH YEH ISOLATED FORM → LATIN SMALL LETTER O, ARABIC LETTER ALEF MAKSURA	# →‎هي‎→
+
+0D5F ;	006F 0D30 006F ;	MA	# ( ൟ → oരo ) MALAYALAM LETTER ARCHAIC II → LATIN SMALL LETTER O, MALAYALAM LETTER RA, LATIN SMALL LETTER O	# →ംരം→
+
+10D7 ;	006F 102C ;	MA	# ( თ → oာ ) GEORGIAN LETTER TAN → LATIN SMALL LETTER O, MYANMAR VOWEL SIGN AA	# →တ→→ဝာ→
+1010 ;	006F 102C ;	MA	# ( တ → oာ ) MYANMAR LETTER TA → LATIN SMALL LETTER O, MYANMAR VOWEL SIGN AA	# →ဝာ→
+
+3358 ;	004F 70B9 ;	MA	#* ( ㍘ → O点 ) IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ZERO → LATIN CAPITAL LETTER O, CJK UNIFIED IDEOGRAPH-70B9	# →0点→
+
+2184 ;	0254 ;	MA	# ( ↄ → ɔ ) LATIN SMALL LETTER REVERSED C → LATIN SMALL LETTER OPEN O	# 
+1D10 ;	0254 ;	MA	# ( ᴐ → ɔ ) LATIN LETTER SMALL CAPITAL OPEN O → LATIN SMALL LETTER OPEN O	# 
+037B ;	0254 ;	MA	# ( ͻ → ɔ ) GREEK SMALL REVERSED LUNATE SIGMA SYMBOL → LATIN SMALL LETTER OPEN O	# 
+1044B ;	0254 ;	MA	# ( 𐑋 → ɔ ) DESERET SMALL LETTER EM → LATIN SMALL LETTER OPEN O	# 
+
+2183 ;	0186 ;	MA	# ( Ↄ → Ɔ ) ROMAN NUMERAL REVERSED ONE HUNDRED → LATIN CAPITAL LETTER OPEN O	# 
+03FD ;	0186 ;	MA	# ( Ͻ → Ɔ ) GREEK CAPITAL REVERSED LUNATE SIGMA SYMBOL → LATIN CAPITAL LETTER OPEN O	# 
+A4DB ;	0186 ;	MA	# ( ꓛ → Ɔ ) LISU LETTER CHA → LATIN CAPITAL LETTER OPEN O	# 
+10423 ;	0186 ;	MA	# ( 𐐣 → Ɔ ) DESERET CAPITAL LETTER EM → LATIN CAPITAL LETTER OPEN O	# 
+
+AB3F ;	0254 0338 ;	MA	# ( ꬿ → ɔ̸ ) LATIN SMALL LETTER OPEN O WITH STROKE → LATIN SMALL LETTER OPEN O, COMBINING LONG SOLIDUS OVERLAY	# 
+
+AB62 ;	0254 0065 ;	MA	# ( ꭢ → ɔe ) LATIN SMALL LETTER OPEN OE → LATIN SMALL LETTER OPEN O, LATIN SMALL LETTER E	# 
+
+1043F ;	0277 ;	MA	# ( 𐐿 → ɷ ) DESERET SMALL LETTER KAY → LATIN SMALL LETTER CLOSED OMEGA	# 
+
+2374 ;	0070 ;	MA	#* ( ⍴ → p ) APL FUNCTIONAL SYMBOL RHO → LATIN SMALL LETTER P	# →ρ→
+FF50 ;	0070 ;	MA	# ( ｐ → p ) FULLWIDTH LATIN SMALL LETTER P → LATIN SMALL LETTER P	# →р→
+1D429 ;	0070 ;	MA	# ( 𝐩 → p ) MATHEMATICAL BOLD SMALL P → LATIN SMALL LETTER P	# 
+1D45D ;	0070 ;	MA	# ( 𝑝 → p ) MATHEMATICAL ITALIC SMALL P → LATIN SMALL LETTER P	# 
+1D491 ;	0070 ;	MA	# ( 𝒑 → p ) MATHEMATICAL BOLD ITALIC SMALL P → LATIN SMALL LETTER P	# 
+1D4C5 ;	0070 ;	MA	# ( 𝓅 → p ) MATHEMATICAL SCRIPT SMALL P → LATIN SMALL LETTER P	# 
+1D4F9 ;	0070 ;	MA	# ( 𝓹 → p ) MATHEMATICAL BOLD SCRIPT SMALL P → LATIN SMALL LETTER P	# 
+1D52D ;	0070 ;	MA	# ( 𝔭 → p ) MATHEMATICAL FRAKTUR SMALL P → LATIN SMALL LETTER P	# 
+1D561 ;	0070 ;	MA	# ( 𝕡 → p ) MATHEMATICAL DOUBLE-STRUCK SMALL P → LATIN SMALL LETTER P	# 
+1D595 ;	0070 ;	MA	# ( 𝖕 → p ) MATHEMATICAL BOLD FRAKTUR SMALL P → LATIN SMALL LETTER P	# 
+1D5C9 ;	0070 ;	MA	# ( 𝗉 → p ) MATHEMATICAL SANS-SERIF SMALL P → LATIN SMALL LETTER P	# 
+1D5FD ;	0070 ;	MA	# ( 𝗽 → p ) MATHEMATICAL SANS-SERIF BOLD SMALL P → LATIN SMALL LETTER P	# 
+1D631 ;	0070 ;	MA	# ( 𝘱 → p ) MATHEMATICAL SANS-SERIF ITALIC SMALL P → LATIN SMALL LETTER P	# 
+1D665 ;	0070 ;	MA	# ( 𝙥 → p ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL P → LATIN SMALL LETTER P	# 
+1D699 ;	0070 ;	MA	# ( 𝚙 → p ) MATHEMATICAL MONOSPACE SMALL P → LATIN SMALL LETTER P	# 
+00FE ;	0070 ;	MA	# ( þ → p ) LATIN SMALL LETTER THORN → LATIN SMALL LETTER P	# →ƿ→
+01BF ;	0070 ;	MA	# ( ƿ → p ) LATIN LETTER WYNN → LATIN SMALL LETTER P	# 
+03C1 ;	0070 ;	MA	# ( ρ → p ) GREEK SMALL LETTER RHO → LATIN SMALL LETTER P	# 
+03F1 ;	0070 ;	MA	# ( ϱ → p ) GREEK RHO SYMBOL → LATIN SMALL LETTER P	# →ρ→
+1D6D2 ;	0070 ;	MA	# ( 𝛒 → p ) MATHEMATICAL BOLD SMALL RHO → LATIN SMALL LETTER P	# →ρ→
+1D6E0 ;	0070 ;	MA	# ( 𝛠 → p ) MATHEMATICAL BOLD RHO SYMBOL → LATIN SMALL LETTER P	# →ρ→
+1D70C ;	0070 ;	MA	# ( 𝜌 → p ) MATHEMATICAL ITALIC SMALL RHO → LATIN SMALL LETTER P	# →ρ→
+1D71A ;	0070 ;	MA	# ( 𝜚 → p ) MATHEMATICAL ITALIC RHO SYMBOL → LATIN SMALL LETTER P	# →ρ→
+1D746 ;	0070 ;	MA	# ( 𝝆 → p ) MATHEMATICAL BOLD ITALIC SMALL RHO → LATIN SMALL LETTER P	# →ρ→
+1D754 ;	0070 ;	MA	# ( 𝝔 → p ) MATHEMATICAL BOLD ITALIC RHO SYMBOL → LATIN SMALL LETTER P	# →ρ→
+1D780 ;	0070 ;	MA	# ( 𝞀 → p ) MATHEMATICAL SANS-SERIF BOLD SMALL RHO → LATIN SMALL LETTER P	# →ρ→
+1D78E ;	0070 ;	MA	# ( 𝞎 → p ) MATHEMATICAL SANS-SERIF BOLD RHO SYMBOL → LATIN SMALL LETTER P	# →ρ→
+1D7BA ;	0070 ;	MA	# ( 𝞺 → p ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL RHO → LATIN SMALL LETTER P	# →ρ→
+1D7C8 ;	0070 ;	MA	# ( 𝟈 → p ) MATHEMATICAL SANS-SERIF BOLD ITALIC RHO SYMBOL → LATIN SMALL LETTER P	# →ρ→
+03F8 ;	0070 ;	MA	# ( ϸ → p ) GREEK SMALL LETTER SHO → LATIN SMALL LETTER P	# →þ→→ƿ→
+2CA3 ;	0070 ;	MA	# ( ⲣ → p ) COPTIC SMALL LETTER RO → LATIN SMALL LETTER P	# →ρ→
+2CCF ;	0070 ;	MA	# ( ⳏ → p ) COPTIC SMALL LETTER OLD COPTIC HA → LATIN SMALL LETTER P	# 
+0440 ;	0070 ;	MA	# ( р → p ) CYRILLIC SMALL LETTER ER → LATIN SMALL LETTER P	# 
+
+FF30 ;	0050 ;	MA	# ( Ｐ → P ) FULLWIDTH LATIN CAPITAL LETTER P → LATIN CAPITAL LETTER P	# →Р→
+2119 ;	0050 ;	MA	# ( ℙ → P ) DOUBLE-STRUCK CAPITAL P → LATIN CAPITAL LETTER P	# 
+1CCE5 ;	0050 ;	MA	#* ( 𜳥 → P ) OUTLINED LATIN CAPITAL LETTER P → LATIN CAPITAL LETTER P	# 
+1D40F ;	0050 ;	MA	# ( 𝐏 → P ) MATHEMATICAL BOLD CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D443 ;	0050 ;	MA	# ( 𝑃 → P ) MATHEMATICAL ITALIC CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D477 ;	0050 ;	MA	# ( 𝑷 → P ) MATHEMATICAL BOLD ITALIC CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D4AB ;	0050 ;	MA	# ( 𝒫 → P ) MATHEMATICAL SCRIPT CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D4DF ;	0050 ;	MA	# ( 𝓟 → P ) MATHEMATICAL BOLD SCRIPT CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D513 ;	0050 ;	MA	# ( 𝔓 → P ) MATHEMATICAL FRAKTUR CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D57B ;	0050 ;	MA	# ( 𝕻 → P ) MATHEMATICAL BOLD FRAKTUR CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D5AF ;	0050 ;	MA	# ( 𝖯 → P ) MATHEMATICAL SANS-SERIF CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D5E3 ;	0050 ;	MA	# ( 𝗣 → P ) MATHEMATICAL SANS-SERIF BOLD CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D617 ;	0050 ;	MA	# ( 𝘗 → P ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D64B ;	0050 ;	MA	# ( 𝙋 → P ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL P → LATIN CAPITAL LETTER P	# 
+1D67F ;	0050 ;	MA	# ( 𝙿 → P ) MATHEMATICAL MONOSPACE CAPITAL P → LATIN CAPITAL LETTER P	# 
+03A1 ;	0050 ;	MA	# ( Ρ → P ) GREEK CAPITAL LETTER RHO → LATIN CAPITAL LETTER P	# 
+1D6B8 ;	0050 ;	MA	# ( 𝚸 → P ) MATHEMATICAL BOLD CAPITAL RHO → LATIN CAPITAL LETTER P	# →𝐏→
+1D6F2 ;	0050 ;	MA	# ( 𝛲 → P ) MATHEMATICAL ITALIC CAPITAL RHO → LATIN CAPITAL LETTER P	# →Ρ→
+1D72C ;	0050 ;	MA	# ( 𝜬 → P ) MATHEMATICAL BOLD ITALIC CAPITAL RHO → LATIN CAPITAL LETTER P	# →Ρ→
+1D766 ;	0050 ;	MA	# ( 𝝦 → P ) MATHEMATICAL SANS-SERIF BOLD CAPITAL RHO → LATIN CAPITAL LETTER P	# →Ρ→
+1D7A0 ;	0050 ;	MA	# ( 𝞠 → P ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL RHO → LATIN CAPITAL LETTER P	# →Ρ→
+2CA2 ;	0050 ;	MA	# ( Ⲣ → P ) COPTIC CAPITAL LETTER RO → LATIN CAPITAL LETTER P	# 
+2CCE ;	0050 ;	MA	# ( Ⳏ → P ) COPTIC CAPITAL LETTER OLD COPTIC HA → LATIN CAPITAL LETTER P	# 
+0420 ;	0050 ;	MA	# ( Р → P ) CYRILLIC CAPITAL LETTER ER → LATIN CAPITAL LETTER P	# 
+13E2 ;	0050 ;	MA	# ( Ꮲ → P ) CHEROKEE LETTER TLV → LATIN CAPITAL LETTER P	# 
+146D ;	0050 ;	MA	# ( ᑭ → P ) CANADIAN SYLLABICS KI → LATIN CAPITAL LETTER P	# 
+A4D1 ;	0050 ;	MA	# ( ꓑ → P ) LISU LETTER PA → LATIN CAPITAL LETTER P	# 
+10295 ;	0050 ;	MA	# ( 𐊕 → P ) LYCIAN LETTER R → LATIN CAPITAL LETTER P	# 
+
+01A5 ;	0070 0314 ;	MA	# ( ƥ → p̔ ) LATIN SMALL LETTER P WITH HOOK → LATIN SMALL LETTER P, COMBINING REVERSED COMMA ABOVE	# 
+
+1D7D ;	0070 0335 ;	MA	# ( ᵽ → p̵ ) LATIN SMALL LETTER P WITH STROKE → LATIN SMALL LETTER P, COMBINING SHORT STROKE OVERLAY	# 
+
+1477 ;	0070 00B7 ;	MA	# ( ᑷ → p· ) CANADIAN SYLLABICS WEST-CREE KWI → LATIN SMALL LETTER P, MIDDLE DOT	# →pᐧ→
+
+1486 ;	0050 0027 ;	MA	# ( ᒆ → P' ) CANADIAN SYLLABICS SOUTH-SLAVEY KIH → LATIN CAPITAL LETTER P, APOSTROPHE	# →ᑭᑊ→
+
+1D29 ;	1D18 ;	MA	# ( ᴩ → ᴘ ) GREEK LETTER SMALL CAPITAL RHO → LATIN LETTER SMALL CAPITAL P	# 
+ABB2 ;	1D18 ;	MA	# ( ꮲ → ᴘ ) CHEROKEE SMALL LETTER TLV → LATIN LETTER SMALL CAPITAL P	# 
+
+03C6 ;	0278 ;	MA	# ( φ → ɸ ) GREEK SMALL LETTER PHI → LATIN SMALL LETTER PHI	# 
+03D5 ;	0278 ;	MA	# ( ϕ → ɸ ) GREEK PHI SYMBOL → LATIN SMALL LETTER PHI	# 
+1D6D7 ;	0278 ;	MA	# ( 𝛗 → ɸ ) MATHEMATICAL BOLD SMALL PHI → LATIN SMALL LETTER PHI	# →φ→
+1D6DF ;	0278 ;	MA	# ( 𝛟 → ɸ ) MATHEMATICAL BOLD PHI SYMBOL → LATIN SMALL LETTER PHI	# →φ→
+1D711 ;	0278 ;	MA	# ( 𝜑 → ɸ ) MATHEMATICAL ITALIC SMALL PHI → LATIN SMALL LETTER PHI	# →φ→
+1D719 ;	0278 ;	MA	# ( 𝜙 → ɸ ) MATHEMATICAL ITALIC PHI SYMBOL → LATIN SMALL LETTER PHI	# →φ→
+1D74B ;	0278 ;	MA	# ( 𝝋 → ɸ ) MATHEMATICAL BOLD ITALIC SMALL PHI → LATIN SMALL LETTER PHI	# →φ→
+1D753 ;	0278 ;	MA	# ( 𝝓 → ɸ ) MATHEMATICAL BOLD ITALIC PHI SYMBOL → LATIN SMALL LETTER PHI	# →φ→
+1D785 ;	0278 ;	MA	# ( 𝞅 → ɸ ) MATHEMATICAL SANS-SERIF BOLD SMALL PHI → LATIN SMALL LETTER PHI	# →φ→
+1D78D ;	0278 ;	MA	# ( 𝞍 → ɸ ) MATHEMATICAL SANS-SERIF BOLD PHI SYMBOL → LATIN SMALL LETTER PHI	# →φ→
+1D7BF ;	0278 ;	MA	# ( 𝞿 → ɸ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PHI → LATIN SMALL LETTER PHI	# →φ→
+1D7C7 ;	0278 ;	MA	# ( 𝟇 → ɸ ) MATHEMATICAL SANS-SERIF BOLD ITALIC PHI SYMBOL → LATIN SMALL LETTER PHI	# →φ→
+2CAB ;	0278 ;	MA	# ( ⲫ → ɸ ) COPTIC SMALL LETTER FI → LATIN SMALL LETTER PHI	# →ϕ→
+2CE1 ;	0278 ;	MA	# ( ⳡ → ɸ ) COPTIC SMALL LETTER OLD NUBIAN NYI → LATIN SMALL LETTER PHI	# →φ→
+2CE0 ;	0278 ;	MA	# ( Ⳡ → ɸ ) COPTIC CAPITAL LETTER OLD NUBIAN NYI → LATIN SMALL LETTER PHI	# →φ→
+0444 ;	0278 ;	MA	# ( ф → ɸ ) CYRILLIC SMALL LETTER EF → LATIN SMALL LETTER PHI	# 
+
+1D42A ;	0071 ;	MA	# ( 𝐪 → q ) MATHEMATICAL BOLD SMALL Q → LATIN SMALL LETTER Q	# 
+1D45E ;	0071 ;	MA	# ( 𝑞 → q ) MATHEMATICAL ITALIC SMALL Q → LATIN SMALL LETTER Q	# 
+1D492 ;	0071 ;	MA	# ( 𝒒 → q ) MATHEMATICAL BOLD ITALIC SMALL Q → LATIN SMALL LETTER Q	# 
+1D4C6 ;	0071 ;	MA	# ( 𝓆 → q ) MATHEMATICAL SCRIPT SMALL Q → LATIN SMALL LETTER Q	# 
+1D4FA ;	0071 ;	MA	# ( 𝓺 → q ) MATHEMATICAL BOLD SCRIPT SMALL Q → LATIN SMALL LETTER Q	# 
+1D52E ;	0071 ;	MA	# ( 𝔮 → q ) MATHEMATICAL FRAKTUR SMALL Q → LATIN SMALL LETTER Q	# 
+1D562 ;	0071 ;	MA	# ( 𝕢 → q ) MATHEMATICAL DOUBLE-STRUCK SMALL Q → LATIN SMALL LETTER Q	# 
+1D596 ;	0071 ;	MA	# ( 𝖖 → q ) MATHEMATICAL BOLD FRAKTUR SMALL Q → LATIN SMALL LETTER Q	# 
+1D5CA ;	0071 ;	MA	# ( 𝗊 → q ) MATHEMATICAL SANS-SERIF SMALL Q → LATIN SMALL LETTER Q	# 
+1D5FE ;	0071 ;	MA	# ( 𝗾 → q ) MATHEMATICAL SANS-SERIF BOLD SMALL Q → LATIN SMALL LETTER Q	# 
+1D632 ;	0071 ;	MA	# ( 𝘲 → q ) MATHEMATICAL SANS-SERIF ITALIC SMALL Q → LATIN SMALL LETTER Q	# 
+1D666 ;	0071 ;	MA	# ( 𝙦 → q ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Q → LATIN SMALL LETTER Q	# 
+1D69A ;	0071 ;	MA	# ( 𝚚 → q ) MATHEMATICAL MONOSPACE SMALL Q → LATIN SMALL LETTER Q	# 
+051B ;	0071 ;	MA	# ( ԛ → q ) CYRILLIC SMALL LETTER QA → LATIN SMALL LETTER Q	# 
+0563 ;	0071 ;	MA	# ( գ → q ) ARMENIAN SMALL LETTER GIM → LATIN SMALL LETTER Q	# 
+0566 ;	0071 ;	MA	# ( զ → q ) ARMENIAN SMALL LETTER ZA → LATIN SMALL LETTER Q	# 
+
+211A ;	0051 ;	MA	# ( ℚ → Q ) DOUBLE-STRUCK CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1CCE6 ;	0051 ;	MA	#* ( 𜳦 → Q ) OUTLINED LATIN CAPITAL LETTER Q → LATIN CAPITAL LETTER Q	# 
+1D410 ;	0051 ;	MA	# ( 𝐐 → Q ) MATHEMATICAL BOLD CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D444 ;	0051 ;	MA	# ( 𝑄 → Q ) MATHEMATICAL ITALIC CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D478 ;	0051 ;	MA	# ( 𝑸 → Q ) MATHEMATICAL BOLD ITALIC CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D4AC ;	0051 ;	MA	# ( 𝒬 → Q ) MATHEMATICAL SCRIPT CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D4E0 ;	0051 ;	MA	# ( 𝓠 → Q ) MATHEMATICAL BOLD SCRIPT CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D514 ;	0051 ;	MA	# ( 𝔔 → Q ) MATHEMATICAL FRAKTUR CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D57C ;	0051 ;	MA	# ( 𝕼 → Q ) MATHEMATICAL BOLD FRAKTUR CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D5B0 ;	0051 ;	MA	# ( 𝖰 → Q ) MATHEMATICAL SANS-SERIF CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D5E4 ;	0051 ;	MA	# ( 𝗤 → Q ) MATHEMATICAL SANS-SERIF BOLD CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D618 ;	0051 ;	MA	# ( 𝘘 → Q ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D64C ;	0051 ;	MA	# ( 𝙌 → Q ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+1D680 ;	0051 ;	MA	# ( 𝚀 → Q ) MATHEMATICAL MONOSPACE CAPITAL Q → LATIN CAPITAL LETTER Q	# 
+2D55 ;	0051 ;	MA	# ( ⵕ → Q ) TIFINAGH LETTER YARR → LATIN CAPITAL LETTER Q	# 
+
+02A0 ;	0071 0314 ;	MA	# ( ʠ → q̔ ) LATIN SMALL LETTER Q WITH HOOK → LATIN SMALL LETTER Q, COMBINING REVERSED COMMA ABOVE	# 
+
+1F700 ;	0051 0045 ;	MA	#* ( 🜀 → QE ) ALCHEMICAL SYMBOL FOR QUINTESSENCE → LATIN CAPITAL LETTER Q, LATIN CAPITAL LETTER E	# 
+
+1D90 ;	024B ;	MA	# ( ᶐ → ɋ ) LATIN SMALL LETTER ALPHA WITH RETROFLEX HOOK → LATIN SMALL LETTER Q WITH HOOK TAIL	# 
+
+1D0B ;	0138 ;	MA	# ( ᴋ → ĸ ) LATIN LETTER SMALL CAPITAL K → LATIN SMALL LETTER KRA	# 
+03BA ;	0138 ;	MA	# ( κ → ĸ ) GREEK SMALL LETTER KAPPA → LATIN SMALL LETTER KRA	# 
+03F0 ;	0138 ;	MA	# ( ϰ → ĸ ) GREEK KAPPA SYMBOL → LATIN SMALL LETTER KRA	# →κ→
+1D6CB ;	0138 ;	MA	# ( 𝛋 → ĸ ) MATHEMATICAL BOLD SMALL KAPPA → LATIN SMALL LETTER KRA	# →κ→
+1D6DE ;	0138 ;	MA	# ( 𝛞 → ĸ ) MATHEMATICAL BOLD KAPPA SYMBOL → LATIN SMALL LETTER KRA	# →κ→
+1D705 ;	0138 ;	MA	# ( 𝜅 → ĸ ) MATHEMATICAL ITALIC SMALL KAPPA → LATIN SMALL LETTER KRA	# →κ→
+1D718 ;	0138 ;	MA	# ( 𝜘 → ĸ ) MATHEMATICAL ITALIC KAPPA SYMBOL → LATIN SMALL LETTER KRA	# →κ→
+1D73F ;	0138 ;	MA	# ( 𝜿 → ĸ ) MATHEMATICAL BOLD ITALIC SMALL KAPPA → LATIN SMALL LETTER KRA	# →κ→
+1D752 ;	0138 ;	MA	# ( 𝝒 → ĸ ) MATHEMATICAL BOLD ITALIC KAPPA SYMBOL → LATIN SMALL LETTER KRA	# →κ→
+1D779 ;	0138 ;	MA	# ( 𝝹 → ĸ ) MATHEMATICAL SANS-SERIF BOLD SMALL KAPPA → LATIN SMALL LETTER KRA	# →κ→
+1D78C ;	0138 ;	MA	# ( 𝞌 → ĸ ) MATHEMATICAL SANS-SERIF BOLD KAPPA SYMBOL → LATIN SMALL LETTER KRA	# →κ→
+1D7B3 ;	0138 ;	MA	# ( 𝞳 → ĸ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL KAPPA → LATIN SMALL LETTER KRA	# →κ→
+1D7C6 ;	0138 ;	MA	# ( 𝟆 → ĸ ) MATHEMATICAL SANS-SERIF BOLD ITALIC KAPPA SYMBOL → LATIN SMALL LETTER KRA	# →κ→
+2C95 ;	0138 ;	MA	# ( ⲕ → ĸ ) COPTIC SMALL LETTER KAPA → LATIN SMALL LETTER KRA	# →κ→
+043A ;	0138 ;	MA	# ( к → ĸ ) CYRILLIC SMALL LETTER KA → LATIN SMALL LETTER KRA	# 
+ABB6 ;	0138 ;	MA	# ( ꮶ → ĸ ) CHEROKEE SMALL LETTER TSO → LATIN SMALL LETTER KRA	# →ᴋ→
+
+049B ;	0138 0329 ;	MA	# ( қ → ĸ̩ ) CYRILLIC SMALL LETTER KA WITH DESCENDER → LATIN SMALL LETTER KRA, COMBINING VERTICAL LINE BELOW	# →к̩→
+
+049F ;	0138 0335 ;	MA	# ( ҟ → ĸ̵ ) CYRILLIC SMALL LETTER KA WITH STROKE → LATIN SMALL LETTER KRA, COMBINING SHORT STROKE OVERLAY	# →к̵→
+
+1D42B ;	0072 ;	MA	# ( 𝐫 → r ) MATHEMATICAL BOLD SMALL R → LATIN SMALL LETTER R	# 
+1D45F ;	0072 ;	MA	# ( 𝑟 → r ) MATHEMATICAL ITALIC SMALL R → LATIN SMALL LETTER R	# 
+1D493 ;	0072 ;	MA	# ( 𝒓 → r ) MATHEMATICAL BOLD ITALIC SMALL R → LATIN SMALL LETTER R	# 
+1D4C7 ;	0072 ;	MA	# ( 𝓇 → r ) MATHEMATICAL SCRIPT SMALL R → LATIN SMALL LETTER R	# 
+1D4FB ;	0072 ;	MA	# ( 𝓻 → r ) MATHEMATICAL BOLD SCRIPT SMALL R → LATIN SMALL LETTER R	# 
+1D52F ;	0072 ;	MA	# ( 𝔯 → r ) MATHEMATICAL FRAKTUR SMALL R → LATIN SMALL LETTER R	# 
+1D563 ;	0072 ;	MA	# ( 𝕣 → r ) MATHEMATICAL DOUBLE-STRUCK SMALL R → LATIN SMALL LETTER R	# 
+1D597 ;	0072 ;	MA	# ( 𝖗 → r ) MATHEMATICAL BOLD FRAKTUR SMALL R → LATIN SMALL LETTER R	# 
+1D5CB ;	0072 ;	MA	# ( 𝗋 → r ) MATHEMATICAL SANS-SERIF SMALL R → LATIN SMALL LETTER R	# 
+1D5FF ;	0072 ;	MA	# ( 𝗿 → r ) MATHEMATICAL SANS-SERIF BOLD SMALL R → LATIN SMALL LETTER R	# 
+1D633 ;	0072 ;	MA	# ( 𝘳 → r ) MATHEMATICAL SANS-SERIF ITALIC SMALL R → LATIN SMALL LETTER R	# 
+1D667 ;	0072 ;	MA	# ( 𝙧 → r ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL R → LATIN SMALL LETTER R	# 
+1D69B ;	0072 ;	MA	# ( 𝚛 → r ) MATHEMATICAL MONOSPACE SMALL R → LATIN SMALL LETTER R	# 
+AB47 ;	0072 ;	MA	# ( ꭇ → r ) LATIN SMALL LETTER R WITHOUT HANDLE → LATIN SMALL LETTER R	# 
+AB48 ;	0072 ;	MA	# ( ꭈ → r ) LATIN SMALL LETTER DOUBLE R → LATIN SMALL LETTER R	# 
+1D26 ;	0072 ;	MA	# ( ᴦ → r ) GREEK LETTER SMALL CAPITAL GAMMA → LATIN SMALL LETTER R	# →г→
+2C85 ;	0072 ;	MA	# ( ⲅ → r ) COPTIC SMALL LETTER GAMMA → LATIN SMALL LETTER R	# →г→
+0433 ;	0072 ;	MA	# ( г → r ) CYRILLIC SMALL LETTER GHE → LATIN SMALL LETTER R	# 
+AB81 ;	0072 ;	MA	# ( ꮁ → r ) CHEROKEE SMALL LETTER HU → LATIN SMALL LETTER R	# →ᴦ→→г→
+
+1D216 ;	0052 ;	MA	#* ( 𝈖 → R ) GREEK VOCAL NOTATION SYMBOL-23 → LATIN CAPITAL LETTER R	# 
+211B ;	0052 ;	MA	# ( ℛ → R ) SCRIPT CAPITAL R → LATIN CAPITAL LETTER R	# 
+211C ;	0052 ;	MA	# ( ℜ → R ) BLACK-LETTER CAPITAL R → LATIN CAPITAL LETTER R	# 
+211D ;	0052 ;	MA	# ( ℝ → R ) DOUBLE-STRUCK CAPITAL R → LATIN CAPITAL LETTER R	# 
+1CCE7 ;	0052 ;	MA	#* ( 𜳧 → R ) OUTLINED LATIN CAPITAL LETTER R → LATIN CAPITAL LETTER R	# 
+1D411 ;	0052 ;	MA	# ( 𝐑 → R ) MATHEMATICAL BOLD CAPITAL R → LATIN CAPITAL LETTER R	# 
+1D445 ;	0052 ;	MA	# ( 𝑅 → R ) MATHEMATICAL ITALIC CAPITAL R → LATIN CAPITAL LETTER R	# 
+1D479 ;	0052 ;	MA	# ( 𝑹 → R ) MATHEMATICAL BOLD ITALIC CAPITAL R → LATIN CAPITAL LETTER R	# 
+1D4E1 ;	0052 ;	MA	# ( 𝓡 → R ) MATHEMATICAL BOLD SCRIPT CAPITAL R → LATIN CAPITAL LETTER R	# 
+1D57D ;	0052 ;	MA	# ( 𝕽 → R ) MATHEMATICAL BOLD FRAKTUR CAPITAL R → LATIN CAPITAL LETTER R	# 
+1D5B1 ;	0052 ;	MA	# ( 𝖱 → R ) MATHEMATICAL SANS-SERIF CAPITAL R → LATIN CAPITAL LETTER R	# 
+1D5E5 ;	0052 ;	MA	# ( 𝗥 → R ) MATHEMATICAL SANS-SERIF BOLD CAPITAL R → LATIN CAPITAL LETTER R	# 
+1D619 ;	0052 ;	MA	# ( 𝘙 → R ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL R → LATIN CAPITAL LETTER R	# 
+1D64D ;	0052 ;	MA	# ( 𝙍 → R ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL R → LATIN CAPITAL LETTER R	# 
+1D681 ;	0052 ;	MA	# ( 𝚁 → R ) MATHEMATICAL MONOSPACE CAPITAL R → LATIN CAPITAL LETTER R	# 
+01A6 ;	0052 ;	MA	# ( Ʀ → R ) LATIN LETTER YR → LATIN CAPITAL LETTER R	# 
+13A1 ;	0052 ;	MA	# ( Ꭱ → R ) CHEROKEE LETTER E → LATIN CAPITAL LETTER R	# 
+13D2 ;	0052 ;	MA	# ( Ꮢ → R ) CHEROKEE LETTER SV → LATIN CAPITAL LETTER R	# 
+104B4 ;	0052 ;	MA	# ( 𐒴 → R ) OSAGE CAPITAL LETTER BRA → LATIN CAPITAL LETTER R	# →Ʀ→
+1587 ;	0052 ;	MA	# ( ᖇ → R ) CANADIAN SYLLABICS TLHI → LATIN CAPITAL LETTER R	# 
+A4E3 ;	0052 ;	MA	# ( ꓣ → R ) LISU LETTER ZHA → LATIN CAPITAL LETTER R	# 
+16F35 ;	0052 ;	MA	# ( 𖼵 → R ) MIAO LETTER ZHA → LATIN CAPITAL LETTER R	# 
+
+027D ;	0072 0328 ;	MA	# ( ɽ → r̨ ) LATIN SMALL LETTER R WITH TAIL → LATIN SMALL LETTER R, COMBINING OGONEK	# 
+
+027C ;	0072 0329 ;	MA	# ( ɼ → r̩ ) LATIN SMALL LETTER R WITH LONG LEG → LATIN SMALL LETTER R, COMBINING VERTICAL LINE BELOW	# 
+
+024D ;	0072 0335 ;	MA	# ( ɍ → r̵ ) LATIN SMALL LETTER R WITH STROKE → LATIN SMALL LETTER R, COMBINING SHORT STROKE OVERLAY	# 
+0493 ;	0072 0335 ;	MA	# ( ғ → r̵ ) CYRILLIC SMALL LETTER GHE WITH STROKE → LATIN SMALL LETTER R, COMBINING SHORT STROKE OVERLAY	# →г̵→
+
+1D72 ;	0072 0334 ;	MA	# ( ᵲ → r̴ ) LATIN SMALL LETTER R WITH MIDDLE TILDE → LATIN SMALL LETTER R, COMBINING TILDE OVERLAY	# 
+
+0491 ;	0072 0027 ;	MA	# ( ґ → r' ) CYRILLIC SMALL LETTER GHE WITH UPTURN → LATIN SMALL LETTER R, APOSTROPHE	# →гˈ→
+
+118E3 ;	0072 006E ;	MA	# ( 𑣣 → rn ) WARANG CITI DIGIT THREE → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+006D ;	0072 006E ;	MA	# ( m → rn ) LATIN SMALL LETTER M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# 
+217F ;	0072 006E ;	MA	# ( ⅿ → rn ) SMALL ROMAN NUMERAL ONE THOUSAND → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D426 ;	0072 006E ;	MA	# ( 𝐦 → rn ) MATHEMATICAL BOLD SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D45A ;	0072 006E ;	MA	# ( 𝑚 → rn ) MATHEMATICAL ITALIC SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D48E ;	0072 006E ;	MA	# ( 𝒎 → rn ) MATHEMATICAL BOLD ITALIC SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D4C2 ;	0072 006E ;	MA	# ( 𝓂 → rn ) MATHEMATICAL SCRIPT SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D4F6 ;	0072 006E ;	MA	# ( 𝓶 → rn ) MATHEMATICAL BOLD SCRIPT SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D52A ;	0072 006E ;	MA	# ( 𝔪 → rn ) MATHEMATICAL FRAKTUR SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D55E ;	0072 006E ;	MA	# ( 𝕞 → rn ) MATHEMATICAL DOUBLE-STRUCK SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D592 ;	0072 006E ;	MA	# ( 𝖒 → rn ) MATHEMATICAL BOLD FRAKTUR SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D5C6 ;	0072 006E ;	MA	# ( 𝗆 → rn ) MATHEMATICAL SANS-SERIF SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D5FA ;	0072 006E ;	MA	# ( 𝗺 → rn ) MATHEMATICAL SANS-SERIF BOLD SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D62E ;	0072 006E ;	MA	# ( 𝘮 → rn ) MATHEMATICAL SANS-SERIF ITALIC SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D662 ;	0072 006E ;	MA	# ( 𝙢 → rn ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+1D696 ;	0072 006E ;	MA	# ( 𝚖 → rn ) MATHEMATICAL MONOSPACE SMALL M → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+11700 ;	0072 006E ;	MA	# ( 𑜀 → rn ) AHOM LETTER KA → LATIN SMALL LETTER R, LATIN SMALL LETTER N	# →m→
+
+20A5 ;	0072 006E 0338 ;	MA	#* ( ₥ → rn̸ ) MILL SIGN → LATIN SMALL LETTER R, LATIN SMALL LETTER N, COMBINING LONG SOLIDUS OVERLAY	# →m̷→
+
+0271 ;	0072 006E 0326 ;	MA	# ( ɱ → rn̦ ) LATIN SMALL LETTER M WITH HOOK → LATIN SMALL LETTER R, LATIN SMALL LETTER N, COMBINING COMMA BELOW	# →m̡→
+
+1D6F ;	0072 006E 0334 ;	MA	# ( ᵯ → rn̴ ) LATIN SMALL LETTER M WITH MIDDLE TILDE → LATIN SMALL LETTER R, LATIN SMALL LETTER N, COMBINING TILDE OVERLAY	# →m̴→
+
+20A8 ;	0052 0073 ;	MA	#* ( ₨ → Rs ) RUPEE SIGN → LATIN CAPITAL LETTER R, LATIN SMALL LETTER S	# 
+
+AB71 ;	0280 ;	MA	# ( ꭱ → ʀ ) CHEROKEE SMALL LETTER E → LATIN LETTER SMALL CAPITAL R	# 
+ABA2 ;	0280 ;	MA	# ( ꮢ → ʀ ) CHEROKEE SMALL LETTER SV → LATIN LETTER SMALL CAPITAL R	# 
+
+044F ;	1D19 ;	MA	# ( я → ᴙ ) CYRILLIC SMALL LETTER YA → LATIN LETTER SMALL CAPITAL REVERSED R	# 
+
+1D73 ;	027E 0334 ;	MA	# ( ᵳ → ɾ̴ ) LATIN SMALL LETTER R WITH FISHHOOK AND MIDDLE TILDE → LATIN SMALL LETTER R WITH FISHHOOK, COMBINING TILDE OVERLAY	# 
+
+2129 ;	027F ;	MA	#* ( ℩ → ɿ ) TURNED GREEK SMALL LETTER IOTA → LATIN SMALL LETTER REVERSED R WITH FISHHOOK	# 
+
+FF53 ;	0073 ;	MA	# ( ｓ → s ) FULLWIDTH LATIN SMALL LETTER S → LATIN SMALL LETTER S	# →ѕ→
+1D42C ;	0073 ;	MA	# ( 𝐬 → s ) MATHEMATICAL BOLD SMALL S → LATIN SMALL LETTER S	# 
+1D460 ;	0073 ;	MA	# ( 𝑠 → s ) MATHEMATICAL ITALIC SMALL S → LATIN SMALL LETTER S	# 
+1D494 ;	0073 ;	MA	# ( 𝒔 → s ) MATHEMATICAL BOLD ITALIC SMALL S → LATIN SMALL LETTER S	# 
+1D4C8 ;	0073 ;	MA	# ( 𝓈 → s ) MATHEMATICAL SCRIPT SMALL S → LATIN SMALL LETTER S	# 
+1D4FC ;	0073 ;	MA	# ( 𝓼 → s ) MATHEMATICAL BOLD SCRIPT SMALL S → LATIN SMALL LETTER S	# 
+1D530 ;	0073 ;	MA	# ( 𝔰 → s ) MATHEMATICAL FRAKTUR SMALL S → LATIN SMALL LETTER S	# 
+1D564 ;	0073 ;	MA	# ( 𝕤 → s ) MATHEMATICAL DOUBLE-STRUCK SMALL S → LATIN SMALL LETTER S	# 
+1D598 ;	0073 ;	MA	# ( 𝖘 → s ) MATHEMATICAL BOLD FRAKTUR SMALL S → LATIN SMALL LETTER S	# 
+1D5CC ;	0073 ;	MA	# ( 𝗌 → s ) MATHEMATICAL SANS-SERIF SMALL S → LATIN SMALL LETTER S	# 
+1D600 ;	0073 ;	MA	# ( 𝘀 → s ) MATHEMATICAL SANS-SERIF BOLD SMALL S → LATIN SMALL LETTER S	# 
+1D634 ;	0073 ;	MA	# ( 𝘴 → s ) MATHEMATICAL SANS-SERIF ITALIC SMALL S → LATIN SMALL LETTER S	# 
+1D668 ;	0073 ;	MA	# ( 𝙨 → s ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL S → LATIN SMALL LETTER S	# 
+1D69C ;	0073 ;	MA	# ( 𝚜 → s ) MATHEMATICAL MONOSPACE SMALL S → LATIN SMALL LETTER S	# 
+A731 ;	0073 ;	MA	# ( ꜱ → s ) LATIN LETTER SMALL CAPITAL S → LATIN SMALL LETTER S	# 
+01BD ;	0073 ;	MA	# ( ƽ → s ) LATIN SMALL LETTER TONE FIVE → LATIN SMALL LETTER S	# 
+0455 ;	0073 ;	MA	# ( ѕ → s ) CYRILLIC SMALL LETTER DZE → LATIN SMALL LETTER S	# 
+0D1F ;	0073 ;	MA	# ( ട → s ) MALAYALAM LETTER TTA → LATIN SMALL LETTER S	# 
+ABAA ;	0073 ;	MA	# ( ꮪ → s ) CHEROKEE SMALL LETTER DU → LATIN SMALL LETTER S	# →ꜱ→
+118C1 ;	0073 ;	MA	# ( 𑣁 → s ) WARANG CITI SMALL LETTER A → LATIN SMALL LETTER S	# 
+10448 ;	0073 ;	MA	# ( 𐑈 → s ) DESERET SMALL LETTER ZHEE → LATIN SMALL LETTER S	# 
+
+FF33 ;	0053 ;	MA	# ( Ｓ → S ) FULLWIDTH LATIN CAPITAL LETTER S → LATIN CAPITAL LETTER S	# →Ѕ→
+1CCE8 ;	0053 ;	MA	#* ( 𜳨 → S ) OUTLINED LATIN CAPITAL LETTER S → LATIN CAPITAL LETTER S	# 
+1D412 ;	0053 ;	MA	# ( 𝐒 → S ) MATHEMATICAL BOLD CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D446 ;	0053 ;	MA	# ( 𝑆 → S ) MATHEMATICAL ITALIC CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D47A ;	0053 ;	MA	# ( 𝑺 → S ) MATHEMATICAL BOLD ITALIC CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D4AE ;	0053 ;	MA	# ( 𝒮 → S ) MATHEMATICAL SCRIPT CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D4E2 ;	0053 ;	MA	# ( 𝓢 → S ) MATHEMATICAL BOLD SCRIPT CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D516 ;	0053 ;	MA	# ( 𝔖 → S ) MATHEMATICAL FRAKTUR CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D54A ;	0053 ;	MA	# ( 𝕊 → S ) MATHEMATICAL DOUBLE-STRUCK CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D57E ;	0053 ;	MA	# ( 𝕾 → S ) MATHEMATICAL BOLD FRAKTUR CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D5B2 ;	0053 ;	MA	# ( 𝖲 → S ) MATHEMATICAL SANS-SERIF CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D5E6 ;	0053 ;	MA	# ( 𝗦 → S ) MATHEMATICAL SANS-SERIF BOLD CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D61A ;	0053 ;	MA	# ( 𝘚 → S ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D64E ;	0053 ;	MA	# ( 𝙎 → S ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL S → LATIN CAPITAL LETTER S	# 
+1D682 ;	0053 ;	MA	# ( 𝚂 → S ) MATHEMATICAL MONOSPACE CAPITAL S → LATIN CAPITAL LETTER S	# 
+0405 ;	0053 ;	MA	# ( Ѕ → S ) CYRILLIC CAPITAL LETTER DZE → LATIN CAPITAL LETTER S	# 
+054F ;	0053 ;	MA	# ( Տ → S ) ARMENIAN CAPITAL LETTER TIWN → LATIN CAPITAL LETTER S	# 
+13D5 ;	0053 ;	MA	# ( Ꮥ → S ) CHEROKEE LETTER DE → LATIN CAPITAL LETTER S	# 
+13DA ;	0053 ;	MA	# ( Ꮪ → S ) CHEROKEE LETTER DU → LATIN CAPITAL LETTER S	# 
+A4E2 ;	0053 ;	MA	# ( ꓢ → S ) LISU LETTER SA → LATIN CAPITAL LETTER S	# 
+16F3A ;	0053 ;	MA	# ( 𖼺 → S ) MIAO LETTER SA → LATIN CAPITAL LETTER S	# 
+10296 ;	0053 ;	MA	# ( 𐊖 → S ) LYCIAN LETTER S → LATIN CAPITAL LETTER S	# 
+10420 ;	0053 ;	MA	# ( 𐐠 → S ) DESERET CAPITAL LETTER ZHEE → LATIN CAPITAL LETTER S	# 
+
+0282 ;	0073 0328 ;	MA	# ( ʂ → s̨ ) LATIN SMALL LETTER S WITH HOOK → LATIN SMALL LETTER S, COMBINING OGONEK	# 
+
+1D74 ;	0073 0334 ;	MA	# ( ᵴ → s̴ ) LATIN SMALL LETTER S WITH MIDDLE TILDE → LATIN SMALL LETTER S, COMBINING TILDE OVERLAY	# 
+
+A7B5 ;	00DF ;	MA	# ( ꞵ → ß ) LATIN SMALL LETTER BETA → LATIN SMALL LETTER SHARP S	# →β→
+1E9E ;	00DF ;	MA	# ( ẞ → ß ) LATIN CAPITAL LETTER SHARP S → LATIN SMALL LETTER SHARP S	# 
+A7D6 ;	00DF ;	MA	# ( Ꟗ → ß ) LATIN CAPITAL LETTER MIDDLE SCOTS S → LATIN SMALL LETTER SHARP S	# →β→
+03B2 ;	00DF ;	MA	# ( β → ß ) GREEK SMALL LETTER BETA → LATIN SMALL LETTER SHARP S	# 
+03D0 ;	00DF ;	MA	# ( ϐ → ß ) GREEK BETA SYMBOL → LATIN SMALL LETTER SHARP S	# →β→
+1D6C3 ;	00DF ;	MA	# ( 𝛃 → ß ) MATHEMATICAL BOLD SMALL BETA → LATIN SMALL LETTER SHARP S	# →β→
+1D6FD ;	00DF ;	MA	# ( 𝛽 → ß ) MATHEMATICAL ITALIC SMALL BETA → LATIN SMALL LETTER SHARP S	# →β→
+1D737 ;	00DF ;	MA	# ( 𝜷 → ß ) MATHEMATICAL BOLD ITALIC SMALL BETA → LATIN SMALL LETTER SHARP S	# →β→
+1D771 ;	00DF ;	MA	# ( 𝝱 → ß ) MATHEMATICAL SANS-SERIF BOLD SMALL BETA → LATIN SMALL LETTER SHARP S	# →β→
+1D7AB ;	00DF ;	MA	# ( 𝞫 → ß ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL BETA → LATIN SMALL LETTER SHARP S	# →β→
+13F0 ;	00DF ;	MA	# ( Ᏸ → ß ) CHEROKEE LETTER YE → LATIN SMALL LETTER SHARP S	# →β→
+
+1F75C ;	0073 0073 0073 ;	MA	#* ( 🝜 → sss ) ALCHEMICAL SYMBOL FOR STRATUM SUPER STRATUM → LATIN SMALL LETTER S, LATIN SMALL LETTER S, LATIN SMALL LETTER S	# 
+
+FB06 ;	0073 0074 ;	MA	# ( st → st ) LATIN SMALL LIGATURE ST → LATIN SMALL LETTER S, LATIN SMALL LETTER T	# 
+
+222B ;	0283 ;	MA	#* ( ∫ → ʃ ) INTEGRAL → LATIN SMALL LETTER ESH	# 
+AB4D ;	0283 ;	MA	# ( ꭍ → ʃ ) LATIN SMALL LETTER BASELINE ESH → LATIN SMALL LETTER ESH	# 
+
+2211 ;	01A9 ;	MA	#* ( ∑ → Ʃ ) N-ARY SUMMATION → LATIN CAPITAL LETTER ESH	# 
+2140 ;	01A9 ;	MA	#* ( ⅀ → Ʃ ) DOUBLE-STRUCK N-ARY SUMMATION → LATIN CAPITAL LETTER ESH	# →∑→
+03A3 ;	01A9 ;	MA	# ( Σ → Ʃ ) GREEK CAPITAL LETTER SIGMA → LATIN CAPITAL LETTER ESH	# 
+1D6BA ;	01A9 ;	MA	# ( 𝚺 → Ʃ ) MATHEMATICAL BOLD CAPITAL SIGMA → LATIN CAPITAL LETTER ESH	# →Σ→
+1D6F4 ;	01A9 ;	MA	# ( 𝛴 → Ʃ ) MATHEMATICAL ITALIC CAPITAL SIGMA → LATIN CAPITAL LETTER ESH	# →Σ→
+1D72E ;	01A9 ;	MA	# ( 𝜮 → Ʃ ) MATHEMATICAL BOLD ITALIC CAPITAL SIGMA → LATIN CAPITAL LETTER ESH	# →Σ→
+1D768 ;	01A9 ;	MA	# ( 𝝨 → Ʃ ) MATHEMATICAL SANS-SERIF BOLD CAPITAL SIGMA → LATIN CAPITAL LETTER ESH	# →Σ→
+1D7A2 ;	01A9 ;	MA	# ( 𝞢 → Ʃ ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL SIGMA → LATIN CAPITAL LETTER ESH	# →Σ→
+2D49 ;	01A9 ;	MA	# ( ⵉ → Ʃ ) TIFINAGH LETTER YI → LATIN CAPITAL LETTER ESH	# 
+
+222C ;	0283 0283 ;	MA	#* ( ∬ → ʃʃ ) DOUBLE INTEGRAL → LATIN SMALL LETTER ESH, LATIN SMALL LETTER ESH	# →∫∫→
+
+222D ;	0283 0283 0283 ;	MA	#* ( ∭ → ʃʃʃ ) TRIPLE INTEGRAL → LATIN SMALL LETTER ESH, LATIN SMALL LETTER ESH, LATIN SMALL LETTER ESH	# →∫∫∫→
+
+2A0C ;	0283 0283 0283 0283 ;	MA	#* ( ⨌ → ʃʃʃʃ ) QUADRUPLE INTEGRAL OPERATOR → LATIN SMALL LETTER ESH, LATIN SMALL LETTER ESH, LATIN SMALL LETTER ESH, LATIN SMALL LETTER ESH	# →∫∫∫∫→
+
+1D42D ;	0074 ;	MA	# ( 𝐭 → t ) MATHEMATICAL BOLD SMALL T → LATIN SMALL LETTER T	# 
+1D461 ;	0074 ;	MA	# ( 𝑡 → t ) MATHEMATICAL ITALIC SMALL T → LATIN SMALL LETTER T	# 
+1D495 ;	0074 ;	MA	# ( 𝒕 → t ) MATHEMATICAL BOLD ITALIC SMALL T → LATIN SMALL LETTER T	# 
+1D4C9 ;	0074 ;	MA	# ( 𝓉 → t ) MATHEMATICAL SCRIPT SMALL T → LATIN SMALL LETTER T	# 
+1D4FD ;	0074 ;	MA	# ( 𝓽 → t ) MATHEMATICAL BOLD SCRIPT SMALL T → LATIN SMALL LETTER T	# 
+1D531 ;	0074 ;	MA	# ( 𝔱 → t ) MATHEMATICAL FRAKTUR SMALL T → LATIN SMALL LETTER T	# 
+1D565 ;	0074 ;	MA	# ( 𝕥 → t ) MATHEMATICAL DOUBLE-STRUCK SMALL T → LATIN SMALL LETTER T	# 
+1D599 ;	0074 ;	MA	# ( 𝖙 → t ) MATHEMATICAL BOLD FRAKTUR SMALL T → LATIN SMALL LETTER T	# 
+1D5CD ;	0074 ;	MA	# ( 𝗍 → t ) MATHEMATICAL SANS-SERIF SMALL T → LATIN SMALL LETTER T	# 
+1D601 ;	0074 ;	MA	# ( 𝘁 → t ) MATHEMATICAL SANS-SERIF BOLD SMALL T → LATIN SMALL LETTER T	# 
+1D635 ;	0074 ;	MA	# ( 𝘵 → t ) MATHEMATICAL SANS-SERIF ITALIC SMALL T → LATIN SMALL LETTER T	# 
+1D669 ;	0074 ;	MA	# ( 𝙩 → t ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL T → LATIN SMALL LETTER T	# 
+1D69D ;	0074 ;	MA	# ( 𝚝 → t ) MATHEMATICAL MONOSPACE SMALL T → LATIN SMALL LETTER T	# 
+
+22A4 ;	0054 ;	MA	#* ( ⊤ → T ) DOWN TACK → LATIN CAPITAL LETTER T	# 
+27D9 ;	0054 ;	MA	#* ( ⟙ → T ) LARGE DOWN TACK → LATIN CAPITAL LETTER T	# 
+1F768 ;	0054 ;	MA	#* ( 🝨 → T ) ALCHEMICAL SYMBOL FOR CRUCIBLE-4 → LATIN CAPITAL LETTER T	# 
+FF34 ;	0054 ;	MA	# ( Ｔ → T ) FULLWIDTH LATIN CAPITAL LETTER T → LATIN CAPITAL LETTER T	# →Т→
+1CCE9 ;	0054 ;	MA	#* ( 𜳩 → T ) OUTLINED LATIN CAPITAL LETTER T → LATIN CAPITAL LETTER T	# 
+1D413 ;	0054 ;	MA	# ( 𝐓 → T ) MATHEMATICAL BOLD CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D447 ;	0054 ;	MA	# ( 𝑇 → T ) MATHEMATICAL ITALIC CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D47B ;	0054 ;	MA	# ( 𝑻 → T ) MATHEMATICAL BOLD ITALIC CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D4AF ;	0054 ;	MA	# ( 𝒯 → T ) MATHEMATICAL SCRIPT CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D4E3 ;	0054 ;	MA	# ( 𝓣 → T ) MATHEMATICAL BOLD SCRIPT CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D517 ;	0054 ;	MA	# ( 𝔗 → T ) MATHEMATICAL FRAKTUR CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D54B ;	0054 ;	MA	# ( 𝕋 → T ) MATHEMATICAL DOUBLE-STRUCK CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D57F ;	0054 ;	MA	# ( 𝕿 → T ) MATHEMATICAL BOLD FRAKTUR CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D5B3 ;	0054 ;	MA	# ( 𝖳 → T ) MATHEMATICAL SANS-SERIF CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D5E7 ;	0054 ;	MA	# ( 𝗧 → T ) MATHEMATICAL SANS-SERIF BOLD CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D61B ;	0054 ;	MA	# ( 𝘛 → T ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D64F ;	0054 ;	MA	# ( 𝙏 → T ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL T → LATIN CAPITAL LETTER T	# 
+1D683 ;	0054 ;	MA	# ( 𝚃 → T ) MATHEMATICAL MONOSPACE CAPITAL T → LATIN CAPITAL LETTER T	# 
+03A4 ;	0054 ;	MA	# ( Τ → T ) GREEK CAPITAL LETTER TAU → LATIN CAPITAL LETTER T	# 
+1D6BB ;	0054 ;	MA	# ( 𝚻 → T ) MATHEMATICAL BOLD CAPITAL TAU → LATIN CAPITAL LETTER T	# →Τ→
+1D6F5 ;	0054 ;	MA	# ( 𝛵 → T ) MATHEMATICAL ITALIC CAPITAL TAU → LATIN CAPITAL LETTER T	# →Τ→
+1D72F ;	0054 ;	MA	# ( 𝜯 → T ) MATHEMATICAL BOLD ITALIC CAPITAL TAU → LATIN CAPITAL LETTER T	# →Τ→
+1D769 ;	0054 ;	MA	# ( 𝝩 → T ) MATHEMATICAL SANS-SERIF BOLD CAPITAL TAU → LATIN CAPITAL LETTER T	# →Τ→
+1D7A3 ;	0054 ;	MA	# ( 𝞣 → T ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL TAU → LATIN CAPITAL LETTER T	# →Τ→
+2CA6 ;	0054 ;	MA	# ( Ⲧ → T ) COPTIC CAPITAL LETTER TAU → LATIN CAPITAL LETTER T	# 
+0422 ;	0054 ;	MA	# ( Т → T ) CYRILLIC CAPITAL LETTER TE → LATIN CAPITAL LETTER T	# 
+13A2 ;	0054 ;	MA	# ( Ꭲ → T ) CHEROKEE LETTER I → LATIN CAPITAL LETTER T	# 
+A4D4 ;	0054 ;	MA	# ( ꓔ → T ) LISU LETTER TA → LATIN CAPITAL LETTER T	# 
+16F0A ;	0054 ;	MA	# ( 𖼊 → T ) MIAO LETTER TA → LATIN CAPITAL LETTER T	# 
+118BC ;	0054 ;	MA	# ( 𑢼 → T ) WARANG CITI CAPITAL LETTER HAR → LATIN CAPITAL LETTER T	# 
+10297 ;	0054 ;	MA	# ( 𐊗 → T ) LYCIAN LETTER T → LATIN CAPITAL LETTER T	# 
+102B1 ;	0054 ;	MA	# ( 𐊱 → T ) CARIAN LETTER C-18 → LATIN CAPITAL LETTER T	# 
+10315 ;	0054 ;	MA	# ( 𐌕 → T ) OLD ITALIC LETTER TE → LATIN CAPITAL LETTER T	# 
+
+01AD ;	0074 0314 ;	MA	# ( ƭ → t̔ ) LATIN SMALL LETTER T WITH HOOK → LATIN SMALL LETTER T, COMBINING REVERSED COMMA ABOVE	# 
+
+2361 ;	0054 0308 ;	MA	#* ( ⍡ → T̈ ) APL FUNCTIONAL SYMBOL UP TACK DIAERESIS → LATIN CAPITAL LETTER T, COMBINING DIAERESIS	# →⊤̈→
+
+023E ;	0054 0338 ;	MA	# ( Ⱦ → T̸ ) LATIN CAPITAL LETTER T WITH DIAGONAL STROKE → LATIN CAPITAL LETTER T, COMBINING LONG SOLIDUS OVERLAY	# 
+
+021A ;	0162 ;	MA	# ( Ț → Ţ ) LATIN CAPITAL LETTER T WITH COMMA BELOW → LATIN CAPITAL LETTER T WITH CEDILLA	# 
+
+01AE ;	0054 0328 ;	MA	# ( Ʈ → T̨ ) LATIN CAPITAL LETTER T WITH RETROFLEX HOOK → LATIN CAPITAL LETTER T, COMBINING OGONEK	# 
+
+04AC ;	0054 0329 ;	MA	# ( Ҭ → T̩ ) CYRILLIC CAPITAL LETTER TE WITH DESCENDER → LATIN CAPITAL LETTER T, COMBINING VERTICAL LINE BELOW	# →Т̩→
+
+20AE ;	0054 20EB ;	MA	#* ( ₮ → T⃫ ) TUGRIK SIGN → LATIN CAPITAL LETTER T, COMBINING LONG DOUBLE SOLIDUS OVERLAY	# →Т⃫→
+
+0167 ;	0074 0335 ;	MA	# ( ŧ → t̵ ) LATIN SMALL LETTER T WITH STROKE → LATIN SMALL LETTER T, COMBINING SHORT STROKE OVERLAY	# 
+
+0166 ;	0054 0335 ;	MA	# ( Ŧ → T̵ ) LATIN CAPITAL LETTER T WITH STROKE → LATIN CAPITAL LETTER T, COMBINING SHORT STROKE OVERLAY	# 
+
+1D75 ;	0074 0334 ;	MA	# ( ᵵ → t̴ ) LATIN SMALL LETTER T WITH MIDDLE TILDE → LATIN SMALL LETTER T, COMBINING TILDE OVERLAY	# 
+
+10A0 ;	A786 ;	MA	# ( Ⴀ → Ꞇ ) GEORGIAN CAPITAL LETTER AN → LATIN CAPITAL LETTER INSULAR T	# 
+
+A728 ;	0054 0033 ;	MA	# ( Ꜩ → T3 ) LATIN CAPITAL LETTER TZ → LATIN CAPITAL LETTER T, DIGIT THREE	# →TƷ→
+
+02A8 ;	0074 0255 ;	MA	# ( ʨ → tɕ ) LATIN SMALL LETTER TC DIGRAPH WITH CURL → LATIN SMALL LETTER T, LATIN SMALL LETTER C WITH CURL	# 
+
+2121 ;	0054 0045 004C ;	MA	#* ( ℡ → TEL ) TELEPHONE SIGN → LATIN CAPITAL LETTER T, LATIN CAPITAL LETTER E, LATIN CAPITAL LETTER L	# 
+
+A777 ;	0074 0066 ;	MA	# ( ꝷ → tf ) LATIN SMALL LETTER TUM → LATIN SMALL LETTER T, LATIN SMALL LETTER F	# 
+
+02A6 ;	0074 0073 ;	MA	# ( ʦ → ts ) LATIN SMALL LETTER TS DIGRAPH → LATIN SMALL LETTER T, LATIN SMALL LETTER S	# 
+
+02A7 ;	0074 0283 ;	MA	# ( ʧ → tʃ ) LATIN SMALL LETTER TESH DIGRAPH → LATIN SMALL LETTER T, LATIN SMALL LETTER ESH	# 
+
+A729 ;	0074 021D ;	MA	# ( ꜩ → tȝ ) LATIN SMALL LETTER TZ → LATIN SMALL LETTER T, LATIN SMALL LETTER YOGH	# 
+
+03C4 ;	1D1B ;	MA	# ( τ → ᴛ ) GREEK SMALL LETTER TAU → LATIN LETTER SMALL CAPITAL T	# 
+1D6D5 ;	1D1B ;	MA	# ( 𝛕 → ᴛ ) MATHEMATICAL BOLD SMALL TAU → LATIN LETTER SMALL CAPITAL T	# 
+1D70F ;	1D1B ;	MA	# ( 𝜏 → ᴛ ) MATHEMATICAL ITALIC SMALL TAU → LATIN LETTER SMALL CAPITAL T	# 
+1D749 ;	1D1B ;	MA	# ( 𝝉 → ᴛ ) MATHEMATICAL BOLD ITALIC SMALL TAU → LATIN LETTER SMALL CAPITAL T	# 
+1D783 ;	1D1B ;	MA	# ( 𝞃 → ᴛ ) MATHEMATICAL SANS-SERIF BOLD SMALL TAU → LATIN LETTER SMALL CAPITAL T	# 
+1D7BD ;	1D1B ;	MA	# ( 𝞽 → ᴛ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL TAU → LATIN LETTER SMALL CAPITAL T	# 
+2CA7 ;	1D1B ;	MA	# ( ⲧ → ᴛ ) COPTIC SMALL LETTER TAU → LATIN LETTER SMALL CAPITAL T	# →т→
+0442 ;	1D1B ;	MA	# ( т → ᴛ ) CYRILLIC SMALL LETTER TE → LATIN LETTER SMALL CAPITAL T	# 
+AB72 ;	1D1B ;	MA	# ( ꭲ → ᴛ ) CHEROKEE SMALL LETTER I → LATIN LETTER SMALL CAPITAL T	# 
+
+04AD ;	1D1B 0329 ;	MA	# ( ҭ → ᴛ̩ ) CYRILLIC SMALL LETTER TE WITH DESCENDER → LATIN LETTER SMALL CAPITAL T, COMBINING VERTICAL LINE BELOW	# →т̩→
+
+0163 ;	01AB ;	MA	# ( ţ → ƫ ) LATIN SMALL LETTER T WITH CEDILLA → LATIN SMALL LETTER T WITH PALATAL HOOK	# 
+021B ;	01AB ;	MA	# ( ț → ƫ ) LATIN SMALL LETTER T WITH COMMA BELOW → LATIN SMALL LETTER T WITH PALATAL HOOK	# →ţ→
+13BF ;	01AB ;	MA	# ( Ꮏ → ƫ ) CHEROKEE LETTER HNA → LATIN SMALL LETTER T WITH PALATAL HOOK	# 
+
+1D42E ;	0075 ;	MA	# ( 𝐮 → u ) MATHEMATICAL BOLD SMALL U → LATIN SMALL LETTER U	# 
+1D462 ;	0075 ;	MA	# ( 𝑢 → u ) MATHEMATICAL ITALIC SMALL U → LATIN SMALL LETTER U	# 
+1D496 ;	0075 ;	MA	# ( 𝒖 → u ) MATHEMATICAL BOLD ITALIC SMALL U → LATIN SMALL LETTER U	# 
+1D4CA ;	0075 ;	MA	# ( 𝓊 → u ) MATHEMATICAL SCRIPT SMALL U → LATIN SMALL LETTER U	# 
+1D4FE ;	0075 ;	MA	# ( 𝓾 → u ) MATHEMATICAL BOLD SCRIPT SMALL U → LATIN SMALL LETTER U	# 
+1D532 ;	0075 ;	MA	# ( 𝔲 → u ) MATHEMATICAL FRAKTUR SMALL U → LATIN SMALL LETTER U	# 
+1D566 ;	0075 ;	MA	# ( 𝕦 → u ) MATHEMATICAL DOUBLE-STRUCK SMALL U → LATIN SMALL LETTER U	# 
+1D59A ;	0075 ;	MA	# ( 𝖚 → u ) MATHEMATICAL BOLD FRAKTUR SMALL U → LATIN SMALL LETTER U	# 
+1D5CE ;	0075 ;	MA	# ( 𝗎 → u ) MATHEMATICAL SANS-SERIF SMALL U → LATIN SMALL LETTER U	# 
+1D602 ;	0075 ;	MA	# ( 𝘂 → u ) MATHEMATICAL SANS-SERIF BOLD SMALL U → LATIN SMALL LETTER U	# 
+1D636 ;	0075 ;	MA	# ( 𝘶 → u ) MATHEMATICAL SANS-SERIF ITALIC SMALL U → LATIN SMALL LETTER U	# 
+1D66A ;	0075 ;	MA	# ( 𝙪 → u ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL U → LATIN SMALL LETTER U	# 
+1D69E ;	0075 ;	MA	# ( 𝚞 → u ) MATHEMATICAL MONOSPACE SMALL U → LATIN SMALL LETTER U	# 
+A79F ;	0075 ;	MA	# ( ꞟ → u ) LATIN SMALL LETTER VOLAPUK UE → LATIN SMALL LETTER U	# 
+1D1C ;	0075 ;	MA	# ( ᴜ → u ) LATIN LETTER SMALL CAPITAL U → LATIN SMALL LETTER U	# 
+AB4E ;	0075 ;	MA	# ( ꭎ → u ) LATIN SMALL LETTER U WITH SHORT RIGHT LEG → LATIN SMALL LETTER U	# 
+AB52 ;	0075 ;	MA	# ( ꭒ → u ) LATIN SMALL LETTER U WITH LEFT HOOK → LATIN SMALL LETTER U	# 
+028B ;	0075 ;	MA	# ( ʋ → u ) LATIN SMALL LETTER V WITH HOOK → LATIN SMALL LETTER U	# 
+03C5 ;	0075 ;	MA	# ( υ → u ) GREEK SMALL LETTER UPSILON → LATIN SMALL LETTER U	# →ʋ→
+1D6D6 ;	0075 ;	MA	# ( 𝛖 → u ) MATHEMATICAL BOLD SMALL UPSILON → LATIN SMALL LETTER U	# →υ→→ʋ→
+1D710 ;	0075 ;	MA	# ( 𝜐 → u ) MATHEMATICAL ITALIC SMALL UPSILON → LATIN SMALL LETTER U	# →υ→→ʋ→
+1D74A ;	0075 ;	MA	# ( 𝝊 → u ) MATHEMATICAL BOLD ITALIC SMALL UPSILON → LATIN SMALL LETTER U	# →υ→→ʋ→
+1D784 ;	0075 ;	MA	# ( 𝞄 → u ) MATHEMATICAL SANS-SERIF BOLD SMALL UPSILON → LATIN SMALL LETTER U	# →υ→→ʋ→
+1D7BE ;	0075 ;	MA	# ( 𝞾 → u ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL UPSILON → LATIN SMALL LETTER U	# →υ→→ʋ→
+057D ;	0075 ;	MA	# ( ս → u ) ARMENIAN SMALL LETTER SEH → LATIN SMALL LETTER U	# 
+104F6 ;	0075 ;	MA	# ( 𐓶 → u ) OSAGE SMALL LETTER U → LATIN SMALL LETTER U	# →ᴜ→
+118D8 ;	0075 ;	MA	# ( 𑣘 → u ) WARANG CITI SMALL LETTER PU → LATIN SMALL LETTER U	# →υ→→ʋ→
+
+222A ;	0055 ;	MA	#* ( ∪ → U ) UNION → LATIN CAPITAL LETTER U	# →ᑌ→
+22C3 ;	0055 ;	MA	#* ( ⋃ → U ) N-ARY UNION → LATIN CAPITAL LETTER U	# →∪→→ᑌ→
+1CCEA ;	0055 ;	MA	#* ( 𜳪 → U ) OUTLINED LATIN CAPITAL LETTER U → LATIN CAPITAL LETTER U	# 
+1D414 ;	0055 ;	MA	# ( 𝐔 → U ) MATHEMATICAL BOLD CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D448 ;	0055 ;	MA	# ( 𝑈 → U ) MATHEMATICAL ITALIC CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D47C ;	0055 ;	MA	# ( 𝑼 → U ) MATHEMATICAL BOLD ITALIC CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D4B0 ;	0055 ;	MA	# ( 𝒰 → U ) MATHEMATICAL SCRIPT CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D4E4 ;	0055 ;	MA	# ( 𝓤 → U ) MATHEMATICAL BOLD SCRIPT CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D518 ;	0055 ;	MA	# ( 𝔘 → U ) MATHEMATICAL FRAKTUR CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D54C ;	0055 ;	MA	# ( 𝕌 → U ) MATHEMATICAL DOUBLE-STRUCK CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D580 ;	0055 ;	MA	# ( 𝖀 → U ) MATHEMATICAL BOLD FRAKTUR CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D5B4 ;	0055 ;	MA	# ( 𝖴 → U ) MATHEMATICAL SANS-SERIF CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D5E8 ;	0055 ;	MA	# ( 𝗨 → U ) MATHEMATICAL SANS-SERIF BOLD CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D61C ;	0055 ;	MA	# ( 𝘜 → U ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D650 ;	0055 ;	MA	# ( 𝙐 → U ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL U → LATIN CAPITAL LETTER U	# 
+1D684 ;	0055 ;	MA	# ( 𝚄 → U ) MATHEMATICAL MONOSPACE CAPITAL U → LATIN CAPITAL LETTER U	# 
+054D ;	0055 ;	MA	# ( Ս → U ) ARMENIAN CAPITAL LETTER SEH → LATIN CAPITAL LETTER U	# 
+1200 ;	0055 ;	MA	# ( ሀ → U ) ETHIOPIC SYLLABLE HA → LATIN CAPITAL LETTER U	# →Ս→
+104CE ;	0055 ;	MA	# ( 𐓎 → U ) OSAGE CAPITAL LETTER U → LATIN CAPITAL LETTER U	# 
+144C ;	0055 ;	MA	# ( ᑌ → U ) CANADIAN SYLLABICS TE → LATIN CAPITAL LETTER U	# 
+A4F4 ;	0055 ;	MA	# ( ꓴ → U ) LISU LETTER U → LATIN CAPITAL LETTER U	# 
+16F42 ;	0055 ;	MA	# ( 𖽂 → U ) MIAO LETTER WA → LATIN CAPITAL LETTER U	# 
+118B8 ;	0055 ;	MA	# ( 𑢸 → U ) WARANG CITI CAPITAL LETTER PU → LATIN CAPITAL LETTER U	# 
+
+01D4 ;	016D ;	MA	# ( ǔ → ŭ ) LATIN SMALL LETTER U WITH CARON → LATIN SMALL LETTER U WITH BREVE	# 
+
+01D3 ;	016C ;	MA	# ( Ǔ → Ŭ ) LATIN CAPITAL LETTER U WITH CARON → LATIN CAPITAL LETTER U WITH BREVE	# 
+
+045F ;	0075 0329 ;	MA	# ( џ → u̩ ) CYRILLIC SMALL LETTER DZHE → LATIN SMALL LETTER U, COMBINING VERTICAL LINE BELOW	# 
+
+1D7E ;	0075 0335 ;	MA	# ( ᵾ → u̵ ) LATIN SMALL CAPITAL LETTER U WITH STROKE → LATIN SMALL LETTER U, COMBINING SHORT STROKE OVERLAY	# →ᴜ̵→
+AB9C ;	0075 0335 ;	MA	# ( ꮜ → u̵ ) CHEROKEE SMALL LETTER SA → LATIN SMALL LETTER U, COMBINING SHORT STROKE OVERLAY	# →ᴜ̵→
+
+0244 ;	0055 0335 ;	MA	# ( Ʉ → U̵ ) LATIN CAPITAL LETTER U BAR → LATIN CAPITAL LETTER U, COMBINING SHORT STROKE OVERLAY	# →U̶→
+13CC ;	0055 0335 ;	MA	# ( Ꮜ → U̵ ) CHEROKEE LETTER SA → LATIN CAPITAL LETTER U, COMBINING SHORT STROKE OVERLAY	# →Ʉ→→U̶→
+
+1458 ;	0055 00B7 ;	MA	# ( ᑘ → U· ) CANADIAN SYLLABICS WEST-CREE TWE → LATIN CAPITAL LETTER U, MIDDLE DOT	# →ᑌᐧ→→ᑌ·→
+
+1467 ;	0055 0027 ;	MA	# ( ᑧ → U' ) CANADIAN SYLLABICS TTE → LATIN CAPITAL LETTER U, APOSTROPHE	# →ᑌᑊ→→ᑌ'→
+
+1D6B ;	0075 0065 ;	MA	# ( ᵫ → ue ) LATIN SMALL LETTER UE → LATIN SMALL LETTER U, LATIN SMALL LETTER E	# 
+
+AB63 ;	0075 006F ;	MA	# ( ꭣ → uo ) LATIN SMALL LETTER UO → LATIN SMALL LETTER U, LATIN SMALL LETTER O	# 
+
+1E43 ;	AB51 ;	MA	# ( ṃ → ꭑ ) LATIN SMALL LETTER M WITH DOT BELOW → LATIN SMALL LETTER TURNED UI	# 
+
+057A ;	0270 ;	MA	# ( պ → ɰ ) ARMENIAN SMALL LETTER PEH → LATIN SMALL LETTER TURNED M WITH LONG LEG	# 
+1223 ;	0270 ;	MA	# ( ሣ → ɰ ) ETHIOPIC SYLLABLE SZAA → LATIN SMALL LETTER TURNED M WITH LONG LEG	# →պ→
+
+2127 ;	01B1 ;	MA	#* ( ℧ → Ʊ ) INVERTED OHM SIGN → LATIN CAPITAL LETTER UPSILON	# 
+162E ;	01B1 ;	MA	# ( ᘮ → Ʊ ) CANADIAN SYLLABICS CARRIER LHU → LATIN CAPITAL LETTER UPSILON	# →℧→
+1634 ;	01B1 ;	MA	# ( ᘴ → Ʊ ) CANADIAN SYLLABICS CARRIER TLHU → LATIN CAPITAL LETTER UPSILON	# →ᘮ→→℧→
+
+1D7F ;	028A 0335 ;	MA	# ( ᵿ → ʊ̵ ) LATIN SMALL LETTER UPSILON WITH STROKE → LATIN SMALL LETTER UPSILON, COMBINING SHORT STROKE OVERLAY	# 
+
+2228 ;	0076 ;	MA	#* ( ∨ → v ) LOGICAL OR → LATIN SMALL LETTER V	# 
+22C1 ;	0076 ;	MA	#* ( ⋁ → v ) N-ARY LOGICAL OR → LATIN SMALL LETTER V	# →∨→
+FF56 ;	0076 ;	MA	# ( ｖ → v ) FULLWIDTH LATIN SMALL LETTER V → LATIN SMALL LETTER V	# →ν→
+2174 ;	0076 ;	MA	# ( ⅴ → v ) SMALL ROMAN NUMERAL FIVE → LATIN SMALL LETTER V	# 
+1D42F ;	0076 ;	MA	# ( 𝐯 → v ) MATHEMATICAL BOLD SMALL V → LATIN SMALL LETTER V	# 
+1D463 ;	0076 ;	MA	# ( 𝑣 → v ) MATHEMATICAL ITALIC SMALL V → LATIN SMALL LETTER V	# 
+1D497 ;	0076 ;	MA	# ( 𝒗 → v ) MATHEMATICAL BOLD ITALIC SMALL V → LATIN SMALL LETTER V	# 
+1D4CB ;	0076 ;	MA	# ( 𝓋 → v ) MATHEMATICAL SCRIPT SMALL V → LATIN SMALL LETTER V	# 
+1D4FF ;	0076 ;	MA	# ( 𝓿 → v ) MATHEMATICAL BOLD SCRIPT SMALL V → LATIN SMALL LETTER V	# 
+1D533 ;	0076 ;	MA	# ( 𝔳 → v ) MATHEMATICAL FRAKTUR SMALL V → LATIN SMALL LETTER V	# 
+1D567 ;	0076 ;	MA	# ( 𝕧 → v ) MATHEMATICAL DOUBLE-STRUCK SMALL V → LATIN SMALL LETTER V	# 
+1D59B ;	0076 ;	MA	# ( 𝖛 → v ) MATHEMATICAL BOLD FRAKTUR SMALL V → LATIN SMALL LETTER V	# 
+1D5CF ;	0076 ;	MA	# ( 𝗏 → v ) MATHEMATICAL SANS-SERIF SMALL V → LATIN SMALL LETTER V	# 
+1D603 ;	0076 ;	MA	# ( 𝘃 → v ) MATHEMATICAL SANS-SERIF BOLD SMALL V → LATIN SMALL LETTER V	# 
+1D637 ;	0076 ;	MA	# ( 𝘷 → v ) MATHEMATICAL SANS-SERIF ITALIC SMALL V → LATIN SMALL LETTER V	# 
+1D66B ;	0076 ;	MA	# ( 𝙫 → v ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL V → LATIN SMALL LETTER V	# 
+1D69F ;	0076 ;	MA	# ( 𝚟 → v ) MATHEMATICAL MONOSPACE SMALL V → LATIN SMALL LETTER V	# 
+1D20 ;	0076 ;	MA	# ( ᴠ → v ) LATIN LETTER SMALL CAPITAL V → LATIN SMALL LETTER V	# 
+03BD ;	0076 ;	MA	# ( ν → v ) GREEK SMALL LETTER NU → LATIN SMALL LETTER V	# 
+1D6CE ;	0076 ;	MA	# ( 𝛎 → v ) MATHEMATICAL BOLD SMALL NU → LATIN SMALL LETTER V	# →ν→
+1D708 ;	0076 ;	MA	# ( 𝜈 → v ) MATHEMATICAL ITALIC SMALL NU → LATIN SMALL LETTER V	# →ν→
+1D742 ;	0076 ;	MA	# ( 𝝂 → v ) MATHEMATICAL BOLD ITALIC SMALL NU → LATIN SMALL LETTER V	# →ν→
+1D77C ;	0076 ;	MA	# ( 𝝼 → v ) MATHEMATICAL SANS-SERIF BOLD SMALL NU → LATIN SMALL LETTER V	# →ν→
+1D7B6 ;	0076 ;	MA	# ( 𝞶 → v ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL NU → LATIN SMALL LETTER V	# →ν→
+0475 ;	0076 ;	MA	# ( ѵ → v ) CYRILLIC SMALL LETTER IZHITSA → LATIN SMALL LETTER V	# 
+05D8 ;	0076 ;	MA	# ( ‎ט‎ → v ) HEBREW LETTER TET → LATIN SMALL LETTER V	# 
+11706 ;	0076 ;	MA	# ( 𑜆 → v ) AHOM LETTER PA → LATIN SMALL LETTER V	# 
+ABA9 ;	0076 ;	MA	# ( ꮩ → v ) CHEROKEE SMALL LETTER DO → LATIN SMALL LETTER V	# →ᴠ→
+118C0 ;	0076 ;	MA	# ( 𑣀 → v ) WARANG CITI SMALL LETTER NGAA → LATIN SMALL LETTER V	# 
+
+1D20D ;	0056 ;	MA	#* ( 𝈍 → V ) GREEK VOCAL NOTATION SYMBOL-14 → LATIN CAPITAL LETTER V	# 
+0667 ;	0056 ;	MA	# ( ‎٧‎ → V ) ARABIC-INDIC DIGIT SEVEN → LATIN CAPITAL LETTER V	# 
+06F7 ;	0056 ;	MA	# ( ۷ → V ) EXTENDED ARABIC-INDIC DIGIT SEVEN → LATIN CAPITAL LETTER V	# →‎٧‎→
+2164 ;	0056 ;	MA	# ( Ⅴ → V ) ROMAN NUMERAL FIVE → LATIN CAPITAL LETTER V	# 
+1CCEB ;	0056 ;	MA	#* ( 𜳫 → V ) OUTLINED LATIN CAPITAL LETTER V → LATIN CAPITAL LETTER V	# 
+1D415 ;	0056 ;	MA	# ( 𝐕 → V ) MATHEMATICAL BOLD CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D449 ;	0056 ;	MA	# ( 𝑉 → V ) MATHEMATICAL ITALIC CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D47D ;	0056 ;	MA	# ( 𝑽 → V ) MATHEMATICAL BOLD ITALIC CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D4B1 ;	0056 ;	MA	# ( 𝒱 → V ) MATHEMATICAL SCRIPT CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D4E5 ;	0056 ;	MA	# ( 𝓥 → V ) MATHEMATICAL BOLD SCRIPT CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D519 ;	0056 ;	MA	# ( 𝔙 → V ) MATHEMATICAL FRAKTUR CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D54D ;	0056 ;	MA	# ( 𝕍 → V ) MATHEMATICAL DOUBLE-STRUCK CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D581 ;	0056 ;	MA	# ( 𝖁 → V ) MATHEMATICAL BOLD FRAKTUR CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D5B5 ;	0056 ;	MA	# ( 𝖵 → V ) MATHEMATICAL SANS-SERIF CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D5E9 ;	0056 ;	MA	# ( 𝗩 → V ) MATHEMATICAL SANS-SERIF BOLD CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D61D ;	0056 ;	MA	# ( 𝘝 → V ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D651 ;	0056 ;	MA	# ( 𝙑 → V ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL V → LATIN CAPITAL LETTER V	# 
+1D685 ;	0056 ;	MA	# ( 𝚅 → V ) MATHEMATICAL MONOSPACE CAPITAL V → LATIN CAPITAL LETTER V	# 
+0474 ;	0056 ;	MA	# ( Ѵ → V ) CYRILLIC CAPITAL LETTER IZHITSA → LATIN CAPITAL LETTER V	# 
+2D38 ;	0056 ;	MA	# ( ⴸ → V ) TIFINAGH LETTER YADH → LATIN CAPITAL LETTER V	# 
+13D9 ;	0056 ;	MA	# ( Ꮩ → V ) CHEROKEE LETTER DO → LATIN CAPITAL LETTER V	# 
+142F ;	0056 ;	MA	# ( ᐯ → V ) CANADIAN SYLLABICS PE → LATIN CAPITAL LETTER V	# 
+A6DF ;	0056 ;	MA	# ( ꛟ → V ) BAMUM LETTER KO → LATIN CAPITAL LETTER V	# 
+A4E6 ;	0056 ;	MA	# ( ꓦ → V ) LISU LETTER HA → LATIN CAPITAL LETTER V	# 
+16F08 ;	0056 ;	MA	# ( 𖼈 → V ) MIAO LETTER VA → LATIN CAPITAL LETTER V	# 
+118A0 ;	0056 ;	MA	# ( 𑢠 → V ) WARANG CITI CAPITAL LETTER NGAA → LATIN CAPITAL LETTER V	# 
+1051D ;	0056 ;	MA	# ( 𐔝 → V ) ELBASAN LETTER TE → LATIN CAPITAL LETTER V	# 
+
+10197 ;	0056 0335 ;	MA	#* ( 𐆗 → V̵ ) ROMAN QUINARIUS SIGN → LATIN CAPITAL LETTER V, COMBINING SHORT STROKE OVERLAY	# →V̶→
+
+143B ;	0056 00B7 ;	MA	# ( ᐻ → V· ) CANADIAN SYLLABICS WEST-CREE PWE → LATIN CAPITAL LETTER V, MIDDLE DOT	# →ᐯᐧ→
+
+1F76C ;	0056 0042 ;	MA	#* ( 🝬 → VB ) ALCHEMICAL SYMBOL FOR BATH OF VAPOURS → LATIN CAPITAL LETTER V, LATIN CAPITAL LETTER B	# 
+
+2175 ;	0076 0069 ;	MA	# ( ⅵ → vi ) SMALL ROMAN NUMERAL SIX → LATIN SMALL LETTER V, LATIN SMALL LETTER I	# 
+
+2176 ;	0076 0069 0069 ;	MA	# ( ⅶ → vii ) SMALL ROMAN NUMERAL SEVEN → LATIN SMALL LETTER V, LATIN SMALL LETTER I, LATIN SMALL LETTER I	# 
+
+2177 ;	0076 0069 0069 0069 ;	MA	# ( ⅷ → viii ) SMALL ROMAN NUMERAL EIGHT → LATIN SMALL LETTER V, LATIN SMALL LETTER I, LATIN SMALL LETTER I, LATIN SMALL LETTER I	# 
+
+2165 ;	0056 006C ;	MA	# ( Ⅵ → Vl ) ROMAN NUMERAL SIX → LATIN CAPITAL LETTER V, LATIN SMALL LETTER L	# →VI→
+
+2166 ;	0056 006C 006C ;	MA	# ( Ⅶ → Vll ) ROMAN NUMERAL SEVEN → LATIN CAPITAL LETTER V, LATIN SMALL LETTER L, LATIN SMALL LETTER L	# →VII→
+
+2167 ;	0056 006C 006C 006C ;	MA	# ( Ⅷ → Vlll ) ROMAN NUMERAL EIGHT → LATIN CAPITAL LETTER V, LATIN SMALL LETTER L, LATIN SMALL LETTER L, LATIN SMALL LETTER L	# →VIII→
+
+1F708 ;	0056 1DE4 ;	MA	#* ( 🜈 → Vᷤ ) ALCHEMICAL SYMBOL FOR AQUA VITAE → LATIN CAPITAL LETTER V, COMBINING LATIN SMALL LETTER S	# 
+
+1D27 ;	028C ;	MA	# ( ᴧ → ʌ ) GREEK LETTER SMALL CAPITAL LAMDA → LATIN SMALL LETTER TURNED V	# 
+2C97 ;	028C ;	MA	# ( ⲗ → ʌ ) COPTIC SMALL LETTER LAULA → LATIN SMALL LETTER TURNED V	# 
+104D8 ;	028C ;	MA	# ( 𐓘 → ʌ ) OSAGE SMALL LETTER A → LATIN SMALL LETTER TURNED V	# 
+
+0668 ;	0245 ;	MA	# ( ‎٨‎ → Ʌ ) ARABIC-INDIC DIGIT EIGHT → LATIN CAPITAL LETTER TURNED V	# →Λ→
+06F8 ;	0245 ;	MA	# ( ۸ → Ʌ ) EXTENDED ARABIC-INDIC DIGIT EIGHT → LATIN CAPITAL LETTER TURNED V	# →‎٨‎→→Λ→
+A7DA ;	0245 ;	MA	# ( Ꟛ → Ʌ ) LATIN CAPITAL LETTER LAMBDA → LATIN CAPITAL LETTER TURNED V	# →Λ→
+039B ;	0245 ;	MA	# ( Λ → Ʌ ) GREEK CAPITAL LETTER LAMDA → LATIN CAPITAL LETTER TURNED V	# 
+1D6B2 ;	0245 ;	MA	# ( 𝚲 → Ʌ ) MATHEMATICAL BOLD CAPITAL LAMDA → LATIN CAPITAL LETTER TURNED V	# →Λ→
+1D6EC ;	0245 ;	MA	# ( 𝛬 → Ʌ ) MATHEMATICAL ITALIC CAPITAL LAMDA → LATIN CAPITAL LETTER TURNED V	# →Λ→
+1D726 ;	0245 ;	MA	# ( 𝜦 → Ʌ ) MATHEMATICAL BOLD ITALIC CAPITAL LAMDA → LATIN CAPITAL LETTER TURNED V	# →Λ→
+1D760 ;	0245 ;	MA	# ( 𝝠 → Ʌ ) MATHEMATICAL SANS-SERIF BOLD CAPITAL LAMDA → LATIN CAPITAL LETTER TURNED V	# →Λ→
+1D79A ;	0245 ;	MA	# ( 𝞚 → Ʌ ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL LAMDA → LATIN CAPITAL LETTER TURNED V	# →Λ→
+041B ;	0245 ;	MA	# ( Л → Ʌ ) CYRILLIC CAPITAL LETTER EL → LATIN CAPITAL LETTER TURNED V	# →Λ→
+2D37 ;	0245 ;	MA	# ( ⴷ → Ʌ ) TIFINAGH LETTER YAD → LATIN CAPITAL LETTER TURNED V	# 
+104B0 ;	0245 ;	MA	# ( 𐒰 → Ʌ ) OSAGE CAPITAL LETTER A → LATIN CAPITAL LETTER TURNED V	# 
+1431 ;	0245 ;	MA	# ( ᐱ → Ʌ ) CANADIAN SYLLABICS PI → LATIN CAPITAL LETTER TURNED V	# 
+A6CE ;	0245 ;	MA	# ( ꛎ → Ʌ ) BAMUM LETTER MI → LATIN CAPITAL LETTER TURNED V	# →Λ→
+A4E5 ;	0245 ;	MA	# ( ꓥ → Ʌ ) LISU LETTER NGA → LATIN CAPITAL LETTER TURNED V	# 
+16F3D ;	0245 ;	MA	# ( 𖼽 → Ʌ ) MIAO LETTER ZZA → LATIN CAPITAL LETTER TURNED V	# 
+1028D ;	0245 ;	MA	# ( 𐊍 → Ʌ ) LYCIAN LETTER L → LATIN CAPITAL LETTER TURNED V	# →Λ→
+
+A7DC ;	0245 0338 ;	MA	# ( Ƛ → Ʌ̸ ) LATIN CAPITAL LETTER LAMBDA WITH STROKE → LATIN CAPITAL LETTER TURNED V, COMBINING LONG SOLIDUS OVERLAY	# →Λ̷→
+
+04C5 ;	0245 0326 ;	MA	# ( Ӆ → Ʌ̦ ) CYRILLIC CAPITAL LETTER EL WITH TAIL → LATIN CAPITAL LETTER TURNED V, COMBINING COMMA BELOW	# →Л̡→
+
+143D ;	0245 00B7 ;	MA	# ( ᐽ → Ʌ· ) CANADIAN SYLLABICS WEST-CREE PWI → LATIN CAPITAL LETTER TURNED V, MIDDLE DOT	# →ᐱᐧ→→ᐱ·→
+
+026F ;	0077 ;	MA	# ( ɯ → w ) LATIN SMALL LETTER TURNED M → LATIN SMALL LETTER W	# 
+1D430 ;	0077 ;	MA	# ( 𝐰 → w ) MATHEMATICAL BOLD SMALL W → LATIN SMALL LETTER W	# 
+1D464 ;	0077 ;	MA	# ( 𝑤 → w ) MATHEMATICAL ITALIC SMALL W → LATIN SMALL LETTER W	# 
+1D498 ;	0077 ;	MA	# ( 𝒘 → w ) MATHEMATICAL BOLD ITALIC SMALL W → LATIN SMALL LETTER W	# 
+1D4CC ;	0077 ;	MA	# ( 𝓌 → w ) MATHEMATICAL SCRIPT SMALL W → LATIN SMALL LETTER W	# 
+1D500 ;	0077 ;	MA	# ( 𝔀 → w ) MATHEMATICAL BOLD SCRIPT SMALL W → LATIN SMALL LETTER W	# 
+1D534 ;	0077 ;	MA	# ( 𝔴 → w ) MATHEMATICAL FRAKTUR SMALL W → LATIN SMALL LETTER W	# 
+1D568 ;	0077 ;	MA	# ( 𝕨 → w ) MATHEMATICAL DOUBLE-STRUCK SMALL W → LATIN SMALL LETTER W	# 
+1D59C ;	0077 ;	MA	# ( 𝖜 → w ) MATHEMATICAL BOLD FRAKTUR SMALL W → LATIN SMALL LETTER W	# 
+1D5D0 ;	0077 ;	MA	# ( 𝗐 → w ) MATHEMATICAL SANS-SERIF SMALL W → LATIN SMALL LETTER W	# 
+1D604 ;	0077 ;	MA	# ( 𝘄 → w ) MATHEMATICAL SANS-SERIF BOLD SMALL W → LATIN SMALL LETTER W	# 
+1D638 ;	0077 ;	MA	# ( 𝘸 → w ) MATHEMATICAL SANS-SERIF ITALIC SMALL W → LATIN SMALL LETTER W	# 
+1D66C ;	0077 ;	MA	# ( 𝙬 → w ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL W → LATIN SMALL LETTER W	# 
+1D6A0 ;	0077 ;	MA	# ( 𝚠 → w ) MATHEMATICAL MONOSPACE SMALL W → LATIN SMALL LETTER W	# 
+1D21 ;	0077 ;	MA	# ( ᴡ → w ) LATIN LETTER SMALL CAPITAL W → LATIN SMALL LETTER W	# 
+2CBD ;	0077 ;	MA	# ( ⲽ → w ) COPTIC SMALL LETTER CRYPTOGRAMMIC NI → LATIN SMALL LETTER W	# →ш→
+0461 ;	0077 ;	MA	# ( ѡ → w ) CYRILLIC SMALL LETTER OMEGA → LATIN SMALL LETTER W	# 
+0448 ;	0077 ;	MA	# ( ш → w ) CYRILLIC SMALL LETTER SHA → LATIN SMALL LETTER W	# 
+051D ;	0077 ;	MA	# ( ԝ → w ) CYRILLIC SMALL LETTER WE → LATIN SMALL LETTER W	# 
+0561 ;	0077 ;	MA	# ( ա → w ) ARMENIAN SMALL LETTER AYB → LATIN SMALL LETTER W	# →ɯ→
+1170A ;	0077 ;	MA	# ( 𑜊 → w ) AHOM LETTER JA → LATIN SMALL LETTER W	# 
+1170E ;	0077 ;	MA	# ( 𑜎 → w ) AHOM LETTER LA → LATIN SMALL LETTER W	# 
+1170F ;	0077 ;	MA	# ( 𑜏 → w ) AHOM LETTER SA → LATIN SMALL LETTER W	# 
+AB83 ;	0077 ;	MA	# ( ꮃ → w ) CHEROKEE SMALL LETTER LA → LATIN SMALL LETTER W	# →ᴡ→
+
+118E6 ;	0057 ;	MA	# ( 𑣦 → W ) WARANG CITI DIGIT SIX → LATIN CAPITAL LETTER W	# 
+118EF ;	0057 ;	MA	#* ( 𑣯 → W ) WARANG CITI NUMBER SIXTY → LATIN CAPITAL LETTER W	# 
+1CCEC ;	0057 ;	MA	#* ( 𜳬 → W ) OUTLINED LATIN CAPITAL LETTER W → LATIN CAPITAL LETTER W	# 
+1D416 ;	0057 ;	MA	# ( 𝐖 → W ) MATHEMATICAL BOLD CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D44A ;	0057 ;	MA	# ( 𝑊 → W ) MATHEMATICAL ITALIC CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D47E ;	0057 ;	MA	# ( 𝑾 → W ) MATHEMATICAL BOLD ITALIC CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D4B2 ;	0057 ;	MA	# ( 𝒲 → W ) MATHEMATICAL SCRIPT CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D4E6 ;	0057 ;	MA	# ( 𝓦 → W ) MATHEMATICAL BOLD SCRIPT CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D51A ;	0057 ;	MA	# ( 𝔚 → W ) MATHEMATICAL FRAKTUR CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D54E ;	0057 ;	MA	# ( 𝕎 → W ) MATHEMATICAL DOUBLE-STRUCK CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D582 ;	0057 ;	MA	# ( 𝖂 → W ) MATHEMATICAL BOLD FRAKTUR CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D5B6 ;	0057 ;	MA	# ( 𝖶 → W ) MATHEMATICAL SANS-SERIF CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D5EA ;	0057 ;	MA	# ( 𝗪 → W ) MATHEMATICAL SANS-SERIF BOLD CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D61E ;	0057 ;	MA	# ( 𝘞 → W ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D652 ;	0057 ;	MA	# ( 𝙒 → W ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL W → LATIN CAPITAL LETTER W	# 
+1D686 ;	0057 ;	MA	# ( 𝚆 → W ) MATHEMATICAL MONOSPACE CAPITAL W → LATIN CAPITAL LETTER W	# 
+051C ;	0057 ;	MA	# ( Ԝ → W ) CYRILLIC CAPITAL LETTER WE → LATIN CAPITAL LETTER W	# 
+13B3 ;	0057 ;	MA	# ( Ꮃ → W ) CHEROKEE LETTER LA → LATIN CAPITAL LETTER W	# 
+13D4 ;	0057 ;	MA	# ( Ꮤ → W ) CHEROKEE LETTER TA → LATIN CAPITAL LETTER W	# 
+A4EA ;	0057 ;	MA	# ( ꓪ → W ) LISU LETTER WA → LATIN CAPITAL LETTER W	# 
+
+047D ;	0077 0486 0487 ;	MA	# ( ѽ → w҆҇ ) CYRILLIC SMALL LETTER OMEGA WITH TITLO → LATIN SMALL LETTER W, COMBINING CYRILLIC PSILI PNEUMATA, COMBINING CYRILLIC POKRYTIE	# →ѡ҆҇→
+
+114C5 ;	0077 0307 ;	MA	# ( 𑓅 → ẇ ) TIRHUTA GVANG → LATIN SMALL LETTER W, COMBINING DOT ABOVE	# 
+
+20A9 ;	0057 0335 ;	MA	#* ( ₩ → W̵ ) WON SIGN → LATIN CAPITAL LETTER W, COMBINING SHORT STROKE OVERLAY	# 
+
+A761 ;	0077 0326 ;	MA	# ( ꝡ → w̦ ) LATIN SMALL LETTER VY → LATIN SMALL LETTER W, COMBINING COMMA BELOW	# →w̡→
+
+1D0D ;	028D ;	MA	# ( ᴍ → ʍ ) LATIN LETTER SMALL CAPITAL M → LATIN SMALL LETTER TURNED W	# →м→
+2C99 ;	028D ;	MA	# ( ⲙ → ʍ ) COPTIC SMALL LETTER MI → LATIN SMALL LETTER TURNED W	# →ᴍ→→м→
+043C ;	028D ;	MA	# ( м → ʍ ) CYRILLIC SMALL LETTER EM → LATIN SMALL LETTER TURNED W	# 
+AB87 ;	028D ;	MA	# ( ꮇ → ʍ ) CHEROKEE SMALL LETTER LU → LATIN SMALL LETTER TURNED W	# →ᴍ→→м→
+
+04CE ;	028D 0326 ;	MA	# ( ӎ → ʍ̦ ) CYRILLIC SMALL LETTER EM WITH TAIL → LATIN SMALL LETTER TURNED W, COMBINING COMMA BELOW	# →м̡→
+
+166E ;	0078 ;	MA	#* ( ᙮ → x ) CANADIAN SYLLABICS FULL STOP → LATIN SMALL LETTER X	# 
+00D7 ;	0078 ;	MA	#* ( × → x ) MULTIPLICATION SIGN → LATIN SMALL LETTER X	# 
+292B ;	0078 ;	MA	#* ( ⤫ → x ) RISING DIAGONAL CROSSING FALLING DIAGONAL → LATIN SMALL LETTER X	# 
+292C ;	0078 ;	MA	#* ( ⤬ → x ) FALLING DIAGONAL CROSSING RISING DIAGONAL → LATIN SMALL LETTER X	# 
+2A2F ;	0078 ;	MA	#* ( ⨯ → x ) VECTOR OR CROSS PRODUCT → LATIN SMALL LETTER X	# →×→
+FF58 ;	0078 ;	MA	# ( ｘ → x ) FULLWIDTH LATIN SMALL LETTER X → LATIN SMALL LETTER X	# →х→
+2179 ;	0078 ;	MA	# ( ⅹ → x ) SMALL ROMAN NUMERAL TEN → LATIN SMALL LETTER X	# 
+1D431 ;	0078 ;	MA	# ( 𝐱 → x ) MATHEMATICAL BOLD SMALL X → LATIN SMALL LETTER X	# 
+1D465 ;	0078 ;	MA	# ( 𝑥 → x ) MATHEMATICAL ITALIC SMALL X → LATIN SMALL LETTER X	# 
+1D499 ;	0078 ;	MA	# ( 𝒙 → x ) MATHEMATICAL BOLD ITALIC SMALL X → LATIN SMALL LETTER X	# 
+1D4CD ;	0078 ;	MA	# ( 𝓍 → x ) MATHEMATICAL SCRIPT SMALL X → LATIN SMALL LETTER X	# 
+1D501 ;	0078 ;	MA	# ( 𝔁 → x ) MATHEMATICAL BOLD SCRIPT SMALL X → LATIN SMALL LETTER X	# 
+1D535 ;	0078 ;	MA	# ( 𝔵 → x ) MATHEMATICAL FRAKTUR SMALL X → LATIN SMALL LETTER X	# 
+1D569 ;	0078 ;	MA	# ( 𝕩 → x ) MATHEMATICAL DOUBLE-STRUCK SMALL X → LATIN SMALL LETTER X	# 
+1D59D ;	0078 ;	MA	# ( 𝖝 → x ) MATHEMATICAL BOLD FRAKTUR SMALL X → LATIN SMALL LETTER X	# 
+1D5D1 ;	0078 ;	MA	# ( 𝗑 → x ) MATHEMATICAL SANS-SERIF SMALL X → LATIN SMALL LETTER X	# 
+1D605 ;	0078 ;	MA	# ( 𝘅 → x ) MATHEMATICAL SANS-SERIF BOLD SMALL X → LATIN SMALL LETTER X	# 
+1D639 ;	0078 ;	MA	# ( 𝘹 → x ) MATHEMATICAL SANS-SERIF ITALIC SMALL X → LATIN SMALL LETTER X	# 
+1D66D ;	0078 ;	MA	# ( 𝙭 → x ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL X → LATIN SMALL LETTER X	# 
+1D6A1 ;	0078 ;	MA	# ( 𝚡 → x ) MATHEMATICAL MONOSPACE SMALL X → LATIN SMALL LETTER X	# 
+0445 ;	0078 ;	MA	# ( х → x ) CYRILLIC SMALL LETTER HA → LATIN SMALL LETTER X	# 
+1541 ;	0078 ;	MA	# ( ᕁ → x ) CANADIAN SYLLABICS SAYISI YI → LATIN SMALL LETTER X	# →᙮→
+157D ;	0078 ;	MA	# ( ᕽ → x ) CANADIAN SYLLABICS HK → LATIN SMALL LETTER X	# →ᕁ→→᙮→
+
+2DEF ;	036F ;	MA	# ( ⷯ → ͯ ) COMBINING CYRILLIC LETTER HA → COMBINING LATIN SMALL LETTER X	# 
+
+166D ;	0058 ;	MA	#* ( ᙭ → X ) CANADIAN SYLLABICS CHI SIGN → LATIN CAPITAL LETTER X	# 
+2573 ;	0058 ;	MA	#* ( ╳ → X ) BOX DRAWINGS LIGHT DIAGONAL CROSS → LATIN CAPITAL LETTER X	# 
+10322 ;	0058 ;	MA	#* ( 𐌢 → X ) OLD ITALIC NUMERAL TEN → LATIN CAPITAL LETTER X	# →𐌗→
+118EC ;	0058 ;	MA	#* ( 𑣬 → X ) WARANG CITI NUMBER THIRTY → LATIN CAPITAL LETTER X	# 
+FF38 ;	0058 ;	MA	# ( Ｘ → X ) FULLWIDTH LATIN CAPITAL LETTER X → LATIN CAPITAL LETTER X	# →Х→
+2169 ;	0058 ;	MA	# ( Ⅹ → X ) ROMAN NUMERAL TEN → LATIN CAPITAL LETTER X	# 
+1CCED ;	0058 ;	MA	#* ( 𜳭 → X ) OUTLINED LATIN CAPITAL LETTER X → LATIN CAPITAL LETTER X	# 
+1D417 ;	0058 ;	MA	# ( 𝐗 → X ) MATHEMATICAL BOLD CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D44B ;	0058 ;	MA	# ( 𝑋 → X ) MATHEMATICAL ITALIC CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D47F ;	0058 ;	MA	# ( 𝑿 → X ) MATHEMATICAL BOLD ITALIC CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D4B3 ;	0058 ;	MA	# ( 𝒳 → X ) MATHEMATICAL SCRIPT CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D4E7 ;	0058 ;	MA	# ( 𝓧 → X ) MATHEMATICAL BOLD SCRIPT CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D51B ;	0058 ;	MA	# ( 𝔛 → X ) MATHEMATICAL FRAKTUR CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D54F ;	0058 ;	MA	# ( 𝕏 → X ) MATHEMATICAL DOUBLE-STRUCK CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D583 ;	0058 ;	MA	# ( 𝖃 → X ) MATHEMATICAL BOLD FRAKTUR CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D5B7 ;	0058 ;	MA	# ( 𝖷 → X ) MATHEMATICAL SANS-SERIF CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D5EB ;	0058 ;	MA	# ( 𝗫 → X ) MATHEMATICAL SANS-SERIF BOLD CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D61F ;	0058 ;	MA	# ( 𝘟 → X ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D653 ;	0058 ;	MA	# ( 𝙓 → X ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL X → LATIN CAPITAL LETTER X	# 
+1D687 ;	0058 ;	MA	# ( 𝚇 → X ) MATHEMATICAL MONOSPACE CAPITAL X → LATIN CAPITAL LETTER X	# 
+A7B3 ;	0058 ;	MA	# ( Ꭓ → X ) LATIN CAPITAL LETTER CHI → LATIN CAPITAL LETTER X	# 
+03A7 ;	0058 ;	MA	# ( Χ → X ) GREEK CAPITAL LETTER CHI → LATIN CAPITAL LETTER X	# 
+1D6BE ;	0058 ;	MA	# ( 𝚾 → X ) MATHEMATICAL BOLD CAPITAL CHI → LATIN CAPITAL LETTER X	# →Χ→
+1D6F8 ;	0058 ;	MA	# ( 𝛸 → X ) MATHEMATICAL ITALIC CAPITAL CHI → LATIN CAPITAL LETTER X	# →Χ→
+1D732 ;	0058 ;	MA	# ( 𝜲 → X ) MATHEMATICAL BOLD ITALIC CAPITAL CHI → LATIN CAPITAL LETTER X	# →𝑿→
+1D76C ;	0058 ;	MA	# ( 𝝬 → X ) MATHEMATICAL SANS-SERIF BOLD CAPITAL CHI → LATIN CAPITAL LETTER X	# →Χ→
+1D7A6 ;	0058 ;	MA	# ( 𝞦 → X ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL CHI → LATIN CAPITAL LETTER X	# →Χ→
+2CAC ;	0058 ;	MA	# ( Ⲭ → X ) COPTIC CAPITAL LETTER KHI → LATIN CAPITAL LETTER X	# →Х→
+0425 ;	0058 ;	MA	# ( Х → X ) CYRILLIC CAPITAL LETTER HA → LATIN CAPITAL LETTER X	# 
+2D5D ;	0058 ;	MA	# ( ⵝ → X ) TIFINAGH LETTER YATH → LATIN CAPITAL LETTER X	# 
+16B7 ;	0058 ;	MA	# ( ᚷ → X ) RUNIC LETTER GEBO GYFU G → LATIN CAPITAL LETTER X	# 
+A4EB ;	0058 ;	MA	# ( ꓫ → X ) LISU LETTER SHA → LATIN CAPITAL LETTER X	# 
+10290 ;	0058 ;	MA	# ( 𐊐 → X ) LYCIAN LETTER MM → LATIN CAPITAL LETTER X	# 
+102B4 ;	0058 ;	MA	# ( 𐊴 → X ) CARIAN LETTER X → LATIN CAPITAL LETTER X	# 
+10317 ;	0058 ;	MA	# ( 𐌗 → X ) OLD ITALIC LETTER EKS → LATIN CAPITAL LETTER X	# 
+10527 ;	0058 ;	MA	# ( 𐔧 → X ) ELBASAN LETTER KHE → LATIN CAPITAL LETTER X	# 
+
+2A30 ;	0078 0307 ;	MA	#* ( ⨰ → ẋ ) MULTIPLICATION SIGN WITH DOT ABOVE → LATIN SMALL LETTER X, COMBINING DOT ABOVE	# →×̇→
+
+04B2 ;	0058 0329 ;	MA	# ( Ҳ → X̩ ) CYRILLIC CAPITAL LETTER HA WITH DESCENDER → LATIN CAPITAL LETTER X, COMBINING VERTICAL LINE BELOW	# →Х̩→
+
+10196 ;	0058 0335 ;	MA	#* ( 𐆖 → X̵ ) ROMAN DENARIUS SIGN → LATIN CAPITAL LETTER X, COMBINING SHORT STROKE OVERLAY	# →X̶→
+
+217A ;	0078 0069 ;	MA	# ( ⅺ → xi ) SMALL ROMAN NUMERAL ELEVEN → LATIN SMALL LETTER X, LATIN SMALL LETTER I	# 
+
+217B ;	0078 0069 0069 ;	MA	# ( ⅻ → xii ) SMALL ROMAN NUMERAL TWELVE → LATIN SMALL LETTER X, LATIN SMALL LETTER I, LATIN SMALL LETTER I	# 
+
+216A ;	0058 006C ;	MA	# ( Ⅺ → Xl ) ROMAN NUMERAL ELEVEN → LATIN CAPITAL LETTER X, LATIN SMALL LETTER L	# →XI→
+
+216B ;	0058 006C 006C ;	MA	# ( Ⅻ → Xll ) ROMAN NUMERAL TWELVE → LATIN CAPITAL LETTER X, LATIN SMALL LETTER L, LATIN SMALL LETTER L	# →XII→
+
+0263 ;	0079 ;	MA	# ( ɣ → y ) LATIN SMALL LETTER GAMMA → LATIN SMALL LETTER Y	# →γ→
+1D8C ;	0079 ;	MA	# ( ᶌ → y ) LATIN SMALL LETTER V WITH PALATAL HOOK → LATIN SMALL LETTER Y	# 
+FF59 ;	0079 ;	MA	# ( ｙ → y ) FULLWIDTH LATIN SMALL LETTER Y → LATIN SMALL LETTER Y	# →у→
+1D432 ;	0079 ;	MA	# ( 𝐲 → y ) MATHEMATICAL BOLD SMALL Y → LATIN SMALL LETTER Y	# 
+1D466 ;	0079 ;	MA	# ( 𝑦 → y ) MATHEMATICAL ITALIC SMALL Y → LATIN SMALL LETTER Y	# 
+1D49A ;	0079 ;	MA	# ( 𝒚 → y ) MATHEMATICAL BOLD ITALIC SMALL Y → LATIN SMALL LETTER Y	# 
+1D4CE ;	0079 ;	MA	# ( 𝓎 → y ) MATHEMATICAL SCRIPT SMALL Y → LATIN SMALL LETTER Y	# 
+1D502 ;	0079 ;	MA	# ( 𝔂 → y ) MATHEMATICAL BOLD SCRIPT SMALL Y → LATIN SMALL LETTER Y	# 
+1D536 ;	0079 ;	MA	# ( 𝔶 → y ) MATHEMATICAL FRAKTUR SMALL Y → LATIN SMALL LETTER Y	# 
+1D56A ;	0079 ;	MA	# ( 𝕪 → y ) MATHEMATICAL DOUBLE-STRUCK SMALL Y → LATIN SMALL LETTER Y	# 
+1D59E ;	0079 ;	MA	# ( 𝖞 → y ) MATHEMATICAL BOLD FRAKTUR SMALL Y → LATIN SMALL LETTER Y	# 
+1D5D2 ;	0079 ;	MA	# ( 𝗒 → y ) MATHEMATICAL SANS-SERIF SMALL Y → LATIN SMALL LETTER Y	# 
+1D606 ;	0079 ;	MA	# ( 𝘆 → y ) MATHEMATICAL SANS-SERIF BOLD SMALL Y → LATIN SMALL LETTER Y	# 
+1D63A ;	0079 ;	MA	# ( 𝘺 → y ) MATHEMATICAL SANS-SERIF ITALIC SMALL Y → LATIN SMALL LETTER Y	# 
+1D66E ;	0079 ;	MA	# ( 𝙮 → y ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Y → LATIN SMALL LETTER Y	# 
+1D6A2 ;	0079 ;	MA	# ( 𝚢 → y ) MATHEMATICAL MONOSPACE SMALL Y → LATIN SMALL LETTER Y	# 
+028F ;	0079 ;	MA	# ( ʏ → y ) LATIN LETTER SMALL CAPITAL Y → LATIN SMALL LETTER Y	# →ү→→γ→
+1EFF ;	0079 ;	MA	# ( ỿ → y ) LATIN SMALL LETTER Y WITH LOOP → LATIN SMALL LETTER Y	# 
+AB5A ;	0079 ;	MA	# ( ꭚ → y ) LATIN SMALL LETTER Y WITH SHORT RIGHT LEG → LATIN SMALL LETTER Y	# 
+03B3 ;	0079 ;	MA	# ( γ → y ) GREEK SMALL LETTER GAMMA → LATIN SMALL LETTER Y	# 
+213D ;	0079 ;	MA	# ( ℽ → y ) DOUBLE-STRUCK SMALL GAMMA → LATIN SMALL LETTER Y	# →γ→
+1D6C4 ;	0079 ;	MA	# ( 𝛄 → y ) MATHEMATICAL BOLD SMALL GAMMA → LATIN SMALL LETTER Y	# →γ→
+1D6FE ;	0079 ;	MA	# ( 𝛾 → y ) MATHEMATICAL ITALIC SMALL GAMMA → LATIN SMALL LETTER Y	# →γ→
+1D738 ;	0079 ;	MA	# ( 𝜸 → y ) MATHEMATICAL BOLD ITALIC SMALL GAMMA → LATIN SMALL LETTER Y	# →γ→
+1D772 ;	0079 ;	MA	# ( 𝝲 → y ) MATHEMATICAL SANS-SERIF BOLD SMALL GAMMA → LATIN SMALL LETTER Y	# →γ→
+1D7AC ;	0079 ;	MA	# ( 𝞬 → y ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL GAMMA → LATIN SMALL LETTER Y	# →γ→
+2CA9 ;	0079 ;	MA	# ( ⲩ → y ) COPTIC SMALL LETTER UA → LATIN SMALL LETTER Y	# →γ→
+0443 ;	0079 ;	MA	# ( у → y ) CYRILLIC SMALL LETTER U → LATIN SMALL LETTER Y	# 
+04AF ;	0079 ;	MA	# ( ү → y ) CYRILLIC SMALL LETTER STRAIGHT U → LATIN SMALL LETTER Y	# →γ→
+10E7 ;	0079 ;	MA	# ( ყ → y ) GEORGIAN LETTER QAR → LATIN SMALL LETTER Y	# 
+118DC ;	0079 ;	MA	# ( 𑣜 → y ) WARANG CITI SMALL LETTER HAR → LATIN SMALL LETTER Y	# →ɣ→→γ→
+
+FF39 ;	0059 ;	MA	# ( Ｙ → Y ) FULLWIDTH LATIN CAPITAL LETTER Y → LATIN CAPITAL LETTER Y	# →Υ→
+1CCEE ;	0059 ;	MA	#* ( 𜳮 → Y ) OUTLINED LATIN CAPITAL LETTER Y → LATIN CAPITAL LETTER Y	# 
+1D418 ;	0059 ;	MA	# ( 𝐘 → Y ) MATHEMATICAL BOLD CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D44C ;	0059 ;	MA	# ( 𝑌 → Y ) MATHEMATICAL ITALIC CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D480 ;	0059 ;	MA	# ( 𝒀 → Y ) MATHEMATICAL BOLD ITALIC CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D4B4 ;	0059 ;	MA	# ( 𝒴 → Y ) MATHEMATICAL SCRIPT CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D4E8 ;	0059 ;	MA	# ( 𝓨 → Y ) MATHEMATICAL BOLD SCRIPT CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D51C ;	0059 ;	MA	# ( 𝔜 → Y ) MATHEMATICAL FRAKTUR CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D550 ;	0059 ;	MA	# ( 𝕐 → Y ) MATHEMATICAL DOUBLE-STRUCK CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D584 ;	0059 ;	MA	# ( 𝖄 → Y ) MATHEMATICAL BOLD FRAKTUR CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D5B8 ;	0059 ;	MA	# ( 𝖸 → Y ) MATHEMATICAL SANS-SERIF CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D5EC ;	0059 ;	MA	# ( 𝗬 → Y ) MATHEMATICAL SANS-SERIF BOLD CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D620 ;	0059 ;	MA	# ( 𝘠 → Y ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D654 ;	0059 ;	MA	# ( 𝙔 → Y ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+1D688 ;	0059 ;	MA	# ( 𝚈 → Y ) MATHEMATICAL MONOSPACE CAPITAL Y → LATIN CAPITAL LETTER Y	# 
+03A5 ;	0059 ;	MA	# ( Υ → Y ) GREEK CAPITAL LETTER UPSILON → LATIN CAPITAL LETTER Y	# 
+03D2 ;	0059 ;	MA	# ( ϒ → Y ) GREEK UPSILON WITH HOOK SYMBOL → LATIN CAPITAL LETTER Y	# 
+1D6BC ;	0059 ;	MA	# ( 𝚼 → Y ) MATHEMATICAL BOLD CAPITAL UPSILON → LATIN CAPITAL LETTER Y	# →Υ→
+1D6F6 ;	0059 ;	MA	# ( 𝛶 → Y ) MATHEMATICAL ITALIC CAPITAL UPSILON → LATIN CAPITAL LETTER Y	# →Υ→
+1D730 ;	0059 ;	MA	# ( 𝜰 → Y ) MATHEMATICAL BOLD ITALIC CAPITAL UPSILON → LATIN CAPITAL LETTER Y	# →Υ→
+1D76A ;	0059 ;	MA	# ( 𝝪 → Y ) MATHEMATICAL SANS-SERIF BOLD CAPITAL UPSILON → LATIN CAPITAL LETTER Y	# →Υ→
+1D7A4 ;	0059 ;	MA	# ( 𝞤 → Y ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL UPSILON → LATIN CAPITAL LETTER Y	# →Υ→
+2CA8 ;	0059 ;	MA	# ( Ⲩ → Y ) COPTIC CAPITAL LETTER UA → LATIN CAPITAL LETTER Y	# 
+0423 ;	0059 ;	MA	# ( У → Y ) CYRILLIC CAPITAL LETTER U → LATIN CAPITAL LETTER Y	# 
+04AE ;	0059 ;	MA	# ( Ү → Y ) CYRILLIC CAPITAL LETTER STRAIGHT U → LATIN CAPITAL LETTER Y	# 
+13A9 ;	0059 ;	MA	# ( Ꭹ → Y ) CHEROKEE LETTER GI → LATIN CAPITAL LETTER Y	# 
+13BD ;	0059 ;	MA	# ( Ꮍ → Y ) CHEROKEE LETTER MU → LATIN CAPITAL LETTER Y	# →Ꭹ→
+A4EC ;	0059 ;	MA	# ( ꓬ → Y ) LISU LETTER YA → LATIN CAPITAL LETTER Y	# 
+16F43 ;	0059 ;	MA	# ( 𖽃 → Y ) MIAO LETTER AH → LATIN CAPITAL LETTER Y	# 
+118A4 ;	0059 ;	MA	# ( 𑢤 → Y ) WARANG CITI CAPITAL LETTER YA → LATIN CAPITAL LETTER Y	# 
+102B2 ;	0059 ;	MA	# ( 𐊲 → Y ) CARIAN LETTER U → LATIN CAPITAL LETTER Y	# 
+
+01B4 ;	0079 0314 ;	MA	# ( ƴ → y̔ ) LATIN SMALL LETTER Y WITH HOOK → LATIN SMALL LETTER Y, COMBINING REVERSED COMMA ABOVE	# 
+
+024F ;	0079 0335 ;	MA	# ( ɏ → y̵ ) LATIN SMALL LETTER Y WITH STROKE → LATIN SMALL LETTER Y, COMBINING SHORT STROKE OVERLAY	# 
+04B1 ;	0079 0335 ;	MA	# ( ұ → y̵ ) CYRILLIC SMALL LETTER STRAIGHT U WITH STROKE → LATIN SMALL LETTER Y, COMBINING SHORT STROKE OVERLAY	# →ү̵→
+
+00A5 ;	0059 0335 ;	MA	#* ( ¥ → Y̵ ) YEN SIGN → LATIN CAPITAL LETTER Y, COMBINING SHORT STROKE OVERLAY	# 
+024E ;	0059 0335 ;	MA	# ( Ɏ → Y̵ ) LATIN CAPITAL LETTER Y WITH STROKE → LATIN CAPITAL LETTER Y, COMBINING SHORT STROKE OVERLAY	# 
+04B0 ;	0059 0335 ;	MA	# ( Ұ → Y̵ ) CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE → LATIN CAPITAL LETTER Y, COMBINING SHORT STROKE OVERLAY	# →Ү̵→
+
+0292 ;	021D ;	MA	# ( ʒ → ȝ ) LATIN SMALL LETTER EZH → LATIN SMALL LETTER YOGH	# 
+A76B ;	021D ;	MA	# ( ꝫ → ȝ ) LATIN SMALL LETTER ET → LATIN SMALL LETTER YOGH	# 
+2CC5 ;	021D ;	MA	# ( ⳅ → ȝ ) COPTIC SMALL LETTER OLD COPTIC SHEI → LATIN SMALL LETTER YOGH	# →ʒ→
+2CCD ;	021D ;	MA	# ( ⳍ → ȝ ) COPTIC SMALL LETTER OLD COPTIC HORI → LATIN SMALL LETTER YOGH	# 
+04E1 ;	021D ;	MA	# ( ӡ → ȝ ) CYRILLIC SMALL LETTER ABKHASIAN DZE → LATIN SMALL LETTER YOGH	# →ʒ→
+10F3 ;	021D ;	MA	# ( ჳ → ȝ ) GEORGIAN LETTER WE → LATIN SMALL LETTER YOGH	# →ʒ→
+
+1D433 ;	007A ;	MA	# ( 𝐳 → z ) MATHEMATICAL BOLD SMALL Z → LATIN SMALL LETTER Z	# 
+1D467 ;	007A ;	MA	# ( 𝑧 → z ) MATHEMATICAL ITALIC SMALL Z → LATIN SMALL LETTER Z	# 
+1D49B ;	007A ;	MA	# ( 𝒛 → z ) MATHEMATICAL BOLD ITALIC SMALL Z → LATIN SMALL LETTER Z	# 
+1D4CF ;	007A ;	MA	# ( 𝓏 → z ) MATHEMATICAL SCRIPT SMALL Z → LATIN SMALL LETTER Z	# 
+1D503 ;	007A ;	MA	# ( 𝔃 → z ) MATHEMATICAL BOLD SCRIPT SMALL Z → LATIN SMALL LETTER Z	# 
+1D537 ;	007A ;	MA	# ( 𝔷 → z ) MATHEMATICAL FRAKTUR SMALL Z → LATIN SMALL LETTER Z	# 
+1D56B ;	007A ;	MA	# ( 𝕫 → z ) MATHEMATICAL DOUBLE-STRUCK SMALL Z → LATIN SMALL LETTER Z	# 
+1D59F ;	007A ;	MA	# ( 𝖟 → z ) MATHEMATICAL BOLD FRAKTUR SMALL Z → LATIN SMALL LETTER Z	# 
+1D5D3 ;	007A ;	MA	# ( 𝗓 → z ) MATHEMATICAL SANS-SERIF SMALL Z → LATIN SMALL LETTER Z	# 
+1D607 ;	007A ;	MA	# ( 𝘇 → z ) MATHEMATICAL SANS-SERIF BOLD SMALL Z → LATIN SMALL LETTER Z	# 
+1D63B ;	007A ;	MA	# ( 𝘻 → z ) MATHEMATICAL SANS-SERIF ITALIC SMALL Z → LATIN SMALL LETTER Z	# 
+1D66F ;	007A ;	MA	# ( 𝙯 → z ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Z → LATIN SMALL LETTER Z	# 
+1D6A3 ;	007A ;	MA	# ( 𝚣 → z ) MATHEMATICAL MONOSPACE SMALL Z → LATIN SMALL LETTER Z	# 
+1D22 ;	007A ;	MA	# ( ᴢ → z ) LATIN LETTER SMALL CAPITAL Z → LATIN SMALL LETTER Z	# 
+AB93 ;	007A ;	MA	# ( ꮓ → z ) CHEROKEE SMALL LETTER NO → LATIN SMALL LETTER Z	# →ᴢ→
+118C4 ;	007A ;	MA	# ( 𑣄 → z ) WARANG CITI SMALL LETTER YA → LATIN SMALL LETTER Z	# 
+
+118E5 ;	005A ;	MA	# ( 𑣥 → Z ) WARANG CITI DIGIT FIVE → LATIN CAPITAL LETTER Z	# 
+102F5 ;	005A ;	MA	#* ( 𐋵 → Z ) COPTIC EPACT NUMBER THREE HUNDRED → LATIN CAPITAL LETTER Z	# 
+FF3A ;	005A ;	MA	# ( Ｚ → Z ) FULLWIDTH LATIN CAPITAL LETTER Z → LATIN CAPITAL LETTER Z	# →Ζ→
+2124 ;	005A ;	MA	# ( ℤ → Z ) DOUBLE-STRUCK CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+2128 ;	005A ;	MA	# ( ℨ → Z ) BLACK-LETTER CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1CCEF ;	005A ;	MA	#* ( 𜳯 → Z ) OUTLINED LATIN CAPITAL LETTER Z → LATIN CAPITAL LETTER Z	# 
+1D419 ;	005A ;	MA	# ( 𝐙 → Z ) MATHEMATICAL BOLD CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1D44D ;	005A ;	MA	# ( 𝑍 → Z ) MATHEMATICAL ITALIC CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1D481 ;	005A ;	MA	# ( 𝒁 → Z ) MATHEMATICAL BOLD ITALIC CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1D4B5 ;	005A ;	MA	# ( 𝒵 → Z ) MATHEMATICAL SCRIPT CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1D4E9 ;	005A ;	MA	# ( 𝓩 → Z ) MATHEMATICAL BOLD SCRIPT CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1D585 ;	005A ;	MA	# ( 𝖅 → Z ) MATHEMATICAL BOLD FRAKTUR CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1D5B9 ;	005A ;	MA	# ( 𝖹 → Z ) MATHEMATICAL SANS-SERIF CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1D5ED ;	005A ;	MA	# ( 𝗭 → Z ) MATHEMATICAL SANS-SERIF BOLD CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1D621 ;	005A ;	MA	# ( 𝘡 → Z ) MATHEMATICAL SANS-SERIF ITALIC CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1D655 ;	005A ;	MA	# ( 𝙕 → Z ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+1D689 ;	005A ;	MA	# ( 𝚉 → Z ) MATHEMATICAL MONOSPACE CAPITAL Z → LATIN CAPITAL LETTER Z	# 
+0396 ;	005A ;	MA	# ( Ζ → Z ) GREEK CAPITAL LETTER ZETA → LATIN CAPITAL LETTER Z	# 
+1D6AD ;	005A ;	MA	# ( 𝚭 → Z ) MATHEMATICAL BOLD CAPITAL ZETA → LATIN CAPITAL LETTER Z	# →Ζ→
+1D6E7 ;	005A ;	MA	# ( 𝛧 → Z ) MATHEMATICAL ITALIC CAPITAL ZETA → LATIN CAPITAL LETTER Z	# →𝑍→
+1D721 ;	005A ;	MA	# ( 𝜡 → Z ) MATHEMATICAL BOLD ITALIC CAPITAL ZETA → LATIN CAPITAL LETTER Z	# →Ζ→
+1D75B ;	005A ;	MA	# ( 𝝛 → Z ) MATHEMATICAL SANS-SERIF BOLD CAPITAL ZETA → LATIN CAPITAL LETTER Z	# →Ζ→
+1D795 ;	005A ;	MA	# ( 𝞕 → Z ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ZETA → LATIN CAPITAL LETTER Z	# →Ζ→
+13C3 ;	005A ;	MA	# ( Ꮓ → Z ) CHEROKEE LETTER NO → LATIN CAPITAL LETTER Z	# 
+A4DC ;	005A ;	MA	# ( ꓜ → Z ) LISU LETTER DZA → LATIN CAPITAL LETTER Z	# 
+118A9 ;	005A ;	MA	# ( 𑢩 → Z ) WARANG CITI CAPITAL LETTER O → LATIN CAPITAL LETTER Z	# 
+
+0290 ;	007A 0328 ;	MA	# ( ʐ → z̨ ) LATIN SMALL LETTER Z WITH RETROFLEX HOOK → LATIN SMALL LETTER Z, COMBINING OGONEK	# →z̢→
+
+01B6 ;	007A 0335 ;	MA	# ( ƶ → z̵ ) LATIN SMALL LETTER Z WITH STROKE → LATIN SMALL LETTER Z, COMBINING SHORT STROKE OVERLAY	# 
+
+01B5 ;	005A 0335 ;	MA	# ( Ƶ → Z̵ ) LATIN CAPITAL LETTER Z WITH STROKE → LATIN CAPITAL LETTER Z, COMBINING SHORT STROKE OVERLAY	# 
+
+0225 ;	007A 0326 ;	MA	# ( ȥ → z̦ ) LATIN SMALL LETTER Z WITH HOOK → LATIN SMALL LETTER Z, COMBINING COMMA BELOW	# →z̡→
+
+0224 ;	005A 0326 ;	MA	# ( Ȥ → Z̦ ) LATIN CAPITAL LETTER Z WITH HOOK → LATIN CAPITAL LETTER Z, COMBINING COMMA BELOW	# →Z̧→
+
+1D76 ;	007A 0334 ;	MA	# ( ᵶ → z̴ ) LATIN SMALL LETTER Z WITH MIDDLE TILDE → LATIN SMALL LETTER Z, COMBINING TILDE OVERLAY	# 
+
+2C8D ;	2C6C ;	MA	# ( ⲍ → ⱬ ) COPTIC SMALL LETTER ZATA → LATIN SMALL LETTER Z WITH DESCENDER	# 
+
+2C8C ;	2C6B ;	MA	# ( Ⲍ → Ⱬ ) COPTIC CAPITAL LETTER ZATA → LATIN CAPITAL LETTER Z WITH DESCENDER	# 
+
+2C9D ;	0293 ;	MA	# ( ⲝ → ʓ ) COPTIC SMALL LETTER KSI → LATIN SMALL LETTER EZH WITH CURL	# 
+
+03F7 ;	00DE ;	MA	# ( Ϸ → Þ ) GREEK CAPITAL LETTER SHO → LATIN CAPITAL LETTER THORN	# 
+104C4 ;	00DE ;	MA	# ( 𐓄 → Þ ) OSAGE CAPITAL LETTER PA → LATIN CAPITAL LETTER THORN	# 
+
+A7D2 ;	A7D3 ;	MA	# ( ꟒ → ꟓ ) LATIN CAPITAL LETTER DOUBLE THORN → LATIN SMALL LETTER DOUBLE THORN	# 
+
+A7D4 ;	A7D5 ;	MA	# ( ꟔ → ꟕ ) LATIN CAPITAL LETTER DOUBLE WYNN → LATIN SMALL LETTER DOUBLE WYNN	# 
+
+2079 ;	A770 ;	MA	#* ( ⁹ → ꝰ ) SUPERSCRIPT NINE → MODIFIER LETTER US	# 
+
+1D24 ;	01A8 ;	MA	# ( ᴤ → ƨ ) LATIN LETTER VOICED LARYNGEAL SPIRANT → LATIN SMALL LETTER TONE TWO	# 
+03E9 ;	01A8 ;	MA	# ( ϩ → ƨ ) COPTIC SMALL LETTER HORI → LATIN SMALL LETTER TONE TWO	# 
+A645 ;	01A8 ;	MA	# ( ꙅ → ƨ ) CYRILLIC SMALL LETTER REVERSED DZE → LATIN SMALL LETTER TONE TWO	# 
+
+044C ;	0185 ;	MA	# ( ь → ƅ ) CYRILLIC SMALL LETTER SOFT SIGN → LATIN SMALL LETTER TONE SIX	# 
+AB9F ;	0185 ;	MA	# ( ꮟ → ƅ ) CHEROKEE SMALL LETTER SI → LATIN SMALL LETTER TONE SIX	# →ь→
+16ED1 ;	0185 ;	MA	# ( 𖻑 → ƅ ) BERIA ERFE SMALL LETTER UI → LATIN SMALL LETTER TONE SIX	# →ь→
+
+044B ;	0185 0069 ;	MA	# ( ы → ƅi ) CYRILLIC SMALL LETTER YERU → LATIN SMALL LETTER TONE SIX, LATIN SMALL LETTER I	# →ьı→
+
+AB7E ;	0242 ;	MA	# ( ꭾ → ɂ ) CHEROKEE SMALL LETTER HE → LATIN SMALL LETTER GLOTTAL STOP	# 
+
+02E4 ;	02C1 ;	MA	# ( ˤ → ˁ ) MODIFIER LETTER SMALL REVERSED GLOTTAL STOP → MODIFIER LETTER REVERSED GLOTTAL STOP	# 
+
+A6CD ;	02A1 ;	MA	# ( ꛍ → ʡ ) BAMUM LETTER LU → LATIN LETTER GLOTTAL STOP WITH STROKE	# 
+
+256A ;	01C2 ;	MA	#* ( ╪ → ǂ ) BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE → LATIN LETTER ALVEOLAR CLICK	# 
+
+2299 ;	0298 ;	MA	#* ( ⊙ → ʘ ) CIRCLED DOT OPERATOR → LATIN LETTER BILABIAL CLICK	# 
+2609 ;	0298 ;	MA	#* ( ☉ → ʘ ) SUN → LATIN LETTER BILABIAL CLICK	# →⊙→
+2A00 ;	0298 ;	MA	#* ( ⨀ → ʘ ) N-ARY CIRCLED DOT OPERATOR → LATIN LETTER BILABIAL CLICK	# →⊙→
+A668 ;	0298 ;	MA	# ( Ꙩ → ʘ ) CYRILLIC CAPITAL LETTER MONOCULAR O → LATIN LETTER BILABIAL CLICK	# 
+2D59 ;	0298 ;	MA	# ( ⵙ → ʘ ) TIFINAGH LETTER YAS → LATIN LETTER BILABIAL CLICK	# →⊙→
+104C3 ;	0298 ;	MA	# ( 𐓃 → ʘ ) OSAGE CAPITAL LETTER OIN → LATIN LETTER BILABIAL CLICK	# →Ꙩ→
+
+213E ;	0393 ;	MA	# ( ℾ → Γ ) DOUBLE-STRUCK CAPITAL GAMMA → GREEK CAPITAL LETTER GAMMA	# 
+1D6AA ;	0393 ;	MA	# ( 𝚪 → Γ ) MATHEMATICAL BOLD CAPITAL GAMMA → GREEK CAPITAL LETTER GAMMA	# 
+1D6E4 ;	0393 ;	MA	# ( 𝛤 → Γ ) MATHEMATICAL ITALIC CAPITAL GAMMA → GREEK CAPITAL LETTER GAMMA	# 
+1D71E ;	0393 ;	MA	# ( 𝜞 → Γ ) MATHEMATICAL BOLD ITALIC CAPITAL GAMMA → GREEK CAPITAL LETTER GAMMA	# 
+1D758 ;	0393 ;	MA	# ( 𝝘 → Γ ) MATHEMATICAL SANS-SERIF BOLD CAPITAL GAMMA → GREEK CAPITAL LETTER GAMMA	# 
+1D792 ;	0393 ;	MA	# ( 𝞒 → Γ ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL GAMMA → GREEK CAPITAL LETTER GAMMA	# 
+2C84 ;	0393 ;	MA	# ( Ⲅ → Γ ) COPTIC CAPITAL LETTER GAMMA → GREEK CAPITAL LETTER GAMMA	# 
+0413 ;	0393 ;	MA	# ( Г → Γ ) CYRILLIC CAPITAL LETTER GHE → GREEK CAPITAL LETTER GAMMA	# 
+13B1 ;	0393 ;	MA	# ( Ꮁ → Γ ) CHEROKEE LETTER HU → GREEK CAPITAL LETTER GAMMA	# 
+14A5 ;	0393 ;	MA	# ( ᒥ → Γ ) CANADIAN SYLLABICS MI → GREEK CAPITAL LETTER GAMMA	# 
+16F07 ;	0393 ;	MA	# ( 𖼇 → Γ ) MIAO LETTER FA → GREEK CAPITAL LETTER GAMMA	# 
+
+0492 ;	0393 0335 ;	MA	# ( Ғ → Γ̵ ) CYRILLIC CAPITAL LETTER GHE WITH STROKE → GREEK CAPITAL LETTER GAMMA, COMBINING SHORT STROKE OVERLAY	# →Г̵→
+
+14AF ;	0393 00B7 ;	MA	# ( ᒯ → Γ· ) CANADIAN SYLLABICS WEST-CREE MWI → GREEK CAPITAL LETTER GAMMA, MIDDLE DOT	# →ᒥᐧ→→ᒥ·→
+
+0490 ;	0393 0027 ;	MA	# ( Ґ → Γ' ) CYRILLIC CAPITAL LETTER GHE WITH UPTURN → GREEK CAPITAL LETTER GAMMA, APOSTROPHE	# →Гˈ→
+
+2206 ;	0394 ;	MA	#* ( ∆ → Δ ) INCREMENT → GREEK CAPITAL LETTER DELTA	# 
+25B3 ;	0394 ;	MA	#* ( △ → Δ ) WHITE UP-POINTING TRIANGLE → GREEK CAPITAL LETTER DELTA	# 
+1F702 ;	0394 ;	MA	#* ( 🜂 → Δ ) ALCHEMICAL SYMBOL FOR FIRE → GREEK CAPITAL LETTER DELTA	# →△→
+1D6AB ;	0394 ;	MA	# ( 𝚫 → Δ ) MATHEMATICAL BOLD CAPITAL DELTA → GREEK CAPITAL LETTER DELTA	# 
+1D6E5 ;	0394 ;	MA	# ( 𝛥 → Δ ) MATHEMATICAL ITALIC CAPITAL DELTA → GREEK CAPITAL LETTER DELTA	# 
+1D71F ;	0394 ;	MA	# ( 𝜟 → Δ ) MATHEMATICAL BOLD ITALIC CAPITAL DELTA → GREEK CAPITAL LETTER DELTA	# 
+1D759 ;	0394 ;	MA	# ( 𝝙 → Δ ) MATHEMATICAL SANS-SERIF BOLD CAPITAL DELTA → GREEK CAPITAL LETTER DELTA	# 
+1D793 ;	0394 ;	MA	# ( 𝞓 → Δ ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL DELTA → GREEK CAPITAL LETTER DELTA	# 
+2C86 ;	0394 ;	MA	# ( Ⲇ → Δ ) COPTIC CAPITAL LETTER DALDA → GREEK CAPITAL LETTER DELTA	# 
+2D60 ;	0394 ;	MA	# ( ⵠ → Δ ) TIFINAGH LETTER YAV → GREEK CAPITAL LETTER DELTA	# 
+1403 ;	0394 ;	MA	# ( ᐃ → Δ ) CANADIAN SYLLABICS I → GREEK CAPITAL LETTER DELTA	# 
+16F1A ;	0394 ;	MA	# ( 𖼚 → Δ ) MIAO LETTER TLHA → GREEK CAPITAL LETTER DELTA	# 
+10285 ;	0394 ;	MA	# ( 𐊅 → Δ ) LYCIAN LETTER D → GREEK CAPITAL LETTER DELTA	# 
+102A3 ;	0394 ;	MA	# ( 𐊣 → Δ ) CARIAN LETTER L → GREEK CAPITAL LETTER DELTA	# 
+
+2359 ;	0394 0332 ;	MA	#* ( ⍙ → Δ̲ ) APL FUNCTIONAL SYMBOL DELTA UNDERBAR → GREEK CAPITAL LETTER DELTA, COMBINING LOW LINE	# 
+
+140F ;	0394 00B7 ;	MA	# ( ᐏ → Δ· ) CANADIAN SYLLABICS WEST-CREE WI → GREEK CAPITAL LETTER DELTA, MIDDLE DOT	# →ᐃᐧ→
+
+142C ;	0394 1420 ;	MA	# ( ᐬ → Δᐠ ) CANADIAN SYLLABICS IN → GREEK CAPITAL LETTER DELTA, CANADIAN SYLLABICS FINAL GRAVE	# →ᐃᐠ→
+
+1D7CB ;	03DD ;	MA	# ( 𝟋 → ϝ ) MATHEMATICAL BOLD SMALL DIGAMMA → GREEK SMALL LETTER DIGAMMA	# 
+
+1D6C7 ;	03B6 ;	MA	# ( 𝛇 → ζ ) MATHEMATICAL BOLD SMALL ZETA → GREEK SMALL LETTER ZETA	# 
+1D701 ;	03B6 ;	MA	# ( 𝜁 → ζ ) MATHEMATICAL ITALIC SMALL ZETA → GREEK SMALL LETTER ZETA	# 
+1D73B ;	03B6 ;	MA	# ( 𝜻 → ζ ) MATHEMATICAL BOLD ITALIC SMALL ZETA → GREEK SMALL LETTER ZETA	# 
+1D775 ;	03B6 ;	MA	# ( 𝝵 → ζ ) MATHEMATICAL SANS-SERIF BOLD SMALL ZETA → GREEK SMALL LETTER ZETA	# 
+1D7AF ;	03B6 ;	MA	# ( 𝞯 → ζ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ZETA → GREEK SMALL LETTER ZETA	# 
+
+2CE4 ;	03D7 ;	MA	# ( ⳤ → ϗ ) COPTIC SYMBOL KAI → GREEK KAI SYMBOL	# 
+
+A7DB ;	03BB ;	MA	# ( ꟛ → λ ) LATIN SMALL LETTER LAMBDA → GREEK SMALL LETTER LAMDA	# 
+1D6CC ;	03BB ;	MA	# ( 𝛌 → λ ) MATHEMATICAL BOLD SMALL LAMDA → GREEK SMALL LETTER LAMDA	# 
+1D706 ;	03BB ;	MA	# ( 𝜆 → λ ) MATHEMATICAL ITALIC SMALL LAMDA → GREEK SMALL LETTER LAMDA	# 
+1D740 ;	03BB ;	MA	# ( 𝝀 → λ ) MATHEMATICAL BOLD ITALIC SMALL LAMDA → GREEK SMALL LETTER LAMDA	# 
+1D77A ;	03BB ;	MA	# ( 𝝺 → λ ) MATHEMATICAL SANS-SERIF BOLD SMALL LAMDA → GREEK SMALL LETTER LAMDA	# 
+1D7B4 ;	03BB ;	MA	# ( 𝞴 → λ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL LAMDA → GREEK SMALL LETTER LAMDA	# 
+2C96 ;	03BB ;	MA	# ( Ⲗ → λ ) COPTIC CAPITAL LETTER LAULA → GREEK SMALL LETTER LAMDA	# 
+104DB ;	03BB ;	MA	# ( 𐓛 → λ ) OSAGE SMALL LETTER AH → GREEK SMALL LETTER LAMDA	# 
+
+019B ;	03BB 0338 ;	MA	# ( ƛ → λ̸ ) LATIN SMALL LETTER LAMBDA WITH STROKE → GREEK SMALL LETTER LAMDA, COMBINING LONG SOLIDUS OVERLAY	# →λ̷→
+
+00B5 ;	03BC ;	MA	# ( µ → μ ) MICRO SIGN → GREEK SMALL LETTER MU	# 
+1D6CD ;	03BC ;	MA	# ( 𝛍 → μ ) MATHEMATICAL BOLD SMALL MU → GREEK SMALL LETTER MU	# 
+1D707 ;	03BC ;	MA	# ( 𝜇 → μ ) MATHEMATICAL ITALIC SMALL MU → GREEK SMALL LETTER MU	# 
+1D741 ;	03BC ;	MA	# ( 𝝁 → μ ) MATHEMATICAL BOLD ITALIC SMALL MU → GREEK SMALL LETTER MU	# 
+1D77B ;	03BC ;	MA	# ( 𝝻 → μ ) MATHEMATICAL SANS-SERIF BOLD SMALL MU → GREEK SMALL LETTER MU	# 
+1D7B5 ;	03BC ;	MA	# ( 𝞵 → μ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL MU → GREEK SMALL LETTER MU	# 
+
+1D6CF ;	03BE ;	MA	# ( 𝛏 → ξ ) MATHEMATICAL BOLD SMALL XI → GREEK SMALL LETTER XI	# 
+1D709 ;	03BE ;	MA	# ( 𝜉 → ξ ) MATHEMATICAL ITALIC SMALL XI → GREEK SMALL LETTER XI	# 
+1D743 ;	03BE ;	MA	# ( 𝝃 → ξ ) MATHEMATICAL BOLD ITALIC SMALL XI → GREEK SMALL LETTER XI	# 
+1D77D ;	03BE ;	MA	# ( 𝝽 → ξ ) MATHEMATICAL SANS-SERIF BOLD SMALL XI → GREEK SMALL LETTER XI	# 
+1D7B7 ;	03BE ;	MA	# ( 𝞷 → ξ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL XI → GREEK SMALL LETTER XI	# 
+
+2630 ;	039E ;	MA	#* ( ☰ → Ξ ) TRIGRAM FOR HEAVEN → GREEK CAPITAL LETTER XI	# →Ⲷ→
+1D6B5 ;	039E ;	MA	# ( 𝚵 → Ξ ) MATHEMATICAL BOLD CAPITAL XI → GREEK CAPITAL LETTER XI	# 
+1D6EF ;	039E ;	MA	# ( 𝛯 → Ξ ) MATHEMATICAL ITALIC CAPITAL XI → GREEK CAPITAL LETTER XI	# 
+1D729 ;	039E ;	MA	# ( 𝜩 → Ξ ) MATHEMATICAL BOLD ITALIC CAPITAL XI → GREEK CAPITAL LETTER XI	# 
+1D763 ;	039E ;	MA	# ( 𝝣 → Ξ ) MATHEMATICAL SANS-SERIF BOLD CAPITAL XI → GREEK CAPITAL LETTER XI	# 
+1D79D ;	039E ;	MA	# ( 𝞝 → Ξ ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL XI → GREEK CAPITAL LETTER XI	# 
+2CB6 ;	039E ;	MA	# ( Ⲷ → Ξ ) COPTIC CAPITAL LETTER CRYPTOGRAMMIC EIE → GREEK CAPITAL LETTER XI	# 
+
+03D6 ;	03C0 ;	MA	# ( ϖ → π ) GREEK PI SYMBOL → GREEK SMALL LETTER PI	# 
+213C ;	03C0 ;	MA	# ( ℼ → π ) DOUBLE-STRUCK SMALL PI → GREEK SMALL LETTER PI	# 
+1D6D1 ;	03C0 ;	MA	# ( 𝛑 → π ) MATHEMATICAL BOLD SMALL PI → GREEK SMALL LETTER PI	# 
+1D6E1 ;	03C0 ;	MA	# ( 𝛡 → π ) MATHEMATICAL BOLD PI SYMBOL → GREEK SMALL LETTER PI	# 
+1D70B ;	03C0 ;	MA	# ( 𝜋 → π ) MATHEMATICAL ITALIC SMALL PI → GREEK SMALL LETTER PI	# 
+1D71B ;	03C0 ;	MA	# ( 𝜛 → π ) MATHEMATICAL ITALIC PI SYMBOL → GREEK SMALL LETTER PI	# 
+1D745 ;	03C0 ;	MA	# ( 𝝅 → π ) MATHEMATICAL BOLD ITALIC SMALL PI → GREEK SMALL LETTER PI	# 
+1D755 ;	03C0 ;	MA	# ( 𝝕 → π ) MATHEMATICAL BOLD ITALIC PI SYMBOL → GREEK SMALL LETTER PI	# 
+1D77F ;	03C0 ;	MA	# ( 𝝿 → π ) MATHEMATICAL SANS-SERIF BOLD SMALL PI → GREEK SMALL LETTER PI	# 
+1D78F ;	03C0 ;	MA	# ( 𝞏 → π ) MATHEMATICAL SANS-SERIF BOLD PI SYMBOL → GREEK SMALL LETTER PI	# 
+1D7B9 ;	03C0 ;	MA	# ( 𝞹 → π ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PI → GREEK SMALL LETTER PI	# 
+1D7C9 ;	03C0 ;	MA	# ( 𝟉 → π ) MATHEMATICAL SANS-SERIF BOLD ITALIC PI SYMBOL → GREEK SMALL LETTER PI	# 
+1D28 ;	03C0 ;	MA	# ( ᴨ → π ) GREEK LETTER SMALL CAPITAL PI → GREEK SMALL LETTER PI	# →п→
+2CA1 ;	03C0 ;	MA	# ( ⲡ → π ) COPTIC SMALL LETTER PI → GREEK SMALL LETTER PI	# →п→
+043F ;	03C0 ;	MA	# ( п → π ) CYRILLIC SMALL LETTER PE → GREEK SMALL LETTER PI	# 
+16EC1 ;	03C0 ;	MA	# ( 𖻁 → π ) BERIA ERFE SMALL LETTER HIRDEABO → GREEK SMALL LETTER PI	# →п→
+
+220F ;	03A0 ;	MA	#* ( ∏ → Π ) N-ARY PRODUCT → GREEK CAPITAL LETTER PI	# 
+213F ;	03A0 ;	MA	# ( ℿ → Π ) DOUBLE-STRUCK CAPITAL PI → GREEK CAPITAL LETTER PI	# 
+1D6B7 ;	03A0 ;	MA	# ( 𝚷 → Π ) MATHEMATICAL BOLD CAPITAL PI → GREEK CAPITAL LETTER PI	# 
+1D6F1 ;	03A0 ;	MA	# ( 𝛱 → Π ) MATHEMATICAL ITALIC CAPITAL PI → GREEK CAPITAL LETTER PI	# 
+1D72B ;	03A0 ;	MA	# ( 𝜫 → Π ) MATHEMATICAL BOLD ITALIC CAPITAL PI → GREEK CAPITAL LETTER PI	# 
+1D765 ;	03A0 ;	MA	# ( 𝝥 → Π ) MATHEMATICAL SANS-SERIF BOLD CAPITAL PI → GREEK CAPITAL LETTER PI	# 
+1D79F ;	03A0 ;	MA	# ( 𝞟 → Π ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PI → GREEK CAPITAL LETTER PI	# 
+2CA0 ;	03A0 ;	MA	# ( Ⲡ → Π ) COPTIC CAPITAL LETTER PI → GREEK CAPITAL LETTER PI	# 
+041F ;	03A0 ;	MA	# ( П → Π ) CYRILLIC CAPITAL LETTER PE → GREEK CAPITAL LETTER PI	# 
+A6DB ;	03A0 ;	MA	# ( ꛛ → Π ) BAMUM LETTER NA → GREEK CAPITAL LETTER PI	# 
+16EA6 ;	03A0 ;	MA	# ( 𖺦 → Π ) BERIA ERFE CAPITAL LETTER HIRDEABO → GREEK CAPITAL LETTER PI	# →П→
+
+102AD ;	03D8 ;	MA	# ( 𐊭 → Ϙ ) CARIAN LETTER T → GREEK LETTER ARCHAIC KOPPA	# 
+10312 ;	03D8 ;	MA	# ( 𐌒 → Ϙ ) OLD ITALIC LETTER KU → GREEK LETTER ARCHAIC KOPPA	# 
+
+2CC1 ;	03FC ;	MA	# ( ⳁ → ϼ ) COPTIC SMALL LETTER SAMPI → GREEK RHO WITH STROKE SYMBOL	# 
+
+03DB ;	03C2 ;	MA	# ( ϛ → ς ) GREEK SMALL LETTER STIGMA → GREEK SMALL LETTER FINAL SIGMA	# 
+1D6D3 ;	03C2 ;	MA	# ( 𝛓 → ς ) MATHEMATICAL BOLD SMALL FINAL SIGMA → GREEK SMALL LETTER FINAL SIGMA	# 
+1D70D ;	03C2 ;	MA	# ( 𝜍 → ς ) MATHEMATICAL ITALIC SMALL FINAL SIGMA → GREEK SMALL LETTER FINAL SIGMA	# 
+1D747 ;	03C2 ;	MA	# ( 𝝇 → ς ) MATHEMATICAL BOLD ITALIC SMALL FINAL SIGMA → GREEK SMALL LETTER FINAL SIGMA	# 
+1D781 ;	03C2 ;	MA	# ( 𝞁 → ς ) MATHEMATICAL SANS-SERIF BOLD SMALL FINAL SIGMA → GREEK SMALL LETTER FINAL SIGMA	# 
+1D7BB ;	03C2 ;	MA	# ( 𝞻 → ς ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL FINAL SIGMA → GREEK SMALL LETTER FINAL SIGMA	# 
+2C8B ;	03C2 ;	MA	# ( ⲋ → ς ) COPTIC SMALL LETTER SOU → GREEK SMALL LETTER FINAL SIGMA	# 
+
+1D6BD ;	03A6 ;	MA	# ( 𝚽 → Φ ) MATHEMATICAL BOLD CAPITAL PHI → GREEK CAPITAL LETTER PHI	# 
+1D6F7 ;	03A6 ;	MA	# ( 𝛷 → Φ ) MATHEMATICAL ITALIC CAPITAL PHI → GREEK CAPITAL LETTER PHI	# 
+1D731 ;	03A6 ;	MA	# ( 𝜱 → Φ ) MATHEMATICAL BOLD ITALIC CAPITAL PHI → GREEK CAPITAL LETTER PHI	# 
+1D76B ;	03A6 ;	MA	# ( 𝝫 → Φ ) MATHEMATICAL SANS-SERIF BOLD CAPITAL PHI → GREEK CAPITAL LETTER PHI	# 
+1D7A5 ;	03A6 ;	MA	# ( 𝞥 → Φ ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PHI → GREEK CAPITAL LETTER PHI	# 
+2CAA ;	03A6 ;	MA	# ( Ⲫ → Φ ) COPTIC CAPITAL LETTER FI → GREEK CAPITAL LETTER PHI	# 
+0424 ;	03A6 ;	MA	# ( Ф → Φ ) CYRILLIC CAPITAL LETTER EF → GREEK CAPITAL LETTER PHI	# 
+0553 ;	03A6 ;	MA	# ( Փ → Φ ) ARMENIAN CAPITAL LETTER PIWR → GREEK CAPITAL LETTER PHI	# 
+1240 ;	03A6 ;	MA	# ( ቀ → Φ ) ETHIOPIC SYLLABLE QA → GREEK CAPITAL LETTER PHI	# →Փ→
+16F0 ;	03A6 ;	MA	# ( ᛰ → Φ ) RUNIC BELGTHOR SYMBOL → GREEK CAPITAL LETTER PHI	# 
+102B3 ;	03A6 ;	MA	# ( 𐊳 → Φ ) CARIAN LETTER NN → GREEK CAPITAL LETTER PHI	# 
+
+AB53 ;	03C7 ;	MA	# ( ꭓ → χ ) LATIN SMALL LETTER CHI → GREEK SMALL LETTER CHI	# 
+AB55 ;	03C7 ;	MA	# ( ꭕ → χ ) LATIN SMALL LETTER CHI WITH LOW LEFT SERIF → GREEK SMALL LETTER CHI	# 
+1D6D8 ;	03C7 ;	MA	# ( 𝛘 → χ ) MATHEMATICAL BOLD SMALL CHI → GREEK SMALL LETTER CHI	# 
+1D712 ;	03C7 ;	MA	# ( 𝜒 → χ ) MATHEMATICAL ITALIC SMALL CHI → GREEK SMALL LETTER CHI	# 
+1D74C ;	03C7 ;	MA	# ( 𝝌 → χ ) MATHEMATICAL BOLD ITALIC SMALL CHI → GREEK SMALL LETTER CHI	# 
+1D786 ;	03C7 ;	MA	# ( 𝞆 → χ ) MATHEMATICAL SANS-SERIF BOLD SMALL CHI → GREEK SMALL LETTER CHI	# 
+1D7C0 ;	03C7 ;	MA	# ( 𝟀 → χ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL CHI → GREEK SMALL LETTER CHI	# 
+2CAD ;	03C7 ;	MA	# ( ⲭ → χ ) COPTIC SMALL LETTER KHI → GREEK SMALL LETTER CHI	# 
+
+1D6D9 ;	03C8 ;	MA	# ( 𝛙 → ψ ) MATHEMATICAL BOLD SMALL PSI → GREEK SMALL LETTER PSI	# 
+1D713 ;	03C8 ;	MA	# ( 𝜓 → ψ ) MATHEMATICAL ITALIC SMALL PSI → GREEK SMALL LETTER PSI	# 
+1D74D ;	03C8 ;	MA	# ( 𝝍 → ψ ) MATHEMATICAL BOLD ITALIC SMALL PSI → GREEK SMALL LETTER PSI	# 
+1D787 ;	03C8 ;	MA	# ( 𝞇 → ψ ) MATHEMATICAL SANS-SERIF BOLD SMALL PSI → GREEK SMALL LETTER PSI	# 
+1D7C1 ;	03C8 ;	MA	# ( 𝟁 → ψ ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PSI → GREEK SMALL LETTER PSI	# 
+2CAF ;	03C8 ;	MA	# ( ⲯ → ψ ) COPTIC SMALL LETTER PSI → GREEK SMALL LETTER PSI	# 
+0471 ;	03C8 ;	MA	# ( ѱ → ψ ) CYRILLIC SMALL LETTER PSI → GREEK SMALL LETTER PSI	# 
+104F9 ;	03C8 ;	MA	# ( 𐓹 → ψ ) OSAGE SMALL LETTER GHA → GREEK SMALL LETTER PSI	# 
+
+1D6BF ;	03A8 ;	MA	# ( 𝚿 → Ψ ) MATHEMATICAL BOLD CAPITAL PSI → GREEK CAPITAL LETTER PSI	# 
+1D6F9 ;	03A8 ;	MA	# ( 𝛹 → Ψ ) MATHEMATICAL ITALIC CAPITAL PSI → GREEK CAPITAL LETTER PSI	# 
+1D733 ;	03A8 ;	MA	# ( 𝜳 → Ψ ) MATHEMATICAL BOLD ITALIC CAPITAL PSI → GREEK CAPITAL LETTER PSI	# 
+1D76D ;	03A8 ;	MA	# ( 𝝭 → Ψ ) MATHEMATICAL SANS-SERIF BOLD CAPITAL PSI → GREEK CAPITAL LETTER PSI	# 
+1D7A7 ;	03A8 ;	MA	# ( 𝞧 → Ψ ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PSI → GREEK CAPITAL LETTER PSI	# 
+2CAE ;	03A8 ;	MA	# ( Ⲯ → Ψ ) COPTIC CAPITAL LETTER PSI → GREEK CAPITAL LETTER PSI	# 
+0470 ;	03A8 ;	MA	# ( Ѱ → Ψ ) CYRILLIC CAPITAL LETTER PSI → GREEK CAPITAL LETTER PSI	# 
+104D1 ;	03A8 ;	MA	# ( 𐓑 → Ψ ) OSAGE CAPITAL LETTER GHA → GREEK CAPITAL LETTER PSI	# 
+16D8 ;	03A8 ;	MA	# ( ᛘ → Ψ ) RUNIC LETTER LONG-BRANCH-MADR M → GREEK CAPITAL LETTER PSI	# 
+102B5 ;	03A8 ;	MA	# ( 𐊵 → Ψ ) CARIAN LETTER N → GREEK CAPITAL LETTER PSI	# 
+
+2375 ;	03C9 ;	MA	#* ( ⍵ → ω ) APL FUNCTIONAL SYMBOL OMEGA → GREEK SMALL LETTER OMEGA	# 
+A7B7 ;	03C9 ;	MA	# ( ꞷ → ω ) LATIN SMALL LETTER OMEGA → GREEK SMALL LETTER OMEGA	# 
+1D6DA ;	03C9 ;	MA	# ( 𝛚 → ω ) MATHEMATICAL BOLD SMALL OMEGA → GREEK SMALL LETTER OMEGA	# 
+1D714 ;	03C9 ;	MA	# ( 𝜔 → ω ) MATHEMATICAL ITALIC SMALL OMEGA → GREEK SMALL LETTER OMEGA	# 
+1D74E ;	03C9 ;	MA	# ( 𝝎 → ω ) MATHEMATICAL BOLD ITALIC SMALL OMEGA → GREEK SMALL LETTER OMEGA	# 
+1D788 ;	03C9 ;	MA	# ( 𝞈 → ω ) MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA → GREEK SMALL LETTER OMEGA	# 
+1D7C2 ;	03C9 ;	MA	# ( 𝟂 → ω ) MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA → GREEK SMALL LETTER OMEGA	# 
+2CB1 ;	03C9 ;	MA	# ( ⲱ → ω ) COPTIC SMALL LETTER OOU → GREEK SMALL LETTER OMEGA	# 
+A64D ;	03C9 ;	MA	# ( ꙍ → ω ) CYRILLIC SMALL LETTER BROAD OMEGA → GREEK SMALL LETTER OMEGA	# →ꞷ→
+
+2126 ;	03A9 ;	MA	# ( Ω → Ω ) OHM SIGN → GREEK CAPITAL LETTER OMEGA	# 
+1D6C0 ;	03A9 ;	MA	# ( 𝛀 → Ω ) MATHEMATICAL BOLD CAPITAL OMEGA → GREEK CAPITAL LETTER OMEGA	# 
+1D6FA ;	03A9 ;	MA	# ( 𝛺 → Ω ) MATHEMATICAL ITALIC CAPITAL OMEGA → GREEK CAPITAL LETTER OMEGA	# 
+1D734 ;	03A9 ;	MA	# ( 𝜴 → Ω ) MATHEMATICAL BOLD ITALIC CAPITAL OMEGA → GREEK CAPITAL LETTER OMEGA	# 
+1D76E ;	03A9 ;	MA	# ( 𝝮 → Ω ) MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA → GREEK CAPITAL LETTER OMEGA	# 
+1D7A8 ;	03A9 ;	MA	# ( 𝞨 → Ω ) MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA → GREEK CAPITAL LETTER OMEGA	# 
+162F ;	03A9 ;	MA	# ( ᘯ → Ω ) CANADIAN SYLLABICS CARRIER LHO → GREEK CAPITAL LETTER OMEGA	# 
+1635 ;	03A9 ;	MA	# ( ᘵ → Ω ) CANADIAN SYLLABICS CARRIER TLHO → GREEK CAPITAL LETTER OMEGA	# →ᘯ→
+102B6 ;	03A9 ;	MA	# ( 𐊶 → Ω ) CARIAN LETTER TT2 → GREEK CAPITAL LETTER OMEGA	# 
+
+2379 ;	03C9 0332 ;	MA	#* ( ⍹ → ω̲ ) APL FUNCTIONAL SYMBOL OMEGA UNDERBAR → GREEK SMALL LETTER OMEGA, COMBINING LOW LINE	# 
+
+1F7D ;	1FF4 ;	MA	# ( ώ → ῴ ) GREEK SMALL LETTER OMEGA WITH OXIA → GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI	# 
+
+0497 ;	0436 0329 ;	MA	# ( җ → ж̩ ) CYRILLIC SMALL LETTER ZHE WITH DESCENDER → CYRILLIC SMALL LETTER ZHE, COMBINING VERTICAL LINE BELOW	# 
+
+0496 ;	0416 0329 ;	MA	# ( Җ → Ж̩ ) CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER → CYRILLIC CAPITAL LETTER ZHE, COMBINING VERTICAL LINE BELOW	# 
+
+1D20B ;	0418 ;	MA	#* ( 𝈋 → И ) GREEK VOCAL NOTATION SYMBOL-12 → CYRILLIC CAPITAL LETTER I	# →Ͷ→
+0376 ;	0418 ;	MA	# ( Ͷ → И ) GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA → CYRILLIC CAPITAL LETTER I	# 
+A6A1 ;	0418 ;	MA	# ( ꚡ → И ) BAMUM LETTER KA → CYRILLIC CAPITAL LETTER I	# →Ͷ→
+10425 ;	0418 ;	MA	# ( 𐐥 → И ) DESERET CAPITAL LETTER ENG → CYRILLIC CAPITAL LETTER I	# 
+
+0419 ;	040D ;	MA	# ( Й → Ѝ ) CYRILLIC CAPITAL LETTER SHORT I → CYRILLIC CAPITAL LETTER I WITH GRAVE	# 
+
+048A ;	040D 0326 ;	MA	# ( Ҋ → Ѝ̦ ) CYRILLIC CAPITAL LETTER SHORT I WITH TAIL → CYRILLIC CAPITAL LETTER I WITH GRAVE, COMBINING COMMA BELOW	# →Й̡→
+
+045D ;	0439 ;	MA	# ( ѝ → й ) CYRILLIC SMALL LETTER I WITH GRAVE → CYRILLIC SMALL LETTER SHORT I	# 
+
+048B ;	0439 0326 ;	MA	# ( ҋ → й̦ ) CYRILLIC SMALL LETTER SHORT I WITH TAIL → CYRILLIC SMALL LETTER SHORT I, COMBINING COMMA BELOW	# →й̡→
+
+104BC ;	04C3 ;	MA	# ( 𐒼 → Ӄ ) OSAGE CAPITAL LETTER KA → CYRILLIC CAPITAL LETTER KA WITH HOOK	# 
+
+1D2B ;	043B ;	MA	# ( ᴫ → л ) CYRILLIC LETTER SMALL CAPITAL EL → CYRILLIC SMALL LETTER EL	# 
+
+04C6 ;	043B 0326 ;	MA	# ( ӆ → л̦ ) CYRILLIC SMALL LETTER EL WITH TAIL → CYRILLIC SMALL LETTER EL, COMBINING COMMA BELOW	# →л̡→
+
+AB60 ;	0459 ;	MA	# ( ꭠ → љ ) LATIN SMALL LETTER SAKHA YAT → CYRILLIC SMALL LETTER LJE	# 
+
+104EB ;	A669 ;	MA	# ( 𐓫 → ꙩ ) OSAGE SMALL LETTER OIN → CYRILLIC SMALL LETTER MONOCULAR O	# 
+
+1DEE ;	2DEC ;	MA	# ( ᷮ → ⷬ ) COMBINING LATIN SMALL LETTER P → COMBINING CYRILLIC LETTER ER	# 
+
+104CD ;	040B ;	MA	# ( 𐓍 → Ћ ) OSAGE CAPITAL LETTER DHA → CYRILLIC CAPITAL LETTER TSHE	# 
+
+1D202 ;	04FE ;	MA	#* ( 𝈂 → Ӿ ) GREEK VOCAL NOTATION SYMBOL-3 → CYRILLIC CAPITAL LETTER HA WITH STROKE	# 
+
+1D222 ;	0460 ;	MA	#* ( 𝈢 → Ѡ ) GREEK INSTRUMENTAL NOTATION SYMBOL-8 → CYRILLIC CAPITAL LETTER OMEGA	# 
+13C7 ;	0460 ;	MA	# ( Ꮗ → Ѡ ) CHEROKEE LETTER QUE → CYRILLIC CAPITAL LETTER OMEGA	# 
+15EF ;	0460 ;	MA	# ( ᗯ → Ѡ ) CANADIAN SYLLABICS CARRIER GU → CYRILLIC CAPITAL LETTER OMEGA	# 
+
+047C ;	0460 0486 0487 ;	MA	# ( Ѽ → Ѡ҆҇ ) CYRILLIC CAPITAL LETTER OMEGA WITH TITLO → CYRILLIC CAPITAL LETTER OMEGA, COMBINING CYRILLIC PSILI PNEUMATA, COMBINING CYRILLIC POKRYTIE	# 
+
+18ED ;	0460 00B7 ;	MA	# ( ᣭ → Ѡ· ) CANADIAN SYLLABICS CARRIER GWU → CYRILLIC CAPITAL LETTER OMEGA, MIDDLE DOT	# →ᗯᐧ→
+
+A7B6 ;	A64C ;	MA	# ( Ꞷ → Ꙍ ) LATIN CAPITAL LETTER OMEGA → CYRILLIC CAPITAL LETTER BROAD OMEGA	# 
+2CB0 ;	A64C ;	MA	# ( Ⲱ → Ꙍ ) COPTIC CAPITAL LETTER OOU → CYRILLIC CAPITAL LETTER BROAD OMEGA	# 
+
+0AEB ;	0447 ;	MA	# ( ૫ → ч ) GUJARATI DIGIT FIVE → CYRILLIC SMALL LETTER CHE	# 
+03E5 ;	0447 ;	MA	# ( ϥ → ч ) COPTIC SMALL LETTER FEI → CYRILLIC SMALL LETTER CHE	# 
+0AAA ;	0447 ;	MA	# ( પ → ч ) GUJARATI LETTER PA → CYRILLIC SMALL LETTER CHE	# →૫→
+
+03E4 ;	0427 ;	MA	# ( Ϥ → Ч ) COPTIC CAPITAL LETTER FEI → CYRILLIC CAPITAL LETTER CHE	# 
+
+04CC ;	04B7 ;	MA	# ( ӌ → ҷ ) CYRILLIC SMALL LETTER KHAKASSIAN CHE → CYRILLIC SMALL LETTER CHE WITH DESCENDER	# 
+
+04CB ;	04B6 ;	MA	# ( Ӌ → Ҷ ) CYRILLIC CAPITAL LETTER KHAKASSIAN CHE → CYRILLIC CAPITAL LETTER CHE WITH DESCENDER	# 
+
+04BE ;	04BC 0328 ;	MA	# ( Ҿ → Ҽ̨ ) CYRILLIC CAPITAL LETTER ABKHASIAN CHE WITH DESCENDER → CYRILLIC CAPITAL LETTER ABKHASIAN CHE, COMBINING OGONEK	# 
+
+2CBC ;	0428 ;	MA	# ( Ⲽ → Ш ) COPTIC CAPITAL LETTER CRYPTOGRAMMIC NI → CYRILLIC CAPITAL LETTER SHA	# 
+
+A650 ;	042A 006C ;	MA	# ( Ꙑ → Ъl ) CYRILLIC CAPITAL LETTER YERU WITH BACK YER → CYRILLIC CAPITAL LETTER HARD SIGN, LATIN SMALL LETTER L	# →ЪІ→
+
+2108 ;	042D ;	MA	#* ( ℈ → Э ) SCRUPLE → CYRILLIC CAPITAL LETTER E	# 
+
+1F701 ;	A658 ;	MA	#* ( 🜁 → Ꙙ ) ALCHEMICAL SYMBOL FOR AIR → CYRILLIC CAPITAL LETTER CLOSED LITTLE YUS	# 
+16F1C ;	A658 ;	MA	# ( 𖼜 → Ꙙ ) MIAO LETTER TLHYA → CYRILLIC CAPITAL LETTER CLOSED LITTLE YUS	# 
+
+A992 ;	2C3F ;	MA	# ( ꦒ → ⰿ ) JAVANESE LETTER GA → GLAGOLITIC SMALL LETTER MYSLITE	# 
+
+0587 ;	0565 0069 ;	MA	# ( և → եi ) ARMENIAN SMALL LIGATURE ECH YIWN → ARMENIAN SMALL LETTER ECH, LATIN SMALL LETTER I	# →եւ→
+
+1294 ;	0571 ;	MA	# ( ኔ → ձ ) ETHIOPIC SYLLABLE NEE → ARMENIAN SMALL LETTER JA	# 
+
+FB14 ;	0574 0565 ;	MA	# ( ﬔ → մե ) ARMENIAN SMALL LIGATURE MEN ECH → ARMENIAN SMALL LETTER MEN, ARMENIAN SMALL LETTER ECH	# 
+
+FB15 ;	0574 056B ;	MA	# ( ﬕ → մի ) ARMENIAN SMALL LIGATURE MEN INI → ARMENIAN SMALL LETTER MEN, ARMENIAN SMALL LETTER INI	# 
+
+FB17 ;	0574 056D ;	MA	# ( ﬗ → մխ ) ARMENIAN SMALL LIGATURE MEN XEH → ARMENIAN SMALL LETTER MEN, ARMENIAN SMALL LETTER XEH	# 
+
+FB13 ;	0574 0576 ;	MA	# ( ﬓ → մն ) ARMENIAN SMALL LIGATURE MEN NOW → ARMENIAN SMALL LETTER MEN, ARMENIAN SMALL LETTER NOW	# 
+
+2229 ;	0548 ;	MA	#* ( ∩ → Ո ) INTERSECTION → ARMENIAN CAPITAL LETTER VO	# →ᑎ→
+22C2 ;	0548 ;	MA	#* ( ⋂ → Ո ) N-ARY INTERSECTION → ARMENIAN CAPITAL LETTER VO	# →∩→→ᑎ→
+1D245 ;	0548 ;	MA	#* ( 𝉅 → Ո ) GREEK MUSICAL LEIMMA → ARMENIAN CAPITAL LETTER VO	# →∩→→ᑎ→
+1260 ;	0548 ;	MA	# ( በ → Ո ) ETHIOPIC SYLLABLE BA → ARMENIAN CAPITAL LETTER VO	# 
+144E ;	0548 ;	MA	# ( ᑎ → Ո ) CANADIAN SYLLABICS TI → ARMENIAN CAPITAL LETTER VO	# 
+A4F5 ;	0548 ;	MA	# ( ꓵ → Ո ) LISU LETTER UE → ARMENIAN CAPITAL LETTER VO	# →∩→→ᑎ→
+
+145A ;	0548 00B7 ;	MA	# ( ᑚ → Ո· ) CANADIAN SYLLABICS WEST-CREE TWI → ARMENIAN CAPITAL LETTER VO, MIDDLE DOT	# →ᑎᐧ→→ᑎ·→
+
+1468 ;	0548 0027 ;	MA	# ( ᑨ → Ո' ) CANADIAN SYLLABICS TTI → ARMENIAN CAPITAL LETTER VO, APOSTROPHE	# →ᑎᑊ→→ᑎ'→
+
+FB16 ;	057E 0576 ;	MA	# ( ﬖ → վն ) ARMENIAN SMALL LIGATURE VEW NOW → ARMENIAN SMALL LETTER VEW, ARMENIAN SMALL LETTER NOW	# 
+
+2CE8 ;	0554 ;	MA	#* ( ⳨ → Ք ) COPTIC SYMBOL TAU RO → ARMENIAN CAPITAL LETTER KEH	# →₽→
+101A0 ;	0554 ;	MA	#* ( 𐆠 → Ք ) GREEK SYMBOL TAU RHO → ARMENIAN CAPITAL LETTER KEH	# →⳨→→₽→
+20BD ;	0554 ;	MA	#* ( ₽ → Ք ) RUBLE SIGN → ARMENIAN CAPITAL LETTER KEH	# 
+2CC0 ;	0554 ;	MA	# ( Ⳁ → Ք ) COPTIC CAPITAL LETTER SAMPI → ARMENIAN CAPITAL LETTER KEH	# →₽→
+
+02D3 ;	0559 ;	MA	#* ( ˓ → ՙ ) MODIFIER LETTER CENTRED LEFT HALF RING → ARMENIAN MODIFIER LETTER LEFT HALF RING	# 
+02BF ;	0559 ;	MA	# ( ʿ → ՙ ) MODIFIER LETTER LEFT HALF RING → ARMENIAN MODIFIER LETTER LEFT HALF RING	# 
+
+2135 ;	05D0 ;	MA	# ( ℵ → ‎א‎ ) ALEF SYMBOL → HEBREW LETTER ALEF	# 
+FB21 ;	05D0 ;	MA	# ( ‎ﬡ‎ → ‎א‎ ) HEBREW LETTER WIDE ALEF → HEBREW LETTER ALEF	# 
+
+FB2F ;	FB2E ;	MA	# ( ‎אָ‎ → ‎אַ‎ ) HEBREW LETTER ALEF WITH QAMATS → HEBREW LETTER ALEF WITH PATAH	# 
+FB30 ;	FB2E ;	MA	# ( ‎אּ‎ → ‎אַ‎ ) HEBREW LETTER ALEF WITH MAPIQ → HEBREW LETTER ALEF WITH PATAH	# 
+
+FB4F ;	05D0 05DC ;	MA	# ( ‎ﭏ‎ → ‎אל‎ ) HEBREW LIGATURE ALEF LAMED → HEBREW LETTER ALEF, HEBREW LETTER LAMED	# 
+
+2136 ;	05D1 ;	MA	# ( ℶ → ‎ב‎ ) BET SYMBOL → HEBREW LETTER BET	# 
+
+2137 ;	05D2 ;	MA	# ( ℷ → ‎ג‎ ) GIMEL SYMBOL → HEBREW LETTER GIMEL	# 
+
+2138 ;	05D3 ;	MA	# ( ℸ → ‎ד‎ ) DALET SYMBOL → HEBREW LETTER DALET	# 
+FB22 ;	05D3 ;	MA	# ( ‎ﬢ‎ → ‎ד‎ ) HEBREW LETTER WIDE DALET → HEBREW LETTER DALET	# 
+
+FB23 ;	05D4 ;	MA	# ( ‎ﬣ‎ → ‎ה‎ ) HEBREW LETTER WIDE HE → HEBREW LETTER HE	# 
+
+FB39 ;	FB1D ;	MA	# ( ‎יּ‎ → ‎יִ‎ ) HEBREW LETTER YOD WITH DAGESH → HEBREW LETTER YOD WITH HIRIQ	# 
+
+FB24 ;	05DB ;	MA	# ( ‎ﬤ‎ → ‎כ‎ ) HEBREW LETTER WIDE KAF → HEBREW LETTER KAF	# 
+
+FB25 ;	05DC ;	MA	# ( ‎ﬥ‎ → ‎ל‎ ) HEBREW LETTER WIDE LAMED → HEBREW LETTER LAMED	# 
+
+FB26 ;	05DD ;	MA	# ( ‎ﬦ‎ → ‎ם‎ ) HEBREW LETTER WIDE FINAL MEM → HEBREW LETTER FINAL MEM	# 
+
+FB20 ;	05E2 ;	MA	# ( ‎ﬠ‎ → ‎ע‎ ) HEBREW LETTER ALTERNATIVE AYIN → HEBREW LETTER AYIN	# 
+
+FB27 ;	05E8 ;	MA	# ( ‎ﬧ‎ → ‎ר‎ ) HEBREW LETTER WIDE RESH → HEBREW LETTER RESH	# 
+
+FB2B ;	FB2A ;	MA	# ( ‎שׂ‎ → ‎שׁ‎ ) HEBREW LETTER SHIN WITH SIN DOT → HEBREW LETTER SHIN WITH SHIN DOT	# 
+FB49 ;	FB2A ;	MA	# ( ‎שּ‎ → ‎שׁ‎ ) HEBREW LETTER SHIN WITH DAGESH → HEBREW LETTER SHIN WITH SHIN DOT	# 
+
+FB2D ;	FB2C ;	MA	# ( ‎שּׂ‎ → ‎שּׁ‎ ) HEBREW LETTER SHIN WITH DAGESH AND SIN DOT → HEBREW LETTER SHIN WITH DAGESH AND SHIN DOT	# 
+
+FB28 ;	05EA ;	MA	# ( ‎ﬨ‎ → ‎ת‎ ) HEBREW LETTER WIDE TAV → HEBREW LETTER TAV	# 
+
+FE80 ;	0621 ;	MA	# ( ‎ﺀ‎ → ‎ء‎ ) ARABIC LETTER HAMZA ISOLATED FORM → ARABIC LETTER HAMZA	# 
+
+06FD ;	0621 10EFA ;	MA	#* ( ‎۽‎ → ‎ء𐻺‎ ) ARABIC SIGN SINDHI AMPERSAND → ARABIC LETTER HAMZA, ARABIC DOUBLE VERTICAL BAR BELOW	# 
+
+FE82 ;	0622 ;	MA	# ( ‎ﺂ‎ → ‎آ‎ ) ARABIC LETTER ALEF WITH MADDA ABOVE FINAL FORM → ARABIC LETTER ALEF WITH MADDA ABOVE	# 
+FE81 ;	0622 ;	MA	# ( ‎ﺁ‎ → ‎آ‎ ) ARABIC LETTER ALEF WITH MADDA ABOVE ISOLATED FORM → ARABIC LETTER ALEF WITH MADDA ABOVE	# 
+
+FB51 ;	0671 ;	MA	# ( ‎ﭑ‎ → ‎ٱ‎ ) ARABIC LETTER ALEF WASLA FINAL FORM → ARABIC LETTER ALEF WASLA	# 
+FB50 ;	0671 ;	MA	# ( ‎ﭐ‎ → ‎ٱ‎ ) ARABIC LETTER ALEF WASLA ISOLATED FORM → ARABIC LETTER ALEF WASLA	# 
+
+1EE01 ;	0628 ;	MA	# ( ‎𞸁‎ → ‎ب‎ ) ARABIC MATHEMATICAL BEH → ARABIC LETTER BEH	# 
+1EE21 ;	0628 ;	MA	# ( ‎𞸡‎ → ‎ب‎ ) ARABIC MATHEMATICAL INITIAL BEH → ARABIC LETTER BEH	# 
+1EE61 ;	0628 ;	MA	# ( ‎𞹡‎ → ‎ب‎ ) ARABIC MATHEMATICAL STRETCHED BEH → ARABIC LETTER BEH	# 
+1EE81 ;	0628 ;	MA	# ( ‎𞺁‎ → ‎ب‎ ) ARABIC MATHEMATICAL LOOPED BEH → ARABIC LETTER BEH	# 
+1EEA1 ;	0628 ;	MA	# ( ‎𞺡‎ → ‎ب‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK BEH → ARABIC LETTER BEH	# 
+FE91 ;	0628 ;	MA	# ( ‎ﺑ‎ → ‎ب‎ ) ARABIC LETTER BEH INITIAL FORM → ARABIC LETTER BEH	# 
+FE92 ;	0628 ;	MA	# ( ‎ﺒ‎ → ‎ب‎ ) ARABIC LETTER BEH MEDIAL FORM → ARABIC LETTER BEH	# 
+FE90 ;	0628 ;	MA	# ( ‎ﺐ‎ → ‎ب‎ ) ARABIC LETTER BEH FINAL FORM → ARABIC LETTER BEH	# 
+FE8F ;	0628 ;	MA	# ( ‎ﺏ‎ → ‎ب‎ ) ARABIC LETTER BEH ISOLATED FORM → ARABIC LETTER BEH	# 
+
+0751 ;	0628 06DB ;	MA	# ( ‎ݑ‎ → ‎بۛ‎ ) ARABIC LETTER BEH WITH DOT BELOW AND THREE DOTS ABOVE → ARABIC LETTER BEH, ARABIC SMALL HIGH THREE DOTS	# 
+
+08B6 ;	0628 06E2 ;	MA	# ( ‎ࢶ‎ → ‎بۢ‎ ) ARABIC LETTER BEH WITH SMALL MEEM ABOVE → ARABIC LETTER BEH, ARABIC SMALL HIGH MEEM ISOLATED FORM	# 
+
+08A1 ;	0628 0654 ;	MA	# ( ‎ࢡ‎ → ‎بٔ‎ ) ARABIC LETTER BEH WITH HAMZA ABOVE → ARABIC LETTER BEH, ARABIC HAMZA ABOVE	# 
+
+FCA0 ;	0628 006F ;	MA	# ( ‎ﲠ‎ → ‎بo‎ ) ARABIC LIGATURE BEH WITH HEH INITIAL FORM → ARABIC LETTER BEH, LATIN SMALL LETTER O	# →‎به‎→
+FCE2 ;	0628 006F ;	MA	# ( ‎ﳢ‎ → ‎بo‎ ) ARABIC LIGATURE BEH WITH HEH MEDIAL FORM → ARABIC LETTER BEH, LATIN SMALL LETTER O	# →‎به‎→
+
+FC9C ;	0628 062C ;	MA	# ( ‎ﲜ‎ → ‎بج‎ ) ARABIC LIGATURE BEH WITH JEEM INITIAL FORM → ARABIC LETTER BEH, ARABIC LETTER JEEM	# 
+FC05 ;	0628 062C ;	MA	# ( ‎ﰅ‎ → ‎بج‎ ) ARABIC LIGATURE BEH WITH JEEM ISOLATED FORM → ARABIC LETTER BEH, ARABIC LETTER JEEM	# 
+
+FC9D ;	0628 062D ;	MA	# ( ‎ﲝ‎ → ‎بح‎ ) ARABIC LIGATURE BEH WITH HAH INITIAL FORM → ARABIC LETTER BEH, ARABIC LETTER HAH	# 
+FC06 ;	0628 062D ;	MA	# ( ‎ﰆ‎ → ‎بح‎ ) ARABIC LIGATURE BEH WITH HAH ISOLATED FORM → ARABIC LETTER BEH, ARABIC LETTER HAH	# 
+
+FDC2 ;	0628 062D 0649 ;	MA	# ( ‎ﷂ‎ → ‎بحى‎ ) ARABIC LIGATURE BEH WITH HAH WITH YEH FINAL FORM → ARABIC LETTER BEH, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎بحي‎→
+
+FC9E ;	0628 062E ;	MA	# ( ‎ﲞ‎ → ‎بخ‎ ) ARABIC LIGATURE BEH WITH KHAH INITIAL FORM → ARABIC LETTER BEH, ARABIC LETTER KHAH	# 
+FC07 ;	0628 062E ;	MA	# ( ‎ﰇ‎ → ‎بخ‎ ) ARABIC LIGATURE BEH WITH KHAH ISOLATED FORM → ARABIC LETTER BEH, ARABIC LETTER KHAH	# 
+FCD2 ;	0628 062E ;	MA	# ( ‎ﳒ‎ → ‎بخ‎ ) ARABIC LIGATURE NOON WITH JEEM INITIAL FORM → ARABIC LETTER BEH, ARABIC LETTER KHAH	# →‎ﲞ‎→
+FC4B ;	0628 062E ;	MA	# ( ‎ﱋ‎ → ‎بخ‎ ) ARABIC LIGATURE NOON WITH JEEM ISOLATED FORM → ARABIC LETTER BEH, ARABIC LETTER KHAH	# →‎نج‎→→‎ﳒ‎→→‎ﲞ‎→
+
+FD9E ;	0628 062E 0649 ;	MA	# ( ‎ﶞ‎ → ‎بخى‎ ) ARABIC LIGATURE BEH WITH KHAH WITH YEH FINAL FORM → ARABIC LETTER BEH, ARABIC LETTER KHAH, ARABIC LETTER ALEF MAKSURA	# →‎بخي‎→
+
+FC6A ;	0628 0631 ;	MA	# ( ‎ﱪ‎ → ‎بر‎ ) ARABIC LIGATURE BEH WITH REH FINAL FORM → ARABIC LETTER BEH, ARABIC LETTER REH	# 
+
+FC6B ;	0628 0632 ;	MA	# ( ‎ﱫ‎ → ‎بز‎ ) ARABIC LIGATURE BEH WITH ZAIN FINAL FORM → ARABIC LETTER BEH, ARABIC LETTER ZAIN	# 
+
+FC9F ;	0628 0645 ;	MA	# ( ‎ﲟ‎ → ‎بم‎ ) ARABIC LIGATURE BEH WITH MEEM INITIAL FORM → ARABIC LETTER BEH, ARABIC LETTER MEEM	# 
+FCE1 ;	0628 0645 ;	MA	# ( ‎ﳡ‎ → ‎بم‎ ) ARABIC LIGATURE BEH WITH MEEM MEDIAL FORM → ARABIC LETTER BEH, ARABIC LETTER MEEM	# 
+FC6C ;	0628 0645 ;	MA	# ( ‎ﱬ‎ → ‎بم‎ ) ARABIC LIGATURE BEH WITH MEEM FINAL FORM → ARABIC LETTER BEH, ARABIC LETTER MEEM	# 
+FC08 ;	0628 0645 ;	MA	# ( ‎ﰈ‎ → ‎بم‎ ) ARABIC LIGATURE BEH WITH MEEM ISOLATED FORM → ARABIC LETTER BEH, ARABIC LETTER MEEM	# 
+
+FC6D ;	0628 0646 ;	MA	# ( ‎ﱭ‎ → ‎بن‎ ) ARABIC LIGATURE BEH WITH NOON FINAL FORM → ARABIC LETTER BEH, ARABIC LETTER NOON	# 
+
+FC6E ;	0628 0649 ;	MA	# ( ‎ﱮ‎ → ‎بى‎ ) ARABIC LIGATURE BEH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER BEH, ARABIC LETTER ALEF MAKSURA	# 
+FC09 ;	0628 0649 ;	MA	# ( ‎ﰉ‎ → ‎بى‎ ) ARABIC LIGATURE BEH WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER BEH, ARABIC LETTER ALEF MAKSURA	# 
+FC6F ;	0628 0649 ;	MA	# ( ‎ﱯ‎ → ‎بى‎ ) ARABIC LIGATURE BEH WITH YEH FINAL FORM → ARABIC LETTER BEH, ARABIC LETTER ALEF MAKSURA	# →‎بي‎→
+FC0A ;	0628 0649 ;	MA	# ( ‎ﰊ‎ → ‎بى‎ ) ARABIC LIGATURE BEH WITH YEH ISOLATED FORM → ARABIC LETTER BEH, ARABIC LETTER ALEF MAKSURA	# →‎بي‎→
+
+FB54 ;	067B ;	MA	# ( ‎ﭔ‎ → ‎ٻ‎ ) ARABIC LETTER BEEH INITIAL FORM → ARABIC LETTER BEEH	# 
+FB55 ;	067B ;	MA	# ( ‎ﭕ‎ → ‎ٻ‎ ) ARABIC LETTER BEEH MEDIAL FORM → ARABIC LETTER BEEH	# 
+FB53 ;	067B ;	MA	# ( ‎ﭓ‎ → ‎ٻ‎ ) ARABIC LETTER BEEH FINAL FORM → ARABIC LETTER BEEH	# 
+FB52 ;	067B ;	MA	# ( ‎ﭒ‎ → ‎ٻ‎ ) ARABIC LETTER BEEH ISOLATED FORM → ARABIC LETTER BEEH	# 
+06D0 ;	067B ;	MA	# ( ‎ې‎ → ‎ٻ‎ ) ARABIC LETTER E → ARABIC LETTER BEEH	# 
+FBE6 ;	067B ;	MA	# ( ‎ﯦ‎ → ‎ٻ‎ ) ARABIC LETTER E INITIAL FORM → ARABIC LETTER BEEH	# →‎ې‎→
+FBE7 ;	067B ;	MA	# ( ‎ﯧ‎ → ‎ٻ‎ ) ARABIC LETTER E MEDIAL FORM → ARABIC LETTER BEEH	# →‎ې‎→
+FBE5 ;	067B ;	MA	# ( ‎ﯥ‎ → ‎ٻ‎ ) ARABIC LETTER E FINAL FORM → ARABIC LETTER BEEH	# →‎ې‎→
+FBE4 ;	067B ;	MA	# ( ‎ﯤ‎ → ‎ٻ‎ ) ARABIC LETTER E ISOLATED FORM → ARABIC LETTER BEEH	# →‎ې‎→
+
+FB5C ;	0680 ;	MA	# ( ‎ﭜ‎ → ‎ڀ‎ ) ARABIC LETTER BEHEH INITIAL FORM → ARABIC LETTER BEHEH	# 
+FB5D ;	0680 ;	MA	# ( ‎ﭝ‎ → ‎ڀ‎ ) ARABIC LETTER BEHEH MEDIAL FORM → ARABIC LETTER BEHEH	# 
+FB5B ;	0680 ;	MA	# ( ‎ﭛ‎ → ‎ڀ‎ ) ARABIC LETTER BEHEH FINAL FORM → ARABIC LETTER BEHEH	# 
+FB5A ;	0680 ;	MA	# ( ‎ﭚ‎ → ‎ڀ‎ ) ARABIC LETTER BEHEH ISOLATED FORM → ARABIC LETTER BEHEH	# 
+10EC7 ;	0680 ;	MA	# ( ‎𐻇‎ → ‎ڀ‎ ) ARABIC LETTER YEH WITH FOUR DOTS BELOW → ARABIC LETTER BEHEH	# 
+
+08A9 ;	0754 ;	MA	# ( ‎ࢩ‎ → ‎ݔ‎ ) ARABIC LETTER YEH WITH TWO DOTS BELOW AND DOT ABOVE → ARABIC LETTER BEH WITH TWO DOTS BELOW AND DOT ABOVE	# 
+0767 ;	0754 ;	MA	# ( ‎ݧ‎ → ‎ݔ‎ ) ARABIC LETTER NOON WITH TWO DOTS BELOW → ARABIC LETTER BEH WITH TWO DOTS BELOW AND DOT ABOVE	# 
+
+2365 ;	0629 ;	MA	#* ( ⍥ → ‎ة‎ ) APL FUNCTIONAL SYMBOL CIRCLE DIAERESIS → ARABIC LETTER TEH MARBUTA	# →ö→
+00F6 ;	0629 ;	MA	# ( ö → ‎ة‎ ) LATIN SMALL LETTER O WITH DIAERESIS → ARABIC LETTER TEH MARBUTA	# 
+FE94 ;	0629 ;	MA	# ( ‎ﺔ‎ → ‎ة‎ ) ARABIC LETTER TEH MARBUTA FINAL FORM → ARABIC LETTER TEH MARBUTA	# 
+FE93 ;	0629 ;	MA	# ( ‎ﺓ‎ → ‎ة‎ ) ARABIC LETTER TEH MARBUTA ISOLATED FORM → ARABIC LETTER TEH MARBUTA	# 
+06C3 ;	0629 ;	MA	# ( ‎ۃ‎ → ‎ة‎ ) ARABIC LETTER TEH MARBUTA GOAL → ARABIC LETTER TEH MARBUTA	# 
+
+1EE15 ;	062A ;	MA	# ( ‎𞸕‎ → ‎ت‎ ) ARABIC MATHEMATICAL TEH → ARABIC LETTER TEH	# 
+1EE35 ;	062A ;	MA	# ( ‎𞸵‎ → ‎ت‎ ) ARABIC MATHEMATICAL INITIAL TEH → ARABIC LETTER TEH	# 
+1EE75 ;	062A ;	MA	# ( ‎𞹵‎ → ‎ت‎ ) ARABIC MATHEMATICAL STRETCHED TEH → ARABIC LETTER TEH	# 
+1EE95 ;	062A ;	MA	# ( ‎𞺕‎ → ‎ت‎ ) ARABIC MATHEMATICAL LOOPED TEH → ARABIC LETTER TEH	# 
+1EEB5 ;	062A ;	MA	# ( ‎𞺵‎ → ‎ت‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK TEH → ARABIC LETTER TEH	# 
+FE97 ;	062A ;	MA	# ( ‎ﺗ‎ → ‎ت‎ ) ARABIC LETTER TEH INITIAL FORM → ARABIC LETTER TEH	# 
+FE98 ;	062A ;	MA	# ( ‎ﺘ‎ → ‎ت‎ ) ARABIC LETTER TEH MEDIAL FORM → ARABIC LETTER TEH	# 
+FE96 ;	062A ;	MA	# ( ‎ﺖ‎ → ‎ت‎ ) ARABIC LETTER TEH FINAL FORM → ARABIC LETTER TEH	# 
+FE95 ;	062A ;	MA	# ( ‎ﺕ‎ → ‎ت‎ ) ARABIC LETTER TEH ISOLATED FORM → ARABIC LETTER TEH	# 
+067A ;	062A ;	MA	# ( ‎ٺ‎ → ‎ت‎ ) ARABIC LETTER TTEHEH → ARABIC LETTER TEH	# 
+FB60 ;	062A ;	MA	# ( ‎ﭠ‎ → ‎ت‎ ) ARABIC LETTER TTEHEH INITIAL FORM → ARABIC LETTER TEH	# →‎ٺ‎→
+FB61 ;	062A ;	MA	# ( ‎ﭡ‎ → ‎ت‎ ) ARABIC LETTER TTEHEH MEDIAL FORM → ARABIC LETTER TEH	# →‎ٺ‎→
+FB5F ;	062A ;	MA	# ( ‎ﭟ‎ → ‎ت‎ ) ARABIC LETTER TTEHEH FINAL FORM → ARABIC LETTER TEH	# →‎ٺ‎→
+FB5E ;	062A ;	MA	# ( ‎ﭞ‎ → ‎ت‎ ) ARABIC LETTER TTEHEH ISOLATED FORM → ARABIC LETTER TEH	# →‎ٺ‎→
+
+08BF ;	062A 0306 ;	MA	# ( ‎ࢿ‎ → ‎ت̆‎ ) ARABIC LETTER TEH WITH SMALL V → ARABIC LETTER TEH, COMBINING BREVE	# →‎تٚ‎→
+
+FCA5 ;	062A 006F ;	MA	# ( ‎ﲥ‎ → ‎تo‎ ) ARABIC LIGATURE TEH WITH HEH INITIAL FORM → ARABIC LETTER TEH, LATIN SMALL LETTER O	# →‎ته‎→
+FCE4 ;	062A 006F ;	MA	# ( ‎ﳤ‎ → ‎تo‎ ) ARABIC LIGATURE TEH WITH HEH MEDIAL FORM → ARABIC LETTER TEH, LATIN SMALL LETTER O	# →‎ته‎→
+
+FCA1 ;	062A 062C ;	MA	# ( ‎ﲡ‎ → ‎تج‎ ) ARABIC LIGATURE TEH WITH JEEM INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER JEEM	# 
+FC0B ;	062A 062C ;	MA	# ( ‎ﰋ‎ → ‎تج‎ ) ARABIC LIGATURE TEH WITH JEEM ISOLATED FORM → ARABIC LETTER TEH, ARABIC LETTER JEEM	# 
+
+FD50 ;	062A 062C 0645 ;	MA	# ( ‎ﵐ‎ → ‎تجم‎ ) ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER JEEM, ARABIC LETTER MEEM	# 
+
+FDA0 ;	062A 062C 0649 ;	MA	# ( ‎ﶠ‎ → ‎تجى‎ ) ARABIC LIGATURE TEH WITH JEEM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# 
+FD9F ;	062A 062C 0649 ;	MA	# ( ‎ﶟ‎ → ‎تجى‎ ) ARABIC LIGATURE TEH WITH JEEM WITH YEH FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# →‎تجي‎→
+
+FCA2 ;	062A 062D ;	MA	# ( ‎ﲢ‎ → ‎تح‎ ) ARABIC LIGATURE TEH WITH HAH INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER HAH	# 
+FC0C ;	062A 062D ;	MA	# ( ‎ﰌ‎ → ‎تح‎ ) ARABIC LIGATURE TEH WITH HAH ISOLATED FORM → ARABIC LETTER TEH, ARABIC LETTER HAH	# 
+
+FD52 ;	062A 062D 062C ;	MA	# ( ‎ﵒ‎ → ‎تحج‎ ) ARABIC LIGATURE TEH WITH HAH WITH JEEM INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER HAH, ARABIC LETTER JEEM	# 
+FD51 ;	062A 062D 062C ;	MA	# ( ‎ﵑ‎ → ‎تحج‎ ) ARABIC LIGATURE TEH WITH HAH WITH JEEM FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER HAH, ARABIC LETTER JEEM	# 
+
+FD53 ;	062A 062D 0645 ;	MA	# ( ‎ﵓ‎ → ‎تحم‎ ) ARABIC LIGATURE TEH WITH HAH WITH MEEM INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER HAH, ARABIC LETTER MEEM	# 
+
+FCA3 ;	062A 062E ;	MA	# ( ‎ﲣ‎ → ‎تخ‎ ) ARABIC LIGATURE TEH WITH KHAH INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER KHAH	# 
+FC0D ;	062A 062E ;	MA	# ( ‎ﰍ‎ → ‎تخ‎ ) ARABIC LIGATURE TEH WITH KHAH ISOLATED FORM → ARABIC LETTER TEH, ARABIC LETTER KHAH	# 
+
+FD54 ;	062A 062E 0645 ;	MA	# ( ‎ﵔ‎ → ‎تخم‎ ) ARABIC LIGATURE TEH WITH KHAH WITH MEEM INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER KHAH, ARABIC LETTER MEEM	# 
+
+FDA2 ;	062A 062E 0649 ;	MA	# ( ‎ﶢ‎ → ‎تخى‎ ) ARABIC LIGATURE TEH WITH KHAH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER KHAH, ARABIC LETTER ALEF MAKSURA	# 
+FDA1 ;	062A 062E 0649 ;	MA	# ( ‎ﶡ‎ → ‎تخى‎ ) ARABIC LIGATURE TEH WITH KHAH WITH YEH FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER KHAH, ARABIC LETTER ALEF MAKSURA	# →‎تخي‎→
+
+FC70 ;	062A 0631 ;	MA	# ( ‎ﱰ‎ → ‎تر‎ ) ARABIC LIGATURE TEH WITH REH FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER REH	# 
+
+FC71 ;	062A 0632 ;	MA	# ( ‎ﱱ‎ → ‎تز‎ ) ARABIC LIGATURE TEH WITH ZAIN FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER ZAIN	# 
+
+FCA4 ;	062A 0645 ;	MA	# ( ‎ﲤ‎ → ‎تم‎ ) ARABIC LIGATURE TEH WITH MEEM INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER MEEM	# 
+FCE3 ;	062A 0645 ;	MA	# ( ‎ﳣ‎ → ‎تم‎ ) ARABIC LIGATURE TEH WITH MEEM MEDIAL FORM → ARABIC LETTER TEH, ARABIC LETTER MEEM	# 
+FC72 ;	062A 0645 ;	MA	# ( ‎ﱲ‎ → ‎تم‎ ) ARABIC LIGATURE TEH WITH MEEM FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER MEEM	# 
+FC0E ;	062A 0645 ;	MA	# ( ‎ﰎ‎ → ‎تم‎ ) ARABIC LIGATURE TEH WITH MEEM ISOLATED FORM → ARABIC LETTER TEH, ARABIC LETTER MEEM	# 
+
+FD55 ;	062A 0645 062C ;	MA	# ( ‎ﵕ‎ → ‎تمج‎ ) ARABIC LIGATURE TEH WITH MEEM WITH JEEM INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER MEEM, ARABIC LETTER JEEM	# 
+
+FD56 ;	062A 0645 062D ;	MA	# ( ‎ﵖ‎ → ‎تمح‎ ) ARABIC LIGATURE TEH WITH MEEM WITH HAH INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+
+FD57 ;	062A 0645 062E ;	MA	# ( ‎ﵗ‎ → ‎تمخ‎ ) ARABIC LIGATURE TEH WITH MEEM WITH KHAH INITIAL FORM → ARABIC LETTER TEH, ARABIC LETTER MEEM, ARABIC LETTER KHAH	# 
+
+FDA4 ;	062A 0645 0649 ;	MA	# ( ‎ﶤ‎ → ‎تمى‎ ) ARABIC LIGATURE TEH WITH MEEM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# 
+FDA3 ;	062A 0645 0649 ;	MA	# ( ‎ﶣ‎ → ‎تمى‎ ) ARABIC LIGATURE TEH WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎تمي‎→
+
+FC73 ;	062A 0646 ;	MA	# ( ‎ﱳ‎ → ‎تن‎ ) ARABIC LIGATURE TEH WITH NOON FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER NOON	# 
+
+FC74 ;	062A 0649 ;	MA	# ( ‎ﱴ‎ → ‎تى‎ ) ARABIC LIGATURE TEH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER ALEF MAKSURA	# 
+FC0F ;	062A 0649 ;	MA	# ( ‎ﰏ‎ → ‎تى‎ ) ARABIC LIGATURE TEH WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER TEH, ARABIC LETTER ALEF MAKSURA	# 
+FC75 ;	062A 0649 ;	MA	# ( ‎ﱵ‎ → ‎تى‎ ) ARABIC LIGATURE TEH WITH YEH FINAL FORM → ARABIC LETTER TEH, ARABIC LETTER ALEF MAKSURA	# →‎تي‎→
+FC10 ;	062A 0649 ;	MA	# ( ‎ﰐ‎ → ‎تى‎ ) ARABIC LIGATURE TEH WITH YEH ISOLATED FORM → ARABIC LETTER TEH, ARABIC LETTER ALEF MAKSURA	# →‎تي‎→
+
+FB64 ;	067F ;	MA	# ( ‎ﭤ‎ → ‎ٿ‎ ) ARABIC LETTER TEHEH INITIAL FORM → ARABIC LETTER TEHEH	# 
+FB65 ;	067F ;	MA	# ( ‎ﭥ‎ → ‎ٿ‎ ) ARABIC LETTER TEHEH MEDIAL FORM → ARABIC LETTER TEHEH	# 
+FB63 ;	067F ;	MA	# ( ‎ﭣ‎ → ‎ٿ‎ ) ARABIC LETTER TEHEH FINAL FORM → ARABIC LETTER TEHEH	# 
+FB62 ;	067F ;	MA	# ( ‎ﭢ‎ → ‎ٿ‎ ) ARABIC LETTER TEHEH ISOLATED FORM → ARABIC LETTER TEHEH	# 
+
+1EE02 ;	062C ;	MA	# ( ‎𞸂‎ → ‎ج‎ ) ARABIC MATHEMATICAL JEEM → ARABIC LETTER JEEM	# 
+1EE22 ;	062C ;	MA	# ( ‎𞸢‎ → ‎ج‎ ) ARABIC MATHEMATICAL INITIAL JEEM → ARABIC LETTER JEEM	# 
+1EE42 ;	062C ;	MA	# ( ‎𞹂‎ → ‎ج‎ ) ARABIC MATHEMATICAL TAILED JEEM → ARABIC LETTER JEEM	# 
+1EE62 ;	062C ;	MA	# ( ‎𞹢‎ → ‎ج‎ ) ARABIC MATHEMATICAL STRETCHED JEEM → ARABIC LETTER JEEM	# 
+1EE82 ;	062C ;	MA	# ( ‎𞺂‎ → ‎ج‎ ) ARABIC MATHEMATICAL LOOPED JEEM → ARABIC LETTER JEEM	# 
+1EEA2 ;	062C ;	MA	# ( ‎𞺢‎ → ‎ج‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK JEEM → ARABIC LETTER JEEM	# 
+FE9F ;	062C ;	MA	# ( ‎ﺟ‎ → ‎ج‎ ) ARABIC LETTER JEEM INITIAL FORM → ARABIC LETTER JEEM	# 
+FEA0 ;	062C ;	MA	# ( ‎ﺠ‎ → ‎ج‎ ) ARABIC LETTER JEEM MEDIAL FORM → ARABIC LETTER JEEM	# 
+FE9E ;	062C ;	MA	# ( ‎ﺞ‎ → ‎ج‎ ) ARABIC LETTER JEEM FINAL FORM → ARABIC LETTER JEEM	# 
+FE9D ;	062C ;	MA	# ( ‎ﺝ‎ → ‎ج‎ ) ARABIC LETTER JEEM ISOLATED FORM → ARABIC LETTER JEEM	# 
+
+FCA7 ;	062C 062D ;	MA	# ( ‎ﲧ‎ → ‎جح‎ ) ARABIC LIGATURE JEEM WITH HAH INITIAL FORM → ARABIC LETTER JEEM, ARABIC LETTER HAH	# 
+FC15 ;	062C 062D ;	MA	# ( ‎ﰕ‎ → ‎جح‎ ) ARABIC LIGATURE JEEM WITH HAH ISOLATED FORM → ARABIC LETTER JEEM, ARABIC LETTER HAH	# 
+
+FDA6 ;	062C 062D 0649 ;	MA	# ( ‎ﶦ‎ → ‎جحى‎ ) ARABIC LIGATURE JEEM WITH HAH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER JEEM, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# 
+FDBE ;	062C 062D 0649 ;	MA	# ( ‎ﶾ‎ → ‎جحى‎ ) ARABIC LIGATURE JEEM WITH HAH WITH YEH FINAL FORM → ARABIC LETTER JEEM, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎جحي‎→
+
+FDFB ;	062C 0644 0020 062C 0644 006C 0644 006F ;	MA	#* ( ‎ﷻ‎ → ‎جل جلlلo‎ ) ARABIC LIGATURE JALLAJALALOUHOU → ARABIC LETTER JEEM, ARABIC LETTER LAM, SPACE, ARABIC LETTER JEEM, ARABIC LETTER LAM, LATIN SMALL LETTER L, ARABIC LETTER LAM, LATIN SMALL LETTER O	# →‎جل جلاله‎→
+
+FCA8 ;	062C 0645 ;	MA	# ( ‎ﲨ‎ → ‎جم‎ ) ARABIC LIGATURE JEEM WITH MEEM INITIAL FORM → ARABIC LETTER JEEM, ARABIC LETTER MEEM	# 
+FC16 ;	062C 0645 ;	MA	# ( ‎ﰖ‎ → ‎جم‎ ) ARABIC LIGATURE JEEM WITH MEEM ISOLATED FORM → ARABIC LETTER JEEM, ARABIC LETTER MEEM	# 
+
+FD59 ;	062C 0645 062D ;	MA	# ( ‎ﵙ‎ → ‎جمح‎ ) ARABIC LIGATURE JEEM WITH MEEM WITH HAH INITIAL FORM → ARABIC LETTER JEEM, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+FD58 ;	062C 0645 062D ;	MA	# ( ‎ﵘ‎ → ‎جمح‎ ) ARABIC LIGATURE JEEM WITH MEEM WITH HAH FINAL FORM → ARABIC LETTER JEEM, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+
+FDA7 ;	062C 0645 0649 ;	MA	# ( ‎ﶧ‎ → ‎جمى‎ ) ARABIC LIGATURE JEEM WITH MEEM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER JEEM, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# 
+FDA5 ;	062C 0645 0649 ;	MA	# ( ‎ﶥ‎ → ‎جمى‎ ) ARABIC LIGATURE JEEM WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER JEEM, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎جمي‎→
+
+FD1D ;	062C 0649 ;	MA	# ( ‎ﴝ‎ → ‎جى‎ ) ARABIC LIGATURE JEEM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# 
+FD01 ;	062C 0649 ;	MA	# ( ‎ﴁ‎ → ‎جى‎ ) ARABIC LIGATURE JEEM WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# 
+FD1E ;	062C 0649 ;	MA	# ( ‎ﴞ‎ → ‎جى‎ ) ARABIC LIGATURE JEEM WITH YEH FINAL FORM → ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# →‎جي‎→
+FD02 ;	062C 0649 ;	MA	# ( ‎ﴂ‎ → ‎جى‎ ) ARABIC LIGATURE JEEM WITH YEH ISOLATED FORM → ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# →‎جي‎→
+
+FB78 ;	0683 ;	MA	# ( ‎ﭸ‎ → ‎ڃ‎ ) ARABIC LETTER NYEH INITIAL FORM → ARABIC LETTER NYEH	# 
+FB79 ;	0683 ;	MA	# ( ‎ﭹ‎ → ‎ڃ‎ ) ARABIC LETTER NYEH MEDIAL FORM → ARABIC LETTER NYEH	# 
+FB77 ;	0683 ;	MA	# ( ‎ﭷ‎ → ‎ڃ‎ ) ARABIC LETTER NYEH FINAL FORM → ARABIC LETTER NYEH	# 
+FB76 ;	0683 ;	MA	# ( ‎ﭶ‎ → ‎ڃ‎ ) ARABIC LETTER NYEH ISOLATED FORM → ARABIC LETTER NYEH	# 
+
+FB74 ;	0684 ;	MA	# ( ‎ﭴ‎ → ‎ڄ‎ ) ARABIC LETTER DYEH INITIAL FORM → ARABIC LETTER DYEH	# 
+FB75 ;	0684 ;	MA	# ( ‎ﭵ‎ → ‎ڄ‎ ) ARABIC LETTER DYEH MEDIAL FORM → ARABIC LETTER DYEH	# 
+FB73 ;	0684 ;	MA	# ( ‎ﭳ‎ → ‎ڄ‎ ) ARABIC LETTER DYEH FINAL FORM → ARABIC LETTER DYEH	# 
+FB72 ;	0684 ;	MA	# ( ‎ﭲ‎ → ‎ڄ‎ ) ARABIC LETTER DYEH ISOLATED FORM → ARABIC LETTER DYEH	# 
+
+FB7C ;	0686 ;	MA	# ( ‎ﭼ‎ → ‎چ‎ ) ARABIC LETTER TCHEH INITIAL FORM → ARABIC LETTER TCHEH	# 
+FB7D ;	0686 ;	MA	# ( ‎ﭽ‎ → ‎چ‎ ) ARABIC LETTER TCHEH MEDIAL FORM → ARABIC LETTER TCHEH	# 
+FB7B ;	0686 ;	MA	# ( ‎ﭻ‎ → ‎چ‎ ) ARABIC LETTER TCHEH FINAL FORM → ARABIC LETTER TCHEH	# 
+FB7A ;	0686 ;	MA	# ( ‎ﭺ‎ → ‎چ‎ ) ARABIC LETTER TCHEH ISOLATED FORM → ARABIC LETTER TCHEH	# 
+
+08C1 ;	0686 0306 ;	MA	# ( ‎ࣁ‎ → ‎چ̆‎ ) ARABIC LETTER TCHEH WITH SMALL V → ARABIC LETTER TCHEH, COMBINING BREVE	# →‎چٚ‎→
+
+FB80 ;	0687 ;	MA	# ( ‎ﮀ‎ → ‎ڇ‎ ) ARABIC LETTER TCHEHEH INITIAL FORM → ARABIC LETTER TCHEHEH	# 
+FB81 ;	0687 ;	MA	# ( ‎ﮁ‎ → ‎ڇ‎ ) ARABIC LETTER TCHEHEH MEDIAL FORM → ARABIC LETTER TCHEHEH	# 
+FB7F ;	0687 ;	MA	# ( ‎ﭿ‎ → ‎ڇ‎ ) ARABIC LETTER TCHEHEH FINAL FORM → ARABIC LETTER TCHEHEH	# 
+FB7E ;	0687 ;	MA	# ( ‎ﭾ‎ → ‎ڇ‎ ) ARABIC LETTER TCHEHEH ISOLATED FORM → ARABIC LETTER TCHEHEH	# 
+
+1EE07 ;	062D ;	MA	# ( ‎𞸇‎ → ‎ح‎ ) ARABIC MATHEMATICAL HAH → ARABIC LETTER HAH	# 
+1EE27 ;	062D ;	MA	# ( ‎𞸧‎ → ‎ح‎ ) ARABIC MATHEMATICAL INITIAL HAH → ARABIC LETTER HAH	# 
+1EE47 ;	062D ;	MA	# ( ‎𞹇‎ → ‎ح‎ ) ARABIC MATHEMATICAL TAILED HAH → ARABIC LETTER HAH	# 
+1EE67 ;	062D ;	MA	# ( ‎𞹧‎ → ‎ح‎ ) ARABIC MATHEMATICAL STRETCHED HAH → ARABIC LETTER HAH	# 
+1EE87 ;	062D ;	MA	# ( ‎𞺇‎ → ‎ح‎ ) ARABIC MATHEMATICAL LOOPED HAH → ARABIC LETTER HAH	# 
+1EEA7 ;	062D ;	MA	# ( ‎𞺧‎ → ‎ح‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK HAH → ARABIC LETTER HAH	# 
+FEA3 ;	062D ;	MA	# ( ‎ﺣ‎ → ‎ح‎ ) ARABIC LETTER HAH INITIAL FORM → ARABIC LETTER HAH	# 
+FEA4 ;	062D ;	MA	# ( ‎ﺤ‎ → ‎ح‎ ) ARABIC LETTER HAH MEDIAL FORM → ARABIC LETTER HAH	# 
+FEA2 ;	062D ;	MA	# ( ‎ﺢ‎ → ‎ح‎ ) ARABIC LETTER HAH FINAL FORM → ARABIC LETTER HAH	# 
+FEA1 ;	062D ;	MA	# ( ‎ﺡ‎ → ‎ح‎ ) ARABIC LETTER HAH ISOLATED FORM → ARABIC LETTER HAH	# 
+
+0685 ;	062D 06DB ;	MA	# ( ‎څ‎ → ‎حۛ‎ ) ARABIC LETTER HAH WITH THREE DOTS ABOVE → ARABIC LETTER HAH, ARABIC SMALL HIGH THREE DOTS	# 
+
+0681 ;	062D 0654 ;	MA	# ( ‎ځ‎ → ‎حٔ‎ ) ARABIC LETTER HAH WITH HAMZA ABOVE → ARABIC LETTER HAH, ARABIC HAMZA ABOVE	# 
+0772 ;	062D 0654 ;	MA	# ( ‎ݲ‎ → ‎حٔ‎ ) ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH ABOVE → ARABIC LETTER HAH, ARABIC HAMZA ABOVE	# 
+
+FCA9 ;	062D 062C ;	MA	# ( ‎ﲩ‎ → ‎حج‎ ) ARABIC LIGATURE HAH WITH JEEM INITIAL FORM → ARABIC LETTER HAH, ARABIC LETTER JEEM	# 
+FC17 ;	062D 062C ;	MA	# ( ‎ﰗ‎ → ‎حج‎ ) ARABIC LIGATURE HAH WITH JEEM ISOLATED FORM → ARABIC LETTER HAH, ARABIC LETTER JEEM	# 
+
+FDBF ;	062D 062C 0649 ;	MA	# ( ‎ﶿ‎ → ‎حجى‎ ) ARABIC LIGATURE HAH WITH JEEM WITH YEH FINAL FORM → ARABIC LETTER HAH, ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# →‎حجي‎→
+
+FCAA ;	062D 0645 ;	MA	# ( ‎ﲪ‎ → ‎حم‎ ) ARABIC LIGATURE HAH WITH MEEM INITIAL FORM → ARABIC LETTER HAH, ARABIC LETTER MEEM	# 
+FC18 ;	062D 0645 ;	MA	# ( ‎ﰘ‎ → ‎حم‎ ) ARABIC LIGATURE HAH WITH MEEM ISOLATED FORM → ARABIC LETTER HAH, ARABIC LETTER MEEM	# 
+
+FD5B ;	062D 0645 0649 ;	MA	# ( ‎ﵛ‎ → ‎حمى‎ ) ARABIC LIGATURE HAH WITH MEEM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER HAH, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# 
+FD5A ;	062D 0645 0649 ;	MA	# ( ‎ﵚ‎ → ‎حمى‎ ) ARABIC LIGATURE HAH WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER HAH, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎حمي‎→
+
+FD1B ;	062D 0649 ;	MA	# ( ‎ﴛ‎ → ‎حى‎ ) ARABIC LIGATURE HAH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# 
+FCFF ;	062D 0649 ;	MA	# ( ‎ﳿ‎ → ‎حى‎ ) ARABIC LIGATURE HAH WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# 
+FD1C ;	062D 0649 ;	MA	# ( ‎ﴜ‎ → ‎حى‎ ) ARABIC LIGATURE HAH WITH YEH FINAL FORM → ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎حي‎→
+FD00 ;	062D 0649 ;	MA	# ( ‎ﴀ‎ → ‎حى‎ ) ARABIC LIGATURE HAH WITH YEH ISOLATED FORM → ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎حي‎→
+
+1EE17 ;	062E ;	MA	# ( ‎𞸗‎ → ‎خ‎ ) ARABIC MATHEMATICAL KHAH → ARABIC LETTER KHAH	# 
+1EE37 ;	062E ;	MA	# ( ‎𞸷‎ → ‎خ‎ ) ARABIC MATHEMATICAL INITIAL KHAH → ARABIC LETTER KHAH	# 
+1EE57 ;	062E ;	MA	# ( ‎𞹗‎ → ‎خ‎ ) ARABIC MATHEMATICAL TAILED KHAH → ARABIC LETTER KHAH	# 
+1EE77 ;	062E ;	MA	# ( ‎𞹷‎ → ‎خ‎ ) ARABIC MATHEMATICAL STRETCHED KHAH → ARABIC LETTER KHAH	# 
+1EE97 ;	062E ;	MA	# ( ‎𞺗‎ → ‎خ‎ ) ARABIC MATHEMATICAL LOOPED KHAH → ARABIC LETTER KHAH	# 
+1EEB7 ;	062E ;	MA	# ( ‎𞺷‎ → ‎خ‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK KHAH → ARABIC LETTER KHAH	# 
+FEA7 ;	062E ;	MA	# ( ‎ﺧ‎ → ‎خ‎ ) ARABIC LETTER KHAH INITIAL FORM → ARABIC LETTER KHAH	# 
+FEA8 ;	062E ;	MA	# ( ‎ﺨ‎ → ‎خ‎ ) ARABIC LETTER KHAH MEDIAL FORM → ARABIC LETTER KHAH	# 
+FEA6 ;	062E ;	MA	# ( ‎ﺦ‎ → ‎خ‎ ) ARABIC LETTER KHAH FINAL FORM → ARABIC LETTER KHAH	# 
+FEA5 ;	062E ;	MA	# ( ‎ﺥ‎ → ‎خ‎ ) ARABIC LETTER KHAH ISOLATED FORM → ARABIC LETTER KHAH	# 
+
+FCAB ;	062E 062C ;	MA	# ( ‎ﲫ‎ → ‎خج‎ ) ARABIC LIGATURE KHAH WITH JEEM INITIAL FORM → ARABIC LETTER KHAH, ARABIC LETTER JEEM	# 
+FC19 ;	062E 062C ;	MA	# ( ‎ﰙ‎ → ‎خج‎ ) ARABIC LIGATURE KHAH WITH JEEM ISOLATED FORM → ARABIC LETTER KHAH, ARABIC LETTER JEEM	# 
+
+FC1A ;	062E 062D ;	MA	# ( ‎ﰚ‎ → ‎خح‎ ) ARABIC LIGATURE KHAH WITH HAH ISOLATED FORM → ARABIC LETTER KHAH, ARABIC LETTER HAH	# 
+
+FCAC ;	062E 0645 ;	MA	# ( ‎ﲬ‎ → ‎خم‎ ) ARABIC LIGATURE KHAH WITH MEEM INITIAL FORM → ARABIC LETTER KHAH, ARABIC LETTER MEEM	# 
+FC1B ;	062E 0645 ;	MA	# ( ‎ﰛ‎ → ‎خم‎ ) ARABIC LIGATURE KHAH WITH MEEM ISOLATED FORM → ARABIC LETTER KHAH, ARABIC LETTER MEEM	# 
+
+FD1F ;	062E 0649 ;	MA	# ( ‎ﴟ‎ → ‎خى‎ ) ARABIC LIGATURE KHAH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER KHAH, ARABIC LETTER ALEF MAKSURA	# 
+FD03 ;	062E 0649 ;	MA	# ( ‎ﴃ‎ → ‎خى‎ ) ARABIC LIGATURE KHAH WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER KHAH, ARABIC LETTER ALEF MAKSURA	# 
+FD20 ;	062E 0649 ;	MA	# ( ‎ﴠ‎ → ‎خى‎ ) ARABIC LIGATURE KHAH WITH YEH FINAL FORM → ARABIC LETTER KHAH, ARABIC LETTER ALEF MAKSURA	# →‎خي‎→
+FD04 ;	062E 0649 ;	MA	# ( ‎ﴄ‎ → ‎خى‎ ) ARABIC LIGATURE KHAH WITH YEH ISOLATED FORM → ARABIC LETTER KHAH, ARABIC LETTER ALEF MAKSURA	# →‎خي‎→
+
+102E1 ;	062F ;	MA	#* ( 𐋡 → ‎د‎ ) COPTIC EPACT DIGIT ONE → ARABIC LETTER DAL	# 
+1EE03 ;	062F ;	MA	# ( ‎𞸃‎ → ‎د‎ ) ARABIC MATHEMATICAL DAL → ARABIC LETTER DAL	# 
+1EE83 ;	062F ;	MA	# ( ‎𞺃‎ → ‎د‎ ) ARABIC MATHEMATICAL LOOPED DAL → ARABIC LETTER DAL	# 
+1EEA3 ;	062F ;	MA	# ( ‎𞺣‎ → ‎د‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK DAL → ARABIC LETTER DAL	# 
+FEAA ;	062F ;	MA	# ( ‎ﺪ‎ → ‎د‎ ) ARABIC LETTER DAL FINAL FORM → ARABIC LETTER DAL	# 
+FEA9 ;	062F ;	MA	# ( ‎ﺩ‎ → ‎د‎ ) ARABIC LETTER DAL ISOLATED FORM → ARABIC LETTER DAL	# 
+
+0688 ;	062F 0615 ;	MA	# ( ‎ڈ‎ → ‎دؕ‎ ) ARABIC LETTER DDAL → ARABIC LETTER DAL, ARABIC SMALL HIGH TAH	# 
+FB89 ;	062F 0615 ;	MA	# ( ‎ﮉ‎ → ‎دؕ‎ ) ARABIC LETTER DDAL FINAL FORM → ARABIC LETTER DAL, ARABIC SMALL HIGH TAH	# →‎ڈ‎→
+FB88 ;	062F 0615 ;	MA	# ( ‎ﮈ‎ → ‎دؕ‎ ) ARABIC LETTER DDAL ISOLATED FORM → ARABIC LETTER DAL, ARABIC SMALL HIGH TAH	# →‎ڈ‎→
+
+068E ;	062F 06DB ;	MA	# ( ‎ڎ‎ → ‎دۛ‎ ) ARABIC LETTER DUL → ARABIC LETTER DAL, ARABIC SMALL HIGH THREE DOTS	# 
+FB87 ;	062F 06DB ;	MA	# ( ‎ﮇ‎ → ‎دۛ‎ ) ARABIC LETTER DUL FINAL FORM → ARABIC LETTER DAL, ARABIC SMALL HIGH THREE DOTS	# →‎ڎ‎→
+FB86 ;	062F 06DB ;	MA	# ( ‎ﮆ‎ → ‎دۛ‎ ) ARABIC LETTER DUL ISOLATED FORM → ARABIC LETTER DAL, ARABIC SMALL HIGH THREE DOTS	# →‎ڎ‎→
+068F ;	062F 06DB ;	MA	# ( ‎ڏ‎ → ‎دۛ‎ ) ARABIC LETTER DAL WITH THREE DOTS ABOVE DOWNWARDS → ARABIC LETTER DAL, ARABIC SMALL HIGH THREE DOTS	# →‎ڎ‎→
+
+06EE ;	062F 0302 ;	MA	# ( ‎ۮ‎ → ‎د̂‎ ) ARABIC LETTER DAL WITH INVERTED V → ARABIC LETTER DAL, COMBINING CIRCUMFLEX ACCENT	# →‎دٛ‎→
+
+08AE ;	062F 0324 0323 ;	MA	# ( ‎ࢮ‎ → ‎د̤̣‎ ) ARABIC LETTER DAL WITH THREE DOTS BELOW → ARABIC LETTER DAL, COMBINING DIAERESIS BELOW, COMBINING DOT BELOW	# →‎د࣮࣭‎→
+
+1EE18 ;	0630 ;	MA	# ( ‎𞸘‎ → ‎ذ‎ ) ARABIC MATHEMATICAL THAL → ARABIC LETTER THAL	# 
+1EE98 ;	0630 ;	MA	# ( ‎𞺘‎ → ‎ذ‎ ) ARABIC MATHEMATICAL LOOPED THAL → ARABIC LETTER THAL	# 
+1EEB8 ;	0630 ;	MA	# ( ‎𞺸‎ → ‎ذ‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK THAL → ARABIC LETTER THAL	# 
+FEAC ;	0630 ;	MA	# ( ‎ﺬ‎ → ‎ذ‎ ) ARABIC LETTER THAL FINAL FORM → ARABIC LETTER THAL	# 
+FEAB ;	0630 ;	MA	# ( ‎ﺫ‎ → ‎ذ‎ ) ARABIC LETTER THAL ISOLATED FORM → ARABIC LETTER THAL	# 
+
+FC5B ;	0630 0670 ;	MA	# ( ‎ﱛ‎ → ‎ذٰ‎ ) ARABIC LIGATURE THAL WITH SUPERSCRIPT ALEF ISOLATED FORM → ARABIC LETTER THAL, ARABIC LETTER SUPERSCRIPT ALEF	# 
+
+068B ;	068A 0615 ;	MA	# ( ‎ڋ‎ → ‎ڊؕ‎ ) ARABIC LETTER DAL WITH DOT BELOW AND SMALL TAH → ARABIC LETTER DAL WITH DOT BELOW, ARABIC SMALL HIGH TAH	# 
+
+FB85 ;	068C ;	MA	# ( ‎ﮅ‎ → ‎ڌ‎ ) ARABIC LETTER DAHAL FINAL FORM → ARABIC LETTER DAHAL	# 
+FB84 ;	068C ;	MA	# ( ‎ﮄ‎ → ‎ڌ‎ ) ARABIC LETTER DAHAL ISOLATED FORM → ARABIC LETTER DAHAL	# 
+
+FB83 ;	068D ;	MA	# ( ‎ﮃ‎ → ‎ڍ‎ ) ARABIC LETTER DDAHAL FINAL FORM → ARABIC LETTER DDAHAL	# 
+FB82 ;	068D ;	MA	# ( ‎ﮂ‎ → ‎ڍ‎ ) ARABIC LETTER DDAHAL ISOLATED FORM → ARABIC LETTER DDAHAL	# 
+
+1EE13 ;	0631 ;	MA	# ( ‎𞸓‎ → ‎ر‎ ) ARABIC MATHEMATICAL REH → ARABIC LETTER REH	# 
+1EE93 ;	0631 ;	MA	# ( ‎𞺓‎ → ‎ر‎ ) ARABIC MATHEMATICAL LOOPED REH → ARABIC LETTER REH	# 
+1EEB3 ;	0631 ;	MA	# ( ‎𞺳‎ → ‎ر‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK REH → ARABIC LETTER REH	# 
+FEAE ;	0631 ;	MA	# ( ‎ﺮ‎ → ‎ر‎ ) ARABIC LETTER REH FINAL FORM → ARABIC LETTER REH	# 
+FEAD ;	0631 ;	MA	# ( ‎ﺭ‎ → ‎ر‎ ) ARABIC LETTER REH ISOLATED FORM → ARABIC LETTER REH	# 
+
+0691 ;	0631 0615 ;	MA	# ( ‎ڑ‎ → ‎رؕ‎ ) ARABIC LETTER RREH → ARABIC LETTER REH, ARABIC SMALL HIGH TAH	# 
+FB8D ;	0631 0615 ;	MA	# ( ‎ﮍ‎ → ‎رؕ‎ ) ARABIC LETTER RREH FINAL FORM → ARABIC LETTER REH, ARABIC SMALL HIGH TAH	# →‎ڑ‎→
+FB8C ;	0631 0615 ;	MA	# ( ‎ﮌ‎ → ‎رؕ‎ ) ARABIC LETTER RREH ISOLATED FORM → ARABIC LETTER REH, ARABIC SMALL HIGH TAH	# →‎ڑ‎→
+
+0698 ;	0631 06DB ;	MA	# ( ‎ژ‎ → ‎رۛ‎ ) ARABIC LETTER JEH → ARABIC LETTER REH, ARABIC SMALL HIGH THREE DOTS	# 
+FB8B ;	0631 06DB ;	MA	# ( ‎ﮋ‎ → ‎رۛ‎ ) ARABIC LETTER JEH FINAL FORM → ARABIC LETTER REH, ARABIC SMALL HIGH THREE DOTS	# →‎ژ‎→
+FB8A ;	0631 06DB ;	MA	# ( ‎ﮊ‎ → ‎رۛ‎ ) ARABIC LETTER JEH ISOLATED FORM → ARABIC LETTER REH, ARABIC SMALL HIGH THREE DOTS	# →‎ژ‎→
+
+0692 ;	0631 0306 ;	MA	# ( ‎ڒ‎ → ‎ر̆‎ ) ARABIC LETTER REH WITH SMALL V → ARABIC LETTER REH, COMBINING BREVE	# →‎رٚ‎→
+
+08B9 ;	0631 0306 0307 ;	MA	# ( ‎ࢹ‎ → ‎ر̆̇‎ ) ARABIC LETTER REH WITH SMALL NOON ABOVE → ARABIC LETTER REH, COMBINING BREVE, COMBINING DOT ABOVE	# →‎رۨ‎→
+
+06EF ;	0631 0302 ;	MA	# ( ‎ۯ‎ → ‎ر̂‎ ) ARABIC LETTER REH WITH INVERTED V → ARABIC LETTER REH, COMBINING CIRCUMFLEX ACCENT	# →‎رٛ‎→
+
+076C ;	0631 0654 ;	MA	# ( ‎ݬ‎ → ‎رٔ‎ ) ARABIC LETTER REH WITH HAMZA ABOVE → ARABIC LETTER REH, ARABIC HAMZA ABOVE	# 
+
+FC5C ;	0631 0670 ;	MA	# ( ‎ﱜ‎ → ‎رٰ‎ ) ARABIC LIGATURE REH WITH SUPERSCRIPT ALEF ISOLATED FORM → ARABIC LETTER REH, ARABIC LETTER SUPERSCRIPT ALEF	# 
+
+FDF6 ;	0631 0633 0648 0644 ;	MA	# ( ‎ﷶ‎ → ‎رسول‎ ) ARABIC LIGATURE RASOUL ISOLATED FORM → ARABIC LETTER REH, ARABIC LETTER SEEN, ARABIC LETTER WAW, ARABIC LETTER LAM	# 
+
+FDFC ;	0631 0649 006C 0644 ;	MA	#* ( ‎﷼‎ → ‎رىlل‎ ) RIAL SIGN → ARABIC LETTER REH, ARABIC LETTER ALEF MAKSURA, LATIN SMALL LETTER L, ARABIC LETTER LAM	# →‎ریال‎→
+20C1 ;	0631 0649 006C 0644 ;	MA	#* ( ⃁ → ‎رىlل‎ ) SAUDI RIYAL SIGN → ARABIC LETTER REH, ARABIC LETTER ALEF MAKSURA, LATIN SMALL LETTER L, ARABIC LETTER LAM	# →‎﷼‎→→‎ریال‎→
+
+1EE06 ;	0632 ;	MA	# ( ‎𞸆‎ → ‎ز‎ ) ARABIC MATHEMATICAL ZAIN → ARABIC LETTER ZAIN	# 
+1EE86 ;	0632 ;	MA	# ( ‎𞺆‎ → ‎ز‎ ) ARABIC MATHEMATICAL LOOPED ZAIN → ARABIC LETTER ZAIN	# 
+1EEA6 ;	0632 ;	MA	# ( ‎𞺦‎ → ‎ز‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK ZAIN → ARABIC LETTER ZAIN	# 
+FEB0 ;	0632 ;	MA	# ( ‎ﺰ‎ → ‎ز‎ ) ARABIC LETTER ZAIN FINAL FORM → ARABIC LETTER ZAIN	# 
+FEAF ;	0632 ;	MA	# ( ‎ﺯ‎ → ‎ز‎ ) ARABIC LETTER ZAIN ISOLATED FORM → ARABIC LETTER ZAIN	# 
+
+08B2 ;	0632 0302 ;	MA	# ( ‎ࢲ‎ → ‎ز̂‎ ) ARABIC LETTER ZAIN WITH INVERTED V ABOVE → ARABIC LETTER ZAIN, COMBINING CIRCUMFLEX ACCENT	# →‎زٛ‎→
+
+0771 ;	0697 0615 ;	MA	# ( ‎ݱ‎ → ‎ڗؕ‎ ) ARABIC LETTER REH WITH SMALL ARABIC LETTER TAH AND TWO DOTS → ARABIC LETTER REH WITH TWO DOTS ABOVE, ARABIC SMALL HIGH TAH	# 
+
+1EE0E ;	0633 ;	MA	# ( ‎𞸎‎ → ‎س‎ ) ARABIC MATHEMATICAL SEEN → ARABIC LETTER SEEN	# 
+1EE2E ;	0633 ;	MA	# ( ‎𞸮‎ → ‎س‎ ) ARABIC MATHEMATICAL INITIAL SEEN → ARABIC LETTER SEEN	# 
+1EE4E ;	0633 ;	MA	# ( ‎𞹎‎ → ‎س‎ ) ARABIC MATHEMATICAL TAILED SEEN → ARABIC LETTER SEEN	# 
+1EE6E ;	0633 ;	MA	# ( ‎𞹮‎ → ‎س‎ ) ARABIC MATHEMATICAL STRETCHED SEEN → ARABIC LETTER SEEN	# 
+1EE8E ;	0633 ;	MA	# ( ‎𞺎‎ → ‎س‎ ) ARABIC MATHEMATICAL LOOPED SEEN → ARABIC LETTER SEEN	# 
+1EEAE ;	0633 ;	MA	# ( ‎𞺮‎ → ‎س‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK SEEN → ARABIC LETTER SEEN	# 
+FEB3 ;	0633 ;	MA	# ( ‎ﺳ‎ → ‎س‎ ) ARABIC LETTER SEEN INITIAL FORM → ARABIC LETTER SEEN	# 
+FEB4 ;	0633 ;	MA	# ( ‎ﺴ‎ → ‎س‎ ) ARABIC LETTER SEEN MEDIAL FORM → ARABIC LETTER SEEN	# 
+FEB2 ;	0633 ;	MA	# ( ‎ﺲ‎ → ‎س‎ ) ARABIC LETTER SEEN FINAL FORM → ARABIC LETTER SEEN	# 
+FEB1 ;	0633 ;	MA	# ( ‎ﺱ‎ → ‎س‎ ) ARABIC LETTER SEEN ISOLATED FORM → ARABIC LETTER SEEN	# 
+
+0634 ;	0633 06DB ;	MA	# ( ‎ش‎ → ‎سۛ‎ ) ARABIC LETTER SHEEN → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# 
+1EE14 ;	0633 06DB ;	MA	# ( ‎𞸔‎ → ‎سۛ‎ ) ARABIC MATHEMATICAL SHEEN → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# →‎ش‎→
+1EE34 ;	0633 06DB ;	MA	# ( ‎𞸴‎ → ‎سۛ‎ ) ARABIC MATHEMATICAL INITIAL SHEEN → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# →‎ش‎→
+1EE54 ;	0633 06DB ;	MA	# ( ‎𞹔‎ → ‎سۛ‎ ) ARABIC MATHEMATICAL TAILED SHEEN → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# →‎ش‎→
+1EE74 ;	0633 06DB ;	MA	# ( ‎𞹴‎ → ‎سۛ‎ ) ARABIC MATHEMATICAL STRETCHED SHEEN → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# →‎ش‎→
+1EE94 ;	0633 06DB ;	MA	# ( ‎𞺔‎ → ‎سۛ‎ ) ARABIC MATHEMATICAL LOOPED SHEEN → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# →‎ش‎→
+1EEB4 ;	0633 06DB ;	MA	# ( ‎𞺴‎ → ‎سۛ‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK SHEEN → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# →‎ش‎→
+FEB7 ;	0633 06DB ;	MA	# ( ‎ﺷ‎ → ‎سۛ‎ ) ARABIC LETTER SHEEN INITIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# →‎ش‎→
+FEB8 ;	0633 06DB ;	MA	# ( ‎ﺸ‎ → ‎سۛ‎ ) ARABIC LETTER SHEEN MEDIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# →‎ش‎→
+FEB6 ;	0633 06DB ;	MA	# ( ‎ﺶ‎ → ‎سۛ‎ ) ARABIC LETTER SHEEN FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# →‎ش‎→
+FEB5 ;	0633 06DB ;	MA	# ( ‎ﺵ‎ → ‎سۛ‎ ) ARABIC LETTER SHEEN ISOLATED FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS	# →‎ش‎→
+
+077E ;	0633 0302 ;	MA	# ( ‎ݾ‎ → ‎س̂‎ ) ARABIC LETTER SEEN WITH INVERTED V → ARABIC LETTER SEEN, COMBINING CIRCUMFLEX ACCENT	# →‎سٛ‎→
+
+FD31 ;	0633 006F ;	MA	# ( ‎ﴱ‎ → ‎سo‎ ) ARABIC LIGATURE SEEN WITH HEH INITIAL FORM → ARABIC LETTER SEEN, LATIN SMALL LETTER O	# →‎سه‎→
+FCE8 ;	0633 006F ;	MA	# ( ‎ﳨ‎ → ‎سo‎ ) ARABIC LIGATURE SEEN WITH HEH MEDIAL FORM → ARABIC LETTER SEEN, LATIN SMALL LETTER O	# →‎سه‎→
+
+FD32 ;	0633 06DB 006F ;	MA	# ( ‎ﴲ‎ → ‎سۛo‎ ) ARABIC LIGATURE SHEEN WITH HEH INITIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, LATIN SMALL LETTER O	# →‎شه‎→
+FCEA ;	0633 06DB 006F ;	MA	# ( ‎ﳪ‎ → ‎سۛo‎ ) ARABIC LIGATURE SHEEN WITH HEH MEDIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, LATIN SMALL LETTER O	# →‎شه‎→
+
+FCAD ;	0633 062C ;	MA	# ( ‎ﲭ‎ → ‎سج‎ ) ARABIC LIGATURE SEEN WITH JEEM INITIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER JEEM	# 
+FD34 ;	0633 062C ;	MA	# ( ‎ﴴ‎ → ‎سج‎ ) ARABIC LIGATURE SEEN WITH JEEM MEDIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER JEEM	# 
+FC1C ;	0633 062C ;	MA	# ( ‎ﰜ‎ → ‎سج‎ ) ARABIC LIGATURE SEEN WITH JEEM ISOLATED FORM → ARABIC LETTER SEEN, ARABIC LETTER JEEM	# 
+
+FD2D ;	0633 06DB 062C ;	MA	# ( ‎ﴭ‎ → ‎سۛج‎ ) ARABIC LIGATURE SHEEN WITH JEEM INITIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER JEEM	# →‎شج‎→
+FD37 ;	0633 06DB 062C ;	MA	# ( ‎ﴷ‎ → ‎سۛج‎ ) ARABIC LIGATURE SHEEN WITH JEEM MEDIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER JEEM	# →‎شج‎→
+FD25 ;	0633 06DB 062C ;	MA	# ( ‎ﴥ‎ → ‎سۛج‎ ) ARABIC LIGATURE SHEEN WITH JEEM FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER JEEM	# →‎شج‎→
+FD09 ;	0633 06DB 062C ;	MA	# ( ‎ﴉ‎ → ‎سۛج‎ ) ARABIC LIGATURE SHEEN WITH JEEM ISOLATED FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER JEEM	# →‎شج‎→
+
+FD5D ;	0633 062C 062D ;	MA	# ( ‎ﵝ‎ → ‎سجح‎ ) ARABIC LIGATURE SEEN WITH JEEM WITH HAH INITIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER JEEM, ARABIC LETTER HAH	# 
+
+FD5E ;	0633 062C 0649 ;	MA	# ( ‎ﵞ‎ → ‎سجى‎ ) ARABIC LIGATURE SEEN WITH JEEM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER SEEN, ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# 
+
+FD69 ;	0633 06DB 062C 0649 ;	MA	# ( ‎ﵩ‎ → ‎سۛجى‎ ) ARABIC LIGATURE SHEEN WITH JEEM WITH YEH FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# →‎شجي‎→
+
+FCAE ;	0633 062D ;	MA	# ( ‎ﲮ‎ → ‎سح‎ ) ARABIC LIGATURE SEEN WITH HAH INITIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER HAH	# 
+FD35 ;	0633 062D ;	MA	# ( ‎ﴵ‎ → ‎سح‎ ) ARABIC LIGATURE SEEN WITH HAH MEDIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER HAH	# 
+FC1D ;	0633 062D ;	MA	# ( ‎ﰝ‎ → ‎سح‎ ) ARABIC LIGATURE SEEN WITH HAH ISOLATED FORM → ARABIC LETTER SEEN, ARABIC LETTER HAH	# 
+
+FD2E ;	0633 06DB 062D ;	MA	# ( ‎ﴮ‎ → ‎سۛح‎ ) ARABIC LIGATURE SHEEN WITH HAH INITIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER HAH	# →‎شح‎→
+FD38 ;	0633 06DB 062D ;	MA	# ( ‎ﴸ‎ → ‎سۛح‎ ) ARABIC LIGATURE SHEEN WITH HAH MEDIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER HAH	# →‎شح‎→
+FD26 ;	0633 06DB 062D ;	MA	# ( ‎ﴦ‎ → ‎سۛح‎ ) ARABIC LIGATURE SHEEN WITH HAH FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER HAH	# →‎شح‎→
+FD0A ;	0633 06DB 062D ;	MA	# ( ‎ﴊ‎ → ‎سۛح‎ ) ARABIC LIGATURE SHEEN WITH HAH ISOLATED FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER HAH	# →‎شح‎→
+
+FD5C ;	0633 062D 062C ;	MA	# ( ‎ﵜ‎ → ‎سحج‎ ) ARABIC LIGATURE SEEN WITH HAH WITH JEEM INITIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER HAH, ARABIC LETTER JEEM	# 
+
+FD68 ;	0633 06DB 062D 0645 ;	MA	# ( ‎ﵨ‎ → ‎سۛحم‎ ) ARABIC LIGATURE SHEEN WITH HAH WITH MEEM INITIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER HAH, ARABIC LETTER MEEM	# →‎شحم‎→
+FD67 ;	0633 06DB 062D 0645 ;	MA	# ( ‎ﵧ‎ → ‎سۛحم‎ ) ARABIC LIGATURE SHEEN WITH HAH WITH MEEM FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER HAH, ARABIC LETTER MEEM	# →‎شحم‎→
+
+FDAA ;	0633 06DB 062D 0649 ;	MA	# ( ‎ﶪ‎ → ‎سۛحى‎ ) ARABIC LIGATURE SHEEN WITH HAH WITH YEH FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎شحي‎→
+
+FCAF ;	0633 062E ;	MA	# ( ‎ﲯ‎ → ‎سخ‎ ) ARABIC LIGATURE SEEN WITH KHAH INITIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER KHAH	# 
+FD36 ;	0633 062E ;	MA	# ( ‎ﴶ‎ → ‎سخ‎ ) ARABIC LIGATURE SEEN WITH KHAH MEDIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER KHAH	# 
+FC1E ;	0633 062E ;	MA	# ( ‎ﰞ‎ → ‎سخ‎ ) ARABIC LIGATURE SEEN WITH KHAH ISOLATED FORM → ARABIC LETTER SEEN, ARABIC LETTER KHAH	# 
+
+FD2F ;	0633 06DB 062E ;	MA	# ( ‎ﴯ‎ → ‎سۛخ‎ ) ARABIC LIGATURE SHEEN WITH KHAH INITIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER KHAH	# →‎شخ‎→
+FD39 ;	0633 06DB 062E ;	MA	# ( ‎ﴹ‎ → ‎سۛخ‎ ) ARABIC LIGATURE SHEEN WITH KHAH MEDIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER KHAH	# →‎شخ‎→
+FD27 ;	0633 06DB 062E ;	MA	# ( ‎ﴧ‎ → ‎سۛخ‎ ) ARABIC LIGATURE SHEEN WITH KHAH FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER KHAH	# →‎شخ‎→
+FD0B ;	0633 06DB 062E ;	MA	# ( ‎ﴋ‎ → ‎سۛخ‎ ) ARABIC LIGATURE SHEEN WITH KHAH ISOLATED FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER KHAH	# →‎شخ‎→
+
+FDA8 ;	0633 062E 0649 ;	MA	# ( ‎ﶨ‎ → ‎سخى‎ ) ARABIC LIGATURE SEEN WITH KHAH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER SEEN, ARABIC LETTER KHAH, ARABIC LETTER ALEF MAKSURA	# 
+FDC6 ;	0633 062E 0649 ;	MA	# ( ‎ﷆ‎ → ‎سخى‎ ) ARABIC LIGATURE SEEN WITH KHAH WITH YEH FINAL FORM → ARABIC LETTER SEEN, ARABIC LETTER KHAH, ARABIC LETTER ALEF MAKSURA	# →‎سخي‎→
+
+FD2A ;	0633 0631 ;	MA	# ( ‎ﴪ‎ → ‎سر‎ ) ARABIC LIGATURE SEEN WITH REH FINAL FORM → ARABIC LETTER SEEN, ARABIC LETTER REH	# 
+FD0E ;	0633 0631 ;	MA	# ( ‎ﴎ‎ → ‎سر‎ ) ARABIC LIGATURE SEEN WITH REH ISOLATED FORM → ARABIC LETTER SEEN, ARABIC LETTER REH	# 
+
+FD29 ;	0633 06DB 0631 ;	MA	# ( ‎ﴩ‎ → ‎سۛر‎ ) ARABIC LIGATURE SHEEN WITH REH FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER REH	# →‎شر‎→
+FD0D ;	0633 06DB 0631 ;	MA	# ( ‎ﴍ‎ → ‎سۛر‎ ) ARABIC LIGATURE SHEEN WITH REH ISOLATED FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER REH	# →‎شر‎→
+
+FCB0 ;	0633 0645 ;	MA	# ( ‎ﲰ‎ → ‎سم‎ ) ARABIC LIGATURE SEEN WITH MEEM INITIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER MEEM	# 
+FCE7 ;	0633 0645 ;	MA	# ( ‎ﳧ‎ → ‎سم‎ ) ARABIC LIGATURE SEEN WITH MEEM MEDIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER MEEM	# 
+FC1F ;	0633 0645 ;	MA	# ( ‎ﰟ‎ → ‎سم‎ ) ARABIC LIGATURE SEEN WITH MEEM ISOLATED FORM → ARABIC LETTER SEEN, ARABIC LETTER MEEM	# 
+
+FD30 ;	0633 06DB 0645 ;	MA	# ( ‎ﴰ‎ → ‎سۛم‎ ) ARABIC LIGATURE SHEEN WITH MEEM INITIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM	# →‎شم‎→
+FCE9 ;	0633 06DB 0645 ;	MA	# ( ‎ﳩ‎ → ‎سۛم‎ ) ARABIC LIGATURE SHEEN WITH MEEM MEDIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM	# →‎شم‎→
+FD28 ;	0633 06DB 0645 ;	MA	# ( ‎ﴨ‎ → ‎سۛم‎ ) ARABIC LIGATURE SHEEN WITH MEEM FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM	# →‎شم‎→
+FD0C ;	0633 06DB 0645 ;	MA	# ( ‎ﴌ‎ → ‎سۛم‎ ) ARABIC LIGATURE SHEEN WITH MEEM ISOLATED FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM	# →‎شم‎→
+
+FD61 ;	0633 0645 062C ;	MA	# ( ‎ﵡ‎ → ‎سمج‎ ) ARABIC LIGATURE SEEN WITH MEEM WITH JEEM INITIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER MEEM, ARABIC LETTER JEEM	# 
+
+FD60 ;	0633 0645 062D ;	MA	# ( ‎ﵠ‎ → ‎سمح‎ ) ARABIC LIGATURE SEEN WITH MEEM WITH HAH INITIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+FD5F ;	0633 0645 062D ;	MA	# ( ‎ﵟ‎ → ‎سمح‎ ) ARABIC LIGATURE SEEN WITH MEEM WITH HAH FINAL FORM → ARABIC LETTER SEEN, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+
+FD6B ;	0633 06DB 0645 062E ;	MA	# ( ‎ﵫ‎ → ‎سۛمخ‎ ) ARABIC LIGATURE SHEEN WITH MEEM WITH KHAH INITIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM, ARABIC LETTER KHAH	# →‎شمخ‎→
+FD6A ;	0633 06DB 0645 062E ;	MA	# ( ‎ﵪ‎ → ‎سۛمخ‎ ) ARABIC LIGATURE SHEEN WITH MEEM WITH KHAH FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM, ARABIC LETTER KHAH	# →‎شمخ‎→
+
+FD63 ;	0633 0645 0645 ;	MA	# ( ‎ﵣ‎ → ‎سمم‎ ) ARABIC LIGATURE SEEN WITH MEEM WITH MEEM INITIAL FORM → ARABIC LETTER SEEN, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+FD62 ;	0633 0645 0645 ;	MA	# ( ‎ﵢ‎ → ‎سمم‎ ) ARABIC LIGATURE SEEN WITH MEEM WITH MEEM FINAL FORM → ARABIC LETTER SEEN, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+
+FD6D ;	0633 06DB 0645 0645 ;	MA	# ( ‎ﵭ‎ → ‎سۛمم‎ ) ARABIC LIGATURE SHEEN WITH MEEM WITH MEEM INITIAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# →‎شمم‎→
+FD6C ;	0633 06DB 0645 0645 ;	MA	# ( ‎ﵬ‎ → ‎سۛمم‎ ) ARABIC LIGATURE SHEEN WITH MEEM WITH MEEM FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# →‎شمم‎→
+
+FD17 ;	0633 0649 ;	MA	# ( ‎ﴗ‎ → ‎سى‎ ) ARABIC LIGATURE SEEN WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER SEEN, ARABIC LETTER ALEF MAKSURA	# 
+FCFB ;	0633 0649 ;	MA	# ( ‎ﳻ‎ → ‎سى‎ ) ARABIC LIGATURE SEEN WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER SEEN, ARABIC LETTER ALEF MAKSURA	# 
+FD18 ;	0633 0649 ;	MA	# ( ‎ﴘ‎ → ‎سى‎ ) ARABIC LIGATURE SEEN WITH YEH FINAL FORM → ARABIC LETTER SEEN, ARABIC LETTER ALEF MAKSURA	# →‎سي‎→
+FCFC ;	0633 0649 ;	MA	# ( ‎ﳼ‎ → ‎سى‎ ) ARABIC LIGATURE SEEN WITH YEH ISOLATED FORM → ARABIC LETTER SEEN, ARABIC LETTER ALEF MAKSURA	# →‎سي‎→
+
+FD19 ;	0633 06DB 0649 ;	MA	# ( ‎ﴙ‎ → ‎سۛى‎ ) ARABIC LIGATURE SHEEN WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER ALEF MAKSURA	# →‎شى‎→
+FCFD ;	0633 06DB 0649 ;	MA	# ( ‎ﳽ‎ → ‎سۛى‎ ) ARABIC LIGATURE SHEEN WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER ALEF MAKSURA	# →‎شى‎→
+FD1A ;	0633 06DB 0649 ;	MA	# ( ‎ﴚ‎ → ‎سۛى‎ ) ARABIC LIGATURE SHEEN WITH YEH FINAL FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER ALEF MAKSURA	# →‎شي‎→
+FCFE ;	0633 06DB 0649 ;	MA	# ( ‎ﳾ‎ → ‎سۛى‎ ) ARABIC LIGATURE SHEEN WITH YEH ISOLATED FORM → ARABIC LETTER SEEN, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER ALEF MAKSURA	# →‎شي‎→
+
+102F2 ;	0635 ;	MA	#* ( 𐋲 → ‎ص‎ ) COPTIC EPACT NUMBER NINETY → ARABIC LETTER SAD	# 
+1EE11 ;	0635 ;	MA	# ( ‎𞸑‎ → ‎ص‎ ) ARABIC MATHEMATICAL SAD → ARABIC LETTER SAD	# 
+1EE31 ;	0635 ;	MA	# ( ‎𞸱‎ → ‎ص‎ ) ARABIC MATHEMATICAL INITIAL SAD → ARABIC LETTER SAD	# 
+1EE51 ;	0635 ;	MA	# ( ‎𞹑‎ → ‎ص‎ ) ARABIC MATHEMATICAL TAILED SAD → ARABIC LETTER SAD	# 
+1EE71 ;	0635 ;	MA	# ( ‎𞹱‎ → ‎ص‎ ) ARABIC MATHEMATICAL STRETCHED SAD → ARABIC LETTER SAD	# 
+1EE91 ;	0635 ;	MA	# ( ‎𞺑‎ → ‎ص‎ ) ARABIC MATHEMATICAL LOOPED SAD → ARABIC LETTER SAD	# 
+1EEB1 ;	0635 ;	MA	# ( ‎𞺱‎ → ‎ص‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK SAD → ARABIC LETTER SAD	# 
+FEBB ;	0635 ;	MA	# ( ‎ﺻ‎ → ‎ص‎ ) ARABIC LETTER SAD INITIAL FORM → ARABIC LETTER SAD	# 
+FEBC ;	0635 ;	MA	# ( ‎ﺼ‎ → ‎ص‎ ) ARABIC LETTER SAD MEDIAL FORM → ARABIC LETTER SAD	# 
+FEBA ;	0635 ;	MA	# ( ‎ﺺ‎ → ‎ص‎ ) ARABIC LETTER SAD FINAL FORM → ARABIC LETTER SAD	# 
+FEB9 ;	0635 ;	MA	# ( ‎ﺹ‎ → ‎ص‎ ) ARABIC LETTER SAD ISOLATED FORM → ARABIC LETTER SAD	# 
+
+069E ;	0635 06DB ;	MA	# ( ‎ڞ‎ → ‎صۛ‎ ) ARABIC LETTER SAD WITH THREE DOTS ABOVE → ARABIC LETTER SAD, ARABIC SMALL HIGH THREE DOTS	# 
+
+08AF ;	0635 0324 0323 ;	MA	# ( ‎ࢯ‎ → ‎ص̤̣‎ ) ARABIC LETTER SAD WITH THREE DOTS BELOW → ARABIC LETTER SAD, COMBINING DIAERESIS BELOW, COMBINING DOT BELOW	# →‎ص࣮࣭‎→
+
+FCB1 ;	0635 062D ;	MA	# ( ‎ﲱ‎ → ‎صح‎ ) ARABIC LIGATURE SAD WITH HAH INITIAL FORM → ARABIC LETTER SAD, ARABIC LETTER HAH	# 
+FC20 ;	0635 062D ;	MA	# ( ‎ﰠ‎ → ‎صح‎ ) ARABIC LIGATURE SAD WITH HAH ISOLATED FORM → ARABIC LETTER SAD, ARABIC LETTER HAH	# 
+
+FD65 ;	0635 062D 062D ;	MA	# ( ‎ﵥ‎ → ‎صحح‎ ) ARABIC LIGATURE SAD WITH HAH WITH HAH INITIAL FORM → ARABIC LETTER SAD, ARABIC LETTER HAH, ARABIC LETTER HAH	# 
+FD64 ;	0635 062D 062D ;	MA	# ( ‎ﵤ‎ → ‎صحح‎ ) ARABIC LIGATURE SAD WITH HAH WITH HAH FINAL FORM → ARABIC LETTER SAD, ARABIC LETTER HAH, ARABIC LETTER HAH	# 
+
+FDA9 ;	0635 062D 0649 ;	MA	# ( ‎ﶩ‎ → ‎صحى‎ ) ARABIC LIGATURE SAD WITH HAH WITH YEH FINAL FORM → ARABIC LETTER SAD, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎صحي‎→
+
+FCB2 ;	0635 062E ;	MA	# ( ‎ﲲ‎ → ‎صخ‎ ) ARABIC LIGATURE SAD WITH KHAH INITIAL FORM → ARABIC LETTER SAD, ARABIC LETTER KHAH	# 
+
+FD2B ;	0635 0631 ;	MA	# ( ‎ﴫ‎ → ‎صر‎ ) ARABIC LIGATURE SAD WITH REH FINAL FORM → ARABIC LETTER SAD, ARABIC LETTER REH	# 
+FD0F ;	0635 0631 ;	MA	# ( ‎ﴏ‎ → ‎صر‎ ) ARABIC LIGATURE SAD WITH REH ISOLATED FORM → ARABIC LETTER SAD, ARABIC LETTER REH	# 
+
+FDF5 ;	0635 0644 0639 0645 ;	MA	# ( ‎ﷵ‎ → ‎صلعم‎ ) ARABIC LIGATURE SALAM ISOLATED FORM → ARABIC LETTER SAD, ARABIC LETTER LAM, ARABIC LETTER AIN, ARABIC LETTER MEEM	# 
+
+FDF9 ;	0635 0644 0649 ;	MA	# ( ‎ﷹ‎ → ‎صلى‎ ) ARABIC LIGATURE SALLA ISOLATED FORM → ARABIC LETTER SAD, ARABIC LETTER LAM, ARABIC LETTER ALEF MAKSURA	# 
+FDF0 ;	0635 0644 0649 ;	MA	# ( ‎ﷰ‎ → ‎صلى‎ ) ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM → ARABIC LETTER SAD, ARABIC LETTER LAM, ARABIC LETTER ALEF MAKSURA	# →‎صلے‎→
+
+FDFA ;	0635 0644 0649 0020 006C 0644 0644 006F 0020 0639 0644 0649 006F 0020 0648 0633 0644 0645 ;	MA	#* ( ‎ﷺ‎ → ‎صلى lللo علىo وسلم‎ ) ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM → ARABIC LETTER SAD, ARABIC LETTER LAM, ARABIC LETTER ALEF MAKSURA, SPACE, LATIN SMALL LETTER L, ARABIC LETTER LAM, ARABIC LETTER LAM, LATIN SMALL LETTER O, SPACE, ARABIC LETTER AIN, ARABIC LETTER LAM, ARABIC LETTER ALEF MAKSURA, LATIN SMALL LETTER O, SPACE, ARABIC LETTER WAW, ARABIC LETTER SEEN, ARABIC LETTER LAM, ARABIC LETTER MEEM	# →‎صلى الله عليه وسلم‎→
+
+FCB3 ;	0635 0645 ;	MA	# ( ‎ﲳ‎ → ‎صم‎ ) ARABIC LIGATURE SAD WITH MEEM INITIAL FORM → ARABIC LETTER SAD, ARABIC LETTER MEEM	# 
+FC21 ;	0635 0645 ;	MA	# ( ‎ﰡ‎ → ‎صم‎ ) ARABIC LIGATURE SAD WITH MEEM ISOLATED FORM → ARABIC LETTER SAD, ARABIC LETTER MEEM	# 
+
+FDC5 ;	0635 0645 0645 ;	MA	# ( ‎ﷅ‎ → ‎صمم‎ ) ARABIC LIGATURE SAD WITH MEEM WITH MEEM INITIAL FORM → ARABIC LETTER SAD, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+FD66 ;	0635 0645 0645 ;	MA	# ( ‎ﵦ‎ → ‎صمم‎ ) ARABIC LIGATURE SAD WITH MEEM WITH MEEM FINAL FORM → ARABIC LETTER SAD, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+
+FD21 ;	0635 0649 ;	MA	# ( ‎ﴡ‎ → ‎صى‎ ) ARABIC LIGATURE SAD WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER SAD, ARABIC LETTER ALEF MAKSURA	# 
+FD05 ;	0635 0649 ;	MA	# ( ‎ﴅ‎ → ‎صى‎ ) ARABIC LIGATURE SAD WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER SAD, ARABIC LETTER ALEF MAKSURA	# 
+FD22 ;	0635 0649 ;	MA	# ( ‎ﴢ‎ → ‎صى‎ ) ARABIC LIGATURE SAD WITH YEH FINAL FORM → ARABIC LETTER SAD, ARABIC LETTER ALEF MAKSURA	# →‎صي‎→
+FD06 ;	0635 0649 ;	MA	# ( ‎ﴆ‎ → ‎صى‎ ) ARABIC LIGATURE SAD WITH YEH ISOLATED FORM → ARABIC LETTER SAD, ARABIC LETTER ALEF MAKSURA	# →‎صي‎→
+
+1EE19 ;	0636 ;	MA	# ( ‎𞸙‎ → ‎ض‎ ) ARABIC MATHEMATICAL DAD → ARABIC LETTER DAD	# 
+1EE39 ;	0636 ;	MA	# ( ‎𞸹‎ → ‎ض‎ ) ARABIC MATHEMATICAL INITIAL DAD → ARABIC LETTER DAD	# 
+1EE59 ;	0636 ;	MA	# ( ‎𞹙‎ → ‎ض‎ ) ARABIC MATHEMATICAL TAILED DAD → ARABIC LETTER DAD	# 
+1EE79 ;	0636 ;	MA	# ( ‎𞹹‎ → ‎ض‎ ) ARABIC MATHEMATICAL STRETCHED DAD → ARABIC LETTER DAD	# 
+1EE99 ;	0636 ;	MA	# ( ‎𞺙‎ → ‎ض‎ ) ARABIC MATHEMATICAL LOOPED DAD → ARABIC LETTER DAD	# 
+1EEB9 ;	0636 ;	MA	# ( ‎𞺹‎ → ‎ض‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK DAD → ARABIC LETTER DAD	# 
+FEBF ;	0636 ;	MA	# ( ‎ﺿ‎ → ‎ض‎ ) ARABIC LETTER DAD INITIAL FORM → ARABIC LETTER DAD	# 
+FEC0 ;	0636 ;	MA	# ( ‎ﻀ‎ → ‎ض‎ ) ARABIC LETTER DAD MEDIAL FORM → ARABIC LETTER DAD	# 
+FEBE ;	0636 ;	MA	# ( ‎ﺾ‎ → ‎ض‎ ) ARABIC LETTER DAD FINAL FORM → ARABIC LETTER DAD	# 
+FEBD ;	0636 ;	MA	# ( ‎ﺽ‎ → ‎ض‎ ) ARABIC LETTER DAD ISOLATED FORM → ARABIC LETTER DAD	# 
+
+FCB4 ;	0636 062C ;	MA	# ( ‎ﲴ‎ → ‎ضج‎ ) ARABIC LIGATURE DAD WITH JEEM INITIAL FORM → ARABIC LETTER DAD, ARABIC LETTER JEEM	# 
+FC22 ;	0636 062C ;	MA	# ( ‎ﰢ‎ → ‎ضج‎ ) ARABIC LIGATURE DAD WITH JEEM ISOLATED FORM → ARABIC LETTER DAD, ARABIC LETTER JEEM	# 
+
+FCB5 ;	0636 062D ;	MA	# ( ‎ﲵ‎ → ‎ضح‎ ) ARABIC LIGATURE DAD WITH HAH INITIAL FORM → ARABIC LETTER DAD, ARABIC LETTER HAH	# 
+FC23 ;	0636 062D ;	MA	# ( ‎ﰣ‎ → ‎ضح‎ ) ARABIC LIGATURE DAD WITH HAH ISOLATED FORM → ARABIC LETTER DAD, ARABIC LETTER HAH	# 
+
+FD6E ;	0636 062D 0649 ;	MA	# ( ‎ﵮ‎ → ‎ضحى‎ ) ARABIC LIGATURE DAD WITH HAH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER DAD, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# 
+FDAB ;	0636 062D 0649 ;	MA	# ( ‎ﶫ‎ → ‎ضحى‎ ) ARABIC LIGATURE DAD WITH HAH WITH YEH FINAL FORM → ARABIC LETTER DAD, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎ضحي‎→
+
+FCB6 ;	0636 062E ;	MA	# ( ‎ﲶ‎ → ‎ضخ‎ ) ARABIC LIGATURE DAD WITH KHAH INITIAL FORM → ARABIC LETTER DAD, ARABIC LETTER KHAH	# 
+FC24 ;	0636 062E ;	MA	# ( ‎ﰤ‎ → ‎ضخ‎ ) ARABIC LIGATURE DAD WITH KHAH ISOLATED FORM → ARABIC LETTER DAD, ARABIC LETTER KHAH	# 
+
+FD70 ;	0636 062E 0645 ;	MA	# ( ‎ﵰ‎ → ‎ضخم‎ ) ARABIC LIGATURE DAD WITH KHAH WITH MEEM INITIAL FORM → ARABIC LETTER DAD, ARABIC LETTER KHAH, ARABIC LETTER MEEM	# 
+FD6F ;	0636 062E 0645 ;	MA	# ( ‎ﵯ‎ → ‎ضخم‎ ) ARABIC LIGATURE DAD WITH KHAH WITH MEEM FINAL FORM → ARABIC LETTER DAD, ARABIC LETTER KHAH, ARABIC LETTER MEEM	# 
+
+FD2C ;	0636 0631 ;	MA	# ( ‎ﴬ‎ → ‎ضر‎ ) ARABIC LIGATURE DAD WITH REH FINAL FORM → ARABIC LETTER DAD, ARABIC LETTER REH	# 
+FD10 ;	0636 0631 ;	MA	# ( ‎ﴐ‎ → ‎ضر‎ ) ARABIC LIGATURE DAD WITH REH ISOLATED FORM → ARABIC LETTER DAD, ARABIC LETTER REH	# 
+
+FCB7 ;	0636 0645 ;	MA	# ( ‎ﲷ‎ → ‎ضم‎ ) ARABIC LIGATURE DAD WITH MEEM INITIAL FORM → ARABIC LETTER DAD, ARABIC LETTER MEEM	# 
+FC25 ;	0636 0645 ;	MA	# ( ‎ﰥ‎ → ‎ضم‎ ) ARABIC LIGATURE DAD WITH MEEM ISOLATED FORM → ARABIC LETTER DAD, ARABIC LETTER MEEM	# 
+
+FD23 ;	0636 0649 ;	MA	# ( ‎ﴣ‎ → ‎ضى‎ ) ARABIC LIGATURE DAD WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER DAD, ARABIC LETTER ALEF MAKSURA	# 
+FD07 ;	0636 0649 ;	MA	# ( ‎ﴇ‎ → ‎ضى‎ ) ARABIC LIGATURE DAD WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER DAD, ARABIC LETTER ALEF MAKSURA	# 
+FD24 ;	0636 0649 ;	MA	# ( ‎ﴤ‎ → ‎ضى‎ ) ARABIC LIGATURE DAD WITH YEH FINAL FORM → ARABIC LETTER DAD, ARABIC LETTER ALEF MAKSURA	# →‎ضي‎→
+FD08 ;	0636 0649 ;	MA	# ( ‎ﴈ‎ → ‎ضى‎ ) ARABIC LIGATURE DAD WITH YEH ISOLATED FORM → ARABIC LETTER DAD, ARABIC LETTER ALEF MAKSURA	# →‎ضي‎→
+
+102E8 ;	0637 ;	MA	#* ( 𐋨 → ‎ط‎ ) COPTIC EPACT DIGIT EIGHT → ARABIC LETTER TAH	# 
+1EE08 ;	0637 ;	MA	# ( ‎𞸈‎ → ‎ط‎ ) ARABIC MATHEMATICAL TAH → ARABIC LETTER TAH	# 
+1EE68 ;	0637 ;	MA	# ( ‎𞹨‎ → ‎ط‎ ) ARABIC MATHEMATICAL STRETCHED TAH → ARABIC LETTER TAH	# 
+1EE88 ;	0637 ;	MA	# ( ‎𞺈‎ → ‎ط‎ ) ARABIC MATHEMATICAL LOOPED TAH → ARABIC LETTER TAH	# 
+1EEA8 ;	0637 ;	MA	# ( ‎𞺨‎ → ‎ط‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK TAH → ARABIC LETTER TAH	# 
+FEC3 ;	0637 ;	MA	# ( ‎ﻃ‎ → ‎ط‎ ) ARABIC LETTER TAH INITIAL FORM → ARABIC LETTER TAH	# 
+FEC4 ;	0637 ;	MA	# ( ‎ﻄ‎ → ‎ط‎ ) ARABIC LETTER TAH MEDIAL FORM → ARABIC LETTER TAH	# 
+FEC2 ;	0637 ;	MA	# ( ‎ﻂ‎ → ‎ط‎ ) ARABIC LETTER TAH FINAL FORM → ARABIC LETTER TAH	# 
+FEC1 ;	0637 ;	MA	# ( ‎ﻁ‎ → ‎ط‎ ) ARABIC LETTER TAH ISOLATED FORM → ARABIC LETTER TAH	# 
+
+069F ;	0637 06DB ;	MA	# ( ‎ڟ‎ → ‎طۛ‎ ) ARABIC LETTER TAH WITH THREE DOTS ABOVE → ARABIC LETTER TAH, ARABIC SMALL HIGH THREE DOTS	# 
+
+FCB8 ;	0637 062D ;	MA	# ( ‎ﲸ‎ → ‎طح‎ ) ARABIC LIGATURE TAH WITH HAH INITIAL FORM → ARABIC LETTER TAH, ARABIC LETTER HAH	# 
+FC26 ;	0637 062D ;	MA	# ( ‎ﰦ‎ → ‎طح‎ ) ARABIC LIGATURE TAH WITH HAH ISOLATED FORM → ARABIC LETTER TAH, ARABIC LETTER HAH	# 
+
+FD33 ;	0637 0645 ;	MA	# ( ‎ﴳ‎ → ‎طم‎ ) ARABIC LIGATURE TAH WITH MEEM INITIAL FORM → ARABIC LETTER TAH, ARABIC LETTER MEEM	# 
+FD3A ;	0637 0645 ;	MA	# ( ‎ﴺ‎ → ‎طم‎ ) ARABIC LIGATURE TAH WITH MEEM MEDIAL FORM → ARABIC LETTER TAH, ARABIC LETTER MEEM	# 
+FC27 ;	0637 0645 ;	MA	# ( ‎ﰧ‎ → ‎طم‎ ) ARABIC LIGATURE TAH WITH MEEM ISOLATED FORM → ARABIC LETTER TAH, ARABIC LETTER MEEM	# 
+
+FD72 ;	0637 0645 062D ;	MA	# ( ‎ﵲ‎ → ‎طمح‎ ) ARABIC LIGATURE TAH WITH MEEM WITH HAH INITIAL FORM → ARABIC LETTER TAH, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+FD71 ;	0637 0645 062D ;	MA	# ( ‎ﵱ‎ → ‎طمح‎ ) ARABIC LIGATURE TAH WITH MEEM WITH HAH FINAL FORM → ARABIC LETTER TAH, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+
+FD73 ;	0637 0645 0645 ;	MA	# ( ‎ﵳ‎ → ‎طمم‎ ) ARABIC LIGATURE TAH WITH MEEM WITH MEEM INITIAL FORM → ARABIC LETTER TAH, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+
+FD74 ;	0637 0645 0649 ;	MA	# ( ‎ﵴ‎ → ‎طمى‎ ) ARABIC LIGATURE TAH WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER TAH, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎طمي‎→
+
+FD11 ;	0637 0649 ;	MA	# ( ‎ﴑ‎ → ‎طى‎ ) ARABIC LIGATURE TAH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER TAH, ARABIC LETTER ALEF MAKSURA	# 
+FCF5 ;	0637 0649 ;	MA	# ( ‎ﳵ‎ → ‎طى‎ ) ARABIC LIGATURE TAH WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER TAH, ARABIC LETTER ALEF MAKSURA	# 
+FD12 ;	0637 0649 ;	MA	# ( ‎ﴒ‎ → ‎طى‎ ) ARABIC LIGATURE TAH WITH YEH FINAL FORM → ARABIC LETTER TAH, ARABIC LETTER ALEF MAKSURA	# →‎طي‎→
+FCF6 ;	0637 0649 ;	MA	# ( ‎ﳶ‎ → ‎طى‎ ) ARABIC LIGATURE TAH WITH YEH ISOLATED FORM → ARABIC LETTER TAH, ARABIC LETTER ALEF MAKSURA	# →‎طي‎→
+
+1EE1A ;	0638 ;	MA	# ( ‎𞸚‎ → ‎ظ‎ ) ARABIC MATHEMATICAL ZAH → ARABIC LETTER ZAH	# 
+1EE7A ;	0638 ;	MA	# ( ‎𞹺‎ → ‎ظ‎ ) ARABIC MATHEMATICAL STRETCHED ZAH → ARABIC LETTER ZAH	# 
+1EE9A ;	0638 ;	MA	# ( ‎𞺚‎ → ‎ظ‎ ) ARABIC MATHEMATICAL LOOPED ZAH → ARABIC LETTER ZAH	# 
+1EEBA ;	0638 ;	MA	# ( ‎𞺺‎ → ‎ظ‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK ZAH → ARABIC LETTER ZAH	# 
+FEC7 ;	0638 ;	MA	# ( ‎ﻇ‎ → ‎ظ‎ ) ARABIC LETTER ZAH INITIAL FORM → ARABIC LETTER ZAH	# 
+FEC8 ;	0638 ;	MA	# ( ‎ﻈ‎ → ‎ظ‎ ) ARABIC LETTER ZAH MEDIAL FORM → ARABIC LETTER ZAH	# 
+FEC6 ;	0638 ;	MA	# ( ‎ﻆ‎ → ‎ظ‎ ) ARABIC LETTER ZAH FINAL FORM → ARABIC LETTER ZAH	# 
+FEC5 ;	0638 ;	MA	# ( ‎ﻅ‎ → ‎ظ‎ ) ARABIC LETTER ZAH ISOLATED FORM → ARABIC LETTER ZAH	# 
+
+FCB9 ;	0638 0645 ;	MA	# ( ‎ﲹ‎ → ‎ظم‎ ) ARABIC LIGATURE ZAH WITH MEEM INITIAL FORM → ARABIC LETTER ZAH, ARABIC LETTER MEEM	# 
+FD3B ;	0638 0645 ;	MA	# ( ‎ﴻ‎ → ‎ظم‎ ) ARABIC LIGATURE ZAH WITH MEEM MEDIAL FORM → ARABIC LETTER ZAH, ARABIC LETTER MEEM	# 
+FC28 ;	0638 0645 ;	MA	# ( ‎ﰨ‎ → ‎ظم‎ ) ARABIC LIGATURE ZAH WITH MEEM ISOLATED FORM → ARABIC LETTER ZAH, ARABIC LETTER MEEM	# 
+
+060F ;	0639 ;	MA	#* ( ؏ → ‎ع‎ ) ARABIC SIGN MISRA → ARABIC LETTER AIN	# 
+1EE0F ;	0639 ;	MA	# ( ‎𞸏‎ → ‎ع‎ ) ARABIC MATHEMATICAL AIN → ARABIC LETTER AIN	# 
+1EE2F ;	0639 ;	MA	# ( ‎𞸯‎ → ‎ع‎ ) ARABIC MATHEMATICAL INITIAL AIN → ARABIC LETTER AIN	# 
+1EE4F ;	0639 ;	MA	# ( ‎𞹏‎ → ‎ع‎ ) ARABIC MATHEMATICAL TAILED AIN → ARABIC LETTER AIN	# 
+1EE6F ;	0639 ;	MA	# ( ‎𞹯‎ → ‎ع‎ ) ARABIC MATHEMATICAL STRETCHED AIN → ARABIC LETTER AIN	# 
+1EE8F ;	0639 ;	MA	# ( ‎𞺏‎ → ‎ع‎ ) ARABIC MATHEMATICAL LOOPED AIN → ARABIC LETTER AIN	# 
+1EEAF ;	0639 ;	MA	# ( ‎𞺯‎ → ‎ع‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK AIN → ARABIC LETTER AIN	# 
+FECB ;	0639 ;	MA	# ( ‎ﻋ‎ → ‎ع‎ ) ARABIC LETTER AIN INITIAL FORM → ARABIC LETTER AIN	# 
+FECC ;	0639 ;	MA	# ( ‎ﻌ‎ → ‎ع‎ ) ARABIC LETTER AIN MEDIAL FORM → ARABIC LETTER AIN	# 
+FECA ;	0639 ;	MA	# ( ‎ﻊ‎ → ‎ع‎ ) ARABIC LETTER AIN FINAL FORM → ARABIC LETTER AIN	# 
+FEC9 ;	0639 ;	MA	# ( ‎ﻉ‎ → ‎ع‎ ) ARABIC LETTER AIN ISOLATED FORM → ARABIC LETTER AIN	# 
+
+FCBA ;	0639 062C ;	MA	# ( ‎ﲺ‎ → ‎عج‎ ) ARABIC LIGATURE AIN WITH JEEM INITIAL FORM → ARABIC LETTER AIN, ARABIC LETTER JEEM	# 
+FC29 ;	0639 062C ;	MA	# ( ‎ﰩ‎ → ‎عج‎ ) ARABIC LIGATURE AIN WITH JEEM ISOLATED FORM → ARABIC LETTER AIN, ARABIC LETTER JEEM	# 
+
+FDC4 ;	0639 062C 0645 ;	MA	# ( ‎ﷄ‎ → ‎عجم‎ ) ARABIC LIGATURE AIN WITH JEEM WITH MEEM INITIAL FORM → ARABIC LETTER AIN, ARABIC LETTER JEEM, ARABIC LETTER MEEM	# 
+FD75 ;	0639 062C 0645 ;	MA	# ( ‎ﵵ‎ → ‎عجم‎ ) ARABIC LIGATURE AIN WITH JEEM WITH MEEM FINAL FORM → ARABIC LETTER AIN, ARABIC LETTER JEEM, ARABIC LETTER MEEM	# 
+
+FDF7 ;	0639 0644 0649 006F ;	MA	# ( ‎ﷷ‎ → ‎علىo‎ ) ARABIC LIGATURE ALAYHE ISOLATED FORM → ARABIC LETTER AIN, ARABIC LETTER LAM, ARABIC LETTER ALEF MAKSURA, LATIN SMALL LETTER O	# →‎عليه‎→
+
+FCBB ;	0639 0645 ;	MA	# ( ‎ﲻ‎ → ‎عم‎ ) ARABIC LIGATURE AIN WITH MEEM INITIAL FORM → ARABIC LETTER AIN, ARABIC LETTER MEEM	# 
+FC2A ;	0639 0645 ;	MA	# ( ‎ﰪ‎ → ‎عم‎ ) ARABIC LIGATURE AIN WITH MEEM ISOLATED FORM → ARABIC LETTER AIN, ARABIC LETTER MEEM	# 
+
+FD77 ;	0639 0645 0645 ;	MA	# ( ‎ﵷ‎ → ‎عمم‎ ) ARABIC LIGATURE AIN WITH MEEM WITH MEEM INITIAL FORM → ARABIC LETTER AIN, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+FD76 ;	0639 0645 0645 ;	MA	# ( ‎ﵶ‎ → ‎عمم‎ ) ARABIC LIGATURE AIN WITH MEEM WITH MEEM FINAL FORM → ARABIC LETTER AIN, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+
+FD78 ;	0639 0645 0649 ;	MA	# ( ‎ﵸ‎ → ‎عمى‎ ) ARABIC LIGATURE AIN WITH MEEM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER AIN, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# 
+FDB6 ;	0639 0645 0649 ;	MA	# ( ‎ﶶ‎ → ‎عمى‎ ) ARABIC LIGATURE AIN WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER AIN, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎عمي‎→
+
+FD13 ;	0639 0649 ;	MA	# ( ‎ﴓ‎ → ‎عى‎ ) ARABIC LIGATURE AIN WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER AIN, ARABIC LETTER ALEF MAKSURA	# 
+FCF7 ;	0639 0649 ;	MA	# ( ‎ﳷ‎ → ‎عى‎ ) ARABIC LIGATURE AIN WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER AIN, ARABIC LETTER ALEF MAKSURA	# 
+FD14 ;	0639 0649 ;	MA	# ( ‎ﴔ‎ → ‎عى‎ ) ARABIC LIGATURE AIN WITH YEH FINAL FORM → ARABIC LETTER AIN, ARABIC LETTER ALEF MAKSURA	# →‎عي‎→
+FCF8 ;	0639 0649 ;	MA	# ( ‎ﳸ‎ → ‎عى‎ ) ARABIC LIGATURE AIN WITH YEH ISOLATED FORM → ARABIC LETTER AIN, ARABIC LETTER ALEF MAKSURA	# →‎عي‎→
+
+1EE1B ;	063A ;	MA	# ( ‎𞸛‎ → ‎غ‎ ) ARABIC MATHEMATICAL GHAIN → ARABIC LETTER GHAIN	# 
+1EE3B ;	063A ;	MA	# ( ‎𞸻‎ → ‎غ‎ ) ARABIC MATHEMATICAL INITIAL GHAIN → ARABIC LETTER GHAIN	# 
+1EE5B ;	063A ;	MA	# ( ‎𞹛‎ → ‎غ‎ ) ARABIC MATHEMATICAL TAILED GHAIN → ARABIC LETTER GHAIN	# 
+1EE7B ;	063A ;	MA	# ( ‎𞹻‎ → ‎غ‎ ) ARABIC MATHEMATICAL STRETCHED GHAIN → ARABIC LETTER GHAIN	# 
+1EE9B ;	063A ;	MA	# ( ‎𞺛‎ → ‎غ‎ ) ARABIC MATHEMATICAL LOOPED GHAIN → ARABIC LETTER GHAIN	# 
+1EEBB ;	063A ;	MA	# ( ‎𞺻‎ → ‎غ‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN → ARABIC LETTER GHAIN	# 
+FECF ;	063A ;	MA	# ( ‎ﻏ‎ → ‎غ‎ ) ARABIC LETTER GHAIN INITIAL FORM → ARABIC LETTER GHAIN	# 
+FED0 ;	063A ;	MA	# ( ‎ﻐ‎ → ‎غ‎ ) ARABIC LETTER GHAIN MEDIAL FORM → ARABIC LETTER GHAIN	# 
+FECE ;	063A ;	MA	# ( ‎ﻎ‎ → ‎غ‎ ) ARABIC LETTER GHAIN FINAL FORM → ARABIC LETTER GHAIN	# 
+FECD ;	063A ;	MA	# ( ‎ﻍ‎ → ‎غ‎ ) ARABIC LETTER GHAIN ISOLATED FORM → ARABIC LETTER GHAIN	# 
+
+FCBC ;	063A 062C ;	MA	# ( ‎ﲼ‎ → ‎غج‎ ) ARABIC LIGATURE GHAIN WITH JEEM INITIAL FORM → ARABIC LETTER GHAIN, ARABIC LETTER JEEM	# 
+FC2B ;	063A 062C ;	MA	# ( ‎ﰫ‎ → ‎غج‎ ) ARABIC LIGATURE GHAIN WITH JEEM ISOLATED FORM → ARABIC LETTER GHAIN, ARABIC LETTER JEEM	# 
+
+FCBD ;	063A 0645 ;	MA	# ( ‎ﲽ‎ → ‎غم‎ ) ARABIC LIGATURE GHAIN WITH MEEM INITIAL FORM → ARABIC LETTER GHAIN, ARABIC LETTER MEEM	# 
+FC2C ;	063A 0645 ;	MA	# ( ‎ﰬ‎ → ‎غم‎ ) ARABIC LIGATURE GHAIN WITH MEEM ISOLATED FORM → ARABIC LETTER GHAIN, ARABIC LETTER MEEM	# 
+
+FD79 ;	063A 0645 0645 ;	MA	# ( ‎ﵹ‎ → ‎غمم‎ ) ARABIC LIGATURE GHAIN WITH MEEM WITH MEEM FINAL FORM → ARABIC LETTER GHAIN, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+
+FD7B ;	063A 0645 0649 ;	MA	# ( ‎ﵻ‎ → ‎غمى‎ ) ARABIC LIGATURE GHAIN WITH MEEM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER GHAIN, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# 
+FD7A ;	063A 0645 0649 ;	MA	# ( ‎ﵺ‎ → ‎غمى‎ ) ARABIC LIGATURE GHAIN WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER GHAIN, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎غمي‎→
+
+FD15 ;	063A 0649 ;	MA	# ( ‎ﴕ‎ → ‎غى‎ ) ARABIC LIGATURE GHAIN WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER GHAIN, ARABIC LETTER ALEF MAKSURA	# 
+FCF9 ;	063A 0649 ;	MA	# ( ‎ﳹ‎ → ‎غى‎ ) ARABIC LIGATURE GHAIN WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER GHAIN, ARABIC LETTER ALEF MAKSURA	# 
+FD16 ;	063A 0649 ;	MA	# ( ‎ﴖ‎ → ‎غى‎ ) ARABIC LIGATURE GHAIN WITH YEH FINAL FORM → ARABIC LETTER GHAIN, ARABIC LETTER ALEF MAKSURA	# →‎غي‎→
+FCFA ;	063A 0649 ;	MA	# ( ‎ﳺ‎ → ‎غى‎ ) ARABIC LIGATURE GHAIN WITH YEH ISOLATED FORM → ARABIC LETTER GHAIN, ARABIC LETTER ALEF MAKSURA	# →‎غي‎→
+
+1EE10 ;	0641 ;	MA	# ( ‎𞸐‎ → ‎ف‎ ) ARABIC MATHEMATICAL FEH → ARABIC LETTER FEH	# 
+1EE30 ;	0641 ;	MA	# ( ‎𞸰‎ → ‎ف‎ ) ARABIC MATHEMATICAL INITIAL FEH → ARABIC LETTER FEH	# 
+1EE70 ;	0641 ;	MA	# ( ‎𞹰‎ → ‎ف‎ ) ARABIC MATHEMATICAL STRETCHED FEH → ARABIC LETTER FEH	# 
+1EE90 ;	0641 ;	MA	# ( ‎𞺐‎ → ‎ف‎ ) ARABIC MATHEMATICAL LOOPED FEH → ARABIC LETTER FEH	# 
+1EEB0 ;	0641 ;	MA	# ( ‎𞺰‎ → ‎ف‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK FEH → ARABIC LETTER FEH	# 
+FED3 ;	0641 ;	MA	# ( ‎ﻓ‎ → ‎ف‎ ) ARABIC LETTER FEH INITIAL FORM → ARABIC LETTER FEH	# 
+FED4 ;	0641 ;	MA	# ( ‎ﻔ‎ → ‎ف‎ ) ARABIC LETTER FEH MEDIAL FORM → ARABIC LETTER FEH	# 
+FED2 ;	0641 ;	MA	# ( ‎ﻒ‎ → ‎ف‎ ) ARABIC LETTER FEH FINAL FORM → ARABIC LETTER FEH	# 
+FED1 ;	0641 ;	MA	# ( ‎ﻑ‎ → ‎ف‎ ) ARABIC LETTER FEH ISOLATED FORM → ARABIC LETTER FEH	# 
+06A7 ;	0641 ;	MA	# ( ‎ڧ‎ → ‎ف‎ ) ARABIC LETTER QAF WITH DOT ABOVE → ARABIC LETTER FEH	# 
+
+FCBE ;	0641 062C ;	MA	# ( ‎ﲾ‎ → ‎فج‎ ) ARABIC LIGATURE FEH WITH JEEM INITIAL FORM → ARABIC LETTER FEH, ARABIC LETTER JEEM	# 
+FC2D ;	0641 062C ;	MA	# ( ‎ﰭ‎ → ‎فج‎ ) ARABIC LIGATURE FEH WITH JEEM ISOLATED FORM → ARABIC LETTER FEH, ARABIC LETTER JEEM	# 
+
+FCBF ;	0641 062D ;	MA	# ( ‎ﲿ‎ → ‎فح‎ ) ARABIC LIGATURE FEH WITH HAH INITIAL FORM → ARABIC LETTER FEH, ARABIC LETTER HAH	# 
+FC2E ;	0641 062D ;	MA	# ( ‎ﰮ‎ → ‎فح‎ ) ARABIC LIGATURE FEH WITH HAH ISOLATED FORM → ARABIC LETTER FEH, ARABIC LETTER HAH	# 
+
+FCC0 ;	0641 062E ;	MA	# ( ‎ﳀ‎ → ‎فخ‎ ) ARABIC LIGATURE FEH WITH KHAH INITIAL FORM → ARABIC LETTER FEH, ARABIC LETTER KHAH	# 
+FC2F ;	0641 062E ;	MA	# ( ‎ﰯ‎ → ‎فخ‎ ) ARABIC LIGATURE FEH WITH KHAH ISOLATED FORM → ARABIC LETTER FEH, ARABIC LETTER KHAH	# 
+
+FD7D ;	0641 062E 0645 ;	MA	# ( ‎ﵽ‎ → ‎فخم‎ ) ARABIC LIGATURE FEH WITH KHAH WITH MEEM INITIAL FORM → ARABIC LETTER FEH, ARABIC LETTER KHAH, ARABIC LETTER MEEM	# 
+FD7C ;	0641 062E 0645 ;	MA	# ( ‎ﵼ‎ → ‎فخم‎ ) ARABIC LIGATURE FEH WITH KHAH WITH MEEM FINAL FORM → ARABIC LETTER FEH, ARABIC LETTER KHAH, ARABIC LETTER MEEM	# 
+
+FCC1 ;	0641 0645 ;	MA	# ( ‎ﳁ‎ → ‎فم‎ ) ARABIC LIGATURE FEH WITH MEEM INITIAL FORM → ARABIC LETTER FEH, ARABIC LETTER MEEM	# 
+FC30 ;	0641 0645 ;	MA	# ( ‎ﰰ‎ → ‎فم‎ ) ARABIC LIGATURE FEH WITH MEEM ISOLATED FORM → ARABIC LETTER FEH, ARABIC LETTER MEEM	# 
+
+FDC1 ;	0641 0645 0649 ;	MA	# ( ‎ﷁ‎ → ‎فمى‎ ) ARABIC LIGATURE FEH WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER FEH, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎فمي‎→
+
+FC7C ;	0641 0649 ;	MA	# ( ‎ﱼ‎ → ‎فى‎ ) ARABIC LIGATURE FEH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER FEH, ARABIC LETTER ALEF MAKSURA	# 
+FC31 ;	0641 0649 ;	MA	# ( ‎ﰱ‎ → ‎فى‎ ) ARABIC LIGATURE FEH WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER FEH, ARABIC LETTER ALEF MAKSURA	# 
+FC7D ;	0641 0649 ;	MA	# ( ‎ﱽ‎ → ‎فى‎ ) ARABIC LIGATURE FEH WITH YEH FINAL FORM → ARABIC LETTER FEH, ARABIC LETTER ALEF MAKSURA	# →‎في‎→
+FC32 ;	0641 0649 ;	MA	# ( ‎ﰲ‎ → ‎فى‎ ) ARABIC LIGATURE FEH WITH YEH ISOLATED FORM → ARABIC LETTER FEH, ARABIC LETTER ALEF MAKSURA	# →‎في‎→
+
+1EE1E ;	06A1 ;	MA	# ( ‎𞸞‎ → ‎ڡ‎ ) ARABIC MATHEMATICAL DOTLESS FEH → ARABIC LETTER DOTLESS FEH	# 
+1EE7E ;	06A1 ;	MA	# ( ‎𞹾‎ → ‎ڡ‎ ) ARABIC MATHEMATICAL STRETCHED DOTLESS FEH → ARABIC LETTER DOTLESS FEH	# 
+08BB ;	06A1 ;	MA	# ( ‎ࢻ‎ → ‎ڡ‎ ) ARABIC LETTER AFRICAN FEH → ARABIC LETTER DOTLESS FEH	# 
+066F ;	06A1 ;	MA	# ( ‎ٯ‎ → ‎ڡ‎ ) ARABIC LETTER DOTLESS QAF → ARABIC LETTER DOTLESS FEH	# 
+1EE1F ;	06A1 ;	MA	# ( ‎𞸟‎ → ‎ڡ‎ ) ARABIC MATHEMATICAL DOTLESS QAF → ARABIC LETTER DOTLESS FEH	# →‎ٯ‎→
+1EE5F ;	06A1 ;	MA	# ( ‎𞹟‎ → ‎ڡ‎ ) ARABIC MATHEMATICAL TAILED DOTLESS QAF → ARABIC LETTER DOTLESS FEH	# →‎ٯ‎→
+08BC ;	06A1 ;	MA	# ( ‎ࢼ‎ → ‎ڡ‎ ) ARABIC LETTER AFRICAN QAF → ARABIC LETTER DOTLESS FEH	# →‎ٯ‎→
+
+06A4 ;	06A1 06DB ;	MA	# ( ‎ڤ‎ → ‎ڡۛ‎ ) ARABIC LETTER VEH → ARABIC LETTER DOTLESS FEH, ARABIC SMALL HIGH THREE DOTS	# 
+FB6C ;	06A1 06DB ;	MA	# ( ‎ﭬ‎ → ‎ڡۛ‎ ) ARABIC LETTER VEH INITIAL FORM → ARABIC LETTER DOTLESS FEH, ARABIC SMALL HIGH THREE DOTS	# →‎ڤ‎→
+FB6D ;	06A1 06DB ;	MA	# ( ‎ﭭ‎ → ‎ڡۛ‎ ) ARABIC LETTER VEH MEDIAL FORM → ARABIC LETTER DOTLESS FEH, ARABIC SMALL HIGH THREE DOTS	# →‎ڤ‎→
+FB6B ;	06A1 06DB ;	MA	# ( ‎ﭫ‎ → ‎ڡۛ‎ ) ARABIC LETTER VEH FINAL FORM → ARABIC LETTER DOTLESS FEH, ARABIC SMALL HIGH THREE DOTS	# →‎ڤ‎→
+FB6A ;	06A1 06DB ;	MA	# ( ‎ﭪ‎ → ‎ڡۛ‎ ) ARABIC LETTER VEH ISOLATED FORM → ARABIC LETTER DOTLESS FEH, ARABIC SMALL HIGH THREE DOTS	# →‎ڤ‎→
+06A8 ;	06A1 06DB ;	MA	# ( ‎ڨ‎ → ‎ڡۛ‎ ) ARABIC LETTER QAF WITH THREE DOTS ABOVE → ARABIC LETTER DOTLESS FEH, ARABIC SMALL HIGH THREE DOTS	# →‎ڤ‎→
+
+08A4 ;	06A2 06DB ;	MA	# ( ‎ࢤ‎ → ‎ڢۛ‎ ) ARABIC LETTER FEH WITH DOT BELOW AND THREE DOTS ABOVE → ARABIC LETTER FEH WITH DOT MOVED BELOW, ARABIC SMALL HIGH THREE DOTS	# 
+
+FB70 ;	06A6 ;	MA	# ( ‎ﭰ‎ → ‎ڦ‎ ) ARABIC LETTER PEHEH INITIAL FORM → ARABIC LETTER PEHEH	# 
+FB71 ;	06A6 ;	MA	# ( ‎ﭱ‎ → ‎ڦ‎ ) ARABIC LETTER PEHEH MEDIAL FORM → ARABIC LETTER PEHEH	# 
+FB6F ;	06A6 ;	MA	# ( ‎ﭯ‎ → ‎ڦ‎ ) ARABIC LETTER PEHEH FINAL FORM → ARABIC LETTER PEHEH	# 
+FB6E ;	06A6 ;	MA	# ( ‎ﭮ‎ → ‎ڦ‎ ) ARABIC LETTER PEHEH ISOLATED FORM → ARABIC LETTER PEHEH	# 
+
+1EE12 ;	0642 ;	MA	# ( ‎𞸒‎ → ‎ق‎ ) ARABIC MATHEMATICAL QAF → ARABIC LETTER QAF	# 
+1EE32 ;	0642 ;	MA	# ( ‎𞸲‎ → ‎ق‎ ) ARABIC MATHEMATICAL INITIAL QAF → ARABIC LETTER QAF	# 
+1EE52 ;	0642 ;	MA	# ( ‎𞹒‎ → ‎ق‎ ) ARABIC MATHEMATICAL TAILED QAF → ARABIC LETTER QAF	# 
+1EE72 ;	0642 ;	MA	# ( ‎𞹲‎ → ‎ق‎ ) ARABIC MATHEMATICAL STRETCHED QAF → ARABIC LETTER QAF	# 
+1EE92 ;	0642 ;	MA	# ( ‎𞺒‎ → ‎ق‎ ) ARABIC MATHEMATICAL LOOPED QAF → ARABIC LETTER QAF	# 
+1EEB2 ;	0642 ;	MA	# ( ‎𞺲‎ → ‎ق‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK QAF → ARABIC LETTER QAF	# 
+FED7 ;	0642 ;	MA	# ( ‎ﻗ‎ → ‎ق‎ ) ARABIC LETTER QAF INITIAL FORM → ARABIC LETTER QAF	# 
+FED8 ;	0642 ;	MA	# ( ‎ﻘ‎ → ‎ق‎ ) ARABIC LETTER QAF MEDIAL FORM → ARABIC LETTER QAF	# 
+FED6 ;	0642 ;	MA	# ( ‎ﻖ‎ → ‎ق‎ ) ARABIC LETTER QAF FINAL FORM → ARABIC LETTER QAF	# 
+FED5 ;	0642 ;	MA	# ( ‎ﻕ‎ → ‎ق‎ ) ARABIC LETTER QAF ISOLATED FORM → ARABIC LETTER QAF	# 
+
+FCC2 ;	0642 062D ;	MA	# ( ‎ﳂ‎ → ‎قح‎ ) ARABIC LIGATURE QAF WITH HAH INITIAL FORM → ARABIC LETTER QAF, ARABIC LETTER HAH	# 
+FC33 ;	0642 062D ;	MA	# ( ‎ﰳ‎ → ‎قح‎ ) ARABIC LIGATURE QAF WITH HAH ISOLATED FORM → ARABIC LETTER QAF, ARABIC LETTER HAH	# 
+
+FDF1 ;	0642 0644 0649 ;	MA	# ( ‎ﷱ‎ → ‎قلى‎ ) ARABIC LIGATURE QALA USED AS KORANIC STOP SIGN ISOLATED FORM → ARABIC LETTER QAF, ARABIC LETTER LAM, ARABIC LETTER ALEF MAKSURA	# →‎قلے‎→
+
+FCC3 ;	0642 0645 ;	MA	# ( ‎ﳃ‎ → ‎قم‎ ) ARABIC LIGATURE QAF WITH MEEM INITIAL FORM → ARABIC LETTER QAF, ARABIC LETTER MEEM	# 
+FC34 ;	0642 0645 ;	MA	# ( ‎ﰴ‎ → ‎قم‎ ) ARABIC LIGATURE QAF WITH MEEM ISOLATED FORM → ARABIC LETTER QAF, ARABIC LETTER MEEM	# 
+
+FDB4 ;	0642 0645 062D ;	MA	# ( ‎ﶴ‎ → ‎قمح‎ ) ARABIC LIGATURE QAF WITH MEEM WITH HAH INITIAL FORM → ARABIC LETTER QAF, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+FD7E ;	0642 0645 062D ;	MA	# ( ‎ﵾ‎ → ‎قمح‎ ) ARABIC LIGATURE QAF WITH MEEM WITH HAH FINAL FORM → ARABIC LETTER QAF, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+
+FD7F ;	0642 0645 0645 ;	MA	# ( ‎ﵿ‎ → ‎قمم‎ ) ARABIC LIGATURE QAF WITH MEEM WITH MEEM FINAL FORM → ARABIC LETTER QAF, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+
+FDB2 ;	0642 0645 0649 ;	MA	# ( ‎ﶲ‎ → ‎قمى‎ ) ARABIC LIGATURE QAF WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER QAF, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎قمي‎→
+
+FC7E ;	0642 0649 ;	MA	# ( ‎ﱾ‎ → ‎قى‎ ) ARABIC LIGATURE QAF WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER QAF, ARABIC LETTER ALEF MAKSURA	# 
+FC35 ;	0642 0649 ;	MA	# ( ‎ﰵ‎ → ‎قى‎ ) ARABIC LIGATURE QAF WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER QAF, ARABIC LETTER ALEF MAKSURA	# 
+FC7F ;	0642 0649 ;	MA	# ( ‎ﱿ‎ → ‎قى‎ ) ARABIC LIGATURE QAF WITH YEH FINAL FORM → ARABIC LETTER QAF, ARABIC LETTER ALEF MAKSURA	# →‎قي‎→
+FC36 ;	0642 0649 ;	MA	# ( ‎ﰶ‎ → ‎قى‎ ) ARABIC LIGATURE QAF WITH YEH ISOLATED FORM → ARABIC LETTER QAF, ARABIC LETTER ALEF MAKSURA	# →‎قي‎→
+
+1EE0A ;	0643 ;	MA	# ( ‎𞸊‎ → ‎ك‎ ) ARABIC MATHEMATICAL KAF → ARABIC LETTER KAF	# 
+1EE2A ;	0643 ;	MA	# ( ‎𞸪‎ → ‎ك‎ ) ARABIC MATHEMATICAL INITIAL KAF → ARABIC LETTER KAF	# 
+1EE6A ;	0643 ;	MA	# ( ‎𞹪‎ → ‎ك‎ ) ARABIC MATHEMATICAL STRETCHED KAF → ARABIC LETTER KAF	# 
+FEDB ;	0643 ;	MA	# ( ‎ﻛ‎ → ‎ك‎ ) ARABIC LETTER KAF INITIAL FORM → ARABIC LETTER KAF	# 
+FEDC ;	0643 ;	MA	# ( ‎ﻜ‎ → ‎ك‎ ) ARABIC LETTER KAF MEDIAL FORM → ARABIC LETTER KAF	# 
+FEDA ;	0643 ;	MA	# ( ‎ﻚ‎ → ‎ك‎ ) ARABIC LETTER KAF FINAL FORM → ARABIC LETTER KAF	# 
+FED9 ;	0643 ;	MA	# ( ‎ﻙ‎ → ‎ك‎ ) ARABIC LETTER KAF ISOLATED FORM → ARABIC LETTER KAF	# 
+06A9 ;	0643 ;	MA	# ( ‎ک‎ → ‎ك‎ ) ARABIC LETTER KEHEH → ARABIC LETTER KAF	# 
+FB90 ;	0643 ;	MA	# ( ‎ﮐ‎ → ‎ك‎ ) ARABIC LETTER KEHEH INITIAL FORM → ARABIC LETTER KAF	# →‎ک‎→
+FB91 ;	0643 ;	MA	# ( ‎ﮑ‎ → ‎ك‎ ) ARABIC LETTER KEHEH MEDIAL FORM → ARABIC LETTER KAF	# →‎ک‎→
+FB8F ;	0643 ;	MA	# ( ‎ﮏ‎ → ‎ك‎ ) ARABIC LETTER KEHEH FINAL FORM → ARABIC LETTER KAF	# →‎ک‎→
+FB8E ;	0643 ;	MA	# ( ‎ﮎ‎ → ‎ك‎ ) ARABIC LETTER KEHEH ISOLATED FORM → ARABIC LETTER KAF	# →‎ک‎→
+06AA ;	0643 ;	MA	# ( ‎ڪ‎ → ‎ك‎ ) ARABIC LETTER SWASH KAF → ARABIC LETTER KAF	# 
+
+06AD ;	0643 06DB ;	MA	# ( ‎ڭ‎ → ‎كۛ‎ ) ARABIC LETTER NG → ARABIC LETTER KAF, ARABIC SMALL HIGH THREE DOTS	# 
+FBD5 ;	0643 06DB ;	MA	# ( ‎ﯕ‎ → ‎كۛ‎ ) ARABIC LETTER NG INITIAL FORM → ARABIC LETTER KAF, ARABIC SMALL HIGH THREE DOTS	# →‎ڭ‎→
+FBD6 ;	0643 06DB ;	MA	# ( ‎ﯖ‎ → ‎كۛ‎ ) ARABIC LETTER NG MEDIAL FORM → ARABIC LETTER KAF, ARABIC SMALL HIGH THREE DOTS	# →‎ڭ‎→
+FBD4 ;	0643 06DB ;	MA	# ( ‎ﯔ‎ → ‎كۛ‎ ) ARABIC LETTER NG FINAL FORM → ARABIC LETTER KAF, ARABIC SMALL HIGH THREE DOTS	# →‎ڭ‎→
+FBD3 ;	0643 06DB ;	MA	# ( ‎ﯓ‎ → ‎كۛ‎ ) ARABIC LETTER NG ISOLATED FORM → ARABIC LETTER KAF, ARABIC SMALL HIGH THREE DOTS	# →‎ڭ‎→
+0763 ;	0643 06DB ;	MA	# ( ‎ݣ‎ → ‎كۛ‎ ) ARABIC LETTER KEHEH WITH THREE DOTS ABOVE → ARABIC LETTER KAF, ARABIC SMALL HIGH THREE DOTS	# →‎ڭ‎→
+
+08C2 ;	0643 0306 ;	MA	# ( ‎ࣂ‎ → ‎ك̆‎ ) ARABIC LETTER KEHEH WITH SMALL V → ARABIC LETTER KAF, COMBINING BREVE	# →‎کٚ‎→
+
+FC80 ;	0643 006C ;	MA	# ( ‎ﲀ‎ → ‎كl‎ ) ARABIC LIGATURE KAF WITH ALEF FINAL FORM → ARABIC LETTER KAF, LATIN SMALL LETTER L	# →‎كا‎→
+FC37 ;	0643 006C ;	MA	# ( ‎ﰷ‎ → ‎كl‎ ) ARABIC LIGATURE KAF WITH ALEF ISOLATED FORM → ARABIC LETTER KAF, LATIN SMALL LETTER L	# →‎كا‎→
+
+FCC4 ;	0643 062C ;	MA	# ( ‎ﳄ‎ → ‎كج‎ ) ARABIC LIGATURE KAF WITH JEEM INITIAL FORM → ARABIC LETTER KAF, ARABIC LETTER JEEM	# 
+FC38 ;	0643 062C ;	MA	# ( ‎ﰸ‎ → ‎كج‎ ) ARABIC LIGATURE KAF WITH JEEM ISOLATED FORM → ARABIC LETTER KAF, ARABIC LETTER JEEM	# 
+
+FCC5 ;	0643 062D ;	MA	# ( ‎ﳅ‎ → ‎كح‎ ) ARABIC LIGATURE KAF WITH HAH INITIAL FORM → ARABIC LETTER KAF, ARABIC LETTER HAH	# 
+FC39 ;	0643 062D ;	MA	# ( ‎ﰹ‎ → ‎كح‎ ) ARABIC LIGATURE KAF WITH HAH ISOLATED FORM → ARABIC LETTER KAF, ARABIC LETTER HAH	# 
+
+FCC6 ;	0643 062E ;	MA	# ( ‎ﳆ‎ → ‎كخ‎ ) ARABIC LIGATURE KAF WITH KHAH INITIAL FORM → ARABIC LETTER KAF, ARABIC LETTER KHAH	# 
+FC3A ;	0643 062E ;	MA	# ( ‎ﰺ‎ → ‎كخ‎ ) ARABIC LIGATURE KAF WITH KHAH ISOLATED FORM → ARABIC LETTER KAF, ARABIC LETTER KHAH	# 
+
+FCC7 ;	0643 0644 ;	MA	# ( ‎ﳇ‎ → ‎كل‎ ) ARABIC LIGATURE KAF WITH LAM INITIAL FORM → ARABIC LETTER KAF, ARABIC LETTER LAM	# 
+FCEB ;	0643 0644 ;	MA	# ( ‎ﳫ‎ → ‎كل‎ ) ARABIC LIGATURE KAF WITH LAM MEDIAL FORM → ARABIC LETTER KAF, ARABIC LETTER LAM	# 
+FC81 ;	0643 0644 ;	MA	# ( ‎ﲁ‎ → ‎كل‎ ) ARABIC LIGATURE KAF WITH LAM FINAL FORM → ARABIC LETTER KAF, ARABIC LETTER LAM	# 
+FC3B ;	0643 0644 ;	MA	# ( ‎ﰻ‎ → ‎كل‎ ) ARABIC LIGATURE KAF WITH LAM ISOLATED FORM → ARABIC LETTER KAF, ARABIC LETTER LAM	# 
+
+FCC8 ;	0643 0645 ;	MA	# ( ‎ﳈ‎ → ‎كم‎ ) ARABIC LIGATURE KAF WITH MEEM INITIAL FORM → ARABIC LETTER KAF, ARABIC LETTER MEEM	# 
+FCEC ;	0643 0645 ;	MA	# ( ‎ﳬ‎ → ‎كم‎ ) ARABIC LIGATURE KAF WITH MEEM MEDIAL FORM → ARABIC LETTER KAF, ARABIC LETTER MEEM	# 
+FC82 ;	0643 0645 ;	MA	# ( ‎ﲂ‎ → ‎كم‎ ) ARABIC LIGATURE KAF WITH MEEM FINAL FORM → ARABIC LETTER KAF, ARABIC LETTER MEEM	# 
+FC3C ;	0643 0645 ;	MA	# ( ‎ﰼ‎ → ‎كم‎ ) ARABIC LIGATURE KAF WITH MEEM ISOLATED FORM → ARABIC LETTER KAF, ARABIC LETTER MEEM	# 
+
+FDC3 ;	0643 0645 0645 ;	MA	# ( ‎ﷃ‎ → ‎كمم‎ ) ARABIC LIGATURE KAF WITH MEEM WITH MEEM INITIAL FORM → ARABIC LETTER KAF, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+FDBB ;	0643 0645 0645 ;	MA	# ( ‎ﶻ‎ → ‎كمم‎ ) ARABIC LIGATURE KAF WITH MEEM WITH MEEM FINAL FORM → ARABIC LETTER KAF, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+
+FDB7 ;	0643 0645 0649 ;	MA	# ( ‎ﶷ‎ → ‎كمى‎ ) ARABIC LIGATURE KAF WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER KAF, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎كمي‎→
+
+FC83 ;	0643 0649 ;	MA	# ( ‎ﲃ‎ → ‎كى‎ ) ARABIC LIGATURE KAF WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER KAF, ARABIC LETTER ALEF MAKSURA	# 
+FC3D ;	0643 0649 ;	MA	# ( ‎ﰽ‎ → ‎كى‎ ) ARABIC LIGATURE KAF WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER KAF, ARABIC LETTER ALEF MAKSURA	# 
+FC84 ;	0643 0649 ;	MA	# ( ‎ﲄ‎ → ‎كى‎ ) ARABIC LIGATURE KAF WITH YEH FINAL FORM → ARABIC LETTER KAF, ARABIC LETTER ALEF MAKSURA	# →‎كي‎→
+FC3E ;	0643 0649 ;	MA	# ( ‎ﰾ‎ → ‎كى‎ ) ARABIC LIGATURE KAF WITH YEH ISOLATED FORM → ARABIC LETTER KAF, ARABIC LETTER ALEF MAKSURA	# →‎كي‎→
+
+0762 ;	06AC ;	MA	# ( ‎ݢ‎ → ‎ڬ‎ ) ARABIC LETTER KEHEH WITH DOT ABOVE → ARABIC LETTER KAF WITH DOT ABOVE	# 
+
+FB94 ;	06AF ;	MA	# ( ‎ﮔ‎ → ‎گ‎ ) ARABIC LETTER GAF INITIAL FORM → ARABIC LETTER GAF	# 
+FB95 ;	06AF ;	MA	# ( ‎ﮕ‎ → ‎گ‎ ) ARABIC LETTER GAF MEDIAL FORM → ARABIC LETTER GAF	# 
+FB93 ;	06AF ;	MA	# ( ‎ﮓ‎ → ‎گ‎ ) ARABIC LETTER GAF FINAL FORM → ARABIC LETTER GAF	# 
+FB92 ;	06AF ;	MA	# ( ‎ﮒ‎ → ‎گ‎ ) ARABIC LETTER GAF ISOLATED FORM → ARABIC LETTER GAF	# 
+08B0 ;	06AF ;	MA	# ( ‎ࢰ‎ → ‎گ‎ ) ARABIC LETTER GAF WITH INVERTED STROKE → ARABIC LETTER GAF	# 
+
+06B4 ;	06AF 06DB ;	MA	# ( ‎ڴ‎ → ‎گۛ‎ ) ARABIC LETTER GAF WITH THREE DOTS ABOVE → ARABIC LETTER GAF, ARABIC SMALL HIGH THREE DOTS	# 
+
+FB9C ;	06B1 ;	MA	# ( ‎ﮜ‎ → ‎ڱ‎ ) ARABIC LETTER NGOEH INITIAL FORM → ARABIC LETTER NGOEH	# 
+FB9D ;	06B1 ;	MA	# ( ‎ﮝ‎ → ‎ڱ‎ ) ARABIC LETTER NGOEH MEDIAL FORM → ARABIC LETTER NGOEH	# 
+FB9B ;	06B1 ;	MA	# ( ‎ﮛ‎ → ‎ڱ‎ ) ARABIC LETTER NGOEH FINAL FORM → ARABIC LETTER NGOEH	# 
+FB9A ;	06B1 ;	MA	# ( ‎ﮚ‎ → ‎ڱ‎ ) ARABIC LETTER NGOEH ISOLATED FORM → ARABIC LETTER NGOEH	# 
+
+FB98 ;	06B3 ;	MA	# ( ‎ﮘ‎ → ‎ڳ‎ ) ARABIC LETTER GUEH INITIAL FORM → ARABIC LETTER GUEH	# 
+FB99 ;	06B3 ;	MA	# ( ‎ﮙ‎ → ‎ڳ‎ ) ARABIC LETTER GUEH MEDIAL FORM → ARABIC LETTER GUEH	# 
+FB97 ;	06B3 ;	MA	# ( ‎ﮗ‎ → ‎ڳ‎ ) ARABIC LETTER GUEH FINAL FORM → ARABIC LETTER GUEH	# 
+FB96 ;	06B3 ;	MA	# ( ‎ﮖ‎ → ‎ڳ‎ ) ARABIC LETTER GUEH ISOLATED FORM → ARABIC LETTER GUEH	# 
+
+1EE0B ;	0644 ;	MA	# ( ‎𞸋‎ → ‎ل‎ ) ARABIC MATHEMATICAL LAM → ARABIC LETTER LAM	# 
+1EE2B ;	0644 ;	MA	# ( ‎𞸫‎ → ‎ل‎ ) ARABIC MATHEMATICAL INITIAL LAM → ARABIC LETTER LAM	# 
+1EE4B ;	0644 ;	MA	# ( ‎𞹋‎ → ‎ل‎ ) ARABIC MATHEMATICAL TAILED LAM → ARABIC LETTER LAM	# 
+1EE8B ;	0644 ;	MA	# ( ‎𞺋‎ → ‎ل‎ ) ARABIC MATHEMATICAL LOOPED LAM → ARABIC LETTER LAM	# 
+1EEAB ;	0644 ;	MA	# ( ‎𞺫‎ → ‎ل‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK LAM → ARABIC LETTER LAM	# 
+FEDF ;	0644 ;	MA	# ( ‎ﻟ‎ → ‎ل‎ ) ARABIC LETTER LAM INITIAL FORM → ARABIC LETTER LAM	# 
+FEE0 ;	0644 ;	MA	# ( ‎ﻠ‎ → ‎ل‎ ) ARABIC LETTER LAM MEDIAL FORM → ARABIC LETTER LAM	# 
+FEDE ;	0644 ;	MA	# ( ‎ﻞ‎ → ‎ل‎ ) ARABIC LETTER LAM FINAL FORM → ARABIC LETTER LAM	# 
+FEDD ;	0644 ;	MA	# ( ‎ﻝ‎ → ‎ل‎ ) ARABIC LETTER LAM ISOLATED FORM → ARABIC LETTER LAM	# 
+
+06B7 ;	0644 06DB ;	MA	# ( ‎ڷ‎ → ‎لۛ‎ ) ARABIC LETTER LAM WITH THREE DOTS ABOVE → ARABIC LETTER LAM, ARABIC SMALL HIGH THREE DOTS	# 
+
+06B5 ;	0644 0306 ;	MA	# ( ‎ڵ‎ → ‎ل̆‎ ) ARABIC LETTER LAM WITH SMALL V → ARABIC LETTER LAM, COMBINING BREVE	# →‎لٚ‎→
+
+FEFC ;	0644 006C ;	MA	# ( ‎ﻼ‎ → ‎لl‎ ) ARABIC LIGATURE LAM WITH ALEF FINAL FORM → ARABIC LETTER LAM, LATIN SMALL LETTER L	# →‎لا‎→
+FEFB ;	0644 006C ;	MA	# ( ‎ﻻ‎ → ‎لl‎ ) ARABIC LIGATURE LAM WITH ALEF ISOLATED FORM → ARABIC LETTER LAM, LATIN SMALL LETTER L	# →‎لا‎→
+
+FEFA ;	0644 006C 0655 ;	MA	# ( ‎ﻺ‎ → ‎لlٕ‎ ) ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW FINAL FORM → ARABIC LETTER LAM, LATIN SMALL LETTER L, ARABIC HAMZA BELOW	# →‎لإ‎→
+FEF9 ;	0644 006C 0655 ;	MA	# ( ‎ﻹ‎ → ‎لlٕ‎ ) ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW ISOLATED FORM → ARABIC LETTER LAM, LATIN SMALL LETTER L, ARABIC HAMZA BELOW	# →‎لإ‎→
+
+FEF8 ;	0644 006C 0674 ;	MA	# ( ‎ﻸ‎ → ‎لlٴ‎ ) ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE FINAL FORM → ARABIC LETTER LAM, LATIN SMALL LETTER L, ARABIC LETTER HIGH HAMZA	# →‎لأ‎→
+FEF7 ;	0644 006C 0674 ;	MA	# ( ‎ﻷ‎ → ‎لlٴ‎ ) ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE ISOLATED FORM → ARABIC LETTER LAM, LATIN SMALL LETTER L, ARABIC LETTER HIGH HAMZA	# →‎لأ‎→
+
+FCCD ;	0644 006F ;	MA	# ( ‎ﳍ‎ → ‎لo‎ ) ARABIC LIGATURE LAM WITH HEH INITIAL FORM → ARABIC LETTER LAM, LATIN SMALL LETTER O	# →‎له‎→
+
+FEF6 ;	0644 0622 ;	MA	# ( ‎ﻶ‎ → ‎لآ‎ ) ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER ALEF WITH MADDA ABOVE	# 
+FEF5 ;	0644 0622 ;	MA	# ( ‎ﻵ‎ → ‎لآ‎ ) ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE ISOLATED FORM → ARABIC LETTER LAM, ARABIC LETTER ALEF WITH MADDA ABOVE	# 
+
+FCC9 ;	0644 062C ;	MA	# ( ‎ﳉ‎ → ‎لج‎ ) ARABIC LIGATURE LAM WITH JEEM INITIAL FORM → ARABIC LETTER LAM, ARABIC LETTER JEEM	# 
+FC3F ;	0644 062C ;	MA	# ( ‎ﰿ‎ → ‎لج‎ ) ARABIC LIGATURE LAM WITH JEEM ISOLATED FORM → ARABIC LETTER LAM, ARABIC LETTER JEEM	# 
+
+FD83 ;	0644 062C 062C ;	MA	# ( ‎ﶃ‎ → ‎لجج‎ ) ARABIC LIGATURE LAM WITH JEEM WITH JEEM INITIAL FORM → ARABIC LETTER LAM, ARABIC LETTER JEEM, ARABIC LETTER JEEM	# 
+FD84 ;	0644 062C 062C ;	MA	# ( ‎ﶄ‎ → ‎لجج‎ ) ARABIC LIGATURE LAM WITH JEEM WITH JEEM FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER JEEM, ARABIC LETTER JEEM	# 
+
+FDBA ;	0644 062C 0645 ;	MA	# ( ‎ﶺ‎ → ‎لجم‎ ) ARABIC LIGATURE LAM WITH JEEM WITH MEEM INITIAL FORM → ARABIC LETTER LAM, ARABIC LETTER JEEM, ARABIC LETTER MEEM	# 
+FDBC ;	0644 062C 0645 ;	MA	# ( ‎ﶼ‎ → ‎لجم‎ ) ARABIC LIGATURE LAM WITH JEEM WITH MEEM FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER JEEM, ARABIC LETTER MEEM	# 
+
+FDAC ;	0644 062C 0649 ;	MA	# ( ‎ﶬ‎ → ‎لجى‎ ) ARABIC LIGATURE LAM WITH JEEM WITH YEH FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# →‎لجي‎→
+
+FCCA ;	0644 062D ;	MA	# ( ‎ﳊ‎ → ‎لح‎ ) ARABIC LIGATURE LAM WITH HAH INITIAL FORM → ARABIC LETTER LAM, ARABIC LETTER HAH	# 
+FC40 ;	0644 062D ;	MA	# ( ‎ﱀ‎ → ‎لح‎ ) ARABIC LIGATURE LAM WITH HAH ISOLATED FORM → ARABIC LETTER LAM, ARABIC LETTER HAH	# 
+
+FDB5 ;	0644 062D 0645 ;	MA	# ( ‎ﶵ‎ → ‎لحم‎ ) ARABIC LIGATURE LAM WITH HAH WITH MEEM INITIAL FORM → ARABIC LETTER LAM, ARABIC LETTER HAH, ARABIC LETTER MEEM	# 
+FD80 ;	0644 062D 0645 ;	MA	# ( ‎ﶀ‎ → ‎لحم‎ ) ARABIC LIGATURE LAM WITH HAH WITH MEEM FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER HAH, ARABIC LETTER MEEM	# 
+
+FD82 ;	0644 062D 0649 ;	MA	# ( ‎ﶂ‎ → ‎لحى‎ ) ARABIC LIGATURE LAM WITH HAH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# 
+FD81 ;	0644 062D 0649 ;	MA	# ( ‎ﶁ‎ → ‎لحى‎ ) ARABIC LIGATURE LAM WITH HAH WITH YEH FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎لحي‎→
+
+FCCB ;	0644 062E ;	MA	# ( ‎ﳋ‎ → ‎لخ‎ ) ARABIC LIGATURE LAM WITH KHAH INITIAL FORM → ARABIC LETTER LAM, ARABIC LETTER KHAH	# 
+FC41 ;	0644 062E ;	MA	# ( ‎ﱁ‎ → ‎لخ‎ ) ARABIC LIGATURE LAM WITH KHAH ISOLATED FORM → ARABIC LETTER LAM, ARABIC LETTER KHAH	# 
+
+FD86 ;	0644 062E 0645 ;	MA	# ( ‎ﶆ‎ → ‎لخم‎ ) ARABIC LIGATURE LAM WITH KHAH WITH MEEM INITIAL FORM → ARABIC LETTER LAM, ARABIC LETTER KHAH, ARABIC LETTER MEEM	# 
+FD85 ;	0644 062E 0645 ;	MA	# ( ‎ﶅ‎ → ‎لخم‎ ) ARABIC LIGATURE LAM WITH KHAH WITH MEEM FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER KHAH, ARABIC LETTER MEEM	# 
+
+FCCC ;	0644 0645 ;	MA	# ( ‎ﳌ‎ → ‎لم‎ ) ARABIC LIGATURE LAM WITH MEEM INITIAL FORM → ARABIC LETTER LAM, ARABIC LETTER MEEM	# 
+FCED ;	0644 0645 ;	MA	# ( ‎ﳭ‎ → ‎لم‎ ) ARABIC LIGATURE LAM WITH MEEM MEDIAL FORM → ARABIC LETTER LAM, ARABIC LETTER MEEM	# 
+FC85 ;	0644 0645 ;	MA	# ( ‎ﲅ‎ → ‎لم‎ ) ARABIC LIGATURE LAM WITH MEEM FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER MEEM	# 
+FC42 ;	0644 0645 ;	MA	# ( ‎ﱂ‎ → ‎لم‎ ) ARABIC LIGATURE LAM WITH MEEM ISOLATED FORM → ARABIC LETTER LAM, ARABIC LETTER MEEM	# 
+
+FD88 ;	0644 0645 062D ;	MA	# ( ‎ﶈ‎ → ‎لمح‎ ) ARABIC LIGATURE LAM WITH MEEM WITH HAH INITIAL FORM → ARABIC LETTER LAM, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+FD87 ;	0644 0645 062D ;	MA	# ( ‎ﶇ‎ → ‎لمح‎ ) ARABIC LIGATURE LAM WITH MEEM WITH HAH FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+
+FDAD ;	0644 0645 0649 ;	MA	# ( ‎ﶭ‎ → ‎لمى‎ ) ARABIC LIGATURE LAM WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎لمي‎→
+
+FC86 ;	0644 0649 ;	MA	# ( ‎ﲆ‎ → ‎لى‎ ) ARABIC LIGATURE LAM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER ALEF MAKSURA	# 
+FC43 ;	0644 0649 ;	MA	# ( ‎ﱃ‎ → ‎لى‎ ) ARABIC LIGATURE LAM WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER LAM, ARABIC LETTER ALEF MAKSURA	# 
+FC87 ;	0644 0649 ;	MA	# ( ‎ﲇ‎ → ‎لى‎ ) ARABIC LIGATURE LAM WITH YEH FINAL FORM → ARABIC LETTER LAM, ARABIC LETTER ALEF MAKSURA	# →‎لي‎→
+FC44 ;	0644 0649 ;	MA	# ( ‎ﱄ‎ → ‎لى‎ ) ARABIC LIGATURE LAM WITH YEH ISOLATED FORM → ARABIC LETTER LAM, ARABIC LETTER ALEF MAKSURA	# →‎لي‎→
+
+1EE0C ;	0645 ;	MA	# ( ‎𞸌‎ → ‎م‎ ) ARABIC MATHEMATICAL MEEM → ARABIC LETTER MEEM	# 
+1EE2C ;	0645 ;	MA	# ( ‎𞸬‎ → ‎م‎ ) ARABIC MATHEMATICAL INITIAL MEEM → ARABIC LETTER MEEM	# 
+1EE6C ;	0645 ;	MA	# ( ‎𞹬‎ → ‎م‎ ) ARABIC MATHEMATICAL STRETCHED MEEM → ARABIC LETTER MEEM	# 
+1EE8C ;	0645 ;	MA	# ( ‎𞺌‎ → ‎م‎ ) ARABIC MATHEMATICAL LOOPED MEEM → ARABIC LETTER MEEM	# 
+1EEAC ;	0645 ;	MA	# ( ‎𞺬‎ → ‎م‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK MEEM → ARABIC LETTER MEEM	# 
+FEE3 ;	0645 ;	MA	# ( ‎ﻣ‎ → ‎م‎ ) ARABIC LETTER MEEM INITIAL FORM → ARABIC LETTER MEEM	# 
+FEE4 ;	0645 ;	MA	# ( ‎ﻤ‎ → ‎م‎ ) ARABIC LETTER MEEM MEDIAL FORM → ARABIC LETTER MEEM	# 
+FEE2 ;	0645 ;	MA	# ( ‎ﻢ‎ → ‎م‎ ) ARABIC LETTER MEEM FINAL FORM → ARABIC LETTER MEEM	# 
+FEE1 ;	0645 ;	MA	# ( ‎ﻡ‎ → ‎م‎ ) ARABIC LETTER MEEM ISOLATED FORM → ARABIC LETTER MEEM	# 
+
+08A7 ;	0645 06DB ;	MA	# ( ‎ࢧ‎ → ‎مۛ‎ ) ARABIC LETTER MEEM WITH THREE DOTS ABOVE → ARABIC LETTER MEEM, ARABIC SMALL HIGH THREE DOTS	# 
+
+FC88 ;	0645 006C ;	MA	# ( ‎ﲈ‎ → ‎مl‎ ) ARABIC LIGATURE MEEM WITH ALEF FINAL FORM → ARABIC LETTER MEEM, LATIN SMALL LETTER L	# →‎ما‎→
+
+FCCE ;	0645 062C ;	MA	# ( ‎ﳎ‎ → ‎مج‎ ) ARABIC LIGATURE MEEM WITH JEEM INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER JEEM	# 
+FC45 ;	0645 062C ;	MA	# ( ‎ﱅ‎ → ‎مج‎ ) ARABIC LIGATURE MEEM WITH JEEM ISOLATED FORM → ARABIC LETTER MEEM, ARABIC LETTER JEEM	# 
+
+FD8C ;	0645 062C 062D ;	MA	# ( ‎ﶌ‎ → ‎مجح‎ ) ARABIC LIGATURE MEEM WITH JEEM WITH HAH INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER JEEM, ARABIC LETTER HAH	# 
+
+FD92 ;	0645 062C 062E ;	MA	# ( ‎ﶒ‎ → ‎مجخ‎ ) ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER JEEM, ARABIC LETTER KHAH	# 
+
+FD8D ;	0645 062C 0645 ;	MA	# ( ‎ﶍ‎ → ‎مجم‎ ) ARABIC LIGATURE MEEM WITH JEEM WITH MEEM INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER JEEM, ARABIC LETTER MEEM	# 
+
+FDC0 ;	0645 062C 0649 ;	MA	# ( ‎ﷀ‎ → ‎مجى‎ ) ARABIC LIGATURE MEEM WITH JEEM WITH YEH FINAL FORM → ARABIC LETTER MEEM, ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# →‎مجي‎→
+
+FCCF ;	0645 062D ;	MA	# ( ‎ﳏ‎ → ‎مح‎ ) ARABIC LIGATURE MEEM WITH HAH INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+FC46 ;	0645 062D ;	MA	# ( ‎ﱆ‎ → ‎مح‎ ) ARABIC LIGATURE MEEM WITH HAH ISOLATED FORM → ARABIC LETTER MEEM, ARABIC LETTER HAH	# 
+
+FD89 ;	0645 062D 062C ;	MA	# ( ‎ﶉ‎ → ‎محج‎ ) ARABIC LIGATURE MEEM WITH HAH WITH JEEM INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER HAH, ARABIC LETTER JEEM	# 
+
+FD8A ;	0645 062D 0645 ;	MA	# ( ‎ﶊ‎ → ‎محم‎ ) ARABIC LIGATURE MEEM WITH HAH WITH MEEM INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER HAH, ARABIC LETTER MEEM	# 
+
+FDF4 ;	0645 062D 0645 062F ;	MA	# ( ‎ﷴ‎ → ‎محمد‎ ) ARABIC LIGATURE MOHAMMAD ISOLATED FORM → ARABIC LETTER MEEM, ARABIC LETTER HAH, ARABIC LETTER MEEM, ARABIC LETTER DAL	# 
+
+FD8B ;	0645 062D 0649 ;	MA	# ( ‎ﶋ‎ → ‎محى‎ ) ARABIC LIGATURE MEEM WITH HAH WITH YEH FINAL FORM → ARABIC LETTER MEEM, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎محي‎→
+
+FCD0 ;	0645 062E ;	MA	# ( ‎ﳐ‎ → ‎مخ‎ ) ARABIC LIGATURE MEEM WITH KHAH INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER KHAH	# 
+FC47 ;	0645 062E ;	MA	# ( ‎ﱇ‎ → ‎مخ‎ ) ARABIC LIGATURE MEEM WITH KHAH ISOLATED FORM → ARABIC LETTER MEEM, ARABIC LETTER KHAH	# 
+
+FD8E ;	0645 062E 062C ;	MA	# ( ‎ﶎ‎ → ‎مخج‎ ) ARABIC LIGATURE MEEM WITH KHAH WITH JEEM INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER KHAH, ARABIC LETTER JEEM	# 
+
+FD8F ;	0645 062E 0645 ;	MA	# ( ‎ﶏ‎ → ‎مخم‎ ) ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER KHAH, ARABIC LETTER MEEM	# 
+
+FDB9 ;	0645 062E 0649 ;	MA	# ( ‎ﶹ‎ → ‎مخى‎ ) ARABIC LIGATURE MEEM WITH KHAH WITH YEH FINAL FORM → ARABIC LETTER MEEM, ARABIC LETTER KHAH, ARABIC LETTER ALEF MAKSURA	# →‎مخي‎→
+
+FCD1 ;	0645 0645 ;	MA	# ( ‎ﳑ‎ → ‎مم‎ ) ARABIC LIGATURE MEEM WITH MEEM INITIAL FORM → ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+FC89 ;	0645 0645 ;	MA	# ( ‎ﲉ‎ → ‎مم‎ ) ARABIC LIGATURE MEEM WITH MEEM FINAL FORM → ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+FC48 ;	0645 0645 ;	MA	# ( ‎ﱈ‎ → ‎مم‎ ) ARABIC LIGATURE MEEM WITH MEEM ISOLATED FORM → ARABIC LETTER MEEM, ARABIC LETTER MEEM	# 
+
+FDB1 ;	0645 0645 0649 ;	MA	# ( ‎ﶱ‎ → ‎ممى‎ ) ARABIC LIGATURE MEEM WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER MEEM, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎ممي‎→
+
+FC49 ;	0645 0649 ;	MA	# ( ‎ﱉ‎ → ‎مى‎ ) ARABIC LIGATURE MEEM WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# 
+FC4A ;	0645 0649 ;	MA	# ( ‎ﱊ‎ → ‎مى‎ ) ARABIC LIGATURE MEEM WITH YEH ISOLATED FORM → ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎مي‎→
+
+06FE ;	0645 10EFA ;	MA	#* ( ‎۾‎ → ‎م𐻺‎ ) ARABIC SIGN SINDHI POSTPOSITION MEN → ARABIC LETTER MEEM, ARABIC DOUBLE VERTICAL BAR BELOW	# 
+
+1EE0D ;	0646 ;	MA	# ( ‎𞸍‎ → ‎ن‎ ) ARABIC MATHEMATICAL NOON → ARABIC LETTER NOON	# 
+1EE2D ;	0646 ;	MA	# ( ‎𞸭‎ → ‎ن‎ ) ARABIC MATHEMATICAL INITIAL NOON → ARABIC LETTER NOON	# 
+1EE4D ;	0646 ;	MA	# ( ‎𞹍‎ → ‎ن‎ ) ARABIC MATHEMATICAL TAILED NOON → ARABIC LETTER NOON	# 
+1EE6D ;	0646 ;	MA	# ( ‎𞹭‎ → ‎ن‎ ) ARABIC MATHEMATICAL STRETCHED NOON → ARABIC LETTER NOON	# 
+1EE8D ;	0646 ;	MA	# ( ‎𞺍‎ → ‎ن‎ ) ARABIC MATHEMATICAL LOOPED NOON → ARABIC LETTER NOON	# 
+1EEAD ;	0646 ;	MA	# ( ‎𞺭‎ → ‎ن‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK NOON → ARABIC LETTER NOON	# 
+FEE7 ;	0646 ;	MA	# ( ‎ﻧ‎ → ‎ن‎ ) ARABIC LETTER NOON INITIAL FORM → ARABIC LETTER NOON	# 
+FEE8 ;	0646 ;	MA	# ( ‎ﻨ‎ → ‎ن‎ ) ARABIC LETTER NOON MEDIAL FORM → ARABIC LETTER NOON	# 
+FEE6 ;	0646 ;	MA	# ( ‎ﻦ‎ → ‎ن‎ ) ARABIC LETTER NOON FINAL FORM → ARABIC LETTER NOON	# 
+FEE5 ;	0646 ;	MA	# ( ‎ﻥ‎ → ‎ن‎ ) ARABIC LETTER NOON ISOLATED FORM → ARABIC LETTER NOON	# 
+10EC6 ;	0646 ;	MA	# ( ‎𐻆‎ → ‎ن‎ ) ARABIC LETTER THIN NOON → ARABIC LETTER NOON	# 
+
+0768 ;	0646 0615 ;	MA	# ( ‎ݨ‎ → ‎نؕ‎ ) ARABIC LETTER NOON WITH SMALL TAH → ARABIC LETTER NOON, ARABIC SMALL HIGH TAH	# 
+
+0769 ;	0646 0306 ;	MA	# ( ‎ݩ‎ → ‎ن̆‎ ) ARABIC LETTER NOON WITH SMALL V → ARABIC LETTER NOON, COMBINING BREVE	# →‎نٚ‎→
+
+FCD6 ;	0646 006F ;	MA	# ( ‎ﳖ‎ → ‎نo‎ ) ARABIC LIGATURE NOON WITH HEH INITIAL FORM → ARABIC LETTER NOON, LATIN SMALL LETTER O	# →‎نه‎→
+FCEF ;	0646 006F ;	MA	# ( ‎ﳯ‎ → ‎نo‎ ) ARABIC LIGATURE NOON WITH HEH MEDIAL FORM → ARABIC LETTER NOON, LATIN SMALL LETTER O	# →‎نه‎→
+
+FDB8 ;	0646 062C 062D ;	MA	# ( ‎ﶸ‎ → ‎نجح‎ ) ARABIC LIGATURE NOON WITH JEEM WITH HAH INITIAL FORM → ARABIC LETTER NOON, ARABIC LETTER JEEM, ARABIC LETTER HAH	# 
+FDBD ;	0646 062C 062D ;	MA	# ( ‎ﶽ‎ → ‎نجح‎ ) ARABIC LIGATURE NOON WITH JEEM WITH HAH FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER JEEM, ARABIC LETTER HAH	# 
+
+FD98 ;	0646 062C 0645 ;	MA	# ( ‎ﶘ‎ → ‎نجم‎ ) ARABIC LIGATURE NOON WITH JEEM WITH MEEM INITIAL FORM → ARABIC LETTER NOON, ARABIC LETTER JEEM, ARABIC LETTER MEEM	# 
+FD97 ;	0646 062C 0645 ;	MA	# ( ‎ﶗ‎ → ‎نجم‎ ) ARABIC LIGATURE NOON WITH JEEM WITH MEEM FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER JEEM, ARABIC LETTER MEEM	# 
+
+FD99 ;	0646 062C 0649 ;	MA	# ( ‎ﶙ‎ → ‎نجى‎ ) ARABIC LIGATURE NOON WITH JEEM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# 
+FDC7 ;	0646 062C 0649 ;	MA	# ( ‎ﷇ‎ → ‎نجى‎ ) ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# →‎نجي‎→
+
+FCD3 ;	0646 062D ;	MA	# ( ‎ﳓ‎ → ‎نح‎ ) ARABIC LIGATURE NOON WITH HAH INITIAL FORM → ARABIC LETTER NOON, ARABIC LETTER HAH	# 
+FC4C ;	0646 062D ;	MA	# ( ‎ﱌ‎ → ‎نح‎ ) ARABIC LIGATURE NOON WITH HAH ISOLATED FORM → ARABIC LETTER NOON, ARABIC LETTER HAH	# 
+
+FD95 ;	0646 062D 0645 ;	MA	# ( ‎ﶕ‎ → ‎نحم‎ ) ARABIC LIGATURE NOON WITH HAH WITH MEEM INITIAL FORM → ARABIC LETTER NOON, ARABIC LETTER HAH, ARABIC LETTER MEEM	# 
+
+FD96 ;	0646 062D 0649 ;	MA	# ( ‎ﶖ‎ → ‎نحى‎ ) ARABIC LIGATURE NOON WITH HAH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# 
+FDB3 ;	0646 062D 0649 ;	MA	# ( ‎ﶳ‎ → ‎نحى‎ ) ARABIC LIGATURE NOON WITH HAH WITH YEH FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎نحي‎→
+
+FCD4 ;	0646 062E ;	MA	# ( ‎ﳔ‎ → ‎نخ‎ ) ARABIC LIGATURE NOON WITH KHAH INITIAL FORM → ARABIC LETTER NOON, ARABIC LETTER KHAH	# 
+FC4D ;	0646 062E ;	MA	# ( ‎ﱍ‎ → ‎نخ‎ ) ARABIC LIGATURE NOON WITH KHAH ISOLATED FORM → ARABIC LETTER NOON, ARABIC LETTER KHAH	# 
+
+FC8A ;	0646 0631 ;	MA	# ( ‎ﲊ‎ → ‎نر‎ ) ARABIC LIGATURE NOON WITH REH FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER REH	# 
+
+FC8B ;	0646 0632 ;	MA	# ( ‎ﲋ‎ → ‎نز‎ ) ARABIC LIGATURE NOON WITH ZAIN FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER ZAIN	# 
+
+FCD5 ;	0646 0645 ;	MA	# ( ‎ﳕ‎ → ‎نم‎ ) ARABIC LIGATURE NOON WITH MEEM INITIAL FORM → ARABIC LETTER NOON, ARABIC LETTER MEEM	# 
+FCEE ;	0646 0645 ;	MA	# ( ‎ﳮ‎ → ‎نم‎ ) ARABIC LIGATURE NOON WITH MEEM MEDIAL FORM → ARABIC LETTER NOON, ARABIC LETTER MEEM	# 
+FC8C ;	0646 0645 ;	MA	# ( ‎ﲌ‎ → ‎نم‎ ) ARABIC LIGATURE NOON WITH MEEM FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER MEEM	# 
+FC4E ;	0646 0645 ;	MA	# ( ‎ﱎ‎ → ‎نم‎ ) ARABIC LIGATURE NOON WITH MEEM ISOLATED FORM → ARABIC LETTER NOON, ARABIC LETTER MEEM	# 
+
+FD9B ;	0646 0645 0649 ;	MA	# ( ‎ﶛ‎ → ‎نمى‎ ) ARABIC LIGATURE NOON WITH MEEM WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# 
+FD9A ;	0646 0645 0649 ;	MA	# ( ‎ﶚ‎ → ‎نمى‎ ) ARABIC LIGATURE NOON WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎نمي‎→
+
+FC8D ;	0646 0646 ;	MA	# ( ‎ﲍ‎ → ‎نن‎ ) ARABIC LIGATURE NOON WITH NOON FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER NOON	# 
+
+FC8E ;	0646 0649 ;	MA	# ( ‎ﲎ‎ → ‎نى‎ ) ARABIC LIGATURE NOON WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER ALEF MAKSURA	# 
+FC4F ;	0646 0649 ;	MA	# ( ‎ﱏ‎ → ‎نى‎ ) ARABIC LIGATURE NOON WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER NOON, ARABIC LETTER ALEF MAKSURA	# 
+FC8F ;	0646 0649 ;	MA	# ( ‎ﲏ‎ → ‎نى‎ ) ARABIC LIGATURE NOON WITH YEH FINAL FORM → ARABIC LETTER NOON, ARABIC LETTER ALEF MAKSURA	# →‎ني‎→
+FC50 ;	0646 0649 ;	MA	# ( ‎ﱐ‎ → ‎نى‎ ) ARABIC LIGATURE NOON WITH YEH ISOLATED FORM → ARABIC LETTER NOON, ARABIC LETTER ALEF MAKSURA	# →‎ني‎→
+
+06C2 ;	06C0 ;	MA	# ( ‎ۂ‎ → ‎ۀ‎ ) ARABIC LETTER HEH GOAL WITH HAMZA ABOVE → ARABIC LETTER HEH WITH YEH ABOVE	# →‎ﮤ‎→
+FBA5 ;	06C0 ;	MA	# ( ‎ﮥ‎ → ‎ۀ‎ ) ARABIC LETTER HEH WITH YEH ABOVE FINAL FORM → ARABIC LETTER HEH WITH YEH ABOVE	# 
+FBA4 ;	06C0 ;	MA	# ( ‎ﮤ‎ → ‎ۀ‎ ) ARABIC LETTER HEH WITH YEH ABOVE ISOLATED FORM → ARABIC LETTER HEH WITH YEH ABOVE	# 
+
+102E4 ;	0648 ;	MA	#* ( 𐋤 → ‎و‎ ) COPTIC EPACT DIGIT FOUR → ARABIC LETTER WAW	# 
+1EE05 ;	0648 ;	MA	# ( ‎𞸅‎ → ‎و‎ ) ARABIC MATHEMATICAL WAW → ARABIC LETTER WAW	# 
+1EE85 ;	0648 ;	MA	# ( ‎𞺅‎ → ‎و‎ ) ARABIC MATHEMATICAL LOOPED WAW → ARABIC LETTER WAW	# 
+1EEA5 ;	0648 ;	MA	# ( ‎𞺥‎ → ‎و‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK WAW → ARABIC LETTER WAW	# 
+FEEE ;	0648 ;	MA	# ( ‎ﻮ‎ → ‎و‎ ) ARABIC LETTER WAW FINAL FORM → ARABIC LETTER WAW	# 
+FEED ;	0648 ;	MA	# ( ‎ﻭ‎ → ‎و‎ ) ARABIC LETTER WAW ISOLATED FORM → ARABIC LETTER WAW	# 
+08B1 ;	0648 ;	MA	# ( ‎ࢱ‎ → ‎و‎ ) ARABIC LETTER STRAIGHT WAW → ARABIC LETTER WAW	# 
+
+06CB ;	0648 06DB ;	MA	# ( ‎ۋ‎ → ‎وۛ‎ ) ARABIC LETTER VE → ARABIC LETTER WAW, ARABIC SMALL HIGH THREE DOTS	# 
+FBDF ;	0648 06DB ;	MA	# ( ‎ﯟ‎ → ‎وۛ‎ ) ARABIC LETTER VE FINAL FORM → ARABIC LETTER WAW, ARABIC SMALL HIGH THREE DOTS	# →‎ۋ‎→
+FBDE ;	0648 06DB ;	MA	# ( ‎ﯞ‎ → ‎وۛ‎ ) ARABIC LETTER VE ISOLATED FORM → ARABIC LETTER WAW, ARABIC SMALL HIGH THREE DOTS	# →‎ۋ‎→
+
+06C7 ;	0648 0313 ;	MA	# ( ‎ۇ‎ → ‎و̓‎ ) ARABIC LETTER U → ARABIC LETTER WAW, COMBINING COMMA ABOVE	# →‎وُ‎→
+FBD8 ;	0648 0313 ;	MA	# ( ‎ﯘ‎ → ‎و̓‎ ) ARABIC LETTER U FINAL FORM → ARABIC LETTER WAW, COMBINING COMMA ABOVE	# →‎ۇ‎→→‎وُ‎→
+FBD7 ;	0648 0313 ;	MA	# ( ‎ﯗ‎ → ‎و̓‎ ) ARABIC LETTER U ISOLATED FORM → ARABIC LETTER WAW, COMBINING COMMA ABOVE	# →‎ۇ‎→→‎وُ‎→
+
+06C6 ;	0648 0306 ;	MA	# ( ‎ۆ‎ → ‎و̆‎ ) ARABIC LETTER OE → ARABIC LETTER WAW, COMBINING BREVE	# →‎وٚ‎→
+FBDA ;	0648 0306 ;	MA	# ( ‎ﯚ‎ → ‎و̆‎ ) ARABIC LETTER OE FINAL FORM → ARABIC LETTER WAW, COMBINING BREVE	# →‎ۆ‎→→‎وٚ‎→
+FBD9 ;	0648 0306 ;	MA	# ( ‎ﯙ‎ → ‎و̆‎ ) ARABIC LETTER OE ISOLATED FORM → ARABIC LETTER WAW, COMBINING BREVE	# →‎ۆ‎→→‎وٚ‎→
+
+06C9 ;	0648 0302 ;	MA	# ( ‎ۉ‎ → ‎و̂‎ ) ARABIC LETTER KIRGHIZ YU → ARABIC LETTER WAW, COMBINING CIRCUMFLEX ACCENT	# →‎وٛ‎→
+FBE3 ;	0648 0302 ;	MA	# ( ‎ﯣ‎ → ‎و̂‎ ) ARABIC LETTER KIRGHIZ YU FINAL FORM → ARABIC LETTER WAW, COMBINING CIRCUMFLEX ACCENT	# →‎ۉ‎→→‎وٛ‎→
+FBE2 ;	0648 0302 ;	MA	# ( ‎ﯢ‎ → ‎و̂‎ ) ARABIC LETTER KIRGHIZ YU ISOLATED FORM → ARABIC LETTER WAW, COMBINING CIRCUMFLEX ACCENT	# →‎ۉ‎→→‎وٛ‎→
+
+06C8 ;	0648 0670 ;	MA	# ( ‎ۈ‎ → ‎وٰ‎ ) ARABIC LETTER YU → ARABIC LETTER WAW, ARABIC LETTER SUPERSCRIPT ALEF	# 
+FBDC ;	0648 0670 ;	MA	# ( ‎ﯜ‎ → ‎وٰ‎ ) ARABIC LETTER YU FINAL FORM → ARABIC LETTER WAW, ARABIC LETTER SUPERSCRIPT ALEF	# →‎ۈ‎→
+FBDB ;	0648 0670 ;	MA	# ( ‎ﯛ‎ → ‎وٰ‎ ) ARABIC LETTER YU ISOLATED FORM → ARABIC LETTER WAW, ARABIC LETTER SUPERSCRIPT ALEF	# →‎ۈ‎→
+
+0676 ;	0648 0674 ;	MA	# ( ‎ٶ‎ → ‎وٴ‎ ) ARABIC LETTER HIGH HAMZA WAW → ARABIC LETTER WAW, ARABIC LETTER HIGH HAMZA	# 
+0624 ;	0648 0674 ;	MA	# ( ‎ؤ‎ → ‎وٴ‎ ) ARABIC LETTER WAW WITH HAMZA ABOVE → ARABIC LETTER WAW, ARABIC LETTER HIGH HAMZA	# →‎ٶ‎→
+FE86 ;	0648 0674 ;	MA	# ( ‎ﺆ‎ → ‎وٴ‎ ) ARABIC LETTER WAW WITH HAMZA ABOVE FINAL FORM → ARABIC LETTER WAW, ARABIC LETTER HIGH HAMZA	# →‎ٶ‎→
+FE85 ;	0648 0674 ;	MA	# ( ‎ﺅ‎ → ‎وٴ‎ ) ARABIC LETTER WAW WITH HAMZA ABOVE ISOLATED FORM → ARABIC LETTER WAW, ARABIC LETTER HIGH HAMZA	# →‎ٶ‎→
+
+0677 ;	0648 0313 0674 ;	MA	# ( ‎ٷ‎ → ‎و̓ٴ‎ ) ARABIC LETTER U WITH HAMZA ABOVE → ARABIC LETTER WAW, COMBINING COMMA ABOVE, ARABIC LETTER HIGH HAMZA	# →‎ۇٴ‎→
+FBDD ;	0648 0313 0674 ;	MA	# ( ‎ﯝ‎ → ‎و̓ٴ‎ ) ARABIC LETTER U WITH HAMZA ABOVE ISOLATED FORM → ARABIC LETTER WAW, COMBINING COMMA ABOVE, ARABIC LETTER HIGH HAMZA	# →‎ۇٴ‎→
+
+FDF8 ;	0648 0633 0644 0645 ;	MA	# ( ‎ﷸ‎ → ‎وسلم‎ ) ARABIC LIGATURE WASALLAM ISOLATED FORM → ARABIC LETTER WAW, ARABIC LETTER SEEN, ARABIC LETTER LAM, ARABIC LETTER MEEM	# 
+
+FBE1 ;	06C5 ;	MA	# ( ‎ﯡ‎ → ‎ۅ‎ ) ARABIC LETTER KIRGHIZ OE FINAL FORM → ARABIC LETTER KIRGHIZ OE	# 
+FBE0 ;	06C5 ;	MA	# ( ‎ﯠ‎ → ‎ۅ‎ ) ARABIC LETTER KIRGHIZ OE ISOLATED FORM → ARABIC LETTER KIRGHIZ OE	# 
+
+066E ;	0649 ;	MA	# ( ‎ٮ‎ → ‎ى‎ ) ARABIC LETTER DOTLESS BEH → ARABIC LETTER ALEF MAKSURA	# 
+1EE1C ;	0649 ;	MA	# ( ‎𞸜‎ → ‎ى‎ ) ARABIC MATHEMATICAL DOTLESS BEH → ARABIC LETTER ALEF MAKSURA	# →‎ٮ‎→
+1EE7C ;	0649 ;	MA	# ( ‎𞹼‎ → ‎ى‎ ) ARABIC MATHEMATICAL STRETCHED DOTLESS BEH → ARABIC LETTER ALEF MAKSURA	# →‎ٮ‎→
+06BA ;	0649 ;	MA	# ( ‎ں‎ → ‎ى‎ ) ARABIC LETTER NOON GHUNNA → ARABIC LETTER ALEF MAKSURA	# 
+1EE1D ;	0649 ;	MA	# ( ‎𞸝‎ → ‎ى‎ ) ARABIC MATHEMATICAL DOTLESS NOON → ARABIC LETTER ALEF MAKSURA	# →‎ں‎→
+1EE5D ;	0649 ;	MA	# ( ‎𞹝‎ → ‎ى‎ ) ARABIC MATHEMATICAL TAILED DOTLESS NOON → ARABIC LETTER ALEF MAKSURA	# →‎ں‎→
+FB9F ;	0649 ;	MA	# ( ‎ﮟ‎ → ‎ى‎ ) ARABIC LETTER NOON GHUNNA FINAL FORM → ARABIC LETTER ALEF MAKSURA	# →‎ں‎→
+FB9E ;	0649 ;	MA	# ( ‎ﮞ‎ → ‎ى‎ ) ARABIC LETTER NOON GHUNNA ISOLATED FORM → ARABIC LETTER ALEF MAKSURA	# →‎ں‎→
+08BD ;	0649 ;	MA	# ( ‎ࢽ‎ → ‎ى‎ ) ARABIC LETTER AFRICAN NOON → ARABIC LETTER ALEF MAKSURA	# →‎ں‎→
+FBE8 ;	0649 ;	MA	# ( ‎ﯨ‎ → ‎ى‎ ) ARABIC LETTER UIGHUR KAZAKH KIRGHIZ ALEF MAKSURA INITIAL FORM → ARABIC LETTER ALEF MAKSURA	# 
+FBE9 ;	0649 ;	MA	# ( ‎ﯩ‎ → ‎ى‎ ) ARABIC LETTER UIGHUR KAZAKH KIRGHIZ ALEF MAKSURA MEDIAL FORM → ARABIC LETTER ALEF MAKSURA	# 
+FEF0 ;	0649 ;	MA	# ( ‎ﻰ‎ → ‎ى‎ ) ARABIC LETTER ALEF MAKSURA FINAL FORM → ARABIC LETTER ALEF MAKSURA	# 
+FEEF ;	0649 ;	MA	# ( ‎ﻯ‎ → ‎ى‎ ) ARABIC LETTER ALEF MAKSURA ISOLATED FORM → ARABIC LETTER ALEF MAKSURA	# 
+064A ;	0649 ;	MA	# ( ‎ي‎ → ‎ى‎ ) ARABIC LETTER YEH → ARABIC LETTER ALEF MAKSURA	# 
+1EE09 ;	0649 ;	MA	# ( ‎𞸉‎ → ‎ى‎ ) ARABIC MATHEMATICAL YEH → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+1EE29 ;	0649 ;	MA	# ( ‎𞸩‎ → ‎ى‎ ) ARABIC MATHEMATICAL INITIAL YEH → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+1EE49 ;	0649 ;	MA	# ( ‎𞹉‎ → ‎ى‎ ) ARABIC MATHEMATICAL TAILED YEH → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+1EE69 ;	0649 ;	MA	# ( ‎𞹩‎ → ‎ى‎ ) ARABIC MATHEMATICAL STRETCHED YEH → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+1EE89 ;	0649 ;	MA	# ( ‎𞺉‎ → ‎ى‎ ) ARABIC MATHEMATICAL LOOPED YEH → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+1EEA9 ;	0649 ;	MA	# ( ‎𞺩‎ → ‎ى‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK YEH → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+FEF3 ;	0649 ;	MA	# ( ‎ﻳ‎ → ‎ى‎ ) ARABIC LETTER YEH INITIAL FORM → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+FEF4 ;	0649 ;	MA	# ( ‎ﻴ‎ → ‎ى‎ ) ARABIC LETTER YEH MEDIAL FORM → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+FEF2 ;	0649 ;	MA	# ( ‎ﻲ‎ → ‎ى‎ ) ARABIC LETTER YEH FINAL FORM → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+FEF1 ;	0649 ;	MA	# ( ‎ﻱ‎ → ‎ى‎ ) ARABIC LETTER YEH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+06CC ;	0649 ;	MA	# ( ‎ی‎ → ‎ى‎ ) ARABIC LETTER FARSI YEH → ARABIC LETTER ALEF MAKSURA	# 
+FBFE ;	0649 ;	MA	# ( ‎ﯾ‎ → ‎ى‎ ) ARABIC LETTER FARSI YEH INITIAL FORM → ARABIC LETTER ALEF MAKSURA	# →‎ی‎→
+FBFF ;	0649 ;	MA	# ( ‎ﯿ‎ → ‎ى‎ ) ARABIC LETTER FARSI YEH MEDIAL FORM → ARABIC LETTER ALEF MAKSURA	# →‎ی‎→
+FBFD ;	0649 ;	MA	# ( ‎ﯽ‎ → ‎ى‎ ) ARABIC LETTER FARSI YEH FINAL FORM → ARABIC LETTER ALEF MAKSURA	# →‎ﻰ‎→
+FBFC ;	0649 ;	MA	# ( ‎ﯼ‎ → ‎ى‎ ) ARABIC LETTER FARSI YEH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA	# 
+06D2 ;	0649 ;	MA	# ( ‎ے‎ → ‎ى‎ ) ARABIC LETTER YEH BARREE → ARABIC LETTER ALEF MAKSURA	# →‎ي‎→
+FBAF ;	0649 ;	MA	# ( ‎ﮯ‎ → ‎ى‎ ) ARABIC LETTER YEH BARREE FINAL FORM → ARABIC LETTER ALEF MAKSURA	# →‎ے‎→→‎ي‎→
+FBAE ;	0649 ;	MA	# ( ‎ﮮ‎ → ‎ى‎ ) ARABIC LETTER YEH BARREE ISOLATED FORM → ARABIC LETTER ALEF MAKSURA	# →‎ے‎→→‎ي‎→
+
+0679 ;	0649 0615 ;	MA	# ( ‎ٹ‎ → ‎ىؕ‎ ) ARABIC LETTER TTEH → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH	# →‎ٮؕ‎→
+FB68 ;	0649 0615 ;	MA	# ( ‎ﭨ‎ → ‎ىؕ‎ ) ARABIC LETTER TTEH INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH	# →‎ٹ‎→→‎ٮؕ‎→
+FB69 ;	0649 0615 ;	MA	# ( ‎ﭩ‎ → ‎ىؕ‎ ) ARABIC LETTER TTEH MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH	# →‎ٹ‎→→‎ٮؕ‎→
+FB67 ;	0649 0615 ;	MA	# ( ‎ﭧ‎ → ‎ىؕ‎ ) ARABIC LETTER TTEH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH	# →‎ٹ‎→→‎ٮؕ‎→
+FB66 ;	0649 0615 ;	MA	# ( ‎ﭦ‎ → ‎ىؕ‎ ) ARABIC LETTER TTEH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH	# →‎ٹ‎→→‎ٮؕ‎→
+06BB ;	0649 0615 ;	MA	# ( ‎ڻ‎ → ‎ىؕ‎ ) ARABIC LETTER RNOON → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH	# →‎ںؕ‎→
+FBA2 ;	0649 0615 ;	MA	# ( ‎ﮢ‎ → ‎ىؕ‎ ) ARABIC LETTER RNOON INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH	# →‎ڻ‎→→‎ںؕ‎→
+FBA3 ;	0649 0615 ;	MA	# ( ‎ﮣ‎ → ‎ىؕ‎ ) ARABIC LETTER RNOON MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH	# →‎ڻ‎→→‎ںؕ‎→
+FBA1 ;	0649 0615 ;	MA	# ( ‎ﮡ‎ → ‎ىؕ‎ ) ARABIC LETTER RNOON FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH	# →‎ڻ‎→→‎ںؕ‎→
+FBA0 ;	0649 0615 ;	MA	# ( ‎ﮠ‎ → ‎ىؕ‎ ) ARABIC LETTER RNOON ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH	# →‎ڻ‎→→‎ںؕ‎→
+
+067E ;	0649 06DB ;	MA	# ( ‎پ‎ → ‎ىۛ‎ ) ARABIC LETTER PEH → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ڽ‎→→‎ںۛ‎→
+FB58 ;	0649 06DB ;	MA	# ( ‎ﭘ‎ → ‎ىۛ‎ ) ARABIC LETTER PEH INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎پ‎→→‎ڽ‎→→‎ںۛ‎→
+FB59 ;	0649 06DB ;	MA	# ( ‎ﭙ‎ → ‎ىۛ‎ ) ARABIC LETTER PEH MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎پ‎→→‎ڽ‎→→‎ںۛ‎→
+FB57 ;	0649 06DB ;	MA	# ( ‎ﭗ‎ → ‎ىۛ‎ ) ARABIC LETTER PEH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎پ‎→→‎ڽ‎→→‎ںۛ‎→
+FB56 ;	0649 06DB ;	MA	# ( ‎ﭖ‎ → ‎ىۛ‎ ) ARABIC LETTER PEH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎پ‎→→‎ڽ‎→→‎ںۛ‎→
+0752 ;	0649 06DB ;	MA	# ( ‎ݒ‎ → ‎ىۛ‎ ) ARABIC LETTER BEH WITH THREE DOTS POINTING UPWARDS BELOW → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎پ‎→→‎ڽ‎→→‎ںۛ‎→
+062B ;	0649 06DB ;	MA	# ( ‎ث‎ → ‎ىۛ‎ ) ARABIC LETTER THEH → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ٮۛ‎→
+1EE16 ;	0649 06DB ;	MA	# ( ‎𞸖‎ → ‎ىۛ‎ ) ARABIC MATHEMATICAL THEH → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ث‎→→‎ٮۛ‎→
+1EE36 ;	0649 06DB ;	MA	# ( ‎𞸶‎ → ‎ىۛ‎ ) ARABIC MATHEMATICAL INITIAL THEH → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ث‎→→‎ٮۛ‎→
+1EE76 ;	0649 06DB ;	MA	# ( ‎𞹶‎ → ‎ىۛ‎ ) ARABIC MATHEMATICAL STRETCHED THEH → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ث‎→→‎ٮۛ‎→
+1EE96 ;	0649 06DB ;	MA	# ( ‎𞺖‎ → ‎ىۛ‎ ) ARABIC MATHEMATICAL LOOPED THEH → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ث‎→→‎ٮۛ‎→
+1EEB6 ;	0649 06DB ;	MA	# ( ‎𞺶‎ → ‎ىۛ‎ ) ARABIC MATHEMATICAL DOUBLE-STRUCK THEH → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ث‎→→‎ٮۛ‎→
+FE9B ;	0649 06DB ;	MA	# ( ‎ﺛ‎ → ‎ىۛ‎ ) ARABIC LETTER THEH INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ث‎→→‎ٮۛ‎→
+FE9C ;	0649 06DB ;	MA	# ( ‎ﺜ‎ → ‎ىۛ‎ ) ARABIC LETTER THEH MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ث‎→→‎ٮۛ‎→
+FE9A ;	0649 06DB ;	MA	# ( ‎ﺚ‎ → ‎ىۛ‎ ) ARABIC LETTER THEH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ث‎→→‎ٮۛ‎→
+FE99 ;	0649 06DB ;	MA	# ( ‎ﺙ‎ → ‎ىۛ‎ ) ARABIC LETTER THEH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ث‎→→‎ٮۛ‎→
+06BD ;	0649 06DB ;	MA	# ( ‎ڽ‎ → ‎ىۛ‎ ) ARABIC LETTER NOON WITH THREE DOTS ABOVE → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎ںۛ‎→
+06D1 ;	0649 06DB ;	MA	# ( ‎ۑ‎ → ‎ىۛ‎ ) ARABIC LETTER YEH WITH THREE DOTS BELOW → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎پ‎→→‎ڽ‎→→‎ںۛ‎→
+063F ;	0649 06DB ;	MA	# ( ‎ؿ‎ → ‎ىۛ‎ ) ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS	# →‎یۛ‎→
+
+08B7 ;	0649 06DB 06E2 ;	MA	# ( ‎ࢷ‎ → ‎ىۛۢ‎ ) ARABIC LETTER PEH WITH SMALL MEEM ABOVE → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC SMALL HIGH MEEM ISOLATED FORM	# →‎پۢ‎→
+
+0756 ;	0649 0306 ;	MA	# ( ‎ݖ‎ → ‎ى̆‎ ) ARABIC LETTER BEH WITH SMALL V → ARABIC LETTER ALEF MAKSURA, COMBINING BREVE	# →‎ٮٚ‎→
+06CE ;	0649 0306 ;	MA	# ( ‎ێ‎ → ‎ى̆‎ ) ARABIC LETTER YEH WITH SMALL V → ARABIC LETTER ALEF MAKSURA, COMBINING BREVE	# →‎یٚ‎→
+
+08C0 ;	0649 0615 0306 ;	MA	# ( ‎ࣀ‎ → ‎ىؕ̆‎ ) ARABIC LETTER TTEH WITH SMALL V → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH TAH, COMBINING BREVE	# →‎ٹٚ‎→
+
+08BE ;	0649 06DB 0306 ;	MA	# ( ‎ࢾ‎ → ‎ىۛ̆‎ ) ARABIC LETTER PEH WITH SMALL V → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, COMBINING BREVE	# →‎پٚ‎→
+
+08BA ;	0649 0306 0307 ;	MA	# ( ‎ࢺ‎ → ‎ى̆̇‎ ) ARABIC LETTER YEH WITH TWO DOTS BELOW AND SMALL NOON ABOVE → ARABIC LETTER ALEF MAKSURA, COMBINING BREVE, COMBINING DOT ABOVE	# →‎يۨ‎→
+
+063D ;	0649 0302 ;	MA	# ( ‎ؽ‎ → ‎ى̂‎ ) ARABIC LETTER FARSI YEH WITH INVERTED V → ARABIC LETTER ALEF MAKSURA, COMBINING CIRCUMFLEX ACCENT	# →‎یٛ‎→
+
+088F ;	0649 030A ;	MA	# ( ‎࢏‎ → ‎ى̊‎ ) ARABIC LETTER NOON WITH RING ABOVE → ARABIC LETTER ALEF MAKSURA, COMBINING RING ABOVE	# →‎ں̊‎→
+
+08A8 ;	0649 0654 ;	MA	# ( ‎ࢨ‎ → ‎ىٔ‎ ) ARABIC LETTER YEH WITH TWO DOTS BELOW AND HAMZA ABOVE → ARABIC LETTER ALEF MAKSURA, ARABIC HAMZA ABOVE	# →‎ئ‎→
+
+FC90 ;	0649 0670 ;	MA	# ( ‎ﲐ‎ → ‎ىٰ‎ ) ARABIC LIGATURE ALEF MAKSURA WITH SUPERSCRIPT ALEF FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER SUPERSCRIPT ALEF	# 
+FC5D ;	0649 0670 ;	MA	# ( ‎ﱝ‎ → ‎ىٰ‎ ) ARABIC LIGATURE ALEF MAKSURA WITH SUPERSCRIPT ALEF ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER SUPERSCRIPT ALEF	# 
+
+FCDE ;	0649 006F ;	MA	# ( ‎ﳞ‎ → ‎ىo‎ ) ARABIC LIGATURE YEH WITH HEH INITIAL FORM → ARABIC LETTER ALEF MAKSURA, LATIN SMALL LETTER O	# →‎يه‎→
+FCF1 ;	0649 006F ;	MA	# ( ‎ﳱ‎ → ‎ىo‎ ) ARABIC LIGATURE YEH WITH HEH MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, LATIN SMALL LETTER O	# →‎يه‎→
+
+FCE6 ;	0649 06DB 006F ;	MA	# ( ‎ﳦ‎ → ‎ىۛo‎ ) ARABIC LIGATURE THEH WITH HEH MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, LATIN SMALL LETTER O	# →‎ثه‎→
+
+0678 ;	0649 0674 ;	MA	# ( ‎ٸ‎ → ‎ىٴ‎ ) ARABIC LETTER HIGH HAMZA YEH → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA	# →‎يٴ‎→
+0626 ;	0649 0674 ;	MA	# ( ‎ئ‎ → ‎ىٴ‎ ) ARABIC LETTER YEH WITH HAMZA ABOVE → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA	# →‎ٸ‎→→‎يٴ‎→
+FE8B ;	0649 0674 ;	MA	# ( ‎ﺋ‎ → ‎ىٴ‎ ) ARABIC LETTER YEH WITH HAMZA ABOVE INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA	# →‎ئ‎→→‎ٸ‎→→‎يٴ‎→
+FE8C ;	0649 0674 ;	MA	# ( ‎ﺌ‎ → ‎ىٴ‎ ) ARABIC LETTER YEH WITH HAMZA ABOVE MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA	# →‎ئ‎→→‎ٸ‎→→‎يٴ‎→
+FE8A ;	0649 0674 ;	MA	# ( ‎ﺊ‎ → ‎ىٴ‎ ) ARABIC LETTER YEH WITH HAMZA ABOVE FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA	# →‎ئ‎→→‎ٸ‎→→‎يٴ‎→
+FE89 ;	0649 0674 ;	MA	# ( ‎ﺉ‎ → ‎ىٴ‎ ) ARABIC LETTER YEH WITH HAMZA ABOVE ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA	# →‎ٸ‎→→‎يٴ‎→
+
+FBEB ;	0649 0674 006C ;	MA	# ( ‎ﯫ‎ → ‎ىٴl‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, LATIN SMALL LETTER L	# →‎ئا‎→
+FBEA ;	0649 0674 006C ;	MA	# ( ‎ﯪ‎ → ‎ىٴl‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, LATIN SMALL LETTER L	# →‎ئا‎→
+
+FC9B ;	0649 0674 006F ;	MA	# ( ‎ﲛ‎ → ‎ىٴo‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HEH INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, LATIN SMALL LETTER O	# →‎ئه‎→
+FCE0 ;	0649 0674 006F ;	MA	# ( ‎ﳠ‎ → ‎ىٴo‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HEH MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, LATIN SMALL LETTER O	# →‎ئه‎→
+FBED ;	0649 0674 006F ;	MA	# ( ‎ﯭ‎ → ‎ىٴo‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH AE FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, LATIN SMALL LETTER O	# →‎ئە‎→→‎ٴىo‎→→‎ئه‎→
+FBEC ;	0649 0674 006F ;	MA	# ( ‎ﯬ‎ → ‎ىٴo‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH AE ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, LATIN SMALL LETTER O	# →‎ئە‎→→‎ٴىo‎→→‎ئه‎→
+
+FBF8 ;	0649 0674 067B ;	MA	# ( ‎ﯸ‎ → ‎ىٴٻ‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER BEEH	# →‎ئې‎→
+FBF7 ;	0649 0674 067B ;	MA	# ( ‎ﯷ‎ → ‎ىٴٻ‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER BEEH	# →‎ئې‎→
+FBF6 ;	0649 0674 067B ;	MA	# ( ‎ﯶ‎ → ‎ىٴٻ‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER BEEH	# →‎ئې‎→
+
+FC97 ;	0649 0674 062C ;	MA	# ( ‎ﲗ‎ → ‎ىٴج‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH JEEM INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER JEEM	# →‎ئج‎→
+FC00 ;	0649 0674 062C ;	MA	# ( ‎ﰀ‎ → ‎ىٴج‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH JEEM ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER JEEM	# →‎ئج‎→
+
+FC98 ;	0649 0674 062D ;	MA	# ( ‎ﲘ‎ → ‎ىٴح‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HAH INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER HAH	# →‎ئح‎→
+FC01 ;	0649 0674 062D ;	MA	# ( ‎ﰁ‎ → ‎ىٴح‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HAH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER HAH	# →‎ئح‎→
+
+FC99 ;	0649 0674 062E ;	MA	# ( ‎ﲙ‎ → ‎ىٴخ‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH KHAH INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER KHAH	# →‎ئخ‎→
+
+FC64 ;	0649 0674 0631 ;	MA	# ( ‎ﱤ‎ → ‎ىٴر‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH REH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER REH	# →‎ئر‎→
+
+FC65 ;	0649 0674 0632 ;	MA	# ( ‎ﱥ‎ → ‎ىٴز‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ZAIN FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER ZAIN	# →‎ئز‎→
+
+FC9A ;	0649 0674 0645 ;	MA	# ( ‎ﲚ‎ → ‎ىٴم‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER MEEM	# →‎ئم‎→
+FCDF ;	0649 0674 0645 ;	MA	# ( ‎ﳟ‎ → ‎ىٴم‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER MEEM	# →‎ئم‎→
+FC66 ;	0649 0674 0645 ;	MA	# ( ‎ﱦ‎ → ‎ىٴم‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER MEEM	# →‎ئم‎→
+FC02 ;	0649 0674 0645 ;	MA	# ( ‎ﰂ‎ → ‎ىٴم‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER MEEM	# →‎ئم‎→
+
+FC67 ;	0649 0674 0646 ;	MA	# ( ‎ﱧ‎ → ‎ىٴن‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH NOON FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER NOON	# →‎ئن‎→
+
+FBEF ;	0649 0674 0648 ;	MA	# ( ‎ﯯ‎ → ‎ىٴو‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH WAW FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER WAW	# →‎ئو‎→
+FBEE ;	0649 0674 0648 ;	MA	# ( ‎ﯮ‎ → ‎ىٴو‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH WAW ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER WAW	# →‎ئو‎→
+
+FBF1 ;	0649 0674 0648 0313 ;	MA	# ( ‎ﯱ‎ → ‎ىٴو̓‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH U FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER WAW, COMBINING COMMA ABOVE	# →‎ئۇ‎→
+FBF0 ;	0649 0674 0648 0313 ;	MA	# ( ‎ﯰ‎ → ‎ىٴو̓‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH U ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER WAW, COMBINING COMMA ABOVE	# →‎ئۇ‎→
+
+FBF3 ;	0649 0674 0648 0306 ;	MA	# ( ‎ﯳ‎ → ‎ىٴو̆‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH OE FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER WAW, COMBINING BREVE	# →‎ئۆ‎→
+FBF2 ;	0649 0674 0648 0306 ;	MA	# ( ‎ﯲ‎ → ‎ىٴو̆‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH OE ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER WAW, COMBINING BREVE	# →‎ئۆ‎→
+
+FBF5 ;	0649 0674 0648 0670 ;	MA	# ( ‎ﯵ‎ → ‎ىٴوٰ‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YU FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER WAW, ARABIC LETTER SUPERSCRIPT ALEF	# →‎ئۈ‎→
+FBF4 ;	0649 0674 0648 0670 ;	MA	# ( ‎ﯴ‎ → ‎ىٴوٰ‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YU ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER WAW, ARABIC LETTER SUPERSCRIPT ALEF	# →‎ئۈ‎→
+
+FBFB ;	0649 0674 0649 ;	MA	# ( ‎ﯻ‎ → ‎ىٴى‎ ) ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER ALEF MAKSURA	# →‎ئى‎→
+FBFA ;	0649 0674 0649 ;	MA	# ( ‎ﯺ‎ → ‎ىٴى‎ ) ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER ALEF MAKSURA	# →‎ئى‎→
+FC68 ;	0649 0674 0649 ;	MA	# ( ‎ﱨ‎ → ‎ىٴى‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER ALEF MAKSURA	# →‎ئى‎→
+FBF9 ;	0649 0674 0649 ;	MA	# ( ‎ﯹ‎ → ‎ىٴى‎ ) ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER ALEF MAKSURA	# →‎ئى‎→
+FC03 ;	0649 0674 0649 ;	MA	# ( ‎ﰃ‎ → ‎ىٴى‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER ALEF MAKSURA	# →‎ئى‎→
+FC69 ;	0649 0674 0649 ;	MA	# ( ‎ﱩ‎ → ‎ىٴى‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YEH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER ALEF MAKSURA	# →‎ئي‎→→‎ٴىى‎→→‎ئى‎→
+FC04 ;	0649 0674 0649 ;	MA	# ( ‎ﰄ‎ → ‎ىٴى‎ ) ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YEH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HIGH HAMZA, ARABIC LETTER ALEF MAKSURA	# →‎ئي‎→→‎ٴىى‎→→‎ئى‎→
+
+FCDA ;	0649 062C ;	MA	# ( ‎ﳚ‎ → ‎ىج‎ ) ARABIC LIGATURE YEH WITH JEEM INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER JEEM	# →‎يج‎→
+FC55 ;	0649 062C ;	MA	# ( ‎ﱕ‎ → ‎ىج‎ ) ARABIC LIGATURE YEH WITH JEEM ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER JEEM	# →‎يج‎→
+
+FC11 ;	0649 06DB 062C ;	MA	# ( ‎ﰑ‎ → ‎ىۛج‎ ) ARABIC LIGATURE THEH WITH JEEM ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER JEEM	# →‎ثج‎→
+
+FDAF ;	0649 062C 0649 ;	MA	# ( ‎ﶯ‎ → ‎ىجى‎ ) ARABIC LIGATURE YEH WITH JEEM WITH YEH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER JEEM, ARABIC LETTER ALEF MAKSURA	# →‎يجي‎→
+
+FCDB ;	0649 062D ;	MA	# ( ‎ﳛ‎ → ‎ىح‎ ) ARABIC LIGATURE YEH WITH HAH INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HAH	# →‎يح‎→
+FC56 ;	0649 062D ;	MA	# ( ‎ﱖ‎ → ‎ىح‎ ) ARABIC LIGATURE YEH WITH HAH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HAH	# →‎يح‎→
+
+FDAE ;	0649 062D 0649 ;	MA	# ( ‎ﶮ‎ → ‎ىحى‎ ) ARABIC LIGATURE YEH WITH HAH WITH YEH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER HAH, ARABIC LETTER ALEF MAKSURA	# →‎يحي‎→
+
+FCDC ;	0649 062E ;	MA	# ( ‎ﳜ‎ → ‎ىخ‎ ) ARABIC LIGATURE YEH WITH KHAH INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER KHAH	# →‎يخ‎→
+FC57 ;	0649 062E ;	MA	# ( ‎ﱗ‎ → ‎ىخ‎ ) ARABIC LIGATURE YEH WITH KHAH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER KHAH	# →‎يخ‎→
+
+FC91 ;	0649 0631 ;	MA	# ( ‎ﲑ‎ → ‎ىر‎ ) ARABIC LIGATURE YEH WITH REH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER REH	# →‎ير‎→
+
+FC76 ;	0649 06DB 0631 ;	MA	# ( ‎ﱶ‎ → ‎ىۛر‎ ) ARABIC LIGATURE THEH WITH REH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER REH	# →‎ثر‎→
+
+FC92 ;	0649 0632 ;	MA	# ( ‎ﲒ‎ → ‎ىز‎ ) ARABIC LIGATURE YEH WITH ZAIN FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER ZAIN	# →‎يز‎→
+
+FC77 ;	0649 06DB 0632 ;	MA	# ( ‎ﱷ‎ → ‎ىۛز‎ ) ARABIC LIGATURE THEH WITH ZAIN FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER ZAIN	# →‎ثز‎→
+
+FCDD ;	0649 0645 ;	MA	# ( ‎ﳝ‎ → ‎ىم‎ ) ARABIC LIGATURE YEH WITH MEEM INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER MEEM	# →‎يم‎→
+FCF0 ;	0649 0645 ;	MA	# ( ‎ﳰ‎ → ‎ىم‎ ) ARABIC LIGATURE YEH WITH MEEM MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER MEEM	# →‎يم‎→
+FC93 ;	0649 0645 ;	MA	# ( ‎ﲓ‎ → ‎ىم‎ ) ARABIC LIGATURE YEH WITH MEEM FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER MEEM	# →‎يم‎→
+FC58 ;	0649 0645 ;	MA	# ( ‎ﱘ‎ → ‎ىم‎ ) ARABIC LIGATURE YEH WITH MEEM ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER MEEM	# →‎يم‎→
+
+FCA6 ;	0649 06DB 0645 ;	MA	# ( ‎ﲦ‎ → ‎ىۛم‎ ) ARABIC LIGATURE THEH WITH MEEM INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM	# →‎ثم‎→
+FCE5 ;	0649 06DB 0645 ;	MA	# ( ‎ﳥ‎ → ‎ىۛم‎ ) ARABIC LIGATURE THEH WITH MEEM MEDIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM	# →‎ثم‎→
+FC78 ;	0649 06DB 0645 ;	MA	# ( ‎ﱸ‎ → ‎ىۛم‎ ) ARABIC LIGATURE THEH WITH MEEM FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM	# →‎ثم‎→
+FC12 ;	0649 06DB 0645 ;	MA	# ( ‎ﰒ‎ → ‎ىۛم‎ ) ARABIC LIGATURE THEH WITH MEEM ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER MEEM	# →‎ثم‎→
+
+FD9D ;	0649 0645 0645 ;	MA	# ( ‎ﶝ‎ → ‎ىمم‎ ) ARABIC LIGATURE YEH WITH MEEM WITH MEEM INITIAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# →‎يمم‎→
+FD9C ;	0649 0645 0645 ;	MA	# ( ‎ﶜ‎ → ‎ىمم‎ ) ARABIC LIGATURE YEH WITH MEEM WITH MEEM FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER MEEM, ARABIC LETTER MEEM	# →‎يمم‎→
+
+FDB0 ;	0649 0645 0649 ;	MA	# ( ‎ﶰ‎ → ‎ىمى‎ ) ARABIC LIGATURE YEH WITH MEEM WITH YEH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER MEEM, ARABIC LETTER ALEF MAKSURA	# →‎يمي‎→
+
+FC94 ;	0649 0646 ;	MA	# ( ‎ﲔ‎ → ‎ىن‎ ) ARABIC LIGATURE YEH WITH NOON FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER NOON	# →‎ين‎→
+
+FC79 ;	0649 06DB 0646 ;	MA	# ( ‎ﱹ‎ → ‎ىۛن‎ ) ARABIC LIGATURE THEH WITH NOON FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER NOON	# →‎ثن‎→
+
+FC95 ;	0649 0649 ;	MA	# ( ‎ﲕ‎ → ‎ىى‎ ) ARABIC LIGATURE YEH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER ALEF MAKSURA	# →‎يى‎→
+FC59 ;	0649 0649 ;	MA	# ( ‎ﱙ‎ → ‎ىى‎ ) ARABIC LIGATURE YEH WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER ALEF MAKSURA	# →‎يى‎→
+FC96 ;	0649 0649 ;	MA	# ( ‎ﲖ‎ → ‎ىى‎ ) ARABIC LIGATURE YEH WITH YEH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER ALEF MAKSURA	# →‎يي‎→
+FC5A ;	0649 0649 ;	MA	# ( ‎ﱚ‎ → ‎ىى‎ ) ARABIC LIGATURE YEH WITH YEH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC LETTER ALEF MAKSURA	# →‎يي‎→
+
+FC7A ;	0649 06DB 0649 ;	MA	# ( ‎ﱺ‎ → ‎ىۛى‎ ) ARABIC LIGATURE THEH WITH ALEF MAKSURA FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER ALEF MAKSURA	# →‎ثى‎→
+FC13 ;	0649 06DB 0649 ;	MA	# ( ‎ﰓ‎ → ‎ىۛى‎ ) ARABIC LIGATURE THEH WITH ALEF MAKSURA ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER ALEF MAKSURA	# →‎ثى‎→
+FC7B ;	0649 06DB 0649 ;	MA	# ( ‎ﱻ‎ → ‎ىۛى‎ ) ARABIC LIGATURE THEH WITH YEH FINAL FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER ALEF MAKSURA	# →‎ثي‎→
+FC14 ;	0649 06DB 0649 ;	MA	# ( ‎ﰔ‎ → ‎ىۛى‎ ) ARABIC LIGATURE THEH WITH YEH ISOLATED FORM → ARABIC LETTER ALEF MAKSURA, ARABIC SMALL HIGH THREE DOTS, ARABIC LETTER ALEF MAKSURA	# →‎ثي‎→
+
+FBB1 ;	06D3 ;	MA	# ( ‎ﮱ‎ → ‎ۓ‎ ) ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM → ARABIC LETTER YEH BARREE WITH HAMZA ABOVE	# 
+FBB0 ;	06D3 ;	MA	# ( ‎ﮰ‎ → ‎ۓ‎ ) ARABIC LETTER YEH BARREE WITH HAMZA ABOVE ISOLATED FORM → ARABIC LETTER YEH BARREE WITH HAMZA ABOVE	# 
+
+102B8 ;	2D40 ;	MA	# ( 𐊸 → ⵀ ) CARIAN LETTER SS → TIFINAGH LETTER YAH	# 
+
+205E ;	2D42 ;	MA	#* ( ⁞ → ⵂ ) VERTICAL FOUR DOTS → TIFINAGH LETTER TUAREG YAH	# 
+2E3D ;	2D42 ;	MA	#* ( ⸽ → ⵂ ) VERTICAL SIX DOTS → TIFINAGH LETTER TUAREG YAH	# →⁞→
+2999 ;	2D42 ;	MA	#* ( ⦙ → ⵂ ) DOTTED FENCE → TIFINAGH LETTER TUAREG YAH	# →⁞→
+1CEEF ;	2D42 ;	MA	#* ( 𜻯 → ⵂ ) GEOMANTIC FIGURE VIA → TIFINAGH LETTER TUAREG YAH	# →⁞→
+
+FE19 ;	2D57 ;	MA	#* ( ︙ → ⵗ ) PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS → TIFINAGH LETTER TUAREG YAGH	# →⁝→
+205D ;	2D57 ;	MA	#* ( ⁝ → ⵗ ) TRICOLON → TIFINAGH LETTER TUAREG YAGH	# 
+22EE ;	2D57 ;	MA	#* ( ⋮ → ⵗ ) VERTICAL ELLIPSIS → TIFINAGH LETTER TUAREG YAGH	# →︙→→⁝→
+
+0544 ;	1206 ;	MA	# ( Մ → ሆ ) ARMENIAN CAPITAL LETTER MEN → ETHIOPIC SYLLABLE HO	# 
+
+054C ;	1261 ;	MA	# ( Ռ → ቡ ) ARMENIAN CAPITAL LETTER RA → ETHIOPIC SYLLABLE BU	# 
+
+053B ;	12AE ;	MA	# ( Ի → ኮ ) ARMENIAN CAPITAL LETTER INI → ETHIOPIC SYLLABLE KO	# 
+
+054A ;	1323 ;	MA	# ( Պ → ጣ ) ARMENIAN CAPITAL LETTER PEH → ETHIOPIC SYLLABLE THAA	# 
+
+0972 ;	0905 0306 ;	MA	# ( ॲ → अ̆ ) DEVANAGARI LETTER CANDRA A → DEVANAGARI LETTER A, COMBINING BREVE	# →अॅ→
+
+0906 ;	0905 093E ;	MA	# ( आ → अा ) DEVANAGARI LETTER AA → DEVANAGARI LETTER A, DEVANAGARI VOWEL SIGN AA	# 
+
+0911 ;	0905 093E 0306 ;	MA	# ( ऑ → अा̆ ) DEVANAGARI LETTER CANDRA O → DEVANAGARI LETTER A, DEVANAGARI VOWEL SIGN AA, COMBINING BREVE	# →अॉ→
+
+0974 ;	0905 093E 093A ;	MA	# ( ॴ → अाऺ ) DEVANAGARI LETTER OOE → DEVANAGARI LETTER A, DEVANAGARI VOWEL SIGN AA, DEVANAGARI VOWEL SIGN OE	# →अऻ→
+
+0912 ;	0905 093E 0946 ;	MA	# ( ऒ → अाॆ ) DEVANAGARI LETTER SHORT O → DEVANAGARI LETTER A, DEVANAGARI VOWEL SIGN AA, DEVANAGARI VOWEL SIGN SHORT E	# →अॊ→→आॆ→
+
+0914 ;	0905 093E 0948 ;	MA	# ( औ → अाै ) DEVANAGARI LETTER AU → DEVANAGARI LETTER A, DEVANAGARI VOWEL SIGN AA, DEVANAGARI VOWEL SIGN AI	# →अौ→→आै→
+
+0913 ;	0905 093E 11B64 ;	MA	# ( ओ → अा𑭤 ) DEVANAGARI LETTER O → DEVANAGARI LETTER A, DEVANAGARI VOWEL SIGN AA, SHARADA VOWEL SIGN SHORT E	# →अो→→आे→
+
+0973 ;	0905 093A ;	MA	# ( ॳ → अऺ ) DEVANAGARI LETTER OE → DEVANAGARI LETTER A, DEVANAGARI VOWEL SIGN OE	# 
+
+0975 ;	0905 094F ;	MA	# ( ॵ → अॏ ) DEVANAGARI LETTER AW → DEVANAGARI LETTER A, DEVANAGARI VOWEL SIGN AW	# 
+
+0904 ;	0905 0946 ;	MA	# ( ऄ → अॆ ) DEVANAGARI LETTER SHORT A → DEVANAGARI LETTER A, DEVANAGARI VOWEL SIGN SHORT E	# 
+
+0A24 ;	0909 ;	MA	# ( ਤ → उ ) GURMUKHI LETTER TA → DEVANAGARI LETTER U	# 
+
+090D ;	090F 0306 ;	MA	# ( ऍ → ए̆ ) DEVANAGARI LETTER CANDRA E → DEVANAGARI LETTER E, COMBINING BREVE	# →एॅ→
+
+090E ;	090F 0946 ;	MA	# ( ऎ → एॆ ) DEVANAGARI LETTER SHORT E → DEVANAGARI LETTER E, DEVANAGARI VOWEL SIGN SHORT E	# 
+
+0910 ;	090F 11B64 ;	MA	# ( ऐ → ए𑭤 ) DEVANAGARI LETTER AI → DEVANAGARI LETTER E, SHARADA VOWEL SIGN SHORT E	# →एे→
+
+0A1F ;	091F ;	MA	# ( ਟ → ट ) GURMUKHI LETTER TTA → DEVANAGARI LETTER TTA	# 
+
+0A20 ;	0920 ;	MA	# ( ਠ → ठ ) GURMUKHI LETTER TTHA → DEVANAGARI LETTER TTHA	# 
+
+0A2B ;	0922 ;	MA	# ( ਫ → ढ ) GURMUKHI LETTER PHA → DEVANAGARI LETTER DDHA	# 
+
+0A1C ;	0924 094D 0924 ;	MA	# ( ਜ → त्त ) GURMUKHI LETTER JA → DEVANAGARI LETTER TA, DEVANAGARI SIGN VIRAMA, DEVANAGARI LETTER TA	# 
+
+0A27 ;	092A ;	MA	# ( ਧ → प ) GURMUKHI LETTER DHA → DEVANAGARI LETTER PA	# 
+
+0A72 ;	092A 094D 091F ;	MA	# ( ੲ → प्ट ) GURMUKHI IRI → DEVANAGARI LETTER PA, DEVANAGARI SIGN VIRAMA, DEVANAGARI LETTER TTA	# 
+
+0A07 ;	092A 094D 091F 09BF ;	MA	# ( ਇ → प्टি ) GURMUKHI LETTER I → DEVANAGARI LETTER PA, DEVANAGARI SIGN VIRAMA, DEVANAGARI LETTER TTA, BENGALI VOWEL SIGN I	# →ੲਿ→
+
+0A08 ;	092A 094D 091F 0A40 ;	MA	# ( ਈ → प्टੀ ) GURMUKHI LETTER II → DEVANAGARI LETTER PA, DEVANAGARI SIGN VIRAMA, DEVANAGARI LETTER TTA, GURMUKHI VOWEL SIGN II	# →ੲੀ→
+
+0A0F ;	092A 094D 091F 11B64 ;	MA	# ( ਏ → प्ट𑭤 ) GURMUKHI LETTER EE → DEVANAGARI LETTER PA, DEVANAGARI SIGN VIRAMA, DEVANAGARI LETTER TTA, SHARADA VOWEL SIGN SHORT E	# →ੲੇ→
+
+0A2E ;	092D ;	MA	# ( ਮ → भ ) GURMUKHI LETTER MA → DEVANAGARI LETTER BHA	# 
+
+0A38 ;	092E ;	MA	# ( ਸ → म ) GURMUKHI LETTER SA → DEVANAGARI LETTER MA	# 
+
+0908 ;	0930 094D 0907 ;	MA	# ( ई → र्इ ) DEVANAGARI LETTER II → DEVANAGARI LETTER RA, DEVANAGARI SIGN VIRAMA, DEVANAGARI LETTER I	# 
+
+0A15 ;	0935 ;	MA	# ( ਕ → व ) GURMUKHI LETTER KA → DEVANAGARI LETTER VA	# 
+
+0A35 ;	0939 ;	MA	# ( ਵ → ह ) GURMUKHI LETTER VA → DEVANAGARI LETTER HA	# 
+
+0ABD ;	093D ;	MA	# ( ઽ → ऽ ) GUJARATI SIGN AVAGRAHA → DEVANAGARI SIGN AVAGRAHA	# 
+
+111DC ;	A8FB ;	MA	# ( 𑇜 → ꣻ ) SHARADA HEADSTROKE → DEVANAGARI HEADSTROKE	# 
+
+0949 ;	093E 0306 ;	MA	# ( ॉ → ा̆ ) DEVANAGARI VOWEL SIGN CANDRA O → DEVANAGARI VOWEL SIGN AA, COMBINING BREVE	# →ाॅ→
+
+093B ;	093E 093A ;	MA	# ( ऻ → ाऺ ) DEVANAGARI VOWEL SIGN OOE → DEVANAGARI VOWEL SIGN AA, DEVANAGARI VOWEL SIGN OE	# 
+
+111CB ;	093A ;	MA	# ( 𑇋 → ऺ ) SHARADA VOWEL MODIFIER MARK → DEVANAGARI VOWEL SIGN OE	# 
+11B60 ;	093A ;	MA	# ( 𑭠 → ऺ ) SHARADA VOWEL SIGN OE → DEVANAGARI VOWEL SIGN OE	# 
+
+0AC1 ;	0941 ;	MA	# ( ુ → ु ) GUJARATI VOWEL SIGN U → DEVANAGARI VOWEL SIGN U	# 
+
+0AC2 ;	0942 ;	MA	# ( ૂ → ू ) GUJARATI VOWEL SIGN UU → DEVANAGARI VOWEL SIGN UU	# 
+
+0A4B ;	0946 ;	MA	# ( ੋ → ॆ ) GURMUKHI VOWEL SIGN OO → DEVANAGARI VOWEL SIGN SHORT E	# 
+
+0A48 ;	0948 ;	MA	# ( ੈ → ै ) GURMUKHI VOWEL SIGN AI → DEVANAGARI VOWEL SIGN AI	# 
+
+0A4D ;	094D ;	MA	# ( ੍ → ् ) GURMUKHI SIGN VIRAMA → DEVANAGARI SIGN VIRAMA	# 
+0ACD ;	094D ;	MA	# ( ્ → ् ) GUJARATI SIGN VIRAMA → DEVANAGARI SIGN VIRAMA	# 
+
+0986 ;	0985 09BE ;	MA	# ( আ → অা ) BENGALI LETTER AA → BENGALI LETTER A, BENGALI VOWEL SIGN AA	# 
+
+09E0 ;	098B 09C3 ;	MA	# ( ৠ → ঋৃ ) BENGALI LETTER VOCALIC RR → BENGALI LETTER VOCALIC R, BENGALI VOWEL SIGN VOCALIC R	# 
+09E1 ;	098B 09C3 ;	MA	# ( ৡ → ঋৃ ) BENGALI LETTER VOCALIC LL → BENGALI LETTER VOCALIC R, BENGALI VOWEL SIGN VOCALIC R	# →ঌৢ→→ৠ→
+
+11492 ;	0998 ;	MA	# ( 𑒒 → ঘ ) TIRHUTA LETTER GHA → BENGALI LETTER GHA	# 
+
+11494 ;	099A ;	MA	# ( 𑒔 → চ ) TIRHUTA LETTER CA → BENGALI LETTER CA	# 
+
+11496 ;	099C ;	MA	# ( 𑒖 → জ ) TIRHUTA LETTER JA → BENGALI LETTER JA	# 
+
+11498 ;	099E ;	MA	# ( 𑒘 → ঞ ) TIRHUTA LETTER NYA → BENGALI LETTER NYA	# 
+
+11499 ;	099F ;	MA	# ( 𑒙 → ট ) TIRHUTA LETTER TTA → BENGALI LETTER TTA	# 
+
+1149B ;	09A1 ;	MA	# ( 𑒛 → ড ) TIRHUTA LETTER DDA → BENGALI LETTER DDA	# 
+
+114AA ;	09A3 ;	MA	# ( 𑒪 → ণ ) TIRHUTA LETTER LA → BENGALI LETTER NNA	# 
+
+1149E ;	09A4 ;	MA	# ( 𑒞 → ত ) TIRHUTA LETTER TA → BENGALI LETTER TA	# 
+
+1149F ;	09A5 ;	MA	# ( 𑒟 → থ ) TIRHUTA LETTER THA → BENGALI LETTER THA	# 
+
+114A0 ;	09A6 ;	MA	# ( 𑒠 → দ ) TIRHUTA LETTER DA → BENGALI LETTER DA	# 
+
+114A1 ;	09A7 ;	MA	# ( 𑒡 → ধ ) TIRHUTA LETTER DHA → BENGALI LETTER DHA	# 
+
+114A2 ;	09A8 ;	MA	# ( 𑒢 → ন ) TIRHUTA LETTER NA → BENGALI LETTER NA	# 
+
+114A3 ;	09AA ;	MA	# ( 𑒣 → প ) TIRHUTA LETTER PA → BENGALI LETTER PA	# 
+
+114A9 ;	09AC ;	MA	# ( 𑒩 → ব ) TIRHUTA LETTER RA → BENGALI LETTER BA	# 
+
+114A7 ;	09AE ;	MA	# ( 𑒧 → ম ) TIRHUTA LETTER MA → BENGALI LETTER MA	# 
+
+114A8 ;	09AF ;	MA	# ( 𑒨 → য ) TIRHUTA LETTER YA → BENGALI LETTER YA	# 
+
+09F0 ;	09B0 ;	MA	# ( ৰ → র ) BENGALI LETTER RA WITH MIDDLE DIAGONAL → BENGALI LETTER RA	# 
+114AB ;	09B0 ;	MA	# ( 𑒫 → র ) TIRHUTA LETTER VA → BENGALI LETTER RA	# 
+
+1149D ;	09B2 ;	MA	# ( 𑒝 → ল ) TIRHUTA LETTER NNA → BENGALI LETTER LA	# 
+
+114AD ;	09B7 ;	MA	# ( 𑒭 → ষ ) TIRHUTA LETTER SSA → BENGALI LETTER SSA	# 
+
+114AE ;	09B8 ;	MA	# ( 𑒮 → স ) TIRHUTA LETTER SA → BENGALI LETTER SA	# 
+
+114C4 ;	09BD ;	MA	# ( 𑓄 → ঽ ) TIRHUTA SIGN AVAGRAHA → BENGALI SIGN AVAGRAHA	# 
+
+114B0 ;	09BE ;	MA	# ( 𑒰 → া ) TIRHUTA VOWEL SIGN AA → BENGALI VOWEL SIGN AA	# 
+
+093F ;	09BF ;	MA	# ( ि → ি ) DEVANAGARI VOWEL SIGN I → BENGALI VOWEL SIGN I	# 
+0A3F ;	09BF ;	MA	# ( ਿ → ি ) GURMUKHI VOWEL SIGN I → BENGALI VOWEL SIGN I	# →ि→
+114B1 ;	09BF ;	MA	# ( 𑒱 → ি ) TIRHUTA VOWEL SIGN I → BENGALI VOWEL SIGN I	# 
+
+114B9 ;	09C7 ;	MA	# ( 𑒹 → ে ) TIRHUTA VOWEL SIGN E → BENGALI VOWEL SIGN E	# 
+
+114BC ;	09CB ;	MA	# ( 𑒼 → ো ) TIRHUTA VOWEL SIGN O → BENGALI VOWEL SIGN O	# 
+
+114BE ;	09CC ;	MA	# ( 𑒾 → ৌ ) TIRHUTA VOWEL SIGN AU → BENGALI VOWEL SIGN AU	# 
+
+114C2 ;	09CD ;	MA	# ( 𑓂 → ্ ) TIRHUTA SIGN VIRAMA → BENGALI SIGN VIRAMA	# 
+
+114BD ;	09D7 ;	MA	# ( 𑒽 → ৗ ) TIRHUTA VOWEL SIGN SHORT O → BENGALI AU LENGTH MARK	# 
+
+0A09 ;	0A73 11B62 ;	MA	# ( ਉ → ੳ𑭢 ) GURMUKHI LETTER U → GURMUKHI URA, SHARADA VOWEL SIGN UE	# →ੳੁ→
+
+0A0A ;	0A73 11B63 ;	MA	# ( ਊ → ੳ𑭣 ) GURMUKHI LETTER UU → GURMUKHI URA, SHARADA VOWEL SIGN UUE	# →ੳੂ→
+
+0A10 ;	0A05 0948 ;	MA	# ( ਐ → ਅै ) GURMUKHI LETTER AI → GURMUKHI LETTER A, DEVANAGARI VOWEL SIGN AI	# →ਅੈ→
+
+0A06 ;	0A05 0A3E ;	MA	# ( ਆ → ਅਾ ) GURMUKHI LETTER AA → GURMUKHI LETTER A, GURMUKHI VOWEL SIGN AA	# 
+
+0A14 ;	0A05 0A4C ;	MA	# ( ਔ → ਅੌ ) GURMUKHI LETTER AU → GURMUKHI LETTER A, GURMUKHI VOWEL SIGN AU	# 
+
+0A86 ;	0A85 0ABE ;	MA	# ( આ → અા ) GUJARATI LETTER AA → GUJARATI LETTER A, GUJARATI VOWEL SIGN AA	# 
+
+0A91 ;	0A85 0ABE 0AC5 ;	MA	# ( ઑ → અાૅ ) GUJARATI VOWEL CANDRA O → GUJARATI LETTER A, GUJARATI VOWEL SIGN AA, GUJARATI VOWEL SIGN CANDRA E	# →અૉ→→આૅ→
+
+0A93 ;	0A85 0ABE 0AC7 ;	MA	# ( ઓ → અાે ) GUJARATI LETTER O → GUJARATI LETTER A, GUJARATI VOWEL SIGN AA, GUJARATI VOWEL SIGN E	# →અો→→આે→
+
+0A94 ;	0A85 0ABE 0AC8 ;	MA	# ( ઔ → અાૈ ) GUJARATI LETTER AU → GUJARATI LETTER A, GUJARATI VOWEL SIGN AA, GUJARATI VOWEL SIGN AI	# →અૌ→→આૈ→
+
+0A8D ;	0A85 0AC5 ;	MA	# ( ઍ → અૅ ) GUJARATI VOWEL CANDRA E → GUJARATI LETTER A, GUJARATI VOWEL SIGN CANDRA E	# 
+
+0A8F ;	0A85 0AC7 ;	MA	# ( એ → અે ) GUJARATI LETTER E → GUJARATI LETTER A, GUJARATI VOWEL SIGN E	# 
+
+0A90 ;	0A85 0AC8 ;	MA	# ( ઐ → અૈ ) GUJARATI LETTER AI → GUJARATI LETTER A, GUJARATI VOWEL SIGN AI	# 
+
+0B06 ;	0B05 0B3E ;	MA	# ( ଆ → ଅା ) ORIYA LETTER AA → ORIYA LETTER A, ORIYA VOWEL SIGN AA	# 
+
+1031 ;	0B47 ;	MA	# ( ေ → େ ) MYANMAR VOWEL SIGN E → ORIYA VOWEL SIGN E	# 
+
+0BEE ;	0B85 ;	MA	# ( ௮ → அ ) TAMIL DIGIT EIGHT → TAMIL LETTER A	# 
+
+0BB0 ;	0B88 ;	MA	# ( ர → ஈ ) TAMIL LETTER RA → TAMIL LETTER II	# →ா→
+0BBE ;	0B88 ;	MA	# ( ா → ஈ ) TAMIL VOWEL SIGN AA → TAMIL LETTER II	# 
+
+0BEB ;	0B88 0BC1 ;	MA	# ( ௫ → ஈு ) TAMIL DIGIT FIVE → TAMIL LETTER II, TAMIL VOWEL SIGN U	# →ரு→
+
+0BE8 ;	0B89 ;	MA	# ( ௨ → உ ) TAMIL DIGIT TWO → TAMIL LETTER U	# 
+0D09 ;	0B89 ;	MA	# ( ഉ → உ ) MALAYALAM LETTER U → TAMIL LETTER U	# 
+
+0B8A ;	0B89 0BB3 ;	MA	# ( ஊ → உள ) TAMIL LETTER UU → TAMIL LETTER U, TAMIL LETTER LLA	# 
+
+0D0A ;	0B89 0D57 ;	MA	# ( ഊ → உൗ ) MALAYALAM LETTER UU → TAMIL LETTER U, MALAYALAM AU LENGTH MARK	# →ഉൗ→
+
+0BED ;	0B8E ;	MA	# ( ௭ → எ ) TAMIL DIGIT SEVEN → TAMIL LETTER E	# 
+
+0BF7 ;	0B8E 0BB5 ;	MA	#* ( ௷ → எவ ) TAMIL CREDIT SIGN → TAMIL LETTER E, TAMIL LETTER VA	# 
+
+0B9C ;	0B90 ;	MA	# ( ஜ → ஐ ) TAMIL LETTER JA → TAMIL LETTER AI	# 
+0D1C ;	0B90 ;	MA	# ( ജ → ஐ ) MALAYALAM LETTER JA → TAMIL LETTER AI	# →ஜ→
+
+0B94 ;	0B92 0BB3 ;	MA	# ( ஔ → ஒள ) TAMIL LETTER AU → TAMIL LETTER O, TAMIL LETTER LLA	# 
+
+0BE7 ;	0B95 ;	MA	# ( ௧ → க ) TAMIL DIGIT ONE → TAMIL LETTER KA	# 
+
+0BEA ;	0B9A ;	MA	# ( ௪ → ச ) TAMIL DIGIT FOUR → TAMIL LETTER CA	# 
+
+0BEC ;	0B9A 0BC1 ;	MA	# ( ௬ → சு ) TAMIL DIGIT SIX → TAMIL LETTER CA, TAMIL VOWEL SIGN U	# 
+
+0BF2 ;	0B9A 0BC2 ;	MA	#* ( ௲ → சூ ) TAMIL NUMBER ONE THOUSAND → TAMIL LETTER CA, TAMIL VOWEL SIGN UU	# 
+
+0D3A ;	0B9F 0BBF ;	MA	# ( ഺ → டி ) MALAYALAM LETTER TTTA → TAMIL LETTER TTA, TAMIL VOWEL SIGN I	# 
+
+0D23 ;	0BA3 ;	MA	# ( ണ → ண ) MALAYALAM LETTER NNA → TAMIL LETTER NNA	# 
+
+0D7A ;	0BA3 0D4D ;	MA	# ( ൺ → ண് ) MALAYALAM LETTER CHILLU NN → TAMIL LETTER NNA, MALAYALAM SIGN VIRAMA	# →ണ്→
+
+0BFA ;	0BA8 0BC0 ;	MA	#* ( ௺ → நீ ) TAMIL NUMBER SIGN → TAMIL LETTER NA, TAMIL VOWEL SIGN II	# 
+
+0D25 ;	0BAE ;	MA	# ( ഥ → ம ) MALAYALAM LETTER THA → TAMIL LETTER MA	# 
+
+0BF4 ;	0BAE 0BC0 ;	MA	#* ( ௴ → மீ ) TAMIL MONTH SIGN → TAMIL LETTER MA, TAMIL VOWEL SIGN II	# 
+
+0BF0 ;	0BAF ;	MA	#* ( ௰ → ய ) TAMIL NUMBER TEN → TAMIL LETTER YA	# 
+
+0D16 ;	0BB5 ;	MA	# ( ഖ → வ ) MALAYALAM LETTER KHA → TAMIL LETTER VA	# 
+
+0D34 ;	0BB4 ;	MA	# ( ഴ → ழ ) MALAYALAM LETTER LLLA → TAMIL LETTER LLLA	# 
+
+0BD7 ;	0BB3 ;	MA	# ( ௗ → ள ) TAMIL AU LENGTH MARK → TAMIL LETTER LLA	# 
+
+0BC8 ;	0BA9 ;	MA	# ( ை → ன ) TAMIL VOWEL SIGN AI → TAMIL LETTER NNNA	# 
+
+0BB8 ;	0BB6 ;	MA	# ( ஸ → ஶ ) TAMIL LETTER SA → TAMIL LETTER SHA	# 
+0D36 ;	0BB6 ;	MA	# ( ശ → ஶ ) MALAYALAM LETTER SHA → TAMIL LETTER SHA	# 
+
+0BF8 ;	0BB7 ;	MA	#* ( ௸ → ஷ ) TAMIL AS ABOVE SIGN → TAMIL LETTER SSA	# 
+
+0D3F ;	0BBF ;	MA	# ( ി → ி ) MALAYALAM VOWEL SIGN I → TAMIL VOWEL SIGN I	# 
+0D40 ;	0BBF ;	MA	# ( ീ → ி ) MALAYALAM VOWEL SIGN II → TAMIL VOWEL SIGN I	# 
+
+0D46 ;	0BC6 ;	MA	# ( െ → ெ ) MALAYALAM VOWEL SIGN E → TAMIL VOWEL SIGN E	# 
+
+0BCA ;	0BC6 0B88 ;	MA	# ( ொ → ெஈ ) TAMIL VOWEL SIGN O → TAMIL VOWEL SIGN E, TAMIL LETTER II	# →ெர→
+
+0BCC ;	0BC6 0BB3 ;	MA	# ( ௌ → ெள ) TAMIL VOWEL SIGN AU → TAMIL VOWEL SIGN E, TAMIL LETTER LLA	# 
+
+0D48 ;	0BC6 0BC6 ;	MA	# ( ൈ → ெெ ) MALAYALAM VOWEL SIGN AI → TAMIL VOWEL SIGN E, TAMIL VOWEL SIGN E	# →െെ→
+
+0D10 ;	0BC6 0D0E ;	MA	# ( ഐ → ெഎ ) MALAYALAM LETTER AI → TAMIL VOWEL SIGN E, MALAYALAM LETTER E	# →െഎ→
+
+0D47 ;	0BC7 ;	MA	# ( േ → ே ) MALAYALAM VOWEL SIGN EE → TAMIL VOWEL SIGN EE	# 
+
+0BCB ;	0BC7 0B88 ;	MA	# ( ோ → ேஈ ) TAMIL VOWEL SIGN OO → TAMIL VOWEL SIGN EE, TAMIL LETTER II	# →ேர→
+
+0C85 ;	0C05 ;	MA	# ( ಅ → అ ) KANNADA LETTER A → TELUGU LETTER A	# 
+
+0C86 ;	0C06 ;	MA	# ( ಆ → ఆ ) KANNADA LETTER AA → TELUGU LETTER AA	# 
+
+0C87 ;	0C07 ;	MA	# ( ಇ → ఇ ) KANNADA LETTER I → TELUGU LETTER I	# 
+
+0C60 ;	0C0B 0C3E ;	MA	# ( ౠ → ఋా ) TELUGU LETTER VOCALIC RR → TELUGU LETTER VOCALIC R, TELUGU VOWEL SIGN AA	# 
+
+0C61 ;	0C0C 0C3E ;	MA	# ( ౡ → ఌా ) TELUGU LETTER VOCALIC LL → TELUGU LETTER VOCALIC L, TELUGU VOWEL SIGN AA	# 
+
+0C90 ;	0C10 ;	MA	# ( ಐ → ఐ ) KANNADA LETTER AI → TELUGU LETTER AI	# 
+
+0C92 ;	0C12 ;	MA	# ( ಒ → ఒ ) KANNADA LETTER O → TELUGU LETTER O	# 
+
+0C14 ;	0C12 0C4C ;	MA	# ( ఔ → ఒౌ ) TELUGU LETTER AU → TELUGU LETTER O, TELUGU VOWEL SIGN AU	# 
+0C94 ;	0C12 0C4C ;	MA	# ( ಔ → ఒౌ ) KANNADA LETTER AU → TELUGU LETTER O, TELUGU VOWEL SIGN AU	# →ఔ→
+
+0C13 ;	0C12 0C55 ;	MA	# ( ఓ → ఒౕ ) TELUGU LETTER OO → TELUGU LETTER O, TELUGU LENGTH MARK	# 
+0C93 ;	0C12 0C55 ;	MA	# ( ಓ → ఒౕ ) KANNADA LETTER OO → TELUGU LETTER O, TELUGU LENGTH MARK	# →ఓ→
+
+0C97 ;	0C17 ;	MA	# ( ಗ → గ ) KANNADA LETTER GA → TELUGU LETTER GA	# 
+
+0C9C ;	0C1C ;	MA	# ( ಜ → జ ) KANNADA LETTER JA → TELUGU LETTER JA	# 
+
+0C9D ;	0C1D ;	MA	# ( ಝ → ఝ ) KANNADA LETTER JHA → TELUGU LETTER JHA	# 
+
+0C9E ;	0C1E ;	MA	# ( ಞ → ఞ ) KANNADA LETTER NYA → TELUGU LETTER NYA	# 
+
+0C9F ;	0C1F ;	MA	# ( ಟ → ట ) KANNADA LETTER TTA → TELUGU LETTER TTA	# 
+
+0C22 ;	0C21 0323 ;	MA	# ( ఢ → డ̣ ) TELUGU LETTER DDHA → TELUGU LETTER DDA, COMBINING DOT BELOW	# 
+
+0CA3 ;	0C23 ;	MA	# ( ಣ → ణ ) KANNADA LETTER NNA → TELUGU LETTER NNA	# 
+
+0CA6 ;	0C26 ;	MA	# ( ದ → ద ) KANNADA LETTER DA → TELUGU LETTER DA	# 
+
+0C25 ;	0C27 05BC ;	MA	# ( థ → ధּ ) TELUGU LETTER THA → TELUGU LETTER DHA, HEBREW POINT DAGESH OR MAPIQ	# 
+
+0CA8 ;	0C28 ;	MA	# ( ನ → న ) KANNADA LETTER NA → TELUGU LETTER NA	# 
+
+0C2D ;	0C2C 0323 ;	MA	# ( భ → బ̣ ) TELUGU LETTER BHA → TELUGU LETTER BA, COMBINING DOT BELOW	# 
+
+0CAF ;	0C2F ;	MA	# ( ಯ → య ) KANNADA LETTER YA → TELUGU LETTER YA	# 
+
+0CB0 ;	0C30 ;	MA	# ( ರ → ర ) KANNADA LETTER RA → TELUGU LETTER RA	# 
+
+0C20 ;	0C30 05BC ;	MA	# ( ఠ → రּ ) TELUGU LETTER TTHA → TELUGU LETTER RA, HEBREW POINT DAGESH OR MAPIQ	# 
+
+0CB1 ;	0C31 ;	MA	# ( ಱ → ఱ ) KANNADA LETTER RRA → TELUGU LETTER RRA	# 
+
+0CB2 ;	0C32 ;	MA	# ( ಲ → ల ) KANNADA LETTER LA → TELUGU LETTER LA	# 
+
+0C37 ;	0C35 0323 ;	MA	# ( ష → వ̣ ) TELUGU LETTER SSA → TELUGU LETTER VA, COMBINING DOT BELOW	# 
+
+0C39 ;	0C35 0C3E ;	MA	# ( హ → వా ) TELUGU LETTER HA → TELUGU LETTER VA, TELUGU VOWEL SIGN AA	# 
+
+0C2E ;	0C35 0C41 ;	MA	# ( మ → వు ) TELUGU LETTER MA → TELUGU LETTER VA, TELUGU VOWEL SIGN U	# 
+
+0CB3 ;	0C33 ;	MA	# ( ಳ → ళ ) KANNADA LETTER LLA → TELUGU LETTER LLA	# 
+
+0CBF ;	0C3F ;	MA	# ( ಿ → ి ) KANNADA VOWEL SIGN I → TELUGU VOWEL SIGN I	# 
+
+0CC1 ;	0C41 ;	MA	# ( ು → ు ) KANNADA VOWEL SIGN U → TELUGU VOWEL SIGN U	# 
+
+0C42 ;	0C41 0C3E ;	MA	# ( ూ → ుా ) TELUGU VOWEL SIGN UU → TELUGU VOWEL SIGN U, TELUGU VOWEL SIGN AA	# 
+
+0CC3 ;	0C43 ;	MA	# ( ೃ → ృ ) KANNADA VOWEL SIGN VOCALIC R → TELUGU VOWEL SIGN VOCALIC R	# 
+
+0C44 ;	0C43 0C3E ;	MA	# ( ౄ → ృా ) TELUGU VOWEL SIGN VOCALIC RR → TELUGU VOWEL SIGN VOCALIC R, TELUGU VOWEL SIGN AA	# 
+
+0CE1 ;	0C8C 0CBE ;	MA	# ( ೡ → ಌಾ ) KANNADA LETTER VOCALIC LL → KANNADA LETTER VOCALIC L, KANNADA VOWEL SIGN AA	# 
+
+0C16 ;	0C96 0323 ;	MA	# ( ఖ → ಖ̣ ) TELUGU LETTER KHA → KANNADA LETTER KHA, COMBINING DOT BELOW	# 
+
+0D08 ;	0D07 0D57 ;	MA	# ( ഈ → ഇൗ ) MALAYALAM LETTER II → MALAYALAM LETTER I, MALAYALAM AU LENGTH MARK	# 
+
+0D13 ;	0D12 0D3E ;	MA	# ( ഓ → ഒാ ) MALAYALAM LETTER OO → MALAYALAM LETTER O, MALAYALAM VOWEL SIGN AA	# 
+
+0D14 ;	0D12 0D57 ;	MA	# ( ഔ → ഒൗ ) MALAYALAM LETTER AU → MALAYALAM LETTER O, MALAYALAM AU LENGTH MARK	# 
+
+0D61 ;	0D1E ;	MA	# ( ൡ → ഞ ) MALAYALAM LETTER VOCALIC LL → MALAYALAM LETTER NYA	# 
+
+0D6B ;	0D26 0D4D 0D30 ;	MA	# ( ൫ → ദ്ര ) MALAYALAM DIGIT FIVE → MALAYALAM LETTER DA, MALAYALAM SIGN VIRAMA, MALAYALAM LETTER RA	# 
+
+0D79 ;	0D28 0D41 ;	MA	#* ( ൹ → നു ) MALAYALAM DATE MARK → MALAYALAM LETTER NA, MALAYALAM VOWEL SIGN U	# 
+0D0C ;	0D28 0D41 ;	MA	# ( ഌ → നു ) MALAYALAM LETTER VOCALIC L → MALAYALAM LETTER NA, MALAYALAM VOWEL SIGN U	# 
+0D19 ;	0D28 0D41 ;	MA	# ( ങ → നു ) MALAYALAM LETTER NGA → MALAYALAM LETTER NA, MALAYALAM VOWEL SIGN U	# →ഌ→
+
+0D6F ;	0D28 0D4D ;	MA	# ( ൯ → ന് ) MALAYALAM DIGIT NINE → MALAYALAM LETTER NA, MALAYALAM SIGN VIRAMA	# 
+0D7B ;	0D28 0D4D ;	MA	# ( ൻ → ന് ) MALAYALAM LETTER CHILLU N → MALAYALAM LETTER NA, MALAYALAM SIGN VIRAMA	# →൯→
+
+0D6C ;	0D28 0D4D 0D28 ;	MA	# ( ൬ → ന്ന ) MALAYALAM DIGIT SIX → MALAYALAM LETTER NA, MALAYALAM SIGN VIRAMA, MALAYALAM LETTER NA	# 
+
+0D5A ;	0D28 0D4D 0D2E ;	MA	#* ( ൚ → ന്മ ) MALAYALAM FRACTION THREE EIGHTIETHS → MALAYALAM LETTER NA, MALAYALAM SIGN VIRAMA, MALAYALAM LETTER MA	# 
+
+10D8 ;	0D30 ;	MA	# ( ი → ര ) GEORGIAN LETTER IN → MALAYALAM LETTER RA	# →റ→
+0D31 ;	0D30 ;	MA	# ( റ → ര ) MALAYALAM LETTER RRA → MALAYALAM LETTER RA	# 
+1002 ;	0D30 ;	MA	# ( ဂ → ര ) MYANMAR LETTER GA → MALAYALAM LETTER RA	# →റ→
+
+0D6A ;	0D30 0D4D ;	MA	# ( ൪ → ര് ) MALAYALAM DIGIT FOUR → MALAYALAM LETTER RA, MALAYALAM SIGN VIRAMA	# 
+0D7C ;	0D30 0D4D ;	MA	# ( ർ → ര് ) MALAYALAM LETTER CHILLU RR → MALAYALAM LETTER RA, MALAYALAM SIGN VIRAMA	# →൪→
+
+1081 ;	0D30 103E ;	MA	# ( ႁ → രှ ) MYANMAR LETTER SHAN HA → MALAYALAM LETTER RA, MYANMAR CONSONANT SIGN MEDIAL HA	# →ဂှ→
+
+1000 ;	0D30 102C ;	MA	# ( က → രာ ) MYANMAR LETTER KA → MALAYALAM LETTER RA, MYANMAR VOWEL SIGN AA	# →ဂာ→
+
+1023 ;	0D30 102C 1039 0D30 102C ;	MA	# ( ဣ → രာ္രာ ) MYANMAR LETTER I → MALAYALAM LETTER RA, MYANMAR VOWEL SIGN AA, MYANMAR SIGN VIRAMA, MALAYALAM LETTER RA, MYANMAR VOWEL SIGN AA	# →က္က→
+
+0D7D ;	0D32 0D4D ;	MA	# ( ൽ → ല് ) MALAYALAM LETTER CHILLU L → MALAYALAM LETTER LA, MALAYALAM SIGN VIRAMA	# 
+
+0D6E ;	0D35 0D4D 0D30 ;	MA	# ( ൮ → വ്ര ) MALAYALAM DIGIT EIGHT → MALAYALAM LETTER VA, MALAYALAM SIGN VIRAMA, MALAYALAM LETTER RA	# 
+
+0D76 ;	0D39 0D4D 0D2E ;	MA	#* ( ൶ → ഹ്മ ) MALAYALAM FRACTION ONE SIXTEENTH → MALAYALAM LETTER HA, MALAYALAM SIGN VIRAMA, MALAYALAM LETTER MA	# 
+
+0D7E ;	0D33 0D4D ;	MA	# ( ൾ → ള് ) MALAYALAM LETTER CHILLU LL → MALAYALAM LETTER LLA, MALAYALAM SIGN VIRAMA	# 
+
+0D42 ;	0D41 ;	MA	# ( ൂ → ു ) MALAYALAM VOWEL SIGN UU → MALAYALAM VOWEL SIGN U	# 
+0D43 ;	0D41 ;	MA	# ( ൃ → ു ) MALAYALAM VOWEL SIGN VOCALIC R → MALAYALAM VOWEL SIGN U	# →ൂ→
+
+0DB5 ;	0D91 ;	MA	# ( ඵ → එ ) SINHALA LETTER MAHAAPRAANA PAYANNA → SINHALA LETTER EYANNA	# 
+
+0D93 ;	0D91 0DD9 ;	MA	# ( ඓ → එෙ ) SINHALA LETTER AIYANNA → SINHALA LETTER EYANNA, SINHALA VOWEL SIGN KOMBUVA	# 
+
+0D92 ;	0D91 0DCA ;	MA	# ( ඒ → එ් ) SINHALA LETTER EEYANNA → SINHALA LETTER EYANNA, SINHALA SIGN AL-LAKUNA	# 
+
+0DB9 ;	0D94 ;	MA	# ( ඹ → ඔ ) SINHALA LETTER AMBA BAYANNA → SINHALA LETTER OYANNA	# 
+
+0DB6 ;	0D9B ;	MA	# ( බ → ඛ ) SINHALA LETTER ALPAPRAANA BAYANNA → SINHALA LETTER MAHAAPRAANA KAYANNA	# 
+
+0DC0 ;	0DA0 ;	MA	# ( ව → ච ) SINHALA LETTER VAYANNA → SINHALA LETTER ALPAPRAANA CAYANNA	# 
+
+0DEA ;	0DA2 ;	MA	# ( ෪ → ජ ) SINHALA LITH DIGIT FOUR → SINHALA LETTER ALPAPRAANA JAYANNA	# 
+
+0DEB ;	0DAF ;	MA	# ( ෫ → ද ) SINHALA LITH DIGIT FIVE → SINHALA LETTER ALPAPRAANA DAYANNA	# 
+
+0DC4 ;	0DB7 ;	MA	# ( හ → භ ) SINHALA LETTER HAYANNA → SINHALA LETTER MAHAAPRAANA BAYANNA	# 
+
+0D8D ;	0DC3 0DD8 ;	MA	# ( ඍ → සෘ ) SINHALA LETTER IRUYANNA → SINHALA LETTER DANTAJA SAYANNA, SINHALA VOWEL SIGN GAETTA-PILLA	# 
+
+11413 ;	11434 11442 11412 ;	MA	# ( 𑐓 → 𑐴𑑂𑐒 ) NEWA LETTER NGHA → NEWA LETTER HA, NEWA SIGN VIRAMA, NEWA LETTER NGA	# 
+
+11419 ;	11434 11442 11418 ;	MA	# ( 𑐙 → 𑐴𑑂𑐘 ) NEWA LETTER NYHA → NEWA LETTER HA, NEWA SIGN VIRAMA, NEWA LETTER NYA	# 
+
+11424 ;	11434 11442 11423 ;	MA	# ( 𑐤 → 𑐴𑑂𑐣 ) NEWA LETTER NHA → NEWA LETTER HA, NEWA SIGN VIRAMA, NEWA LETTER NA	# 
+
+1142A ;	11434 11442 11429 ;	MA	# ( 𑐪 → 𑐴𑑂𑐩 ) NEWA LETTER MHA → NEWA LETTER HA, NEWA SIGN VIRAMA, NEWA LETTER MA	# 
+
+1142D ;	11434 11442 1142C ;	MA	# ( 𑐭 → 𑐴𑑂𑐬 ) NEWA LETTER RHA → NEWA LETTER HA, NEWA SIGN VIRAMA, NEWA LETTER RA	# 
+
+1142F ;	11434 11442 1142E ;	MA	# ( 𑐯 → 𑐴𑑂𑐮 ) NEWA LETTER LHA → NEWA LETTER HA, NEWA SIGN VIRAMA, NEWA LETTER LA	# 
+
+115D8 ;	11582 ;	MA	# ( 𑗘 → 𑖂 ) SIDDHAM LETTER THREE-CIRCLE ALTERNATE I → SIDDHAM LETTER I	# 
+115D9 ;	11582 ;	MA	# ( 𑗙 → 𑖂 ) SIDDHAM LETTER TWO-CIRCLE ALTERNATE I → SIDDHAM LETTER I	# 
+
+115DA ;	11583 ;	MA	# ( 𑗚 → 𑖃 ) SIDDHAM LETTER TWO-CIRCLE ALTERNATE II → SIDDHAM LETTER II	# 
+
+115DB ;	11584 ;	MA	# ( 𑗛 → 𑖄 ) SIDDHAM LETTER ALTERNATE U → SIDDHAM LETTER U	# 
+
+115DC ;	115B2 ;	MA	# ( 𑗜 → 𑖲 ) SIDDHAM VOWEL SIGN ALTERNATE U → SIDDHAM VOWEL SIGN U	# 
+
+115DD ;	115B3 ;	MA	# ( 𑗝 → 𑖳 ) SIDDHAM VOWEL SIGN ALTERNATE UU → SIDDHAM VOWEL SIGN UU	# 
+
+0E03 ;	0E02 ;	MA	# ( ฃ → ข ) THAI CHARACTER KHO KHUAT → THAI CHARACTER KHO KHAI	# 
+
+0E14 ;	0E04 ;	MA	# ( ด → ค ) THAI CHARACTER DO DEK → THAI CHARACTER KHO KHWAI	# 
+0E15 ;	0E04 ;	MA	# ( ต → ค ) THAI CHARACTER TO TAO → THAI CHARACTER KHO KHWAI	# →ด→
+
+0E21 ;	0E06 ;	MA	# ( ม → ฆ ) THAI CHARACTER MO MA → THAI CHARACTER KHO RAKHANG	# 
+
+0E88 ;	0E08 ;	MA	# ( ຈ → จ ) LAO LETTER CO → THAI CHARACTER CHO CHAN	# 
+
+0E0B ;	0E0A ;	MA	# ( ซ → ช ) THAI CHARACTER SO SO → THAI CHARACTER CHO CHANG	# 
+
+0E0F ;	0E0E ;	MA	# ( ฏ → ฎ ) THAI CHARACTER TO PATAK → THAI CHARACTER DO CHADA	# 
+
+0E17 ;	0E11 ;	MA	# ( ท → ฑ ) THAI CHARACTER THO THAHAN → THAI CHARACTER THO NANGMONTHO	# 
+
+0E9A ;	0E1A ;	MA	# ( ບ → บ ) LAO LETTER BO → THAI CHARACTER BO BAIMAI	# 
+
+0E9B ;	0E1B ;	MA	# ( ປ → ป ) LAO LETTER PO → THAI CHARACTER PO PLA	# 
+
+0E9D ;	0E1D ;	MA	# ( ຝ → ฝ ) LAO LETTER FO TAM → THAI CHARACTER FO FA	# 
+
+0E9E ;	0E1E ;	MA	# ( ພ → พ ) LAO LETTER PHO TAM → THAI CHARACTER PHO PHAN	# 
+
+0E9F ;	0E1F ;	MA	# ( ຟ → ฟ ) LAO LETTER FO SUNG → THAI CHARACTER FO FAN	# 
+
+0E26 ;	0E20 ;	MA	# ( ฦ → ภ ) THAI CHARACTER LU → THAI CHARACTER PHO SAMPHAO	# 
+
+0E8D ;	0E22 ;	MA	# ( ຍ → ย ) LAO LETTER NYO → THAI CHARACTER YO YAK	# 
+
+17D4 ;	0E2F ;	MA	#* ( ។ → ฯ ) KHMER SIGN KHAN → THAI CHARACTER PAIYANNOI	# 
+
+0E45 ;	0E32 ;	MA	# ( ๅ → า ) THAI CHARACTER LAKKHANGYAO → THAI CHARACTER SARA AA	# 
+
+0E33 ;	030A 0E32 ;	MA	# ( ำ → ̊า ) THAI CHARACTER SARA AM → COMBINING RING ABOVE, THAI CHARACTER SARA AA	# →ํา→
+
+17B7 ;	0E34 ;	MA	# ( ិ → ิ ) KHMER VOWEL SIGN I → THAI CHARACTER SARA I	# 
+
+17B8 ;	0E35 ;	MA	# ( ី → ี ) KHMER VOWEL SIGN II → THAI CHARACTER SARA II	# 
+
+17B9 ;	0E36 ;	MA	# ( ឹ → ึ ) KHMER VOWEL SIGN Y → THAI CHARACTER SARA UE	# 
+
+17BA ;	0E37 ;	MA	# ( ឺ → ื ) KHMER VOWEL SIGN YY → THAI CHARACTER SARA UEE	# 
+
+0EB8 ;	0E38 ;	MA	# ( ຸ → ุ ) LAO VOWEL SIGN U → THAI CHARACTER SARA U	# 
+
+0EB9 ;	0E39 ;	MA	# ( ູ → ู ) LAO VOWEL SIGN UU → THAI CHARACTER SARA UU	# 
+
+0E41 ;	0E40 0E40 ;	MA	# ( แ → เเ ) THAI CHARACTER SARA AE → THAI CHARACTER SARA E, THAI CHARACTER SARA E	# 
+
+0EDC ;	0EAB 0E99 ;	MA	# ( ໜ → ຫນ ) LAO HO NO → LAO LETTER HO SUNG, LAO LETTER NO	# 
+
+0EDD ;	0EAB 0EA1 ;	MA	# ( ໝ → ຫມ ) LAO HO MO → LAO LETTER HO SUNG, LAO LETTER MO	# 
+
+0EB3 ;	030A 0EB2 ;	MA	# ( ຳ → ̊າ ) LAO VOWEL SIGN AM → COMBINING RING ABOVE, LAO VOWEL SIGN AA	# →ໍາ→
+
+0F02 ;	0F60 0F74 0F82 0F7F ;	MA	#* ( ༂ → འུྂཿ ) TIBETAN MARK GTER YIG MGO -UM RNAM BCAD MA → TIBETAN LETTER -A, TIBETAN VOWEL SIGN U, TIBETAN SIGN NYI ZLA NAA DA, TIBETAN SIGN RNAM BCAD	# 
+
+0F03 ;	0F60 0F74 0F82 0F14 ;	MA	#* ( ༃ → འུྂ༔ ) TIBETAN MARK GTER YIG MGO -UM GTER TSHEG MA → TIBETAN LETTER -A, TIBETAN VOWEL SIGN U, TIBETAN SIGN NYI ZLA NAA DA, TIBETAN MARK GTER TSHEG	# 
+
+0F6A ;	0F62 ;	MA	# ( ཪ → ར ) TIBETAN LETTER FIXED-FORM RA → TIBETAN LETTER RA	# 
+
+0F00 ;	0F68 0F7C 0F7E ;	MA	# ( ༀ → ཨོཾ ) TIBETAN SYLLABLE OM → TIBETAN LETTER A, TIBETAN VOWEL SIGN O, TIBETAN SIGN RJES SU NGA RO	# 
+
+0F77 ;	0FB2 0F71 0F80 ;	MA	# ( ཷ → ྲཱྀ ) TIBETAN VOWEL SIGN VOCALIC RR → TIBETAN SUBJOINED LETTER RA, TIBETAN VOWEL SIGN AA, TIBETAN VOWEL SIGN REVERSED I	# 
+
+0F79 ;	0FB3 0F71 0F80 ;	MA	# ( ཹ → ླཱྀ ) TIBETAN VOWEL SIGN VOCALIC LL → TIBETAN SUBJOINED LETTER LA, TIBETAN VOWEL SIGN AA, TIBETAN VOWEL SIGN REVERSED I	# 
+
+0F7B ;	0F7A 0F7A ;	MA	# ( ཻ → ེེ ) TIBETAN VOWEL SIGN EE → TIBETAN VOWEL SIGN E, TIBETAN VOWEL SIGN E	# 
+
+0F7D ;	0F7C 0F7C ;	MA	# ( ཽ → ོོ ) TIBETAN VOWEL SIGN OO → TIBETAN VOWEL SIGN O, TIBETAN VOWEL SIGN O	# 
+
+11CB2 ;	11CAA ;	MA	# ( 𑲲 → 𑲪 ) MARCHEN VOWEL SIGN U → MARCHEN SUBJOINED LETTER RA	# 
+
+1734 ;	1715 ;	MA	# ( ᜴ → ᜕ ) HANUNOO SIGN PAMUDPOD → TAGALOG SIGN PAMUDPOD	# 
+
+1070 ;	1003 103E ;	MA	# ( ၰ → ဃှ ) MYANMAR LETTER EASTERN PWO KAREN GHWA → MYANMAR LETTER GHA, MYANMAR CONSONANT SIGN MEDIAL HA	# 
+
+1066 ;	1015 103E ;	MA	# ( ၦ → ပှ ) MYANMAR LETTER WESTERN PWO KAREN PWA → MYANMAR LETTER PA, MYANMAR CONSONANT SIGN MEDIAL HA	# 
+
+101F ;	1015 102C ;	MA	# ( ဟ → ပာ ) MYANMAR LETTER HA → MYANMAR LETTER PA, MYANMAR VOWEL SIGN AA	# 
+
+106F ;	1015 102C 103E ;	MA	# ( ၯ → ပာှ ) MYANMAR LETTER EASTERN PWO KAREN YWA → MYANMAR LETTER PA, MYANMAR VOWEL SIGN AA, MYANMAR CONSONANT SIGN MEDIAL HA	# →ဟှ→
+
+107E ;	107D 103E ;	MA	# ( ၾ → ၽှ ) MYANMAR LETTER SHAN FA → MYANMAR LETTER SHAN PHA, MYANMAR CONSONANT SIGN MEDIAL HA	# 
+
+1061 ;	101B 103E ;	MA	# ( ၡ → ရှ ) MYANMAR LETTER SGAW KAREN SHA → MYANMAR LETTER RA, MYANMAR CONSONANT SIGN MEDIAL HA	# 
+
+1029 ;	101E 103C ;	MA	# ( ဩ → သြ ) MYANMAR LETTER O → MYANMAR LETTER SA, MYANMAR CONSONANT SIGN MEDIAL RA	# 
+
+102A ;	101E 103C 0B47 102C 103A ;	MA	# ( ဪ → သြେာ် ) MYANMAR LETTER AU → MYANMAR LETTER SA, MYANMAR CONSONANT SIGN MEDIAL RA, ORIYA VOWEL SIGN E, MYANMAR VOWEL SIGN AA, MYANMAR SIGN ASAT	# →ဩော်→
+
+109E ;	1083 030A ;	MA	#* ( ႞ → ႃ̊ ) MYANMAR SYMBOL SHAN ONE → MYANMAR VOWEL SIGN SHAN AA, COMBINING RING ABOVE	# →ႃံ→
+
+178F ;	178A ;	MA	# ( ត → ដ ) KHMER LETTER TA → KHMER LETTER DA	# 
+
+17A3 ;	17A2 ;	MA	# ( ឣ → អ ) KHMER INDEPENDENT VOWEL QAQ → KHMER LETTER QA	# 
+
+19D0 ;	199E ;	MA	# ( ᧐ → ᦞ ) NEW TAI LUE DIGIT ZERO → NEW TAI LUE LETTER LOW VA	# 
+
+19D1 ;	19B1 ;	MA	# ( ᧑ → ᦱ ) NEW TAI LUE DIGIT ONE → NEW TAI LUE VOWEL SIGN AA	# 
+
+1A80 ;	1A45 ;	MA	# ( ᪀ → ᩅ ) TAI THAM HORA DIGIT ZERO → TAI THAM LETTER WA	# 
+1A90 ;	1A45 ;	MA	# ( ᪐ → ᩅ ) TAI THAM THAM DIGIT ZERO → TAI THAM LETTER WA	# 
+
+AA53 ;	AA01 ;	MA	# ( ꩓ → ꨁ ) CHAM DIGIT THREE → CHAM LETTER I	# 
+
+AA56 ;	AA23 ;	MA	# ( ꩖ → ꨣ ) CHAM DIGIT SIX → CHAM LETTER RA	# 
+
+1B52 ;	1B0D ;	MA	# ( ᭒ → ᬍ ) BALINESE DIGIT TWO → BALINESE LETTER LA LENGA	# 
+
+1B53 ;	1B11 ;	MA	# ( ᭓ → ᬑ ) BALINESE DIGIT THREE → BALINESE LETTER OKARA	# 
+
+1B58 ;	1B28 ;	MA	# ( ᭘ → ᬨ ) BALINESE DIGIT EIGHT → BALINESE LETTER PA KAPAL	# 
+
+A9A3 ;	A99D ;	MA	# ( ꦣ → ꦝ ) JAVANESE LETTER DA MAHAPRANA → JAVANESE LETTER DDA	# 
+
+1896 ;	185C ;	MA	# ( ᢖ → ᡜ ) MONGOLIAN LETTER ALI GALI ZA → MONGOLIAN LETTER TODO DZA	# 
+
+1855 ;	1835 ;	MA	# ( ᡕ → ᠵ ) MONGOLIAN LETTER TODO YA → MONGOLIAN LETTER JA	# 
+
+1FF6 ;	13EF ;	MA	# ( ῶ → Ꮿ ) GREEK SMALL LETTER OMEGA WITH PERISPOMENI → CHEROKEE LETTER YA	# 
+
+140D ;	1401 00B7 ;	MA	# ( ᐍ → ᐁ· ) CANADIAN SYLLABICS WEST-CREE WE → CANADIAN SYLLABICS E, MIDDLE DOT	# →ᐁᐧ→
+
+142B ;	1401 1420 ;	MA	# ( ᐫ → ᐁᐠ ) CANADIAN SYLLABICS EN → CANADIAN SYLLABICS E, CANADIAN SYLLABICS FINAL GRAVE	# 
+
+1411 ;	1404 00B7 ;	MA	# ( ᐑ → ᐄ· ) CANADIAN SYLLABICS WEST-CREE WII → CANADIAN SYLLABICS II, MIDDLE DOT	# →ᐄᐧ→
+
+1413 ;	1405 00B7 ;	MA	# ( ᐓ → ᐅ· ) CANADIAN SYLLABICS WEST-CREE WO → CANADIAN SYLLABICS O, MIDDLE DOT	# →ᐅᐧ→
+
+142D ;	1405 1420 ;	MA	# ( ᐭ → ᐅᐠ ) CANADIAN SYLLABICS ON → CANADIAN SYLLABICS O, CANADIAN SYLLABICS FINAL GRAVE	# 
+
+1415 ;	1406 00B7 ;	MA	# ( ᐕ → ᐆ· ) CANADIAN SYLLABICS WEST-CREE WOO → CANADIAN SYLLABICS OO, MIDDLE DOT	# →ᐆᐧ→
+
+1418 ;	140A 00B7 ;	MA	# ( ᐘ → ᐊ· ) CANADIAN SYLLABICS WEST-CREE WA → CANADIAN SYLLABICS A, MIDDLE DOT	# →ᐊᐧ→
+
+142E ;	140A 1420 ;	MA	# ( ᐮ → ᐊᐠ ) CANADIAN SYLLABICS AN → CANADIAN SYLLABICS A, CANADIAN SYLLABICS FINAL GRAVE	# 
+
+141A ;	140B 00B7 ;	MA	# ( ᐚ → ᐋ· ) CANADIAN SYLLABICS WEST-CREE WAA → CANADIAN SYLLABICS AA, MIDDLE DOT	# →ᐋᐧ→
+
+18DD ;	141E 18DF ;	MA	# ( ᣝ → ᐞᣟ ) CANADIAN SYLLABICS WESTERN W → CANADIAN SYLLABICS GLOTTAL STOP, CANADIAN SYLLABICS FINAL RAISED DOT	# 
+
+14D1 ;	1421 ;	MA	# ( ᓑ → ᐡ ) CANADIAN SYLLABICS CARRIER NG → CANADIAN SYLLABICS FINAL BOTTOM HALF RING	# 
+
+1540 ;	1429 ;	MA	# ( ᕀ → ᐩ ) CANADIAN SYLLABICS WEST-CREE Y → CANADIAN SYLLABICS FINAL PLUS	# 
+
+143F ;	1432 00B7 ;	MA	# ( ᐿ → ᐲ· ) CANADIAN SYLLABICS WEST-CREE PWII → CANADIAN SYLLABICS PII, MIDDLE DOT	# →ᐲᐧ→
+
+1443 ;	1434 00B7 ;	MA	# ( ᑃ → ᐴ· ) CANADIAN SYLLABICS WEST-CREE PWOO → CANADIAN SYLLABICS POO, MIDDLE DOT	# →ᐴᐧ→
+
+2369 ;	1435 ;	MA	#* ( ⍩ → ᐵ ) APL FUNCTIONAL SYMBOL GREATER-THAN DIAERESIS → CANADIAN SYLLABICS Y-CREE POO	# 
+
+1447 ;	1439 00B7 ;	MA	# ( ᑇ → ᐹ· ) CANADIAN SYLLABICS WEST-CREE PWAA → CANADIAN SYLLABICS PAA, MIDDLE DOT	# →ᐹᐧ→
+
+145C ;	144F 00B7 ;	MA	# ( ᑜ → ᑏ· ) CANADIAN SYLLABICS WEST-CREE TWII → CANADIAN SYLLABICS TII, MIDDLE DOT	# →ᑏᐧ→
+
+2E27 ;	1450 ;	MA	#* ( ⸧ → ᑐ ) RIGHT SIDEWAYS U BRACKET → CANADIAN SYLLABICS TO	# →⊃→
+2283 ;	1450 ;	MA	#* ( ⊃ → ᑐ ) SUPERSET OF → CANADIAN SYLLABICS TO	# 
+
+145E ;	1450 00B7 ;	MA	# ( ᑞ → ᑐ· ) CANADIAN SYLLABICS WEST-CREE TWO → CANADIAN SYLLABICS TO, MIDDLE DOT	# →ᑐᐧ→
+
+1469 ;	1450 0027 ;	MA	# ( ᑩ → ᑐ' ) CANADIAN SYLLABICS TTO → CANADIAN SYLLABICS TO, APOSTROPHE	# →ᑐᑊ→
+
+27C9 ;	1450 002F ;	MA	#* ( ⟉ → ᑐ/ ) SUPERSET PRECEDING SOLIDUS → CANADIAN SYLLABICS TO, SOLIDUS	# →⊃/→
+
+2AD7 ;	1450 1455 ;	MA	#* ( ⫗ → ᑐᑕ ) SUPERSET BESIDE SUBSET → CANADIAN SYLLABICS TO, CANADIAN SYLLABICS TA	# →⊃⊂→
+
+1460 ;	1451 00B7 ;	MA	# ( ᑠ → ᑑ· ) CANADIAN SYLLABICS WEST-CREE TWOO → CANADIAN SYLLABICS TOO, MIDDLE DOT	# →ᑑᐧ→
+
+2E26 ;	1455 ;	MA	#* ( ⸦ → ᑕ ) LEFT SIDEWAYS U BRACKET → CANADIAN SYLLABICS TA	# →⊂→
+2282 ;	1455 ;	MA	#* ( ⊂ → ᑕ ) SUBSET OF → CANADIAN SYLLABICS TA	# 
+
+1462 ;	1455 00B7 ;	MA	# ( ᑢ → ᑕ· ) CANADIAN SYLLABICS WEST-CREE TWA → CANADIAN SYLLABICS TA, MIDDLE DOT	# →ᑕᐧ→
+
+146A ;	1455 0027 ;	MA	# ( ᑪ → ᑕ' ) CANADIAN SYLLABICS TTA → CANADIAN SYLLABICS TA, APOSTROPHE	# →ᑕᑊ→
+
+1464 ;	1456 00B7 ;	MA	# ( ᑤ → ᑖ· ) CANADIAN SYLLABICS WEST-CREE TWAA → CANADIAN SYLLABICS TAA, MIDDLE DOT	# →ᑖᐧ→
+
+1475 ;	146B 00B7 ;	MA	# ( ᑵ → ᑫ· ) CANADIAN SYLLABICS WEST-CREE KWE → CANADIAN SYLLABICS KE, MIDDLE DOT	# →ᑫᐧ→
+
+1485 ;	146B 0027 ;	MA	# ( ᒅ → ᑫ' ) CANADIAN SYLLABICS SOUTH-SLAVEY KEH → CANADIAN SYLLABICS KE, APOSTROPHE	# →ᑫᑊ→
+
+1479 ;	146E 00B7 ;	MA	# ( ᑹ → ᑮ· ) CANADIAN SYLLABICS WEST-CREE KWII → CANADIAN SYLLABICS KII, MIDDLE DOT	# →ᑮᐧ→
+
+147D ;	1470 00B7 ;	MA	# ( ᑽ → ᑰ· ) CANADIAN SYLLABICS WEST-CREE KWOO → CANADIAN SYLLABICS KOO, MIDDLE DOT	# →ᑰᐧ→
+
+1603 ;	1489 ;	MA	# ( ᘃ → ᒉ ) CANADIAN SYLLABICS CARRIER NO → CANADIAN SYLLABICS CE	# 
+
+1493 ;	1489 00B7 ;	MA	# ( ᒓ → ᒉ· ) CANADIAN SYLLABICS WEST-CREE CWE → CANADIAN SYLLABICS CE, MIDDLE DOT	# →ᒉᐧ→
+
+1495 ;	148B 00B7 ;	MA	# ( ᒕ → ᒋ· ) CANADIAN SYLLABICS WEST-CREE CWI → CANADIAN SYLLABICS CI, MIDDLE DOT	# →ᒋᐧ→
+
+1497 ;	148C 00B7 ;	MA	# ( ᒗ → ᒌ· ) CANADIAN SYLLABICS WEST-CREE CWII → CANADIAN SYLLABICS CII, MIDDLE DOT	# →ᒌᐧ→
+
+149B ;	148E 00B7 ;	MA	# ( ᒛ → ᒎ· ) CANADIAN SYLLABICS WEST-CREE CWOO → CANADIAN SYLLABICS COO, MIDDLE DOT	# →ᒎᐧ→
+
+1602 ;	1490 ;	MA	# ( ᘂ → ᒐ ) CANADIAN SYLLABICS CARRIER NU → CANADIAN SYLLABICS CA	# 
+
+149D ;	1490 00B7 ;	MA	# ( ᒝ → ᒐ· ) CANADIAN SYLLABICS WEST-CREE CWA → CANADIAN SYLLABICS CA, MIDDLE DOT	# →ᒐᐧ→
+
+149F ;	1491 00B7 ;	MA	# ( ᒟ → ᒑ· ) CANADIAN SYLLABICS WEST-CREE CWAA → CANADIAN SYLLABICS CAA, MIDDLE DOT	# →ᒑᐧ→
+
+14AD ;	14A3 00B7 ;	MA	# ( ᒭ → ᒣ· ) CANADIAN SYLLABICS WEST-CREE MWE → CANADIAN SYLLABICS ME, MIDDLE DOT	# →ᒣᐧ→
+
+14B1 ;	14A6 00B7 ;	MA	# ( ᒱ → ᒦ· ) CANADIAN SYLLABICS WEST-CREE MWII → CANADIAN SYLLABICS MII, MIDDLE DOT	# →ᒦᐧ→
+
+14B3 ;	14A7 00B7 ;	MA	# ( ᒳ → ᒧ· ) CANADIAN SYLLABICS WEST-CREE MWO → CANADIAN SYLLABICS MO, MIDDLE DOT	# →ᒧᐧ→
+
+14B5 ;	14A8 00B7 ;	MA	# ( ᒵ → ᒨ· ) CANADIAN SYLLABICS WEST-CREE MWOO → CANADIAN SYLLABICS MOO, MIDDLE DOT	# →ᒨᐧ→
+
+14B9 ;	14AB 00B7 ;	MA	# ( ᒹ → ᒫ· ) CANADIAN SYLLABICS WEST-CREE MWAA → CANADIAN SYLLABICS MAA, MIDDLE DOT	# →ᒫᐧ→
+
+14CA ;	14C0 00B7 ;	MA	# ( ᓊ → ᓀ· ) CANADIAN SYLLABICS WEST-CREE NWE → CANADIAN SYLLABICS NE, MIDDLE DOT	# →ᓀᐧ→
+
+18C7 ;	14C2 00B7 ;	MA	# ( ᣇ → ᓂ· ) CANADIAN SYLLABICS OJIBWAY NWI → CANADIAN SYLLABICS NI, MIDDLE DOT	# →ᓂᐧ→
+
+18C9 ;	14C3 00B7 ;	MA	# ( ᣉ → ᓃ· ) CANADIAN SYLLABICS OJIBWAY NWII → CANADIAN SYLLABICS NII, MIDDLE DOT	# →ᓃᐧ→
+
+18CB ;	14C4 00B7 ;	MA	# ( ᣋ → ᓄ· ) CANADIAN SYLLABICS OJIBWAY NWO → CANADIAN SYLLABICS NO, MIDDLE DOT	# →ᓄᐧ→
+
+18CD ;	14C5 00B7 ;	MA	# ( ᣍ → ᓅ· ) CANADIAN SYLLABICS OJIBWAY NWOO → CANADIAN SYLLABICS NOO, MIDDLE DOT	# →ᓅᐧ→
+
+14CC ;	14C7 00B7 ;	MA	# ( ᓌ → ᓇ· ) CANADIAN SYLLABICS WEST-CREE NWA → CANADIAN SYLLABICS NA, MIDDLE DOT	# →ᓇᐧ→
+
+14CE ;	14C8 00B7 ;	MA	# ( ᓎ → ᓈ· ) CANADIAN SYLLABICS WEST-CREE NWAA → CANADIAN SYLLABICS NAA, MIDDLE DOT	# →ᓈᐧ→
+
+1604 ;	14D3 ;	MA	# ( ᘄ → ᓓ ) CANADIAN SYLLABICS CARRIER NE → CANADIAN SYLLABICS LE	# 
+
+14DD ;	14D3 00B7 ;	MA	# ( ᓝ → ᓓ· ) CANADIAN SYLLABICS WEST-CREE LWE → CANADIAN SYLLABICS LE, MIDDLE DOT	# →ᓓᐧ→
+
+14DF ;	14D5 00B7 ;	MA	# ( ᓟ → ᓕ· ) CANADIAN SYLLABICS WEST-CREE LWI → CANADIAN SYLLABICS LI, MIDDLE DOT	# →ᓕᐧ→
+
+14E1 ;	14D6 00B7 ;	MA	# ( ᓡ → ᓖ· ) CANADIAN SYLLABICS WEST-CREE LWII → CANADIAN SYLLABICS LII, MIDDLE DOT	# →ᓖᐧ→
+
+14E3 ;	14D7 00B7 ;	MA	# ( ᓣ → ᓗ· ) CANADIAN SYLLABICS WEST-CREE LWO → CANADIAN SYLLABICS LO, MIDDLE DOT	# →ᓗᐧ→
+
+14E5 ;	14D8 00B7 ;	MA	# ( ᓥ → ᓘ· ) CANADIAN SYLLABICS WEST-CREE LWOO → CANADIAN SYLLABICS LOO, MIDDLE DOT	# →ᓘᐧ→
+
+1607 ;	14DA ;	MA	# ( ᘇ → ᓚ ) CANADIAN SYLLABICS CARRIER NA → CANADIAN SYLLABICS LA	# 
+
+14E7 ;	14DA 00B7 ;	MA	# ( ᓧ → ᓚ· ) CANADIAN SYLLABICS WEST-CREE LWA → CANADIAN SYLLABICS LA, MIDDLE DOT	# →ᓚᐧ→
+
+14E9 ;	14DB 00B7 ;	MA	# ( ᓩ → ᓛ· ) CANADIAN SYLLABICS WEST-CREE LWAA → CANADIAN SYLLABICS LAA, MIDDLE DOT	# →ᓛᐧ→
+
+14F7 ;	14ED 00B7 ;	MA	# ( ᓷ → ᓭ· ) CANADIAN SYLLABICS WEST-CREE SWE → CANADIAN SYLLABICS SE, MIDDLE DOT	# →ᓭᐧ→
+
+14F9 ;	14EF 00B7 ;	MA	# ( ᓹ → ᓯ· ) CANADIAN SYLLABICS WEST-CREE SWI → CANADIAN SYLLABICS SI, MIDDLE DOT	# →ᓯᐧ→
+
+14FB ;	14F0 00B7 ;	MA	# ( ᓻ → ᓰ· ) CANADIAN SYLLABICS WEST-CREE SWII → CANADIAN SYLLABICS SII, MIDDLE DOT	# →ᓰᐧ→
+
+14FD ;	14F1 00B7 ;	MA	# ( ᓽ → ᓱ· ) CANADIAN SYLLABICS WEST-CREE SWO → CANADIAN SYLLABICS SO, MIDDLE DOT	# →ᓱᐧ→
+
+14FF ;	14F2 00B7 ;	MA	# ( ᓿ → ᓲ· ) CANADIAN SYLLABICS WEST-CREE SWOO → CANADIAN SYLLABICS SOO, MIDDLE DOT	# →ᓲᐧ→
+
+1501 ;	14F4 00B7 ;	MA	# ( ᔁ → ᓴ· ) CANADIAN SYLLABICS WEST-CREE SWA → CANADIAN SYLLABICS SA, MIDDLE DOT	# →ᓴᐧ→
+
+1503 ;	14F5 00B7 ;	MA	# ( ᔃ → ᓵ· ) CANADIAN SYLLABICS WEST-CREE SWAA → CANADIAN SYLLABICS SAA, MIDDLE DOT	# →ᓵᐧ→
+
+150C ;	150B 003C ;	MA	# ( ᔌ → ᔋ< ) CANADIAN SYLLABICS NASKAPI SPWA → CANADIAN SYLLABICS NASKAPI S-W, LESS-THAN SIGN	# →ᔋᐸ→
+
+150E ;	150B 0062 ;	MA	# ( ᔎ → ᔋb ) CANADIAN SYLLABICS NASKAPI SKWA → CANADIAN SYLLABICS NASKAPI S-W, LATIN SMALL LETTER B	# →ᔋᑲ→
+
+150D ;	150B 1455 ;	MA	# ( ᔍ → ᔋᑕ ) CANADIAN SYLLABICS NASKAPI STWA → CANADIAN SYLLABICS NASKAPI S-W, CANADIAN SYLLABICS TA	# 
+
+150F ;	150B 1490 ;	MA	# ( ᔏ → ᔋᒐ ) CANADIAN SYLLABICS NASKAPI SCWA → CANADIAN SYLLABICS NASKAPI S-W, CANADIAN SYLLABICS CA	# 
+
+1518 ;	1510 00B7 ;	MA	# ( ᔘ → ᔐ· ) CANADIAN SYLLABICS WEST-CREE SHWE → CANADIAN SYLLABICS SHE, MIDDLE DOT	# →ᔐᐧ→
+
+151A ;	1511 00B7 ;	MA	# ( ᔚ → ᔑ· ) CANADIAN SYLLABICS WEST-CREE SHWI → CANADIAN SYLLABICS SHI, MIDDLE DOT	# →ᔑᐧ→
+
+151C ;	1512 00B7 ;	MA	# ( ᔜ → ᔒ· ) CANADIAN SYLLABICS WEST-CREE SHWII → CANADIAN SYLLABICS SHII, MIDDLE DOT	# →ᔒᐧ→
+
+151E ;	1513 00B7 ;	MA	# ( ᔞ → ᔓ· ) CANADIAN SYLLABICS WEST-CREE SHWO → CANADIAN SYLLABICS SHO, MIDDLE DOT	# →ᔓᐧ→
+
+1520 ;	1514 00B7 ;	MA	# ( ᔠ → ᔔ· ) CANADIAN SYLLABICS WEST-CREE SHWOO → CANADIAN SYLLABICS SHOO, MIDDLE DOT	# →ᔔᐧ→
+
+1522 ;	1515 00B7 ;	MA	# ( ᔢ → ᔕ· ) CANADIAN SYLLABICS WEST-CREE SHWA → CANADIAN SYLLABICS SHA, MIDDLE DOT	# →ᔕᐧ→
+
+1524 ;	1516 00B7 ;	MA	# ( ᔤ → ᔖ· ) CANADIAN SYLLABICS WEST-CREE SHWAA → CANADIAN SYLLABICS SHAA, MIDDLE DOT	# →ᔖᐧ→
+
+1532 ;	1528 00B7 ;	MA	# ( ᔲ → ᔨ· ) CANADIAN SYLLABICS WEST-CREE YWI → CANADIAN SYLLABICS YI, MIDDLE DOT	# →ᔨᐧ→
+
+1534 ;	1529 00B7 ;	MA	# ( ᔴ → ᔩ· ) CANADIAN SYLLABICS WEST-CREE YWII → CANADIAN SYLLABICS YII, MIDDLE DOT	# →ᔩᐧ→
+
+1536 ;	152A 00B7 ;	MA	# ( ᔶ → ᔪ· ) CANADIAN SYLLABICS WEST-CREE YWO → CANADIAN SYLLABICS YO, MIDDLE DOT	# →ᔪᐧ→
+
+1538 ;	152B 00B7 ;	MA	# ( ᔸ → ᔫ· ) CANADIAN SYLLABICS WEST-CREE YWOO → CANADIAN SYLLABICS YOO, MIDDLE DOT	# →ᔫᐧ→
+
+153A ;	152D 00B7 ;	MA	# ( ᔺ → ᔭ· ) CANADIAN SYLLABICS WEST-CREE YWA → CANADIAN SYLLABICS YA, MIDDLE DOT	# →ᔭᐧ→
+
+153C ;	152E 00B7 ;	MA	# ( ᔼ → ᔮ· ) CANADIAN SYLLABICS WEST-CREE YWAA → CANADIAN SYLLABICS YAA, MIDDLE DOT	# →ᔮᐧ→
+
+1622 ;	1543 ;	MA	# ( ᘢ → ᕃ ) CANADIAN SYLLABICS CARRIER LU → CANADIAN SYLLABICS R-CREE RE	# 
+
+18E0 ;	1543 00B7 ;	MA	# ( ᣠ → ᕃ· ) CANADIAN SYLLABICS R-CREE RWE → CANADIAN SYLLABICS R-CREE RE, MIDDLE DOT	# →ᕃᐧ→
+
+1623 ;	1546 ;	MA	# ( ᘣ → ᕆ ) CANADIAN SYLLABICS CARRIER LO → CANADIAN SYLLABICS RI	# 
+
+1624 ;	154A ;	MA	# ( ᘤ → ᕊ ) CANADIAN SYLLABICS CARRIER LE → CANADIAN SYLLABICS WEST-CREE LO	# 
+
+154F ;	154C 00B7 ;	MA	# ( ᕏ → ᕌ· ) CANADIAN SYLLABICS WEST-CREE RWAA → CANADIAN SYLLABICS RAA, MIDDLE DOT	# →ᕌᐧ→
+
+1583 ;	1550 0062 ;	MA	# ( ᖃ → ᕐb ) CANADIAN SYLLABICS QA → CANADIAN SYLLABICS R, LATIN SMALL LETTER B	# →ᕐᑲ→
+
+1584 ;	1550 0062 0307 ;	MA	# ( ᖄ → ᕐḃ ) CANADIAN SYLLABICS QAA → CANADIAN SYLLABICS R, LATIN SMALL LETTER B, COMBINING DOT ABOVE	# →ᕐᑳ→
+
+1581 ;	1550 0064 ;	MA	# ( ᖁ → ᕐd ) CANADIAN SYLLABICS QO → CANADIAN SYLLABICS R, LATIN SMALL LETTER D	# →ᕐᑯ→
+
+157F ;	1550 0050 ;	MA	# ( ᕿ → ᕐP ) CANADIAN SYLLABICS QI → CANADIAN SYLLABICS R, LATIN CAPITAL LETTER P	# →ᕐᑭ→
+
+166F ;	1550 146B ;	MA	# ( ᙯ → ᕐᑫ ) CANADIAN SYLLABICS QAI → CANADIAN SYLLABICS R, CANADIAN SYLLABICS KE	# 
+
+157E ;	1550 146C ;	MA	# ( ᕾ → ᕐᑬ ) CANADIAN SYLLABICS QAAI → CANADIAN SYLLABICS R, CANADIAN SYLLABICS KAAI	# 
+
+1580 ;	1550 146E ;	MA	# ( ᖀ → ᕐᑮ ) CANADIAN SYLLABICS QII → CANADIAN SYLLABICS R, CANADIAN SYLLABICS KII	# 
+
+1582 ;	1550 1470 ;	MA	# ( ᖂ → ᕐᑰ ) CANADIAN SYLLABICS QOO → CANADIAN SYLLABICS R, CANADIAN SYLLABICS KOO	# 
+
+1585 ;	1550 1483 ;	MA	# ( ᖅ → ᕐᒃ ) CANADIAN SYLLABICS Q → CANADIAN SYLLABICS R, CANADIAN SYLLABICS K	# 
+
+155C ;	155A 00B7 ;	MA	# ( ᕜ → ᕚ· ) CANADIAN SYLLABICS WEST-CREE FWAA → CANADIAN SYLLABICS FAA, MIDDLE DOT	# →ᕚᐧ→
+
+18E3 ;	155E 00B7 ;	MA	# ( ᣣ → ᕞ· ) CANADIAN SYLLABICS THWE → CANADIAN SYLLABICS THE, MIDDLE DOT	# →ᕞᐧ→
+
+18E4 ;	1566 00B7 ;	MA	# ( ᣤ → ᕦ· ) CANADIAN SYLLABICS THWA → CANADIAN SYLLABICS THA, MIDDLE DOT	# →ᕦᐧ→
+
+1569 ;	1567 00B7 ;	MA	# ( ᕩ → ᕧ· ) CANADIAN SYLLABICS WEST-CREE THWAA → CANADIAN SYLLABICS THAA, MIDDLE DOT	# →ᕧᐧ→
+
+18E5 ;	156B 00B7 ;	MA	# ( ᣥ → ᕫ· ) CANADIAN SYLLABICS TTHWE → CANADIAN SYLLABICS TTHE, MIDDLE DOT	# →ᕫᐧ→
+
+18E8 ;	1586 00B7 ;	MA	# ( ᣨ → ᖆ· ) CANADIAN SYLLABICS TLHWE → CANADIAN SYLLABICS TLHE, MIDDLE DOT	# →ᖆᐧ→
+
+1591 ;	1595 004A ;	MA	# ( ᖑ → ᖕJ ) CANADIAN SYLLABICS NGO → CANADIAN SYLLABICS NG, LATIN CAPITAL LETTER J	# →ᖕᒍ→
+
+1670 ;	1595 1489 ;	MA	# ( ᙰ → ᖕᒉ ) CANADIAN SYLLABICS NGAI → CANADIAN SYLLABICS NG, CANADIAN SYLLABICS CE	# 
+
+158E ;	1595 148A ;	MA	# ( ᖎ → ᖕᒊ ) CANADIAN SYLLABICS NGAAI → CANADIAN SYLLABICS NG, CANADIAN SYLLABICS CAAI	# 
+
+158F ;	1595 148B ;	MA	# ( ᖏ → ᖕᒋ ) CANADIAN SYLLABICS NGI → CANADIAN SYLLABICS NG, CANADIAN SYLLABICS CI	# 
+
+1590 ;	1595 148C ;	MA	# ( ᖐ → ᖕᒌ ) CANADIAN SYLLABICS NGII → CANADIAN SYLLABICS NG, CANADIAN SYLLABICS CII	# 
+
+1592 ;	1595 148E ;	MA	# ( ᖒ → ᖕᒎ ) CANADIAN SYLLABICS NGOO → CANADIAN SYLLABICS NG, CANADIAN SYLLABICS COO	# 
+
+1593 ;	1595 1490 ;	MA	# ( ᖓ → ᖕᒐ ) CANADIAN SYLLABICS NGA → CANADIAN SYLLABICS NG, CANADIAN SYLLABICS CA	# 
+
+1594 ;	1595 1491 ;	MA	# ( ᖔ → ᖕᒑ ) CANADIAN SYLLABICS NGAA → CANADIAN SYLLABICS NG, CANADIAN SYLLABICS CAA	# 
+
+1673 ;	1596 004A ;	MA	# ( ᙳ → ᖖJ ) CANADIAN SYLLABICS NNGO → CANADIAN SYLLABICS NNG, LATIN CAPITAL LETTER J	# →ᖖᒍ→
+
+1671 ;	1596 148B ;	MA	# ( ᙱ → ᖖᒋ ) CANADIAN SYLLABICS NNGI → CANADIAN SYLLABICS NNG, CANADIAN SYLLABICS CI	# 
+
+1672 ;	1596 148C ;	MA	# ( ᙲ → ᖖᒌ ) CANADIAN SYLLABICS NNGII → CANADIAN SYLLABICS NNG, CANADIAN SYLLABICS CII	# 
+
+1674 ;	1596 148E ;	MA	# ( ᙴ → ᖖᒎ ) CANADIAN SYLLABICS NNGOO → CANADIAN SYLLABICS NNG, CANADIAN SYLLABICS COO	# 
+
+1675 ;	1596 1490 ;	MA	# ( ᙵ → ᖖᒐ ) CANADIAN SYLLABICS NNGA → CANADIAN SYLLABICS NNG, CANADIAN SYLLABICS CA	# 
+
+1676 ;	1596 1491 ;	MA	# ( ᙶ → ᖖᒑ ) CANADIAN SYLLABICS NNGAA → CANADIAN SYLLABICS NNG, CANADIAN SYLLABICS CAA	# 
+
+18EA ;	1597 00B7 ;	MA	# ( ᣪ → ᖗ· ) CANADIAN SYLLABICS SAYISI SHWE → CANADIAN SYLLABICS SAYISI SHE, MIDDLE DOT	# →ᖗᐧ→
+
+1677 ;	15A7 00B7 ;	MA	# ( ᙷ → ᖧ· ) CANADIAN SYLLABICS WOODS-CREE THWEE → CANADIAN SYLLABICS TH-CREE THE, MIDDLE DOT	# →ᖧᐧ→
+
+1678 ;	15A8 00B7 ;	MA	# ( ᙸ → ᖨ· ) CANADIAN SYLLABICS WOODS-CREE THWI → CANADIAN SYLLABICS TH-CREE THI, MIDDLE DOT	# →ᖨᐧ→
+
+1679 ;	15A9 00B7 ;	MA	# ( ᙹ → ᖩ· ) CANADIAN SYLLABICS WOODS-CREE THWII → CANADIAN SYLLABICS TH-CREE THII, MIDDLE DOT	# →ᖩᐧ→
+
+167A ;	15AA 00B7 ;	MA	# ( ᙺ → ᖪ· ) CANADIAN SYLLABICS WOODS-CREE THWO → CANADIAN SYLLABICS TH-CREE THO, MIDDLE DOT	# →ᖪᐧ→
+
+167B ;	15AB 00B7 ;	MA	# ( ᙻ → ᖫ· ) CANADIAN SYLLABICS WOODS-CREE THWOO → CANADIAN SYLLABICS TH-CREE THOO, MIDDLE DOT	# →ᖫᐧ→
+
+167C ;	15AC 00B7 ;	MA	# ( ᙼ → ᖬ· ) CANADIAN SYLLABICS WOODS-CREE THWA → CANADIAN SYLLABICS TH-CREE THA, MIDDLE DOT	# →ᖬᐧ→
+
+167D ;	15AD 00B7 ;	MA	# ( ᙽ → ᖭ· ) CANADIAN SYLLABICS WOODS-CREE THWAA → CANADIAN SYLLABICS TH-CREE THAA, MIDDLE DOT	# →ᖭᐧ→
+
+2AAB ;	15D2 ;	MA	#* ( ⪫ → ᗒ ) LARGER THAN → CANADIAN SYLLABICS CARRIER WE	# 
+
+2AAA ;	15D5 ;	MA	#* ( ⪪ → ᗕ ) SMALLER THAN → CANADIAN SYLLABICS CARRIER WA	# 
+
+A4F7 ;	15E1 ;	MA	# ( ꓷ → ᗡ ) LISU LETTER OE → CANADIAN SYLLABICS CARRIER THA	# 
+
+18F0 ;	15F4 00B7 ;	MA	# ( ᣰ → ᗴ· ) CANADIAN SYLLABICS CARRIER GWA → CANADIAN SYLLABICS CARRIER GA, MIDDLE DOT	# →ᗴᐧ→
+
+18F2 ;	161B 00B7 ;	MA	# ( ᣲ → ᘛ· ) CANADIAN SYLLABICS CARRIER JWA → CANADIAN SYLLABICS CARRIER JA, MIDDLE DOT	# →ᘛᐧ→
+
+1DBB ;	1646 ;	MA	# ( ᶻ → ᙆ ) MODIFIER LETTER SMALL Z → CANADIAN SYLLABICS CARRIER Z	# 
+
+A4ED ;	1660 ;	MA	# ( ꓭ → ᙠ ) LISU LETTER GHA → CANADIAN SYLLABICS CARRIER TSA	# 
+
+1DBA ;	18D4 ;	MA	# ( ᶺ → ᣔ ) MODIFIER LETTER SMALL TURNED V → CANADIAN SYLLABICS OJIBWAY P	# 
+
+1D3E ;	18D6 ;	MA	# ( ᴾ → ᣖ ) MODIFIER LETTER CAPITAL P → CANADIAN SYLLABICS OJIBWAY K	# 
+
+18DC ;	18DF 141E ;	MA	# ( ᣜ → ᣟᐞ ) CANADIAN SYLLABICS EASTERN W → CANADIAN SYLLABICS FINAL RAISED DOT, CANADIAN SYLLABICS GLOTTAL STOP	# 
+
+02E1 ;	18F3 ;	MA	# ( ˡ → ᣳ ) MODIFIER LETTER SMALL L → CANADIAN SYLLABICS BEAVER DENE L	# 
+
+02B3 ;	18F4 ;	MA	# ( ʳ → ᣴ ) MODIFIER LETTER SMALL R → CANADIAN SYLLABICS BEAVER DENE R	# 
+
+02E2 ;	18F5 ;	MA	# ( ˢ → ᣵ ) MODIFIER LETTER SMALL S → CANADIAN SYLLABICS CARRIER DENTAL S	# 
+18DB ;	18F5 ;	MA	# ( ᣛ → ᣵ ) CANADIAN SYLLABICS OJIBWAY SH → CANADIAN SYLLABICS CARRIER DENTAL S	# →ˢ→
+A7F1 ;	18F5 ;	MA	# ( ꟱ → ᣵ ) MODIFIER LETTER CAPITAL S → CANADIAN SYLLABICS CARRIER DENTAL S	# →ˢ→
+
+A6B0 ;	16B9 ;	MA	# ( ꚰ → ᚹ ) BAMUM LETTER TAA → RUNIC LETTER WUNJO WYNN W	# 
+
+16E1 ;	16BC ;	MA	# ( ᛡ → ᚼ ) RUNIC LETTER IOR → RUNIC LETTER LONG-BRANCH-HAGALL H	# 
+
+237F ;	16BD ;	MA	#* ( ⍿ → ᚽ ) VERTICAL LINE WITH MIDDLE DOT → RUNIC LETTER SHORT-TWIG-HAGALL H	# →ᛂ→
+16C2 ;	16BD ;	MA	# ( ᛂ → ᚽ ) RUNIC LETTER E → RUNIC LETTER SHORT-TWIG-HAGALL H	# 
+
+1D23F ;	16CB ;	MA	#* ( 𝈿 → ᛋ ) GREEK INSTRUMENTAL NOTATION SYMBOL-52 → RUNIC LETTER SIGEL LONG-BRANCH-SOL S	# 
+
+2191 ;	16CF ;	MA	#* ( ↑ → ᛏ ) UPWARDS ARROW → RUNIC LETTER TIWAZ TIR TYR T	# 
+
+21BF ;	16D0 ;	MA	#* ( ↿ → ᛐ ) UPWARDS HARPOON WITH BARB LEFTWARDS → RUNIC LETTER SHORT-TWIG-TYR T	# 
+
+296E ;	16D0 21C2 ;	MA	#* ( ⥮ → ᛐ⇂ ) UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT → RUNIC LETTER SHORT-TWIG-TYR T, DOWNWARDS HARPOON WITH BARB RIGHTWARDS	# →↿⇂→
+
+2963 ;	16D0 16DA ;	MA	#* ( ⥣ → ᛐᛚ ) UPWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT → RUNIC LETTER SHORT-TWIG-TYR T, RUNIC LETTER LAUKAZ LAGU LOGR L	# →↿↾→
+
+2D63 ;	16EF ;	MA	# ( ⵣ → ᛯ ) TIFINAGH LETTER YAZ → RUNIC TVIMADUR SYMBOL	# 
+
+21BE ;	16DA ;	MA	#* ( ↾ → ᛚ ) UPWARDS HARPOON WITH BARB RIGHTWARDS → RUNIC LETTER LAUKAZ LAGU LOGR L	# 
+2A21 ;	16DA ;	MA	#* ( ⨡ → ᛚ ) Z NOTATION SCHEMA PROJECTION → RUNIC LETTER LAUKAZ LAGU LOGR L	# →↾→
+
+22C4 ;	16DC ;	MA	#* ( ⋄ → ᛜ ) DIAMOND OPERATOR → RUNIC LETTER INGWAZ	# →◇→
+25C7 ;	16DC ;	MA	#* ( ◇ → ᛜ ) WHITE DIAMOND → RUNIC LETTER INGWAZ	# 
+25CA ;	16DC ;	MA	#* ( ◊ → ᛜ ) LOZENGE → RUNIC LETTER INGWAZ	# →⋄→→◇→
+2662 ;	16DC ;	MA	#* ( ♢ → ᛜ ) WHITE DIAMOND SUIT → RUNIC LETTER INGWAZ	# →◊→→⋄→→◇→
+1F754 ;	16DC ;	MA	#* ( 🝔 → ᛜ ) ALCHEMICAL SYMBOL FOR SOAP → RUNIC LETTER INGWAZ	# →◇→
+118B7 ;	16DC ;	MA	# ( 𑢷 → ᛜ ) WARANG CITI CAPITAL LETTER BU → RUNIC LETTER INGWAZ	# →◇→
+10294 ;	16DC ;	MA	# ( 𐊔 → ᛜ ) LYCIAN LETTER KK → RUNIC LETTER INGWAZ	# →◇→
+
+235A ;	16DC 0332 ;	MA	#* ( ⍚ → ᛜ̲ ) APL FUNCTIONAL SYMBOL DIAMOND UNDERBAR → RUNIC LETTER INGWAZ, COMBINING LOW LINE	# →◇̲→
+
+22C8 ;	16DE ;	MA	#* ( ⋈ → ᛞ ) BOWTIE → RUNIC LETTER DAGAZ DAEG D	# 
+2A1D ;	16DE ;	MA	#* ( ⨝ → ᛞ ) JOIN → RUNIC LETTER DAGAZ DAEG D	# →⋈→
+
+104D0 ;	16E6 ;	MA	# ( 𐓐 → ᛦ ) OSAGE CAPITAL LETTER KHA → RUNIC LETTER LONG-BRANCH-YR	# 
+
+2195 ;	16E8 ;	MA	#* ( ↕ → ᛨ ) UP DOWN ARROW → RUNIC LETTER ICELANDIC-YR	# 
+
+10CFC ;	10C82 ;	MA	#* ( ‎𐳼‎ → ‎𐲂‎ ) OLD HUNGARIAN NUMBER TEN → OLD HUNGARIAN CAPITAL LETTER EB	# 
+
+10CFA ;	10CA5 ;	MA	#* ( ‎𐳺‎ → ‎𐲥‎ ) OLD HUNGARIAN NUMBER ONE → OLD HUNGARIAN CAPITAL LETTER ESZ	# 
+
+3131 ;	1100 ;	MA	# ( ㄱ → ᄀ ) HANGUL LETTER KIYEOK → HANGUL CHOSEONG KIYEOK	# 
+11A8 ;	1100 ;	MA	# ( ᆨ → ᄀ ) HANGUL JONGSEONG KIYEOK → HANGUL CHOSEONG KIYEOK	# 
+
+1101 ;	1100 1100 ;	MA	# ( ᄁ → ᄀᄀ ) HANGUL CHOSEONG SSANGKIYEOK → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG KIYEOK	# 
+3132 ;	1100 1100 ;	MA	# ( ㄲ → ᄀᄀ ) HANGUL LETTER SSANGKIYEOK → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG KIYEOK	# →ᄁ→
+11A9 ;	1100 1100 ;	MA	# ( ᆩ → ᄀᄀ ) HANGUL JONGSEONG SSANGKIYEOK → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG KIYEOK	# →ᄁ→
+
+11FA ;	1100 1102 ;	MA	# ( ᇺ → ᄀᄂ ) HANGUL JONGSEONG KIYEOK-NIEUN → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG NIEUN	# →ᆨᆫ→
+
+115A ;	1100 1103 ;	MA	# ( ᅚ → ᄀᄃ ) HANGUL CHOSEONG KIYEOK-TIKEUT → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG TIKEUT	# 
+
+11C3 ;	1100 1105 ;	MA	# ( ᇃ → ᄀᄅ ) HANGUL JONGSEONG KIYEOK-RIEUL → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG RIEUL	# →ᆨᆯ→
+
+11FB ;	1100 1107 ;	MA	# ( ᇻ → ᄀᄇ ) HANGUL JONGSEONG KIYEOK-PIEUP → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG PIEUP	# →ᆨᆸ→
+
+11AA ;	1100 1109 ;	MA	# ( ᆪ → ᄀᄉ ) HANGUL JONGSEONG KIYEOK-SIOS → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG SIOS	# →ᆨᆺ→
+3133 ;	1100 1109 ;	MA	# ( ㄳ → ᄀᄉ ) HANGUL LETTER KIYEOK-SIOS → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG SIOS	# →ᆪ→→ᆨᆺ→
+
+11C4 ;	1100 1109 1100 ;	MA	# ( ᇄ → ᄀᄉᄀ ) HANGUL JONGSEONG KIYEOK-SIOS-KIYEOK → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG KIYEOK	# →ᆨᆺᆨ→
+
+11FC ;	1100 110E ;	MA	# ( ᇼ → ᄀᄎ ) HANGUL JONGSEONG KIYEOK-CHIEUCH → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG CHIEUCH	# →ᆨᆾ→
+
+11FD ;	1100 110F ;	MA	# ( ᇽ → ᄀᄏ ) HANGUL JONGSEONG KIYEOK-KHIEUKH → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG KHIEUKH	# →ᆨᆿ→
+
+11FE ;	1100 1112 ;	MA	# ( ᇾ → ᄀᄒ ) HANGUL JONGSEONG KIYEOK-HIEUH → HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG HIEUH	# →ᆨᇂ→
+
+3134 ;	1102 ;	MA	# ( ㄴ → ᄂ ) HANGUL LETTER NIEUN → HANGUL CHOSEONG NIEUN	# 
+11AB ;	1102 ;	MA	# ( ᆫ → ᄂ ) HANGUL JONGSEONG NIEUN → HANGUL CHOSEONG NIEUN	# 
+
+1113 ;	1102 1100 ;	MA	# ( ᄓ → ᄂᄀ ) HANGUL CHOSEONG NIEUN-KIYEOK → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG KIYEOK	# 
+11C5 ;	1102 1100 ;	MA	# ( ᇅ → ᄂᄀ ) HANGUL JONGSEONG NIEUN-KIYEOK → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG KIYEOK	# →ᄓ→
+
+1114 ;	1102 1102 ;	MA	# ( ᄔ → ᄂᄂ ) HANGUL CHOSEONG SSANGNIEUN → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG NIEUN	# 
+3165 ;	1102 1102 ;	MA	# ( ㅥ → ᄂᄂ ) HANGUL LETTER SSANGNIEUN → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG NIEUN	# →ᄔ→
+11FF ;	1102 1102 ;	MA	# ( ᇿ → ᄂᄂ ) HANGUL JONGSEONG SSANGNIEUN → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG NIEUN	# →ᆫᆫ→
+
+1115 ;	1102 1103 ;	MA	# ( ᄕ → ᄂᄃ ) HANGUL CHOSEONG NIEUN-TIKEUT → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG TIKEUT	# 
+3166 ;	1102 1103 ;	MA	# ( ㅦ → ᄂᄃ ) HANGUL LETTER NIEUN-TIKEUT → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG TIKEUT	# →ᄕ→
+11C6 ;	1102 1103 ;	MA	# ( ᇆ → ᄂᄃ ) HANGUL JONGSEONG NIEUN-TIKEUT → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG TIKEUT	# →ᄕ→
+
+D7CB ;	1102 1105 ;	MA	# ( ퟋ → ᄂᄅ ) HANGUL JONGSEONG NIEUN-RIEUL → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG RIEUL	# →ᆫᆯ→
+
+1116 ;	1102 1107 ;	MA	# ( ᄖ → ᄂᄇ ) HANGUL CHOSEONG NIEUN-PIEUP → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG PIEUP	# 
+
+115B ;	1102 1109 ;	MA	# ( ᅛ → ᄂᄉ ) HANGUL CHOSEONG NIEUN-SIOS → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG SIOS	# 
+11C7 ;	1102 1109 ;	MA	# ( ᇇ → ᄂᄉ ) HANGUL JONGSEONG NIEUN-SIOS → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG SIOS	# →ᆫᆺ→
+3167 ;	1102 1109 ;	MA	# ( ㅧ → ᄂᄉ ) HANGUL LETTER NIEUN-SIOS → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG SIOS	# →ᇇ→→ᆫᆺ→
+
+115C ;	1102 110C ;	MA	# ( ᅜ → ᄂᄌ ) HANGUL CHOSEONG NIEUN-CIEUC → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG CIEUC	# 
+11AC ;	1102 110C ;	MA	# ( ᆬ → ᄂᄌ ) HANGUL JONGSEONG NIEUN-CIEUC → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG CIEUC	# →ᆫᆽ→
+3135 ;	1102 110C ;	MA	# ( ㄵ → ᄂᄌ ) HANGUL LETTER NIEUN-CIEUC → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG CIEUC	# →ᆬ→→ᆫᆽ→
+
+D7CC ;	1102 110E ;	MA	# ( ퟌ → ᄂᄎ ) HANGUL JONGSEONG NIEUN-CHIEUCH → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG CHIEUCH	# →ᆫᆾ→
+
+11C9 ;	1102 1110 ;	MA	# ( ᇉ → ᄂᄐ ) HANGUL JONGSEONG NIEUN-THIEUTH → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG THIEUTH	# →ᆫᇀ→
+
+115D ;	1102 1112 ;	MA	# ( ᅝ → ᄂᄒ ) HANGUL CHOSEONG NIEUN-HIEUH → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG HIEUH	# 
+11AD ;	1102 1112 ;	MA	# ( ᆭ → ᄂᄒ ) HANGUL JONGSEONG NIEUN-HIEUH → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG HIEUH	# →ᆫᇂ→
+3136 ;	1102 1112 ;	MA	# ( ㄶ → ᄂᄒ ) HANGUL LETTER NIEUN-HIEUH → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG HIEUH	# →ᆭ→→ᆫᇂ→
+
+11C8 ;	1102 1140 ;	MA	# ( ᇈ → ᄂᅀ ) HANGUL JONGSEONG NIEUN-PANSIOS → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG PANSIOS	# →ᆫᇫ→
+3168 ;	1102 1140 ;	MA	# ( ㅨ → ᄂᅀ ) HANGUL LETTER NIEUN-PANSIOS → HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG PANSIOS	# →ᇈ→→ᆫᇫ→
+
+723F ;	1102 116E 4E28 ;	MA	# ( 爿 → 누丨 ) CJK UNIFIED IDEOGRAPH-723F → HANGUL CHOSEONG NIEUN, HANGUL JUNGSEONG U, CJK UNIFIED IDEOGRAPH-4E28	# →뉘→→누ᅵ→
+2F59 ;	1102 116E 4E28 ;	MA	#* ( ⽙ → 누丨 ) KANGXI RADICAL HALF TREE TRUNK → HANGUL CHOSEONG NIEUN, HANGUL JUNGSEONG U, CJK UNIFIED IDEOGRAPH-4E28	# →爿→→뉘→→누ᅵ→
+
+3137 ;	1103 ;	MA	# ( ㄷ → ᄃ ) HANGUL LETTER TIKEUT → HANGUL CHOSEONG TIKEUT	# 
+11AE ;	1103 ;	MA	# ( ᆮ → ᄃ ) HANGUL JONGSEONG TIKEUT → HANGUL CHOSEONG TIKEUT	# 
+
+1117 ;	1103 1100 ;	MA	# ( ᄗ → ᄃᄀ ) HANGUL CHOSEONG TIKEUT-KIYEOK → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG KIYEOK	# 
+11CA ;	1103 1100 ;	MA	# ( ᇊ → ᄃᄀ ) HANGUL JONGSEONG TIKEUT-KIYEOK → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG KIYEOK	# →ᄗ→
+
+1104 ;	1103 1103 ;	MA	# ( ᄄ → ᄃᄃ ) HANGUL CHOSEONG SSANGTIKEUT → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG TIKEUT	# 
+3138 ;	1103 1103 ;	MA	# ( ㄸ → ᄃᄃ ) HANGUL LETTER SSANGTIKEUT → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG TIKEUT	# →ᄄ→
+D7CD ;	1103 1103 ;	MA	# ( ퟍ → ᄃᄃ ) HANGUL JONGSEONG SSANGTIKEUT → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG TIKEUT	# →ᆮᆮ→
+
+D7CE ;	1103 1103 1107 ;	MA	# ( ퟎ → ᄃᄃᄇ ) HANGUL JONGSEONG SSANGTIKEUT-PIEUP → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG PIEUP	# →ᆮᆮᆸ→
+
+115E ;	1103 1105 ;	MA	# ( ᅞ → ᄃᄅ ) HANGUL CHOSEONG TIKEUT-RIEUL → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG RIEUL	# 
+11CB ;	1103 1105 ;	MA	# ( ᇋ → ᄃᄅ ) HANGUL JONGSEONG TIKEUT-RIEUL → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG RIEUL	# →ᆮᆯ→
+
+A960 ;	1103 1106 ;	MA	# ( ꥠ → ᄃᄆ ) HANGUL CHOSEONG TIKEUT-MIEUM → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG MIEUM	# 
+
+A961 ;	1103 1107 ;	MA	# ( ꥡ → ᄃᄇ ) HANGUL CHOSEONG TIKEUT-PIEUP → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG PIEUP	# 
+D7CF ;	1103 1107 ;	MA	# ( ퟏ → ᄃᄇ ) HANGUL JONGSEONG TIKEUT-PIEUP → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG PIEUP	# →ᆮᆸ→
+
+A962 ;	1103 1109 ;	MA	# ( ꥢ → ᄃᄉ ) HANGUL CHOSEONG TIKEUT-SIOS → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG SIOS	# 
+D7D0 ;	1103 1109 ;	MA	# ( ퟐ → ᄃᄉ ) HANGUL JONGSEONG TIKEUT-SIOS → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG SIOS	# →ᆮᆺ→
+
+D7D1 ;	1103 1109 1100 ;	MA	# ( ퟑ → ᄃᄉᄀ ) HANGUL JONGSEONG TIKEUT-SIOS-KIYEOK → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG KIYEOK	# →ᆮᆺᆨ→
+
+A963 ;	1103 110C ;	MA	# ( ꥣ → ᄃᄌ ) HANGUL CHOSEONG TIKEUT-CIEUC → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG CIEUC	# 
+D7D2 ;	1103 110C ;	MA	# ( ퟒ → ᄃᄌ ) HANGUL JONGSEONG TIKEUT-CIEUC → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG CIEUC	# →ᆮᆽ→
+
+D7D3 ;	1103 110E ;	MA	# ( ퟓ → ᄃᄎ ) HANGUL JONGSEONG TIKEUT-CHIEUCH → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG CHIEUCH	# →ᆮᆾ→
+
+D7D4 ;	1103 1110 ;	MA	# ( ퟔ → ᄃᄐ ) HANGUL JONGSEONG TIKEUT-THIEUTH → HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG THIEUTH	# →ᆮᇀ→
+
+3139 ;	1105 ;	MA	# ( ㄹ → ᄅ ) HANGUL LETTER RIEUL → HANGUL CHOSEONG RIEUL	# 
+11AF ;	1105 ;	MA	# ( ᆯ → ᄅ ) HANGUL JONGSEONG RIEUL → HANGUL CHOSEONG RIEUL	# 
+
+A964 ;	1105 1100 ;	MA	# ( ꥤ → ᄅᄀ ) HANGUL CHOSEONG RIEUL-KIYEOK → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KIYEOK	# 
+11B0 ;	1105 1100 ;	MA	# ( ᆰ → ᄅᄀ ) HANGUL JONGSEONG RIEUL-KIYEOK → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KIYEOK	# →ᆯᆨ→
+313A ;	1105 1100 ;	MA	# ( ㄺ → ᄅᄀ ) HANGUL LETTER RIEUL-KIYEOK → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KIYEOK	# →ᆰ→→ᆯᆨ→
+
+A965 ;	1105 1100 1100 ;	MA	# ( ꥥ → ᄅᄀᄀ ) HANGUL CHOSEONG RIEUL-SSANGKIYEOK → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG KIYEOK	# 
+D7D5 ;	1105 1100 1100 ;	MA	# ( ퟕ → ᄅᄀᄀ ) HANGUL JONGSEONG RIEUL-SSANGKIYEOK → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG KIYEOK	# →ᆯᆨᆨ→
+
+11CC ;	1105 1100 1109 ;	MA	# ( ᇌ → ᄅᄀᄉ ) HANGUL JONGSEONG RIEUL-KIYEOK-SIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG SIOS	# →ᆯᆨᆺ→
+3169 ;	1105 1100 1109 ;	MA	# ( ㅩ → ᄅᄀᄉ ) HANGUL LETTER RIEUL-KIYEOK-SIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG SIOS	# →ᇌ→→ᆯᆨᆺ→
+
+D7D6 ;	1105 1100 1112 ;	MA	# ( ퟖ → ᄅᄀᄒ ) HANGUL JONGSEONG RIEUL-KIYEOK-HIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG HIEUH	# →ᆯᆨᇂ→
+
+1118 ;	1105 1102 ;	MA	# ( ᄘ → ᄅᄂ ) HANGUL CHOSEONG RIEUL-NIEUN → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG NIEUN	# 
+11CD ;	1105 1102 ;	MA	# ( ᇍ → ᄅᄂ ) HANGUL JONGSEONG RIEUL-NIEUN → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG NIEUN	# →ᄘ→
+
+A966 ;	1105 1103 ;	MA	# ( ꥦ → ᄅᄃ ) HANGUL CHOSEONG RIEUL-TIKEUT → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG TIKEUT	# 
+11CE ;	1105 1103 ;	MA	# ( ᇎ → ᄅᄃ ) HANGUL JONGSEONG RIEUL-TIKEUT → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG TIKEUT	# →ᆯᆮ→
+316A ;	1105 1103 ;	MA	# ( ㅪ → ᄅᄃ ) HANGUL LETTER RIEUL-TIKEUT → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG TIKEUT	# →ᇎ→→ᆯᆮ→
+
+A967 ;	1105 1103 1103 ;	MA	# ( ꥧ → ᄅᄃᄃ ) HANGUL CHOSEONG RIEUL-SSANGTIKEUT → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG TIKEUT	# 
+
+11CF ;	1105 1103 1112 ;	MA	# ( ᇏ → ᄅᄃᄒ ) HANGUL JONGSEONG RIEUL-TIKEUT-HIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG TIKEUT, HANGUL CHOSEONG HIEUH	# →ᆯᆮᇂ→
+
+1119 ;	1105 1105 ;	MA	# ( ᄙ → ᄅᄅ ) HANGUL CHOSEONG SSANGRIEUL → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG RIEUL	# 
+11D0 ;	1105 1105 ;	MA	# ( ᇐ → ᄅᄅ ) HANGUL JONGSEONG SSANGRIEUL → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG RIEUL	# →ᄙ→
+
+D7D7 ;	1105 1105 110F ;	MA	# ( ퟗ → ᄅᄅᄏ ) HANGUL JONGSEONG SSANGRIEUL-KHIEUKH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KHIEUKH	# →ᆯᆯᆿ→
+
+A968 ;	1105 1106 ;	MA	# ( ꥨ → ᄅᄆ ) HANGUL CHOSEONG RIEUL-MIEUM → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG MIEUM	# 
+11B1 ;	1105 1106 ;	MA	# ( ᆱ → ᄅᄆ ) HANGUL JONGSEONG RIEUL-MIEUM → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG MIEUM	# →ᆯᆷ→
+313B ;	1105 1106 ;	MA	# ( ㄻ → ᄅᄆ ) HANGUL LETTER RIEUL-MIEUM → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG MIEUM	# →ᆱ→→ᆯᆷ→
+
+11D1 ;	1105 1106 1100 ;	MA	# ( ᇑ → ᄅᄆᄀ ) HANGUL JONGSEONG RIEUL-MIEUM-KIYEOK → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG KIYEOK	# →ᆯᆷᆨ→
+
+11D2 ;	1105 1106 1109 ;	MA	# ( ᇒ → ᄅᄆᄉ ) HANGUL JONGSEONG RIEUL-MIEUM-SIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG SIOS	# →ᆯᆷᆺ→
+
+D7D8 ;	1105 1106 1112 ;	MA	# ( ퟘ → ᄅᄆᄒ ) HANGUL JONGSEONG RIEUL-MIEUM-HIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG HIEUH	# →ᆯᆷᇂ→
+
+A969 ;	1105 1107 ;	MA	# ( ꥩ → ᄅᄇ ) HANGUL CHOSEONG RIEUL-PIEUP → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP	# 
+11B2 ;	1105 1107 ;	MA	# ( ᆲ → ᄅᄇ ) HANGUL JONGSEONG RIEUL-PIEUP → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP	# →ᆯᆸ→
+313C ;	1105 1107 ;	MA	# ( ㄼ → ᄅᄇ ) HANGUL LETTER RIEUL-PIEUP → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP	# →ᆲ→→ᆯᆸ→
+
+D7D9 ;	1105 1107 1103 ;	MA	# ( ퟙ → ᄅᄇᄃ ) HANGUL JONGSEONG RIEUL-PIEUP-TIKEUT → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG TIKEUT	# →ᆯᆸᆮ→
+
+A96A ;	1105 1107 1107 ;	MA	# ( ꥪ → ᄅᄇᄇ ) HANGUL CHOSEONG RIEUL-SSANGPIEUP → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG PIEUP	# 
+
+11D3 ;	1105 1107 1109 ;	MA	# ( ᇓ → ᄅᄇᄉ ) HANGUL JONGSEONG RIEUL-PIEUP-SIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS	# →ᆯᆸᆺ→
+316B ;	1105 1107 1109 ;	MA	# ( ㅫ → ᄅᄇᄉ ) HANGUL LETTER RIEUL-PIEUP-SIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS	# →ᇓ→→ᆯᆸᆺ→
+
+A96B ;	1105 1107 110B ;	MA	# ( ꥫ → ᄅᄇᄋ ) HANGUL CHOSEONG RIEUL-KAPYEOUNPIEUP → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG IEUNG	# 
+11D5 ;	1105 1107 110B ;	MA	# ( ᇕ → ᄅᄇᄋ ) HANGUL JONGSEONG RIEUL-KAPYEOUNPIEUP → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG IEUNG	# →ᆯᆸᆼ→
+
+D7DA ;	1105 1107 1111 ;	MA	# ( ퟚ → ᄅᄇᄑ ) HANGUL JONGSEONG RIEUL-PIEUP-PHIEUPH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG PHIEUPH	# →ᆯᆸᇁ→
+
+11D4 ;	1105 1107 1112 ;	MA	# ( ᇔ → ᄅᄇᄒ ) HANGUL JONGSEONG RIEUL-PIEUP-HIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG HIEUH	# →ᆯᆸᇂ→
+
+A96C ;	1105 1109 ;	MA	# ( ꥬ → ᄅᄉ ) HANGUL CHOSEONG RIEUL-SIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG SIOS	# 
+11B3 ;	1105 1109 ;	MA	# ( ᆳ → ᄅᄉ ) HANGUL JONGSEONG RIEUL-SIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG SIOS	# →ᆯᆺ→
+313D ;	1105 1109 ;	MA	# ( ㄽ → ᄅᄉ ) HANGUL LETTER RIEUL-SIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG SIOS	# →ᆳ→→ᆯᆺ→
+
+11D6 ;	1105 1109 1109 ;	MA	# ( ᇖ → ᄅᄉᄉ ) HANGUL JONGSEONG RIEUL-SSANGSIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS	# →ᆯᆺᆺ→
+
+111B ;	1105 110B ;	MA	# ( ᄛ → ᄅᄋ ) HANGUL CHOSEONG KAPYEOUNRIEUL → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG IEUNG	# 
+D7DD ;	1105 110B ;	MA	# ( ퟝ → ᄅᄋ ) HANGUL JONGSEONG KAPYEOUNRIEUL → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG IEUNG	# →ᆯᆼ→
+
+A96D ;	1105 110C ;	MA	# ( ꥭ → ᄅᄌ ) HANGUL CHOSEONG RIEUL-CIEUC → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG CIEUC	# 
+
+A96E ;	1105 110F ;	MA	# ( ꥮ → ᄅᄏ ) HANGUL CHOSEONG RIEUL-KHIEUKH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KHIEUKH	# 
+11D8 ;	1105 110F ;	MA	# ( ᇘ → ᄅᄏ ) HANGUL JONGSEONG RIEUL-KHIEUKH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG KHIEUKH	# →ᆯᆿ→
+
+11B4 ;	1105 1110 ;	MA	# ( ᆴ → ᄅᄐ ) HANGUL JONGSEONG RIEUL-THIEUTH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG THIEUTH	# →ᆯᇀ→
+313E ;	1105 1110 ;	MA	# ( ㄾ → ᄅᄐ ) HANGUL LETTER RIEUL-THIEUTH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG THIEUTH	# →ᆴ→→ᆯᇀ→
+
+11B5 ;	1105 1111 ;	MA	# ( ᆵ → ᄅᄑ ) HANGUL JONGSEONG RIEUL-PHIEUPH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PHIEUPH	# →ᆯᇁ→
+313F ;	1105 1111 ;	MA	# ( ㄿ → ᄅᄑ ) HANGUL LETTER RIEUL-PHIEUPH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PHIEUPH	# →ᆵ→→ᆯᇁ→
+
+111A ;	1105 1112 ;	MA	# ( ᄚ → ᄅᄒ ) HANGUL CHOSEONG RIEUL-HIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG HIEUH	# 
+3140 ;	1105 1112 ;	MA	# ( ㅀ → ᄅᄒ ) HANGUL LETTER RIEUL-HIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG HIEUH	# →ᄚ→
+113B ;	1105 1112 ;	MA	# ( ᄻ → ᄅᄒ ) HANGUL CHOSEONG SIOS-HIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG HIEUH	# →ᄚ→
+11B6 ;	1105 1112 ;	MA	# ( ᆶ → ᄅᄒ ) HANGUL JONGSEONG RIEUL-HIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG HIEUH	# →ᄚ→
+D7F2 ;	1105 1112 ;	MA	# ( ퟲ → ᄅᄒ ) HANGUL JONGSEONG SIOS-HIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG HIEUH	# →ᆺᇂ→→ᄉᄒ→→ᄻ→→ᄚ→
+
+11D7 ;	1105 1140 ;	MA	# ( ᇗ → ᄅᅀ ) HANGUL JONGSEONG RIEUL-PANSIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PANSIOS	# →ᆯᇫ→
+316C ;	1105 1140 ;	MA	# ( ㅬ → ᄅᅀ ) HANGUL LETTER RIEUL-PANSIOS → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PANSIOS	# →ᇗ→→ᆯᇫ→
+
+D7DB ;	1105 114C ;	MA	# ( ퟛ → ᄅᅌ ) HANGUL JONGSEONG RIEUL-YESIEUNG → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG YESIEUNG	# →ᆯᇰ→
+
+11D9 ;	1105 1159 ;	MA	# ( ᇙ → ᄅᅙ ) HANGUL JONGSEONG RIEUL-YEORINHIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG YEORINHIEUH	# →ᆯᇹ→
+316D ;	1105 1159 ;	MA	# ( ㅭ → ᄅᅙ ) HANGUL LETTER RIEUL-YEORINHIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG YEORINHIEUH	# →ᇙ→→ᆯᇹ→
+
+D7DC ;	1105 1159 1112 ;	MA	# ( ퟜ → ᄅᅙᄒ ) HANGUL JONGSEONG RIEUL-YEORINHIEUH-HIEUH → HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG YEORINHIEUH, HANGUL CHOSEONG HIEUH	# →ᆯᇹᇂ→
+
+3141 ;	1106 ;	MA	# ( ㅁ → ᄆ ) HANGUL LETTER MIEUM → HANGUL CHOSEONG MIEUM	# 
+11B7 ;	1106 ;	MA	# ( ᆷ → ᄆ ) HANGUL JONGSEONG MIEUM → HANGUL CHOSEONG MIEUM	# 
+
+A96F ;	1106 1100 ;	MA	# ( ꥯ → ᄆᄀ ) HANGUL CHOSEONG MIEUM-KIYEOK → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG KIYEOK	# 
+11DA ;	1106 1100 ;	MA	# ( ᇚ → ᄆᄀ ) HANGUL JONGSEONG MIEUM-KIYEOK → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG KIYEOK	# →ᆷᆨ→
+
+D7DE ;	1106 1102 ;	MA	# ( ퟞ → ᄆᄂ ) HANGUL JONGSEONG MIEUM-NIEUN → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG NIEUN	# →ᆷᆫ→
+
+D7DF ;	1106 1102 1102 ;	MA	# ( ퟟ → ᄆᄂᄂ ) HANGUL JONGSEONG MIEUM-SSANGNIEUN → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG NIEUN	# →ᆷᆫᆫ→
+
+A970 ;	1106 1103 ;	MA	# ( ꥰ → ᄆᄃ ) HANGUL CHOSEONG MIEUM-TIKEUT → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG TIKEUT	# 
+
+11DB ;	1106 1105 ;	MA	# ( ᇛ → ᄆᄅ ) HANGUL JONGSEONG MIEUM-RIEUL → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG RIEUL	# →ᆷᆯ→
+
+D7E0 ;	1106 1106 ;	MA	# ( ퟠ → ᄆᄆ ) HANGUL JONGSEONG SSANGMIEUM → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG MIEUM	# →ᆷᆷ→
+
+111C ;	1106 1107 ;	MA	# ( ᄜ → ᄆᄇ ) HANGUL CHOSEONG MIEUM-PIEUP → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG PIEUP	# 
+316E ;	1106 1107 ;	MA	# ( ㅮ → ᄆᄇ ) HANGUL LETTER MIEUM-PIEUP → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG PIEUP	# →ᄜ→
+11DC ;	1106 1107 ;	MA	# ( ᇜ → ᄆᄇ ) HANGUL JONGSEONG MIEUM-PIEUP → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG PIEUP	# →ᄜ→
+
+D7E1 ;	1106 1107 1109 ;	MA	# ( ퟡ → ᄆᄇᄉ ) HANGUL JONGSEONG MIEUM-PIEUP-SIOS → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS	# →ᆷᆸᆺ→
+
+A971 ;	1106 1109 ;	MA	# ( ꥱ → ᄆᄉ ) HANGUL CHOSEONG MIEUM-SIOS → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG SIOS	# 
+11DD ;	1106 1109 ;	MA	# ( ᇝ → ᄆᄉ ) HANGUL JONGSEONG MIEUM-SIOS → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG SIOS	# →ᆷᆺ→
+316F ;	1106 1109 ;	MA	# ( ㅯ → ᄆᄉ ) HANGUL LETTER MIEUM-SIOS → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG SIOS	# →ᇝ→→ᆷᆺ→
+
+11DE ;	1106 1109 1109 ;	MA	# ( ᇞ → ᄆᄉᄉ ) HANGUL JONGSEONG MIEUM-SSANGSIOS → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS	# →ᆷᆺᆺ→
+
+111D ;	1106 110B ;	MA	# ( ᄝ → ᄆᄋ ) HANGUL CHOSEONG KAPYEOUNMIEUM → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG IEUNG	# 
+3171 ;	1106 110B ;	MA	# ( ㅱ → ᄆᄋ ) HANGUL LETTER KAPYEOUNMIEUM → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG IEUNG	# →ᄝ→
+11E2 ;	1106 110B ;	MA	# ( ᇢ → ᄆᄋ ) HANGUL JONGSEONG KAPYEOUNMIEUM → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG IEUNG	# →ᄝ→
+
+D7E2 ;	1106 110C ;	MA	# ( ퟢ → ᄆᄌ ) HANGUL JONGSEONG MIEUM-CIEUC → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG CIEUC	# →ᆷᆽ→
+
+11E0 ;	1106 110E ;	MA	# ( ᇠ → ᄆᄎ ) HANGUL JONGSEONG MIEUM-CHIEUCH → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG CHIEUCH	# →ᆷᆾ→
+
+11E1 ;	1106 1112 ;	MA	# ( ᇡ → ᄆᄒ ) HANGUL JONGSEONG MIEUM-HIEUH → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG HIEUH	# →ᆷᇂ→
+
+11DF ;	1106 1140 ;	MA	# ( ᇟ → ᄆᅀ ) HANGUL JONGSEONG MIEUM-PANSIOS → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG PANSIOS	# →ᆷᇫ→
+3170 ;	1106 1140 ;	MA	# ( ㅰ → ᄆᅀ ) HANGUL LETTER MIEUM-PANSIOS → HANGUL CHOSEONG MIEUM, HANGUL CHOSEONG PANSIOS	# →ᇟ→→ᆷᇫ→
+
+535F ;	1106 1161 ;	MA	# ( 卟 → 마 ) CJK UNIFIED IDEOGRAPH-535F → HANGUL CHOSEONG MIEUM, HANGUL JUNGSEONG A	# 
+
+3142 ;	1107 ;	MA	# ( ㅂ → ᄇ ) HANGUL LETTER PIEUP → HANGUL CHOSEONG PIEUP	# 
+11B8 ;	1107 ;	MA	# ( ᆸ → ᄇ ) HANGUL JONGSEONG PIEUP → HANGUL CHOSEONG PIEUP	# 
+
+111E ;	1107 1100 ;	MA	# ( ᄞ → ᄇᄀ ) HANGUL CHOSEONG PIEUP-KIYEOK → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG KIYEOK	# 
+3172 ;	1107 1100 ;	MA	# ( ㅲ → ᄇᄀ ) HANGUL LETTER PIEUP-KIYEOK → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG KIYEOK	# →ᄞ→
+
+111F ;	1107 1102 ;	MA	# ( ᄟ → ᄇᄂ ) HANGUL CHOSEONG PIEUP-NIEUN → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG NIEUN	# 
+
+1120 ;	1107 1103 ;	MA	# ( ᄠ → ᄇᄃ ) HANGUL CHOSEONG PIEUP-TIKEUT → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG TIKEUT	# 
+3173 ;	1107 1103 ;	MA	# ( ㅳ → ᄇᄃ ) HANGUL LETTER PIEUP-TIKEUT → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG TIKEUT	# →ᄠ→
+D7E3 ;	1107 1103 ;	MA	# ( ퟣ → ᄇᄃ ) HANGUL JONGSEONG PIEUP-TIKEUT → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG TIKEUT	# →ᆸᆮ→
+
+11E3 ;	1107 1105 ;	MA	# ( ᇣ → ᄇᄅ ) HANGUL JONGSEONG PIEUP-RIEUL → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG RIEUL	# →ᆸᆯ→
+
+D7E4 ;	1107 1105 1111 ;	MA	# ( ퟤ → ᄇᄅᄑ ) HANGUL JONGSEONG PIEUP-RIEUL-PHIEUPH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG RIEUL, HANGUL CHOSEONG PHIEUPH	# →ᆸᆯᇁ→
+
+D7E5 ;	1107 1106 ;	MA	# ( ퟥ → ᄇᄆ ) HANGUL JONGSEONG PIEUP-MIEUM → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG MIEUM	# →ᆸᆷ→
+
+1108 ;	1107 1107 ;	MA	# ( ᄈ → ᄇᄇ ) HANGUL CHOSEONG SSANGPIEUP → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG PIEUP	# 
+3143 ;	1107 1107 ;	MA	# ( ㅃ → ᄇᄇ ) HANGUL LETTER SSANGPIEUP → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG PIEUP	# →ᄈ→
+D7E6 ;	1107 1107 ;	MA	# ( ퟦ → ᄇᄇ ) HANGUL JONGSEONG SSANGPIEUP → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG PIEUP	# →ᆸᆸ→
+
+112C ;	1107 1107 110B ;	MA	# ( ᄬ → ᄇᄇᄋ ) HANGUL CHOSEONG KAPYEOUNSSANGPIEUP → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG IEUNG	# 
+3179 ;	1107 1107 110B ;	MA	# ( ㅹ → ᄇᄇᄋ ) HANGUL LETTER KAPYEOUNSSANGPIEUP → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG IEUNG	# →ᄬ→
+
+1121 ;	1107 1109 ;	MA	# ( ᄡ → ᄇᄉ ) HANGUL CHOSEONG PIEUP-SIOS → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS	# 
+3144 ;	1107 1109 ;	MA	# ( ㅄ → ᄇᄉ ) HANGUL LETTER PIEUP-SIOS → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS	# →ᄡ→
+11B9 ;	1107 1109 ;	MA	# ( ᆹ → ᄇᄉ ) HANGUL JONGSEONG PIEUP-SIOS → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS	# →ᄡ→
+
+1122 ;	1107 1109 1100 ;	MA	# ( ᄢ → ᄇᄉᄀ ) HANGUL CHOSEONG PIEUP-SIOS-KIYEOK → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG KIYEOK	# 
+3174 ;	1107 1109 1100 ;	MA	# ( ㅴ → ᄇᄉᄀ ) HANGUL LETTER PIEUP-SIOS-KIYEOK → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG KIYEOK	# →ᄢ→
+
+1123 ;	1107 1109 1103 ;	MA	# ( ᄣ → ᄇᄉᄃ ) HANGUL CHOSEONG PIEUP-SIOS-TIKEUT → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG TIKEUT	# 
+3175 ;	1107 1109 1103 ;	MA	# ( ㅵ → ᄇᄉᄃ ) HANGUL LETTER PIEUP-SIOS-TIKEUT → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG TIKEUT	# →ᄣ→
+D7E7 ;	1107 1109 1103 ;	MA	# ( ퟧ → ᄇᄉᄃ ) HANGUL JONGSEONG PIEUP-SIOS-TIKEUT → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG TIKEUT	# →ᆸᆺᆮ→
+
+1124 ;	1107 1109 1107 ;	MA	# ( ᄤ → ᄇᄉᄇ ) HANGUL CHOSEONG PIEUP-SIOS-PIEUP → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG PIEUP	# 
+
+1125 ;	1107 1109 1109 ;	MA	# ( ᄥ → ᄇᄉᄉ ) HANGUL CHOSEONG PIEUP-SSANGSIOS → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS	# 
+
+1126 ;	1107 1109 110C ;	MA	# ( ᄦ → ᄇᄉᄌ ) HANGUL CHOSEONG PIEUP-SIOS-CIEUC → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG CIEUC	# 
+
+A972 ;	1107 1109 1110 ;	MA	# ( ꥲ → ᄇᄉᄐ ) HANGUL CHOSEONG PIEUP-SIOS-THIEUTH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG THIEUTH	# 
+
+112B ;	1107 110B ;	MA	# ( ᄫ → ᄇᄋ ) HANGUL CHOSEONG KAPYEOUNPIEUP → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG IEUNG	# 
+3178 ;	1107 110B ;	MA	# ( ㅸ → ᄇᄋ ) HANGUL LETTER KAPYEOUNPIEUP → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG IEUNG	# →ᄫ→
+11E6 ;	1107 110B ;	MA	# ( ᇦ → ᄇᄋ ) HANGUL JONGSEONG KAPYEOUNPIEUP → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG IEUNG	# →ᄫ→
+
+1127 ;	1107 110C ;	MA	# ( ᄧ → ᄇᄌ ) HANGUL CHOSEONG PIEUP-CIEUC → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG CIEUC	# 
+3176 ;	1107 110C ;	MA	# ( ㅶ → ᄇᄌ ) HANGUL LETTER PIEUP-CIEUC → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG CIEUC	# →ᄧ→
+D7E8 ;	1107 110C ;	MA	# ( ퟨ → ᄇᄌ ) HANGUL JONGSEONG PIEUP-CIEUC → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG CIEUC	# →ᆸᆽ→
+
+1128 ;	1107 110E ;	MA	# ( ᄨ → ᄇᄎ ) HANGUL CHOSEONG PIEUP-CHIEUCH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG CHIEUCH	# 
+D7E9 ;	1107 110E ;	MA	# ( ퟩ → ᄇᄎ ) HANGUL JONGSEONG PIEUP-CHIEUCH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG CHIEUCH	# →ᆸᆾ→
+
+A973 ;	1107 110F ;	MA	# ( ꥳ → ᄇᄏ ) HANGUL CHOSEONG PIEUP-KHIEUKH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG KHIEUKH	# 
+
+1129 ;	1107 1110 ;	MA	# ( ᄩ → ᄇᄐ ) HANGUL CHOSEONG PIEUP-THIEUTH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG THIEUTH	# 
+3177 ;	1107 1110 ;	MA	# ( ㅷ → ᄇᄐ ) HANGUL LETTER PIEUP-THIEUTH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG THIEUTH	# →ᄩ→
+
+112A ;	1107 1111 ;	MA	# ( ᄪ → ᄇᄑ ) HANGUL CHOSEONG PIEUP-PHIEUPH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG PHIEUPH	# 
+11E4 ;	1107 1111 ;	MA	# ( ᇤ → ᄇᄑ ) HANGUL JONGSEONG PIEUP-PHIEUPH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG PHIEUPH	# →ᄪ→
+
+A974 ;	1107 1112 ;	MA	# ( ꥴ → ᄇᄒ ) HANGUL CHOSEONG PIEUP-HIEUH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG HIEUH	# 
+11E5 ;	1107 1112 ;	MA	# ( ᇥ → ᄇᄒ ) HANGUL JONGSEONG PIEUP-HIEUH → HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG HIEUH	# →ᆸᇂ→
+
+3145 ;	1109 ;	MA	# ( ㅅ → ᄉ ) HANGUL LETTER SIOS → HANGUL CHOSEONG SIOS	# 
+11BA ;	1109 ;	MA	# ( ᆺ → ᄉ ) HANGUL JONGSEONG SIOS → HANGUL CHOSEONG SIOS	# 
+
+4ECA ;	1109 30FC 1100 ;	MA	# ( 今 → ᄉーᄀ ) CJK UNIFIED IDEOGRAPH-4ECA → HANGUL CHOSEONG SIOS, KATAKANA-HIRAGANA PROLONGED SOUND MARK, HANGUL CHOSEONG KIYEOK	# →슥→→스ᄀ→
+
+5408 ;	1109 30FC 1106 ;	MA	# ( 合 → ᄉーᄆ ) CJK UNIFIED IDEOGRAPH-5408 → HANGUL CHOSEONG SIOS, KATAKANA-HIRAGANA PROLONGED SOUND MARK, HANGUL CHOSEONG MIEUM	# →슴→→스ᄆ→
+
+112D ;	1109 1100 ;	MA	# ( ᄭ → ᄉᄀ ) HANGUL CHOSEONG SIOS-KIYEOK → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG KIYEOK	# 
+317A ;	1109 1100 ;	MA	# ( ㅺ → ᄉᄀ ) HANGUL LETTER SIOS-KIYEOK → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG KIYEOK	# →ᄭ→
+11E7 ;	1109 1100 ;	MA	# ( ᇧ → ᄉᄀ ) HANGUL JONGSEONG SIOS-KIYEOK → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG KIYEOK	# →ᄭ→
+
+112E ;	1109 1102 ;	MA	# ( ᄮ → ᄉᄂ ) HANGUL CHOSEONG SIOS-NIEUN → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG NIEUN	# 
+317B ;	1109 1102 ;	MA	# ( ㅻ → ᄉᄂ ) HANGUL LETTER SIOS-NIEUN → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG NIEUN	# →ᄮ→
+
+112F ;	1109 1103 ;	MA	# ( ᄯ → ᄉᄃ ) HANGUL CHOSEONG SIOS-TIKEUT → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG TIKEUT	# 
+317C ;	1109 1103 ;	MA	# ( ㅼ → ᄉᄃ ) HANGUL LETTER SIOS-TIKEUT → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG TIKEUT	# →ᄯ→
+11E8 ;	1109 1103 ;	MA	# ( ᇨ → ᄉᄃ ) HANGUL JONGSEONG SIOS-TIKEUT → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG TIKEUT	# →ᄯ→
+
+1130 ;	1109 1105 ;	MA	# ( ᄰ → ᄉᄅ ) HANGUL CHOSEONG SIOS-RIEUL → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG RIEUL	# 
+11E9 ;	1109 1105 ;	MA	# ( ᇩ → ᄉᄅ ) HANGUL JONGSEONG SIOS-RIEUL → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG RIEUL	# →ᄰ→
+
+1131 ;	1109 1106 ;	MA	# ( ᄱ → ᄉᄆ ) HANGUL CHOSEONG SIOS-MIEUM → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG MIEUM	# 
+D7EA ;	1109 1106 ;	MA	# ( ퟪ → ᄉᄆ ) HANGUL JONGSEONG SIOS-MIEUM → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG MIEUM	# →ᆺᆷ→
+
+1132 ;	1109 1107 ;	MA	# ( ᄲ → ᄉᄇ ) HANGUL CHOSEONG SIOS-PIEUP → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG PIEUP	# 
+317D ;	1109 1107 ;	MA	# ( ㅽ → ᄉᄇ ) HANGUL LETTER SIOS-PIEUP → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG PIEUP	# →ᄲ→
+11EA ;	1109 1107 ;	MA	# ( ᇪ → ᄉᄇ ) HANGUL JONGSEONG SIOS-PIEUP → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG PIEUP	# →ᄲ→
+
+1133 ;	1109 1107 1100 ;	MA	# ( ᄳ → ᄉᄇᄀ ) HANGUL CHOSEONG SIOS-PIEUP-KIYEOK → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG KIYEOK	# 
+
+D7EB ;	1109 1107 110B ;	MA	# ( ퟫ → ᄉᄇᄋ ) HANGUL JONGSEONG SIOS-KAPYEOUNPIEUP → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG IEUNG	# →ᆺᆸᆼ→
+
+110A ;	1109 1109 ;	MA	# ( ᄊ → ᄉᄉ ) HANGUL CHOSEONG SSANGSIOS → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS	# 
+3146 ;	1109 1109 ;	MA	# ( ㅆ → ᄉᄉ ) HANGUL LETTER SSANGSIOS → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS	# →ᄊ→
+11BB ;	1109 1109 ;	MA	# ( ᆻ → ᄉᄉ ) HANGUL JONGSEONG SSANGSIOS → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS	# →ᄊ→
+
+4E1B ;	1109 1109 30FC ;	MA	# ( 丛 → ᄉᄉー ) CJK UNIFIED IDEOGRAPH-4E1B → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS, KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →쓰→→ᄉ스→
+
+D7EC ;	1109 1109 1100 ;	MA	# ( ퟬ → ᄉᄉᄀ ) HANGUL JONGSEONG SSANGSIOS-KIYEOK → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG KIYEOK	# →ᆺᆺᆨ→
+
+D7ED ;	1109 1109 1103 ;	MA	# ( ퟭ → ᄉᄉᄃ ) HANGUL JONGSEONG SSANGSIOS-TIKEUT → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG TIKEUT	# →ᆺᆺᆮ→
+
+A975 ;	1109 1109 1107 ;	MA	# ( ꥵ → ᄉᄉᄇ ) HANGUL CHOSEONG SSANGSIOS-PIEUP → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG PIEUP	# 
+
+1134 ;	1109 1109 1109 ;	MA	# ( ᄴ → ᄉᄉᄉ ) HANGUL CHOSEONG SIOS-SSANGSIOS → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS, HANGUL CHOSEONG SIOS	# 
+
+1135 ;	1109 110B ;	MA	# ( ᄵ → ᄉᄋ ) HANGUL CHOSEONG SIOS-IEUNG → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG IEUNG	# 
+
+1136 ;	1109 110C ;	MA	# ( ᄶ → ᄉᄌ ) HANGUL CHOSEONG SIOS-CIEUC → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG CIEUC	# 
+317E ;	1109 110C ;	MA	# ( ㅾ → ᄉᄌ ) HANGUL LETTER SIOS-CIEUC → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG CIEUC	# →ᄶ→
+D7EF ;	1109 110C ;	MA	# ( ퟯ → ᄉᄌ ) HANGUL JONGSEONG SIOS-CIEUC → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG CIEUC	# →ᆺᆽ→
+
+1137 ;	1109 110E ;	MA	# ( ᄷ → ᄉᄎ ) HANGUL CHOSEONG SIOS-CHIEUCH → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG CHIEUCH	# 
+D7F0 ;	1109 110E ;	MA	# ( ퟰ → ᄉᄎ ) HANGUL JONGSEONG SIOS-CHIEUCH → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG CHIEUCH	# →ᆺᆾ→
+
+1138 ;	1109 110F ;	MA	# ( ᄸ → ᄉᄏ ) HANGUL CHOSEONG SIOS-KHIEUKH → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG KHIEUKH	# 
+
+1139 ;	1109 1110 ;	MA	# ( ᄹ → ᄉᄐ ) HANGUL CHOSEONG SIOS-THIEUTH → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG THIEUTH	# 
+D7F1 ;	1109 1110 ;	MA	# ( ퟱ → ᄉᄐ ) HANGUL JONGSEONG SIOS-THIEUTH → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG THIEUTH	# →ᆺᇀ→
+
+113A ;	1109 1111 ;	MA	# ( ᄺ → ᄉᄑ ) HANGUL CHOSEONG SIOS-PHIEUPH → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG PHIEUPH	# 
+
+D7EE ;	1109 1140 ;	MA	# ( ퟮ → ᄉᅀ ) HANGUL JONGSEONG SIOS-PANSIOS → HANGUL CHOSEONG SIOS, HANGUL CHOSEONG PANSIOS	# →ᆺᇫ→
+
+3147 ;	110B ;	MA	# ( ㅇ → ᄋ ) HANGUL LETTER IEUNG → HANGUL CHOSEONG IEUNG	# 
+11BC ;	110B ;	MA	# ( ᆼ → ᄋ ) HANGUL JONGSEONG IEUNG → HANGUL CHOSEONG IEUNG	# 
+
+1141 ;	110B 1100 ;	MA	# ( ᅁ → ᄋᄀ ) HANGUL CHOSEONG IEUNG-KIYEOK → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG KIYEOK	# 
+11EC ;	110B 1100 ;	MA	# ( ᇬ → ᄋᄀ ) HANGUL JONGSEONG IEUNG-KIYEOK → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG KIYEOK	# →ᅁ→
+
+11ED ;	110B 1100 1100 ;	MA	# ( ᇭ → ᄋᄀᄀ ) HANGUL JONGSEONG IEUNG-SSANGKIYEOK → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG KIYEOK, HANGUL CHOSEONG KIYEOK	# →ᆼᆨᆨ→
+
+1142 ;	110B 1103 ;	MA	# ( ᅂ → ᄋᄃ ) HANGUL CHOSEONG IEUNG-TIKEUT → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG TIKEUT	# 
+
+A976 ;	110B 1105 ;	MA	# ( ꥶ → ᄋᄅ ) HANGUL CHOSEONG IEUNG-RIEUL → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG RIEUL	# 
+
+1143 ;	110B 1106 ;	MA	# ( ᅃ → ᄋᄆ ) HANGUL CHOSEONG IEUNG-MIEUM → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG MIEUM	# 
+
+1144 ;	110B 1107 ;	MA	# ( ᅄ → ᄋᄇ ) HANGUL CHOSEONG IEUNG-PIEUP → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG PIEUP	# 
+
+1145 ;	110B 1109 ;	MA	# ( ᅅ → ᄋᄉ ) HANGUL CHOSEONG IEUNG-SIOS → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG SIOS	# 
+11F1 ;	110B 1109 ;	MA	# ( ᇱ → ᄋᄉ ) HANGUL JONGSEONG YESIEUNG-SIOS → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG SIOS	# →ᅅ→
+3182 ;	110B 1109 ;	MA	# ( ㆂ → ᄋᄉ ) HANGUL LETTER YESIEUNG-SIOS → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG SIOS	# →ᇱ→→ᅅ→
+
+1147 ;	110B 110B ;	MA	# ( ᅇ → ᄋᄋ ) HANGUL CHOSEONG SSANGIEUNG → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG IEUNG	# 
+3180 ;	110B 110B ;	MA	# ( ㆀ → ᄋᄋ ) HANGUL LETTER SSANGIEUNG → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG IEUNG	# →ᅇ→
+11EE ;	110B 110B ;	MA	# ( ᇮ → ᄋᄋ ) HANGUL JONGSEONG SSANGIEUNG → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG IEUNG	# →ᅇ→
+
+1148 ;	110B 110C ;	MA	# ( ᅈ → ᄋᄌ ) HANGUL CHOSEONG IEUNG-CIEUC → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG CIEUC	# 
+
+1149 ;	110B 110E ;	MA	# ( ᅉ → ᄋᄎ ) HANGUL CHOSEONG IEUNG-CHIEUCH → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG CHIEUCH	# 
+
+11EF ;	110B 110F ;	MA	# ( ᇯ → ᄋᄏ ) HANGUL JONGSEONG IEUNG-KHIEUKH → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG KHIEUKH	# →ᆼᆿ→
+
+114A ;	110B 1110 ;	MA	# ( ᅊ → ᄋᄐ ) HANGUL CHOSEONG IEUNG-THIEUTH → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG THIEUTH	# 
+
+114B ;	110B 1111 ;	MA	# ( ᅋ → ᄋᄑ ) HANGUL CHOSEONG IEUNG-PHIEUPH → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG PHIEUPH	# 
+
+A977 ;	110B 1112 ;	MA	# ( ꥷ → ᄋᄒ ) HANGUL CHOSEONG IEUNG-HIEUH → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG HIEUH	# 
+
+1146 ;	110B 1140 ;	MA	# ( ᅆ → ᄋᅀ ) HANGUL CHOSEONG IEUNG-PANSIOS → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG PANSIOS	# 
+11F2 ;	110B 1140 ;	MA	# ( ᇲ → ᄋᅀ ) HANGUL JONGSEONG YESIEUNG-PANSIOS → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG PANSIOS	# →ᅆ→
+3183 ;	110B 1140 ;	MA	# ( ㆃ → ᄋᅀ ) HANGUL LETTER YESIEUNG-PANSIOS → HANGUL CHOSEONG IEUNG, HANGUL CHOSEONG PANSIOS	# →ᇲ→→ᅆ→
+
+3148 ;	110C ;	MA	# ( ㅈ → ᄌ ) HANGUL LETTER CIEUC → HANGUL CHOSEONG CIEUC	# 
+11BD ;	110C ;	MA	# ( ᆽ → ᄌ ) HANGUL JONGSEONG CIEUC → HANGUL CHOSEONG CIEUC	# 
+
+D7F7 ;	110C 1107 ;	MA	# ( ퟷ → ᄌᄇ ) HANGUL JONGSEONG CIEUC-PIEUP → HANGUL CHOSEONG CIEUC, HANGUL CHOSEONG PIEUP	# →ᆽᆸ→
+
+D7F8 ;	110C 1107 1107 ;	MA	# ( ퟸ → ᄌᄇᄇ ) HANGUL JONGSEONG CIEUC-SSANGPIEUP → HANGUL CHOSEONG CIEUC, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG PIEUP	# →ᆽᆸᆸ→
+
+114D ;	110C 110B ;	MA	# ( ᅍ → ᄌᄋ ) HANGUL CHOSEONG CIEUC-IEUNG → HANGUL CHOSEONG CIEUC, HANGUL CHOSEONG IEUNG	# 
+
+110D ;	110C 110C ;	MA	# ( ᄍ → ᄌᄌ ) HANGUL CHOSEONG SSANGCIEUC → HANGUL CHOSEONG CIEUC, HANGUL CHOSEONG CIEUC	# 
+3149 ;	110C 110C ;	MA	# ( ㅉ → ᄌᄌ ) HANGUL LETTER SSANGCIEUC → HANGUL CHOSEONG CIEUC, HANGUL CHOSEONG CIEUC	# →ᄍ→
+D7F9 ;	110C 110C ;	MA	# ( ퟹ → ᄌᄌ ) HANGUL JONGSEONG SSANGCIEUC → HANGUL CHOSEONG CIEUC, HANGUL CHOSEONG CIEUC	# →ᆽᆽ→
+
+A978 ;	110C 110C 1112 ;	MA	# ( ꥸ → ᄌᄌᄒ ) HANGUL CHOSEONG SSANGCIEUC-HIEUH → HANGUL CHOSEONG CIEUC, HANGUL CHOSEONG CIEUC, HANGUL CHOSEONG HIEUH	# 
+
+4E15 ;	110C 1169 ;	MA	# ( 丕 → 조 ) CJK UNIFIED IDEOGRAPH-4E15 → HANGUL CHOSEONG CIEUC, HANGUL JUNGSEONG O	# 
+
+314A ;	110E ;	MA	# ( ㅊ → ᄎ ) HANGUL LETTER CHIEUCH → HANGUL CHOSEONG CHIEUCH	# 
+11BE ;	110E ;	MA	# ( ᆾ → ᄎ ) HANGUL JONGSEONG CHIEUCH → HANGUL CHOSEONG CHIEUCH	# 
+
+1152 ;	110E 110F ;	MA	# ( ᅒ → ᄎᄏ ) HANGUL CHOSEONG CHIEUCH-KHIEUKH → HANGUL CHOSEONG CHIEUCH, HANGUL CHOSEONG KHIEUKH	# 
+
+1153 ;	110E 1112 ;	MA	# ( ᅓ → ᄎᄒ ) HANGUL CHOSEONG CHIEUCH-HIEUH → HANGUL CHOSEONG CHIEUCH, HANGUL CHOSEONG HIEUH	# 
+
+314B ;	110F ;	MA	# ( ㅋ → ᄏ ) HANGUL LETTER KHIEUKH → HANGUL CHOSEONG KHIEUKH	# 
+11BF ;	110F ;	MA	# ( ᆿ → ᄏ ) HANGUL JONGSEONG KHIEUKH → HANGUL CHOSEONG KHIEUKH	# 
+
+314C ;	1110 ;	MA	# ( ㅌ → ᄐ ) HANGUL LETTER THIEUTH → HANGUL CHOSEONG THIEUTH	# 
+11C0 ;	1110 ;	MA	# ( ᇀ → ᄐ ) HANGUL JONGSEONG THIEUTH → HANGUL CHOSEONG THIEUTH	# 
+
+9577 ;	1110 30FC 1102 110C ;	MA	# ( 長 → ᄐーᄂᄌ ) CJK UNIFIED IDEOGRAPH-9577 → HANGUL CHOSEONG THIEUTH, KATAKANA-HIRAGANA PROLONGED SOUND MARK, HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG CIEUC	# →튽→→트ᄂᄌ→
+2ED1 ;	1110 30FC 1102 110C ;	MA	#* ( ⻑ → ᄐーᄂᄌ ) CJK RADICAL LONG ONE → HANGUL CHOSEONG THIEUTH, KATAKANA-HIRAGANA PROLONGED SOUND MARK, HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG CIEUC	# →長→→튽→→트ᄂᄌ→
+2FA7 ;	1110 30FC 1102 110C ;	MA	#* ( ⾧ → ᄐーᄂᄌ ) KANGXI RADICAL LONG → HANGUL CHOSEONG THIEUTH, KATAKANA-HIRAGANA PROLONGED SOUND MARK, HANGUL CHOSEONG NIEUN, HANGUL CHOSEONG CIEUC	# →長→→튽→→트ᄂᄌ→
+
+A979 ;	1110 1110 ;	MA	# ( ꥹ → ᄐᄐ ) HANGUL CHOSEONG SSANGTHIEUTH → HANGUL CHOSEONG THIEUTH, HANGUL CHOSEONG THIEUTH	# 
+
+314D ;	1111 ;	MA	# ( ㅍ → ᄑ ) HANGUL LETTER PHIEUPH → HANGUL CHOSEONG PHIEUPH	# 
+11C1 ;	1111 ;	MA	# ( ᇁ → ᄑ ) HANGUL JONGSEONG PHIEUPH → HANGUL CHOSEONG PHIEUPH	# 
+
+1156 ;	1111 1107 ;	MA	# ( ᅖ → ᄑᄇ ) HANGUL CHOSEONG PHIEUPH-PIEUP → HANGUL CHOSEONG PHIEUPH, HANGUL CHOSEONG PIEUP	# 
+11F3 ;	1111 1107 ;	MA	# ( ᇳ → ᄑᄇ ) HANGUL JONGSEONG PHIEUPH-PIEUP → HANGUL CHOSEONG PHIEUPH, HANGUL CHOSEONG PIEUP	# →ᅖ→
+
+D7FA ;	1111 1109 ;	MA	# ( ퟺ → ᄑᄉ ) HANGUL JONGSEONG PHIEUPH-SIOS → HANGUL CHOSEONG PHIEUPH, HANGUL CHOSEONG SIOS	# →ᇁᆺ→
+
+1157 ;	1111 110B ;	MA	# ( ᅗ → ᄑᄋ ) HANGUL CHOSEONG KAPYEOUNPHIEUPH → HANGUL CHOSEONG PHIEUPH, HANGUL CHOSEONG IEUNG	# 
+3184 ;	1111 110B ;	MA	# ( ㆄ → ᄑᄋ ) HANGUL LETTER KAPYEOUNPHIEUPH → HANGUL CHOSEONG PHIEUPH, HANGUL CHOSEONG IEUNG	# →ᅗ→
+11F4 ;	1111 110B ;	MA	# ( ᇴ → ᄑᄋ ) HANGUL JONGSEONG KAPYEOUNPHIEUPH → HANGUL CHOSEONG PHIEUPH, HANGUL CHOSEONG IEUNG	# →ᅗ→
+
+D7FB ;	1111 1110 ;	MA	# ( ퟻ → ᄑᄐ ) HANGUL JONGSEONG PHIEUPH-THIEUTH → HANGUL CHOSEONG PHIEUPH, HANGUL CHOSEONG THIEUTH	# →ᇁᇀ→
+
+A97A ;	1111 1112 ;	MA	# ( ꥺ → ᄑᄒ ) HANGUL CHOSEONG PHIEUPH-HIEUH → HANGUL CHOSEONG PHIEUPH, HANGUL CHOSEONG HIEUH	# 
+
+314E ;	1112 ;	MA	# ( ㅎ → ᄒ ) HANGUL LETTER HIEUH → HANGUL CHOSEONG HIEUH	# 
+11C2 ;	1112 ;	MA	# ( ᇂ → ᄒ ) HANGUL JONGSEONG HIEUH → HANGUL CHOSEONG HIEUH	# 
+
+11F5 ;	1112 1102 ;	MA	# ( ᇵ → ᄒᄂ ) HANGUL JONGSEONG HIEUH-NIEUN → HANGUL CHOSEONG HIEUH, HANGUL CHOSEONG NIEUN	# →ᇂᆫ→
+
+11F6 ;	1112 1105 ;	MA	# ( ᇶ → ᄒᄅ ) HANGUL JONGSEONG HIEUH-RIEUL → HANGUL CHOSEONG HIEUH, HANGUL CHOSEONG RIEUL	# →ᇂᆯ→
+
+11F7 ;	1112 1106 ;	MA	# ( ᇷ → ᄒᄆ ) HANGUL JONGSEONG HIEUH-MIEUM → HANGUL CHOSEONG HIEUH, HANGUL CHOSEONG MIEUM	# →ᇂᆷ→
+
+11F8 ;	1112 1107 ;	MA	# ( ᇸ → ᄒᄇ ) HANGUL JONGSEONG HIEUH-PIEUP → HANGUL CHOSEONG HIEUH, HANGUL CHOSEONG PIEUP	# →ᇂᆸ→
+
+A97B ;	1112 1109 ;	MA	# ( ꥻ → ᄒᄉ ) HANGUL CHOSEONG HIEUH-SIOS → HANGUL CHOSEONG HIEUH, HANGUL CHOSEONG SIOS	# 
+
+1158 ;	1112 1112 ;	MA	# ( ᅘ → ᄒᄒ ) HANGUL CHOSEONG SSANGHIEUH → HANGUL CHOSEONG HIEUH, HANGUL CHOSEONG HIEUH	# 
+3185 ;	1112 1112 ;	MA	# ( ㆅ → ᄒᄒ ) HANGUL LETTER SSANGHIEUH → HANGUL CHOSEONG HIEUH, HANGUL CHOSEONG HIEUH	# →ᅘ→
+
+113D ;	113C 113C ;	MA	# ( ᄽ → ᄼᄼ ) HANGUL CHOSEONG CHITUEUMSSANGSIOS → HANGUL CHOSEONG CHITUEUMSIOS, HANGUL CHOSEONG CHITUEUMSIOS	# 
+
+113F ;	113E 113E ;	MA	# ( ᄿ → ᄾᄾ ) HANGUL CHOSEONG CEONGCHIEUMSSANGSIOS → HANGUL CHOSEONG CEONGCHIEUMSIOS, HANGUL CHOSEONG CEONGCHIEUMSIOS	# 
+
+317F ;	1140 ;	MA	# ( ㅿ → ᅀ ) HANGUL LETTER PANSIOS → HANGUL CHOSEONG PANSIOS	# 
+11EB ;	1140 ;	MA	# ( ᇫ → ᅀ ) HANGUL JONGSEONG PANSIOS → HANGUL CHOSEONG PANSIOS	# 
+
+D7F3 ;	1140 1107 ;	MA	# ( ퟳ → ᅀᄇ ) HANGUL JONGSEONG PANSIOS-PIEUP → HANGUL CHOSEONG PANSIOS, HANGUL CHOSEONG PIEUP	# →ᇫᆸ→
+
+D7F4 ;	1140 1107 110B ;	MA	# ( ퟴ → ᅀᄇᄋ ) HANGUL JONGSEONG PANSIOS-KAPYEOUNPIEUP → HANGUL CHOSEONG PANSIOS, HANGUL CHOSEONG PIEUP, HANGUL CHOSEONG IEUNG	# →ᇫᆸᆼ→
+
+3181 ;	114C ;	MA	# ( ㆁ → ᅌ ) HANGUL LETTER YESIEUNG → HANGUL CHOSEONG YESIEUNG	# 
+11F0 ;	114C ;	MA	# ( ᇰ → ᅌ ) HANGUL JONGSEONG YESIEUNG → HANGUL CHOSEONG YESIEUNG	# 
+
+D7F5 ;	114C 1106 ;	MA	# ( ퟵ → ᅌᄆ ) HANGUL JONGSEONG YESIEUNG-MIEUM → HANGUL CHOSEONG YESIEUNG, HANGUL CHOSEONG MIEUM	# →ᇰᆷ→
+
+D7F6 ;	114C 1112 ;	MA	# ( ퟶ → ᅌᄒ ) HANGUL JONGSEONG YESIEUNG-HIEUH → HANGUL CHOSEONG YESIEUNG, HANGUL CHOSEONG HIEUH	# →ᇰᇂ→
+
+114F ;	114E 114E ;	MA	# ( ᅏ → ᅎᅎ ) HANGUL CHOSEONG CHITUEUMSSANGCIEUC → HANGUL CHOSEONG CHITUEUMCIEUC, HANGUL CHOSEONG CHITUEUMCIEUC	# 
+
+1151 ;	1150 1150 ;	MA	# ( ᅑ → ᅐᅐ ) HANGUL CHOSEONG CEONGCHIEUMSSANGCIEUC → HANGUL CHOSEONG CEONGCHIEUMCIEUC, HANGUL CHOSEONG CEONGCHIEUMCIEUC	# 
+
+3186 ;	1159 ;	MA	# ( ㆆ → ᅙ ) HANGUL LETTER YEORINHIEUH → HANGUL CHOSEONG YEORINHIEUH	# 
+11F9 ;	1159 ;	MA	# ( ᇹ → ᅙ ) HANGUL JONGSEONG YEORINHIEUH → HANGUL CHOSEONG YEORINHIEUH	# 
+
+A97C ;	1159 1159 ;	MA	# ( ꥼ → ᅙᅙ ) HANGUL CHOSEONG SSANGYEORINHIEUH → HANGUL CHOSEONG YEORINHIEUH, HANGUL CHOSEONG YEORINHIEUH	# 
+
+3164 ;	1160 ;	MA	# (  →  ) HANGUL FILLER → HANGUL JUNGSEONG FILLER	# 
+
+314F ;	1161 ;	MA	# ( ㅏ → ᅡ ) HANGUL LETTER A → HANGUL JUNGSEONG A	# 
+
+11A3 ;	1161 30FC ;	MA	# ( ᆣ → ᅡー ) HANGUL JUNGSEONG A-EU → HANGUL JUNGSEONG A, KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →ᅡᅳ→
+
+1176 ;	1161 1169 ;	MA	# ( ᅶ → ᅡᅩ ) HANGUL JUNGSEONG A-O → HANGUL JUNGSEONG A, HANGUL JUNGSEONG O	# 
+
+1177 ;	1161 116E ;	MA	# ( ᅷ → ᅡᅮ ) HANGUL JUNGSEONG A-U → HANGUL JUNGSEONG A, HANGUL JUNGSEONG U	# 
+
+1162 ;	1161 4E28 ;	MA	# ( ᅢ → ᅡ丨 ) HANGUL JUNGSEONG AE → HANGUL JUNGSEONG A, CJK UNIFIED IDEOGRAPH-4E28	# →ᅡᅵ→
+3150 ;	1161 4E28 ;	MA	# ( ㅐ → ᅡ丨 ) HANGUL LETTER AE → HANGUL JUNGSEONG A, CJK UNIFIED IDEOGRAPH-4E28	# →ᅢ→→ᅡᅵ→
+
+3151 ;	1163 ;	MA	# ( ㅑ → ᅣ ) HANGUL LETTER YA → HANGUL JUNGSEONG YA	# 
+
+1178 ;	1163 1169 ;	MA	# ( ᅸ → ᅣᅩ ) HANGUL JUNGSEONG YA-O → HANGUL JUNGSEONG YA, HANGUL JUNGSEONG O	# 
+
+1179 ;	1163 116D ;	MA	# ( ᅹ → ᅣᅭ ) HANGUL JUNGSEONG YA-YO → HANGUL JUNGSEONG YA, HANGUL JUNGSEONG YO	# 
+
+11A4 ;	1163 116E ;	MA	# ( ᆤ → ᅣᅮ ) HANGUL JUNGSEONG YA-U → HANGUL JUNGSEONG YA, HANGUL JUNGSEONG U	# 
+
+1164 ;	1163 4E28 ;	MA	# ( ᅤ → ᅣ丨 ) HANGUL JUNGSEONG YAE → HANGUL JUNGSEONG YA, CJK UNIFIED IDEOGRAPH-4E28	# →ᅣᅵ→
+3152 ;	1163 4E28 ;	MA	# ( ㅒ → ᅣ丨 ) HANGUL LETTER YAE → HANGUL JUNGSEONG YA, CJK UNIFIED IDEOGRAPH-4E28	# →ᅤ→→ᅣᅵ→
+
+3153 ;	1165 ;	MA	# ( ㅓ → ᅥ ) HANGUL LETTER EO → HANGUL JUNGSEONG EO	# 
+
+117C ;	1165 30FC ;	MA	# ( ᅼ → ᅥー ) HANGUL JUNGSEONG EO-EU → HANGUL JUNGSEONG EO, KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →ᅥᅳ→
+
+117A ;	1165 1169 ;	MA	# ( ᅺ → ᅥᅩ ) HANGUL JUNGSEONG EO-O → HANGUL JUNGSEONG EO, HANGUL JUNGSEONG O	# 
+
+117B ;	1165 116E ;	MA	# ( ᅻ → ᅥᅮ ) HANGUL JUNGSEONG EO-U → HANGUL JUNGSEONG EO, HANGUL JUNGSEONG U	# 
+
+1166 ;	1165 4E28 ;	MA	# ( ᅦ → ᅥ丨 ) HANGUL JUNGSEONG E → HANGUL JUNGSEONG EO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅥᅵ→
+3154 ;	1165 4E28 ;	MA	# ( ㅔ → ᅥ丨 ) HANGUL LETTER E → HANGUL JUNGSEONG EO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅦ→→ᅥᅵ→
+
+3155 ;	1167 ;	MA	# ( ㅕ → ᅧ ) HANGUL LETTER YEO → HANGUL JUNGSEONG YEO	# 
+
+11A5 ;	1167 1163 ;	MA	# ( ᆥ → ᅧᅣ ) HANGUL JUNGSEONG YEO-YA → HANGUL JUNGSEONG YEO, HANGUL JUNGSEONG YA	# 
+
+117D ;	1167 1169 ;	MA	# ( ᅽ → ᅧᅩ ) HANGUL JUNGSEONG YEO-O → HANGUL JUNGSEONG YEO, HANGUL JUNGSEONG O	# 
+
+117E ;	1167 116E ;	MA	# ( ᅾ → ᅧᅮ ) HANGUL JUNGSEONG YEO-U → HANGUL JUNGSEONG YEO, HANGUL JUNGSEONG U	# 
+
+1168 ;	1167 4E28 ;	MA	# ( ᅨ → ᅧ丨 ) HANGUL JUNGSEONG YE → HANGUL JUNGSEONG YEO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅧᅵ→
+3156 ;	1167 4E28 ;	MA	# ( ㅖ → ᅧ丨 ) HANGUL LETTER YE → HANGUL JUNGSEONG YEO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅨ→→ᅧᅵ→
+
+3157 ;	1169 ;	MA	# ( ㅗ → ᅩ ) HANGUL LETTER O → HANGUL JUNGSEONG O	# 
+
+116A ;	1169 1161 ;	MA	# ( ᅪ → ᅩᅡ ) HANGUL JUNGSEONG WA → HANGUL JUNGSEONG O, HANGUL JUNGSEONG A	# 
+3158 ;	1169 1161 ;	MA	# ( ㅘ → ᅩᅡ ) HANGUL LETTER WA → HANGUL JUNGSEONG O, HANGUL JUNGSEONG A	# →ᅪ→
+
+116B ;	1169 1161 4E28 ;	MA	# ( ᅫ → ᅩᅡ丨 ) HANGUL JUNGSEONG WAE → HANGUL JUNGSEONG O, HANGUL JUNGSEONG A, CJK UNIFIED IDEOGRAPH-4E28	# →ᅩᅡᅵ→
+3159 ;	1169 1161 4E28 ;	MA	# ( ㅙ → ᅩᅡ丨 ) HANGUL LETTER WAE → HANGUL JUNGSEONG O, HANGUL JUNGSEONG A, CJK UNIFIED IDEOGRAPH-4E28	# →ᅫ→→ᅩᅡᅵ→
+
+11A6 ;	1169 1163 ;	MA	# ( ᆦ → ᅩᅣ ) HANGUL JUNGSEONG O-YA → HANGUL JUNGSEONG O, HANGUL JUNGSEONG YA	# 
+
+11A7 ;	1169 1163 4E28 ;	MA	# ( ᆧ → ᅩᅣ丨 ) HANGUL JUNGSEONG O-YAE → HANGUL JUNGSEONG O, HANGUL JUNGSEONG YA, CJK UNIFIED IDEOGRAPH-4E28	# →ᅩᅣᅵ→
+
+117F ;	1169 1165 ;	MA	# ( ᅿ → ᅩᅥ ) HANGUL JUNGSEONG O-EO → HANGUL JUNGSEONG O, HANGUL JUNGSEONG EO	# 
+
+1180 ;	1169 1165 4E28 ;	MA	# ( ᆀ → ᅩᅥ丨 ) HANGUL JUNGSEONG O-E → HANGUL JUNGSEONG O, HANGUL JUNGSEONG EO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅩᅥᅵ→
+
+D7B0 ;	1169 1167 ;	MA	# ( ힰ → ᅩᅧ ) HANGUL JUNGSEONG O-YEO → HANGUL JUNGSEONG O, HANGUL JUNGSEONG YEO	# 
+
+1181 ;	1169 1167 4E28 ;	MA	# ( ᆁ → ᅩᅧ丨 ) HANGUL JUNGSEONG O-YE → HANGUL JUNGSEONG O, HANGUL JUNGSEONG YEO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅩᅧᅵ→
+
+1182 ;	1169 1169 ;	MA	# ( ᆂ → ᅩᅩ ) HANGUL JUNGSEONG O-O → HANGUL JUNGSEONG O, HANGUL JUNGSEONG O	# 
+
+D7B1 ;	1169 1169 4E28 ;	MA	# ( ힱ → ᅩᅩ丨 ) HANGUL JUNGSEONG O-O-I → HANGUL JUNGSEONG O, HANGUL JUNGSEONG O, CJK UNIFIED IDEOGRAPH-4E28	# →ᅩᅩᅵ→
+
+1183 ;	1169 116E ;	MA	# ( ᆃ → ᅩᅮ ) HANGUL JUNGSEONG O-U → HANGUL JUNGSEONG O, HANGUL JUNGSEONG U	# 
+
+116C ;	1169 4E28 ;	MA	# ( ᅬ → ᅩ丨 ) HANGUL JUNGSEONG OE → HANGUL JUNGSEONG O, CJK UNIFIED IDEOGRAPH-4E28	# →ᅩᅵ→
+315A ;	1169 4E28 ;	MA	# ( ㅚ → ᅩ丨 ) HANGUL LETTER OE → HANGUL JUNGSEONG O, CJK UNIFIED IDEOGRAPH-4E28	# →ᅬ→→ᅩᅵ→
+
+315B ;	116D ;	MA	# ( ㅛ → ᅭ ) HANGUL LETTER YO → HANGUL JUNGSEONG YO	# 
+
+D7B2 ;	116D 1161 ;	MA	# ( ힲ → ᅭᅡ ) HANGUL JUNGSEONG YO-A → HANGUL JUNGSEONG YO, HANGUL JUNGSEONG A	# 
+
+D7B3 ;	116D 1161 4E28 ;	MA	# ( ힳ → ᅭᅡ丨 ) HANGUL JUNGSEONG YO-AE → HANGUL JUNGSEONG YO, HANGUL JUNGSEONG A, CJK UNIFIED IDEOGRAPH-4E28	# →ᅭᅡᅵ→
+
+1184 ;	116D 1163 ;	MA	# ( ᆄ → ᅭᅣ ) HANGUL JUNGSEONG YO-YA → HANGUL JUNGSEONG YO, HANGUL JUNGSEONG YA	# 
+3187 ;	116D 1163 ;	MA	# ( ㆇ → ᅭᅣ ) HANGUL LETTER YO-YA → HANGUL JUNGSEONG YO, HANGUL JUNGSEONG YA	# →ᆄ→
+1186 ;	116D 1163 ;	MA	# ( ᆆ → ᅭᅣ ) HANGUL JUNGSEONG YO-YEO → HANGUL JUNGSEONG YO, HANGUL JUNGSEONG YA	# →ᆄ→
+
+1185 ;	116D 1163 4E28 ;	MA	# ( ᆅ → ᅭᅣ丨 ) HANGUL JUNGSEONG YO-YAE → HANGUL JUNGSEONG YO, HANGUL JUNGSEONG YA, CJK UNIFIED IDEOGRAPH-4E28	# →ᅭᅣᅵ→
+3188 ;	116D 1163 4E28 ;	MA	# ( ㆈ → ᅭᅣ丨 ) HANGUL LETTER YO-YAE → HANGUL JUNGSEONG YO, HANGUL JUNGSEONG YA, CJK UNIFIED IDEOGRAPH-4E28	# →ᆅ→→ᅭᅣᅵ→
+
+D7B4 ;	116D 1165 ;	MA	# ( ힴ → ᅭᅥ ) HANGUL JUNGSEONG YO-EO → HANGUL JUNGSEONG YO, HANGUL JUNGSEONG EO	# 
+
+1187 ;	116D 1169 ;	MA	# ( ᆇ → ᅭᅩ ) HANGUL JUNGSEONG YO-O → HANGUL JUNGSEONG YO, HANGUL JUNGSEONG O	# 
+
+1188 ;	116D 4E28 ;	MA	# ( ᆈ → ᅭ丨 ) HANGUL JUNGSEONG YO-I → HANGUL JUNGSEONG YO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅭᅵ→
+3189 ;	116D 4E28 ;	MA	# ( ㆉ → ᅭ丨 ) HANGUL LETTER YO-I → HANGUL JUNGSEONG YO, CJK UNIFIED IDEOGRAPH-4E28	# →ᆈ→→ᅭᅵ→
+
+315C ;	116E ;	MA	# ( ㅜ → ᅮ ) HANGUL LETTER U → HANGUL JUNGSEONG U	# 
+
+1189 ;	116E 1161 ;	MA	# ( ᆉ → ᅮᅡ ) HANGUL JUNGSEONG U-A → HANGUL JUNGSEONG U, HANGUL JUNGSEONG A	# 
+
+118A ;	116E 1161 4E28 ;	MA	# ( ᆊ → ᅮᅡ丨 ) HANGUL JUNGSEONG U-AE → HANGUL JUNGSEONG U, HANGUL JUNGSEONG A, CJK UNIFIED IDEOGRAPH-4E28	# →ᅮᅡᅵ→
+
+116F ;	116E 1165 ;	MA	# ( ᅯ → ᅮᅥ ) HANGUL JUNGSEONG WEO → HANGUL JUNGSEONG U, HANGUL JUNGSEONG EO	# 
+315D ;	116E 1165 ;	MA	# ( ㅝ → ᅮᅥ ) HANGUL LETTER WEO → HANGUL JUNGSEONG U, HANGUL JUNGSEONG EO	# →ᅯ→
+
+118B ;	116E 1165 30FC ;	MA	# ( ᆋ → ᅮᅥー ) HANGUL JUNGSEONG U-EO-EU → HANGUL JUNGSEONG U, HANGUL JUNGSEONG EO, KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →ᅮᅥᅳ→
+
+1170 ;	116E 1165 4E28 ;	MA	# ( ᅰ → ᅮᅥ丨 ) HANGUL JUNGSEONG WE → HANGUL JUNGSEONG U, HANGUL JUNGSEONG EO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅮᅥᅵ→
+315E ;	116E 1165 4E28 ;	MA	# ( ㅞ → ᅮᅥ丨 ) HANGUL LETTER WE → HANGUL JUNGSEONG U, HANGUL JUNGSEONG EO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅰ→→ᅮᅥᅵ→
+
+D7B5 ;	116E 1167 ;	MA	# ( ힵ → ᅮᅧ ) HANGUL JUNGSEONG U-YEO → HANGUL JUNGSEONG U, HANGUL JUNGSEONG YEO	# 
+
+118C ;	116E 1167 4E28 ;	MA	# ( ᆌ → ᅮᅧ丨 ) HANGUL JUNGSEONG U-YE → HANGUL JUNGSEONG U, HANGUL JUNGSEONG YEO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅮᅧᅵ→
+
+118D ;	116E 116E ;	MA	# ( ᆍ → ᅮᅮ ) HANGUL JUNGSEONG U-U → HANGUL JUNGSEONG U, HANGUL JUNGSEONG U	# 
+
+1171 ;	116E 4E28 ;	MA	# ( ᅱ → ᅮ丨 ) HANGUL JUNGSEONG WI → HANGUL JUNGSEONG U, CJK UNIFIED IDEOGRAPH-4E28	# →ᅮᅵ→
+315F ;	116E 4E28 ;	MA	# ( ㅟ → ᅮ丨 ) HANGUL LETTER WI → HANGUL JUNGSEONG U, CJK UNIFIED IDEOGRAPH-4E28	# →ᅱ→→ᅮᅵ→
+
+D7B6 ;	116E 4E28 4E28 ;	MA	# ( ힶ → ᅮ丨丨 ) HANGUL JUNGSEONG U-I-I → HANGUL JUNGSEONG U, CJK UNIFIED IDEOGRAPH-4E28, CJK UNIFIED IDEOGRAPH-4E28	# →ᅮᅵᅵ→
+
+3160 ;	1172 ;	MA	# ( ㅠ → ᅲ ) HANGUL LETTER YU → HANGUL JUNGSEONG YU	# 
+
+118E ;	1172 1161 ;	MA	# ( ᆎ → ᅲᅡ ) HANGUL JUNGSEONG YU-A → HANGUL JUNGSEONG YU, HANGUL JUNGSEONG A	# 
+
+D7B7 ;	1172 1161 4E28 ;	MA	# ( ힷ → ᅲᅡ丨 ) HANGUL JUNGSEONG YU-AE → HANGUL JUNGSEONG YU, HANGUL JUNGSEONG A, CJK UNIFIED IDEOGRAPH-4E28	# →ᅲᅡᅵ→
+
+118F ;	1172 1165 ;	MA	# ( ᆏ → ᅲᅥ ) HANGUL JUNGSEONG YU-EO → HANGUL JUNGSEONG YU, HANGUL JUNGSEONG EO	# 
+
+1190 ;	1172 1165 4E28 ;	MA	# ( ᆐ → ᅲᅥ丨 ) HANGUL JUNGSEONG YU-E → HANGUL JUNGSEONG YU, HANGUL JUNGSEONG EO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅲᅥᅵ→
+
+1191 ;	1172 1167 ;	MA	# ( ᆑ → ᅲᅧ ) HANGUL JUNGSEONG YU-YEO → HANGUL JUNGSEONG YU, HANGUL JUNGSEONG YEO	# 
+318A ;	1172 1167 ;	MA	# ( ㆊ → ᅲᅧ ) HANGUL LETTER YU-YEO → HANGUL JUNGSEONG YU, HANGUL JUNGSEONG YEO	# →ᆑ→
+
+1192 ;	1172 1167 4E28 ;	MA	# ( ᆒ → ᅲᅧ丨 ) HANGUL JUNGSEONG YU-YE → HANGUL JUNGSEONG YU, HANGUL JUNGSEONG YEO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅲᅧᅵ→
+318B ;	1172 1167 4E28 ;	MA	# ( ㆋ → ᅲᅧ丨 ) HANGUL LETTER YU-YE → HANGUL JUNGSEONG YU, HANGUL JUNGSEONG YEO, CJK UNIFIED IDEOGRAPH-4E28	# →ᆒ→→ᅲᅧᅵ→
+
+D7B8 ;	1172 1169 ;	MA	# ( ힸ → ᅲᅩ ) HANGUL JUNGSEONG YU-O → HANGUL JUNGSEONG YU, HANGUL JUNGSEONG O	# 
+
+1193 ;	1172 116E ;	MA	# ( ᆓ → ᅲᅮ ) HANGUL JUNGSEONG YU-U → HANGUL JUNGSEONG YU, HANGUL JUNGSEONG U	# 
+
+1194 ;	1172 4E28 ;	MA	# ( ᆔ → ᅲ丨 ) HANGUL JUNGSEONG YU-I → HANGUL JUNGSEONG YU, CJK UNIFIED IDEOGRAPH-4E28	# →ᅲᅵ→
+318C ;	1172 4E28 ;	MA	# ( ㆌ → ᅲ丨 ) HANGUL LETTER YU-I → HANGUL JUNGSEONG YU, CJK UNIFIED IDEOGRAPH-4E28	# →ᆔ→→ᅲᅵ→
+
+318D ;	119E ;	MA	# ( ㆍ → ᆞ ) HANGUL LETTER ARAEA → HANGUL JUNGSEONG ARAEA	# 
+
+D7C5 ;	119E 1161 ;	MA	# ( ퟅ → ᆞᅡ ) HANGUL JUNGSEONG ARAEA-A → HANGUL JUNGSEONG ARAEA, HANGUL JUNGSEONG A	# 
+
+119F ;	119E 1165 ;	MA	# ( ᆟ → ᆞᅥ ) HANGUL JUNGSEONG ARAEA-EO → HANGUL JUNGSEONG ARAEA, HANGUL JUNGSEONG EO	# 
+
+D7C6 ;	119E 1165 4E28 ;	MA	# ( ퟆ → ᆞᅥ丨 ) HANGUL JUNGSEONG ARAEA-E → HANGUL JUNGSEONG ARAEA, HANGUL JUNGSEONG EO, CJK UNIFIED IDEOGRAPH-4E28	# →ᆞᅥᅵ→
+
+11A0 ;	119E 116E ;	MA	# ( ᆠ → ᆞᅮ ) HANGUL JUNGSEONG ARAEA-U → HANGUL JUNGSEONG ARAEA, HANGUL JUNGSEONG U	# 
+
+11A2 ;	119E 119E ;	MA	# ( ᆢ → ᆞᆞ ) HANGUL JUNGSEONG SSANGARAEA → HANGUL JUNGSEONG ARAEA, HANGUL JUNGSEONG ARAEA	# 
+
+11A1 ;	119E 4E28 ;	MA	# ( ᆡ → ᆞ丨 ) HANGUL JUNGSEONG ARAEA-I → HANGUL JUNGSEONG ARAEA, CJK UNIFIED IDEOGRAPH-4E28	# →ᆞᅵ→
+318E ;	119E 4E28 ;	MA	# ( ㆎ → ᆞ丨 ) HANGUL LETTER ARAEAE → HANGUL JUNGSEONG ARAEA, CJK UNIFIED IDEOGRAPH-4E28	# →ᆡ→→ᆞᅵ→
+
+30D8 ;	3078 ;	MA	# ( ヘ → へ ) KATAKANA LETTER HE → HIRAGANA LETTER HE	# 
+
+2341 ;	303C ;	MA	#* ( ⍁ → 〼 ) APL FUNCTIONAL SYMBOL QUAD SLASH → MASU MARK	# →⧄→
+29C4 ;	303C ;	MA	#* ( ⧄ → 〼 ) SQUARED RISING DIAGONAL SLASH → MASU MARK	# 
+
+4E8E ;	1B122 ;	MA	# ( 于 → 𛄢 ) CJK UNIFIED IDEOGRAPH-4E8E → KATAKANA LETTER ARCHAIC WU	# 
+
+A49E ;	A04A ;	MA	#* ( ꒞ → ꁊ ) YI RADICAL PUT → YI SYLLABLE PUT	# 
+
+A4AC ;	A050 ;	MA	#* ( ꒬ → ꁐ ) YI RADICAL PYT → YI SYLLABLE PYT	# 
+
+A49C ;	A0C0 ;	MA	#* ( ꒜ → ꃀ ) YI RADICAL MOP → YI SYLLABLE MOP	# 
+
+A4A8 ;	A132 ;	MA	#* ( ꒨ → ꄲ ) YI RADICAL TU → YI SYLLABLE TU	# 
+
+A4BF ;	A259 ;	MA	#* ( ꒿ → ꉙ ) YI RADICAL HXOP → YI SYLLABLE HXOP	# 
+
+A4BE ;	A2B1 ;	MA	#* ( ꒾ → ꊱ ) YI RADICAL CIP → YI SYLLABLE CIP	# 
+
+A494 ;	A2CD ;	MA	#* ( ꒔ → ꋍ ) YI RADICAL CYP → YI SYLLABLE CYP	# 
+
+A4C0 ;	A3AB ;	MA	#* ( ꓀ → ꎫ ) YI RADICAL SHAT → YI SYLLABLE SHAT	# 
+
+A4C2 ;	A3B5 ;	MA	#* ( ꓂ → ꎵ ) YI RADICAL SHOP → YI SYLLABLE SHOP	# 
+
+A4BA ;	A3BF ;	MA	#* ( ꒺ → ꎿ ) YI RADICAL SHUR → YI SYLLABLE SHUR	# 
+
+A4B0 ;	A3C2 ;	MA	#* ( ꒰ → ꏂ ) YI RADICAL SHY → YI SYLLABLE SHY	# 
+
+A4A7 ;	A458 ;	MA	#* ( ꒧ → ꑘ ) YI RADICAL NYOP → YI SYLLABLE NYOP	# 
+
+22A5 ;	A4D5 ;	MA	#* ( ⊥ → ꓕ ) UP TACK → LISU LETTER THA	# 
+27C2 ;	A4D5 ;	MA	#* ( ⟂ → ꓕ ) PERPENDICULAR → LISU LETTER THA	# →⊥→
+1D21C ;	A4D5 ;	MA	#* ( 𝈜 → ꓕ ) GREEK VOCAL NOTATION SYMBOL-54 → LISU LETTER THA	# →Ʇ→
+A7B1 ;	A4D5 ;	MA	# ( Ʇ → ꓕ ) LATIN CAPITAL LETTER TURNED T → LISU LETTER THA	# 
+
+A79E ;	A4E4 ;	MA	# ( Ꞟ → ꓤ ) LATIN CAPITAL LETTER VOLAPUK UE → LISU LETTER ZA	# 
+
+2141 ;	A4E8 ;	MA	#* ( ⅁ → ꓨ ) TURNED SANS-SERIF CAPITAL G → LISU LETTER HHA	# 
+
+2142 ;	A4F6 ;	MA	#* ( ⅂ → ꓶ ) TURNED SANS-SERIF CAPITAL L → LISU LETTER UH	# 
+1D215 ;	A4F6 ;	MA	#* ( 𝈕 → ꓶ ) GREEK VOCAL NOTATION SYMBOL-22 → LISU LETTER UH	# →⅂→
+1D22B ;	A4F6 ;	MA	#* ( 𝈫 → ꓶ ) GREEK INSTRUMENTAL NOTATION SYMBOL-24 → LISU LETTER UH	# →𝈕→→⅂→
+16F26 ;	A4F6 ;	MA	# ( 𖼦 → ꓶ ) MIAO LETTER HA → LISU LETTER UH	# →⅂→
+10411 ;	A4F6 ;	MA	# ( 𐐑 → ꓶ ) DESERET CAPITAL LETTER PEE → LISU LETTER UH	# →⅂→
+
+2143 ;	16F00 ;	MA	#* ( ⅃ → 𖼀 ) REVERSED SANS-SERIF CAPITAL L → MIAO LETTER PA	# 
+
+11AE6 ;	11AE5 11AEF ;	MA	# ( 𑫦 → 𑫥𑫯 ) PAU CIN HAU RISING TONE → PAU CIN HAU RISING TONE LONG, PAU CIN HAU MID-LEVEL TONE	# 
+
+11AE8 ;	11AE5 11AE5 ;	MA	# ( 𑫨 → 𑫥𑫥 ) PAU CIN HAU RISING TONE LONG FINAL → PAU CIN HAU RISING TONE LONG, PAU CIN HAU RISING TONE LONG	# 
+
+11AE9 ;	11AE5 11AE5 11AEF ;	MA	# ( 𑫩 → 𑫥𑫥𑫯 ) PAU CIN HAU RISING TONE FINAL → PAU CIN HAU RISING TONE LONG, PAU CIN HAU RISING TONE LONG, PAU CIN HAU MID-LEVEL TONE	# →𑫥𑫦→
+
+11AEA ;	11AE5 11AE5 11AF0 ;	MA	# ( 𑫪 → 𑫥𑫥𑫰 ) PAU CIN HAU SANDHI GLOTTAL STOP FINAL → PAU CIN HAU RISING TONE LONG, PAU CIN HAU RISING TONE LONG, PAU CIN HAU GLOTTAL STOP VARIANT	# →𑫥𑫧→
+
+11AE7 ;	11AE5 11AF0 ;	MA	# ( 𑫧 → 𑫥𑫰 ) PAU CIN HAU SANDHI GLOTTAL STOP → PAU CIN HAU RISING TONE LONG, PAU CIN HAU GLOTTAL STOP VARIANT	# 
+
+11AF4 ;	11AF3 11AEF ;	MA	# ( 𑫴 → 𑫳𑫯 ) PAU CIN HAU LOW-FALLING TONE → PAU CIN HAU LOW-FALLING TONE LONG, PAU CIN HAU MID-LEVEL TONE	# 
+
+11AF6 ;	11AF3 11AF3 ;	MA	# ( 𑫶 → 𑫳𑫳 ) PAU CIN HAU LOW-FALLING TONE LONG FINAL → PAU CIN HAU LOW-FALLING TONE LONG, PAU CIN HAU LOW-FALLING TONE LONG	# 
+
+11AF7 ;	11AF3 11AF3 11AEF ;	MA	# ( 𑫷 → 𑫳𑫳𑫯 ) PAU CIN HAU LOW-FALLING TONE FINAL → PAU CIN HAU LOW-FALLING TONE LONG, PAU CIN HAU LOW-FALLING TONE LONG, PAU CIN HAU MID-LEVEL TONE	# →𑫳𑫴→
+
+11AF8 ;	11AF3 11AF3 11AF0 ;	MA	# ( 𑫸 → 𑫳𑫳𑫰 ) PAU CIN HAU GLOTTAL STOP FINAL → PAU CIN HAU LOW-FALLING TONE LONG, PAU CIN HAU LOW-FALLING TONE LONG, PAU CIN HAU GLOTTAL STOP VARIANT	# →𑫳𑫵→
+
+11AF5 ;	11AF3 11AF0 ;	MA	# ( 𑫵 → 𑫳𑫰 ) PAU CIN HAU GLOTTAL STOP → PAU CIN HAU LOW-FALLING TONE LONG, PAU CIN HAU GLOTTAL STOP VARIANT	# 
+
+11AEC ;	11AEB 11AEF ;	MA	# ( 𑫬 → 𑫫𑫯 ) PAU CIN HAU SANDHI TONE → PAU CIN HAU SANDHI TONE LONG, PAU CIN HAU MID-LEVEL TONE	# 
+
+11AED ;	11AEB 11AEB ;	MA	# ( 𑫭 → 𑫫𑫫 ) PAU CIN HAU SANDHI TONE LONG FINAL → PAU CIN HAU SANDHI TONE LONG, PAU CIN HAU SANDHI TONE LONG	# 
+
+11AEE ;	11AEB 11AEB 11AEF ;	MA	# ( 𑫮 → 𑫫𑫫𑫯 ) PAU CIN HAU SANDHI TONE FINAL → PAU CIN HAU SANDHI TONE LONG, PAU CIN HAU SANDHI TONE LONG, PAU CIN HAU MID-LEVEL TONE	# →𑫫𑫬→
+
+2295 ;	102A8 ;	MA	#* ( ⊕ → 𐊨 ) CIRCLED PLUS → CARIAN LETTER Q	# 
+2A01 ;	102A8 ;	MA	#* ( ⨁ → 𐊨 ) N-ARY CIRCLED PLUS OPERATOR → CARIAN LETTER Q	# →⊕→
+1F728 ;	102A8 ;	MA	#* ( 🜨 → 𐊨 ) ALCHEMICAL SYMBOL FOR VERDIGRIS → CARIAN LETTER Q	# →⊕→
+A69A ;	102A8 ;	MA	# ( Ꚛ → 𐊨 ) CYRILLIC CAPITAL LETTER CROSSED O → CARIAN LETTER Q	# →⊕→
+
+25BD ;	102BC ;	MA	#* ( ▽ → 𐊼 ) WHITE DOWN-POINTING TRIANGLE → CARIAN LETTER K	# 
+1D214 ;	102BC ;	MA	#* ( 𝈔 → 𐊼 ) GREEK VOCAL NOTATION SYMBOL-21 → CARIAN LETTER K	# →▽→
+1F704 ;	102BC ;	MA	#* ( 🜄 → 𐊼 ) ALCHEMICAL SYMBOL FOR WATER → CARIAN LETTER K	# →▽→
+
+29D6 ;	102C0 ;	MA	#* ( ⧖ → 𐋀 ) WHITE HOURGLASS → CARIAN LETTER G	# 
+
+A79B ;	1043A ;	MA	# ( ꞛ → 𐐺 ) LATIN SMALL LETTER VOLAPUK AE → DESERET SMALL LETTER BEE	# 
+
+A79A ;	10412 ;	MA	# ( Ꞛ → 𐐒 ) LATIN CAPITAL LETTER VOLAPUK AE → DESERET CAPITAL LETTER BEE	# 
+
+104A0 ;	10486 ;	MA	# ( 𐒠 → 𐒆 ) OSMANYA DIGIT ZERO → OSMANYA LETTER DEEL	# 
+
+103D1 ;	10382 ;	MA	# ( 𐏑 → 𐎂 ) OLD PERSIAN NUMBER ONE → UGARITIC LETTER GAMLA	# 
+
+103D3 ;	10393 ;	MA	# ( 𐏓 → 𐎓 ) OLD PERSIAN NUMBER TEN → UGARITIC LETTER AIN	# 
+
+12038 ;	1039A ;	MA	# ( 𒀸 → 𐎚 ) CUNEIFORM SIGN ASH → UGARITIC LETTER TO	# 
+
+2625 ;	1099E ;	MA	#* ( ☥ → ‎𐦞‎ ) ANKH → MEROITIC HIEROGLYPHIC SYMBOL VIDJ	# 
+132F9 ;	1099E ;	MA	# ( 𓋹 → ‎𐦞‎ ) EGYPTIAN HIEROGLYPH S034 → MEROITIC HIEROGLYPHIC SYMBOL VIDJ	# →☥→
+
+3039 ;	5344 ;	MA	# ( 〹 → 卄 ) HANGZHOU NUMERAL TWENTY → CJK UNIFIED IDEOGRAPH-5344	# 
+
+F967 ;	4E0D ;	MA	# ( 不 → 不 ) CJK COMPATIBILITY IDEOGRAPH-F967 → CJK UNIFIED IDEOGRAPH-4E0D	# 
+
+2F800 ;	4E3D ;	MA	# ( 丽 → 丽 ) CJK COMPATIBILITY IDEOGRAPH-2F800 → CJK UNIFIED IDEOGRAPH-4E3D	# 
+
+FA70 ;	4E26 ;	MA	# ( 並 → 並 ) CJK COMPATIBILITY IDEOGRAPH-FA70 → CJK UNIFIED IDEOGRAPH-4E26	# 
+
+239C ;	4E28 ;	MA	#* ( ⎜ → 丨 ) LEFT PARENTHESIS EXTENSION → CJK UNIFIED IDEOGRAPH-4E28	# →⎥→→⎮→
+239F ;	4E28 ;	MA	#* ( ⎟ → 丨 ) RIGHT PARENTHESIS EXTENSION → CJK UNIFIED IDEOGRAPH-4E28	# →⎥→→⎮→
+23A2 ;	4E28 ;	MA	#* ( ⎢ → 丨 ) LEFT SQUARE BRACKET EXTENSION → CJK UNIFIED IDEOGRAPH-4E28	# →⎥→→⎮→
+23A5 ;	4E28 ;	MA	#* ( ⎥ → 丨 ) RIGHT SQUARE BRACKET EXTENSION → CJK UNIFIED IDEOGRAPH-4E28	# →⎮→
+23AA ;	4E28 ;	MA	#* ( ⎪ → 丨 ) CURLY BRACKET EXTENSION → CJK UNIFIED IDEOGRAPH-4E28	# →⎥→→⎮→
+23AE ;	4E28 ;	MA	#* ( ⎮ → 丨 ) INTEGRAL EXTENSION → CJK UNIFIED IDEOGRAPH-4E28	# 
+31D1 ;	4E28 ;	MA	#* ( ㇑ → 丨 ) CJK STROKE S → CJK UNIFIED IDEOGRAPH-4E28	# 
+1175 ;	4E28 ;	MA	# ( ᅵ → 丨 ) HANGUL JUNGSEONG I → CJK UNIFIED IDEOGRAPH-4E28	# →ㅣ→
+3163 ;	4E28 ;	MA	# ( ㅣ → 丨 ) HANGUL LETTER I → CJK UNIFIED IDEOGRAPH-4E28	# 
+2F01 ;	4E28 ;	MA	#* ( ⼁ → 丨 ) KANGXI RADICAL LINE → CJK UNIFIED IDEOGRAPH-4E28	# 
+
+119C ;	4E28 30FC ;	MA	# ( ᆜ → 丨ー ) HANGUL JUNGSEONG I-EU → CJK UNIFIED IDEOGRAPH-4E28, KATAKANA-HIRAGANA PROLONGED SOUND MARK	# →ᅵᅳ→
+
+1198 ;	4E28 1161 ;	MA	# ( ᆘ → 丨ᅡ ) HANGUL JUNGSEONG I-A → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG A	# →ᅵᅡ→
+
+1199 ;	4E28 1163 ;	MA	# ( ᆙ → 丨ᅣ ) HANGUL JUNGSEONG I-YA → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG YA	# →ᅵᅣ→
+
+D7BD ;	4E28 1163 1169 ;	MA	# ( ힽ → 丨ᅣᅩ ) HANGUL JUNGSEONG I-YA-O → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG YA, HANGUL JUNGSEONG O	# →ᅵᅣᅩ→
+
+D7BE ;	4E28 1163 4E28 ;	MA	# ( ힾ → 丨ᅣ丨 ) HANGUL JUNGSEONG I-YAE → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG YA, CJK UNIFIED IDEOGRAPH-4E28	# →ᅵᅣᅵ→
+
+D7BF ;	4E28 1167 ;	MA	# ( ힿ → 丨ᅧ ) HANGUL JUNGSEONG I-YEO → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG YEO	# →ᅵᅧ→
+
+D7C0 ;	4E28 1167 4E28 ;	MA	# ( ퟀ → 丨ᅧ丨 ) HANGUL JUNGSEONG I-YE → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG YEO, CJK UNIFIED IDEOGRAPH-4E28	# →ᅵᅧᅵ→
+
+119A ;	4E28 1169 ;	MA	# ( ᆚ → 丨ᅩ ) HANGUL JUNGSEONG I-O → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG O	# →ᅵᅩ→
+
+D7C1 ;	4E28 1169 4E28 ;	MA	# ( ퟁ → 丨ᅩ丨 ) HANGUL JUNGSEONG I-O-I → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG O, CJK UNIFIED IDEOGRAPH-4E28	# →ᅵᅩᅵ→
+
+D7C2 ;	4E28 116D ;	MA	# ( ퟂ → 丨ᅭ ) HANGUL JUNGSEONG I-YO → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG YO	# →ᅵᅭ→
+
+119B ;	4E28 116E ;	MA	# ( ᆛ → 丨ᅮ ) HANGUL JUNGSEONG I-U → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG U	# →ᅵᅮ→
+
+D7C3 ;	4E28 1172 ;	MA	# ( ퟃ → 丨ᅲ ) HANGUL JUNGSEONG I-YU → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG YU	# →ᅵᅲ→
+
+119D ;	4E28 119E ;	MA	# ( ᆝ → 丨ᆞ ) HANGUL JUNGSEONG I-ARAEA → CJK UNIFIED IDEOGRAPH-4E28, HANGUL JUNGSEONG ARAEA	# →ᅵᆞ→
+
+D7C4 ;	4E28 4E28 ;	MA	# ( ퟄ → 丨丨 ) HANGUL JUNGSEONG I-I → CJK UNIFIED IDEOGRAPH-4E28, CJK UNIFIED IDEOGRAPH-4E28	# →ᅵᅵ→
+
+F905 ;	4E32 ;	MA	# ( 串 → 串 ) CJK COMPATIBILITY IDEOGRAPH-F905 → CJK UNIFIED IDEOGRAPH-4E32	# 
+
+2F801 ;	4E38 ;	MA	# ( 丸 → 丸 ) CJK COMPATIBILITY IDEOGRAPH-2F801 → CJK UNIFIED IDEOGRAPH-4E38	# 
+
+F95E ;	4E39 ;	MA	# ( 丹 → 丹 ) CJK COMPATIBILITY IDEOGRAPH-F95E → CJK UNIFIED IDEOGRAPH-4E39	# 
+
+2F802 ;	4E41 ;	MA	# ( 乁 → 乁 ) CJK COMPATIBILITY IDEOGRAPH-2F802 → CJK UNIFIED IDEOGRAPH-4E41	# 
+
+31E0 ;	4E59 ;	MA	#* ( ㇠ → 乙 ) CJK STROKE HXWG → CJK UNIFIED IDEOGRAPH-4E59	# 
+2F04 ;	4E59 ;	MA	#* ( ⼄ → 乙 ) KANGXI RADICAL SECOND → CJK UNIFIED IDEOGRAPH-4E59	# 
+
+31DF ;	4E5A ;	MA	#* ( ㇟ → 乚 ) CJK STROKE SWG → CJK UNIFIED IDEOGRAPH-4E5A	# 
+2E83 ;	4E5A ;	MA	#* ( ⺃ → 乚 ) CJK RADICAL SECOND TWO → CJK UNIFIED IDEOGRAPH-4E5A	# 
+
+31D6 ;	4E5B ;	MA	#* ( ㇖ → 乛 ) CJK STROKE HG → CJK UNIFIED IDEOGRAPH-4E5B	# 
+2E82 ;	4E5B ;	MA	#* ( ⺂ → 乛 ) CJK RADICAL SECOND ONE → CJK UNIFIED IDEOGRAPH-4E5B	# →㇖→
+
+2EF2 ;	4E80 ;	MA	#* ( ⻲ → 亀 ) CJK RADICAL J-SIMPLIFIED TURTLE → CJK UNIFIED IDEOGRAPH-4E80	# 
+
+F91B ;	4E82 ;	MA	# ( 亂 → 亂 ) CJK COMPATIBILITY IDEOGRAPH-F91B → CJK UNIFIED IDEOGRAPH-4E82	# 
+
+31DA ;	4E85 ;	MA	#* ( ㇚ → 亅 ) CJK STROKE SG → CJK UNIFIED IDEOGRAPH-4E85	# 
+2F05 ;	4E85 ;	MA	#* ( ⼅ → 亅 ) KANGXI RADICAL HOOK → CJK UNIFIED IDEOGRAPH-4E85	# 
+
+F9BA ;	4E86 ;	MA	# ( 了 → 了 ) CJK COMPATIBILITY IDEOGRAPH-F9BA → CJK UNIFIED IDEOGRAPH-4E86	# 
+
+30CB ;	4E8C ;	MA	# ( ニ → 二 ) KATAKANA LETTER NI → CJK UNIFIED IDEOGRAPH-4E8C	# 
+2F06 ;	4E8C ;	MA	#* ( ⼆ → 二 ) KANGXI RADICAL TWO → CJK UNIFIED IDEOGRAPH-4E8C	# 
+
+2F803 ;	20122 ;	MA	# ( 𠄢 → 𠄢 ) CJK COMPATIBILITY IDEOGRAPH-2F803 → CJK UNIFIED IDEOGRAPH-20122	# 
+
+2F07 ;	4EA0 ;	MA	#* ( ⼇ → 亠 ) KANGXI RADICAL LID → CJK UNIFIED IDEOGRAPH-4EA0	# 
+
+F977 ;	4EAE ;	MA	# ( 亮 → 亮 ) CJK COMPATIBILITY IDEOGRAPH-F977 → CJK UNIFIED IDEOGRAPH-4EAE	# 
+
+2F08 ;	4EBA ;	MA	#* ( ⼈ → 人 ) KANGXI RADICAL MAN → CJK UNIFIED IDEOGRAPH-4EBA	# 
+
+30A4 ;	4EBB ;	MA	# ( イ → 亻 ) KATAKANA LETTER I → CJK UNIFIED IDEOGRAPH-4EBB	# →⺅→
+2E85 ;	4EBB ;	MA	#* ( ⺅ → 亻 ) CJK RADICAL PERSON → CJK UNIFIED IDEOGRAPH-4EBB	# 
+
+F9FD ;	4EC0 ;	MA	# ( 什 → 什 ) CJK COMPATIBILITY IDEOGRAPH-F9FD → CJK UNIFIED IDEOGRAPH-4EC0	# 
+
+2F819 ;	4ECC ;	MA	# ( 仌 → 仌 ) CJK COMPATIBILITY IDEOGRAPH-2F819 → CJK UNIFIED IDEOGRAPH-4ECC	# 
+
+F9A8 ;	4EE4 ;	MA	# ( 令 → 令 ) CJK COMPATIBILITY IDEOGRAPH-F9A8 → CJK UNIFIED IDEOGRAPH-4EE4	# 
+
+2F804 ;	4F60 ;	MA	# ( 你 → 你 ) CJK COMPATIBILITY IDEOGRAPH-2F804 → CJK UNIFIED IDEOGRAPH-4F60	# 
+
+5002 ;	4F75 ;	MA	# ( 倂 → 併 ) CJK UNIFIED IDEOGRAPH-5002 → CJK UNIFIED IDEOGRAPH-4F75	# 
+2F807 ;	4F75 ;	MA	# ( 倂 → 併 ) CJK COMPATIBILITY IDEOGRAPH-2F807 → CJK UNIFIED IDEOGRAPH-4F75	# →倂→
+
+FA73 ;	4F80 ;	MA	# ( 侀 → 侀 ) CJK COMPATIBILITY IDEOGRAPH-FA73 → CJK UNIFIED IDEOGRAPH-4F80	# 
+
+F92D ;	4F86 ;	MA	# ( 來 → 來 ) CJK COMPATIBILITY IDEOGRAPH-F92D → CJK UNIFIED IDEOGRAPH-4F86	# 
+
+F9B5 ;	4F8B ;	MA	# ( 例 → 例 ) CJK COMPATIBILITY IDEOGRAPH-F9B5 → CJK UNIFIED IDEOGRAPH-4F8B	# 
+
+FA30 ;	4FAE ;	MA	# ( 侮 → 侮 ) CJK COMPATIBILITY IDEOGRAPH-FA30 → CJK UNIFIED IDEOGRAPH-4FAE	# 
+2F805 ;	4FAE ;	MA	# ( 侮 → 侮 ) CJK COMPATIBILITY IDEOGRAPH-2F805 → CJK UNIFIED IDEOGRAPH-4FAE	# 
+
+2F806 ;	4FBB ;	MA	# ( 侻 → 侻 ) CJK COMPATIBILITY IDEOGRAPH-2F806 → CJK UNIFIED IDEOGRAPH-4FBB	# 
+
+F965 ;	4FBF ;	MA	# ( 便 → 便 ) CJK COMPATIBILITY IDEOGRAPH-F965 → CJK UNIFIED IDEOGRAPH-4FBF	# 
+
+503C ;	5024 ;	MA	# ( 值 → 値 ) CJK UNIFIED IDEOGRAPH-503C → CJK UNIFIED IDEOGRAPH-5024	# 
+
+F9D4 ;	502B ;	MA	# ( 倫 → 倫 ) CJK COMPATIBILITY IDEOGRAPH-F9D4 → CJK UNIFIED IDEOGRAPH-502B	# 
+
+2F808 ;	507A ;	MA	# ( 偺 → 偺 ) CJK COMPATIBILITY IDEOGRAPH-2F808 → CJK UNIFIED IDEOGRAPH-507A	# 
+
+2F809 ;	5099 ;	MA	# ( 備 → 備 ) CJK COMPATIBILITY IDEOGRAPH-2F809 → CJK UNIFIED IDEOGRAPH-5099	# 
+
+2F80B ;	50CF ;	MA	# ( 像 → 像 ) CJK COMPATIBILITY IDEOGRAPH-2F80B → CJK UNIFIED IDEOGRAPH-50CF	# 
+
+F9BB ;	50DA ;	MA	# ( 僚 → 僚 ) CJK COMPATIBILITY IDEOGRAPH-F9BB → CJK UNIFIED IDEOGRAPH-50DA	# 
+
+FA31 ;	50E7 ;	MA	# ( 僧 → 僧 ) CJK COMPATIBILITY IDEOGRAPH-FA31 → CJK UNIFIED IDEOGRAPH-50E7	# 
+2F80A ;	50E7 ;	MA	# ( 僧 → 僧 ) CJK COMPATIBILITY IDEOGRAPH-2F80A → CJK UNIFIED IDEOGRAPH-50E7	# 
+
+2F80C ;	349E ;	MA	# ( 㒞 → 㒞 ) CJK COMPATIBILITY IDEOGRAPH-2F80C → CJK UNIFIED IDEOGRAPH-349E	# 
+
+3126 ;	513F ;	MA	# ( ㄦ → 儿 ) BOPOMOFO LETTER ER → CJK UNIFIED IDEOGRAPH-513F	# 
+2F09 ;	513F ;	MA	#* ( ⼉ → 儿 ) KANGXI RADICAL LEGS → CJK UNIFIED IDEOGRAPH-513F	# 
+16FF2 ;	513F ;	MA	# ( 𖿲 → 儿 ) CHINESE SMALL SIMPLIFIED ER → CJK UNIFIED IDEOGRAPH-513F	# 
+
+FA0C ;	5140 ;	MA	# ( 兀 → 兀 ) CJK COMPATIBILITY IDEOGRAPH-FA0C → CJK UNIFIED IDEOGRAPH-5140	# 
+2E8E ;	5140 ;	MA	#* ( ⺎ → 兀 ) CJK RADICAL LAME ONE → CJK UNIFIED IDEOGRAPH-5140	# 
+
+FA74 ;	5145 ;	MA	# ( 充 → 充 ) CJK COMPATIBILITY IDEOGRAPH-FA74 → CJK UNIFIED IDEOGRAPH-5145	# 
+
+FA32 ;	514D ;	MA	# ( 免 → 免 ) CJK COMPATIBILITY IDEOGRAPH-FA32 → CJK UNIFIED IDEOGRAPH-514D	# 
+2F80E ;	514D ;	MA	# ( 免 → 免 ) CJK COMPATIBILITY IDEOGRAPH-2F80E → CJK UNIFIED IDEOGRAPH-514D	# 
+
+2F80F ;	5154 ;	MA	# ( 兔 → 兔 ) CJK COMPATIBILITY IDEOGRAPH-2F80F → CJK UNIFIED IDEOGRAPH-5154	# 
+
+2F810 ;	5164 ;	MA	# ( 兤 → 兤 ) CJK COMPATIBILITY IDEOGRAPH-2F810 → CJK UNIFIED IDEOGRAPH-5164	# 
+
+2F0A ;	5165 ;	MA	#* ( ⼊ → 入 ) KANGXI RADICAL ENTER → CJK UNIFIED IDEOGRAPH-5165	# 
+
+2F814 ;	5167 ;	MA	# ( 內 → 內 ) CJK COMPATIBILITY IDEOGRAPH-2F814 → CJK UNIFIED IDEOGRAPH-5167	# 
+
+FA72 ;	5168 ;	MA	# ( 全 → 全 ) CJK COMPATIBILITY IDEOGRAPH-FA72 → CJK UNIFIED IDEOGRAPH-5168	# 
+
+F978 ;	5169 ;	MA	# ( 兩 → 兩 ) CJK COMPATIBILITY IDEOGRAPH-F978 → CJK UNIFIED IDEOGRAPH-5169	# 
+
+30CF ;	516B ;	MA	# ( ハ → 八 ) KATAKANA LETTER HA → CJK UNIFIED IDEOGRAPH-516B	# 
+2F0B ;	516B ;	MA	#* ( ⼋ → 八 ) KANGXI RADICAL EIGHT → CJK UNIFIED IDEOGRAPH-516B	# 
+
+F9D1 ;	516D ;	MA	# ( 六 → 六 ) CJK COMPATIBILITY IDEOGRAPH-F9D1 → CJK UNIFIED IDEOGRAPH-516D	# 
+
+2F811 ;	5177 ;	MA	# ( 具 → 具 ) CJK COMPATIBILITY IDEOGRAPH-2F811 → CJK UNIFIED IDEOGRAPH-5177	# 
+
+2F812 ;	2051C ;	MA	# ( 𠔜 → 𠔜 ) CJK COMPATIBILITY IDEOGRAPH-2F812 → CJK UNIFIED IDEOGRAPH-2051C	# 
+
+2F91B ;	20525 ;	MA	# ( 𠔥 → 𠔥 ) CJK COMPATIBILITY IDEOGRAPH-2F91B → CJK UNIFIED IDEOGRAPH-20525	# 
+
+FA75 ;	5180 ;	MA	# ( 冀 → 冀 ) CJK COMPATIBILITY IDEOGRAPH-FA75 → CJK UNIFIED IDEOGRAPH-5180	# 
+
+2F813 ;	34B9 ;	MA	# ( 㒹 → 㒹 ) CJK COMPATIBILITY IDEOGRAPH-2F813 → CJK UNIFIED IDEOGRAPH-34B9	# 
+
+2F0C ;	5182 ;	MA	#* ( ⼌ → 冂 ) KANGXI RADICAL DOWN BOX → CJK UNIFIED IDEOGRAPH-5182	# 
+
+2F815 ;	518D ;	MA	# ( 再 → 再 ) CJK COMPATIBILITY IDEOGRAPH-2F815 → CJK UNIFIED IDEOGRAPH-518D	# 
+
+2F816 ;	2054B ;	MA	# ( 𠕋 → 𠕋 ) CJK COMPATIBILITY IDEOGRAPH-2F816 → CJK UNIFIED IDEOGRAPH-2054B	# 
+
+2F8D2 ;	5192 ;	MA	# ( 冒 → 冒 ) CJK COMPATIBILITY IDEOGRAPH-2F8D2 → CJK UNIFIED IDEOGRAPH-5192	# 
+
+2F8D3 ;	5195 ;	MA	# ( 冕 → 冕 ) CJK COMPATIBILITY IDEOGRAPH-2F8D3 → CJK UNIFIED IDEOGRAPH-5195	# 
+
+2F9CA ;	34BB ;	MA	# ( 㒻 → 㒻 ) CJK COMPATIBILITY IDEOGRAPH-2F9CA → CJK UNIFIED IDEOGRAPH-34BB	# 
+
+2F8D4 ;	6700 ;	MA	# ( 最 → 最 ) CJK COMPATIBILITY IDEOGRAPH-2F8D4 → CJK UNIFIED IDEOGRAPH-6700	# 
+
+2F0D ;	5196 ;	MA	#* ( ⼍ → 冖 ) KANGXI RADICAL COVER → CJK UNIFIED IDEOGRAPH-5196	# 
+
+2F817 ;	5197 ;	MA	# ( 冗 → 冗 ) CJK COMPATIBILITY IDEOGRAPH-2F817 → CJK UNIFIED IDEOGRAPH-5197	# 
+
+2F818 ;	51A4 ;	MA	# ( 冤 → 冤 ) CJK COMPATIBILITY IDEOGRAPH-2F818 → CJK UNIFIED IDEOGRAPH-51A4	# 
+
+2F0E ;	51AB ;	MA	#* ( ⼎ → 冫 ) KANGXI RADICAL ICE → CJK UNIFIED IDEOGRAPH-51AB	# 
+
+2F81A ;	51AC ;	MA	# ( 冬 → 冬 ) CJK COMPATIBILITY IDEOGRAPH-2F81A → CJK UNIFIED IDEOGRAPH-51AC	# 
+
+FA71 ;	51B5 ;	MA	# ( 况 → 况 ) CJK COMPATIBILITY IDEOGRAPH-FA71 → CJK UNIFIED IDEOGRAPH-51B5	# 
+2F81B ;	51B5 ;	MA	# ( 况 → 况 ) CJK COMPATIBILITY IDEOGRAPH-2F81B → CJK UNIFIED IDEOGRAPH-51B5	# 
+
+F92E ;	51B7 ;	MA	# ( 冷 → 冷 ) CJK COMPATIBILITY IDEOGRAPH-F92E → CJK UNIFIED IDEOGRAPH-51B7	# 
+
+F979 ;	51C9 ;	MA	# ( 凉 → 凉 ) CJK COMPATIBILITY IDEOGRAPH-F979 → CJK UNIFIED IDEOGRAPH-51C9	# 
+
+F955 ;	51CC ;	MA	# ( 凌 → 凌 ) CJK COMPATIBILITY IDEOGRAPH-F955 → CJK UNIFIED IDEOGRAPH-51CC	# 
+
+F954 ;	51DC ;	MA	# ( 凜 → 凜 ) CJK COMPATIBILITY IDEOGRAPH-F954 → CJK UNIFIED IDEOGRAPH-51DC	# 
+
+FA15 ;	51DE ;	MA	# ( 凞 → 凞 ) CJK COMPATIBILITY IDEOGRAPH-FA15 → CJK UNIFIED IDEOGRAPH-51DE	# 
+
+2F0F ;	51E0 ;	MA	#* ( ⼏ → 几 ) KANGXI RADICAL TABLE → CJK UNIFIED IDEOGRAPH-51E0	# 
+
+2F80D ;	2063A ;	MA	# ( 𠘺 → 𠘺 ) CJK COMPATIBILITY IDEOGRAPH-2F80D → CJK UNIFIED IDEOGRAPH-2063A	# 
+
+2F81D ;	51F5 ;	MA	# ( 凵 → 凵 ) CJK COMPATIBILITY IDEOGRAPH-2F81D → CJK UNIFIED IDEOGRAPH-51F5	# 
+2F10 ;	51F5 ;	MA	#* ( ⼐ → 凵 ) KANGXI RADICAL OPEN BOX → CJK UNIFIED IDEOGRAPH-51F5	# 
+20674 ;	51F5 ;	MA	# ( 𠙴 → 凵 ) CJK UNIFIED IDEOGRAPH-20674 → CJK UNIFIED IDEOGRAPH-51F5	# →凵→
+
+2F11 ;	5200 ;	MA	#* ( ⼑ → 刀 ) KANGXI RADICAL KNIFE → CJK UNIFIED IDEOGRAPH-5200	# 
+
+2E89 ;	5202 ;	MA	#* ( ⺉ → 刂 ) CJK RADICAL KNIFE TWO → CJK UNIFIED IDEOGRAPH-5202	# 
+
+2F81E ;	5203 ;	MA	# ( 刃 → 刃 ) CJK COMPATIBILITY IDEOGRAPH-2F81E → CJK UNIFIED IDEOGRAPH-5203	# 
+
+FA00 ;	5207 ;	MA	# ( 切 → 切 ) CJK COMPATIBILITY IDEOGRAPH-FA00 → CJK UNIFIED IDEOGRAPH-5207	# 
+2F850 ;	5207 ;	MA	# ( 切 → 切 ) CJK COMPATIBILITY IDEOGRAPH-2F850 → CJK UNIFIED IDEOGRAPH-5207	# 
+
+F99C ;	5217 ;	MA	# ( 列 → 列 ) CJK COMPATIBILITY IDEOGRAPH-F99C → CJK UNIFIED IDEOGRAPH-5217	# 
+
+F9DD ;	5229 ;	MA	# ( 利 → 利 ) CJK COMPATIBILITY IDEOGRAPH-F9DD → CJK UNIFIED IDEOGRAPH-5229	# 
+
+2F81F ;	34DF ;	MA	# ( 㓟 → 㓟 ) CJK COMPATIBILITY IDEOGRAPH-2F81F → CJK UNIFIED IDEOGRAPH-34DF	# 
+
+F9FF ;	523A ;	MA	# ( 刺 → 刺 ) CJK COMPATIBILITY IDEOGRAPH-F9FF → CJK UNIFIED IDEOGRAPH-523A	# 
+
+2F820 ;	523B ;	MA	# ( 刻 → 刻 ) CJK COMPATIBILITY IDEOGRAPH-2F820 → CJK UNIFIED IDEOGRAPH-523B	# 
+
+2F821 ;	5246 ;	MA	# ( 剆 → 剆 ) CJK COMPATIBILITY IDEOGRAPH-2F821 → CJK UNIFIED IDEOGRAPH-5246	# 
+
+2F822 ;	5272 ;	MA	# ( 割 → 割 ) CJK COMPATIBILITY IDEOGRAPH-2F822 → CJK UNIFIED IDEOGRAPH-5272	# 
+
+2F823 ;	5277 ;	MA	# ( 剷 → 剷 ) CJK COMPATIBILITY IDEOGRAPH-2F823 → CJK UNIFIED IDEOGRAPH-5277	# 
+
+F9C7 ;	5289 ;	MA	# ( 劉 → 劉 ) CJK COMPATIBILITY IDEOGRAPH-F9C7 → CJK UNIFIED IDEOGRAPH-5289	# 
+
+2F9D9 ;	20804 ;	MA	# ( 𠠄 → 𠠄 ) CJK COMPATIBILITY IDEOGRAPH-2F9D9 → CJK UNIFIED IDEOGRAPH-20804	# 
+
+30AB ;	529B ;	MA	# ( カ → 力 ) KATAKANA LETTER KA → CJK UNIFIED IDEOGRAPH-529B	# →⼒→
+F98A ;	529B ;	MA	# ( 力 → 力 ) CJK COMPATIBILITY IDEOGRAPH-F98A → CJK UNIFIED IDEOGRAPH-529B	# 
+2F12 ;	529B ;	MA	#* ( ⼒ → 力 ) KANGXI RADICAL POWER → CJK UNIFIED IDEOGRAPH-529B	# 
+
+F99D ;	52A3 ;	MA	# ( 劣 → 劣 ) CJK COMPATIBILITY IDEOGRAPH-F99D → CJK UNIFIED IDEOGRAPH-52A3	# 
+
+2F824 ;	3515 ;	MA	# ( 㔕 → 㔕 ) CJK COMPATIBILITY IDEOGRAPH-2F824 → CJK UNIFIED IDEOGRAPH-3515	# 
+
+2F992 ;	52B3 ;	MA	# ( 劳 → 劳 ) CJK COMPATIBILITY IDEOGRAPH-2F992 → CJK UNIFIED IDEOGRAPH-52B3	# 
+
+FA76 ;	52C7 ;	MA	# ( 勇 → 勇 ) CJK COMPATIBILITY IDEOGRAPH-FA76 → CJK UNIFIED IDEOGRAPH-52C7	# 
+2F825 ;	52C7 ;	MA	# ( 勇 → 勇 ) CJK COMPATIBILITY IDEOGRAPH-2F825 → CJK UNIFIED IDEOGRAPH-52C7	# 
+
+FA33 ;	52C9 ;	MA	# ( 勉 → 勉 ) CJK COMPATIBILITY IDEOGRAPH-FA33 → CJK UNIFIED IDEOGRAPH-52C9	# 
+2F826 ;	52C9 ;	MA	# ( 勉 → 勉 ) CJK COMPATIBILITY IDEOGRAPH-2F826 → CJK UNIFIED IDEOGRAPH-52C9	# 
+
+F952 ;	52D2 ;	MA	# ( 勒 → 勒 ) CJK COMPATIBILITY IDEOGRAPH-F952 → CJK UNIFIED IDEOGRAPH-52D2	# 
+
+F92F ;	52DE ;	MA	# ( 勞 → 勞 ) CJK COMPATIBILITY IDEOGRAPH-F92F → CJK UNIFIED IDEOGRAPH-52DE	# 
+
+FA34 ;	52E4 ;	MA	# ( 勤 → 勤 ) CJK COMPATIBILITY IDEOGRAPH-FA34 → CJK UNIFIED IDEOGRAPH-52E4	# 
+2F827 ;	52E4 ;	MA	# ( 勤 → 勤 ) CJK COMPATIBILITY IDEOGRAPH-2F827 → CJK UNIFIED IDEOGRAPH-52E4	# 
+
+F97F ;	52F5 ;	MA	# ( 勵 → 勵 ) CJK COMPATIBILITY IDEOGRAPH-F97F → CJK UNIFIED IDEOGRAPH-52F5	# 
+
+2F13 ;	52F9 ;	MA	#* ( ⼓ → 勹 ) KANGXI RADICAL WRAP → CJK UNIFIED IDEOGRAPH-52F9	# 
+
+FA77 ;	52FA ;	MA	# ( 勺 → 勺 ) CJK COMPATIBILITY IDEOGRAPH-FA77 → CJK UNIFIED IDEOGRAPH-52FA	# 
+2F828 ;	52FA ;	MA	# ( 勺 → 勺 ) CJK COMPATIBILITY IDEOGRAPH-2F828 → CJK UNIFIED IDEOGRAPH-52FA	# 
+
+2F829 ;	5305 ;	MA	# ( 包 → 包 ) CJK COMPATIBILITY IDEOGRAPH-2F829 → CJK UNIFIED IDEOGRAPH-5305	# 
+
+2F82A ;	5306 ;	MA	# ( 匆 → 匆 ) CJK COMPATIBILITY IDEOGRAPH-2F82A → CJK UNIFIED IDEOGRAPH-5306	# 
+
+2F9DD ;	208DE ;	MA	# ( 𠣞 → 𠣞 ) CJK COMPATIBILITY IDEOGRAPH-2F9DD → CJK UNIFIED IDEOGRAPH-208DE	# 
+
+2F14 ;	5315 ;	MA	#* ( ⼔ → 匕 ) KANGXI RADICAL SPOON → CJK UNIFIED IDEOGRAPH-5315	# 
+
+F963 ;	5317 ;	MA	# ( 北 → 北 ) CJK COMPATIBILITY IDEOGRAPH-F963 → CJK UNIFIED IDEOGRAPH-5317	# 
+2F82B ;	5317 ;	MA	# ( 北 → 北 ) CJK COMPATIBILITY IDEOGRAPH-2F82B → CJK UNIFIED IDEOGRAPH-5317	# 
+
+2F15 ;	531A ;	MA	#* ( ⼕ → 匚 ) KANGXI RADICAL RIGHT OPEN BOX → CJK UNIFIED IDEOGRAPH-531A	# 
+
+2F16 ;	5338 ;	MA	#* ( ⼖ → 匸 ) KANGXI RADICAL HIDING ENCLOSURE → CJK UNIFIED IDEOGRAPH-5338	# 
+
+F9EB ;	533F ;	MA	# ( 匿 → 匿 ) CJK COMPATIBILITY IDEOGRAPH-F9EB → CJK UNIFIED IDEOGRAPH-533F	# 
+
+2F17 ;	5341 ;	MA	#* ( ⼗ → 十 ) KANGXI RADICAL TEN → CJK UNIFIED IDEOGRAPH-5341	# 
+3038 ;	5341 ;	MA	# ( 〸 → 十 ) HANGZHOU NUMERAL TEN → CJK UNIFIED IDEOGRAPH-5341	# 
+
+303A ;	5345 ;	MA	# ( 〺 → 卅 ) HANGZHOU NUMERAL THIRTY → CJK UNIFIED IDEOGRAPH-5345	# 
+
+2F82C ;	5349 ;	MA	# ( 卉 → 卉 ) CJK COMPATIBILITY IDEOGRAPH-2F82C → CJK UNIFIED IDEOGRAPH-5349	# 
+
+0FD6 ;	534D ;	MA	#* ( ࿖ → 卍 ) LEFT-FACING SVASTI SIGN → CJK UNIFIED IDEOGRAPH-534D	# 
+
+0FD5 ;	5350 ;	MA	#* ( ࿕ → 卐 ) RIGHT-FACING SVASTI SIGN → CJK UNIFIED IDEOGRAPH-5350	# 
+
+FA35 ;	5351 ;	MA	# ( 卑 → 卑 ) CJK COMPATIBILITY IDEOGRAPH-FA35 → CJK UNIFIED IDEOGRAPH-5351	# 
+2F82D ;	5351 ;	MA	# ( 卑 → 卑 ) CJK COMPATIBILITY IDEOGRAPH-2F82D → CJK UNIFIED IDEOGRAPH-5351	# 
+2D161 ;	5351 ;	MA	# ( 𭅡 → 卑 ) CJK UNIFIED IDEOGRAPH-2D161 → CJK UNIFIED IDEOGRAPH-5351	# →卑→
+
+2F82E ;	535A ;	MA	# ( 博 → 博 ) CJK COMPATIBILITY IDEOGRAPH-2F82E → CJK UNIFIED IDEOGRAPH-535A	# 
+
+30C8 ;	535C ;	MA	# ( ト → 卜 ) KATAKANA LETTER TO → CJK UNIFIED IDEOGRAPH-535C	# →⼘→
+2F18 ;	535C ;	MA	#* ( ⼘ → 卜 ) KANGXI RADICAL DIVINATION → CJK UNIFIED IDEOGRAPH-535C	# 
+
+2F19 ;	5369 ;	MA	#* ( ⼙ → 卩 ) KANGXI RADICAL SEAL → CJK UNIFIED IDEOGRAPH-5369	# 
+
+2E8B ;	353E ;	MA	#* ( ⺋ → 㔾 ) CJK RADICAL SEAL → CJK UNIFIED IDEOGRAPH-353E	# 
+
+2F82F ;	5373 ;	MA	# ( 即 → 即 ) CJK COMPATIBILITY IDEOGRAPH-2F82F → CJK UNIFIED IDEOGRAPH-5373	# 
+
+F91C ;	5375 ;	MA	# ( 卵 → 卵 ) CJK COMPATIBILITY IDEOGRAPH-F91C → CJK UNIFIED IDEOGRAPH-5375	# 
+
+2F830 ;	537D ;	MA	# ( 卽 → 卽 ) CJK COMPATIBILITY IDEOGRAPH-2F830 → CJK UNIFIED IDEOGRAPH-537D	# 
+
+2F831 ;	537F ;	MA	# ( 卿 → 卿 ) CJK COMPATIBILITY IDEOGRAPH-2F831 → CJK UNIFIED IDEOGRAPH-537F	# 
+2F832 ;	537F ;	MA	# ( 卿 → 卿 ) CJK COMPATIBILITY IDEOGRAPH-2F832 → CJK UNIFIED IDEOGRAPH-537F	# 
+2F833 ;	537F ;	MA	# ( 卿 → 卿 ) CJK COMPATIBILITY IDEOGRAPH-2F833 → CJK UNIFIED IDEOGRAPH-537F	# 
+
+2F1A ;	5382 ;	MA	#* ( ⼚ → 厂 ) KANGXI RADICAL CLIFF → CJK UNIFIED IDEOGRAPH-5382	# 
+
+2F834 ;	20A2C ;	MA	# ( 𠨬 → 𠨬 ) CJK COMPATIBILITY IDEOGRAPH-2F834 → CJK UNIFIED IDEOGRAPH-20A2C	# 
+
+2F1B ;	53B6 ;	MA	#* ( ⼛ → 厶 ) KANGXI RADICAL PRIVATE → CJK UNIFIED IDEOGRAPH-53B6	# 
+
+F96B ;	53C3 ;	MA	# ( 參 → 參 ) CJK COMPATIBILITY IDEOGRAPH-F96B → CJK UNIFIED IDEOGRAPH-53C3	# 
+
+2F1C ;	53C8 ;	MA	#* ( ⼜ → 又 ) KANGXI RADICAL AGAIN → CJK UNIFIED IDEOGRAPH-53C8	# 
+
+2F836 ;	53CA ;	MA	# ( 及 → 及 ) CJK COMPATIBILITY IDEOGRAPH-2F836 → CJK UNIFIED IDEOGRAPH-53CA	# 
+
+2F837 ;	53DF ;	MA	# ( 叟 → 叟 ) CJK COMPATIBILITY IDEOGRAPH-2F837 → CJK UNIFIED IDEOGRAPH-53DF	# 
+
+2F838 ;	20B63 ;	MA	# ( 𠭣 → 𠭣 ) CJK COMPATIBILITY IDEOGRAPH-2F838 → CJK UNIFIED IDEOGRAPH-20B63	# 
+
+30ED ;	53E3 ;	MA	# ( ロ → 口 ) KATAKANA LETTER RO → CJK UNIFIED IDEOGRAPH-53E3	# →⼞→→⼝→
+2F1D ;	53E3 ;	MA	#* ( ⼝ → 口 ) KANGXI RADICAL MOUTH → CJK UNIFIED IDEOGRAPH-53E3	# 
+56D7 ;	53E3 ;	MA	# ( 囗 → 口 ) CJK UNIFIED IDEOGRAPH-56D7 → CJK UNIFIED IDEOGRAPH-53E3	# →⼞→→⼝→
+2F1E ;	53E3 ;	MA	#* ( ⼞ → 口 ) KANGXI RADICAL ENCLOSURE → CJK UNIFIED IDEOGRAPH-53E3	# →⼝→
+
+F906 ;	53E5 ;	MA	# ( 句 → 句 ) CJK COMPATIBILITY IDEOGRAPH-F906 → CJK UNIFIED IDEOGRAPH-53E5	# 
+
+2F839 ;	53EB ;	MA	# ( 叫 → 叫 ) CJK COMPATIBILITY IDEOGRAPH-2F839 → CJK UNIFIED IDEOGRAPH-53EB	# 
+
+2F83A ;	53F1 ;	MA	# ( 叱 → 叱 ) CJK COMPATIBILITY IDEOGRAPH-2F83A → CJK UNIFIED IDEOGRAPH-53F1	# 
+
+2F83B ;	5406 ;	MA	# ( 吆 → 吆 ) CJK COMPATIBILITY IDEOGRAPH-2F83B → CJK UNIFIED IDEOGRAPH-5406	# 
+
+F9DE ;	540F ;	MA	# ( 吏 → 吏 ) CJK COMPATIBILITY IDEOGRAPH-F9DE → CJK UNIFIED IDEOGRAPH-540F	# 
+
+F9ED ;	541D ;	MA	# ( 吝 → 吝 ) CJK COMPATIBILITY IDEOGRAPH-F9ED → CJK UNIFIED IDEOGRAPH-541D	# 
+
+2F83D ;	5438 ;	MA	# ( 吸 → 吸 ) CJK COMPATIBILITY IDEOGRAPH-2F83D → CJK UNIFIED IDEOGRAPH-5438	# 
+
+F980 ;	5442 ;	MA	# ( 呂 → 呂 ) CJK COMPATIBILITY IDEOGRAPH-F980 → CJK UNIFIED IDEOGRAPH-5442	# 
+
+2F83E ;	5448 ;	MA	# ( 呈 → 呈 ) CJK COMPATIBILITY IDEOGRAPH-2F83E → CJK UNIFIED IDEOGRAPH-5448	# 
+
+2F83F ;	5468 ;	MA	# ( 周 → 周 ) CJK COMPATIBILITY IDEOGRAPH-2F83F → CJK UNIFIED IDEOGRAPH-5468	# 
+
+2F83C ;	549E ;	MA	# ( 咞 → 咞 ) CJK COMPATIBILITY IDEOGRAPH-2F83C → CJK UNIFIED IDEOGRAPH-549E	# 
+
+2F840 ;	54A2 ;	MA	# ( 咢 → 咢 ) CJK COMPATIBILITY IDEOGRAPH-2F840 → CJK UNIFIED IDEOGRAPH-54A2	# 
+
+F99E ;	54BD ;	MA	# ( 咽 → 咽 ) CJK COMPATIBILITY IDEOGRAPH-F99E → CJK UNIFIED IDEOGRAPH-54BD	# 
+
+439B ;	3588 ;	MA	# ( 䎛 → 㖈 ) CJK UNIFIED IDEOGRAPH-439B → CJK UNIFIED IDEOGRAPH-3588	# 
+
+2F841 ;	54F6 ;	MA	# ( 哶 → 哶 ) CJK COMPATIBILITY IDEOGRAPH-2F841 → CJK UNIFIED IDEOGRAPH-54F6	# 
+
+2F842 ;	5510 ;	MA	# ( 唐 → 唐 ) CJK COMPATIBILITY IDEOGRAPH-2F842 → CJK UNIFIED IDEOGRAPH-5510	# 
+
+2F843 ;	5553 ;	MA	# ( 啓 → 啓 ) CJK COMPATIBILITY IDEOGRAPH-2F843 → CJK UNIFIED IDEOGRAPH-5553	# 
+555F ;	5553 ;	MA	# ( 啟 → 啓 ) CJK UNIFIED IDEOGRAPH-555F → CJK UNIFIED IDEOGRAPH-5553	# 
+
+FA79 ;	5555 ;	MA	# ( 啕 → 啕 ) CJK COMPATIBILITY IDEOGRAPH-FA79 → CJK UNIFIED IDEOGRAPH-5555	# 
+
+2F844 ;	5563 ;	MA	# ( 啣 → 啣 ) CJK COMPATIBILITY IDEOGRAPH-2F844 → CJK UNIFIED IDEOGRAPH-5563	# 
+
+2F845 ;	5584 ;	MA	# ( 善 → 善 ) CJK COMPATIBILITY IDEOGRAPH-2F845 → CJK UNIFIED IDEOGRAPH-5584	# 
+2F846 ;	5584 ;	MA	# ( 善 → 善 ) CJK COMPATIBILITY IDEOGRAPH-2F846 → CJK UNIFIED IDEOGRAPH-5584	# 
+
+F90B ;	5587 ;	MA	# ( 喇 → 喇 ) CJK COMPATIBILITY IDEOGRAPH-F90B → CJK UNIFIED IDEOGRAPH-5587	# 
+
+FA7A ;	5599 ;	MA	# ( 喙 → 喙 ) CJK COMPATIBILITY IDEOGRAPH-FA7A → CJK UNIFIED IDEOGRAPH-5599	# 
+2F847 ;	5599 ;	MA	# ( 喙 → 喙 ) CJK COMPATIBILITY IDEOGRAPH-2F847 → CJK UNIFIED IDEOGRAPH-5599	# 
+
+FA36 ;	559D ;	MA	# ( 喝 → 喝 ) CJK COMPATIBILITY IDEOGRAPH-FA36 → CJK UNIFIED IDEOGRAPH-559D	# 
+FA78 ;	559D ;	MA	# ( 喝 → 喝 ) CJK COMPATIBILITY IDEOGRAPH-FA78 → CJK UNIFIED IDEOGRAPH-559D	# 
+
+2F848 ;	55AB ;	MA	# ( 喫 → 喫 ) CJK COMPATIBILITY IDEOGRAPH-2F848 → CJK UNIFIED IDEOGRAPH-55AB	# 
+
+2F849 ;	55B3 ;	MA	# ( 喳 → 喳 ) CJK COMPATIBILITY IDEOGRAPH-2F849 → CJK UNIFIED IDEOGRAPH-55B3	# 
+
+FA0D ;	55C0 ;	MA	# ( 嗀 → 嗀 ) CJK COMPATIBILITY IDEOGRAPH-FA0D → CJK UNIFIED IDEOGRAPH-55C0	# 
+
+2F84A ;	55C2 ;	MA	# ( 嗂 → 嗂 ) CJK COMPATIBILITY IDEOGRAPH-2F84A → CJK UNIFIED IDEOGRAPH-55C2	# 
+
+FA7B ;	55E2 ;	MA	# ( 嗢 → 嗢 ) CJK COMPATIBILITY IDEOGRAPH-FA7B → CJK UNIFIED IDEOGRAPH-55E2	# 
+
+FA37 ;	5606 ;	MA	# ( 嘆 → 嘆 ) CJK COMPATIBILITY IDEOGRAPH-FA37 → CJK UNIFIED IDEOGRAPH-5606	# 
+2F84C ;	5606 ;	MA	# ( 嘆 → 嘆 ) CJK COMPATIBILITY IDEOGRAPH-2F84C → CJK UNIFIED IDEOGRAPH-5606	# 
+
+2F84E ;	5651 ;	MA	# ( 噑 → 噑 ) CJK COMPATIBILITY IDEOGRAPH-2F84E → CJK UNIFIED IDEOGRAPH-5651	# 
+
+2F84F ;	5674 ;	MA	# ( 噴 → 噴 ) CJK COMPATIBILITY IDEOGRAPH-2F84F → CJK UNIFIED IDEOGRAPH-5674	# 
+
+FA38 ;	5668 ;	MA	# ( 器 → 器 ) CJK COMPATIBILITY IDEOGRAPH-FA38 → CJK UNIFIED IDEOGRAPH-5668	# 
+
+F9A9 ;	56F9 ;	MA	# ( 囹 → 囹 ) CJK COMPATIBILITY IDEOGRAPH-F9A9 → CJK UNIFIED IDEOGRAPH-56F9	# 
+
+2F84B ;	5716 ;	MA	# ( 圖 → 圖 ) CJK COMPATIBILITY IDEOGRAPH-2F84B → CJK UNIFIED IDEOGRAPH-5716	# 
+
+2F84D ;	5717 ;	MA	# ( 圗 → 圗 ) CJK COMPATIBILITY IDEOGRAPH-2F84D → CJK UNIFIED IDEOGRAPH-5717	# 
+
+2F1F ;	571F ;	MA	#* ( ⼟ → 土 ) KANGXI RADICAL EARTH → CJK UNIFIED IDEOGRAPH-571F	# 
+58EB ;	571F ;	MA	# ( 士 → 土 ) CJK UNIFIED IDEOGRAPH-58EB → CJK UNIFIED IDEOGRAPH-571F	# →⼠→→⼟→
+2F20 ;	571F ;	MA	#* ( ⼠ → 土 ) KANGXI RADICAL SCHOLAR → CJK UNIFIED IDEOGRAPH-571F	# →⼟→
+
+2F855 ;	578B ;	MA	# ( 型 → 型 ) CJK COMPATIBILITY IDEOGRAPH-2F855 → CJK UNIFIED IDEOGRAPH-578B	# 
+
+2F852 ;	57CE ;	MA	# ( 城 → 城 ) CJK COMPATIBILITY IDEOGRAPH-2F852 → CJK UNIFIED IDEOGRAPH-57CE	# 
+
+39B3 ;	363D ;	MA	# ( 㦳 → 㘽 ) CJK UNIFIED IDEOGRAPH-39B3 → CJK UNIFIED IDEOGRAPH-363D	# 
+
+2F853 ;	57F4 ;	MA	# ( 埴 → 埴 ) CJK COMPATIBILITY IDEOGRAPH-2F853 → CJK UNIFIED IDEOGRAPH-57F4	# 
+
+2F854 ;	580D ;	MA	# ( 堍 → 堍 ) CJK COMPATIBILITY IDEOGRAPH-2F854 → CJK UNIFIED IDEOGRAPH-580D	# 
+
+2F857 ;	5831 ;	MA	# ( 報 → 報 ) CJK COMPATIBILITY IDEOGRAPH-2F857 → CJK UNIFIED IDEOGRAPH-5831	# 
+
+2F856 ;	5832 ;	MA	# ( 堲 → 堲 ) CJK COMPATIBILITY IDEOGRAPH-2F856 → CJK UNIFIED IDEOGRAPH-5832	# 
+
+FA39 ;	5840 ;	MA	# ( 塀 → 塀 ) CJK COMPATIBILITY IDEOGRAPH-FA39 → CJK UNIFIED IDEOGRAPH-5840	# 
+
+FA10 ;	585A ;	MA	# ( 塚 → 塚 ) CJK COMPATIBILITY IDEOGRAPH-FA10 → CJK UNIFIED IDEOGRAPH-585A	# 
+FA7C ;	585A ;	MA	# ( 塚 → 塚 ) CJK COMPATIBILITY IDEOGRAPH-FA7C → CJK UNIFIED IDEOGRAPH-585A	# 
+
+F96C ;	585E ;	MA	# ( 塞 → 塞 ) CJK COMPATIBILITY IDEOGRAPH-F96C → CJK UNIFIED IDEOGRAPH-585E	# 
+
+586B ;	5861 ;	MA	# ( 填 → 塡 ) CJK UNIFIED IDEOGRAPH-586B → CJK UNIFIED IDEOGRAPH-5861	# 
+
+58FF ;	58AB ;	MA	# ( 壿 → 墫 ) CJK UNIFIED IDEOGRAPH-58FF → CJK UNIFIED IDEOGRAPH-58AB	# 
+
+2F858 ;	58AC ;	MA	# ( 墬 → 墬 ) CJK COMPATIBILITY IDEOGRAPH-2F858 → CJK UNIFIED IDEOGRAPH-58AC	# 
+
+FA7D ;	58B3 ;	MA	# ( 墳 → 墳 ) CJK COMPATIBILITY IDEOGRAPH-FA7D → CJK UNIFIED IDEOGRAPH-58B3	# 
+
+F94A ;	58D8 ;	MA	# ( 壘 → 壘 ) CJK COMPATIBILITY IDEOGRAPH-F94A → CJK UNIFIED IDEOGRAPH-58D8	# 
+
+F942 ;	58DF ;	MA	# ( 壟 → 壟 ) CJK COMPATIBILITY IDEOGRAPH-F942 → CJK UNIFIED IDEOGRAPH-58DF	# 
+
+2F859 ;	214E4 ;	MA	# ( 𡓤 → 𡓤 ) CJK COMPATIBILITY IDEOGRAPH-2F859 → CJK UNIFIED IDEOGRAPH-214E4	# 
+
+2F851 ;	58EE ;	MA	# ( 壮 → 壮 ) CJK COMPATIBILITY IDEOGRAPH-2F851 → CJK UNIFIED IDEOGRAPH-58EE	# 
+
+2F85A ;	58F2 ;	MA	# ( 売 → 売 ) CJK COMPATIBILITY IDEOGRAPH-2F85A → CJK UNIFIED IDEOGRAPH-58F2	# 
+
+2F85B ;	58F7 ;	MA	# ( 壷 → 壷 ) CJK COMPATIBILITY IDEOGRAPH-2F85B → CJK UNIFIED IDEOGRAPH-58F7	# 
+21533 ;	58F7 ;	MA	# ( 𡔳 → 壷 ) CJK UNIFIED IDEOGRAPH-21533 → CJK UNIFIED IDEOGRAPH-58F7	# →壷→
+
+2F21 ;	5902 ;	MA	#* ( ⼡ → 夂 ) KANGXI RADICAL GO → CJK UNIFIED IDEOGRAPH-5902	# 
+
+2F85C ;	5906 ;	MA	# ( 夆 → 夆 ) CJK COMPATIBILITY IDEOGRAPH-2F85C → CJK UNIFIED IDEOGRAPH-5906	# 
+
+2F22 ;	590A ;	MA	#* ( ⼢ → 夊 ) KANGXI RADICAL GO SLOWLY → CJK UNIFIED IDEOGRAPH-590A	# 
+
+30BF ;	5915 ;	MA	# ( タ → 夕 ) KATAKANA LETTER TA → CJK UNIFIED IDEOGRAPH-5915	# →⼣→
+2F23 ;	5915 ;	MA	#* ( ⼣ → 夕 ) KANGXI RADICAL EVENING → CJK UNIFIED IDEOGRAPH-5915	# 
+
+2F85D ;	591A ;	MA	# ( 多 → 多 ) CJK COMPATIBILITY IDEOGRAPH-2F85D → CJK UNIFIED IDEOGRAPH-591A	# 
+21587 ;	591A ;	MA	# ( 𡖇 → 多 ) CJK UNIFIED IDEOGRAPH-21587 → CJK UNIFIED IDEOGRAPH-591A	# →多→
+
+2F85E ;	5922 ;	MA	# ( 夢 → 夢 ) CJK COMPATIBILITY IDEOGRAPH-2F85E → CJK UNIFIED IDEOGRAPH-5922	# 
+
+2F24 ;	5927 ;	MA	#* ( ⼤ → 大 ) KANGXI RADICAL BIG → CJK UNIFIED IDEOGRAPH-5927	# 
+
+FA7E ;	5944 ;	MA	# ( 奄 → 奄 ) CJK COMPATIBILITY IDEOGRAPH-FA7E → CJK UNIFIED IDEOGRAPH-5944	# 
+
+F90C ;	5948 ;	MA	# ( 奈 → 奈 ) CJK COMPATIBILITY IDEOGRAPH-F90C → CJK UNIFIED IDEOGRAPH-5948	# 
+
+FA7F ;	5954 ;	MA	# ( 奔 → 奔 ) CJK COMPATIBILITY IDEOGRAPH-FA7F → CJK UNIFIED IDEOGRAPH-5954	# 
+
+F909 ;	5951 ;	MA	# ( 契 → 契 ) CJK COMPATIBILITY IDEOGRAPH-F909 → CJK UNIFIED IDEOGRAPH-5951	# 
+
+2F85F ;	5962 ;	MA	# ( 奢 → 奢 ) CJK COMPATIBILITY IDEOGRAPH-2F85F → CJK UNIFIED IDEOGRAPH-5962	# 
+
+F981 ;	5973 ;	MA	# ( 女 → 女 ) CJK COMPATIBILITY IDEOGRAPH-F981 → CJK UNIFIED IDEOGRAPH-5973	# 
+2F25 ;	5973 ;	MA	#* ( ⼥ → 女 ) KANGXI RADICAL WOMAN → CJK UNIFIED IDEOGRAPH-5973	# 
+
+216A7 ;	216A8 ;	MA	# ( 𡚧 → 𡚨 ) CJK UNIFIED IDEOGRAPH-216A7 → CJK UNIFIED IDEOGRAPH-216A8	# →𡚨→
+2F860 ;	216A8 ;	MA	# ( 𡚨 → 𡚨 ) CJK COMPATIBILITY IDEOGRAPH-2F860 → CJK UNIFIED IDEOGRAPH-216A8	# 
+
+2F861 ;	216EA ;	MA	# ( 𡛪 → 𡛪 ) CJK COMPATIBILITY IDEOGRAPH-2F861 → CJK UNIFIED IDEOGRAPH-216EA	# 
+
+2F865 ;	59D8 ;	MA	# ( 姘 → 姘 ) CJK COMPATIBILITY IDEOGRAPH-2F865 → CJK UNIFIED IDEOGRAPH-59D8	# 
+
+2F862 ;	59EC ;	MA	# ( 姬 → 姬 ) CJK COMPATIBILITY IDEOGRAPH-2F862 → CJK UNIFIED IDEOGRAPH-59EC	# 
+
+2F863 ;	5A1B ;	MA	# ( 娛 → 娛 ) CJK COMPATIBILITY IDEOGRAPH-2F863 → CJK UNIFIED IDEOGRAPH-5A1B	# 
+
+2F864 ;	5A27 ;	MA	# ( 娧 → 娧 ) CJK COMPATIBILITY IDEOGRAPH-2F864 → CJK UNIFIED IDEOGRAPH-5A27	# 
+
+FA80 ;	5A62 ;	MA	# ( 婢 → 婢 ) CJK COMPATIBILITY IDEOGRAPH-FA80 → CJK UNIFIED IDEOGRAPH-5A62	# 
+
+2F866 ;	5A66 ;	MA	# ( 婦 → 婦 ) CJK COMPATIBILITY IDEOGRAPH-2F866 → CJK UNIFIED IDEOGRAPH-5A66	# 
+
+5B00 ;	5AAF ;	MA	# ( 嬀 → 媯 ) CJK UNIFIED IDEOGRAPH-5B00 → CJK UNIFIED IDEOGRAPH-5AAF	# 
+
+2F867 ;	36EE ;	MA	# ( 㛮 → 㛮 ) CJK COMPATIBILITY IDEOGRAPH-2F867 → CJK UNIFIED IDEOGRAPH-36EE	# 
+
+2F868 ;	36FC ;	MA	# ( 㛼 → 㛼 ) CJK COMPATIBILITY IDEOGRAPH-2F868 → CJK UNIFIED IDEOGRAPH-36FC	# 
+
+2F986 ;	5AB5 ;	MA	# ( 媵 → 媵 ) CJK COMPATIBILITY IDEOGRAPH-2F986 → CJK UNIFIED IDEOGRAPH-5AB5	# 
+
+2F869 ;	5B08 ;	MA	# ( 嬈 → 嬈 ) CJK COMPATIBILITY IDEOGRAPH-2F869 → CJK UNIFIED IDEOGRAPH-5B08	# 
+
+FA81 ;	5B28 ;	MA	# ( 嬨 → 嬨 ) CJK COMPATIBILITY IDEOGRAPH-FA81 → CJK UNIFIED IDEOGRAPH-5B28	# 
+
+2F86A ;	5B3E ;	MA	# ( 嬾 → 嬾 ) CJK COMPATIBILITY IDEOGRAPH-2F86A → CJK UNIFIED IDEOGRAPH-5B3E	# 
+2F86B ;	5B3E ;	MA	# ( 嬾 → 嬾 ) CJK COMPATIBILITY IDEOGRAPH-2F86B → CJK UNIFIED IDEOGRAPH-5B3E	# 
+
+2F26 ;	5B50 ;	MA	#* ( ⼦ → 子 ) KANGXI RADICAL CHILD → CJK UNIFIED IDEOGRAPH-5B50	# 
+
+2F27 ;	5B80 ;	MA	#* ( ⼧ → 宀 ) KANGXI RADICAL ROOF → CJK UNIFIED IDEOGRAPH-5B80	# 
+
+FA04 ;	5B85 ;	MA	# ( 宅 → 宅 ) CJK COMPATIBILITY IDEOGRAPH-FA04 → CJK UNIFIED IDEOGRAPH-5B85	# 
+
+2F86C ;	219C8 ;	MA	# ( 𡧈 → 𡧈 ) CJK COMPATIBILITY IDEOGRAPH-2F86C → CJK UNIFIED IDEOGRAPH-219C8	# 
+
+2F86D ;	5BC3 ;	MA	# ( 寃 → 寃 ) CJK COMPATIBILITY IDEOGRAPH-2F86D → CJK UNIFIED IDEOGRAPH-5BC3	# 
+
+2F86E ;	5BD8 ;	MA	# ( 寘 → 寘 ) CJK COMPATIBILITY IDEOGRAPH-2F86E → CJK UNIFIED IDEOGRAPH-5BD8	# 
+
+F95F ;	5BE7 ;	MA	# ( 寧 → 寧 ) CJK COMPATIBILITY IDEOGRAPH-F95F → CJK UNIFIED IDEOGRAPH-5BE7	# 
+F9AA ;	5BE7 ;	MA	# ( 寧 → 寧 ) CJK COMPATIBILITY IDEOGRAPH-F9AA → CJK UNIFIED IDEOGRAPH-5BE7	# 
+2F86F ;	5BE7 ;	MA	# ( 寧 → 寧 ) CJK COMPATIBILITY IDEOGRAPH-2F86F → CJK UNIFIED IDEOGRAPH-5BE7	# 
+
+F9BC ;	5BEE ;	MA	# ( 寮 → 寮 ) CJK COMPATIBILITY IDEOGRAPH-F9BC → CJK UNIFIED IDEOGRAPH-5BEE	# 
+
+2F870 ;	5BF3 ;	MA	# ( 寳 → 寳 ) CJK COMPATIBILITY IDEOGRAPH-2F870 → CJK UNIFIED IDEOGRAPH-5BF3	# 
+
+2F871 ;	21B18 ;	MA	# ( 𡬘 → 𡬘 ) CJK COMPATIBILITY IDEOGRAPH-2F871 → CJK UNIFIED IDEOGRAPH-21B18	# 
+
+2F28 ;	5BF8 ;	MA	#* ( ⼨ → 寸 ) KANGXI RADICAL INCH → CJK UNIFIED IDEOGRAPH-5BF8	# 
+
+2F872 ;	5BFF ;	MA	# ( 寿 → 寿 ) CJK COMPATIBILITY IDEOGRAPH-2F872 → CJK UNIFIED IDEOGRAPH-5BFF	# 
+
+2F873 ;	5C06 ;	MA	# ( 将 → 将 ) CJK COMPATIBILITY IDEOGRAPH-2F873 → CJK UNIFIED IDEOGRAPH-5C06	# 
+
+2F29 ;	5C0F ;	MA	#* ( ⼩ → 小 ) KANGXI RADICAL SMALL → CJK UNIFIED IDEOGRAPH-5C0F	# 
+
+2F875 ;	5C22 ;	MA	# ( 尢 → 尢 ) CJK COMPATIBILITY IDEOGRAPH-2F875 → CJK UNIFIED IDEOGRAPH-5C22	# 
+2E90 ;	5C22 ;	MA	#* ( ⺐ → 尢 ) CJK RADICAL LAME THREE → CJK UNIFIED IDEOGRAPH-5C22	# 
+2F2A ;	5C22 ;	MA	#* ( ⼪ → 尢 ) KANGXI RADICAL LAME → CJK UNIFIED IDEOGRAPH-5C22	# 
+
+2E8F ;	5C23 ;	MA	#* ( ⺏ → 尣 ) CJK RADICAL LAME TWO → CJK UNIFIED IDEOGRAPH-5C23	# 
+
+2F876 ;	3781 ;	MA	# ( 㞁 → 㞁 ) CJK COMPATIBILITY IDEOGRAPH-2F876 → CJK UNIFIED IDEOGRAPH-3781	# 
+
+2F2B ;	5C38 ;	MA	#* ( ⼫ → 尸 ) KANGXI RADICAL CORPSE → CJK UNIFIED IDEOGRAPH-5C38	# 
+
+F9BD ;	5C3F ;	MA	# ( 尿 → 尿 ) CJK COMPATIBILITY IDEOGRAPH-F9BD → CJK UNIFIED IDEOGRAPH-5C3F	# 
+
+2F877 ;	5C60 ;	MA	# ( 屠 → 屠 ) CJK COMPATIBILITY IDEOGRAPH-2F877 → CJK UNIFIED IDEOGRAPH-5C60	# 
+
+F94B ;	5C62 ;	MA	# ( 屢 → 屢 ) CJK COMPATIBILITY IDEOGRAPH-F94B → CJK UNIFIED IDEOGRAPH-5C62	# 
+
+FA3B ;	5C64 ;	MA	# ( 層 → 層 ) CJK COMPATIBILITY IDEOGRAPH-FA3B → CJK UNIFIED IDEOGRAPH-5C64	# 
+
+F9DF ;	5C65 ;	MA	# ( 履 → 履 ) CJK COMPATIBILITY IDEOGRAPH-F9DF → CJK UNIFIED IDEOGRAPH-5C65	# 
+
+FA3C ;	5C6E ;	MA	# ( 屮 → 屮 ) CJK COMPATIBILITY IDEOGRAPH-FA3C → CJK UNIFIED IDEOGRAPH-5C6E	# 
+2F878 ;	5C6E ;	MA	# ( 屮 → 屮 ) CJK COMPATIBILITY IDEOGRAPH-2F878 → CJK UNIFIED IDEOGRAPH-5C6E	# 
+2F2C ;	5C6E ;	MA	#* ( ⼬ → 屮 ) KANGXI RADICAL SPROUT → CJK UNIFIED IDEOGRAPH-5C6E	# 
+
+2F8F8 ;	21D0B ;	MA	# ( 𡴋 → 𡴋 ) CJK COMPATIBILITY IDEOGRAPH-2F8F8 → CJK UNIFIED IDEOGRAPH-21D0B	# 
+
+2F2D ;	5C71 ;	MA	#* ( ⼭ → 山 ) KANGXI RADICAL MOUNTAIN → CJK UNIFIED IDEOGRAPH-5C71	# 
+
+2F879 ;	5CC0 ;	MA	# ( 峀 → 峀 ) CJK COMPATIBILITY IDEOGRAPH-2F879 → CJK UNIFIED IDEOGRAPH-5CC0	# 
+2B73A ;	5CC0 ;	MA	# ( 𫜺 → 峀 ) CJK UNIFIED IDEOGRAPH-2B73A → CJK UNIFIED IDEOGRAPH-5CC0	# 
+
+2F87A ;	5C8D ;	MA	# ( 岍 → 岍 ) CJK COMPATIBILITY IDEOGRAPH-2F87A → CJK UNIFIED IDEOGRAPH-5C8D	# 
+
+2F87B ;	21DE4 ;	MA	# ( 𡷤 → 𡷤 ) CJK COMPATIBILITY IDEOGRAPH-2F87B → CJK UNIFIED IDEOGRAPH-21DE4	# 
+
+2F87D ;	21DE6 ;	MA	# ( 𡷦 → 𡷦 ) CJK COMPATIBILITY IDEOGRAPH-2F87D → CJK UNIFIED IDEOGRAPH-21DE6	# 
+
+F9D5 ;	5D19 ;	MA	# ( 崙 → 崙 ) CJK COMPATIBILITY IDEOGRAPH-F9D5 → CJK UNIFIED IDEOGRAPH-5D19	# 
+
+2F87C ;	5D43 ;	MA	# ( 嵃 → 嵃 ) CJK COMPATIBILITY IDEOGRAPH-2F87C → CJK UNIFIED IDEOGRAPH-5D43	# 
+
+F921 ;	5D50 ;	MA	# ( 嵐 → 嵐 ) CJK COMPATIBILITY IDEOGRAPH-F921 → CJK UNIFIED IDEOGRAPH-5D50	# 
+
+2F87F ;	5D6B ;	MA	# ( 嵫 → 嵫 ) CJK COMPATIBILITY IDEOGRAPH-2F87F → CJK UNIFIED IDEOGRAPH-5D6B	# 
+
+2F87E ;	5D6E ;	MA	# ( 嵮 → 嵮 ) CJK COMPATIBILITY IDEOGRAPH-2F87E → CJK UNIFIED IDEOGRAPH-5D6E	# 
+
+2F880 ;	5D7C ;	MA	# ( 嵼 → 嵼 ) CJK COMPATIBILITY IDEOGRAPH-2F880 → CJK UNIFIED IDEOGRAPH-5D7C	# 
+
+2F9F4 ;	5DB2 ;	MA	# ( 嶲 → 嶲 ) CJK COMPATIBILITY IDEOGRAPH-2F9F4 → CJK UNIFIED IDEOGRAPH-5DB2	# 
+
+F9AB ;	5DBA ;	MA	# ( 嶺 → 嶺 ) CJK COMPATIBILITY IDEOGRAPH-F9AB → CJK UNIFIED IDEOGRAPH-5DBA	# 
+
+2F2E ;	5DDB ;	MA	#* ( ⼮ → 巛 ) KANGXI RADICAL RIVER → CJK UNIFIED IDEOGRAPH-5DDB	# 
+
+2F882 ;	5DE2 ;	MA	# ( 巢 → 巢 ) CJK COMPATIBILITY IDEOGRAPH-2F882 → CJK UNIFIED IDEOGRAPH-5DE2	# 
+
+30A8 ;	5DE5 ;	MA	# ( エ → 工 ) KATAKANA LETTER E → CJK UNIFIED IDEOGRAPH-5DE5	# →⼯→
+2F2F ;	5DE5 ;	MA	#* ( ⼯ → 工 ) KANGXI RADICAL WORK → CJK UNIFIED IDEOGRAPH-5DE5	# 
+
+2F30 ;	5DF1 ;	MA	#* ( ⼰ → 己 ) KANGXI RADICAL ONESELF → CJK UNIFIED IDEOGRAPH-5DF1	# 
+
+2E92 ;	5DF3 ;	MA	#* ( ⺒ → 巳 ) CJK RADICAL SNAKE → CJK UNIFIED IDEOGRAPH-5DF3	# 
+
+2F883 ;	382F ;	MA	# ( 㠯 → 㠯 ) CJK COMPATIBILITY IDEOGRAPH-2F883 → CJK UNIFIED IDEOGRAPH-382F	# 
+
+2F884 ;	5DFD ;	MA	# ( 巽 → 巽 ) CJK COMPATIBILITY IDEOGRAPH-2F884 → CJK UNIFIED IDEOGRAPH-5DFD	# 
+
+2F31 ;	5DFE ;	MA	#* ( ⼱ → 巾 ) KANGXI RADICAL TURBAN → CJK UNIFIED IDEOGRAPH-5DFE	# 
+
+5E32 ;	5E21 ;	MA	# ( 帲 → 帡 ) CJK UNIFIED IDEOGRAPH-5E32 → CJK UNIFIED IDEOGRAPH-5E21	# 
+
+2F885 ;	5E28 ;	MA	# ( 帨 → 帨 ) CJK COMPATIBILITY IDEOGRAPH-2F885 → CJK UNIFIED IDEOGRAPH-5E28	# 
+
+2F886 ;	5E3D ;	MA	# ( 帽 → 帽 ) CJK COMPATIBILITY IDEOGRAPH-2F886 → CJK UNIFIED IDEOGRAPH-5E3D	# 
+
+2F887 ;	5E69 ;	MA	# ( 幩 → 幩 ) CJK COMPATIBILITY IDEOGRAPH-2F887 → CJK UNIFIED IDEOGRAPH-5E69	# 
+
+2F888 ;	3862 ;	MA	# ( 㡢 → 㡢 ) CJK COMPATIBILITY IDEOGRAPH-2F888 → CJK UNIFIED IDEOGRAPH-3862	# 
+
+2F889 ;	22183 ;	MA	# ( 𢆃 → 𢆃 ) CJK COMPATIBILITY IDEOGRAPH-2F889 → CJK UNIFIED IDEOGRAPH-22183	# 
+
+2F32 ;	5E72 ;	MA	#* ( ⼲ → 干 ) KANGXI RADICAL DRY → CJK UNIFIED IDEOGRAPH-5E72	# 
+
+F98E ;	5E74 ;	MA	# ( 年 → 年 ) CJK COMPATIBILITY IDEOGRAPH-F98E → CJK UNIFIED IDEOGRAPH-5E74	# 
+
+2F939 ;	2219F ;	MA	# ( 𢆟 → 𢆟 ) CJK COMPATIBILITY IDEOGRAPH-2F939 → CJK UNIFIED IDEOGRAPH-2219F	# 
+
+2E93 ;	5E7A ;	MA	#* ( ⺓ → 幺 ) CJK RADICAL THREAD → CJK UNIFIED IDEOGRAPH-5E7A	# 
+2F33 ;	5E7A ;	MA	#* ( ⼳ → 幺 ) KANGXI RADICAL SHORT THREAD → CJK UNIFIED IDEOGRAPH-5E7A	# 
+
+2F34 ;	5E7F ;	MA	#* ( ⼴ → 广 ) KANGXI RADICAL DOTTED CLIFF → CJK UNIFIED IDEOGRAPH-5E7F	# 
+
+FA01 ;	5EA6 ;	MA	# ( 度 → 度 ) CJK COMPATIBILITY IDEOGRAPH-FA01 → CJK UNIFIED IDEOGRAPH-5EA6	# 
+
+2F88A ;	387C ;	MA	# ( 㡼 → 㡼 ) CJK COMPATIBILITY IDEOGRAPH-2F88A → CJK UNIFIED IDEOGRAPH-387C	# 
+
+2F88B ;	5EB0 ;	MA	# ( 庰 → 庰 ) CJK COMPATIBILITY IDEOGRAPH-2F88B → CJK UNIFIED IDEOGRAPH-5EB0	# 
+
+2F88C ;	5EB3 ;	MA	# ( 庳 → 庳 ) CJK COMPATIBILITY IDEOGRAPH-2F88C → CJK UNIFIED IDEOGRAPH-5EB3	# 
+
+2F88D ;	5EB6 ;	MA	# ( 庶 → 庶 ) CJK COMPATIBILITY IDEOGRAPH-2F88D → CJK UNIFIED IDEOGRAPH-5EB6	# 
+
+F928 ;	5ECA ;	MA	# ( 廊 → 廊 ) CJK COMPATIBILITY IDEOGRAPH-F928 → CJK UNIFIED IDEOGRAPH-5ECA	# 
+2F88E ;	5ECA ;	MA	# ( 廊 → 廊 ) CJK COMPATIBILITY IDEOGRAPH-2F88E → CJK UNIFIED IDEOGRAPH-5ECA	# 
+
+F9A2 ;	5EC9 ;	MA	# ( 廉 → 廉 ) CJK COMPATIBILITY IDEOGRAPH-F9A2 → CJK UNIFIED IDEOGRAPH-5EC9	# 
+
+FA82 ;	5ED2 ;	MA	# ( 廒 → 廒 ) CJK COMPATIBILITY IDEOGRAPH-FA82 → CJK UNIFIED IDEOGRAPH-5ED2	# 
+
+FA0B ;	5ED3 ;	MA	# ( 廓 → 廓 ) CJK COMPATIBILITY IDEOGRAPH-FA0B → CJK UNIFIED IDEOGRAPH-5ED3	# 
+
+FA83 ;	5ED9 ;	MA	# ( 廙 → 廙 ) CJK COMPATIBILITY IDEOGRAPH-FA83 → CJK UNIFIED IDEOGRAPH-5ED9	# 
+
+F982 ;	5EEC ;	MA	# ( 廬 → 廬 ) CJK COMPATIBILITY IDEOGRAPH-F982 → CJK UNIFIED IDEOGRAPH-5EEC	# 
+
+2F35 ;	5EF4 ;	MA	#* ( ⼵ → 廴 ) KANGXI RADICAL LONG STRIDE → CJK UNIFIED IDEOGRAPH-5EF4	# 
+
+2F890 ;	5EFE ;	MA	# ( 廾 → 廾 ) CJK COMPATIBILITY IDEOGRAPH-2F890 → CJK UNIFIED IDEOGRAPH-5EFE	# 
+2F36 ;	5EFE ;	MA	#* ( ⼶ → 廾 ) KANGXI RADICAL TWO HANDS → CJK UNIFIED IDEOGRAPH-5EFE	# 
+
+2F891 ;	22331 ;	MA	# ( 𢌱 → 𢌱 ) CJK COMPATIBILITY IDEOGRAPH-2F891 → CJK UNIFIED IDEOGRAPH-22331	# 
+2F892 ;	22331 ;	MA	# ( 𢌱 → 𢌱 ) CJK COMPATIBILITY IDEOGRAPH-2F892 → CJK UNIFIED IDEOGRAPH-22331	# 
+
+F943 ;	5F04 ;	MA	# ( 弄 → 弄 ) CJK COMPATIBILITY IDEOGRAPH-F943 → CJK UNIFIED IDEOGRAPH-5F04	# 
+
+2F37 ;	5F0B ;	MA	#* ( ⼷ → 弋 ) KANGXI RADICAL SHOOT → CJK UNIFIED IDEOGRAPH-5F0B	# 
+
+2F38 ;	5F13 ;	MA	#* ( ⼸ → 弓 ) KANGXI RADICAL BOW → CJK UNIFIED IDEOGRAPH-5F13	# 
+
+2F894 ;	5F22 ;	MA	# ( 弢 → 弢 ) CJK COMPATIBILITY IDEOGRAPH-2F894 → CJK UNIFIED IDEOGRAPH-5F22	# 
+2F895 ;	5F22 ;	MA	# ( 弢 → 弢 ) CJK COMPATIBILITY IDEOGRAPH-2F895 → CJK UNIFIED IDEOGRAPH-5F22	# 
+
+2F39 ;	5F50 ;	MA	#* ( ⼹ → 彐 ) KANGXI RADICAL SNOUT → CJK UNIFIED IDEOGRAPH-5F50	# 
+
+2E94 ;	5F51 ;	MA	#* ( ⺔ → 彑 ) CJK RADICAL SNOUT ONE → CJK UNIFIED IDEOGRAPH-5F51	# 
+
+2F874 ;	5F53 ;	MA	# ( 当 → 当 ) CJK COMPATIBILITY IDEOGRAPH-2F874 → CJK UNIFIED IDEOGRAPH-5F53	# 
+
+2F896 ;	38C7 ;	MA	# ( 㣇 → 㣇 ) CJK COMPATIBILITY IDEOGRAPH-2F896 → CJK UNIFIED IDEOGRAPH-38C7	# 
+
+2F3A ;	5F61 ;	MA	#* ( ⼺ → 彡 ) KANGXI RADICAL BRISTLE → CJK UNIFIED IDEOGRAPH-5F61	# 
+
+2F899 ;	5F62 ;	MA	# ( 形 → 形 ) CJK COMPATIBILITY IDEOGRAPH-2F899 → CJK UNIFIED IDEOGRAPH-5F62	# 
+
+FA84 ;	5F69 ;	MA	# ( 彩 → 彩 ) CJK COMPATIBILITY IDEOGRAPH-FA84 → CJK UNIFIED IDEOGRAPH-5F69	# 
+
+2F89A ;	5F6B ;	MA	# ( 彫 → 彫 ) CJK COMPATIBILITY IDEOGRAPH-2F89A → CJK UNIFIED IDEOGRAPH-5F6B	# 
+
+2F3B ;	5F73 ;	MA	#* ( ⼻ → 彳 ) KANGXI RADICAL STEP → CJK UNIFIED IDEOGRAPH-5F73	# 
+
+F9D8 ;	5F8B ;	MA	# ( 律 → 律 ) CJK COMPATIBILITY IDEOGRAPH-F9D8 → CJK UNIFIED IDEOGRAPH-5F8B	# 
+
+2F89B ;	38E3 ;	MA	# ( 㣣 → 㣣 ) CJK COMPATIBILITY IDEOGRAPH-2F89B → CJK UNIFIED IDEOGRAPH-38E3	# 
+
+22505 ;	5F9A ;	MA	# ( 𢔅 → 徚 ) CJK UNIFIED IDEOGRAPH-22505 → CJK UNIFIED IDEOGRAPH-5F9A	# →徚→
+2F89C ;	5F9A ;	MA	# ( 徚 → 徚 ) CJK COMPATIBILITY IDEOGRAPH-2F89C → CJK UNIFIED IDEOGRAPH-5F9A	# 
+
+F966 ;	5FA9 ;	MA	# ( 復 → 復 ) CJK COMPATIBILITY IDEOGRAPH-F966 → CJK UNIFIED IDEOGRAPH-5FA9	# 
+
+FA85 ;	5FAD ;	MA	# ( 徭 → 徭 ) CJK COMPATIBILITY IDEOGRAPH-FA85 → CJK UNIFIED IDEOGRAPH-5FAD	# 
+
+2F3C ;	5FC3 ;	MA	#* ( ⼼ → 心 ) KANGXI RADICAL HEART → CJK UNIFIED IDEOGRAPH-5FC3	# 
+
+2E96 ;	5FC4 ;	MA	#* ( ⺖ → 忄 ) CJK RADICAL HEART ONE → CJK UNIFIED IDEOGRAPH-5FC4	# 
+
+2E97 ;	38FA ;	MA	#* ( ⺗ → 㣺 ) CJK RADICAL HEART TWO → CJK UNIFIED IDEOGRAPH-38FA	# 
+
+2F89D ;	5FCD ;	MA	# ( 忍 → 忍 ) CJK COMPATIBILITY IDEOGRAPH-2F89D → CJK UNIFIED IDEOGRAPH-5FCD	# 
+
+2F89E ;	5FD7 ;	MA	# ( 志 → 志 ) CJK COMPATIBILITY IDEOGRAPH-2F89E → CJK UNIFIED IDEOGRAPH-5FD7	# 
+
+F9A3 ;	5FF5 ;	MA	# ( 念 → 念 ) CJK COMPATIBILITY IDEOGRAPH-F9A3 → CJK UNIFIED IDEOGRAPH-5FF5	# 
+
+2F89F ;	5FF9 ;	MA	# ( 忹 → 忹 ) CJK COMPATIBILITY IDEOGRAPH-2F89F → CJK UNIFIED IDEOGRAPH-5FF9	# 
+
+F960 ;	6012 ;	MA	# ( 怒 → 怒 ) CJK COMPATIBILITY IDEOGRAPH-F960 → CJK UNIFIED IDEOGRAPH-6012	# 
+
+F9AC ;	601C ;	MA	# ( 怜 → 怜 ) CJK COMPATIBILITY IDEOGRAPH-F9AC → CJK UNIFIED IDEOGRAPH-601C	# 
+
+FA6B ;	6075 ;	MA	# ( 恵 → 恵 ) CJK COMPATIBILITY IDEOGRAPH-FA6B → CJK UNIFIED IDEOGRAPH-6075	# 
+
+2F8A2 ;	391C ;	MA	# ( 㤜 → 㤜 ) CJK COMPATIBILITY IDEOGRAPH-2F8A2 → CJK UNIFIED IDEOGRAPH-391C	# 
+
+2F8A1 ;	393A ;	MA	# ( 㤺 → 㤺 ) CJK COMPATIBILITY IDEOGRAPH-2F8A1 → CJK UNIFIED IDEOGRAPH-393A	# 
+
+2F8A0 ;	6081 ;	MA	# ( 悁 → 悁 ) CJK COMPATIBILITY IDEOGRAPH-2F8A0 → CJK UNIFIED IDEOGRAPH-6081	# 
+
+FA3D ;	6094 ;	MA	# ( 悔 → 悔 ) CJK COMPATIBILITY IDEOGRAPH-FA3D → CJK UNIFIED IDEOGRAPH-6094	# 
+2F8A3 ;	6094 ;	MA	# ( 悔 → 悔 ) CJK COMPATIBILITY IDEOGRAPH-2F8A3 → CJK UNIFIED IDEOGRAPH-6094	# 
+
+2F8A5 ;	60C7 ;	MA	# ( 惇 → 惇 ) CJK COMPATIBILITY IDEOGRAPH-2F8A5 → CJK UNIFIED IDEOGRAPH-60C7	# 
+
+FA86 ;	60D8 ;	MA	# ( 惘 → 惘 ) CJK COMPATIBILITY IDEOGRAPH-FA86 → CJK UNIFIED IDEOGRAPH-60D8	# 
+
+F9B9 ;	60E1 ;	MA	# ( 惡 → 惡 ) CJK COMPATIBILITY IDEOGRAPH-F9B9 → CJK UNIFIED IDEOGRAPH-60E1	# 
+
+2F8A4 ;	226D4 ;	MA	# ( 𢛔 → 𢛔 ) CJK COMPATIBILITY IDEOGRAPH-2F8A4 → CJK UNIFIED IDEOGRAPH-226D4	# 
+
+FA88 ;	6108 ;	MA	# ( 愈 → 愈 ) CJK COMPATIBILITY IDEOGRAPH-FA88 → CJK UNIFIED IDEOGRAPH-6108	# 
+
+FA3E ;	6168 ;	MA	# ( 慨 → 慨 ) CJK COMPATIBILITY IDEOGRAPH-FA3E → CJK UNIFIED IDEOGRAPH-6168	# 
+
+F9D9 ;	6144 ;	MA	# ( 慄 → 慄 ) CJK COMPATIBILITY IDEOGRAPH-F9D9 → CJK UNIFIED IDEOGRAPH-6144	# 
+
+2F8A6 ;	6148 ;	MA	# ( 慈 → 慈 ) CJK COMPATIBILITY IDEOGRAPH-2F8A6 → CJK UNIFIED IDEOGRAPH-6148	# 
+
+2F8A7 ;	614C ;	MA	# ( 慌 → 慌 ) CJK COMPATIBILITY IDEOGRAPH-2F8A7 → CJK UNIFIED IDEOGRAPH-614C	# 
+2F8A9 ;	614C ;	MA	# ( 慌 → 慌 ) CJK COMPATIBILITY IDEOGRAPH-2F8A9 → CJK UNIFIED IDEOGRAPH-614C	# 
+
+FA87 ;	614E ;	MA	# ( 慎 → 慎 ) CJK COMPATIBILITY IDEOGRAPH-FA87 → CJK UNIFIED IDEOGRAPH-614E	# 
+2F8A8 ;	614E ;	MA	# ( 慎 → 慎 ) CJK COMPATIBILITY IDEOGRAPH-2F8A8 → CJK UNIFIED IDEOGRAPH-614E	# 
+
+FA8A ;	6160 ;	MA	# ( 慠 → 慠 ) CJK COMPATIBILITY IDEOGRAPH-FA8A → CJK UNIFIED IDEOGRAPH-6160	# 
+
+2F8AA ;	617A ;	MA	# ( 慺 → 慺 ) CJK COMPATIBILITY IDEOGRAPH-2F8AA → CJK UNIFIED IDEOGRAPH-617A	# 
+
+FA3F ;	618E ;	MA	# ( 憎 → 憎 ) CJK COMPATIBILITY IDEOGRAPH-FA3F → CJK UNIFIED IDEOGRAPH-618E	# 
+FA89 ;	618E ;	MA	# ( 憎 → 憎 ) CJK COMPATIBILITY IDEOGRAPH-FA89 → CJK UNIFIED IDEOGRAPH-618E	# 
+2F8AB ;	618E ;	MA	# ( 憎 → 憎 ) CJK COMPATIBILITY IDEOGRAPH-2F8AB → CJK UNIFIED IDEOGRAPH-618E	# 
+
+F98F ;	6190 ;	MA	# ( 憐 → 憐 ) CJK COMPATIBILITY IDEOGRAPH-F98F → CJK UNIFIED IDEOGRAPH-6190	# 
+
+2F8AD ;	61A4 ;	MA	# ( 憤 → 憤 ) CJK COMPATIBILITY IDEOGRAPH-2F8AD → CJK UNIFIED IDEOGRAPH-61A4	# 
+
+2F8AE ;	61AF ;	MA	# ( 憯 → 憯 ) CJK COMPATIBILITY IDEOGRAPH-2F8AE → CJK UNIFIED IDEOGRAPH-61AF	# 
+
+2F8AC ;	61B2 ;	MA	# ( 憲 → 憲 ) CJK COMPATIBILITY IDEOGRAPH-2F8AC → CJK UNIFIED IDEOGRAPH-61B2	# 
+
+FAD0 ;	22844 ;	MA	# ( 𢡄 → 𢡄 ) CJK COMPATIBILITY IDEOGRAPH-FAD0 → CJK UNIFIED IDEOGRAPH-22844	# 
+
+FACF ;	2284A ;	MA	# ( 𢡊 → 𢡊 ) CJK COMPATIBILITY IDEOGRAPH-FACF → CJK UNIFIED IDEOGRAPH-2284A	# 
+
+2F8AF ;	61DE ;	MA	# ( 懞 → 懞 ) CJK COMPATIBILITY IDEOGRAPH-2F8AF → CJK UNIFIED IDEOGRAPH-61DE	# 
+
+FA40 ;	61F2 ;	MA	# ( 懲 → 懲 ) CJK COMPATIBILITY IDEOGRAPH-FA40 → CJK UNIFIED IDEOGRAPH-61F2	# 
+FA8B ;	61F2 ;	MA	# ( 懲 → 懲 ) CJK COMPATIBILITY IDEOGRAPH-FA8B → CJK UNIFIED IDEOGRAPH-61F2	# 
+2F8B0 ;	61F2 ;	MA	# ( 懲 → 懲 ) CJK COMPATIBILITY IDEOGRAPH-2F8B0 → CJK UNIFIED IDEOGRAPH-61F2	# 
+
+F90D ;	61F6 ;	MA	# ( 懶 → 懶 ) CJK COMPATIBILITY IDEOGRAPH-F90D → CJK UNIFIED IDEOGRAPH-61F6	# 
+2F8B1 ;	61F6 ;	MA	# ( 懶 → 懶 ) CJK COMPATIBILITY IDEOGRAPH-2F8B1 → CJK UNIFIED IDEOGRAPH-61F6	# 
+
+F990 ;	6200 ;	MA	# ( 戀 → 戀 ) CJK COMPATIBILITY IDEOGRAPH-F990 → CJK UNIFIED IDEOGRAPH-6200	# 
+
+2F3D ;	6208 ;	MA	#* ( ⼽ → 戈 ) KANGXI RADICAL HALBERD → CJK UNIFIED IDEOGRAPH-6208	# 
+
+2F8B2 ;	6210 ;	MA	# ( 成 → 成 ) CJK COMPATIBILITY IDEOGRAPH-2F8B2 → CJK UNIFIED IDEOGRAPH-6210	# 
+
+2F8B3 ;	621B ;	MA	# ( 戛 → 戛 ) CJK COMPATIBILITY IDEOGRAPH-2F8B3 → CJK UNIFIED IDEOGRAPH-621B	# 
+
+F9D2 ;	622E ;	MA	# ( 戮 → 戮 ) CJK COMPATIBILITY IDEOGRAPH-F9D2 → CJK UNIFIED IDEOGRAPH-622E	# 
+
+FA8C ;	6234 ;	MA	# ( 戴 → 戴 ) CJK COMPATIBILITY IDEOGRAPH-FA8C → CJK UNIFIED IDEOGRAPH-6234	# 
+
+2F3E ;	6236 ;	MA	#* ( ⼾ → 戶 ) KANGXI RADICAL DOOR → CJK UNIFIED IDEOGRAPH-6236	# 
+6238 ;	6236 ;	MA	# ( 戸 → 戶 ) CJK UNIFIED IDEOGRAPH-6238 → CJK UNIFIED IDEOGRAPH-6236	# →⼾→
+
+2F3F ;	624B ;	MA	#* ( ⼿ → 手 ) KANGXI RADICAL HAND → CJK UNIFIED IDEOGRAPH-624B	# 
+
+2E98 ;	624C ;	MA	#* ( ⺘ → 扌 ) CJK RADICAL HAND → CJK UNIFIED IDEOGRAPH-624C	# 
+
+2F8B4 ;	625D ;	MA	# ( 扝 → 扝 ) CJK COMPATIBILITY IDEOGRAPH-2F8B4 → CJK UNIFIED IDEOGRAPH-625D	# 
+
+2F8B5 ;	62B1 ;	MA	# ( 抱 → 抱 ) CJK COMPATIBILITY IDEOGRAPH-2F8B5 → CJK UNIFIED IDEOGRAPH-62B1	# 
+
+F925 ;	62C9 ;	MA	# ( 拉 → 拉 ) CJK COMPATIBILITY IDEOGRAPH-F925 → CJK UNIFIED IDEOGRAPH-62C9	# 
+
+F95B ;	62CF ;	MA	# ( 拏 → 拏 ) CJK COMPATIBILITY IDEOGRAPH-F95B → CJK UNIFIED IDEOGRAPH-62CF	# 
+
+FA02 ;	62D3 ;	MA	# ( 拓 → 拓 ) CJK COMPATIBILITY IDEOGRAPH-FA02 → CJK UNIFIED IDEOGRAPH-62D3	# 
+
+2F8B6 ;	62D4 ;	MA	# ( 拔 → 拔 ) CJK COMPATIBILITY IDEOGRAPH-2F8B6 → CJK UNIFIED IDEOGRAPH-62D4	# 
+
+2F8BA ;	62FC ;	MA	# ( 拼 → 拼 ) CJK COMPATIBILITY IDEOGRAPH-2F8BA → CJK UNIFIED IDEOGRAPH-62FC	# 
+
+F973 ;	62FE ;	MA	# ( 拾 → 拾 ) CJK COMPATIBILITY IDEOGRAPH-F973 → CJK UNIFIED IDEOGRAPH-62FE	# 
+
+2F8B8 ;	22B0C ;	MA	# ( 𢬌 → 𢬌 ) CJK COMPATIBILITY IDEOGRAPH-2F8B8 → CJK UNIFIED IDEOGRAPH-22B0C	# 
+
+2F8B9 ;	633D ;	MA	# ( 挽 → 挽 ) CJK COMPATIBILITY IDEOGRAPH-2F8B9 → CJK UNIFIED IDEOGRAPH-633D	# 
+
+2F8B7 ;	6350 ;	MA	# ( 捐 → 捐 ) CJK COMPATIBILITY IDEOGRAPH-2F8B7 → CJK UNIFIED IDEOGRAPH-6350	# 
+
+2F8BB ;	6368 ;	MA	# ( 捨 → 捨 ) CJK COMPATIBILITY IDEOGRAPH-2F8BB → CJK UNIFIED IDEOGRAPH-6368	# 
+
+F9A4 ;	637B ;	MA	# ( 捻 → 捻 ) CJK COMPATIBILITY IDEOGRAPH-F9A4 → CJK UNIFIED IDEOGRAPH-637B	# 
+
+2F8BC ;	6383 ;	MA	# ( 掃 → 掃 ) CJK COMPATIBILITY IDEOGRAPH-2F8BC → CJK UNIFIED IDEOGRAPH-6383	# 
+
+F975 ;	63A0 ;	MA	# ( 掠 → 掠 ) CJK COMPATIBILITY IDEOGRAPH-F975 → CJK UNIFIED IDEOGRAPH-63A0	# 
+
+2F8C1 ;	63A9 ;	MA	# ( 掩 → 掩 ) CJK COMPATIBILITY IDEOGRAPH-2F8C1 → CJK UNIFIED IDEOGRAPH-63A9	# 
+
+FA8D ;	63C4 ;	MA	# ( 揄 → 揄 ) CJK COMPATIBILITY IDEOGRAPH-FA8D → CJK UNIFIED IDEOGRAPH-63C4	# 
+
+2F8BD ;	63E4 ;	MA	# ( 揤 → 揤 ) CJK COMPATIBILITY IDEOGRAPH-2F8BD → CJK UNIFIED IDEOGRAPH-63E4	# 
+
+FA8E ;	641C ;	MA	# ( 搜 → 搜 ) CJK COMPATIBILITY IDEOGRAPH-FA8E → CJK UNIFIED IDEOGRAPH-641C	# 
+
+2F8BE ;	22BF1 ;	MA	# ( 𢯱 → 𢯱 ) CJK COMPATIBILITY IDEOGRAPH-2F8BE → CJK UNIFIED IDEOGRAPH-22BF1	# 
+
+2F8BF ;	6422 ;	MA	# ( 搢 → 搢 ) CJK COMPATIBILITY IDEOGRAPH-2F8BF → CJK UNIFIED IDEOGRAPH-6422	# 
+
+2F8C0 ;	63C5 ;	MA	# ( 揅 → 揅 ) CJK COMPATIBILITY IDEOGRAPH-2F8C0 → CJK UNIFIED IDEOGRAPH-63C5	# 
+
+FA8F ;	6452 ;	MA	# ( 摒 → 摒 ) CJK COMPATIBILITY IDEOGRAPH-FA8F → CJK UNIFIED IDEOGRAPH-6452	# 
+
+2F8C3 ;	6469 ;	MA	# ( 摩 → 摩 ) CJK COMPATIBILITY IDEOGRAPH-2F8C3 → CJK UNIFIED IDEOGRAPH-6469	# 
+
+2F8C6 ;	6477 ;	MA	# ( 摷 → 摷 ) CJK COMPATIBILITY IDEOGRAPH-2F8C6 → CJK UNIFIED IDEOGRAPH-6477	# 
+
+2F8C4 ;	647E ;	MA	# ( 摾 → 摾 ) CJK COMPATIBILITY IDEOGRAPH-2F8C4 → CJK UNIFIED IDEOGRAPH-647E	# 
+
+2F8C2 ;	3A2E ;	MA	# ( 㨮 → 㨮 ) CJK COMPATIBILITY IDEOGRAPH-2F8C2 → CJK UNIFIED IDEOGRAPH-3A2E	# 
+
+6409 ;	3A41 ;	MA	# ( 搉 → 㩁 ) CJK UNIFIED IDEOGRAPH-6409 → CJK UNIFIED IDEOGRAPH-3A41	# 
+
+F991 ;	649A ;	MA	# ( 撚 → 撚 ) CJK COMPATIBILITY IDEOGRAPH-F991 → CJK UNIFIED IDEOGRAPH-649A	# 
+
+2F8C5 ;	649D ;	MA	# ( 撝 → 撝 ) CJK COMPATIBILITY IDEOGRAPH-2F8C5 → CJK UNIFIED IDEOGRAPH-649D	# 
+
+F930 ;	64C4 ;	MA	# ( 擄 → 擄 ) CJK COMPATIBILITY IDEOGRAPH-F930 → CJK UNIFIED IDEOGRAPH-64C4	# 
+
+2F8C7 ;	3A6C ;	MA	# ( 㩬 → 㩬 ) CJK COMPATIBILITY IDEOGRAPH-2F8C7 → CJK UNIFIED IDEOGRAPH-3A6C	# 
+
+2F40 ;	652F ;	MA	#* ( ⽀ → 支 ) KANGXI RADICAL BRANCH → CJK UNIFIED IDEOGRAPH-652F	# 
+
+2F41 ;	6534 ;	MA	#* ( ⽁ → 攴 ) KANGXI RADICAL RAP → CJK UNIFIED IDEOGRAPH-6534	# 
+
+2E99 ;	6535 ;	MA	#* ( ⺙ → 攵 ) CJK RADICAL RAP → CJK UNIFIED IDEOGRAPH-6535	# 
+
+FA41 ;	654F ;	MA	# ( 敏 → 敏 ) CJK COMPATIBILITY IDEOGRAPH-FA41 → CJK UNIFIED IDEOGRAPH-654F	# 
+2F8C8 ;	654F ;	MA	# ( 敏 → 敏 ) CJK COMPATIBILITY IDEOGRAPH-2F8C8 → CJK UNIFIED IDEOGRAPH-654F	# 
+
+FA90 ;	6556 ;	MA	# ( 敖 → 敖 ) CJK COMPATIBILITY IDEOGRAPH-FA90 → CJK UNIFIED IDEOGRAPH-6556	# 
+
+2F8C9 ;	656C ;	MA	# ( 敬 → 敬 ) CJK COMPATIBILITY IDEOGRAPH-2F8C9 → CJK UNIFIED IDEOGRAPH-656C	# 
+
+F969 ;	6578 ;	MA	# ( 數 → 數 ) CJK COMPATIBILITY IDEOGRAPH-F969 → CJK UNIFIED IDEOGRAPH-6578	# 
+
+2F8CA ;	2300A ;	MA	# ( 𣀊 → 𣀊 ) CJK COMPATIBILITY IDEOGRAPH-2F8CA → CJK UNIFIED IDEOGRAPH-2300A	# 
+
+2F42 ;	6587 ;	MA	#* ( ⽂ → 文 ) KANGXI RADICAL SCRIPT → CJK UNIFIED IDEOGRAPH-6587	# 
+
+2EEB ;	6589 ;	MA	#* ( ⻫ → 斉 ) CJK RADICAL J-SIMPLIFIED EVEN → CJK UNIFIED IDEOGRAPH-6589	# 
+
+2F43 ;	6597 ;	MA	#* ( ⽃ → 斗 ) KANGXI RADICAL DIPPER → CJK UNIFIED IDEOGRAPH-6597	# 
+
+F9BE ;	6599 ;	MA	# ( 料 → 料 ) CJK COMPATIBILITY IDEOGRAPH-F9BE → CJK UNIFIED IDEOGRAPH-6599	# 
+
+2F44 ;	65A4 ;	MA	#* ( ⽄ → 斤 ) KANGXI RADICAL AXE → CJK UNIFIED IDEOGRAPH-65A4	# 
+
+2F45 ;	65B9 ;	MA	#* ( ⽅ → 方 ) KANGXI RADICAL SQUARE → CJK UNIFIED IDEOGRAPH-65B9	# 
+
+F983 ;	65C5 ;	MA	# ( 旅 → 旅 ) CJK COMPATIBILITY IDEOGRAPH-F983 → CJK UNIFIED IDEOGRAPH-65C5	# 
+
+2F46 ;	65E0 ;	MA	#* ( ⽆ → 无 ) KANGXI RADICAL NOT → CJK UNIFIED IDEOGRAPH-65E0	# 
+
+2E9B ;	65E1 ;	MA	#* ( ⺛ → 旡 ) CJK RADICAL CHOKE → CJK UNIFIED IDEOGRAPH-65E1	# 
+
+FA42 ;	65E2 ;	MA	# ( 既 → 既 ) CJK COMPATIBILITY IDEOGRAPH-FA42 → CJK UNIFIED IDEOGRAPH-65E2	# 
+
+2F8CB ;	65E3 ;	MA	# ( 旣 → 旣 ) CJK COMPATIBILITY IDEOGRAPH-2F8CB → CJK UNIFIED IDEOGRAPH-65E3	# 
+
+2F47 ;	65E5 ;	MA	#* ( ⽇ → 日 ) KANGXI RADICAL SUN → CJK UNIFIED IDEOGRAPH-65E5	# 
+
+F9E0 ;	6613 ;	MA	# ( 易 → 易 ) CJK COMPATIBILITY IDEOGRAPH-F9E0 → CJK UNIFIED IDEOGRAPH-6613	# 
+
+66F6 ;	3ADA ;	MA	# ( 曶 → 㫚 ) CJK UNIFIED IDEOGRAPH-66F6 → CJK UNIFIED IDEOGRAPH-3ADA	# 
+
+2F8D1 ;	3AE4 ;	MA	# ( 㫤 → 㫤 ) CJK COMPATIBILITY IDEOGRAPH-2F8D1 → CJK UNIFIED IDEOGRAPH-3AE4	# 
+
+2F8CD ;	6649 ;	MA	# ( 晉 → 晉 ) CJK COMPATIBILITY IDEOGRAPH-2F8CD → CJK UNIFIED IDEOGRAPH-6649	# 
+
+6669 ;	665A ;	MA	# ( 晩 → 晚 ) CJK UNIFIED IDEOGRAPH-6669 → CJK UNIFIED IDEOGRAPH-665A	# 
+
+FA12 ;	6674 ;	MA	# ( 晴 → 晴 ) CJK COMPATIBILITY IDEOGRAPH-FA12 → CJK UNIFIED IDEOGRAPH-6674	# 
+FA91 ;	6674 ;	MA	# ( 晴 → 晴 ) CJK COMPATIBILITY IDEOGRAPH-FA91 → CJK UNIFIED IDEOGRAPH-6674	# 
+
+FA43 ;	6691 ;	MA	# ( 暑 → 暑 ) CJK COMPATIBILITY IDEOGRAPH-FA43 → CJK UNIFIED IDEOGRAPH-6691	# 
+2F8CF ;	6691 ;	MA	# ( 暑 → 暑 ) CJK COMPATIBILITY IDEOGRAPH-2F8CF → CJK UNIFIED IDEOGRAPH-6691	# 
+
+F9C5 ;	6688 ;	MA	# ( 暈 → 暈 ) CJK COMPATIBILITY IDEOGRAPH-F9C5 → CJK UNIFIED IDEOGRAPH-6688	# 
+
+2F8D0 ;	3B08 ;	MA	# ( 㬈 → 㬈 ) CJK COMPATIBILITY IDEOGRAPH-2F8D0 → CJK UNIFIED IDEOGRAPH-3B08	# 
+
+2F8D5 ;	669C ;	MA	# ( 暜 → 暜 ) CJK COMPATIBILITY IDEOGRAPH-2F8D5 → CJK UNIFIED IDEOGRAPH-669C	# 
+
+FA06 ;	66B4 ;	MA	# ( 暴 → 暴 ) CJK COMPATIBILITY IDEOGRAPH-FA06 → CJK UNIFIED IDEOGRAPH-66B4	# 
+
+F98B ;	66C6 ;	MA	# ( 曆 → 曆 ) CJK COMPATIBILITY IDEOGRAPH-F98B → CJK UNIFIED IDEOGRAPH-66C6	# 
+
+2F8CE ;	3B19 ;	MA	# ( 㬙 → 㬙 ) CJK COMPATIBILITY IDEOGRAPH-2F8CE → CJK UNIFIED IDEOGRAPH-3B19	# 
+
+2F897 ;	232B8 ;	MA	# ( 𣊸 → 𣊸 ) CJK COMPATIBILITY IDEOGRAPH-2F897 → CJK UNIFIED IDEOGRAPH-232B8	# 
+
+2F48 ;	66F0 ;	MA	#* ( ⽈ → 曰 ) KANGXI RADICAL SAY → CJK UNIFIED IDEOGRAPH-66F0	# 
+
+F901 ;	66F4 ;	MA	# ( 更 → 更 ) CJK COMPATIBILITY IDEOGRAPH-F901 → CJK UNIFIED IDEOGRAPH-66F4	# 
+
+2F8CC ;	66F8 ;	MA	# ( 書 → 書 ) CJK COMPATIBILITY IDEOGRAPH-2F8CC → CJK UNIFIED IDEOGRAPH-66F8	# 
+
+2F49 ;	6708 ;	MA	#* ( ⽉ → 月 ) KANGXI RADICAL MOON → CJK UNIFIED IDEOGRAPH-6708	# 
+
+2F980 ;	2335F ;	MA	# ( 𣍟 → 𣍟 ) CJK COMPATIBILITY IDEOGRAPH-2F980 → CJK UNIFIED IDEOGRAPH-2335F	# 
+2B73E ;	2335F ;	MA	# ( 𫜾 → 𣍟 ) CJK UNIFIED IDEOGRAPH-2B73E → CJK UNIFIED IDEOGRAPH-2335F	# 
+
+80A6 ;	670C ;	MA	# ( 肦 → 朌 ) CJK UNIFIED IDEOGRAPH-80A6 → CJK UNIFIED IDEOGRAPH-670C	# 
+
+80D0 ;	670F ;	MA	# ( 胐 → 朏 ) CJK UNIFIED IDEOGRAPH-80D0 → CJK UNIFIED IDEOGRAPH-670F	# 
+
+80CA ;	6710 ;	MA	# ( 胊 → 朐 ) CJK UNIFIED IDEOGRAPH-80CA → CJK UNIFIED IDEOGRAPH-6710	# 
+
+8101 ;	6713 ;	MA	# ( 脁 → 朓 ) CJK UNIFIED IDEOGRAPH-8101 → CJK UNIFIED IDEOGRAPH-6713	# 
+
+80F6 ;	3B35 ;	MA	# ( 胶 → 㬵 ) CJK UNIFIED IDEOGRAPH-80F6 → CJK UNIFIED IDEOGRAPH-3B35	# 
+
+F929 ;	6717 ;	MA	# ( 朗 → 朗 ) CJK COMPATIBILITY IDEOGRAPH-F929 → CJK UNIFIED IDEOGRAPH-6717	# 
+FA92 ;	6717 ;	MA	# ( 朗 → 朗 ) CJK COMPATIBILITY IDEOGRAPH-FA92 → CJK UNIFIED IDEOGRAPH-6717	# 
+2F8D8 ;	6717 ;	MA	# ( 朗 → 朗 ) CJK COMPATIBILITY IDEOGRAPH-2F8D8 → CJK UNIFIED IDEOGRAPH-6717	# 
+
+8127 ;	6718 ;	MA	# ( 脧 → 朘 ) CJK UNIFIED IDEOGRAPH-8127 → CJK UNIFIED IDEOGRAPH-6718	# 
+
+FA93 ;	671B ;	MA	# ( 望 → 望 ) CJK COMPATIBILITY IDEOGRAPH-FA93 → CJK UNIFIED IDEOGRAPH-671B	# 
+2F8D9 ;	671B ;	MA	# ( 望 → 望 ) CJK COMPATIBILITY IDEOGRAPH-2F8D9 → CJK UNIFIED IDEOGRAPH-671B	# 
+
+5E50 ;	3B3A ;	MA	# ( 幐 → 㬺 ) CJK UNIFIED IDEOGRAPH-5E50 → CJK UNIFIED IDEOGRAPH-3B3A	# 
+
+4420 ;	3B3B ;	MA	# ( 䐠 → 㬻 ) CJK UNIFIED IDEOGRAPH-4420 → CJK UNIFIED IDEOGRAPH-3B3B	# 
+
+2F989 ;	23393 ;	MA	# ( 𣎓 → 𣎓 ) CJK COMPATIBILITY IDEOGRAPH-2F989 → CJK UNIFIED IDEOGRAPH-23393	# 
+
+81A7 ;	6723 ;	MA	# ( 膧 → 朣 ) CJK UNIFIED IDEOGRAPH-81A7 → CJK UNIFIED IDEOGRAPH-6723	# 
+
+2F98A ;	2339C ;	MA	# ( 𣎜 → 𣎜 ) CJK COMPATIBILITY IDEOGRAPH-2F98A → CJK UNIFIED IDEOGRAPH-2339C	# 
+
+2F4A ;	6728 ;	MA	#* ( ⽊ → 木 ) KANGXI RADICAL TREE → CJK UNIFIED IDEOGRAPH-6728	# 
+
+F9E1 ;	674E ;	MA	# ( 李 → 李 ) CJK COMPATIBILITY IDEOGRAPH-F9E1 → CJK UNIFIED IDEOGRAPH-674E	# 
+
+2F8DC ;	6753 ;	MA	# ( 杓 → 杓 ) CJK COMPATIBILITY IDEOGRAPH-2F8DC → CJK UNIFIED IDEOGRAPH-6753	# 
+
+FA94 ;	6756 ;	MA	# ( 杖 → 杖 ) CJK COMPATIBILITY IDEOGRAPH-FA94 → CJK UNIFIED IDEOGRAPH-6756	# 
+
+2F8DB ;	675E ;	MA	# ( 杞 → 杞 ) CJK COMPATIBILITY IDEOGRAPH-2F8DB → CJK UNIFIED IDEOGRAPH-675E	# 
+
+2F8DD ;	233C3 ;	MA	# ( 𣏃 → 𣏃 ) CJK COMPATIBILITY IDEOGRAPH-2F8DD → CJK UNIFIED IDEOGRAPH-233C3	# 
+
+67FF ;	676E ;	MA	# ( 柿 → 杮 ) CJK UNIFIED IDEOGRAPH-67FF → CJK UNIFIED IDEOGRAPH-676E	# 
+
+F9C8 ;	677B ;	MA	# ( 杻 → 杻 ) CJK COMPATIBILITY IDEOGRAPH-F9C8 → CJK UNIFIED IDEOGRAPH-677B	# 
+
+2F8E0 ;	6785 ;	MA	# ( 枅 → 枅 ) CJK COMPATIBILITY IDEOGRAPH-2F8E0 → CJK UNIFIED IDEOGRAPH-6785	# 
+
+F9F4 ;	6797 ;	MA	# ( 林 → 林 ) CJK COMPATIBILITY IDEOGRAPH-F9F4 → CJK UNIFIED IDEOGRAPH-6797	# 
+
+2F8DE ;	3B49 ;	MA	# ( 㭉 → 㭉 ) CJK COMPATIBILITY IDEOGRAPH-2F8DE → CJK UNIFIED IDEOGRAPH-3B49	# 
+
+FAD1 ;	233D5 ;	MA	# ( 𣏕 → 𣏕 ) CJK COMPATIBILITY IDEOGRAPH-FAD1 → CJK UNIFIED IDEOGRAPH-233D5	# 
+
+F9C9 ;	67F3 ;	MA	# ( 柳 → 柳 ) CJK COMPATIBILITY IDEOGRAPH-F9C9 → CJK UNIFIED IDEOGRAPH-67F3	# 
+
+2F8DF ;	67FA ;	MA	# ( 柺 → 柺 ) CJK COMPATIBILITY IDEOGRAPH-2F8DF → CJK UNIFIED IDEOGRAPH-67FA	# 
+
+F9DA ;	6817 ;	MA	# ( 栗 → 栗 ) CJK COMPATIBILITY IDEOGRAPH-F9DA → CJK UNIFIED IDEOGRAPH-6817	# 
+
+2F8E5 ;	681F ;	MA	# ( 栟 → 栟 ) CJK COMPATIBILITY IDEOGRAPH-2F8E5 → CJK UNIFIED IDEOGRAPH-681F	# 
+
+2F8E1 ;	6852 ;	MA	# ( 桒 → 桒 ) CJK COMPATIBILITY IDEOGRAPH-2F8E1 → CJK UNIFIED IDEOGRAPH-6852	# 
+
+2F8E3 ;	2346D ;	MA	# ( 𣑭 → 𣑭 ) CJK COMPATIBILITY IDEOGRAPH-2F8E3 → CJK UNIFIED IDEOGRAPH-2346D	# 
+
+F97A ;	6881 ;	MA	# ( 梁 → 梁 ) CJK COMPATIBILITY IDEOGRAPH-F97A → CJK UNIFIED IDEOGRAPH-6881	# 
+
+FA44 ;	6885 ;	MA	# ( 梅 → 梅 ) CJK COMPATIBILITY IDEOGRAPH-FA44 → CJK UNIFIED IDEOGRAPH-6885	# 
+2F8E2 ;	6885 ;	MA	# ( 梅 → 梅 ) CJK COMPATIBILITY IDEOGRAPH-2F8E2 → CJK UNIFIED IDEOGRAPH-6885	# 
+
+2F8E4 ;	688E ;	MA	# ( 梎 → 梎 ) CJK COMPATIBILITY IDEOGRAPH-2F8E4 → CJK UNIFIED IDEOGRAPH-688E	# 
+
+F9E2 ;	68A8 ;	MA	# ( 梨 → 梨 ) CJK COMPATIBILITY IDEOGRAPH-F9E2 → CJK UNIFIED IDEOGRAPH-68A8	# 
+
+2F8E6 ;	6914 ;	MA	# ( 椔 → 椔 ) CJK COMPATIBILITY IDEOGRAPH-2F8E6 → CJK UNIFIED IDEOGRAPH-6914	# 
+
+2F8E8 ;	6942 ;	MA	# ( 楂 → 楂 ) CJK COMPATIBILITY IDEOGRAPH-2F8E8 → CJK UNIFIED IDEOGRAPH-6942	# 
+
+FAD2 ;	3B9D ;	MA	# ( 㮝 → 㮝 ) CJK COMPATIBILITY IDEOGRAPH-FAD2 → CJK UNIFIED IDEOGRAPH-3B9D	# 
+2F8E7 ;	3B9D ;	MA	# ( 㮝 → 㮝 ) CJK COMPATIBILITY IDEOGRAPH-2F8E7 → CJK UNIFIED IDEOGRAPH-3B9D	# 
+
+69E9 ;	3BA3 ;	MA	# ( 槩 → 㮣 ) CJK UNIFIED IDEOGRAPH-69E9 → CJK UNIFIED IDEOGRAPH-3BA3	# 
+
+6A27 ;	699D ;	MA	# ( 樧 → 榝 ) CJK UNIFIED IDEOGRAPH-6A27 → CJK UNIFIED IDEOGRAPH-699D	# 
+
+2F8E9 ;	69A3 ;	MA	# ( 榣 → 榣 ) CJK COMPATIBILITY IDEOGRAPH-2F8E9 → CJK UNIFIED IDEOGRAPH-69A3	# 
+
+2F8EA ;	69EA ;	MA	# ( 槪 → 槪 ) CJK COMPATIBILITY IDEOGRAPH-2F8EA → CJK UNIFIED IDEOGRAPH-69EA	# 
+
+F914 ;	6A02 ;	MA	# ( 樂 → 樂 ) CJK COMPATIBILITY IDEOGRAPH-F914 → CJK UNIFIED IDEOGRAPH-6A02	# 
+F95C ;	6A02 ;	MA	# ( 樂 → 樂 ) CJK COMPATIBILITY IDEOGRAPH-F95C → CJK UNIFIED IDEOGRAPH-6A02	# 
+F9BF ;	6A02 ;	MA	# ( 樂 → 樂 ) CJK COMPATIBILITY IDEOGRAPH-F9BF → CJK UNIFIED IDEOGRAPH-6A02	# 
+
+F94C ;	6A13 ;	MA	# ( 樓 → 樓 ) CJK COMPATIBILITY IDEOGRAPH-F94C → CJK UNIFIED IDEOGRAPH-6A13	# 
+
+2F8EC ;	236A3 ;	MA	# ( 𣚣 → 𣚣 ) CJK COMPATIBILITY IDEOGRAPH-2F8EC → CJK UNIFIED IDEOGRAPH-236A3	# 
+
+2F8EB ;	6AA8 ;	MA	# ( 檨 → 檨 ) CJK COMPATIBILITY IDEOGRAPH-2F8EB → CJK UNIFIED IDEOGRAPH-6AA8	# 
+
+F931 ;	6AD3 ;	MA	# ( 櫓 → 櫓 ) CJK COMPATIBILITY IDEOGRAPH-F931 → CJK UNIFIED IDEOGRAPH-6AD3	# 
+
+2F8ED ;	6ADB ;	MA	# ( 櫛 → 櫛 ) CJK COMPATIBILITY IDEOGRAPH-2F8ED → CJK UNIFIED IDEOGRAPH-6ADB	# 
+
+F91D ;	6B04 ;	MA	# ( 欄 → 欄 ) CJK COMPATIBILITY IDEOGRAPH-F91D → CJK UNIFIED IDEOGRAPH-6B04	# 
+
+2F8EE ;	3C18 ;	MA	# ( 㰘 → 㰘 ) CJK COMPATIBILITY IDEOGRAPH-2F8EE → CJK UNIFIED IDEOGRAPH-3C18	# 
+
+2F4B ;	6B20 ;	MA	#* ( ⽋ → 欠 ) KANGXI RADICAL LACK → CJK UNIFIED IDEOGRAPH-6B20	# 
+
+2F8EF ;	6B21 ;	MA	# ( 次 → 次 ) CJK COMPATIBILITY IDEOGRAPH-2F8EF → CJK UNIFIED IDEOGRAPH-6B21	# 
+
+2F8F0 ;	238A7 ;	MA	# ( 𣢧 → 𣢧 ) CJK COMPATIBILITY IDEOGRAPH-2F8F0 → CJK UNIFIED IDEOGRAPH-238A7	# 
+
+2F8F1 ;	6B54 ;	MA	# ( 歔 → 歔 ) CJK COMPATIBILITY IDEOGRAPH-2F8F1 → CJK UNIFIED IDEOGRAPH-6B54	# 
+
+2F8F2 ;	3C4E ;	MA	# ( 㱎 → 㱎 ) CJK COMPATIBILITY IDEOGRAPH-2F8F2 → CJK UNIFIED IDEOGRAPH-3C4E	# 
+
+2F4C ;	6B62 ;	MA	#* ( ⽌ → 止 ) KANGXI RADICAL STOP → CJK UNIFIED IDEOGRAPH-6B62	# 
+
+2EED ;	6B6F ;	MA	#* ( ⻭ → 歯 ) CJK RADICAL J-SIMPLIFIED TOOTH → CJK UNIFIED IDEOGRAPH-6B6F	# 
+
+2F8F3 ;	6B72 ;	MA	# ( 歲 → 歲 ) CJK COMPATIBILITY IDEOGRAPH-2F8F3 → CJK UNIFIED IDEOGRAPH-6B72	# 
+
+F98C ;	6B77 ;	MA	# ( 歷 → 歷 ) CJK COMPATIBILITY IDEOGRAPH-F98C → CJK UNIFIED IDEOGRAPH-6B77	# 
+
+FA95 ;	6B79 ;	MA	# ( 歹 → 歹 ) CJK COMPATIBILITY IDEOGRAPH-FA95 → CJK UNIFIED IDEOGRAPH-6B79	# 
+2F4D ;	6B79 ;	MA	#* ( ⽍ → 歹 ) KANGXI RADICAL DEATH → CJK UNIFIED IDEOGRAPH-6B79	# 
+
+2E9E ;	6B7A ;	MA	#* ( ⺞ → 歺 ) CJK RADICAL DEATH → CJK UNIFIED IDEOGRAPH-6B7A	# 
+
+2F8F4 ;	6B9F ;	MA	# ( 殟 → 殟 ) CJK COMPATIBILITY IDEOGRAPH-2F8F4 → CJK UNIFIED IDEOGRAPH-6B9F	# 
+
+F9A5 ;	6BAE ;	MA	# ( 殮 → 殮 ) CJK COMPATIBILITY IDEOGRAPH-F9A5 → CJK UNIFIED IDEOGRAPH-6BAE	# 
+
+2F4E ;	6BB3 ;	MA	#* ( ⽎ → 殳 ) KANGXI RADICAL WEAPON → CJK UNIFIED IDEOGRAPH-6BB3	# 
+
+F970 ;	6BBA ;	MA	# ( 殺 → 殺 ) CJK COMPATIBILITY IDEOGRAPH-F970 → CJK UNIFIED IDEOGRAPH-6BBA	# 
+FA96 ;	6BBA ;	MA	# ( 殺 → 殺 ) CJK COMPATIBILITY IDEOGRAPH-FA96 → CJK UNIFIED IDEOGRAPH-6BBA	# 
+2F8F5 ;	6BBA ;	MA	# ( 殺 → 殺 ) CJK COMPATIBILITY IDEOGRAPH-2F8F5 → CJK UNIFIED IDEOGRAPH-6BBA	# 
+
+2F8F6 ;	6BBB ;	MA	# ( 殻 → 殻 ) CJK COMPATIBILITY IDEOGRAPH-2F8F6 → CJK UNIFIED IDEOGRAPH-6BBB	# 
+
+2F8F7 ;	23A8D ;	MA	# ( 𣪍 → 𣪍 ) CJK COMPATIBILITY IDEOGRAPH-2F8F7 → CJK UNIFIED IDEOGRAPH-23A8D	# 
+
+2F4F ;	6BCB ;	MA	#* ( ⽏ → 毋 ) KANGXI RADICAL DO NOT → CJK UNIFIED IDEOGRAPH-6BCB	# 
+
+2E9F ;	6BCD ;	MA	#* ( ⺟ → 母 ) CJK RADICAL MOTHER → CJK UNIFIED IDEOGRAPH-6BCD	# 
+
+2F8F9 ;	23AFA ;	MA	# ( 𣫺 → 𣫺 ) CJK COMPATIBILITY IDEOGRAPH-2F8F9 → CJK UNIFIED IDEOGRAPH-23AFA	# 
+
+2F50 ;	6BD4 ;	MA	#* ( ⽐ → 比 ) KANGXI RADICAL COMPARE → CJK UNIFIED IDEOGRAPH-6BD4	# 
+
+2F51 ;	6BDB ;	MA	#* ( ⽑ → 毛 ) KANGXI RADICAL FUR → CJK UNIFIED IDEOGRAPH-6BDB	# 
+
+2F52 ;	6C0F ;	MA	#* ( ⽒ → 氏 ) KANGXI RADICAL CLAN → CJK UNIFIED IDEOGRAPH-6C0F	# 
+
+2EA0 ;	6C11 ;	MA	#* ( ⺠ → 民 ) CJK RADICAL CIVILIAN → CJK UNIFIED IDEOGRAPH-6C11	# 
+
+2F53 ;	6C14 ;	MA	#* ( ⽓ → 气 ) KANGXI RADICAL STEAM → CJK UNIFIED IDEOGRAPH-6C14	# 
+
+2F54 ;	6C34 ;	MA	#* ( ⽔ → 水 ) KANGXI RADICAL WATER → CJK UNIFIED IDEOGRAPH-6C34	# 
+
+2EA1 ;	6C35 ;	MA	#* ( ⺡ → 氵 ) CJK RADICAL WATER ONE → CJK UNIFIED IDEOGRAPH-6C35	# 
+
+2EA2 ;	6C3A ;	MA	#* ( ⺢ → 氺 ) CJK RADICAL WATER TWO → CJK UNIFIED IDEOGRAPH-6C3A	# 
+
+2F8FA ;	6C4E ;	MA	# ( 汎 → 汎 ) CJK COMPATIBILITY IDEOGRAPH-2F8FA → CJK UNIFIED IDEOGRAPH-6C4E	# 
+
+2F8FE ;	6C67 ;	MA	# ( 汧 → 汧 ) CJK COMPATIBILITY IDEOGRAPH-2F8FE → CJK UNIFIED IDEOGRAPH-6C67	# 
+
+F972 ;	6C88 ;	MA	# ( 沈 → 沈 ) CJK COMPATIBILITY IDEOGRAPH-F972 → CJK UNIFIED IDEOGRAPH-6C88	# 
+
+2F8FC ;	6CBF ;	MA	# ( 沿 → 沿 ) CJK COMPATIBILITY IDEOGRAPH-2F8FC → CJK UNIFIED IDEOGRAPH-6CBF	# 
+
+F968 ;	6CCC ;	MA	# ( 泌 → 泌 ) CJK COMPATIBILITY IDEOGRAPH-F968 → CJK UNIFIED IDEOGRAPH-6CCC	# 
+
+2F8FD ;	6CCD ;	MA	# ( 泍 → 泍 ) CJK COMPATIBILITY IDEOGRAPH-2F8FD → CJK UNIFIED IDEOGRAPH-6CCD	# 
+
+F9E3 ;	6CE5 ;	MA	# ( 泥 → 泥 ) CJK COMPATIBILITY IDEOGRAPH-F9E3 → CJK UNIFIED IDEOGRAPH-6CE5	# 
+
+2F8FB ;	23CBC ;	MA	# ( 𣲼 → 𣲼 ) CJK COMPATIBILITY IDEOGRAPH-2F8FB → CJK UNIFIED IDEOGRAPH-23CBC	# 
+
+F915 ;	6D1B ;	MA	# ( 洛 → 洛 ) CJK COMPATIBILITY IDEOGRAPH-F915 → CJK UNIFIED IDEOGRAPH-6D1B	# 
+
+FA05 ;	6D1E ;	MA	# ( 洞 → 洞 ) CJK COMPATIBILITY IDEOGRAPH-FA05 → CJK UNIFIED IDEOGRAPH-6D1E	# 
+
+2F907 ;	6D34 ;	MA	# ( 洴 → 洴 ) CJK COMPATIBILITY IDEOGRAPH-2F907 → CJK UNIFIED IDEOGRAPH-6D34	# 
+
+2F900 ;	6D3E ;	MA	# ( 派 → 派 ) CJK COMPATIBILITY IDEOGRAPH-2F900 → CJK UNIFIED IDEOGRAPH-6D3E	# 
+
+F9CA ;	6D41 ;	MA	# ( 流 → 流 ) CJK COMPATIBILITY IDEOGRAPH-F9CA → CJK UNIFIED IDEOGRAPH-6D41	# 
+FA97 ;	6D41 ;	MA	# ( 流 → 流 ) CJK COMPATIBILITY IDEOGRAPH-FA97 → CJK UNIFIED IDEOGRAPH-6D41	# 
+2F902 ;	6D41 ;	MA	# ( 流 → 流 ) CJK COMPATIBILITY IDEOGRAPH-2F902 → CJK UNIFIED IDEOGRAPH-6D41	# 
+
+2F8FF ;	6D16 ;	MA	# ( 洖 → 洖 ) CJK COMPATIBILITY IDEOGRAPH-2F8FF → CJK UNIFIED IDEOGRAPH-6D16	# 
+
+2F903 ;	6D69 ;	MA	# ( 浩 → 浩 ) CJK COMPATIBILITY IDEOGRAPH-2F903 → CJK UNIFIED IDEOGRAPH-6D69	# 
+
+F92A ;	6D6A ;	MA	# ( 浪 → 浪 ) CJK COMPATIBILITY IDEOGRAPH-F92A → CJK UNIFIED IDEOGRAPH-6D6A	# 
+
+FA45 ;	6D77 ;	MA	# ( 海 → 海 ) CJK COMPATIBILITY IDEOGRAPH-FA45 → CJK UNIFIED IDEOGRAPH-6D77	# 
+2F901 ;	6D77 ;	MA	# ( 海 → 海 ) CJK COMPATIBILITY IDEOGRAPH-2F901 → CJK UNIFIED IDEOGRAPH-6D77	# 
+
+2F904 ;	6D78 ;	MA	# ( 浸 → 浸 ) CJK COMPATIBILITY IDEOGRAPH-2F904 → CJK UNIFIED IDEOGRAPH-6D78	# 
+
+2F905 ;	6D85 ;	MA	# ( 涅 → 涅 ) CJK COMPATIBILITY IDEOGRAPH-2F905 → CJK UNIFIED IDEOGRAPH-6D85	# 
+23D40 ;	6D85 ;	MA	# ( 𣵀 → 涅 ) CJK UNIFIED IDEOGRAPH-23D40 → CJK UNIFIED IDEOGRAPH-6D85	# →涅→
+
+2F906 ;	23D1E ;	MA	# ( 𣴞 → 𣴞 ) CJK COMPATIBILITY IDEOGRAPH-2F906 → CJK UNIFIED IDEOGRAPH-23D1E	# 
+
+F9F5 ;	6DCB ;	MA	# ( 淋 → 淋 ) CJK COMPATIBILITY IDEOGRAPH-F9F5 → CJK UNIFIED IDEOGRAPH-6DCB	# 
+
+F94D ;	6DDA ;	MA	# ( 淚 → 淚 ) CJK COMPATIBILITY IDEOGRAPH-F94D → CJK UNIFIED IDEOGRAPH-6DDA	# 
+
+F9D6 ;	6DEA ;	MA	# ( 淪 → 淪 ) CJK COMPATIBILITY IDEOGRAPH-F9D6 → CJK UNIFIED IDEOGRAPH-6DEA	# 
+
+2F90E ;	6DF9 ;	MA	# ( 淹 → 淹 ) CJK COMPATIBILITY IDEOGRAPH-2F90E → CJK UNIFIED IDEOGRAPH-6DF9	# 
+
+FA46 ;	6E1A ;	MA	# ( 渚 → 渚 ) CJK COMPATIBILITY IDEOGRAPH-FA46 → CJK UNIFIED IDEOGRAPH-6E1A	# 
+
+2F908 ;	6E2F ;	MA	# ( 港 → 港 ) CJK COMPATIBILITY IDEOGRAPH-2F908 → CJK UNIFIED IDEOGRAPH-6E2F	# 
+
+2F909 ;	6E6E ;	MA	# ( 湮 → 湮 ) CJK COMPATIBILITY IDEOGRAPH-2F909 → CJK UNIFIED IDEOGRAPH-6E6E	# 
+
+6F59 ;	6E88 ;	MA	# ( 潙 → 溈 ) CJK UNIFIED IDEOGRAPH-6F59 → CJK UNIFIED IDEOGRAPH-6E88	# 
+
+FA99 ;	6ECB ;	MA	# ( 滋 → 滋 ) CJK COMPATIBILITY IDEOGRAPH-FA99 → CJK UNIFIED IDEOGRAPH-6ECB	# 
+2F90B ;	6ECB ;	MA	# ( 滋 → 滋 ) CJK COMPATIBILITY IDEOGRAPH-2F90B → CJK UNIFIED IDEOGRAPH-6ECB	# 
+
+F9CB ;	6E9C ;	MA	# ( 溜 → 溜 ) CJK COMPATIBILITY IDEOGRAPH-F9CB → CJK UNIFIED IDEOGRAPH-6E9C	# 
+
+F9EC ;	6EBA ;	MA	# ( 溺 → 溺 ) CJK COMPATIBILITY IDEOGRAPH-F9EC → CJK UNIFIED IDEOGRAPH-6EBA	# 
+
+2F90C ;	6EC7 ;	MA	# ( 滇 → 滇 ) CJK COMPATIBILITY IDEOGRAPH-2F90C → CJK UNIFIED IDEOGRAPH-6EC7	# 
+
+F904 ;	6ED1 ;	MA	# ( 滑 → 滑 ) CJK COMPATIBILITY IDEOGRAPH-F904 → CJK UNIFIED IDEOGRAPH-6ED1	# 
+
+FA98 ;	6EDB ;	MA	# ( 滛 → 滛 ) CJK COMPATIBILITY IDEOGRAPH-FA98 → CJK UNIFIED IDEOGRAPH-6EDB	# 
+
+2F90A ;	3D33 ;	MA	# ( 㴳 → 㴳 ) CJK COMPATIBILITY IDEOGRAPH-2F90A → CJK UNIFIED IDEOGRAPH-3D33	# 
+
+F94E ;	6F0F ;	MA	# ( 漏 → 漏 ) CJK COMPATIBILITY IDEOGRAPH-F94E → CJK UNIFIED IDEOGRAPH-6F0F	# 
+
+FA47 ;	6F22 ;	MA	# ( 漢 → 漢 ) CJK COMPATIBILITY IDEOGRAPH-FA47 → CJK UNIFIED IDEOGRAPH-6F22	# 
+FA9A ;	6F22 ;	MA	# ( 漢 → 漢 ) CJK COMPATIBILITY IDEOGRAPH-FA9A → CJK UNIFIED IDEOGRAPH-6F22	# 
+
+F992 ;	6F23 ;	MA	# ( 漣 → 漣 ) CJK COMPATIBILITY IDEOGRAPH-F992 → CJK UNIFIED IDEOGRAPH-6F23	# 
+
+2F90D ;	23ED1 ;	MA	# ( 𣻑 → 𣻑 ) CJK COMPATIBILITY IDEOGRAPH-2F90D → CJK UNIFIED IDEOGRAPH-23ED1	# 
+
+2F90F ;	6F6E ;	MA	# ( 潮 → 潮 ) CJK COMPATIBILITY IDEOGRAPH-2F90F → CJK UNIFIED IDEOGRAPH-6F6E	# 
+
+2F910 ;	23F5E ;	MA	# ( 𣽞 → 𣽞 ) CJK COMPATIBILITY IDEOGRAPH-2F910 → CJK UNIFIED IDEOGRAPH-23F5E	# 
+
+2F911 ;	23F8E ;	MA	# ( 𣾎 → 𣾎 ) CJK COMPATIBILITY IDEOGRAPH-2F911 → CJK UNIFIED IDEOGRAPH-23F8E	# 
+
+2F912 ;	6FC6 ;	MA	# ( 濆 → 濆 ) CJK COMPATIBILITY IDEOGRAPH-2F912 → CJK UNIFIED IDEOGRAPH-6FC6	# 
+
+F922 ;	6FEB ;	MA	# ( 濫 → 濫 ) CJK COMPATIBILITY IDEOGRAPH-F922 → CJK UNIFIED IDEOGRAPH-6FEB	# 
+
+F984 ;	6FFE ;	MA	# ( 濾 → 濾 ) CJK COMPATIBILITY IDEOGRAPH-F984 → CJK UNIFIED IDEOGRAPH-6FFE	# 
+
+2F915 ;	701B ;	MA	# ( 瀛 → 瀛 ) CJK COMPATIBILITY IDEOGRAPH-2F915 → CJK UNIFIED IDEOGRAPH-701B	# 
+
+FA9B ;	701E ;	MA	# ( 瀞 → 瀞 ) CJK COMPATIBILITY IDEOGRAPH-FA9B → CJK UNIFIED IDEOGRAPH-701E	# 
+2F914 ;	701E ;	MA	# ( 瀞 → 瀞 ) CJK COMPATIBILITY IDEOGRAPH-2F914 → CJK UNIFIED IDEOGRAPH-701E	# 
+
+2F913 ;	7039 ;	MA	# ( 瀹 → 瀹 ) CJK COMPATIBILITY IDEOGRAPH-2F913 → CJK UNIFIED IDEOGRAPH-7039	# 
+
+2F917 ;	704A ;	MA	# ( 灊 → 灊 ) CJK COMPATIBILITY IDEOGRAPH-2F917 → CJK UNIFIED IDEOGRAPH-704A	# 
+
+2F916 ;	3D96 ;	MA	# ( 㶖 → 㶖 ) CJK COMPATIBILITY IDEOGRAPH-2F916 → CJK UNIFIED IDEOGRAPH-3D96	# 
+
+2F55 ;	706B ;	MA	#* ( ⽕ → 火 ) KANGXI RADICAL FIRE → CJK UNIFIED IDEOGRAPH-706B	# 
+
+2EA3 ;	706C ;	MA	#* ( ⺣ → 灬 ) CJK RADICAL FIRE → CJK UNIFIED IDEOGRAPH-706C	# 
+
+2F835 ;	7070 ;	MA	# ( 灰 → 灰 ) CJK COMPATIBILITY IDEOGRAPH-2F835 → CJK UNIFIED IDEOGRAPH-7070	# 
+
+2F919 ;	7077 ;	MA	# ( 灷 → 灷 ) CJK COMPATIBILITY IDEOGRAPH-2F919 → CJK UNIFIED IDEOGRAPH-7077	# 
+
+2F918 ;	707D ;	MA	# ( 災 → 災 ) CJK COMPATIBILITY IDEOGRAPH-2F918 → CJK UNIFIED IDEOGRAPH-707D	# 
+
+F9FB ;	7099 ;	MA	# ( 炙 → 炙 ) CJK COMPATIBILITY IDEOGRAPH-F9FB → CJK UNIFIED IDEOGRAPH-7099	# 
+
+2F91A ;	70AD ;	MA	# ( 炭 → 炭 ) CJK COMPATIBILITY IDEOGRAPH-2F91A → CJK UNIFIED IDEOGRAPH-70AD	# 
+
+F99F ;	70C8 ;	MA	# ( 烈 → 烈 ) CJK COMPATIBILITY IDEOGRAPH-F99F → CJK UNIFIED IDEOGRAPH-70C8	# 
+
+F916 ;	70D9 ;	MA	# ( 烙 → 烙 ) CJK COMPATIBILITY IDEOGRAPH-F916 → CJK UNIFIED IDEOGRAPH-70D9	# 
+
+FA48 ;	716E ;	MA	# ( 煮 → 煮 ) CJK COMPATIBILITY IDEOGRAPH-FA48 → CJK UNIFIED IDEOGRAPH-716E	# 
+FA9C ;	716E ;	MA	# ( 煮 → 煮 ) CJK COMPATIBILITY IDEOGRAPH-FA9C → CJK UNIFIED IDEOGRAPH-716E	# 
+
+2F91D ;	24263 ;	MA	# ( 𤉣 → 𤉣 ) CJK COMPATIBILITY IDEOGRAPH-2F91D → CJK UNIFIED IDEOGRAPH-24263	# 
+
+2F91C ;	7145 ;	MA	# ( 煅 → 煅 ) CJK COMPATIBILITY IDEOGRAPH-2F91C → CJK UNIFIED IDEOGRAPH-7145	# 
+
+F993 ;	7149 ;	MA	# ( 煉 → 煉 ) CJK COMPATIBILITY IDEOGRAPH-F993 → CJK UNIFIED IDEOGRAPH-7149	# 
+
+FA6C ;	242EE ;	MA	# ( 𤋮 → 𤋮 ) CJK COMPATIBILITY IDEOGRAPH-FA6C → CJK UNIFIED IDEOGRAPH-242EE	# 
+
+2F91E ;	719C ;	MA	# ( 熜 → 熜 ) CJK COMPATIBILITY IDEOGRAPH-2F91E → CJK UNIFIED IDEOGRAPH-719C	# 
+
+F9C0 ;	71CE ;	MA	# ( 燎 → 燎 ) CJK COMPATIBILITY IDEOGRAPH-F9C0 → CJK UNIFIED IDEOGRAPH-71CE	# 
+
+F9EE ;	71D0 ;	MA	# ( 燐 → 燐 ) CJK COMPATIBILITY IDEOGRAPH-F9EE → CJK UNIFIED IDEOGRAPH-71D0	# 
+
+2F91F ;	243AB ;	MA	# ( 𤎫 → 𤎫 ) CJK COMPATIBILITY IDEOGRAPH-2F91F → CJK UNIFIED IDEOGRAPH-243AB	# 
+
+F932 ;	7210 ;	MA	# ( 爐 → 爐 ) CJK COMPATIBILITY IDEOGRAPH-F932 → CJK UNIFIED IDEOGRAPH-7210	# 
+
+F91E ;	721B ;	MA	# ( 爛 → 爛 ) CJK COMPATIBILITY IDEOGRAPH-F91E → CJK UNIFIED IDEOGRAPH-721B	# 
+
+2F920 ;	7228 ;	MA	# ( 爨 → 爨 ) CJK COMPATIBILITY IDEOGRAPH-2F920 → CJK UNIFIED IDEOGRAPH-7228	# 
+
+2F56 ;	722A ;	MA	#* ( ⽖ → 爪 ) KANGXI RADICAL CLAW → CJK UNIFIED IDEOGRAPH-722A	# 
+
+FA49 ;	722B ;	MA	# ( 爫 → 爫 ) CJK COMPATIBILITY IDEOGRAPH-FA49 → CJK UNIFIED IDEOGRAPH-722B	# 
+2EA4 ;	722B ;	MA	#* ( ⺤ → 爫 ) CJK RADICAL PAW ONE → CJK UNIFIED IDEOGRAPH-722B	# 
+
+FA9E ;	7235 ;	MA	# ( 爵 → 爵 ) CJK COMPATIBILITY IDEOGRAPH-FA9E → CJK UNIFIED IDEOGRAPH-7235	# 
+2F921 ;	7235 ;	MA	# ( 爵 → 爵 ) CJK COMPATIBILITY IDEOGRAPH-2F921 → CJK UNIFIED IDEOGRAPH-7235	# 
+
+2F57 ;	7236 ;	MA	#* ( ⽗ → 父 ) KANGXI RADICAL FATHER → CJK UNIFIED IDEOGRAPH-7236	# 
+
+2F58 ;	723B ;	MA	#* ( ⽘ → 爻 ) KANGXI RADICAL DOUBLE X → CJK UNIFIED IDEOGRAPH-723B	# 
+
+2EA6 ;	4E2C ;	MA	#* ( ⺦ → 丬 ) CJK RADICAL SIMPLIFIED HALF TREE TRUNK → CJK UNIFIED IDEOGRAPH-4E2C	# 
+
+2F5A ;	7247 ;	MA	#* ( ⽚ → 片 ) KANGXI RADICAL SLICE → CJK UNIFIED IDEOGRAPH-7247	# 
+
+2F922 ;	7250 ;	MA	# ( 牐 → 牐 ) CJK COMPATIBILITY IDEOGRAPH-2F922 → CJK UNIFIED IDEOGRAPH-7250	# 
+
+2F5B ;	7259 ;	MA	#* ( ⽛ → 牙 ) KANGXI RADICAL FANG → CJK UNIFIED IDEOGRAPH-7259	# 
+
+2F923 ;	24608 ;	MA	# ( 𤘈 → 𤘈 ) CJK COMPATIBILITY IDEOGRAPH-2F923 → CJK UNIFIED IDEOGRAPH-24608	# 
+
+2F5C ;	725B ;	MA	#* ( ⽜ → 牛 ) KANGXI RADICAL COW → CJK UNIFIED IDEOGRAPH-725B	# 
+
+F946 ;	7262 ;	MA	# ( 牢 → 牢 ) CJK COMPATIBILITY IDEOGRAPH-F946 → CJK UNIFIED IDEOGRAPH-7262	# 
+
+2F924 ;	7280 ;	MA	# ( 犀 → 犀 ) CJK COMPATIBILITY IDEOGRAPH-2F924 → CJK UNIFIED IDEOGRAPH-7280	# 
+
+2F925 ;	7295 ;	MA	# ( 犕 → 犕 ) CJK COMPATIBILITY IDEOGRAPH-2F925 → CJK UNIFIED IDEOGRAPH-7295	# 
+
+2F5D ;	72AC ;	MA	#* ( ⽝ → 犬 ) KANGXI RADICAL DOG → CJK UNIFIED IDEOGRAPH-72AC	# 
+
+2EA8 ;	72AD ;	MA	#* ( ⺨ → 犭 ) CJK RADICAL DOG → CJK UNIFIED IDEOGRAPH-72AD	# 
+
+FA9F ;	72AF ;	MA	# ( 犯 → 犯 ) CJK COMPATIBILITY IDEOGRAPH-FA9F → CJK UNIFIED IDEOGRAPH-72AF	# 
+
+F9FA ;	72C0 ;	MA	# ( 狀 → 狀 ) CJK COMPATIBILITY IDEOGRAPH-F9FA → CJK UNIFIED IDEOGRAPH-72C0	# 
+
+2F926 ;	24735 ;	MA	# ( 𤜵 → 𤜵 ) CJK COMPATIBILITY IDEOGRAPH-2F926 → CJK UNIFIED IDEOGRAPH-24735	# 
+
+F92B ;	72FC ;	MA	# ( 狼 → 狼 ) CJK COMPATIBILITY IDEOGRAPH-F92B → CJK UNIFIED IDEOGRAPH-72FC	# 
+
+FA16 ;	732A ;	MA	# ( 猪 → 猪 ) CJK COMPATIBILITY IDEOGRAPH-FA16 → CJK UNIFIED IDEOGRAPH-732A	# 
+FAA0 ;	732A ;	MA	# ( 猪 → 猪 ) CJK COMPATIBILITY IDEOGRAPH-FAA0 → CJK UNIFIED IDEOGRAPH-732A	# 
+
+2AEC5 ;	24814 ;	MA	# ( 𪻅 → 𤠔 ) CJK UNIFIED IDEOGRAPH-2AEC5 → CJK UNIFIED IDEOGRAPH-24814	# →𤠔→
+2F927 ;	24814 ;	MA	# ( 𤠔 → 𤠔 ) CJK COMPATIBILITY IDEOGRAPH-2F927 → CJK UNIFIED IDEOGRAPH-24814	# 
+
+F9A7 ;	7375 ;	MA	# ( 獵 → 獵 ) CJK COMPATIBILITY IDEOGRAPH-F9A7 → CJK UNIFIED IDEOGRAPH-7375	# 
+
+2F928 ;	737A ;	MA	# ( 獺 → 獺 ) CJK COMPATIBILITY IDEOGRAPH-2F928 → CJK UNIFIED IDEOGRAPH-737A	# 
+
+2F5E ;	7384 ;	MA	#* ( ⽞ → 玄 ) KANGXI RADICAL PROFOUND → CJK UNIFIED IDEOGRAPH-7384	# 
+
+F961 ;	7387 ;	MA	# ( 率 → 率 ) CJK COMPATIBILITY IDEOGRAPH-F961 → CJK UNIFIED IDEOGRAPH-7387	# 
+F9DB ;	7387 ;	MA	# ( 率 → 率 ) CJK COMPATIBILITY IDEOGRAPH-F9DB → CJK UNIFIED IDEOGRAPH-7387	# 
+
+2F5F ;	7389 ;	MA	#* ( ⽟ → 玉 ) KANGXI RADICAL JADE → CJK UNIFIED IDEOGRAPH-7389	# 
+
+2F929 ;	738B ;	MA	# ( 王 → 王 ) CJK COMPATIBILITY IDEOGRAPH-2F929 → CJK UNIFIED IDEOGRAPH-738B	# 
+
+2F92A ;	3EAC ;	MA	# ( 㺬 → 㺬 ) CJK COMPATIBILITY IDEOGRAPH-2F92A → CJK UNIFIED IDEOGRAPH-3EAC	# 
+
+2F92B ;	73A5 ;	MA	# ( 玥 → 玥 ) CJK COMPATIBILITY IDEOGRAPH-2F92B → CJK UNIFIED IDEOGRAPH-73A5	# 
+248FD ;	73A5 ;	MA	# ( 𤣽 → 玥 ) CJK UNIFIED IDEOGRAPH-248FD → CJK UNIFIED IDEOGRAPH-73A5	# →玥→
+
+F9AD ;	73B2 ;	MA	# ( 玲 → 玲 ) CJK COMPATIBILITY IDEOGRAPH-F9AD → CJK UNIFIED IDEOGRAPH-73B2	# 
+
+2F92C ;	3EB8 ;	MA	# ( 㺸 → 㺸 ) CJK COMPATIBILITY IDEOGRAPH-2F92C → CJK UNIFIED IDEOGRAPH-3EB8	# 
+2F92D ;	3EB8 ;	MA	# ( 㺸 → 㺸 ) CJK COMPATIBILITY IDEOGRAPH-2F92D → CJK UNIFIED IDEOGRAPH-3EB8	# 
+
+F917 ;	73DE ;	MA	# ( 珞 → 珞 ) CJK COMPATIBILITY IDEOGRAPH-F917 → CJK UNIFIED IDEOGRAPH-73DE	# 
+
+F9CC ;	7409 ;	MA	# ( 琉 → 琉 ) CJK COMPATIBILITY IDEOGRAPH-F9CC → CJK UNIFIED IDEOGRAPH-7409	# 
+
+F9E4 ;	7406 ;	MA	# ( 理 → 理 ) CJK COMPATIBILITY IDEOGRAPH-F9E4 → CJK UNIFIED IDEOGRAPH-7406	# 
+
+FA4A ;	7422 ;	MA	# ( 琢 → 琢 ) CJK COMPATIBILITY IDEOGRAPH-FA4A → CJK UNIFIED IDEOGRAPH-7422	# 
+
+2F92E ;	7447 ;	MA	# ( 瑇 → 瑇 ) CJK COMPATIBILITY IDEOGRAPH-2F92E → CJK UNIFIED IDEOGRAPH-7447	# 
+
+2F92F ;	745C ;	MA	# ( 瑜 → 瑜 ) CJK COMPATIBILITY IDEOGRAPH-2F92F → CJK UNIFIED IDEOGRAPH-745C	# 
+
+F9AE ;	7469 ;	MA	# ( 瑩 → 瑩 ) CJK COMPATIBILITY IDEOGRAPH-F9AE → CJK UNIFIED IDEOGRAPH-7469	# 
+
+FAA1 ;	7471 ;	MA	# ( 瑱 → 瑱 ) CJK COMPATIBILITY IDEOGRAPH-FAA1 → CJK UNIFIED IDEOGRAPH-7471	# 
+2F930 ;	7471 ;	MA	# ( 瑱 → 瑱 ) CJK COMPATIBILITY IDEOGRAPH-2F930 → CJK UNIFIED IDEOGRAPH-7471	# 
+
+2F931 ;	7485 ;	MA	# ( 璅 → 璅 ) CJK COMPATIBILITY IDEOGRAPH-2F931 → CJK UNIFIED IDEOGRAPH-7485	# 
+
+F994 ;	7489 ;	MA	# ( 璉 → 璉 ) CJK COMPATIBILITY IDEOGRAPH-F994 → CJK UNIFIED IDEOGRAPH-7489	# 
+
+F9EF ;	7498 ;	MA	# ( 璘 → 璘 ) CJK COMPATIBILITY IDEOGRAPH-F9EF → CJK UNIFIED IDEOGRAPH-7498	# 
+
+2F932 ;	74CA ;	MA	# ( 瓊 → 瓊 ) CJK COMPATIBILITY IDEOGRAPH-2F932 → CJK UNIFIED IDEOGRAPH-74CA	# 
+
+2F60 ;	74DC ;	MA	#* ( ⽠ → 瓜 ) KANGXI RADICAL MELON → CJK UNIFIED IDEOGRAPH-74DC	# 
+
+2F61 ;	74E6 ;	MA	#* ( ⽡ → 瓦 ) KANGXI RADICAL TILE → CJK UNIFIED IDEOGRAPH-74E6	# 
+
+2F933 ;	3F1B ;	MA	# ( 㼛 → 㼛 ) CJK COMPATIBILITY IDEOGRAPH-2F933 → CJK UNIFIED IDEOGRAPH-3F1B	# 
+
+FAA2 ;	7506 ;	MA	# ( 甆 → 甆 ) CJK COMPATIBILITY IDEOGRAPH-FAA2 → CJK UNIFIED IDEOGRAPH-7506	# 
+
+2F62 ;	7518 ;	MA	#* ( ⽢ → 甘 ) KANGXI RADICAL SWEET → CJK UNIFIED IDEOGRAPH-7518	# 
+
+2F63 ;	751F ;	MA	#* ( ⽣ → 生 ) KANGXI RADICAL LIFE → CJK UNIFIED IDEOGRAPH-751F	# 
+
+2F934 ;	7524 ;	MA	# ( 甤 → 甤 ) CJK COMPATIBILITY IDEOGRAPH-2F934 → CJK UNIFIED IDEOGRAPH-7524	# 
+
+2F64 ;	7528 ;	MA	#* ( ⽤ → 用 ) KANGXI RADICAL USE → CJK UNIFIED IDEOGRAPH-7528	# 
+
+2F65 ;	7530 ;	MA	#* ( ⽥ → 田 ) KANGXI RADICAL FIELD → CJK UNIFIED IDEOGRAPH-7530	# 
+
+FAA3 ;	753B ;	MA	# ( 画 → 画 ) CJK COMPATIBILITY IDEOGRAPH-FAA3 → CJK UNIFIED IDEOGRAPH-753B	# 
+
+2F936 ;	753E ;	MA	# ( 甾 → 甾 ) CJK COMPATIBILITY IDEOGRAPH-2F936 → CJK UNIFIED IDEOGRAPH-753E	# 
+
+2F935 ;	24C36 ;	MA	# ( 𤰶 → 𤰶 ) CJK COMPATIBILITY IDEOGRAPH-2F935 → CJK UNIFIED IDEOGRAPH-24C36	# 
+
+F9CD ;	7559 ;	MA	# ( 留 → 留 ) CJK COMPATIBILITY IDEOGRAPH-F9CD → CJK UNIFIED IDEOGRAPH-7559	# 
+
+F976 ;	7565 ;	MA	# ( 略 → 略 ) CJK COMPATIBILITY IDEOGRAPH-F976 → CJK UNIFIED IDEOGRAPH-7565	# 
+
+F962 ;	7570 ;	MA	# ( 異 → 異 ) CJK COMPATIBILITY IDEOGRAPH-F962 → CJK UNIFIED IDEOGRAPH-7570	# 
+2F938 ;	7570 ;	MA	# ( 異 → 異 ) CJK COMPATIBILITY IDEOGRAPH-2F938 → CJK UNIFIED IDEOGRAPH-7570	# 
+
+2F937 ;	24C92 ;	MA	# ( 𤲒 → 𤲒 ) CJK COMPATIBILITY IDEOGRAPH-2F937 → CJK UNIFIED IDEOGRAPH-24C92	# 
+
+2F66 ;	758B ;	MA	#* ( ⽦ → 疋 ) KANGXI RADICAL BOLT OF CLOTH → CJK UNIFIED IDEOGRAPH-758B	# 
+
+2F67 ;	7592 ;	MA	#* ( ⽧ → 疒 ) KANGXI RADICAL SICKNESS → CJK UNIFIED IDEOGRAPH-7592	# 
+
+F9E5 ;	75E2 ;	MA	# ( 痢 → 痢 ) CJK COMPATIBILITY IDEOGRAPH-F9E5 → CJK UNIFIED IDEOGRAPH-75E2	# 
+
+2F93A ;	7610 ;	MA	# ( 瘐 → 瘐 ) CJK COMPATIBILITY IDEOGRAPH-2F93A → CJK UNIFIED IDEOGRAPH-7610	# 
+
+FAA5 ;	761F ;	MA	# ( 瘟 → 瘟 ) CJK COMPATIBILITY IDEOGRAPH-FAA5 → CJK UNIFIED IDEOGRAPH-761F	# 
+
+FAA4 ;	761D ;	MA	# ( 瘝 → 瘝 ) CJK COMPATIBILITY IDEOGRAPH-FAA4 → CJK UNIFIED IDEOGRAPH-761D	# 
+
+F9C1 ;	7642 ;	MA	# ( 療 → 療 ) CJK COMPATIBILITY IDEOGRAPH-F9C1 → CJK UNIFIED IDEOGRAPH-7642	# 
+
+F90E ;	7669 ;	MA	# ( 癩 → 癩 ) CJK COMPATIBILITY IDEOGRAPH-F90E → CJK UNIFIED IDEOGRAPH-7669	# 
+
+2F68 ;	7676 ;	MA	#* ( ⽨ → 癶 ) KANGXI RADICAL DOTTED TENT → CJK UNIFIED IDEOGRAPH-7676	# 
+
+2F69 ;	767D ;	MA	#* ( ⽩ → 白 ) KANGXI RADICAL WHITE → CJK UNIFIED IDEOGRAPH-767D	# 
+
+2F93B ;	24FA1 ;	MA	# ( 𤾡 → 𤾡 ) CJK COMPATIBILITY IDEOGRAPH-2F93B → CJK UNIFIED IDEOGRAPH-24FA1	# 
+
+2F93C ;	24FB8 ;	MA	# ( 𤾸 → 𤾸 ) CJK COMPATIBILITY IDEOGRAPH-2F93C → CJK UNIFIED IDEOGRAPH-24FB8	# 
+
+2F6A ;	76AE ;	MA	#* ( ⽪ → 皮 ) KANGXI RADICAL SKIN → CJK UNIFIED IDEOGRAPH-76AE	# 
+
+2F6B ;	76BF ;	MA	#* ( ⽫ → 皿 ) KANGXI RADICAL DISH → CJK UNIFIED IDEOGRAPH-76BF	# 
+
+2F93D ;	25044 ;	MA	# ( 𥁄 → 𥁄 ) CJK COMPATIBILITY IDEOGRAPH-2F93D → CJK UNIFIED IDEOGRAPH-25044	# 
+
+2F93E ;	3FFC ;	MA	# ( 㿼 → 㿼 ) CJK COMPATIBILITY IDEOGRAPH-2F93E → CJK UNIFIED IDEOGRAPH-3FFC	# 
+
+FA17 ;	76CA ;	MA	# ( 益 → 益 ) CJK COMPATIBILITY IDEOGRAPH-FA17 → CJK UNIFIED IDEOGRAPH-76CA	# 
+FAA6 ;	76CA ;	MA	# ( 益 → 益 ) CJK COMPATIBILITY IDEOGRAPH-FAA6 → CJK UNIFIED IDEOGRAPH-76CA	# 
+
+FAA7 ;	76DB ;	MA	# ( 盛 → 盛 ) CJK COMPATIBILITY IDEOGRAPH-FAA7 → CJK UNIFIED IDEOGRAPH-76DB	# 
+
+F933 ;	76E7 ;	MA	# ( 盧 → 盧 ) CJK COMPATIBILITY IDEOGRAPH-F933 → CJK UNIFIED IDEOGRAPH-76E7	# 
+
+2F93F ;	4008 ;	MA	# ( 䀈 → 䀈 ) CJK COMPATIBILITY IDEOGRAPH-2F93F → CJK UNIFIED IDEOGRAPH-4008	# 
+
+2F6C ;	76EE ;	MA	#* ( ⽬ → 目 ) KANGXI RADICAL EYE → CJK UNIFIED IDEOGRAPH-76EE	# 
+
+FAA8 ;	76F4 ;	MA	# ( 直 → 直 ) CJK COMPATIBILITY IDEOGRAPH-FAA8 → CJK UNIFIED IDEOGRAPH-76F4	# 
+2F940 ;	76F4 ;	MA	# ( 直 → 直 ) CJK COMPATIBILITY IDEOGRAPH-2F940 → CJK UNIFIED IDEOGRAPH-76F4	# 
+
+2F942 ;	250F2 ;	MA	# ( 𥃲 → 𥃲 ) CJK COMPATIBILITY IDEOGRAPH-2F942 → CJK UNIFIED IDEOGRAPH-250F2	# 
+
+2F941 ;	250F3 ;	MA	# ( 𥃳 → 𥃳 ) CJK COMPATIBILITY IDEOGRAPH-2F941 → CJK UNIFIED IDEOGRAPH-250F3	# 
+
+F96D ;	7701 ;	MA	# ( 省 → 省 ) CJK COMPATIBILITY IDEOGRAPH-F96D → CJK UNIFIED IDEOGRAPH-7701	# 
+
+FAD3 ;	4018 ;	MA	# ( 䀘 → 䀘 ) CJK COMPATIBILITY IDEOGRAPH-FAD3 → CJK UNIFIED IDEOGRAPH-4018	# 
+
+2F943 ;	25119 ;	MA	# ( 𥄙 → 𥄙 ) CJK COMPATIBILITY IDEOGRAPH-2F943 → CJK UNIFIED IDEOGRAPH-25119	# 
+2511A ;	25119 ;	MA	# ( 𥄚 → 𥄙 ) CJK UNIFIED IDEOGRAPH-2511A → CJK UNIFIED IDEOGRAPH-25119	# →𥄙→
+
+2F945 ;	771E ;	MA	# ( 眞 → 眞 ) CJK COMPATIBILITY IDEOGRAPH-2F945 → CJK UNIFIED IDEOGRAPH-771E	# 
+
+2F946 ;	771F ;	MA	# ( 真 → 真 ) CJK COMPATIBILITY IDEOGRAPH-2F946 → CJK UNIFIED IDEOGRAPH-771F	# 
+2F947 ;	771F ;	MA	# ( 真 → 真 ) CJK COMPATIBILITY IDEOGRAPH-2F947 → CJK UNIFIED IDEOGRAPH-771F	# 
+
+2F944 ;	25133 ;	MA	# ( 𥄳 → 𥄳 ) CJK COMPATIBILITY IDEOGRAPH-2F944 → CJK UNIFIED IDEOGRAPH-25133	# 
+
+FAAA ;	7740 ;	MA	# ( 着 → 着 ) CJK COMPATIBILITY IDEOGRAPH-FAAA → CJK UNIFIED IDEOGRAPH-7740	# 
+
+FAA9 ;	774A ;	MA	# ( 睊 → 睊 ) CJK COMPATIBILITY IDEOGRAPH-FAA9 → CJK UNIFIED IDEOGRAPH-774A	# 
+2F948 ;	774A ;	MA	# ( 睊 → 睊 ) CJK COMPATIBILITY IDEOGRAPH-2F948 → CJK UNIFIED IDEOGRAPH-774A	# 
+
+9FC3 ;	4039 ;	MA	# ( 鿃 → 䀹 ) CJK UNIFIED IDEOGRAPH-9FC3 → CJK UNIFIED IDEOGRAPH-4039	# →䀹→
+FAD4 ;	4039 ;	MA	# ( 䀹 → 䀹 ) CJK COMPATIBILITY IDEOGRAPH-FAD4 → CJK UNIFIED IDEOGRAPH-4039	# 
+2F949 ;	4039 ;	MA	# ( 䀹 → 䀹 ) CJK COMPATIBILITY IDEOGRAPH-2F949 → CJK UNIFIED IDEOGRAPH-4039	# 
+
+6663 ;	403F ;	MA	# ( 晣 → 䀿 ) CJK UNIFIED IDEOGRAPH-6663 → CJK UNIFIED IDEOGRAPH-403F	# 
+
+2F94B ;	4046 ;	MA	# ( 䁆 → 䁆 ) CJK COMPATIBILITY IDEOGRAPH-2F94B → CJK UNIFIED IDEOGRAPH-4046	# 
+
+2F94A ;	778B ;	MA	# ( 瞋 → 瞋 ) CJK COMPATIBILITY IDEOGRAPH-2F94A → CJK UNIFIED IDEOGRAPH-778B	# 
+
+FAD5 ;	25249 ;	MA	# ( 𥉉 → 𥉉 ) CJK COMPATIBILITY IDEOGRAPH-FAD5 → CJK UNIFIED IDEOGRAPH-25249	# 
+
+FA9D ;	77A7 ;	MA	# ( 瞧 → 瞧 ) CJK COMPATIBILITY IDEOGRAPH-FA9D → CJK UNIFIED IDEOGRAPH-77A7	# 
+
+2F6D ;	77DB ;	MA	#* ( ⽭ → 矛 ) KANGXI RADICAL SPEAR → CJK UNIFIED IDEOGRAPH-77DB	# 
+
+2F6E ;	77E2 ;	MA	#* ( ⽮ → 矢 ) KANGXI RADICAL ARROW → CJK UNIFIED IDEOGRAPH-77E2	# 
+
+2F6F ;	77F3 ;	MA	#* ( ⽯ → 石 ) KANGXI RADICAL STONE → CJK UNIFIED IDEOGRAPH-77F3	# 
+
+2F94C ;	4096 ;	MA	# ( 䂖 → 䂖 ) CJK COMPATIBILITY IDEOGRAPH-2F94C → CJK UNIFIED IDEOGRAPH-4096	# 
+
+2F94D ;	2541D ;	MA	# ( 𥐝 → 𥐝 ) CJK COMPATIBILITY IDEOGRAPH-2F94D → CJK UNIFIED IDEOGRAPH-2541D	# 
+
+784F ;	7814 ;	MA	# ( 硏 → 研 ) CJK UNIFIED IDEOGRAPH-784F → CJK UNIFIED IDEOGRAPH-7814	# 
+
+2F94E ;	784E ;	MA	# ( 硎 → 硎 ) CJK COMPATIBILITY IDEOGRAPH-2F94E → CJK UNIFIED IDEOGRAPH-784E	# 
+
+F9CE ;	786B ;	MA	# ( 硫 → 硫 ) CJK COMPATIBILITY IDEOGRAPH-F9CE → CJK UNIFIED IDEOGRAPH-786B	# 
+
+F93B ;	788C ;	MA	# ( 碌 → 碌 ) CJK COMPATIBILITY IDEOGRAPH-F93B → CJK UNIFIED IDEOGRAPH-788C	# 
+2F94F ;	788C ;	MA	# ( 碌 → 碌 ) CJK COMPATIBILITY IDEOGRAPH-2F94F → CJK UNIFIED IDEOGRAPH-788C	# 
+
+FA4B ;	7891 ;	MA	# ( 碑 → 碑 ) CJK COMPATIBILITY IDEOGRAPH-FA4B → CJK UNIFIED IDEOGRAPH-7891	# 
+
+F947 ;	78CA ;	MA	# ( 磊 → 磊 ) CJK COMPATIBILITY IDEOGRAPH-F947 → CJK UNIFIED IDEOGRAPH-78CA	# 
+
+FAAB ;	78CC ;	MA	# ( 磌 → 磌 ) CJK COMPATIBILITY IDEOGRAPH-FAAB → CJK UNIFIED IDEOGRAPH-78CC	# 
+2F950 ;	78CC ;	MA	# ( 磌 → 磌 ) CJK COMPATIBILITY IDEOGRAPH-2F950 → CJK UNIFIED IDEOGRAPH-78CC	# 
+
+F964 ;	78FB ;	MA	# ( 磻 → 磻 ) CJK COMPATIBILITY IDEOGRAPH-F964 → CJK UNIFIED IDEOGRAPH-78FB	# 
+
+2F951 ;	40E3 ;	MA	# ( 䃣 → 䃣 ) CJK COMPATIBILITY IDEOGRAPH-2F951 → CJK UNIFIED IDEOGRAPH-40E3	# 
+
+F985 ;	792A ;	MA	# ( 礪 → 礪 ) CJK COMPATIBILITY IDEOGRAPH-F985 → CJK UNIFIED IDEOGRAPH-792A	# 
+
+2F70 ;	793A ;	MA	#* ( ⽰ → 示 ) KANGXI RADICAL SPIRIT → CJK UNIFIED IDEOGRAPH-793A	# 
+
+2EAD ;	793B ;	MA	#* ( ⺭ → 礻 ) CJK RADICAL SPIRIT TWO → CJK UNIFIED IDEOGRAPH-793B	# 
+
+FA18 ;	793C ;	MA	# ( 礼 → 礼 ) CJK COMPATIBILITY IDEOGRAPH-FA18 → CJK UNIFIED IDEOGRAPH-793C	# 
+
+FA4C ;	793E ;	MA	# ( 社 → 社 ) CJK COMPATIBILITY IDEOGRAPH-FA4C → CJK UNIFIED IDEOGRAPH-793E	# 
+
+FA4E ;	7948 ;	MA	# ( 祈 → 祈 ) CJK COMPATIBILITY IDEOGRAPH-FA4E → CJK UNIFIED IDEOGRAPH-7948	# 
+
+FA4D ;	7949 ;	MA	# ( 祉 → 祉 ) CJK COMPATIBILITY IDEOGRAPH-FA4D → CJK UNIFIED IDEOGRAPH-7949	# 
+
+2F952 ;	25626 ;	MA	# ( 𥘦 → 𥘦 ) CJK COMPATIBILITY IDEOGRAPH-2F952 → CJK UNIFIED IDEOGRAPH-25626	# 
+
+FA4F ;	7950 ;	MA	# ( 祐 → 祐 ) CJK COMPATIBILITY IDEOGRAPH-FA4F → CJK UNIFIED IDEOGRAPH-7950	# 
+
+FA50 ;	7956 ;	MA	# ( 祖 → 祖 ) CJK COMPATIBILITY IDEOGRAPH-FA50 → CJK UNIFIED IDEOGRAPH-7956	# 
+2F953 ;	7956 ;	MA	# ( 祖 → 祖 ) CJK COMPATIBILITY IDEOGRAPH-2F953 → CJK UNIFIED IDEOGRAPH-7956	# 
+
+FA51 ;	795D ;	MA	# ( 祝 → 祝 ) CJK COMPATIBILITY IDEOGRAPH-FA51 → CJK UNIFIED IDEOGRAPH-795D	# 
+
+FA19 ;	795E ;	MA	# ( 神 → 神 ) CJK COMPATIBILITY IDEOGRAPH-FA19 → CJK UNIFIED IDEOGRAPH-795E	# 
+
+FA1A ;	7965 ;	MA	# ( 祥 → 祥 ) CJK COMPATIBILITY IDEOGRAPH-FA1A → CJK UNIFIED IDEOGRAPH-7965	# 
+
+FA61 ;	8996 ;	MA	# ( 視 → 視 ) CJK COMPATIBILITY IDEOGRAPH-FA61 → CJK UNIFIED IDEOGRAPH-8996	# 
+FAB8 ;	8996 ;	MA	# ( 視 → 視 ) CJK COMPATIBILITY IDEOGRAPH-FAB8 → CJK UNIFIED IDEOGRAPH-8996	# 
+
+F93C ;	797F ;	MA	# ( 祿 → 祿 ) CJK COMPATIBILITY IDEOGRAPH-F93C → CJK UNIFIED IDEOGRAPH-797F	# 
+
+2F954 ;	2569A ;	MA	# ( 𥚚 → 𥚚 ) CJK COMPATIBILITY IDEOGRAPH-2F954 → CJK UNIFIED IDEOGRAPH-2569A	# 
+
+FA52 ;	798D ;	MA	# ( 禍 → 禍 ) CJK COMPATIBILITY IDEOGRAPH-FA52 → CJK UNIFIED IDEOGRAPH-798D	# 
+
+FA53 ;	798E ;	MA	# ( 禎 → 禎 ) CJK COMPATIBILITY IDEOGRAPH-FA53 → CJK UNIFIED IDEOGRAPH-798E	# 
+
+FA1B ;	798F ;	MA	# ( 福 → 福 ) CJK COMPATIBILITY IDEOGRAPH-FA1B → CJK UNIFIED IDEOGRAPH-798F	# 
+2F956 ;	798F ;	MA	# ( 福 → 福 ) CJK COMPATIBILITY IDEOGRAPH-2F956 → CJK UNIFIED IDEOGRAPH-798F	# 
+
+2F955 ;	256C5 ;	MA	# ( 𥛅 → 𥛅 ) CJK COMPATIBILITY IDEOGRAPH-2F955 → CJK UNIFIED IDEOGRAPH-256C5	# 
+
+F9B6 ;	79AE ;	MA	# ( 禮 → 禮 ) CJK COMPATIBILITY IDEOGRAPH-F9B6 → CJK UNIFIED IDEOGRAPH-79AE	# 
+
+2F71 ;	79B8 ;	MA	#* ( ⽱ → 禸 ) KANGXI RADICAL TRACK → CJK UNIFIED IDEOGRAPH-79B8	# 
+
+2F72 ;	79BE ;	MA	#* ( ⽲ → 禾 ) KANGXI RADICAL GRAIN → CJK UNIFIED IDEOGRAPH-79BE	# 
+
+F995 ;	79CA ;	MA	# ( 秊 → 秊 ) CJK COMPATIBILITY IDEOGRAPH-F995 → CJK UNIFIED IDEOGRAPH-79CA	# 
+
+2F958 ;	412F ;	MA	# ( 䄯 → 䄯 ) CJK COMPATIBILITY IDEOGRAPH-2F958 → CJK UNIFIED IDEOGRAPH-412F	# 
+
+2F957 ;	79EB ;	MA	# ( 秫 → 秫 ) CJK COMPATIBILITY IDEOGRAPH-2F957 → CJK UNIFIED IDEOGRAPH-79EB	# 
+
+F956 ;	7A1C ;	MA	# ( 稜 → 稜 ) CJK COMPATIBILITY IDEOGRAPH-F956 → CJK UNIFIED IDEOGRAPH-7A1C	# 
+
+2F95A ;	7A4A ;	MA	# ( 穊 → 穊 ) CJK COMPATIBILITY IDEOGRAPH-2F95A → CJK UNIFIED IDEOGRAPH-7A4A	# 
+
+FA54 ;	7A40 ;	MA	# ( 穀 → 穀 ) CJK COMPATIBILITY IDEOGRAPH-FA54 → CJK UNIFIED IDEOGRAPH-7A40	# 
+2F959 ;	7A40 ;	MA	# ( 穀 → 穀 ) CJK COMPATIBILITY IDEOGRAPH-2F959 → CJK UNIFIED IDEOGRAPH-7A40	# 
+
+2F95B ;	7A4F ;	MA	# ( 穏 → 穏 ) CJK COMPATIBILITY IDEOGRAPH-2F95B → CJK UNIFIED IDEOGRAPH-7A4F	# 
+
+2F73 ;	7A74 ;	MA	#* ( ⽳ → 穴 ) KANGXI RADICAL CAVE → CJK UNIFIED IDEOGRAPH-7A74	# 
+
+FA55 ;	7A81 ;	MA	# ( 突 → 突 ) CJK COMPATIBILITY IDEOGRAPH-FA55 → CJK UNIFIED IDEOGRAPH-7A81	# 
+
+2F95C ;	2597C ;	MA	# ( 𥥼 → 𥥼 ) CJK COMPATIBILITY IDEOGRAPH-2F95C → CJK UNIFIED IDEOGRAPH-2597C	# 
+
+FAAC ;	7AB1 ;	MA	# ( 窱 → 窱 ) CJK COMPATIBILITY IDEOGRAPH-FAAC → CJK UNIFIED IDEOGRAPH-7AB1	# 
+
+F9F7 ;	7ACB ;	MA	# ( 立 → 立 ) CJK COMPATIBILITY IDEOGRAPH-F9F7 → CJK UNIFIED IDEOGRAPH-7ACB	# 
+2F74 ;	7ACB ;	MA	#* ( ⽴ → 立 ) KANGXI RADICAL STAND → CJK UNIFIED IDEOGRAPH-7ACB	# 
+
+2EEF ;	7ADC ;	MA	#* ( ⻯ → 竜 ) CJK RADICAL J-SIMPLIFIED DRAGON → CJK UNIFIED IDEOGRAPH-7ADC	# 
+
+2F95D ;	25AA7 ;	MA	# ( 𥪧 → 𥪧 ) CJK COMPATIBILITY IDEOGRAPH-2F95D → CJK UNIFIED IDEOGRAPH-25AA7	# 
+2F95E ;	25AA7 ;	MA	# ( 𥪧 → 𥪧 ) CJK COMPATIBILITY IDEOGRAPH-2F95E → CJK UNIFIED IDEOGRAPH-25AA7	# 
+
+2F95F ;	7AEE ;	MA	# ( 竮 → 竮 ) CJK COMPATIBILITY IDEOGRAPH-2F95F → CJK UNIFIED IDEOGRAPH-7AEE	# 
+
+2F75 ;	7AF9 ;	MA	#* ( ⽵ → 竹 ) KANGXI RADICAL BAMBOO → CJK UNIFIED IDEOGRAPH-7AF9	# 
+
+F9F8 ;	7B20 ;	MA	# ( 笠 → 笠 ) CJK COMPATIBILITY IDEOGRAPH-F9F8 → CJK UNIFIED IDEOGRAPH-7B20	# 
+
+FA56 ;	7BC0 ;	MA	# ( 節 → 節 ) CJK COMPATIBILITY IDEOGRAPH-FA56 → CJK UNIFIED IDEOGRAPH-7BC0	# 
+FAAD ;	7BC0 ;	MA	# ( 節 → 節 ) CJK COMPATIBILITY IDEOGRAPH-FAAD → CJK UNIFIED IDEOGRAPH-7BC0	# 
+
+2F960 ;	4202 ;	MA	# ( 䈂 → 䈂 ) CJK COMPATIBILITY IDEOGRAPH-2F960 → CJK UNIFIED IDEOGRAPH-4202	# 
+
+2F961 ;	25BAB ;	MA	# ( 𥮫 → 𥮫 ) CJK COMPATIBILITY IDEOGRAPH-2F961 → CJK UNIFIED IDEOGRAPH-25BAB	# 
+
+2F962 ;	7BC6 ;	MA	# ( 篆 → 篆 ) CJK COMPATIBILITY IDEOGRAPH-2F962 → CJK UNIFIED IDEOGRAPH-7BC6	# 
+
+2F964 ;	4227 ;	MA	# ( 䈧 → 䈧 ) CJK COMPATIBILITY IDEOGRAPH-2F964 → CJK UNIFIED IDEOGRAPH-4227	# 
+
+2F963 ;	7BC9 ;	MA	# ( 築 → 築 ) CJK COMPATIBILITY IDEOGRAPH-2F963 → CJK UNIFIED IDEOGRAPH-7BC9	# 
+
+2F965 ;	25C80 ;	MA	# ( 𥲀 → 𥲀 ) CJK COMPATIBILITY IDEOGRAPH-2F965 → CJK UNIFIED IDEOGRAPH-25C80	# 
+
+FAD6 ;	25CD0 ;	MA	# ( 𥳐 → 𥳐 ) CJK COMPATIBILITY IDEOGRAPH-FAD6 → CJK UNIFIED IDEOGRAPH-25CD0	# 
+
+F9A6 ;	7C3E ;	MA	# ( 簾 → 簾 ) CJK COMPATIBILITY IDEOGRAPH-F9A6 → CJK UNIFIED IDEOGRAPH-7C3E	# 
+
+F944 ;	7C60 ;	MA	# ( 籠 → 籠 ) CJK COMPATIBILITY IDEOGRAPH-F944 → CJK UNIFIED IDEOGRAPH-7C60	# 
+
+2F76 ;	7C73 ;	MA	#* ( ⽶ → 米 ) KANGXI RADICAL RICE → CJK UNIFIED IDEOGRAPH-7C73	# 
+
+FAAE ;	7C7B ;	MA	# ( 类 → 类 ) CJK COMPATIBILITY IDEOGRAPH-FAAE → CJK UNIFIED IDEOGRAPH-7C7B	# 
+
+F9F9 ;	7C92 ;	MA	# ( 粒 → 粒 ) CJK COMPATIBILITY IDEOGRAPH-F9F9 → CJK UNIFIED IDEOGRAPH-7C92	# 
+
+FA1D ;	7CBE ;	MA	# ( 精 → 精 ) CJK COMPATIBILITY IDEOGRAPH-FA1D → CJK UNIFIED IDEOGRAPH-7CBE	# 
+
+2F966 ;	7CD2 ;	MA	# ( 糒 → 糒 ) CJK COMPATIBILITY IDEOGRAPH-2F966 → CJK UNIFIED IDEOGRAPH-7CD2	# 
+
+FA03 ;	7CD6 ;	MA	# ( 糖 → 糖 ) CJK COMPATIBILITY IDEOGRAPH-FA03 → CJK UNIFIED IDEOGRAPH-7CD6	# 
+
+2F968 ;	7CE8 ;	MA	# ( 糨 → 糨 ) CJK COMPATIBILITY IDEOGRAPH-2F968 → CJK UNIFIED IDEOGRAPH-7CE8	# 
+
+2F967 ;	42A0 ;	MA	# ( 䊠 → 䊠 ) CJK COMPATIBILITY IDEOGRAPH-2F967 → CJK UNIFIED IDEOGRAPH-42A0	# 
+
+2F969 ;	7CE3 ;	MA	# ( 糣 → 糣 ) CJK COMPATIBILITY IDEOGRAPH-2F969 → CJK UNIFIED IDEOGRAPH-7CE3	# 
+
+F97B ;	7CE7 ;	MA	# ( 糧 → 糧 ) CJK COMPATIBILITY IDEOGRAPH-F97B → CJK UNIFIED IDEOGRAPH-7CE7	# 
+
+2F77 ;	7CF8 ;	MA	#* ( ⽷ → 糸 ) KANGXI RADICAL SILK → CJK UNIFIED IDEOGRAPH-7CF8	# 
+
+2EAF ;	7CF9 ;	MA	#* ( ⺯ → 糹 ) CJK RADICAL SILK → CJK UNIFIED IDEOGRAPH-7CF9	# 
+
+2F96B ;	25F86 ;	MA	# ( 𥾆 → 𥾆 ) CJK COMPATIBILITY IDEOGRAPH-2F96B → CJK UNIFIED IDEOGRAPH-25F86	# 
+
+2F96A ;	7D00 ;	MA	# ( 紀 → 紀 ) CJK COMPATIBILITY IDEOGRAPH-2F96A → CJK UNIFIED IDEOGRAPH-7D00	# 
+
+F9CF ;	7D10 ;	MA	# ( 紐 → 紐 ) CJK COMPATIBILITY IDEOGRAPH-F9CF → CJK UNIFIED IDEOGRAPH-7D10	# 
+
+F96A ;	7D22 ;	MA	# ( 索 → 索 ) CJK COMPATIBILITY IDEOGRAPH-F96A → CJK UNIFIED IDEOGRAPH-7D22	# 
+
+F94F ;	7D2F ;	MA	# ( 累 → 累 ) CJK COMPATIBILITY IDEOGRAPH-F94F → CJK UNIFIED IDEOGRAPH-7D2F	# 
+
+7D76 ;	7D55 ;	MA	# ( 絶 → 絕 ) CJK UNIFIED IDEOGRAPH-7D76 → CJK UNIFIED IDEOGRAPH-7D55	# 
+
+2F96C ;	7D63 ;	MA	# ( 絣 → 絣 ) CJK COMPATIBILITY IDEOGRAPH-2F96C → CJK UNIFIED IDEOGRAPH-7D63	# 
+
+FAAF ;	7D5B ;	MA	# ( 絛 → 絛 ) CJK COMPATIBILITY IDEOGRAPH-FAAF → CJK UNIFIED IDEOGRAPH-7D5B	# 
+
+F93D ;	7DA0 ;	MA	# ( 綠 → 綠 ) CJK COMPATIBILITY IDEOGRAPH-F93D → CJK UNIFIED IDEOGRAPH-7DA0	# 
+
+F957 ;	7DBE ;	MA	# ( 綾 → 綾 ) CJK COMPATIBILITY IDEOGRAPH-F957 → CJK UNIFIED IDEOGRAPH-7DBE	# 
+
+2F96E ;	7DC7 ;	MA	# ( 緇 → 緇 ) CJK COMPATIBILITY IDEOGRAPH-2F96E → CJK UNIFIED IDEOGRAPH-7DC7	# 
+31E7C ;	7DC7 ;	MA	# ( 𱹼 → 緇 ) CJK UNIFIED IDEOGRAPH-31E7C → CJK UNIFIED IDEOGRAPH-7DC7	# →緇→
+
+F996 ;	7DF4 ;	MA	# ( 練 → 練 ) CJK COMPATIBILITY IDEOGRAPH-F996 → CJK UNIFIED IDEOGRAPH-7DF4	# 
+FA57 ;	7DF4 ;	MA	# ( 練 → 練 ) CJK COMPATIBILITY IDEOGRAPH-FA57 → CJK UNIFIED IDEOGRAPH-7DF4	# 
+FAB0 ;	7DF4 ;	MA	# ( 練 → 練 ) CJK COMPATIBILITY IDEOGRAPH-FAB0 → CJK UNIFIED IDEOGRAPH-7DF4	# 
+
+2F96F ;	7E02 ;	MA	# ( 縂 → 縂 ) CJK COMPATIBILITY IDEOGRAPH-2F96F → CJK UNIFIED IDEOGRAPH-7E02	# 
+
+2F96D ;	4301 ;	MA	# ( 䌁 → 䌁 ) CJK COMPATIBILITY IDEOGRAPH-2F96D → CJK UNIFIED IDEOGRAPH-4301	# 
+
+FA58 ;	7E09 ;	MA	# ( 縉 → 縉 ) CJK COMPATIBILITY IDEOGRAPH-FA58 → CJK UNIFIED IDEOGRAPH-7E09	# 
+
+F950 ;	7E37 ;	MA	# ( 縷 → 縷 ) CJK COMPATIBILITY IDEOGRAPH-F950 → CJK UNIFIED IDEOGRAPH-7E37	# 
+
+FA59 ;	7E41 ;	MA	# ( 繁 → 繁 ) CJK COMPATIBILITY IDEOGRAPH-FA59 → CJK UNIFIED IDEOGRAPH-7E41	# 
+
+2F970 ;	7E45 ;	MA	# ( 繅 → 繅 ) CJK COMPATIBILITY IDEOGRAPH-2F970 → CJK UNIFIED IDEOGRAPH-7E45	# 
+
+2F898 ;	261DA ;	MA	# ( 𦇚 → 𦇚 ) CJK COMPATIBILITY IDEOGRAPH-2F898 → CJK UNIFIED IDEOGRAPH-261DA	# 
+
+2F971 ;	4334 ;	MA	# ( 䌴 → 䌴 ) CJK COMPATIBILITY IDEOGRAPH-2F971 → CJK UNIFIED IDEOGRAPH-4334	# 
+
+2F78 ;	7F36 ;	MA	#* ( ⽸ → 缶 ) KANGXI RADICAL JAR → CJK UNIFIED IDEOGRAPH-7F36	# 
+
+2F972 ;	26228 ;	MA	# ( 𦈨 → 𦈨 ) CJK COMPATIBILITY IDEOGRAPH-2F972 → CJK UNIFIED IDEOGRAPH-26228	# 
+
+FAB1 ;	7F3E ;	MA	# ( 缾 → 缾 ) CJK COMPATIBILITY IDEOGRAPH-FAB1 → CJK UNIFIED IDEOGRAPH-7F3E	# 
+
+2F973 ;	26247 ;	MA	# ( 𦉇 → 𦉇 ) CJK COMPATIBILITY IDEOGRAPH-2F973 → CJK UNIFIED IDEOGRAPH-26247	# 
+
+2F79 ;	7F51 ;	MA	#* ( ⽹ → 网 ) KANGXI RADICAL NET → CJK UNIFIED IDEOGRAPH-7F51	# 
+
+2EAB ;	7F52 ;	MA	#* ( ⺫ → 罒 ) CJK RADICAL EYE → CJK UNIFIED IDEOGRAPH-7F52	# 
+2EB2 ;	7F52 ;	MA	#* ( ⺲ → 罒 ) CJK RADICAL NET TWO → CJK UNIFIED IDEOGRAPH-7F52	# 
+
+2EB1 ;	7F53 ;	MA	#* ( ⺱ → 罓 ) CJK RADICAL NET ONE → CJK UNIFIED IDEOGRAPH-7F53	# 
+
+2F974 ;	4359 ;	MA	# ( 䍙 → 䍙 ) CJK COMPATIBILITY IDEOGRAPH-2F974 → CJK UNIFIED IDEOGRAPH-4359	# 
+
+FA5A ;	7F72 ;	MA	# ( 署 → 署 ) CJK COMPATIBILITY IDEOGRAPH-FA5A → CJK UNIFIED IDEOGRAPH-7F72	# 
+
+2F975 ;	262D9 ;	MA	# ( 𦋙 → 𦋙 ) CJK COMPATIBILITY IDEOGRAPH-2F975 → CJK UNIFIED IDEOGRAPH-262D9	# 
+
+F9E6 ;	7F79 ;	MA	# ( 罹 → 罹 ) CJK COMPATIBILITY IDEOGRAPH-F9E6 → CJK UNIFIED IDEOGRAPH-7F79	# 
+
+2F976 ;	7F7A ;	MA	# ( 罺 → 罺 ) CJK COMPATIBILITY IDEOGRAPH-2F976 → CJK UNIFIED IDEOGRAPH-7F7A	# 
+
+F90F ;	7F85 ;	MA	# ( 羅 → 羅 ) CJK COMPATIBILITY IDEOGRAPH-F90F → CJK UNIFIED IDEOGRAPH-7F85	# 
+
+2F977 ;	2633E ;	MA	# ( 𦌾 → 𦌾 ) CJK COMPATIBILITY IDEOGRAPH-2F977 → CJK UNIFIED IDEOGRAPH-2633E	# 
+
+2F7A ;	7F8A ;	MA	#* ( ⽺ → 羊 ) KANGXI RADICAL SHEEP → CJK UNIFIED IDEOGRAPH-7F8A	# 
+
+2F978 ;	7F95 ;	MA	# ( 羕 → 羕 ) CJK COMPATIBILITY IDEOGRAPH-2F978 → CJK UNIFIED IDEOGRAPH-7F95	# 
+
+F9AF ;	7F9A ;	MA	# ( 羚 → 羚 ) CJK COMPATIBILITY IDEOGRAPH-F9AF → CJK UNIFIED IDEOGRAPH-7F9A	# 
+
+FA1E ;	7FBD ;	MA	# ( 羽 → 羽 ) CJK COMPATIBILITY IDEOGRAPH-FA1E → CJK UNIFIED IDEOGRAPH-7FBD	# 
+2F7B ;	7FBD ;	MA	#* ( ⽻ → 羽 ) KANGXI RADICAL FEATHER → CJK UNIFIED IDEOGRAPH-7FBD	# 
+
+2F979 ;	7FFA ;	MA	# ( 翺 → 翺 ) CJK COMPATIBILITY IDEOGRAPH-2F979 → CJK UNIFIED IDEOGRAPH-7FFA	# 
+
+F934 ;	8001 ;	MA	# ( 老 → 老 ) CJK COMPATIBILITY IDEOGRAPH-F934 → CJK UNIFIED IDEOGRAPH-8001	# 
+2F7C ;	8001 ;	MA	#* ( ⽼ → 老 ) KANGXI RADICAL OLD → CJK UNIFIED IDEOGRAPH-8001	# 
+
+2EB9 ;	8002 ;	MA	#* ( ⺹ → 耂 ) CJK RADICAL OLD → CJK UNIFIED IDEOGRAPH-8002	# 
+
+FA5B ;	8005 ;	MA	# ( 者 → 者 ) CJK COMPATIBILITY IDEOGRAPH-FA5B → CJK UNIFIED IDEOGRAPH-8005	# 
+FAB2 ;	8005 ;	MA	# ( 者 → 者 ) CJK COMPATIBILITY IDEOGRAPH-FAB2 → CJK UNIFIED IDEOGRAPH-8005	# 
+2F97A ;	8005 ;	MA	# ( 者 → 者 ) CJK COMPATIBILITY IDEOGRAPH-2F97A → CJK UNIFIED IDEOGRAPH-8005	# 
+
+2F7D ;	800C ;	MA	#* ( ⽽ → 而 ) KANGXI RADICAL AND → CJK UNIFIED IDEOGRAPH-800C	# 
+
+2F97B ;	264DA ;	MA	# ( 𦓚 → 𦓚 ) CJK COMPATIBILITY IDEOGRAPH-2F97B → CJK UNIFIED IDEOGRAPH-264DA	# 
+
+2F7E ;	8012 ;	MA	#* ( ⽾ → 耒 ) KANGXI RADICAL PLOW → CJK UNIFIED IDEOGRAPH-8012	# 
+
+2F97C ;	26523 ;	MA	# ( 𦔣 → 𦔣 ) CJK COMPATIBILITY IDEOGRAPH-2F97C → CJK UNIFIED IDEOGRAPH-26523	# 
+
+2F7F ;	8033 ;	MA	#* ( ⽿ → 耳 ) KANGXI RADICAL EAR → CJK UNIFIED IDEOGRAPH-8033	# 
+
+F9B0 ;	8046 ;	MA	# ( 聆 → 聆 ) CJK COMPATIBILITY IDEOGRAPH-F9B0 → CJK UNIFIED IDEOGRAPH-8046	# 
+
+2F97D ;	8060 ;	MA	# ( 聠 → 聠 ) CJK COMPATIBILITY IDEOGRAPH-2F97D → CJK UNIFIED IDEOGRAPH-8060	# 
+
+2659D ;	265A8 ;	MA	# ( 𦖝 → 𦖨 ) CJK UNIFIED IDEOGRAPH-2659D → CJK UNIFIED IDEOGRAPH-265A8	# →𦖨→
+2F97E ;	265A8 ;	MA	# ( 𦖨 → 𦖨 ) CJK COMPATIBILITY IDEOGRAPH-2F97E → CJK UNIFIED IDEOGRAPH-265A8	# 
+
+F997 ;	806F ;	MA	# ( 聯 → 聯 ) CJK COMPATIBILITY IDEOGRAPH-F997 → CJK UNIFIED IDEOGRAPH-806F	# 
+
+2F97F ;	8070 ;	MA	# ( 聰 → 聰 ) CJK COMPATIBILITY IDEOGRAPH-2F97F → CJK UNIFIED IDEOGRAPH-8070	# 
+
+F945 ;	807E ;	MA	# ( 聾 → 聾 ) CJK COMPATIBILITY IDEOGRAPH-F945 → CJK UNIFIED IDEOGRAPH-807E	# 
+
+2F80 ;	807F ;	MA	#* ( ⾀ → 聿 ) KANGXI RADICAL BRUSH → CJK UNIFIED IDEOGRAPH-807F	# 
+
+2EBA ;	8080 ;	MA	#* ( ⺺ → 肀 ) CJK RADICAL BRUSH ONE → CJK UNIFIED IDEOGRAPH-8080	# 
+
+2F81 ;	8089 ;	MA	#* ( ⾁ → 肉 ) KANGXI RADICAL MEAT → CJK UNIFIED IDEOGRAPH-8089	# 
+
+F953 ;	808B ;	MA	# ( 肋 → 肋 ) CJK COMPATIBILITY IDEOGRAPH-F953 → CJK UNIFIED IDEOGRAPH-808B	# 
+
+2F8D6 ;	80AD ;	MA	# ( 肭 → 肭 ) CJK COMPATIBILITY IDEOGRAPH-2F8D6 → CJK UNIFIED IDEOGRAPH-80AD	# 
+
+2F982 ;	80B2 ;	MA	# ( 育 → 育 ) CJK COMPATIBILITY IDEOGRAPH-2F982 → CJK UNIFIED IDEOGRAPH-80B2	# 
+
+2F981 ;	43D5 ;	MA	# ( 䏕 → 䏕 ) CJK COMPATIBILITY IDEOGRAPH-2F981 → CJK UNIFIED IDEOGRAPH-43D5	# 
+
+2F8D7 ;	43D9 ;	MA	# ( 䏙 → 䏙 ) CJK COMPATIBILITY IDEOGRAPH-2F8D7 → CJK UNIFIED IDEOGRAPH-43D9	# 
+
+8141 ;	80FC ;	MA	# ( 腁 → 胼 ) CJK UNIFIED IDEOGRAPH-8141 → CJK UNIFIED IDEOGRAPH-80FC	# 
+
+2F983 ;	8103 ;	MA	# ( 脃 → 脃 ) CJK COMPATIBILITY IDEOGRAPH-2F983 → CJK UNIFIED IDEOGRAPH-8103	# 
+
+2F985 ;	813E ;	MA	# ( 脾 → 脾 ) CJK COMPATIBILITY IDEOGRAPH-2F985 → CJK UNIFIED IDEOGRAPH-813E	# 
+
+2F984 ;	440B ;	MA	# ( 䐋 → 䐋 ) CJK COMPATIBILITY IDEOGRAPH-2F984 → CJK UNIFIED IDEOGRAPH-440B	# 
+
+2F8DA ;	6721 ;	MA	# ( 朡 → 朡 ) CJK COMPATIBILITY IDEOGRAPH-2F8DA → CJK UNIFIED IDEOGRAPH-6721	# 
+
+2F987 ;	267A7 ;	MA	# ( 𦞧 → 𦞧 ) CJK COMPATIBILITY IDEOGRAPH-2F987 → CJK UNIFIED IDEOGRAPH-267A7	# 
+
+2F988 ;	267B5 ;	MA	# ( 𦞵 → 𦞵 ) CJK COMPATIBILITY IDEOGRAPH-2F988 → CJK UNIFIED IDEOGRAPH-267B5	# 
+
+6726 ;	4443 ;	MA	# ( 朦 → 䑃 ) CJK UNIFIED IDEOGRAPH-6726 → CJK UNIFIED IDEOGRAPH-4443	# 
+
+F926 ;	81D8 ;	MA	# ( 臘 → 臘 ) CJK COMPATIBILITY IDEOGRAPH-F926 → CJK UNIFIED IDEOGRAPH-81D8	# 
+
+2F82 ;	81E3 ;	MA	#* ( ⾂ → 臣 ) KANGXI RADICAL MINISTER → CJK UNIFIED IDEOGRAPH-81E3	# 
+
+F9F6 ;	81E8 ;	MA	# ( 臨 → 臨 ) CJK COMPATIBILITY IDEOGRAPH-F9F6 → CJK UNIFIED IDEOGRAPH-81E8	# 
+
+2F83 ;	81EA ;	MA	#* ( ⾃ → 自 ) KANGXI RADICAL SELF → CJK UNIFIED IDEOGRAPH-81EA	# 
+
+FA5C ;	81ED ;	MA	# ( 臭 → 臭 ) CJK COMPATIBILITY IDEOGRAPH-FA5C → CJK UNIFIED IDEOGRAPH-81ED	# 
+
+2F84 ;	81F3 ;	MA	#* ( ⾄ → 至 ) KANGXI RADICAL ARRIVE → CJK UNIFIED IDEOGRAPH-81F3	# 
+
+2F85 ;	81FC ;	MA	#* ( ⾅ → 臼 ) KANGXI RADICAL MORTAR → CJK UNIFIED IDEOGRAPH-81FC	# 
+
+2F893 ;	8201 ;	MA	# ( 舁 → 舁 ) CJK COMPATIBILITY IDEOGRAPH-2F893 → CJK UNIFIED IDEOGRAPH-8201	# 
+2F98B ;	8201 ;	MA	# ( 舁 → 舁 ) CJK COMPATIBILITY IDEOGRAPH-2F98B → CJK UNIFIED IDEOGRAPH-8201	# 
+
+2F98C ;	8204 ;	MA	# ( 舄 → 舄 ) CJK COMPATIBILITY IDEOGRAPH-2F98C → CJK UNIFIED IDEOGRAPH-8204	# 
+
+2F86 ;	820C ;	MA	#* ( ⾆ → 舌 ) KANGXI RADICAL TONGUE → CJK UNIFIED IDEOGRAPH-820C	# 
+
+FA6D ;	8218 ;	MA	# ( 舘 → 舘 ) CJK COMPATIBILITY IDEOGRAPH-FA6D → CJK UNIFIED IDEOGRAPH-8218	# 
+
+2F87 ;	821B ;	MA	#* ( ⾇ → 舛 ) KANGXI RADICAL OPPOSE → CJK UNIFIED IDEOGRAPH-821B	# 
+
+2F88 ;	821F ;	MA	#* ( ⾈ → 舟 ) KANGXI RADICAL BOAT → CJK UNIFIED IDEOGRAPH-821F	# 
+
+2F98E ;	446B ;	MA	# ( 䑫 → 䑫 ) CJK COMPATIBILITY IDEOGRAPH-2F98E → CJK UNIFIED IDEOGRAPH-446B	# 
+
+2F89 ;	826E ;	MA	#* ( ⾉ → 艮 ) KANGXI RADICAL STOPPING → CJK UNIFIED IDEOGRAPH-826E	# 
+
+F97C ;	826F ;	MA	# ( 良 → 良 ) CJK COMPATIBILITY IDEOGRAPH-F97C → CJK UNIFIED IDEOGRAPH-826F	# 
+
+2F8A ;	8272 ;	MA	#* ( ⾊ → 色 ) KANGXI RADICAL COLOR → CJK UNIFIED IDEOGRAPH-8272	# 
+
+2F8B ;	8278 ;	MA	#* ( ⾋ → 艸 ) KANGXI RADICAL GRASS → CJK UNIFIED IDEOGRAPH-8278	# 
+
+FA5D ;	8279 ;	MA	# ( 艹 → 艹 ) CJK COMPATIBILITY IDEOGRAPH-FA5D → CJK UNIFIED IDEOGRAPH-8279	# 
+FA5E ;	8279 ;	MA	# ( 艹 → 艹 ) CJK COMPATIBILITY IDEOGRAPH-FA5E → CJK UNIFIED IDEOGRAPH-8279	# 
+2EBE ;	8279 ;	MA	#* ( ⺾ → 艹 ) CJK RADICAL GRASS ONE → CJK UNIFIED IDEOGRAPH-8279	# 
+2EBF ;	8279 ;	MA	#* ( ⺿ → 艹 ) CJK RADICAL GRASS TWO → CJK UNIFIED IDEOGRAPH-8279	# →艹→
+2EC0 ;	8279 ;	MA	#* ( ⻀ → 艹 ) CJK RADICAL GRASS THREE → CJK UNIFIED IDEOGRAPH-8279	# →艹→
+
+2F990 ;	828B ;	MA	# ( 芋 → 芋 ) CJK COMPATIBILITY IDEOGRAPH-2F990 → CJK UNIFIED IDEOGRAPH-828B	# 
+
+2F98F ;	8291 ;	MA	# ( 芑 → 芑 ) CJK COMPATIBILITY IDEOGRAPH-2F98F → CJK UNIFIED IDEOGRAPH-8291	# 
+
+2F991 ;	829D ;	MA	# ( 芝 → 芝 ) CJK COMPATIBILITY IDEOGRAPH-2F991 → CJK UNIFIED IDEOGRAPH-829D	# 
+
+2F993 ;	82B1 ;	MA	# ( 花 → 花 ) CJK COMPATIBILITY IDEOGRAPH-2F993 → CJK UNIFIED IDEOGRAPH-82B1	# 
+
+2F994 ;	82B3 ;	MA	# ( 芳 → 芳 ) CJK COMPATIBILITY IDEOGRAPH-2F994 → CJK UNIFIED IDEOGRAPH-82B3	# 
+
+2F995 ;	82BD ;	MA	# ( 芽 → 芽 ) CJK COMPATIBILITY IDEOGRAPH-2F995 → CJK UNIFIED IDEOGRAPH-82BD	# 
+
+F974 ;	82E5 ;	MA	# ( 若 → 若 ) CJK COMPATIBILITY IDEOGRAPH-F974 → CJK UNIFIED IDEOGRAPH-82E5	# 
+2F998 ;	82E5 ;	MA	# ( 若 → 若 ) CJK COMPATIBILITY IDEOGRAPH-2F998 → CJK UNIFIED IDEOGRAPH-82E5	# 
+
+2F996 ;	82E6 ;	MA	# ( 苦 → 苦 ) CJK COMPATIBILITY IDEOGRAPH-2F996 → CJK UNIFIED IDEOGRAPH-82E6	# 
+
+2F997 ;	26B3C ;	MA	# ( 𦬼 → 𦬼 ) CJK COMPATIBILITY IDEOGRAPH-2F997 → CJK UNIFIED IDEOGRAPH-26B3C	# 
+
+F9FE ;	8336 ;	MA	# ( 茶 → 茶 ) CJK COMPATIBILITY IDEOGRAPH-F9FE → CJK UNIFIED IDEOGRAPH-8336	# 
+
+FAB3 ;	8352 ;	MA	# ( 荒 → 荒 ) CJK COMPATIBILITY IDEOGRAPH-FAB3 → CJK UNIFIED IDEOGRAPH-8352	# 
+
+2F99A ;	8363 ;	MA	# ( 荣 → 荣 ) CJK COMPATIBILITY IDEOGRAPH-2F99A → CJK UNIFIED IDEOGRAPH-8363	# 
+
+2F999 ;	831D ;	MA	# ( 茝 → 茝 ) CJK COMPATIBILITY IDEOGRAPH-2F999 → CJK UNIFIED IDEOGRAPH-831D	# 
+
+2F99C ;	8323 ;	MA	# ( 茣 → 茣 ) CJK COMPATIBILITY IDEOGRAPH-2F99C → CJK UNIFIED IDEOGRAPH-8323	# 
+
+2F99D ;	83BD ;	MA	# ( 莽 → 莽 ) CJK COMPATIBILITY IDEOGRAPH-2F99D → CJK UNIFIED IDEOGRAPH-83BD	# 
+
+2F9A0 ;	8353 ;	MA	# ( 荓 → 荓 ) CJK COMPATIBILITY IDEOGRAPH-2F9A0 → CJK UNIFIED IDEOGRAPH-8353	# 
+
+F93E ;	83C9 ;	MA	# ( 菉 → 菉 ) CJK COMPATIBILITY IDEOGRAPH-F93E → CJK UNIFIED IDEOGRAPH-83C9	# 
+
+2F9A1 ;	83CA ;	MA	# ( 菊 → 菊 ) CJK COMPATIBILITY IDEOGRAPH-2F9A1 → CJK UNIFIED IDEOGRAPH-83CA	# 
+
+2F9A2 ;	83CC ;	MA	# ( 菌 → 菌 ) CJK COMPATIBILITY IDEOGRAPH-2F9A2 → CJK UNIFIED IDEOGRAPH-83CC	# 
+
+2F9A3 ;	83DC ;	MA	# ( 菜 → 菜 ) CJK COMPATIBILITY IDEOGRAPH-2F9A3 → CJK UNIFIED IDEOGRAPH-83DC	# 
+
+2F99E ;	83E7 ;	MA	# ( 菧 → 菧 ) CJK COMPATIBILITY IDEOGRAPH-2F99E → CJK UNIFIED IDEOGRAPH-83E7	# 
+
+FAB4 ;	83EF ;	MA	# ( 華 → 華 ) CJK COMPATIBILITY IDEOGRAPH-FAB4 → CJK UNIFIED IDEOGRAPH-83EF	# 
+
+F958 ;	83F1 ;	MA	# ( 菱 → 菱 ) CJK COMPATIBILITY IDEOGRAPH-F958 → CJK UNIFIED IDEOGRAPH-83F1	# 
+
+FA5F ;	8457 ;	MA	# ( 著 → 著 ) CJK COMPATIBILITY IDEOGRAPH-FA5F → CJK UNIFIED IDEOGRAPH-8457	# 
+2F99F ;	8457 ;	MA	# ( 著 → 著 ) CJK COMPATIBILITY IDEOGRAPH-2F99F → CJK UNIFIED IDEOGRAPH-8457	# 
+
+2F9A4 ;	26C36 ;	MA	# ( 𦰶 → 𦰶 ) CJK COMPATIBILITY IDEOGRAPH-2F9A4 → CJK UNIFIED IDEOGRAPH-26C36	# 
+26D06 ;	26C36 ;	MA	# ( 𦴆 → 𦰶 ) CJK UNIFIED IDEOGRAPH-26D06 → CJK UNIFIED IDEOGRAPH-26C36	# →𦰶→
+
+2F99B ;	83AD ;	MA	# ( 莭 → 莭 ) CJK COMPATIBILITY IDEOGRAPH-2F99B → CJK UNIFIED IDEOGRAPH-83AD	# 
+
+F918 ;	843D ;	MA	# ( 落 → 落 ) CJK COMPATIBILITY IDEOGRAPH-F918 → CJK UNIFIED IDEOGRAPH-843D	# 
+
+F96E ;	8449 ;	MA	# ( 葉 → 葉 ) CJK COMPATIBILITY IDEOGRAPH-F96E → CJK UNIFIED IDEOGRAPH-8449	# 
+
+853F ;	848D ;	MA	# ( 蔿 → 蒍 ) CJK UNIFIED IDEOGRAPH-853F → CJK UNIFIED IDEOGRAPH-848D	# 
+
+2F9A6 ;	26CD5 ;	MA	# ( 𦳕 → 𦳕 ) CJK COMPATIBILITY IDEOGRAPH-2F9A6 → CJK UNIFIED IDEOGRAPH-26CD5	# 
+
+2F9A5 ;	26D6B ;	MA	# ( 𦵫 → 𦵫 ) CJK COMPATIBILITY IDEOGRAPH-2F9A5 → CJK UNIFIED IDEOGRAPH-26D6B	# 
+
+F999 ;	84EE ;	MA	# ( 蓮 → 蓮 ) CJK COMPATIBILITY IDEOGRAPH-F999 → CJK UNIFIED IDEOGRAPH-84EE	# 
+
+2F9A8 ;	84F1 ;	MA	# ( 蓱 → 蓱 ) CJK COMPATIBILITY IDEOGRAPH-2F9A8 → CJK UNIFIED IDEOGRAPH-84F1	# 
+
+2F9A9 ;	84F3 ;	MA	# ( 蓳 → 蓳 ) CJK COMPATIBILITY IDEOGRAPH-2F9A9 → CJK UNIFIED IDEOGRAPH-84F3	# 
+
+F9C2 ;	84FC ;	MA	# ( 蓼 → 蓼 ) CJK COMPATIBILITY IDEOGRAPH-F9C2 → CJK UNIFIED IDEOGRAPH-84FC	# 
+
+2F9AA ;	8516 ;	MA	# ( 蔖 → 蔖 ) CJK COMPATIBILITY IDEOGRAPH-2F9AA → CJK UNIFIED IDEOGRAPH-8516	# 
+
+2F9A7 ;	452B ;	MA	# ( 䔫 → 䔫 ) CJK COMPATIBILITY IDEOGRAPH-2F9A7 → CJK UNIFIED IDEOGRAPH-452B	# 
+
+2F9AC ;	8564 ;	MA	# ( 蕤 → 蕤 ) CJK COMPATIBILITY IDEOGRAPH-2F9AC → CJK UNIFIED IDEOGRAPH-8564	# 
+
+2F9AD ;	26F2C ;	MA	# ( 𦼬 → 𦼬 ) CJK COMPATIBILITY IDEOGRAPH-2F9AD → CJK UNIFIED IDEOGRAPH-26F2C	# 
+
+F923 ;	85CD ;	MA	# ( 藍 → 藍 ) CJK COMPATIBILITY IDEOGRAPH-F923 → CJK UNIFIED IDEOGRAPH-85CD	# 
+
+2F9AE ;	455D ;	MA	# ( 䕝 → 䕝 ) CJK COMPATIBILITY IDEOGRAPH-2F9AE → CJK UNIFIED IDEOGRAPH-455D	# 
+
+2F9B0 ;	26FB1 ;	MA	# ( 𦾱 → 𦾱 ) CJK COMPATIBILITY IDEOGRAPH-2F9B0 → CJK UNIFIED IDEOGRAPH-26FB1	# 
+
+2F9AF ;	4561 ;	MA	# ( 䕡 → 䕡 ) CJK COMPATIBILITY IDEOGRAPH-2F9AF → CJK UNIFIED IDEOGRAPH-4561	# 
+
+F9F0 ;	85FA ;	MA	# ( 藺 → 藺 ) CJK COMPATIBILITY IDEOGRAPH-F9F0 → CJK UNIFIED IDEOGRAPH-85FA	# 
+
+F935 ;	8606 ;	MA	# ( 蘆 → 蘆 ) CJK COMPATIBILITY IDEOGRAPH-F935 → CJK UNIFIED IDEOGRAPH-8606	# 
+
+2F9B2 ;	456B ;	MA	# ( 䕫 → 䕫 ) CJK COMPATIBILITY IDEOGRAPH-2F9B2 → CJK UNIFIED IDEOGRAPH-456B	# 
+
+FA20 ;	8612 ;	MA	# ( 蘒 → 蘒 ) CJK COMPATIBILITY IDEOGRAPH-FA20 → CJK UNIFIED IDEOGRAPH-8612	# 
+
+F91F ;	862D ;	MA	# ( 蘭 → 蘭 ) CJK COMPATIBILITY IDEOGRAPH-F91F → CJK UNIFIED IDEOGRAPH-862D	# 
+
+2F9B1 ;	270D2 ;	MA	# ( 𧃒 → 𧃒 ) CJK COMPATIBILITY IDEOGRAPH-2F9B1 → CJK UNIFIED IDEOGRAPH-270D2	# 
+
+8641 ;	8637 ;	MA	# ( 虁 → 蘷 ) CJK UNIFIED IDEOGRAPH-8641 → CJK UNIFIED IDEOGRAPH-8637	# 
+
+F910 ;	863F ;	MA	# ( 蘿 → 蘿 ) CJK COMPATIBILITY IDEOGRAPH-F910 → CJK UNIFIED IDEOGRAPH-863F	# 
+
+2F8C ;	864D ;	MA	#* ( ⾌ → 虍 ) KANGXI RADICAL TIGER → CJK UNIFIED IDEOGRAPH-864D	# 
+
+2EC1 ;	864E ;	MA	#* ( ⻁ → 虎 ) CJK RADICAL TIGER → CJK UNIFIED IDEOGRAPH-864E	# 
+
+2F9B3 ;	8650 ;	MA	# ( 虐 → 虐 ) CJK COMPATIBILITY IDEOGRAPH-2F9B3 → CJK UNIFIED IDEOGRAPH-8650	# 
+
+F936 ;	865C ;	MA	# ( 虜 → 虜 ) CJK COMPATIBILITY IDEOGRAPH-F936 → CJK UNIFIED IDEOGRAPH-865C	# 
+2F9B4 ;	865C ;	MA	# ( 虜 → 虜 ) CJK COMPATIBILITY IDEOGRAPH-2F9B4 → CJK UNIFIED IDEOGRAPH-865C	# 
+
+2F9B5 ;	8667 ;	MA	# ( 虧 → 虧 ) CJK COMPATIBILITY IDEOGRAPH-2F9B5 → CJK UNIFIED IDEOGRAPH-8667	# 
+
+2F9B6 ;	8669 ;	MA	# ( 虩 → 虩 ) CJK COMPATIBILITY IDEOGRAPH-2F9B6 → CJK UNIFIED IDEOGRAPH-8669	# 
+
+2F8D ;	866B ;	MA	#* ( ⾍ → 虫 ) KANGXI RADICAL INSECT → CJK UNIFIED IDEOGRAPH-866B	# 
+
+2F9B7 ;	86A9 ;	MA	# ( 蚩 → 蚩 ) CJK COMPATIBILITY IDEOGRAPH-2F9B7 → CJK UNIFIED IDEOGRAPH-86A9	# 
+
+2F9B8 ;	8688 ;	MA	# ( 蚈 → 蚈 ) CJK COMPATIBILITY IDEOGRAPH-2F9B8 → CJK UNIFIED IDEOGRAPH-8688	# 
+
+2F9BA ;	86E2 ;	MA	# ( 蛢 → 蛢 ) CJK COMPATIBILITY IDEOGRAPH-2F9BA → CJK UNIFIED IDEOGRAPH-86E2	# 
+
+2F9B9 ;	870E ;	MA	# ( 蜎 → 蜎 ) CJK COMPATIBILITY IDEOGRAPH-2F9B9 → CJK UNIFIED IDEOGRAPH-870E	# 
+
+2F9BC ;	8728 ;	MA	# ( 蜨 → 蜨 ) CJK COMPATIBILITY IDEOGRAPH-2F9BC → CJK UNIFIED IDEOGRAPH-8728	# 
+
+2F9BD ;	876B ;	MA	# ( 蝫 → 蝫 ) CJK COMPATIBILITY IDEOGRAPH-2F9BD → CJK UNIFIED IDEOGRAPH-876B	# 
+
+2F9C0 ;	87E1 ;	MA	# ( 蟡 → 蟡 ) CJK COMPATIBILITY IDEOGRAPH-2F9C0 → CJK UNIFIED IDEOGRAPH-87E1	# 
+
+FAB5 ;	8779 ;	MA	# ( 蝹 → 蝹 ) CJK COMPATIBILITY IDEOGRAPH-FAB5 → CJK UNIFIED IDEOGRAPH-8779	# 
+2F9BB ;	8779 ;	MA	# ( 蝹 → 蝹 ) CJK COMPATIBILITY IDEOGRAPH-2F9BB → CJK UNIFIED IDEOGRAPH-8779	# 
+
+2F9BE ;	8786 ;	MA	# ( 螆 → 螆 ) CJK COMPATIBILITY IDEOGRAPH-2F9BE → CJK UNIFIED IDEOGRAPH-8786	# 
+
+2F9BF ;	45D7 ;	MA	# ( 䗗 → 䗗 ) CJK COMPATIBILITY IDEOGRAPH-2F9BF → CJK UNIFIED IDEOGRAPH-45D7	# 
+
+2F9AB ;	273CA ;	MA	# ( 𧏊 → 𧏊 ) CJK COMPATIBILITY IDEOGRAPH-2F9AB → CJK UNIFIED IDEOGRAPH-273CA	# 
+
+F911 ;	87BA ;	MA	# ( 螺 → 螺 ) CJK COMPATIBILITY IDEOGRAPH-F911 → CJK UNIFIED IDEOGRAPH-87BA	# 
+
+2F9C1 ;	8801 ;	MA	# ( 蠁 → 蠁 ) CJK COMPATIBILITY IDEOGRAPH-2F9C1 → CJK UNIFIED IDEOGRAPH-8801	# 
+
+2F9C2 ;	45F9 ;	MA	# ( 䗹 → 䗹 ) CJK COMPATIBILITY IDEOGRAPH-2F9C2 → CJK UNIFIED IDEOGRAPH-45F9	# 
+
+F927 ;	881F ;	MA	# ( 蠟 → 蠟 ) CJK COMPATIBILITY IDEOGRAPH-F927 → CJK UNIFIED IDEOGRAPH-881F	# 
+
+2F8E ;	8840 ;	MA	#* ( ⾎ → 血 ) KANGXI RADICAL BLOOD → CJK UNIFIED IDEOGRAPH-8840	# 
+
+FA08 ;	884C ;	MA	# ( 行 → 行 ) CJK COMPATIBILITY IDEOGRAPH-FA08 → CJK UNIFIED IDEOGRAPH-884C	# 
+2F8F ;	884C ;	MA	#* ( ⾏ → 行 ) KANGXI RADICAL WALK ENCLOSURE → CJK UNIFIED IDEOGRAPH-884C	# 
+
+2F9C3 ;	8860 ;	MA	# ( 衠 → 衠 ) CJK COMPATIBILITY IDEOGRAPH-2F9C3 → CJK UNIFIED IDEOGRAPH-8860	# 
+
+2F9C4 ;	8863 ;	MA	# ( 衣 → 衣 ) CJK COMPATIBILITY IDEOGRAPH-2F9C4 → CJK UNIFIED IDEOGRAPH-8863	# 
+2F90 ;	8863 ;	MA	#* ( ⾐ → 衣 ) KANGXI RADICAL CLOTHES → CJK UNIFIED IDEOGRAPH-8863	# 
+
+2EC2 ;	8864 ;	MA	#* ( ⻂ → 衤 ) CJK RADICAL CLOTHES → CJK UNIFIED IDEOGRAPH-8864	# 
+
+F9A0 ;	88C2 ;	MA	# ( 裂 → 裂 ) CJK COMPATIBILITY IDEOGRAPH-F9A0 → CJK UNIFIED IDEOGRAPH-88C2	# 
+
+2F9C5 ;	27667 ;	MA	# ( 𧙧 → 𧙧 ) CJK COMPATIBILITY IDEOGRAPH-2F9C5 → CJK UNIFIED IDEOGRAPH-27667	# 
+
+F9E7 ;	88CF ;	MA	# ( 裏 → 裏 ) CJK COMPATIBILITY IDEOGRAPH-F9E7 → CJK UNIFIED IDEOGRAPH-88CF	# 
+
+2F9C6 ;	88D7 ;	MA	# ( 裗 → 裗 ) CJK COMPATIBILITY IDEOGRAPH-2F9C6 → CJK UNIFIED IDEOGRAPH-88D7	# 
+
+2F9C7 ;	88DE ;	MA	# ( 裞 → 裞 ) CJK COMPATIBILITY IDEOGRAPH-2F9C7 → CJK UNIFIED IDEOGRAPH-88DE	# 
+
+F9E8 ;	88E1 ;	MA	# ( 裡 → 裡 ) CJK COMPATIBILITY IDEOGRAPH-F9E8 → CJK UNIFIED IDEOGRAPH-88E1	# 
+
+F912 ;	88F8 ;	MA	# ( 裸 → 裸 ) CJK COMPATIBILITY IDEOGRAPH-F912 → CJK UNIFIED IDEOGRAPH-88F8	# 
+
+2F9C9 ;	88FA ;	MA	# ( 裺 → 裺 ) CJK COMPATIBILITY IDEOGRAPH-2F9C9 → CJK UNIFIED IDEOGRAPH-88FA	# 
+
+2F9C8 ;	4635 ;	MA	# ( 䘵 → 䘵 ) CJK COMPATIBILITY IDEOGRAPH-2F9C8 → CJK UNIFIED IDEOGRAPH-4635	# 
+
+FA60 ;	8910 ;	MA	# ( 褐 → 褐 ) CJK COMPATIBILITY IDEOGRAPH-FA60 → CJK UNIFIED IDEOGRAPH-8910	# 
+
+FAB6 ;	8941 ;	MA	# ( 襁 → 襁 ) CJK COMPATIBILITY IDEOGRAPH-FAB6 → CJK UNIFIED IDEOGRAPH-8941	# 
+
+F924 ;	8964 ;	MA	# ( 襤 → 襤 ) CJK COMPATIBILITY IDEOGRAPH-F924 → CJK UNIFIED IDEOGRAPH-8964	# 
+
+2F91 ;	897E ;	MA	#* ( ⾑ → 襾 ) KANGXI RADICAL WEST → CJK UNIFIED IDEOGRAPH-897E	# 
+
+2EC4 ;	897F ;	MA	#* ( ⻄ → 西 ) CJK RADICAL WEST TWO → CJK UNIFIED IDEOGRAPH-897F	# 
+
+2EC3 ;	8980 ;	MA	#* ( ⻃ → 覀 ) CJK RADICAL WEST ONE → CJK UNIFIED IDEOGRAPH-8980	# 
+
+FAB7 ;	8986 ;	MA	# ( 覆 → 覆 ) CJK COMPATIBILITY IDEOGRAPH-FAB7 → CJK UNIFIED IDEOGRAPH-8986	# 
+
+FA0A ;	898B ;	MA	# ( 見 → 見 ) CJK COMPATIBILITY IDEOGRAPH-FA0A → CJK UNIFIED IDEOGRAPH-898B	# 
+2F92 ;	898B ;	MA	#* ( ⾒ → 見 ) KANGXI RADICAL SEE → CJK UNIFIED IDEOGRAPH-898B	# 
+
+2EC5 ;	89C1 ;	MA	#* ( ⻅ → 见 ) CJK RADICAL C-SIMPLIFIED SEE → CJK UNIFIED IDEOGRAPH-89C1	# 
+
+4695 ;	278AE ;	MA	# ( 䚕 → 𧢮 ) CJK UNIFIED IDEOGRAPH-4695 → CJK UNIFIED IDEOGRAPH-278AE	# →𧢮→
+2F9CB ;	278AE ;	MA	# ( 𧢮 → 𧢮 ) CJK COMPATIBILITY IDEOGRAPH-2F9CB → CJK UNIFIED IDEOGRAPH-278AE	# 
+
+2F93 ;	89D2 ;	MA	#* ( ⾓ → 角 ) KANGXI RADICAL HORN → CJK UNIFIED IDEOGRAPH-89D2	# 
+
+2F94 ;	8A00 ;	MA	#* ( ⾔ → 言 ) KANGXI RADICAL SPEECH → CJK UNIFIED IDEOGRAPH-8A00	# 
+
+2EC8 ;	8BA0 ;	MA	#* ( ⻈ → 讠 ) CJK RADICAL C-SIMPLIFIED SPEECH → CJK UNIFIED IDEOGRAPH-8BA0	# 
+
+2F9CC ;	27966 ;	MA	# ( 𧥦 → 𧥦 ) CJK COMPATIBILITY IDEOGRAPH-2F9CC → CJK UNIFIED IDEOGRAPH-27966	# 
+
+8A7D ;	8A2E ;	MA	# ( 詽 → 訮 ) CJK UNIFIED IDEOGRAPH-8A7D → CJK UNIFIED IDEOGRAPH-8A2E	# 
+
+8A1E ;	46B6 ;	MA	# ( 訞 → 䚶 ) CJK UNIFIED IDEOGRAPH-8A1E → CJK UNIFIED IDEOGRAPH-46B6	# 
+
+2F9CD ;	46BE ;	MA	# ( 䚾 → 䚾 ) CJK COMPATIBILITY IDEOGRAPH-2F9CD → CJK UNIFIED IDEOGRAPH-46BE	# 
+
+2F9CE ;	46C7 ;	MA	# ( 䛇 → 䛇 ) CJK COMPATIBILITY IDEOGRAPH-2F9CE → CJK UNIFIED IDEOGRAPH-46C7	# 
+
+2F9CF ;	8AA0 ;	MA	# ( 誠 → 誠 ) CJK COMPATIBILITY IDEOGRAPH-2F9CF → CJK UNIFIED IDEOGRAPH-8AA0	# 
+
+F96F ;	8AAA ;	MA	# ( 說 → 說 ) CJK COMPATIBILITY IDEOGRAPH-F96F → CJK UNIFIED IDEOGRAPH-8AAA	# 
+F9A1 ;	8AAA ;	MA	# ( 說 → 說 ) CJK COMPATIBILITY IDEOGRAPH-F9A1 → CJK UNIFIED IDEOGRAPH-8AAA	# 
+
+FAB9 ;	8ABF ;	MA	# ( 調 → 調 ) CJK COMPATIBILITY IDEOGRAPH-FAB9 → CJK UNIFIED IDEOGRAPH-8ABF	# 
+
+FABB ;	8ACB ;	MA	# ( 請 → 請 ) CJK COMPATIBILITY IDEOGRAPH-FABB → CJK UNIFIED IDEOGRAPH-8ACB	# 
+
+F97D ;	8AD2 ;	MA	# ( 諒 → 諒 ) CJK COMPATIBILITY IDEOGRAPH-F97D → CJK UNIFIED IDEOGRAPH-8AD2	# 
+
+F941 ;	8AD6 ;	MA	# ( 論 → 論 ) CJK COMPATIBILITY IDEOGRAPH-F941 → CJK UNIFIED IDEOGRAPH-8AD6	# 
+
+FABE ;	8AED ;	MA	# ( 諭 → 諭 ) CJK COMPATIBILITY IDEOGRAPH-FABE → CJK UNIFIED IDEOGRAPH-8AED	# 
+2F9D0 ;	8AED ;	MA	# ( 諭 → 諭 ) CJK COMPATIBILITY IDEOGRAPH-2F9D0 → CJK UNIFIED IDEOGRAPH-8AED	# 
+
+FA22 ;	8AF8 ;	MA	# ( 諸 → 諸 ) CJK COMPATIBILITY IDEOGRAPH-FA22 → CJK UNIFIED IDEOGRAPH-8AF8	# 
+FABA ;	8AF8 ;	MA	# ( 諸 → 諸 ) CJK COMPATIBILITY IDEOGRAPH-FABA → CJK UNIFIED IDEOGRAPH-8AF8	# 
+
+F95D ;	8AFE ;	MA	# ( 諾 → 諾 ) CJK COMPATIBILITY IDEOGRAPH-F95D → CJK UNIFIED IDEOGRAPH-8AFE	# 
+FABD ;	8AFE ;	MA	# ( 諾 → 諾 ) CJK COMPATIBILITY IDEOGRAPH-FABD → CJK UNIFIED IDEOGRAPH-8AFE	# 
+
+FA62 ;	8B01 ;	MA	# ( 謁 → 謁 ) CJK COMPATIBILITY IDEOGRAPH-FA62 → CJK UNIFIED IDEOGRAPH-8B01	# 
+FABC ;	8B01 ;	MA	# ( 謁 → 謁 ) CJK COMPATIBILITY IDEOGRAPH-FABC → CJK UNIFIED IDEOGRAPH-8B01	# 
+
+FA63 ;	8B39 ;	MA	# ( 謹 → 謹 ) CJK COMPATIBILITY IDEOGRAPH-FA63 → CJK UNIFIED IDEOGRAPH-8B39	# 
+FABF ;	8B39 ;	MA	# ( 謹 → 謹 ) CJK COMPATIBILITY IDEOGRAPH-FABF → CJK UNIFIED IDEOGRAPH-8B39	# 
+
+F9FC ;	8B58 ;	MA	# ( 識 → 識 ) CJK COMPATIBILITY IDEOGRAPH-F9FC → CJK UNIFIED IDEOGRAPH-8B58	# 
+
+F95A ;	8B80 ;	MA	# ( 讀 → 讀 ) CJK COMPATIBILITY IDEOGRAPH-F95A → CJK UNIFIED IDEOGRAPH-8B80	# 
+
+8B8F ;	8B86 ;	MA	# ( 讏 → 讆 ) CJK UNIFIED IDEOGRAPH-8B8F → CJK UNIFIED IDEOGRAPH-8B86	# 
+
+FAC0 ;	8B8A ;	MA	# ( 變 → 變 ) CJK COMPATIBILITY IDEOGRAPH-FAC0 → CJK UNIFIED IDEOGRAPH-8B8A	# 
+2F9D1 ;	8B8A ;	MA	# ( 變 → 變 ) CJK COMPATIBILITY IDEOGRAPH-2F9D1 → CJK UNIFIED IDEOGRAPH-8B8A	# 
+
+2F95 ;	8C37 ;	MA	#* ( ⾕ → 谷 ) KANGXI RADICAL VALLEY → CJK UNIFIED IDEOGRAPH-8C37	# 
+
+2F96 ;	8C46 ;	MA	#* ( ⾖ → 豆 ) KANGXI RADICAL BEAN → CJK UNIFIED IDEOGRAPH-8C46	# 
+
+F900 ;	8C48 ;	MA	# ( 豈 → 豈 ) CJK COMPATIBILITY IDEOGRAPH-F900 → CJK UNIFIED IDEOGRAPH-8C48	# 
+
+2F9D2 ;	8C55 ;	MA	# ( 豕 → 豕 ) CJK COMPATIBILITY IDEOGRAPH-2F9D2 → CJK UNIFIED IDEOGRAPH-8C55	# 
+2F97 ;	8C55 ;	MA	#* ( ⾗ → 豕 ) KANGXI RADICAL PIG → CJK UNIFIED IDEOGRAPH-8C55	# 
+
+8C63 ;	8C5C ;	MA	# ( 豣 → 豜 ) CJK UNIFIED IDEOGRAPH-8C63 → CJK UNIFIED IDEOGRAPH-8C5C	# 
+
+2F98 ;	8C78 ;	MA	#* ( ⾘ → 豸 ) KANGXI RADICAL BADGER → CJK UNIFIED IDEOGRAPH-8C78	# 
+
+2F9D3 ;	27CA8 ;	MA	# ( 𧲨 → 𧲨 ) CJK COMPATIBILITY IDEOGRAPH-2F9D3 → CJK UNIFIED IDEOGRAPH-27CA8	# 
+
+2F99 ;	8C9D ;	MA	#* ( ⾙ → 貝 ) KANGXI RADICAL SHELL → CJK UNIFIED IDEOGRAPH-8C9D	# 
+
+2EC9 ;	8D1D ;	MA	#* ( ⻉ → 贝 ) CJK RADICAL C-SIMPLIFIED SHELL → CJK UNIFIED IDEOGRAPH-8D1D	# 
+
+2F9D4 ;	8CAB ;	MA	# ( 貫 → 貫 ) CJK COMPATIBILITY IDEOGRAPH-2F9D4 → CJK UNIFIED IDEOGRAPH-8CAB	# 
+
+2F9D5 ;	8CC1 ;	MA	# ( 賁 → 賁 ) CJK COMPATIBILITY IDEOGRAPH-2F9D5 → CJK UNIFIED IDEOGRAPH-8CC1	# 
+
+F948 ;	8CC2 ;	MA	# ( 賂 → 賂 ) CJK COMPATIBILITY IDEOGRAPH-F948 → CJK UNIFIED IDEOGRAPH-8CC2	# 
+
+F903 ;	8CC8 ;	MA	# ( 賈 → 賈 ) CJK COMPATIBILITY IDEOGRAPH-F903 → CJK UNIFIED IDEOGRAPH-8CC8	# 
+
+FA64 ;	8CD3 ;	MA	# ( 賓 → 賓 ) CJK COMPATIBILITY IDEOGRAPH-FA64 → CJK UNIFIED IDEOGRAPH-8CD3	# 
+
+FA65 ;	8D08 ;	MA	# ( 贈 → 贈 ) CJK COMPATIBILITY IDEOGRAPH-FA65 → CJK UNIFIED IDEOGRAPH-8D08	# 
+FAC1 ;	8D08 ;	MA	# ( 贈 → 贈 ) CJK COMPATIBILITY IDEOGRAPH-FAC1 → CJK UNIFIED IDEOGRAPH-8D08	# 
+
+25AD4 ;	8D1B ;	MA	# ( 𥫔 → 贛 ) CJK UNIFIED IDEOGRAPH-25AD4 → CJK UNIFIED IDEOGRAPH-8D1B	# →贛→
+2F9D6 ;	8D1B ;	MA	# ( 贛 → 贛 ) CJK COMPATIBILITY IDEOGRAPH-2F9D6 → CJK UNIFIED IDEOGRAPH-8D1B	# 
+
+2F9A ;	8D64 ;	MA	#* ( ⾚ → 赤 ) KANGXI RADICAL RED → CJK UNIFIED IDEOGRAPH-8D64	# 
+
+2F9B ;	8D70 ;	MA	#* ( ⾛ → 走 ) KANGXI RADICAL RUN → CJK UNIFIED IDEOGRAPH-8D70	# 
+
+2F9D7 ;	8D77 ;	MA	# ( 起 → 起 ) CJK COMPATIBILITY IDEOGRAPH-2F9D7 → CJK UNIFIED IDEOGRAPH-8D77	# 
+
+8D86 ;	8D7F ;	MA	# ( 趆 → 赿 ) CJK UNIFIED IDEOGRAPH-8D86 → CJK UNIFIED IDEOGRAPH-8D7F	# 
+
+FAD7 ;	27ED3 ;	MA	# ( 𧻓 → 𧻓 ) CJK COMPATIBILITY IDEOGRAPH-FAD7 → CJK UNIFIED IDEOGRAPH-27ED3	# 
+
+2F9D8 ;	27F2F ;	MA	# ( 𧼯 → 𧼯 ) CJK COMPATIBILITY IDEOGRAPH-2F9D8 → CJK UNIFIED IDEOGRAPH-27F2F	# 
+
+2F9C ;	8DB3 ;	MA	#* ( ⾜ → 足 ) KANGXI RADICAL FOOT → CJK UNIFIED IDEOGRAPH-8DB3	# 
+
+2F9DA ;	8DCB ;	MA	# ( 跋 → 跋 ) CJK COMPATIBILITY IDEOGRAPH-2F9DA → CJK UNIFIED IDEOGRAPH-8DCB	# 
+
+2F9DB ;	8DBC ;	MA	# ( 趼 → 趼 ) CJK COMPATIBILITY IDEOGRAPH-2F9DB → CJK UNIFIED IDEOGRAPH-8DBC	# 
+
+8DFA ;	8DE5 ;	MA	# ( 跺 → 跥 ) CJK UNIFIED IDEOGRAPH-8DFA → CJK UNIFIED IDEOGRAPH-8DE5	# 
+
+F937 ;	8DEF ;	MA	# ( 路 → 路 ) CJK COMPATIBILITY IDEOGRAPH-F937 → CJK UNIFIED IDEOGRAPH-8DEF	# 
+
+2F9DC ;	8DF0 ;	MA	# ( 跰 → 跰 ) CJK COMPATIBILITY IDEOGRAPH-2F9DC → CJK UNIFIED IDEOGRAPH-8DF0	# 
+
+8E9B ;	8E97 ;	MA	# ( 躛 → 躗 ) CJK UNIFIED IDEOGRAPH-8E9B → CJK UNIFIED IDEOGRAPH-8E97	# 
+
+2F9D ;	8EAB ;	MA	#* ( ⾝ → 身 ) KANGXI RADICAL BODY → CJK UNIFIED IDEOGRAPH-8EAB	# 
+
+F902 ;	8ECA ;	MA	# ( 車 → 車 ) CJK COMPATIBILITY IDEOGRAPH-F902 → CJK UNIFIED IDEOGRAPH-8ECA	# 
+2F9E ;	8ECA ;	MA	#* ( ⾞ → 車 ) KANGXI RADICAL CART → CJK UNIFIED IDEOGRAPH-8ECA	# 
+
+2ECB ;	8F66 ;	MA	#* ( ⻋ → 车 ) CJK RADICAL C-SIMPLIFIED CART → CJK UNIFIED IDEOGRAPH-8F66	# 
+
+2F9DE ;	8ED4 ;	MA	# ( 軔 → 軔 ) CJK COMPATIBILITY IDEOGRAPH-2F9DE → CJK UNIFIED IDEOGRAPH-8ED4	# 
+
+8F27 ;	8EFF ;	MA	# ( 輧 → 軿 ) CJK UNIFIED IDEOGRAPH-8F27 → CJK UNIFIED IDEOGRAPH-8EFF	# 
+
+F998 ;	8F26 ;	MA	# ( 輦 → 輦 ) CJK COMPATIBILITY IDEOGRAPH-F998 → CJK UNIFIED IDEOGRAPH-8F26	# 
+
+F9D7 ;	8F2A ;	MA	# ( 輪 → 輪 ) CJK COMPATIBILITY IDEOGRAPH-F9D7 → CJK UNIFIED IDEOGRAPH-8F2A	# 
+
+FAC2 ;	8F38 ;	MA	# ( 輸 → 輸 ) CJK COMPATIBILITY IDEOGRAPH-FAC2 → CJK UNIFIED IDEOGRAPH-8F38	# 
+2F9DF ;	8F38 ;	MA	# ( 輸 → 輸 ) CJK COMPATIBILITY IDEOGRAPH-2F9DF → CJK UNIFIED IDEOGRAPH-8F38	# 
+
+FA07 ;	8F3B ;	MA	# ( 輻 → 輻 ) CJK COMPATIBILITY IDEOGRAPH-FA07 → CJK UNIFIED IDEOGRAPH-8F3B	# 
+
+F98D ;	8F62 ;	MA	# ( 轢 → 轢 ) CJK COMPATIBILITY IDEOGRAPH-F98D → CJK UNIFIED IDEOGRAPH-8F62	# 
+
+2F9F ;	8F9B ;	MA	#* ( ⾟ → 辛 ) KANGXI RADICAL BITTER → CJK UNIFIED IDEOGRAPH-8F9B	# 
+
+2F98D ;	8F9E ;	MA	# ( 辞 → 辞 ) CJK COMPATIBILITY IDEOGRAPH-2F98D → CJK UNIFIED IDEOGRAPH-8F9E	# 
+
+F971 ;	8FB0 ;	MA	# ( 辰 → 辰 ) CJK COMPATIBILITY IDEOGRAPH-F971 → CJK UNIFIED IDEOGRAPH-8FB0	# 
+2FA0 ;	8FB0 ;	MA	#* ( ⾠ → 辰 ) KANGXI RADICAL MORNING → CJK UNIFIED IDEOGRAPH-8FB0	# 
+
+2FA1 ;	8FB5 ;	MA	#* ( ⾡ → 辵 ) KANGXI RADICAL WALK → CJK UNIFIED IDEOGRAPH-8FB5	# 
+
+FA66 ;	8FB6 ;	MA	# ( 辶 → 辶 ) CJK COMPATIBILITY IDEOGRAPH-FA66 → CJK UNIFIED IDEOGRAPH-8FB6	# 
+2ECC ;	8FB6 ;	MA	#* ( ⻌ → 辶 ) CJK RADICAL SIMPLIFIED WALK → CJK UNIFIED IDEOGRAPH-8FB6	# 
+2ECD ;	8FB6 ;	MA	#* ( ⻍ → 辶 ) CJK RADICAL WALK ONE → CJK UNIFIED IDEOGRAPH-8FB6	# 
+
+2F881 ;	5DE1 ;	MA	# ( 巡 → 巡 ) CJK COMPATIBILITY IDEOGRAPH-2F881 → CJK UNIFIED IDEOGRAPH-5DE1	# 
+
+F99A ;	9023 ;	MA	# ( 連 → 連 ) CJK COMPATIBILITY IDEOGRAPH-F99A → CJK UNIFIED IDEOGRAPH-9023	# 
+
+FA25 ;	9038 ;	MA	# ( 逸 → 逸 ) CJK COMPATIBILITY IDEOGRAPH-FA25 → CJK UNIFIED IDEOGRAPH-9038	# 
+FA67 ;	9038 ;	MA	# ( 逸 → 逸 ) CJK COMPATIBILITY IDEOGRAPH-FA67 → CJK UNIFIED IDEOGRAPH-9038	# 
+
+FAC3 ;	9072 ;	MA	# ( 遲 → 遲 ) CJK COMPATIBILITY IDEOGRAPH-FAC3 → CJK UNIFIED IDEOGRAPH-9072	# 
+
+F9C3 ;	907C ;	MA	# ( 遼 → 遼 ) CJK COMPATIBILITY IDEOGRAPH-F9C3 → CJK UNIFIED IDEOGRAPH-907C	# 
+
+2F9E0 ;	285D2 ;	MA	# ( 𨗒 → 𨗒 ) CJK COMPATIBILITY IDEOGRAPH-2F9E0 → CJK UNIFIED IDEOGRAPH-285D2	# 
+
+2F9E1 ;	285ED ;	MA	# ( 𨗭 → 𨗭 ) CJK COMPATIBILITY IDEOGRAPH-2F9E1 → CJK UNIFIED IDEOGRAPH-285ED	# 
+
+F913 ;	908F ;	MA	# ( 邏 → 邏 ) CJK COMPATIBILITY IDEOGRAPH-F913 → CJK UNIFIED IDEOGRAPH-908F	# 
+
+2FA2 ;	9091 ;	MA	#* ( ⾢ → 邑 ) KANGXI RADICAL CITY → CJK UNIFIED IDEOGRAPH-9091	# 
+
+2F9E2 ;	9094 ;	MA	# ( 邔 → 邔 ) CJK COMPATIBILITY IDEOGRAPH-2F9E2 → CJK UNIFIED IDEOGRAPH-9094	# 
+
+F92C ;	90CE ;	MA	# ( 郎 → 郎 ) CJK COMPATIBILITY IDEOGRAPH-F92C → CJK UNIFIED IDEOGRAPH-90CE	# 
+90DE ;	90CE ;	MA	# ( 郞 → 郎 ) CJK UNIFIED IDEOGRAPH-90DE → CJK UNIFIED IDEOGRAPH-90CE	# →郎→
+FA2E ;	90CE ;	MA	# ( 郞 → 郎 ) CJK COMPATIBILITY IDEOGRAPH-FA2E → CJK UNIFIED IDEOGRAPH-90CE	# →郞→→郎→
+
+2F9E3 ;	90F1 ;	MA	# ( 郱 → 郱 ) CJK COMPATIBILITY IDEOGRAPH-2F9E3 → CJK UNIFIED IDEOGRAPH-90F1	# 
+
+FA26 ;	90FD ;	MA	# ( 都 → 都 ) CJK COMPATIBILITY IDEOGRAPH-FA26 → CJK UNIFIED IDEOGRAPH-90FD	# 
+
+2F9E5 ;	2872E ;	MA	# ( 𨜮 → 𨜮 ) CJK COMPATIBILITY IDEOGRAPH-2F9E5 → CJK UNIFIED IDEOGRAPH-2872E	# 
+
+2F9E4 ;	9111 ;	MA	# ( 鄑 → 鄑 ) CJK COMPATIBILITY IDEOGRAPH-2F9E4 → CJK UNIFIED IDEOGRAPH-9111	# 
+
+2F9E6 ;	911B ;	MA	# ( 鄛 → 鄛 ) CJK COMPATIBILITY IDEOGRAPH-2F9E6 → CJK UNIFIED IDEOGRAPH-911B	# 
+
+2FA3 ;	9149 ;	MA	#* ( ⾣ → 酉 ) KANGXI RADICAL WINE → CJK UNIFIED IDEOGRAPH-9149	# 
+
+F919 ;	916A ;	MA	# ( 酪 → 酪 ) CJK COMPATIBILITY IDEOGRAPH-F919 → CJK UNIFIED IDEOGRAPH-916A	# 
+
+FAC4 ;	9199 ;	MA	# ( 醙 → 醙 ) CJK COMPATIBILITY IDEOGRAPH-FAC4 → CJK UNIFIED IDEOGRAPH-9199	# 
+
+F9B7 ;	91B4 ;	MA	# ( 醴 → 醴 ) CJK COMPATIBILITY IDEOGRAPH-F9B7 → CJK UNIFIED IDEOGRAPH-91B4	# 
+
+2FA4 ;	91C6 ;	MA	#* ( ⾤ → 釆 ) KANGXI RADICAL DISTINGUISH → CJK UNIFIED IDEOGRAPH-91C6	# 
+
+F9E9 ;	91CC ;	MA	# ( 里 → 里 ) CJK COMPATIBILITY IDEOGRAPH-F9E9 → CJK UNIFIED IDEOGRAPH-91CC	# 
+2FA5 ;	91CC ;	MA	#* ( ⾥ → 里 ) KANGXI RADICAL VILLAGE → CJK UNIFIED IDEOGRAPH-91CC	# 
+
+F97E ;	91CF ;	MA	# ( 量 → 量 ) CJK COMPATIBILITY IDEOGRAPH-F97E → CJK UNIFIED IDEOGRAPH-91CF	# 
+
+F90A ;	91D1 ;	MA	# ( 金 → 金 ) CJK COMPATIBILITY IDEOGRAPH-F90A → CJK UNIFIED IDEOGRAPH-91D1	# 
+2FA6 ;	91D1 ;	MA	#* ( ⾦ → 金 ) KANGXI RADICAL GOLD → CJK UNIFIED IDEOGRAPH-91D1	# 
+
+2ED0 ;	9485 ;	MA	#* ( ⻐ → 钅 ) CJK RADICAL C-SIMPLIFIED GOLD → CJK UNIFIED IDEOGRAPH-9485	# 
+
+F9B1 ;	9234 ;	MA	# ( 鈴 → 鈴 ) CJK COMPATIBILITY IDEOGRAPH-F9B1 → CJK UNIFIED IDEOGRAPH-9234	# 
+
+2F9E7 ;	9238 ;	MA	# ( 鈸 → 鈸 ) CJK COMPATIBILITY IDEOGRAPH-2F9E7 → CJK UNIFIED IDEOGRAPH-9238	# 
+
+FAC5 ;	9276 ;	MA	# ( 鉶 → 鉶 ) CJK COMPATIBILITY IDEOGRAPH-FAC5 → CJK UNIFIED IDEOGRAPH-9276	# 
+
+2F9E8 ;	92D7 ;	MA	# ( 鋗 → 鋗 ) CJK COMPATIBILITY IDEOGRAPH-2F9E8 → CJK UNIFIED IDEOGRAPH-92D7	# 
+
+2F9E9 ;	92D8 ;	MA	# ( 鋘 → 鋘 ) CJK COMPATIBILITY IDEOGRAPH-2F9E9 → CJK UNIFIED IDEOGRAPH-92D8	# 
+
+2F9EA ;	927C ;	MA	# ( 鉼 → 鉼 ) CJK COMPATIBILITY IDEOGRAPH-2F9EA → CJK UNIFIED IDEOGRAPH-927C	# 
+
+F93F ;	9304 ;	MA	# ( 錄 → 錄 ) CJK COMPATIBILITY IDEOGRAPH-F93F → CJK UNIFIED IDEOGRAPH-9304	# 
+
+F99B ;	934A ;	MA	# ( 鍊 → 鍊 ) CJK COMPATIBILITY IDEOGRAPH-F99B → CJK UNIFIED IDEOGRAPH-934A	# 
+
+93AE ;	93AD ;	MA	# ( 鎮 → 鎭 ) CJK UNIFIED IDEOGRAPH-93AE → CJK UNIFIED IDEOGRAPH-93AD	# 
+
+2F9EB ;	93F9 ;	MA	# ( 鏹 → 鏹 ) CJK COMPATIBILITY IDEOGRAPH-2F9EB → CJK UNIFIED IDEOGRAPH-93F9	# 
+
+2F9EC ;	9415 ;	MA	# ( 鐕 → 鐕 ) CJK COMPATIBILITY IDEOGRAPH-2F9EC → CJK UNIFIED IDEOGRAPH-9415	# 
+
+2F9ED ;	28BFA ;	MA	# ( 𨯺 → 𨯺 ) CJK COMPATIBILITY IDEOGRAPH-2F9ED → CJK UNIFIED IDEOGRAPH-28BFA	# 
+
+2ED2 ;	9578 ;	MA	#* ( ⻒ → 镸 ) CJK RADICAL LONG TWO → CJK UNIFIED IDEOGRAPH-9578	# 
+
+2ED3 ;	957F ;	MA	#* ( ⻓ → 长 ) CJK RADICAL C-SIMPLIFIED LONG → CJK UNIFIED IDEOGRAPH-957F	# 
+
+2FA8 ;	9580 ;	MA	#* ( ⾨ → 門 ) KANGXI RADICAL GATE → CJK UNIFIED IDEOGRAPH-9580	# 
+
+2ED4 ;	95E8 ;	MA	#* ( ⻔ → 门 ) CJK RADICAL C-SIMPLIFIED GATE → CJK UNIFIED IDEOGRAPH-95E8	# 
+
+2F9EE ;	958B ;	MA	# ( 開 → 開 ) CJK COMPATIBILITY IDEOGRAPH-2F9EE → CJK UNIFIED IDEOGRAPH-958B	# 
+
+2F9EF ;	4995 ;	MA	# ( 䦕 → 䦕 ) CJK COMPATIBILITY IDEOGRAPH-2F9EF → CJK UNIFIED IDEOGRAPH-4995	# 
+
+F986 ;	95AD ;	MA	# ( 閭 → 閭 ) CJK COMPATIBILITY IDEOGRAPH-F986 → CJK UNIFIED IDEOGRAPH-95AD	# 
+
+2F9F0 ;	95B7 ;	MA	# ( 閷 → 閷 ) CJK COMPATIBILITY IDEOGRAPH-2F9F0 → CJK UNIFIED IDEOGRAPH-95B7	# 
+
+2F9F1 ;	28D77 ;	MA	# ( 𨵷 → 𨵷 ) CJK COMPATIBILITY IDEOGRAPH-2F9F1 → CJK UNIFIED IDEOGRAPH-28D77	# 
+
+2FA9 ;	961C ;	MA	#* ( ⾩ → 阜 ) KANGXI RADICAL MOUND → CJK UNIFIED IDEOGRAPH-961C	# 
+
+2ECF ;	961D ;	MA	#* ( ⻏ → 阝 ) CJK RADICAL CITY → CJK UNIFIED IDEOGRAPH-961D	# 
+2ED6 ;	961D ;	MA	#* ( ⻖ → 阝 ) CJK RADICAL MOUND TWO → CJK UNIFIED IDEOGRAPH-961D	# 
+
+F9C6 ;	962E ;	MA	# ( 阮 → 阮 ) CJK COMPATIBILITY IDEOGRAPH-F9C6 → CJK UNIFIED IDEOGRAPH-962E	# 
+
+F951 ;	964B ;	MA	# ( 陋 → 陋 ) CJK COMPATIBILITY IDEOGRAPH-F951 → CJK UNIFIED IDEOGRAPH-964B	# 
+
+FA09 ;	964D ;	MA	# ( 降 → 降 ) CJK COMPATIBILITY IDEOGRAPH-FA09 → CJK UNIFIED IDEOGRAPH-964D	# 
+
+F959 ;	9675 ;	MA	# ( 陵 → 陵 ) CJK COMPATIBILITY IDEOGRAPH-F959 → CJK UNIFIED IDEOGRAPH-9675	# 
+
+F9D3 ;	9678 ;	MA	# ( 陸 → 陸 ) CJK COMPATIBILITY IDEOGRAPH-F9D3 → CJK UNIFIED IDEOGRAPH-9678	# 
+
+FAC6 ;	967C ;	MA	# ( 陼 → 陼 ) CJK COMPATIBILITY IDEOGRAPH-FAC6 → CJK UNIFIED IDEOGRAPH-967C	# 
+
+F9DC ;	9686 ;	MA	# ( 隆 → 隆 ) CJK COMPATIBILITY IDEOGRAPH-F9DC → CJK UNIFIED IDEOGRAPH-9686	# 
+
+F9F1 ;	96A3 ;	MA	# ( 隣 → 隣 ) CJK COMPATIBILITY IDEOGRAPH-F9F1 → CJK UNIFIED IDEOGRAPH-96A3	# 
+
+2F9F2 ;	49E6 ;	MA	# ( 䧦 → 䧦 ) CJK COMPATIBILITY IDEOGRAPH-2F9F2 → CJK UNIFIED IDEOGRAPH-49E6	# 
+
+2FAA ;	96B6 ;	MA	#* ( ⾪ → 隶 ) KANGXI RADICAL SLAVE → CJK UNIFIED IDEOGRAPH-96B6	# 
+
+FA2F ;	96B7 ;	MA	# ( 隷 → 隷 ) CJK COMPATIBILITY IDEOGRAPH-FA2F → CJK UNIFIED IDEOGRAPH-96B7	# 
+96B8 ;	96B7 ;	MA	# ( 隸 → 隷 ) CJK UNIFIED IDEOGRAPH-96B8 → CJK UNIFIED IDEOGRAPH-96B7	# →隸→
+F9B8 ;	96B7 ;	MA	# ( 隸 → 隷 ) CJK COMPATIBILITY IDEOGRAPH-F9B8 → CJK UNIFIED IDEOGRAPH-96B7	# 
+
+2FAB ;	96B9 ;	MA	#* ( ⾫ → 隹 ) KANGXI RADICAL SHORT TAILED BIRD → CJK UNIFIED IDEOGRAPH-96B9	# 
+
+2F9F3 ;	96C3 ;	MA	# ( 雃 → 雃 ) CJK COMPATIBILITY IDEOGRAPH-2F9F3 → CJK UNIFIED IDEOGRAPH-96C3	# 
+
+F9EA ;	96E2 ;	MA	# ( 離 → 離 ) CJK COMPATIBILITY IDEOGRAPH-F9EA → CJK UNIFIED IDEOGRAPH-96E2	# 
+
+FA68 ;	96E3 ;	MA	# ( 難 → 難 ) CJK COMPATIBILITY IDEOGRAPH-FA68 → CJK UNIFIED IDEOGRAPH-96E3	# 
+FAC7 ;	96E3 ;	MA	# ( 難 → 難 ) CJK COMPATIBILITY IDEOGRAPH-FAC7 → CJK UNIFIED IDEOGRAPH-96E3	# 
+
+2FAC ;	96E8 ;	MA	#* ( ⾬ → 雨 ) KANGXI RADICAL RAIN → CJK UNIFIED IDEOGRAPH-96E8	# 
+
+F9B2 ;	96F6 ;	MA	# ( 零 → 零 ) CJK COMPATIBILITY IDEOGRAPH-F9B2 → CJK UNIFIED IDEOGRAPH-96F6	# 
+
+F949 ;	96F7 ;	MA	# ( 雷 → 雷 ) CJK COMPATIBILITY IDEOGRAPH-F949 → CJK UNIFIED IDEOGRAPH-96F7	# 
+
+2F9F5 ;	9723 ;	MA	# ( 霣 → 霣 ) CJK COMPATIBILITY IDEOGRAPH-2F9F5 → CJK UNIFIED IDEOGRAPH-9723	# 
+
+2F9F6 ;	29145 ;	MA	# ( 𩅅 → 𩅅 ) CJK COMPATIBILITY IDEOGRAPH-2F9F6 → CJK UNIFIED IDEOGRAPH-29145	# 
+
+F938 ;	9732 ;	MA	# ( 露 → 露 ) CJK COMPATIBILITY IDEOGRAPH-F938 → CJK UNIFIED IDEOGRAPH-9732	# 
+
+F9B3 ;	9748 ;	MA	# ( 靈 → 靈 ) CJK COMPATIBILITY IDEOGRAPH-F9B3 → CJK UNIFIED IDEOGRAPH-9748	# 
+
+2FAD ;	9751 ;	MA	#* ( ⾭ → 靑 ) KANGXI RADICAL BLUE → CJK UNIFIED IDEOGRAPH-9751	# 
+
+2ED8 ;	9752 ;	MA	#* ( ⻘ → 青 ) CJK RADICAL BLUE → CJK UNIFIED IDEOGRAPH-9752	# 
+
+FA1C ;	9756 ;	MA	# ( 靖 → 靖 ) CJK COMPATIBILITY IDEOGRAPH-FA1C → CJK UNIFIED IDEOGRAPH-9756	# 
+FAC8 ;	9756 ;	MA	# ( 靖 → 靖 ) CJK COMPATIBILITY IDEOGRAPH-FAC8 → CJK UNIFIED IDEOGRAPH-9756	# 
+
+2F81C ;	291DF ;	MA	# ( 𩇟 → 𩇟 ) CJK COMPATIBILITY IDEOGRAPH-2F81C → CJK UNIFIED IDEOGRAPH-291DF	# 
+
+2FAE ;	975E ;	MA	#* ( ⾮ → 非 ) KANGXI RADICAL WRONG → CJK UNIFIED IDEOGRAPH-975E	# 
+
+2FAF ;	9762 ;	MA	#* ( ⾯ → 面 ) KANGXI RADICAL FACE → CJK UNIFIED IDEOGRAPH-9762	# 
+
+2F9F7 ;	2921A ;	MA	# ( 𩈚 → 𩈚 ) CJK COMPATIBILITY IDEOGRAPH-2F9F7 → CJK UNIFIED IDEOGRAPH-2921A	# 
+
+2FB0 ;	9769 ;	MA	#* ( ⾰ → 革 ) KANGXI RADICAL LEATHER → CJK UNIFIED IDEOGRAPH-9769	# 
+
+2F9F8 ;	4A6E ;	MA	# ( 䩮 → 䩮 ) CJK COMPATIBILITY IDEOGRAPH-2F9F8 → CJK UNIFIED IDEOGRAPH-4A6E	# 
+
+2F9F9 ;	4A76 ;	MA	# ( 䩶 → 䩶 ) CJK COMPATIBILITY IDEOGRAPH-2F9F9 → CJK UNIFIED IDEOGRAPH-4A76	# 
+
+2FB1 ;	97CB ;	MA	#* ( ⾱ → 韋 ) KANGXI RADICAL TANNED LEATHER → CJK UNIFIED IDEOGRAPH-97CB	# 
+
+2ED9 ;	97E6 ;	MA	#* ( ⻙ → 韦 ) CJK RADICAL C-SIMPLIFIED TANNED LEATHER → CJK UNIFIED IDEOGRAPH-97E6	# 
+
+FAC9 ;	97DB ;	MA	# ( 韛 → 韛 ) CJK COMPATIBILITY IDEOGRAPH-FAC9 → CJK UNIFIED IDEOGRAPH-97DB	# 
+
+2F9FA ;	97E0 ;	MA	# ( 韠 → 韠 ) CJK COMPATIBILITY IDEOGRAPH-2F9FA → CJK UNIFIED IDEOGRAPH-97E0	# 
+
+2FB2 ;	97ED ;	MA	#* ( ⾲ → 韭 ) KANGXI RADICAL LEEK → CJK UNIFIED IDEOGRAPH-97ED	# 
+
+2F9FB ;	2940A ;	MA	# ( 𩐊 → 𩐊 ) CJK COMPATIBILITY IDEOGRAPH-2F9FB → CJK UNIFIED IDEOGRAPH-2940A	# 
+
+2FB3 ;	97F3 ;	MA	#* ( ⾳ → 音 ) KANGXI RADICAL SOUND → CJK UNIFIED IDEOGRAPH-97F3	# 
+
+FA69 ;	97FF ;	MA	# ( 響 → 響 ) CJK COMPATIBILITY IDEOGRAPH-FA69 → CJK UNIFIED IDEOGRAPH-97FF	# 
+FACA ;	97FF ;	MA	# ( 響 → 響 ) CJK COMPATIBILITY IDEOGRAPH-FACA → CJK UNIFIED IDEOGRAPH-97FF	# 
+
+2FB4 ;	9801 ;	MA	#* ( ⾴ → 頁 ) KANGXI RADICAL LEAF → CJK UNIFIED IDEOGRAPH-9801	# 
+
+2EDA ;	9875 ;	MA	#* ( ⻚ → 页 ) CJK RADICAL C-SIMPLIFIED LEAF → CJK UNIFIED IDEOGRAPH-9875	# 
+
+2F9FC ;	4AB2 ;	MA	# ( 䪲 → 䪲 ) CJK COMPATIBILITY IDEOGRAPH-2F9FC → CJK UNIFIED IDEOGRAPH-4AB2	# 
+
+FACB ;	980B ;	MA	# ( 頋 → 頋 ) CJK COMPATIBILITY IDEOGRAPH-FACB → CJK UNIFIED IDEOGRAPH-980B	# 
+2F9FE ;	980B ;	MA	# ( 頋 → 頋 ) CJK COMPATIBILITY IDEOGRAPH-2F9FE → CJK UNIFIED IDEOGRAPH-980B	# 
+2F9FF ;	980B ;	MA	# ( 頋 → 頋 ) CJK COMPATIBILITY IDEOGRAPH-2F9FF → CJK UNIFIED IDEOGRAPH-980B	# 
+
+F9B4 ;	9818 ;	MA	# ( 領 → 領 ) CJK COMPATIBILITY IDEOGRAPH-F9B4 → CJK UNIFIED IDEOGRAPH-9818	# 
+
+2FA00 ;	9829 ;	MA	# ( 頩 → 頩 ) CJK COMPATIBILITY IDEOGRAPH-2FA00 → CJK UNIFIED IDEOGRAPH-9829	# 
+
+2F9FD ;	29496 ;	MA	# ( 𩒖 → 𩒖 ) CJK COMPATIBILITY IDEOGRAPH-2F9FD → CJK UNIFIED IDEOGRAPH-29496	# 
+
+FA6A ;	983B ;	MA	# ( 頻 → 頻 ) CJK COMPATIBILITY IDEOGRAPH-FA6A → CJK UNIFIED IDEOGRAPH-983B	# 
+FACC ;	983B ;	MA	# ( 頻 → 頻 ) CJK COMPATIBILITY IDEOGRAPH-FACC → CJK UNIFIED IDEOGRAPH-983B	# 
+
+F9D0 ;	985E ;	MA	# ( 類 → 類 ) CJK COMPATIBILITY IDEOGRAPH-F9D0 → CJK UNIFIED IDEOGRAPH-985E	# 
+
+2FB5 ;	98A8 ;	MA	#* ( ⾵ → 風 ) KANGXI RADICAL WIND → CJK UNIFIED IDEOGRAPH-98A8	# 
+
+2EDB ;	98CE ;	MA	#* ( ⻛ → 风 ) CJK RADICAL C-SIMPLIFIED WIND → CJK UNIFIED IDEOGRAPH-98CE	# 
+
+2FA01 ;	295B6 ;	MA	# ( 𩖶 → 𩖶 ) CJK COMPATIBILITY IDEOGRAPH-2FA01 → CJK UNIFIED IDEOGRAPH-295B6	# 
+
+2FB6 ;	98DB ;	MA	#* ( ⾶ → 飛 ) KANGXI RADICAL FLY → CJK UNIFIED IDEOGRAPH-98DB	# 
+
+2EDC ;	98DE ;	MA	#* ( ⻜ → 飞 ) CJK RADICAL C-SIMPLIFIED FLY → CJK UNIFIED IDEOGRAPH-98DE	# 
+
+2EDD ;	98DF ;	MA	#* ( ⻝ → 食 ) CJK RADICAL EAT ONE → CJK UNIFIED IDEOGRAPH-98DF	# 
+2FB7 ;	98DF ;	MA	#* ( ⾷ → 食 ) KANGXI RADICAL EAT → CJK UNIFIED IDEOGRAPH-98DF	# 
+
+2EDF ;	98E0 ;	MA	#* ( ⻟ → 飠 ) CJK RADICAL EAT THREE → CJK UNIFIED IDEOGRAPH-98E0	# 
+
+2EE0 ;	9963 ;	MA	#* ( ⻠ → 饣 ) CJK RADICAL C-SIMPLIFIED EAT → CJK UNIFIED IDEOGRAPH-9963	# 
+
+2FA02 ;	98E2 ;	MA	# ( 飢 → 飢 ) CJK COMPATIBILITY IDEOGRAPH-2FA02 → CJK UNIFIED IDEOGRAPH-98E2	# 
+
+FA2A ;	98EF ;	MA	# ( 飯 → 飯 ) CJK COMPATIBILITY IDEOGRAPH-FA2A → CJK UNIFIED IDEOGRAPH-98EF	# 
+
+FA2B ;	98FC ;	MA	# ( 飼 → 飼 ) CJK COMPATIBILITY IDEOGRAPH-FA2B → CJK UNIFIED IDEOGRAPH-98FC	# 
+
+2FA03 ;	4B33 ;	MA	# ( 䬳 → 䬳 ) CJK COMPATIBILITY IDEOGRAPH-2FA03 → CJK UNIFIED IDEOGRAPH-4B33	# 
+
+FA2C ;	9928 ;	MA	# ( 館 → 館 ) CJK COMPATIBILITY IDEOGRAPH-FA2C → CJK UNIFIED IDEOGRAPH-9928	# 
+
+2FA04 ;	9929 ;	MA	# ( 餩 → 餩 ) CJK COMPATIBILITY IDEOGRAPH-2FA04 → CJK UNIFIED IDEOGRAPH-9929	# 
+
+2FB8 ;	9996 ;	MA	#* ( ⾸ → 首 ) KANGXI RADICAL HEAD → CJK UNIFIED IDEOGRAPH-9996	# 
+
+2FB9 ;	9999 ;	MA	#* ( ⾹ → 香 ) KANGXI RADICAL FRAGRANT → CJK UNIFIED IDEOGRAPH-9999	# 
+
+2FA05 ;	99A7 ;	MA	# ( 馧 → 馧 ) CJK COMPATIBILITY IDEOGRAPH-2FA05 → CJK UNIFIED IDEOGRAPH-99A7	# 
+
+2FBA ;	99AC ;	MA	#* ( ⾺ → 馬 ) KANGXI RADICAL HORSE → CJK UNIFIED IDEOGRAPH-99AC	# 
+
+2EE2 ;	9A6C ;	MA	#* ( ⻢ → 马 ) CJK RADICAL C-SIMPLIFIED HORSE → CJK UNIFIED IDEOGRAPH-9A6C	# 
+
+2FA06 ;	99C2 ;	MA	# ( 駂 → 駂 ) CJK COMPATIBILITY IDEOGRAPH-2FA06 → CJK UNIFIED IDEOGRAPH-99C2	# 
+
+F91A ;	99F1 ;	MA	# ( 駱 → 駱 ) CJK COMPATIBILITY IDEOGRAPH-F91A → CJK UNIFIED IDEOGRAPH-99F1	# 
+
+2FA07 ;	99FE ;	MA	# ( 駾 → 駾 ) CJK COMPATIBILITY IDEOGRAPH-2FA07 → CJK UNIFIED IDEOGRAPH-99FE	# 
+
+F987 ;	9A6A ;	MA	# ( 驪 → 驪 ) CJK COMPATIBILITY IDEOGRAPH-F987 → CJK UNIFIED IDEOGRAPH-9A6A	# 
+
+2FBB ;	9AA8 ;	MA	#* ( ⾻ → 骨 ) KANGXI RADICAL BONE → CJK UNIFIED IDEOGRAPH-9AA8	# 
+
+2FA08 ;	4BCE ;	MA	# ( 䯎 → 䯎 ) CJK COMPATIBILITY IDEOGRAPH-2FA08 → CJK UNIFIED IDEOGRAPH-4BCE	# 
+
+2FBC ;	9AD8 ;	MA	#* ( ⾼ → 高 ) KANGXI RADICAL TALL → CJK UNIFIED IDEOGRAPH-9AD8	# 
+
+2FBD ;	9ADF ;	MA	#* ( ⾽ → 髟 ) KANGXI RADICAL HAIR → CJK UNIFIED IDEOGRAPH-9ADF	# 
+
+2FA09 ;	29B30 ;	MA	# ( 𩬰 → 𩬰 ) CJK COMPATIBILITY IDEOGRAPH-2FA09 → CJK UNIFIED IDEOGRAPH-29B30	# 
+
+FACD ;	9B12 ;	MA	# ( 鬒 → 鬒 ) CJK COMPATIBILITY IDEOGRAPH-FACD → CJK UNIFIED IDEOGRAPH-9B12	# 
+2FA0A ;	9B12 ;	MA	# ( 鬒 → 鬒 ) CJK COMPATIBILITY IDEOGRAPH-2FA0A → CJK UNIFIED IDEOGRAPH-9B12	# 
+
+2FBE ;	9B25 ;	MA	#* ( ⾾ → 鬥 ) KANGXI RADICAL FIGHT → CJK UNIFIED IDEOGRAPH-9B25	# 
+
+2FBF ;	9B2F ;	MA	#* ( ⾿ → 鬯 ) KANGXI RADICAL SACRIFICIAL WINE → CJK UNIFIED IDEOGRAPH-9B2F	# 
+
+2FC0 ;	9B32 ;	MA	#* ( ⿀ → 鬲 ) KANGXI RADICAL CAULDRON → CJK UNIFIED IDEOGRAPH-9B32	# 
+
+2FC1 ;	9B3C ;	MA	#* ( ⿁ → 鬼 ) KANGXI RADICAL GHOST → CJK UNIFIED IDEOGRAPH-9B3C	# 
+2EE4 ;	9B3C ;	MA	#* ( ⻤ → 鬼 ) CJK RADICAL GHOST → CJK UNIFIED IDEOGRAPH-9B3C	# 
+
+2FC2 ;	9B5A ;	MA	#* ( ⿂ → 魚 ) KANGXI RADICAL FISH → CJK UNIFIED IDEOGRAPH-9B5A	# 
+
+2EE5 ;	9C7C ;	MA	#* ( ⻥ → 鱼 ) CJK RADICAL C-SIMPLIFIED FISH → CJK UNIFIED IDEOGRAPH-9C7C	# 
+
+F939 ;	9B6F ;	MA	# ( 魯 → 魯 ) CJK COMPATIBILITY IDEOGRAPH-F939 → CJK UNIFIED IDEOGRAPH-9B6F	# 
+
+2FA0B ;	9C40 ;	MA	# ( 鱀 → 鱀 ) CJK COMPATIBILITY IDEOGRAPH-2FA0B → CJK UNIFIED IDEOGRAPH-9C40	# 
+
+F9F2 ;	9C57 ;	MA	# ( 鱗 → 鱗 ) CJK COMPATIBILITY IDEOGRAPH-F9F2 → CJK UNIFIED IDEOGRAPH-9C57	# 
+
+2FC3 ;	9CE5 ;	MA	#* ( ⿃ → 鳥 ) KANGXI RADICAL BIRD → CJK UNIFIED IDEOGRAPH-9CE5	# 
+
+2FA0C ;	9CFD ;	MA	# ( 鳽 → 鳽 ) CJK COMPATIBILITY IDEOGRAPH-2FA0C → CJK UNIFIED IDEOGRAPH-9CFD	# 
+
+2FA0D ;	4CCE ;	MA	# ( 䳎 → 䳎 ) CJK COMPATIBILITY IDEOGRAPH-2FA0D → CJK UNIFIED IDEOGRAPH-4CCE	# 
+
+9E43 ;	9E42 ;	MA	# ( 鹃 → 鹂 ) CJK UNIFIED IDEOGRAPH-9E43 → CJK UNIFIED IDEOGRAPH-9E42	# 
+
+2FA0F ;	9D67 ;	MA	# ( 鵧 → 鵧 ) CJK COMPATIBILITY IDEOGRAPH-2FA0F → CJK UNIFIED IDEOGRAPH-9D67	# 
+
+2FA0E ;	4CED ;	MA	# ( 䳭 → 䳭 ) CJK COMPATIBILITY IDEOGRAPH-2FA0E → CJK UNIFIED IDEOGRAPH-4CED	# 
+
+2FA10 ;	2A0CE ;	MA	# ( 𪃎 → 𪃎 ) CJK COMPATIBILITY IDEOGRAPH-2FA10 → CJK UNIFIED IDEOGRAPH-2A0CE	# 
+
+FA2D ;	9DB4 ;	MA	# ( 鶴 → 鶴 ) CJK COMPATIBILITY IDEOGRAPH-FA2D → CJK UNIFIED IDEOGRAPH-9DB4	# 
+
+2FA12 ;	2A105 ;	MA	# ( 𪄅 → 𪄅 ) CJK COMPATIBILITY IDEOGRAPH-2FA12 → CJK UNIFIED IDEOGRAPH-2A105	# 
+
+2FA11 ;	4CF8 ;	MA	# ( 䳸 → 䳸 ) CJK COMPATIBILITY IDEOGRAPH-2FA11 → CJK UNIFIED IDEOGRAPH-4CF8	# 
+
+F93A ;	9DFA ;	MA	# ( 鷺 → 鷺 ) CJK COMPATIBILITY IDEOGRAPH-F93A → CJK UNIFIED IDEOGRAPH-9DFA	# 
+
+2FA13 ;	2A20E ;	MA	# ( 𪈎 → 𪈎 ) CJK COMPATIBILITY IDEOGRAPH-2FA13 → CJK UNIFIED IDEOGRAPH-2A20E	# 
+
+F920 ;	9E1E ;	MA	# ( 鸞 → 鸞 ) CJK COMPATIBILITY IDEOGRAPH-F920 → CJK UNIFIED IDEOGRAPH-9E1E	# 
+
+2FC4 ;	9E75 ;	MA	#* ( ⿄ → 鹵 ) KANGXI RADICAL SALT → CJK UNIFIED IDEOGRAPH-9E75	# 
+
+F940 ;	9E7F ;	MA	# ( 鹿 → 鹿 ) CJK COMPATIBILITY IDEOGRAPH-F940 → CJK UNIFIED IDEOGRAPH-9E7F	# 
+2FC5 ;	9E7F ;	MA	#* ( ⿅ → 鹿 ) KANGXI RADICAL DEER → CJK UNIFIED IDEOGRAPH-9E7F	# 
+
+2FA14 ;	2A291 ;	MA	# ( 𪊑 → 𪊑 ) CJK COMPATIBILITY IDEOGRAPH-2FA14 → CJK UNIFIED IDEOGRAPH-2A291	# 
+
+F988 ;	9E97 ;	MA	# ( 麗 → 麗 ) CJK COMPATIBILITY IDEOGRAPH-F988 → CJK UNIFIED IDEOGRAPH-9E97	# 
+
+F9F3 ;	9E9F ;	MA	# ( 麟 → 麟 ) CJK COMPATIBILITY IDEOGRAPH-F9F3 → CJK UNIFIED IDEOGRAPH-9E9F	# 
+
+2FC6 ;	9EA5 ;	MA	#* ( ⿆ → 麥 ) KANGXI RADICAL WHEAT → CJK UNIFIED IDEOGRAPH-9EA5	# 
+
+2EE8 ;	9EA6 ;	MA	#* ( ⻨ → 麦 ) CJK RADICAL SIMPLIFIED WHEAT → CJK UNIFIED IDEOGRAPH-9EA6	# 
+
+2FA15 ;	9EBB ;	MA	# ( 麻 → 麻 ) CJK COMPATIBILITY IDEOGRAPH-2FA15 → CJK UNIFIED IDEOGRAPH-9EBB	# 
+2FC7 ;	9EBB ;	MA	#* ( ⿇ → 麻 ) KANGXI RADICAL HEMP → CJK UNIFIED IDEOGRAPH-9EBB	# 
+
+2F88F ;	2A392 ;	MA	# ( 𪎒 → 𪎒 ) CJK COMPATIBILITY IDEOGRAPH-2F88F → CJK UNIFIED IDEOGRAPH-2A392	# 
+
+2FC8 ;	9EC3 ;	MA	#* ( ⿈ → 黃 ) KANGXI RADICAL YELLOW → CJK UNIFIED IDEOGRAPH-9EC3	# 
+
+2EE9 ;	9EC4 ;	MA	#* ( ⻩ → 黄 ) CJK RADICAL SIMPLIFIED YELLOW → CJK UNIFIED IDEOGRAPH-9EC4	# 
+
+2FC9 ;	9ECD ;	MA	#* ( ⿉ → 黍 ) KANGXI RADICAL MILLET → CJK UNIFIED IDEOGRAPH-9ECD	# 
+
+F989 ;	9ECE ;	MA	# ( 黎 → 黎 ) CJK COMPATIBILITY IDEOGRAPH-F989 → CJK UNIFIED IDEOGRAPH-9ECE	# 
+
+2FA16 ;	4D56 ;	MA	# ( 䵖 → 䵖 ) CJK COMPATIBILITY IDEOGRAPH-2FA16 → CJK UNIFIED IDEOGRAPH-4D56	# 
+
+2FCA ;	9ED1 ;	MA	#* ( ⿊ → 黑 ) KANGXI RADICAL BLACK → CJK UNIFIED IDEOGRAPH-9ED1	# 
+9ED2 ;	9ED1 ;	MA	# ( 黒 → 黑 ) CJK UNIFIED IDEOGRAPH-9ED2 → CJK UNIFIED IDEOGRAPH-9ED1	# →⿊→
+
+FA3A ;	58A8 ;	MA	# ( 墨 → 墨 ) CJK COMPATIBILITY IDEOGRAPH-FA3A → CJK UNIFIED IDEOGRAPH-58A8	# 
+
+2FA17 ;	9EF9 ;	MA	# ( 黹 → 黹 ) CJK COMPATIBILITY IDEOGRAPH-2FA17 → CJK UNIFIED IDEOGRAPH-9EF9	# 
+2FCB ;	9EF9 ;	MA	#* ( ⿋ → 黹 ) KANGXI RADICAL EMBROIDERY → CJK UNIFIED IDEOGRAPH-9EF9	# 
+
+2FCC ;	9EFD ;	MA	#* ( ⿌ → 黽 ) KANGXI RADICAL FROG → CJK UNIFIED IDEOGRAPH-9EFD	# 
+
+2FA18 ;	9EFE ;	MA	# ( 黾 → 黾 ) CJK COMPATIBILITY IDEOGRAPH-2FA18 → CJK UNIFIED IDEOGRAPH-9EFE	# 
+
+2FA19 ;	9F05 ;	MA	# ( 鼅 → 鼅 ) CJK COMPATIBILITY IDEOGRAPH-2FA19 → CJK UNIFIED IDEOGRAPH-9F05	# 
+
+2FCD ;	9F0E ;	MA	#* ( ⿍ → 鼎 ) KANGXI RADICAL TRIPOD → CJK UNIFIED IDEOGRAPH-9F0E	# 
+
+2FA1A ;	9F0F ;	MA	# ( 鼏 → 鼏 ) CJK COMPATIBILITY IDEOGRAPH-2FA1A → CJK UNIFIED IDEOGRAPH-9F0F	# 
+
+2FCE ;	9F13 ;	MA	#* ( ⿎ → 鼓 ) KANGXI RADICAL DRUM → CJK UNIFIED IDEOGRAPH-9F13	# 
+
+2FA1B ;	9F16 ;	MA	# ( 鼖 → 鼖 ) CJK COMPATIBILITY IDEOGRAPH-2FA1B → CJK UNIFIED IDEOGRAPH-9F16	# 
+
+2FCF ;	9F20 ;	MA	#* ( ⿏ → 鼠 ) KANGXI RADICAL RAT → CJK UNIFIED IDEOGRAPH-9F20	# 
+
+2FA1C ;	9F3B ;	MA	# ( 鼻 → 鼻 ) CJK COMPATIBILITY IDEOGRAPH-2FA1C → CJK UNIFIED IDEOGRAPH-9F3B	# 
+2FD0 ;	9F3B ;	MA	#* ( ⿐ → 鼻 ) KANGXI RADICAL NOSE → CJK UNIFIED IDEOGRAPH-9F3B	# 
+
+FAD8 ;	9F43 ;	MA	# ( 齃 → 齃 ) CJK COMPATIBILITY IDEOGRAPH-FAD8 → CJK UNIFIED IDEOGRAPH-9F43	# 
+
+2FD1 ;	9F4A ;	MA	#* ( ⿑ → 齊 ) KANGXI RADICAL EVEN → CJK UNIFIED IDEOGRAPH-9F4A	# 
+
+2EEC ;	9F50 ;	MA	#* ( ⻬ → 齐 ) CJK RADICAL C-SIMPLIFIED EVEN → CJK UNIFIED IDEOGRAPH-9F50	# 
+
+2FD2 ;	9F52 ;	MA	#* ( ⿒ → 齒 ) KANGXI RADICAL TOOTH → CJK UNIFIED IDEOGRAPH-9F52	# 
+
+2EEE ;	9F7F ;	MA	#* ( ⻮ → 齿 ) CJK RADICAL C-SIMPLIFIED TOOTH → CJK UNIFIED IDEOGRAPH-9F7F	# 
+
+2FA1D ;	2A600 ;	MA	# ( 𪘀 → 𪘀 ) CJK COMPATIBILITY IDEOGRAPH-2FA1D → CJK UNIFIED IDEOGRAPH-2A600	# 
+
+F9C4 ;	9F8D ;	MA	# ( 龍 → 龍 ) CJK COMPATIBILITY IDEOGRAPH-F9C4 → CJK UNIFIED IDEOGRAPH-9F8D	# 
+2FD3 ;	9F8D ;	MA	#* ( ⿓ → 龍 ) KANGXI RADICAL DRAGON → CJK UNIFIED IDEOGRAPH-9F8D	# 
+
+2EF0 ;	9F99 ;	MA	#* ( ⻰ → 龙 ) CJK RADICAL C-SIMPLIFIED DRAGON → CJK UNIFIED IDEOGRAPH-9F99	# 
+
+FAD9 ;	9F8E ;	MA	# ( 龎 → 龎 ) CJK COMPATIBILITY IDEOGRAPH-FAD9 → CJK UNIFIED IDEOGRAPH-9F8E	# 
+
+F907 ;	9F9C ;	MA	# ( 龜 → 龜 ) CJK COMPATIBILITY IDEOGRAPH-F907 → CJK UNIFIED IDEOGRAPH-9F9C	# 
+F908 ;	9F9C ;	MA	# ( 龜 → 龜 ) CJK COMPATIBILITY IDEOGRAPH-F908 → CJK UNIFIED IDEOGRAPH-9F9C	# 
+FACE ;	9F9C ;	MA	# ( 龜 → 龜 ) CJK COMPATIBILITY IDEOGRAPH-FACE → CJK UNIFIED IDEOGRAPH-9F9C	# 
+2FD4 ;	9F9C ;	MA	#* ( ⿔ → 龜 ) KANGXI RADICAL TURTLE → CJK UNIFIED IDEOGRAPH-9F9C	# 
+
+2EF3 ;	9F9F ;	MA	#* ( ⻳ → 龟 ) CJK RADICAL C-SIMPLIFIED TURTLE → CJK UNIFIED IDEOGRAPH-9F9F	# 
+
+2FD5 ;	9FA0 ;	MA	#* ( ⿕ → 龠 ) KANGXI RADICAL FLUTE → CJK UNIFIED IDEOGRAPH-9FA0	# 
+
+0CDC ;	0C5C ;	MA	# ( ೜ → ౜ ) KANNADA ARCHAIC SHRII → TELUGU ARCHAIC SHRII	# 
+
+1DE8 ;	1ADA ;	MA	# ( ᷨ → ᫚ ) COMBINING LATIN SMALL LETTER B → COMBINING FLAT SIGN	# 
+
+2DEE ;	1ADB ;	MA	# ( ⷮ → ᫛ ) COMBINING CYRILLIC LETTER TE → COMBINING DOWN TACK ABOVE	# 
+
+1AE7 ;	1AE5 ;	MA	# ( ᫧ → ᫥ ) COMBINING DOUBLE ARCH ABOVE → COMBINING SEAGULL ABOVE	# 
+
+031A ;	1AE9 ;	MA	# ( ̚ → ᫩ ) COMBINING LEFT ANGLE ABOVE → COMBINING LEFT ANGLE CENTRED ABOVE	# 
+
+0295 ;	A7CE ;	MA	# ( ʕ → ꟎ ) LATIN LETTER PHARYNGEAL VOICED FRICATIVE → LATIN CAPITAL LETTER PHARYNGEAL VOICED FRICATIVE	# 
+A7CF ;	A7CE ;	MA	# ( ꟏ → ꟎ ) LATIN SMALL LETTER PHARYNGEAL VOICED FRICATIVE → LATIN CAPITAL LETTER PHARYNGEAL VOICED FRICATIVE	# →ʕ→
+
+0348 ;	10EFA ;	MA	# ( ͈ → 𐻺 ) COMBINING DOUBLE VERTICAL LINE BELOW → ARABIC DOUBLE VERTICAL BAR BELOW	# 
+
+0956 ;	11B62 ;	MA	# ( ॖ → 𑭢 ) DEVANAGARI VOWEL SIGN UE → SHARADA VOWEL SIGN UE	# 
+0A41 ;	11B62 ;	MA	# ( ੁ → 𑭢 ) GURMUKHI VOWEL SIGN U → SHARADA VOWEL SIGN UE	# →ॖ→
+
+0957 ;	11B63 ;	MA	# ( ॗ → 𑭣 ) DEVANAGARI VOWEL SIGN UUE → SHARADA VOWEL SIGN UUE	# 
+0A42 ;	11B63 ;	MA	# ( ੂ → 𑭣 ) GURMUKHI VOWEL SIGN UU → SHARADA VOWEL SIGN UUE	# →ॗ→
+
+0947 ;	11B64 ;	MA	# ( े → 𑭤 ) DEVANAGARI VOWEL SIGN E → SHARADA VOWEL SIGN SHORT E	# 
+0A47 ;	11B64 ;	MA	# ( ੇ → 𑭤 ) GURMUKHI VOWEL SIGN EE → SHARADA VOWEL SIGN SHORT E	# →े→
+
+5152 ;	16FF3 ;	MA	# ( 兒 → 𖿳 ) CJK UNIFIED IDEOGRAPH-5152 → CHINESE SMALL TRADITIONAL ER	# 
+
+1F40D ;	1CCFA ;	MA	#* ( 🐍 → 𜳺 ) SNAKE → SNAKE SYMBOL	# 
+
+1F443 ;	1CCFC ;	MA	#* ( 👃 → 𜳼 ) NOSE → NOSE SYMBOL	# 
+
+1F377 ;	1CEBA ;	MA	#* ( 🍷 → 𜺺 ) WINE GLASS → FRAGILE SYMBOL	# 
+
+1F3E2 ;	1CEBB ;	MA	#* ( 🏢 → 𜺻 ) OFFICE BUILDING → OFFICE BUILDING SYMBOL	# 
+
+1F333 ;	1CEBC ;	MA	#* ( 🌳 → 𜺼 ) DECIDUOUS TREE → TREE SYMBOL	# 
+
+1F34E ;	1CEBD ;	MA	#* ( 🍎 → 𜺽 ) RED APPLE → APPLE SYMBOL	# 
+1F34F ;	1CEBD ;	MA	#* ( 🍏 → 𜺽 ) GREEN APPLE → APPLE SYMBOL	# 
+
+1F352 ;	1CEBE ;	MA	#* ( 🍒 → 𜺾 ) CHERRIES → CHERRY SYMBOL	# 
+
+1F353 ;	1CEBF ;	MA	#* ( 🍓 → 𜺿 ) STRAWBERRY → STRAWBERRY SYMBOL	# 
+
+28FF ;	1CEE0 ;	MA	#* ( ⣿ → 𜻠 ) BRAILLE PATTERN DOTS-12345678 → GEOMANTIC FIGURE POPULUS	# 
+
+29B5 ;	1CEF0 ;	MA	#* ( ⦵ → 𜻰 ) CIRCLE WITH HORIZONTAL BAR → MEDIUM SMALL WHITE CIRCLE WITH HORIZONTAL BAR	# 
+
+21C4 ;	1F8D0 ;	MA	#* ( ⇄ → 🣐 ) RIGHTWARDS ARROW OVER LEFTWARDS ARROW → LONG RIGHTWARDS ARROW OVER LONG LEFTWARDS ARROW	# 
+
+21CC ;	1F8D1 ;	MA	#* ( ⇌ → 🣑 ) RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON → LONG RIGHTWARDS HARPOON OVER LONG LEFTWARDS HARPOON	# 
+
+2657 ;	1FA55 ;	MA	#* ( ♗ → 🩕 ) WHITE CHESS BISHOP → WHITE CHESS ALFIL	# 
+
+265D ;	1FA57 ;	MA	#* ( ♝ → 🩗 ) BLACK CHESS BISHOP → BLACK CHESS ALFIL	# 
+
+1F514 ;	1FBFA ;	MA	#* ( 🔔 → 🯺 ) BELL → ALARM BELL SYMBOL	# 
+
+6138 ;	2B73F ;	MA	# ( 愸 → 𫜿 ) CJK UNIFIED IDEOGRAPH-6138 → CJK UNIFIED IDEOGRAPH-2B73F	# 
+
+# total: 6565
+
diff --git a/lib/elixir/unicode/security.ex b/lib/elixir/unicode/security.ex
new file mode 100644
index 00000000000..f1069768915
--- /dev/null
+++ b/lib/elixir/unicode/security.ex
@@ -0,0 +1,193 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule String.Tokenizer.Security do
+  @moduledoc false
+
+  # UTS39 security checks that operate on all tokens in a file,
+  # like Confusables. If we add whole-file mixed-script-confusable-characters
+  # checks we can add them to the list of lints here
+  def unicode_lint_warnings(tokens) do
+    for warning <- confusables(tokens),
+        do: format_warning(warning)
+  end
+
+  defp format_warning({token, reason}) do
+    {_, {line, col, _}, _} = token
+    {{line, col}, to_charlist(reason)}
+  end
+
+  ## Confusables
+
+  defp confusables(tokens) do
+    {_, warnings} =
+      for token <- tokens, reduce: {%{}, []} do
+        {skeletons, warnings} ->
+          case check_token_for_confusability(token, skeletons) do
+            {:ok, skeletons} -> {skeletons, warnings}
+            {:warn, reason} -> {skeletons, [{token, reason} | warnings]}
+          end
+      end
+
+    warnings
+  end
+
+  @identifiers [
+    :identifier,
+    :op_identifier,
+    :kw_identifier,
+    :paren_identifier,
+    :bracket_identifier,
+    :alias,
+    :atom
+  ]
+
+  defp check_token_for_confusability(
+         {kind, {_line, _column, [_ | _] = name} = info, _},
+         skeletons
+       )
+       when kind in @identifiers do
+    skeleton = confusable_skeleton(name)
+
+    case skeletons[skeleton] do
+      {_, _, ^name} ->
+        {:ok, skeletons}
+
+      {line, _, previous_name} when name != previous_name ->
+        {:warn,
+         "confusable identifier: '#{name}' looks like '#{previous_name}' on line #{line}, " <>
+           "but they are written using different characters" <> dir_compare(name, previous_name)}
+
+      _ ->
+        {:ok, Map.put(skeletons, skeleton, info)}
+    end
+  end
+
+  defp check_token_for_confusability(_token, skeletons), do: {:ok, skeletons}
+
+  # AAAA ;   BBBB CCCC DDDDD ;
+  # ^ char   ^ prototypical char or sequence of chars it can be confused with
+  confusables_path = "confusables.txt"
+
+  lines =
+    Path.join(__DIR__, confusables_path)
+    |> File.read!()
+    |> String.split(["\r\n", "\n"], trim: true)
+
+  regex = ~r/^((?:[0-9A-F]+ )+);\t((?:[0-9A-F]+ )+);/u
+  matches = Enum.map(lines, &Regex.run(regex, &1, capture: :all_but_first))
+
+  confusable_prototype_lookup =
+    for [confusable_str, prototype_str] <- matches, reduce: %{} do
+      acc ->
+        confusable = String.to_integer(String.trim(confusable_str), 16)
+
+        if Map.has_key?(acc, confusable) or
+             confusable in ?A..?Z or confusable in ?a..?z or confusable in ?0..?9 do
+          acc
+        else
+          prototype =
+            prototype_str
+            |> String.split(" ", trim: true)
+            |> Enum.map(&String.to_integer(&1, 16))
+
+          Map.put(acc, confusable, prototype)
+        end
+    end
+
+  for {confusable, prototype} <- confusable_prototype_lookup do
+    defp confusable_prototype(unquote(confusable)) do
+      unquote(prototype)
+    end
+  end
+
+  defp confusable_prototype(other), do: <<other::utf8>>
+
+  def confusable_skeleton(s) do
+    # "- Convert X to NFD format, as described in [UAX15].
+    #  - Concatenate the prototypes for each character in X according to
+    #    the specified data, producing a string of exemplar characters.
+    #  - Reapply NFD." (UTS 39 section 4, skeleton definition)
+    :unicode.characters_to_nfd_list(s)
+    |> bidi_skeleton()
+    |> :unicode.characters_to_nfd_list()
+  end
+
+  # Unicode 15 adds bidiSkeleton because, w/RTL codepoints, idents that
+  # aren't confusable LTR *are* confusable in most places human review
+  # occurs (editors/browsers, thanks to bidi algo, UAX9).
+  #
+  # The solution is to detect spans with reversed visual direction,
+  # and reverse those, so that the input we check for confusability
+  # matches the perceived sequence instead of the byte sequence.
+  #
+  # (we need this regardless of script mixing, because direction-neutral
+  # chars like _ or 0..9 can mix w/RTL chars).
+  def bidi_skeleton(s) do
+    # UTS39-28 4:
+    #
+    # Bidirectional confusability is costlier to check than
+    # confusability, as [unicode bidi algo] must be applied.
+    # [...] a fast path can be used: [...] if X has no characters
+    # w/bidi classes R or AL, bidiSkeleton(X) = skeleton(X)
+    if match?([_, _ | _], s) and any_rtl?(s) do
+      unbidify(s) |> Enum.map(&confusable_prototype/1)
+    else
+      Enum.map(s, &confusable_prototype/1)
+    end
+  end
+
+  defp any_rtl?(s), do: Enum.any?(s, &(:rtl == String.Tokenizer.dir(&1)))
+
+  defp dir_compare(a, b) do
+    """
+    #{if any_rtl?(a), do: "\n\n" <> dir_breakdown(a)}
+    #{if any_rtl?(b), do: dir_breakdown(b)}
+    """
+  end
+
+  defp dir_breakdown(s) do
+    init = "'#{s}' includes right-to-left characters:\n"
+
+    init <>
+      for codepoint <- s, into: "" do
+        hex = :io_lib.format(~c"~4.16.0B", [codepoint])
+        "  \\u#{hex} #{[codepoint]} #{String.Tokenizer.dir(codepoint)}\n"
+      end
+  end
+
+  # make charlist match visual order by reversing spans of {rtl, neutral}
+  # and attaching neutral characters and weak number types according to uax9
+  #
+  #  UTS39-28 4: '[...] if the strings are known not to contain explicit
+  #   directional formatting characters[...], the algorithm can
+  #   be drastically simplified, [...], obviating the need for
+  #   the [...] stack of the [unicode bidi algo]'
+  def unbidify(chars) when is_list(chars) do
+    {neutrals, direction, last_part, acc} =
+      Enum.reduce(chars, {[], :ltr, [], []}, fn head, {neutrals, part_dir, part, acc} ->
+        # https://www.unicode.org/reports/tr9/#W2
+        case String.Tokenizer.dir(head) do
+          :weak_number ->
+            {[], part_dir, [head] ++ neutrals ++ part, acc}
+
+          :neutral ->
+            {[head | neutrals], part_dir, part, acc}
+
+          ^part_dir ->
+            {[], part_dir, [head | neutrals] ++ part, acc}
+
+          :ltr when part_dir == :rtl ->
+            {[], :ltr, [head | neutrals], Enum.reverse(part, acc)}
+
+          :rtl when part_dir == :ltr ->
+            {[], :rtl, [head], neutrals ++ part ++ acc}
+        end
+      end)
+
+    case direction do
+      :ltr -> Enum.reverse(acc, Enum.reverse(neutrals ++ last_part))
+      :rtl -> Enum.reverse(acc, neutrals ++ last_part)
+    end
+  end
+end
diff --git a/lib/elixir/unicode/tokenizer.ex b/lib/elixir/unicode/tokenizer.ex
new file mode 100644
index 00000000000..9e612812346
--- /dev/null
+++ b/lib/elixir/unicode/tokenizer.ex
@@ -0,0 +1,549 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule String.Tokenizer do
+  @moduledoc false
+
+  ## Custom normalization definitions
+  #
+  # These codepoints will be normalized from => to, and their
+  # scriptset will be the union of both. If one of the two
+  # codepoints is Script='Common|Inherited', this means both
+  # codepoints can be used anywhere without unsafe script mixing;
+  # similarly, they are exempted from the Restricted list.
+  #
+  start_normalizations = %{
+    # NFKC-based automatic normalizations
+    # U+00B5 => U+03BC
+    ?µ => ?μ
+  }
+
+  normalizations = start_normalizations
+
+  ##
+  ## First let's load all characters that we will allow in identifiers
+  ##
+
+  range_to_codepoints = fn range ->
+    case :binary.split(String.trim(range), "..") do
+      [a] -> [String.to_integer(a, 16)]
+      [a, b] -> Enum.to_list(String.to_integer(a, 16)..String.to_integer(b, 16))
+    end
+  end
+
+  {letter_uptitlecase, start, continue, dir_rtls, dir_neutrals, _} =
+    Path.join(__DIR__, "UnicodeData.txt")
+    |> File.read!()
+    |> String.split(["\r\n", "\n"], trim: true)
+    |> Enum.reduce({[], [], [], [], [], nil}, fn line, acc ->
+      {letter_uptitlecase, start, continue, rtls, neutrals, first} = acc
+
+      # https://www.unicode.org/reports/tr44/tr44-32.html#UnicodeData.txt
+      [codepoint, line] = :binary.split(line, ";")
+      [name, line] = :binary.split(line, ";")
+      [category, line] = :binary.split(line, ";")
+      [_canonical_combining, line] = :binary.split(line, ";")
+      [bidi, _] = :binary.split(line, ";")
+
+      {codepoints, first} =
+        case name do
+          "<" <> _ when is_integer(first) ->
+            last = String.to_integer(codepoint, 16)
+            {Enum.to_list(last..first//-1), nil}
+
+          "<" <> _ ->
+            first = String.to_integer(codepoint, 16)
+            {[first], first + 1}
+
+          _ ->
+            {[String.to_integer(codepoint, 16)], nil}
+        end
+
+      {rtls, neutrals} =
+        cond do
+          bidi in ~w(R AL)s -> {codepoints ++ rtls, neutrals}
+          bidi in ~w(WS ON CS EN ES ET NSM)s -> {rtls, codepoints ++ neutrals}
+          true -> {rtls, neutrals}
+        end
+
+      cond do
+        category in ~w(Lu Lt) ->
+          {codepoints ++ letter_uptitlecase, start, continue, rtls, neutrals, first}
+
+        category in ~w(Ll Lm Lo Nl) ->
+          {letter_uptitlecase, codepoints ++ start, continue, rtls, neutrals, first}
+
+        category in ~w(Mn Mc Nd Pc) ->
+          {letter_uptitlecase, start, codepoints ++ continue, rtls, neutrals, first}
+
+        true ->
+          {letter_uptitlecase, start, continue, rtls, neutrals, first}
+      end
+    end)
+
+  # Each character is classified accordingly
+
+  {start, continue, patterns} =
+    Path.join(__DIR__, "PropList.txt")
+    |> File.read!()
+    |> String.split(["\r\n", "\n"], trim: true)
+    |> Enum.reduce({start, continue, []}, fn line, acc ->
+      [range | category] = :binary.split(line, ";")
+
+      pos =
+        case category do
+          [" Other_ID_Start" <> _] -> 0
+          [" Other_ID_Continue" <> _] -> 1
+          [" Pattern_White_Space" <> _] -> 2
+          [" Pattern_Syntax" <> _] -> 2
+          _ -> -1
+        end
+
+      if pos >= 0 do
+        put_elem(acc, pos, range_to_codepoints.(range) ++ elem(acc, pos))
+      else
+        acc
+      end
+    end)
+
+  # Also restrict characters for security purposes according to UTS 39
+
+  restricted =
+    Path.join(__DIR__, "IdentifierType.txt")
+    |> File.read!()
+    |> String.split(["\r\n", "\n"], trim: true)
+    |> Enum.flat_map(fn line ->
+      with [range, type_with_comments] <- :binary.split(line, ";"),
+           [types, _comments] <- :binary.split(type_with_comments, "#"),
+           types = String.split(types, " ", trim: true),
+           false <- "Inclusion" in types or "Recommended" in types do
+        range_to_codepoints.(range)
+      else
+        _ -> []
+      end
+    end)
+
+  id_upper = (letter_uptitlecase -- patterns) -- restricted
+  id_start = (start -- patterns) -- restricted
+  id_continue = (continue -- patterns) -- restricted
+
+  unicode_upper = Enum.filter(id_upper, &(&1 > 127))
+  unicode_start = Enum.filter(id_start, &(&1 > 127))
+  unicode_continue = Enum.filter(id_continue, &(&1 > 127))
+
+  unicode_all = Map.from_keys(unicode_upper ++ unicode_start ++ unicode_continue, [])
+
+  IO.puts(:stderr, "[Unicode] Tokenizing #{map_size(unicode_all)} non-ascii codepoints")
+
+  ##
+  ## Compute scriptsets for all characters above
+  ##
+
+  # 3 text files from UAX24 (Scripts):
+  #
+  # 1. Scripts.txt               codepoint => primary script (by full name)
+  # 2. ScriptExtensions.txt      codepoint => N scripts, (by short names)
+  # 3. PropertyValueAliases.txt  short names <=> long names mapping
+
+  # First we'll build a lookup of short <=> long names, starting with
+  # names that we will make part of the highly restricted set later.
+  script_aliases =
+    Path.join(__DIR__, "PropertyValueAliases.txt")
+    |> File.read!()
+    |> String.split(["\r\n", "\n"], trim: true)
+    |> Enum.flat_map(fn line ->
+      case String.split(line, [";", " "], trim: true) do
+        ["sc", short, long | _] -> [{short, long}]
+        _ -> []
+      end
+    end)
+    |> Map.new()
+
+  # Now we will compute all used scriptsets as well as
+  # a mapping from codepoint to scriptsets.
+  codepoints_to_scriptset = fn file, aliases ->
+    Path.join(__DIR__, file)
+    |> File.read!()
+    |> String.split(["\r\n", "\n"], trim: true)
+    |> Enum.flat_map(fn line ->
+      with [range, scripts_with_comments] <- :binary.split(line, ";"),
+           [scripts, _comments] <- :binary.split(scripts_with_comments, "#"),
+           scripts =
+             scripts |> String.split(" ", trim: true) |> Enum.map(&Map.get(aliases, &1, &1)) do
+        for codepoint <- range_to_codepoints.(range),
+            Map.has_key?(unicode_all, codepoint) and
+              "Common" not in scripts and "Inherited" not in scripts,
+            do: {codepoint, scripts}
+      else
+        _ -> []
+      end
+    end)
+  end
+
+  scripts = codepoints_to_scriptset.("Scripts.txt", %{})
+  script_extensions = codepoints_to_scriptset.("ScriptExtensions.txt", script_aliases)
+  all_codepoints_to_scriptset = scripts ++ script_extensions
+
+  all_scriptsets =
+    all_codepoints_to_scriptset
+    |> Enum.flat_map(&elem(&1, 1))
+    |> Enum.uniq()
+    |> then(&(["Han with Bopomofo", "Japanese", "Korean"] ++ &1))
+
+  # We will represent scriptsets using a bitmap. So let's define
+  # a separate module for said operations. We will also sort the
+  # scriptsets and make Latin the first one for convenience.
+
+  defmodule ScriptSet do
+    @moduledoc false
+    def from_index(idx), do: :erlang.bsl(1, idx)
+    def lattices(size), do: {0, trunc(:math.pow(2, size)) - 1}
+    def union(left, right), do: :erlang.bor(left, right)
+
+    def to_indexes(set) do
+      for {?1, index} <- set |> Integer.to_charlist(2) |> Enum.reverse() |> Enum.with_index() do
+        index
+      end
+    end
+  end
+
+  sorted_scriptsets = ["Latin" | all_scriptsets |> List.delete("Latin") |> Enum.sort()]
+
+  scriptset_masks =
+    sorted_scriptsets
+    |> Enum.with_index(fn scriptset, index ->
+      {scriptset, ScriptSet.from_index(index)}
+    end)
+    |> Map.new()
+
+  # Some scriptsets must be augmented according to the rules below,
+  # see https://www.unicode.org/reports/tr39/
+  #
+  # Note, however, Bopo(mofo) characters are not actually tokenized,
+  # as it is not in the list of recommended scriptsets.
+  augmentation_rules = %{
+    "Han" => ["Han with Bopomofo", "Japanese", "Korean"],
+    "Hiragana" => ["Japanese"],
+    "Katakana" => ["Japanese"],
+    "Hangul" => ["Korean"],
+    "Bopomofo" => ["Han with Bopomofo"]
+  }
+
+  scriptset_masks =
+    for {key, additions} <- augmentation_rules, reduce: scriptset_masks do
+      acc ->
+        Map.update!(acc, key, fn value ->
+          additions
+          |> Enum.map(&Map.fetch!(acc, &1))
+          |> Enum.reduce(value, &ScriptSet.union/2)
+        end)
+    end
+
+  {bottom, top} = ScriptSet.lattices(map_size(scriptset_masks))
+  IO.puts(:stderr, "[Unicode] Tokenizing #{map_size(scriptset_masks)} scriptsets")
+
+  codepoints_to_mask =
+    for {codepoint, scriptsets} <- all_codepoints_to_scriptset, into: %{} do
+      {codepoint,
+       scriptsets
+       |> Enum.map(&Map.fetch!(scriptset_masks, &1))
+       |> Enum.reduce(bottom, &ScriptSet.union/2)}
+    end
+
+  # Add our custom normalizations
+
+  codepoints_to_mask =
+    for {from, to} <- normalizations, reduce: codepoints_to_mask do
+      acc ->
+        ss = ScriptSet.union(Map.get(acc, from, top), Map.get(acc, to, top))
+        Map.put(acc, to, ss)
+    end
+
+  ##
+  ## Define functions and module attributes to access characters and their scriptsets
+  ##
+
+  # bottom of bitmap == all bits are 0, no scripts in the scriptset
+  @bottom bottom
+  @latin 1
+  # top of bitmap (all bits are 1) is ALL in UTS39 ('Common', 'Inherited');
+  # a scriptset that will intersect with other all non-empty scriptsets
+  @top top
+  @indexed_scriptsets sorted_scriptsets |> Enum.with_index(&{&2, &1}) |> Map.new()
+
+  # ScriptSet helpers. Inline instead of dispatching to ScriptSet for performance
+
+  @compile {:inline, ss_latin: 1, ss_intersect: 2}
+  defp ss_latin(ss), do: :erlang.band(ss, @latin)
+  defp ss_intersect(left, right), do: :erlang.band(left, right)
+
+  # Ascii helpers
+
+  @compile {:inline, ascii_upper?: 1, ascii_lower?: 1, ascii_continue?: 1}
+  defp ascii_upper?(entry), do: entry >= ?A and entry <= ?Z
+  defp ascii_lower?(entry), do: entry >= ?a and entry <= ?z
+  defp ascii_continue?(entry), do: entry >= ?0 and entry <= ?9
+
+  # Unicode helpers
+  # We use ranges whenever possible to reduce bytecode size.
+
+  unicode_upper = Enum.map(unicode_upper, &{&1, Map.get(codepoints_to_mask, &1, top)})
+  unicode_start = Enum.map(unicode_start, &{&1, Map.get(codepoints_to_mask, &1, top)})
+  unicode_continue = Enum.map(unicode_continue, &{&1, Map.get(codepoints_to_mask, &1, top)})
+
+  rangify = fn [{head, scriptset} | tail] ->
+    {first, last, scriptset, acc} =
+      Enum.reduce(tail, {head, head, scriptset, []}, fn
+        {number, scriptset}, {first, last, scriptset, acc} when number == first - 1 ->
+          {number, last, scriptset, acc}
+
+        {number, scriptset}, {first, last, range_scriptset, acc} ->
+          {number, number, scriptset, [{first, last, range_scriptset} | acc]}
+      end)
+
+    [{first, last, scriptset} | acc]
+  end
+
+  for {first, last, scriptset} <- rangify.(unicode_upper) do
+    if first == last do
+      defp unicode_upper(unquote(first)), do: unquote(scriptset)
+    else
+      defp unicode_upper(entry) when entry in unquote(first)..unquote(last),
+        do: unquote(scriptset)
+    end
+  end
+
+  defp unicode_upper(_), do: @bottom
+
+  for {first, last, scriptset} <- rangify.(unicode_start) do
+    if first == last do
+      defp unicode_start(unquote(first)), do: unquote(scriptset)
+    else
+      defp unicode_start(entry) when entry in unquote(first)..unquote(last),
+        do: unquote(scriptset)
+    end
+  end
+
+  defp unicode_start(_), do: @bottom
+
+  for {first, last, scriptset} <- rangify.(unicode_continue) do
+    if first == last do
+      defp unicode_continue(unquote(first)), do: unquote(scriptset)
+    else
+      defp unicode_continue(entry) when entry in unquote(first)..unquote(last),
+        do: unquote(scriptset)
+    end
+  end
+
+  defp unicode_continue(_), do: @bottom
+
+  # subset of direction-changing/neutral characters valid in idents
+  id_all = id_upper ++ id_start ++ id_continue
+  dir_rtls = for c <- dir_rtls, c in id_all, do: {c, :rtl}
+  dir_neutrals = for c <- dir_neutrals, c not in 48..57, c in id_all, do: {c, :neutral}
+  dir_ranges = rangify.(dir_rtls) ++ rangify.(dir_neutrals)
+
+  # direction of a codepoint. (rtl, neutral, weak, ltr fallback)
+  # weaks are pulled towards previous directional spans,
+  # but the only weaks allowed in idents are numbers 0..9
+  def dir(i) when i in 48..57, do: :weak_number
+
+  for {first, last, direction} <- dir_ranges do
+    if first == last do
+      def dir(unquote(first)), do: unquote(direction)
+    else
+      def dir(i) when i in unquote(first)..unquote(last), do: unquote(direction)
+    end
+  end
+
+  def dir(i) when is_integer(i), do: :ltr
+
+  # Hard-coded normalizations. Also split by upper, start, continue.
+
+  for {from, to} <- start_normalizations do
+    mask = Map.fetch!(codepoints_to_mask, to)
+    defp normalize_start(unquote(from)), do: {unquote(to), unquote(mask)}
+  end
+
+  defp normalize_start(_codepoint), do: @bottom
+
+  ##
+  ## Now we are ready to tokenize!
+  ##
+
+  def tokenize([head | tail]) do
+    cond do
+      ascii_upper?(head) ->
+        validate(continue(tail, [head], 1, true, @latin, []), :alias)
+
+      ascii_lower?(head) ->
+        validate(continue(tail, [head], 1, true, @latin, []), :identifier)
+
+      head == ?_ ->
+        validate(continue(tail, [head], 1, true, @top, []), :identifier)
+
+      true ->
+        case unicode_upper(head) do
+          @bottom ->
+            case unicode_start(head) do
+              @bottom ->
+                case normalize_start(head) do
+                  @bottom ->
+                    {:error, :empty}
+
+                  {head, scriptset} ->
+                    validate(continue(tail, [head], 1, false, scriptset, [:nfkc]), :identifier)
+                end
+
+              scriptset ->
+                validate(continue(tail, [head], 1, false, scriptset, []), :identifier)
+            end
+
+          scriptset ->
+            validate(continue(tail, [head], 1, false, scriptset, []), :atom)
+        end
+    end
+  end
+
+  def tokenize([]) do
+    {:error, :empty}
+  end
+
+  defp continue([?! | tail], acc, length, ascii_letters?, scriptset, special) do
+    {[?! | acc], tail, length + 1, ascii_letters?, scriptset, [:punctuation | special]}
+  end
+
+  defp continue([?? | tail], acc, length, ascii_letters?, scriptset, special) do
+    {[?? | acc], tail, length + 1, ascii_letters?, scriptset, [:punctuation | special]}
+  end
+
+  defp continue([?@ | tail], acc, length, ascii_letters?, scriptset, special) do
+    special = [:at | List.delete(special, :at)]
+    continue(tail, [?@ | acc], length + 1, ascii_letters?, scriptset, special)
+  end
+
+  defp continue([head | tail] = list, acc, length, ascii_letters?, scriptset, special) do
+    cond do
+      ascii_lower?(head) or ascii_upper?(head) ->
+        continue(tail, [head | acc], length + 1, ascii_letters?, ss_latin(scriptset), special)
+
+      head == ?_ or ascii_continue?(head) ->
+        continue(tail, [head | acc], length + 1, ascii_letters?, scriptset, special)
+
+      # Pattern is used for performance and to not mark ascii tokens as unicode
+      # ' \\\t\n\r!"#$%&\'()*+,-./:;<=>?@[]^`{|}~'
+      head <= 127 ->
+        {acc, list, length, ascii_letters?, scriptset, special}
+
+      true ->
+        with @bottom <- unicode_start(head),
+             @bottom <- unicode_upper(head),
+             @bottom <- unicode_continue(head) do
+          case normalize_start(head) do
+            @bottom ->
+              {:error, {:unexpected_token, :lists.reverse([head | acc])}}
+
+            {head, ss} ->
+              ss = ss_intersect(scriptset, ss)
+              special = [:nfkc | List.delete(special, :nfkc)]
+              continue(tail, [head | acc], length + 1, false, ss, special)
+          end
+        else
+          ss ->
+            ss = ss_intersect(scriptset, ss)
+            continue(tail, [head | acc], length + 1, false, ss, special)
+        end
+    end
+  end
+
+  defp continue([], acc, length, ascii_letters?, scriptset, special) do
+    {acc, [], length, ascii_letters?, scriptset, special}
+  end
+
+  defp validate({:error, _} = error, _kind) do
+    error
+  end
+
+  defp validate({acc, rest, length, true, _scriptset, special}, kind) do
+    {kind, :lists.reverse(acc), rest, length, true, special}
+  end
+
+  defp validate({original_acc, rest, length, false, scriptset, special}, kind) do
+    original_acc = :lists.reverse(original_acc)
+    acc = :unicode.characters_to_nfc_list(original_acc)
+
+    special =
+      if original_acc == acc do
+        special
+      else
+        [:nfkc | List.delete(special, :nfkc)]
+      end
+
+    if scriptset != @bottom or chunks_single?(acc) do
+      {kind, acc, rest, length, false, special}
+    else
+      breakdown =
+        for codepoint <- acc do
+          scriptsets =
+            case codepoint_to_scriptset(codepoint) do
+              @top ->
+                ""
+
+              scriptset ->
+                scriptset
+                |> ScriptSet.to_indexes()
+                |> Enum.map(&Map.fetch!(@indexed_scriptsets, &1))
+                |> then(&(" {" <> Enum.join(&1, ",") <> "}"))
+            end
+
+          hex = :io_lib.format(~c"~4.16.0B", [codepoint])
+          "  \\u#{hex} #{[codepoint]}#{scriptsets}\n"
+        end
+
+      prefix = ~c"invalid mixed-script identifier found: "
+
+      suffix = ~c"""
+
+
+      Mixed-script identifiers are not supported for security reasons. \
+      '#{acc}' is made of the following scripts:\n
+      #{breakdown}
+      Characters in identifiers from different scripts must be separated \
+      by underscore (_).
+      """
+
+      {:error, {:mixed_script, acc, {prefix, suffix}}}
+    end
+  end
+
+  # Support script mixing via chunked identifiers (UTS 55-5's strong recommends).
+  # Each chunk in an ident like foo_bar_baz should pass checks.
+  defp chunks_single?(acc),
+    do: chunks_single?(acc, @top)
+
+  defp chunks_single?([?_ | rest], acc),
+    do: acc != @bottom and chunks_single?(rest, @top)
+
+  defp chunks_single?([head | rest], acc),
+    do: chunks_single?(rest, ss_intersect(codepoint_to_scriptset(head), acc))
+
+  defp chunks_single?([], acc),
+    do: acc != @bottom
+
+  defp codepoint_to_scriptset(head) do
+    cond do
+      ascii_lower?(head) or ascii_upper?(head) ->
+        @latin
+
+      head == ?_ or ascii_continue?(head) ->
+        @top
+
+      true ->
+        with @bottom <- unicode_start(head),
+             @bottom <- unicode_upper(head),
+             @bottom <- unicode_continue(head),
+             do: @top
+    end
+  end
+end
diff --git a/lib/elixir/unicode/unicode.ex b/lib/elixir/unicode/unicode.ex
index 3ab64897304..8aa9ef02a3e 100644
--- a/lib/elixir/unicode/unicode.ex
+++ b/lib/elixir/unicode/unicode.ex
@@ -1,352 +1,487 @@
-defmodule String.Unicode do
-  @moduledoc false
-  def version, do: {7, 0, 0}
-
-  to_binary = fn
-    "" ->
-      nil
-    codepoints ->
-      codepoints = :binary.split(codepoints, " ", [:global])
-      Enum.reduce codepoints, "", fn(codepoint, acc) ->
-        acc <> << String.to_integer(codepoint, 16) :: utf8 >>
-      end
-  end
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# How to update the Unicode files
+#
+# Unicode files can be found in https://www.unicode.org/Public/VERSION_NUMBER/ where
+# VERSION_NUMBER is the current Unicode version.
+#
+# 1. Replace UnicodeData.txt by copying original
+# 2. Replace PropertyValueAliases.txt by copying original
+# 3. Replace PropList.txt by copying original
+# 4. Replace ScriptExtensions.txt by copying original
+# 5. Replace Scripts.txt by copying original
+# 6. Replace SpecialCasing.txt by copying original
+# 7. Replace confusables.txt by copying original
+#    (from https://www.unicode.org/Public/security/VERSION_NUMBER/)
+# 8. Replace IdentifierType.txt by copying original
+#    (from https://www.unicode.org/Public/security/VERSION_NUMBER/)
+# 9. Update String.Unicode.version/0 and on String module docs (version and link)
+# 10. make unicode
+
+data_path = Path.join(__DIR__, "UnicodeData.txt")
+
+to_binary = fn
+  "" ->
+    nil
 
-  data_path = Path.join(__DIR__, "UnicodeData.txt")
+  codepoints ->
+    codepoints
+    |> :binary.split(" ", [:global])
+    |> Enum.map(&<<String.to_integer(&1, 16)::utf8>>)
+    |> IO.iodata_to_binary()
+end
 
-  {codes, whitespace} = Enum.reduce File.stream!(data_path), {[], []}, fn(line, {cacc, wacc}) ->
-    [ codepoint, _name, _category,
-      _class, bidi, _decomposition,
-      _numeric_1, _numeric_2, _numeric_3,
-      _bidi_mirror, _unicode_1, _iso,
-      upper, lower, title ] = :binary.split(line, ";", [:global])
+rangify = fn [head | tail] ->
+  {first, last, acc} =
+    Enum.reduce(tail, {head, head, []}, fn
+      number, {first, last, acc} when number == first - 1 ->
+        {number, last, acc}
 
-    title = :binary.part(title, 0, byte_size(title) - 1)
+      number, {first, last, acc} ->
+        {number, number, [{first, last} | acc]}
+    end)
 
-    cond do
-      upper != "" or lower != "" or title != "" ->
-        {[{to_binary.(codepoint), to_binary.(upper), to_binary.(lower), to_binary.(title)} | cacc], wacc}
-      bidi in ["B", "S", "WS"] ->
-        {cacc, [to_binary.(codepoint) | wacc]}
-      true ->
-        {cacc, wacc}
-    end
-  end
+  [{first, last} | acc]
+end
 
-  special_path = Path.join(__DIR__, "SpecialCasing.txt")
+# A character is case ignorable if:
+#
+#    Word_Break(C) = MidLetter or MidNumLet or Single_Quote, or
+#    General_Category(C) = Nonspacing_Mark (Mn), Enclosing_Mark (Me), Format (Cf),
+#                          Modifier_Letter (Lm), or Modifier_Symbol (Sk).
+#
+# Word breaks are defined below based on TR29 (https://unicode.org/reports/tr29/).
+# The categories are computed later.
+case_ignorable = [
+  0x0027,
+  0x002E,
+  0x2018,
+  0x2019,
+  0x2024,
+  0xFE52,
+  0xFF07,
+  0xFF0E,
+  0x00B7,
+  0x0387,
+  0x05F4,
+  0x2027,
+  0x003A,
+  0xFE13,
+  0xFE55,
+  0xFF1A
+]
+
+acc = {[], [], case_ignorable, [], %{}, %{}}
+cased_letter_categories = :binary.compile_pattern(["Ll", "Lt", "Lu"])
+case_ignorable_categories = :binary.compile_pattern(["Mn", "Me", "Cf", "Lm", "Sk"])
+
+{codes, cased_letters, case_ignorable, non_breakable, decompositions, combining_classes} =
+  data_path
+  |> File.read!()
+  |> String.split(["\r\n", "\n"], trim: true)
+  |> Enum.reduce(acc, fn line, {cacc, lacc, iacc, wacc, dacc, kacc} ->
+    [
+      codepoint,
+      _name,
+      category,
+      class,
+      _bidi,
+      decomposition,
+      _numeric_1,
+      _numeric_2,
+      _numeric_3,
+      _bidi_mirror,
+      _unicode_1,
+      _iso,
+      upper,
+      lower,
+      _title
+    ] = :binary.split(line, ";", [:global])
+
+    cacc =
+      if upper != "" or lower != "" do
+        [{to_binary.(codepoint), to_binary.(upper), to_binary.(lower)} | cacc]
+      else
+        cacc
+      end
 
-  codes = Enum.reduce File.stream!(special_path), codes, fn(line, acc) ->
-    [ codepoint, lower, title, upper, _comment ] = :binary.split(line, "; ", [:global])
-    key = to_binary.(codepoint)
-    :lists.keystore(key, 1, acc, {key, to_binary.(upper), to_binary.(lower), to_binary.(title)})
-  end
+    cased_letter_categories = :binary.compile_pattern(["Ll", "Lt", "Lu"])
+    case_ignorable_categories = :binary.compile_pattern(["Mn", "Me", "Cf", "Lm", "Sk"])
 
-  # Downcase
+    {lacc, iacc} =
+      cond do
+        match?({0, _}, :binary.match(category, cased_letter_categories)) ->
+          {[String.to_integer(codepoint, 16) | lacc], iacc}
 
-  def downcase(string), do: do_downcase(string) |> IO.iodata_to_binary
+        match?({0, _}, :binary.match(category, case_ignorable_categories)) ->
+          {lacc, [String.to_integer(codepoint, 16) | iacc]}
 
-  for {codepoint, _upper, lower, _title} <- codes, lower && lower != codepoint do
-    defp do_downcase(unquote(codepoint) <> rest) do
-      unquote(:binary.bin_to_list(lower)) ++ downcase(rest)
-    end
-  end
-
-  defp do_downcase(<< char, rest :: binary >>) do
-    [char|do_downcase(rest)]
-  end
+        true ->
+          {lacc, iacc}
+      end
 
-  defp do_downcase(""), do: []
+    wacc =
+      case decomposition do
+        "<noBreak>" <> _ -> [to_binary.(codepoint) | wacc]
+        _ -> wacc
+      end
 
-  # Upcase
+    dacc =
+      case decomposition do
+        # Decomposition
+        <<h, _::binary>> when h != ?< ->
+          decomposition =
+            decomposition
+            |> :binary.split(" ", [:global])
+            |> Enum.map(&String.to_integer(&1, 16))
 
-  def upcase(string), do: do_upcase(string) |> IO.iodata_to_binary
+          :maps.put(String.to_integer(codepoint, 16), decomposition, dacc)
 
-  for {codepoint, upper, _lower, _title} <- codes, upper && upper != codepoint do
-    defp do_upcase(unquote(codepoint) <> rest) do
-      unquote(:binary.bin_to_list(upper)) ++ do_upcase(rest)
-    end
-  end
+        _ ->
+          dacc
+      end
 
-  defp do_upcase(<< char, rest :: binary >>) do
-    [char|do_upcase(rest)]
-  end
+    kacc =
+      case String.to_integer(class) do
+        0 -> kacc
+        n -> :maps.put(String.to_integer(codepoint, 16), n, kacc)
+      end
 
-  defp do_upcase(""), do: []
+    {cacc, lacc, iacc, wacc, dacc, kacc}
+  end)
 
-  # Titlecase once
+defmodule String.Unicode do
+  @moduledoc false
+  def version, do: {17, 0, 0}
+
+  [unconditional_mappings, _conditional_mappings] =
+    Path.join(__DIR__, "SpecialCasing.txt")
+    |> File.read!()
+    |> :binary.split("# Conditional Mappings")
+
+  codes =
+    unconditional_mappings
+    |> String.split(["\r\n", "\n"], trim: true)
+    |> Enum.reduce(codes, fn
+      "", acc ->
+        acc
+
+      "#" <> _, acc ->
+        acc
+
+      line, acc ->
+        [codepoint, lower, _title, upper, _] = :binary.split(line, "; ", [:global])
+        key = to_binary.(codepoint)
+
+        :lists.keystore(
+          key,
+          1,
+          acc,
+          {key, to_binary.(upper), to_binary.(lower)}
+        )
+    end)
+
+  # The function computes byte lookups based on the prefix. For example,
+  # Á, É, etc all have the same prefix <<195>>, so they are lumped
+  # together for lookup and then we just do a byte lookup later. We
+  # tried doing the byte lookup on 64-element tuple (since the byte
+  # is always within 0b10000000 and 0b10111111) but that's slower,
+  # especially because we need to check the byte range for invalid
+  # Unicode, instead the last byte lookup is a case. Grouping the
+  # top-level lookup makes the cost of a miss 3x cheaper albeit a
+  # hit is 10% more expensive) and reduces bytecode size.
+  compute_lookup = fn key_values ->
+    prefixes =
+      Enum.reduce(key_values, %{}, fn {codepoint, result}, acc ->
+        prefix_size = bit_size(codepoint) - 8
+        <<prefix::size(^prefix_size)-bits, byte>> = codepoint
+        Map.update(acc, prefix, [{byte, result}], &[{byte, result} | &1])
+      end)
+
+    {singles, tables} =
+      Enum.reduce(Map.delete(prefixes, ""), {[], []}, fn {prefix, pairs}, {singles, tables} ->
+        case pairs do
+          [{byte, result}] ->
+            {[{prefix <> <<byte>>, result} | singles], tables}
+
+          _ ->
+            clauses =
+              Enum.flat_map(pairs, fn {byte, result} ->
+                quote do
+                  unquote(byte) -> unquote(result)
+                end
+              end)
+
+            clauses = clauses ++ quote do: (byte -> <<unquote(prefix), byte>>)
+            {singles, [{prefix, clauses} | tables]}
+        end
+      end)
+
+    {Enum.sort(singles), Enum.sort_by(tables, &(-byte_size(elem(&1, 0))))}
+  end
+
+  # Sigma variants for Greek
+  @letter_sigma <<0x03A3::utf8>>
+  @letter_small_sigma_final <<0x03C2::utf8>>
+  @letter_small_sigma <<0x03C3::utf8>>
+
+  # Letter I variants for Turkic languages
+  @letter_I <<0x0049::utf8>>
+  @dotless_letter_i <<0x0131::utf8>>
+  @letter_i <<0x0069::utf8>>
+  @letter_I_dot_above <<0x0130::utf8>>
+  @combining_dot_above <<0x0307::utf8>>
 
-  def titlecase_once(""), do: {"", ""}
+  # Downcase
 
-  for {codepoint, _upper, _lower, title} <- codes, title && title != codepoint do
-    def titlecase_once(unquote(codepoint) <> rest) do
-      {unquote(title), rest}
-    end
+  # Turkic İ -> i
+  def downcase(<<unquote(@letter_I_dot_above), rest::bits>>, acc, mode) do
+    char = if mode == :turkic, do: @letter_i, else: <<@letter_i, @combining_dot_above>>
+    downcase(rest, [char | acc], mode)
   end
 
-  def titlecase_once(<< char, rest :: binary >>) do
-    {<< char >>, rest}
+  def downcase(<<@letter_I, @combining_dot_above, rest::bits>>, acc, mode) do
+    char = if mode == :turkic, do: @letter_i, else: <<@letter_i, @combining_dot_above>>
+    downcase(rest, [char | acc], mode)
   end
 
-  # Strip
-
-  def lstrip(""), do: ""
-
-  for codepoint <- whitespace do
-    def lstrip(unquote(codepoint) <> rest) do
-      lstrip(rest)
-    end
+  # Turkic I -> ı
+  def downcase(<<@letter_I, rest::bits>>, acc, mode) do
+    char = if mode == :turkic, do: @dotless_letter_i, else: @letter_i
+    downcase(rest, [char | acc], mode)
   end
 
-  def lstrip(other) when is_binary(other), do: other
+  # Greek sigma
+  def downcase(<<@letter_sigma, rest::bits>>, acc, mode) do
+    downcased =
+      if mode == :greek and cased_letter_list?(acc) and not cased_letter_binary?(rest) do
+        @letter_small_sigma_final
+      else
+        @letter_small_sigma
+      end
 
-  def rstrip(string) when is_binary(string) do
-    do_rstrip(string, [], [])
+    downcase(rest, [downcased | acc], mode)
   end
 
-  for codepoint <- whitespace do
-    c = :binary.bin_to_list(codepoint) |> :lists.reverse
+  conditional_downcase = [@letter_I, @letter_I_dot_above, @letter_sigma]
 
-    defp do_rstrip(unquote(codepoint) <> rest, acc1, acc2) do
-      do_rstrip(rest, unquote(c) ++ (acc1 || acc2), acc2)
+  {singles, tables} =
+    compute_lookup.(
+      for {codepoint, _upper, lower} <- codes,
+          lower && lower != codepoint,
+          codepoint not in conditional_downcase,
+          do: {codepoint, lower}
+    )
+
+  for {codepoint, lower} <- singles do
+    def downcase(<<unquote(codepoint), rest::bits>>, acc, mode) do
+      downcase(rest, [unquote(lower) | acc], mode)
     end
   end
 
-  defp do_rstrip(<< char, rest :: binary >>, nil, acc2) do
-    do_rstrip(rest, nil, [char|acc2])
+  for {prefix, clauses} <- tables do
+    def downcase(<<unquote(prefix), byte, rest::bits>>, acc, mode) do
+      value = case byte, do: unquote(clauses)
+      downcase(rest, [value | acc], mode)
+    end
   end
 
-  defp do_rstrip(<< char, rest :: binary >>, acc1, _acc2) do
-    do_rstrip(rest, nil, [char|acc1])
+  def downcase(<<byte, rest::bits>>, acc, mode) do
+    if byte >= ?A and byte <= ?Z do
+      downcase(rest, [byte + 32 | acc], mode)
+    else
+      downcase(rest, [byte | acc], mode)
+    end
   end
 
-  defp do_rstrip(<<>>, _acc1, acc2), do: acc2 |> :lists.reverse |> IO.iodata_to_binary
-
-  # Split
-
-  def split(""), do: [""]
+  def downcase("", acc, _mode), do: IO.iodata_to_binary(:lists.reverse(acc))
 
-  def split(string) when is_binary(string) do
-    :lists.reverse do_split(string, "", [])
-  end
+  # Sigma handling
 
-  for codepoint <- whitespace do
-    defp do_split(unquote(codepoint) <> rest, buffer, acc) do
-      do_split(rest, "", add_buffer_to_acc(buffer, acc))
+  defp cased_letter_binary?(<<codepoint::utf8, rest::bits>>) do
+    if case_ignorable?(codepoint) do
+      cased_letter_binary?(rest)
+    else
+      cased_letter?(codepoint)
     end
   end
 
-  defp do_split(<< char, rest :: binary >>, buffer, acc) do
-    do_split(rest, << buffer :: binary, char >>, acc)
-  end
+  defp cased_letter_binary?(_), do: false
 
-  defp do_split(<<>>, buffer, acc) do
-    add_buffer_to_acc(buffer, acc)
+  defp cased_letter_list?([<<codepoint::utf8>> | rest]) do
+    if case_ignorable?(codepoint) do
+      cased_letter_list?(rest)
+    else
+      cased_letter?(codepoint)
+    end
   end
 
-  @compile {:inline, add_buffer_to_acc: 2}
-
-  defp add_buffer_to_acc("", acc),     do: acc
-  defp add_buffer_to_acc(buffer, acc), do: [buffer|acc]
-
-  # Codepoints
+  defp cased_letter_list?(_), do: false
 
-  def next_codepoint(<< cp :: utf8, rest :: binary >>) do
-    {<<cp :: utf8>>, rest}
+  for {first, last} <- rangify.(cased_letters) do
+    if first == last do
+      defp cased_letter?(unquote(first)), do: true
+    else
+      defp cased_letter?(codepoint)
+           when codepoint >= unquote(first) and codepoint <= unquote(last),
+           do: true
+    end
   end
 
-  def next_codepoint(<< cp, rest :: binary >>) do
-    {<<cp>>, rest}
-  end
+  defp cased_letter?(_), do: false
 
-  def next_codepoint(<<>>) do
-    nil
+  for {first, last} <- rangify.(case_ignorable) do
+    if first == last do
+      defp case_ignorable?(unquote(first)), do: true
+    else
+      defp case_ignorable?(codepoint)
+           when codepoint >= unquote(first) and codepoint <= unquote(last),
+           do: true
+    end
   end
 
-  def codepoints(binary) when is_binary(binary) do
-    do_codepoints(next_codepoint(binary))
-  end
+  defp case_ignorable?(_), do: false
 
-  defp do_codepoints({c, rest}) do
-    [c|do_codepoints(next_codepoint(rest))]
-  end
+  # Upcase
 
-  defp do_codepoints(nil) do
-    []
+  # Turkic i -> İ
+  def upcase(<<@letter_i, rest::bits>>, acc, mode) do
+    char = if mode == :turkic, do: @letter_I_dot_above, else: @letter_I
+    upcase(rest, [char | acc], mode)
   end
-end
-
-defmodule String.Graphemes do
-  @moduledoc false
 
-  cluster_path = Path.join(__DIR__, "GraphemeBreakProperty.txt")
-  regex = ~r/(?:^([0-9A-F]+)(?:\.\.([0-9A-F]+))?)\s+;\s(\w+)/m
+  conditional_upcase = [@letter_i]
 
-  to_range = fn
-    first, ""   ->
-      [<< String.to_integer(first, 16) :: utf8 >>]
-    first, last ->
-      range = String.to_integer(first, 16)..String.to_integer(last, 16)
-      Enum.map(range, fn(int) -> << int :: utf8 >> end)
-  end
-
-  cluster = Enum.reduce File.stream!(cluster_path), HashDict.new, fn(line, dict) ->
-    [ _full, first, last, class ] = Regex.run(regex, line)
+  {singles, tables} =
+    compute_lookup.(
+      for {codepoint, upper, _lower} <- codes,
+          upper && upper != codepoint,
+          codepoint not in conditional_upcase,
+          do: {codepoint, upper}
+    )
 
-    # Skip surrogates
-    if first == "D800" and last == "DFFF" do
-      dict
-    else
-      list = to_range.(first, last)
-      Dict.update(dict, class, list, &(&1 ++ list))
+  for {codepoint, upper} <- singles do
+    def upcase(<<unquote(codepoint), rest::bits>>, acc, mode) do
+      upcase(rest, [unquote(upper) | acc], mode)
     end
   end
 
-  # There is no codepoint marked as Prepend by Unicode 6.3.0
-  if cluster["Prepend"] do
-    raise "It seems this new unicode version has added Prepend items. " <>
-          "Please remove this error and uncomment the code below."
-  end
-
-  # Don't break CRLF
-  def next_grapheme(<< ?\n, ?\r, rest :: binary >>) do
-    {"\n\r", rest}
-  end
-
-  # Break on control
-  for codepoint <- cluster["CR"] ++ cluster["LF"] ++ cluster["Control"] do
-    def next_grapheme(<< unquote(codepoint), rest :: binary >> = string) do
-      {:binary.part(string, 0, unquote(byte_size(codepoint))), rest}
+  for {prefix, clauses} <- tables do
+    def upcase(<<unquote(prefix), byte, rest::bits>>, acc, mode) do
+      value = case byte, do: unquote(clauses)
+      upcase(rest, [value | acc], mode)
     end
   end
 
-  # Break on Prepend*
-  # for codepoint <- cluster["Prepend"] do
-  #   def next_grapheme(<< unquote(codepoint), rest :: binary >> = string) do
-  #     next_prepend(rest, string, unquote(byte_size(codepoint)))
-  #   end
-  # end
-
-  # Handle Hangul L
-  for codepoint <- cluster["L"] do
-    def next_grapheme(<< unquote(codepoint), rest :: binary >> = string) do
-      next_hangul_l(rest, string, unquote(byte_size(codepoint)))
+  def upcase(<<byte, rest::bits>>, acc, mode) do
+    if byte >= ?a and byte <= ?z do
+      upcase(rest, [byte - 32 | acc], mode)
+    else
+      upcase(rest, [byte | acc], mode)
     end
   end
 
-  # Handle Hangul T
-  for codepoint <- cluster["T"] do
-    def next_grapheme(<< unquote(codepoint), rest :: binary >> = string) do
-      next_hangul_t(rest, string, unquote(byte_size(codepoint)))
-    end
-  end
+  def upcase("", acc, _mode), do: IO.iodata_to_binary(:lists.reverse(acc))
+end
 
-  # Handle Regional
-  for codepoint <- cluster["Regional_Indicator"] do
-    def next_grapheme(<< unquote(codepoint), rest :: binary >> = string) do
-      next_regional(rest, string, unquote(byte_size(codepoint)))
-    end
-  end
+defmodule String.Break do
+  @moduledoc false
+  @whitespace_max_size 3
+
+  prop_path = Path.join(__DIR__, "PropList.txt")
+
+  whitespace =
+    prop_path
+    |> File.read!()
+    |> String.split(["\r\n", "\n"])
+    |> Enum.reduce([], fn line, acc ->
+      case :binary.split(line, ";") do
+        [<<first::4-bytes, "..", last::4-bytes, _::binary>>, <<" White_Space", _::binary>>] ->
+          first = String.to_integer(first, 16)
+          last = String.to_integer(last, 16)
+          Enum.map(first..last, fn int -> <<int::utf8>> end) ++ acc
+
+        [<<single::4-bytes, _::binary>>, <<" White_Space", _::binary>>] ->
+          [<<String.to_integer(single, 16)::utf8>> | acc]
+
+        _ ->
+          acc
+      end
+    end)
 
-  # Handle extended entries
-  def next_grapheme(<< cp :: utf8, rest :: binary >> = string) do
-    next_extend(rest, string, byte_size(<< cp :: utf8 >>))
-  end
+  IO.puts(:stderr, "[Unicode] Break on #{length(whitespace)} whitespace codepoints")
 
-  def next_grapheme(<< cp, rest :: binary >>) do
-    {<<cp>>, rest}
-  end
+  # trim_leading
 
-  def next_grapheme(<<>>) do
-    nil
+  def trim_leading(string) when is_binary(string) do
+    do_trim_leading(string)
   end
 
-  # Handle Hangul L
-  for codepoint <- cluster["L"] do
-    defp next_hangul_l(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_hangul_l(rest, string, size + unquote(byte_size(codepoint)))
-    end
+  for codepoint <- whitespace do
+    def do_trim_leading(<<unquote(codepoint), rest::bits>>), do: do_trim_leading(rest)
   end
 
-  for codepoint <- cluster["LV"] do
-    defp next_hangul_l(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_hangul_v(rest, string, size + unquote(byte_size(codepoint)))
-    end
-  end
+  def do_trim_leading(<<rest::bits>>), do: rest
 
-  for codepoint <- cluster["LVT"] do
-    defp next_hangul_l(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_hangul_t(rest, string, size + unquote(byte_size(codepoint)))
-    end
-  end
+  # trim_trailing
 
-  defp next_hangul_l(rest, string, size) do
-    next_hangul_v(rest, string, size)
-  end
+  for cp <- whitespace do
+    # We need to increment @whitespace_max_size as well
+    # as the small table (_s) if we add a new entry here.
+    case byte_size(cp) do
+      3 ->
+        defp do_trim_trailing_l(unquote(cp)), do: -3
 
-  # Handle Hangul V
-  for codepoint <- cluster["V"] do
-    defp next_hangul_v(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_hangul_v(rest, string, size + unquote(byte_size(codepoint)))
-    end
-  end
+      2 ->
+        defp do_trim_trailing_l(<<_, unquote(cp)>>), do: -2
+        defp do_trim_trailing_s(unquote(cp)), do: <<>>
 
-  defp next_hangul_v(rest, string, size) do
-    next_hangul_t(rest, string, size)
-  end
+      1 ->
+        defp do_trim_trailing_l(<<unquote(cp), unquote(cp), unquote(cp)>>), do: -3
+        defp do_trim_trailing_l(<<_, unquote(cp), unquote(cp)>>), do: -2
+        defp do_trim_trailing_l(<<_, _, unquote(cp)>>), do: -1
 
-  # Handle Hangul T
-  for codepoint <- cluster["T"] do
-    defp next_hangul_t(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_hangul_t(rest, string, size + unquote(byte_size(codepoint)))
+        defp do_trim_trailing_s(<<x, unquote(cp)>>), do: do_trim_trailing_s(<<x>>)
+        defp do_trim_trailing_s(unquote(cp)), do: <<>>
     end
   end
 
-  defp next_hangul_t(rest, string, size) do
-    next_extend(rest, string, size)
-  end
+  defp do_trim_trailing_l(_), do: 0
+  defp do_trim_trailing_s(o), do: o
 
-  # Handle regional
-  for codepoint <- cluster["Regional_Indicator"] do
-    defp next_regional(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_regional(rest, string, size + unquote(byte_size(codepoint)))
-    end
+  def trim_trailing(string) when is_binary(string) do
+    trim_trailing(string, byte_size(string))
   end
 
-  defp next_regional(rest, string, size) do
-    next_extend(rest, string, size)
+  defp trim_trailing(string, size) when size < @whitespace_max_size do
+    do_trim_trailing_s(string)
   end
 
-  # Handle Extend+SpacingMark
-  for codepoint <- cluster["Extend"] ++ cluster["SpacingMark"]  do
-    defp next_extend(<< unquote(codepoint), rest :: binary >>, string, size) do
-      next_extend(rest, string, size + unquote(byte_size(codepoint)))
+  defp trim_trailing(string, size) do
+    trail = binary_part(string, size, -@whitespace_max_size)
+
+    case do_trim_trailing_l(trail) do
+      0 -> string
+      x -> trim_trailing(binary_part(string, 0, size + x), size + x)
     end
   end
 
-  defp next_extend(rest, string, size) do
-    {:binary.part(string, 0, size), rest}
-  end
+  # Split
 
-  # Handle Prepend
-  # for codepoint <- cluster["Prepend"] do
-  #   defp next_prepend(<< unquote(codepoint), rest :: binary >>, string, size) do
-  #     next_prepend(rest, string, size + unquote(byte_size(codepoint)))
-  #   end
-  # end
-  #
-  # defp next_prepend(rest, string, size) do
-  #   {:binary.part(string, 0, size), rest}
-  # end
-
-  def graphemes(binary) when is_binary(binary) do
-    do_graphemes(next_grapheme(binary))
+  def split(string) do
+    :binary.split(string, unquote(whitespace -- non_breakable), [:global, :trim_all])
   end
 
-  defp do_graphemes({c, rest}) do
-    [c|do_graphemes(next_grapheme(rest))]
-  end
+  # Decompose
 
-  defp do_graphemes(nil) do
-    []
+  def decompose(entries, map) do
+    for entry <- entries do
+      case map do
+        %{^entry => match} -> decompose(match, map)
+        %{} -> <<entry::utf8>>
+      end
+    end
   end
 end
diff --git a/lib/ex_unit/examples/difference.exs b/lib/ex_unit/examples/difference.exs
new file mode 100644
index 00000000000..3af3d3104e1
--- /dev/null
+++ b/lib/ex_unit/examples/difference.exs
@@ -0,0 +1,195 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# Run it from root as: make compile && bin/elixir lib/ex_unit/examples/difference.exs
+ExUnit.start(seed: 0)
+
+defmodule Difference do
+  @moduledoc """
+  This module contains failing tests to see
+  difference highlighting in action.
+  """
+  use ExUnit.Case
+
+  defmodule User do
+    defstruct [:age]
+  end
+
+  defmacrop one, do: 1
+
+  describe "regular context" do
+    test "integers" do
+      assert 491_512_235 == 490_512_035
+    end
+
+    test "floats" do
+      assert 42.0 == 43.0
+    end
+
+    test "strings" do
+      string1 = "fox hops over \"the dog"
+      string2 = "fox  jumps over the lazy cat"
+      assert string1 == string2
+    end
+
+    test "whitespace" do
+      list1 = [%{a: "abc "}, %{a: "def"}, %{c: "gh"}]
+      list2 = [%{a: "abc"}, %{a: " def"}, %{c: "hi"}]
+      assert list1 == list2
+    end
+
+    test "large strings" do
+      string1 = "short"
+      string2 = "really long string that should not emit diff"
+      assert string1 == string2
+    end
+
+    test "large strings; inner" do
+      tuple1 = {"short"}
+      tuple2 = {"really long string that should not emit diff"}
+      assert tuple1 == tuple2
+    end
+
+    test "lists" do
+      list1 = ["Tvo", make_ref(), :ok, {}]
+      list2 = ["Two", :ok, self(), {true}]
+      assert list1 == list2
+    end
+
+    test "lists; missing entries" do
+      assert [] == [1, 2, 3]
+    end
+
+    test "lists; surplus entries" do
+      assert [1, 2, 3] == []
+    end
+
+    test "improper lists" do
+      list1 = [1 | "b"]
+      list2 = [1, "a"]
+      assert list1 == list2
+    end
+
+    test "charlists" do
+      charlist1 = ~c"fox hops over 'the dog"
+      charlist2 = ~c"fox jumps over the lazy cat"
+      assert charlist1 == charlist2
+    end
+
+    test "keyword lists" do
+      assert [file: "nofile", line: 12] == [file: nil, lime: 10]
+    end
+
+    test "keyword lists; reverse order" do
+      keyword1 = [port: 4000, max_connections: 1000]
+      keyword2 = [max_connections: 1000, port: 4000]
+      assert keyword1 == keyword2
+    end
+
+    test "tuples" do
+      tuple1 = {:hex, "0.1", [{:ex_doc}]}
+      tuple2 = {:hex, "1.1"}
+      assert tuple1 == tuple2
+    end
+
+    test "maps; mixed diff" do
+      map1 = Enum.into(1..15, %{}, &{&1, &1}) |> Map.delete(13)
+      map2 = Enum.reduce(5..10, map1, &Map.delete(&2, &1)) |> Map.put(13, 13) |> Map.put(12, 32)
+      assert map1 == map2
+    end
+
+    test "maps; missing pairs" do
+      map1 = %{baz: 12}
+      map2 = %{foo: 12, bar: 12, baz: 12}
+      assert map1 == map2
+    end
+
+    test "maps; surplus pairs" do
+      map1 = %{foo: 12, bar: 12, baz: 12}
+      map2 = %{baz: 12}
+      assert map1 == map2
+    end
+
+    test "maps; missing pair" do
+      assert %{} == %{baz: 12}
+    end
+
+    test "maps; surplus pair" do
+      assert %{baz: 12} == %{}
+    end
+
+    test "structs" do
+      assert %User{age: 16} == %User{age: 21}
+    end
+  end
+
+  describe "match context" do
+    test "pins" do
+      x = 1
+      assert ^x = 2
+    end
+
+    test "vars" do
+      assert {x, x} = {1, 2}
+    end
+
+    test "strings; concat" do
+      assert "fox hops over the" <> x = "fox jumps over the lazy cat"
+    end
+
+    test "lists; head and tail" do
+      assert ["Tvo", 1 | [:ok, {}]] = ["Two", :ok, self(), {true}]
+    end
+
+    test "lists; concat" do
+      assert ["Tvo", 1] ++ [:ok, {}] = ["Two", :ok, self(), {true}]
+    end
+
+    test "maps" do
+      assert %{baz: 12} = %{foo: 13, bar: 13, baz: 13}
+    end
+
+    test "macro" do
+      assert one() = 2
+    end
+
+    test "underscore" do
+      assert {_, 1} = {1, 2}
+    end
+  end
+
+  describe "receive" do
+    test "no messages in the mailbox" do
+      assert_received x when x == :hello
+    end
+
+    test "only 1 message in the mailbox" do
+      send(self(), {:message, 1})
+
+      assert_received x when x == :hello
+    end
+
+    test "more than 1 messages in the mailbox" do
+      for i <- 1..2, do: send(self(), {:message, i})
+
+      assert_received x when x == :hello
+    end
+
+    test "more than 10 messages in the mailbox" do
+      for i <- 1..11, do: send(self(), {:message, i})
+
+      assert_received x when x == :hello
+    end
+
+    test "macro" do
+      send(self(), 12)
+
+      assert_received one()
+    end
+  end
+
+  test "only one side with metadata" do
+    assert "one" != "one"
+  end
+end
diff --git a/lib/ex_unit/examples/one_of_each.exs b/lib/ex_unit/examples/one_of_each.exs
index d5af037c05f..cd7b40d30c8 100644
--- a/lib/ex_unit/examples/one_of_each.exs
+++ b/lib/ex_unit/examples/one_of_each.exs
@@ -1,25 +1,33 @@
-ExUnit.start [seed: 0]
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# Run it from root as: make compile && bin/elixir lib/ex_unit/examples/one_of_each.exs
+ExUnit.start(seed: 0)
 
 defmodule TestOneOfEach do
   @moduledoc """
   This module contains one of each type of failing test.
   It is used simply to document the style of each.
   """
-
-  use ExUnit.Case, async: false
+  use ExUnit.Case
 
   @one 1
   @two 2
 
-  @long_data_1  [ field1: "one", field2: {:two1, :two2}, field3: 'three', field4: [1,2,3,4]]
-  @long_data_2  [ field1: "one", field2: {:two1, :two3}, field3: 'three', field4: [1,2,3,4]]
+  @long_data_1 [field1: "one", field2: {:two1, :two2}, field3: ~c"three", field4: [1, 2, 3, 4]]
+  @long_data_2 [field1: "one", field2: {:two1, :two3}, field3: ~c"three", field4: [1, 2, 3, 4]]
+
+  setup do
+    {:ok, user_id: 1, post_id: 2, many_ids: Enum.to_list(1..50)}
+  end
 
   test "1. assert with a match" do
     assert [@one] = [@two]
   end
 
   test "2. assert with a binary operator" do
-    assert @one * 4 > @two *3
+    assert @one * 4 > @two * 3
   end
 
   test "3. assert match with a long argument" do
@@ -35,7 +43,7 @@ defmodule TestOneOfEach do
   end
 
   test "6. refute with a binary operator" do
-    refute @one * 6 > @two *2
+    refute @one * 6 > @two * 2
   end
 
   test "7. refute match with a long argument" do
@@ -51,7 +59,7 @@ defmodule TestOneOfEach do
   end
 
   test "10. assert with explicit expected and actual values" do
-    assert @one > @two, @one, @two, "one should be greater than two"
+    assert @one > @two, left: @one, right: @two, message: "one should be greater than two"
   end
 
   test "11. assert that a message is ready to be received" do
@@ -59,31 +67,35 @@ defmodule TestOneOfEach do
   end
 
   test "12. assert that a message is received within a timeout" do
+    send(self(), {:ok, 1})
+    send(self(), :message_in_my_inbox)
+    send(self(), {:ok, 2})
+    send(self(), :another_message)
     assert_receive :no_message_after_timeout
   end
 
   test "13. assert an exception with a given message is raised, but no exception" do
-    assert_raise(SomeException, "some message", fn -> end)
+    assert_raise(SomeException, "some message", fn -> nil end)
   end
 
   test "14. assert an exception with a given message is raised" do
     assert_raise(SomeException, "some message", fn ->
-                                                     raise "other exception"
-                                                end)
+      raise "other exception"
+    end)
   end
 
   test "15. assert an exception with a given message is raised, but the message is wrong" do
     assert_raise(RuntimeError, "some message", fn ->
-                                                    raise "other error"
-                                               end)
+      raise "other error"
+    end)
   end
 
   test "16. assert an exception is raised" do
-    assert_raise(SomeException, fn -> end)
+    assert_raise(SomeException, fn -> nil end)
   end
 
   test "17. assert two values are within some delta" do
-    assert_in_delta 3.1415926, 22.0/7, 0.001
+    assert_in_delta 3.1415926, 22.0 / 7, 0.001
   end
 
   test "18. refute a value with a message" do
@@ -91,12 +103,12 @@ defmodule TestOneOfEach do
   end
 
   test "19. refute a message is received within a timeout" do
-    send self, {:hello, "Dave"}
-    refute_receive {:hello, _}, 1000
+    send(self(), {:hello, "Dave"})
+    refute_receive {:hello, _}, 100
   end
 
   test "20. refute a message is ready to be received" do
-    send self, :hello_again
+    send(self(), :hello_again)
     refute_received :hello_again
   end
 
@@ -109,24 +121,86 @@ defmodule TestOneOfEach do
   end
 
   test "23. flunk" do
-    flunk "we failed. totally"
+    flunk("we failed. totally")
   end
 
   test "24. exception raised while running test" do
-    assert blows_up
+    assert blows_up()
   end
 
   test "25. error due to exit" do
-    spawn_link fn -> raise "oops" end
+    spawn_link(fn -> raise "oops" end)
+
     receive do
     end
   end
 
+  test "26. multi error" do
+    error1 =
+      try do
+        assert [@one] = [@two]
+      rescue
+        e in ExUnit.AssertionError ->
+          {:error, e, __STACKTRACE__}
+      end
+
+    error2 =
+      try do
+        assert @one * 4 > @two * 3
+      rescue
+        e in ExUnit.AssertionError ->
+          {:error, e, __STACKTRACE__}
+      end
+
+    raise ExUnit.MultiError, errors: [error1, error2]
+  end
+
+  @tag capture_log: true
+  test "27. log capturing" do
+    require Logger
+    Logger.debug("this will be logged")
+    flunk("oops")
+  end
+
+  test "28. function clause error" do
+    Access.fetch(:foo, :bar)
+  end
+
+  test "29. function call arguments" do
+    assert some_vars(1 + 2, 3 + 4)
+  end
+
+  @tag :capture_log
+  test "30. linked assertion error" do
+    Task.async(fn -> assert 1 == 2 end) |> Task.await()
+  end
+
+  @tag :capture_log
+  test "31. linked function clause error" do
+    Task.async(fn -> Access.fetch(:foo, :bar) end) |> Task.await()
+  end
+
+  @tag :capture_log
+  test "32. trapped assertion error" do
+    Process.flag(:trap_exit, true)
+    Task.async(fn -> assert 1 == 2 end) |> Task.await()
+  end
+
+  @tag :capture_log
+  test "33. trapped function clause error" do
+    Process.flag(:trap_exit, true)
+    Task.async(fn -> Access.fetch(:foo, :bar) end) |> Task.await()
+  end
+
+  defp some_vars(_a, _b) do
+    false
+  end
+
   defp blows_up do
     ignite(0) + 1
   end
 
   defp ignite(val) do
-    1/val
+    1 / val
   end
 end
diff --git a/lib/ex_unit/lib/ex_unit.ex b/lib/ex_unit/lib/ex_unit.ex
index c004c6ef36c..b323e0f58e5 100644
--- a/lib/ex_unit/lib/ex_unit.ex
+++ b/lib/ex_unit/lib/ex_unit.ex
@@ -1,6 +1,10 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit do
   @moduledoc """
-  Basic unit testing framework for Elixir.
+  Unit testing framework for Elixir.
 
   ## Example
 
@@ -9,34 +13,34 @@ defmodule ExUnit do
       # File: assertion_test.exs
 
       # 1) Start ExUnit.
-      ExUnit.start
+      ExUnit.start()
 
-      # 2) Create a new test module (test case) and use `ExUnit.Case`.
+      # 2) Create a new test module and use "ExUnit.Case".
       defmodule AssertionTest do
-        # 3) Notice we pass `async: true`, this runs the test case
-        #    concurrently with other test cases
+        # 3) Note that we pass "async: true", this runs the tests in the
+        #    test module concurrently with other test modules. The
+        #    individual tests within each test module are still run serially.
         use ExUnit.Case, async: true
 
-        # 4) Use the `test` macro instead of `def` for clarity.
+        # 4) Use the "test" macro instead of "def" for clarity.
         test "the truth" do
           assert true
         end
       end
 
-  To run the tests above, run the file
-  using `elixir` from the command line. Assuming you named the file
-  `assertion_test.exs`, you can run it as:
+  To run the tests above, run the file using `elixir` from the
+  command line. Assuming you named the file `assertion_test.exs`,
+  you can run it as:
 
-      bin/elixir assertion_test.exs
+      $ elixir assertion_test.exs
 
   ## Case, Callbacks and Assertions
 
-  See `ExUnit.Case` and `ExUnit.Callbacks`
-  for more information about defining test cases.
+  See `ExUnit.Case` and `ExUnit.Callbacks` for more information
+  about defining test cases and setting up callbacks.
 
-  The `ExUnit.Assertions` module contains
-  a set of macros to easily generate assertions with appropriate
-  error messages.
+  The `ExUnit.Assertions` module contains a set of macros to
+  generate assertions with appropriate error messages.
 
   ## Integration with Mix
 
@@ -50,16 +54,88 @@ defmodule ExUnit do
   The minimum example of a `test_helper.exs` file would be:
 
       # test/test_helper.exs
-      ExUnit.start
+      ExUnit.start()
 
   Mix will load the `test_helper.exs` file before executing the tests.
   It is not necessary to `require` the `test_helper.exs` file in your test
-  files. See `Mix.Tasks.Test` for more information.
+  files. Run `mix help test` for more information.
   """
 
-  @typedoc "The state returned by ExUnit.Test and ExUnit.TestCase"
-  @type state  :: nil | {:failed, failed} | {:skip, binary} | {:invalid, module}
-  @type failed :: {Exception.kind, reason :: term, stacktrace :: [tuple]}
+  @typedoc """
+  All tests start with a state of `nil`.
+
+  A finished test can be in one of five states:
+
+    1. Passed (also represented by `nil`)
+    2. Failed
+    3. Skipped (via @tag :skip)
+    4. Excluded (via :exclude filters)
+    5. Invalid (when setup_all fails)
+
+  """
+  @type state ::
+          nil
+          | {:excluded, binary}
+          | {:failed, failed}
+          | {:invalid, ExUnit.TestModule.t()}
+          | {:skipped, binary}
+
+  @typedoc "The error state returned by `ExUnit.Test` and `ExUnit.TestModule`"
+  @type failed :: [{Exception.kind(), reason :: term, Exception.stacktrace()}]
+
+  @typedoc "A map representing the results of running a test suite"
+  @type suite_result :: %{
+          excluded: non_neg_integer,
+          failures: non_neg_integer,
+          skipped: non_neg_integer,
+          total: non_neg_integer
+        }
+
+  @type test_id :: {module, name :: atom}
+
+  @typedoc """
+  Configuration options for ExUnit.
+
+  See `configure/1` for detailed documentation of each option.
+  """
+  @type configure_opts :: [
+          {:assert_receive_timeout, non_neg_integer()}
+          | {:autorun, boolean()}
+          | {:capture_log, boolean() | [level: Logger.level()]}
+          | {:colors,
+             [
+               enabled: boolean(),
+               success: atom(),
+               invalid: atom(),
+               skipped: atom(),
+               failure: atom(),
+               error_info: atom(),
+               extra_info: atom(),
+               location_info: [atom()],
+               diff_insert: atom(),
+               diff_insert_whitespace: IO.ANSI.ansidata(),
+               diff_delete: atom(),
+               diff_delete_whitespace: IO.ANSI.ansidata()
+             ]}
+          | {:exclude, keyword()}
+          | {:exit_status, non_neg_integer()}
+          | {:failures_manifest_path, String.t()}
+          | {:formatters, [module()]}
+          | {:include, keyword()}
+          | {:max_cases, pos_integer()}
+          | {:max_failures, pos_integer() | :infinity}
+          | {:only_test_ids, [test_id()]}
+          | {:rand_algorithm, atom()}
+          | {:refute_receive_timeout, non_neg_integer()}
+          | {:seed, non_neg_integer()}
+          | {:slowest, non_neg_integer()}
+          | {:slowest_modules, non_neg_integer()}
+          | {:stacktrace_depth, non_neg_integer()}
+          | {:timeout, pos_integer()}
+          | {:trace, boolean()}
+          | {:test_location_relative_path, String.t()}
+          | {atom(), term()}
+        ]
 
   defmodule Test do
     @moduledoc """
@@ -67,45 +143,109 @@ defmodule ExUnit do
 
     It is received by formatters and contains the following fields:
 
-      * `:name`  - the test name
-      * `:case`  - the test case
-      * `:state` - the test state (see ExUnit.state)
-      * `:time`  - the time to run the test
-      * `:tags`  - the test tags
+      * `:name` - the test name
+      * `:module` - the test module
+      * `:state` - the finished test state (see `t:ExUnit.state/0`)
+      * `:time` - the duration in microseconds of the test's runtime
+      * `:tags` - the test tags
+      * `:logs` - the captured logs
+      * `:parameters` - the test parameters
 
     """
-    defstruct name: nil :: atom,
-              case: nil :: module,
-              state: nil :: ExUnit.state,
-              time: 0 :: non_neg_integer,
-              tags: %{} :: map
+    defstruct [:name, :case, :module, :state, time: 0, tags: %{}, logs: "", parameters: %{}]
+
+    # TODO: Remove the `:case` field on v2.0
+    @type t :: %__MODULE__{
+            name: atom,
+            case: module,
+            module: module,
+            state: ExUnit.state(),
+            time: non_neg_integer,
+            tags: map,
+            logs: String.t(),
+            parameters: map
+          }
   end
 
-  defmodule TestCase do
+  defmodule TestModule do
     @moduledoc """
-    A struct that keeps information about the test case.
+    A struct that keeps information about the test module.
 
     It is received by formatters and contains the following fields:
 
-      * `:name`  - the test case name
-      * `:state` - the test state (see ExUnit.state)
-      * `:tests` - all tests for this case
+      * `:file` - (since v1.11.0) the file of the test module
+
+      * `:name` - the test module name
+
+      * `:parameters` - (since v1.18.0) the test module parameters
+
+      * `:setup_all?` - (since v1.18.0) if the test module requires a setup all
+
+      * `:state` - the test error state (see `t:ExUnit.state/0`)
+
+      * `:tags` - all tags in this module
+
+      * `:tests` - all tests in this module
 
     """
-    defstruct name: nil :: module,
-              state: nil :: ExUnit.state,
-              tests: [] :: [ExUnit.Test.t]
+    defstruct [:file, :name, :setup_all?, :state, parameters: %{}, tags: %{}, tests: []]
+
+    @type t :: %__MODULE__{
+            file: binary(),
+            name: module,
+            parameters: map(),
+            setup_all?: boolean(),
+            state: ExUnit.state(),
+            tags: map,
+            tests: [ExUnit.Test.t()]
+          }
+  end
+
+  defmodule TestCase do
+    # TODO: Remove this module on v2.0 (it has been replaced by TestModule)
+    @moduledoc false
+    defstruct [:name, :state, tests: []]
+
+    @type t :: %__MODULE__{name: module, state: ExUnit.state(), tests: [ExUnit.Test.t()]}
+  end
+
+  defmodule TimeoutError do
+    @moduledoc """
+    Exception raised when a test times out.
+    """
+
+    @typedoc since: "1.16.0"
+    @type t :: %__MODULE__{
+            timeout: non_neg_integer,
+            type: String.t()
+          }
+
+    defexception [:timeout, :type]
+
+    @impl true
+    def message(%{timeout: timeout, type: type}) do
+      """
+      #{type} timed out after #{timeout}ms. You can change the timeout:
+
+        1. per test by setting "@tag timeout: x" (accepts :infinity)
+        2. per test module by setting "@moduletag timeout: x" (accepts :infinity)
+        3. globally via "ExUnit.start(timeout: x)" configuration
+        4. by running "mix test --timeout x" which sets timeout
+        5. or by running "mix test --trace" which sets timeout to infinity
+           (useful when using IEx.pry/0)
+
+      where "x" is the timeout given as integer in milliseconds (defaults to 60_000).
+      """
+    end
   end
 
   use Application
 
   @doc false
   def start(_type, []) do
-    import Supervisor.Spec
-
     children = [
-      worker(ExUnit.Server, []),
-      worker(ExUnit.OnExitHandler, [])
+      ExUnit.Server,
+      ExUnit.CaptureServer
     ]
 
     opts = [strategy: :one_for_one, name: ExUnit.Supervisor]
@@ -114,29 +254,39 @@ defmodule ExUnit do
 
   @doc """
   Starts ExUnit and automatically runs tests right before the
-  VM terminates. It accepts a set of options to configure `ExUnit`
+  VM terminates.
+
+  It accepts a set of `options` to configure `ExUnit`
   (the same ones accepted by `configure/1`).
 
-  If you want to run tests manually, you can set `:autorun` to `false`.
+  If you want to run tests manually, you can set the `:autorun` option
+  to `false` and use `run/0` to run tests.
   """
+  @spec start(configure_opts()) :: :ok
   def start(options \\ []) do
-    Application.start(:elixir)
-    Application.start(:ex_unit)
+    {:ok, _} = Application.ensure_all_started(:ex_unit)
 
     configure(options)
 
-    if Application.get_env(:ex_unit, :autorun, true) do
+    if Application.fetch_env!(:ex_unit, :autorun) do
       Application.put_env(:ex_unit, :autorun, false)
 
-      System.at_exit fn
+      System.at_exit(fn
         0 ->
-          %{failures: failures} = ExUnit.run
-          System.at_exit fn _ ->
-            if failures > 0, do: System.halt(1)
+          time = ExUnit.Server.modules_loaded(false)
+          seed = Application.get_env(:ex_unit, :seed)
+          options = persist_defaults(configuration())
+          %{failures: failures} = maybe_repeated_run(options, seed, time)
+
+          if failures > 0 do
+            System.at_exit(fn _ -> exit({:shutdown, Keyword.fetch!(options, :exit_status)}) end)
           end
+
         _ ->
           :ok
-      end
+      end)
+    else
+      :ok
     end
   end
 
@@ -147,50 +297,313 @@ defmodule ExUnit do
 
   ExUnit supports the following options:
 
-    * `:color` - when color should be used by specific formatters;
-      defaults to the result of `IO.ANSI.terminal?/1`
+    * `:assert_receive_timeout` - the timeout to be used on `assert_receive`
+      calls in milliseconds, defaults to `100`;
+
+    * `:autorun` - if ExUnit should run by default on exit. Defaults to `true`;
+
+    * `:capture_log` - if ExUnit should default to keeping track of log messages
+      and print them on test failure. Can be overridden for individual tests via
+      `@tag capture_log: false`. This can also be configured to a specific level
+      with `capture_log: [level: LEVEL]`, to capture all logs but only keep those
+      above `LEVEL`. Note that `on_exit` and `setup_all` callbacks may still log,
+      as they run outside of the testing process. To silent those, you can use
+      `ExUnit.CaptureLog.capture_log/2` or consider disabling logging altogether.
+
+    * `:colors` - a keyword list of color options to be used by some formatters:
+      * `:enabled` - boolean option to enable colors, defaults to `IO.ANSI.enabled?/0`;
+
+      * `:success` - success message (defaults to `:green`)
+      * `:invalid` - invalid test message (defaults to `:yellow`)
+      * `:skipped` - skipped test message (defaults to `:yellow`)
+      * `:failure` - failed test message (defaults to `:red`)
+      * `:error_info` - display of actual error (defaults to `:red`)
+      * `:extra_info` - additional information (defaults to `:cyan`)
+      * `:location_info` - filename and tags (defaults to `[:bright, :black]`)
+      * `:diff_insert` - color of the insertions on diffs, defaults to `:green`;
+      * `:diff_insert_whitespace` - color of the whitespace insertions on diffs,
+        defaults to `IO.ANSI.color_background(2, 0, 0)`;
+      * `:diff_delete` - color of the deletions on diffs, defaults to `:red`;
+      * `:diff_delete_whitespace` - color of the whitespace deletions on diffs,
+        defaults to `IO.ANSI.color_background(0, 2, 0)`;
+
+    * `:exclude` - specifies which tests are run by skipping tests that match the
+      filter. See the "Filters" section in the documentation for `ExUnit.Case`;
+
+    * `:exit_status` - specifies an alternate exit status to use when the test
+      suite fails. Defaults to `2`;
+
+    * `:failures_manifest_path` - specifies a path to the file used to store failures
+      between runs;
+
+    * `:formatters` - the formatters that will print results,
+      defaults to `[ExUnit.CLIFormatter]`;
+
+    * `:include` - specifies which tests are run by skipping tests that do not
+      match the filter. Keep in mind that all tests are included by default, so unless they are
+      excluded first, the `:include` option has no effect. To only run the tests
+      that match the `:include` filter, exclude the `:test` tag first (see the
+      documentation for `ExUnit.Case` for more information on tags and filters);
+
+    * `:max_cases` - maximum number of tests to run in parallel. Only tests from
+      different modules run in parallel. It defaults to `System.schedulers_online * 2`
+      to optimize both CPU-bound and IO-bound tests;
+
+    * `:max_failures` - the suite stops evaluating tests when this number of test failures
+      is reached. All tests within a module that fail when using the
+      [`setup_all/1,2`](`ExUnit.Callbacks.setup_all/1`) callbacks
+      are counted as failures. Defaults to `:infinity`;
+
+    * `:only_test_ids` - a list of `{module_name, test_name}` tuples that limits
+      what tests get run. This is typically used by Mix to filter which tests
+      should run;
+
+    * `:rand_algorithm` - algorithm to be used when generating the test seed.
+      Available algorithms can be found in Erlang's
+      [`:rand`](`:rand`) documentation (see
+      [`:rand.builting_arg/0`](https://www.erlang.org/doc/apps/stdlib/rand.html#t:builtin_alg/0)).
+      Available since v1.16.0. Before v1.16.0, the algorithm was hard-coded to
+      `:exs1024`. On Elixir v1.16.0 and after, the default changed to `:exsss`;
+
+    * `:refute_receive_timeout` - the timeout to be used on `refute_receive`
+      calls in milliseconds, defaults to `100`;
+
+    * `:seed` - an integer seed value to randomize the test suite. This seed
+      is also mixed with the test module and name to create a new unique seed
+      on every test, which is automatically fed into the [`:rand`](`:rand`) module.
+      This provides randomness between tests, but predictable and reproducible
+      results. A `:seed` of `0` will disable randomization and the tests in each
+      file will always run in the order that they were defined in;
+
+    * `:slowest` - prints timing information for the N slowest tests. Running
+      ExUnit with slow test reporting automatically runs in `trace` mode. It
+      is disabled by default;
+
+    * `:slowest_modules` - prints timing information for the N slowest test modules. Running
+      ExUnit with slow test reporting automatically runs in `trace` mode. It
+      is disabled by default;
+
+    * `:stacktrace_depth` - configures the stacktrace depth to be used
+      on formatting and reporters, defaults to `20`;
+
+    * `:timeout` - sets the timeout for the tests in milliseconds, defaults to `60_000`;
+
+    * `:trace` - sets ExUnit into trace mode, this sets `:max_cases` to `1` and
+      prints each test case and test while running. Note that in trace mode test
+      timeouts will be ignored as timeout is set to `:infinity`;
+
+    * `:test_location_relative_path` - the test location is the file:line information
+      printed by tests as a shortcut to run a given test. When this value is set,
+      the value is used as a prefix for the test itself. This is typically used by
+      Mix to properly set-up umbrella projects;
+
+  Any arbitrary configuration can also be passed to `configure/1` or `start/1`,
+  and these options can then be used in places such as custom formatters. These
+  other options will be ignored by ExUnit itself.
+  """
+  @spec configure(configure_opts()) :: :ok
+  def configure(options) when is_list(options) do
+    Enum.each(options, fn {k, v} ->
+      Application.put_env(:ex_unit, k, v)
+    end)
+  end
 
-    * `:formatters` - the formatters that will print results;
-      defaults to `[ExUnit.CLIFormatter]`
+  @doc """
+  Returns ExUnit configuration.
 
-    * `:max_cases` - maximum number of cases to run in parallel;
-      defaults to `:erlang.system_info(:schedulers_online)`
+  For the available configuration options, see `configure/1`.
+  """
+  @spec configuration() :: Keyword.t()
+  def configuration do
+    Application.get_all_env(:ex_unit)
+    |> put_seed()
+    |> put_slowest()
+    |> put_max_cases()
+  end
 
-    * `:trace` - set ExUnit into trace mode, this sets `:max_cases` to `1` and
-      prints each test case and test while running
+  @doc """
+  Returns the pluralization for `word`.
 
-    * `:autorun` - if ExUnit should run by default on exit; defaults to `true`
+  If one is not registered, returns the word appended with an "s".
+  """
+  @spec plural_rule(binary) :: binary
+  def plural_rule(word) when is_binary(word) do
+    Application.get_env(:ex_unit, :plural_rules, %{})
+    |> Map.get(word, "#{word}s")
+  end
 
-    * `:include` - specify which tests are run by skipping tests that do not
-      match the filter
+  @doc """
+  Registers a `pluralization` for `word`.
 
-    * `:exclude` - specify which tests are run by skipping tests that match the
-      filter
+  If one is already registered, it is replaced.
+  """
+  @spec plural_rule(binary, binary) :: :ok
+  def plural_rule(word, pluralization) when is_binary(word) and is_binary(pluralization) do
+    plural_rules =
+      Application.get_env(:ex_unit, :plural_rules, %{})
+      |> Map.put(word, pluralization)
 
-    * `:seed` - an integer seed value to randomize the test suite
+    configure(plural_rules: plural_rules)
+  end
+
+  @doc """
+  Runs the tests. It is invoked automatically
+  if ExUnit is started via `start/1`.
+
+  From Elixir v1.14, it accepts an optional list of modules to run
+  as part of the suite. This is often used to rerun modules already
+  loaded in memory.
+
+  Returns a map containing the total number of tests, the number
+  of failures, the number of excluded tests and the number of skipped tests.
   """
-  def configure(options) do
-    Enum.each options, fn {k, v} ->
-      Application.put_env(:ex_unit, k, v)
+  @spec run([module()]) :: suite_result()
+  def run(additional_modules \\ []) do
+    for module <- additional_modules do
+      if Code.ensure_loaded?(module) and function_exported?(module, :__ex_unit__, 1) do
+        ExUnit.Server.add_module(module, module.__ex_unit__(:config))
+      else
+        raise(ArgumentError, "#{inspect(module)} is not a ExUnit.Case module")
+      end
     end
+
+    _ = ExUnit.Server.modules_loaded(additional_modules != [])
+    seed = Application.get_env(:ex_unit, :seed)
+    options = persist_defaults(configuration())
+    maybe_repeated_run(options, seed, nil)
   end
 
   @doc """
-  Returns ExUnit configuration.
+  Starts tests asynchronously while test cases are still loading.
+
+  It returns a task that must be given to `await_run/0` when a result
+  is desired.
   """
-  def configuration do
-    Application.get_all_env(:ex_unit)
+  @doc since: "1.12.0"
+  @spec async_run() :: Task.t()
+  def async_run() do
+    seed = Application.get_env(:ex_unit, :seed)
+    options = persist_defaults(configuration())
+
+    Task.async(fn ->
+      maybe_repeated_run(options, seed, nil)
+    end)
   end
 
   @doc """
-  API used to run the tests. It is invoked automatically
-  if ExUnit is started via `ExUnit.start/1`.
+  Awaits for a test suite that has been started with `async_run/0`.
+  """
+  @doc since: "1.12.0"
+  @spec await_run(Task.t()) :: suite_result()
+  def await_run(task) do
+    ExUnit.Server.modules_loaded(false)
+    Task.await(task, :infinity)
+  end
+
+  @doc """
+  Sets a callback to be executed after the completion of a test suite.
+
+  Callbacks set with `after_suite/1` must accept a single argument, which is a
+  map containing the results of the test suite's execution.
+
+  If `after_suite/1` is called multiple times, the callbacks will be called in
+  reverse order. In other words, the last callback set will be the first to be
+  called.
+  """
+  @doc since: "1.8.0"
+  @spec after_suite((suite_result() -> any)) :: :ok
+  def after_suite(function) when is_function(function) do
+    current_callbacks = Application.fetch_env!(:ex_unit, :after_suite)
+    configure(after_suite: [function | current_callbacks])
+  end
+
+  @doc """
+  Fetches the test supervisor for the current test.
+
+  Returns `{:ok, supervisor_pid}` or `:error` if not called from the test process.
 
-  Returns a map containing the number of tests and the number
-  of failures.
+  This is the same supervisor as used by `ExUnit.Callbacks.start_supervised/2`
+  and similar, see `ExUnit.Callbacks` module documentation for more information.
   """
-  def run do
-    {async, sync, load_us} = ExUnit.Server.start_run
-    ExUnit.Runner.run async, sync, configuration, load_us
+  @doc since: "1.11.0"
+  @spec fetch_test_supervisor() :: {:ok, pid()} | :error
+  def fetch_test_supervisor() do
+    case ExUnit.OnExitHandler.get_supervisor(self()) do
+      {:ok, nil} ->
+        {:ok, sup} = ExUnit.OnExitHandler.Supervisor.start_link([])
+        ExUnit.OnExitHandler.put_supervisor(self(), sup)
+        {:ok, sup}
+
+      {:ok, _} = ok ->
+        ok
+
+      :error ->
+        :error
+    end
+  end
+
+  # Persists default values in application
+  # environment before the test suite starts.
+  defp persist_defaults(config) do
+    config |> Keyword.take([:max_cases, :seed, :trace]) |> configure()
+    config
+  end
+
+  defp maybe_repeated_run(options, seed, load_us) do
+    repeat = Keyword.fetch!(options, :repeat_until_failure)
+    maybe_repeated_run(options, seed, load_us, repeat)
+  end
+
+  defp maybe_repeated_run(options, seed, load_us, repeat) do
+    case ExUnit.Runner.run(options, load_us) do
+      {%{failures: 0}, {async_modules, sync_modules}}
+      when repeat > 0 and (sync_modules != [] or async_modules != []) ->
+        ExUnit.Server.restore_modules(async_modules, sync_modules)
+
+        # Clear the seed if it was generated
+        if seed == nil do
+          Application.delete_env(:ex_unit, :seed)
+        end
+
+        # Re-run configuration
+        options = persist_defaults(configuration())
+        maybe_repeated_run(options, seed, load_us, repeat - 1)
+
+      {stats, _} ->
+        stats
+    end
+  end
+
+  defp put_seed(opts) do
+    Keyword.put_new_lazy(opts, :seed, fn ->
+      # We're using `rem System.system_time()` here
+      # instead of directly using :os.timestamp or using the
+      # :microsecond argument because the VM on Windows has odd
+      # precision. Calling with :microsecond will give us a multiple
+      # of 1000. Calling without it gives actual microsecond precision.
+      System.system_time()
+      |> System.convert_time_unit(:native, :microsecond)
+      |> rem(1_000_000)
+    end)
+  end
+
+  defp put_max_cases(opts) do
+    Keyword.put(opts, :max_cases, max_cases(opts))
+  end
+
+  defp put_slowest(opts) do
+    if opts[:slowest] > 0 or opts[:slowest_modules] > 0 do
+      Keyword.put(opts, :trace, true)
+    else
+      opts
+    end
+  end
+
+  defp max_cases(opts) do
+    cond do
+      opts[:trace] -> 1
+      max = opts[:max_cases] -> max
+      true -> System.schedulers_online() * 2
+    end
   end
 end
diff --git a/lib/ex_unit/lib/ex_unit/assertions.ex b/lib/ex_unit/lib/ex_unit/assertions.ex
index b79b8e6e077..c55a5db4e62 100644
--- a/lib/ex_unit/lib/ex_unit/assertions.ex
+++ b/lib/ex_unit/lib/ex_unit/assertions.ex
@@ -1,17 +1,82 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.AssertionError do
+  @moduledoc """
+  Raised to signal an assertion error.
+
+  This is used by macros such as `ExUnit.Assertions.assert/1`.
+  """
+
   @no_value :ex_unit_no_meaningful_value
 
-  defexception left:    @no_value,
-               right:   @no_value,
+  @typedoc since: "1.16.0"
+  @type t :: %__MODULE__{
+          left: any,
+          right: any,
+          message: any,
+          expr: any,
+          args: any,
+          doctest: any,
+          context: any
+        }
+
+  defexception left: @no_value,
+               right: @no_value,
                message: @no_value,
-               expr:    @no_value
+               expr: @no_value,
+               args: @no_value,
+               doctest: @no_value,
+               context: :==
 
   @doc """
   Indicates no meaningful value for a field.
   """
+  @spec no_value :: atom
   def no_value do
     @no_value
   end
+
+  @impl true
+  def exception(message) when is_binary(message) do
+    %ExUnit.AssertionError{message: message}
+  end
+
+  def exception(opts) do
+    with {:ok, message} when not is_binary(message) <- Keyword.fetch(opts, :message) do
+      raise ArgumentError,
+            ":message in ExUnit.Assertion must be a binary, got: #{inspect(message)}"
+    end
+
+    struct(__MODULE__, opts)
+  end
+
+  @impl true
+  def message(exception) do
+    "\n\n" <> ExUnit.Formatter.format_assertion_error(exception)
+  end
+end
+
+defmodule ExUnit.MultiError do
+  @moduledoc """
+  Raised to signal multiple errors happened in a test case.
+  """
+
+  @typedoc since: "1.16.0"
+  @type t :: %__MODULE__{
+          errors: [{Exception.kind(), any, Exception.stacktrace()}]
+        }
+
+  defexception errors: []
+
+  @impl true
+  def message(%{errors: errors}) do
+    "got the following errors:\n\n" <>
+      Enum.map_join(errors, "\n\n", fn {kind, error, stack} ->
+        Exception.format_banner(kind, error, stack)
+      end)
+  end
 end
 
 defmodule ExUnit.Assertions do
@@ -20,137 +85,183 @@ defmodule ExUnit.Assertions do
   imported by default into your test cases.
 
   In general, a developer will want to use the general
-  `assert` macro in tests. This macro tries to be smart
-  and provide good reporting whenever there is a failure.
+  `assert` macro in tests. This macro introspects your code
+  and provides good reporting whenever there is a failure.
   For example, `assert some_fun() == 10` will fail (assuming
-  `some_fun()` returns 13):
+  `some_fun()` returns `13`):
 
-     Comparison (using ==) failed in:
-     code: some_fun() == 10
-     lhs:  13
-     rhs:  10
+      Comparison (using ==) failed in:
+      code:  assert some_fun() == 10
+      left:  13
+      right: 10
 
   This module also provides other convenience functions
-  like `assert_in_delta` and `assert_raise` to easily handle other
-  common cases such as checking a floating point number or handling exceptions.
+  like `assert_in_delta` and `assert_raise` to easily handle
+  other common cases such as checking a floating-point number
+  or handling exceptions.
   """
 
   @doc """
-  Asserts its argument is true.
+  Asserts its argument is a truthy value.
+
+  `assert` introspects the underlying expression and provides
+  good reporting whenever there is a failure. For example,
+  if the expression uses the comparison operator, the message
+  will show the values of the two sides. The assertion
+
+      assert 1 + 2 + 3 + 4 > 15
 
-  `assert` tries to be smart and provide good
-  reporting whenever there is a failure. In particular, if
-  given a match expression, it will report any failure in terms
-  of that match. Given
+   will fail with the message:
+
+      Assertion with > failed
+      code:  assert 1 + 2 + 3 + 4 > 15
+      left:  10
+      right: 15
+
+  Similarly, if a match expression is given, it will report
+  any failure in terms of that match. Given
 
-      assert [one] = [two]
+      assert [1] = [2]
 
   you'll see:
 
       match (=) failed
-      code: [one] = [two]
-      rhs:  [2]
+      code:  assert [1] = [2]
+      left: [1]
+      right: [2]
 
-  If the expression is a comparison operator, the message
-  will show the values of the two sides. The assertion
+  Keep in mind that `assert` does not change its semantics
+  based on the expression. In other words, the expression
+  is still required to return a truthy value. For example,
+  the following will fail:
 
-      assert 1+2+3+4 > 15
+      assert nil = some_function_that_returns_nil()
 
-   will fail with the message:
+  Even though the match works, `assert` still expects a truth
+  value. In such cases, simply use `==/2` or `match?/2`.
+
+  If you need more complex pattern matching using guards, you
+  need to use `match?/2`:
+
+      assert match?([%{id: id} | _] when is_integer(id), records)
 
-      Assertion with > failed
-      code: 1+2+3+4 > 15
-      lhs:  10
-      rhs:  15
   """
-  defmacro assert({:=, _, [left, right]} = assertion) do
-    code = Macro.escape(assertion)
-    {:case, meta, args} =
-      quote do
-        case right do
-          unquote(left) ->
-            right
-          _ ->
-            raise ExUnit.AssertionError,
-              right: right,
-              expr: unquote(code),
-              message: "match (=) failed"
+  defmacro assert({:=, meta, [left, right]} = assertion) do
+    code = escape_quoted(:assert, meta, mark_as_generated(assertion))
+
+    check =
+      quote generated: true do
+        if right do
+          :ok
+        else
+          raise ExUnit.AssertionError,
+            expr: expr,
+            message: "Expected truthy, got #{inspect(right)}"
         end
       end
 
+    {left, right} = move_match(left, right)
+    __match__(left, right, code, check, __CALLER__)
+  end
+
+  defmacro assert({:match?, meta, [left, right]} = assertion) do
+    code = escape_quoted(:assert, meta, mark_as_generated(assertion))
+    match? = {:match?, meta, [left, Macro.var(:right, __MODULE__)]}
+
+    left = __expand_pattern__(left, __CALLER__)
+    pins = collect_pins_from_pattern(left, Macro.Env.vars(__CALLER__))
+
     quote do
       right = unquote(right)
-      unquote({:case, [{:export_head, true}|meta], args})
+      left = unquote(Macro.escape(left))
+
+      ExUnit.Assertions.assert(unquote(match?),
+        right: right,
+        left: left,
+        expr: unquote(code),
+        message: "match (match?) failed" <> ExUnit.Assertions.__pins__(unquote(pins)),
+        context: {:match, unquote(pins)}
+      )
     end
   end
 
   defmacro assert(assertion) do
-    case translate_assertion(assertion) do
-      nil ->
-        quote do
-          value = unquote(assertion)
-
-          unless value do
-            raise ExUnit.AssertionError,
-              expr: unquote(Macro.escape(assertion)),
-              message: "Expected truthy, got #{inspect value}"
-          end
+    if translated = translate_assertion(:assert, assertion, __CALLER__) do
+      translated
+    else
+      {args, value} = extract_args(assertion, __CALLER__)
 
+      quote generated: true do
+        if value = unquote(value) do
           value
+        else
+          raise ExUnit.AssertionError,
+            args: unquote(args),
+            expr: unquote(escape_quoted(:assert, [], assertion)),
+            message: "Expected truthy, got #{inspect(value)}"
         end
-
-      value ->
-        value
+      end
     end
   end
 
   @doc """
-  This is a negative assertion, failing if its parameter
-  is truthy.
+  A negative assertion, expects the expression to be `false` or `nil`.
+
+  Keep in mind that `refute` does not change the semantics of
+  the given expression. In other words, the following will fail:
+
+      refute {:ok, _} = some_function_that_returns_error_tuple()
+
+  The code above will fail because the `=` operator always fails
+  when the sides do not match and `refute/2` does not change it.
+
+  The correct way to write the refutation above is to use `match?/2`:
+
+      refute match?({:ok, _}, some_function_that_returns_error_tuple())
 
   ## Examples
 
       refute age < 0
 
   """
-  defmacro refute({:=, _, [left, right]} = assertion) do
-    code = Macro.escape(assertion)
-    {:case, meta, args} =
-      quote do
-        case right do
-          unquote(left) ->
-            raise ExUnit.AssertionError,
-              right: right,
-              expr: unquote(code),
-              message: "match (=) succeeded, but should have failed"
-          _ ->
-            right
-        end
-      end
+  defmacro refute({:match?, meta, [left, right]} = assertion) do
+    code = escape_quoted(:refute, meta, assertion)
+    match? = {:match?, meta, [left, Macro.var(:right, __MODULE__)]}
+
+    left = __expand_pattern__(left, __CALLER__)
+    pins = collect_pins_from_pattern(left, Macro.Env.vars(__CALLER__))
 
     quote do
       right = unquote(right)
-      unquote({:case, [{:export_head, true}|meta], args})
+      left = unquote(Macro.escape(left))
+
+      refute unquote(match?),
+        right: right,
+        left: left,
+        expr: unquote(code),
+        message:
+          "match (match?) succeeded, but should have failed" <>
+            ExUnit.Assertions.__pins__(unquote(pins)),
+        context: {:match, unquote(pins)}
     end
   end
 
   defmacro refute(assertion) do
-    case translate_assertion({:!, [], [assertion]}) do
-      nil ->
-        quote do
-          value = unquote(assertion)
-
-          if value do
-            raise ExUnit.AssertionError,
-              expr: unquote(Macro.escape(assertion)),
-              message: "Expected false or nil, got #{inspect value}"
-          end
-
+    if translated = translate_assertion(:refute, assertion, __CALLER__) do
+      {:!, [generated: true], [translated]}
+    else
+      {args, value} = extract_args(assertion, __CALLER__)
+
+      quote generated: true do
+        if value = unquote(value) do
+          raise ExUnit.AssertionError,
+            args: unquote(args),
+            expr: unquote(escape_quoted(:refute, [], assertion)),
+            message: "Expected false or nil, got #{inspect(value)}"
+        else
           value
         end
-
-      value ->
-        {:!, [], [value]}
+      end
     end
   end
 
@@ -158,77 +269,211 @@ defmodule ExUnit.Assertions do
 
   @operator [:==, :<, :>, :<=, :>=, :===, :=~, :!==, :!=, :in]
 
-  defp translate_assertion({operator, _, [left, right]} = expr) when operator in @operator  do
-    expr = Macro.escape(expr)
+  defp translate_assertion(:assert, {operator, meta, [_, _]} = expr, caller)
+       when operator in @operator do
+    if match?([{_, Kernel}], Macro.Env.lookup_import(caller, {operator, 2})) do
+      left = Macro.var(:left, __MODULE__)
+      right = Macro.var(:right, __MODULE__)
+      call = {operator, meta, [left, right]}
+      equality_check? = operator in [:<, :>, :!==, :!=]
+      message = "Assertion with #{operator} failed"
+      translate_operator(:assert, expr, call, message, equality_check?, caller)
+    end
+  end
+
+  defp translate_assertion(:refute, {operator, meta, [_, _]} = expr, caller)
+       when operator in @operator do
+    if match?([{_, Kernel}], Macro.Env.lookup_import(caller, {operator, 2})) do
+      left = Macro.var(:left, __MODULE__)
+      right = Macro.var(:right, __MODULE__)
+      call = {:not, meta, [{operator, meta, [left, right]}]}
+      equality_check? = operator in [:<=, :>=, :===, :==, :=~]
+      message = "Refute with #{operator} failed"
+      translate_operator(:refute, expr, call, message, equality_check?, caller)
+    end
+  end
+
+  defp translate_assertion(_kind, _expected, _caller) do
+    nil
+  end
+
+  defp translate_operator(kind, {op, meta, [left, right]} = expr, call, message, true, _caller) do
+    expr = escape_quoted(kind, meta, expr)
+    context = if op in [:===, :!==], do: :===, else: :==
+
     quote do
-      left  = unquote(left)
+      left = unquote(left)
       right = unquote(right)
-      assert unquote(operator)(left, right),
-             left: left,
-             right: right,
-             expr: unquote(expr),
-             message: unquote("Assertion with #{operator} failed")
+      expr = unquote(expr)
+      message = unquote(message)
+
+      if ExUnit.Assertions.__equal__?(left, right) do
+        ExUnit.Assertions.assert(false,
+          left: left,
+          expr: expr,
+          message: message <> ", both sides are exactly equal"
+        )
+      else
+        ExUnit.Assertions.assert(unquote(call),
+          left: left,
+          right: right,
+          expr: expr,
+          message: message,
+          context: unquote(context)
+        )
+      end
     end
   end
 
-  defp translate_assertion({:!, [], [{operator, _, [left, right]} = expr]}) when operator in @operator do
-    expr = Macro.escape(expr)
+  defp translate_operator(kind, {op, meta, [left, right]} = expr, call, message, false, _caller) do
+    expr = escape_quoted(kind, meta, expr)
+    context = if op in [:===, :!==], do: :===, else: :==
+
     quote do
-      left  = unquote(left)
+      left = unquote(left)
       right = unquote(right)
-      assert not(unquote(operator)(left, right)),
-             left: left,
-             right: right,
-             expr: unquote(expr),
-             message: unquote("Refute with #{operator} failed")
+
+      ExUnit.Assertions.assert(unquote(call),
+        left: left,
+        right: right,
+        expr: unquote(expr),
+        message: unquote(message),
+        context: unquote(context)
+      )
     end
   end
 
-  defp translate_assertion(_expected) do
-    nil
+  @doc false
+  def __equal__?(left, right) do
+    left === right
+  end
+
+  defp escape_quoted(kind, meta, expr) do
+    Macro.escape({kind, meta, [expr]}, prune_metadata: true)
+  end
+
+  defp extract_args({root, meta, [_ | _] = args} = expr, env) do
+    arity = length(args)
+
+    reserved? =
+      is_atom(root) and (Macro.special_form?(root, arity) or Macro.operator?(root, arity))
+
+    all_quoted_literals? = Enum.all?(args, &Macro.quoted_literal?/1)
+
+    case Macro.expand_once(expr, env) do
+      ^expr when not reserved? and not all_quoted_literals? ->
+        vars = for i <- 1..arity, do: Macro.var(:"arg#{i}", __MODULE__)
+
+        quoted =
+          quote do
+            {unquote_splicing(vars)} = {unquote_splicing(args)}
+            unquote({root, meta, vars})
+          end
+
+        {vars, quoted}
+
+      other ->
+        {ExUnit.AssertionError.no_value(), other}
+    end
+  end
+
+  defp extract_args(expr, _env) do
+    {ExUnit.AssertionError.no_value(), expr}
+  end
+
+  defp move_match(left, {:=, meta, [middle, right]}),
+    do: move_match({:=, meta, [left, middle]}, right)
+
+  defp move_match(left, right),
+    do: {left, right}
+
+  @doc false
+  def __match__({:when, _, _} = left, right, _, _, _) do
+    suggestion =
+      quote do
+        assert match?(unquote(left), unquote(right))
+      end
+
+    raise ArgumentError, """
+    invalid pattern in assert/1:
+
+    #{Macro.to_string(left) |> Inspect.Error.pad(2)}
+
+    To assert with guards, use match?/2:
+
+    #{Macro.to_string(suggestion) |> Inspect.Error.pad(2)}
+    """
+  end
+
+  def __match__(left, right, code, check, caller) do
+    left = __expand_pattern__(left, caller)
+    vars = collect_vars_from_pattern(left)
+    pins = collect_pins_from_pattern(left, Macro.Env.vars(caller))
+
+    match_expr =
+      suppress_warning(
+        quote do
+          case right do
+            unquote(left) ->
+              unquote(check)
+              {unquote_splicing(mark_as_generated(vars))}
+
+            _ ->
+              left = unquote(Macro.escape(left))
+
+              raise ExUnit.AssertionError,
+                left: left,
+                right: right,
+                expr: expr,
+                message: "match (=) failed" <> ExUnit.Assertions.__pins__(unquote(pins)),
+                context: {:match, unquote(pins)}
+          end
+        end
+      )
+
+    quote do
+      right = unquote(right)
+      expr = unquote(code)
+      {unquote_splicing(vars)} = unquote(match_expr)
+      right
+    end
   end
 
   ## END HELPERS
 
   @doc """
-  Asserts `value` is true, displaying the given `message` otherwise.
+  Asserts `value` is truthy, displaying the given `message` otherwise.
 
   ## Examples
 
       assert false, "it will never be true"
 
+      assert x == :foo, "expected x to be foo"
+
+      assert match?({:ok, _}, x), "expected x to match {:ok, _}"
+
   """
   def assert(value, message) when is_binary(message) do
     assert(value, message: message)
   end
 
   def assert(value, opts) when is_list(opts) do
-    unless value, do: raise(ExUnit.AssertionError, opts)
+    if !value, do: raise(ExUnit.AssertionError, opts)
     true
   end
 
   @doc """
-  Asserts `value` is true.
-  If it fails, it raises an expectation error
-  using the given `left` and `right` values.
+  Asserts that a message matching `pattern` was or is going to be received
+  within the `timeout` period, specified in milliseconds.
 
-  You probably don't need to use this—the regular `assert` function
-  handles this for you.
+  Unlike `assert_received`, it has a configurable timeout.
+  The default timeout duration is determined by the `assert_receive_timeout` option,
+  which can be set using `ExUnit.configure/1`. This option defaults to 100 milliseconds.
 
-  ## Examples
-
-      assert this > that, this, that, "more than"
-
-  """
-  def assert(value, left, right, message) when is_binary(message) do
-    assert(value, left: left, right: right, message: message)
-  end
-
-  @doc """
-  Asserts a message was or is going to be received. Unlike
-  `assert_received`, it has a default timeout of 100 milliseconds.
+  The `pattern` argument must be a match pattern.
 
-  The `expected` argument is a pattern.
+  Flunks with `failure_message` if a message matching `pattern` is not received.
+  If a message matches, it is also removed from the process mailbox.
 
   ## Examples
 
@@ -246,69 +491,356 @@ defmodule ExUnit.Assertions do
       assert_receive {:count, ^x}
 
   """
-  defmacro assert_receive(expected, timeout \\ 100, message \\ nil) do
-    do_assert_receive(expected, timeout, message)
+  defmacro assert_receive(pattern, timeout \\ nil, failure_message \\ nil) do
+    code = escape_quoted(:assert_receive, [], pattern)
+    assert_receive(pattern, timeout, failure_message, __CALLER__, code)
   end
 
   @doc """
-  Asserts a message was received and is in the current process' mailbox.
-  Timeout is set to 0, so there is no waiting time.
+  Asserts that a message matching `pattern` was received and is in the
+  current process' mailbox.
+
+  The `pattern` argument must be a match pattern.
 
-  The `expected` argument is a pattern.
+  Flunks with `failure_message` if a message matching `pattern` was not received.
+  If a message matches, it is also removed from the process mailbox.
+
+  Timeout is set to `0`, so there is no waiting time.
 
   ## Examples
 
-      send self, :hello
+      send(self(), :hello)
       assert_received :hello
 
+      send(self(), :bye)
+      assert_received :hello, "Oh No!"
+      ** (ExUnit.AssertionError) Oh No!
+
   You can also match against specific patterns:
 
-      send self, {:hello, "world"}
+      send(self(), {:hello, "world"})
       assert_received {:hello, _}
 
   """
-  defmacro assert_received(expected, message \\ nil) do
-    do_assert_receive(expected, 0, message)
+  defmacro assert_received(pattern, failure_message \\ nil) do
+    code = escape_quoted(:assert_received, [], pattern)
+    assert_receive(pattern, 0, failure_message, __CALLER__, code)
   end
 
-  defp do_assert_receive(expected, timeout, message) do
-    binary = Macro.to_string(expected)
-    message = message || "No message matching #{binary}"
+  defp assert_receive(pattern, timeout, failure_message, caller, code) do
+    # Expand before extracting metadata
+    expanded_pattern = __expand_pattern__(pattern, caller)
+    vars = collect_vars_from_pattern(expanded_pattern)
+    pins = collect_pins_from_pattern(expanded_pattern, Macro.Env.vars(caller))
+
+    pattern =
+      case expanded_pattern do
+        {:when, meta, [left, right]} ->
+          {:when, meta, [quote(do: unquote(left) = received), right]}
+
+        left ->
+          quote(do: unquote(left) = received)
+      end
 
-    {:receive, meta, args} =
+    quoted_pattern =
       quote do
+        case message do
+          unquote(pattern) ->
+            _ = unquote(mark_as_generated(vars))
+            true
+
+          _ ->
+            false
+        end
+      end
+
+    pattern_finder =
+      quote do
+        fn message ->
+          unquote(suppress_warning(quoted_pattern))
+        end
+      end
+
+    on_timeout =
+      if failure_message do
+        quote do
+          flunk(unquote(failure_message))
+        end
+      else
+        quote do
+          ExUnit.Assertions.__timeout__(
+            unquote(Macro.escape(expanded_pattern)),
+            unquote(code),
+            unquote(pins),
+            unquote(pattern_finder),
+            timeout
+          )
+        end
+      end
+
+    quote do
+      timeout = ExUnit.Assertions.__timeout__(unquote(timeout), :assert_receive_timeout)
+
+      {received, unquote(vars)} =
         receive do
-          unquote(expected) = received -> received
+          unquote(pattern) -> {received, unquote(mark_as_generated(vars))}
         after
-          unquote(timeout) ->
-            flunk unquote(message)
+          timeout -> unquote(on_timeout)
         end
-      end
 
-    {:receive, [{:export_head, true}|meta], args}
+      received
+    end
+  end
+
+  @indent "\n  "
+  @max_mailbox_length 10
+
+  @doc false
+  def __timeout__(timeout, _) when is_integer(timeout) and timeout >= 0, do: timeout
+
+  def __timeout__(nil, key), do: Application.fetch_env!(:ex_unit, key)
+
+  def __timeout__(timeout, _),
+    do: raise(ArgumentError, "timeout must be a non-negative integer, got: #{inspect(timeout)}")
+
+  @doc false
+  def __timeout__(pattern, code, pins, pattern_finder, timeout) do
+    {:messages, messages} = Process.info(self(), :messages)
+
+    if Enum.any?(messages, pattern_finder) do
+      raise ExUnit.AssertionError,
+        expr: code,
+        message: """
+        Found message matching #{Macro.to_string(pattern)} after #{timeout}ms.
+
+        This means the message was delivered too close to the timeout value, you may want to either:
+
+          1. Give an increased timeout to `assert_receive/2`
+          2. Increase the default timeout to all `assert_receive` in your
+             test_helper.exs by setting ExUnit.configure(assert_receive_timeout: ...)
+        """
+    else
+      {message, mailbox} = format_mailbox(messages)
+
+      # The error contains a special `context` that will be transformed
+      # into `{:match, pins}` by the formatter to execute a diff for each
+      # message in the `mailbox`
+      raise ExUnit.AssertionError,
+        left: pattern,
+        expr: code,
+        message:
+          "Assertion failed, no matching message after #{timeout}ms" <>
+            ExUnit.Assertions.__pins__(pins) <> message,
+        context: {:mailbox, pins, mailbox}
+    end
   end
 
-  @doc """
+  @doc false
+  def __pins__(pins) do
+    pins
+    |> Enum.filter(fn {{_, ctx}, _} -> ctx == nil end)
+    |> Enum.sort()
+    |> Enum.map_join(@indent, fn {{name, _}, var} -> "#{name} = #{inspect(var)}" end)
+    |> case do
+      "" ->
+        ""
+
+      pinned ->
+        "\nThe following variables were pinned:" <> @indent <> pinned
+    end
+  end
+
+  defp format_mailbox(messages) do
+    length = length(messages)
+    mailbox = Enum.take(messages, -@max_mailbox_length)
+
+    {mailbox_message(length), mailbox}
+  end
+
+  defp mailbox_message(0), do: "\nThe process mailbox is empty."
+
+  defp mailbox_message(1) do
+    "\nShowing 1 of 1 message in the mailbox"
+  end
+
+  defp mailbox_message(length) when length > @max_mailbox_length do
+    "\nShowing #{@max_mailbox_length} of #{length} messages in the mailbox"
+  end
+
+  defp mailbox_message(length) do
+    "\nShowing #{length} of #{length} messages in the mailbox"
+  end
+
+  defp collect_pins_from_pattern(expr, vars) do
+    {_, pins} =
+      Macro.prewalk(expr, %{}, fn
+        {:quote, _, [_]}, acc ->
+          {:ok, acc}
+
+        {:quote, _, [_, _]}, acc ->
+          {:ok, acc}
+
+        {:^, _, [var]}, acc ->
+          identifier = var_context(var)
+
+          if identifier in vars do
+            {:ok, Map.put(acc, var_context(var), var)}
+          else
+            {:ok, acc}
+          end
+
+        form, acc ->
+          {form, acc}
+      end)
+
+    Enum.to_list(pins)
+  end
+
+  defp var_context({name, meta, context}) do
+    {name, meta[:counter] || context}
+  end
+
+  defp collect_vars_from_pattern({:when, _, [left, right]}) do
+    pattern = collect_vars_from_pattern(left)
+
+    vars =
+      for {name, _, context} = var <- collect_vars_from_pattern(right),
+          has_var?(pattern, name, context),
+          do: var
+
+    pattern ++ vars
+  end
+
+  defp collect_vars_from_pattern(expr) do
+    Macro.prewalk(expr, [], fn
+      {:"::", _, [left, right]}, acc ->
+        {[left], collect_vars_from_binary(right, acc)}
+
+      {skip, _, [_]}, acc when skip in [:^, :@, :quote] ->
+        {:ok, acc}
+
+      {skip, _, [_, _]}, acc when skip in [:quote] ->
+        {:ok, acc}
+
+      {:_, _, context}, acc when is_atom(context) ->
+        {:ok, acc}
+
+      {name, meta, context}, acc when is_atom(name) and is_atom(context) ->
+        {:ok, [{name, meta, context} | acc]}
+
+      node, acc ->
+        {node, acc}
+    end)
+    |> elem(1)
+  end
+
+  defp collect_vars_from_binary(right, original_acc) do
+    Macro.prewalk(right, original_acc, fn
+      {mode, _, [{name, meta, context}]}, acc
+      when is_atom(mode) and is_atom(name) and is_atom(context) ->
+        if has_var?(original_acc, name, context) do
+          {:ok, [{name, meta, context} | acc]}
+        else
+          {:ok, acc}
+        end
+
+      node, acc ->
+        {node, acc}
+    end)
+    |> elem(1)
+  end
+
+  defp has_var?(pattern, name, context), do: Enum.any?(pattern, &match?({^name, _, ^context}, &1))
+
+  defp mark_as_generated(vars) when is_list(vars) do
+    Enum.map(vars, fn {name, meta, context} -> {name, [generated: true] ++ meta, context} end)
+  end
+
+  defp mark_as_generated({name, meta, context}), do: {name, [generated: true] ++ meta, context}
+  defp mark_as_generated(other), do: other
+
+  @doc false
+  def __expand_pattern__({:when, meta, [left, right]}, caller) do
+    left = expand_pattern(left, Macro.Env.to_match(caller))
+    right = expand_pattern(right, %{caller | context: :guard})
+    {:when, meta, [left, right]}
+  end
+
+  def __expand_pattern__(expr, caller) do
+    expand_pattern(expr, Macro.Env.to_match(caller))
+  end
+
+  defp expand_pattern({:quote, _, [_]} = expr, _caller), do: expr
+  defp expand_pattern({:quote, _, [_, _]} = expr, _caller), do: expr
+  defp expand_pattern({:__aliases__, _, _} = expr, caller), do: Macro.expand(expr, caller)
+
+  defp expand_pattern({:@, _, [{attribute, _, _}]}, caller) do
+    caller.module |> Module.get_attribute(attribute) |> Macro.escape()
+  end
+
+  defp expand_pattern({left, meta, right} = expr, caller) do
+    case Macro.expand(expr, caller) do
+      ^expr ->
+        {expand_pattern(left, caller), meta, expand_pattern(right, caller)}
+
+      {left, meta, right} ->
+        {expand_pattern(left, caller), [original: expr] ++ meta, expand_pattern(right, caller)}
+
+      other ->
+        other
+    end
+  end
+
+  defp expand_pattern({left, right}, caller) do
+    {expand_pattern(left, caller), expand_pattern(right, caller)}
+  end
+
+  defp expand_pattern([_ | _] = list, caller) do
+    Enum.map(list, &expand_pattern(&1, caller))
+  end
+
+  defp expand_pattern(other, _caller), do: other
+
+  defp suppress_warning({name, meta, [expr, [do: clauses]]}) do
+    clauses =
+      Enum.map(clauses, fn {:->, meta, args} ->
+        {:->, [generated: true] ++ meta, args}
+      end)
+
+    {name, meta, [expr, [do: clauses]]}
+  end
+
+  @doc ~S"""
   Asserts the `exception` is raised during `function` execution with
-  the `expected_message`. Returns the rescued exception, fails otherwise.
+  the expected `message`, which can be a `Regex` or an exact `String`.
+  Returns the rescued exception, fails otherwise.
 
   ## Examples
 
       assert_raise ArithmeticError, "bad argument in arithmetic expression", fn ->
-        1 + "test"
+        1 / 0
       end
+
+      assert_raise RuntimeError, ~r/^today's lucky number is 0\.\d+!$/, fn ->
+        raise "today's lucky number is #{:rand.uniform()}!"
+      end
+
   """
   def assert_raise(exception, message, function) when is_function(function) do
     error = assert_raise(exception, function)
 
-    is_match = cond do
-      is_binary(message) -> Exception.message(error) == message
-      Regex.regex?(message) -> Exception.message(error) =~ message
-    end
+    match? =
+      cond do
+        is_binary(message) -> Exception.message(error) == message
+        is_struct(message, Regex) -> Exception.message(error) =~ message
+      end
+
+    message =
+      "Wrong message for #{inspect(exception)}\n" <>
+        "expected:\n  #{inspect(message)}\n" <>
+        "actual:\n" <> "  #{inspect(Exception.message(error))}"
 
-    msg = "Wrong message for #{inspect exception}. " <>
-          "Expected #{inspect message}, got #{inspect Exception.message(error)}"
-    assert is_match, message: msg
+    if not match?, do: flunk(message)
 
     error
   end
@@ -323,53 +855,87 @@ defmodule ExUnit.Assertions do
         1 + "test"
       end
 
+      assert_raise RuntimeError, fn ->
+        raise "assertion will pass due to this raise"
+      end
+
   """
   def assert_raise(exception, function) when is_function(function) do
     try do
       function.()
     rescue
       error ->
-        stacktrace = System.stacktrace
         name = error.__struct__
 
         cond do
           name == exception ->
+            check_error_message(name, error)
             error
+
           name == ExUnit.AssertionError ->
-            reraise(error, stacktrace)
+            reraise(error, __STACKTRACE__)
+
           true ->
-            flunk "Expected exception #{inspect exception} but got #{inspect name} (#{Exception.message(error)})"
+            message =
+              "Expected exception #{inspect(exception)} " <>
+                "but got #{inspect(name)} (#{Exception.message(error)})"
+
+            reraise ExUnit.AssertionError, [message: message], __STACKTRACE__
         end
     else
-      _ -> flunk "Expected exception #{inspect exception} but nothing was raised"
+      _ -> flunk("Expected exception #{inspect(exception)} but nothing was raised")
     end
   end
 
+  defp check_error_message(module, error) do
+    module.message(error)
+  catch
+    kind, reason ->
+      message =
+        "Got exception #{inspect(module)} but it failed to produce a message with:\n\n" <>
+          Exception.format(kind, reason, __STACKTRACE__)
+
+      flunk(message)
+  end
+
   @doc """
-  Asserts that `val1` and `val2` differ by no more than `delta`.
+  Asserts that `value1` and `value2` differ by no more than `delta`.
 
+  This difference is inclusive, so the test will pass if the difference
+  and the `delta` are equal.
 
   ## Examples
 
       assert_in_delta 1.1, 1.5, 0.2
-      assert_in_delta 10, 15, 4
+      assert_in_delta 10, 15, 2
+      assert_in_delta 10, 15, 5
 
   """
-  def assert_in_delta(val1, val2, delta, message \\ nil) do
-    diff = abs(val1 - val2)
-    message = message ||
-      "Expected the difference between #{inspect val1} and " <>
-      "#{inspect val2} (#{inspect diff}) to be less than #{inspect delta}"
-    assert diff < delta, message
+  def assert_in_delta(value1, value2, delta, message \\ nil)
+
+  def assert_in_delta(_, _, delta, _) when delta < 0 do
+    raise ArgumentError, "delta must always be a positive number, got: #{inspect(delta)}"
+  end
+
+  def assert_in_delta(value1, value2, delta, message) do
+    diff = abs(value1 - value2)
+
+    message =
+      message ||
+        "Expected the difference between #{inspect(value1)} and " <>
+          "#{inspect(value2)} (#{inspect(diff)}) to be less than or equal to #{inspect(delta)}"
+
+    assert diff <= delta, message
   end
 
   @doc """
   Asserts `expression` will throw a value.
+
   Returns the thrown value or fails otherwise.
 
   ## Examples
 
-      assert catch_throw(throw 1) == 1
+      assert catch_throw(throw(1)) == 1
 
   """
   defmacro catch_throw(expression) do
@@ -378,11 +944,19 @@ defmodule ExUnit.Assertions do
 
   @doc """
   Asserts `expression` will exit.
-  Returns the exit status/message or fails otherwise.
+
+  Returns the exit status/message of the current process or fails otherwise.
 
   ## Examples
 
-      assert catch_exit(exit 1) == 1
+      assert catch_exit(exit(1)) == 1
+
+  To assert exits from linked processes started from the test, trap exits
+  with `Process.flag/2` and assert the exit message with `assert_receive/2`.
+
+      Process.flag(:trap_exit, true)
+      pid = spawn_link(fn -> Process.exit(self(), :normal) end)
+      assert_receive {:EXIT, ^pid, :normal}
 
   """
   defmacro catch_exit(expression) do
@@ -391,11 +965,12 @@ defmodule ExUnit.Assertions do
 
   @doc """
   Asserts `expression` will cause an error.
+
   Returns the error or fails otherwise.
 
   ## Examples
 
-      assert catch_error(error 1) == 1
+      assert catch_error(error(1)) == 1
 
   """
   defmacro catch_error(expression) do
@@ -405,11 +980,11 @@ defmodule ExUnit.Assertions do
   defp do_catch(kind, expr) do
     quote do
       try do
-        unquote(expr)
-        flunk "Expected to catch #{unquote(kind)}, got nothing"
+        _ = unquote(mark_as_generated(expr))
+        flunk("Expected to catch #{unquote(kind)}, got nothing")
       rescue
         e in [ExUnit.AssertionError] ->
-          reraise(e, System.stacktrace)
+          reraise(e, __STACKTRACE__)
       catch
         unquote(kind), we_got -> we_got
       end
@@ -429,70 +1004,84 @@ defmodule ExUnit.Assertions do
   end
 
   @doc """
-      refute_receive message, timeout \\ 100, message \\ nil
+  Asserts that a message matching `pattern` was not received (and won't be received)
+  within the `timeout` period, specified in milliseconds.
 
-  Asserts `message` was not received (and won't be received) within
-  the `timeout` period.
-
-  The `not_expected` argument is a match pattern.
+  The `pattern` argument must be a match pattern. Flunks with `failure_message`
+  if a message matching `pattern` is received.
 
   ## Examples
 
       refute_receive :bye
 
-  Refute received with a explicit timeout:
+  Refute received with an explicit timeout:
 
       refute_receive :bye, 1000
 
   """
-  defmacro refute_receive(not_expected, timeout \\ 100, message \\ nil) do
-    do_refute_receive(not_expected, timeout, message)
+  defmacro refute_receive(pattern, timeout \\ nil, failure_message \\ nil) do
+    do_refute_receive(pattern, timeout, failure_message)
   end
 
   @doc """
-  Asserts a message was not received (i.e. it is not in the current process mailbox).
-  The `not_expected` argument must be a match pattern.
+  Asserts a message matching `pattern` was not received (i.e. it is not in the
+  current process' mailbox).
+
+  The `pattern` argument must be a match pattern. Flunks with `failure_message`
+  if a message matching `pattern` was received.
 
-  Timeout is set to 0, so there is no waiting time.
+  Timeout is set to `0`, so there is no waiting time.
 
   ## Examples
 
-      send self, :hello
+      send(self(), :hello)
       refute_received :bye
 
+      send(self(), :hello)
+      refute_received :hello, "Oh No!"
+      ** (ExUnit.AssertionError) Oh No!
+
   """
-  defmacro refute_received(not_expected, message \\ nil) do
-    do_refute_receive(not_expected, 0, message)
+  defmacro refute_received(pattern, failure_message \\ nil) do
+    do_refute_receive(pattern, 0, failure_message)
   end
 
-  defp do_refute_receive(not_expected, timeout, message) do
-    receive_clause = refute_receive_clause(not_expected, message)
+  defp do_refute_receive(pattern, timeout, failure_message) do
+    receive_clause = refute_receive_clause(pattern, failure_message)
 
     quote do
+      timeout = ExUnit.Assertions.__timeout__(unquote(timeout), :refute_receive_timeout)
+
       receive do
         unquote(receive_clause)
       after
-        unquote(timeout) -> false
+        timeout -> false
       end
     end
   end
 
- defp refute_receive_clause(not_expected, nil) do
-  binary = Macro.to_string(not_expected)
-  quote do
-    unquote(not_expected) = actual ->
-      flunk "Unexpectedly received message #{inspect actual} (which matched #{unquote binary})"
+  defp refute_receive_clause(pattern, nil) do
+    binary = Macro.to_string(pattern)
+
+    quote do
+      unquote(pattern) = actual ->
+        flunk(
+          "Unexpectedly received message #{inspect(actual)} (which matched #{unquote(binary)})"
+        )
     end
   end
 
-  defp refute_receive_clause(not_expected, message) do
+  defp refute_receive_clause(pattern, failure_message) do
     quote do
-      unquote(not_expected) -> flunk unquote(message)
+      unquote(pattern) -> flunk(unquote(failure_message))
     end
   end
 
   @doc """
-  Asserts `val1` and `val2` are not within `delta`.
+  Asserts `value1` and `value2` are not within `delta`.
+
+  This difference is exclusive, so the test will fail if the difference
+  and the delta are equal.
 
   If you supply `message`, information about the values will
   automatically be appended to it.
@@ -503,15 +1092,19 @@ defmodule ExUnit.Assertions do
       refute_in_delta 10, 11, 2
 
   """
-  def refute_in_delta(val1, val2, delta, message \\ nil) do
-    diff = abs(val1 - val2)
-    message = if message do
-      message <> " (difference between #{inspect val1} " <>
-      "and #{inspect val2} is less than #{inspect delta})"
-    else
-      "Expected the difference between #{inspect val1} and " <>
-      "#{inspect val2} (#{inspect diff}) to be more than #{inspect delta}"
-    end
+  def refute_in_delta(value1, value2, delta, message \\ nil) do
+    diff = abs(value1 - value2)
+
+    message =
+      if message do
+        message <>
+          " (difference between #{inspect(value1)} " <>
+          "and #{inspect(value2)} is less than #{inspect(delta)})"
+      else
+        "Expected the difference between #{inspect(value1)} and " <>
+          "#{inspect(value2)} (#{inspect(diff)}) to be more than #{inspect(delta)}"
+      end
+
     refute diff < delta, message
   end
 
@@ -520,12 +1113,12 @@ defmodule ExUnit.Assertions do
 
   ## Examples
 
-      flunk "This should raise an error"
+      flunk("This should raise an error")
 
   """
   @spec flunk :: no_return
-  @spec flunk(String.t) :: no_return
-  def flunk(message \\ "Flunked!") do
+  @spec flunk(String.t()) :: no_return
+  def flunk(message \\ "Flunked!") when is_binary(message) do
     assert false, message: message
   end
 end
diff --git a/lib/ex_unit/lib/ex_unit/callbacks.ex b/lib/ex_unit/lib/ex_unit/callbacks.ex
index f05b0c32bee..5fad529b552 100644
--- a/lib/ex_unit/lib/ex_unit/callbacks.ex
+++ b/lib/ex_unit/lib/ex_unit/callbacks.ex
@@ -1,43 +1,75 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.Callbacks do
   @moduledoc ~S"""
-  Defines ExUnit Callbacks.
-
-  This module defines both `setup_all` and `setup` callbacks, as well as
-  the `on_exit` facility.
-
-  The setup callbacks are defined via macros and each one can optionally
-  receive a map with metadata, usually referred to as `context`. The
-  callback may optionally put extra data into `context` to be used in
-  the tests.
+  Defines ExUnit callbacks.
+
+  This module defines the `setup/1`, `setup/2`, `setup_all/1`, and
+  `setup_all/2` macros, as well as process lifecycle and management
+  functions, such as `on_exit/2`, `start_supervised/2`, `stop_supervised/1`
+  and `start_link_supervised!/2`.
+
+  The setup callbacks may be used to define [test fixtures](https://en.wikipedia.org/wiki/Test_fixture#Software)
+  and run any initialization code which help bring the system into a known
+  state. They are defined via macros and each one can optionally receive a map
+  with test state and metadata, usually referred to as the `context`.
+  Optionally, the context to be used in the tests can be extended by the
+  setup callbacks by returning a properly structured value (see below).
+
+  The `setup_all` callbacks are invoked only once per module, before any
+  test is run. All `setup` callbacks are run before each test. No callback
+  is run if the test case has no tests or all tests have been filtered out.
+
+  `setup` and `setup_all` callbacks can be defined by either a block, an atom
+  naming a local function, a `{module, function}` tuple, or a list of atoms/tuples.
+
+  Both can opt to receive the current context by specifying it
+  as a parameter if defined by a block. Functions used to define a test
+  setup must accept the context as a single argument.
+
+  A test module can define multiple `setup` and `setup_all` callbacks,
+  and they are invoked in order of appearance.
+
+  `start_supervised/2` is used to start processes under a supervisor. The
+  supervisor is linked to the current test process. The supervisor as well
+  as all child processes are guaranteed to terminate before any `on_exit/2`
+  callback runs.
+
+  `on_exit/2` callbacks are registered on demand, usually to undo an action
+  performed by a setup callback. `on_exit/2` may also take a reference,
+  allowing the callback to be overridden in the future. A registered `on_exit/2`
+  callback will always run, while failures in `setup` and `setup_all` will stop
+  all remaining setup callbacks from executing.
 
-  The `setup_all` callbacks are invoked once before the first test's `setup`
-  and all `setup` callbacks are run before each test. No callback runs if the
-  test case has no tests or all tests were filtered out.
+  Finally, `setup_all` callbacks run in a separate process per module, while
+  all `setup` callbacks run in the same process as the test itself. `on_exit/2`
+  callbacks always run in a separate process, as implied by their name. The
+  test process always exits with reason `:shutdown`, which means any process
+  linked to the test process will also exit, although asynchronously. Therefore
+  it is preferred to use `start_supervised/2` to guarantee synchronous termination.
 
-  `on_exit` callbacks are registered on demand, usually to undo an action
-  performed by a setup callback. `on_exit` may also take a reference,
-  allowing callback to be overridden in the future. A registered `on_exit`
-  callback always runs, while failures in `setup` and `setup_all` will stop
-  all remaining setup callbacks from executing.
+  Here is a rundown of the life cycle of the test process:
 
-  Finally, `setup_all` callbacks run in the test case process, while all
-  `setup` callbacks run in the same process as the test itself. `on_exit`
-  callbacks always run in a separate process than the test case or the
-  test itself. Since the test process exits with reason `:shutdown`, most
-  of times `on_exit/1` can be avoided as processes are going to clean
-  up on their own.
+    1. the test process is spawned
+    2. it runs `setup/2` callbacks
+    3. it runs the test itself
+    4. it stops all supervised processes
+    5. the test process exits with reason `:shutdown`
+    6. `on_exit/2` callbacks are executed in a separate process
 
   ## Context
 
-  If you return `{:ok, <dict>}` from `setup_all`, the dictionary
-  will be merged into the current context and be available in all
-  subsequent `setup_all`, `setup` and the test itself.
+  `setup_all` or `setup` may return one of:
 
-  Similarly, returning `{:ok, <dict>}` from `setup`, the dict returned
-  will be merged into the current context and be available in all
-  subsequent `setup` and the `test` itself.
+    * the atom `:ok`
+    * a keyword list or map
+    * a tuple in the shape of `{:ok, keyword() | map()}`
 
-  Returning `:ok` leaves the context unchanged in both cases.
+  If a keyword list or map is returned, it will be merged into the current context
+  and will be available in all subsequent `setup_all`, `setup`, and the `test`
+  itself.
 
   Returning anything else from `setup_all` will force all tests to fail,
   while a bad response from `setup` causes the current test to fail.
@@ -47,151 +79,843 @@ defmodule ExUnit.Callbacks do
       defmodule AssertionTest do
         use ExUnit.Case, async: true
 
-        # `setup_all` is called once before every test
+        # "setup_all" is called once per module before any test runs
         setup_all do
-          IO.puts "Starting AssertionTest"
+          IO.puts("Starting AssertionTest")
 
-          # No metadata
+          # Context is not updated here
           :ok
         end
 
-        # `setup` is called before each test is run
+        # "setup" is called before each test
         setup do
-          IO.puts "This is a setup callback"
-
-          on_exit fn ->
-            IO.puts "This is invoked once the test is done"
-          end
-
-          # Returns extra metadata, it must be a dict
-          {:ok, hello: "world"}
+          IO.puts("This is a setup callback for #{inspect(self())}")
+
+          on_exit(fn ->
+            IO.puts("This is invoked once the test is done. Process: #{inspect(self())}")
+          end)
+
+          # Returns extra metadata to be merged into context.
+          # Any of the following would also work:
+          #
+          #     {:ok, %{hello: "world"}}
+          #     {:ok, [hello: "world"]}
+          #     %{hello: "world"}
+          #
+          [hello: "world"]
         end
 
-        # Same as `setup`, but receives the context
-        # for the current test
+        # Same as above, but receives the context as argument
         setup context do
-          IO.puts "Setting up: #{context[:test]}"
+          IO.puts("Setting up: #{context.test}")
+
+          # We can simply return :ok when we don't want to add any extra metadata
           :ok
         end
 
+        # Setups can also invoke a local or imported function that returns a context
+        setup :invoke_local_or_imported_function
+
         test "always pass" do
           assert true
         end
 
-        test "another one", context do
+        test "uses metadata from setup", context do
           assert context[:hello] == "world"
+          assert context[:from_named_setup] == true
+        end
+
+        defp invoke_local_or_imported_function(context) do
+          [from_named_setup: true]
+        end
+      end
+
+  It is also common to define your setup as a series of functions,
+  which are put together by calling `setup` or `setup_all` with a
+  list of function names. Each of these functions receive the context and can
+  return any of the values allowed in `setup` blocks:
+
+      defmodule ExampleContextTest do
+        use ExUnit.Case
+
+        setup [:step1, :step2, :step3, {OtherModule, :step4}]
+
+        defp step1(_context), do: [step_one: true]
+        defp step2(_context), do: {:ok, step_two: true} # return values with shape of {:ok, keyword() | map()} allowed
+        defp step3(_context), do: :ok # Context not modified
+
+        test "context was modified", context do
+          assert context[:step_one] == true
+          assert context[:step_two] == true
         end
       end
 
+  Finally, as discussed in the `ExUnit.Case` documentation, remember
+  that the initial context metadata can also be set via `@tag`s, which
+  can then be accessed in the `setup` block:
+
+      defmodule ExampleTagModificationTest do
+        use ExUnit.Case
+
+        setup %{login_as: username} do
+          {:ok, current_user: username}
+        end
+
+        @tag login_as: "max"
+        test "tags modify context", context do
+          assert context[:login_as] == "max"
+          assert context[:current_user] == "max"
+        end
+      end
   """
 
+  @type child_spec_overrides :: [
+          restart: :permanent | :transient | :temporary,
+          shutdown: :brutal_kill | timeout(),
+          type: :worker | :supervisor
+        ]
+
   @doc false
-  defmacro __using__(_) do
-    quote do
-      @ex_unit_setup []
-      @ex_unit_setup_all []
+  def __register__(module) do
+    Module.put_attribute(module, :ex_unit_describe, nil)
+    Module.put_attribute(module, :ex_unit_setup, [])
+    Module.put_attribute(module, :ex_unit_setup_all, [])
+    Module.put_attribute(module, :ex_unit_used_describes, %{})
+  end
 
-      @before_compile unquote(__MODULE__)
-      import unquote(__MODULE__)
-    end
+  @doc false
+  def __callbacks__(module) do
+    setup = Module.get_attribute(module, :ex_unit_setup)
+    setup_all = Module.get_attribute(module, :ex_unit_setup_all)
+    used_describes = Module.get_attribute(module, :ex_unit_used_describes)
+
+    code =
+      quote do
+        unquote(compile_setup(:setup, setup, used_describes))
+        unquote(compile_setup(:setup_all, setup_all, %{}))
+      end
+
+    {setup_all != [], code}
   end
 
   @doc false
-  defmacro __before_compile__(env) do
-    [compile_callbacks(env, :setup),
-     compile_callbacks(env, :setup_all)]
+  defmacro __before_compile__(%{module: module}) do
+    __callbacks__(module)
   end
 
   @doc """
   Defines a callback to be run before each test in a case.
+
+  Accepts one of these:
+
+    * a block
+    * an atom naming a local function
+    * a `{module, function}` tuple
+    * a list of atoms and `{module, function}` tuples
+
+  Can return values to be merged into the context, to set up the state for
+  tests. For more details, see the "Context" section shown above.
+
+  `setup/1` callbacks are executed in the same process as the test process.
+
+  ## Examples
+
+      defp clean_up_tmp_directory(context) do
+        # perform setup
+        :ok
+      end
+
+      setup :clean_up_tmp_directory
+
+      setup [:clean_up_tmp_directory, :another_setup]
+
+      setup do
+        [conn: Plug.Conn.build_conn()]
+      end
+
+      setup {MyModule, :my_setup_function}
+
   """
-  defmacro setup(var \\ quote(do: _), block) do
-    quote bind_quoted: [var: escape(var), block: escape(block)] do
-      name = :"__ex_unit_setup_#{length(@ex_unit_setup)}"
-      defp unquote(name)(unquote(var)), unquote(block)
-      @ex_unit_setup [name|@ex_unit_setup]
+  defmacro setup(block_or_functions) do
+    if Keyword.keyword?(block_or_functions) do
+      do_setup(quote(do: _), block_or_functions)
+    else
+      quote do
+        ExUnit.Callbacks.__setup__(__MODULE__, unquote(block_or_functions))
+      end
     end
   end
 
+  @doc """
+  Defines a callback to be run before each test in a case.
+
+  This is similar to `setup/1`, but the first argument is the context.
+  The `block` argument can only be a block.
+
+  For more details, see the "Context" section shown above.
+
+  ## Examples
+
+      setup context do
+        [conn: Plug.Conn.build_conn()]
+      end
+
+  """
+  defmacro setup(context, block) do
+    if not (Keyword.keyword?(block) and Keyword.has_key?(block, :do)) do
+      raise ArgumentError,
+            "setup/2 requires a block as the second argument after the context, got: #{Macro.to_string(block)}"
+    end
+
+    do_setup(context, block)
+  end
+
+  defp do_setup(context, block) do
+    quote bind_quoted: [context: escape(context), block: escape(block)] do
+      name = ExUnit.Callbacks.__setup__(__MODULE__)
+      defp unquote(name)(unquote(context)), unquote(block)
+    end
+  end
+
+  @doc false
+  def __setup__(module, callbacks) do
+    setup = Module.get_attribute(module, :ex_unit_setup)
+
+    Module.put_attribute(
+      module,
+      :ex_unit_setup,
+      Enum.reverse(validate_callbacks!(callbacks), setup)
+    )
+  end
+
+  @doc false
+  def __setup__(module) do
+    setup = Module.get_attribute(module, :ex_unit_setup)
+
+    name =
+      case Module.get_attribute(module, :ex_unit_describe) do
+        {_line, _message, counter} -> :"__ex_unit_setup_#{counter}_#{length(setup)}"
+        nil -> :"__ex_unit_setup_#{length(setup)}"
+      end
+
+    Module.put_attribute(module, :ex_unit_setup, [name | setup])
+    name
+  end
+
   @doc """
   Defines a callback to be run before all tests in a case.
+
+  Accepts one of these:
+
+    * a block
+    * an atom naming a local function
+    * a `{module, function}` tuple
+    * a list of atoms and `{module, function}` tuples
+
+  Can return values to be merged into the `context`, to set up the state for
+  tests. For more details, see the "Context" section shown above.
+
+  `setup_all/1` callbacks are executed in a separate process than tests.
+  All `setup_all/1` callbacks are executed in order in the same process.
+
+  ## On-Exit Handlers
+
+  On-exit handlers that you register inside `setup_all/1` callbacks
+  are executed at once after all tests in the module have been run.
+  They are all executed *in the same process*, which is a separate
+  process dedicated to running these handlers. These handlers are
+  executed in the reverse order of their respective `setup_all/1`
+  callbacks.
+
+  ## Examples
+
+      # One-arity function name
+      setup_all :clean_up_tmp_directory
+
+      # A module and function
+      setup_all {MyModule, :my_setup_function}
+
+      # A list of one-arity functions and module/function tuples
+      setup_all [:clean_up_tmp_directory, {MyModule, :my_setup_function}]
+
+      defp clean_up_tmp_directory(_context) do
+        # perform setup
+        :ok
+      end
+
+      # A block
+      setup_all do
+        [conn: Plug.Conn.build_conn()]
+      end
+
+  The context returned by `setup_all/1` will be available in all subsequent
+  `setup_all`, `setup`, and the `test` itself. For instance, the `conn` from
+  the previous example can be accessed as:
+
+      test "fetches current users", %{conn: conn} do
+        # ...
+      end
+
+  ### Handlers
+
+  You can define "global" on-exit handlers in `setup_all/1` callbacks:
+
+      setup_all do
+        Database.create_table_for(__MODULE__)
+
+        on_exit(fn ->
+          Database.drop_table_for(__MODULE__)
+        end)
+
+        :ok
+      end
+
+  The handler in the example above will be executed only once, after
+  running all tests in the module.
   """
-  defmacro setup_all(var \\ quote(do: _), block) do
-    quote bind_quoted: [var: escape(var), block: escape(block)] do
-      name = :"__ex_unit_setup_all_#{length(@ex_unit_setup_all)}"
-      defp unquote(name)(unquote(var)), unquote(block)
-      @ex_unit_setup_all [name|@ex_unit_setup_all]
+  defmacro setup_all(block) do
+    if Keyword.keyword?(block) do
+      do_setup_all(quote(do: _), block)
+    else
+      quote do
+        ExUnit.Callbacks.__setup_all__(__MODULE__, unquote(block))
+      end
     end
   end
 
   @doc """
-  Defines a callback that runs on the test (or test case) exit.
+  Defines a callback to be run before all tests in a case.
+
+  Similar as `setup_all/1` but also takes a context. The second argument
+  must be a block. See the "Context" section in the module documentation.
+
+  ## Examples
 
-  An `on_exit` callback is a function that receives no arguments and
-  runs in a separate process than the caller.
+      setup_all _context do
+        [conn: Plug.Conn.build_conn()]
+      end
 
-  `on_exit/2` is usually called from `setup` and `setup_all` callbacks,
-  often to undo the action performed during `setup`. However, `on_exit`
-  may also be called dynamically, where a reference can be used to
-  guarantee the callback will be invoked only once.
   """
-  @spec on_exit(term, (() -> term)) :: :ok
-  def on_exit(ref \\ make_ref, callback) do
-    case ExUnit.OnExitHandler.add(self, ref, callback) do
-      :ok -> :ok
+  defmacro setup_all(context, block) do
+    if not (Keyword.keyword?(block) and Keyword.has_key?(block, :do)) do
+      raise ArgumentError,
+            "setup_all/2 requires a block as the second argument after the context, got: #{Macro.to_string(block)}"
+    end
+
+    do_setup_all(context, block)
+  end
+
+  defp do_setup_all(context, block) do
+    quote bind_quoted: [context: escape(context), block: escape(block)] do
+      name = ExUnit.Callbacks.__setup_all__(__MODULE__)
+      defp unquote(name)(unquote(context)), unquote(block)
+    end
+  end
+
+  @doc false
+  def __setup_all__(module, callbacks) do
+    no_describe!(module)
+    setup_all = Module.get_attribute(module, :ex_unit_setup_all)
+
+    Module.put_attribute(
+      module,
+      :ex_unit_setup_all,
+      Enum.reverse(validate_callbacks!(callbacks), setup_all)
+    )
+  end
+
+  @doc false
+  def __setup_all__(module) do
+    no_describe!(module)
+    setup_all = Module.get_attribute(module, :ex_unit_setup_all)
+    name = :"__ex_unit_setup_all_#{length(setup_all)}"
+    Module.put_attribute(module, :ex_unit_setup_all, [name | setup_all])
+    name
+  end
+
+  defp no_describe!(module) do
+    if Module.get_attribute(module, :ex_unit_describe) do
+      raise "cannot invoke setup_all/1-2 inside describe as setup_all " <>
+              "always applies to all tests in a module"
+    end
+  end
+
+  defp validate_callbacks!(callbacks) do
+    for k <- List.wrap(callbacks) do
+      case k do
+        {mod, fun} when is_atom(mod) and is_atom(fun) ->
+          {mod, fun}
+
+        name when is_atom(name) ->
+          name
+
+        invalid ->
+          raise ArgumentError,
+                "setup/setup_all expect a callback as an atom, " <>
+                  "a {module, function} tuple or a list of callbacks, got: " <>
+                  inspect(invalid)
+      end
+    end
+  end
+
+  @doc """
+  Registers a callback that runs once the test exits.
+
+  `callback` is a function that receives no arguments and
+  runs in a separate process than the caller. Its return
+  value is irrelevant and is discarded.
+
+  `on_exit/2` is usually called from `setup/1` and `setup_all/1`
+  callbacks, often to undo the action performed during the setup.
+
+  However, `on_exit/2` may also be called dynamically. An "ID" (the
+  `name_or_ref` argument) can be used to guarantee that the callback
+  will be invoked only once. ExUnit uses this term to identify an
+  `on_exit/2` handler: if you want to override a previous handler, for
+  example, use the same `name_or_ref` across multiple `on_exit/2`
+  calls.
+
+  If `on_exit/2` is called inside `setup/1` or inside a test, it's
+  executed in a blocking fashion after the test exits and *before
+  running the next test*. This means that no other test from the same
+  test case will be running while the `on_exit/2` callback for a
+  previous test is running. `on_exit/2` is executed in a different
+  process than the test process. On the other hand, if `on_exit/2` is
+  called inside a `setup_all/1` callback then `callback` is executed
+  after running *all tests* (see `setup_all/1` for more information).
+
+  ## Examples
+
+      setup do
+        File.write!("fixture.json", "{}")
+        on_exit(fn -> File.rm!("fixture.json") end)
+      end
+
+  You can use the same `name_or_ref` across multiple `on_exit/2` calls
+  to "override" the registered handler:
+
+      setup do
+        on_exit(:drop_table, fn ->
+          Database.drop_table()
+        end)
+      end
+
+      test "a test that shouldn't drop the table" do
+        on_exit(:drop_table, fn -> :ok end)
+      end
+
+  Relying too much on overriding callbacks like this can lead to test
+  cases that are hard to understand and with too many layers of
+  indirection. However, it can be useful in some cases or for library
+  authors, for example.
+  """
+  @spec on_exit(term, (-> term)) :: :ok
+  def on_exit(name_or_ref \\ make_ref(), callback) when is_function(callback, 0) do
+    case ExUnit.OnExitHandler.add(self(), name_or_ref, callback) do
+      :ok ->
+        :ok
+
+      :error ->
+        raise ArgumentError, "on_exit/2 callback can only be invoked from the test process"
+    end
+  end
+
+  @doc """
+  Starts a child process under the test supervisor.
+
+  It expects a child specification or a module, similar to the ones
+  given to `Supervisor.start_link/2`. For example, if your application
+  starts a supervision tree by running:
+
+      Supervisor.start_link([MyServer, {OtherSupervisor, ...}], ...)
+
+  You can start those processes under test in isolation by running:
+
+      start_supervised(MyServer)
+      start_supervised({OtherSupervisor, :initial_value})
+
+  A keyword list can also be given if there is a need to change
+  the child specification for the given child process:
+
+      start_supervised({MyServer, :initial_value}, restart: :temporary)
+
+  See the `Supervisor` module for a discussion on child specifications
+  and the available specification keys.
+
+  The started process is not linked to the test process and a crash will
+  not necessarily fail the test. To start and link a process to guarantee
+  that any crash would also fail the test use `start_link_supervised!/2`.
+
+  This function returns `{:ok, pid}` in case of success, otherwise it
+  returns `{:error, reason}`.
+
+  The advantage of starting a process under the test supervisor is that
+  it is guaranteed to exit before the next test starts. Therefore, you
+  don't need to remove the process at the end of your tests via
+  `stop_supervised/1`. You only need to use `stop_supervised/1 ` if you
+  want to remove a process from the supervision tree in the middle of a
+  test, as simply shutting down the process would cause it to be restarted
+  according to its `:restart` value.
+
+  Finally, since Elixir v1.17.0, the test supervisor has both `$ancestors`
+  and `$callers` key in its process dictionary pointing to the test process.
+  This means developers can invoke `Process.get(:"$callers", [])` in their
+  `start_link` function and forward it to the spawned process, which may set
+  `Process.put(:"$callers", callers)` during its initialization. This may be
+  useful in projects who track process ownership during tests. You can learn
+  more about these keys in [the `Task` module](`Task#module-ancestor-and-caller-tracking`).
+  """
+  @doc since: "1.5.0"
+  @spec start_supervised(Supervisor.child_spec() | module | {module, term}, child_spec_overrides) ::
+          Supervisor.on_start_child()
+  def start_supervised(child_spec_or_module, opts \\ []) do
+    sup =
+      case ExUnit.fetch_test_supervisor() do
+        {:ok, sup} ->
+          sup
+
+        :error ->
+          raise ArgumentError, "start_supervised/2 can only be invoked from the test process"
+      end
+
+    child_spec = Supervisor.child_spec(child_spec_or_module, opts)
+    Supervisor.start_child(sup, child_spec)
+  end
+
+  @doc """
+  Same as `start_supervised/2` but returns the PID on success and raises if
+  not started properly.
+  """
+  @doc since: "1.6.0"
+  @spec start_supervised!(Supervisor.child_spec() | module | {module, term}, child_spec_overrides) ::
+          pid
+  def start_supervised!(child_spec_or_module, opts \\ []) do
+    case start_supervised(child_spec_or_module, opts) do
+      {:ok, pid} ->
+        pid
+
+      {:ok, pid, _info} ->
+        pid
+
+      {:error, reason} ->
+        raise "failed to start child with the spec #{inspect(child_spec_or_module)}.\n" <>
+                "Reason: #{start_supervised_error(reason)}"
+    end
+  end
+
+  defp start_supervised_error({{:EXIT, reason}, info}) when is_tuple(info),
+    do: Exception.format_exit(reason)
+
+  defp start_supervised_error({reason, info}) when is_tuple(info),
+    do: Exception.format_exit(reason)
+
+  defp start_supervised_error(reason), do: Exception.format_exit({:start_spec, reason})
+
+  @doc """
+  Same as `start_supervised!/2` but links the started process to the test process.
+
+  If the process that was started crashes, the crash is propagated to the test process,
+  failing the test and printing the cause of the crash.
+
+  Note that if the started process terminates before it is linked to the test process,
+  this function will exit with reason `:noproc`.
+
+  > #### To link or not to link {: .warning}
+  >
+  > When using `start_link_supervised!/2`, the test process will be linked to the
+  > spawned processes. When the test process exits, it exits with reason `:shutdown`,
+  > and the crash signal propagates to all linked processes virtually simultaneously,
+  > which can lead to processes terminating in an unpredictable order if they are not
+  > trapping exits. This is particularly problematic when you have processes that the
+  > test starts with `start_link_supervised!/2` and that depend on each other.
+  >
+  > If you need guaranteed shutdown order, use `start_supervised!/2`. This way the
+  > test process exiting does not affect the started processes, and they will be shut down
+  > *by the test supervisor* in reverse order, ensuring graceful termination.
+  """
+  @doc since: "1.14.0"
+  @spec start_link_supervised!(
+          Supervisor.child_spec() | module | {module, term},
+          child_spec_overrides
+        ) ::
+          pid
+  def start_link_supervised!(child_spec_or_module, opts \\ []) do
+    pid = start_supervised!(child_spec_or_module, opts)
+    Process.link(pid)
+    pid
+  end
+
+  @doc """
+  Stops a child process started via `start_supervised/2`.
+
+  This function expects the `id` in the child specification.
+  For example:
+
+      {:ok, _} = start_supervised(MyServer)
+      :ok = stop_supervised(MyServer)
+
+  It returns `:ok` if there is a supervised process with such
+  `id`, `{:error, :not_found}` otherwise.
+  """
+  @doc since: "1.5.0"
+  @spec stop_supervised(id :: term()) :: :ok | {:error, :not_found}
+  def stop_supervised(id) do
+    case ExUnit.OnExitHandler.get_supervisor(self()) do
+      {:ok, nil} ->
+        {:error, :not_found}
+
+      {:ok, sup} ->
+        pid = pid_for_child(sup, id)
+
+        if pid do
+          Process.unlink(pid)
+        end
+
+        with :ok <- Supervisor.terminate_child(sup, id) do
+          # If the terminated child was temporary, delete_child returns {:error, :not_found}.
+          # Since the child was successfully terminated, we treat this result as a success.
+          true = Supervisor.delete_child(sup, id) in [:ok, {:error, :not_found}]
+          :ok
+        end
+
       :error ->
-        raise ArgumentError, "on_exit/1 callback can only be invoked from the test process"
+        raise ArgumentError, "stop_supervised/1 can only be invoked from the test process"
+    end
+  end
+
+  defp pid_for_child(sup, id) do
+    children = Supervisor.which_children(sup)
+
+    with {_id, pid, _type, _modules} <- List.keyfind(children, id, 0) do
+      pid
+    end
+  end
+
+  @doc """
+  Same as `stop_supervised/1` but raises if it cannot be stopped.
+  """
+  @doc since: "1.10.0"
+  @spec stop_supervised!(id :: term()) :: :ok
+  def stop_supervised!(id) do
+    case stop_supervised(id) do
+      :ok ->
+        :ok
+
+      {:error, :not_found} ->
+        raise "could not stop child ID #{inspect(id)} because it was not found"
     end
   end
 
   ## Helpers
 
+  @reserved [:case, :file, :line, :test, :async, :registered, :describe]
+
+  @doc false
+  def __callback__(callback, describe) do
+    for k <- List.wrap(callback) do
+      if not is_atom(k) do
+        raise ArgumentError,
+              "setup/setup_all expect a callback name as an atom or " <>
+                "a list of callback names, got: #{inspect(k)}"
+      end
+
+      {k, describe}
+    end
+    |> Enum.reverse()
+  end
+
   @doc false
-  def __merge__(_mod, other, :ok) do
-    {:ok, other}
+  def __merge__(_mod, _kind, context, :ok) do
+    context
+  end
+
+  def __merge__(mod, kind, context, {:ok, value}) do
+    unwrapped_merge(mod, kind, context, value, {:ok, value})
+  end
+
+  def __merge__(mod, kind, context, value) do
+    unwrapped_merge(mod, kind, context, value, value)
+  end
+
+  defp unwrapped_merge(mod, kind, _context, %_{}, original_value) do
+    raise_merge_failed!(mod, kind, original_value)
   end
 
-  def __merge__(_mod, other, {:ok, data}) do
-    {:ok, Dict.merge(other, data)}
+  defp unwrapped_merge(mod, kind, context, data, _original_value) when is_list(data) do
+    context_merge(mod, kind, context, Map.new(data))
   end
 
-  def __merge__(mod, _, failure) do
-    raise "expected ExUnit callback in #{inspect mod} to return :ok " <>
-          " or {:ok, dict}, got #{inspect failure} instead"
+  defp unwrapped_merge(mod, kind, context, data, _original_value) when is_map(data) do
+    context_merge(mod, kind, context, data)
+  end
+
+  defp unwrapped_merge(mod, kind, _, _return_value, original_value) do
+    raise_merge_failed!(mod, kind, original_value)
+  end
+
+  defp context_merge(mod, kind, context, data) do
+    Map.merge(context, data, fn
+      k, v1, v2 when k in @reserved ->
+        if v1 == v2, do: v1, else: raise_merge_reserved!(mod, kind, k, v2)
+
+      _, _, v ->
+        v
+    end)
+  end
+
+  defp raise_merge_failed!(mod, kind, return_value) do
+    raise "expected ExUnit #{kind} callback in #{inspect(mod)} to " <>
+            "return the atom :ok, a keyword, or a map, got #{inspect(return_value)} instead"
+  end
+
+  defp raise_merge_reserved!(mod, kind, key, value) do
+    raise "ExUnit #{kind} callback in #{inspect(mod)} is trying to set " <>
+            "reserved field #{inspect(key)} to #{inspect(value)}"
   end
 
   defp escape(contents) do
     Macro.escape(contents, unquote: true)
   end
 
-  defp compile_callbacks(env, kind) do
-    callbacks = Module.get_attribute(env.module, :"ex_unit_#{kind}") |> Enum.reverse
+  @doc false
+  def __describe__(module, line, message, fun) do
+    if Module.get_attribute(module, :ex_unit_describe) do
+      raise "cannot call \"describe\" inside another \"describe\". See the documentation " <>
+              "for ExUnit.Case.describe/2 on named setups and how to handle hierarchies"
+    end
+
+    used_describes = Module.get_attribute(module, :ex_unit_used_describes)
+
+    cond do
+      not is_binary(message) ->
+        raise ArgumentError, "describe name must be a string, got: #{inspect(message)}"
+
+      is_map_key(used_describes, message) ->
+        raise ArgumentError,
+              "describe #{inspect(message)} is already defined in #{inspect(module)}"
+
+      true ->
+        :ok
+    end
+
+    if Module.get_attribute(module, :describetag) != [] do
+      raise "@describetag must be set inside describe/2 blocks"
+    end
+
+    if Module.get_attribute(module, :tag) != [] do
+      IO.warn("found unused @tag before \"describe\", did you mean to use @describetag?")
+    end
+
+    setup = Module.get_attribute(module, :ex_unit_setup)
+    Module.put_attribute(module, :ex_unit_setup, [])
+    Module.put_attribute(module, :ex_unit_describe, {line, message, map_size(used_describes)})
+
+    try do
+      fun.(message, used_describes)
+    after
+      Module.put_attribute(module, :ex_unit_describe, nil)
+      Module.put_attribute(module, :ex_unit_setup, setup)
+      Module.delete_attribute(module, :describetag)
+
+      for attribute <- Module.get_attribute(module, :ex_unit_registered_describe_attributes) do
+        Module.delete_attribute(module, attribute)
+      end
+    end
+  end
 
-    acc =
-      case callbacks do
+  @doc false
+  def __describe__(module, message, used_describes) do
+    {name, body} =
+      case Module.get_attribute(module, :ex_unit_setup) do
         [] ->
-          quote do: {:ok, context}
-        [h|t] ->
-          Enum.reduce t, compile_merge(h), fn(callback, acc) ->
+          {nil, nil}
+
+        callbacks ->
+          {:"__ex_unit_describe_#{map_size(used_describes)}", compile_setup(callbacks, :setup)}
+      end
+
+    used_describes = Map.put(used_describes, message, name)
+    Module.put_attribute(module, :ex_unit_used_describes, used_describes)
+    {name, body}
+  end
+
+  defp compile_setup(kind, value, describes) do
+    calls = compile_setup(value, kind)
+
+    describe_clauses =
+      for {describe, callback} <- describes,
+          callback != nil,
+          clause <- quote(do: (unquote(describe) -> unquote(callback)(var!(context)))),
+          do: clause
+
+    body =
+      if describe_clauses == [] do
+        calls
+      else
+        describe_clauses =
+          describe_clauses ++
             quote do
-              case unquote(acc) do
-                {:ok, context} ->
-                  unquote(compile_merge(callback))
-                other ->
-                  other
-              end
+              _ -> var!(context)
             end
-          end
+
+        quote do
+          var!(context) = unquote(calls)
+          case Map.get(var!(context), :describe, nil), do: unquote(describe_clauses)
+        end
       end
 
     quote do
-      def __ex_unit__(unquote(kind), context), do: unquote(acc)
+      def __ex_unit__(unquote(kind), var!(context)), do: unquote(body)
     end
   end
 
-  defp compile_merge(callback) do
+  defp compile_setup([], _kind) do
+    quote(do: var!(context))
+  end
+
+  defp compile_setup(callbacks, kind) do
+    [h | t] = Enum.reverse(callbacks)
+
+    Enum.reduce(t, compile_setup_call(h, kind), fn callback, acc ->
+      quote do
+        var!(context) = unquote(acc)
+        unquote(compile_setup_call(callback, kind))
+      end
+    end)
+  end
+
+  defp compile_setup_call(callback, kind) when is_atom(callback) do
     quote do
-      unquote(__MODULE__).__merge__(__MODULE__, context, unquote(callback)(context))
+      result =
+        unquote(__MODULE__).__merge__(
+          __MODULE__,
+          unquote(kind),
+          var!(context),
+          unquote(callback)(var!(context))
+        )
+
+      ExUnit.Callbacks.__noop__()
+      result
     end
   end
+
+  defp compile_setup_call({module, callback}, kind) do
+    quote do
+      result =
+        unquote(__MODULE__).__merge__(
+          __MODULE__,
+          unquote(kind),
+          var!(context),
+          unquote(module).unquote(callback)(var!(context))
+        )
+
+      ExUnit.Callbacks.__noop__()
+      result
+    end
+  end
+
+  # We inject this into compiled setup/setup_all calls, to avoid tail-call optimization and get
+  # better stacktraces. See the comments in https://github.com/elixir-lang/elixir/pull/12382.
+  @doc false
+  def __noop__, do: :noop
 end
diff --git a/lib/ex_unit/lib/ex_unit/capture_io.ex b/lib/ex_unit/lib/ex_unit/capture_io.ex
index c0767d786a2..f506b6a4bf5 100644
--- a/lib/ex_unit/lib/ex_unit/capture_io.ex
+++ b/lib/ex_unit/lib/ex_unit/capture_io.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.CaptureIO do
   @moduledoc ~S"""
   Functionality to capture IO for testing.
@@ -9,126 +13,324 @@ defmodule ExUnit.CaptureIO do
 
         import ExUnit.CaptureIO
 
-        test :example do
-          assert capture_io(fn ->
-            IO.puts "a"
-          end) == "a\n"
+        test "example" do
+          assert capture_io(fn -> IO.puts("a") end) == "a\n"
+        end
+
+        test "another example" do
+          assert with_io(fn ->
+            IO.puts("a")
+            IO.puts("b")
+            2 + 2
+          end) == {4, "a\nb\n"}
         end
       end
 
   """
 
+  @type capture_io_opts :: [
+          input: String.t(),
+          capture_prompt: boolean(),
+          encoding: :unicode | :latin1
+        ]
+
   @doc """
   Captures IO generated when evaluating `fun`.
 
   Returns the binary which is the captured output.
 
-  By default, `capture_io` replaces the `group_leader` (`:stdio`)
-  for the current process. However, the capturing of any other
-  named device, such as `:stderr`, is also possible globally by
-  giving the registered device name explicitly as an argument.
+  By default, `capture_io` replaces the `Process.group_leader/0` of the current
+  process, which is the process used by default for all IO operations. Capturing
+  the group leader of the current process is safe to run concurrently, under
+  `async: true` tests. You may also explicitly capture the group leader of
+  another process, however that is not safe to do concurrently.
+
+  You may also capture any other named IO device, such as `:stderr`. This is
+  also safe to run concurrently but, if several tests are writing to the same
+  device at once, captured output may include output from a different test.
+
+  A developer can set a string as an input. The default input is an empty
+  string. If capturing a named device asynchronously, an input can only be given
+  to the first capture. Any further capture that is given to a capture on that
+  device will raise an exception and would indicate that the test should be run
+  synchronously.
+
+  Similarly, once a capture on a named device has begun, the encoding on that
+  device cannot be changed in a subsequent concurrent capture. An error will
+  be raised in this case.
+
+  ## IO devices
+
+  You may capture the IO of the group leader of any process, by passing a `pid`
+  as argument, or from any registered IO device given as an `atom`. Here are
+  some example values:
+
+    * `:stdio`, `:standard_io` - a shortcut for capturing the group leader
+      of the current process. It is equivalent to passing `self()` as the
+      first argument. This is safe to run concurrently and captures only
+      the of the current process or any child process spawned inside the
+      given function
 
-  Note that when capturing something other than `:stdio`,
-  the test should run with async false.
+    * `:stderr`, `:standard_error` - captures all IO to standard error
+      (represented internally by an Erlang process named `:standard_error`).
+      This is safe to run concurrently but it will capture the output
+      of any other test writing to the same named device
 
-  When capturing `:stdio`, if the `:capture_prompt` option is `false`,
-  prompts (specified as arguments to `IO.get*` functions) are not
-  captured.
+    * any other atom - captures all IO to the given device given by the
+      atom. This is safe to run concurrently but it will capture the output
+      of any other test writing to the same named device
 
-  A developer can set a string as an input. The default
-  input is `:eof`.
+    * any other pid (since v1.17.0) - captures all IO to the group leader
+      of the given process. This option is not safe to run concurrently
+      if the pid is not `self()`. Tests using this value must set `async: true`
+
+  ## Options
+
+    * `:input` - An input to the IO device, defaults to `""`.
+
+    * `:capture_prompt` - Define if prompts (specified as arguments to
+      `IO.get*` functions) should be captured. Defaults to `true`. For
+      IO devices other than `:stdio`, the option is ignored.
+
+    * `:encoding` (since v1.10.0) - encoding of the IO device. Allowed
+      values are `:unicode` (default) and `:latin1`.
 
   ## Examples
 
-      iex> capture_io(fn -> IO.write "josé" end) == "josé"
-      true
+  To capture the standard io:
 
-      iex> capture_io(:stderr, fn -> IO.write(:stderr, "josé") end) == "josé"
+      iex> capture_io(fn -> IO.write("john") end) == "john"
       true
 
       iex> capture_io("this is input", fn ->
-      ...>   input = IO.gets ">"
-      ...>   IO.write input
-      ...> end) == ">this is input"
+      ...>   input = IO.gets("> ")
+      ...>   IO.write(input)
+      ...> end) == "> this is input"
       true
 
       iex> capture_io([input: "this is input", capture_prompt: false], fn ->
-      ...>   input = IO.gets ">"
-      ...>   IO.write input
+      ...>   input = IO.gets("> ")
+      ...>   IO.write(input)
       ...> end) == "this is input"
       true
 
+  Note it is fine to use `==` with `:stdio` (the default IO device), because
+  the content is captured per test process. However, `:stderr` is shared
+  across all tests, so you will want to use `=~` instead of `==` for assertions
+  on `:stderr` if your tests are async:
+
+      iex> capture_io(:stderr, fn -> IO.write(:stderr, "john") end) =~ "john"
+      true
+
+      iex> capture_io(:standard_error, fn -> IO.write(:stderr, "john") end) =~ "john"
+      true
+
+  In particular, avoid empty captures on `:stderr` with async tests:
+
+      iex> capture_io(:stderr, fn -> :nothing end) == ""
+      true
+
+  Otherwise, if the standard error of any other test is captured, the test will
+  fail.
+
+  To capture the IO from another process, you can pass a `pid`:
+
+      capture_io(GenServer.whereis(MyServer), fn ->
+        GenServer.call(MyServer, :do_something)
+      end)
+
+  Tests that directly capture a PID cannot run concurrently.
+
+  ## Returning values
+
+  As seen in the examples above, `capture_io` returns the captured output.
+  If you want to also capture the result of the function executed,
+  use `with_io/2`.
   """
-  def capture_io(fun) do
-    do_capture_io(:standard_io, [], fun)
+  @spec capture_io((-> any())) :: String.t()
+  def capture_io(fun) when is_function(fun, 0) do
+    {_result, capture} = with_io(fun)
+    capture
   end
 
-  def capture_io(device, fun) when is_atom(device) do
-    capture_io(device, [], fun)
+  @doc """
+  Captures IO generated when evaluating `fun`.
+
+  See `capture_io/1` for more information.
+  """
+  @spec capture_io(atom() | pid() | String.t() | capture_io_opts, (-> any())) :: String.t()
+  def capture_io(device_pid_input_or_options, fun)
+
+  def capture_io(device_or_pid, fun)
+      when (is_atom(device_or_pid) or is_pid(device_or_pid)) and is_function(fun, 0) do
+    {_result, capture} = with_io(device_or_pid, fun)
+    capture
   end
 
-  def capture_io(input, fun) when is_binary(input) do
-    capture_io(:standard_io, [input: input], fun)
+  def capture_io(input_or_options, fun)
+      when (is_binary(input_or_options) or is_list(input_or_options)) and is_function(fun, 0) do
+    {_result, capture} = with_io(input_or_options, fun)
+    capture
   end
 
-  def capture_io(options, fun) when is_list(options) do
-    capture_io(:standard_io, options, fun)
+  @doc """
+  Captures IO generated when evaluating `fun`.
+
+  See `capture_io/1` for more information.
+  """
+  @spec capture_io(atom() | pid(), String.t() | capture_io_opts, (-> any())) :: String.t()
+  def capture_io(device_or_pid, input_or_options, fun)
+      when (is_atom(device_or_pid) or is_pid(device_or_pid)) and
+             (is_binary(input_or_options) or is_list(input_or_options)) and is_function(fun, 0) do
+    {_result, capture} = with_io(device_or_pid, input_or_options, fun)
+    capture
   end
 
-  def capture_io(device, input, fun) when is_binary(input) do
-    capture_io(device, [input: input], fun)
+  @doc ~S"""
+  Invokes the given `fun` and returns the result and captured output.
+
+  It accepts the same arguments and options as `capture_io/1`.
+
+  ## Examples
+
+      {result, output} =
+        with_io(fn ->
+          IO.puts("a")
+          IO.puts("b")
+          2 + 2
+        end)
+
+      assert result == 4
+      assert output == "a\nb\n"
+  """
+  @doc since: "1.13.0"
+  @spec with_io((-> any())) :: {any(), String.t()}
+  def with_io(fun) when is_function(fun, 0) do
+    with_io(:stdio, [], fun)
+  end
+
+  @doc """
+  Invokes the given `fun` and returns the result and captured output.
+
+  See `with_io/1` for more information.
+  """
+  @doc since: "1.13.0"
+  @spec with_io(atom() | pid() | String.t() | capture_io_opts, (-> any())) :: {any(), String.t()}
+  def with_io(device_pid_input_or_options, fun)
+
+  def with_io(device, fun) when is_atom(device) and is_function(fun, 0) do
+    with_io(device, [], fun)
+  end
+
+  def with_io(pid, fun) when is_pid(pid) and is_function(fun, 0) do
+    with_io(pid, [], fun)
+  end
+
+  def with_io(input, fun) when is_binary(input) and is_function(fun, 0) do
+    with_io(:stdio, [input: input], fun)
+  end
+
+  def with_io(options, fun) when is_list(options) and is_function(fun, 0) do
+    with_io(:stdio, options, fun)
   end
 
-  def capture_io(device, options, fun) when is_list(options) do
-    do_capture_io(map_dev(device), options, fun)
+  @doc """
+  Invokes the given `fun` and returns the result and captured output.
+
+  See `with_io/1` for more information.
+  """
+  @doc since: "1.13.0"
+  @spec with_io(atom() | pid(), String.t() | capture_io_opts, (-> any())) :: {any(), String.t()}
+  def with_io(device_or_pid, input_or_options, fun)
+
+  def with_io(device, input, fun)
+      when is_atom(device) and is_binary(input) and is_function(fun, 0) do
+    do_with_io(map_dev(device), [input: input], fun)
   end
 
-  defp map_dev(:stdio),  do: :standard_io
+  def with_io(device, options, fun)
+      when is_atom(device) and is_list(options) and is_function(fun, 0) do
+    do_with_io(map_dev(device), options, fun)
+  end
+
+  def with_io(pid, input, fun)
+      when is_pid(pid) and is_binary(input) and is_function(fun, 0) do
+    do_with_io(pid, [input: input], fun)
+  end
+
+  def with_io(pid, options, fun)
+      when is_pid(pid) and is_list(options) and is_function(fun, 0) do
+    do_with_io(pid, options, fun)
+  end
+
+  defp map_dev(:standard_io), do: self()
+  defp map_dev(:stdio), do: self()
   defp map_dev(:stderr), do: :standard_error
-  defp map_dev(other),   do: other
+  defp map_dev(other), do: other
 
-  defp do_capture_io(:standard_io, options, fun) do
+  defp do_with_io(pid, options, fun) when is_pid(pid) do
     prompt_config = Keyword.get(options, :capture_prompt, true)
+    encoding = Keyword.get(options, :encoding, :unicode)
     input = Keyword.get(options, :input, "")
 
-    original_gl = :erlang.group_leader
-    {:ok, capture_gl} = StringIO.open(input, capture_prompt: prompt_config)
-    :erlang.group_leader(capture_gl, self)
+    {:group_leader, original_gl} =
+      Process.info(pid, :group_leader) || {:group_leader, Process.group_leader()}
+
+    {:ok, capture_gl} = StringIO.open(input, capture_prompt: prompt_config, encoding: encoding)
 
     try do
-      fun.()
-      StringIO.close(capture_gl) |> elem(1) |> elem(1)
+      Process.group_leader(pid, capture_gl)
+      do_capture_gl(capture_gl, fun)
     after
-      :erlang.group_leader(original_gl, self)
+      Process.group_leader(pid, original_gl)
     end
   end
 
-  defp do_capture_io(device, options, fun) do
-    unless original_io = Process.whereis(device) do
-      raise "could not find IO device registered at #{inspect device}"
-    end
+  defp do_with_io(device, options, fun) when is_atom(device) do
+    input = Keyword.get(options, :input, "")
+    encoding = Keyword.get(options, :encoding, :unicode)
 
-    unless ExUnit.Server.add_device(device) do
-      raise "IO device registered at #{inspect device} is already captured"
-    end
+    case ExUnit.CaptureServer.device_capture_on(device, encoding, input) do
+      {:ok, ref} ->
+        try do
+          result = fun.()
+          {result, ExUnit.CaptureServer.device_output(device, ref)}
+        after
+          ExUnit.CaptureServer.device_capture_off(ref)
+        end
 
-    input = Keyword.get(options, :input, "")
+      {:error, :no_device} ->
+        raise "could not find IO device registered at #{inspect(device)}"
+
+      {:error, {:changed_encoding, current_encoding}} ->
+        raise ArgumentError, """
+        attempted to change the encoding for a currently captured device #{inspect(device)}.
 
-    Process.unregister(device)
-    {:ok, capture_io} = StringIO.open(input)
-    Process.register(capture_io, device)
+        Currently set as: #{inspect(current_encoding)}
+        Given: #{inspect(encoding)}
 
+        If you need to use multiple encodings on a captured device, you cannot \
+        run your test asynchronously
+        """
+
+      {:error, :input_on_already_captured_device} ->
+        raise ArgumentError,
+              "attempted multiple captures on device #{inspect(device)} with input. " <>
+                "If you need to give an input to a captured device, you cannot run your test asynchronously"
+    end
+  end
+
+  defp do_capture_gl(string_io, fun) do
     try do
       fun.()
-      StringIO.close(capture_io) |> elem(1) |> elem(1)
-    after
-      try do
-        Process.unregister(device)
-      rescue
-        ArgumentError -> nil
-      end
-      Process.register(original_io, device)
-      ExUnit.Server.remove_device(device)
+    catch
+      kind, reason ->
+        _ = StringIO.close(string_io)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      result ->
+        {:ok, {_input, output}} = StringIO.close(string_io)
+        {result, output}
     end
   end
 end
diff --git a/lib/ex_unit/lib/ex_unit/capture_log.ex b/lib/ex_unit/lib/ex_unit/capture_log.ex
new file mode 100644
index 00000000000..1a7b1288df6
--- /dev/null
+++ b/lib/ex_unit/lib/ex_unit/capture_log.ex
@@ -0,0 +1,142 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule ExUnit.CaptureLog do
+  @moduledoc ~S"""
+  Functionality to capture logs for testing.
+
+  ## Examples
+
+      defmodule AssertionTest do
+        use ExUnit.Case
+
+        import ExUnit.CaptureLog
+        require Logger
+
+        test "example" do
+          {result, log} =
+            with_log(fn ->
+              Logger.error("log msg")
+              2 + 2
+            end)
+
+          assert result == 4
+          assert log =~ "log msg"
+        end
+
+        test "check multiple captures concurrently" do
+          fun = fn ->
+            for msg <- ["hello", "hi"] do
+              assert capture_log(fn -> Logger.error(msg) end) =~ msg
+            end
+
+            Logger.debug("testing")
+          end
+
+          assert capture_log(fun) =~ "hello"
+          assert capture_log(fun) =~ "testing"
+        end
+      end
+
+  """
+
+  @compile {:no_warn_undefined, Logger}
+
+  @type capture_log_opts :: [
+          {:level, Logger.level() | nil}
+          | {:formatter, {module(), term()} | nil}
+        ]
+
+  @doc """
+  Captures Logger messages generated when evaluating `fun`.
+
+  Returns the binary which is the captured output. The captured log
+  messages will be formatted using `Logger.default_formatter/1` by
+  default. Any option, besides `:level` or `formatter`, will be
+  forwarded as an override to the default formatter.
+
+  This function mutes the default logger handler and captures any log
+  messages sent to Logger from the calling processes. It is possible
+  to ensure explicit log messages from other processes are captured
+  by waiting for their exit or monitor signal.
+
+  Note that when the `async` is set to `true` on `use ExUnit.Case`,
+  messages from other tests might be captured. This is OK as long
+  you consider such cases in your assertions, typically by using
+  the `=~/2` operator to perform partial matches.
+
+  It is possible to configure the level to capture with `:level`,
+  which will set the capturing level for the duration of the
+  capture, for instance, if the log level is set to `:error`, then
+  any message with the lower level will be ignored.
+  The default level is `nil`, which will capture all messages.
+  Note this setting does not override the overall `Logger.level/0` value.
+  Therefore, if `Logger.level/0` is set to a higher level than the one
+  configured in this function, no message will be captured.
+  The behaviour is undetermined if async tests change Logger level.
+
+  It is possible to use an alternative log formatter with `:formatter`,
+  which must be provided as `{module, config}`. If `:formatter` is not
+  provided, the formatter configuration from `Logger.default_formatter/1`
+  will be used.
+
+  To get the result of the evaluation along with the captured log,
+  use `with_log/2`.
+  """
+  @spec capture_log(capture_log_opts, (-> any)) :: String.t()
+  def capture_log(opts \\ [], fun) do
+    {_, log} = with_log(opts, fun)
+    log
+  end
+
+  @doc """
+  Invokes the given `fun` and returns the result and captured log.
+
+  It accepts the same arguments and options as `capture_log/2`.
+
+  ## Examples
+
+      {result, log} =
+        with_log(fn ->
+          Logger.error("log msg")
+          2 + 2
+        end)
+
+      assert result == 4
+      assert log =~ "log msg"
+
+  """
+  @doc since: "1.13.0"
+  @spec with_log(capture_log_opts, (-> result)) :: {result, log :: String.t()} when result: any
+  def with_log(opts \\ [], fun) when is_list(opts) do
+    opts =
+      if opts[:level] == :warn do
+        IO.warn("level: :warn is deprecated, please use :warning instead")
+        Keyword.put(opts, :level, :warning)
+      else
+        opts
+      end
+
+    {:ok, string_io} = StringIO.open("")
+
+    try do
+      ref = ExUnit.CaptureServer.log_capture_on(self(), string_io, opts)
+
+      try do
+        fun.()
+      after
+        :ok = Logger.flush()
+        :ok = ExUnit.CaptureServer.log_capture_off(ref)
+      end
+    catch
+      kind, reason ->
+        _ = StringIO.close(string_io)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      result ->
+        {:ok, {_input, output}} = StringIO.close(string_io)
+        {result, output}
+    end
+  end
+end
diff --git a/lib/ex_unit/lib/ex_unit/capture_server.ex b/lib/ex_unit/lib/ex_unit/capture_server.ex
new file mode 100644
index 00000000000..5eb4f4a18b4
--- /dev/null
+++ b/lib/ex_unit/lib/ex_unit/capture_server.ex
@@ -0,0 +1,275 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule ExUnit.CaptureServer do
+  @moduledoc false
+  @compile {:no_warn_undefined, Logger}
+  @timeout :infinity
+  @name __MODULE__
+  @ets __MODULE__
+
+  use GenServer
+
+  def start_link(_opts) do
+    GenServer.start_link(__MODULE__, :ok, name: @name)
+  end
+
+  def device_capture_on(name, encoding, input) do
+    GenServer.call(@name, {:device_capture_on, name, encoding, input}, @timeout)
+  end
+
+  def device_output(name, ref) do
+    GenServer.call(@name, {:device_output, name, ref}, @timeout)
+  end
+
+  def device_capture_off(ref) do
+    GenServer.call(@name, {:device_capture_off, ref}, @timeout)
+  end
+
+  def log_capture_on(pid, string_io, opts) do
+    GenServer.call(@name, {:log_capture_on, pid, string_io, opts}, @timeout)
+  end
+
+  def log_capture_off(ref) do
+    GenServer.call(@name, {:log_capture_off, ref}, @timeout)
+  end
+
+  ## Callbacks
+
+  @impl true
+  def init(:ok) do
+    :ets.new(@name, [:named_table, :public, :set])
+
+    state = %{
+      devices: %{},
+      log_captures: %{},
+      log_status: :error
+    }
+
+    {:ok, state}
+  end
+
+  @impl true
+  def handle_call(call, from, state)
+
+  def handle_call({:device_capture_on, name, encoding, input}, {caller, _}, config) do
+    capture_device(name, encoding, input, config, caller)
+  end
+
+  def handle_call({:device_output, name, ref}, _from, config) do
+    device = Map.fetch!(config.devices, name)
+    {_, output} = StringIO.contents(device.pid)
+    total = byte_size(output)
+    {_pid, offset} = Map.fetch!(device.refs, ref)
+    output_size = total - offset
+    {:reply, binary_part(output, offset, output_size), config}
+  end
+
+  def handle_call({:device_capture_off, ref}, _from, config) do
+    {:reply, :ok, release_device(ref, config)}
+  end
+
+  def handle_call({:log_capture_on, pid, string_io, opts}, _from, config) do
+    ref = Process.monitor(pid)
+    refs = Map.put(config.log_captures, ref, true)
+
+    {level, opts} = Keyword.pop(opts, :level)
+
+    {formatter_mod, formatter_config} =
+      Keyword.get_lazy(opts, :formatter, fn -> Logger.default_formatter(opts) end)
+
+    true = :ets.insert(@ets, {ref, string_io, level || :all, formatter_mod, formatter_config})
+
+    if map_size(refs) == 1 do
+      :ok = :logger.add_handler(@name, __MODULE__, %{})
+
+      status =
+        with {:ok, config} <- :logger.get_handler_config(:default),
+             :ok <- :logger.remove_handler(:default) do
+          {:ok, config}
+        else
+          _ -> :error
+        end
+
+      {:reply, ref, %{config | log_captures: refs, log_status: status}}
+    else
+      {:reply, ref, %{config | log_captures: refs}}
+    end
+  end
+
+  def handle_call({:log_capture_off, ref}, _from, config) do
+    Process.demonitor(ref, [:flush])
+    config = remove_log_capture(ref, config)
+    {:reply, :ok, config}
+  end
+
+  @impl true
+  def handle_info({:DOWN, ref, _, _, _}, config) do
+    config = remove_log_capture(ref, config)
+    config = release_device(ref, config)
+    {:noreply, config}
+  end
+
+  defp capture_device(name, encoding, input, config, caller) do
+    case config.devices do
+      %{^name => device} ->
+        dead_refs = for {ref, {pid, _}} <- device.refs, not Process.alive?(pid), do: ref
+
+        case dead_refs do
+          [] ->
+            capture_existing_device(name, encoding, input, config, caller)
+
+          _ ->
+            config = Enum.reduce(dead_refs, config, &release_device/2)
+            capture_device(name, encoding, input, config, caller)
+        end
+
+      %{} ->
+        capture_new_device(name, encoding, input, config, caller)
+    end
+  end
+
+  defp capture_existing_device(name, encoding, input, config, caller) do
+    case Map.fetch!(config.devices, name) do
+      %{input?: input?} when input? or input != "" ->
+        {:reply, {:error, :input_on_already_captured_device}, config}
+
+      %{encoding: ^encoding} = device ->
+        {_, output} = StringIO.contents(device.pid)
+        ref = Process.monitor(caller)
+        config = put_in(config.devices[name].refs[ref], {caller, byte_size(output)})
+        {:reply, {:ok, ref}, config}
+
+      %{encoding: other_encoding} ->
+        {:reply, {:error, {:changed_encoding, other_encoding}}, config}
+    end
+  end
+
+  defp capture_new_device(name, encoding, input, config, caller) do
+    {:ok, pid} = StringIO.open(input, encoding: encoding)
+    original_pid = Process.whereis(name)
+
+    try do
+      Process.unregister(name)
+      Process.register(pid, name)
+    rescue
+      ArgumentError ->
+        {:reply, {:error, :no_device}, config}
+    else
+      _ ->
+        ref = Process.monitor(caller)
+
+        device = %{
+          original_pid: original_pid,
+          pid: pid,
+          refs: %{ref => {caller, 0}},
+          encoding: encoding,
+          input?: input != ""
+        }
+
+        {:reply, {:ok, ref}, put_in(config.devices[name], device)}
+    end
+  end
+
+  defp release_device(ref, %{devices: devices} = config) do
+    Process.demonitor(ref, [:flush])
+
+    case Enum.find(devices, fn {_, device} -> Map.has_key?(device.refs, ref) end) do
+      {name, device} ->
+        case Map.delete(device.refs, ref) do
+          refs when map_size(refs) == 0 ->
+            revert_device_to_original_pid(name, device.original_pid)
+            close_string_io(device.pid)
+            %{config | devices: Map.delete(devices, name)}
+
+          refs ->
+            put_in(config.devices[name].refs, refs)
+        end
+
+      _ ->
+        config
+    end
+  end
+
+  defp revert_device_to_original_pid(name, pid) do
+    Process.unregister(name)
+  rescue
+    ArgumentError -> nil
+  after
+    Process.register(pid, name)
+  end
+
+  defp close_string_io(pid) do
+    StringIO.close(pid)
+  rescue
+    ArgumentError -> nil
+  end
+
+  defp remove_log_capture(ref, %{log_captures: refs} = config) do
+    true = :ets.delete(@ets, ref)
+
+    case Map.pop(refs, ref, false) do
+      {true, refs} ->
+        maybe_revert_to_default_handler(refs, config.log_status)
+        %{config | log_captures: refs}
+
+      {false, _refs} ->
+        config
+    end
+  end
+
+  defp maybe_revert_to_default_handler(refs, status) when map_size(refs) == 0 do
+    :logger.remove_handler(@name)
+
+    with {:ok, %{module: module} = config} <- status do
+      :logger.add_handler(:default, module, config)
+    end
+  end
+
+  defp maybe_revert_to_default_handler(_refs, _config) do
+    :ok
+  end
+
+  ## :logger handler callback.
+
+  def log(event, _config) do
+    {:trap_exit, trapping_exits?} = Process.info(self(), :trap_exit)
+
+    tasks =
+      :ets.tab2list(@ets)
+      |> Enum.filter(fn {_ref, _string_io, level, _formatter_mod, _formatter_config} ->
+        :logger.compare_levels(event.level, level) in [:gt, :eq]
+      end)
+      |> Enum.group_by(
+        fn {_ref, _string_io, _level, formatter_mod, formatter_config} ->
+          {formatter_mod, formatter_config}
+        end,
+        fn {_ref, string_io, _level, _formatter_mod, _formatter_config} ->
+          string_io
+        end
+      )
+      |> Enum.map(fn {{formatter_mod, formatter_config}, string_ios} ->
+        Task.async(fn ->
+          chardata = formatter_mod.format(event, formatter_config)
+
+          # Simply send, do not wait for reply
+          for string_io <- string_ios do
+            send(string_io, {:io_request, self(), make_ref(), {:put_chars, :unicode, chardata}})
+          end
+        end)
+      end)
+
+    Task.await_many(tasks)
+
+    if trapping_exits? do
+      for %{pid: pid} <- tasks do
+        receive do
+          {:EXIT, ^pid, _} -> :ok
+        end
+      end
+    end
+
+    :ok
+  end
+end
diff --git a/lib/ex_unit/lib/ex_unit/case.ex b/lib/ex_unit/lib/ex_unit/case.ex
index 0c701fa5cbb..6af10d22b3d 100644
--- a/lib/ex_unit/lib/ex_unit/case.ex
+++ b/lib/ex_unit/lib/ex_unit/case.ex
@@ -1,31 +1,52 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.Case do
   @moduledoc """
-  Sets up an ExUnit test case.
+  Helpers for defining test cases.
 
   This module must be used in other modules as a way to configure
   and prepare them for testing.
 
   When used, it accepts the following options:
 
-    * :async - configure Elixir to run that specific test case in parallel with
-      others. Must be used for performance when your test cases do not change
-      any global state.
+    * `:async` - configures tests in this module to run concurrently with
+      tests in other modules. Tests in the same module never run concurrently
+      (with the exception of tests run via the `:parameterize` option - see below).
+      It should be enabled only if tests do not change any global state.
+      Defaults to `false`.
+
+    * `:group` (since v1.18.0) - configures the **group** this module belongs to.
+      Tests in the same group never run concurrently. Tests from different
+      groups (or with no groups) can run concurrently when `async: true`
+      is given. By default, this module belongs to no group (defaults to `nil`).
+
+    * `:register` - when `false`, does not register this module within
+      ExUnit server. This means the module won't run when ExUnit suite runs.
 
-  This module automatically includes all callbacks defined in
-  `ExUnit.Callbacks`. See that module's documentation for more
-  information.
+    * `:parameterize` (since v1.18.0) - a list of maps to parameterize tests.
+      If both `:async` and `:parameterize` are given, the different parameters
+      run concurrently. See the "Parameterized tests" section below for more
+      information.
+
+  > #### `use ExUnit.Case` {: .info}
+  >
+  > When you `use ExUnit.Case`, it will import the functionality
+  > from `ExUnit.Assertions`, `ExUnit.Callbacks`, `ExUnit.DocTest`,
+  > and this module itself.
 
   ## Examples
 
-       defmodule AssertionTest do
-         # Use the module
-         use ExUnit.Case, async: true
+      defmodule AssertionTest do
+        # Use the module
+        use ExUnit.Case, async: true
 
-         # The `test` macro is imported by ExUnit.Case
-         test "always pass" do
-           assert true
-         end
-       end
+        # The "test" macro is imported by ExUnit.Case
+        test "always pass" do
+          assert true
+        end
+      end
 
   ## Context
 
@@ -36,11 +57,11 @@ defmodule ExUnit.Case do
         use ExUnit.Case
 
         setup do
-          {:ok, pid} = KV.start_link
-          {:ok, [pid: pid]}
+          {:ok, pid} = KV.start_link()
+          {:ok, pid: pid}
         end
 
-        test "stores key-values", context do
+        test "stores key-value pairs", context do
           assert KV.put(context[:pid], :hello, :world) == :ok
           assert KV.get(context[:pid], :hello) == :world
         end
@@ -49,7 +70,7 @@ defmodule ExUnit.Case do
   As the context is a map, it can be pattern matched on to extract
   information:
 
-      test "stores key-values", %{pid: pid} do
+      test "stores key-value pairs", %{pid: pid} = _context do
         assert KV.put(pid, :hello, :world) == :ok
         assert KV.get(pid, :hello) == :world
       end
@@ -71,17 +92,17 @@ defmodule ExUnit.Case do
         setup context do
           # Read the :cd tag value
           if cd = context[:cd] do
-            prev_cd = File.cwd!
+            prev_cd = File.cwd!()
             File.cd!(cd)
-            on_exit fn -> File.cd!(prev_cd) end
+            on_exit(fn -> File.cd!(prev_cd) end)
           end
 
           :ok
         end
 
         @tag cd: "fixtures"
-        test "reads utf-8 fixtures" do
-          File.read("hello")
+        test "reads UTF-8 fixtures" do
+          File.read("README.md")
         end
       end
 
@@ -100,25 +121,116 @@ defmodule ExUnit.Case do
 
   If a tag is given more than once, the last value wins.
 
-  ### Module tags
+  ### Module and describe tags
+
+  A tag can be set for all tests in a module or describe block by
+  setting `@moduletag` or `@describetag` inside each context
+  respectively:
+
+      defmodule ApiTest do
+        use ExUnit.Case
+        @moduletag :external
+
+        describe "makes calls to the right endpoint" do
+          @describetag :endpoint
 
-  A tag can be set for all tests in a module by setting `@moduletag`:
+          # ...
+        end
+      end
 
-      @moduletag :external
+  If you are setting a `@moduletag` or `@describetag` attribute, you must
+  set them after your call to `use ExUnit.Case` otherwise you will see
+  compilation errors.
 
   If the same key is set via `@tag`, the `@tag` value has higher
   precedence.
 
-  ### Reserved tags
+  The `setup_all` blocks only receive tags that are set using `@moduletag`.
+
+  ### Known tags
 
   The following tags are set automatically by ExUnit and are
   therefore reserved:
 
-    * `:case` - the test case module
-    * `:test` - the test name
-    * `:line` - the line on which the test was defined
+    * `:async` - if the test case is in async mode
+
     * `:file` - the file on which the test was defined
 
+    * `:line` - the line on which the test was defined
+
+    * `:module` - the module on which the test was defined
+
+    * `:registered` - used for `ExUnit.Case.register_attribute/3` values
+
+    * `:test` - the test name
+
+    * `:test_group` - the group the test belongs to
+
+    * `:test_pid` - the PID of the testing process
+
+    * `:test_type` - the test type used when printing test results. It can also
+      be used for filtering. It is set by ExUnit to `:test`, `:doctest`, or
+      the equivalent type given to `register_test/6`
+
+    * `:describe` - the describe block the test belongs to (if in a describe)
+
+    * `:describe_line` - the line the describe block begins on (if in a describe).
+      It can be used to run all tests in the describe block given by line
+
+    * `:doctest` - the module or the file being doctested (if a doctest)
+
+    * `:doctest_data` - additional metadata about doctests stored in a map,
+      such as the `:end_line`, available for reflection purposes (if a doctest)
+
+    * `:doctest_line` - the line the doctest was defined (if a doctest).
+      It can be used to run a doctest defined at the given source line
+
+  The following tags customize how tests behave:
+
+    * `:capture_log` - see the "Log Capture" section below
+
+    * `:skip` - skips the test with the given reason
+
+    * `:timeout` - customizes the test timeout in milliseconds (defaults to `60_000`).
+      Accepts `:infinity` as a timeout value.
+
+    * `:tmp_dir` - (since v1.11.0) see the "Tmp Dir" section below
+
+  ## Parameterized tests
+
+  Sometimes you want to run the same tests but with different parameters.
+  In ExUnit, it is possible to do so by passing a `:parameterize` key to
+  `ExUnit.Case`. The value must be a list of maps which will be the
+  parameters merged into the test context.
+
+  For example, Elixir has a module called `Registry`, which can have type
+  `:unique` or `:duplicate`, and can control its concurrency factor using
+  the `:partitions` option. If you have a number of tests that *behave the
+  same* across all of those values, you can parameterize those tests with:
+
+      use ExUnit.Case,
+        async: true,
+        parameterize:
+          for(kind <- [:unique, :duplicate],
+              partitions <- [1, 8],
+              do: %{kind: kind, partitions: partitions})
+
+  Then, in your tests, you can access the parameters as part of the context:
+
+      test "starts a registry", %{kind: kind, partitions: partitions} do
+        ...
+      end
+
+  Use parameterized tests with care:
+
+    * Although parameterized tests run concurrently when `async: true` is also given,
+      abuse of parameterized tests may make your test suite slower
+
+    * If you use parameterized tests and then find yourself adding conditionals
+      in your tests to deal with different parameters, then parameterized tests
+      may be the wrong solution to your problem. Consider creating separated
+      tests and sharing logic between them using regular functions
+
   ## Filters
 
   Tags can also be used to identify specific tests, which can then
@@ -129,11 +241,11 @@ defmodule ExUnit.Case do
       # Exclude all external tests from running
       ExUnit.configure(exclude: [external: true])
 
-  From now on, ExUnit will not run any test that has the `external` flag
-  set to true. This behaviour can be reversed with the `:include` option
+  From now on, ExUnit will not run any test that has the `:external` option
+  set to `true`. This behaviour can be reversed with the `:include` option
   which is usually passed through the command line:
 
-      mix test --include external:true
+      $ mix test --include external:true
 
   Run `mix help test` for more information on how to run filters via Mix.
 
@@ -143,50 +255,171 @@ defmodule ExUnit.Case do
 
       ExUnit.configure(exclude: :os, include: [os: :unix])
 
+  A given include/exclude filter can be given more than once:
+
+      ExUnit.configure(exclude: [os: :unix, os: :windows])
+
   Keep in mind that all tests are included by default, so unless they are
   excluded first, the `include` option has no effect.
+
+  ## Log Capture
+
+  ExUnit can optionally suppress printing of log messages that are generated
+  during a test. Log messages generated while running a test are captured and
+  only if the test fails are they printed to aid with debugging.
+
+  You can opt into this behaviour for individual tests by tagging them with
+  `:capture_log` or enable log capture for all tests in the ExUnit configuration:
+
+      ExUnit.start(capture_log: true)
+
+  This default can be overridden by `@tag capture_log: false` or
+  `@moduletag capture_log: false`.
+
+  Since `setup_all` blocks don't belong to a specific test, log messages generated
+  in them (or between tests) are never captured. If you want to suppress these
+  messages as well, remove the console backend globally by setting:
+
+      config :logger, :default_handler, false
+
+  ## Tmp Dir
+
+  ExUnit automatically creates a temporary directory for tests tagged with
+  `:tmp_dir` and puts the path to that directory into the test context.
+  The directory is removed before being created to ensure we start with a blank
+  slate.
+
+  The temporary directory path is unique (includes the test module and test name)
+  and thus appropriate for running tests concurrently. You can customize the path
+  further by setting the tag to a string, e.g.: `tmp_dir: "my_path"`, which would
+  make the final path to be: `tmp/<module>/<test>/my_path`.
+
+  Example:
+
+      defmodule MyTest do
+        use ExUnit.Case, async: true
+
+        @tag :tmp_dir
+        test "with tmp_dir", %{tmp_dir: tmp_dir} do
+          assert tmp_dir =~ "with tmp_dir"
+          assert File.dir?(tmp_dir)
+        end
+      end
+
+  As with other tags, `:tmp_dir` can also be set as `@moduletag` and
+  `@describetag`.
+
+  ## Process Architecture
+
+  An ExUnit test case uses several processes when it runs. These are illustrated below.
+
+  ```mermaid
+  sequenceDiagram
+    participant runner as ExUnit Case
+    runner->>runner: Run setup_all callbacks
+
+    loop Each test
+      create participant test as Test Process
+      runner->>test: Spawn
+      test->>test: Run setup callbacks
+      test->>test: Run test
+      destroy test
+      test-xrunner: Exits
+      runner->>runner: Run on_exit callbacks
+    end
+  ```
+
+    1. First, all `ExUnit.Callbacks.setup_all/1` callbacks run in a single process, sequentially,
+       in the order they were defined.
+
+    2. Then, a new process is spawned for the test itself. In this process, first all
+       `ExUnit.Callbacks.setup/1` callbacks run, in the order they were defined. Then,
+       the test itself is executed.
+
+    3. After the test exits, a new process is spawned to run all `ExUnit.Callbacks.on_exit/2`,
+       in the reverse order they were defined.
+
   """
 
+  @type env :: module() | Macro.Env.t()
+
+  @type register_attribute_opts :: [
+          accumulate: boolean(),
+          persist: boolean()
+        ]
+  @compile {:no_warn_undefined, [IEx.Pry]}
+  @reserved [:module, :file, :line, :test, :async, :registered, :describe]
+
   @doc false
   defmacro __using__(opts) do
-    async = Keyword.get(opts, :async, false)
+    quote do
+      ExUnit.Case.__register__(__MODULE__, unquote(opts))
 
-    unless Process.whereis(ExUnit.Server) do
-      raise "cannot use ExUnit.Case without starting the ExUnit application, " <>
-            "please call ExUnit.start() or explicitly start the :ex_unit app"
+      import ExUnit.Callbacks
+      import ExUnit.Assertions
+      import ExUnit.Case, only: [describe: 2, test: 1, test: 2, test: 3]
+      import ExUnit.DocTest
     end
+  end
 
-    quote do
-      unless Module.get_attribute(__MODULE__, :ex_unit_tests) do
-        if unquote(async) do
-          ExUnit.Server.add_async_case(__MODULE__)
-        else
-          ExUnit.Server.add_sync_case(__MODULE__)
-        end
+  @keys [:async, :group, :parameterize, :register]
 
-        Enum.each [:ex_unit_tests, :tag, :moduletag],
-          &Module.register_attribute(__MODULE__, &1, accumulate: true)
+  @doc false
+  def __keys__(opts), do: Keyword.take(opts, @keys)
 
-        @before_compile ExUnit.Case
-        use ExUnit.Callbacks
+  @doc false
+  def __register__(module, opts) do
+    if not Keyword.keyword?(opts) do
+      raise ArgumentError,
+            ~s(the argument passed to "use ExUnit.Case" must be a list of options, ) <>
+              ~s(got: #{inspect(opts)})
+    end
+
+    {register?, opts} = Keyword.pop(opts, :register, true)
+    {next_opts, opts} = Keyword.split(opts, @keys)
+
+    if opts != [] do
+      IO.warn("unknown options given to ExUnit.Case: #{inspect(opts)}")
+    end
+
+    if not Module.has_attribute?(module, :ex_unit_tests) do
+      tag_check = Enum.any?([:moduletag, :describetag, :tag], &Module.has_attribute?(module, &1))
+
+      if tag_check do
+        raise "you must set @tag, @describetag, and @moduletag after the call to \"use ExUnit.Case\""
       end
 
-      import ExUnit.Callbacks
-      import ExUnit.Assertions
-      import ExUnit.Case
-      import ExUnit.DocTest
+      accumulate_attributes = [
+        :ex_unit_tests,
+        :tag,
+        :describetag,
+        :moduletag,
+        :ex_unit_registered_test_attributes,
+        :ex_unit_registered_describe_attributes,
+        :ex_unit_registered_module_attributes
+      ]
+
+      Enum.each(accumulate_attributes, &Module.register_attribute(module, &1, accumulate: true))
+
+      if register? do
+        Module.put_attribute(module, :after_compile, ExUnit.Case)
+      end
+
+      ExUnit.Callbacks.__register__(module)
+      Module.put_attribute(module, :before_compile, ExUnit.Case)
     end
+
+    past_opts = Module.get_attribute(module, :ex_unit_module, [])
+    Module.put_attribute(module, :ex_unit_module, Keyword.merge(past_opts, next_opts))
+    :ok
   end
 
   @doc """
-  Define a test with a string.
+  Defines a test with `message`.
 
-  Provides a convenient macro that allows a test to be
-  defined with a string. This macro automatically inserts
-  the atom `:ok` as the last line of the test. That said,
-  a passing test always returns `:ok`, but, more importantly,
-  it forces Elixir to not tail call optimize the test and
-  therefore avoids hiding lines from the backtrace.
+  The test may also define a pattern, which will be matched
+  against the test context. For more information on contexts, see
+  `ExUnit.Callbacks`.
 
   ## Examples
 
@@ -196,55 +429,530 @@ defmodule ExUnit.Case do
 
   """
   defmacro test(message, var \\ quote(do: _), contents) do
+    if not is_tuple(var) do
+      IO.warn(
+        "test context is always a map. The pattern " <>
+          "#{inspect(Macro.to_string(var))} will never match",
+        Macro.Env.stacktrace(__CALLER__)
+      )
+    end
+
     contents =
-      case contents do
-        [do: _] ->
+      case annotate_test(contents, __CALLER__) do
+        [do: block] ->
           quote do
-            unquote(contents)
+            unquote(block)
             :ok
           end
-        _ ->
+
+        contents ->
           quote do
             try(unquote(contents))
             :ok
           end
       end
 
-    var      = Macro.escape(var)
-    contents = Macro.escape(contents, unquote: true)
+    %{module: mod, file: file, line: line} = __CALLER__
+
+    name =
+      quote do
+        name =
+          ExUnit.Case.register_test(
+            unquote(mod),
+            unquote(file),
+            unquote(line),
+            :test,
+            unquote(message),
+            []
+          )
+      end
+
+    def =
+      {:def, [],
+       [
+         {{:unquote, [], [quote(do: name)]}, [], [var]},
+         [do: contents]
+       ]}
+
+    {:__block__, [], [name, def]}
+  end
+
+  defp annotate_test(contents, caller) do
+    if Application.get_env(:ex_unit, :breakpoints, false) and Keyword.keyword?(contents) do
+      for {key, expr} <- contents do
+        {key, IEx.Pry.annotate_quoted(expr, true, caller)}
+      end
+    else
+      contents
+    end
+  end
+
+  @doc """
+  Defines a not implemented test with a string.
+
+  Provides a convenient macro that allows a test to be defined
+  with a string, but not yet implemented. The resulting test will
+  always fail and print a "Not implemented" error message. The
+  resulting test case is also tagged with `:not_implemented`.
+
+  ## Examples
+
+      test "this will be a test in future"
+
+  """
+  defmacro test(message) do
+    %{module: mod, file: file, line: line} = __CALLER__
+
+    quote bind_quoted: binding() do
+      name = ExUnit.Case.register_test(mod, file, line, :test, message, [:not_implemented])
+      def unquote(name)(_), do: flunk("Not implemented")
+    end
+  end
+
+  @doc """
+  Describes tests together.
+
+  Every describe block receives a name which is used as prefix for
+  upcoming tests. Inside a block, `ExUnit.Callbacks.setup/1` may be
+  invoked and it will define a setup callback to run only for the
+  current block. The describe name is also added as a tag, allowing
+  developers to run tests for specific blocks.
+
+  ## Examples
+
+      defmodule StringTest do
+        use ExUnit.Case, async: true
+
+        describe "String.downcase/1" do
+          test "with ascii characters" do
+            assert String.downcase("HELLO") == "hello"
+          end
+
+          test "with Unicode" do
+            assert String.downcase("HÉLLÒ") == "héllò"
+          end
+        end
+      end
+
+  When using Mix, you can run all tests in a describe block by name:
+
+      $ mix test --only describe:"String.downcase/1"
+
+  or by passing the exact line the describe block starts on:
+
+      $ mix test path/to/file:123
+
+  Note describe blocks cannot be nested. Instead of relying on hierarchy
+  for composition, developers should build on top of named setups. For
+  example:
+
+      defmodule UserManagementTest do
+        use ExUnit.Case, async: true
+
+        describe "when user is logged in and is an admin" do
+          setup [:log_user_in, :set_type_to_admin]
+
+          test ...
+        end
+
+        describe "when user is logged in and is a manager" do
+          setup [:log_user_in, :set_type_to_manager]
+
+          test ...
+        end
+
+        defp log_user_in(context) do
+          # ...
+        end
+      end
+
+  By forbidding hierarchies in favor of named setups, it is straightforward
+  for the developer to glance at each describe block and know exactly the
+  setup steps involved.
+  """
+  @doc since: "1.3.0"
+  defmacro describe(message, do: block) do
+    definition =
+      quote unquote: false do
+        defp unquote(name)(var!(context)), do: unquote(body)
+      end
+
+    quote do
+      ExUnit.Callbacks.__describe__(__MODULE__, __ENV__.line, unquote(message), fn
+        message, describes ->
+          res = unquote(block)
 
-    quote bind_quoted: binding do
-      test = :"test #{message}"
-      ExUnit.Case.__on_definition__(__ENV__, test)
-      def unquote(test)(unquote(var)), do: unquote(contents)
+          case ExUnit.Callbacks.__describe__(__MODULE__, message, describes) do
+            {nil, nil} -> :ok
+            {name, body} -> unquote(definition)
+          end
+
+          res
+      end)
     end
   end
 
   @doc false
-  defmacro __before_compile__(_) do
+  defmacro __before_compile__(%{module: module}) do
+    tests =
+      module
+      |> Module.get_attribute(:ex_unit_tests)
+      |> Enum.reverse()
+      |> Macro.escape()
+
+    moduletag = Module.get_attribute(module, :moduletag)
+
+    tags =
+      moduletag
+      |> normalize_tags()
+      |> validate_tags()
+      |> Map.new()
+
+    opts = Module.get_attribute(module, :ex_unit_module, [])
+    async? = Keyword.get(opts, :async, false)
+    group = Keyword.get(opts, :group, nil)
+    parameterize = Keyword.get(opts, :parameterize, nil)
+
+    if not is_boolean(async?) do
+      raise ArgumentError, ":async must be a boolean, got: #{inspect(async?)}"
+    end
+
+    if not (parameterize == nil or (is_list(parameterize) and Enum.all?(parameterize, &is_map/1))) do
+      raise ArgumentError, ":parameterize must be a list of maps, got: #{inspect(parameterize)}"
+    end
+
+    {setup_all?, callbacks} = ExUnit.Callbacks.__callbacks__(module)
+
     quote do
-      def __ex_unit__(:case) do
-        %ExUnit.TestCase{name: __MODULE__, tests: @ex_unit_tests}
+      unquote(callbacks)
+
+      def __ex_unit__ do
+        %ExUnit.TestModule{
+          file: __ENV__.file,
+          name: __MODULE__,
+          setup_all?: unquote(setup_all?),
+          tags: unquote(Macro.escape(tags)),
+          tests: unquote(tests)
+        }
+      end
+
+      def __ex_unit__(:config) do
+        %{
+          async?: unquote(async?),
+          group: unquote(Macro.escape(group)),
+          parameterize: unquote(Macro.escape(parameterize))
+        }
       end
     end
   end
 
   @doc false
-  def __on_definition__(env, name) do
-    mod  = env.module
-    tags = Module.get_attribute(mod, :tag) ++ Module.get_attribute(mod, :moduletag)
-    tags = tags |> normalize_tags |> Map.merge(%{line: env.line, file: env.file})
+  def __after_compile__(%{module: module}, _) do
+    cond do
+      Process.whereis(ExUnit.Server) ->
+        ExUnit.Server.add_module(module, module.__ex_unit__(:config))
 
-    Module.put_attribute(mod, :ex_unit_tests,
-      %ExUnit.Test{name: name, case: mod, tags: tags})
+      Code.can_await_module_compilation?() ->
+        :ok
 
-    Module.delete_attribute(mod, :tag)
+      true ->
+        raise "cannot use ExUnit.Case without starting the ExUnit application, " <>
+                "please call ExUnit.start() or explicitly start the :ex_unit app"
+    end
   end
 
-  defp normalize_tags(tags) do
-    Enum.reduce Enum.reverse(tags), %{}, fn
-      tag, acc when is_atom(tag) -> Map.put(acc, tag, true)
-      tag, acc when is_list(tag) -> Dict.merge(acc, tag)
+  @doc """
+  Registers a function to run as a test for this module.
+
+  This is used by third-party projects to implement macros like
+  `property/3` that works like `test` but instead defines a property.
+  See `test/3` implementation for an example of invoking this function.
+
+  The test type will be converted to a string and pluralized for
+  display. You can use `ExUnit.plural_rule/2` to set a custom
+  pluralization.
+  """
+  @doc since: "1.11.0"
+  def register_test(mod, file, line, test_type, name, tags) do
+    if not Module.has_attribute?(mod, :ex_unit_tests) do
+      raise "cannot define #{test_type}. Please make sure you have invoked " <>
+              "\"use ExUnit.Case\" in the current module"
+    end
+
+    registered_attribute_keys = [
+      :ex_unit_registered_module_attributes,
+      :ex_unit_registered_describe_attributes,
+      :ex_unit_registered_test_attributes
+    ]
+
+    registered =
+      for key <- registered_attribute_keys,
+          attribute <- Module.get_attribute(mod, key),
+          into: %{} do
+        {attribute, Module.get_attribute(mod, attribute)}
+      end
+
+    moduletag = Module.get_attribute(mod, :moduletag)
+    tag = Module.delete_attribute(mod, :tag)
+
+    {name, describe, describe_line, describetag} =
+      case Module.get_attribute(mod, :ex_unit_describe) do
+        {line, describe, _counter} ->
+          test_name = validate_test_name("#{test_type} #{describe} #{name}")
+          {test_name, describe, line, Module.get_attribute(mod, :describetag)}
+
+        nil ->
+          test_name = validate_test_name("#{test_type} #{name}")
+          {test_name, nil, nil, []}
+      end
+
+    if Module.defines?(mod, {name, 1}) do
+      raise ArgumentError, ~s("#{name}" is already defined in #{inspect(mod)})
     end
+
+    tags =
+      (tags ++ tag ++ describetag ++ moduletag)
+      |> normalize_tags()
+      |> validate_tags()
+      |> Map.merge(%{
+        line: line,
+        file: file,
+        registered: registered,
+        describe: describe,
+        describe_line: describe_line,
+        test_type: test_type
+      })
+
+    test = %ExUnit.Test{name: name, case: mod, tags: tags, module: mod}
+    Module.put_attribute(mod, :ex_unit_tests, test)
+
+    for attribute <- Module.get_attribute(mod, :ex_unit_registered_test_attributes) do
+      Module.delete_attribute(mod, attribute)
+    end
+
+    name
+  end
+
+  @doc """
+  Registers a test with the given environment.
+
+  This function is deprecated in favor of `register_test/6` which performs
+  better under tight loops by avoiding `__ENV__`.
+  """
+  # TODO: Remove me Elixir v2.0
+  @deprecated "Use register_test/6 instead"
+  @doc since: "1.3.0"
+  def register_test(%{module: mod, file: file, line: line}, test_type, name, tags) do
+    register_test(mod, file, line, test_type, name, tags)
+  end
+
+  @doc """
+  Registers a new attribute to be used during `ExUnit.Case` tests.
+
+  The attribute values will be available through `context.registered`.
+  Registered values are cleared after each `test/3` similar
+  to `@tag`.
+
+  This function takes the same options as `Module.register_attribute/3`.
+
+  ## Examples
+
+      defmodule MyTest do
+        use ExUnit.Case
+
+        ExUnit.Case.register_attribute(__MODULE__, :fixtures, accumulate: true)
+
+        @fixtures :user
+        @fixtures {:post, insert: false}
+        test "using custom attribute", context do
+          assert context.registered.fixtures == [{:post, insert: false}, :user]
+        end
+
+        test "custom attributes are cleared per test", context do
+          assert context.registered.fixtures == []
+        end
+      end
+
+  """
+  @doc since: "1.3.0"
+  @spec register_attribute(env, atom, register_attribute_opts) :: :ok
+  def register_attribute(env, name, opts \\ [])
+  def register_attribute(%{module: mod}, name, opts), do: register_attribute(mod, name, opts)
+
+  def register_attribute(mod, name, opts) when is_atom(mod) and is_atom(name) and is_list(opts) do
+    register_attribute(:ex_unit_registered_test_attributes, mod, name, opts)
+  end
+
+  @doc """
+  Registers a new describe attribute to be used during `ExUnit.Case` tests.
+
+  The attribute values will be available through `context.registered`.
+  Registered values are cleared after each `describe/2` similar
+  to `@describetag`.
+
+  This function takes the same options as `Module.register_attribute/3`.
+
+  ## Examples
+
+      defmodule MyTest do
+        use ExUnit.Case
+
+        ExUnit.Case.register_describe_attribute(__MODULE__, :describe_fixtures, accumulate: true)
+
+        describe "using custom attribute" do
+          @describe_fixtures :user
+          @describe_fixtures {:post, insert: false}
+
+          test "has attribute", context do
+            assert context.registered.describe_fixtures == [{:post, insert: false}, :user]
+          end
+        end
+
+        describe "custom attributes are cleared per describe" do
+          test "doesn't have attributes", context do
+            assert context.registered.describe_fixtures == []
+          end
+        end
+      end
+
+  """
+  @doc since: "1.10.0"
+  @spec register_describe_attribute(env, atom, register_attribute_opts) :: :ok
+  def register_describe_attribute(env, name, opts \\ [])
+
+  def register_describe_attribute(%{module: mod}, name, opts) do
+    register_describe_attribute(mod, name, opts)
+  end
+
+  def register_describe_attribute(mod, name, opts)
+      when is_atom(mod) and is_atom(name) and is_list(opts) do
+    register_attribute(:ex_unit_registered_describe_attributes, mod, name, opts)
+  end
+
+  @doc """
+  Registers a new module attribute to be used during `ExUnit.Case` tests.
+
+  The attribute values will be available through `context.registered`.
+
+  This function takes the same options as `Module.register_attribute/3`.
+
+  ## Examples
+
+      defmodule MyTest do
+        use ExUnit.Case
+
+        ExUnit.Case.register_module_attribute(__MODULE__, :module_fixtures, accumulate: true)
+
+        @module_fixtures :user
+        @module_fixtures {:post, insert: false}
+
+        test "using custom attribute", context do
+          assert context.registered.module_fixtures == [{:post, insert: false}, :user]
+        end
+
+        test "still using custom attribute", context do
+          assert context.registered.module_fixtures == [{:post, insert: false}, :user]
+        end
+      end
+
+  """
+  @doc since: "1.10.0"
+  @spec register_module_attribute(env, atom, register_attribute_opts) :: :ok
+  def register_module_attribute(env, name, opts \\ [])
+
+  def register_module_attribute(%{module: mod}, name, opts) do
+    register_module_attribute(mod, name, opts)
+  end
+
+  def register_module_attribute(mod, name, opts)
+      when is_atom(mod) and is_atom(name) and is_list(opts) do
+    register_attribute(:ex_unit_registered_module_attributes, mod, name, opts)
+  end
+
+  defp register_attribute(type, mod, name, opts) do
+    validate_registered_attribute!(type, mod, name)
+    Module.register_attribute(mod, name, opts)
+    Module.put_attribute(mod, type, name)
+  end
+
+  defp validate_registered_attribute!(type, mod, name) do
+    registered_attribute_keys = [
+      :ex_unit_registered_module_attributes,
+      :ex_unit_registered_describe_attributes,
+      :ex_unit_registered_test_attributes
+    ]
+
+    for key <- registered_attribute_keys,
+        type != key and name in Module.get_attribute(mod, key) do
+      raise ArgumentError, "cannot register attribute #{inspect(name)} multiple times"
+    end
+
+    if Module.has_attribute?(mod, name) do
+      raise "you must set @#{name} after it has been registered"
+    end
+  end
+
+  @doc """
+  Returns the most recently registered test case as an `%ExUnit.Test{}`
+  struct.
+
+  This is used by third-party utilities to allow compile-time configuration
+  using test tags without having to explicitly pass the test context at
+  run-time. It is intended to be invoked in macros before the test module
+  is compiled.
+
+  Raises if called with a module that has already been compiled.
+  """
+  @doc since: "1.15.0"
+  @spec get_last_registered_test(env) :: ExUnit.Test.t() | nil
+  def get_last_registered_test(%{module: mod}) do
+    get_last_registered_test(mod)
+  end
+
+  def get_last_registered_test(mod) when is_atom(mod) do
+    Module.get_last_attribute(mod, :ex_unit_tests)
+  end
+
+  defp validate_tags(tags) do
+    for tag <- @reserved, Map.has_key?(tags, tag) do
+      raise "cannot set tag #{inspect(tag)} because it is reserved by ExUnit"
+    end
+
+    if not is_atom(tags[:test_type]) do
+      raise("value for tag \":test_type\" must be an atom")
+    end
+
+    tags
+  end
+
+  defp validate_test_name(name) do
+    try do
+      String.to_atom(name)
+    rescue
+      SystemLimitError ->
+        raise SystemLimitError, """
+        the computed name of a test (which includes its type, the name of its parent describe \
+        block if present, and the test name itself) must be shorter than 255 characters, \
+        got: #{inspect(name)}
+        """
+    end
+  end
+
+  defp normalize_tags(tags) do
+    Enum.reduce(Enum.reverse(tags), %{}, fn
+      {key, value}, acc ->
+        Map.put(acc, key, value)
+
+      tag, acc when is_atom(tag) ->
+        Map.put(acc, tag, true)
+
+      tag, acc ->
+        if Keyword.keyword?(tag) do
+          Enum.into(tag, acc)
+        else
+          raise "an invalid value for a tag was used. " <>
+                  "Expected an atom or a keyword list, got: #{inspect(tag)}"
+        end
+    end)
   end
 end
diff --git a/lib/ex_unit/lib/ex_unit/case_template.ex b/lib/ex_unit/lib/ex_unit/case_template.ex
index 2e41af01cdd..4a7dfa0f03b 100644
--- a/lib/ex_unit/lib/ex_unit/case_template.ex
+++ b/lib/ex_unit/lib/ex_unit/case_template.ex
@@ -1,12 +1,35 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.CaseTemplate do
   @moduledoc """
-  This module allows a developer to define a test case
-  template to be used throughout his tests. This is useful
-  when there are a set of functions that should be shared
-  between tests or a set of setup callbacks.
+  Defines a module template to be used throughout your test suite.
+
+  This is useful when there are a set of setup callbacks or a set
+  of functions that should be shared between test modules.
+
+  Let's imagine that you create a `MyCase` module that calls `use
+  ExUnit.CaseTemplate`. When a test case module calls `use MyCase`, the
+  following things hold true:
+
+    * All the functionality that `MyCase` would have had available from
+      `use ExUnit.Case` is available (same as if `MyCase` called `use
+      ExUnit.Case` directly)
+
+    * The `setup` and `setup_all` callbacks that you define in `MyCase`
+      get used in the test case module
 
-  By using this module, the callbacks and assertions
-  available for regular test cases will also be available.
+  The options that you pass to `use MyCase` get also passed to `use
+  ExUnit.Case` under the hood. This means you can do things like `use
+  MyCase, async: true`. You can also access this options in `using/2`.
+
+  > #### `use ExUnit.CaseTemplate` {: .info}
+  >
+  > When you `use ExUnit.CaseTemplate`, it will import the functionality
+  > from `ExUnit.Assertions`, `ExUnit.Callbacks`, and this module itself.
+  > It will also define a `__using__` callback, so the module itself can
+  > be used as a template instead of `ExUnit.Case`.
 
   ## Example
 
@@ -14,7 +37,7 @@ defmodule ExUnit.CaseTemplate do
         use ExUnit.CaseTemplate
 
         setup do
-          IO.puts "This will run before each test that uses this case"
+          IO.puts("This will run before each test that uses this case")
         end
       end
 
@@ -26,12 +49,28 @@ defmodule ExUnit.CaseTemplate do
         end
       end
 
+  If you need to "hook" into `use MyCase` and do other things as well,
+  you can use the `using/2` macro. See its documentation for more
+  information and examples.
+
+      defmodule MyCase do
+        use ExUnit.CaseTemplate
+
+        using do
+          quote do
+            import MyApp.TestHelpers
+          end
+        end
+      end
+
   """
 
   @doc false
   defmacro __using__(_) do
     quote do
-      use ExUnit.Callbacks
+      ExUnit.Callbacks.__register__(__MODULE__)
+      @before_compile ExUnit.Callbacks
+      import ExUnit.Callbacks
 
       import ExUnit.Assertions
       import unquote(__MODULE__)
@@ -40,14 +79,15 @@ defmodule ExUnit.CaseTemplate do
         unquote(__MODULE__).__proxy__(__MODULE__, opts)
       end
 
-      defoverridable [__using__: 1]
+      defoverridable __using__: 1
     end
   end
 
   @doc false
+  # We inject this code in the module that calls "use MyTemplate".
   def __proxy__(module, opts) do
     quote do
-      use ExUnit.Case, unquote(opts)
+      use ExUnit.Case, ExUnit.Case.__keys__(unquote(opts))
 
       setup_all context do
         unquote(module).__ex_unit__(:setup_all, context)
@@ -62,9 +102,56 @@ defmodule ExUnit.CaseTemplate do
   @doc """
   Allows a developer to customize the using block
   when the case template is used.
+
+  You can use an optional `var` argument when calling `using/2`. ExUnit
+  will pass whatever argument you pass to `use MyCase` as this `var` argument. See the examples below for clarification.
+
+  ## Example
+
+      defmodule MyCase do
+        use ExUnit.CaseTemplate
+
+        using do
+          quote do
+            # This code is injected into every case that calls "use MyCase"
+            alias MyApp.FunModule
+          end
+        end
+      end
+
+  You can specify an argument to `using/2`:
+
+      defmodule MyCase do
+        use ExUnit.CaseTemplate
+
+        using options do
+          quote do
+            if unquote(options)[:import_helpers] do
+              import MyApp.TestHelpers
+            end
+          end
+        end
+      end
+
+  The second argument passed to `use MyCase` gets forwarded to `using/2` too:
+
+      defmodule SomeTestCase do
+        use MyCase, async: true, import_helpers: true
+
+        test "the truth" do
+          # truth/0 comes from MyApp.TestHelpers:
+          assert truth()
+        end
+      end
+
+  > #### Sharing options with `use ExUnit.Case` {: .warning}
+  >
+  > The second argument that you pass to `use MyCase` is *also* passed
+  > as the second argument to `use ExUnit.Case`.
+
   """
   defmacro using(var \\ quote(do: _), do: block) do
-    quote location: :keep do
+    quote do
       defmacro __using__(unquote(var) = opts) do
         parent = unquote(__MODULE__).__proxy__(__MODULE__, opts)
         result = unquote(block)
diff --git a/lib/ex_unit/lib/ex_unit/cli_formatter.ex b/lib/ex_unit/lib/ex_unit/cli_formatter.ex
index 444b896068e..98f73f8f1a5 100644
--- a/lib/ex_unit/lib/ex_unit/cli_formatter.ex
+++ b/lib/ex_unit/lib/ex_unit/cli_formatter.ex
@@ -1,198 +1,537 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.CLIFormatter do
   @moduledoc false
+  use GenServer
 
-  use GenEvent
-
-  import ExUnit.Formatter, only: [format_time: 2, format_filters: 2, format_test_failure: 5,
-                                  format_test_case_failure: 5]
+  import ExUnit.Formatter,
+    only: [format_times: 1, format_filters: 2, format_test_failure: 5, format_test_all_failure: 5]
 
   ## Callbacks
 
   def init(opts) do
-    print_filters(Keyword.take(opts, [:include, :exclude]))
+    IO.puts("Running ExUnit with seed: #{opts[:seed]}, max_cases: #{opts[:max_cases]}")
+    print_filters(opts, :exclude)
+    print_filters(opts, :include)
+    IO.puts("")
+
     config = %{
-      seed: opts[:seed],
+      dry_run: opts[:dry_run],
       trace: opts[:trace],
-      color: opts[:color],
+      colors: colors(opts),
       width: get_terminal_width(),
-      tests_counter: 0,
-      failures_counter: 0,
-      invalids_counter: 0
+      slowest: opts[:slowest],
+      slowest_modules: opts[:slowest_modules],
+      test_counter: %{},
+      test_timings: [],
+      failure_counter: 0,
+      skipped_counter: 0,
+      excluded_counter: 0,
+      invalid_counter: 0
     }
+
     {:ok, config}
   end
 
-  def handle_event({:suite_finished, run_us, load_us}, config) do
-    print_suite(config, run_us, load_us)
-    :remove_handler
+  def handle_cast({:suite_started, _opts}, config) do
+    if config.dry_run, do: IO.puts(extra_info("Tests that would be executed:", config))
+
+    {:noreply, config}
   end
 
-  def handle_event({:test_started, %ExUnit.Test{} = test}, config) do
-    if config.trace, do: IO.write "  * #{trace_test_name test}"
-    {:ok, config}
+  def handle_cast({:suite_finished, times_us}, config) do
+    test_type_counts = collect_test_type_counts(config)
+
+    if test_type_counts == 0 and config.excluded_counter > 0 do
+      IO.puts(invalid("All tests have been excluded.", config))
+    end
+
+    IO.write("\n")
+    IO.puts(format_times(times_us))
+
+    if config.slowest > 0 do
+      IO.puts(format_slowest_tests(config, times_us.run))
+    end
+
+    if config.slowest_modules > 0 do
+      IO.puts(format_slowest_modules(config, times_us.run))
+    end
+
+    print_summary(config, false)
+    {:noreply, config}
   end
 
-  def handle_event({:test_finished, %ExUnit.Test{state: nil} = test}, config) do
+  def handle_cast({:test_started, %ExUnit.Test{} = test}, config) do
+    if config.trace, do: IO.write("#{trace_test_started(test)} [#{trace_test_line(test)}]")
+    {:noreply, config}
+  end
+
+  def handle_cast({:test_finished, %ExUnit.Test{state: nil} = test}, config) do
     if config.trace do
-      IO.puts success(trace_test_result(test), config)
+      IO.puts(success(trace_test_result(test), config))
     else
-      IO.write success(".", config)
+      IO.write(success(".", config))
     end
-    {:ok, %{config | tests_counter: config.tests_counter + 1}}
+
+    config = %{config | test_counter: update_test_counter(config.test_counter, test)}
+    {:noreply, update_test_timings(config, test)}
   end
 
-  def handle_event({:test_finished, %ExUnit.Test{state: {:skip, _}} = test}, config) do
-    if config.trace, do: IO.puts trace_test_skip(test)
-    {:ok, config}
+  def handle_cast({:test_finished, %ExUnit.Test{state: {:excluded, reason}} = test}, config)
+      when is_binary(reason) do
+    if config.trace, do: IO.puts(trace_test_excluded(test))
+
+    test_counter = update_test_counter(config.test_counter, test)
+    config = %{config | test_counter: test_counter, excluded_counter: config.excluded_counter + 1}
+
+    {:noreply, config}
   end
 
-  def handle_event({:test_finished, %ExUnit.Test{state: {:invalid, _}} = test}, config) do
+  def handle_cast({:test_finished, %ExUnit.Test{state: {:skipped, reason}} = test}, config)
+      when is_binary(reason) do
     if config.trace do
-      IO.puts invalid(trace_test_result(test), config)
+      IO.puts(skipped(trace_test_skipped(test), config))
     else
-      IO.write invalid("?", config)
+      IO.write(skipped("*", config))
     end
 
-    {:ok, %{config | tests_counter: config.tests_counter + 1,
-                     invalids_counter: config.invalids_counter + 1}}
+    test_counter = update_test_counter(config.test_counter, test)
+    config = %{config | test_counter: test_counter, skipped_counter: config.skipped_counter + 1}
+
+    {:noreply, config}
   end
 
-  def handle_event({:test_finished, %ExUnit.Test{state: {:failed, failed}} = test}, config) do
+  def handle_cast(
+        {:test_finished,
+         %ExUnit.Test{state: {:invalid, %ExUnit.TestModule{state: {:failed, _}}}} = test},
+        config
+      ) do
     if config.trace do
-      IO.puts failure(trace_test_result(test), config)
+      IO.puts(invalid(trace_test_result(test), config))
+    else
+      IO.write(invalid("?", config))
     end
 
-    formatted = format_test_failure(test, failed, config.failures_counter + 1,
-                                    config.width, &formatter(&1, &2, config))
+    test_counter = update_test_counter(config.test_counter, test)
+    config = %{config | test_counter: test_counter, invalid_counter: config.invalid_counter + 1}
+
+    {:noreply, config}
+  end
+
+  def handle_cast({:test_finished, %ExUnit.Test{state: {:failed, failures}} = test}, config) do
+    if config.trace do
+      IO.puts(failure(trace_test_result(test), config))
+    end
+
+    formatted =
+      format_test_failure(
+        test,
+        failures,
+        config.failure_counter + 1,
+        config.width,
+        &formatter(&1, &2, config)
+      )
+
     print_failure(formatted, config)
+    print_logs(test.logs)
+
+    test_counter = update_test_counter(config.test_counter, test)
+    failure_counter = config.failure_counter + 1
+    config = %{config | test_counter: test_counter, failure_counter: failure_counter}
 
-    {:ok, %{config | tests_counter: config.tests_counter + 1,
-                     failures_counter: config.failures_counter + 1}}
+    {:noreply, update_test_timings(config, test)}
   end
 
-  def handle_event({:case_started, %ExUnit.TestCase{name: name}}, config) do
+  def handle_cast({:module_started, %ExUnit.TestModule{} = module}, config) do
     if config.trace do
-      IO.puts("\n#{inspect name}")
+      %{name: name, file: file, parameters: parameters} = module
+      IO.puts("\n#{inspect(name)} [#{Path.relative_to_cwd(file)}]")
+
+      if parameters != %{} do
+        IO.puts("Parameters: #{inspect(parameters)}")
+      end
     end
 
-    {:ok, config}
+    {:noreply, config}
   end
 
-  def handle_event({:case_finished, %ExUnit.TestCase{state: nil}}, config) do
-    {:ok, config}
+  def handle_cast({:module_finished, %ExUnit.TestModule{state: nil} = module}, config) do
+    if config.dry_run do
+      file_path = Path.relative_to_cwd(module.file)
+
+      Enum.each(module.tests, fn test ->
+        IO.puts("#{file_path}:#{test.tags.line}")
+      end)
+    end
+
+    {:noreply, config}
   end
 
-  def handle_event({:case_finished, %ExUnit.TestCase{state: {:failed, failed}} = test_case}, config) do
-    formatted = format_test_case_failure(test_case, failed, config.failures_counter + 1,
-                                         config.width, &formatter(&1, &2, config))
+  def handle_cast(
+        {:module_finished, %ExUnit.TestModule{state: {:failed, failures}} = test_module},
+        config
+      ) do
+    # The failed tests have already contributed to the counter,
+    # so we should only add the successful tests to the count
+    config =
+      update_in(config.failure_counter, fn counter ->
+        counter + Enum.count(test_module.tests, &is_nil(&1.state))
+      end)
+
+    formatted =
+      format_test_all_failure(
+        test_module,
+        failures,
+        config.failure_counter,
+        config.width,
+        &formatter(&1, &2, config)
+      )
+
     print_failure(formatted, config)
-    {:ok, %{config | failures_counter: config.failures_counter + 1}}
+
+    {:noreply, config}
   end
 
-  def handle_event(_, config) do
-    {:ok, config}
+  def handle_cast(:max_failures_reached, config) do
+    IO.write(failure("--max-failures reached, aborting test suite", config))
+    {:noreply, config}
   end
 
-  ## Tracing
+  def handle_cast({:sigquit, current}, config) do
+    IO.write("\n\n")
 
-  defp trace_test_name(%ExUnit.Test{name: name}) do
-    case Atom.to_string(name) do
-      "test " <> rest -> rest
-      rest -> rest
+    if current == [] do
+      IO.write(failure("Aborting test suite, showing results so far...\n\n", config))
+    else
+      IO.write(failure("Aborting test suite, the following have not completed:\n\n", config))
+      Enum.each(current, &IO.puts(trace_aborted(&1)))
+      IO.write(failure("\nShowing results so far...\n\n", config))
     end
+
+    print_summary(config, true)
+    {:noreply, config}
   end
 
+  def handle_cast(_, config) do
+    {:noreply, config}
+  end
+
+  ## Tracing
+
   defp trace_test_time(%ExUnit.Test{time: time}) do
     "#{format_us(time)}ms"
   end
 
+  defp trace_test_line(%ExUnit.Test{tags: tags}) do
+    "L##{tags.line}"
+  end
+
+  defp trace_test_file_line(%ExUnit.Test{tags: tags}) do
+    "#{Path.relative_to_cwd(tags.file)}:#{tags.line}"
+  end
+
+  defp trace_test_started(test) do
+    String.replace("  * #{test.name}", "\n", " ")
+  end
+
   defp trace_test_result(test) do
-    "\r  * #{trace_test_name test} (#{trace_test_time(test)})"
+    "\r#{trace_test_started(test)} (#{trace_test_time(test)}) [#{trace_test_line(test)}]"
+  end
+
+  defp trace_test_excluded(test) do
+    "\r#{trace_test_started(test)} (excluded) [#{trace_test_line(test)}]"
   end
 
-  defp trace_test_skip(test) do
-    "\r  * #{trace_test_name test} (skipped)"
+  defp trace_test_skipped(test) do
+    "\r#{trace_test_started(test)} (skipped) [#{trace_test_line(test)}]"
+  end
+
+  defp trace_aborted(%ExUnit.Test{} = test) do
+    "* #{test.name} [#{trace_test_file_line(test)}]"
+  end
+
+  defp trace_aborted(%ExUnit.TestModule{name: name, file: file}) do
+    "* #{inspect(name)} [#{Path.relative_to_cwd(file)}]"
+  end
+
+  defp normalize_us(us) do
+    div(us, 1000)
   end
 
   defp format_us(us) do
     us = div(us, 10)
+
     if us < 10 do
       "0.0#{us}"
     else
-      us = div us, 10
+      us = div(us, 10)
       "#{div(us, 10)}.#{rem(us, 10)}"
     end
   end
 
-  ## Printing
+  defp update_test_counter(test_counter, %{state: {:excluded, _reason}}) do
+    test_counter
+  end
+
+  defp update_test_counter(test_counter, %{tags: %{test_type: test_type}}) do
+    Map.update(test_counter, test_type, 1, &(&1 + 1))
+  end
+
+  ## Slowest
+
+  defp format_slowest_tests(%{slowest: slowest, test_timings: timings}, run_us) do
+    slowest_tests =
+      timings
+      |> Enum.sort_by(fn %{time: time} -> -time end)
+      |> Enum.take(slowest)
+
+    slowest_us = Enum.reduce(slowest_tests, 0, &(&1.time + &2))
+    slowest_time = slowest_us |> normalize_us() |> format_us()
+    percentage = Float.round(slowest_us / run_us * 100, 1)
+
+    [
+      "\nTop #{slowest} slowest (#{slowest_time}s), #{percentage}% of total time:\n\n"
+      | Enum.map(slowest_tests, &format_slow_test/1)
+    ]
+  end
+
+  defp format_slowest_modules(%{slowest_modules: slowest, test_timings: timings}, run_us) do
+    slowest_tests =
+      timings
+      |> Enum.group_by(
+        fn %{module: module, tags: tags} ->
+          {module, tags.file}
+        end,
+        fn %{time: time} -> time end
+      )
+      |> Enum.into([], fn {{module, trace_test_file_line}, timings} ->
+        {module, trace_test_file_line, Enum.sum(timings)}
+      end)
+      |> Enum.sort_by(fn {_module, _, sum_timings} -> sum_timings end, :desc)
+      |> Enum.take(slowest)
+
+    slowest_us =
+      Enum.reduce(slowest_tests, 0, fn {_module, _, sum_timings}, acc ->
+        acc + sum_timings
+      end)
+
+    slowest_time = slowest_us |> normalize_us() |> format_us()
+    percentage = Float.round(slowest_us / run_us * 100, 1)
+
+    [
+      "\nTop #{slowest} slowest (#{slowest_time}s), #{percentage}% of total time:\n\n"
+      | Enum.map(slowest_tests, &format_slow_module/1)
+    ]
+  end
 
-  defp print_suite(config, run_us, load_us) do
-    IO.write "\n\n"
-    IO.puts format_time(run_us, load_us)
+  defp format_slow_test(%ExUnit.Test{time: time, module: module} = test) do
+    "#{trace_test_started(test)} (#{inspect(module)}) (#{format_us(time)}ms) " <>
+      "[#{trace_test_file_line(test)}]\n"
+  end
 
-    message = "#{config.tests_counter} tests, #{config.failures_counter} failures"
+  defp format_slow_module({module, test_file_path, timings}) do
+    "#{inspect(module)} (#{format_us(timings)}ms)\n [#{Path.relative_to_cwd(test_file_path)}]\n"
+  end
 
-    if config.invalids_counter > 0 do
-      message = message <>  ", #{config.invalids_counter} invalid"
+  defp update_test_timings(
+         %{slowest: slowest, slowest_modules: slowest_modules} = config,
+         %ExUnit.Test{} = test
+       ) do
+    if slowest > 0 or slowest_modules > 0 do
+      # Do not store logs, as they are not used for timings and consume memory.
+      update_in(config.test_timings, &[%{test | logs: ""} | &1])
+    else
+      config
     end
+  end
+
+  ## Printing
+
+  defp print_summary(config, force_failures?) do
+    test_type_counts = collect_test_type_counts(config)
+    test_counter = test_counter_or_default(config, test_type_counts)
+    formatted_test_type_counts = format_test_type_counts(test_counter)
+    failure_pl = pluralize(config.failure_counter, "failure", "failures")
+
+    message =
+      "#{formatted_test_type_counts}#{config.failure_counter} #{failure_pl}"
+      |> if_true(
+        config.invalid_counter > 0,
+        &(&1 <> ", #{config.invalid_counter} invalid")
+      )
+      |> if_true(
+        config.skipped_counter > 0,
+        &(&1 <> ", " <> skipped("#{config.skipped_counter} skipped", config))
+      )
+      |> if_true(
+        config.excluded_counter > 0,
+        &(&1 <> " (#{config.excluded_counter} excluded)")
+      )
 
     cond do
-      config.failures_counter > 0 -> IO.puts failure(message, config)
-      config.invalids_counter > 0 -> IO.puts invalid(message, config)
-      true                        -> IO.puts success(message, config)
-    end
+      config.failure_counter > 0 or force_failures? ->
+        IO.puts(failure(message, config))
 
-    IO.puts "\nRandomized with seed #{config.seed}"
-  end
+      config.invalid_counter > 0 ->
+        IO.puts(invalid(message, config))
 
-  defp print_filters([include: [], exclude: []]) do
-    :ok
+      test_type_counts > 0 && config.excluded_counter == test_type_counts ->
+        IO.puts(invalid(message, config))
+
+      true ->
+        IO.puts(success(message, config))
+    end
   end
 
-  defp print_filters([include: include, exclude: exclude]) do
-    if include != [], do: IO.puts format_filters(include, :include)
-    if exclude != [], do: IO.puts format_filters(exclude, :exclude)
-    IO.puts("")
-    :ok
+  defp if_true(value, false, _fun), do: value
+  defp if_true(value, true, fun), do: fun.(value)
+
+  defp print_filters(opts, key) do
+    case opts[key] do
+      [] -> :ok
+      filters -> IO.puts(format_filters(filters, key))
+    end
   end
 
   defp print_failure(formatted, config) do
     cond do
-      config.trace -> IO.puts ""
-      true -> IO.puts "\n"
+      config.trace -> IO.puts("")
+      true -> IO.puts("\n")
     end
-    IO.puts formatted
+
+    IO.puts(formatted)
+  end
+
+  defp format_test_type_counts(test_counter) do
+    test_counter
+    |> Enum.sort()
+    |> Enum.map(fn {test_type, count} ->
+      type_pluralized = pluralize(count, test_type, ExUnit.plural_rule(test_type |> to_string()))
+
+      "#{count} #{type_pluralized}, "
+    end)
+  end
+
+  defp test_counter_or_default(_config, 0) do
+    %{test: 0}
+  end
+
+  defp test_counter_or_default(%{test_counter: test_counter} = _config, _test_type_counts) do
+    test_counter
+  end
+
+  defp collect_test_type_counts(%{test_counter: test_counter} = _config) do
+    Enum.reduce(test_counter, 0, fn {_, count}, acc ->
+      acc + count
+    end)
   end
 
   # Color styles
 
-  defp colorize(escape, string, %{color: color}) do
-    IO.ANSI.escape_fragment("%{#{escape}}", color)
-      <> string
-      <> IO.ANSI.escape_fragment("%{reset}", color)
+  defp colorize(key, string, %{colors: colors}) do
+    if escape = colors[:enabled] && colors[key] do
+      [escape, string, :reset]
+      |> IO.ANSI.format_fragment(true)
+      |> IO.iodata_to_binary()
+    else
+      string
+    end
+  end
+
+  defp colorize_doc(escape, doc, %{colors: colors}) do
+    if colors[:enabled] do
+      Inspect.Algebra.color_doc(doc, escape, %Inspect.Opts{syntax_colors: colors})
+    else
+      doc
+    end
   end
 
   defp success(msg, config) do
-    colorize("green", msg, config)
+    colorize(:success, msg, config)
   end
 
   defp invalid(msg, config) do
-    colorize("yellow", msg, config)
+    colorize(:invalid, msg, config)
+  end
+
+  defp skipped(msg, config) do
+    colorize(:skipped, msg, config)
   end
 
   defp failure(msg, config) do
-    colorize("red", msg, config)
+    colorize(:failure, msg, config)
+  end
+
+  defp extra_info(msg, config) do
+    colorize(:extra_info, msg, config)
+  end
+
+  # Diff formatting
+
+  defp formatter(:diff_enabled?, _, %{colors: colors}),
+    do: colors[:enabled]
+
+  defp formatter(:diff_delete, doc, config),
+    do: colorize_doc(:diff_delete, doc, config)
+
+  defp formatter(:diff_delete_whitespace, doc, config),
+    do: colorize_doc(:diff_delete_whitespace, doc, config)
+
+  defp formatter(:diff_insert, doc, config),
+    do: colorize_doc(:diff_insert, doc, config)
+
+  defp formatter(:diff_insert_whitespace, doc, config),
+    do: colorize_doc(:diff_insert_whitespace, doc, config)
+
+  defp formatter(:blame_diff, msg, %{colors: colors} = config) do
+    if colors[:enabled] do
+      colorize(:diff_delete, msg, config)
+    else
+      "-" <> msg <> "-"
+    end
   end
 
-  defp formatter(:error_info, msg, config),    do: colorize("red", msg, config)
-  defp formatter(:extra_info, msg, config),    do: colorize("cyan", msg, config)
-  defp formatter(:location_info, msg, config), do: colorize("bright,black", msg, config)
-  defp formatter(_,  msg, _config),            do: msg
+  defp formatter(key, msg, config), do: colorize(key, msg, config)
+
+  defp pluralize(1, singular, _plural), do: singular
+  defp pluralize(_, _singular, plural), do: plural
 
   defp get_terminal_width do
-    case :io.columns do
+    case :io.columns() do
       {:ok, width} -> max(40, width)
       _ -> 80
     end
   end
+
+  @default_colors [
+    diff_delete: :red,
+    diff_delete_whitespace: IO.ANSI.color_background(2, 0, 0),
+    diff_insert: :green,
+    diff_insert_whitespace: IO.ANSI.color_background(0, 2, 0),
+
+    # CLI formatter
+    success: :green,
+    invalid: :yellow,
+    skipped: :yellow,
+    failure: :red,
+    error_info: :red,
+    extra_info: :cyan,
+    location_info: [:bright, :black]
+  ]
+
+  defp colors(opts) do
+    @default_colors
+    |> Keyword.merge(opts[:colors])
+    |> Keyword.put_new(:enabled, IO.ANSI.enabled?())
+  end
+
+  defp print_logs(""), do: nil
+
+  defp print_logs(output) do
+    indent = "\n     "
+    output = String.replace(output, "\n", indent)
+    IO.puts(["     The following output was logged:", indent | output])
+  end
 end
diff --git a/lib/ex_unit/lib/ex_unit/diff.ex b/lib/ex_unit/lib/ex_unit/diff.ex
new file mode 100644
index 00000000000..b2c9604f16a
--- /dev/null
+++ b/lib/ex_unit/lib/ex_unit/diff.ex
@@ -0,0 +1,1235 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule ExUnit.Diff do
+  @moduledoc false
+
+  # A Diff struct and functions.
+  #
+  # The Diff struct contains the fields `:equivalent?`, `:left`, `:right`.
+  # The `:equivalent?` field represents if the `:left` and `:right` side are
+  # equivalents and contain no diffs. The `:left` and `:right` represent the
+  # sides of the comparison as ASTs.
+  #
+  # The ASTs may be wrapped in blocks with two special metas:
+  #
+  #   * `:diff` - when `true`, the AST inside of it has no equivalent
+  #     on the other side and should be rendered in a different color
+  #
+  #   * `:delimiter` - that particular block should be rendered with
+  #     a delimiter
+  #
+  # Given blocks are do not appear on the left side or right, it is
+  # safe to perform such wrapping.
+
+  alias Inspect.Algebra
+
+  defstruct equivalent?: true,
+            left: nil,
+            right: nil
+
+  @doc """
+  Returns the diff between `left` and `right` and env after the comparison.
+
+  The `left` side can be a literal or an AST, the `right` should always be a
+  value. The `context` should be `{:match, pins}` for pattern matching and
+  `==` and `===` for comparison cases.
+  """
+  def compute(left, right, context) do
+    diff(left, right, context_to_env(context))
+  end
+
+  defp context_to_env({:match, pins}),
+    do: %{pins: Map.new(pins), context: :match, current_vars: %{}, hints: []}
+
+  defp context_to_env(op) when op in [:==, :===],
+    do: %{pins: %{}, context: op, current_vars: %{}, hints: []}
+
+  # Main entry point for recursive diff
+
+  defp diff(left, right, %{context: :match} = env) do
+    case left do
+      {_, [original: original] ++ _, _} ->
+        diff_quoted(original, right, left, env)
+
+      _ ->
+        diff_quoted(left, right, nil, env)
+    end
+  end
+
+  defp diff(left, right, env), do: diff_value(left, right, env)
+
+  # diff quoted
+
+  defp diff_quoted({:_, _, context} = left, right, _expanded, env) when is_atom(context) do
+    diff_right = escape(right)
+    diff = %__MODULE__{equivalent?: true, left: left, right: diff_right}
+    {diff, env}
+  end
+
+  defp diff_quoted({:^, _, [{name, _, context}]} = left, right, _expanded, env)
+       when is_atom(name) and is_atom(context) do
+    diff_pin(left, right, env)
+  end
+
+  defp diff_quoted({name, _, context} = left, right, _expanded, env)
+       when is_atom(name) and is_atom(context) and
+              name not in [:__MODULE__, :__DIR__, :__STACKTRACE__, :__ENV__, :__CALLER__] do
+    diff_var(left, right, env)
+  end
+
+  defp diff_quoted({:-, _, [number]}, right, _expanded, env) when is_number(number) do
+    diff_quoted(-number, right, nil, env)
+  end
+
+  defp diff_quoted({:+, _, [number]}, right, _expanded, env) when is_number(number) do
+    diff_quoted(number, right, nil, env)
+  end
+
+  defp diff_quoted({:++, meta, [prefix, suffix]}, right, _expanded, env) when is_list(right) do
+    diff_maybe_improper_list({:++, meta, [prefix, suffix]}, right, env)
+  end
+
+  defp diff_quoted({:{}, _, left}, right, _expanded, env) when is_tuple(right) do
+    diff_tuple(left, Tuple.to_list(right), env)
+  end
+
+  defp diff_quoted({_, _} = left, right, _expanded, env) when is_tuple(right) do
+    diff_tuple(Tuple.to_list(left), Tuple.to_list(right), env)
+  end
+
+  defp diff_quoted({:%, _, [struct, {:%{}, _, kw}]}, %{} = right, _expanded, env)
+       when is_list(kw) do
+    diff_quoted_struct([__struct__: struct] ++ kw, right, env)
+  end
+
+  defp diff_quoted({:%{}, _, kw}, %{} = right, _expanded, env) when is_list(kw) do
+    diff_quoted_struct(kw, right, env)
+  end
+
+  defp diff_quoted({:<>, _, [literal, _]} = left, right, _expanded, env)
+       when is_binary(literal) and is_binary(right) do
+    diff_string_concat(left, right, env)
+  end
+
+  defp diff_quoted({:when, _, [_, _]} = left, right, _expanded, env) do
+    diff_guard(left, right, env)
+  end
+
+  defp diff_quoted({_, _, _} = left, right, expanded, env) when expanded != nil do
+    expanded = Macro.update_meta(expanded, &Keyword.delete(&1, :original))
+    {diff, post_env} = diff(expanded, right, env)
+    diff_left = update_diff_meta(left, !diff.equivalent?)
+    {%{diff | left: diff_left}, post_env}
+  end
+
+  defp diff_quoted(left, right, _expanded, env) when is_list(left) and is_list(right) do
+    diff_maybe_list(left, right, env)
+  end
+
+  defp diff_quoted(left, right, _expanded, env)
+       when is_atom(left) or is_number(left) or is_reference(left) or
+              is_pid(left) or is_function(left) or is_binary(left) do
+    diff_value(left, right, env)
+  end
+
+  defp diff_quoted(left, right, _expanded, %{context: :match} = env) do
+    diff_left = update_diff_meta(left, true)
+    diff_right = escape(right) |> update_diff_meta(true)
+    diff = %__MODULE__{equivalent?: false, left: diff_left, right: diff_right}
+    {diff, env}
+  end
+
+  ## diff_value
+
+  defp diff_value(literal, literal, env)
+       when is_atom(literal) or is_number(literal) or is_reference(literal) or
+              is_pid(literal) or is_function(literal) do
+    {%__MODULE__{equivalent?: true, left: literal, right: literal}, env}
+  end
+
+  defp diff_value(left, right, %{context: :==} = env) when left == right and is_number(left) do
+    {%__MODULE__{equivalent?: true, left: left, right: right}, env}
+  end
+
+  defp diff_value(left, right, env) when is_number(left) and is_number(right) do
+    diff_number(left, right, env)
+  end
+
+  defp diff_value(left, right, env) when is_list(left) and is_list(right) do
+    diff_maybe_list(left, right, env)
+  end
+
+  defp diff_value(left, right, env) when is_tuple(left) and is_tuple(right) do
+    diff_tuple(Tuple.to_list(left), Tuple.to_list(right), env)
+  end
+
+  defp diff_value(%left_struct{} = left, %right_struct{} = right, env) do
+    diff_struct(
+      left,
+      Map.to_list(left),
+      right,
+      left_struct,
+      right_struct,
+      env
+    )
+  end
+
+  defp diff_value(%{} = left, %{} = right, env) do
+    diff_map(Map.to_list(left), right, maybe_struct(left), maybe_struct(right), env)
+  end
+
+  defp diff_value(left, right, env) when is_binary(left) and is_binary(right) do
+    diff_string(left, right, ?", env)
+  end
+
+  defp diff_value(left, right, env) when is_function(left) and is_function(right) do
+    # If they are local functions in the same module and same name,
+    # then they have different environment, which we compare.
+    if Function.info(left, :type) == {:type, :local} and
+         Function.info(right, :type) == {:type, :local} and
+         Function.info(left, :module) == Function.info(right, :module) and
+         Function.info(left, :new_uniq) == Function.info(right, :new_uniq) and
+         Function.info(left, :new_index) == Function.info(right, :new_index) do
+      {:env, left_env} = Function.info(left, :env)
+      {:env, right_env} = Function.info(right, :env)
+      {diff, env} = diff_maybe_improper_list(left_env, right_env, env)
+
+      diff = %{
+        diff
+        | left: %{custom: &function_env_to_algebra(left, diff.left, &1)},
+          right: %{custom: &function_env_to_algebra(right, diff.right, &1)}
+      }
+
+      {diff, env}
+    else
+      non_recursive_diff_value(left, right, env)
+    end
+  end
+
+  defp diff_value(left, right, env) do
+    non_recursive_diff_value(left, right, env)
+  end
+
+  defp non_recursive_diff_value(left, right, env) do
+    diff_left = escape(left) |> update_diff_meta(true)
+    diff_right = escape(right) |> update_diff_meta(true)
+    diff = %__MODULE__{equivalent?: false, left: diff_left, right: diff_right}
+    {diff, env}
+  end
+
+  # Guards
+
+  defp diff_guard({:when, _, [expression, clause]}, right, env) do
+    {diff, post_env} = diff_quoted(expression, right, nil, env)
+
+    {guard_clause, guard_equivalent?} =
+      if diff.equivalent? do
+        bindings = Map.merge(post_env.pins, post_env.current_vars)
+        diff_guard_clause(clause, bindings)
+      else
+        {clause, false}
+      end
+
+    diff = %{
+      diff
+      | left: {:when, [], [diff.left, guard_clause]},
+        equivalent?: guard_equivalent?
+    }
+
+    {diff, post_env}
+  end
+
+  defp diff_guard_clause(quoted, bindings) do
+    case original_or_current(quoted) do
+      {op, _, [clause1, clause2]} when op in [:and, :or, :when] ->
+        {diff_clause1, clause1_equivalent?} = diff_guard_clause(clause1, bindings)
+        {diff_clause2, clause2_equivalent?} = diff_guard_clause(clause2, bindings)
+
+        equivalent? =
+          case op do
+            :and -> clause1_equivalent? and clause2_equivalent?
+            _other -> clause1_equivalent? or clause2_equivalent?
+          end
+
+        diff = {op, [], [diff_clause1, diff_clause2]}
+        {diff, equivalent?}
+
+      _ ->
+        {original, valid?} =
+          Macro.postwalk(quoted, true, fn
+            {_, [original: original] ++ _, _}, valid? ->
+              {original, valid?}
+
+            {var, _, context} = expr, valid? when is_atom(var) and is_atom(context) ->
+              if Map.has_key?(bindings, var_context(expr)) do
+                {expr, valid?}
+              else
+                {expr, false}
+              end
+
+            other, valid? ->
+              {other, valid?}
+          end)
+
+        if valid? do
+          {equivalent?, _bindings} = Code.eval_quoted(quoted, Map.to_list(bindings))
+          {update_diff_meta(original, equivalent? != true), equivalent? == true}
+        else
+          {original, false}
+        end
+    end
+  end
+
+  defp original_or_current({_, [original: original] ++ _, _}), do: original
+  defp original_or_current(current), do: current
+
+  # Pins
+
+  defp diff_pin({:^, _, [var]} = pin, right, %{pins: pins} = env) do
+    identifier = var_context(var)
+    %{^identifier => pin_value} = pins
+    {diff, post_env} = diff_value(pin_value, right, %{env | context: :===})
+
+    diff_left = update_diff_meta(pin, not diff.equivalent?)
+    {%{diff | left: diff_left}, %{post_env | context: :match}}
+  end
+
+  # Vars
+
+  defp diff_var(left, right, env) do
+    identifier = var_context(left)
+
+    case env.current_vars do
+      %{^identifier => ^right} ->
+        diff_right = escape(right)
+        diff = %__MODULE__{equivalent?: true, left: left, right: diff_right}
+        {diff, env}
+
+      %{^identifier => _} ->
+        diff_left = update_diff_meta(left, true)
+        diff_right = escape(right) |> update_diff_meta(true)
+        diff = %__MODULE__{equivalent?: false, left: diff_left, right: diff_right}
+        {diff, env}
+
+      current_vars = %{} ->
+        updated_vars = Map.put(current_vars, identifier, right)
+        diff_right = escape(right)
+        diff = %__MODULE__{equivalent?: true, left: left, right: diff_right}
+        {diff, %{env | current_vars: updated_vars}}
+    end
+  end
+
+  # Tuples
+
+  defp diff_tuple(list_left, list_right, env) do
+    diff_tuple(list_left, list_right, true, [], [], env)
+  end
+
+  defp diff_tuple([left | tleft], [right | tright], acc_equivalent?, acc_left, acc_right, env) do
+    {diff, env} = diff(left, right, env)
+    acc_equivalent? = acc_equivalent? and diff.equivalent?
+    acc_left = [diff.left | acc_left]
+    acc_right = [diff.right | acc_right]
+    diff_tuple(tleft, tright, acc_equivalent?, acc_left, acc_right, env)
+  end
+
+  defp diff_tuple(remaining_left, remaining_right, acc_equivalent?, acc_left, acc_right, env) do
+    remaining_left =
+      Enum.map(remaining_left, &(&1 |> maybe_escape(env) |> update_diff_meta(true)))
+
+    remaining_right = Enum.map(remaining_right, &(&1 |> escape() |> update_diff_meta(true)))
+
+    equivalent? = acc_equivalent? and remaining_left == [] and remaining_right == []
+    diff_left = {:{}, [], Enum.reverse(acc_left, remaining_left)}
+    diff_right = {:{}, [], Enum.reverse(acc_right, remaining_right)}
+    {%__MODULE__{equivalent?: equivalent?, left: diff_left, right: diff_right}, env}
+  end
+
+  # Lists
+
+  defp diff_maybe_list([], [], env) do
+    {%__MODULE__{equivalent?: true, left: [], right: []}, env}
+  end
+
+  defp diff_maybe_list(left, right, env) do
+    if List.ascii_printable?(left) and List.ascii_printable?(right) do
+      {diff, env} = diff_string(List.to_string(left), List.to_string(right), ?", env)
+
+      diff = %{
+        diff
+        | left: %{custom: &charlist_to_algebra(diff.left, &1)},
+          right: %{custom: &charlist_to_algebra(diff.right, &1)}
+      }
+
+      {diff, env}
+    else
+      diff_maybe_improper_list(left, right, env)
+    end
+  end
+
+  # Compare two lists, removing all the operators (`|` and `++`) from the left
+  # side before and adding them back in the end. Improper lists on the left side
+  # are handled as quoted expressions. Improper lists on the right side are
+  # handled as runtime improper lists.
+  defp diff_maybe_improper_list(left, right, env) do
+    {parsed_left, improper_left, operators_left, length_left} =
+      split_left_list(left, 0, env.context)
+
+    element_limit = if improper_left == [], do: -1, else: length_left
+    {parsed_right, improper_right} = split_right_list(right, element_limit, [])
+
+    {parsed_diff, parsed_post_env} = myers_difference_list(parsed_left, parsed_right, env)
+
+    {improper_diff, improper_post_env} =
+      diff_improper(improper_left, improper_right, parsed_post_env)
+
+    diff =
+      merge_diff(parsed_diff, improper_diff, fn left1, left2, right1, right2 ->
+        improper_left =
+          cond do
+            improper_left != [] -> {:improper, left2}
+            improper_right != [] -> :tail
+            true -> :nothing
+          end
+
+        left = rebuild_left_list(left1, improper_left, operators_left, env)
+        right = rebuild_right_list(right1, right2)
+        {left, right}
+      end)
+
+    {diff, improper_post_env}
+  end
+
+  defp diff_improper([], right, env) when is_list(right) do
+    equivalent? = right == []
+    right = right |> escape() |> update_diff_meta(not equivalent?)
+    {%__MODULE__{equivalent?: equivalent?, right: right, left: []}, env}
+  end
+
+  defp diff_improper(left, right, env) do
+    diff(left, right, env)
+  end
+
+  defp split_right_list([head | tail], length, acc) when length != 0,
+    do: split_right_list(tail, length - 1, [head | acc])
+
+  defp split_right_list(rest, _length, acc),
+    do: {Enum.reverse(acc), rest}
+
+  defp rebuild_right_list(left, right) do
+    left = Enum.reverse(left)
+
+    case extract_diff_meta(right) do
+      # Outer was escaped. Copy its diff? to its inner element and potentially escape it.
+      {{unescaped}, diff?} ->
+        rebuild_maybe_improper(unescaped, left, &(&1 |> escape() |> update_diff_meta(diff?)))
+
+      # We have a proper list, if there are any diffs, they will be inside, so copy as is.
+      {[_ | _] = list, false} ->
+        rebuild_maybe_improper(list, left, & &1)
+
+      # The right itself is improper, so just add it as is.
+      {_, _} ->
+        rebuild_maybe_improper(right, left, & &1)
+    end
+  end
+
+  defp rebuild_maybe_improper([head | tail], acc, fun),
+    do: rebuild_maybe_improper(tail, [fun.(head) | acc], fun)
+
+  defp rebuild_maybe_improper([], acc, _fun),
+    do: Enum.reverse(acc)
+
+  defp rebuild_maybe_improper(other, [prev | acc], fun),
+    do: Enum.reverse([{:|, [], [prev, fun.(other)]} | acc])
+
+  defp split_left_list([], _index, _context) do
+    {[], [], nil, 0}
+  end
+
+  defp split_left_list({:++, _, [left, right]}, _index, :match) do
+    {parsed_left, [], operators_left, length_left} = split_left_list(left, 0, :match)
+
+    case split_left_list(right, 0, :match) do
+      {:improper, improper} ->
+        operators = {:++, length_left, [operators_left, nil]}
+        {parsed_left, improper, operators, length_left}
+
+      {parsed_right, improper_right, operators_right, length_right} ->
+        operators = {:++, length_left, [operators_left, operators_right]}
+        length = length_right + length_left
+        {parsed_left ++ parsed_right, improper_right, operators, length}
+    end
+  end
+
+  defp split_left_list([{:|, _, [head, tail]}], index, :match) do
+    case split_left_list(tail, 0, :match) do
+      {:improper, improper} ->
+        operator = {:|, index, [nil]}
+        {[head], improper, operator, 1}
+
+      {parsed_tail, improper_tail, operators_tail, length_tail} ->
+        operators = {:|, index, [operators_tail]}
+        {[head | parsed_tail], improper_tail, operators, length_tail + 1}
+    end
+  end
+
+  defp split_left_list([head | tail], index, context) do
+    case split_left_list(tail, index + 1, context) do
+      {:improper, improper} ->
+        operator = {:|, index, [nil]}
+        {[head], improper, operator, 1}
+
+      {parsed_tail, improper_tail, operators_tail, length_tail} ->
+        {[head | parsed_tail], improper_tail, operators_tail, length_tail + 1}
+    end
+  end
+
+  defp split_left_list(element, _index, _) do
+    {:improper, element}
+  end
+
+  defp rebuild_left_list([], {:improper, improper}, _operators = nil, _env), do: improper
+  defp rebuild_left_list(list, _, _operators = nil, _env), do: list
+
+  defp rebuild_left_list(list, :tail, {:|, index, [operators]}, env) do
+    {left, [head | tail]} = Enum.split(list, index)
+    rebuilt_tail = rebuild_left_list(tail, :nothing, operators, env)
+    rebuilt_tail = rebuilt_tail |> update_diff_meta(true)
+    left ++ [{:|, [], [head, rebuilt_tail]}]
+  end
+
+  defp rebuild_left_list(list, improper, {:|, index, [operators]}, env) do
+    {left, [head | tail]} = Enum.split(list, index)
+    rebuilt_tail = rebuild_left_list(tail, improper, operators, env)
+    left ++ [{:|, [], [head, rebuilt_tail]}]
+  end
+
+  defp rebuild_left_list(list, improper, {:++, index, operators}, env) do
+    [operators_left, operators_right] = operators
+    {left, right} = Enum.split(list, index)
+
+    rebuilt_left = rebuild_left_list(left, :nothing, operators_left, env)
+    rebuilt_right = rebuild_left_list(right, improper, operators_right, env)
+
+    {:++, [], [rebuilt_left, rebuilt_right]}
+  end
+
+  defp myers_difference_list(left, right, env) do
+    path = {0, left, right, {[], [], env}}
+    find_diff(0, length(left) + length(right), [path])
+  end
+
+  defp find_diff(envelope, max, paths) do
+    case each_diagonal(-envelope, envelope, paths, []) do
+      {:done, {edit1, edit2, env}} ->
+        list_script_to_diff(Enum.reverse(edit1), Enum.reverse(edit2), true, [], [], env)
+
+      {:next, paths} ->
+        find_diff(envelope + 1, max, paths)
+    end
+  end
+
+  defp each_diagonal(diag, limit, _paths, next_paths) when diag > limit do
+    {:next, Enum.reverse(next_paths)}
+  end
+
+  defp each_diagonal(diag, limit, paths, next_paths) do
+    {path, rest} = proceed_path(diag, limit, paths)
+
+    case follow_snake(path) do
+      {:cont, path} -> each_diagonal(diag + 2, limit, rest, [path | next_paths])
+      {:done, edits} -> {:done, edits}
+    end
+  end
+
+  defp proceed_path(0, 0, [path]), do: {path, []}
+
+  defp proceed_path(diag, limit, [path | _] = paths) when diag == -limit do
+    {move_down(path), paths}
+  end
+
+  defp proceed_path(diag, limit, [path]) when diag == limit do
+    {move_right(path), []}
+  end
+
+  defp proceed_path(_diag, _limit, [path1, path2 | rest]) do
+    if elem(path1, 0) > elem(path2, 0) do
+      {move_right(path1), [path2 | rest]}
+    else
+      {move_down(path2), [path2 | rest]}
+    end
+  end
+
+  defp move_right({y, list1, [elem2 | rest2], {edit1, edit2, env}}) do
+    {y, list1, rest2, {edit1, [{:ins, elem2} | edit2], env}}
+  end
+
+  defp move_right({y, list1, [], edits}) do
+    {y, list1, [], edits}
+  end
+
+  defp move_down({y, [elem1 | rest1], list2, {edit1, edit2, env}}) do
+    {y + 1, rest1, list2, {[{:del, elem1} | edit1], edit2, env}}
+  end
+
+  defp move_down({y, [], list2, edits}) do
+    {y + 1, [], list2, edits}
+  end
+
+  defp follow_snake({y, [elem1 | rest1], [elem2 | rest2], {edit1, edit2, env}} = path) do
+    {diff, post_env} = diff(elem1, elem2, env)
+
+    if diff.equivalent? do
+      new_edit1 = [{:eq, diff.left} | edit1]
+      new_edit2 = [{:eq, diff.right} | edit2]
+
+      follow_snake({y + 1, rest1, rest2, {new_edit1, new_edit2, post_env}})
+    else
+      {:cont, path}
+    end
+  end
+
+  defp follow_snake({_y, [], [], edits}) do
+    {:done, edits}
+  end
+
+  defp follow_snake(path) do
+    {:cont, path}
+  end
+
+  defp list_script_to_diff([], [], equivalent?, left, right, env) do
+    diff = %__MODULE__{
+      equivalent?: equivalent?,
+      left: Enum.reverse(left),
+      right: Enum.reverse(right)
+    }
+
+    {diff, env}
+  end
+
+  defp list_script_to_diff(
+         [{:del, elem1} | rest1],
+         [{:ins, elem2} | rest2],
+         equivalent?,
+         left,
+         right,
+         env
+       ) do
+    {diff, env} = diff(elem1, elem2, env)
+    equivalent? = equivalent? and diff.equivalent?
+    list_script_to_diff(rest1, rest2, equivalent?, [diff.left | left], [diff.right | right], env)
+  end
+
+  defp list_script_to_diff([{:del, elem1} | rest1], rest2, _, left, right, env) do
+    diff_left = elem1 |> maybe_escape(env) |> update_diff_meta(true)
+    list_script_to_diff(rest1, rest2, false, [diff_left | left], right, env)
+  end
+
+  defp list_script_to_diff(rest1, [{:ins, elem2} | rest2], _, left, right, env) do
+    diff_right = elem2 |> escape() |> update_diff_meta(true)
+    list_script_to_diff(rest1, rest2, false, left, [diff_right | right], env)
+  end
+
+  defp list_script_to_diff(
+         [{:eq, elem1} | rest1],
+         [{:eq, elem2} | rest2],
+         equivalent?,
+         left,
+         right,
+         env
+       ) do
+    list_script_to_diff(rest1, rest2, equivalent?, [elem1 | left], [elem2 | right], env)
+  end
+
+  # Maps
+
+  # Compare items based on the keys of `left_items` and add the `:diff` meta to
+  # the element that it wasn't able to compare.
+  defp diff_map(left_items, right, struct1, struct2, env) do
+    {equivalent?, left, right, env} = diff_map_by_key(left_items, right, env)
+    left = build_map_or_struct(left, struct1)
+    right = build_map_or_struct(right, struct2)
+    {%__MODULE__{equivalent?: equivalent?, left: left, right: right}, env}
+  end
+
+  defp diff_map_by_key(items, right, env) do
+    {acc_equivalent?, acc_left, acc_right, pending_left, pending_right, env} =
+      Enum.reduce(items, {true, [], [], [], right, env}, fn
+        {left_key, left_value},
+        {acc_equivalent?, acc_left, acc_right, pending_left, pending_right, env} ->
+          right_key = literal_key(left_key, env)
+
+          case pending_right do
+            %{^right_key => right_value} ->
+              pending_right = Map.delete(pending_right, right_key)
+              {diff, env} = diff(left_value, right_value, env)
+              acc_equivalent? = acc_equivalent? and diff.equivalent?
+              acc_left = [{maybe_escape(left_key, env), diff.left} | acc_left]
+              acc_right = [{escape(right_key), diff.right} | acc_right]
+              {acc_equivalent?, acc_left, acc_right, pending_left, pending_right, env}
+
+            %{} ->
+              pair = {maybe_escape(left_key, env), maybe_escape(left_value, env)}
+              pair_diff = update_diff_meta(pair, true)
+              {false, acc_left, acc_right, [pair_diff | pending_left], pending_right, env}
+          end
+      end)
+
+    # It may be a struct, so make sure we convert it to a list before calling Enum
+    pending_right = Map.to_list(pending_right)
+
+    {pending_right, equivalent?} =
+      if env.context == :match do
+        {Enum.map(pending_right, &escape_pair/1), acc_equivalent?}
+      else
+        pending_right = Enum.map(pending_right, &(&1 |> escape_pair() |> update_diff_meta(true)))
+        {pending_right, acc_equivalent? and pending_right == []}
+      end
+
+    left = Enum.sort(acc_left) ++ Enum.sort(pending_left)
+    right = Enum.sort(acc_right) ++ Enum.sort(pending_right)
+
+    {equivalent?, left, right, env}
+  end
+
+  defp literal_key({:^, _, [var]}, %{pins: pins}) do
+    identifier = var_context(var)
+    %{^identifier => pin_value} = pins
+    pin_value
+  end
+
+  defp literal_key(literal, _env) do
+    literal
+  end
+
+  # Structs
+
+  defp diff_quoted_struct(kw, right, env) do
+    if struct = struct_module(kw) do
+      with true <- Macro.quoted_literal?(kw),
+           {eval_kw, []} <- safe_eval(kw),
+           {:ok, data} <- load_struct(struct, eval_kw) do
+        diff_quoted_struct(data, kw, right, struct, env)
+      else
+        _ -> diff_map(kw, right, struct, maybe_struct(right), env)
+      end
+    else
+      diff_map(kw, right, nil, maybe_struct(right), env)
+    end
+  end
+
+  defp diff_quoted_struct(left, kw, %struct2{} = right, struct1, env) do
+    diff_struct(left, kw, right, struct1, struct2, env)
+  end
+
+  defp diff_quoted_struct(_left, kw, right, struct1, env) do
+    diff_map(kw, right, struct1, nil, env)
+  end
+
+  defp diff_struct(left, kw, right, struct1, struct2, env) do
+    with true <- Inspect.impl_for(left) not in [Inspect.Any, Inspect.Map],
+         {:ok, inspect_left} <- safe_inspect(left),
+         {:ok, inspect_right} <- safe_inspect(right) do
+      if inspect_left != inspect_right do
+        diff_string(inspect_left, inspect_right, nil, env)
+      else
+        # If they are equivalent, still use their inspected form
+        case diff_map(kw, right, struct1, struct2, env) do
+          {%{equivalent?: true}, ctx} ->
+            {%__MODULE__{equivalent?: true, left: left, right: right}, ctx}
+
+          diff_ctx ->
+            diff_ctx
+        end
+      end
+    else
+      _ -> diff_map(kw, right, struct1, struct2, env)
+    end
+  end
+
+  defp struct_module(kw) do
+    {struct, struct_kw} = Keyword.pop(kw, :__struct__)
+
+    info =
+      is_atom(struct) and struct != nil and
+        Code.ensure_loaded?(struct) and function_exported?(struct, :__info__, 1) and
+        struct.__info__(:struct)
+
+    if info && Enum.all?(struct_kw, fn {k, _} -> Enum.any?(info, &(&1.field == k)) end) do
+      struct
+    end
+  end
+
+  defp load_struct(struct, kw) do
+    {:ok, struct!(struct, kw)}
+  rescue
+    _ -> :error
+  end
+
+  defp maybe_struct(%name{}), do: name
+  defp maybe_struct(_), do: nil
+
+  defp build_map_or_struct(items, nil) do
+    {:%{}, [], items}
+  end
+
+  defp build_map_or_struct(items, _struct) do
+    {struct, items} = pop_struct(items, [])
+    {:%, [], [struct, {:%{}, [], items}]}
+  end
+
+  defp pop_struct([{:__block__, meta, [{:__struct__, struct}]} | tail], acc),
+    do: {{:__block__, meta, [struct]}, Enum.reverse(acc, tail)}
+
+  defp pop_struct([{:__struct__, struct} | tail], acc),
+    do: {struct, Enum.reverse(acc, tail)}
+
+  defp pop_struct([head | rest], acc),
+    do: pop_struct(rest, [head | acc])
+
+  # Strings
+
+  defp diff_string(left, right, delimiter, env) do
+    {escaped_left, _} = Code.Identifier.escape(left, delimiter)
+    {escaped_right, _} = Code.Identifier.escape(right, delimiter)
+    left = IO.iodata_to_binary(escaped_left)
+    right = IO.iodata_to_binary(escaped_right)
+
+    cond do
+      left == right ->
+        {string_script_to_diff([eq: left], delimiter, true, [], []), env}
+
+      diff_string?(left, right) ->
+        diff =
+          String.myers_difference(left, right)
+          |> string_script_to_diff(delimiter, true, [], [])
+
+        env =
+          if String.equivalent?(left, right) do
+            add_hint(env, :equivalent_but_different_strings)
+          else
+            env
+          end
+
+        {diff, env}
+
+      true ->
+        {string_script_to_diff([del: left, ins: right], delimiter, true, [], []), env}
+    end
+  end
+
+  # Concat all the literals on `left` and split `right` based on the size of
+  # that, comparing them and the remaining AST from `left` and the remaining
+  # string from `right`.
+  defp diff_string_concat(left, right, env) do
+    {parsed_left, quoted, indexes, parsed_left_length} = parse_string(left)
+
+    diff_string_concat(parsed_left, quoted, indexes, parsed_left_length, right, env)
+  end
+
+  defp diff_string_concat(left, nil, indexes, _left_length, right, env) do
+    {diff, parsed_post_env} = diff_string(left, right, ?", env)
+    left_diff = rebuild_concat_string(diff.left, nil, indexes)
+
+    diff = %{diff | left: left_diff}
+    {diff, parsed_post_env}
+  end
+
+  defp diff_string_concat(left, quoted, indexes, left_length, right, env) do
+    {parsed_right, continue_right} = String.split_at(right, left_length)
+    {parsed_diff, parsed_post_env} = diff_string(left, parsed_right, ?", env)
+    {quoted_diff, quoted_post_env} = diff(quoted, continue_right, parsed_post_env)
+
+    diff =
+      merge_diff(parsed_diff, quoted_diff, fn left1, left2, right1, right2 ->
+        new_left = rebuild_concat_string(left1, left2, indexes)
+        new_right = rebuild_split_strings(right1, right2)
+        {new_left, new_right}
+      end)
+
+    {diff, quoted_post_env}
+  end
+
+  defp diff_string?(left, right) do
+    String.bag_distance(left, right) > 0.4
+  end
+
+  defp parse_string({:<>, _, [literal, rest]}) when is_binary(literal) do
+    {parsed, quoted, indexes, parsed_length} = parse_string(rest)
+    literal_length = String.length(literal)
+    length = literal_length + parsed_length
+    {literal <> parsed, quoted, [literal_length | indexes], length}
+  end
+
+  defp parse_string(literal) when is_binary(literal) do
+    {literal, nil, [], String.length(literal)}
+  end
+
+  defp parse_string(pattern) do
+    {"", pattern, [], 0}
+  end
+
+  defp rebuild_split_strings(left, "") do
+    left
+  end
+
+  defp rebuild_split_strings(
+         %{contents: left, delimiter: delimiter},
+         %{contents: right, delimiter: delimiter}
+       ) do
+    %{contents: left ++ right, delimiter: delimiter}
+  end
+
+  defp rebuild_split_strings(%{contents: contents, delimiter: delimiter}, right) do
+    {new_right, diff} = extract_diff_meta(right)
+    %{contents: contents ++ [{diff, new_right}], delimiter: delimiter}
+  end
+
+  defp rebuild_concat_string(literal, nil, []) do
+    literal
+  end
+
+  defp rebuild_concat_string(_literal, quoted, []) do
+    quoted
+  end
+
+  defp rebuild_concat_string(literal, quoted, [index | rest]) do
+    {next, continue} = next_concat_result(literal, index)
+    rebuilt_right = rebuild_concat_string(continue, quoted, rest)
+    {:<>, [], [next, rebuilt_right]}
+  end
+
+  defp next_concat_result(%{contents: contents, delimiter: delimiter}, index) do
+    {next, continue} = next_concat_result(contents, index)
+    {%{contents: next, delimiter: delimiter}, %{contents: continue, delimiter: delimiter}}
+  end
+
+  defp next_concat_result([{diff?, head} | tail], index) do
+    length = String.length(head)
+
+    cond do
+      length > index ->
+        {next, continue} = String.split_at(head, index)
+        {[{diff?, next}], [{diff?, continue} | tail]}
+
+      length < index ->
+        {next, continue} = next_concat_result(tail, index - length)
+        {[{diff?, head} | next], continue}
+
+      true ->
+        {[{diff?, head}], tail}
+    end
+  end
+
+  defp string_script_to_diff([], delimiter, equivalent?, left, right) do
+    left = %{delimiter: delimiter, contents: Enum.reverse(left)}
+    right = %{delimiter: delimiter, contents: Enum.reverse(right)}
+    %__MODULE__{equivalent?: equivalent?, left: left, right: right}
+  end
+
+  defp string_script_to_diff([{:eq, string} | tail], delimiter, equivalent?, left, right) do
+    string_script_to_diff(
+      tail,
+      delimiter,
+      equivalent?,
+      [{false, string} | left],
+      [{false, string} | right]
+    )
+  end
+
+  defp string_script_to_diff([{:del, string} | tail], delimiter, _equivalent?, left, right) do
+    string_script_to_diff(tail, delimiter, false, [{true, string} | left], right)
+  end
+
+  defp string_script_to_diff([{:ins, string} | tail], delimiter, _equivalent?, left, right) do
+    string_script_to_diff(tail, delimiter, false, left, [{true, string} | right])
+  end
+
+  # Numbers
+
+  defp diff_number(left, right, env) do
+    diff_string(inspect(left), inspect(right), nil, env)
+  end
+
+  # Algebra
+
+  @doc """
+  Converts a diff to an algebra document.
+  """
+  def to_algebra(quoted, diff_wrapper) do
+    wrap_on_diff(quoted, &safe_to_algebra/2, diff_wrapper)
+  end
+
+  defp safe_to_algebra(list, diff_wrapper) when is_list(list) do
+    container_to_algebra("[", list, "]", diff_wrapper, select_list_item_algebra(list))
+  end
+
+  defp safe_to_algebra({op, _, [left, right]}, diff_wrapper)
+       when op in [:<>, :++, :|, :when, :and, :or] do
+    to_algebra(left, diff_wrapper)
+    |> Algebra.concat(" #{op} ")
+    |> Algebra.concat(to_algebra(right, diff_wrapper))
+  end
+
+  defp safe_to_algebra({:{}, _, args}, diff_wrapper) do
+    container_to_algebra("{", args, "}", diff_wrapper, &to_algebra/2)
+  end
+
+  defp safe_to_algebra({a, b}, diff_wrapper) do
+    container_to_algebra("{", [a, b], "}", diff_wrapper, &to_algebra/2)
+  end
+
+  defp safe_to_algebra({:%, _, [{:_, _, _}, {:%{}, _, list}]}, diff_wrapper) do
+    open = Algebra.concat(["%", "_", "{"])
+    container_to_algebra(open, list, "}", diff_wrapper, select_map_item_to_algebra(list))
+  end
+
+  defp safe_to_algebra({:%, _, [struct, {:%{}, _, list}]}, diff_wrapper) do
+    open = Algebra.concat(["%", struct_to_algebra(struct, diff_wrapper), "{"])
+    container_to_algebra(open, list, "}", diff_wrapper, select_map_item_to_algebra(list))
+  end
+
+  defp safe_to_algebra({:%{}, _, list}, diff_wrapper) do
+    container_to_algebra("%{", list, "}", diff_wrapper, select_map_item_to_algebra(list))
+  end
+
+  defp safe_to_algebra({_, meta, args} = quoted, _diff_wrapper)
+       when is_list(meta) and (is_list(args) or is_atom(args)) do
+    Macro.to_string(quoted)
+  end
+
+  defp safe_to_algebra({escaped}, _diff_wrapper) do
+    inspect(escaped)
+  end
+
+  # Custom encoding for delimiters+contents
+  defp safe_to_algebra(%{delimiter: delimiter, contents: contents}, diff_wrapper) do
+    content_docs =
+      for {diff?, content} <- contents do
+        if diff?, do: diff_wrapper.(content), else: content
+      end
+
+    if delimiter do
+      delimiter = List.to_string([delimiter])
+      Algebra.concat([delimiter, Algebra.concat(content_docs), delimiter])
+    else
+      Algebra.concat(content_docs)
+    end
+  end
+
+  # Custom encoding for functions
+  defp safe_to_algebra(%{custom: literal}, diff_wrapper) do
+    literal.(diff_wrapper)
+  end
+
+  defp safe_to_algebra(literal, _diff_wrapper) do
+    inspect(literal)
+  end
+
+  defp keyword_to_algebra(quoted, diff_wrapper) do
+    wrap_on_diff(quoted, &safe_keyword_to_algebra/2, diff_wrapper)
+  end
+
+  defp safe_keyword_to_algebra({:{}, _, [key, value]}, diff_wrapper) do
+    keyword_to_algebra({key, value}, diff_wrapper)
+  end
+
+  defp safe_keyword_to_algebra({key, value}, diff_wrapper) do
+    key_to_algebra(key, diff_wrapper)
+    |> Algebra.concat(" ")
+    |> Algebra.concat(to_algebra(value, diff_wrapper))
+  end
+
+  defp key_to_algebra(quoted, diff_wrapper) do
+    wrap_on_diff(quoted, &safe_key_to_algebra/2, diff_wrapper)
+  end
+
+  defp safe_key_to_algebra(key, _diff_wrapper) do
+    Macro.inspect_atom(:key, key)
+  end
+
+  defp map_item_to_algebra(quoted, diff_wrapper) do
+    wrap_on_diff(quoted, &safe_map_item_to_algebra/2, diff_wrapper)
+  end
+
+  defp safe_map_item_to_algebra({:{}, _, [key, value]}, diff_wrapper) do
+    safe_map_item_to_algebra({key, value}, diff_wrapper)
+  end
+
+  defp safe_map_item_to_algebra({key, value}, diff_wrapper) do
+    to_algebra(key, diff_wrapper)
+    |> Algebra.concat(" => ")
+    |> Algebra.concat(to_algebra(value, diff_wrapper))
+  end
+
+  defp container_to_algebra(open, list, close, diff_wrapper, item_to_algebra) do
+    docs =
+      list
+      |> Enum.map(&item_to_algebra.(&1, diff_wrapper))
+      |> Algebra.fold(&join_docs/2)
+
+    open
+    |> Algebra.glue("", docs)
+    |> Algebra.nest(2)
+    |> Algebra.glue("", close)
+    |> Algebra.group()
+  end
+
+  defp join_docs(doc1, doc2) do
+    doc1
+    |> Algebra.concat(",")
+    |> Algebra.glue(doc2)
+  end
+
+  defp struct_to_algebra(quoted, diff_wrapper) do
+    wrap_on_diff(quoted, &safe_struct_to_algebra/2, diff_wrapper)
+  end
+
+  defp safe_struct_to_algebra({:^, _, _} = name, _diff_wrapper) do
+    Macro.to_string(name)
+  end
+
+  defp safe_struct_to_algebra(name, _diff_wrapper) do
+    Macro.inspect_atom(:literal, name)
+  end
+
+  defp select_list_item_algebra(list) do
+    short? = Enum.all?(list, &keyword?/1)
+    if short?, do: &keyword_to_algebra/2, else: &to_algebra/2
+  end
+
+  defp select_map_item_to_algebra(list) do
+    short? = Enum.all?(list, &keyword?/1)
+    if short?, do: &keyword_to_algebra/2, else: &map_item_to_algebra/2
+  end
+
+  defp wrap_on_diff(quoted, fun, wrapper) do
+    case extract_diff_meta(quoted) do
+      {expr, true} -> fun.(expr, & &1) |> wrapper.()
+      {expr, false} -> fun.(expr, wrapper)
+    end
+  end
+
+  defp charlist_to_algebra(%{contents: contents}, diff_wrapper) do
+    content_doc =
+      for {diff, content} <- contents do
+        if diff, do: diff_wrapper.(content), else: content
+      end
+
+    Algebra.concat(["~c\"", Algebra.concat(content_doc), "\""])
+  end
+
+  defp function_env_to_algebra(function, ast, diff_wrapper) do
+    "#Function<" <> contents = inspect(function)
+
+    Algebra.concat([
+      "#Function<",
+      Algebra.nest(
+        Algebra.concat([
+          Algebra.line(),
+          binary_slice(contents, 0..-2//1),
+          Algebra.line(),
+          to_algebra(ast, diff_wrapper)
+        ]),
+        2
+      ),
+      Algebra.line(),
+      ">"
+    ])
+  end
+
+  # Diff helpers
+
+  defp add_hint(%{hints: hints} = env, hint) do
+    if hint in hints, do: env, else: %{env | hints: [hint | hints]}
+  end
+
+  defp maybe_escape(other, %{context: :match}), do: other
+  defp maybe_escape(other, _env), do: escape(other)
+
+  # We escape container types to make a distinction between AST and values that
+  # should be inspected. Maps and structs without custom inspect implementation
+  # should not be inspected, convert it to ast.
+  # All other values have no special AST representation, so we can keep them as is.
+  defp escape(other) when is_map(other) do
+    struct = maybe_struct(other)
+
+    if struct && Inspect.impl_for(other) not in [Inspect.Any, Inspect.Map] do
+      other
+    else
+      other
+      |> Map.to_list()
+      |> Enum.sort()
+      |> Enum.map(&escape_pair/1)
+      |> build_map_or_struct(struct)
+    end
+  end
+
+  defp escape(other) when is_list(other) or is_tuple(other), do: {other}
+  defp escape(other), do: other
+
+  defp escape_pair({key, value}), do: {escape(key), escape(value)}
+
+  defp merge_diff(%__MODULE__{} = result1, %__MODULE__{} = result2, fun) do
+    {left, right} = fun.(result1.left, result2.left, result1.right, result2.right)
+
+    %__MODULE__{
+      equivalent?: result1.equivalent? && result2.equivalent?,
+      left: left,
+      right: right
+    }
+  end
+
+  defp update_diff_meta({left, meta, right}, false) when is_list(meta),
+    do: {left, Keyword.delete(meta, :diff), right}
+
+  defp update_diff_meta({left, meta, right}, true) when is_list(meta),
+    do: {left, Keyword.put(meta, :diff, true), right}
+
+  defp update_diff_meta(literal, false),
+    do: literal
+
+  defp update_diff_meta(literal, true),
+    do: {:__block__, [diff: true], [literal]}
+
+  defp extract_diff_meta({:__block__, [diff: true], [literal]}),
+    do: {literal, true}
+
+  defp extract_diff_meta({left, meta, right}) when is_list(meta),
+    do: {{left, meta, right}, !!meta[:diff]}
+
+  defp extract_diff_meta(other), do: {other, false}
+
+  defp keyword?(quoted) do
+    {pair, _} = extract_diff_meta(quoted)
+    safe_keyword?(pair)
+  end
+
+  defp safe_keyword?({key, _value}), do: key_is_atom?(key)
+  defp safe_keyword?({:{}, _meta, [key, _value]}), do: key_is_atom?(key)
+  defp safe_keyword?(_other), do: false
+
+  defp key_is_atom?(quoted) do
+    {key, _} = extract_diff_meta(quoted)
+    is_atom(key)
+  end
+
+  defp var_context({name, meta, context}) do
+    {name, meta[:counter] || context}
+  end
+
+  defp safe_eval(expr) do
+    Code.eval_quoted(expr, [])
+  rescue
+    _ -> :error
+  end
+
+  defp safe_inspect(value) do
+    {:ok, inspect(value, safe: false)}
+  rescue
+    _ -> :error
+  end
+end
diff --git a/lib/ex_unit/lib/ex_unit/doc_test.ex b/lib/ex_unit/lib/ex_unit/doc_test.ex
index 7b336b4c035..57255cfd35c 100644
--- a/lib/ex_unit/lib/ex_unit/doc_test.ex
+++ b/lib/ex_unit/lib/ex_unit/doc_test.ex
@@ -1,48 +1,50 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.DocTest do
-  @moduledoc """
-  ExUnit.DocTest implements functionality similar to [Python's
-  doctest](http://docs.python.org/2/library/doctest.html).
+  @moduledoc ~S"""
+  Extract test cases from the documentation.
+
+  Doctests allow us to generate tests from code examples found
+  in `@moduledoc` and `@doc` attributes. To do this, invoke the
+  `doctest/1` macro from within your test case and ensure your
+  code examples are written according to the syntax and guidelines
+  below.
 
-  In a nutshell, it allows us to generate tests from the code
-  examples existing in a module/function/macro's documentation.
-  In order to do that, one needs to invoke the `doctest/1` macro
-  from their test case and write their examples according
-  to some guidelines.
+  ## Syntax
 
-  The syntax for examples is as follows. Every new test starts
-  on a new line, with an `iex>` prefix. Multiline expressions
-  can be employed if the following lines start with either
-  `...>` (recommended) or `iex>` prefix.
+  Every new test starts on a new line, with an `iex>` prefix.
+  Multiline expressions can be used by prefixing subsequent lines
+  with either `...>` (recommended) or `iex>`.
 
-  The expected result should start at the next line after `iex>`
-  or `...>` line(s) and is terminated either by a newline, new
-  `iex>` prefix or end of the string literal.
+  The expected result should start the line after the `iex>`
+  and `...>` line(s) and be terminated by a newline.
 
   ## Examples
 
-  Currently, the only way to run doctests is to include them into
-  an ExUnit case with a `doctest` macro:
+  To run doctests include them in an ExUnit case with a `doctest` macro:
 
-      defmodule MyModule.Test do
+      defmodule MyModuleTest do
         use ExUnit.Case, async: true
         doctest MyModule
       end
 
-  The `doctest` macro is going to loop through all functions and
+  The `doctest` macro loops through all functions and
   macros defined in `MyModule`, parsing their documentation in
   search of code examples.
 
   A very basic example is:
 
-      iex> 1+1
+      iex> 1 + 1
       2
 
   Expressions on multiple lines are also supported:
 
-      iex> Enum.map [1, 2, 3], fn(x) ->
+      iex> Enum.map([1, 2, 3], fn x ->
       ...>   x * 2
-      ...> end
-      [2,4,6]
+      ...> end)
+      [2, 4, 6]
 
   Multiple results can be checked within the same test:
 
@@ -57,49 +59,104 @@ defmodule ExUnit.DocTest do
       iex> a = 1
       1
 
-      iex> a + 1  # will fail with a "function a/0 undefined" error
+      iex> a + 1 # will fail with a `undefined variable "a"` error
       2
 
-  Similarly to iex you can use numbers in your "prompts":
+  If you don't want to assert for every result in a doctest, you can omit
+  the result. You can do so between expressions:
+
+      iex> pid = spawn(fn -> :ok end)
+      iex> is_pid(pid)
+      true
+
+  As well as at the end:
+
+      iex> Mod.do_a_call_that_should_not_raise!(...)
+
+  This is useful when the result is something variable (like a PID in the
+  example above) or when the result is a complicated data structure and you
+  don't want to show it all, but just parts of it or some of its properties.
 
-      iex(1)> [1+2,
+  Similarly to IEx you can use numbers in your "prompts":
+
+      iex(1)> [1 + 2,
       ...(1)>  3]
-      [3,3]
+      [3, 3]
 
-  This is useful in two use cases:
+  This is useful in two cases:
 
     * being able to refer to specific numbered scenarios
-    * copy-pasting examples from an actual iex session
+    * copy-pasting examples from an actual IEx session
 
-  We also allow you to select or skip some functions when calling
-  `doctest`. See the documentation for more info.
+  You can also select or skip functions when calling
+  `doctest`. See the documentation on the `:except` and `:only` options below
+  for more information.
 
   ## Opaque types
 
-  Some types internal structure are kept hidden and instead show a
-  user-friendly structure when inspecting the value. The idiom in
-  Elixir is to print those data types as `#Name<...>`. Doctest will
-  test these values by doing a string compare.
+  Some types' internal structures are kept hidden and instead show a
+  user-friendly structure when inspected. The idiom in
+  Elixir is to print those data types in the format `#Name<...>`. Because those
+  values are treated as comments in Elixir code due to the leading
+  `#` sign, they require special care when being used in doctests.
+
+  Imagine you have a map that contains a `DateTime` and is printed as:
+
+      %{datetime: #DateTime<2023-06-26 09:30:00+09:00 JST Asia/Tokyo>}
+
+  If you try to match on such an expression, `doctest` will fail to compile.
+  There are two ways to resolve this.
+
+  The first is to rely on the fact that doctest can compare internal
+  structures as long as they are at the root. So one could write:
+
+      iex> map = %{datetime: DateTime.from_naive!(~N[2023-06-26T09:30:00], "Asia/Tokyo")}
+      iex> map.datetime
+      #DateTime<2023-06-26 09:30:00+09:00 JST Asia/Tokyo>
 
-      iex> Enum.into([a: 10, b: 20], HashDict.new)
-      #HashDict<[b: 20, a: 10]>
+  Whenever a doctest starts with "#Name<", `doctest` will perform a string
+  comparison. For example, the above test will perform the following match:
 
-  The above example will be tested with the following match:
-  `"#HashDict<[b: 20, a: 10]>" = inspect(Enum.into([a: 10, b: 20], HashDict.new))`.
+      inspect(map.datetime) == "#DateTime<2023-06-26 09:30:00+09:00 JST Asia/Tokyo>"
+
+  You can also control `doctest` to use certain inspect options. See the
+  documentation on the `:inspect_opts` option below.
+
+  Alternatively, since doctest results are actually evaluated, you can have
+  the `DateTime` building expression as the doctest result:
+
+      iex> %{datetime: DateTime.from_naive!(~N[2023-06-26T09:30:00], "Asia/Tokyo")}
+      %{datetime: DateTime.from_naive!(~N[2023-06-26T09:30:00], "Asia/Tokyo")}
+
+  The downside of this approach is that the doctest result is not really
+  what users would see in the terminal.
 
   ## Exceptions
 
   You can also showcase expressions raising an exception, for example:
 
-      iex(1)> String.to_atom((fn() -> 1 end).())
-      ** (ArgumentError) argument error
+      iex> raise "some error"
+      ** (RuntimeError) some error
+
+  Doctest will look for a line starting with `** (` and it will parse it
+  accordingly to extract the exception name and message. The exception parser
+  will consider all following lines part of the exception message until there
+  is an empty line or there is a new expression prefixed with `iex>`.
+  Therefore, it is possible to match on multiline messages as long as there
+  are no empty lines on the message itself.
+
+  Asserting on the full exception message might not be possible because it is
+  non-deterministic, or it might result in brittle tests if the exact message
+  changes and gets more detailed.
+  Since Elixir 1.19.0, doctests allow the use of an ellipsis (`...`) at the
+  end of messages:
 
-  What DocTest will be looking for is a line starting with `** (` and it
-  will parse it accordingly to extract the exception name and message.
-  At this moment, the exception parser would make the parser treat the next
-  line as a start of a completely new expression (if it is prefixed with `iex>`)
-  or a no-op line with documentation. Thus, multiline messages are not
-  supported.
+      iex> raise "some error in pid: #{inspect(self())}"
+      ** (RuntimeError) some error in pid: ...
+
+      iex> raise "some error in pid:\n#{inspect(self())}"
+      ** (RuntimeError) some error in pid:
+      ...
 
   ## When not to use doctest
 
@@ -113,425 +170,808 @@ defmodule ExUnit.DocTest do
   """
 
   defmodule Error do
+    @moduledoc """
+    Exception raised when there's an error with the syntax or semantics of a doctest.
+    """
+
+    @typedoc since: "1.16.0"
+    @type t :: %__MODULE__{message: String.t()}
     defexception [:message]
+
+    @impl true
+    def exception(opts) do
+      module = Keyword.fetch!(opts, :module)
+      message = Keyword.fetch!(opts, :message)
+
+      message =
+        if source = module.module_info(:compile)[:source] do
+          file_line = Exception.format_file_line(Path.relative_to_cwd(source), opts[:line])
+          file_line <> " " <> message
+        else
+          message
+        end
+
+      %__MODULE__{message: message}
+    end
   end
 
   @doc """
-  This macro is used to generate ExUnit test cases for doctests.
+  Generate test cases from module documentation.
 
   Calling `doctest(Module)` will generate tests for all doctests found
-  in the module `Module`
+  in the `module`.
 
-  Options can also be supplied:
+  ## Options
 
-    * `:except` — generate tests for all functions except those listed
-      (list of `{function, arity}` tuples).
+    * `:except` - generates tests for all functions except those listed
+      (list of `{function, arity}` tuples, and/or `:moduledoc`).
 
-    * `:only` — generate tests only for functions listed
-      (list of `{function, arity}` tuples).
+    * `:only` - generates tests only for functions listed
+      (list of `{function, arity}` tuples, and/or `:moduledoc`).
 
-    * `:import` — when true, one can test a function defined in the module
+    * `:import` - when `true`, one can test a function defined in the module
       without referring to the module name. However, this is not feasible when
-      there is a clash with a module like Kernel. In these cases, `import`
-      should be set to `false` and a full `M.f` construct should be used.
+      there is a clash with a module like `Kernel`. In these cases, `:import`
+      should be set to `false` and `Module.function(...)` should be used instead.
+
+    * `:tags` - a list of tags to apply to all generated doctests.
+
+    * `:inspect_opts` - A keyword list with options for `inspect/2` on opaque
+      types. This is useful when inspection output on opaque types utilizes
+      pretty printing and to keep the doctests more readable.
 
   ## Examples
 
-      doctest MyModule, except: [trick_fun: 1]
+      defmodule MyModuleTest do
+        use ExUnit.Case
+        doctest MyModule, except: [:moduledoc, trick_fun: 1]
+      end
 
   This macro is auto-imported with every `ExUnit.Case`.
   """
-  defmacro doctest(mod, opts \\ []) do
+  defmacro doctest(module, opts \\ []) do
+    caller = __CALLER__
+
     require =
-      if is_atom Macro.expand(mod, __CALLER__) do
+      if is_atom(Macro.expand(module, caller)) do
         quote do
-          require unquote(mod)
+          require unquote(module)
         end
       end
 
-    tests = quote bind_quoted: binding do
-      file = "(for doctest at) " <> Path.relative_to_cwd(mod.__info__(:compile)[:source])
-      for {name, test} <- ExUnit.DocTest.__doctests__(mod, opts) do
-        @file file
-        test name, do: unquote(test)
+    tests =
+      quote bind_quoted: [
+              module: module,
+              opts: opts,
+              env_line: caller.line,
+              env_file: caller.file
+            ] do
+        file = ExUnit.DocTest.__file__(module)
+
+        for {name, test, tags} <- ExUnit.DocTest.__doctests__(module, opts) do
+          @file file
+          doc = ExUnit.Case.register_test(__MODULE__, env_file, env_line, :doctest, name, tags)
+          def unquote(doc)(_), do: unquote(test)
+        end
       end
-    end
 
     [require, tests]
   end
 
+  @doc """
+  Generate test cases from a markdown file.
+
+  ## Options
+
+    * `:tags` - a list of tags to apply to all generated doctests.
+
+    * `:inspect_opts` - A keyword list with options for `inspect/2` on opaque
+      types. This is useful when inspection output on opaque types utilizes
+      pretty printing and to keep the doctests more readable.
+
+  ## Examples
+
+      defmodule ReadmeTest do
+        use ExUnit.Case
+        doctest_file "README.md"
+      end
+
+  This macro is auto-imported with every `ExUnit.Case`.
+  """
+  @doc since: "1.15.0"
+  defmacro doctest_file(file, opts \\ []) do
+    caller = __CALLER__
+
+    tests =
+      quote bind_quoted: [file: file, opts: opts, env_line: caller.line, env_file: caller.file] do
+        for {name, test, tags} <- ExUnit.DocTest.__doctest_file__(file, __MODULE__, opts) do
+          doc = ExUnit.Case.register_test(__MODULE__, env_file, env_line, :doctest, name, tags)
+          def unquote(doc)(_), do: unquote(test)
+        end
+      end
+
+    tests
+  end
+
+  @doc false
+  def __doctest_file__(file, module, opts) do
+    doc = File.read!(file)
+    file = Path.relative_to_cwd(file)
+    tags = [doctest: file] ++ Keyword.get(opts, :tags, [])
+    inspect_opts = Keyword.get(opts, :inspect_opts, [])
+
+    extract_tests(1, doc, module, :moduledoc)
+    |> Enum.with_index(fn test, acc ->
+      {
+        "#{file} (#{acc + 1})",
+        test_content(test, module, false, file, inspect_opts),
+        test_tags(test, tags)
+      }
+    end)
+  end
+
+  @doc false
+  def __file__(module) do
+    info =
+      if source = module.module_info(:compile)[:source] do
+        Path.relative_to_cwd(source)
+      else
+        inspect(module)
+      end
+
+    "(for doctest at) " <> info
+  end
+
   @doc false
   def __doctests__(module, opts) do
-    do_import = Keyword.get(opts, :import, false)
+    tags = [doctest: module] ++ Keyword.get(opts, :tags, [])
+    import = Keyword.get(opts, :import, false)
+    inspect_opts = Keyword.get(opts, :inspect_opts, [])
+
+    maybe_source =
+      if source = module.module_info(:compile)[:source] do
+        Path.relative_to_cwd(source)
+      end
 
     extract(module)
-    |> filter_by_opts(opts)
-    |> Stream.with_index
-    |> Enum.map(fn {test, acc} ->
-      compile_test(test, module, do_import, acc + 1)
+    |> filter_by_opts(module, opts)
+    |> Enum.sort_by(& &1.line)
+    |> Enum.with_index(fn test, index ->
+      compile_test(test, module, import, index + 1, maybe_source, tags, inspect_opts)
     end)
   end
 
-  defp filter_by_opts(tests, opts) do
-    only   = opts[:only] || []
-    except = opts[:except] || []
+  defp filter_by_opts(tests, module, opts) do
+    except = Keyword.get(opts, :except, [])
 
-    Stream.filter(tests, fn(test) ->
-      fa = test.fun_arity
-      Enum.all?(except, &(&1 != fa)) and Enum.all?(only, &(&1 == fa))
-    end)
+    case Keyword.fetch(opts, :only) do
+      {:ok, []} -> []
+      {:ok, only} -> filter_tests(module, tests, except, only)
+      :error -> Stream.reject(tests, &(&1.fun_arity in except))
+    end
   end
 
+  defp filter_tests(module, tests, except, only) do
+    {filtered_tests, fun_arities} =
+      for test <- tests,
+          test.fun_arity not in except,
+          test.fun_arity in only,
+          reduce: {[], []} do
+        {tests, fun_arities} -> {[test | tests], [test.fun_arity | fun_arities]}
+      end
+
+    case only -- [:moduledoc | fun_arities] do
+      [] ->
+        filtered_tests
+
+      undefined_fun_arities ->
+        pluralized = pluralize_list_name("function", undefined_fun_arities)
+
+        functions =
+          Enum.map_join(undefined_fun_arities, "\n    ", fn {fun, arity} ->
+            Exception.format_mfa(module, fun, arity)
+          end)
+
+        raise Error,
+          module: module,
+          message: "undefined or private #{pluralized} given to doctest:\n\n    #{functions}\n\n"
+    end
+  end
+
+  defp pluralize_list_name(name, [_]), do: name
+  defp pluralize_list_name(name, _), do: ExUnit.plural_rule(name)
+
   ## Compilation of extracted tests
 
-  defp compile_test(test, module, do_import, n) do
-    {test_name(test, module, n), test_content(test, module, do_import)}
+  defp compile_test(test, module, do_import, n, maybe_source, tags, inspect_opts) do
+    {
+      test_name(test, module, n),
+      test_content(test, module, do_import, maybe_source, inspect_opts),
+      test_tags(test, tags)
+    }
   end
 
-  defp test_name(%{fun_arity: nil}, m, n) do
-    "moduledoc at #{inspect m} (#{n})"
+  defp test_name(%{fun_arity: :moduledoc}, m, n) do
+    "module #{inspect(m)} (#{n})"
   end
 
   defp test_name(%{fun_arity: {f, a}}, m, n) do
-    "doc at #{inspect m}.#{f}/#{a} (#{n})"
+    "#{inspect(m)}.#{f}/#{a} (#{n})"
   end
 
-  defp test_content(%{exprs: exprs, line: line, fun_arity: fun_arity}, module, do_import) do
-    file     = module.__info__(:compile)[:source] |> List.to_string
-    location = [line: line, file: Path.relative_to_cwd(file)]
-    stack    = Macro.escape [{module, :__MODULE__, 0, location}]
-
+  defp test_content(%{exprs: exprs, line: line}, module, do_import, maybe_source, inspect_opts) do
     if multiple_exceptions?(exprs) do
-      {fun, arity} = fun_arity
-      raise Error, message: "multiple exceptions in one doctest case are not supported. "
-                            "Invalid doctest for #{inspect module}.#{fun}/#{arity}"
+      raise Error,
+        line: line,
+        module: module,
+        message:
+          "multiple exceptions in the same doctest example are not supported, " <>
+            "please separate your iex> prompts by multiple newlines to start new examples"
     end
 
-    tests = Enum.map exprs, fn {expr, expected} ->
-      test_case_content(expr, expected, module, line, file, stack)
-    end
+    tests =
+      Enum.map(exprs, fn expr -> test_case_content(expr, module, maybe_source, inspect_opts) end)
 
-    quote do
-      unquote_splicing(test_import(module, do_import))
-      unquote(gen_code_for_tests(tests, whole_expr(exprs), stack))
-    end
+    {:__block__, [], test_import(module, do_import) ++ tests}
   end
 
-  defp whole_expr(exprs) do
-    Enum.map_join(exprs, "\n", &elem(&1, 0))
+  defp test_tags(test, tags) do
+    [doctest_line: test.line, doctest_data: %{end_line: test.end_line}] ++ tags
   end
 
   defp multiple_exceptions?(exprs) do
     Enum.count(exprs, fn
-      {_, {:error, _, _}} -> true
+      %{expected: {:error, _, _}} -> true
       _ -> false
     end) > 1
   end
 
-  defp gen_code_for_tests(tests, whole_expr, stack) do
-    quote do
-      stack = unquote(stack)
-      try do
-        # Put all tests into one context
-        unquote_splicing(tests)
-      rescue
-        e in [ExUnit.AssertionError] ->
-          reraise e, stack
+  defp test_case_content(%{expected: :test} = data, module, maybe_source, _inspect_opts) do
+    %{expr: expr, expr_line: expr_line, doctest: doctest} = data
+    string_to_quoted(module, maybe_source, expr_line, expr, doctest) |> insert_assertions()
+  end
 
-        error ->
-          reraise ExUnit.AssertionError,
-            [message: "Doctest failed: got #{inspect(error.__struct__)} with message #{Exception.message(error)}",
-             expr: unquote(whole_expr)],
-            stack
-      end
+  defp test_case_content(
+         %{expected: {:test, expected}} = data,
+         module,
+         maybe_source,
+         _inspect_opts
+       ) do
+    %{expr: expr, expr_line: expr_line, expected_line: expected_line, doctest: doctest} = data
+
+    expr_ast =
+      string_to_quoted(module, maybe_source, expr_line, expr, doctest) |> insert_assertions()
+
+    expected_ast = string_to_quoted(module, maybe_source, expected_line, expected, doctest)
+    last_expr = Macro.to_string(last_expr(expr_ast))
+
+    quote do
+      # `expr_ast` may introduce variables that may be used
+      # within `expected_ast` so it needs to be unquoted here.
+      value = unquote(expr_ast)
+
+      ExUnit.DocTest.__test__(
+        value,
+        unquote(expected_ast),
+        unquote(doctest),
+        unquote(last_expr),
+        unquote(expected),
+        unquote(module),
+        unquote(maybe_source),
+        unquote(expr_line)
+      )
     end
   end
 
-  defp test_case_content(expr, {:test, expected}, module, line, file, stack) do
-    expr_ast     = string_to_quoted(module, line, file, expr)
-    expected_ast = string_to_quoted(module, line, file, expected)
+  defp test_case_content(
+         %{expected: {:inspect, expected}} = data,
+         module,
+         maybe_source,
+         inspect_opts
+       ) do
+    %{expr: expr, expr_line: expr_line, doctest: doctest} = data
+
+    expr_ast =
+      string_to_quoted(module, maybe_source, expr_line, expr, doctest) |> insert_assertions()
+
+    last_expr = Macro.to_string(last_expr(expr_ast))
 
     quote do
-      expected = unquote(expected_ast)
-      case unquote(expr_ast) do
-        ^expected -> :ok
-        actual ->
-          reraise ExUnit.AssertionError,
-            [message: "Doctest failed",
-             expr: "#{unquote(String.strip(expr))} === #{unquote(String.strip(expected))}",
-             left: actual],
-            unquote(stack)
-      end
+      ExUnit.DocTest.__inspect__(
+        unquote(expr_ast),
+        unquote(expected),
+        unquote(doctest),
+        unquote(last_expr),
+        unquote(inspect(expected)),
+        unquote(module),
+        unquote(maybe_source),
+        unquote(expr_line),
+        unquote(inspect_opts)
+      )
     end
   end
 
-  defp test_case_content(expr, {:inspect, expected}, module, line, file, stack) do
-    expr_ast     = quote do: inspect(unquote(string_to_quoted(module, line, file, expr)))
-    expected_ast = string_to_quoted(module, line, file, expected)
+  defp test_case_content(
+         %{expected: {:error, exception, message}} = data,
+         module,
+         maybe_source,
+         _inspect_opts
+       ) do
+    %{expr: expr, expr_line: expr_line, doctest: doctest} = data
+    expr_ast = string_to_quoted(module, maybe_source, expr_line, expr, doctest)
 
     quote do
-      expected = unquote(expected_ast)
-      case unquote(expr_ast) do
-        ^expected -> :ok
-        actual ->
-          reraise ExUnit.AssertionError,
-            [message: "Doctest failed",
-             expr: "inspect(#{unquote(String.strip(expr))}) === #{unquote(String.strip(expected))}",
-             left: actual],
-            unquote(stack)
-      end
+      ExUnit.DocTest.__error__(
+        fn -> unquote(expr_ast) end,
+        unquote(message),
+        unquote(exception),
+        unquote(doctest),
+        unquote(module),
+        unquote(maybe_source),
+        unquote(expr_line)
+      )
     end
   end
 
-  defp test_case_content(expr, {:error, exception, message}, module, line, file, stack) do
-    expr_ast = string_to_quoted(module, line, file, expr)
+  @doc false
+  def __test__(value, expected, doctest, last_expr, expected_expr, module, maybe_source, line) do
+    case value do
+      ^expected ->
+        {:ok, value}
 
-    quote do
-      stack = unquote(stack)
-      expr  = unquote(String.strip(expr))
-      spec  = inspect(unquote(exception)) <> " with message " <> inspect(unquote(message))
+      _ ->
+        error = [
+          message: "Doctest failed",
+          doctest: doctest,
+          expr: "#{last_expr} === #{String.trim(expected_expr)}",
+          left: value,
+          right: expected
+        ]
+
+        reraise ExUnit.AssertionError, error, stack(module, maybe_source, line)
+    end
+  end
 
+  @doc false
+  def __inspect__(
+        value,
+        expected,
+        doctest,
+        last_expr,
+        expected_expr,
+        module,
+        maybe_source,
+        line,
+        inspect_opts
+      ) do
+    result =
       try do
-        unquote(expr_ast)
+        inspect(value, Keyword.put(inspect_opts, :safe, false))
       rescue
-        error ->
-          unless error.__struct__ == unquote(exception) and
-                 Exception.message(error) == unquote(message) do
-            got = inspect(error.__struct__) <> " with message " <> inspect(Exception.message(error))
-            reraise ExUnit.AssertionError,
-              [message: "Doctest failed: expected exception #{spec} but got #{got}",
-               expr: expr],
-              stack
-          end
+        e ->
+          stack = Enum.drop(__STACKTRACE__, 1)
+          {[message: Exception.message(e)], ExUnit.Runner.prune_stacktrace(stack)}
       else
-        _ ->
-          reraise ExUnit.AssertionError,
-            [message: "Doctest failed: expected exception #{spec} but nothing was raised",
-             expr: expr],
-            stack
+        ^expected -> :ok
+        actual -> {[left: actual, right: expected, message: "Doctest failed"], []}
       end
+
+    case result do
+      :ok ->
+        {:ok, value}
+
+      {extra, stack} ->
+        expr = "inspect(#{last_expr}) === #{String.trim(expected_expr)}"
+        error = [doctest: doctest, expr: expr] ++ extra
+        reraise ExUnit.AssertionError, error, stack ++ stack(module, maybe_source, line)
     end
   end
 
-  defp test_import(_mod, false), do: []
-  defp test_import(mod, _) do
-    [quote do: import(unquote(mod))]
+  @doc false
+  def __error__(fun, message, exception, doctest, module, maybe_source, line) do
+    try do
+      fun.()
+    rescue
+      error ->
+        actual_exception = error.__struct__
+        actual_message = Exception.message(error)
+
+        failed =
+          cond do
+            actual_exception != exception ->
+              "Doctest failed: expected exception #{inspect(exception)} but got " <>
+                "#{inspect(actual_exception)} with message #{inspect(actual_message)}"
+
+            not error_message_matches?(actual_message, message) ->
+              "Doctest failed: wrong message for #{inspect(actual_exception)}\n" <>
+                "expected:\n" <>
+                "  #{inspect(message)}\n" <>
+                "actual:\n" <> "  #{inspect(actual_message)}"
+
+            true ->
+              nil
+          end
+
+        if failed do
+          reraise ExUnit.AssertionError,
+                  [message: failed, doctest: doctest],
+                  stack(module, maybe_source, line)
+        end
+    else
+      _ ->
+        failed = "Doctest failed: expected exception #{inspect(exception)} but nothing was raised"
+        error = [message: failed, doctest: doctest]
+        reraise ExUnit.AssertionError, error, stack(module, maybe_source, line)
+    end
+  end
+
+  defp error_message_matches?(actual, expected) when actual == expected, do: true
+
+  defp error_message_matches?(actual, expected) do
+    if String.ends_with?(expected, "...") do
+      ellipsis_removed = binary_slice(expected, 0..-4//1)
+      String.starts_with?(actual, ellipsis_removed)
+    else
+      false
+    end
   end
 
-  defp string_to_quoted(module, line, file, expr) do
-    location = [line: line, file: Path.relative_to_cwd(file)]
-    stack    = Macro.escape [{module, :__MODULE__, 0, location}]
+  defp test_import(_mod, false), do: []
+  defp test_import(mod, _), do: [quote(do: import(unquote(mod)))]
+
+  defp string_to_quoted(module, maybe_source, line, expr, doctest) when is_binary(expr) do
     try do
-      Code.string_to_quoted!(expr, location)
+      Code.string_to_quoted!(expr, file: maybe_source || inspect(module), line: line)
     rescue
       e ->
-        message = "(#{inspect e.__struct__}) #{Exception.message(e)}"
+        ex_message = "(#{inspect(e.__struct__)}) #{Exception.message(e)}"
+        message = "Doctest did not compile, got: #{ex_message}"
+
+        message =
+          if e.__struct__ == TokenMissingError and expr =~ ~r/#[\w\.]+</ do
+            message <>
+              """
+              \nIf you are planning to assert on the result of an iex> expression \
+              which contains a value inspected as #Name<...>, please make sure \
+              the inspected value is placed at the beginning of the expression, \
+              otherwise Elixir will treat it as a comment due to the leading sign #.\
+              """
+          else
+            message
+          end
+
+        opts =
+          if String.valid?(doctest) do
+            [message: message, doctest: doctest]
+          else
+            [message: message]
+          end
+
         quote do
           reraise ExUnit.AssertionError,
-            [message: "Doctest did not compile, got: #{unquote(message)}",
-             expr: unquote(String.strip(expr))],
-            unquote(stack)
+                  unquote(opts),
+                  unquote(Macro.escape(stack(module, maybe_source, line)))
         end
     end
   end
 
+  defp stack(module, file, line) do
+    file_info = if file, do: [file: String.to_charlist(file)], else: []
+    [{module, :__MODULE__, 0, [line: line] ++ file_info}]
+  end
+
   ## Extraction of the tests
 
   defp extract(module) do
-    all_docs = Code.get_docs(module, :all)
-    moduledocs = extract_from_moduledoc(all_docs[:moduledoc])
-
-    docs = for doc <- all_docs[:docs] do
-      extract_from_doc(doc)
-    end |> Enum.concat
-
-    moduledocs ++ docs
+    case Code.fetch_docs(module) do
+      {:docs_v1, annotation, _, _, moduledoc, _, docs} ->
+        extract_from_moduledoc(annotation, moduledoc, module) ++
+          extract_from_docs(Enum.sort(docs), module)
+
+      {:error, reason} ->
+        raise Error,
+          module: module,
+          message:
+            "could not retrieve the documentation for module #{inspect(module)}. " <>
+              explain_docs_error(reason)
+    end
   end
 
-  defp extract_from_moduledoc({_, doc}) when doc in [false, nil], do: []
+  defp explain_docs_error(:module_not_found),
+    do: "The BEAM file of the module cannot be accessed"
 
-  defp extract_from_moduledoc({line, doc}) do
-    extract_tests(line, doc)
-  end
+  defp explain_docs_error(:chunk_not_found),
+    do: "The module was not compiled with documentation"
 
-  defp extract_from_doc({_, _, _, _, doc}) when doc in [false, nil], do: []
+  defp explain_docs_error({:invalid_chunk, _}),
+    do: "The documentation chunk in the module is invalid"
 
-  defp extract_from_doc({fa, line, _, _, doc}) do
-    for test <- extract_tests(line, doc) do
-      %{test | fun_arity: fa}
-    end
+  defp extract_from_moduledoc(annotation, %{"en" => doc}, module) do
+    extract_tests(:erl_anno.line(annotation), doc, module, :moduledoc)
   end
 
-  defp extract_tests(line, doc) do
-    lines = String.split(doc, ~r/\n/, trim: false) |> adjust_indent
-    extract_tests(lines, line, "", "", [], true)
-  end
+  defp extract_from_moduledoc(_, _doc, _module), do: []
 
-  defp adjust_indent(lines) do
-    adjust_indent(lines, [], 0, :text)
+  defp extract_from_docs(docs, module) do
+    for doc <- docs, doc <- extract_from_doc(doc, module), do: doc
   end
 
-  defp adjust_indent([], adjusted_lines, _indent, _) do
-    Enum.reverse adjusted_lines
+  defp extract_from_doc({{_, name, arity}, annotation, _, %{"en" => doc}, _}, module) do
+    line = :erl_anno.line(annotation)
+    extract_tests(line, doc, module, {name, arity})
   end
 
+  defp extract_from_doc(_doc, _module),
+    do: []
+
   @iex_prompt ["iex>", "iex("]
   @dot_prompt ["...>", "...("]
+  @fences ["```", "~~~"]
 
-  defp adjust_indent([line|rest], adjusted_lines, indent, :text) do
-    case String.starts_with?(String.lstrip(line), @iex_prompt) do
-      true  -> adjust_indent([line|rest], adjusted_lines, get_indent(line, indent), :prompt)
-      false -> adjust_indent(rest, adjusted_lines, indent, :text)
-    end
+  defp adjust_indent(lines, line_no, module) do
+    adjust_text(lines, line_no, [], module)
   end
 
-  defp adjust_indent([line|rest], adjusted_lines, indent, check) when check in [:prompt, :after_prompt] do
-    stripped_line = strip_indent(line, indent)
+  defp adjust_text([], line_no, adjusted_lines, _module) do
+    {Enum.reverse(adjusted_lines), line_no - 1}
+  end
 
-    case String.lstrip(line) do
-      "" ->
-        raise Error, message: "expected non-blank line to follow iex> prompt"
-      ^stripped_line ->
-        :ok
-      _ ->
-        raise Error, message: "indentation level mismatch: #{inspect line}, should have been #{indent} spaces"
-    end
+  defp adjust_text([line | rest], line_no, adjusted_lines, module) do
+    case String.starts_with?(String.trim_leading(line), @iex_prompt) do
+      true ->
+        {indent, _len} = :binary.match(line, "iex")
+        adjust_code(:prompt, [line | rest], line_no, adjusted_lines, indent, module)
 
-    if String.starts_with?(stripped_line, @iex_prompt ++ @dot_prompt) do
-      adjust_indent(rest, [stripped_line|adjusted_lines], indent, :after_prompt)
-    else
-      next = if check == :prompt, do: :after_prompt, else: :code
-      adjust_indent(rest, [stripped_line|adjusted_lines], indent, next)
+      false ->
+        adjust_text(rest, line_no + 1, adjusted_lines, module)
     end
   end
 
-  defp adjust_indent([line|rest], adjusted_lines, indent, :code) do
+  defp adjust_code(_kind, [], line_no, adjusted_lines, _indent, _module) do
+    {Enum.reverse(adjusted_lines), line_no - 1}
+  end
+
+  defp adjust_code(kind, [line | rest], line_no, adjusted_lines, indent, module) do
     stripped_line = strip_indent(line, indent)
-    cond do
-      stripped_line == "" ->
-        adjust_indent(rest, [stripped_line|adjusted_lines], 0, :text)
-      String.starts_with?(String.lstrip(line), @iex_prompt) ->
-        adjust_indent([line|rest], adjusted_lines, indent, :prompt)
-      true ->
-        adjust_indent(rest, [stripped_line|adjusted_lines], indent, :code)
+    trimmed_line = String.trim_leading(line)
+    done? = stripped_line == "" or String.starts_with?(stripped_line, @fences)
+
+    overrun? =
+      if kind == :code,
+        do: not done? and byte_size(trimmed_line) > byte_size(stripped_line),
+        else: byte_size(trimmed_line) != byte_size(stripped_line)
+
+    if overrun? do
+      n_spaces = if indent == 1, do: "#{indent} space", else: "#{indent} spaces"
+
+      raise Error,
+        line: line_no,
+        module: module,
+        message: """
+        indentation level mismatch on doctest line: #{inspect(line)}
+
+        If you are planning to assert on the result of an `iex>` expression, \
+        make sure the result is indented at the same level as `iex>`, which \
+        in this case is exactly #{n_spaces}.
+
+        If instead you have an `iex>` expression that spans over multiple lines, \
+        please make sure that each line after the first one begins with `...>`.
+        """
     end
-  end
 
-  defp get_indent(line, current_indent) do
-    case Regex.run ~r/iex/, line, return: :index do
-      [{pos, _len}] -> pos
-      nil -> current_indent
+    cond do
+      done? ->
+        adjusted_lines = [{"", line_no} | adjusted_lines]
+        adjust_text(rest, line_no + 1, adjusted_lines, module)
+
+      kind == :prompt or String.starts_with?(trimmed_line, @iex_prompt) or
+          (kind == :maybe_prompt and String.starts_with?(trimmed_line, @dot_prompt)) ->
+        line = {adjust_prompt(stripped_line, line_no, module), line_no}
+        adjust_code(:maybe_prompt, rest, line_no + 1, [line | adjusted_lines], indent, module)
+
+      true ->
+        adjusted_lines = [{stripped_line, line_no} | adjusted_lines]
+        adjust_code(:code, rest, line_no + 1, adjusted_lines, indent, module)
     end
   end
 
   defp strip_indent(line, indent) do
     length = byte_size(line) - indent
+
     if length > 0 do
-      :binary.part(line, indent, length)
+      binary_part(line, indent, length)
     else
       ""
     end
   end
 
-  defp extract_tests([], _line, "", "", [], _) do
-    []
-  end
+  defp adjust_prompt("iex(" <> rest = line, line_no, module),
+    do: "iex>" <> skip_iex_number(rest, line_no, module, line)
 
-  defp extract_tests([], _line, "", "", acc, _) do
-    Enum.reverse(reverse_last_test(acc))
-  end
+  defp adjust_prompt("...(" <> rest = line, line_no, module),
+    do: "...>" <> skip_iex_number(rest, line_no, module, line)
 
-  # End of input and we've still got a test pending.
-  defp extract_tests([], _, expr_acc, expected_acc, [test=%{exprs: exprs}|t], _) do
-    test = %{test | exprs: [{expr_acc, {:test, expected_acc}} | exprs]}
-    Enum.reverse(reverse_last_test([test|t]))
-  end
+  defp adjust_prompt(line, _line_no, _module),
+    do: line
+
+  defp skip_iex_number(string, line_no, module, line) do
+    case :binary.split(string, ")>") do
+      [_pre, post] ->
+        post
+
+      [_] ->
+        message =
+          "unknown IEx prompt: #{inspect(line)}.\nAccepted formats are: iex>, iex(1)>, ...>, ...(1)>}"
 
-  # We've encountered the next test on an adjacent line. Put them into one group.
-  defp extract_tests([<< "iex>", _ :: binary>>|_] = list, line, expr_acc, expected_acc, [test=%{exprs: exprs}|t], newtest) when expr_acc != "" and expected_acc != "" do
-    test = %{test | exprs: [{expr_acc, {:test, expected_acc}} | exprs]}
-    extract_tests(list, line, "", "", [test|t], newtest)
+        raise Error, line: line_no, module: module, message: message
+    end
   end
 
-  # Store expr_acc and start a new test case.
-  defp extract_tests([<< "iex>", string :: binary>>|lines], line, "", expected_acc, acc, true) do
-    acc = reverse_last_test(acc)
-    test = %{line: line, fun_arity: nil, exprs: []}
-    extract_tests(lines, line, string, expected_acc, [test|acc], false)
+  defp chunk_tests(lines, acc, last_no) do
+    case lines
+         |> Enum.drop_while(&(not test_started?(&1)))
+         |> Enum.split_while(&(not test_finished?(&1))) do
+      {[], []} -> Enum.reverse(acc)
+      {chunk, []} -> Enum.reverse([{chunk, last_no} | acc])
+      {[], [_empty_line | lines]} -> chunk_tests(lines, acc, last_no)
+      {chunk, [{_, line_no} | lines]} -> chunk_tests(lines, [{chunk, line_no} | acc], last_no)
+    end
   end
 
-  # Store expr_acc.
-  defp extract_tests([<< "iex>", string :: binary>>|lines], line, "", expected_acc, acc, false) do
-    extract_tests(lines, line, string, expected_acc, acc, false)
+  defp test_started?({"iex>" <> _, _}), do: true
+  defp test_started?(_), do: false
+
+  defp test_finished?({"", _}), do: true
+  defp test_finished?(_), do: false
+
+  defp extract_tests(line_no, doc, module, fun_arity) do
+    {lines, last_line} =
+      doc
+      |> String.split(["\r\n", "\n"], trim: false)
+      |> adjust_indent(line_no + 1, module)
+
+    lines
+    |> chunk_tests([], last_line)
+    |> Enum.map(&build_test(&1, fun_arity))
   end
 
-  # Still gathering expr_acc. Synonym for the next clause.
-  defp extract_tests([<< "iex>", string :: binary>>|lines], line, expr_acc, expected_acc, acc, newtest) do
-    extract_tests(lines, line, expr_acc <> "\n" <> string, expected_acc, acc, newtest)
+  defp build_test({[{"iex>" <> string = line, line_no} | lines], end_line_no}, fun_arity) do
+    exprs = build_test(lines, [string], [], [line], [], line_no)
+    %{line: line_no, end_line: end_line_no - 1, exprs: Enum.reverse(exprs), fun_arity: fun_arity}
   end
 
-  # Still gathering expr_acc. Synonym for the previous clause.
-  defp extract_tests([<< "...>", string :: binary>>|lines], line, expr_acc, expected_acc, acc, newtest) when expr_acc != "" do
-    extract_tests(lines, line, expr_acc <> "\n" <> string, expected_acc, acc, newtest)
+  # Started a new expression.
+  defp build_test(
+         [{"iex>" <> _, new_line_no} | _] = list,
+         [_ | _] = expr,
+         [_ | _] = expected,
+         formatted,
+         acc,
+         line_no
+       ) do
+    acc = add_expr(acc, expr, expected, formatted, line_no)
+    build_test(list, [], [], [], acc, new_line_no)
   end
 
-  # Expression numbers are simply skipped.
-  defp extract_tests([<< "iex(", _ :: 8, string :: binary>>|lines], line, expr_acc, expected_acc, acc, newtest) do
-    extract_tests(["iex" <> skip_iex_number(string)|lines], line, expr_acc, expected_acc, acc, newtest)
+  # Continuation of an expression.
+  defp build_test(
+         [{"iex>" <> string = line, _} | lines],
+         expr,
+         expected,
+         formatted,
+         acc,
+         line_no
+       ) do
+    expr = add_line(expr, string)
+    formatted = add_line(formatted, line)
+    build_test(lines, expr, expected, formatted, acc, line_no)
   end
 
-  # Expression numbers are simply skipped redux.
-  defp extract_tests([<< "...(", _ :: 8, string :: binary>>|lines], line, expr_acc, expected_acc, acc, newtest) do
-    extract_tests(["..." <> skip_iex_number(string)|lines], line, expr_acc, expected_acc, acc, newtest)
+  # Continuation of an expression.
+  defp build_test(
+         [{"...>" <> string = line, _} | lines],
+         expr,
+         expected,
+         formatted,
+         acc,
+         line_no
+       ) do
+    expr = add_line(expr, string)
+    formatted = add_line(formatted, line)
+    build_test(lines, expr, expected, formatted, acc, line_no)
   end
 
-  # Skip empty or documentation line.
-  defp extract_tests([_|lines], line, "", "", acc, _) do
-    extract_tests(lines, line, "", "", acc, true)
+  # Expected lines.
+  defp build_test([{line, _} | lines], expr, expected, formatted, acc, line_no) do
+    build_test(lines, expr, add_line(expected, line), formatted, acc, line_no)
   end
 
-  # Encountered an empty line, store pending test
-  defp extract_tests([""|lines], line, expr_acc, expected_acc, [test=%{exprs: exprs}|t], _) do
-    test = %{test | exprs: [{expr_acc, {:test, expected_acc}} | exprs]}
-    extract_tests(lines, line,  "", "", [test|t], true)
+  # We are done.
+  defp build_test([], [_ | _] = expr, expected, formatted, acc, line_no) do
+    add_expr(acc, expr, expected, formatted, line_no)
   end
 
-  # Exception test.
-  defp extract_tests([<< "** (", string :: binary >>|lines], line, expr_acc, "", [test=%{exprs: exprs}|t], newtest) do
-    test = %{test | exprs: [{expr_acc, extract_error(string, "")} | exprs]}
-    extract_tests(lines, line,  "", "", [test|t], newtest)
+  defp add_line([], line), do: [line]
+  defp add_line(acc, line), do: [acc, [?\n, line]]
+
+  defp add_expr(exprs, expr_lines, expected_lines, formatted_lines, line_no) do
+    expected = IO.iodata_to_binary(expected_lines)
+    doctest = IO.iodata_to_binary([?\n, formatted_lines, ?\n, expected])
+
+    expr = %{
+      expr: IO.iodata_to_binary(expr_lines),
+      expr_line: line_no,
+      expected: tag_expected(expected),
+      expected_line: line_no + length(expr_lines),
+      doctest: doctest
+    }
+
+    [expr | exprs]
   end
 
-  # Finally, parse expected_acc.
-  defp extract_tests([expected|lines], line, expr_acc, expected_acc, [test=%{exprs: exprs}|t]=acc, newtest) do
-    if expected =~ ~r/^#[A-Z][\w\.]*<.*>$/ do
-      expected = expected_acc <> "\n" <> inspect(expected)
-      test = %{test | exprs: [{expr_acc, {:inspect, expected}} | exprs]}
-      extract_tests(lines, line,  "", "", [test|t], newtest)
-    else
-      extract_tests(lines, line, expr_acc, expected_acc <> "\n" <> expected, acc, newtest)
+  defp tag_expected(expected) do
+    case expected do
+      "" ->
+        :test
+
+      "** (" <> error ->
+        [mod, message] = :binary.split(error, ")")
+        {:error, Module.concat([mod]), String.trim_leading(message)}
+
+      _ ->
+        if inspectable?(expected) do
+          {:inspect, expected}
+        else
+          {:test, expected}
+        end
     end
   end
 
-  defp extract_error(<< ")", t :: binary >>, acc) do
-    {:error, Module.concat([acc]), String.strip(t)}
-  end
+  defp inspectable?(<<?#, char, rest::binary>>) when char in ?A..?Z, do: inspectable_end?(rest)
+  defp inspectable?(_), do: false
 
-  defp extract_error(<< h, t :: binary >>, acc) do
-    extract_error(t, << acc :: binary, h >>)
-  end
+  defp inspectable_end?(<<?., char, rest::binary>>) when char in ?A..?Z,
+    do: inspectable_end?(rest)
 
-  defp skip_iex_number(<< ")", ">", string :: binary >>) do
-    ">" <> string
-  end
+  defp inspectable_end?(<<char, rest::binary>>)
+       when char in ?A..?Z
+       when char in ?a..?z
+       when char in ?0..?9
+       when char == ?_,
+       do: inspectable_end?(rest)
 
-  defp skip_iex_number(<< _ :: 8, string :: binary >>) do
-    skip_iex_number(string)
-  end
+  defp inspectable_end?(<<?<, _::binary>>), do: true
+  defp inspectable_end?(_), do: false
+
+  defp last_expr({:__block__, _, [_ | _] = block}), do: block |> List.last() |> last_expr()
+  defp last_expr(other), do: other
+
+  defp insert_assertions({:__block__, meta, block}),
+    do: {:__block__, meta, Enum.map(block, &insert_match_assertion/1)}
+
+  defp insert_assertions(ast),
+    do: insert_match_assertion(ast)
+
+  defp insert_match_assertion({:=, _, [{var, _, context}, _]} = ast)
+       when is_atom(var) and is_atom(context),
+       do: ast
 
-  defp reverse_last_test([]), do: []
-  defp reverse_last_test([test=%{exprs: exprs} | t]) do
-    test = %{test | exprs: Enum.reverse(exprs)}
-    [test | t]
+  defp insert_match_assertion({:=, meta, [left, right]}),
+    do: {{:., meta, [__MODULE__, :__assert__]}, meta, [{:=, meta, [left, right]}]}
+
+  defp insert_match_assertion(ast),
+    do: ast
+
+  @doc false
+  defmacro __assert__({:=, _, [left, right]} = assertion) do
+    {left, right} = move_match(left, right)
+    code = Macro.escape(assertion, prune_metadata: true)
+    ExUnit.Assertions.__match__(left, right, code, :ok, __CALLER__)
   end
+
+  defp move_match(left, {:=, meta, [middle, right]}),
+    do: move_match({:=, meta, [left, middle]}, right)
+
+  defp move_match(left, right),
+    do: {left, right}
 end
diff --git a/lib/ex_unit/lib/ex_unit/event_manager.ex b/lib/ex_unit/lib/ex_unit/event_manager.ex
index ef0dc0fb838..3ce923fe6e8 100644
--- a/lib/ex_unit/lib/ex_unit/event_manager.ex
+++ b/lib/ex_unit/lib/ex_unit/event_manager.ex
@@ -1,54 +1,97 @@
-# This module publishes events during the test suite run.
-# This is used, for example, by formatters to print user
-# information as well as internal statistics for ExUnit.
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.EventManager do
   @moduledoc false
+  @timeout :infinity
+
+  @typep manager :: {supervisor_manager :: pid, event_manager :: pid}
 
+  @doc """
+  Starts an event manager that publishes events during the suite run.
+
+  This is what power formatters as well as the
+  internal statistics server for ExUnit.
+  """
+  @spec start_link() :: {:ok, manager}
   def start_link() do
-    :gen_event.start_link()
+    {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+    {:ok, event} = :gen_event.start_link()
+    {:ok, {sup, event}}
   end
 
-  def add_handler(ref, handler, args) do
-    :gen_event.add_handler(ref, handler, args)
+  def stop({sup, event}) do
+    for {_, pid, _, _} <- DynamicSupervisor.which_children(sup) do
+      GenServer.stop(pid, :normal, @timeout)
+    end
+
+    DynamicSupervisor.stop(sup)
+    :gen_event.stop(event)
   end
 
-  def delete_handler(ref, handler, args) do
-    :gen_event.delete_handler(ref, handler, args)
+  def add_handler({sup, event}, handler, opts) do
+    if Code.ensure_loaded?(handler) and function_exported?(handler, :handle_call, 2) do
+      IO.warn(
+        "passing GenEvent handlers (#{inspect(handler)} in this case) in " <>
+          "the :formatters option of ExUnit is deprecated, please pass a " <>
+          "GenServer instead. Check the documentation for the ExUnit.Formatter " <>
+          "module for more information"
+      )
+
+      :gen_event.add_handler(event, handler, opts)
+    else
+      DynamicSupervisor.start_child(sup, %{
+        id: GenServer,
+        start: {GenServer, :start_link, [handler, opts]},
+        restart: :temporary
+      })
+    end
   end
 
-  def which_handlers(ref) do
-    :gen_event.which_handlers(ref)
+  def suite_started(manager, opts) do
+    notify(manager, {:suite_started, opts})
   end
 
-  def call(ref, handler, request) do
-    :gen_event.call(ref, handler, request)
+  def suite_finished(manager, times_us) do
+    notify(manager, {:suite_finished, times_us})
   end
 
-  def call(ref, handler, request, timeout) do
-    :gen_event.call(ref, handler, request, timeout)
+  def module_started(manager, test_module) do
+    # TODO: Remove case_started on v2.0
+    notify(manager, {:case_started, Map.put(test_module, :__struct__, ExUnit.TestCase)})
+    notify(manager, {:module_started, test_module})
   end
 
-  def suite_started(ref, opts) do
-    :gen_event.notify(ref, {:suite_started, opts})
+  def module_finished(manager, test_module) do
+    # TODO: Remove case_finished on v2.0
+    notify(manager, {:case_finished, Map.put(test_module, :__struct__, ExUnit.TestCase)})
+    notify(manager, {:module_finished, test_module})
   end
 
-  def suite_finished(ref, load_us, run_us) do
-    :gen_event.notify(ref, {:suite_finished, load_us, run_us})
+  def sigquit(manager, current) do
+    notify(manager, {:sigquit, current})
   end
 
-  def case_started(ref, test_case) do
-    :gen_event.notify(ref, {:case_started, test_case})
+  def test_started(manager, test) do
+    notify(manager, {:test_started, test})
   end
 
-  def case_finished(ref, test_case) do
-    :gen_event.notify(ref, {:case_finished, test_case})
+  def test_finished(manager, test) do
+    notify(manager, {:test_finished, test})
   end
 
-  def test_started(ref, test) do
-    :gen_event.notify(ref, {:test_started, test})
+  def max_failures_reached(manager) do
+    notify(manager, :max_failures_reached)
   end
 
-  def test_finished(ref, test) do
-    :gen_event.notify(ref, {:test_finished, test})
+  defp notify({sup, event}, msg) do
+    :gen_event.notify(event, msg)
+
+    for {_, pid, _, _} <- Supervisor.which_children(sup) do
+      GenServer.cast(pid, msg)
+    end
+
+    :ok
   end
 end
diff --git a/lib/ex_unit/lib/ex_unit/failures_manifest.ex b/lib/ex_unit/lib/ex_unit/failures_manifest.ex
new file mode 100644
index 00000000000..239b63201fd
--- /dev/null
+++ b/lib/ex_unit/lib/ex_unit/failures_manifest.ex
@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule ExUnit.FailuresManifest do
+  @moduledoc false
+
+  @opaque t :: %{optional(ExUnit.test_id()) => test_file :: Path.t()}
+
+  @manifest_vsn 1
+
+  @spec new() :: t
+  def new, do: %{}
+
+  @spec put_test(t, ExUnit.Test.t()) :: t
+  def put_test(%{} = manifest, %ExUnit.Test{state: {ignored_state, _}})
+      when ignored_state in [:skipped, :excluded],
+      do: manifest
+
+  def put_test(%{} = manifest, %ExUnit.Test{state: nil} = test) do
+    Map.delete(manifest, {test.module, test.name})
+  end
+
+  def put_test(%{} = manifest, %ExUnit.Test{state: {failed_state, _}} = test)
+      when failed_state in [:failed, :invalid] do
+    Map.put(manifest, {test.module, test.name}, test.tags.file)
+  end
+
+  @spec write!(t, Path.t()) :: :ok
+  def write!(manifest, file) when is_binary(file) do
+    manifest = prune_deleted_tests(manifest)
+    binary = :erlang.term_to_binary({@manifest_vsn, manifest})
+    Path.dirname(file) |> File.mkdir_p!()
+    File.write!(file, binary)
+  end
+
+  @spec fail_all!(Path.t()) :: :ok
+  def fail_all!(file) when is_binary(file) do
+    binary = :erlang.term_to_binary({@manifest_vsn, :all})
+    Path.dirname(file) |> File.mkdir_p!()
+    File.write!(file, binary)
+  end
+
+  @spec read(Path.t()) :: t
+  def read(file) when is_binary(file) do
+    with {:ok, binary} <- File.read(file),
+         {:ok, {@manifest_vsn, %{} = manifest}} <- safe_binary_to_term(binary) do
+      manifest
+    else
+      _ -> new()
+    end
+  end
+
+  @spec info(Path.t()) :: {MapSet.t(Path.t()), MapSet.t(ExUnit.test_id())} | :all
+  def info(file) when is_binary(file) do
+    with {:ok, binary} <- File.read(file),
+         {:ok, {@manifest_vsn, manifest}} <- safe_binary_to_term(binary) do
+      case manifest do
+        :all ->
+          :all
+
+        %{} ->
+          {manifest |> Map.values() |> MapSet.new(), manifest |> Map.keys() |> MapSet.new()}
+      end
+    else
+      _ -> {MapSet.new(), MapSet.new()}
+    end
+  end
+
+  defp safe_binary_to_term(binary) do
+    {:ok, :erlang.binary_to_term(binary)}
+  rescue
+    ArgumentError -> :error
+  end
+
+  defp prune_deleted_tests(manifest) do
+    Map.drop(manifest, find_deleted_tests(Enum.to_list(manifest), %{}, []))
+  end
+
+  defp find_deleted_tests([], _file_existence, deleted_tests), do: deleted_tests
+
+  defp find_deleted_tests([{{mod, name} = id, file} | rest] = all, file_existence, acc) do
+    file_exists = Map.fetch(file_existence, file)
+
+    cond do
+      file_exists == :error ->
+        # This is the first time we've looked up the existence of the file.
+        # Cache the result and try again.
+        file_existence = Map.put(file_existence, file, File.regular?(file))
+        find_deleted_tests(all, file_existence, acc)
+
+      file_exists == {:ok, false} ->
+        # The file does not exist, so the test has been deleted.
+        find_deleted_tests(rest, file_existence, [id | acc])
+
+      Code.loaded?(mod) and not function_exported?(mod, name, 1) ->
+        # The test module has been loaded, but the test no longer exists.
+        find_deleted_tests(rest, file_existence, [id | acc])
+
+      true ->
+        # The file exists and the test module was not loaded (which means the test
+        # *might* still exist) or the function is exported (which means the test
+        # *definitely* still exists). Either way, we do not want to prune it.
+        find_deleted_tests(rest, file_existence, acc)
+    end
+  end
+end
diff --git a/lib/ex_unit/lib/ex_unit/filters.ex b/lib/ex_unit/lib/ex_unit/filters.ex
index e7708ecffef..9348656b4e6 100644
--- a/lib/ex_unit/lib/ex_unit/filters.ex
+++ b/lib/ex_unit/lib/ex_unit/filters.ex
@@ -1,9 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.Filters do
   @moduledoc """
   Conveniences for parsing and evaluating filters.
   """
+  alias ExUnit.FailuresManifest
+
+  @type t :: list({atom, Regex.t() | String.Chars.t()} | atom)
+  @type location :: {:location, {String.t(), pos_integer | [pos_integer, ...]}}
+  @type ex_unit_opts :: [exclude: [:test], include: [location, ...]] | []
 
-  @type t :: list({atom, Regex.t | String.Chars.t} | atom)
+  # TODO: Remove me on Elixir v2.0
+  @doc false
+  @deprecated "Use parse_paths/1 instead"
+  def parse_path(file_path) do
+    {[parsed_path], ex_unit_opts} = parse_paths([file_path])
+    {parsed_path, ex_unit_opts}
+  end
 
   @doc """
   Parses filters out of a path.
@@ -12,18 +27,53 @@ defmodule ExUnit.Filters do
   on the command line) includes a line number filter, and if so returns the
   appropriate ExUnit configuration options.
   """
-  @spec parse_path(String.t) :: {String.t, any}
-  def parse_path(file) do
-    case Regex.run(~r/^(.+):(\d+)$/, file, capture: :all_but_first) do
-      [file, line_number] ->
-        {file, exclude: [:test], include: [line: line_number]}
-      nil ->
-        {file, []}
+  @spec parse_paths([String.t()]) :: {[String.t()], ex_unit_opts}
+  def parse_paths(file_paths) do
+    {parsed_paths, {lines?, locations}} =
+      Enum.map_reduce(file_paths, {false, []}, fn file_path, {lines?, locations} ->
+        {path, location} = extract_location(file_path)
+        {path, {lines? or is_tuple(location), [{:location, location} | locations]}}
+      end)
+
+    ex_unit_opts =
+      if lines?, do: [exclude: [:test], include: Enum.reverse(locations)], else: []
+
+    {parsed_paths, ex_unit_opts}
+  end
+
+  defp extract_location(file_path) do
+    case Path.relative_to_cwd(file_path) |> String.split(":") do
+      [path] ->
+        {path, path}
+
+      [path | parts] ->
+        {path_parts, line_numbers} = Enum.split_while(parts, &(to_line_number(&1) == nil))
+        path = Enum.join([path | path_parts], ":") |> Path.split() |> Path.join()
+        lines = for n <- line_numbers, valid_number = validate_line_number(n), do: valid_number
+
+        case lines do
+          [] -> {path, path}
+          [line] -> {path, {path, line}}
+          lines -> {path, {path, lines}}
+        end
     end
   end
 
+  defp to_line_number(str) do
+    case Integer.parse(str) do
+      {x, ""} when x > 0 -> x
+      _ -> nil
+    end
+  end
+
+  defp validate_line_number(str) do
+    number = to_line_number(str)
+    number == nil && IO.warn("invalid line number given as ExUnit filter: #{str}", [])
+    number
+  end
+
   @doc """
-  Normalizes include and excludes to remove duplicates
+  Normalizes `include` and `exclude` filters to remove duplicates
   and keep precedence.
 
   ## Examples
@@ -34,12 +84,41 @@ defmodule ExUnit.Filters do
       iex> ExUnit.Filters.normalize([:foo, :bar, :bar], [:foo, :baz])
       {[:foo, :bar], [:baz]}
 
+      iex> ExUnit.Filters.normalize([foo: "true"], [:foo])
+      {[foo: "true"], [:foo]}
+
+      iex> ExUnit.Filters.normalize([:foo], [foo: "true"])
+      {[:foo], []}
+
+      iex> ExUnit.Filters.normalize([foo: "true"], [foo: true])
+      {[foo: "true"], []}
+
+      iex> ExUnit.Filters.normalize([foo: true], [foo: "true"])
+      {[foo: true], []}
+
+      iex> ExUnit.Filters.normalize([foo: 1, foo: 1, foo: 2], [])
+      {[foo: 1, foo: 2], []}
+
+      iex> ExUnit.Filters.normalize([], [foo: 1, foo: 1, foo: 2])
+      {[], [foo: 1, foo: 2]}
+
   """
   @spec normalize(t | nil, t | nil) :: {t, t}
   def normalize(include, exclude) do
-    include = include |> List.wrap |> Enum.uniq
-    exclude = exclude |> List.wrap |> Enum.uniq |> Kernel.--(include)
-    {include, exclude}
+    {include_atoms, include_tags} =
+      include |> List.wrap() |> Enum.uniq() |> Enum.split_with(&is_atom/1)
+
+    {exclude_atoms, exclude_tags} =
+      exclude |> List.wrap() |> Enum.uniq() |> Enum.split_with(&is_atom/1)
+
+    exclude_tags_map = Map.new(exclude_tags)
+
+    exclude_included =
+      for include_tag <- include_tags, key = has_tag(include_tag, exclude_tags_map), do: key
+
+    exclude_tags = exclude_tags |> Keyword.drop(include_atoms) |> Keyword.drop(exclude_included)
+
+    {include_atoms ++ include_tags, (exclude_atoms -- include_atoms) ++ exclude_tags}
   end
 
   @doc """
@@ -48,28 +127,73 @@ defmodule ExUnit.Filters do
   ## Examples
 
       iex> ExUnit.Filters.parse(["foo:bar", "baz", "line:9", "bool:true"])
-      [{:foo, "bar"}, :baz, {:line, "9"}, {:bool, "true"}]
+      [{:foo, "bar"}, :baz, {:line, 9}, {:bool, "true"}]
 
   """
-  @spec parse([String.t]) :: t
+  @spec parse([String.t()]) :: t
   def parse(filters) do
-    Enum.map filters, fn filter ->
-      case String.split(filter, ":", parts: 2) do
-        [key, value] -> {String.to_atom(key), value}
+    Enum.map(filters, fn filter ->
+      case :binary.split(filter, ":") do
+        [key, value] -> parse_kv(String.to_atom(key), value)
         [key] -> String.to_atom(key)
       end
-    end
+    end)
   end
 
+  defp parse_kv(:line, line) when is_binary(line),
+    do: {:line, String.to_integer(line)}
+
+  defp parse_kv(:location, loc) when is_binary(loc),
+    do: {:location, extract_location(loc) |> elem(1)}
+
+  defp parse_kv(key, value), do: {key, value}
+
   @doc """
-  Evaluates the `include` and `exclude` filters against the given `tags`.
+  Returns failure information from the manifest file.
 
-  Some filters, like `:line`, may require the whole test collection to
-  find the closest line, that's why it must also be passed as argument.
+  It returns either `:all`, meaning all tests should be considered as stale,
+  or a tuple containing:
+
+    * A set of files that contain tests that failed the last time they ran.
+      The paths are absolute paths.
+
+    * A set of test IDs that failed the last time they ran
+
+  """
+  @spec failure_info(Path.t()) :: {MapSet.t(Path.t()), MapSet.t(ExUnit.test_id())} | :all
+  def failure_info(manifest_file) do
+    FailuresManifest.info(manifest_file)
+  end
+
+  @doc """
+  Marks the whole suite as failed in the manifest.
+
+  This is useful when the test suite cannot be loaded
+  and there is a desire to make all tests fail.
+  """
+  @spec fail_all!(Path.t()) :: :ok
+  def fail_all!(manifest_file) do
+    FailuresManifest.fail_all!(manifest_file)
+  end
+
+  @doc """
+  Evaluates the `include` and `exclude` filters against the given `tags` to
+  determine if tests should be skipped or excluded.
+
+  Some filters, like `:line`, may require the whole test `collection` to
+  find the closest line, that's why it must also be passed as an argument.
 
   Filters can either be a regular expression or any data structure
-  that implements to `String.Chars`, which is invoked before comparing
-  the filter with the tag value.
+  that implements the `String.Chars` protocol, which is invoked before comparing
+  the filter with the `:tag` value.
+
+  ## Precedence
+
+  Tests are first excluded, then included, and then skipped (if any left).
+
+  If a `:skip` tag is found in `tags`, `{:skipped, message}` is returned if the test
+  remains after the `exclude` and `include` filters. However, if skipped tests are
+  specifically included, then they will always run.
 
   ## Examples
 
@@ -77,33 +201,77 @@ defmodule ExUnit.Filters do
       :ok
 
       iex> ExUnit.Filters.eval([foo: "bar"], [:foo], %{foo: "baz"}, [])
-      {:error, :foo}
+      {:excluded, "due to foo filter"}
 
   """
-  @spec eval(t, t, map, [ExUnit.Test.t]) :: :ok | {:error, atom}
+  @spec eval(t, t, map, [ExUnit.Test.t()]) ::
+          :ok | {:excluded, String.t()} | {:skipped, String.t()}
   def eval(include, exclude, tags, collection) when is_map(tags) do
-    excluded = Enum.find_value exclude, &has_tag(&1, tags, collection)
-    if !excluded or Enum.any?(include, &has_tag(&1, tags, collection)) do
-      :ok
-    else
-      {:error, excluded}
+    cond do
+      Enum.any?(include, &has_tag(&1, tags, collection)) ->
+        maybe_skipped(include, tags, collection)
+
+      excluded = Enum.find_value(exclude, &has_tag(&1, tags, collection)) ->
+        {:excluded, "due to #{excluded} filter"}
+
+      true ->
+        maybe_skipped(include, tags, collection)
     end
   end
 
-  defp has_tag({:line, line}, tags, collection) do
-    line = to_integer(line)
-    tags.line <= line and
-      closest_test_before_line(line, collection).tags.line == tags.line
+  defp maybe_skipped(include, tags, collection) do
+    case tags do
+      %{skip: skip} when is_binary(skip) or skip == true ->
+        skip_tags = %{skip: skip}
+        skip_included_explicitly? = Enum.any?(include, &has_tag(&1, skip_tags, collection))
+
+        cond do
+          skip_included_explicitly? -> :ok
+          is_binary(skip) -> {:skipped, skip}
+          skip -> {:skipped, "due to skip tag"}
+        end
+
+      _ ->
+        :ok
+    end
+  end
+
+  defp has_tag({:location, path}, %{file: file}, _collection) when is_binary(path) do
+    String.ends_with?(file, path)
+  end
+
+  defp has_tag({:location, {path, lines}}, %{line: _, describe_line: _} = tags, collection)
+       when is_binary(path) do
+    String.ends_with?(tags.file, path) and
+      lines |> List.wrap() |> Enum.any?(&has_tag({:line, &1}, tags, collection))
+  end
+
+  defp has_tag({:line, line}, %{line: _, describe_line: _} = tags, collection)
+       when is_integer(line) do
+    cond do
+      tags.describe_line == line ->
+        true
+
+      describe_block?(line, collection) ->
+        false
+
+      true ->
+        tags.line <= line and closest_test_before_line(line, collection).tags.line == tags.line
+    end
+  end
+
+  defp has_tag(pair, tags, _collection) do
+    has_tag(pair, tags)
   end
 
-  defp has_tag({key, %Regex{} = value}, tags, _collection) when is_atom(key) do
+  defp has_tag({key, %Regex{} = value}, tags) when is_atom(key) do
     case Map.fetch(tags, key) do
       {:ok, tag} -> to_string(tag) =~ value and key
       _ -> false
     end
   end
 
-  defp has_tag({key, value}, tags, _collection) when is_atom(key) do
+  defp has_tag({key, value}, tags) when is_atom(key) do
     case Map.fetch(tags, key) do
       {:ok, ^value} -> key
       {:ok, tag} -> compare(to_string(tag), to_string(value)) and key
@@ -111,17 +279,19 @@ defmodule ExUnit.Filters do
     end
   end
 
-  defp has_tag(key, tags, _collection) when is_atom(key),
-    do: Map.has_key?(tags, key) and key
-
-  defp to_integer(integer) when is_integer(integer), do: integer
-  defp to_integer(integer) when is_binary(integer),  do: String.to_integer(integer)
+  defp has_tag(key, tags) when is_atom(key), do: Map.has_key?(tags, key) and key
 
   defp compare("Elixir." <> tag1, tag2), do: compare(tag1, tag2)
   defp compare(tag1, "Elixir." <> tag2), do: compare(tag1, tag2)
   defp compare(tag, tag), do: true
   defp compare(_, _), do: false
 
+  defp describe_block?(line, collection) do
+    Enum.any?(collection, fn %ExUnit.Test{tags: %{describe_line: describe_line}} ->
+      line == describe_line
+    end)
+  end
+
   defp closest_test_before_line(line, collection) do
     Enum.min_by(collection, fn %ExUnit.Test{tags: %{line: test_line}} ->
       if line - test_line >= 0 do
diff --git a/lib/ex_unit/lib/ex_unit/formatter.ex b/lib/ex_unit/lib/ex_unit/formatter.ex
index 0978ccd4721..d79da69eab3 100644
--- a/lib/ex_unit/lib/ex_unit/formatter.ex
+++ b/lib/ex_unit/lib/ex_unit/formatter.ex
@@ -1,242 +1,778 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.Formatter do
   @moduledoc """
-  This module holds helper functions related to formatting and contains
-  documentation about the formatting protocol.
+  Helper functions for formatting and the formatting protocols.
 
-  Formatters are registered at the `ExUnit.EventManager` event manager and
-  will be send events by the runner.
+  Formatters are `GenServer`s specified during ExUnit configuration
+  that receive a series of events as casts.
 
   The following events are possible:
 
     * `{:suite_started, opts}` -
-          the suite has started with the specified options to the runner.
+      the suite has started with the specified options to the runner.
+
+    * `{:suite_finished, times_us}` -
+      the suite has finished. Returns several measurements in microseconds
+      for running the suite. See `t:times_us` for more information.
+
+    * `{:module_started, test_module}` -
+      a test module has started. See `ExUnit.TestModule` for details.
+
+    * `{:module_finished, test_module}` -
+      a test module has finished. See `ExUnit.TestModule` for details.
+
+    * `{:test_started, test}` -
+      a test has started. See `ExUnit.Test` for details.
+
+    * `{:test_finished, test}` -
+      a test has finished. See `ExUnit.Test` for details.
 
-    * `{:suite_finished, run_us, load_us}` -
-          the suite has finished. `run_us` and `load_us` are the run and load
-          times in microseconds respectively.
+    * `{:sigquit, [test | test_module]}` -
+      the VM is going to shutdown. It receives the test cases (or test
+      module in case of `setup_all`) still running.
 
-    * `{:case_started, test_case}` -
-          a test case has started. See `ExUnit.TestCase` for details.
+    * `:max_failures_reached` -
+      the test run has been aborted due to reaching max failures limit set
+      with `:max_failures` option
 
-    * `{:case_finished, test_case}` -
-          a test case has finished. See `ExUnit.TestCase` for details.
+  The formatter will also receive the following events but they are deprecated
+  and should be ignored:
 
-    * `{:test_started, test_case}` -
-          a test case has started. See `ExUnit.Test` for details.
+    * `{:case_started, test_module}` -
+      a test module has started. See `ExUnit.TestModule` for details.
 
-    * `{:test_finished, test_case}` -
-          a test case has finished. See `ExUnit.Test` for details.
+    * `{:case_finished, test_module}` -
+      a test module has finished. See `ExUnit.TestModule` for details.
 
+  The full ExUnit configuration is passed as the argument to `c:GenServer.init/1`
+  callback when the formatters are started. If you need to do runtime configuration
+  of a formatter, you can add any configuration needed by using `ExUnit.configure/1`
+  or `ExUnit.start/1`, and this will then be included in the options passed to
+  the `c:GenServer.init/1` callback.
   """
 
   @type id :: term
-  @type test_case :: ExUnit.TestCase.t
-  @type test :: ExUnit.Test.t
-  @type run_us :: pos_integer
-  @type load_us :: pos_integer | nil
+  @type test :: ExUnit.Test.t()
 
-  import Exception, only: [format_stacktrace_entry: 1]
+  @typedoc """
+  The times spent on several parts of the test suite.
 
-  @label_padding   "      "
-  @counter_padding "     "
-  @inspect_padding @counter_padding <> @label_padding
+  The following properties can be computed:
 
-  @doc """
-  Formats time taken running the test suite.
+      sync = run - (async || 0)
+      total = run + (load || 0)
+
+  `async` is nil when there are no async tests.
+  `load` is nil when the test suite is running and loading
+  tests concurrently.
+  """
+  @type times_us :: %{
+          run: pos_integer,
+          async: pos_integer | nil,
+          load: pos_integer | nil
+        }
+
+  @typedoc """
+  Key passed to a formatter callback to format a diff.
+
+  See `t:formatter_callback/0`.
+  """
+  @typedoc since: "1.16.0"
+  @type formatter_callback_diff_key ::
+          :diff_delete
+          | :diff_delete_whitespace
+          | :diff_insert
+          | :diff_insert_whitespace
+
+  @typedoc """
+  Key passed to a formatter callback to format information.
+
+  See `t:formatter_callback/0`.
+  """
+  @typedoc since: "1.16.0"
+  @type formatter_callback_info_key ::
+          :extra_info
+          | :error_info
+          | :test_module_info
+          | :test_info
+          | :parameters_info
+          | :location_info
+          | :stacktrace_info
+          | :blame_diff
+
+  @typedoc """
+  A function that this module calls to format various things.
+
+  You can pass this functions to various functions in this module, and use it
+  to customize the formatting of the output. For example, ExUnit's CLI formatter
+  uses this callback to colorize output.
+
+  ## Keys
+
+  The possible keys are:
 
-  It receives the time spent running the tests and
-  optionally the time spent loading the test suite.
+    * `:diff_enabled?` - whether diffing is enabled. It receives a boolean
+      indicating whether diffing is enabled by default and returns a boolean
+      indicating whether diffing should be enabled for the current test.
+
+    * `:diff_delete` and `:diff_delete_whitespace` - Should format a diff deletion,
+      with or without whitespace respectively.
+
+    * `:diff_insert` and `:diff_insert_whitespace` - Should format a diff insertion,
+      with or without whitespace respectively.
+
+    * `:extra_info` - Should format optional extra labels, such as the `"code: "` label
+      that precedes code to show.
+
+    * `:error_info` - Should format error information.
+
+    * `:test_module_info` - Should format test module information. The message returned
+    when this key is passed precedes messages such as `"failure on setup_all callback [...]"`.
+
+    * `:test_info` - Should format test information.
+
+    * `:parameters_info` - Should format test parameters.
+
+    * `:location_info` - Should format test location information.
+
+    * `:stacktrace_info` - Should format stacktrace information.
+
+    * `:blame_diff` - Should format a string of code.
 
   ## Examples
 
-      iex> format_time(10000, nil)
-      "Finished in 0.01 seconds"
+  For example, to format errors as *red strings* and everything else as is, you could define
+  a formatter callback function like this:
 
-      iex> format_time(10000, 20000)
-      "Finished in 0.03 seconds (0.02s on load, 0.01s on tests)"
+      formatter_callback = fn
+        :error_info, msg -> [:red, msg, :reset] |> IO.ANSI.format() |> IO.iodata_to_binary()
+        _key, value -> value
+      end
 
-      iex> format_time(10000, 200000)
-      "Finished in 0.2 seconds (0.2s on load, 0.01s on tests)"
+  """
+  @typedoc since: "1.16.0"
+  @type formatter_callback ::
+          (:diff_enabled?, boolean -> boolean)
+          | (formatter_callback_diff_key, Inspect.Algebra.t() -> Inspect.Algebra.t())
+          | (formatter_callback_info_key, String.t() -> String.t())
+
+  @typedoc """
+  Width for formatting.
 
+  For example, see `format_assertion_diff/4`.
   """
-  @spec format_time(run_us, load_us) :: String.t
-  def format_time(run_us, nil) do
-    "Finished in #{run_us |> normalize_us |> format_us} seconds"
-  end
+  @typedoc since: "1.16.0"
+  @type width :: non_neg_integer | :infinity
 
-  def format_time(run_us, load_us) do
-    run_us  = run_us |> normalize_us
-    load_us = load_us |> normalize_us
+  import Exception, only: [format_stacktrace_entry: 1, format_file_line: 3]
 
-    ms = run_us + load_us
-    "Finished in #{format_us ms} seconds (#{format_us load_us}s on load, #{format_us run_us}s on tests)"
-  end
+  alias ExUnit.Diff
+  alias Inspect.Algebra
+
+  @counter_padding "     "
+  @mailbox_label_padding @counter_padding <> "  "
+  @formatter_exceptions [ExUnit.AssertionError, FunctionClauseError]
+  @no_value ExUnit.AssertionError.no_value()
 
-  defp normalize_us(us) do
-    div(us, 10000)
+  @doc """
+  Formats time taken running the test suite.
+
+  ## Examples
+
+      iex> format_times(%{run: 10_000, async: nil, load: nil})
+      "Finished in 0.01 seconds (0.00s async, 0.01s sync)"
+
+      iex> format_times(%{run: 10_000, async: nil, load: 20_000})
+      "Finished in 0.03 seconds (0.02s on load, 0.00s async, 0.01s sync)"
+
+      iex> format_times(%{run: 10_000, async: nil, load: 200_000})
+      "Finished in 0.2 seconds (0.2s on load, 0.00s async, 0.01s sync)"
+
+      iex> format_times(%{run: 100_000, async: 50_000, load: 200_000})
+      "Finished in 0.3 seconds (0.2s on load, 0.05s async, 0.05s sync)"
+
+  """
+  @spec format_times(times_us) :: String.t()
+  def format_times(times) do
+    run_us = normalize_us(times.run)
+    load_us = normalize_us(times.load)
+    async_us = normalize_us(times.async)
+    sync_us = run_us - async_us
+    total_us = run_us + load_us
+
+    maybe_load =
+      if times.load do
+        "#{format_us(load_us)}s on load, "
+      else
+        ""
+      end
+
+    "Finished in #{format_us(total_us)} seconds " <>
+      "(#{maybe_load}#{format_us(async_us)}s async, #{format_us(sync_us)}s sync)"
   end
 
+  defp normalize_us(nil), do: 0
+  defp normalize_us(us), do: div(us, 10_000)
+
   defp format_us(us) do
     if us < 10 do
       "0.0#{us}"
     else
-      us = div us, 10
+      us = div(us, 10)
       "#{div(us, 10)}.#{rem(us, 10)}"
     end
   end
 
+  @doc false
+  @deprecated "Use format_times/1 instead"
+  def format_time(run, load) do
+    format_times(%{run: run, load: load, async: nil})
+  end
+
   @doc """
-  Formats filters used to constain cases to be run.
+  Formats filters used to constrain cases to be run.
 
   ## Examples
 
-    iex> format_filters([run: true, slow: false], :include)
-    "Including tags: [run: true, slow: false]"
+      iex> format_filters([run: true, slow: false], :include)
+      "Including tags: [run: true, slow: false]"
+
+      iex> format_filters([list: [61, 62, 63]], :exclude)
+      "Excluding tags: [list: [61, 62, 63]]"
 
   """
-  @spec format_filters(Keyword.t, atom) :: String.t
+  @spec format_filters(keyword, atom) :: String.t()
   def format_filters(filters, type) do
     case type do
-      :include -> "Including tags: #{inspect filters}"
-      :exclude -> "Excluding tags: #{inspect filters}"
+      :exclude -> "Excluding tags: #{inspect(filters, charlists: :as_lists)}"
+      :include -> "Including tags: #{inspect(filters, charlists: :as_lists)}"
     end
   end
 
-  @doc """
-  Receives a test and formats its failure.
+  @doc ~S"""
+  Receives a test and formats its failures.
+
+  ## Examples
+
+      iex> failure = {:error, catch_error(raise "oops"), _stacktrace = []}
+      iex> formatter_cb = fn _key, value -> value end
+      iex> test = %ExUnit.Test{name: :"it works", module: MyTest, tags: %{file: "file.ex", line: 7}}
+      iex> format_test_failure(test, [failure], 1, 80, formatter_cb)
+      "  1) it works (MyTest)\n     file.ex:7\n     ** (RuntimeError) oops\n"
+
+  """
+  @spec format_test_failure(
+          test,
+          [failure],
+          non_neg_integer,
+          width,
+          formatter_callback
+        ) :: String.t()
+        when failure: {atom, term, Exception.stacktrace()}
+  def format_test_failure(test, failures, counter, width, formatter) do
+    %ExUnit.Test{name: name, module: module, tags: tags, parameters: parameters} = test
+
+    test_info(with_counter(counter, "#{name} (#{inspect(module)})"), formatter) <>
+      test_parameters(parameters, formatter) <>
+      test_location(with_location(tags), formatter) <>
+      Enum.map_join(Enum.with_index(failures), "", fn {{kind, reason, stack}, index} ->
+        {text, stack} = format_kind_reason(test, kind, reason, stack, width, formatter)
+
+        failure_header(failures, index) <>
+          text <> format_stacktrace(stack, module, name, formatter)
+      end)
+  end
+
+  @doc false
+  @deprecated "Use ExUnit.Formatter.format_test_all_failure/5 instead"
+  def format_test_case_failure(test_case, failures, counter, width, formatter) do
+    format_test_all_failure(test_case, failures, counter, width, formatter)
+  end
+
+  @doc ~S"""
+  Receives a test module and formats its failure.
+
+  ## Examples
+
+      iex> failure = {:error, catch_error(raise "oops"), _stacktrace = []}
+      iex> formatter_cb = fn _key, value -> value end
+      iex> test_module = %ExUnit.TestModule{name: Hello}
+      iex> format_test_all_failure(test_module, [failure], 1, 80, formatter_cb)
+      "  1) Hello: failure on setup_all callback, all tests have been invalidated\n     ** (RuntimeError) oops\n"
+
   """
-  def format_test_failure(test, {kind, reason, stack}, counter, width, formatter) do
-    %ExUnit.Test{name: name, case: case, tags: tags} = test
-    test_info(with_counter(counter, "#{name} (#{inspect case})"), formatter)
-      <> test_location(with_location(tags), formatter)
-      <> format_kind_reason(kind, reason, width, formatter)
-      <> format_stacktrace(stack, case, name, formatter)
+  @spec format_test_all_failure(
+          ExUnit.TestModule.t(),
+          [failure],
+          non_neg_integer,
+          width,
+          formatter_callback
+        ) :: String.t()
+        when failure: {atom, term, Exception.stacktrace()}
+  def format_test_all_failure(test_module, failures, counter, width, formatter) do
+    %{name: name, parameters: parameters} = test_module
+
+    test_module_info(with_counter(counter, "#{inspect(name)}: "), formatter) <>
+      test_parameters(parameters, formatter) <>
+      Enum.map_join(Enum.with_index(failures), "", fn {{kind, reason, stack}, index} ->
+        {text, stack} = format_kind_reason(test_module, kind, reason, stack, width, formatter)
+        failure_header(failures, index) <> text <> format_stacktrace(stack, name, nil, formatter)
+      end)
+  end
+
+  ## kind/reason formatting
+
+  defp format_kind_reason(test, :error, %mod{} = struct, stack, width, formatter)
+       when mod in @formatter_exceptions do
+    format_exception(test, struct, stack, width, formatter, @counter_padding)
+  end
+
+  defp format_kind_reason(test, kind, reason, stack, width, formatter) do
+    case linked_or_trapped_exit(kind, reason) do
+      {header, wrapped_reason, wrapped_stack} ->
+        struct = Exception.normalize(:error, wrapped_reason, wrapped_stack)
+
+        {formatted_reason, wrapped_stack} =
+          format_exception(test, struct, wrapped_stack, width, formatter, @counter_padding)
+
+        formatted_stack = format_stacktrace(wrapped_stack, test, formatter)
+
+        {error_info(header, formatter) <> pad(formatted_reason <> formatted_stack), stack}
+
+      :error ->
+        {reason, stack} = Exception.blame(kind, reason, stack)
+        message = error_info(Exception.format_banner(kind, reason), formatter)
+        {message <> format_code(test, stack, formatter), stack}
+    end
+  end
+
+  defp linked_or_trapped_exit({:EXIT, pid}, {reason, [_ | _] = stack})
+       when reason.__struct__ in @formatter_exceptions
+       when reason == :function_clause do
+    {"** (EXIT from #{inspect(pid)}) an exception was raised:\n", reason, stack}
+  end
+
+  defp linked_or_trapped_exit(:exit, {{reason, [_ | _] = stack}, {mod, fun, args}})
+       when is_atom(mod) and is_atom(fun) and is_list(args) and
+              reason.__struct__ in @formatter_exceptions
+       when is_atom(mod) and is_atom(fun) and is_list(args) and reason == :function_clause do
+    {
+      "** (exit) exited in: #{Exception.format_mfa(mod, fun, args)}\n   ** (EXIT) an exception was raised:",
+      reason,
+      stack
+    }
+  end
+
+  defp linked_or_trapped_exit(_kind, _reason), do: :error
+
+  defp format_exception(test, %ExUnit.AssertionError{} = struct, stack, width, formatter, pad) do
+    label_padding_size = if has_value?(struct.right), do: 7, else: 6
+    padding_size = label_padding_size + byte_size(@counter_padding)
+
+    code_multiline =
+      if struct.doctest != @no_value,
+        do: &pad_multiline(&1, padding_size),
+        else: &code_multiline(&1, padding_size)
+
+    formatted =
+      [
+        message: if_value(struct.message, &format_message(&1, formatter)),
+        doctest: if_value(struct.doctest, &pad_multiline(&1, 2 + byte_size(@counter_padding))),
+        code: if_value(struct.expr, code_multiline, fn -> get_code(test, stack) || @no_value end),
+        arguments: if_value(struct.args, &format_args(&1, width))
+      ]
+      |> Kernel.++(format_assertion_diff(struct, padding_size, width, formatter))
+      |> format_meta(formatter, pad, label_padding_size)
+      |> IO.iodata_to_binary()
+
+    {formatted, stack}
+  end
+
+  defp format_exception(test, %FunctionClauseError{} = struct, stack, _width, formatter, _pad) do
+    {blamed, stack} = Exception.blame(:error, struct, stack)
+    banner = Exception.format_banner(:error, struct)
+    blamed = FunctionClauseError.blame(blamed, &inspect/1, &blame_match(&1, formatter))
+    message = error_info(banner, formatter) <> "\n" <> pad(String.trim_leading(blamed, "\n"))
+    {message <> format_code(test, stack, formatter), stack}
+  end
+
+  ## Assertion error and diffing
+
+  @doc false
+  def format_assertion_error(%ExUnit.AssertionError{} = struct) do
+    format_exception(%{}, struct, [], :infinity, fn _, msg -> msg end, "") |> elem(0)
   end
 
   @doc """
-  Receives a test case and formats its failure.
+  Formats `ExUnit.AssertionError` diff.
+
+  It returns a keyword list with diffing information
+  from the left and right side of the assertion, if
+  any exists.
+
+  It expects the assertion error, the `padding_size`
+  for formatted content, the width (may be `:infinity`),
+  and the formatter callback function.
+
+  ## Examples
+
+      iex> error = assert_raise ExUnit.AssertionError, fn -> assert [1, 2] == [1, 3] end
+      iex> formatter_cb = fn
+      ...>   :diff_enabled?, _ -> true
+      ...>   _key, value -> value
+      ...> end
+      iex> keyword = format_assertion_diff(error, 5, 80, formatter_cb)
+      iex> for {key, val} <- keyword, do: {key, IO.iodata_to_binary(val)}
+      [left: "[1, 2]", right: "[1, 3]"]
+
   """
-  def format_test_case_failure(test_case, {kind, reason, stacktrace}, counter, width, formatter) do
-    %ExUnit.TestCase{name: name} = test_case
-    test_case_info(with_counter(counter, "#{inspect name}: "), formatter)
-      <> format_kind_reason(kind, reason, width, formatter)
-      <> format_stacktrace(stacktrace, name, nil, formatter)
+  @spec format_assertion_diff(
+          ExUnit.AssertionError.t(),
+          non_neg_integer,
+          width,
+          formatter_callback
+        ) :: keyword
+  def format_assertion_diff(assert_error, padding_size, width, formatter)
+
+  def format_assertion_diff(%ExUnit.AssertionError{context: {:mailbox, _pins, []}}, _, _, _) do
+    []
   end
 
-  defp format_kind_reason(:error, %ExUnit.AssertionError{} = struct, width, formatter) do
-    width = if width == :infinity, do: width, else: width - byte_size(@inspect_padding)
+  def format_assertion_diff(
+        %ExUnit.AssertionError{left: left, context: {:mailbox, pins, mailbox}},
+        padding_size,
+        width,
+        formatter
+      ) do
+    formatted_mailbox =
+      for message <- mailbox do
+        {pattern, value, _warnings} =
+          format_sides(left, message, {:match, pins}, formatter, padding_size + 5, width)
+
+        [
+          "\n",
+          @mailbox_label_padding,
+          format_label(:pattern, formatter, 9),
+          pattern,
+          "\n",
+          @mailbox_label_padding,
+          format_label(:value, formatter, 9),
+          value
+        ]
+      end
+
+    [mailbox: Enum.join(formatted_mailbox, "\n")]
+  end
+
+  def format_assertion_diff(
+        %ExUnit.AssertionError{left: left, right: right, context: context},
+        padding_size,
+        width,
+        formatter
+      ) do
+    {left, right, extras} = format_sides(left, right, context, formatter, padding_size, width)
+    for {k, v} <- [left: left, right: right] ++ extras, has_value?(v), do: {k, v}
+  end
+
+  defp format_sides(left, right, context, formatter, padding_size, width) do
+    inspect = &inspect_multiline(&1, padding_size, width)
+    content_width = if width == :infinity, do: width, else: width - padding_size
+
+    case format_diff(left, right, context, formatter) do
+      {nil, hints} when is_atom(context) ->
+        {if_value(left, inspect), if_value(right, inspect), hints}
+
+      {nil, hints} ->
+        left =
+          Macro.prewalk(left, fn
+            {_, [original: original], _} -> original
+            other -> other
+          end)
+
+        {if_value(left, &code_multiline(&1, padding_size)), if_value(right, inspect), hints}
+
+      {result, hints} ->
+        left =
+          result.left
+          |> Diff.to_algebra(&colorize_diff_delete(&1, formatter))
+          |> Algebra.nest(padding_size)
+          |> Algebra.format(content_width)
+
+        right =
+          result.right
+          |> Diff.to_algebra(&colorize_diff_insert(&1, formatter))
+          |> Algebra.nest(padding_size)
+          |> Algebra.format(content_width)
+
+        {left, right, hints}
+    end
+  end
 
-    fields =
-      [note: if_value(struct.message, &format_banner(&1, formatter)),
-       code: if_value(struct.expr, &code_multiline(&1, width)),
-       lhs:  if_value(struct.left,  &inspect_multiline(&1, width)),
-       rhs:  if_value(struct.right, &inspect_multiline(&1, width))]
+  defp format_diff(left, right, context, formatter) do
+    if has_value?(left) and has_value?(right) do
+      case find_diff(left, right, context) do
+        {result, env} ->
+          result = if formatter.(:diff_enabled?, false), do: result
+          hints = Enum.map(env.hints, &{:hint, format_hint(&1)})
+          {result, hints}
+
+        nil ->
+          {nil, []}
+      end
+    else
+      {nil, []}
+    end
+  end
 
-    fields
-    |> filter_interesting_fields
-    |> format_each_reason(formatter)
-    |> make_into_lines(@counter_padding)
+  defp format_hint(:equivalent_but_different_strings) do
+    "you are comparing strings that have the same visual representation but are made of different Unicode codepoints"
   end
 
-  defp format_kind_reason(kind, reason, _width, formatter) do
-    error_info Exception.format_banner(kind, reason), formatter
+  defp colorize_diff_delete(doc, formatter) do
+    format = colorize_format(doc, :diff_delete, :diff_delete_whitespace)
+    formatter.(format, doc)
   end
 
-  defp filter_interesting_fields(fields) do
-    Enum.filter(fields, fn {_, value} ->
-      value != ExUnit.AssertionError.no_value
-    end)
+  defp colorize_diff_insert(doc, formatter) do
+    format = colorize_format(doc, :diff_insert, :diff_insert_whitespace)
+    formatter.(format, doc)
   end
 
-  defp format_each_reason(reasons, formatter) do
-    Enum.map(reasons, fn {label, value} ->
-      format_label(label, formatter) <> value
-    end)
+  defp colorize_format(content, normal, whitespace) when is_binary(content) do
+    if String.trim_leading(content) == "", do: whitespace, else: normal
+  end
+
+  defp colorize_format(_doc, normal, _whitespace) do
+    normal
+  end
+
+  defp find_diff(left, right, context) do
+    task = Task.async(Diff, :compute, [left, right, context])
+
+    case Task.yield(task, 1500) || Task.shutdown(task, :brutal_kill) do
+      {:ok, diff} -> diff
+      nil -> nil
+    end
+  end
+
+  ## Helpers
+
+  defp format_code(test, stack, formatter) do
+    if snippet = get_code(test, stack) do
+      "     " <> formatter.(:extra_info, "code: ") <> snippet <> "\n"
+    else
+      ""
+    end
+  end
+
+  defp get_code(%{module: module, name: name}, stack) do
+    info =
+      Enum.find_value(stack, fn
+        {^module, ^name, _, info} -> info
+        _ -> nil
+      end)
+
+    file = info[:file]
+    line = info[:line]
+
+    if line > 0 && file && File.exists?(file) do
+      file |> File.stream!() |> Enum.at(line - 1) |> String.trim()
+    end
+  rescue
+    _ -> nil
+  end
+
+  defp get_code(%{}, _) do
+    nil
+  end
+
+  defp blame_match(%{match?: true, node: node}, _formatter),
+    do: Macro.to_string(node)
+
+  defp blame_match(%{match?: false, node: node}, formatter),
+    do: formatter.(:blame_diff, Macro.to_string(node))
+
+  defp format_meta(fields, formatter, padding, padding_size) do
+    for {label, value} <- fields, has_value?(value) do
+      [padding, format_label(label, formatter, padding_size), value, "\n"]
+    end
   end
 
   defp if_value(value, fun) do
-    if value == ExUnit.AssertionError.no_value do
+    if has_value?(value) do
+      fun.(value)
+    else
       value
+    end
+  end
+
+  defp if_value(value, do_fun, else_fun) do
+    if has_value?(value) do
+      do_fun.(value)
     else
-      fun.(value)
+      else_fun.()
     end
   end
 
-  defp format_label(:note, _formatter) do
-    ""
+  defp has_value?(value) do
+    value != @no_value
   end
 
-  defp format_label(label, formatter) do
-    formatter.(:error_info, String.ljust("#{label}:", byte_size(@label_padding)))
+  defp format_label(:message, _formatter, _padding_size), do: ""
+
+  defp format_label(label, formatter, padding_size) do
+    formatter.(:extra_info, String.pad_trailing("#{label}:", padding_size))
   end
 
-  defp format_banner(value, formatter) do
-    formatter.(:error_info, value)
+  defp format_message(value, formatter) do
+    value = pad_multiline(value, 5)
+
+    if String.contains?(value, IO.ANSI.reset()) do
+      value
+    else
+      formatter.(:error_info, value)
+    end
   end
 
-  defp code_multiline(expr, _width) when is_binary(expr) do
-    expr
-    |> String.replace("\n", "\n" <> @inspect_padding)
+  defp format_args(args, width) do
+    entries =
+      for {arg, i} <- Enum.with_index(args, 1) do
+        """
+
+                 # #{i}
+                 #{inspect_multiline(arg, 9, width)}
+        """
+      end
+
+    ["\n" | entries]
   end
 
-  defp code_multiline(expr, width) do
-    code_multiline(expr |> Macro.to_string, width)
+  @assertions [
+    :assert,
+    :assert_raise,
+    :assert_receive,
+    :assert_received,
+    :refute,
+    :refute_receive,
+    :refute_received
+  ]
+
+  defp code_multiline({fun, _, [expr]}, padding_size) when fun in @assertions do
+    pad_multiline(Atom.to_string(fun) <> " " <> Macro.to_string(expr), padding_size)
   end
 
-  defp inspect_multiline(expr, width) do
-    expr
-    |> inspect(pretty: true, width: width)
-    |> String.replace("\n", "\n" <> @inspect_padding)
+  defp code_multiline(expr, padding_size) do
+    pad_multiline(Macro.to_string(expr), padding_size)
   end
 
-  defp make_into_lines(reasons, padding) do
-    padding <> Enum.join(reasons, "\n" <> padding) <> "\n"
+  defp inspect_multiline(expr, padding_size, width) do
+    width = if width == :infinity, do: width, else: width - padding_size
+
+    expr
+    |> Algebra.to_doc(%Inspect.Opts{width: width})
+    |> Algebra.group()
+    |> Algebra.nest(padding_size)
+    |> Algebra.format(width)
   end
 
-  defp format_stacktrace([], _case, _test, _color) do
+  defp format_stacktrace(stack, %{module: module, name: name}, color),
+    do: format_stacktrace(stack, module, name, color)
+
+  defp format_stacktrace(stack, %{name: name}, color),
+    do: format_stacktrace(stack, name, nil, color)
+
+  defp format_stacktrace([], _module, _test, _color) do
     ""
   end
 
-  defp format_stacktrace(stacktrace, test_case, test, color) do
+  defp format_stacktrace(stacktrace, module, test, color) do
     extra_info("stacktrace:", color) <>
-      Enum.map_join(stacktrace,
-        fn(s) -> stacktrace_info format_stacktrace_entry(s, test_case, test), color end)
+      Enum.map_join(stacktrace, fn entry ->
+        stacktrace_info(format_stacktrace_entry(entry, module, test), color)
+      end)
   end
 
-  defp format_stacktrace_entry({test_case, test, _, location}, test_case, test) do
-    "#{location[:file]}:#{location[:line]}"
+  defp format_stacktrace_entry({module, test, _, location}, module, test) do
+    format_file_line(location[:file], location[:line], " (test)")
   end
 
-  defp format_stacktrace_entry(s, _test_case, _test) do
-    format_stacktrace_entry(s)
+  defp format_stacktrace_entry(entry, _module, _test) do
+    format_stacktrace_entry(entry)
   end
 
   defp with_location(tags) do
-    "#{Path.relative_to_cwd(tags[:file])}:#{tags[:line]}"
+    path = "#{Path.relative_to_cwd(tags[:file])}:#{tags[:line]}"
+
+    if prefix = Application.get_env(:ex_unit, :test_location_relative_path) do
+      Path.join(prefix, path)
+    else
+      path
+    end
+  end
+
+  defp failure_header([_], _), do: ""
+  defp failure_header(_, i), do: "\n#{@counter_padding}Failure ##{i + 1}\n"
+
+  defp with_counter(counter, msg) when counter < 10 do
+    "  #{counter}) #{msg}"
+  end
+
+  defp with_counter(counter, msg) when counter < 100 do
+    " #{counter}) #{msg}"
   end
 
-  defp with_counter(counter, msg) when counter < 10  do "  #{counter}) #{msg}" end
-  defp with_counter(counter, msg) when counter < 100 do  " #{counter}) #{msg}" end
-  defp with_counter(counter, msg)                    do   "#{counter}) #{msg}" end
+  defp with_counter(counter, msg) do
+    "#{counter}) #{msg}"
+  end
+
+  defp test_module_info(msg, nil),
+    do: msg <> "failure on setup_all callback, all tests have been invalidated\n"
 
-  defp test_case_info(msg, nil),       do: msg <> "failure on setup_all callback, tests invalidated\n"
-  defp test_case_info(msg, formatter), do: test_case_info(formatter.(:test_case_info, msg), nil)
+  defp test_module_info(msg, formatter),
+    do: test_module_info(formatter.(:test_module_info, msg), nil)
 
-  defp test_info(msg, nil),       do: msg <> "\n"
+  defp test_info(msg, nil), do: msg <> "\n"
   defp test_info(msg, formatter), do: test_info(formatter.(:test_info, msg), nil)
 
-  defp test_location(msg, nil),       do: "     " <> msg <> "\n"
+  defp test_parameters(params, _formatter) when params == %{}, do: ""
+  defp test_parameters(params, nil) when is_binary(params), do: "     " <> params <> "\n"
+
+  defp test_parameters(params, nil) when is_map(params),
+    do: test_parameters("Parameters: #{inspect(params)}", nil)
+
+  defp test_parameters(params, formatter),
+    do: test_parameters(formatter.(:parameters_info, params), nil)
+
+  defp test_location(msg, nil), do: "     " <> msg <> "\n"
   defp test_location(msg, formatter), do: test_location(formatter.(:location_info, msg), nil)
 
-  defp error_info(msg, nil) do
-    "     " <> String.replace(msg, "\n", "\n     ") <> <<"\n">>
+  defp pad(msg) do
+    "     " <> pad_multiline(msg, 5) <> "\n"
   end
 
-  defp error_info(msg, formatter), do: error_info(formatter.(:error_info, msg), nil)
+  defp pad_multiline(expr, padding_size) when is_binary(expr) do
+    expr
+    |> String.split("\n")
+    |> pad_line("\n" <> String.duplicate(" ", padding_size))
+    |> IO.iodata_to_binary()
+  end
+
+  defp pad_line([last], _padding), do: [last]
+  defp pad_line([first, "" | rest], padding), do: [first, "\n" | pad_line(["" | rest], padding)]
+  defp pad_line([first | rest], padding), do: [first, padding | pad_line(rest, padding)]
+
+  defp error_info(msg, nil), do: pad(msg)
+  defp error_info(msg, formatter), do: pad(formatter.(:error_info, msg))
+
+  defp extra_info(msg, nil), do: pad(msg)
+  defp extra_info(msg, formatter), do: pad(formatter.(:extra_info, msg))
 
-  defp extra_info(msg, nil),       do: "     " <> msg <> "\n"
-  defp extra_info(msg, formatter), do: extra_info(formatter.(:extra_info, msg), nil)
+  defp stacktrace_info("", _formatter), do: ""
+  defp stacktrace_info(msg, nil), do: "       " <> msg <> "\n"
 
-  defp stacktrace_info(msg, nil),       do: "       " <> msg <> "\n"
-  defp stacktrace_info(msg, formatter), do: stacktrace_info(formatter.(:stacktrace_info, msg), nil)
+  defp stacktrace_info(msg, formatter),
+    do: stacktrace_info(formatter.(:stacktrace_info, msg), nil)
 end
diff --git a/lib/ex_unit/lib/ex_unit/on_exit_handler.ex b/lib/ex_unit/lib/ex_unit/on_exit_handler.ex
index 773e702555a..893a29bac85 100644
--- a/lib/ex_unit/lib/ex_unit/on_exit_handler.ex
+++ b/lib/ex_unit/lib/ex_unit/on_exit_handler.ex
@@ -1,59 +1,119 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.OnExitHandler do
   @moduledoc false
-  @name __MODULE__
 
-  def start_link do
-    Agent.start_link(fn -> %{} end, name: @name)
-  end
+  # ETS table name stored in ExUnit.Server
+  @name ExUnit.Server
+
+  # ETS column numbers
+  @supervisor 2
+  @on_exit 3
 
   @spec register(pid) :: :ok
-  def register(pid) do
-    Agent.update(@name, &Map.put(&1, pid, []))
+  def register(pid) when is_pid(pid) do
+    :ets.insert(@name, {pid, nil, []})
+    :ok
   end
 
-  @spec add(pid, term, fun) :: :ok | :error
-  def add(pid, ref, callback) do
-    Agent.get_and_update(@name, fn map ->
-      if entries = Map.get(map, pid) do
-        entries = List.keystore(entries, ref, 0, {ref, callback})
-        {:ok, Map.put(map, pid, entries)}
-      else
-        {:error, map}
-      end
-    end)
+  @spec add(pid, term, (-> term)) :: :ok | :error
+  def add(pid, name_or_ref, callback) when is_pid(pid) and is_function(callback, 0) do
+    try do
+      :ets.lookup_element(@name, pid, @on_exit)
+    rescue
+      _ -> :error
+    else
+      entries ->
+        entries = List.keystore(entries, name_or_ref, 0, {name_or_ref, callback})
+        true = :ets.update_element(@name, pid, {@on_exit, entries})
+        :ok
+    end
   end
 
-  @spec run(pid) :: :ok | {Exception.kind, term, Exception.stacktrace}
-  def run(pid) do
-    callbacks = Agent.get_and_update(@name, &Map.pop(&1, pid))
-    exec_on_exit_callbacks(Enum.reverse(callbacks))
+  @spec get_supervisor(pid) :: {:ok, pid | nil} | :error
+  def get_supervisor(pid) when is_pid(pid) do
+    try do
+      {:ok, :ets.lookup_element(@name, pid, @supervisor)}
+    rescue
+      _ -> :error
+    end
   end
 
-  defp exec_on_exit_callbacks(callbacks) do
-    {runner_pid, runner_monitor, state} =
-      Enum.reduce callbacks, {nil, nil, nil}, &exec_on_exit_callback/2
+  @spec put_supervisor(pid, pid) :: :ok | :error
+  def put_supervisor(pid, sup) when is_pid(pid) and is_pid(sup) do
+    case :ets.update_element(@name, pid, {@supervisor, sup}) do
+      true -> :ok
+      false -> :error
+    end
+  end
+
+  @spec run(pid, timeout) :: :ok | {Exception.kind(), term, Exception.stacktrace()}
+  def run(pid, timeout) when is_pid(pid) do
+    [{^pid, sup, callbacks}] = :ets.take(@name, pid)
+    error = terminate_supervisor(sup, timeout)
+    exec_on_exit_callbacks(Enum.reverse(callbacks), timeout, error)
+  end
+
+  defp terminate_supervisor(nil, _timeout), do: nil
+
+  defp terminate_supervisor(sup, timeout) do
+    ref = Process.monitor(sup)
+
+    receive do
+      {:DOWN, ^ref, _, _, _} -> nil
+    after
+      timeout ->
+        {:error, ExUnit.TimeoutError.exception(timeout: timeout, type: "supervisor shutdown"), []}
+    end
+  end
+
+  defp exec_on_exit_callbacks(callbacks, timeout, error) do
+    {runner_pid, runner_monitor, error} =
+      Enum.reduce(callbacks, {nil, nil, error}, &exec_on_exit_callback(&1, timeout, &2))
 
     if is_pid(runner_pid) and Process.alive?(runner_pid) do
-      send(runner_pid, :shutdown)
+      Process.exit(runner_pid, :shutdown)
+
       receive do
         {:DOWN, ^runner_monitor, :process, ^runner_pid, _error} -> :ok
       end
     end
 
-    state || :ok
+    error || :ok
   end
 
-  defp exec_on_exit_callback({_ref, callback}, {runner_pid, runner_monitor, state}) do
+  defp exec_on_exit_callback({_name_or_ref, callback}, timeout, runner) do
+    {runner_pid, runner_monitor, error} = runner
     {runner_pid, runner_monitor} = ensure_alive_callback_runner(runner_pid, runner_monitor)
     send(runner_pid, {:run, self(), callback})
+    receive_runner_reply(runner_pid, runner_monitor, error, timeout)
+  end
 
+  defp receive_runner_reply(runner_pid, runner_monitor, error, timeout) do
     receive do
-      {^runner_pid, nil} ->
-        {runner_pid, runner_monitor, state}
-      {^runner_pid, error} ->
-        {runner_pid, runner_monitor, state || error}
-      {:DOWN, ^runner_monitor, :process, ^runner_pid, error} ->
-        {nil, nil, state || {{:EXIT, runner_pid}, error, []}}
+      {^runner_pid, reason} ->
+        {runner_pid, runner_monitor, error || reason}
+
+      {:DOWN, ^runner_monitor, :process, ^runner_pid, reason} ->
+        {nil, nil, error || {{:EXIT, runner_pid}, reason, []}}
+    after
+      timeout ->
+        case Process.info(runner_pid, :current_stacktrace) do
+          {:current_stacktrace, stacktrace} ->
+            Process.exit(runner_pid, :kill)
+
+            receive do
+              {:DOWN, ^runner_monitor, :process, ^runner_pid, _} -> :ok
+            end
+
+            exception = ExUnit.TimeoutError.exception(timeout: timeout, type: "on_exit callback")
+            {nil, nil, error || {:error, exception, stacktrace}}
+
+          nil ->
+            receive_runner_reply(runner_pid, runner_monitor, error, timeout)
+        end
     end
   end
 
@@ -65,8 +125,6 @@ defmodule ExUnit.OnExitHandler do
       {:run, from, fun} ->
         send(from, {self(), exec_callback(fun)})
         on_exit_runner_loop()
-      :shutdown ->
-        :ok
     end
   end
 
@@ -83,6 +141,6 @@ defmodule ExUnit.OnExitHandler do
     nil
   catch
     kind, error ->
-      {kind, Exception.normalize(kind, error), System.stacktrace}
+      {kind, error, __STACKTRACE__}
   end
 end
diff --git a/lib/ex_unit/lib/ex_unit/on_exit_handler/supervisor.ex b/lib/ex_unit/lib/ex_unit/on_exit_handler/supervisor.ex
new file mode 100644
index 00000000000..9ce8cd6a39c
--- /dev/null
+++ b/lib/ex_unit/lib/ex_unit/on_exit_handler/supervisor.ex
@@ -0,0 +1,28 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule ExUnit.OnExitHandler.Supervisor do
+  @moduledoc false
+  use Supervisor
+
+  def start_link(children) do
+    Supervisor.start_link(__MODULE__, {children, get_callers(self())})
+  end
+
+  @impl true
+  def init({children, callers}) do
+    put_callers(callers)
+    Supervisor.init(children, strategy: :one_for_one, max_restarts: 1_000_000, max_seconds: 1)
+  end
+
+  defp get_callers(owner) do
+    case :erlang.get(:"$callers") do
+      [_ | _] = list -> [owner | list]
+      _ -> [owner]
+    end
+  end
+
+  defp put_callers(callers) do
+    :erlang.put(:"$callers", callers)
+  end
+end
diff --git a/lib/ex_unit/lib/ex_unit/runner.ex b/lib/ex_unit/lib/ex_unit/runner.ex
index 4bed446d6ea..e8f2fcf23a3 100644
--- a/lib/ex_unit/lib/ex_unit/runner.ex
+++ b/lib/ex_unit/lib/ex_unit/runner.ex
@@ -1,290 +1,662 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.Runner do
   @moduledoc false
 
   alias ExUnit.EventManager, as: EM
-  @stop_timeout 30_000
 
-  def run(async, sync, opts, load_us) do
+  @current_key __MODULE__
+
+  def run(opts, load_us) when (is_integer(load_us) or is_nil(load_us)) and is_list(opts) do
+    runner = self()
+    id = {__MODULE__, runner}
+
+    try do
+      # It may fail on Windows, so we ignore the result.
+      _ =
+        System.trap_signal(:sigquit, id, fn ->
+          ref = Process.monitor(runner)
+          send(runner, {ref, self(), :sigquit})
+
+          receive do
+            ^ref -> :ok
+            {:DOWN, ^ref, _, _, _} -> :ok
+          after
+            5_000 -> :ok
+          end
+
+          Process.demonitor(ref, [:flush])
+          :ok
+        end)
+
+      run_with_trap(opts, load_us)
+    after
+      System.untrap_signal(:sigquit, id)
+    end
+  end
+
+  defp run_with_trap(opts, load_us) do
     opts = normalize_opts(opts)
+    {:ok, manager} = EM.start_link()
+    {:ok, stats_pid} = EM.add_handler(manager, ExUnit.RunnerStats, opts)
+    config = configure(opts, manager, self(), stats_pid)
+    :erlang.system_flag(:backtrace_depth, Keyword.fetch!(opts, :stacktrace_depth))
 
-    {:ok, pid} = EM.start_link
-    formatters = [ExUnit.RunnerStats|opts[:formatters]]
-    Enum.each formatters, &(:ok = EM.add_handler(pid, &1, opts))
+    start_time = System.monotonic_time()
+    EM.suite_started(config.manager, opts)
 
-    config = %{
-      seed: opts[:seed],
-      max_cases: opts[:max_cases],
-      sync_cases: [],
-      async_cases: [],
-      taken_cases: 0,
-      include: opts[:include],
-      exclude: opts[:exclude],
-      manager: pid
-    }
+    modules_to_restore =
+      if Keyword.fetch!(opts, :repeat_until_failure) > 0, do: {[], []}, else: nil
 
-    {run_us, _} =
-      :timer.tc fn ->
-        EM.suite_started(config.manager, opts)
-        loop %{config | sync_cases: shuffle(config, sync),
-                        async_cases: shuffle(config, async)}
-      end
+    {async_stop_time, modules_to_restore} = async_loop(config, %{}, false, modules_to_restore)
+    stop_time = System.monotonic_time()
 
-    EM.suite_finished(config.manager, run_us, load_us)
-    EM.call(config.manager, ExUnit.RunnerStats, :stop, @stop_timeout)
+    if max_failures_reached?(config) do
+      EM.max_failures_reached(config.manager)
+    end
+
+    async_us =
+      async_stop_time &&
+        System.convert_time_unit(async_stop_time - start_time, :native, :microsecond)
+
+    run_us = System.convert_time_unit(stop_time - start_time, :native, :microsecond)
+    times_us = %{async: async_us, load: load_us, run: run_us}
+    EM.suite_finished(config.manager, times_us)
+
+    stats = ExUnit.RunnerStats.stats(stats_pid)
+    EM.stop(config.manager)
+    after_suite_callbacks = Application.fetch_env!(:ex_unit, :after_suite)
+    Enum.each(after_suite_callbacks, fn callback -> callback.(stats) end)
+    {stats, modules_to_restore}
   end
 
-  defp normalize_opts(opts) do
-    opts =
-      if opts[:trace] do
-        Keyword.put_new(opts, :max_cases, 1)
-      else
-        Keyword.put(opts, :trace, false)
-      end
+  defp configure(opts, manager, runner_pid, stats_pid) do
+    Enum.each(opts[:formatters], &EM.add_handler(manager, &1, opts))
+
+    %{
+      capture_log: opts[:capture_log],
+      exclude: opts[:exclude],
+      include: opts[:include],
+      manager: manager,
+      max_cases: opts[:max_cases],
+      max_failures: opts[:max_failures],
+      only_test_ids: opts[:only_test_ids],
+      rand_algorithm: opts[:rand_algorithm],
+      runner_pid: runner_pid,
+      seed: opts[:seed],
+      stats_pid: stats_pid,
+      timeout: opts[:timeout],
+      trace: opts[:trace],
+      dry_run: opts[:dry_run]
+    }
+  end
 
+  defp normalize_opts(opts) do
     {include, exclude} = ExUnit.Filters.normalize(opts[:include], opts[:exclude])
 
     opts
     |> Keyword.put(:exclude, exclude)
     |> Keyword.put(:include, include)
-    |> Keyword.put_new(:color, IO.ANSI.terminal?)
-    |> Keyword.put_new(:max_cases, :erlang.system_info(:schedulers_online))
-    |> Keyword.put_new(:seed, :erlang.now |> elem(2))
   end
 
-  defp loop(config) do
-    available = config.max_cases - config.taken_cases
+  defp async_loop(config, running, async_once?, modules_to_restore) do
+    available = config.max_cases - map_size(running)
 
     cond do
-      # No cases available, wait for one
+      # No modules available, wait for one
       available <= 0 ->
-        wait_until_available config
+        running = wait_until_available(config, running)
+        async_loop(config, running, async_once?, modules_to_restore)
 
-      # Slots are available, start with async cases
-      tuple = take_async_cases(config, available) ->
-        {config, cases} = tuple
-        spawn_cases(config, cases)
+      # Slots are available, start with async modules
+      async_modules = ExUnit.Server.take_async_modules(available) ->
+        running = spawn_modules(config, async_modules, true, running)
+        modules_to_restore = maybe_store_modules(modules_to_restore, :async, async_modules)
+        async_loop(config, running, true, modules_to_restore)
 
-      # No more async cases, wait for them to finish
-      config.taken_cases > 0 ->
-        wait_until_available config
+      true ->
+        sync_modules = ExUnit.Server.take_sync_modules()
+        modules_to_restore = maybe_store_modules(modules_to_restore, :sync, sync_modules)
 
-      # So we can start all sync cases
-      tuple = take_sync_cases(config) ->
-        {config, cases} = tuple
-        spawn_cases(config, cases)
+        # Wait for all async modules
+        0 =
+          running
+          |> Enum.reduce(running, fn _, acc -> wait_until_available(config, acc) end)
+          |> map_size()
 
-      # No more cases, we are done!
-      true ->
-        config
+        async_stop_time = if async_once?, do: System.monotonic_time(), else: nil
+
+        # Run all sync modules directly
+        for pair <- sync_modules do
+          running = spawn_modules(config, [{nil, [pair]}], false, %{})
+          running != %{} and wait_until_available(config, running)
+        end
+
+        {async_stop_time, modules_to_restore}
     end
   end
 
-  # Loop expecting messages from the spawned cases. Whenever
-  # a test case has finished executing, decrease the taken
-  # cases counter and attempt to spawn new ones.
-  defp wait_until_available(config) do
+  # Expect down messages from the spawned modules.
+  #
+  # We first look at the sigquit signal because we don't want
+  # to spawn new test cases when we know we will have to handle
+  # sigquit next.
+  #
+  # Otherwise, whenever a module has finished executing, update
+  # the running modules and attempt to spawn new ones.
+  defp wait_until_available(config, running) do
     receive do
-      {_pid, :case_finished, _test_case} ->
-        loop %{config | taken_cases: config.taken_cases - 1}
+      {ref, pid, :sigquit} ->
+        sigquit(config, ref, pid, running)
+    after
+      0 ->
+        receive do
+          {ref, pid, :sigquit} ->
+            sigquit(config, ref, pid, running)
+
+          {:DOWN, ref, _, _, _} when is_map_key(running, ref) ->
+            Map.delete(running, ref)
+        end
     end
   end
 
-  defp spawn_cases(config, cases) do
-    pid = self()
+  defp spawn_modules(_config, [], _async, running) do
+    running
+  end
 
-    Enum.each cases, fn case_name ->
-      spawn_link fn ->
-        run_case(config, pid, case_name)
-      end
+  defp spawn_modules(config, [{group, modules} | groups], async?, running) do
+    cond do
+      max_failures_reached?(config) ->
+        running
+
+      modules == [] ->
+        spawn_modules(config, groups, async?, running)
+
+      true ->
+        {pid, ref} =
+          spawn_monitor(fn ->
+            Enum.each(modules, fn {module, params} ->
+              run_module(config, module, async?, group, params)
+            end)
+          end)
+
+        spawn_modules(config, groups, async?, Map.put(running, ref, pid))
     end
+  end
+
+  defp maybe_store_modules(nil, _type, _modules), do: nil
+  defp maybe_store_modules({async, sync}, :async, modules), do: {async ++ modules, sync}
+  defp maybe_store_modules({async, sync}, :sync, modules), do: {async, sync ++ modules}
+
+  ## Stacktrace
+
+  # Assertions can pop-up in the middle of the stack
+  def prune_stacktrace([{ExUnit.Assertions, _, _, _} | t]), do: prune_stacktrace(t)
+
+  # As soon as we see a Runner, it is time to ignore the stacktrace
+  def prune_stacktrace([{ExUnit.Runner, _, _, _} | _]), do: []
 
-    loop %{config | taken_cases: config.taken_cases + length(cases)}
+  # All other cases
+  def prune_stacktrace([h | t]), do: [h | prune_stacktrace(t)]
+  def prune_stacktrace([]), do: []
+
+  ## sigquit
+
+  defp sigquit(config, ref, pid, running) do
+    # Stop all child processes from running and get their current state.
+    # We need to stop these processes because they may invoke the event
+    # manager and we must stop the event manager to guarantee the sigquit
+    # data has been flushed.
+    current =
+      Enum.map(running, fn {ref, pid} ->
+        current = safe_pdict_current(pid)
+        Process.exit(pid, :shutdown)
+
+        receive do
+          {:DOWN, ^ref, _, _, _} -> current
+        end
+      end)
+
+    EM.sigquit(config.manager, Enum.reject(current, &is_nil/1))
+    EM.stop(config.manager)
+
+    # Reply to the event manager and wait until it shuts down the VM.
+    send(pid, ref)
+    Process.sleep(:infinity)
   end
 
-  defp run_case(config, pid, case_name) do
-    test_case = case_name.__ex_unit__(:case)
-    EM.case_started(config.manager, test_case)
+  defp safe_pdict_current(pid) do
+    with {:dictionary, dictionary} <- Process.info(pid, :dictionary),
+         {@current_key, current} <- List.keyfind(dictionary, @current_key, 0),
+         do: current
+  rescue
+    _ -> nil
+  end
 
-    # Prepare tests, selecting which ones should
-    # run and which ones were skipped.
-    tests = prepare_tests(config, test_case.tests)
+  ## Running modules
 
-    {test_case, pending} =
-      if Enum.all?(tests, &(&1.state)) do
-        {test_case, tests}
-      else
-        spawn_case(config, test_case, tests)
+  defp run_module(config, module, async?, group, params) do
+    test_module = %{module.__ex_unit__() | parameters: params}
+    EM.module_started(config.manager, test_module)
+
+    # Prepare tests, selecting which ones should be run or skipped
+    {to_run_tests, excluded_and_skipped_tests} =
+      prepare_tests(config, async?, group, test_module.tests)
+
+    for excluded_or_skipped_test <- excluded_and_skipped_tests do
+      EM.test_started(config.manager, excluded_or_skipped_test)
+      EM.test_finished(config.manager, excluded_or_skipped_test)
+    end
+
+    {test_module, invalid_tests, finished_tests} =
+      run_module_tests(config, test_module, async?, to_run_tests)
+
+    pending_tests =
+      case process_max_failures(config, test_module) do
+        :no ->
+          invalid_tests
+
+        {:reached, n} ->
+          Enum.take(invalid_tests, n)
+
+        :surpassed ->
+          nil
+      end
+
+    # If pending_tests is [], EM.module_finished is still called.
+    # Only if process_max_failures/2 returns :surpassed it is not.
+    if pending_tests do
+      for pending_test <- pending_tests do
+        EM.test_started(config.manager, pending_test)
+        EM.test_finished(config.manager, pending_test)
       end
 
-    # Run the pending tests. We don't actually spawn those
-    # tests but we do send the notifications to formatter.
-    Enum.each pending, &run_test(config, &1, [])
-    EM.case_finished(config.manager, test_case)
-    send pid, {self, :case_finished, test_case}
+      test_module = %{test_module | tests: Enum.reverse(finished_tests, pending_tests)}
+      EM.module_finished(config.manager, test_module)
+    end
   end
 
-  defp prepare_tests(config, tests) do
-    tests   = shuffle(config, tests)
+  defp prepare_tests(config, async?, group, tests) do
+    tests = shuffle(config, tests)
     include = config.include
     exclude = config.exclude
-
-    for test <- tests do
-      tags = Map.put(test.tags, :test, test.name)
-      case ExUnit.Filters.eval(include, exclude, tags, tests) do
-        :ok           -> %{test | tags: tags}
-        {:error, tag} -> %{test | state: {:skip, "due to #{tag} filter"}}
+    test_ids = config.only_test_ids
+
+    {to_run, to_skip} =
+      for test <- tests, include_test?(test_ids, test), reduce: {[], []} do
+        {to_run, to_skip} ->
+          tags =
+            Map.merge(test.tags, %{
+              test: test.name,
+              module: test.module,
+              async: async?,
+              test_group: group
+            })
+
+          case ExUnit.Filters.eval(include, exclude, tags, tests) do
+            :ok -> {[%{test | tags: tags} | to_run], to_skip}
+            excluded_or_skipped -> {to_run, [%{test | state: excluded_or_skipped} | to_skip]}
+          end
       end
-    end
+
+    {Enum.reverse(to_run), Enum.reverse(to_skip)}
   end
 
-  defp spawn_case(config, test_case, tests) do
-    parent = self
+  defp include_test?(test_ids, test) do
+    test_ids == nil or MapSet.member?(test_ids, {test.module, test.name})
+  end
 
-    {case_pid, case_ref} =
-      spawn_monitor(fn ->
-        ExUnit.OnExitHandler.register(self)
+  defp run_module_tests(_config, test_module, _async?, []) do
+    {test_module, [], []}
+  end
 
-        case exec_case_setup(test_case) do
-          {:ok, test_case, context} ->
-            Enum.each(tests, &run_test(config, &1, context))
-            send parent, {self, :case_finished, test_case, []}
+  defp run_module_tests(%{dry_run: true}, test_module, _async?, tests) do
+    {test_module, [], tests}
+  end
 
-          {:error, test_case} ->
-            failed_tests = Enum.map(tests, & %{&1 | state: {:invalid, test_case}})
-            send parent, {self, :case_finished, test_case, failed_tests}
-        end
+  defp run_module_tests(config, test_module, async?, tests) do
+    Process.put(@current_key, test_module)
+    %ExUnit.TestModule{name: module, tags: tags, parameters: params} = test_module
+    context = tags |> Map.merge(params) |> Map.merge(%{module: module, async: async?})
+
+    config
+    |> run_setup_all(test_module, context, fn context ->
+      if max_failures_reached?(config),
+        do: [],
+        else: run_tests(config, tests, test_module.parameters, context)
+    end)
+    |> case do
+      {{:ok, finished_tests}, test_module} ->
+        {test_module, [], finished_tests}
+
+      {:error, test_module} ->
+        {test_module, Enum.map(tests, &%{&1 | state: {:invalid, test_module}}), []}
+    end
+  end
+
+  defp run_setup_all(
+         _config,
+         %ExUnit.TestModule{setup_all?: false} = test_module,
+         context,
+         callback
+       ) do
+    {{:ok, callback.(context)}, test_module}
+  end
+
+  defp run_setup_all(config, %ExUnit.TestModule{name: module} = test_module, context, callback) do
+    parent_pid = self()
 
-        exit(:shutdown)
+    {module_pid, module_ref} =
+      spawn_monitor(fn ->
+        ExUnit.OnExitHandler.register(self())
+
+        result =
+          try do
+            {:ok, module.__ex_unit__(:setup_all, context)}
+          catch
+            kind, error ->
+              failed = failed(kind, error, prune_stacktrace(__STACKTRACE__))
+              {:error, %{test_module | state: failed}}
+          end
+
+        send(parent_pid, {self(), :setup_all, result})
+
+        # We keep the process alive so all of its resources
+        # stay alive until we run all tests in this case.
+        ref = Process.monitor(parent_pid)
+
+        receive do
+          {^parent_pid, :exit} -> :ok
+          {:DOWN, ^ref, _, _, _} -> :ok
+        end
       end)
 
-    {test_case, pending} =
+    {ok_or_error, test_module} =
       receive do
-        {^case_pid, :case_finished, test_case, tests} ->
-          {test_case, tests}
-        {:DOWN, ^case_ref, :process, ^case_pid, error} ->
-          test_case = %{test_case | state: {:failed, {{:EXIT, case_pid}, error, []}}}
-          {test_case, []}
+        {^module_pid, :setup_all, {:ok, context}} ->
+          finished_tests = callback.(context)
+          :ok = exit_setup_all(module_pid, module_ref)
+          {{:ok, finished_tests}, test_module}
+
+        {^module_pid, :setup_all, {:error, test_module}} ->
+          :ok = exit_setup_all(module_pid, module_ref)
+          {:error, test_module}
+
+        {:DOWN, ^module_ref, :process, ^module_pid, error} ->
+          {:error, %{test_module | state: failed({:EXIT, module_pid}, error, [])}}
       end
 
-    {exec_on_exit(test_case, case_pid), pending}
+    timeout = get_timeout(config, %{})
+    {ok_or_error, exec_on_exit(test_module, module_pid, timeout)}
   end
 
-  defp exec_case_setup(%ExUnit.TestCase{name: case_name} = test_case) do
-    {:ok, context} = case_name.__ex_unit__(:setup_all, %{case: case_name})
-    {:ok, test_case, context}
-  catch
-    kind, error ->
-      failed = {:failed, {kind, Exception.normalize(kind, error), pruned_stacktrace}}
-      {:error, %{test_case | state: failed}}
+  defp exit_setup_all(pid, ref) do
+    send(pid, {self(), :exit})
+
+    receive do
+      {:DOWN, ^ref, _, _, _} -> :ok
+    end
+  end
+
+  defp run_tests(config, tests, params, context) do
+    Enum.reduce_while(tests, [], fn test, acc ->
+      test = %{test | parameters: params}
+      Process.put(@current_key, test)
+
+      case run_test(config, test, context) do
+        {:ok, test} -> {:cont, [test | acc]}
+        :max_failures_reached -> {:halt, acc}
+      end
+    end)
   end
 
   defp run_test(config, test, context) do
     EM.test_started(config.manager, test)
+    test = spawn_test(config, test, context)
 
-    if nil?(test.state) do
-      test = spawn_test(config, test, Map.merge(test.tags, context))
-    end
+    case process_max_failures(config, test) do
+      :no ->
+        EM.test_finished(config.manager, test)
+        {:ok, test}
+
+      {:reached, 1} ->
+        EM.test_finished(config.manager, test)
+        :max_failures_reached
 
-    EM.test_finished(config.manager, test)
+      :surpassed ->
+        :max_failures_reached
+    end
   end
 
-  defp spawn_test(_config, test, context) do
-    parent = self()
+  defp spawn_test(config, test, context) do
+    parent_pid = self()
+    timeout = get_timeout(config, test.tags)
+    {test_pid, test_ref} = spawn_test_monitor(config, test, parent_pid, context)
+    test = receive_test_reply(test, test_pid, test_ref, timeout)
+    exec_on_exit(test, test_pid, timeout)
+  end
 
-    {test_pid, test_ref} =
-      spawn_monitor(fn ->
-        ExUnit.OnExitHandler.register(self)
+  defp spawn_test_monitor(
+         %{seed: seed, capture_log: capture_log, rand_algorithm: rand_algorithm},
+         test,
+         parent_pid,
+         context
+       ) do
+    spawn_monitor(fn ->
+      Process.set_label({test.case, test.name})
+      ExUnit.OnExitHandler.register(self())
+      generate_test_seed(seed, test, rand_algorithm)
+      context = context |> Map.merge(test.tags) |> Map.put(:test_pid, self())
+      capture_log = Map.get(context, :capture_log, capture_log)
+
+      {time, test} =
+        :timer.tc(
+          maybe_capture_log(capture_log, test, fn ->
+            context = maybe_create_tmp_dir(context, test)
 
-        {us, test} =
-          :timer.tc(fn ->
             case exec_test_setup(test, context) do
-              {:ok, test, context} ->
-                exec_test(test, context)
-              {:error, test} ->
-                test
+              {:ok, context} -> exec_test(test, context)
+              {:error, test} -> test
             end
           end)
+        )
 
-        send parent, {self, :test_finished, %{test | time: us}}
-        exit(:shutdown)
-      end)
+      send(parent_pid, {self(), :test_finished, %{test | time: time}})
+      exit(:shutdown)
+    end)
+  end
 
-    test =
-      receive do
-        {^test_pid, :test_finished, test} ->
-          test
-        {:DOWN, ^test_ref, :process, ^test_pid, error} ->
-          %{test | state: {:failed, {{:EXIT, test_pid}, error, []}}}
+  defp maybe_capture_log(true, test, fun) do
+    maybe_capture_log([], test, fun)
+  end
+
+  defp maybe_capture_log(false, _test, fun) do
+    fun
+  end
+
+  defp maybe_capture_log(capture_log_opts, test, fun) do
+    fn ->
+      try do
+        ExUnit.CaptureLog.with_log(capture_log_opts, fun)
+      catch
+        :exit, :noproc ->
+          message =
+            "could not run test, it uses @tag :capture_log" <>
+              " but the :logger application is not running"
+
+          %{test | state: failed(:error, RuntimeError.exception(message), [])}
+      else
+        {test, logs} -> %{test | logs: logs}
       end
+    end
+  end
 
-    exec_on_exit(test, test_pid)
+  defp receive_test_reply(test, test_pid, test_ref, timeout) do
+    receive do
+      {^test_pid, :test_finished, test} ->
+        Process.demonitor(test_ref, [:flush])
+        test
+
+      {:DOWN, ^test_ref, :process, ^test_pid, error} ->
+        %{test | state: failed({:EXIT, test_pid}, error, [])}
+    after
+      timeout ->
+        case Process.info(test_pid, :current_stacktrace) do
+          {:current_stacktrace, stacktrace} ->
+            Process.demonitor(test_ref, [:flush])
+            Process.exit(test_pid, :kill)
+
+            exception =
+              ExUnit.TimeoutError.exception(
+                timeout: timeout,
+                type: Atom.to_string(test.tags.test_type)
+              )
+
+            %{test | state: failed(:error, exception, stacktrace)}
+
+          nil ->
+            receive_test_reply(test, test_pid, test_ref, timeout)
+        end
+    end
   end
 
-  defp exec_test_setup(%ExUnit.Test{case: case} = test, context) do
-    {:ok, context} = case.__ex_unit__(:setup, context)
-    {:ok, test, context}
+  defp exec_test_setup(%ExUnit.Test{module: module} = test, context) do
+    {:ok, module.__ex_unit__(:setup, context)}
   catch
-    kind2, error2 ->
-      failed = {:failed, {kind2, Exception.normalize(kind2, error2), pruned_stacktrace()}}
-      {:error, %{test | state: failed}}
+    kind, error ->
+      {:error, %{test | state: failed(kind, error, prune_stacktrace(__STACKTRACE__))}}
   end
 
-  defp exec_test(%ExUnit.Test{case: case, name: name} = test, context) do
-    apply(case, name, [context])
+  defp exec_test(%ExUnit.Test{module: module, name: name} = test, context) do
+    apply(module, name, [context])
     test
   catch
     kind, error ->
-      failed = {:failed, {kind, Exception.normalize(kind, error), pruned_stacktrace()}}
-      %{test | state: failed}
+      %{test | state: failed(kind, error, prune_stacktrace(__STACKTRACE__))}
   end
 
-  defp exec_on_exit(test_or_case, pid) do
-    case ExUnit.OnExitHandler.run(pid) do
+  defp exec_on_exit(test_or_case, pid, timeout) do
+    case ExUnit.OnExitHandler.run(pid, timeout) do
       :ok ->
         test_or_case
+
       {kind, reason, stack} ->
-        state = test_or_case.state || {:failed, {kind, reason, prune_stacktrace(stack)}}
+        state = test_or_case.state || failed(kind, reason, prune_stacktrace(stack))
         %{test_or_case | state: state}
     end
   end
 
   ## Helpers
 
-  defp shuffle(%{seed: 0}, list) do
-    Enum.reverse(list)
+  defp generate_test_seed(seed, %ExUnit.Test{module: module, name: name}, rand_algorithm) do
+    :rand.seed(rand_algorithm, {:erlang.phash2(module), :erlang.phash2(name), seed})
   end
 
-  defp shuffle(%{seed: seed}, list) do
-    :random.seed(3172, 9814, seed)
-    Enum.shuffle(list)
+  defp process_max_failures(%{max_failures: :infinity}, _), do: :no
+
+  defp process_max_failures(config, %ExUnit.TestModule{state: {:failed, _}, tests: tests}) do
+    process_max_failures(config.stats_pid, config.max_failures, length(tests))
+  end
+
+  defp process_max_failures(config, %ExUnit.Test{state: {:failed, _}}) do
+    process_max_failures(config.stats_pid, config.max_failures, 1)
   end
 
-  defp take_async_cases(config, count) do
-    case config.async_cases do
-      [] -> nil
-      cases ->
-        {response, remaining} = Enum.split(cases, count)
-        {%{config | async_cases: remaining}, response}
+  defp process_max_failures(config, _test_module_or_test) do
+    if max_failures_reached?(config), do: :surpassed, else: :no
+  end
+
+  defp process_max_failures(stats_pid, max_failures, bump) do
+    previous = ExUnit.RunnerStats.increment_failure_counter(stats_pid, bump)
+
+    cond do
+      previous >= max_failures -> :surpassed
+      previous + bump < max_failures -> :no
+      true -> {:reached, max_failures - previous}
     end
   end
 
-  defp take_sync_cases(config) do
-    case config.sync_cases do
-      [h|t] -> {%{config | sync_cases: t}, [h]}
-      []    -> nil
+  defp max_failures_reached?(%{stats_pid: stats_pid, max_failures: max_failures}) do
+    max_failures != :infinity and
+      ExUnit.RunnerStats.get_failure_counter(stats_pid) >= max_failures
+  end
+
+  defp get_timeout(config, tags) do
+    if config.trace do
+      :infinity
+    else
+      Map.get(tags, :timeout, config.timeout)
     end
   end
 
-  defp pruned_stacktrace, do: prune_stacktrace(System.stacktrace)
+  defp shuffle(%{seed: 0}, list) do
+    list
+  end
 
-  # Assertions can pop-up in the middle of the stack
-  defp prune_stacktrace([{ExUnit.Assertions, _, _, _}|t]), do: prune_stacktrace(t)
+  defp shuffle(%{seed: seed, rand_algorithm: rand_algorithm}, list) do
+    _ = :rand.seed(rand_algorithm, {seed, seed, seed})
+    Enum.shuffle(list)
+  end
 
-  # As soon as we see a Runner, it is time to ignore the stacktrace
-  defp prune_stacktrace([{ExUnit.Runner, _, _, _}|_]), do: []
+  defp failed(:error, %ExUnit.MultiError{errors: errors}, _stack) do
+    errors =
+      Enum.map(errors, fn {kind, reason, stack} ->
+        {kind, Exception.normalize(kind, reason, stack), prune_stacktrace(stack)}
+      end)
 
-  # All other cases
-  defp prune_stacktrace([h|t]), do: [h|prune_stacktrace(t)]
-  defp prune_stacktrace([]), do: []
-end
+    {:failed, errors}
+  end
+
+  defp failed(kind, reason, stack) do
+    {:failed, [{kind, Exception.normalize(kind, reason, stack), stack}]}
+  end
+
+  ## Tmp dir handling
 
+  defp maybe_create_tmp_dir(%{tmp_dir: true} = tags, test) do
+    create_tmp_dir!(test, "", tags)
+  end
+
+  defp maybe_create_tmp_dir(%{tmp_dir: path} = tags, test) when is_binary(path) do
+    create_tmp_dir!(test, path, tags)
+  end
+
+  defp maybe_create_tmp_dir(%{tmp_dir: other}, _test) when other != false do
+    raise ArgumentError, "expected :tmp_dir to be a boolean or a string, got: #{inspect(other)}"
+  end
+
+  defp maybe_create_tmp_dir(tags, _test) do
+    tags
+  end
+
+  defp short_hash(module, test_name, parameters) do
+    suffix = if parameters == %{}, do: "", else: :erlang.term_to_binary(parameters)
+
+    (module <> "/" <> test_name <> suffix)
+    |> :erlang.md5()
+    |> Base.encode16(case: :lower)
+    |> binary_slice(0..7)
+  end
+
+  defp create_tmp_dir!(test, extra_path, tags) do
+    module_string = inspect(test.module)
+    name_string = to_string(test.name)
+
+    module = escape_path(module_string)
+    name = escape_path(name_string)
+    short_hash = short_hash(module_string, name_string, test.parameters)
+
+    path = ["tmp", module, "#{name}-#{short_hash}", extra_path] |> Path.join() |> Path.expand()
+    File.rm_rf!(path)
+    File.mkdir_p!(path)
+    Map.put(tags, :tmp_dir, path)
+  end
+
+  @escape Enum.map(~c" [~#%&*{}\\:<>?/+|\"]", &<<&1::utf8>>)
+
+  defp escape_path(path) do
+    String.replace(path, @escape, "-")
+  end
+end
diff --git a/lib/ex_unit/lib/ex_unit/runner_stats.ex b/lib/ex_unit/lib/ex_unit/runner_stats.ex
index d2e6d07a99f..2154aeb2431 100644
--- a/lib/ex_unit/lib/ex_unit/runner_stats.ex
+++ b/lib/ex_unit/lib/ex_unit/runner_stats.ex
@@ -1,31 +1,128 @@
-# Small event consumer to handle runner statistics.
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.RunnerStats do
   @moduledoc false
 
-  use GenEvent
+  use GenServer
+  alias ExUnit.{FailuresManifest, Test}
+
+  @typep counter :: non_neg_integer
+
+  @spec stats(pid) :: %{
+          excluded: counter,
+          failures: counter,
+          skipped: counter,
+          total: counter
+        }
+  def stats(pid) when is_pid(pid) do
+    GenServer.call(pid, :stats, :infinity)
+  end
+
+  @spec get_failure_counter(pid) :: counter
+  def get_failure_counter(sup) when is_pid(sup) do
+    GenServer.call(sup, :get_failure_counter)
+  end
+
+  @spec increment_failure_counter(pid) :: pos_integer
+  def increment_failure_counter(sup, increment \\ 1)
+      when is_pid(sup) and is_integer(increment) and increment >= 1 do
+    GenServer.call(sup, {:increment_failure_counter, increment})
+  end
+
+  # Callbacks
+
+  def init(opts) do
+    state = %{
+      total: 0,
+      passed: 0,
+      failures: 0,
+      skipped: 0,
+      excluded: 0,
+      failures_manifest_path: opts[:failures_manifest_path],
+      failures_manifest: FailuresManifest.new(),
+      failure_counter: 0,
+      pids: []
+    }
+
+    {:ok, state}
+  end
+
+  def handle_call(:stats, _from, state) do
+    stats = Map.take(state, [:total, :failures, :skipped, :excluded])
+    {:reply, stats, state}
+  end
+
+  def handle_call(:get_failure_counter, _from, state) do
+    {:reply, state.failure_counter, state}
+  end
+
+  def handle_call({:increment_failure_counter, increment}, _from, state) do
+    %{failure_counter: failure_counter} = state
+    {:reply, failure_counter, %{state | failure_counter: failure_counter + increment}}
+  end
+
+  def handle_cast({:test_finished, %Test{} = test}, state) do
+    state =
+      state
+      |> Map.update!(:failures_manifest, &FailuresManifest.put_test(&1, test))
+      |> Map.update!(:total, &(&1 + 1))
+      |> increment_status_counter(test.state)
+
+    {:noreply, state}
+  end
+
+  def handle_cast({:suite_started, _opts}, %{failures_manifest_path: file} = state)
+      when is_binary(file) do
+    state = %{state | failures_manifest: FailuresManifest.read(file)}
+    {:noreply, state}
+  end
 
-  def init(_opts) do
-    {:ok, %{total: 0, failures: 0}}
+  def handle_cast({:suite_finished, _}, %{failures_manifest_path: file} = state)
+      when is_binary(file) do
+    FailuresManifest.write!(state.failures_manifest, file)
+    {:noreply, state}
   end
 
-  def handle_call(:stop, map) do
-    {:remove_handler, map}
+  def handle_cast(
+        {:module_finished, %ExUnit.TestModule{state: {:failed, _}} = test_module},
+        state
+      ) do
+    # The failed tests have already been added to the manifest,
+    # so we should only invalidate the successful tests
+    successful_tests = Enum.filter(test_module.tests, &is_nil(&1.state))
+
+    state =
+      Enum.reduce(successful_tests, state, fn test, acc ->
+        acc
+        |> Map.update!(:failures_manifest, &FailuresManifest.put_test(&1, test))
+        |> Map.update!(:failures, &(&1 + 1))
+        |> Map.update!(:passed, &(&1 - 1))
+      end)
+
+    {:noreply, state}
   end
 
-  def handle_event({:test_finished, %ExUnit.Test{state: {tag, _}}},
-                   %{total: total, failures: failures} = map) when tag in [:failed, :invalid] do
-    {:ok, %{map | total: total + 1, failures: failures + 1}}
+  def handle_cast(_, state) do
+    {:noreply, state}
   end
 
-  def handle_event({:test_finished, %ExUnit.Test{state: {:skip, _}}}, map) do
-    {:ok, map}
+  defp increment_status_counter(state, tag) when tag in [nil, :passed] do
+    Map.update!(state, :passed, &(&1 + 1))
   end
 
-  def handle_event({:test_finished, _}, %{total: total} = map) do
-    {:ok, %{map | total: total + 1}}
+  defp increment_status_counter(state, {:skipped, _}) do
+    Map.update!(state, :skipped, &(&1 + 1))
   end
 
-  def handle_event(_, map) do
-    {:ok, map}
+  defp increment_status_counter(state, {:excluded, _}) do
+    Map.update!(state, :excluded, &(&1 + 1))
   end
-end
\ No newline at end of file
+
+  defp increment_status_counter(state, {tag, _}) when tag in [:failed, :invalid] do
+    Map.update!(state, :failures, &(&1 + 1))
+  end
+
+  defp increment_status_counter(state, _), do: state
+end
diff --git a/lib/ex_unit/lib/ex_unit/server.ex b/lib/ex_unit/lib/ex_unit/server.ex
index d21a3b83cab..62abb3fa580 100644
--- a/lib/ex_unit/lib/ex_unit/server.ex
+++ b/lib/ex_unit/lib/ex_unit/server.ex
@@ -1,93 +1,219 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule ExUnit.Server do
   @moduledoc false
+  @name __MODULE__
+  @timeout :infinity
 
-  @timeout 30_000
   use GenServer
 
-  def start_link() do
-    :gen_server.start_link({:local, __MODULE__}, __MODULE__, :ok, [])
+  def start_link(_opts) do
+    GenServer.start_link(__MODULE__, :ok, name: @name)
   end
 
-  ## Before run API
+  def add_module(name, config) do
+    %{
+      async?: async?,
+      group: group,
+      parameterize: parameterize
+    } = config
+
+    modules =
+      if parameterize do
+        Enum.map(parameterize, &{name, &1})
+      else
+        [{name, %{}}]
+      end
+
+    case GenServer.call(@name, {:add, async?, group, modules}, @timeout) do
+      :ok ->
+        :ok
 
-  def start_load() do
-    :gen_server.cast(__MODULE__, :start_load)
+      :already_running ->
+        raise "cannot add module named #{inspect(name)} to test suite after the suite starts running"
+    end
   end
 
-  def add_async_case(name) do
-    :gen_server.cast(__MODULE__, {:add_async_case, name})
+  def modules_loaded(uniq?) do
+    GenServer.call(@name, {:modules_loaded, uniq?}, @timeout)
   end
 
-  def add_sync_case(name) do
-    :gen_server.cast(__MODULE__, {:add_sync_case, name})
+  def take_async_modules(count) do
+    GenServer.call(@name, {:take_async_modules, count}, @timeout)
   end
 
-  ## After run API
+  def take_sync_modules() do
+    GenServer.call(@name, :take_sync_modules, @timeout)
+  end
 
-  def start_run() do
-    :gen_server.call(__MODULE__, :start_run, @timeout)
+  def restore_modules(async_modules, sync_modules) do
+    GenServer.call(@name, {:restore_modules, async_modules, sync_modules}, @timeout)
   end
 
-  ## Capture Device API
+  ## Callbacks
 
-  def add_device(device) do
-    :gen_server.call(__MODULE__, {:add_device, device})
+  def init(:ok) do
+    # Table used by OnExitHandler
+    :ets.new(__MODULE__, [:public, :named_table, read_concurrency: true, write_concurrency: true])
+
+    state = %{
+      loaded: System.monotonic_time(),
+      waiting: nil,
+      groups: %{},
+      async_groups: [],
+      async_modules: :queue.new(),
+      sync_modules: []
+    }
+
+    {:ok, state}
   end
 
-  def remove_device(device) do
-    :gen_server.call(__MODULE__, {:remove_device, device})
+  # Called on demand until we are signaled all modules are loaded.
+  def handle_call({:take_async_modules, count}, from, %{waiting: nil} = state) do
+    {:noreply, take_modules(%{state | waiting: {from, count}})}
   end
 
-  ## Callbacks
+  # Called once after all async modules have been sent and reverts the state.
+  def handle_call(:take_sync_modules, _from, state) do
+    %{waiting: nil, loaded: :done, async_groups: []} = state
+    true = :queue.is_empty(state.async_modules)
 
-  def init(:ok) do
-    config = %{async_cases: HashSet.new, sync_cases: HashSet.new,
-               start_load: :os.timestamp, captured_devices: HashSet.new}
-    {:ok, config}
+    {:reply, state.sync_modules, %{state | sync_modules: [], loaded: System.monotonic_time()}}
   end
 
-  def handle_call(:start_run, _from, config) do
-    load_us =
-      if start_load = config.start_load do
-        :timer.now_diff(:os.timestamp, start_load)
+  # Called by the runner when --repeat-until-failure is used.
+  def handle_call({:restore_modules, async_modules, sync_modules}, _from, state) do
+    {async_modules, async_groups, groups} =
+      Enum.reduce(async_modules, {[], [], []}, fn
+        {nil, [module]}, {async_modules, async_groups, groups} ->
+          {[module | async_modules], async_groups, groups}
+
+        {group, group_modules}, {async_modules, async_groups, groups} ->
+          {async_modules, [group | async_groups], [{group, group_modules} | groups]}
+      end)
+
+    {:reply, :ok,
+     %{
+       state
+       | loaded: :done,
+         groups: Map.new(groups),
+         async_groups: async_groups,
+         async_modules: :queue.from_list(async_modules),
+         sync_modules: sync_modules
+     }}
+  end
+
+  def handle_call({:modules_loaded, _}, _from, %{loaded: :done} = state) do
+    {:reply, 0, state}
+  end
+
+  def handle_call({:modules_loaded, uniq?}, _from, %{loaded: loaded} = state)
+      when is_integer(loaded) do
+    state =
+      if uniq? do
+        groups = Map.new(state.groups, fn {group, modules} -> {group, Enum.uniq(modules)} end)
+        async_groups = state.async_groups |> Enum.uniq() |> Enum.reverse()
+        async_modules = :queue.to_list(state.async_modules) |> Enum.uniq() |> :queue.from_list()
+        sync_modules = state.sync_modules |> Enum.uniq() |> Enum.reverse()
+
+        %{
+          state
+          | groups: groups,
+            async_groups: async_groups,
+            async_modules: async_modules,
+            sync_modules: sync_modules
+        }
+      else
+        %{
+          state
+          | async_groups: Enum.reverse(state.async_groups),
+            sync_modules: Enum.reverse(state.sync_modules)
+        }
       end
 
-    {:reply,
-      {config.async_cases, config.sync_cases, load_us},
-      %{config | async_cases: HashSet.new, sync_cases: HashSet.new, start_load: nil}}
+    diff = System.convert_time_unit(System.monotonic_time() - loaded, :native, :microsecond)
+    {:reply, diff, take_modules(%{state | loaded: :done})}
   end
 
-  def handle_call({:add_device, device}, _from, config) do
-    {:reply,
-      not(device in config.captured_devices),
-      %{config | captured_devices: Set.put(config.captured_devices, device)}}
+  def handle_call({:add, false = _async, _group, names}, _from, %{loaded: loaded} = state)
+      when is_integer(loaded) do
+    state = update_in(state.sync_modules, &Enum.reverse(names, &1))
+    {:reply, :ok, state}
   end
 
-  def handle_call({:remove_device, device}, _from, config) do
-    {:reply, :ok,
-      %{config | captured_devices: Set.delete(config.captured_devices, device)}}
+  def handle_call({:add, true = _async, nil = _group, names}, _from, %{loaded: loaded} = state)
+      when is_integer(loaded) do
+    state =
+      update_in(
+        state.async_modules,
+        &Enum.reduce(names, &1, fn name, q -> :queue.in(name, q) end)
+      )
+
+    {:reply, :ok, take_modules(state)}
   end
 
-  def handle_call(request, from, config) do
-    super(request, from, config)
+  def handle_call({:add, true = _async, group, names}, _from, %{loaded: loaded} = state)
+      when is_integer(loaded) do
+    {groups, async_groups} =
+      case state.groups do
+        %{^group => entries} = groups ->
+          {%{groups | group => Enum.reverse(names, entries)}, state.async_groups}
+
+        %{} = groups ->
+          {Map.put(groups, group, names), [group | state.async_groups]}
+      end
+
+    {:reply, :ok, take_modules(%{state | groups: groups, async_groups: async_groups})}
   end
 
-  def handle_cast(:start_load, config) do
-    {:noreply,
-      %{config | start_load: :os.timestamp}}
+  def handle_call({:add, _async?, _group, _names}, _from, state) do
+    {:reply, :already_running, state}
   end
 
-  def handle_cast({:add_async_case, name}, config) do
-    {:noreply,
-      %{config | async_cases: Set.put(config.async_cases, name)}}
+  defp take_modules(%{waiting: nil} = state) do
+    state
   end
 
-  def handle_cast({:add_sync_case, name}, config) do
-    {:noreply,
-      %{config | sync_cases: Set.put(config.sync_cases, name)}}
+  defp take_modules(%{waiting: {from, count}} = state) do
+    cond do
+      not :queue.is_empty(state.async_modules) ->
+        {reply, remaining_modules} = take_until(count, state.async_modules)
+        GenServer.reply(from, reply)
+        %{state | async_modules: remaining_modules, waiting: nil}
+
+      state.async_groups != [] and state.loaded == :done ->
+        {groups, remaining_groups} = Enum.split(state.async_groups, count)
+
+        {reply, groups} =
+          Enum.map_reduce(groups, state.groups, fn group, acc ->
+            {entries, acc} = Map.pop!(acc, group)
+            {{group, Enum.reverse(entries)}, acc}
+          end)
+
+        GenServer.reply(from, reply)
+        %{state | groups: groups, async_groups: remaining_groups, waiting: nil}
+
+      state.loaded == :done ->
+        GenServer.reply(from, nil)
+        %{state | waiting: nil}
+
+      true ->
+        state
+    end
   end
 
-  def handle_cast(request, config) do
-    super(request, config)
+  # :queue.split fails if the provided count is larger than the queue size.
+  # We also want to return the values as tuples of shape {group, [modules]}.
+  defp take_until(n, queue), do: take_until(n, queue, [])
+
+  defp take_until(0, queue, acc), do: {Enum.reverse(acc), queue}
+
+  defp take_until(n, queue, acc) do
+    case :queue.out(queue) do
+      {{:value, item}, queue} -> take_until(n - 1, queue, [{nil, [item]} | acc])
+      {:empty, queue} -> {Enum.reverse(acc), queue}
+    end
   end
 end
diff --git a/lib/ex_unit/mix.exs b/lib/ex_unit/mix.exs
index 35aea1a5f26..ac2a611fb8d 100644
--- a/lib/ex_unit/mix.exs
+++ b/lib/ex_unit/mix.exs
@@ -1,25 +1,47 @@
-defmodule ExUnit.Mixfile do
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule ExUnit.MixProject do
   use Mix.Project
 
   def project do
-    [app: :ex_unit,
-     version: System.version,
-     build_per_environment: false]
+    [
+      app: :ex_unit,
+      version: System.version(),
+      build_per_environment: false
+    ]
   end
 
   def application do
-    [registered: [ExUnit.Server],
-     mod: {ExUnit, []},
-     env: [
-       # Calculated on demand
-       # max_cases: :erlang.system_info(:schedulers_online),
-       # color: IO.ANSI.terminal?,
-       # seed: rand(),
+    [
+      registered: [ExUnit.CaptureServer, ExUnit.OnExitHandler, ExUnit.Server, ExUnit.Supervisor],
+      mod: {ExUnit, []},
+      env: [
+        # Calculated on demand
+        # max_cases: System.schedulers_online * 2,
+        # seed: rand(),
 
-       autorun: true,
-       trace: false,
-       formatters: [ExUnit.CLIFormatter],
-       include: [],
-       exclude: []]]
+        assert_receive_timeout: 100,
+        autorun: true,
+        capture_log: false,
+        colors: [],
+        exclude: [],
+        exit_status: 2,
+        formatters: [ExUnit.CLIFormatter],
+        include: [],
+        max_failures: :infinity,
+        rand_algorithm: :exsss,
+        refute_receive_timeout: 100,
+        slowest: 0,
+        slowest_modules: 0,
+        stacktrace_depth: 20,
+        timeout: 60_000,
+        trace: false,
+        after_suite: [],
+        repeat_until_failure: 0,
+        dry_run: false
+      ]
+    ]
   end
 end
diff --git a/lib/ex_unit/test/ex_unit/assertions_test.exs b/lib/ex_unit/test/ex_unit/assertions_test.exs
index 546f58dc47d..ca5ecadd124 100644
--- a/lib/ex_unit/test/ex_unit/assertions_test.exs
+++ b/lib/ex_unit/test/ex_unit/assertions_test.exs
@@ -1,118 +1,634 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule ExUnit.AssertionsTest.Value do
   def tuple, do: {2, 1}
-  def falsy, do: false
-  def truthy, do: true
+  def falsy, do: nil
+  def truthy, do: :truthy
+  def binary, do: <<5, "Frank the Walrus">>
+end
+
+defmodule ExUnit.AssertionsTest.BrokenError do
+  defexception [:message]
+
+  @impl true
+  def message(_) do
+    raise "error"
+  end
 end
 
-alias ExUnit.AssertionsTest.Value
+defmodule ExUnit.AssertionsTest.OverrideOperator do
+  import Kernel, except: [{:=~, 2}]
+
+  defmacro __using__(_) do
+    quote do
+      import Kernel, except: [{:=~, 2}]
+      import ExUnit.AssertionsTest.OverrideOperator
+    end
+  end
+
+  defmacro left =~ right do
+    quote do
+      match?(unquote(left), unquote(right))
+    end
+  end
+end
+
+alias ExUnit.AssertionsTest.{BrokenError, Value}
 
 defmodule ExUnit.AssertionsTest do
   use ExUnit.Case, async: true
 
-  test "assert with true value" do
-    true = assert Value.truthy
+  defmacro sigil_l({:<<>>, _, [string]}, _), do: Code.string_to_quoted!(string, [])
+  defmacro argless_macro(), do: raise("should not be invoked")
+
+  defmacrop assert_ok(arg) do
+    quote do
+      assert {:ok, val} = ok(unquote(arg))
+    end
+  end
+
+  defmacrop assert_ok_with_pin_from_quoted_var(arg) do
+    quote do
+      kind = :ok
+      assert {^kind, value} = unquote(arg)
+    end
+  end
+
+  require Record
+  Record.defrecordp(:vec, x: 0, y: 0, z: 0)
+
+  defguardp is_zero(zero) when zero == 0
+
+  test "direct raise" do
+    try do
+      raise ExUnit.AssertionError, "This is a test"
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "This is a test" = error.message
+    end
+  end
+
+  test "assert inside macro" do
+    assert_ok(42)
   end
 
-  test "assert with message when value is false" do
+  test "assert inside macro with pins" do
     try do
-      "This should never be tested" = assert false, "This should be true"
+      assert_ok_with_pin_from_quoted_var({:error, :oops})
     rescue
       error in [ExUnit.AssertionError] ->
-        "This should be true" = error.message
+        "match (=) failed" = error.message
     end
   end
 
-  test "assert when value evalutes to false" do
+  test "assert with truthy value" do
+    :truthy = assert Value.truthy()
+  end
+
+  test "assert with message when value is falsy" do
     try do
-      "This should never be tested" = assert Value.falsy
+      assert Value.falsy(), "This should be truthy"
+      flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
-        "Value.falsy()" = error.expr |> Macro.to_string
-        "Expected truthy, got false" = error.message
+        "This should be truthy" = error.message
+    end
+  end
+
+  test "assert when value evaluates to falsy" do
+    try do
+      assert Value.falsy()
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "assert Value.falsy()" = error.expr |> Macro.to_string()
+        "Expected truthy, got nil" = error.message
+    end
+  end
+
+  test "assert arguments in special form" do
+    true =
+      assert (case :ok do
+                :ok -> true
+              end)
+  end
+
+  test "assert arguments semantics on function call" do
+    x = 1
+    true = assert not_equal(x = 2, x)
+    2 = x
+  end
+
+  test "assert arguments are not kept for operators" do
+    try do
+      assert !Value.truthy()
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        false = is_list(error.args)
     end
   end
 
   test "assert with equality" do
     try do
-      "This should never be tested" = assert 1 + 1 == 1
+      assert 1 + 1 == 1
+      flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
         1 = error.right
         2 = error.left
-        "1 + 1 == 1" = error.expr |> Macro.to_string
+        "assert 1 + 1 == 1" = error.expr |> Macro.to_string()
     end
   end
 
   test "assert with equality in reverse" do
     try do
-      "This should never be tested" = assert 1 == 1 + 1
+      assert 1 == 1 + 1
+      flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
         1 = error.left
         2 = error.right
-        "1 == 1 + 1" = error.expr |> Macro.to_string
+        "assert 1 == 1 + 1" = error.expr |> Macro.to_string()
     end
   end
 
-  test "refute when value is false" do
+  test "assert exposes nested macro variables in matches" do
+    assert ~l(a) = 1
+    assert a == 1
+
+    assert {~l(b), ~l(c)} = {2, 3}
+    assert b == 2
+    assert c == 3
+  end
+
+  test "assert does not expand variables" do
+    assert argless_macro = 1
+    assert argless_macro == 1
+  end
+
+  defmodule OperatorOverrideTest do
+    use ExUnit.Case
+    use ExUnit.AssertionsTest.OverrideOperator
+
+    test "assert when operator be overrode" do
+      assert [_a, _b] =~ [1, 2]
+    end
+  end
+
+  test "refute when value is falsy" do
     false = refute false
+    nil = refute Value.falsy()
   end
 
-  test "refute when value evaluates to true" do
+  test "refute when value evaluates to truthy" do
     try do
-      refute Value.truthy
+      refute Value.truthy()
       raise "refute was supposed to fail"
     rescue
       error in [ExUnit.AssertionError] ->
-        "Value.truthy()"   = error.expr |> Macro.to_string
-        "Expected false or nil, got true" = error.message
+        "refute Value.truthy()" = Macro.to_string(error.expr)
+        "Expected false or nil, got :truthy" = error.message
     end
   end
 
   test "assert match when equal" do
-    {2, 1} = (assert {2, 1} = Value.tuple)
+    {2, 1} = assert {2, 1} = Value.tuple()
+
+    # With dup vars
+    assert {tuple, tuple} = {Value.tuple(), Value.tuple()}
+    assert <<name_size::size(8), _::binary-size(name_size), " the ", _::binary>> = Value.binary()
+  end
+
+  test "assert match with unused var" do
+    assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+             Code.eval_string("""
+             defmodule ExSample do
+               import ExUnit.Assertions
+
+               def run do
+                 {2, 1} = assert {2, var} = ExUnit.AssertionsTest.Value.tuple()
+               end
+             end
+             """)
+           end) =~ "variable \"var\" is unused"
+  after
+    :code.purge(ExSample)
+    :code.delete(ExSample)
+  end
+
+  test "assert match with quote on left-side" do
+    assert quote(do: x in Alias) = quote(do: x in Alias)
+  end
+
+  defmacro quote_like(ast), do: Macro.escape(ast, prune_metadata: true)
+
+  test "assert match with quote-like on left-side" do
+    assert quote_like(x in Alias) = quote_like(x in Alias)
+  end
+
+  test "assert match expands argument in match context" do
+    {x, y, z} = {1, 2, 3}
+    assert vec(x: ^x, y: ^y) = vec(x: x, y: y, z: z)
+  end
+
+  @test_mod_attribute %{key: :value}
+  test "assert match with module attribute" do
+    try do
+      assert {@test_mod_attribute, 1} = Value.tuple()
+    rescue
+      error in [ExUnit.AssertionError] ->
+        assert "{%{key: :value}, 1}" == Macro.to_string(error.left)
+    end
+  end
+
+  test "assert parallel match" do
+    assert %URI{} = uri = apply(URI, :parse, ["/foo"])
+    # This should not warn
+    assert %URI{uri | path: "/bar"}.path == "/bar"
+
+    assert uri = %URI{} = apply(URI, :parse, ["/foo"])
+    # This should not warn
+    assert %URI{uri | path: "/bar"}.path == "/bar"
+  end
+
+  test "assert match with pinned variable" do
+    a = 1
+    {2, 1} = assert {2, ^a} = Value.tuple()
+
+    try do
+      assert {^a, 1} = Value.tuple()
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "match (=) failed\n" <> "The following variables were pinned:\n" <> "  a = 1" =
+          error.message
+
+        "assert {^a, 1} = Value.tuple()" = Macro.to_string(error.expr)
+    end
+  end
+
+  test "assert match with pinned variable from another context" do
+    var!(a, Elixir) = 1
+    {2, 1} = assert {2, ^var!(a, Elixir)} = Value.tuple()
+
+    try do
+      assert {^var!(a, Elixir), 1} = Value.tuple()
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "match (=) failed" = error.message
+        "assert {^var!(a, Elixir), 1} = Value.tuple()" = Macro.to_string(error.expr)
+    end
+  end
+
+  test "assert match with `when` in the pattern fails" do
+    message = """
+    invalid pattern in assert\/1:
+
+      x when is_map(x)
+
+    To assert with guards, use match?/2:
+
+      assert match?(x when is_map(x), %{})
+    """
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_string("""
+      defmodule AssertGuard do
+        import ExUnit.Assertions
+
+        def run do
+          assert (x when is_map(x)) = %{}
+        end
+      end
+      """)
+    end
+  after
+    :code.purge(AssertGuard)
+    :code.delete(AssertGuard)
+  end
+
+  test "assert match with __ENV__ in the pattern" do
+    message =
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        assert_raise CompileError, fn ->
+          Code.eval_string("""
+          defmodule EnvMatch do
+            import ExUnit.Assertions
+
+            def run do
+              assert __ENV__ = %{}
+            end
+          end
+          """)
+        end
+      end)
+
+    assert message =~ "invalid pattern in match, __ENV__ is not allowed in matches"
+  after
+    :code.purge(EnvMatch)
+    :code.delete(EnvMatch)
+  end
+
+  test "assert match?" do
+    true = assert match?({2, 1}, Value.tuple())
+
+    try do
+      assert match?({:ok, _}, Process.get(:unused, :ok))
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "match (match?) failed" = error.message
+        "assert match?({:ok, _}, Process.get(:unused, :ok))" = Macro.to_string(error.expr)
+        ":ok" = Macro.to_string(error.right)
+    end
+  end
+
+  test "assert match? with guards" do
+    true = assert match?(tuple when is_tuple(tuple), Value.tuple())
+
+    try do
+      assert match?(tuple when not is_tuple(tuple), error(true))
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "match (match?) failed" = error.message
+
+        "assert match?(tuple when not is_tuple(tuple), error(true))" = Macro.to_string(error.expr)
+
+        "{:error, true}" = Macro.to_string(error.right)
+    end
+  end
+
+  test "refute match?" do
+    false = refute match?({1, 1}, Value.tuple())
+
+    try do
+      refute match?({:error, _}, error(true))
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "match (match?) succeeded, but should have failed" = error.message
+        "refute match?({:error, _}, error(true))" = Macro.to_string(error.expr)
+        "{:error, true}" = Macro.to_string(error.right)
+    end
+  end
+
+  test "assert match? with pinned variable" do
+    a = 1
+
+    try do
+      assert(match?({^a, 1}, Value.tuple()))
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "match (match?) failed\nThe following variables were pinned:\n  a = 1" = error.message
+
+        "assert match?({^a, 1}, Value.tuple())" = Macro.to_string(error.expr)
+    end
+  end
+
+  test "refute match? with pinned variable" do
+    a = 2
+
+    try do
+      refute(match?({^a, 1}, Value.tuple()))
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        """
+        match (match?) succeeded, but should have failed
+        The following variables were pinned:
+          a = 2\
+        """ = error.message
+
+        "refute match?({^a, 1}, Value.tuple())" = Macro.to_string(error.expr)
+    end
   end
 
   test "assert receive waits" do
-    parent = self
-    spawn fn -> send parent, :hello end
+    parent = self()
+    spawn(fn -> send(parent, :hello) end)
     :hello = assert_receive :hello
   end
 
+  @string "hello"
+
+  test "assert receive with interpolated compile-time string" do
+    parent = self()
+    spawn(fn -> send(parent, "string: hello") end)
+    "string: #{@string}" = assert_receive "string: #{@string}"
+  end
+
+  test "assert receive accepts custom failure message" do
+    send(self(), :hello)
+    assert_receive message, 0, "failure message"
+    :hello = message
+  end
+
+  test "assert receive with message in mailbox after timeout, but before reading mailbox tells user to increase timeout" do
+    parent = self()
+    # This is testing a race condition, so it's not
+    # guaranteed this works under all loads of the system
+    timeout = 100
+    spawn(fn -> Process.send_after(parent, :hello, timeout) end)
+
+    try do
+      assert_receive :hello, timeout
+    rescue
+      error in [ExUnit.AssertionError] ->
+        true =
+          error.message =~ "Found message matching :hello after 100ms" or
+            error.message =~ "no matching message after 100ms"
+    end
+  end
+
+  test "assert_receive exposes nested macro variables" do
+    send(self(), {:hello})
+    assert_receive {~l(a)}, 0, "failure message"
+
+    assert a == :hello
+  end
+
+  test "assert_receive raises on invalid timeout" do
+    timeout = ok(1)
+
+    try do
+      assert_receive {~l(_a)}, timeout
+    rescue
+      error in [ArgumentError] ->
+        "timeout must be a non-negative integer, got: {:ok, 1}" = error.message
+    end
+  end
+
+  test "assert_receive expands argument in match context" do
+    {x, y, z} = {1, 2, 3}
+    send(self(), vec(x: x, y: y, z: z))
+    assert_receive vec(x: ^x, y: ^y)
+  end
+
+  test "assert_receive expands argument in guard context" do
+    send(self(), {:ok, 0, :other})
+    assert_receive {:ok, val, atom} when is_zero(val) and is_atom(atom)
+  end
+
   test "assert received does not wait" do
-    send self, :hello
+    send(self(), :hello)
     :hello = assert_received :hello
   end
 
-  test "assert received when different" do
+  @received :hello
+
+  test "assert received with module attribute" do
+    send(self(), :hello)
+    :hello = assert_received @received
+  end
+
+  test "assert received with pinned variable" do
+    status = :valid
+    send(self(), {:status, :invalid})
+
+    try do
+      assert_received {:status, ^status}
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        """
+        Assertion failed, no matching message after 0ms
+        The following variables were pinned:
+          status = :valid
+        Showing 1 of 1 message in the mailbox\
+        """ = error.message
+
+        "assert_received {:status, ^status}" = Macro.to_string(error.expr)
+        "{:status, ^status}" = Macro.to_string(error.left)
+    end
+  end
+
+  test "assert received with multiple identical pinned variables" do
+    status = :valid
+    send(self(), {:status, :invalid, :invalid})
+
     try do
-      "This should never be tested" = assert_received :hello
+      assert_received {:status, ^status, ^status}
+      flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
-        "No message matching :hello" = error.message
+        """
+        Assertion failed, no matching message after 0ms
+        The following variables were pinned:
+          status = :valid
+        Showing 1 of 1 message in the mailbox\
+        """ = error.message
+
+        "assert_received {:status, ^status, ^status}" = Macro.to_string(error.expr)
+        "{:status, ^status, ^status}" = Macro.to_string(error.left)
+        "\n\nAssertion failed" <> _ = Exception.message(error)
     end
   end
 
-  test "assert received leaks" do
-    send self, {:hello, :world}
+  test "assert received with multiple unique pinned variables" do
+    status = :valid
+    other_status = :invalid
+    send(self(), {:status, :invalid, :invalid})
+
+    try do
+      assert_received {:status, ^status, ^other_status}
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        """
+        Assertion failed, no matching message after 0ms
+        The following variables were pinned:
+          other_status = :invalid
+          status = :valid
+        Showing 1 of 1 message in the mailbox\
+        """ = error.message
+
+        "assert_received {:status, ^status, ^other_status}" = Macro.to_string(error.expr)
+        "{:status, ^status, ^other_status}" = Macro.to_string(error.left)
+    end
+  end
+
+  test "assert received when empty mailbox" do
+    try do
+      assert_received :hello
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "Assertion failed, no matching message after 0ms\nThe process mailbox is empty." =
+          error.message
+
+        "assert_received :hello" = Macro.to_string(error.expr)
+    end
+  end
+
+  test "assert received when different message" do
+    send(self(), {:message, :not_expected, :at_all})
+
+    try do
+      assert_received :hello
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        """
+        Assertion failed, no matching message after 0ms
+        Showing 1 of 1 message in the mailbox\
+        """ = error.message
+
+        "assert_received :hello" = Macro.to_string(error.expr)
+        ":hello" = Macro.to_string(error.left)
+    end
+  end
+
+  test "assert received when different message having more than 10 on mailbox" do
+    for i <- 1..11, do: send(self(), {:message, i})
+
+    try do
+      assert_received x when x == :hello
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        """
+        Assertion failed, no matching message after 0ms
+        Showing 10 of 11 messages in the mailbox\
+        """ = error.message
+
+        "assert_received x when x == :hello" = Macro.to_string(error.expr)
+        "x when x == :hello" = Macro.to_string(error.left)
+    end
+  end
+
+  test "assert received binds variables" do
+    send(self(), {:hello, :world})
     assert_received {:hello, world}
     :world = world
   end
 
+  test "assert received does not leak external variables used in guards" do
+    send(self(), {:hello, :world})
+    guard_world = :world
+    assert_received {:hello, world} when world == guard_world
+    :world = world
+  end
+
   test "refute received does not wait" do
     false = refute_received :hello
   end
 
   test "refute receive waits" do
-    false = refute_receive :hello
+    false = refute_receive :hello, 100
   end
 
   test "refute received when equal" do
-    send self, :hello
+    send(self(), :hello)
+
     try do
-      "This should never be tested" = refute_received :hello
+      refute_received :hello
+      flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
         "Unexpectedly received message :hello (which matched :hello)" = error.message
@@ -120,135 +636,217 @@ defmodule ExUnit.AssertionsTest do
   end
 
   test "assert in when member" do
-    true = assert 'foo' in ['foo', 'bar']
+    true = assert ~c"foo" in [~c"foo", ~c"bar"]
   end
 
   test "assert in when is not member" do
     try do
-      "This should never be tested" = assert 'foo' in 'bar'
+      assert ~c"foo" in ~c"bar"
+      flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
-        'foo' = error.left
-        'bar' = error.right
-        "'foo' in 'bar'" = error.expr |> Macro.to_string
+        ~c"foo" = error.left
+        ~c"bar" = error.right
+        ~S(assert ~c"foo" in ~c"bar") = Macro.to_string(error.expr)
     end
   end
 
   test "refute in when is not member" do
-    false = refute 'baz' in ['foo', 'bar']
+    false = refute ~c"baz" in [~c"foo", ~c"bar"]
   end
 
   test "refute in when is member" do
     try do
-      "This should never be tested" = refute 'foo' in ['foo', 'bar']
+      refute ~c"foo" in [~c"foo", ~c"bar"]
+      flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
-        'foo'          = error.left
-        ['foo', 'bar'] = error.right
-        "'foo' in ['foo', 'bar']" = error.expr |> Macro.to_string
+        ~c"foo" = error.left
+        [~c"foo", ~c"bar"] = error.right
+        ~S(refute ~c"foo" in [~c"foo", ~c"bar"]) = Macro.to_string(error.expr)
     end
   end
 
   test "assert match" do
-    {:ok, true} = assert {:ok, _} = {:ok, true}
+    {:ok, true} = assert {:ok, _} = ok(true)
+  end
+
+  test "assert match with bitstrings" do
+    "foobar" = assert "foo" <> bar = "foobar"
+    "bar" = bar
   end
 
   test "assert match when no match" do
     try do
-      "This should never be tested" = assert {:ok, _} = "bar"
+      assert {:ok, _} = error(true)
     rescue
       error in [ExUnit.AssertionError] ->
-        "match (=) failed"   = error.message
-        "{:ok, _} = \"bar\"" = error.expr |> Macro.to_string
-        "bar"                = error.right
+        "match (=) failed" = error.message
+        "assert {:ok, _} = error(true)" = Macro.to_string(error.expr)
+        "{:error, true}" = Macro.to_string(error.right)
+    end
+  end
+
+  test "assert match when falsy but not match" do
+    try do
+      assert {:ok, _x} = nil
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "match (=) failed" = error.message
+        "assert {:ok, _x} = nil" = Macro.to_string(error.expr)
+        "nil" = Macro.to_string(error.right)
+    end
+  end
+
+  test "assert match when falsy" do
+    try do
+      assert _x = nil
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "Expected truthy, got nil" = error.message
+        "assert _x = nil" = Macro.to_string(error.expr)
     end
   end
 
   test "refute match when no match" do
     try do
-      "This should never be tested" = refute _ = "bar"
+      refute _ = ok(true)
+      flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
-        "bar"         = error.right
-        "_ = \"bar\"" = error.expr |> Macro.to_string
-        "match (=) succeeded, but should have failed" = error.message
+        "refute _ = ok(true)" = Macro.to_string(error.expr)
+        "Expected false or nil, got {:ok, true}" = error.message
     end
   end
 
   test "assert regex match" do
-    true = assert "foo" =~ ~r(o)
+    true = assert "foo" =~ ~r/o/
   end
 
   test "assert regex match when no match" do
     try do
-      "This should never be tested" = assert "foo" =~ ~r(a)
+      assert "foo" =~ ~r/a/
+      flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
         "foo" = error.left
-        ~r{a} = error.right
+        %Regex{} = error.right
     end
   end
 
   test "refute regex match" do
-    false = refute "foo" =~ ~r(a)
+    false = refute "foo" =~ ~r/a/
   end
 
   test "refute regex match when match" do
     try do
-      "This should never be tested" = refute "foo" =~ ~r(o)
+      refute "foo" =~ ~r/o/
+      flunk("This should never be tested")
     rescue
       error in [ExUnit.AssertionError] ->
         "foo" = error.left
-        ~r"o" = error.right
+        %Regex{} = error.right
     end
   end
 
   test "assert raise with no error" do
-    "This should never be tested" = assert_raise ArgumentError, fn ->
-      # nothing
-    end
+    assert_raise ArgumentError, fn -> nil end
+    flunk("This should never be tested")
   rescue
     error in [ExUnit.AssertionError] ->
       "Expected exception ArgumentError but nothing was raised" = error.message
   end
 
   test "assert raise with error" do
-    error = assert_raise ArgumentError, fn ->
-      raise ArgumentError, "test error"
-    end
-
+    error = assert_raise ArgumentError, fn -> raise ArgumentError, "test error" end
     "test error" = error.message
   end
 
+  @compile {:no_warn_undefined, Not.Defined}
+
   test "assert raise with some other error" do
-    "This should never be tested" = assert_raise ArgumentError, fn ->
-      Not.Defined.function(1, 2, 3)
-    end
+    "This should never be tested" =
+      assert_raise ArgumentError, fn -> Not.Defined.function(1, 2, 3) end
   rescue
     error in [ExUnit.AssertionError] ->
-      "Expected exception ArgumentError but got UndefinedFunctionError (undefined function: Not.Defined.function/3)" = error.message
+      "Expected exception ArgumentError but got UndefinedFunctionError " <>
+        "(function Not.Defined.function/3 is undefined (module Not.Defined is not available))" =
+        error.message
   end
 
-  test "assert raise with erlang error" do
+  test "assert raise with some other error includes stacktrace from original error" do
+    "This should never be tested" =
+      assert_raise ArgumentError, fn -> Not.Defined.function(1, 2, 3) end
+  rescue
+    ExUnit.AssertionError ->
+      [{Not.Defined, :function, [1, 2, 3], _} | _] = __STACKTRACE__
+  end
+
+  test "assert raise with Erlang error" do
     assert_raise SyntaxError, fn ->
       List.flatten(1)
     end
   rescue
     error in [ExUnit.AssertionError] ->
-      "Expected exception SyntaxError but got FunctionClauseError (no function clause matching in :lists.flatten/1)" = error.message
+      "Expected exception SyntaxError but got FunctionClauseError (no function clause matching in :lists.flatten/1)" =
+        error.message
   end
 
-  test "assert greater than operator" do
+  test "assert raise comparing messages (for equality)" do
+    assert_raise RuntimeError, "foo", fn ->
+      raise RuntimeError, "bar"
+    end
+  rescue
+    error in [ExUnit.AssertionError] ->
+      """
+      Wrong message for RuntimeError
+      expected:
+        "foo"
+      actual:
+        "bar"\
+      """ = error.message
+  end
+
+  test "assert raise comparing messages (with a regex)" do
+    assert_raise RuntimeError, ~r/ba[zk]/, fn ->
+      raise RuntimeError, "bar"
+    end
+  rescue
+    error in [ExUnit.AssertionError] ->
+      """
+      Wrong message for RuntimeError
+      expected:
+        ~r/ba[zk]/
+      actual:
+        "bar"\
+      """ = error.message
+  end
+
+  test "assert raise with an exception with bad message/1 implementation" do
+    assert_raise BrokenError, fn ->
+      raise BrokenError
+    end
+  rescue
+    error in [ExUnit.AssertionError] ->
+      """
+      Got exception ExUnit.AssertionsTest.BrokenError but it failed to produce a message with:
+
+      ** (RuntimeError) error
+      """ <> _ = error.message
+  end
+
+  test "assert greater-than operator" do
     true = assert 2 > 1
   end
 
-  test "assert greater than operator error" do
-    "This should never be tested" = assert 1 > 2
+  test "assert greater-than operator error" do
+    assert 1 > 2
+    flunk("This should never be tested")
   rescue
     error in [ExUnit.AssertionError] ->
-      1       = error.left
-      2       = error.right
-      "1 > 2" = error.expr |> Macro.to_string
+      1 = error.left
+      2 = error.right
+      "assert 1 > 2" = Macro.to_string(error.expr)
   end
 
   test "assert less or equal than operator" do
@@ -256,10 +854,11 @@ defmodule ExUnit.AssertionsTest do
   end
 
   test "assert less or equal than operator error" do
-    "This should never be tested" = assert 2 <= 1
+    assert 2 <= 1
+    flunk("This should never be tested")
   rescue
     error in [ExUnit.AssertionError] ->
-      "2 <= 1" = error.expr |> Macro.to_string
+      "assert 2 <= 1" = Macro.to_string(error.expr)
       2 = error.left
       1 = error.right
   end
@@ -270,25 +869,97 @@ defmodule ExUnit.AssertionsTest do
   end
 
   test "assert operator with custom message" do
-    "This should never be tested" = assert 1 > 2, "assertion"
+    assert 1 > 2, "assertion"
+    flunk("This should never be tested")
+  rescue
+    error in [ExUnit.AssertionError] ->
+      "assertion" = error.message
+  end
+
+  test "assert operator with custom options" do
+    assert 1 > 2, message: "assertion"
+    flunk("This should never be tested")
   rescue
     error in [ExUnit.AssertionError] ->
       "assertion" = error.message
   end
 
+  test "assert operator with invalid options" do
+    assert 1 > 2, message: 123
+    flunk("This should never be tested")
+  rescue
+    error in [ArgumentError] ->
+      ":message in ExUnit.Assertion must be a binary, got: 123" = error.message
+  end
+
+  test "assert lack of equality" do
+    try do
+      assert "one" != "one"
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "Assertion with != failed, both sides are exactly equal" = error.message
+        "one" = error.left
+    end
+
+    try do
+      assert 2 != 2.0
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "Assertion with != failed" = error.message
+        2 = error.left
+        2.0 = error.right
+    end
+  end
+
+  test "refute equality" do
+    try do
+      refute "one" == "one"
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "Refute with == failed, both sides are exactly equal" = error.message
+        "one" = error.left
+    end
+
+    try do
+      refute 2 == 2.0
+      flunk("This should never be tested")
+    rescue
+      error in [ExUnit.AssertionError] ->
+        "Refute with == failed" = error.message
+        2 = error.left
+        2.0 = error.right
+    end
+  end
+
   test "assert in delta" do
     true = assert_in_delta(1.1, 1.2, 0.2)
   end
 
+  test "assert in delta raises when passing a negative delta" do
+    assert_raise ArgumentError, fn ->
+      assert_in_delta(1.1, 1.2, -0.2)
+    end
+  end
+
+  test "assert in delta works with equal values and a delta of zero" do
+    assert_in_delta(10, 10, 0)
+  end
+
   test "assert in delta error" do
-    "This should never be tested" = assert_in_delta(10, 12, 1)
+    assert_in_delta(10, 12, 1)
+    flunk("This should never be tested")
   rescue
     error in [ExUnit.AssertionError] ->
-      "Expected the difference between 10 and 12 (2) to be less than 1" = error.message
+      "Expected the difference between 10 and 12 (2) to be less than or equal to 1" =
+        error.message
   end
 
   test "assert in delta with message" do
-    "This should never be tested" = assert_in_delta(10, 12, 1, "test message")
+    assert_in_delta(10, 12, 1, "test message")
+    flunk("This should never be tested")
   rescue
     error in [ExUnit.AssertionError] ->
       "test message" = error.message
@@ -299,14 +970,16 @@ defmodule ExUnit.AssertionsTest do
   end
 
   test "refute in delta error" do
-    "This should never be tested" = refute_in_delta(10, 11, 2)
+    refute_in_delta(10, 11, 2)
+    flunk("This should never be tested")
   rescue
     error in [ExUnit.AssertionError] ->
       "Expected the difference between 10 and 11 (1) to be more than 2" = error.message
   end
 
   test "refute in delta with message" do
-    "This should never be tested" = refute_in_delta(10, 11, 2, "test message")
+    refute_in_delta(10, 11, 2, "test message")
+    flunk("This should never be tested")
   rescue
     error in [ExUnit.AssertionError] ->
       "test message (difference between 10 and 11 is less than 2)" = error.message
@@ -334,11 +1007,11 @@ defmodule ExUnit.AssertionsTest do
   end
 
   test "catch_throw with throw" do
-    1 = catch_throw(throw 1)
+    1 = catch_throw(throw(1))
   end
 
   test "catch_exit with exit" do
-    1 = catch_exit(exit 1)
+    1 = catch_exit(exit(1))
   end
 
   test "catch_error with error" do
@@ -346,16 +1019,45 @@ defmodule ExUnit.AssertionsTest do
   end
 
   test "flunk" do
-    "This should never be tested" = flunk
+    flunk()
+    flunk("This should never be tested")
   rescue
     error in [ExUnit.AssertionError] ->
       "Flunked!" = error.message
   end
 
   test "flunk with message" do
-    "This should never be tested" = flunk "This should raise an error"
+    flunk("This should raise an error")
+    flunk("This should never be tested")
   rescue
     error in [ExUnit.AssertionError] ->
       "This should raise an error" = error.message
   end
+
+  test "flunk with wrong argument type" do
+    flunk(["flunk takes a binary, not a list"])
+    flunk("This should never be tested")
+  rescue
+    error ->
+      "no function clause matching in ExUnit.Assertions.flunk/1" =
+        FunctionClauseError.message(error)
+  end
+
+  test "AssertionError.message/1 is nicely formatted" do
+    assert :a = :b
+  rescue
+    error in [ExUnit.AssertionError] ->
+      """
+
+
+      match (=) failed
+      code:  assert :a = :b
+      left:  :a
+      right: :b
+      """ = Exception.message(error)
+  end
+
+  defp ok(val), do: {:ok, val}
+  defp error(val), do: {:error, val}
+  defp not_equal(left, right), do: left != right
 end
diff --git a/lib/ex_unit/test/ex_unit/callbacks_test.exs b/lib/ex_unit/test/ex_unit/callbacks_test.exs
index 219540ad107..81ea80b2b91 100644
--- a/lib/ex_unit/test/ex_unit/callbacks_test.exs
+++ b/lib/ex_unit/test/ex_unit/callbacks_test.exs
@@ -1,20 +1,28 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule ExUnit.CallbacksTest do
   use ExUnit.Case
 
   import ExUnit.CaptureIO
 
+  def start_counter(_) do
+    [counter: []]
+  end
+
   test "callbacks run custom code with context" do
     defmodule CallbacksTest do
       use ExUnit.Case
 
       setup_all do
-        {:ok, [context: :setup_all]}
+        [context: :setup_all]
       end
 
       setup do
-        {:ok, [initial_setup: true]}
+        %{initial_setup: true}
       end
 
       setup context do
@@ -28,8 +36,58 @@ defmodule ExUnit.CallbacksTest do
       end
     end
 
-    assert capture_io(fn -> ExUnit.run end) =~
-           "1 tests, 0 failures"
+    assert capture_io(fn -> ExUnit.run() end) =~ "1 test, 0 failures"
+  end
+
+  test "named callbacks run custom code in order" do
+    defmodule NamedCallbacksTest do
+      use ExUnit.Case
+
+      import ExUnit.CallbacksTest
+      setup_all :start_counter
+
+      setup :store_1
+      setup [:store_2, :store_3]
+
+      setup context do
+        [counter: [4 | context.counter]]
+      end
+
+      setup :store_5
+
+      test "callbacks", context do
+        assert context[:counter] == [5, 4, 3, 2, 1]
+      end
+
+      defp store(context, number), do: [counter: [number | context.counter]]
+      defp store_1(context), do: store(context, 1)
+      defp store_2(context), do: store(context, 2)
+      defp store_3(context), do: store(context, 3)
+      defp store_5(context), do: store(context, 5)
+    end
+
+    assert capture_io(fn -> ExUnit.run() end) =~ "1 test, 0 failures"
+  end
+
+  test "named callbacks support {module, function} tuples" do
+    defmodule NamedCallbacksTupleTest do
+      use ExUnit.Case
+
+      setup_all {__MODULE__, :setup_1}
+      setup [{__MODULE__, :setup_2}, {__MODULE__, :setup_3}]
+
+      test "callbacks", context do
+        assert context[:setup_1]
+        assert context[:setup_2]
+        assert context[:setup_3]
+      end
+
+      def setup_1(_), do: [setup_1: true]
+      def setup_2(_), do: [setup_2: true]
+      def setup_3(_), do: [setup_3: true]
+    end
+
+    assert capture_io(fn -> ExUnit.run() end) =~ "1 test, 0 failures"
   end
 
   test "doesn't choke on setup errors" do
@@ -37,7 +95,7 @@ defmodule ExUnit.CallbacksTest do
       use ExUnit.Case
 
       setup _ do
-        :ok = error
+        :ok = error()
       end
 
       test "ok" do
@@ -47,8 +105,8 @@ defmodule ExUnit.CallbacksTest do
       defp error, do: :error
     end
 
-    assert capture_io(fn -> ExUnit.run end) =~
-           "** (MatchError) no match of right hand side value: :error"
+    assert capture_io(fn -> ExUnit.run() end) =~
+             "** (MatchError) no match of right hand side value:"
   end
 
   test "doesn't choke on setup_all errors" do
@@ -56,7 +114,7 @@ defmodule ExUnit.CallbacksTest do
       use ExUnit.Case
 
       setup_all _ do
-        :ok = error
+        :ok = error()
       end
 
       test "ok" do
@@ -66,8 +124,42 @@ defmodule ExUnit.CallbacksTest do
       defp error, do: :error
     end
 
-    assert capture_io(fn -> ExUnit.run end) =~
-           "** (MatchError) no match of right hand side value: :error"
+    assert capture_io(fn -> ExUnit.run() end) =~
+             "** (MatchError) no match of right hand side value:"
+  end
+
+  test "doesn't choke on setup_all exits" do
+    defmodule SetupAllExitTest do
+      use ExUnit.Case
+
+      setup_all _ do
+        Process.exit(self(), :error)
+      end
+
+      test "ok" do
+        assert true
+      end
+    end
+
+    assert capture_io(fn -> ExUnit.run() end) =~ "1 test, 0 failures, 1 invalid"
+  end
+
+  test "doesn't choke on dead supervisor" do
+    defmodule StartSupervisedErrorTest do
+      use ExUnit.Case
+
+      @tag timeout: 500
+      test "ok" do
+        fun = fn ->
+          Process.flag(:trap_exit, true)
+          Process.sleep(:infinity)
+        end
+
+        start_supervised({Task, fun})
+      end
+    end
+
+    assert capture_io(fn -> ExUnit.run() end) =~ "supervisor shutdown timed out after 500ms"
   end
 
   test "doesn't choke on on_exit errors" do
@@ -75,15 +167,15 @@ defmodule ExUnit.CallbacksTest do
       use ExUnit.Case
 
       test "ok" do
-        on_exit fn -> :ok = error end
+        on_exit(fn -> :ok = error() end)
         :ok
       end
 
       defp error, do: :error
     end
 
-    assert capture_io(fn -> ExUnit.run end) =~
-           "** (MatchError) no match of right hand side value: :error"
+    assert capture_io(fn -> ExUnit.run() end) =~
+             "** (MatchError) no match of right hand side value:"
   end
 
   test "doesn't choke when on_exit exits" do
@@ -91,18 +183,38 @@ defmodule ExUnit.CallbacksTest do
       use ExUnit.Case, async: false
 
       test "ok" do
-        on_exit fn -> Process.exit(self(), :kill) end
+        on_exit(fn -> Process.exit(self(), :kill) end)
         :ok
       end
     end
 
-    assert capture_io(fn -> ExUnit.run end) =~
-           ">) killed"
+    assert capture_io(fn -> ExUnit.run() end) =~ ">) killed"
+  end
+
+  test "invalidates all tests when on_exit errors within setup_all" do
+    defmodule InvalidatesTestsOnExitErrorTest do
+      use ExUnit.Case
+
+      setup_all do
+        on_exit(fn -> raise "boom" end)
+        :ok
+      end
+
+      test "succeeds" do
+        assert true
+      end
+
+      test "fails" do
+        assert false
+      end
+    end
+
+    assert capture_io(fn -> ExUnit.run() end) =~ "2 tests, 2 failures"
   end
 
   defp no_formatters! do
     ExUnit.configure(formatters: [])
-    on_exit fn -> ExUnit.configure(formatters: [ExUnit.CLIFormatter]) end
+    on_exit(fn -> ExUnit.configure(formatters: [ExUnit.CLIFormatter]) end)
   end
 
   test "exits with shutdown reason" do
@@ -112,22 +224,24 @@ defmodule ExUnit.CallbacksTest do
       setup do
         parent = self()
 
-        pid = spawn_link fn ->
-          Process.flag(:trap_exit, true)
-          send parent, :ready
-          receive do
-            {:EXIT, ^parent, :shutdown} ->
-              receive do: ({:on_exit, pid} -> send pid, :done)
-          end
-        end
+        pid =
+          spawn_link(fn ->
+            Process.flag(:trap_exit, true)
+            send(parent, :ready)
+
+            receive do
+              {:EXIT, ^parent, :shutdown} ->
+                receive do: ({:on_exit, pid} -> send(pid, :done))
+            end
+          end)
 
         receive do: (:ready -> :ok)
 
-        on_exit fn ->
-          send pid, {:on_exit, self}
+        on_exit(fn ->
+          send(pid, {:on_exit, self()})
           assert_receive :done
-          IO.puts "on_exit run"
-        end
+          IO.puts("on_exit run")
+        end)
 
         :ok
       end
@@ -137,9 +251,9 @@ defmodule ExUnit.CallbacksTest do
       end
     end
 
-    output = capture_io(fn -> ExUnit.run end)
+    output = capture_io(fn -> ExUnit.run() end)
     assert output =~ "on_exit run"
-    assert output =~ "1 tests, 0 failures"
+    assert output =~ "1 test, 0 failures"
   end
 
   test "runs multiple on_exit exits and overrides by ref" do
@@ -147,56 +261,56 @@ defmodule ExUnit.CallbacksTest do
       use ExUnit.Case
 
       setup do
-        on_exit fn ->
-          IO.puts "on_exit setup run"
-        end
+        on_exit(fn ->
+          IO.puts("on_exit setup run")
+        end)
 
-        on_exit {:overridden, 1}, fn ->
-          IO.puts "on_exit 1 overridden -> not run"
-        end
+        on_exit({:overridden, 1}, fn ->
+          IO.puts("on_exit 1 overridden -> not run")
+        end)
 
         :ok
       end
 
       setup_all do
-        on_exit fn ->
-          IO.puts "on_exit setup_all run"
-        end
+        on_exit(fn ->
+          IO.puts("on_exit setup_all run")
+        end)
 
         :ok
       end
 
       test "ok" do
-        on_exit fn ->
-          IO.puts "simple on_exit run"
-        end
+        on_exit(fn ->
+          IO.puts("simple on_exit run")
+        end)
 
-        on_exit {:overridden, 2}, fn ->
-          IO.puts "on_exit 2 overridden -> not run"
-        end
+        on_exit({:overridden, 2}, fn ->
+          IO.puts("on_exit 2 overridden -> not run")
+        end)
 
-        on_exit {:overridden, 2}, fn ->
-          IO.puts "on_exit 2 overrides -> run"
-        end
+        on_exit({:overridden, 2}, fn ->
+          IO.puts("on_exit 2 overrides -> run")
+        end)
 
-        on_exit {:overridden, 1}, fn ->
-          IO.puts "on_exit 1 overrides -> run"
-        end
+        on_exit({:overridden, 1}, fn ->
+          IO.puts("on_exit 1 overrides -> run")
+        end)
 
         :ok
       end
     end
 
-    no_formatters!
-    output = capture_io(fn -> ExUnit.run end)
+    no_formatters!()
+    output = capture_io(fn -> ExUnit.run() end)
 
     assert output =~ """
-    on_exit 2 overrides -> run
-    simple on_exit run
-    on_exit 1 overrides -> run
-    on_exit setup run
-    on_exit setup_all run
-    """
+           on_exit 2 overrides -> run
+           simple on_exit run
+           on_exit 1 overrides -> run
+           on_exit setup run
+           on_exit setup_all run
+           """
 
     refute output =~ "not run"
   end
@@ -206,38 +320,129 @@ defmodule ExUnit.CallbacksTest do
       use ExUnit.Case
 
       setup do
-        on_exit fn ->
-          IO.puts "on_exit setup run"
-        end
+        on_exit(fn ->
+          IO.puts("on_exit setup run")
+        end)
 
         :ok
       end
 
       setup_all do
-        on_exit fn ->
-          IO.puts "on_exit setup_all run"
-        end
+        on_exit(fn ->
+          IO.puts("on_exit setup_all run")
+        end)
 
         :ok
       end
 
       test "ok" do
-        on_exit fn ->
-          IO.puts "simple on_exit run"
-        end
+        on_exit(fn ->
+          IO.puts("simple on_exit run")
+        end)
 
-        flunk "oops"
+        flunk("oops")
       end
     end
 
-    no_formatters!
-    output = capture_io(fn -> ExUnit.run end)
+    no_formatters!()
+    output = capture_io(fn -> ExUnit.run() end)
 
     assert output =~ """
-    simple on_exit run
-    on_exit setup run
-    on_exit setup_all run
-    """
+           simple on_exit run
+           on_exit setup run
+           on_exit setup_all run
+           """
+  end
+
+  test "raises an error when using setup/2 with something other than a block" do
+    message =
+      "setup/2 requires a block as the second argument after the context, got: :start_counter"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_quoted(
+        quote do
+          defmodule SetupWithoutBlockTest do
+            use ExUnit.Case
+            setup context, :start_counter
+          end
+        end
+      )
+    end
+  end
+
+  test "raises an error when using setup_all/2 with something other than a block" do
+    message =
+      "setup_all/2 requires a block as the second argument after the context, got: :start_counter"
+
+    assert_raise ArgumentError, message, fn ->
+      Code.eval_quoted(
+        quote do
+          defmodule SetupWithoutBlockTest do
+            use ExUnit.Case
+            setup_all context, :start_counter
+          end
+        end
+      )
+    end
+  end
+
+  test "raises an error when setting an invalid callback in setup" do
+    defmodule SetupErrorTest do
+      use ExUnit.Case
+
+      setup do: {:ok, "foo"}
+      test "ok", do: :ok
+    end
+
+    output = capture_io(fn -> ExUnit.run() end)
+
+    assert output =~
+             "** (RuntimeError) expected ExUnit setup callback in " <>
+               "ExUnit.CallbacksTest.SetupErrorTest to return the atom :ok, a keyword, or a map, " <>
+               "got {:ok, \"foo\"} instead"
+
+    # Make sure that at least the right file where the setup/setup_all call is defined is included
+    # in the stacktrace.
+    assert output =~ ~r/.*callbacks_test\.exs:\d+/
+  end
+
+  test "raises an error when setting an invalid callback in setup_all" do
+    defmodule SetupAllErrorTest do
+      use ExUnit.Case
+
+      setup_all do: {:ok, "foo"}
+      test "ok", do: :ok
+    end
+
+    output = capture_io(fn -> ExUnit.run() end)
+
+    assert output =~
+             "** (RuntimeError) expected ExUnit setup_all callback in " <>
+               "ExUnit.CallbacksTest.SetupAllErrorTest to return the atom :ok, a keyword, or a map, " <>
+               "got {:ok, \"foo\"} instead"
+
+    # Make sure that at least the right file where the setup/setup_all call is defined is included
+    # in the stacktrace.
+    assert output =~ ~r/.*callbacks_test\.exs:\d+/
+  end
+
+  test "raises an error when overriding a reserved callback key in setup" do
+    defmodule SetupReservedTest do
+      use ExUnit.Case
+
+      setup do
+        {:ok, file: "foo"}
+      end
+
+      test "ok" do
+        :ok
+      end
+    end
+
+    assert capture_io(fn -> ExUnit.run() end) =~
+             "** (RuntimeError) ExUnit setup callback in " <>
+               "ExUnit.CallbacksTest.SetupReservedTest is " <>
+               "trying to set reserved field :file to \"foo\""
   end
 end
 
@@ -245,10 +450,14 @@ defmodule ExUnit.CallbacksNoTests do
   use ExUnit.Case, async: true
 
   setup_all do
-    raise "Never run"
+    if :rand.uniform() >= 0 do
+      raise "never run"
+    end
   end
 
   setup do
-    raise "Never run"
+    if :rand.uniform() >= 0 do
+      raise "never run"
+    end
   end
 end
diff --git a/lib/ex_unit/test/ex_unit/capture_io_test.exs b/lib/ex_unit/test/ex_unit/capture_io_test.exs
index e6606812f16..5d8678a0de8 100644
--- a/lib/ex_unit/test/ex_unit/capture_io_test.exs
+++ b/lib/ex_unit/test/ex_unit/capture_io_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule ExUnit.CaptureIOTest do
   use ExUnit.Case
@@ -9,316 +13,544 @@ defmodule ExUnit.CaptureIOTest do
     end
 
     def until_new_line(this_far, chars, stop_char) do
-      case Enum.split_while(chars, fn(c) -> c != stop_char end) do
+      case Enum.split_while(chars, fn c -> c != stop_char end) do
         {l, []} ->
           {:more, this_far ++ l}
-        {l, [stop_char|rest]} ->
+
+        {l, [stop_char | rest]} ->
           {:done, this_far ++ l ++ [stop_char], rest}
       end
     end
 
-    def get_line(device \\ Process.group_leader) do
-      send device, {:io_request, self, device, {:get_until, :unicode, "", __MODULE__, :until_new_line, [?\n]}}
+    def get_line(device \\ Process.group_leader()) do
+      request = {:get_until, :unicode, "", __MODULE__, :until_new_line, [?\n]}
+      send(device, {:io_request, self(), device, request})
+
       receive do
         {:io_reply, _, data} -> data
       end
     end
   end
 
+  defmodule MockProc do
+    use GenServer
+
+    def start_link(gl) do
+      GenServer.start_link(__MODULE__, gl)
+    end
+
+    @impl GenServer
+    def init(gl) do
+      Process.group_leader(self(), gl)
+      {:ok, nil}
+    end
+
+    @impl GenServer
+    def handle_call({:stdio, message}, _from, state) do
+      IO.puts(message)
+      {:reply, :ok, state}
+    end
+
+    @impl GenServer
+    def handle_call({:prompt, prompt}, _from, state) do
+      prompt
+      |> IO.gets()
+      |> IO.puts()
+
+      {:reply, :ok, state}
+    end
+
+    @impl GenServer
+    def handle_call({:stderr, message}, _from, state) do
+      IO.puts(:stderr, message)
+      {:reply, :ok, state}
+    end
+  end
+
   import ExUnit.CaptureIO
   doctest ExUnit.CaptureIO, import: true
 
-  test "with no output" do
-    assert capture_io(fn ->
-    end) == ""
-  end
+  describe "I/O protocol" do
+    test "with put chars" do
+      assert capture_io(fn ->
+               :io.put_chars("")
+             end) == ""
+
+      assert capture_io(fn ->
+               :io.put_chars("a")
+               :io.put_chars("b")
+             end) == "ab"
+
+      assert capture_io(fn ->
+               :io.put_chars("josé")
+             end) == "josé"
+
+      assert capture_io(fn ->
+               spawn(fn -> :io.put_chars("a") end)
+               Process.sleep(10)
+             end) == "a"
+
+      assert capture_io(fn ->
+               assert :io.put_chars("a") == :ok
+             end)
+    end
 
-  test "with put chars" do
-    assert capture_io(fn ->
-      :io.put_chars("")
-    end) == ""
+    test "with fwrite" do
+      assert capture_io(fn ->
+               :io.fwrite(<<127, 128>>)
+             end) == <<127, 194, 128>>
 
-    assert capture_io(fn ->
-      :io.put_chars("a")
-      :io.put_chars("b")
-    end) == "ab"
+      assert capture_io([encoding: :latin1], fn ->
+               :io.fwrite(<<127, 128>>)
+             end) == <<127, 128>>
+    end
 
-    assert capture_io(fn ->
-      :io.put_chars("josé")
-    end) == "josé"
+    test "with get chars" do
+      assert capture_io(fn ->
+               :io.get_chars(">", 3)
+             end) == ">"
 
-    assert capture_io(fn ->
-      spawn(fn -> :io.put_chars("a") end)
-      :timer.sleep(10)
-    end) == "a"
+      assert capture_io([capture_prompt: false], fn ->
+               :io.get_chars(">", 3)
+             end) == ""
 
-    assert capture_io(fn ->
-      assert :io.put_chars("a") == :ok
-    end)
-  end
+      capture_io(fn ->
+        assert :io.get_chars(">", 3) == :eof
+      end)
 
-  test "with put chars to stderr" do
-    assert capture_io(:stderr, fn ->
-      :io.put_chars(:standard_error, "a")
-    end) == "a"
-  end
+      capture_io("", fn ->
+        assert :io.get_chars(">", 3) == :eof
+      end)
 
-  test "with get chars" do
-    assert capture_io(fn ->
-      :io.get_chars(">", 3)
-    end) == ">"
-
-    assert capture_io([capture_prompt: false], fn ->
-      :io.get_chars(">", 3)
-    end) == ""
-
-    capture_io(fn ->
-      assert :io.get_chars(">", 3) == :eof
-    end)
-
-    capture_io("", fn ->
-      assert :io.get_chars(">", 3) == :eof
-    end)
-
-    capture_io("abc\ndef", fn ->
-      assert :io.get_chars(">", 3) == "abc"
-      assert :io.get_chars(">", 5) == "\ndef"
-      assert :io.get_chars(">", 7) == :eof
-    end)
-
-    capture_io("あいう", fn ->
-      assert :io.get_chars(">", 2) == "あい"
-      assert :io.get_chars(">", 1) == "う"
-      assert :io.get_chars(">", 1) == :eof
-    end)
-  end
+      capture_io("abc\ndef", fn ->
+        assert :io.get_chars(">", 3) == "abc"
+        assert :io.get_chars(">", 5) == "\ndef"
+        assert :io.get_chars(">", 7) == :eof
+      end)
 
-  test "with get line" do
-    assert capture_io(fn ->
-      :io.get_line ">"
-    end) == ">"
-
-    assert capture_io([capture_prompt: false], fn ->
-      :io.get_line ">"
-    end) == ""
-
-    capture_io(fn ->
-      assert :io.get_line(">") == :eof
-    end)
-
-    capture_io("", fn ->
-      assert :io.get_line(">") == :eof
-    end)
-
-    capture_io("\n", fn ->
-      assert :io.get_line(">") == "\n"
-      assert :io.get_line(">") == :eof
-    end)
-
-    capture_io("a", fn ->
-      assert :io.get_line(">") == "a"
-      assert :io.get_line(">") == :eof
-    end)
-
-    capture_io("a\n", fn ->
-      assert :io.get_line(">") == "a\n"
-      assert :io.get_line(">") == :eof
-    end)
-
-    capture_io("a\nb", fn ->
-      assert :io.get_line(">") == "a\n"
-      assert :io.get_line(">") == "b"
-      assert :io.get_line(">") == :eof
-    end)
-
-    capture_io("あい\nう", fn ->
-      assert :io.get_line(">") == "あい\n"
-      assert :io.get_line(">") == "う"
-      assert :io.get_line(">") == :eof
-    end)
-  end
+      capture_io("あいう", fn ->
+        assert :io.get_chars(">", 2) == "あい"
+        assert :io.get_chars(">", 1) == "う"
+        assert :io.get_chars(">", 1) == :eof
+      end)
+    end
 
-  test "with get password" do
-    capture_io(fn ->
-      assert :io.get_password() == :eof
-    end)
-
-    capture_io("", fn ->
-      assert :io.get_password() == :eof
-    end)
-
-    capture_io("abc", fn ->
-      assert :io.get_password() == "abc"
-      assert :io.get_password() == :eof
-    end)
-
-    capture_io("abc\n", fn ->
-      assert :io.get_password() == "abc\n"
-      assert :io.get_password() == :eof
-    end)
-
-    capture_io("\n", fn ->
-      assert :io.get_password() == "\n"
-      assert :io.get_password() == :eof
-    end)
-
-    capture_io("a\nb", fn ->
-      assert :io.get_password() == "a\n"
-      assert :io.get_password() == "b"
-      assert :io.get_password() == :eof
-    end)
-
-    capture_io("あい\nう", fn ->
-      assert :io.get_password() == "あい\n"
-      assert :io.get_password() == "う"
-      assert :io.get_password() == :eof
-    end)
-  end
+    test "with get line" do
+      assert capture_io(fn ->
+               :io.get_line(">")
+             end) == ">"
 
-  test "with get until" do
-    assert capture_io(fn ->
-      :io.scan_erl_form('>')
-    end) == ">"
-
-    assert capture_io("1.\n", fn ->
-      :io.scan_erl_form('>')
-    end) == ">"
-
-    assert capture_io("1\n.\n", fn ->
-       :io.scan_erl_form('>')
-    end) == ">>"
-
-    assert capture_io([capture_prompt: false], fn ->
-      :io.scan_erl_form('>')
-    end) == ""
-
-    capture_io(fn ->
-      assert :io.scan_erl_form('>') == {:eof, 1}
-    end)
-
-   capture_io("1", fn ->
-     assert :io.scan_erl_form('>') == {:ok, [{:integer, 1, 1}], 1}
-     assert :io.scan_erl_form('>') == {:eof, 1}
-   end)
-
-    capture_io("1\n.", fn ->
-      assert :io.scan_erl_form('>') == {:ok, [{:integer, 1, 1}, {:dot, 2}], 2}
-      assert :io.scan_erl_form('>') == {:eof, 1}
-    end)
-
-    capture_io("1.\n.", fn ->
-      assert :io.scan_erl_form('>') == {:ok, [{:integer, 1, 1}, {:dot, 1}], 2}
-      assert :io.scan_erl_form('>') == {:ok, [dot: 1], 1}
-      assert :io.scan_erl_form('>') == {:eof, 1}
-    end)
-
-    capture_io("\"a", fn ->
-      assert :io.scan_erl_form('>') == {:error, {1, :erl_scan, {:string, 34, 'a'}}, 1}
-      assert :io.scan_erl_form('>') == {:eof, 1}
-    end)
-
-    capture_io("\"a\n\"", fn ->
-      assert :io.scan_erl_form('>') == {:ok, [{:string, 1, 'a\n'}], 2}
-      assert :io.scan_erl_form('>') == {:eof, 1}
-    end)
-
-    capture_io(":erl. mof*,,l", fn ->
-      assert :io.scan_erl_form('>') == {:ok, [{:":", 1}, {:atom, 1, :erl}, {:dot, 1}], 1}
-      assert :io.scan_erl_form('>') == {:ok, [{:atom, 1, :mof}, {:*, 1}, {:"," , 1}, {:",", 1}, {:atom, 1, :l}], 1}
-      assert :io.scan_erl_form('>') == {:eof, 1}
-    end)
-
-    capture_io("a\nb\nc", fn ->
-      assert GetUntil.get_line == "a\n"
-      assert GetUntil.get_line == "b\n"
-      assert GetUntil.get_line == :eof
-    end)
-  end
+      assert capture_io([capture_prompt: false], fn ->
+               :io.get_line(">")
+             end) == ""
 
-  test "with setopts" do
-    assert capture_io(fn ->
-      assert :io.setopts({:encoding, :latin1}) == {:error, :enotsup}
-    end) == ""
-  end
+      capture_io(fn ->
+        assert :io.get_line(">") == :eof
+      end)
 
-  test "with getopts" do
-    assert capture_io(fn ->
-      assert :io.getopts == {:ok, [binary: true, encoding: :unicode]}
-    end) == ""
-  end
+      capture_io("", fn ->
+        assert :io.get_line(">") == :eof
+      end)
 
-  test "with columns" do
-    assert capture_io(fn ->
-      :io.columns
-    end) == ""
+      capture_io("\n", fn ->
+        assert :io.get_line(">") == "\n"
+        assert :io.get_line(">") == :eof
+      end)
 
-    capture_io(fn ->
-      assert :io.columns == {:error, :enotsup}
-    end)
-  end
+      capture_io("a", fn ->
+        assert :io.get_line(">") == "a"
+        assert :io.get_line(">") == :eof
+      end)
 
-  test "with rows" do
-    assert capture_io(fn ->
-      :io.rows
-    end) == ""
+      capture_io("a\n", fn ->
+        assert :io.get_line(">") == "a\n"
+        assert :io.get_line(">") == :eof
+      end)
 
-    capture_io(fn ->
-      assert :io.rows == {:error, :enotsup}
-    end)
-  end
+      capture_io("a\nb", fn ->
+        assert :io.get_line(">") == "a\n"
+        assert :io.get_line(">") == "b"
+        assert :io.get_line(">") == :eof
+      end)
 
-  test "with multiple io requests" do
-    assert capture_io(fn ->
-      send_and_receive_io({:requests, [{:put_chars, :unicode, "a"},
-                                        {:put_chars, :unicode, "b"}]})
-    end) == "ab"
+      capture_io("あい\nう", fn ->
+        assert :io.get_line(">") == "あい\n"
+        assert :io.get_line(">") == "う"
+        assert :io.get_line(">") == :eof
+      end)
+    end
 
-    capture_io(fn ->
-      assert send_and_receive_io({:requests, [{:put_chars, :unicode, "a"},
-                                               {:put_chars, :unicode, "b"}]}) == :ok
-    end)
-  end
+    test "with get password" do
+      capture_io(fn ->
+        assert :io.get_password(Process.group_leader()) == :eof
+      end)
 
-  test "with unknown io request" do
-    assert capture_io(fn ->
-      send_and_receive_io(:unknown)
-    end) == ""
+      capture_io("", fn ->
+        assert :io.get_password(Process.group_leader()) == :eof
+      end)
 
-    capture_io(fn ->
-      assert send_and_receive_io(:unknown) == {:error, :request}
-    end)
-  end
+      capture_io("abc", fn ->
+        assert :io.get_password(Process.group_leader()) == "abc"
+        assert :io.get_password(Process.group_leader()) == :eof
+      end)
+
+      capture_io("abc\n", fn ->
+        assert :io.get_password(Process.group_leader()) == "abc\n"
+        assert :io.get_password(Process.group_leader()) == :eof
+      end)
+
+      capture_io("\n", fn ->
+        assert :io.get_password(Process.group_leader()) == "\n"
+        assert :io.get_password(Process.group_leader()) == :eof
+      end)
+
+      capture_io("a\nb", fn ->
+        assert :io.get_password(Process.group_leader()) == "a\n"
+        assert :io.get_password(Process.group_leader()) == "b"
+        assert :io.get_password(Process.group_leader()) == :eof
+      end)
+
+      capture_io("あい\nう", fn ->
+        assert :io.get_password(Process.group_leader()) == "あい\n"
+        assert :io.get_password(Process.group_leader()) == "う"
+        assert :io.get_password(Process.group_leader()) == :eof
+      end)
+    end
 
-  test "with assert inside" do
-    group_leader = :erlang.group_leader
+    test "with get until" do
+      assert capture_io(fn ->
+               :io.scan_erl_form(~c">")
+             end) == ">"
+
+      assert capture_io("1.\n", fn ->
+               :io.scan_erl_form(~c">")
+             end) == ">"
+
+      assert capture_io("1\n.\n", fn ->
+               :io.scan_erl_form(~c">")
+             end) == ">>"
+
+      assert capture_io([capture_prompt: false], fn ->
+               :io.scan_erl_form(~c">")
+             end) == ""
 
-    try do
       capture_io(fn ->
-        assert false
+        assert :io.scan_erl_form(~c">") == {:eof, 1}
+      end)
+
+      capture_io("1", fn ->
+        assert :io.scan_erl_form(~c">") == {:ok, [{:integer, 1, 1}], 1}
+        assert :io.scan_erl_form(~c">") == {:eof, 1}
+      end)
+
+      capture_io("1\n.", fn ->
+        assert :io.scan_erl_form(~c">") == {:ok, [{:integer, 1, 1}, {:dot, 2}], 2}
+        assert :io.scan_erl_form(~c">") == {:eof, 1}
+      end)
+
+      capture_io("1.\n.", fn ->
+        assert :io.scan_erl_form(~c">") == {:ok, [{:integer, 1, 1}, {:dot, 1}], 2}
+        assert :io.scan_erl_form(~c">") == {:ok, [dot: 1], 1}
+        assert :io.scan_erl_form(~c">") == {:eof, 1}
+      end)
+
+      capture_io("\"a", fn ->
+        # TODO: Remove me when we require Erlang/OTP 27+
+        expected_error =
+          if System.otp_release() >= "27" do
+            {1, :erl_scan, {:unterminated, :string, ~c"a"}}
+          else
+            {1, :erl_scan, {:string, 34, ~c"a"}}
+          end
+
+        assert :io.scan_erl_form(~c">") == {:error, expected_error, 1}
+        assert :io.scan_erl_form(~c">") == {:eof, 1}
+      end)
+
+      capture_io("\"a\n\"", fn ->
+        assert :io.scan_erl_form(~c">") == {:ok, [{:string, 1, ~c"a\n"}], 2}
+        assert :io.scan_erl_form(~c">") == {:eof, 1}
+      end)
+
+      capture_io(":erl. mof*,,l", fn ->
+        assert :io.scan_erl_form(~c">") == {:ok, [{:":", 1}, {:atom, 1, :erl}, {:dot, 1}], 1}
+
+        expected_tokens = [{:atom, 1, :mof}, {:*, 1}, {:",", 1}, {:",", 1}, {:atom, 1, :l}]
+        assert :io.scan_erl_form(~c">") == {:ok, expected_tokens, 1}
+
+        assert :io.scan_erl_form(~c">") == {:eof, 1}
+      end)
+
+      capture_io("a\nb\nc", fn ->
+        assert GetUntil.get_line() == "a\n"
+        assert GetUntil.get_line() == "b\n"
+        assert GetUntil.get_line() == :eof
       end)
-    rescue
-      error in [ExUnit.AssertionError] ->
-        "Expected truthy, got false" = error.message
     end
 
-    # Ensure no leakage on failures
-    assert group_leader == :erlang.group_leader
+    test "with setopts" do
+      assert capture_io(fn ->
+               assert :io.setopts({:encoding, :latin1}) == {:error, :enotsup}
+             end) == ""
+    end
+
+    test "with getopts" do
+      assert capture_io(fn ->
+               assert :io.getopts() == [binary: true, encoding: :unicode]
+             end) == ""
+    end
+
+    test "with columns" do
+      assert capture_io(fn ->
+               :io.columns()
+             end) == ""
+
+      capture_io(fn ->
+        assert :io.columns() == {:error, :enotsup}
+      end)
+    end
+
+    test "with rows" do
+      assert capture_io(fn ->
+               :io.rows()
+             end) == ""
+
+      capture_io(fn ->
+        assert :io.rows() == {:error, :enotsup}
+      end)
+    end
+
+    test "with multiple requests" do
+      requests = [{:put_chars, :unicode, "a"}, {:put_chars, :unicode, "b"}]
+
+      assert capture_io(fn ->
+               send_and_receive_io({:requests, requests})
+             end) == "ab"
+
+      capture_io(fn ->
+        assert send_and_receive_io({:requests, requests}) == :ok
+      end)
+    end
+
+    test "with unknown request" do
+      assert capture_io(fn ->
+               send_and_receive_io(:unknown)
+             end) == ""
+
+      capture_io(fn ->
+        assert send_and_receive_io(:unknown) == {:error, :request}
+      end)
+    end
   end
 
-  test "capture :stderr by two processes" do
-    spawn(fn -> capture_io(:stderr, fn -> :timer.sleep(100) end) end)
-    :timer.sleep(10)
-    assert_raise RuntimeError, "IO device registered at :standard_error is already captured", fn ->
-      capture_io(:stderr, fn -> end)
+  describe "stdin" do
+    test "double capture from the same process" do
+      assert capture_io(fn ->
+               IO.puts("hello")
+               assert capture_io(fn -> IO.puts("middle") end) == "middle\n"
+               IO.puts("world")
+             end) == "hello\nworld\n"
+    end
+
+    test "no leakage on failures" do
+      group_leader = Process.group_leader()
+
+      test = self()
+
+      assert_raise ArgumentError, fn ->
+        capture_io(fn ->
+          send(test, {:string_io, Process.group_leader()})
+          raise ArgumentError
+        end)
+      end
+
+      receive do
+        {:string_io, pid} ->
+          ref = Process.monitor(pid)
+          assert_receive {:DOWN, ^ref, _, _, _}
+      end
+
+      assert Process.group_leader() == group_leader
+    end
+  end
+
+  describe "stderr" do
+    test "supports writes" do
+      assert capture_io(:stderr, fn ->
+               :io.put_chars(:standard_error, "a")
+             end) == "a"
+    end
+
+    test "double capture from the same process" do
+      assert capture_io(:stderr, fn ->
+               IO.puts(:stderr, "hello")
+               assert capture_io(:stderr, fn -> IO.puts(:stderr, "middle") end) == "middle\n"
+               IO.puts(:stderr, "world")
+             end) == "hello\nmiddle\nworld\n"
+    end
+
+    test "supports async capture_io" do
+      parent = self()
+
+      [pid1, pid2, pid3] =
+        for num <- 1..3 do
+          pid =
+            spawn_link(fn ->
+              captured =
+                capture_io(:stderr, fn ->
+                  :io.put_chars(:standard_error, "before:#{num}\n")
+                  send(parent, {self(), :logged})
+                  assert_receive :continue
+                  :io.put_chars(:standard_error, "after:#{num}\n")
+                end)
+
+              send(parent, captured)
+            end)
+
+          assert_receive {^pid, :logged}
+          pid
+        end
+
+      send(pid3, :continue)
+      assert_receive "before:3\nafter:3\n"
+
+      send(pid2, :continue)
+      assert_receive "before:2\nbefore:3\nafter:3\nafter:2\n"
+
+      send(pid1, :continue)
+      assert_receive "before:1\nbefore:2\nbefore:3\nafter:3\nafter:2\nafter:1\n"
+    end
+
+    test "raises when async capturing a named device with a different encoding than the first" do
+      parent = self()
+
+      pid =
+        spawn_link(fn ->
+          output =
+            capture_io(:stderr, [encoding: :latin1], fn ->
+              :io.put_chars(:standard_error, "a")
+              send(parent, {self(), :logged})
+              assert_receive :continue
+            end)
+
+          send(parent, output)
+        end)
+
+      assert_receive {^pid, :logged}
+
+      assert_raise ArgumentError,
+                   ~r"attempted to change the encoding for a currently captured device :standard_error",
+                   fn ->
+                     capture_io(:stderr, [encoding: :unicode], fn ->
+                       :io.put_chars(:standard_error, "b")
+                     end)
+                   end
+
+      assert capture_io(:stderr, [encoding: :latin1], fn ->
+               :io.put_chars(:standard_error, "c")
+             end) == "c"
+
+      send(pid, :continue)
+      assert_receive "ac"
+    end
+
+    test "raises when async capturing a named device with an input given to an already captured device" do
+      parent = self()
+
+      pid =
+        spawn_link(fn ->
+          capture_io(:stderr, [input: "first"], fn ->
+            send(parent, {self(), :logged})
+            Process.sleep(:infinity)
+          end)
+        end)
+
+      assert_receive {^pid, :logged}
+
+      message =
+        "attempted multiple captures on device :standard_error with input. If you need to give an input to a captured device, you cannot run your test asynchronously"
+
+      assert_raise ArgumentError, message, fn ->
+        capture_io(:stderr, [input: "second"], fn ->
+          :io.put_chars(:standard_error, "b")
+        end)
+      end
+
+      assert_raise ArgumentError, message, fn ->
+        capture_io(:stderr, [input: ""], fn ->
+          :io.put_chars(:standard_error, "b")
+        end)
+      end
+    end
+
+    test "no leakage on failures" do
+      parent = self()
+
+      pid =
+        spawn(fn ->
+          capture_io(:stderr, [input: "a"], fn ->
+            send(parent, :ready)
+            Process.sleep(:infinity)
+          end)
+        end)
+
+      assert_receive :ready
+
+      ref = Process.monitor(pid)
+
+      # Kill the process and make sure the capture is released
+      Process.exit(pid, :shutdown)
+
+      # Make sure the process has exited before we try and start a new capture
+      assert_receive {:DOWN, ^ref, _, _, _}
+
+      assert capture_io(:stderr, [input: "b"], fn -> :ok end)
     end
-    :timer.sleep(100)
+  end
+
+  test "capture_io with a separate process" do
+    {:ok, gl} = StringIO.open("")
+    pid = start_supervised!({MockProc, gl})
+
+    assert Process.info(pid, :group_leader) == {:group_leader, gl}
+
+    assert capture_io(pid, fn ->
+             GenServer.call(pid, {:stdio, "a"})
+           end) == "a\n"
+
+    assert capture_io(pid, [input: "b"], fn ->
+             GenServer.call(pid, {:prompt, "> "})
+           end) == "> b\n"
+
+    assert capture_io(pid, "c", fn ->
+             GenServer.call(pid, {:prompt, "> "})
+           end) == "> c\n"
+
+    assert capture_io(pid, [input: "d", capture_prompt: false], fn ->
+             GenServer.call(pid, {:prompt, "> "})
+           end) == "d\n"
+
+    assert capture_io(:stderr, fn ->
+             GenServer.call(pid, {:stderr, "uhoh"})
+           end) == "uhoh\n"
+
+    assert Process.info(pid, :group_leader) == {:group_leader, gl}
+    assert StringIO.contents(gl) == {"", ""}
+  end
+
+  test "with_io" do
+    assert with_io(fn ->
+             :io.put_chars("xyz")
+             2 + 2
+           end) == {4, "xyz"}
   end
 
   defp send_and_receive_io(req) do
-    send :erlang.group_leader, {:io_request, self, self, req}
-    s = self
+    pid = self()
+    send(:erlang.group_leader(), {:io_request, pid, pid, req})
+
     receive do
-      {:io_reply, ^s, res} -> res
+      {:io_reply, ^pid, res} -> res
     end
   end
 end
diff --git a/lib/ex_unit/test/ex_unit/capture_log_test.exs b/lib/ex_unit/test/ex_unit/capture_log_test.exs
new file mode 100644
index 00000000000..6de5216899d
--- /dev/null
+++ b/lib/ex_unit/test/ex_unit/capture_log_test.exs
@@ -0,0 +1,192 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule ExUnit.CaptureLogTest do
+  use ExUnit.Case
+
+  require Logger
+  import ExUnit.CaptureLog
+
+  test "no output" do
+    assert capture_log(fn -> nil end) == ""
+  end
+
+  test "assert inside" do
+    group_leader = Process.group_leader()
+
+    try do
+      capture_log(fn ->
+        assert false
+      end)
+    rescue
+      error in [ExUnit.AssertionError] ->
+        assert error.message == "Expected truthy, got false"
+    end
+
+    # Ensure no leakage on failures
+    assert group_leader == Process.group_leader()
+    refute_received {:gen_event_EXIT, _, _}
+  end
+
+  test "level aware" do
+    assert capture_log([level: :warning], fn ->
+             Logger.info("here")
+           end) == ""
+  end
+
+  @tag timeout: 2000
+  test "capture removal on exit" do
+    {_pid, ref} =
+      spawn_monitor(fn ->
+        capture_log(fn ->
+          spawn_link(Kernel, :exit, [:shutdown])
+          Process.sleep(:infinity)
+        end)
+      end)
+
+    assert_receive {:DOWN, ^ref, _, _, :shutdown}
+    wait_capture_removal()
+  end
+
+  test "log tracking" do
+    logged =
+      capture_log(fn ->
+        Logger.info("one")
+
+        logged = capture_log(fn -> Logger.error("one") end)
+        send(test = self(), {:nested, logged})
+
+        Logger.warning("two")
+
+        spawn(fn ->
+          Logger.debug("three")
+          send(test, :done)
+        end)
+
+        receive do: (:done -> :ok)
+      end)
+
+    assert logged
+    assert logged =~ "[info] one"
+    assert logged =~ "[warning] two"
+    assert logged =~ "[debug] three"
+    assert logged =~ "[error] one"
+
+    receive do
+      {:nested, logged} ->
+        assert logged =~ "[error] one"
+        refute logged =~ "[warning] two"
+    end
+  end
+
+  test "deprecated log level" do
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      output =
+        capture_log([level: :warn], fn ->
+          Logger.log(:warn, "ABC")
+          Logger.log(:warning, "DEF")
+        end)
+
+      assert output =~ "ABC"
+      assert output =~ "DEF"
+    end)
+  end
+
+  test "exits don't leak" do
+    Process.flag(:trap_exit, true)
+
+    capture_log(fn ->
+      Logger.error("oh no!")
+    end)
+
+    refute_receive {:EXIT, _, _}, 100
+  end
+
+  describe "with_log/2" do
+    test "returns the result and the log" do
+      {result, log} =
+        with_log(fn ->
+          Logger.error("calculating...")
+          2 + 2
+        end)
+
+      assert result == 4
+      assert log =~ "calculating..."
+    end
+
+    test "respects the :format, :metadata, and :colors options" do
+      options = [format: "$metadata| $message", metadata: [:id], colors: [enabled: false]]
+
+      assert {4, log} =
+               with_log(options, fn ->
+                 Logger.info("hello", id: 123)
+                 2 + 2
+               end)
+
+      assert log == "id=123 | hello"
+    end
+
+    @tag capture_log: true
+    test "respect options with capture_log: true" do
+      options = [format: "$metadata| $message", metadata: [:id], colors: [enabled: false]]
+
+      assert {4, log} =
+               with_log(options, fn ->
+                 Logger.info("hello", id: 123)
+                 2 + 2
+               end)
+
+      assert log == "id=123 | hello"
+    end
+  end
+
+  defmodule CustomFormatter do
+    def new do
+      {_, opts} =
+        Logger.Formatter.new(
+          format: "$metadata| $message",
+          metadata: [:id],
+          colors: [enabled: false]
+        )
+
+      {__MODULE__, opts}
+    end
+
+    def format(event, config) do
+      event
+      |> wrap()
+      |> Logger.Formatter.format(config)
+    end
+
+    defp wrap(event) do
+      msg =
+        event
+        |> Logger.Formatter.format_event(:infinity)
+        |> to_string()
+
+      %{event | msg: {:string, ["[CUSTOM]", msg, "[/CUSTOM]"]}}
+    end
+  end
+
+  test "uses the formatter from the `:formatter` option" do
+    log =
+      capture_log([formatter: CustomFormatter.new()], fn ->
+        Logger.info("hello", id: 123)
+        2 + 2
+      end)
+
+    assert log == "id=123 | [CUSTOM]hello[/CUSTOM]"
+  end
+
+  defp wait_capture_removal() do
+    if ExUnit.CaptureServer in Enum.map(:logger.get_handler_config(), & &1.id) do
+      Process.sleep(20)
+      wait_capture_removal()
+    else
+      :ok
+    end
+  end
+end
diff --git a/lib/ex_unit/test/ex_unit/case_template_test.exs b/lib/ex_unit/test/ex_unit/case_template_test.exs
index 1e7281ffa3d..2df56dd7912 100644
--- a/lib/ex_unit/test/ex_unit/case_template_test.exs
+++ b/lib/ex_unit/test/ex_unit/case_template_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule ExUnit.SampleCase do
   use ExUnit.CaseTemplate
@@ -36,7 +40,7 @@ defmodule ExUnit.NestedCase do
 end
 
 defmodule ExUnit.CaseTemplateTest do
-  use ExUnit.SampleCase, async: true
+  use ExUnit.SampleCase, async: true, another_option: 123
   use ExUnit.NestedCase
 
   two = 2
@@ -53,7 +57,7 @@ defmodule ExUnit.CaseTemplateTest do
     assert context[:setup] == 2
   end
 
-  test "runs both templates setup all", context do
+  test "runs both templates setup_all", context do
     assert context[:setup_all] == 2
   end
 
diff --git a/lib/ex_unit/test/ex_unit/case_test.exs b/lib/ex_unit/test/ex_unit/case_test.exs
index 01125b3a98b..014e55d1793 100644
--- a/lib/ex_unit/test/ex_unit/case_test.exs
+++ b/lib/ex_unit/test/ex_unit/case_test.exs
@@ -1,12 +1,28 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule ExUnit.CaseTest do
-  use ExUnit.Case, async: true
+  use ExUnit.Case, async: true, group: :group_foo
+
+  ExUnit.Case.register_attribute(__MODULE__, :foo)
+  ExUnit.Case.register_attribute(__MODULE__, :bar, accumulate: true)
+  ExUnit.Case.register_attribute(__MODULE__, :baz)
+  ExUnit.Case.register_describe_attribute(__MODULE__, :describe_foo)
+  ExUnit.Case.register_describe_attribute(__MODULE__, :describe_bar, accumulate: true)
+  ExUnit.Case.register_describe_attribute(__MODULE__, :describe_baz)
+  ExUnit.Case.register_module_attribute(__MODULE__, :module_foo)
+  ExUnit.Case.register_module_attribute(__MODULE__, :module_bar, accumulate: true)
+  ExUnit.Case.register_module_attribute(__MODULE__, :module_baz)
 
   @moduletag :moduletag
+  @module_foo :hello
+  @module_bar :world
 
-  test "defines test case info" do
-    assert %ExUnit.TestCase{name: __MODULE__, tests: tests} = __ex_unit__(:case)
+  test "defines __ex_unit__" do
+    assert %ExUnit.TestModule{name: __MODULE__, tests: tests} = __ex_unit__()
     assert length(tests) > 0
   end
 
@@ -16,24 +32,292 @@ defmodule ExUnit.CaseTest do
   @tag world: :good
   test "tags", context do
     line = __ENV__.line - 1
-    assert context[:case] == __MODULE__
-    assert context[:test] == __ENV__.function |> elem(0)
+    assert context[:async] == true
     assert context[:line] == line
+    assert context[:module] == __MODULE__
+    assert context[:test] == __ENV__.function |> elem(0)
+    assert context[:test_pid] == self()
+    assert context[:test_type] == :test
     assert context[:hello] == true
     assert context[:world] == :good
+    assert context[:test_group] == :group_foo
   end
 
   test "reset tags", context do
-    assert nil?(context[:hello])
-    assert nil?(context[:world])
+    assert is_nil(context[:hello])
+    assert is_nil(context[:world])
+  end
+
+  # tags are passed to setup_all
+  setup_all context do
+    assert context.async
+    assert context.module == __MODULE__
+    %{moduletag_from_setup_all: context[:moduletag]}
   end
 
   test "module tags", context do
     assert context[:moduletag] == true
+    assert context[:moduletag_from_setup_all] == true
   end
 
   @tag moduletag: :overridden
   test "module tags can be overridden", context do
     assert context[:moduletag] == :overridden
   end
+
+  @foo :hello
+  @bar :world
+  test "registered attributes are in context", context do
+    assert context.registered.foo == :hello
+    assert context.registered.bar == [:world]
+    assert context.registered.baz == nil
+  end
+
+  test "registered attributes are set per test", context do
+    assert context.registered.foo == nil
+    assert context.registered.bar == []
+  end
+
+  describe "with attributes" do
+    @describe_foo :hello
+    @describe_bar :world
+
+    test "registered subscribe attributes are in context", context do
+      assert context.registered.describe_foo == :hello
+      assert context.registered.describe_bar == [:world]
+      assert context.registered.describe_baz == nil
+    end
+  end
+
+  describe "without attributes" do
+    test "registered subscribe attributes are set per subscribe", context do
+      assert context.registered.describe_foo == nil
+      assert context.registered.describe_bar == []
+    end
+  end
+
+  test "registered module attributes are in context", context do
+    assert context.registered.module_foo == :hello
+    assert context.registered.module_bar == [:world]
+    assert context.registered.module_baz == nil
+  end
+
+  test "registered module attributes stay in context", context do
+    assert context.registered.module_foo == :hello
+    assert context.registered.module_bar == [:world]
+  end
+
+  test "raises when same name is registered twice" do
+    assert_raise ArgumentError, "cannot register attribute :foo multiple times", fn ->
+      defmodule AcrossLevelDoubleRegisterTest do
+        use ExUnit.Case
+        ExUnit.Case.register_attribute(__MODULE__, :foo)
+        ExUnit.Case.register_module_attribute(__MODULE__, :foo)
+      end
+    end
+  end
+
+  test "raises when attribute is set before being registered" do
+    assert_raise RuntimeError, "you must set @foo after it has been registered", fn ->
+      defmodule SetBeforeRegisterTest do
+        use ExUnit.Case
+        @foo true
+        ExUnit.Case.register_attribute(__MODULE__, :foo, accumulate: true)
+      end
+    end
+  end
+
+  test "raises when name is longer than 255 characters" do
+    assert_raise SystemLimitError,
+                 ~r/must be shorter than 255 characters, got: "test a{256}"/,
+                 fn ->
+                   defmodule LongNameTest do
+                     use ExUnit.Case
+
+                     test String.duplicate("a", 256)
+                   end
+                 end
+
+    assert_raise SystemLimitError,
+                 ~r/must be shorter than 255 characters, got: "test a{100} a{156}"/,
+                 fn ->
+                   defmodule LongDescribeNameTest do
+                     use ExUnit.Case
+
+                     describe String.duplicate("a", 100) do
+                       test String.duplicate("a", 156)
+                     end
+                   end
+                 end
+  end
+
+  test "warns when using @tag outside of describe" do
+    stderr =
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        defmodule TagOutsideOfDescribe do
+          use ExUnit.Case, register: false
+
+          @tag :foo
+          describe "bar" do
+            test "baz" do
+            end
+          end
+        end
+      end)
+
+    assert stderr =~ "found unused @tag before \"describe\", did you mean to use @describetag?"
+  end
+end
+
+defmodule ExUnit.DoubleCaseTestAsyncFirst do
+  use ExUnit.Case, async: true
+  use ExUnit.Case
+
+  test "async must be true", context do
+    assert context.async
+  end
+end
+
+defmodule ExUnit.DoubleCaseTestAsyncLast do
+  use ExUnit.Case
+  use ExUnit.Case, async: true
+
+  test "async must be true", context do
+    assert context.async
+  end
+end
+
+defmodule ExUnit.CaseTest.TmpDir do
+  use ExUnit.Case
+
+  @moduletag :tmp_dir
+
+  defp ends_with_short_hash?(string) do
+    string
+    |> binary_slice(-9..-1)
+    |> String.starts_with?("-")
+  end
+
+  defp ends_with_short_hash_and_extra_path?(string, extra_path) do
+    extra_path = "/" <> extra_path
+    extra_path_length = String.length(extra_path)
+
+    case String.split_at(string, -extra_path_length) do
+      {tmp_dir_base, extra_path_new} when extra_path_new == extra_path ->
+        ends_with_short_hash?(tmp_dir_base)
+
+      _ ->
+        false
+    end
+  end
+
+  defp starts_with_path?(tmp_dir, path) do
+    String.starts_with?(tmp_dir, Path.expand(path))
+  end
+
+  test "default path", context do
+    assert starts_with_path?(context.tmp_dir, "tmp/ExUnit.CaseTest.TmpDir/test-default-path-")
+    assert ends_with_short_hash?(context.tmp_dir)
+    assert File.ls!(context.tmp_dir) == []
+  end
+
+  test "escapes foo?/0", context do
+    assert starts_with_path?(context.tmp_dir, "tmp/ExUnit.CaseTest.TmpDir/test-escapes-foo--0-")
+    assert ends_with_short_hash?(context.tmp_dir)
+  end
+
+  @tag tmp_dir: "foo/bar"
+  test "custom path", context do
+    assert starts_with_path?(context.tmp_dir, "tmp/ExUnit.CaseTest.TmpDir/test-custom-path-")
+    assert ends_with_short_hash_and_extra_path?(context.tmp_dir, "foo/bar")
+  end
+
+  @tag tmp_dir: false
+  test "disabled", context do
+    refute context[:tmp_dir]
+  end
+
+  describe "colliding test names" do
+    test "foo-bar", context do
+      assert starts_with_path?(
+               context.tmp_dir,
+               "tmp/ExUnit.CaseTest.TmpDir/test-colliding-test-names-foo-bar-"
+             )
+
+      assert String.ends_with?(context.tmp_dir, "-2489e2ce")
+    end
+
+    test "foo+bar", context do
+      assert starts_with_path?(
+               context.tmp_dir,
+               "tmp/ExUnit.CaseTest.TmpDir/test-colliding-test-names-foo-bar-"
+             )
+
+      assert String.ends_with?(context.tmp_dir, "-9633ed5f")
+    end
+  end
+end
+
+defmodule ExUnit.BadOptsCase do
+  use ExUnit.Case, async: true
+
+  test "raises if passed something other than options" do
+    assert_raise ArgumentError, ~r/must be a list of options, got: "not a list of options"/, fn ->
+      defmodule MyBadCase do
+        use ExUnit.Case, "not a list of options"
+      end
+    end
+  end
+end
+
+defmodule ExUnit.CaseTest.GetLastRegisteredTestHelper do
+  defmacro escaped_get_last_registered_test do
+    Macro.escape(ExUnit.Case.get_last_registered_test(__CALLER__))
+  end
+end
+
+defmodule ExUnit.CaseTest.GetLastRegisteredTestTest do
+  use ExUnit.Case, async: true
+  import ExUnit.CaseTest.GetLastRegisteredTestHelper
+
+  last = ExUnit.Case.get_last_registered_test(__MODULE__)
+
+  test "returns nil if called before any test has been registered" do
+    assert unquote(last) == nil
+  end
+
+  test "returns the current test if call is within test body", %{test: name} do
+    assert %ExUnit.Test{
+             name: ^name,
+             module: __MODULE__,
+             state: nil,
+             time: 0
+           } = escaped_get_last_registered_test()
+  end
+
+  last = ExUnit.Case.get_last_registered_test(__MODULE__)
+
+  test "returns the previous test if call is outside test body" do
+    assert %ExUnit.Test{name: :"test returns the current test if call is within test body"} =
+             unquote(Macro.escape(last))
+  end
+
+  test "raises if given module is already compiled" do
+    assert_raise ArgumentError, ~r/could not call Module\.get_last_attribute\/2/, fn ->
+      ExUnit.Case.get_last_registered_test(__MODULE__)
+    end
+  end
+
+  @moduletag tag1: :foo
+  describe "tags" do
+    @describetag tag2: :bar
+
+    @tag tag3: :baz
+    test "includes data available in test context", context do
+      assert %ExUnit.Test{tags: %{tag1: :foo, tag2: :bar, tag3: :baz} = tags} =
+               escaped_get_last_registered_test()
+
+      assert tags == Map.take(context, Map.keys(tags))
+    end
+  end
 end
diff --git a/lib/ex_unit/test/ex_unit/describe_test.exs b/lib/ex_unit/test/ex_unit/describe_test.exs
new file mode 100644
index 00000000000..557885789ee
--- /dev/null
+++ b/lib/ex_unit/test/ex_unit/describe_test.exs
@@ -0,0 +1,139 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule ExUnit.DescribeTest do
+  use ExUnit.Case, async: true
+
+  @moduletag [attribute_tag: :from_module]
+
+  setup _ do
+    [setup_tag: :from_module]
+  end
+
+  describe "tags" do
+    @describetag attribute_tag: :from_describe
+
+    test "from describe have higher precedence", context do
+      assert context.attribute_tag == :from_describe
+    end
+
+    @tag attribute_tag: :from_test
+    test "from test have higher precedence", context do
+      assert context.attribute_tag == :from_test
+    end
+  end
+
+  describe "setup" do
+    setup _ do
+      [setup_tag: :from_describe]
+    end
+
+    test "from describe runs later", context do
+      assert context.setup_tag == :from_describe
+    end
+  end
+
+  describe "setup from import" do
+    import Map
+    setup :to_list
+
+    test "is expanded within describe block", context do
+      assert context.setup_tag == :from_module
+    end
+  end
+
+  describe "failures" do
+    test "when using setup_all inside describe" do
+      assert_raise RuntimeError, ~r"cannot invoke setup_all/1-2 inside describe", fn ->
+        defmodule Sample do
+          use ExUnit.Case
+
+          describe "hello" do
+            setup_all do
+              [hello: "world"]
+            end
+          end
+        end
+      end
+    end
+
+    test "when using describe inside describe" do
+      regex = ~r{cannot call "describe" inside another "describe"}
+
+      assert_raise RuntimeError, regex, fn ->
+        defmodule Sample do
+          use ExUnit.Case
+
+          describe "hello" do
+            describe "another" do
+            end
+          end
+        end
+      end
+    end
+
+    test "when using non-string describe name" do
+      assert_raise ArgumentError, ~r"describe name must be a string, got: :not_allowed", fn ->
+        defmodule Sample do
+          use ExUnit.Case
+
+          describe :not_allowed do
+          end
+        end
+      end
+    end
+
+    test "when using the same name for two describe blocks" do
+      message =
+        ~s(describe "some tests" is already defined in ExUnit.DescribeTest.DescribeWithSameNames)
+
+      assert_raise ArgumentError, message, fn ->
+        defmodule DescribeWithSameNames do
+          use ExUnit.Case
+
+          describe "some tests" do
+          end
+
+          describe "some tests" do
+          end
+        end
+      end
+    end
+  end
+
+  test "when @describetag is used outside of a describe block" do
+    message = ~s(@describetag must be set inside describe/2 blocks)
+
+    assert_raise RuntimeError, message, fn ->
+      defmodule DescribetagOutsideOfDescribeBlock do
+        use ExUnit.Case
+
+        @describetag :integration
+
+        describe "some tests" do
+        end
+      end
+    end
+  end
+
+  describe "test names" do
+    test "merge describe information", context do
+      assert context.test == :"test test names merge describe information"
+    end
+  end
+
+  test "attributes from outside describe", context do
+    assert context.attribute_tag == :from_module
+    assert context.setup_tag == :from_module
+    assert context.test == :"test attributes from outside describe"
+  end
+
+  describe "describe block" do
+    test "sets describe_line", context do
+      assert context.describe_line == __ENV__.line - 2
+    end
+  end
+end
diff --git a/lib/ex_unit/test/ex_unit/diff_test.exs b/lib/ex_unit/test/ex_unit/diff_test.exs
new file mode 100644
index 00000000000..2d7c9ab80df
--- /dev/null
+++ b/lib/ex_unit/test/ex_unit/diff_test.exs
@@ -0,0 +1,1372 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule ExUnit.DiffTest do
+  use ExUnit.Case, async: true
+
+  alias Inspect.Algebra
+  alias ExUnit.{Assertions, Diff}
+
+  defmodule User do
+    defstruct [:name, :age]
+  end
+
+  defmodule Customer do
+    defstruct [:address, :age, :first_name, :language, :last_name, :notifications]
+  end
+
+  defmodule Person do
+    defstruct [:age]
+  end
+
+  defmodule Opaque do
+    defstruct [:data]
+
+    defimpl Inspect do
+      def inspect(%{data: data}, _) when is_tuple(data) or is_map(data),
+        do: "#Opaque<data: #{inspect(data)}>"
+
+      def inspect(_, _),
+        do: "#Opaque<???>"
+    end
+  end
+
+  defmodule HTML do
+    defstruct [:string]
+
+    defimpl Inspect do
+      def inspect(%{string: string}, _) do
+        "~HTML[#{string}]"
+      end
+    end
+  end
+
+  defmacro sigil_HTML({:<<>>, _, [string]}, []) do
+    Macro.escape(%HTML{string: string})
+  end
+
+  defmacrop one, do: 1
+
+  defmacrop tuple(a, b) do
+    quote do
+      {unquote(a), unquote(b)}
+    end
+  end
+
+  defmacrop pin_x do
+    x = Macro.var(:x, nil)
+    quote(do: ^unquote(x))
+  end
+
+  defmacrop block_head({:__block__, _, [head | _]}) do
+    head
+  end
+
+  defmacrop assert_diff(expr, expected_binding, pins \\ [])
+
+  defmacrop assert_diff({:=, _, [left, right]}, expected_binding, pins) do
+    left = Assertions.__expand_pattern__(left, __CALLER__) |> Macro.escape()
+
+    quote do
+      assert_diff(
+        unquote(left),
+        unquote(right),
+        unquote(expected_binding),
+        {:match, unquote(pins)}
+      )
+    end
+  end
+
+  defmacrop assert_diff({op, _, [left, right]}, [], []) when op in [:==, :===] do
+    quote do
+      assert_diff(unquote(left), unquote(right), [], unquote(op))
+    end
+  end
+
+  defmacrop refute_diff(expr, expected_left, expected_right, pins \\ [])
+
+  defmacrop refute_diff({:=, _, [left, right]}, expected_left, expected_right, pins) do
+    left = Assertions.__expand_pattern__(left, __CALLER__) |> Macro.escape()
+
+    quote do
+      refute_diff(
+        unquote(left),
+        unquote(right),
+        unquote(expected_left),
+        unquote(expected_right),
+        {:match, unquote(pins)}
+      )
+    end
+  end
+
+  defmacrop refute_diff({op, _, [left, right]}, expected_left, expected_right, [])
+            when op in [:==, :===] do
+    quote do
+      refute_diff(
+        unquote(left),
+        unquote(right),
+        unquote(expected_left),
+        unquote(expected_right),
+        unquote(op)
+      )
+    end
+  end
+
+  defp refute_diff(left, right, expected_left, expected_right, context) do
+    {diff, _env} = Diff.compute(left, right, context)
+    assert diff.equivalent? == false
+
+    diff_left = to_diff(diff.left, "-")
+    assert diff_left =~ expected_left
+
+    diff_right = to_diff(diff.right, "+")
+    assert diff_right =~ expected_right
+  end
+
+  defp assert_diff(left, right, expected_binding, context) do
+    {diff, env} = Diff.compute(left, right, context)
+    env_binding = for {{name, _}, value} <- env.current_vars, do: {name, value}
+
+    assert diff.equivalent? == true
+    assert env_binding == expected_binding
+  end
+
+  @terminal_width 80
+  defp to_diff(side, sign) do
+    side
+    |> Diff.to_algebra(&diff_wrapper(&1, sign))
+    |> Algebra.format(@terminal_width)
+    |> IO.iodata_to_binary()
+  end
+
+  defp diff_wrapper(doc, side) do
+    Algebra.concat([side, doc, side])
+  end
+
+  test "atoms" do
+    assert_diff(:a = :a, [])
+    assert_diff(:a = :a, [])
+    assert_diff(:"$a" = :"$a", [])
+
+    refute_diff(:a = :b, "-:a-", "+:b+")
+    refute_diff(:a = :aa, "-:a-", "+:aa+")
+
+    refute_diff(:"$" = :"$a", ~s[-:"$"-], ~s[+:"$a"+])
+    refute_diff(:"$a" = :"$b", ~s[-:"$a"-], ~s[+:"$b"+])
+
+    refute_diff(:bar = 42, "-:bar-", "+42+")
+    refute_diff(42 = :bar, "-42-", "+:bar+")
+
+    pins = %{{:a, nil} => :a, {:b, nil} => :b}
+    assert_diff(x = :a, [x: :a], pins)
+    assert_diff(^a = :a, [], pins)
+    assert_diff(^b = :b, [], pins)
+
+    refute_diff(^a = :b, "-^a-", "+:b+", pins)
+    refute_diff(^b = :a, "-^b-", "+:a+", pins)
+  end
+
+  test "pseudo vars" do
+    assert_diff(__MODULE__ = ExUnit.DiffTest, [])
+    refute_diff(__MODULE__ = SomethingElse, "-ExUnit.DiffTest-", "+SomethingElse+")
+  end
+
+  test "integers" do
+    assert_diff(123 = 123, [])
+    assert_diff(-123 = -123, [])
+    assert_diff(123 = +123, [])
+    assert_diff(+123 = 123, [])
+
+    refute_diff(12 = 13, "1-2-", "1+3+")
+    refute_diff(12345 = 123, "123-45-", "123")
+    refute_diff(123 = 12345, "123", "123+45+")
+    refute_diff(12345 = 345, "-12-345", "345")
+    refute_diff(345 = 12345, "345", "+12+345")
+    refute_diff(123 = -123, "123", "+-+123")
+    refute_diff(-123 = 123, "---123", "123")
+    refute_diff(491_512_235 = 490_512_035, "49-1-512-2-35", "49+0+512+0+35")
+
+    assert_diff(0xF = 15, [])
+    refute_diff(0xF = 16, "1-5-", "1+6+")
+    refute_diff(123 = :a, "-123-", "+:a+")
+  end
+
+  test "floats" do
+    assert_diff(123.0 = 123.0, [])
+    assert_diff(-123.0 = -123.0, [])
+    assert_diff(123.0 = +123.0, [])
+    assert_diff(+123.0 = 123.0, [])
+
+    refute_diff(1.2 = 1.3, "1.-2-", "1.+3+")
+    refute_diff(12.345 = 12.3, "12.3-45-", "12.3")
+    refute_diff(12.3 = 12.345, "12.3", "12.3+45+")
+    refute_diff(123.45 = 3.45, "-12-3.45", "3.45")
+    refute_diff(3.45 = 123.45, "3.45", "+12+3.45")
+    refute_diff(1.23 = -1.23, "1.23", "+-+1.23")
+    refute_diff(-1.23 = 1.23, "---1.23", "1.23")
+    refute_diff(123.0 = :a, "-123.0-", "+:a+")
+    refute_diff(123.0 = 123_512_235, "-123.0-", "+123512235+")
+  end
+
+  test "== / ===" do
+    refute_diff(
+      %{a: 1, b: 2} == %{a: 1.0, b: :two},
+      "%{a: 1, b: -2-}",
+      "%{a: 1.0, b: +:two+}"
+    )
+
+    refute_diff(
+      %{a: 1, b: 2} === %{a: 1.0, b: :two},
+      "%{a: -1-, b: -2-}",
+      "%{a: +1.0+, b: +:two+}"
+    )
+  end
+
+  test "lists" do
+    assert_diff([] = [], [])
+
+    assert_diff([:a] = [:a], [])
+    assert_diff([:a, :b, :c] = [:a, :b, :c], [])
+
+    refute_diff([] = [:a], "[]", "[+:a+]")
+    refute_diff([:a] = [], "[-:a-]", "[]")
+    refute_diff([:a] = [:b], "[-:a-]", "[+:b+]")
+    refute_diff([:a, :b, :c] = [:a, :b, :x], "[:a, :b, -:c-]", "[:a, :b, +:x+]")
+    refute_diff([:a, :x, :c] = [:a, :b, :c], "[:a, -:x-, :c]", "[:a, +:b+, :c]")
+    refute_diff([:a, :d, :b, :c] = [:a, :b, :c, :d], "[:a, -:d-, :b, :c]", "[:a, :b, :c, +:d+]")
+    refute_diff([:b, :c] = [:a, :b, :c], "[:b, :c]", "[+:a+, :b, :c]")
+
+    refute_diff([:a, :b, :c] = [:a, :b, []], "[:a, :b, -:c-]", "[:a, :b, +[]+]")
+    refute_diff([:a, :b, []] = [:a, :b, :c], "[:a, :b, -[]-]", "[:a, :b, +:c+]")
+    refute_diff([:a, :b, :c] = [:a, :b], "[:a, :b, -:c-]", "[:a, :b]")
+    refute_diff([:a, :b] = [:a, :b, :c], "[:a, :b]", "[:a, :b, +:c+]")
+    refute_diff([:a, :b, :c, :d, :e] = [:a, :b], "[:a, :b, -:c-, -:d-, -:e-]", "[:a, :b]")
+    refute_diff([:a, :b] = [:a, :b, :c, :d, :e], "[:a, :b]", "[:a, :b, +:c+, +:d+, +:e+]")
+
+    refute_diff(
+      [:a, [:d, :b, :c]] = [:a, [:b, :c, :d]],
+      "[:a, [-:d-, :b, :c]]",
+      "[:a, [:b, :c, +:d+]]"
+    )
+
+    refute_diff(
+      [:e, :a, :b, :c, :d] = [:a, :b, :c, :d, :e],
+      "[-:e-, :a, :b, :c, :d]",
+      "[:a, :b, :c, :d, +:e+]"
+    )
+
+    refute_diff([:a, [:c, :b]] = [:a, [:b, :c]], "[:a, [-:c-, :b]]", "[:a, [:b, +:c+]]")
+    refute_diff(:a = [:a, [:b, :c]], "-:a-", "+[:a, [:b, :c]]+")
+
+    pins = %{
+      {:a, nil} => :a,
+      {:b, nil} => :b,
+      {:list_ab, nil} => [:a, :b],
+      {:list_tuple, nil} => [{:foo}]
+    }
+
+    assert_diff(x = [], [x: []], pins)
+    assert_diff(x = [:a, :b], [x: [:a, :b]], pins)
+    assert_diff([x] = [:a], [x: :a], pins)
+    assert_diff([x, :b, :c] = [:a, :b, :c], [x: :a], pins)
+    assert_diff([x, y, z] = [:a, :b, :c], [x: :a, y: :b, z: :c], pins)
+    assert_diff([x, x, :c] = [:a, :a, :c], [x: :a], pins)
+
+    refute_diff([x] = [], "[-x-]", "[]")
+    refute_diff([x, :b, :c] = [:a, :b, :x], "[x, :b, -:c-]", "[:a, :b, +:x+]")
+    refute_diff([x, x, :c] = [:a, :b, :c], "[x, -x-, :c]", "[:a, +:b+, :c]")
+
+    assert_diff(^list_ab = [:a, :b], [], pins)
+    assert_diff([^a, :b, :c] = [:a, :b, :c], [], pins)
+    assert_diff([^a, ^b, :c] = [:a, :b, :c], [], pins)
+    assert_diff([^a, a, :c] = [:a, :b, :c], [a: :b], pins)
+    assert_diff([b, ^b, :c] = [:a, :b, :c], [b: :a], pins)
+
+    refute_diff(^list_ab = [:x, :b], "-^list_ab-", "[+:x+, :b]", pins)
+    refute_diff([^a, :b, :c] = [:a, :b, :x], "[^a, :b, -:c-]", "[:a, :b, +:x+]", pins)
+    refute_diff([:a, ^a, :c] = [:a, :b, :c], "[:a, -^a-, :c]", "[:a, +:b+, :c]", pins)
+
+    refute_diff(
+      [x, :a, :b, :c, :d] = [:a, :b, :c, :d, :e],
+      "[x, -:a-, :b, :c, :d]",
+      "[:a, :b, :c, :d, +:e+]"
+    )
+
+    refute_diff([:a, :b] = :a, "-[:a, :b]-", "+:a+")
+    refute_diff([:foo] = [:foo, {:a, :b, :c}], "[:foo]", "[:foo, +{:a, :b, :c}+]")
+
+    refute_diff([{:foo}] = [{:bar}], "[{-:foo-}]", "[{+:bar+}]")
+    refute_diff(^list_tuple = [{:bar}], "-^list_tuple-", "[{+:bar+}]", pins)
+  end
+
+  test "improper lists" do
+    assert_diff([:a | :b] = [:a | :b], [])
+    assert_diff([:a, :b | :c] = [:a, :b | :c], [])
+
+    refute_diff([:a | :b] = [:b | :a], "[-:a- | -:b-]", "[+:b+ | +:a+]")
+    refute_diff([:a | :b] = [:a | :x], "[:a | -:b-]", "[:a | +:x+]")
+    refute_diff([:a, :b | :c] = [:a, :b | :x], "[:a, :b | -:c-]", "[:a, :b | +:x+]")
+    refute_diff([:a, :x | :c] = [:a, :b | :c], "[:a, -:x- | :c]", "[:a, +:b+ | :c]")
+    refute_diff([:x, :b | :c] = [:a, :b | :c], "[-:x-, :b | :c]", "[+:a+, :b | :c]")
+    refute_diff([:c, :a | :b] = [:a, :b | :c], "[-:c-, :a | -:b-]", "[:a, +:b+ | +:c+]")
+
+    refute_diff(
+      [:a, :c, :x | :b] = [:a, :b, :c | :d],
+      "[:a, :c, -:x- | -:b-]",
+      "[:a, +:b+, :c | +:d+]"
+    )
+
+    refute_diff([:a | :d] = [:a, :b, :c | :d], "[:a | -:d-]", "[:a, +:b+, +:c+ | +:d+]")
+
+    refute_diff(
+      [[:a | :x], :x | :d] = [[:a | :b], :c | :d],
+      "[[:a | -:x-], -:x- | :d]",
+      "[[:a | +:b+], +:c+ | :d]"
+    )
+
+    assert_diff([:a | x] = [:a | :b], x: :b)
+
+    refute_diff(
+      [[[[], "Hello, "] | "world"] | "!"] ==
+        [[[[], "Hello "] | "world"] | "!"],
+      "[[[[], \"Hello-,- \"] | \"world\"] | \"!\"]",
+      "[[[[], \"Hello \"] | \"world\"] | \"!\"]"
+    )
+
+    refute_diff(:foo = %{bar: [:a | :b]}, "", "")
+  end
+
+  test "proper lists" do
+    assert_diff([:a | [:b]] = [:a, :b], [])
+    assert_diff([:a | [:b, :c]] = [:a, :b, :c], [])
+
+    refute_diff([:a | [:b]] = [:a, :x], "[:a | [-:b-]]", "[:a, +:x+]")
+
+    refute_diff([:a, :b | [:c]] = [:a, :b, :x], "[:a, :b | [-:c-]]", "[:a, :b, +:x+]")
+    refute_diff([:a, :x | [:c]] = [:a, :b, :c], "[:a, -:x- | [:c]]", "[:a, +:b+, :c]")
+    refute_diff([:a | [:b, :c]] = [:a, :b, :x], "[:a | [:b, -:c-]]", "[:a, :b, +:x+]")
+    refute_diff([:a | [:b, :c]] = [:x, :b, :c], "[-:a- | [:b, :c]]", "[+:x+, :b, :c]")
+
+    refute_diff(
+      [:a, :c, :x | [:b, :c]] = [:a, :b, :c, :d, :e],
+      "[:a, -:c-, -:x- | [:b, :c]]",
+      "[:a, :b, :c, +:d+, +:e+]"
+    )
+
+    refute_diff([:a, :b | [:c]] = [:a, :b], "[:a, :b | [-:c-]]", "[:a, :b]")
+    refute_diff([:a, :b | []] = [:a, :b, :c], "[:a, :b | []]", "[:a, :b, +:c+]")
+    refute_diff([:a, :b | [:c, :d]] = [:a, :b, :c], "[:a, :b | [:c, -:d-]]", "[:a, :b, :c]")
+    refute_diff([:a, :b | [:c, :d]] = [:a], "[:a, -:b- | [-:c-, -:d-]]", "[:a]")
+
+    refute_diff(
+      [:a, [:b, :c] | [:d, :e]] = [:a, [:x, :y], :d, :e],
+      "[:a, [-:b-, -:c-] | [:d, :e]]",
+      "[:a, [+:x+, +:y+], :d, :e]"
+    )
+
+    refute_diff(
+      [:a, [:b, :c] | [:d, :e]] = [:a, [:x, :c], :d, :e],
+      "[:a, [-:b-, :c] | [:d, :e]]",
+      "[:a, [+:x+, :c], :d, :e]"
+    )
+
+    assert_diff([:a | x] = [:a, :b], x: [:b])
+    assert_diff([:a | x] = [:a, :b, :c], x: [:b, :c])
+    assert_diff([:a | x] = [:a, :b | :c], x: [:b | :c])
+
+    pins = %{{:list_bc, nil} => [:b, :c]}
+    assert_diff([:a | ^list_bc] = [:a, :b, :c], [], pins)
+    refute_diff([:a | ^list_bc] = [:x, :x, :c], "[-:a- | -^list_bc-]", "[+:x+, +:x+, :c]", pins)
+    refute_diff([:a | ^list_bc] = [:a, :x, :c], "[:a | -^list_bc-]", "[:a, +:x+, :c]", pins)
+  end
+
+  test "concat lists" do
+    assert_diff([:a] ++ [:b] = [:a, :b], [])
+    assert_diff([:a, :b] ++ [] = [:a, :b], [])
+    assert_diff([] ++ [:a, :b] = [:a, :b], [])
+
+    refute_diff([:a, :b] ++ [:c] = [:a, :b], "[:a, :b] ++ [-:c-]", "[:a, :b]")
+    refute_diff([:a, :c] ++ [:b] = [:a, :b], "[:a, -:c-] ++ [:b]", "[:a, :b]")
+    refute_diff([:a] ++ [:b] ++ [:c] = [:a, :b], "[:a] ++ [:b] ++ [-:c-]", "[:a, :b]")
+
+    assert_diff([:a] ++ :b = [:a | :b], [])
+    assert_diff([:a] ++ x = [:a, :b], x: [:b])
+
+    refute_diff([:a, :b] ++ :c = [:a, :b, :c], "[:a, :b] ++ -:c-", "[:a, :b, +:c+]")
+    refute_diff([:a] ++ [:b] ++ :c = [:a, :b, :c], "[:a] ++ [:b] ++ -:c-", "[:a, :b, +:c+]")
+    refute_diff([:a] ++ [:b] = :a, "-[:a] ++ [:b]-", "+:a+")
+  end
+
+  @a [:a]
+  test "concat lists with module attributes" do
+    assert_diff(@a ++ [:b] = [:a, :b], [])
+    refute_diff(@a ++ [:b] = [:a], "[:a] ++ [-:b-]", "[:a]")
+    refute_diff(@a ++ [:b] = [:b], "[-:a-] ++ [:b]", "[:b]")
+  end
+
+  test "mixed lists" do
+    refute_diff([:a | :b] = [:a, :b], "[:a | -:b-]", "[:a, +:b+]")
+    refute_diff([:a, :b] = [:a | :b], "[:a, -:b-]", "[:a | +:b+]")
+    refute_diff([:a | [:b]] = [:a | :b], "[:a | -[:b]-]", "[:a | +:b+]")
+    refute_diff([:a | [:b | [:c]]] = [:a | :c], "[:a | -[:b | [:c]]-]", "[:a | +:c+]")
+    refute_diff([:a | :b] = [:a, :b, :c], "[:a | -:b-]", "[:a, +:b+, +:c+]")
+    refute_diff([:a, :b, :c] = [:a | :b], "[:a, -:b-, -:c-]", "[:a | +:b+]")
+
+    refute_diff([:a | [:b] ++ [:c]] = [:a, :b], "[:a | [:b] ++ [-:c-]]", "[:a, :b]")
+
+    refute_diff(
+      [:a | [:b] ++ [:c]] ++ [:d | :e] = [:a, :b | :e],
+      "[:a | [:b] ++ [-:c-]] ++ [-:d- | :e]",
+      "[:a, :b | :e]"
+    )
+  end
+
+  test "lists outside of match context" do
+    refute_diff(
+      [%_{i_will: :fail}, %_{i_will: :fail_too}] = [],
+      "[-%_{i_will: :fail}-, -%_{i_will: :fail_too}-]",
+      "[]"
+    )
+
+    refute_diff(
+      [:a, {:|, [], [:b, :c]}] == [:a, :b | :c],
+      "[:a, -{:|, [], [:b, :c]}-]",
+      "[:a, +:b+ | +:c+]"
+    )
+
+    refute_diff([:foo] == [:foo, {:a, :b, :c}], "[:foo]", "[:foo, +{:a, :b, :c}+]")
+    refute_diff([:foo, {:a, :b, :c}] == [:foo], "[:foo, -{:a, :b, :c}-]", "[:foo]")
+
+    refute_diff([:foo] == [:foo | {:a, :b, :c}], "[:foo]", "[:foo | +{:a, :b, :c}+]")
+    refute_diff([:foo | {:a, :b, :c}] == [:foo], "[:foo | -{:a, :b, :c}-]", "[:foo]")
+    refute_diff([:foo] == [{:a, :b, :c} | :foo], "[-:foo-]", "[+{:a, :b, :c}+ | +:foo+]")
+    refute_diff([{:a, :b, :c} | :foo] == [:foo], "[-{:a, :b, :c}- | -:foo-]", "[+:foo+]")
+  end
+
+  test "keyword lists" do
+    assert_diff([file: "nofile", line: 1] = [file: "nofile", line: 1], [])
+
+    refute_diff(
+      [file: "nofile", line: 1] = [file: nil, lime: 1],
+      ~s/[file: -"nofile"-, -line:- 1]/,
+      "[file: +nil+, +lime:+ 1]"
+    )
+
+    refute_diff(
+      [file: nil, line: 1] = [file: "nofile"],
+      "[file: -nil-, -line: 1-]",
+      ~s/[file: +"nofile"+]/
+    )
+
+    refute_diff(
+      ["foo-bar": 1] = [],
+      ~s/[-"foo-bar": 1-]/,
+      "[]"
+    )
+
+    refute_diff(
+      [file: nil] = [{:line, 1}, {1, :foo}],
+      "[-file:- -nil-]",
+      "[{+:line+, +1+}, +{1, :foo}+]"
+    )
+  end
+
+  test "tuples" do
+    assert_diff({:a, :b} = {:a, :b}, [])
+
+    refute_diff({:a, :b} = {:a, :x}, "{:a, -:b-}", "{:a, +:x+}")
+    refute_diff({:a, :b} = {:x, :x}, "{-:a-, -:b-}", "{+:x+, +:x+}")
+    refute_diff({:a, :b, :c} = {:a, :b, :x}, "{:a, :b, -:c-}", "{:a, :b, +:x+}")
+
+    refute_diff({:a} = {:a, :b}, "{:a}", "{:a, +:b+}")
+    refute_diff({:a, :b} = {:a}, "{:a, -:b-}", "{:a}")
+
+    refute_diff({:ok, value} = {:error, :fatal}, "{-:ok-, value}", "{+:error+, :fatal}")
+    refute_diff({:a, :b} = :a, "-{:a, :b}-", "+:a+")
+
+    refute_diff({:foo} = {:foo, {:a, :b, :c}}, "{:foo}", "{:foo, +{:a, :b, :c}+}")
+  end
+
+  test "tuples outside of match context" do
+    assert_diff({:a, :b} == {:a, :b}, [])
+
+    refute_diff({:a} == {:a, :b}, "{:a}", "{:a, +:b+}")
+    refute_diff({:a, :b} == {:a}, "{:a, -:b-}", "{:a}")
+
+    refute_diff({:{}, [], [:a]} == {:a}, "{-:{}-, -[]-, -[:a]-}", "{+:a+}")
+    refute_diff({:{}, [], [:a]} == :a, "-{:{}, [], [:a]}-", "+:a+")
+    refute_diff({:a, :b, :c} == {:a, :b, :x}, "{:a, :b, -:c-}", "{:a, :b, +:x+}")
+
+    refute_diff({:foo} == {:foo, {:a, :b, :c}}, "{:foo}", "{:foo, +{:a, :b, :c}+}")
+    refute_diff({:foo, {:a, :b, :c}} == {:foo}, "{:foo, -{:a, :b, :c}-}", "{:foo}")
+  end
+
+  test "maps" do
+    assert_diff(%{a: 1} = %{a: 1}, [])
+    assert_diff(%{a: 1} = %{a: 1, b: 2}, [])
+    assert_diff(%{a: 1, b: 2} = %{a: 1, b: 2}, [])
+    assert_diff(%{b: 2, a: 1} = %{a: 1, b: 2}, [])
+    assert_diff(%{a: 1, b: 2, c: 3} = %{a: 1, b: 2, c: 3}, [])
+    assert_diff(%{c: 3, b: 2, a: 1} = %{a: 1, b: 2, c: 3}, [])
+
+    refute_diff(%{a: 1, b: 2} = %{a: 1}, "%{a: 1, -b: 2-}", "%{a: 1}")
+    refute_diff(%{a: 1, b: 2} = %{a: 1, b: 12}, "%{a: 1, b: 2}", "%{a: 1, b: +1+2}")
+    refute_diff(%{a: 1, b: 2} = %{a: 1, c: 2}, "%{a: 1, -b: 2-}", "%{a: 1, c: 2}")
+    refute_diff(%{a: 1, b: 2, c: 3} = %{a: 1, b: 12}, "%{a: 1, b: 2, -c: 3-}", "%{a: 1, b: +1+2}")
+    refute_diff(%{a: 1, b: 2, c: 3} = %{a: 1, c: 2}, "%{a: 1, c: -3-, -b: 2-}", "%{a: 1, c: +2+}")
+    refute_diff(%{a: 1} = %{a: 2, b: 2, c: 3}, "%{a: -1-}", "%{a: +2+, b: 2, c: 3}")
+
+    refute_diff(
+      %{1 => :a, 2 => :b} = %{1 => :a, 12 => :b},
+      "%{1 => :a, -2 => :b-}",
+      "%{1 => :a, 12 => :b}"
+    )
+
+    refute_diff(
+      %{1 => :a, 2 => :b} = %{1 => :a, :b => 2},
+      "%{1 => :a, -2 => :b-}",
+      "%{1 => :a, :b => 2}"
+    )
+
+    pins = %{{:a, nil} => :a, {:b, nil} => :b}
+    assert_diff(%{^a => 1} = %{a: 1}, [], pins)
+    assert_diff(%{^a => x} = %{a: 1}, [x: 1], pins)
+
+    refute_diff(%{^a => 1, :a => 2} = %{a: 1}, "%{^a => 1, -:a => 2-}", "%{a: 1}", pins)
+
+    refute_diff(
+      %{^a => x, ^b => x} = %{a: 1, b: 2},
+      "%{^a => x, ^b => -x-}",
+      "%{a: 1, b: +2+}",
+      pins
+    )
+
+    refute_diff(%{a: 1} = :a, "-%{a: 1}-", "+:a+")
+  end
+
+  test "maps as pinned map value" do
+    user = %{"id" => 13, "name" => "john"}
+
+    notification = %{
+      "user" => user,
+      "subtitle" => "foo"
+    }
+
+    assert_diff(
+      %{
+        "user" => ^user,
+        "subtitle" => "foo"
+      } = notification,
+      [],
+      %{{:user, nil} => user}
+    )
+
+    refute_diff(
+      %{
+        "user" => ^user,
+        "subtitle" => "bar"
+      } = notification,
+      ~s|%{"subtitle" => "-bar-", "user" => ^user}|,
+      ~s|%{"subtitle" => "+foo+", "user" => %{"id" => 13, "name" => "john"}}|,
+      %{{:user, nil} => user}
+    )
+  end
+
+  test "maps outside match context" do
+    assert_diff(%{a: 1} == %{a: 1}, [])
+    assert_diff(%{a: 1, b: 2} == %{a: 1, b: 2}, [])
+    assert_diff(%{b: 2, a: 1} == %{a: 1, b: 2}, [])
+    assert_diff(%{a: 1, b: 2, c: 3} == %{a: 1, b: 2, c: 3}, [])
+    assert_diff(%{c: 3, b: 2, a: 1} == %{a: 1, b: 2, c: 3}, [])
+
+    refute_diff(%{a: 1} == %{a: 1, b: 2}, "%{a: 1}", "%{a: 1, +b: 2+}")
+    refute_diff(%{a: 1, b: 2} == %{a: 1}, "%{a: 1, -b: 2-}", "%{a: 1}")
+    refute_diff(%{a: 1, b: 12} == %{a: 1, b: 2}, "%{a: 1, b: -1-2}", "%{a: 1, b: 2}")
+    refute_diff(%{a: 1, b: 2} == %{a: 1, b: 12}, "%{a: 1, b: 2}", "%{a: 1, b: +1+2}")
+    refute_diff(%{a: 1, b: 2} == %{a: 1, c: 2}, "%{a: 1, -b: 2-}", "%{a: 1, +c: 2+}")
+
+    refute_diff(
+      %{name: {:a, :b, :c}} == :error,
+      "-%{name: {:a, :b, :c}}",
+      "+:error+"
+    )
+  end
+
+  test "structs" do
+    assert_diff(%User{age: 16} = %User{age: 16}, [])
+    assert_diff(%{age: 16, __struct__: User} = %User{age: 16}, [])
+
+    refute_diff(
+      %User{age: 16} = %User{age: 21},
+      "%ExUnit.DiffTest.User{age: 1-6-}",
+      "%ExUnit.DiffTest.User{age: +2+1, name: nil}"
+    )
+
+    refute_diff(
+      %User{age: 16} = %Person{age: 21},
+      "%-ExUnit.DiffTest.User-{age: 1-6-}",
+      "%+ExUnit.DiffTest.Person+{age: +2+1}"
+    )
+
+    refute_diff(
+      %User{age: 16} = %Person{age: 21},
+      "%-ExUnit.DiffTest.User-{age: 1-6-}",
+      "%+ExUnit.DiffTest.Person+{age: +2+1}"
+    )
+
+    refute_diff(
+      %User{age: 16} = %{age: 16},
+      "%-ExUnit.DiffTest.User-{age: 16}",
+      "%{age: 16}"
+    )
+
+    refute_diff(
+      %User{age: 16} = %{age: 21},
+      "%-ExUnit.DiffTest.User-{age: 1-6-}",
+      "%{age: +2+1}"
+    )
+
+    refute_diff(
+      %{age: 16, __struct__: Person} = %User{age: 16},
+      "%-ExUnit.DiffTest.Person-{age: 16}",
+      "%+ExUnit.DiffTest.User+{age: 16, name: nil}"
+    )
+
+    pins = %{{:twenty_one, nil} => 21}
+    assert_diff(%User{age: ^twenty_one} = %User{age: 21}, [], pins)
+    assert_diff(%User{age: age} = %User{age: 21}, [age: 21], pins)
+    refute_diff(%User{age: 21} = :a, "-%ExUnit.DiffTest.User{age: 21}-", "+:a+", pins)
+  end
+
+  test "structs outside of match context" do
+    assert_diff(%User{age: 16} == %User{age: 16}, [])
+    assert_diff(%{age: 16, __struct__: User, name: nil} == %User{age: 16}, [])
+
+    refute_diff(
+      %User{age: 16} == %{age: 16},
+      "%-ExUnit.DiffTest.User-{age: 16, -name: nil-}",
+      "%{age: 16}"
+    )
+
+    refute_diff(
+      %User{age: 16} == %User{age: 21},
+      "%ExUnit.DiffTest.User{age: 1-6-, name: nil}",
+      "%ExUnit.DiffTest.User{age: +2+1, name: nil}"
+    )
+
+    refute_diff(
+      %User{age: 16} == %Person{age: 21},
+      "%-ExUnit.DiffTest.User-{age: 1-6-, -name: nil-}",
+      "%+ExUnit.DiffTest.Person+{age: +2+1}"
+    )
+  end
+
+  test "structs with inspect" do
+    refute_diff(
+      ~D[2017-10-01] = ~D[2017-10-02],
+      ~s/-~D[2017-10-01]-/,
+      "~D[2017-10-0+2+]"
+    )
+
+    refute_diff(
+      "2017-10-01" = ~D[2017-10-02],
+      ~s/-"2017-10-01"-/,
+      "+~D[2017-10-02]+"
+    )
+
+    refute_diff(
+      ~D[2017-10-02] = "2017-10-01",
+      ~s/-~D[2017-10-02]-/,
+      ~s/+"2017-10-01"+/
+    )
+
+    refute_diff(
+      ~HTML[hi] = ~HTML[bye],
+      "-~HTML[hi]-",
+      "~HTML[+bye+]"
+    )
+  end
+
+  test "structs with missing keys on match" do
+    struct = %User{
+      age: ~U[2020-07-30 13:49:59.253158Z]
+    }
+
+    assert_diff(%User{age: %DateTime{}} = struct, [])
+
+    refute_diff(
+      %User{age: %Date{}} = struct,
+      ~s/%ExUnit.DiffTest.User{age: %-Date-{}}/,
+      """
+      %ExUnit.DiffTest.User{
+        age: %+DateTime+{
+          calendar: Calendar.ISO,
+          day: 30,
+          hour: 13,
+          microsecond: {253158, 6},
+          minute: 49,
+          month: 7,
+          second: 59,
+          std_offset: 0,
+          time_zone: "Etc\/UTC",
+          utc_offset: 0,
+          year: 2020,
+          zone_abbr: "UTC"
+        },
+        name: nil
+      }\
+      """
+    )
+
+    refute_diff(
+      %{age: %Date{}} = struct,
+      ~s/%{age: %-Date-{}}/,
+      """
+      %ExUnit.DiffTest.User{
+        age: %+DateTime+{
+          calendar: Calendar.ISO,
+          day: 30,
+          hour: 13,
+          microsecond: {253158, 6},
+          minute: 49,
+          month: 7,
+          second: 59,
+          std_offset: 0,
+          time_zone: \"Etc/UTC\",
+          utc_offset: 0,
+          year: 2020,
+          zone_abbr: \"UTC\"
+        },
+        name: nil
+      }\
+      """
+    )
+  end
+
+  test "structs with inspect outside match context" do
+    refute_diff(
+      ~D[2017-10-01] == ~D[2017-10-02],
+      "~D[2017-10-0-1-]",
+      "~D[2017-10-0+2+]"
+    )
+
+    refute_diff(
+      "2017-10-01" == ~D[2017-10-02],
+      ~s/-"2017-10-01"-/,
+      "+~D[2017-10-02]+"
+    )
+
+    refute_diff(
+      ~D[2017-10-02] == "2017-10-01",
+      ~s/-~D[2017-10-02]-/,
+      ~s/+"2017-10-01"+/
+    )
+
+    refute_diff(
+      ~HTML[hi] == ~HTML[bye],
+      "~HTML[-hi-]",
+      "~HTML[+bye+]"
+    )
+  end
+
+  test "structs with same inspect but different inside match" do
+    refute_diff(
+      %Opaque{data: 1} = %Opaque{data: 2},
+      "%ExUnit.DiffTest.Opaque{data: -1-}",
+      "%ExUnit.DiffTest.Opaque{data: +2+}"
+    )
+
+    refute_diff(
+      %Opaque{data: %{hello: :world}} = %Opaque{data: %{hello: "world"}},
+      "#Opaque<data: %{hello: -:-world}>",
+      "#Opaque<data: %{hello: +\"+world+\"+}>"
+    )
+  end
+
+  test "structs with same inspect but different outside match" do
+    refute_diff(
+      %Opaque{data: 1} == %Opaque{data: 2},
+      "%ExUnit.DiffTest.Opaque{data: -1-}",
+      "%ExUnit.DiffTest.Opaque{data: +2+}"
+    )
+
+    refute_diff(
+      %Opaque{data: %{hello: :world}} == %Opaque{data: %{hello: "world"}},
+      "#Opaque<data: %{hello: -:-world}>",
+      "#Opaque<data: %{hello: +\"+world+\"+}>"
+    )
+  end
+
+  test "structs with inspect in a list" do
+    refute_diff(
+      Enum.sort([~D[2019-03-31], ~D[2019-04-01]]) == [~D[2019-03-31], ~D[2019-04-01]],
+      "[-~D[2019-04-01]-, ~D[2019-03-31]]",
+      "[~D[2019-03-31], +~D[2019-04-01]+]"
+    )
+  end
+
+  test "structs with matched type" do
+    pins = %{{:type, nil} => User, {:age, nil} => 33}
+
+    # pin on __struct__
+    assert_diff(
+      %{__struct__: ^type, age: ^age, name: "john"} = %User{name: "john", age: 33},
+      [],
+      pins
+    )
+
+    refute_diff(
+      %{__struct__: ^type, age: ^age, name: "john"} = %User{name: "jane", age: 33},
+      "%{__struct__: ^type, age: ^age, name: \"j-oh-n\"}",
+      "%ExUnit.DiffTest.User{age: 33, name: \"j+a+n+e+\"}",
+      pins
+    )
+
+    refute_diff(
+      %{__struct__: ^type, age: ^age, name: "john"} = %User{name: "john", age: 35},
+      "%{__struct__: ^type, age: -^age-, name: \"john\"}",
+      "%ExUnit.DiffTest.User{age: 3+5+, name: \"john\"}",
+      pins
+    )
+
+    refute_diff(
+      %{__struct__: ^type, age: ^age, name: "john"} = ~D[2020-01-01],
+      "%{__struct__: -^type-, -age: ^age-, -name: \"john\"-}",
+      "%+Date+{calendar: Calendar.ISO, day: 1, month: 1, year: 2020}",
+      pins
+    )
+
+    # pin on %
+    assert_diff(
+      %^type{age: ^age, name: "john"} = %User{name: "john", age: 33},
+      [],
+      pins
+    )
+
+    refute_diff(
+      %^type{age: ^age, name: "john"} = %User{name: "jane", age: 33},
+      "%{__struct__: ^type, age: ^age, name: \"j-oh-n\"}",
+      "%ExUnit.DiffTest.User{age: 33, name: \"j+a+n+e+\"}",
+      pins
+    )
+
+    refute_diff(
+      %^type{age: ^age, name: "john"} = %User{name: "john", age: 35},
+      "%{__struct__: ^type, age: -^age-, name: \"john\"}",
+      "%ExUnit.DiffTest.User{age: 3+5+, name: \"john\"}",
+      pins
+    )
+
+    refute_diff(
+      %^type{age: ^age, name: "john"} = ~D[2020-01-01],
+      "%{__struct__: -^type-, -age: ^age-, -name: \"john\"-}",
+      "%+Date+{calendar: Calendar.ISO, day: 1, month: 1, year: 2020}",
+      pins
+    )
+
+    # right side is not map-like
+    refute_diff(
+      %^type{age: ^age, name: "john"} = nil,
+      "-%^type{age: ^age, name: \"john\"}-",
+      "+nil+",
+      pins
+    )
+  end
+
+  test "invalid structs" do
+    refute_diff(
+      %{__struct__: Unknown} = %{},
+      "%{-__struct__: Unknown-}",
+      "%{}"
+    )
+
+    refute_diff(
+      %{__struct__: Date, unknown: :field} = %{},
+      "%{-__struct__: Date-, -unknown: :field-}",
+      "%{}"
+    )
+  end
+
+  test "maps in lists" do
+    map = %{
+      "address" => %{
+        "street" => "123 Main St",
+        "zip" => "62701"
+      },
+      "age" => 30,
+      "first_name" => "John",
+      "language" => "en-US",
+      "last_name" => "Doe",
+      "notifications" => true
+    }
+
+    refute_diff(
+      [map] == [],
+      """
+      [
+        -%{
+          "address" => %{"street" => "123 Main St", "zip" => "62701"},
+          "age" => 30,
+          "first_name" => "John",
+          "language" => "en-US",
+          "last_name" => "Doe",
+          "notifications" => true
+        }-
+      ]\
+      """,
+      "[]"
+    )
+
+    refute_diff(
+      [] == [map],
+      "[]",
+      """
+      [
+        +%{
+          "address" => %{"street" => "123 Main St", "zip" => "62701"},
+          "age" => 30,
+          "first_name" => "John",
+          "language" => "en-US",
+          "last_name" => "Doe",
+          "notifications" => true
+        }+
+      ]\
+      """
+    )
+
+    assert_diff([map] == [map], [])
+  end
+
+  test "structs in lists" do
+    customer = %Customer{
+      address: %{
+        "street" => "123 Main St",
+        "zip" => "62701"
+      },
+      age: 30,
+      first_name: "John",
+      language: "en-US",
+      last_name: "Doe",
+      notifications: true
+    }
+
+    refute_diff(
+      [customer] == [],
+      """
+      [
+        -%ExUnit.DiffTest.Customer{
+          address: %{"street" => "123 Main St", "zip" => "62701"},
+          age: 30,
+          first_name: "John",
+          language: "en-US",
+          last_name: "Doe",
+          notifications: true
+        }-
+      ]\
+      """,
+      "[]"
+    )
+
+    refute_diff(
+      [] == [customer],
+      "[]",
+      """
+      [
+        +%ExUnit.DiffTest.Customer{
+          address: %{"street" => "123 Main St", "zip" => "62701"},
+          age: 30,
+          first_name: "John",
+          language: "en-US",
+          last_name: "Doe",
+          notifications: true
+        }+
+      ]\
+      """
+    )
+
+    assert_diff([customer] == [customer], [])
+  end
+
+  test "maps and structs with escaped values" do
+    refute_diff(
+      %User{age: {1, 2, 3}} = %User{age: {1, 2, 4}},
+      "%ExUnit.DiffTest.User{age: {1, 2, -3-}}",
+      "%ExUnit.DiffTest.User{age: {1, 2, +4+}, name: nil}"
+    )
+
+    refute_diff(
+      %User{age: {1, 2, 3}, name: name} = %User{age: {1, 2, 4}},
+      "%ExUnit.DiffTest.User{age: {1, 2, -3-}, name: name}",
+      "%ExUnit.DiffTest.User{age: {1, 2, +4+}, name: nil}"
+    )
+
+    refute_diff(
+      %User{name: :foo} = %User{name: :bar, age: {1, 2, 3}},
+      "%ExUnit.DiffTest.User{name: -:foo-}",
+      "%ExUnit.DiffTest.User{name: +:bar+, age: {1, 2, 3}}"
+    )
+
+    refute_diff(
+      %User{age: {1, 2, 3}} == %User{age: {1, 2, 4}},
+      "%ExUnit.DiffTest.User{age: {1, 2, -3-}, name: nil}",
+      "%ExUnit.DiffTest.User{age: {1, 2, +4+}, name: nil}"
+    )
+
+    refute_diff(
+      %User{age: {1, 2, 4}} == %User{age: {1, 2, 3}},
+      "%ExUnit.DiffTest.User{age: {1, 2, -4-}, name: nil}",
+      "%ExUnit.DiffTest.User{age: {1, 2, +3+}, name: nil}"
+    )
+
+    refute_diff(
+      %{name: :foo} == %{name: :foo, age: {1, 2, 3}},
+      "%{name: :foo}",
+      "%{name: :foo, +age: {1, 2, 3}+}"
+    )
+
+    refute_diff(
+      %{name: :foo, age: {1, 2, 3}} == %{name: :foo},
+      "%{name: :foo, -age: {1, 2, 3}-}",
+      "%{name: :foo}"
+    )
+  end
+
+  test "strings" do
+    assert_diff("" = "", [])
+    assert_diff("fox hops over the dog" = "fox hops over the dog", [])
+
+    refute_diff("fox" = "foo", "fo-x-", "fo+o+")
+
+    refute_diff(
+      "fox hops over \"the dog" = "fox  jumps over the  lazy cat",
+      ~s/"fox -ho-ps over -\\\"-the -dog-"/,
+      ~s/"fox + jum+ps over the + lazy cat+"/
+    )
+
+    refute_diff(
+      "short" = "really long string that should not emit diff against short",
+      ~s/"-short-"/,
+      ~s/"+really long string that should not emit diff against short+"/
+    )
+
+    refute_diff("foo" = :a, ~s/-"foo"-/, "+:a+")
+  end
+
+  test "strings outside match context" do
+    assert_diff("" == "", [])
+    assert_diff("fox hops over the dog" == "fox hops over the dog", [])
+    refute_diff("fox" == "foo", "fo-x-", "fo+o+")
+
+    refute_diff(
+      "{\"foo\":1,\"barbaz\":[1,2,3]}" == "4",
+      ~s/"-{\\\"foo\\\":1,\\\"barbaz\\\":[1,2,3]}-"/,
+      ~s/"+4+"/
+    )
+  end
+
+  test "concat binaries" do
+    assert_diff("fox hops" <> _ = "fox hops over the dog", [])
+    assert_diff("fox hops" <> " over the dog" = "fox hops over the dog", [])
+    assert_diff("fox hops " <> "over " <> "the dog" = "fox hops over the dog", [])
+
+    refute_diff(
+      "fox hops" <> _ = "dog hops over the fox",
+      ~s/"-f-o-x- hops" <> _/,
+      ~s/+d+o+g+ hops over the fox/
+    )
+
+    refute_diff(
+      "fox hops" <> " under the dog" = "fox hops over the dog",
+      ~s/"fox hops" <> " -und-er the dog"/,
+      ~s/"fox hops +ov+er the dog"/
+    )
+
+    refute_diff(
+      "fox hops over" <> " the dog" = "fox hops over",
+      ~s/"fox hops over" <> "- the dog-"/,
+      ~s/"fox hops over"/
+    )
+
+    refute_diff(
+      "fox hops" <> " over the dog" = "fox",
+      ~s/"-fox hops-" <> "- over the dog-"/,
+      ~s/"+fox+"/
+    )
+
+    refute_diff(
+      "fox" <> " hops" = "fox h",
+      ~s/"fox" <> " h-ops-"/,
+      ~s/"fox h"/
+    )
+
+    refute_diff(
+      "fox hops " <> "hover " <> "the dog" = "fox hops over the dog",
+      ~s/"fox hops " <> "-h-over " <> "the dog"/,
+      ~s/"fox hops over the dog"/
+    )
+
+    refute_diff("fox" <> " hops" = :a, ~s/-"fox" <> " hops"-/, "+:a+")
+  end
+
+  test "concat binaries with pin" do
+    pins = %{{:x, nil} => " over the dog"}
+
+    assert_diff("fox hops" <> x = "fox hops over the dog", x: " over the dog")
+    assert_diff("fox hops " <> "over " <> x = "fox hops over the dog", x: "the dog")
+    assert_diff("fox hops" <> ^x = "fox hops over the dog", [], pins)
+
+    refute_diff(
+      "fox hops " <> "hover " <> x = "fox hops over the dog",
+      ~s/"fox hops " <> "-h-over " <> x/,
+      ~s/"fox hops over +t+he dog"/
+    )
+
+    refute_diff(
+      "fox hops " <> "hover " <> ^x = "fox hops over the dog",
+      ~s/"fox hops " <> "-h-over " <> -^x-/,
+      ~s/"fox hops over +t+he dog"/,
+      pins
+    )
+  end
+
+  test "concat binaries with specifiers" do
+    input = "foobar"
+
+    refute_diff(
+      <<trap::binary-size(3)>> <> "baz" = input,
+      "-<<trap::binary-size(3)>> <> \"baz\"-",
+      "+\"foobar\"+"
+    )
+
+    refute_diff(
+      "hello " <> <<_::binary-size(6)>> = "hello world",
+      "\"hello \" <> -<<_::binary-size(6)>>-",
+      "\"hello +world+\""
+    )
+  end
+
+  test "underscore" do
+    assert_diff(_ = :a, [])
+    assert_diff({_, _} = {:a, :b}, [])
+
+    refute_diff({_, :a} = {:b, :b}, "{_, -:a-}", "{:b, +:b+}")
+  end
+
+  test "macros" do
+    assert_diff(one() = 1, [])
+    assert_diff(tuple(x, x) = {1, 1}, x: 1)
+
+    refute_diff(one() = 2, "-1-", "+2+")
+    refute_diff(tuple(x, x) = {1, 2}, "{x, -x-}", "{1, +2+}")
+
+    pins = %{{:x, nil} => 1}
+    assert_diff(pin_x() = 1, [], pins)
+    refute_diff(pin_x() = 2, "-pin_x()-", "+2+", pins)
+  end
+
+  test "guards" do
+    assert_diff((x when x == 0) = 0, x: 0)
+    assert_diff((x when x == 0 and is_integer(x)) = 0, x: 0)
+    assert_diff((x when x == 0 or x == 1) = 0, x: 0)
+    assert_diff((x when x == 0 when x == 1) = 0, x: 0)
+    assert_diff((x when one() == 1) = 0, x: 0)
+
+    refute_diff((x when x == 1) = 0, "x when -x == 1-", "0")
+    refute_diff((x when x == 0 and x == 1) = 0, "x when x == 0 and -x == 1-", "0")
+    refute_diff((x when x == 1 and x == 2) = 0, "x when -x == 1- and -x == 2-", "0")
+    refute_diff((x when x == 1 or x == 2) = 0, "x when -x == 1- or -x == 2-", "0")
+    refute_diff((x when x == 1 when x == 2) = 0, "x when -x == 1- when -x == 2-", "0")
+    refute_diff((x when x in [1, 2]) = 0, "x when -x in [1, 2]-", "0")
+    refute_diff(({:ok, x} when x == 1) = :error, "-{:ok, x}- when x == 1", "+:error+")
+
+    refute_diff((x when x == z) = 0, "x when x == z", "0", z: 1)
+  end
+
+  test "blocks" do
+    refute_diff(
+      block_head(
+        (
+          1
+          2
+        )
+      ) = 3,
+      "1",
+      "3"
+    )
+
+    refute_diff(
+      ["foo" | {:__block__, [], [1]}] = ["bar" | {:__block__, [], [2]}],
+      "[\"-foo-\" | {:__block__, [], [-1-]}]",
+      "[\"+bar+\" | {:__block__, [], [+2+]}]"
+    )
+
+    refute_diff(
+      ["foo" | {:__block__, [], [1]}] == ["bar" | {:__block__, [], [2]}],
+      "[\"-foo-\" | {:__block__, [], [-1-]}]",
+      "[\"+bar+\" | {:__block__, [], [+2+]}]"
+    )
+  end
+
+  test "charlists" do
+    refute_diff(
+      ~c"fox hops over 'the dog" = ~c"fox jumps over the lazy cat",
+      "~c\"fox -ho-ps over -'-the -dog-\"",
+      "~c\"fox +jum+ps over the +lazy cat+\""
+    )
+
+    refute_diff({[], :ok} = {[], [], :ok}, "{[], -:ok-}", "{[], +[]+, +:ok+}")
+    refute_diff({[], :ok} = {~c"foo", [], :ok}, "{~c\"--\", -:ok-}", "{~c\"+foo+\", +[]+, +:ok+}")
+    refute_diff({~c"foo", :ok} = {[], [], :ok}, "{~c\"-foo-\", -:ok-}", "{~c\"++\", +[]+, +:ok+}")
+
+    refute_diff(
+      {~c"foo", :ok} = {~c"bar", [], :ok},
+      "{~c\"-foo-\", -:ok-}",
+      "{~c\"+bar+\", +[]+, +:ok+}"
+    )
+  end
+
+  test "refs" do
+    ref1 = make_ref()
+    ref2 = make_ref()
+
+    inspect_ref1 = inspect(ref1)
+    inspect_ref2 = inspect(ref2)
+
+    assert_diff(ref1 == ref1, [])
+    assert_diff({ref1, ref2} == {ref1, ref2}, [])
+
+    refute_diff(ref1 == ref2, "-#{inspect_ref1}-", "+#{inspect_ref2}+")
+
+    refute_diff(
+      {ref1, ref2} == {ref2, ref1},
+      """
+      {
+        -#{inspect_ref1}-,
+        -#{inspect_ref2}-
+      }\
+      """,
+      """
+      {
+        +#{inspect_ref2}+,
+        +#{inspect_ref1}+
+      }\
+      """
+    )
+
+    refute_diff(
+      {ref1, ref2} == ref1,
+      "-{#{inspect_ref1}, #{inspect_ref2}}-",
+      "+#{inspect_ref1}+"
+    )
+
+    refute_diff(
+      ref1 == {ref1, ref2},
+      "-#{inspect_ref1}-",
+      "+{#{inspect_ref1}, #{inspect_ref2}}+"
+    )
+
+    refute_diff(ref1 == :a, "-#{inspect_ref1}-", "+:a+")
+    refute_diff({ref1, ref2} == :a, "-{#{inspect_ref1}, #{inspect_ref2}}", "+:a+")
+
+    refute_diff(
+      %{ref1 => ref2} == :a,
+      """
+      -%{
+        #{inspect_ref1} => #{inspect_ref2}
+      }\
+      """,
+      "+:a+"
+    )
+
+    refute_diff(
+      %Opaque{data: ref1} == :a,
+      "-#Opaque<???>-",
+      "+:a+"
+    )
+  end
+
+  test "pids" do
+    pid = self()
+    inspect_pid = inspect(pid)
+
+    assert_diff(pid == pid, [])
+    assert_diff({pid, pid} == {pid, pid}, [])
+
+    refute_diff(pid == :a, "-#{inspect_pid}-", "+:a+")
+    refute_diff({pid, pid} == :a, "-{#{inspect_pid}, #{inspect_pid}}", "+:a+")
+
+    refute_diff({pid, :a} == {:a, pid}, "{-#{inspect_pid}-, -:a-}", "{+:a+, +#{inspect_pid}+}")
+    refute_diff(%{pid => pid} == :a, "-%{#{inspect_pid} => #{inspect_pid}}", "+:a+")
+
+    refute_diff(
+      %Opaque{data: pid} == :a,
+      "-#Opaque<???>-",
+      "+:a+"
+    )
+  end
+
+  @compile {:no_warn_undefined, String}
+
+  test "functions" do
+    identity = & &1
+    inspect = inspect(identity)
+
+    assert_diff(identity == identity, [])
+    assert_diff({identity, identity} == {identity, identity}, [])
+
+    refute_diff(identity == :a, "-#{inspect}-", "+:a+")
+    refute_diff({identity, identity} == :a, "-{#{inspect}, #{inspect}}", "+:a+")
+    refute_diff({identity, :a} == {:a, identity}, "{-#{inspect}-, -:a-}", "{+:a+, +#{inspect}+}")
+
+    refute_diff(
+      %{identity => identity} == :a,
+      """
+      -%{
+        #{inspect} => #{inspect}
+      }-\
+      """,
+      "+:a+"
+    )
+
+    refute_diff(
+      (&String.to_charlist/1) == (&String.unknown/1),
+      "-&String.to_charlist/1-",
+      "+&String.unknown/1"
+    )
+
+    refute_diff(
+      %Opaque{data: identity} == :a,
+      "-#Opaque<???>-",
+      "+:a+"
+    )
+  end
+
+  defp closure(a), do: fn -> a end
+
+  test "functions with closure" do
+    closure1 = closure(1)
+    closure2 = closure(2)
+
+    fun_info = Function.info(closure1)
+    uniq = Integer.to_string(fun_info[:new_index]) <> "." <> Integer.to_string(fun_info[:uniq])
+
+    assert_diff(closure1 == closure1, [])
+
+    refute_diff(
+      closure1 == closure2,
+      "#Function<\n  #{uniq}/0 in ExUnit.DiffTest.closure/1\n  [-1-]\n>",
+      "#Function<\n  #{uniq}/0 in ExUnit.DiffTest.closure/1\n  [+2+]\n>"
+    )
+  end
+
+  test "not supported" do
+    refute_diff(
+      <<147, 1, 2, 31>> = <<193, 1, 31>>,
+      "-<<147, 1, 2, 31>>-",
+      "+<<193, 1, 31>>+"
+    )
+  end
+end
diff --git a/lib/ex_unit/test/ex_unit/doc_test_test.exs b/lib/ex_unit/test/ex_unit/doc_test_test.exs
index 9b67cfde36f..fffb4cbe5b0 100644
--- a/lib/ex_unit/test/ex_unit/doc_test_test.exs
+++ b/lib/ex_unit/test/ex_unit/doc_test_test.exs
@@ -1,15 +1,42 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-import ExUnit.TestHelpers
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule ExUnit.BeamHelpers do
+  # Beam files compiled on demand
+  path = Path.expand("../../tmp/beams", __DIR__)
+  File.rm_rf!(path)
+  File.mkdir_p!(path)
+  Code.prepend_path(path)
+
+  def write_beam({:module, name, bin, _} = res) do
+    beam_path = Path.join(unquote(path), Atom.to_string(name) <> ".beam")
+    File.write!(beam_path, bin)
+    res
+  end
+end
 
 defmodule ExUnit.DocTestTest.GoodModule do
   @doc """
-  iex> test_fun
+  iex> one()
   1
-  iex> test_fun + 1
+  iex> one() + 1
   2
   """
-  def test_fun, do: 1
+  def one, do: 1
+
+  @doc """
+  iex> List.flatten([])
+  """
+  def only_call, do: :ok
+
+  @doc ~S"""
+  iex> ~S(f#{o}o)
+  "f\#{o}o"
+  """
+  def test_sigil, do: :ok
 
   @doc """
   iex> a = 1
@@ -21,33 +48,35 @@ defmodule ExUnit.DocTestTest.GoodModule do
   def single_context, do: :ok
 
   @doc """
-  iex> 1 + (fn() -> "" end).()
-  ** (ArithmeticError) bad argument in arithmetic expression
+  iex> raise "message"
+  ** (RuntimeError) message
 
-  iex> 2 + (fn() -> :a end).()
-  ** (ArithmeticError) bad argument in arithmetic expression
+  iex> raise "message"
+  ** (RuntimeError) message
   """
   def two_exceptions, do: :ok
 
   @doc """
-  iex> 1 + (fn() -> :a end).()
-  ** (ArithmeticError) bad argument in arithmetic expression
+  iex> raise "message"
+  ** (RuntimeError) message
   """
   def exception_test, do: :ok
 
-  @doc """
-  iex> Enum.into([a: 0, b: 1, c: 2], HashDict.new)
-  #HashDict<[c: 2, b: 1, a: 0]>
+  @doc ~S"""
+  iex> raise "foo\nbar"
+  ** (RuntimeError) foo
+  bar
   """
-  def inspect1_test, do: :ok
+  def multiline_exception_test, do: :ok
 
   @doc """
-  iex> x = Enum.into([a: 0, b: 1, c: 2], HashDict.new)
-  ...> x
-  #HashDict<[c: 2, b: 1, a: 0]>
+  iex> num = 1
+  iex> ExUnit.DocTestTest.GoodModule.variable_in_expectation(num)
+  num + 1
   """
-  def inspect2_test, do: :ok
-end |> write_beam
+  def variable_in_expectation(num), do: num + 1
+end
+|> ExUnit.BeamHelpers.write_beam()
 
 defmodule ExUnit.DocTestTest.MultipleExceptions do
   @doc """
@@ -57,53 +86,73 @@ defmodule ExUnit.DocTestTest.MultipleExceptions do
   ** (ArithmeticError) bad argument in arithmetic expression
   """
   def two_exceptions, do: :ok
-end |> write_beam
+end
+|> ExUnit.BeamHelpers.write_beam()
 
 defmodule ExUnit.DocTestTest.SomewhatGoodModuleWithOnly do
   @doc """
-  iex> test_fun
+  iex> one()
   1
-  iex> test_fun + 1
+  iex> one() + 1
   2
   """
-  def test_fun, do: 1
+  def one, do: 1
 
   @doc """
-  iex> test_fun
-  1
-  iex> test_fun + 1
-  1
+  iex> two()
+  2
+  iex> two() + 1
+  100
   """
-  def test_fun1, do: 1
-end |> write_beam
+  def two, do: 2
+end
+|> ExUnit.BeamHelpers.write_beam()
 
 defmodule ExUnit.DocTestTest.SomewhatGoodModuleWithExcept do
+  @moduledoc """
+  iex> 1 + 1
+  1
+  """
+
   @doc """
-  iex> test_fun
+  iex> one()
   1
-  iex> test_fun + 1
+  iex> one() + 1
   2
   """
-  def test_fun, do: 1
+  def one, do: 1
 
   @doc """
-  iex> test_fun
-  1
-  iex> test_fun + 1
-  1
+  iex> two()
+  2
+  iex> two() + 1
+  100
   """
-  def test_fun1, do: 1
-end |> write_beam
+  def two, do: 2
+end
+|> ExUnit.BeamHelpers.write_beam()
 
 defmodule ExUnit.DocTestTest.NoImport do
   @doc """
-  iex> ExUnit.DocTestTest.NoImport.min(1, 2)
+  iex> ExUnit.DocTestTest.NoImport.max(1, 2)
+  {:ok, 2}
+
+  iex> max(1, 2)
   2
   """
-  def min(a, b), do: max(a, b)
-end |> write_beam
+  def max(a, b), do: {:ok, Kernel.max(a, b)}
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.NoTrailing do
+  @doc "    iex>1 + 2\n    3"
+  def no_trailing_new_line, do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.Failure do
+  def starting_line, do: __ENV__.line + 2
 
-defmodule ExUnit.DocTestTest.Invalid do
   @moduledoc """
 
       iex> 1 + * 1
@@ -112,10 +161,16 @@ defmodule ExUnit.DocTestTest.Invalid do
       iex> 1 + hd(List.flatten([1]))
       3
 
+      iex> a = "This is an egregiously long text string."
+      iex> b = ~r{an egregiously long}
+      iex> c = "a slightly shorter"
+      iex> String.replace(a, b, c)
+      "This is a much shorter text string."
+
       iex> :oops
-      #HashDict<[]>
+      #Inspect<[]>
 
-      iex> Hello.world
+      iex> Hello.world()
       :world
 
       iex> raise "oops"
@@ -125,7 +180,87 @@ defmodule ExUnit.DocTestTest.Invalid do
       ** (RuntimeError) hello
 
   """
-end |> write_beam
+
+  @doc """
+      # This will fail to inspect
+      iex> ExUnit.DocTestTest.Haiku.new(:this, :is, {:not, :a, :haiku})
+      #Haiku<:this_wont_be_asserted>
+  """
+  def raising_inspect, do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.Invalid do
+  def starting_line, do: __ENV__.line + 2
+
+  @doc """
+      iex> 1 + * 1
+      1
+  """
+  def a(), do: :ok
+
+  @doc """
+      iex> 1 + * 1
+      1
+  """
+  defmacro b(), do: :ok
+
+  @doc ~S'''
+  ```
+  iex> 1 + 2
+  3
+    ```
+  '''
+  def indented_too_much, do: :ok
+
+  @doc """
+      ```
+  iex> 1 + 2
+  3
+      ```
+  """
+  def dedented_past_fence, do: :ok
+
+  @doc """
+  iex> String.valid?("invalid utf8 \xFF")
+  false
+  """
+  def invalid_utf8, do: :ok
+
+  @doc """
+      iex> {:ok, :oops}
+      {:ok, #Inspect<[]>}
+  """
+  def misplaced_opaque_type, do: :ok
+
+  @typedoc """
+      iex> 1 + * 1
+      1
+  """
+  @type t :: any()
+
+  @doc """
+      iex> :foo
+      iex> :bar
+      1 + * 1
+  """
+  def result, do: :ok
+
+  @doc """
+      iex> 123 +
+      :mixed
+  """
+  def mixed, do: :ok
+
+  @doc """
+      iex> 1 + 2
+      3
+      iex> 123 +
+      :mixed
+  """
+  def invalid_second, do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
 
 defmodule ExUnit.DocTestTest.IndentationHeredocs do
   @doc ~S'''
@@ -141,7 +276,8 @@ defmodule ExUnit.DocTestTest.IndentationHeredocs do
 
   '''
   def heredocs, do: :ok
-end |> write_beam
+end
+|> ExUnit.BeamHelpers.write_beam()
 
 defmodule ExUnit.DocTestTest.IndentationMismatchedPrompt do
   @doc ~S'''
@@ -151,7 +287,8 @@ defmodule ExUnit.DocTestTest.IndentationMismatchedPrompt do
     3
   '''
   def mismatched, do: :ok
-end |> write_beam
+end
+|> ExUnit.BeamHelpers.write_beam()
 
 defmodule ExUnit.DocTestTest.IndentationTooMuch do
   @doc ~S'''
@@ -159,23 +296,289 @@ defmodule ExUnit.DocTestTest.IndentationTooMuch do
       3
   '''
   def too_much, do: :ok
-end |> write_beam
+end
+|> ExUnit.BeamHelpers.write_beam()
 
 defmodule ExUnit.DocTestTest.IndentationNotEnough do
   @doc ~S'''
       iex> 1 + 2
     3
   '''
-  def not_enough, do: :ok
-end |> write_beam
+  def test_fun, do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
 
-defmodule ExUnit.DocTestTest.Incomplete do
+defmodule ExUnit.DocTestTest.FencedNotEnough do
   @doc ~S'''
+    ```
+    iex> 1 + 2
+    3
+  ```
+  '''
+  def test_fun, do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.IndentationNotEnoughMultilineCode do
+  @doc ~S'''
+      iex> "hello
+      ...> world"
+      "hello
+  world"
+  '''
+  def test_fun, do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.FencedHeredocs do
+  @doc ~S'''
+  Receives a test and formats its failure.
+
+  ## Examples
+
+  ```
+  iex> 1 + 2
+  3
+  ```
+
+      ```
+      iex> 3 = 1 + 2
+      ```
+
+  ```
       iex> 1 + 2
+      3
+  ```
+  '''
+  def heredocs, do: :ok
+
+  @doc ~S'''
+  ```
+  iex> 1 + 2
+  3
+  '''
+  def incomplete, do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
 
+defmodule ExUnit.DocTestTest.FenceIncomplete do
+  @doc ~S'''
+  ```
+  iex> 1 + 2
+  3
   '''
-  def not_enough, do: :ok
-end |> write_beam
+  def test_fun, do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.Numbered do
+  @doc """
+  iex(1)> 1 +
+  ...(1)> 2
+  3
+  """
+  def test_fun(), do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.Host do
+  @doc """
+      iex(foo@bar)1> 1 +
+      ...(foo@bar)1> 2
+      3
+  """
+  def test_fun(), do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.Haiku do
+  @moduledoc """
+  This module describes the ancient Japanese poem form known as Haiku.
+
+  The Inspect protocol has been overridden for `%Haiku{}`
+  so that Haikus are shown in a pretty-printed fashion.
+
+  This module is part of the DocTest test suite,
+  to ensure that DocTest can handle opaque inspect types
+  which contain unicode and possibly consist of multiple lines.
+  """
+
+  defstruct [:first_phrase, :second_phrase, :third_phrase, :author]
+
+  @doc """
+  Creates a new Haiku.
+
+  Optionally pass in the `author` as fourth argument.
+
+  ## Examples:
+
+      # Simple Haiku, inspect output consists of multiple lines.
+      iex> ExUnit.DocTestTest.Haiku.new("Haikus are easy", "But sometimes they don't make sense", "Refrigerator")
+      #Haiku<
+        Haikus are easy
+        But sometimes they don't make sense
+        Refrigerator
+      >
+
+      # Haiku with Unicode characters (Japanese Kanji, em-dash).
+      iex> ExUnit.DocTestTest.Haiku.new("古池や", "蛙飛びこむ", "水の音", "Matsuo Basho")
+      #Haiku<
+        古池や
+        蛙飛びこむ
+        水の音
+        -- Matsuo Basho
+      >
+
+  """
+  def new(first, second, third, author \\ "") do
+    %__MODULE__{
+      first_phrase: first,
+      second_phrase: second,
+      third_phrase: third,
+      author: author
+    }
+  end
+
+  @doc """
+       iex> ExUnit.DocTestTest.Haiku.new("古池や", "蛙飛びこむ", "水の音", "Matsuo Basho")
+       #Haiku<
+         古池や
+         蛙飛びこむ
+         水の音
+         -- Matsuo Basho
+       >
+       """
+       |> String.replace("\n", "\r\n")
+  def crlf_test, do: :ok
+
+  defimpl Inspect do
+    def inspect(haiku, opts) do
+      indent = Keyword.get(opts.custom_options, :indent, 2)
+      spaces = String.duplicate(" ", indent)
+      author = if haiku.author == "", do: "", else: "\n#{spaces}-- #{haiku.author}"
+
+      """
+      #Haiku<
+      #{spaces}#{haiku.first_phrase}
+      #{spaces}#{haiku.second_phrase}
+      #{spaces}#{haiku.third_phrase}#{author}
+      >
+      """
+      |> String.trim_trailing("\n")
+    end
+  end
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.HaikuIndent4UsingInspectOpts do
+  @moduledoc """
+  This module is part of the DocTest test suite,
+  to ensure that DocTest respect the `:inspect_opts` options.
+  """
+
+  @doc """
+      # Simple Haiku, inspect output consists of multiple lines.
+      iex> ExUnit.DocTestTest.Haiku.new("Haikus are easy", "But sometimes they don't make sense", "Refrigerator")
+      #Haiku<
+          Haikus are easy
+          But sometimes they don't make sense
+          Refrigerator
+      >
+
+      # Haiku with Unicode characters (Japanese Kanji, em-dash).
+      iex> ExUnit.DocTestTest.Haiku.new("古池や", "蛙飛びこむ", "水の音", "Matsuo Basho")
+      #Haiku<
+          古池や
+          蛙飛びこむ
+          水の音
+          -- Matsuo Basho
+      >
+
+  """
+  def indent_4, do: :ok
+
+  @doc """
+       iex> ExUnit.DocTestTest.Haiku.new("古池や", "蛙飛びこむ", "水の音", "Matsuo Basho")
+       #Haiku<
+           古池や
+           蛙飛びこむ
+           水の音
+           -- Matsuo Basho
+       >
+       """
+       |> String.replace("\n", "\r\n")
+  def crlf_test, do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.PatternMatching do
+  def starting_line, do: __ENV__.line + 2
+
+  @moduledoc """
+  The doctests below test pattern matching failures.
+
+      iex> {1, 2}={1, 3}
+
+      iex> tuple = {1, 3}
+      iex> {1, 2} = tuple
+
+      iex> "Hello, world" = "Hello world"
+
+      iex> "Hello, " <> _ = "Hello world"
+
+      iex> [:a | _] = [:b, :a]
+
+      iex> atom = :a
+      iex> [^atom | _] = [:b, :a]
+
+      iex> %{b: _, d: :e} = %{a: :c, d: :e}
+
+      iex> %{year: 2001, day: 1} = ~D[2000-01-01]
+  """
+
+  @doc """
+      iex> adder = fn int -> int + 1 end
+      iex> num =
+      ...>   adder.(0)
+      iex> {^num, _, _} =
+      ...> # Comments can be here as well
+      ...>
+      ...>   {adder.(0), adder.(1), :three}
+
+      # false assertions do not accidentally raise
+      iex> false = (List.flatten([]) != [])
+  """
+  def passing(), do: :ok
+end
+|> ExUnit.BeamHelpers.write_beam()
+
+defmodule ExUnit.DocTestTest.Ellipsis do
+  @doc """
+      iex> ExUnit.DocTestTest.Ellipsis.same_line_err(self())
+      ** (ArgumentError) Unexpected: ...
+  """
+  def same_line_err(arg) do
+    raise ArgumentError, "Unexpected: #{inspect(arg)}"
+  end
+
+  @doc """
+      iex> ExUnit.DocTestTest.Ellipsis.multi_line_err(self())
+      ** (ArgumentError) Unexpected:
+      ...
+  """
+  def multi_line_err(arg) do
+    raise ArgumentError, "Unexpected:\n#{inspect(arg)}"
+  end
+
+  @doc """
+      iex> ExUnit.DocTestTest.Ellipsis.triple_dot_err(:foo)
+      ** (ArgumentError) :foo ...
+  """
+  def triple_dot_err(arg) do
+    raise ArgumentError, "#{inspect(arg)} ..."
+  end
+end
+|> ExUnit.BeamHelpers.write_beam()
 
 defmodule ExUnit.DocTestTest do
   use ExUnit.Case
@@ -185,115 +588,723 @@ defmodule ExUnit.DocTestTest do
   # doctest ExUnit.DocTest
 
   doctest ExUnit.DocTestTest.GoodModule, import: true
-  doctest ExUnit.DocTestTest.SomewhatGoodModuleWithOnly, only: [test_fun: 0], import: true
-  doctest ExUnit.DocTestTest.SomewhatGoodModuleWithExcept, except: [test_fun1: 0], import: true
+  doctest ExUnit.DocTestTest.NoTrailing
+
+  doctest ExUnit.DocTestTest.SomewhatGoodModuleWithOnly,
+    only: [:moduledoc, one: 0],
+    import: true
+
+  doctest ExUnit.DocTestTest.SomewhatGoodModuleWithExcept,
+    except: [:moduledoc, two: 0],
+    import: true
+
   doctest ExUnit.DocTestTest.NoImport
   doctest ExUnit.DocTestTest.IndentationHeredocs
+  doctest ExUnit.DocTestTest.FencedHeredocs
+  doctest ExUnit.DocTestTest.Haiku
+
+  doctest ExUnit.DocTestTest.HaikuIndent4UsingInspectOpts,
+    inspect_opts: [custom_options: [indent: 4]]
+
+  doctest ExUnit.DocTestTest.Ellipsis
 
   import ExUnit.CaptureIO
 
+  test "multiple functions filtered with :only" do
+    defmodule MultipleOnly do
+      use ExUnit.Case
+      doctest ExUnit.DocTestTest.SomewhatGoodModuleWithOnly, only: [one: 0, two: 0], import: true
+    end
+
+    assert capture_io(fn -> ExUnit.run() end) =~ "2 doctests, 1 failure"
+  end
+
+  test "empty :only" do
+    defmodule EmptyOnly do
+      use ExUnit.Case
+      doctest ExUnit.DocTestTest.SomewhatGoodModuleWithOnly, only: [], import: true
+    end
+
+    output = capture_io(fn -> ExUnit.run() end)
+
+    assert output =~ "0 failures"
+    refute output =~ "doctest"
+  end
+
+  test "allows users to tag doctests with configuration options" do
+    defmodule TaggedTests do
+      use ExUnit.Case
+      doctest ExUnit.DocTestTest.SomewhatGoodModuleWithOnly, tags: [skip: true], import: true
+    end
+
+    output = capture_io(fn -> ExUnit.run() end)
+
+    assert output =~ "0 failures"
+    assert output =~ "2 skipped"
+  end
+
   test "doctest failures" do
-    defmodule ActuallyCompiled do
+    # When adding or removing lines above this line, the tests below will
+    # fail because we are explicitly asserting some doctest lines from
+    # FailureCompiled in the format of "test/ex_unit/doc_test_test.exs:<LINE>".
+    defmodule FailureCompiled do
+      use ExUnit.Case
+      doctest ExUnit.DocTestTest.Failure
+    end
+
+    doctest_line = __ENV__.line - 3
+    starting_line = ExUnit.DocTestTest.Failure.starting_line() + 2
+
+    ExUnit.configure(seed: 0, colors: [enabled: false])
+    output = capture_io(fn -> ExUnit.run() end)
+    output = String.replace(output, [IO.ANSI.red(), IO.ANSI.reset()], "")
+    location = location(ExUnit.DocTestTest.Failure)
+
+    assert output =~ """
+             1) doctest module ExUnit.DocTestTest.Failure (1) (ExUnit.DocTestTest.FailureCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (SyntaxError) invalid syntax found on #{location}:#{starting_line}:6:
+                     error: syntax error before: '*'
+                     │
+                 #{starting_line} │  1 + * 1
+                     │      ^
+                     │
+                     └─ #{location}:#{starting_line}:6
+                doctest:
+                  iex> 1 + * 1
+                  1
+                stacktrace:
+                  #{stack(starting_line)}ExUnit.DocTestTest.Failure (module)
+           """
+
+    assert output =~ """
+             2) doctest module ExUnit.DocTestTest.Failure (2) (ExUnit.DocTestTest.FailureCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest failed
+                doctest:
+                  iex> 1 + hd(List.flatten([1]))
+                  3
+                code:  1 + hd(List.flatten([1])) === 3
+                left:  2
+                right: 3
+                stacktrace:
+                  #{stack(starting_line + 3)}ExUnit.DocTestTest.Failure (module)
+           """
+
+    assert output =~ """
+             3) doctest module ExUnit.DocTestTest.Failure (3) (ExUnit.DocTestTest.FailureCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest failed
+                doctest:
+                  iex> a = "This is an egregiously long text string."
+                  iex> b = ~r{an egregiously long}
+                  iex> c = "a slightly shorter"
+                  iex> String.replace(a, b, c)
+                  "This is a much shorter text string."
+                code:  String.replace(a, b, c) === "This is a much shorter text string."
+                left:  "This is a slightly shorter text string."
+                right: "This is a much shorter text string."
+                stacktrace:
+                  #{stack(starting_line + 6)}ExUnit.DocTestTest.Failure (module)
+           """
+
+    assert output =~ """
+             4) doctest module ExUnit.DocTestTest.Failure (4) (ExUnit.DocTestTest.FailureCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest failed
+                doctest:
+                  iex> :oops
+                  #Inspect<[]>
+                code:  inspect(:oops) === "#Inspect<[]>"
+                left:  ":oops"
+                right: "#Inspect<[]>"
+                stacktrace:
+                  #{stack(starting_line + 12)}ExUnit.DocTestTest.Failure (module)
+           """
+
+    assert output =~ """
+             5) doctest module ExUnit.DocTestTest.Failure (5) (ExUnit.DocTestTest.FailureCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                ** (UndefinedFunctionError) function Hello.world/0 is undefined (module Hello is not available). Make sure the module name is correct and has been specified in full (or that an alias has been defined)
+                stacktrace:
+                  Hello.world()
+                  (for doctest at) #{location}:#{starting_line + 15}: (test)
+           """
+
+    assert output =~ """
+             6) doctest module ExUnit.DocTestTest.Failure (6) (ExUnit.DocTestTest.FailureCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest failed: expected exception WhatIsThis but got RuntimeError with message "oops"
+                doctest:
+                  iex> raise "oops"
+                  ** (WhatIsThis) oops
+                stacktrace:
+                  #{stack(starting_line + 18)}ExUnit.DocTestTest.Failure (module)
+           """
+
+    assert output =~ """
+             7) doctest module ExUnit.DocTestTest.Failure (7) (ExUnit.DocTestTest.FailureCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest failed: wrong message for RuntimeError
+                expected:
+                  "hello"
+                actual:
+                  "oops"
+                doctest:
+                  iex> raise "oops"
+                  ** (RuntimeError) hello
+                stacktrace:
+                  #{stack(starting_line + 21)}ExUnit.DocTestTest.Failure (module)
+           """
+
+    assert output =~ "8) doctest ExUnit.DocTestTest.Failure.raising_inspect/0"
+    assert output =~ "iex> ExUnit.DocTestTest.Haiku.new(:this, :is, {:not, :a, :haiku})"
+
+    assert output =~
+             "#{stack(starting_line + 28)}ExUnit.DocTestTest.Failure (module)"
+
+    assert output =~ "8 doctests, 8 failures"
+  end
+
+  test "doctest invalid" do
+    # When adding or removing lines above this line, the tests below will
+    # fail because we are explicitly asserting some doctest lines from
+    # InvalidCompiled in the format of "test/ex_unit/doc_test_test.exs:<LINE>".
+    defmodule InvalidCompiled do
       use ExUnit.Case
       doctest ExUnit.DocTestTest.Invalid
     end
 
-    ExUnit.configure(seed: 0)
-    output = capture_io(fn -> ExUnit.run end)
+    doctest_line = __ENV__.line - 3
+    starting_line = ExUnit.DocTestTest.Invalid.starting_line() + 1
+    location = location(ExUnit.DocTestTest.Invalid)
+
+    ExUnit.configure(seed: 0, colors: [enabled: false])
+    output = capture_io(fn -> ExUnit.run() end)
+    output = String.replace(output, [IO.ANSI.red(), IO.ANSI.reset()], "")
+
+    line = starting_line
 
     assert output =~ """
-      1) test moduledoc at ExUnit.DocTestTest.Invalid (1) (ExUnit.DocTestTest.ActuallyCompiled)
-         test/ex_unit/doc_test_test.exs:198
-         Doctest did not compile, got: (SyntaxError) test/ex_unit/doc_test_test.exs:106: syntax error before: '*'
-         code: 1 + * 1
-         stacktrace:
-           test/ex_unit/doc_test_test.exs:106: ExUnit.DocTestTest.Invalid (module)
-    """
+             1) doctest ExUnit.DocTestTest.Invalid.a/0 (1) (ExUnit.DocTestTest.InvalidCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (SyntaxError) invalid syntax found on #{location}:#{line}:6:
+                     error: syntax error before: '*'
+                     │
+                 #{line} │  1 + * 1
+                     │      ^
+                     │
+                     └─ #{location}:#{line}:6
+                doctest:
+                  iex> 1 + * 1
+                  1
+                stacktrace:
+                  #{stack(line)}ExUnit.DocTestTest.Invalid (module)
+           """
+
+    line = starting_line + 6
 
     assert output =~ """
-      2) test moduledoc at ExUnit.DocTestTest.Invalid (2) (ExUnit.DocTestTest.ActuallyCompiled)
-         test/ex_unit/doc_test_test.exs:198
-         Doctest failed
-         code: 1 + hd(List.flatten([1])) === 3
-         lhs:  2
-         stacktrace:
-           test/ex_unit/doc_test_test.exs:106: ExUnit.DocTestTest.Invalid (module)
-    """
+             2) doctest ExUnit.DocTestTest.Invalid.b/0 (2) (ExUnit.DocTestTest.InvalidCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (SyntaxError) invalid syntax found on #{location}:#{line}:6:
+                     error: syntax error before: '*'
+                     │
+                 #{line} │  1 + * 1
+                     │      ^
+                     │
+                     └─ #{location}:#{line}:6
+                doctest:
+                  iex> 1 + * 1
+                  1
+                stacktrace:
+                  #{stack(line)}ExUnit.DocTestTest.Invalid (module)
+           """
+
+    line = starting_line + 15
 
     assert output =~ """
-      3) test moduledoc at ExUnit.DocTestTest.Invalid (3) (ExUnit.DocTestTest.ActuallyCompiled)
-         test/ex_unit/doc_test_test.exs:198
-         Doctest failed
-         code: inspect(:oops) === "#HashDict<[]>"
-         lhs:  ":oops"
-         stacktrace:
-           test/ex_unit/doc_test_test.exs:106: ExUnit.DocTestTest.Invalid (module)
-    """
+             3) doctest ExUnit.DocTestTest.Invalid.indented_too_much/0 (3) (ExUnit.DocTestTest.InvalidCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (SyntaxError) invalid syntax found on #{location}:#{line}:3:
+                     error: unexpected token: "`" (column 3, code point U+0060)
+                     │
+                 #{line} │   ```
+                     │   ^
+                     │
+                     └─ #{location}:#{line}:3
+                doctest:
+                  iex> 1 + 2
+                  3
+                    ```
+                stacktrace:
+                  #{stack(line - 1)}ExUnit.DocTestTest.Invalid (module)
+           """
+
+    line = starting_line + 23
 
     assert output =~ """
-      4) test moduledoc at ExUnit.DocTestTest.Invalid (4) (ExUnit.DocTestTest.ActuallyCompiled)
-         test/ex_unit/doc_test_test.exs:198
-         Doctest failed: got UndefinedFunctionError with message undefined function: Hello.world/0
-         code:  Hello.world
-         stacktrace:
-           test/ex_unit/doc_test_test.exs:106: ExUnit.DocTestTest.Invalid (module)
-    """
+             4) doctest ExUnit.DocTestTest.Invalid.dedented_past_fence/0 (4) (ExUnit.DocTestTest.InvalidCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (SyntaxError) invalid syntax found on #{location}:#{line}:5:
+                     error: unexpected token: "`" (column 5, code point U+0060)
+                     │
+                 #{line} │     ```
+                     │     ^
+                     │
+                     └─ #{location}:#{line}:5
+                doctest:
+                  iex> 1 + 2
+                  3
+                      ```
+                stacktrace:
+                  #{stack(line - 1)}ExUnit.DocTestTest.Invalid (module)
+           """
+
+    line = starting_line + 28
+
+    assert output =~ """
+             5) doctest ExUnit.DocTestTest.Invalid.invalid_utf8/0 (5) (ExUnit.DocTestTest.InvalidCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (UnicodeConversionError) invalid encoding starting at <<255, 34, 41>>
+                stacktrace:
+                  #{stack(line)}ExUnit.DocTestTest.Invalid (module)
+           """
+
+    line = starting_line + 35
 
     assert output =~ """
-      5) test moduledoc at ExUnit.DocTestTest.Invalid (5) (ExUnit.DocTestTest.ActuallyCompiled)
-         test/ex_unit/doc_test_test.exs:198
-         Doctest failed: expected exception WhatIsThis with message "oops" but got RuntimeError with message "oops"
-         code: raise "oops"
-         stacktrace:
-           test/ex_unit/doc_test_test.exs:106: ExUnit.DocTestTest.Invalid (module)
-    """
+           6) doctest ExUnit.DocTestTest.Invalid.misplaced_opaque_type/0 (6) (ExUnit.DocTestTest.InvalidCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (TokenMissingError) token missing on #{location}:#{line}:20:
+                     error: missing terminator: }
+                     │
+                 #{line} │ {:ok, #Inspect<[]>}
+                     │ │                  └ missing closing delimiter (expected "}")
+                     │ └ unclosed delimiter
+                     │
+                     └─ #{location}:#{line}:20
+                If you are planning to assert on the result of an iex> expression which contains a value inspected as #Name<...>, please make sure the inspected value is placed at the beginning of the expression, otherwise Elixir will treat it as a comment due to the leading sign #.
+                doctest:
+                  iex> {:ok, :oops}
+                  {:ok, #Inspect<[]>}
+                stacktrace:
+                  #{stack(line)}ExUnit.DocTestTest.Invalid (module)
+           """
+
+    line = starting_line + 40
+
+    assert output =~ """
+             7) doctest ExUnit.DocTestTest.Invalid.t/0 (7) (ExUnit.DocTestTest.InvalidCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (SyntaxError) invalid syntax found on #{location}:#{line}:6:
+                     error: syntax error before: '*'
+                     │
+                 #{line} │  1 + * 1
+                     │      ^
+                     │
+                     └─ #{location}:#{line}:6
+                doctest:
+                  iex> 1 + * 1
+                  1
+                stacktrace:
+                  #{stack(line)}ExUnit.DocTestTest.Invalid (module)
+           """
+
+    line = starting_line + 48
+
+    assert output =~ """
+             8) doctest ExUnit.DocTestTest.Invalid.result/0 (8) (ExUnit.DocTestTest.InvalidCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (SyntaxError) invalid syntax found on #{location}:#{line}:5:
+                     error: syntax error before: '*'
+                     │
+                 #{line} │ 1 + * 1
+                     │     ^
+                     │
+                     └─ #{location}:#{line}:5
+                doctest:
+                  iex> :foo
+                  iex> :bar
+                  1 + * 1
+                stacktrace:
+                  #{stack(line)}ExUnit.DocTestTest.Invalid (module)
+           """
+
+    line = starting_line + 53
+
+    assert output =~ """
+             9) doctest ExUnit.DocTestTest.Invalid.mixed/0 (9) (ExUnit.DocTestTest.InvalidCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (TokenMissingError) token missing on #{location}:#{line}:6:
+                     error: syntax error: expression is incomplete
+                     │
+                 #{line} │  123 +
+                     │      ^
+                     │
+                     └─ #{location}:#{line}:6
+                doctest:
+                  iex> 123 +
+                  :mixed
+                stacktrace:
+                  #{stack(line)}ExUnit.DocTestTest.Invalid (module)
+           """
+
+    line = starting_line + 61
 
     assert output =~ """
-      6) test moduledoc at ExUnit.DocTestTest.Invalid (6) (ExUnit.DocTestTest.ActuallyCompiled)
-         test/ex_unit/doc_test_test.exs:198
-         Doctest failed: expected exception RuntimeError with message "hello" but got RuntimeError with message "oops"
-         code: raise "oops"
-         stacktrace:
-           test/ex_unit/doc_test_test.exs:106: ExUnit.DocTestTest.Invalid (module)
-    """
+            10) doctest ExUnit.DocTestTest.Invalid.invalid_second/0 (10) (ExUnit.DocTestTest.InvalidCompiled)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                Doctest did not compile, got: (TokenMissingError) token missing on #{location}:#{line}:6:
+                     error: syntax error: expression is incomplete
+                     │
+                 #{line} │  123 +
+                     │      ^
+                     │
+                     └─ #{location}:#{line}:6
+                doctest:
+                  iex> 123 +
+                  :mixed
+                stacktrace:
+                  #{stack(line)}ExUnit.DocTestTest.Invalid (module)
+           """
+
+    assert output =~ "10 doctests, 10 failures"
+  end
+
+  test "pattern matching assertions in doctests" do
+    defmodule PatternMatchingRunner do
+      use ExUnit.Case
+      doctest ExUnit.DocTestTest.PatternMatching, import: true
+    end
+
+    doctest_line = __ENV__.line - 3
+    starting_line = ExUnit.DocTestTest.PatternMatching.starting_line()
+    location = location(ExUnit.DocTestTest.PatternMatching)
+
+    ExUnit.configure(seed: 0, colors: [enabled: false])
+    output = capture_io(fn -> ExUnit.run() end)
+
+    assert output =~ """
+             1) doctest module ExUnit.DocTestTest.PatternMatching (1) (ExUnit.DocTestTest.PatternMatchingRunner)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                match (=) failed
+                code:  {1, 2} = {1, 3}
+                left:  {1, 2}
+                right: {1, 3}
+                stacktrace:
+                  (for doctest at) #{location}:#{starting_line + 3}: (test)
+           """
+
+    assert output =~ """
+             2) doctest module ExUnit.DocTestTest.PatternMatching (2) (ExUnit.DocTestTest.PatternMatchingRunner)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                match (=) failed
+                code:  {1, 2} = tuple
+                left:  {1, 2}
+                right: {1, 3}
+                stacktrace:
+                  (for doctest at) #{location}:#{starting_line + 6}: (test)
+           """
+
+    assert output =~ """
+             3) doctest module ExUnit.DocTestTest.PatternMatching (3) (ExUnit.DocTestTest.PatternMatchingRunner)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                match (=) failed
+                code:  "Hello, world" = "Hello world"
+                left:  "Hello, world"
+                right: "Hello world"
+                stacktrace:
+                  (for doctest at) #{location}:#{starting_line + 8}: (test)
+           """
+
+    assert output =~ """
+             4) doctest module ExUnit.DocTestTest.PatternMatching (4) (ExUnit.DocTestTest.PatternMatchingRunner)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                match (=) failed
+                code:  "Hello, " <> _ = "Hello world"
+                left:  "Hello, " <> _
+                right: "Hello world"
+                stacktrace:
+                  (for doctest at) #{location}:#{starting_line + 10}: (test)
+           """
+
+    assert output =~ """
+             5) doctest module ExUnit.DocTestTest.PatternMatching (5) (ExUnit.DocTestTest.PatternMatchingRunner)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                match (=) failed
+                code:  [:a | _] = [:b, :a]
+                left:  [:a | _]
+                right: [:b, :a]
+                stacktrace:
+                  (for doctest at) #{location}:#{starting_line + 12}: (test)
+           """
+
+    assert output =~ """
+             6) doctest module ExUnit.DocTestTest.PatternMatching (6) (ExUnit.DocTestTest.PatternMatchingRunner)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                match (=) failed
+                The following variables were pinned:
+                  atom = :a
+                code:  [^atom | _] = [:b, :a]
+                left:  [^atom | _]
+                right: [:b, :a]
+                stacktrace:
+                  (for doctest at) #{location}:#{starting_line + 15}: (test)
+           """
+
+    assert output =~ """
+             7) doctest module ExUnit.DocTestTest.PatternMatching (7) (ExUnit.DocTestTest.PatternMatchingRunner)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                match (=) failed
+                code:  %{b: _, d: :e} = %{a: :c, d: :e}
+                left:  %{b: _, d: :e}
+                right: %{a: :c, d: :e}
+                stacktrace:
+                  (for doctest at) #{location}:#{starting_line + 17}: (test)
+           """
+
+    assert output =~ """
+             8) doctest module ExUnit.DocTestTest.PatternMatching (8) (ExUnit.DocTestTest.PatternMatchingRunner)
+                test/ex_unit/doc_test_test.exs:#{doctest_line}
+                match (=) failed
+                code:  %{year: 2001, day: 1} = ~D[2000-01-01]
+                left:  %{year: 2001, day: 1}
+                right: ~D[2000-01-01]
+                stacktrace:
+                  (for doctest at) #{location}:#{starting_line + 19}: (test)
+           """
+
+    assert output =~ "10 doctests, 8 failures"
   end
 
-  test "multiple exceptions in one test case is not supported" do
-    assert_raise ExUnit.DocTest.Error, ~r"multiple exceptions in one doctest case are not supported", fn ->
-      defmodule NeverCompiled do
-        import ExUnit.DocTest
-        doctest ExUnit.DocTestTest.MultipleExceptions
+  test "IEx prefix contains a number" do
+    defmodule NumberedUsage do
+      use ExUnit.Case
+      doctest ExUnit.DocTestTest.Numbered
+    end
+
+    assert capture_io(fn -> ExUnit.run() end) =~ "1 doctest, 0 failures"
+  end
+
+  test "IEx prompt contains host" do
+    message =
+      ~s[unknown IEx prompt: "iex(foo@bar)1> 1 +".\nAccepted formats are: iex>, iex(1)>, ...>, ...(1)>]
+
+    assert_raise ExUnit.DocTest.Error, ~r/#{Regex.escape(message)}/, fn ->
+      defmodule HostUsage do
+        use ExUnit.Case
+        doctest ExUnit.DocTestTest.Host
       end
     end
   end
 
-  test "fails in indentation mismatch" do
-    assert_raise ExUnit.DocTest.Error, ~r/indentation level mismatch: "   iex> bar = 2", should have been 2 spaces/, fn ->
-      defmodule NeverCompiled do
-        import ExUnit.DocTest
-        doctest ExUnit.DocTestTest.IndentationMismatchedPrompt
+  test "doctests built-in tags" do
+    alias ExUnit.DocTestTest.{NoImport, NoTrailing}
+
+    defmodule DoctestTags do
+      use ExUnit.Case, register: false
+      doctest NoImport
+      doctest NoTrailing
+    end
+
+    assert %ExUnit.TestModule{tests: [test1, test2, test3]} = DoctestTags.__ex_unit__()
+
+    assert %{
+             test_type: :doctest,
+             doctest: NoImport,
+             doctest_line: 137,
+             doctest_data: %{end_line: 138}
+           } = test1.tags
+
+    assert %{
+             test_type: :doctest,
+             doctest: NoImport,
+             doctest_line: 140,
+             doctest_data: %{end_line: 141}
+           } = test2.tags
+
+    assert %{
+             test_type: :doctest,
+             doctest: NoTrailing,
+             doctest_line: 149,
+             doctest_data: %{end_line: 149}
+           } = test3.tags
+  end
+
+  describe "errors" do
+    test "multiple exceptions in one test case is not supported" do
+      message = ~r"multiple exceptions in the same doctest example are not supported"
+
+      assert_raise ExUnit.DocTest.Error, message, fn ->
+        defmodule NeverCompiled do
+          import ExUnit.DocTest
+          doctest ExUnit.DocTestTest.MultipleExceptions
+        end
       end
     end
 
-    assert_raise ExUnit.DocTest.Error, ~r/indentation level mismatch: "    3", should have been 2 spaces/, fn ->
-      defmodule NeverCompiled do
-        import ExUnit.DocTest
-        doctest ExUnit.DocTestTest.IndentationTooMuch
+    test "fails on invalid module" do
+      assert capture_io(:stderr, fn ->
+               assert_raise CompileError, fn ->
+                 defmodule NeverCompiled do
+                   import ExUnit.DocTest
+                   doctest ExUnit.DocTestTest.Unknown
+                 end
+               end
+             end) =~ "module ExUnit.DocTestTest.Unknown is not loaded and could not be found"
+    end
+
+    test "fails when testing functions are not found" do
+      message = """
+      #{stack(0)}undefined or private functions given to doctest:
+
+          ExUnit.DocTestTest.SomewhatGoodModuleWithOnly.three/0
+          ExUnit.DocTestTest.SomewhatGoodModuleWithOnly.four/1
+
+      """
+
+      assert_raise ExUnit.DocTest.Error, message, fn ->
+        defmodule NeverCompiled do
+          import ExUnit.DocTest
+
+          doctest ExUnit.DocTestTest.SomewhatGoodModuleWithOnly,
+            only: [three: 0, four: 1],
+            import: true
+        end
       end
     end
 
-    assert_raise ExUnit.DocTest.Error, ~r/indentation level mismatch: \"  3\", should have been 4 spaces/, fn ->
-      defmodule NeverCompiled do
-        import ExUnit.DocTest
-        doctest ExUnit.DocTestTest.IndentationNotEnough
+    test "fails when there are no docs" do
+      message = ~r"could not retrieve the documentation for module ExUnit\.DocTestTest"
+
+      assert_raise ExUnit.DocTest.Error, message, fn ->
+        defmodule NeverCompiled do
+          import ExUnit.DocTest
+          doctest ExUnit.DocTestTest
+        end
+      end
+    end
+
+    test "fails in indentation mismatch" do
+      message =
+        ~r[indentation level mismatch on doctest line: \"   iex> bar = 2\".*is exactly 2 spaces]s
+
+      assert_raise ExUnit.DocTest.Error, message, fn ->
+        defmodule NeverCompiled do
+          import ExUnit.DocTest
+          doctest ExUnit.DocTestTest.IndentationMismatchedPrompt
+        end
+      end
+
+      message = ~r[indentation level mismatch on doctest line: \"    3\".*is exactly 2 spaces]s
+
+      assert_raise ExUnit.DocTest.Error, message, fn ->
+        defmodule NeverCompiled do
+          import ExUnit.DocTest
+          doctest ExUnit.DocTestTest.IndentationTooMuch
+        end
+      end
+
+      message = ~r[indentation level mismatch on doctest line: \"  3\".*is exactly 4 spaces]s
+
+      assert_raise ExUnit.DocTest.Error, message, fn ->
+        defmodule NeverCompiled do
+          import ExUnit.DocTest
+          doctest ExUnit.DocTestTest.IndentationNotEnough
+        end
+      end
+
+      message = ~r[indentation level mismatch on doctest line: \"```\".*is exactly 2 spaces]s
+
+      assert_raise ExUnit.DocTest.Error, message, fn ->
+        defmodule NeverCompiled do
+          import ExUnit.DocTest
+          doctest ExUnit.DocTestTest.FencedNotEnough
+        end
+      end
+
+      message =
+        ~r[indentation level mismatch on doctest line: \"world\\\"\".*is exactly 4 spaces]s
+
+      assert_raise ExUnit.DocTest.Error, message, fn ->
+        defmodule NeverCompiled do
+          import ExUnit.DocTest
+          doctest ExUnit.DocTestTest.IndentationNotEnoughMultilineCode
+        end
       end
     end
 
-    assert_raise ExUnit.DocTest.Error, ~r/expected non-blank line to follow iex> prompt/, fn ->
-      defmodule NeverCompiled do
-        import ExUnit.DocTest
-        doctest ExUnit.DocTestTest.Incomplete
+    test "fails on invalid use" do
+      assert_raise RuntimeError, ~r"cannot define doctest", fn ->
+        defmodule FunctionClashFail do
+          import ExUnit.DocTest
+          doctest ExUnit.DocTestTest.Failure
+        end
       end
     end
   end
+
+  describe "doctest_file" do
+    test "passing" do
+      defmodule FilePassing do
+        use ExUnit.Case
+        doctest_file(Path.expand("../fixtures/passing.md", __DIR__))
+      end
+
+      output = capture_io(fn -> ExUnit.run() end)
+      assert output =~ "2 doctests, 0 failures"
+    end
+
+    test "failing" do
+      defmodule FileFailing do
+        use ExUnit.Case
+        doctest_file(Path.expand("../fixtures/failing.md", __DIR__))
+      end
+
+      doctest_line = __ENV__.line - 3
+      ExUnit.configure(seed: 0, colors: [enabled: false])
+      output = capture_io(fn -> ExUnit.run() end)
+
+      assert output =~ """
+               1) doctest test/fixtures/failing.md (1) (ExUnit.DocTestTest.FileFailing)
+                  test/ex_unit/doc_test_test.exs:#{doctest_line}
+                  Doctest failed
+                  doctest:
+                    iex> 1 + 2
+                    4
+                  code:  1 + 2 === 4
+                  left:  3
+                  right: 4
+                  stacktrace:
+                    test/fixtures/failing.md:4: ExUnit.DocTestTest.FileFailing (module)
+             """
+    end
+  end
+
+  test "doctest direct invocation" do
+    defmodule Direct do
+      use ExUnit.Case, register: false
+      doctest ExUnit.DocTestTest.GoodModule, import: true
+    end
+
+    [head | _] = Direct.__ex_unit__().tests
+    assert apply(Direct, head.name, [%{}]) == {:ok, 2}
+  end
+
+  defp location(module) do
+    if __MODULE__.module_info(:compile)[:source] do
+      "test/ex_unit/doc_test_test.exs"
+    else
+      inspect(module)
+    end
+  end
+
+  defp stack(line) do
+    if __MODULE__.module_info(:compile)[:source] do
+      [Exception.format_file_line("test/ex_unit/doc_test_test.exs", line), ?\s]
+    else
+      ""
+    end
+  end
 end
diff --git a/lib/ex_unit/test/ex_unit/failures_manifest_test.exs b/lib/ex_unit/test/ex_unit/failures_manifest_test.exs
new file mode 100644
index 00000000000..06808d2f77c
--- /dev/null
+++ b/lib/ex_unit/test/ex_unit/failures_manifest_test.exs
@@ -0,0 +1,218 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule ExUnit.FailuresManifestTest do
+  use ExUnit.Case, async: false
+
+  import ExUnit.FailuresManifest
+
+  @passed nil
+  @skipped {:skipped, "reason"}
+  @excluded {:excluded, "reason"}
+  @failed {:failed, []}
+  @invalid {:invalid, %ExUnit.TestModule{}}
+  @manifest_path "example.manifest"
+
+  describe "info/1" do
+    @tag :tmp_dir
+    test "returns the sets of files and test IDs with failures", context do
+      manifest =
+        new()
+        |> put_test(failed_1 = new_test(@failed, context))
+        |> put_test(failed_2 = new_test(@failed, context))
+        |> put_test(new_test(@passed, context))
+        |> put_test(invalid_1 = new_test(@invalid, context))
+
+      File.cd!(context.tmp_dir, fn ->
+        write!(manifest, @manifest_path)
+
+        assert info(@manifest_path) ==
+                 {MapSet.new([context.file]),
+                  MapSet.new([test_id(failed_1), test_id(failed_2), test_id(invalid_1)])}
+      end)
+    end
+
+    @tag :tmp_dir
+    test "returns all when the whole suite should be considered as failed", context do
+      File.cd!(context.tmp_dir, fn ->
+        fail_all!(@manifest_path)
+        assert info(@manifest_path) == :all
+      end)
+    end
+
+    @tag :tmp_dir
+    test "returns no information when loading a file that does not exit", context do
+      path = Path.join(context.tmp_dir, "missing.manifest")
+      refute File.exists?(path)
+      assert info(path) == {MapSet.new(), MapSet.new()}
+    end
+  end
+
+  describe "put_test/2 when the test is not already in the manifest" do
+    test "ignores passed tests since we only care to store failures" do
+      assert put_test(new(), new_test(@passed)) == new()
+    end
+
+    test "stores failed tests" do
+      test = new_test(@failed)
+      assert put_test(new(), test) == %{test_id(test) => file(test)}
+    end
+
+    test "stores invalid tests" do
+      test = new_test(@invalid)
+      assert put_test(new(), test) == %{test_id(test) => file(test)}
+    end
+
+    test "ignores skipped tests since we know nothing about their pass/fail status" do
+      assert put_test(new(), new_test(@skipped)) == new()
+    end
+
+    test "ignores excluded tests since we know nothing about their pass/fail status" do
+      assert put_test(new(), new_test(@excluded)) == new()
+    end
+  end
+
+  describe "put_test/2 when the test is already in the manifest" do
+    setup do
+      failed_test = new_test(@failed)
+      manifest = put_test(new(), failed_test)
+      {:ok, %{failed_test: failed_test, manifest: manifest}}
+    end
+
+    test "removes a newly passed test, since it is no longer failing", context do
+      test = %{context.failed_test | state: @passed}
+      assert put_test(context.manifest, test) == new()
+    end
+
+    test "stores failed tests, updating the stored file value", context do
+      test = %{context.failed_test | tags: %{file: "some-other-file"}}
+      assert put_test(context.manifest, test) == %{test_id(test) => file(test)}
+    end
+
+    test "stores invalid tests, updating the stored file value", context do
+      test = %{context.failed_test | tags: %{file: "some-other-file"}, state: @invalid}
+      assert put_test(context.manifest, test) == %{test_id(test) => file(test)}
+    end
+
+    test "ignores skipped tests since we know nothing about their pass/fail status", context do
+      test = %{context.failed_test | state: @skipped}
+      assert put_test(context.manifest, test) == context.manifest
+    end
+
+    test "ignores excluded tests since we know nothing about their pass/fail status", context do
+      test = %{context.failed_test | state: @excluded}
+      assert put_test(context.manifest, test) == context.manifest
+    end
+  end
+
+  describe "write!/2" do
+    @tag :tmp_dir
+    test "stores a manifest that can later be read with read/1", context do
+      manifest = non_blank_manifest(context)
+
+      File.cd!(context.tmp_dir, fn ->
+        assert write!(manifest, @manifest_path) == :ok
+        assert read(@manifest_path) == manifest
+      end)
+    end
+
+    @tag :tmp_dir
+    test "prunes tests from files that no longer exist", context do
+      test = new_test(@failed, %{context | file: "missing_file.exs"})
+
+      File.cd!(context.tmp_dir, fn ->
+        new()
+        |> put_test(test)
+        |> write!(@manifest_path)
+
+        assert read(@manifest_path) == new()
+      end)
+    end
+
+    @tag :tmp_dir
+    test "keeps tests from modules that were not loaded", context do
+      test = new_test(@failed, %{context | module: SomeUnloadedModule})
+      manifest = new() |> put_test(test)
+
+      File.cd!(context.tmp_dir, fn ->
+        write!(manifest, @manifest_path)
+        assert read(@manifest_path) == manifest
+      end)
+    end
+
+    @tag :tmp_dir
+    test "prunes tests defined in a function that no longer exists", context do
+      test = new_test(@failed, %{context | test: :not_a_function_anymore})
+
+      File.cd!(context.tmp_dir, fn ->
+        new()
+        |> put_test(test)
+        |> write!(@manifest_path)
+
+        assert read(@manifest_path) == new()
+      end)
+    end
+  end
+
+  describe "read/1" do
+    @tag :tmp_dir
+    test "returns a blank manifest when loading a file that does not exit", context do
+      path = Path.join(context.tmp_dir, "missing.manifest")
+      refute File.exists?(path)
+      assert read(path) == new()
+    end
+
+    @tag :tmp_dir
+    test "returns a blank manifest when the file is corrupted", context do
+      manifest = non_blank_manifest(context)
+
+      File.cd!(context.tmp_dir, fn ->
+        assert write!(manifest, @manifest_path) == :ok
+        corrupted = "corrupted" <> File.read!(@manifest_path)
+        File.write!(@manifest_path, corrupted)
+        assert read(@manifest_path) == new()
+      end)
+    end
+
+    @tag :tmp_dir
+    test "returns a blank manifest when the file was saved at a prior version", context do
+      manifest = non_blank_manifest(context)
+
+      File.cd!(context.tmp_dir, fn ->
+        assert write!(manifest, @manifest_path) == :ok
+        assert {vsn, ^manifest} = @manifest_path |> File.read!() |> :erlang.binary_to_term()
+        File.write!(@manifest_path, :erlang.term_to_binary({vsn + 1, manifest}))
+        assert read(@manifest_path) == new()
+      end)
+    end
+  end
+
+  defp new_test(state, file \\ "file")
+
+  defp new_test(state, %{} = context) do
+    %ExUnit.Test{
+      state: state,
+      module: context.module,
+      name: context.test,
+      tags: %{file: context.file}
+    }
+  end
+
+  defp new_test(state, file) do
+    %ExUnit.Test{
+      state: state,
+      module: SomeMod,
+      name: :"test #{System.unique_integer()}",
+      tags: %{file: file}
+    }
+  end
+
+  defp test_id(test), do: {test.module, test.name}
+
+  defp file(test), do: test.tags.file
+
+  defp non_blank_manifest(context), do: new() |> put_test(new_test(@failed, context))
+end
diff --git a/lib/ex_unit/test/ex_unit/filters_test.exs b/lib/ex_unit/test/ex_unit/filters_test.exs
index f81fe3af14d..6dd01f0d3d0 100644
--- a/lib/ex_unit/test/ex_unit/filters_test.exs
+++ b/lib/ex_unit/test/ex_unit/filters_test.exs
@@ -1,75 +1,328 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule ExUnit.FiltersTest do
   use ExUnit.Case, async: true
 
   doctest ExUnit.Filters
 
+  describe "filter precedence" do
+    setup do
+      [
+        one: %{
+          one: true,
+          numeric: true,
+          test: :"test one",
+          test_type: :test
+        },
+        two: %{
+          skip: true,
+          numeric: true,
+          test: :"test two",
+          test_type: :test,
+          two: true
+        }
+      ]
+    end
+
+    test "no filters", tags do
+      assert ExUnit.Filters.eval([], [], tags.one, []) == :ok
+      assert ExUnit.Filters.eval([], [], tags.two, []) == {:skipped, "due to skip tag"}
+    end
+
+    test "exclude tests", tags do
+      assert ExUnit.Filters.eval([], [:two], tags.one, []) == :ok
+      assert ExUnit.Filters.eval([], [:test], tags.one, []) == {:excluded, "due to test filter"}
+      assert ExUnit.Filters.eval([], [:test], tags.two, []) == {:excluded, "due to test filter"}
+
+      assert ExUnit.Filters.eval([], [:numeric], tags.one, []) ==
+               {:excluded, "due to numeric filter"}
+
+      assert ExUnit.Filters.eval([], [:unknown], tags.one, []) == :ok
+      assert ExUnit.Filters.eval([], [:unknown], tags.two, []) == {:skipped, "due to skip tag"}
+    end
+
+    test "explicitly exclude a test with the :skip tag", tags do
+      # --exclude two
+      assert ExUnit.Filters.eval([], [:two], tags.two, []) == {:excluded, "due to two filter"}
+
+      assert ExUnit.Filters.eval([], [:two, :test], tags.two, []) ==
+               {:excluded, "due to two filter"}
+    end
+
+    test "include tests", tags do
+      # use --include, exclude is missing
+      assert ExUnit.Filters.eval([:two], [], tags.one, []) == :ok
+      assert ExUnit.Filters.eval([:unknown], [], tags.one, []) == :ok
+
+      # --only
+      assert ExUnit.Filters.eval([:one], [:test], tags.one, []) == :ok
+
+      assert ExUnit.Filters.eval([:two], [:test], tags.one, []) ==
+               {:excluded, "due to test filter"}
+
+      assert ExUnit.Filters.eval([:unknown], [:test], tags.one, []) ==
+               {:excluded, "due to test filter"}
+
+      assert ExUnit.Filters.eval([:unknown], [:test], tags.two, []) ==
+               {:excluded, "due to test filter"}
+    end
+
+    test "explicitly include a test with the :skip tag", tags do
+      # --include two, exclude is missing
+      assert ExUnit.Filters.eval([:two], [], tags.two, []) == {:skipped, "due to skip tag"}
+
+      # --only two
+      assert ExUnit.Filters.eval([:two], [:test], tags.two, []) == {:skipped, "due to skip tag"}
+    end
+
+    test "exception to the rule: include tests with the :skip tag", tags do
+      # --include skip, exclude is missing
+      assert ExUnit.Filters.eval([:skip], [], tags.two, []) == :ok
+      assert ExUnit.Filters.eval([:skip], [], %{tags.two | skip: "skip me please"}, []) == :ok
+      assert ExUnit.Filters.eval([skip: ~r/alpha/], [], %{tags.two | skip: "alpha"}, []) == :ok
+
+      assert ExUnit.Filters.eval([skip: ~r/alpha/], [], %{tags.two | skip: "beta"}, []) ==
+               {:skipped, "beta"}
+
+      # --only skip
+      assert ExUnit.Filters.eval([:skip], [:test], tags.two, []) == :ok
+
+      assert ExUnit.Filters.eval([:skip], [:test], %{tags.two | skip: "skip me please"}, []) ==
+               :ok
+
+      assert ExUnit.Filters.eval([skip: ~r/alpha/], [:test], %{tags.two | skip: "alpha"}, []) ==
+               :ok
+
+      assert ExUnit.Filters.eval([skip: ~r/alpha/], [:test], %{tags.two | skip: "beta"}, []) ==
+               {:excluded, "due to test filter"}
+    end
+  end
+
   test "evaluating filters" do
-    assert ExUnit.Filters.eval([], [:os], %{}, [])                == :ok
-    assert ExUnit.Filters.eval([], [os: :win], %{os: :unix}, [])  == :ok
-    assert ExUnit.Filters.eval([], [:os], %{os: :unix}, [])       == {:error, :os}
-    assert ExUnit.Filters.eval([], [os: :unix], %{os: :unix}, []) == {:error, :os}
-
-    assert ExUnit.Filters.eval([os: :win], [], %{}, [])            == :ok
-    assert ExUnit.Filters.eval([os: :win], [], %{os: :unix}, [])   == :ok
-    assert ExUnit.Filters.eval([os: :win], [:os], %{}, [])         == :ok
+    assert ExUnit.Filters.eval([], [:os], %{}, []) == :ok
+    assert ExUnit.Filters.eval([], [os: :win], %{os: :unix}, []) == :ok
+    assert ExUnit.Filters.eval([], [:os], %{os: :unix}, []) == {:excluded, "due to os filter"}
+
+    assert ExUnit.Filters.eval([], [os: :unix], %{os: :unix}, []) ==
+             {:excluded, "due to os filter"}
+
+    assert ExUnit.Filters.eval([os: :win], [], %{}, []) == :ok
+    assert ExUnit.Filters.eval([os: :win], [], %{os: :unix}, []) == :ok
+    assert ExUnit.Filters.eval([os: :win], [:os], %{}, []) == :ok
     assert ExUnit.Filters.eval([os: :win], [:os], %{os: :win}, []) == :ok
 
     assert ExUnit.Filters.eval([os: :win, os: :unix], [:os], %{os: :win}, []) == :ok
   end
 
+  describe "evaluating filters with skip" do
+    test "regular usage" do
+      assert ExUnit.Filters.eval([], [], %{}, []) == :ok
+      assert ExUnit.Filters.eval([], [], %{skip: true}, []) == {:skipped, "due to skip tag"}
+      assert ExUnit.Filters.eval([], [], %{skip: "skipped"}, []) == {:skipped, "skipped"}
+      assert ExUnit.Filters.eval([], [:os], %{skip: "skipped"}, []) == {:skipped, "skipped"}
+    end
+
+    test "exception to the rule: explicitly including tests with the :skip tag" do
+      assert ExUnit.Filters.eval([:skip], [], %{skip: true}, []) == :ok
+      assert ExUnit.Filters.eval([:skip], [], %{skip: "skipped"}, []) == :ok
+      assert ExUnit.Filters.eval([:skip], [:test], %{skip: true}, []) == :ok
+      assert ExUnit.Filters.eval([:skip], [:test], %{skip: "skipped"}, []) == :ok
+      assert ExUnit.Filters.eval([skip: true], [:test], %{skip: true}, []) == :ok
+
+      assert ExUnit.Filters.eval([skip: ~r/skip me/], [:test], %{skip: "skip me please"}, []) ==
+               :ok
+
+      assert ExUnit.Filters.eval([skip: ~r/skip me/], [:test], %{skip: "don't skip!"}, []) ==
+               {:skipped, "don't skip!"}
+    end
+  end
+
   test "evaluating filters matches integers" do
-    assert ExUnit.Filters.eval([int: "1"], [], %{int: 1}, [])       == :ok
+    assert ExUnit.Filters.eval([int: "1"], [], %{int: 1}, []) == :ok
     assert ExUnit.Filters.eval([int: "1"], [int: 5], %{int: 1}, []) == :ok
-    assert ExUnit.Filters.eval([int: "1"], [:int], %{int: 1}, [])   == :ok
+    assert ExUnit.Filters.eval([int: "1"], [:int], %{int: 1}, []) == :ok
   end
 
   test "evaluating filter matches atoms" do
-    assert ExUnit.Filters.eval([os: "win"], [], %{os: :win}, [])          == :ok
+    assert ExUnit.Filters.eval([os: "win"], [], %{os: :win}, []) == :ok
     assert ExUnit.Filters.eval([os: "win"], [os: :unix], %{os: :win}, []) == :ok
-    assert ExUnit.Filters.eval([os: "win"], [:os], %{os: :win}, [])       == :ok
-    assert ExUnit.Filters.eval([case: "Foo"], [:os], %{case: Foo}, [])    == :ok
+    assert ExUnit.Filters.eval([os: "win"], [:os], %{os: :win}, []) == :ok
+    assert ExUnit.Filters.eval([module: "Foo"], [:os], %{module: Foo}, []) == :ok
   end
 
   test "evaluating filter matches regexes" do
-    assert ExUnit.Filters.eval([os: ~r"win"], [], %{os: :win}, [])           == :ok
-    assert ExUnit.Filters.eval([os: ~r"mac"], [os: :unix], %{os: :unix}, []) == {:error, :os}
+    assert ExUnit.Filters.eval([os: ~r"win"], [], %{os: :win}, []) == :ok
+
+    assert ExUnit.Filters.eval([os: ~r"mac"], [os: :unix], %{os: :unix}, []) ==
+             {:excluded, "due to os filter"}
   end
 
   test "evaluating filter uses special rules for line" do
-    tests = [%ExUnit.Test{tags: %{line: 3}}, %ExUnit.Test{tags: %{line: 5}}]
+    tests = [
+      %ExUnit.Test{tags: %{line: 3, describe_line: 2}},
+      %ExUnit.Test{tags: %{line: 5, describe_line: nil}},
+      %ExUnit.Test{tags: %{line: 8, describe_line: 7}},
+      %ExUnit.Test{tags: %{line: 10, describe_line: 7}},
+      %ExUnit.Test{tags: %{line: 13, describe_line: 12}}
+    ]
+
+    assert ExUnit.Filters.eval([line: 3], [:line], %{line: 3, describe_line: 2}, tests) == :ok
+    assert ExUnit.Filters.eval([line: 4], [:line], %{line: 3, describe_line: 2}, tests) == :ok
+    assert ExUnit.Filters.eval([line: 5], [:line], %{line: 5, describe_line: nil}, tests) == :ok
+    assert ExUnit.Filters.eval([line: 6], [:line], %{line: 5, describe_line: nil}, tests) == :ok
+    assert ExUnit.Filters.eval([line: 2], [:line], %{line: 3, describe_line: 2}, tests) == :ok
+    assert ExUnit.Filters.eval([line: 7], [:line], %{line: 8, describe_line: 7}, tests) == :ok
+    assert ExUnit.Filters.eval([line: 7], [:line], %{line: 10, describe_line: 7}, tests) == :ok
+
+    assert ExUnit.Filters.eval([line: 1], [:line], %{line: 3, describe_line: 2}, tests) ==
+             {:excluded, "due to line filter"}
+
+    assert ExUnit.Filters.eval([line: 7], [:line], %{line: 3, describe_line: 2}, tests) ==
+             {:excluded, "due to line filter"}
+
+    assert ExUnit.Filters.eval([line: 7], [:line], %{line: 5, describe_line: nil}, tests) ==
+             {:excluded, "due to line filter"}
+  end
+
+  test "evaluating filter uses special rules for location" do
+    tests = [
+      %ExUnit.Test{tags: %{line: 3, describe_line: 2}},
+      %ExUnit.Test{tags: %{line: 5, describe_line: nil}}
+    ]
+
+    assert ExUnit.Filters.eval(
+             [location: "foo_test.exs"],
+             [:line],
+             %{line: 3, describe_line: 2, file: "foo_test.exs"},
+             tests
+           ) == :ok
+
+    assert ExUnit.Filters.eval(
+             [location: "bar_test.exs"],
+             [:line],
+             %{line: 3, describe_line: 2, file: "foo_test.exs"},
+             tests
+           ) == {:excluded, "due to line filter"}
+
+    assert ExUnit.Filters.eval(
+             [location: {"foo_test.exs", 3}],
+             [:line],
+             %{line: 3, describe_line: 2, file: "foo_test.exs"},
+             tests
+           ) == :ok
 
-    assert ExUnit.Filters.eval([line: 3], [:line], %{line: 3}, tests) == :ok
-    assert ExUnit.Filters.eval([line: 4], [:line], %{line: 3}, tests) == :ok
-    assert ExUnit.Filters.eval([line: 2], [:line], %{line: 3}, tests) == {:error, :line}
-    assert ExUnit.Filters.eval([line: 5], [:line], %{line: 3}, tests) == {:error, :line}
+    assert ExUnit.Filters.eval(
+             [location: {"bar_test.exs", 3}],
+             [:line],
+             %{line: 3, describe_line: 2, file: "foo_test.exs"},
+             tests
+           ) == {:excluded, "due to line filter"}
   end
 
   test "parsing filters" do
     assert ExUnit.Filters.parse(["run"]) == [:run]
     assert ExUnit.Filters.parse(["run:true"]) == [run: "true"]
     assert ExUnit.Filters.parse(["run:test"]) == [run: "test"]
-    assert ExUnit.Filters.parse(["line:9"]) == [line: "9"]
+    assert ExUnit.Filters.parse(["line:9"]) == [line: 9]
+    assert ExUnit.Filters.parse(["location:foo.exs"]) == [location: "foo.exs"]
+    assert ExUnit.Filters.parse(["location:foo.exs:invalid"]) == [location: "foo.exs:invalid"]
+    assert ExUnit.Filters.parse(["location:foo.exs:9"]) == [location: {"foo.exs", 9}]
+    assert ExUnit.Filters.parse(["location:foo.exs:9:11"]) == [location: {"foo.exs", [9, 11]}]
   end
 
   test "file paths with line numbers" do
-    assert ExUnit.Filters.parse_path("test/some/path.exs:123") ==
-      {"test/some/path.exs", [exclude: [:test], include: [line: "123"]]}
+    unix_path = "test/some/path.exs"
+    windows_path = "C:\\some\\path.exs"
+    unix_path_with_dot = "./test/some/path.exs"
+
+    for path <- [unix_path, windows_path, unix_path_with_dot] do
+      fixed_path = path |> Path.split() |> Path.join() |> Path.relative_to_cwd()
+
+      assert ExUnit.Filters.parse_paths(["#{path}:123"]) ==
+               {[fixed_path], [exclude: [:test], include: [location: {fixed_path, 123}]]}
+
+      assert ExUnit.Filters.parse_paths([path]) == {[fixed_path], []}
+
+      assert ExUnit.Filters.parse_paths(["#{path}:123notreallyalinenumber123"]) ==
+               {["#{fixed_path}:123notreallyalinenumber123"], []}
+
+      assert ExUnit.Filters.parse_paths(["#{path}:123:456"]) ==
+               {[fixed_path], [exclude: [:test], include: [location: {fixed_path, [123, 456]}]]}
+
+      assert ExUnit.Filters.parse_paths(["#{path}:123notalinenumber123:456"]) ==
+               {["#{fixed_path}:123notalinenumber123"],
+                [
+                  exclude: [:test],
+                  include: [location: {"#{fixed_path}:123notalinenumber123", 456}]
+                ]}
+
+      output =
+        ExUnit.CaptureIO.capture_io(:stderr, fn ->
+          assert ExUnit.Filters.parse_paths(["#{path}:123:456notalinenumber456"]) ==
+                   {[fixed_path],
+                    [{:exclude, [:test]}, {:include, [location: {fixed_path, 123}]}]}
+
+          assert ExUnit.Filters.parse_paths(["#{path}:123:0:-789:456"]) ==
+                   {[fixed_path],
+                    [exclude: [:test], include: [location: {fixed_path, [123, 456]}]]}
+        end)
+
+      assert output =~ "invalid line number given as ExUnit filter: 456notalinenumber456"
+      assert output =~ "invalid line number given as ExUnit filter: 0"
+      assert output =~ "invalid line number given as ExUnit filter: -789"
+    end
+  end
+
+  test "multiple file paths with line numbers" do
+    unix_path = "test/some/path.exs"
+    windows_path = "C:\\some\\path.exs"
+    other_unix_path = "test//some//other_path.exs"
+    other_windows_path = "C:\\some\\other_path.exs"
+
+    for {path, other_path} <- [{unix_path, other_unix_path}, {windows_path, other_windows_path}] do
+      fixed_path = path |> Path.split() |> Path.join()
+      fixed_other_path = other_path |> Path.split() |> Path.join()
 
-    assert ExUnit.Filters.parse_path("test/some/path.exs") ==
-      {"test/some/path.exs", []}
+      assert ExUnit.Filters.parse_paths([path, other_path]) ==
+               {[fixed_path, fixed_other_path], []}
 
-    assert ExUnit.Filters.parse_path("test/some/path.exs:123notreallyalinenumber123") ==
-      {"test/some/path.exs:123notreallyalinenumber123", []}
+      assert ExUnit.Filters.parse_paths([path, "#{other_path}:456:789"]) ==
+               {[fixed_path, fixed_other_path],
+                [
+                  exclude: [:test],
+                  include: [location: fixed_path, location: {fixed_other_path, [456, 789]}]
+                ]}
 
-    assert ExUnit.Filters.parse_path("C:\\some\\path.exs:123") ==
-      {"C:\\some\\path.exs", [exclude: [:test], include: [line: "123"]]}
+      assert ExUnit.Filters.parse_paths(["#{path}:123", "#{other_path}:456"]) ==
+               {[fixed_path, fixed_other_path],
+                [
+                  exclude: [:test],
+                  include: [location: {fixed_path, 123}, location: {fixed_other_path, 456}]
+                ]}
 
-    assert ExUnit.Filters.parse_path("C:\\some\\path.exs") ==
-      {"C:\\some\\path.exs", []}
+      output =
+        ExUnit.CaptureIO.capture_io(:stderr, fn ->
+          assert ExUnit.Filters.parse_paths([
+                   "#{path}:123:0:-789:456",
+                   "#{other_path}:321:0:-987:654"
+                 ]) ==
+                   {[fixed_path, fixed_other_path],
+                    [
+                      exclude: [:test],
+                      include: [
+                        location: {fixed_path, [123, 456]},
+                        location: {fixed_other_path, [321, 654]}
+                      ]
+                    ]}
+        end)
 
-    assert ExUnit.Filters.parse_path("C:\\some\\path.exs:123notreallyalinenumber123") ==
-      {"C:\\some\\path.exs:123notreallyalinenumber123", []}
+      assert output =~ "invalid line number given as ExUnit filter: 0"
+      assert output =~ "invalid line number given as ExUnit filter: -789"
+      assert output =~ "invalid line number given as ExUnit filter: -987"
+    end
   end
 end
diff --git a/lib/ex_unit/test/ex_unit/formatter_test.exs b/lib/ex_unit/test/ex_unit/formatter_test.exs
index 9756b5f4d3d..b6243e1e0a0 100644
--- a/lib/ex_unit/test/ex_unit/formatter_test.exs
+++ b/lib/ex_unit/test/ex_unit/formatter_test.exs
@@ -1,136 +1,612 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule ExUnit.FormatterTest do
-  use ExUnit.Case, async: true
+  use ExUnit.Case
 
   import ExUnit.Formatter
   doctest ExUnit.Formatter
 
-  def falsy, do: false
-  def formatter(_color, msg), do: msg
-
   defmacrop catch_assertion(expr) do
     quote do
       try do
         unquote(expr)
       rescue
-        e -> e
+        ex -> ex
       end
     end
   end
 
-  defp case do
-    %ExUnit.TestCase{name: Hello}
+  defp test_module do
+    %ExUnit.TestModule{name: Hello}
   end
 
   defp test do
-    %ExUnit.Test{name: :world, case: Hello, tags: [file: __ENV__.file, line: 1]}
+    %ExUnit.Test{name: :world, module: Hello, tags: %{file: __ENV__.file, line: 1}}
   end
 
+  def falsy() do
+    false
+  end
+
+  defp formatter(_key, value), do: value
+
+  defp diff_formatter(:diff_enabled?, _default), do: true
+  defp diff_formatter(_key, value), do: value
+
+  defp kw_to_string(kw), do: for({k, v} <- kw, do: {k, IO.iodata_to_binary(v)})
+
   test "formats test case filters" do
     filters = [run: true, slow: false]
-    assert format_filters(filters, :include) =~ "Including tags: [run: true, slow: false]"
     assert format_filters(filters, :exclude) =~ "Excluding tags: [run: true, slow: false]"
+    assert format_filters(filters, :include) =~ "Including tags: [run: true, slow: false]"
   end
 
   test "formats test errors" do
-    failure = {:error, catch_error(raise "oops"), []}
+    failure = [{:error, catch_error(raise "oops"), []}]
+
     assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ """
-      1) world (Hello)
-         test/ex_unit/formatter_test.exs:1
-         ** (RuntimeError) oops
-    """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                ** (RuntimeError) oops
+           """
   end
 
   test "formats test exits" do
-    failure = {:exit, 1, []}
+    failure = [{:exit, 1, []}]
+
     assert format_test_failure(test(), failure, 1, 80, &formatter/2) == """
-      1) world (Hello)
-         test/ex_unit/formatter_test.exs:1
-         ** (exit) 1
-    """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                ** (exit) 1
+           """
   end
 
   test "formats test exits with mfa" do
-    failure = {:exit, {:bye, {:m, :f, []}}, []}
+    failure = [{:exit, {:bye, {:mod, :fun, []}}, []}]
+
     assert format_test_failure(test(), failure, 1, 80, &formatter/2) == """
-      1) world (Hello)
-         test/ex_unit/formatter_test.exs:1
-         ** (exit) exited in: :m.f()
-             ** (EXIT) :bye
-    """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                ** (exit) exited in: :mod.fun()
+                    ** (EXIT) :bye
+           """
+  end
+
+  test "formats test exits with function clause mfa" do
+    {error, stack} =
+      try do
+        Access.fetch(:foo, :bar)
+      catch
+        :error, error -> {error, __STACKTRACE__}
+      end
+
+    failure = [{:exit, {{error, stack}, {:mod, :fun, []}}, []}]
+
+    format = trim_multiline_whitespace(format_test_failure(test(), failure, 1, 80, &formatter/2))
+
+    assert format =~
+             """
+               1) world (Hello)
+                  test/ex_unit/formatter_test.exs:1
+                  ** (exit) exited in: :mod.fun()
+                     ** (EXIT) an exception was raised:
+                       ** (FunctionClauseError) no function clause matching in Access.fetch/2
+
+                       The following arguments were given to Access.fetch/2:
+
+                           # 1
+                           :foo
+
+                           # 2
+                           :bar
+             """
+
+    if Access not in :cover.modules() do
+      assert format =~
+               """
+                         Attempted function clauses (showing 5 out of 5):
+
+                             def fetch(%module{} = container, key)
+               """
+    end
+  end
+
+  test "formats test exits with assertion mfa" do
+    {error, stack} =
+      try do
+        assert 1 == 2
+      rescue
+        error -> {error, __STACKTRACE__}
+      end
+
+    failure = [{:exit, {{error, stack}, {:mod, :fun, []}}, []}]
+
+    assert trim_multiline_whitespace(format_test_failure(test(), failure, 1, 80, &formatter/2)) =~
+             """
+               1) world (Hello)
+                  test/ex_unit/formatter_test.exs:1
+                  ** (exit) exited in: :mod.fun()
+                     ** (EXIT) an exception was raised:
+                       Assertion with == failed
+                       code:  assert 1 == 2
+                       left:  1
+                       right: 2
+             """
   end
 
   test "formats test throws" do
-    failure = {:throw, 1, []}
+    failure = [{:throw, 1, []}]
+
     assert format_test_failure(test(), failure, 1, 80, &formatter/2) == """
-      1) world (Hello)
-         test/ex_unit/formatter_test.exs:1
-         ** (throw) 1
-    """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                ** (throw) 1
+           """
   end
 
   test "formats test EXITs" do
-    failure = {{:EXIT, self}, 1, []}
+    failure = [{{:EXIT, self()}, 1, []}]
+
     assert format_test_failure(test(), failure, 1, 80, &formatter/2) == """
-      1) world (Hello)
-         test/ex_unit/formatter_test.exs:1
-         ** (EXIT from #{inspect self}) 1
-    """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                ** (EXIT from #{inspect(self())}) 1
+           """
+  end
+
+  test "formats test EXITs with function clause errors" do
+    {error, stack} =
+      try do
+        Access.fetch(:foo, :bar)
+      catch
+        :error, error -> {error, __STACKTRACE__}
+      end
+
+    failure = [{{:EXIT, self()}, {error, stack}, []}]
+    format = trim_multiline_whitespace(format_test_failure(test(), failure, 1, 80, &formatter/2))
+
+    assert format =~
+             """
+               1) world (Hello)
+                  test/ex_unit/formatter_test.exs:1
+                  ** (EXIT from #{inspect(self())}) an exception was raised:
+
+                       ** (FunctionClauseError) no function clause matching in Access.fetch/2
+
+                       The following arguments were given to Access.fetch/2:
+
+                           # 1
+                           :foo
+
+                           # 2
+                           :bar
+             """
+
+    if Access not in :cover.modules() do
+      assert format =~
+               """
+                         Attempted function clauses (showing 5 out of 5):
+
+                             def fetch(%module{} = container, key)
+               """
+    end
+
+    assert format =~ ~r"lib/access.ex:\d+: Access.fetch/2"
+  end
+
+  test "formats test EXITs with assertion errors" do
+    {error, stack} =
+      try do
+        assert 1 == 2
+      rescue
+        error -> {error, __STACKTRACE__}
+      end
+
+    failure = [{{:EXIT, self()}, {error, stack}, []}]
+
+    assert trim_multiline_whitespace(format_test_failure(test(), failure, 1, 80, &formatter/2)) =~
+             """
+               1) world (Hello)
+                  test/ex_unit/formatter_test.exs:1
+                  ** (EXIT from #{inspect(self())}) an exception was raised:
+
+                       Assertion with == failed
+                       code:  assert 1 == 2
+                       left:  1
+                       right: 2
+             """
+  end
+
+  test "formats test errors with test_location_relative_path" do
+    Application.put_env(:ex_unit, :test_location_relative_path, "apps/sample")
+    failure = [{:error, catch_error(raise "oops"), []}]
+
+    assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ """
+             1) world (Hello)
+                apps/sample/test/ex_unit/formatter_test.exs:1
+                ** (RuntimeError) oops
+           """
+  after
+    Application.delete_env(:ex_unit, :test_location_relative_path)
+  end
+
+  test "formats test errors with code snippets" do
+    stack = {Hello, :world, 1, [file: __ENV__.file, line: 7]}
+    failure = [{:error, catch_error(raise "oops"), [stack]}]
+
+    assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                ** (RuntimeError) oops
+                code: defmodule ExUnit.FormatterTest do
+           """
+  end
+
+  test "formats test errors with parameters" do
+    failure = [{:error, catch_error(raise "oops"), []}]
+
+    assert format_test_failure(%{test() | parameters: %{foo: :bar}}, failure, 1, 80, &formatter/2) =~
+             """
+               1) world (Hello)
+                  Parameters: %{foo: :bar}
+                  test/ex_unit/formatter_test.exs:1
+                  ** (RuntimeError) oops
+             """
+
+    formatter = fn
+      :parameters_info, map -> Map.put(map, :more, :keys)
+      key, val -> formatter(key, val)
+    end
+
+    assert format_test_failure(%{test() | parameters: %{foo: :bar}}, failure, 1, 80, formatter) =~
+             """
+               1) world (Hello)
+                  Parameters: #{inspect(%{foo: :bar, more: :keys})}
+                  test/ex_unit/formatter_test.exs:1
+                  ** (RuntimeError) oops
+             """
   end
 
   test "formats stacktraces" do
-    failure = {:error, catch_error(raise "oops"), [{Oops, :wrong, 1, [file: "formatter_test.exs", line: 1]}]}
+    stacktrace = [{Oops, :wrong, 1, [file: "formatter_test.exs", line: 1]}]
+    failure = [{:error, catch_error(raise "oops"), stacktrace}]
+
     assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ """
-      1) world (Hello)
-         test/ex_unit/formatter_test.exs:1
-         ** (RuntimeError) oops
-         stacktrace:
-           formatter_test.exs:1: Oops.wrong/1
-    """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                ** (RuntimeError) oops
+                stacktrace:
+                  formatter_test.exs:1: Oops.wrong/1
+           """
   end
 
   test "formats assertions" do
-    failure = {:error, catch_assertion(assert ExUnit.FormatterTest.falsy), []}
+    assertion_error = catch_assertion(assert ExUnit.FormatterTest.falsy())
+    failure = [{:error, assertion_error, []}]
+
     assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ """
-      1) world (Hello)
-         test/ex_unit/formatter_test.exs:1
-         Expected truthy, got false
-         code: ExUnit.FormatterTest.falsy()
-    """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                Expected truthy, got false
+                code: assert ExUnit.FormatterTest.falsy()
+           """
+
+    assert format_assertion_diff(assertion_error, 0, :infinity, &formatter/2) == []
   end
 
-  test "formats test case errors" do
-    failure = {:error, catch_error(raise "oops"), []}
-    assert format_test_case_failure(case(), failure, 1, 80, &formatter/2) =~ """
-      1) Hello: failure on setup_all callback, tests invalidated
-         ** (RuntimeError) oops
-    """
+  test "formats assertions with patterns and values" do
+    assertion_error = catch_assertion(assert {1, 2, 3} > {1, 2, 3})
+    failure = [{:error, assertion_error, []}]
+
+    assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                Assertion with > failed, both sides are exactly equal
+                code: assert {1, 2, 3} > {1, 2, 3}
+                left: {1, 2, 3}
+           """
+
+    assert format_assertion_diff(assertion_error, 0, :infinity, &diff_formatter/2)
+           |> kw_to_string() ==
+             [left: "{1, 2, 3}"]
+
+    assertion_error = catch_assertion(assert {3, 2, 1} = {1, 2, 3})
+    failure = [{:error, assertion_error, []}]
+
+    assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                match (=) failed
+                code:  assert {3, 2, 1} = {1, 2, 3}
+                left:  {3, 2, 1}
+                right: {1, 2, 3}
+           """
+
+    assert format_assertion_diff(assertion_error, 0, :infinity, &diff_formatter/2)
+           |> kw_to_string() ==
+             [{:left, "{3, 2, 1}"}, {:right, "{1, 2, 3}"}]
+  end
+
+  nfc_hello = String.normalize("héllo", :nfc)
+  nfd_hello = String.normalize("héllo", :nfd)
+
+  test "formats assertions with hints" do
+    assertion_error = catch_assertion(assert unquote(nfc_hello) == unquote(nfd_hello))
+    failure = [{:error, assertion_error, []}]
+
+    assert format_test_failure(test(), failure, 1, 80, &diff_formatter/2) =~ """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                Assertion with == failed
+                code:  assert "#{unquote(nfc_hello)}" == "#{unquote(nfd_hello)}"
+                left:  "#{unquote(nfc_hello)}"
+                right: "#{unquote(nfd_hello)}"
+                hint:  you are comparing strings that have the same visual representation but are made of different Unicode codepoints
+           """
+
+    assert format_test_failure(test(), failure, 1, 80, &diff_formatter/2) ==
+             format_test_failure(test(), failure, 1, 80, &formatter/2)
+
+    assert format_assertion_diff(assertion_error, 0, :infinity, &diff_formatter/2)
+           |> kw_to_string() ==
+             [
+               left: inspect(unquote(nfc_hello)),
+               right: inspect(unquote(nfd_hello)),
+               hint:
+                 "you are comparing strings that have the same visual representation but are made of different Unicode codepoints"
+             ]
+  end
+
+  test "formats match error between pinned struct type and a non-struct" do
+    failure = [
+      {:error,
+       catch_assertion do
+         expected_module = ExUnit.TestModule
+         assert %^expected_module{} = nil
+       end, []}
+    ]
+
+    assert format_test_failure(test(), failure, 1, 80, &diff_formatter/2) =~ """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                match (=) failed
+                The following variables were pinned:
+                  expected_module = ExUnit.TestModule
+                code:  assert %^expected_module{} = nil
+                left:  %^expected_module{}
+                right: nil
+           """
+  end
+
+  test "formats multiple assertions" do
+    failure = [
+      {:error, catch_assertion(assert ExUnit.FormatterTest.falsy()), []},
+      {:error, catch_assertion(assert 1 == 2), []}
+    ]
+
+    assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+
+                Failure #1
+                Expected truthy, got false
+                code: assert ExUnit.FormatterTest.falsy()
+
+                Failure #2
+                Assertion with == failed
+                code:  assert 1 == 2
+                left:  1
+                right: 2
+           """
+  end
+
+  defp trim_multiline_whitespace(string) do
+    String.replace(string, ~r"\n\s+\n", "\n\n")
+  end
+
+  test "blames function clause error" do
+    {error, stack} =
+      try do
+        Access.fetch(:foo, :bar)
+      rescue
+        exception -> {exception, __STACKTRACE__}
+      end
+
+    failure = format_test_failure(test(), [{:error, error, [hd(stack)]}], 1, 80, &formatter/2)
+
+    assert trim_multiline_whitespace(failure) =~ """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                ** (FunctionClauseError) no function clause matching in Access.fetch/2
+
+                The following arguments were given to Access.fetch/2:
+
+                    # 1
+                    :foo
+
+                    # 2
+                    :bar
+           """
+
+    if Access not in :cover.modules() do
+      assert failure =~
+               """
+                    Attempted function clauses (showing 5 out of 5):
+
+                        def fetch(%module{} = container, key)
+               """
+    end
+
+    assert failure =~ ~r"\(elixir #{System.version()}\) lib/access\.ex:\d+: Access\.fetch/2"
+  end
+
+  test "formats setup_all errors" do
+    failure = [{:error, catch_error(raise "oops"), []}]
+
+    assert format_test_all_failure(test_module(), failure, 1, 80, &formatter/2) =~ """
+             1) Hello: failure on setup_all callback, all tests have been invalidated
+                ** (RuntimeError) oops
+           """
+  end
+
+  test "formats matches correctly" do
+    failure = [{:error, catch_assertion(assert %{a: :b} = %{a: :c}), []}]
+
+    assert format_test_all_failure(test_module(), failure, 1, :infinity, &formatter/2) =~ """
+             1) Hello: failure on setup_all callback, all tests have been invalidated
+                match (=) failed
+                code:  assert %{a: :b} = %{a: :c}
+                left:  %{a: :b}
+                right: %{a: :c}
+           """
+  end
+
+  test "formats setup_all exit stacktraces using module context" do
+    stacktrace = [
+      {Hello, :setup_all, [], [file: __ENV__.file, line: 123]},
+      {Hello, :some_fun, [], [file: __ENV__.file, line: 456]}
+    ]
+
+    failure = [{{:EXIT, self()}, {:function_clause, stacktrace}, []}]
+
+    formatted =
+      format_test_all_failure(test_module(), failure, 1, 80, &formatter/2)
+
+    assert formatted =~ "Hello.setup_all/0"
+    assert formatted =~ "Hello.some_fun()"
   end
 
   test "formats assertions with operators with no limit" do
-    failure = {:error, catch_assertion(assert [1, 2, 3] == [4, 5, 6]), []}
-    assert format_test_case_failure(case(), failure, 1, :infinity, &formatter/2) =~ """
-      1) Hello: failure on setup_all callback, tests invalidated
-         Assertion with == failed
-         code: [1, 2, 3] == [4, 5, 6]
-         lhs:  [1, 2, 3]
-         rhs:  [4, 5, 6]
-    """
+    failure = [{:error, catch_assertion(assert [1, 2, 3] == [4, 5, 6]), []}]
+
+    assert format_test_all_failure(test_module(), failure, 1, :infinity, &formatter/2) =~ """
+             1) Hello: failure on setup_all callback, all tests have been invalidated
+                Assertion with == failed
+                code:  assert [1, 2, 3] == [4, 5, 6]
+                left:  [1, 2, 3]
+                right: [4, 5, 6]
+           """
   end
 
   test "formats assertions with operators with column limit" do
-    failure = {:error, catch_assertion(assert [1, 2, 3] == [4, 5, 6]), []}
-    assert format_test_case_failure(case(), failure, 1, 15, &formatter/2) =~ """
-      1) Hello: failure on setup_all callback, tests invalidated
-         Assertion with == failed
-         code: [1, 2, 3] == [4, 5, 6]
-         lhs:  [1,
-                2,
-                3]
-         rhs:  [4,
-                5,
-                6]
-    """
+    failure = [{:error, catch_assertion(assert [1, 2, 3] == [4, 5, 6]), []}]
+
+    assert format_test_all_failure(test_module(), failure, 1, 15, &formatter/2) =~ """
+             1) Hello: failure on setup_all callback, all tests have been invalidated
+                Assertion with == failed
+                code:  assert [1, 2, 3] == [4, 5, 6]
+                left:  [1,
+                        2,
+                        3]
+                right: [4,
+                        5,
+                        6]
+           """
+  end
+
+  test "formats assertions with complex function call arguments" do
+    failure = [{:error, catch_assertion(assert is_list(List.to_tuple([1, 2, 3]))), []}]
+
+    assert format_test_all_failure(test_module(), failure, 1, 80, &formatter/2) =~ """
+             1) Hello: failure on setup_all callback, all tests have been invalidated
+                Expected truthy, got false
+                code: assert is_list(List.to_tuple([1, 2, 3]))
+                arguments:
+
+                    # 1
+                    {1, 2, 3}
+           """
+
+    failure = [{:error, catch_assertion(assert is_list({1, 2})), []}]
+
+    assert format_test_all_failure(test_module(), failure, 1, 80, &formatter/2) =~ """
+             1) Hello: failure on setup_all callback, all tests have been invalidated
+                Expected truthy, got false
+                code: assert is_list({1, 2})
+           """
+  end
+
+  test "formats assertions with message with multiple lines" do
+    message = "Some meaningful error:\nuseful info\nanother useful info"
+    failure = [{:error, catch_assertion(assert(false, message)), []}]
+
+    assert format_test_all_failure(test_module(), failure, 1, :infinity, &formatter/2) =~ """
+             1) Hello: failure on setup_all callback, all tests have been invalidated
+                Some meaningful error:
+                useful info
+                another useful info
+           """
+  end
+
+  test "formats assertions with nested improper list diffing" do
+    failure = [{:error, catch_assertion(assert :foo = %{bar: [1 | 2]}), []}]
+
+    assert format_test_all_failure(test_module(), failure, 1, :infinity, &diff_formatter/2) =~ """
+           match (=) failed
+                code:  assert :foo = %{bar: [1 | 2]}
+                left:  :foo
+                right: %{bar: [1 | 2]}
+           """
+  end
+
+  defmodule BadInspect do
+    defstruct key: 0
+
+    defimpl Inspect do
+      def inspect(_struct, opts) when is_atom(opts) do
+        raise "the clause above should never match"
+      end
+    end
+  end
+
+  test "inspect failure" do
+    failure = [{:error, catch_assertion(assert :will_fail == struct!(BadInspect)), []}]
+
+    assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ ~s'''
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                Assertion with == failed
+                code:  assert :will_fail == struct!(BadInspect)
+                left:  :will_fail
+                right: #Inspect.Error<
+             got FunctionClauseError with message:
+
+                 """
+                 no function clause matching in Inspect.ExUnit.FormatterTest.BadInspect.inspect/2
+                 """
+
+             while inspecting:
+
+                 #{inspect(%BadInspect{}, structs: false)}
+
+             Stacktrace:
+           '''
+  end
+
+  defmodule BadMessage do
+    defexception key: 0
+
+    @impl true
+    def message(_message) do
+      raise "oops"
+    end
+  end
+
+  test "message failure" do
+    failure = [{:error, catch_error(raise BadMessage), []}]
+
+    message =
+      "got RuntimeError with message \"oops\" while retrieving Exception.message/1 " <>
+        "for %ExUnit.FormatterTest.BadMessage{key: 0}. Stacktrace:"
+
+    assert format_test_failure(test(), failure, 1, 80, &formatter/2) =~ """
+             1) world (Hello)
+                test/ex_unit/formatter_test.exs:1
+                ** (ExUnit.FormatterTest.BadMessage) #{message}
+           """
   end
 end
diff --git a/lib/ex_unit/test/ex_unit/register_test.exs b/lib/ex_unit/test/ex_unit/register_test.exs
new file mode 100644
index 00000000000..8dd2f730f57
--- /dev/null
+++ b/lib/ex_unit/test/ex_unit/register_test.exs
@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule ExUnit.RegisterTest do
+  use ExUnit.Case
+
+  import ExUnit.CaptureIO
+
+  test "singular test types" do
+    on_exit(fn ->
+      ExUnit.configure(plural_rules: %{})
+    end)
+
+    ExUnit.plural_rule("property", "properties")
+
+    defmodule SingularTestTypeCase do
+      use ExUnit.Case
+
+      :"property is true" =
+        ExUnit.Case.register_test(
+          __ENV__.module,
+          __ENV__.file,
+          __ENV__.line,
+          :property,
+          "is true",
+          []
+        )
+
+      def unquote(:"property is true")(_) do
+        assert succeed()
+      end
+
+      test "test true" do
+        assert succeed()
+      end
+
+      defp succeed, do: true
+    end
+
+    assert capture_io(fn ->
+             assert ExUnit.run() == %{failures: 0, skipped: 0, total: 2, excluded: 0}
+           end) =~ "1 property, 1 test, 0 failures"
+  end
+
+  test "plural test types" do
+    on_exit(fn ->
+      ExUnit.configure(plural_rules: %{})
+    end)
+
+    ExUnit.plural_rule("property", "properties")
+
+    defmodule PluralTestTypeCase do
+      use ExUnit.Case
+
+      :"property is true" =
+        ExUnit.Case.register_test(
+          __ENV__.module,
+          __ENV__.file,
+          __ENV__.line,
+          :property,
+          "is true",
+          []
+        )
+
+      def unquote(:"property is true")(_) do
+        assert succeed()
+      end
+
+      :"property is also true" =
+        ExUnit.Case.register_test(
+          __ENV__.module,
+          __ENV__.file,
+          __ENV__.line,
+          :property,
+          "is also true",
+          []
+        )
+
+      def unquote(:"property is also true")(_) do
+        assert succeed()
+      end
+
+      test "test true" do
+        assert succeed()
+      end
+
+      test "test true also" do
+        assert succeed()
+      end
+
+      defp succeed, do: true
+    end
+
+    assert capture_io(fn ->
+             assert ExUnit.run() == %{failures: 0, skipped: 0, total: 4, excluded: 0}
+           end) =~ "2 properties, 2 tests, 0 failures"
+  end
+end
diff --git a/lib/ex_unit/test/ex_unit/runner_stats_test.exs b/lib/ex_unit/test/ex_unit/runner_stats_test.exs
new file mode 100644
index 00000000000..05db0642eea
--- /dev/null
+++ b/lib/ex_unit/test/ex_unit/runner_stats_test.exs
@@ -0,0 +1,173 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule ExUnit.RunnerStatsTest do
+  use ExUnit.Case, async: false
+
+  alias ExUnit.{FailuresManifest, RunnerStats}
+
+  @failures_manifest_path "ex_unit_failures_manifest.elixir"
+
+  describe "stats tracking" do
+    test "counts total, failures, skipped, and excluded tests" do
+      stats =
+        simulate_suite([], fn formatter ->
+          simulate_test(formatter, :test_1, :passed)
+          simulate_test(formatter, :test_2, :skipped)
+          simulate_test(formatter, :test_3, :failed)
+          simulate_test(formatter, :test_4, :invalid)
+          simulate_test(formatter, :test_5, :passed)
+          simulate_test(formatter, :test_6, :passed)
+          simulate_test(formatter, :test_7, :excluded)
+          simulate_test(formatter, :test_8, :excluded)
+          simulate_test(formatter, :test_9, :excluded)
+          simulate_test(formatter, :test_10, :excluded)
+        end)
+
+      assert stats == %{total: 10, failures: 2, skipped: 1, excluded: 4}
+    end
+
+    test "invalidates successful tests when a module fails" do
+      module_tests_a = [
+        {:test_a1, :passed},
+        {:test_a2, :skipped},
+        {:test_a3, :failed},
+        {:test_a4, :invalid},
+        {:test_a5, :excluded}
+      ]
+
+      module_tests_b = [
+        {:test_b1, :passed},
+        {:test_b2, :failed},
+        {:test_b3, :failed},
+        {:test_b4, :passed},
+        {:test_b5, :passed}
+      ]
+
+      tests = module_tests_a ++ module_tests_b
+
+      stats =
+        simulate_suite([], fn formatter ->
+          for {test_name, status} <- tests do
+            simulate_test(formatter, test_name, status)
+          end
+
+          simulate_module_finished(
+            formatter,
+            :module_a,
+            :passed,
+            module_tests_a
+          )
+
+          simulate_module_finished(
+            formatter,
+            :module_b,
+            :failed,
+            module_tests_b
+          )
+        end)
+
+      assert stats == %{total: 10, failures: 7, skipped: 1, excluded: 1}
+    end
+  end
+
+  describe "when no failures manifest path option is provided" do
+    @tag :tmp_dir
+    test "does not write a failures manifest", %{tmp_dir: tmp_dir} do
+      File.cd!(tmp_dir, fn ->
+        simulate_suite([], fn formatter ->
+          simulate_test(formatter, :test_1, :passed)
+          simulate_test(formatter, :test_2, :failed)
+        end)
+
+        assert File.ls(".") == {:ok, []}
+      end)
+    end
+  end
+
+  describe "when a failures manifest path option is provided" do
+    @tag :tmp_dir
+    test "records the test failures in the failures manifest file", %{tmp_dir: tmp_dir} do
+      File.cd!(tmp_dir, fn ->
+        simulate_suite(fn formatter ->
+          simulate_test(formatter, :test_1, :passed)
+          simulate_test(formatter, :test_2, :failed)
+        end)
+
+        assert read_failures_manifest() == %{{TestModule, :test_2} => __ENV__.file}
+      end)
+    end
+
+    @tag :tmp_dir
+    test "merges the results with the results from the prior run", %{tmp_dir: tmp_dir} do
+      File.cd!(tmp_dir, fn ->
+        simulate_suite(&simulate_test(&1, :test_1, :failed))
+        simulate_suite(&simulate_test(&1, :test_2, :failed))
+
+        assert read_failures_manifest() == %{
+                 {TestModule, :test_1} => __ENV__.file,
+                 {TestModule, :test_2} => __ENV__.file
+               }
+      end)
+    end
+  end
+
+  defp simulate_suite(opts \\ [failures_manifest_path: @failures_manifest_path], fun) do
+    {:ok, pid} = GenServer.start_link(RunnerStats, opts)
+    GenServer.cast(pid, {:suite_started, opts})
+
+    fun.(pid)
+
+    GenServer.cast(pid, {:suite_finished, %{}})
+    RunnerStats.stats(pid)
+  end
+
+  defp simulate_test(formatter, test_name, status) do
+    GenServer.cast(
+      formatter,
+      {:test_finished,
+       %ExUnit.Test{
+         module: TestModule,
+         name: test_name,
+         tags: %{file: __ENV__.file},
+         state: state_for(status)
+       }}
+    )
+  end
+
+  defp simulate_module_finished(formatter, module_name, status, tests) do
+    tests =
+      for {test_name, status} <- tests do
+        %ExUnit.Test{
+          module: TestModule,
+          name: test_name,
+          tags: %{file: __ENV__.file},
+          state: state_for(status)
+        }
+      end
+
+    GenServer.cast(
+      formatter,
+      {:module_finished,
+       %ExUnit.TestModule{
+         file: __ENV__.file,
+         name: module_name,
+         state: state_for(status),
+         tests: tests
+       }}
+    )
+  end
+
+  defp state_for(:passed), do: nil
+  defp state_for(:failed), do: {:failed, []}
+  defp state_for(:invalid), do: {:invalid, %ExUnit.TestModule{}}
+  defp state_for(:skipped), do: {:skipped, "reason"}
+  defp state_for(:excluded), do: {:excluded, "reason"}
+
+  defp read_failures_manifest do
+    FailuresManifest.read(@failures_manifest_path)
+  end
+end
diff --git a/lib/ex_unit/test/ex_unit/supervised_test.exs b/lib/ex_unit/test/ex_unit/supervised_test.exs
new file mode 100644
index 00000000000..c74fce26a76
--- /dev/null
+++ b/lib/ex_unit/test/ex_unit/supervised_test.exs
@@ -0,0 +1,160 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule ExUnit.SupervisedTest do
+  use ExUnit.Case, async: true
+
+  defmodule MyAgent do
+    use Agent
+
+    def start_link(:error) do
+      {:error, "some error"}
+    end
+
+    def start_link(:exception) do
+      raise "some exception"
+    end
+
+    def start_link(arg) do
+      Agent.start_link(fn -> arg end, name: __MODULE__)
+    end
+  end
+
+  test "returns error if the supervised process returns an error tuple" do
+    {:error, error} = start_supervised({MyAgent, :error})
+    assert {"some error", _info} = error
+
+    message =
+      "failed to start child with the spec {ExUnit.SupervisedTest.MyAgent, :error}.\n" <>
+        "Reason: \"some error\""
+
+    assert_raise RuntimeError, message, fn ->
+      start_supervised!({MyAgent, :error})
+    end
+  end
+
+  test "returns error if the supervised process raises an exception" do
+    {:error, {{:EXIT, {exception, _}}, _}} = start_supervised({MyAgent, :exception})
+    assert exception == %RuntimeError{message: "some exception"}
+
+    message =
+      "failed to start child with the spec {ExUnit.SupervisedTest.MyAgent, :exception}.\n" <>
+        "Reason: an exception was raised:\n" <> "    ** (RuntimeError) some exception"
+
+    exception =
+      assert_raise RuntimeError, fn ->
+        start_supervised!({MyAgent, :exception})
+      end
+
+    assert String.starts_with?(Exception.message(exception), message)
+  end
+
+  test "starts a supervised process that terminates before on_exit" do
+    {:ok, pid} = start_supervised(MyAgent)
+    assert Process.alive?(pid)
+    on_exit(fn -> refute Process.alive?(pid) end)
+  end
+
+  test "starts a supervised process that is permanent" do
+    {:ok, _} = start_supervised({MyAgent, 0})
+    Agent.update(MyAgent, &(&1 + 1))
+    assert Agent.get(MyAgent, & &1) == 1
+    Agent.stop(MyAgent)
+    wait_until_registered(MyAgent)
+    assert Agent.get(MyAgent, & &1) == 0
+  end
+
+  test "starts a supervised process that is temporary" do
+    {:ok, _} = start_supervised({MyAgent, 0}, restart: :temporary)
+    Agent.update(MyAgent, &(&1 + 1))
+    assert Agent.get(MyAgent, & &1) == 1
+    Agent.stop(MyAgent)
+    refute Process.whereis(MyAgent)
+  end
+
+  test "starts a supervised process with ID checks" do
+    {:ok, pid} = start_supervised({MyAgent, 0})
+    assert is_pid(pid)
+
+    assert {:error, _} = start_supervised({MyAgent, 0})
+    assert {:error, _} = start_supervised({MyAgent, 0}, id: :another)
+
+    assert_raise RuntimeError, ~r"Reason: bad child specification", fn ->
+      start_supervised!(%{id: 1, start: :oops})
+    end
+  end
+
+  test "starts a supervised process with correct :\"$callers\"" do
+    test_pid = self()
+    fun = fn -> send(test_pid, {:callers, Process.get(:"$callers")}) end
+    {:ok, _pid} = start_supervised({Task, fun})
+
+    assert_receive {:callers, callers}
+    assert List.last(callers) == test_pid
+  end
+
+  test "starts a supervised process with correct :\"$ancestors\"" do
+    test_pid = self()
+    fun = fn -> send(test_pid, {:ancestors, Process.get(:"$ancestors")}) end
+    {:ok, _pid} = start_supervised({Task, fun})
+
+    assert_receive {:ancestors, ancestors}
+    assert List.last(ancestors) == test_pid
+  end
+
+  test "stops a supervised process" do
+    {:ok, pid} = start_supervised({MyAgent, 0})
+    assert stop_supervised(MyAgent) == :ok
+    refute Process.alive?(pid)
+  end
+
+  test "stops a linked supervised process" do
+    pid = start_link_supervised!({MyAgent, 0})
+    assert stop_supervised(MyAgent) == :ok
+    refute Process.alive?(pid)
+  end
+
+  test "stops a temporary supervised process" do
+    {:ok, pid} = start_supervised({MyAgent, 0}, restart: :temporary)
+    assert stop_supervised(MyAgent) == :ok
+    refute Process.alive?(pid)
+  end
+
+  test "stops! a supervised process" do
+    {:ok, pid} = start_supervised({MyAgent, 0})
+    assert stop_supervised!(MyAgent) == :ok
+    refute Process.alive?(pid)
+  end
+
+  test "does not stop unknown processes" do
+    assert stop_supervised(:unknown) == {:error, :not_found}
+    {:ok, _} = start_supervised({MyAgent, 0})
+    assert stop_supervised(:unknown) == {:error, :not_found}
+  end
+
+  test "raises if starting or stopping outside of test process" do
+    Task.async(fn ->
+      message = "start_supervised/2 can only be invoked from the test process"
+
+      assert_raise ArgumentError, message, fn ->
+        start_supervised(MyAgent)
+      end
+
+      message = "stop_supervised/1 can only be invoked from the test process"
+
+      assert_raise ArgumentError, message, fn ->
+        stop_supervised(MyAgent)
+      end
+    end)
+    |> Task.await()
+  end
+
+  defp wait_until_registered(name) do
+    if !Process.whereis(name) do
+      wait_until_registered(name)
+    end
+  end
+end
diff --git a/lib/ex_unit/test/ex_unit_test.exs b/lib/ex_unit/test/ex_unit_test.exs
index 9513aef1c9d..84d68c377f6 100644
--- a/lib/ex_unit/test/ex_unit_test.exs
+++ b/lib/ex_unit/test/ex_unit_test.exs
@@ -1,13 +1,17 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule ExUnitTest do
   use ExUnit.Case
 
   import ExUnit.CaptureIO
 
-  test "it supports many runs" do
+  test "supports many runs and loads" do
     defmodule SampleTest do
-      use ExUnit.Case, async: false
+      use ExUnit.Case
 
       test "true" do
         assert false
@@ -18,26 +22,294 @@ defmodule ExUnitTest do
       end
     end
 
+    configure_and_reload_on_exit([])
+
+    assert capture_io(fn ->
+             assert ExUnit.run() == %{failures: 2, skipped: 0, total: 2, excluded: 0}
+           end) =~ "\n2 tests, 2 failures\n"
+
+    ExUnit.Server.modules_loaded(false)
+
+    assert capture_io(fn ->
+             assert ExUnit.async_run() |> ExUnit.await_run() ==
+                      %{failures: 0, skipped: 0, total: 0, excluded: 0}
+           end) =~ "\n0 tests, 0 failures\n"
+  end
+
+  test "supports rerunning given modules" do
+    defmodule SampleAsyncTest do
+      use ExUnit.Case, async: true, register: false
+
+      test "true" do
+        assert false
+      end
+    end
+
+    defmodule SampleSyncTest do
+      use ExUnit.Case, register: false
+
+      test "true" do
+        assert false
+      end
+    end
+
+    defmodule IgnoreTest do
+      use ExUnit.Case
+
+      test "true" do
+        assert false
+      end
+    end
+
+    configure_and_reload_on_exit([])
+
     assert capture_io(fn ->
-      assert ExUnit.run == %{failures: 2, total: 2}
-    end) =~ "2 tests, 2 failures"
+             assert ExUnit.run() == %{
+                      failures: 1,
+                      skipped: 0,
+                      total: 1,
+                      excluded: 0
+                    }
+           end) =~ "\n1 test, 1 failure\n"
+
+    sample = [SampleSyncTest, SampleAsyncTest]
+
+    assert capture_io(fn ->
+             assert ExUnit.run(sample) == %{
+                      failures: 2,
+                      skipped: 0,
+                      total: 2,
+                      excluded: 0
+                    }
+           end) =~ "\n2 tests, 2 failures\n"
+
+    assert capture_io(fn ->
+             assert ExUnit.run(sample ++ sample) == %{
+                      failures: 2,
+                      skipped: 0,
+                      total: 2,
+                      excluded: 0
+                    }
+           end) =~ "\n2 tests, 2 failures\n"
+  end
+
+  test "prints aborted runs on sigquit", config do
+    Process.register(self(), :aborted_on_sigquit)
+    line = __ENV__.line + 5
+
+    defmodule SleepOnTest do
+      use ExUnit.Case, async: true
+
+      test "true" do
+        send(:aborted_on_sigquit, :sleeping)
+        Process.sleep(:infinity)
+      end
+    end
+
+    defmodule SleepOnSetupAll do
+      use ExUnit.Case, async: true
+
+      setup_all do
+        send(:aborted_on_sigquit, :sleeping)
+        Process.sleep(:infinity)
+      end
+
+      test "true", do: :ok
+    end
+
+    configure_and_reload_on_exit(max_cases: 8)
+
+    result =
+      capture_io(fn ->
+        {pid, ref} = spawn_monitor(fn -> ExUnit.run() end)
+        assert_receive :sleeping
+        assert_receive :sleeping
+
+        # We are testing implementation details but since this involves
+        # the signal handler, it is truly the only way to test it.
+        send(pid, {ref, self(), :sigquit})
+
+        receive do
+          ^ref -> :ok
+        end
+      end)
+
+    assert result =~ "Aborting test suite, the following have not completed:"
+    assert result =~ ~r"\* ExUnitTest.SleepOnSetupAll \[.*test/ex_unit_test.exs\]"
+    assert result =~ ~r"\* test true \[.*test/ex_unit_test.exs:#{line}\]"
+
+    assert result =~ """
+           Showing results so far...
+
+           0 tests, 0 failures
+           """
   end
 
-  test "it doesn't hang on exists" do
+  test "doesn't hang on exits" do
     defmodule EventServerTest do
-      use ExUnit.Case, async: false
+      use ExUnit.Case
 
       test "spawn and crash" do
         spawn_link(fn ->
-          exit :foo
+          exit(:foo)
         end)
+
         receive after: (1000 -> :ok)
       end
     end
 
+    configure_and_reload_on_exit([])
+
+    assert capture_io(fn ->
+             assert ExUnit.run() == %{failures: 1, skipped: 0, total: 1, excluded: 0}
+           end) =~ "\n1 test, 1 failure\n"
+  end
+
+  test "reports capture log crashes" do
+    defmodule CaptureLogTest do
+      use ExUnit.Case
+
+      test "capture log crash because logger stopped" do
+        Logger.App.stop()
+        Logger.App.start()
+        flunk("this should fail")
+      end
+    end
+
+    configure_and_reload_on_exit([])
+
     assert capture_io(fn ->
-      assert ExUnit.run == %{failures: 1, total: 1}
-    end) =~ "1 tests, 1 failures"
+             assert ExUnit.run() == %{failures: 1, skipped: 0, total: 1, excluded: 0}
+           end) =~ "\n1 test, 1 failure\n"
+  end
+
+  test "supports timeouts" do
+    defmodule TimeoutTest do
+      use ExUnit.Case
+
+      @tag timeout: 10
+      test "ok" do
+        Process.sleep(:infinity)
+      end
+    end
+
+    output = capture_io(fn -> ExUnit.run() end)
+    assert output =~ "** (ExUnit.TimeoutError) test timed out after 10ms"
+    assert output =~ ~r"\(elixir #{System.version()}\) lib/process\.ex:\d+: Process\.sleep/1"
+  end
+
+  test "supports configured timeout" do
+    defmodule ConfiguredTimeoutTest do
+      use ExUnit.Case
+
+      test "ok" do
+        Process.sleep(:infinity)
+      end
+    end
+
+    ExUnit.configure(timeout: 5)
+    output = capture_io(fn -> ExUnit.run() end)
+    assert output =~ "** (ExUnit.TimeoutError) test timed out after 5ms"
+  after
+    ExUnit.configure(timeout: 60_000)
+  end
+
+  test "reports slow tests" do
+    defmodule SlowestTest do
+      use ExUnit.Case
+
+      test "tardy" do
+        refute false
+      end
+
+      test "delayed" do
+        Process.sleep(5)
+        assert false
+      end
+
+      test "slowest" do
+        Process.sleep(10)
+        refute false
+      end
+    end
+
+    configure_and_reload_on_exit(slowest: 2)
+
+    output = capture_io(fn -> ExUnit.run() end)
+    assert output =~ ~r"Top 2 slowest \(\d+\.\d+s\), \d+.\d% of total time:"
+    assert output =~ ~r"\* test slowest \(.+ms\)"
+    assert output =~ ~r"\* test delayed \(.+ms\)"
+  end
+
+  test "reports slow test modules" do
+    defmodule SlowTestModule do
+      use ExUnit.Case
+
+      test "slow" do
+        refute false
+      end
+    end
+
+    defmodule SlowerTestModule do
+      use ExUnit.Case
+
+      test "slower" do
+        Process.sleep(5)
+        refute false
+      end
+    end
+
+    defmodule SlowestTestModule do
+      use ExUnit.Case
+
+      test "slowest" do
+        Process.sleep(10)
+        refute false
+      end
+    end
+
+    configure_and_reload_on_exit(slowest_modules: 2)
+
+    output = capture_io(fn -> ExUnit.run() end)
+    assert output =~ ~r"Top 2 slowest \(\d+\.\d+s\), \d+.\d% of total time:"
+    assert output =~ ~r"SlowestTestModule \(.+ms\)"
+    assert output =~ ~r"SlowerTestModule \(.+ms\)"
+  end
+
+  test "sets max cases to one with trace enabled" do
+    configure_and_reload_on_exit(trace: true, max_cases: 10)
+    config = ExUnit.configuration()
+    assert config[:trace]
+    assert config[:max_cases] == 1
+    assert config[:timeout] == 60_000
+  end
+
+  test "sets trace when slowest is enabled" do
+    configure_and_reload_on_exit(slowest: 10, max_cases: 10)
+    config = ExUnit.configuration()
+    assert config[:trace]
+    assert config[:slowest] == 10
+    assert config[:max_cases] == 1
+  end
+
+  test "filters to the given test IDs when the :only_test_ids option is provided" do
+    defmodule TestIdTestModule do
+      use ExUnit.Case
+
+      test "passing", do: :ok
+      test "failing", do: assert(1 == 2)
+    end
+
+    test_ids =
+      MapSet.new([
+        {TestIdTestModule, :"test failing"},
+        {TestIdTestModule, :"test missing"},
+        {MissingModule, :"test passing"}
+      ])
+
+    {result, output} = run_with_filter([only_test_ids: test_ids], [])
+    assert result == %{failures: 1, skipped: 0, excluded: 0, total: 1}
+    assert output =~ "\n1 test, 1 failure\n"
   end
 
   test "filtering cases with tags" do
@@ -50,35 +322,964 @@ defmodule ExUnitTest do
       test "one", do: :ok
 
       @tag even: true
-      test "two", do: assert 1 == 2
+      test "two", do: assert(1 == 2)
 
       @tag even: false
       test "three", do: :ok
     end
 
-    test_cases = ExUnit.Server.start_run
+    # Empty because it is already loaded
+    {result, output} = run_with_filter([], [])
+    assert result == %{failures: 1, skipped: 0, total: 4, excluded: 0}
+    assert output =~ "\n4 tests, 1 failure\n"
+
+    {result, output} = run_with_filter([exclude: [even: true]], [ParityTest])
+    assert result == %{failures: 0, skipped: 0, excluded: 1, total: 4}
+    assert output =~ "\n3 tests, 0 failures (1 excluded)\n"
+
+    {result, output} = run_with_filter([exclude: :even], [ParityTest])
+    assert result == %{failures: 0, skipped: 0, excluded: 3, total: 4}
+    assert output =~ "\n1 test, 0 failures (3 excluded)\n"
+
+    {result, output} = run_with_filter([exclude: :even, include: [even: true]], [ParityTest])
+    assert result == %{failures: 1, skipped: 0, excluded: 2, total: 4}
+    assert output =~ "\n2 tests, 1 failure (2 excluded)\n"
+
+    {result, output} = run_with_filter([exclude: :test, include: [even: true]], [ParityTest])
+    assert result == %{failures: 1, skipped: 0, excluded: 3, total: 4}
+    assert output =~ "\n1 test, 1 failure (3 excluded)\n"
+  end
+
+  test "log capturing" do
+    defmodule LogCapturingTest do
+      use ExUnit.Case
+      require Logger
+
+      @tag :capture_log
+      test "one" do
+        Logger.debug("one")
+        assert 1 == 1
+      end
+
+      @tag :capture_log
+      test "two" do
+        Logger.debug("two")
+        assert 1 == 2
+      end
+
+      @tag capture_log: []
+      test "three" do
+        Logger.debug("three")
+        assert 1 == 2
+      end
+    end
+
+    output = capture_io(&ExUnit.run/0)
+    refute output =~ "[debug] one"
+    assert output =~ "[debug] two"
+    assert output =~ "[debug] three"
+  end
+
+  test "supports multi errors" do
+    capture_io(:stderr, fn ->
+      defmodule MultiTest do
+        use ExUnit.Case
+
+        test "multi" do
+          error1 =
+            try do
+              assert 1 = 2
+            rescue
+              e in ExUnit.AssertionError ->
+                {:error, e, __STACKTRACE__}
+            end
+
+          error2 =
+            try do
+              assert 3 > 4
+            rescue
+              e in ExUnit.AssertionError ->
+                {:error, e, __STACKTRACE__}
+            end
+
+          raise ExUnit.MultiError, errors: [error1, error2]
+        end
+      end
+    end)
+
+    configure_and_reload_on_exit([])
+
+    output =
+      capture_io(fn ->
+        assert ExUnit.run() == %{failures: 1, skipped: 0, total: 1, excluded: 0}
+      end)
+
+    assert output =~ "\n1 test, 1 failure\n"
+    assert output =~ "\n  1) test multi (ExUnitTest.MultiTest)\n"
+    assert output =~ "Failure #1\n"
+    assert output =~ "Failure #2\n"
+
+    assert_raise ExUnit.MultiError, ~r/oops/, fn ->
+      stack =
+        try do
+          raise("oops")
+        rescue
+          _ -> __STACKTRACE__
+        end
+
+      error = {:error, RuntimeError.exception("oops"), stack}
+      raise ExUnit.MultiError, errors: [error]
+    end
+  end
+
+  test "raises friendly error for duplicate test names" do
+    message = ~S("test duplicate" is already defined in ExUnitTest.TestWithSameNames)
+
+    assert_raise ArgumentError, message, fn ->
+      defmodule TestWithSameNames do
+        use ExUnit.Case
+
+        test "duplicate" do
+          assert true
+        end
+
+        test "duplicate" do
+          assert true
+        end
+      end
+    end
+  end
+
+  test "produces error on not implemented tests" do
+    defmodule TestNotImplemented do
+      use ExUnit.Case
+
+      setup context do
+        assert context[:not_implemented]
+        :ok
+      end
+
+      test "this is not implemented yet"
+    end
+
+    configure_and_reload_on_exit([])
 
-    assert run_with_filter([], test_cases) ==
-           %{failures: 1, total: 4}
+    output =
+      capture_io(fn ->
+        assert ExUnit.run() == %{failures: 1, skipped: 0, total: 1, excluded: 0}
+      end)
 
-    assert run_with_filter([exclude: [even: true]], test_cases) ==
-           %{failures: 0, total: 3}
+    assert output =~ "Not implemented\n"
+    assert output =~ "\n1 test, 1 failure\n"
+  end
+
+  test "skips tagged test with skip" do
+    defmodule TestSkipped do
+      use ExUnit.Case
+
+      setup context do
+        assert context[:not_implemented]
+        :ok
+      end
+
+      @tag :skip
+      test "this will raise", do: raise("oops")
+
+      @tag skip: "won't work"
+      test "this will also raise", do: raise("oops")
+    end
 
-    assert run_with_filter([exclude: :even], test_cases) ==
-           %{failures: 0, total: 1}
+    configure_and_reload_on_exit([])
 
-    assert run_with_filter([exclude: :even, include: [even: true]], test_cases) ==
-           %{failures: 1, total: 2}
+    output =
+      capture_io(fn ->
+        assert ExUnit.run() == %{failures: 0, skipped: 2, total: 2, excluded: 0}
+      end)
 
-    assert run_with_filter([exclude: :test, include: [even: true]], test_cases) ==
-           %{failures: 1, total: 1}
+    assert output =~ "\n2 tests, 0 failures, 2 skipped\n"
   end
 
-  defp run_with_filter(filters, {async, sync, load_us}) do
-    opts = Keyword.merge(ExUnit.configuration, filters)
-    capture_io fn ->
-      Process.put :capture_result, ExUnit.Runner.run(async, sync, opts, load_us)
+  test "filtering cases with :module tag" do
+    defmodule FirstTestModule do
+      use ExUnit.Case
+      test "ok", do: :ok
+    end
+
+    defmodule SecondTestModule do
+      use ExUnit.Case
+      test "false", do: assert(false)
     end
-    Process.get :capture_result
+
+    # Empty because it is already loaded
+    {result, output} = run_with_filter([exclude: :module], [])
+
+    assert result == %{failures: 0, skipped: 0, excluded: 2, total: 2}
+    assert output =~ "\n0 tests, 0 failures (2 excluded)\n"
+
+    {result, output} =
+      [exclude: :test, include: [module: "ExUnitTest.SecondTestModule"]]
+      |> run_with_filter([FirstTestModule, SecondTestModule])
+
+    assert result == %{failures: 1, skipped: 0, excluded: 1, total: 2}
+    assert output =~ "\n  1) test false (ExUnitTest.SecondTestModule)\n"
+    assert output =~ "\n1 test, 1 failure (1 excluded)\n"
+  end
+
+  test "raises on reserved tag :file in module" do
+    assert_raise RuntimeError, "cannot set tag :file because it is reserved by ExUnit", fn ->
+      defmodule ReservedTagFile do
+        use ExUnit.Case
+
+        @tag file: "oops"
+        test "sample", do: :ok
+      end
+    end
+  end
+
+  test "raises on reserved tag :async in module" do
+    assert_raise RuntimeError, "cannot set tag :async because it is reserved by ExUnit", fn ->
+      defmodule ReservedTagAsync do
+        use ExUnit.Case
+
+        @tag async: true
+        test "sample", do: :ok
+      end
+    end
+  end
+
+  test "raises on reserved tag :file in setup" do
+    defmodule ReservedSetupTagFile do
+      use ExUnit.Case
+
+      setup do
+        {:ok, file: :foo}
+      end
+
+      test "sample", do: :ok
+    end
+
+    configure_and_reload_on_exit([])
+
+    output =
+      capture_io(fn ->
+        assert ExUnit.run() == %{failures: 1, skipped: 0, total: 1, excluded: 0}
+      end)
+
+    assert output =~ "trying to set reserved field :file"
+  end
+
+  test "removes new lines from multiline test name (with --trace option)" do
+    defmodule Multiline do
+      use ExUnit.Case
+
+      test """
+      - line 1
+      - line 2
+      """ do
+        :ok
+      end
+    end
+
+    configure_and_reload_on_exit(trace: true)
+
+    output = capture_io(fn -> ExUnit.run() end)
+
+    assert output =~ "test - line 1 - line 2"
+  end
+
+  test "raises on reserved tag :async in setup" do
+    defmodule ReservedSetupTagAsync do
+      use ExUnit.Case
+
+      setup do
+        {:ok, async: true}
+      end
+
+      test "sample", do: :ok
+    end
+
+    output =
+      capture_io(fn ->
+        assert ExUnit.run() == %{failures: 1, skipped: 0, total: 1, excluded: 0}
+      end)
+
+    assert output =~ "trying to set reserved field :async"
+  end
+
+  test "does not raise on reserved tag in setup_all (lower priority)" do
+    defmodule ReservedSetupAllTag do
+      use ExUnit.Case
+
+      setup_all do
+        {:ok, file: :foo}
+      end
+
+      test "sample", do: :ok
+    end
+
+    capture_io(fn ->
+      assert ExUnit.run() == %{failures: 0, skipped: 0, total: 1, excluded: 0}
+    end)
+  end
+
+  test "seed is predictable and different for each test" do
+    defmodule PredictableSeedTest do
+      use ExUnit.Case, async: true
+
+      test "generated seed is always the same in the same module and test" do
+        assert :rand.uniform(1_000_000) == 253_740
+      end
+
+      test "generated seed is different for other test" do
+        assert :rand.uniform(1_000_000) == 462_665
+      end
+    end
+
+    defmodule DifferentModuleWithDifferentSeedTest do
+      use ExUnit.Case, async: true
+
+      test "generated seed is always the same in the same module and test" do
+        assert :rand.uniform(1_000_000) == 563_517
+      end
+    end
+
+    configure_and_reload_on_exit(seed: 1)
+
+    assert capture_io(fn ->
+             assert ExUnit.run() == %{failures: 0, skipped: 0, total: 3, excluded: 0}
+           end) =~ "\n3 tests, 0 failures\n"
+  end
+
+  # Skipped and excluded tests should be included in the stats
+  # as well as printed to stdout. On the other hand, invalid tests
+  # should be marked as failures in the stats, but still be printed
+  # as "invalid" to stdout.
+  #
+  # If setup_all fails, the skipped and excluded tests should not be
+  # counted as invalid or failures.
+  test "setup_all fails and module has skipped and excluded tests" do
+    defmodule SetupAllFailsModuleHasSkippedExcludedTest do
+      use ExUnit.Case
+
+      setup_all do
+        raise "oops"
+      end
+
+      @tag :skip
+      test "skipped #{__ENV__.line}", do: assert(false)
+
+      test "pass #{__ENV__.line}", do: assert(true)
+      test "pass #{__ENV__.line}", do: assert(true)
+      test "fail #{__ENV__.line}", do: assert(false)
+      test "fail #{__ENV__.line}", do: assert(false)
+
+      @tag :exclude
+      test "excluded #{__ENV__.line}", do: assert(false)
+    end
+
+    configure_and_reload_on_exit([])
+
+    output =
+      capture_io(fn ->
+        assert ExUnit.run() == %{total: 6, failures: 4, excluded: 1, skipped: 1}
+      end)
+
+    refute output =~ max_failures_reached_msg()
+    assert output =~ "\n5 tests, 0 failures, 4 invalid, 1 skipped (1 excluded)\n"
+  end
+
+  test "parameterized tests" do
+    Process.register(self(), :parameterized_tests)
+
+    defmodule ParameterizedTests do
+      use ExUnit.Case, async: true, parameterize: [%{value: true}, %{value: false}]
+
+      @tag :tmp_dir
+      test "hello world", %{value: value, tmp_dir: tmp_dir} do
+        send(:parameterized_tests, {:tmp_dir, tmp_dir})
+        assert value
+      end
+    end
+
+    configure_and_reload_on_exit(trace: true)
+
+    output = capture_io(fn -> ExUnit.run() end)
+
+    assert output =~ ~r"""
+           ExUnitTest.ParameterizedTests \[.*test/ex_unit_test.exs\]
+           Parameters: %\{value: false\}
+           """
+
+    assert output =~ """
+             1) test hello world (ExUnitTest.ParameterizedTests)
+                Parameters: %{value: false}
+           """
+
+    # Check that the temporary paths are different
+    assert_receive {:tmp_dir, tmp_dir1}
+    assert_receive {:tmp_dir, tmp_dir2} when tmp_dir1 != tmp_dir2
+  end
+
+  test "empty parameterized tests" do
+    defmodule EmptyParameterizedTests do
+      use ExUnit.Case, async: true, parameterize: []
+
+      test "hello world" do
+        assert false
+      end
+    end
+
+    configure_and_reload_on_exit(trace: true)
+    assert capture_io(fn -> ExUnit.run() end) =~ "0 tests"
+
+    defmodule EmptyGroupedParameterizedTests do
+      use ExUnit.Case, async: true, parameterize: [], group: :example
+
+      test "hello world" do
+        assert false
+      end
+    end
+
+    configure_and_reload_on_exit(trace: true)
+    assert capture_io(fn -> ExUnit.run() end) =~ "0 tests"
+  end
+
+  describe "after_suite/1" do
+    test "executes all callbacks set in reverse order" do
+      Process.register(self(), :after_suite_test_process)
+
+      defmodule MultipleAfterSuiteTest do
+        use ExUnit.Case
+
+        test "true" do
+          send(:after_suite_test_process, :in_first_test)
+        end
+      end
+
+      ExUnit.after_suite(fn _ -> send(:after_suite_test_process, :first_after_suite) end)
+      ExUnit.after_suite(fn result -> send(:after_suite_test_process, result) end)
+      ExUnit.after_suite(fn _ -> send(:after_suite_test_process, :third_after_suite) end)
+
+      capture_io(fn -> ExUnit.run() end)
+
+      # Because `after_suite` is global, we need to be sure to clear out the
+      # test callbacks here, otherwise it will attempt to execute them after
+      # every subsequent call to `ExUnit.run()` in any tests run after these.
+      Application.put_env(:ex_unit, :after_suite, [])
+
+      assert next_message_in_mailbox() == :in_first_test
+      assert next_message_in_mailbox() == :third_after_suite
+      assert next_message_in_mailbox() == %{excluded: 0, failures: 0, skipped: 0, total: 1}
+      assert next_message_in_mailbox() == :first_after_suite
+      # Check to make sure the mailbox is empty after these four messages
+      refute_received _
+    end
+  end
+
+  describe ":max_failures" do
+    test "default value to :infinity" do
+      configure_and_reload_on_exit([])
+      ExUnit.start(autorun: false)
+      config = ExUnit.configuration()
+      assert config[:max_failures] == :infinity
+    end
+
+    test "sets value of :max_failures" do
+      configure_and_reload_on_exit([])
+      ExUnit.start(max_failures: 5, autorun: false)
+      config = ExUnit.configuration()
+      assert config[:max_failures] == 5
+    end
+
+    test ":max_failures are reached" do
+      defmodule TestMaxFailuresReached do
+        use ExUnit.Case
+
+        @tag :skip
+        test "skipped #{__ENV__.line}", do: assert(false)
+
+        test __ENV__.line, do: assert(true)
+        test __ENV__.line, do: assert(true)
+        test __ENV__.line, do: assert(false)
+        test __ENV__.line, do: assert(false)
+        test __ENV__.line, do: assert(true)
+
+        @tag :exclude
+        test "excluded #{__ENV__.line}", do: assert(false)
+      end
+
+      configure_and_reload_on_exit(max_failures: 2)
+
+      output =
+        capture_io(fn ->
+          assert ExUnit.run() == %{total: 6, failures: 2, skipped: 1, excluded: 1}
+        end)
+
+      assert output =~ max_failures_reached_msg()
+      assert output =~ "\n5 tests, 2 failures, 1 skipped (1 excluded)\n"
+    end
+
+    test ":max_failures is not reached" do
+      defmodule TestMaxFailuresNotReached do
+        use ExUnit.Case
+
+        @tag :skip
+        test "skipped #{__ENV__.line}", do: assert(true)
+
+        test "pass #{__ENV__.line}", do: assert(true)
+        test "fail #{__ENV__.line}", do: assert(false)
+        test "pass #{__ENV__.line}", do: assert(true)
+        test "fail #{__ENV__.line}", do: assert(false)
+        test "pass #{__ENV__.line}", do: assert(true)
+
+        @tag :exclude
+        test "excluded #{__ENV__.line}", do: assert(true)
+
+        @tag :exclude
+        test "excluded #{__ENV__.line}", do: assert(false)
+      end
+
+      configure_and_reload_on_exit(max_failures: 3)
+
+      output =
+        capture_io(fn ->
+          assert ExUnit.run() == %{total: 8, excluded: 2, failures: 2, skipped: 1}
+        end)
+
+      refute output =~ max_failures_reached_msg()
+      assert output =~ "\n6 tests, 2 failures, 1 skipped (2 excluded)\n"
+    end
+
+    test ":max_failures has been reached" do
+      defmodule TestMaxFailuresAlreadyReached do
+        use ExUnit.Case
+
+        @tag :skip
+        test "skipped #{__ENV__.line}", do: assert(true)
+
+        @tag :skip
+        test "skipped #{__ENV__.line}", do: assert(false)
+
+        test "pass #{__ENV__.line}", do: assert(true)
+        test "fail #{__ENV__.line}", do: assert(false)
+        test "fail #{__ENV__.line}", do: assert(false)
+        test "fail #{__ENV__.line}", do: assert(false)
+        test "pass #{__ENV__.line}", do: assert(true)
+
+        @tag :exclude
+        test "excluded #{__ENV__.line}", do: assert(true)
+
+        @tag :exclude
+        test "excluded #{__ENV__.line}", do: assert(true)
+      end
+
+      configure_and_reload_on_exit(max_failures: 2)
+
+      output =
+        capture_io(fn ->
+          assert ExUnit.run() == %{total: 7, failures: 2, excluded: 2, skipped: 2}
+        end)
+
+      assert output =~ max_failures_reached_msg()
+      assert output =~ "\n5 tests, 2 failures, 2 skipped (2 excluded)\n"
+    end
+
+    # Excluded and skipped tests are detected before setup_all
+    # callback is executed, therefore they are always included
+    # as part of the total number of tests in the stats.
+    test ":max_failures on setup_all errors" do
+      defmodule TestMaxFailuresSetupAll do
+        use ExUnit.Case
+
+        setup_all do
+          raise "oops"
+        end
+
+        @tag :skip
+        test "skipped #{__ENV__.line}", do: assert(true)
+
+        test "pass #{__ENV__.line}", do: assert(true)
+        test "pass #{__ENV__.line}", do: assert(true)
+        test "fail #{__ENV__.line}", do: assert(false)
+        test "fail #{__ENV__.line}", do: assert(false)
+
+        @tag :exclude
+        test "excluded #{__ENV__.line}", do: assert(false)
+      end
+
+      configure_and_reload_on_exit(max_failures: 2)
+
+      output =
+        capture_io(fn ->
+          assert ExUnit.run() == %{total: 4, failures: 2, excluded: 1, skipped: 1}
+        end)
+
+      assert output =~ max_failures_reached_msg()
+      assert output =~ "\n3 tests, 0 failures, 2 invalid, 1 skipped (1 excluded)\n"
+    end
+
+    test ":max_failures flushes all async/sync cases" do
+      defmodule TestMaxFailuresAsync1 do
+        use ExUnit.Case, async: true
+        test "error", do: assert(false)
+      end
+
+      defmodule TestMaxFailuresAsync2 do
+        use ExUnit.Case, async: true
+        test "error", do: assert(false)
+      end
+
+      defmodule TestMaxFailuresSync do
+        use ExUnit.Case
+        test "error", do: assert(false)
+      end
+
+      configure_and_reload_on_exit(max_failures: 1)
+
+      output =
+        capture_io(fn ->
+          assert ExUnit.run() == %{total: 1, failures: 1, excluded: 0, skipped: 0}
+        end)
+
+      assert output =~ max_failures_reached_msg()
+      assert output =~ "\n1 test, 1 failure\n"
+
+      capture_io(fn ->
+        assert ExUnit.run() == %{total: 0, failures: 0, excluded: 0, skipped: 0}
+      end)
+    end
+
+    test "warns and errors when context is not a map" do
+      assert capture_io(:stderr, fn ->
+               defmodule ContextTest do
+                 use ExUnit.Case, async: true
+
+                 test "I made a typo", conn: conn do
+                   assert true
+                 end
+               end
+             end) =~ "test context is always a map. The pattern \"[conn: conn]\" will never match"
+
+      configure_and_reload_on_exit([])
+
+      assert capture_io(fn ->
+               assert ExUnit.run() == %{failures: 1, skipped: 0, total: 1, excluded: 0}
+             end) =~ "** (FunctionClauseError) no function clause matching"
+    end
+  end
+
+  describe ":exit_status" do
+    test "defaults value to 2" do
+      configure_and_reload_on_exit([])
+      ExUnit.start(autorun: false)
+      config = ExUnit.configuration()
+      assert config[:exit_status] == 2
+    end
+
+    test "sets value of :exit_status" do
+      configure_and_reload_on_exit([])
+      ExUnit.start(exit_status: 5, autorun: false)
+      config = ExUnit.configuration()
+      assert config[:exit_status] == 5
+    end
+  end
+
+  describe ":repeat_until_failure" do
+    test "defaults to 0" do
+      configure_and_reload_on_exit([])
+      ExUnit.start(autorun: false)
+      config = ExUnit.configuration()
+      assert config[:repeat_until_failure] == 0
+    end
+
+    test "sets value of :repeat_until_failure" do
+      configure_and_reload_on_exit([])
+      ExUnit.start(repeat_until_failure: 5, autorun: false)
+      config = ExUnit.configuration()
+      assert config[:repeat_until_failure] == 5
+    end
+
+    test "repeats tests up to the configured number of times" do
+      defmodule TestRepeatUntilFailureReached do
+        use ExUnit.Case
+
+        @tag :skip
+        test "skipped #{__ENV__.line}", do: assert(false)
+
+        test __ENV__.line, do: assert(true)
+        test __ENV__.line, do: assert(true)
+        test __ENV__.line, do: assert(true)
+
+        @tag :exclude
+        test "excluded #{__ENV__.line}", do: assert(false)
+      end
+
+      configure_and_reload_on_exit(repeat_until_failure: 5)
+
+      output =
+        capture_io(fn ->
+          assert ExUnit.run() == %{total: 5, failures: 0, skipped: 1, excluded: 1}
+        end)
+
+      runs = String.split(output, "Running ExUnit", trim: true)
+      # 6 runs in total, 5 repeats
+      assert length(runs) == 6
+    end
+
+    test "repeats tests up to the configured number of times with groups" do
+      defmodule TestGroupedRepeatUntilFailureReached do
+        use ExUnit.Case, async: true, group: :example
+        test __ENV__.line, do: assert(true)
+      end
+
+      configure_and_reload_on_exit(repeat_until_failure: 5)
+
+      output =
+        capture_io(fn ->
+          assert ExUnit.run() == %{total: 1, failures: 0, skipped: 0, excluded: 0}
+        end)
+
+      runs = String.split(output, "Running ExUnit", trim: true)
+      # 6 runs in total, 5 repeats
+      assert length(runs) == 6
+    end
+
+    test "stops on failure" do
+      {:ok, pid} = Agent.start_link(fn -> 0 end)
+      Process.register(pid, :ex_unit_repeat_until_failure_count)
+
+      defmodule TestRepeatUntilFailureFailure do
+        use ExUnit.Case
+
+        @tag :skip
+        test "skipped #{__ENV__.line}", do: assert(true)
+
+        test "maybe pass #{__ENV__.line}" do
+          count = Agent.get(:ex_unit_repeat_until_failure_count, & &1)
+
+          if count < 3 do
+            Agent.update(:ex_unit_repeat_until_failure_count, &(&1 + 1))
+            assert(true)
+          else
+            assert(false)
+          end
+        end
+
+        @tag :exclude
+        test "excluded #{__ENV__.line}", do: assert(true)
+
+        @tag :exclude
+        test "excluded #{__ENV__.line}", do: assert(false)
+      end
+
+      configure_and_reload_on_exit(repeat_until_failure: 5)
+
+      output =
+        capture_io(fn ->
+          assert ExUnit.run() == %{total: 4, excluded: 2, failures: 1, skipped: 1}
+        end)
+
+      runs = String.split(output, "Running ExUnit", trim: true)
+      # four runs in total, the first two repeats work fine, the third repeat (4th run)
+      # fails, therefore we stop
+      assert length(runs) == 4
+      assert List.last(runs) =~ "Expected truthy, got false"
+    end
+  end
+
+  test "prints warning when all tests are excluded" do
+    defmodule OnlyExcludedTests do
+      use ExUnit.Case
+
+      @tag :exclude
+      test "excluded test", do: assert(false)
+
+      @tag :exclude
+      test "one more excluded test", do: assert(false)
+    end
+
+    configure_and_reload_on_exit([])
+
+    output =
+      capture_io(fn ->
+        assert ExUnit.run() == %{total: 2, failures: 0, excluded: 2, skipped: 0}
+      end)
+
+    assert output =~ "All tests have been excluded.\n"
+    assert output =~ "0 tests, 0 failures (2 excluded)\n"
+  end
+
+  test "tests are run in compile order (FIFO)" do
+    defmodule FirstTestFIFO do
+      use ExUnit.Case
+
+      test "first test" do
+        assert true
+      end
+    end
+
+    defmodule SecondTestFIFO do
+      use ExUnit.Case
+
+      test "second test" do
+        assert true
+      end
+    end
+
+    defmodule ThirdTestFIFO do
+      use ExUnit.Case
+
+      test "third test" do
+        assert true
+      end
+    end
+
+    configure_and_reload_on_exit(trace: true)
+
+    output =
+      capture_io(fn ->
+        assert ExUnit.run() == %{total: 3, failures: 0, excluded: 0, skipped: 0}
+      end)
+
+    [_, first, second, third | _] = String.split(output, "\n\n")
+
+    assert first =~ "FirstTestFIFO"
+    assert second =~ "SecondTestFIFO"
+    assert third =~ "ThirdTestFIFO"
+  end
+
+  test "groups are run in compile order (FIFO)" do
+    defmodule RedOneFIFO do
+      use ExUnit.Case, async: true, group: :red
+
+      test "red one test" do
+        Process.sleep(5)
+        assert true
+      end
+    end
+
+    defmodule BlueOneFIFO do
+      use ExUnit.Case, async: true, group: :blue
+
+      test "blue one test" do
+        Process.sleep(5)
+        assert true
+      end
+    end
+
+    defmodule RedTwoFIFO do
+      use ExUnit.Case, async: true, group: :red
+
+      test "red two test" do
+        assert true
+      end
+    end
+
+    defmodule BlueTwoFIFO do
+      use ExUnit.Case, async: true, group: :blue
+
+      test "blue two test" do
+        assert true
+      end
+    end
+
+    configure_and_reload_on_exit(trace: true, max_cases: 2)
+
+    output =
+      capture_io(fn ->
+        assert ExUnit.run() == %{total: 4, failures: 0, excluded: 0, skipped: 0}
+      end)
+
+    [_, first, second, third, fourth | _] = String.split(output, "\n\n")
+
+    assert first =~ "RedOneFIFO"
+    assert second =~ "RedTwoFIFO"
+    assert third =~ "BlueOneFIFO"
+    assert fourth =~ "BlueTwoFIFO"
+  end
+
+  test "filters async tests" do
+    defmodule FirstTestAsyncTrue do
+      use ExUnit.Case, async: true
+
+      test "first test" do
+        assert true
+      end
+    end
+
+    defmodule SecondTestAsyncTrue do
+      use ExUnit.Case, async: true
+
+      test "second test" do
+        assert true
+      end
+    end
+
+    defmodule FirstTestAsyncFalse do
+      use ExUnit.Case, async: false
+
+      test "first test" do
+        assert true
+      end
+    end
+
+    assert {%{failures: 0, skipped: 0, total: 3, excluded: 1}, _} =
+             run_with_filter([include: [async: true], exclude: [:test]], [])
+
+    assert {%{failures: 0, skipped: 0, total: 3, excluded: 2}, _} =
+             run_with_filter(
+               [include: [async: false], exclude: [:test]],
+               [FirstTestAsyncTrue, SecondTestAsyncTrue, FirstTestAsyncFalse]
+             )
+  end
+
+  ##  Helpers
+
+  defp run_with_filter(filters, cases) do
+    Enum.each(cases, fn mod ->
+      ExUnit.Server.add_module(mod, mod.__ex_unit__(:config))
+    end)
+
+    ExUnit.Server.modules_loaded(false)
+
+    opts =
+      ExUnit.configuration()
+      |> Keyword.merge(filters)
+      |> Keyword.merge(colors: [enabled: false])
+
+    with_io(fn -> ExUnit.Runner.run(opts, nil) |> elem(0) end)
+  end
+
+  defp next_message_in_mailbox() do
+    receive do
+      msg -> msg
+    after
+      0 -> nil
+    end
+  end
+
+  test "sets process label for each test" do
+    # TODO: Remove check once we support Erlang/OTP 27+
+    if function_exported?(:proc_lib, :get_label, 1) do
+      label = apply(:proc_lib, :get_label, [self()])
+      assert label == {ExUnitTest, :"test sets process label for each test"}
+    end
+  end
+
+  defp configure_and_reload_on_exit(opts) do
+    old_opts = ExUnit.configuration()
+
+    ExUnit.configure(
+      Keyword.merge(
+        [autorun: false, seed: 0, colors: [enabled: false], exclude: [:exclude]],
+        opts
+      )
+    )
+
+    on_exit(fn -> ExUnit.configure(old_opts) end)
+  end
+
+  defp max_failures_reached_msg() do
+    "--max-failures reached, aborting test suite"
   end
 end
diff --git a/lib/ex_unit/test/fixtures/failing.md b/lib/ex_unit/test/fixtures/failing.md
new file mode 100644
index 00000000000..ba2530c4979
--- /dev/null
+++ b/lib/ex_unit/test/fixtures/failing.md
@@ -0,0 +1,4 @@
+# Example
+
+    iex> 1 + 2
+    4
diff --git a/lib/ex_unit/test/fixtures/passing.md b/lib/ex_unit/test/fixtures/passing.md
new file mode 100644
index 00000000000..3c8329bd25b
--- /dev/null
+++ b/lib/ex_unit/test/fixtures/passing.md
@@ -0,0 +1,7 @@
+# Example
+
+    iex> 1 + 2
+    3
+
+    iex> 2 + 3
+    5
diff --git a/lib/ex_unit/test/test_helper.exs b/lib/ex_unit/test/test_helper.exs
index 3633e26c6e6..3ed3e6894a3 100644
--- a/lib/ex_unit/test/test_helper.exs
+++ b/lib/ex_unit/test/test_helper.exs
@@ -1,15 +1,16 @@
-ExUnit.start [trace: "--trace" in System.argv]
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-# Beam files compiled on demand
-path = Path.expand("../tmp/beams", __DIR__)
-File.rm_rf!(path)
-File.mkdir_p!(path)
-Code.prepend_path(path)
+{line_exclude, line_include} =
+  if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
 
-defmodule ExUnit.TestHelpers do
-  def write_beam({:module, name, bin, _} = res) do
-    beam_path = Path.join(unquote(path), Atom.to_string(name) <> ".beam")
-    File.write!(beam_path, bin)
-    res
-  end
-end
+Code.require_file("../../elixir/scripts/cover_record.exs", __DIR__)
+CoverageRecorder.maybe_record("ex_unit")
+
+ExUnit.start(
+  trace: !!System.get_env("TRACE"),
+  include: line_include,
+  exclude: line_exclude,
+  assert_receive_timeout: String.to_integer(System.get_env("ELIXIR_ASSERT_TIMEOUT", "300"))
+)
diff --git a/lib/iex/lib/iex.ex b/lib/iex/lib/iex.ex
index e104879bc46..52ead574c14 100644
--- a/lib/iex/lib/iex.ex
+++ b/lib/iex/lib/iex.ex
@@ -1,11 +1,12 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule IEx do
   @moduledoc ~S"""
   Elixir's interactive shell.
 
-  This module is the main entry point for Interactive Elixir and
-  in this documentation we will talk a bit about how IEx works.
-
-  Notice that some of the functionality described here will not be available
+  Some of the functionalities described here will not be available
   depending on your terminal. In particular, if you get a message
   saying that the smart terminal could not be run, some of the
   features described here won't work.
@@ -15,23 +16,217 @@ defmodule IEx do
   IEx provides a bunch of helpers. They can be accessed by typing
   `h()` into the shell or as a documentation for the `IEx.Helpers` module.
 
-  ## The Break command
+  ## Autocomplete
+
+  To discover a module's public functions or other modules, type the module name
+  followed by a dot, then press tab to trigger autocomplete. For example:
+
+      Enum.
+
+  A module may export functions that are not meant to be used directly:
+  these functions won't be autocompleted by IEx. IEx will not autocomplete
+  functions annotated with `@doc false`, `@impl true`, or functions that
+  aren't explicitly documented and where the function name is in the form
+  of `__foo__`.
+
+  Autocomplete is available by default on Windows shells from Erlang/OTP 26.
+
+  ## Encoding and coloring
+
+  IEx expects inputs and outputs to be in UTF-8 encoding. This is the
+  default for most Unix terminals but it may not be the case on Windows.
+  If you are running on Windows and you see incorrect values printed,
+  you may need to change the encoding of your current session by running
+  `chcp 65001` before calling `iex` (or before calling `iex.bat` if using
+  PowerShell).
+
+  Similarly, ANSI coloring is enabled by default on most Unix terminals.
+  They are also available on Windows consoles from Windows 10 and on
+  Erlang/OTP 26 or later. For earlier Erlang/OTP versions, you can
+  explicitly enable it for the current user in the registry by running
+  the following command:
+
+      $ reg add HKCU\Console /v VirtualTerminalLevel /t REG_DWORD /d 1
+
+  After running the command above, you must restart your current console.
+
+  ## Shell history
+
+  It is possible to get shell history by passing some options that enable it
+  in the VM. This can be done on a per-need basis when starting IEx:
+
+      $ iex --erl "-kernel shell_history enabled"
+
+  If you would rather enable it on your system as a whole, you can use
+  the `ERL_AFLAGS` environment variable and make sure that it is set
+  accordingly on your terminal/shell configuration.
+
+  On Unix-like / Bash:
+
+      $ export ERL_AFLAGS="-kernel shell_history enabled"
+
+  On Windows:
+
+      $ set ERL_AFLAGS "-kernel shell_history enabled"
+
+  On Windows 10 / PowerShell:
+
+      $ $env:ERL_AFLAGS = "-kernel shell_history enabled"
+
+  ## Expressions in IEx
+
+  As an interactive shell, IEx evaluates expressions. This has some
+  interesting consequences that are worth discussing.
+
+  The first one is that the code is truly evaluated and not compiled.
+  This means that any benchmarking done in the shell is going to have
+  skewed results. So never run any profiling nor benchmarks in the shell.
+
+  Second, IEx allows you to break an expression into many lines,
+  since this is common in Elixir. For example:
+
+      iex(1)> "ab
+      ...(1)> c"
+      "ab\nc"
+
+  In the example above, the shell will be expecting more input until it
+  finds the closing quote. Sometimes it is not obvious which character
+  the shell is expecting, and the user may find themselves trapped in
+  the state of incomplete expression with no ability to terminate it other
+  than by exiting the shell.
+
+  For such cases, there is a special break-trigger (`#iex:break`) that when
+  encountered on a line by itself will force the shell to break out of any
+  pending expression and return to its normal state:
+
+      iex(1)> ["ab
+      ...(1)> c"
+      ...(1)> "
+      ...(1)> ]
+      ...(1)> #iex:break
+      ** (TokenMissingError) iex:1: incomplete expression
+
+  ## Pasting multiline expressions into IEx
+
+  IEx evaluates its input line by line in an eager fashion. If at the end of a
+  line the code seen so far is a complete expression, IEx will evaluate it at
+  that point.
+
+      iex(1)> [1, [2], 3]
+      [1, [2], 3]
+
+  To prevent this behavior breaking valid code where the subsequent line
+  begins with a binary operator, such as `|>/2` or `++/2` , IEx automatically
+  treats such lines as if they were prepended with `IEx.Helpers.v/0`, which
+  returns the value of the previous expression, if available.
+
+      iex(1)> [1, [2], 3]
+      [1, [2], 3]
+      iex(2)> |> List.flatten()
+      [1, 2, 3]
+
+  The above is equivalent to:
+
+      iex(1)> [1, [2], 3]
+      [1, [2], 3]
+      iex(2)> v() |> List.flatten()
+      [1, 2, 3]
+
+  If there are no previous expressions in the history, the pipe operator will
+  fail:
+
+      iex(1)> |> List.flatten()
+      ** (RuntimeError) v(-1) is out of bounds
+
+  If the previous expression was a match operation, the pipe operator will also
+  fail, to prevent an unsolicited break of the match:
+
+      iex(1)> x = 42
+      iex(2)> |> IO.puts()
+      ** (SyntaxError) iex:2:1: pipe shorthand is not allowed immediately after a match expression in IEx. To make it work, surround the whole pipeline with parentheses ('|>')
+          |
+        2 | |> IO.puts()
+          | ^
+
+  Note, however, the above does not work for `+/2` and `-/2`, as they
+  are ambiguous with the unary `+/1` and `-/1`:
+
+      iex(1)> 1
+      1
+      iex(2)> + 2
+      2
+
+  ## The BREAK menu
 
   Inside IEx, hitting `Ctrl+C` will open up the `BREAK` menu. In this
-  menu you can quit the shell, see process and ets tables information
+  menu you can quit the shell, see process and ETS tables information
   and much more.
 
-  ## The User Switch command
+  ## Exiting the shell
+
+  There are a few ways to quit the IEx shell:
+
+    * via the `BREAK` menu (available via `Ctrl+C`) by typing `q`, pressing enter
+    * by hitting `Ctrl+C`, `Ctrl+C`
+    * by hitting `Ctrl+\ `
+
+  If you are connected to remote shell, it remains alive after disconnection.
+
+  ## `dbg` and breakpoints
+
+  IEx integrates with `Kernel.dbg/2` and introduces a backend that
+  can pause code execution. To enable it, you must pass `--dbg pry`:
+
+      $ iex --dbg pry
+
+  For example, take the following function:
+
+      def my_fun(arg1, arg2) do
+        dbg(arg1 + arg2)
+        ... implementation ...
+      end
+
+  When the code is executed with `iex` (most often by calling
+  `iex --dbg pry -S mix`), it will ask you permission to use "pry".
+  If you agree, it will start an IEx shell in the context of the function
+  above, with access to its variables, imports, and aliases. However,
+  you can only access existing values, it is not possible to access
+  private functions nor change the execution itself (hence the name
+  "pry").
+
+  When using `|> dbg()` at the end of a pipeline, you can pry each
+  step of the pipeline. You can type `n` whenever you want to jump
+  into the next pipe. Type `continue` when you want to execute all
+  of the steps but stay within the pried process. Type `respawn` when
+  you want to leave the pried process and start a new shell.
+
+  Alternatively, you can start a pry session directly, without `dbg/2`
+  by calling `IEx.pry/0`.
+
+  IEx also allows you to set breakpoints to start pry sessions
+  on a given module, function, and arity you have no control of
+  via `IEx.break!/4`. Similar to pipelines in `dbg()`, `IEx.break!/4`
+  allows you to debug a function line by line and access its variables.
+  However, breakpoints do not contain information about imports and
+  aliases from the source code.
+
+  When using `dbg` or breakpoints with tests, remember to pass the
+  `--trace` to `mix test` to avoid running into timeouts:
 
-  Besides the break command, one can type `Ctrl+G` to get to the
-  user switch command menu. When reached, you can type `h` to
+      $ iex -S mix test --trace
+      $ iex -S mix test path/to/file:line --trace
+
+  ## The User switch command
+
+  Besides the `BREAK` menu, one can type `Ctrl+G` to get to the
+  `User switch command` menu. When reached, you can type `h` to
   get more information.
 
   In this menu, developers are able to start new shells and
   alternate between them. Let's give it a try:
 
       User switch command
-       --> s 'Elixir.IEx'
+       --> s iex
        --> c
 
   The command above will start a new shell and connect to it.
@@ -47,14 +242,22 @@ defmodule IEx do
   Now, try to access the `hello` variable again:
 
       hello
-      ** (UndefinedFunctionError) undefined function: hello/0
+      ** (CompileError) undefined variable "hello"
 
   The command above fails because we have switched shells.
   Since shells are isolated from each other, you can't access the
   variables defined in one shell from the other one.
 
-  The user switch command menu also allows developers to connect to remote
-  shells using the `r` command. A topic which we will discuss next.
+  The `User switch command` can also be used to terminate an existing
+  session, for example when the evaluator gets stuck in an infinite
+  loop or when you are stuck typing an expression:
+
+      User switch command
+       --> i
+       --> c
+
+  The `User switch command` menu also allows developers to connect to
+  remote shells using the `r` command. A topic which we will discuss next.
 
   ## Remote shells
 
@@ -62,13 +265,13 @@ defmodule IEx do
   First of all, we can only connect to a shell if we give names
   both to the current shell and the shell we want to connect to.
 
-  Let's give it a try. First start a new shell:
+  Let's give it a try. First, start a new shell:
 
       $ iex --sname foo
       iex(foo@HOST)1>
 
-  The string in between parenthesis in the prompt is the name
-  of your node. We can retrieve it by calling the `node()`
+  The string between the parentheses in the prompt is the name
+  of your node. We can retrieve it by calling the `node/0`
   function:
 
       iex(foo@HOST)1> node()
@@ -87,14 +290,14 @@ defmodule IEx do
       $ iex --sname bar
       iex(bar@HOST)1>
 
-  If we try to dispatch to `Hello.world`, it won't be available
+  If we try to dispatch to `Hello.world/0`, it won't be available
   as it was defined only in the other shell:
 
-      iex(bar@HOST)1> Hello.world
-      ** (UndefinedFunctionError) undefined function: Hello.world/0
+      iex(bar@HOST)1> Hello.world()
+      ** (UndefinedFunctionError) undefined function Hello.world/0
 
   However, we can connect to the other shell remotely. Open up
-  the User Switch prompt (Ctrl+G) and type:
+  the `User switch command` prompt (Ctrl+G) and type:
 
       User switch command
        --> r 'foo@HOST' 'Elixir.IEx'
@@ -103,8 +306,8 @@ defmodule IEx do
   Now we are connected into the remote node, as the prompt shows us,
   and we can access the information and modules defined over there:
 
-      rem(foo@macbook)1> Hello.world
-      "it works"
+      iex(foo@HOST)1> Hello.world()
+      "it works!"
 
   In fact, connecting to remote shells is so common that we provide
   a shortcut via the command line as well:
@@ -113,107 +316,170 @@ defmodule IEx do
 
   Where "remsh" means "remote shell". In general, Elixir supports:
 
-    * remsh from an elixir node to an elixir node
-    * remsh from a plain erlang node to an elixir node (through the ^G menu)
-    * remsh from an elixir node to a plain erlang node (and get an erl shell there)
+    * remsh from an Elixir node to an Elixir node
+    * remsh from a plain Erlang node to an Elixir node (through the ^G menu)
+    * remsh from an Elixir node to a plain Erlang node (and get an `erl` shell there)
 
   Connecting an Elixir shell to a remote node without Elixir is
   **not** supported.
 
+  When remsh halts, the Elixir shell process exits with reason `:normal`.
+
   ## The .iex.exs file
 
-  When starting IEx, it will look for a local `.iex.exs` file (located in the current
-  working directory), then a global one (located at `~/.iex.exs`) and will load the
-  first one it finds (if any). The code in the chosen .iex file will be
-  evaluated in the shell's context. So, for instance, any modules that are
-  loaded or variables that are bound in the .iex file will be available in the
-  shell after it has booted.
+  When starting, IEx looks for a configured path, then for a local `.iex.exs` file
+  (located in the current working directory), then for a global `.iex.exs` file
+  located inside the directory pointed by the `IEX_HOME` environment variable
+  (which defaults to `~`) and loads the first one it finds (if any).
 
-  Sample contents of a local .iex file:
+  The code in the chosen `.iex.exs` file is evaluated line by line in the shell's
+  context, as if each line were being typed in the shell. For instance, any modules
+  that are loaded or variables that are bound in the `.iex.exs` file will be available
+  in the shell after it has booted.
 
-      # source another `.iex` file
-      import_file "~/.iex.exs"
+  Take the following `.iex.exs` file:
 
-      # print something before the shell starts
-      IO.puts "hello world"
+      # Load another ".iex.exs" file
+      import_file("~/.iex.exs")
 
-      # bind a variable that'll be accessible in the shell
+      # Import some module from lib that may not yet have been defined
+      import_if_available(MyApp.Mod)
+
+      # Print something before the shell starts
+      IO.puts("hello world")
+
+      # Bind a variable that'll be accessible in the shell
       value = 13
 
-  Running the shell in the directory where the above .iex file is located
+  Running IEx in the directory where the above `.iex.exs` file is located
   results in:
 
       $ iex
-      Erlang 17 [...]
+      Erlang/OTP 24 [...]
 
       hello world
       Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)
       iex(1)> value
       13
 
-  It is possible to load another file by supplying the `--dot-iex`
-  option to iex. See `iex --help`.
+  It is possible to load another file by configuring the `iex` application's `dot_iex`
+  value (`config :iex, dot_iex: "PATH"` or `IEx.configure(dot_iex: "PATH")`)
+  or supplying the `--dot-iex` option to IEx. See `iex --help`.
+
+  In case of remote nodes, the location of the `.iex.exs` files are taken
+  relative to the user that started the application, not to the user that
+  is connecting to the node in case of remote IEx connections.
 
   ## Configuring the shell
 
-  There are a number of customization options provided by the shell. Take a look
+  There are a number of customization options provided by IEx. Take a look
   at the docs for the `IEx.configure/1` function by typing `h IEx.configure/1`.
 
   Those options can be configured in your project configuration file or globally
-  by calling `IEx.configure/1` from your `~/.iex.exs` file like this:
+  by calling `IEx.configure/1` from your `~/.iex.exs` file. For example:
 
-      # .iex
+      # .iex.exs
       IEx.configure(inspect: [limit: 3])
 
-      ### now run the shell ###
+  Now run the shell:
 
       $ iex
-      Erlang 17 (erts-5.10.1) [...]
+      Erlang/OTP 24 [...]
 
       Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)
       iex(1)> [1, 2, 3, 4, 5]
-      [1,2,3,...]
-
-  ## Expressions in IEx
-
-  As an interactive shell, IEx evaluates expressions. This has some
-  interesting consequences that are worth discussing.
-
-  The first one is that the code is truly evaluated and not compiled.
-  This means that any benchmarking done in the shell is going to have
-  skewed results. So never run any profiling nor benchmarks in the shell.
-
-  Second, IEx allows you to break an expression into many lines,
-  since this is common in Elixir. For example:
-
-      iex(1)> "ab
-      ...(1)> c"
-      "ab\nc"
-
-  In the example above, the shell will be expecting more input until it
-  finds the closing quote. Sometimes it is not obvious which character
-  the shell is expecting, and the user may find themselves trapped in
-  the state of incomplete expression with no ability to terminate it other
-  than by exiting the shell.
-
-  For such cases, there is a special break-trigger (`#iex:break`) that when
-  encountered on a line by itself will force the shell to break out of any
-  pending expression and return to its normal state:
+      [1, 2, 3, ...]
 
-      iex(1)> ["ab
-      ...(1)> c"
-      ...(1)> "
-      ...(1)> ]
-      ...(1)> #iex:break
-      ** (TokenMissingError) iex:1: incomplete expression
+  """
 
+  @typedoc """
+  Color settings used by the IEx shell.
+  """
+  @type colors_opts :: [
+          enabled: boolean(),
+          eval_result: IO.ANSI.ansidata(),
+          eval_info: IO.ANSI.ansidata(),
+          eval_error: IO.ANSI.ansidata(),
+          eval_interrupt: IO.ANSI.ansidata(),
+          stack_info: IO.ANSI.ansidata(),
+          blame_diff: IO.ANSI.ansidata(),
+          ls_directory: IO.ANSI.ansidata(),
+          ls_device: IO.ANSI.ansidata(),
+          doc_code: IO.ANSI.ansidata(),
+          doc_inline_code: IO.ANSI.ansidata(),
+          doc_headings: IO.ANSI.ansidata(),
+          doc_title: IO.ANSI.ansidata(),
+          doc_bold: IO.ANSI.ansidata(),
+          doc_underline: IO.ANSI.ansidata(),
+          syntax_colors: syntax_colors_opts() | false
+        ]
+
+  @typedoc """
+  Syntax coloring settings for inspected expressions.
+  """
+  @type syntax_colors_opts :: [
+          atom: IO.ANSI.ansidata(),
+          binary: IO.ANSI.ansidata(),
+          boolean: IO.ANSI.ansidata(),
+          charlist: IO.ANSI.ansidata(),
+          list: IO.ANSI.ansidata(),
+          map: IO.ANSI.ansidata(),
+          nil: IO.ANSI.ansidata(),
+          number: IO.ANSI.ansidata(),
+          string: IO.ANSI.ansidata(),
+          tuple: IO.ANSI.ansidata(),
+          variable: IO.ANSI.ansidata(),
+          call: IO.ANSI.ansidata(),
+          operator: IO.ANSI.ansidata(),
+          reset: IO.ANSI.ansidata()
+        ]
+
+  @typedoc """
+  Inspect settings used by the IEx shell.
   """
+  @type inspect_opts :: [
+          base: :binary | :decimal | :octal | :hex,
+          binaries: :infer | :as_binaries | :as_strings,
+          charlists: :infer | :as_charlists | :as_lists,
+          custom_options: keyword(),
+          inspect_fun: (term(), Inspect.Opts.t() -> Inspect.Algebra.t()),
+          limit: pos_integer() | :infinity,
+          pretty: boolean(),
+          printable_limit: pos_integer() | :infinity,
+          safe: boolean(),
+          structs: boolean(),
+          syntax_colors: syntax_colors_opts(),
+          width: pos_integer() | :infinity
+        ]
+
+  @type configure_opts :: [
+          auto_reload: boolean(),
+          alive_prompt: String.t(),
+          colors: colors_opts(),
+          default_prompt: String.t(),
+          dot_iex: String.t() | nil,
+          history_size: integer(),
+          inspect: inspect_opts(),
+          parser: {module(), atom(), [any()]},
+          width: pos_integer()
+        ]
 
   @doc """
   Configures IEx.
 
-  The supported options are: `:colors`, `:inspect`,
-  `:default_prompt`, `:alive_prompt` and `:history_size`.
+  The supported options are:
+
+    * `:auto_reload`
+    * `:alive_prompt`
+    * `:colors`
+    * `:default_prompt`
+    * `:dot_iex`
+    * `:history_size`
+    * `:inspect`
+    * `:parser`
+    * `:width`
+
+  They are discussed individually in the sections below.
 
   ## Colors
 
@@ -221,35 +487,62 @@ defmodule IEx do
   shell. See documentation for the `IO.ANSI` module for the list of
   supported colors and attributes.
 
-  The value is a keyword list. List of supported keys:
+  List of supported keys in the keyword list:
 
-    * `:enabled`      - boolean value that allows for switching the coloring on and off
-    * `:eval_result`  - color for an expression's resulting value
-    * `:eval_info`    - … various informational messages
-    * `:eval_error`   - … error messages
-    * `:stack_app`    - … the app in stack traces
-    * `:stack_info`   - … the remaining info in stacktraces
-    * `:ls_directory` - … for directory entries (ls helper)
-    * `:ls_device`    - … device entries (ls helper)
+    * `:enabled` - boolean value that allows for switching the coloring on and off
+    * `:eval_result` - color for an expression's resulting value
+    * `:eval_info` - ... various informational messages
+    * `:eval_error` - ... error messages
+    * `:eval_interrupt` - ... interrupt messages
+    * `:stack_info` - ... the stacktrace color
+    * `:blame_diff` - ... when blaming source with no match
+    * `:ls_directory` - ... for directory entries (ls helper)
+    * `:ls_device` - ... device entries (ls helper)
 
-  When printing documentation, IEx will convert the markdown
-  documentation to ANSI as well. Those can be configured via:
+  When printing documentation, IEx will convert the Markdown
+  documentation to ANSI as well. Colors for this can be configured
+  via:
 
-    * `:doc_code`        — the attributes for code blocks (cyan, bright)
+    * `:doc_code`        - the attributes for code blocks (cyan, bright)
     * `:doc_inline_code` - inline code (cyan)
     * `:doc_headings`    - h1 and h2 (yellow, bright)
-    * `:doc_title`       — the overall heading for the output (reverse,yellow,bright)
+    * `:doc_title`       - the overall heading for the output (reverse, yellow, bright)
     * `:doc_bold`        - (bright)
     * `:doc_underline`   - (underline)
 
+  IEx will also color inspected expressions using the `:syntax_colors`
+  option. Such can be disabled with:
+
+      IEx.configure(colors: [syntax_colors: false])
+
+  You can also configure the syntax colors, however, as desired.
+  The below will format atoms in red and remove the coloring for
+  all other data types:
+
+      IEx.configure(colors: [syntax_colors: [atom: :red]])
+
+  The default values can be found in `IO.ANSI.syntax_colors/0`.
+
   ## Inspect
 
   A keyword list containing inspect options used by the shell
-  when printing results of expression evaluation. Defailt to
+  when printing results of expression evaluation. Defaults to
   pretty formatting with a limit of 50 entries.
 
+  To show all entries, configure the limit to `:infinity`:
+
+      IEx.configure(inspect: [limit: :infinity])
+
   See `Inspect.Opts` for the full list of options.
 
+  ## Width
+
+  An integer indicating the maximum number of columns to use in output.
+  The default value is 80 columns. The actual output width is the minimum
+  of this number and result of `:io.columns`. This way you can configure IEx
+  to be your largest screen size and it should always take up the full width
+  of your current terminal screen.
+
   ## History size
 
   Number of expressions and their results to keep in the history.
@@ -260,67 +553,82 @@ defmodule IEx do
   This is an option determining the prompt displayed to the user
   when awaiting input.
 
-  The value is a keyword list. Two prompt types:
+  The value is a keyword list with two possible keys representing prompt types:
+
+    * `:default_prompt` - used when `Node.alive?/0` returns `false`
 
-    * `:default_prompt` - used when `Node.alive?` returns false
-    * `:alive_prompt`   - used when `Node.alive?` returns true
+    * `:alive_prompt` - used when `Node.alive?/0` returns `true`
 
-  The part of the listed in the following of the prompt string is replaced.
+  The following values in the prompt string will be replaced appropriately:
 
     * `%counter` - the index of the history
     * `%prefix`  - a prefix given by `IEx.Server`
     * `%node`    - the name of the local node
 
-  """
-  def configure(options) do
-    Enum.each options, fn {k, v} ->
-      Application.put_env(:iex, k, configure(k, v))
-    end
-  end
+  ## Parser
 
-  defp configure(k, v) when k in [:colors, :inspect] and is_list(v) do
-    Keyword.merge(Application.get_env(:iex, k), v)
-  end
+  This is an option determining the parser to use for IEx.
 
-  defp configure(:history_size, v) when is_integer(v) do
-    v
-  end
+  The parser is a "mfargs", which is a tuple with three elements:
+  the module name, the function name, and extra arguments to
+  be appended. The parser receives at least three arguments, the
+  current input as a charlist, the parsing options as a keyword list,
+  and the state. The initial state is an empty charlist. It must
+  return `{:ok, expr, state}` or `{:incomplete, state}`.
 
-  defp configure(k, v) when k in [:default_prompt, :alive_prompt] and is_binary(v) do
-    v
-  end
+  If the parser raises, the state is reset to an empty charlist.
+
+  > In earlier Elixir versions, the parser would receive the input
+  > and the initial buffer as strings. However, this behaviour
+  > changed when Erlang/OTP introduced multiline editing. If you
+  > support earlier Elixir versions, you can normalize the inputs
+  > by calling `to_charlist/1`.
+
+  ## `.iex`
 
-  defp configure(k, v) do
-    raise ArgumentError, "invalid value #{inspect v} for configuration #{inspect k}"
+  Configure the file loaded into your IEx session when it starts.
+  See more information [in the `.iex.exs` documentation](`m:IEx#module-the-iex-exs-file`).
+
+  ## Auto reloading
+
+  When set to `true`, the `:auto_reload` option automatically purges
+  in-memory modules when they get invalidated by a concurrent compilation
+  happening in the Operating System.
+  """
+  @spec configure(configure_opts) :: :ok
+  def configure(options) do
+    IEx.Config.configure(options)
   end
 
   @doc """
   Returns IEx configuration.
   """
+  @spec configuration() :: keyword()
   def configuration do
-    Application.get_all_env(:iex)
+    IEx.Config.configuration()
   end
 
-  @doc """
-  Registers a function to be invoked after the IEx process is spawned.
-  """
+  @doc false
+  @deprecated "The functionality is no longer supported"
   def after_spawn(fun) when is_function(fun) do
-    Application.put_env(:iex, :after_spawn, [fun|after_spawn])
+    IEx.Config.after_spawn(fun)
   end
 
-  @doc """
-  Returns registered `after_spawn` callbacks.
-  """
+  @doc false
+  @deprecated "The functionality is no longer supported"
   def after_spawn do
-    {:ok, list} = Application.fetch_env(:iex, :after_spawn)
-    list
+    IEx.Config.after_spawn()
   end
 
   @doc """
-  Returns `true` if IEx was started.
+  Returns `true` if IEx was started, `false` otherwise.
+
+  This means the IEx application was started, but not
+  that its CLI interface is running.
   """
+  @spec started?() :: boolean()
   def started? do
-    Application.get_env(:iex, :started, false)
+    IEx.Config.started?()
   end
 
   @doc """
@@ -328,69 +636,72 @@ defmodule IEx do
 
   ANSI escapes in `string` are not processed in any way.
   """
+  @spec color(atom(), iodata()) :: iodata()
   def color(color, string) do
-    colors = Application.get_env(:iex, :colors)
+    case IEx.Config.color(color) do
+      nil ->
+        string
 
-    if colors[:enabled] do
-      ansi = Keyword.get(colors, color, default_color(color))
-      IO.ANSI.escape_fragment("%{#{ansi}}", true) <> string <>
-        IO.ANSI.escape_fragment("%{reset}", true)
-    else
-      string
+      ansi ->
+        [ansi | string] |> IO.ANSI.format(true) |> IO.iodata_to_binary()
     end
   end
 
   @doc """
-  Gets the IEx width for printing.
+  Returns the IEx width for printing.
 
-  Used by helpers and it has a maximum cap of 80 chars.
+  Used by helpers and it has a default maximum cap of 80 chars.
   """
+  @spec width() :: pos_integer()
   def width do
-    case :io.columns() do
-      {:ok, width} -> min(width, 80)
-      {:error, _}  -> 80
-    end
+    IEx.Config.width()
   end
 
   @doc """
-  Gets the options used for inspecting.
+  Returns the options used for inspecting.
   """
+  @spec inspect_opts() :: keyword()
   def inspect_opts do
-    Application.get_env(:iex, :inspect) ++
-      [width: width(), pretty: true]
+    IEx.Config.inspect_opts()
   end
 
   @doc """
   Pries into the process environment.
 
-  This is useful for debugging a particular chunk of code
-  and inspect the state of a particular process. The process
-  is temporarily changed to trap exits (i.e. the process flag
-  `:trap_exit` is set to true) and has the `group_leader` changed
-  to support ANSI escape codes. Those values are reverted by
-  calling `respawn`, which starts a new IEx shell, freeing up
-  the pried one.
+  This function is useful for debugging a particular chunk of code
+  when executed by a particular process. The process becomes
+  the evaluator of IEx commands and is temporarily changed to
+  have a custom group leader. Those values are reverted by
+  calling `IEx.Helpers.respawn/0`, which starts a new IEx shell,
+  freeing up the pried one.
+
+  When a process is pried, all code runs inside IEx and has
+  access to all imports and aliases from the original code.
+  However, you cannot change the execution of the code nor
+  access private functions of the module being pried. Module
+  functions still need to be accessed via `Mod.fun(args)`.
 
-  When a process is pried, all code runs inside IEx and, as
-  such, it is evaluated and cannot access private functions
-  of the module being pried. Module functions still need to be
-  accessed via `Mod.fun(args)`.
+  See also `break!/4` for others ways to pry.
+
+  > #### `dbg/0` integration
+  >
+  > By calling `iex --dbg pry`, `iex` will set this function
+  > as the default backend for `dbg/0` calls.
 
   ## Examples
 
   Let's suppose you want to investigate what is happening
-  with some particular function. By invoking `IEx.pry` from
+  with some particular function. By invoking `IEx.pry/0` from
   the function, IEx will allow you to access its binding
   (variables), verify its lexical information and access
   the process information. Let's see an example:
 
       import Enum, only: [map: 2]
-      require IEx
 
       defmodule Adder do
         def add(a, b) do
           c = a + b
-          IEx.pry
+          require IEx; IEx.pry()
         end
       end
 
@@ -399,123 +710,235 @@ defmodule IEx do
   the shell will be reset and you gain access to all variables
   and the lexical scope from above:
 
-      pry(1)> map([a,b,c], &IO.inspect(&1))
+      iex(1)> map([a, b, c], &IO.inspect(&1))
       1
       2
       3
 
-  Keep in mind that `IEx.pry` runs in the caller process,
+  Keep in mind that `IEx.pry/0` runs in the caller process,
   blocking the caller during the evaluation cycle. The caller
-  process can be freed by calling `respawn`, which starts a
+  process can be freed by calling [`respawn/0`](`IEx.Helpers.respawn/0`), which starts a
   new IEx evaluation cycle, letting this one go:
 
-      pry(2)> respawn
+      iex(2)> respawn()
       true
 
       Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)
 
   Setting variables or importing modules in IEx does not
-  affect the caller the environment (hence it is called `pry`).
-  """
-  defmacro pry(timeout \\ 1000) do
-    quote do
-      env  = __ENV__
-      meta = "#{inspect self} at #{Path.relative_to_cwd(env.file)}:#{env.line}"
-      opts = [binding: binding, dot_iex_path: "", env: env, prefix: "pry"]
-      res  = IEx.Server.take_over("Request to pry #{meta}", opts, unquote(timeout))
-
-      # We cannot use colors because IEx may be off.
-      case res do
-        {:error, :self} = err ->
-          IO.puts :stdio, "IEx cannot pry itself."
-        {:error, :no_iex} = err ->
-          IO.puts :stdio, "Cannot pry #{meta}. Is an IEx shell running?"
-        _ ->
-          :ok
-      end
+  affect the caller's environment. However, sending and
+  receiving messages will change the process state.
 
-      res
-    end
-  end
+  ## Pry and macros
 
-  ## Callbacks
+  When setting up Pry inside a code defined by macros, such as:
 
-  # This is a callback invoked by Erlang shell utilities
-  # when someone press Ctrl+G and adds 's Elixir.IEx'.
-  @doc false
-  def start(opts \\ [], mfa \\ {IEx, :dont_display_result, []}) do
-    spawn fn ->
-      case :init.notify_when_started(self()) do
-        :started -> :ok
-        _        -> :init.wait_until_started()
+      defmacro __using__(_) do
+        quote do
+          def add(a, b) do
+            c = a + b
+            require IEx; IEx.pry()
+          end
+        end
       end
 
-      start_iex()
-      set_expand_fun()
-      run_after_spawn()
-      IEx.Server.start(opts, mfa)
-    end
-  end
+  The variables defined inside `quote` won't be available during
+  prying due to the hygiene mechanism in quoted expressions. The
+  hygiene mechanism changes the variable names in quoted expressions
+  so they don't collide with variables defined by the users of the
+  macros. Therefore the original names are not available.
 
-  @doc false
-  def dont_display_result, do: :"do not show this result in output"
+  ## Pry and `mix test`
 
-  ## Helpers
+  To use `IEx.pry/0` during tests, you need to run `mix` inside
+  the `iex` command and pass the `--trace` to `mix test` to avoid running
+  into timeouts:
 
-  defp start_iex() do
-    unless started? do
-      Application.start(:elixir)
-      Application.start(:iex)
-      Application.put_env(:iex, :started, true)
+      $ iex -S mix test --trace
+      $ iex -S mix test path/to/file:line --trace
 
-      colors = [enabled: IO.ANSI.terminal?] ++
-               Application.get_env(:iex, :colors)
-      Application.put_env(:iex, :colors, colors)
+  """
+  defmacro pry() do
+    quote do
+      IEx.Pry.pry(binding(), __ENV__)
     end
   end
 
-  defp set_expand_fun do
-    gl = Process.group_leader
-    glnode = node gl
+  @doc """
+  Macro-based shortcut for `IEx.break!/4`.
+  """
+  @doc since: "1.5.0"
+  defmacro break!(ast, stops \\ 1) do
+    quote do
+      IEx.__break__!(unquote(Macro.escape(ast)), unquote(Macro.escape(stops)), __ENV__)
+    end
+  end
 
-    if glnode != node do
-      ensure_module_exists glnode, IEx.Remsh
-      expand_fun = IEx.Remsh.expand node
+  def __break__!({:/, _, [call, arity]} = ast, stops, env) when arity in 0..255 do
+    with {module, fun, []} <- Macro.decompose_call(call),
+         module when is_atom(module) <- Macro.expand(module, env) do
+      IEx.Pry.break!(module, fun, arity, stops)
     else
-      expand_fun = &IEx.Autocomplete.expand(&1)
+      _ ->
+        raise_unknown_break_ast!(ast)
     end
+  end
+
+  def __break__!({{:., _, [module, fun]}, _, args} = ast, stops, env) do
+    __break__!(ast, module, fun, args, true, stops, env)
+  end
+
+  def __break__!({:when, _, [{{:., _, [module, fun]}, _, args}, guards]} = ast, stops, env) do
+    __break__!(ast, module, fun, args, guards, stops, env)
+  end
 
-    :io.setopts gl, [expand_fun: expand_fun, binary: true, encoding: :unicode]
+  def __break__!(ast, _stops) do
+    raise_unknown_break_ast!(ast)
   end
 
-  defp ensure_module_exists(node, mod) do
-    unless :rpc.call node, :code, :is_loaded, [mod] do
-      {m, b, f} = :code.get_object_code mod
-      {:module, _} = :rpc.call node, :code, :load_binary, [m, f, b]
+  defp __break__!(ast, module, fun, args, guards, stops, env) do
+    module = Macro.expand(module, env)
+
+    if not is_atom(module) do
+      raise_unknown_break_ast!(ast)
     end
+
+    IEx.Pry.break!(module, fun, args, guards, env, stops)
   end
 
-  defp run_after_spawn do
-    for fun <- Enum.reverse(after_spawn), do: fun.()
+  defp raise_unknown_break_ast!(ast) do
+    raise ArgumentError, """
+    unknown expression to break on, expected one of:
+
+      * Mod.fun/arity, such as: URI.parse/1
+      * Mod.fun(arg1, arg2, ...), such as: URI.parse(_)
+      * Mod.fun(arg1, arg2, ...) when guard, such as: URI.parse(var) when is_binary(var)
+
+    Got #{Macro.to_string(ast)}
+    """
   end
 
-  # Used by default on evaluation cycle
-  defp default_color(:eval_interrupt), do: "yellow"
-  defp default_color(:eval_result), do: "yellow"
-  defp default_color(:eval_error), do: "red"
-  defp default_color(:eval_info), do: "normal"
-  defp default_color(:stack_app), do: "red,bright"
-  defp default_color(:stack_info), do: "red"
-
-  # Used by ls
-  defp default_color(:ls_directory), do: "blue"
-  defp default_color(:ls_device), do: "green"
-
-  # Used by ansi docs
-  defp default_color(:doc_bold), do: "bright"
-  defp default_color(:doc_code), do: "cyan,bright"
-  defp default_color(:doc_headings), do: "yellow,bright"
-  defp default_color(:doc_inline_code), do: "cyan"
-  defp default_color(:doc_underline), do: "underline"
-  defp default_color(:doc_title), do: "reverse,yellow,bright"
+  @doc """
+  Sets up a breakpoint in `module`, `function` and `arity` with
+  the given number of `stops`.
+
+  This function will instrument the given module and load a new
+  version in memory with line by line breakpoints at the given
+  function and arity. If the module is recompiled, all breakpoints
+  are lost.
+
+  When a breakpoint is reached, IEx will ask if you want to `pry`
+  the given function and arity. In other words, this works similar
+  to `IEx.pry/0` as the running process becomes the evaluator of
+  IEx commands and is temporarily changed to have a custom group
+  leader. However, differently from `IEx.pry/0`, aliases and imports
+  from the source code won't be available in the shell.
+
+  IEx helpers includes many conveniences related to breakpoints.
+  Below they are listed with the full module, such as `IEx.Helpers.breaks/0`,
+  but remember it can be called directly as `breaks()` inside IEx.
+  They are:
+
+    * `IEx.Helpers.break!/2` - sets up a breakpoint for a given `Mod.fun/arity`
+    * `IEx.Helpers.break!/4` - sets up a breakpoint for the given module, function, arity
+    * `IEx.Helpers.breaks/0` - prints all breakpoints and their IDs
+    * `IEx.Helpers.continue/0` - continues until the next breakpoint in the same shell
+    * `IEx.Helpers.n/0` - goes to the next line of the current breakpoint
+    * `IEx.Helpers.next/0` - same as above
+    * `IEx.Helpers.open/0` - opens editor on the current breakpoint
+    * `IEx.Helpers.remove_breaks/0` - removes all breakpoints in all modules
+    * `IEx.Helpers.remove_breaks/1` - removes all breakpoints in a given module
+    * `IEx.Helpers.reset_break/1` - sets the number of stops on the given ID to zero
+    * `IEx.Helpers.reset_break/3` - sets the number of stops on the given module, function, arity to zero
+    * `IEx.Helpers.respawn/0` - starts a new shell (breakpoints will ask for permission once more)
+    * `IEx.Helpers.whereami/1` - shows the current location
+
+  By default, the number of stops in a breakpoint is 1. Any follow-up
+  call won't stop the code execution unless another breakpoint is set.
+
+  Alternatively, the number of stops can be increased by passing the `stops`
+  argument. `IEx.Helpers.reset_break/1` and `IEx.Helpers.reset_break/3`
+  can be used to reset the number back to zero. Note the module remains
+  "instrumented" even after all stops on all breakpoints are consumed.
+  You can remove the instrumentation in a given module by calling
+  `IEx.Helpers.remove_breaks/1` and on all modules by calling
+  `IEx.Helpers.remove_breaks/0`.
+
+  Within a breakpoint, you can call `n` to jump to the next line.
+  To exit a breakpoint, you can either invoke `continue`, which will
+  block the shell until the next breakpoint is found or the process
+  terminates, or invoke `respawn`, which starts a new IEx shell,
+  freeing up the pried one.
+
+  ## Examples
+
+  The examples below will use `break!`, assuming that you are setting
+  a breakpoint directly from your IEx shell. But you can set up a break
+  from anywhere by using the fully qualified name `IEx.break!`.
+
+  The following sets up a breakpoint on `URI.parse/1`:
+
+      break! URI, :parse, 1
+
+  This call will setup a breakpoint that stops once.
+  To set a breakpoint that will stop 10 times:
+
+      break! URI, :parse, 1, 10
+
+  `IEx.break!/2` is a convenience macro that allows breakpoints
+  to be given in the `Mod.fun/arity` format:
+
+      break! URI.parse/1
+
+  Or to set a breakpoint that will stop 10 times:
+
+      break! URI.parse/1, 10
+
+  This function returns the breakpoint ID and will raise if there
+  is an error setting up the breakpoint.
+
+  ## Patterns and guards
+
+  `IEx.break!/2` allows patterns to be given, triggering the
+  breakpoint only in some occasions. For example, to trigger
+  the breakpoint only when the first argument starts with the
+  "https" string:
+
+      break! URI.parse("https" <> _, _)
+
+  Only a single break point can be set per function. So if you call
+  `IEx.break!` multiple times with different patterns, only the last
+  pattern is kept.
+
+  ## Macros
+
+  While it is possible to set breakpoint in macros, remember that macros
+  are generally expanded at compilation time, and therefore they may never
+  be invoked during runtime. Similarly, while patterns may be given to
+  macros, macros receive ASTs as arguments, and not values. For example,
+  if you try to break on a macro with the following pattern:
+
+      break! MyModule.some_macro(pid) when pid == self()
+
+  This breakpoint will never be reached, because a macro never receives
+  a PID. Even if you call the macro as `MyModule.some_macro(self())`,
+  the macro will receive the AST representing the `self()` call, and not
+  the PID itself.
+
+  ## Breaks and `mix test`
+
+  To use `IEx.break!/4` during tests, you need to run `mix` inside
+  the `iex` command and pass the `--trace` to `mix test` to avoid running
+  into timeouts:
+
+      $ iex -S mix test --trace
+      $ iex -S mix test path/to/file:line --trace
+
+  """
+  @doc since: "1.5.0"
+  @spec break!(module, atom, arity, non_neg_integer) :: IEx.Pry.id()
+  defdelegate break!(module, function, arity, stops \\ 1), to: IEx.Pry
+
+  @doc false
+  def dont_display_result, do: :"do not show this result in output"
 end
diff --git a/lib/iex/lib/iex/app.ex b/lib/iex/lib/iex/app.ex
new file mode 100644
index 00000000000..8ab2ccb2418
--- /dev/null
+++ b/lib/iex/lib/iex/app.ex
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule IEx.App do
+  @moduledoc false
+
+  use Application
+
+  def start(_type, _args) do
+    with :default <- Application.get_env(:stdlib, :shell_multiline_prompt, :default) do
+      Application.put_env(:stdlib, :shell_multiline_prompt, {IEx.Config, :prompt})
+    end
+
+    children = [IEx.Config, IEx.Broker, IEx.Pry]
+    Supervisor.start_link(children, strategy: :one_for_one, name: IEx.Supervisor)
+  end
+end
diff --git a/lib/iex/lib/iex/autocomplete.ex b/lib/iex/lib/iex/autocomplete.ex
index 72e94044938..830ae173322 100644
--- a/lib/iex/lib/iex/autocomplete.ex
+++ b/lib/iex/lib/iex/autocomplete.ex
@@ -1,259 +1,908 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule IEx.Autocomplete do
   @moduledoc false
 
-  def expand([]) do
-    funs = module_funs(IEx.Helpers) ++ module_funs(Kernel)
-    mods = [%{name: "Elixir", type: :elixir, kind: :module}]
-    format_expansion mods ++ funs
-  end
+  @bitstring_modifiers [
+    %{kind: :variable, name: "big"},
+    %{kind: :variable, name: "binary"},
+    %{kind: :variable, name: "bitstring"},
+    %{kind: :variable, name: "integer"},
+    %{kind: :variable, name: "float"},
+    %{kind: :variable, name: "little"},
+    %{kind: :variable, name: "native"},
+    %{kind: :variable, name: "signed"},
+    %{kind: :export, name: "size", arity: 1},
+    %{kind: :export, name: "unit", arity: 1},
+    %{kind: :variable, name: "unsigned"},
+    %{kind: :variable, name: "utf8"},
+    %{kind: :variable, name: "utf16"},
+    %{kind: :variable, name: "utf32"}
+  ]
+
+  block_keywords =
+    for block_keyword <- ~w(do end after catch else rescue) do
+      %{kind: :block_keyword, name: block_keyword}
+    end
 
-  def expand([h|t]=expr) do
-    cond do
-      h === ?. and t != []->
-        expand_dot reduce(t)
-      h === ?: ->
-        expand_erlang_modules
-      identifier?(h) ->
-        expand_expr reduce(expr)
-      (h == ?/) and t != [] and identifier?(hd(t)) ->
-        expand_expr reduce(t)
-      h in '(+[' ->
-        expand ''
-      true ->
-        no()
+  binary_operators =
+    for operator <-
+          ["**", "*", "/", "+", "-", "++", "--", "+++", "---", "..", "<>"] ++
+            ["in", "not in", "|>", "<<<", ">>>", "<<~", "~>>", "<~", "~>", "<~>"] ++
+            ["<", ">", "<=", ">=", "==", "!=", "=~", "===", "!=="] ++
+            ["&&", "&&&", "and", "||", "|||", "or"] ++
+            ["=", "=>", "|", "::", "when", "<-", "\\\\"] do
+      %{kind: :export, name: operator, arity: 2}
+    end
+
+  @block_keyword_or_binary_operator block_keywords ++ Enum.sort(binary_operators)
+
+  @alias_only_atoms ~w(alias import require)a
+  @alias_only_charlists ~w(alias import require)c
+
+  @doc """
+  Provides one helper function that is injected into connecting
+  remote nodes to properly handle autocompletion.
+  """
+  def remsh(node) do
+    fn e ->
+      try do
+        :erpc.call(node, IEx.Autocomplete, :expand, [e, :shell.whereis()])
+      catch
+        _, _ -> {:no, ~c"", []}
+      end
     end
   end
 
-  defp identifier?(h) do
-    (h in ?a..?z) or (h in ?A..?Z) or (h in ?0..?9) or h in [?_, ??, ?!]
+  @doc """
+  The expansion logic.
+
+  Some of the expansion has to use the current shell
+  environment, which is found via the broker.
+  """
+  def expand(code, shell \\ :shell.whereis()) do
+    case path_fragment(code) do
+      [] -> expand_code(code, shell)
+      path -> expand_path(path)
+    end
   end
 
-  defp expand_dot(expr) do
-    case Code.string_to_quoted expr do
-      {:ok, atom} when is_atom(atom) ->
-        expand_call atom, ""
-      {:ok, {:__aliases__, _, list}} ->
-        expand_elixir_modules list
+  defp expand_code(code, shell) do
+    code = Enum.reverse(code)
+    helper = get_helper(code)
+
+    case Code.Fragment.cursor_context(code) do
+      {:alias, alias} ->
+        expand_aliases(List.to_string(alias), shell)
+
+      {:unquoted_atom, unquoted_atom} ->
+        expand_erlang_modules(List.to_string(unquoted_atom))
+
+      {:block_keyword_or_binary_operator, hint} ->
+        filter_and_format_expansion(@block_keyword_or_binary_operator, List.to_string(hint))
+
+      expansion when helper == ?b ->
+        expand_typespecs(expansion, shell, &get_module_callbacks/1)
+
+      expansion when helper == ?t ->
+        expand_typespecs(expansion, shell, &get_module_types/1)
+
+      {:dot, path, hint} ->
+        if alias = alias_only(path, hint, code, shell) do
+          expand_aliases(List.to_string(alias), shell)
+        else
+          expand_dot(path, List.to_string(hint), false, shell)
+        end
+
+      {:dot_arity, path, hint} ->
+        expand_dot(path, List.to_string(hint), true, shell)
+
+      {:dot_call, path, hint} ->
+        expand_dot_call(path, List.to_atom(hint), shell)
+
+      :expr ->
+        expand_container_context(code, :expr, "", shell) || expand_local_or_var("", shell)
+
+      {:local_or_var, local_or_var} ->
+        hint = List.to_string(local_or_var)
+        expand_container_context(code, :expr, hint, shell) || expand_local_or_var(hint, shell)
+
+      {:local_arity, local} ->
+        expand_local(List.to_string(local), true, shell)
+
+      {:local_call, local} when local in @alias_only_charlists ->
+        expand_aliases("", shell)
+
+      {:local_call, local} ->
+        expand_local_call(List.to_atom(local), shell)
+
+      {:operator, operator} when operator in ~w(:: -)c ->
+        expand_container_context(code, :operator, "", shell) ||
+          expand_local(List.to_string(operator), false, shell)
+
+      {:operator, operator} ->
+        expand_local(List.to_string(operator), false, shell)
+
+      {:operator_arity, operator} ->
+        expand_local(List.to_string(operator), true, shell)
+
+      {:operator_call, operator} when operator in ~w(|)c ->
+        expand_container_context(code, :expr, "", shell) || expand_local_or_var("", shell)
+
+      {:operator_call, _operator} ->
+        expand_local_or_var("", shell)
+
+      {:sigil, []} ->
+        expand_sigil(shell)
+
+      {:sigil, [_]} ->
+        {:yes, [], ~w|" """ ' ''' \( / < [ { \||c}
+
+      {:struct, struct} when is_list(struct) ->
+        expand_structs(List.to_string(struct), shell)
+
+      {:struct, {:dot, {:alias, struct}, ~c""}} when is_list(struct) ->
+        expand_structs(List.to_string(struct ++ ~c"."), shell)
+
+      # {:module_attribute, charlist}
+      # :none
       _ ->
         no()
     end
   end
 
-  defp expand_expr(expr) do
-    case Code.string_to_quoted expr do
-      {:ok, atom} when is_atom(atom) ->
-        expand_erlang_modules Atom.to_string(atom)
-      {:ok, {atom, _, nil}} when is_atom(atom) ->
-        expand_call Kernel, Atom.to_string(atom)
-      {:ok, {:__aliases__, _, [root]}} ->
-        expand_elixir_modules [], Atom.to_string(root)
-      {:ok, {:__aliases__, _, [h|_] = list}} when is_atom(h) ->
-        hint = Atom.to_string(List.last(list))
-        list = Enum.take(list, length(list) - 1)
-        expand_elixir_modules list, hint
-      {:ok, {{:., _, [mod, fun]}, _, []}} when is_atom(fun) ->
-        expand_call mod, Atom.to_string(fun)
+  defp get_helper(expr) do
+    with [helper | rest] when helper in ~c"bt" <- expr,
+         [space_or_paren, char | _] <- squeeze_spaces(rest),
+         true <-
+           space_or_paren in ~c" (" and
+             (char in ?A..?Z or char in ?a..?z or char in ?0..?9 or char in ~c"_:") do
+      helper
+    else
+      _ -> nil
+    end
+  end
+
+  defp squeeze_spaces(~c"  " ++ rest), do: squeeze_spaces([?\s | rest])
+  defp squeeze_spaces(rest), do: rest
+
+  @doc false
+  def exports(mod) do
+    if ensure_loaded?(mod) and function_exported?(mod, :__info__, 1) do
+      mod.__info__(:macros) ++ (mod.__info__(:functions) -- [__info__: 1])
+    else
+      mod.module_info(:exports) -- [module_info: 0, module_info: 1]
+    end
+  end
+
+  ## Typespecs
+
+  defp expand_typespecs({:dot, path, hint}, shell, fun) do
+    hint = List.to_string(hint)
+
+    case expand_dot_path(path, shell) do
+      {:ok, mod} when is_atom(mod) ->
+        mod
+        |> fun.()
+        |> match_exports(hint, false)
+        |> format_expansion(hint)
+
       _ ->
         no()
     end
   end
 
-  defp reduce(expr) do
-    last_token(Enum.reverse(expr), [' ', '(', '[', '+', '-'])
+  defp expand_typespecs(_, _, _), do: no()
+
+  ## Expand call
+
+  defp expand_local_call(fun, shell) do
+    imports_from_env(shell)
+    |> Enum.filter(fn {_, funs} -> List.keymember?(funs, fun, 0) end)
+    |> Enum.flat_map(fn {module, _} -> get_signatures(fun, module) end)
+    |> expand_signatures(shell)
   end
 
-  defp last_token(s, []) do
-    s
+  defp expand_dot_call(path, fun, shell) do
+    case expand_dot_path(path, shell) do
+      {:ok, mod} when is_atom(mod) -> get_signatures(fun, mod) |> expand_signatures(shell)
+      _ -> no()
+    end
   end
 
-  defp last_token(s, [h|t]) do
-    last_token(List.last(:string.tokens(s, h)), t)
+  defp get_signatures(name, module) when is_atom(module) do
+    with docs when is_list(docs) <- get_docs(module, [:function, :macro], name) do
+      Enum.map(docs, fn {_, _, signatures, _, _} -> Enum.join(signatures, " ") end)
+    else
+      _ -> []
+    end
   end
 
-  defp yes(hint, entries) do
-    {:yes, String.to_char_list(hint), Enum.map(entries, &String.to_char_list/1)}
+  defp expand_signatures([_ | _] = signatures, _shell) do
+    yes(~c"", signatures |> Enum.map(&String.to_charlist/1) |> Enum.sort_by(&length/1))
   end
 
-  defp no do
-    {:no, '', []}
+  defp expand_signatures([], shell), do: expand_local_or_var("", shell)
+
+  ## Expand dot
+
+  defp expand_dot(path, hint, exact?, shell) do
+    case expand_dot_path(path, shell) do
+      {:ok, mod} when is_atom(mod) and hint == "" -> expand_dot_aliases(mod)
+      {:ok, mod} when is_atom(mod) -> expand_require(mod, hint, exact?)
+      {:ok, map} when is_map(map) -> expand_map_field_access(map, hint)
+      _ -> no()
+    end
   end
 
-  ## Formatting
+  defp expand_dot_path({:unquoted_atom, var}, _shell) do
+    {:ok, List.to_atom(var)}
+  end
 
-  defp format_expansion(list, hint \\ "")
+  defp expand_dot_path(path, shell) do
+    case recur_expand_dot_path(path, shell) do
+      {:ok, [_ | _] = path} -> value_from_binding(Enum.reverse(path), shell)
+      other -> other
+    end
+  end
 
-  defp format_expansion([], _) do
-    no()
+  defp recur_expand_dot_path({:var, var}, _shell) do
+    {:ok, [List.to_atom(var)]}
   end
 
-  defp format_expansion([uniq], hint) do
-    hint = to_hint(uniq, hint)
-    uniq = if hint == "", do: to_uniq_entries(uniq), else: []
-    yes(hint, uniq)
+  defp recur_expand_dot_path({:alias, var}, shell) do
+    {:ok, var |> List.to_string() |> String.split(".") |> value_from_alias(shell)}
   end
 
-  defp format_expansion([first|_]=entries, hint) do
-    binary = Enum.map(entries, &(&1.name))
-    length = byte_size(hint)
-    prefix = :binary.longest_common_prefix(binary)
-    if prefix in [0, length] do
-      entries = Enum.reduce(entries, [], fn e, acc -> to_entries(e) ++ acc end)
-      yes("", entries)
-    else
-      yes(:binary.part(first.name, prefix, length-prefix), [])
+  defp recur_expand_dot_path({:dot, parent, call}, shell) do
+    case recur_expand_dot_path(parent, shell) do
+      {:ok, [_ | _] = path} -> {:ok, [List.to_atom(call) | path]}
+      _ -> :error
     end
   end
 
-  ## Root Modules
+  defp recur_expand_dot_path(_, _shell) do
+    :error
+  end
 
-  defp root_modules do
-    Enum.reduce :code.all_loaded, [], fn {m, _}, acc ->
-      mod = Atom.to_string(m)
-      case mod do
-        "Elixir" <> _ ->
-          tokens = String.split(mod, ".")
-          if length(tokens) == 2 do
-            [%{kind: :module, name: List.last(tokens), type: :elixir}|acc]
-          else
-            acc
-          end
-        _ ->
-          [%{kind: :module, name: mod, type: :erlang}|acc]
-      end
+  defp expand_map_field_access(map, hint) do
+    case match_map_fields(map, hint) do
+      [%{kind: :map_key, name: ^hint, value_is_map: false}] -> no()
+      map_fields when is_list(map_fields) -> format_expansion(map_fields, hint)
     end
   end
 
-  ## Expand calls
+  defp expand_dot_aliases(mod) do
+    all = match_elixir_modules(mod, "") ++ get_and_match_module_defs(mod, "", false)
+    format_expansion(all, "")
+  end
 
-  # :atom.fun
-  defp expand_call(mod, hint) when is_atom(mod) do
-    expand_module_funs mod, hint
+  defp expand_require(mod, hint, exact?) do
+    mod
+    |> get_and_match_module_defs(hint, exact?)
+    |> format_expansion(hint)
   end
 
-  # Elixir.fun
-  defp expand_call({:__aliases__, _, list}, hint) do
-    expand_module_funs Module.concat(list), hint
+  ## Expand local or var
+
+  defp expand_local_or_var(hint, shell) do
+    format_expansion(match_var(hint, shell) ++ match_local(hint, false, shell), hint)
   end
 
-  defp expand_call(_, _) do
-    no()
+  defp expand_local(hint, exact?, shell) do
+    format_expansion(match_local(hint, exact?, shell), hint)
   end
 
-  defp expand_module_funs(mod, hint) do
-    format_expansion module_funs(mod, hint), hint
+  defp expand_sigil(shell) do
+    sigils =
+      match_local("sigil_", false, shell)
+      |> Enum.map(fn %{name: "sigil_" <> rest} -> %{kind: :sigil, name: rest} end)
+
+    format_expansion(match_local("~", false, shell) ++ sigils, "~")
   end
 
-  ## Erlang modules
+  defp match_local(hint, exact?, shell) do
+    imports = imports_from_env(shell) |> Enum.flat_map(&elem(&1, 1))
+    module_funs = exports(Kernel.SpecialForms)
+    match_exports(imports ++ module_funs, hint, exact?)
+  end
 
-  defp expand_erlang_modules(hint \\ "") do
-    format_expansion match_erlang_modules(hint), hint
+  defp match_var(hint, shell) do
+    variables_from_binding(hint, shell)
+    |> Enum.sort()
+    |> Enum.map(&%{kind: :variable, name: &1})
   end
 
-  defp match_erlang_modules("") do
-    Enum.filter root_modules, fn m -> m.type === :erlang end
+  ## Erlang modules
+
+  defp expand_erlang_modules(hint) do
+    format_expansion(match_erlang_modules(hint), hint)
   end
 
   defp match_erlang_modules(hint) do
-    Enum.filter root_modules, fn m -> String.starts_with?(m.name, hint) end
+    for mod <- match_modules(hint, false), usable_as_unquoted_module?(mod) do
+      %{kind: :module, name: mod}
+    end
   end
 
-  ## Elixir modules
+  ## Structs
+
+  defp expand_structs(hint, shell) do
+    aliases =
+      for {alias, mod} <- aliases_from_env(shell),
+          [name] = Module.split(alias),
+          String.starts_with?(name, hint),
+          do: {mod, name}
+
+    modules =
+      for "Elixir." <> name = full_name <- match_modules("Elixir." <> hint, true),
+          String.starts_with?(name, hint),
+          mod = String.to_atom(full_name),
+          do: {mod, name}
 
-  defp expand_elixir_modules(list, hint \\ "") do
-    mod = Module.concat(list)
-    format_expansion elixir_submodules(mod, hint, list == []) ++ module_funs(mod, hint), hint
+    all = aliases ++ modules
+    Code.ensure_all_loaded(Enum.map(all, &elem(&1, 0)))
+
+    refs =
+      for {mod, name} <- all,
+          function_exported?(mod, :__struct__, 1) and not function_exported?(mod, :exception, 1),
+          do: %{kind: :struct, name: name}
+
+    format_expansion(refs, hint)
   end
 
-  defp elixir_submodules(mod, hint, root) do
-    modname = Atom.to_string(mod)
-    depth   = length(String.split(modname, ".")) + 1
-    base    = modname <> "." <> hint
+  defp expand_container_context(code, context, hint, shell) do
+    case container_context(code, shell) do
+      {:map, map, pairs} when context == :expr ->
+        container_context_map_fields(pairs, map, hint)
 
-    Enum.reduce modules_as_lists(root), [], fn(m, acc) ->
-      if String.starts_with?(m, base) do
-        tokens = String.split(m, ".")
-        if length(tokens) == depth do
-          name = List.last(tokens)
-          [%{kind: :module, type: :elixir, name: name}|acc]
-        else
-          acc
+      {:struct, alias, pairs} when context == :expr ->
+        map = Map.from_struct(alias.__struct__())
+        container_context_map_fields(pairs, map, hint)
+
+      :bitstring_modifier ->
+        existing =
+          code
+          |> List.to_string()
+          |> String.split("::")
+          |> List.last()
+          |> String.split("-")
+
+        @bitstring_modifiers
+        |> Enum.filter(&(String.starts_with?(&1.name, hint) and &1.name not in existing))
+        |> format_expansion(hint)
+
+      _ ->
+        nil
+    end
+  end
+
+  defp container_context_map_fields(pairs, map, hint) do
+    pairs =
+      Enum.reduce(pairs, map, fn {key, _}, map ->
+        Map.delete(map, key)
+      end)
+
+    entries =
+      for key when key != :__struct__ <- Map.keys(pairs),
+          name = Atom.to_string(key),
+          if(hint == "",
+            do: not String.starts_with?(name, "_"),
+            else: String.starts_with?(name, hint)
+          ),
+          do: %{kind: :keyword, name: name}
+
+    format_expansion(entries, hint)
+  end
+
+  defp container_context(code, shell) do
+    case Code.Fragment.container_cursor_to_quoted(code) do
+      {:ok, quoted} ->
+        case Macro.path(quoted, &match?({:__cursor__, _, []}, &1)) do
+          [cursor, {:%{}, _, pairs}, {:%, _, [{:__aliases__, _, aliases = [h | _]}, _map]} | _]
+          when is_atom(h) ->
+            container_context_struct(cursor, pairs, aliases, shell)
+
+          [
+            cursor,
+            pairs,
+            {:|, _, _},
+            {:%{}, _, _},
+            {:%, _, [{:__aliases__, _, aliases = [h | _]}, _map]} | _
+          ]
+          when is_atom(h) ->
+            container_context_struct(cursor, pairs, aliases, shell)
+
+          [cursor, pairs, {:|, _, [{variable, _, nil} | _]}, {:%{}, _, _} | _] ->
+            container_context_map(cursor, pairs, variable, shell)
+
+          [cursor, {special_form, _, [cursor]} | _] when special_form in @alias_only_atoms ->
+            :alias_only
+
+          [cursor | tail] ->
+            case remove_operators(tail, cursor) do
+              [{:"::", _, [_, _]}, {:<<>>, _, [_ | _]} | _] -> :bitstring_modifier
+              _ -> nil
+            end
+
+          _ ->
+            nil
         end
-      else
-        acc
+
+      {:error, _} ->
+        nil
+    end
+  end
+
+  defp remove_operators([{op, _, [_, previous]} = head | tail], previous) when op in [:-],
+    do: remove_operators(tail, head)
+
+  defp remove_operators(tail, _previous),
+    do: tail
+
+  defp container_context_struct(cursor, pairs, aliases, shell) do
+    with {pairs, [^cursor]} <- Enum.split(pairs, -1),
+         alias = value_from_alias(aliases, shell),
+         true <-
+           Keyword.keyword?(pairs) and ensure_loaded?(alias) and
+             function_exported?(alias, :__struct__, 1) do
+      {:struct, alias, pairs}
+    else
+      _ -> nil
+    end
+  end
+
+  defp container_context_map(cursor, pairs, variable, shell) do
+    with {pairs, [^cursor]} <- Enum.split(pairs, -1),
+         {:ok, map} when is_map(map) <- value_from_binding([variable], shell),
+         true <- Keyword.keyword?(pairs) do
+      {:map, map, pairs}
+    else
+      _ -> nil
+    end
+  end
+
+  ## Aliases and modules
+
+  defp alias_only(path, hint, code, shell) do
+    with {:alias, alias} <- path,
+         [] <- hint,
+         :alias_only <- container_context(code, shell) do
+      alias ++ [?.]
+    else
+      _ -> nil
+    end
+  end
+
+  defp expand_aliases(all, shell) do
+    case String.split(all, ".") do
+      [hint] ->
+        all = match_aliases(hint, shell) ++ match_elixir_modules(Elixir, hint)
+        format_expansion(all, hint)
+
+      parts ->
+        hint = List.last(parts)
+        list = Enum.take(parts, length(parts) - 1)
+
+        value_from_alias(list, shell)
+        |> match_elixir_modules(hint)
+        |> format_expansion(hint)
+    end
+  end
+
+  defp value_from_alias([name | rest], shell) do
+    case Keyword.fetch(aliases_from_env(shell), Module.concat(Elixir, name)) do
+      {:ok, name} when rest == [] -> name
+      {:ok, name} -> Module.concat([name | rest])
+      :error -> Module.concat([name | rest])
+    end
+  end
+
+  defp match_aliases(hint, shell) do
+    for {alias, module} <- aliases_from_env(shell),
+        [name] = Module.split(alias),
+        String.starts_with?(name, hint) do
+      %{kind: :module, name: name, module: module}
+    end
+  end
+
+  defp match_elixir_modules(module, hint) do
+    name = Atom.to_string(module)
+    depth = length(String.split(name, ".")) + 1
+    base = name <> "." <> hint
+
+    for mod <- match_modules(base, module == Elixir),
+        parts = String.split(mod, "."),
+        depth <= length(parts),
+        name = Enum.at(parts, depth - 1),
+        valid_alias_piece?("." <> name),
+        uniq: true,
+        do: %{kind: :module, name: name}
+  end
+
+  defp valid_alias_piece?(<<?., char, rest::binary>>) when char in ?A..?Z,
+    do: valid_alias_rest?(rest)
+
+  defp valid_alias_piece?(_), do: false
+
+  defp valid_alias_rest?(<<char, rest::binary>>)
+       when char in ?A..?Z
+       when char in ?a..?z
+       when char in ?0..?9
+       when char == ?_,
+       do: valid_alias_rest?(rest)
+
+  defp valid_alias_rest?(<<>>), do: true
+  defp valid_alias_rest?(rest), do: valid_alias_piece?(rest)
+
+  ## Formatting
+
+  defp filter_and_format_expansion(results, hint) do
+    results
+    |> Enum.filter(&String.starts_with?(&1.name, hint))
+    |> format_expansion(hint)
+  end
+
+  defp format_expansion([], _) do
+    no()
+  end
+
+  defp format_expansion([uniq], hint) do
+    case to_hint(uniq, hint) do
+      ~c"" -> yes(~c"", [to_entry(uniq)])
+      hint -> yes(hint, [])
+    end
+  end
+
+  defp format_expansion([first | _] = entries, hint) do
+    binary = Enum.map(entries, & &1.name)
+    length = byte_size(hint)
+    prefix = :binary.longest_common_prefix(binary)
+
+    if prefix in [0, length] do
+      case Enum.group_by(entries, &Map.get(&1, :group, "Exports")) do
+        groups when map_size(groups) == 1 ->
+          yes(~c"", Enum.map(entries, &to_entry/1))
+
+        groups ->
+          sections =
+            groups
+            |> Enum.map(fn {group, entries} ->
+              %{
+                title: to_charlist(group),
+                options: [{:highlight_all}],
+                elems: Enum.map(entries, &to_entry/1)
+              }
+            end)
+            |> Enum.sort_by(&length(&1.elems))
+
+          yes(~c"", sections)
       end
+    else
+      hint = binary_part(first.name, prefix, length - prefix)
+      yes(String.to_charlist(hint), [])
     end
   end
 
-  defp modules_as_lists(true) do
-    ["Elixir.Elixir"] ++ modules_as_lists(false)
+  defp yes(hint, entries) when is_list(hint) and is_list(entries) do
+    {:yes, hint, entries}
   end
 
-  defp modules_as_lists(false) do
-    Enum.map(:code.all_loaded, fn({m, _}) -> Atom.to_string(m) end)
+  defp no do
+    {:no, ~c"", []}
   end
 
   ## Helpers
 
-  defp module_funs(mod, hint \\ "") do
-    case ensure_loaded(mod) do
-      {:module, _} ->
-        falist = get_funs(mod)
+  defp usable_as_unquoted_module?(name) do
+    # Conversion to atom is not a problem because
+    # it is only called with existing modules names.
+    Macro.classify_atom(String.to_atom(name)) in [:identifier, :unquoted]
+  end
 
-        list = Enum.reduce falist, [], fn {f, a}, acc ->
-          case :lists.keyfind(f, 1, acc) do
-            {f, aa} -> :lists.keyreplace(f, 1, acc, {f, [a|aa]})
-            false -> [{f, [a]}|acc]
-          end
-        end
+  defp match_modules(hint, elixir_root?) do
+    get_modules(elixir_root?)
+    |> Enum.sort()
+    |> Enum.dedup()
+    |> Enum.drop_while(&(not String.starts_with?(&1, hint)))
+    |> Enum.take_while(&String.starts_with?(&1, hint))
+  end
 
-        for {fun, arities} <- list,
-            name = Atom.to_string(fun),
-            String.starts_with?(name, hint) do
-          %{kind: :function, name: name, arities: arities}
-        end
-      _ ->
+  defp get_modules(true) do
+    ["Elixir.Elixir"] ++ get_modules(false)
+  end
+
+  defp get_modules(false) do
+    modules = Enum.map(:code.all_loaded(), &Atom.to_string(elem(&1, 0)))
+
+    case :code.get_mode() do
+      :interactive -> modules ++ get_modules_from_applications()
+      _otherwise -> modules
+    end
+  end
+
+  defp get_modules_from_applications do
+    for [app] <- loaded_applications(),
+        {:ok, modules} = :application.get_key(app, :modules),
+        module <- modules do
+      Atom.to_string(module)
+    end
+  end
+
+  defp loaded_applications do
+    # If we invoke :application.loaded_applications/0,
+    # it can error if we don't call safe_fixtable before.
+    # Since in both cases we are reaching over the
+    # application controller internals, we choose to match
+    # for performance.
+    :ets.match(:ac_tab, {{:loaded, :"$1"}, :_})
+  end
+
+  defp match_map_fields(map, hint) do
+    for {key, value} when is_atom(key) <- Map.to_list(map),
+        key = Atom.to_string(key),
+        String.starts_with?(key, hint) do
+      %{kind: :map_key, name: key, value_is_map: is_map(value)}
+    end
+    |> Enum.sort_by(& &1.name)
+  end
+
+  defp match_exports(funs, hint, exact?) do
+    for {fun, arity} <- funs,
+        name = Atom.to_string(fun),
+        if(exact?, do: name == hint, else: String.starts_with?(name, hint)) do
+      %{
+        kind: :export,
+        name: name,
+        arity: arity
+      }
+    end
+    |> Enum.sort_by(&{&1.name, &1.arity})
+  end
+
+  defp get_and_match_module_defs(mod, hint, exact?) do
+    cond do
+      not ensure_loaded?(mod) ->
         []
+
+      docs = get_docs(mod, [:function, :macro]) ->
+        exports(mod)
+        |> Enum.filter(fn {fun, _} ->
+          name = Atom.to_string(fun)
+          if exact?, do: name == hint, else: String.starts_with?(name, hint)
+        end)
+        |> Kernel.--(default_arg_functions_with_doc_false(docs))
+        |> Enum.sort()
+        |> Enum.flat_map(&decorate_definition(&1, docs))
+
+      true ->
+        mod
+        |> exports()
+        |> match_exports(hint, exact?)
     end
   end
 
-  defp get_funs(mod) do
-    if function_exported?(mod, :__info__, 1) do
-      if docs = Code.get_docs(mod, :docs) do
-        for {tuple, _line, _kind, _sign, doc} <- docs, doc != false, do: tuple
-      else
-        (mod.__info__(:functions) -- [__info__: 1]) ++ mod.__info__(:macros)
+  defp get_module_types(mod) do
+    if ensure_loaded?(mod) do
+      case Code.Typespec.fetch_types(mod) do
+        {:ok, types} ->
+          for {kind, {name, _, args}} <- types,
+              kind in [:type, :opaque] do
+            {name, length(args)}
+          end
+
+        :error ->
+          []
       end
     else
-      mod.module_info(:exports)
+      []
+    end
+  end
+
+  defp get_module_callbacks(mod) do
+    if ensure_loaded?(mod) do
+      case Code.Typespec.fetch_callbacks(mod) do
+        {:ok, callbacks} ->
+          for {name_arity, _} <- callbacks do
+            {_kind, name, arity} = IEx.Introspection.translate_callback_name_arity(name_arity)
+
+            {name, arity}
+          end
+
+        :error ->
+          []
+      end
+    else
+      []
+    end
+  end
+
+  defp get_docs(mod, kinds, fun \\ nil) do
+    case Code.fetch_docs(mod) do
+      {:docs_v1, _, _, _, _, _, docs} ->
+        if is_nil(fun) do
+          for {{kind, _, _}, _, _, _, _} = doc <- docs, kind in kinds, do: doc
+        else
+          for {{kind, ^fun, _}, _, _, _, _} = doc <- docs, kind in kinds, do: doc
+        end
+
+      {:error, _} ->
+        nil
+    end
+  end
+
+  defp default_arg_functions_with_doc_false(docs) do
+    for {{_, fun_name, arity}, _, _, :hidden, %{defaults: count}} <- docs,
+        new_arity <- (arity - count)..arity,
+        do: {fun_name, new_arity}
+  end
+
+  defp decorate_definition({fun, arity}, docs) do
+    case Enum.find(docs, &match?({{_, ^fun, ^arity}, _, _, _, _}, &1)) do
+      nil ->
+        case Atom.to_string(fun) do
+          "_" <> _ -> []
+          name -> [%{kind: :export, name: name, arity: arity}]
+        end
+
+      {_, _, _, :hidden, _} ->
+        []
+
+      {_, _, _, _, metadata} ->
+        group = metadata[:group] || (metadata[:guard] && "Guards") || "Exports"
+        [%{kind: :export, name: Atom.to_string(fun), arity: arity, group: group}]
     end
   end
 
-  defp ensure_loaded(Elixir), do: {:error, :nofile}
-  defp ensure_loaded(mod),    do: Code.ensure_compiled(mod)
+  defp ensure_loaded?(Elixir), do: false
+  defp ensure_loaded?(mod), do: Code.ensure_loaded?(mod)
 
   ## Ad-hoc conversions
 
-  defp to_entries(%{kind: :module, name: name}) do
-    [name]
+  defp to_entry(%{kind: :export, name: name, arity: arity}) do
+    ~c"#{name}/#{arity}"
+  end
+
+  defp to_entry(%{kind: :sigil, name: name}) do
+    ~c"~#{name} (sigil_#{name})"
   end
 
-  defp to_entries(%{kind: :function, name: name, arities: arities}) do
-    for a <- arities, do: "#{name}/#{a}"
+  defp to_entry(%{kind: :keyword, name: name}) do
+    ~c"#{name}:"
   end
 
-  defp to_uniq_entries(%{kind: :module}) do
-    []
+  defp to_entry(%{kind: _, name: name}) do
+    String.to_charlist(name)
   end
 
-  defp to_uniq_entries(%{kind: :function} = fun) do
-    to_entries(fun)
+  # Add extra character only if pressing tab when done
+  defp to_hint(%{kind: :module, name: hint}, hint) do
+    ~c"."
   end
 
-  defp to_hint(%{kind: :module, name: name}, hint) do
-    :binary.part(name, byte_size(hint), byte_size(name) - byte_size(hint)) <> "."
+  defp to_hint(%{kind: :map_key, name: hint, value_is_map: true}, hint) do
+    ~c"."
   end
 
-  defp to_hint(%{kind: :function, name: name}, hint) do
-    :binary.part(name, byte_size(hint), byte_size(name) - byte_size(hint))
+  defp to_hint(%{kind: :file, name: hint}, hint) do
+    ~c"\""
+  end
+
+  # Add extra character whenever possible
+  defp to_hint(%{kind: :dir, name: name}, hint) do
+    format_hint(name, hint) ++ ~c"/"
+  end
+
+  defp to_hint(%{kind: :struct, name: name}, hint) do
+    format_hint(name, hint) ++ ~c"{"
+  end
+
+  defp to_hint(%{kind: :keyword, name: name}, hint) do
+    format_hint(name, hint) ++ ~c": "
+  end
+
+  defp to_hint(%{kind: _, name: name}, hint) do
+    format_hint(name, hint)
+  end
+
+  defp format_hint(name, hint) do
+    hint_size = byte_size(hint)
+
+    name
+    |> binary_part(hint_size, byte_size(name) - hint_size)
+    |> String.to_charlist()
+  end
+
+  ## Evaluator interface
+
+  defp imports_from_env(shell) do
+    with {evaluator, server} <- IEx.Broker.evaluator(shell),
+         env_fields = IEx.Evaluator.fields_from_env(evaluator, server, [:functions, :macros]),
+         %{functions: funs, macros: macros} <- env_fields do
+      funs ++ macros
+    else
+      _ -> []
+    end
+  end
+
+  defp aliases_from_env(shell) do
+    with {evaluator, server} <- IEx.Broker.evaluator(shell),
+         %{aliases: aliases} <- IEx.Evaluator.fields_from_env(evaluator, server, [:aliases]) do
+      aliases
+    else
+      _ -> []
+    end
+  end
+
+  defp variables_from_binding(hint, shell) do
+    with {evaluator, server} <- IEx.Broker.evaluator(shell) do
+      IEx.Evaluator.variables_from_binding(evaluator, server, hint)
+    else
+      _ -> []
+    end
+  end
+
+  defp value_from_binding([var | path], shell) do
+    with {evaluator, server} <- IEx.Broker.evaluator(shell) do
+      IEx.Evaluator.value_from_binding(evaluator, server, var, path)
+    else
+      _ -> :error
+    end
+  end
+
+  ## Path helpers
+
+  defp path_fragment(expr), do: path_fragment(expr, [])
+  defp path_fragment([], _acc), do: []
+  defp path_fragment([?{, ?# | _rest], _acc), do: []
+  defp path_fragment([?", ?\\ | t], acc), do: path_fragment(t, [?\\, ?" | acc])
+
+  defp path_fragment([?/, ?:, x, ?" | _], acc) when x in ?a..?z or x in ?A..?Z,
+    do: [x, ?:, ?/ | acc]
+
+  defp path_fragment([?/, ?., ?" | _], acc), do: [?., ?/ | acc]
+  defp path_fragment([?/, ?" | _], acc), do: [?/ | acc]
+  defp path_fragment([?" | _], _acc), do: []
+  defp path_fragment([h | t], acc), do: path_fragment(t, [h | acc])
+
+  defp expand_path(path) do
+    path
+    |> List.to_string()
+    |> ls_prefix()
+    |> Enum.map(fn path ->
+      %{
+        kind: if(File.dir?(path), do: :dir, else: :file),
+        name: Path.basename(path)
+      }
+    end)
+    |> format_expansion(path_hint(path))
+  end
+
+  defp path_hint(path) do
+    if List.last(path) in [?/, ?\\] do
+      ""
+    else
+      Path.basename(path)
+    end
+  end
+
+  defp prefix_from_dir(".", <<c, _::binary>>) when c != ?., do: ""
+  defp prefix_from_dir(dir, _fragment), do: dir
+
+  defp ls_prefix(path) do
+    dir = Path.dirname(path)
+    prefix = prefix_from_dir(dir, path)
+
+    case File.ls(dir) do
+      {:ok, list} ->
+        list
+        |> Enum.map(&Path.join(prefix, &1))
+        |> Enum.filter(&String.starts_with?(&1, path))
+
+      _ ->
+        []
+    end
   end
 end
diff --git a/lib/iex/lib/iex/broker.ex b/lib/iex/lib/iex/broker.ex
new file mode 100644
index 00000000000..d2d9ed57140
--- /dev/null
+++ b/lib/iex/lib/iex/broker.ex
@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule IEx.Broker do
+  @moduledoc false
+  @name __MODULE__
+
+  @type take_ref :: {takeover_ref :: reference(), server_ref :: reference()}
+  @type shell :: pid | nil
+
+  use GenServer
+
+  ## Shell API
+
+  @doc """
+  Finds the evaluator and server running inside `:user_drv`, on this node exclusively.
+  """
+  @spec evaluator(shell()) :: {evaluator :: pid, server :: pid} | nil
+  def evaluator(pid \\ :shell.whereis()) do
+    if pid do
+      {:dictionary, dictionary} = Process.info(pid, :dictionary)
+      {dictionary[:evaluator], pid}
+    end
+  end
+
+  ## Broker API
+
+  def start_link(_) do
+    GenServer.start_link(@name, :ok, name: @name)
+  end
+
+  @doc """
+  Registers an IEx server in the broker.
+
+  All instances, except shell ones, are registered.
+  """
+  @spec register(pid) :: :ok
+  def register(pid) do
+    GenServer.call(@name, {:register, pid})
+  end
+
+  @doc """
+  Client responds to a takeover request.
+
+  The broker's PID is needed to support remote shells.
+  """
+  @spec respond(pid, take_ref, integer(), boolean()) ::
+          :ok | {:error, :refused | :already_accepted}
+  def respond(broker_pid, take_ref, counter, true) do
+    GenServer.call(broker_pid, {:accept, take_ref, Process.group_leader(), counter})
+  end
+
+  def respond(broker_pid, take_ref, _counter, false) do
+    GenServer.call(broker_pid, {:refuse, take_ref})
+  end
+
+  @doc """
+  Client requests a takeover.
+  """
+  @spec take_over(binary, iodata, keyword) ::
+          {:ok, server :: pid, group_leader :: pid, counter :: integer}
+          | {:error, :no_iex | :refused | atom()}
+  def take_over(location, whereami, opts) do
+    case GenServer.whereis(@name) do
+      nil -> {:error, :no_iex}
+      _pid -> GenServer.call(@name, {:take_over, location, whereami, opts}, :infinity)
+    end
+  end
+
+  ## Callbacks
+
+  @impl true
+  def init(:ok) do
+    state = %{
+      servers: %{},
+      takeovers: %{}
+    }
+
+    {:ok, state}
+  end
+
+  @impl true
+  def handle_call({:take_over, location, whereami, opts}, {_, ref} = from, state) do
+    case servers(state) do
+      [] ->
+        {:reply, {:error, :no_iex}, state}
+
+      servers ->
+        server_refs =
+          for {server_ref, server_pid} <- servers do
+            send(server_pid, {:take_over, self(), {ref, server_ref}, location, whereami, opts})
+            server_ref
+          end
+
+        state = put_in(state.takeovers[ref], {from, server_refs})
+        {:noreply, state}
+    end
+  end
+
+  def handle_call({:register, pid}, _from, state) do
+    ref = Process.monitor(pid)
+    state = put_in(state.servers[ref], pid)
+    {:reply, :ok, state}
+  end
+
+  def handle_call({:accept, {ref, _server_ref}, group_leader, counter}, {server, _}, state) do
+    case pop_in(state.takeovers[ref]) do
+      {nil, state} ->
+        {:reply, {:error, :already_accepted}, state}
+
+      {{from, _}, state} ->
+        GenServer.reply(from, {:ok, server, group_leader, counter})
+        {:reply, :ok, state}
+    end
+  end
+
+  def handle_call({:refuse, {ref, server_ref}}, _from, state) do
+    if takeover = state.takeovers[ref] do
+      {:reply, {:error, :refused}, refuse(state, ref, takeover, server_ref)}
+    else
+      {:reply, {:error, :refused}, state}
+    end
+  end
+
+  @impl true
+  def handle_info({:DOWN, server_ref, _, _, _}, state) do
+    {_pid, state} = pop_in(state.servers[server_ref])
+
+    state =
+      Enum.reduce(state.takeovers, state, fn {ref, takeover}, state ->
+        refuse(state, ref, takeover, server_ref)
+      end)
+
+    {:noreply, state}
+  end
+
+  defp refuse(state, ref, {from, server_refs}, server_ref) do
+    case List.delete(server_refs, server_ref) do
+      [] ->
+        {_, state} = pop_in(state.takeovers[ref])
+        GenServer.reply(from, {:error, :refused})
+        state
+
+      server_refs ->
+        put_in(state.takeovers[ref], {from, server_refs})
+    end
+  end
+
+  defp servers(state) do
+    if pid = local_or_remote_shell() do
+      [{Process.monitor(pid), pid} | Enum.to_list(state.servers)]
+    else
+      Enum.to_list(state.servers)
+    end
+  end
+
+  defp local_or_remote_shell() do
+    Enum.find_value([node() | Node.list()], fn node ->
+      try do
+        case :erpc.call(node, :shell, :whereis, []) do
+          pid when is_pid(pid) -> pid
+          :undefined -> nil
+        end
+      catch
+        _, _ -> nil
+      end
+    end)
+  end
+end
diff --git a/lib/iex/lib/iex/cli.ex b/lib/iex/lib/iex/cli.ex
deleted file mode 100644
index c2e24afc122..00000000000
--- a/lib/iex/lib/iex/cli.ex
+++ /dev/null
@@ -1,143 +0,0 @@
-# IEx sets the Erlang user to be IEx.CLI via the command line.
-# While this works most of the time, there are some problems
-# that may happen depending on how the booting process goes.
-# Those problems need to be manually tested in case changes are
-# done to this file.
-#
-# 1. In some situations, printing something before the shell
-#    starts becomes very slow. To verify this feature, just
-#    get an existing project and run:
-#
-#      $ mix clean
-#      $ iex -S mix
-#
-#    If the printing of data is slower than usual. This particular
-#    bug has arisen;
-#
-# 2. In some situations, connecting to a remote node via --remsh
-#    is not possible. This can be tested by starting two iex nodes:
-#
-#      $ iex --sname foo
-#      $ iex --sname bar --remsh foo@localhost
-#
-# 3. When still using --remsh, we need to guarantee the arguments
-#    are processed on the local node and not the remote one. For such,
-#    one can replace the last line above by:
-#
-#      $ iex --sname bar --remsh foo@localhost -e IO.inspect node
-#
-#    And verify that the local node name is printed.
-#
-# 4. Finally, in some other circumstances, printing messages may become
-#    borked. This can be verified with:
-#
-#      $ iex -e ":error_logger.info_msg("foo~nbar", [])"
-#
-# By the time those instructions have been written, all tests above pass.
-defmodule IEx.CLI do
-  @moduledoc false
-
-  @doc """
-  In order to work properly, IEx needs to be set as the
-  proper `-user` when starting the Erlang VM and we do so
-  by pointing exactly to this function.
-
-  If possible, Elixir will start a tty (smart terminal)
-  which makes all control commands available in tty
-  available to the developer.
-
-  In case `tty` is not available (for example, Windows),
-  a dumb terminal version is started instead.
-  """
-  def start do
-    if tty_works? do
-      :user_drv.start([:"tty_sl -c -e", tty_args])
-    else
-      :user.start
-      IO.puts "Warning: could not run smart terminal, falling back to dumb one"
-      local_start()
-    end
-  end
-
-  # Check if tty works. If it does not, we fall back to the
-  # simple/dumb terminal. This is starting the linked in
-  # driver twice, it would be nice and appropriate if we had
-  # to do it just once.
-  defp tty_works? do
-    try do
-      port = Port.open {:spawn, 'tty_sl -c -e'}, [:eof]
-      Port.close(port)
-    catch
-      _, _ -> false
-    end
-  end
-
-  defp tty_args do
-    if remote = get_remsh(:init.get_plain_arguments) do
-      if Node.alive? do
-        case :rpc.call remote, :code, :ensure_loaded, [IEx] do
-          {:badrpc, reason} ->
-            abort "Could not contact remote node #{remote}, reason: #{inspect reason}. Aborting..."
-          {:module, IEx} ->
-            {remote, :erlang, :apply, [remote_start_function, []]}
-          _ ->
-            abort "Could not find IEx on remote node #{remote}. Aborting..."
-        end
-      else
-        abort "In order to use --remsh, you need to name the current node using --name or --sname. Aborting..."
-      end
-    else
-      {:erlang, :apply, [local_start_function, []]}
-    end
-  end
-
-  def local_start do
-    IEx.start(config(), {:elixir, :start_cli, []})
-  end
-
-  def remote_start(parent, ref) do
-    send parent, {:begin, ref, self}
-    receive do: ({:done, ^ref} -> :ok)
-  end
-
-  defp local_start_function do
-    &local_start/0
-  end
-
-  defp remote_start_function do
-    ref    = make_ref
-    config = config()
-
-    parent = spawn_link fn ->
-      receive do
-        {:begin, ^ref, other} ->
-          :elixir.start_cli
-          send other, {:done, ref}
-      end
-    end
-
-    fn ->
-      IEx.start(config, {__MODULE__, :remote_start, [parent, ref]})
-    end
-  end
-
-  defp config do
-    [dot_iex_path: find_dot_iex(:init.get_plain_arguments)]
-  end
-
-  defp abort(msg) do
-    function = fn ->
-      IO.puts(:stderr, msg)
-      System.halt(1)
-    end
-    {:erlang, :apply, [function, []]}
-  end
-
-  defp find_dot_iex(['--dot-iex', h|_]), do: List.to_string(h)
-  defp find_dot_iex([_|t]), do: find_dot_iex(t)
-  defp find_dot_iex([]), do: nil
-
-  defp get_remsh(['--remsh', h|_]), do: List.to_atom(h)
-  defp get_remsh([_|t]), do: get_remsh(t)
-  defp get_remsh([]), do: nil
-end
diff --git a/lib/iex/lib/iex/config.ex b/lib/iex/lib/iex/config.ex
new file mode 100644
index 00000000000..85f3ca20190
--- /dev/null
+++ b/lib/iex/lib/iex/config.ex
@@ -0,0 +1,224 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule IEx.Config do
+  @moduledoc false
+  use Agent
+
+  @table __MODULE__
+  @agent __MODULE__
+  @keys [
+    :colors,
+    :inspect,
+    :history_size,
+    :default_prompt,
+    :alive_prompt,
+    :width,
+    :parser,
+    :dot_iex,
+    :auto_reload
+  ]
+
+  # Generate a continuation prompt based on IEx prompt.
+  # This is set as global configuration on app start.
+  def prompt(prompt) do
+    case Enum.split_while(prompt, &(&1 != ?()) do
+      # It is not the default Elixir shell, so we use the default prompt
+      {_, []} ->
+        List.duplicate(?\s, max(0, prompt_width(prompt) - 3)) ++ ~c".. "
+
+      {left, right} ->
+        List.duplicate(?., prompt_width(left)) ++ right
+    end
+  end
+
+  # TODO: Remove this when we require Erlang/OTP 27+
+  @compile {:no_warn_undefined, :prim_tty}
+  @compile {:no_warn_undefined, :shell}
+  defp prompt_width(prompt) do
+    if function_exported?(:prim_tty, :npwcwidthstring, 1) do
+      :prim_tty.npwcwidthstring(prompt)
+    else
+      :shell.prompt_width(prompt)
+    end
+  end
+
+  # Read API
+
+  def configuration() do
+    Application.get_all_env(:iex) |> Keyword.take(@keys)
+  end
+
+  def width() do
+    columns = columns()
+    value = Application.get_env(:iex, :width) || 80
+    min(value, columns)
+  end
+
+  defp columns() do
+    case :io.columns() do
+      {:ok, width} -> width
+      {:error, _} -> 80
+    end
+  end
+
+  def started?() do
+    Process.whereis(@agent) != nil
+  end
+
+  def history_size() do
+    Application.fetch_env!(:iex, :history_size)
+  end
+
+  def default_prompt() do
+    Application.fetch_env!(:iex, :default_prompt)
+  end
+
+  def alive_prompt() do
+    Application.fetch_env!(:iex, :alive_prompt)
+  end
+
+  def parser() do
+    # Since the parser itself can be invoked from the remote node
+    # without IEx running, we cannot use fetch_env!
+    Application.get_env(:iex, :parser, {IEx.Evaluator, :parse, []})
+  end
+
+  def color(color) do
+    color(color, Application.get_env(:iex, :colors, []))
+  end
+
+  defp color(color, colors) do
+    if colors_enabled?(colors) do
+      case Keyword.fetch(colors, color) do
+        {:ok, value} -> value
+        :error -> default_color(color)
+      end
+    else
+      nil
+    end
+  end
+
+  defp colors_enabled?(colors) do
+    Keyword.get_lazy(colors, :enabled, &IO.ANSI.enabled?/0)
+  end
+
+  def dot_iex() do
+    Application.get_env(:iex, :dot_iex)
+  end
+
+  def auto_reload?() do
+    Application.fetch_env!(:iex, :auto_reload)
+  end
+
+  # Used by default on evaluation cycle
+  defp default_color(:eval_interrupt), do: [:yellow]
+  defp default_color(:eval_result), do: [:yellow]
+  defp default_color(:eval_error), do: [:red]
+  defp default_color(:eval_info), do: [:normal]
+  defp default_color(:stack_info), do: [:red]
+  defp default_color(:blame_diff), do: [:red]
+
+  # Used by ls
+  defp default_color(:ls_directory), do: [:blue]
+  defp default_color(:ls_device), do: [:green]
+
+  # Used by inspect
+  defp default_color(:syntax_colors) do
+    IO.ANSI.syntax_colors()
+  end
+
+  # Used by ansi docs
+  defp default_color(doc_color) do
+    IO.ANSI.Docs.default_options() |> Keyword.fetch!(doc_color)
+  end
+
+  def ansi_docs() do
+    colors = Application.get_env(:iex, :colors, [])
+    enabled = colors_enabled?(colors)
+    [width: width(), enabled: enabled] ++ colors
+  end
+
+  def inspect_opts() do
+    Application.get_env(:iex, :inspect, [])
+    |> Keyword.put_new_lazy(:width, &width/0)
+    |> update_syntax_colors()
+  end
+
+  defp update_syntax_colors(opts) do
+    colors = Application.get_env(:iex, :colors, [])
+
+    if syntax_colors = color(:syntax_colors, colors) do
+      reset = [:reset | List.wrap(color(:eval_result, colors))]
+      syntax_colors = [reset: reset] ++ syntax_colors
+      Keyword.update(opts, :syntax_colors, syntax_colors, &Keyword.merge(syntax_colors, &1))
+    else
+      opts
+    end
+  end
+
+  # Agent API
+
+  def start_link(_) do
+    Agent.start_link(__MODULE__, :handle_init, [], name: @agent)
+  end
+
+  def after_spawn(fun) do
+    Agent.update(@agent, __MODULE__, :handle_after_spawn, [fun])
+  end
+
+  def after_spawn() do
+    :ets.lookup_element(@table, :after_spawn, 2)
+  end
+
+  def configure(options) do
+    Agent.update(@agent, __MODULE__, :handle_configure, [options])
+  end
+
+  # Agent callbacks
+
+  def handle_init do
+    :ets.new(@table, [:named_table, :public])
+    true = :ets.insert_new(@table, after_spawn: [])
+    @table
+  end
+
+  def handle_after_spawn(tab, fun) do
+    :ets.update_element(tab, :after_spawn, {2, [fun | after_spawn()]})
+  end
+
+  def handle_configure(tab, options) do
+    Enum.each(options, &validate_option/1)
+
+    configuration()
+    |> Keyword.merge(options, &merge_option/3)
+    |> update_configuration()
+
+    tab
+  end
+
+  defp update_configuration(config) do
+    Enum.each(config, fn {key, value} when key in @keys ->
+      Application.put_env(:iex, key, value)
+    end)
+  end
+
+  defp merge_option(:colors, old, new) when is_list(new), do: Keyword.merge(old, new)
+  defp merge_option(:inspect, old, new) when is_list(new), do: Keyword.merge(old, new)
+  defp merge_option(_key, _old, new), do: new
+
+  defp validate_option({:colors, new}) when is_list(new), do: :ok
+  defp validate_option({:inspect, new}) when is_list(new), do: :ok
+  defp validate_option({:history_size, new}) when is_integer(new), do: :ok
+  defp validate_option({:default_prompt, new}) when is_binary(new), do: :ok
+  defp validate_option({:alive_prompt, new}) when is_binary(new), do: :ok
+  defp validate_option({:width, new}) when is_integer(new), do: :ok
+  defp validate_option({:parser, tuple}) when tuple_size(tuple) == 3, do: :ok
+  defp validate_option({:dot_iex, path}) when is_binary(path), do: :ok
+  defp validate_option({:auto_reload, enabled}) when is_boolean(enabled), do: :ok
+
+  defp validate_option(option) do
+    raise ArgumentError, "invalid configuration #{inspect(option)}"
+  end
+end
diff --git a/lib/iex/lib/iex/evaluator.ex b/lib/iex/lib/iex/evaluator.ex
index 6d6ce100a3e..47351e034a2 100644
--- a/lib/iex/lib/iex/evaluator.ex
+++ b/lib/iex/lib/iex/evaluator.ex
@@ -1,6 +1,12 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule IEx.Evaluator do
   @moduledoc false
 
+  alias IEx.Config
+
   @doc """
   Eval loop for an IEx session. Its responsibilities include:
 
@@ -10,213 +16,438 @@ defmodule IEx.Evaluator do
     * keeping expression history
 
   """
-  def start(server, leader) do
-    IEx.History.init
-    old_leader = Process.group_leader
-    Process.group_leader(self, leader)
+  def init(command, server, leader, start, opts) do
+    ref = make_ref()
+    old_leader = Process.group_leader()
+    Process.group_leader(self(), leader)
+
+    old_server = Process.get(:iex_server)
+    Process.put(:iex_server, server)
+
+    old_evaluator = Process.get(:iex_evaluator)
+    Process.put(:iex_evaluator, ref)
+
+    if old_evaluator do
+      send(self(), {:done, old_evaluator, false})
+    end
+
+    state = loop_state(ref, server, IEx.History.init(start), opts)
+    command == :ack && :proc_lib.init_ack(self())
 
     try do
-      loop(server)
+      loop(state)
     after
-      IEx.History.reset
-      Process.group_leader(self, old_leader)
+      Process.group_leader(self(), old_leader)
+
+      if old_server do
+        Process.put(:iex_server, old_server)
+      else
+        Process.delete(:iex_server)
+      end
+
+      if old_evaluator do
+        Process.put(:iex_evaluator, old_evaluator)
+      else
+        Process.delete(:iex_evaluator)
+      end
+
+      :ok
     end
   end
 
-  defp loop(server) do
+  @break_trigger ~c"#iex:break\n"
+
+  @op_tokens [:or_op, :and_op, :comp_op, :rel_op, :arrow_op, :in_op] ++
+               [:three_op, :concat_op, :mult_op]
+
+  @doc """
+  Default parsing implementation with support for pipes and #iex:break.
+
+  If parsing fails, this might be a TokenMissingError which we treat in
+  a special way (to allow for continuation of an expression on the next
+  line in IEx).
+  """
+  def parse(input, opts, parser_state)
+
+  def parse(input, opts, []), do: parse(input, opts, {[], :other})
+
+  def parse(input, opts, {buffer, last_op}) do
+    input = buffer ++ input
+    file = Keyword.get(opts, :file, "nofile")
+    line = Keyword.get(opts, :line, 1)
+    column = Keyword.get(opts, :column, 1)
+
+    if List.ends_with?(input, @break_trigger) do
+      triplet = {~c"", line, column, 0}
+      :elixir_errors.parse_error([line: line], file, "incomplete expression", "", triplet)
+    else
+      result =
+        with {:ok, tokens} <- :elixir.string_to_tokens(input, line, column, file, opts),
+             {:ok, adjusted_tokens, adjusted_op} <-
+               adjust_operator(tokens, line, column, file, opts, last_op),
+             {:ok, forms} <- :elixir.tokens_to_quoted(adjusted_tokens, file, opts) do
+          last_op =
+            case forms do
+              {:=, _, [_, _]} -> :match
+              _ -> :other
+            end
+
+          forms =
+            if adjusted_op != nil do
+              quote do
+                IEx.Evaluator.assert_no_error!()
+                unquote(forms)
+              end
+            else
+              forms
+            end
+
+          {:ok, forms, last_op}
+        end
+
+      case result do
+        {:ok, forms, last_op} ->
+          {:ok, forms, {[], last_op}}
+
+        {:error, {_, _, ""}} ->
+          {:incomplete, {input, last_op}}
+
+        {:error, {location, error, token}} ->
+          :elixir_errors.parse_error(
+            location,
+            file,
+            error,
+            token,
+            {input, line, column, 0}
+          )
+      end
+    end
+  end
+
+  defp adjust_operator([{op_type, _, token} | _] = _tokens, line, column, _file, _opts, :match)
+       when op_type in @op_tokens,
+       do:
+         {:error,
+          {[line: line, column: column],
+           "pipe shorthand is not allowed immediately after a match expression in IEx. To make it work, surround the whole pipeline with parentheses ",
+           "'#{token}'"}}
+
+  defp adjust_operator([{op_type, _, _} | _] = tokens, line, column, file, opts, _last_op)
+       when op_type in @op_tokens do
+    {:ok, prefix} = :elixir.string_to_tokens(~c"v(-1)", line, column, file, opts)
+    {:ok, prefix ++ tokens, op_type}
+  end
+
+  defp adjust_operator(tokens, _line, _column, _file, _opts, _last_op), do: {:ok, tokens, nil}
+
+  @doc """
+  Raises an error if the last iex result was itself an error
+  """
+  def assert_no_error!() do
+    if Process.get(:iex_error, false) do
+      message = "skipping evaluation of expression because pipeline has failed"
+      reraise RuntimeError.exception(message), []
+    end
+  end
+
+  @doc """
+  Gets a value out of the binding, using the provided
+  variable name and map key path.
+  """
+  @spec value_from_binding(pid, pid, atom, [atom]) :: {:ok, any} | :error
+  def value_from_binding(evaluator, server, var_name, map_key_path) do
+    ref = make_ref()
+    send(evaluator, {:value_from_binding, server, ref, self(), var_name, map_key_path})
+
     receive do
-      {:eval, ^server, code, config} ->
-        send server, {:evaled, self, eval(code, config)}
-        loop(server)
-      {:done, ^server} ->
-        IEx.History.reset
-        :ok
+      {^ref, result} -> result
+    after
+      5000 -> :error
     end
   end
 
   @doc """
-  Locates and loads an .iex.exs file from one of predefined locations.
-  Returns the new config.
+  Gets a list of variables out of the binding that match the passed
+  variable prefix.
   """
-  def load_dot_iex(config, path \\ nil) do
-    candidates = if path do
-      [path]
-    else
-      Enum.map [".iex.exs", "~/.iex.exs"], &Path.expand/1
+  @spec variables_from_binding(pid, pid, String.t()) :: [String.t()]
+  def variables_from_binding(evaluator, server, variable_prefix) do
+    ref = make_ref()
+    send(evaluator, {:variables_from_binding, server, ref, self(), variable_prefix})
+
+    receive do
+      {^ref, result} -> result
+    after
+      5000 -> []
     end
+  end
+
+  @doc """
+  Returns the named fields from the current session environment.
+  """
+  @spec fields_from_env(pid, pid, [atom]) :: %{optional(atom) => term}
+  def fields_from_env(evaluator, server, fields) do
+    ref = make_ref()
+    send(evaluator, {:fields_from_env, server, ref, self(), fields})
 
-    path = Enum.find candidates, &File.regular?/1
+    receive do
+      {^ref, result} -> result
+    after
+      5000 -> %{}
+    end
+  end
 
-    if nil?(path) do
-      config
+  defp loop(%{server: server, ref: ref} = state) do
+    receive do
+      {:reader_errored, ^server} ->
+        Process.put(:iex_error, true)
+        loop(state)
+
+      {:eval, ^server, code, counter} ->
+        {status, state} = safe_eval_and_inspect(code, counter, state)
+        send(server, {:evaled, self(), status})
+        loop(state)
+
+      {:fields_from_env, ^server, ref, receiver, fields} ->
+        send(receiver, {ref, Map.take(state.env, fields)})
+        loop(state)
+
+      {:value_from_binding, ^server, ref, receiver, var_name, map_key_path} ->
+        value = traverse_binding(state.binding, var_name, map_key_path)
+        send(receiver, {ref, value})
+        loop(state)
+
+      {:variables_from_binding, ^server, ref, receiver, var_prefix} ->
+        value = find_matched_variables(state.binding, var_prefix)
+        send(receiver, {ref, value})
+        loop(state)
+
+      {:done, ^server, next?} ->
+        {:ok, next?}
+
+      {:done, ^ref, next?} ->
+        {:ok, next?}
+    end
+  end
+
+  defp traverse_binding(binding, var_name, map_key_path) do
+    accumulator = Keyword.fetch(binding, var_name)
+
+    Enum.reduce(map_key_path, accumulator, fn
+      key, {:ok, map} when is_map(map) -> Map.fetch(map, key)
+      _key, _acc -> :error
+    end)
+  end
+
+  defp find_matched_variables(binding, var_prefix) do
+    for {var_name, _value} <- binding,
+        is_atom(var_name),
+        var_name = Atom.to_string(var_name),
+        String.starts_with?(var_name, var_prefix),
+        do: var_name
+  end
+
+  defp loop_state(ref, server, history, opts) do
+    env = opts[:env] || Code.env_for_eval(file: "iex")
+    {_, _, env} = Code.eval_quoted_with_env(quote(do: import(IEx.Helpers)), [], env)
+    stacktrace = opts[:stacktrace]
+    binding = opts[:binding] || []
+
+    state = %{
+      binding: binding,
+      env: env,
+      server: server,
+      history: history,
+      stacktrace: stacktrace,
+      ref: ref
+    }
+
+    dot_iex = opts[:dot_iex] || Config.dot_iex()
+
+    case dot_iex do
+      "" -> state
+      path -> load_dot_iex(state, path)
+    end
+  end
+
+  defp load_dot_iex(state, path) do
+    candidates =
+      if path do
+        [path]
+      else
+        # Do not assume there is a $HOME
+        for dir <- [".", System.get_env("IEX_HOME") || System.user_home()],
+            dir != nil,
+            do: dir |> Path.join(".iex.exs") |> Path.expand()
+      end
+
+    path = Enum.find(candidates, &File.regular?/1)
+
+    if is_nil(path) do
+      state
     else
-      eval_dot_iex(config, path)
+      eval_dot_iex(state, path)
     end
   end
 
-  defp eval_dot_iex(config, path) do
+  defp eval_dot_iex(state, path) do
     try do
       code = File.read!(path)
-      env  = :elixir.env_for_eval(config.env, file: path, line: 1)
+      quoted = :elixir.string_to_quoted!(String.to_charlist(code), 1, 1, path, [])
+      Process.put(:iex_imported_paths, MapSet.new([path]))
 
       # Evaluate the contents in the same environment server_loop will run in
-      {_result, binding, env, _scope} =
-        :elixir.eval(String.to_char_list(code), config.binding, env)
-
-      %{config | binding: binding, env: :elixir.env_for_eval(env, file: "iex", line: 1)}
+      env = %{state.env | file: path, line: 1}
+      {_result, binding, env} = eval_expr_by_expr(quoted, state.binding, env)
+      %{state | binding: binding, env: %{env | file: "iex", line: 1}}
     catch
       kind, error ->
-        io_result "Error while evaluating: #{path}"
-        print_error(kind, error, System.stacktrace)
-        System.halt(1)
+        io_result("Error while evaluating: #{path}")
+        print_error(kind, error, __STACKTRACE__)
+        state
+    after
+      Process.delete(:iex_imported_paths)
     end
   end
 
-  # Instead of doing just `:elixir.eval`, we first parse the expression to see
-  # if it's well formed. If parsing succeeds, we evaluate the AST as usual.
-  #
-  # If parsing fails, this might be a TokenMissingError which we treat in
-  # a special way (to allow for continuation of an expression on the next
-  # line in IEx). In case of any other error, we let :elixir_translator
-  # to re-raise it.
-  #
-  # Returns updated config.
-  #
-  # The first two clauses provide support for the break-trigger allowing to
-  # break out from a pending incomplete expression. See
-  # https://github.com/elixir-lang/elixir/issues/1089 for discussion.
-  @break_trigger '#iex:break\n'
-
-  defp eval(code, config) do
-    try do
-      do_eval(String.to_char_list(code), config)
-    catch
-      kind, error ->
-        print_error(kind, error, System.stacktrace)
-        %{config | cache: ''}
-    end
+  defp safe_eval_and_inspect(forms, counter, state) do
+    put_history(state)
+    put_whereami(state)
+    result = eval_and_inspect(forms, counter, state)
+    Process.delete(:iex_error)
+    {:ok, result}
+  catch
+    kind, error ->
+      Process.put(:iex_error, true)
+      print_error(kind, error, __STACKTRACE__)
+      {:error, state}
+  after
+    Process.delete(:iex_history)
+    Process.delete(:iex_whereami)
+  end
+
+  defp put_history(%{history: history}) do
+    Process.put(:iex_history, history)
   end
 
-  defp do_eval(@break_trigger, config=%IEx.Config{cache: ''}) do
-    config
+  defp put_whereami(%{env: %{file: "iex"}}) do
+    :ok
   end
 
-  defp do_eval(@break_trigger, config) do
-    :elixir_errors.parse_error(config.counter, "iex", "incomplete expression", "")
+  defp put_whereami(%{env: %{file: file, line: line}, stacktrace: stacktrace}) do
+    Process.put(:iex_whereami, {file, line, stacktrace})
   end
 
-  defp do_eval(latest_input, config) do
-    code = config.cache ++ latest_input
-    line = config.counter
+  defp eval_and_inspect(forms, line, state) do
+    %{env: env, binding: binding} = state
+    forms = add_if_undefined_apply_to_vars(forms, env)
+    {result, binding, env} = eval_expr_by_expr(forms, binding, env)
+
+    if result != IEx.dont_display_result() do
+      io_inspect(result)
+    end
+
+    history = IEx.History.append(state.history, {line, result}, IEx.Config.history_size())
+    %{state | env: env, binding: binding, history: history}
+  end
 
-    case Code.string_to_quoted(code, [line: line, file: "iex"]) do
-      {:ok, forms} ->
-        {result, new_binding, env, scope} =
-          :elixir.eval_forms(forms, config.binding, config.env, config.scope)
-        unless result == IEx.dont_display_result, do: io_inspect(result)
-        update_history(line, code, result)
-        %{config | env: env,
-                   cache: '',
-                   scope: scope,
-                   binding: new_binding,
-                   counter: config.counter + 1}
-      {:error, {line, error, token}} ->
-        if token == "" do
-          # Update config.cache so that IEx continues to add new input to
-          # the unfinished expression in `code`
-          %{config | cache: code}
+  defp add_if_undefined_apply_to_vars(forms, env) do
+    Macro.prewalk(forms, fn
+      {var, meta, context} when is_atom(var) and is_atom(context) ->
+        if Macro.Env.lookup_import(env, {var, 0}) != [] do
+          {var, Keyword.put_new(meta, :if_undefined, :apply), context}
         else
-          # Encountered malformed expression
-          :elixir_errors.parse_error(line, "iex", error, token)
+          {var, meta, context}
         end
-    end
+
+      other ->
+        other
+    end)
   end
 
-  defp update_history(counter, cache, result) do
-    IEx.History.append({counter, cache, result}, counter,
-                       Application.get_env(:iex, :history_size))
+  defp eval_expr_by_expr(expr, binding, env) do
+    case maybe_expand(expr, env) do
+      {:__block__, _, exprs} ->
+        Enum.reduce(exprs, {nil, binding, env}, fn expr, {_result, binding, env} ->
+          eval_expr_by_expr(expr, binding, env)
+        end)
+
+      expr ->
+        Code.eval_quoted_with_env(expr, binding, env)
+    end
   end
 
+  defp maybe_expand({import_file, _, [_ | _]} = expr, env)
+       when import_file in [:import_file, :import_file_if_available],
+       do: Macro.expand(expr, env)
+
+  defp maybe_expand(expr, _env),
+    do: expr
+
   defp io_inspect(result) do
-    io_result inspect(result, IEx.inspect_opts)
+    io_result(inspect(result, IEx.inspect_opts()))
   end
 
   defp io_result(result) do
-    IO.puts :stdio, IEx.color(:eval_result, result)
-  end
-
-  defp io_error(result) do
-    IO.puts :stdio, IEx.color(:eval_error, result)
+    IO.puts(:stdio, IEx.color(:eval_result, result))
   end
 
   ## Error handling
 
   defp print_error(kind, reason, stacktrace) do
-    {reason, stacktrace} = normalize_exception(kind, reason, stacktrace)
+    {blamed, stacktrace} =
+      case reason do
+        %CompileError{description: "cannot compile file (errors have been logged)" <> _, line: 0} ->
+          {%CompileError{description: "cannot compile code (errors have been logged)"}, []}
 
-    message = Exception.format_banner(kind, reason, stacktrace)
-    io_error message
-    io_error (stacktrace |> prune_stacktrace |> format_stacktrace)
-  end
+        _ ->
+          Exception.blame(kind, reason, stacktrace)
+      end
 
-  defp normalize_exception(:error, :undef, [{IEx.Helpers, fun, arity, _}|t]) do
-    {%RuntimeError{message: "undefined function: #{format_function(fun, arity)}"}, t}
-  end
+    ansidata =
+      case blamed do
+        %FunctionClauseError{} ->
+          {_, inspect_opts} = pop_in(IEx.inspect_opts()[:syntax_colors][:reset])
+          banner = Exception.format_banner(kind, reason, stacktrace)
+          blame = FunctionClauseError.blame(blamed, &inspect(&1, inspect_opts), &blame_match/1)
+          [IEx.color(:eval_error, banner), pad(blame)]
+
+        _ ->
+          banner = Exception.format_banner(kind, blamed, stacktrace)
+          [IEx.color(:eval_error, banner)]
+      end
 
-  defp normalize_exception(_kind, reason, stacktrace) do
-    {reason, stacktrace}
+    stackdata = Exception.format_stacktrace(prune_stacktrace(stacktrace))
+    IO.write(:stdio, [ansidata, ?\n, IEx.color(:stack_info, stackdata)])
   end
 
-  defp format_function(fun, arity) do
-    cond do
-      is_list(arity) ->
-        "#{fun}/#{length(arity)}"
-      true ->
-        "#{fun}/#{arity}"
-    end
+  defp pad(string) do
+    "    " <> String.replace(string, "\n", "\n    ")
   end
 
-  defp prune_stacktrace(stacktrace) do
-    # The order in which each drop_while is listed is important.
-    # For example, the user my call Code.eval_string/2 in IEx
-    # and if there is an error we should not remove erl_eval
-    # and eval_bits information from the user stacktrace.
-    stacktrace
-    |> Enum.reverse()
-    |> Enum.drop_while(&(elem(&1, 0) == __MODULE__))
-    |> Enum.drop_while(&(elem(&1, 0) == :elixir))
-    |> Enum.drop_while(&(elem(&1, 0) in [:erl_eval, :eval_bits]))
-    |> Enum.reverse()
-  end
+  defp blame_match(%{match?: true, node: node}), do: Macro.to_string(node)
+  defp blame_match(%{match?: false, node: node}), do: blame_ansi(:blame_diff, "-", node)
 
-  @doc false
-  def format_stacktrace(trace) do
-    entries =
-      for entry <- trace do
-        split_entry(Exception.format_stacktrace_entry(entry))
-      end
+  defp blame_ansi(color, no_ansi, node) do
+    case IEx.Config.color(color) do
+      nil ->
+        no_ansi <> Macro.to_string(node) <> no_ansi
 
-    width = Enum.reduce entries, 0, fn {app, _}, acc ->
-      max(String.length(app), acc)
+      ansi ->
+        [ansi | Macro.to_string(node)]
+        |> IO.ANSI.format(true)
+        |> IO.iodata_to_binary()
     end
-
-    "    " <> Enum.map_join(entries, "\n    ", &format_entry(&1, width))
   end
 
-  defp split_entry(entry) do
-    case entry do
-      "(" <> _ ->
-        case :binary.split(entry, ") ") do
-          [left, right] -> {left <> ") ", right}
-          _ -> {"", entry}
-        end
-      _ ->
-        {"", entry}
+  defp prune_stacktrace(stack) do
+    stack
+    |> Enum.reverse()
+    |> Enum.drop_while(&(elem(&1, 0) != :elixir_eval))
+    |> Enum.reverse()
+    |> case do
+      [] -> stack
+      stack -> stack
     end
   end
-
-  defp format_entry({app, info}, width) do
-    app = String.rjust(app, width)
-    "#{IEx.color(:stack_app, app)}#{IEx.color(:stack_info, info)}"
-  end
 end
diff --git a/lib/iex/lib/iex/helpers.ex b/lib/iex/lib/iex/helpers.ex
index 60e8a5580d8..493f046195b 100644
--- a/lib/iex/lib/iex/helpers.ex
+++ b/lib/iex/lib/iex/helpers.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule IEx.Helpers do
   @moduledoc """
   Welcome to Interactive Elixir. You are currently
@@ -5,96 +9,338 @@ defmodule IEx.Helpers do
   which provides many helpers to make Elixir's shell
   more joyful to work with.
 
-  This message was triggered by invoking the helper
-  `h()`, usually referred to as `h/0` (since it expects 0
-  arguments).
+  This message was triggered by invoking the helper `h()`,
+  usually referred to as `h/0` (since it expects 0 arguments).
+
+  You can use the `h/1` function to invoke the documentation
+  for any Elixir module or function:
+
+      iex> h(Enum)
+      iex> h(Enum.map)
+      iex> h(Enum.reverse/1)
+
+  You can also use the `i/1` function to introspect any value
+  you have in the shell:
+
+      iex> i("hello")
+
+  There are many other helpers available, here are some examples:
+
+    * `b/1`             - prints callbacks info and docs for a given module
+    * `c/1`             - compiles a file
+    * `c/2`             - compiles a file and writes bytecode to the given path
+    * `cd/1`            - changes the current directory
+    * `clear/0`         - clears the screen
+    * `exports/1`       - shows all exports (functions + macros) in a module
+    * `flush/0`         - flushes all messages sent to the shell
+    * `h/0`             - prints this help message
+    * `h/1`             - prints help for the given module, function or macro
+    * `i/0`             - prints information about the last value
+    * `i/1`             - prints information about the given term
+    * `ls/0`            - lists the contents of the current directory
+    * `ls/1`            - lists the contents of the specified directory
+    * `open/1`          - opens the source for the given module or function in your editor
+    * `pid/1`           - creates a PID from a string
+    * `pid/3`           - creates a PID with the 3 integer arguments passed
+    * `port/1`          - creates a port from a string
+    * `port/2`          - creates a port with the 2 non-negative integers passed
+    * `process_info/1`  - returns information about the given process
+    * `pwd/0`           - prints the current working directory
+    * `r/1`             - recompiles the given module's source file
+    * `recompile/0`     - recompiles the current project
+    * `ref/1`           - creates a reference from a string
+    * `ref/4`           - creates a reference with the 4 integer arguments passed
+    * `runtime_info/0`  - prints runtime info (versions, memory usage, stats)
+    * `t/1`             - prints the types for the given module or function
+    * `v/0`             - retrieves the last value from the history
+    * `v/1`             - retrieves the nth value from the history
+
+  There are also several helpers available when debugging, such as:
+
+    * `break!/2`        - sets a breakpoint at `Module.function/arity`
+    * `breaks/0`        - prints all breakpoints to the terminal
+    * `c/0`             - a shortcut for `continue/0`
+    * `continue/0`      - continues execution of the current process
+    * `n/0`             - a shortcut for `next/0`
+    * `next/0`          - goes to the next line of the current breakpoint
+    * `remove_breaks/0` - removes all breakpoints and instrumentation from all modules
+    * `whereami/1`      - prints the current location and stacktrace in a pry session
+
+  Help for all of those functions can be consulted directly from
+  the command line using the `h/1` helper itself. Try:
+
+      iex> h(v/0)
+
+  To list all IEx helpers available, which is effectively all
+  exports (functions and macros) in the `IEx.Helpers` module:
+
+      iex> exports(IEx.Helpers)
+
+  This module also includes helpers for debugging purposes, see
+  `IEx.break!/4` for more information.
+
+  To learn more about IEx as a whole, type `h(IEx)`.
+  """
+
+  import IEx, only: [dont_display_result: 0]
+
+  @doc """
+  Recompiles the current Mix project or Mix install
+  dependencies.
+
+  This helper requires either `Mix.install/2` to have been
+  called within the current IEx session or for IEx to be
+  started alongside, for example, `iex -S mix`.
 
-  There are many other helpers available:
+  In the `Mix.install/1` case, it will recompile any outdated
+  path dependency declared during install. Within a project,
+  it will recompile any outdated module.
 
-    * `c/2`       — compiles a file at the given path
-    * `cd/1`      — changes the current directory
-    * `clear/0`   — clears the screen
-    * `flush/0`   — flushes all messages sent to the shell
-    * `h/0`       — prints this help message
-    * `h/1`       — prints help for the given module, function or macro
-    * `l/1`       — loads the given module's beam code and purges the current version
-    * `ls/0`      — lists the contents of the current directory
-    * `ls/1`      — lists the contents of the specified directory
-    * `pwd/0`     — prints the current working directory
-    * `r/1`       — recompiles and reloads the given module's source file
-    * `respawn/0` — respawns the current shell
-    * `s/1`       — prints spec information
-    * `t/1`       — prints type information
-    * `v/0`       — prints the history of commands evaluated in the session
-    * `v/1`       — retrieves the nth value from the history
-    * `import_file/1`
-                  — evaluates the given file in the shell's context
+  Note this function simply recompiles Elixir modules, without
+  reloading configuration or restarting applications. This means
+  any long running process may crash on recompilation, as changed
+  modules will be temporarily removed and recompiled, without
+  going through the proper code change callback.
 
-  Help for functions in this module can be consulted
-  directly from the command line, as an example, try:
+  If you want to reload a single module, consider using
+  `r(ModuleName)` instead.
 
-      h(c/2)
+  This function is meant to be used for development and
+  debugging purposes. Do not depend on it in production code.
 
-  You can also retrieve the documentation for any module
-  or function. Try these:
+  ## Options
 
-      h(Enum)
-      h(Enum.reverse/1)
+    * `:force` - when `true`, forces the application to recompile
 
-  To learn more about IEx as a whole, just type `h(IEx)`.
   """
+  @spec recompile(force: boolean()) :: :ok | :error | :noop
+  def recompile(options \\ []) do
+    cond do
+      not mix_started?() ->
+        IO.puts(IEx.color(:eval_error, "Mix is not running. Please start IEx with: iex -S mix"))
+        :error
+
+      Mix.installed?() ->
+        Mix.in_install_project(fn ->
+          # TODO: remove this once Mix requires Hex with the fix from
+          # https://github.com/hexpm/hex/pull/1015
+          # Context: Mix.install/1 starts :hex if necessary and stops
+          # it afterwards. Calling compile here may require hex to be
+          # started and that should happen automatically, but because
+          # of a bug it is not (fixed in the linked PR).
+          _ = Application.ensure_all_started(:hex)
+
+          do_recompile(options)
+          # Just as with Mix.install/2 we clear all task invocations,
+          # so that we can recompile the dependencies again next time
+          Mix.Task.clear()
+          :ok
+        end)
 
-  import IEx, only: [dont_display_result: 0]
+      true ->
+        project = Mix.Project.get()
+
+        if is_nil(project) or
+             project.__info__(:compile)[:source] == String.to_charlist(Path.absname("mix.exs")) do
+          Mix.Project.with_build_lock(fn ->
+            purge_result = IEx.MixListener.purge()
+
+            case do_recompile(options) do
+              :noop -> purge_result
+              compile_result -> compile_result
+            end
+          end)
+        else
+          message = "Cannot recompile because the current working directory changed"
+          IO.puts(IEx.color(:eval_error, message))
+        end
+    end
+  end
+
+  defp do_recompile(options) do
+    config = Mix.Project.config()
+    consolidation = Mix.Project.consolidation_path(config)
+    reenable_tasks(config)
+
+    force? = Keyword.get(options, :force, false)
+    args = ["--purge-consolidation-path-if-stale", consolidation, "--return-errors"]
+    args = if force?, do: ["--force" | args], else: args
+
+    {result, _} = Mix.Task.run("compile", args)
+    result
+  end
+
+  defp mix_started? do
+    List.keyfind(Application.started_applications(), :mix, 0) != nil
+  end
+
+  defp reenable_tasks(config) do
+    compilers = config[:compilers] || Mix.compilers()
+    Mix.Task.Compiler.reenable(compilers)
+  end
 
   @doc """
-  Expects a list of files to compile and a path
-  to write their object code to. It returns the name
-  of the compiled modules.
+  Compiles the given files.
+
+  It expects a list of files to compile and an optional path to write
+  the compiled code to. By default files are in-memory compiled.
+  To write compiled files to the current directory, `"."` can be given.
+
+  It returns the names of the compiled modules.
 
-  When compiling one file, there is no need to wrap it in a list.
+  If you want to recompile an existing module, check `r/1` instead.
+
+  > #### Remote compilation {: .warning}
+  >
+  > When compiling code, warnings and errors may be printed to standard error.
+  > However, when connecting to a remote node, the standard error output is not
+  > redirected to the client. This means that compilation failures will be written
+  > to the logs or the output terminal of the machine you connect to.
 
   ## Examples
 
-      c ["foo.ex", "bar.ex"], "ebin"
-      #=> [Foo,Bar]
+  In the example below, we pass a directory to where the `c/2` function will
+  write the compiled `.beam` files to. This directory is typically named "ebin"
+  in Erlang/Elixir systems:
+
+      iex> c(["foo.ex", "bar.ex"], "ebin")
+      [Foo, Bar]
+
+  When compiling one file, there is no need to wrap it in a list:
+
+      iex> c("baz.ex")
+      [Baz]
 
-      c "baz.ex"
-      #=> [Baz]
   """
-  def c(files, path \\ ".") when is_binary(path) do
+  def c(files, path \\ :in_memory) when is_binary(path) or path == :in_memory do
     files = List.wrap(files)
 
-    unless Enum.all?(files, &is_binary/1) do
+    if not Enum.all?(files, &is_binary/1) do
       raise ArgumentError, "expected a binary or a list of binaries as argument"
     end
 
-    {found, not_found} =
-      files
-      |> Enum.map(&Path.expand(&1, path))
-      |> Enum.partition(&File.exists?/1)
+    {found, not_found} = Enum.split_with(files, &File.exists?/1)
 
-    unless Enum.empty?(not_found) do
+    if not Enum.empty?(not_found) do
       raise ArgumentError, "could not find files #{Enum.join(not_found, ", ")}"
     end
 
-    {erls, exs} = Enum.partition(found, &String.ends_with?(&1, ".erl"))
+    {erls, exs} = Enum.split_with(found, &String.ends_with?(&1, ".erl"))
 
-    modules = Enum.map(erls, fn(source) ->
-      {module, binary} = compile_erlang(source)
-      base = source |> Path.basename |> Path.rootname
-      File.write!(Path.join(path, base <> ".beam"), binary)
-      module
-    end)
+    erl_modules =
+      Enum.map(erls, fn source ->
+        {module, binary} = compile_erlang(source)
+
+        if path != :in_memory do
+          base = source |> Path.basename() |> Path.rootname()
+          File.write!(Path.join(path, base <> ".beam"), binary)
+        end
+
+        module
+      end)
 
-    modules ++ Kernel.ParallelCompiler.files_to_path(exs, path)
+    ex_modules =
+      case compile_elixir(exs, path) do
+        {:ok, modules, _} -> modules
+        {:error, _, _} -> raise CompileError
+      end
+
+    erl_modules ++ ex_modules
+  end
+
+  @doc """
+  Clears the console screen.
+
+  This function only works if ANSI escape codes are enabled
+  on the shell, which means this function is by default
+  unavailable on Windows machines.
+  """
+  def clear() do
+    if IO.ANSI.enabled?() do
+      IO.write([IO.ANSI.home(), IO.ANSI.clear()])
+    else
+      IO.puts("Cannot clear the screen because ANSI escape codes are not enabled on this shell")
+    end
+
+    dont_display_result()
+  end
+
+  @doc """
+  Opens the current prying location.
+
+  This command only works inside a pry session started manually
+  via `IEx.pry/0` or a breakpoint set via `IEx.break!/4`. Calling
+  this function during a regular `IEx` session will print an error.
+
+  Keep in mind the `open/0` location may not exist when prying
+  precompiled source code, such as Elixir itself.
+
+  For more information and to open any module or function, see
+  `open/1`.
+  """
+  def open() do
+    case Process.get(:iex_whereami) do
+      {file, line, _} ->
+        IEx.Introspection.open({file, line})
+
+      _ ->
+        IO.puts(IEx.color(:eval_error, "Pry session is not currently enabled"))
+    end
+
+    dont_display_result()
   end
 
   @doc """
-  Clear the console screen.
+  Opens the given `module`, `module.function/arity`, or `{file, line}`.
+
+  This function uses the `ELIXIR_EDITOR` environment variable
+  and falls back to `EDITOR` if the former is not available.
+
+  By default, it attempts to open the file and line using the
+  `file:line` notation. For example, for Sublime Text you can
+  set it as:
+
+      ELIXIR_EDITOR="subl"
+
+  Which will then try to open it as:
+
+      subl path/to/file:line
+
+  For Visual Studio Code, once enabled on the command line,
+  you can set it to:
+
+      ELIXIR_EDITOR="code --goto"
+
+  It is important that you choose an editor command that does
+  not block nor that attempts to run an editor directly in the
+  terminal. Command-line based editors likely need extra
+  configuration so they open up the given file and line in a
+  separate window.
+
+  For more complex use cases, you can use the `__FILE__` and
+  `__LINE__` notations to explicitly interpolate the file and
+  line into the command:
+
+      ELIXIR_EDITOR="my_editor +__LINE__ __FILE__"
+
+  Since this function prints the result returned by the editor,
+  `ELIXIR_EDITOR` can be set "echo" if you prefer to display the
+  location rather than opening it.
+
+  Keep in mind the location may not exist when opening precompiled
+  source code.
+
+  ## Examples
+
+      iex> open(MyApp)
+      iex> open(MyApp.fun/2)
+      iex> open({"path/to/file", 1})
+
   """
-  def clear do
-    IO.write [IO.ANSI.home, IO.ANSI.clear]
-    dont_display_result
+  defmacro open(term) do
+    quote do
+      IEx.Introspection.open(unquote(decompose(term, __CALLER__)))
+    end
   end
 
   @doc """
@@ -102,205 +348,654 @@ defmodule IEx.Helpers do
   """
   def h() do
     IEx.Introspection.h(IEx.Helpers)
-    dont_display_result
   end
 
   @doc """
   Prints the documentation for the given module
-  or for the given function/arity pair.
+  or for the given `function/arity` pair.
 
   ## Examples
 
-      h(Enum)
-      #=> Prints documentation for Enum
+      iex> h(Enum)
 
-  It also accepts functions in the format `fun/arity`
-  and `module.fun/arity`, for example:
+  It also accepts functions in the format `function/arity`
+  and `module.function/arity`, for example:
 
-      h receive/1
-      h Enum.all?/2
-      h Enum.all?
+      iex> h(receive/1)
+      iex> h(Enum.all?/2)
+      iex> h(Enum.all?)
 
   """
-  @h_modules [__MODULE__, Kernel, Kernel.SpecialForms]
+  defmacro h(term) do
+    quote do
+      IEx.Introspection.h(unquote(decompose(term, __CALLER__)))
+    end
+  end
 
-  defmacro h({:/, _, [call, arity]} = other) do
-    args =
-      case Macro.decompose_call(call) do
-        {_mod, :__info__, []} when arity == 1 ->
-          [Module, :__info__, 1]
-        {mod, fun, []} ->
-          [mod, fun, arity]
-        {fun, []} ->
-          [@h_modules, fun, arity]
-        _ ->
-          [other]
-      end
+  @doc """
+  Prints the documentation for the given callback function.
 
+  It also accepts single module argument to list
+  all available behaviour callbacks.
+
+  ## Examples
+
+      iex> b(Mix.Task.run/1)
+      iex> b(Mix.Task.run)
+      iex> b(GenServer)
+
+  """
+  defmacro b(term) do
     quote do
-      IEx.Introspection.h(unquote_splicing(args))
+      IEx.Introspection.b(unquote(decompose(term, __CALLER__)))
     end
   end
 
-  defmacro h(call) do
-    args =
-      case Macro.decompose_call(call) do
-        {_mod, :__info__, []} ->
-          [Module, :__info__, 1]
-        {mod, fun, []} ->
-          [mod, fun]
-        {fun, []} ->
-          [@h_modules, fun]
-        _ ->
-          [call]
-      end
+  @doc """
+  Prints the types for the given module or for the given function/arity pair.
 
+  ## Examples
+
+      iex> t(Enum)
+      @type t() :: Enumerable.t()
+      @type acc() :: any()
+      @type element() :: any()
+      @type index() :: integer()
+      @type default() :: any()
+
+      iex> t(Enum.t/0)
+      @type t() :: Enumerable.t()
+
+      iex> t(Enum.t)
+      @type t() :: Enumerable.t()
+
+  """
+  defmacro t(term) do
     quote do
-      IEx.Introspection.h(unquote_splicing(args))
+      IEx.Introspection.t(unquote(decompose(term, __CALLER__)))
     end
   end
 
   @doc """
-  When given a module, prints specifications (or simply specs) for all the
-  types defined in it.
+  Returns the value of the `n`th expression in the history.
 
-  When given a particular type name, prints its spec.
+  `n` can be a negative value: if it is, the corresponding expression value
+  relative to the current one is returned. For example, `v(-2)` returns the
+  value of the expression evaluated before the last evaluated expression. In
+  particular, `v(-1)` returns the result of the last evaluated expression and
+  `v()` does the same.
 
   ## Examples
 
-      t(Enum)
-      t(Enum.t/0)
-      t(Enum.t)
+      iex(1)> "hello" <> " world"
+      "hello world"
+      iex(2)> 40 + 2
+      42
+      iex(3)> v(-2)
+      "hello world"
+      iex(4)> v(2)
+      42
+      iex(5)> v()
+      42
+
   """
-  defmacro t({:/, _, [{{:., _, [mod, fun]}, _, []}, arity]}) do
-    quote do
-      IEx.Introspection.t(unquote(mod), unquote(fun), unquote(arity))
-    end
+  def v(n \\ -1) do
+    IEx.History.nth(history(), n) |> elem(1)
   end
 
-  defmacro t({{:., _, [mod, fun]}, _, []}) do
-    quote do
-      IEx.Introspection.t(unquote(mod), unquote(fun))
+  @doc """
+  Recompiles and reloads the given `module` or `modules`.
+
+  Please note that all the modules defined in the same file as
+  `modules` are recompiled and reloaded. If you want to reload
+  multiple modules, it is best to reload them at the same time,
+  such as in `r [Foo, Bar]`. This is important to avoid false
+  warnings, since the module is only reloaded in memory and its
+  latest information is not persisted to disk. See the "In-memory
+  reloading" section below.
+
+  This function is meant to be used for development and
+  debugging purposes. Do not depend on it in production code.
+
+  ## In-memory reloading
+
+  When we reload the module in IEx, we recompile the module source
+  code, updating its contents in memory. The original `.beam` file
+  in disk, probably the one where the first definition of the module
+  came from, does not change at all.
+
+  Since docs, typespecs, and exports information are loaded from the
+  .beam file, they are not reloaded when you invoke this function.
+  """
+  def r(module_or_modules) do
+    modules = List.wrap(module_or_modules)
+
+    sources =
+      Enum.map(modules, fn module ->
+        if not Code.ensure_loaded?(module) do
+          raise ArgumentError, "could not load nor find module: #{inspect(module)}"
+        end
+
+        source = source(module)
+
+        cond do
+          source == nil ->
+            raise ArgumentError, "could not find source for module: #{inspect(module)}"
+
+          not File.exists?(source) ->
+            raise ArgumentError,
+                  "could not find source (#{source}) for module: #{inspect(module)}"
+
+          true ->
+            source
+        end
+      end)
+
+    {erlang, elixir} = Enum.split_with(sources, &String.ends_with?(&1, ".erl"))
+
+    erlang =
+      for source <- erlang do
+        compile_erlang(source) |> elem(0)
+      end
+
+    elixir =
+      if elixir != [] do
+        {:ok, modules, _warning} =
+          Kernel.ParallelCompiler.compile(elixir, return_diagnostics: true)
+
+        modules
+      else
+        []
+      end
+
+    {:reloaded, erlang ++ elixir}
+  end
+
+  @doc """
+  Loads the given module's BEAM code (and ensures any previous
+  old version was properly purged before).
+
+  This function is useful when you know the bytecode for module
+  has been updated in the file system and you want to tell the VM
+  to load it.
+  """
+  def l(module) when is_atom(module) do
+    :code.purge(module)
+    :code.load_file(module)
+  end
+
+  @doc """
+  Prints information about the data type of any given term.
+
+  If no argument is given, the value of the previous expression
+  is used.
+
+  ## Examples
+
+      iex> i(1..5)
+
+  Will print:
+
+      Term
+        1..5
+      Data type
+        Range
+      Description
+        This is a struct. Structs are maps with a __struct__ key.
+      Reference modules
+        Range, Map
+
+  """
+  def i(term \\ v(-1)) do
+    implemented_protocols = [{"Implemented protocols", all_implemented_protocols_for_term(term)}]
+    info = [{"Term", inspect(term)}] ++ IEx.Info.info(term) ++ implemented_protocols
+
+    for {subject, info} <- info do
+      info = info |> to_string() |> String.trim() |> String.replace("\n", "\n  ")
+      IO.puts(IEx.color(:eval_result, to_string(subject)))
+      IO.puts(IEx.color(:eval_info, "  #{info}"))
     end
+
+    dont_display_result()
   end
 
-  defmacro t(module) do
-    quote do
-      IEx.Introspection.t(unquote(module))
+  defp decompose(term, context) do
+    case IEx.Introspection.decompose(term, context) do
+      :error -> term
+      m_mf_mfa -> Macro.escape(m_mf_mfa)
     end
   end
 
-  @doc """
-  Similar to `t/1`, only for specs.
+  # Given any "term", this function returns all the protocols in
+  # :code.get_path() implemented by the data structure of such term, in the form
+  # of a binary like "Protocol1, Protocol2, Protocol3".
+  defp all_implemented_protocols_for_term(term) do
+    :code.get_path()
+    |> Protocol.extract_protocols()
+    |> Enum.uniq()
+    |> Enum.filter(fn protocol ->
+      Code.ensure_loaded?(protocol) and function_exported?(protocol, :impl_for, 1) and
+        protocol.impl_for(term) != nil
+    end)
+    |> Enum.sort()
+    |> Enum.map_join(", ", &inspect/1)
+  end
 
-  When given a module, prints the list of all specs defined in the module.
+  @runtime_info_topics [:system, :memory, :limits, :applications, :allocators]
+  @doc """
+  Prints VM/runtime information such as versions, memory usage and statistics.
 
-  When given a particular spec name (with optional arity), prints its spec.
+  Additional topics are available via `runtime_info/1`.
 
-  ## Examples
+  For more metrics, info, and debugging facilities, see the
+  [Recon](https://github.com/ferd/recon) project.
+  """
+  @doc since: "1.5.0"
+  def runtime_info(), do: runtime_info([:system, :memory, :limits])
 
-      s(Enum)
-      s(Enum.all?)
-      s(Enum.all?/2)
-      s(is_atom)
-      s(is_atom/1)
+  @doc """
+  Just like `runtime_info/0`, except accepts topic or a list of topics.
 
+  For example, topic `:applications` will list the applications loaded.
   """
-  defmacro s({:/, _, [call, arity]} = other) do
-    args =
-      case Macro.decompose_call(call) do
-        {mod, fun, []} -> [mod, fun, arity]
-        {fun, []} -> [Kernel, fun, arity]
-        _ -> [other]
+  @doc since: "1.5.0"
+  def runtime_info(topic) when is_atom(topic) and topic in @runtime_info_topics do
+    topic
+    |> List.wrap()
+    |> runtime_info()
+  end
+
+  def runtime_info(topics) when is_list(topics) do
+    topics
+    |> Enum.uniq()
+    |> print_runtime_info()
+  end
+
+  defp print_runtime_info(topics) do
+    Enum.each(topics, &print_runtime_info_topic/1)
+    IO.puts("")
+    print_topic_info(topics)
+    IO.puts("")
+    dont_display_result()
+  end
+
+  defp print_topic_info(topics) when is_list(topics) do
+    IO.write(pad_key("Showing topics:"))
+    IO.puts(inspect(topics))
+    IO.write(pad_key("Additional topics:"))
+    IO.puts(inspect(@runtime_info_topics -- topics))
+    IO.puts("")
+    IO.puts("To view a specific topic call runtime_info(topic)")
+  end
+
+  defp print_runtime_info_topic(:system) do
+    print_pane("System and architecture")
+
+    print_entry("Elixir version", System.version())
+    print_entry("Erlang/OTP version", System.otp_release())
+    print_entry("ERTS version", :erlang.system_info(:version))
+    print_entry("Compiled for", :erlang.system_info(:system_architecture))
+    print_entry("Schedulers", :erlang.system_info(:schedulers))
+    print_entry("Schedulers online", :erlang.system_info(:schedulers_online))
+  end
+
+  defp print_runtime_info_topic(:memory) do
+    print_pane("Memory")
+    print_memory("Atoms", :atom)
+    print_memory("Binaries", :binary)
+    print_memory("Code", :code)
+    print_memory("ETS", :ets)
+    print_memory("Processes", :processes)
+    print_memory("Total", :total)
+  end
+
+  defp print_runtime_info_topic(:limits) do
+    print_pane("Statistics / limits")
+    print_uptime()
+    print_entry("Run queue", :erlang.statistics(:run_queue))
+
+    print_percentage("Atoms", :atom_count, :atom_limit)
+    print_percentage("ETS", :ets_count, :ets_limit)
+    print_percentage("Ports", :port_count, :port_limit)
+    print_percentage("Processes", :process_count, :process_limit)
+  end
+
+  defp print_runtime_info_topic(:applications) do
+    print_pane("Loaded OTP applications")
+    started = Application.started_applications()
+    loaded = Application.loaded_applications()
+
+    for {app, _, version} = entry <- Enum.sort(loaded) do
+      IO.write(pad_key(Atom.to_string(app)))
+      IO.write(String.pad_trailing("#{version}", 20))
+
+      if entry in started do
+        IO.write("(started)")
       end
 
-    quote do
-      IEx.Introspection.s(unquote_splicing(args))
+      IO.puts("")
+    end
+
+    :ok
+  end
+
+  @allocator_column_padding 12
+  @allocator_size_padding 19
+
+  defp print_runtime_info_topic(:allocators) do
+    allocator_sizes_map = get_allocator_sizes()
+
+    if Enum.empty?(allocator_sizes_map) do
+      IO.puts(IEx.color(:eval_error, "Could not get allocator sizes."))
+    else
+      print_pane("Memory allocators")
+
+      IO.puts([
+        String.duplicate(" ", @allocator_column_padding),
+        String.pad_leading("Block size", @allocator_size_padding),
+        String.pad_leading("Carrier size", @allocator_size_padding),
+        String.pad_leading("Max carrier size", @allocator_size_padding)
+      ])
+
+      print_allocator("Temporary", allocator_sizes_map.temp_alloc)
+      print_allocator("Short-lived", allocator_sizes_map.sl_alloc)
+      print_allocator("STD", allocator_sizes_map.std_alloc)
+      print_allocator("Long-lived", allocator_sizes_map.ll_alloc)
+      print_allocator("Erlang heap", allocator_sizes_map.eheap_alloc)
+      print_allocator("ETS", allocator_sizes_map.ets_alloc)
+      print_allocator("Fix", allocator_sizes_map.fix_alloc)
+      print_allocator("Literal", allocator_sizes_map.literal_alloc)
+      print_allocator("Binary", allocator_sizes_map.binary_alloc)
+      print_allocator("Driver", allocator_sizes_map.driver_alloc)
+      print_allocator("Total", allocator_sizes_map.total)
     end
   end
 
-  defmacro s(call) do
-    args =
-      case Macro.decompose_call(call) do
-        {mod, fun, []} -> [mod, fun]
-        {fun, []} -> [Kernel, fun]
-        _ -> [call]
+  defp print_pane(msg) do
+    IO.puts(IEx.color(:eval_result, ["\n## ", msg, " \n"]))
+  end
+
+  defp print_entry(_key, nil), do: :ok
+  defp print_entry(key, value), do: IO.puts("#{pad_key(key)}#{value}")
+
+  defp print_uptime() do
+    IO.write(pad_key("Uptime"))
+    :c.uptime()
+  end
+
+  defp print_percentage(key, min, max) do
+    min = get_stat(min)
+    max = get_stat(max)
+    percentage = trunc(min / max * 100)
+    IO.puts("#{pad_key(key)}#{min} / #{max} (#{percentage}% used)")
+  end
+
+  defp get_stat(:ets_count), do: :erlang.system_info(:ets_count)
+  defp get_stat(other), do: :erlang.system_info(other)
+
+  defp print_memory(key, memory) do
+    value = :erlang.memory(memory)
+    IO.puts("#{pad_key(key)}#{format_bytes(value)}")
+  end
+
+  defp print_allocator(title, %{
+         block_size: block_size,
+         carrier_size: carriers_size,
+         max_carrier_size: max_carriers_size
+       }) do
+    IO.puts([
+      String.pad_trailing(title, @allocator_column_padding),
+      block_size |> format_bytes(:KB) |> String.pad_leading(@allocator_size_padding),
+      carriers_size |> format_bytes(:KB) |> String.pad_leading(@allocator_size_padding),
+      max_carriers_size |> format_bytes(:KB) |> String.pad_leading(@allocator_size_padding)
+    ])
+  end
+
+  defp get_allocator_sizes() do
+    alloc_util_allocators = :erlang.system_info(:alloc_util_allocators)
+
+    allocators_map =
+      Map.new(
+        [:total | alloc_util_allocators],
+        &{&1, %{block_size: 0, carrier_size: 0, max_carrier_size: 0}}
+      )
+
+    try do
+      for {allocator, allocator_instances} <-
+            :erlang.system_info({:allocator_sizes, alloc_util_allocators}),
+          {:instance, _, instance_info} <- allocator_instances,
+          {_, [{:blocks, blocks}, {:carriers_size, ccs, mcs, _}]} <-
+            instance_info,
+          reduce: allocators_map do
+        acc ->
+          cbs =
+            case blocks do
+              [{_, [{:size, bs, _, _}]}] -> bs
+              _ -> 0
+            end
+
+          %{
+            block_size: block_size,
+            carrier_size: carrier_size,
+            max_carrier_size: max_carrier_size
+          } = Map.fetch!(acc, allocator)
+
+          %{
+            block_size: total_block_size,
+            carrier_size: total_carrier_size,
+            max_carrier_size: total_max_carrier_size
+          } = Map.fetch!(acc, :total)
+
+          acc
+          |> Map.replace!(allocator, %{
+            block_size: block_size + cbs,
+            carrier_size: carrier_size + ccs,
+            max_carrier_size: max_carrier_size + mcs
+          })
+          |> Map.replace!(:total, %{
+            block_size: total_block_size + cbs,
+            carrier_size: total_carrier_size + ccs,
+            max_carrier_size: total_max_carrier_size + mcs
+          })
       end
+    rescue
+      _ -> %{}
+    end
+  end
 
-    quote do
-      IEx.Introspection.s(unquote_splicing(args))
+  defp format_bytes(bytes) when is_integer(bytes) do
+    cond do
+      bytes >= memory_unit(:GB) -> format_bytes(bytes, :GB)
+      bytes >= memory_unit(:MB) -> format_bytes(bytes, :MB)
+      bytes >= memory_unit(:KB) -> format_bytes(bytes, :KB)
+      true -> format_bytes(bytes, :B)
     end
   end
 
+  defp format_bytes(bytes, unit) when is_integer(bytes) and unit in [:GB, :MB, :KB] do
+    value =
+      bytes
+      |> div(memory_unit(unit))
+      |> round()
+
+    "#{value} #{unit}"
+  end
+
+  defp format_bytes(bytes, :B) when is_integer(bytes), do: "#{bytes} B"
+
+  defp memory_unit(:GB), do: 1024 * 1024 * 1024
+  defp memory_unit(:MB), do: 1024 * 1024
+  defp memory_unit(:KB), do: 1024
+
+  defp pad_key(key), do: String.pad_trailing(key, 21, " ")
+
+  @process_info_keys_and_labels [
+    {:initial_call, "Initial call"},
+    {:dictionary, "Dictionary"},
+    {:registered_name, "Registered name"},
+    {:current_function, "Current function"},
+    {:status, "Status"},
+    {:message_queue_len, "Message queue length"},
+    {:trap_exit, "Trap exit"},
+    {:priority, "Priority"},
+    {:group_leader, "Group leader"},
+    {:reductions, "Reductions"},
+    {:links, "Links"},
+    {:monitors, "Monitors"},
+    {:memory, "Memory"},
+    {:total_heap_size, "Total heap size"},
+    {:heap_size, "Heap size"},
+    {:stack_size, "Stack size"},
+    {:current_stacktrace, "Current stacktrace"}
+  ]
+  @process_info_keys Enum.map(@process_info_keys_and_labels, fn {key, _} -> key end)
+  @process_info_label_mapping Map.new(@process_info_keys_and_labels)
+
   @doc """
-  Prints the history of expressions evaluated during the session along with
-  their results.
+  Prints information about the given process.
+
+  Includes a generic overview and details such as the linked and monitored processes,
+  the memory usage and the current stacktrace.
+
+  ## Examples
+
+      iex> process_info(self())
+      ...
+      iex> process_info({:via, Registry, {MyApp.Registry, :name}})
+      ...
+
   """
-  def v do
-    inspect_opts = IEx.inspect_opts
-    IEx.History.each(&print_history_entry(&1, inspect_opts))
+  @doc since: "1.19.0"
+  def process_info(pid) do
+    with pid when is_pid(pid) <- GenServer.whereis(pid),
+         info when is_list(info) <-
+           :erpc.call(node(pid), :erlang, :process_info, [pid, @process_info_keys]) do
+      info = Map.new(info)
+
+      IO.puts(IEx.color(:eval_result, ["\n# Process ", inspect(pid)]))
+
+      print_process_overview(info)
+      print_process_links(info[:links])
+      print_process_monitors(info[:monitors])
+      print_process_memory(info)
+      print_process_stacktrace(info[:current_stacktrace])
+    else
+      _ ->
+        IO.puts(
+          IEx.color(
+            :eval_error,
+            "Failed to get process info. Either the process was not found or is not alive."
+          )
+        )
+    end
+
+    dont_display_result()
   end
 
-  defp print_history_entry({counter, cache, result}, inspect_opts) do
-    IO.write IEx.color(:eval_info, "#{counter}: #{cache}#=> ")
-    IO.puts  IEx.color(:eval_result, "#{inspect result, inspect_opts}\n")
+  defp print_process_overview(info) do
+    print_pane("Overview")
+
+    for key <- [
+          :initial_call,
+          :current_function,
+          :registered_name,
+          :status,
+          :message_queue_len,
+          :group_leader,
+          :priority,
+          :trap_exit,
+          :reductions
+        ] do
+      print_entry(
+        @process_info_label_mapping[key],
+        inspect(info[key], printable_limit: 256, limit: 5)
+      )
+    end
   end
 
-  @doc """
-  Retrieves the nth expression's value from the history.
+  defp print_process_links([]), do: :ok
 
-  Use negative values to lookup expression values relative to the current one.
-  For instance, v(-1) returns the result of the last evaluated expression.
-  """
-  def v(n) do
-    IEx.History.nth(n) |> elem(2)
+  defp print_process_links(ports_and_pids) do
+    print_pane("Links")
+
+    for link <- ports_and_pids do
+      print_entry(inspect(link), pid_or_port_details(link))
+    end
   end
 
-  @doc """
-  Recompiles and reloads the specified module's source file.
+  defp print_process_monitors([]), do: :ok
 
-  Please note that all the modules defined in the same file as `module`
-  are recompiled and reloaded.
-  """
-  def r(module) when is_atom(module) do
-    {:reloaded, module, do_r(module)}
+  defp print_process_monitors(monitors) do
+    print_pane("Monitors")
+
+    for {_, pid_or_port} <- monitors do
+      print_entry(inspect(pid_or_port), pid_or_port_details(pid_or_port))
+    end
   end
 
-  defp do_r(module) do
-    unless Code.ensure_loaded?(module) do
-      raise ArgumentError, "could not load nor find module: #{inspect module}"
+  defp print_process_memory(info) do
+    print_pane("Memory")
+
+    for key <- [:memory, :total_heap_size, :heap_size, :stack_size] do
+      print_entry(@process_info_label_mapping[key], format_bytes(info[key]))
     end
+  end
 
-    source = source(module)
-    cond do
-      source == nil ->
-        raise ArgumentError, "could not find source for module: #{inspect module}"
+  defp print_process_stacktrace([]), do: :ok
 
-      not File.exists?(source) ->
-        raise ArgumentError, "could not find source (#{source}) for module: #{inspect module}"
+  defp print_process_stacktrace(stacktrace) do
+    print_pane("Current stacktrace")
 
-      String.ends_with?(source, ".erl") ->
-        [compile_erlang(source) |> elem(0)]
+    IO.puts(IEx.color(:eval_info, Exception.format_stacktrace(stacktrace)))
+  end
 
-      true ->
-        Enum.map(Code.load_file(source), fn {name, _} -> name end)
+  defp pid_or_port_details(pid) when is_pid(pid), do: to_process_details(pid)
+  defp pid_or_port_details(name) when is_atom(name), do: to_process_details(name)
+  defp pid_or_port_details(port) when is_port(port), do: to_port_details(port)
+  defp pid_or_port_details(reference) when is_reference(reference), do: reference
+
+  defp to_process_details(pid) when is_pid(pid) do
+    case Process.info(pid, [:initial_call, :dictionary, :registered_name]) do
+      [{:initial_call, initial_call}, {:dictionary, dictionary}, {:registered_name, name}] ->
+        initial_call = Keyword.get(dictionary, :"$initial_call", initial_call)
+
+        format_registered_name(name) ||
+          format_process_label(Keyword.get(dictionary, :"$process_label")) ||
+          format_initial_call(initial_call)
+
+      _ ->
+        "-"
     end
   end
 
-  @doc """
-  Load the given module's beam code (and ensures any previous
-  old version was properly purged before).
-  """
-  def l(module) when is_atom(module) do
-    :code.purge(module)
-    :code.load_file(module)
+  defp to_process_details(name) when is_atom(name) do
+    Process.whereis(name)
+    |> to_process_details()
+  end
+
+  defp format_process_label(nil), do: nil
+  defp format_process_label(label) when is_binary(label), do: label
+  defp format_process_label(label), do: inspect(label)
+
+  defp format_registered_name([]), do: nil
+  defp format_registered_name(name), do: inspect(name)
+
+  defp format_initial_call({:supervisor, mod, arity}), do: Exception.format_mfa(mod, :init, arity)
+  defp format_initial_call({m, f, a}), do: Exception.format_mfa(m, f, a)
+  defp format_initial_call(nil), do: nil
+
+  defp to_port_details(port) when is_port(port) do
+    case Port.info(port, :name) do
+      {:name, name} -> name
+      _ -> "-"
+    end
   end
 
   @doc """
-  Flushes all messages sent to the shell and prints them out.
+  Clears out all messages sent to the shell's inbox and prints them out.
   """
   def flush do
-    do_flush(IEx.inspect_opts)
+    do_flush(IEx.inspect_opts())
   end
 
   defp do_flush(inspect_opts) do
@@ -326,7 +1021,8 @@ defmodule IEx.Helpers do
   Prints the current working directory.
   """
   def pwd do
-    IO.puts IEx.color(:eval_info, System.cwd!)
+    IO.puts(IEx.color(:eval_info, File.cwd!()))
+    dont_display_result()
   end
 
   @doc """
@@ -334,62 +1030,113 @@ defmodule IEx.Helpers do
   """
   def cd(directory) when is_binary(directory) do
     case File.cd(expand_home(directory)) do
-      :ok -> pwd
+      :ok ->
+        pwd()
+
       {:error, :enoent} ->
-        IO.puts IEx.color(:eval_error, "No directory #{directory}")
+        IO.puts(IEx.color(:eval_error, "No directory #{directory}"))
+
+      {:error, reason} ->
+        IO.puts(IEx.color(:eval_error, :file.format_error(reason)))
     end
+
+    dont_display_result()
+  end
+
+  @doc """
+  Prints a list of all the functions and macros exported by the given module.
+  """
+  @doc since: "1.5.0"
+  def exports(module \\ Kernel) do
+    exports = IEx.Autocomplete.exports(module)
+
+    list =
+      Enum.map(exports, fn {name, arity} ->
+        Atom.to_string(name) <> "/" <> Integer.to_string(arity)
+      end)
+
+    print_table(list)
+    dont_display_result()
   end
 
   @doc """
-  Produces a simple list of a directory's contents.
+  Prints a list of the given directory's contents.
+
   If `path` points to a file, prints its full path.
   """
   def ls(path \\ ".") when is_binary(path) do
     path = expand_home(path)
+
     case File.ls(path) do
       {:ok, items} ->
         sorted_items = Enum.sort(items)
-        ls_print(path, sorted_items)
+
+        printer = fn item, width ->
+          format_item(Path.join(path, item), String.pad_trailing(item, width))
+        end
+
+        print_table(sorted_items, printer)
 
       {:error, :enoent} ->
-        IO.puts IEx.color(:eval_error, "No such file or directory #{path}")
+        IO.puts(IEx.color(:eval_error, "No such file or directory #{path}"))
+
+      {:error, reason} ->
+        cond do
+          File.exists?(path) and not File.dir?(path) ->
+            IO.puts(IEx.color(:eval_info, Path.absname(path)))
 
-      {:error, :enotdir} ->
-        IO.puts IEx.color(:eval_info, Path.absname(path))
+          reason == :enotdir ->
+            IO.puts(IEx.color(:eval_error, "No such file or directory #{path}"))
+
+          true ->
+            IO.puts(IEx.color(:eval_error, :file.format_error(reason)))
+        end
     end
+
+    dont_display_result()
   end
 
-  defp expand_home(<<?~, rest :: binary>>) do
-    System.user_home! <> rest
+  defp expand_home(<<?~, rest::binary>>) do
+    System.user_home!() <> rest
   end
 
   defp expand_home(other), do: other
 
-  defp ls_print(_, []) do
+  defp print_table(list, printer \\ &String.pad_trailing/2)
+
+  defp print_table([], _printer) do
     :ok
   end
 
-  defp ls_print(path, list) do
+  defp print_table(list, printer) do
     # print items in multiple columns (2 columns in the worst case)
     lengths = Enum.map(list, &String.length(&1))
-    maxlen = maxlength(lengths)
-    width = min(maxlen, 30) + 5
-    ls_print(path, list, width)
+    max_length = max_length(lengths)
+    offset = min(max_length, 30) + 4
+    print_table(list, printer, offset)
   end
 
-  defp ls_print(path, list, width) do
-    Enum.reduce(list, 0, fn(item, len) ->
-      if len >= 80 do
-        IO.puts ""
-        len = 0
-      end
-      IO.write format_item(Path.join(path, item), String.ljust(item, width))
-      len+width
+  defp print_table(list, printer, offset) do
+    Enum.reduce(list, 0, fn item, length ->
+      length =
+        if length >= 80 do
+          IO.puts("")
+          0
+        else
+          length
+        end
+
+      printed = printer.(item, offset)
+      actual_offset = String.length(printed) + 1
+
+      IO.write(printed <> " ")
+      length + actual_offset
     end)
-    IO.puts ""
+
+    IO.puts("")
   end
 
-  defp maxlength(list) do
+  defp max_length(list) do
     Enum.reduce(list, 0, &max(&1, &2))
   end
 
@@ -397,29 +1144,334 @@ defmodule IEx.Helpers do
     case File.stat(path) do
       {:ok, %File.Stat{type: :device}} ->
         IEx.color(:ls_device, representation)
+
       {:ok, %File.Stat{type: :directory}} ->
         IEx.color(:ls_directory, representation)
+
       _ ->
         representation
     end
   end
 
   @doc """
-  Respawns the current shell by starting a new
-  process and a new scope. Returns true if it worked.
+  Respawns the current shell by starting a new shell process.
   """
   def respawn do
-    if whereis = IEx.Server.whereis do
-      send whereis, {:respawn, self}
-      dont_display_result
+    if iex_server = Process.get(:iex_server) do
+      send(iex_server, {:respawn, self()})
     end
+
+    dont_display_result()
   end
 
   @doc """
-  Evaluates the contents of the file at `path` as if it were directly typed into
-  the shell. `path` has to be a literal binary.
+  Continues execution of the current process.
+
+  This is usually called by sessions started with `IEx.pry/0`
+  or `IEx.break!/4`. This allows the current process to execute
+  until the next breakpoint, which will automatically yield control
+  back to IEx without requesting permission to pry.
 
-  A leading `~` in `path` is automatically expanded.
+  If you simply want to move to the next line of the current breakpoint,
+  use `n/0` or `next/0` instead.
+
+  If the running process terminates, a new IEx session is
+  started.
+
+  While the process executes, the user will no longer have
+  control of the shell. If you would rather start a new shell,
+  use `respawn/0` instead.
+  """
+  @doc since: "1.5.0"
+  def continue do
+    if iex_server = Process.get(:iex_server) do
+      send(iex_server, {:continue, self(), false})
+    end
+
+    dont_display_result()
+  end
+
+  @doc """
+  Goes to the next line of the current breakpoint.
+
+  This is usually called by sessions started with `IEx.break!/4`.
+  If instead of the next line you want to move to the next breakpoint,
+  call `continue/0` instead.
+
+  While the process executes, the user will no longer have
+  control of the shell. If you would rather start a new shell,
+  use `respawn/0` instead.
+  """
+  @doc since: "1.14.0"
+  def next do
+    if iex_server = Process.get(:iex_server) do
+      send(iex_server, {:continue, self(), true})
+    end
+
+    dont_display_result()
+  end
+
+  @doc """
+  A shortcut for `next/0`.
+  """
+  @doc since: "1.14.0"
+  def n do
+    next()
+  end
+
+  @doc """
+  A shortcut for `continue/0`.
+  """
+  @doc since: "1.17.0"
+  def c do
+    continue()
+  end
+
+  @doc """
+  Sets up a breakpoint in the AST of shape `Module.function/arity`
+  with the given number of `stops`.
+
+  See `IEx.break!/4` for a complete description of breakpoints
+  in IEx.
+
+  ## Examples
+
+      break! URI.decode_query/2
+
+  """
+  @doc since: "1.5.0"
+  defmacro break!(ast, stops \\ 1) do
+    quote do
+      require IEx
+      IEx.break!(unquote(ast), unquote(stops))
+    end
+  end
+
+  @doc """
+  Sets up a breakpoint in `module`, `function` and `arity`
+  with the given number of `stops`.
+
+  See `IEx.break!/4` for a complete description of breakpoints
+  in IEx.
+
+  ## Examples
+
+      break! URI, :decode_query, 2
+
+  """
+  @doc since: "1.5.0"
+  defdelegate break!(module, function, arity, stops \\ 1), to: IEx
+
+  @doc """
+  Prints all breakpoints to the terminal.
+  """
+  @doc since: "1.5.0"
+  def breaks do
+    breaks(IEx.Pry.breaks())
+  end
+
+  defp breaks([]) do
+    IO.puts(IEx.color(:eval_info, "No breakpoints set"))
+    dont_display_result()
+  end
+
+  defp breaks(breaks) do
+    entries =
+      for {id, module, {function, arity}, stops} <- breaks do
+        {
+          Integer.to_string(id),
+          Exception.format_mfa(module, function, arity),
+          Integer.to_string(stops)
+        }
+      end
+
+    entries = [{"ID", "Module.function/arity", "Pending stops"} | entries]
+
+    {id_max, mfa_max, stops_max} =
+      Enum.reduce(entries, {0, 0, 0}, fn {id, mfa, stops}, {id_max, mfa_max, stops_max} ->
+        {
+          max(byte_size(id), id_max),
+          max(byte_size(mfa), mfa_max),
+          max(byte_size(stops), stops_max)
+        }
+      end)
+
+    [header | entries] = entries
+
+    IO.puts("")
+    print_break(header, id_max, mfa_max)
+
+    IO.puts([
+      String.duplicate("-", id_max + 2),
+      ?\s,
+      String.duplicate("-", mfa_max + 2),
+      ?\s,
+      String.duplicate("-", stops_max + 2)
+    ])
+
+    Enum.each(entries, &print_break(&1, id_max, mfa_max))
+    IO.puts("")
+
+    dont_display_result()
+  end
+
+  defp print_break({id, mfa, stops}, id_max, mfa_max) do
+    IO.puts([
+      ?\s,
+      String.pad_trailing(id, id_max + 2),
+      ?\s,
+      String.pad_trailing(mfa, mfa_max + 2),
+      ?\s,
+      stops
+    ])
+  end
+
+  @doc """
+  Resets the number of pending stops in the breakpoint
+  with the given `id` to zero.
+
+  Returns `:ok` if there is such breakpoint ID. `:not_found`
+  otherwise.
+
+  Note the module remains "instrumented" on reset. If you would
+  like to effectively remove all breakpoints and instrumentation
+  code from a module, use `remove_breaks/1` instead.
+  """
+  @doc since: "1.5.0"
+  defdelegate reset_break(id), to: IEx.Pry
+
+  @doc """
+  Resets the number of pending stops in the given module,
+  function and arity to zero.
+
+  If the module is not instrumented or if the given function
+  does not have a breakpoint, it is a no-op and it returns
+  `:not_found`. Otherwise it returns `:ok`.
+
+  Note the module remains "instrumented" on reset. If you would
+  like to effectively remove all breakpoints and instrumentation
+  code from a module, use `remove_breaks/1` instead.
+  """
+  @doc since: "1.5.0"
+  defdelegate reset_break(module, function, arity), to: IEx.Pry
+
+  @doc """
+  Removes all breakpoints and instrumentation from `module`.
+  """
+  @doc since: "1.5.0"
+  defdelegate remove_breaks(module), to: IEx.Pry
+
+  @doc """
+  Removes all breakpoints and instrumentation from all modules.
+  """
+  @doc since: "1.5.0"
+  defdelegate remove_breaks(), to: IEx.Pry
+
+  @doc """
+  Prints the current location and stacktrace in a pry session.
+
+  It expects a `radius` which chooses how many lines before and after
+  the current line we should print. By default the `radius` is of two
+  lines:
+
+      Location: lib/iex/lib/iex/helpers.ex:79
+
+      77:
+      78:   def recompile do
+      79:     require IEx; IEx.pry()
+      80:     if mix_started?() do
+      81:       config = Mix.Project.config
+
+      (IEx.Helpers) lib/iex/lib/iex/helpers.ex:78: IEx.Helpers.recompile/0
+
+  This command only works inside a pry session started manually
+  via `IEx.pry/0` or a breakpoint set via `IEx.break!/4`. Calling
+  this function during a regular `IEx` session will print an error.
+
+  Keep in mind the `whereami/1` location may not exist when prying
+  precompiled source code, such as Elixir itself.
+  """
+  @doc since: "1.5.0"
+  def whereami(radius \\ 2) do
+    case Process.get(:iex_whereami) do
+      {file, line, stacktrace} ->
+        msg = ["Location: ", Path.relative_to_cwd(file), ":", Integer.to_string(line)]
+        IO.puts(IEx.color(:eval_info, msg))
+
+        case IEx.Pry.whereami(file, line, radius) do
+          {:ok, lines} ->
+            IO.write([?\n, lines, ?\n])
+
+          :error ->
+            msg = "Could not extract source snippet. Location is not available."
+            IO.puts(IEx.color(:eval_error, msg))
+        end
+
+        case stacktrace do
+          nil -> :ok
+          stacktrace -> IO.write([Exception.format_stacktrace(stacktrace), ?\n])
+        end
+
+      _ ->
+        IO.puts(IEx.color(:eval_error, "Pry session is not currently enabled"))
+    end
+
+    dont_display_result()
+  end
+
+  @doc """
+  Similar to `import_file` but only imports the file if it is available.
+
+  By default, `import_file/1` fails when the given file does not exist.
+  However, since `import_file/1` is expanded at compile-time, it's not
+  possible to conditionally import a file since the macro is always
+  expanded:
+
+      # This raises a File.Error if ~/.iex.exs doesn't exist.
+      if "~/.iex.exs" |> Path.expand() |> File.exists?() do
+        import_file("~/.iex.exs")
+      end
+
+  This macro addresses this issue by checking if the file exists or not
+  in behalf of the user.
+  """
+  defmacro import_file_if_available(path) when is_binary(path) do
+    import_file_if_available(path, true)
+  end
+
+  defmacro import_file_if_available(_) do
+    raise ArgumentError, "import_file_if_available/1 expects a literal binary as its argument"
+  end
+
+  defp import_file_if_available(path, optional?) when is_binary(path) do
+    path = Path.expand(path)
+
+    if not optional? or File.exists?(path) do
+      if imported_paths = Process.get(:iex_imported_paths) do
+        if path in imported_paths do
+          IO.warn("path #{path} was already imported, skipping circular file imports", [])
+        else
+          Process.put(:iex_imported_paths, MapSet.put(imported_paths, path))
+          path |> File.read!() |> Code.string_to_quoted!(file: path)
+        end
+      else
+        path |> File.read!() |> Code.string_to_quoted!(file: path)
+      end
+    end
+  end
+
+  @doc """
+  Injects the contents of the file at `path`.
+
+  This would be the equivalent of getting all of the file contents and
+  pasting it all at once in IEx and executing it.
+
+  By default, the contents of a `.iex.exs` file in the same directory
+  as you are starting IEx are automatically imported. See the section
+  for ".iex.exs" in the `IEx` module docs for more information.
+
+  `path` has to be a literal string and is automatically expanded via
+  `Path.expand/1`.
 
   ## Examples
 
@@ -427,30 +1479,271 @@ defmodule IEx.Helpers do
       value = 13
 
       # in the shell
-      iex(1)> import_file "~/file.exs"
+      iex(1)> import_file("~/file.exs")
       13
       iex(2)> value
       13
+
   """
+  @doc since: "1.4.0"
   defmacro import_file(path) when is_binary(path) do
-    path = Path.expand(path)
-    Code.string_to_quoted! File.read!(path), file: path
+    import_file_if_available(path, false)
   end
 
   defmacro import_file(_) do
     raise ArgumentError, "import_file/1 expects a literal binary as its argument"
   end
 
-  # Compiles and loads an erlang source file, returns {module, binary}
+  @doc false
+  @deprecated "Use import_file_if_available/1 instead"
+  defmacro import_file(path, opts) when is_binary(path) and is_list(opts) do
+    import_file_if_available(path, Keyword.get(opts, :optional, false))
+  end
+
+  @doc """
+  Calls `import/2` with the given arguments, but only if the module is available.
+
+  This lets you put imports in `.iex.exs` files (including `~/.iex.exs`) without
+  getting compile errors if you open a console where the module is not available.
+
+  ## Example
+
+      # In ~/.iex.exs
+      import_if_available(Ecto.Query)
+
+  """
+  defmacro import_if_available(quoted_module, opts \\ []) do
+    module = Macro.expand(quoted_module, __CALLER__)
+
+    if Code.ensure_loaded?(module) do
+      quote do
+        import unquote(quoted_module), unquote(opts)
+      end
+    end
+  end
+
+  @doc """
+  Calls `use/2` with the given arguments, but only if the module is available.
+
+  This lets you use the module in `.iex.exs` files (including `~/.iex.exs`) without
+  getting compile errors if you open a console where the module is not available.
+
+  ## Example
+
+      # In ~/.iex.exs
+      use_if_available(Phoenix.HTML)
+
+  """
+  @doc since: "1.7.0"
+  defmacro use_if_available(quoted_module, opts \\ []) do
+    module = Macro.expand(quoted_module, __CALLER__)
+
+    if Code.ensure_loaded?(module) do
+      quote do
+        use unquote(quoted_module), unquote(opts)
+      end
+    end
+  end
+
+  defp compile_elixir(exs, :in_memory),
+    do: Kernel.ParallelCompiler.compile(exs, return_diagnostics: true)
+
+  defp compile_elixir(exs, path),
+    do: Kernel.ParallelCompiler.compile_to_path(exs, path, return_diagnostics: true)
+
+  # Compiles and loads an Erlang source file, returns {module, binary}
   defp compile_erlang(source) do
-    source = Path.relative_to_cwd(source) |> String.to_char_list
+    source = Path.relative_to_cwd(source) |> String.to_charlist()
+
     case :compile.file(source, [:binary, :report]) do
       {:ok, module, binary} ->
         :code.purge(module)
         {:module, module} = :code.load_binary(module, source, binary)
         {module, binary}
+
       _ ->
         raise CompileError
     end
   end
+
+  defp history, do: Process.get(:iex_history)
+
+  @doc """
+  Creates a PID from `string` or `atom`.
+
+  ## Examples
+
+      iex> pid("0.21.32")
+      #PID<0.21.32>
+
+      iex> pid("#PID<0.21.32>")
+      #PID<0.21.32>
+
+      iex> pid(:init)
+      #PID<0.0.0>
+
+  """
+  @spec pid(binary | atom) :: pid()
+  def pid("#PID<" <> string) do
+    :erlang.list_to_pid(~c"<#{string}")
+  end
+
+  def pid(string) when is_binary(string) do
+    :erlang.list_to_pid(~c"<#{string}>")
+  end
+
+  def pid(name) when is_atom(name) do
+    case Process.whereis(name) do
+      p when is_pid(p) -> p
+      _ -> raise ArgumentError, "could not find registered process with name: #{inspect(name)}"
+    end
+  end
+
+  @doc """
+  Creates a PID with 3 non-negative integers passed as arguments
+  to the function.
+
+  ## Examples
+
+      iex> pid(0, 21, 32)
+      #PID<0.21.32>
+      iex> pid(0, 64, 2048)
+      #PID<0.64.2048>
+
+  """
+  @spec pid(non_neg_integer, non_neg_integer, non_neg_integer) :: pid()
+  def pid(x, y, z)
+      when is_integer(x) and x >= 0 and is_integer(y) and y >= 0 and is_integer(z) and z >= 0 do
+    :erlang.list_to_pid(
+      ~c"<" ++
+        Integer.to_charlist(x) ++
+        ~c"." ++ Integer.to_charlist(y) ++ ~c"." ++ Integer.to_charlist(z) ++ ~c">"
+    )
+  end
+
+  @doc """
+  Creates a Port from `string`.
+
+  ## Examples
+
+      iex> port("0.4")
+      #Port<0.4>
+
+  """
+  @doc since: "1.8.0"
+  @spec port(binary) :: port()
+  def port(string) when is_binary(string) do
+    :erlang.list_to_port(~c"#Port<#{string}>")
+  end
+
+  @doc """
+  Creates a Port from two non-negative integers.
+
+  ## Examples
+
+      iex> port(0, 8080)
+      #Port<0.8080>
+      iex> port(0, 443)
+      #Port<0.443>
+
+  """
+  @doc since: "1.8.0"
+  @spec port(non_neg_integer, non_neg_integer) :: port()
+  def port(major, minor)
+      when is_integer(major) and major >= 0 and is_integer(minor) and minor >= 0 do
+    :erlang.list_to_port(
+      ~c"#Port<" ++ Integer.to_charlist(major) ++ ~c"." ++ Integer.to_charlist(minor) ++ ~c">"
+    )
+  end
+
+  @doc """
+  Creates a Reference from `string`.
+
+  ## Examples
+
+      iex> ref("0.1.2.3")
+      #Reference<0.1.2.3>
+
+  """
+  @doc since: "1.6.0"
+  @spec ref(binary) :: reference()
+  def ref(string) when is_binary(string) do
+    :erlang.list_to_ref(~c"#Ref<#{string}>")
+  end
+
+  @doc """
+  Creates a Reference from its 4 non-negative integers components.
+
+  ## Examples
+
+      iex> ref(0, 1, 2, 3)
+      #Reference<0.1.2.3>
+
+  """
+  @doc since: "1.6.0"
+  @spec ref(non_neg_integer, non_neg_integer, non_neg_integer, non_neg_integer) :: reference()
+  def ref(w, x, y, z)
+      when is_integer(w) and w >= 0 and is_integer(x) and x >= 0 and is_integer(y) and y >= 0 and
+             is_integer(z) and z >= 0 do
+    :erlang.list_to_ref(
+      ~c"#Ref<" ++
+        Integer.to_charlist(w) ++
+        ~c"." ++
+        Integer.to_charlist(x) ++
+        ~c"." ++ Integer.to_charlist(y) ++ ~c"." ++ Integer.to_charlist(z) ++ ~c">"
+    )
+  end
+
+  @doc """
+  Deploys a given module's BEAM code to a list of nodes.
+
+  This function is useful for development and debugging when you have code that
+  has been compiled or updated locally that you want to run on other nodes.
+
+  The node list defaults to a list of all connected nodes.
+
+  Returns `{:error, :nofile}` if the object code (i.e. ".beam" file) for the module
+  could not be found locally.
+
+  ## Examples
+
+      iex> nl(HelloWorld)
+      {:ok,
+       [
+         {:node1@easthost, :loaded, HelloWorld},
+         {:node1@westhost, :loaded, HelloWorld}
+       ]}
+
+      iex> nl(NoSuchModuleExists)
+      {:error, :nofile}
+
+  """
+  def nl(nodes \\ Node.list(), module) when is_list(nodes) and is_atom(module) do
+    case get_beam_and_path(module) do
+      {bin, beam_path} ->
+        call = :erpc.multicall(nodes, :code, :load_binary, [module, beam_path, bin])
+
+        results =
+          Enum.zip_with(nodes, call, fn
+            node, {:ok, {:module, _}} -> {node, :loaded, module}
+            node, {:ok, {:error, reason}} -> {node, :error, reason}
+            node, {:error, {:erpc, reason}} -> {node, :badrpc, reason}
+          end)
+
+        {:ok, results}
+
+      _otherwise ->
+        {:error, :nofile}
+    end
+  end
+
+  defp get_beam_and_path(module) do
+    with {^module, beam, filename} <- :code.get_object_code(module),
+         info_pairs when is_list(info_pairs) <- :beam_lib.info(beam),
+         {:ok, ^module} <- Keyword.fetch(info_pairs, :module) do
+      {beam, filename}
+    else
+      _ -> :error
+    end
+  end
 end
diff --git a/lib/iex/lib/iex/history.ex b/lib/iex/lib/iex/history.ex
index 2e800b4d311..a517cb81f2c 100644
--- a/lib/iex/lib/iex/history.ex
+++ b/lib/iex/lib/iex/history.ex
@@ -1,109 +1,85 @@
- defmodule IEx.History do
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule IEx.History do
   @moduledoc false
 
+  alias IEx.History
+
+  defstruct queue: :queue.new(), size: 0, start: 1
+
   @doc """
-  Initializes IEx process variables. All history
-  information is kept in the process dictionary.
+  Initializes IEx history state.
   """
-  def init do
-    Process.put(:iex_history_start_counter, 1)
-    Process.put(:iex_history_counter, 1)
-  end
+  def init(start), do: %History{start: start}
 
   @doc """
-  Appends one entry to the history with the given counter.
+  Appends one entry to the history.
   """
-  def append(entry, counter, limit) do
-    Process.put({:iex_history, counter}, entry)
-    Process.put(:iex_history_counter, counter+1)
-
-    start_counter = Process.get(:iex_history_start_counter)
-    should_collect = limit_history(start_counter, counter, limit, false)
-    if should_collect do
-      collect_garbage()
-    end
-  end
-
-  defp limit_history(_, _, limit, _) when limit < 0 do
-    false
-  end
-
-  defp limit_history(counter, max_counter, limit, should_collect) when max_counter - counter < limit do
-    Process.put(:iex_history_start_counter, counter)
-    should_collect
-  end
+  def append(%History{} = state, entry, limit) do
+    {collect?, state} =
+      state
+      |> append(entry)
+      |> prune(limit)
 
-  defp limit_history(counter, max_counter, limit, should_collect) do
-    if not should_collect do
-      entry = Process.delete({:iex_history, counter})
-      should_collect = has_binary(entry)
-    else
-      Process.delete({:iex_history, counter})
-    end
-    limit_history(counter+1, max_counter, limit, should_collect)
+    if collect?, do: collect_garbage()
+    state
   end
 
   @doc """
-  Removes all entries from the history and forces a garbage collection cycle.
+  Enumerates over all items in the history starting from the oldest one and
+  applies `fun` to each one in turn.
   """
-  def reset() do
-    each_pair(fn(key, _) ->
-      Process.delete(key)
-    end)
-
-    counter = Process.get(:iex_history_counter)
-    Process.put(:iex_history_start_counter, counter)
-
-    collect_garbage()
+  def each(%History{} = state, fun) do
+    state
+    |> to_list()
+    |> Enum.each(fun)
   end
 
-  # Checks val and each of its elements (if it is a list or a tuple)
-  # recursively to see if it has any binaries
-  defp has_binary(val) do
-    try do
-      has_bin(val)
-    catch
-      :throw, true -> true
-    end
-  end
+  @doc """
+  Gets the nth item from the history.
 
-  # Worker function used by has_binary. Throws when the first binary of the
-  # minimum specified size is found
-  defp has_bin(val) when is_tuple(val) do
-    has_bin(val, tuple_size(val)-1)
+  If `n` < 0, the count starts from the most recent item and goes back in time.
+  """
+  # Traverses the queue front-to-back if the index is positive.
+  def nth(%History{queue: q, size: size, start: start}, n)
+      when n - start >= 0 and n - start < size do
+    get_nth(q, n - start)
   end
 
-  defp has_bin([h|t]) do
-    has_bin(h)
-    has_bin(t)
+  # Traverses the queue back-to-front if the index is negative.
+  def nth(%History{queue: q, size: size}, n)
+      when n < 0 and size + n >= 0 do
+    get_nth(:queue.reverse(q), abs(n) - 1)
   end
 
-  defp has_bin(val) when byte_size(val) > 64 do
-    throw true
+  def nth(%History{size: 0}, n) do
+    raise "v(#{n}) is out of bounds, no entries were stored in history so far"
   end
 
-  defp has_bin(_) do
-    false
+  def nth(%History{size: size, start: start}, n) do
+    raise "v(#{n}) is out of bounds, the currently preserved history ranges from #{start} to #{start + size - 1} " <>
+            "(or use negative numbers to look from the end)"
   end
 
-  defp has_bin(_, -1) do
-    false
-  end
+  defp get_nth(q, 0), do: :queue.head(q)
+  defp get_nth(q, n) when n > 0, do: get_nth(:queue.tail(q), n - 1)
 
-  defp has_bin(tuple, index) do
-    has_bin(elem(tuple, index))
-    has_bin(tuple, index-1)
+  defp append(%{queue: q, size: size} = state, item) do
+    %{state | queue: :queue.in(item, q), size: size + 1}
   end
 
+  defp to_list(%{queue: q}), do: :queue.to_list(q)
+
   # Based on https://github.com/erlang/otp/blob/7dcccee4371477e983f026db9e243cb66900b1ef/lib/stdlib/src/shell.erl#L1401
-  defp collect_garbage do
-    :erlang.garbage_collect(self())
-    collect_garbage Process.whereis(:user)
-    collect_garbage Process.group_leader()
+  defp collect_garbage() do
+    collect_proc_garbage(Process.whereis(:user))
+    collect_proc_garbage(Process.group_leader())
     :erlang.garbage_collect()
   end
 
-  defp collect_garbage(process) do
+  defp collect_proc_garbage(process) do
     try do
       :erlang.garbage_collect(process)
     catch
@@ -111,48 +87,49 @@
     end
   end
 
-  @doc """
-  Enumerates over all items in the history starting from the oldest one and
-  applies `fun` to each one in turn.
-  """
-  def each(fun) do
-    each_pair(fn _, item -> fun.(item) end)
+  defp prune(%{start: start} = state, limit) do
+    prune(state, start, limit, false)
   end
 
-  # Private helper that invokes fun with both key and item.
-  defp each_pair(fun) do
-    each_pair(Process.get(:iex_history_start_counter),
-              Process.get(:iex_history_counter),
-              fun)
+  defp prune(state, _, limit, _) when limit < 0 do
+    {false, state}
   end
 
-  defp each_pair(counter, max_counter, fun) when counter < max_counter do
-    key = {:iex_history, counter}
-    entry = Process.get(key)
-    fun.(key, entry)
-    each_pair(counter+1, max_counter, fun)
+  defp prune(%{size: size} = state, counter, limit, collect?) when size <= limit do
+    {collect?, %{state | start: counter}}
   end
 
-  defp each_pair(_, _, _) do
-    :ok
+  defp prune(%{queue: q, size: size} = state, counter, limit, collect?) do
+    {{:value, entry}, q} = :queue.out(q)
+    collect? = collect? || has_binary(entry)
+    prune(%{state | queue: q, size: size - 1}, counter + 1, limit, collect?)
   end
 
-  @doc """
-  Gets the nth item from the history.
-
-  If `n` < 0, the count starts from the most recent item and goes back in time.
-  """
-  def nth(n) do
-    entry = case n do
-      x when x >= 0 ->
-        Process.get({:iex_history, n})
-      x when x < 0 ->
-        counter = Process.get(:iex_history_counter)
-        Process.get({:iex_history, counter + n})
-    end
-    if nil?(entry) do
-      raise "v(#{n}) is out of bounds"
+  # Checks val and each of its elements (if it is a list or a tuple)
+  # recursively to see if it has any large binaries (outside of the heap).
+  defp has_binary(val) do
+    try do
+      has_bin(val)
+    catch
+      :throw, :found -> true
     end
-    entry
+  end
+
+  defp has_bin(val) when is_tuple(val), do: has_bin(val, tuple_size(val) - 1)
+
+  defp has_bin([head | tail]) do
+    has_bin(head)
+    has_bin(tail)
+  end
+
+  defp has_bin(val) when byte_size(val) > 64, do: throw(:found)
+
+  defp has_bin(_), do: false
+
+  defp has_bin(_, -1), do: false
+
+  defp has_bin(tuple, index) do
+    has_bin(elem(tuple, index))
+    has_bin(tuple, index - 1)
   end
 end
diff --git a/lib/iex/lib/iex/info.ex b/lib/iex/lib/iex/info.ex
new file mode 100644
index 00000000000..332d7ade11a
--- /dev/null
+++ b/lib/iex/lib/iex/info.ex
@@ -0,0 +1,492 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defprotocol IEx.Info do
+  @fallback_to_any true
+
+  @moduledoc """
+  A protocol to print information in IEx about the given data structure.
+
+  `IEx.Helpers.i/1` uses this protocol to display a term-specific list
+  of information.
+
+  By default, an `Any` implementation will be used which returns
+  the `"Data type"`, `"Description"` and `"Reference modules"` sections.
+  """
+
+  @doc """
+  Returns information for the given term.
+
+  Information should be returned as a list of `info_name`-`info` tuples,
+  where `info_name` is a string-like value, such as an atom or a string
+  itself, and `info` is a string. `info_name` should be short. `info` can
+  be arbitrarily long and contain newlines.
+
+  `IEx.Helpers.i/1` will generate (and always display)
+  the 'Implemented protocols' and 'Term' sections in the result.
+
+  All other sections of information are added (and can be overridden)
+  by customized implementations of this function.
+
+  It is recommended to at least include the following sections for a
+  custom implementation:
+
+    * `"Data type"`: Name of the data type. Usually the name of the module
+       defining the data type.
+    * `"Description"`: One or a few sentences describing what the data type represents.
+    * `"Reference modules"`: One or a few comma-separated module names that focus
+      on working with this datatype.
+
+  Other recommended sections are:
+
+    * `"Raw representation"`: showing another way of writing the passed `term`.
+      This is mostly relevant for data-structures whose `String.Chars`-implementations
+      make use of sigils or other syntactic sugar.
+  """
+  @spec info(term()) :: [{info_name :: String.Chars.t(), info :: String.t()}]
+  def info(term)
+end
+
+defimpl IEx.Info, for: Tuple do
+  def info(_tuple) do
+    [
+      {"Data type", "Tuple"},
+      {"Reference modules", "Tuple"}
+    ]
+  end
+end
+
+defimpl IEx.Info, for: Atom do
+  def info(atom) do
+    specific_info =
+      cond do
+        module?(atom) ->
+          info_module(atom)
+
+        match?("Elixir." <> _, Atom.to_string(atom)) ->
+          info_module_like_atom(atom)
+
+        true ->
+          info_atom(atom)
+      end
+
+    description =
+      if atom == IEx.dont_display_result() do
+        description = """
+        This atom is returned by IEx when a function that should not print its
+        return value on screen is executed.
+        """
+
+        [{"Description", description}]
+      else
+        []
+      end
+
+    [{"Data type", "Atom"}] ++ description ++ specific_info
+  end
+
+  defp module?(atom) do
+    case :code.get_object_code(atom) do
+      :error ->
+        Code.ensure_loaded?(atom)
+
+      {^atom, beam, _path} ->
+        info = :beam_lib.info(beam)
+        is_list(info) and Keyword.fetch(info, :module) == {:ok, atom}
+    end
+  end
+
+  defp info_module(mod) do
+    extra =
+      case Code.fetch_docs(mod) do
+        {:docs_v1, _, _, _, %{}, _, _} -> "Use h(#{inspect(mod)}) to access its documentation.\n"
+        _ -> ""
+      end
+
+    mod_info = mod.module_info()
+
+    generic_info = [
+      {"Module bytecode", module_object_file(mod)},
+      {"Source", module_source_file(mod_info)},
+      {"Version", module_version(mod_info)},
+      {"Compile options", module_compile_options(mod_info)},
+      {"Description", "#{extra}Call #{inspect(mod)}.module_info() to access metadata."}
+    ]
+
+    final_info = [
+      {"Raw representation", ":" <> inspect(Atom.to_string(mod))},
+      {"Reference modules", "Module, Atom"}
+    ]
+
+    generic_info ++ protocol_info(mod) ++ final_info
+  end
+
+  defp protocol_info(mod) do
+    if function_exported?(mod, :__protocol__, 1) do
+      impls =
+        mod
+        |> Protocol.extract_impls(:code.get_path())
+        |> Enum.map_join(", ", &inspect/1)
+
+      [{"Protocol", "This module is a protocol. These data structures implement it:\n  #{impls}"}]
+    else
+      []
+    end
+  end
+
+  defp info_module_like_atom(atom) do
+    [
+      {"Raw representation", ":" <> inspect(Atom.to_string(atom))},
+      {"Reference modules", "Atom"}
+    ]
+  end
+
+  defp info_atom(_atom) do
+    [{"Reference modules", "Atom"}]
+  end
+
+  defp module_object_file(mod) do
+    default_or_apply(:code.which(mod), fn
+      [_ | _] = path -> Path.relative_to_cwd(path)
+      atom -> inspect(atom)
+    end)
+  end
+
+  defp module_version(mod_info) do
+    default_or_apply(mod_info[:attributes][:vsn], &inspect/1)
+  end
+
+  defp module_source_file(mod_info) do
+    default_or_apply(mod_info[:compile][:source], &Path.relative_to_cwd/1)
+  end
+
+  defp module_compile_options(mod_info) do
+    default_or_apply(mod_info[:compile][:options], &inspect/1)
+  end
+
+  defp default_or_apply(nil, _), do: "no value found"
+  defp default_or_apply(data, fun), do: fun.(data)
+end
+
+defimpl IEx.Info, for: List do
+  def info(list) do
+    specific_info =
+      cond do
+        list == [] -> info_list(list)
+        List.ascii_printable?(list) -> info_printable_charlist(list)
+        Keyword.keyword?(list) -> info_kw_list(list)
+        List.improper?(list) -> info_improper_list(list)
+        true -> info_list(list)
+      end
+
+    [{"Data type", "List"}] ++ specific_info
+  end
+
+  defp info_printable_charlist(charlist) do
+    description = """
+    This is a list of integers that is printed using the `~c` sigil syntax,
+    defined by the `Kernel.sigil_c/2` macro, because all the integers in it
+    represent printable ASCII characters. Conventionally, a list of Unicode
+    code points is known as a charlist and a list of ASCII characters is a
+    subset of it.
+    """
+
+    [
+      {"Description", description},
+      {"Raw representation", inspect(charlist, charlists: :as_lists)},
+      {"Reference modules", "List"}
+    ]
+  end
+
+  defp info_kw_list(_kw_list) do
+    description = """
+    This is what is referred to as a "keyword list". A keyword list is a list
+    of two-element tuples where the first element of each tuple is an atom.
+    """
+
+    [{"Description", description}, {"Reference modules", "Keyword, List"}]
+  end
+
+  defp info_improper_list(_improper_list) do
+    description = """
+    This is what is referred to as an "improper list". An improper list is a
+    list whose last tail is not an empty list. For example: [1, 2, 3] is a
+    proper list, as it is equivalent to [1, 2, 3 | []], as opposed to
+    [1, 2 | 3] which is an improper list since its last tail is 3.
+    """
+
+    [
+      {"Description", description},
+      {"Reference modules", "List"}
+    ]
+  end
+
+  defp info_list(_list) do
+    [{"Reference modules", "List"}]
+  end
+end
+
+defimpl IEx.Info, for: BitString do
+  def info(bitstring) do
+    specific_info =
+      cond do
+        is_binary(bitstring) and String.printable?(bitstring) -> info_string(bitstring)
+        is_binary(bitstring) and String.valid?(bitstring) -> info_non_printable_string(bitstring)
+        is_binary(bitstring) -> info_binary(bitstring)
+        is_bitstring(bitstring) -> info_bitstring(bitstring)
+      end
+
+    [{"Data type", "BitString"}] ++ specific_info
+  end
+
+  defp info_string(bitstring) do
+    description = """
+    This is a string: a UTF-8 encoded binary. It's printed surrounded by
+    "double quotes" because all UTF-8 encoded code points in it are printable.
+    """
+
+    [
+      {"Byte size", byte_size(bitstring)},
+      {"Description", description},
+      {"Raw representation", inspect(bitstring, binaries: :as_binaries)},
+      {"Reference modules", "String, :binary"}
+    ]
+  end
+
+  defp info_non_printable_string(bitstring) do
+    first_non_printable = find_first_codepoint(bitstring, &(not String.printable?(&1)))
+
+    desc = """
+    This is a string: a UTF-8 encoded binary. It's printed with the `<<>>`
+    syntax (as opposed to double quotes) because it contains non-printable
+    UTF-8 encoded code points (the first non-printable code point being
+    `#{inspect(first_non_printable)}`).
+    """
+
+    [
+      {"Byte size", byte_size(bitstring)},
+      {"Description", desc},
+      {"Reference modules", "String, :binary"}
+    ]
+  end
+
+  defp info_binary(bitstring) do
+    first_non_valid = find_first_codepoint(bitstring, &(not String.valid?(&1)))
+
+    description = """
+    This is a binary: a collection of bytes. It's printed with the `<<>>`
+    syntax (as opposed to double quotes) because it is not a UTF-8 encoded
+    binary (the first invalid byte being `#{inspect(first_non_valid)}`)
+    """
+
+    [
+      {"Byte size", byte_size(bitstring)},
+      {"Description", description},
+      {"Reference modules", ":binary"}
+    ]
+  end
+
+  defp info_bitstring(bitstring) do
+    description = """
+    This is a bitstring. It's a chunk of bits that are not divisible by 8
+    (the number of bytes isn't whole).
+    """
+
+    [{"Bits size", bit_size(bitstring)}, {"Description", description}]
+  end
+
+  defp find_first_codepoint(binary, fun) do
+    binary
+    |> String.codepoints()
+    |> Enum.find(fun)
+  end
+end
+
+defimpl IEx.Info, for: Integer do
+  def info(_integer) do
+    [{"Data type", "Integer"}, {"Reference modules", "Integer"}]
+  end
+end
+
+defimpl IEx.Info, for: Float do
+  def info(_float) do
+    [{"Data type", "Float"}, {"Reference modules", "Float"}]
+  end
+end
+
+defimpl IEx.Info, for: Function do
+  def info(fun) do
+    fun_info = Function.info(fun)
+
+    specific_info =
+      if fun_info[:type] == :external and fun_info[:env] == [] do
+        info_named_fun(fun_info)
+      else
+        info_anon_fun(fun_info)
+      end
+
+    [{"Data type", "Function"}] ++ specific_info
+  end
+
+  defp info_anon_fun(fun_info) do
+    [
+      {"Type", to_string(fun_info[:type])},
+      {"Arity", fun_info[:arity]},
+      {"Description", "This is an anonymous function."}
+    ]
+  end
+
+  defp info_named_fun(fun_info) do
+    [
+      {"Type", to_string(fun_info[:type])},
+      {"Arity", fun_info[:arity]}
+    ]
+  end
+end
+
+defimpl IEx.Info, for: PID do
+  @keys [:registered_name, :links, :message_queue_len]
+
+  def info(pid) do
+    extra_info =
+      try do
+        :erpc.call(node(pid), :erlang, :process_info, [pid, @keys])
+      catch
+        _, _ -> [{"Alive", false}]
+      else
+        [_ | _] = info ->
+          [
+            {"Alive", true},
+            {"Name", process_name(info[:registered_name])},
+            {"Links", links(info[:links])},
+            {"Message queue length", info[:message_queue_len]}
+          ]
+
+        _ ->
+          [{"Alive", false}]
+      end
+
+    final_info = [
+      {"Description", "Use Process.info/1 to get more info about this process"},
+      {"Reference modules", "Process, Node"}
+    ]
+
+    [{"Data type", "PID"}] ++ extra_info ++ final_info
+  end
+
+  defp process_name([]), do: "not registered"
+  defp process_name(name), do: inspect(name)
+
+  defp links([]), do: "none"
+  defp links(links), do: Enum.map_join(links, ", ", &inspect/1)
+end
+
+defimpl IEx.Info, for: Map do
+  def info(_map) do
+    [{"Data type", "Map"}, {"Reference modules", "Map"}]
+  end
+end
+
+defimpl IEx.Info, for: Port do
+  def info(port) do
+    open? =
+      try do
+        :erpc.call(node(port), :erlang, :port_info, [port, :connected])
+      catch
+        _, _ -> false
+      else
+        {:connected, _} -> true
+        _ -> false
+      end
+
+    [
+      {"Data type", "Port"},
+      {"Open", open?},
+      {"Reference modules", "Port"}
+    ]
+  end
+end
+
+defimpl IEx.Info, for: Reference do
+  def info(_ref) do
+    [{"Data type", "Reference"}]
+  end
+end
+
+defimpl IEx.Info, for: [Date, Time, DateTime, NaiveDateTime, Regex] do
+  naive_datetime_repr = ~S{"naive" datetime (that is, a datetime without a time zone)}
+
+  {sigil, repr, modules} =
+    case @for do
+      Date -> {"D", "date", [Calendar, Map]}
+      Time -> {"T", "time", [Calendar, Map]}
+      DateTime -> {"U", "datetime", [Calendar, Map]}
+      NaiveDateTime -> {"N", naive_datetime_repr, [Calendar, Map]}
+      Regex -> {"r", "regular expression", [:re]}
+    end
+
+  def info(value) do
+    description = """
+    This is a struct representing a #{unquote(repr)}. It is commonly
+    represented using the `~#{unquote(sigil)}` sigil syntax, that is
+    defined in the `Kernel.sigil_#{unquote(sigil)}/2` macro.
+    """
+
+    [
+      {"Data type", inspect(@for)},
+      {"Description", description},
+      {"Raw representation", raw_inspect(value)},
+      {"Reference modules", unquote(Enum.map_join([@for | modules], ", ", &inspect/1))}
+    ]
+  end
+
+  defp raw_inspect(value) do
+    value
+    |> Inspect.Any.inspect(%Inspect.Opts{})
+    |> case do
+      {doc, %Inspect.Opts{}} -> doc
+      doc -> doc
+    end
+    |> Inspect.Algebra.format(:infinity)
+    |> IO.iodata_to_binary()
+  end
+end
+
+defimpl IEx.Info, for: Range do
+  def info(value) do
+    description = """
+    This is a struct representing a range of numbers. It is commonly
+    defined using the `first..last//step` syntax. The step is not
+    required and defaults to `1`.
+    """
+
+    [
+      {"Data type", inspect(@for)},
+      {"Description", description},
+      {"Raw representation", raw_inspect(value)},
+      {"Reference modules", inspect(@for)}
+    ]
+  end
+
+  defp raw_inspect(value) do
+    value
+    |> Inspect.Any.inspect(%Inspect.Opts{})
+    |> case do
+      {doc, %Inspect.Opts{}} -> doc
+      doc -> doc
+    end
+    |> Inspect.Algebra.format(:infinity)
+    |> IO.iodata_to_binary()
+  end
+end
+
+defimpl IEx.Info, for: Any do
+  def info(%module{}) do
+    [
+      {"Data type", inspect(module)},
+      {"Description", "This is a struct. Structs are maps with a __struct__ key."},
+      {"Reference modules", inspect(module) <> ", Map"}
+    ]
+  end
+end
diff --git a/lib/iex/lib/iex/introspection.ex b/lib/iex/lib/iex/introspection.ex
index c5653b39ac2..8e230984756 100644
--- a/lib/iex/lib/iex/introspection.ex
+++ b/lib/iex/lib/iex/introspection.ex
@@ -1,342 +1,902 @@
-# Convenience helpers for showing docs, specs and types
-# from modules. Invoked directly from IEx.Helpers.
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# Convenience helpers for showing docs, specs, types
+# and opening modules. Invoked directly from IEx.Helpers.
 defmodule IEx.Introspection do
   @moduledoc false
 
   import IEx, only: [dont_display_result: 0]
 
+  alias Code.Typespec
+
   @doc """
-  Documentation for modules.
-  It has a fallback clauses
+  Decomposes an introspection call into `{mod, fun, arity}`,
+  `{mod, fun}` or `mod`.
   """
-  def h(module) when is_atom(module) do
-    case Code.ensure_loaded(module) do
-      {:module, _} ->
-        if function_exported?(module, :__info__, 1) do
-          case Code.get_docs(module, :moduledoc) do
-            {_, binary} when is_binary(binary) ->
-              if opts = ansi_docs() do
-                IO.ANSI.Docs.print_heading(inspect(module), opts)
-                IO.ANSI.Docs.print(binary, opts)
-              else
-                IO.puts "* #{inspect(module)}\n"
-                IO.puts binary
-              end
-            {_, _} ->
-              nodocs(inspect module)
-            _ ->
-              IO.puts IEx.color(:eval_error, "#{inspect module} was not compiled with docs")
-          end
-        else
-          IO.puts IEx.color(:eval_error, "#{inspect module} is an Erlang module and, as such, it does not have Elixir-style docs")
+  def decompose(atom, _context) when is_atom(atom), do: atom
+
+  def decompose({:__aliases__, _, _} = module, context) do
+    Macro.expand(module, context)
+  end
+
+  def decompose({:/, _, [call, arity]}, context) do
+    case Macro.decompose_call(call) do
+      {_mod, :__info__, []} when arity == 1 ->
+        {Module, :__info__, 1}
+
+      {mod, fun, []} ->
+        {Macro.expand(mod, context), fun, arity}
+
+      {fun, []} ->
+        {find_decompose_fun_arity(fun, arity, context), fun, arity}
+
+      _ ->
+        :error
+    end
+  end
+
+  def decompose(call, context) do
+    case Macro.decompose_call(call) do
+      {_mod, :__info__, []} ->
+        {Module, :__info__, 1}
+
+      {maybe_sigil, [_, _]} ->
+        case Atom.to_string(maybe_sigil) do
+          "sigil_" <> _ ->
+            {find_decompose_fun_arity(maybe_sigil, 2, context), maybe_sigil, 2}
+
+          _ ->
+            :error
         end
-      {:error, reason} ->
-        IO.puts IEx.color(:eval_error, "Could not load module #{inspect module}, got: #{reason}")
+
+      {mod, fun, []} ->
+        {Macro.expand(mod, context), fun}
+
+      {fun, []} ->
+        {find_decompose_fun(fun, context), fun}
+
+      _ ->
+        :error
     end
-    dont_display_result
   end
 
-  def h(_) do
-    IO.puts IEx.color(:eval_error, "Invalid arguments for h helper")
-    dont_display_result
+  defp find_decompose_fun(fun, context) do
+    find_import(fun, context.functions) || find_import(fun, context.macros) ||
+      find_special_form(fun) || Kernel
+  end
+
+  defp find_decompose_fun_arity(fun, arity, context) do
+    pair = {fun, arity}
+
+    find_import(pair, context.functions) || find_import(pair, context.macros) ||
+      find_special_form(pair) || Kernel
+  end
+
+  defp find_import(pair, context) when is_tuple(pair) do
+    Enum.find_value(context, fn {mod, functions} ->
+      if pair in functions, do: mod
+    end)
+  end
+
+  defp find_import(fun, context) do
+    Enum.find_value(context, fn {mod, functions} ->
+      if Keyword.has_key?(functions, fun), do: mod
+    end)
+  end
+
+  defp find_special_form(pair) when is_tuple(pair) do
+    special_form_function? = pair in Kernel.SpecialForms.__info__(:functions)
+    special_form_macro? = pair in Kernel.SpecialForms.__info__(:macros)
+
+    if special_form_function? or special_form_macro?, do: Kernel.SpecialForms
+  end
+
+  defp find_special_form(fun) do
+    special_form_function? = Keyword.has_key?(Kernel.SpecialForms.__info__(:functions), fun)
+    special_form_macro? = Keyword.has_key?(Kernel.SpecialForms.__info__(:macros), fun)
+
+    if special_form_function? or special_form_macro?, do: Kernel.SpecialForms
   end
 
   @doc """
-  Docs for the given function, with any arity, in any of the modules.
+  Opens the given module, mfa, file/line, binary.
   """
-  def h(modules, function) when is_list(modules) and is_atom(function) do
-    result =
-      Enum.reduce modules, :not_found, fn
-        module, :not_found -> h_mod_fun(module, function)
-        _module, acc -> acc
-      end
+  def open(module) when is_atom(module) do
+    case open_mfa(module, :__info__, 1) do
+      {source, nil, _} -> open(source)
+      {_, tuple, _} -> open(tuple)
+      {:error, reason} -> puts_error("Could not open #{inspect(module)}, #{reason}")
+    end
+
+    dont_display_result()
+  end
 
-    unless result == :ok, do:
-      nodocs(function)
+  def open({module, function}) when is_atom(module) and is_atom(function) do
+    case open_mfa(module, function, :*) do
+      {_, _, nil} ->
+        puts_error(
+          "Could not open #{inspect(module)}.#{function}, function/macro is not available"
+        )
 
-    dont_display_result
+      {_, _, tuple} ->
+        open(tuple)
+
+      {:error, reason} ->
+        puts_error("Could not open #{inspect(module)}.#{function}, #{reason}")
+    end
+
+    dont_display_result()
   end
 
-  def h(module, function) when is_atom(module) and is_atom(function) do
-    case h_mod_fun(module, function) do
-      :ok ->
-        :ok
-      :no_docs ->
-        IO.puts IEx.color(:eval_error, "#{inspect module} was not compiled with docs")
-      :not_found ->
-        nodocs("#{inspect module}.#{function}")
+  def open({module, function, arity})
+      when is_atom(module) and is_atom(function) and is_integer(arity) do
+    case open_mfa(module, function, arity) do
+      {_, _, nil} ->
+        puts_error(
+          "Could not open #{inspect(module)}.#{function}/#{arity}, function/macro is not available"
+        )
+
+      {_, _, tuple} ->
+        open(tuple)
+
+      {:error, reason} ->
+        puts_error("Could not open #{inspect(module)}.#{function}/#{arity}, #{reason}")
     end
 
-    dont_display_result
+    dont_display_result()
   end
 
-  defp h_mod_fun(mod, fun) when is_atom(mod) and is_atom(fun) do
-    if docs = Code.get_docs(mod, :docs) do
-      result = for {{f, arity}, _line, _type, _args, doc} <- docs, fun == f, doc != false do
-        h(mod, fun, arity)
-        IO.puts ""
-      end
+  def open({file, line}) when is_binary(file) and is_integer(line) do
+    cond do
+      not File.regular?(file) ->
+        puts_error("Could not open #{inspect(file)}, file is not available.")
+
+      editor = System.get_env("ELIXIR_EDITOR") || System.get_env("EDITOR") ->
+        command =
+          if editor =~ "__FILE__" or editor =~ "__LINE__" do
+            editor
+            |> String.replace("__FILE__", inspect(file))
+            |> String.replace("__LINE__", Integer.to_string(line))
+          else
+            "#{editor} #{inspect(file)}:#{line}"
+          end
+
+        IO.write(IEx.color(:eval_info, :os.cmd(String.to_charlist(command))))
+
+      true ->
+        puts_error(
+          "Could not open: #{inspect(file)}. " <>
+            "Please set the ELIXIR_EDITOR or EDITOR environment variables with the " <>
+            "command line invocation of your favorite EDITOR."
+        )
+    end
+
+    dont_display_result()
+  end
+
+  def open(invalid) do
+    puts_error("Invalid arguments for open helper: #{inspect(invalid)}")
+    dont_display_result()
+  end
+
+  defp open_mfa(module, fun, arity) do
+    case Code.ensure_loaded(module) do
+      {:module, _} ->
+        case module.module_info(:compile)[:source] do
+          [_ | _] = source ->
+            source = rewrite_source(module, source)
+            open_abstract_code(module, fun, arity, source)
+
+          _ ->
+            {:error, "source code is not available"}
+        end
 
-      if result != [], do: :ok, else: :not_found
+      _ ->
+        {:error, "module is not available"}
+    end
+  end
+
+  defp open_abstract_code(module, fun, arity, source) do
+    fun = Atom.to_string(fun)
+
+    with [_ | _] = beam <- :code.which(module),
+         {:ok, {_, [abstract_code: abstract_code]}} <- :beam_lib.chunks(beam, [:abstract_code]),
+         {:raw_abstract_v1, code} <- abstract_code do
+      {_, module_pair, fa_pair} =
+        Enum.reduce(code, {source, nil, nil}, &open_abstract_code_reduce(&1, &2, fun, arity))
+
+      {source, module_pair, fa_pair}
     else
-      :no_docs
+      _ ->
+        {source, nil, nil}
+    end
+  end
+
+  defp open_abstract_code_reduce(entry, {file, module_pair, fa_pair}, fun, arity) do
+    case entry do
+      {:attribute, ann, :module, _} ->
+        {file, {file, :erl_anno.line(ann)}, fa_pair}
+
+      {:function, ann, ann_fun, ann_arity, _} ->
+        case Atom.to_string(ann_fun) do
+          "MACRO-" <> ^fun when arity == :* or ann_arity == arity + 1 ->
+            {file, module_pair, fa_pair || {file, :erl_anno.line(ann)}}
+
+          ^fun when arity == :* or ann_arity == arity ->
+            {file, module_pair, fa_pair || {file, :erl_anno.line(ann)}}
+
+          _ ->
+            {file, module_pair, fa_pair}
+        end
+
+      _ ->
+        {file, module_pair, fa_pair}
+    end
+  end
+
+  @elixir_apps ~w(eex elixir ex_unit iex logger mix)a
+  @otp_apps ~w(kernel stdlib)a
+  @apps @elixir_apps ++ @otp_apps
+
+  defp rewrite_source(module, source) do
+    case :application.get_application(module) do
+      {:ok, app} when app in @apps ->
+        Application.app_dir(app, rewrite_source(source))
+
+      _ ->
+        beam_path = :code.which(module)
+
+        if is_list(beam_path) and List.starts_with?(beam_path, :code.root_dir()) do
+          app_vsn = beam_path |> Path.dirname() |> Path.dirname() |> Path.basename()
+          Path.join([:code.root_dir(), "lib", app_vsn, rewrite_source(source)])
+        else
+          List.to_string(source)
+        end
     end
   end
 
+  defp rewrite_source(source) do
+    {in_app, [lib_or_src | _]} =
+      source
+      |> Path.split()
+      |> Enum.reverse()
+      |> Enum.split_while(&(&1 not in ["lib", "src"]))
+
+    Path.join([lib_or_src | Enum.reverse(in_app)])
+  end
+
   @doc """
-  Documentation for the given function and arity in the list of modules.
+  Prints documentation.
   """
-  def h(modules, function, arity) when is_list(modules) and is_atom(function) and is_integer(arity) do
-    result =
-      Enum.reduce modules, :not_found, fn
-        module, :not_found -> h_mod_fun_arity(module, function, arity)
-        _module, acc -> acc
-      end
+  def h(module) when is_atom(module) do
+    case Code.ensure_loaded(module) do
+      {:module, _} ->
+        case Code.fetch_docs(module) do
+          # TODO remove once we require Erlang/OTP 27+
+          {:docs_v1, _, :erlang, "application/erlang+html", _, _, _} = erl_docs ->
+            :shell_docs.render(module, erl_docs) |> IO.puts()
 
-    unless result == :ok, do:
-      nodocs("#{function}/#{arity}")
+          {:docs_v1, _, _, format, doc, metadata, _} when is_map(doc) or doc == :none ->
+            print_doc([inspect(module)], [], format, doc, metadata)
 
-    dont_display_result
-  end
+          {:docs_v1, _, _, _, _, _, _} ->
+            docs_not_found(inspect(module))
 
-  def h(module, function, arity) when is_atom(module) and is_atom(function) and is_integer(arity) do
-    case h_mod_fun_arity(module, function, arity) do
-      :ok ->
-        :ok
-      :no_docs ->
-        IO.puts IEx.color(:eval_error, "#{inspect module} was not compiled with docs")
-      :not_found ->
-        nodocs("#{inspect module}.#{function}/#{arity}")
+          _ ->
+            no_docs(module)
+        end
+
+      {:error, reason} ->
+        puts_error("Could not load module #{inspect(module)}, got: #{reason}")
     end
 
-    dont_display_result
+    dont_display_result()
   end
 
-  defp h_mod_fun_arity(mod, fun, arity) when is_atom(mod) and is_atom(fun) and is_integer(arity) do
-    if docs = Code.get_docs(mod, :docs) do
-      doc =
+  def h({module, function}) when is_atom(module) and is_atom(function) do
+    case Code.ensure_loaded(module) do
+      {:module, _} ->
+        {_language, _format, docs, _} = get_docs(module, [:function, :macro])
+
+        exports =
+          cond do
+            docs ->
+              Enum.map(docs, &extract_name_and_arity/1)
+
+            function_exported?(module, :__info__, 1) ->
+              module.__info__(:functions) ++ module.__info__(:macros)
+
+            true ->
+              module.module_info(:exports)
+          end
+          |> Enum.sort()
+          |> Enum.dedup()
+
+        result =
+          for {^function, arity} <- exports,
+              (if docs do
+                 find_doc_with_content(docs, function, arity)
+               else
+                 get_spec(module, function, arity) != []
+               end) do
+            h_mod_fun_arity(module, function, arity)
+          end
+
         cond do
-          d = find_doc(docs, fun, arity)         -> d
-          d = find_default_doc(docs, fun, arity) -> d
-          true                                   -> nil
+          result != [] ->
+            :ok
+
+          docs && has_callback?(module, function) ->
+            behaviour_found("#{inspect(module)}.#{function}")
+
+          docs && has_type?(module, function) ->
+            type_found("#{inspect(module)}.#{function}")
+
+          is_nil(docs) ->
+            no_docs(module)
+
+          true ->
+            docs_not_found("#{inspect(module)}.#{function}")
         end
 
-      if doc do
-        print_doc(doc)
+      {:error, reason} ->
+        puts_error("Could not load module #{inspect(module)}, got: #{reason}")
+    end
+
+    dont_display_result()
+  end
+
+  def h({module, function, arity})
+      when is_atom(module) and is_atom(function) and is_integer(arity) do
+    case Code.ensure_loaded(module) do
+      {:module, _} ->
+        case h_mod_fun_arity(module, function, arity) do
+          :ok ->
+            :ok
+
+          :behaviour_found ->
+            behaviour_found("#{inspect(module)}.#{function}/#{arity}")
+
+          :type_found ->
+            type_found("#{inspect(module)}.#{function}/#{arity}")
+
+          :no_docs ->
+            no_docs(module)
+
+          :not_found ->
+            docs_not_found("#{inspect(module)}.#{function}/#{arity}")
+        end
+
+      {:error, reason} ->
+        puts_error("Could not load module #{inspect(module)}, got: #{reason}")
+    end
+
+    dont_display_result()
+  end
+
+  def h(invalid) do
+    puts_error(
+      "The \"h\" helper expects a Module, Module.fun or Module.fun/arity, got: #{inspect(invalid)}"
+    )
+
+    puts_error(
+      "If instead of accessing documentation you would like more information about a value " <>
+        "or about the result of an expression, use the \"i\" helper instead"
+    )
+
+    dont_display_result()
+  end
+
+  defp h_mod_fun_arity(mod, fun, arity) when is_atom(mod) do
+    {language, format, docs, docs_v1} = get_docs(mod, [:function, :macro])
+    spec = get_spec(mod, fun, arity)
+
+    cond do
+      # TODO remove once we require Erlang/OTP 27+
+      language == :erlang and format == "application/erlang+html" ->
+        print_erlang_doc(mod, fun, arity, docs_v1)
         :ok
-      else
+
+      doc_tuple = find_doc_with_content(docs, fun, arity) ->
+        print_fun(mod, language, format, doc_tuple, spec)
+        :ok
+
+      docs && has_callback?(mod, fun, arity) ->
+        :behaviour_found
+
+      docs && has_type?(mod, fun, arity) ->
+        :type_found
+
+      is_nil(docs) and spec != [] ->
+        en = "Module was compiled without docs. Showing only specs."
+        formatted = Exception.format_mfa(mod, fun, arity)
+        print_doc([formatted], spec, "text/markdown", %{"en" => en}, %{})
+        :ok
+
+      is_nil(docs) ->
+        :no_docs
+
+      true ->
         :not_found
-      end
-    else
-      :no_docs
     end
   end
 
-  defp find_doc(docs, function, arity) do
-    if doc = List.keyfind(docs, {function, arity}, 0) do
-      case elem(doc, 4) do
-        false -> nil
-        _ -> doc
-      end
+  defp has_callback?(mod, fun) do
+    match?([_ | _], get_callback_docs(mod, &match?({_, ^fun, _}, elem(&1, 0))))
+  end
+
+  defp has_callback?(mod, fun, arity) do
+    match?([_ | _], get_callback_docs(mod, &match?({_, ^fun, ^arity}, elem(&1, 0))))
+  end
+
+  defp has_type?(mod, fun) do
+    {_, _, docs, _} = get_docs(mod, [:type])
+    Enum.any?(docs, &match?({_, ^fun, _}, elem(&1, 0)))
+  end
+
+  defp has_type?(mod, fun, arity) do
+    {_, _, docs, _} = get_docs(mod, [:type])
+    Enum.any?(docs, &match?({_, ^fun, ^arity}, elem(&1, 0)))
+  end
+
+  defp get_docs(mod, kinds) do
+    case Code.fetch_docs(mod) do
+      {:docs_v1, _, language, format, _, _, docs} = docs_v1 ->
+        docs = for {{kind, _, _}, _, _, _, _} = doc <- docs, kind in kinds, do: doc
+        {language, format, docs, docs_v1}
+
+      {:error, _} ->
+        {nil, nil, nil, nil}
     end
   end
 
-  defp find_default_doc(docs, function, min) do
-    Enum.find docs, fn(doc) ->
-      case elem(doc, 0) do
-        {^function, max} when max > min ->
-          defaults = Enum.count elem(doc, 3), &match?({:\\, _, _}, &1)
-          min + defaults >= max
-        _ ->
-          false
-      end
+  defp extract_name_and_arity({{_, name, arity}, _, _, _, _}), do: {name, arity}
+
+  defp find_doc_with_content(docs, function, arity) do
+    case find_doc(docs, function, arity) do
+      {_, _, _, :hidden, _} -> nil
+      {_, _, _, _, _} = doc -> doc
+      _ -> nil
     end
   end
 
-  defp print_doc({{fun, _}, _line, kind, args, doc}) do
-    args    = Enum.map_join(args, ", ", &print_doc_arg(&1))
-    heading = "#{kind} #{fun}(#{args})"
-    doc     = doc || ""
+  defp find_doc(nil, _fun, _arity) do
+    nil
+  end
+
+  defp find_doc(docs, fun, arity) do
+    Enum.find(docs, &match?({_, ^fun, ^arity}, elem(&1, 0))) ||
+      find_doc_defaults(docs, fun, arity)
+  end
+
+  defp find_doc_defaults(docs, function, min) do
+    Enum.find(docs, fn
+      {{_, ^function, arity}, _, _, _, %{defaults: defaults}} when arity > min ->
+        arity <= min + defaults
+
+      _ ->
+        false
+    end)
+  end
+
+  defp print_fun(
+         mod,
+         language,
+         format,
+         {{kind, fun, arity}, _line, signature, doc, metadata},
+         spec
+       ) do
+    callback_module = doc == :none and callback_module(mod, fun, arity)
+
+    if callback_module do
+      filter = &match?({_, ^fun, ^arity}, elem(&1, 0))
 
-    if opts = ansi_docs() do
-      IO.ANSI.Docs.print_heading(heading, opts)
-      IO.ANSI.Docs.print(doc, opts)
+      case get_callback_docs(callback_module, filter) do
+        :no_beam ->
+          nil
+
+        callback_docs ->
+          en =
+            "#{Exception.format_mfa(mod, fun, arity)} has no docs but is a callback for behaviour " <>
+              "#{inspect(callback_module)}. Showing callback docs instead."
+
+          format_signature(language, kind, signature)
+          |> print_doc(spec, format, %{"en" => en}, metadata)
+
+          Enum.each(callback_docs, &print_typespec/1)
+      end
     else
-      IO.puts "* #{heading}\n"
-      IO.puts doc
+      print_doc(format_signature(language, kind, signature), spec, format, doc, metadata)
     end
   end
 
-  defp print_doc_arg({:\\, _, [left, right]}) do
-    print_doc_arg(left) <> " \\\\ " <> Macro.to_string(right)
-  end
+  defp format_signature(:elixir, :function, signature), do: Enum.map(signature, &("def " <> &1))
+  defp format_signature(:elixir, :macro, signature), do: Enum.map(signature, &("defmacro " <> &1))
+  defp format_signature(_, _, signature), do: signature
 
-  defp print_doc_arg({var, _, _}) do
-    Atom.to_string(var)
+  defp callback_module(mod, fun, arity) do
+    mod.module_info(:attributes)
+    |> Keyword.get_values(:behaviour)
+    |> Stream.concat()
+    |> Enum.find(&has_callback?(&1, fun, arity))
   end
 
-  defp ansi_docs() do
-    opts = Application.get_env(:iex, :colors)
-    if opts[:enabled] do
-      [width: IEx.width] ++ opts
+  defp get_spec(module, name, arity) do
+    with {:ok, all_specs} <- Typespec.fetch_specs(module),
+         {_, specs} <- List.keyfind(all_specs, {name, arity}, 0) do
+      formatted =
+        Enum.map(specs, fn spec ->
+          Typespec.spec_to_quoted(name, spec)
+          |> format_typespec(:spec, 2)
+        end)
+
+      [formatted, ?\n]
+    else
+      _ -> []
     end
   end
 
   @doc """
-  Print types in module.
+  Prints the list of behaviour callbacks or a given callback.
   """
-  def t(module) when is_atom(module) do
-    case Kernel.Typespec.beam_types(module) do
-      nil   -> nobeam(module)
-      []    -> notypes(inspect module)
-      types -> for type <- types, do: print_type(type)
+  def b(mod) when is_atom(mod) do
+    case get_callback_docs(mod, fn _ -> true end) do
+      :no_beam ->
+        no_beam(mod)
+
+      [] ->
+        puts_error("No callbacks for #{inspect(mod)} were found")
+
+      docs ->
+        docs
+        |> add_optional_callback_docs(mod)
+        |> Enum.each(fn {_, definition, _, _} -> IO.puts(definition) end)
     end
 
-    dont_display_result
+    dont_display_result()
   end
 
-  @doc """
-  Print the given type in module with any arity.
-  """
-  def t(module, type) when is_atom(module) and is_atom(type) do
-    case Kernel.Typespec.beam_types(module) do
-      nil   -> nobeam(module)
-      types ->
-        printed =
-          for {_, {t, _, _args}} = typespec <- types, t == type do
-            print_type(typespec)
-            typespec
-          end
+  def b({mod, fun}) when is_atom(mod) and is_atom(fun) do
+    filter = &match?({_, ^fun, _}, elem(&1, 0))
 
-        if printed == [] do
-          notypes("#{inspect module}.#{type}")
-        end
+    case get_callback_docs(mod, filter) do
+      :no_beam -> no_beam(mod)
+      [] -> docs_not_found("#{inspect(mod)}.#{fun}")
+      docs -> Enum.each(docs, &print_typespec/1)
     end
 
-    dont_display_result
+    dont_display_result()
   end
 
-  @doc """
-  Print type in module with given arity.
-  """
-  def t(module, type, arity) when is_atom(module) and is_atom(type) and is_integer(arity) do
-    case Kernel.Typespec.beam_types(module) do
-      nil   -> nobeam(module)
-      types ->
-        printed =
-          for {_, {t, _, args}} = typespec <- types, t == type, length(args) == arity do
-            print_type(typespec)
-            typespec
+  def b({mod, fun, arity}) when is_atom(mod) and is_atom(fun) and is_integer(arity) do
+    filter = &match?({_, ^fun, ^arity}, elem(&1, 0))
+
+    case get_callback_docs(mod, filter) do
+      :no_beam -> no_beam(mod)
+      [] -> docs_not_found("#{inspect(mod)}.#{fun}/#{arity}")
+      docs -> Enum.each(docs, &print_typespec/1)
+    end
+
+    dont_display_result()
+  end
+
+  def b(invalid) do
+    puts_error("Invalid arguments for b helper: #{inspect(invalid)}")
+    dont_display_result()
+  end
+
+  defp get_callback_docs(mod, filter) do
+    {_, format, docs, _} = get_docs(mod, [:callback, :macrocallback])
+
+    case Typespec.fetch_callbacks(mod) do
+      :error ->
+        :no_beam
+
+      {:ok, callbacks} ->
+        callbacks
+        |> Enum.map(&translate_callback/1)
+        |> Enum.filter(filter)
+        |> Enum.sort()
+        |> Enum.flat_map(fn {{_, function, arity}, _specs} = callback ->
+          case find_doc(docs, function, arity) do
+            nil -> [{format, format_callback(callback), :none, %{}}]
+            {_, _, _, :hidden, _} -> []
+            {_, _, _, doc, metadata} -> [{format, format_callback(callback), doc, metadata}]
           end
+        end)
+    end
+  end
 
-        if printed == [] do
-          notypes("#{inspect module}.#{type}")
-        end
+  defp translate_callback({name_arity, specs}) do
+    case translate_callback_name_arity(name_arity) do
+      {:macrocallback, _, _} = kind_name_arity ->
+        # The typespec of a macrocallback differs from the one expressed
+        # via @macrocallback:
+        #
+        #   * The function name is prefixed with "MACRO-"
+        #   * The arguments contain an additional first argument: the caller
+        #   * The arity is increased by 1
+        #
+        specs = Enum.map(specs, &unpack_caller/1)
+        {kind_name_arity, specs}
+
+      kind_name_arity ->
+        {kind_name_arity, specs}
+    end
+  end
+
+  defp unpack_caller({:type, line1, :fun, [{:type, line2, :product, [_ | args]} | tail]}) do
+    {:type, line1, :fun, [{:type, line2, :product, args} | tail]}
+  end
+
+  defp unpack_caller({:type, line, :bounded_fun, [head | tail]}) do
+    {:type, line, :bounded_fun, [unpack_caller(head) | tail]}
+  end
+
+  def translate_callback_name_arity({name, arity}) do
+    case Atom.to_string(name) do
+      "MACRO-" <> macro_name -> {:macrocallback, String.to_atom(macro_name), arity - 1}
+      _ -> {:callback, name, arity}
+    end
+  end
+
+  defp format_callback({{kind, name, _arity}, specs}) do
+    Enum.map(specs, fn spec ->
+      Typespec.spec_to_quoted(name, spec)
+      |> format_typespec(kind, 0)
+    end)
+  end
+
+  defp add_optional_callback_docs(docs, mod) do
+    optional_callbacks =
+      if Code.ensure_loaded?(mod) and function_exported?(mod, :behaviour_info, 1) do
+        mod.behaviour_info(:optional_callbacks)
+        |> Enum.map(fn name_arity ->
+          {_kind, name, arity} = translate_callback_name_arity(name_arity)
+          {name, arity}
+        end)
+        |> Enum.sort()
+      else
+        []
+      end
+
+    if optional_callbacks == [] do
+      docs
+    else
+      docs ++ [{"text/markdown", format_optional_callbacks(optional_callbacks), "", %{}}]
     end
+  end
 
-    dont_display_result
+  defp format_optional_callbacks(callbacks) do
+    format_typespec(callbacks, :optional_callbacks, 0)
   end
 
   @doc """
-  Print specs for given module.
+  Prints the types for the given module and type documentation.
   """
-  def s(module) when is_atom(module) do
-    case beam_specs(module) do
-      nil   -> nobeam(module)
-      []    -> nospecs(inspect module)
-      specs ->
-        printed = for {_kind, {{f, _arity}, _spec}} = spec <- specs, f != :"__info__" do
-          print_spec(spec)
-        end
-        if printed == [] do
-          nospecs(inspect module)
+  def t(module) when is_atom(module) do
+    case :code.get_doc(module) do
+      # TODO remove once we require Erlang/OTP 27+
+      {:ok, {:docs_v1, _, :erlang, "application/erlang+html", _, _, _} = erl_docs} ->
+        :shell_docs.render_type(module, erl_docs) |> IO.puts()
+
+      _ ->
+        case Typespec.fetch_types(module) do
+          :error ->
+            no_beam(module)
+
+          {:ok, []} ->
+            types_not_found(inspect(module))
+
+          {:ok, types} ->
+            types
+            |> Enum.sort_by(fn {_, {name, _, args}} -> {name, length(args)} end)
+            |> Enum.each(&(&1 |> format_type() |> IO.puts()))
         end
     end
 
-    dont_display_result
+    dont_display_result()
   end
 
-  @doc """
-  Print specs for given module and function.
-  """
-  def s(module, function) when is_atom(module) and is_atom(function) do
-    case beam_specs(module) do
-      nil   -> nobeam(module)
-      specs ->
-        printed =
-          for {_kind, {{f, _arity}, _spec}} = spec <- specs, f == function do
-            print_spec(spec)
-            spec
-          end
+  def t({module, type}) when is_atom(module) and is_atom(type) do
+    case get_docs(module, [:type]) do
+      # TODO remove once we require Erlang/OTP 27+
+      {:erlang, "application/erlang+html", _, erl_docs} ->
+        case :shell_docs.render_type(module, type, erl_docs) do
+          {:error, :type_missing} -> types_not_found_or_private("#{inspect(module)}.#{type}")
+          iodata -> IO.puts(iodata)
+        end
 
-        if printed == [] do
-          nospecs("#{inspect module}.#{function}")
+      {_, format, docs, _} ->
+        case Typespec.fetch_types(module) do
+          :error ->
+            no_beam(module)
+
+          {:ok, types} ->
+            types
+            |> Enum.filter(&match?({kind, {^type, _, _}} when kind in [:type, :opaque], &1))
+            |> Enum.sort_by(fn {_, {name, _, args}} -> {name, length(args)} end)
+            |> case do
+              [] ->
+                types_not_found_or_private("#{inspect(module)}.#{type}")
+
+              types ->
+                Enum.map(types, fn {_, {_, _, args}} = typespec ->
+                  type
+                  |> type_doc(length(args), typespec, format, docs)
+                  |> print_typespec()
+                end)
+            end
         end
     end
 
-    dont_display_result
+    dont_display_result()
   end
 
-  @doc """
-  Print spec in given module, with arity.
-  """
-  def s(module, function, arity) when is_atom(module) and is_atom(function) and is_integer(arity) do
-    case beam_specs(module) do
-      nil   -> nobeam(module)
-      specs ->
-        printed =
-          for {_kind, {{f, a}, _spec}} = spec <- specs, f == function and a == arity do
-            print_spec(spec)
-            spec
-          end
+  def t({module, type, arity}) when is_atom(module) and is_atom(type) and is_integer(arity) do
+    case get_docs(module, [:type]) do
+      # TODO remove once we require Erlang/OTP 27+
+      {:erlang, "application/erlang+html", _, erl_docs} ->
+        case :shell_docs.render_type(module, type, arity, erl_docs) do
+          {:error, :type_missing} -> types_not_found_or_private("#{inspect(module)}.#{type}")
+          chardata -> IO.puts(chardata)
+        end
 
-        if printed == [] do
-          nospecs("#{inspect module}.#{function}")
+      {_, format, docs, _} ->
+        case Typespec.fetch_types(module) do
+          :error ->
+            no_beam(module)
+
+          {:ok, types} ->
+            types
+            |> Enum.find(
+              &match?(
+                {kind, {^type, _, args}} when kind in [:type, :opaque] and length(args) == arity,
+                &1
+              )
+            )
+            |> case do
+              nil ->
+                types_not_found_or_private("#{inspect(module)}.#{type}")
+
+              typespec ->
+                type
+                |> type_doc(arity, typespec, format, docs)
+                |> print_typespec()
+            end
         end
     end
 
-    dont_display_result
+    dont_display_result()
+  end
+
+  def t(invalid) do
+    puts_error("Invalid arguments for t helper: #{inspect(invalid)}")
+    dont_display_result()
+  end
+
+  defp type_doc(type, arity, typespec, format, docs) do
+    if docs do
+      {_, _, _, content, metadata} = Enum.find(docs, &match?({:type, ^type, ^arity}, elem(&1, 0)))
+      {format, format_type(typespec), content, metadata}
+    else
+      {format, format_type(typespec), :none, %{}}
+    end
+  end
+
+  defp format_type({:opaque, type}) do
+    {:"::", _, [ast, _]} = Typespec.type_to_quoted(type)
+    format_typespec(ast, :opaque, 0)
+  end
+
+  defp format_type({kind, type}) do
+    ast = Typespec.type_to_quoted(type)
+    format_typespec(ast, kind, 0)
+  end
+
+  ## Helpers
+
+  defp format_typespec(definition, kind, nesting) do
+    {:@, [], [{kind, [], [definition]}]}
+    |> Code.quoted_to_algebra()
+    |> Inspect.Algebra.format(IEx.Config.width())
+    |> IO.iodata_to_binary()
+    |> color_prefix_with_line()
+    |> indent(nesting)
+  end
+
+  defp indent(content, 0) do
+    [content, ?\n]
+  end
+
+  defp indent(content, nesting) do
+    whitespace = String.duplicate(" ", nesting)
+    [whitespace, String.replace(content, "\n", "\n#{whitespace}"), ?\n]
   end
 
-  defp beam_specs(module) do
-    specs = beam_specs_tag(Kernel.Typespec.beam_specs(module), :spec)
-    callbacks = beam_specs_tag(Kernel.Typespec.beam_callbacks(module), :callback)
-    specs && callbacks && Enum.concat(specs, callbacks)
+  defp color_prefix_with_line(string) do
+    [left, right] = :binary.split(string, " ")
+    IEx.color(:doc_inline_code, left) <> " " <> right
   end
 
-  defp beam_specs_tag(nil, _), do: nil
-  defp beam_specs_tag(specs, tag) do
-    Enum.map(specs, &{tag, &1})
+  defp print_doc(headings, types, format, doc, metadata) do
+    doc = translate_doc(doc) || ""
+    opts = IEx.Config.ansi_docs()
+    IO.ANSI.Docs.print_headings(headings, opts)
+    IO.write(types)
+    IO.ANSI.Docs.print_metadata(metadata, opts)
+    IO.ANSI.Docs.print(doc, format, opts)
   end
 
-  defp print_type({kind, type}) do
-    ast = Kernel.Typespec.type_to_ast(type)
-    IO.puts IEx.color(:eval_info, "@#{kind} #{Macro.to_string(ast)}")
-    true
+  defp print_typespec({format, types, doc, metadata}) do
+    IO.puts(types)
+    doc = translate_doc(doc)
+    opts = IEx.Config.ansi_docs()
+    IO.ANSI.Docs.print_metadata(metadata, opts)
+    doc && IO.ANSI.Docs.print(doc, format, opts)
   end
 
-  defp print_spec({kind, {{name, _arity}, specs}}) do
-    Enum.each specs, fn(spec) ->
-      binary = Macro.to_string Kernel.Typespec.spec_to_ast(name, spec)
-      IO.puts IEx.color(:eval_info, "@#{kind} #{binary}")
+  defp translate_doc(%{"en" => doc}), do: doc
+  defp translate_doc(_), do: nil
+
+  defp print_erlang_doc(mod, fun, arity, docs) do
+    heading = Exception.format_mfa(mod, fun, arity)
+    opts = IEx.Config.ansi_docs()
+
+    case :shell_docs.render(mod, fun, arity, docs) do
+      {:error, :function_missing} ->
+        docs_not_found("#{inspect(mod)}.#{fun}")
+
+      chardata ->
+        IO.ANSI.Docs.print_headings([heading], opts)
+        IO.puts(chardata)
     end
-    true
   end
 
-  defp nobeam(module) do
+  defp no_beam(module) do
     case Code.ensure_loaded(module) do
       {:module, _} ->
-        IO.puts IEx.color(:eval_error, "Beam code not available for #{inspect module} or debug info is missing, cannot load typespecs")
+        puts_error(
+          "Beam code not available for #{inspect(module)} or debug info is missing, cannot load typespecs"
+        )
+
       {:error, reason} ->
-        IO.puts IEx.color(:eval_error, "Could not load module #{inspect module}, got: #{reason}")
+        puts_error("Could not load module #{inspect(module)}, got: #{reason}")
     end
   end
 
-  defp nospecs(for), do: no(for, "specification")
-  defp notypes(for), do: no(for, "type information")
-  defp nodocs(for),  do: no(for, "documentation")
+  defp no_docs(module) do
+    puts_error("#{inspect(module)} was not compiled with docs")
+  end
+
+  defp types_not_found(for), do: not_found(for, "type information")
+  defp docs_not_found(for), do: not_found(for, "documentation")
+
+  defp types_not_found_or_private(for) do
+    puts_error("No type information for #{for} was found or #{for} is private")
+  end
+
+  defp behaviour_found(for) do
+    puts_error("""
+    No documentation for function #{for} was found, but there is a callback with the same name.
+    You can view callback documentation with the b/1 helper.
+    """)
+  end
+
+  defp type_found(for) do
+    puts_error("""
+    No documentation for function #{for} was found, but there is a type with the same name.
+    You can view type documentation with the t/1 helper.
+    """)
+  end
+
+  defp not_found(for, type) do
+    puts_error("No #{type} for #{for} was found")
+  end
 
-  defp no(for, type) do
-    IO.puts IEx.color(:eval_error, "No #{type} for #{for} was found")
+  defp puts_error(string) do
+    IO.puts(IEx.color(:eval_error, string))
   end
 end
diff --git a/lib/iex/lib/iex/mix_listener.ex b/lib/iex/lib/iex/mix_listener.ex
new file mode 100644
index 00000000000..1910f9397de
--- /dev/null
+++ b/lib/iex/lib/iex/mix_listener.ex
@@ -0,0 +1,75 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule IEx.MixListener do
+  @moduledoc false
+
+  use GenServer
+
+  @name __MODULE__
+
+  @spec start_link(keyword) :: GenServer.on_start()
+  def start_link(_opts) do
+    GenServer.start_link(__MODULE__, {}, name: @name)
+  end
+
+  @doc """
+  Unloads all modules invalidated by external compilations.
+
+  Returns `:noop` if there is no module to purge or if
+  the listener is not running (it may happen when connecting
+  via --remsh to a node that was started without IEx).
+  """
+  @spec purge :: :ok | :noop
+  def purge do
+    if Process.whereis(@name) do
+      GenServer.call(@name, :purge, :infinity)
+    else
+      :noop
+    end
+  end
+
+  @impl true
+  def init({}) do
+    {:ok, %{to_purge: MapSet.new()}}
+  end
+
+  @impl true
+  def handle_call(:purge, _from, state) do
+    purge_modules(state.to_purge)
+    status = if Enum.empty?(state.to_purge), do: :noop, else: :ok
+    {:reply, status, %{state | to_purge: MapSet.new()}}
+  end
+
+  @impl true
+  def handle_info({:modules_compiled, info}, state) do
+    if info.os_pid == System.pid() do
+      # Ignore compilations from ourselves, because the modules are
+      # already updated in memory
+      {:noreply, state}
+    else
+      %{changed: changed, removed: removed} = info.modules_diff
+
+      if IEx.Config.auto_reload?() do
+        purge_modules(changed)
+        purge_modules(removed)
+        {:noreply, state}
+      else
+        state = update_in(state.to_purge, &Enum.into(changed, &1))
+        state = update_in(state.to_purge, &Enum.into(removed, &1))
+        {:noreply, state}
+      end
+    end
+  end
+
+  def handle_info(_message, state) do
+    {:noreply, state}
+  end
+
+  defp purge_modules(modules) do
+    for module <- modules do
+      :code.purge(module)
+      :code.delete(module)
+    end
+  end
+end
diff --git a/lib/iex/lib/iex/pry.ex b/lib/iex/lib/iex/pry.ex
new file mode 100644
index 00000000000..333365f65b6
--- /dev/null
+++ b/lib/iex/lib/iex/pry.ex
@@ -0,0 +1,748 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule IEx.Pry do
+  @moduledoc """
+  The low-level API for prying sessions and setting up breakpoints.
+  """
+
+  @doc false
+  use GenServer
+
+  @table __MODULE__
+  @server __MODULE__
+  @timeout :infinity
+  @initial_counter 1
+
+  @type id :: integer()
+  @type break :: {id, module, {function, arity}, pending :: non_neg_integer}
+  @type break_error ::
+          :recompilation_failed
+          | :no_beam_file
+          | :unknown_function_arity
+          | :missing_debug_info
+          | :outdated_debug_info
+          | :non_elixir_module
+
+  @doc """
+  Callback for `IEx.pry/0`.
+
+  You can invoke this function directly when you are not able to invoke
+  `IEx.pry/0` as a macro. This function expects the binding (from
+  `binding/0`) and the environment (from `__ENV__/0`).
+  """
+  def pry(binding, %Macro.Env{} = env) do
+    self = self()
+    %{file: file, line: line, module: module, function: function_arity} = env
+    {:current_stacktrace, stacktrace} = Process.info(self, :current_stacktrace)
+
+    opts = [
+      binding: binding,
+      dot_iex: "",
+      # Remove all tracers because the tracer code is most
+      # likely stale by the time we are prying the code.
+      env: %{env | tracers: [], lexical_tracker: nil},
+      stacktrace: prune_stacktrace(stacktrace)
+    ]
+
+    location =
+      case function_arity do
+        {function, arity} ->
+          "#{Exception.format_mfa(module, function, arity)} (#{Path.relative_to_cwd(file)}:#{line})"
+
+        _ ->
+          "#{Path.relative_to_cwd(file)}:#{line}"
+      end
+
+    whereami =
+      case whereami(file, line, 3) do
+        {:ok, lines} -> [?\n, ?\n, lines]
+        :error -> []
+      end
+
+    # We cannot use colors because IEx may be off
+    case IEx.Broker.take_over(location, whereami, [evaluator: self()] ++ opts) do
+      {:ok, server, group_leader, start} ->
+        IEx.Evaluator.init(:no_ack, server, group_leader, start, opts)
+
+      {:error, :no_iex} ->
+        message = "Cannot pry #{inspect(self)} at #{location}. Is an IEx shell running?"
+        IO.puts(:stdio, message)
+        {:error, :no_iex}
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  def pry(binding, opts) when is_list(opts) do
+    vars = for {k, _} when is_atom(k) <- binding, do: {k, nil}
+    pry(binding, opts |> Code.env_for_eval() |> :elixir_env.with_vars(vars))
+  end
+
+  @doc false
+  def __next__(next?, binding, opts_or_env) when is_boolean(next?) do
+    next? and pry(binding, opts_or_env) == {:ok, true}
+  end
+
+  @elixir_internals [:elixir, :erl_eval, IEx.Evaluator, IEx.Pry]
+
+  defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
+    prune_stacktrace(t)
+  end
+
+  defp prune_stacktrace([{Process, :info, 2, _} | t]) do
+    prune_stacktrace(t)
+  end
+
+  defp prune_stacktrace([h | t]) do
+    [h | prune_stacktrace(t)]
+  end
+
+  defp prune_stacktrace([]) do
+    []
+  end
+
+  @doc """
+  Annotate quoted expression with line-by-line `IEx.Pry` debugging steps.
+
+  It expects the `quoted` expression to annotate, a boolean `condition` that controls
+  if pry should run or not (usually is simply the boolean `true`), and the
+  caller macro environment.
+  """
+  @doc since: "1.17.0"
+  @spec annotate_quoted(Macro.t(), Macro.t(), Macro.Env.t()) :: Macro.t()
+  def annotate_quoted(quoted, condition, caller) do
+    prelude =
+      quote do
+        [
+          env = unquote(Macro.escape(Macro.Env.prune_compile_info(caller))),
+          next? = unquote(condition)
+        ]
+      end
+
+    next_pry =
+      fn line, _version, _binding ->
+        quote do
+          next? = IEx.Pry.__next__(next?, binding(), %{env | line: unquote(line)})
+        end
+      end
+
+    annotate_quoted(quoted, prelude, caller.line, 0, :ok, fn _, _ -> :ok end, next_pry)
+  end
+
+  defp annotate_quoted(maybe_block, prelude, line, version, binding, next_binding, next_pry)
+       when is_list(prelude) do
+    exprs =
+      maybe_block
+      |> unwrap_block()
+      |> annotate_quoted(true, line, version, binding, {next_binding, next_pry})
+
+    {:__block__, [], prelude ++ exprs}
+  end
+
+  defp annotate_quoted([expr | exprs], force?, line, version, binding, funs) do
+    {next_binding, next_pry} = funs
+    new_binding = next_binding.(expr, binding)
+    {min_line, max_line} = line_range(expr, line)
+
+    if force? or min_line > line do
+      [
+        next_pry.(min_line, version, binding),
+        expr | annotate_quoted(exprs, false, max_line, version + 1, new_binding, funs)
+      ]
+    else
+      [expr | annotate_quoted(exprs, false, max_line, version, new_binding, funs)]
+    end
+  end
+
+  defp annotate_quoted([], _force?, _line, _version, _binding, _funs) do
+    []
+  end
+
+  @doc """
+  Formats the location for `whereami/3` prying.
+
+  It receives the `file`, `line` and the snippet `radius` and
+  returns `{:ok, lines}`, where lines is a list of chardata
+  containing each formatted line, or `:error`.
+
+  The actual line is especially formatted in bold.
+  """
+  @spec whereami(String.t(), non_neg_integer(), pos_integer()) :: {:ok, IO.chardata()} | :error
+  def whereami(file, line, radius)
+      when is_binary(file) and is_integer(line) and is_integer(radius) and radius > 0 do
+    with true <- File.regular?(file),
+         [_ | _] = lines <- whereami_lines(file, line, radius) do
+      {:ok, lines}
+    else
+      _ -> :error
+    end
+  end
+
+  defp whereami_lines(file, line, radius) do
+    min = max(line - radius - 1, 0)
+    max = line + radius - 1
+
+    file
+    |> File.stream!()
+    |> Enum.slice(min..max)
+    |> Enum.with_index(min + 1)
+    |> Enum.map(&whereami_format_line(&1, line))
+  end
+
+  defp whereami_format_line({line_text, line_number}, line) do
+    gutter = String.pad_leading(Integer.to_string(line_number), 5, " ")
+
+    if line_number == line do
+      IO.ANSI.format_fragment([:bright, gutter, ": ", line_text, :normal])
+    else
+      [gutter, ": ", line_text]
+    end
+  end
+
+  @doc """
+  Sets up a breakpoint on the given module/function/arity.
+  """
+  @spec break(module, atom, arity, non_neg_integer) :: {:ok, id()} | {:error, break_error()}
+  def break(module, function, arity, breaks \\ 1)
+      when is_atom(module) and is_atom(function) and arity in 0..255 and
+             is_integer(breaks) and breaks >= 0 do
+    break_call(module, function, arity, quote(do: _), breaks)
+  end
+
+  @doc """
+  Sets up a breakpoint on the given module/function/args with the given `guard`.
+
+  It requires an `env` to be given to make the expansion of the guards.
+  """
+  @spec break(module, atom, [Macro.t()], Macro.t(), Macro.Env.t(), non_neg_integer) ::
+          {:ok, id()} | {:error, break_error()}
+  def break(module, function, args, guard, env, breaks \\ 1)
+      when is_atom(module) and is_atom(function) and is_list(args) and is_integer(breaks) and
+             breaks >= 0 do
+    condition = build_args_guard_condition(args, guard, env)
+    break_call(module, function, length(args), condition, breaks)
+  end
+
+  defp break_call(module, function, arity, condition, breaks) do
+    GenServer.call(@server, {:break, module, {function, arity}, condition, breaks}, @timeout)
+  end
+
+  @doc """
+  Raising variant of `break/4`.
+  """
+  @spec break!(module, atom, arity, non_neg_integer) :: id()
+  def break!(module, function, arity, breaks \\ 1) do
+    break_call!(module, function, arity, quote(do: _), breaks)
+  end
+
+  @doc """
+  Raising variant of `break/6`.
+  """
+  @spec break!(module, atom, [Macro.t()], Macro.t(), Macro.Env.t(), non_neg_integer) :: id()
+  def break!(module, function, args, guard, env, breaks \\ 1)
+      when is_atom(module) and is_atom(function) and is_list(args) and is_integer(breaks) and
+             breaks >= 0 do
+    condition = build_args_guard_condition(args, guard, env)
+    break_call!(module, function, length(args), condition, breaks)
+  end
+
+  defp break_call!(module, function, arity, condition, breaks) do
+    case break_call(module, function, arity, condition, breaks) do
+      {:ok, id} ->
+        id
+
+      {:error, kind} ->
+        message =
+          case kind do
+            :missing_debug_info ->
+              "module #{inspect(module)} was not compiled with debug_info"
+
+            :no_beam_file ->
+              "could not find .beam file for #{inspect(module)}"
+
+            :non_elixir_module ->
+              "module #{inspect(module)} was not written in Elixir"
+
+            :outdated_debug_info ->
+              "module #{inspect(module)} was not compiled with the latest debug_info"
+
+            :recompilation_failed ->
+              "the module could not be compiled with breakpoints (likely an internal error)"
+
+            :unknown_function_arity ->
+              "unknown function/macro #{Exception.format_mfa(module, function, arity)}"
+          end
+
+        raise "could not set breakpoint, " <> message
+    end
+  end
+
+  defp build_args_guard_condition(args, guards, env) do
+    pattern = {:when, [], [{:{}, [], args}, guards]}
+
+    to_expand =
+      quote do
+        case Unknown.module() do
+          unquote(pattern) -> :ok
+        end
+      end
+
+    {{:case, _, [_, [do: [{:->, [], [[condition], _]}]]]}, _, _} =
+      :elixir_expand.expand(to_expand, :elixir_env.env_to_ex(env), env)
+
+    condition
+  end
+
+  @doc """
+  Resets the breaks on a given breakpoint ID.
+  """
+  @spec reset_break(id) :: :ok | :not_found
+  def reset_break(id) when is_integer(id) do
+    GenServer.call(@server, {:reset_break, {id, :_, :_, :_, :_}}, @timeout)
+  end
+
+  @doc """
+  Resets the breaks for the given `module`, `function` and `arity`.
+
+  If the `module` is not instrumented or if the given `function`
+  does not have a breakpoint, it is a no-op and it returns
+  `:not_found`. Otherwise it returns `:ok`.
+  """
+  @spec reset_break(module, atom, arity) :: :ok | :not_found
+  def reset_break(module, function, arity) do
+    GenServer.call(@server, {:reset_break, {:_, module, {function, arity}, :_, :_}}, @timeout)
+  end
+
+  @doc """
+  Removes all breakpoints on all modules.
+
+  This effectively loads the non-instrumented version of
+  currently instrumented modules into memory.
+  """
+  @spec remove_breaks :: :ok
+  def remove_breaks do
+    GenServer.call(@server, :remove_breaks, @timeout)
+  end
+
+  @doc """
+  Removes breakpoints in the given module.
+
+  This effectively loads the non-instrumented version of
+  the module into memory.
+  """
+  @spec remove_breaks(module) :: :ok | {:error, :no_beam_file}
+  def remove_breaks(module) do
+    GenServer.call(@server, {:remove_breaks, module}, @timeout)
+  end
+
+  @doc """
+  Returns all breakpoints.
+  """
+  @spec breaks :: [break]
+  def breaks do
+    @server
+    |> GenServer.call(:breaks, @timeout)
+    |> Enum.sort()
+  end
+
+  ## Callbacks
+
+  @doc false
+  def start_link(_) do
+    GenServer.start_link(__MODULE__, :ok, name: @server)
+  end
+
+  @impl true
+  def init(:ok) do
+    Process.flag(:trap_exit, true)
+    :ets.new(@table, [:named_table, :public, write_concurrency: true])
+    {:ok, @initial_counter}
+  end
+
+  @impl true
+  def handle_call({:break, module, fa, condition, breaks}, _from, counter) do
+    # If there is a match for the given module and fa, we
+    # use the ref, otherwise we create a new one.
+    {ref, counter} =
+      case :ets.match_object(@table, {:_, module, fa, :_, :_}) do
+        [{ref, _, _, _, _}] -> {ref, counter}
+        [] -> {counter, counter + 1}
+      end
+
+    case fetch_elixir_debug_info_with_fa_check(module, fa) do
+      {:ok, beam, backend, elixir} ->
+        true = :ets.insert(@table, {ref, module, fa, condition, breaks})
+        entries = :ets.match_object(@table, {:_, module, :_, :_, :_})
+        {:reply, instrument(beam, backend, elixir, ref, entries), counter}
+
+      {:error, _} = error ->
+        {:reply, error, counter}
+    end
+  end
+
+  def handle_call({:reset_break, pattern}, _from, counter) do
+    reset =
+      for {ref, module, fa, condition, _} <- :ets.match_object(@table, pattern) do
+        if instrumented?(module) do
+          :ets.insert(@table, {ref, module, fa, condition, 0})
+          true
+        else
+          :ets.delete(@table, ref)
+          false
+        end
+      end
+
+    if Enum.any?(reset) do
+      {:reply, :ok, counter}
+    else
+      {:reply, :not_found, counter}
+    end
+  end
+
+  def handle_call(:breaks, _from, counter) do
+    entries =
+      for {id, module, function_arity, _condition, breaks} <- :ets.tab2list(@table),
+          keep_instrumented(id, module) == :ok do
+        {id, module, function_arity, max(breaks, 0)}
+      end
+
+    {:reply, entries, counter}
+  end
+
+  def handle_call(:remove_breaks, _from, _counter) do
+    # Make sure to deinstrument before clearing
+    # up the table to avoid race conditions.
+    @table
+    |> :ets.match({:_, :"$1", :_, :_, :_})
+    |> List.flatten()
+    |> Enum.uniq()
+    |> Enum.each(&deinstrument_if_instrumented/1)
+
+    true = :ets.delete_all_objects(@table)
+    {:reply, :ok, @initial_counter}
+  end
+
+  def handle_call({:remove_breaks, module}, _from, counter) do
+    # Make sure to deinstrument before clearing
+    # up the table to avoid race conditions.
+    reply = deinstrument_if_instrumented(module)
+    true = :ets.match_delete(@table, {:_, module, :_, :_, :_})
+    {:reply, reply, counter}
+  end
+
+  defp keep_instrumented(id, module) do
+    if instrumented?(module) do
+      :ok
+    else
+      :ets.delete(@table, id)
+      :error
+    end
+  end
+
+  defp deinstrument_if_instrumented(module) do
+    if instrumented?(module) do
+      deinstrument(module)
+    else
+      :ok
+    end
+  end
+
+  defp deinstrument(module) do
+    with [_ | _] = beam <- :code.which(module),
+         {:ok, binary} <- File.read(beam) do
+      :code.purge(module)
+      {:module, _} = :code.load_binary(module, beam, binary)
+      :ok
+    else
+      _ -> {:error, :no_beam_file}
+    end
+  end
+
+  defp fetch_elixir_debug_info_with_fa_check(module, fa) do
+    case :code.which(module) do
+      [_ | _] = beam ->
+        case :beam_lib.chunks(beam, [:debug_info]) do
+          {:ok, {_, [debug_info: {:debug_info_v1, backend, {:elixir_v1, map, _} = elixir}]}} ->
+            case List.keyfind(map.definitions, fa, 0) do
+              {_, _, _, _} -> {:ok, beam, backend, elixir}
+              nil -> {:error, :unknown_function_arity}
+            end
+
+          {:ok, {_, [debug_info: {:debug_info_v1, _, _}]}} ->
+            {:error, :non_elixir_module}
+
+          {:error, :beam_lib, {:missing_chunk, _, _}} ->
+            {:error, :missing_debug_info}
+
+          _ ->
+            {:error, :outdated_debug_info}
+        end
+
+      _ ->
+        {:error, :no_beam_file}
+    end
+  end
+
+  defp instrument(beam, backend, {:elixir_v1, map, specs}, counter, entries) do
+    %{attributes: attributes, definitions: definitions, module: module} = map
+
+    attributes = [{:iex_pry, true} | attributes]
+    definitions = Enum.map(definitions, &instrument_definition(&1, map, entries))
+    map = %{map | attributes: attributes, definitions: definitions}
+
+    with {:ok, forms} <- backend.debug_info(:erlang_v1, module, {:elixir_v1, map, specs}, []),
+         {:ok, _, binary, _} <- :compile.noenv_forms(forms, [:return | map.compile_opts]) do
+      :code.purge(module)
+      {:module, _} = :code.load_binary(module, beam, binary)
+      {:ok, counter}
+    else
+      _error ->
+        {:error, :recompilation_failed}
+    end
+  end
+
+  defp instrument_definition({fa, kind, meta, clauses} = definition, map, entries) do
+    case List.keyfind(entries, fa, 2) do
+      {ref, _, ^fa, condition, _} ->
+        %{module: module, file: file} = map
+
+        file =
+          case meta[:location] do
+            {file, _} -> file
+            _ -> file
+          end
+
+        opts = [module: module, file: file, function: fa]
+        clauses = Enum.map(clauses, &instrument_clause(&1, ref, condition, opts))
+        {fa, kind, meta, clauses}
+
+      nil ->
+        definition
+    end
+  end
+
+  defp instrument_clause({meta, args, guards, clause}, ref, case_pattern, opts) do
+    arity = length(args)
+
+    # Have an extra binding per argument for case matching.
+    case_vars =
+      for id <- 1..arity//1 do
+        {String.to_atom("arg" <> Integer.to_string(id)), [version: -id], __MODULE__}
+      end
+
+    case_head = {:{}, [], case_vars}
+    update_op = Macro.escape({5, -1, -1, -1})
+
+    # Generate the take_over condition with the ETS lookup.
+    # Remember this is expanded AST, so no aliases allowed,
+    # no locals (such as the unary -) and so on.
+    prelude =
+      quote do
+        [
+          unquote(next_var(arity + 1)) = unquote(opts),
+          unquote(next_var(arity + 2)) =
+            case unquote(case_head) do
+              unquote(case_pattern) ->
+                :erlang."/="(
+                  # :ets.update_counter(table, key, {pos, inc, threshold, reset})
+                  :ets.update_counter(unquote(@table), unquote(ref), unquote(update_op)),
+                  unquote(-1)
+                )
+
+              _ ->
+                false
+            end
+        ]
+      end
+
+    args =
+      case_vars
+      |> Enum.zip(args)
+      |> Enum.map(fn {var, arg} -> {:=, [], [arg, var]} end)
+
+    version = arity + 2
+    binding = match_binding(args, %{})
+    line = Keyword.get(meta, :line, 1)
+    env_var = next_var(arity + 1)
+
+    clause =
+      annotate_quoted(clause, prelude, line, version, binding, &next_binding/2, fn
+        line, version, binding ->
+          quote do
+            unquote(next_var(version + 1)) =
+              :"Elixir.IEx.Pry".__next__(
+                unquote(next_var(version)),
+                unquote(Map.to_list(binding)),
+                [{:line, unquote(line)} | unquote(env_var)]
+              )
+          end
+      end)
+
+    {meta, args, guards, clause}
+  end
+
+  defp line_range(ast, line) do
+    # We want min_line to start from infinity because
+    # if it starts from line it will always just return line.
+    {_, {min, max}} =
+      Macro.prewalk(ast, {:infinity, line}, fn
+        {_, meta, _} = ast, {min_line, max_line} when is_list(meta) ->
+          case Keyword.fetch(meta, :line) do
+            {:ok, line} when line > 0 ->
+              {ast, {min(line, min_line), max(line, max_line)}}
+
+            _ ->
+              {ast, {min_line, max_line}}
+          end
+
+        ast, acc ->
+          {ast, acc}
+      end)
+
+    if min == :infinity, do: {line, max}, else: {min, max}
+  end
+
+  defp next_binding(ast, binding) do
+    {_, binding} =
+      Macro.prewalk(ast, binding, fn
+        {:=, _, [left, _right]}, acc ->
+          {:ok, match_binding(left, acc)}
+
+        {:case, _, [arg, _block]}, acc ->
+          {arg, acc}
+
+        {special_form, _, _}, acc
+        when special_form in [:cond, :fn, :for, :receive, :try, :with] ->
+          {:ok, acc}
+
+        expr, acc ->
+          {expr, acc}
+      end)
+
+    binding
+  end
+
+  defp match_binding(match, binding) do
+    {_, binding} =
+      Macro.prewalk(match, binding, fn
+        {name, _, nil} = var, acc when name != :_ and is_atom(name) ->
+          {var, Map.put(acc, name, var)}
+
+        # Stop traversing inside pin operators and :: in binaries
+        {special_form, _, _}, acc when special_form in [:^, :"::"] ->
+          {:ok, acc}
+
+        expr, acc ->
+          {expr, acc}
+      end)
+
+    binding
+  end
+
+  defp next_var(id) do
+    {:next?, [version: -id], __MODULE__}
+  end
+
+  defp instrumented?(module) do
+    module.__info__(:attributes)[:iex_pry] == [true]
+  end
+
+  defp unwrap_block(expr), do: expr |> unwrap_block([]) |> Enum.reverse()
+  defp unwrap_block({:__block__, _, exprs}, acc), do: Enum.reduce(exprs, acc, &unwrap_block/2)
+  defp unwrap_block(expr, acc), do: [expr | acc]
+
+  # IEx backend for Kernel.dbg/2.
+  @doc false
+  def dbg(ast, options, env)
+
+  def dbg({:|>, _meta, _args} = ast, options, %Macro.Env{} = env) when is_list(options) do
+    [first_ast_chunk | asts_chunks] = ast |> Macro.unpipe() |> chunk_pipeline_asts_by_line(env)
+
+    {first_line, _max_line} = line_range(ast, env.line)
+
+    prelude =
+      quote do
+        options = unquote(options)
+
+        options =
+          if IO.ANSI.enabled?() do
+            Keyword.put_new(options, :syntax_colors, IO.ANSI.syntax_colors())
+          else
+            options
+          end
+
+        value = unquote(pipe_chunk_of_asts(first_ast_chunk))
+
+        IEx.Pry.__dbg_pipe_step__(
+          value,
+          unquote(asts_chunk_to_strings(first_ast_chunk)),
+          _start_with_pipe? = false,
+          options
+        )
+      end
+
+    main_block =
+      for asts_chunk <- asts_chunks do
+        piped_asts = pipe_chunk_of_asts([{quote(do: value), _index = 0}] ++ asts_chunk)
+
+        quote do
+          value = unquote(piped_asts)
+
+          IEx.Pry.__dbg_pipe_step__(
+            value,
+            unquote(asts_chunk_to_strings(asts_chunk)),
+            _start_with_pipe? = true,
+            options
+          )
+        end
+      end
+
+    annotate_quoted({:__block__, [], [prelude | main_block]}, true, %{env | line: first_line})
+  end
+
+  def dbg(ast, options, %Macro.Env{} = env) when is_list(options) do
+    options = Keyword.put(options, :print_location, false)
+
+    quote do
+      IEx.Pry.pry(binding(), __ENV__)
+      unquote(Macro.dbg(ast, options, env))
+    end
+  end
+
+  # Made public to be called from IEx.Pry.dbg/3 to reduce the amount of generated code.
+  @doc false
+  def __dbg_pipe_step__(value, string_asts, start_with_pipe?, options) do
+    asts_string = Enum.intersperse(string_asts, [:faint, " |> ", :reset])
+
+    asts_string =
+      if start_with_pipe? do
+        IO.ANSI.format([:faint, "|> ", :reset, asts_string])
+      else
+        asts_string
+      end
+
+    [asts_string, :faint, " #=> ", :reset, inspect(value, options), "\n\n"]
+    |> IO.ANSI.format()
+    |> IO.write()
+
+    value
+  end
+
+  defp chunk_pipeline_asts_by_line(asts, %Macro.Env{line: env_line}) do
+    Enum.chunk_by(asts, fn
+      {{_fun_or_var, meta, _args}, _pipe_index} -> meta[:line] || env_line
+      {_other_ast, _pipe_index} -> env_line
+    end)
+  end
+
+  defp pipe_chunk_of_asts([{first_ast, _first_index} | asts] = _ast_chunk) do
+    Enum.reduce(asts, first_ast, fn {ast, index}, acc -> Macro.pipe(acc, ast, index) end)
+  end
+
+  defp asts_chunk_to_strings(asts) do
+    Enum.map(asts, fn {ast, _pipe_index} -> Macro.to_string(ast) end)
+  end
+end
diff --git a/lib/iex/lib/iex/remsh.ex b/lib/iex/lib/iex/remsh.ex
deleted file mode 100644
index 59e83340dd8..00000000000
--- a/lib/iex/lib/iex/remsh.ex
+++ /dev/null
@@ -1,16 +0,0 @@
-defmodule IEx.Remsh do
-  @moduledoc false
-
-  @doc """
-  Provides one helper function that is injected into connecting
-  remote nodes to properly handle autocompletion.
-  """
-  def expand(node) do
-    fn e ->
-      case :rpc.call node, IEx.Autocomplete, :expand, [e] do
-        {:badrpc, _} -> {:no, '', []}
-        r -> r
-      end
-    end
-  end
-end
diff --git a/lib/iex/lib/iex/server.ex b/lib/iex/lib/iex/server.ex
index 071a0e61820..ff28bde7a8d 100644
--- a/lib/iex/lib/iex/server.ex
+++ b/lib/iex/lib/iex/server.ex
@@ -1,287 +1,428 @@
-defmodule IEx.Config do
-  @moduledoc false
-  defstruct binding: nil, cache: '', counter: 1, prefix: "iex", scope: nil, env: nil
-end
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
 defmodule IEx.Server do
-  @moduledoc false
+  @moduledoc """
+  The IEx.Server.
 
-  @doc """
-  Finds where the current IEx server is located.
-  """
-  @spec whereis :: pid | nil
-  def whereis() do
-    # Locate top group leader, always registered as user
-    # can be implemented by group (normally) or user
-    # (if oldshell or noshell)
-    if user = Process.whereis(:user) do
-      case :group.interfaces(user) do
-        [] -> # Old or no shell
-          case :user.interfaces(user) do
-            [] -> nil
-            [shell: shell] -> shell
-          end
-        [user_drv: user_drv] -> # Get current group from user_drv
-          case :user_drv.interfaces(user_drv) do
-            [] -> nil
-            [current_group: group] -> :group.interfaces(group)[:shell]
-          end
-      end
-    end
-  end
+  The server responsibilities include:
+
+    * reading input from the group leader and writing to the group leader
+    * sending messages to the evaluator
+    * taking over the evaluator process when using `IEx.pry/0` or setting up breakpoints
 
-  @doc """
-  Requests to take over the given shell from the
-  current process.
   """
-  @spec take_over(binary, Keyword.t, pos_integer) ::
-        :ok | {:error, :no_iex} | {:error, :refused}
-  def take_over(identifier, opts, timeout \\ 1000, server \\ whereis()) do
-    cond do
-      nil?(server) ->
-        {:error, :no_iex}
-      true ->
-        ref = make_ref()
-        send server, {:take?, self, ref}
-
-        receive do
-          ^ref ->
-            opts = [evaluator: self] ++ opts
-            send server, {:take, self, identifier, ref, opts}
-
-            receive do
-              {^ref, nil} ->
-                {:error, :refused}
-              {^ref, leader} ->
-                IEx.Evaluator.start(server, leader)
-            end
-        after
-          timeout ->
-            {:error, :no_iex}
-        end
-    end
-  end
+
+  @type run_opts :: [
+          prefix: String.t(),
+          env: Macro.Env.t(),
+          binding: keyword(),
+          on_eof: :stop_evaluator | :halt,
+          register: boolean()
+        ]
+
+  @doc false
+  defstruct parser_state: [],
+            counter: 1,
+            prefix: "iex",
+            on_eof: :stop_evaluator,
+            evaluator_options: [],
+            expand_fun: nil
 
   @doc """
-  Starts IEx by executing a given callback and spawning
-  the server only after the callback is done.
+  Starts a new IEx server session.
 
-  The server responsibilities include:
+  The accepted options are:
 
-    * reading input
-    * sending messages to the evaluator
-    * handling takeover process of the evaluator
+    * `:prefix` - the IEx prefix
+    * `:env` - the `Macro.Env` used for the evaluator
+    * `:binding` - an initial set of variables for the evaluator
+    * `:on_eof` - if it should `:stop_evaluator` (default) or `:halt` the system
+    * `:register` - if this shell should be registered in the broker (default is `true`)
 
-  If there is any takeover during the callback execution
-  we spawn a new server for it without waiting for its
-  conclusion.
   """
-  @spec start(list, mfa) :: :ok
-  def start(opts, {m, f, a}) do
+  @doc since: "1.8.0"
+  @spec run(run_opts) :: :ok
+  def run(opts) when is_list(opts) do
+    if Keyword.get(opts, :register, true) do
+      IEx.Broker.register(self())
+    end
+
+    run_without_registration(init_state(opts), opts, nil)
+  end
+
+  ## Private APIs
+
+  # Starts IEx to run directly from the Erlang shell.
+  #
+  # The server is spawned only after the callback is done.
+  #
+  # If there is any takeover during the callback execution
+  # we spawn a new server for it without waiting for its
+  # conclusion.
+  @doc false
+  @spec run_from_shell(keyword, {module, atom, [any]}) :: :ok
+  def run_from_shell(opts, {m, f, a}) do
+    opts[:register] && IEx.Broker.register(self())
+    Process.flag(:trap_exit, true)
     {pid, ref} = spawn_monitor(m, f, a)
-    start_loop(opts, pid, ref)
+    shell_loop(opts, pid, ref)
   end
 
-  defp start_loop(opts, pid, ref) do
+  defp shell_loop(opts, pid, ref) do
     receive do
-      {:take?, other, ref} ->
-        send(other, ref)
-        start_loop(opts, pid, ref)
-
-      {:take, other, identifier, ref, opts} ->
-        if allow_take?(identifier) do
-          send(other, {ref, Process.group_leader})
-          run(opts)
+      {:take_over, take_pid, take_ref, take_location, take_whereami, take_opts} ->
+        IO.puts(IEx.color(:eval_interrupt, "Break reached: #{take_location}#{take_whereami}"))
+
+        if take_over?(take_pid, take_ref, 1, true) do
+          run_without_registration(init_state(opts), take_opts, nil)
         else
-          send(other, {ref, nil})
-          start_loop(opts, pid, ref)
+          shell_loop(opts, pid, ref)
         end
 
-      {:DOWN, ^ref, :process, ^pid,  :normal} ->
-        run(opts)
+      {:DOWN, ^ref, :process, ^pid, :normal} ->
+        run_without_registration(init_state(opts), opts, nil)
 
-      {:DOWN, ^ref, :process, ^pid,  _reason} ->
+      {:DOWN, ^ref, :process, ^pid, _reason} ->
         :ok
     end
   end
 
-  # Run loop: this is where the work is really
-  # done after the start loop.
+  # Since we want to register only once, this function is the
+  # reentrant point for starting a new shell (instead of run/run_from_shell).
+  defp run_without_registration(state, opts, input) do
+    Process.flag(:trap_exit, true)
+    Process.link(Process.group_leader())
 
-  defp run(opts) when is_list(opts) do
-    IO.puts "Interactive Elixir (#{System.version}) - press Ctrl+C to exit (type h() ENTER for help)"
-    self_pid    = self
-    self_leader = Process.group_leader
-    evaluator   = opts[:evaluator] || spawn(fn -> IEx.Evaluator.start(self_pid, self_leader) end)
-    Process.put(:evaluator, evaluator)
-    loop(run_config(opts), evaluator, Process.monitor(evaluator))
+    IO.puts(
+      "Interactive Elixir (#{System.version()}) - press Ctrl+C to exit (type h() ENTER for help)"
+    )
+
+    evaluator = start_evaluator(state.counter, Keyword.merge(state.evaluator_options, opts))
+    loop(state, evaluator, Process.monitor(evaluator), input)
   end
 
-  defp reset_loop(opts, evaluator, evaluator_ref) do
-    IO.puts("")
-    # We only kill the evaluator if the new evaluator
-    # is not the same as the current one. Otherwise
-    # we end up killing the process that is taking over.
-    exit_loop(evaluator, evaluator_ref, opts[:evaluator] != evaluator)
-    run(opts)
+  # Starts an evaluator using the provided options.
+  # Made public but undocumented for testing.
+  @doc false
+  def start_evaluator(counter, opts) do
+    args = [:ack, self(), Process.group_leader(), counter, opts]
+    evaluator = opts[:evaluator] || :proc_lib.start(IEx.Evaluator, :init, args)
+    Process.put(:evaluator, evaluator)
+    evaluator
   end
 
-  defp exit_loop(evaluator, evaluator_ref, done? \\ true) do
+  ## Helpers
+
+  defp stop_evaluator(evaluator, evaluator_ref) do
     Process.delete(:evaluator)
     Process.demonitor(evaluator_ref, [:flush])
-    if done? do
-      send(evaluator, {:done, self})
-    end
+    send(evaluator, {:done, self(), false})
     :ok
   end
 
-  defp loop(config, evaluator, evaluator_ref) do
-    self_pid = self()
-    counter  = config.counter
-    prefix   = if config.cache != [], do: "...", else: config.prefix
+  defp rerun(state, opts, evaluator, evaluator_ref, input) do
+    IO.puts("")
+    stop_evaluator(evaluator, evaluator_ref)
+    state = reset_state(state)
+    run_without_registration(state, opts, input)
+  end
+
+  defp loop(state, evaluator, evaluator_ref, input) do
+    %{counter: counter, expand_fun: expand_fun, prefix: prefix, parser_state: parser} = state
+    :io.setopts(expand_fun: expand_fun)
+    input = input || io_get(prompt(prefix, counter), counter, parser)
+    wait_input(state, evaluator, evaluator_ref, input)
+  end
+
+  defp wait_input(state, evaluator, evaluator_ref, input) do
+    receive do
+      {:io_reply, ^input, {:ok, code, parser_state}} ->
+        :io.setopts(expand_fun: fn _ -> {:yes, [], []} end)
+        send(evaluator, {:eval, self(), code, state.counter})
+        wait_eval(%{state | parser_state: parser_state}, evaluator, evaluator_ref)
+
+      {:io_reply, ^input, :eof} ->
+        case state.on_eof do
+          :halt -> System.halt(0)
+          :stop_evaluator -> stop_evaluator(evaluator, evaluator_ref)
+        end
+
+      {:io_reply, ^input, {:error, kind, error, stacktrace}} ->
+        send(evaluator, {:reader_errored, self()})
+
+        banner = Exception.format_banner(kind, error, stacktrace)
 
-    input = spawn(fn -> io_get(self_pid, prefix, counter) end)
-    wait_input(config, evaluator, evaluator_ref, input)
+        banner =
+          if String.contains?(banner, IO.ANSI.reset()) do
+            banner
+          else
+            IEx.color(:eval_error, banner)
+          end
+
+        stackdata = Exception.format_stacktrace(stacktrace)
+        IO.write(:stdio, [banner, ?\n, IEx.color(:stack_info, stackdata)])
+        loop(%{state | parser_state: []}, evaluator, evaluator_ref, nil)
+
+      # Triggered by pressing "i" as the job control switch
+      {:io_reply, ^input, {:error, :interrupted}} ->
+        io_error("** (EXIT) interrupted")
+        loop(%{state | parser_state: []}, evaluator, evaluator_ref, nil)
+
+      # Unknown IO message
+      {:io_reply, ^input, msg} ->
+        io_error("** (EXIT) unknown IO message: #{inspect(msg)}")
+        loop(%{state | parser_state: []}, evaluator, evaluator_ref, nil)
+
+      # Triggered when IO dies while waiting for input
+      {:DOWN, ^input, _, _, _} ->
+        stop_evaluator(evaluator, evaluator_ref)
+
+      msg ->
+        handle_common(msg, state, evaluator, evaluator_ref, input, fn state ->
+          wait_input(state, evaluator, evaluator_ref, input)
+        end)
+    end
   end
 
-  defp wait_input(config, evaluator, evaluator_ref, input) do
+  defp wait_eval(state, evaluator, evaluator_ref) do
     receive do
-      {:input, ^input, code} when is_binary(code) ->
-        send evaluator, {:eval, self, code, config}
-        wait_eval(evaluator, evaluator_ref)
-      {:input, ^input, {:error, :interrupted}} ->
-        io_error "** (EXIT) interrupted"
-        loop(%{config | cache: ''}, evaluator, evaluator_ref)
-      {:input, ^input, :eof} ->
-        exit_loop(evaluator, evaluator_ref)
-      {:input, ^input, {:error, :terminated}} ->
-        exit_loop(evaluator, evaluator_ref)
+      {:evaled, ^evaluator, status} ->
+        counter = if(status == :ok, do: state.counter + 1, else: state.counter)
+        state = %{state | counter: counter}
+        loop(state, evaluator, evaluator_ref, nil)
 
       msg ->
-        handle_take_over(msg, evaluator, evaluator_ref, input, fn ->
-          wait_input(config, evaluator, evaluator_ref, input)
+        handle_common(msg, state, evaluator, evaluator_ref, nil, fn state ->
+          wait_eval(state, evaluator, evaluator_ref)
         end)
     end
   end
 
-  defp wait_eval(evaluator, evaluator_ref) do
+  defp wait_common(state, evaluator, evaluator_ref, input) do
     receive do
-      {:evaled, ^evaluator, config} ->
-        loop(config, evaluator, evaluator_ref)
       msg ->
-        handle_take_over(msg, evaluator, evaluator_ref, nil,
-                         fn -> wait_eval(evaluator, evaluator_ref) end)
+        handle_common(msg, state, evaluator, evaluator_ref, input, fn state ->
+          wait_common(state, evaluator, evaluator_ref, input)
+        end)
     end
   end
 
   # Take process.
   #
-  # The take? message is received out of band, so we can
-  # go back to wait for the same input. The take message
-  # needs to take hold of the IO, so it kills the input,
-  # re-runs the server OR goes back to the main loop.
-  #
   # A take process may also happen if the evaluator dies,
-  # then a new evaluator is created to tackle replace the dead
-  # one.
-  defp handle_take_over({:take?, other, ref}, _evaluator, _evaluator_ref, _input, callback) do
-    send(other, ref)
-    callback.()
+  # then a new evaluator is created to replace the dead one.
+  defp handle_common(
+         {:take_over, take_pid, take_ref, take_location, take_whereami, take_opts},
+         state,
+         evaluator,
+         evaluator_ref,
+         input,
+         callback
+       ) do
+    cond do
+      evaluator == take_opts[:evaluator] ->
+        IO.puts(IEx.color(:eval_interrupt, "Break reached: #{take_location}#{take_whereami}"))
+
+        if take_over?(take_pid, take_ref, state.counter + 1, true) do
+          # Since we are in process, also bump the counter
+          state = reset_state(bump_counter(state))
+          loop(state, evaluator, evaluator_ref, input)
+        else
+          callback.(state)
+        end
+
+      take_over?(take_pid, take_ref, take_location, take_whereami, take_opts, state.counter) ->
+        rerun(state, take_opts, evaluator, evaluator_ref, input)
+
+      true ->
+        callback.(state)
+    end
   end
 
-  defp handle_take_over({:take, other, identifier, ref, opts}, evaluator, evaluator_ref, input, callback) do
-    kill_input(input)
+  # User did ^G while the evaluator was busy or stuck
+  defp handle_common(
+         {:EXIT, _pid, :interrupt},
+         state,
+         evaluator,
+         evaluator_ref,
+         input,
+         _callback
+       ) do
+    io_error("** (EXIT) interrupted")
+    Process.exit(evaluator, :kill)
+    rerun(state, [], evaluator, evaluator_ref, input)
+  end
 
-    if allow_take?(identifier) do
-      send other, {ref, Process.group_leader}
-      reset_loop(opts, evaluator, evaluator_ref)
+  defp handle_common(
+         {:EXIT, pid, reason},
+         state,
+         evaluator,
+         evaluator_ref,
+         _input,
+         callback
+       ) do
+    if pid == Process.group_leader() do
+      stop_evaluator(evaluator, evaluator_ref)
+      exit(reason)
     else
-      send other, {ref, nil}
-      callback.()
+      callback.(state)
     end
   end
 
-  defp handle_take_over({:respawn, evaluator}, evaluator, evaluator_ref, input, _callback) do
-    kill_input(input)
-    reset_loop([], evaluator, evaluator_ref)
+  defp handle_common({:respawn, evaluator}, state, evaluator, evaluator_ref, input, _callback) do
+    rerun(bump_counter(state), [], evaluator, evaluator_ref, input)
+  end
+
+  defp handle_common(
+         {:continue, evaluator, next?},
+         state,
+         evaluator,
+         evaluator_ref,
+         input,
+         _callback
+       ) do
+    send(evaluator, {:done, self(), next?})
+    wait_common(state, evaluator, evaluator_ref, input)
   end
 
-  defp handle_take_over({:DOWN, evaluator_ref, :process, evaluator,  reason},
-                        evaluator, evaluator_ref, input, _callback) do
+  defp handle_common(
+         {:DOWN, evaluator_ref, :process, evaluator, reason},
+         state,
+         evaluator,
+         evaluator_ref,
+         input,
+         _callback
+       ) do
     try do
-      io_error Exception.format_banner({:EXIT, evaluator}, reason)
+      io_error(
+        "** (EXIT from #{inspect(evaluator)}) shell process exited with reason: " <>
+          Exception.format_exit(reason)
+      )
     catch
       type, detail ->
-        io_error "** (IEx.Error) #{type} when printing EXIT message: #{inspect detail}"
+        io_error("** (IEx.Error) #{type} when printing EXIT message: #{inspect(detail)}")
     end
-    kill_input(input)
-    reset_loop([], evaluator, evaluator_ref)
+
+    rerun(state, [], evaluator, evaluator_ref, input)
+  end
+
+  defp handle_common(_, state, _evaluator, _evaluator_ref, _input, callback) do
+    callback.(state)
   end
 
-  defp handle_take_over(_, _evaluator, _evaluator_ref, _input, callback) do
-    callback.()
+  defp take_over?(take_pid, take_ref, take_location, take_whereami, take_opts, counter) do
+    evaluator = take_opts[:evaluator] || self()
+    message = "Request to pry #{inspect(evaluator)} at #{take_location}#{take_whereami}"
+    interrupt = IEx.color(:eval_interrupt, "#{message}\nAllow? [Yn] ")
+    answer = yes?(IO.gets(:stdio, interrupt))
+    take_over?(take_pid, take_ref, counter, answer)
   end
 
-  defp kill_input(nil),   do: :ok
-  defp kill_input(input), do: Process.exit(input, :kill)
+  defp take_over?(take_pid, take_ref, counter, response) when is_boolean(response) do
+    case IEx.Broker.respond(take_pid, take_ref, counter, response) do
+      :ok ->
+        true
 
-  defp allow_take?(identifier) do
-    message = IEx.color(:eval_interrupt, "#{identifier}. Allow? [Yn] ")
-    IO.gets(:stdio, message) =~ ~r/^(Y(es)?)?$/i
+      {:error, :refused} ->
+        false
+
+      {:error, :already_accepted} ->
+        io_error("** session was already accepted elsewhere")
+        false
+    end
   end
 
-  ## Config
+  defp yes?(string) when is_binary(string),
+    do: String.trim(string) in ["", "y", "Y", "yes", "YES", "Yes"]
+
+  defp yes?(charlist) when is_list(charlist),
+    do: yes?(List.to_string(charlist))
 
-  defp run_config(opts) do
-    locals = Keyword.get(opts, :delegate_locals_to, IEx.Helpers)
+  defp yes?(_), do: false
 
-    env =
-      if env = opts[:env] do
-        :elixir.env_for_eval(env, delegate_locals_to: locals)
+  ## State
+
+  defp init_state(opts) do
+    prefix = Keyword.get(opts, :prefix, "iex")
+    on_eof = Keyword.get(opts, :on_eof, :stop_evaluator)
+    gl = Process.group_leader()
+
+    expand_fun =
+      if node(gl) != node() do
+        IEx.Autocomplete.remsh(node())
       else
-        :elixir.env_for_eval(file: "iex", delegate_locals_to: locals)
+        &IEx.Autocomplete.expand/1
       end
 
-    {_, _, env, scope} = :elixir.eval('require IEx.Helpers', [], env)
+    %IEx.Server{
+      prefix: prefix,
+      on_eof: on_eof,
+      expand_fun: expand_fun,
+      evaluator_options: Keyword.take(opts, [:dot_iex])
+    }
+  end
 
-    binding = Keyword.get(opts, :binding, [])
-    prefix  = Keyword.get(opts, :prefix, "iex")
-    config  = %IEx.Config{binding: binding, scope: scope, prefix: prefix, env: env}
+  # For the state, reset only reset the parser state.
+  # The counter will continue going up as the input process is shared.
+  # The opts can also set "dot_iex" and the "evaluator" itself,
+  # but those are not stored: they are temporary to whatever is rerunning.
+  # Once the rerunning session restarts, we keep the same evaluator_options
+  # and rollback to a new evaluator.
+  defp reset_state(state) do
+    %{state | parser_state: []}
+  end
 
-    case opts[:dot_iex_path] do
-      ""   -> config
-      path -> IEx.Evaluator.load_dot_iex(config, path)
-    end
+  defp bump_counter(state) do
+    update_in(state.counter, &(&1 + 1))
   end
 
   ## IO
 
-  defp io_get(pid, prefix, counter) do
-    prompt = prompt(prefix, counter)
-    send pid, {:input, self, IO.gets(:stdio, prompt)}
+  defp io_get(prompt, counter, parser_state) do
+    gl = Process.group_leader()
+    ref = Process.monitor(gl)
+    command = {:get_until, :unicode, prompt, __MODULE__, :__parse__, [{counter, parser_state}]}
+    send(gl, {:io_request, self(), ref, command})
+    ref
+  end
+
+  @doc false
+  def __parse__(_, :eof, _parser_state), do: {:done, :eof, []}
+
+  def __parse__([], chars, {counter, parser_state} = to_be_unused) do
+    __parse__({counter, parser_state, IEx.Config.parser()}, chars, to_be_unused)
+  end
+
+  def __parse__({counter, parser_state, mfa}, chars, _unused) do
+    {parser_module, parser_fun, args} = mfa
+    args = [chars, [line: counter, file: "iex"], parser_state | args]
+
+    case apply(parser_module, parser_fun, args) do
+      {:ok, forms, parser_state} -> {:done, {:ok, forms, parser_state}, []}
+      {:incomplete, parser_state} -> {:more, {counter, parser_state, mfa}}
+    end
+  catch
+    kind, error ->
+      {:done, {:error, kind, error, __STACKTRACE__}, []}
   end
 
   defp prompt(prefix, counter) do
-    {mode, prefix} =
-      if Node.alive? do
-        {:alive, prefix || remote_prefix}
+    prompt =
+      if Node.alive?() do
+        IEx.Config.alive_prompt()
       else
-        {:default, prefix || "iex"}
+        IEx.Config.default_prompt()
       end
+      |> String.replace("%counter", to_string(counter))
+      |> String.replace("%prefix", to_string(prefix))
+      |> String.replace("%node", to_string(node()))
 
-    prompt = Application.get_env(:iex, :"#{mode}_prompt")
-             |> String.replace("%counter", to_string(counter))
-             |> String.replace("%prefix", to_string(prefix))
-             |> String.replace("%node", to_string(node))
-
-    prompt <> " "
+    [prompt, " "]
   end
 
   defp io_error(result) do
-    IO.puts :stdio, IEx.color(:eval_error, result)
-  end
-
-  defp remote_prefix do
-    if node == node(Process.group_leader), do: "iex", else: "rem"
+    IO.puts(:stdio, IEx.color(:eval_error, result))
   end
 end
diff --git a/lib/iex/mix.exs b/lib/iex/mix.exs
index 456337be90e..4867ba3ddf3 100644
--- a/lib/iex/mix.exs
+++ b/lib/iex/mix.exs
@@ -1,19 +1,30 @@
-defmodule IEx.Mixfile do
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule IEx.MixProject do
   use Mix.Project
 
   def project do
-    [app: :iex,
-     version: System.version,
-     build_per_environment: false]
+    [
+      app: :iex,
+      version: System.version(),
+      build_per_environment: false
+    ]
   end
 
   def application do
-    [env: [
-       after_spawn: [],
-       colors: [],
-       inspect: [],
-       history_size: 20,
-       default_prompt: "%prefix(%counter)>",
-       alive_prompt: "%prefix(%node)%counter>"]]
+    [
+      registered: [IEx.Broker, IEx.Config, IEx.Pry, IEx.Supervisor],
+      mod: {IEx.App, []},
+      env: [
+        colors: [],
+        inspect: [pretty: true],
+        history_size: 20,
+        default_prompt: "%prefix(%counter)>",
+        alive_prompt: "%prefix(%node)%counter>",
+        auto_reload: false
+      ]
+    ]
   end
 end
diff --git a/lib/iex/test/iex/autocomplete_test.exs b/lib/iex/test/iex/autocomplete_test.exs
index ad4f30f6b78..39d454f50ef 100644
--- a/lib/iex/test/iex/autocomplete_test.exs
+++ b/lib/iex/test/iex/autocomplete_test.exs
@@ -1,98 +1,607 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule IEx.AutocompleteTest do
   use ExUnit.Case, async: true
 
-  def expand(expr) do
-    IEx.Autocomplete.expand(Enum.reverse expr)
+  setup do
+    evaluator = IEx.Server.start_evaluator(1, [])
+    Process.put(:evaluator, evaluator)
+    :ok
+  end
+
+  defp eval(line) do
+    ExUnit.CaptureIO.capture_io(fn ->
+      evaluator = Process.get(:evaluator)
+      Process.group_leader(evaluator, Process.group_leader())
+      send(evaluator, {:eval, self(), Code.string_to_quoted!(line <> "\n"), 1})
+      assert_receive {:evaled, _, _}
+    end)
+  end
+
+  defp expand(expr) do
+    IEx.Autocomplete.expand(Enum.reverse(expr), self())
+  end
+
+  test "Erlang module completion" do
+    assert expand(~c":zl") == {:yes, ~c"ib", []}
+  end
+
+  test "Erlang module no completion" do
+    assert expand(~c":unknown") == {:no, ~c"", []}
+  end
+
+  test "Erlang module multiple values completion" do
+    {:yes, ~c"", list} = expand(~c":logger")
+    assert ~c"logger" in list
+    assert ~c"logger_proxy" in list
+  end
+
+  test "Erlang root completion" do
+    {:yes, ~c"", list} = expand(~c":")
+    assert is_list(list)
+    assert ~c"lists" in list
+    assert ~c"Elixir.List" not in list
+  end
+
+  test "Elixir proxy" do
+    {:yes, ~c"", list} = expand(~c"E")
+    assert ~c"Elixir" in list
+  end
+
+  test "Elixir completion" do
+    assert expand(~c"En") == {:yes, ~c"um", []}
+    assert expand(~c"Enumera") == {:yes, ~c"ble", []}
   end
 
-  test :erlang_module_simple_completion do
-    assert expand(':z') == {:yes, 'lib.', []}
+  test "Elixir type completion" do
+    assert expand(~c"t :gen_ser") == {:yes, ~c"ver", []}
+    assert expand(~c"t String") == {:yes, ~c"", [~c"String", ~c"StringIO"]}
+
+    assert expand(~c"t String.") ==
+             {:yes, ~c"",
+              [
+                ~c"codepoint/0",
+                ~c"grapheme/0",
+                ~c"pattern/0",
+                ~c"replace_opts/0",
+                ~c"split_opts/0",
+                ~c"splitter_opts/0",
+                ~c"t/0"
+              ]}
+
+    assert expand(~c"t String.grap") == {:yes, ~c"heme", []}
+    assert expand(~c"t  String.grap") == {:yes, ~c"heme", []}
+    assert {:yes, ~c"", [~c"date_time/0" | _]} = expand(~c"t :file.")
+    assert expand(~c"t :file.n") == {:yes, ~c"ame", []}
   end
 
-  test :erlang_module_no_completion do
-    assert expand(':x') == {:no, '', []}
-    assert expand('x.Foo') == {:no, '', []}
+  test "Elixir callback completion" do
+    assert expand(~c"b :strin") == {:yes, ~c"g", []}
+    assert expand(~c"b String") == {:yes, ~c"", [~c"String", ~c"StringIO"]}
+    assert expand(~c"b String.") == {:no, ~c"", []}
+    assert expand(~c"b Access.") == {:yes, ~c"", [~c"fetch/2", ~c"get_and_update/3", ~c"pop/2"]}
+    assert expand(~c"b GenServer.term") == {:yes, ~c"inate", []}
+    assert expand(~c"b   GenServer.term") == {:yes, ~c"inate", []}
+    assert expand(~c"b :gen_server.handle_in") == {:yes, ~c"fo", []}
   end
 
-  test :erlang_module_common_prefix_completion do
-    assert expand(':us') == {:yes, 'er', []}
+  test "Elixir helper completion with parentheses" do
+    assert expand(~c"t(:gen_ser") == {:yes, ~c"ver", []}
+    assert expand(~c"t(String") == {:yes, ~c"", [~c"String", ~c"StringIO"]}
+
+    assert expand(~c"t(String.") ==
+             {:yes, ~c"",
+              [
+                ~c"codepoint/0",
+                ~c"grapheme/0",
+                ~c"pattern/0",
+                ~c"replace_opts/0",
+                ~c"split_opts/0",
+                ~c"splitter_opts/0",
+                ~c"t/0"
+              ]}
+
+    assert expand(~c"t(String.grap") == {:yes, ~c"heme", []}
   end
 
-  test :erlang_module_multiple_values_completion do
-    {:yes, '', list} = expand(':user')
-    assert length(list) > 1
+  test "Elixir completion with self" do
+    assert expand(~c"Enumerable") == {:yes, ~c".", []}
   end
 
-  test :elixir_simple_completion do
-    assert expand('En') == {:yes, 'um', []}
-    assert expand('Enumera') == {:yes, 'ble.', []}
+  test "Elixir completion on modules from load path" do
+    assert expand(~c"Str") == {:yes, [], [~c"Stream", ~c"String", ~c"StringIO"]}
+    assert expand(~c"Ma") == {:yes, ~c"", [~c"Macro", ~c"Map", ~c"MapSet", ~c"MatchError"]}
+    assert expand(~c"Dic") == {:yes, ~c"t", []}
+    assert expand(~c"Ex") == {:yes, [], [~c"ExUnit", ~c"Exception"]}
   end
 
-  test :elixir_auto_completion_with_self do
-    assert expand('Enumerable') == {:yes, '.', []}
+  test "Elixir no completion for underscored functions with no doc" do
+    {:module, _, bytecode, _} =
+      defmodule Elixir.Sample do
+        def __foo__(), do: 0
+        @doc "Bar doc"
+        def __bar__(), do: 1
+      end
+
+    File.write!("Elixir.Sample.beam", bytecode)
+    assert {:docs_v1, _, _, _, _, _, _} = Code.fetch_docs(Sample)
+    assert expand(~c"Sample._") == {:yes, ~c"_bar__", []}
+  after
+    File.rm("Elixir.Sample.beam")
+    :code.purge(Sample)
+    :code.delete(Sample)
+  end
+
+  test "Elixir no completion for default argument functions with doc set to false" do
+    {:yes, ~c"", available} = expand(~c"String.")
+    refute Enum.member?(available, ~c"rjust/2")
+    assert Enum.member?(available, ~c"replace/3")
+
+    assert expand(~c"String.r") == {:yes, ~c"e", []}
+
+    {:module, _, bytecode, _} =
+      defmodule Elixir.DefaultArgumentFunctions do
+        def foo(a \\ :a, b, c \\ :c), do: {a, b, c}
+
+        def _do_fizz(a \\ :a, b, c \\ :c), do: {a, b, c}
+
+        @doc false
+        def __fizz__(a \\ :a, b, c \\ :c), do: {a, b, c}
+
+        @doc "bar/0 doc"
+        def bar(), do: :bar
+        @doc false
+        def bar(a \\ :a, b, c \\ :c, d \\ :d), do: {a, b, c, d}
+        @doc false
+        def bar(a, b, c, d, e), do: {a, b, c, d, e}
+
+        @doc false
+        def baz(a \\ :a), do: {a}
+
+        @doc "biz/3 doc"
+        def biz(a, b, c \\ :c), do: {a, b, c}
+      end
+
+    File.write!("Elixir.DefaultArgumentFunctions.beam", bytecode)
+    assert {:docs_v1, _, _, _, _, _, _} = Code.fetch_docs(DefaultArgumentFunctions)
+
+    functions_list = [~c"bar/0", ~c"biz/2", ~c"biz/3", ~c"foo/1", ~c"foo/2", ~c"foo/3"]
+    assert expand(~c"DefaultArgumentFunctions.") == {:yes, ~c"", functions_list}
+
+    assert expand(~c"DefaultArgumentFunctions.bi") == {:yes, ~c"z", []}
+
+    assert expand(~c"DefaultArgumentFunctions.foo") ==
+             {:yes, ~c"", [~c"foo/1", ~c"foo/2", ~c"foo/3"]}
+  after
+    File.rm("Elixir.DefaultArgumentFunctions.beam")
+    :code.purge(DefaultArgumentFunctions)
+    :code.delete(DefaultArgumentFunctions)
   end
 
-  test :elixir_no_completion do
-    assert expand('.')   == {:no, '', []}
-    assert expand('Xyz') == {:no, '', []}
+  test "Elixir no completion" do
+    assert expand(~c".") == {:no, ~c"", []}
+    assert expand(~c"Xyz") == {:no, ~c"", []}
+    assert expand(~c"x.Foo") == {:no, ~c"", []}
+    assert expand(~c"x.Foo.get_by") == {:no, ~c"", []}
+    assert expand(~c"@foo.bar") == {:no, ~c"", []}
   end
 
-  test :elixir_root_submodule_completion do
-    _ = [foo: 1][:foo]
-    assert expand('Elixir.Acce') == {:yes, 'ss.', []}
+  test "Elixir root submodule completion" do
+    assert expand(~c"Elixir.Acce") == {:yes, ~c"ss", []}
   end
 
-  test :elixir_submodule_completion do
-    assert expand('String.Cha') == {:yes, 'rs.', []}
+  test "Elixir submodule completion" do
+    assert expand(~c"String.Cha") == {:yes, ~c"rs", []}
   end
 
-  test :elixir_submodule_no_completion do
-    assert expand('IEx.Xyz') == {:no, '', []}
+  test "Elixir submodule no completion" do
+    assert expand(~c"IEx.Xyz") == {:no, ~c"", []}
   end
 
-  test :elixir_function_completion do
-    assert expand('System.ve') == {:yes, 'rsion', []}
-    assert expand(':ets.fun2') == {:yes, 'ms', []}
+  test "block keywords" do
+    assert expand(~c"if true do") == {:yes, ~c"", [~c"do"]}
+    assert expand(~c"if true a") == {:yes, ~c"", [~c"after", ~c"and/2"]}
+    assert expand(~c"if true d") == {:yes, ~c"o", []}
+    assert expand(~c"if true e") == {:yes, ~c"", [~c"end", ~c"else"]}
   end
 
-  test :elixir_function_completion_with_arity do
-    assert expand('String.printable?')  == {:yes, '', ['printable?/1']}
-    assert expand('String.printable?/') == {:yes, '', ['printable?/1']}
+  test "block keywords or operators" do
+    {:yes, ~c"", hints} = expand(~c"if true ")
+    assert ~c"do" in hints
+    assert ~c"else" in hints
+    assert ~c"+/2" in hints
+    assert ~c"and/2" in hints
   end
 
-  test :elixir_macro_completion do
-    {:yes, '', list} = expand('Kernel.is_')
+  test "function completion" do
+    assert expand(~c"System.ve") == {:yes, ~c"rsion", []}
+    assert expand(~c":ets.fun2") == {:yes, ~c"ms", []}
+  end
+
+  test "function completion with groups" do
+    {:yes, ~c"", [exports, guards]} = expand(~c"Kernel.i")
+    assert %{title: ~c"Exports", elems: [~c"if/2", ~c"inspect/1", ~c"inspect/2"]} = exports
+    assert %{title: ~c"Guards", elems: [_ | _]} = guards
+
+    {:yes, ~c"", [guards, exports]} = expand(~c"Kernel.in")
+    assert %{title: ~c"Guards", elems: [~c"in/2"]} = guards
+    assert %{title: ~c"Exports", elems: [~c"inspect/1", ~c"inspect/2"]} = exports
+  end
+
+  test "function completion with arity" do
+    assert expand(~c"String.printable?") == {:yes, ~c"", [~c"printable?/1", ~c"printable?/2"]}
+    assert expand(~c"String.printable?/") == {:yes, ~c"", [~c"printable?/1", ~c"printable?/2"]}
+
+    assert expand(~c"Enum.count") ==
+             {:yes, ~c"", [~c"count/1", ~c"count/2", ~c"count_until/2", ~c"count_until/3"]}
+
+    assert expand(~c"Enum.count/") == {:yes, ~c"", [~c"count/1", ~c"count/2"]}
+  end
+
+  test "operator completion" do
+    assert expand(~c"+") == {:yes, ~c"", [~c"+/1", ~c"+/2", ~c"++/2"]}
+    assert expand(~c"+/") == {:yes, ~c"", [~c"+/1", ~c"+/2"]}
+    assert expand(~c"++/") == {:yes, ~c"", [~c"++/2"]}
+  end
+
+  test "sigil completion" do
+    {:yes, ~c"", sigils} = expand(~c"~")
+    assert ~c"~C (sigil_C)" in sigils
+    {:yes, ~c"", sigils} = expand(~c"~r")
+    assert ~c"\"" in sigils
+    assert ~c"(" in sigils
+  end
+
+  test "function completion using a variable bound to a module" do
+    eval("mod = String")
+    assert expand(~c"mod.print") == {:yes, ~c"able?", []}
+  end
+
+  test "map atom key completion is supported" do
+    eval("map = %{foo: 1, bar_1: 23, bar_2: 14}")
+    assert expand(~c"map.f") == {:yes, ~c"oo", []}
+    assert expand(~c"map.b") == {:yes, ~c"ar_", []}
+    assert expand(~c"map.bar_") == {:yes, ~c"", [~c"bar_1", ~c"bar_2"]}
+    assert expand(~c"map.c") == {:no, ~c"", []}
+    assert expand(~c"map.") == {:yes, ~c"", [~c"bar_1", ~c"bar_2", ~c"foo"]}
+    assert expand(~c"map.foo") == {:no, ~c"", []}
+  end
+
+  test "nested map atom key completion is supported" do
+    eval("map = %{nested: %{deeply: %{foo: 1, bar_1: 23, bar_2: 14, mod: String, num: 1}}}")
+    assert expand(~c"map.nested.deeply.f") == {:yes, ~c"oo", []}
+    assert expand(~c"map.nested.deeply.b") == {:yes, ~c"ar_", []}
+    assert expand(~c"map.nested.deeply.bar_") == {:yes, ~c"", [~c"bar_1", ~c"bar_2"]}
+
+    assert expand(~c"map.nested.deeply.") ==
+             {:yes, ~c"", [~c"bar_1", ~c"bar_2", ~c"foo", ~c"mod", ~c"num"]}
+
+    assert expand(~c"map.nested.deeply.mod.print") == {:yes, ~c"able?", []}
+
+    assert expand(~c"map.nested") == {:yes, ~c".", []}
+    assert expand(~c"map.nested.deeply") == {:yes, ~c".", []}
+    assert expand(~c"map.nested.deeply.foo") == {:no, ~c"", []}
+
+    assert expand(~c"map.nested.deeply.c") == {:no, ~c"", []}
+    assert expand(~c"map.a.b.c.f") == {:no, ~c"", []}
+  end
+
+  test "map string key completion is not supported" do
+    eval(~S(map = %{"foo" => 1}))
+    assert expand(~c"map.f") == {:no, ~c"", []}
+  end
+
+  test "bound variables for modules and maps" do
+    eval("num = 5; map = %{nested: %{num: 23}}")
+    assert expand(~c"num.print") == {:no, ~c"", []}
+    assert expand(~c"map.nested.num.f") == {:no, ~c"", []}
+    assert expand(~c"map.nested.num.key.f") == {:no, ~c"", []}
+  end
+
+  test "access syntax is not supported" do
+    eval("map = %{nested: %{deeply: %{num: 23}}}")
+    assert expand(~c"map[:nested][:deeply].n") == {:no, ~c"", []}
+    assert expand(~c"map[:nested].deeply.n") == {:no, ~c"", []}
+    assert expand(~c"map.nested.[:deeply].n") == {:no, ~c"", []}
+  end
+
+  test "unbound variables is not supported" do
+    eval("num = 5")
+    assert expand(~c"other_var.f") == {:no, ~c"", []}
+    assert expand(~c"a.b.c.d") == {:no, ~c"", []}
+  end
+
+  test "macro completion" do
+    {:yes, ~c"", list} = expand(~c"Kernel.is_")
     assert is_list(list)
   end
 
-  test :elixir_root_completion do
-    {:yes, '', list} = expand('')
+  test "imports completion" do
+    {:yes, ~c"", list} = expand(~c"")
     assert is_list(list)
-    assert 'h/1' in list
-    assert 'Elixir' in list
+    assert ~c"h/1" in list
+    assert ~c"unquote/1" in list
+    assert ~c"pwd/0" in list
   end
 
-  test :elixir_kernel_completion do
-    assert expand('defstru') == {:yes, 'ct', []}
+  test "kernel import completion" do
+    assert expand(~c"defstru") == {:yes, ~c"ct", []}
+    assert expand(~c"put_") == {:yes, ~c"", [~c"put_elem/3", ~c"put_in/2", ~c"put_in/3"]}
   end
 
-  test :elixir_proxy do
-    {:yes, '', list} = expand('E')
-    assert 'Elixir' in list
+  test "variable name completion" do
+    eval("numeral = 3; number = 3; nothing = nil")
+    assert expand(~c"numb") == {:yes, ~c"er", []}
+    assert expand(~c"num") == {:yes, ~c"", [~c"number", ~c"numeral"]}
+    assert expand(~c"no") == {:yes, ~c"", [~c"nothing", ~c"node/0", ~c"node/1", ~c"not/1"]}
   end
 
-  test :elixir_erlang_module_root_completion do
-    {:yes, '', list} = expand(':')
-    assert is_list(list)
-    assert 'lists' in list
+  test "completion of manually imported functions and macros" do
+    eval("import Enum; import Supervisor, only: [count_children: 1]; import Protocol")
+
+    assert expand(~c"der") == {:yes, ~c"ive", []}
+
+    assert expand(~c"take") ==
+             {:yes, ~c"", [~c"take/2", ~c"take_every/2", ~c"take_random/2", ~c"take_while/2"]}
+
+    assert expand(~c"take/") == {:yes, ~c"", [~c"take/2"]}
+
+    assert expand(~c"count") ==
+             {:yes, ~c"",
+              [
+                ~c"count/1",
+                ~c"count/2",
+                ~c"count_children/1",
+                ~c"count_until/2",
+                ~c"count_until/3"
+              ]}
+
+    assert expand(~c"count/") == {:yes, ~c"", [~c"count/1", ~c"count/2"]}
+  end
+
+  defmacro define_var do
+    quote(do: var!(my_var_1, Elixir) = 1)
+  end
+
+  test "ignores quoted variables when performing variable completion" do
+    eval("require #{__MODULE__}; #{__MODULE__}.define_var(); my_var_2 = 2")
+    assert expand(~c"my_var") == {:yes, ~c"_2", []}
+  end
+
+  test "kernel special form completion" do
+    assert expand(~c"unquote_spl") == {:yes, ~c"icing", []}
+  end
+
+  test "completion inside expression" do
+    assert expand(~c"1 En") == {:yes, ~c"um", []}
+    assert expand(~c"Test(En") == {:yes, ~c"um", []}
+    assert expand(~c"Test :zl") == {:yes, ~c"ib", []}
+    assert expand(~c"[:zl") == {:yes, ~c"ib", []}
+    assert expand(~c"{:zl") == {:yes, ~c"ib", []}
+  end
+
+  defmodule SublevelTest.LevelA.LevelB do
+  end
+
+  test "Elixir completion sublevel" do
+    assert expand(~c"IEx.AutocompleteTest.SublevelTest.") == {:yes, ~c"LevelA", []}
+  end
+
+  test "complete aliases of Elixir modules" do
+    eval("alias List, as: MyList")
+    assert expand(~c"MyL") == {:yes, ~c"ist", []}
+    assert expand(~c"MyList") == {:yes, ~c".", []}
+    assert expand(~c"MyList.to_integer") == {:yes, [], [~c"to_integer/1", ~c"to_integer/2"]}
+  end
+
+  test "complete aliases of Erlang modules" do
+    eval("alias :lists, as: EList")
+    assert expand(~c"EL") == {:yes, ~c"ist", []}
+    assert expand(~c"EList") == {:yes, ~c".", []}
+    assert expand(~c"EList.map") == {:yes, [], [~c"map/2", ~c"mapfoldl/3", ~c"mapfoldr/3"]}
+  end
+
+  test "completion for functions added when compiled module is reloaded" do
+    {:module, _, bytecode, _} =
+      defmodule Sample do
+        def foo(), do: 0
+      end
+
+    File.write!("Elixir.IEx.AutocompleteTest.Sample.beam", bytecode)
+    assert {:docs_v1, _, _, _, _, _, _} = Code.fetch_docs(Sample)
+    assert expand(~c"IEx.AutocompleteTest.Sample.foo") == {:yes, ~c"", [~c"foo/0"]}
+
+    Code.compiler_options(ignore_module_conflict: true)
+
+    defmodule Sample do
+      def foo(), do: 0
+      def foobar(), do: 0
+    end
+
+    assert expand(~c"IEx.AutocompleteTest.Sample.foo") == {:yes, ~c"", [~c"foo/0", ~c"foobar/0"]}
+  after
+    File.rm("Elixir.IEx.AutocompleteTest.Sample.beam")
+    Code.compiler_options(ignore_module_conflict: false)
+    :code.purge(Sample)
+    :code.delete(Sample)
+  end
+
+  defmodule MyStruct do
+    defstruct [:my_val]
+  end
+
+  test "completion for struct names" do
+    assert {:yes, ~c"", entries} = expand(~c"%")
+    assert ~c"URI" in entries
+    assert ~c"IEx.History" in entries
+    assert ~c"IEx.Server" in entries
+
+    assert {:yes, ~c"", entries} = expand(~c"%IEx.")
+    assert ~c"IEx.History" in entries
+    assert ~c"IEx.Server" in entries
+
+    assert expand(~c"%IEx.AutocompleteTe") == {:yes, ~c"st.MyStruct{", []}
+    assert expand(~c"%IEx.AutocompleteTest.MyStr") == {:yes, ~c"uct{", []}
+
+    eval("alias IEx.AutocompleteTest.MyStruct")
+    assert expand(~c"%MyStr") == {:yes, ~c"uct{", []}
+  end
+
+  test "completion for struct keys" do
+    assert {:yes, ~c"", entries} = expand(~c"%URI{")
+    assert ~c"path:" in entries
+    assert ~c"query:" in entries
+
+    assert {:yes, ~c"", entries} = expand(~c"%URI{path: \"foo\",")
+    assert ~c"path:" not in entries
+    assert ~c"query:" in entries
+
+    assert {:yes, ~c"ry: ", []} = expand(~c"%URI{path: \"foo\", que")
+    assert {:no, [], []} = expand(~c"%URI{path: \"foo\", unkno")
+    assert {:no, [], []} = expand(~c"%Unknown{path: \"foo\", unkno")
+
+    assert {:yes, [], _} = expand(~c"%__MODULE__{")
+    assert {:yes, [], _} = expand(~c"%__MODULE__.Some{")
+  end
+
+  test "completion for struct keys in update syntax" do
+    assert {:yes, ~c"", entries} = expand(~c"%URI{var | ")
+    assert ~c"path:" in entries
+    assert ~c"query:" in entries
+
+    assert {:yes, ~c"", entries} = expand(~c"%URI{var | path: \"foo\",")
+    assert ~c"path:" not in entries
+    assert ~c"query:" in entries
+
+    assert {:yes, ~c"ry: ", []} = expand(~c"%URI{var | path: \"foo\", que")
+    assert {:no, [], []} = expand(~c"%URI{var | path: \"foo\", unkno")
+    assert {:no, [], []} = expand(~c"%Unknown{var | path: \"foo\", unkno")
+
+    eval("var = %URI{}")
+
+    assert {:yes, ~c"", entries} = expand(~c"%{var | ")
+    assert ~c"path:" in entries
+    assert ~c"query:" in entries
+
+    assert {:yes, ~c"", entries} = expand(~c"%{var | path: \"foo\",")
+    assert ~c"path:" not in entries
+    assert ~c"query:" in entries
+
+    assert {:yes, ~c"ry: ", []} = expand(~c"%{var | path: \"foo\", que")
+    assert {:no, [], []} = expand(~c"%URI{var | path: \"foo\", unkno")
+  end
+
+  test "completion for map keys in update syntax" do
+    eval("map = %{some: 1, other: :ok, another: \"qwe\"}")
+    assert {:yes, ~c"", entries} = expand(~c"%{map | ")
+    assert ~c"some:" in entries
+    assert ~c"other:" in entries
+
+    assert {:yes, ~c"", entries} = expand(~c"%{map | some: \"foo\",")
+    assert ~c"some:" not in entries
+    assert ~c"other:" in entries
+
+    assert {:yes, ~c"er: ", []} = expand(~c"%{map | some: \"foo\", oth")
+    assert {:no, [], []} = expand(~c"%{map | some: \"foo\", unkno")
+    assert {:no, [], []} = expand(~c"%{unknown | some: \"foo\", unkno")
+  end
+
+  test "completion for struct var keys" do
+    eval("struct = %IEx.AutocompleteTest.MyStruct{}")
+    assert expand(~c"struct.my") == {:yes, ~c"_val", []}
+  end
+
+  test "completion for bitstring modifiers" do
+    assert {:yes, ~c"", entries} = expand(~c"<<foo::")
+    assert ~c"integer" in entries
+    assert ~c"size/1" in entries
+
+    assert {:yes, ~c"eger", []} = expand(~c"<<foo::int")
+
+    assert {:yes, ~c"", entries} = expand(~c"<<foo::integer-")
+    refute ~c"integer" in entries
+    assert ~c"little" in entries
+    assert ~c"size/1" in entries
+
+    assert {:yes, ~c"", entries} = expand(~c"<<foo::integer-little-")
+    refute ~c"integer" in entries
+    refute ~c"little" in entries
+    assert ~c"size/1" in entries
+  end
+
+  test "completion for aliases in special forms" do
+    assert {:yes, ~c"", entries} = expand(~c"alias ")
+    assert ~c"Atom" in entries
+    refute ~c"is_atom" in entries
+
+    assert {:yes, ~c"Range", []} = expand(~c"alias Date.")
+  end
+
+  test "ignore invalid Elixir module literals" do
+    defmodule(:"Elixir.IEx.AutocompleteTest.Unicodé", do: nil)
+    assert expand(~c"IEx.AutocompleteTest.Unicod") == {:no, ~c"", []}
+  after
+    :code.purge(:"Elixir.IEx.AutocompleteTest.Unicodé")
+    :code.delete(:"Elixir.IEx.AutocompleteTest.Unicodé")
+  end
+
+  test "signature help for functions and macros" do
+    assert expand(~c"String.graphemes(") == {:yes, ~c"", [~c"graphemes(string)"]}
+    assert expand(~c"def ") == {:yes, ~c"", [~c"def(call, expr \\\\ nil)"]}
+
+    eval("import Enum; import Protocol")
+
+    assert expand(~c"reduce(") ==
+             {:yes, ~c"", [~c"reduce(enumerable, fun)", ~c"reduce(enumerable, acc, fun)"]}
+
+    assert expand(~c"take(") == {:yes, ~c"", [~c"take(enumerable, amount)"]}
+    assert expand(~c"derive(") == {:yes, ~c"", [~c"derive(protocol, module, options \\\\ [])"]}
+
+    defmodule NoDocs do
+      def sample(a), do: a
+    end
+
+    assert {:yes, [], [_ | _]} = expand(~c"NoDocs.sample(")
+  end
+
+  @tag :tmp_dir
+  test "path completion inside strings", %{tmp_dir: dir} do
+    dir |> Path.join("single1") |> File.touch()
+    dir |> Path.join("file1") |> File.touch()
+    dir |> Path.join("file2") |> File.touch()
+    dir |> Path.join("dir") |> File.mkdir()
+    dir |> Path.join("dir/file3") |> File.touch()
+    dir |> Path.join("dir/file4") |> File.touch()
+
+    assert expand(~c"\"./") == path_autocompletion(".")
+    assert expand(~c"\"/") == path_autocompletion("/")
+    assert expand(~c"\"./#\{") == expand(~c"{")
+    assert expand(~c"\"./#\{Str") == expand(~c"{Str")
+    assert expand(~c"Path.join(\"./\", is_") == expand(~c"is_")
+
+    assert expand(~c"\"#{dir}/") == path_autocompletion(dir)
+    assert expand(~c"\"#{dir}/sin") == {:yes, ~c"gle1", []}
+    assert expand(~c"\"#{dir}/single1") == {:yes, ~c"\"", []}
+    assert expand(~c"\"#{dir}/fi") == {:yes, ~c"le", []}
+    assert expand(~c"\"#{dir}/file") == path_autocompletion(dir, "file")
+    assert expand(~c"\"#{dir}/d") == {:yes, ~c"ir/", []}
+    assert expand(~c"\"#{dir}/dir") == {:yes, ~c"/", []}
+    assert expand(~c"\"#{dir}/dir/") == {:yes, ~c"file", []}
+    assert expand(~c"\"#{dir}/dir/file") == dir |> Path.join("dir") |> path_autocompletion("file")
   end
 
-  test :completion_inside_expression do
-    assert expand('1+En') == {:yes, 'um', []}
-    assert expand('Test(En') == {:yes, 'um', []}
-    assert expand('Test :z') == {:yes, 'lib.', []}
-    assert expand('[:z') == {:yes, 'lib.', []}
+  defp path_autocompletion(dir, hint \\ "") do
+    dir
+    |> File.ls!()
+    |> Stream.filter(&String.starts_with?(&1, hint))
+    |> Enum.map(&String.to_charlist/1)
+    |> case do
+      [] -> {:no, ~c"", []}
+      list -> {:yes, ~c"", list}
+    end
   end
 end
diff --git a/lib/iex/test/iex/config_test.exs b/lib/iex/test/iex/config_test.exs
new file mode 100644
index 00000000000..7159938fee4
--- /dev/null
+++ b/lib/iex/test/iex/config_test.exs
@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule IEx.ConfigTest do
+  use ExUnit.Case, async: true
+
+  import IEx.Config
+
+  describe "prompt" do
+    test "converts everything before opening parens to dots" do
+      assert prompt(~c"iex(321)>") == ~c"...(321)>"
+      assert prompt(~c"foo-bar(321)>") == ~c".......(321)>"
+    end
+
+    test "falls back to Erlang wit no parens around" do
+      assert prompt(~c"foo-bar>") == ~c"     .. "
+    end
+
+    test "ignores ansi escapes" do
+      assert prompt(~c"#{IO.ANSI.red()}iex(foo)>") == ~c"...(foo)>"
+      assert prompt(~c"#{IO.ANSI.red()}foo-bar>") == ~c"     .. "
+    end
+  end
+end
diff --git a/lib/iex/test/iex/evaluator_test.exs b/lib/iex/test/iex/evaluator_test.exs
deleted file mode 100644
index 0860956e441..00000000000
--- a/lib/iex/test/iex/evaluator_test.exs
+++ /dev/null
@@ -1,25 +0,0 @@
-Code.require_file "../test_helper.exs", __DIR__
-
-defmodule IEx.EvaluatorTest do
-  use ExUnit.Case, async: true
-
-  alias IEx.Evaluator, as: E
-
-  test "format_stacktrace returns formatted result in columns" do
-    frames = [
-      {List,   :one,    1, [file: "loc",    line: 1]},
-      {String, :second, 2, [file: "loc2",   line: 102]},
-      {IEx,    :three,  3, [file: "longer", line: 1234]},
-      {List,   :four,   4, [file: "loc",    line: 1]},
-    ]
-
-    expected = """
-        (elixir) loc:1: List.one/1
-        (elixir) loc2:102: String.second/2
-           (iex) longer:1234: IEx.three/3
-        (elixir) loc:1: List.four/4
-    """
-
-    assert E.format_stacktrace(frames) <> "\n" == expected
-  end
-end
diff --git a/lib/iex/test/iex/helpers_test.exs b/lib/iex/test/iex/helpers_test.exs
index e6f7a44c01e..170073edaeb 100644
--- a/lib/iex/test/iex/helpers_test.exs
+++ b/lib/iex/test/iex/helpers_test.exs
@@ -1,318 +1,1697 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule IEx.HelpersTest do
   use IEx.Case
 
-  import IEx.Helpers
+  import IEx.Helpers
+
+  @compile {:no_warn_undefined, [:sample, Sample, Sample2]}
+
+  describe "whereami" do
+    test "is disabled by default" do
+      assert capture_iex("whereami()") =~ "Pry session is not currently enabled"
+    end
+
+    test "shows current location for custom envs" do
+      whereami = capture_iex("whereami()", [], env: %{__ENV__ | line: 7})
+      assert whereami =~ "test/iex/helpers_test.exs:7"
+      assert whereami =~ "7: defmodule IEx.HelpersTest do"
+    end
+
+    test "prints message when location is not available" do
+      whereami = capture_iex("whereami()", [], env: %{__ENV__ | line: 30000})
+      assert whereami =~ "test/iex/helpers_test.exs:30000"
+      assert whereami =~ "Could not extract source snippet. Location is not available."
+
+      whereami = capture_iex("whereami()", [], env: %{__ENV__ | file: "nofile", line: 1})
+      assert whereami =~ "nofile:1"
+      assert whereami =~ "Could not extract source snippet. Location is not available."
+    end
+  end
+
+  describe "breakpoints" do
+    setup do
+      on_exit(fn -> IEx.Pry.remove_breaks() end)
+    end
+
+    test "sets up a breakpoint with capture syntax" do
+      assert break!(PryExampleModule.two() / 2) == 1
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
+    end
+
+    test "sets up a breakpoint with call syntax" do
+      assert break!(PryExampleModule.two(_, %{})) == 1
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
+    end
+
+    test "sets up a breakpoint with guards syntax" do
+      assert break!(PryExampleModule.two(_, map) when is_map(map)) == 1
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
+    end
+
+    test "sets up a breakpoint on the given module" do
+      assert break!(PryExampleModule, :two, 2) == 1
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
+    end
+
+    test "resets breaks on the given ID" do
+      assert break!(PryExampleModule, :two, 2) == 1
+      assert reset_break(1) == :ok
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 0}]
+    end
+
+    test "resets breaks on the given module" do
+      assert break!(PryExampleModule, :two, 2) == 1
+      assert reset_break(PryExampleModule, :two, 2) == :ok
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 0}]
+    end
+
+    test "removes breaks in the given module" do
+      assert break!(PryExampleModule.two() / 2) == 1
+      assert remove_breaks(PryExampleModule) == :ok
+      assert IEx.Pry.breaks() == []
+    end
+
+    test "removes breaks on all modules" do
+      assert break!(PryExampleModule.two() / 2) == 1
+      assert remove_breaks() == :ok
+      assert IEx.Pry.breaks() == []
+    end
+
+    test "errors when setting up a breakpoint with invalid guard" do
+      assert capture_io(:stderr, fn ->
+               assert_raise CompileError, fn ->
+                 break!(PryExampleModule.two(_, map) when is_whatever(map))
+               end
+             end) =~ "cannot find or invoke local is_whatever/1"
+    end
+
+    test "errors when setting up a break with no beam" do
+      assert_raise RuntimeError,
+                   "could not set breakpoint, could not find .beam file for IEx.HelpersTest",
+                   fn -> break!(__MODULE__, :setup, 1) end
+    end
+
+    test "errors when setting up a break for unknown function" do
+      assert_raise RuntimeError,
+                   "could not set breakpoint, unknown function/macro #{inspect(PryExampleModule)}.unknown/2",
+                   fn -> break!(PryExampleModule, :unknown, 2) end
+    end
+
+    test "errors for non-Elixir modules" do
+      assert_raise RuntimeError,
+                   "could not set breakpoint, module :maps was not written in Elixir",
+                   fn -> break!(:maps, :unknown, 2) end
+    end
+
+    test "prints table with breaks" do
+      break!(PryExampleModule, :two, 2)
+
+      assert capture_io(fn -> breaks() end) == """
+
+              ID   Module.function/arity    Pending stops
+             ---- ------------------------ ---------------
+              1    PryExampleModule.two/2   1
+
+             """
+
+      assert capture_io(fn -> PryExampleModule.two("foo=bar", %{}) end) != ""
+
+      assert capture_io(fn -> breaks() end) == """
+
+              ID   Module.function/arity    Pending stops
+             ---- ------------------------ ---------------
+              1    PryExampleModule.two/2   0
+
+             """
+
+      assert capture_io(fn -> PryExampleModule.two("foo=bar", %{}) end) == ""
+
+      assert capture_io(fn -> breaks() end) == """
+
+              ID   Module.function/arity    Pending stops
+             ---- ------------------------ ---------------
+              1    PryExampleModule.two/2   0
+
+             """
+    end
+
+    test "does not print table when there are no breaks" do
+      assert capture_io(fn -> breaks() end) == "No breakpoints set\n"
+    end
+  end
+
+  describe "open" do
+    @describetag :requires_source
+    @iex_helpers "iex/lib/iex/helpers.ex"
+    @elixir_erl "elixir/src/elixir.erl"
+    @lists_erl Application.app_dir(:stdlib, "src/lists.erl")
+    @httpc_erl "src/http_client/httpc.erl"
+    @editor System.get_env("ELIXIR_EDITOR")
+    @example_module_path "lib/iex/test/test_helper.exs"
+
+    test "opens __FILE__ and __LINE__" do
+      System.put_env("ELIXIR_EDITOR", "echo __LINE__:__FILE__")
+
+      assert capture_iex("open({#{inspect(__ENV__.file)}, 3})") |> maybe_trim_quotes() ==
+               "3:#{__ENV__.file}"
+    after
+      System.put_env("ELIXIR_EDITOR", @editor)
+    end
+
+    test "opens Elixir module" do
+      assert capture_iex("open(HelperExampleModule)") |> maybe_trim_quotes() =~
+               ~r/#{@example_module_path}:\d+$/
+    end
+
+    @tag :require_ast
+    test "opens function" do
+      assert capture_iex("open(h)") |> maybe_trim_quotes() =~ ~r/#{@iex_helpers}:\d+$/
+    end
+
+    @tag :require_ast
+    test "opens function/arity" do
+      assert capture_iex("open(b/1)") |> maybe_trim_quotes() =~ ~r/#{@iex_helpers}:\d+$/
+      assert capture_iex("open(h/0)") |> maybe_trim_quotes() =~ ~r/#{@iex_helpers}:\d+$/
+    end
+
+    test "opens module.function" do
+      assert capture_iex("open(HelperExampleModule.fun)") |> maybe_trim_quotes() =~
+               ~r/#{@example_module_path}:\d+$/
+
+      assert capture_iex("open(HelperExampleModule.macro)") |> maybe_trim_quotes() =~
+               ~r/#{@example_module_path}:\d+$/
+    end
+
+    test "opens module.function/arity" do
+      assert capture_iex("open(HelperExampleModule.fun/1)") |> maybe_trim_quotes() =~
+               ~r/#{@example_module_path}:\d+$/
+
+      assert capture_iex("open(HelperExampleModule.macro/1)") |> maybe_trim_quotes() =~
+               ~r/#{@example_module_path}:\d+$/
+    end
+
+    @tag :require_ast
+    test "opens Erlang module" do
+      assert capture_iex("open(:elixir)") |> maybe_trim_quotes() =~ ~r/#{@elixir_erl}:\d+$/
+    end
+
+    @tag :require_ast
+    test "opens Erlang module.function" do
+      assert capture_iex("open(:elixir.start)") |> maybe_trim_quotes() =~ ~r/#{@elixir_erl}:\d+$/
+    end
+
+    @tag :require_ast
+    test "opens Erlang module.function/arity" do
+      assert capture_iex("open(:elixir.start/2)") |> maybe_trim_quotes() =~
+               ~r/#{@elixir_erl}:\d+$/
+    end
+
+    # Some installations remove the source file once Erlang is compiled. See #7348.
+    if File.regular?(@lists_erl) do
+      test "opens OTP lists module" do
+        assert capture_iex("open(:lists)") |> maybe_trim_quotes() =~ ~r/#{@lists_erl}:\d+$/
+      end
+
+      test "opens OTP lists module.function" do
+        assert capture_iex("open(:lists.reverse)") |> maybe_trim_quotes() =~
+                 ~r/#{@lists_erl}:\d+$/
+      end
+
+      test "opens OTP lists module.function/arity" do
+        assert capture_iex("open(:lists.reverse/1)") |> maybe_trim_quotes() =~
+                 ~r/#{@lists_erl}:\d+$/
+      end
+    end
+
+    # Some installations remove the source file once Erlang is compiled. See #7348.
+    if File.regular?(@httpc_erl) do
+      test "opens OTP httpc module" do
+        assert capture_iex("open(:httpc)") |> maybe_trim_quotes() =~ ~r/#{@httpc_erl}:\d+$/
+      end
+
+      test "opens OTP httpc module.function" do
+        assert capture_iex("open(:httpc.request)") |> maybe_trim_quotes() =~
+                 ~r/#{@httpc_erl}:\d+$/
+      end
+
+      test "opens OTP httpc module.function/arity" do
+        assert capture_iex("open(:httpc.request/1)") |> maybe_trim_quotes() =~
+                 ~r/#{@httpc_erl}:\d+$/
+      end
+    end
+
+    test "errors OTP preloaded module" do
+      assert capture_iex("open(:init)") =~ ~r"(Could not open)|(Invalid arguments)"
+    end
+
+    test "errors if module is not available" do
+      assert capture_iex("open(:unknown)") == "Could not open :unknown, module is not available"
+    end
+
+    test "errors if module.function is not available" do
+      assert capture_iex("open(:unknown.unknown)") ==
+               "Could not open :unknown.unknown, module is not available"
+
+      assert capture_iex("open(:elixir.unknown)") ==
+               "Could not open :elixir.unknown, function/macro is not available"
+
+      assert capture_iex("open(:lists.unknown)") ==
+               "Could not open :lists.unknown, function/macro is not available"
+
+      assert capture_iex("open(:httpc.unknown)") ==
+               "Could not open :httpc.unknown, function/macro is not available"
+    end
+
+    test "errors if module.function/arity is not available" do
+      assert capture_iex("open(:unknown.start/10)") ==
+               "Could not open :unknown.start/10, module is not available"
+
+      assert capture_iex("open(:elixir.start/10)") ==
+               "Could not open :elixir.start/10, function/macro is not available"
+
+      assert capture_iex("open(:lists.reverse/10)") ==
+               "Could not open :lists.reverse/10, function/macro is not available"
+
+      assert capture_iex("open(:httpc.request/10)") ==
+               "Could not open :httpc.request/10, function/macro is not available"
+    end
+
+    test "errors if module is in-memory" do
+      assert capture_iex("defmodule Foo, do: nil ; open(Foo)") =~
+               ~r"Invalid arguments for open helper:"
+    after
+      cleanup_modules([Foo])
+    end
+
+    test "opens the current pry location" do
+      assert capture_iex("open()", [], env: %{__ENV__ | line: 3}) |> maybe_trim_quotes() ==
+               "#{__ENV__.file}:3"
+    end
+
+    test "errors if prying is not available" do
+      assert capture_iex("open()") == "Pry session is not currently enabled"
+    end
+
+    test "opens given {file, line}" do
+      assert capture_iex("open({#{inspect(__ENV__.file)}, 3})") |> maybe_trim_quotes() ==
+               "#{__ENV__.file}:3"
+    end
+
+    test "errors when given {file, line} is not available" do
+      assert capture_iex("open({~s[foo], 3})") =~
+               "Could not open \"foo\", file is not available"
+    end
+
+    defp maybe_trim_quotes(string) do
+      case :os.type() do
+        {:win32, _} -> String.replace(string, "\"", "")
+        _ -> string
+      end
+    end
+  end
+
+  describe "clear" do
+    test "clear the screen with ansi" do
+      Application.put_env(:elixir, :ansi_enabled, true)
+      assert capture_iex("clear()") == "\e[H\e[2J"
+
+      Application.put_env(:elixir, :ansi_enabled, false)
+
+      assert capture_iex("clear()") =~
+               "Cannot clear the screen because ANSI escape codes are not enabled on this shell"
+    after
+      Application.delete_env(:elixir, :ansi_enabled)
+    end
+  end
+
+  describe "runtime_info" do
+    test "shows VM information" do
+      assert "\n## System and architecture" <> _ = capture_io(fn -> runtime_info() end)
+
+      assert "\n## Loaded OTP applications" <> _ =
+               capture_io(fn -> runtime_info([:applications]) end)
+
+      assert "\n## Memory allocators" <> _ = capture_io(fn -> runtime_info([:allocators]) end)
+    end
+  end
+
+  describe "h" do
+    test "shows help" do
+      help = capture_iex("h()")
+      assert help =~ "IEx.Helpers"
+      assert help =~ "Welcome to Interactive Elixir"
+    end
+
+    @tag :erlang_doc
+    test "prints Erlang module documentation" do
+      captured = capture_io(fn -> h(:timer) end)
+      assert captured =~ "This module provides useful functions related to time."
+    end
+
+    @tag :erlang_doc
+    test "prints Erlang module function specs" do
+      captured = capture_io(fn -> h(:timer.sleep() / 1) end)
+
+      # TODO remove once we require Erlang/OTP 27+
+      if System.otp_release() < "27" do
+        assert captured =~ ":timer.sleep/1"
+        assert captured =~ "-spec sleep(Time) -> ok when Time :: timeout()."
+      else
+        assert captured =~ "sleep(Time)"
+        assert captured =~ "@spec sleep(time) :: :ok when time: "
+      end
+    end
+
+    @tag :erlang_doc
+    test "handles non-existing Erlang module function" do
+      captured = capture_io(fn -> h(:timer.baz() / 1) end)
+
+      # TODO remove once we require Erlang/OTP 27+
+      if System.otp_release() < "27" do
+        assert captured =~ "No documentation for :timer.baz was found"
+      else
+        assert captured =~ "No documentation for :timer.baz/1 was found"
+      end
+    end
+
+    @tag :erlang_doc
+    # TODO remove once we require Erlang/OTP 27+
+    @tag skip: System.otp_release() < "27"
+    test "erlang -moduledoc" do
+      filename = "sample.erl"
+
+      code = ~s'''
+      -module(sample).
+      -moduledoc "Module documentation.".
+      '''
+
+      with_file(filename, code, fn ->
+        assert c(filename, ".") == [:sample]
+
+        help = capture_iex("h(:sample)")
+        assert help =~ "Module documentation."
+      end)
+    after
+      cleanup_modules([:sample])
+    end
+
+    @tag :erlang_doc
+    # TODO remove once we require Erlang/OTP 27+
+    @tag skip: System.otp_release() < "27"
+    test "erlang -doc" do
+      filename = "sample.erl"
+
+      code = ~s'''
+      -module(sample).
+      -export([hello/0]).
+
+      -doc "Function documentation.".
+      hello() -> world.
+      '''
+
+      with_file(filename, code, fn ->
+        assert c(filename, ".") == [:sample]
+
+        help = capture_iex("h(:sample.hello)")
+        assert help =~ "Function documentation."
+      end)
+    after
+      cleanup_modules([:sample])
+    end
+
+    test "prints module documentation" do
+      assert "\n                                  IEx.Helpers\n\nWelcome to Interactive Elixir" <>
+               _ = capture_io(fn -> h(IEx.Helpers) end)
+
+      assert capture_io(fn -> h(:whatever) end) ==
+               "Could not load module :whatever, got: nofile\n"
+    end
+
+    test "prints function/macro documentation" do
+      pwd_h = """
+
+                                         def pwd()
+
+      Prints the current working directory.
+
+      """
+
+      c_h = """
+
+                              def c(files, path \\\\ :in_memory)
+
+      Compiles the given files.
+      """
+
+      eq_h = """
+
+                                     def left == right
+
+        @spec term() == term() :: boolean()
+
+      guard: true
+
+      Equal to operator. Returns `true` if the two terms are equal.
+      """
+
+      def_h = """
+
+                              defmacro def(call, expr \\\\ nil)
+
+      Defines a public function with the given name and body.
+      """
+
+      assert capture_io(fn -> h(IEx.Helpers.pwd() / 0) end) =~ pwd_h
+      assert capture_io(fn -> h(IEx.Helpers.c() / 2) end) =~ c_h
+      assert capture_io(fn -> h(== / 2) end) =~ eq_h
+      assert capture_io(fn -> h(def / 2) end) =~ def_h
+
+      assert capture_io(fn -> h(IEx.Helpers.c() / 1) end) =~ c_h
+      assert capture_io(fn -> h(pwd) end) =~ pwd_h
+      assert capture_io(fn -> h(def) end) =~ def_h
+    end
+
+    test "prints sigil documentation" do
+      assert capture_io(fn -> h(~w//) end) =~ "Handles the sigil `~w` for list of words"
+    end
+
+    test "prints __info__ documentation" do
+      h_output_module = capture_io(fn -> h(Module.__info__()) end)
+      assert capture_io(fn -> h(Module.UnlikelyTo.Exist.__info__()) end) == h_output_module
+      assert capture_io(fn -> h(Module.UnlikelyTo.Exist.__info__() / 1) end) == h_output_module
+
+      assert capture_io(fn -> h(__info__) end) ==
+               "No documentation for Kernel.__info__ was found\n"
+    end
+
+    test "prints documentation metadata" do
+      content = """
+      defmodule Sample do
+        @moduledoc "Sample module"
+        @moduledoc deprecated: "Use OtherSample", since: "1.2.3", authors: ["Alice", "Bob"]
+        @doc "With metadata"
+        @doc since: "1.2.3", author: "Alice"
+        @deprecated "Use OtherSample.with_metadata/0"
+        def with_metadata(), do: 0
+        @doc "Without metadata"
+        def without_metadata(), do: 1
+      end
+      """
+
+      filename = "sample.ex"
+
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [Sample]
+
+        assert capture_io(fn -> h(Sample) end) == """
+
+                                                    Sample
+
+               deprecated: Use OtherSample
+               since: 1.2.3
+
+               Sample module
+
+               """
+
+        assert capture_io(fn -> h(Sample.with_metadata()) end) == """
+
+                                             def with_metadata()
+
+               deprecated: Use OtherSample.with_metadata/0
+               since: 1.2.3
+
+               With metadata
+
+               """
+
+        assert capture_io(fn -> h(Sample.without_metadata()) end) == """
+
+                                            def without_metadata()
+
+               Without metadata
+
+               """
+      end)
+    after
+      cleanup_modules([Sample])
+    end
+
+    test "considers underscored functions without docs by default" do
+      content = """
+      defmodule Sample do
+        def __foo__(), do: 0
+        @doc "Bar doc"
+        def __bar__(), do: 1
+      end
+      """
+
+      filename = "sample.ex"
+
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [Sample]
+
+        assert capture_io(fn -> h(Sample.__foo__()) end) ==
+                 "No documentation for Sample.__foo__ was found\n"
+
+        assert capture_io(fn -> h(Sample.__bar__()) end) == """
+
+                                                def __bar__()
+
+               Bar doc
+
+               """
+
+        assert capture_io(fn -> h(Sample.__foo__() / 0) end) ==
+                 "No documentation for Sample.__foo__/0 was found\n"
+
+        assert capture_io(fn -> h(Sample.__bar__() / 0) end) == """
+
+                                                def __bar__()
+
+               Bar doc
+
+               """
+      end)
+    after
+      cleanup_modules([Sample])
+    end
+
+    test "prints callback documentation when function docs are not available" do
+      behaviour = """
+      defmodule MyBehaviour do
+        @doc "Docs for MyBehaviour.first"
+        @callback first(integer) :: integer
+        @callback second(integer) :: integer
+        @callback second(integer, integer) :: integer
+      end
+      """
+
+      impl = """
+      defmodule Impl do
+        @behaviour MyBehaviour
+        @doc delegate_to: {Foo, :bar, 3}
+        def first(0), do: 0
+        @doc "Docs for Impl.second/1"
+        def second(0), do: 0
+        @doc "Docs for Impl.second/2"
+        def second(0, 0), do: 0
+      end
+      """
+
+      files = ["my_behaviour.ex", "impl.ex"]
+
+      with_file(files, [behaviour, impl], fn ->
+        assert c(files, ".") |> Enum.sort() == [Impl, MyBehaviour]
+
+        assert capture_io(fn -> h(Impl.first() / 1) end) == """
+
+                                                def first(int)
+
+               delegate_to: Foo.bar/3
+
+               Impl.first/1 has no docs but is a callback for behaviour MyBehaviour. Showing
+               callback docs instead.
+
+               @callback first(integer()) :: integer()
+
+               Docs for MyBehaviour.first
+
+               """
+
+        assert capture_io(fn -> h(Impl.second() / 1) end) == """
+
+                                               def second(int)
+
+               Docs for Impl.second/1
+
+               """
+
+        assert capture_io(fn -> h(Impl.second() / 2) end) == """
+
+                                            def second(int1, int2)
+
+               Docs for Impl.second/2
+
+               """
+
+        assert capture_io(fn -> h(Impl.first()) end) == capture_io(fn -> h(Impl.first() / 1) end)
+
+        assert capture_io(fn -> h(Impl.second()) end) == """
+
+                                               def second(int)
+
+               Docs for Impl.second/1
+
+
+                                            def second(int1, int2)
+
+               Docs for Impl.second/2
+
+               """
+
+        assert capture_io(fn -> h(MyBehaviour.first()) end) == """
+               No documentation for function MyBehaviour.first was found, but there is a callback with the same name.
+               You can view callback documentation with the b/1 helper.\n
+               """
+
+        assert capture_io(fn -> h(MyBehaviour.second() / 2) end) == """
+               No documentation for function MyBehaviour.second/2 was found, but there is a callback with the same name.
+               You can view callback documentation with the b/1 helper.\n
+               """
+
+        assert capture_io(fn -> h(MyBehaviour.second() / 3) end) ==
+                 "No documentation for MyBehaviour.second/3 was found\n"
+      end)
+    after
+      cleanup_modules([Impl, MyBehaviour])
+    end
+
+    test "prints protocol function docs" do
+      output = capture_io(fn -> h(Enumerable.reduce()) end)
+      assert output =~ "@spec reduce(t(), acc(), reducer()) :: result()"
+      assert output =~ "Reduces the `enumerable`"
+    end
+
+    test "prints documentation for delegates" do
+      filename = "delegate.ex"
+
+      content = """
+      defmodule Delegator do
+        defdelegate func1, to: Delegated
+        @doc "Delegator func2 doc"
+        defdelegate func2, to: Delegated
+      end
+      defmodule Delegated do
+        def func1, do: 1
+        def func2, do: 2
+      end
+      """
+
+      with_file(filename, content, fn ->
+        assert c(filename, ".") |> Enum.sort() == [Delegated, Delegator]
+
+        assert capture_io(fn -> h(Delegator.func1()) end) == """
+
+                                                 def func1()
+
+               delegate_to: Delegated.func1/0
+
+               """
+
+        assert capture_io(fn -> h(Delegator.func2()) end) == """
+
+                                                 def func2()
+
+               delegate_to: Delegated.func2/0
+
+               Delegator func2 doc
+
+               """
+      end)
+    after
+      cleanup_modules([Delegated, Delegator])
+    end
+
+    test "prints type documentation when function docs are not available" do
+      content = """
+      defmodule MyTypes do
+        @type first() :: any()
+        @type second(a, b) :: {a, b}
+      end
+      """
 
-  test "clear helper" do
-    assert "\e[H\e[2J" == capture_iex("clear")
-  end
+      filename = "my_types.ex"
 
-  test "h helper" do
-    assert "* IEx.Helpers\n\nWelcome to Interactive Elixir" <> _
-           = capture_iex("h")
-  end
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [MyTypes]
 
-  test "h helper module" do
-    assert "* IEx.Helpers\n\nWelcome to Interactive Elixir" <> _ =
-           capture_io(fn -> h IEx.Helpers end)
+        assert capture_io(fn -> h(MyTypes.first()) end) == """
+               No documentation for function MyTypes.first was found, but there is a type with the same name.
+               You can view type documentation with the t/1 helper.\n
+               """
 
-    assert capture_io(fn -> h :whatever end) ==
-           "Could not load module :whatever, got: nofile\n"
+        assert capture_io(fn -> h(MyTypes.second() / 2) end) == """
+               No documentation for function MyTypes.second/2 was found, but there is a type with the same name.
+               You can view type documentation with the t/1 helper.\n
+               """
+      end)
+    after
+      cleanup_modules([MyTypes])
+    end
 
-    assert capture_io(fn -> h :lists end) ==
-           ":lists is an Erlang module and, as such, it does not have Elixir-style docs\n"
-  end
+    test "prints modules compiled without docs" do
+      Code.compiler_options(docs: false)
 
-  test "h helper function" do
-    pwd_h = "* def pwd()\n\nPrints the current working directory.\n\n"
-    c_h   = "* def c(files, path \\\\ \".\")\n\nExpects a list of files to compile"
+      content = """
+      defmodule Sample do
+        @spec foo(any()) :: any()
+        def foo(arg), do: arg
+      end
+      """
 
-    assert capture_io(fn -> h IEx.Helpers.pwd/0 end) =~ pwd_h
-    assert capture_io(fn -> h IEx.Helpers.c/2 end) =~ c_h
+      filename = "sample.ex"
 
-    assert capture_io(fn -> h IEx.Helpers.c/1 end) =~ c_h
-    assert capture_io(fn -> h pwd end) =~ pwd_h
-  end
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [Sample]
 
-  test "h helper __info__" do
-    h_output_module = capture_io(fn -> h Module.__info__ end)
-    assert capture_io(fn -> h Module.UnlikelyTo.Exist.__info__ end) == h_output_module
-    assert capture_io(fn -> h Module.UnlikelyTo.Exist.__info__/1 end) == h_output_module
-    assert capture_io(fn -> h __info__ end) == "No documentation for __info__ was found\n"
-  end
+        assert capture_io(fn -> h(Sample.foo() / 1) end) == """
 
-  test "t helper" do
-    assert capture_io(fn -> t IEx end) == "No type information for IEx was found\n"
+                                                 Sample.foo/1
 
-    # Test that it shows at least two types
-    assert Enum.count(capture_io(fn -> t Enum end) |> String.split("\n"), fn line ->
-      String.starts_with? line, "@type"
-    end) >= 2
+                 @spec foo(any()) :: any()
+
+               Module was compiled without docs. Showing only specs.
+
+               """
+      end)
+    after
+      Code.compiler_options(docs: true)
+      cleanup_modules([Sample])
+    end
 
-    assert "@type t() :: " <> _
-           = capture_io(fn -> t Enum.t end)
-    assert capture_io(fn -> t Enum.t end) == capture_io(fn -> t Enum.t/0 end)
+    test "does not print docs for @doc false functions" do
+      # Here we assert that @doc false works and that we are not leaking
+      # IEx.Pry internal functions.
+      assert capture_io(fn -> h(IEx.Pry.child_spec()) end) ==
+               "No documentation for IEx.Pry.child_spec was found\n"
+    end
   end
 
-  test "s helper" do
-    assert capture_io(fn -> s ExUnit end) == "No specification for ExUnit was found\n"
+  describe "b" do
+    test "lists all callbacks for an Elixir module" do
+      assert capture_io(fn -> b(Mix) end) == "No callbacks for Mix were found\n"
+      assert capture_io(fn -> b(NoMix) end) == "Could not load module NoMix, got: nofile\n"
+
+      assert capture_io(fn -> b(Mix.SCM) end) =~ """
+             @callback accepts_options(app :: atom(), opts()) :: opts() | nil
+
+             @callback checked_out?(opts()) :: boolean()
+             """
+    end
+
+    test "lists all callbacks for an Erlang module" do
+      output = capture_io(fn -> b(:gen_server) end)
+
+      assert output =~ "@callback init(args :: term()) ::"
+      assert output =~ "@callback handle_cast("
+      assert output =~ "@callback handle_info("
+    end
+
+    test "lists all macrocallbacks for a module" do
+      filename = "macrocallbacks.ex"
+
+      content = """
+      defmodule Macrocallbacks do
+        @macrocallback test(:foo) :: integer
+        @macrocallback test(:bar) :: var when var: integer
+      end
+      """
+
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [Macrocallbacks]
+        callbacks = capture_io(fn -> b(Macrocallbacks) end)
+        assert callbacks =~ "@macrocallback test(:foo) :: integer()\n"
+        assert callbacks =~ "@macrocallback test(:bar) :: var when var: integer()\n"
+      end)
+    after
+      cleanup_modules([Macrocallbacks])
+    end
+
+    test "lists all callbacks for a protocol" do
+      assert capture_io(fn -> b(Enumerable) end) =~ """
+             @callback count(t()) :: {:ok, non_neg_integer()} | {:error, module()}
+
+             @callback member?(t(), term()) :: {:ok, boolean()} | {:error, module()}
+
+             @callback reduce(t(), acc(), reducer()) :: result()
+             """
+    end
+
+    test "prints protocol function docs" do
+      output = capture_io(fn -> b(Enumerable.reduce()) end)
+      assert output =~ "@callback reduce(t(), acc(), reducer()) :: result()"
+      assert output =~ "Reduces the `enumerable`"
+    end
+
+    test "lists callback with multiple clauses" do
+      filename = "multiple_clauses_callback.ex"
+
+      content = """
+      defmodule MultipleClauseCallback do
+        @doc "callback"
+        @callback test(:foo) :: integer
+        @callback test(:bar) :: [integer]
+      end
+      """
+
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [MultipleClauseCallback]
+
+        assert capture_io(fn -> b(MultipleClauseCallback) end) =~ """
+               @callback test(:foo) :: integer()
+               @callback test(:bar) :: [integer()]
+               """
+
+        assert capture_io(fn -> b(MultipleClauseCallback.test()) end) =~ """
+               @callback test(:foo) :: integer()
+               @callback test(:bar) :: [integer()]
+
+               callback
+               """
+      end)
+    after
+      cleanup_modules([MultipleClauseCallback])
+    end
+
+    test "prints callback documentation" do
+      assert capture_io(fn -> b(Mix.Task.stop()) end) ==
+               "No documentation for Mix.Task.stop was found\n"
+
+      assert capture_io(fn -> b(Mix.Task.run()) end) =~
+               "@callback run(command_line_args :: [binary()]) :: any()\n\nA task needs to implement `run`"
+
+      assert capture_io(fn -> b(NoMix.run()) end) == "Could not load module NoMix, got: nofile\n"
+
+      assert capture_io(fn -> b(Exception.message() / 1) end) =~
+               "@callback message(t()) :: String.t()\n\n"
+
+      assert capture_io(fn -> b(:gen_server.handle_cast() / 2) end) =~
+               "@callback handle_cast("
+    end
+
+    test "prints callback documentation metadata" do
+      filename = "callback_with_metadata.ex"
+
+      content = """
+      defmodule CallbackWithMetadata do
+        @doc "callback"
+        @doc since: "1.2.3", deprecated: "Use handle_test/1", purpose: :test
+        @callback test(:foo) :: integer
+      end
+      """
+
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [CallbackWithMetadata]
+
+        assert capture_io(fn -> b(CallbackWithMetadata.test()) end) == """
+               @callback test(:foo) :: integer()
+
+               deprecated: Use handle_test/1
+               since: 1.2.3
+
+               callback
+
+               """
+      end)
+    after
+      cleanup_modules([CallbackWithMetadata])
+    end
+
+    test "prints optional callback" do
+      filename = "optional_callbacks.ex"
 
-    # Test that it shows at least two specs
-    assert Enum.count(capture_io(fn -> s Enum end) |> String.split("\n"), fn line ->
-      String.starts_with? line, "@spec"
-    end) >= 2
+      content = """
+      defmodule OptionalCallbacks do
+        @doc "callback"
+        @callback optional_callback(:foo) :: integer
+        @macrocallback optional_macrocallback(:bar) :: atom
+        @optional_callbacks optional_callback: 1, optional_macrocallback: 1
+      end
+      """
+
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [OptionalCallbacks]
+
+        assert capture_io(fn -> b(OptionalCallbacks) end) =~ """
+               @callback optional_callback(:foo) :: integer()
+
+               @macrocallback optional_macrocallback(:bar) :: atom()
+
+               @optional_callbacks optional_callback: 1, optional_macrocallback: 1
+
+               """
+      end)
+    after
+      cleanup_modules([OptionalCallbacks])
+    end
+
+    test "does not print docs for @doc false callbacks" do
+      filename = "hidden_callbacks.ex"
+
+      content = """
+      defmodule HiddenCallbacks do
+        @doc false
+        @callback hidden_callback() :: integer
+
+        @doc false
+        @macrocallback hidden_macrocallback() :: integer
+      end
+      """
 
-    assert Enum.count(capture_io(fn -> s Enum.all? end) |> String.split("\n"), fn line ->
-      String.starts_with? line, "@spec"
-    end) >= 2
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [HiddenCallbacks]
 
-    assert capture_io(fn -> s Enum.all?/1 end) ==
-           "@spec all?(t()) :: boolean()\n"
-    assert capture_io(fn -> s struct end) ==
-           "@spec struct(module() | %{}, Enum.t()) :: %{}\n"
+        assert capture_io(fn -> b(HiddenCallbacks) end) =~
+                 "No callbacks for HiddenCallbacks were found\n"
+      end)
+    after
+      cleanup_modules([HiddenCallbacks])
+    end
   end
 
-  test "v helper" do
-    assert capture_iex("v") == ":ok"
-    assert capture_iex("1\n2\nv") == String.rstrip """
-      1
-      2
-      1: 1
-      #=> 1
+  describe "t" do
+    test "prints when there is no type information or the type is private" do
+      assert capture_io(fn -> t(List) end) == "No type information for List was found\n"
+
+      assert capture_io(fn -> t(Enum.doesnt_exist()) end) ==
+               "No type information for Enum.doesnt_exist was found or " <>
+                 "Enum.doesnt_exist is private\n"
+
+      contents = """
+      defmodule TypeSample do
+        @type public_so_t_doesnt_warn() :: t()
+        @typep t() :: term()
+      end
+      """
+
+      filename = "typesample.ex"
+
+      with_file(filename, contents, fn ->
+        assert c(filename, ".") == [TypeSample]
+
+        assert capture_io(fn -> t(TypeSample.t() / 0) end) ==
+                 "No type information for TypeSample.t was found or TypeSample.t is private\n"
+      end)
+    after
+      cleanup_modules([TypeSample])
+    end
+
+    test "prints all types in module" do
+      # Test that it shows at least two types
+      assert Enum.count(capture_io(fn -> t(Enum) end) |> String.split("\n"), fn line ->
+               String.starts_with?(line, "@type")
+             end) >= 2
+    end
+
+    test "prints private types" do
+      assert capture_io(fn -> t(Date.Range) end) =~ "@typep days"
+    end
+
+    test "prints type information" do
+      assert "@type t() ::" <> _ = capture_io(fn -> t(Enum.t()) end)
+      assert capture_io(fn -> t(Enum.t()) end) == capture_io(fn -> t(Enum.t() / 0) end)
+      assert capture_io(fn -> t(URI.t()) end) == capture_io(fn -> t(URI.t() / 0) end)
+    end
+
+    test "sorts types alphabetically" do
+      unsorted =
+        capture_io(fn -> t(Enum) end)
+        |> String.split("\n")
+        |> Enum.reject(&(&1 == ""))
+        |> Enum.map(&String.replace(&1, ~r/@(type|opaque) /, ""))
 
-      2: 2
-      #=> 2
+      assert unsorted == Enum.sort(unsorted)
+    end
+
+    test "prints type documentation" do
+      content = """
+      defmodule TypeSample do
+        @typedoc "An ID with description."
+        @type id_with_desc :: {number, String.t}
+        @type unquote(:"?")() :: :question_mark
+      end
+      """
+
+      filename = "typesample.ex"
+
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [TypeSample]
+
+        assert capture_io(fn -> t(TypeSample.id_with_desc() / 0) end) == """
+               @type id_with_desc() :: {number(), String.t()}
+
+               An ID with description.
+
+               """
+
+        assert capture_io(fn -> t(TypeSample.id_with_desc()) end) == """
+               @type id_with_desc() :: {number(), String.t()}
+
+               An ID with description.
+
+               """
+
+        assert capture_io(fn -> t(TypeSample."?"()) end) == """
+               @type ?() :: :question_mark
+
+               """
+      end)
+    after
+      cleanup_modules([TypeSample])
+    end
 
-      :ok
+    test "prints type documentation metadata" do
+      content = """
+      defmodule TypeSample do
+        @typedoc "An ID with description."
+        @typedoc since: "1.2.3", deprecated: "Use t/0", purpose: :test
+        @type id_with_desc :: {number, String.t}
+      end
       """
 
-    assert "** (RuntimeError) v(0) is out of bounds" <> _
-           = capture_iex("v(0)")
-    assert capture_iex("1\n2\nv(2)") == "1\n2\n2"
-    assert capture_iex("1\n2\nv(2)") == capture_iex("1\n2\nv(-1)")
+      filename = "typesample.ex"
+
+      with_file(filename, content, fn ->
+        assert c(filename, ".") == [TypeSample]
+
+        assert capture_io(fn -> t(TypeSample.id_with_desc()) end) == """
+               @type id_with_desc() :: {number(), String.t()}
+
+               deprecated: Use t/0
+               since: 1.2.3
+
+               An ID with description.
+
+               """
+      end)
+    after
+      cleanup_modules([TypeSample])
+    end
+
+    @tag :erlang_doc
+    test "prints all types in Erlang module" do
+      captured = capture_io(fn -> t(:queue) end)
+
+      # TODO remove once we require Erlang/OTP 27+
+      if System.otp_release() < "27" do
+        assert captured =~ "-type queue() :: queue(_)"
+        assert captured =~ "-opaque queue(Item)"
+      else
+        assert captured =~ "@type queue() :: queue(_)"
+        assert captured =~ "@opaque queue(item)"
+      end
+    end
+
+    @tag :erlang_doc
+    test "prints single type from Erlang module" do
+      captured = capture_io(fn -> t(:erlang.iovec()) end)
+
+      # TODO remove once we require Erlang/OTP 27+
+      if System.otp_release() < "27" do
+        assert captured =~ "-type iovec() :: [binary()]"
+      else
+        assert captured =~ "@type iovec() :: [binary()]"
+      end
+
+      assert captured =~ "A list of binaries."
+
+      captured = capture_io(fn -> t(:erlang.iovec() / 0) end)
 
-    assert capture_iex("1\n2\nIEx.History.reset\nv")
-           == String.rstrip """
-           1
-           2
-           true
-           3: IEx.History.reset
-           #=> true
+      # TODO remove once we require Erlang/OTP 27+
+      if System.otp_release() < "27" do
+        assert captured =~ "-type iovec() :: [binary()]"
+      else
+        assert captured =~ "@type iovec() :: [binary()]"
+      end
+
+      assert captured =~ "A list of binaries."
+    end
+
+    @tag :erlang_doc
+    test "handles non-existing types from Erlang module" do
+      captured = capture_io(fn -> t(:erlang.foo()) end)
+      assert captured =~ "No type information for :erlang.foo was found or :erlang.foo is private"
+
+      captured = capture_io(fn -> t(:erlang.foo() / 1) end)
+      assert captured =~ "No type information for :erlang.foo was found or :erlang.foo is private"
+    end
+  end
+
+  describe "v" do
+    test "returns history" do
+      assert "** (RuntimeError) v(0) is out of bounds" <> _ = capture_iex("v(0)")
+      assert "** (RuntimeError) v(1) is out of bounds" <> _ = capture_iex("v(1)")
+      assert "** (RuntimeError) v(-1) is out of bounds" <> _ = capture_iex("v(-1)")
+      assert capture_iex("1\n2\nv(2)") == "1\n2\n2"
+      assert capture_iex("1\n2\nv(2)") == capture_iex("1\n2\nv(-1)")
+      assert capture_iex("1\n2\nv(2)") == capture_iex("1\n2\nv()")
+    end
+
+    test "returns proper error when trying to access history out of bounds" do
+      # We evaluate 22 statements as 20 is the current limit for iex history
+      assert capture_iex("""
+             \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
+             v(1)
+             """) =~
+               "(RuntimeError) v(1) is out of bounds, the currently preserved history ranges from 3 to 22"
+    end
 
-           :ok
-           """
+    test "negative lookup works properly after crashes" do
+      capture =
+        capture_iex("""
+            \n
+            \n
+            \n
+            Process.exit(self(), :some_reason)\n
+            :target_value
+            v(-1)
+        """)
+
+      assert capture |> String.split("\n") |> List.last() == ":target_value"
+    end
   end
 
-  test "flush helper" do
-    assert capture_io(fn -> send self(), :hello; flush end) == ":hello\n"
+  describe "flush" do
+    test "flushes messages" do
+      assert capture_io(fn ->
+               send(self(), :hello)
+               flush()
+             end) == ":hello\n"
+    end
   end
 
-  test "pwd helper" do
-    File.cd! iex_path, fn ->
-      assert capture_io(fn -> pwd end) =~ ~r"lib[\\/]iex\n$"
+  describe "pwd" do
+    test "prints the working directory" do
+      File.cd!(iex_path(), fn ->
+        assert capture_io(fn -> pwd() end) =~ ~r"lib[\\/]iex\n$"
+      end)
     end
   end
 
-  test "ls helper" do
-    File.cd! iex_path, fn ->
-      paths = capture_io(fn -> ls end)
-              |> String.split
-              |> Enum.map(&String.strip(&1))
+  describe "ls" do
+    test "lists the current directory" do
+      File.cd!(iex_path(), fn ->
+        paths =
+          capture_io(fn -> ls() end)
+          |> String.split()
+          |> Enum.map(&String.trim/1)
+
+        assert "ebin" in paths
+        assert "mix.exs" in paths
+      end)
+    end
 
-      assert "ebin" in paths
-      assert "mix.exs" in paths
+    test "lists the given directory" do
+      assert capture_io(fn -> ls("~") end) == capture_io(fn -> ls(System.user_home()) end)
+    end
 
-      assert capture_io(fn -> ls "~" end) ==
-             capture_io(fn -> ls System.user_home end)
+    test "returns an existing file" do
+      File.cd!(iex_path(), fn ->
+        assert capture_io(fn -> ls("mix.exs") end) == Path.join(iex_path(), "mix.exs") <> "\n"
+      end)
     end
-  end
 
-  test "import_file helper" do
-    with_file "dot-iex", "variable = :hello\nimport IO", fn ->
-      assert "** (RuntimeError) undefined function: variable/0" <> _
-             = capture_iex("variable")
-      assert "** (RuntimeError) undefined function: puts/1" <> _
-             = capture_iex("puts \"hi\"")
+    test "prints an error if directory doesn't exist" do
+      File.cd!(iex_path(), fn ->
+        assert capture_io(fn -> ls("unknown_dir") end) ==
+                 "No such file or directory unknown_dir\n"
+      end)
+    end
+
+    test "prints an error if part of the path is not a dir (enotdir)" do
+      File.cd!(iex_path(), fn ->
+        path = Path.join("mix.exs", "foo")
 
-      assert capture_iex("import_file \"dot-iex\"\nvariable\nputs \"hi\"")
-             == "nil\n:hello\nhi\n:ok"
+        assert capture_io(fn -> ls(path) end) ==
+                 "No such file or directory #{path}\n"
+      end)
     end
   end
 
-  test "import_file nested" do
-    dot   = "parent = true\nimport_file \"dot-iex-1\""
-    dot_1 = "variable = :hello\nimport IO"
+  describe "exports" do
+    test "prints module exports" do
+      exports = capture_io(fn -> exports(IEx.Autocomplete) end)
+      assert exports == "expand/1      expand/2      exports/1     remsh/1       \n"
+    end
 
-    with_file ["dot-iex", "dot-iex-1"], [dot, dot_1], fn ->
-      assert "** (RuntimeError) undefined function: parent/0" <> _
-             = capture_iex("parent")
-      assert "** (RuntimeError) undefined function: variable/0" <> _
-             = capture_iex("variable")
-      assert "** (RuntimeError) undefined function: puts/1" <> _
-             = capture_iex("puts \"hi\"")
+    test "handles long function names" do
+      exports = capture_io(fn -> exports(Calendar.UTCOnlyTimeZoneDatabase) end)
 
-      assert capture_iex("import_file \"dot-iex\"\nvariable\nputs \"hi\"\nparent")
-             == "nil\n:hello\nhi\n:ok\ntrue"
+      assert exports ==
+               "time_zone_period_from_utc_iso_days/2 time_zone_periods_from_wall_datetime/2 \n"
     end
   end
 
-  test "c helper" do
-    assert_raise UndefinedFunctionError, "undefined function: Sample.run/0", fn ->
-      Sample.run
+  describe "import_file" do
+    test "imports a file" do
+      with_file("dot-iex", "variable = :hello\nimport IO", fn ->
+        assert capture_io(:stderr, fn -> capture_iex("variable") end) =~
+                 "undefined variable \"variable\""
+
+        assert capture_io(:stderr, fn -> capture_iex("puts \"hi\"") end) =~
+                 "undefined function puts/1"
+
+        assert capture_iex("import_file \"dot-iex\"\nvariable\nputs \"hi\"") ==
+                 "IO\n:hello\nhi\n:ok"
+      end)
+    end
+
+    test "imports a file that imports another file" do
+      dot = "parent = true\nimport_file \"dot-iex-1\""
+      dot_1 = "variable = :hello\nimport IO"
+
+      with_file(["dot-iex", "dot-iex-1"], [dot, dot_1], fn ->
+        assert capture_io(:stderr, fn -> capture_iex("parent") end) =~
+                 "undefined variable \"parent\""
+
+        assert capture_io(:stderr, fn -> capture_iex("puts \"hi\"") end) =~
+                 "undefined function puts/1"
+
+        assert capture_iex("import_file \"dot-iex\"\nvariable\nputs \"hi\"\nparent") ==
+                 "IO\n:hello\nhi\n:ok\ntrue"
+      end)
+    end
+
+    test "raises if file is missing" do
+      failing = capture_iex("import_file \"nonexistent\"")
+      assert "** (File.Error) could not read file" <> _ = failing
+      assert failing =~ "no such file or directory"
+    end
+
+    test "does not raise if file is missing and using import_file_if_available" do
+      assert "nil" == capture_iex("import_file_if_available \"nonexistent\"")
+    end
+
+    test "circular imports" do
+      dot_1 = "import_file \"dot-iex-2\""
+      dot_2 = "import_file \"dot-iex-1\""
+
+      with_file(["dot-iex-1", "dot-iex-2"], [dot_1, dot_2], fn ->
+        assert capture_io(:stderr, fn ->
+                 assert capture_iex(":ok", [], dot_iex: "dot-iex-1") == ":ok"
+               end) =~ "dot-iex-2 was already imported, skipping circular file imports"
+      end)
     end
+  end
 
-    filename = "sample.ex"
-    with_file filename, test_module_code, fn ->
-      assert c(filename) == [Sample]
-      assert Sample.run == :run
+  describe "import_if_available" do
+    test "imports a module only if available" do
+      assert "nil" == capture_iex("import_if_available NoSuchModule")
+      assert "[1, 2, 3]" == capture_iex("import_if_available Integer; digits 123")
+
+      assert "[1, 2, 3]" ==
+               capture_iex("import_if_available Integer, only: [digits: 1]; digits 123")
     end
-  after
-    cleanup_modules([Sample])
   end
 
-  test "c helper with full path" do
-    filename = "sample.ex"
-    with_file filename, test_module_code, fn ->
-      assert c(Path.expand(filename)) == [Sample]
-      assert Sample.run == :run
+  describe "use_if_available" do
+    test "uses a module only if available" do
+      assert "nil" == capture_iex("use_if_available NoSuchModule")
     end
-  after
-    cleanup_modules([Sample])
   end
 
-  test "c helper multiple modules" do
-    assert_raise UndefinedFunctionError, "undefined function: Sample.run/0", fn ->
-      Sample.run
+  describe "iex> |> (and other binary operators)" do
+    test "passes previous result to the pipe" do
+      Enum.each([:~>>, :<<~, :~>, :<~, :<~>], fn op ->
+        assert capture_io(:stderr, fn -> capture_iex("42\n  #{op} IO.puts()") end) =~
+                 "undefined function #{op}/2"
+      end)
+
+      assert capture_iex("+42") =~ "42"
+      assert capture_iex("-42") =~ "-42"
+      assert capture_iex("42\n |> IO.inspect(label: \"foo\")") =~ "foo: 42"
+      assert capture_iex("[42]\n++ [24]\n|> IO.inspect(label: \"foo\")") =~ "foo: [42, 24]"
+      assert capture_iex("|> IO.puts()") =~ "(RuntimeError) v(-1) is out of bounds"
     end
 
-    filename = "sample.ex"
-    with_file filename, test_module_code <> "\n" <> another_test_module, fn ->
-      assert c(filename) |> Enum.sort == [Sample, Sample2]
-      assert Sample.run == :run
-      assert Sample2.hello == :world
+    test "raises if previous expression was a match" do
+      assert capture_iex("x = 42\n|> IO.puts()") =~
+               "surround the whole pipeline with parentheses '|>'"
+
+      assert capture_iex("%{x: x} = %{x: 42}\n|> IO.puts()") =~
+               "surround the whole pipeline with parentheses '|>'"
+
+      assert capture_iex("%{x: x} = map = %{x: 42}\n|> IO.puts()") =~
+               "surround the whole pipeline with parentheses '|>'"
     end
-  after
-    cleanup_modules([Sample, Sample2])
   end
 
-  test "c helper list" do
-    assert_raise UndefinedFunctionError, "undefined function: Sample.run/0", fn ->
-      Sample.run
+  describe "c" do
+    test "compiles a file" do
+      assert_raise UndefinedFunctionError, ~r"function Sample\.run/0 is undefined", fn ->
+        Sample.run()
+      end
+
+      filename = "sample.ex"
+
+      with_file(filename, test_module_code(), fn ->
+        assert c(Path.expand(filename)) == [Sample]
+        refute File.exists?("Elixir.Sample.beam")
+        assert Sample.run() == :run
+      end)
+    after
+      cleanup_modules([Sample])
+    end
+
+    test "handles errors" do
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        with_file("sample.ex", "raise \"oops\"", fn ->
+          assert_raise CompileError, fn -> c("sample.ex") end
+        end)
+      end)
+    end
+
+    test "compiles a file with multiple modules " do
+      assert_raise UndefinedFunctionError, ~r"function Sample.run/0 is undefined", fn ->
+        Sample.run()
+      end
+
+      filename = "sample.ex"
+
+      with_file(filename, test_module_code() <> "\n" <> another_test_module(), fn ->
+        assert c(filename) |> Enum.sort() == [Sample, Sample2]
+        assert Sample.run() == :run
+        assert Sample2.hello() == :world
+      end)
+    after
+      cleanup_modules([Sample, Sample2])
+    end
+
+    test "compiles multiple modules" do
+      assert_raise UndefinedFunctionError, ~r"function Sample.run/0 is undefined", fn ->
+        Sample.run()
+      end
+
+      filenames = ["sample1.ex", "sample2.ex"]
+
+      with_file(filenames, [test_module_code(), another_test_module()], fn ->
+        assert c(filenames) |> Enum.sort() == [Sample, Sample2]
+        assert Sample.run() == :run
+        assert Sample2.hello() == :world
+      end)
+    after
+      cleanup_modules([Sample, Sample2])
+    end
+
+    test "compiles Erlang modules" do
+      assert_raise UndefinedFunctionError, ~r"function :sample.hello/0 is undefined", fn ->
+        :sample.hello()
+      end
+
+      filename = "sample.erl"
+
+      with_file(filename, erlang_module_code(), fn ->
+        assert c(filename) == [:sample]
+        assert :sample.hello() == :world
+        refute File.exists?("sample.beam")
+      end)
+    after
+      cleanup_modules([:sample])
+    end
+
+    test "skips unknown files" do
+      assert_raise UndefinedFunctionError, ~r"function :sample.hello/0 is undefined", fn ->
+        :sample.hello()
+      end
+
+      filenames = ["sample.erl", "not_found.ex", "sample2.ex"]
+
+      with_file(filenames, [erlang_module_code(), "", another_test_module()], fn ->
+        assert c(filenames) |> Enum.sort() == [Sample2, :sample]
+        assert :sample.hello() == :world
+        assert Sample2.hello() == :world
+      end)
+    after
+      cleanup_modules([:sample, Sample2])
     end
 
-    filenames = ["sample1.ex", "sample2.ex"]
-    with_file filenames, [test_module_code, another_test_module], fn ->
-      assert c(filenames) |> Enum.sort == [Sample, Sample2]
-      assert Sample.run == :run
-      assert Sample2.hello == :world
+    test "compiles file in path" do
+      assert_raise UndefinedFunctionError, ~r"function Sample\.run/0 is undefined", fn ->
+        Sample.run()
+      end
+
+      filename = "sample.ex"
+
+      with_file(filename, test_module_code(), fn ->
+        assert c(filename, ".") == [Sample]
+        assert File.exists?("Elixir.Sample.beam")
+        assert Sample.run() == :run
+      end)
+    after
+      cleanup_modules([Sample])
     end
-  after
-    cleanup_modules([Sample, Sample2])
   end
 
-  test "c helper erlang" do
-    assert_raise UndefinedFunctionError, "undefined function: :sample.hello/0", fn ->
-      :sample.hello
+  describe "l" do
+    test "returns error tuple for nonexistent modules" do
+      assert l(:nonexistent_module) == {:error, :nofile}
+    end
+
+    test "loads a given module" do
+      assert_raise UndefinedFunctionError,
+                   ~r"function Sample.run/0 is undefined",
+                   fn -> Sample.run() end
+
+      filename = "sample.ex"
+
+      with_file(filename, test_module_code(), fn ->
+        assert c(filename, ".") == [Sample]
+        assert Sample.run() == :run
+
+        File.write!(filename, "defmodule Sample do end")
+        elixirc(["sample.ex"])
+        assert l(Sample) == {:module, Sample}
+
+        assert_raise UndefinedFunctionError,
+                     ~r"function Sample.run/0 is undefined",
+                     fn -> Sample.run() end
+      end)
+    after
+      # Clean up the old version left over after l()
+      cleanup_modules([Sample])
     end
+  end
+
+  describe "nl" do
+    @tag :capture_log
+    test "loads a given module on the given nodes" do
+      assert nl([node()], :lists) == {:ok, [{:nonode@nohost, :error, :sticky_directory}]}
 
-    filename = "sample.erl"
-    with_file filename, erlang_module_code, fn ->
-      assert c(filename) == [:sample]
-      assert :sample.hello == :world
+      assert nl([node()], HelperExampleModule) ==
+               {:ok, [{:nonode@nohost, :loaded, HelperExampleModule}]}
+
+      assert nl(:nonexistent_module) == {:error, :nofile}
+
+      assert nl([:nosuchnode@badhost], HelperExampleModule) ==
+               {:ok, [{:nosuchnode@badhost, :badrpc, :noconnection}]}
     end
-  after
-    cleanup_modules([:sample])
   end
 
+  describe "r" do
+    @describetag :requires_source
+
+    test "raises when reloading a nonexistent module" do
+      assert_raise ArgumentError, "could not load nor find module: :nonexistent_module", fn ->
+        r(:nonexistent_module)
+      end
+    end
+
+    test "reloads Elixir modules" do
+      message = ~r"function Sample.run/0 is undefined \(module Sample is not available\)"
+
+      assert_raise UndefinedFunctionError, message, fn ->
+        Sample.run()
+      end
+
+      filename = "sample.ex"
+
+      with_file(filename, test_module_code(), fn ->
+        assert capture_io(:stderr, fn ->
+                 assert c(filename, ".") == [Sample]
+                 assert Sample.run() == :run
+
+                 File.write!(filename, "defmodule Sample do end")
+                 assert {:reloaded, [Sample]} = r(Sample)
+                 assert {:reloaded, [Sample]} = r([Sample])
+
+                 message = "function Sample.run/0 is undefined or private"
 
-  test "c helper skips unknown files" do
-    assert_raise UndefinedFunctionError, "undefined function: :sample.hello/0", fn ->
-      :sample.hello
+                 assert_raise UndefinedFunctionError, message, fn ->
+                   Sample.run()
+                 end
+               end) =~
+                 "redefining module Sample (current version loaded from Elixir.Sample.beam)"
+      end)
+    after
+      # Clean up old version produced by the r helper
+      cleanup_modules([Sample])
     end
 
-   filenames = ["sample.erl", "not_found.ex", "sample2.ex"]
-   with_file filenames, [erlang_module_code, "", another_test_module], fn ->
-      assert c(filenames) |> Enum.sort == [Sample2, :sample]
-      assert :sample.hello == :world
-      assert Sample2.hello == :world
+    test "reloads Erlang modules" do
+      assert_raise UndefinedFunctionError, ~r"function :sample.hello/0 is undefined", fn ->
+        :sample.hello()
+      end
+
+      filename = "sample.erl"
+
+      with_file(filename, erlang_module_code(), fn ->
+        assert c(filename, ".") == [:sample]
+        assert :sample.hello() == :world
+
+        File.write!(filename, other_erlang_module_code())
+        assert {:reloaded, [:sample]} = r(:sample)
+        assert {:reloaded, [:sample]} = r([:sample])
+        assert :sample.hello() == :bye
+      end)
+    after
+      cleanup_modules([:sample])
     end
-  after
-    cleanup_modules([:sample, Sample2])
   end
 
+  describe "pid/1,3" do
+    test "builds a PID from string" do
+      assert inspect(pid("0.32767.0")) == "#PID<0.32767.0>"
+      assert inspect(pid("0.5.0")) == "#PID<0.5.0>"
 
-  test "l helper" do
-    assert_raise UndefinedFunctionError, "undefined function: Sample.run/0", fn ->
-      Sample.run
+      assert_raise ArgumentError, fn ->
+        pid("0.6.-6")
+      end
     end
 
-    assert l(:non_existent_module) == {:error, :nofile}
+    test "builds a PID from atom" do
+      assert inspect(pid(:init)) == "#PID<0.0.0>"
 
-    filename = "sample.ex"
-    with_file filename, test_module_code, fn ->
-      assert c(filename) == [Sample]
-      assert Sample.run == :run
+      assert_raise ArgumentError, fn ->
+        pid(:random_atom_ZM6pX6VwQx)
+      end
+    end
 
-      File.write! filename, "defmodule Sample do end"
-      elixirc("sample.ex")
+    test "builds a PID from integers" do
+      assert inspect(pid(0, 32767, 0)) == "#PID<0.32767.0>"
+      assert inspect(pid(0, 5, 0)) == "#PID<0.5.0>"
 
-      assert l(Sample) == {:module, Sample}
-      assert_raise UndefinedFunctionError, "undefined function: Sample.run/0", fn ->
-        Sample.run
+      assert_raise FunctionClauseError, fn ->
+        pid(0, 6, -6)
       end
     end
-  after
-    # Clean up the old version left over after l()
-    cleanup_modules([Sample])
   end
 
-  test "r helper unavailable" do
-    assert_raise ArgumentError, "could not load nor find module: :non_existent_module", fn ->
-      r :non_existent_module
+  describe "port" do
+    test "builds a port from string" do
+      assert inspect(port("0.8080")) == "#Port<0.8080>"
+      assert inspect(port("0.0")) == "#Port<0.0>"
+
+      assert_raise ArgumentError, fn ->
+        port("0.-6")
+      end
+    end
+
+    test "builds a port from integers" do
+      assert inspect(port(0, 8080)) == "#Port<0.8080>"
+      assert inspect(port(0, 0)) == "#Port<0.0>"
+
+      assert_raise FunctionClauseError, fn ->
+        port(-1, -6)
+      end
     end
   end
 
-  test "r helper elixir" do
-    assert_raise UndefinedFunctionError, "undefined function: Sample.run/0", fn ->
-      Sample.run
+  describe "ref" do
+    test "builds a ref from string" do
+      ref = make_ref()
+      [_, inner, _] = String.split(inspect(ref), ["<", ">"])
+      assert ref(inner) == ref
+
+      assert_raise ArgumentError, fn ->
+        ref("0.6.6.-6")
+      end
     end
 
-    filename = "sample.ex"
-    with_file filename, test_module_code, fn ->
-      assert capture_io(:stderr, fn ->
-        assert c(filename) == [Sample]
-        assert Sample.run == :run
+    test "builds a ref from integers" do
+      ref = make_ref()
+      [_, inner, _] = String.split(inspect(ref), ["<", ">"])
+      [p1, p2, p3, p4] = inner |> String.split(".") |> Enum.map(&String.to_integer/1)
+      assert ref(p1, p2, p3, p4) == ref
+
+      assert_raise FunctionClauseError, fn ->
+        ref(0, 6, 6, -6)
+      end
+    end
+  end
+
+  describe "i" do
+    test "prints information about the data type" do
+      assert capture_io(fn -> i(:ok) end) =~ """
+             Term
+               :ok
+             Data type
+               Atom
+             Reference modules
+               Atom\
+             """
+    end
+
+    test "handles functions that don't display result" do
+      assert capture_io(fn -> i(IEx.dont_display_result()) end) =~ """
+             Term
+               :"do not show this result in output"
+             Data type
+               Atom
+             Description
+               This atom is returned by IEx when a function that should not print its
+               return value on screen is executed.\
+             """
+    end
+
+    defmodule MyIExInfoModule do
+      defstruct []
+
+      defimpl IEx.Info do
+        def info(_), do: [{"A", "it's A"}, {:b, "it's :b"}, {~c"c", "it's 'c'"}]
+      end
+    end
 
-        File.write! filename, "defmodule Sample do end"
-        assert {:reloaded, Sample, [Sample]} = r(Sample)
-        assert_raise UndefinedFunctionError, "undefined function: Sample.run/0", fn ->
-          Sample.run
-        end
-      end) =~ ~r"^.*?sample\.ex:1: warning: redefining module Sample\n$"
+    test "uses the IEx.Info protocol" do
+      assert capture_io(fn -> i(%MyIExInfoModule{}) end) =~ """
+             Term
+               %IEx.HelpersTest.MyIExInfoModule{}
+             A
+               it's A
+             b
+               it's :b
+             c
+               it's 'c'
+             """
+    after
+      cleanup_modules([MyIExInfoModule])
     end
-  after
-    # Clean up old version produced by the r helper
-    cleanup_modules([Sample])
   end
 
-  test "r helper erlang" do
-    assert_raise UndefinedFunctionError, "undefined function: :sample.hello/0", fn ->
-      :sample.hello
+  describe "process_info/1" do
+    test "returns information about a process" do
+      result = capture_io(fn -> process_info(self()) end)
+
+      assert result =~ "Process #{inspect(self())}"
+      assert result =~ "## Overview"
+      assert result =~ "Initial call"
+      assert result =~ "## Memory"
+      assert result =~ "## Current stacktrace"
+      assert result =~ "IEx.Helpers.process_info/1"
+
+      refute result =~ "## Links"
+      refute result =~ "## Monitors"
     end
 
-    filename = "sample.erl"
-    with_file filename, erlang_module_code, fn ->
-      assert c(filename) == [:sample]
-      assert :sample.hello == :world
+    test "includes process links and monitors" do
+      pid =
+        spawn_link(fn ->
+          Process.register(self(), :iex_process_info_link_test)
+          Process.sleep(:infinity)
+        end)
+
+      Process.monitor(pid)
 
-      File.write!(filename, other_erlang_module_code)
-      assert {:reloaded, :sample, [:sample]} = r(:sample)
-      assert :sample.hello == :bye
+      result = capture_io(fn -> process_info(self()) end)
+      assert result =~ "## Links"
+      assert result =~ "## Monitors"
+      assert result =~ ":iex_process_info_link_test"
     end
-  after
-    cleanup_modules([:sample])
   end
 
   defp test_module_code do
@@ -352,22 +1731,22 @@ defmodule IEx.HelpersTest do
   end
 
   defp cleanup_modules(mods) do
-    Enum.each mods, fn mod ->
+    Enum.each(mods, fn mod ->
       File.rm("#{mod}.beam")
       :code.purge(mod)
-      true = :code.delete(mod)
-    end
+      :code.delete(mod)
+    end)
   end
 
   defp with_file(names, codes, fun) when is_list(names) and is_list(codes) do
-    Enum.each Enum.zip(names, codes), fn {name, code} ->
-      File.write! name, code
-    end
+    Enum.each(Enum.zip(names, codes), fn {name, code} ->
+      File.write!(name, code)
+    end)
 
     try do
       fun.()
     after
-      Enum.each names, &File.rm/1
+      Enum.each(names, &File.rm/1)
     end
   end
 
@@ -377,14 +1756,14 @@ defmodule IEx.HelpersTest do
 
   defp elixirc(args) do
     executable = Path.expand("../../../../bin/elixirc", __DIR__)
-    System.cmd("#{executable}#{executable_extension} #{args}")
+    System.cmd("#{executable}#{executable_extension()}", args, stderr_to_stdout: true)
   end
 
   defp iex_path do
-    Path.expand "../..", __DIR__
+    Path.expand("../..", __DIR__)
   end
 
-  if match? {:win32, _}, :os.type do
+  if match?({:win32, _}, :os.type()) do
     defp executable_extension, do: ".bat"
   else
     defp executable_extension, do: ""
diff --git a/lib/iex/test/iex/info_test.exs b/lib/iex/test/iex/info_test.exs
new file mode 100644
index 00000000000..b018ac178f8
--- /dev/null
+++ b/lib/iex/test/iex/info_test.exs
@@ -0,0 +1,270 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule IEx.InfoTest do
+  use ExUnit.Case
+
+  import ExUnit.CaptureLog
+
+  alias IEx.Info
+
+  defmodule Foo do
+    defstruct [:foo]
+  end
+
+  test "tuples" do
+    assert Info.info({:ok, "good!"}) == [{"Data type", "Tuple"}, {"Reference modules", "Tuple"}]
+  end
+
+  describe "atoms" do
+    test "loaded module (without docs)" do
+      info = Info.info(Foo)
+      assert get_key(info, "Data type") == "Atom"
+
+      assert get_key(info, "Description") ==
+               "Call IEx.InfoTest.Foo.module_info() to access metadata."
+
+      assert get_key(info, "Raw representation") == ~s(:"Elixir.IEx.InfoTest.Foo")
+    end
+
+    @tag :requires_source
+    test "loaded module (with source)" do
+      info = Info.info(Foo)
+      assert get_key(info, "Source") == Path.relative_to_cwd(__ENV__.file)
+    end
+
+    test "loaded module (with docs)" do
+      info = Info.info(List)
+
+      description = """
+      Use h(List) to access its documentation.
+      Call List.module_info() to access metadata.\
+      """
+
+      assert get_key(info, "Description") == description
+    end
+
+    test "module that is also a protocol" do
+      info = Info.info(String.Chars)
+      protocol_info = get_key(info, "Protocol")
+      assert protocol_info =~ "This module is a protocol"
+      assert protocol_info =~ "Atom"
+      assert protocol_info =~ "BitString"
+    end
+
+    test "module-like atom (Foo)" do
+      info = Info.info(NonexistentModuleAtom)
+      assert get_key(info, "Raw representation") == ~s(:"Elixir.NonexistentModuleAtom")
+    end
+
+    test "regular atom" do
+      assert Info.info(:foo) == [{"Data type", "Atom"}, {"Reference modules", "Atom"}]
+    end
+
+    test "do not log errors if module exists with different casing" do
+      assert capture_log(fn -> Info.info(Datetime) end) == ""
+    end
+  end
+
+  describe "lists" do
+    test "charlists" do
+      info = Info.info(~c"foo")
+      assert get_key(info, "Description") =~ "This is a list of integers that is printed"
+      assert get_key(info, "Raw representation") == "[102, 111, 111]"
+    end
+
+    test "keyword lists" do
+      info = Info.info(a: 1, b: 2)
+      assert get_key(info, "Description") =~ "This is what is referred to as a \"keyword list\""
+    end
+
+    test "regular lists" do
+      assert get_key(Info.info([]), "Reference modules") == "List"
+      assert get_key(Info.info([:foo, :bar, :baz]), "Reference modules") == "List"
+    end
+  end
+
+  describe "bitstring" do
+    test "strings" do
+      info = Info.info("føø")
+      assert get_key(info, "Byte size") == 5
+      assert get_key(info, "Description") =~ "This is a string: a UTF-8 encoded binary"
+      assert get_key(info, "Raw representation") == "<<102, 195, 184, 195, 184>>"
+    end
+
+    test "non-printable string" do
+      info = Info.info(<<"foo", 0, "bar">>)
+      description = get_key(info, "Description")
+
+      assert get_key(info, "Byte size") == 7
+      assert description =~ "This is a string"
+      assert description =~ "It's printed with the `<<>>`"
+      assert description =~ "the first non-printable code point being\n`<<0>>`"
+    end
+
+    test "binary" do
+      info = Info.info(<<255, 255>>)
+      assert get_key(info, "Description") =~ "This is a binary: a collection of bytes"
+    end
+
+    test "bitstring" do
+      info = Info.info(<<1::1>>)
+      assert get_key(info, "Bits size") == 1
+      assert get_key(info, "Description") =~ "This is a bitstring"
+    end
+  end
+
+  test "integers" do
+    assert Info.info(99) == [{"Data type", "Integer"}, {"Reference modules", "Integer"}]
+  end
+
+  test "float" do
+    assert Info.info(3.14) == [{"Data type", "Float"}, {"Reference modules", "Float"}]
+  end
+
+  describe "functions" do
+    test "named function" do
+      info = Info.info(&String.length/1)
+      assert get_key(info, "Type") == "external"
+      assert get_key(info, "Arity") == 1
+    end
+
+    test "anonymous function" do
+      info = Info.info(fn -> :ok end)
+      assert get_key(info, "Type") == "local"
+      assert get_key(info, "Arity") == 0
+      assert get_key(info, "Description") == "This is an anonymous function."
+    end
+  end
+
+  test "PIDs" do
+    pid = spawn_link(fn -> Process.sleep(1000) end)
+
+    info = Info.info(pid)
+    assert get_key(info, "Alive") == true
+    assert get_key(info, "Name") == "not registered"
+    assert get_key(info, "Links") == inspect(self())
+    assert get_key(info, "Message queue length") == 0
+
+    Process.register(pid, :iex_info_registered_pid)
+    Process.unlink(pid)
+    send(pid, :oops)
+    info = Info.info(pid)
+    assert get_key(info, "Name") == ":iex_info_registered_pid"
+    assert get_key(info, "Links") == "none"
+    assert get_key(info, "Message queue length") == 1
+
+    Process.exit(pid, :kill)
+    assert get_key(Info.info(pid), "Alive") == false
+  end
+
+  test "ports" do
+    {:ok, port} = :gen_udp.open(0)
+    assert get_key(Info.info(port), "Open") == true
+    :ok = :gen_udp.close(port)
+    assert get_key(Info.info(port), "Open") == false
+  end
+
+  test "references" do
+    assert Info.info(make_ref()) == [{"Data type", "Reference"}]
+  end
+
+  describe "calendar types" do
+    test "date" do
+      {:ok, date} = Date.new(2017, 1, 1)
+      info = Info.info(date)
+      assert get_key(info, "Data type") == "Date"
+
+      assert get_key(info, "Raw representation") ==
+               "%Date{year: 2017, month: 1, day: 1, calendar: Calendar.ISO}"
+
+      assert get_key(info, "Reference modules") == "Date, Calendar, Map"
+      assert get_key(info, "Description") =~ "a date"
+      assert get_key(info, "Description") =~ "`~D`"
+    end
+
+    test "time" do
+      {:ok, time} = Time.new(23, 59, 59)
+      info = Info.info(time)
+      assert get_key(info, "Data type") == "Time"
+
+      assert get_key(info, "Raw representation") ==
+               "%Time{hour: 23, minute: 59, second: 59, microsecond: {0, 0}, calendar: Calendar.ISO}"
+
+      assert get_key(info, "Reference modules") == "Time, Calendar, Map"
+      assert get_key(info, "Description") =~ "a time"
+      assert get_key(info, "Description") =~ "`~T`"
+    end
+
+    test "datetime" do
+      {:ok, date} = Date.new(2017, 1, 1)
+      {:ok, time} = Time.new(23, 59, 59)
+      {:ok, date_time} = DateTime.new(date, time)
+      info = Info.info(date_time)
+      assert get_key(info, "Data type") == "DateTime"
+
+      assert get_key(info, "Raw representation") ==
+               "%DateTime{year: 2017, month: 1, day: 1, hour: 23, minute: 59, second: 59, time_zone: \"Etc/UTC\", zone_abbr: \"UTC\", utc_offset: 0, std_offset: 0, microsecond: {0, 0}, calendar: Calendar.ISO}"
+
+      assert get_key(info, "Reference modules") == "DateTime, Calendar, Map"
+      assert get_key(info, "Description") =~ "a datetime"
+      assert get_key(info, "Description") =~ "`~U`"
+    end
+
+    test "naive datetime" do
+      {:ok, time} = NaiveDateTime.new(2017, 1, 1, 23, 59, 59)
+      info = Info.info(time)
+      assert get_key(info, "Data type") == "NaiveDateTime"
+
+      assert get_key(info, "Raw representation") ==
+               "%NaiveDateTime{year: 2017, month: 1, day: 1, hour: 23, minute: 59, second: 59, microsecond: {0, 0}, calendar: Calendar.ISO}"
+
+      assert get_key(info, "Reference modules") == "NaiveDateTime, Calendar, Map"
+
+      assert get_key(info, "Description") =~
+               ~S{a "naive" datetime (that is, a datetime without a time zone)}
+
+      assert get_key(info, "Description") =~ "`~N`"
+    end
+  end
+
+  test "Regex" do
+    info = Info.info(~r/(ab)+c/)
+    assert get_key(info, "Data type") == "Regex"
+    assert get_key(info, "Description")
+    assert get_key(info, "Raw representation") =~ "%Regex{re_pattern: {:re_pattern, "
+    assert get_key(info, "Reference modules") == "Regex, :re"
+  end
+
+  test "Range" do
+    info = Info.info(1..10//2)
+    assert get_key(info, "Data type") == "Range"
+    assert get_key(info, "Description")
+    assert get_key(info, "Raw representation") == "%Range{first: 1, last: 10, step: 2}"
+    assert get_key(info, "Reference modules") == "Range"
+  end
+
+  test "maps" do
+    info = Info.info(%{foo: "bar"})
+    assert get_key(info, "Data type") == "Map"
+    assert get_key(info, "Reference modules") == "Map"
+  end
+
+  test "structs" do
+    info = Info.info(%Foo{})
+    assert get_key(info, "Data type") == "IEx.InfoTest.Foo"
+
+    assert get_key(info, "Description") ==
+             "This is a struct. Structs are maps with a __struct__ key."
+
+    assert get_key(info, "Reference modules") == "IEx.InfoTest.Foo, Map"
+  end
+
+  defp get_key(info, key) do
+    {^key, value} = List.keyfind(info, key, 0)
+    value
+  end
+end
diff --git a/lib/iex/test/iex/interaction_test.exs b/lib/iex/test/iex/interaction_test.exs
index 9670430e663..26635c4f005 100644
--- a/lib/iex/test/iex/interaction_test.exs
+++ b/lib/iex/test/iex/interaction_test.exs
@@ -1,15 +1,18 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule IEx.InteractionTest do
   use IEx.Case
 
-  ## Basic interaction
-
   test "whole output" do
     assert capture_io("IO.puts \"Hello world\"", fn ->
-      IEx.Server.start([dot_iex_path: ""], {IEx, :dont_display_result, []})
-    end) =~ "Interactive Elixir (#{System.version}) - press Ctrl+C to exit (type h() ENTER for help)" <>
-            "\niex(1)> Hello world\n:ok\niex(2)>"
+             IEx.Server.run(dot_iex: "")
+           end) =~
+             "Interactive Elixir (#{System.version()}) - press Ctrl+C to exit (type h() ENTER for help)" <>
+               "\niex(1)> Hello world\n:ok\niex(2)>"
   end
 
   test "empty input" do
@@ -20,29 +23,57 @@ defmodule IEx.InteractionTest do
     assert capture_iex("1 + 2") == "3"
   end
 
+  test "omits error color if exception has ansi reset character" do
+    enabled? = IO.ANSI.enabled?()
+    Application.put_env(:elixir, :ansi_enabled, true)
+
+    expected = """
+    ** (SyntaxError) invalid syntax found on iex:1:4:
+        \e[31merror:\e[0m syntax error before: '='
+        │
+      1 │ a += 2
+        │ \e[31m   ^\e[0m
+        │
+        └─ iex:1:4
+    """
+
+    opts = [colors: [enabled: true]]
+    output = capture_iex("a += 2", opts)
+
+    refute String.starts_with?(output, IO.ANSI.red())
+    assert output =~ expected
+
+    Application.put_env(:elixir, :ansi_enabled, enabled?)
+  end
+
+  test "invalid input" do
+    output = capture_iex("if true do ) false end")
+
+    assert output =~ "** (MismatchedDelimiterError) mismatched delimiter found on iex:1:12:"
+    assert output =~ "unexpected token: )"
+    assert output =~ "iex:1:12"
+    assert output =~ "if true do ) false end"
+    assert output =~ "└ unclosed delimiter"
+    assert output =~ "└ mismatched closing delimiter"
+  end
+
   test "multiple vars" do
     code = """
-    << a, b, c, d, e, f, g, h, i, j :: binary >> = <<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>>
-    << a, b, c, d, e, f, g, h, i, x :: binary >> = <<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>>
+    <<a, b, c, d, e, f, g, h, i, j :: binary>> = <<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>>
+    <<a, b, c, d, e, f, g, h, i, x :: binary>> = <<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>>
     x
     """
-    assert capture_iex(code) =~ "10"
-  end
 
-  test "exception" do
-    exception = Regex.escape("** (ArithmeticError) bad argument in arithmetic expression")
-    assert capture_iex("1 + :atom\n:this_is_still_working")
-           =~ ~r/^#{exception}.+\n:this_is_still_working$/s
-    refute capture_iex("1 + :atom\n:this_is_still_working")
-           =~ ~r/erl_eval/s
+    assert capture_iex(code) =~ "10"
   end
 
-  test "empty history at the start" do
-    assert capture_iex("v(-1)") =~ "** (RuntimeError) v(-1) is out of bounds"
-  end
+  test "code escape" do
+    code = """
+    1 \\
+    + 2
+    """
 
-  test "empty history at the start redux" do
-    assert capture_iex("v(1)") =~ "** (RuntimeError) v(1) is out of bounds"
+    assert capture_iex(code) =~ "3"
   end
 
   test "no break" do
@@ -51,6 +82,7 @@ defmodule IEx.InteractionTest do
       b
       c
     """
+
     assert capture_iex(input) == ""
   end
 
@@ -61,120 +93,275 @@ defmodule IEx.InteractionTest do
       c
     #iex:break
     """
-    assert capture_iex(input) =~ "** (TokenMissingError) iex:1: incomplete expression"
-  end
 
-  test "invalid input" do
-    assert capture_iex("if true do ) false end") =~ "** (SyntaxError) iex:1: \"do\" starting at"
-  end
+    output = capture_iex(input)
 
-  test "undefined function" do
-    assert "** (RuntimeError) undefined function: format/0"   <> _ = capture_iex("format")
-    assert "** (RuntimeError) undefined function: with_one/1" <> _ = capture_iex("with_one(22)")
-    assert "** (RuntimeError) undefined function: many/3"     <> _ = capture_iex("many(:ok, 22, \"hi\")")
+    assert output =~ "** (TokenMissingError) token missing on iex:1:"
+    assert output =~ "error:"
+    assert output =~ "incomplete expression\n"
+    assert output =~ "iex:1"
   end
 
   test "module definition" do
     input = """
     defmodule Sample do
-      def foo, do: bar
+      def foo, do: bar()
       def bar, do: 13
-    end && Sample.foo
+    end && Sample.foo()
+    """
+
+    assert capture_iex(input) =~ "13"
+  after
+    :code.purge(Sample)
+    :code.delete(Sample)
+  end
+
+  test "blocks" do
+    input = """
+    (
+      defmodule Sample do
+        def foo, do: bar()
+        def bar, do: 13
+      end
+      import Sample
+      foo()
+    )
     """
+
     assert capture_iex(input) =~ "13"
   after
     :code.purge(Sample)
     :code.delete(Sample)
   end
 
+  test "ExUnit.Assertions" do
+    capture = capture_iex("import ExUnit.Assertions; assert 1 == 2")
+    assert capture =~ "** (ExUnit.AssertionError)"
+    assert capture =~ "assert 1 == 2"
+  end
+
   test "prompt" do
     opts = [default_prompt: "prompt(%counter)>"]
     assert capture_iex("1\n", opts, [], true) == "prompt(1)> 1\nprompt(2)>"
   end
 
-  unless match?({:win32,_}, :os.type) do
+  if IO.ANSI.enabled?() do
     test "color" do
-      opts = [colors: [enabled: true, eval_result: "red"]]
-      assert capture_iex("1 + 2", opts) == "\e[31m3\e[0m"
-
-      # Sanity checks
-      assert capture_iex("IO.ANSI.escape(\"%{blue}hello\", true)", opts)
-             == "\e[31m\"\\e[34mhello\\e[0m\"\e[0m"
-      assert capture_iex("IO.puts IO.ANSI.escape(\"%{blue}hello\", true)", opts)
-             == "\e[34mhello\e[0m\n\e[31m:ok\e[0m"
-      assert capture_iex("IO.puts IO.ANSI.escape(\"%{blue}hello\", true)", [colors: [enabled: false]])
-             == "\e[34mhello\e[0m\n:ok"
-
-      # Test that ANSI escapes in the docs are left alone
-      opts = [colors: [enabled: true]]
-      assert capture_iex("h IO.ANSI.escape_fragment", opts)
-             =~ ~r"%\{red\}"
-
-      # Test that ANSI escapes in iex output are left alone
-      opts = [colors: [enabled: true, eval_result: "red", eval_info: "red"]]
-      assert capture_iex("\"%{red} %{blue}\"", opts) == "\e[31m\"%{red} %{blue}\"\e[0m"
-      assert capture_iex("IO.puts IEx.color(:eval_info, \"%{red} %{blue}\")", opts)
-             == "\e[31m%{red} %{blue}\e[0m\n\e[31m:ok\e[0m"
+      opts = [colors: [enabled: true, eval_result: [:red]]]
+      assert capture_iex("1 + 2", opts) == "\e[31m\e[33m3\e[0m\e[31m\e[0m"
+      assert capture_iex("IO.ANSI.blue()", opts) == "\e[31m\e[32m\"\\e[34m\"\e[0m\e[31m\e[0m"
+
+      assert capture_iex("{:ok}", opts) ==
+               "\e[31m\e[39m{\e[0m\e[31m\e[36m:ok\e[0m\e[31m\e[39m}\e[0m\e[31m\e[0m"
     end
   end
 
   test "inspect opts" do
-    opts = [inspect: [binaries: :as_binaries, char_lists: :as_lists, structs: false, limit: 4]]
-    assert capture_iex("<<45,46,47>>\n[45,46,47]\n%IO.Stream{}", opts) ==
-              "<<45, 46, 47>>\n[45, 46, 47]\n%{__struct__: IO.Stream, device: nil, line_or_bytes: :line, raw: true}"
-  end
+    opts = [
+      inspect: [
+        binaries: :as_binaries,
+        charlists: :as_lists,
+        structs: false,
+        limit: 4,
+        custom_options: [sort_maps: true]
+      ]
+    ]
 
-  test "history size" do
-    opts = [history_size: 3]
-    assert capture_iex("1\n2\n3\nv(1)", opts) == "1\n2\n3\n1"
-    assert "1\n2\n3\n4\n** (RuntimeError) v(1) is out of bounds" <> _ = capture_iex("1\n2\n3\n4\nv(1)", opts)
-    assert "1\n2\n3\n4\n** (RuntimeError) v(-4) is out of bounds" <> _ = capture_iex("1\n2\n3\n4\nv(-4)", opts)
-    assert "1\n2\n3\n4\n2\n** (RuntimeError) v(2) is out of bounds" <> _ = capture_iex("1\n2\n3\n4\nv(2)\nv(2)", opts)
+    assert capture_iex("<<45, 46, 47>>\n[45, 46, 47]\n%IO.Stream{}", opts) ==
+             "<<45, 46, 47>>\n[45, 46, 47]\n%{__struct__: IO.Stream, device: nil, line_or_bytes: :line, raw: true}"
   end
 
-  ## .iex file loading
+  test "exception" do
+    exception = Regex.escape("** (ArithmeticError) bad argument in arithmetic expression")
 
-  test "no .iex" do
-    assert "** (RuntimeError) undefined function: my_variable/0" <> _ = capture_iex("my_variable")
-  end
+    assert capture_iex("1 + :atom\n:this_is_still_working") =~
+             ~r/^#{exception}.+\n:this_is_still_working$/s
 
-  test ".iex" do
-    File.write!("dot-iex", "my_variable = 144")
-    assert capture_iex("my_variable", [], [dot_iex_path: "dot-iex"]) == "144"
-  after
-    File.rm("dot-iex")
+    refute capture_iex("1 + :atom\n:this_is_still_working") =~ ~r/erl_eval/s
   end
 
-  test "nested .iex" do
-    File.write!("dot-iex-1", "nested_var = 13\nimport IO")
-    File.write!("dot-iex", "import_file \"dot-iex-1\"\nmy_variable=14")
+  test "exception while invoking conflicting helpers" do
+    import File, only: [open: 1], warn: false
 
-    input = "nested_var\nmy_variable\nputs \"hello\""
-    assert capture_iex(input, [], [dot_iex_path: "dot-iex"]) == "13\n14\nhello\n:ok"
-  after
-    File.rm("dot-iex-1")
-    File.rm("dot-iex")
+    assert capture_io(:stderr, fn ->
+             capture_iex("open('README.md')", [], env: __ENV__)
+           end) =~
+             ~r"function open/1 imported from both File and IEx.Helpers"
   end
 
   test "receive exit" do
-    assert capture_iex("spawn_link(fn -> exit(:bye) end)") =~
-           ~r"\*\* \(EXIT from #PID<\d+\.\d+\.\d+>\) :bye"
-    assert capture_iex("spawn_link(fn -> exit({:bye, [:world]}) end)") =~
-           ~r"\*\* \(EXIT from #PID<\d+\.\d+\.\d+>\) {:bye, \[:world\]}"
+    assert capture_iex("spawn_link(fn -> exit(:bye) end); Process.sleep(1000)") =~
+             ~r"\*\* \(EXIT from #PID<\d+\.\d+\.\d+>\) shell process exited with reason: :bye"
+
+    assert capture_iex("spawn_link(fn -> exit({:bye, [:world]}) end); Process.sleep(1000)") =~
+             ~r"\*\* \(EXIT from #PID<\d+\.\d+\.\d+>\) shell process exited with reason: {:bye, \[:world\]}"
+  end
+
+  test "receive normal exits" do
+    assert capture_iex("spawn_link(fn -> exit(:normal) end); Process.sleep(1000)") =~ ":ok"
+
+    assert capture_iex("spawn_link(fn -> exit(:shutdown) end); Process.sleep(1000)") =~
+             ~r"\*\* \(EXIT from #PID<\d+\.\d+\.\d+>\) shell process exited with reason: shutdown"
+
+    assert capture_iex("spawn_link(fn -> exit({:shutdown, :bye}) end); Process.sleep(1000)") =~
+             ~r"\*\* \(EXIT from #PID<\d+\.\d+\.\d+>\) shell process exited with reason: shutdown: :bye"
   end
 
   test "receive exit from exception" do
     # use exit/1 to fake an error so that an error message
     # is not sent to the error logger.
     content = capture_iex("spawn_link(fn -> exit({%ArgumentError{},
-                           [{:not_a_real_module, :function, 0, []}]}) end)")
-    assert content =~ ~r"\*\* \(EXIT from #PID<\d+\.\d+\.\d+>\) an exception was raised:\n"
+                           [{:not_a_real_module, :function, 0, []}]}) end);
+                           Process.sleep(1000)")
+
+    assert content =~
+             ~r"\*\* \(EXIT from #PID<\d+\.\d+\.\d+>\) shell process exited with reason: an exception was raised:\n"
+
     assert content =~ ~r"\s{4}\*\* \(ArgumentError\) argument error\n"
     assert content =~ ~r"\s{8}:not_a_real_module\.function/0"
   end
 
-  test "exit due to failed call" do
+  test "receive exit due to failed call" do
     assert capture_iex("exit({:bye, {:gen_server, :call, [self(), :hello]}})") =~
-           ~r"\*\* \(exit\) exited in: :gen_server\.call\(#PID<\d+\.\d+\.\d+>, :hello\)\n\s{4}\*\* \(EXIT\) :bye"
+             ~r"\*\* \(exit\) exited in: :gen_server\.call\(#PID<\d+\.\d+\.\d+>, :hello\)\n\s{4}\*\* \(EXIT\) :bye"
+  end
+
+  test "blames function clause error" do
+    import PathHelpers
+
+    write_beam(
+      defmodule ExampleModule do
+        def fun(:valid), do: :ok
+      end
+    )
+
+    content = capture_iex("IEx.InteractionTest.ExampleModule.fun(:invalid)")
+
+    assert content =~
+             "** (FunctionClauseError) no function clause matching in IEx.InteractionTest.ExampleModule.fun/1"
+
+    assert content =~
+             "The following arguments were given to IEx.InteractionTest.ExampleModule.fun/1"
+
+    assert content =~ ":invalid"
+    assert content =~ "def fun(-:valid-)"
+
+    assert content =~
+             ~r"test/iex/interaction_test.exs:\d+: IEx\.InteractionTest\.ExampleModule\.fun/1"
+
+    content = capture_iex("Access.fetch(:foo, :bar)")
+
+    assert content =~ ~r"\(elixir #{System.version()}\) lib/access\.ex:\d+: Access\.fetch/2"
+  end
+
+  test "parser" do
+    defmodule EchoParser do
+      def parse(input, _opts, buffer) do
+        {:ok, input, buffer}
+      end
+    end
+
+    assert capture_iex("foo", parser: {EchoParser, :parse, []}) == "~c\"foo\""
+  after
+    IEx.configure(parser: {IEx.Evaluator, :parse, []})
+  end
+
+  ## .iex file loading
+
+  describe ".iex" do
+    test "no .iex" do
+      assert capture_io(:stderr, fn -> capture_iex("my_variable") end) =~
+               "undefined variable \"my_variable\""
+    end
+
+    @tag :tmp_dir
+    test "single .iex", %{tmp_dir: tmp_dir} do
+      path =
+        write_dot_iex!(tmp_dir, "dot-iex", """
+        defmodule DotIEx do
+          def my_fun_single, do: :single
+        end
+        import DotIEx
+        my_variable = 42
+        """)
+
+      assert capture_iex("{my_fun_single(), my_variable}", [], dot_iex: path) ==
+               "{:single, 42}"
+    end
+
+    @tag :tmp_dir
+    test "nested .iex", %{tmp_dir: tmp_dir} do
+      write_dot_iex!(tmp_dir, "dot-iex-1", """
+      defmodule DotIExNested do
+        def my_fun_nested, do: :nested
+      end
+      import DotIExNested
+      nested_var = 42
+      """)
+
+      path =
+        write_dot_iex!(tmp_dir, "dot-iex", "import_file \"#{tmp_dir}/dot-iex-1\"\nmy_variable=13")
+
+      input = "nested_var\nmy_variable\nmy_fun_nested()"
+      assert capture_iex(input, [], dot_iex: path) == "42\n13\n:nested"
+    end
+
+    @tag :tmp_dir
+    test "configured .iex", %{tmp_dir: tmp_dir} do
+      path =
+        write_dot_iex!(tmp_dir, "configured-dot-iex", """
+        defmodule ConfiguredDotIEx do
+          def my_fun_single, do: :single
+        end
+        import ConfiguredDotIEx
+        my_variable = 42
+        """)
+
+      assert capture_iex("{my_fun_single(), my_variable}", [dot_iex: path], dot_iex: nil) ==
+               "{:single, 42}"
+    end
+  end
+
+  defp write_dot_iex!(tmp_dir, name, contents) do
+    path = Path.join(tmp_dir, name)
+    File.write!(path, contents)
+    path
+  end
+
+  describe "pipeline error safety" do
+    test "syntax error in pipeline prevents subsequent operations" do
+      input = """
+      1, 2, 3]
+      |> Enum.map(&(&1 * 2))
+      """
+
+      output = capture_iex(input)
+      assert output =~ "skipping evaluation of expression because pipeline has failed"
+    end
+
+    test "runtime error in first pipeline step prevents subsequent operations" do
+      input = """
+      :not_a_list
+      |> Enum.map(&(&1 * 2))
+      |> Enum.sum()
+      """
+
+      output = capture_iex(input)
+      assert output =~ "skipping evaluation of expression because pipeline has failed"
+    end
+
+    test "error state is cleared after successful evaluation" do
+      input = """
+      :not_a_list
+      |> Enum.map(&(&1 * 2))
+      |> Enum.sum()
+      [1, 2, 3]
+      |> Enum.sum()
+      """
+
+      output = capture_iex(input)
+      assert output =~ "skipping evaluation of expression because pipeline has failed"
+      assert String.ends_with?(output, "6")
+    end
   end
 end
diff --git a/lib/iex/test/iex/pry_test.exs b/lib/iex/test/iex/pry_test.exs
new file mode 100644
index 00000000000..d1038da5683
--- /dev/null
+++ b/lib/iex/test/iex/pry_test.exs
@@ -0,0 +1,274 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule IEx.PryTest do
+  use ExUnit.Case
+
+  setup do
+    on_exit(fn -> IEx.Pry.remove_breaks() end)
+  end
+
+  describe "whereami" do
+    test "shows lines with radius" do
+      Application.put_env(:elixir, :ansi_enabled, true)
+
+      {:ok, contents} = IEx.Pry.whereami(__ENV__.file, 7, 2)
+
+      assert IO.iodata_to_binary(contents) == """
+                 5: Code.require_file("../test_helper.exs", __DIR__)
+                 6:\s
+             \e[1m    7: defmodule IEx.PryTest do
+             \e[22m    8:   use ExUnit.Case
+                 9:\s
+             """
+
+      {:ok, contents} = IEx.Pry.whereami(__ENV__.file, 7, 1)
+
+      assert IO.iodata_to_binary(contents) == """
+                 6:\s
+             \e[1m    7: defmodule IEx.PryTest do
+             \e[22m    8:   use ExUnit.Case
+             """
+    after
+      Application.delete_env(:elixir, :ansi_enabled)
+    end
+
+    test "returns error for unknown files" do
+      assert IEx.Pry.whereami("unknown", 3, 2) == :error
+    end
+
+    test "returns error for out of range lines" do
+      assert IEx.Pry.whereami(__ENV__.file, 1000, 2) == :error
+    end
+  end
+
+  describe "break" do
+    test "sets up a breakpoint on the given module" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert instrumented?(PryExampleModule)
+      assert [_] = IEx.Pry.breaks()
+    end
+
+    test "sets up multiple breakpoints in the same module" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert instrumented?(PryExampleModule)
+      assert IEx.Pry.break(PryExampleModule, :one, 1) == {:ok, 2}
+      assert instrumented?(PryExampleModule)
+      assert [_, _] = IEx.Pry.breaks()
+    end
+
+    test "reinstruments if module has been reloaded" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert instrumented?(PryExampleModule)
+      deinstrument!(PryExampleModule)
+      refute instrumented?(PryExampleModule)
+      assert IEx.Pry.break(PryExampleModule, :one, 1) == {:ok, 2}
+      assert instrumented?(PryExampleModule)
+      assert [_, _] = IEx.Pry.breaks()
+    end
+
+    test "returns ID when breakpoint is already set" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert [_] = IEx.Pry.breaks()
+    end
+
+    test "returns ID even when breakpoint is already set on deinstrument" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      deinstrument!(PryExampleModule)
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert [_] = IEx.Pry.breaks()
+    end
+
+    test "errors when setting up a break with no beam" do
+      assert IEx.Pry.break(__MODULE__, :setup, 2) == {:error, :no_beam_file}
+    end
+
+    test "errors when setting up a break for unknown function" do
+      assert IEx.Pry.break(PryExampleModule, :unknown, 2) == {:error, :unknown_function_arity}
+    end
+
+    test "errors for non-Elixir modules" do
+      assert IEx.Pry.break(:maps, :unknown, 2) == {:error, :non_elixir_module}
+    end
+  end
+
+  describe "breaks" do
+    test "returns all breaks" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
+
+      assert IEx.Pry.break(PryExampleModule, :two, 2, 10) == {:ok, 1}
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 10}]
+
+      assert IEx.Pry.break(PryExampleModule, :one, 1, 1) == {:ok, 2}
+
+      assert IEx.Pry.breaks() == [
+               {1, PryExampleModule, {:two, 2}, 10},
+               {2, PryExampleModule, {:one, 1}, 1}
+             ]
+    end
+
+    test "sets negative break to 0" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      :ets.insert(IEx.Pry, {1, PryExampleModule, {:two, 2}, {[], true}, -1})
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 0}]
+    end
+
+    test "do not return break points for deinstrumented modules" do
+      assert IEx.Pry.break(PryExampleModule, :one, 1) == {:ok, 1}
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:one, 1}, 1}]
+      deinstrument!(PryExampleModule)
+      assert IEx.Pry.breaks() == []
+    end
+  end
+
+  describe "reset_break" do
+    test "resets break for given ID" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert IEx.Pry.reset_break(1) == :ok
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 0}]
+    end
+
+    test "resets break for given mfa" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert IEx.Pry.reset_break(PryExampleModule, :two, 2) == :ok
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 0}]
+    end
+
+    test "returns not_found if module is deinstrumented" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      deinstrument!(PryExampleModule)
+      assert IEx.Pry.reset_break(PryExampleModule, :two, 2) == :not_found
+      assert IEx.Pry.breaks() == []
+    end
+
+    test "returns not_found if mfa has no break" do
+      assert IEx.Pry.reset_break(PryExampleModule, :two, 2) == :not_found
+    end
+
+    test "returns not_found if ID is deinstrumented" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      deinstrument!(PryExampleModule)
+      assert IEx.Pry.reset_break(1) == :not_found
+      assert IEx.Pry.breaks() == []
+    end
+
+    test "returns not_found if ID has no break" do
+      assert IEx.Pry.reset_break(1) == :not_found
+    end
+  end
+
+  describe "remove_breaks" do
+    test "removes all breaks" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert IEx.Pry.remove_breaks() == :ok
+      assert IEx.Pry.breaks() == []
+    end
+
+    test "removes all breaks even if module is deinstrumented" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      deinstrument!(PryExampleModule)
+      assert IEx.Pry.remove_breaks() == :ok
+      assert IEx.Pry.breaks() == []
+    end
+
+    test "remove breaks in a given module" do
+      assert IEx.Pry.remove_breaks(PryExampleStruct) == :ok
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      assert IEx.Pry.break(PryExampleStruct, :__struct__, 1) == {:ok, 2}
+      assert IEx.Pry.remove_breaks(PryExampleStruct) == :ok
+      assert IEx.Pry.breaks() == [{1, PryExampleModule, {:two, 2}, 1}]
+    end
+
+    test "remove breaks in a given module even if deinstrumented" do
+      assert IEx.Pry.break(PryExampleModule, :two, 2) == {:ok, 1}
+      deinstrument!(PryExampleModule)
+      assert IEx.Pry.breaks() == []
+    end
+  end
+
+  describe "annotate_quoted" do
+    def annotate_quoted(block, condition \\ true) do
+      {:__block__, meta, [{:=, _, [{:env, _, _}, _]} | tail]} =
+        block
+        |> Code.string_to_quoted!()
+        |> IEx.Pry.annotate_quoted(condition, %{__ENV__ | line: 1})
+
+      Macro.to_string({:__block__, meta, tail})
+    end
+
+    test "one expression, one line" do
+      assert annotate_quoted("""
+             x = 123
+             y = 456
+             x + y
+             """) == """
+             next? = true
+             next? = IEx.Pry.__next__(next?, binding(), %{env | line: 1})
+             x = 123
+             next? = IEx.Pry.__next__(next?, binding(), %{env | line: 2})
+             y = 456
+             next? = IEx.Pry.__next__(next?, binding(), %{env | line: 3})
+             x + y\
+             """
+    end
+
+    test "one expression, multiple lines" do
+      assert annotate_quoted("""
+             (x = 123) &&
+              (y = 456)
+             x + y
+             """) == """
+             next? = true
+             next? = IEx.Pry.__next__(next?, binding(), %{env | line: 1})
+             (x = 123) && (y = 456)
+             next? = IEx.Pry.__next__(next?, binding(), %{env | line: 3})
+             x + y\
+             """
+    end
+
+    test "one line, multiple expressions" do
+      assert annotate_quoted("""
+             x = 123; y = 456
+             x + y
+             """) == """
+             next? = true
+             next? = IEx.Pry.__next__(next?, binding(), %{env | line: 1})
+             x = 123
+             y = 456
+             next? = IEx.Pry.__next__(next?, binding(), %{env | line: 2})
+             x + y\
+             """
+    end
+
+    test "multiple line, multiple expressions" do
+      assert annotate_quoted("""
+             x = 123; y =
+              456
+             x + y
+             """) == """
+             next? = true
+             next? = IEx.Pry.__next__(next?, binding(), %{env | line: 1})
+             x = 123
+             y = 456
+             next? = IEx.Pry.__next__(next?, binding(), %{env | line: 3})
+             x + y\
+             """
+    end
+  end
+
+  defp instrumented?(module) do
+    module.module_info(:attributes)[:iex_pry] == [true]
+  end
+
+  defp deinstrument!(module) do
+    beam = :code.which(module)
+    :code.purge(module)
+    {:module, _} = :code.load_binary(module, beam, File.read!(beam))
+    :ok
+  end
+end
diff --git a/lib/iex/test/iex/server_test.exs b/lib/iex/test/iex/server_test.exs
index 596ea7784f3..d55f0206490 100644
--- a/lib/iex/test/iex/server_test.exs
+++ b/lib/iex/test/iex/server_test.exs
@@ -1,61 +1,222 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule IEx.ServerTest do
-  use IEx.Case, async: true
+  use IEx.Case
 
-  # Options
+  require IEx
 
-  test "prefix option" do
-    assert capture_io(fn ->
-      boot([prefix: "pry"])
-    end) =~ "pry(1)> "
-  end
+  describe "options" do
+    test "prefix" do
+      assert capture_io(fn ->
+               IEx.Server.run(prefix: "custom", dot_iex: "")
+             end) =~ "custom(1)> "
+    end
 
-  test "delegate_locals_to option" do
-    assert capture_io("sort([:foo, :bar])", fn ->
-      boot([delegate_locals_to: Enum])
-    end) =~ "[:bar, :foo]"
+    test "env" do
+      assert capture_iex("__ENV__.file", [], env: __ENV__) =~ "server_test.exs"
+    end
   end
 
-  test "env option" do
-    assert capture_io("__ENV__.file", fn ->
-      boot([env: __ENV__])
-    end) =~ "server_test.exs"
+  describe "pry" do
+    test "inside evaluator itself" do
+      assert capture_iex("require IEx; IEx.pry()") =~ "Break reached"
+    end
+
+    test "outside of the evaluator with acceptance", config do
+      Process.register(self(), config.test)
+
+      {server, evaluator} = pry_session(config.test, "Y\niex_context")
+      client = pry_request([server])
+      send(evaluator, :run)
+
+      assert Task.await(server) =~ ":inside_pry"
+      assert Task.await(client) == {:ok, false}
+    end
+
+    test "outside of the evaluator with refusal", config do
+      Process.register(self(), config.test)
+
+      assert capture_io(:stderr, fn ->
+               {server, evaluator} = pry_session(config.test, "N\niex_context")
+               client = pry_request([server])
+               send(evaluator, :run)
+
+               assert Task.await(client) == {:error, :refused}
+               assert Task.await(server) =~ "cannot compile code"
+             end) =~ "undefined variable \"iex_context\""
+    end
+
+    test "outside of the evaluator with crash", config do
+      Process.register(self(), config.test)
+
+      {server, _evaluator} = pry_session(config.test, "iex_context")
+      client = pry_request([server])
+
+      _ = Task.shutdown(server, :brutal_kill)
+      assert Task.await(client) == {:error, :refused}
+    end
+
+    test "outside of the evaluator with double acceptance", config do
+      Process.register(self(), config.test)
+
+      assert capture_io(:stderr, fn ->
+               {server1, evaluator1} = pry_session(config.test, "Y\niex_context")
+               {server2, evaluator2} = pry_session(config.test, "Y\niex_context")
+               client = pry_request([server1, server2])
+
+               send(evaluator1, :run)
+               send(evaluator2, :run)
+               reply1 = Task.await(server1)
+               reply2 = Task.await(server2)
+
+               {accepted, refused} =
+                 if reply1 =~ ":inside_pry", do: {reply1, reply2}, else: {reply2, reply1}
+
+               assert accepted =~ ":inside_pry"
+               assert refused =~ "** session was already accepted elsewhere"
+
+               assert Task.await(client) == {:ok, false}
+             end) =~ "undefined variable \"iex_context\""
+    end
+
+    test "outside of the evaluator with double refusal", config do
+      Process.register(self(), config.test)
+
+      assert capture_io(:stderr, fn ->
+               {server1, evaluator1} = pry_session(config.test, "N\niex_context")
+               {server2, evaluator2} = pry_session(config.test, "N\niex_context")
+               client = pry_request([server1, server2])
+
+               send(evaluator1, :run)
+               send(evaluator2, :run)
+               reply1 = Task.await(server1)
+               reply2 = Task.await(server2)
+
+               assert reply1 =~ "cannot compile code"
+               assert reply2 =~ "cannot compile code"
+
+               assert Task.await(client) == {:error, :refused}
+             end) =~ "undefined variable \"iex_context\""
+    end
+
+    test "outside of the evaluator with acceptance and then refusal", config do
+      Process.register(self(), config.test)
+
+      assert capture_io(:stderr, fn ->
+               {server1, evaluator1} = pry_session(config.test, "Y\niex_context")
+               {server2, evaluator2} = pry_session(config.test, "N\niex_context")
+               client = pry_request([server1, server2])
+
+               send(evaluator1, :run)
+               send(evaluator2, :run)
+               assert Task.await(server1) =~ ":inside_pry"
+               assert Task.await(server2) =~ "cannot compile code"
+
+               assert Task.await(client) == {:ok, false}
+             end) =~ "undefined variable \"iex_context\""
+    end
+
+    test "outside of the evaluator with refusal and then acceptance", config do
+      Process.register(self(), config.test)
+
+      assert capture_io(:stderr, fn ->
+               {server1, evaluator1} = pry_session(config.test, "N\niex_context")
+               {server2, evaluator2} = pry_session(config.test, "Y\niex_context")
+               client = pry_request([server1, server2])
+
+               send(evaluator1, :run)
+               send(evaluator2, :run)
+               assert Task.await(server1) =~ "cannot compile code"
+               assert Task.await(server2) =~ ":inside_pry"
+
+               assert Task.await(client) == {:ok, false}
+             end) =~ "undefined variable \"iex_context\""
+    end
+
+    @tag :tmp_dir
+    test "outside evaluator with .iex", %{tmp_dir: tmp_dir} = config do
+      Process.register(self(), config.test)
+      path = Path.join(tmp_dir, "dot-iex")
+      File.write!(path, "my_variable = 144")
+
+      assert capture_io(:stderr, fn ->
+               {server, evaluator} =
+                 pry_session(config.test, "Y\nmy_variable", dot_iex: path)
+
+               client = pry_request([server])
+               send(evaluator, :run)
+
+               assert Task.await(server) =~ "** (CompileError)"
+
+               assert Task.await(client) == {:ok, false}
+             end) =~ "undefined variable \"my_variable\""
+    end
+
+    @tag :tmp_dir
+    test "after pry outside evaluator .iex", %{tmp_dir: tmp_dir} = config do
+      Process.register(self(), config.test)
+      path = Path.join(tmp_dir, "dot-iex")
+      File.write!(path, "my_variable = 144")
+
+      {server, evaluator} =
+        pry_session(config.test, "Y\ncontinue\nmy_variable", dot_iex: path)
+
+      client = pry_request([server])
+      send(evaluator, :run)
+
+      assert Task.await(server) =~ "144"
+      assert Task.await(client) == {:ok, false}
+
+      {server, evaluator} = pry_session(config.test, "Y\nnext\nmy_variable", dot_iex: path)
+
+      client = pry_request([server])
+      send(evaluator, :run)
+
+      assert Task.await(server) =~ "144"
+      assert Task.await(client) == {:ok, true}
+    end
   end
 
-  # Take over
+  # Helpers
 
-  test "allows take over of the shell during boot" do
-    assert capture_io("Y\na+b", fn ->
-      server = self
-      boot([], fn ->
-        opts = [prefix: "dbg", binding: [a: 1, b: 2]]
-        IEx.Server.take_over("iex:13", opts, 1000, server)
+  defp pry_session(name, session, server_options \\ []) do
+    task =
+      Task.async(fn ->
+        capture_iex(
+          """
+          send(#{inspect(name)}, {:running, self()}) && receive do: (:run -> :ok)
+          #{session}
+          """,
+          [],
+          server_options
+        )
       end)
-    end) =~ "dbg(1)> "
-  end
 
-  test "does not operate if callback during boot fails" do
-    assert capture_io(fn ->
-      boot([], fn -> exit(0) end)
-    end) == ""
+    assert_receive {:running, evaluator}
+    {task, evaluator}
   end
 
-  test "take over fails when there is no shell" do
-    assert IEx.Server.take_over("iex:13", [], 10) == {:error, :no_iex}
-  end
+  defp pry_request(sessions) do
+    :erlang.trace(Process.whereis(IEx.Broker), true, [:receive, tracer: self()])
+    patterns = for %{pid: pid} <- sessions, do: {[:_, pid, :_], [], []}
+    :erlang.trace_pattern(:receive, patterns, [])
 
-  test "pry wraps around take over" do
-    require IEx
-    assert capture_io(fn ->
-      assert IEx.pry == {:error, :no_iex}
-    end) =~ "Is an IEx shell running?"
-  end
+    task =
+      Task.async(fn ->
+        iex_context = :inside_pry
+        IEx.pry()
+      end)
 
-  # Helpers
+    for _ <- sessions do
+      assert_receive {:trace, _, :receive, {_, _, call}} when elem(call, 0) in [:accept, :refuse]
+    end
 
-  defp boot(opts, callback \\ fn -> end) do
-    IEx.Server.start(Keyword.merge([dot_iex_path: ""], opts),
-                     {:erlang, :apply, [callback, []]})
+    task
+  after
+    :erlang.trace(Process.whereis(IEx.Broker), false, [:receive, tracer: self()])
   end
 end
diff --git a/lib/iex/test/test_helper.exs b/lib/iex/test/test_helper.exs
index e3bf9ed704f..a5c0ec1e212 100644
--- a/lib/iex/test/test_helper.exs
+++ b/lib/iex/test/test_helper.exs
@@ -1,6 +1,50 @@
-Application.start(:iex)
-Application.put_env(:iex, :colors, [enabled: false])
-ExUnit.start [trace: "--trace" in System.argv]
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# Beam files compiled on demand
+path = Path.expand("../tmp/beams", __DIR__)
+File.rm_rf!(path)
+File.mkdir_p!(path)
+Code.prepend_path(path)
+System.put_env("ELIXIR_EDITOR", "echo")
+
+{:ok, _} = Application.ensure_all_started(:iex)
+IEx.configure(colors: [enabled: false], dot_iex: "/path/to/unknown/file")
+
+{line_exclude, line_include} =
+  if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
+
+erlang_doc_exclude =
+  if match?({:docs_v1, _, _, _, %{}, _, _}, Code.fetch_docs(:array)) do
+    []
+  else
+    IO.puts("Erlang/OTP compiled without docs, some tests are excluded...")
+    [:erlang_doc]
+  end
+
+source_exclude =
+  if :deterministic in :compile.env_compiler_options() do
+    [:requires_source]
+  else
+    []
+  end
+
+Code.require_file("../../elixir/scripts/cover_record.exs", __DIR__)
+
+cover_exclude =
+  if CoverageRecorder.maybe_record("iex") do
+    [:require_ast]
+  else
+    []
+  end
+
+ExUnit.start(
+  trace: !!System.get_env("TRACE"),
+  include: line_include,
+  exclude: line_exclude ++ erlang_doc_exclude ++ source_exclude ++ cover_exclude,
+  assert_receive_timeout: String.to_integer(System.get_env("ELIXIR_ASSERT_TIMEOUT", "300"))
+)
 
 defmodule IEx.Case do
   use ExUnit.CaseTemplate
@@ -12,7 +56,7 @@ defmodule IEx.Case do
   #   defmodule IEx.InteractionTest do
   #     use IEx.Case
   #
-  #     test :input do
+  #     test "input" do
   #       assert capture_iex("1+2") == "3"
   #     end
   #   end
@@ -27,16 +71,21 @@ defmodule IEx.Case do
   using do
     quote do
       import ExUnit.CaptureIO
+      import ExUnit.CaptureLog
       import unquote(__MODULE__)
     end
   end
 
+  @keys [:default_prompt, :alive_prompt, :inspect, :colors, :history_size, :dot_iex]
+  @iex_env Application.get_all_env(:iex) |> Keyword.take(@keys)
+
   setup do
-    opts = IEx.configuration |>
-           Keyword.take([:default_prompt, :alive_prompt, :inspect, :colors, :history_size])
-    on_exit fn ->
-      Enum.each opts, fn {k, v} -> Application.put_env(:iex, k, v) end
-    end
+    on_exit(fn ->
+      env = @iex_env
+      Enum.each(@keys, &Application.delete_env(:iex, &1))
+      IEx.configure(env)
+    end)
+
     :ok
   end
 
@@ -48,25 +97,54 @@ defmodule IEx.Case do
   Options, if provided, will be set before the eval loop is started.
 
   If you provide server options, it will be passed to
-  IEx.Server.start to be used in the normal .iex loading process.
+  IEx.Server.run to be used in the normal .iex loading process.
   """
   def capture_iex(input, options \\ [], server_options \\ [], capture_prompt \\ false) do
     IEx.configure(options)
 
     ExUnit.CaptureIO.capture_io([input: input, capture_prompt: capture_prompt], fn ->
-      server_options = Keyword.put_new(server_options, :dot_iex_path, "")
-      IEx.Server.start(server_options, {IEx, :dont_display_result, []})
-    end) |> strip_iex
+      IEx.Server.run(server_options)
+    end)
+    |> strip_iex()
   end
 
   defp strip_iex(string) do
     string
-    |> strip_line   # strip the greeting
-    |> String.strip
+    |> String.split("\n", parts: 2)
+    |> Enum.at(1)
+    |> String.trim()
   end
+end
+
+defmodule PathHelpers do
+  def write_beam({:module, name, bin, _} = res) do
+    File.mkdir_p!(unquote(path))
+    beam_path = Path.join(unquote(path), Atom.to_string(name) <> ".beam")
+    File.write!(beam_path, bin)
+
+    :code.purge(name)
+    :code.delete(name)
 
-  defp strip_line(string) do
-    Regex.replace ~r/\A.+?$/ms, string, ""
+    res
   end
 end
 
+PathHelpers.write_beam(
+  defmodule HelperExampleModule do
+    def fun(_arg), do: :ok
+    defmacro macro(_arg), do: :ok
+  end
+)
+
+PathHelpers.write_beam(
+  defmodule PryExampleModule do
+    def one(_arg), do: :ok
+    def two(_arg1, _arg2), do: :ok
+  end
+)
+
+PathHelpers.write_beam(
+  defmodule PryExampleStruct do
+    defstruct one: nil
+  end
+)
diff --git a/lib/logger/lib/logger.ex b/lib/logger/lib/logger.ex
new file mode 100644
index 00000000000..a8238184f28
--- /dev/null
+++ b/lib/logger/lib/logger.ex
@@ -0,0 +1,1282 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger do
+  @moduledoc ~S"""
+  A logger for Elixir applications.
+
+  This application is mostly a wrapper around Erlang's
+  [`:logger`](`:logger`) functionality, to provide message
+  translation and formatting to Elixir terms.
+
+  Overall, you will find that `Logger`:
+
+    * Provides all 8 syslog levels
+      (although debug, info, warning, and error are the most commonly used).
+
+    * Supports both message-based and structural logging.
+
+    * Integrate with Erlang's [`:logger`](`:logger`) and
+      support custom filters and handlers.
+
+    * Formats and truncates messages on the client
+      to avoid clogging `Logger` handlers.
+
+    * Provides multiple forms of [overload protection](https://www.erlang.org/doc/apps/kernel/logger_chapter.html#protecting-the-handler-from-overload):
+      * keeps track of its message queue and switches to sync mode to apply
+        back pressure or even drop messages
+      * limits the number of logs emitted defaulting to 500 per second
+      * optionally allows to terminate and restart it if the message queue length
+        or memory thresholds are exceeded
+
+    * Allows overriding the logging level for a specific module,
+      application or process.
+
+  Logging is useful for tracking when an event of interest happens in your
+  system. For example, it may be helpful to log whenever a user is deleted.
+
+      def delete_user(user) do
+        Logger.info("Deleting user from the system: #{inspect(user)}")
+        # ...
+      end
+
+  The `Logger.info/2` macro emits the provided message at the `:info`
+  level. Note the arguments given to `info/2` will only be evaluated
+  if a message is logged. For instance, if the Logger level is
+  set to `:warning`, `:info` messages are never logged and therefore
+  the arguments given above won't even be executed.
+
+  There are additional macros for other levels.
+
+  Logger also allows log commands to be removed altogether via the
+  `:compile_time_purge_matching` option (see below).
+
+  For dynamically logging messages, see `bare_log/3`. But note that
+  `bare_log/3` always evaluates its arguments (unless the argument
+  is an anonymous function).
+
+  ## Levels
+
+  The supported levels, ordered by importance, are:
+
+    * `:emergency` - when system is unusable, panics
+    * `:alert` - for alerts, actions that must be taken immediately,
+      ex. corrupted database
+    * `:critical` - for critical conditions
+    * `:error` - for errors
+    * `:warning` - for warnings
+    * `:notice` - for normal, but significant, messages
+    * `:info` - for information of any kind
+    * `:debug` - for debug-related messages
+
+  For example, `:info` takes precedence over `:debug`. If your log
+  level is set to `:info`, then all `:info`, `:notice` and above will
+  be passed to handlers. If your log level is set to `:alert`, only
+  `:alert` and `:emergency` will be printed.
+
+  ## Message
+
+  Logger can be used for logging both unstructured and structured data.
+
+  Unstructured data is a string or a list of strings:
+
+      Logger.info("hello world!")
+      Logger.info(["hello ", "world!"])
+
+  Structured data, also known as reports, are keyword lists and maps:
+
+      Logger.info([new_user: user.id, account_type: :admin])
+      Logger.info(%{new_user: user.id, account_type: :admin})
+
+  Log functions also accept a zero-arity anonymous function as a message:
+
+      Logger.info(fn -> "hello world!" end)
+
+  The anonymous function can return a message or a tuple containing
+  the message and additional metadata (to be described in the next
+  section).
+
+  In all cases, the arguments given to the `Logger` macros are only
+  evaluated if required by the current log level. The exception is
+  the `bare_log/3` function, which is the raw mechanism for logging.
+
+  ## Metadata
+
+  Whenever a message is logged, additional information can be given
+  via metadata. Each log operation, such as `Logger.info/2`, allows
+  metadata to be given as an argument.
+
+  Furthermore, metadata can be set per process with `Logger.metadata/1`.
+
+  Some metadata, however, may be added automatically by Logger whenever
+  possible. Those are:
+
+    * `:application` - the current application
+
+    * `:mfa` - the current module, function and arity
+
+    * `:file` - the current file
+
+    * `:line` - the current line
+
+    * `:pid` - the current process identifier
+
+    * `:initial_call` - the initial call that started the process
+
+    * `:registered_name` - the process registered name as an atom
+
+    * `:domain` - a list of domains for the logged message. For example,
+      all Elixir reports default to `[:elixir]`. Erlang reports may start
+      with `[:otp]` or `[:sasl]`
+
+    * `:crash_reason` - a two-element tuple with the throw/error/exit reason
+      as first argument and the stacktrace as second. A throw will always be
+      `{:nocatch, term}`. An error is always an `Exception` struct. All other
+      entries are exits. The default formatter ignores this metadata by default
+      but it can be useful to certain handlers, such as the ones that report
+      errors to third-party services
+
+  There are two special metadata keys, `:module` and `:function`, which
+  extract the relevant bits from `:mfa`.
+
+  The metadata keys above may not always be available. The `:mfa`, `:file`,
+  `:line`, and similar metadata are automatically included when using `Logger`
+  macros, but not when using `Logger.bare_log/3`. Other metadata, such as
+  `:crash_reason`, `:initial_call`, and `:registered_name` are available
+  only inside behaviours such as GenServer, Supervisor, and others.
+
+  It is also possible to pass metadata on a particular Logger invocation.
+  For example, you might wish to include a custom `:error_code` metadata in
+  your logs:
+
+      Logger.error("We have a problem", [error_code: :pc_load_letter])
+
+  By default, no metadata is logged. We will learn how to enable that
+  over the next sections.
+
+  ## Configuration
+
+  `Logger` supports a wide range of configurations.
+
+  This configuration is split in three categories:
+
+    * Boot configuration - this configuration is read when logger
+      starts and configures how Elixir hooks into Erlang's own logger
+
+    * Compile configuration - this must be set before your code
+      is compiled
+
+    * Runtime configuration - can be set before the `:logger`
+      application is started, but may be changed during runtime
+
+  ### Boot configuration
+
+  When `Logger` starts, it configures the `:default` log handler from
+  Erlang to translate and format Elixir terms. As a developer, you
+  are able to customize the default handler, the default formatter,
+  and many other options.
+
+  The following configuration must be set via config files (such as
+  `config/config.exs`), under the `:logger` key, before your application
+  is started:
+
+    * `:default_formatter` - a keyword list which configures the
+      default formatter used by the default handler. See `Logger.Formatter`
+      for the full list of configuration.
+
+    * `:default_handler` - this option configures the default handler
+      used for logging. The default handler is a [`:logger_std_h`](`:logger_std_h`)
+      instance which also supports file logging and log rotation.
+      You can set it to `false` to disable the default logging altogether.
+      See the examples below for more information.
+
+    * `:handle_otp_reports` - if Erlang/OTP message should be logged.
+      Defaults to `true`.
+
+    * `:handle_sasl_reports` - if supervisor, crash, and progress reports
+      should be logged. Defaults to `false`. This option only has an effect
+      if `:handle_otp_reports` is true.
+
+    * `:metadata` - key-value pairs of global primary metadata to be included
+      in all log messages. Defaults to `[]`. The default formatter writes to
+      standard out and therefore cannot print all metadata. See
+      [`Logger.Formatter`'s documentation](`m:Logger.Formatter#module-metadata`)
+      for more information.
+
+  For example, to configure `Logger` to redirect all Erlang messages using a
+  `config/config.exs` file:
+
+      config :logger,
+        handle_otp_reports: true,
+        handle_sasl_reports: true
+
+  To configure the default formatter, for example, to use a different format
+  and include some metadata:
+
+      config :logger, :default_formatter,
+        format: "[$level] $message $metadata\n",
+        metadata: [:error_code, :file]
+
+  Or to configure default handler, for instance, to log into a file with
+  built-in support for log rotation and compression:
+
+      config :logger, :default_handler,
+        config: [
+          file: ~c"system.log",
+          filesync_repeat_interval: 5000,
+          file_check: 5000,
+          max_no_bytes: 10_000_000,
+          max_no_files: 5,
+          compress_on_rotate: true
+        ]
+
+  You can find a complete reference on all handler options
+  [on Erlang/OTP docs](`t::logger_handler.config/0`). Here is Elixir's
+  default configuration for the default handler:
+
+      [
+        # Do not log messages from other nodes
+        filters: [{&:logger_filters.remote_gl/2, :stop}],
+        filter_default: :log,
+        formatter: &Logger.default_formatter/0,
+        level: :all,
+        module: :logger_std_h
+      ]
+
+  The `:config` customizes a specific handler module. The default handler
+  is [`:logger_std_h`](`:logger_std_h`), which logs to standard IO, and you
+  can find all relevant configuration in its module documentation, including
+  information overload protection.
+
+  You may also set `:default_handler` to false to disable the default logging
+  altogether:
+
+      config :logger, :default_handler, false
+
+  How to add more handlers besides the default one is covered in later sections.
+
+  > #### Keywords or maps {: .tip}
+  >
+  > While Erlang's logger expects `:config` to be a map, Elixir's Logger
+  > allows the default handler configuration to be set with keyword lists.
+  > For example, this allows your `config/*.exs` files, such as `config/dev.exs`,
+  > to override individual keys defined in `config/config.exs`.
+  >
+  > When reading the handler configuration using Erlang's APIs,
+  > the configuration will always be read (and written) as a map.
+
+  ### Compile configuration
+
+  The following configuration must be set via config files (such as
+  `config/config.exs`) under the `:logger` application before your code
+  is compiled:
+
+    * `:always_evaluate_messages` - if messages should be *evaluated* even if
+      the log level is lower than the minimum configured level. Defaults to `false`.
+      This is useful for cases where the log level in your *test environment*
+      is high (such as `:error`), which is common in order to avoid logs mixed
+      with the test output. In such, cases, you might discover log messages
+      that contain runtime errors only when your code is deployed to production,
+      where the log level is lower (such as `:info`). These runtime errors could
+      be caused by, for example, interpolating something that doesn't implement
+      the `String.Chars` protocol in the log message, such as `"PID: #{self()}"`
+      (since PIDs cannot be converted to strings with `String.Chars`).
+
+    * `:compile_time_application` - sets the `:application` metadata value
+      to the configured value at compilation time. This configuration is
+      automatically set by Mix and made available as metadata when logging.
+
+    * `:compile_time_purge_matching` - purges *at compilation time* all calls
+      that match the given conditions. This means that `Logger` calls with
+      level lower than this option will be completely removed at compile time,
+      accruing no overhead at runtime. This configuration expects a list of
+      keyword lists. Each keyword list contains a metadata key and the matching
+      value that should be purged. Some special keys are supported:
+
+        * `:level_lower_than` - purges all messages with a lower logger level
+        * `:module` - purges all messages with the matching module
+        * `:function` - purges all messages with the "function/arity"
+
+      Remember that if you want to purge log calls from a dependency, the
+      dependency must be recompiled.
+
+  For example, to purge all calls that happen at compile time with level
+  lower than `:info` in a `config/config.exs` file:
+
+      config :logger,
+        compile_time_purge_matching: [
+          [level_lower_than: :info]
+        ]
+
+  If you want to purge all log calls from an application named `:foo` and only
+  keep errors from `Bar.foo/3`, you can set up two different matches:
+
+      config :logger,
+        compile_time_purge_matching: [
+          [application: :foo],
+          [module: Bar, function: "foo/3", level_lower_than: :error]
+        ]
+
+  ### Runtime Configuration
+
+  All configuration below can be set via config files (such as
+  `config/config.exs`) but also changed dynamically during runtime via
+  `Logger.configure/1`.
+
+    * `:level` - the logging level. Attempting to log any message
+      with severity less than the configured level will simply
+      cause the message to be ignored. Keep in mind that each handler
+      may have its specific level, too. In addition to levels mentioned
+      above it also supports 2 "meta-levels":
+
+        - `:all` - all messages will be logged, conceptually identical to
+          `:debug`
+        - `:none` - no messages will be logged at all
+
+    * `:translator_inspect_opts` - when translating OTP reports and
+      errors, the last message and state must be inspected in the
+      error reports. This configuration allow developers to change
+      how much and how the data should be inspected. See `Kernel.inspect/2`
+      for more information on the available options.
+
+  For example, to configure the `:level` options in a `config/config.exs`
+  file:
+
+      config :logger, level: :warning
+
+  Furthermore, `Logger` allows messages sent by Erlang to be translated
+  into an Elixir format via translators. Translators can be added at any
+  time with the `add_translator/1` and `remove_translator/1` APIs. Check
+  `Logger.Translator` for more information.
+
+  ## Erlang/OTP handlers
+
+  Handlers represent the ability to integrate into the logging system to
+  handle each logged message/event.
+
+  ### Built-in handlers
+
+  Elixir's Logger automatically sets a default handler based on Erlang's
+  `:logger_std_h`, which you can configure using the `:default_handler` boot
+  configuration outlined above. You may also attach additional handlers
+  when you boot your application.
+
+  To do so, you must list a series of handlers under the `:logger` key
+  of your application configuration. For example, to setup an additional
+  handler that writes to a file:
+
+      config :my_app, :logger, [
+        {:handler, :file_log, :logger_std_h, %{
+           config: %{
+             file: ~c"system.log",
+             filesync_repeat_interval: 5000,
+             file_check: 5000,
+             max_no_bytes: 10_000_000,
+             max_no_files: 5,
+             compress_on_rotate: true
+           },
+           formatter: Logger.Formatter.new()
+         }}
+      ]
+
+  Each handler has the shape `{:handler, name, handler_module, config_map}`.
+  Once defined, a handler can be explicitly attached in your
+  `c:Application.start/2` callback, typically in `lib/my_app/application.ex`
+  with `Logger.add_handlers/1`:
+
+      Logger.add_handlers(:my_app)
+
+  You can also add, remove, and update handlers at runtime with the help
+  of the Erlang's [`:logger`](`:logger`) module.
+
+  ### Custom handlers
+
+  You may also develop your own handlers. Handlers run in the same
+  process as the process logging the message/event. This gives developers
+  flexibility but they should avoid performing any long running action in
+  such handlers, as it may slow down the action being executed considerably.
+
+  You must implement the [`:logger_handler`](`:logger_handler`) behaviour
+  to define custom handlers, which has only one required callback:
+
+      defmodule MyApp.CustomHandler do
+        @behaviour :logger_handler
+
+        def log(event, _config) do
+          IO.inspect(event)
+        end
+      end
+
+  Then you must define the handler in your configuration file:
+
+      config :my_app, :logger, [
+        {:handler, :my_handler, MyApp.CustomHandler, _config = %{}}
+      ]
+
+  And attach it on your application start using `Logger.add_handlers/1`,
+  as in the previous section.
+
+  Note there is no built-in overload protection for Erlang handlers,
+  so it is your responsibility to implement it if necessary. One alternative is
+  to use the [`:logger_backends`](https://github.com/elixir-lang/logger_backends)
+  project, which sets up a log handler with overload protection and allows
+  incoming events to be dispatched to multiple backends, although one must be
+  careful for backends to not become a bottleneck during logging.
+
+  ### Filtering
+
+  You can add filters to any handler. For example, to filter out logs
+  that contain a particular string, you could create a module:
+
+      defmodule LogFilter do
+        def filter(log_event, _opts) do
+          case log_event do
+            %{msg: {:string, msg}} ->
+              # msg may be a charlist or a binary
+              if to_string(msg) =~ "password" do
+                :stop
+              else
+                :ignore
+              end
+
+            _ ->
+              :ignore
+          end
+        end
+      end
+
+  The filter may return the possibly modified event (to change the
+  event used by subsequent filters), `:stop` (to discard the event),
+  or `:ignore` (to ignore the filter and continue with the subsequent filters).
+
+  Then you can attach the filter, either as a primary filter (which
+  applies to all handlers), or to a specific handler, when you start
+  your application, such as in the `c:Application.start/2` callback:
+
+      :logger.add_primary_filter(:word_filter, {&LogFilter.filter/2, []})
+
+  ## Backends and backwards compatibility
+
+  Prior to Elixir v1.15, custom logging could be achieved with Logger
+  backends. The main API for writing Logger backends have been moved to
+  the [`:logger_backends`](https://github.com/elixir-lang/logger_backends)
+  project. However, the backends API is still part of Elixir for backwards
+  compatibility.
+
+  Important remarks:
+
+    * If the `:backends` key is set and it doesn't have the `:console` entry,
+      we assume that you want to disable the built-in logging. You can force
+      logging by setting `config :logger, :default_handler, []`
+
+    * The `:console` backend configuration is automatically mapped to the default
+      handler and default formatter. Previously, you would set:
+
+          config :logger, :console,
+            level: :error,
+            format: "$time $message $metadata"
+
+      This is now equivalent to:
+
+          config :logger, :default_handler,
+            level: :error
+
+          config :logger, :default_formatter,
+            format: "$time $message $metadata"
+
+      All previous console configuration, except for `:level`, now go under
+      `:default_formatter`.
+
+    * If you want to use the previous `:console` implementation based on Logger
+      Backends, you can still set `backends: [Logger.Backends.Console]` and place
+      the configuration under `config :logger, Logger.Backends.Console`. Although
+      consider using the [`:logger_backends`](https://github.com/elixir-lang/logger_backends)
+      project in such cases, as `Logger.Backends.Console` itself will be deprecated
+      in future releases
+
+    * `Logger.Backends` only receive `:debug`, `:info`, `:warning`, and `:error`
+      messages. `:notice` maps to `:info`. `:warn` maps to `:warnings`.
+      All others map to `:error`
+  """
+
+  @type level ::
+          :emergency | :alert | :critical | :error | :warning | :warn | :notice | :info | :debug
+  @type report :: map() | keyword()
+  @type message :: :unicode.chardata() | String.Chars.t() | report()
+  @type metadata :: keyword()
+
+  @type configure_opts :: [
+          level: level(),
+          translator_inspect_opts: Inspect.Opts.t(),
+          sync_threshold: non_neg_integer(),
+          discard_threshold: non_neg_integer(),
+          truncate: non_neg_integer() | :infinity,
+          utc_log: boolean()
+        ]
+
+  @type formatter_opts :: [
+          colors: [
+            enabled: boolean(),
+            debug: atom(),
+            info: atom(),
+            warning: atom(),
+            error: atom()
+          ],
+          format: String.t() | {module(), atom()},
+          metadata: :all | [atom()],
+          truncate: pos_integer() | :infinity,
+          utc_log: boolean()
+        ]
+
+  @new_erlang_levels [:emergency, :alert, :critical, :warning, :notice]
+  @levels [:error, :info, :debug] ++ @new_erlang_levels
+  @metadata :logger_level
+
+  @doc ~S"""
+  Returns all the available levels.
+  """
+  @doc since: "1.16.0"
+  @spec levels() :: [level(), ...]
+  def levels(), do: @levels
+
+  @doc ~S"""
+  Returns the default formatter used by Logger.
+
+  It returns a `Logger.Formatter` built on the `:default_formatter` configuration:
+
+      config :logger, :default_formatter,
+        format: "\n$time $metadata[$level] $message\n",
+        metadata: [:user_id]
+
+  In case of a list, a set of `overrides` can be given to merge into the list.
+  See `Logger.Formatter.new/1` for all options.
+
+  ## Examples
+
+  `Logger` will automatically load a default formatter into the default handler
+  on boot. However, you can use this function if you wish to programmatically replace
+  a handler formatter. For example, inside tests, you might want to change the formatter
+  settings:
+
+      setup tags do
+        formatter = Logger.default_formatter(colors: [enabled: false])
+        :logger.update_handler_config(:default, :formatter, formatter)
+
+        on_exit(fn ->
+          :logger.update_handler_config(:default, :formatter, Logger.default_formatter())
+        end)
+      end
+
+  However, note you should not invoke this function inside `config` files,
+  as this function expects `Logger` to already be configured and started.
+  To start a brand new handler with this formatter, use `Logger.Formatter.new/1`
+  instead.
+  """
+  @doc since: "1.15.0"
+  @spec default_formatter(formatter_opts) :: {module, :logger.formatter_config()}
+  def default_formatter(overrides \\ []) when is_list(overrides) do
+    Application.get_env(:logger, :default_formatter, [])
+    |> Keyword.merge(overrides)
+    |> Logger.Formatter.new()
+  end
+
+  @doc """
+  Alters the current process metadata according to the given enumerable.
+
+  This function will merge the given enumerable into the existing metadata,
+  with the exception of setting a key to `nil`, which will remove that key
+  from the metadata.
+
+  Note some metadata keys are reserved and cannot be overridden. See
+  [the module documentation](#module-metadata) for more information.
+  """
+  @spec metadata(Enumerable.t({atom(), term()})) :: :ok
+  def metadata(enumerable) do
+    case :logger.get_process_metadata() do
+      :undefined ->
+        reset_metadata(enumerable)
+
+      map when is_map(map) ->
+        metadata =
+          Enum.reduce(enumerable, map, fn
+            {k, nil}, acc -> Map.delete(acc, k)
+            {k, v}, acc -> Map.put(acc, k, v)
+          end)
+
+        :ok = :logger.set_process_metadata(metadata)
+    end
+  end
+
+  @doc """
+  Reads the current process metadata.
+
+  This does not return the "global" logger metadata (set via the `:metadata` key in the
+  `:logger` application config), but only the process metadata.
+  """
+  @spec metadata() :: metadata
+  def metadata() do
+    case :logger.get_process_metadata() do
+      :undefined -> []
+      map when is_map(map) -> Map.to_list(map)
+    end
+  end
+
+  @doc """
+  Resets the current process metadata to the given enumerable.
+  """
+  @spec reset_metadata(Enumerable.t({atom(), term()})) :: :ok
+  def reset_metadata(enumerable \\ []) do
+    :ok = :logger.set_process_metadata(filter_out_nils(enumerable))
+  end
+
+  defp filter_out_nils(keyword) do
+    for {_k, v} = elem <- keyword, v != nil, into: %{}, do: elem
+  end
+
+  @doc """
+  Enables logging for the current process.
+
+  Currently the only accepted PID is `self()`.
+
+  Equivalent of:
+
+      delete_process_level(pid)
+  """
+  # TODO: Remove me on v2.0
+  @deprecated "Use Logger.delete_process_level(pid) instead"
+  @spec enable(pid) :: :ok
+  def enable(pid) when pid == self() do
+    delete_process_level(pid)
+  end
+
+  @doc """
+  Disables logging for the current process.
+
+  Currently the only accepted PID is `self()`.
+
+  Equivalent of:
+
+      put_process_level(pid, :none)
+  """
+  # TODO: Remove me on v2.0
+  @deprecated "Use Logger.put_process_level(pid, :none) instead"
+  @spec disable(pid) :: :ok
+  def disable(pid) when pid == self() do
+    put_process_level(pid, :none)
+  end
+
+  @doc """
+  Returns whether the logging is enabled for a given process.
+
+  Currently the only accepted PID is `self()`.
+  """
+  # TODO: Remove me on v2.0
+  @deprecated "Use Logger.get_process_level(pid) instead"
+  @spec enabled?(pid) :: boolean
+  def enabled?(pid) when pid == self() do
+    get_process_level(pid) != :none
+  end
+
+  @doc """
+  Retrieves the `Logger` level.
+
+  The `Logger` level can be changed via `configure/1`.
+  """
+  @spec level() :: level() | :all | :none
+  def level() do
+    %{level: level} = :logger.get_primary_config()
+
+    level
+  end
+
+  @doc """
+  Compares log levels.
+
+  Receives two log levels and compares the `left` level
+  against the `right` level and returns:
+
+    * `:lt` if `left` is less than `right`
+    * `:eq` if `left` and `right` are equal
+    * `:gt` if `left` is greater than `right`
+
+  ## Examples
+
+      iex> Logger.compare_levels(:debug, :warning)
+      :lt
+      iex> Logger.compare_levels(:error, :info)
+      :gt
+
+  """
+  @spec compare_levels(level, level) :: :lt | :eq | :gt
+  def compare_levels(left, right) do
+    :logger.compare_levels(
+      elixir_level_to_erlang_level(left),
+      elixir_level_to_erlang_level(right)
+    )
+  end
+
+  @doc """
+  Configures the logger.
+
+  See the "Runtime Configuration" section in the `Logger` module
+  documentation for the available options. The changes done here
+  are automatically persisted to the `:logger` application
+  environment.
+  """
+  @valid_options [
+    :always_evaluate_messages,
+    :compile_time_application,
+    :compile_time_purge_level,
+    :compile_time_purge_matching,
+    :truncate,
+    :utc_log,
+    :translator_inspect_opts
+  ]
+  @backend_options [:sync_threshold, :discard_threshold, :truncate, :utc_log]
+  @spec configure(configure_opts) :: :ok
+  def configure(options) do
+    for {k, v} <- options do
+      cond do
+        k == :level -> :logger.set_primary_config(:level, elixir_level_to_erlang_level(v))
+        k in @valid_options -> Application.put_env(:logger, k, v)
+        true -> :ok
+      end
+    end
+
+    case Keyword.take(options, @backend_options) do
+      [] ->
+        :ok
+
+      backend_options ->
+        for {key, _} <- backend_options do
+          IO.warn_once(
+            {__MODULE__, :configure, key},
+            fn ->
+              "setting #{inspect(key)} in Logger.configure/2 is deprecated, " <>
+                "add the :logger_backends dependency and configure it instead"
+            end,
+            3
+          )
+        end
+
+        Logger.Backends.Internal.configure(backend_options)
+    end
+
+    :ok
+  end
+
+  @doc """
+  Flushes the logger.
+
+  This guarantees all logger handlers flush to disk or storage.
+  This is useful for testing but it should be avoided in production,
+  as it could force logger handlers to drop whatever they are doing
+  and flush, even if continuing to buffer would be the most performant
+  option.
+  """
+  @spec flush :: :ok
+  def flush do
+    for %{id: id, module: module} <- :logger.get_handler_config(),
+        function_exported?(module, :filesync, 1) do
+      try do
+        module.filesync(id)
+      catch
+        _, _ -> :ok
+      end
+    end
+
+    :ok
+  end
+
+  @doc """
+  Puts logging level for given module.
+
+  This will take priority over the primary level set, so it can be
+  used to increase or decrease verbosity of some parts of the project.
+
+  ## Example
+
+      defmodule Foo do
+        require Logger
+
+        def log, do: Logger.debug("foo")
+      end
+
+      Logger.configure(level: :error)
+      Logger.put_module_level(Foo, :all)
+
+      Foo.log()
+      # This will print the message even if global level is :error
+
+  """
+  @doc since: "1.11.0"
+  @spec put_module_level(module() | [module()], level() | :all | :none) :: :ok | {:error, term()}
+  defdelegate put_module_level(mod, level), to: :logger, as: :set_module_level
+
+  @doc """
+  Gets logging level for given module.
+
+  The returned value will be the effective value used. If no value
+  was set for a given module, then it will not be present in
+  the returned list.
+  """
+  @doc since: "1.11.0"
+  @spec get_module_level(module() | [module()]) :: [{module(), level() | :all | :none}]
+  defdelegate get_module_level(mod), to: :logger
+
+  @doc """
+  Resets the logging level for a given module to the primary level.
+  """
+  @doc since: "1.11.0"
+  @spec delete_module_level(module() | [module()]) :: :ok
+  defdelegate delete_module_level(module), to: :logger, as: :unset_module_level
+
+  @doc """
+  Resets the logging level for all modules to the primary level.
+  """
+  @doc since: "1.11.0"
+  @spec delete_all_module_levels() :: :ok
+  defdelegate delete_all_module_levels(), to: :logger, as: :unset_module_level
+
+  @doc """
+  Puts logging level for modules in a given application.
+
+  This will take priority over the primary level set, so it can be
+  used to increase or decrease verbosity of some parts of the project.
+
+  Equivalent of:
+
+      appname |> Application.spec(:modules) |> Logger.put_module_level(level)
+  """
+  @doc since: "1.13.0"
+  @spec put_application_level(atom(), level() | :all | :none) :: :ok | {:error, :not_loaded}
+  defdelegate put_application_level(appname, level), to: :logger, as: :set_application_level
+
+  @doc """
+  Resets logging level for all modules in the given application to the primary level.
+
+  Equivalent of:
+
+      appname |> Application.spec(:modules) |> Logger.delete_module_level()
+  """
+  @doc since: "1.13.0"
+  @spec delete_application_level(application) :: :ok | {:error, {:not_loaded, application}}
+        when application: atom()
+  defdelegate delete_application_level(appname), to: :logger, as: :unset_application_level
+
+  @doc """
+  Puts logging level for the current process.
+
+  Currently the only accepted PID is `self()`.
+
+  Different from `put_module_level/2`, the process level doesn't take priority
+  over the global level, but instead works alongside it. Effectively, the higher
+  logger level is used.
+  """
+  @doc since: "1.15.0"
+  @spec put_process_level(pid(), level() | :all | :none) :: :ok
+  def put_process_level(pid, level) when pid == self() do
+    Process.put(@metadata, elixir_level_to_erlang_level(level))
+    :ok
+  end
+
+  @doc """
+  Gets logging level for the current process.
+
+  Currently the only accepted PID is `self()`.
+
+  The returned value will be the effective value used. If no value
+  was set for a given process, then `nil` is returned.
+  """
+  @doc since: "1.15.0"
+  @spec get_process_level(pid) :: level() | :all | :none | nil
+  def get_process_level(pid) when pid == self() do
+    Process.get(@metadata, nil)
+  end
+
+  @doc """
+  Resets logging level for the current process to the primary level.
+
+  Currently the only accepted PID is `self()`.
+  """
+  @doc since: "1.15.0"
+  @spec delete_process_level(pid()) :: :ok
+  def delete_process_level(pid) when pid == self() do
+    Process.delete(@metadata)
+    :ok
+  end
+
+  @doc """
+  Adds the handlers configured in the `:logger` application parameter
+  of the given `app`.
+
+  This is used to register new handlers into the logging system.
+  See [the module documentation](#module-erlang-otp-handlers) for
+  more information.
+  """
+  @doc since: "1.15.0"
+  @spec add_handlers(atom()) :: :ok | {:error, term}
+  def add_handlers(app) when is_atom(app) do
+    :logger.add_handlers(app)
+  end
+
+  @doc """
+  Adds a new backend.
+  """
+  # TODO: Remove me on v2.0
+  @deprecated "Use LoggerBackends.add/2 from :logger_backends dependency"
+  def add_backend(backend, opts \\ []) do
+    Logger.Backends.Internal.add(backend, opts)
+  end
+
+  @doc """
+  Removes a backend.
+  """
+  # TODO: Remove me on v2.0
+  @deprecated "Use LoggerBackends.remove/2 from :logger_backends dependency"
+  def remove_backend(backend, opts \\ []) do
+    Logger.Backends.Internal.remove(backend, opts)
+  end
+
+  @doc """
+  Configures the given backend.
+  """
+  # TODO: Remove me on v2.0
+  @deprecated "Use LoggerBackends.configure/2 from :logger_backends dependency"
+  def configure_backend(:console, options) when is_list(options) do
+    options = Keyword.merge(Application.get_env(:logger, :console, []), options)
+    Application.put_env(:logger, :console, options)
+    {with_level, without_level} = Keyword.split(options, [:level])
+    config = Map.new(with_level ++ [formatter: Logger.Formatter.new(without_level)])
+    :logger.update_handler_config(:default, config)
+  end
+
+  def configure_backend(backend, options) do
+    Logger.Backends.Internal.configure(backend, options)
+  end
+
+  @doc """
+  Adds a new translator.
+  """
+  @spec add_translator({module, function :: atom}) :: :ok
+  def add_translator({mod, fun} = translator) when is_atom(mod) and is_atom(fun) do
+    update_translators(&[translator | List.delete(&1, translator)])
+  end
+
+  @doc """
+  Removes a translator.
+  """
+  @spec remove_translator({module, function :: atom}) :: :ok
+  def remove_translator({mod, fun} = translator) when is_atom(mod) and is_atom(fun) do
+    update_translators(&List.delete(&1, translator))
+  end
+
+  defp update_translators(updater) do
+    :elixir_config.serial(fn ->
+      translators = updater.(Application.fetch_env!(:logger, :translators))
+      Application.put_env(:logger, :translators, translators)
+
+      with %{filters: filters} <- :logger.get_primary_config(),
+           {{_, {fun, config}}, filters} <- List.keytake(filters, :logger_translator, 0) do
+        config = %{config | translators: translators}
+        :ok = :logger.set_primary_config(:filters, filters ++ [logger_translator: {fun, config}])
+      end
+    end)
+
+    :ok
+  end
+
+  @doc """
+  Logs a message dynamically.
+
+  Opposite to `log/3`, `debug/2`, `info/2`, and friends, the arguments
+  given to `bare_log/3` are always evaluated. However, you can pass
+  anonymous functions to `bare_log/3` and they will only be evaluated
+  if there is something to be logged.
+  """
+  @spec bare_log(level, message | (-> message | {message, keyword}), metadata) :: :ok
+  def bare_log(level, message_or_fun, metadata \\ []) do
+    level = elixir_level_to_erlang_level(level)
+
+    if :logger_config.allow(level) do
+      __do_log__(level, message_or_fun, %{}, Map.new(metadata))
+    end
+
+    :ok
+  end
+
+  @doc false
+  def __should_log__(level, module) do
+    level = elixir_level_to_erlang_level(level)
+
+    if :logger_config.allow(level, module) do
+      level
+    end
+  end
+
+  @doc false
+  def __evaluate_log__(data) when is_function(data, 0) do
+    data.()
+  end
+
+  def __evaluate_log__(data) do
+    data
+  end
+
+  @doc false
+  def __do_log__(level, fun, location, metadata)
+      when is_function(fun, 0) and is_map(location) and is_map(metadata) do
+    case fun.() do
+      {msg, meta} ->
+        __do_log__(level, msg, location, Enum.into(meta, metadata))
+
+      msg ->
+        __do_log__(level, msg, location, metadata)
+    end
+  end
+
+  def __do_log__(level, msg, location, metadata)
+      when level in @levels and is_map(location) and is_map(metadata) do
+    if is_binary(msg) or is_list(msg) or is_map(msg) do
+      :logger.macro_log(location, level, msg, add_elixir_domain(metadata))
+    else
+      IO.warn(
+        "passing #{inspect(msg)} to Logger is deprecated, expected a map, a keyword list, " <>
+          "a string, a list of strings, or a zero-arity anonymous function"
+      )
+
+      :logger.macro_log(location, level, to_string(msg), add_elixir_domain(metadata))
+    end
+  end
+
+  defp add_elixir_domain(%{domain: domain} = metadata) when is_list(domain) do
+    %{metadata | domain: [:elixir | domain]}
+  end
+
+  defp add_elixir_domain(metadata), do: Map.put(metadata, :domain, [:elixir])
+
+  for level <- @levels do
+    report = [something: :reported, this: level]
+    metadata = [user_id: 42, request_id: "xU32kFa"]
+    article = if level in [:info, :error, :alert, :emergency], do: "an", else: "a"
+
+    @doc """
+    Logs #{article} #{level} message.
+
+    Returns `:ok`.
+
+    ## Examples
+
+    Logging a message (string or iodata):
+
+        Logger.#{level}("this is #{article} #{level} message")
+
+    Report message (maps or keywords):
+
+        # as keyword list
+        Logger.#{level}(#{inspect(report)})
+
+        # as map
+        Logger.#{level}(#{inspect(Map.new(report))})
+
+    Report message with metadata (maps or keywords):
+
+        # as a keyword list
+        Logger.#{level}("this is #{article} #{level} message", #{inspect(metadata)})
+
+        # as map
+        Logger.#{level}("this is #{article} #{level} message", #{inspect(Map.new(metadata))})
+    """
+
+    # Only macros generated for the "new" Erlang levels are available since 1.11.0. Other
+    # ones, such as :info or :debug, are available since the early days of Elixir.
+    if level in @new_erlang_levels do
+      @doc since: "1.11.0"
+    end
+
+    defmacro unquote(level)(message_or_fun, metadata \\ []) do
+      maybe_log(unquote(level), message_or_fun, metadata, __CALLER__)
+    end
+  end
+
+  @deprecated "Use Logger.warning/2 instead"
+  defmacro warn(message_or_fun, metadata \\ []) do
+    maybe_log(:warning, message_or_fun, metadata, __CALLER__)
+  end
+
+  @doc """
+  Logs a message with the given `level`.
+
+  Returns `:ok`.
+
+  The macros `debug/2`, `info/2`, `notice/2`, `warning/2`,
+  `error/2`, `critical/2`, `alert/2`, and `emergency/2` are
+  preferred over this macro as they can automatically eliminate
+  the call to `Logger` altogether at compile time if desired
+  (see the documentation for the `Logger` module).
+  """
+  defmacro log(level, message_or_fun, metadata \\ []) do
+    macro_log(level, message_or_fun, metadata, __CALLER__)
+  end
+
+  defp macro_log(level, data, metadata, caller) do
+    {maybe_application, file} = compile_time_application_and_file(caller)
+
+    location =
+      case caller do
+        %{module: module, function: {fun, arity}, line: line} ->
+          %{mfa: {module, fun, arity}, file: file, line: line}
+
+        _ ->
+          %{}
+      end
+
+    {compile_metadata, quoted_metadata} =
+      if Keyword.keyword?(metadata) do
+        metadata = Keyword.merge(maybe_application, metadata)
+        {Map.merge(location, Map.new(metadata)), escape_metadata(metadata)}
+      else
+        {%{},
+         quote do
+           Enum.into(unquote(metadata), unquote(escape_metadata(maybe_application)))
+         end}
+      end
+
+    compile_level = if is_atom(level), do: level, else: :error
+
+    cond do
+      compile_time_purge_matching?(compile_level, compile_metadata) ->
+        no_log(data, quoted_metadata)
+
+      Application.get_env(:logger, :always_evaluate_messages, false) ->
+        quote do
+          data = Logger.__evaluate_log__(unquote(data))
+          metadata = unquote(quoted_metadata)
+
+          case Logger.__should_log__(unquote(level), __MODULE__) do
+            nil -> :ok
+            level -> Logger.__do_log__(level, data, unquote(Macro.escape(location)), metadata)
+          end
+        end
+
+      true ->
+        quote do
+          case Logger.__should_log__(unquote(level), __MODULE__) do
+            nil ->
+              :ok
+
+            level ->
+              Logger.__do_log__(
+                level,
+                unquote(data),
+                unquote(Macro.escape(location)),
+                unquote(quoted_metadata)
+              )
+          end
+        end
+    end
+  end
+
+  defp escape_metadata(metadata) do
+    {_, metadata} =
+      Keyword.get_and_update(metadata, :mfa, fn
+        nil -> :pop
+        mfa -> {mfa, Macro.escape(mfa)}
+      end)
+
+    {:%{}, [], metadata}
+  end
+
+  defp compile_time_application_and_file(%{file: file}) do
+    if app = Application.get_env(:logger, :compile_time_application) do
+      {[application: app], file |> Path.relative_to_cwd() |> String.to_charlist()}
+    else
+      {[], String.to_charlist(file)}
+    end
+  end
+
+  defp compile_time_purge_matching?(level, compile_metadata) do
+    matching = Application.get_env(:logger, :compile_time_purge_matching, [])
+
+    if not is_list(matching) do
+      bad_compile_time_purge_matching!(matching)
+    end
+
+    Enum.any?(matching, fn filter ->
+      if not is_list(filter) do
+        bad_compile_time_purge_matching!(matching)
+      end
+
+      Enum.all?(filter, fn
+        {:level_lower_than, min_level} ->
+          compare_levels(level, min_level) == :lt
+
+        {:module, module} ->
+          match?({:ok, {^module, _, _}}, Map.fetch(compile_metadata, :mfa))
+
+        {:function, func} ->
+          case Map.fetch(compile_metadata, :mfa) do
+            {:ok, {_, f, a}} -> "#{f}/#{a}" == func
+            _ -> false
+          end
+
+        {k, v} when is_atom(k) ->
+          Map.fetch(compile_metadata, k) == {:ok, v}
+
+        _ ->
+          bad_compile_time_purge_matching!(matching)
+      end)
+    end)
+  end
+
+  defp bad_compile_time_purge_matching!(matching) do
+    raise "expected :compile_time_purge_matching to be a list of keyword lists, " <>
+            "got: #{inspect(matching)}"
+  end
+
+  defp maybe_log(level, data, metadata, caller) do
+    min_level =
+      if env_level = Application.get_env(:logger, :compile_time_purge_level) do
+        IO.warn(
+          ":compile_time_purge_level option for the :logger application is deprecated, " <>
+            "use :compile_time_purge_matching instead",
+          Macro.Env.stacktrace(caller)
+        )
+
+        env_level
+      else
+        :debug
+      end
+
+    if compare_levels(level, min_level) != :lt do
+      macro_log(level, data, metadata, caller)
+    else
+      no_log(data, metadata)
+    end
+  end
+
+  defp no_log(data, metadata) do
+    if Application.get_env(:logger, :always_evaluate_messages, false) do
+      quote do
+        Logger.__evaluate_log__(unquote(data))
+        unquote(metadata)
+        :ok
+      end
+    else
+      # We wrap the contents in an anonymous function
+      # to avoid unused variable warnings.
+      quote do
+        _ = fn -> {unquote(data), unquote(metadata)} end
+        :ok
+      end
+    end
+  end
+
+  defp elixir_level_to_erlang_level(:warn) do
+    IO.warn("the log level :warn is deprecated, use :warning instead")
+    :warning
+  end
+
+  defp elixir_level_to_erlang_level(other), do: other
+end
diff --git a/lib/logger/lib/logger/app.ex b/lib/logger/lib/logger/app.ex
new file mode 100644
index 00000000000..c63338a6d0b
--- /dev/null
+++ b/lib/logger/lib/logger/app.ex
@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.App do
+  @moduledoc false
+
+  use Application
+
+  @doc false
+  def start(_type, _args) do
+    otp_reports? = Application.fetch_env!(:logger, :handle_otp_reports)
+    sasl_reports? = Application.fetch_env!(:logger, :handle_sasl_reports)
+    translators = Application.fetch_env!(:logger, :translators)
+
+    {backends, console?} =
+      case Application.fetch_env(:logger, :backends) do
+        {:ok, backends} ->
+          IO.warn("""
+          the :backends key for the :logger application is deprecated.
+          Here is how to proceed:
+
+          1. If you want to set it to [:console], simply remove the option.
+
+          2. If you want to disable logging, remove :backends and instead set:
+
+              config :logger, :default_handler, false
+
+          3. If you want to configure any other backend, then it is recommended
+             to add `{:logger_backends, "~> 1.0"}` as a dependency and call
+             `LoggerBackends.add(CustomBackend)` in your application start callback
+          """)
+
+          {List.delete(backends, :console), :console in backends}
+
+        :error ->
+          {[], true}
+      end
+
+    # TODO: Warn if :console is set on Elixir v1.20
+    default_handler =
+      if console = Application.get_env(:logger, :console) do
+        {handler, formatter} = Keyword.split(console, [:level])
+
+        with :error <- Application.fetch_env(:logger, :default_formatter) do
+          Application.put_env(:logger, :default_formatter, formatter)
+        end
+
+        handler
+      else
+        []
+      end
+
+    primary_config = :logger.get_primary_config()
+    :ok = :logger.set_primary_config(:level, default_level())
+
+    # If there is additional metadata in the :logger config, we merge it into
+    # the primary :logger metadata.
+    with [_ | _] = metadata <- Application.fetch_env!(:logger, :metadata) do
+      :ok = :logger.set_primary_config(:metadata, Enum.into(metadata, primary_config.metadata))
+    end
+
+    process_level_filter = {&Logger.Utils.process_level/2, []}
+    :ok = :logger.add_primary_filter(:logger_process_level, process_level_filter)
+
+    translator_config = %{translators: translators, otp: otp_reports?, sasl: sasl_reports?}
+    translator_filter = {&Logger.Utils.translator/2, translator_config}
+    :ok = :logger.add_primary_filter(:logger_translator, translator_filter)
+
+    revert = [{:set_primary_config, [primary_config]} | remove_erlang_handler()]
+    children = if backends != [], do: [Logger.Backends.Internal], else: []
+
+    case Supervisor.start_link(children, strategy: :one_for_one, name: Logger.Supervisor) do
+      {:ok, sup} ->
+        {:ok, sup, [add_elixir_handler(console? && default_handler) | revert]}
+
+      {:error, _} = error ->
+        redo(revert)
+        error
+    end
+  end
+
+  @doc false
+  def start do
+    Application.start(:logger)
+  end
+
+  @doc false
+  def stop(revert) do
+    # TODO: Remove this line and all of Logger.Backends.* on Elixir v2.0+
+    _ = :logger.remove_handler(Logger)
+    _ = :logger.remove_primary_filter(:logger_process_level)
+    _ = :logger.remove_primary_filter(:logger_translator)
+
+    redo(revert)
+
+    :logger.add_primary_filter(
+      :silence_logger_exit,
+      {&Logger.Utils.silence_logger_exit/2, []}
+    )
+  end
+
+  @doc false
+  def config_change(changed, _new, _removed) do
+    # All other config has already been persisted, we only need to
+    # update the level and reload the logger state.
+    Logger.configure(Keyword.take(changed, [:level]))
+  end
+
+  @doc """
+  Stops the application without sending messages to error logger.
+  """
+  def stop() do
+    Application.stop(:logger)
+  end
+
+  ## Helpers
+
+  defp default_level() do
+    case Application.get_env(:logger, :level, :debug) do
+      :warn ->
+        IO.warn(
+          ":logger :level has been set to :warn in config files, please use :warning instead"
+        )
+
+        :warning
+
+      level ->
+        level
+    end
+  end
+
+  defp remove_erlang_handler() do
+    with {:ok, %{module: module} = config} <- :logger.get_handler_config(:default),
+         :ok <- :logger.remove_handler(:default) do
+      [{:add_handler, [:default, module, config]}]
+    else
+      _ -> []
+    end
+  end
+
+  defp add_elixir_handler(default_handler) do
+    if handler = Application.get_env(:logger, :default_handler, default_handler) do
+      config =
+        handler
+        |> Keyword.put_new(:filters, remote_gl: {&:logger_filters.remote_gl/2, :stop})
+        |> Keyword.put_new(:filter_default, :log)
+        |> Keyword.put_new(:module, :logger_std_h)
+        |> Keyword.put_new_lazy(:formatter, &Logger.default_formatter/0)
+        |> Keyword.replace_lazy(:config, &Map.new/1)
+        |> Map.new()
+
+      case :logger.add_handler(:default, config.module, config) do
+        :ok ->
+          [{:remove_handler, [:default]}]
+
+        {:error, error} ->
+          IO.puts(:stderr, "Could not attach default Logger handler: #{inspect(error)}")
+      end
+    else
+      []
+    end
+  end
+
+  defp redo(handlers) do
+    for {fun, args} <- handlers do
+      apply(:logger, fun, args)
+    end
+  end
+end
diff --git a/lib/logger/lib/logger/backends/config.ex b/lib/logger/lib/logger/backends/config.ex
new file mode 100644
index 00000000000..90907a2bf53
--- /dev/null
+++ b/lib/logger/lib/logger/backends/config.ex
@@ -0,0 +1,109 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.Backends.Config do
+  @moduledoc false
+
+  @behaviour :gen_event
+  @name __MODULE__
+  @update_counter_message {__MODULE__, :update_counter}
+
+  def configure(options) do
+    :gen_event.call(Logger, @name, {:configure, options})
+  end
+
+  ## Callbacks
+
+  def init(counter) do
+    state = load_state(counter)
+    state = update_counter(state, false)
+    schedule_update_counter(state)
+    {:ok, state}
+  end
+
+  defp load_state(counter) do
+    {counter, :log, Application.fetch_env!(:logger, :discard_threshold),
+     Application.fetch_env!(:logger, :discard_threshold_periodic_check)}
+  end
+
+  def handle_event(_event, state) do
+    {:ok, update_counter(state, false)}
+  end
+
+  def handle_call({:configure, options}, {counter, _, _, _}) do
+    Enum.each(options, fn {key, value} ->
+      Application.put_env(:logger, key, value)
+    end)
+
+    {:ok, :ok, load_state(counter)}
+  end
+
+  def handle_info(@update_counter_message, state) do
+    state = update_counter(state, true)
+    schedule_update_counter(state)
+    {:ok, state}
+  end
+
+  def handle_info(_, state) do
+    {:ok, state}
+  end
+
+  def terminate(_reason, _state) do
+    :ok
+  end
+
+  def code_change(_old, state, _extra) do
+    {:ok, state}
+  end
+
+  @counter_pos 1
+
+  defp update_counter({counter, log, discard_threshold, discard_period}, periodic_check?) do
+    # If length is more than the total, it means the counter is behind,
+    # due to non-log messages, so we need to increase the counter.
+    #
+    # If length is less than the total, then we either have a spike or
+    # the counter drifted due to failures.
+    #
+    # Because we always bump the counter and then we send the message,
+    # there is a chance clients have bumped the counter but they did not
+    # deliver the message yet. Those bumps will be lost. At the same time,
+    # we are careful to read the counter first here, so if the counter is
+    # bumped after we read from it, those bumps won't be lost.
+    total = :counters.get(counter, @counter_pos)
+    {:message_queue_len, length} = Process.info(self(), :message_queue_len)
+    :counters.add(counter, @counter_pos, length - total)
+
+    # In case we are logging but we reached the threshold, we log that we
+    # started discarding messages. This can only be reverted by the periodic
+    # discard check.
+    cond do
+      total >= discard_threshold ->
+        if log == :log or periodic_check? do
+          warn("Attempted to log #{total} messages, which is above :discard_threshold")
+        end
+
+        {counter, :discard, discard_threshold, discard_period}
+
+      log == :discard and periodic_check? ->
+        warn("Attempted to log #{total} messages, which is below :discard_threshold")
+        {counter, :log, discard_threshold, discard_period}
+
+      true ->
+        {counter, log, discard_threshold, discard_period}
+    end
+  end
+
+  defp warn(message) do
+    system_time = :os.system_time(:microsecond)
+    utc_log = Application.fetch_env!(:logger, :utc_log)
+    date_time_ms = Logger.Formatter.system_time_to_date_time_ms(system_time, utc_log)
+    event = {Logger, message, date_time_ms, pid: self()}
+    :gen_event.notify(self(), {:warning, Process.group_leader(), event})
+  end
+
+  defp schedule_update_counter({_, _, _, discard_period}) do
+    Process.send_after(self(), @update_counter_message, discard_period)
+  end
+end
diff --git a/lib/logger/lib/logger/backends/console.ex b/lib/logger/lib/logger/backends/console.ex
new file mode 100644
index 00000000000..87e6501fe4e
--- /dev/null
+++ b/lib/logger/lib/logger/backends/console.ex
@@ -0,0 +1,315 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.Backends.Console do
+  @moduledoc ~S"""
+  A logger backend that logs messages by printing them to the console.
+
+  This backend was typically configured as `config :logger, :console`,
+  but it has been deprecated in favor of `:default_handler` and
+  `:default_formatter`. However, for backwards compatibility, you can
+  still add it as:
+
+      config :logger, :backends, [Logger.Backends.Console]
+
+  However, if you plan to continue using Logger backends in the long
+  term, consider using the [`:logger_backends`](https://github.com/elixir-lang/logger_backends)
+  project.
+  """
+
+  @moduledoc deprecated: "Use LoggerBackends.Console from :logger_backends dependency"
+  @behaviour :gen_event
+
+  defstruct buffer: [],
+            buffer_size: 0,
+            colors: nil,
+            device: nil,
+            format: nil,
+            level: nil,
+            max_buffer: nil,
+            metadata: nil,
+            output: nil,
+            ref: nil
+
+  # TODO: Deprecate me on Elixir v1.20
+  @impl true
+  def init(atom) when is_atom(atom) do
+    IO.warn(
+      "Logger.Backends.Console is deprecated, " <>
+        "you should migrate to the new :console handler, " <>
+        "see Logger.Backends.Console docs for more information"
+    )
+
+    config = read_env()
+    device = Keyword.get(config, :device, :user)
+
+    if Process.whereis(device) do
+      {:ok, init(config, %__MODULE__{})}
+    else
+      {:error, :ignore}
+    end
+  end
+
+  def init({__MODULE__, opts}) when is_list(opts) do
+    config = configure_merge(read_env(), opts)
+    {:ok, init(config, %__MODULE__{})}
+  end
+
+  @impl true
+  def handle_call({:configure, options}, state) do
+    {:ok, :ok, configure(options, state)}
+  end
+
+  @impl true
+  def handle_event({level, _gl, {Logger, msg, ts, md}}, state) do
+    %{level: log_level, ref: ref, buffer_size: buffer_size, max_buffer: max_buffer} = state
+
+    {:erl_level, level} = List.keyfind(md, :erl_level, 0, {:erl_level, level})
+
+    cond do
+      not meet_level?(level, log_level) ->
+        {:ok, state}
+
+      is_nil(ref) ->
+        {:ok, log_event(level, msg, ts, md, state)}
+
+      buffer_size < max_buffer ->
+        {:ok, buffer_event(level, msg, ts, md, state)}
+
+      buffer_size === max_buffer ->
+        state = buffer_event(level, msg, ts, md, state)
+        {:ok, await_io(state)}
+    end
+  end
+
+  def handle_event(:flush, state) do
+    {:ok, flush(state)}
+  end
+
+  def handle_event(_, state) do
+    {:ok, state}
+  end
+
+  @impl true
+  def handle_info({:io_reply, ref, msg}, %{ref: ref} = state) do
+    {:ok, handle_io_reply(msg, state)}
+  end
+
+  def handle_info({:DOWN, ref, _, pid, reason}, %{ref: ref}) do
+    raise "device #{inspect(pid)} exited: " <> Exception.format_exit(reason)
+  end
+
+  def handle_info(_, state) do
+    {:ok, state}
+  end
+
+  @impl true
+  def code_change(_old_vsn, state, _extra) do
+    {:ok, state}
+  end
+
+  @impl true
+  def terminate(_reason, _state) do
+    :ok
+  end
+
+  ## Helpers
+
+  defp meet_level?(_lvl, nil), do: true
+
+  defp meet_level?(lvl, min) do
+    Logger.compare_levels(lvl, min) != :lt
+  end
+
+  defp configure(options, state) do
+    config = configure_merge(read_env(), options)
+    Application.put_env(:logger, __MODULE__, config)
+    init(config, state)
+  end
+
+  defp init(config, state) do
+    level = Keyword.get(config, :level)
+    device = Keyword.get(config, :device, :user)
+    format = Logger.Formatter.compile(Keyword.get(config, :format))
+    colors = configure_colors(config)
+    metadata = Keyword.get(config, :metadata, []) |> configure_metadata()
+    max_buffer = Keyword.get(config, :max_buffer, 32)
+
+    %{
+      state
+      | format: format,
+        metadata: metadata,
+        level: level,
+        colors: colors,
+        device: device,
+        max_buffer: max_buffer
+    }
+  end
+
+  defp configure_metadata(:all), do: :all
+  defp configure_metadata(metadata), do: Enum.reverse(metadata)
+
+  defp configure_merge(env, options) do
+    Keyword.merge(env, options, fn
+      :colors, v1, v2 -> Keyword.merge(v1, v2)
+      _, _v1, v2 -> v2
+    end)
+  end
+
+  defp configure_colors(config) do
+    colors = Keyword.get(config, :colors, [])
+
+    warning =
+      Keyword.get_lazy(colors, :warning, fn ->
+        if warn = Keyword.get(colors, :warn) do
+          warn
+        else
+          :yellow
+        end
+      end)
+
+    %{
+      emergency: Keyword.get(colors, :error, :red),
+      alert: Keyword.get(colors, :error, :red),
+      critical: Keyword.get(colors, :error, :red),
+      error: Keyword.get(colors, :error, :red),
+      warning: warning,
+      notice: Keyword.get(colors, :info, :normal),
+      info: Keyword.get(colors, :info, :normal),
+      debug: Keyword.get(colors, :debug, :cyan),
+      enabled: Keyword.get(colors, :enabled, IO.ANSI.enabled?())
+    }
+  end
+
+  defp log_event(level, msg, ts, md, %{device: device} = state) do
+    output = format_event(level, msg, ts, md, state)
+    %{state | ref: async_io(device, output), output: output}
+  end
+
+  defp buffer_event(level, msg, ts, md, state) do
+    %{buffer: buffer, buffer_size: buffer_size} = state
+    buffer = [buffer | format_event(level, msg, ts, md, state)]
+    %{state | buffer: buffer, buffer_size: buffer_size + 1}
+  end
+
+  defp async_io(name, output) when is_atom(name) do
+    case Process.whereis(name) do
+      device when is_pid(device) ->
+        async_io(device, output)
+
+      nil ->
+        raise "no device registered with the name #{inspect(name)}"
+    end
+  end
+
+  defp async_io(device, output) when is_pid(device) do
+    ref = Process.monitor(device)
+    send(device, {:io_request, self(), ref, {:put_chars, :unicode, output}})
+    ref
+  end
+
+  defp await_io(%{ref: nil} = state), do: state
+
+  defp await_io(%{ref: ref} = state) do
+    receive do
+      {:io_reply, ^ref, :ok} ->
+        handle_io_reply(:ok, state)
+
+      {:io_reply, ^ref, error} ->
+        handle_io_reply(error, state)
+        |> await_io()
+
+      {:DOWN, ^ref, _, pid, reason} ->
+        raise "device #{inspect(pid)} exited: " <> Exception.format_exit(reason)
+    end
+  end
+
+  defp format_event(level, msg, ts, md, state) do
+    %{format: format, metadata: keys, colors: colors} = state
+
+    format
+    |> Logger.Formatter.format(level, msg, ts, take_metadata(md, keys))
+    |> color_event(level, colors, md)
+  end
+
+  defp take_metadata(metadata, :all) do
+    metadata
+  end
+
+  defp take_metadata(metadata, keys) do
+    Enum.reduce(keys, [], fn key, acc ->
+      case Keyword.fetch(metadata, key) do
+        {:ok, val} -> [{key, val} | acc]
+        :error -> acc
+      end
+    end)
+  end
+
+  defp color_event(data, _level, %{enabled: false}, _md), do: data
+
+  defp color_event(data, level, %{enabled: true} = colors, md) do
+    color = md[:ansi_color] || Map.fetch!(colors, level)
+    [IO.ANSI.format_fragment(color, true), data | IO.ANSI.reset()]
+  end
+
+  defp log_buffer(%{buffer_size: 0, buffer: []} = state), do: state
+
+  defp log_buffer(state) do
+    %{device: device, buffer: buffer} = state
+    %{state | ref: async_io(device, buffer), buffer: [], buffer_size: 0, output: buffer}
+  end
+
+  defp handle_io_reply(:ok, %{ref: ref} = state) do
+    Process.demonitor(ref, [:flush])
+    log_buffer(%{state | ref: nil, output: nil})
+  end
+
+  defp handle_io_reply({:error, {:put_chars, :unicode, _} = error}, state) do
+    retry_log(error, state)
+  end
+
+  defp handle_io_reply({:error, :put_chars}, %{output: output} = state) do
+    retry_log({:put_chars, :unicode, output}, state)
+  end
+
+  defp handle_io_reply({:error, {:no_translation, _encoding_from, _encoding_to} = error}, state) do
+    retry_log(error, state)
+  end
+
+  defp handle_io_reply({:error, error}, _) do
+    raise "failure while logging console messages: " <> inspect(error)
+  end
+
+  defp retry_log(error, %{device: device, ref: ref, output: dirty} = state) do
+    Process.demonitor(ref, [:flush])
+
+    try do
+      :unicode.characters_to_binary(dirty)
+    rescue
+      ArgumentError ->
+        clean = ["failure while trying to log malformed data: ", inspect(dirty), ?\n]
+        %{state | ref: async_io(device, clean), output: clean}
+    else
+      {_, good, bad} ->
+        clean = [good | Logger.Formatter.prune(bad)]
+        %{state | ref: async_io(device, clean), output: clean}
+
+      _ ->
+        # A well behaved IO device should not error on good data
+        raise "failure while logging consoles messages: " <> inspect(error)
+    end
+  end
+
+  defp flush(%{ref: nil} = state), do: state
+
+  defp flush(state) do
+    state
+    |> await_io()
+    |> flush()
+  end
+
+  defp read_env do
+    Application.get_env(:logger, __MODULE__, Application.get_env(:logger, :console, []))
+  end
+end
diff --git a/lib/logger/lib/logger/backends/handler.ex b/lib/logger/lib/logger/backends/handler.ex
new file mode 100644
index 00000000000..e39eede7f09
--- /dev/null
+++ b/lib/logger/lib/logger/backends/handler.ex
@@ -0,0 +1,135 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.Backends.Handler do
+  @moduledoc false
+  @internal_keys [:counter]
+
+  def filesync(id) do
+    :gen_event.sync_notify(id, :flush)
+  end
+
+  ## Config management
+
+  def adding_handler(config) do
+    {:ok, update_in(config.config, &Map.merge(default_config(), &1))}
+  end
+
+  def changing_config(:update, config, %{config: :refresh}) do
+    {:ok, update_in(config.config, &Map.merge(&1, default_config()))}
+  end
+
+  def filter_config(%{config: data} = config) do
+    %{config | config: Map.drop(data, @internal_keys)}
+  end
+
+  defp default_config do
+    sync_threshold = Application.fetch_env!(:logger, :sync_threshold)
+    discard_threshold = Application.fetch_env!(:logger, :discard_threshold)
+
+    %{
+      utc_log: Application.fetch_env!(:logger, :utc_log),
+      truncate: Application.fetch_env!(:logger, :truncate),
+      thresholds: {sync_threshold, discard_threshold}
+    }
+  end
+
+  ## Main logging API
+
+  def log(%{level: erl_level, meta: metadata} = event, %{config: config}) do
+    case threshold(config) do
+      :discard ->
+        :ok
+
+      mode ->
+        %{gl: gl} = metadata
+        %{truncate: truncate, utc_log: utc_log?} = config
+        level = erlang_level_to_elixir_level(erl_level)
+        message = Logger.Formatter.format_event(event, truncate)
+
+        timestamp =
+          case metadata do
+            %{time: time} when is_integer(time) and time >= 0 -> time
+            _ -> :os.system_time(:microsecond)
+          end
+
+        date_time_ms = Logger.Formatter.system_time_to_date_time_ms(timestamp, utc_log?)
+        metadata = [erl_level: erl_level] ++ erlang_metadata_to_elixir_metadata(metadata)
+        event = {level, gl, {Logger, message, date_time_ms, metadata}}
+        notify(mode, event)
+    end
+  rescue
+    ArgumentError -> {:error, :noproc}
+  catch
+    :exit, reason -> {:error, reason}
+  end
+
+  defp notify(:sync, msg) do
+    pid = Process.whereis(Logger)
+
+    # If we are within the logger process itself,
+    #  we cannot use sync notify as that will deadlock.
+    if pid == self(), do: :gen_event.notify(pid, msg), else: :gen_event.sync_notify(pid, msg)
+  end
+
+  defp notify(:async, msg) do
+    :gen_event.notify(Logger, msg)
+  end
+
+  @counter_pos 1
+
+  defp threshold(config) do
+    %{
+      counter: counter,
+      thresholds: {sync, discard}
+    } = config
+
+    :counters.add(counter, @counter_pos, 1)
+    value = :counters.get(counter, @counter_pos)
+
+    cond do
+      value >= discard -> :discard
+      value >= sync -> :sync
+      true -> :async
+    end
+  end
+
+  ## Metadata helpers
+
+  defp erlang_metadata_to_elixir_metadata(metadata) do
+    metadata =
+      case metadata do
+        %{mfa: {mod, fun, arity}} ->
+          Map.merge(%{module: mod, function: form_fa(fun, arity)}, metadata)
+
+        %{} ->
+          metadata
+      end
+
+    metadata =
+      case metadata do
+        %{file: file} -> %{metadata | file: List.to_string(file)}
+        %{} -> metadata
+      end
+
+    Map.to_list(metadata)
+  rescue
+    _ -> Map.to_list(metadata)
+  end
+
+  defp form_fa(fun, arity) do
+    Atom.to_string(fun) <> "/" <> Integer.to_string(arity)
+  end
+
+  defp erlang_level_to_elixir_level(:none), do: :error
+  defp erlang_level_to_elixir_level(:emergency), do: :error
+  defp erlang_level_to_elixir_level(:alert), do: :error
+  defp erlang_level_to_elixir_level(:critical), do: :error
+  defp erlang_level_to_elixir_level(:error), do: :error
+  defp erlang_level_to_elixir_level(:warning), do: :warn
+  defp erlang_level_to_elixir_level(:notice), do: :info
+  defp erlang_level_to_elixir_level(:info), do: :info
+  defp erlang_level_to_elixir_level(:debug), do: :debug
+  defp erlang_level_to_elixir_level(:all), do: :debug
+end
diff --git a/lib/logger/lib/logger/backends/internal.ex b/lib/logger/lib/logger/backends/internal.ex
new file mode 100644
index 00000000000..4af6c2e117b
--- /dev/null
+++ b/lib/logger/lib/logger/backends/internal.ex
@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Logger.Backends.Internal do
+  @moduledoc false
+
+  use Supervisor
+  @name __MODULE__
+  @type backend :: :gen_event.handler()
+
+  @typedoc """
+  Configuration options for Logger backends.
+
+  These are the built-in backend options that can be configured at runtime.
+  """
+  @type backend_config_opts :: [
+          sync_threshold: pos_integer(),
+          discard_threshold: pos_integer() | :infinity,
+          truncate: pos_integer() | :infinity,
+          utc_log: boolean()
+        ]
+
+  @typedoc """
+  Options for `add/2` and `remove/2` operations.
+  """
+  @type add_remove_opts :: [
+          flush: boolean()
+        ]
+
+  @doc """
+  Apply runtime configuration to all backends.
+
+  See the module doc for more information.
+  """
+  @backend_options [:sync_threshold, :discard_threshold, :truncate, :utc_log]
+  @spec configure(backend_config_opts) :: :ok
+  def configure(options) do
+    ensure_started()
+    Logger.Backends.Config.configure(Keyword.take(options, @backend_options))
+    :ok = :logger.update_handler_config(Logger, :config, :refresh)
+  end
+
+  @doc """
+  Configures a given backend.
+  """
+  @spec configure(backend, keyword) :: term
+  def configure(backend, options) when is_list(options) do
+    ensure_started()
+    :gen_event.call(Logger, backend, {:configure, options})
+  end
+
+  @doc """
+  Adds a new backend.
+
+  Adding a backend calls the `init/1` function in that backend
+  with the name of the backend as its argument. For example,
+  calling
+
+      Logger.Backends.add(MyBackend)
+
+  will call `MyBackend.init(MyBackend)` to initialize the new
+  backend. If the backend's `init/1` callback returns `{:ok, _}`,
+  then this function returns `{:ok, pid}`. If the handler returns
+  `{:error, :ignore}` from `init/1`, this function still returns
+  `{:ok, pid}` but the handler is not started. If the handler
+  returns `{:error, reason}` from `init/1`, this function returns
+  `{:error, {reason, info}}` where `info` is more information on
+  the backend that failed to start.
+
+  Backends added by this function are not persisted. Therefore
+  if the Logger application or supervision tree is restarted,
+  the backend won't be available. If you need this guarantee,
+  then configure the backend via the application environment:
+
+      config :logger, :backends, [MyBackend]
+
+  ## Options
+
+    * `:flush` - when `true`, guarantees all messages currently sent
+      to `Logger` are processed before the backend is added
+
+  ## Examples
+
+      {:ok, _pid} = Logger.add_backend(MyBackend, flush: true)
+
+  """
+  @spec add(backend, add_remove_opts) :: Supervisor.on_start_child()
+  def add(backend, opts \\ []) do
+    ensure_started()
+    _ = if opts[:flush], do: Logger.flush()
+
+    case Logger.Backends.Supervisor.add(backend) do
+      {:ok, _} = ok ->
+        ok
+
+      {:error, {:already_started, _pid}} ->
+        {:error, :already_present}
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  @doc """
+  Removes a backend.
+
+  ## Options
+
+    * `:flush` - when `true`, guarantees all messages currently sent
+      to `Logger` are processed before the backend is removed
+
+  """
+  @spec remove(backend, add_remove_opts) :: :ok | {:error, term}
+  def remove(backend, opts \\ []) do
+    ensure_started()
+    _ = if opts[:flush], do: Logger.flush()
+    Logger.Backends.Supervisor.remove(backend)
+  end
+
+  ## Supervisor callbacks
+
+  defp ensure_started() do
+    if !Process.whereis(@name) do
+      Supervisor.start_child(Logger.Supervisor, __MODULE__)
+    end
+
+    :ok
+  end
+
+  @doc false
+  def start_link(_opts) do
+    Supervisor.start_link(__MODULE__, :ok, name: @name)
+  end
+
+  @impl true
+  def init(:ok) do
+    backends = Application.get_env(:logger, :backends, []) -- [:console]
+    start_options = Application.fetch_env!(:logger, :start_options)
+    counter = :counters.new(1, [:atomics])
+
+    children = [
+      %{
+        id: :gen_event,
+        start: {:gen_event, :start_link, [{:local, Logger}, start_options]},
+        modules: :dynamic
+      },
+      {Logger.Backends.Watcher, {Logger.Backends.Config, counter}},
+      {Logger.Backends.Supervisor, backends}
+    ]
+
+    :ok =
+      :logger.add_handler(Logger, Logger.Backends.Handler, %{
+        level: :all,
+        config: %{counter: counter},
+        filter_default: :log,
+        filters: []
+      })
+
+    Supervisor.init(children, strategy: :rest_for_one)
+  end
+end
diff --git a/lib/logger/lib/logger/backends/supervisor.ex b/lib/logger/lib/logger/backends/supervisor.ex
new file mode 100644
index 00000000000..859502075b6
--- /dev/null
+++ b/lib/logger/lib/logger/backends/supervisor.ex
@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.Backends.Supervisor do
+  @moduledoc false
+  use Supervisor
+
+  @name __MODULE__
+
+  def add(backend) do
+    spec = %{
+      id: backend,
+      start: {Logger.Backends.Watcher, :start_link, [{backend, backend}]},
+      restart: :transient
+    }
+
+    case Supervisor.start_child(@name, spec) do
+      {:error, :already_present} ->
+        _ = Supervisor.delete_child(@name, backend)
+        add(backend)
+
+      other ->
+        other
+    end
+  end
+
+  def remove(backend) do
+    case Supervisor.terminate_child(@name, backend) do
+      :ok ->
+        _ = Supervisor.delete_child(@name, backend)
+        :ok
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  def start_link(backends) do
+    case Supervisor.start_link(__MODULE__, [], name: @name) do
+      {:ok, _} = ok ->
+        for backend <- backends do
+          case add(backend) do
+            {:ok, _} ->
+              :ok
+
+            {:error, {{:EXIT, exit}, _spec}} ->
+              raise "EXIT when installing backend #{inspect(backend)}: " <>
+                      Exception.format_exit(exit)
+
+            {:error, error} ->
+              raise "ERROR when installing backend #{inspect(backend)}: " <>
+                      Exception.format_exit(error)
+          end
+        end
+
+        ok
+
+      {:error, _} = error ->
+        error
+    end
+  end
+
+  @impl true
+  def init(children) do
+    Supervisor.init(children, strategy: :one_for_one, max_restarts: 30, max_seconds: 3)
+  end
+end
diff --git a/lib/logger/lib/logger/backends/watcher.ex b/lib/logger/lib/logger/backends/watcher.ex
new file mode 100644
index 00000000000..60d8009b0ee
--- /dev/null
+++ b/lib/logger/lib/logger/backends/watcher.ex
@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.Backends.Watcher do
+  @moduledoc false
+  use GenServer
+
+  @doc false
+  def start_link(tuple) do
+    GenServer.start_link(__MODULE__, tuple)
+  end
+
+  @impl true
+  def init({handler, args}) do
+    Process.flag(:trap_exit, true)
+
+    case :gen_event.delete_handler(Logger, handler, :ok) do
+      {:error, :module_not_found} ->
+        case :gen_event.add_sup_handler(Logger, handler, args) do
+          :ok ->
+            {:ok, handler}
+
+          {:error, :ignore} ->
+            # Can't return :ignore as a transient child under a one_for_one.
+            # Instead return ok and then immediately exit normally - using a fake
+            # message.
+            send(self(), {:gen_event_EXIT, handler, :normal})
+            {:ok, handler}
+
+          {:error, reason} ->
+            {:stop, reason}
+
+          {:EXIT, _} = exit ->
+            {:stop, exit}
+        end
+
+      _ ->
+        init({handler, args})
+    end
+  end
+
+  @impl true
+  def handle_info({:gen_event_EXIT, handler, reason}, handler)
+      when reason in [:normal, :shutdown] do
+    {:stop, reason, handler}
+  end
+
+  def handle_info({:gen_event_EXIT, handler, reason}, handler) do
+    message = [
+      ":gen_event handler ",
+      inspect(handler),
+      " installed in Logger terminating\n",
+      "** (exit) ",
+      format_exit(reason)
+    ]
+
+    cond do
+      logger_has_backends?() -> :ok
+      true -> IO.puts(:stderr, message)
+    end
+
+    {:stop, reason, handler}
+  end
+
+  def handle_info(_msg, state) do
+    {:noreply, state}
+  end
+
+  defp logger_has_backends?() do
+    try do
+      :gen_event.which_handlers(Logger) != [Logger.Backends.Config]
+    catch
+      _, _ -> false
+    end
+  end
+
+  @impl true
+  def terminate(_reason, handler) do
+    # On terminate we remove the handler, this makes the
+    # process sync, allowing existing messages to be flushed
+    :gen_event.delete_handler(Logger, handler, :ok)
+    :ok
+  end
+
+  defp format_exit({:EXIT, reason}), do: Exception.format_exit(reason)
+  defp format_exit(reason), do: Exception.format_exit(reason)
+end
diff --git a/lib/logger/lib/logger/formatter.ex b/lib/logger/lib/logger/formatter.ex
new file mode 100644
index 00000000000..f70c017dcb9
--- /dev/null
+++ b/lib/logger/lib/logger/formatter.ex
@@ -0,0 +1,582 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+import Kernel, except: [inspect: 2]
+
+defmodule Logger.Formatter do
+  @moduledoc ~S"""
+  Conveniences and built-in formatter for logs.
+
+  This module defines a suitable `:logger` formatter which formats
+  messages and reports as Elixir terms and also provides additional
+  functionality, such as timezone conversion, truncation, and coloring.
+  This formatter is used by default by `Logger` and you can configure it
+  using:
+
+      config :logger, :default_formatter,
+        format: "\n$time $metadata[$level] $message\n",
+        metadata: [:user_id]
+
+  You can also use `Logger.Formatter.new/1` to create your own formatter,
+  which can then be passed as a formatter to any [`:logger_handler`](`:logger_handler`).
+  See `Logger.Formatter.new/1` for all configuration options.
+
+  This module also provides several conveniences for those who wish
+  to [write their custom logger formatters](https://www.erlang.org/doc/apps/kernel/logger_chapter.html#formatters).
+
+  ## Formatting
+
+  The log messages can be controlled by a formatting string. Here is
+  an example:
+
+      config :logger, :default_formatter,
+        format: "\n$time $metadata[$level] $message\n",
+        metadata: [:user_id]
+
+  The above will print error messages as:
+
+      18:43:12.439 user_id=13 [error] Hello\n
+
+  The valid parameters you can use are:
+
+    * `$time`     - the time the log message was sent
+    * `$date`     - the date the log message was sent
+    * `$message`  - the log message
+    * `$level`    - the log level
+    * `$node`     - the node that prints the message
+    * `$metadata` - user controlled data presented in `"key=val key2=val2 "` format
+
+  ### Formatting function
+
+  You can also customize the format of your log messages with
+  a `{module, function_name}` tuple if you wish to change how messages
+  are formatted but keep all other features provided by `Logger.Formatter`
+  such as truncation and coloring. However, if you want to get full
+  control of formatting, consider writing a custom
+  [`:logger` formatter](https://www.erlang.org/doc/apps/kernel/logger_chapter.html#formatters)
+  instead, which has complete access to all events and metadata.
+
+  When using a `{module, function_name}`, the function will be invoked
+  with the level, the message, the timestamp, and metadata, like this:
+
+      defmodule MyConsoleLogger do
+        @spec format(atom, chardata, Logger.Formatter.date_time_ms(), keyword()) :: IO.chardata()
+        def format(level, message, timestamp, metadata) do
+          # Custom formatting logic that must return chardata.
+          # ...
+        end
+      end
+
+  ### Metadata
+
+  Metadata to be sent to the logger can be read and written with
+  the `Logger.metadata/0` and `Logger.metadata/1` functions. For example,
+  you can set `Logger.metadata([user_id: 13])` to add user_id metadata
+  to the current process. The user can configure the backend to choose
+  which metadata it wants to print and it will replace the `$metadata`
+  value.
+
+  > #### When is user metadata printed? {: .warning}
+  >
+  > The default Logger formatter requires the user's metadata to meet
+  > one of the following conditions to be printed:
+  >
+  >   * Be a string (`is_binary/1`)
+  >   * Be a number (either `is_integer/1` or `is_float/1`)
+  >   * Be a PID
+  >   * Be an atom
+  >   * Be a reference
+  >   * Be a port
+  >   * Implement the `String.Chars` protocol (except for charlists)
+  >
+  > If none of the conditions above are `true`, the given metadata get
+  > discarded.
+  """
+
+  @type date :: {1970..10_000, 1..12, 1..31}
+  @type time_ms :: {0..23, 0..59, 0..59, 0..999}
+  @type date_time_ms :: {date, time_ms}
+
+  @type pattern :: :date | :level | :levelpad | :message | :metadata | :node | :time
+
+  @type new_opts :: [
+          colors: [
+            enabled: boolean(),
+            debug: atom(),
+            info: atom(),
+            warning: atom(),
+            error: atom()
+          ],
+          format: String.t() | {module(), atom()},
+          metadata: :all | [atom()],
+          truncate: pos_integer() | :infinity,
+          utc_log: boolean()
+        ]
+  @valid_patterns [:time, :date, :message, :level, :node, :metadata, :levelpad]
+  @default_pattern "\n$time $metadata[$level] $message\n"
+  @replacement "�"
+
+  ## Formatter API
+
+  defstruct [:template, :truncate, :metadata, :colors, :utc_log?]
+
+  @doc ~S"""
+  Initializes a formatter for `:logger` handlers.
+
+  The supported options are:
+
+    * `:colors` - a keyword list of coloring options.
+
+    * `:format` - the format message used to print logs.
+      Defaults to: `"\n$time $metadata[$level] $message\n"`.
+      It may also be a `{module, function_name}` tuple that is invoked
+      with the log level, the message, the current timestamp and
+      the metadata and must return `t:IO.chardata/0`.
+      See the module docs for more information on `:format`.
+
+    * `:metadata` - a list of metadata keys to be printed by
+      `$metadata`. Defaults to an empty list (no metadata).
+      Setting `:metadata` to `:all` prints all metadata. See
+      the "Metadata" section in the `Logger` documentation for
+      more information.
+
+    * `:truncate` - the maximum message size to be logged (in bytes).
+      Defaults to 8192 bytes. Note this configuration is approximate.
+      Truncated messages will have `" (truncated)"` at the end.
+      The atom `:infinity` can be passed to disable this behavior.
+
+    * `:utc_log` - when `true`, uses UTC in logs. By default it uses
+      local time (as it defaults to `false`).
+
+  The supported keys in the `:colors` keyword list are:
+
+    * `:enabled` - boolean value that allows for switching the
+      coloring on and off. Defaults to: `IO.ANSI.enabled?/0`
+
+    * `:debug` - color for debug messages. Defaults to: `:cyan`
+
+    * `:info` - color for info and notice messages. Defaults to: `:normal`
+
+    * `:warning` - color for warning messages. Defaults to: `:yellow`
+
+    * `:error` - color for error and higher messages. Defaults to: `:red`
+
+  See the `IO.ANSI` module for a list of colors and attributes.
+  The color of the message can also be configured per message via
+  the `:ansi_color` metadata.
+  """
+  @spec new(new_opts) :: formatter when formatter: term
+  def new(options \\ []) do
+    template = compile(options[:format])
+    colors = colors(options[:colors] || [])
+    truncate = options[:truncate] || Application.fetch_env!(:logger, :truncate)
+    metadata = options[:metadata] || []
+    utc_log? = Keyword.get(options, :utc_log, Application.fetch_env!(:logger, :utc_log))
+
+    {__MODULE__,
+     %__MODULE__{
+       template: template,
+       truncate: truncate,
+       metadata: metadata,
+       colors: colors,
+       utc_log?: utc_log?
+     }}
+  end
+
+  defp colors(colors) do
+    %{
+      emergency: Keyword.get(colors, :error, :red),
+      alert: Keyword.get(colors, :error, :red),
+      critical: Keyword.get(colors, :error, :red),
+      error: Keyword.get(colors, :error, :red),
+      warning: Keyword.get(colors, :warning, :yellow),
+      notice: Keyword.get(colors, :info, :normal),
+      info: Keyword.get(colors, :info, :normal),
+      debug: Keyword.get(colors, :debug, :cyan),
+      enabled: Keyword.get(colors, :enabled, &IO.ANSI.enabled?/0)
+    }
+  end
+
+  @doc false
+  def format(%{level: level, meta: meta} = event, %__MODULE__{} = config) do
+    %{
+      utc_log?: utc_log?,
+      metadata: metadata_keys,
+      template: template,
+      colors: colors,
+      truncate: truncate
+    } = config
+
+    system_time =
+      case meta do
+        %{time: time} when is_integer(time) and time >= 0 -> time
+        _ -> :os.system_time(:microsecond)
+      end
+
+    date_time_ms = system_time_to_date_time_ms(system_time, utc_log?)
+
+    meta_list =
+      case metadata_keys do
+        :all -> Map.to_list(meta)
+        keys -> for key <- keys, value = compute_meta(key, meta), do: {key, value}
+      end
+
+    chardata = format_event(event, truncate)
+
+    template
+    |> format(level, chardata, date_time_ms, meta_list)
+    |> colorize(level, colors, meta)
+  end
+
+  def format(_event, _config) do
+    raise "invalid configuration for Logger.Formatter. " <>
+            "Use Logger.Formatter.new/1 to define a formatter"
+  end
+
+  defp compute_meta(:module, %{mfa: {mod, _, _}}), do: mod
+  defp compute_meta(:function, %{mfa: {_, fun, arity}}), do: format_fa(fun, arity)
+  defp compute_meta(key, meta), do: meta[key]
+
+  defp format_fa(fun, arity), do: [Atom.to_string(fun), "/", Integer.to_string(arity)]
+
+  defp colorize(data, level, %{enabled: enabled} = colors, md) do
+    case if(is_function(enabled, 0), do: enabled.(), else: enabled) do
+      true ->
+        color = md[:ansi_color] || Map.fetch!(colors, level)
+        [IO.ANSI.format_fragment(color, true), add_reset(data)]
+
+      false ->
+        data
+    end
+  end
+
+  defp add_reset(binary) when is_binary(binary) do
+    size = byte_size(binary)
+
+    cond do
+      binary == "" ->
+        IO.ANSI.reset()
+
+      :binary.at(binary, size - 1) == ?\n ->
+        if size > 1 and :binary.at(binary, size - 2) == ?\r do
+          [binary_part(binary, 0, size - 2), IO.ANSI.reset() | "\r\n"]
+        else
+          [binary_part(binary, 0, size - 1), IO.ANSI.reset(), ?\n]
+        end
+
+      true ->
+        [binary | IO.ANSI.reset()]
+    end
+  end
+
+  defp add_reset([?\r, ?\n]), do: [IO.ANSI.reset(), ?\r, ?\n]
+  defp add_reset([?\n]), do: [IO.ANSI.reset(), ?\n]
+  defp add_reset([last]), do: add_reset(last)
+  defp add_reset([h | t]), do: [h | add_reset(t)]
+  defp add_reset(rest), do: [rest | IO.ANSI.reset()]
+
+  @doc """
+  Formats the message of a log event.
+  """
+  @spec format_event(:logger.log_event(), pos_integer | :infinity) :: IO.chardata()
+  def format_event(%{msg: msg, meta: meta} = _log_event, truncate) do
+    format_message(msg, meta, truncate)
+  end
+
+  defp format_message({:string, message}, _metadata, truncate) do
+    wrapped_truncate(message, truncate)
+  end
+
+  defp format_message({:report, data}, %{report_cb: callback} = meta, truncate) do
+    cond do
+      is_function(callback, 1) and callback != (&:logger.format_otp_report/1) ->
+        format_message(callback.(data), meta, truncate)
+
+      is_function(callback, 2) ->
+        callback.(data, %{depth: :unlimited, chars_limit: truncate, single_line: false})
+
+      true ->
+        format_report(data, truncate)
+    end
+  end
+
+  defp format_message({:report, data}, _meta, truncate) do
+    format_report(data, truncate)
+  end
+
+  defp format_message({format, args}, _meta, truncate) do
+    format
+    |> Logger.Utils.scan_inspect(args, truncate)
+    |> :io_lib.build_text()
+    |> wrapped_truncate(truncate)
+  end
+
+  defp format_report(%{} = data, truncate) do
+    wrapped_truncate(Kernel.inspect(Map.to_list(data), translator_inspect_opts()), truncate)
+  end
+
+  defp format_report(data, truncate) do
+    wrapped_truncate(Kernel.inspect(data, translator_inspect_opts()), truncate)
+  end
+
+  defp translator_inspect_opts() do
+    Application.fetch_env!(:logger, :translator_inspect_opts)
+  end
+
+  defp wrapped_truncate(data, n) when is_binary(data), do: truncate(data, n)
+
+  defp wrapped_truncate(data, n) when is_list(data) do
+    truncate(data, n)
+  rescue
+    msg in ArgumentError -> Exception.message(msg)
+  end
+
+  @doc """
+  Truncates a `chardata` into `n` bytes.
+
+  There is a chance we truncate in the middle of a grapheme
+  cluster but we never truncate in the middle of a binary
+  code point. For this reason, truncation is not exact.
+  """
+  @spec truncate(IO.chardata(), non_neg_integer | :infinity) :: IO.chardata()
+  def truncate(chardata, :infinity) when is_binary(chardata) or is_list(chardata) do
+    chardata
+  end
+
+  def truncate(chardata, n) when n >= 0 do
+    {chardata, n} = Logger.Utils.truncate_n(chardata, n)
+    if n >= 0, do: chardata, else: [chardata, " (truncated)"]
+  end
+
+  @doc """
+  Prunes invalid Unicode code points from lists and invalid UTF-8 bytes.
+
+  Typically called after formatting when the data cannot be printed.
+  """
+  @spec prune(IO.chardata()) :: IO.chardata()
+  def prune(binary) when is_binary(binary), do: prune_binary(binary, "")
+  def prune([h | t]) when h in 0..1_114_111, do: [h | prune(t)]
+  def prune([h | t]), do: [prune(h) | prune(t)]
+  def prune([]), do: []
+  def prune(_), do: @replacement
+
+  defp prune_binary(<<h::utf8, t::binary>>, acc), do: prune_binary(t, <<acc::binary, h::utf8>>)
+  defp prune_binary(<<_, t::binary>>, acc), do: prune_binary(t, <<acc::binary, @replacement>>)
+  defp prune_binary(<<>>, acc), do: acc
+
+  @doc """
+  Formats time as chardata.
+  """
+  @spec format_time(time_ms) :: IO.chardata()
+  def format_time({hh, mi, ss, ms} = _time_ms_tuple) do
+    [pad2(hh), ?:, pad2(mi), ?:, pad2(ss), ?., pad3(ms)]
+  end
+
+  @doc """
+  Formats date as chardata.
+  """
+  @spec format_date(date) :: IO.chardata()
+  def format_date({yy, mm, dd} = _date_tuple) do
+    [Integer.to_string(yy), ?-, pad2(mm), ?-, pad2(dd)]
+  end
+
+  defp pad3(int) when int < 10, do: [?0, ?0, Integer.to_string(int)]
+  defp pad3(int) when int < 100, do: [?0, Integer.to_string(int)]
+  defp pad3(int), do: Integer.to_string(int)
+
+  defp pad2(int) when int < 10, do: [?0, Integer.to_string(int)]
+  defp pad2(int), do: Integer.to_string(int)
+
+  @doc """
+  Converts the system time (in microseconds) from metadata into a `date_time_ms` tuple.
+  """
+  @spec system_time_to_date_time_ms(integer(), boolean()) :: date_time_ms()
+  def system_time_to_date_time_ms(system_time, utc_log? \\ false) do
+    micro = rem(system_time, 1_000_000)
+
+    {date, {hours, minutes, seconds}} =
+      case utc_log? do
+        true -> :calendar.system_time_to_universal_time(system_time, :microsecond)
+        false -> :calendar.system_time_to_local_time(system_time, :microsecond)
+      end
+
+    {date, {hours, minutes, seconds, div(micro, 1000)}}
+  end
+
+  @doc """
+  Compiles a pattern or function into a data structure that `format/5` can handle.
+
+  Check the module doc for documentation on the valid parameters that
+  will be interpolated in the pattern. If you pass `nil` as the pattern,
+  the pattern defaults to:
+
+      #{inspect(@default_pattern)}
+
+  If you want to customize formatting with a custom function, you can
+  pass a `{module, function_name}` tuple.
+
+  This function, alongside `format/5`, is the main building block used
+  by `Logger.Formatter.new/1` for formatting messages. It can also be used
+  by those interested in building custom formatters.
+
+  ## Examples
+
+      iex> Logger.Formatter.compile("$time $metadata [$level] $message\\n")
+      [:time, " ", :metadata, " [", :level, "] ", :message, "\\n"]
+
+      iex> Logger.Formatter.compile({MyLoggerFormatter, :format})
+      {MyLoggerFormatter, :format}
+
+  """
+  @spec compile(binary | nil) :: [pattern | binary]
+  @spec compile(pattern) :: pattern when pattern: {module, function :: atom}
+  def compile(pattern_or_function)
+
+  def compile(nil), do: compile(@default_pattern)
+  def compile({mod, fun}) when is_atom(mod) and is_atom(fun), do: {mod, fun}
+
+  def compile(str) when is_binary(str) do
+    regex = ~r/(?<head>)\$[a-z]+(?<tail>)/
+
+    for part <- Regex.split(regex, str, on: [:head, :tail], trim: true) do
+      case part do
+        "$" <> code -> compile_code(String.to_atom(code))
+        _ -> part
+      end
+    end
+  end
+
+  defp compile_code(:levelpad) do
+    IO.warn("$levelpad in Logger message format is deprecated, please remove it")
+    :levelpad
+  end
+
+  defp compile_code(key) when key in @valid_patterns, do: key
+
+  defp compile_code(key) when is_atom(key) do
+    raise ArgumentError, "$#{key} is an invalid format pattern"
+  end
+
+  @doc """
+  Formats a `pattern_or_function` returned by `compile/1`.
+
+  It takes a compiled format and injects the level, timestamp, message,
+  and metadata keyword list and returns a properly formatted string.
+
+  If `pattern_or_function` is a `{module, function_name}` tuple,
+  then `module.function_name(level, message, timestamp, metadata)` is
+  invoked to get the message.
+
+  This function, alongside `compile/1`, is the main building block used
+  by `Logger.Formatter.new/1` for formatting messages. It can also be used
+  by those interested in building custom formatters.
+
+  ## Examples
+
+      iex> pattern = Logger.Formatter.compile("[$level] $message")
+      iex> timestamp = {{1977, 01, 28}, {13, 29, 00, 000}}
+      iex> formatted = Logger.Formatter.format(pattern, :info, "hello", timestamp, [])
+      iex> IO.chardata_to_string(formatted)
+      "[info] hello"
+
+  """
+  @spec format(
+          mod_and_fun | [pattern | binary],
+          Logger.level(),
+          Logger.message(),
+          date_time_ms(),
+          keyword
+        ) ::
+          IO.chardata()
+        when mod_and_fun: {atom, atom}
+  def format(pattern_or_function, level, message, timestamp, metadata)
+
+  def format({mod, fun}, level, msg, timestamp, metadata) do
+    apply(mod, fun, [level, msg, timestamp, metadata])
+  end
+
+  def format(config, level, msg, timestamp, metadata) do
+    for config_option <- config do
+      output(config_option, level, msg, timestamp, metadata)
+    end
+  end
+
+  defp output(:message, _, msg, _, _), do: msg
+  defp output(:date, _, _, {date, _time}, _), do: format_date(date)
+  defp output(:time, _, _, {_date, time}, _), do: format_time(time)
+  defp output(:level, level, _, _, _), do: Atom.to_string(level)
+  defp output(:node, _, _, _, _), do: Atom.to_string(node())
+  defp output(:metadata, _, _, _, []), do: ""
+  defp output(:metadata, _, _, _, meta), do: metadata(meta)
+  defp output(:levelpad, level, _, _, _), do: levelpad(level)
+  defp output(other, _, _, _, _), do: other
+
+  defp levelpad(:info), do: " "
+  defp levelpad(:warn), do: " "
+  defp levelpad(_), do: ""
+
+  defp metadata([{key, value} | metadata]) do
+    if formatted = metadata(key, value) do
+      [to_string(key), ?=, formatted, ?\s | metadata(metadata)]
+    else
+      metadata(metadata)
+    end
+  end
+
+  defp metadata([]) do
+    []
+  end
+
+  defp metadata(:time, _), do: nil
+  defp metadata(:gl, _), do: nil
+  defp metadata(:report_cb, _), do: nil
+
+  defp metadata(_, nil), do: nil
+  defp metadata(_, string) when is_binary(string), do: string
+  defp metadata(_, integer) when is_integer(integer), do: Integer.to_string(integer)
+  defp metadata(_, float) when is_float(float), do: Float.to_string(float)
+  defp metadata(_, pid) when is_pid(pid), do: :erlang.pid_to_list(pid)
+
+  defp metadata(_, atom) when is_atom(atom) do
+    case Atom.to_string(atom) do
+      "Elixir." <> rest -> rest
+      binary -> binary
+    end
+  end
+
+  defp metadata(_, ref) when is_reference(ref) do
+    ~c"#Ref" ++ rest = :erlang.ref_to_list(ref)
+    rest
+  end
+
+  defp metadata(_, port) when is_port(port) do
+    ~c"#Port" ++ rest = :erlang.port_to_list(port)
+    rest
+  end
+
+  defp metadata(:domain, [head | tail]) when is_atom(head) do
+    Enum.map_intersperse([head | tail], ?., &Atom.to_string/1)
+  end
+
+  defp metadata(:mfa, {mod, fun, arity})
+       when is_atom(mod) and is_atom(fun) and is_integer(arity) do
+    Exception.format_mfa(mod, fun, arity)
+  end
+
+  defp metadata(:initial_call, {mod, fun, arity})
+       when is_atom(mod) and is_atom(fun) and is_integer(arity) do
+    Exception.format_mfa(mod, fun, arity)
+  end
+
+  defp metadata(:function, function) when is_list(function), do: function
+  defp metadata(:file, file) when is_list(file), do: file
+  defp metadata(_, list) when is_list(list), do: nil
+
+  defp metadata(_, other) do
+    case String.Chars.impl_for(other) do
+      nil -> nil
+      impl -> impl.to_string(other)
+    end
+  end
+end
diff --git a/lib/logger/lib/logger/translator.ex b/lib/logger/lib/logger/translator.ex
new file mode 100644
index 00000000000..00191c90dad
--- /dev/null
+++ b/lib/logger/lib/logger/translator.ex
@@ -0,0 +1,732 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.Translator do
+  @moduledoc """
+  Default translation for Erlang log messages.
+
+  Logger allows developers to rewrite log messages provided by
+  OTP applications into a format more compatible with Elixir
+  log messages by providing a translator.
+
+  A translator is simply a tuple containing a module and a function
+  that can be added and removed via the `Logger.add_translator/1` and
+  `Logger.remove_translator/1` functions and is invoked for every Erlang
+  message above the minimum log level with four arguments:
+
+    * `min_level` - the current Logger level
+    * `level` - the level of the message being translated
+    * `kind` - if the message is a `:report` or `:format`
+    * `message` - the message to format. If it is `:report`, it is a tuple
+      with `{report_type, report_data}`, if it is `:format`, it is a
+      tuple with `{format_message, format_args}`.
+
+  The function must return:
+
+    * `{:ok, chardata, metadata}` - if the message translation with its metadata
+    * `{:ok, chardata}` - the translated message
+    * `:skip` - if the message is not meant to be translated nor logged
+    * `:none` - if there is no translation, which triggers the next translator
+
+  See the function `translate/4` in this module for an example implementation
+  and the default messages translated by Logger.
+  """
+
+  @doc """
+  Callback for translating a logger message.
+  """
+  @callback translate(Logger.level(), Logger.level(), :format | :report, :logger.report()) ::
+              {:ok, iodata, keyword}
+              | {:ok, iodata}
+              | :skip
+              | :none
+
+  @doc """
+  Built-in translation function.
+
+  This function is an implementation of the `c:translate/4` callback.
+  For arguments and return value of this function, see that callback.
+  """
+  def translate(min_level, level, kind, message)
+
+  def translate(min_level, _level, :report, {:logger, %{label: label} = report}) do
+    case label do
+      {:gen_server, :terminate} ->
+        report_gen_server_terminate(min_level, report)
+
+      {:gen_event, :terminate} ->
+        report_gen_event_terminate(min_level, report)
+
+      {:gen_statem, :terminate} ->
+        report_gen_statem_terminate(min_level, report)
+
+      _ ->
+        :skip
+    end
+  end
+
+  def translate(min_level, _level, :report, {{:proc_lib, :crash}, data}) do
+    report_crash(min_level, data)
+  end
+
+  def translate(min_level, _level, :report, {{:supervisor, :progress}, data}) do
+    report_supervisor_progress(min_level, data)
+  end
+
+  def translate(min_level, _level, :report, {{:supervisor, _}, data}) do
+    report_supervisor(min_level, data)
+  end
+
+  def translate(
+        _min_level,
+        _level,
+        :report,
+        {{:application_controller, :progress}, [application: app, started_at: node]}
+      ) do
+    {:ok, ["Application ", Atom.to_string(app), " started at " | inspect(node)]}
+  end
+
+  def translate(
+        _min_level,
+        _level,
+        :report,
+        {{:application_controller, :exit}, [application: app, exited: reason, type: _type]}
+      ) do
+    {:ok, ["Application ", Atom.to_string(app), " exited: " | Application.format_error(reason)]}
+  end
+
+  def translate(
+        _min_level,
+        :error,
+        :report,
+        {{Task.Supervisor, :terminating},
+         %{
+           name: name,
+           starter: starter,
+           function: function,
+           args: args,
+           reason: reason,
+           process_label: process_label
+         }}
+      ) do
+    opts = Application.get_env(:logger, :translator_inspect_opts)
+
+    {formatted, reason} = format_reason(reason)
+    metadata = [crash_reason: reason] ++ registered_name(name)
+
+    msg =
+      ["\nFunction: #{inspect(function, opts)}"] ++
+        ["\n    Args: #{inspect(args, opts)}"]
+
+    msg =
+      case process_label do
+        :undefined -> msg
+        _ -> ["\nProcess Label: #{inspect(process_label, opts)}"] ++ msg
+      end
+
+    msg = ["Task #{inspect(name)} started from #{inspect(starter)} terminating", formatted] ++ msg
+
+    {:ok, msg, metadata}
+  end
+
+  def translate(min_level, :error, :format, message) do
+    case message do
+      # This is no longer emitted by Erlang/OTP but it may be
+      # manually emitted by libraries like connection.
+      {~c"** Generic server " ++ _, [name, last, state, reason | client]} ->
+        opts = Application.fetch_env!(:logger, :translator_inspect_opts)
+        {formatted, reason} = format_reason(reason)
+        metadata = [crash_reason: reason] ++ registered_name(name)
+
+        msg =
+          ["GenServer #{inspect(name)} terminating", formatted] ++
+            ["\nLast message#{format_from(client)}: #{inspect(last, opts)}"]
+
+        if min_level == :debug do
+          msg = [msg, "\nState: #{inspect(state, opts)}" | format_client(client)]
+          {:ok, msg, metadata}
+        else
+          {:ok, msg, metadata}
+        end
+
+      {~c"Error in process " ++ _, [pid, node, {reason, stack}]} ->
+        reason = Exception.normalize(:error, reason, stack)
+
+        msg = [
+          "Process ",
+          inspect(pid),
+          " on node ",
+          inspect(node),
+          " raised an exception" | format(:error, reason, stack)
+        ]
+
+        {:ok, msg, [crash_reason: exit_reason(:error, reason, stack)]}
+
+      {~c"Error in process " ++ _, [pid, {reason, stack}]} ->
+        reason = Exception.normalize(:error, reason, stack)
+        msg = ["Process ", inspect(pid), " raised an exception" | format(:error, reason, stack)]
+        {:ok, msg, [crash_reason: exit_reason(:error, reason, stack)]}
+
+      _ ->
+        :none
+    end
+  end
+
+  def translate(_min_level, :info, :report, {
+        :std_info,
+        [application: app, exited: reason, type: _type]
+      }) do
+    {:ok, ["Application ", Atom.to_string(app), " exited: " | Application.format_error(reason)]}
+  end
+
+  def translate(min_level, :error, :report, {{:error_logger, :error_report}, data}) do
+    report_supervisor(min_level, data)
+  end
+
+  def translate(min_level, :error, :report, {:supervisor_report, data}) do
+    report_supervisor(min_level, data)
+  end
+
+  def translate(min_level, :error, :report, {:crash_report, data}) do
+    report_crash(min_level, data)
+  end
+
+  def translate(min_level, :info, :report, {:progress, [{:supervisor, _} | _] = data}) do
+    report_supervisor_progress(min_level, data)
+  end
+
+  def translate(_min_level, :info, :report, {:progress, [application: app, started_at: node]}) do
+    {:ok, ["Application ", Atom.to_string(app), " started at " | inspect(node)]}
+  end
+
+  def translate(_min_level, :debug, :report, {:logger, [formatter_error: formatter] ++ data}) do
+    case data[:caught] do
+      {:throw, {:error, good, bad}, stacktrace} ->
+        message =
+          "bad return value from Logger formatter #{inspect(formatter)}, " <>
+            "got #{inspect(bad)} after #{inspect(good)}"
+
+        {:ok, Exception.format(:error, RuntimeError.exception(message), stacktrace)}
+
+      _ ->
+        :none
+    end
+  end
+
+  ## Helpers
+
+  def translate(_min_level, _level, _kind, _message) do
+    :none
+  end
+
+  defp report_gen_server_terminate(min_level, report) do
+    inspect_opts = Application.fetch_env!(:logger, :translator_inspect_opts)
+
+    %{
+      client_info: client,
+      last_message: last,
+      name: name,
+      reason: reason,
+      state: state
+    } = report
+
+    {formatted, reason} = format_reason(reason)
+    metadata = [crash_reason: reason] ++ registered_name(name)
+
+    label_msg =
+      case report do
+        %{process_label: process_label} when process_label != :undefined ->
+          ["\nProcess Label: ", inspect(process_label, inspect_opts)]
+
+        _ ->
+          []
+      end
+
+    msg =
+      ["GenServer ", inspect(name), " terminating", formatted, label_msg] ++
+        ["\nLast message", format_last_message_from(client), ": ", inspect(last, inspect_opts)]
+
+    if min_level == :debug do
+      msg = [msg, "\nState: ", inspect(state, inspect_opts) | format_client_info(client)]
+      {:ok, msg, metadata}
+    else
+      {:ok, msg, metadata}
+    end
+  end
+
+  defp report_gen_event_terminate(min_level, report) do
+    inspect_opts = Application.fetch_env!(:logger, :translator_inspect_opts)
+
+    %{
+      handler: handler,
+      last_message: last,
+      name: name,
+      reason: reason,
+      state: state
+    } = report
+
+    reason =
+      case reason do
+        {:EXIT, why} -> why
+        _ -> reason
+      end
+
+    {formatted, reason} = format_reason(reason)
+    metadata = [crash_reason: reason] ++ registered_name(name)
+
+    label_msg =
+      case report do
+        %{process_label: process_label} when process_label != :undefined ->
+          ["\nProcess Label: ", inspect(process_label, inspect_opts)]
+
+        _ ->
+          []
+      end
+
+    msg =
+      [":gen_event handler ", inspect(handler), " installed in ", inspect(name), " terminating"] ++
+        [formatted, label_msg, "\nLast message: ", inspect(last, inspect_opts)]
+
+    if min_level == :debug do
+      {:ok, [msg, "\nState: ", inspect(state, inspect_opts)], metadata}
+    else
+      {:ok, msg, metadata}
+    end
+  end
+
+  defp report_gen_statem_terminate(min_level, report) do
+    inspect_opts = Application.get_env(:logger, :translator_inspect_opts)
+
+    %{
+      client_info: client,
+      name: name,
+      reason: {kind, reason, stack},
+      state: state,
+      queue: queue,
+      postponed: postponed,
+      callback_mode: callback_mode,
+      state_enter: state_enter?
+    } = report
+
+    {reason, stack} = exit_reason(kind, reason, stack)
+    {formatted, reason} = format_reason({reason, stack})
+    metadata = [crash_reason: reason] ++ registered_name(name)
+
+    label_msg =
+      case report do
+        %{process_label: process_label} when process_label != :undefined ->
+          ["\nProcess Label: ", inspect(process_label, inspect_opts)]
+
+        _ ->
+          []
+      end
+
+    msg =
+      [":gen_statem ", inspect(name), " terminating", formatted, label_msg] ++
+        ["\nQueue: #{inspect(queue, inspect_opts)}"] ++
+        ["\nPostponed: #{inspect(postponed, inspect_opts)}"]
+
+    if min_level == :debug do
+      msg = [
+        msg,
+        "\nState: ",
+        inspect(state, inspect_opts),
+        "\nCallback mode: ",
+        "#{inspect(callback_mode, inspect_opts)}, state_enter: #{state_enter?}"
+        | format_client_info(client)
+      ]
+
+      {:ok, msg, metadata}
+    else
+      {:ok, msg, metadata}
+    end
+  end
+
+  defp report_supervisor_progress(
+         min_level,
+         supervisor: sup,
+         started: [{:pid, pid}, {:id, id} | started]
+       ) do
+    msg =
+      ["Child ", inspect(id), " of Supervisor ", sup_name(sup), " started"] ++
+        ["\nPid: ", inspect(pid)] ++ child_info(min_level, started)
+
+    {:ok, msg}
+  end
+
+  defp report_supervisor_progress(
+         min_level,
+         supervisor: sup,
+         started: [{:pid, pid} | started]
+       ) do
+    msg =
+      ["Child of Supervisor ", sup_name(sup), " started", "\nPid: ", inspect(pid)] ++
+        child_info(min_level, started)
+
+    {:ok, msg}
+  end
+
+  defp report_supervisor_progress(_min_level, _other), do: :none
+
+  defp report_supervisor(
+         min_level,
+         supervisor: sup,
+         errorContext: context,
+         reason: reason,
+         offender: [{:pid, pid}, {:id, id} | offender]
+       ) do
+    pid_info =
+      if is_pid(pid) and context != :shutdown do
+        ["\nPid: ", inspect(pid)]
+      else
+        []
+      end
+
+    msg =
+      ["Child ", inspect(id), " of Supervisor ", sup_name(sup)] ++
+        [?\s, sup_context(context), "\n** (exit) ", offender_reason(reason, context)] ++
+        pid_info ++ child_info(min_level, offender)
+
+    {:ok, msg}
+  end
+
+  defp report_supervisor(
+         min_level,
+         supervisor: sup,
+         errorContext: context,
+         reason: reason,
+         offender: [{:nb_children, n}, {:id, id} | offender]
+       ) do
+    msg =
+      ["Children ", inspect(id), " of Supervisor ", sup_name(sup), ?\s, sup_context(context)] ++
+        ["\n** (exit) ", offender_reason(reason, context), "\nNumber: ", Integer.to_string(n)] ++
+        child_info(min_level, offender)
+
+    {:ok, msg}
+  end
+
+  defp report_supervisor(
+         min_level,
+         supervisor: sup,
+         errorContext: context,
+         reason: reason,
+         offender: [{:pid, pid} | offender]
+       ) do
+    msg =
+      ["Child of Supervisor ", sup_name(sup), ?\s, sup_context(context)] ++
+        ["\n** (exit) ", offender_reason(reason, context), "\nPid: ", inspect(pid)] ++
+        child_info(min_level, offender)
+
+    {:ok, msg}
+  end
+
+  defp report_supervisor(_min_level, _other), do: :none
+
+  # If start call raises reason will be of form {:EXIT, reason}
+  defp offender_reason({:EXIT, reason}, :start_error) do
+    Exception.format_exit(reason)
+  end
+
+  defp offender_reason(reason, _context) do
+    Exception.format_exit(reason)
+  end
+
+  defp sup_name({:local, name}), do: inspect(name)
+  defp sup_name({:global, name}), do: inspect(name)
+  defp sup_name({:via, _mod, name}), do: inspect(name)
+  defp sup_name({pid, mod}), do: [inspect(pid), " (", inspect(mod), ?)]
+  defp sup_name(unknown_name), do: inspect(unknown_name)
+
+  defp sup_context(:start_error), do: "failed to start"
+  defp sup_context(:child_terminated), do: "terminated"
+  defp sup_context(:shutdown), do: "caused shutdown"
+  defp sup_context(:shutdown_error), do: "shut down abnormally"
+
+  defp child_info(min_level, [{:mfargs, {mod, fun, args}} | debug]) do
+    ["\nStart Call: ", format_mfa(mod, fun, args) | child_debug(min_level, debug)]
+  end
+
+  # Comes from bridge with MFA
+  defp child_info(min_level, [{:mfa, {mod, fun, args}} | debug]) do
+    ["\nStart Call: ", format_mfa(mod, fun, args) | child_debug(min_level, debug)]
+  end
+
+  # Comes from bridge with Mod
+  defp child_info(min_level, [{:mod, mod} | debug]) do
+    ["\nStart Module: ", inspect(mod) | child_debug(min_level, debug)]
+  end
+
+  defp child_info(_min_level, _child) do
+    []
+  end
+
+  defp child_debug(:debug, opts) do
+    for {key, value} <- opts do
+      child_debug_key(key, value)
+    end
+  end
+
+  defp child_debug(_min_level, _child) do
+    []
+  end
+
+  defp child_debug_key(:restart_type, value), do: ["\nRestart: " | inspect(value)]
+  defp child_debug_key(:shutdown, value), do: ["\nShutdown: " | inspect(value)]
+  defp child_debug_key(:child_type, value), do: ["\nType: " | inspect(value)]
+  defp child_debug_key(:significant, value), do: if(value, do: "\nSignificant: true", else: [])
+  defp child_debug_key(_, _), do: []
+
+  defp report_crash(min_level, [[{:initial_call, initial_call} | crashed], linked]) do
+    mfa = initial_call_to_mfa(initial_call)
+    report_crash(min_level, crashed, [{:initial_call, mfa}], linked)
+  end
+
+  defp report_crash(min_level, [crashed, linked]) do
+    report_crash(min_level, crashed, [], linked)
+  end
+
+  defp report_crash(min_level, crashed, extra, linked) do
+    {pid, crashed} = Keyword.pop_first(crashed, :pid)
+    {name, crashed} = Keyword.pop_first(crashed, :registered_name)
+    {{kind, reason, stack}, crashed} = Keyword.pop_first(crashed, :error_info)
+
+    dictionary = crashed[:dictionary]
+    reason = Exception.normalize(kind, reason, stack)
+
+    case Keyword.get(dictionary, :logger_enabled, true) do
+      false ->
+        :skip
+
+      true ->
+        user_metadata = Keyword.get(dictionary, :"$logger_metadata$", %{}) |> Map.to_list()
+
+        msg =
+          ["Process ", crash_name(pid, name), " terminating", format(kind, reason, stack)] ++
+            [crash_info(min_level, extra ++ crashed, [?\n]), crash_linked(min_level, linked)]
+
+        extra =
+          if ancestors = crashed[:ancestors], do: [{:ancestors, ancestors} | extra], else: extra
+
+        extra =
+          if callers = dictionary[:"$callers"], do: [{:callers, callers} | extra], else: extra
+
+        extra = [{:crash_reason, exit_reason(kind, reason, stack)} | extra]
+        {:ok, msg, registered_name(name) ++ extra ++ user_metadata}
+    end
+  end
+
+  defp initial_call_to_mfa({:supervisor, module, _}), do: {module, :init, 1}
+  defp initial_call_to_mfa({:supervisor_bridge, module, _}), do: {module, :init, 1}
+  defp initial_call_to_mfa({mod, fun, args}) when is_list(args), do: {mod, fun, length(args)}
+  defp initial_call_to_mfa(mfa), do: mfa
+
+  defp crash_name(pid, []), do: inspect(pid)
+  defp crash_name(pid, name), do: [inspect(name), " (", inspect(pid), ?)]
+
+  defp crash_info(min_level, [{:initial_call, {mod, fun, args}} | info], prefix) do
+    [prefix, "Initial Call: ", crash_call(mod, fun, args) | crash_info(min_level, info, prefix)]
+  end
+
+  defp crash_info(min_level, [{:current_function, {mod, fun, args}} | info], prefix) do
+    [prefix, "Current Call: ", crash_call(mod, fun, args) | crash_info(min_level, info, prefix)]
+  end
+
+  defp crash_info(min_level, [{:current_function, []} | info], prefix) do
+    crash_info(min_level, info, prefix)
+  end
+
+  defp crash_info(min_level, [{:ancestors, ancestors} | debug], prefix) do
+    [prefix, "Ancestors: ", inspect(ancestors) | crash_info(min_level, debug, prefix)]
+  end
+
+  defp crash_info(min_level, [{:process_label, :undefined} | info], prefix) do
+    crash_info(min_level, info, prefix)
+  end
+
+  defp crash_info(min_level, [{:process_label, label} | debug], prefix) do
+    [prefix, "Process Label: ", inspect(label) | crash_info(min_level, debug, prefix)]
+  end
+
+  defp crash_info(:debug, debug, prefix) do
+    for {key, value} <- debug do
+      crash_debug(key, value, prefix)
+    end
+  end
+
+  defp crash_info(_, _, _) do
+    []
+  end
+
+  defp crash_call(mod, fun, arity) when is_integer(arity) do
+    format_mfa(mod, fun, arity)
+  end
+
+  defp crash_call(mod, fun, args) do
+    format_mfa(mod, fun, length(args))
+  end
+
+  defp crash_debug(:current_stacktrace, stack, prefix) do
+    stack_prefix = [prefix | "    "]
+    stacktrace = Enum.map(stack, &[stack_prefix | Exception.format_stacktrace_entry(&1)])
+    [prefix, "Current Stacktrace:" | stacktrace]
+  end
+
+  defp crash_debug(key, value, prefix) do
+    [prefix, crash_debug_key(key), ?:, ?\s, inspect(value)]
+  end
+
+  defp crash_debug_key(key) do
+    case key do
+      :message_queue_len -> "Message Queue Length"
+      :messages -> "Messages"
+      :links -> "Links"
+      :dictionary -> "Dictionary"
+      :trap_exit -> "Trapping Exits"
+      :status -> "Status"
+      :heap_size -> "Heap Size"
+      :stack_size -> "Stack Size"
+      :reductions -> "Reductions"
+    end
+  end
+
+  defp crash_linked(_min_level, []), do: []
+
+  defp crash_linked(min_level, neighbours) do
+    Enum.reduce(neighbours, "\nNeighbours:", fn {:neighbour, info}, acc ->
+      [acc | crash_neighbour(min_level, info)]
+    end)
+  end
+
+  @indent "    "
+
+  defp crash_neighbour(min_level, [{:pid, pid}, {:registered_name, []} | info]) do
+    [?\n, @indent, inspect(pid) | crash_info(min_level, info, [?\n, @indent | @indent])]
+  end
+
+  defp crash_neighbour(min_level, [{:pid, pid}, {:registered_name, name} | info]) do
+    [?\n, @indent, inspect(name), " (", inspect(pid), ")"] ++
+      crash_info(min_level, info, [?\n, @indent | @indent])
+  end
+
+  defp format_last_message_from({_, {name, _}}), do: [" (from ", inspect(name), ")"]
+  defp format_last_message_from({from, _}), do: [" (from ", inspect(from), ")"]
+  defp format_last_message_from(_), do: []
+
+  defp format_client_info({from, :dead}),
+    do: ["\nClient ", inspect(from), " is dead"]
+
+  defp format_client_info({from, :remote}),
+    do: ["\nClient ", inspect(from), " is remote on node ", inspect(node(from))]
+
+  defp format_client_info({_, {name, stacktrace}}),
+    do: ["\nClient ", inspect(name), " is alive\n" | format_stacktrace(stacktrace)]
+
+  defp format_client_info(_),
+    do: []
+
+  defp format_reason({maybe_exception, [_ | _] = maybe_stacktrace} = reason) do
+    try do
+      format_stacktrace(maybe_stacktrace)
+    catch
+      :error, _ ->
+        {format_stop(reason), {reason, []}}
+    else
+      formatted_stacktrace ->
+        {formatted, reason} = maybe_normalize(maybe_exception, maybe_stacktrace)
+        {[formatted | formatted_stacktrace], {reason, maybe_stacktrace}}
+    end
+  end
+
+  defp format_reason(reason) do
+    {format_stop(reason), {reason, []}}
+  end
+
+  defp format_stop(reason) do
+    ["\n** (stop) " | Exception.format_exit(reason)]
+  end
+
+  # Erlang processes rewrite the :undef error to these reasons when logging
+  @gen_undef [:"module could not be loaded", :"function not exported"]
+
+  defp maybe_normalize(undef, [{mod, fun, args, _info} | _] = stacktrace)
+       when undef in @gen_undef and is_atom(mod) and is_atom(fun) do
+    cond do
+      is_list(args) ->
+        format_undef(mod, fun, length(args), undef, stacktrace)
+
+      is_integer(args) ->
+        format_undef(mod, fun, args, undef, stacktrace)
+
+      true ->
+        {format_stop(undef), undef}
+    end
+  end
+
+  defp maybe_normalize(reason, stacktrace) do
+    # If this is already an exception (even an ErlangError), we format it as an
+    # exception. Otherwise, we try to normalize it, and if it's normalized as an
+    # ErlangError we instead format it as an exit.
+    if is_exception(reason) do
+      {[?\n | Exception.format_banner(:error, reason, stacktrace)], reason}
+    else
+      case Exception.normalize(:error, reason, stacktrace) do
+        %ErlangError{} ->
+          {format_stop(reason), reason}
+
+        exception ->
+          {[?\n | Exception.format_banner(:error, exception, stacktrace)], exception}
+      end
+    end
+  end
+
+  defp format(kind, payload, stacktrace) do
+    [?\n, Exception.format_banner(kind, payload, stacktrace) | format_stacktrace(stacktrace)]
+  end
+
+  defp format_stacktrace(stacktrace) do
+    for entry <- stacktrace do
+      ["\n    " | Exception.format_stacktrace_entry(entry)]
+    end
+  end
+
+  defp registered_name(name) when is_atom(name), do: [registered_name: name]
+  defp registered_name(_name), do: []
+
+  defp format_mfa(mod, fun, :undefined),
+    do: [inspect(mod), ?., Macro.inspect_atom(:remote_call, fun) | "/?"]
+
+  defp format_mfa(mod, fun, args),
+    do: Exception.format_mfa(mod, fun, args)
+
+  defp exit_reason(:exit, reason, stack), do: {reason, stack}
+  defp exit_reason(:error, reason, stack), do: {reason, stack}
+  defp exit_reason(:throw, value, stack), do: {{:nocatch, value}, stack}
+
+  ## Deprecated helpers
+
+  defp format_from([]), do: ""
+  defp format_from([from]), do: " (from #{inspect(from)})"
+  defp format_from([from, stacktrace]) when is_list(stacktrace), do: " (from #{inspect(from)})"
+
+  defp format_from([from, node_name]) when is_atom(node_name),
+    do: " (from #{inspect(from)} on #{inspect(node_name)})"
+
+  defp format_client([from]) do
+    "\nClient #{inspect(from)} is dead"
+  end
+
+  defp format_client([from, stacktrace]) when is_list(stacktrace) do
+    ["\nClient #{inspect(from)} is alive\n" | format_stacktrace(stacktrace)]
+  end
+
+  defp format_client(_) do
+    []
+  end
+
+  defp format_undef(mod, fun, arity, undef, stacktrace) do
+    opts = [module: mod, function: fun, arity: arity, reason: undef]
+    exception = UndefinedFunctionError.exception(opts)
+    {[?\n | Exception.format_banner(:error, exception, stacktrace)], exception}
+  end
+end
diff --git a/lib/logger/lib/logger/utils.ex b/lib/logger/lib/logger/utils.ex
new file mode 100644
index 00000000000..302e4829e8c
--- /dev/null
+++ b/lib/logger/lib/logger/utils.ex
@@ -0,0 +1,283 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.Utils do
+  @moduledoc false
+
+  @doc """
+  A filter for default translation and handling of reports.
+  """
+  def translator(%{meta: %{domain: [:otp | _]}}, %{otp: false}), do: :stop
+  def translator(%{meta: %{domain: [:otp, :sasl | _]}}, %{sasl: false}), do: :stop
+  def translator(%{meta: %{domain: [:supervisor_report | _]}}, %{sasl: false}), do: :stop
+  def translator(%{msg: {:string, _}}, _config), do: :ignore
+
+  def translator(%{msg: msg, level: level, meta: meta} = event, %{translators: translators}) do
+    %{level: min_level} = :logger.get_primary_config()
+
+    try do
+      case msg do
+        {:report, %{label: label, report: report} = complete}
+        when map_size(complete) == 2 ->
+          translate(translators, min_level, level, :report, {label, report})
+
+        {:report, %{label: {:error_logger, _}, format: format, args: args}} ->
+          translate(translators, min_level, level, :format, {format, args})
+
+        {:report, report} ->
+          translate(translators, min_level, level, :report, {:logger, report})
+
+        {format, args} ->
+          translate(translators, min_level, level, :format, {format, args})
+      end
+    rescue
+      e ->
+        chardata = [
+          "Failure while translating Erlang's logger event\n",
+          Exception.format(:error, e, __STACKTRACE__)
+        ]
+
+        %{event | msg: {:string, chardata}}
+    else
+      :none ->
+        :ignore
+
+      :skip ->
+        :stop
+
+      {:ok, chardata} ->
+        return_translated_event(event, chardata, meta)
+
+      {:ok, chardata, translation_meta} ->
+        return_translated_event(event, chardata, Enum.into(translation_meta, meta))
+    end
+  end
+
+  def translated_cb(report) do
+    {~c"~ts", [report[:elixir_translation]]}
+  end
+
+  defp return_translated_event(%{msg: {:report, report}} = event, translation, meta) do
+    report =
+      if is_list(report),
+        do: [elixir_translation: translation] ++ report,
+        else: Map.put(report, :elixir_translation, translation)
+
+    %{
+      event
+      | msg: {:report, report},
+        meta: Map.put(meta, :report_cb, &__MODULE__.translated_cb/1)
+    }
+  end
+
+  defp return_translated_event(event, translation, meta) do
+    %{event | msg: {:string, translation}, meta: meta}
+  end
+
+  defp translate([{mod, fun} | t], min_level, level, kind, data) do
+    with :none <- apply(mod, fun, [min_level, level, kind, data]) do
+      translate(t, min_level, level, kind, data)
+    end
+  end
+
+  defp translate([], _min_level, _level, _kind, _data) do
+    :none
+  end
+
+  @doc """
+  A filter for removing logs if current process opted out of certain levels.
+  """
+  def process_level(%{level: level}, _extra) do
+    process_level = Logger.get_process_level(self())
+
+    if process_level != nil and :logger.compare_levels(level, process_level) == :lt do
+      :stop
+    else
+      :ignore
+    end
+  end
+
+  @doc """
+  A filter for logger exits which then removes itself.
+  """
+  def silence_logger_exit(
+        %{
+          msg:
+            {:report,
+             %{
+               label: {:application_controller, :exit},
+               report: [application: :logger, exited: :stopped] ++ _
+             }}
+        },
+        _extra
+      ) do
+    :logger.remove_primary_filter(:silence_logger_exit)
+    :stop
+  end
+
+  def silence_logger_exit(_message, _extra) do
+    :ignore
+  end
+
+  @doc """
+  Receives a format string and arguments, scans them, and then replace `~p`,
+  `~P`, `~w` and `~W` by its inspected variants.
+
+  For information about format scanning and how to consume them,
+  check `:io_lib.scan_format/2`.
+  """
+  @spec scan_inspect(
+          atom() | binary() | charlist(),
+          list(),
+          non_neg_integer() | :infinity,
+          Inspect.Opts.t()
+        ) :: [:io_lib.format_spec()]
+  def scan_inspect(format, args, truncate, opts \\ %Inspect.Opts{})
+
+  def scan_inspect(format, args, truncate, opts) when is_atom(format) do
+    scan_inspect(Atom.to_charlist(format), args, truncate, opts)
+  end
+
+  def scan_inspect(format, args, truncate, opts) when is_binary(format) do
+    scan_inspect(:binary.bin_to_list(format), args, truncate, opts)
+  end
+
+  def scan_inspect(format, [], _truncate, _opts) when is_list(format) do
+    :io_lib.scan_format(format, [])
+  end
+
+  def scan_inspect(format, args, truncate, opts) when is_list(format) do
+    # A pre-pass that removes binaries from
+    # arguments according to the truncate limit.
+    {args, _} =
+      Enum.map_reduce(args, truncate, fn arg, acc ->
+        if is_binary(arg) and acc != :infinity do
+          truncate_n(arg, acc)
+        else
+          {arg, acc}
+        end
+      end)
+
+    format
+    |> :io_lib.scan_format(args)
+    |> Enum.map(&handle_format_spec(&1, opts))
+  end
+
+  @inspected_format_spec %{
+    adjust: :right,
+    args: [],
+    control_char: ?s,
+    encoding: :unicode,
+    pad_char: ?\s,
+    precision: :none,
+    strings: true,
+    width: :none,
+    maps_order: :undefined
+  }
+
+  defp handle_format_spec(%{control_char: char} = spec, opts) when char in ~c"wWpP" do
+    %{args: args, width: width, strings: strings?} = spec
+
+    opts = %{
+      opts
+      | charlists: inspect_charlists(strings?, opts),
+        limit: inspect_limit(char, args, opts),
+        width: inspect_width(char, width)
+    }
+
+    %{@inspected_format_spec | args: [inspect_data(args, opts)]}
+  end
+
+  defp handle_format_spec(spec, _opts), do: spec
+
+  defp inspect_charlists(false, _), do: :as_lists
+  defp inspect_charlists(_, opts), do: opts.charlists
+
+  defp inspect_limit(char, [_, limit], _) when char in ~c"WP", do: limit
+  defp inspect_limit(_, _, opts), do: opts.limit
+
+  defp inspect_width(char, _) when char in ~c"wW", do: :infinity
+  defp inspect_width(_, width), do: width
+
+  defp inspect_data([data | _], opts) do
+    width = if opts.width == :none, do: 80, else: opts.width
+
+    data
+    |> Inspect.Algebra.to_doc(opts)
+    |> Inspect.Algebra.format(width)
+  end
+
+  @doc """
+  Truncates `n` elements from chartdata.
+  """
+  def truncate_n(_, n) when n < 0 do
+    {"", n}
+  end
+
+  def truncate_n(binary, n) when is_binary(binary) do
+    remaining = n - byte_size(binary)
+
+    if remaining < 0 do
+      # There is a chance we are cutting at the wrong
+      # place so we need to fix the binary.
+      {fix_binary(binary_part(binary, 0, n)), remaining}
+    else
+      {binary, remaining}
+    end
+  end
+
+  def truncate_n(int, n) when int in 0..127, do: {int, n - 1}
+  def truncate_n(int, n) when int in 127..0x07FF, do: {int, n - 2}
+  def truncate_n(int, n) when int in 0x800..0xFFFF, do: {int, n - 3}
+  def truncate_n(int, n) when int >= 0x10000 and is_integer(int), do: {int, n - 4}
+
+  def truncate_n(list, n) when is_list(list) do
+    truncate_n_list(list, n, [])
+  end
+
+  def truncate_n(other, _n) do
+    raise ArgumentError,
+          "cannot truncate chardata because it contains something that is not " <>
+            "valid chardata: #{inspect(other)}"
+  end
+
+  defp truncate_n_list(_, n, acc) when n < 0 do
+    {:lists.reverse(acc), n}
+  end
+
+  defp truncate_n_list([h | t], n, acc) do
+    {h, n} = truncate_n(h, n)
+    truncate_n_list(t, n, [h | acc])
+  end
+
+  defp truncate_n_list([], n, acc) do
+    {:lists.reverse(acc), n}
+  end
+
+  defp truncate_n_list(t, n, acc) do
+    {t, n} = truncate_n(t, n)
+    {:lists.reverse(acc, t), n}
+  end
+
+  defp fix_binary(binary) do
+    # Use a thirteen-bytes offset to look back in the binary.
+    # This should allow at least two code points of 6 bytes.
+    suffix_size = min(byte_size(binary), 13)
+    prefix_size = byte_size(binary) - suffix_size
+    <<prefix::binary-size(^prefix_size), suffix::binary-size(^suffix_size)>> = binary
+    prefix <> fix_binary(suffix, "")
+  end
+
+  defp fix_binary(<<h::utf8, t::binary>>, acc) do
+    acc <> <<h::utf8>> <> fix_binary(t, "")
+  end
+
+  defp fix_binary(<<h, t::binary>>, acc) do
+    fix_binary(t, <<acc::binary, h>>)
+  end
+
+  defp fix_binary(<<>>, _acc) do
+    <<>>
+  end
+end
diff --git a/lib/logger/mix.exs b/lib/logger/mix.exs
new file mode 100644
index 00000000000..67fc089bb3d
--- /dev/null
+++ b/lib/logger/mix.exs
@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :logger,
+      version: System.version(),
+      build_per_environment: false
+    ]
+  end
+
+  def application do
+    [
+      registered: [Logger, Logger.Supervisor],
+      mod: {Logger.App, []},
+      env: [
+        utc_log: false,
+        truncate: 8096,
+        translators: [{Logger.Translator, :translate}],
+        handle_otp_reports: true,
+        handle_sasl_reports: false,
+        always_evaluate_messages: false,
+        compile_time_purge_matching: [],
+        compile_time_application: nil,
+        translator_inspect_opts: [],
+        start_options: [],
+        sync_threshold: 20,
+        discard_threshold: 500,
+        discard_threshold_periodic_check: 30_000,
+        metadata: []
+      ]
+    ]
+  end
+end
diff --git a/lib/logger/test/logger/backends/console_test.exs b/lib/logger/test/logger/backends/console_test.exs
new file mode 100644
index 00000000000..210ea7d954f
--- /dev/null
+++ b/lib/logger/test/logger/backends/console_test.exs
@@ -0,0 +1,240 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.Backends.ConsoleTest do
+  use Logger.Case
+
+  require Logger
+  import ExUnit.CaptureIO
+
+  setup_all do
+    capture_io(:stderr, fn ->
+      Application.put_env(:logger, :backends, [Logger.Backends.Console])
+      Logger.App.stop()
+      Application.start(:logger)
+    end)
+
+    on_exit(fn ->
+      Application.delete_env(:logger, :backends)
+      Logger.App.stop()
+      Application.start(:logger)
+    end)
+  end
+
+  setup do
+    on_exit(fn ->
+      :ok =
+        Logger.Backends.Internal.configure(
+          Logger.Backends.Console,
+          format: nil,
+          device: :user,
+          level: nil,
+          metadata: [],
+          colors: [enabled: false]
+        )
+    end)
+  end
+
+  test "does not start when there is no user" do
+    :ok = Logger.Backends.Internal.remove(Logger.Backends.Console)
+    user = Process.whereis(:user)
+
+    try do
+      Process.unregister(:user)
+
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        assert :gen_event.add_handler(Logger, Logger.Backends.Console, Logger.Backends.Console) ==
+                 {:error, :ignore}
+      end)
+    after
+      Process.register(user, :user)
+    end
+  after
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      {:ok, _} = Logger.Backends.Internal.add(Logger.Backends.Console)
+    end)
+  end
+
+  test "may use another device" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console, device: :standard_error)
+
+    assert capture_io(:standard_error, fn ->
+             Logger.debug("hello")
+             Logger.flush()
+           end) =~ "hello"
+  end
+
+  test "configures format" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console, format: "$message [$level]")
+
+    assert capture_log(fn -> Logger.debug("hello") end) =~ "hello [debug]"
+  end
+
+  test "configures metadata" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console,
+      format: "$metadata$message",
+      metadata: [:user_id]
+    )
+
+    assert capture_log(fn -> Logger.debug("hello") end) =~ "hello"
+
+    Logger.metadata(user_id: 11)
+    Logger.metadata(user_id: 13)
+    assert capture_log(fn -> Logger.debug("hello") end) =~ "user_id=13 hello"
+  end
+
+  test "logs initial_call as metadata" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console,
+      format: "$metadata$message",
+      metadata: [:initial_call]
+    )
+
+    assert capture_log(fn -> Logger.debug("hello", initial_call: {Foo, :bar, 3}) end) =~
+             "initial_call=Foo.bar/3 hello"
+  end
+
+  test "logs domain as metadata" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console,
+      format: "$metadata$message",
+      metadata: [:domain]
+    )
+
+    assert capture_log(fn -> Logger.debug("hello", domain: [:foobar]) end) =~
+             "domain=elixir.foobar hello"
+  end
+
+  test "logs mfa as metadata" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console,
+      format: "$metadata$message",
+      metadata: [:mfa]
+    )
+
+    {function, arity} = __ENV__.function
+    mfa = Exception.format_mfa(__MODULE__, function, arity)
+
+    assert capture_log(fn -> Logger.debug("hello") end) =~
+             "mfa=#{mfa} hello"
+  end
+
+  test "ignores crash_reason metadata when configured with metadata: :all" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console,
+      format: "$metadata$message",
+      metadata: :all
+    )
+
+    Logger.metadata(crash_reason: {%RuntimeError{message: "oops"}, []})
+    assert capture_log(fn -> Logger.debug("hello") end) =~ "hello"
+  end
+
+  test "configures formatter to {module, function} tuple" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console, format: {__MODULE__, :format})
+
+    assert capture_log(fn -> Logger.debug("hello") end) =~ "my_format: hello"
+  end
+
+  def format(_level, message, _ts, _metadata) do
+    "my_format: #{message}"
+  end
+
+  test "configures metadata to :all" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console,
+      format: "$metadata",
+      metadata: :all
+    )
+
+    Logger.metadata(user_id: 11)
+    Logger.metadata(dynamic_metadata: 5)
+
+    %{module: mod, function: {name, arity}, file: file, line: line} = __ENV__
+    log = capture_log(fn -> Logger.debug("hello") end)
+
+    assert log =~ "file=#{file}"
+    assert log =~ "line=#{line + 1}"
+    assert log =~ "module=#{inspect(mod)}"
+    assert log =~ "function=#{name}/#{arity}"
+    assert log =~ "dynamic_metadata=5"
+    assert log =~ "user_id=11"
+  end
+
+  test "provides metadata defaults" do
+    metadata = [:file, :line, :module, :function]
+
+    Logger.Backends.Internal.configure(Logger.Backends.Console,
+      format: "$metadata",
+      metadata: metadata
+    )
+
+    %{module: mod, function: {name, arity}, file: file, line: line} = __ENV__
+    log = capture_log(fn -> Logger.debug("hello") end)
+
+    assert log =~ "file=#{file} line=#{line + 1} module=#{inspect(mod)} function=#{name}/#{arity}"
+  end
+
+  test "configures level" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console, level: :info)
+
+    assert capture_log(fn -> Logger.debug("hello") end) == ""
+  end
+
+  test "filter by notice" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console, level: :notice)
+
+    assert capture_log(fn -> Logger.debug("hello") end) == ""
+    assert capture_log(fn -> Logger.info("hello") end) == ""
+    assert capture_log(fn -> Logger.notice("hello") end) =~ "[notice] hello\n"
+    assert capture_log(fn -> Logger.warning("hello") end) =~ "[warning] hello\n"
+    assert capture_log(fn -> Logger.critical("hello") end) =~ "[critical] hello\n"
+    assert capture_log(fn -> Logger.alert("hello") end) =~ "[alert] hello\n"
+    assert capture_log(fn -> Logger.error("hello") end) =~ "[error] hello\n"
+  end
+
+  test "configures colors" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console,
+      format: "$message",
+      colors: [enabled: true]
+    )
+
+    assert capture_log(fn -> Logger.debug("hello") end) ==
+             IO.ANSI.cyan() <> "hello" <> IO.ANSI.reset()
+
+    Logger.Backends.Internal.configure(Logger.Backends.Console, colors: [debug: :magenta])
+
+    assert capture_log(fn -> Logger.debug("hello") end) ==
+             IO.ANSI.magenta() <> "hello" <> IO.ANSI.reset()
+
+    assert capture_log(fn -> Logger.info("hello") end) ==
+             IO.ANSI.normal() <> "hello" <> IO.ANSI.reset()
+
+    Logger.Backends.Internal.configure(Logger.Backends.Console, colors: [info: :cyan])
+
+    assert capture_log(fn -> Logger.info("hello") end) ==
+             IO.ANSI.cyan() <> "hello" <> IO.ANSI.reset()
+
+    assert capture_log(fn -> Logger.warning("hello") end) ==
+             IO.ANSI.yellow() <> "hello" <> IO.ANSI.reset()
+
+    Logger.Backends.Internal.configure(Logger.Backends.Console, colors: [warning: :magenta])
+
+    assert capture_log(fn -> Logger.warning("hello") end) ==
+             IO.ANSI.magenta() <> "hello" <> IO.ANSI.reset()
+
+    assert capture_log(fn -> Logger.error("hello") end) ==
+             IO.ANSI.red() <> "hello" <> IO.ANSI.reset()
+
+    Logger.Backends.Internal.configure(Logger.Backends.Console, colors: [error: :cyan])
+
+    assert capture_log(fn -> Logger.error("hello") end) ==
+             IO.ANSI.cyan() <> "hello" <> IO.ANSI.reset()
+  end
+
+  test "uses colors from metadata" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console,
+      format: "$message",
+      colors: [enabled: true]
+    )
+
+    assert capture_log(fn -> Logger.log(:error, "hello", ansi_color: :yellow) end) ==
+             IO.ANSI.yellow() <> "hello" <> IO.ANSI.reset()
+  end
+end
diff --git a/lib/logger/test/logger/backends/handler_test.exs b/lib/logger/test/logger/backends/handler_test.exs
new file mode 100644
index 00000000000..6510af3e795
--- /dev/null
+++ b/lib/logger/test/logger/backends/handler_test.exs
@@ -0,0 +1,211 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.Backends.HandlerTest do
+  use Logger.Case
+  @moduletag :logger
+
+  defmodule CustomTranslator do
+    def t(:debug, _level, :format, {~c"hello: ~p", [:ok]}) do
+      :skip
+    end
+
+    def t(:debug, _level, :format, {~c"world: ~p", [:ok]}) do
+      {:ok, "rewritten"}
+    end
+
+    def t(:debug, :info, :report, {:logger, %{hello: :ok}}) do
+      :skip
+    end
+
+    def t(:debug, :info, :report, {:logger, %{world: :ok}}) do
+      {:ok, "rewritten"}
+    end
+
+    def t(:debug, :info, :report, {:logger, %{error: error}}) do
+      raise(error)
+    end
+
+    def t(_, _, _, _) do
+      :none
+    end
+  end
+
+  setup_all do
+    Application.put_env(:logger, :default_handler, false)
+    Logger.App.stop()
+
+    # Explicitly use add to make sure that root is dynamically started
+    Application.start(:logger)
+
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      Logger.Backends.Internal.add(Logger.Backends.Console)
+    end)
+
+    on_exit(fn ->
+      Application.delete_env(:logger, :default_handler)
+      Logger.App.stop()
+      Application.start(:logger)
+    end)
+  end
+
+  test "add_translator/1 and remove_translator/1 for error_logger" do
+    assert Logger.add_translator({CustomTranslator, :t})
+
+    assert capture_log(fn ->
+             :error_logger.info_msg(~c"hello: ~p", [:ok])
+           end) == ""
+
+    assert capture_log(fn ->
+             :error_logger.info_msg(~c"world: ~p", [:ok])
+           end) =~ "[notice] rewritten"
+  after
+    assert Logger.remove_translator({CustomTranslator, :t})
+  end
+
+  test "add_translator/1 and remove_translator/1 for logger formats" do
+    refute {CustomTranslator, :t} in Application.fetch_env!(:logger, :translators)
+    assert Logger.add_translator({CustomTranslator, :t})
+    assert {CustomTranslator, :t} in Application.fetch_env!(:logger, :translators)
+
+    assert capture_log(fn ->
+             :logger.info(~c"hello: ~p", [:ok])
+           end) == ""
+
+    assert capture_log(fn ->
+             :logger.info(~c"world: ~p", [:ok])
+           end) =~ "[info] rewritten"
+
+    assert capture_log(fn ->
+             :logger.info(%{hello: :ok})
+           end) == ""
+
+    assert capture_log(fn ->
+             :logger.info(%{world: :ok})
+           end) =~ "[info] rewritten"
+  after
+    assert Logger.remove_translator({CustomTranslator, :t})
+  end
+
+  test "handles translation error" do
+    assert Logger.add_translator({CustomTranslator, :t})
+
+    message = capture_log(fn -> :logger.info(%{error: "oops"}) end)
+    assert message =~ "[info] Failure while translating Erlang's logger event\n"
+    assert message =~ "** (RuntimeError) oops\n"
+  after
+    assert Logger.remove_translator({CustomTranslator, :t})
+  end
+
+  test "converts Erlang metadata" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console,
+      metadata: [:file, :line, :module, :function]
+    )
+
+    message =
+      capture_log(fn ->
+        :logger.info("ok", %{file: ~c"file.erl", line: 13, mfa: {Foo, :bar, 3}})
+      end)
+
+    assert message =~ "module=Foo"
+    assert message =~ "function=bar/3"
+    assert message =~ "file=file.erl"
+    assert message =~ "line=13"
+  after
+    Logger.Backends.Internal.configure(Logger.Backends.Console, metadata: [])
+  end
+
+  test "ignores invalid Erlang metadata" do
+    assert capture_log(fn -> :logger.info("ok", %{time: "bad"}) end) =~ "ok"
+  after
+    Logger.Backends.Internal.configure(Logger.Backends.Console, metadata: [])
+  end
+
+  test "uses reporting callback with Elixir inspection" do
+    assert capture_log(fn ->
+             callback = fn %{hello: :world} -> {"~p~n", [:formatted]} end
+             :logger.info(%{hello: :world}, %{report_cb: callback})
+           end) =~ "[info] :formatted"
+  end
+
+  test "uses Erlang log levels" do
+    assert capture_log(fn -> :logger.emergency(~c"ok") end) =~ "[emergency] ok"
+    assert capture_log(fn -> :logger.alert(~c"ok") end) =~ "[alert] ok"
+    assert capture_log(fn -> :logger.critical(~c"ok") end) =~ "[critical] ok"
+    assert capture_log(fn -> :logger.error(~c"ok") end) =~ "[error] ok"
+    assert capture_log(fn -> :logger.warning(~c"ok") end) =~ "[warning] ok"
+    assert capture_log(fn -> :logger.notice(~c"ok") end) =~ "[notice] ok"
+    assert capture_log(fn -> :logger.info(~c"ok") end) =~ "[info] ok"
+    assert capture_log(fn -> :logger.debug(~c"ok") end) =~ "[debug] ok"
+  end
+
+  test "include Erlang severity level information" do
+    Logger.Backends.Internal.configure(Logger.Backends.Console, metadata: [:erl_level])
+
+    assert capture_log(fn -> :logger.emergency(~c"ok") end) =~ "erl_level=emergency"
+    assert capture_log(fn -> :logger.alert(~c"ok") end) =~ "erl_level=alert"
+    assert capture_log(fn -> :logger.critical(~c"ok") end) =~ "erl_level=critical"
+    assert capture_log(fn -> :logger.error(~c"ok") end) =~ "erl_level=error"
+    assert capture_log(fn -> :logger.warning(~c"ok") end) =~ "erl_level=warning"
+    assert capture_log(fn -> :logger.info(~c"ok") end) =~ "erl_level=info"
+    assert capture_log(fn -> :logger.debug(~c"ok") end) =~ "erl_level=debug"
+
+    [:emergency, :alert, :critical, :error, :warning, :notice, :info, :debug]
+    |> Enum.each(fn level ->
+      assert capture_log(fn -> :logger.log(level, ~c"ok") end) =~ "erl_level=#{level}"
+    end)
+  after
+    Logger.Backends.Internal.configure(Logger.Backends.Console, metadata: [])
+  end
+
+  test "respects translator_inspect_opts for reports" do
+    Application.put_env(:logger, :translator_inspect_opts, printable_limit: 1)
+
+    assert capture_log(fn -> :logger.error(%{foo: "bar"}) end) =~
+             ~S([error] [foo: "b" <> ...])
+  after
+    Application.put_env(:logger, :translator_inspect_opts, [])
+  end
+
+  test "calls report_cb/1 when supplied" do
+    report = %{foo: "bar"}
+
+    assert capture_log(fn -> :logger.error(report, %{report_cb: &format_report/1}) end) =~
+             ~S([error] %{foo: "bar"})
+
+    assert_received {:format, ^report}
+  end
+
+  test "calls report_cb/2 when supplied" do
+    report = %{foo: "bar"}
+
+    assert capture_log(fn -> :logger.error(report, %{report_cb: &format_report/2}) end) =~
+             ~S([error] %{foo: "bar"})
+
+    assert_received {:format, ^report, opts} when is_map(opts)
+    assert %{chars_limit: 8096, depth: :unlimited, single_line: false} = opts
+  end
+
+  test "calls report_cb/2 when passed %{label: term(), report: term()}" do
+    report = %{label: :foo, report: %{bar: 1, baz: 2}}
+
+    assert capture_log(fn -> :logger.error(report, %{report_cb: &format_report/1}) end)
+    assert_received {:format, ^report}
+
+    assert capture_log(fn -> :logger.error(report, %{report_cb: &format_report/2}) end)
+    assert_received {:format, ^report, _opts}
+  end
+
+  defp format_report(report) do
+    send(self(), {:format, report})
+
+    {~c"~p", [report]}
+  end
+
+  defp format_report(report, opts) do
+    send(self(), {:format, report, opts})
+
+    inspect(report)
+  end
+end
diff --git a/lib/logger/test/logger/backends_test.exs b/lib/logger/test/logger/backends_test.exs
new file mode 100644
index 00000000000..308a20061bd
--- /dev/null
+++ b/lib/logger/test/logger/backends_test.exs
@@ -0,0 +1,131 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Logger.BackendsTest do
+  use Logger.Case
+  require Logger
+
+  import ExUnit.CaptureIO
+
+  defmodule MyBackend do
+    @behaviour :gen_event
+
+    def init({MyBackend, pid}) when is_pid(pid) do
+      {:ok, pid}
+    end
+
+    def handle_event(event, state) do
+      send(state, {:event, event})
+      {:ok, state}
+    end
+
+    def handle_call(:error, _) do
+      raise "oops"
+    end
+
+    def handle_info(_msg, state) do
+      {:ok, state}
+    end
+
+    def code_change(_old_vsn, state, _extra) do
+      {:ok, state}
+    end
+
+    def terminate(_reason, _state) do
+      :ok
+    end
+  end
+
+  test "add_backend/1 and remove_backend/1" do
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      assert {:ok, _pid} = Logger.Backends.Internal.add(Logger.Backends.Console)
+    end)
+
+    assert Logger.Backends.Internal.add(Logger.Backends.Console) == {:error, :already_present}
+    assert :ok = Logger.Backends.Internal.remove(Logger.Backends.Console)
+    assert Logger.Backends.Internal.remove(Logger.Backends.Console) == {:error, :not_found}
+  end
+
+  test "add_backend/1 with {module, id}" do
+    assert {:ok, _} = Logger.Backends.Internal.add({MyBackend, self()})
+    assert {:error, :already_present} = Logger.Backends.Internal.add({MyBackend, self()})
+    assert :ok = Logger.Backends.Internal.remove({MyBackend, self()})
+  end
+
+  test "add_backend/1 with unknown backend" do
+    assert {:error, {{:EXIT, {:undef, [_ | _]}}, _}} =
+             Logger.Backends.Internal.add({UnknownBackend, self()})
+  end
+
+  test "logs or writes to stderr on failed call on async mode" do
+    assert {:ok, _} = Logger.Backends.Internal.add({MyBackend, self()})
+
+    assert capture_log(fn ->
+             ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               :gen_event.call(Logger, {MyBackend, self()}, :error)
+               wait_for_handler(Logger, {MyBackend, self()})
+             end)
+           end) =~
+             ~r":gen_event handler {Logger.BackendsTest.MyBackend, #PID<.*>} installed in Logger terminating"
+
+    Logger.flush()
+  after
+    Logger.Backends.Internal.remove({MyBackend, self()})
+  end
+
+  test "logs or writes to stderr on failed call on sync mode" do
+    capture_io(:stderr, fn ->
+      Logger.configure(sync_threshold: 0)
+    end)
+
+    assert {:ok, _} = Logger.Backends.Internal.add({MyBackend, self()})
+
+    assert capture_log(fn ->
+             ExUnit.CaptureIO.capture_io(:stderr, fn ->
+               :gen_event.call(Logger, {MyBackend, self()}, :error)
+               wait_for_handler(Logger, {MyBackend, self()})
+             end)
+           end) =~
+             ~r":gen_event handler {Logger.BackendsTest.MyBackend, #PID<.*>} installed in Logger terminating"
+
+    Logger.flush()
+  after
+    Logger.configure(sync_threshold: 20)
+    Logger.Backends.Internal.remove({MyBackend, :hello})
+  end
+
+  test "logs when discarding messages" do
+    capture_io(:stderr, fn ->
+      assert :ok = Logger.configure(discard_threshold: 5)
+    end)
+
+    Logger.Backends.Internal.add({MyBackend, self()})
+
+    capture_log(fn ->
+      :sys.suspend(Logger)
+      for _ <- 1..10, do: Logger.warning("warning!")
+      :sys.resume(Logger)
+      Logger.flush()
+      send(Logger, {Logger.Backends.Config, :update_counter})
+    end)
+
+    assert_receive {:event,
+                    {:warning, _,
+                     {Logger, "Attempted to log 0 messages, which is below :discard_threshold",
+                      _time, _metadata}}}
+  after
+    :sys.resume(Logger)
+    Logger.Backends.Internal.remove({MyBackend, self()})
+    assert :ok = Logger.configure(discard_threshold: 500)
+  end
+
+  test "restarts Logger.Backends.Config on Logger exits" do
+    Logger.Backends.Internal.configure([])
+
+    capture_log(fn ->
+      Process.whereis(Logger) |> Process.exit(:kill)
+      wait_for_logger()
+      wait_for_handler(Logger, Logger.Backends.Config)
+    end)
+  end
+end
diff --git a/lib/logger/test/logger/formatter_test.exs b/lib/logger/test/logger/formatter_test.exs
new file mode 100644
index 00000000000..01bc8fad4af
--- /dev/null
+++ b/lib/logger/test/logger/formatter_test.exs
@@ -0,0 +1,225 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.FormatterTest do
+  use Logger.Case, async: true
+
+  doctest Logger.Formatter
+  import Logger.Formatter
+
+  test "prune/1" do
+    assert prune(1) == "�"
+    assert prune(<<"hí", 233>>) == "hí�"
+    assert prune(["hi" | 233]) == ["hi" | "�"]
+    assert prune([233 | "hi"]) == [233 | "hi"]
+    assert prune([[] | []]) == [[]]
+  end
+
+  test "truncate/2" do
+    # ASCII binaries
+    assert truncate("foo", 4) == "foo"
+    assert truncate("foo", 3) == "foo"
+    assert truncate("foo", 2) == ["fo", " (truncated)"]
+
+    # UTF-8 binaries
+    assert truncate("olá", 2) == ["ol", " (truncated)"]
+    assert truncate("olá", 3) == ["ol", " (truncated)"]
+    assert truncate("olá", 4) == "olá"
+    assert truncate("ááááá:", 10) == ["ááááá", " (truncated)"]
+    assert truncate("áááááá:", 10) == ["ááááá", " (truncated)"]
+    assert truncate("𠜎𠜱𠝹𠱓", 15) == ["𠜎𠜱𠝹", " (truncated)"]
+
+    # Charlists
+    assert truncate(~c"olá", 2) == [~c"olá", " (truncated)"]
+    assert truncate(~c"olá", 3) == [~c"olá", " (truncated)"]
+    assert truncate(~c"olá", 4) == ~c"olá"
+
+    # Chardata
+    assert truncate(~c"ol" ++ "á", 2) == [~c"ol" ++ "", " (truncated)"]
+    assert truncate(~c"ol" ++ "á", 3) == [~c"ol" ++ "", " (truncated)"]
+    assert truncate(~c"ol" ++ "á", 4) == ~c"ol" ++ "á"
+
+    # :infinity
+    long_string = String.duplicate("foo", 10_000)
+    assert truncate(long_string, :infinity) == long_string
+  end
+
+  test "format_date/1" do
+    date = {2015, 1, 30}
+    assert format_date(date) == ["2015", ?-, [?0, "1"], ?-, "30"]
+  end
+
+  test "format_time/1" do
+    time = {12, 30, 10, 1}
+    assert format_time(time) == ["12", ?:, "30", ?:, "10", ?., [?0, ?0, "1"]]
+
+    time = {12, 30, 10, 10}
+    assert format_time(time) == ["12", ?:, "30", ?:, "10", ?., [?0, "10"]]
+  end
+
+  describe "log" do
+    test "handles :module and :function" do
+      {_, formatter} =
+        new(
+          format: "\n$time $metadata[$level] $message\n",
+          metadata: [:module, :function, :mfa],
+          colors: [enabled: false]
+        )
+
+      assert %{
+               level: :warning,
+               msg: {:string, "foo"},
+               meta: %{
+                 mfa: {Logger.Formatter, :compile, 1}
+               }
+             }
+             |> format(formatter)
+             |> IO.chardata_to_string() =~
+               "module=Logger.Formatter function=compile/1 mfa=Logger.Formatter.compile/1"
+    end
+
+    test "handles invalid :time in metadata" do
+      {_, formatter} =
+        new(
+          format: "\n$time $message\n",
+          colors: [enabled: false]
+        )
+
+      assert %{
+               level: :warning,
+               msg: {:string, "message"},
+               meta: %{
+                 mfa: {Logger.Formatter, :compile, 1},
+                 time: "invalid"
+               }
+             }
+             |> format(formatter)
+             |> IO.chardata_to_string() =~ ~r"\d\d\d message"
+    end
+
+    test "handles colorize with newlines" do
+      {_, formatter} =
+        new(
+          format: "$message",
+          colors: [enabled: true]
+        )
+
+      assert %{level: :warning, msg: {:string, ""}, meta: %{}}
+             |> format(formatter)
+             |> IO.chardata_to_string() == "\e[33m\e[0m"
+
+      assert %{level: :warning, msg: {:string, "s"}, meta: %{}}
+             |> format(formatter)
+             |> IO.chardata_to_string() == "\e[33ms\e[0m"
+
+      assert %{level: :warning, msg: {:string, "message"}, meta: %{}}
+             |> format(formatter)
+             |> IO.chardata_to_string() == "\e[33mmessage\e[0m"
+
+      assert %{level: :warning, msg: {:string, "message\n"}, meta: %{}}
+             |> format(formatter)
+             |> IO.chardata_to_string() == "\e[33mmessage\e[0m\n"
+
+      assert %{level: :warning, msg: {:string, "message\r\n"}, meta: %{}}
+             |> format(formatter)
+             |> IO.chardata_to_string() == "\e[33mmessage\e[0m\r\n"
+
+      assert %{level: :warning, msg: {:string, [?é, ["message", [?\n]]]}, meta: %{}}
+             |> format(formatter)
+             |> IO.chardata_to_string() == "\e[33mémessage\e[0m\n"
+
+      assert %{level: :warning, msg: {:string, [?é, "message", ?\r, ?\n]}, meta: %{}}
+             |> format(formatter)
+             |> IO.chardata_to_string() == "\e[33mémessage\e[0m\r\n"
+
+      assert %{level: :warning, msg: {:string, [?é, "message" | "\r\n"]}, meta: %{}}
+             |> format(formatter)
+             |> IO.chardata_to_string() == "\e[33mémessage\e[0m\r\n"
+    end
+  end
+
+  describe "compile + format" do
+    defmodule CompileMod do
+      def format(_level, _msg, _ts, _md) do
+        true
+      end
+    end
+
+    test "compile with nil" do
+      assert compile(nil) ==
+               ["\n", :time, " ", :metadata, "[", :level, "] ", :message, "\n"]
+    end
+
+    test "compile with string" do
+      assert compile("$level $time $date $metadata $message $node") ==
+               Enum.intersperse([:level, :time, :date, :metadata, :message, :node], " ")
+
+      assert_raise ArgumentError, "$bad is an invalid format pattern", fn ->
+        compile("$bad $good")
+      end
+    end
+
+    test "compile with {mod, fun}" do
+      assert compile({CompileMod, :format}) == {CompileMod, :format}
+    end
+
+    test "format with {mod, fun}" do
+      assert format({CompileMod, :format}, nil, nil, nil, nil) == true
+    end
+
+    test "format with format string" do
+      compiled = compile("[$level] $message")
+      assert format(compiled, :error, "hello", nil, []) == ["[", "error", "] ", "hello"]
+
+      compiled = compile("$node")
+      assert format(compiled, :error, nil, nil, []) == [Atom.to_string(node())]
+
+      compiled = compile("$metadata")
+      format = format(compiled, :error, nil, nil, meta: :data)
+      assert IO.chardata_to_string(format) == "meta=data "
+
+      pid = :erlang.list_to_pid(~c"<0.123.0>")
+      format = format(compiled, :error, nil, nil, meta: :data, pid: pid)
+      assert IO.chardata_to_string(format) == "meta=data pid=<0.123.0> "
+
+      # Hack to get the same predictable reference for every test run.
+      ref =
+        :erlang.binary_to_term(
+          <<131, 114, 0, 3, 100, 0, 13, 110, 111, 110, 111, 100, 101, 64, 110, 111>> <>
+            <<104, 111, 115, 116, 0, 0, 0, 0, 80, 0, 0, 0, 0, 0, 0, 0, 0>>
+        )
+
+      # Ensure the deserialization worked correctly
+      assert "#Reference<0.0.0.80>" == inspect(ref)
+
+      assert IO.chardata_to_string(format(compiled, :error, nil, nil, meta: :data, ref: ref)) ==
+               "meta=data ref=<0.0.0.80> "
+
+      port = :erlang.list_to_port(~c"#Port<0.1234>")
+      format = format(compiled, :error, nil, nil, meta: :data, port: port)
+      assert IO.chardata_to_string(format) == "meta=data port=<0.1234> "
+
+      # Also works with to_string
+      format = format(compiled, :error, nil, nil, date: ~D[2020-10-01])
+      assert IO.chardata_to_string(format) == "date=2020-10-01 "
+
+      # And with no metadata
+      assert IO.chardata_to_string(format(compiled, :error, nil, nil, [])) == ""
+
+      timestamp = {{2014, 12, 30}, {12, 6, 30, 100}}
+      compiled = compile("$date $time")
+
+      assert IO.chardata_to_string(format(compiled, :error, nil, timestamp, [])) ==
+               "2014-12-30 12:06:30.100"
+    end
+
+    test "format discards unknown formats" do
+      compiled = compile("$metadata $message")
+      metadata = [ancestors: [self()], crash_reason: {:some, :tuple}, foo: :bar]
+
+      assert format(compiled, :error, "hello", nil, metadata) ==
+               [["foo", 61, "bar", 32], " ", "hello"]
+    end
+  end
+end
diff --git a/lib/logger/test/logger/translator_test.exs b/lib/logger/test/logger/translator_test.exs
new file mode 100644
index 00000000000..badd09e529f
--- /dev/null
+++ b/lib/logger/test/logger/translator_test.exs
@@ -0,0 +1,1351 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.TranslatorTest do
+  use Logger.Case
+
+  defmodule MyGenServer do
+    use GenServer
+
+    def init(args) do
+      {:ok, args}
+    end
+
+    def handle_cast(:error, _) do
+      raise "oops"
+    end
+
+    def handle_call(:exit, _, _) do
+      exit(:oops)
+    end
+
+    def handle_call(:error, _, _) do
+      raise "oops"
+    end
+
+    def handle_call({:execute, fun}, _, state) do
+      fun.()
+      {:reply, :ok, state}
+    end
+
+    def handle_call(:error_on_down, {pid, _}, _) do
+      mon = Process.monitor(pid)
+      assert_receive {:DOWN, ^mon, _, _, _}
+      raise "oops"
+    end
+  end
+
+  defmodule MyGenEvent do
+    @behaviour :gen_event
+
+    def init(args) do
+      {:ok, args}
+    end
+
+    def handle_event(_event, state) do
+      {:ok, state}
+    end
+
+    def handle_call(:error, _) do
+      raise "oops"
+    end
+
+    def handle_call({:execute, fun}, state) do
+      fun.()
+      {:ok, :ok, state}
+    end
+
+    def handle_info(_msg, state) do
+      {:ok, state}
+    end
+
+    def code_change(_old_vsn, state, _extra) do
+      {:ok, state}
+    end
+
+    def terminate(_reason, _state) do
+      :ok
+    end
+  end
+
+  defmodule MyGenStatem do
+    @behaviour :gen_statem
+
+    @impl true
+    def callback_mode, do: :state_functions
+
+    @impl true
+    def init(args) do
+      {:ok, :started, args}
+    end
+
+    def started(:cast, :error, _) do
+      raise "oops"
+    end
+
+    def started({:call, _}, :exit, _) do
+      exit(:oops)
+    end
+
+    def started({:call, _}, :error, _) do
+      raise "oops"
+    end
+
+    def started({:call, from}, {:execute, fun}, data) do
+      fun.()
+      {:keep_state_and_data, {:reply, from, {:started, data}}}
+    end
+
+    def started({:call, {pid, _}}, :error_on_down, _) do
+      mon = Process.monitor(pid)
+      assert_receive {:DOWN, ^mon, _, _, _}
+      raise "oops"
+    end
+  end
+
+  defmodule MyGenStatemHandleEvent do
+    @behaviour :gen_statem
+
+    @impl true
+    def callback_mode, do: :handle_event_function
+
+    @impl true
+    def init(state) do
+      {:ok, :no_state, state}
+    end
+
+    @impl true
+    def handle_event({:call, _}, :error, :no_state, _data) do
+      raise "oops"
+    end
+
+    @impl :gen_statem
+    def format_status(_opts, [_pdict, _, state]) do
+      state
+    end
+  end
+
+  defmodule MyBridge do
+    @behaviour :supervisor_bridge
+
+    def init(reason) do
+      {:ok, pid} = Task.start_link(Kernel, :exit, [reason])
+      {:ok, pid, pid}
+    end
+
+    def terminate(_reason, pid) do
+      Process.exit(pid, :shutdown)
+    end
+  end
+
+  setup_all do
+    config = Application.get_all_env(:logger)
+
+    config
+    |> Keyword.put(:handle_sasl_reports, true)
+    |> put_logger_config()
+
+    on_exit(fn -> restore_logger_config(config) end)
+  end
+
+  setup context do
+    test_overrides = Map.get(context, :logger_config, [])
+    existing_config = Application.get_all_env(:logger)
+
+    case Keyword.merge(existing_config, test_overrides) do
+      ^existing_config ->
+        :ok
+
+      new_config ->
+        put_logger_config(new_config)
+        on_exit(fn -> restore_logger_config(existing_config) end)
+    end
+  end
+
+  setup do
+    fun = fn event, parent ->
+      send(parent, {:event, event.msg, event.meta})
+      :ignore
+    end
+
+    :logger.add_handler_filter(:default, :forwarder, {fun, self()})
+    on_exit(fn -> :logger.remove_handler_filter(:default, :forwarder) end)
+  end
+
+  test "translates GenServer crashes" do
+    {:ok, pid} = GenServer.start(MyGenServer, :ok)
+
+    assert capture_log(:info, fn ->
+             catch_exit(GenServer.call(pid, :error))
+           end) =~ """
+           [error] GenServer #{inspect(pid)} terminating
+           ** (RuntimeError) oops
+           """
+
+    assert_receive {:event, {:report, %{label: {:gen_server, :terminate}}}, gen_server_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = gen_server_metadata[:crash_reason]
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+
+    refute Map.has_key?(gen_server_metadata, :initial_call)
+    assert process_metadata[:initial_call] == {Logger.TranslatorTest.MyGenServer, :init, 1}
+
+    refute Map.has_key?(gen_server_metadata, :registered_name)
+    refute Map.has_key?(process_metadata, :registered_name)
+  end
+
+  test "translates GenServer crashes with local name", config do
+    {:ok, pid} = GenServer.start(MyGenServer, :ok, name: config.test)
+    capture_log(:info, fn -> catch_exit(GenServer.call(pid, :error)) end)
+
+    assert_receive {:event, {:report, %{label: {:gen_server, :terminate}}}, gen_server_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert gen_server_metadata[:registered_name] == config.test
+    assert process_metadata[:registered_name] == config.test
+  end
+
+  test "translates GenServer crashes with global name", config do
+    {:ok, pid} = GenServer.start(MyGenServer, :ok, name: {:global, config.test})
+    capture_log(:info, fn -> catch_exit(GenServer.call(pid, :error)) end)
+
+    assert_receive {:event, {:report, %{label: {:gen_server, :terminate}}}, gen_server_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert gen_server_metadata[:registered_name] == config.test
+    refute Map.has_key?(process_metadata, :registered_name)
+  end
+
+  @tag skip: System.otp_release() < "27"
+  test "translates GenServer crashes with process label" do
+    {:ok, pid} = GenServer.start(MyGenServer, :ok)
+    :ok = GenServer.call(pid, {:execute, fn -> Process.set_label({:any, "term"}) end})
+
+    assert capture_log(:info, fn -> catch_exit(GenServer.call(pid, :error)) end) =~ ~r"""
+           \[error\] GenServer #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Process Label: {:any, \"term\"}
+           Last message \(from #PID<\d+\.\d+\.\d+>\): :error\
+           """s
+  end
+
+  test "translates GenServer crashes with custom inspect options" do
+    {:ok, pid} = GenServer.start(MyGenServer, List.duplicate(:ok, 1000))
+    Application.put_env(:logger, :translator_inspect_opts, limit: 3)
+
+    assert capture_log(:debug, fn ->
+             catch_exit(GenServer.call(pid, :error))
+           end) =~ """
+           [:ok, :ok, :ok, ...]
+           """
+  after
+    Application.put_env(:logger, :translator_inspect_opts, [])
+  end
+
+  test "translates GenServer crashes on debug" do
+    {:ok, pid} = GenServer.start(MyGenServer, :ok)
+
+    assert capture_log(:debug, fn ->
+             catch_exit(GenServer.call(pid, :error))
+           end) =~ ~r"""
+           \[error\] GenServer #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Last message \(from #PID<\d+\.\d+\.\d+>\): :error
+           State: :ok
+           Client #PID<\d+\.\d+\.\d+> is alive
+           .*
+           """s
+
+    assert_receive {:event, {:report, %{label: {:gen_server, :terminate}}}, gen_server_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = gen_server_metadata[:crash_reason]
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+  end
+
+  test "translates GenServer crashes with named client on debug" do
+    {:ok, pid} = GenServer.start(MyGenServer, :ok)
+
+    assert capture_log(:debug, fn ->
+             Process.register(self(), :named_client)
+             catch_exit(GenServer.call(pid, :error))
+           end) =~ ~r"""
+           \[error\] GenServer #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Last message \(from :named_client\): :error
+           State: :ok
+           Client :named_client is alive
+           .*
+           """s
+  end
+
+  test "translates GenServer crashes with dead client on debug" do
+    {:ok, pid} = GenServer.start(MyGenServer, :ok)
+
+    assert capture_log(:debug, fn ->
+             mon = Process.monitor(pid)
+
+             spawn_link(fn ->
+               catch_exit(GenServer.call(pid, :error_on_down, 0))
+             end)
+
+             assert_receive {:DOWN, ^mon, _, _, _}
+           end) =~ ~r"""
+           \[error\] GenServer #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Last message \(from #PID<\d+\.\d+\.\d+>\): :error_on_down
+           State: :ok
+           Client #PID<\d+\.\d+\.\d+> is dead\
+           """s
+  end
+
+  test "translates GenServer crashes with no client" do
+    {:ok, pid} = GenServer.start(MyGenServer, :ok)
+
+    assert capture_log(:debug, fn ->
+             mon = Process.monitor(pid)
+             GenServer.cast(pid, :error)
+             assert_receive {:DOWN, ^mon, _, _, _}
+           end) =~ ~r"""
+           \[error\] GenServer #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Last message: {:"\$gen_cast", :error}
+           State: :ok\
+           """s
+  end
+
+  test "translates GenServer crashes with no client on debug" do
+    {:ok, pid} = GenServer.start(MyGenServer, :ok)
+
+    refute capture_log(:debug, fn ->
+             mon = Process.monitor(pid)
+             GenServer.cast(pid, :error)
+             assert_receive {:DOWN, ^mon, _, _, _}
+           end) =~ "Client"
+
+    assert_receive {:event, {:report, %{label: {:gen_server, :terminate}}}, _gen_server_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, _process_metadata}
+  end
+
+  test "translates :gen_event crashes" do
+    {:ok, pid} = :gen_event.start()
+    :ok = :gen_event.add_handler(pid, MyGenEvent, :ok)
+
+    assert capture_log(:info, fn ->
+             :gen_event.call(pid, MyGenEvent, :error)
+           end) =~ """
+           [error] :gen_event handler Logger.TranslatorTest.MyGenEvent \
+           installed in #{inspect(pid)} terminating
+           ** (RuntimeError) oops
+           """
+
+    assert_receive {:event, {:report, %{label: {:gen_event, :terminate}}}, metadata}
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = metadata[:crash_reason]
+    refute Map.has_key?(metadata, :initial_call)
+    refute Map.has_key?(metadata, :registered_name)
+  end
+
+  test "translates :gen_event crashes with name", config do
+    {:ok, pid} = :gen_event.start({:local, config.test})
+    :ok = :gen_event.add_handler(pid, MyGenEvent, :ok)
+
+    assert capture_log(:info, fn ->
+             :gen_event.call(pid, MyGenEvent, :error)
+           end) =~ """
+           [error] :gen_event handler Logger.TranslatorTest.MyGenEvent \
+           installed in #{inspect(config.test)} terminating
+           ** (RuntimeError) oops
+           """
+
+    assert_receive {:event, {:report, %{label: {:gen_event, :terminate}}}, metadata}
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = metadata[:crash_reason]
+    assert metadata[:registered_name] == config.test
+  end
+
+  @tag skip: System.otp_release() < "27"
+  test "translates :gen_event crashes with process label" do
+    {:ok, pid} = :gen_event.start()
+    :ok = :gen_event.add_handler(pid, MyGenEvent, :ok)
+
+    fun = fn -> Process.set_label({:any, "term"}) end
+    :ok = :gen_event.call(pid, MyGenEvent, {:execute, fun})
+
+    assert capture_log(:info, fn ->
+             :gen_event.call(pid, MyGenEvent, :error)
+           end) =~ ~r"""
+           \[error\] :gen_event handler Logger.TranslatorTest.MyGenEvent installed in #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Process Label: {:any, "term"}
+           Last message: :error\
+           """s
+  end
+
+  test "translates :gen_event crashes on debug" do
+    {:ok, pid} = :gen_event.start()
+    :ok = :gen_event.add_handler(pid, MyGenEvent, :ok)
+
+    assert capture_log(:debug, fn ->
+             :gen_event.call(pid, MyGenEvent, :error)
+           end) =~ ~r"""
+           \[error\] :gen_event handler Logger.TranslatorTest.MyGenEvent installed in #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Last message: :error
+           State: :ok\
+           """s
+
+    assert_receive {:event, {:report, %{label: {:gen_event, :terminate}}}, metadata}
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = metadata[:crash_reason]
+  end
+
+  test "translates :gen_statem crashes" do
+    {:ok, pid} = :gen_statem.start(MyGenStatem, :ok, [])
+
+    assert capture_log(:info, fn ->
+             catch_exit(:gen_statem.call(pid, :error))
+           end) =~ """
+           [error] :gen_statem #{inspect(pid)} terminating
+           ** (RuntimeError) oops
+           """
+
+    assert_receive {:event, {:report, %{label: {:gen_statem, :terminate}}}, gen_statem_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = gen_statem_metadata[:crash_reason]
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+
+    refute Map.has_key?(gen_statem_metadata, :initial_call)
+    assert process_metadata[:initial_call] == {MyGenStatem, :init, 1}
+
+    refute Map.has_key?(gen_statem_metadata, :registered_name)
+    refute Map.has_key?(process_metadata, :registered_name)
+  end
+
+  test "translates :gen_statem crashes with local name", config do
+    {:ok, pid} = :gen_statem.start({:local, config.test}, MyGenStatem, :ok, [])
+    capture_log(:info, fn -> catch_exit(:gen_statem.call(pid, :error)) end)
+
+    assert_receive {:event, {:report, %{label: {:gen_statem, :terminate}}}, gen_statem_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert gen_statem_metadata[:registered_name] == config.test
+    assert process_metadata[:registered_name] == config.test
+  end
+
+  test "translates :gen_statem crashes with global name", config do
+    {:ok, pid} = :gen_statem.start({:global, config.test}, MyGenStatem, :ok, [])
+    capture_log(:info, fn -> catch_exit(:gen_statem.call(pid, :error)) end)
+
+    assert_receive {:event, {:report, %{label: {:gen_statem, :terminate}}}, gen_statem_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert gen_statem_metadata[:registered_name] == config.test
+    refute Map.has_key?(process_metadata, :registered_name)
+  end
+
+  @tag skip: System.otp_release() < "27"
+  test "translates :gen_statem crashes with process label" do
+    {:ok, pid} = :gen_statem.start(MyGenStatem, :ok, [])
+
+    {:started, :ok} =
+      :gen_statem.call(pid, {:execute, fn -> Process.set_label({:any, "term"}) end})
+
+    assert capture_log(:info, fn -> catch_exit(:gen_statem.call(pid, :error)) end) =~ ~r"""
+           \[error\] :gen_statem #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Process Label: {:any, \"term\"}
+           Queue: .*
+           Postponed: \[\]\
+           """s
+  end
+
+  test "translates :gen_statem crashes with custom inspect options" do
+    {:ok, pid} = :gen_statem.start(MyGenStatem, List.duplicate(:ok, 1000), [])
+    Application.put_env(:logger, :translator_inspect_opts, limit: 3)
+
+    assert capture_log(:debug, fn ->
+             catch_exit(:gen_statem.call(pid, :error))
+           end) =~ """
+           State: {:started, [:ok, ...]}
+           """
+  after
+    Application.put_env(:logger, :translator_inspect_opts, [])
+  end
+
+  test "translates :gen_statem crashes on debug" do
+    {:ok, pid} = :gen_statem.start(MyGenStatem, :ok, [])
+
+    assert capture_log(:debug, fn ->
+             catch_exit(GenServer.call(pid, :error))
+           end) =~ ~r"""
+           \[error\] :gen_statem #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Queue: .*
+           Postponed: \[\]
+           State: {:started, :ok}
+           Callback mode: :state_functions, state_enter: false
+           Client #PID<\d+\.\d+\.\d+> is alive
+           .*
+           """s
+
+    assert_receive {:event, {:report, %{label: {:gen_statem, :terminate}}}, gen_statem_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = gen_statem_metadata[:crash_reason]
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+  end
+
+  test "translates :gen_statem crashed with named client on debug" do
+    {:ok, pid} = :gen_statem.start(MyGenStatem, :ok, [])
+
+    assert capture_log(:debug, fn ->
+             Process.register(self(), :named_client)
+             catch_exit(:gen_statem.call(pid, :error))
+           end) =~ ~r"""
+           \[error\] :gen_statem #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Queue: .*
+           Postponed: \[\]
+           State: {:started, :ok}
+           Callback mode: :state_functions, state_enter: false
+           Client :named_client is alive
+           .*
+           """s
+  end
+
+  test "translates :gen_statem crashes with dead client on debug" do
+    {:ok, pid} = :gen_statem.start(MyGenStatem, :ok, [])
+
+    assert capture_log(:debug, fn ->
+             mon = Process.monitor(pid)
+
+             spawn_link(fn ->
+               catch_exit(:gen_statem.call(pid, :error_on_down, 0))
+             end)
+
+             assert_receive {:DOWN, ^mon, _, _, _}
+           end) =~ ~r"""
+           \[error\] :gen_statem #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Queue: .*
+           Postponed: \[\]
+           State: {:started, :ok}
+           Callback mode: :state_functions, state_enter: false
+           Client #PID<\d+\.\d+\.\d+> is dead\
+           """s
+  end
+
+  test "translates :gen_statem crashes with no client" do
+    {:ok, pid} = :gen_statem.start(MyGenStatem, :ok, [])
+
+    assert capture_log(:debug, fn ->
+             mon = Process.monitor(pid)
+             :gen_statem.cast(pid, :error)
+             assert_receive {:DOWN, ^mon, _, _, _}
+           end) =~ ~r"""
+           \[error\] :gen_statem #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Queue: .*
+           Postponed: \[\]
+           State: {:started, :ok}
+           Callback mode: :state_functions, state_enter: false\
+           """s
+  end
+
+  test "translates :gen_statem crashes with no client on debug" do
+    {:ok, pid} = :gen_statem.start(MyGenStatem, :ok, [])
+
+    refute capture_log(:debug, fn ->
+             mon = Process.monitor(pid)
+             :gen_statem.cast(pid, :error)
+             assert_receive {:DOWN, ^mon, _, _, _}
+           end) =~ "Client"
+
+    assert_receive {:event, {:report, %{label: {:gen_statem, :terminate}}}, _gen_statem_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, _process_metadata}
+  end
+
+  test "translates :gen_statem crashes when callback_mode is :handle_event_function" do
+    {:ok, pid} = :gen_statem.start(MyGenStatemHandleEvent, :ok, [])
+
+    assert capture_log(:debug, fn ->
+             catch_exit(:gen_statem.call(pid, :error))
+           end) =~ ~r"""
+           \[error\] :gen_statem #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Queue: .*
+           Postponed: \[\]
+           State: :ok
+           Callback mode: .*, state_enter: false
+           """s
+
+    assert_receive {:event, {:report, %{label: {:gen_statem, :terminate}}}, gen_statem_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = gen_statem_metadata[:crash_reason]
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+
+    refute Map.has_key?(gen_statem_metadata, :initial_call)
+    assert process_metadata[:initial_call] == {MyGenStatemHandleEvent, :init, 1}
+
+    refute Map.has_key?(gen_statem_metadata, :registered_name)
+    refute Map.has_key?(process_metadata, :registered_name)
+  end
+
+  test "translates Task crashes" do
+    {:ok, pid} = Task.start_link(__MODULE__, :task, [self()])
+    parent = self()
+
+    assert capture_log(fn ->
+             ref = Process.monitor(pid)
+             send(pid, :go)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Task #{inspect(pid)} started from #{inspect(self())} terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Function: &Logger.TranslatorTest.task\/1
+               Args: \[#PID<\d+\.\d+\.\d+>\]\
+           """s
+
+    assert_receive {:event, {:report, %{label: {Task.Supervisor, :terminating}}}, task_metadata}
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = task_metadata[:crash_reason]
+    assert [parent] == task_metadata[:callers]
+    refute Map.has_key?(task_metadata, :initial_call)
+  end
+
+  test "translates Task undef module crash" do
+    parent = self()
+
+    assert capture_log(fn ->
+             {:ok, pid} = Task.start(:module_does_not_exist, :undef, [])
+             ref = Process.monitor(pid)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Task #PID<\d+\.\d+\.\d+> started from #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(UndefinedFunctionError\) function :module_does_not_exist.undef/0 is undefined \(module :module_does_not_exist is not available\)
+           .*
+           Function: &:module_does_not_exist.undef/0
+               Args: \[\]\
+           """s
+
+    assert_receive {:event, {:report, %{label: {Task.Supervisor, :terminating}}}, task_metadata}
+    assert [parent] == task_metadata[:callers]
+    assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = task_metadata[:crash_reason]
+  end
+
+  test "translates Task undef function crash" do
+    parent = self()
+
+    assert capture_log(fn ->
+             {:ok, pid} = Task.start(__MODULE__, :undef, [])
+             ref = Process.monitor(pid)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Task #PID<\d+\.\d+\.\d+> started from #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(UndefinedFunctionError\) function Logger.TranslatorTest.undef/0 is undefined or private
+           .*
+           Function: &Logger.TranslatorTest.undef/0
+               Args: \[\]\
+           """s
+
+    assert_receive {:event, {:report, %{label: {Task.Supervisor, :terminating}}}, task_metadata}
+    assert [parent] == task_metadata[:callers]
+    assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = task_metadata[:crash_reason]
+  end
+
+  test "translates Task raising ErlangError" do
+    parent = self()
+
+    assert capture_log(fn ->
+             exception =
+               try do
+                 :erlang.error(:foo)
+               rescue
+                 x ->
+                   x
+               end
+
+             {:ok, pid} = Task.start(:erlang, :error, [exception])
+             ref = Process.monitor(pid)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Task #PID<\d+\.\d+\.\d+> started from #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(ErlangError\) Erlang error: :foo
+           .*
+           Function: &:erlang\.error/1
+               Args: \[%ErlangError{.*}\]\
+           """s
+
+    assert_receive {:event, {:report, %{label: {Task.Supervisor, :terminating}}}, task_metadata}
+    assert [parent] == task_metadata[:callers]
+    assert {%ErlangError{original: :foo}, [_ | _]} = task_metadata[:crash_reason]
+  end
+
+  test "translates Task raising Erlang badarg error" do
+    parent = self()
+
+    assert capture_log(fn ->
+             {:ok, pid} = Task.start(:erlang, :error, [:badarg])
+             ref = Process.monitor(pid)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Task #PID<\d+\.\d+\.\d+> started from #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(ArgumentError\) argument error
+           .*
+           Function: &:erlang\.error/1
+               Args: \[:badarg\]\
+           """s
+
+    assert_receive {:event, {:report, %{label: {Task.Supervisor, :terminating}}}, task_metadata}
+    assert [parent] == task_metadata[:callers]
+    assert {%ArgumentError{message: "argument error"}, [_ | _]} = task_metadata[:crash_reason]
+  end
+
+  test "translates Task exiting abnormally" do
+    parent = self()
+
+    assert capture_log(fn ->
+             {:ok, pid} = Task.start(:erlang, :exit, [:abnormal])
+             ref = Process.monitor(pid)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Task #PID<\d+\.\d+\.\d+> started from #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(stop\) :abnormal
+           .*
+           Function: &:erlang\.exit/1
+               Args: \[:abnormal\]\
+           """s
+
+    assert_receive {:event, {:report, %{label: {Task.Supervisor, :terminating}}}, task_metadata}
+    assert [parent] == task_metadata[:callers]
+    assert {:abnormal, [_ | _]} = task_metadata[:crash_reason]
+  end
+
+  test "translates Task crashes with process label" do
+    fun = fn ->
+      Process.set_label({:any, "term"})
+      raise "oops"
+    end
+
+    {:ok, pid} = Task.start_link(__MODULE__, :task, [self(), fun])
+
+    assert capture_log(fn ->
+             ref = Process.monitor(pid)
+             send(pid, :go)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~
+             ~r"""
+             \[error\] Task #{inspect(pid)} started from #{inspect(self())} terminating
+             \*\* \(RuntimeError\) oops
+             .*
+             Process Label: {:any, \"term\"}
+             Function: &Logger.TranslatorTest.task\/2
+                 Args: \[#PID<\d+\.\d+\.\d+>\, .*]\
+             """s
+  end
+
+  test "translates application start" do
+    assert capture_log(fn ->
+             :ok = Application.start(:eex)
+             Application.stop(:eex)
+           end) =~ "Application eex started at #{inspect(node())}"
+  end
+
+  test "translates application stop" do
+    assert capture_log(fn ->
+             :ok = Application.start(:eex)
+             Application.stop(:eex)
+           end) =~ "Application eex exited: :stopped"
+  end
+
+  test "translates bare process crashes" do
+    assert capture_log(:info, fn ->
+             {_, ref} = spawn_monitor(fn -> raise "oops" end)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+             # Even though the monitor has been received the emulator may not have
+             # sent the message to the error logger
+             Process.sleep(200)
+           end) =~ ~r"""
+           \[error\] Process #PID<\d+\.\d+\.\d+>\ raised an exception
+           \*\* \(RuntimeError\) oops
+           """
+
+    assert_receive {:event, {:string, ["Process " | _]}, process_metadata}
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+  end
+
+  test "translates :proc_lib crashes" do
+    fun = fn ->
+      Logger.metadata(foo: :bar)
+      raise "oops"
+    end
+
+    pid = :proc_lib.spawn_link(__MODULE__, :task, [self(), fun])
+
+    assert capture_log(:info, fn ->
+             ref = Process.monitor(pid)
+             send(pid, :go)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Process #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Initial Call: Logger.TranslatorTest.task/2
+           Ancestors: \[#PID<\d+\.\d+\.\d+>\]\
+           """s
+
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert is_pid(process_metadata[:pid])
+    assert is_list(process_metadata[:ancestors])
+    assert process_metadata[:foo] == :bar
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+  end
+
+  test "skips :proc_lib crashes with disabled metadata" do
+    fun = fn ->
+      Logger.put_process_level(self(), :none)
+      raise "oops"
+    end
+
+    pid = :proc_lib.spawn_link(__MODULE__, :task, [self(), fun])
+
+    assert capture_log(:info, fn ->
+             ref = Process.monitor(pid)
+             send(pid, :go)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) == ""
+  end
+
+  test "translates :proc_lib crashes with name" do
+    fun = fn ->
+      Process.register(self(), __MODULE__)
+      raise "oops"
+    end
+
+    pid = :proc_lib.spawn_link(__MODULE__, :task, [self(), fun])
+
+    assert capture_log(:info, fn ->
+             ref = Process.monitor(pid)
+             send(pid, :message)
+             send(pid, :go)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Process Logger.TranslatorTest \(#PID<\d+\.\d+\.\d+>\) terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Initial Call: Logger.TranslatorTest.task/2
+           Ancestors: \[#PID<\d+\.\d+\.\d+>\]\
+           """s
+
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+  end
+
+  @tag skip: System.otp_release() < "27"
+  test "translates :proc_lib crashes with process label" do
+    fun = fn ->
+      Process.set_label({:any, "term"})
+      raise "oops"
+    end
+
+    pid = :proc_lib.spawn_link(__MODULE__, :task, [self(), fun])
+
+    assert capture_log(:info, fn ->
+             ref = Process.monitor(pid)
+             send(pid, :message)
+             send(pid, :go)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Process #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Initial Call: Logger.TranslatorTest.task/2
+           Process Label: {:any, \"term\"}
+           Ancestors: \[#PID<\d+\.\d+\.\d+>\]\
+           """s
+
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+  end
+
+  test "translates :proc_lib crashes without initial call" do
+    fun = fn ->
+      Process.delete(:"$initial_call")
+      raise "oops"
+    end
+
+    pid = :proc_lib.spawn_link(__MODULE__, :task, [self(), fun])
+
+    assert capture_log(:info, fn ->
+             ref = Process.monitor(pid)
+             send(pid, :message)
+             send(pid, :go)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Process #PID<\d+\.\d+\.\d+> terminating
+           \*\* \(RuntimeError\) oops
+           .*
+           Ancestors: \[#PID<\d+\.\d+\.\d+>\]\
+           """s
+
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+  end
+
+  test "translates :proc_lib crashes with neighbour" do
+    pid = :proc_lib.spawn_link(__MODULE__, :sub_task, [self()])
+
+    assert capture_log(:info, fn ->
+             ref = Process.monitor(pid)
+             send(pid, :message)
+             send(pid, :go)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           Ancestors: \[#PID<\d+\.\d+\.\d+>\]
+           Neighbours:
+               #PID<\d+\.\d+\.\d+>
+                   Initial Call: Logger.TranslatorTest.sleep/1
+                   Current Call: Logger.TranslatorTest.sleep/1
+                   Ancestors: \[#PID<\d+\.\d+\.\d+>, #PID<\d+\.\d+\.\d+>\]\
+           """
+  end
+
+  test "translates :proc_lib crashes with neighbour with name" do
+    fun = fn pid2 ->
+      Process.register(pid2, __MODULE__)
+      raise "oops"
+    end
+
+    pid = :proc_lib.spawn_link(__MODULE__, :sub_task, [self(), fun])
+
+    assert capture_log(:info, fn ->
+             ref = Process.monitor(pid)
+             send(pid, :message)
+             send(pid, :go)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           Ancestors: \[#PID<\d+\.\d+\.\d+>\]
+           Neighbours:
+               Logger.TranslatorTest \(#PID<\d+\.\d+\.\d+>\)
+                   Initial Call: Logger.TranslatorTest.sleep/1
+                   Current Call: Logger.TranslatorTest.sleep/1
+                   Ancestors: \[#PID<\d+\.\d+\.\d+>, #PID<\d+\.\d+\.\d+>\]\
+           """
+  end
+
+  test "translates Supervisor progress" do
+    {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)
+
+    assert capture_log(:debug, fn ->
+             ref = Process.monitor(pid)
+             Supervisor.start_child(pid, worker(Task, [__MODULE__, :sleep, [self()]]))
+             Process.exit(pid, :normal)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[(debug|info)\] Child Task of Supervisor #PID<\d+\.\d+\.\d+> \(Supervisor\.Default\) started
+           Pid: #PID<\d+\.\d+\.\d+>
+           Start Call: Task.start_link\(Logger.TranslatorTest, :sleep, \[#PID<\d+\.\d+\.\d+>\]\)
+           """
+  end
+
+  test "translates Supervisor progress with name" do
+    {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one, name: __MODULE__)
+
+    assert capture_log(:debug, fn ->
+             ref = Process.monitor(pid)
+             Supervisor.start_child(pid, worker(Task, [__MODULE__, :sleep, [self()]]))
+             Process.exit(pid, :normal)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[(debug|info)\] Child Task of Supervisor Logger.TranslatorTest started
+           """
+
+    {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one, name: {:global, __MODULE__})
+
+    assert capture_log(:debug, fn ->
+             ref = Process.monitor(pid)
+             Supervisor.start_child(pid, worker(Task, [__MODULE__, :sleep, [self()]]))
+             Process.exit(pid, :normal)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[(debug|info)\] Child Task of Supervisor Logger.TranslatorTest started
+           """
+
+    {:ok, pid} =
+      Supervisor.start_link([], strategy: :one_for_one, name: {:via, :global, __MODULE__})
+
+    assert capture_log(:debug, fn ->
+             ref = Process.monitor(pid)
+             Supervisor.start_child(pid, worker(Task, [__MODULE__, :sleep, [self()]]))
+             Process.exit(pid, :normal)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           \[(debug|info)\] Child Task of Supervisor Logger.TranslatorTest started
+           """
+  end
+
+  test "translates Supervisor progress on debug" do
+    {:ok, pid} = Supervisor.start_link([], strategy: :one_for_one)
+
+    assert capture_log(:debug, fn ->
+             ref = Process.monitor(pid)
+             Supervisor.start_child(pid, worker(Task, [__MODULE__, :sleep, [self()]]))
+             Process.exit(pid, :normal)
+             receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+           end) =~ ~r"""
+           Start Call: Task.start_link\(Logger.TranslatorTest, :sleep, \[#PID<\d+\.\d+\.\d+>\]\)
+           Restart: :permanent
+           Shutdown: 5000
+           Type: :worker\
+           """
+  end
+
+  test "translates Supervisor reports start error" do
+    Process.flag(:trap_exit, true)
+
+    assert capture_log(:info, fn ->
+             children = [worker(__MODULE__, [], function: :error)]
+
+             assert {:error, {:shutdown, {:failed_to_start_child, __MODULE__, :stop}}} =
+                      Supervisor.start_link(children, strategy: :one_for_one)
+           end) =~ ~r"""
+           \[error\] Child Logger.TranslatorTest of Supervisor #PID<\d+\.\d+\.\d+> \(Supervisor\.Default\) failed to start
+           \*\* \(exit\) :stop
+           Start Call: Logger.TranslatorTest.error\(\)\
+           """
+  end
+
+  test "translates Supervisor reports start error with raise" do
+    Process.flag(:trap_exit, true)
+
+    assert capture_log(:info, fn ->
+             children = [worker(__MODULE__, [], function: :undef)]
+
+             assert {:error, {:shutdown, {:failed_to_start_child, __MODULE__, {:EXIT, _}}}} =
+                      Supervisor.start_link(children, strategy: :one_for_one)
+           end) =~ ~r"""
+           \[error\] Child Logger.TranslatorTest of Supervisor #PID<\d+\.\d+\.\d+> \(Supervisor\.Default\) failed to start
+           \*\* \(exit\) an exception was raised:
+               \*\* \(UndefinedFunctionError\) function Logger.TranslatorTest.undef/0 is undefined or private
+               .*
+           Start Call: Logger.TranslatorTest.undef\(\)\
+           """s
+
+    assert_receive {:event, {:report, %{label: {:supervisor, :start_error}}}, _child_metadata}
+  end
+
+  test "translates Supervisor reports terminated" do
+    Process.flag(:trap_exit, true)
+
+    assert capture_log(:info, fn ->
+             children = [worker(Task, [Kernel, :exit, [:stop]])]
+             {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one, max_restarts: 0)
+             receive do: ({:EXIT, ^pid, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Child Task of Supervisor #PID<\d+\.\d+\.\d+> \(Supervisor\.Default\) terminated
+           \*\* \(exit\) :stop
+           Pid: #PID<\d+\.\d+\.\d+>
+           Start Call: Task.start_link\(Kernel, :exit, \[:stop\]\)\
+           """
+
+    assert_receive {:event, {:report, %{label: {Task.Supervisor, :terminating}}}, task_metadata}
+    assert_receive {:event, {:report, %{label: {:supervisor, :shutdown}}}, _child_metadata}
+
+    assert_receive {:event, {:report, %{label: {:supervisor, :child_terminated}}},
+                    _child_task_metadata}
+
+    assert {:stop, [_ | _]} = task_metadata[:crash_reason]
+  end
+
+  test "translates Supervisor reports max restarts shutdown" do
+    Process.flag(:trap_exit, true)
+
+    assert capture_log(:info, fn ->
+             children = [worker(Task, [Kernel, :exit, [:stop]])]
+             {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one, max_restarts: 0)
+             receive do: ({:EXIT, ^pid, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Child Task of Supervisor #PID<\d+\.\d+\.\d+> \(Supervisor\.Default\) caused shutdown
+           \*\* \(exit\) :reached_max_restart_intensity
+           Start Call: Task.start_link\(Kernel, :exit, \[:stop\]\)\
+           """
+
+    assert_receive {:event, {:report, %{label: {Task.Supervisor, :terminating}}}, task_metadata}
+    assert_receive {:event, {:report, %{label: {:supervisor, :shutdown}}}, _child_metadata}
+
+    assert_receive {:event, {:report, %{label: {:supervisor, :child_terminated}}},
+                    _child_task_metadata}
+
+    assert {:stop, [_ | _]} = task_metadata[:crash_reason]
+  end
+
+  test "translates Supervisor reports abnormal shutdown" do
+    assert capture_log(:info, fn ->
+             children = [worker(__MODULE__, [], function: :abnormal)]
+             {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one)
+             :ok = Supervisor.terminate_child(pid, __MODULE__)
+           end) =~ ~r"""
+           \[error\] Child Logger.TranslatorTest of Supervisor #PID<\d+\.\d+\.\d+> \(Supervisor\.Default\) shut down abnormally
+           \*\* \(exit\) :stop
+           Pid: #PID<\d+\.\d+\.\d+>
+           Start Call: Logger.TranslatorTest.abnormal\(\)\
+           """
+
+    assert_receive {:event, {:report, %{label: {:supervisor, :shutdown_error}}}, _child_metadata}
+  end
+
+  test "translates Supervisor reports abnormal shutdown on debug" do
+    assert capture_log(:debug, fn ->
+             children = [
+               worker(__MODULE__, [], function: :abnormal, restart: :permanent, shutdown: 5000)
+             ]
+
+             {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one)
+             :ok = Supervisor.terminate_child(pid, __MODULE__)
+           end) =~ ~r"""
+           \*\* \(exit\) :stop
+           Pid: #PID<\d+\.\d+\.\d+>
+           Start Call: Logger.TranslatorTest.abnormal\(\)
+           Restart: :permanent
+           Shutdown: 5000
+           Type: :worker\
+           """
+
+    assert_receive {:event, {:report, %{label: {:supervisor, :shutdown_error}}}, _child_metadata}
+  end
+
+  test "translates DynamicSupervisor reports abnormal shutdown" do
+    Process.flag(:trap_exit, true)
+
+    assert capture_log(:info, fn ->
+             child = %{id: __MODULE__, start: {__MODULE__, :abnormal, []}}
+             {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one)
+             {:ok, _pid2} = DynamicSupervisor.start_child(pid, child)
+             Process.exit(pid, :normal)
+             receive do: ({:EXIT, ^pid, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Child :undefined of Supervisor #PID<\d+\.\d+\.\d+> \(Supervisor\.Default\) shut down abnormally
+           \*\* \(exit\) :stop
+           Pid: #PID<\d+\.\d+\.\d+>
+           Start Call: Logger.TranslatorTest.abnormal\(\)\
+           """
+
+    assert_receive {:event, {:report, %{label: {:supervisor, :shutdown_error}}}, _child_metadata}
+  end
+
+  test "translates DynamicSupervisor reports abnormal shutdown including extra_arguments" do
+    Process.flag(:trap_exit, true)
+
+    assert capture_log(:info, fn ->
+             {:ok, pid} =
+               DynamicSupervisor.start_link(strategy: :one_for_one, extra_arguments: [:extra])
+
+             child = %{id: __MODULE__, start: {__MODULE__, :abnormal, [:args]}}
+             {:ok, _pid2} = DynamicSupervisor.start_child(pid, child)
+             Process.exit(pid, :normal)
+             receive do: ({:EXIT, ^pid, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Child :undefined of Supervisor #PID<\d+\.\d+\.\d+> \(Supervisor\.Default\) shut down abnormally
+           \*\* \(exit\) :stop
+           Pid: #PID<\d+\.\d+\.\d+>
+           Start Call: Logger.TranslatorTest.abnormal\(:extra, :args\)\
+           """
+
+    assert_receive {:event, {:report, %{label: {:supervisor, :shutdown_error}}}, _child_metadata}
+  end
+
+  test "translates named DynamicSupervisor reports abnormal shutdown" do
+    Process.flag(:trap_exit, true)
+
+    assert capture_log(:info, fn ->
+             child = %{id: __MODULE__, start: {__MODULE__, :abnormal, []}}
+             {:ok, pid} = DynamicSupervisor.start_link(strategy: :one_for_one, name: __MODULE__)
+             {:ok, _pid2} = DynamicSupervisor.start_child(pid, child)
+             Process.exit(pid, :normal)
+             receive do: ({:EXIT, ^pid, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Child :undefined of Supervisor Logger.TranslatorTest shut down abnormally
+           \*\* \(exit\) :stop
+           Pid: #PID<\d+\.\d+\.\d+>
+           Start Call: Logger.TranslatorTest.abnormal\(\)\
+           """
+
+    assert_receive {:event, {:report, %{label: {:supervisor, :shutdown_error}}}, _child_metadata}
+  end
+
+  test "translates :supervisor_bridge progress" do
+    Process.flag(:trap_exit, true)
+
+    assert capture_log(:info, fn ->
+             {:ok, pid} = :supervisor_bridge.start_link(MyBridge, :normal)
+             receive do: ({:EXIT, ^pid, _} -> :ok)
+           end) =~ ~r"""
+           \[info\] Child of Supervisor #PID<\d+\.\d+\.\d+> \(Logger\.TranslatorTest\.MyBridge\) started
+           Pid: #PID<\d+\.\d+\.\d+>
+           Start Call: Logger.TranslatorTest.MyBridge.init\(:normal\)\
+           """
+  end
+
+  test "translates :supervisor_bridge reports" do
+    Process.flag(:trap_exit, true)
+
+    assert capture_log(:info, fn ->
+             {:ok, pid} = :supervisor_bridge.start_link(MyBridge, :stop)
+             receive do: ({:EXIT, ^pid, _} -> :ok)
+           end) =~ ~r"""
+           \[error\] Child of Supervisor #PID<\d+\.\d+\.\d+> \(Logger\.TranslatorTest\.MyBridge\) terminated
+           \*\* \(exit\) :stop
+           Pid: #PID<\d+\.\d+\.\d+>
+           Start Module: Logger.TranslatorTest.MyBridge\
+           """
+
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, task_metadata}
+    assert_receive {:event, {:report, %{label: {:gen_server, :terminate}}}, _child_metadata}
+    assert {:stop, [_ | _]} = task_metadata[:crash_reason]
+  end
+
+  test "translates process crash with ERTS" do
+    assert {:ok, _msg, meta} =
+             Logger.Translator.translate(
+               :error,
+               :error,
+               :format,
+               {~c"Error in process ~p on node ~p with exit value:~n~p~n",
+                [self(), :"name@127.0.0.1", {:badarith, [{:erlang, :/, [1, 0], []}]}]}
+             )
+
+    assert meta[:crash_reason]
+  end
+
+  test "reports :undefined MFA properly" do
+    defmodule WeirdFunctionNamesGenServer do
+      use GenServer
+
+      def unquote(:"start link")(), do: GenServer.start_link(__MODULE__, [])
+      def init(args), do: {:ok, args}
+      def handle_call(_call, _from, _state), do: raise("oops")
+    end
+
+    start = {WeirdFunctionNamesGenServer, :"start link", []}
+    child = %{id: :weird, start: start, restart: :temporary}
+    {:ok, sup} = DynamicSupervisor.start_link(strategy: :one_for_one)
+
+    log =
+      capture_log(:info, fn ->
+        {:ok, pid} = DynamicSupervisor.start_child(sup, child)
+        catch_exit(GenServer.call(pid, :error))
+        [] = DynamicSupervisor.which_children(sup)
+      end)
+
+    assert log =~ ~s(Start Call: Logger.TranslatorTest.WeirdFunctionNamesGenServer."start link"/?)
+    assert_receive {:event, {:report, %{label: {:gen_server, :terminate}}}, server_metadata}
+    assert_receive {:event, {:report, %{label: {:proc_lib, :crash}}}, process_metadata}
+
+    assert_receive {:event, {:report, %{label: {:supervisor, :child_terminated}}},
+                    _child_metadata}
+
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = server_metadata[:crash_reason]
+    assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+  after
+    :code.purge(WeirdFunctionNamesGenServer)
+    :code.delete(WeirdFunctionNamesGenServer)
+  end
+
+  @tag logger_config: [handle_otp_reports: false]
+  test "drops events if otp report handling is switched off" do
+    {:ok, pid} = GenServer.start(MyGenServer, :ok)
+    catch_exit(GenServer.call(pid, :error))
+    refute_receive {:event, _, _}, 100
+  end
+
+  def task(parent, fun \\ fn -> raise "oops" end) do
+    mon = Process.monitor(parent)
+    Process.unlink(parent)
+
+    receive do
+      :go ->
+        fun.()
+
+      {:DOWN, ^mon, _, _, _} ->
+        exit(:shutdown)
+    end
+  end
+
+  def sub_task(parent, fun \\ fn _ -> raise "oops" end) do
+    mon = Process.monitor(parent)
+    Process.unlink(parent)
+    {:ok, pid} = Task.start_link(__MODULE__, :sleep, [self()])
+    receive do: (:sleeping -> :ok)
+
+    receive do
+      :go ->
+        fun.(pid)
+
+      {:DOWN, ^mon, _, _, _} ->
+        exit(:shutdown)
+    end
+  end
+
+  def sleep(pid) do
+    mon = Process.monitor(pid)
+    send(pid, :sleeping)
+    receive do: ({:DOWN, ^mon, _, _, _} -> exit(:shutdown))
+  end
+
+  def error(), do: {:error, :stop}
+
+  def abnormal() do
+    :proc_lib.start_link(__MODULE__, :abnormal_init, [])
+  end
+
+  def abnormal(:extra, :args) do
+    :proc_lib.start_link(__MODULE__, :abnormal_init, [])
+  end
+
+  def abnormal_init() do
+    Process.flag(:trap_exit, true)
+    :proc_lib.init_ack({:ok, self()})
+    receive do: ({:EXIT, _, _} -> exit(:stop))
+  end
+
+  defp worker(name, args, opts \\ []) do
+    Enum.into(opts, %{id: name, start: {name, opts[:function] || :start_link, args}})
+  end
+
+  defp put_logger_config(new_config) do
+    Application.put_all_env(logger: new_config)
+
+    Logger.App.stop()
+
+    # Shutdown the application
+    Logger.App.stop()
+
+    # And start it without warnings
+    Application.put_env(:logger, :level, :error)
+    Application.start(:logger)
+    Application.delete_env(:logger, :level)
+    Logger.configure(level: :debug)
+  end
+
+  defp restore_logger_config(config) do
+    Application.put_all_env(logger: config)
+    Logger.App.stop()
+    Application.start(:logger)
+  end
+end
diff --git a/lib/logger/test/logger/utils_test.exs b/lib/logger/test/logger/utils_test.exs
new file mode 100644
index 00000000000..992084faab2
--- /dev/null
+++ b/lib/logger/test/logger/utils_test.exs
@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Logger.UtilsTest do
+  use Logger.Case, async: true
+
+  doctest Logger.Utils
+
+  defp scan_inspect(format, args, truncate \\ 10) do
+    format
+    |> Logger.Utils.scan_inspect(args, truncate)
+    |> :io_lib.unscan_format()
+  end
+
+  test "formats" do
+    assert scan_inspect(~c"~p", [1]) == {~c"~ts", ["1"]}
+    assert scan_inspect("~p", [1]) == {~c"~ts", ["1"]}
+    assert scan_inspect(:"~p", [1]) == {~c"~ts", ["1"]}
+  end
+
+  test "sigils" do
+    assert scan_inspect(~c"~10.10tp", [1]) == {~c"~ts", ["1"]}
+    assert scan_inspect(~c"~-10.10tp", [1]) == {~c"~ts", ["1"]}
+
+    assert scan_inspect(~c"~10.10lp", [1]) == {~c"~ts", ["1"]}
+    assert scan_inspect(~c"~10.10x~p~n", [1, 2, 3]) == {~c"~10.10x~ts~n", [1, 2, "3"]}
+  end
+
+  test "with modifier t has no effect (as it is the default)" do
+    assert scan_inspect(~c"~tp", [1]) == {~c"~ts", ["1"]}
+    assert scan_inspect(~c"~tw", [1]) == {~c"~ts", ["1"]}
+  end
+
+  test "with modifier l always prints lists" do
+    assert scan_inspect(~c"~lp", [~c"abc"]) ==
+             {~c"~ts", ["[97, 98, 99]"]}
+
+    assert scan_inspect(~c"~lw", [~c"abc"]) ==
+             {~c"~ts", ["[97, 98, 99]"]}
+  end
+
+  test "with modifier for width" do
+    assert scan_inspect(~c"~5lp", [~c"abc"]) ==
+             {~c"~ts", ["[97,\n 98,\n 99]"]}
+
+    assert scan_inspect(~c"~5lw", [~c"abc"]) ==
+             {~c"~ts", ["[97, 98, 99]"]}
+  end
+
+  test "with modifier for limit" do
+    assert scan_inspect(~c"~5lP", [~c"abc", 2]) ==
+             {~c"~ts", ["[97,\n 98,\n ...]"]}
+
+    assert scan_inspect(~c"~5lW", [~c"abc", 2]) ==
+             {~c"~ts", ["[97, 98, ...]"]}
+  end
+
+  test "truncates binaries" do
+    assert scan_inspect(~c"~ts", ["abcdeabcdeabcdeabcde"]) == {~c"~ts", ["abcdeabcde"]}
+
+    assert scan_inspect(~c"~ts~ts~ts", ["abcdeabcde", "abcde", "abcde"]) ==
+             {~c"~ts~ts~ts", ["abcdeabcde", "", ""]}
+  end
+
+  test "with :infinity truncate" do
+    long_string = String.duplicate("foo", 10_000)
+    assert scan_inspect(~c"~ts", [long_string], :infinity) == {~c"~ts", [long_string]}
+  end
+end
diff --git a/lib/logger/test/logger_test.exs b/lib/logger/test/logger_test.exs
new file mode 100644
index 00000000000..c5bac9ecffc
--- /dev/null
+++ b/lib/logger/test/logger_test.exs
@@ -0,0 +1,783 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule LoggerTest do
+  use Logger.Case
+  require Logger
+
+  @moduletag formatter: [metadata: [:application, :module]]
+
+  setup tags do
+    :logger.update_handler_config(:default, :formatter, Logger.default_formatter(tags.formatter))
+
+    on_exit(fn ->
+      :logger.update_handler_config(:default, :formatter, Logger.default_formatter())
+    end)
+  end
+
+  defp msg_with_meta(text) do
+    msg("module=LoggerTest #{text}")
+  end
+
+  test "levels/0" do
+    assert [_ | _] = Logger.levels()
+    assert :info in Logger.levels()
+  end
+
+  test "level/0" do
+    assert Logger.level() == :debug
+
+    Logger.configure(level: :all)
+    assert Logger.level() == :all
+
+    Logger.configure(level: :info)
+    assert Logger.level() == :info
+
+    Logger.configure(level: :notice)
+    assert Logger.level() == :notice
+
+    Logger.configure(level: :warning)
+    assert Logger.level() == :warning
+
+    Logger.configure(level: :error)
+    assert Logger.level() == :error
+
+    Logger.configure(level: :critical)
+    assert Logger.level() == :critical
+
+    Logger.configure(level: :alert)
+    assert Logger.level() == :alert
+
+    Logger.configure(level: :emergency)
+    assert Logger.level() == :emergency
+
+    Logger.configure(level: :none)
+    assert Logger.level() == :none
+  after
+    Logger.configure(level: :debug)
+  end
+
+  test "per-module levels" do
+    defmodule PerModuleLevels do
+      def debug, do: Logger.debug("debug_msg")
+
+      def error, do: Logger.error("error_msg")
+    end
+
+    assert capture_log(fn -> assert PerModuleLevels.debug() == :ok end) =~ "debug_msg"
+    assert capture_log(fn -> assert PerModuleLevels.error() == :ok end) =~ "error_msg"
+
+    Logger.put_module_level(PerModuleLevels, :error)
+
+    assert capture_log(fn -> assert PerModuleLevels.debug() == :ok end) == ""
+    assert capture_log(fn -> Logger.debug("outer_debug_msg") end) =~ "outer_debug_msg"
+    assert capture_log(fn -> assert PerModuleLevels.error() == :ok end) =~ "error_msg"
+
+    Logger.put_module_level(PerModuleLevels, :debug)
+
+    assert capture_log(:error, fn -> assert PerModuleLevels.debug() == :ok end) =~ "debug_msg"
+    assert capture_log(:error, fn -> Logger.debug("outer_debug_msg") end) == ""
+    assert capture_log(:error, fn -> assert PerModuleLevels.error() == :ok end) =~ "error_msg"
+
+    Logger.delete_module_level(PerModuleLevels)
+
+    assert capture_log(fn -> assert PerModuleLevels.debug() == :ok end) =~ "debug_msg"
+    assert capture_log(fn -> assert PerModuleLevels.error() == :ok end) =~ "error_msg"
+
+    Logger.put_module_level(PerModuleLevels, :error)
+    assert capture_log(fn -> assert PerModuleLevels.debug() == :ok end) == ""
+    Logger.delete_all_module_levels()
+    assert capture_log(fn -> assert PerModuleLevels.debug() == :ok end) =~ "debug_msg"
+  end
+
+  test "per-modules levels" do
+    modules =
+      for n <- 1..2 do
+        name = Module.concat([__MODULE__, PerModulesLevels, to_string(n)])
+
+        defmodule name do
+          def debug, do: Logger.debug("debug_msg")
+
+          def error, do: Logger.error("error_msg")
+        end
+
+        name
+      end
+
+    for module <- modules do
+      assert capture_log(fn -> assert module.debug() == :ok end) =~ "debug_msg"
+      assert capture_log(fn -> assert module.error() == :ok end) =~ "error_msg"
+    end
+
+    Logger.put_module_level(modules, :error)
+
+    for module <- modules do
+      assert capture_log(fn -> assert module.debug() == :ok end) =~ ""
+      assert capture_log(fn -> Logger.debug("outer_debug_msg") end) =~ "outer_debug_msg"
+      assert capture_log(fn -> assert module.error() == :ok end) =~ "error_msg"
+    end
+
+    Logger.put_module_level(modules, :debug)
+
+    for module <- modules do
+      assert capture_log(:error, fn -> assert module.debug() == :ok end) =~ "debug_msg"
+      assert capture_log(:error, fn -> Logger.debug("outer_debug_msg") end) == ""
+      assert capture_log(fn -> assert module.error() == :ok end) =~ "error_msg"
+    end
+
+    Logger.delete_module_level(modules)
+
+    for module <- modules do
+      assert capture_log(fn -> assert module.debug() == :ok end) =~ "debug_msg"
+      assert capture_log(fn -> assert module.error() == :ok end) =~ "error_msg"
+    end
+
+    Logger.put_module_level(modules, :error)
+
+    for module <- modules do
+      assert capture_log(fn -> assert module.debug() == :ok end) == ""
+    end
+
+    Logger.delete_all_module_levels()
+
+    for module <- modules do
+      assert capture_log(fn -> assert module.debug() == :ok end) =~ "debug_msg"
+    end
+  end
+
+  test "per-application levels" do
+    Application.load(:eex)
+    assert Logger.get_module_level(EEx) == []
+    Logger.put_application_level(:eex, :notice)
+    assert Logger.get_module_level(EEx) == [{EEx, :notice}]
+    Logger.put_module_level(EEx, :alert)
+    assert Logger.get_module_level(EEx) == [{EEx, :alert}]
+  after
+    Logger.delete_all_module_levels()
+  end
+
+  test "per-process levels" do
+    assert Logger.get_process_level(self()) == nil
+
+    assert capture_log(fn -> Logger.debug("debug_msg") end) =~ "debug_msg"
+
+    Logger.put_process_level(self(), :debug)
+    assert Logger.get_process_level(self()) == :debug
+
+    assert capture_log(fn -> Logger.debug("debug_msg") end) =~ "debug_msg"
+
+    Logger.put_process_level(self(), :error)
+
+    assert capture_log(fn -> Logger.debug("debug_msg") end) == ""
+    assert capture_log(fn -> Logger.error("error_msg") end) =~ "error_msg"
+
+    Logger.put_process_level(self(), :none)
+    assert Logger.get_process_level(self()) == :none
+
+    assert capture_log(fn -> Logger.debug("debug_msg") end) == ""
+    assert capture_log(fn -> Logger.error("error_msg") end) == ""
+
+    Logger.delete_process_level(self())
+    assert Logger.get_process_level(self()) == nil
+
+    assert capture_log(fn -> Logger.debug("debug_msg") end) =~ "debug_msg"
+    assert capture_log(fn -> Logger.error("error_msg") end) =~ "error_msg"
+  end
+
+  test "process metadata" do
+    assert Logger.metadata(data: true) == :ok
+    assert Logger.metadata() == [data: true]
+    assert Logger.metadata(data: true) == :ok
+    assert Logger.metadata() == [data: true]
+    assert Logger.metadata(%{meta: 1}) == :ok
+    assert Enum.sort(Logger.metadata()) == [data: true, meta: 1]
+    assert Logger.metadata(%{data: nil}) == :ok
+    assert Logger.metadata() == [meta: 1]
+
+    assert Logger.reset_metadata(meta: 2) == :ok
+    assert Logger.metadata() == [meta: 2]
+    assert Logger.reset_metadata(%{data: true, app: nil}) == :ok
+    assert Logger.metadata() == [data: true]
+    assert Logger.reset_metadata() == :ok
+    assert Logger.metadata() == []
+  end
+
+  test "metadata merge" do
+    assert Logger.metadata(module: Sample) == :ok
+
+    assert capture_log(fn ->
+             assert Logger.bare_log(:info, "ok", application: nil, module: LoggerTest) == :ok
+           end) =~ msg("module=LoggerTest [info] ok")
+  end
+
+  test "metadata compile-time merge" do
+    assert Logger.metadata(mfa: {Sample, :foo, 1}) == :ok
+
+    assert capture_log(fn ->
+             assert Logger.bare_log(:info, "ok", application: nil, mfa: {CustomTest, :bar, 2}) ==
+                      :ok
+           end) =~ msg("module=CustomTest [info] ok")
+  end
+
+  test "metadata merge when the argument function returns metadata" do
+    assert Logger.metadata(module: Sample) == :ok
+
+    fun = fn -> {"ok", [module: "Function"]} end
+
+    assert capture_log(fn ->
+             assert Logger.bare_log(:info, fun, application: nil, module: LoggerTest) == :ok
+           end) =~ msg("module=Function [info] ok")
+  end
+
+  describe "log with function" do
+    test "supports iolist" do
+      fun = fn -> ["ok", ?:, ~c"example"] end
+
+      assert capture_log(fn ->
+               assert Logger.bare_log(:info, fun, application: nil, module: FunctionTest) == :ok
+             end) =~ msg("module=FunctionTest [info] ok:example")
+    end
+
+    test "supports binaries" do
+      fun = fn -> "ok:example" end
+
+      assert capture_log(fn ->
+               assert Logger.bare_log(:info, fun, application: nil, module: FunctionTest) == :ok
+             end) =~ msg("module=FunctionTest [info] ok:example")
+    end
+  end
+
+  describe "report logging" do
+    test "supports maps" do
+      assert capture_log(fn ->
+               assert Logger.bare_log(:info, %{foo: 10}, application: nil, module: FunctionTest) ==
+                        :ok
+             end) =~ msg("module=FunctionTest [info] [foo: 10]")
+    end
+
+    test "supports keyword" do
+      assert capture_log(fn ->
+               assert Logger.bare_log(:info, foo: 10) == :ok
+             end) =~ msg("[info] [foo: 10]")
+    end
+
+    test "supports custom report_cb" do
+      report_cb = fn %{foo: foo} -> {"Foo is ~B", [foo]} end
+
+      assert capture_log(fn ->
+               assert Logger.bare_log(:info, %{foo: 10}, report_cb: report_cb) == :ok
+             end) =~ msg("[info] Foo is 10")
+
+      report_cb = fn %{foo: foo}, _opts -> "Foo is #{foo}" end
+
+      assert capture_log(fn ->
+               assert Logger.bare_log(:info, %{foo: 20}, report_cb: report_cb) == :ok
+             end) =~ msg("[info] Foo is 20")
+    end
+
+    test "supports translator_inspect_opts for reports" do
+      Application.put_env(:logger, :translator_inspect_opts, printable_limit: 1)
+
+      assert capture_log(fn -> :logger.error(%{foo: "bar"}) end) =~
+               ~S([error] [foo: "b" <> ...])
+    after
+      Application.put_env(:logger, :translator_inspect_opts, [])
+    end
+
+    test "supports function that return report" do
+      assert capture_log(fn ->
+               assert Logger.bare_log(:info, fn -> %{foo: 10} end) == :ok
+             end) =~ msg("[info] [foo: 10]")
+
+      assert capture_log(fn ->
+               assert Logger.bare_log(:info, fn -> {%{foo: 10}, []} end) == :ok
+             end) =~ msg("[info] [foo: 10]")
+
+      assert capture_log(fn ->
+               assert Logger.bare_log(:info, fn -> {[foo: 10], []} end) == :ok
+             end) =~ msg("[info] [foo: 10]")
+    end
+  end
+
+  test "compare_levels/2" do
+    assert Logger.compare_levels(:debug, :debug) == :eq
+    assert Logger.compare_levels(:debug, :info) == :lt
+    assert Logger.compare_levels(:debug, :notice) == :lt
+    assert Logger.compare_levels(:debug, :warning) == :lt
+    assert Logger.compare_levels(:debug, :error) == :lt
+    assert Logger.compare_levels(:debug, :critical) == :lt
+    assert Logger.compare_levels(:debug, :alert) == :lt
+    assert Logger.compare_levels(:debug, :emergency) == :lt
+
+    assert Logger.compare_levels(:info, :debug) == :gt
+    assert Logger.compare_levels(:info, :info) == :eq
+    assert Logger.compare_levels(:info, :warning) == :lt
+    assert Logger.compare_levels(:info, :error) == :lt
+
+    assert Logger.compare_levels(:warning, :debug) == :gt
+    assert Logger.compare_levels(:warning, :info) == :gt
+    assert Logger.compare_levels(:warning, :warning) == :eq
+    assert Logger.compare_levels(:warning, :error) == :lt
+
+    assert Logger.compare_levels(:error, :debug) == :gt
+    assert Logger.compare_levels(:error, :info) == :gt
+    assert Logger.compare_levels(:error, :warning) == :gt
+    assert Logger.compare_levels(:error, :error) == :eq
+  end
+
+  test "deprecated :warn" do
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      assert capture_log(fn ->
+               Logger.log(:warn, "hello") == :ok
+             end) =~ "[warning]"
+
+      assert capture_log(fn ->
+               Logger.bare_log(:warn, "hello") == :ok
+             end) =~ "[warning]"
+    end)
+  end
+
+  describe "levels" do
+    test "debug/2" do
+      assert capture_log(fn ->
+               assert Logger.debug("hello", []) == :ok
+             end) =~ msg_with_meta("[debug] hello")
+
+      assert capture_log(:info, fn ->
+               assert Logger.debug("hello", []) == :ok
+             end) == ""
+
+      assert capture_log(:info, fn ->
+               assert Logger.debug(send(self(), :something), []) == :ok
+             end) == ""
+
+      refute_received :something
+    end
+
+    test "info/2" do
+      assert capture_log(fn ->
+               assert Logger.info("hello", []) == :ok
+             end) =~ msg_with_meta("[info] hello")
+
+      assert capture_log(:notice, fn ->
+               assert Logger.info("hello", []) == :ok
+             end) == ""
+
+      assert capture_log(:notice, fn ->
+               assert Logger.info(send(self(), :something), []) == :ok
+             end) == ""
+
+      refute_received :something
+    end
+
+    test "warning/2" do
+      assert capture_log(fn ->
+               assert Logger.warning("hello", []) == :ok
+             end) =~ msg_with_meta("[warning] hello")
+
+      assert capture_log(:error, fn ->
+               assert Logger.warning("hello", []) == :ok
+             end) == ""
+
+      assert capture_log(:error, fn ->
+               assert Logger.warning(send(self(), :something), []) == :ok
+             end) == ""
+
+      refute_received :something
+    end
+
+    test "error/2" do
+      assert capture_log(fn ->
+               assert Logger.error("hello", []) == :ok
+             end) =~ msg_with_meta("[error] hello")
+
+      assert capture_log(:critical, fn ->
+               assert Logger.error("hello", []) == :ok
+             end) == ""
+
+      assert capture_log(:critical, fn ->
+               assert Logger.error(send(self(), :something), []) == :ok
+             end) == ""
+
+      refute_received :something
+    end
+
+    test "critical/2" do
+      assert capture_log(fn ->
+               assert Logger.critical("hello", []) == :ok
+             end) =~ msg_with_meta("[critical] hello")
+
+      assert capture_log(:alert, fn ->
+               assert Logger.critical("hello", []) == :ok
+             end) == ""
+
+      assert capture_log(:alert, fn ->
+               assert Logger.critical(send(self(), :something), []) == :ok
+             end) == ""
+
+      refute_received :something
+    end
+
+    test "alert/2" do
+      assert capture_log(fn ->
+               assert Logger.alert("hello", []) == :ok
+             end) =~ msg_with_meta("[alert] hello")
+
+      assert capture_log(:emergency, fn ->
+               assert Logger.alert("hello", []) == :ok
+             end) == ""
+
+      assert capture_log(:emergency, fn ->
+               assert Logger.alert(send(self(), :something), []) == :ok
+             end) == ""
+
+      refute_received :something
+    end
+
+    test "emergency/2" do
+      assert capture_log(fn ->
+               assert Logger.emergency("hello", []) == :ok
+             end) =~ msg_with_meta("[emergency] hello")
+
+      assert capture_log(:none, fn ->
+               assert Logger.emergency("hello", []) == :ok
+             end) == ""
+
+      assert capture_log(:none, fn ->
+               assert Logger.emergency(send(self(), :something), []) == :ok
+             end) == ""
+
+      refute_received :something
+    end
+  end
+
+  test "remove unused calls at compile time based on matching metadata" do
+    Logger.configure(
+      compile_time_application: :sample_app,
+      compile_time_purge_matching: [
+        [module: LoggerTest.PurgeMatching, function: "two_filters/0"],
+        [function: "one_filter/0"],
+        [custom: true],
+        [function: "level_filter/0", level_lower_than: :warning],
+        [application: :sample_app, level_lower_than: :info]
+      ]
+    )
+
+    defmodule PurgeMatching do
+      def two_filters do
+        Logger.debug("two_filters")
+      end
+
+      def one_filter do
+        Logger.debug("one_filter")
+      end
+
+      def custom_filters do
+        Logger.debug("custom_filters", custom: true)
+      end
+
+      def level_filter do
+        Logger.info("info_filter")
+        Logger.warning("warning_filter")
+      end
+
+      def works do
+        Logger.info("works")
+      end
+
+      def log(level, metadata \\ []) do
+        Logger.log(level, "ok", metadata)
+      end
+    end
+
+    assert capture_log(fn -> assert PurgeMatching.works() == :ok end) =~ "works"
+    assert capture_log(fn -> assert PurgeMatching.one_filter() == :ok end) == ""
+    assert capture_log(fn -> assert PurgeMatching.two_filters() == :ok end) == ""
+    assert capture_log(fn -> assert PurgeMatching.custom_filters() == :ok end) == ""
+    assert capture_log(fn -> assert PurgeMatching.level_filter() == :ok end) =~ "warning_filter"
+    refute capture_log(fn -> assert PurgeMatching.level_filter() == :ok end) =~ "info_filter"
+
+    capture_log(fn -> assert PurgeMatching.log(:info) == :ok end)
+    capture_log(fn -> assert PurgeMatching.log(:debug) == :ok end)
+  after
+    Logger.configure(compile_time_application: nil)
+    Logger.configure(compile_time_purge_matching: [])
+  end
+
+  test "set application metadata at compile time" do
+    Logger.configure(compile_time_application: nil)
+
+    defmodule SampleNoApp do
+      def info do
+        Logger.info("hello")
+      end
+    end
+
+    assert capture_log(fn ->
+             assert SampleNoApp.info() == :ok
+           end) =~ msg("module=LoggerTest.SampleNoApp [info] hello")
+
+    Logger.configure(compile_time_application: :sample_app)
+
+    defmodule SampleApp do
+      def info do
+        Logger.info("hello")
+      end
+    end
+
+    assert capture_log(fn ->
+             assert SampleApp.info() == :ok
+           end) =~ msg("application=sample_app module=LoggerTest.SampleApp [info] hello")
+  after
+    Logger.configure(compile_time_application: nil)
+  end
+
+  @tag formatter: [truncate: 4]
+  test "log/2 truncates messages" do
+    assert capture_log(fn -> Logger.log(:debug, "hello") end) =~ "hell (truncated)"
+  end
+
+  test "log/2 handles bad Unicode chars" do
+    output =
+      capture_log(fn ->
+        assert Logger.log(:debug, "he" <> <<185>> <> "lo") == :ok
+        Process.sleep(100)
+      end)
+
+    assert output =~ "FORMATTER ERROR: bad return value"
+    assert output =~ "** (RuntimeError) bad return value from Logger formatter Logger.Formatter"
+  end
+
+  test "stops the application silently" do
+    Logger.App.stop()
+    Application.start(:logger)
+  end
+
+  test "starts the application with warning level" do
+    Logger.App.stop()
+    assert %{level: :notice} = :logger.get_primary_config()
+    Application.put_env(:logger, :level, :warning)
+    Application.start(:logger)
+    assert %{level: :warning} = :logger.get_primary_config()
+  after
+    Application.delete_env(:logger, :level)
+    Logger.App.stop()
+    Application.start(:logger)
+  end
+
+  test "starts the application without a handler" do
+    Application.put_env(:logger, :default_handler, false)
+    Logger.App.stop()
+    Application.start(:logger)
+    assert :logger.get_handler_config() == []
+  after
+    Application.delete_env(:logger, :default_handler)
+    Logger.App.stop()
+    Application.start(:logger)
+  end
+
+  test "starts the application with custom formatter" do
+    Application.put_env(:logger, :default_formatter, format: "yes--$message--yes")
+    Logger.App.stop()
+    Application.start(:logger)
+    assert capture_log(fn -> Logger.log(:debug, "hello") end) =~ "yes--hello--yes"
+  after
+    Application.delete_env(:logger, :default_formatter)
+    Logger.App.stop()
+    Application.start(:logger)
+  end
+
+  test "starts the application with custom handler" do
+    Application.put_env(:logger, :default_handler,
+      level: :error,
+      formatter: Logger.Formatter.new(format: "no--$message--no")
+    )
+
+    Logger.App.stop()
+    Application.start(:logger)
+    assert capture_log(fn -> Logger.log(:debug, "hello") end) == ""
+    assert capture_log(fn -> Logger.log(:error, "hello") end) =~ "no--hello--no"
+  after
+    Application.delete_env(:logger, :default_handler)
+    Logger.App.stop()
+    Application.start(:logger)
+  end
+
+  test "starts the application with global metadata" do
+    Application.put_env(:logger, :metadata, global_meta: :yes)
+    Logger.App.stop()
+    Application.start(:logger)
+    assert :logger.get_primary_config()[:metadata] == %{global_meta: :yes}
+  after
+    Application.put_env(:logger, :metadata, [])
+    Logger.App.stop()
+    Application.start(:logger)
+  end
+
+  test "writes to stderr on bad default handler config" do
+    Application.put_env(:logger, :default_handler, config: %{file: 123})
+    Logger.App.stop()
+
+    assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+             Application.start(:logger)
+           end) =~
+             "Could not attach default Logger handler: {:handler_not_added, {:callback_crashed,"
+  after
+    Application.delete_env(:logger, :default_handler)
+    Logger.App.stop()
+    Application.start(:logger)
+  end
+
+  test "writes to stderr on bad default handler module" do
+    Application.put_env(:logger, :default_handler, module: :who_knows)
+    Logger.App.stop()
+
+    assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+             Application.start(:logger)
+           end) =~
+             "Could not attach default Logger handler: {:invalid_handler, {:function_not_exported"
+  after
+    Application.delete_env(:logger, :default_handler)
+    Logger.App.stop()
+    Application.start(:logger)
+  end
+
+  test "configure/1 sets options" do
+    Logger.configure(translator_inspect_opts: [limit: 3])
+    assert Application.get_env(:logger, :translator_inspect_opts) == [limit: 3]
+  after
+    Logger.configure(translator_inspect_opts: [])
+  end
+
+  test "always evaluate messages" do
+    Logger.configure(
+      always_evaluate_messages: true,
+      compile_time_purge_matching: [[level_lower_than: :info]],
+      level: :error
+    )
+
+    defmodule AlwaysEvaluate do
+      def compile_purged do
+        Logger.debug(send(self(), "compile purged"))
+      end
+
+      def runtime_purged do
+        Logger.info(send(self(), "runtime purged"))
+      end
+
+      def not_purged do
+        Logger.error(send(self(), "not purged"))
+      end
+    end
+
+    assert capture_log(fn -> AlwaysEvaluate.not_purged() end) =~ "not purged"
+    assert_received "not purged"
+
+    assert capture_log(fn ->
+             Logger.configure(level: :error)
+             AlwaysEvaluate.runtime_purged()
+           end) == ""
+
+    assert_received "runtime purged"
+
+    assert capture_log(fn ->
+             Logger.configure(level: :debug)
+             AlwaysEvaluate.runtime_purged()
+           end) =~ "runtime purged"
+
+    assert_received "runtime purged"
+
+    assert capture_log(fn ->
+             Logger.configure(level: :error)
+             AlwaysEvaluate.compile_purged()
+           end) == ""
+
+    assert_received "compile purged"
+  after
+    Logger.configure(
+      level: :debug,
+      always_evaluate_messages: false,
+      compile_time_purge_matching: []
+    )
+  end
+
+  describe "colors" do
+    @tag formatter: [format: "$message", colors: [enabled: true]]
+    test "default" do
+      assert capture_log(fn -> Logger.debug("hello", ansi_color: :yellow) end) ==
+               IO.ANSI.yellow() <> "hello" <> IO.ANSI.reset()
+
+      assert capture_log(fn -> Logger.debug("hello") end) ==
+               IO.ANSI.cyan() <> "hello" <> IO.ANSI.reset()
+
+      assert capture_log(fn -> Logger.info("hello") end) ==
+               IO.ANSI.normal() <> "hello" <> IO.ANSI.reset()
+
+      assert capture_log(fn -> Logger.warning("hello") end) ==
+               IO.ANSI.yellow() <> "hello" <> IO.ANSI.reset()
+
+      assert capture_log(fn -> Logger.error("hello") end) ==
+               IO.ANSI.red() <> "hello" <> IO.ANSI.reset()
+    end
+
+    @tag formatter: [
+           format: "$message",
+           colors: [enabled: true, debug: :magenta, info: :cyan, warning: :magenta, error: :cyan]
+         ]
+    test "custom" do
+      assert capture_log(fn -> Logger.debug("hello") end) ==
+               IO.ANSI.magenta() <> "hello" <> IO.ANSI.reset()
+
+      assert capture_log(fn -> Logger.info("hello") end) ==
+               IO.ANSI.cyan() <> "hello" <> IO.ANSI.reset()
+
+      assert capture_log(fn -> Logger.warning("hello") end) ==
+               IO.ANSI.magenta() <> "hello" <> IO.ANSI.reset()
+
+      assert capture_log(fn -> Logger.error("hello") end) ==
+               IO.ANSI.cyan() <> "hello" <> IO.ANSI.reset()
+    end
+  end
+
+  describe "OTP integration" do
+    test "changes level in both" do
+      assert :logger.get_primary_config().level == :debug
+      Logger.configure(level: :error)
+      assert :logger.get_primary_config().level == :error
+    after
+      Logger.configure(level: :debug)
+    end
+
+    test "supports module level" do
+      :logger.set_module_level(__MODULE__, :none)
+      assert capture_log(fn -> Logger.info("hello") end) == ""
+      :logger.set_module_level(__MODULE__, :all)
+      assert capture_log(fn -> Logger.info("hello") end) =~ "hello"
+    after
+      :logger.unset_module_level(__MODULE__)
+    end
+
+    test "maps Erlang levels" do
+      :logger.set_primary_config(:level, :notice)
+      assert capture_log(fn -> Logger.info("hello") end) =~ "hello"
+
+      :logger.set_primary_config(:level, :notice)
+      assert Logger.level() == :notice
+
+      :logger.set_primary_config(:level, :emergency)
+      assert Logger.level() == :emergency
+    after
+      Logger.configure(level: :debug)
+    end
+
+    test "metadata is synchronised" do
+      Logger.metadata(foo: "bar")
+
+      assert Map.new(Logger.metadata()) == :logger.get_process_metadata()
+      :logger.set_process_metadata(%{bar: "foo"})
+
+      assert Map.new(Logger.metadata()) == :logger.get_process_metadata()
+    end
+  end
+end
diff --git a/lib/logger/test/test_helper.exs b/lib/logger/test/test_helper.exs
new file mode 100644
index 00000000000..3d623846e1a
--- /dev/null
+++ b/lib/logger/test/test_helper.exs
@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+{line_exclude, line_include} =
+  if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
+
+Code.require_file("../../elixir/scripts/cover_record.exs", __DIR__)
+CoverageRecorder.maybe_record("logger")
+
+ExUnit.start(
+  trace: !!System.get_env("TRACE"),
+  include: line_include,
+  exclude: line_exclude,
+  assert_receive_timeout: String.to_integer(System.get_env("ELIXIR_ASSERT_TIMEOUT", "300"))
+)
+
+defmodule Logger.Case do
+  use ExUnit.CaseTemplate
+  import ExUnit.CaptureIO
+
+  using _ do
+    quote do
+      import Logger.Case
+    end
+  end
+
+  def msg(msg) do
+    ~r/\d\d\:\d\d\:\d\d\.\d\d\d #{Regex.escape(msg)}/
+  end
+
+  def wait_for_handler(manager, handler) do
+    if handler not in :gen_event.which_handlers(manager) do
+      Process.sleep(10)
+      wait_for_handler(manager, handler)
+    end
+  end
+
+  def wait_for_logger() do
+    try do
+      :gen_event.which_handlers(Logger)
+    catch
+      :exit, _ ->
+        Process.sleep(10)
+        wait_for_logger()
+    else
+      _ ->
+        :ok
+    end
+  end
+
+  def capture_log(level \\ :debug, fun) do
+    Logger.configure(level: level)
+
+    capture_io(:user, fn ->
+      fun.()
+      Logger.flush()
+    end)
+  after
+    Logger.configure(level: :debug)
+  end
+end
diff --git a/lib/mix/lib/mix.ex b/lib/mix/lib/mix.ex
index 4db88d5f3cc..9f0e0c65155 100644
--- a/lib/mix/lib/mix.ex
+++ b/lib/mix/lib/mix.ex
@@ -1,108 +1,1225 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix do
-  @moduledoc """
-  Mix is a build tool that provides tasks for creating, compiling and
-  testing Elixir projects. Mix is inspired by the Leiningen
-  build tool for Clojure and was written by one of its contributors.
+  @moduledoc ~S"""
+  Mix is a build tool that provides tasks for creating, compiling,
+  and testing Elixir projects, managing its dependencies, and more.
+
+  ## `Mix.Project`
+
+  The foundation of Mix is a project. A project can be defined by using
+  `Mix.Project` in a module, usually placed in a file named `mix.exs`:
+
+      defmodule MyApp.MixProject do
+        use Mix.Project
+
+        def project do
+          [
+            app: :my_app,
+            version: "1.0.0"
+          ]
+        end
+      end
+
+  See the `Mix.Project` module for detailed documentation on Mix projects.
+
+  Once the project is defined, a number of default Mix tasks can be run
+  directly from the command line:
+
+    * `mix compile` - compiles the current project
+    * `mix test` - runs tests for the given project
+    * `mix run` - runs a particular command inside the project
+
+  Each task has its own options and sometimes specific configuration
+  to be defined in the `project/0` function. You can use `mix help`
+  to list all available tasks and `mix help NAME` to show help for
+  a particular task.
+
+  The best way to get started with your first project is by calling
+  `mix new my_project` from the command line.
+
+  ## `Mix.Task`
+
+  Tasks are what make Mix extensible.
+
+  Projects can extend Mix behaviour by adding their own tasks. For
+  example, adding the task below inside your project will
+  make it available to everyone that uses your project:
+
+      defmodule Mix.Tasks.Hello do
+        use Mix.Task
+
+        def run(_) do
+          Mix.shell().info("Hello world")
+        end
+      end
+
+  The task can now be invoked with `mix hello`.
+
+  See the `Mix.Task` behaviour for detailed documentation on Mix tasks.
+
+  ## Dependencies
+
+  Mix also manages your dependencies and integrates nicely with the [Hex package
+  manager](https://hex.pm).
+
+  In order to use dependencies, you need to add a `:deps` key
+  to your project configuration. We often extract the list of dependencies
+  into its own function:
+
+      defmodule MyApp.MixProject do
+        use Mix.Project
+
+        def project do
+          [
+            app: :my_app,
+            version: "1.0.0",
+            deps: deps()
+          ]
+        end
+
+        defp deps do
+          [
+            {:ecto, "~> 2.0"},
+            {:plug, github: "elixir-lang/plug"}
+          ]
+        end
+      end
+
+  You can run `mix help deps` to learn more about dependencies in Mix.
+
+  ## Environments
+
+  Mix supports different environments. Environments allow developers
+  to prepare and organize their project specifically for different
+  scenarios. By default, Mix provides three environments:
+
+    * `:dev` - the default environment
+    * `:test` - the environment `mix test` runs on
+    * `:prod` - the environment your dependencies run on
+
+  The environment can be changed via the command line by setting
+  the `MIX_ENV` environment variable, for example:
+
+  ```bash
+  $ MIX_ENV=prod mix run server.exs
+  ```
+
+  You can also specify that certain dependencies are available only for
+  certain environments:
+
+      {:some_test_dependency, "~> 1.0", only: :test}
+
+  When running Mix via the command line, you can configure the default
+  environment or the preferred environment per task via the `def cli`
+  function in your `mix.exs`. For example:
+
+      def cli do
+        [
+          default_env: :local,
+          preferred_envs: [docs: :docs]
+        ]
+      end
+
+  The environment can be read via `Mix.env/0`.
+
+  ## Targets
+
+  Besides environments, Mix supports targets. Targets are useful when a
+  project needs to compile to different architectures and some of the
+  dependencies are only available to some of them. By default, the target
+  is `:host` but it can be set via the `MIX_TARGET` environment variable.
+
+  When running Mix via the command line, you can configure the default
+  target or the preferred target per task via the `def cli` function
+  in your `mix.exs`. For example:
+
+      def cli do
+        [
+          default_target: :local,
+          preferred_targets: [docs: :docs]
+        ]
+      end
+
+  The target can be read via `Mix.target/0`.
+
+  ## Configuration
+
+  Mix allows you to configure the application environment of your application
+  and of your dependencies. See the `Application` module to learn more about
+  the application environment. On this section, we will focus on how to configure
+  it at two distinct moments: build-time and runtime.
+
+  > #### Avoiding the application environment {: .warning}
+  >
+  > The application environment is discouraged for libraries. See Elixir's
+  > [Library Guidelines](https://hexdocs.pm/elixir/library-guidelines.html) for
+  > more information.
+
+  ### Build-time configuration
+
+  Whenever you invoke a `mix` command, Mix loads the configuration
+  in `config/config.exs`, if said file exists. It is common for the
+  `config/config.exs` file itself to import other configuration based
+  on the current `MIX_ENV`, such as `config/dev.exs`, `config/test.exs`,
+  and `config/prod.exs`, by calling `Config.import_config/1`:
+
+      import Config
+      import_config "#{config_env()}.exs"
+
+  We say `config/config.exs` and all imported files are build-time
+  configuration as they are evaluated whenever you compile your code.
+  In other words, if your configuration does something like:
+
+      import Config
+      config :my_app, :secret_key, System.fetch_env!("MY_APP_SECRET_KEY")
+
+  The `:secret_key` key under `:my_app` will be computed on the host
+  machine before your code compiles. This can be an issue if the machine
+  compiling your code does not have access to all environment variables
+  used to run your code, as loading the config above will fail due to the
+  missing environment variable. Furthermore, even if the environment variable
+  is set, changing the environment variable will require a full recompilation
+  of your application by calling `mix compile --force` (otherwise your project
+  won't start). Luckily, Mix also provides runtime configuration, which is
+  preferred in such cases and we will see next.
+
+  ### Runtime configuration
+
+  To enable runtime configuration in your release, all you need to do is
+  to create a file named `config/runtime.exs`:
+
+      import Config
+      config :my_app, :secret_key, System.fetch_env!("MY_APP_SECRET_KEY")
+
+  This file is executed whenever your project runs. If you assemble
+  a release with `mix release`, it also executes every time your release
+  starts.
+
+  ## Aliases
+
+  Aliases are shortcuts or tasks specific to the current project.
+
+  In the [Mix.Task section](#module-mix-task), we have defined a task that would be
+  available to everyone using our project as a dependency. What if
+  we wanted the task to only be available for our project? Just
+  define an alias:
+
+      defmodule MyApp.MixProject do
+        use Mix.Project
+
+        def project do
+          [
+            app: :my_app,
+            version: "1.0.0",
+            aliases: aliases()
+          ]
+        end
+
+        defp aliases do
+          [
+            c: "compile",
+            hello: &hello/1,
+            paid_task: &paid_task/1
+          ]
+        end
+
+        defp hello(_) do
+          Mix.shell().info("Hello world")
+        end
+
+        defp paid_task(_) do
+          Mix.Task.run("paid.task", [
+            "first_arg",
+            "second_arg",
+            "--license-key",
+            System.fetch_env!("SOME_LICENSE_KEY")
+          ])
+        end
+      end
+
+  In the example above, we have defined three aliases. One is `mix c`
+  which is a shortcut for `mix compile`. Another is named
+  `mix hello` and the third is named `mix paid_task`, which executes
+  the code inside a custom function to invoke the `paid.task` task
+  with several arguments, including one pulled from an environment
+  variable.
+
+  Aliases may also be lists, specifying multiple tasks to be run
+  consecutively:
+
+      [all: [&hello/1, "deps.get --only #{Mix.env()}", "compile"]]
+
+  In the example above, we have defined an alias named `mix all`,
+  that prints "Hello world", then fetches dependencies specific
+  to the current environment, and compiles the project.
+
+  Aliases can also be used to augment existing tasks. Let's suppose
+  you want to augment `mix clean` to clean another directory Mix does
+  not know about:
+
+      [clean: ["clean", &clean_extra/1]]
+
+  Where `&clean_extra/1` would be a function in your `mix.exs`
+  with extra cleanup logic.
+
+  If the alias is overriding an existing task, the arguments given
+  to the alias will be forwarded to the original task in order to
+  preserve semantics. Otherwise arguments given to the alias are
+  appended to the arguments of the last task in the list.
+
+  Another use case of aliases is to run Elixir scripts and shell
+  commands, for example:
+
+      # priv/hello1.exs
+      IO.puts("Hello One")
+
+      # priv/hello2.exs
+      IO.puts("Hello Two")
+
+      # priv/world.sh
+      #!/bin/sh
+      echo "world!"
+
+      # mix.exs
+      defp aliases do
+        [
+          some_alias: ["hex.info", "run priv/hello1.exs", "cmd priv/world.sh"]
+        ]
+      end
+
+  In the example above we have created the alias `some_alias` that will
+  run the task `mix hex.info`, then `mix run` to run an Elixir script,
+  then `mix cmd` to execute a command line shell script. This shows how
+  powerful aliases mixed with Mix tasks can be.
+
+  One common pitfall of aliases comes when trying to invoke the same task
+  multiple times. Mix tasks are designed to run only once. This prevents
+  the same task from being executed multiple times. For example, if there
+  are several tasks depending on `mix compile`, the code will be compiled
+  only once.
+
+  Similarly, `mix format` can only be invoked once. So if you have an alias
+  that attempts to invoke `mix format` multiple times, it won't work unless
+  it is explicitly reenabled using `Mix.Task.reenable/1`:
+
+      another_alias: [
+        "format --check-formatted priv/hello1.exs",
+        "cmd priv/world.sh",
+        fn _ -> Mix.Task.reenable("format") end,
+        "format --check-formatted priv/hello2.exs"
+      ]
 
-  This module works as a facade for accessing the most common functionality
-  in Elixir, such as the shell and the current project configuration.
+  Some tasks are automatically reenabled though, as they are expected to
+  be invoked multiple times, such as: `mix cmd`, `mix do`, `mix xref`, etc.
 
-  For getting started with Elixir, checkout out the guide available on
-  [Elixir's website](http://elixir-lang.org).
+  Finally, aliases defined in the current project do not affect its
+  dependencies and aliases defined in dependencies are not accessible
+  from the current project, with the exception of umbrella projects.
+  Umbrella projects will run the aliases of its children when the
+  umbrella project itself does not define said alias and there is no
+  task with said name.
+
+  ## Environment variables
+
+  Several environment variables can be used to modify Mix's behavior.
+
+  Mix responds to the following variables:
+
+    * `MIX_ARCHIVES` - specifies the directory into which the archives should be installed
+      (default: `~/.mix/archives`)
+
+    * `MIX_BUILD_PATH` - sets the project `Mix.Project.build_path/0`, including the
+      current environment, such as "/path/to/project/_build/dev". This environment
+      variable is used mostly by external build tools who need enforce a build
+      directory independent of `MIX_ENV` and `MIX_TARGET`. For your CI servers,
+      you likely want to use `MIX_BUILD_ROOT` below.
+
+    * `MIX_BUILD_ROOT` - sets the root directory where build artifacts should be
+      written to. For example, "/path/to/_build". If `MIX_BUILD_PATH` is set,
+      this option is ignored.
+
+    * `MIX_DEBUG` - outputs debug information about each task before running it
+
+    * `MIX_DEPS_PATH` - sets the project `Mix.Project.deps_path/0` config for the
+      current project, as an absolute path, such as `/path/to/project/deps`
+
+    * `MIX_ENV` - specifies which environment should be used. See [Environments](#module-environments)
+
+    * `MIX_EXS` - changes the full path to the `mix.exs` file
+
+    * `MIX_HOME` - path to Mix's home directory, stores configuration files and scripts used by Mix
+      (default: `~/.mix`)
+
+    * `MIX_INSTALL_DIR` *(since v1.12.0)* - specifies directory where `Mix.install/2` keeps
+       install cache
+
+    * `MIX_OS_CONCURRENCY_LOCK` - when set to `0` or `false`, disables mix compilation locking.
+      While not recommended, this may be necessary in cases where hard links or TCP sockets are
+      not available. When opting for this behaviour, make sure to not start concurrent compilations
+      of the same project
+
+    * `MIX_OS_DEPS_COMPILE_PARTITION_COUNT` - when set to a number greater than 1, it enables
+      compilation of dependencies over multiple operating system processes. See `mix help deps.compile`
+      for more information
+
+    * `MIX_PATH` - appends extra code paths
+
+    * `MIX_PROFILE` - a list of comma-separated Mix tasks to profile the time spent on
+      functions by the process running the task, such as `MIX_PROFILE=compile,test`.
+      You can also set `MIX_PROFILE_FLAGS` to control the flags given to profiling,
+      see `mix profile.tprof` for all options. By default, it uses `--no-warmup`.
+
+    * `MIX_QUIET` - does not print information messages to the terminal
+
+    * `MIX_REBAR3` - path to rebar3 command that overrides the one Mix installs
+      (default: `~/.mix/rebar3`)
+
+    * `MIX_TARGET` - specifies which target should be used. See [Targets](#module-targets)
+
+    * `MIX_XDG` - asks Mix to follow the [XDG Directory Specification](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html)
+      for its home directory and configuration files. This behavior needs to
+      be opt-in due to backwards compatibility. `MIX_HOME` has higher preference
+      than `MIX_XDG`. If none of the variables are set, the default directory
+      `~/.mix` will be used
+
+  Environment variables that are not meant to hold a value (and act basically as
+  flags) should be set to either `1` or `true`, for example:
+
+      $ MIX_DEBUG=1 mix compile
+
+  ## SSL certificates
+
+  Mix and the Hex package manager use the default operating system certificates
+  when downloading resources. In certain situations, such as when running behind
+  proxies, you want to replace those certificates.
+
+  If you simply want to change the certificates used by Mix and Hex, you may set
+  the `HEX_CACERTS_PATH` environment variable, pointing to a CA certificate file.
+  See [`mix hex.config`](https://hexdocs.pm/hex/Mix.Tasks.Hex.Config.html#module-config-keys).
+
+  From Erlang/OTP 27.2, it is also possible to change the certificates for your
+  project as a whole. To do so, you might add the following to your `config/config.exs`:
+
+      config :public_key, :cacerts_path, "/path/to/certs.pem"
+
+  You can also do so by setting the `ERL_AFLAGS` and `ERL_ZFLAGS` environment variables:
+
+  ```bash
+  ERL_AFLAGS="-public_key cacerts_path '\"/path/to/certs.pem\"'"
+  ERL_ZFLAGS="-public_key cacerts_path '\"/path/to/certs.pem\"'"
+  ```
+
+  You can verify if the configuration has been properly set by calling the following
+  inside `iex -S mix`:
+
+      Application.load(:public_key)
+      Application.get_env(:public_key, :cacerts_path)
+
+  And by loading the certificates:
+
+      :public_key.cacerts_get()
+
+  """
+
+  @typedoc """
+  Options for `install/2`.
+
+  See the `install/2` function documentation for detailed information about each option.
   """
+  @type install_opts :: [
+          force: boolean(),
+          verbose: boolean(),
+          consolidate_protocols: boolean(),
+          elixir: String.t(),
+          system_env: Enum.t(),
+          config: keyword(),
+          config_path: String.t() | atom(),
+          lockfile: String.t() | atom(),
+          start_applications: boolean(),
+          compilers: [atom()],
+          runtime_config: keyword()
+        ]
+
+  @mix_install_project Mix.InstallProject
+  @mix_install_app :mix_install
+  @mix_install_app_string Atom.to_string(@mix_install_app)
 
   use Application
 
+  import Kernel, except: [raise: 2]
+
   @doc false
   def start do
-    Application.start(:elixir)
-    Application.start(:mix)
+    {:ok, _} = Application.ensure_all_started(:mix)
+    :ok
   end
 
-  @doc false
+  @impl true
   def start(_type, []) do
-    import Supervisor.Spec
-
-    children = [
-      worker(Mix.TasksServer, []),
-      worker(Mix.ProjectStack, [])
-    ]
-
-    opts = [strategy: :one_for_one, name: Mix.Supervisor]
-    stat = Supervisor.start_link(children, opts)
-
-    if env = System.get_env("MIX_ENV") do
-      env(String.to_atom env)
-    end
+    Mix.Local.append_archives()
+    Mix.Local.append_paths()
+    children = [Mix.Sync.PubSub, Mix.State, Mix.TasksServer, Mix.ProjectStack]
+    opts = [strategy: :one_for_one, name: Mix.Supervisor, max_restarts: 0]
+    Supervisor.start_link(children, opts)
+  end
 
-    stat
+  @impl true
+  def stop(_data) do
+    Mix.Local.remove_archives()
+    Mix.Local.remove_paths()
+    :ok
   end
 
   @doc """
-  Returns the mix environment.
+  Returns the current Mix environment.
+
+  This function should not be used at runtime in application code (as opposed
+  to infrastructure and build code like Mix tasks). Mix is a build tool and may
+  not be available after the code is compiled (for example in a release).
+
+  To differentiate the program behavior depending on the environment, it is
+  recommended to use application environment through `Application.get_env/3`.
+  Proper configuration can be set in config files, often per-environment
+  (see the `Config` module for more information).
   """
+  @spec env() :: atom()
   def env do
     # env is not available on bootstrapping, so set a :dev default
-    Application.get_env(:mix, :env, :dev)
+    Mix.State.get(:env, :dev)
   end
 
   @doc """
-  Changes the current mix env.
+  Changes the current Mix environment to `env`.
 
   Be careful when invoking this function as any project
   configuration won't be reloaded.
+
+  This function should not be used at runtime in application code
+  (see `env/0` for more information).
   """
+  @spec env(atom()) :: :ok
   def env(env) when is_atom(env) do
-    Application.put_env(:mix, :env, env)
+    Mix.State.put(:env, env)
+  end
+
+  @doc """
+  Returns the Mix target.
+  """
+  @spec target() :: atom()
+  def target do
+    # target is not available on bootstrapping, so set a :host default
+    Mix.State.get(:target, :host)
+  end
+
+  @doc """
+  Changes the current Mix target to `target`.
+
+  Be careful when invoking this function as any project
+  configuration won't be reloaded.
+  """
+  @spec target(atom()) :: :ok
+  def target(target) when is_atom(target) do
+    Mix.State.put(:target, target)
+  end
+
+  @doc """
+  Returns the default compilers used by Mix.
+
+  It can be used in your `mix.exs` to prepend or
+  append new compilers to Mix:
+
+      def project do
+        [compilers: Mix.compilers() ++ [:foo, :bar]]
+      end
+
+  """
+  @spec compilers() :: [atom()]
+  def compilers do
+    [:erlang, :elixir, :app]
   end
 
   @doc """
-  The shell is a wrapper for doing IO.
+  Returns the current shell.
+
+  `shell/0` can be used as a wrapper for the current shell. It contains
+  conveniences for requesting information from the user, printing to the
+  shell and so forth. The Mix shell is swappable (see `shell/1`), allowing
+  developers to use a test shell that simply sends messages to the current
+  process instead of performing IO (see `Mix.Shell.Process`).
+
+  By default, this returns `Mix.Shell.IO`.
+
+  ## Examples
+
+      Mix.shell().info("Preparing to do something dangerous...")
+
+      if Mix.shell().yes?("Are you sure?") do
+        # do something dangerous
+      end
 
-  It contains conveniences for asking the user information,
-  printing status and so forth. It is also swappable,
-  allowing developers to use a test shell that simply sends the
-  messages to the current process.
   """
+  @spec shell() :: module
   def shell do
-    Application.get_env(:mix, :shell, Mix.Shell.IO)
+    Mix.State.get(:shell, Mix.Shell.IO)
   end
 
   @doc """
   Sets the current shell.
+
+  As an argument you may pass `Mix.Shell.IO`, `Mix.Shell.Process`,
+  `Mix.Shell.Quiet`, or any module that implements the `Mix.Shell`
+  behaviour.
+
+  After calling this function, `shell` becomes the shell that is
+  returned by `shell/0`.
+
+  ## Examples
+
+      iex> Mix.shell(Mix.Shell.IO)
+      :ok
+
+  You can use `shell/0` and `shell/1` to temporarily switch shells,
+  for example, if you want to run a Mix Task that normally produces
+  a lot of output:
+
+      shell = Mix.shell()
+      Mix.shell(Mix.Shell.Quiet)
+
+      try do
+        Mix.Task.run("noisy.task")
+      after
+        Mix.shell(shell)
+      end
+
   """
+  @spec shell(module) :: :ok
   def shell(shell) do
-    Application.put_env(:mix, :shell, shell)
+    Mix.State.put(:shell, shell)
   end
 
   @doc """
-  Raises a mix error that is nicely formatted.
+  Returns `true` if Mix is in debug mode, `false` otherwise.
   """
-  def raise(message) when is_binary(message) do
-    Kernel.raise Mix.Error, mix: mix_info, message: message
+  @spec debug?() :: boolean()
+  def debug? do
+    Mix.State.get(:debug, false)
   end
 
   @doc """
-  Raises a mix compatible exception.
+  Sets Mix debug mode.
+  """
+  @spec debug(boolean()) :: :ok
+  def debug(debug) when is_boolean(debug) do
+    Mix.State.put(:debug, debug)
+  end
 
-  A mix compatible exception has a `mix_error` field which mix
-  uses to store the project or application name which is
-  automatically by the formatting tools.
+  @doc """
+  Raises a Mix error that is nicely formatted, defaulting to exit status `1`.
   """
-  def raise(exception, opts) when is_atom(exception) do
-    Kernel.raise %{exception.exception(opts) | mix: mix_info}
+  @spec raise(binary) :: no_return
+  def raise(message) do
+    __MODULE__.raise(message, exit_status: 1)
   end
 
-  defp mix_info do
-    case Mix.ProjectStack.peek do
-      %{name: name, config: config, pos: pos} when pos > 0 ->
-        if app = config[:app] do
-          {:app, app}
+  @doc """
+  Raises a Mix error that is nicely formatted.
+
+  ## Options
+
+    * `:exit_status` - defines exit status, defaults to `1`
+
+  """
+  @doc since: "1.12.3"
+  @spec raise(binary, exit_status: non_neg_integer()) :: no_return
+  def raise(message, opts) when is_binary(message) and is_list(opts) do
+    status =
+      opts[:exit_status] ||
+        if exit_code = opts[:exit_code] do
+          IO.warn(":exit_code is deprecated, use :exit_status instead")
+          exit_code
         else
-          {:project, name}
+          1
+        end
+
+    Kernel.raise(Mix.Error, mix: status, message: message)
+  end
+
+  @doc """
+  The path for local archives or escripts.
+  """
+  @doc since: "1.10.0"
+  @spec path_for(:archives | :escripts) :: String.t()
+  def path_for(:archives) do
+    System.get_env("MIX_ARCHIVES") || Path.join(Mix.Utils.mix_home(), "archives")
+  end
+
+  def path_for(:escripts) do
+    Path.join(Mix.Utils.mix_home(), "escripts")
+  end
+
+  @doc """
+  Ensures the given application from Erlang/OTP or Elixir and its dependencies
+  are available in the path.
+
+  Generally speaking, you should list the Erlang application dependencies under
+  the `:extra_applications` section of your `mix.exs`. This must only be used by
+  Mix tasks which wish to avoid depending on Erlang/Elixir for certain reasons.
+
+  This function does not start the given applications.
+  """
+  @doc since: "1.15.0"
+  def ensure_application!(app) when is_atom(app) do
+    ensure_application!(app, Mix.State.builtin_apps(), [], %{})
+    :ok
+  end
+
+  defp ensure_application!(app, builtin_apps, optional, seen) do
+    case seen do
+      %{^app => _} ->
+        seen
+
+      %{} ->
+        seen = Map.put(seen, app, true)
+
+        case builtin_apps do
+          %{^app => path} ->
+            Code.prepend_path(path, cache: true)
+            Application.load(app)
+
+            required = List.wrap(Application.spec(app, :applications))
+            optional = List.wrap(Application.spec(app, :optional_applications))
+
+            Enum.reduce(
+              required ++ optional,
+              seen,
+              &ensure_application!(&1, builtin_apps, optional, &2)
+            )
+
+          %{} ->
+            if app not in optional do
+              Mix.raise(
+                "The application \"#{app}\" could not be found. This may happen if your " <>
+                  "Operating System broke Erlang into multiple packages and may be fixed " <>
+                  "by installing the missing \"erlang-dev\" and \"erlang-#{app}\" packages"
+              )
+            end
+
+            seen
+        end
+    end
+  end
+
+  @doc """
+  Installs and starts dependencies.
+
+  The given `deps` should be in the same format as defined in a regular Mix
+  project. See `mix help deps` for more information. As a shortcut, an atom
+  can be given as dependency to mean the latest version. In other words,
+  specifying `:decimal` is the same as `{:decimal, ">= 0.0.0"}`.
+
+  After each successful installation, a given set of dependencies is cached
+  so starting another VM and calling `Mix.install/2` with the same dependencies
+  will avoid unnecessary downloads and compilations. The location of the cache
+  directory can be controlled using the `MIX_INSTALL_DIR` environment variable.
+
+  This function can only be called outside of a Mix project and only with the
+  same dependencies in the given VM.
+
+  ## Options
+
+    * `:config` *(since v1.13.0)* - a keyword list of keyword lists of compile-time
+      configuration. The configuration is part of the `Mix.install/2` cache, so
+      different configurations will lead to different apps. For this reason, you
+      want to minimize the amount of configuration set through this option.
+      Use `Application.put_all_env/2` for setting other runtime configuration.
+
+    * `:config_path` *(since v1.14.0)* - path to a configuration file. If a `runtime.exs`
+      file exists in the same directory as the given path, it is loaded too.
+
+    * `:consolidate_protocols` - if `true`, runs protocol consolidation (Default: `true`)
+
+    * `:elixir` - if set, ensures the current Elixir version matches the given
+      version requirement (Default: `nil`)
+
+    * `:force` - if `true`, runs with empty install cache. This is useful when you want
+      to update your dependencies or your install got into an inconsistent state.
+      To use this option, you can also set the `MIX_INSTALL_FORCE` environment variable.
+      (Default: `false`)
+
+    * `:lockfile` *(since v1.14.0)* - path to a lockfile to be used as a basis of
+      dependency resolution.
+
+    * `:start_applications` *(since v1.15.3)* - if `true`, ensures that installed app
+      and its dependencies are started after install (Default: `true`)
+
+    * `:stop_unused_applications` *(since v1.20.0)* - as part of the installation process,
+      Elixir may start Hex, SSL, and other applications. Those are automatically shutdown
+      after installation, but you can set this option to false so they remain running
+
+    * `:system_env` *(since v1.13.0)* - a list or a map of system environment variable
+      names with respective values as binaries. The system environment is made part
+      of the `Mix.install/2` cache, so different configurations will lead to different apps
+
+    * `:verbose` - if `true`, prints additional debugging information
+      (Default: `false`)
+
+  ## Examples
+
+  Installing `:decimal` and `:jason`:
+
+      Mix.install([
+        :decimal,
+        {:jason, "~> 1.0"}
+      ])
+
+  Installing `:nx` and `:exla`, and configuring the underlying applications
+  and environment variables:
+
+      Mix.install(
+        [:nx, :exla],
+        config: [
+          nx: [default_backend: EXLA]
+        ],
+        system_env: [
+          XLA_TARGET: "cuda111"
+        ]
+      )
+
+  Installing a Mix project as a path dependency along with its configuration
+  and deps:
+
+      # $ git clone https://github.com/hexpm/hexpm /tmp/hexpm
+      # $ cd /tmp/hexpm && mix setup
+
+      Mix.install(
+        [
+          {:hexpm, path: "/tmp/hexpm", env: :dev},
+        ],
+        config_path: "/tmp/hexpm/config/config.exs",
+        lockfile: "/tmp/hexpm/mix.lock"
+      )
+
+      Hexpm.Repo.query!("SELECT COUNT(1) from packages")
+      #=> ...
+
+  The example above can be simplified by passing the application
+  name as an atom for `:config_path` and `:lockfile`:
+
+      Mix.install(
+        [
+          {:hexpm, path: "/tmp/hexpm", env: :dev},
+        ],
+        config_path: :hexpm,
+        lockfile: :hexpm
+      )
+
+  ## Limitations
+
+  There is one limitation to `Mix.install/2`, which is actually an Elixir
+  behavior. If you are installing a dependency that defines a struct or
+  macro, you cannot use the struct or macro immediately after the install
+  call. For example, this won't work:
+
+      Mix.install([:decimal])
+      %Decimal{} = Decimal.new(42)
+
+  That's because Elixir first expands all structs and all macros, and then
+  it executes the code. This means that, by the time Elixir tries to expand
+  the `%Decimal{}` struct, the dependency has not been installed yet.
+
+  Luckily this has a straightforward solution, which is to move the code
+  inside a module:
+
+      Mix.install([:decimal])
+
+      defmodule Script do
+        def run do
+          %Decimal{} = Decimal.new(42)
+        end
+      end
+
+      Script.run()
+
+  The contents inside `defmodule` will only be expanded and executed
+  after `Mix.install/2` runs, which means that any struct, macros,
+  and imports will be correctly handled.
+
+  ## Environment variables
+
+  The `MIX_INSTALL_DIR` environment variable configures the directory that
+  caches all `Mix.install/2`. It defaults to the `mix/install` folder in the
+  default user cache of your operating system. You can use `install_project_dir/0`
+  to access the directory of an existing install (alongside other installs):
+
+      iex> Mix.install([])
+      iex> Mix.install_project_dir()
+
+  The `MIX_INSTALL_FORCE` is available since Elixir v1.13.0 and forces
+  `Mix.install/2` to discard any previously cached entry of the current install.
+
+  The `MIX_INSTALL_RESTORE_PROJECT_DIR` environment variable may be specified
+  since Elixir v1.16.2. It should point to a previous installation directory,
+  which can be obtained with `Mix.install_project_dir/0` (after calling `Mix.install/2`).
+  Using a restore dir may speed up the installation, since matching dependencies
+  do not need be refetched nor recompiled. This environment variable is ignored
+  if `:force` is enabled.
+  """
+  @doc since: "1.12.0"
+  @spec install(
+          [atom() | {atom(), String.t()} | {atom(), String.t(), keyword()} | {atom(), keyword()}],
+          install_opts()
+        ) :: :ok
+  def install(deps, opts \\ [])
+
+  def install(deps, opts) when is_list(deps) and is_list(opts) do
+    Mix.start()
+
+    if Mix.Project.get() do
+      Mix.raise("Mix.install/2 cannot be used inside a Mix project")
+    end
+
+    elixir_requirement = opts[:elixir]
+    elixir_version = System.version()
+
+    if !!elixir_requirement and not Version.match?(elixir_version, elixir_requirement) do
+      Mix.raise(
+        "Mix.install/2 declared it supports only Elixir #{elixir_requirement} " <>
+          "but you're running on Elixir #{elixir_version}"
+      )
+    end
+
+    deps =
+      Enum.map(deps, fn
+        dep when is_atom(dep) ->
+          {dep, ">= 0.0.0"}
+
+        {app, opts} when is_atom(app) and is_list(opts) ->
+          {app, maybe_expand_path_dep(opts)}
+
+        {app, requirement, opts} when is_atom(app) and is_binary(requirement) and is_list(opts) ->
+          {app, requirement, maybe_expand_path_dep(opts)}
+
+        other ->
+          other
+      end)
+
+    opts =
+      Keyword.validate!(opts,
+        config: [],
+        config_path: nil,
+        consolidate_protocols: true,
+        compilers: [:elixir],
+        elixir: nil,
+        force: false,
+        lockfile: nil,
+        runtime_config: [],
+        start_applications: true,
+        stop_unused_applications: true,
+        system_env: [],
+        verbose: false
+      )
+
+    config_path = expand_path(opts[:config_path], deps, :config_path, "config/config.exs")
+    config = Keyword.fetch!(opts, :config)
+    system_env = Keyword.fetch!(opts, :system_env)
+    consolidate_protocols? = Keyword.fetch!(opts, :consolidate_protocols)
+    start_applications? = Keyword.fetch!(opts, :start_applications)
+    compilers = Keyword.fetch!(opts, :compilers)
+
+    id =
+      {deps, config, system_env, consolidate_protocols?}
+      |> :erlang.term_to_binary()
+      |> :erlang.md5()
+      |> Base.url_encode64(padding: false)
+
+    force? = System.get_env("MIX_INSTALL_FORCE") in ["1", "true"] or Keyword.fetch!(opts, :force)
+
+    case Mix.State.get(:installed) do
+      nil ->
+        System.put_env(system_env)
+        install_project_dir = install_project_dir(id)
+
+        if Keyword.fetch!(opts, :verbose) do
+          Mix.shell().info("Mix.install/2 using #{install_project_dir}")
+        end
+
+        if force? do
+          File.rm_rf!(install_project_dir)
+        end
+
+        dynamic_config = [
+          deps: deps,
+          consolidate_protocols: consolidate_protocols?,
+          config_path: config_path,
+          compilers: compilers
+        ]
+
+        :ok =
+          Mix.ProjectStack.push(
+            @mix_install_project,
+            [compile_config: config] ++ install_project_config(dynamic_config),
+            "nofile"
+          )
+
+        started_apps = Application.started_applications()
+        build_dir = Path.join(install_project_dir, "_build")
+        external_lockfile = expand_path(opts[:lockfile], deps, :lockfile, "mix.lock")
+
+        try do
+          first_build? = not File.dir?(build_dir)
+
+          restore_dir = System.get_env("MIX_INSTALL_RESTORE_PROJECT_DIR")
+
+          if first_build? and restore_dir != nil and not force? do
+            File.cp_r(restore_dir, install_project_dir)
+            remove_dep(install_project_dir, @mix_install_app_string)
+          end
+
+          File.mkdir_p!(install_project_dir)
+
+          File.cd!(install_project_dir, fn ->
+            # This steps need to be mirror in mix deps.partition
+            Application.put_all_env(config, persistent: true)
+            Mix.Task.rerun("loadconfig")
+
+            cond do
+              external_lockfile ->
+                md5_path = Path.join(install_project_dir, "merge.lock.md5")
+
+                old_md5 =
+                  case File.read(md5_path) do
+                    {:ok, data} -> Base.decode64!(data)
+                    _ -> nil
+                  end
+
+                new_md5 = external_lockfile |> File.read!() |> :erlang.md5()
+
+                if old_md5 != new_md5 do
+                  lockfile = Path.join(install_project_dir, "mix.lock")
+                  old_lock = Mix.Dep.Lock.read(lockfile)
+                  new_lock = Mix.Dep.Lock.read(external_lockfile)
+                  Mix.Dep.Lock.write(Map.merge(old_lock, new_lock), file: lockfile)
+                  File.write!(md5_path, Base.encode64(new_md5))
+                  Mix.Task.rerun("deps.get")
+                end
+
+              first_build? ->
+                Mix.Task.rerun("deps.get")
+
+              true ->
+                # We already have a cache. If the user by any chance uninstalled Hex,
+                # we make sure it is installed back (which mix deps.get would do anyway)
+                Mix.Hex.ensure_installed?(true)
+                :ok
+            end
+
+            Mix.Task.rerun("deps.loadpaths")
+
+            # Hex and SSL can use a good amount of memory after the registry fetching,
+            # so we stop any app started during deps resolution.
+            if Keyword.fetch!(opts, :stop_unused_applications) do
+              stop_apps(Application.started_applications() -- started_apps)
+            end
+
+            Mix.Task.rerun("compile")
+
+            if config_path do
+              Mix.Task.rerun("app.config")
+            end
+          end)
+
+          if start_applications? do
+            for %{app: app, opts: opts} <- Mix.Dep.cached(),
+                Keyword.get(opts, :runtime, true) and Keyword.get(opts, :app, true) do
+              Application.ensure_all_started(app)
+            end
+          end
+
+          if restore_dir do
+            remove_leftover_deps(install_project_dir)
+          end
+
+          Mix.State.put(:installed, {id, dynamic_config})
+          :ok
+        after
+          Mix.ProjectStack.pop()
+          # Clear all tasks invoked during installation, since there
+          # is no reason to keep this in memory. Additionally this
+          # allows us to rerun tasks for the dependencies later on,
+          # such as recompilation
+          Mix.Task.clear()
         end
+
+      {^id, _dynamic_config} when not force? ->
+        :ok
+
       _ ->
-        :none
+        Mix.raise("Mix.install/2 can only be called with the same dependencies in the given VM")
+    end
+  end
+
+  defp expand_path(_path = nil, _deps, _key, _), do: nil
+  defp expand_path(path, _deps, _key, _) when is_binary(path), do: Path.expand(path)
+
+  defp expand_path(app_name, deps, key, relative_path) when is_atom(app_name) do
+    app_dir =
+      case List.keyfind(deps, app_name, 0) do
+        {_, _, opts} when is_list(opts) -> opts[:path]
+        {_, opts} when is_list(opts) -> opts[:path]
+        _ -> Mix.raise("unknown dependency #{inspect(app_name)} given to #{inspect(key)}")
+      end
+
+    if !app_dir do
+      Mix.raise("#{inspect(app_name)} given to #{inspect(key)} must be a path dependency")
+    end
+
+    Path.join(app_dir, relative_path)
+  end
+
+  defp remove_leftover_deps(install_project_dir) do
+    build_lib_dir = Path.join([install_project_dir, "_build", "dev", "lib"])
+
+    deps = File.ls!(build_lib_dir)
+
+    loaded_deps =
+      for {app, _description, _version} <- Application.loaded_applications(),
+          into: MapSet.new(),
+          do: Atom.to_string(app)
+
+    # We want to keep :mix_install, but it has no application
+    loaded_deps = MapSet.put(loaded_deps, @mix_install_app_string)
+
+    for dep <- deps, not MapSet.member?(loaded_deps, dep) do
+      remove_dep(install_project_dir, dep)
     end
   end
+
+  defp remove_dep(install_project_dir, dep) do
+    build_lib_dir = Path.join([install_project_dir, "_build", "dev", "lib"])
+    deps_dir = Path.join(install_project_dir, "deps")
+
+    build_path = Path.join(build_lib_dir, dep)
+    File.rm_rf(build_path)
+    dep_path = Path.join(deps_dir, dep)
+    File.rm_rf(dep_path)
+  end
+
+  defp install_project_dir(cache_id) do
+    install_root =
+      System.get_env("MIX_INSTALL_DIR") ||
+        Path.join(Mix.Utils.mix_cache(), "installs")
+
+    version = "ex-#{System.version()}-erl-#{:erlang.system_info(:version)}"
+    Path.join([install_root, version, cache_id])
+  end
+
+  defp install_project_config(dynamic_config) do
+    [
+      version: "1.0.0",
+      build_per_environment: true,
+      build_path: "_build",
+      lockfile: "mix.lock",
+      deps_path: "deps",
+      app: @mix_install_app,
+      erlc_paths: [],
+      elixirc_paths: [],
+      prune_code_paths: false
+    ] ++ dynamic_config
+  end
+
+  @doc false
+  def in_install_project(fun) do
+    case safe_get_installed() do
+      {id, dynamic_config} ->
+        config = install_project_config(dynamic_config)
+
+        install_project_dir = install_project_dir(id)
+
+        File.cd!(install_project_dir, fn ->
+          :ok = Mix.ProjectStack.push(@mix_install_project, config, "nofile")
+
+          try do
+            fun.()
+          after
+            Mix.ProjectStack.pop()
+          end
+        end)
+
+      nil ->
+        Mix.raise("trying to call Mix.in_install_project/1, but Mix.install/2 was never called")
+    end
+  end
+
+  @doc """
+  Returns the directory where the current `Mix.install/2` project
+  resides.
+  """
+  @doc since: "1.16.2"
+  @spec install_project_dir() :: Path.t() | nil
+  def install_project_dir() do
+    case safe_get_installed() do
+      {id, _dynamic_config} -> install_project_dir(id)
+      nil -> nil
+    end
+  end
+
+  @doc """
+  Returns whether `Mix.install/2` was called in the current node.
+  """
+  @doc since: "1.13.0"
+  @spec installed?() :: boolean()
+  def installed? do
+    safe_get_installed() != nil
+  end
+
+  defp safe_get_installed() do
+    if mix_started?() do
+      Mix.State.get(:installed)
+    end
+  end
+
+  defp mix_started?() do
+    Process.whereis(Mix.State) != nil
+  end
+
+  defp stop_apps([]), do: :ok
+
+  defp stop_apps(apps) do
+    :logger.add_primary_filter(:silence_app_exit, {&silence_app_exit/2, []})
+    Enum.each(apps, fn {app, _, _} -> Application.stop(app) end)
+    :logger.remove_primary_filter(:silence_app_exit)
+    :ok
+  end
+
+  defp silence_app_exit(
+         %{
+           msg:
+             {:report,
+              %{
+                label: {:application_controller, :exit},
+                report: [application: _, exited: :stopped] ++ _
+              }}
+         },
+         _extra
+       ) do
+    :stop
+  end
+
+  defp silence_app_exit(_message, _extra) do
+    :ignore
+  end
+
+  defp maybe_expand_path_dep(opts) do
+    if Keyword.has_key?(opts, :path) do
+      Keyword.update!(opts, :path, &Path.expand/1)
+    else
+      opts
+    end
+  end
+
+  @doc false
+  def install?, do: Mix.Project.get() == @mix_install_project
 end
diff --git a/lib/mix/lib/mix/app_loader.ex b/lib/mix/lib/mix/app_loader.ex
new file mode 100644
index 00000000000..c3543059452
--- /dev/null
+++ b/lib/mix/lib/mix/app_loader.ex
@@ -0,0 +1,160 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Mix.AppLoader do
+  @moduledoc false
+
+  @manifest_vsn 1
+  @manifest "compile.app_cache"
+
+  @doc """
+  Reads the app cache.
+  """
+  def read_cache(config \\ Mix.Project.config()) do
+    try do
+      manifest(config) |> File.read!() |> :erlang.binary_to_term()
+    rescue
+      _ -> []
+    else
+      {@manifest_vsn, app_to_modules} -> app_to_modules
+    end
+  end
+
+  @doc """
+  Writes to the cache.
+  """
+  def write_cache(manifest, contents) when is_map(contents) do
+    term = {@manifest_vsn, contents}
+    File.mkdir_p!(Path.dirname(manifest))
+    File.write!(manifest, :erlang.term_to_binary(term, [:compressed]))
+  end
+
+  @doc """
+  Returns the path to the cache only if it is stale.
+  """
+  def stale_cache(config \\ Mix.Project.config()) do
+    manifest = manifest(config)
+    modified = Mix.Utils.last_modified(manifest)
+
+    # We depend both on the lockfile via compile.lock (a build artifact) via
+    # `config_mtime` and `project_file`. Ideally we compare the `project_file`
+    # timestamp (a source artifact) against its old timestamp (instead of the
+    # manifest timestamp which is a build artifact), but at the moment there
+    # is no trivial place to store it.
+    if Mix.Utils.stale?([Mix.Project.config_mtime(), Mix.Project.project_file()], [modified]) do
+      manifest
+    else
+      List.first(
+        for %{app: app, scm: scm, opts: opts} <- Mix.Dep.cached(),
+            not scm.fetchable?(),
+            Mix.Utils.last_modified(Path.join([opts[:build], "ebin", "#{app}.app"])) >
+              modified do
+          manifest
+        end
+      )
+    end
+  end
+
+  defp manifest(config) do
+    Path.join(Mix.Project.manifest_path(config), @manifest)
+  end
+
+  @doc """
+  Reads the given app from path in an optimized format and returns its contents.
+  """
+  def read_app(app, app_path) do
+    case File.read(app_path) do
+      {:ok, bin} ->
+        with {:ok, tokens, _} <- :erl_scan.string(String.to_charlist(bin)),
+             {:ok, {:application, ^app, properties}} <- :erl_parse.parse_term(tokens) do
+          {:ok, properties}
+        else
+          _ -> :invalid
+        end
+
+      {:error, _} ->
+        :missing
+    end
+  end
+
+  @doc """
+  Loads the given app from path in an optimized format and returns its contents.
+  """
+  def load_app(app, app_path) do
+    with {:ok, properties} <- read_app(app, app_path) do
+      case :application.load({:application, app, properties}) do
+        :ok -> {:ok, properties}
+        {:error, {:already_loaded, _}} -> {:ok, properties}
+        {:error, _} -> :invalid
+      end
+    end
+  end
+
+  @doc """
+  Loads the given applications.
+  """
+  def load_apps(apps, deps, config, acc, fun) do
+    lib_path = to_charlist(Path.join(Mix.Project.build_path(config), "lib"))
+    deps_children = for dep <- deps, into: %{}, do: {dep.app, Enum.map(dep.deps, & &1.app)}
+    builtin_paths = Mix.State.builtin_apps()
+
+    (extra_apps(config) ++ apps)
+    |> traverse_apps(%{}, deps_children, builtin_paths, lib_path)
+    |> Enum.reduce(acc, fun)
+  end
+
+  defp extra_apps(config) do
+    case Keyword.get(config, :language, :elixir) do
+      :elixir -> [:ex_unit, :iex, :mix, :elixir]
+      :erlang -> [:compiler]
+    end
+  end
+
+  # We already processed this app, skip it.
+  defp traverse_apps([app | apps], seen, deps_children, builtin_paths, lib_path)
+       when is_map_key(seen, app) do
+    traverse_apps(apps, seen, deps_children, builtin_paths, lib_path)
+  end
+
+  # We haven't processed this app, emit it.
+  defp traverse_apps([app | apps], seen, deps_children, builtin_paths, lib_path) do
+    {ebin_path, dep_children} =
+      case deps_children do
+        %{^app => dep_children} -> {app_join(lib_path, app, ~c"/ebin"), dep_children}
+        _ -> {builtin_paths[app], []}
+      end
+
+    app_children =
+      if Application.spec(app, :vsn) do
+        app_children(app)
+      else
+        with true <- ebin_path != nil,
+             {:ok, _} <- load_app(app, app_join(ebin_path, app, ~c".app")) do
+          app_children(app)
+        else
+          # Optional applications won't be available
+          _ -> []
+        end
+      end
+
+    children = (dep_children -- app_children) ++ app_children
+    seen = Map.put(seen, app, true)
+    apps = children ++ apps
+    [{app, ebin_path} | traverse_apps(apps, seen, deps_children, builtin_paths, lib_path)]
+  end
+
+  # We have processed all apps.
+  defp traverse_apps([], seen, _deps_children, builtin_paths, _lib_path) do
+    # We want to keep erts in the load path but it doesn't require to be loaded.
+    case builtin_paths do
+      %{erts: path} when not is_map_key(seen, :erts) -> [{:erts, path}]
+      %{} -> []
+    end
+  end
+
+  defp app_children(app) do
+    Application.spec(app, :applications) ++ Application.spec(app, :included_applications)
+  end
+
+  defp app_join(path, app, suffix), do: path ++ ~c"/" ++ Atom.to_charlist(app) ++ suffix
+end
diff --git a/lib/mix/lib/mix/archive.ex b/lib/mix/lib/mix/archive.ex
deleted file mode 100644
index fa2c751f80d..00000000000
--- a/lib/mix/lib/mix/archive.ex
+++ /dev/null
@@ -1,86 +0,0 @@
-defmodule Mix.Archive do
-  @moduledoc """
-  Module responsible for managing [archives](http://www.erlang.org/doc/man/code.html).
-
-  An archive is a zip file containing the app and beam files.
-  A valid archive must be named with the name of the application and
-  it should contain the relative paths beginning with the application
-  name, e.g. the root of the zip file should be `my_app/ebin/Elixir.My.App.beam`.
-  """
-
-  @doc """
-  Returns the archive name based on `app` and `version`.
-
-  ## Examples
-
-      iex> Mix.Archive.name("foo", nil)
-      "foo.ez"
-
-      iex> Mix.Archive.name("foo", "0.1.0")
-      "foo-0.1.0.ez"
-
-  """
-  def name(app, nil), do: "#{app}.ez"
-  def name(app, vsn), do: "#{app}-#{vsn}.ez"
-
-  @doc """
-  Returns the archive internal directory from its `path`.
-
-  ## Examples
-
-      iex> Mix.Archive.dir("foo/bar/baz-0.1.0.ez")
-      "baz-0.1.0"
-
-  """
-  def dir(path) do
-    path |> Path.basename |> Path.rootname
-  end
-
-  @doc """
-  Returns the ebin directory inside the given archive path.
-
-  ## Examples
-
-      iex> Mix.Archive.ebin("foo/bar/baz-0.1.0.ez")
-      "foo/bar/baz-0.1.0.ez/baz-0.1.0/ebin"
-
-  """
-  def ebin(path) do
-    dir = dir(path)
-    Path.join [path, dir, "ebin"]
-  end
-
-  @doc """
-  Creates an application archive.
-
-  It receives the archive file in the format
-  `path/to/archive/app-vsn.ez` and the path to the root of
-  the project to be archived. Everything in the `ebin` and
-  `priv` directories is archived. Dependencies are not
-  archived.
-  """
-  def create(source, target) do
-    source_path = Path.expand(source)
-    target_path = Path.expand(target)
-    dir = dir(target_path) |> String.to_char_list
-    {:ok, _} = :zip.create(String.to_char_list(target_path),
-                  files_to_add(source_path, dir),
-                  uncompress: ['.beam', '.app'])
-  end
-
-  defp files_to_add(path, dir) do
-    File.cd! path, fn ->
-      ebin = Path.wildcard("ebin/*.{beam,app}")
-      priv = Path.wildcard("priv/**/*")
-
-      Enum.reduce ebin ++ priv, [], fn(f, acc) ->
-        case File.read(f) do
-          {:ok, bin} ->
-            [{Path.join(dir, f) |> String.to_char_list, bin}|acc]
-          {:error, _} ->
-            acc
-        end
-      end
-    end
-  end
-end
diff --git a/lib/mix/lib/mix/cli.ex b/lib/mix/lib/mix/cli.ex
index 4fd0484d0db..d1b60b4aadd 100644
--- a/lib/mix/lib/mix/cli.ex
+++ b/lib/mix/lib/mix/cli.ex
@@ -1,125 +1,295 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.CLI do
   @moduledoc false
 
   @doc """
   Runs Mix according to the command line arguments.
   """
-  def main(args \\ System.argv) do
-    Mix.Local.append_archives
-    Mix.Local.append_paths
+  def main(args \\ System.argv(), mix_exs \\ System.get_env("MIX_EXS") || "mix.exs") do
+    if env_variable_activated?("MIX_DEBUG") do
+      IO.puts("-> Running mix CLI")
+      {time, res} = :timer.tc(&main/3, [args, mix_exs, true])
+      IO.puts(["<- Ran mix CLI in ", Integer.to_string(div(time, 1000)), "ms"])
+      res
+    else
+      main(args, mix_exs, false)
+    end
+  end
+
+  defp main(args, mix_exs, debug?) do
+    Mix.start()
+
+    if debug?, do: Mix.debug(true)
+    if env_variable_activated?("MIX_QUIET"), do: Mix.shell(Mix.Shell.Quiet)
+
+    if profile = System.get_env("MIX_PROFILE") do
+      flags = System.get_env("MIX_PROFILE_FLAGS", "")
+      {opts, args} = Mix.Tasks.Profile.Tprof.parse!(OptionParser.split(flags))
+
+      if args != [] do
+        Mix.raise("Invalid arguments given to MIX_PROFILE_FLAGS: #{inspect(args)}")
+      end
+
+      opts = Keyword.put_new(opts, :warmup, false)
+      Mix.State.put(:profile, {opts, String.split(profile, ",")})
+    end
 
     case check_for_shortcuts(args) do
       :help ->
-        proceed(["help"])
+        Mix.shell().info("Mix is a build tool for Elixir")
+        display_usage()
+
       :version ->
         display_version()
+
       nil ->
-        proceed(args)
+        proceed(args, mix_exs)
     end
   end
 
-  defp proceed(args) do
-    Mix.Tasks.Local.Hex.maybe_update()
+  defp proceed(args, mix_exs) do
     load_dot_config()
-    args = load_mixfile(args)
-    {task, args} = get_task(args)
-    change_env(task)
+    load_mix_exs(args, mix_exs)
+    project = Mix.Project.get()
+    {task, args} = get_task(args, project)
+    ensure_hex(task)
+    maybe_change_env_and_target(task, project)
     run_task(task, args)
   end
 
-  defp load_mixfile(args) do
-    file = System.get_env("MIX_EXS") || "mix.exs"
-    if File.regular?(file) do
-      Code.load_file(file)
+  defp load_mix_exs(args, mix_exs) do
+    if is_binary(mix_exs) and File.regular?(mix_exs) do
+      Mix.ProjectStack.post_config(state_loader: {:cli, List.first(args)})
+      old_undefined = Code.get_compiler_option(:no_warn_undefined)
+      Code.put_compiler_option(:no_warn_undefined, :all)
+      Code.compile_file(mix_exs)
+      Code.put_compiler_option(:no_warn_undefined, old_undefined)
     end
-    args
   end
 
-  defp get_task(["-" <> _|_]) do
-    Mix.shell.error "** (Mix) Cannot implicitly pass flags to default mix task, " <>
-                    "please invoke instead: mix #{Mix.Project.config[:default_task]}"
-    exit(1)
+  defp get_task(["-" <> _ | _], project) do
+    task = "mix #{default_task(project)}"
+
+    Mix.shell().error(
+      "** (Mix) Mix only recognizes the options --help and --version.\n" <>
+        "You may have wanted to invoke a task instead, such as #{inspect(task)}"
+    )
+
+    display_usage()
+    exit({:shutdown, 1})
   end
 
-  defp get_task([h|t]) do
+  defp get_task([h | t], _project) do
     {h, t}
   end
 
-  defp get_task([]) do
-    {Mix.Project.config[:default_task], []}
+  defp get_task([], nil) do
+    Mix.shell().error(
+      "** (Mix) \"mix\" with no arguments must be executed in a directory with a mix.exs file"
+    )
+
+    display_usage()
+    exit({:shutdown, 1})
+  end
+
+  defp get_task([], project) do
+    {default_task(project), []}
+  end
+
+  defp default_task(project) do
+    cond do
+      function_exported?(project, :cli, 0) ->
+        project.cli()[:default_task] || "run"
+
+      default_task = Mix.Project.config()[:default_task] ->
+        IO.warn("""
+        setting :default_task in your mix.exs \"def project\" is deprecated, set it inside \"def cli\" instead:
+
+            def cli do
+              [default_task: #{inspect(default_task)}]
+            end
+        """)
+
+        default_task
+
+      true ->
+        "run"
+    end
   end
 
   defp run_task(name, args) do
     try do
-      if Mix.Project.get do
-        Mix.Task.run "loadconfig"
-        Mix.Task.run "deps.loadpaths", ["--no-deps-check"]
-        Mix.Task.run "loadpaths", ["--no-elixir-version-check"]
-        Mix.Task.reenable "deps.loadpaths"
-        Mix.Task.reenable "loadpaths"
-      end
-
-      # If the task is not available, let's try to
-      # compile the repository and then run it again.
-      cond do
-        Mix.Task.get(name) ->
-          Mix.Task.run(name, args)
-        Mix.Project.get ->
-          Mix.Task.run("compile")
-          Mix.Task.run(name, args)
-        true ->
-          # Raise no task error
-          Mix.Task.get!(name)
-      end
+      ensure_no_slashes(name)
+      # We must go through the task instead of invoking the
+      # module directly because projects like Nerves alias it.
+      Mix.Task.run("loadconfig")
+      Mix.Task.run(name, args)
     rescue
-      # We only rescue exceptions in the mix namespace, all
-      # others pass through and will explode on the users face
+      # We only rescue exceptions in the Mix namespace,
+      # all others pass through and raise as usual.
       exception ->
-        stacktrace = System.stacktrace
+        case {Mix.debug?(), Map.get(exception, :mix, false)} do
+          {false, true} ->
+            simplified_exception(exception, 1)
 
-        if info = Map.get(exception, :mix) do
-          mod = exception.__struct__ |> Module.split() |> Enum.at(0, "Mix")
-          Mix.shell.error "** (#{mod})#{show_mix_info(info)} #{Exception.message(exception)}"
-        else
-          reraise exception, stacktrace
+          {false, code} when code in 0..255 ->
+            simplified_exception(exception, code)
+
+          _ ->
+            reraise exception, __STACKTRACE__
         end
+    end
+  end
+
+  defp simplified_exception(%name{} = exception, code) do
+    mod = name |> Module.split() |> hd()
+    Mix.shell().error("** (#{mod}) #{Exception.message(exception)}")
+    exit({:shutdown, code})
+  end
+
+  defp env_variable_activated?(name) do
+    System.get_env(name) in ~w(1 true)
+  end
+
+  defp ensure_hex("local.hex"), do: :ok
+  defp ensure_hex(_task), do: Mix.Hex.ensure_updated?()
 
-        exit(1)
+  defp ensure_no_slashes(task) do
+    if String.contains?(task, "/") do
+      raise Mix.NoTaskError, task: task
     end
   end
 
-  defp show_mix_info({:project, proj}), do: " [#{inspect proj}]"
-  defp show_mix_info({:app, app}),      do: " [#{app}]"
-  defp show_mix_info(:none),            do: ""
+  defp maybe_change_env_and_target(task, project) do
+    task = String.to_atom(task)
+    config = Mix.Project.config()
 
-  defp change_env(task) do
-    if nil?(System.get_env("MIX_ENV")) &&
-       (env = Mix.Project.config[:preferred_cli_env][task]) do
-      Mix.env(env)
-      if project = Mix.Project.pop do
-        %{name: name, file: file} = project
-        Mix.Project.push name, file
+    env = preferred_cli_env(project, task, config)
+    target = preferred_cli_target(project, task, config)
+    env && Mix.env(env)
+    target && Mix.target(target)
+
+    if env || target do
+      reload_project()
+    end
+  end
+
+  defp preferred_cli_env(project, task, config) do
+    if function_exported?(project, :cli, 0) || System.get_env("MIX_ENV") do
+      nil
+    else
+      value = config[:preferred_cli_env]
+
+      if value do
+        IO.warn("""
+        setting :preferred_cli_env in your mix.exs \"def project\" is deprecated, set it inside \"def cli\" instead:
+
+            def cli do
+              [preferred_envs: #{inspect(value)}]
+            end
+        """)
+      end
+
+      value[task] || preferred_cli_env(task)
+    end
+  end
+
+  defp preferred_cli_target(project, task, config) do
+    if function_exported?(project, :cli, 0) || System.get_env("MIX_TARGET") do
+      nil
+    else
+      value = config[:preferred_cli_target]
+
+      if value do
+        IO.warn("""
+        setting :preferred_cli_target in your mix.exs \"def project\" is deprecated, set it inside \"def cli\" instead:
+
+            def cli do
+              [preferred_targets: #{inspect(value)}]
+            end
+        """)
       end
+
+      value[task]
+    end
+  end
+
+  @doc """
+  Available for backwards compatibility.
+  """
+  def preferred_cli_env(task) when is_atom(task) or is_binary(task) do
+    case Mix.Task.get(task) do
+      nil ->
+        nil
+
+      module ->
+        case List.keyfind(module.__info__(:attributes), :preferred_cli_env, 0) do
+          {:preferred_cli_env, [setting]} ->
+            IO.warn(
+              """
+              setting @preferred_cli_env is deprecated inside Mix tasks.
+              Please remove it from #{inspect(module)} and set your preferred environment in mix.exs instead:
+
+                  def cli do
+                    [
+                      preferred_envs: [docs: "docs"]
+                    ]
+                  end
+              """,
+              []
+            )
+
+            setting
+
+          _ ->
+            nil
+        end
+    end
+  end
+
+  defp reload_project() do
+    if project = Mix.Project.pop() do
+      %{name: name, file: file} = project
+      Mix.Project.push(name, file)
     end
   end
 
   defp load_dot_config do
-    path = Path.join(Mix.Utils.mix_home, "config.exs")
+    path = Path.join(Mix.Utils.mix_config(), "config.exs")
+
     if File.regular?(path) do
-      Mix.Task.run "loadconfig", [path]
+      Mix.Tasks.Loadconfig.load_compile(path)
     end
   end
 
-  defp display_version() do
-    IO.puts "Elixir #{System.version}"
+  defp display_version do
+    IO.puts(:erlang.system_info(:system_version))
+    IO.puts("Mix " <> System.build_info()[:build])
+  end
+
+  defp display_usage do
+    Mix.shell().info("""
+
+    Usage: mix [task]
+
+    Examples:
+
+        mix             - Invokes the default task (mix run) in a project
+        mix new PATH    - Creates a new Elixir project at the given path
+        mix help        - Lists all available tasks
+        mix help TASK   - Prints documentation for a given task
+
+    The --help and --version options can be given instead of a task for usage and versioning information.
+    """)
   end
 
   # Check for --help or --version in the args
-  defp check_for_shortcuts([first_arg|_]) when first_arg in
-      ["--help", "-h", "-help"], do: :help
+  defp check_for_shortcuts([arg]) when arg in ["--help", "-h"], do: :help
 
-  defp check_for_shortcuts([first_arg|_]) when first_arg in
-      ["--version", "-v"], do: :version
+  defp check_for_shortcuts([arg]) when arg in ["--version", "-v"], do: :version
 
   defp check_for_shortcuts(_), do: nil
 end
diff --git a/lib/mix/lib/mix/compilers/elixir.ex b/lib/mix/lib/mix/compilers/elixir.ex
index f85ae9cc786..8a25b7aa647 100644
--- a/lib/mix/lib/mix/compilers/elixir.ex
+++ b/lib/mix/lib/mix/compilers/elixir.ex
@@ -1,202 +1,1407 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Compilers.Elixir do
   @moduledoc false
 
+  @manifest_vsn 29
+  @checkpoint_vsn 4
+
+  import Record
+
+  defrecord :module, [:kind, :sources, :export, :recompile?, :timestamp]
+
+  defrecord :source,
+    size: 0,
+    mtime: 0,
+    digest: nil,
+    compile_references: [],
+    export_references: [],
+    runtime_references: [],
+    compile_env: [],
+    external: [],
+    compile_warnings: [],
+    runtime_warnings: [],
+    modules: []
+
   @doc """
   Compiles stale Elixir files.
 
-  It expects a manifest file, the source directories, the extensions
-  to read in sources, the destination directory, a flag to know if
-  compilation is being forced or not and a callback to be invoked
-  once (and only if) compilation starts.
+  It expects a `manifest` file, the source directories, the destination
+  directory, the cache key based on compiler configuration, external
+  manifests, and external modules, followed by opts.
 
-  The manifest is written down with information including dependencies
-  in between modules, which helps it recompile only the modules that
+  The `manifest` is written down with information including dependencies
+  between modules, which helps it recompile only the modules that
   have changed at runtime.
   """
-  def compile(manifest, srcs, exts, dest, force, on_start) do
-    all = Mix.Utils.extract_files(srcs, exts)
-    all_entries = read_manifest(manifest)
+  def compile(manifest, srcs, dest, new_cache_key, new_parent_manifests, new_parents, opts) do
+    Mix.ensure_application!(:crypto)
+    modified = Mix.Utils.last_modified(manifest)
+    config_mtime = Mix.Project.config_mtime()
+    project_mtime = Mix.Utils.last_modified(Mix.Project.project_file())
+    new_parents = :ordsets.from_list(new_parents)
 
-    removed =
-      for {_b, _m, source, _d, _f} <- all_entries, not(source in all), do: source
+    # We fetch the time from before we read files so any future
+    # change to files are still picked up by the compiler. This
+    # timestamp is used when writing BEAM files and the manifest.
+    timestamp = System.os_time(:second)
+    all_paths = Mix.Utils.extract_files(srcs, [:ex])
 
-    changed =
-      if force do
-        # A config, path dependency or manifest has
-        # changed, let's just compile everything
-        all
+    {all_modules, all_sources, all_local_exports, old_parents, old_cache_key, old_cwd,
+     old_deps_config, old_project_mtime, old_config_mtime, old_protocols_and_impls} =
+      parse_manifest(manifest, dest)
+
+    # In case we aborted in the middle of a verification,
+    # we need to delete all modules that we wrote to disk.
+    # In the future, we may want to make it so we only run
+    # the verification again.
+    with {:ok, modules} <- parse_checkpoint(:verify, manifest) do
+      for module <- modules do
+        File.rm(Path.join(dest, Atom.to_string(module) <> ".beam"))
+      end
+    end
+
+    # Prepend ourselves early because of __mix_recompile__? checks
+    # and also that, in case of nothing compiled, we already need
+    # ourselves available in the path.
+    File.mkdir_p!(dest)
+    Code.prepend_path(dest)
+
+    # If modules have been added or removed from the Erlang compiler,
+    # we need to recompile all references to old and new modules.
+    stale =
+      if old_parents != new_parents or
+           Mix.Utils.stale?(new_parent_manifests, [modified]) do
+        :ordsets.union(old_parents, new_parents)
+      else
+        []
+      end
+
+    local_deps = Enum.reject(Mix.Dep.cached(), & &1.scm.fetchable?())
+
+    # If mix.exs has changed, recompile anything that calls Mix.Project.
+    stale =
+      if project_mtime > old_project_mtime,
+        do: [Mix.Project | stale],
+        else: stale
+
+    # If the lock has changed or a local dependency was added or removed,
+    # we need to traverse lock/config files.
+    deps_changed? =
+      config_mtime > old_config_mtime or
+        local_deps_changed?(old_deps_config, local_deps)
+
+    # If a configuration is only accessed at compile-time, we don't need to
+    # track modules, only the compile env. So far this is only true for Elixir's
+    # dbg callback.
+    compile_env_apps = deps_config_compile_env_apps(old_deps_config)
+
+    {force?, stale, new_deps_config} =
+      cond do
+        !!opts[:force] or is_nil(old_deps_config) or old_cache_key != new_cache_key or
+            (Keyword.get(opts, :check_cwd, true) and old_cwd != File.cwd!()) ->
+          {true, stale, deps_config(local_deps)}
+
+        deps_changed? or compile_env_apps != [] ->
+          new_deps_config = deps_config(local_deps)
+          local_apps = merge_appset(old_deps_config.local, new_deps_config.local, [])
+          config_apps = merge_appset(old_deps_config.config, new_deps_config.config, local_apps)
+          apps = merge_appset(old_deps_config.lock, new_deps_config.lock, config_apps)
+
+          if Mix.Project.config()[:app] in apps do
+            {true, stale, new_deps_config}
+          else
+            app_modules = Mix.AppLoader.read_cache()
+
+            apps_stale =
+              apps
+              |> deps_on()
+              |> Enum.flat_map(fn {app, _} ->
+                new_modules = Application.spec(app, :modules) || []
+
+                if old_modules = app_modules[app] do
+                  :ordsets.union(old_modules, :ordsets.from_list(new_modules))
+                else
+                  new_modules
+                end
+              end)
+
+            compile_env_apps = compile_env_apps ++ config_apps
+
+            compile_env_stale =
+              for {_, source(compile_env: compile_env, modules: modules)} <- all_sources,
+                  Enum.any?(compile_env_apps, &List.keymember?(compile_env, &1, 0)),
+                  module <- modules,
+                  do: module
+
+            stale = (stale ++ compile_env_stale) ++ apps_stale
+            {false, stale, new_deps_config}
+          end
+
+        true ->
+          {false, stale, old_deps_config}
+      end
+
+    {stale_modules, stale_exports, all_local_exports, protocols_and_impls} =
+      stale_local_deps(local_deps, manifest, stale, modified, all_local_exports)
+
+    prev_paths = Map.keys(all_sources)
+    removed = prev_paths -- all_paths
+    {sources, removed_modules} = remove_removed_sources(all_sources, removed)
+
+    {modules, exports, changed, sources_stats} =
+      if force? do
+        compiler_info_from_force(manifest, all_paths, all_modules, dest)
       else
-        modified = Mix.Utils.last_modified(manifest)
-
-        # Otherwise let's start with the new ones
-        # plus the ones that have changed
-        for(source <- all,
-            not Enum.any?(all_entries, fn {_b, _m, s, _d, _f} -> s == source end),
-            do: source)
-          ++
-        for({_b, _m, source, _d, files} <- all_entries,
-            Mix.Utils.stale?([source|files], [modified]),
-            do: source)
+        compiler_info_from_updated(
+          manifest,
+          all_paths -- prev_paths,
+          all_modules,
+          all_sources,
+          removed,
+          Map.merge(stale_modules, removed_modules),
+          Map.merge(stale_exports, removed_modules),
+          dest,
+          timestamp
+        )
       end
 
-    {entries, changed} = remove_stale_entries(all_entries, removed ++ changed, [], [])
     stale = changed -- removed
 
-    cond do
-      stale != [] ->
-        do_compile(manifest, entries, stale, dest, on_start)
-        :ok
-      removed != [] ->
-        :ok
-      true ->
-        :noop
+    {sources, stale_exports} =
+      update_stale_sources(sources, stale, removed_modules, sources_stats)
+
+    consolidation_status =
+      if Mix.Project.umbrella?() do
+        :off
+      else
+        Mix.Compilers.Protocol.status(config_mtime > old_config_mtime, opts)
+      end
+
+    if stale != [] or stale_modules != %{} or removed != [] or deps_changed? or
+         consolidation_status == :force do
+      path = opts[:purge_consolidation_path_if_stale]
+
+      if is_binary(path) and Code.delete_path(path) do
+        purge_modules_in_path(path)
+      end
+
+      if stale != [] do
+        Mix.Utils.compiling_n(length(stale), :ex)
+      end
+
+      Mix.Project.ensure_structure()
+      previous_opts = set_compiler_opts(opts)
+
+      try do
+        consolidation = {consolidation_status, old_protocols_and_impls, protocols_and_impls}
+
+        state = %{
+          modules: %{},
+          exports: exports,
+          sources: sources,
+          changed: [],
+          pending_modules: modules,
+          stale_exports: stale_exports,
+          consolidation: consolidation
+        }
+
+        compiler_loop(manifest, stale, stale_modules, dest, timestamp, opts, state)
+      else
+        {:ok, %{runtime_warnings: runtime_warnings, compile_warnings: compile_warnings}, state} ->
+          %{
+            modules: modules,
+            sources: sources,
+            pending_modules: pending_modules,
+            consolidation: protocols_and_impls
+          } = state
+
+          previous_warnings =
+            if Keyword.get(opts, :all_warnings, true),
+              do: previous_warnings(sources, true),
+              else: []
+
+          runtime_warnings = Enum.map(runtime_warnings, &diagnostic/1)
+          compile_warnings = Enum.map(compile_warnings, &diagnostic/1)
+          sources = apply_warnings(sources, runtime_warnings, compile_warnings)
+
+          write_manifest(
+            manifest,
+            Map.merge(modules, pending_modules),
+            sources,
+            all_local_exports,
+            new_parents,
+            new_cache_key,
+            new_deps_config,
+            project_mtime,
+            config_mtime,
+            protocols_and_impls,
+            timestamp
+          )
+
+          put_compile_env(sources)
+          all_warnings = previous_warnings ++ runtime_warnings ++ compile_warnings
+
+          lazy_modules_diff = fn ->
+            modules_diff(modules, removed_modules, all_modules, timestamp)
+          end
+
+          Mix.Task.Compiler.notify_modules_compiled(lazy_modules_diff)
+          unless_warnings_as_errors(opts, {:ok, all_warnings})
+
+        {:error, errors, %{runtime_warnings: r_warnings, compile_warnings: c_warnings}, state} ->
+          {errors, warnings} =
+            if opts[:warnings_as_errors],
+              do: {errors ++ r_warnings ++ c_warnings, []},
+              else: {errors, r_warnings ++ c_warnings}
+
+          # In case of errors, we show all previous warnings and all new ones.
+          errors = Enum.map(errors, &diagnostic/1)
+          warnings = Enum.map(warnings, &diagnostic/1)
+          all_warnings = Keyword.get(opts, :all_warnings, errors == [])
+          {:error, previous_warnings(state.sources, all_warnings) ++ warnings ++ errors}
+      after
+        Code.compiler_options(previous_opts)
+      end
+    else
+      all_warnings = Keyword.get(opts, :all_warnings, true)
+      previous_warnings = previous_warnings(sources, all_warnings)
+      unless_warnings_as_errors(opts, {:noop, previous_warnings})
+    end
+  end
+
+  defp deps_config(local_deps) do
+    # If you change this config, you need to bump @manifest_vsn
+    %{
+      local: Enum.sort(Enum.map(local_deps, &{&1.app, true})),
+      lock: Enum.sort(Mix.Dep.Lock.read()),
+      config: Enum.sort(Mix.Tasks.Loadconfig.read_compile()),
+      dbg: Application.fetch_env!(:elixir, :dbg_callback)
+    }
+  end
+
+  defp local_deps_changed?(deps_config, local_deps) do
+    is_map(deps_config) and Enum.sort(Enum.map(local_deps, &{&1.app, true})) != deps_config.local
+  end
+
+  defp deps_config_compile_env_apps(deps_config) do
+    if deps_config[:dbg] != Application.fetch_env!(:elixir, :dbg_callback) do
+      [:elixir]
+    else
+      []
     end
   end
 
   @doc """
-  Removes compiled files.
+  Removes compiled files for the given `manifest`.
   """
-  def clean(manifest) do
-    case File.read(manifest) do
-      {:ok, contents} ->
-        contents
-        |> String.split("\n")
-        |> Enum.each &(&1 |> String.split("\t") |> hd |> File.rm)
-        File.rm(manifest)
-      {:error, _} ->
-        :ok
-    end
-  end
-
-  defp do_compile(manifest, entries, stale, dest, on_start) do
-    Mix.Project.build_structure
-    on_start.()
-    cwd = File.cwd!
-
-    # Starts a server responsible for keeping track which files
-    # were compiled and the dependencies in between them.
-    {:ok, pid} = Agent.start_link(fn ->
-      Enum.map(entries, &Tuple.insert_at(&1, 5, nil))
+  def clean(manifest, compile_path) do
+    {modules, _} = read_manifest(manifest)
+    _ = File.rm(manifest)
+
+    Enum.each(modules, fn {module, _} ->
+      File.rm(beam_path(compile_path, module))
     end)
+  end
 
+  @doc """
+  Reads the manifest for external consumption.
+  """
+  def read_manifest(manifest) do
     try do
-      Kernel.ParallelCompiler.files :lists.usort(stale),
-        each_module: &each_module(pid, dest, cwd, &1, &2, &3),
-        each_file: &each_file(&1)
-      Agent.cast pid, fn entries ->
-        write_manifest(manifest, entries)
-        entries
+      manifest |> File.read!() |> :erlang.binary_to_term()
+    rescue
+      _ -> {[], []}
+    else
+      {@manifest_vsn, modules, sources, _, _, _, _, _, _, _, _} -> {modules, sources}
+      _ -> {[], []}
+    end
+  end
+
+  @doc """
+  Retrieves all diagnostics from the given manifest.
+  """
+  def diagnostics(manifest) do
+    {_, sources} = read_manifest(manifest)
+    previous_warnings(sources, false)
+  end
+
+  defp compiler_info_from_force(manifest, all_paths, all_modules, dest) do
+    # A config, path dependency or manifest has changed, let's just compile everything
+    for {module, _} <- all_modules,
+        do: remove_and_purge(beam_path(dest, module), module)
+
+    sources_stats =
+      for path <- all_paths,
+          into: %{},
+          do: {path, Mix.Utils.last_modified_and_size(path)}
+
+    # Now that we have deleted all beams, remember to remove the manifest.
+    # This is important in case mix compile --force fails, otherwise we
+    # would have an outdated manifest.
+    File.rm(manifest)
+
+    {%{}, %{}, all_paths, sources_stats}
+  end
+
+  # If the user does a change, compilation fails, and then they revert
+  # the change, the mtime will have changed but the .beam files will
+  # be missing and the digest is the same, so we need to check if .beam
+  # files are available. Checking the first .beam file is enough, as
+  # they would be all removed. If there are no modules, then we can rely
+  # purely on digests.
+  defp missing_beam_file?(dest, [mod | _]), do: not File.exists?(beam_path(dest, mod))
+  defp missing_beam_file?(_dest, []), do: false
+
+  defp compiler_info_from_updated(
+         manifest,
+         new_paths,
+         all_modules,
+         all_sources,
+         removed,
+         stale_modules,
+         stale_exports,
+         dest,
+         timestamp
+       ) do
+    {checkpoint_stale_modules, checkpoint_stale_exports} =
+      case parse_checkpoint(:update, manifest) do
+        {:ok, {_, _} = data} -> data
+        :error -> {%{}, %{}}
       end
-    after
-      Agent.stop pid
+
+    stale_modules = Map.merge(checkpoint_stale_modules, stale_modules)
+    stale_exports = Map.merge(checkpoint_stale_exports, stale_exports)
+
+    # Once we added semantic recompilation, the following can happen:
+    #
+    # 1. The user changes config/mix.exs/__mix_recompile__?
+    # 2. We detect the change, remove .beam files and start recompilation
+    # 3. Recompilation fails
+    # 4. The user reverts the change
+    # 5. The compiler no longer recompiles and the .beam files are missing
+    #
+    # Therefore, it is important for us to checkpoint any state that may
+    # have lead to a compilation and which can now be reverted.
+    if map_size(stale_modules) != map_size(checkpoint_stale_modules) or
+         map_size(stale_exports) != map_size(checkpoint_stale_exports) do
+      write_checkpoint(:update, manifest, {stale_modules, stale_exports})
     end
 
-    :ok
+    # We don't need to store those in the checkpoint because
+    # these changes come from modules and, when they are stale,
+    # we remove the .beam files and touch sources.
+    modules_to_mix_check =
+      for {module, module(recompile?: true)} <- all_modules,
+          not Map.has_key?(stale_modules, module),
+          do: module
+
+    _ = Code.ensure_all_loaded(modules_to_mix_check)
+
+    modules_to_recompile =
+      for {:ok, {module, true}} <-
+            Task.async_stream(
+              modules_to_mix_check,
+              fn module ->
+                {module,
+                 function_exported?(module, :__mix_recompile__?, 0) and
+                   module.__mix_recompile__?()}
+              end,
+              ordered: false,
+              timeout: :infinity
+            ),
+          into: %{} do
+        {module, true}
+      end
+
+    sources_stats =
+      for path <- new_paths,
+          into: mtimes_and_sizes(all_sources),
+          do: {path, Mix.Utils.last_modified_and_size(path)}
+
+    # Sources that have changed on disk or
+    # any modules associated with them need to be recompiled
+    changed =
+      Enum.flat_map(all_sources, fn
+        {source,
+         source(external: external, size: size, mtime: mtime, digest: digest, modules: modules)} ->
+          {last_mtime, last_size} = Map.fetch!(sources_stats, source)
+
+          cond do
+            Enum.any?(external, &stale_external?(&1, sources_stats)) or
+                has_any_key?(modules_to_recompile, modules) ->
+              # Mark the source as changed so the combination of a timestamp
+              # plus removed beam files (which are removed by update_stale_entries)
+              # causes it to be recompiled. Note we don't raise use touch! because
+              # in case of checkpoints the file may have been removed.
+              File.touch(source, timestamp + 1)
+              [source]
+
+            size != last_size or
+              has_any_key?(stale_modules, modules) or
+                (last_mtime != mtime and
+                   (missing_beam_file?(dest, modules) or digest_changed?(source, digest))) ->
+              [source]
+
+            true ->
+              []
+          end
+      end)
+
+    changed = new_paths ++ changed
+
+    {modules, exports, changed} =
+      update_stale_entries(
+        all_modules,
+        all_sources,
+        removed ++ changed,
+        stale_modules,
+        stale_exports,
+        dest
+      )
+
+    # Now sort the files so the ones changed more recently come first.
+    # We do an optimized version of sort_by since we don't care about
+    # stable sorting.
+    changed =
+      changed
+      |> Enum.map(&{-elem(Map.fetch!(sources_stats, &1), 0), &1})
+      |> Enum.sort()
+      |> Enum.map(&elem(&1, 1))
+
+    {modules, exports, changed, sources_stats}
   end
 
-  defp each_module(pid, dest, cwd, source, module, binary) do
-    source = Path.relative_to(source, cwd)
-    bin    = Atom.to_string(module)
-    beam   = dest
-             |> Path.join(bin <> ".beam")
-             |> Path.relative_to(cwd)
+  defp stale_external?({external, {mtime, size}, digest}, sources_stats) do
+    case sources_stats do
+      %{^external => {0, 0}} ->
+        digest != nil
 
-    deps = Kernel.LexicalTracker.remotes(module)
-           |> List.delete(module)
-           |> :lists.usort
-           |> Enum.map(&Atom.to_string(&1))
-           |> Enum.reject(&match?("elixir_" <> _, &1))
+      %{^external => {last_mtime, last_size}} ->
+        size != last_size or (last_mtime != mtime and digest_changed?(external, digest))
+    end
+  end
 
-    files = for file <- get_external_resources(module),
-                File.regular?(file),
-                relative = Path.relative_to(file, cwd),
-                Path.type(relative) == :relative,
-                do: relative
+  defp mtimes_and_sizes(sources) do
+    Enum.reduce(sources, %{}, fn {source, source(external: external)}, map ->
+      map = Map.put_new_lazy(map, source, fn -> Mix.Utils.last_modified_and_size(source) end)
 
-    Agent.cast pid, &:lists.keystore(beam, 1, &1, {beam, bin, source, deps, files, binary})
+      Enum.reduce(external, map, fn {file, _, _}, map ->
+        Map.put_new_lazy(map, file, fn -> Mix.Utils.last_modified_and_size(file) end)
+      end)
+    end)
   end
 
-  defp get_external_resources(module) do
-    module.__info__(:attributes)[:external_resource] || []
+  defp digest_changed?(file, digest) do
+    case File.read(file) do
+      {:ok, binary} -> digest != digest_contents(binary)
+      {:error, _} -> true
+    end
   end
 
-  defp each_file(file) do
-    Mix.shell.info "Compiled #{file}"
+  defp digest_contents(contents) do
+    case :erlang.system_info(:wordsize) do
+      8 -> :crypto.hash(:blake2b, contents)
+      _ -> :crypto.hash(:blake2s, contents)
+    end
+  rescue
+    # Blake may not be available on all OpenSSL distribution
+    _ -> :erlang.md5(contents)
+  end
+
+  defp set_compiler_opts(opts) do
+    opts
+    |> Keyword.take(Code.available_compiler_options())
+    |> Code.compiler_options()
+  end
+
+  defp put_compile_env(sources) do
+    all_compile_env =
+      Enum.reduce(sources, :ordsets.new(), fn {_, source(compile_env: compile_env)}, acc ->
+        :ordsets.union(compile_env, acc)
+      end)
+
+    Mix.ProjectStack.compile_env(all_compile_env)
   end
 
   ## Resolution
 
+  defp remove_removed_sources(sources, removed) do
+    Enum.reduce(removed, {sources, %{}}, fn file, {acc_sources, acc_modules} ->
+      {source(modules: modules), acc_sources} = Map.pop(acc_sources, file)
+      acc_modules = Enum.reduce(modules, acc_modules, &Map.put(&2, &1, true))
+      {acc_sources, acc_modules}
+    end)
+  end
+
+  # Initial definition of empty records for changed sources
+  # as the compiler appends data. This may include new files,
+  # so we rely on sources_stats to avoid multiple FS lookups.
+  defp update_stale_sources(sources, stale, removed_modules, sources_stats) do
+    Enum.reduce(stale, {sources, removed_modules}, fn file, {acc_sources, acc_modules} ->
+      %{^file => {mtime, size}} = sources_stats
+
+      modules =
+        case acc_sources do
+          %{^file => source(modules: modules)} -> modules
+          %{} -> []
+        end
+
+      acc_modules = Enum.reduce(modules, acc_modules, &Map.put(&2, &1, true))
+      {Map.put(acc_sources, file, source(size: size, mtime: mtime)), acc_modules}
+    end)
+  end
+
   # This function receives the manifest entries and some source
-  # files that have changed. It then, recursively, figures out
-  # all the files that changed (thanks to the dependencies) and
-  # return their sources as the remaining entries.
-  defp remove_stale_entries(all, []) do
-    {all, []}
+  # files that have changed. Then it recursively figures out
+  # all the files that changed (via the module dependencies) and
+  # return the non-changed entries and the removed sources.
+  defp update_stale_entries(modules, _sources, [], stale_modules, stale_exports, _compile_path)
+       when stale_modules == %{} and stale_exports == %{} do
+    {modules, %{}, []}
   end
 
-  defp remove_stale_entries(all, changed) do
-    remove_stale_entries(all, :lists.usort(changed), [], [])
+  defp update_stale_entries(modules, sources, changed, stale_modules, stale_exports, compile_path) do
+    changed = Map.from_keys(changed, true)
+    reducer = &remove_stale_entry(&1, &2, sources, stale_exports, compile_path)
+    remove_stale_entries(modules, %{}, changed, stale_modules, reducer)
   end
 
-  defp remove_stale_entries([{beam, module, source, _d, _f} = entry|t], changed, removed, acc) do
-    if source in changed do
-      File.rm(beam)
-      remove_stale_entries(t, changed, [module|removed], acc)
+  defp remove_stale_entries(modules, exports, old_changed, old_stale, reducer) do
+    {pending_modules, exports, new_changed, new_stale} =
+      Enum.reduce(modules, {modules, exports, old_changed, old_stale}, reducer)
+
+    if map_size(new_stale) > map_size(old_stale) or map_size(new_changed) > map_size(old_changed) do
+      remove_stale_entries(pending_modules, exports, new_changed, new_stale, reducer)
     else
-      remove_stale_entries(t, changed, removed, [entry|acc])
+      {pending_modules, exports, Map.keys(new_changed)}
     end
   end
 
-  defp remove_stale_entries([], changed, removed, acc) do
-    # If any of the dependencies for the remaining entries
-    # were removed, get its source so we can remove them.
-    next_changed = for {_b, _m, source, deps, _f} <- acc,
-                    Enum.any?(deps, &(&1 in removed)),
-                    do: source
+  defp remove_stale_entry(entry, acc, sources, stale_exports, compile_path) do
+    {module, module(sources: source_files, export: export)} = entry
+    {pending_modules, exports, changed, stale_modules} = acc
+
+    {compile_references, export_references, runtime_references} =
+      Enum.reduce(source_files, {[], [], []}, fn file, {compile_acc, export_acc, runtime_acc} ->
+        source(
+          compile_references: compile_refs,
+          export_references: export_refs,
+          runtime_references: runtime_refs
+        ) = Map.fetch!(sources, file)
+
+        {compile_acc ++ compile_refs, export_acc ++ export_refs, runtime_acc ++ runtime_refs}
+      end)
+
+    cond do
+      # If I changed in disk or have a compile time reference to
+      # something stale or have a reference to an old export,
+      # I need to be recompiled.
+      has_any_key?(changed, source_files) or has_any_key?(stale_modules, compile_references) or
+          has_any_key?(stale_exports, export_references) ->
+        remove_and_purge(beam_path(compile_path, module), module)
+        changed = Enum.reduce(source_files, changed, &Map.put(&2, &1, true))
+
+        {Map.delete(pending_modules, module), Map.put(exports, module, export), changed,
+         Map.put(stale_modules, module, true)}
+
+      # If I have a runtime references to something stale,
+      # I am stale too.
+      has_any_key?(stale_modules, runtime_references) ->
+        {pending_modules, exports, changed, Map.put(stale_modules, module, true)}
 
-    {acc, next} = remove_stale_entries(Enum.reverse(acc), next_changed)
-    {acc, next ++ changed}
+      # Otherwise, we don't store it anywhere
+      true ->
+        {pending_modules, exports, changed, stale_modules}
+    end
   end
 
-  ## Manifest handling
+  defp has_any_key?(map, enumerable) do
+    map != %{} and Enum.any?(enumerable, &Map.has_key?(map, &1))
+  end
+
+  defp stale_local_deps(local_deps, manifest, stale_modules, modified, deps_exports) do
+    base = Path.basename(manifest)
+
+    # The stale modules so far will become both stale_modules and stale_exports,
+    # as any export from a dependency needs to be recompiled.
+    stale_modules = Map.from_keys(stale_modules, true)
 
-  # Reads the manifest returning the results as tuples.
-  # The beam files are read, removed and stored in memory.
-  defp read_manifest(manifest) do
-    case File.read(manifest) do
-      {:ok, contents} ->
-        Enum.reduce String.split(contents, "\n"), [], fn x, acc ->
-          case String.split(x, "\t") do
-            [beam, module, source|deps] ->
-              {deps, files} =
-                case Enum.split_while(deps, &(&1 != "Elixir")) do
-                  {deps, ["Elixir"|files]} -> {deps, files}
-                  {deps, _} -> {deps, []}
+    for %{app: app, opts: opts} <- local_deps,
+        manifest = Path.join([opts[:build], ".mix", base]),
+        Mix.Utils.last_modified(manifest) > modified,
+        reduce: {stale_modules, stale_modules, deps_exports, protocols_and_impls()} do
+      {modules, exports, deps_exports, protocols_and_impls} ->
+        {manifest_modules, manifest_sources} = read_manifest(manifest)
+
+        dep_modules =
+          for {module, module(timestamp: timestamp)} <- manifest_modules,
+              timestamp > modified,
+              do: module
+
+        # If any module has a compile time dependency on a changed module
+        # within the dependency, they will be recompiled. However, export
+        # and runtime dependencies won't have recompiled so we need to
+        # propagate them to the parent app.
+        dep_modules =
+          fixpoint_non_compile_modules(manifest_sources, Map.from_keys(dep_modules, true))
+
+        old_exports = Map.get(deps_exports, app, %{})
+
+        # Update exports
+        {exports, new_exports} =
+          for {module, _} <- dep_modules, reduce: {exports, []} do
+            {exports, new_exports} ->
+              export =
+                if Code.ensure_loaded?(module) and function_exported?(module, :__info__, 1) do
+                  module.__info__(:exports_md5)
                 end
-              [{beam, module, source, deps, files}|acc]
-            _ ->
-              acc
+
+              # If the exports are the same, then the API did not change,
+              # so we do not mark the export as stale. Note this has to
+              # be very conservative. If the module is not loaded or if
+              # the exports were not there, we need to consider it a stale
+              # export.
+              exports =
+                if export && old_exports[module] == export,
+                  do: exports,
+                  else: Map.put(exports, module, true)
+
+              # Then we store the new export if any
+              new_exports =
+                if export,
+                  do: [{module, export} | new_exports],
+                  else: new_exports
+
+              {exports, new_exports}
           end
+
+        new_exports = Map.new(new_exports)
+
+        removed =
+          for {module, _} <- old_exports,
+              not is_map_key(new_exports, module),
+              do: {module, true},
+              into: %{}
+
+        modules = modules |> Map.merge(dep_modules) |> Map.merge(removed)
+        exports = Map.merge(exports, removed)
+        deps_exports = Map.put(deps_exports, app, new_exports)
+
+        protocols_and_impls =
+          protocols_and_impls_from_modules(manifest_modules, protocols_and_impls)
+
+        {modules, exports, deps_exports, protocols_and_impls}
+    end
+  end
+
+  defp fixpoint_non_compile_modules(sources, modules) when modules != %{} do
+    fixpoint_non_compile_modules(Map.to_list(sources), modules, false, [])
+  end
+
+  defp fixpoint_non_compile_modules(_sources, modules) do
+    modules
+  end
+
+  defp fixpoint_non_compile_modules(
+         [{_source_path, source_entry} = pair | sources],
+         modules,
+         new?,
+         pending_sources
+       ) do
+    source(export_references: export_refs, runtime_references: runtime_refs) = source_entry
+
+    if has_any_key?(modules, export_refs) or has_any_key?(modules, runtime_refs) do
+      new_modules = Enum.reject(source(source_entry, :modules), &Map.has_key?(modules, &1))
+      modules = Enum.reduce(new_modules, modules, &Map.put(&2, &1, true))
+      new? = new? or new_modules != []
+      fixpoint_non_compile_modules(sources, modules, new?, pending_sources)
+    else
+      pending_sources = [pair | pending_sources]
+      fixpoint_non_compile_modules(sources, modules, new?, pending_sources)
+    end
+  end
+
+  defp fixpoint_non_compile_modules([], modules, new?, pending_sources)
+       when new? == false or pending_sources == [],
+       do: modules
+
+  defp fixpoint_non_compile_modules([], modules, true, pending_sources),
+    do: fixpoint_non_compile_modules(pending_sources, modules, false, [])
+
+  defp remove_and_purge(beam, module) do
+    _ = File.rm(beam)
+
+    if Code.loaded?(module) do
+      :code.purge(module)
+      :code.delete(module)
+    end
+  end
+
+  defp purge_modules_in_path(path) do
+    with {:ok, beams} <- File.ls(path) do
+      Enum.each(beams, fn beam ->
+        module = beam |> Path.rootname() |> String.to_atom()
+
+        if Code.loaded?(module) do
+          :code.purge(module)
+          :code.delete(module)
         end
-      {:error, _} ->
-        []
+      end)
+    end
+  end
+
+  defp previous_warnings(sources, print?) do
+    for {_, source(compile_warnings: compile_warnings, runtime_warnings: runtime_warnings)} <-
+          sources,
+        diagnostic <- compile_warnings ++ runtime_warnings do
+      if print? do
+        Mix.shell().print_app()
+        Code.print_diagnostic(diagnostic)
+      end
+
+      diagnostic
     end
   end
 
-  # Writes the manifest separating entries by tabs.
-  defp write_manifest(_manifest, []) do
+  defp apply_warnings(sources, [], []) do
+    sources
+  end
+
+  defp apply_warnings(sources, runtime_warnings, compile_warnings) do
+    cwd = File.cwd!()
+    runtime_group = Enum.group_by(runtime_warnings, & &1.source)
+    compile_group = Enum.group_by(compile_warnings, & &1.source)
+
+    for {source_path, source_entry} <- sources, into: %{} do
+      source(
+        runtime_warnings: runtime_warnings,
+        compile_warnings: compile_warnings,
+        external: external
+      ) = source_entry
+
+      keys = [
+        Path.absname(source_path, cwd)
+        | Enum.map(external, &(&1 |> elem(0) |> Path.absname(cwd)))
+      ]
+
+      runtime_warnings =
+        case Enum.flat_map(keys, &Map.get(runtime_group, &1, [])) do
+          [] -> runtime_warnings
+          runtime_warnings -> runtime_warnings
+        end
+
+      compile_warnings =
+        case Enum.flat_map(keys, &Map.get(compile_group, &1, [])) do
+          [] -> compile_warnings
+          compile_warnings -> compile_warnings
+        end
+
+      {source_path,
+       source(source_entry,
+         runtime_warnings: runtime_warnings,
+         compile_warnings: compile_warnings
+       )}
+    end
+  end
+
+  defp diagnostic(
+         %{
+           file: file,
+           position: position,
+           message: message,
+           severity: severity,
+           stacktrace: stacktrace,
+           span: span,
+           source: source
+         } = diagnostic
+       ) do
+    %Mix.Task.Compiler.Diagnostic{
+      file: file,
+      source: source,
+      position: position,
+      message: message,
+      severity: severity,
+      compiler_name: "Elixir",
+      stacktrace: stacktrace,
+      span: span,
+      details: Map.get(diagnostic, :details, nil)
+    }
+  end
+
+  ## Merging of lock and config files
+
+  # Value for app didn't change
+  defp merge_appset([{app, value} | old_set], [{app, value} | new_set], apps),
+    do: merge_appset(old_set, new_set, apps)
+
+  # Value for app changed
+  defp merge_appset([{app, _} | old_set], [{app, _} | new_set], apps),
+    do: merge_appset(old_set, new_set, [app | apps])
+
+  # Added value for app
+  defp merge_appset([{app1, _} | _] = old_set, [{app2, _} | new_set], apps)
+       when app1 > app2,
+       do: merge_appset(old_set, new_set, [app2 | apps])
+
+  # Removed value for app
+  defp merge_appset([{app1, _} | old_set], [{app2, _} | _] = new_set, apps)
+       when app1 < app2,
+       do: merge_appset(old_set, new_set, [app1 | apps])
+
+  # One of them is done, add the others
+  defp merge_appset(old_set, new_set, apps) do
+    apps = Enum.reduce(old_set, apps, fn {app, _}, apps -> [app | apps] end)
+    Enum.reduce(new_set, apps, fn {app, _}, apps -> [app | apps] end)
+  end
+
+  defp deps_on(apps) do
+    apps = Map.from_keys(apps, true)
+    deps_on(Mix.Dep.cached(), apps, [], false)
+  end
+
+  defp deps_on([%{app: app, deps: deps} = dep | cached_deps], apps, acc, stored?) do
+    cond do
+      # We have already seen this dep
+      Map.has_key?(apps, app) ->
+        deps_on(cached_deps, apps, acc, stored?)
+
+      # It depends on one of the apps, store it
+      Enum.any?(deps, &Map.has_key?(apps, &1.app)) ->
+        deps_on(cached_deps, Map.put(apps, app, true), acc, true)
+
+      # Otherwise we will check it later
+      true ->
+        deps_on(cached_deps, apps, [dep | acc], stored?)
+    end
+  end
+
+  defp deps_on([], apps, cached_deps, true), do: deps_on(cached_deps, apps, [], false)
+  defp deps_on([], apps, _cached_deps, false), do: apps
+
+  ## Manifest handling
+
+  @default_manifest {%{}, %{}, %{}, [], nil, nil, nil, 0, 0, {%{}, %{}}}
+
+  # Similar to read_manifest, but for internal consumption and with data migration support.
+  defp parse_manifest(manifest, compile_path) do
+    try do
+      manifest |> File.read!() |> :erlang.binary_to_term()
+    rescue
+      _ ->
+        @default_manifest
+    else
+      {@manifest_vsn, modules, sources, local_exports, parent, cache_key, cwd, deps_config,
+       project_mtime, config_mtime, protocols_and_impls} ->
+        {modules, sources, local_exports, parent, cache_key, cwd, deps_config, project_mtime,
+         config_mtime, protocols_and_impls}
+
+      # {vsn, %{module => record}, sources, ...} v22-?
+      # {vsn, [module_record], sources, ...} v5-v21
+      manifest when is_tuple(manifest) and is_integer(elem(manifest, 0)) ->
+        purge_old_manifest(compile_path, elem(manifest, 1))
+
+      # v1-v4
+      [vsn | data] when is_integer(vsn) ->
+        purge_old_manifest(compile_path, data)
+
+      _ ->
+        @default_manifest
+    end
+  end
+
+  defp purge_old_manifest(compile_path, data) do
+    try do
+      # If data is a list, we have an old manifest and
+      # we convert it to the same format as maps.
+      data =
+        if is_list(data) do
+          for entry <- data, elem(entry, 0) == :module do
+            {elem(entry, 1), entry}
+          end
+        else
+          data
+        end
+
+      for {module, _} <- data do
+        remove_and_purge(beam_path(compile_path, module), module)
+      end
+    rescue
+      _ ->
+        Mix.raise(
+          "Cannot clean-up stale manifest, please run \"mix clean --deps\" manually before proceeding"
+        )
+    end
+
+    @default_manifest
+  end
+
+  defp write_manifest(
+         manifest,
+         %{} = modules,
+         %{} = sources,
+         exports,
+         parents,
+         cache_key,
+         deps_config,
+         project_mtime,
+         config_mtime,
+         protocols_and_impls,
+         timestamp
+       ) do
+    File.mkdir_p!(Path.dirname(manifest))
+
+    term =
+      {@manifest_vsn, modules, sources, exports, parents, cache_key, File.cwd!(), deps_config,
+       project_mtime, config_mtime, protocols_and_impls}
+
+    manifest_data = :erlang.term_to_binary(term, [:compressed])
+    File.write!(manifest, manifest_data)
+    File.touch!(manifest, timestamp)
+    delete_checkpoints(manifest)
+
+    # Since Elixir is a dependency itself, we need to touch the lock
+    # so the current Elixir version, used to compile the files above,
+    # is properly stored.
+    config = Mix.Project.config()
+    Mix.Dep.ElixirSCM.update(config[:build_scm], config[:deps_lock])
     :ok
   end
 
-  defp write_manifest(manifest, entries) do
-    lines = Enum.map(entries, fn
-      {beam, module, source, deps, files, binary} ->
-        if binary, do: File.write!(beam, binary)
-        tail = deps ++ ["Elixir"] ++ files
-        [beam, module, source | tail] |> Enum.join("\t")
-    end)
+  defp beam_path(compile_path, module) do
+    Path.join(compile_path, Atom.to_string(module) <> ".beam")
+  end
 
+  defp parse_checkpoint(type, manifest) when type in [:update, :verify] do
+    try do
+      (manifest <> ".#{type}.cp") |> File.read!() |> :erlang.binary_to_term()
+    rescue
+      _ -> :error
+    else
+      {@checkpoint_vsn, data} -> {:ok, data}
+      _ -> :error
+    end
+  end
+
+  defp write_checkpoint(type, manifest, data) when type in [:update, :verify] do
     File.mkdir_p!(Path.dirname(manifest))
-    File.write!(manifest, Enum.join(lines, "\n"))
+    term = {@checkpoint_vsn, data}
+    checkpoint_data = :erlang.term_to_binary(term)
+    File.write!(manifest <> ".#{type}.cp", checkpoint_data)
+  end
+
+  defp delete_checkpoints(manifest) do
+    File.rm(manifest <> ".update.cp")
+    File.rm(manifest <> ".verify.cp")
+  end
+
+  defp unless_warnings_as_errors(opts, {status, all_warnings}) do
+    if all_warnings != [] and opts[:warnings_as_errors] do
+      message = "Compilation failed due to warnings while using the --warnings-as-errors option"
+      IO.puts(:stderr, message)
+      {:error, all_warnings}
+    else
+      {status, all_warnings}
+    end
+  end
+
+  defp modules_diff(compiled_modules, removed_modules, all_modules, timestamp) do
+    {changed, added} =
+      compiled_modules
+      |> Map.keys()
+      |> Enum.split_with(&Map.has_key?(all_modules, &1))
+
+    # Note that removed_modules may also include changed modules
+    removed =
+      for {module, _} <- removed_modules, not Map.has_key?(compiled_modules, module), do: module
+
+    %{
+      added: added,
+      changed: changed,
+      removed: removed,
+      timestamp: timestamp
+    }
+  end
+
+  ## Compiler loop
+  # The compiler is invoked in a separate process so we avoid blocking its main loop.
+
+  defp compiler_loop(manifest, stale, stale_modules, dest, timestamp, opts, state) do
+    ref = make_ref()
+    parent = self()
+    compilation_threshold = opts[:long_compilation_threshold] || 10
+    verification_threshold = opts[:long_verification_threshold] || 10
+    profile = opts[:profile]
+    verbose = Keyword.get(opts, :verbose, false)
+    verification = Keyword.get(opts, :verification, true)
+
+    if not verification and not Mix.debug?() do
+      Mix.shell().error("--no-verification flag is only recommended with MIX_DEBUG=1")
+    end
+
+    pid =
+      spawn_link(fn ->
+        compile_opts = [
+          after_compile: fn ->
+            compiler_call(parent, ref, {:after_compile, manifest, opts})
+          end,
+          each_cycle: fn ->
+            compiler_call(parent, ref, {:each_cycle, stale_modules, dest, timestamp})
+          end,
+          each_file: fn file, lexical ->
+            compiler_call(parent, ref, {:each_file, file, lexical, verbose})
+          end,
+          each_module: fn file, module, _binary ->
+            compiler_call(parent, ref, {:each_module, file, module, System.os_time(:second)})
+          end,
+          each_long_compilation: fn file, pid ->
+            Mix.shell().info(
+              "Compiling #{Path.relative_to(file, File.cwd!())} " <>
+                "(it's taking more than #{compilation_threshold}s)#{debug_stacktrace(pid)}"
+            )
+          end,
+          each_long_verification: fn module, pid ->
+            Mix.shell().info(
+              "Verifying #{inspect(module)} " <>
+                "(it's taking more than #{verification_threshold}s)#{debug_stacktrace(pid)}"
+            )
+          end,
+          long_compilation_threshold: compilation_threshold,
+          long_verification_threshold: verification_threshold,
+          beam_timestamp: timestamp,
+          return_diagnostics: true,
+          profile: profile,
+          verification: verification
+        ]
+
+        response = Kernel.ParallelCompiler.compile_to_path(stale, dest, compile_opts)
+        send(parent, {ref, response})
+      end)
+
+    compiler_loop(ref, pid, state, File.cwd!())
+  end
+
+  defp compiler_call(parent, ref, info) do
+    send(parent, {ref, info})
+
+    receive do
+      {^ref, response} -> response
+    end
+  end
+
+  defp compiler_loop(ref, pid, state, cwd) do
+    receive do
+      {^ref, {:after_compile, manifest, opts}} ->
+        {response, state} = after_compile(manifest, state, opts)
+        send(pid, {ref, response})
+        compiler_loop(ref, pid, state, cwd)
+
+      {^ref, {:each_cycle, stale_modules, dest, timestamp}} ->
+        {response, state} = each_cycle(stale_modules, dest, timestamp, state)
+        send(pid, {ref, response})
+        compiler_loop(ref, pid, state, cwd)
+
+      {^ref, {:each_file, file, lexical, verbose}} ->
+        # Read the relevant file information and unblock the compiler
+        references = Kernel.LexicalTracker.references(lexical)
+        send(pid, {ref, :ok})
+        state = each_file(file, references, verbose, state, cwd)
+        compiler_loop(ref, pid, state, cwd)
+
+      {^ref, {:each_module, file, module, timestamp}} ->
+        # Read the relevant module information and unblock the compiler
+        kind = detect_kind(module)
+        external = Module.get_attribute(module, :external_resource)
+        new_export = Module.get_attribute(module, :exports_md5)
+        recompile? = Module.defines?(module, {:__mix_recompile__?, 0}, :def)
+        send(pid, {ref, :ok})
+
+        state =
+          each_module(file, module, kind, external, new_export, recompile?, state, timestamp, cwd)
+
+        compiler_loop(ref, pid, state, cwd)
+
+      {^ref, {:ok, _modules, info}} ->
+        {:ok, info, state}
+
+      {^ref, {:error, errors, info}} ->
+        {:error, errors, info, state}
+    end
+  end
+
+  defp after_compile(manifest, state, opts) do
+    %{modules: modules, pending_modules: pending_modules, consolidation: consolidation} = state
+    write_checkpoint(:verify, manifest, Map.keys(modules))
+    consolidation = maybe_consolidate(consolidation, modules, pending_modules, opts)
+    {:ok, %{state | consolidation: consolidation}}
+  end
+
+  defp each_cycle(stale_modules, dest, timestamp, state) do
+    %{
+      modules: modules,
+      sources: sources,
+      changed: changed,
+      pending_modules: pending_modules,
+      stale_exports: stale_exports
+    } = state
+
+    # At this point, we may have additional files to compile.
+    # There are two potential sources:
+    #
+    # * We need to go through all exports that we have confirmed that changed.
+    #   When we first compile, we store all removed/changed modules as stale
+    #   exports. Then, if they are not compiled again, or compiled with a
+    #   different exports MD5, they remain as stale, causing the next cycle.
+    #
+    # * In case a module is defined in two places, we add all sources to changed
+    {pending_modules, exports, changed} =
+      update_stale_entries(pending_modules, sources, changed, %{}, stale_exports, dest)
+
+    state = %{
+      state
+      | changed: [],
+        exports: exports,
+        pending_modules: pending_modules
+    }
+
+    # Those files have been changed transitively, so we mark them as changed
+    # in case compilation fails mid-cycle. The combination of the outdated
+    # timestamp plus the missing BEAM files (which were removed in
+    # update_stale_entries above) will cause them to be recompiled next time.
+    for file <- changed do
+      File.touch!(file, timestamp)
+    end
+
+    if changed == [] do
+      # We merge stale_modules (which is a map of %{module => true} that the user changed)
+      # into a map of modules we compiled (which is a map of %{module => record}). This is
+      # fine because we only care about the keys.
+      changed_modules = Map.merge(modules, stale_modules)
+
+      # Now we do a simple pass finding anything that directly depends on the modules that
+      # changed. We don't need to compute a fixpoint, because now only the directly affected
+      # matter.
+      {sources, runtime_modules} =
+        Enum.reduce(sources, {sources, []}, fn
+          {source_path, source_entry}, {acc_sources, acc_modules} ->
+            source(export_references: export_refs, runtime_references: runtime_refs) =
+              source_entry
+
+            if has_any_key?(changed_modules, export_refs) or
+                 has_any_key?(changed_modules, runtime_refs) do
+              acc_sources =
+                Map.replace!(acc_sources, source_path, source(source_entry, runtime_warnings: []))
+
+              new_modules =
+                Enum.reject(source(source_entry, :modules), &Map.has_key?(changed_modules, &1))
+
+              {acc_sources, new_modules ++ acc_modules}
+            else
+              {acc_sources, acc_modules}
+            end
+        end)
+
+      runtime_paths =
+        Enum.map(runtime_modules, &{&1, Path.join(dest, Atom.to_string(&1) <> ".beam")})
+
+      state = %{state | sources: sources}
+      {{:runtime, runtime_paths, []}, state}
+    else
+      Mix.Utils.compiling_n(length(changed), :ex)
+
+      # Now we need to detect the new stale_exports.
+      # This is a simplified version of update_stale_sources.
+      {sources, %{}} =
+        Enum.reduce(changed, {sources, stale_exports}, fn file, {acc_sources, acc_modules} ->
+          source(size: size, digest: digest, modules: modules) = Map.fetch!(acc_sources, file)
+          acc_modules = Enum.reduce(modules, acc_modules, &Map.put(&2, &1, true))
+          {Map.replace!(acc_sources, file, source(size: size, digest: digest)), acc_modules}
+        end)
+
+      state = %{state | sources: sources, stale_exports: stale_exports}
+      {{:compile, changed, []}, state}
+    end
+  end
+
+  defp each_file(file, references, verbose, state, cwd) do
+    {compile_references, export_references, runtime_references, compile_env} = references
+    %{sources: sources} = state
+
+    file = Path.relative_to(file, cwd)
+
+    if verbose do
+      Mix.shell().info("Compiled #{file}")
+    end
+
+    compile_references =
+      Enum.reject(compile_references, &match?("elixir_" <> _, Atom.to_string(&1)))
+
+    source(modules: source_modules) = source = Map.fetch!(sources, file)
+    compile_references = compile_references -- source_modules
+    export_references = export_references -- source_modules
+    runtime_references = runtime_references -- source_modules
+
+    source =
+      source(
+        source,
+        # We preserve the digest if the file is recompiled but not changed
+        digest: source(source, :digest) || file |> File.read!() |> digest_contents(),
+        compile_references: compile_references,
+        export_references: export_references,
+        runtime_references: runtime_references,
+        compile_env: compile_env
+      )
+
+    %{state | sources: Map.replace!(sources, file, source)}
+  end
+
+  defp each_module(file, module, kind, external, new_export, recompile?, state, timestamp, cwd) do
+    %{
+      modules: modules,
+      exports: exports,
+      sources: sources,
+      changed: changed,
+      pending_modules: pending_modules,
+      stale_exports: stale_exports
+    } = state
+
+    file = Path.relative_to(file, cwd)
+    external = process_external_resources(external, cwd)
+    old_export = Map.get(exports, module)
+
+    stale_exports =
+      if old_export && old_export != new_export do
+        stale_exports
+      else
+        Map.delete(stale_exports, module)
+      end
+
+    module_sources =
+      case modules do
+        %{^module => module(sources: old_sources)} -> [file | List.delete(old_sources, file)]
+        %{} -> [file]
+      end
+
+    source =
+      Map.get(sources, file) ||
+        Mix.raise(
+          "Could not find source for #{inspect(file)}. Make sure the :elixirc_paths configuration " <>
+            "is a list of relative paths to the current project or absolute paths to external directories"
+        )
+
+    source =
+      source(
+        source,
+        external: external ++ source(source, :external),
+        modules: [module | source(source, :modules)]
+      )
+
+    entry =
+      module(
+        kind: kind,
+        sources: module_sources,
+        export: new_export,
+        timestamp: timestamp,
+        recompile?: recompile?
+      )
+
+    modules = Map.put(modules, module, entry)
+    sources = Map.replace!(sources, file, source)
+
+    # In case the module defined is pending, this is a source conflict.
+    # So we need to compile all duplicates.
+    changed =
+      case pending_modules do
+        %{^module => module(sources: sources)} -> sources ++ changed
+        %{} -> changed
+      end
+
+    %{state | modules: modules, changed: changed, sources: sources, stale_exports: stale_exports}
+  end
+
+  defp detect_kind(module) do
+    protocol_metadata = Module.get_attribute(module, :__impl__)
+
+    cond do
+      is_list(protocol_metadata) and protocol_metadata[:protocol] ->
+        {:impl, protocol_metadata[:protocol]}
+
+      is_list(Module.get_attribute(module, :__protocol__)) ->
+        :protocol
+
+      true ->
+        :module
+    end
+  end
+
+  defp process_external_resources(external, cwd) do
+    for file <- external do
+      digest =
+        case File.read(file) do
+          {:ok, binary} -> digest_contents(binary)
+          {:error, _} -> nil
+        end
+
+      {Path.relative_to(file, cwd), Mix.Utils.last_modified_and_size(file), digest}
+    end
+  end
+
+  defp debug_stacktrace(pid) do
+    with true <- Mix.debug?(),
+         {:current_stacktrace, stacktrace} <- Process.info(pid, :current_stacktrace) do
+      [?\n, Exception.format_stacktrace(stacktrace)]
+    else
+      _ -> ""
+    end
+  end
+
+  ## Consolidation
+
+  @doc """
+  Returns protocols and implementations for the given `manifest`.
+  """
+  def protocols_and_impls_from_paths(paths) do
+    Enum.reduce(paths, protocols_and_impls(), fn path, acc ->
+      {modules, _} = read_manifest(Path.join(path, ".mix/compile.elixir"))
+      protocols_and_impls_from_modules(modules, acc)
+    end)
+  end
+
+  defp protocols_and_impls_from_modules(modules, protocols_and_impls) do
+    Enum.reduce(modules, protocols_and_impls, fn
+      {module, module(kind: kind, timestamp: timestamp)}, {protocols, impls} ->
+        case kind do
+          :protocol -> {Map.put(protocols, module, timestamp), impls}
+          {:impl, protocol} -> {protocols, Map.put(impls, module, protocol)}
+          _ -> {protocols, impls}
+        end
+    end)
+  end
+
+  defp protocols_and_impls(), do: {%{}, %{}}
+
+  defp maybe_consolidate({:off, _, _}, _, _, _) do
+    protocols_and_impls()
+  end
+
+  defp maybe_consolidate(
+         {on_or_force, old_protocols_and_impls, protocols_and_impls},
+         modules,
+         pending_modules,
+         opts
+       ) do
+    protocols_and_impls = protocols_and_impls_from_modules(modules, protocols_and_impls)
+    protocols_and_impls = protocols_and_impls_from_modules(pending_modules, protocols_and_impls)
+
+    Mix.Compilers.Protocol.compile(
+      on_or_force == :force,
+      old_protocols_and_impls,
+      protocols_and_impls,
+      opts
+    )
+
+    protocols_and_impls
   end
 end
diff --git a/lib/mix/lib/mix/compilers/erlang.ex b/lib/mix/lib/mix/compilers/erlang.ex
index 12fba983bdd..c88857a8fe6 100644
--- a/lib/mix/lib/mix/compilers/erlang.ex
+++ b/lib/mix/lib/mix/compilers/erlang.ex
@@ -1,112 +1,248 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Compilers.Erlang do
   @moduledoc false
 
+  @manifest_vsn 1
+
+  @typedoc """
+  Options for `compile/6`.
+  """
+  @type compile_opts :: [
+          all_warnings: boolean(),
+          force: boolean(),
+          parallel: boolean() | MapSet.t(Path.t()),
+          preload: (-> term()),
+          verbose: boolean()
+        ]
+
   @doc """
-  Compiles the files in `src_dirs` with given extensions into
-  the destination, automatically invoking the callback for each
-  stale input and output pair (or for all if `force` is true) and
-  removing files that no longer have a source, while keeping the
-  manifest up to date.
+  Compiles the given `mappings`.
+
+  `mappings` is a list of `{src, dest}` pairs, where the source
+  extensions are compiled into the destination extension,
+  automatically invoking the callback for each stale pair (or for
+  all if `force` is `true`) and removing files that no longer have
+  a source, while keeping the `manifest` up to date.
+
+  ## Options
+
+    * `:all_warnings` - a flag to disable showing all previous warnings
+
+    * `:force` - forces compilation regardless of modification times
+
+    * `:parallel` - a mapset of files to compile in parallel
+
+    * `:preload` - any code that must be preloaded if any pending
+      entry needs to be compiled
+
+    * `:verbose` - a flag to enable verbose printing
 
   ## Examples
 
   For example, a simple compiler for Lisp Flavored Erlang
   would be implemented like:
 
-      manifest = Path.join Mix.Project.manifest_path, ".compile.lfe"
-      dest = Mix.Project.compile_path
+      manifest = Path.join(Mix.Project.manifest_path(), "compile.lfe")
+      dest = Mix.Project.compile_path()
 
-      compile manifest, [{"src", dest}], :lfe, :beam, opts[:force], fn
-        input, output ->
-          :lfe_comp.file(to_erl_file(input),
-                         [output_dir: Path.dirname(output)])
-      end
+      compile(manifest, [{"src", dest}], :lfe, :beam, opts, fn input, output ->
+        :lfe_comp.file(
+          to_erl_file(input),
+          [{:outdir, Path.dirname(output)}, :return, :report]
+        )
+      end)
 
   The command above will:
 
-    1. look for files ending with the `lfe` extension in `src`
-       and their `beam` counterpart in `ebin`
+    1. look for files ending with the `lfe` extension in `src` path
+       and their `beam` counterpart in `ebin` path
 
-    2. for each stale file (or for all if `force` is true),
+    2. for each stale file (or for all if `force` is `true`),
        invoke the callback passing the calculated input
        and output
 
     3. update the manifest with the newly compiled outputs
 
-    4. remove any output in the manifest that that does not
+    4. remove any output in the manifest that does not
        have an equivalent source
 
-  The callback must return `{:ok, mod}` or `:error` in case
-  of error. An error is raised at the end if any of the
-  files failed to compile.
+  The callback must return `{:ok, term, warnings}` or
+  `{:error, errors, warnings}` in case of error. This function returns
+  `{status, diagnostics}` as specified in `Mix.Task.Compiler`.
   """
-  def compile(manifest, mappings, src_ext, dest_ext, force, callback) do
-    files = for {src, dest} <- mappings do
-              extract_targets(src, src_ext, dest, dest_ext, force)
-            end |> Enum.concat
-    compile(manifest, files, callback)
+  @spec compile(
+          Path.t(),
+          [{Path.t(), Path.t()}],
+          atom(),
+          atom(),
+          compile_opts,
+          (Path.t(), Path.t() -> {:ok, term(), [term()]} | {:error, [term()], [term()]})
+        ) :: {Mix.Task.Compiler.status(), [Mix.Task.Compiler.Diagnostic.t()]}
+  def compile(manifest, mappings, src_ext, dest_ext, opts, callback)
+      when is_atom(src_ext) and is_atom(dest_ext) and is_list(opts) do
+    force = opts[:force]
+
+    entries =
+      for {src, dest} <- mappings,
+          target <- extract_entries(src, src_ext, dest, dest_ext, force),
+          do: target
+
+    if preload = entries != [] && opts[:preload] do
+      preload.()
+    end
+
+    compile_entries(manifest, entries, src_ext, dest_ext, opts, callback)
   end
 
-  @doc """
-  Compiles the given src/dest tuples.
+  # TODO: remove me on v1.22
+  @deprecated "Use compile/6 or open an up an issue"
+  def compile(manifest, entries, opts \\ [], callback) do
+    compile_entries(manifest, entries, :erl, :beam, opts, callback)
+  end
 
-  A manifest file and a callback to be invoked for each src/dest pair
-  must be given. A src/dest pair where destination is nil is considered
-  to be up to date and won't be (re-)compiled.
-  """
-  def compile(manifest, tuples, callback) do
-    stale = for {:stale, src, dest} <- tuples, do: {src, dest}
+  @doc false
+  def compile_entries(manifest, mappings, src_ext, dest_ext, opts, callback) do
+    stale = for {:stale, src, dest} <- mappings, do: {src, dest}
 
     # Get the previous entries from the manifest
-    entries = read_manifest(manifest)
+    timestamp = System.os_time(:second)
+    old_entries = entries = read_manifest(manifest)
 
-    # Files to remove are the ones in the manifest
-    # but they no longer have a source
-    removed = Enum.filter(entries, fn entry ->
-      not Enum.any?(tuples, fn {_status, _src, dest} -> dest == entry end)
-    end)
+    # Files to remove are the ones in the manifest but they no longer have a source
+    removed =
+      for {dest, _} <- entries, not List.keymember?(mappings, dest, 2), do: dest
 
-    if stale == [] && removed == [] do
-      :noop
+    # Remove manifest entries with no source
+    Enum.each(removed, &File.rm/1)
+    verbose = opts[:verbose]
+
+    # Clear stale and removed files from manifest
+    entries =
+      Enum.reject(entries, fn {dest, _warnings} ->
+        dest in removed || List.keymember?(stale, dest, 1)
+      end)
+
+    if Keyword.get(opts, :all_warnings, true), do: show_warnings(entries)
+
+    if stale == [] and removed == [] do
+      {:noop, manifest_warnings(entries)}
     else
-      # Build the project structure so we can write down compiled files.
-      Mix.Project.build_structure
+      Mix.Utils.compiling_n(length(stale), src_ext)
+      Mix.Project.ensure_structure()
+
+      # Let's prepend the newly created path so compiled files
+      # can be accessed still during compilation (for behaviours
+      # and what not). Note we don't want to cache this path as
+      # we will write to it.
+      Code.prepend_path(Mix.Project.compile_path())
+
+      {parallel, serial} =
+        case opts[:parallel] || false do
+          true -> {stale, []}
+          false -> {[], stale}
+          parallel -> Enum.split_with(stale, fn {source, _target} -> source in parallel end)
+        end
 
-      # Remove manifest entries with no source
-      Enum.each(removed, &File.rm/1)
+      serial_results = Enum.map(serial, &do_compile(&1, callback, timestamp, verbose))
+
+      parallel_results =
+        parallel
+        |> Task.async_stream(&do_compile(&1, callback, timestamp, verbose),
+          timeout: :infinity,
+          ordered: false
+        )
+        |> Enum.map(fn {:ok, result} -> result end)
 
       # Compile stale files and print the results
-      results = for {input, output} <- stale do
-        interpret_result(input, callback.(input, output))
+      {status, new_entries, warnings, errors} =
+        Enum.reduce(serial_results ++ parallel_results, {:ok, [], [], []}, &combine_results/2)
+
+      write_manifest(manifest, entries ++ new_entries, timestamp)
+
+      # Return status and diagnostics
+      warnings = manifest_warnings(entries) ++ to_diagnostics(warnings, :warning)
+
+      if dest_ext == :beam do
+        lazy_modules_diff = fn ->
+          {changed, added} =
+            stale
+            |> Enum.map(&elem(&1, 1))
+            |> Enum.split_with(fn dest -> List.keymember?(old_entries, dest, 0) end)
+
+          modules_diff(added, changed, removed, timestamp)
+        end
+
+        Mix.Task.Compiler.notify_modules_compiled(lazy_modules_diff)
       end
 
-      # Write final entries to manifest
-      entries = (entries -- removed) ++ Enum.map(stale, &elem(&1, 1))
-      write_manifest(manifest, :lists.usort(entries))
+      case status do
+        :ok ->
+          {:ok, warnings}
 
-      # Raise if any error, return :ok otherwise
-      if :error in results, do: raise CompileError
-      :ok
+        :error ->
+          errors = to_diagnostics(errors, :error)
+          {:error, warnings ++ errors}
+      end
     end
   end
 
+  @deprecated "Use Mix.ensure_application!(app) plus Application.ensure_all_started(app) instead"
+  def ensure_application!(app, _input) do
+    Mix.ensure_application!(app)
+    {:ok, _} = Application.ensure_all_started(app)
+  end
+
   @doc """
-  Removes compiled files.
+  Removes compiled files for the given `manifest`.
   """
   def clean(manifest) do
-    Enum.each read_manifest(manifest), &File.rm/1
-    File.rm manifest
+    contents = read_manifest(manifest)
+    File.rm(manifest)
+    Enum.each(contents, fn {file, _} -> File.rm(file) end)
   end
 
   @doc """
-  Converts the given file to a format accepted by
+  Converts the given `file` to a format accepted by
   the Erlang compilation tools.
   """
   def to_erl_file(file) do
-    to_char_list(file)
+    to_charlist(file)
+  end
+
+  @doc """
+  Asserts that the `:erlc_paths` configuration option that many Mix tasks
+  rely on is valid.
+
+  Raises a `Mix.Error` exception if the option is not valid, returns `:ok`
+  otherwise.
+  """
+  def assert_valid_erlc_paths(erlc_paths) do
+    if is_list(erlc_paths) do
+      :ok
+    else
+      Mix.raise(":erlc_paths should be a list of paths, got: #{inspect(erlc_paths)}")
+    end
   end
 
-  defp extract_targets(src_dir, src_ext, dest_dir, dest_ext, force) do
+  @doc """
+  Returns the output paths in the manifest.
+  """
+  def outputs(manifest) do
+    manifest |> read_manifest() |> Enum.map(&elem(&1, 0))
+  end
+
+  @doc """
+  Retrieves all diagnostics from the given manifest.
+  """
+  def diagnostics(manifest) do
+    entries = read_manifest(manifest)
+    manifest_warnings(entries)
+  end
+
+  defp extract_entries(src_dir, src_ext, dest_dir, dest_ext, force) do
     files = Mix.Utils.extract_files(List.wrap(src_dir), List.wrap(src_ext))
 
     for file <- files do
@@ -122,26 +258,119 @@ defmodule Mix.Compilers.Erlang do
   end
 
   defp module_from_artifact(artifact) do
-    artifact |> Path.basename |> Path.rootname
+    artifact |> Path.basename() |> Path.rootname()
   end
 
-  defp interpret_result(file, result) do
-    case result do
-      {:ok, _} -> Mix.shell.info "Compiled #{file}"
-      :error -> :error
+  # The manifest file contains a list of {dest, warnings} tuples
+  defp read_manifest(file) do
+    try do
+      file |> File.read!() |> :erlang.binary_to_term()
+    rescue
+      _ -> []
+    else
+      {@manifest_vsn, data} when is_list(data) -> data
+      _ -> []
     end
-    result
   end
 
-  defp read_manifest(file) do
-    case File.read(file) do
-      {:ok, contents} -> String.split(contents, "\n")
-      {:error, _} -> []
+  defp write_manifest(file, entries, timestamp) do
+    File.mkdir_p!(Path.dirname(file))
+    File.write!(file, :erlang.term_to_binary({@manifest_vsn, entries}))
+    File.touch!(file, timestamp)
+  end
+
+  defp do_compile({input, output}, callback, timestamp, verbose) do
+    case callback.(input, output) do
+      {:ok, _, warnings} ->
+        File.touch!(output, timestamp)
+        verbose && Mix.shell().info("Compiled #{input}")
+        {:ok, [{output, warnings}], warnings, []}
+
+      {:error, errors, warnings} ->
+        {:error, [], warnings, errors}
+
+      {:ok, _} ->
+        IO.warn(
+          "returning {:ok, contents} in the Mix.Compilers.Erlang.compile/6 callback is deprecated " <>
+            "The callback should return {:ok, contents, warnings} or {:error, errors, warnings}"
+        )
+
+        {:ok, [], [], []}
+
+      :error ->
+        IO.warn(
+          "returning :error in the Mix.Compilers.Erlang.compile/6 callback is deprecated " <>
+            "The callback should return {:ok, contents, warnings} or {:error, errors, warnings}"
+        )
+
+        {:error, [], [], []}
+    end
+  end
+
+  defp combine_results(result1, result2) do
+    {status1, new_entries1, warnings1, errors1} = result1
+    {status2, new_entries2, warnings2, errors2} = result2
+    status = if status1 == :error or status2 == :error, do: :error, else: :ok
+    {status, new_entries1 ++ new_entries2, warnings1 ++ warnings2, errors1 ++ errors2}
+  end
+
+  defp manifest_warnings(entries) do
+    Enum.flat_map(entries, fn {_, warnings} ->
+      to_diagnostics(warnings, :warning)
+    end)
+  end
+
+  defp to_diagnostics(warnings_or_errors, severity) do
+    for {file, issues} <- warnings_or_errors,
+        file = if(?/ in file, do: Path.absname(file), else: List.to_string(file)),
+        {location, module, data} <- issues do
+      %Mix.Task.Compiler.Diagnostic{
+        file: file,
+        source: file,
+        position: location_normalize(location),
+        message: to_string(module.format_error(data)),
+        severity: severity,
+        compiler_name: to_string(module),
+        details: data
+      }
+    end
+  end
+
+  defp show_warnings(entries) do
+    for {_, warnings} <- entries,
+        {file, issues} <- warnings,
+        {location, module, message} <- issues do
+      message = "#{file}:#{location_to_string(location)} warning: #{module.format_error(message)}"
+
+      IO.puts(:stderr, message)
     end
   end
 
-  defp write_manifest(file, entries) do
-    Path.dirname(file) |> File.mkdir_p!
-    File.write!(file, Enum.join(entries, "\n"))
+  defp location_normalize({line, column})
+       when is_integer(line) and line >= 1 and is_integer(column) and column >= 0,
+       do: {line, column}
+
+  defp location_normalize(line) when is_integer(line) and line >= 1, do: line
+  defp location_normalize(_), do: 0
+
+  defp location_to_string({line, column}), do: "#{line}:#{column}:"
+  defp location_to_string(0), do: ""
+  defp location_to_string(line), do: "#{line}:"
+
+  defp modules_diff(added, changed, removed, timestamp) do
+    %{
+      added: modules_from_paths(added),
+      changed: modules_from_paths(changed),
+      removed: modules_from_paths(removed),
+      timestamp: timestamp
+    }
+  end
+
+  defp modules_from_paths(paths) do
+    Enum.map(paths, &module_from_path/1)
+  end
+
+  defp module_from_path(path) do
+    path |> Path.basename() |> Path.rootname() |> String.to_atom()
   end
 end
diff --git a/lib/mix/lib/mix/compilers/protocol.ex b/lib/mix/lib/mix/compilers/protocol.ex
new file mode 100644
index 00000000000..10154796009
--- /dev/null
+++ b/lib/mix/lib/mix/compilers/protocol.ex
@@ -0,0 +1,239 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Compilers.Protocol do
+  @moduledoc false
+  @manifest "compile.protocols"
+  @manifest_vsn 3
+
+  ## Umbrella handling
+
+  @switches [force: :boolean, verbose: :boolean, consolidate_protocols: :boolean]
+
+  def umbrella(args, res) do
+    config = Mix.Project.config()
+    {opts, _, _} = OptionParser.parse(args, switches: @switches)
+
+    opts =
+      if "--no-protocol-consolidation" in args do
+        # TODO: Deprecate me on Elixir v1.23
+        Keyword.put(opts, :consolidate_protocols, false)
+      else
+        opts ++ Keyword.take(config, [:consolidate_protocols])
+      end
+
+    manifest = manifest()
+    config_mtime = Mix.Project.config_mtime()
+    {old_config_mtime, old_protocols_and_impls} = read_manifest(manifest)
+
+    case status(config_mtime > old_config_mtime, opts) do
+      :off ->
+        res
+
+      :on when res == :noop ->
+        :noop
+
+      on_or_force ->
+        deps_paths =
+          for %{scm: scm, opts: opts} <- Mix.Dep.cached(),
+              not scm.fetchable?(),
+              do: opts[:build]
+
+        protocols_and_impls = Mix.Compilers.Elixir.protocols_and_impls_from_paths(deps_paths)
+
+        case compile(on_or_force == :force, old_protocols_and_impls, protocols_and_impls, opts) do
+          :ok ->
+            write_manifest(manifest, {config_mtime, protocols_and_impls})
+            :ok
+
+          :noop ->
+            res
+        end
+    end
+  end
+
+  defp manifest, do: Path.join(Mix.Project.manifest_path(), @manifest)
+
+  defp read_manifest(manifest) do
+    try do
+      [@manifest_vsn | metadata] = manifest |> File.read!() |> :erlang.binary_to_term()
+      metadata
+    rescue
+      _ ->
+        # If there is no manifest or it is out of date, remove old files
+        clean_consolidated()
+        {0, {%{}, %{}}}
+    end
+  end
+
+  defp write_manifest(manifest, metadata) do
+    File.mkdir_p!(Path.dirname(manifest))
+    manifest_data = :erlang.term_to_binary([@manifest_vsn | metadata], [:compressed])
+    File.write!(manifest, manifest_data)
+  end
+
+  def clean do
+    File.rm(manifest())
+    clean_consolidated()
+  end
+
+  ## General handling
+
+  def status(mtime_changed?, opts) do
+    consolidation_path = Mix.Project.consolidation_path()
+
+    cond do
+      not Keyword.get(opts, :consolidate_protocols, true) ->
+        clean_consolidated()
+        :off
+
+      # We need to reconsolidate all protocols whenever the dependency changes
+      # because we only track protocols from the current app and from local deps.
+      # We are only interested in the compile.lock from config_mtime (which is
+      # a build artifact).
+      not File.exists?(consolidation_path) or mtime_changed? ->
+        :force
+
+      true ->
+        :on
+    end
+  end
+
+  def compile(force?, old_protocols_and_impls, protocols_and_impls, opts) do
+    output = Mix.Project.consolidation_path()
+
+    res =
+      if opts[:force] || force? do
+        clean_consolidated()
+        paths = consolidation_paths()
+
+        paths
+        |> Protocol.extract_protocols()
+        |> consolidate(paths, output, opts)
+      else
+        protocols_and_impls
+        |> diff_manifest(old_protocols_and_impls, output)
+        |> consolidate(consolidation_paths(), output, opts)
+      end
+
+    Code.prepend_path(output)
+    res
+  end
+
+  defp clean_consolidated do
+    File.rm_rf(Mix.Project.consolidation_path())
+  end
+
+  defp consolidation_paths do
+    filter_otp(:code.get_path(), :code.lib_dir())
+  end
+
+  defp filter_otp(paths, otp) do
+    Enum.filter(paths, &(not :lists.prefix(otp, &1)))
+  end
+
+  defp consolidate([], _paths, output, _opts) do
+    File.mkdir_p!(output)
+
+    :noop
+  end
+
+  defp consolidate(protocols, paths, output, opts) do
+    File.mkdir_p!(output)
+
+    protocols
+    |> Enum.uniq()
+    |> Enum.map(&Task.async(fn -> consolidate_each(&1, paths, output, opts) end))
+    |> Enum.map(&Task.await(&1, :infinity))
+
+    :ok
+  end
+
+  defp consolidate_each(protocol, paths, output, opts) do
+    impls = Protocol.extract_impls(protocol, paths)
+    reload(protocol)
+
+    case Protocol.consolidate(protocol, impls) do
+      {:ok, binary} ->
+        File.write!(Path.join(output, "#{Atom.to_string(protocol)}.beam"), binary)
+
+        if opts[:verbose] do
+          Mix.shell().info("Consolidated #{inspect_protocol(protocol)}")
+        end
+
+      # If we remove a dependency and we have implemented one of its
+      # protocols locally, we will mark the protocol as needing to be
+      # reconsolidated when the implementation is removed even though
+      # the protocol no longer exists. Although most times removing a
+      # dependency will trigger a full recompilation, such won't happen
+      # in umbrella apps with shared build.
+      {:error, :no_beam_info} ->
+        remove_consolidated(protocol, output)
+
+        if opts[:verbose] do
+          Mix.shell().info("Unavailable #{inspect_protocol(protocol)}")
+        end
+    end
+  end
+
+  # We cannot use the inspect protocol while consolidating
+  # since inspect may not be available.
+  defp inspect_protocol(protocol) do
+    Macro.inspect_atom(:literal, protocol)
+  end
+
+  defp reload(module) do
+    :code.purge(module)
+    :code.delete(module)
+  end
+
+  defp diff_manifest({new_protocols, new_impls}, {old_protocols, old_impls}, output) do
+    protocols =
+      new_protocols
+      |> Enum.filter(fn {protocol, new_timestamp} ->
+        case old_protocols do
+          # There is a new version, removed the consolidated
+          %{^protocol => old_timestamp} when new_timestamp > old_timestamp ->
+            remove_consolidated(protocol, output)
+            true
+
+          # Nothing changed
+          %{^protocol => _} ->
+            false
+
+          # New protocol
+          %{} ->
+            true
+        end
+      end)
+      |> Map.new()
+
+    protocols =
+      for {impl, protocol} <- new_impls,
+          not is_map_key(old_impls, impl),
+          do: {protocol, true},
+          into: protocols
+
+    removed_protocols =
+      for {protocol, _timestamp} <- old_protocols,
+          not is_map_key(new_protocols, protocol),
+          do: remove_consolidated(protocol, output)
+
+    removed_protocols = Map.from_keys(removed_protocols, true)
+
+    protocols =
+      for {impl, protocol} <- old_impls,
+          not is_map_key(new_impls, impl),
+          not is_map_key(removed_protocols, protocol),
+          do: {protocol, true},
+          into: protocols
+
+    Map.keys(protocols)
+  end
+
+  defp remove_consolidated(protocol, output) do
+    File.rm(Path.join(output, "#{Atom.to_string(protocol)}.beam"))
+    protocol
+  end
+end
diff --git a/lib/mix/lib/mix/compilers/test.ex b/lib/mix/lib/mix/compilers/test.ex
new file mode 100644
index 00000000000..78eeb8c9b5b
--- /dev/null
+++ b/lib/mix/lib/mix/compilers/test.ex
@@ -0,0 +1,338 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Compilers.Test do
+  @moduledoc false
+
+  require Mix.Compilers.Elixir, as: CE
+
+  import Record
+
+  defrecordp :source,
+    compile_references: [],
+    runtime_references: [],
+    external: []
+
+  # Necessary to avoid warnings during bootstrap
+  @compile {:no_warn_undefined, ExUnit}
+  @stale_manifest "compile.test_stale"
+  @manifest_vsn 2
+
+  @doc """
+  Requires and runs test files.
+
+  It expects all of the test patterns, the test files that were matched for the
+  test patterns, the test paths, and the opts from the test task.
+  """
+  def require_and_run(matched_test_files, test_paths, elixirc_opts, opts) do
+    elixirc_opts =
+      Keyword.merge([docs: false, debug_info: false, infer_signatures: false], elixirc_opts)
+
+    previous_opts = Code.compiler_options(elixirc_opts)
+
+    try do
+      require_and_run(matched_test_files, test_paths, opts)
+    after
+      Code.compiler_options(previous_opts)
+    end
+  end
+
+  defp require_and_run(matched_test_files, test_paths, opts) do
+    dry_run = Keyword.get(opts, :dry_run, false)
+    stale = Keyword.get(opts, :stale, false)
+    max_requires = opts[:max_requires]
+
+    {test_files, stale_manifest_pid, parallel_require_callbacks} =
+      if stale and not dry_run do
+        set_up_stale(matched_test_files, test_paths, opts)
+      else
+        {matched_test_files, nil, []}
+      end
+
+    shared_require_options =
+      if max_requires do
+        [max_concurrency: max_requires, return_diagnostics: true]
+      else
+        [return_diagnostics: true]
+      end
+
+    Application.ensure_all_started(:ex_unit)
+
+    cond do
+      test_files == [] ->
+        # Make sure we run the after_suite callbacks but with no feedback
+        formatters = Application.fetch_env!(:ex_unit, :formatters)
+
+        try do
+          Application.put_env(:ex_unit, :formatters, [])
+          _ = ExUnit.run()
+          :noop
+        after
+          Application.put_env(:ex_unit, :formatters, formatters)
+        end
+
+      Keyword.get(opts, :profile_require) == "time" ->
+        Kernel.ParallelCompiler.require(test_files, [profile: :time] ++ shared_require_options)
+        :noop
+
+      true ->
+        task = ExUnit.async_run()
+        seed = Application.fetch_env!(:ex_unit, :seed)
+        rand_algorithm = Application.fetch_env!(:ex_unit, :rand_algorithm)
+        test_files = shuffle(seed, rand_algorithm, test_files)
+
+        try do
+          parallel_require_options = shared_require_options ++ parallel_require_callbacks
+
+          warnings? =
+            case Kernel.ParallelCompiler.require(test_files, parallel_require_options) do
+              {:ok, _, %{compile_warnings: c, runtime_warnings: r}}
+              when c != [] or r != [] ->
+                true
+
+              {:ok, _, _} ->
+                false
+
+              {:error, _, _} ->
+                exit({:shutdown, 1})
+            end
+
+          %{failures: failures} = results = ExUnit.await_run(task)
+
+          if failures == 0 do
+            agent_write_manifest(stale_manifest_pid)
+          end
+
+          {:ok, Map.put(results, :warnings?, warnings?)}
+        catch
+          kind, reason ->
+            # In case there is an error, shut down the runner task
+            # before the error propagates up and trigger links.
+            Task.shutdown(task)
+            :erlang.raise(kind, reason, __STACKTRACE__)
+        after
+          agent_stop(stale_manifest_pid)
+        end
+    end
+  end
+
+  defp set_up_stale(matched_test_files, test_paths, opts) do
+    manifest = manifest()
+    modified = Mix.Utils.last_modified(manifest)
+    test_sources = read_manifest()
+
+    removed =
+      for {source, _} <- test_sources, source not in matched_test_files, do: source
+
+    test_helpers = Enum.map(test_paths, &Path.join(&1, "test_helper.exs"))
+    sources = [Mix.Project.config_mtime(), Mix.Project.project_file() | test_helpers]
+    force = opts[:force] || Mix.Utils.stale?(sources, [modified])
+
+    changed =
+      if force do
+        # Let's just require everything
+        matched_test_files
+      else
+        sources_mtimes = mtimes(test_sources)
+
+        # Otherwise let's start with the new sources
+        # Plus the sources that have changed in disk
+        for(
+          source <- matched_test_files,
+          not is_map_key(test_sources, source),
+          do: source
+        ) ++
+          for(
+            {source, source(external: external)} <- test_sources,
+            times = Enum.map([source | external], &Map.fetch!(sources_mtimes, &1)),
+            Mix.Utils.stale?(times, [modified]),
+            do: source
+          )
+      end
+
+    stale = MapSet.new(changed -- removed)
+    sources = update_stale_sources(test_sources, removed, changed)
+
+    test_files_to_run =
+      sources
+      |> tests_with_changed_references()
+      |> MapSet.union(stale)
+      |> MapSet.to_list()
+
+    if test_files_to_run == [] do
+      write_manifest(sources)
+      {[], nil, nil}
+    else
+      {:ok, pid} = Agent.start_link(fn -> sources end)
+      cwd = File.cwd!()
+
+      parallel_require_callbacks = [
+        each_module: &each_module(pid, cwd, &1, &2, &3),
+        each_file: &each_file(pid, cwd, &1, &2)
+      ]
+
+      {test_files_to_run, pid, parallel_require_callbacks}
+    end
+  end
+
+  defp agent_write_manifest(nil), do: :noop
+
+  defp agent_write_manifest(pid) do
+    Agent.cast(pid, fn sources ->
+      write_manifest(sources)
+      sources
+    end)
+  end
+
+  defp agent_stop(nil), do: :noop
+
+  defp agent_stop(pid) do
+    Agent.stop(pid, :normal, :infinity)
+  end
+
+  ## Setup helpers
+
+  defp mtimes(sources) do
+    Enum.reduce(sources, %{}, fn {source, source(external: external)}, map ->
+      Enum.reduce([source | external], map, fn file, map ->
+        Map.put_new_lazy(map, file, fn -> Mix.Utils.last_modified(file) end)
+      end)
+    end)
+  end
+
+  defp update_stale_sources(sources, removed, changed) do
+    sources = Map.drop(sources, removed)
+    sources = Enum.reduce(changed, sources, &Map.put(&2, &1, source()))
+    sources
+  end
+
+  ## Manifest
+
+  defp manifest, do: Path.join(Mix.Project.manifest_path(), @stale_manifest)
+
+  defp read_manifest() do
+    try do
+      [@manifest_vsn | sources] = manifest() |> File.read!() |> :erlang.binary_to_term()
+      sources
+    rescue
+      _ -> %{}
+    end
+  end
+
+  defp write_manifest(test_sources) when test_sources == %{} do
+    File.rm(manifest())
+    :ok
+  end
+
+  defp write_manifest(test_sources = %{}) do
+    manifest = manifest()
+    File.mkdir_p!(Path.dirname(manifest))
+
+    manifest_data = :erlang.term_to_binary([@manifest_vsn | test_sources], [:compressed])
+    File.write!(manifest, manifest_data)
+  end
+
+  ## Test changed dependency resolution
+
+  defp tests_with_changed_references(test_sources) do
+    test_manifest = manifest()
+    [elixir_manifest] = Mix.Tasks.Compile.Elixir.manifests()
+
+    if Mix.Utils.stale?([elixir_manifest], [test_manifest]) do
+      compile_path = Mix.Project.compile_path()
+      {elixir_modules, elixir_sources} = CE.read_manifest(elixir_manifest)
+
+      stale_modules =
+        for {module, _} <- elixir_modules,
+            beam = Path.join(compile_path, Atom.to_string(module) <> ".beam"),
+            Mix.Utils.stale?([beam], [test_manifest]),
+            do: module,
+            into: MapSet.new()
+
+      stale_modules = find_all_dependent_on(stale_modules, elixir_modules, elixir_sources)
+
+      for {source, source(runtime_references: r, compile_references: c)} <- test_sources,
+          Enum.any?(r, &(&1 in stale_modules)) or Enum.any?(c, &(&1 in stale_modules)),
+          do: source,
+          into: MapSet.new()
+    else
+      MapSet.new()
+    end
+  end
+
+  defp find_all_dependent_on(modules, elixir_modules, elixir_sources, resolved \\ MapSet.new()) do
+    new_modules =
+      for module <- modules,
+          module not in resolved,
+          dependent_module <- dependent_modules(module, elixir_modules, elixir_sources),
+          do: dependent_module,
+          into: modules
+
+    if MapSet.size(new_modules) == MapSet.size(modules) do
+      new_modules
+    else
+      find_all_dependent_on(new_modules, elixir_modules, elixir_sources, modules)
+    end
+  end
+
+  defp dependent_modules(module, modules, sources) do
+    for {source,
+         CE.source(
+           runtime_references: r,
+           compile_references: c,
+           export_references: e
+         )} <- sources,
+        module in r or module in c or module in e,
+        {dependent_module, CE.module(sources: sources)} <- modules,
+        source in sources,
+        do: dependent_module
+  end
+
+  ## ParallelRequire callback
+
+  defp each_module(pid, cwd, file, module, _binary) do
+    external = get_external_resources(module, cwd)
+
+    if external != [] do
+      Agent.update(pid, fn sources ->
+        file = Path.relative_to(file, cwd)
+        source(external: current_external) = source = Map.fetch!(sources, file)
+        Map.put(sources, file, source(source, external: external ++ current_external))
+      end)
+    end
+
+    :ok
+  end
+
+  defp each_file(pid, cwd, file, lexical) do
+    Agent.update(pid, fn sources ->
+      file = Path.relative_to(file, cwd)
+
+      {compile_references, export_references, runtime_references, _compile_env} =
+        Kernel.LexicalTracker.references(lexical)
+
+      source =
+        source(
+          Map.fetch!(sources, file),
+          compile_references: compile_references ++ export_references,
+          runtime_references: runtime_references
+        )
+
+      Map.put(sources, file, source)
+    end)
+  end
+
+  defp get_external_resources(module, cwd) do
+    for file <- Module.get_attribute(module, :external_resource), do: Path.relative_to(file, cwd)
+  end
+
+  defp shuffle(_seed = 0, _rand_algorithm, list) do
+    list
+  end
+
+  defp shuffle(seed, rand_algorithm, list) do
+    _ = :rand.seed(rand_algorithm, {seed, seed, seed})
+    Enum.shuffle(list)
+  end
+end
diff --git a/lib/mix/lib/mix/config.ex b/lib/mix/lib/mix/config.ex
index 0586997f2af..5690df1bc1c 100644
--- a/lib/mix/lib/mix/config.ex
+++ b/lib/mix/lib/mix/config.ex
@@ -1,160 +1,93 @@
-defmodule Mix.Config do
-  @moduledoc ~S"""
-  Module for defining, reading and merging app configurations.
-
-  Most commonly, this module is used to define your own configuration:
-
-      use Mix.Config
-
-      config :plug,
-        key1: "value1",
-        key2: "value2"
-
-      import_config "#{Mix.env}.exs"
-
-  All `config/*` macros, including `import_config/1`, are used
-  to help define such configuration files.
-
-  Furthermore, this module provides functions like `read!/1`,
-  `merge/2` and friends which help manipulate configurations
-  in general.
-  """
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-  defmodule LoadError do
-    defexception [:file, :error]
-
-    def message(%LoadError{file: file, error: error}) do
-      "could not load config #{Path.relative_to_cwd(file)}\n    " <>
-        "#{Exception.format_banner(:error, error)}"
-    end
-  end
+defmodule Mix.Config do
+  @moduledoc false
+  @moduledoc deprecated: "Use the Config module instead"
 
-  @doc false
+  @deprecated "Use the Config module instead"
   defmacro __using__(_) do
     quote do
       import Mix.Config, only: [config: 2, config: 3, import_config: 1]
-      var!(config, Mix.Config) = []
     end
   end
 
-  @doc """
-  Configures the given application.
-
-  ## Examples
-
-  The given `opts` are merged into the existing configuration
-  for the given `app`. Conflicting keys are overridden by the
-  ones specified in `opts`. For example, the declaration below:
+  @deprecated "Use the Config module instead"
+  defdelegate config(root_key, opts), to: Config
 
-      config :lager,
-        log_level: :warn,
-        mode: :truncate
+  @deprecated "Use the Config module instead"
+  defdelegate config(root_key, key, opts), to: Config
 
-      config :lager,
-        log_level: :info,
-        threshold: 1024
-
-  Will have a final configuration of:
-
-      [log_level: :info, mode: :truncate, threshold: 1024]
-
-  """
-  defmacro config(app, opts) do
+  @deprecated "Use the Config module instead"
+  defmacro import_config(path_or_wildcard) do
     quote do
-      var!(config, Mix.Config) =
-        Mix.Config.merge(var!(config, Mix.Config), [{unquote(app), unquote(opts)}])
+      Mix.Config.__import__!(unquote(path_or_wildcard), __DIR__)
     end
   end
 
-  @doc """
-  Configures the given key for the given application.
-
-  ## Examples
-
-  The given `opts` are merged into the existing values for `key`
-  in the given `app`. Conflicting keys are overridden by the
-  ones specified in `opts`. For example, the declaration below:
-
-      config :ecto, Repo,
-        log_level: :warn
-
-      config :ecto, Repo,
-        log_level: :info,
-        pool_size: 10
-
-  Will have a final value for `Repo` of:
-
-      [log_level: :info, pool_size: 10]
-
-  """
-  defmacro config(app, key, opts) do
-    quote do
-      var!(config, Mix.Config) =
-        Mix.Config.merge(var!(config, Mix.Config),
-                         [{unquote(app), [{unquote(key), unquote(opts)}]}],
-                         fn _app, _key, v1, v2 -> Keyword.merge(v1, v2) end)
+  @doc false
+  def __import__!(path_or_wildcard, dir) do
+    path_or_wildcard = Path.expand(path_or_wildcard, dir)
+
+    paths =
+      if String.contains?(path_or_wildcard, ~w(* ? [ {)) do
+        Path.wildcard(path_or_wildcard)
+      else
+        [path_or_wildcard]
+      end
+
+    for path <- paths do
+      Config.__import__!(path)
     end
-  end
-
-  @doc ~S"""
-  Imports configuration from the given file.
 
-  The path is expected to be related to the directory the
-  current configuration file is on.
-
-  ## Examples
-
-  This is often used to emulate configuration across environments:
-
-      import_config "#{Mix.env}.exs"
+    :ok
+  end
 
-  Or to import files from children in umbrella projects:
+  ## Mix API
 
-      import_config "../apps/child/config/config.exs"
+  @deprecated "Use Config.Reader.read_imports!/2 instead"
+  def eval!(file, imported_paths \\ []) do
+    Config.Reader.read_imports!(file,
+      imports: imported_paths,
+      env: Mix.env(),
+      target: Mix.target()
+    )
+  end
 
-  """
-  defmacro import_config(file) do
-    quote do
-      var!(config, Mix.Config) =
-        Mix.Config.merge(var!(config, Mix.Config),
-                         Mix.Config.read!(Path.expand(unquote(file), __DIR__)))
-    end
+  @deprecated "Use Config.Reader.read!/2 instead"
+  def read!(file, imported_paths \\ []) do
+    Config.Reader.read!(file, imports: imported_paths, env: Mix.env(), target: Mix.target())
   end
 
-  @doc """
-  Reads and validates a configuration file.
-  """
-  def read!(file) do
-    try do
-      {config, binding} = Code.eval_file(file)
-      config =
-        case List.keyfind(binding, {:config, Mix.Config}, 0) do
-          {_, value} -> value
-          nil -> config
-        end
-      validate!(config)
-      config
-    rescue
-      e in [LoadError] -> reraise(e, System.stacktrace)
-      e -> raise LoadError, file: file, error: e
-    end
+  @deprecated "Use Config.Reader.merge/2 instead"
+  def merge(config1, config2) do
+    Config.__merge__(config1, config2)
   end
 
-  @doc """
-  Persists the given configuration by modifying
-  the configured applications environment.
-  """
+  @deprecated "Use Application.put_all_env/2 instead"
   def persist(config) do
-    for {app, kw} <- config, {k, v} <- kw do
-      :application.set_env(app, k, v, persistent: true)
-    end
-    :ok
+    Application.put_all_env(config, persistent: true)
+  end
+
+  @deprecated "Use the Config.Reader module instead"
+  def read_wildcard!(path, loaded_paths \\ []) do
+    paths =
+      if String.contains?(path, ~w(* ? [ {)) do
+        Path.wildcard(path)
+      else
+        [path]
+      end
+
+    Enum.reduce(paths, [], &merge(&2, read!(&1, loaded_paths)))
   end
 
-  @doc """
-  Validates a configuration.
-  """
+  @deprecated "Manually validate the data instead"
   def validate!(config) do
+    validate!(config, "runtime")
+  end
+
+  defp validate!(config, file) do
     if is_list(config) do
       Enum.all?(config, fn
         {app, value} when is_atom(app) ->
@@ -162,63 +95,19 @@ defmodule Mix.Config do
             true
           else
             raise ArgumentError,
-              "expected config for app #{inspect app} to return keyword list, got: #{inspect value}"
+                  "expected #{Path.relative_to_cwd(file)} config for app #{inspect(app)} " <>
+                    "to return keyword list, got: #{inspect(value)}"
           end
+
         _ ->
           false
       end)
     else
       raise ArgumentError,
-        "expected config file to return keyword list, got: #{inspect config}"
+            "expected #{Path.relative_to_cwd(file)} config to return " <>
+              "keyword list, got: #{inspect(config)}"
     end
-  end
-
-  @doc """
-  Merges two configurations.
-
-  The configuration of each application is merged together
-  with the values in the second one having higher preference
-  than the first in case of conflicts.
 
-  ## Examples
-
-      iex> Mix.Config.merge([app: [k: :v1]], [app: [k: :v2]])
-      [app: [k: :v2]]
-
-      iex> Mix.Config.merge([app1: []], [app2: []])
-      [app1: [], app2: []]
-
-  """
-  def merge(config1, config2) do
-    Keyword.merge(config1, config2, fn _, app1, app2 ->
-      Keyword.merge(app1, app2)
-    end)
-  end
-
-  @doc """
-  Merges two configurations.
-
-  The configuration of each application is merged together
-  and a callback is invoked in case of conflicts receiving
-  the app, the conflicting key and both values. It must return
-  a value that will be used as part of the conflict resolution.
-
-  ## Examples
-
-      iex> Mix.Config.merge([app: [k: :v1]], [app: [k: :v2]],
-      ...>   fn app, k, v1, v2 -> {app, k, v1, v2} end)
-      [app: [k: {:app, :k, :v1, :v2}]]
-
-  """
-  def merge(config1, config2, callback) do
-    Keyword.merge(config1, config2, fn app, app1, app2 ->
-      Keyword.merge(app1, app2, fn k, v1, v2 ->
-        if v1 == v2 do
-          v1
-        else
-          callback.(app, k, v1, v2)
-        end
-      end)
-    end)
+    config
   end
 end
diff --git a/lib/mix/lib/mix/dep.ex b/lib/mix/lib/mix/dep.ex
index 7848fa2cfa8..96acd4e4fcb 100644
--- a/lib/mix/lib/mix/dep.ex
+++ b/lib/mix/lib/mix/dep.ex
@@ -1,8 +1,13 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Dep do
   @moduledoc false
 
   @doc """
-  The Mix.Dep a struct keeps information about your project dependencies.
+  The Mix.Dep struct keeps information about your project dependencies.
+
   It contains:
 
     * `scm` - a module representing the source code management tool (SCM)
@@ -10,10 +15,10 @@ defmodule Mix.Dep do
 
     * `app` - the application name as an atom
 
-    * `requirement` - a binary or regex with the dependency's requirement
+    * `requirement` - a binary or regular expression with the dependency's requirement
 
     * `status` - the current status of the dependency, check
-      `Mix.Dep.format_status/1` for more info
+      `Mix.Dep.format_status/1` for more information
 
     * `opts` - the options given by the developer
 
@@ -22,7 +27,7 @@ defmodule Mix.Dep do
     * `top_level` - true if dependency was defined in the top-level project
 
     * `manager` - the project management, possible values:
-      `:rebar` | `:mix` | `:make` | `nil`
+      `:rebar3` | `:mix` | `:make` | `nil`
 
     * `from` - path to the file where the dependency was defined
 
@@ -30,6 +35,9 @@ defmodule Mix.Dep do
       the information on this field is private to the manager and should not be
       relied on
 
+    * `system_env` - an enumerable of key-value tuples of binaries to be set as environment variables
+      when loading or compiling the dependency
+
   A dependency is in two specific states: loaded and unloaded.
 
   When a dependency is unloaded, it means Mix only parsed its specification
@@ -46,80 +54,224 @@ defmodule Mix.Dep do
     * `:build` - the build path for the dependency
 
   """
-  defstruct scm: nil, app: nil, requirement: nil, status: nil, opts: [],
-            deps: [], top_level: false, extra: [], manager: nil, from: nil
+  defstruct scm: nil,
+            app: nil,
+            requirement: nil,
+            status: nil,
+            opts: [],
+            deps: [],
+            top_level: false,
+            extra: [],
+            manager: nil,
+            from: nil,
+            system_env: []
+
+  @type t :: %__MODULE__{
+          scm: Mix.SCM.t(),
+          app: atom,
+          requirement: String.t() | Regex.t() | nil,
+          status: {:ok, String.t() | nil} | atom | tuple,
+          opts: keyword,
+          top_level: boolean,
+          manager: :rebar3 | :mix | :make | nil,
+          from: String.t(),
+          extra: term,
+          system_env: keyword
+        }
 
   @doc """
-  Returns all children dependencies for the current project,
-  as well as the defined apps in case of umbrella projects.
-  The children dependencies returned by this function were
-  not loaded yet.
+  Returns loaded dependencies from the cache for the current environment.
 
-  ## Exceptions
+  If dependencies have not been cached yet, they are loaded
+  and then cached.
 
-  This function raises an exception if any of the dependencies
-  provided in the project are in the wrong format.
+  Because the dependencies are cached during deps.loadpaths,
+  their status may be outdated (for example, `:compile` did not
+  yet become `:ok`). Therefore it is recommended to not rely
+  on their status, also given they haven't been checked
+  against the lock.
   """
-  defdelegate children(otps), to: Mix.Dep.Loader
+  def cached() do
+    if project = Mix.Project.get() do
+      read_cached_deps(project, {Mix.env(), Mix.target()}) || load_and_cache()
+    else
+      load_and_cache()
+    end
+  end
 
   @doc """
-  Returns loaded dependencies recursively as a `Mix.Dep` struct.
+  Returns loaded dependencies recursively and caches it.
+
+  The result is cached for future `cached/0` calls.
 
   ## Exceptions
 
   This function raises an exception if any of the dependencies
   provided in the project are in the wrong format.
   """
-  def loaded(opts) do
-    Mix.Dep.Converger.converge(nil, nil, opts, &{&1, &2, &3}) |> elem(0)
+  def load_and_cache() do
+    env = Mix.env()
+    target = Mix.target()
+
+    case Mix.ProjectStack.top_and_bottom() do
+      {%{name: top, config: config}, %{name: bottom}} ->
+        write_cached_deps(top, {env, target}, load_and_cache(config, top, bottom, env, target))
+
+      _ ->
+        converge_and_load(env: env, target: target)
+    end
   end
 
-  @doc """
-  Receives a list of dependency names and returns loaded `Mix.Dep`s.
-  Logs a message if the dependency could not be found.
+  defp load_and_cache(_config, top, top, env, target) do
+    converge_and_load(env: env, target: target)
+  end
 
-  ## Exceptions
+  defp load_and_cache(config, _top, bottom, _env, _target) do
+    {_, deps} =
+      Mix.State.read_cache({:cached_deps, bottom}) ||
+        raise "cannot retrieve dependencies information because dependencies were not loaded. " <>
+                "Please invoke one of \"deps.loadpaths\", \"loadpaths\", or \"compile\" Mix task"
+
+    app = Keyword.fetch!(config, :app)
+    seen = populate_seen(MapSet.new(), [app])
+    children = get_deps(deps, tl(Enum.uniq(get_children(deps, seen, [app]))))
+
+    top_level =
+      for dep <- deps,
+          dep.app == app,
+          child <- dep.deps,
+          do: {child.app, Keyword.get(child.opts, :optional, false)},
+          into: %{}
+
+    Enum.map(children, fn %{app: app, opts: opts} = dep ->
+      # optional only matters at the top level. Any non-top level dependency
+      # that is optional and is still available means it has been fulfilled.
+      case top_level do
+        %{^app => optional} ->
+          %{dep | top_level: true, opts: Keyword.put(opts, :optional, optional)}
+
+        %{} ->
+          %{dep | top_level: false, opts: Keyword.delete(opts, :optional)}
+      end
+    end)
+  end
 
-  This function raises an exception if any of the dependencies
-  provided in the project are in the wrong format.
+  defp converge_and_load(opts) do
+    for %{app: app, opts: opts} = dep <- Mix.Dep.Converger.converge(opts) do
+      case Keyword.pop(opts, :app_properties) do
+        {nil, _opts} ->
+          dep
+
+        {app_properties, opts} ->
+          # We don't raise because child dependencies may be missing if manually cleaned
+          :application.load({:application, app, app_properties})
+          %{dep | opts: opts}
+      end
+    end
+  end
+
+  defp read_cached_deps(project, env_target) do
+    case Mix.State.read_cache({:cached_deps, project}) do
+      {^env_target, deps} -> deps
+      _ -> nil
+    end
+  end
+
+  defp write_cached_deps(project, env_target, deps) do
+    Mix.State.write_cache({:cached_deps, project}, {env_target, deps})
+    deps
+  end
+
+  @doc """
+  Clears loaded dependencies from the cache for the current environment.
   """
-  def loaded_by_name(given, all_deps \\ nil, opts) do
-    all_deps = all_deps || loaded(opts)
+  def clear_cached() do
+    if project = Mix.Project.get() do
+      key = {:cached_deps, project}
+      Mix.State.delete_cache(key)
+    end
+  end
+
+  @doc """
+  Filters the given dependencies by name.
 
+  Raises if any of the names are missing.
+  """
+  def filter_by_name(given, all_deps, opts \\ []) do
     # Ensure all apps are atoms
     apps = to_app_names(given)
 
-    # We need to keep the order of deps, loaded/1 properly orders them
-    deps = Enum.filter(all_deps, &(&1.app in apps))
+    deps =
+      if opts[:include_children] do
+        seen = populate_seen(MapSet.new(), apps)
+        get_deps(all_deps, Enum.uniq(get_children(all_deps, seen, apps)))
+      else
+        get_deps(all_deps, apps)
+      end
 
-    Enum.each apps, fn(app) ->
-      unless Enum.any?(all_deps, &(&1.app == app)) do
-        Mix.raise "Unknown dependency #{app} for environment #{Mix.env}"
+    Enum.each(apps, fn app ->
+      if not Enum.any?(all_deps, &(&1.app == app)) do
+        Mix.raise("Unknown dependency #{app} for environment #{Mix.env()}")
       end
-    end
+    end)
 
     deps
   end
 
+  defp get_deps(all_deps, apps) do
+    Enum.filter(all_deps, &(&1.app in apps))
+  end
+
+  defp get_children(_all_deps, _seen, []), do: []
+
+  defp get_children(all_deps, seen, apps) do
+    children_apps =
+      for %{deps: children} <- get_deps(all_deps, apps),
+          %{app: app} <- children,
+          app not in seen,
+          do: app
+
+    apps ++ get_children(all_deps, populate_seen(seen, children_apps), children_apps)
+  end
+
+  defp populate_seen(seen, apps) do
+    Enum.reduce(apps, seen, &MapSet.put(&2, &1))
+  end
+
   @doc """
   Runs the given `fun` inside the given dependency project by
   changing the current working directory and loading the given
   project onto the project stack.
 
-  It is expected a loaded dependency as argument.
+  It expects a loaded dependency as argument.
   """
   def in_dependency(dep, post_config \\ [], fun)
 
-  def in_dependency(%Mix.Dep{app: app, opts: opts}, config, fun) do
-    # Set the app_path to be the one stored in the dependency.
+  def in_dependency(%Mix.Dep{app: app, opts: opts, scm: scm}, config, fun) do
+    # Set the deps_app_path to be the one stored in the dependency.
     # This is important because the name of application in the
     # mix.exs file can be different than the actual name and we
     # choose to respect the one in the mix.exs
-    config = Keyword.merge(Mix.Project.deps_config, config)
-    config = Keyword.put(config, :app_path, opts[:build])
+    config =
+      Mix.Project.deps_config()
+      |> Keyword.merge(config)
+      |> Keyword.put(:build_scm, scm)
+      |> Keyword.put(:deps_app_path, opts[:build])
+
+    config =
+      if scm.fetchable?() do
+        # If the dependency is fetchable, we want to store the lock in
+        # the Elixir SCM file.
+        [deps_lock: opts[:lock]] ++ config
+      else
+        # If the dependency is not fetchable, then it is never compiled
+        # from scratch and therefore it needs the parent configuration
+        # files to know when to recompile.
+        [inherit_parent_config_files: true] ++ config
+      end
 
     env = opts[:env] || :prod
-    old_env = Mix.env
+    old_env = Mix.env()
 
     try do
       Mix.env(env)
@@ -132,114 +284,232 @@ defmodule Mix.Dep do
   @doc """
   Formats the status of a dependency.
   """
-  def format_status(%Mix.Dep{status: {:ok, _vsn}}),
-    do: "ok"
+  def format_status(%Mix.Dep{status: {:ok, _vsn}}) do
+    "ok"
+  end
 
-  def format_status(%Mix.Dep{status: {:noappfile, path}}),
-    do: "could not find an app file at #{Path.relative_to_cwd(path)}, " <>
-        "this may happen when you specified the wrong application name in your deps " <>
-        "or if the dependency did not compile (which can be amended with `#{mix_env_var}mix deps.compile`)"
+  def format_status(%Mix.Dep{status: {:noappfile, {path, nil}}}) do
+    "could not find an app file at #{inspect(Path.relative_to_cwd(path))}. " <>
+      "This may happen if the dependency was not yet compiled " <>
+      "or the dependency indeed has no app file (then you can pass app: false as option)"
+  end
 
-  def format_status(%Mix.Dep{status: {:invalidapp, path}}),
-    do: "the app file at #{Path.relative_to_cwd(path)} is invalid"
+  def format_status(%Mix.Dep{status: {:noappfile, {path, other_path}}}) do
+    other_app = Path.rootname(Path.basename(other_path))
 
-  def format_status(%Mix.Dep{status: {:invalidvsn, vsn}}),
-    do: "the app file contains an invalid version: #{inspect vsn}"
+    "could not find an app file at #{inspect(Path.relative_to_cwd(path))}. " <>
+      "Another app file was found in the same directory " <>
+      "#{inspect(Path.relative_to_cwd(other_path))}, " <>
+      "try changing the dependency name to :#{other_app}"
+  end
 
-  def format_status(%Mix.Dep{status: {:nomatchvsn, vsn}, requirement: req}),
-    do: "the dependency does not match the requirement #{inspect req}, got #{inspect vsn}"
+  def format_status(%Mix.Dep{status: {:invalidapp, path}}) do
+    "the app file at #{inspect(Path.relative_to_cwd(path))} is invalid"
+  end
 
-  def format_status(%Mix.Dep{status: {:lockmismatch, _}}),
-    do: "lock mismatch: the dependency is out of date"
+  def format_status(%Mix.Dep{status: {:invalidvsn, vsn}}) do
+    "the app file contains an invalid version: #{inspect(vsn)}"
+  end
 
-  def format_status(%Mix.Dep{status: :lockoutdated}),
-    do: "lock outdated: the lock is outdated compared to the options in your mixfile"
+  def format_status(%Mix.Dep{status: {:nosemver, vsn}, requirement: req}) do
+    "the app file specified a non-Semantic Versioning format: #{inspect(vsn)}. Mix can only match the " <>
+      "requirement #{inspect(req)} against semantic versions. Please fix the application version " <>
+      "or use a regular expression as a requirement to match against any version"
+  end
 
-  def format_status(%Mix.Dep{status: :nolock}),
-    do: "the dependency is not locked"
+  def format_status(%Mix.Dep{status: {:nomatchvsn, vsn}, requirement: req}) do
+    "the dependency does not match the requirement #{inspect(req)}, got #{inspect(vsn)}"
+  end
 
-  def format_status(%Mix.Dep{status: :compile}),
-    do: "the dependency build is outdated, please run `#{mix_env_var}mix deps.compile`"
+  def format_status(%Mix.Dep{status: {:lockmismatch, _}}) do
+    "lock mismatch: the dependency is out of date. To fetch locked version run \"mix deps.get\""
+  end
+
+  def format_status(%Mix.Dep{status: :lockoutdated}) do
+    "lock outdated: the lock is outdated compared to the options in your mix.exs. To fetch " <>
+      "locked version run \"mix deps.get\""
+  end
+
+  def format_status(%Mix.Dep{status: :nolock}) do
+    "the dependency is not locked. To generate the \"mix.lock\" file run \"mix deps.get\""
+  end
+
+  def format_status(%Mix.Dep{status: :compile}) do
+    "the dependency build is outdated, please run \"#{mix_env_var()}mix deps.compile\""
+  end
+
+  def format_status(%Mix.Dep{app: app, status: {:divergedreq, vsn, other}} = dep) do
+    "the dependency #{app} #{vsn}\n" <>
+      dep_status(dep) <>
+      "\n  does not match the requirement specified\n" <>
+      dep_status(other) <>
+      "\n  Ensure they match or specify one of the above in your deps and set \"override: true\""
+  end
+
+  def format_status(%Mix.Dep{app: app, status: {:divergedonly, other}} = dep) do
+    recommendation =
+      if Keyword.has_key?(other.opts, :only) do
+        "Ensure you specify at least the same environments in :only in your dep"
+      else
+        "Remove the :only restriction from your dep"
+      end
+
+    "the :only option for dependency #{app}\n" <>
+      dep_status(dep) <>
+      "\n  does not match the :only option calculated for\n" <>
+      dep_status(other) <> "\n  #{recommendation}"
+  end
+
+  def format_status(%Mix.Dep{app: app, status: {:divergedtargets, other}} = dep) do
+    recommendation =
+      if Keyword.has_key?(other.opts, :targets) do
+        "Ensure you specify at least the same targets in :targets in your dep"
+      else
+        "Remove the :targets restriction from your dep"
+      end
 
-  def format_status(%Mix.Dep{app: app, status: {:divergedreq, other}} = dep) do
-    "the dependency #{app} defined\n" <>
-    "#{dep_status(dep)}" <>
-    "\n  does not match the requirement specified\n" <>
-    "#{dep_status(other)}" <>
-    "\n  Ensure they match or specify one of the above in your #{inspect Mix.Project.get} deps and set `override: true`"
+    "the :targets option for dependency #{app}\n" <>
+      dep_status(dep) <>
+      "\n  does not match the :targets option calculated for\n" <>
+      dep_status(other) <> "\n  #{recommendation}"
   end
 
   def format_status(%Mix.Dep{app: app, status: {:diverged, other}} = dep) do
     "different specs were given for the #{app} app:\n" <>
-    "#{dep_status(dep)}#{dep_status(other)}" <>
-    "\n  Ensure they match or specify one of the above in your #{inspect Mix.Project.get} deps and set `override: true`"
+      "#{dep_status(dep)}#{dep_status(other)}\n  " <> override_diverge_recommendation(dep, other)
   end
 
   def format_status(%Mix.Dep{app: app, status: {:overridden, other}} = dep) do
     "the dependency #{app} in #{Path.relative_to_cwd(dep.from)} is overriding a child dependency:\n" <>
-    "#{dep_status(dep)}#{dep_status(other)}" <>
-    "\n  Ensure they match or specify one of the above in your #{inspect Mix.Project.get} deps and set `override: true`"
+      "#{dep_status(dep)}#{dep_status(other)}\n  " <> override_diverge_recommendation(dep, other)
   end
 
   def format_status(%Mix.Dep{status: {:unavailable, _}, scm: scm}) do
-    if scm.fetchable? do
-      "the dependency is not available, run `mix deps.get`"
+    if scm.fetchable?() do
+      "the dependency is not available, run \"mix deps.get\""
     else
       "the dependency is not available"
     end
   end
 
-  def format_status(%Mix.Dep{status: {:elixirlock, _}}),
-    do: "the dependency is built with an out-of-date elixir version, run `#{mix_env_var}mix deps.compile`"
+  def format_status(%Mix.Dep{status: {:vsnlock, _}}) do
+    "the dependency was built with an out-of-date Erlang/Elixir version, run \"#{mix_env_var()}mix deps.compile\""
+  end
+
+  def format_status(%Mix.Dep{status: {:scmlock, _}}) do
+    "the dependency was built with another SCM, run \"#{mix_env_var()}mix deps.compile\""
+  end
+
+  defp override_diverge_recommendation(dep, other) do
+    if dep.opts[:from_umbrella] || other.opts[:from_umbrella] do
+      "Please remove the conflicting options from your definition"
+    else
+      "Ensure they match or specify one of the above in your deps and set \"override: true\""
+    end
+  end
 
-  defp dep_status(%Mix.Dep{app: app, requirement: req, opts: opts, from: from}) do
-    info = {app, req, Dict.drop(opts, [:dest, :lock, :env, :build])}
-    "\n  > In #{Path.relative_to_cwd(from)}:\n    #{inspect info}\n"
+  defp dep_status(%Mix.Dep{} = dep) do
+    %{
+      app: app,
+      requirement: req,
+      manager: manager,
+      opts: opts,
+      from: from,
+      system_env: system_env
+    } = dep
+
+    opts =
+      []
+      |> Kernel.++(if manager, do: [manager: manager], else: [])
+      |> Kernel.++(if system_env != [], do: [system_env: system_env], else: [])
+      |> Kernel.++(opts)
+      |> Keyword.drop([:dest, :build, :lock, :manager, :checkout, :app_properties])
+
+    info = if req, do: {app, req, opts}, else: {app, opts}
+    "\n  > In #{Path.relative_to_cwd(from)}:\n    #{inspect(info)}\n"
   end
 
   @doc """
   Checks the lock for the given dependency and update its status accordingly.
   """
-  def check_lock(%Mix.Dep{scm: scm, app: app, opts: opts} = dep, lock) do
-    if rev = lock[app] do
-      opts = Keyword.put(opts, :lock, rev)
-    end
-
+  def check_lock(%Mix.Dep{scm: scm, opts: opts} = dep) do
     if available?(dep) do
       case scm.lock_status(opts) do
         :mismatch ->
-          status = if rev, do: {:lockmismatch, rev}, else: :nolock
-          %{dep | status: status, opts: opts}
+          status = if rev = opts[:lock], do: {:lockmismatch, rev}, else: :nolock
+          %{dep | status: status}
+
         :outdated ->
           # Don't include the lock in the dependency if it is outdated
           %{dep | status: :lockoutdated}
+
         :ok ->
-          if vsn = old_elixir_lock(dep) do
-            %{dep | status: {:elixirlock, vsn}, opts: opts}
-          else
-            %{dep | opts: opts}
-          end
+          check_manifest(dep)
       end
     else
-      %{dep | opts: opts}
+      dep
+    end
+  end
+
+  defp check_manifest(%{scm: scm, opts: opts} = dep) do
+    vsn = {System.version(), :erlang.system_info(:otp_release)}
+    lock = opts[:lock]
+
+    case Mix.Dep.ElixirSCM.read(Path.join(opts[:build], ".mix")) do
+      {:ok, old_vsn, _, _} when old_vsn != vsn ->
+        %{dep | status: {:vsnlock, old_vsn}}
+
+      {:ok, _, old_scm, _} when old_scm != scm ->
+        %{dep | status: {:scmlock, old_scm}}
+
+      {:ok, _, _, old_lock} when old_lock != lock ->
+        %{dep | status: :compile}
+
+      :error ->
+        if scm.fetchable?() do
+          %{dep | status: :compile}
+        else
+          dep
+        end
+
+      # If the file is missing, it is handled in the loader
+      _ ->
+        dep
     end
   end
 
   @doc """
-  Returns true if the dependency is ok.
+  Returns `true` if the dependency is ok.
   """
   def ok?(%Mix.Dep{status: {:ok, _}}), do: true
   def ok?(%Mix.Dep{}), do: false
 
   @doc """
-  Checks if a dependency is available. Available dependencies
-  are the ones that can be loaded.
+  Checks if a dependency is available.
+
+  Available dependencies are the ones that can be loaded.
+  """
+  def available?(%Mix.Dep{status: {:unavailable, _}}), do: false
+  def available?(dep), do: not diverged?(dep)
+
+  @doc """
+  Checks if a dependency has diverged.
   """
-  def available?(%Mix.Dep{status: {:overridden, _}}),   do: false
-  def available?(%Mix.Dep{status: {:diverged, _}}),     do: false
-  def available?(%Mix.Dep{status: {:divergedreq, _}}),  do: false
-  def available?(%Mix.Dep{status: {:unavailable, _}}),  do: false
-  def available?(%Mix.Dep{}), do: true
+  def diverged?(%Mix.Dep{status: {:overridden, _}}), do: true
+  def diverged?(%Mix.Dep{status: {:diverged, _}}), do: true
+  def diverged?(%Mix.Dep{status: {:divergedreq, _, _}}), do: true
+  def diverged?(%Mix.Dep{status: {:divergedonly, _}}), do: true
+  def diverged?(%Mix.Dep{status: {:divergedtargets, _}}), do: true
+  def diverged?(%Mix.Dep{}), do: false
+
+  @doc """
+  Returns `true` if the dependency is compilable.
+  """
+  def compilable?(%Mix.Dep{status: {:vsnlock, _}}), do: true
+  def compilable?(%Mix.Dep{status: {:noappfile, {_, _}}}), do: true
+  def compilable?(%Mix.Dep{status: {:scmlock, _}}), do: true
+  def compilable?(%Mix.Dep{status: :compile}), do: true
+  def compilable?(_), do: false
 
   @doc """
   Formats a dependency for printing.
@@ -259,51 +529,27 @@ defmodule Mix.Dep do
 
   Automatically derived from source paths.
   """
-  def load_paths(%Mix.Dep{opts: opts} = dep) do
+  def load_paths(%Mix.Dep{app: app, opts: opts}) do
     build_path = Path.dirname(opts[:build])
-    Enum.map source_paths(dep), fn path ->
-      Path.join [build_path, Path.basename(path), "ebin"]
-    end
+    [Path.join([build_path, Atom.to_string(app), "ebin"])]
   end
 
   @doc """
-  Returns all source paths.
-
-  Source paths are the directories that contains ebin files for a given
-  dependency. All managers, except rebar, have only one source path.
-  """
-  def source_paths(%Mix.Dep{manager: :rebar, opts: opts, extra: extra}) do
-    # Add root dir and all sub dirs with ebin/ directory
-    sub_dirs = Enum.map(extra[:sub_dirs] || [], fn path ->
-      Path.join(opts[:dest], path)
-    end)
-
-    [opts[:dest] | sub_dirs]
-    |> Enum.map(&Path.wildcard(&1))
-    |> Enum.concat
-    |> Enum.filter(fn p -> p |> Path.join("ebin") |> File.dir? end)
-  end
-
-  def source_paths(%Mix.Dep{opts: opts}) do
-    [opts[:dest]]
-  end
-
-  @doc """
-  Return `true` if dependency is a mix project.
+  Returns `true` if dependency is a Mix project.
   """
   def mix?(%Mix.Dep{manager: manager}) do
     manager == :mix
   end
 
   @doc """
-  Return `true` if dependency is a rebar project.
+  Returns `true` if dependency is a Rebar project.
   """
   def rebar?(%Mix.Dep{manager: manager}) do
-    manager == :rebar
+    manager == :rebar3
   end
 
   @doc """
-  Return `true` if dependency is a make project.
+  Returns `true` if dependency is a Make project.
   """
   def make?(%Mix.Dep{manager: manager}) do
     manager == :make
@@ -312,23 +558,16 @@ defmodule Mix.Dep do
   ## Helpers
 
   defp mix_env_var do
-    if Mix.env == :dev do
+    if Mix.env() == :dev do
       ""
     else
-      "MIX_ENV=#{Mix.env} "
+      "MIX_ENV=#{Mix.env()} "
     end
   end
 
   defp to_app_names(given) do
-    Enum.map given, fn(app) ->
+    Enum.map(given, fn app ->
       if is_binary(app), do: String.to_atom(app), else: app
-    end
-  end
-
-  defp old_elixir_lock(%Mix.Dep{opts: opts}) do
-    old_vsn = Mix.Dep.Lock.elixir_vsn(opts[:build])
-    if old_vsn && old_vsn != System.version do
-      old_vsn
-    end
+    end)
   end
 end
diff --git a/lib/mix/lib/mix/dep/converger.ex b/lib/mix/lib/mix/dep/converger.ex
index f8b2316fbf3..1d036c49822 100644
--- a/lib/mix/lib/mix/dep/converger.ex
+++ b/lib/mix/lib/mix/dep/converger.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 # This module is the one responsible for converging
 # dependencies in a recursive fashion. This
 # module and its functions are private to Mix.
@@ -5,10 +9,10 @@ defmodule Mix.Dep.Converger do
   @moduledoc false
 
   @doc """
-  Topsorts the given dependencies.
+  Topologically sorts the given dependencies.
   """
-  def topsort(deps) do
-    graph = :digraph.new
+  def topological_sort(deps) do
+    graph = :digraph.new()
 
     try do
       Enum.each(deps, fn %Mix.Dep{app: app} ->
@@ -16,23 +20,62 @@ defmodule Mix.Dep.Converger do
       end)
 
       Enum.each(deps, fn %Mix.Dep{app: app, deps: other_deps} ->
-        Enum.each(other_deps, fn %Mix.Dep{app: other_app} ->
-          :digraph.add_edge(graph, other_app, app)
+        Enum.each(other_deps, fn
+          %Mix.Dep{app: ^app} ->
+            Mix.raise("App #{app} lists itself as a dependency")
+
+          %Mix.Dep{app: other_app} ->
+            :digraph.add_edge(graph, other_app, app)
         end)
       end)
 
       if apps = :digraph_utils.topsort(graph) do
-        Enum.map(apps, fn(app) ->
-          Enum.find(deps, fn(%Mix.Dep{app: other_app}) -> app == other_app end)
+        Enum.map(apps, fn app ->
+          Enum.find(deps, fn %Mix.Dep{app: other_app} -> app == other_app end)
         end)
       else
-        Mix.raise "Could not sort dependencies. There are cycles in the dependency graph."
+        find_cycle(graph)
       end
     after
       :digraph.delete(graph)
     end
   end
 
+  @doc """
+  A Depth-First Search to find where is the dependency graph cycle
+  and then display the cyclic dependencies back to the developer.
+  """
+  def find_cycle(graph), do: find_cycle(graph, :digraph.vertices(graph), MapSet.new())
+
+  defp find_cycle(_, [], _visited), do: nil
+
+  defp find_cycle(graph, [v | vs], visited) do
+    if v in visited, do: cycle_found(visited)
+
+    find_cycle(graph, :digraph.out_neighbours(graph, v), MapSet.put(visited, v))
+    find_cycle(graph, vs, visited)
+  end
+
+  defp cycle_found(visited) do
+    Mix.raise(
+      "Could not sort dependencies. " <>
+        "The following dependencies form a cycle: " <>
+        Enum.join(visited, ", ")
+    )
+  end
+
+  @doc """
+  Converge without lock and accumulator updates.
+
+  Note the dependencies returned from converge are not yet loaded.
+  The relevant app keys are found under `dep.opts[:app_properties]`.
+
+  See `Mix.Dep.Loader.children/1` for options.
+  """
+  def converge(opts \\ []) do
+    converge(nil, nil, opts, &{&1, &2, &3}) |> elem(0)
+  end
+
   @doc """
   Converges all dependencies from the current project,
   including nested dependencies.
@@ -41,72 +84,106 @@ defmodule Mix.Dep.Converger do
   must return an updated dependency in case some processing
   is done.
 
+  Note the dependencies returned from converge are not yet loaded.
+  The relevant app keys are found under `dep.opts[:app_properties]`.
+
   See `Mix.Dep.Loader.children/1` for options.
   """
   def converge(acc, lock, opts, callback) do
     {deps, acc, lock} = all(acc, lock, opts, callback)
-    {topsort(deps), acc, lock}
+    if remote = Mix.RemoteConverger.get(), do: remote.post_converge()
+    {topological_sort(deps), acc, lock}
   end
 
   defp all(acc, lock, opts, callback) do
-    main = Mix.Dep.Loader.children(opts)
-    main = Enum.map(main, &(%{&1 | top_level: true}))
-    apps = Enum.map(main, &(&1.app))
+    lock_given? = !!lock
+
+    main = Mix.Dep.Loader.children(lock_given?)
+    main = Enum.map(main, &%{&1 | top_level: true})
+    apps = Enum.map(main, & &1.app)
+    env_target = {opts[:env], opts[:target]}
+
+    # If no lock was given, let's read one to fill in the deps
+    lock = lock || Mix.Dep.Lock.read()
 
     # Run converger for all dependencies, except remote
     # dependencies. Since the remote converger may be
     # lazily loaded, we need to check for it on every
     # iteration.
-
-    {deps, rest, lock} =
-      all(main, [], [], apps, callback, acc, lock, fn dep ->
-        if (converger = Mix.RemoteConverger.get) &&
-           converger.remote?(dep) do
+    {deps, acc, lock} =
+      init_all(main, apps, acc, lock, callback, lock_given?, env_target, fn dep ->
+        if (remote = Mix.RemoteConverger.get()) && remote.remote?(dep) do
           {:loaded, dep}
         else
           {:unloaded, dep, nil}
         end
       end)
 
-    # Run remote converger if one is available and rerun mix's
-    # converger with the new information
-    if converger = Mix.RemoteConverger.get do
+    # Run remote converger and rerun Mix's converger with the new information.
+    # Don't run the remote if deps didn't converge, if the remote is not
+    # available or if none of the deps are handled by the remote.
+    remote = Mix.RemoteConverger.get()
+    diverged? = Enum.any?(deps, &Mix.Dep.diverged?/1)
+    use_remote? = !!remote and Enum.any?(deps, &remote.remote?/1)
+
+    if not diverged? and use_remote? do
+      # Make sure there are no cycles before calling the remote converger
+      topological_sort(deps)
+
       # If there is a lock, it means we are doing a get/update
       # and we need to hit the remote converger which do external
-      # requests and what not. In case of deps.check, deps and so
+      # requests and what not. In case of deps.loadpaths, deps and so
       # on, there is no lock, so we won't hit this branch.
-      if lock do
-        lock = converger.converge(deps, lock)
-      end
+      lock = if lock_given?, do: remote.converge(deps, lock), else: lock
 
-      deps = deps
-             |> Enum.reject(&converger.remote?(&1))
-             |> Enum.into(HashDict.new, &{&1.app, &1})
+      cache =
+        deps
+        |> Enum.reject(&remote.remote?(&1))
+        |> Enum.into(%{}, &{&1.app, &1})
 
-      # In case there is no lock, we will read the current lock
-      # which is potentially stale. So converger.deps/2 needs to
-      # always check if the data it finds in the lock is actually
-      # valid.
-      lock_for_converger = lock || Mix.Dep.Lock.read
+      # In case no lock was given, we will use the local lock
+      # which is potentially stale. So remote.deps/2 needs to always
+      # check if the data it finds in the lock is actually valid.
+      {deps, acc, lock} =
+        init_all(main, apps, acc, lock, callback, lock_given?, env_target, fn dep ->
+          %{app: app, scm: scm} = dep
 
-      all(main, [], [], apps, callback, rest, lock, fn dep ->
-        cond do
-          cached = deps[dep.app] ->
-            {:loaded, cached}
-          true ->
-            {:unloaded, dep, converger.deps(dep, lock_for_converger)}
-        end
-      end)
+          case cache do
+            # If the SCM matches, use the already cached dependency from first converger pass
+            %{^app => %{scm: ^scm} = cached} ->
+              {:loaded, cached}
+
+            # If SCM doesn't match, the remote converger resolved a new dependency but because
+            # there is conflict we return the new dependency as is for the converger to fail
+            %{^app => _cached} ->
+              {:loaded, dep}
+
+            %{} ->
+              {:unloaded, dep, remote.deps(dep, lock)}
+          end
+        end)
+
+      {reject_non_fulfilled_optional(deps), acc, lock}
     else
-      {deps, rest, lock}
+      {reject_non_fulfilled_optional(deps), acc, lock}
     end
   end
 
-  # We traverse the tree of dependencies in a breadth-
-  # first fashion. The reason for this is that we converge
+  defp init_all(main, apps, rest, lock, callback, locked?, env_target, cache) do
+    state = %{locked?: locked?, env_target: env_target, cache: cache, callback: callback}
+    {deps, _kept, _optional, rest, lock} = all(main, [], [], [], apps, [], rest, lock, state)
+    deps = Enum.reverse(deps)
+    # When traversing dependencies, we keep skipped ones to
+    # find conflicts. We remove them now after traversal.
+    {deps, _} = Mix.Dep.Loader.split_by_env_and_target(deps, env_target)
+    {deps, rest, lock}
+  end
+
+  # We traverse the tree of dependencies in a breadth-first
+  # fashion. The reason for this is that we converge
   # dependencies, but allow the parent to override any
   # dependency in the child. Consider this tree with
-  # dependencies `a`, `b`, etc and the order they are
+  # dependencies "a", "b", "c", and so forth, and the order they are
   # converged:
   #
   #     * project
@@ -118,10 +195,10 @@ defmodule Mix.Dep.Converger do
   #         6) f
   #           7) d
   #
-  # Notice that the `d` dependency exists as a child of `b`
-  # and child of `f`. In case the dependency is the same,
+  # Note that the "d" dependency exists as a child of "b"
+  # and child of "f". In case the dependency is the same,
   # we proceed. However, if there is a conflict, for instance
-  # different git repositories is used as source in each, we
+  # different Git repositories are used as source in each, we
   # raise an exception.
   #
   # In order to solve such dependencies, we allow the project
@@ -138,39 +215,65 @@ defmodule Mix.Dep.Converger do
   #           8) d
   #       4) d
   #
-  # Now, since `d` was specified in a parent project, no
+  # Now, since "d" was specified in a parent project, no
   # exception is going to be raised since d is considered
-  # to be the authorative source.
-  defp all([dep|t], acc, upper_breadths, current_breadths, callback, rest, lock, cache) do
-    cond do
-      new_acc = diverged_deps(acc, upper_breadths, dep) ->
-        all(t, new_acc, upper_breadths, current_breadths, callback, rest, lock, cache)
-      true ->
-        dep =
-          case cache.(dep) do
+  # to be the authoritative source.
+  defp all([dep | t], acc, kept, upper, breadths, optional, rest, lock, state) do
+    case match_deps(acc, upper, dep, state.env_target) do
+      {:replace, dep, acc} ->
+        all([dep | t], acc, kept, upper, breadths, optional, rest, lock, state)
+
+      {:match, acc} ->
+        all(t, acc, kept, upper, breadths, optional, rest, lock, state)
+
+      :skip ->
+        # We still keep skipped dependencies around to detect conflicts.
+        # They must be rejected after every all iteration but they are not
+        # included in the list of kept dependencies.
+        all(t, [dep | acc], kept, upper, breadths, optional, rest, lock, state)
+
+      :nomatch ->
+        {%{app: app, deps: deps, opts: opts} = dep, rest, lock} =
+          case state.cache.(dep) do
             {:loaded, cached_dep} ->
-              cached_dep
+              {cached_dep, rest, lock}
+
             {:unloaded, dep, children} ->
-              {dep, rest, lock} = callback.(dep, rest, lock)
+              {dep, rest, lock} = state.callback.(put_lock(dep, lock), rest, lock)
+
+              dep =
+                Mix.Dep.Loader.with_system_env(dep, fn ->
+                  Mix.Dep.Loader.load(dep, children, state.locked?)
+                end)
 
-              # After we invoke the callback (which may actually check out the
-              # dependency), we load the dependency including its latest info
-              # and children information.
-              dep = Mix.Dep.Loader.load(dep)
-              %{dep | deps: Enum.filter(dep.deps, &(!children || &1.app in children))}
+              {dep, rest, lock}
           end
 
-        dep = %{dep | deps: reject_non_fullfilled_optional(dep.deps, current_breadths)}
-        {acc, rest, lock} = all(t, [dep|acc], upper_breadths, current_breadths, callback, rest, lock, cache)
-        all(dep.deps, acc, current_breadths, Enum.map(dep.deps, &(&1.app)) ++ current_breadths, callback, rest, lock, cache)
+        # Something that we previously ruled out as an optional dependency is
+        # no longer a dependency. Add it back for traversal.
+        {no_longer_optional, optional} = Enum.split_with(optional, &(&1.app == app))
+        t = no_longer_optional ++ t
+
+        {acc, kept, optional, rest, lock} =
+          all(t, [dep | acc], [dep.app | kept], upper, breadths, optional, rest, lock, state)
+
+        # Now traverse all parent dependencies and see if we have any optional dependency.
+        {discarded, deps} = split_non_fulfilled_optional(deps, kept, opts[:from_umbrella])
+
+        new_breadths = Enum.map(deps, & &1.app) ++ breadths
+        all(deps, acc, kept, breadths, new_breadths, discarded ++ optional, rest, lock, state)
     end
   end
 
-  defp all([], acc, _upper, _current, _callback, rest, lock, _cache) do
-    {acc, rest, lock}
+  defp all([], acc, kept, _upper, _current, optional, rest, lock, _state) do
+    {acc, kept, optional, rest, lock}
+  end
+
+  defp put_lock(%Mix.Dep{app: app} = dep, lock) do
+    put_in(dep.opts[:lock], lock[app])
   end
 
-  # Look for divergence in dependencies.
+  # Look for matching and divergence in dependencies.
   #
   # If the same dependency is specified more than once,
   # we need to guarantee they converge. If they don't
@@ -180,50 +283,166 @@ defmodule Mix.Dep.Converger do
   # diverges is in the upper breadth, in those cases we
   # also check for the override option and mark the dependency
   # as overridden instead of diverged.
-  defp diverged_deps(list, upper_breadths, dep) do
-    %Mix.Dep{app: app} = dep
-    in_upper? = app in upper_breadths
+  defp match_deps(list, upper_breadths, %Mix.Dep{app: app} = dep, env_target) do
+    case Enum.split_while(list, &(&1.app != app)) do
+      {_, []} ->
+        if Mix.Dep.Loader.skip?(dep, env_target) do
+          :skip
+        else
+          :nomatch
+        end
 
-    {acc, match} =
-      Enum.map_reduce list, false, fn(other, match) ->
-        %Mix.Dep{app: other_app, opts: other_opts} = other
+      {pre, [%Mix.Dep{opts: other_opts} = other | pos]} ->
+        in_upper? = app in upper_breadths
+
+        if other.top_level and dep.top_level do
+          Mix.shell().error(
+            "warning: the dependency #{inspect(dep.app)} is " <>
+              "duplicated at the top level, please remove one of them"
+          )
+        end
 
         cond do
-          app != other_app ->
-            {other, match}
           in_upper? && other_opts[:override] ->
-            {other, true}
-          converge?(other, dep) ->
-            {with_matching_req(other, dep), true}
-          true ->
+            {:match, list}
+
+          not converge?(other, dep) ->
             tag = if in_upper?, do: :overridden, else: :diverged
-            {%{other | status: {tag, dep}}, true}
-        end
-      end
+            other = %{other | status: {tag, dep}}
+            {:match, pre ++ [other | pos]}
 
-    if match, do: acc
-  end
+          vsn = req_mismatch(other, dep) ->
+            other = %{other | status: {:divergedreq, vsn, dep}}
+            {:match, pre ++ [other | pos]}
+
+          not in_upper? and Mix.Dep.Loader.skip?(other, env_target) and
+              not Mix.Dep.Loader.skip?(dep, env_target) ->
+            dep =
+              dep
+              |> with_matching_only_and_targets(other, in_upper?)
+              |> merge_manager(other, in_upper?)
+
+            {:replace, dep, pre ++ pos}
 
-  defp converge?(%Mix.Dep{scm: scm1, opts: opts1}, %Mix.Dep{scm: scm2, opts: opts2}) do
-    scm1 == scm2 and scm1.equal?(opts1, opts2)
+          true ->
+            other =
+              other
+              |> with_matching_only_and_targets(dep, in_upper?)
+              |> merge_manager(dep, in_upper?)
+
+            {:match, pre ++ [other | pos]}
+        end
+    end
   end
 
-  defp reject_non_fullfilled_optional(children, upper_breadths) do
-    Enum.reject children, fn %Mix.Dep{app: app, opts: opts} ->
-      opts[:optional] && not(app in upper_breadths)
+  defp with_matching_only_and_targets(other, dep, in_upper?) do
+    %{opts: opts} = dep
+
+    if opts[:optional] do
+      other
+    else
+      other
+      |> with_matching(:only, dep, opts, in_upper?)
+      |> with_matching(:targets, dep, opts, in_upper?)
     end
   end
 
-  defp with_matching_req(%Mix.Dep{} = other, %Mix.Dep{} = dep) do
-    case other.status do
-      {:ok, vsn} when not nil?(vsn) ->
-        if Mix.Dep.Loader.vsn_match?(dep.requirement, vsn, dep.app) do
-          other
-        else
-          %{other | status: {:divergedreq, dep}}
+  # When in_upper is true
+  #
+  # When a parent dependency specifies :only/:targets that is a
+  # subset of a child dependency, we are going to abort as the
+  # parent dependency must explicitly outline a superset of child
+  # dependencies.
+  #
+  # We could resolve such conflicts automatically but, since
+  # the user has likely written a :only/:targets in their mix.exs
+  # file, we decided to go with a more explicit approach of asking
+  # them to change it to avoid later surprises and headaches.
+  defp with_matching(%{opts: other_opts} = other, key, dep, opts, true) do
+    case Keyword.fetch(other_opts, key) do
+      {:ok, other_value} ->
+        case Keyword.fetch(opts, key) do
+          {:ok, value} ->
+            case List.wrap(value) -- List.wrap(other_value) do
+              [] -> other
+              _ -> %{other | status: {:"diverged#{key}", dep}}
+            end
+
+          :error ->
+            %{other | status: {:"diverged#{key}", dep}}
         end
-      _ ->
+
+      :error ->
         other
     end
   end
+
+  # When in_upper is false
+  #
+  # In this case, the two dependencies do not have a common path and
+  # only solution is to merge the environments. We have decided to
+  # perform it automatically as, opposite to in_upper above, the
+  # dependencies are never really laid out in the parent tree.
+  defp with_matching(%{opts: other_opts} = other, key, _dep, opts, false) do
+    other_value = Keyword.get(other_opts, key)
+    value = Keyword.get(opts, key)
+
+    if other_value && value do
+      put_in(other.opts[key], Enum.uniq(List.wrap(other_value) ++ List.wrap(value)))
+    else
+      %{other | opts: Keyword.delete(other_opts, key)}
+    end
+  end
+
+  defp converge?(
+         %Mix.Dep{scm: scm1, opts: opts1, system_env: system_env1},
+         %Mix.Dep{scm: scm2, opts: opts2, system_env: system_env2}
+       ) do
+    scm1 == scm2 and system_env1 == system_env2 and opts_equal?(opts1, opts2) and
+      scm1.equal?(opts1, opts2)
+  end
+
+  defp opts_equal?(opts1, opts2) do
+    keys = ~w(app env compile manager)a
+    Enum.all?(keys, &(Keyword.fetch(opts1, &1) == Keyword.fetch(opts2, &1)))
+  end
+
+  defp reject_non_fulfilled_optional(deps) do
+    apps = Enum.map(deps, & &1.app)
+
+    for dep <- deps do
+      {_discarded, deps} = split_non_fulfilled_optional(dep.deps, apps, dep.opts[:from_umbrella])
+      %{dep | deps: deps}
+    end
+  end
+
+  defp split_non_fulfilled_optional(children, upper_breadths, umbrella?) do
+    Enum.split_with(children, fn %Mix.Dep{app: app, opts: opts} ->
+      opts[:optional] && app not in upper_breadths && !umbrella?
+    end)
+  end
+
+  defp merge_manager(%{manager: other_manager} = other, %{manager: manager}, in_upper?) do
+    %{other | manager: sort_manager(other_manager, manager, in_upper?)}
+  end
+
+  @managers [:mix, :rebar3, :make]
+
+  defp sort_manager(other_manager, manager, true) do
+    other_manager || manager
+  end
+
+  defp sort_manager(other_manager, manager, false) do
+    to_exclude = @managers -- (List.wrap(other_manager) ++ List.wrap(manager))
+    List.first(@managers -- to_exclude) || other_manager || manager
+  end
+
+  defp req_mismatch(%Mix.Dep{status: status}, %Mix.Dep{app: app, requirement: requirement}) do
+    with {:ok, vsn} when not is_nil(vsn) <- status,
+         true <- Mix.Dep.Loader.vsn_match(requirement, vsn, app) != {:ok, true} do
+      vsn
+    else
+      _ -> nil
+    end
+  end
 end
diff --git a/lib/mix/lib/mix/dep/elixir_scm.ex b/lib/mix/lib/mix/dep/elixir_scm.ex
new file mode 100644
index 00000000000..ed7abae1dac
--- /dev/null
+++ b/lib/mix/lib/mix/dep/elixir_scm.ex
@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# Manifest file where we treat Erlang/OTP, Elixir and SCMs as a dependency.
+# We also store the exact version this dependency was compiled for.
+defmodule Mix.Dep.ElixirSCM do
+  @moduledoc false
+  @manifest "compile.elixir_scm"
+  @manifest_vsn 2
+
+  def manifest(manifest_path \\ Mix.Project.manifest_path()) do
+    Path.join(manifest_path, @manifest)
+  end
+
+  def update(manifest_path \\ Mix.Project.manifest_path(), scm, lock) do
+    File.mkdir_p!(manifest_path)
+
+    manifest_data =
+      {@manifest_vsn, {System.version(), :erlang.system_info(:otp_release)}, scm, lock}
+      |> :erlang.term_to_binary()
+
+    File.write!(manifest(manifest_path), manifest_data)
+  end
+
+  def read(manifest_path \\ Mix.Project.manifest_path()) do
+    case File.read(manifest(manifest_path)) do
+      {:ok, contents} ->
+        try do
+          {@manifest_vsn, vsn, scm, lock} = :erlang.binary_to_term(contents)
+          {:ok, vsn, scm, lock}
+        rescue
+          _ -> {:ok, {"1.0.0", ~c"17"}, nil, nil}
+        end
+
+      _ ->
+        :error
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/dep/fetcher.ex b/lib/mix/lib/mix/dep/fetcher.ex
index 9e42b762ad4..1e477e8f4af 100644
--- a/lib/mix/lib/mix/dep/fetcher.ex
+++ b/lib/mix/lib/mix/dep/fetcher.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 # Module responsible for fetching (getting/updating)
 # dependencies from their sources.
 #
@@ -7,7 +11,7 @@
 defmodule Mix.Dep.Fetcher do
   @moduledoc false
 
-  import Mix.Dep, only: [format_dep: 1, check_lock: 2, available?: 1, ok?: 1]
+  import Mix.Dep, only: [format_dep: 1, check_lock: 1, available?: 1]
 
   @doc """
   Fetches all dependencies.
@@ -27,17 +31,17 @@ defmodule Mix.Dep.Fetcher do
     {apps, deps} = do_finalize(result, old_lock, opts)
 
     # Check if all given dependencies are loaded or fail
-    Mix.Dep.loaded_by_name(names, deps, opts)
+    _ = Mix.Dep.filter_by_name(names, deps, opts)
     apps
   end
 
   defp fetch_by_name(given, lock) do
     names = to_app_names(given)
 
-    fn(%Mix.Dep{app: app} = dep, acc, new_lock) ->
+    fn %Mix.Dep{app: app} = dep, acc, new_lock ->
       # Only fetch if dependency is in given names or if lock has
-      # been changed for dependency by remote converger
-      if app in names or lock[app] != new_lock[app] do
+      # been changed for dependency by remote converger or it is new
+      if app in names or lock[app] != new_lock[app] or is_nil(lock[app]) do
         do_fetch(dep, acc, new_lock)
       else
         {dep, acc, new_lock}
@@ -46,26 +50,35 @@ defmodule Mix.Dep.Fetcher do
   end
 
   defp do_fetch(dep, acc, lock) do
-    %Mix.Dep{app: app, scm: scm, opts: opts} = dep = check_lock(dep, lock)
+    %Mix.Dep{app: app, scm: scm, opts: opts} = dep = check_lock(dep)
 
     cond do
       # Dependencies that cannot be fetched are always compiled afterwards
-      not scm.fetchable? ->
-        {dep, [app|acc], lock}
+      not scm.fetchable?() ->
+        if not scm.checked_out?(opts) do
+          Mix.shell().error("warning: missing dependency #{format_dep(dep)}")
+        end
+
+        {dep, [app | acc], lock}
 
       # If the dependency is not available or we have a lock mismatch
       out_of_date?(dep) ->
+        # Mark the dependency as fetched upfront, in case updating fails,
+        # gets interrupted, or corrupted.
+        mark_as_fetched([dep])
+
         new =
           if scm.checked_out?(opts) do
-            Mix.shell.info "* Updating #{format_dep(dep)}"
+            Mix.shell().info("* Updating #{format_dep(dep)}")
             scm.update(opts)
           else
-            Mix.shell.info "* Getting #{format_dep(dep)}"
+            Mix.shell().info("* Getting #{format_dep(dep)}")
             scm.checkout(opts)
           end
 
         if new do
-          {dep, [app|acc], Map.put(lock, app, new)}
+          dep = put_in(dep.opts[:lock], new)
+          {dep, [app | acc], Map.put(lock, app, new)}
         else
           {dep, acc, lock}
         end
@@ -77,53 +90,58 @@ defmodule Mix.Dep.Fetcher do
   end
 
   defp out_of_date?(%Mix.Dep{status: {:lockmismatch, _}}), do: true
-  defp out_of_date?(%Mix.Dep{status: :lockoutdated}),      do: true
-  defp out_of_date?(%Mix.Dep{status: :nolock}),            do: true
-  defp out_of_date?(%Mix.Dep{status: {:unavailable, _}}),  do: true
-  defp out_of_date?(%Mix.Dep{}),                           do: false
+  defp out_of_date?(%Mix.Dep{status: :lockoutdated}), do: true
+  defp out_of_date?(%Mix.Dep{status: :nolock}), do: true
+  defp out_of_date?(%Mix.Dep{status: {:unavailable, _}}), do: true
+  defp out_of_date?(%Mix.Dep{}), do: false
 
   defp do_finalize({all_deps, apps, new_lock}, old_lock, opts) do
     # Let's get the loaded versions of deps
-    deps = Mix.Dep.loaded_by_name(apps, all_deps, opts)
-
-    # Do not mark dependencies that are not available
-    deps = Enum.filter(deps, &available?/1)
+    deps = Mix.Dep.filter_by_name(apps, all_deps, opts)
 
     # Note we only retrieve the parent dependencies of the updated
     # deps if all dependencies are available. This is because if a
     # dependency is missing, it could directly affect one of the
     # dependencies we are trying to compile, causing the whole thing
     # to fail.
-    #
-    # If there is any other dependency that is not ok, we include
-    # it for compilation too, this is our best to try to solve the
-    # maximum we can at each deps.get and deps.update.
-    if Enum.all?(all_deps, &available?/1) do
-      deps = with_depending(deps, all_deps) ++
-             Enum.filter(all_deps, fn dep -> not ok?(dep) end)
-    end
+    parent_deps =
+      if Enum.all?(all_deps, &available?/1) do
+        Enum.uniq_by(with_depending(deps, all_deps), & &1.app)
+      else
+        []
+      end
+
+    # Mark parents as fetched before we write the lock file.
+    mark_as_fetched(parent_deps)
 
     # Merge the new lock on top of the old to guarantee we don't
     # leave out things that could not be fetched and save it.
-    lock = Dict.merge(old_lock, new_lock)
-    Mix.Dep.Lock.write(lock)
+    lock = Map.merge(old_lock, new_lock)
+    Mix.Dep.Lock.write(lock, opts)
+
+    # See if any of the deps diverged and abort.
+    show_diverged!(Enum.filter(all_deps, &Mix.Dep.diverged?/1))
 
-    mark_as_fetched(deps)
     {apps, all_deps}
   end
 
   defp mark_as_fetched(deps) do
-    # If the dependency is fetchable, we are going to write a .fetch
-    # file to it. Each build, regardless of the environment and location,
-    # will compared against this .fetch file to know if the depednency
-    # needs recompiling.
-    for %Mix.Dep{scm: scm, opts: opts} <- deps, scm.fetchable? do
-      File.touch Path.join opts[:dest], ".fetch"
+    build_path =
+      Mix.Project.build_path()
+      |> Path.dirname()
+
+    for %Mix.Dep{app: app, scm: scm} <- deps, scm.fetchable?() do
+      build_path
+      |> Path.join("*/lib/#{app}/.mix/compile.elixir_scm")
+      |> Path.wildcard(match_dot: true)
+      |> Enum.each(&File.rm/1)
     end
+
+    :ok
   end
 
   defp with_depending(deps, all_deps) do
-    (deps ++ do_with_depending(deps, all_deps)) |> Enum.uniq(&(&1.app))
+    deps ++ do_with_depending(deps, all_deps)
   end
 
   defp do_with_depending([], _all_deps) do
@@ -133,16 +151,31 @@ defmodule Mix.Dep.Fetcher do
   defp do_with_depending(deps, all_deps) do
     dep_names = Enum.map(deps, fn dep -> dep.app end)
 
-    parents = Enum.filter all_deps, fn dep ->
-      Enum.any?(dep.deps, &(&1 in dep_names))
-    end
+    parents =
+      Enum.filter(all_deps, fn dep ->
+        Enum.any?(dep.deps, &(&1.app in dep_names))
+      end)
 
     do_with_depending(parents, all_deps) ++ parents
   end
 
   defp to_app_names(given) do
-    Enum.map(given, fn(app) ->
+    Enum.map(given, fn app ->
       if is_binary(app), do: String.to_atom(app), else: app
     end)
   end
+
+  defp show_diverged!([]), do: :ok
+
+  defp show_diverged!(deps) do
+    shell = Mix.shell()
+    shell.error("Dependencies have diverged:")
+
+    Enum.each(deps, fn dep ->
+      shell.error("* #{Mix.Dep.format_dep(dep)}")
+      shell.error("  #{Mix.Dep.format_status(dep)}")
+    end)
+
+    Mix.raise("Can't continue due to errors on dependencies")
+  end
 end
diff --git a/lib/mix/lib/mix/dep/loader.ex b/lib/mix/lib/mix/dep/loader.ex
index febf499b4d7..290579a23ea 100644
--- a/lib/mix/lib/mix/dep/loader.ex
+++ b/lib/mix/lib/mix/dep/loader.ex
@@ -1,138 +1,205 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 # This module is responsible for loading dependencies
 # of the current project. This module and its functions
 # are private to Mix.
 defmodule Mix.Dep.Loader do
   @moduledoc false
 
+  import Mix.Dep, only: [ok?: 1, mix?: 1, rebar?: 1, make?: 1]
+
   @doc """
   Gets all direct children of the current `Mix.Project`
   as a `Mix.Dep` struct. Umbrella project dependencies
   are included as children.
 
   By default, it will filter all dependencies that does not match
-  current environment, behaviour can be overriden via options.
+  current environment, behavior can be overridden via options.
+  """
+  def children(locked?) do
+    mix_children(Mix.Project.config(), locked?, []) ++ Mix.Dep.Umbrella.unloaded()
+  end
 
-  ## Options
+  @doc """
+  Partitions loaded dependencies by environment.
+  """
+  def split_by_env_and_target(deps, {nil, nil}), do: {deps, []}
 
-    * `:env` - filter dependencies on given environments
+  def split_by_env_and_target(deps, env_target),
+    do: Enum.split_with(deps, &(not skip?(&1, env_target)))
+
+  @doc """
+  Checks if a dependency must be skipped according to the environment.
   """
-  def children(opts) do
-    from = Path.absname("mix.exs")
-    deps = Enum.map(Mix.Project.config[:deps] || [], &to_dep(&1, from))
-
-    # Filter deps not matching mix environment
-    if env = opts[:env] do
-      deps =
-        Enum.filter(deps, fn %Mix.Dep{opts: opts} ->
-          only = opts[:only]
-          if only, do: env in List.wrap(only), else: true
-        end)
+  def skip?(%Mix.Dep{status: {:divergedonly, _}}, _), do: false
+  def skip?(%Mix.Dep{status: {:divergedtargets, _}}, _), do: false
+
+  def skip?(%Mix.Dep{opts: opts}, {env, target}) do
+    skip?(opts[:only], :only, env) or skip?(opts[:targets], :targets, target)
+  end
+
+  # The dependency is not filtered
+  defp skip?(nil, _key, _value), do: false
+
+  # The command is not filtered
+  defp skip?(_maybe_list_of_atoms, _key, nil), do: false
+
+  # The dependency is filtered as well as the command
+  defp skip?(maybe_list_of_atoms, key, value) do
+    wrapped = List.wrap(maybe_list_of_atoms)
+
+    for entry <- wrapped, not is_atom(entry) do
+      Mix.raise(
+        "Expected #{inspect(key)} in dependency to be an atom or a list of atoms, " <>
+          "got: #{inspect(maybe_list_of_atoms)}"
+      )
     end
 
-    deps ++ Mix.Dep.Umbrella.unloaded
+    value not in wrapped
+  end
+
+  def with_system_env(%Mix.Dep{system_env: []}, callback), do: callback.()
+
+  def with_system_env(%Mix.Dep{system_env: new_env}, callback) do
+    old_env =
+      for {key, _} <- new_env do
+        key = to_string(key)
+        {key, System.get_env(key)}
+      end
+
+    try do
+      System.put_env(new_env)
+      callback.()
+    after
+      System.put_env(old_env)
+    end
   end
 
   @doc """
   Loads the given dependency information, including its
   latest status and children.
   """
-  def load(dep) do
-    %Mix.Dep{manager: manager, scm: scm, opts: opts} = dep
-    dep  = %{dep | status: scm_status(scm, opts)}
-    dest = opts[:dest]
+  def load(%Mix.Dep{manager: manager, scm: scm, opts: opts} = dep, children, locked?) do
+    # The manager for a child dependency is set based on the following rules:
+    #   1. Set in dependency definition
+    #   2. From SCM, so that Hex dependencies of a rebar project can be compiled with mix
+    #   3. From the parent dependency, used for rebar dependencies from git
+    #   4. Inferred from files in dependency (mix.exs, rebar.config, Makefile)
+    manager = opts[:manager] || scm_manager(scm, opts) || manager || infer_manager(opts[:dest])
+    dep = %{dep | manager: manager, status: scm_status(scm, opts)}
 
     {dep, children} =
       cond do
-        not ok?(dep.status) ->
+        not ok?(dep) ->
           {dep, []}
 
-        manager == :rebar ->
-          rebar_dep(dep)
-
-        mix?(dest) ->
-          mix_dep(%{dep | manager: :mix})
+        mix?(dep) ->
+          mix_dep(dep, children, locked?)
 
-        rebar?(dest) ->
-          rebar_dep(%{dep | manager: :rebar})
+        # If not an explicit Rebar or Mix dependency
+        # but came from Rebar, assume to be a Rebar dep.
+        rebar?(dep) ->
+          rebar_dep(dep, children, manager, locked?)
 
-        make?(dest) ->
-          {%{dep | manager: :make}, []}
+        make?(dep) ->
+          make_dep(dep)
 
         true ->
           {dep, []}
       end
 
-    %{validate_path(validate_app(dep)) | deps: children}
+    validate_app(%{dep | deps: attach_only_and_targets(children, opts)})
   end
 
   @doc """
   Checks if a requirement from a dependency matches
   the given version.
   """
-  def vsn_match?(nil, _actual, _app),
-    do: true
-  def vsn_match?(req, actual, app) do
-    if Regex.regex?(req) do
-      actual =~ req
+  def vsn_match(nil, _actual, _app), do: {:ok, true}
+
+  def vsn_match(req, actual, app) do
+    if is_struct(req, Regex) do
+      {:ok, actual =~ req}
     else
       case Version.parse(actual) do
         {:ok, version} ->
           case Version.parse_requirement(req) do
             {:ok, req} ->
-              Version.match?(version, req)
+              {:ok, Version.match?(version, req)}
+
             :error ->
-              Mix.raise "Invalid requirement #{req} for app #{app}"
+              Mix.raise("Invalid requirement #{req} for app #{app}")
           end
 
         :error ->
-          Mix.raise "The application #{app} specified a non Semantic Version #{actual}. " <>
-            "Mix can only match the requirement #{req} against Semantic Versions, to match against any " <>
-            "version, please use a regex as requirement"
+          {:error, :nosemver}
       end
     end
   end
 
   ## Helpers
 
-  def to_dep(tuple, from, manager \\ nil) do
-    %{with_scm_and_app(tuple) | from: from, manager: manager}
+  defp to_dep(tuple, from, manager, locked?) do
+    %{with_scm_and_app(tuple, locked?) | from: from, manager: manager}
   end
 
-  defp with_scm_and_app({app, opts}) when is_list(opts) do
-    with_scm_and_app({app, nil, opts})
+  defp with_scm_and_app({app, opts} = original, locked?) when is_atom(app) and is_list(opts) do
+    with_scm_and_app(app, nil, opts, original, locked?)
   end
 
-  defp with_scm_and_app({app, req}) do
-    with_scm_and_app({app, req, []})
+  defp with_scm_and_app({app, req} = original, locked?) when is_atom(app) do
+    if is_binary(req) or is_struct(req, Regex) do
+      with_scm_and_app(app, req, [], original, locked?)
+    else
+      invalid_dep_format(original)
+    end
   end
 
-  defp with_scm_and_app({app, req, opts} = other) when is_atom(app) and is_list(opts) do
-    unless is_binary(req) or Regex.regex?(req) or nil?(req) do
-      invalid_dep_format(other)
+  defp with_scm_and_app({app, req, opts} = original, locked?)
+       when is_atom(app) and is_list(opts) do
+    if is_binary(req) or is_struct(req, Regex) do
+      with_scm_and_app(app, req, opts, original, locked?)
+    else
+      invalid_dep_format(original)
     end
+  end
 
-    unless Keyword.keyword?(opts) do
-      invalid_dep_format(other)
+  defp with_scm_and_app(original, _locked?) do
+    invalid_dep_format(original)
+  end
+
+  defp with_scm_and_app(app, req, opts, original, locked?) do
+    if not Keyword.keyword?(opts) do
+      invalid_dep_format(original)
     end
 
     bin_app = Atom.to_string(app)
 
-    dest  = Path.join(Mix.Project.deps_path, bin_app)
-    build = Path.join([Mix.Project.build_path, "lib", bin_app])
-    opts  = opts
-            |> Keyword.put(:dest, dest)
-            |> Keyword.put(:build, build)
+    dest = Path.join(Mix.Project.deps_path(), bin_app)
+    build = Path.join([Mix.Project.build_path(), "lib", bin_app])
+
+    opts =
+      opts
+      |> Keyword.put(:dest, dest)
+      |> Keyword.put(:build, build)
 
+    {system_env, opts} = Keyword.pop(opts, :system_env, [])
     {scm, opts} = get_scm(app, opts)
 
-    unless scm do
-      Mix.Tasks.Local.Hex.maybe_install(app)
-      Mix.Tasks.Local.Hex.maybe_start()
-      {scm, opts} = get_scm(app, opts)
-    end
+    {scm, opts} =
+      if is_nil(scm) and Mix.Hex.ensure_installed?(locked?) do
+        _ = Mix.Hex.start()
+        get_scm(app, opts)
+      else
+        {scm, opts}
+      end
 
-    unless scm do
-      Mix.raise "Could not find a SCM for dependency #{inspect app} from #{inspect Mix.Project.get}"
+    if !scm do
+      Mix.raise(
+        "Could not find an SCM for dependency #{inspect(app)} from #{inspect(Mix.Project.get())}"
+      )
     end
 
     %Mix.Dep{
@@ -140,17 +207,24 @@ defmodule Mix.Dep.Loader do
       app: app,
       requirement: req,
       status: scm_status(scm, opts),
-      opts: opts}
-  end
-
-  defp with_scm_and_app(other) do
-    invalid_dep_format(other)
+      opts: Keyword.put_new(opts, :env, :prod),
+      system_env: Enum.to_list(system_env)
+    }
   end
 
   defp get_scm(app, opts) do
-    Enum.find_value Mix.SCM.available, {nil, opts}, fn(scm) ->
+    Enum.find_value(Mix.SCM.available(), {nil, opts}, fn scm ->
       (new = scm.accepts_options(app, opts)) && {scm, new}
-    end
+    end)
+  end
+
+  # Note that we ignore Make dependencies because the
+  # file based heuristic will always figure it out.
+  @scm_managers ~w(mix rebar3)a
+
+  defp scm_manager(scm, opts) do
+    managers = scm.managers(opts)
+    Enum.find(@scm_managers, &(&1 in managers))
   end
 
   defp scm_status(scm, opts) do
@@ -161,19 +235,20 @@ defmodule Mix.Dep.Loader do
     end
   end
 
-  defp ok?({:ok, _}), do: true
-  defp ok?(_), do: false
+  defp infer_manager(dest) do
+    cond do
+      any_of?(dest, ["mix.exs"]) ->
+        :mix
 
-  defp mix?(dest) do
-    any_of?(dest, ["mix.exs"])
-  end
+      any_of?(dest, ["rebar", "rebar.config", "rebar.config.script", "rebar.lock"]) ->
+        :rebar3
 
-  defp rebar?(dest) do
-    any_of?(dest, ["rebar", "rebar.config", "rebar.config.script"])
-  end
+      any_of?(dest, ["Makefile", "Makefile.win"]) ->
+        :make
 
-  defp make?(dest) do
-    any_of?(dest, ["Makefile", "Makefile.win"])
+      true ->
+        nil
+    end
   end
 
   defp any_of?(dest, files) do
@@ -181,10 +256,10 @@ defmodule Mix.Dep.Loader do
   end
 
   defp invalid_dep_format(dep) do
-    Mix.raise """
+    Mix.raise("""
     Dependency specified in the wrong format:
 
-        #{inspect dep}
+        #{inspect(dep)}
 
     Expected:
 
@@ -194,105 +269,177 @@ defmodule Mix.Dep.Loader do
 
         app :: atom
         requirement :: String.t | Regex.t
-        opts :: Keyword.t
+        opts :: keyword
 
-    """
+    If you want to skip the requirement (not recommended), use ">= 0.0.0".
+    """)
   end
 
   ## Fetching
 
-  defp mix_dep(%Mix.Dep{opts: opts} = dep) do
+  # We need to override the dependencies so they mirror
+  # the :only and :targets requirements from the parent.
+  defp attach_only_and_targets(deps, opts) do
+    case Keyword.take(opts, [:only, :targets]) do
+      [] ->
+        deps
+
+      merge_opts ->
+        Enum.map(deps, fn %{opts: opts} = dep ->
+          %{dep | opts: Keyword.merge(merge_opts, opts)}
+        end)
+    end
+  end
+
+  defp mix_dep(%Mix.Dep{app: app, opts: opts} = dep, nil, locked?) do
     Mix.Dep.in_dependency(dep, fn _ ->
-      config    = Mix.Project.config
-      umbrella? = Mix.Project.umbrella?
+      config = Mix.Project.config()
 
-      if umbrella? do
-        opts = Keyword.put_new(opts, :app, false)
-      end
+      opts =
+        if Mix.Project.umbrella?() do
+          Keyword.put_new(opts, :app, false)
+        else
+          opts
+        end
 
-      if req = old_elixir_req(config) do
-        Mix.shell.error "warning: the dependency #{dep.app} requires Elixir #{inspect req} " <>
-                        "but you are running on v#{System.version}"
-      end
+      child_opts =
+        if opts[:from_umbrella] do
+          if config[:app] != app do
+            Mix.raise(
+              "Umbrella app #{inspect(config[:app])} is located at " <>
+                "directory #{app}. Mix requires the directory to match " <>
+                "the application name for umbrella apps. Please rename the " <>
+                "directory or change the application name in the mix.exs file."
+            )
+          end
 
-      dep = %{dep | manager: :mix, opts: opts, extra: [umbrella: umbrella?]}
-      {dep, children(env: opts[:env] || :prod)}
-    end)
-  end
+          []
+        else
+          [env: Keyword.fetch!(opts, :env)]
+        end
 
-  defp rebar_dep(%Mix.Dep{} = dep) do
-    Mix.Dep.in_dependency(dep, fn _ ->
-      rebar = Mix.Rebar.load_config(".")
-      extra = Dict.take(rebar, [:sub_dirs])
-      dep   = %{dep | manager: :rebar, extra: extra}
-      {dep, rebar_children(rebar)}
+      deps = mix_children(config, locked?, child_opts) ++ Mix.Dep.Umbrella.unloaded()
+      {%{dep | opts: opts}, deps}
     end)
   end
 
-  defp rebar_children(root_config) do
-    from = Path.absname("rebar.config")
-    Mix.Rebar.recur(root_config, fn config ->
-      Mix.Rebar.deps(config) |> Enum.map(&to_dep(&1, from, :rebar))
-    end) |> Enum.concat
+  # If we have a Mix dependency that came from a remote converger,
+  # we just use the dependencies given by the remote converger,
+  # we don't need to load the mix.exs at all. We can only do this
+  # because umbrella projects are not supported in remotes.
+  defp mix_dep(%Mix.Dep{opts: opts} = dep, children, locked?) do
+    from = Path.join(opts[:dest], "mix.exs")
+    deps = Enum.map(children, &to_dep(&1, from, _manager = nil, locked?))
+    {dep, deps}
   end
 
-  defp validate_path(%Mix.Dep{scm: scm, manager: manager} = dep) do
-    if scm == Mix.SCM.Path and not manager in [:mix, nil] do
-      Mix.raise ":path option can only be used with mix projects, " <>
-                                "invalid path dependency for #{inspect dep.app}"
-    else
-      dep
+  defp rebar_dep(dep, children, manager, locked?) do
+    %Mix.Dep{app: app, opts: opts, extra: overrides} = dep
+
+    if locked? and not Mix.Rebar.available?(manager) do
+      Mix.Tasks.Local.Rebar.run(["--force"])
     end
+
+    config = File.cd!(opts[:dest], fn -> Mix.Rebar.load_config(".") end)
+    config = Mix.Rebar.apply_overrides(app, config, overrides)
+
+    deps =
+      if children do
+        from = Path.join(opts[:dest], "rebar.config")
+        # Pass the manager because deps of a Rebar project need
+        # to default to Rebar if we cannot chose a manager from
+        # files in the dependency
+        Enum.map(children, &to_dep(&1, from, manager, locked?))
+      else
+        rebar_children(config, manager, opts[:dest], locked?)
+      end
+
+    {%{dep | extra: config}, deps}
+  end
+
+  defp make_dep(dep) do
+    {dep, []}
+  end
+
+  defp mix_children(config, locked?, opts) do
+    from = Mix.Project.project_file()
+
+    (config[:deps] || [])
+    |> Enum.map(&to_dep(&1, from, _manager = nil, locked?))
+    |> split_by_env_and_target({opts[:env], nil})
+    |> elem(0)
   end
 
-  defp validate_app(%Mix.Dep{opts: opts, requirement: req, app: app, status: status} = dep) do
+  defp rebar_children(config, manager, dest, locked?) do
+    from = Path.absname(Path.join(dest, "rebar.config"))
+    overrides = overrides(manager, config)
+
+    config
+    |> Mix.Rebar.deps()
+    |> Enum.map(fn dep -> %{to_dep(dep, from, manager, locked?) | extra: overrides} end)
+  end
+
+  defp overrides(:rebar3, config), do: config[:overrides] || []
+  defp overrides(_, _config), do: []
+
+  defp validate_app(%Mix.Dep{opts: opts, requirement: req, app: app} = dep) do
     opts_app = opts[:app]
 
     cond do
-      not ok?(status) ->
+      not ok?(dep) ->
         dep
-      recently_fetched?(dep) ->
-        %{dep | status: :compile}
+
       opts_app == false ->
         dep
+
       true ->
         path = if is_binary(opts_app), do: opts_app, else: "ebin/#{app}.app"
         path = Path.expand(path, opts[:build])
-        %{dep | status: app_status(path, app, req)}
-    end
-  end
 
-  defp recently_fetched?(%Mix.Dep{opts: opts, scm: scm}) do
-    scm.fetchable? &&
-      Mix.Utils.stale?([Path.join(opts[:dest], ".fetch")],
-                       [Path.join(opts[:build], ".compile.lock")])
+        case app_status(path, app, req) do
+          {:ok, vsn, app} -> %{dep | status: {:ok, vsn}, opts: [app_properties: app] ++ opts}
+          status -> %{dep | status: status}
+        end
+    end
   end
 
   defp app_status(app_path, app, req) do
-    case :file.consult(app_path) do
-      {:ok, [{:application, ^app, config}]} ->
-        case List.keyfind(config, :vsn, 0) do
+    case Mix.AppLoader.read_app(app, app_path) do
+      {:ok, properties} ->
+        case List.keyfind(properties, :vsn, 0) do
           {:vsn, actual} when is_list(actual) ->
             actual = IO.iodata_to_binary(actual)
-            if vsn_match?(req, actual, app) do
-              {:ok, actual}
-            else
-              {:nomatchvsn, actual}
+
+            case vsn_match(req, actual, app) do
+              {:ok, true} -> compile_env_status(actual, properties)
+              {:ok, false} -> {:nomatchvsn, actual}
+              {:error, error} -> {error, actual}
             end
+
           {:vsn, actual} ->
             {:invalidvsn, actual}
+
           nil ->
             {:invalidvsn, nil}
         end
-      {:ok, _} -> {:invalidapp, app_path}
-      {:error, _} -> {:noappfile, app_path}
+
+      :invalid ->
+        {:invalidapp, app_path}
+
+      :missing ->
+        case Path.wildcard(Path.join(Path.dirname(app_path), "*.app")) do
+          [other_app_path] -> {:noappfile, {app_path, other_app_path}}
+          _ -> {:noappfile, {app_path, nil}}
+        end
     end
   end
 
-  defp old_elixir_req(config) do
-    req = config[:elixir]
-    if req && not Version.match?(System.version, req) do
-      req
+  defp compile_env_status(vsn, properties) do
+    with [_ | _] = compile_env <- properties[:compile_env],
+         false <- Config.Provider.valid_compile_env?(compile_env) do
+      :compile
+    else
+      _ -> {:ok, vsn, properties}
     end
   end
 end
diff --git a/lib/mix/lib/mix/dep/lock.ex b/lib/mix/lib/mix/dep/lock.ex
index fb95a2999e2..a8ec7192f56 100644
--- a/lib/mix/lib/mix/dep/lock.ex
+++ b/lib/mix/lib/mix/dep/lock.ex
@@ -1,82 +1,76 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 # This module keeps a lock file and the manifest for the lock file.
 # The lockfile keeps the latest dependency information while the
 # manifest is used whenever a dependency is affected via any of the
 # deps.* tasks. We also keep the Elixir version in the manifest file.
 defmodule Mix.Dep.Lock do
   @moduledoc false
-  @manifest ".compile.lock"
 
-  @doc """
-  Returns the manifest file for dependencies.
+  @typedoc """
+  Options for `write/2`.
   """
-  def manifest(manifest_path \\ Mix.Project.manifest_path) do
-    Path.join(manifest_path, @manifest)
-  end
-
-  @doc """
-  Touches the manifest timestamp unless it is an umbrella application.
-  """
-  def touch() do
-    unless Mix.Project.umbrella?, do: touch(Mix.Project.manifest_path)
-  end
+  @type write_opts :: [
+          file: Path.t(),
+          check_locked: boolean()
+        ]
 
   @doc """
-  Touches the manifest timestamp and updates the elixir version
-  and mix environment information in the given path.
-  """
-  def touch(manifest_path) do
-    File.mkdir_p!(manifest_path)
-    File.write!(Path.join(manifest_path, @manifest), System.version)
-  end
-
-  @doc """
-  Returns the elixir version in the lock manifest unless is an umbrella app.
+  Reads the lockfile, returns a map containing
+  each app name and its current lock information.
   """
-  def elixir_vsn() do
-    unless Mix.Project.umbrella?, do: elixir_vsn(Mix.Project.manifest_path)
-  end
+  @spec read(Path.t()) :: map()
+  def read(lockfile \\ lockfile()) do
+    opts = [file: lockfile, emit_warnings: false]
 
-  @doc """
-  Returns the elixir version in the lock manifest in the given path.
-  """
-  def elixir_vsn(manifest_path) do
-    case File.read(manifest(manifest_path)) do
-      {:ok, contents} ->
-        contents
-      {:error, _} ->
-        nil
+    with {:ok, contents} <- File.read(lockfile),
+         assert_no_merge_conflicts_in_lockfile(lockfile, contents),
+         {:ok, quoted} <- Code.string_to_quoted(contents, opts),
+         {%{} = lock, _binding} <- Code.eval_quoted(quoted, [], opts) do
+      lock
+    else
+      _ -> %{}
     end
   end
 
   @doc """
-  Read the lockfile, returns a keyword list containing
-  each app name and its current lock information.
+  Receives a map and writes it as the latest lock.
   """
-  def read() do
-    case File.read(lockfile) do
-      {:ok, info} ->
-        {value, _binding} = Code.eval_string(info)
-        value || %{}
-      {:error, _} ->
-        %{}
-    end
-  end
+  @spec write(map(), write_opts) :: :ok
+  def write(map, opts \\ []) do
+    lockfile = opts[:file] || lockfile()
+
+    if map != read() do
+      if Keyword.get(opts, :check_locked, false) do
+        Mix.raise(
+          "Your #{lockfile} is out of date and must be updated without the --check-locked flag"
+        )
+      end
 
-  @doc """
-  Receives a keyword list and writes it as the latest lock.
-  """
-  def write(map) do
-    unless map == read do
       lines =
-        for {app, rev} <- map, rev != nil do
-          ~s("#{app}": #{inspect rev, limit: :infinity})
+        for {app, rev} <- Enum.sort(map), rev != nil do
+          ~s(  "#{app}": #{inspect(rev, limit: :infinity)},\n)
         end
-      File.write! lockfile, "%{" <> Enum.join(lines, ",\n  ") <> "}\n"
-      touch
+
+      File.write!(lockfile, ["%{\n", lines, "}\n"])
+      Mix.Task.run("will_recompile")
     end
+
+    :ok
   end
 
   defp lockfile do
-    Mix.Project.config[:lockfile]
+    Mix.Project.config()[:lockfile]
+  end
+
+  defp assert_no_merge_conflicts_in_lockfile(lockfile, info) do
+    if String.contains?(info, ~w(<<<<<<< ======= >>>>>>>)) do
+      Mix.raise(
+        "Your #{lockfile} contains merge conflicts. Please resolve the conflicts " <>
+          "and run the command again"
+      )
+    end
   end
 end
diff --git a/lib/mix/lib/mix/dep/umbrella.ex b/lib/mix/lib/mix/dep/umbrella.ex
index fc78fb17ed7..820623ded73 100644
--- a/lib/mix/lib/mix/dep/umbrella.ex
+++ b/lib/mix/lib/mix/dep/umbrella.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Dep.Umbrella do
   @moduledoc false
 
@@ -5,61 +9,69 @@ defmodule Mix.Dep.Umbrella do
   Gets all umbrella dependencies in unloaded format.
   """
   def unloaded do
-    config = Mix.Project.config
+    config = Mix.Project.config()
+
+    if apps_paths = Mix.Project.apps_paths(config) do
+      env = Mix.env()
+      from = Path.absname("mix.exs")
+      build = Mix.Project.build_path(config)
+
+      for {app, path} <- apps_paths do
+        dest_path = Path.expand(path)
+        build_path = Path.join([build, "lib", Atom.to_string(app)])
 
-    if apps_path = config[:apps_path] do
-      paths = Path.wildcard(Path.join(apps_path, "*"))
-      build = Mix.Project.build_path
+        opts = [
+          path: path,
+          dest: dest_path,
+          from_umbrella: true,
+          env: env,
+          build: build_path
+        ]
 
-      paths
-      |> Enum.filter(&File.dir?(&1))
-      |> extract_umbrella
-      |> filter_umbrella(config[:apps])
-      |> to_umbrella_dep(build)
+        %Mix.Dep{
+          scm: Mix.SCM.Path,
+          app: app,
+          requirement: nil,
+          manager: :mix,
+          status: {:ok, nil},
+          from: from,
+          opts: opts
+        }
+      end
     else
       []
     end
   end
 
+  @doc """
+  Gets all umbrella dependencies in the loaded format from cache (if available).
+  """
+  def cached do
+    if project = Mix.Project.get() do
+      key = {:umbrella_deps, Mix.env(), project}
+      Mix.State.read_cache(key) || Mix.State.write_cache(key, loaded())
+    else
+      loaded()
+    end
+  end
+
   @doc """
   Gets all umbrella dependencies in the loaded format.
   """
   def loaded do
-    deps = unloaded
-    apps = Enum.map(deps, &(&1.app))
+    deps = unloaded()
+    apps = Enum.map(deps, & &1.app)
 
     Enum.map(deps, fn umbrella_dep ->
-      umbrella_dep = Mix.Dep.Loader.load(umbrella_dep)
-      deps = Enum.filter(umbrella_dep.deps, fn dep ->
-        Mix.Dep.available?(dep) and dep.app in apps
-      end)
-      %{umbrella_dep | deps: deps}
-    end) |> Mix.Dep.Converger.topsort
-  end
-
-  defp extract_umbrella(paths) do
-    for path <- paths do
-      app = path |> Path.basename |> String.downcase |> String.to_atom
-      {app, path}
-    end
-  end
+      umbrella_dep = Mix.Dep.Loader.load(umbrella_dep, nil, false)
 
-  defp filter_umbrella(pairs, nil), do: pairs
-  defp filter_umbrella(pairs, apps) when is_list(apps) do
-    for {app, _} = pair <- pairs, app in apps, do: pair
-  end
+      deps =
+        Enum.filter(umbrella_dep.deps, fn dep ->
+          Mix.Dep.available?(dep) and dep.app in apps
+        end)
 
-  defp to_umbrella_dep(paths, build) do
-    Enum.map paths, fn({app, path}) ->
-      opts = [path: path, dest: Path.expand(path), from_umbrella: true,
-              env: Mix.env, build: Path.join([build, "lib", Atom.to_string(app)])]
-      %Mix.Dep{
-        scm: Mix.SCM.Path,
-        app: app,
-        requirement: nil,
-        manager: :mix,
-        status: {:ok, nil},
-        opts: opts}
-    end
+      %{umbrella_dep | deps: deps}
+    end)
+    |> Mix.Dep.Converger.topological_sort()
   end
 end
diff --git a/lib/mix/lib/mix/exceptions.ex b/lib/mix/lib/mix/exceptions.ex
index c2fe48ab6af..5579fac9ed2 100644
--- a/lib/mix/lib/mix/exceptions.ex
+++ b/lib/mix/lib/mix/exceptions.ex
@@ -1,39 +1,94 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.NoTaskError do
-  defexception [:task, :message, :mix]
+  defexception [:task, :message, mix: true]
 
+  @impl true
   def exception(opts) do
     task = opts[:task]
-    %Mix.NoTaskError{task: task, message: "The task #{task} could not be found"}
+    %Mix.NoTaskError{task: task, message: msg(task)}
+  end
+
+  defp msg(task) do
+    msg = "The task #{inspect(task)} could not be found"
+
+    case did_you_mean(task) do
+      {mod, ^task, _score} ->
+        msg <>
+          " because the module is named #{inspect(mod)} instead of " <>
+          "#{expected_mod_name(task)} as expected. Please rename it and try again"
+
+      {_mod, similar, score} when score > 0.8 ->
+        msg <> ". Did you mean #{inspect(similar)}?" <> maybe_no_project()
+
+      _otherwise ->
+        msg <> maybe_no_project()
+    end
+  end
+
+  defp maybe_no_project do
+    if Mix.Project.get() do
+      ""
+    else
+      "\nNote no mix.exs was found in the current directory"
+    end
+  end
+
+  defp did_you_mean(task) do
+    # Ensure all tasks are loaded
+    Mix.Task.load_all()
+
+    Mix.Task.all_modules()
+    |> Enum.map(&{&1, Mix.Task.task_name(&1)})
+    |> Enum.reduce({nil, nil, 0}, &max_similar(&1, task, &2))
+  end
+
+  defp max_similar({mod, source}, target, {_, _, current} = best) do
+    score = String.jaro_distance(source, target)
+    if score < current, do: best, else: {mod, source, score}
+  end
+
+  defp expected_mod_name(task) do
+    "Mix.Tasks." <> Mix.Utils.command_to_module_name(task)
   end
 end
 
 defmodule Mix.InvalidTaskError do
-  defexception [:task, :message, :mix]
+  defexception [:task, :message, mix: true]
 
+  @impl true
   def exception(opts) do
     task = opts[:task]
-    %Mix.InvalidTaskError{task: task, message: "The task #{task} does not export run/1"}
+    %Mix.InvalidTaskError{task: task, message: "The task #{inspect(task)} does not export run/1"}
   end
 end
 
 defmodule Mix.ElixirVersionError do
-  defexception [:target, :expected, :actual, :message, :mix]
+  defexception [:target, :expected, :actual, :message, mix: true]
 
+  @impl true
   def exception(opts) do
-    target   = opts[:target]
-    actual   = opts[:actual]
+    target = opts[:target]
+    actual = opts[:actual]
     expected = opts[:expected]
-    message  = "You're trying to run #{inspect target} on Elixir v#{actual} but it " <>
-               "has declared in its mix.exs file it supports only Elixir #{expected}"
+
+    message =
+      "You're trying to run #{inspect(target)} on Elixir v#{actual} but it " <>
+        "has declared in its mix.exs file it supports only Elixir #{expected}"
+
     %Mix.ElixirVersionError{target: target, expected: expected, actual: actual, message: message}
   end
 end
 
 defmodule Mix.NoProjectError do
-  defexception message: "Could not find a Mix.Project, please ensure a mix.exs file is available",
-               mix: nil
+  message =
+    "Could not find a Mix.Project, please ensure you are running Mix in a directory with a mix.exs file"
+
+  defexception message: message, mix: true
 end
 
 defmodule Mix.Error do
-  defexception [:mix, :message]
+  defexception [:message, mix: 1]
 end
diff --git a/lib/mix/lib/mix/generator.ex b/lib/mix/lib/mix/generator.ex
index 5f7d829139c..e04e4ca30dd 100644
--- a/lib/mix/lib/mix/generator.ex
+++ b/lib/mix/lib/mix/generator.ex
@@ -1,50 +1,184 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Generator do
   @moduledoc """
   Conveniences for working with paths and generating content.
-
-  All of those functions are verbose, in the sense they log
-  the action to be performed via `Mix.shell`.
   """
 
-  @doc """
+  @type generator_opts :: [
+          force: boolean(),
+          quiet: boolean(),
+          format_elixir: boolean()
+        ]
+
+  @doc ~S"""
   Creates a file with the given contents.
-  If the file already exists, asks for user confirmation.
+
+  If the file already exists and the contents are not the same,
+  it asks for user confirmation.
+
+  ## Options
+
+    * `:force` - forces creation without a shell prompt
+    * `:quiet` - does not log command output
+    * `:format_elixir` (since v1.18.0) - if `true`, apply formatter to the generated file
+
+  ## Examples
+
+      iex> Mix.Generator.create_file(".gitignore", "_build\ndeps\n")
+      * creating .gitignore
+      true
+
   """
-  def create_file(path, contents) when is_binary(path) do
-    Mix.shell.info "%{green}* creating%{reset} #{Path.relative_to_cwd path}"
+  @spec create_file(Path.t(), iodata, generator_opts) :: boolean()
+  def create_file(path, contents, opts \\ []) when is_binary(path) do
+    log(:green, :creating, Path.relative_to_cwd(path), opts)
 
-    if overwriting?(path) do
+    if opts[:force] || overwrite?(path, contents) do
       File.mkdir_p!(Path.dirname(path))
+
+      contents =
+        case opts[:format_elixir] do
+          true -> [Code.format_string!(contents), ?\n]
+          _ -> contents
+        end
+
       File.write!(path, contents)
+      true
+    else
+      false
     end
   end
 
   @doc """
   Creates a directory if one does not exist yet.
+
+  This function does nothing if the given directory already exists; in this
+  case, it still logs the directory creation.
+
+  ## Options
+
+    * `:quiet` - does not log command output
+
+  ## Examples
+
+      iex> Mix.Generator.create_directory("path/to/dir")
+      * creating path/to/dir
+      true
+
+  """
+  @spec create_directory(Path.t(), quiet: boolean()) :: true
+  def create_directory(path, options \\ []) when is_binary(path) do
+    log(:green, "creating", Path.relative_to_cwd(path), options)
+    File.mkdir_p!(path)
+    true
+  end
+
+  @doc ~S"""
+  Copies `source` to `target`.
+
+  If `target` already exists and the contents are not the same,
+  it asks for user confirmation.
+
+  ## Options
+
+    * `:force` - forces copying without a shell prompt
+    * `:quiet` - does not log command output
+    * `:format_elixir` (since v1.18.0) - if `true`, apply formatter to the generated file
+
+  ## Examples
+
+      iex> Mix.Generator.copy_file("source/gitignore", ".gitignore")
+      * creating .gitignore
+      true
+
   """
-  def create_directory(path) when is_binary(path) do
-    Mix.shell.info "%{green}* creating%{reset} #{Path.relative_to_cwd path}"
-    File.mkdir_p! path
+  @doc since: "1.9.0"
+  @spec copy_file(Path.t(), Path.t(), generator_opts) :: boolean()
+  def copy_file(source, target, options \\ []) do
+    create_file(target, File.read!(source), options)
   end
 
-  defp overwriting?(path) do
+  @doc ~S"""
+  Evaluates and copy templates at `source` to `target`.
+
+  The template in `source` is evaluated with the given `assigns`.
+
+  If `target` already exists and the contents are not the same,
+  it asks for user confirmation.
+
+  ## Options
+
+    * `:force` - forces copying without a shell prompt
+    * `:quiet` - does not log command output
+    * `:format_elixir` (since v1.18.0) - if `true`, apply formatter to the generated file
+
+  ## Examples
+
+      iex> assigns = [project_path: "/Users/joe/newproject"]
+      iex> Mix.Generator.copy_template("source/gitignore", ".gitignore", assigns)
+      * creating .gitignore
+      true
+
+  """
+  @doc since: "1.9.0"
+  @spec copy_template(Path.t(), Path.t(), keyword, generator_opts) :: boolean()
+  def copy_template(source, target, assigns, options \\ []) do
+    create_file(target, EEx.eval_file(source, assigns: assigns), options)
+  end
+
+  @doc """
+  Prompts the user to overwrite the file if it exists.
+
+  Returns `false` if the file exists and the user forbade
+  to override it. Returns `true` otherwise.
+  """
+  @doc since: "1.9.0"
+  @spec overwrite?(Path.t()) :: boolean
+  def overwrite?(path) do
     if File.exists?(path) do
       full = Path.expand(path)
-      Mix.shell.yes?(Path.relative_to_cwd(full) <> " already exists, overwrite?")
+      Mix.shell().yes?(Path.relative_to_cwd(full) <> " already exists, overwrite?")
     else
       true
     end
   end
 
-  @doc false
-  defmacro from_file(path) do
-    quote do
-      File.read! Path.expand(unquote(path), __ENV__.file)
+  @doc """
+  Prompts the user to overwrite the file if it exists.
+
+  The contents are compared to avoid asking the user to
+  override if the contents did not change. Returns `false`
+  if the file exists and the content is the same or the
+  user forbade to override it. Returns `true` otherwise.
+  """
+  @doc since: "1.9.0"
+  @spec overwrite?(Path.t(), iodata) :: boolean
+  def overwrite?(path, contents) do
+    case File.read(path) do
+      {:ok, binary} ->
+        if binary == IO.iodata_to_binary(contents) do
+          false
+        else
+          full = Path.expand(path)
+          Mix.shell().yes?(Path.relative_to_cwd(full) <> " already exists, overwrite?")
+        end
+
+      _ ->
+        true
+    end
+  end
+
+  defp log(color, command, message, opts) do
+    if !opts[:quiet] do
+      Mix.shell().info([color, "* #{command} ", :reset, message])
     end
   end
 
   @doc """
-  Embed a template given by `contents` into the current module.
+  Embeds a template given by `contents` into the current module.
 
   It will define a private function with the `name` followed by
   `_template` that expects assigns as arguments.
@@ -54,23 +188,35 @@ defmodule Mix.Generator do
   template using the `@` macro.
 
   For more information, check `EEx.SmartEngine`.
+
+  ## Examples
+
+      defmodule Mix.Tasks.MyTask do
+        require Mix.Generator
+        Mix.Generator.embed_template(:log, "Log: <%= @log %>")
+      end
+
   """
   defmacro embed_template(name, contents) do
-    quote bind_quoted: binding do
+    quote bind_quoted: binding() do
       contents =
         case contents do
           [from_file: file] ->
             @file file
             File.read!(file)
+
           c when is_binary(c) ->
-            @file {__ENV__.file, __ENV__.line+1}
+            @file {__ENV__.file, __ENV__.line + 1}
             c
+
           _ ->
             raise ArgumentError, "expected string or from_file: file"
         end
 
       require EEx
-      EEx.function_from_string :defp, :"#{name}_template", "<% _ = assigns %>" <> contents, [:assigns]
+
+      source = "<% _ = assigns %>" <> contents
+      EEx.function_from_string(:defp, :"#{name}_template", source, [:assigns])
     end
   end
 
@@ -78,16 +224,25 @@ defmodule Mix.Generator do
   Embeds a text given by `contents` into the current module.
 
   It will define a private function with the `name` followed by
-  `_text` that expects no argument.
+  `_text` that expects no arguments.
+
+  ## Examples
+
+      defmodule Mix.Tasks.MyTask do
+        require Mix.Generator
+        Mix.Generator.embed_text(:error, "There was an error!")
+      end
+
   """
   defmacro embed_text(name, contents) do
-    quote bind_quoted: binding do
+    quote bind_quoted: binding() do
       contents =
         case contents do
           [from_file: f] -> File.read!(f)
           c when is_binary(c) -> c
           _ -> raise ArgumentError, "expected string or from_file: file"
         end
+
       defp unquote(:"#{name}_text")(), do: unquote(contents)
     end
   end
diff --git a/lib/mix/lib/mix/hex.ex b/lib/mix/lib/mix/hex.ex
new file mode 100644
index 00000000000..21cef2607f2
--- /dev/null
+++ b/lib/mix/lib/mix/hex.ex
@@ -0,0 +1,82 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Hex do
+  @moduledoc false
+  @compile {:no_warn_undefined, Hex}
+  @hex_requirement ">= 2.0.6"
+  @hex_builds_url "https://builds.hex.pm"
+
+  @doc """
+  Returns `true` if `Hex` is loaded or installed.
+
+  Otherwise returns `false`.
+  """
+  @spec ensure_installed?(boolean) :: boolean
+  def ensure_installed?(force?) do
+    cond do
+      Code.ensure_loaded?(Hex) -> true
+      force? or install_hex?() -> Mix.Tasks.Local.Hex.run(["--force"])
+      true -> false
+    end
+  end
+
+  defp install_hex? do
+    shell = Mix.shell()
+    shell.info("Mix requires the Hex package manager to fetch dependencies")
+
+    shell.yes?(
+      "Shall I install Hex? (if running non-interactively, use \"mix local.hex --force\")"
+    )
+  end
+
+  @doc """
+  Returns `true` if it has the required `Hex`. If an update is performed, it then exits.
+  Otherwise returns `false` without updating anything.
+  """
+  @spec ensure_updated?() :: boolean
+  def ensure_updated?() do
+    cond do
+      not Code.ensure_loaded?(Hex) ->
+        false
+
+      not Version.match?(Hex.version(), @hex_requirement) ->
+        Mix.shell().info("Mix requires Hex #{@hex_requirement} but you have #{Hex.version()}")
+
+        if Mix.shell().yes?("Shall I abort the current command and update Hex?") do
+          Mix.Tasks.Local.Hex.run(["--force"])
+          exit({:shutdown, 0})
+        end
+
+        false
+
+      true ->
+        true
+    end
+  end
+
+  @doc """
+  Ensures `Hex` is started.
+  """
+  def start do
+    try do
+      Hex.start()
+    catch
+      kind, reason ->
+        Mix.shell().error(
+          "Could not start Hex. Try fetching a new version with " <>
+            "\"mix local.hex\" or uninstalling it with \"mix archive.uninstall hex.ez\""
+        )
+
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    end
+  end
+
+  @doc """
+  Returns the URL to the Hex build assets.
+  """
+  def url do
+    System.get_env("HEX_BUILDS_URL") || System.get_env("HEX_MIRROR") || @hex_builds_url
+  end
+end
diff --git a/lib/mix/lib/mix/local.ex b/lib/mix/lib/mix/local.ex
index 2d8ccb0e9be..7070ad8d524 100644
--- a/lib/mix/lib/mix/local.ex
+++ b/lib/mix/lib/mix/local.ex
@@ -1,56 +1,229 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Local do
   @moduledoc false
 
   @doc """
-  The path for local archives.
+  Returns the name for an archive or an escript, based on the project config.
+
+  ## Examples
 
-  It checks the `MIX_ARCHIVES` variable or it uses the
-  "archives" directory inside `Mix.Utils.mix_home/0`.
+      iex> Mix.Local.name_for(:archives, app: "foo", version: "0.1.0")
+      "foo-0.1.0.ez"
+
+      iex> Mix.Local.name_for(:escripts, escript: [name: "foo"])
+      "foo"
 
-  Since archives are specific to Elixir versions, it is
-  expected from build tools to swap the `MIX_ARCHIVES`
-  variable to different locations based on a particular
-  Elixir installation.
   """
-  def archives_path do
-    System.get_env("MIX_ARCHIVES") ||
-      Path.join(Mix.Utils.mix_home, "archives")
+  @spec name_for(:archives | :escripts, keyword) :: String.t()
+  def name_for(:archives, project) do
+    version = if version = project[:version], do: "-#{version}"
+    "#{project[:app]}#{version}.ez"
+  end
+
+  def name_for(:escripts, project) do
+    case get_in(project, [:escript, :name]) do
+      nil -> project[:app]
+      name -> name
+    end
+    |> to_string()
   end
 
+  @deprecated "Use Mix.path_for/1 instead"
+  def path_for(:archive), do: Mix.path_for(:archives)
+  def path_for(:escript), do: Mix.path_for(:escripts)
+
   @doc """
-  Append archives paths into Erlang code path.
+  Appends archive paths to the Erlang code path.
   """
   def append_archives do
-    Enum.each(archives_ebin, &Code.append_path(&1))
+    for archive <- archives_ebins() do
+      check_elixir_version_in_ebin(archive)
+      Code.append_path(archive, cache: true)
+    end
+
+    :ok
   end
 
   @doc """
-  Append mix paths into Erlang code path.
+  Removes archive paths from Erlang code path.
+  """
+  def remove_archives do
+    for archive <- archives_ebins() do
+      Code.delete_path(archive)
+    end
+
+    :ok
+  end
+
+  @doc """
+  Appends Mix paths to the Erlang code path.
+
+  We don't cache them as they are rarely used and
+  they may be development paths.
   """
   def append_paths do
-    Enum.each(Mix.Utils.mix_paths, &Code.append_path(&1))
+    Enum.each(mix_paths(), &Code.append_path/1)
+  end
+
+  @doc """
+  Removes Mix paths from the Erlang code path.
+  """
+  def remove_paths do
+    Enum.each(mix_paths(), &Code.delete_path/1)
+  end
+
+  defp mix_paths do
+    if path = System.get_env("MIX_PATH") do
+      String.split(path, path_separator())
+    else
+      []
+    end
+  end
+
+  defp path_separator do
+    case :os.type() do
+      {:win32, _} -> ";"
+      {:unix, _} -> ":"
+    end
   end
 
   @doc """
   Returns all tasks in local archives.
   """
-  def all_tasks, do: Mix.Task.load_tasks(archives_ebin)
+  def archives_tasks do
+    Mix.Task.load_tasks(archives_ebins())
+  end
+
+  @doc """
+  Returns the name of an archive given a path.
+  """
+  def archive_name(path) do
+    path
+    |> Path.basename()
+    |> Path.rootname(".ez")
+  end
+
+  @doc """
+  Returns the ebin path of an archive.
+  """
+  def archive_ebin(path) do
+    Path.join([path, archive_name(path), "ebin"])
+  end
+
+  defp archives_ebins do
+    path = Mix.path_for(:archives)
+
+    case File.ls(path) do
+      {:ok, entries} -> Enum.map(entries, &archive_ebin(Path.join(path, &1)))
+      {:error, _} -> []
+    end
+  end
 
   @doc """
-  Returns paths of all archive files matching given
-  application name.
+  Checks Elixir version requirement stored in the ebin directory
+  and print a warning if it is not satisfied.
   """
-  def archive_files(name) do
-    archives(name, ".ez") ++ archives(name, "-*.ez")
+  def check_elixir_version_in_ebin(ebin) do
+    elixir = ebin |> Path.dirname() |> Path.join(".elixir") |> String.to_charlist()
+
+    case File.read(elixir) do
+      {:ok, req} ->
+        if !Version.match?(System.version(), req) do
+          archive = ebin |> Path.dirname() |> Path.basename()
+
+          Mix.shell().error(
+            "warning: the archive #{archive} requires Elixir #{inspect(req)} " <>
+              "but you are running on v#{System.version()}"
+          )
+        end
+
+        :ok
+
+      {:error, _} ->
+        :ok
+    end
   end
 
-  defp archives(name, suffix) do
-    Mix.Local.archives_path
-    |> Path.join(name <> suffix)
-    |> Path.wildcard
+  @doc """
+  Fetches the given signed CSV files, verifies and returns the matching
+  Elixir version, artifact version and artifact's checksum.
+
+  Used to install both Rebar and Hex from S3.
+  """
+  def find_matching_versions!(name, version, path) do
+    name
+    |> read_path!(path)
+    |> parse_csv()
+    |> find_latest_eligible_version(version)
+    |> Kernel.||(Mix.raise("Could not find a version of #{name} matching: #{version}"))
+  end
+
+  defp read_path!(name, path) do
+    case Mix.Utils.read_path(path) do
+      {:ok, contents} ->
+        contents
+
+      {:remote, message} ->
+        Mix.raise(
+          """
+          #{message}
+
+          Could not install #{name} because Mix could not download metadata at #{path}.
+          """ <> suggestions(name)
+        )
+    end
+  end
+
+  defp suggestions("Hex") do
+    """
+
+    Alternatively, you can compile and install Hex directly with this command:
+
+        $ mix archive.install github hexpm/hex branch latest
+    """
+  end
+
+  defp suggestions(_) do
+    ""
+  end
+
+  defp parse_csv(body) do
+    body
+    |> :binary.split("\n", [:global, :trim])
+    |> Enum.map(&:binary.split(&1, ",", [:global, :trim]))
+  end
+
+  defp find_latest_eligible_version(entries, artifact_version) do
+    elixir_version = Version.parse!(System.version())
+    otp_release = System.otp_release()
+
+    entries
+    |> Enum.reverse()
+    |> find_version(artifact_version, elixir_version, otp_release)
+  end
+
+  defp find_version(entries, artifact_version, elixir_version, otp_release) do
+    entries =
+      if artifact_version do
+        Enum.filter(entries, &(hd(&1) == artifact_version))
+      else
+        entries
+      end
+
+    Enum.find_value(entries, &find_by_elixir_version(&1, elixir_version, otp_release))
   end
 
-  defp archives_ebin do
-    Path.join(archives_path, "*.ez") |> Path.wildcard |> Enum.map(&Mix.Archive.ebin/1)
+  defp find_by_elixir_version(
+         [artifact_version, digest, hex_elixir_version, hex_otp_release | _],
+         elixir_version,
+         otp_release
+       ) do
+    if Version.compare(hex_elixir_version, elixir_version) != :gt and
+         hex_otp_release <= otp_release do
+      {hex_elixir_version, artifact_version, digest, hex_otp_release}
+    end
   end
 end
diff --git a/lib/mix/lib/mix/local/installer.ex b/lib/mix/lib/mix/local/installer.ex
new file mode 100644
index 00000000000..2dc14451ba8
--- /dev/null
+++ b/lib/mix/lib/mix/local/installer.ex
@@ -0,0 +1,428 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Local.Installer do
+  @moduledoc false
+
+  # This module implements pieces of functionality shared
+  # by the archive- and escript-related tasks.
+
+  @typedoc """
+  Installs types supported by `Mix.Local.Installer`.
+
+    * `:project` - installs the current Mix project's artifact
+    * `:local` - installs the artifact located at `path`
+    * `:url` - installs the artifact retrievable at `url`
+    * `:fetcher` - builds and install the artifact generated by the `dep_spec`
+
+  """
+  @type install_spec ::
+          :project
+          | {:local, path :: Path.t()}
+          | {:url, url :: binary}
+          | {:fetcher, dep_spec :: tuple}
+
+  @typedoc """
+  Options for installer functions.
+
+  These options are used by various installer functions to control behavior
+  during installation, parsing, and uninstallation.
+  """
+  @type installer_opts :: [
+          app: String.t(),
+          submodules: boolean(),
+          sparse: String.t(),
+          force: boolean(),
+          sha512: String.t(),
+          organization: String.t(),
+          repo: String.t(),
+          timeout: pos_integer()
+        ]
+
+  @doc """
+  Checks that the `install_spec` and `opts` are supported by the respective module.
+  """
+  @callback check_install_spec(install_spec, opts :: installer_opts) :: :ok | {:error, String.t()}
+
+  @doc """
+  Returns a list of already installed version of the same artifact.
+  """
+  @callback find_previous_versions(basename :: String.t()) :: [Path.t()]
+
+  @doc """
+  Builds a local artifact either from a remote dependency or for
+  the current project.
+  """
+  @callback build(install_spec, opts :: installer_opts) :: Path.t()
+
+  @doc """
+  The installation itself.
+  """
+  @callback install(basename :: String.t(), contents :: binary, previous :: [Path.t()]) :: :ok
+
+  @doc """
+  Common implementation of installation for archives and escripts.
+
+  Relies on a few callbacks provided by respective callback modules
+  for customizing certain steps in the installation process.
+  """
+  @spec install(module, OptionParser.argv(), keyword) :: boolean
+  def install(module, argv, switches) do
+    {opts, args} = OptionParser.parse!(argv, strict: switches)
+
+    install_spec =
+      case parse_args(args, opts) do
+        {:error, message} -> Mix.raise(message <> "\n\n" <> usage(module))
+        install_spec -> install_spec
+      end
+
+    case module.check_install_spec(install_spec, opts) do
+      :ok -> :noop
+      {:error, message} -> Mix.raise(message <> "\n\n" <> usage(module))
+    end
+
+    case install_spec do
+      {:fetcher, dep_spec} ->
+        if opts[:sha512] do
+          Mix.raise(
+            "--sha512 is not supported when installing from git/github/hex\n\n" <> usage(module)
+          )
+        end
+
+        fetch(dep_spec, fn _ ->
+          local_install(module, module.build(install_spec, opts), opts)
+        end)
+
+      {path_or_url, src} when path_or_url in [:local, :url] ->
+        local_install(module, src, opts)
+
+      :project ->
+        local_install(module, module.build(install_spec, opts), opts)
+    end
+  end
+
+  defp task(module) do
+    Mix.Utils.module_name_to_command(module, 2)
+  end
+
+  defp usage(module) do
+    "For more information run \"mix help #{task(module)}\""
+  end
+
+  defp local_path?(url_or_path) do
+    File.regular?(url_or_path)
+  end
+
+  defp file_url?(url_or_path) do
+    URI.parse(url_or_path).scheme in ["http", "https"]
+  end
+
+  defp local_install(module, src, opts) do
+    basename = Path.basename(URI.parse(src).path)
+    previous_files = module.find_previous_versions(basename)
+
+    if opts[:force] || should_install?(src, previous_files) do
+      case Mix.Utils.read_path(src, opts) do
+        {:ok, binary} ->
+          module.install(basename, binary, previous_files)
+
+        :badpath ->
+          Mix.raise("Expected #{inspect(src)} to be a local file path")
+
+        {:local, message} ->
+          Mix.raise(message)
+
+        {kind, message} when kind in [:remote, :checksum] ->
+          Mix.raise("""
+          #{message}
+
+          Could not run #{task(module)} for:
+
+              #{src}
+
+          Please download the file above to your current directory and run:
+
+              mix #{task(module)} ./#{basename}
+
+          You can download it either with your browser or via the command line.
+
+          On Unix-like operating systems (Linux, macOS):
+
+              wget #{src}
+
+          or
+
+              curl -o #{basename} #{src}
+
+          On Windows / PowerShell (Windows 7 or later):
+
+              powershell -Command "Invoke-WebRequest #{src} -OutFile #{basename}"
+
+          or
+
+              powershell -Command "(New-Object Net.WebClient).DownloadFile('#{src}', '#{basename}')"
+          """)
+      end
+
+      true
+    else
+      false
+    end
+  end
+
+  defp should_install?(src, previous_files) do
+    message =
+      case previous_files do
+        [] ->
+          "Are you sure you want to install #{inspect(src)}?"
+
+        [file] ->
+          "Found existing entry: #{file}\n" <>
+            "Are you sure you want to replace it with #{inspect(src)}?"
+
+        files ->
+          "Found existing entries: #{Enum.map_join(files, ", ", &Path.basename/1)}\n" <>
+            "Are you sure you want to replace them with #{inspect(src)}?"
+      end
+
+    Mix.shell().yes?(message)
+  end
+
+  @doc """
+  Receives `argv` and `opts` from options parsing and returns an `install_spec`.
+  """
+  @spec parse_args([String.t()], installer_opts) :: install_spec | {:error, String.t()}
+  def parse_args(argv, opts)
+
+  def parse_args([], _opts) do
+    :project
+  end
+
+  def parse_args([url_or_path], _opts) do
+    cond do
+      local_path?(url_or_path) -> {:local, url_or_path}
+      file_url?(url_or_path) -> {:url, url_or_path}
+      true -> {:error, "Expected #{inspect(url_or_path)} to be a local file path"}
+    end
+  end
+
+  def parse_args(["github" | rest], opts) do
+    [repo | rest] = rest
+    url = "https://github.com/#{repo}.git"
+    parse_args(["git", url] ++ rest, opts)
+  end
+
+  def parse_args(["git", url], opts) do
+    git_fetcher(url, [], opts)
+  end
+
+  def parse_args(["git", url, ref_type, ref], opts) do
+    case ref_to_config(ref_type, ref) do
+      {:error, error} ->
+        {:error, error}
+
+      git_config ->
+        git_fetcher(url, git_config, opts)
+    end
+  end
+
+  def parse_args(["git" | [_url | rest]], _opts) do
+    {:error, "received invalid git checkout spec: #{Enum.join(rest, " ")}"}
+  end
+
+  def parse_args(["hex", package_name], opts) do
+    parse_args(["hex", package_name, ">= 0.0.0"], opts)
+  end
+
+  def parse_args(["hex", package_name, version], opts) do
+    app_name =
+      if opts[:app] do
+        opts[:app]
+      else
+        package_name
+      end
+
+    dep_opts = [
+      hex: String.to_atom(package_name),
+      repo: hex_repo(opts)
+    ]
+
+    {:fetcher, {String.to_atom(app_name), version, dep_opts}}
+  end
+
+  def parse_args(["hex" | [_package_name | rest]], _opts) do
+    {:error, "received invalid Hex package spec: #{Enum.join(rest, " ")}"}
+  end
+
+  defp hex_repo(opts) do
+    repo = Keyword.get(opts, :repo, "hexpm")
+
+    if organization = opts[:organization] do
+      repo <> ":" <> organization
+    else
+      repo
+    end
+  end
+
+  defp git_fetcher(url, git_config, opts) do
+    git_opts = git_config ++ [git: url, submodules: opts[:submodules], sparse: opts[:sparse]]
+
+    app_name =
+      if opts[:app] do
+        opts[:app]
+      else
+        "new package"
+      end
+
+    {:fetcher, {String.to_atom(app_name), git_opts}}
+  end
+
+  defp ref_to_config("branch", branch), do: [branch: branch]
+  defp ref_to_config("tag", tag), do: [tag: tag]
+  defp ref_to_config("ref", ref), do: [ref: ref]
+
+  defp ref_to_config(ref_type, _) do
+    {:error, "expected one of \"branch\", \"tag\", or \"ref\". Got: \"#{ref_type}\""}
+  end
+
+  @doc """
+  A common implementation for uninstalling archives and scripts.
+  """
+  @spec uninstall(Path.t(), String.t(), OptionParser.argv(), keyword) :: Path.t() | nil
+  def uninstall(root, listing, argv, switches) do
+    {opts, argv} = OptionParser.parse!(argv, switches: switches)
+
+    if name = List.first(argv) do
+      found =
+        if File.exists?(Path.join(root, name)) do
+          Path.join(root, name)
+        else
+          matching_package(root, name)
+        end
+
+      cond do
+        found && should_uninstall?(found, opts) ->
+          File.rm_rf!(found)
+          found
+
+        found ->
+          nil
+
+        true ->
+          Mix.shell().error("Could not find a local artifact named #{inspect(name)}. We found:")
+          Mix.Task.rerun(listing)
+          nil
+      end
+    else
+      Mix.raise(
+        "No argument was given to uninstall command. " <>
+          " Use \"mix #{listing}.uninstall PATH\" or run \"mix help #{listing}.uninstall\" for more information"
+      )
+    end
+  end
+
+  defp matching_package(root, name) do
+    root |> Path.join(name <> "-*") |> Path.wildcard() |> List.first()
+  end
+
+  defp should_uninstall?(path, opts) do
+    opts[:force] || Mix.shell().yes?("Are you sure you want to uninstall #{path}?")
+  end
+
+  @doc """
+  Fetches `dep_spec` with `in_fetcher` and then runs `in_package`.
+
+  Generates a new Mix project in a temporary directory with the given `dep_spec`
+  added to a mix.exs. Then, `in_fetcher` is executed in the fetcher project. By
+  default, this fetches the dependency, but you can provide an `in_fetcher`
+  during test or for other purposes. After the `in_fetcher` is executed,
+  `in_package` is executed in the now (presumably) fetched package, with the
+  package's config overridden with the deps_path and lockfile of the fetcher
+  package. Also, the Mix env is set to :prod.
+  """
+  @spec fetch(tuple, (atom -> any), (atom -> any)) :: any
+  def fetch(dep_spec, in_fetcher \\ &in_fetcher/1, in_package) do
+    tmp_path = tmp_path()
+    previous_env = Mix.env()
+    deps_path = System.get_env("MIX_DEPS_PATH")
+    code_path = :code.get_path()
+
+    try do
+      File.mkdir_p!(tmp_path)
+      System.delete_env("MIX_DEPS_PATH")
+      Mix.env(:prod)
+
+      File.write!(Path.join(tmp_path, "mix.exs"), """
+      defmodule Mix.Local.Installer.MixProject do
+        use Mix.Project
+
+        def project do
+          [
+            app: :mix_local_installer,
+            version: "1.0.0",
+            deps: [#{inspect(dep_spec)}]
+          ]
+        end
+      end
+      """)
+
+      Mix.ProjectStack.on_clean_slate(fn ->
+        tmp_path =
+          Mix.Project.in_project(:mix_local_installer, tmp_path, [], fn mix_exs ->
+            in_fetcher.(mix_exs)
+
+            # The tmp_dir may have symlinks in it, so we properly resolve
+            # the directory before customizing deps_path and lockfile.
+            File.cwd!()
+          end)
+
+        {package_name, package_path} = package_name_path(dep_spec, tmp_path)
+
+        post_config = [
+          deps_path: Path.join(tmp_path, "deps"),
+          lockfile: Path.join(tmp_path, "mix.lock")
+        ]
+
+        Mix.Project.in_project(package_name, package_path, post_config, fn mix_exs ->
+          in_fetcher.(mix_exs)
+          in_package.(mix_exs)
+        end)
+      end)
+    after
+      File.rm_rf(tmp_path)
+      Mix.env(previous_env)
+      deps_path && System.put_env("MIX_DEPS_PATH", deps_path)
+      :code.set_path(code_path)
+      :code.purge(Mix.Local.Installer.Fetcher)
+      :code.delete(Mix.Local.Installer.Fetcher)
+    end
+  end
+
+  defp package_name_path(dep_spec, tmp_path) do
+    package_name = elem(dep_spec, 0)
+    package_name_string = Atom.to_string(package_name)
+    package_path = Path.join([tmp_path, "deps", package_name_string, maybe_sparse_dir(dep_spec)])
+
+    {package_name, package_path}
+  end
+
+  defp maybe_sparse_dir({_app, opts}) when is_list(opts) do
+    if opts[:git] do
+      opts[:sparse] || ""
+    else
+      ""
+    end
+  end
+
+  defp maybe_sparse_dir(_dep_spec), do: ""
+
+  defp in_fetcher(_mix_exs) do
+    Mix.Task.run("deps.get", ["--only", Atom.to_string(Mix.env())])
+  end
+
+  defp tmp_path do
+    unique = :crypto.strong_rand_bytes(4) |> Base.url_encode64(padding: false)
+    Path.join(System.tmp_dir!(), "mix-local-installer-fetcher-" <> unique)
+  end
+end
diff --git a/lib/mix/lib/mix/project.ex b/lib/mix/lib/mix/project.ex
index 3ff1cf7bac1..93ff56bed96 100644
--- a/lib/mix/lib/mix/project.ex
+++ b/lib/mix/lib/mix/project.ex
@@ -1,31 +1,240 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Project do
   @moduledoc """
-  Defines and manipulate Mix projects.
+  Defines and manipulates Mix projects.
 
-  In order to configure Mix, a developer needs to use
-  `Mix.Project` in a module and define a function named
-  `project` that returns a keyword list with configuration.
+  A Mix project is defined by calling `use Mix.Project` in a module, usually
+  placed in `mix.exs`:
 
-      defmodule MyApp do
+      defmodule MyApp.MixProject do
         use Mix.Project
 
         def project do
-          [app: :my_app,
-           vsn: "0.6.0"]
+          [
+            app: :my_app,
+            version: "1.0.0"
+          ]
         end
       end
 
-  After being defined, the configuration for this project can be read
-  as `Mix.Project.config/0`. Notice that `config/0` won't fail if a
-  project is not defined; this allows many mix tasks to work
-  even without a project.
+  > #### `use Mix.Project` {: .info}
+  >
+  > When you `use Mix.Project`, it notifies Mix that a new project
+  > has been defined, so all Mix tasks use your module as a starting
+  > point.
+
+  ## Configuration
+
+  In order to configure Mix, the module that calls `use Mix.Project` should export
+  a `project/0` function that returns a keyword list representing configuration
+  for the project.
 
-  In case the developer needs a project or wants to access a special
-  function in the project, he/she can call `Mix.Project.get!/0`
-  which fails with `Mix.NoProjectError` in case a project is not
+  This configuration can be read using `Mix.Project.config/0`. Note that
+  `config/0` won't fail if a project is not defined; this allows many Mix tasks
+  to work without a project.
+
+  If a task requires a project to be defined or needs to access a
+  special function within the project, the task can call `Mix.Project.get!/0`
+  which fails with `Mix.NoProjectError` in the case a project is not
   defined.
+
+  There isn't a comprehensive list of all the options that can be returned by
+  `project/0` since many Mix tasks define their own options that they read from
+  this configuration. For example, look at the "Configuration" section in the
+  documentation for the `Mix.Tasks.Compile` task.
+
+  These are a few options that are not used by just one Mix task (and will thus
+  be documented here):
+
+    * `:build_per_environment` - if `true`, builds will be *per-environment*. If
+      `false`, builds will go in `_build/shared` regardless of the Mix
+      environment. Defaults to `true`.
+
+    * `:aliases` - a list of task aliases. For more information, check out the
+      "Aliases" section in the documentation for the `Mix` module. Defaults to
+      `[]`.
+
+    * `:config_path` - a string representing the path of the main config
+      file. See `config_files/0` for more information. Defaults to
+      `"config/config.exs"`.
+
+    * `:deps` - a list of dependencies of this project. Refer to the
+      documentation for the `Mix.Tasks.Deps` task for more information. Defaults
+      to `[]`.
+
+    * `:deps_path` - directory where dependencies are stored. Also see
+      `deps_path/1`. Defaults to `"deps"`.
+
+    * `:lockfile` - the name of the lockfile used by the `mix deps.*` family of
+      tasks. Defaults to `"mix.lock"`.
+
+  Mix tasks may require their own configuration inside `def project`. For example,
+  check the `Mix.Tasks.Compile` task and all the specific compiler tasks
+  (such as `Mix.Tasks.Compile.Elixir` or `Mix.Tasks.Compile.Erlang`).
+
+  Note that different tasks may share the same configuration option. For example,
+  the `:erlc_paths` configuration is used by `mix compile.erlang`, `mix compile.yecc`,
+  and other tasks.
+
+  > #### Keep `project/0` fast {: .warning}
+  >
+  > `project/0` is called whenever your `mix.exs` is loaded, so heavy
+  > computation should be avoided. If a task requires a potentially complex
+  > configuration value, it should allow its configuration to be set to an
+  > anonymous function or similar, so that it can be invoked only when
+  > needed by the task itself.
+
+  ## CLI configuration
+
+  Mix is most often invoked from the command line. For this purpose, you may define
+  a specific `cli/0` function which customizes default values when executed from
+  the CLI. For example:
+
+      def cli do
+        [
+          default_task: "phx.server",
+          preferred_envs: [docs: :docs]
+        ]
+      end
+
+  The example above sets the default task (used by `iex -S mix` and `mix`) to
+  `phx.server`. It also sets the default environment for the "mix docs" task to
+  be "docs".
+
+  The following CLI configuration are available:
+
+    * `:default_env` - the default environment to use when none is given
+      and `MIX_ENV` is not set
+
+    * `:default_target` - the default target to use when none is given
+      and `MIX_TARGET` is not set
+
+    * `:default_task` - the default task to invoke when none is given
+
+    * `:preferred_envs` - a keyword list of `{task, env}` tuples where `task`
+      is the task name as an atom (for example, `:"deps.get"`) and `env` is the
+      preferred environment (for example, `:test`)
+
+    * `:preferred_targets` - a keyword list of `{task, target}` tuples where
+      `task` is the task name as an atom (for example, `:test`) and `target`
+      is the preferred target (for example, `:host`)
+
+  ## Erlang projects
+
+  Mix can be used to manage Erlang projects that don't have any Elixir code. To
+  ensure Mix tasks work correctly for an Erlang project, `language: :erlang` has
+  to be part of the configuration returned by `project/0`. This setting also
+  makes sure Elixir is not added as a dependency to the generated `.app` file or
+  to the escript generated with `mix escript.build`, and so on.
+
+  ## Umbrella projects
+
+  Umbrella projects are a convenience to help you organize and manage multiple
+  applications. While it provides a degree of separation between applications,
+  those applications are not fully decoupled, as they share the same configuration
+  and the same dependencies.
+
+  In an umbrella project, you have an `apps/` folder where you store each application.
+  Then, instead of each app in the umbrella having its own configuration, build cache,
+  lockfile and so, they all point to the parent project by specifying the following
+  configuration in their `mix.exs`:
+
+      build_path: "../../_build",
+      config_path: "../../config/config.exs",
+      deps_path: "../../deps",
+      lockfile: "../../mix.lock",
+
+  The pattern of keeping multiple applications in the same repository is known as
+  [monorepo](https://en.wikipedia.org/wiki/Monorepo). Umbrella projects maximize
+  this pattern by providing conveniences to compile, test and run multiple
+  applications at once. When an umbrella application needs to depend on another
+  one, it can be done by passing the `in_umbrella: true` option to your dependency.
+  If an umbrella application `:foo` depends on its sibling `:bar`, you can specify
+  this dependency in `foo`'s `mix.exs` file as:
+
+      {:bar, in_umbrella: true}
+
+  ### Undoing umbrellas
+
+  Using umbrella projects can impact how you design and write your software and,
+  as time passes, they may turn out to be the wrong choice.
+  If you find yourself in a position where you want to use different configurations
+  in each application for the same dependency or use different dependency versions,
+  then it is likely your codebase has grown beyond what umbrellas can provide.
+
+  If you find yourself in this situation, you have two options:
+
+    1. Convert everything into a single Mix project, which can be done in steps.
+       First move all files in `lib`, `test`, `priv`, and friends into a single
+       application, while still keeping the overall umbrella structure and
+       `mix.exs` files. For example, if your umbrellas has three applications,
+       `foo`, `bar` and `baz`, where `baz` depends on both `foo` and `bar`,
+       move all source to `baz`. Then remove `foo` and `bar` one by one,
+       updating any configuration and removing references to the `:foo` and
+      `:bar` application names. Until you have only a single application.
+
+    2. Remove umbrella structure while keeping them as distinct applications.
+       This is done by moving applications outside of the umbrella
+       project's `apps/` directory and updating the projects' `mix.exs` files
+       to no longer set the `build_path`, `config_path`, `deps_path`, and
+       `lockfile` configurations, guaranteeing each of them have their own
+       build and dependency structure.
+
+  Keep in mind that umbrellas are one of many options for managing private
+  packages within your organization. You might:
+
+    1. Have multiple directories inside the same repository and using `:path`
+       dependencies (which is essentially the monorepo pattern)
+    2. Use private Git repositories and Mix' ability to fetch Git dependencies
+    3. Publishing packages to a private [Hex.pm](https://hex.pm/) organization
+
+  ## Invoking this module
+
+  This module contains many functions that return project information and
+  metadata. However, since Mix is not included nor configured during releases,
+  we recommend using the functions in this module only inside Mix tasks.
+  If you need to configure your own app, consider using the application
+  environment instead. For example, don't do this:
+
+      def some_config do
+        Mix.Project.config()[:some_config]
+      end
+
+  Nor this:
+
+      @some_config Mix.Project.config()[:some_config]
+
+  Instead, do this:
+
+      def some_config do
+        Application.get_env(:my_app, :some_config)
+      end
+
+  Or this:
+
+      @some_config Application.compile_env(:my_app, :some_config)
+
   """
 
+  @type build_structure_opts :: [
+          symlink_ebin: boolean(),
+          source: String.t()
+        ]
+
+  @typedoc """
+  Options for dependency traversal functions.
+
+  These options control how dependency trees are traversed and filtered
+  in functions like `deps_scms/1`, `deps_paths/1`, and `deps_tree/1`.
+  """
+  @type deps_traversal_opts :: [
+          depth: pos_integer(),
+          parents: [atom()]
+        ]
+
   @doc false
   defmacro __using__(_) do
     quote do
@@ -33,60 +242,95 @@ defmodule Mix.Project do
     end
   end
 
-  @private_config [:build_path, :app_path]
-
   # Invoked after each Mix.Project is compiled.
   @doc false
   def __after_compile__(env, _binary) do
-    push env.module, env.file
+    push(env.module, env.file)
   end
 
   # Push a project onto the project stack.
   # Only the top of the stack can be accessed.
   @doc false
-  def push(atom, file \\ nil) when is_atom(atom) do
-    file = file ||
-           (atom && List.to_string(atom.__info__(:compile)[:source]))
-
-    config = default_config
-             |> Keyword.merge(get_project_config(atom))
-             |> Keyword.drop(@private_config)
+  def push(module, file \\ nil, app \\ nil) when is_atom(module) do
+    file =
+      cond do
+        file != nil -> file
+        source = module && module.module_info(:compile)[:source] -> List.to_string(source)
+        true -> "nofile"
+      end
 
-    case Mix.ProjectStack.push(atom, config, file) do
+    case Mix.ProjectStack.push(module, push_config(module, app), file) do
       :ok ->
         :ok
+
       {:error, other} when is_binary(other) ->
-        Mix.raise "Trying to load #{inspect atom} from #{inspect file}" <>
-          " but another project with the same name was already defined at #{inspect other}"
+        Mix.raise(
+          "Trying to load #{inspect(module)} from #{inspect(file)}" <>
+            " but another project with the same name was already defined at #{inspect(other)}"
+        )
+    end
+  end
+
+  @preferred_envs [test: :test, "test.coverage": :test]
+
+  defp push_config(module, app) do
+    with {state_loader, task} <- Mix.ProjectStack.pop_post_config(:state_loader) do
+      config =
+        if function_exported?(module, state_loader, 0),
+          do: apply(module, state_loader, []),
+          else: []
+
+      task = String.to_atom(task || config[:default_task] || "run")
+
+      if !System.get_env("MIX_ENV") do
+        if env = config[:preferred_envs][task] || @preferred_envs[task] || config[:default_env] do
+          Mix.env(env)
+        end
+      end
+
+      if !System.get_env("MIX_TARGET") do
+        if target = config[:preferred_targets][task] || config[:default_target] do
+          Mix.target(target)
+        end
+      end
     end
+
+    ([app: app] ++ default_config())
+    |> Keyword.merge(get_project_config(module))
   end
 
   # Pops a project from the stack.
   @doc false
   def pop do
-    Mix.ProjectStack.pop
+    Mix.ProjectStack.pop()
   end
 
   # The configuration that is pushed down to dependencies.
   @doc false
   def deps_config(config \\ config()) do
-    [build_path: build_path(config),
-     build_per_environment: config[:build_per_environment],
-     deps_path: deps_path(config)]
+    [
+      consolidate_protocols: false,
+      consolidation_path: consolidation_path(config),
+      deps_path: deps_path(config),
+      deps_build_path: build_path(config),
+      lockfile: Path.expand(config[:lockfile])
+    ] ++ Keyword.take(config, [:build_embedded, :build_per_environment, :prune_code_paths])
   end
 
   @doc """
   Retrieves the current project if there is one.
 
-  Otherwise `nil` is returned. It may happen in cases
-  there is no mixfile in the current directory.
+  If there is no current project, `nil` is returned. This
+  may happen in cases there is no `mix.exs` in the current
+  directory.
 
-  If you expect a project to be defined, i.e. it is a
+  If you expect a project to be defined, i.e., it is a
   requirement of the current task, you should call
   `get!/0` instead.
   """
+  @spec get() :: module | nil
   def get do
-    case Mix.ProjectStack.peek do
+    case Mix.ProjectStack.peek() do
       %{name: name} -> name
       _ -> nil
     end
@@ -98,32 +342,54 @@ defmodule Mix.Project do
   This is usually called by tasks that need additional
   functions on the project to be defined. Since such
   tasks usually depend on a project being defined, this
-  function raises `Mix.NoProjectError` in case no project
-  is available.
+  function raises a `Mix.NoProjectError` exception in
+  case no project is available.
   """
+  @spec get!() :: module
   def get! do
-    get || Mix.raise Mix.NoProjectError, []
+    get() || raise Mix.NoProjectError, []
   end
 
+  @doc """
+  Returns the path to the file that defines the current project.
+
+  The majority of the time, it will point to a `mix.exs` file.
+  Returns `nil` if not inside a project.
+  """
+  @doc since: "1.13.0"
+  @spec project_file() :: binary | nil
+  defdelegate project_file(), to: Mix.ProjectStack
+
+  @doc """
+  Returns the path to the file that defines the parent umbrella project, if one.
+
+  The majority of the time, it will point to a `mix.exs` file.
+  Returns `nil` if not inside a project or not inside an umbrella.
+  """
+  @doc since: "1.15.0"
+  @spec parent_umbrella_project_file() :: binary | nil
+  defdelegate parent_umbrella_project_file(), to: Mix.ProjectStack
+
   @doc """
   Returns the project configuration.
 
   If there is no project defined, it still returns a keyword
-  list with default values. This allows many mix tasks to work
+  list with default values. This allows many Mix tasks to work
   without the need for an underlying project.
 
   Note this configuration is cached once the project is
-  pushed into the stack. Calling it multiple times won't
+  pushed onto the stack. Calling it multiple times won't
   cause it to be recomputed.
 
-  Do not use `Mix.Project.config` to rely on runtime configuration.
+  Do not use `Mix.Project.config/0` to find the runtime configuration.
   Use it only to configure aspects of your project (like
   compilation directories) and not your application runtime.
   """
+  @spec config() :: keyword
   def config do
-    case Mix.ProjectStack.peek do
+    case Mix.ProjectStack.peek() do
       %{config: config} -> config
-      _ -> default_config
+      _ -> default_config()
     end
   end
 
@@ -133,33 +399,127 @@ defmodule Mix.Project do
   This function is usually used in compilation tasks to trigger
   a full recompilation whenever such configuration files change.
 
-  By default it includes the mix.exs file, the lock manifest and
-  all config files in the `config` directory.
+  It returns the lock manifest, and all config files in the `config`
+  directory that do not start with a leading period (for example,
+  `.my_config.exs`).
+
+  Note: before Elixir v1.13.0, the `mix.exs` file was also included
+  as a config file, but since then it has been moved to its own
+  function called `project_file/0`.
   """
+  @spec config_files() :: [Path.t()]
   def config_files do
-    [Mix.Dep.Lock.manifest] ++
-      case Mix.ProjectStack.peek do
-        %{config: config, file: file} ->
-          configs =
-            (config[:config_path] || "config/config.exs")
-            |> Path.dirname
-            |> Path.join("*.*")
-            |> Path.wildcard
-            |> Enum.reject(&String.starts_with?(Path.basename(&1), "."))
-          [file|configs]
-        _ ->
-          []
-      end
+    Mix.ProjectStack.config_files()
+  end
+
+  @doc """
+  Returns the latest modification time from config files.
+
+  This function is usually used in compilation tasks to trigger
+  a full recompilation whenever such configuration files change.
+  For this reason, the mtime is cached to avoid file system lookups.
+
+  However, for effective used of this function, you must avoid
+  comparing source files with the `config_mtime` itself. Instead,
+  store the previous `config_mtime` and compare it with the new
+  `config_mtime` in order to detect if something is stale.
+
+  Note: before Elixir v1.13.0, the `mix.exs` file was also included
+  in the mtimes, but not anymore. You can compute its modification
+  date by calling `project_file/0`.
+  """
+  @doc since: "1.7.0"
+  @spec config_mtime() :: posix_mtime when posix_mtime: integer()
+  def config_mtime do
+    Mix.ProjectStack.config_mtime()
   end
 
   @doc """
-  Returns `true` if project is an umbrella project.
+  Returns `true` if `config` is the configuration for an umbrella project.
+
+  When called with no arguments, tells whether the current project is
+  an umbrella project.
   """
-  def umbrella? do
+  @spec umbrella?(keyword) :: boolean
+  def umbrella?(config \\ config()) do
     config[:apps_path] != nil
   end
 
   @doc """
+  Returns a map with the umbrella child applications paths.
+
+  These paths are based on the `:apps_path` and `:apps` configurations.
+
+  If the given project configuration identifies an umbrella project, the return
+  value is a map of `app => path` where `app` is a child app of the umbrella and
+  `path` is its path relative to the root of the umbrella project.
+
+  If the given project configuration does not identify an umbrella project,
+  `nil` is returned.
+
+  ## Examples
+
+      Mix.Project.apps_paths()
+      #=> %{my_app1: "apps/my_app1", my_app2: "apps/my_app2"}
+
+  """
+  @doc since: "1.4.0"
+  @spec apps_paths(keyword) :: %{optional(atom) => Path.t()} | nil
+  def apps_paths(config \\ config()) do
+    if apps_path = config[:apps_path] do
+      key = {:apps_paths, Mix.Project.get!()}
+
+      if cache = Mix.State.read_cache(key) do
+        cache
+      else
+        cache = config[:apps] |> umbrella_apps(apps_path) |> to_apps_paths(apps_path)
+        Mix.State.write_cache(key, cache)
+      end
+    end
+  end
+
+  defp umbrella_apps(nil, apps_path) do
+    case File.ls(apps_path) do
+      {:ok, apps} -> Enum.map(apps, &String.to_atom/1)
+      {:error, _} -> []
+    end
+  end
+
+  defp umbrella_apps(apps, _apps_path) when is_list(apps) do
+    apps
+  end
+
+  defp to_apps_paths(apps, apps_path) do
+    for app <- apps,
+        path = path_with_mix_exs_otherwise_warn(app, apps_path),
+        do: {app, path},
+        into: %{}
+  end
+
+  defp path_with_mix_exs_otherwise_warn(app, apps_path) do
+    path = Path.join(apps_path, Atom.to_string(app))
+
+    cond do
+      File.regular?(Path.join(path, "mix.exs")) ->
+        path
+
+      File.dir?(path) ->
+        Mix.shell().error(
+          "warning: path #{inspect(Path.relative_to_cwd(path))} is a directory but " <>
+            "it has no mix.exs. Mix won't consider this directory as part of your " <>
+            "umbrella application. Please add a \"mix.exs\" or set the \":apps\" key " <>
+            "in your umbrella configuration with all relevant apps names as atoms"
+        )
+
+        nil
+
+      true ->
+        # If it is a stray file, we just ignore it.
+        nil
+    end
+  end
+
+  @doc ~S"""
   Runs the given `fun` inside the given project.
 
   This function changes the current working directory and
@@ -168,84 +528,312 @@ defmodule Mix.Project do
 
   A `post_config` can be passed that will be merged into
   the project configuration.
+
+  `fun` is called with the module name of the given `Mix.Project`.
+  The return value of this function is the return value of `fun`.
+
+  ## Examples
+
+      Mix.Project.in_project(:my_app, "/path/to/my_app", fn module ->
+        "Mix project is: #{inspect(module)}"
+      end)
+      #=> "Mix project is: MyApp.MixProject"
+
   """
+  @spec in_project(atom, Path.t(), keyword, (module -> result)) :: result when result: term
   def in_project(app, path, post_config \\ [], fun)
 
-  def in_project(app, ".", post_config, fun) do
-    cached = load_project(app, post_config)
-    result = try do
+  def in_project(app, ".", post_config, fun) when is_atom(app) do
+    cached =
+      try do
+        load_project(app, post_config)
+      rescue
+        any ->
+          Mix.shell().error("Error while loading project #{inspect(app)} at #{File.cwd!()}")
+          reraise any, __STACKTRACE__
+      end
+
+    try do
       fun.(cached)
     after
-      Mix.Project.pop
+      Mix.Project.pop()
     end
-    result
   end
 
-  def in_project(app, path, post_config, fun) do
-    File.cd! path, fn ->
+  def in_project(app, path, post_config, fun) when is_atom(app) do
+    File.cd!(path, fn ->
       in_project(app, ".", post_config, fun)
-    end
+    end)
   end
 
   @doc """
-  Returns the path to store dependencies for this project.
+  Returns the path where dependencies are stored for the given project.
+
+  If no configuration is given, the one for the current project is used.
 
   The returned path will be expanded.
 
   ## Examples
 
-      Mix.Project.deps_path
+      Mix.Project.deps_path()
       #=> "/path/to/project/deps"
 
   """
+  @spec deps_path(keyword) :: Path.t()
   def deps_path(config \\ config()) do
-    Path.expand config[:deps_path]
+    dir = System.get_env("MIX_DEPS_PATH") || config[:deps_path]
+    Path.expand(dir)
   end
 
   @doc """
-  Returns the build path for this project.
+  Returns all dependencies app names.
 
-  The returned path will be expanded.
+  The order they are returned is guaranteed to be sorted
+  for proper dependency resolution. For example, if A
+  depends on B, then B will listed before A.
+  """
+  @doc since: "1.11.0"
+  @spec deps_apps() :: [atom()]
+  def deps_apps() do
+    Mix.Dep.cached() |> Enum.map(& &1.app)
+  end
+
+  @doc """
+  Returns the SCMs of all dependencies as a map.
+
+  See `Mix.SCM` module documentation to learn more about SCMs.
+
+  ## Options
+
+    * `:depth` - only returns dependencies to the depth level,
+      a depth of `1` will only return top-level dependencies
+    * `:parents` - starts the dependency traversal from the
+      given parents instead of the application root
+
+  ## Examples
+
+      Mix.Project.deps_scms()
+      #=> %{foo: Mix.SCM.Path, bar: Mix.SCM.Git}
+
+  """
+  @doc since: "1.10.0"
+  @spec deps_scms(deps_traversal_opts) :: %{optional(atom) => Mix.SCM.t()}
+  def deps_scms(opts \\ []) when is_list(opts) do
+    traverse_deps(opts, fn %{scm: scm} -> scm end)
+  end
+
+  @doc """
+  Returns the full path of all dependencies as a map.
+
+  ## Options
+
+    * `:depth` - only returns dependencies to the depth level,
+      a depth of `1` will only return top-level dependencies
+    * `:parents` - starts the dependency traversal from the
+      given parents instead of the application root
+
+  ## Examples
+
+      Mix.Project.deps_paths()
+      #=> %{foo: "deps/foo", bar: "custom/path/dep"}
+
+  """
+  @spec deps_paths(deps_traversal_opts) :: %{optional(atom) => Path.t()}
+  def deps_paths(opts \\ []) when is_list(opts) do
+    traverse_deps(opts, fn %{opts: opts} -> opts[:dest] end)
+  end
+
+  @doc """
+  Returns the dependencies of all dependencies as a map.
+
+  ## Options
+
+    * `:depth` - only returns dependencies to the depth level,
+      a depth of `1` will only return top-level dependencies
+    * `:parents` - starts the dependency traversal from the
+      given parents instead of the application root
+
+  ## Examples
+
+      Mix.Project.deps_tree()
+      #=> %{foo: [:bar, :baz], bar: [], baz: []}
+
+  """
+  @doc since: "1.15.0"
+  @spec deps_tree(deps_traversal_opts) :: %{optional(atom) => [atom]}
+  def deps_tree(opts \\ []) when is_list(opts) do
+    traverse_deps(opts, fn %{deps: deps} -> Enum.map(deps, & &1.app) end)
+  end
+
+  defp traverse_deps(opts, fun) do
+    all_deps = Mix.Dep.cached()
+    parents = opts[:parents]
+    depth = opts[:depth]
+
+    if parents || depth do
+      parent_filter = if parents, do: &(&1.app in parents), else: & &1.top_level
+
+      all_deps
+      |> Enum.filter(parent_filter)
+      |> traverse_deps_map(fun)
+      |> traverse_deps_depth(all_deps, fun, 1, depth || :infinity)
+    else
+      traverse_deps_map(all_deps, fun)
+    end
+  end
+
+  defp traverse_deps_map(deps, fun) do
+    for %{app: app} = dep <- deps, do: {app, fun.(dep)}, into: %{}
+  end
+
+  defp traverse_deps_depth(deps, _all_deps, _fun, depth, depth) do
+    deps
+  end
+
+  defp traverse_deps_depth(parents, all_deps, fun, depth, target_depth) do
+    children =
+      for parent_dep <- all_deps,
+          Map.has_key?(parents, parent_dep.app),
+          %{app: app} = dep <- parent_dep.deps,
+          do: {app, fun.(dep)},
+          into: %{}
+
+    case Map.merge(parents, children) do
+      ^parents -> parents
+      new_parents -> traverse_deps_depth(new_parents, all_deps, fun, depth + 1, target_depth)
+    end
+  end
+
+  @doc """
+  Clears the dependency for the current environment.
+
+  Useful when dependencies need to be reloaded due to change of global state.
+
+  For example, Nerves uses this function to force all dependencies to be
+  reloaded after it updates the system environment. It goes roughly like
+  this:
+
+    1. Nerves fetches all dependencies and looks for the system specific deps
+    2. Once the system specific dep is found, it loads it alongside env vars
+    3. Nerves then clears the cache, forcing dependencies to be loaded again
+    4. Dependencies are loaded again, now with an updated env environment
+
+  """
+  @doc since: "1.7.0"
+  @spec clear_deps_cache() :: :ok
+  def clear_deps_cache() do
+    Mix.Dep.clear_cached()
+    :ok
+  end
+
+  @doc """
+  Returns the build path for the given project.
+
+  The build path is built based on the `:build_path` configuration
+  (which defaults to `"_build"`) and a subdirectory. The subdirectory
+  is built based on two factors:
+
+    * If `:build_per_environment` is set (the default), the subdirectory
+      is the value of `Mix.env/0` (which can be set via `MIX_ENV`).
+      Otherwise it is set to "shared".
+
+    * If `Mix.target/0` is set (often via the `MIX_TARGET` environment
+      variable), it will be used as a prefix to the subdirectory.
+
+  The behaviour of this function can be modified by two environment
+  variables, `MIX_BUILD_ROOT` and `MIX_BUILD_PATH`, see [the Mix
+  documentation for more information](Mix.html#environment-variables).
+
+  > #### Naming differences {: .info}
+  >
+  > Ideally the configuration option `:build_path` would be called
+  > `:build_root`, as it only sets the root component of the build
+  > path but not the subdirectory. However, its name is preserved
+  > for backwards compatibility.
 
   ## Examples
 
-      Mix.Project.build_path
+      Mix.Project.build_path()
       #=> "/path/to/project/_build/shared"
 
-  If :build_per_environment is set to true (the default), it
-  will create a new build per environment:
+  If `:build_per_environment` is set to `true`, it will create a new build per
+  environment:
 
-      Mix.env
+      Mix.env()
       #=> :dev
-      Mix.Project.build_path
+      Mix.Project.build_path()
       #=> "/path/to/project/_build/dev"
 
   """
+  @spec build_path(keyword) :: Path.t()
   def build_path(config \\ config()) do
-    config[:build_path] || if config[:build_per_environment] do
-      Path.expand("_build/#{Mix.env}")
-    else
-      Path.expand("_build/shared")
+    cond do
+      deps_build_path = config[:deps_build_path] ->
+        deps_build_path
+
+      build_path = System.get_env("MIX_BUILD_PATH") ->
+        Path.expand(build_path)
+
+      true ->
+        do_build_path(config)
+    end
+  end
+
+  defp do_build_path(config) do
+    dir = System.get_env("MIX_BUILD_ROOT") || config[:build_path] || "_build"
+    subdir = build_target() <> build_per_environment(config)
+    Path.expand(dir <> "/" <> subdir)
+  end
+
+  defp build_target do
+    case Mix.target() do
+      :host -> ""
+      other -> "#{other}_"
+    end
+  end
+
+  defp build_per_environment(config) do
+    case config[:build_per_environment] do
+      true ->
+        Atom.to_string(Mix.env())
+
+      false ->
+        "shared"
+
+      other ->
+        Mix.raise("The :build_per_environment option should be a boolean, got: #{inspect(other)}")
     end
   end
 
   @doc """
-  The path to store manifests.
+  Returns the path where manifests are stored.
 
-  By default they are stored in the app path
-  inside the build directory but it may be changed
-  in future releases.
+  By default they are stored in the app path inside
+  the build directory. Umbrella applications have
+  the manifest path set to the root of the build directory.
+  Directories may be changed in future releases.
 
   The returned path will be expanded.
 
   ## Examples
 
-      Mix.Project.manifest_path
-      #=> "/path/to/project/_build/shared/lib/app"
+  If your project defines the app `my_app`:
+
+      Mix.Project.manifest_path()
+      #=> "/path/to/project/_build/shared/lib/my_app/.mix"
 
   """
+  @spec manifest_path(keyword) :: Path.t()
   def manifest_path(config \\ config()) do
-    app_path(config)
+    app_path =
+      config[:deps_app_path] ||
+        if app = config[:app] do
+          Path.join([build_path(config), "lib", Atom.to_string(app)])
+        else
+          build_path(config)
+        end
+
+    Path.join(app_path, ".mix")
   end
 
   @doc """
@@ -255,122 +843,252 @@ defmodule Mix.Project do
 
   ## Examples
 
-      Mix.Project.app_path
-      #=> "/path/to/project/_build/shared/lib/app"
+  If your project defines the app `my_app`:
+
+      Mix.Project.app_path()
+      #=> "/path/to/project/_build/shared/lib/my_app"
 
   """
+  @spec app_path(keyword) :: Path.t()
   def app_path(config \\ config()) do
-    config[:app_path] || cond do
-      app = config[:app] ->
-        Path.join([build_path(config), "lib", Atom.to_string(app)])
-      config[:apps_path] ->
-        raise "Trying to access app_path for an umbrella project but umbrellas have no app"
-      true ->
-        Mix.raise "Cannot access build without an application name, " <>
-          "please ensure you are in a directory with a mix.exs file and it defines " <>
-          "an :app name under the project configuration"
-    end
+    config[:deps_app_path] ||
+      cond do
+        app = config[:app] ->
+          Path.join([build_path(config), "lib", Atom.to_string(app)])
+
+        config[:apps_path] ->
+          raise "trying to access Mix.Project.app_path/1 for an umbrella project but umbrellas have no app"
+
+        true ->
+          Mix.raise(
+            "Cannot access build without an application name, " <>
+              "please ensure you are in a directory with a mix.exs file and it defines " <>
+              "an :app name under the project configuration"
+          )
+      end
   end
 
   @doc """
-  Returns the paths this project compiles to.
+  Returns the paths the given project compiles to.
+
+  If no configuration is given, the one for the current project will be used.
 
   The returned path will be expanded.
 
   ## Examples
 
-      Mix.Project.compile_path
-      #=> "/path/to/project/_build/shared/lib/app/priv"
+  If your project defines the app `my_app`:
+
+      Mix.Project.compile_path()
+      #=> "/path/to/project/_build/dev/lib/my_app/ebin"
 
   """
+  @spec compile_path(keyword) :: Path.t()
   def compile_path(config \\ config()) do
     Path.join(app_path(config), "ebin")
   end
 
   @doc """
-  Builds the project structure for the current application.
+  Returns the path where protocol consolidations are stored.
+
+  The returned path will be expanded.
+
+  ## Examples
+
+  If your project defines the app `my_app`:
+
+      Mix.Project.consolidation_path()
+      #=> "/path/to/project/_build/dev/lib/my_app/consolidated"
+
+  Inside umbrellas:
+
+      Mix.Project.consolidation_path()
+      #=> "/path/to/project/_build/dev/consolidated"
+
+  """
+  @spec consolidation_path(keyword) :: Path.t()
+  def consolidation_path(config \\ config()) do
+    config[:consolidation_path] ||
+      if umbrella?(config) do
+        Path.join(build_path(config), "consolidated")
+      else
+        Path.join(app_path(config), "consolidated")
+      end
+  end
+
+  @doc false
+  @deprecated "Use Mix.Task.run(\"compile\", args) instead"
+  def compile(args, _config \\ []) do
+    Mix.Task.run("compile", args)
+  end
+
+  @doc """
+  Builds the project structure for the given application.
 
   ## Options
 
     * `:symlink_ebin` - symlink ebin instead of copying it
 
+    * `:source` - the source directory to copy from.
+      Defaults to the current working directory.
+
   """
+  @spec build_structure(keyword, build_structure_opts) :: :ok
   def build_structure(config \\ config(), opts \\ []) do
-    app = app_path(config)
-    File.mkdir_p!(app)
-
-    source = Path.expand("ebin")
-    target = Path.join(app, "ebin")
+    source = opts[:source] || File.cwd!()
+    target = app_path(config)
+    File.mkdir_p!(target)
+    target_ebin = Path.join(target, "ebin")
+
+    _ =
+      cond do
+        opts[:symlink_ebin] ->
+          _ = Mix.Utils.symlink_or_copy(Path.join(source, "ebin"), target_ebin)
+
+        match?({:ok, _}, :file.read_link(target_ebin)) ->
+          _ = File.rm_rf!(target_ebin)
+          File.mkdir_p!(target_ebin)
+
+        true ->
+          File.mkdir_p!(target_ebin)
+      end
 
-    cond do
-      opts[:symlink_ebin] ->
-        Mix.Utils.symlink_or_copy(source, target)
-      match?({:ok, _}, :file.read_link(target)) ->
-        File.rm_rf!(target)
-        File.mkdir_p!(target)
-      true ->
-        File.mkdir_p!(target)
+    for dir <- ~w(include priv) do
+      Mix.Utils.symlink_or_copy(Path.join(source, dir), Path.join(target, dir))
     end
 
-    Mix.Utils.symlink_or_copy(Path.expand("include"), Path.join(app, "include"))
-    Mix.Utils.symlink_or_copy(Path.expand("priv"), Path.join(app, "priv"))
     :ok
   end
 
   @doc """
-  Returns all load paths for this project.
+  Ensures the project structure for the given project exists.
+
+  In case it does exist, it is a no-op. Otherwise, it is built.
+
+  `opts` are the same options that can be passed to `build_structure/2`.
   """
-  def load_paths do
-    if umbrella? do
+  @spec ensure_structure(keyword, build_structure_opts) :: :ok
+  def ensure_structure(config \\ config(), opts \\ []) do
+    if File.exists?(app_path(config)) do
+      :ok
+    else
+      build_structure(config, opts)
+    end
+  end
+
+  @deprecated "Use Mix.Project.compile_path/1 instead"
+  def load_paths(config \\ config()) do
+    if umbrella?(config) do
       []
     else
-      [compile_path]
+      [compile_path(config)]
+    end
+  end
+
+  @doc """
+  Acquires a lock on the project build path and runs the given function.
+
+  When another process (across all OS processes) is holding the lock,
+  a message is printed and this call blocks until the lock is acquired.
+  This function can also be called if this process already has the
+  lock. In such case the function is executed immediately.
+
+  This lock is primarily useful for compiler tasks that alter the build
+  artifacts to avoid conflicts with a concurrent compilation.
+  """
+  @spec with_build_lock(keyword, (-> term())) :: term()
+  def with_build_lock(config \\ config(), fun) do
+    # To avoid duplicated compilation, we wrap compilation tasks, such
+    # as compile.all, deps.compile, compile.elixir, compile.erlang in
+    # a lock. Note that compile.all covers compile.elixir, but the
+    # latter can still be invoked directly, so we put the lock over
+    # each individual task.
+
+    build_path = build_path(config)
+
+    on_taken = fn os_pid ->
+      Mix.shell().error([
+        IO.ANSI.reset(),
+        "Waiting for lock on the build directory (held by process #{os_pid})"
+      ])
     end
+
+    Mix.Sync.Lock.with_lock(build_path, fun, on_taken: on_taken)
+  end
+
+  @doc false
+  def with_deps_lock(config \\ config(), fun) do
+    # We wrap operations on the deps directory and on mix.lock to
+    # avoid write conflicts.
+
+    deps_path = deps_path(config)
+
+    on_taken = fn os_pid ->
+      Mix.shell().error([
+        IO.ANSI.reset(),
+        "Waiting for lock on the deps directory (held by process #{os_pid})"
+      ])
+    end
+
+    Mix.Sync.Lock.with_lock(deps_path, fun, on_taken: on_taken)
   end
 
   # Loads mix.exs in the current directory or loads the project from the
-  # mixfile cache and pushes the project to the project stack.
+  # mixfile cache and pushes the project onto the project stack.
   defp load_project(app, post_config) do
     Mix.ProjectStack.post_config(post_config)
 
-    if cached = Mix.ProjectStack.read_cache(app) do
+    if cached = Mix.State.read_cache({:app, app}) do
       {project, file} = cached
-      push(project, file)
+      push(project, file, app)
       project
     else
       file = Path.expand("mix.exs")
-      old_proj = get
-
-      if File.regular?(file) do
-        Code.load_file(file)
-      end
-
-      new_proj = get
-
-      if old_proj == new_proj do
-        file = "nofile"
-        new_proj = nil
-        push new_proj, file
-      end
+      old_proj = get()
+
+      {new_proj, file} =
+        if File.regular?(file) do
+          old_undefined = Code.get_compiler_option(:no_warn_undefined)
+
+          try do
+            Code.compiler_options(relative_paths: false, no_warn_undefined: :all)
+            _ = Code.compile_file(file)
+            get()
+          else
+            ^old_proj -> Mix.raise("Could not find a Mix project at #{file}")
+            new_proj -> {new_proj, file}
+          after
+            Code.compiler_options(relative_paths: true, no_warn_undefined: old_undefined)
+          end
+        else
+          push(nil, file, app)
+          {nil, "nofile"}
+        end
 
-      Mix.ProjectStack.write_cache(app, {new_proj, file})
+      Mix.State.write_cache({:app, app}, {new_proj, file})
       new_proj
     end
   end
 
   defp default_config do
-    [build_per_environment: true,
-     default_task: "run",
-     deps: [],
-     deps_path: "deps",
-     elixirc_paths: ["lib"],
-     erlc_paths: ["src"],
-     erlc_include_path: "include",
-     erlc_options: [:debug_info],
-     lockfile: "mix.lock",
-     preferred_cli_env: %{"test" => :test}]
-  end
-
-  defp get_project_config(nil),  do: []
-  defp get_project_config(atom), do: atom.project
+    [
+      aliases: [],
+      build_per_environment: true,
+      build_scm: Mix.SCM.Path,
+      config_path: "config/config.exs",
+      consolidate_protocols: true,
+      deps: [],
+      deps_path: "deps",
+      elixirc_paths: ["lib"],
+      erlc_paths: ["src"],
+      erlc_include_path: "include",
+      erlc_options: [],
+      lockfile: "mix.lock",
+      start_permanent: false
+    ]
+  end
+
+  @private_config [:build_scm, :deps_app_path, :deps_build_path]
+  defp get_project_config(nil), do: []
+  defp get_project_config(atom), do: atom.project() |> Keyword.drop(@private_config)
 end
diff --git a/lib/mix/lib/mix/project_stack.ex b/lib/mix/lib/mix/project_stack.ex
index ba8344055e9..0df75726544 100644
--- a/lib/mix/lib/mix/project_stack.ex
+++ b/lib/mix/lib/mix/project_stack.ex
@@ -1,169 +1,339 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.ProjectStack do
-  # Keeps the project stack.
   @moduledoc false
 
-  @timeout 30_000
+  use GenServer
+  @name __MODULE__
+  @timeout :infinity
 
-  @typep file    :: binary
-  @typep config  :: Keyword.t
-  @typep project :: {module, config, file}
+  # compile.lock is not the best name, but the name is completely
+  # opaque and we keep it for backwards compatibility (just in case).
+  @manifest "compile.lock"
 
-  @spec start_link :: {:ok, pid}
-  def start_link() do
-    initial = %{stack: [], post_config: [], cache: HashDict.new}
-    Agent.start_link fn -> initial end, name: __MODULE__
-  end
+  @typep file :: binary
+  @typep config :: keyword
+  @typep project :: %{name: module, config: config, file: file}
 
-  @spec push(module, config, file) :: :ok | {:error, file}
-  def push(module, config, file) do
-    get_and_update fn %{stack: stack} = state ->
-      # Consider the first children to always have io_done
-      # because we don't need to print anything unless another
-      # project talks ahold of the shell.
-      io_done? = stack == []
-
-      config  = Keyword.merge(config, state.post_config)
-      project = %{name: module, config: config, file: file, pos: length(stack),
-                  recursing?: false, io_done: io_done?, tasks: HashSet.new}
-
-      cond do
-        file = find_project_named(module, stack) ->
-          {{:error, file}, state}
-        true ->
-          {:ok, %{state | post_config: [], stack: [project|state.stack]}}
-      end
-    end
+  @spec start_link(keyword) :: {:ok, pid}
+  def start_link(_opts) do
+    GenServer.start_link(__MODULE__, :ok, name: @name)
   end
 
-  @spec pop() :: project | nil
-  def pop do
-    get_and_update fn %{stack: stack} = state ->
-      case stack do
-        [h|t] -> {take(h), %{state | stack: t}}
-        [] -> {nil, state}
-      end
+  @spec on_clean_slate((-> result)) :: result when result: var
+  def on_clean_slate(callback) do
+    previous_state = update_state(fn state -> {state, initial_state()} end)
+
+    try do
+      callback.()
+    after
+      update_state(fn _ -> {:ok, previous_state} end)
     end
   end
 
-  @spec peek() :: project | nil
-  def peek do
-    get fn %{stack: stack} ->
-      case stack do
-        [h|_] -> take(h)
-        [] -> nil
-      end
-    end
+  @spec clear_stack() :: :ok
+  def clear_stack do
+    update_state(fn _ -> {:ok, initial_state()} end)
   end
 
   @spec post_config(config) :: :ok
   def post_config(config) do
-    cast fn state ->
-      %{state | post_config: Keyword.merge(state.post_config, config)}
-    end
+    update_state(fn {stack, post_config} ->
+      {:ok, {stack, Keyword.merge(post_config, config)}}
+    end)
   end
 
-  @spec print_app?() :: boolean
-  def print_app? do
-    get_and_update fn %{stack: stack} = state ->
-      case stack do
-        [] ->
-          {false, state}
-        [%{io_done: true}|_] ->
-          {false, state}
-        [h|t] ->
-          h = %{h | io_done: true}
-          t = Enum.map(t, &%{&1 | io_done: false})
-          {has_app?(h), %{state | stack: [h|t]}}
-      end
-    end
+  @spec pop_post_config(atom) :: term
+  def pop_post_config(key) do
+    update_state(fn {stack, post_config} ->
+      {value, post_config} = Keyword.pop(post_config, key)
+      {value, {stack, post_config}}
+    end)
   end
 
-  @spec clear_stack() :: :ok
-  def clear_stack do
-    cast fn state ->
-      %{state | stack: [], post_config: []}
-    end
+  @spec merge_config(config) :: :ok
+  def merge_config(config) do
+    update_stack(fn
+      [h | t] -> {:ok, [update_in(h.config, &Keyword.merge(&1, config)) | t]}
+      [] -> {:ok, []}
+    end)
   end
 
-  @doc """
-  Enables the recursion for the project at the top of the stack.
-  Returns true if recursion was enabled or false if the project
-  already had recursion enabled or there is no project in the stack.
-  """
-  @spec enable_recursion :: boolean
-  def enable_recursion do
-    get_and_update fn %{stack: stack} = state ->
-      case stack do
-        [h|t] ->
-          {not h.recursing?, %{state | stack: [%{h | recursing?: true}|t]}}
-        _ ->
-          {false, state}
-      end
+  @spec on_recursing_root((-> result)) :: result when result: var
+  def on_recursing_root(fun) do
+    {top, file} =
+      update_stack(fn stack ->
+        {top, [mid | bottom]} = Enum.split_while(stack, &(not &1.recursing?))
+        {{top, mid.file}, [%{mid | recursing?: false} | bottom]}
+      end)
+
+    try do
+      File.cd!(Path.dirname(file), fun)
+    after
+      update_stack(fn [mid | bottom] ->
+        {:ok, top ++ [%{mid | recursing?: true} | bottom]}
+      end)
     end
   end
 
-  @doc """
-  Disables the recursion for the project in the stack.
-  Returns true if recursion was disabled or false if there
-  is no project or recursion was not enabled.
-  """
-  @spec disable_recursion :: boolean
-  def disable_recursion do
-    get_and_update fn %{stack: stack} = state ->
-      case stack do
-        [h|t] ->
-          {h.recursing?, %{state | stack: [%{h | recursing?: false}|t]}}
-        _ ->
-          {false, state}
-      end
-    end
+  @spec loaded_config([atom], [binary()]) :: :ok
+  def loaded_config(apps, files) do
+    update_stack(fn
+      [%{config_apps: h_apps, config_files: h_files} = h | t] ->
+        h = %{
+          h
+          | config_apps: apps ++ h_apps,
+            config_files: files ++ h_files,
+            config_mtime: nil
+        }
+
+        {:ok, [h | t]}
+
+      [] ->
+        {:ok, []}
+    end)
   end
 
-  @spec read_cache(term) :: term
-  def read_cache(key) do
-    get fn %{cache: cache} ->
-      cache[key]
+  # We include the year 2000 as a minimum value in case we
+  # don't have any config files, which would return 0 and
+  # then not trigger stale sources.
+  @minimum_mtime 946_684_800
+
+  @spec config_mtime() :: integer
+  def config_mtime() do
+    mtime_or_files =
+      get_stack(fn
+        [%{config_mtime: nil, config_files: files} | _] -> files
+        [%{config_mtime: mtime} | _] -> mtime
+        [] -> @minimum_mtime
+      end)
+
+    if is_list(mtime_or_files) do
+      mtime =
+        mtime_or_files
+        |> Enum.map(&Mix.Utils.last_modified/1)
+        |> Enum.max()
+        |> max(@minimum_mtime)
+
+      update_stack(fn [h | t] -> {mtime, [%{h | config_mtime: mtime} | t]} end)
+    else
+      mtime_or_files
     end
   end
 
-  @spec write_cache(term, term) :: :ok
-  def write_cache(key, value) do
-    cast fn state ->
-      %{state | cache: Dict.put(state.cache, key, value)}
-    end
+  @spec reset_config_mtime() :: binary
+  def reset_config_mtime() do
+    update_stack(fn
+      [h | t] -> {:ok, [%{h | config_mtime: nil} | t]}
+      [] -> {:ok, []}
+    end)
+
+    @manifest
+  end
+
+  @spec config_apps() :: [atom]
+  def config_apps() do
+    get_stack(fn
+      [h | _] -> h.config_apps
+      [] -> []
+    end)
+  end
+
+  @spec config_files() :: [binary]
+  def config_files() do
+    get_stack(fn
+      [h | _] -> h.config_files
+      [] -> []
+    end)
+  end
+
+  @spec project_file() :: binary | nil
+  def project_file() do
+    get_stack(fn
+      [h | _] -> h.file
+      [] -> nil
+    end)
+  end
+
+  @spec parent_umbrella_project_file() :: binary | nil
+  def parent_umbrella_project_file() do
+    get_stack(fn
+      [_, h | _] -> if h.config[:apps_path], do: h.file, else: nil
+      _ -> nil
+    end)
   end
 
-  @spec clear_cache :: :ok
-  def clear_cache do
-    cast fn state ->
-      %{state | cache: HashDict.new}
+  @spec compile_env([term] | nil) :: [term] | nil
+  def compile_env(compile_env) do
+    update_stack(fn
+      [h | t] -> {h.compile_env, [%{h | compile_env: compile_env} | t]}
+      [] -> {nil, []}
+    end)
+  end
+
+  @spec prepend_after_compiler(atom, fun) :: :ok
+  def prepend_after_compiler(name, fun) do
+    update_stack(fn
+      [h | t] -> {:ok, [update_in(h.after_compiler[name], &[fun | &1 || []]) | t]}
+      [] -> {:ok, []}
+    end)
+  end
+
+  @spec pop_after_compiler(atom) :: [fun]
+  def pop_after_compiler(name) do
+    update_stack(fn
+      [h | t] ->
+        {value, h} = pop_in(h.after_compiler[name])
+        {value || [], [h | t]}
+
+      [] ->
+        {[], []}
+    end)
+  end
+
+  @spec pop() :: project | nil
+  def pop do
+    update_stack(fn
+      [h | t] -> {project(h), t}
+      [] -> {nil, []}
+    end)
+  end
+
+  @spec peek() :: project | nil
+  def peek do
+    get_stack(fn
+      [h | _] -> project(h)
+      [] -> nil
+    end)
+  end
+
+  @spec top_and_bottom() :: {project, project} | nil
+  def top_and_bottom do
+    get_stack(fn
+      [h | _] = stack -> {project(h), project(List.last(stack))}
+      [] -> nil
+    end)
+  end
+
+  @spec printable_app_name() :: atom | nil
+  def printable_app_name do
+    update_stack(fn
+      [] ->
+        {nil, []}
+
+      [%{io_done: true} | _] = stack ->
+        {nil, stack}
+
+      [h | t] ->
+        h = %{h | io_done: true}
+        t = Enum.map(t, &%{&1 | io_done: false})
+        {h.config[:app], [h | t]}
+    end)
+  end
+
+  @spec recur((-> result)) :: result when result: var
+  def recur(fun) do
+    update_stack(fn [h | t] -> {:ok, [%{h | recursing?: true} | t]} end)
+
+    try do
+      fun.()
+    after
+      update_stack(fn [h | t] -> {:ok, [%{h | recursing?: false} | t]} end)
     end
   end
 
-  defp find_project_named(name, stack) do
-    name && Enum.find_value(stack, fn
-      %{name: n, file: file} when n === name -> file
-      %{} -> nil
+  @spec recursing :: module | nil
+  def recursing do
+    get_stack(fn stack -> Enum.find_value(stack, &(&1.recursing? and &1.name)) end)
+  end
+
+  @spec push(module, config, file) :: :ok | {:error, file}
+  def push(module, config, file) do
+    update_state(fn {stack, post_config} ->
+      if existing_file = find_project_named(module, stack) do
+        {{:error, existing_file}, {stack, post_config}}
+      else
+        # Consider the first children to always have io_done
+        # because we don't need to print anything unless another
+        # project takes ahold of the shell.
+        io_done? = stack == []
+        config = Keyword.merge(config, post_config)
+        manifest_file = Path.join(Mix.Project.manifest_path(config), @manifest)
+        parent_files = peek_config_files(config[:inherit_parent_config_files], stack)
+
+        project = %{
+          name: module,
+          config: config,
+          file: file,
+          pos: length(stack),
+          recursing?: false,
+          io_done: io_done?,
+          config_apps: [],
+          config_files: [manifest_file | parent_files],
+          config_mtime: nil,
+          after_compiler: %{},
+          compile_env: nil
+        }
+
+        {:ok, {[project | stack], []}}
+      end
     end)
   end
 
-  defp take(h) do
+  defp peek_config_files(true, [%{config_files: files} | _]), do: files
+  defp peek_config_files(_, _), do: []
+
+  defp find_project_named(name, stack) do
+    name &&
+      Enum.find_value(stack, fn
+        %{name: n, file: file} when n == name -> file
+        %{} -> nil
+      end)
+  end
+
+  defp project(h) do
     Map.take(h, [:name, :config, :file, :pos])
   end
 
-  defp has_app?(%{config: config}) do
-    config[:app]
+  ## GenServer helpers and callbacks
+
+  defp get_stack(fun) do
+    GenServer.call(@name, {:get_stack, fun}, @timeout)
+  end
+
+  defp update_stack(fun) do
+    GenServer.call(@name, {:update_stack, fun}, @timeout)
+  end
+
+  defp update_state(fun) do
+    GenServer.call(@name, {:update_state, fun}, @timeout)
+  end
+
+  defp initial_state() do
+    {[], []}
+  end
+
+  @impl true
+  def init(:ok) do
+    {:ok, initial_state()}
   end
 
-  defp get_and_update(fun) do
-    Agent.get_and_update __MODULE__, fun, @timeout
+  @impl true
+  def handle_call({:get_stack, fun}, _from, {stack, post_config}) do
+    {:reply, fun.(stack), {stack, post_config}}
   end
 
-  defp get(fun) do
-    Agent.get __MODULE__, fun, @timeout
+  @impl true
+  def handle_call({:update_stack, fun}, _from, {stack, post_config}) do
+    {reply, stack} = fun.(stack)
+    {:reply, reply, {stack, post_config}}
   end
 
-  defp cast(fun) do
-    Agent.cast __MODULE__, fun
+  @impl true
+  def handle_call({:update_state, fun}, _from, state) do
+    {reply, state} = fun.(state)
+    {:reply, reply, state}
   end
 end
diff --git a/lib/mix/lib/mix/pubsub.ex b/lib/mix/lib/mix/pubsub.ex
new file mode 100644
index 00000000000..5926bfcff77
--- /dev/null
+++ b/lib/mix/lib/mix/pubsub.ex
@@ -0,0 +1,110 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Mix.PubSub do
+  @moduledoc false
+
+  # The Mix pub/sub is responsible for notifying other OS processes
+  # about relevant concurrent events.
+  #
+  # The pub/sub consists of a local subscriber process that receives
+  # events from other OS processes, and a listener supervisor, which
+  # holds all listener processes that have been configured. Whenever
+  # the subscriber receives an event, it sends a message to each of
+  # the listeners.
+  #
+  # Inherently, a compilation may be required before the listener
+  # modules are available, so we start the local subscriber process
+  # separately with `start/0`, and then start the listeners later
+  # with `start_listeners/0`. The subscriber is going to accumulate
+  # events and reply them once the listeners are started.
+
+  @spec start :: :ok
+  def start do
+    # Avoid calling the supervisor, if already started
+    if Process.whereis(Mix.PubSub) do
+      :ok
+    else
+      case Supervisor.start_child(Mix.Supervisor, Mix.PubSub) do
+        {:ok, _pid} ->
+          :ok
+
+        {:error, {:already_started, _pid}} ->
+          :ok
+
+        {:error, reason} ->
+          raise RuntimeError, "failed to start Mix.PubSub, reason: #{inspect(reason)}"
+      end
+    end
+  end
+
+  @spec child_spec(term) :: Supervisor.child_spec()
+  def child_spec(_opts) do
+    children = [
+      Mix.PubSub.Subscriber
+    ]
+
+    opts = [strategy: :one_for_one, name: Mix.PubSub]
+
+    %{
+      id: Mix.PubSub,
+      start: {Supervisor, :start_link, [children, opts]},
+      type: :supervisor
+    }
+  end
+
+  @spec start_listeners :: :ok
+  def start_listeners do
+    # Avoid calling the supervisor, if already started
+    if Process.whereis(Mix.PubSub.ListenerSupervisor) do
+      :ok
+    else
+      case Supervisor.start_child(Mix.PubSub, listener_supervisor()) do
+        {:ok, _pid} ->
+          Mix.PubSub.Subscriber.flush()
+          :ok
+
+        {:error, {:already_started, _pid}} ->
+          :ok
+
+        {:error, reason} ->
+          raise RuntimeError,
+                "failed to start Mix.PubSub.ListenerSupervisor, reason: #{inspect(reason)}"
+      end
+    end
+  end
+
+  defp listener_supervisor do
+    children = configured_listeners() ++ built_in_listeners()
+
+    children = Enum.map(children, &Supervisor.child_spec(&1, []))
+
+    opts = [strategy: :one_for_one, name: Mix.PubSub.ListenerSupervisor]
+
+    %{
+      id: Mix.PubSub.ListenerSupervisor,
+      start: {Supervisor, :start_link, [children, opts]},
+      type: :supervisor
+    }
+  end
+
+  defp configured_listeners do
+    config = Mix.Project.config()
+
+    listeners =
+      Application.get_env(:mix, :listeners, []) ++
+        Keyword.get(config, :listeners, [])
+
+    Enum.uniq(listeners)
+  end
+
+  defp built_in_listeners do
+    iex_started? = Process.whereis(IEx.Supervisor) != nil
+
+    if iex_started? do
+      [IEx.MixListener]
+    else
+      []
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/pubsub/subscriber.ex b/lib/mix/lib/mix/pubsub/subscriber.ex
new file mode 100644
index 00000000000..2fe66fef69c
--- /dev/null
+++ b/lib/mix/lib/mix/pubsub/subscriber.ex
@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Mix.PubSub.Subscriber do
+  @moduledoc false
+
+  use GenServer
+
+  @name __MODULE__
+
+  @spec start_link(keyword) :: GenServer.on_start()
+  def start_link(_opts) do
+    GenServer.start_link(__MODULE__, {}, name: @name)
+  end
+
+  @spec flush :: :ok
+  def flush do
+    GenServer.cast(@name, :flush)
+  end
+
+  @impl true
+  def init({}) do
+    build_path = Mix.Project.build_path()
+
+    case Mix.Sync.PubSub.subscribe(build_path) do
+      :ok ->
+        {:ok, %{acc: []}}
+
+      {:error, message} ->
+        IO.warn(message, [])
+        :ignore
+    end
+  end
+
+  @impl true
+  def handle_info(message, %{acc: nil} = state) do
+    notify_listeners([message])
+    {:noreply, state}
+  end
+
+  def handle_info(message, state) do
+    # Accumulate messages until the flush
+    {:noreply, update_in(state.acc, &[message | &1])}
+  end
+
+  @impl true
+  def handle_cast(:flush, state) do
+    notify_listeners(Enum.reverse(state.acc))
+    {:noreply, %{state | acc: nil}}
+  end
+
+  defp notify_listeners(messages) do
+    children = Supervisor.which_children(Mix.PubSub.ListenerSupervisor)
+
+    for message <- messages do
+      for {_, pid, _, _} <- children, is_pid(pid) do
+        send(pid, message)
+      end
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/rebar.ex b/lib/mix/lib/mix/rebar.ex
index 3f2b2931029..6f4d021e498 100644
--- a/lib/mix/lib/mix/rebar.ex
+++ b/lib/mix/lib/mix/rebar.ex
@@ -1,50 +1,92 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Rebar do
   @moduledoc false
 
+  # TODO: Remove on Elixir v1.22 because phx_new and other installers rely on it.
+  @deprecated "Use env_rebar_path/1 instead"
+  def global_rebar_cmd(manager) do
+    env_rebar_path(manager)
+  end
+
+  @deprecated "Use local_rebar_path/1 instead"
+  def local_rebar_cmd(manager) do
+    local_rebar_path(manager)
+  end
+
+  @deprecated "Use rebar_args/2 or available?/1 instead"
+  def rebar_cmd(manager) do
+    global_rebar_cmd(manager) || local_rebar_cmd(manager)
+  end
+
   @doc """
-  Returns the path supposed to host the local copy of rebar.
+  Returns if Rebar is available or not.
   """
-  def local_rebar_path, do: Path.join(Mix.Utils.mix_home, "rebar")
+  def available?(manager) do
+    env_rebar_path(manager) != nil or File.regular?(local_rebar_path(manager))
+  end
 
   @doc """
-  Returns the path to the global copy of rebar, if one exists.
+  Receives a Rebar executable and returns how it must be invoked.
+
+  It returns a result even if Rebar is not available.
   """
-  def global_rebar_cmd do
-    wrap_cmd System.find_executable("rebar")
+  def rebar_args(:rebar3, args) do
+    rebar = env_rebar_path(:rebar3) || local_rebar_path(:rebar3)
+
+    if match?({:win32, _}, :os.type()) and not String.ends_with?(rebar, ".cmd") do
+      {"escript.exe", [rebar | args]}
+    else
+      {rebar, args}
+    end
   end
 
   @doc """
-  Returns the path to the local copy of rebar, if one exists.
+  Returns the global rebar path.
   """
-  def local_rebar_cmd do
-    rebar = local_rebar_path
-    wrap_cmd(if File.regular?(rebar), do: rebar)
+  def env_rebar_path(:rebar3) do
+    System.get_env("MIX_REBAR3")
   end
 
   @doc """
-  Returns the path to the available rebar command.
+  Returns the path supposed to host the local copy of `rebar`.
+
+  The rebar3 installation is specific to the Elixir version and OTP release,
+  in order to force updates when new Elixir versions come out.
   """
-  def rebar_cmd do
-    global_rebar_cmd || local_rebar_cmd
+  def local_rebar_path(:rebar3) do
+    [major, minor | _] = String.split(System.version(), ".")
+
+    Path.join([
+      Mix.Utils.mix_home(),
+      "elixir",
+      "#{major}-#{minor}-otp-#{System.otp_release()}",
+      "rebar3"
+    ])
   end
 
   @doc """
-  Loads the rebar.config and evaluates rebar.config.script if it
+  Loads `rebar.config` and evaluates `rebar.config.script` if it
   exists in the given directory.
   """
   def load_config(dir) do
     config_path = Path.join(dir, "rebar.config")
     script_path = Path.join(dir, "rebar.config.script")
 
-    config = case :file.consult(config_path) do
-      {:ok, config} ->
-        config
-      {:error, :enoent} ->
-        []
-      {:error, error} ->
-        reason = :file.format_error(error)
-        Mix.raise "Error consulting rebar config #{config_path}: #{reason}"
-    end
+    config =
+      case :file.consult(config_path) do
+        {:ok, config} ->
+          config
+
+        {:error, :enoent} ->
+          []
+
+        {:error, error} ->
+          reason = :file.format_error(error)
+          Mix.raise("Error consulting Rebar config #{inspect(config_path)}: #{reason}")
+      end
 
     if File.exists?(script_path) do
       eval_script(script_path, config)
@@ -54,111 +96,185 @@ defmodule Mix.Rebar do
   end
 
   @doc """
-  Parses the dependencies in given rebar.config to Mix's dependency format.
+  Serializes a Rebar config to a term file.
+  """
+  def serialize_config(config) do
+    Enum.map(config, &[:io_lib.print(&1) | ".\n"])
+  end
+
+  @doc """
+  Updates Rebar configuration to be more suitable for dependencies.
+  """
+  def dependency_config(config) do
+    Enum.flat_map(config, fn
+      {:erl_opts, opts} ->
+        [{:erl_opts, List.delete(opts, :warnings_as_errors)}]
+
+      {:project_plugins, _} ->
+        []
+
+      other ->
+        [other]
+    end)
+  end
+
+  @doc """
+  Parses the dependencies in given `rebar.config` to Mix's dependency format.
   """
   def deps(config) do
+    # We don't have to handle Rebar3 profiles because dependencies
+    # are always in the default profile which cannot be customized
     if deps = config[:deps] do
-      deps_dir = config[:deps_dir] || "deps"
-      Enum.map(deps, &parse_dep(&1, deps_dir))
+      Enum.map(deps, &parse_dep/1)
     else
       []
     end
   end
 
-  @doc """
-  Runs `fun` for the given config and for each `sub_dirs` in the
-  given rebar config.
-  """
-  def recur(config, fun) when is_binary(config) do
-    recur(load_config(config), fun)
+  # Translate a Rebar dependency declaration to a Mix declaration
+  # From http://www.rebar3.org/docs/dependencies#section-declaring-dependencies
+  defp parse_dep(app) when is_atom(app) do
+    {app, override: true}
   end
 
-  def recur(config, fun) do
-    subs = (config[:sub_dirs] || [])
-     |> Enum.map(&Path.wildcard(&1))
-     |> Enum.concat
-     |> Enum.filter(&File.dir?(&1))
-     |> Enum.map(&recur(&1, fun))
-     |> Enum.concat
+  defp parse_dep({app, req}) when is_list(req) do
+    {app, List.to_string(req), override: true}
+  end
+
+  defp parse_dep({app, source}) when is_tuple(source) do
+    parse_dep({app, nil, source, []})
+  end
 
-    [fun.(config)|subs]
+  defp parse_dep({app, req, source}) do
+    parse_dep({app, req, source, []})
   end
 
-  defp parse_dep({app, req}, deps_dir) do
-    {app, compile_req(req), [path: Path.join(deps_dir, Atom.to_string(app))]}
+  defp parse_dep({app, req, source, opts}) do
+    source = parse_source(source)
+    compile = if :proplists.get_value(:raw, opts, false), do: [compile: false], else: []
+    opts = [override: true] ++ source ++ compile
+
+    if req do
+      {app, compile_req(req), opts}
+    else
+      {app, opts}
+    end
   end
 
-  defp parse_dep({app, req, source}, deps_dir) do
-    parse_dep({app, req, source, []}, deps_dir)
+  defp parse_source({:pkg, pkg}) do
+    [hex: pkg]
   end
 
-  defp parse_dep({app, req, source, opts}, _deps_dir) do
+  defp parse_source(source) do
     [scm, url | source] = Tuple.to_list(source)
-    mix_opts = [{scm, to_string(url)}]
+
+    {scm, additional_opts} =
+      case {scm, source} do
+        {:git_subdir, [_, sparse_dir | _]} -> {:git, [sparse: sparse_dir]}
+        {_, _} -> {:git, []}
+      end
 
     ref =
       case source do
-        [""|_]                -> [branch: "HEAD"]
-        [{:branch, branch}|_] -> [branch: to_string(branch)]
-        [{:tag, tag}|_]       -> [tag: to_string(tag)]
-        [ref|_]               -> [ref: to_string(ref)]
-        _                     -> []
+        ["" | _] -> [branch: "HEAD"]
+        [{:branch, branch} | _] -> [branch: to_string(branch)]
+        [{:tag, tag} | _] -> [tag: to_string(tag)]
+        [{:ref, ref} | _] -> [ref: to_string(ref)]
+        [ref | _] -> [ref: to_string(ref)]
+        _ -> []
       end
 
-    mix_opts = mix_opts ++ ref
+    [{scm, to_string(url)}] ++ ref ++ additional_opts
+  end
 
-    if :proplists.get_value(:raw, opts, false) do
-      mix_opts = mix_opts ++ [compile: false]
-    end
+  defp compile_req(req) do
+    req = List.to_string(req)
 
-    {app, compile_req(req), mix_opts}
-  end
+    case Version.parse_requirement(req) do
+      {:ok, _} ->
+        req
 
-  defp parse_dep(app, deps_dir) do
-    parse_dep({app, ".*"}, deps_dir)
-  end
+      :error ->
+        case Regex.compile(req) do
+          {:ok, re} ->
+            re
 
-  defp compile_req(req) do
-    case Regex.compile to_string(req) do
-      {:ok, re} ->
-        re
-      {:error, reason} ->
-        Mix.raise "Unable to compile version regex: \"#{req}\", #{reason}"
+          {:error, reason} ->
+            Mix.raise("Unable to compile version regular expression: #{inspect(req)}, #{reason}")
+        end
     end
   end
 
   defp eval_script(script_path, config) do
-    script = Path.basename(script_path) |> String.to_char_list
+    script = String.to_charlist(Path.basename(script_path))
 
-    result = File.cd!(Path.dirname(script_path), fn ->
-      :file.script(script, eval_binds(CONFIG: config, SCRIPT: script))
-    end)
+    result =
+      File.cd!(Path.dirname(script_path), fn ->
+        :file.script(script, eval_binds(CONFIG: config, SCRIPT: script))
+      end)
 
     case result do
       {:ok, config} ->
         config
+
       {:error, error} ->
         reason = :file.format_error(error)
-        Mix.shell.error("Error evaluating rebar config script #{script_path}: #{reason}")
-        Mix.shell.error("You may solve this issue by adding rebar as a dependency to your project")
-        Mix.shell.error("Any dependency defined in the script won't be available " <>
-                        "unless you add them to your Mix project")
+        Mix.shell().error("Error evaluating Rebar config script #{script_path}:#{reason}")
+
+        Mix.shell().error(
+          "Any dependencies defined in the script won't be available " <>
+            "unless you add them to your Mix project"
+        )
+
         config
     end
   end
 
   defp eval_binds(binds) do
-    Enum.reduce(binds, :erl_eval.new_bindings, fn ({k, v}, binds) ->
+    Enum.reduce(binds, :erl_eval.new_bindings(), fn {k, v}, binds ->
       :erl_eval.add_binding(k, v, binds)
     end)
   end
 
-  defp wrap_cmd(nil), do: nil
-  defp wrap_cmd(rebar) do
-    if match?({:win32, _}, :os.type) and not String.ends_with?(rebar,".cmd") do
-      "escript.exe #{rebar}"
-    else
-      rebar
-    end
+  @doc """
+  Applies the given overrides for app config.
+  """
+  def apply_overrides(app, config, overrides) do
+    # Inefficient. We want the order we get here though.
+    config =
+      Enum.reduce(overrides, config, fn
+        {:override, overrides}, config ->
+          Enum.reduce(overrides, config, fn {key, value}, config ->
+            Keyword.put(config, key, value)
+          end)
+
+        _, config ->
+          config
+      end)
+
+    config =
+      Enum.reduce(overrides, config, fn
+        {:override, ^app, overrides}, config ->
+          Enum.reduce(overrides, config, fn {key, value}, config ->
+            Keyword.put(config, key, value)
+          end)
+
+        _, config ->
+          config
+      end)
+
+    config =
+      Enum.reduce(overrides, config, fn
+        {:add, ^app, overrides}, config ->
+          Enum.reduce(overrides, config, fn {key, value}, config ->
+            old_value = Keyword.get(config, key, [])
+            Keyword.put(config, key, value ++ old_value)
+          end)
+
+        _, config ->
+          config
+      end)
+
+    Keyword.update(config, :overrides, overrides, &(overrides ++ &1))
   end
 end
diff --git a/lib/mix/lib/mix/release.ex b/lib/mix/lib/mix/release.ex
new file mode 100644
index 00000000000..9a399a04169
--- /dev/null
+++ b/lib/mix/lib/mix/release.ex
@@ -0,0 +1,964 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Release do
+  @moduledoc """
+  Defines the release structure and convenience for assembling releases.
+  """
+
+  @doc """
+  The Mix.Release struct has the following read-only fields:
+
+    * `:name` - the name of the release as an atom
+    * `:version` - the version of the release as a string
+    * `:path` - the path to the release root
+    * `:version_path` - the path to the release version inside the release
+    * `:applications` - a map of application with their definitions
+    * `:erts_source` - the ERTS source as a charlist (or nil)
+    * `:erts_version` - the ERTS version as a charlist
+
+  The following fields may be modified as long as they keep their defined types:
+
+    * `:boot_scripts` - a map of boot scripts with the boot script name
+      as key and a keyword list with **all** applications that are part of
+      it and their modes as value
+    * `:config_providers` - a list of `{config_provider, term}` tuples where the
+      first element is a module that implements the `Config.Provider` behaviour
+      and `term` is the value given to it on `c:Config.Provider.init/1`
+    * `:options` - a keyword list with all other user supplied release options
+    * `:overlays` - a list of extra files added to the release. If you have a custom
+      step adding extra files to a release, you can add these files to the `:overlays`
+      field so they are also considered on further commands, such as tar/zip. Each entry
+      in overlays is the relative path to the release root of each file
+    * `:steps` - a list of functions that receive the release and returns a release.
+      Must also contain the atom `:assemble` which is the internal assembling step.
+      May also contain the atom `:tar` to create a tarball of the release.
+
+  """
+  defstruct [
+    :name,
+    :version,
+    :path,
+    :version_path,
+    :applications,
+    :boot_scripts,
+    :erts_source,
+    :erts_version,
+    :config_providers,
+    :options,
+    :overlays,
+    :steps
+  ]
+
+  @type mode :: :permanent | :transient | :temporary | :load | :none
+  @type application :: atom()
+  @type t :: %__MODULE__{
+          name: atom(),
+          version: String.t(),
+          path: String.t(),
+          version_path: String.t(),
+          applications: %{application() => keyword()},
+          boot_scripts: %{atom() => [{application(), mode()}]},
+          erts_version: charlist(),
+          erts_source: charlist() | nil,
+          config_providers: [{module, term}],
+          options: keyword(),
+          overlays: list(String.t()),
+          steps: [(t -> t) | :assemble, ...]
+        }
+
+  @typedoc """
+  Options for stripping BEAM files.
+  """
+  @type strip_beam_opts :: [
+          keep: [String.t()],
+          compress: boolean()
+        ]
+
+  @typedoc """
+  Erlang/OTP sys.config structure.
+
+  A list of tuples where each tuple contains an application name and its
+  configuration as a keyword list. This is the standard format for Erlang
+  application configuration.
+  """
+  @type sys_config :: [{application(), keyword()}]
+
+  @default_apps [kernel: :permanent, stdlib: :permanent, elixir: :permanent, sasl: :permanent]
+  @safe_modes [:permanent, :temporary, :transient]
+  @unsafe_modes [:load, :none]
+  @additional_chunks ~w(Attr)c
+  @copy_app_dirs ["priv", "include"]
+
+  @doc false
+  @spec from_config!(atom, keyword, keyword) :: t
+  def from_config!(name, config, overrides) do
+    {name, apps, opts} = find_release(name, config)
+
+    if not (Atom.to_string(name) =~ ~r/^[a-z][a-z0-9_]*$/) do
+      Mix.raise(
+        "Invalid release name. A release name must start with a lowercase ASCII letter, " <>
+          "followed by lowercase ASCII letters, numbers, or underscores, got: #{inspect(name)}"
+      )
+    end
+
+    opts =
+      [overwrite: false, quiet: false, strip_beams: true]
+      |> Keyword.merge(opts)
+      |> Keyword.merge(overrides)
+
+    {include_erts, opts} = Keyword.pop(opts, :include_erts, true)
+    {erts_source, erts_lib_dir, erts_version} = erts_data(include_erts)
+
+    deps_apps = Mix.Project.deps_apps()
+    loaded_apps = load_apps(apps, deps_apps, %{}, erts_lib_dir, [], apps)
+
+    # Make sure IEx is either an active part of the release or add it as none.
+    {loaded_apps, apps} =
+      if Map.has_key?(loaded_apps, :iex) do
+        {loaded_apps, apps}
+      else
+        {load_apps([iex: :none], deps_apps, loaded_apps, erts_lib_dir, [], apps),
+         apps ++ [iex: :none]}
+      end
+
+    start_boot = build_start_boot(loaded_apps, apps)
+    start_clean_boot = build_start_clean_boot(start_boot)
+
+    {path, opts} =
+      Keyword.pop_lazy(opts, :path, fn ->
+        Path.join([Mix.Project.build_path(config), "rel", Atom.to_string(name)])
+      end)
+
+    path = Path.absname(path)
+
+    {version, opts} =
+      Keyword.pop_lazy(opts, :version, fn ->
+        config[:version] ||
+          Mix.raise(
+            "No :version found. Please make sure a :version is set in your project definition " <>
+              "or inside the release the configuration"
+          )
+      end)
+
+    version =
+      case version do
+        {:from_app, app} ->
+          Application.load(app)
+          version = Application.spec(app, :vsn)
+
+          if !version do
+            Mix.raise(
+              "Could not find version for #{inspect(app)}, please make sure the application exists"
+            )
+          end
+
+          to_string(version)
+
+        "" ->
+          Mix.raise("The release :version cannot be an empty string")
+
+        _ ->
+          version
+      end
+
+    {config_providers, opts} = Keyword.pop(opts, :config_providers, [])
+    {steps, opts} = Keyword.pop(opts, :steps, [:assemble])
+    validate_steps!(steps)
+
+    %Mix.Release{
+      name: name,
+      version: version,
+      path: path,
+      version_path: Path.join([path, "releases", version]),
+      erts_source: erts_source,
+      erts_version: erts_version,
+      applications: Map.delete(loaded_apps, :erts),
+      boot_scripts: %{start: start_boot, start_clean: start_clean_boot},
+      config_providers: config_providers,
+      options: opts,
+      overlays: [],
+      steps: steps
+    }
+  end
+
+  defp find_release(name, config) do
+    {name, opts_fun_or_list} = lookup_release(name, config) || infer_release(config)
+    opts = if is_function(opts_fun_or_list, 0), do: opts_fun_or_list.(), else: opts_fun_or_list
+    {apps, opts} = Keyword.pop(opts, :applications, [])
+
+    if apps == [] and Mix.Project.umbrella?(config) do
+      bad_umbrella!()
+    end
+
+    app = Keyword.get(config, :app)
+    apps = Keyword.merge(@default_apps, apps)
+
+    if is_nil(app) or Keyword.has_key?(apps, app) do
+      {name, apps, opts}
+    else
+      {name, apps ++ [{app, :permanent}], opts}
+    end
+  end
+
+  defp lookup_release(nil, config) do
+    case Keyword.get(config, :releases, []) do
+      [] ->
+        nil
+
+      [{name, opts}] ->
+        {name, opts}
+
+      [_ | _] ->
+        case Keyword.get(config, :default_release) do
+          nil ->
+            Mix.raise(
+              "\"mix release\" was invoked without a name but there are multiple releases. " <>
+                "Please call \"mix release NAME\" or set :default_release in your project configuration"
+            )
+
+          name ->
+            lookup_release(name, config)
+        end
+    end
+  end
+
+  defp lookup_release(name, config) do
+    if opts = config[:releases][name] do
+      {name, opts}
+    else
+      found = Keyword.get(config, :releases, [])
+
+      Mix.raise(
+        "Unknown release #{inspect(name)}. " <>
+          "The available releases are: #{inspect(Keyword.keys(found))}"
+      )
+    end
+  end
+
+  defp infer_release(config) do
+    if Mix.Project.umbrella?(config) do
+      bad_umbrella!()
+    else
+      {Keyword.fetch!(config, :app), []}
+    end
+  end
+
+  defp bad_umbrella! do
+    Mix.raise("""
+    Umbrella projects require releases to be explicitly defined with \
+    a non-empty applications key that chooses which umbrella children \
+    should be part of the releases:
+
+        releases: [
+          foo: [
+            applications: [child_app_foo: :permanent]
+          ],
+          bar: [
+            applications: [child_app_bar: :permanent]
+          ]
+        ]
+
+    Alternatively you can perform the release from the children applications
+    """)
+  end
+
+  defp erts_data(erts_data) when is_function(erts_data) do
+    erts_data(erts_data.())
+  end
+
+  defp erts_data(false) do
+    {nil, :code.lib_dir(), :erlang.system_info(:version)}
+  end
+
+  defp erts_data(true) do
+    version = :erlang.system_info(:version)
+    {:filename.join(:code.root_dir(), ~c"erts-#{version}"), :code.lib_dir(), version}
+  end
+
+  defp erts_data(erts_source) when is_binary(erts_source) do
+    if File.exists?(erts_source) do
+      [_, erts_version] = erts_source |> Path.basename() |> String.split("-")
+      erts_lib_dir = erts_source |> Path.dirname() |> Path.join("lib") |> to_charlist()
+      {to_charlist(erts_source), erts_lib_dir, to_charlist(erts_version)}
+    else
+      Mix.raise("Could not find ERTS system at #{inspect(erts_source)}")
+    end
+  end
+
+  defp load_apps(apps, deps_apps, seen, otp_root, optional, overrides) do
+    for {app, mode} <- apps, reduce: seen do
+      seen ->
+        properties = seen[app]
+
+        cond do
+          is_nil(properties) ->
+            load_app(app, overrides[app] || mode, deps_apps, seen, otp_root, optional, overrides)
+
+          Keyword.has_key?(overrides, app) ->
+            seen
+
+          new_mode = merge_mode!(app, mode, properties[:mode]) ->
+            apps =
+              properties
+              |> Keyword.get(:applications, [])
+              |> Enum.map(&{&1, new_mode})
+
+            seen = put_in(seen[app][:mode], new_mode)
+            optional = Keyword.get(properties, :optional_applications, [])
+            load_apps(apps, deps_apps, seen, otp_root, optional, overrides)
+
+          true ->
+            seen
+        end
+    end
+  end
+
+  defp merge_mode!(_app, mode, mode), do: nil
+
+  defp merge_mode!(app, left, right) do
+    if left == :included or right == :included do
+      Mix.raise(
+        "#{inspect(app)} is listed both as a regular application and as an included application"
+      )
+    else
+      merge_mode(left, right)
+    end
+  end
+
+  defp merge_mode(:none, other), do: other
+  defp merge_mode(other, :none), do: other
+  defp merge_mode(:load, other), do: other
+  defp merge_mode(other, :load), do: other
+  defp merge_mode(:temporary, other), do: other
+  defp merge_mode(other, :temporary), do: other
+  defp merge_mode(:transient, other), do: other
+  defp merge_mode(other, :transient), do: other
+  defp merge_mode(:permanent, other), do: other
+  defp merge_mode(other, :permanent), do: other
+
+  defp load_app(app, mode, deps_apps, seen, otp_root, optional, overrides) do
+    cond do
+      path = app not in deps_apps && otp_path(otp_root, app) ->
+        do_load_app(app, mode, path, deps_apps, seen, otp_root, true, overrides)
+
+      path = code_path(app) ->
+        do_load_app(app, mode, path, deps_apps, seen, otp_root, false, overrides)
+
+      app in optional ->
+        seen
+
+      true ->
+        Mix.raise("Could not find application #{inspect(app)}")
+    end
+  end
+
+  defp otp_path(otp_root, app) do
+    path = Path.join(otp_root, "#{app}-*")
+
+    case Path.wildcard(path) do
+      [] -> nil
+      paths -> paths |> Enum.sort() |> List.last() |> to_charlist()
+    end
+  end
+
+  defp code_path(app) do
+    case :code.lib_dir(app) do
+      {:error, :bad_name} -> nil
+      path -> path
+    end
+  end
+
+  defp do_load_app(app, mode, path, deps_apps, seen, otp_root, otp_app?, overrides) do
+    case :file.consult(Path.join(path, "ebin/#{app}.app")) do
+      {:ok, terms} ->
+        [{:application, ^app, properties}] = terms
+        value = [path: path, otp_app?: otp_app?, mode: mode] ++ properties
+        seen = Map.put(seen, app, value)
+        child_mode = if mode == :included, do: :load, else: mode
+
+        applications =
+          properties
+          |> Keyword.get(:applications, [])
+          |> Enum.map(&{&1, child_mode})
+
+        optional = Keyword.get(properties, :optional_applications, [])
+        seen = load_apps(applications, deps_apps, seen, otp_root, optional, overrides)
+
+        included_applications =
+          properties
+          |> Keyword.get(:included_applications, [])
+          |> Enum.map(&{&1, :included})
+
+        load_apps(included_applications, deps_apps, seen, otp_root, [], overrides)
+
+      {:error, reason} ->
+        Mix.raise("Could not load #{app}.app. Reason: #{inspect(reason)}")
+    end
+  end
+
+  defp build_start_boot(all_apps, specified_apps) do
+    specified_apps ++
+      Enum.sort(
+        for(
+          {app, props} <- all_apps,
+          not List.keymember?(specified_apps, app, 0),
+          do: {app, boot_mode(props[:mode])}
+        )
+      )
+  end
+
+  defp boot_mode(:included), do: :load
+  defp boot_mode(mode), do: mode
+
+  defp build_start_clean_boot(boot) do
+    for({app, mode} <- boot, do: {app, if(mode == :none, do: :none, else: :load)})
+    |> Keyword.put(:stdlib, :permanent)
+    |> Keyword.put(:kernel, :permanent)
+  end
+
+  defp validate_steps!(steps) do
+    valid_atoms = [:assemble, :tar]
+
+    if not is_list(steps) or Enum.any?(steps, &(&1 not in valid_atoms and not is_function(&1, 1))) do
+      Mix.raise("""
+      The :steps option must be a list of:
+
+        * anonymous function that receives one argument
+        * the atom :assemble or :tar
+
+      Got: #{inspect(steps)}
+      """)
+    end
+
+    if Enum.count(steps, &(&1 == :assemble)) != 1 do
+      Mix.raise("The :steps option must contain the atom :assemble once, got: #{inspect(steps)}")
+    end
+
+    if :assemble in Enum.drop_while(steps, &(&1 != :tar)) do
+      Mix.raise("The :tar step must come after :assemble")
+    end
+
+    if Enum.count(steps, &(&1 == :tar)) > 1 do
+      Mix.raise("The :steps option can only contain the atom :tar once")
+    end
+
+    :ok
+  end
+
+  @doc """
+  Makes the `sys.config` structure.
+
+  If there are config providers, then a value is injected into
+  the `:elixir` application configuration in `sys_config` to be
+  read during boot and trigger the providers.
+
+  It uses the following release options to customize its behavior:
+
+    * `:reboot_system_after_config`
+    * `:start_distribution_during_config`
+    * `:prune_runtime_sys_config_after_boot`
+
+  In case there are no config providers, it doesn't change `sys_config`.
+  """
+  @spec make_sys_config(t, sys_config(), Config.Provider.config_path()) ::
+          :ok | {:error, String.t()}
+  def make_sys_config(release, sys_config, config_provider_path) do
+    {sys_config, runtime_config?} =
+      merge_provider_config(release, sys_config, config_provider_path)
+
+    case consultable_sys_config(sys_config) do
+      {:ok, contents} ->
+        path = Path.join(release.version_path, "sys.config")
+        args = [runtime_config?, contents]
+        format = "%% coding: utf-8~n%% RUNTIME_CONFIG=~s~n~ts.~n"
+        File.mkdir_p!(Path.dirname(path))
+        File.write!(path, IO.chardata_to_string(:io_lib.format(format, args)))
+        :ok
+
+      {:error, message} ->
+        {:error, message}
+    end
+  end
+
+  defp consultable_sys_config(sys_config) do
+    contents =
+      Enum.map_intersperse(sys_config, ?,, fn {app, kv} ->
+        kv =
+          Enum.map_intersperse(kv, ?,, fn {key, value} ->
+            case Mix.Utils.consultable(value) do
+              {:ok, value} -> [?{, :io_lib.print(key), ?,, value, ?}]
+              {:error, term, reason} -> throw({:error, app, key, term, reason})
+            end
+          end)
+
+        [?{, :io_lib.print(app), ?,, ?[, kv, ?], ?}]
+      end)
+
+    {:ok, [?[, contents, ?]]}
+  catch
+    {:error, app, key, value, reason} ->
+      message = """
+      Could not write configuration file because it has invalid terms
+
+      Application: #{inspect(app)}
+      Key: #{inspect(key)}
+      Invalid value: #{inspect(value)}
+      Reason: #{reason}
+      """
+
+      {:error, message}
+  end
+
+  defp merge_provider_config(%{config_providers: []}, sys_config, _), do: {sys_config, false}
+
+  defp merge_provider_config(release, sys_config, config_path) do
+    {reboot?, extra_config, initial_config} = start_distribution(release)
+
+    prune_runtime_sys_config_after_boot =
+      Keyword.get(release.options, :prune_runtime_sys_config_after_boot, false)
+
+    opts = [
+      extra_config: initial_config,
+      prune_runtime_sys_config_after_boot: prune_runtime_sys_config_after_boot,
+      reboot_system_after_config: reboot?,
+      validate_compile_env: validate_compile_env(release)
+    ]
+
+    init_config = Config.Provider.init(release.config_providers, config_path, opts)
+    {Config.Reader.merge(sys_config, init_config ++ extra_config), reboot?}
+  end
+
+  defp validate_compile_env(release) do
+    with true <- Keyword.get(release.options, :validate_compile_env, true),
+         [_ | _] = compile_env <- compile_env(release) do
+      compile_env
+    else
+      _ -> false
+    end
+  end
+
+  defp compile_env(release) do
+    for {_, properties} <- release.applications,
+        triplet <- Keyword.get(properties, :compile_env, []),
+        do: triplet
+  end
+
+  defp start_distribution(%{options: opts}) do
+    reboot? = Keyword.get(opts, :reboot_system_after_config, false)
+    early_distribution? = Keyword.get(opts, :start_distribution_during_config, false)
+
+    if not reboot? or early_distribution? do
+      {reboot?, [], []}
+    else
+      {true, [kernel: [start_distribution: false]], [kernel: [start_distribution: true]]}
+    end
+  end
+
+  @doc """
+  Copies the cookie to the given path.
+
+  If a cookie option was given, we compare it with
+  the contents of the file (if any), and ask the user
+  if they want to override.
+
+  If there is no option, we generate a random one
+  the first time.
+  """
+  @spec make_cookie(t, Path.t()) :: :ok
+  def make_cookie(release, path) do
+    cond do
+      cookie = release.options[:cookie] ->
+        force? = Keyword.get(release.options, :overwrite, false)
+        Mix.Generator.create_file(path, cookie, quiet: true, force: force?)
+        :ok
+
+      File.exists?(path) ->
+        :ok
+
+      true ->
+        File.write!(path, random_cookie())
+        :ok
+    end
+  end
+
+  defp random_cookie, do: Base.encode32(:crypto.strong_rand_bytes(32))
+
+  @doc """
+  Makes the start_erl.data file with the
+  ERTS version and release versions.
+  """
+  @spec make_start_erl(t, Path.t()) :: :ok
+  def make_start_erl(release, path) do
+    File.write!(path, "#{release.erts_version} #{release.version}")
+    :ok
+  end
+
+  @doc """
+  Makes boot scripts.
+
+  It receives a path to the boot file, without extension, such as
+  `releases/0.1.0/start` and this command will write `start.rel`,
+  `start.boot`, and `start.script` to the given path, returning
+  `{:ok, rel_path}` or `{:error, message}`.
+
+  The boot script uses the RELEASE_LIB environment variable, which must
+  be accordingly set with `--boot-var` and point to the release lib dir.
+  """
+  @spec make_boot_script(t, Path.t(), [{application(), mode()}], [String.t()]) ::
+          :ok | {:error, String.t()}
+  def make_boot_script(release, path, modes, prepend_paths \\ []) do
+    with {:ok, rel_spec} <- build_release_spec(release, modes) do
+      File.write!(path <> ".rel", consultable(rel_spec))
+
+      sys_path = String.to_charlist(path)
+
+      sys_options = [
+        :silent,
+        :no_dot_erlang,
+        :no_warn_sasl,
+        variables: build_variables(release),
+        path: build_paths(release)
+      ]
+
+      case :systools.make_script(sys_path, sys_options) do
+        {:ok, _module, _warnings} ->
+          script_path = sys_path ++ ~c".script"
+          {:ok, [{:script, rel_info, instructions}]} = :file.consult(script_path)
+
+          instructions =
+            instructions
+            |> post_stdlib_applies(release)
+            |> prepend_paths_to_script(prepend_paths)
+
+          script = {:script, rel_info, instructions}
+          File.write!(script_path, consultable(script))
+          :ok = :systools.script2boot(sys_path)
+
+        {:error, module, info} ->
+          message = module.format_error(info) |> to_string() |> String.trim()
+          {:error, message}
+      end
+    end
+  end
+
+  defp build_variables(release) do
+    for {_, properties} <- release.applications,
+        not Keyword.fetch!(properties, :otp_app?),
+        uniq: true,
+        do: {~c"RELEASE_LIB", properties |> Keyword.fetch!(:path) |> :filename.dirname()}
+  end
+
+  defp build_paths(release) do
+    for {_, properties} <- release.applications,
+        Keyword.fetch!(properties, :otp_app?),
+        do: properties |> Keyword.fetch!(:path) |> Path.join("ebin") |> to_charlist()
+  end
+
+  defp build_release_spec(release, modes) do
+    %{
+      name: name,
+      version: version,
+      erts_version: erts_version,
+      applications: apps,
+      options: options
+    } = release
+
+    skip_mode_validation_for =
+      options
+      |> Keyword.get(:skip_mode_validation_for, [])
+      |> MapSet.new()
+
+    rel_apps =
+      for {app, mode} <- modes do
+        properties = Map.get(apps, app) || throw({:error, "Unknown application #{inspect(app)}"})
+        children = Keyword.get(properties, :applications, [])
+        optional = Keyword.get(properties, :optional_applications, [])
+        app in skip_mode_validation_for || validate_mode!(app, mode, modes, children, optional)
+        build_app_for_release(app, mode, properties)
+      end
+
+    {:ok, {:release, {to_charlist(name), to_charlist(version)}, {:erts, erts_version}, rel_apps}}
+  catch
+    {:error, message} -> {:error, message}
+  end
+
+  defp validate_mode!(app, mode, modes, children, optional) do
+    safe_mode? = mode in @safe_modes
+
+    if not safe_mode? and mode not in @unsafe_modes do
+      throw(
+        {:error,
+         "Unknown mode #{inspect(mode)} for #{inspect(app)}. " <>
+           "Valid modes are: #{inspect(@safe_modes ++ @unsafe_modes)}"}
+      )
+    end
+
+    for child <- children do
+      child_mode = Keyword.get(modes, child)
+
+      cond do
+        is_nil(child_mode) and child not in optional ->
+          throw(
+            {:error,
+             "Application #{inspect(app)} is listed in the release boot, " <>
+               "but it depends on #{inspect(child)}, which isn't"}
+          )
+
+        safe_mode? and child_mode in @unsafe_modes ->
+          throw(
+            {:error,
+             """
+             Application #{inspect(app)} has mode #{inspect(mode)} but it depends on \
+             #{inspect(child)} which is set to #{inspect(child_mode)}. If you really want \
+             to set such mode for #{inspect(child)} make sure that all applications that depend \
+             on it are also set to :load or :none, otherwise your release will fail to boot
+             """}
+          )
+
+        true ->
+          :ok
+      end
+    end
+  end
+
+  defp build_app_for_release(app, mode, properties) do
+    vsn = Keyword.fetch!(properties, :vsn)
+
+    case Keyword.get(properties, :included_applications, []) do
+      [] -> {app, vsn, mode}
+      included_apps -> {app, vsn, mode, included_apps}
+    end
+  end
+
+  defp post_stdlib_applies(instructions, release) do
+    {pre, [stdlib | post]} =
+      Enum.split_while(
+        instructions,
+        &(not match?({:apply, {:application, :start_boot, [:stdlib, _]}}, &1))
+      )
+
+    pre ++ [stdlib] ++ config_provider_apply(release) ++ post
+  end
+
+  defp config_provider_apply(%{config_providers: []}),
+    do: []
+
+  defp config_provider_apply(_),
+    do: [{:apply, {Config.Provider, :boot, []}}]
+
+  defp prepend_paths_to_script(instructions, []), do: instructions
+
+  defp prepend_paths_to_script(instructions, prepend_paths) do
+    prepend_paths = Enum.map(prepend_paths, &String.to_charlist/1)
+
+    Enum.map(instructions, fn
+      {:path, paths} ->
+        if Enum.any?(paths, &List.starts_with?(&1, ~c"$RELEASE_LIB")) do
+          {:path, prepend_paths ++ paths}
+        else
+          {:path, paths}
+        end
+
+      other ->
+        other
+    end)
+  end
+
+  defp consultable(term) do
+    IO.chardata_to_string(:io_lib.format("%% coding: utf-8~n~tp.~n", [term]))
+  end
+
+  @doc """
+  Finds a template path for the release.
+  """
+  @spec rel_templates_path(t, Path.t()) :: binary
+  def rel_templates_path(release, path) do
+    Path.join(release.options[:rel_templates_path] || "rel", path)
+  end
+
+  @doc """
+  Copies ERTS if the release is configured to do so.
+
+  Returns `true` if the release was copied, `false` otherwise.
+  """
+  @spec copy_erts(t) :: boolean()
+  def copy_erts(%{erts_source: nil}) do
+    false
+  end
+
+  def copy_erts(release) do
+    destination = Path.join(release.path, "erts-#{release.erts_version}/bin")
+    File.mkdir_p!(destination)
+
+    release.erts_source
+    |> Path.join("bin")
+    |> File.cp_r!(destination, on_conflict: fn _, _ -> false end)
+
+    _ = File.rm(Path.join(destination, "erl"))
+    _ = File.rm(Path.join(destination, "erl.ini"))
+
+    destination
+    |> Path.join("erl")
+    |> File.write!(~S"""
+    #!/bin/sh
+    SELF=$(readlink "$0" || true)
+    if [ -z "$SELF" ]; then SELF="$0"; fi
+    BINDIR="$(cd "$(dirname "$SELF")" && pwd -P)"
+    ROOTDIR="${ERL_ROOTDIR:-"$(dirname "$(dirname "$BINDIR")")"}"
+    EMU=beam
+    PROGNAME=$(echo "$0" | sed 's/.*\///')
+    export EMU
+    export ROOTDIR
+    export BINDIR
+    export PROGNAME
+    exec "$BINDIR/erlexec" ${1+"$@"}
+    """)
+
+    File.chmod!(Path.join(destination, "erl"), 0o755)
+    true
+  end
+
+  @doc """
+  Copies the given application specification into the release.
+
+  It assumes the application exists in the release.
+  """
+  @spec copy_app(t, application) :: boolean()
+  def copy_app(release, app) do
+    properties = Map.fetch!(release.applications, app)
+    vsn = Keyword.fetch!(properties, :vsn)
+
+    source_app = Keyword.fetch!(properties, :path)
+    target_app = Path.join([release.path, "lib", "#{app}-#{vsn}"])
+
+    if is_nil(release.erts_source) and Keyword.fetch!(properties, :otp_app?) do
+      false
+    else
+      File.rm_rf!(target_app)
+      File.mkdir_p!(target_app)
+
+      copy_ebin(release, Path.join(source_app, "ebin"), Path.join(target_app, "ebin"))
+
+      for dir <- @copy_app_dirs do
+        source_dir = Path.join(source_app, dir)
+        target_dir = Path.join(target_app, dir)
+        File.exists?(source_dir) && File.cp_r!(source_dir, target_dir, dereference_symlinks: true)
+      end
+
+      true
+    end
+  end
+
+  @doc """
+  Copies the ebin directory at `source` to `target`
+  respecting release options such a `:strip_beams`.
+  """
+  @spec copy_ebin(t, Path.t(), Path.t()) :: boolean()
+  def copy_ebin(release, source, target) do
+    with {:ok, [_ | _] = files} <- File.ls(source) do
+      File.mkdir_p!(target)
+
+      strip_options =
+        release.options
+        |> Keyword.get(:strip_beams, true)
+        |> parse_strip_beams_options()
+
+      for file <- files do
+        source_file = Path.join(source, file)
+        target_file = Path.join(target, file)
+
+        case Path.extname(file) do
+          ".beam" ->
+            process_beam_file(source_file, target_file, strip_options)
+
+          ".app" ->
+            process_app_file(source_file, target_file)
+
+          _ ->
+            # Use File.cp!/3 to preserve file mode for any executables stored
+            # in the ebin directory.
+            File.cp!(source_file, target_file)
+        end
+      end
+
+      true
+    else
+      _ -> false
+    end
+  end
+
+  defp process_beam_file(source_file, target_file, strip_options) do
+    with true <- is_list(strip_options),
+         {:ok, binary} <- strip_beam(File.read!(source_file), strip_options) do
+      File.write!(target_file, binary)
+    else
+      _ -> File.cp!(source_file, target_file)
+    end
+  end
+
+  defp process_app_file(source_file, target_file) do
+    with {:ok, [{:application, app, info}]} <- :file.consult(source_file) do
+      File.write!(target_file, :io_lib.format("~tp.~n", [{:application, app, info}]))
+    else
+      _ -> File.cp!(source_file, target_file)
+    end
+  end
+
+  @doc """
+  Strips a beam file for a release.
+
+  This keeps only significant chunks necessary for the VM operation,
+  discarding documentation, debug info, compile information and others.
+
+  The exact chunks that are kept are not documented and may change in
+  future versions.
+
+  ## Options
+
+    * `:keep` - a list of additional chunk names (as strings) to keep in the
+      stripped BEAM file beyond those required by Erlang/Elixir
+
+    * `:compress` - when `true`, the resulting BEAM file will be compressed
+      using gzip. Defaults to `false`
+
+  ## Examples
+
+      # Strip with default options
+      Mix.Release.strip_beam(beam_binary)
+
+      # Keep additional chunks and compress
+      Mix.Release.strip_beam(beam_binary, keep: ["Docs", "ChunkName"], compress: true)
+
+  """
+  @spec strip_beam(binary(), strip_beam_opts()) :: {:ok, binary()} | {:error, :beam_lib, term()}
+  def strip_beam(binary, options \\ []) when is_list(options) do
+    chunks_to_keep = options[:keep] |> List.wrap() |> Enum.map(&String.to_charlist/1)
+    all_chunks = Enum.uniq(@additional_chunks ++ :beam_lib.significant_chunks() ++ chunks_to_keep)
+    compress? = Keyword.get(options, :compress, false)
+
+    case :beam_lib.chunks(binary, all_chunks, [:allow_missing_chunks]) do
+      {:ok, {_, chunks}} ->
+        chunks = for {name, chunk} <- chunks, is_binary(chunk), do: {name, chunk}
+        {:ok, binary} = :beam_lib.build_module(chunks)
+
+        if compress? do
+          {:ok, :zlib.gzip(binary)}
+        else
+          {:ok, binary}
+        end
+
+      {:error, _, _} = error ->
+        error
+    end
+  end
+
+  defp parse_strip_beams_options(options) do
+    case options do
+      options when is_list(options) -> options
+      true -> []
+      false -> nil
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/remote_converger.ex b/lib/mix/lib/mix/remote_converger.ex
index e9de940ffa6..14bbc3ee988 100644
--- a/lib/mix/lib/mix/remote_converger.ex
+++ b/lib/mix/lib/mix/remote_converger.ex
@@ -1,42 +1,50 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.RemoteConverger do
   @moduledoc false
-  use Behaviour
 
   # A remote converger returns updated dependencies with
-  # extra information that can be used during mix's converging.
+  # extra information that can be used during Mix's converging.
   # Useful for things like external package managers
 
   @doc """
-  Return `true` if given dependency is handled by
+  Returns `true` if given dependency is handled by
   remote converger.
   """
-  defcallback remote?(Mix.Dep.t) :: boolean
+  @callback remote?(Mix.Dep.t()) :: boolean
 
   @doc """
-  Run the remote converger.
+  Runs the remote converger.
 
   Return updated lock.
   """
-  defcallback converge([Mix.Dep.t], map) :: map
+  @callback converge([Mix.Dep.t()], map) :: map
 
   @doc """
   Returns child dependencies the converger has for the
   dependency. This list should filter the loaded children.
   """
-  defcallback deps(Mix.Dep.t, map) :: [atom]
+  @callback deps(Mix.Dep.t(), map) :: [atom]
 
+  @doc """
+  Called after all convergers have run so that the remote
+  converger can perform cleanup.
+  """
+  @callback post_converge() :: any
 
   @doc """
-  Get registered remote converger.
+  Gets registered remote converger.
   """
   def get do
-    Application.get_env(:mix, :remote_converger)
+    Mix.State.get(:remote_converger)
   end
 
   @doc """
-  Register a remote converger.
+  Registers a remote converger.
   """
   def register(mod) when is_atom(mod) do
-    Application.put_env(:mix, :remote_converger, mod)
+    Mix.State.put(:remote_converger, mod)
   end
 end
diff --git a/lib/mix/lib/mix/scm.ex b/lib/mix/lib/mix/scm.ex
index f83df6ec052..eae876a7d50 100644
--- a/lib/mix/lib/mix/scm.ex
+++ b/lib/mix/lib/mix/scm.ex
@@ -1,22 +1,29 @@
-defmodule Mix.SCM do
-  use Behaviour
-
-  @type opts :: Keyword.t
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
+defmodule Mix.SCM do
   @moduledoc """
   This module provides helper functions and defines the
-  behaviour required by any SCM used by mix.
+  behaviour required by any source code manager (SCM) used by Mix.
   """
 
+  @typedoc """
+  A module implementing the `Mix.SCM` behaviour.
+  """
+  @type t :: module
+
+  @type opts :: keyword
+
   @doc """
   Returns a boolean if the dependency can be fetched
   or it is meant to be previously available in the
-  filesystem.
+  file system.
 
-  Local dependencies (i.e. non fetchable ones) are automatically
+  Local dependencies (i.e. non-fetchable ones) are automatically
   recompiled every time the parent project is compiled.
   """
-  defcallback fetchable? :: boolean
+  @callback fetchable? :: boolean
 
   @doc """
   Returns a string representing the SCM. This is used
@@ -24,7 +31,7 @@ defmodule Mix.SCM do
   so the amount of information should be concise and
   easy to spot.
   """
-  defcallback format(opts) :: String.t
+  @callback format(opts) :: String.t()
 
   @doc """
   Returns a string representing the SCM. This is used
@@ -34,7 +41,7 @@ defmodule Mix.SCM do
 
   If nil is returned, it means no lock information is available.
   """
-  defcallback format_lock(opts) :: String.t | nil
+  @callback format_lock(opts) :: String.t() | nil
 
   @doc """
   This behaviour function receives a keyword list of `opts`
@@ -47,15 +54,15 @@ defmodule Mix.SCM do
   Each registered SCM will be asked if they consume this dependency,
   receiving `[github: "foo/bar"]` as argument. Since this option makes
   sense for the Git SCM, it will return an update list of options
-  while other SCMs would simply return nil.
+  while other SCMs would simply return `nil`.
   """
-  defcallback accepts_options(app :: atom, opts) :: opts | nil
+  @callback accepts_options(app :: atom, opts) :: opts | nil
 
   @doc """
   This behaviour function returns a boolean if the
   dependency is available.
   """
-  defcallback checked_out?(opts) :: boolean
+  @callback checked_out?(opts) :: boolean
 
   @doc """
   This behaviour function checks out dependencies.
@@ -67,7 +74,7 @@ defmodule Mix.SCM do
 
   It must return the current lock.
   """
-  defcallback checkout(opts) :: any
+  @callback checkout(opts) :: any
 
   @doc """
   This behaviour function updates dependencies. It may be
@@ -79,12 +86,14 @@ defmodule Mix.SCM do
 
   It must return the current lock.
   """
-  defcallback update(opts) :: any
+  @callback update(opts) :: any
 
   @doc """
   This behaviour function checks the status of the lock. In
   particular, it checks if the revision stored in the lock
-  is the same as the repository it is currently in. It may return:
+  is the same as the repository it is currently in.
+
+  It may return:
 
     * `:mismatch` - if the lock doesn't match and we need to
       simply move to the latest lock
@@ -96,43 +105,55 @@ defmodule Mix.SCM do
 
   The lock is sent via `opts[:lock]` but it may not always be
   available. In such cases, if the SCM requires a lock, it must
-  return `:lockmismatch`, otherwise simply `:ok`.
+  return `:mismatch`, otherwise simply `:ok`.
 
   Note the lock may also belong to another SCM and as such, an
   structural check is required. A structural mismatch should always
   return `:outdated`.
   """
-  defcallback lock_status(opts) :: :mismatch | :outdated | :ok
+  @callback lock_status(opts) :: :mismatch | :outdated | :ok
 
   @doc """
-  Receives two options and must return true if they refer to the
+  Receives two options and must return `true` if they refer to the
   same repository. The options are guaranteed to belong to the
   same SCM.
   """
-  defcallback equal?(opts1 :: opts, opts2 :: opts) :: boolean
+  @callback equal?(opts1 :: opts, opts2 :: opts) :: boolean
+
+  @doc """
+  Returns the usable managers for the dependency. This can be used
+  if the SCM has extra knowledge of the dependency, otherwise it
+  should return an empty list.
+  """
+  @callback managers(opts) :: [atom]
 
   @doc """
   Returns all available SCMs. Each SCM is tried in order
   until a matching one is found.
   """
   def available do
-    {:ok, scm} = Application.fetch_env(:mix, :scm)
-    scm
+    Mix.State.get(:scm)
+  end
+
+  @doc """
+  Deletes the given SCM from the list of available SCMs.
+  """
+  @doc since: "1.16.2"
+  def delete(mod) when is_atom(mod) do
+    Mix.State.update(:scm, &List.delete(&1, mod))
   end
 
   @doc """
-  Prepend the given SCM module to the list of available SCMs.
+  Prepends the given SCM module to the list of available SCMs.
   """
   def prepend(mod) when is_atom(mod) do
-    available = Enum.reject(available(), &(&1 == mod))
-    Application.put_env(:mix, :scm, [mod|available])
+    Mix.State.update(:scm, &[mod | List.delete(&1, mod)])
   end
 
   @doc """
-  Append the given SCM module to the list of available SCMs.
+  Appends the given SCM module to the list of available SCMs.
   """
   def append(mod) when is_atom(mod) do
-    available = Enum.reject(available(), &(&1 == mod))
-    Application.put_env(:mix, :scm, available ++ [mod])
+    Mix.State.update(:scm, &(List.delete(&1, mod) ++ [mod]))
   end
 end
diff --git a/lib/mix/lib/mix/scm/git.ex b/lib/mix/lib/mix/scm/git.ex
index 686c95ec050..cb2c29f5c35 100644
--- a/lib/mix/lib/mix/scm/git.ex
+++ b/lib/mix/lib/mix/scm/git.ex
@@ -1,132 +1,312 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.SCM.Git do
   @behaviour Mix.SCM
   @moduledoc false
 
+  @impl true
   def fetchable? do
     true
   end
 
+  @impl true
   def format(opts) do
-    opts[:git]
+    if rev = get_opts_rev(opts) do
+      "#{redact_uri(opts[:git])} - #{rev}"
+    else
+      redact_uri(opts[:git])
+    end
   end
 
+  @impl true
   def format_lock(opts) do
     case opts[:lock] do
       {:git, _, lock_rev, lock_opts} ->
         lock = String.slice(lock_rev, 0, 7)
-        case Enum.find_value [:branch, :ref, :tag], &List.keyfind(lock_opts, &1, 0) do
-          {:ref, _}  -> lock <> " (ref)"
+
+        case Enum.find_value([:ref, :branch, :tag], &List.keyfind(lock_opts, &1, 0)) do
+          {:ref, _} -> lock <> " (ref)"
           {key, val} -> lock <> " (#{key}: #{val})"
-          nil        -> lock
+          nil -> lock
         end
+
       _ ->
         nil
     end
   end
 
+  @impl true
   def accepts_options(_app, opts) do
+    opts =
+      opts
+      |> Keyword.put(:checkout, opts[:dest])
+      |> sparse_opts()
+      |> subdir_opts()
+
     cond do
       gh = opts[:github] ->
-        opts |> Keyword.delete(:github) |> Keyword.put(:git, "git://github.com/#{gh}.git")
+        opts
+        |> Keyword.delete(:github)
+        |> Keyword.put(:git, "https://github.com/#{gh}.git")
+        |> validate_git_options()
+
       opts[:git] ->
         opts
+        |> validate_git_options()
+
       true ->
         nil
     end
   end
 
+  @impl true
   def checked_out?(opts) do
-    # Are we inside a git repository?
-    File.regular?(Path.join(opts[:dest], ".git/HEAD"))
+    # Are we inside a Git repository?
+    opts[:checkout]
+    |> Path.join(".git/HEAD")
+    |> File.regular?()
   end
 
+  @impl true
   def lock_status(opts) do
-    assert_git
+    lock = opts[:lock]
 
-    case opts[:lock] do
-      {:git, lock_repo, lock_rev, lock_opts} ->
-        File.cd!(opts[:dest], fn ->
-          rev_info = get_rev_info
-          cond do
-            lock_repo != opts[:git]          -> :outdated
-            lock_opts != get_lock_opts(opts) -> :outdated
-            lock_rev  != rev_info[:rev]      -> :mismatch
-            lock_repo != rev_info[:origin]   -> :outdated
-            true -> :ok
+    cond do
+      lock_rev = get_lock_rev(lock, opts) ->
+        File.cd!(opts[:checkout], fn ->
+          %{origin: origin, rev: rev} = get_rev_info()
+
+          if get_lock_repo(lock) == origin and lock_rev == rev do
+            :ok
+          else
+            :mismatch
           end
         end)
-      nil ->
+
+      is_nil(lock) ->
         :mismatch
-      _ ->
+
+      true ->
         :outdated
     end
   end
 
+  @impl true
   def equal?(opts1, opts2) do
-    opts1[:git] == opts2[:git] &&
-      get_lock_opts(opts1) == get_lock_opts(opts2)
+    opts1[:git] == opts2[:git] and get_lock_opts(opts1) == get_lock_opts(opts2)
   end
 
-  def checkout(opts) do
-    assert_git
-
-    path     = opts[:dest]
-    location = opts[:git]
+  @impl true
+  def managers(_opts) do
+    []
+  end
 
+  @impl true
+  def checkout(opts) do
+    path = opts[:checkout]
     File.rm_rf!(path)
-    command  = ~s(git clone --no-checkout --progress "#{location}" "#{path}")
+    File.mkdir_p!(opts[:dest])
 
-    run_cmd_or_raise(command)
-    File.cd! path, fn -> do_checkout(opts) end
+    File.cd!(path, fn ->
+      git!(~w[-c core.hooksPath='' init --quiet])
+      git!(["--git-dir=.git", "remote", "add", "origin", opts[:git]])
+      checkout(path, opts)
+    end)
   end
 
+  @impl true
   def update(opts) do
-    assert_git
+    path = opts[:checkout]
+    File.cd!(path, fn -> checkout(path, opts) end)
+  end
+
+  defp checkout(_path, opts) do
+    Mix.shell().print_app()
+
+    # Set configuration
+    sparse_toggle(opts)
+    update_origin(opts[:git])
 
-    File.cd! opts[:dest], fn ->
-      # Ensures origin is set the lock repo
-      location = opts[:git]
-      update_origin(location)
+    # Fetch external data
+    lock_rev = get_lock_rev(opts[:lock], opts)
 
-      command = "git --git-dir=.git fetch --force"
+    ["--git-dir=.git", "fetch", "--force", "--quiet"]
+    |> Kernel.++(progress_switch(git_version()))
+    |> Kernel.++(tags_switch(opts[:tag]))
+    |> Kernel.++(depth_switch(opts[:depth]))
+    |> Kernel.++(refspec_switch(opts, lock_rev || get_opts_rev(opts)))
+    |> git!()
+
+    # Migrate the Git repo
+    rev = lock_rev || get_origin_opts_rev(opts) || default_branch()
+    git!(["--git-dir=.git", "checkout", "--force", "--quiet", rev])
+
+    if opts[:submodules] do
+      git!(~w[-c core.hooksPath='' --git-dir=.git submodule update --init --recursive])
+    end
+
+    # Get the new repo lock
+    get_lock(opts)
+  end
 
-      if {1, 7, 1} <= git_version() do
-        command = command <> " --progress"
-      end
+  defp sparse_opts(opts) do
+    if opts[:sparse] do
+      dest = Path.join(opts[:dest], opts[:sparse])
+      Keyword.put(opts, :dest, dest)
+    else
+      opts
+    end
+  end
+
+  defp subdir_opts(opts) do
+    if opts[:subdir] do
+      dest = Path.join(opts[:dest], opts[:subdir])
+      Keyword.put(opts, :dest, dest)
+    else
+      opts
+    end
+  end
+
+  defp sparse_toggle(opts) do
+    cond do
+      sparse = opts[:sparse] ->
+        check_sparse_support(git_version())
+        git!(["--git-dir=.git", "config", "core.sparsecheckout", "true"])
+        File.mkdir_p!(".git/info")
+        File.write!(".git/info/sparse-checkout", sparse)
+
+      File.exists?(".git/info/sparse-checkout") ->
+        File.write!(".git/info/sparse-checkout", "*")
+        git!(["--git-dir=.git", "read-tree", "-mu", "HEAD"])
+        git!(["--git-dir=.git", "config", "core.sparsecheckout", "false"])
+        File.rm(".git/info/sparse-checkout")
+
+      true ->
+        :ok
+    end
+  end
+
+  @min_git_version_sparse {1, 7, 4}
+  @min_git_version_depth {1, 5, 0}
+  @min_git_version_progress {1, 7, 1}
+
+  defp check_sparse_support(version) do
+    ensure_feature_compatibility(version, @min_git_version_sparse, "sparse checkout")
+  end
+
+  defp check_depth_support(version) do
+    ensure_feature_compatibility(version, @min_git_version_depth, "depth (shallow clone)")
+  end
+
+  defp ensure_feature_compatibility(version, required_version, feature) do
+    if not (required_version <= version) do
+      Mix.raise(
+        "Git >= #{format_version(required_version)} is required to use #{feature}. " <>
+          "You are running version #{format_version(version)}"
+      )
+    end
+  end
+
+  defp progress_switch(version) do
+    if @min_git_version_progress <= version, do: ["--progress"], else: []
+  end
+
+  defp tags_switch(nil), do: []
+  defp tags_switch(_), do: ["--tags"]
+
+  defp depth_switch(nil), do: []
+
+  defp depth_switch(n) when is_integer(n) and n > 0 do
+    check_depth_support(git_version())
+    ["--depth=#{n}"]
+  end
 
-      if opts[:tag] do
-        command = command <> " --tags"
-      end
+  defp refspec_switch(_opts, nil), do: []
 
-      run_cmd_or_raise(command)
-      do_checkout(opts)
+  defp refspec_switch(opts, rev) do
+    case Keyword.take(opts, [:depth, :branch, :tag]) do
+      [_ | _] -> ["origin", rev]
+      _ -> []
     end
   end
 
   ## Helpers
 
-  defp do_checkout(opts) do
-    ref = get_lock_rev(opts[:lock]) || get_opts_rev(opts)
-    run_cmd_or_raise "git --git-dir=.git checkout --quiet #{ref}"
+  defp validate_git_options(opts) do
+    opts
+    |> validate_refspec()
+    |> validate_depth()
+  end
 
-    if opts[:submodules] do
-      run_cmd_or_raise "git --git-dir=.git submodule update --init --recursive"
+  defp validate_refspec(opts) do
+    case Keyword.take(opts, [:branch, :ref, :tag]) do
+      [] ->
+        opts
+
+      [{_refspec, value}] when is_binary(value) ->
+        opts
+
+      [{refspec, value}] ->
+        Mix.raise(
+          "A dependency's #{refspec} must be a string, got: #{inspect(value)}. " <>
+            "Error on Git dependency: #{redact_uri(opts[:git])}"
+        )
+
+      _ ->
+        Mix.raise(
+          "You should specify only one of branch, ref or tag, and only once. " <>
+            "Error on Git dependency: #{redact_uri(opts[:git])}"
+        )
     end
+  end
 
-    get_lock(opts)
+  @sha1_size 40
+
+  defp validate_depth(opts) do
+    case Keyword.take(opts, [:depth]) do
+      [] ->
+        opts
+
+      [{:depth, depth}] when is_integer(depth) and depth > 0 ->
+        ref = opts[:ref]
+
+        if ref && byte_size(ref) < @sha1_size do
+          Mix.raise(
+            "When :depth is used with :ref, a full commit hash is required. " <>
+              "Error on Git dependency: #{redact_uri(opts[:git])}"
+          )
+        end
+
+        opts
+
+      invalid_depth ->
+        Mix.raise(
+          "The depth must be a positive integer, and be specified only once, got: #{inspect(invalid_depth)}. " <>
+            "Error on Git dependency: #{redact_uri(opts[:git])}"
+        )
+    end
   end
 
   defp get_lock(opts) do
-    rev_info = get_rev_info
-    {:git, opts[:git], rev_info[:rev], get_lock_opts(opts)}
+    %{rev: rev} = get_rev_info()
+    {:git, opts[:git], rev, get_lock_opts(opts)}
+  end
+
+  defp get_lock_repo({:git, repo, _, _}), do: repo
+
+  defp get_lock_rev({:git, repo, lock, lock_opts}, opts) when is_binary(lock) do
+    if repo == opts[:git] and lock_opts == get_lock_opts(opts) do
+      lock
+    end
   end
 
-  defp get_lock_rev({:git, _repo, lock, _opts}) when is_binary(lock), do: lock
-  defp get_lock_rev(_), do: nil
+  defp get_lock_rev(_, _), do: nil
 
   defp get_lock_opts(opts) do
-    lock_opts = Enum.find_value [:branch, :ref, :tag], &List.keyfind(opts, &1, 0)
-    lock_opts = List.wrap(lock_opts)
+    lock_opts = Keyword.take(opts, [:branch, :ref, :tag, :sparse, :subdir, :depth])
+
     if opts[:submodules] do
       lock_opts ++ [submodules: true]
     else
@@ -135,61 +315,132 @@ defmodule Mix.SCM.Git do
   end
 
   defp get_opts_rev(opts) do
+    opts[:branch] || opts[:ref] || opts[:tag]
+  end
+
+  defp get_origin_opts_rev(opts) do
     if branch = opts[:branch] do
       "origin/#{branch}"
     else
-      opts[:ref] || opts[:tag] || "origin/master"
+      opts[:ref] || opts[:tag]
+    end
+  end
+
+  defp redact_uri(git) do
+    case URI.parse(git) do
+      %{userinfo: nil} -> git
+      uri -> URI.to_string(%{uri | userinfo: "****:****"})
     end
   end
 
   defp get_rev_info do
-    destructure [origin, rev],
-      System.cmd('git --git-dir=.git config remote.origin.url && git --git-dir=.git rev-parse --verify --quiet HEAD')
-      |> IO.iodata_to_binary
-      |> String.split("\n", trim: true)
-    [ origin: origin, rev: rev ]
+    # These commands can fail and we don't want to raise.
+    origin_command = ["--git-dir=.git", "config", "remote.origin.url"]
+    rev_command = ["--git-dir=.git", "rev-parse", "--verify", "--quiet", "HEAD"]
+    opts = cmd_opts([])
+
+    with {origin, 0} <- System.cmd("git", origin_command, opts),
+         {rev, 0} <- System.cmd("git", rev_command, opts) do
+      %{origin: String.trim(origin), rev: String.trim(rev)}
+    else
+      _ -> %{origin: nil, rev: nil}
+    end
   end
 
   defp update_origin(location) do
-    System.cmd('git --git-dir=.git config remote.origin.url #{location}')
+    git!(["--git-dir=.git", "config", "remote.origin.url", location])
+    :ok
   end
 
-  defp run_cmd_or_raise(command) do
-    if Mix.shell.cmd(command) != 0 do
-      Mix.raise "Command `#{command}` failed"
-    end
-    true
+  defp default_branch() do
+    # Note: the `set-head -a` command requires the remote reference to be
+    # fetched first.
+    git!(["--git-dir=.git", "remote", "set-head", "origin", "-a"])
+    "origin/HEAD"
   end
 
-  defp assert_git do
-    case Application.fetch_env(:mix, :git_available) do
-      {:ok, true} ->
-        :ok
-      :error ->
-        if :os.find_executable('git') == false do
-          Mix.raise "Error fetching/updating Git repository: the `git` "  <>
-            "executable is not available in your PATH. Please install "   <>
+  defp git!(args, into \\ default_into()) do
+    opts = cmd_opts(into: into, stderr_to_stdout: true)
+
+    try do
+      System.cmd("git", args, opts)
+    catch
+      :error, :enoent ->
+        Mix.raise(
+          "Error fetching/updating Git repository: the \"git\" " <>
+            "executable is not available in your PATH. Please install " <>
             "Git on this machine or pass --no-deps-check if you want to " <>
             "run a previously built application on a system without Git."
-        else
-          Application.put_env(:mix, :git_available, true)
-        end
+        )
+    else
+      {response, 0} ->
+        response
+
+      {response, _} when is_binary(response) ->
+        Mix.raise("Command \"git #{Enum.join(args, " ")}\" failed with reason: #{response}")
+
+      {_, _} ->
+        Mix.raise("Command \"git #{Enum.join(args, " ")}\" failed")
+    end
+  end
+
+  defp default_into() do
+    case Mix.shell() do
+      Mix.Shell.IO -> IO.stream()
+      _ -> ""
+    end
+  end
+
+  # Attempt to set the current working directory by default.
+  # This addresses an issue changing the working directory when executing from
+  # within a secondary node since file I/O is done through the main node.
+  defp cmd_opts(opts) do
+    case File.cwd() do
+      {:ok, cwd} -> Keyword.put(opts, :cd, cwd)
+      _ -> opts
     end
   end
 
+  # Invoked by lib/mix/test/test_helper.exs
+  @doc false
+  def unsupported_options do
+    git_version = git_version()
+
+    []
+    |> Kernel.++(if git_version < @min_git_version_sparse, do: [:sparse], else: [])
+    |> Kernel.++(if git_version < @min_git_version_depth, do: [:depth], else: [])
+  end
+
   defp git_version do
-    case Application.fetch_env(:mix, :git_version) do
+    case Mix.State.fetch(:git_version) do
       {:ok, version} ->
         version
+
       :error ->
-        "git version " <> version = String.strip System.cmd("git --version")
-        version = String.split(version, ".")
-                  |> Enum.take(3)
-                  |> Enum.map(&String.to_integer(&1))
-                  |> List.to_tuple
+        version =
+          ["--version"]
+          |> git!("")
+          |> parse_version()
 
-        Application.put_env(:mix, :git_version, version)
+        Mix.State.put(:git_version, version)
         version
     end
   end
+
+  defp parse_version("git version " <> version) do
+    version
+    |> String.split(".")
+    |> Enum.take(3)
+    |> Enum.map(&to_integer/1)
+    |> List.to_tuple()
+  end
+
+  defp format_version(version) do
+    version |> Tuple.to_list() |> Enum.join(".")
+  end
+
+  defp to_integer(string) do
+    {int, _} = Integer.parse(string)
+    int
+  end
 end
diff --git a/lib/mix/lib/mix/scm/path.ex b/lib/mix/lib/mix/scm/path.ex
index 7f544d748bf..179498e36ca 100644
--- a/lib/mix/lib/mix/scm/path.ex
+++ b/lib/mix/lib/mix/scm/path.ex
@@ -1,52 +1,86 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.SCM.Path do
   @behaviour Mix.SCM
   @moduledoc false
 
+  @impl true
   def fetchable? do
     false
   end
 
+  @impl true
   def format(opts) do
     opts[:path]
   end
 
+  @impl true
   def format_lock(_opts) do
     nil
   end
 
+  @impl true
   def accepts_options(app, opts) do
     cond do
       raw = opts[:path] ->
-        Keyword.put opts, :dest, Path.expand(raw)
+        Keyword.put(opts, :dest, Path.expand(raw))
+
       opts[:in_umbrella] ->
+        if opts[:override] do
+          Mix.shell().error("""
+          warning: in-umbrella application #{inspect(app)} has the flag :override \
+          set to true, but the flag has no effect when running from the umbrella root
+          """)
+        end
+
+        if opts[:optional] do
+          Mix.shell().error("""
+          warning: in-umbrella application #{inspect(app)} has the flag :optional \
+          set to true, but the flag is not supported for umbrella dependencies
+          """)
+        end
+
         path = "../#{app}"
 
         opts
         |> Keyword.put(:dest, Path.expand(path))
         |> Keyword.put_new(:path, path)
-        |> Keyword.put_new(:env, Mix.env)
+        |> Keyword.put_new(:env, Mix.env())
+
       true ->
         nil
     end
   end
 
+  @impl true
   def checked_out?(opts) do
     File.dir?(opts[:dest])
   end
 
+  @impl true
   def lock_status(_opts) do
     :ok
   end
 
+  @impl true
   def equal?(opts1, opts2) do
     opts1[:dest] == opts2[:dest]
   end
 
+  @impl true
+  def managers(_opts) do
+    []
+  end
+
+  @impl true
   def checkout(opts) do
-    path = Path.relative_to_cwd opts[:dest]
-    Mix.raise "Cannot checkout path dependency, expected a dependency at #{path}"
+    path = Path.relative_to_cwd(opts[:dest])
+    Mix.raise("Cannot checkout path dependency, expected a dependency at #{path}")
   end
 
+  @impl true
   def update(opts) do
     opts[:lock]
   end
diff --git a/lib/mix/lib/mix/shell.ex b/lib/mix/lib/mix/shell.ex
index 6a65f83bab9..e1aa69ddda3 100644
--- a/lib/mix/lib/mix/shell.ex
+++ b/lib/mix/lib/mix/shell.ex
@@ -1,89 +1,179 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Shell do
   @moduledoc """
-  Defines Mix.Shell contract.
+  Defines `Mix.Shell` contract.
   """
 
-  use Behaviour
+  @type cmd_opts :: [
+          {:print_app, boolean()}
+          | {:stderr_to_stdout, boolean()}
+          | {:quiet, boolean()}
+          | {:env, [{String.t(), String.t()}]}
+          | {:cd, String.t()}
+          | {atom(), term()}
+        ]
+
+  @type yes_opts :: [
+          {:default, :yes | :no}
+          | {atom(), term()}
+        ]
+
+  @type stream_cmd_opts :: [
+          {:cd, String.t()}
+          | {:stderr_to_stdout, boolean()}
+          | {:use_stdio, boolean()}
+          | {:env, [{String.t(), String.t()}]}
+          | {:quiet, boolean()}
+          | {atom(), term()}
+        ]
+
+  @doc false
+  defstruct [:callback]
+
+  @doc """
+  Prints the given ANSI message to the shell.
+  """
+  @callback info(message :: IO.ANSI.ansidata()) :: :ok
 
   @doc """
-  Informs the given message.
+  Prints the given ANSI error to the shell.
   """
-  defcallback info(message :: String.t) :: any
+  @callback error(message :: IO.ANSI.ansidata()) :: :ok
 
   @doc """
-  Warns about the given error message.
+  Executes the given command and returns its exit status.
+
+  Shortcut for `c:cmd/2` with empty options.
+  """
+  @callback cmd(command :: String.t()) :: integer
+
+  @doc """
+  Executes the given command and returns its exit status.
+
+  ## Options
+
+  This callback should support the following options:
+
+    * `:print_app` - when `false`, does not print the app name
+      when the command outputs something
+
+    * `:stderr_to_stdout` - when `false`, does not redirect
+      stderr to stdout
+
+    * `:quiet` - when `true`, do not print the command output
+
+    * `:env` - environment options to the executed command
+
+    * `:cd` *(since v1.11.0)* - the directory to run the command in
+
+  All the built-in shells support these.
   """
-  defcallback error(message :: String.t) :: any
+  @callback cmd(command :: String.t(), options :: cmd_opts) :: integer
 
   @doc """
   Prompts the user for input.
   """
-  defcallback prompt(message :: String.t) :: String.t
+  @callback prompt(message :: binary) :: binary
 
   @doc """
-  Asks the user for confirmation.
+  Prompts the user for confirmation.
+
+  Shortcut for `yes?/2` with empty options.
   """
-  defcallback yes?(message :: String.t) :: boolean
+  @callback yes?(message :: binary) :: boolean
 
   @doc """
-  Executes the given command and returns
-  its exit status.
+  Prompts the user for confirmation.
+
+  ## Options
+
+    * `:default` - `:yes` or `:no` (the default is `:yes`)
   """
-  defcallback cmd(command :: String.t) :: integer
+  @callback yes?(message :: binary, options :: yes_opts) :: boolean
 
   @doc """
-  Prints the current application to shell if
+  Prints the current application to the shell if
   it was not printed yet.
   """
-  defcallback print_app() :: any
+  @callback print_app() :: :ok
 
   @doc """
-  Returns if we should print application name to shell.
+  Returns the printable app name.
+
+  This function returns the current application name,
+  but only if the application name should be printed.
 
   Calling this function automatically toggles its value
-  to false.
+  to `false` until the current project is re-entered. The
+  goal is to avoid printing the application name
+  multiple times.
   """
-  def print_app? do
-    Mix.ProjectStack.print_app?
+  @spec printable_app_name() :: atom | nil
+  def printable_app_name do
+    Mix.ProjectStack.printable_app_name()
   end
 
   @doc """
-  An implementation of the command callback that
-  is shared across different shells.
+  Executes the given `command` and invokes the `callback` for the streamed response.
+
+  `command` is either a string, to be executed as a `System.shell/2` command,
+  or a `{executable, args}` to be executed via `System.cmd/3`.
+
+  `callback` takes the output data of the command. Its return value is ignored.
+
+  This function is most commonly used by `Mix.Shell` implementations but can
+  also be invoked directly.
+
+  ## Options
+
+    * `:cd` *(since v1.11.0)* - the directory to run the command in
+
+    * `:stderr_to_stdout` - redirects stderr to stdout, defaults to `true`, unless `:use_stdio` is set to `false`
+
+    * `:use_stdio` - controls whether the command should use `stdin` / `stdout` / `stderr`, defaults to `true`
+
+    * `:env` - a list of environment variables, defaults to `[]`
+
+    * `:quiet` - overrides the callback to no-op
+
   """
-  def cmd(command, callback) do
-    port = Port.open({:spawn, shell_command(command)},
-      [:stream, :binary, :exit_status, :hide, :use_stdio, :stderr_to_stdout])
-    do_cmd(port, callback)
-  end
+  @spec cmd(String.t() | {String.t(), [String.t()]}, stream_cmd_opts, (binary -> term)) ::
+          exit_status :: non_neg_integer
+  def cmd(command, options \\ [], callback) when is_function(callback, 1) do
+    callback =
+      if options[:quiet] do
+        fn x -> x end
+      else
+        callback
+      end
 
-  defp do_cmd(port, callback) do
-    receive do
-      {^port, {:data, data}} ->
-        callback.(data)
-        do_cmd(port, callback)
-      {^port, {:exit_status, status}} ->
-        status
-    end
+    use_stdio = Keyword.get(options, :use_stdio, true)
+
+    options =
+      options
+      |> Keyword.take([:cd, :stderr_to_stdout, :env, :use_stdio])
+      |> Keyword.put(:into, %Mix.Shell{callback: callback})
+      |> Keyword.put_new(:stderr_to_stdout, use_stdio)
+
+    {_, status} =
+      case command do
+        {command, args} -> System.cmd(command, args, options)
+        command when is_binary(command) -> System.shell(command, options)
+      end
+
+    status
   end
 
-  # Finding shell command logic from :os.cmd in OTP
-  # https://github.com/erlang/otp/blob/8deb96fb1d017307e22d2ab88968b9ef9f1b71d0/lib/kernel/src/os.erl#L184
-  defp shell_command(command) do
-    case :os.type do
-      {:unix, _} ->
-        command = command
-          |> String.replace("\"", "\\\"")
-          |> :binary.bin_to_list
-        'sh -c "' ++ command ++ '"'
-
-      {:win32, osname} ->
-        command = :binary.bin_to_list(command)
-        case {System.get_env("COMSPEC"), osname} do
-          {nil, :windows} -> 'command.com /c ' ++ command
-          {nil, _}        -> 'cmd /c ' ++ command
-          {cmd, _}        -> '#{cmd} /c ' ++ command
-        end
+  defimpl Collectable do
+    def into(%Mix.Shell{callback: fun}) do
+      {:ok,
+       fn
+         _, {:cont, data} -> fun.(data)
+         _, _ -> :ok
+       end}
     end
   end
 end
diff --git a/lib/mix/lib/mix/shell/io.ex b/lib/mix/lib/mix/shell/io.ex
index 48631000aa6..b9841fc6827 100644
--- a/lib/mix/lib/mix/shell/io.ex
+++ b/lib/mix/lib/mix/shell/io.ex
@@ -1,68 +1,128 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Shell.IO do
   @moduledoc """
   This is Mix's default shell.
+
   It simply prints messages to stdio and stderr.
   """
 
   @behaviour Mix.Shell
 
+  @typedoc """
+  Options for `yes?/2`.
+  """
+  @type yes_opts :: [default: :yes | :no]
+
   @doc """
-  Prints the currently running application if it
+  Prints the current application to the shell if it
   was not printed yet.
   """
   def print_app do
-    if Mix.Shell.print_app? do
-      IO.puts "==> #{Mix.Project.config[:app]}"
+    if name = Mix.Shell.printable_app_name() do
+      IO.puts("==> #{name}")
     end
-  end
 
-  @doc """
-  Executes the given command and prints its output
-  to stdout as it comes.
-  """
-  def cmd(command) do
-    Mix.Shell.cmd(command, &IO.write(&1))
+    :ok
   end
 
   @doc """
-  Writes a message to the shell followed by new line.
+  Prints the given ANSI message to the shell followed by a newline.
   """
   def info(message) do
-    print_app
-    IO.puts IO.ANSI.escape(message)
+    print_app()
+    IO.puts(IO.ANSI.format(message))
   end
 
   @doc """
-  Writes an error message to the shell followed by new line.
+  Prints the given ANSI error to the shell followed by a newline.
   """
   def error(message) do
-    print_app
-    IO.puts :stderr, IO.ANSI.escape "%{red,bright}#{message}"
+    print_app()
+    IO.puts(:stderr, IO.ANSI.format(red(message)))
   end
 
   @doc """
-  Writes a message shell followed by prompting the user for
-  input. Input will be consumed until enter is pressed.
+  Prints a message and prompts the user for input.
+
+  Input will be consumed until Enter is pressed.
   """
   def prompt(message) do
-    print_app
-    IO.gets IO.ANSI.escape(message <> " ")
+    print_app()
+
+    case IO.gets(message <> " ") do
+      {:error, _} -> raise "Mix.shell().prompt/1 is not supported over this device"
+      answer -> answer
+    end
   end
 
   @doc """
-  Receives a message and asks the user if he wants to proceed.
-  He must press enter or type anything that matches the a "yes"
-  regex `~r/^Y(es)?$/i`.
+  Prints a message and asks the user to confirm if they
+  want to proceed. The user must type and submit one of
+  "y", "yes", "Y", "YES" or "Yes".
+
+  The user may also press Enter; this can be configured
+  to either accept or reject the prompt. The latter case
+  may be useful for a potentially dangerous operation that
+  should require explicit confirmation from the user.
+
+  If the default IO device is stderr, then it will default
+  to the default value.
+
+  ## Options
+
+    * `:default` - (:yes or :no) if `:yes` pressing Enter
+      accepts the prompt; if `:no` pressing Enter rejects
+      the prompt instead. Defaults to `:yes`.
+
+  ## Examples
+
+      if Mix.shell().yes?("Are you sure?") do
+        # do something...
+      end
+
   """
-  def yes?(message) do
-    print_app
-    got_yes? IO.gets(message <> IO.ANSI.escape(" [Yn] "))
+  @spec yes?(String.t(), yes_opts) :: boolean()
+  def yes?(message, options \\ []) do
+    default = Keyword.get(options, :default, :yes)
+
+    if default not in [:yes, :no] do
+      raise ArgumentError,
+            "expected :default to be either :yes or :no, got: #{inspect(default)}"
+    end
+
+    answers = ["y", "Y", "yes", "YES", "Yes"]
+
+    {prompt, accepted_answers} =
+      case default do
+        :yes -> {" [Yn] ", ["" | answers]}
+        :no -> {" [yN] ", answers}
+      end
+
+    print_app()
+
+    case IO.gets(message <> prompt) do
+      {:error, _} -> default == :yes
+      answer -> is_binary(answer) and String.trim(answer) in accepted_answers
+    end
   end
 
-  defp got_yes?(answer) when is_binary(answer) do
-    answer =~ ~r/^(Y(es)?)?$/i
+  defp red(message) do
+    [:red, :bright, message]
   end
 
-  # The io server may return :eof or :error
-  defp got_yes?(_), do: false
+  @doc """
+  Executes the given command and prints its output
+  to stdout as it comes.
+  """
+  def cmd(command, opts \\ []) do
+    print_app? = Keyword.get(opts, :print_app, true)
+
+    Mix.Shell.cmd(command, opts, fn data ->
+      if print_app?, do: print_app()
+      IO.write(data)
+    end)
+  end
 end
diff --git a/lib/mix/lib/mix/shell/process.ex b/lib/mix/lib/mix/shell/process.ex
index 1194979156e..5492f4ddb30 100644
--- a/lib/mix/lib/mix/shell/process.ex
+++ b/lib/mix/lib/mix/shell/process.ex
@@ -1,36 +1,67 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Shell.Process do
   @moduledoc """
-  This is a Mix shell that uses the current process mailbox
-  for communication instead of IO.
+  Mix shell that uses the current process mailbox for communication.
+
+  This module provides a Mix shell implementation that uses
+  the current process mailbox for communication instead of IO.
 
-  When a developer calls `info("hello")`, the following
-  message will be sent to the current process:
+  As an example, when `Mix.shell().info("hello")` is called,
+  the following message will be sent to the calling process:
 
       {:mix_shell, :info, ["hello"]}
 
   This is mainly useful in tests, allowing us to assert
-  if given messages were received or not. Since we need
-  to guarantee a clean slate between tests, there
-  is also a `flush/1` function responsible for flushing all
-  `:mix_shell` related messages from the process inbox.
+  if given messages were received or not instead of performing
+  checks on some captured IO. There is also a `flush/1` function
+  responsible for flushing all `:mix_shell` related messages
+  from the process inbox.
+
+  ## Examples
+
+  The first step is to set the Mix shell to this module:
+
+      Mix.shell(Mix.Shell.Process)
+
+  Then if your Mix task calls:
+
+      Mix.shell().info("hello")
+
+  You should be able to receive it in your tests as long as
+  they run in the same process:
+
+      assert_receive {:mix_shell, :info, [msg]}
+      assert msg == "hello"
+
+  You can respond to prompts in tests as well:
+
+      send(self(), {:mix_shell_input, :prompt, "Pretty cool"})
+      Mix.shell().prompt("How cool was that?!")
+      #=> "Pretty cool"
+
   """
 
   @behaviour Mix.Shell
 
   @doc """
-  Flush all `:mix_shell` and `:mix_shell_input` messages from the current process.
+  Flushes all `:mix_shell` and `:mix_shell_input` messages from the current process.
+
   If a callback is given, it is invoked for each received message.
 
   ## Examples
 
-      flush &IO.inspect(&1)
+      flush(&IO.inspect/1)
 
   """
-  def flush(callback \\ fn(x) -> x end) do
+  def flush(callback \\ fn x -> x end) do
     receive do
       {:mix_shell, _, _} = message ->
         callback.(message)
         flush(callback)
+
       {:mix_shell_input, _, _} = message ->
         callback.(message)
         flush(callback)
@@ -40,78 +71,113 @@ defmodule Mix.Shell.Process do
   end
 
   @doc """
-  Prints the currently running application if it
+  Prints the current application if it
   was not printed yet.
   """
   def print_app do
-    if Mix.Shell.print_app? do
-      send self, {:mix_shell, :info, ["==> #{Mix.Project.config[:app]}"]}
+    if name = Mix.Shell.printable_app_name() do
+      send(message_target(), {:mix_shell, :info, ["==> #{name}"]})
     end
   end
 
-  @doc """
-  Executes the given command and forwards its messages to
-  the current process.
-  """
-  def cmd(command) do
-    Mix.Shell.cmd(command, fn(data) ->
-      send self, {:mix_shell, :run, [data]}
-    end)
-  end
-
   @doc """
   Forwards the message to the current process.
   """
   def info(message) do
-    print_app
-    send self, {:mix_shell, :info, [IO.ANSI.escape(message, false)]}
+    print_app()
+    send(message_target(), {:mix_shell, :info, [format(message)]})
+    :ok
   end
 
   @doc """
-  Forwards the message to the current process.
+  Forwards the error to the current process.
   """
   def error(message) do
-    print_app
-    send self, {:mix_shell, :error, [IO.ANSI.escape(message, false)]}
+    print_app()
+    send(message_target(), {:mix_shell, :error, [format(message)]})
+    :ok
+  end
+
+  defp format(message) do
+    message |> IO.ANSI.format(false) |> IO.iodata_to_binary()
   end
 
   @doc """
   Forwards the message to the current process.
+
   It also checks the inbox for an input message matching:
 
       {:mix_shell_input, :prompt, value}
 
   If one does not exist, it will abort since there was no shell
-  process inputs given. Value must be a string.
+  process inputs given. `value` must be a string.
+
+  ## Examples
+
+  The following will answer with `"Meg"` to the prompt
+  `"What's your name?"`:
+
+      # The response is sent before calling prompt/1 so that prompt/1 can read it
+      send(self(), {:mix_shell_input, :prompt, "Meg"})
+      Mix.shell().prompt("What's your name?")
+
   """
   def prompt(message) do
-    print_app
-    send self, {:mix_shell, :prompt, [IO.ANSI.escape(message, false)]}
+    print_app()
+    send(message_target(), {:mix_shell, :prompt, [message]})
 
     receive do
       {:mix_shell_input, :prompt, response} -> response
     after
-      0 -> raise "No shell process input given for prompt/1"
+      0 -> raise "no shell process input given for prompt/1"
     end
   end
 
   @doc """
   Forwards the message to the current process.
+
   It also checks the inbox for an input message matching:
 
       {:mix_shell_input, :yes?, value}
 
   If one does not exist, it will abort since there was no shell
-  process inputs given. Value must be `true` or `false`.
+  process inputs given. `value` must be `true` or `false`.
+
+  ## Example
+
+      # Send the response to self() first so that yes?/2 will be able to read it
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.shell().yes?("Are you sure you want to continue?")
+
   """
-  def yes?(message) do
-    print_app
-    send self, {:mix_shell, :yes?, [IO.ANSI.escape(message, false)]}
+  def yes?(message, _options \\ []) do
+    print_app()
+    send(message_target(), {:mix_shell, :yes?, [message]})
 
     receive do
       {:mix_shell_input, :yes?, response} -> response
     after
-      0 -> raise "No shell process input given for yes?/1"
+      0 -> raise "no shell process input given for yes?/2"
+    end
+  end
+
+  @doc """
+  Executes the given command and forwards its messages to
+  the current process.
+  """
+  def cmd(command, opts \\ []) do
+    print_app? = Keyword.get(opts, :print_app, true)
+
+    Mix.Shell.cmd(command, opts, fn data ->
+      if print_app?, do: print_app()
+      send(message_target(), {:mix_shell, :run, [data]})
+    end)
+  end
+
+  defp message_target() do
+    case Process.get(:"$callers") do
+      [parent | _] -> parent
+      _ -> self()
     end
   end
 end
diff --git a/lib/mix/lib/mix/shell/quiet.ex b/lib/mix/lib/mix/shell/quiet.ex
new file mode 100644
index 00000000000..22fec04943f
--- /dev/null
+++ b/lib/mix/lib/mix/shell/quiet.ex
@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Shell.Quiet do
+  @moduledoc """
+  This is Mix's default shell when the `MIX_QUIET` environment
+  variable is set.
+
+  It's just like `Mix.Shell.IO`, but prints far less.
+  """
+
+  @behaviour Mix.Shell
+
+  @doc """
+  Prints the current application if it
+  was not printed yet.
+  """
+  defdelegate print_app, to: Mix.Shell.IO
+
+  @doc """
+  Prints nothing to the shell.
+  """
+  def info(_message), do: :ok
+
+  @doc """
+  Prints the error to the shell followed by a newline.
+  """
+  defdelegate error(message), to: Mix.Shell.IO
+
+  @doc """
+  Prints a message and prompts the user for input.
+
+  Input will be consumed until Enter is pressed.
+  """
+  defdelegate prompt(message), to: Mix.Shell.IO
+
+  @doc """
+  Prints a message and asks the user to confirm if they
+  want to proceed. The user must type and submit one of
+  "y", "yes", "Y", "YES" or "Yes".
+
+  The user may also press Enter; this can be configured
+  to either accept or reject the prompt. The latter case
+  may be useful for a potentially dangerous operation that
+  should require explicit confirmation from the user.
+
+  ## Options
+
+    * `:default` - (:yes or :no) if `:yes` pressing Enter
+      accepts the prompt; if `:no` pressing Enter rejects
+      the prompt instead. Defaults to `:yes`.
+
+  """
+  @spec yes?(String.t(), Mix.Shell.IO.yes_opts()) :: boolean()
+  defdelegate yes?(message, options \\ []), to: Mix.Shell.IO
+
+  @doc """
+  Executes the given command quietly without outputting anything.
+  """
+  @spec cmd(String.t() | {String.t(), [String.t()]}, Mix.Shell.stream_cmd_opts()) ::
+          exit_status :: non_neg_integer
+  def cmd(command, opts \\ []) do
+    Mix.Shell.cmd(command, opts, fn data -> data end)
+  end
+end
diff --git a/lib/mix/lib/mix/state.ex b/lib/mix/lib/mix/state.ex
new file mode 100644
index 00000000000..74200f276fa
--- /dev/null
+++ b/lib/mix/lib/mix/state.ex
@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.State do
+  @moduledoc false
+  @name __MODULE__
+  @timeout :infinity
+
+  use GenServer
+
+  def start_link(_opts) do
+    GenServer.start_link(__MODULE__, :ok, name: @name)
+  end
+
+  def builtin_apps do
+    GenServer.call(@name, :builtin_apps, @timeout)
+  end
+
+  ## ETS state storage (mutable, not cleared in tests)
+
+  def fetch(key) do
+    case :ets.lookup(@name, key) do
+      [{^key, value}] -> {:ok, value}
+      [] -> :error
+    end
+  end
+
+  def get(key, default \\ nil) do
+    case :ets.lookup(@name, key) do
+      [{^key, value}] -> value
+      [] -> default
+    end
+  end
+
+  def put(key, value) do
+    :ets.insert(@name, {key, value})
+    :ok
+  end
+
+  def update(key, fun) do
+    :ets.insert(@name, {key, fun.(:ets.lookup_element(@name, key, 2))})
+    :ok
+  end
+
+  ## Persistent term cache (persistent, cleared in tests)
+
+  def read_cache(key) do
+    :persistent_term.get({__MODULE__, key}, nil)
+  end
+
+  def write_cache(key, value) do
+    :persistent_term.put({__MODULE__, key}, value)
+    value
+  end
+
+  def delete_cache(key) do
+    :persistent_term.erase({__MODULE__, key})
+  end
+
+  def clear_cache do
+    for {{__MODULE__, _} = key, _value} <- :persistent_term.get() do
+      :persistent_term.erase(key)
+    end
+  end
+
+  ## Callbacks
+
+  @impl true
+  def init(:ok) do
+    table = :ets.new(@name, [:public, :set, :named_table, read_concurrency: true])
+
+    :ets.insert(table,
+      shell: Mix.Shell.IO,
+      env: from_env("MIX_ENV", :dev),
+      target: from_env("MIX_TARGET", :host),
+      scm: [Mix.SCM.Git, Mix.SCM.Path]
+    )
+
+    state = %{
+      builtin_apps: :code.get_path()
+    }
+
+    {:ok, state}
+  end
+
+  defp from_env(varname, default) do
+    case System.get_env(varname) do
+      nil -> default
+      "" -> default
+      value -> String.to_atom(value)
+    end
+  end
+
+  @impl true
+  def handle_call(:builtin_apps, _from, %{builtin_apps: builtin_apps} = state) do
+    if is_map(builtin_apps) do
+      {:reply, builtin_apps, state}
+    else
+      builtin_apps =
+        for path <- builtin_apps,
+            app = app_from_code_path(path),
+            do: {app, path},
+            into: %{}
+
+      {:reply, builtin_apps, %{state | builtin_apps: builtin_apps}}
+    end
+  end
+
+  # ../elixir/ebin -> elixir
+  # ../ssl-9.6/ebin -> ssl
+  defp app_from_code_path(path) do
+    case path |> Enum.reverse() |> discard_ebin() |> collect_dir([]) do
+      [] -> nil
+      app -> List.to_atom(app)
+    end
+  end
+
+  defp discard_ebin(~c"nibe/" ++ path), do: path
+  defp discard_ebin(~c"nibe\\" ++ path), do: path
+  defp discard_ebin(_), do: []
+
+  defp collect_dir([?\\ | _], acc), do: acc
+  defp collect_dir([?/ | _], acc), do: acc
+  defp collect_dir([?- | path], _acc), do: collect_dir(path, [])
+  defp collect_dir([head | path], acc), do: collect_dir(path, [head | acc])
+  defp collect_dir([], acc), do: acc
+end
diff --git a/lib/mix/lib/mix/sync/lock.ex b/lib/mix/lib/mix/sync/lock.ex
new file mode 100644
index 00000000000..e588fafe33a
--- /dev/null
+++ b/lib/mix/lib/mix/sync/lock.ex
@@ -0,0 +1,475 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Mix.Sync.Lock do
+  @moduledoc false
+
+  # Lock implementation working across multiple OS processes.
+  #
+  # The lock is implemented using TCP sockets and hard links.
+  #
+  # A process holds the lock if it owns a TCP socket, whose port is
+  # written in the lock_0 file. We need to create such lock files
+  # atomically, so the process first writes its port to a port_P
+  # file and then attempts to create a hard link to it at lock_0.
+  #
+  # An inherent problem with lock files is that the lock owner may
+  # terminate abruptly, leaving a "stale" file. Other processes can
+  # detect a stale file by reading the port written in that file,
+  # trying to connect to that port and failing. In order for another
+  # process to link to the same path, the file needs to be replaced.
+  # However, we need to guarantee that only a single process can
+  # remove or replace the file, otherwise a concurrent process may
+  # end up removing a newly linked file.
+  #
+  # To address this problem we employ a chained locking procedure.
+  # Specifically, we attempt to link our port to lock_0, if that
+  # fails, we try to connect to the lock_0 port. If we manage to
+  # connect, it means the lock is taken, so we wait for it to close
+  # and start over. If we fail to connect, it means the lock is stale,
+  # so we want to replace it. In order to do that, we try to obtain
+  # lock_1. Again, we try to link and connect. Eventually, we should
+  # successfully link to lock_N. At that point we can clean up all
+  # the files, so we perform these steps:
+  #
+  #   * replace lock_0 content with port P
+  #   * remove all port_P files
+  #   * remove all lock_1+ files
+  #
+  # It is important to perform these steps in this order, to avoid
+  # race conditions. By moving to lock_0, we make sure that all new
+  # processes trying to lock will connect to our port. By removing
+  # all port_P files we make sure that currently paused processes
+  # that are about to link port_P at lock_N will fail to link, since
+  # the port_P file will no longer exist (once lock_N is removed).
+  #
+  # Finally, note that we do not remove the lock file in `unlock/1`.
+  # If we did that, another process could read it before removal,
+  # then it may connect and fail (once the socket is closed), in such
+  # case the process would assume the file is stale and needs to be
+  # replaced, therefore possibly replacing another process who
+  # successfully links at the empty spot. This means we effectively
+  # always leave a stale file, however, in order to shortcut the port
+  # check for future processes, we atomically replace the file content
+  # with port 0, to indicate the file is stale.
+  #
+  # The main caveat of using ephemeral TCP ports is that they are not
+  # unique. This creates a theoretical scenario where the lock holder
+  # terminates abruptly and leaves its port in lock_0, then the port
+  # is assigned to a unrelated process (unaware of the locking). To
+  # handle this scenario, when we connect to a lock_N port, we expect
+  # it to immediately send us `@probe_data`. If this does not happen
+  # within `@probe_timeout_ms`, we assume the port is taken by an
+  # unrelated process and the lock file is stale. Note that it is ok
+  # to use a long timeout, because this scenario is very unlikely.
+  # Theoretically, if an actual lock owner is not able to send the
+  # probe data within the timeout, the lock will fail, however with
+  # a high enough timeout, this should not be a problem in practice.
+
+  @loopback {127, 0, 0, 1}
+  @listen_opts [:binary, ip: @loopback, packet: :raw, nodelay: true, backlog: 128, active: false]
+  @connect_opts [:binary, packet: :raw, nodelay: true, active: false]
+  @probe_data "mixlock"
+  @probe_data_size byte_size(@probe_data)
+  @probe_timeout_ms 5_000
+
+  @typedoc """
+  Options for `with_lock/3`.
+  """
+  @type with_lock_opts :: [
+          on_taken: (String.t() -> any())
+        ]
+
+  @doc """
+  Acquires a lock identified by the given key.
+
+  This function blocks until the lock is acquired by this process,
+  and then executes `fun`, returning its return value.
+
+  This function can also be called if this process already has the
+  lock. In such case the function is executed immediately.
+
+  When the `MIX_OS_CONCURRENCY_LOCK` environment variable is set to
+  a falsy value, the lock is ignored and the function is executed
+  immediately.
+
+  ## Options
+
+    * `:on_taken` - a one-arity function called if the lock is held
+      by a different process. The operating system PID of that process
+      is given as the first argument (as a string). This function may
+      be called multiple times, if the lock owner changes, until it
+      is successfully acquired by this process.
+
+  """
+  @spec with_lock(iodata(), (-> term()), with_lock_opts()) :: term()
+  def with_lock(key, fun, opts \\ []) do
+    opts = Keyword.validate!(opts, [:on_taken])
+
+    hash = key |> :erlang.md5() |> Base.url_encode64(padding: false)
+    path = Path.join(base_path(), hash)
+
+    pdict_key = {__MODULE__, path}
+    has_lock? = Process.get(pdict_key, false)
+
+    if has_lock? or lock_disabled?() do
+      fun.()
+    else
+      lock = lock(path, opts[:on_taken])
+      Process.put(pdict_key, true)
+
+      try do
+        fun.()
+      after
+        # Unlocking will always close the socket, but it may raise,
+        # so we remove key from the dictionary first
+        Process.delete(pdict_key)
+        unlock(lock)
+      end
+    end
+  end
+
+  defp base_path do
+    # We include user in the dir to avoid permission conflicts across users
+    Path.join(System.tmp_dir!(), "mix_lock_user#{Mix.Utils.detect_user_id!()}")
+  end
+
+  defp lock_disabled?(), do: System.get_env("MIX_OS_CONCURRENCY_LOCK") in ~w(0 false)
+
+  defp lock(path, on_taken) do
+    File.mkdir_p!(path)
+
+    case listen() do
+      {:ok, socket, port} ->
+        spawn_link(fn -> accept_loop(socket) end)
+
+        try do
+          try_lock(path, socket, port, on_taken)
+        rescue
+          exception ->
+            # Close the socket to make sure we don't block the lock
+            :gen_tcp.close(socket)
+            reraise exception, __STACKTRACE__
+        end
+
+      {:error, reason} ->
+        Mix.raise("failed to acquire filesystem lock using TCP, reason: #{inspect(reason)}")
+    end
+  end
+
+  defp listen do
+    with {:ok, socket} <- :gen_tcp.listen(0, @listen_opts) do
+      case :inet.port(socket) do
+        {:ok, port} ->
+          {:ok, socket, port}
+
+        {:error, reason} ->
+          :gen_tcp.close(socket)
+          {:error, reason}
+      end
+    end
+  end
+
+  defp try_lock(path, socket, port, on_taken) do
+    port_path = Path.join(path, "port_#{port}")
+    os_pid = System.pid()
+
+    switch_file_create!(port_path, encode_lock_info(port, os_pid))
+
+    case grab_lock(path, port_path, 0) do
+      {:ok, 0} ->
+        # We grabbed lock_0, so all good
+        %{socket: socket, path: path}
+
+      {:ok, _n} ->
+        # We grabbed lock_1+, so we need to replace lock_0 and clean up
+        take_over(path, port, os_pid)
+        %{socket: socket, path: path}
+
+      {:taken, probe_socket, os_pid} ->
+        # Another process has the lock, wait for close and start over
+        if on_taken, do: on_taken.(os_pid)
+        await_close(probe_socket)
+        try_lock(path, socket, port, on_taken)
+
+      :invalidated ->
+        try_lock(path, socket, port, on_taken)
+    end
+  end
+
+  defp grab_lock(path, port_path, n) do
+    lock_path = Path.join(path, "lock_#{n}")
+
+    case File.ln(port_path, lock_path) do
+      :ok ->
+        {:ok, n}
+
+      {:error, :eexist} ->
+        case probe(lock_path) do
+          {:ok, probe_socket, os_pid} ->
+            {:taken, probe_socket, os_pid}
+
+          {:error, _reason} ->
+            grab_lock(path, port_path, n + 1)
+        end
+
+      {:error, :enoent} ->
+        :invalidated
+
+      {:error, reason} ->
+        Mix.raise("""
+        could not create hard link from #{port_path} to "#{lock_path}: #{:file.format_error(reason)}.
+
+        Hard link support is required for Mix compilation locking. If your system \
+        does not support hard links, set MIX_OS_CONCURRENCY_LOCK=0\
+        """)
+    end
+  end
+
+  defp accept_loop(listen_socket) do
+    case accept(listen_socket) do
+      {:ok, socket} ->
+        _ = :gen_tcp.send(socket, @probe_data)
+        accept_loop(listen_socket)
+
+      {:error, reason} when reason in [:closed, :einval] ->
+        :ok
+
+      {:error, reason} ->
+        raise RuntimeError,
+              "failed to accept connection in #{inspect(__MODULE__)}.receive_event/1, reason: #{inspect(reason)}"
+    end
+  end
+
+  defp probe(port_path) do
+    with {:ok, port, os_pid} <- fetch_probe_port(port_path),
+         {:ok, socket} <- connect(port),
+         {:ok, socket} <- await_probe_data(socket) do
+      {:ok, socket, os_pid}
+    end
+  end
+
+  defp fetch_probe_port(port_path) do
+    case switch_file_read(port_path) do
+      {:ok, data} ->
+        case decode_lock_info(data) do
+          {0, _os_pid} -> {:error, :ignore}
+          {port, os_pid} -> {:ok, port, os_pid}
+        end
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  defp connect(port) do
+    # On Windows connecting to an unbound port takes a few seconds to
+    # fail, so instead we shortcut the check by attempting a listen,
+    # which succeeds or fails immediately. Note that `reuseaddr` here
+    # ensures that if the listening socket closed recently, we can
+    # immediately reclaim the same port.
+    case :gen_tcp.listen(port, [reuseaddr: true] ++ @listen_opts) do
+      {:ok, socket} ->
+        :gen_tcp.close(socket)
+        # The port is free, so connecting would fail
+        {:error, :econnrefused}
+
+      {:error, _reason} ->
+        :gen_tcp.connect(@loopback, port, @connect_opts)
+    end
+  end
+
+  defp await_probe_data(socket) do
+    case recv(socket, @probe_data_size, @probe_timeout_ms) do
+      {:ok, @probe_data} ->
+        {:ok, socket}
+
+      {:ok, _data} ->
+        :gen_tcp.close(socket)
+        {:error, :unexpected_port_owner}
+
+      {:error, reason} ->
+        :gen_tcp.close(socket)
+        {:error, reason}
+    end
+  end
+
+  defp recv(socket, size, timeout \\ :infinity) do
+    # eintr is "Interrupted system call".
+    with {:error, :eintr} <- :gen_tcp.recv(socket, size, timeout) do
+      recv(socket, size, timeout)
+    end
+  end
+
+  defp accept(socket) do
+    with {:error, :eintr} <- :gen_tcp.accept(socket) do
+      accept(socket)
+    end
+  end
+
+  defp take_over(path, port, os_pid) do
+    # The operations here must happen in precise order, so if anything
+    # fails, we keep the files as is and the next process that grabs
+    # the lock will do the cleanup
+
+    lock_path = Path.join(path, "lock_0")
+
+    switch_file_replace!(lock_path, encode_lock_info(port, os_pid))
+
+    names = File.ls!(path)
+
+    # On Windows, removing a file may fail if the file is open, so we
+    # ignore failures just to be safe
+
+    for "port_" <> _ = name <- names do
+      _ = File.rm(Path.join(path, name))
+    end
+
+    for "lock_" <> _ = name <- names, name != "lock_0" do
+      _ = File.rm(Path.join(path, name))
+    end
+  end
+
+  defp await_close(socket) do
+    case recv(socket, 0) do
+      {:error, :closed} ->
+        :ok
+
+      {:error, _other} ->
+        # In case of an unexpected error, we close the socket ourselves
+        # to retry
+        :gen_tcp.close(socket)
+    end
+  end
+
+  defp unlock(lock) do
+    lock_path = Path.join(lock.path, "lock_0")
+
+    switch_file_replace!(lock_path, encode_lock_info(0, ""))
+  after
+    # Closing the socket will cause the accepting process to finish
+    # and all accepted sockets (tied to that process) will get closed
+    :gen_tcp.close(lock.socket)
+  end
+
+  defp encode_lock_info(port, os_pid) do
+    os_pid_size = byte_size(os_pid)
+
+    if os_pid_size > 32 do
+      Mix.raise("unexpectedly long PID: #{inspect(os_pid)}")
+    end
+
+    # The info needs to have fixed size, so we pad os_pid to maximum
+    # of 32 bytes (we expect it to be a few bytes).
+    padding_size = 32 - os_pid_size
+    padding = :binary.copy(<<0>>, padding_size)
+
+    <<
+      port::unsigned-integer-32,
+      padding_size::unsigned-integer-8,
+      padding::binary,
+      os_pid::binary
+    >>
+  end
+
+  defp decode_lock_info(data) do
+    <<
+      port::unsigned-integer-32,
+      padding_size::unsigned-integer-8,
+      _padding::binary-size(padding_size),
+      os_pid::binary
+    >> = data
+
+    {port, os_pid}
+  end
+
+  # We need a mechanism to atomically replace file content. Typically,
+  # we could use File.rename/2 to do that, however File.rename/2 is
+  # not atomic on Windows, if the destination exists [1].
+  #
+  # As an alternative approach we use a switch-file. The file content
+  # consists of 1 switch byte (either 0 or 1) and two content segments
+  # with fixed, equal lengths. The switch byte indicates which segment
+  # is currently active. To replace the file content, we write to the
+  # non-active segment and call :file.sync/1 to ensure the segment is
+  # persisted, then we toggle the switch byte. While we cannot write
+  # multiple bytes atomically (since they may reside in multiple disk
+  # sectors), if we toggle only a single byte, there is no intermediate
+  # invalid state, which gives us the atomic replace we need.
+  #
+  # Note that file content can be replaced only by a single process
+  # at a time.
+  #
+  # [1]: https://github.com/elixir-lang/elixir/pull/14793#issuecomment-3338665065
+  defp switch_file_create!(path, content) do
+    data = <<0, content::binary, content::binary>>
+    File.write!(path, data, [:raw])
+  end
+
+  defp switch_file_replace!(path, new_content) do
+    file = File.open!(path, [:read, :write, :binary, :raw])
+
+    content_size = byte_size(new_content)
+
+    <<switch_byte>> = read_bytes!(file, 1)
+
+    try do
+      inactive_content_position =
+        case switch_byte do
+          0 -> 1 + content_size
+          1 -> 1
+        end
+
+      # Write new data
+      file_pwrite_sync!(file, inactive_content_position, new_content)
+
+      # Toggle switch byte - it's a single byte so the content changes
+      # atomically
+      file_pwrite_sync!(file, 0, <<1 - switch_byte>>)
+    after
+      File.close(file)
+    end
+  end
+
+  defp switch_file_read(path) do
+    with {:ok, data} <- File.read(path) do
+      <<switch_byte, rest::binary>> = data
+      content_size = rest |> byte_size() |> div(2)
+      <<content1::binary-size(^content_size), content2::binary-size(^content_size)>> = rest
+
+      case switch_byte do
+        0 -> {:ok, content1}
+        1 -> {:ok, content2}
+      end
+    end
+  end
+
+  defp read_bytes!(file, bytes) do
+    case :file.read(file, bytes) do
+      {:ok, data} ->
+        data
+
+      :eof ->
+        raise "unexpected EOF of file when reading file"
+
+      {:error, reason} ->
+        raise File.Error, reason: reason, action: "read file"
+    end
+  end
+
+  defp file_pwrite_sync!(file, position, bytes) do
+    case :file.pwrite(file, position, bytes) do
+      :ok ->
+        case :file.sync(file) do
+          :ok ->
+            :ok
+
+          {:error, reason} ->
+            raise File.Error, reason: reason, action: "sync file"
+        end
+
+      {:error, reason} ->
+        raise File.Error, reason: reason, action: "write to file at position"
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/sync/pubsub.ex b/lib/mix/lib/mix/sync/pubsub.ex
new file mode 100644
index 00000000000..d8133aa6713
--- /dev/null
+++ b/lib/mix/lib/mix/sync/pubsub.ex
@@ -0,0 +1,296 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Mix.Sync.PubSub do
+  @moduledoc false
+
+  # Pub/sub implementation working across multiple OS processes.
+  #
+  # The pub/sub is implemented using TCP sockets.
+  #
+  # Every subscriber opens a TCP socket and creates a port_P file.
+  # A publisher lists the directory, connects to each port and sends
+  # the message payload. When subscriber processes terminate, the
+  # files are left behind, so whenever a publisher fails to connect
+  # to one of the ports, it removes the corresponding file.
+  #
+  # We use a single socket for all the subscriptions. We create the
+  # socket lazily on the first subscription. Since the socket is
+  # shared, we include the hashed key in the broadcast payload, so
+  # that we can determine which subscribers to notify.
+
+  use GenServer
+
+  @opaque subscription :: %{socket: :gen_tcp.socket()}
+
+  @loopback {127, 0, 0, 1}
+  @listen_opts [:binary, ip: @loopback, packet: :raw, nodelay: true, backlog: 128, active: false]
+  @connect_opts [:binary, packet: :raw, nodelay: true, active: false]
+
+  @tag_data "mixpubsub"
+  @tag_data_size byte_size(@tag_data)
+
+  @name __MODULE__
+
+  @doc false
+  def start_link(_opts) do
+    GenServer.start_link(__MODULE__, {}, name: @name)
+  end
+
+  @doc """
+  Subscribes the caller to messages for `key`.
+
+  The messages are delivered to the caller's message queue.
+  """
+  @spec subscribe(String.t()) :: :ok | {:error, String.t()}
+  def subscribe(key) do
+    GenServer.call(@name, {:subscribe, self(), key}, :infinity)
+  end
+
+  @doc """
+  Sends `message` to all processes subscribed to `key`.
+  """
+  @spec broadcast(String.t(), term() | (-> term())) :: :ok
+  def broadcast(key, message) do
+    hash = hash(key)
+    path = path(hash)
+
+    case File.ls(path) do
+      {:ok, []} ->
+        :ok
+
+      {:ok, names} ->
+        message =
+          case message do
+            lazy_message when is_function(lazy_message, 0) -> lazy_message.()
+            message -> message
+          end
+
+        binary = :erlang.term_to_binary(message)
+
+        for "port_" <> port = name <- names do
+          port = String.to_integer(port)
+          port_path = Path.join(path, name)
+          _ = send_message(port_path, port, hash, binary)
+        end
+
+        :ok
+
+      {:error, :enoent} ->
+        :ok
+
+      {:error, reason} ->
+        raise File.Error, reason: reason, action: "list directory", path: path
+    end
+  end
+
+  defp send_message(port_path, port, hash, binary) do
+    # On Windows connecting to an unbound port takes a few seconds to
+    # fail, so instead we shortcut the check by attempting a listen,
+    # which succeeds or fails immediately. Note that `reuseaddr` here
+    # ensures that if the listening socket closed recently, we can
+    # immediately reclaim the same port.
+    #
+    # Also, if we manage to bind, it means the port is free and the
+    # subscription is no longer active, so we remove the file. It is
+    # important we remove the file while holding onto the port, so
+    # it is not claimed by a new subscriber as we remove the file.
+    #
+    # Finally, if we fail to connect, we could attempt to bind again
+    # and remove the file, but we just leave it up to the next send
+    # attempt.
+
+    case :gen_tcp.listen(port, [reuseaddr: true] ++ @listen_opts) do
+      {:ok, socket} ->
+        _ = File.rm(port_path)
+        :gen_tcp.close(socket)
+        {:error, :econnrefused}
+
+      {:error, _reason} ->
+        with {:ok, socket} <- :gen_tcp.connect(@loopback, port, @connect_opts) do
+          size = byte_size(binary)
+
+          result =
+            :gen_tcp.send(
+              socket,
+              <<@tag_data, hash::binary, size::unsigned-integer-64, binary::binary>>
+            )
+
+          :gen_tcp.shutdown(socket, :read_write)
+          :gen_tcp.close(socket)
+
+          result
+        end
+    end
+  end
+
+  @impl true
+  def init({}) do
+    state = %{port: nil, hash_to_pids: %{}}
+    {:ok, state}
+  end
+
+  @impl true
+  def handle_call({:subscribe, pid, key}, _from, state) do
+    Process.monitor(pid)
+
+    case ensure_socket(state) do
+      {:ok, state} ->
+        hash = hash(key)
+        path = path(hash)
+
+        create_subscription_file(path, state.port)
+
+        state =
+          update_in(state.hash_to_pids, fn
+            %{^hash => pids} = hash_to_pids ->
+              %{hash_to_pids | hash => MapSet.put(pids, pid)}
+
+            %{} = hash_to_pids ->
+              Map.put(hash_to_pids, hash, MapSet.new([pid]))
+          end)
+
+        {:reply, :ok, state}
+
+      {:error, error} ->
+        {:reply, {:error, error}, state}
+    end
+  end
+
+  @impl true
+  def handle_info({:message, hash, message}, state) do
+    if pids = state.hash_to_pids[hash] do
+      for pid <- pids do
+        send(pid, message)
+      end
+    end
+
+    {:noreply, state}
+  end
+
+  def handle_info({:DOWN, _, :process, pid, _}, state) do
+    hash_to_pids =
+      for {hash, pids} <- state.hash_to_pids,
+          pids = remove_pid(pids, pid, hash, state.port),
+          into: %{},
+          do: {hash, pids}
+
+    {:noreply, %{state | hash_to_pids: hash_to_pids}}
+  end
+
+  defp remove_pid(pids, pid, hash, port) do
+    pids = MapSet.delete(pids, pid)
+
+    if Enum.empty?(pids) do
+      path = path(hash)
+      remove_subscription_file(path, port)
+      nil
+    else
+      pids
+    end
+  end
+
+  defp ensure_socket(%{port: nil} = state) do
+    case listen() do
+      {:ok, socket, port} ->
+        parent = self()
+        spawn_link(fn -> receive_message_loop(socket, parent) end)
+        {:ok, %{state | port: port}}
+
+      {:error, reason} ->
+        {:error, "failed to subscribe to Mix events using TCP, reason: #{inspect(reason)}"}
+    end
+  end
+
+  defp ensure_socket(state), do: {:ok, state}
+
+  defp listen do
+    with {:ok, socket} <- :gen_tcp.listen(0, @listen_opts) do
+      case :inet.port(socket) do
+        {:ok, port} ->
+          {:ok, socket, port}
+
+        {:error, reason} ->
+          :gen_tcp.close(socket)
+          {:error, reason}
+      end
+    end
+  end
+
+  defp create_subscription_file(path, port) do
+    File.mkdir_p!(path)
+    port_path = Path.join(path, "port_#{port}")
+    File.touch!(port_path)
+  end
+
+  defp remove_subscription_file(path, port) do
+    port_path = Path.join(path, "port_#{port}")
+    _ = File.rm(port_path)
+  end
+
+  defp receive_message_loop(socket, parent) do
+    {hash, message} = receive_message(socket)
+    send(parent, {:message, hash, message})
+    receive_message_loop(socket, parent)
+  end
+
+  defp receive_message(listen_socket) do
+    # Note that receive failures may happen if the sender terminates
+    # abruptly. We ignore such attempts and wait for the next message.
+    #
+    # Also, the first recv has a timeout in case an unrelated process
+    # connects to the port and doesn't send any data.
+
+    case accept(listen_socket) do
+      {:ok, socket} ->
+        with {:ok, <<@tag_data, hash::binary-size(16), size::unsigned-integer-64>>} <-
+               recv(socket, @tag_data_size + 16 + 8, 1_000),
+             {:ok, binary} <- recv(socket, size),
+             {:ok, data} <- decode_data(binary) do
+          :gen_tcp.close(socket)
+          {hash, data}
+        else
+          _other ->
+            :gen_tcp.close(socket)
+            receive_message(listen_socket)
+        end
+
+      {:error, reason} ->
+        raise RuntimeError,
+              "failed to accept connection in #{inspect(__MODULE__)}.receive_message/1, reason: #{inspect(reason)}"
+    end
+  end
+
+  defp decode_data(binary) do
+    try do
+      {:ok, :erlang.binary_to_term(binary)}
+    rescue
+      _error -> :error
+    end
+  end
+
+  defp hash(key), do: :erlang.md5(key)
+
+  defp path(hash) do
+    hash = Base.url_encode64(hash, padding: false)
+    Path.join(base_path(), hash)
+  end
+
+  defp base_path do
+    # We include user in the dir to avoid permission conflicts across users
+    Path.join(System.tmp_dir!(), "mix_pubsub_user#{Mix.Utils.detect_user_id!()}")
+  end
+
+  defp recv(socket, size, timeout \\ :infinity) do
+    # eintr is "Interrupted system call".
+    with {:error, :eintr} <- :gen_tcp.recv(socket, size, timeout) do
+      recv(socket, size)
+    end
+  end
+
+  defp accept(socket) do
+    with {:error, :eintr} <- :gen_tcp.accept(socket) do
+      accept(socket)
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/task.compiler.ex b/lib/mix/lib/mix/task.compiler.ex
new file mode 100644
index 00000000000..fd3154af684
--- /dev/null
+++ b/lib/mix/lib/mix/task.compiler.ex
@@ -0,0 +1,387 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Task.Compiler do
+  @moduledoc """
+  This module defines the behaviour for a Mix task that does compilation.
+
+  A Mix compiler task can be defined by simply using `Mix.Task.Compiler`
+  in a module whose name starts with `Mix.Tasks.Compile.` and defining
+  the [`run/1`](`c:run/1`) function:
+
+      defmodule Mix.Tasks.Compile.MyLanguage do
+        use Mix.Task.Compiler
+
+        def run(_args) do
+          :ok
+        end
+      end
+
+  The [`run/1`](`c:run/1`) function returns an atom indicating the status of the
+  compilation, and optionally can also return a list of "diagnostics"
+  such as warnings or compilation errors. Doing this enables code
+  editors to display issues inline without having to analyze the
+  command-line output.
+
+  If the compiler uses manifest files to track stale sources, it should
+  define `manifests/0`, and if it writes any output to disk it should
+  also define `clean/0`.
+
+  A compiler supports the same attributes for configuration and
+  documentation as a regular Mix task. See `Mix.Task` for more information.
+
+  ## Listening to compilation
+
+  When running a long-lived Mix task you may want to detect compilations
+  triggered in a separate OS process, for example, to reload the modules.
+  In order to do that, the Mix project may configure listeners:
+
+      def project do
+        [
+          ...,
+          listeners: [SomeDep.MixListener]
+        ]
+      end
+
+  or
+
+      config :mix, :listeners, [SomeDep.MixListener]
+
+  Each entry in the list must be either `t:Supervisor.module_spec/0` or
+  `t:Supervisor.child_spec/0`. Additionally, the listener module must
+  be defined in a dependency of the project, not the project itself.
+
+  The listener process receives the following messages:
+
+    * `{:modules_compiled, info}` - delivered after a set of modules is
+      compiled. `info` is a map with the following keys:
+
+        * `:app` - app which modules have been compiled.
+
+        * `:scm` - the SCM module of the compiled project.
+
+        * `:modules_diff` - information about the compiled modules. The
+          value is a map with keys: `:added`, `:changed`, `:removed`,
+          where each holds a list of modules. There is also a `:timestamp`
+          key, which matches the modification time of all the compiled
+          module files.
+
+        * `:os_pid` - the operating system PID of the process that run
+          the compilation. The value is a string and it can be compared
+          with `System.pid/0` to determine if compilation happened in
+          the same OS process as the listener.
+
+    * `{:dep_compiled, info}` - delivered after a dependency is compiled.
+      `info` is a map with the following keys:
+
+        * `:app` - the dependency app.
+
+        * `:scm` - the SCM module of the dependency.
+
+        * `:manager` - the dependency project management, possible values:
+          `:rebar3`, `:mix`, `:make`, `nil`.
+
+        * `:os_pid` - the operating system PID of the process that run
+          the compilation. The value is a string and it can be compared
+          with `System.pid/0` to determine if compilation happened in
+          the same OS process as the listener.
+
+  New messages may be added in the future, so the process should have
+  a catch-all clause and ignore other messages.
+
+  Note that the listener starts before any of the project apps are started.
+  """
+
+  defmodule Diagnostic do
+    @moduledoc """
+    Diagnostic information such as a warning or compilation error.
+
+    The file and position relate to where the diagnostic should be shown.
+    If there is a file and position, then the diagnostic is precise
+    and you can use the given file and position for generating snippets,
+    IDEs annotations, and so on. An optional span is available with
+    the line and column the diagnostic ends.
+
+    Otherwise, a stacktrace may be given, which you can place your own
+    heuristics to provide better reporting.
+
+    The source field points to the source file the compiler tracked
+    the error to. For example, a file `lib/foo.ex` may embed `.eex`
+    templates from `lib/foo/bar.eex`. A syntax error on the EEx template
+    will point to file `lib/foo/bar.eex` but the source is `lib/foo.ex`.
+    """
+
+    @type t :: %__MODULE__{
+            file: Path.t() | nil,
+            source: Path.t() | nil,
+            severity: severity,
+            message: IO.chardata(),
+            position: Code.position(),
+            compiler_name: String.t(),
+            details: term(),
+            stacktrace: Exception.stacktrace(),
+            span: {line :: pos_integer(), column :: pos_integer()} | nil
+          }
+
+    @typedoc """
+    Severity of a diagnostic:
+
+      * `:error` - An issue that caused compilation to fail
+
+      * `:warning` - An issue that did not cause failure but suggests the
+        programmer may have made a mistake
+
+      * `:hint` - A suggestion for style or good practices that is not as
+        severe as a warning
+
+      * `:information` - Any other information relevant to compilation that
+        does not fit into the above categories
+
+    """
+    @type severity :: :error | :warning | :information | :hint
+
+    @enforce_keys [:file, :severity, :message, :position, :compiler_name]
+    defstruct [
+      :file,
+      :source,
+      :severity,
+      :message,
+      :position,
+      :compiler_name,
+      span: nil,
+      details: nil,
+      stacktrace: []
+    ]
+  end
+
+  @type status :: :ok | :noop | :error
+
+  @doc """
+  Receives command-line arguments and performs compilation. If it
+  produces errors, warnings, or any other diagnostic information,
+  it should return a tuple with the status and a list of diagnostics.
+  """
+  @callback run([binary]) :: status | {status, [Diagnostic.t()]}
+
+  @doc """
+  Lists manifest files for the compiler.
+  """
+  @callback manifests() :: [Path.t()]
+
+  @doc """
+  Lists persisted diagnostics from the compiler.
+  """
+  @callback diagnostics() :: [Diagnostic.t()]
+
+  @doc """
+  Removes build artifacts and manifests.
+  """
+  @callback clean() :: any
+
+  @optional_callbacks clean: 0, manifests: 0, diagnostics: 0
+
+  @doc """
+  Adds a callback that runs after a given compiler.
+
+  The callback is invoked after the compiler runs and
+  it receives a tuple with current status and the list
+  of diagnostic. It must return the updated status and
+  diagnostics.
+
+  If the given compiler does not run (for instance,
+  because an earlier compiler in the stack has aborted),
+  the callback will not be executed.
+  """
+  @doc since: "1.10.0"
+  @spec after_compiler(atom, ({status, [Diagnostic.t()]} -> {status, [Diagnostic.t()]})) :: :ok
+  def after_compiler(name, fun) when is_atom(name) and is_function(fun, 1) do
+    Mix.ProjectStack.prepend_after_compiler(name, fun)
+  end
+
+  @doc false
+  defmacro __using__(_opts) do
+    quote do
+      Enum.each(
+        Mix.Task.supported_attributes(),
+        &Module.register_attribute(__MODULE__, &1, persist: true)
+      )
+
+      @behaviour Mix.Task.Compiler
+    end
+  end
+
+  @doc """
+  Returns all compilers for the current project.
+  """
+  def compilers(config \\ Mix.Project.config()) do
+    compilers = config[:compilers] || Mix.compilers()
+
+    if :xref in compilers do
+      IO.warn(
+        "the :xref compiler is deprecated, please remove it from your mix.exs :compilers options"
+      )
+
+      List.delete(compilers, :xref)
+    else
+      compilers
+    end
+    |> maybe_prepend(:leex)
+    |> maybe_prepend(:yecc)
+  end
+
+  defp maybe_prepend(compilers, compiler) do
+    if compiler in compilers do
+      compilers
+    else
+      [compiler | compilers]
+    end
+  end
+
+  @doc """
+  Lists manifest files for all compilers in the current project.
+  """
+  def manifests(config \\ Mix.Project.config()) do
+    Enum.flat_map(compilers(config), fn compiler ->
+      module = Mix.Task.get("compile.#{compiler}")
+
+      if module && function_exported?(module, :manifests, 0) do
+        module.manifests()
+      else
+        []
+      end
+    end)
+  end
+
+  @doc """
+  Lists persisted diagnostics from all compilers in the current project.
+  """
+  def diagnostics(config \\ Mix.Project.config()) do
+    Enum.flat_map(compilers(config), fn compiler ->
+      module = Mix.Task.get("compile.#{compiler}")
+
+      if module && function_exported?(module, :diagnostics, 0) do
+        module.diagnostics()
+      else
+        []
+      end
+    end)
+  end
+
+  @doc """
+  Runs the given list of compilers with the given arguments.
+
+  It returns a `{status, diagnostics}` tuple. If a compiler
+  errors, following compilers do not run.
+  """
+  @doc since: "1.19.0"
+  def run(compilers, args) do
+    run(compilers, args, :noop, [])
+  end
+
+  defp run([], _, status, diagnostics) do
+    {status, diagnostics}
+  end
+
+  defp run([compiler | rest], args, status, diagnostics) do
+    {new_status, new_diagnostics} = run_compiler(compiler, args)
+    diagnostics = diagnostics ++ new_diagnostics
+
+    case new_status do
+      :error -> {:error, diagnostics}
+      :ok -> run(rest, args, :ok, diagnostics)
+      :noop -> run(rest, args, status, diagnostics)
+    end
+  end
+
+  defp run_compiler(compiler, args) do
+    args_maybe_force = maybe_prepend_force(args, compiler)
+    result = normalize(Mix.Task.run("compile.#{compiler}", args_maybe_force), compiler)
+    Enum.reduce(Mix.ProjectStack.pop_after_compiler(compiler), result, & &1.(&2))
+  end
+
+  defp maybe_prepend_force(args, compiler) do
+    args
+    |> Enum.any?(fn
+      "--force-" <> rest -> rest == compiler |> to_string() |> String.replace("_", "-")
+      _ -> false
+    end)
+    |> if do
+      ["--force" | args]
+    else
+      args
+    end
+  end
+
+  # Normalize the compiler result to a diagnostic tuple
+  defp normalize(result, name) do
+    case result do
+      {status, diagnostics} when status in [:ok, :noop, :error] and is_list(diagnostics) ->
+        {status, diagnostics}
+
+      # ok/noop can come from tasks that have already run
+      _ when result in [:ok, :noop] ->
+        {result, []}
+
+      _ ->
+        # TODO: Convert this to an error on v2.0
+        Mix.shell().error(
+          "warning: Mix compiler #{inspect(name)} was supposed to return " <>
+            "{:ok | :noop | :error, [diagnostic]} but it returned #{inspect(result)}"
+        )
+
+        {:noop, []}
+    end
+  end
+
+  @doc false
+  # Broadcast an event about a finished compilation of a set of modules.
+  @spec notify_modules_compiled((-> modules_diff)) :: :ok
+        when modules_diff: %{
+               added: [module],
+               changed: [module],
+               removed: [module],
+               timestamp: integer
+             }
+  def notify_modules_compiled(lazy_modules_diff) when is_function(lazy_modules_diff, 0) do
+    config = Mix.Project.config()
+    build_path = Mix.Project.build_path(config)
+
+    lazy_message = fn ->
+      info = %{
+        app: config[:app],
+        scm: config[:build_scm],
+        modules_diff: lazy_modules_diff.(),
+        os_pid: System.pid()
+      }
+
+      {:modules_compiled, info}
+    end
+
+    Mix.Sync.PubSub.broadcast(build_path, lazy_message)
+  end
+
+  @doc """
+  Reenables given compilers so they can be executed again down the stack.
+
+  If an umbrella project reenables compilers, they are re-enabled for all
+  child projects.
+
+  Default is `:all` which effectively means all the compilers returned by
+  `Mix.Task.Compiler.compilers()` are to be reenabled. This task always
+  re-enables `"compile"` and `"compile.all"`.
+  """
+  @doc since: "1.19.0"
+  @spec reenable(compilers) :: :ok when compilers: :all | [atom()]
+  def reenable(compilers \\ :all) do
+    compilers =
+      case compilers do
+        :all -> Mix.Task.Compiler.compilers()
+        list when is_list(list) -> list
+      end
+
+    Mix.Task.reenable("compile")
+    Mix.Task.reenable("compile.all")
+    Enum.each(compilers, &Mix.Task.reenable("compile.#{&1}"))
+  end
+end
diff --git a/lib/mix/lib/mix/task.ex b/lib/mix/lib/mix/task.ex
index e5eb304dcc9..c0ca782fdd3 100644
--- a/lib/mix/lib/mix/task.ex
+++ b/lib/mix/lib/mix/task.ex
@@ -1,112 +1,234 @@
-defmodule Mix.Task do
-  use Behaviour
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
+defmodule Mix.Task do
   @moduledoc """
-  A simple module that provides conveniences for creating,
-  loading and manipulating tasks.
+  Provides conveniences for creating, loading, and manipulating Mix tasks.
+
+  To create a new Mix task, you'll need to:
+
+    1. Create a module whose name begins with `Mix.Tasks.` (for example,
+       `Mix.Tasks.MyTask`).
+    2. Call `use Mix.Task` in that module.
+    3. Implement the `Mix.Task` behaviour in that module (that is,
+       implement the `c:run/1` callback).
+
+  Typically, task modules live inside the `lib/mix/tasks/` directory,
+  and their file names use dot separators instead of underscores
+  (for example, `deps.clean.ex`) - although ultimately the file name is not
+  relevant.
+
+  For example:
 
-  A Mix task can be defined by simply using `Mix.Task`
-  in a module starting with `Mix.Tasks.` and defining
-  the `run/1` function:
+      # lib/mix/tasks/echo.ex
+      defmodule Mix.Tasks.Echo do
+        @moduledoc "Printed when the user requests `mix help echo`"
+        @shortdoc "Echoes arguments"
 
-      defmodule Mix.Tasks.Hello do
         use Mix.Task
 
-        def run(_) do
-          IO.puts "hello"
+        @impl Mix.Task
+        def run(args) do
+          Mix.shell().info(Enum.join(args, " "))
         end
       end
 
-  The `run/1` function will receive all arguments passed
-  to the command line.
+  The command name will correspond to the portion of the module
+  name following `Mix.Tasks.`. For example, a module name of
+  `Mix.Tasks.Deps.Clean` corresponds to a task name of `deps.clean`.
+
+  The `run/1` function will receive a list of all command line
+  arguments passed, according to the user's terminal.
+
+  For example, if the `args` in the above `echo` task were
+  inspected, you might see something like this:
+
+      $ mix echo 'A and B' C --test
+      ["A and B", "C", "--test"]
+
+  > #### `use Mix.Task` {: .info}
+  >
+  > When you `use Mix.Task`, the `Mix.Task` module will
+  > set `@behaviour Mix.Task` and define default values
+  > for the module attributes documented in the section
+  > below.
+
+  ## Module attributes
+
+  You can control some behavior of your Mix task by setting module
+  attributes. This section documents the available attributes.
+
+  ### `@shortdoc`
+
+  Define the `@shortdoc` attribute if you wish to make the task
+  publicly visible on `mix help`. Omit this attribute if you do
+  not want your task to be listed via `mix help`.
+
+  ### `@moduledoc`
+
+  The `@moduledoc` attribute may override `@shortdoc`. The task
+  will not appear in `mix help` if documentation for the entire
+  module is hidden with `@moduledoc false`.
+
+  ### `@requirements`
+
+  If a task has *requirements*, they can be listed using the
+  `@requirements` attribute. Requirements are other Mix
+  tasks that this task requires to have run. For example:
+
+      @requirements ["app.config"]
+
+  A task will typically depend on one of the following tasks:
+
+    * ["loadpaths"](`Mix.Tasks.Loadpaths`) - this ensures
+      dependencies are available and compiled. If you are publishing
+      a task as part of a library to be used by others, and your
+      task does not need to interact with the user code in any way,
+      this is the recommended requirement
+
+    * ["app.config"](`Mix.Tasks.App.Config`) - additionally compiles
+      and load the runtime configuration for the current project. If
+      you are creating a task to be used within your application or
+      as part of a library, which must invoke or interact with the
+      user code, this is the minimum recommended requirement
 
-  ## Attributes
+    * ["app.start"](`Mix.Tasks.App.Start`) - additionally starts the
+      supervision tree of the current project and its dependencies
 
-  There are a couple attributes available in Mix tasks to
-  configure them in Mix:
+  ### `@recursive`
 
-    * `@shortdoc`  - makes the task public with a short description that appears
-                     on `mix help`
-    * `@recursive` - run the task recursively in umbrella projects
+  Set `@recursive true` if you want the task to run
+  on each umbrella child in an umbrella project.
 
+  ### `@preferred_cli_env`
+
+  Sets the preferred Mix environment for this task. For example,
+  if your task is meant to be used for testing, you could set
+
+      @preferred_cli_env :test
+
+  ## Documentation
+
+  Users can read the documentation for public Mix tasks by
+  running `mix help my_task`. The documentation that will be
+  shown is the `@moduledoc` of the task's module.
   """
 
+  @typedoc """
+  The name of a task.
+
+  For example, `"deps.clean"` or `:"deps.clean"`.
+  """
+  @type task_name :: String.t() | atom
+
+  @typedoc """
+  The module that implements a Mix task.
+
+  For example, `Mix.Tasks.MyTask`.
+  """
+  @type task_module :: atom
+
   @doc """
   A task needs to implement `run` which receives
   a list of command line args.
   """
-  defcallback run([binary]) :: any
+  @callback run(command_line_args :: [binary]) :: any
 
   @doc false
   defmacro __using__(_opts) do
     quote do
-      Enum.each [:shortdoc, :recursive],
+      Enum.each(
+        Mix.Task.supported_attributes(),
         &Module.register_attribute(__MODULE__, &1, persist: true)
+      )
 
       @behaviour Mix.Task
     end
   end
 
+  @doc false
+  def supported_attributes do
+    [:shortdoc, :recursive, :preferred_cli_env, :requirements]
+  end
+
   @doc """
   Loads all tasks in all code paths.
   """
-  def load_all, do: load_tasks(:code.get_path)
+  @spec load_all() :: [task_module]
+  def load_all, do: load_tasks(:code.get_path())
 
   @doc """
   Loads all tasks in the given `paths`.
   """
-  def load_tasks(paths) do
-    Enum.reduce(paths, [], fn(path, matches) ->
-      {:ok, files} = :erl_prim_loader.list_dir(path |> to_char_list)
-      Enum.reduce(files, matches, &match_tasks/2)
-    end)
+  @spec load_tasks([List.Chars.t()]) :: [task_module]
+  def load_tasks(dirs) do
+    # We may get duplicate modules because we look through the
+    # entire load path so make sure we only return unique modules.
+    for dir <- dirs,
+        file <- safe_list_dir(to_charlist(dir)),
+        mod = task_from_path(file),
+        uniq: true,
+        do: mod
+  end
+
+  defp safe_list_dir(path) do
+    case File.ls(path) do
+      {:ok, paths} -> paths
+      {:error, _} -> []
+    end
   end
 
-  @re_pattern Regex.re_pattern(~r/Elixir\.Mix\.Tasks\..*\.beam$/)
+  @prefix_size byte_size("Elixir.Mix.Tasks.")
+  @suffix_size byte_size(".beam")
+
+  defp task_from_path(filename) do
+    base = Path.basename(filename)
+    part = byte_size(base) - @prefix_size - @suffix_size
+
+    case base do
+      <<"Elixir.Mix.Tasks.", rest::binary-size(^part), ".beam">> ->
+        mod = :"Elixir.Mix.Tasks.#{rest}"
+        ensure_task?(mod) && mod
 
-  defp match_tasks(filename, modules) do
-    if :re.run(filename, @re_pattern, [capture: :none]) == :match do
-      mod = :filename.rootname(filename, '.beam') |> List.to_atom
-      if Code.ensure_loaded?(mod), do: [mod | modules], else: modules
-    else
-      modules
+      _ ->
+        nil
     end
   end
 
   @doc """
-  Returns all loaded tasks.
+  Returns all loaded task modules.
 
   Modules that are not yet loaded won't show up.
   Check `load_all/0` if you want to preload all tasks.
   """
+  @spec all_modules() :: [task_module]
   def all_modules do
-    Enum.reduce :code.all_loaded, [], fn({module, _}, acc) ->
-      case Atom.to_char_list(module) do
-        'Elixir.Mix.Tasks.' ++ _ ->
-          if is_task?(module), do: [module|acc], else: acc
-        _ ->
-          acc
-      end
-    end
+    for {module, _} <- :code.all_loaded(), task?(module), do: module
   end
 
   @doc """
   Gets the moduledoc for the given task `module`.
+
   Returns the moduledoc or `nil`.
   """
+  @spec moduledoc(task_module) :: String.t() | nil | false
   def moduledoc(module) when is_atom(module) do
-    case Code.get_docs(module, :moduledoc) do
-      {_line, moduledoc} -> moduledoc
-      nil -> nil
+    case Code.fetch_docs(module) do
+      {:docs_v1, _, _, _, %{"en" => moduledoc}, _, _} -> moduledoc
+      {:docs_v1, _, _, _, :none, _, _} -> nil
+      _ -> false
     end
   end
 
   @doc """
   Gets the shortdoc for the given task `module`.
+
   Returns the shortdoc or `nil`.
   """
+  @spec shortdoc(task_module) :: String.t() | nil
   def shortdoc(module) when is_atom(module) do
-    case List.keyfind module.__info__(:attributes), :shortdoc, 0 do
+    case List.keyfind(module.__info__(:attributes), :shortdoc, 0) do
       {:shortdoc, [shortdoc]} -> shortdoc
       _ -> nil
     end
@@ -114,35 +236,99 @@ defmodule Mix.Task do
 
   @doc """
   Checks if the task should be run recursively for all sub-apps in
-  umbrella projects. Returns `true`, `false` or `:both`.
+  umbrella projects.
+
+  Returns `true` or `false`.
   """
+  @spec recursive(task_module) :: boolean
   def recursive(module) when is_atom(module) do
-    case List.keyfind module.__info__(:attributes), :recursive, 0 do
+    case List.keyfind(module.__info__(:attributes), :recursive, 0) do
       {:recursive, [setting]} -> setting
       _ -> false
     end
   end
 
+  @doc """
+  Indicates if the current task is recursing.
+
+  This returns `true` if a task is marked as recursive
+  and it is being executed inside an umbrella project.
+  """
+  @doc since: "1.8.0"
+  @spec recursing?() :: boolean
+  def recursing?() do
+    Mix.ProjectStack.recursing() != nil
+  end
+
+  @doc """
+  Available for backwards compatibility.
+  """
+  @deprecated "Configure the environment in your mix.exs"
+  defdelegate preferred_cli_env(task), to: Mix.CLI
+
+  @doc """
+  Gets the list of requirements for the given task.
+
+  Returns a list of strings, where the string is expected
+  to be a task optionally followed by its arguments.
+  """
+  @doc since: "1.11.0"
+  @spec requirements(task_module) :: []
+  def requirements(module) when is_atom(module) do
+    {:requirements, requirements} =
+      List.keyfind(module.__info__(:attributes), :requirements, 0, {:requirements, []})
+
+    requirements
+  end
+
   @doc """
   Returns the task name for the given `module`.
+
+  ## Examples
+
+      iex> Mix.Task.task_name(Mix.Tasks.Test)
+      "test"
+
   """
-  def task_name(module) do
+  @spec task_name(task_module) :: task_name
+  def task_name(module) when is_atom(module) do
     Mix.Utils.module_name_to_command(module, 2)
   end
 
   @doc """
-  Receives a task name and retrieves the task module.
-  Returns nil if the task cannot be found.
+  Checks if the given `task` name is an alias.
+
+  Returns `false` if the given name is not an alias or if it is not a task.
+
+  For more information about task aliasing, take a look at the
+  ["Aliases"](https://hexdocs.pm/mix/Mix.html#module-aliases) section in the
+  docs for `Mix`.
   """
+  @spec alias?(task_name) :: boolean
+  def alias?(task) when is_binary(task) do
+    alias?(String.to_atom(task))
+  end
+
+  def alias?(task) when is_atom(task) do
+    Keyword.has_key?(Mix.Project.config()[:aliases], task)
+  end
+
+  @doc """
+  Receives a task name and returns the corresponding task module if one exists.
+
+  Returns `nil` if the module cannot be found, if it is an alias, or if it is
+  not a valid `Mix.Task`.
+  """
+  @spec get(task_name) :: task_module | nil
   def get(task) do
-    case Mix.Utils.command_to_module(task, Mix.Tasks) do
-      {:module, module} -> module
+    case fetch(task) do
+      {:ok, module} -> module
       {:error, _} -> nil
     end
   end
 
   @doc """
-  Receives a task name and retrieves the task module.
+  Receives a task name and retrieves the corresponding task module.
 
   ## Exceptions
 
@@ -150,88 +336,363 @@ defmodule Mix.Task do
     * `Mix.InvalidTaskError` - raised if the task is not a valid `Mix.Task`
 
   """
+  @spec get!(task_name) :: task_module
   def get!(task) do
-    if module = get(task) do
-      if is_task?(module) do
+    case fetch(task) do
+      {:ok, module} ->
         module
-      else
-        Mix.raise Mix.InvalidTaskError, task: task
-      end
-    else
-      Mix.raise Mix.NoTaskError, task: task
+
+      {:error, :invalid} ->
+        raise Mix.InvalidTaskError, task: task
+
+      {:error, :not_found} ->
+        raise Mix.NoTaskError, task: task
+    end
+  end
+
+  defp fetch(task) when is_binary(task) or is_atom(task) do
+    case Mix.Utils.command_to_module(to_string(task), Mix.Tasks) do
+      {:module, module} ->
+        if task?(module), do: {:ok, module}, else: {:error, :invalid}
+
+      {:error, _} ->
+        {:error, :not_found}
     end
   end
 
   @doc """
-  Runs a `task` with the given `args`.
+  Conditionally runs the task (or alias) with the given `args`.
+
+  If there exists a task matching the given task name and it has not yet been
+  invoked, this will run the task with the given `args` and return the result.
+
+  If there is an [alias](Mix.html#module-aliases) defined
+  for the given task name, the alias will be invoked instead of the original
+  task.
+
+  If the task or alias has already been invoked, subsequent calls to `run/2`
+  will _abort_ without executing and return `:noop`.
+
+  Remember: by default, tasks will only run _once_, even when called repeatedly!
+  If you need to run a task multiple times, you need to re-enable it via
+  `reenable/1` or call it using `rerun/2`.
 
-  If the task was not yet invoked, it runs the task and
-  returns the result.
+  `run/2` raises an exception if an alias or a task cannot be found or if the
+  task is invalid. See `get!/1` for more information.
 
-  If the task was already invoked, it does not run the task
-  again and simply aborts with `:noop`.
+  ## Examples
+
+      iex> Mix.Task.run("format", ["mix.exs"])
+      :ok
 
-  It may raise an exception if the task was not found
-  or it is invalid. Check `get!/1` for more information.
   """
+  @spec run(task_name, [any]) :: any
   def run(task, args \\ []) do
-    task = to_string(task)
+    do_run(task, args, nil)
+  end
 
-    if Mix.TasksServer.run_task(task, Mix.Project.get) do
-      module = get!(task)
+  @doc """
+  Runs recursive tasks in the specified list of children apps for umbrella projects.
 
-      recur module, fn proj ->
-        Mix.TasksServer.put_task(task, proj)
-        module.run(args)
-      end
-    else
-      :noop
+  If the task is not recursive (whose purpose is to be run in children
+  applications), it runs at the project root level as usual. Calling
+  this function outside of an umbrella project root fails.
+  """
+  @doc since: "1.14.0"
+  @spec run_in_apps(task_name, [atom], [any]) :: any
+  def run_in_apps(task, apps, args \\ []) do
+    if !Mix.Project.umbrella?() do
+      Mix.raise(
+        "Could not run #{inspect(task)} with the --app option because this is not an umbrella project"
+      )
+    end
+
+    do_run(task, args, apps)
+  end
+
+  defp do_run(task, args, apps) when is_atom(task) do
+    do_run(Atom.to_string(task), args, apps)
+  end
+
+  defp do_run(task, args, apps) when is_binary(task) do
+    proj = Mix.Project.get()
+    alias = Mix.Project.config()[:aliases][String.to_atom(task)]
+
+    cond do
+      alias && Mix.TasksServer.run({:alias, task, proj}) ->
+        run_alias(List.wrap(alias), args, proj, task, apps, :ok)
+
+      Mix.TasksServer.get({:task, task, proj}) ->
+        :noop
+
+      module = maybe_load_or_compile_task(proj, task) ->
+        run_task(proj, module, task, args, apps)
+
+      results = Mix.Project.umbrella?() && recur_umbrella_children_alias(task, args, apps) ->
+        results
+
+      true ->
+        # We could not find the task, let's raise
+        get!(task)
     end
   end
 
+  defp recur_umbrella_children_alias(task, args, apps) do
+    alias_key = String.to_atom(task)
+
+    entries =
+      Mix.ProjectStack.recur(fn ->
+        recur(
+          fn proj ->
+            alias = Mix.Project.config()[:aliases][alias_key]
+
+            cond do
+              is_nil(alias) ->
+                :error
+
+              Mix.TasksServer.run({:alias, task, proj}) ->
+                {:ok, run_alias(List.wrap(alias), args, proj, task, nil, :ok)}
+
+              true ->
+                {:ok, :noop}
+            end
+          end,
+          apps
+        )
+      end)
+
+    case for({:ok, res} <- entries, do: res) do
+      [] -> nil
+      result -> result
+    end
+  end
+
+  defp maybe_load_or_compile_task(proj, task) do
+    # 1. If the task is available, we run it.
+    # 2. Otherwise we compile and load dependencies
+    # 3. Finally, we compile the current project in hope it is available.
+    get_task_or_run(proj, task, fn -> run("deps.loadpaths") end) ||
+      get_task_or_run(proj, task, fn -> run("compile", []) end) ||
+      get(task)
+  end
+
+  defp run_task(proj, module, task, args, apps) do
+    recursive = recursive(module)
+
+    cond do
+      recursive && Mix.Project.umbrella?() ->
+        Mix.ProjectStack.recur(fn ->
+          recur(fn _ -> run(task, args) end, apps)
+        end)
+
+      apps && not recursive ->
+        run(task, args)
+
+      not recursive && Mix.ProjectStack.recursing() ->
+        Mix.ProjectStack.on_recursing_root(fn -> run(task, args) end)
+
+      Mix.TasksServer.run({:task, task, proj}) ->
+        run_requirements(module)
+
+        with_debug(task, args, proj, fn ->
+          try do
+            module.run(args)
+          rescue
+            e in OptionParser.ParseError ->
+              Mix.raise("Could not invoke task #{inspect(task)}: " <> Exception.message(e))
+          end
+        end)
+
+      true ->
+        :noop
+    end
+  end
+
+  defp run_requirements(module) do
+    Enum.each(requirements(module), fn requirement ->
+      [task | args] = OptionParser.split(requirement)
+      run(task, args)
+    end)
+  end
+
+  defp with_debug(task, args, proj, fun) do
+    cond do
+      Mix.debug?() ->
+        shell = Mix.shell()
+        shell.info(["-> Running mix ", task_to_string(task, args), project_to_string(proj)])
+        {time, res} = :timer.tc(fun)
+        shell.info(["<- Ran mix ", task, " in ", Integer.to_string(div(time, 1000)), "ms"])
+        res
+
+      opts = profile_opts_for(task) ->
+        shell = Mix.shell()
+        shell.info(["-> Profiling mix ", task_to_string(task, args), project_to_string(proj)])
+        Mix.Tasks.Profile.Tprof.profile(fun, opts)
+
+      true ->
+        fun.()
+    end
+  end
+
+  defp profile_opts_for(task) do
+    {opts, tasks} = Mix.State.get(:profile, {[], []})
+
+    if task in tasks do
+      opts
+    end
+  end
+
+  defp project_to_string(nil), do: ""
+  defp project_to_string(proj), do: " (inside #{inspect(proj)})"
+
+  defp task_to_string(task, []), do: task
+  defp task_to_string(task, args), do: task <> " " <> Enum.join(args, " ")
+
+  defp get_task_or_run(proj, task, fun) do
+    cond do
+      module = get(task) ->
+        module
+
+      proj ->
+        fun.()
+        nil
+
+      true ->
+        nil
+    end
+  end
+
+  defp run_alias([h | t], alias_args, proj, original_task, apps, _res) when is_binary(h) do
+    case OptionParser.split(h) do
+      [^original_task | args] ->
+        module = maybe_load_or_compile_task(proj, original_task) || get!(original_task)
+        res = run_task(proj, module, original_task, args ++ alias_args, apps)
+        run_alias(t, [], proj, original_task, apps, res)
+
+      [task | args] ->
+        res = do_run(task, join_args(args, alias_args, t), apps)
+        run_alias(t, alias_args, proj, original_task, apps, res)
+    end
+  end
+
+  defp run_alias([h | t], alias_args, proj, original_task, apps, _res)
+       when is_function(h, 1) do
+    res =
+      if apps do
+        Mix.ProjectStack.recur(fn ->
+          recur(fn _ -> h.(join_args([], alias_args, t)) end, apps)
+        end)
+      else
+        h.(join_args([], alias_args, t))
+      end
+
+    run_alias(t, alias_args, proj, original_task, apps, res)
+  end
+
+  defp run_alias([h | _], _alias_args, _proj, _original_task, _apps, _res) do
+    Mix.raise(
+      "Invalid Mix alias format, aliases can be either a string (representing a Mix task " <>
+        "with arguments) or a function that takes one argument (a list of alias arguments), " <>
+        "got: #{inspect(h)}"
+    )
+  end
+
+  defp run_alias([], _alias_args, proj, original_task, _apps, res) do
+    Mix.TasksServer.put({:task, original_task, proj})
+    res
+  end
+
+  defp join_args(args, alias_args, []), do: args ++ alias_args
+  defp join_args(args, _alias_args, _), do: args
+
   @doc """
   Clears all invoked tasks, allowing them to be reinvoked.
+
+  This operation is not recursive.
   """
+  @spec clear :: :ok
   def clear do
-    Mix.TasksServer.clear_tasks
+    Mix.TasksServer.clear()
   end
 
   @doc """
-  Reenables a given task so it can be executed again down the stack. If
-  an umbrella project reenables a task it is reenabled for all sub projects.
+  Reenables a given task so it can be executed again down the stack.
+
+  Both alias and the regular stack are re-enabled when this function
+  is called.
+
+  If an umbrella project reenables a task, it is re-enabled for all
+  child projects.
   """
-  def reenable(task) do
-    task   = to_string(task)
-    module = get!(task)
+  @spec reenable(task_name) :: :ok
+  def reenable(task) when is_binary(task) or is_atom(task) do
+    task = to_string(task)
+    proj = Mix.Project.get()
+    recursive = (module = get(task)) && recursive(module)
+
+    Mix.TasksServer.delete_many([{:task, task, proj}, {:alias, task, proj}])
+
+    cond do
+      recursive && Mix.Project.umbrella?() ->
+        recur(
+          fn proj ->
+            Mix.TasksServer.delete_many([{:task, task, proj}, {:alias, task, proj}])
+          end,
+          nil
+        )
 
-    recur module, fn project ->
-      Mix.TasksServer.delete_task(task, project)
+      proj = !recursive && Mix.ProjectStack.recursing() ->
+        Mix.TasksServer.delete_many([{:task, task, proj}, {:alias, task, proj}])
+
+      true ->
+        :ok
     end
+
+    :ok
   end
 
-  defp recur(module, fun) do
-    umbrella? = Mix.Project.umbrella?
-    recursive = recursive(module)
+  defp recur(fun, nil), do: run_in_children_projects(fun, Mix.Dep.Umbrella.cached())
 
-    if umbrella? && recursive && Mix.ProjectStack.enable_recursion do
-      # Get all dependency configuration but not the deps path
-      # as we leave the control of the deps path still to the
-      # umbrella child.
-      config = Mix.Project.deps_config |> Keyword.delete(:deps_path)
-      res = for %Mix.Dep{app: app, opts: opts} <- Mix.Dep.Umbrella.loaded do
-        Mix.Project.in_project(app, opts[:path], config, fun)
-      end
-      Mix.ProjectStack.disable_recursion
-      res
-    else
-      fun.(Mix.Project.get)
+  defp recur(fun, apps) do
+    selected_children =
+      Mix.Dep.Umbrella.cached()
+      |> Enum.filter(fn %Mix.Dep{app: app} -> app in apps end)
+
+    run_in_children_projects(fun, selected_children)
+  end
+
+  defp run_in_children_projects(fun, deps) do
+    # Get all dependency configuration but not the deps path
+    # as we leave the control of the deps path still to the
+    # umbrella child.
+    config = Mix.Project.deps_config() |> Keyword.delete(:deps_path)
+
+    for %Mix.Dep{app: app, opts: opts} <- deps do
+      Mix.Project.in_project(app, opts[:path], [inherit_parent_config_files: true] ++ config, fun)
     end
   end
 
+  @doc """
+  Reruns `task` with the given arguments.
+
+  This function reruns the given task; to do that, it first re-enables the task
+  and then runs it as normal.
+  """
+  @spec rerun(task_name, [any]) :: any
+  def rerun(task, args \\ []) do
+    reenable(task)
+    run(task, args)
+  end
+
   @doc """
   Returns `true` if given module is a task.
   """
-  def is_task?(module) do
-    function_exported?(module, :run, 1)
+  @spec task?(task_module) :: boolean
+  def task?(module) when is_atom(module) do
+    match?(~c"Elixir.Mix.Tasks." ++ _, Atom.to_charlist(module)) and ensure_task?(module)
+  end
+
+  defp ensure_task?(module) do
+    Code.ensure_loaded?(module) and function_exported?(module, :run, 1)
   end
 end
diff --git a/lib/mix/lib/mix/tasks/app.config.ex b/lib/mix/lib/mix/tasks/app.config.ex
new file mode 100644
index 00000000000..cc402258710
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/app.config.ex
@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.App.Config do
+  use Mix.Task
+
+  @shortdoc "Configures all registered apps"
+
+  @moduledoc """
+  Loads and configures all registered apps.
+
+  This is done by loading `config/runtime.exs` if one exists.
+  The application will be compiled if it was not compiled before.
+
+  ## Command line options
+
+    * `--force` - forces compilation regardless of compilation times
+    * `--preload-modules` - preloads all modules defined in applications
+    * `--no-archives-check` - does not check archives
+    * `--no-app-loading` - does not load .app resource file after compilation
+    * `--no-compile` - does not compile even if files require compilation
+    * `--no-deps-check` - does not check dependencies
+    * `--no-elixir-version-check` - does not check Elixir version
+    * `--no-validate-compile-env` - does not validate the application compile environment
+
+  """
+
+  @switches [preload_modules: :boolean]
+
+  @impl true
+  def run(args) do
+    Mix.Project.get!()
+    Mix.Task.run("compile", args)
+    {opts, _, _} = OptionParser.parse(args, switches: @switches)
+
+    config = Mix.Project.config()
+    runtime = config[:config_path] |> Path.dirname() |> Path.join("runtime.exs")
+
+    if File.exists?(runtime) do
+      Mix.Tasks.Loadconfig.load_runtime(runtime)
+    end
+
+    if opts[:preload_modules] do
+      for {app, _, _} <- Application.loaded_applications() do
+        :code.ensure_modules_loaded(Application.spec(app, :modules))
+      end
+    end
+
+    # If the build path is set, we assume it is being shared
+    # (such as in an umbrella) and therefore we cannot check
+    # for applications as we may have both false positives and
+    # false negatives.
+    #
+    # Therefore we let the application that owns the build path
+    # to ultimately perform the check.
+    if !config[:build_path] do
+      check_configured()
+    end
+  end
+
+  defp check_configured() do
+    for app <- Mix.ProjectStack.config_apps(),
+        # Application.spec is a quick check that doesn't involve
+        # a separate process, so we try that first.
+        is_nil(Application.spec(app, :vsn)),
+        # Then we fallback to checking the :code.lib_dir for apps
+        # with runtime: false, which is still reasonably fast as
+        # the code server also uses a ETS table
+        :code.lib_dir(app) == {:error, :bad_name} do
+      Mix.shell().error("""
+      You have configured application #{inspect(app)} in your configuration file,
+      but the application is not available.
+
+      This usually means one of:
+
+        1. You have not added the application as a dependency in a mix.exs file.
+
+        2. You are configuring an application that does not really exist.
+
+      Please ensure #{inspect(app)} exists or remove the configuration.
+      """)
+    end
+
+    :ok
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/app.start.ex b/lib/mix/lib/mix/tasks/app.start.ex
index 974710da12d..a1cc4460635 100644
--- a/lib/mix/lib/mix/tasks/app.start.ex
+++ b/lib/mix/lib/mix/tasks/app.start.ex
@@ -1,48 +1,116 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.App.Start do
   use Mix.Task
 
-  @recursive true
+  @shortdoc "Starts all registered apps"
 
   @moduledoc """
-  Starts all registered apps. If no apps key exists,
-  it starts the current application.
+  Starts all registered apps.
+
+  First, this task guarantees that all dependencies are in place
+  and that the current project has been compiled. Then, the current
+  application is started as a temporary application, unless
+  `:start_permanent` is set to `true` in your project configuration
+  or the `--permanent` option is given. Setting it to permanent
+  guarantees the node will shut down if the application terminates
+  (typically because its root supervisor has terminated).
+
+  ## Configuration
+
+    * `:start_permanent` - the application and all of its children
+      applications are started in permanent mode. Defaults to `false`.
+
+    * `:start_concurrently` - applications are started concurrently
+      whenever possible. Defaults to `false`.
 
   ## Command line options
 
-    * `--force`         - force compilation regardless of compilation times
-    * `--no-compile`    - do not compile even if files require compilation
-    * `--no-deps-check` - do not check dependencies
-    * `--no-elixir-version-check`
-                        - do not check elixir version
-    * `--no-start`      - do not start applications after compilation
+    * `--force` - forces compilation regardless of compilation times
+    * `--temporary` - starts the application as temporary
+    * `--permanent` - starts the application as permanent
+    * `--preload-modules` - preloads all modules defined in applications
+    * `--no-archives-check` - does not check archives
+    * `--no-compile` - does not compile even if files require compilation
+    * `--no-deps-check` - does not check dependencies
+    * `--no-elixir-version-check` - does not check Elixir version
+    * `--no-start` - does not actually start applications, only compiles and loads code
 
   """
+
+  @compile {:no_warn_undefined, Logger.App}
+
+  @switches [
+    permanent: :boolean,
+    temporary: :boolean
+  ]
+
+  @impl true
   def run(args) do
-    {opts, _, _} = OptionParser.parse(args)
+    Mix.Project.get!()
+    Mix.Task.run("app.config", args)
+    {opts, _, _} = OptionParser.parse(args, switches: @switches)
+
+    if "--no-start" in args do
+      Mix.Task.reenable("app.start")
+    else
+      # Stop Logger when starting the application as it is up to the
+      # application to decide if it should be restarted or not.
+      #
+      # Mix should not depend directly on Logger so check that it's loaded.
+      Logger.App.stop()
+      config = Mix.Project.config()
+      type = type(config, opts)
+      mode = if config[:start_concurrently], do: :concurrent, else: :serial
+      start(apps(config), type, mode)
+    end
+
+    :ok
+  end
+
+  @doc false
+  def start(apps, type, mode) do
+    case Application.ensure_all_started(apps, type: type, mode: mode) do
+      {:ok, _} ->
+        :ok
 
-    Mix.Task.run "deps.loadpaths", args
-    Mix.Task.run "loadpaths", args
+      {:error, {app, reason}} when type == :permanent ->
+        # We need to stop immediately because application_controller is
+        # shutting down all applications. Since any work we do here is prone
+        # to race conditions as whatever process we call may no longer exist,
+        # we print a quick message, and then we block by calling `System.stop/1`.
+        Mix.shell().error(["** (Mix) ", could_not_start(app, reason)])
+        System.stop(1)
+        Process.sleep(:infinity)
 
-    unless opts[:no_compile] do
-      Mix.Task.run "compile", args
+      {:error, {app, reason}} ->
+        Mix.raise(could_not_start(app, reason))
     end
 
-    unless opts[:no_start] do
-      start(Mix.Project.config[:app])
+    :ok
+  end
+
+  defp apps(config) do
+    cond do
+      Mix.Project.umbrella?(config) -> Enum.map(Mix.Dep.Umbrella.cached(), & &1.app)
+      app = config[:app] -> [app]
+      true -> []
     end
   end
 
+  defp could_not_start(app, reason) do
+    "Could not start application #{app}: " <> Application.format_error(reason)
+  end
+
   @doc false
-  def start(app) do
-    if app do
-      case Application.ensure_all_started(app) do
-        {:ok, _} -> :ok
-        {:error, {app, reason}} ->
-          Mix.raise "Could not start application #{app}: " <>
-            Application.format_error(reason)
-      end
-    else
-      :error
+  def type(config, opts) do
+    cond do
+      opts[:temporary] -> :temporary
+      opts[:permanent] -> :permanent
+      config[:start_permanent] -> :permanent
+      true -> :temporary
     end
   end
 end
diff --git a/lib/mix/lib/mix/tasks/app.tree.ex b/lib/mix/lib/mix/tasks/app.tree.ex
new file mode 100644
index 00000000000..97e0142a5fb
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/app.tree.ex
@@ -0,0 +1,108 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.App.Tree do
+  use Mix.Task
+
+  @shortdoc "Prints the application tree"
+  @recursive true
+
+  @moduledoc """
+  Prints the application tree.
+
+      $ mix app.tree --exclude logger --exclude elixir
+
+  If no application is given, it uses the current application defined
+  in the `mix.exs` file.
+
+  ## Command line options
+
+    * `--exclude` - exclude applications which you do not want to see printed.
+      `kernel`, `stdlib` and `compiler` are always excluded from the tree.
+
+    * `--format` - Can be set to one of either:
+
+      * `pretty` - uses Unicode code points for formatting the tree.
+        This is the default except on Windows.
+
+      * `plain` - does not use Unicode code points for formatting the tree.
+        This is the default on Windows.
+
+      * `dot` - produces a DOT graph description of the application tree
+        in `app_tree.dot` in the current directory.
+        Warning: this will overwrite any previously generated file.
+
+  """
+
+  @default_excluded [:kernel, :stdlib, :compiler]
+
+  @impl true
+  def run(args) do
+    Mix.Task.run("compile", args)
+
+    {app, opts} =
+      case OptionParser.parse!(args, strict: [exclude: :keep, format: :string]) do
+        {opts, []} ->
+          app =
+            Mix.Project.config()[:app] ||
+              Mix.raise("no application given and none found in mix.exs file")
+
+          {app, opts}
+
+        {opts, [app]} ->
+          {String.to_atom(app), opts}
+      end
+
+    excluded = Keyword.get_values(opts, :exclude) |> Enum.map(&String.to_atom/1)
+    excluded = @default_excluded ++ excluded
+
+    callback = fn {app, type} ->
+      if load(app, type) do
+        {{app, type(type)}, children_for(app, excluded)}
+      else
+        {{app, "(optional - missing)"}, []}
+      end
+    end
+
+    if opts[:format] == "dot" do
+      root = [{app, :normal}]
+      Mix.Utils.write_dot_graph!("app_tree.dot", "application tree", root, callback, opts)
+
+      """
+      Generated "app_tree.dot" in the current directory. To generate a PNG:
+
+         dot -Tpng app_tree.dot -o app_tree.png
+
+      For more options see http://www.graphviz.org/.
+      """
+      |> String.trim_trailing()
+      |> Mix.shell().info()
+    else
+      Mix.Utils.print_tree([{app, :normal}], callback, opts)
+    end
+  end
+
+  defp load(app, type) do
+    case Application.ensure_loaded(app) do
+      :ok -> true
+      _ when type == :optional -> false
+      _ -> Mix.raise("could not find application #{app}")
+    end
+  end
+
+  defp children_for(app, excluded) do
+    apps = Application.spec(app, :applications) -- excluded
+    included_apps = Application.spec(app, :included_applications) -- excluded
+    optional_apps = Application.spec(app, :optional_applications) || []
+
+    Enum.sort(
+      Enum.map(apps, &{&1, if(&1 in optional_apps, do: :optional, else: :normal)}) ++
+        Enum.map(included_apps, &{&1, :included})
+    )
+  end
+
+  defp type(:normal), do: nil
+  defp type(:included), do: "(included)"
+  defp type(:optional), do: "(optional)"
+end
diff --git a/lib/mix/lib/mix/tasks/archive.build.ex b/lib/mix/lib/mix/tasks/archive.build.ex
new file mode 100644
index 00000000000..9d9a763a7b8
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/archive.build.ex
@@ -0,0 +1,143 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Archive.Build do
+  use Mix.Task
+
+  @shortdoc "Archives this project into a .ez file"
+  @recursive true
+
+  @moduledoc """
+  Builds an archive according to the specification of the
+  [Erlang archive format](`:code`).
+
+  Archives are meant to contain small projects, usually installed
+  locally. Archives may be installed into a Mix environment by
+  running `mix archive.install`. Once installed, the archive is
+  available to all Mix projects. For this reason, the functionality
+  behind archives is limited. For instance, archives do not include
+  dependencies, as those would conflict with any dependency in a
+  Mix project after the archive is installed. In general, we recommend
+  the usage of archives to be limited for extensions of Mix, such
+  as custom SCMs, package managers, and the like. For general scripts to be
+  distributed to developers, please see `mix escript.build`.
+
+  The archive will be created in the current directory (which is
+  expected to be the project root), unless an argument `-o` is
+  provided with the file name.
+
+  By default, this command archives the current project but the `-i`
+  option can be used to archive any directory. For example,
+  `mix archive.build` with no options translates to:
+
+      $ mix archive.build -i _build/ENV/lib/APP -o APP-VERSION.ez
+
+  ## Command line options
+
+    * `-o` - specifies output file name.
+      If there is a `mix.exs`, defaults to `APP-VERSION.ez`.
+
+    * `-i` - specifies the input directory to archive.
+      If there is a `mix.exs`, defaults to the current application build.
+
+    * `--no-compile` - skips compilation.
+      Only applies when `mix.exs` is available.
+
+    * `--include-dot-files` - adds dot files from priv directory to the archive.
+
+  """
+  @switches [
+    force: :boolean,
+    compile: :boolean,
+    output: :string,
+    input: :string,
+    deps_check: :boolean,
+    archives_check: :boolean,
+    elixir_version_check: :boolean,
+    include_dot_files: :boolean
+  ]
+
+  @impl true
+  def run(args) do
+    {opts, _} = OptionParser.parse!(args, aliases: [o: :output, i: :input], strict: @switches)
+
+    project = Mix.Project.get()
+
+    if project && Keyword.get(opts, :compile, true) do
+      # We only care about the archive ebin, so we disable protocol
+      # consolidation to avoid further changes to the environment.
+      Mix.Task.run(:compile, ["--no-consolidate-protocols" | args])
+    end
+
+    source =
+      cond do
+        input = opts[:input] ->
+          input
+
+        project ->
+          path = Mix.Project.app_path()
+
+          if elixir = Mix.Project.config()[:elixir] do
+            File.write(Path.join(path, ".elixir"), elixir)
+          else
+            File.rm(Path.join(path, ".elixir"))
+          end
+
+          path
+
+        true ->
+          Mix.raise("Cannot create archive without input directory, please pass -i as an option")
+      end
+
+    project_config = Mix.Project.config()
+
+    target =
+      cond do
+        output = opts[:output] ->
+          output
+
+        project_config[:app] ->
+          Mix.Local.name_for(:archives, project_config)
+
+        true ->
+          Mix.raise("Cannot create archive without output file, please pass -o as an option")
+      end
+
+    if not File.dir?(source) do
+      Mix.raise("Expected archive source #{inspect(source)} to be a directory")
+    end
+
+    create(source, target, Keyword.get(opts, :include_dot_files, false))
+
+    Mix.shell().info("Generated archive #{inspect(target)} with MIX_ENV=#{Mix.env()}")
+    :ok
+  end
+
+  defp create(source, target, include_dot_files?) do
+    source_path = Path.expand(source)
+    target_path = Path.expand(target)
+    dir = Mix.Local.archive_name(target_path) |> String.to_charlist()
+    file_list = files_to_add(source_path, dir, include_dot_files?)
+    {:ok, _} = :zip.create(String.to_charlist(target_path), file_list)
+    :ok
+  end
+
+  defp files_to_add(path, dir, include_dot_files?) do
+    File.cd!(path, fn ->
+      evsn = Path.wildcard(".elixir")
+      ebin = Path.wildcard("ebin/*.{beam,app}")
+      priv = Path.wildcard("priv/**/*", match_dot: include_dot_files?)
+
+      Enum.reduce(evsn ++ ebin ++ priv, [], fn f, acc ->
+        case File.read(f) do
+          {:ok, bin} ->
+            [{Path.join(dir, f) |> String.to_charlist(), bin} | acc]
+
+          {:error, _} ->
+            acc
+        end
+      end)
+    end)
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/archive.check.ex b/lib/mix/lib/mix/tasks/archive.check.ex
new file mode 100644
index 00000000000..515952ac207
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/archive.check.ex
@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Archive.Check do
+  use Mix.Task
+
+  @moduledoc """
+  Checks all archives are available.
+
+  Mix projects can specify required archives using
+  the `:archives` option:
+
+      archives: [{:foo, "~> 1.0.0"}]
+
+  This task guarantees this option is respected.
+  """
+
+  @impl true
+  def run(_) do
+    archives = Mix.Project.config()[:archives] || []
+
+    Enum.each(archives, fn tuple ->
+      {archive, req} = parse_archive(tuple)
+      _ = Application.load(archive)
+      vsn = Application.spec(archive, :vsn)
+
+      cond do
+        is_nil(vsn) ->
+          Mix.raise(
+            "Archive \"#{archive}\" could not be found. " <>
+              "Please make sure the archive is installed locally."
+          )
+
+        not Version.match?(List.to_string(vsn), req) ->
+          Mix.raise(
+            "Archive \"#{archive}-#{vsn}\" does not match requirement #{req}. " <>
+              "Please update your archive version accordingly."
+          )
+
+        true ->
+          :ok
+      end
+    end)
+  end
+
+  defp parse_archive({archive, req}) when is_atom(archive) and is_binary(req) do
+    case Version.parse_requirement(req) do
+      {:ok, req} ->
+        {archive, req}
+
+      :error ->
+        Mix.raise("Invalid requirement #{req} for archive \"#{archive}\"")
+    end
+  end
+
+  defp parse_archive(other) do
+    Mix.raise("""
+    Expected archive to be in the format:
+
+        {app :: atom, requirement :: binary}
+
+    got:
+
+        #{inspect(other)}
+
+    """)
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/archive.ex b/lib/mix/lib/mix/tasks/archive.ex
index a1f5c6e320d..5ba36df1b0c 100644
--- a/lib/mix/lib/mix/tasks/archive.ex
+++ b/lib/mix/lib/mix/tasks/archive.ex
@@ -1,66 +1,40 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Archive do
   use Mix.Task
 
-  @shortdoc "Archive this project into a .ez file"
+  @shortdoc "Lists installed archives"
 
   @moduledoc """
-  Packages the current project (though not its dependencies) into a
-  zip file according to the specification of the
-  [Erlang Archive Format](http://www.erlang.org/doc/man/code.html).
-
-  Archives are meant to bundle small projects, usually installed
-  locally.
-
-  The file will be created in the current directory (which is expected
-  to be the project root), unless an argument -o is provided with the file name.
-
-  ## Command line options
-
-    * `-o` - specify output file name.
-             If there is a mix.exs, defaults to app-vsn.ez.
-
-    * `-i` - specify the input directory to archive.
-             If there is a mix.exs, defaults to the current application build.
+  Lists all installed archives.
 
-    * `--no-compile`
-           - skip compilation. Only applies to projects.
+  Archives are typically installed at `~/.mix/archives`
+  although the installation path can be customized by
+  setting the `MIX_ARCHIVES` environment variable.
 
+  Since archives are specific to Elixir versions, it is
+  expected from build tools to swap the `MIX_ARCHIVES`
+  variable to different locations based on a particular
+  Elixir installation.
   """
 
-  def run(args) do
-    {opts, _, _} = OptionParser.parse(args, aliases: [o: :output, i: :input],
-                                        switches: [force: :boolean, no_compile: :boolean])
-
-    project = Mix.Project.get
-
-    if project && !opts[:no_compile] do
-      Mix.Task.run :compile, args
-    end
-
-    source = cond do
-      input = opts[:input] ->
-        input
-      project ->
-        Mix.Project.app_path
-      true ->
-        Mix.raise "Cannot create archive without input directory, " <>
-          "please pass -i as an option"
-    end
-
-    target = cond do
-      output = opts[:output] ->
-        output
-      app = Mix.Project.config[:app] ->
-        Mix.Archive.name(app, Mix.Project.config[:version])
-      true ->
-        Mix.raise "Cannot create archive without a name, " <>
-          "please pass -o as an option"
-    end
+  @impl true
+  def run(_) do
+    Mix.path_for(:archives)
+    |> Path.join("*")
+    |> Path.wildcard()
+    |> Enum.map(&Path.basename/1)
+    |> print()
+  end
 
-    unless File.dir?(source) do
-      Mix.raise "Expected archive source #{inspect source} to be a directory"
-    end
+  defp print([]) do
+    Mix.shell().info("No archives currently installed.")
+  end
 
-    Mix.Archive.create(source, target)
+  defp print(items) do
+    Enum.each(items, fn item -> Mix.shell().info(["* ", item]) end)
+    Mix.shell().info("Archives installed at: #{Mix.path_for(:archives)}")
   end
 end
diff --git a/lib/mix/lib/mix/tasks/archive.install.ex b/lib/mix/lib/mix/tasks/archive.install.ex
new file mode 100644
index 00000000000..19814f1c8fc
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/archive.install.ex
@@ -0,0 +1,171 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Archive.Install do
+  use Mix.Task
+
+  @shortdoc "Installs an archive locally"
+
+  @moduledoc """
+  Installs an archive locally.
+
+  If no argument is supplied but there is an archive in the project's
+  root directory (created with `mix archive.build`), then the archive
+  will be installed locally. For example:
+
+      $ mix do archive.build + archive.install
+
+  If an argument is provided, it should be a local path to a
+  prebuilt archive, a Git repository, a GitHub repository, or a Hex
+  package.
+
+      $ mix archive.install archive.ez
+      $ mix archive.install path/to/archive.ez
+      $ mix archive.install git https://path/to/git/repo
+      $ mix archive.install git https://path/to/git/repo branch git_branch
+      $ mix archive.install git https://path/to/git/repo tag git_tag
+      $ mix archive.install git https://path/to/git/repo ref git_ref
+      $ mix archive.install github user/project
+      $ mix archive.install github user/project branch git_branch
+      $ mix archive.install github user/project tag git_tag
+      $ mix archive.install github user/project ref git_ref
+      $ mix archive.install hex hex_package
+      $ mix archive.install hex hex_package 1.2.3
+
+  After installation, the tasks in the archive are available locally:
+
+      $ mix some_task
+
+  Note that installing via Git, GitHub, or Hex fetches the source
+  of the archive and builds it, while using local path uses a pre-built archive.
+
+  ## Command line options
+
+    * `--sha512` - checks the archive matches the given SHA-512 checksum. Only
+      applies to installations via a local path
+
+    * `--force` - forces installation without a shell prompt; primarily
+      intended for automation in build systems like Make
+
+    * `--submodules` - fetches repository submodules before building archive from
+      Git or GitHub
+
+    * `--sparse` - checkout a single directory inside the Git repository and use
+      it as the archive root directory
+
+    * `--app` - specifies a custom app name to be used for building the archive
+      from Git, GitHub, or Hex
+
+    * `--organization` - set this for Hex private packages belonging to an
+      organization
+
+    * `--repo` - set this for self-hosted Hex instances, defaults to `hexpm`
+
+  """
+
+  @behaviour Mix.Local.Installer
+
+  @switches [
+    force: :boolean,
+    sha512: :string,
+    submodules: :boolean,
+    sparse: :string,
+    app: :string,
+    organization: :string,
+    repo: :string,
+    timeout: :integer
+  ]
+
+  @impl true
+  def run(argv) do
+    Mix.Local.Installer.install(__MODULE__, argv, @switches)
+  end
+
+  @impl true
+  def check_install_spec({:local, path} = _install_spec, _opts) do
+    check_extname(path)
+  end
+
+  def check_install_spec({:url, url} = _install_spec, _opts) do
+    check_extname(url)
+  end
+
+  def check_install_spec(_, _), do: :ok
+
+  defp check_extname(path_or_url) do
+    if Path.extname(path_or_url) == ".ez" do
+      :ok
+    else
+      {:error, "Expected a local file path ending in \".ez\"."}
+    end
+  end
+
+  @impl true
+  def find_previous_versions(src) do
+    app =
+      src
+      |> Mix.Local.archive_name()
+      |> String.split("-")
+      |> List.first()
+
+    if app do
+      archives(app) ++ archives(app <> "-*")
+    else
+      []
+    end
+  end
+
+  @impl true
+  def install(basename, contents, previous) do
+    ez_path = Path.join(Mix.path_for(:archives), basename)
+    dir_dest = resolve_destination(ez_path, contents)
+
+    remove_previous_versions(previous)
+
+    File.mkdir_p!(dir_dest)
+    {:ok, _} = :zip.extract(contents, cwd: to_charlist(dir_dest))
+    Mix.shell().info([:green, "* creating ", :reset, Path.relative_to_cwd(dir_dest)])
+
+    ebin = Mix.Local.archive_ebin(dir_dest)
+    Mix.Local.check_elixir_version_in_ebin(ebin)
+    true = Code.append_path(ebin, cache: true)
+    :ok
+  end
+
+  @impl true
+  def build(_install_spec, _opts) do
+    src = Mix.Local.name_for(:archives, Mix.Project.config())
+    previous = find_previous_versions(src)
+
+    Enum.each(previous, fn path ->
+      Code.delete_path(Mix.Local.archive_ebin(path))
+    end)
+
+    Mix.Task.run("loadconfig")
+    Mix.Task.run("archive.build", [])
+    src
+  end
+
+  ### Private helpers
+
+  defp resolve_destination(ez_path, contents) do
+    with {:ok, [_comment, zip_first_file | _]} <- :zip.list_dir(contents),
+         {:zip_file, zip_first_path, _, _, _, _} = zip_first_file,
+         [zip_root_dir | _] = Path.split(zip_first_path) do
+      Path.join(Path.dirname(ez_path), zip_root_dir)
+    else
+      _ ->
+        Mix.raise("Installation failed: invalid archive file")
+    end
+  end
+
+  defp archives(name) do
+    Mix.path_for(:archives)
+    |> Path.join(name)
+    |> Path.wildcard()
+  end
+
+  defp remove_previous_versions([]), do: :ok
+  defp remove_previous_versions(previous), do: Enum.each(previous, &File.rm_rf!/1)
+end
diff --git a/lib/mix/lib/mix/tasks/archive.uninstall.ex b/lib/mix/lib/mix/tasks/archive.uninstall.ex
new file mode 100644
index 00000000000..b1e82d68c1a
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/archive.uninstall.ex
@@ -0,0 +1,28 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Archive.Uninstall do
+  use Mix.Task
+
+  @shortdoc "Uninstalls archives"
+
+  @moduledoc """
+  Uninstalls local archives.
+
+      $ mix archive.uninstall archive.ez
+
+  ## Command line options
+    * `--force` - forces uninstallation without a shell prompt; primarily
+      intended for automation
+  """
+
+  @switches [
+    force: :boolean
+  ]
+
+  @impl true
+  def run(argv) do
+    Mix.Local.Installer.uninstall(Mix.path_for(:archives), "archive", argv, @switches)
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/clean.ex b/lib/mix/lib/mix/tasks/clean.ex
index c3ea1313202..b0dcf4c6e8c 100644
--- a/lib/mix/lib/mix/tasks/clean.ex
+++ b/lib/mix/lib/mix/tasks/clean.ex
@@ -1,44 +1,84 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Clean do
   use Mix.Task
 
-  @shortdoc "Clean generated application files"
+  @shortdoc "Deletes generated application files"
   @recursive true
 
   @moduledoc """
-  Clean generated application files.
+  Deletes generated application files.
+
+  This command deletes all build artifacts for the current project.
+  Dependencies' sources and build files are cleaned only if the
+  `--deps` option is given.
 
-  This command delete all build artifacts for the current application
-  accross all environments. Dependencies are only cleaned up if the
-  `--all` option is given.
+  By default this task works across all environments, unless `--only`
+  is given.
 
   ## Command line options
 
-    * `--all` - clean everything, including builds and dependencies
+    * `--deps` - clean dependencies as well as the current project's files
+    * `--only` - only clean the given environment
 
   """
 
+  @switches [deps: :boolean, only: :string]
+
+  @impl true
   def run(args) do
-    {opts, _, _} = OptionParser.parse(args)
+    Mix.Project.get!()
+    loadpaths!()
 
-    for compiler <- Mix.Tasks.Compile.compilers() do
-      module = Mix.Task.get!("compile.#{compiler}")
-      if function_exported?(module, :clean, 0) do
-        module.clean
-      end
-    end
+    {opts, _, _} = OptionParser.parse(args, switches: @switches)
+
+    Mix.Project.with_build_lock(fn ->
+      do_run(opts)
+    end)
+  end
+
+  defp do_run(opts) do
+    # First, we get the tasks. After that, we clean them.
+    # This is to avoid a task cleaning a compiler module.
+    tasks =
+      for compiler <- Mix.Task.Compiler.compilers(),
+          module = Mix.Task.get("compile.#{compiler}"),
+          function_exported?(module, :clean, 0),
+          do: module
 
-    if opts[:all] do
-      Mix.Task.run("deps.clean", args)
-      Mix.Project.build_path
-      |> Path.dirname
-      |> File.rm_rf
+    Mix.Compilers.Protocol.clean()
+    Enum.each(tasks, & &1.clean())
+
+    build =
+      Mix.Project.build_path()
+      |> Path.dirname()
+      |> Path.join("*#{opts[:only]}")
+
+    if opts[:deps] do
+      build
+      |> Path.wildcard()
+      |> Enum.each(&File.rm_rf/1)
     else
-      config = Mix.Project.config
-      Mix.Project.build_path(config)
-      |> Path.dirname
-      |> Path.join("*/lib/#{config[:app]}")
-      |> Path.wildcard
+      build
+      |> Path.join("lib/#{Mix.Project.config()[:app]}")
+      |> Path.wildcard()
       |> Enum.each(&File.rm_rf/1)
     end
   end
+
+  # Loadpaths without checks because compilers may be defined in deps.
+  defp loadpaths! do
+    options = [
+      "--no-elixir-version-check",
+      "--no-deps-check",
+      "--no-archives-check",
+      "--no-listeners"
+    ]
+
+    Mix.Task.run("loadpaths", options)
+    Mix.Task.reenable("loadpaths")
+    Mix.Task.reenable("deps.loadpaths")
+  end
 end
diff --git a/lib/mix/lib/mix/tasks/cmd.ex b/lib/mix/lib/mix/tasks/cmd.ex
index d332a7c619b..db2c852daba 100644
--- a/lib/mix/lib/mix/tasks/cmd.ex
+++ b/lib/mix/lib/mix/tasks/cmd.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Cmd do
   use Mix.Task
 
@@ -7,19 +11,131 @@ defmodule Mix.Tasks.Cmd do
   @moduledoc """
   Executes the given command.
 
-  Useful in umbrella applications to execute a command
+  For example, you can invoke an external command such as make:
+
+      $ mix cmd make
+
+  ## Shell expansion
+
+  When you invoke `mix cmd` from the command line, environment variables,
+  glob patterns, and similar are expanded by the current shell and then
+  passed to `mix cmd`. For example, if you invoke:
+
+      $ mix cmd echo lib/*
+
+  Your shell will expand "lib/*" and then pass multiple arguments to
+  `mix cmd`, which in turn passes them to `echo`. Note that, `mix cmd`
+  by itself, does not perform any shell expansion. This means that,
+  if you invoke `mix cmd` programmatically, as in:
+
+      Mix.Task.run("cmd", ["echo", "lib/*"])
+
+  or through a `mix.exs` alias:
+
+      alias: "cmd echo lib/*"
+
+  It will literally print "lib/*".
+
+  This behaviour is the default from Elixir v1.19. If you want
+  `mix cmd` to behave like a shell, you can pass the `--shell`
+  option before the command name:
+
+      Mix.Task.run("cmd", ["--shell", "echo", "lib/*"])
+
+  Keep in mind however that, if `--shell` is given, quoted arguments
+  are no longer correctly propagated to the underlying command
+  (as they get expanded before hand).
+
+  This task is automatically re-enabled, so it can be called multiple times
+  with different arguments.
+
+  ## Umbrella applications and directories
+
+  This task is also useful in umbrella applications to execute a command
   on each child app:
 
-      mix cmd echo pwd
+      $ mix cmd pwd
+
+  In such cases, Mix will change the current working directory to the root
+  of each umbrella application before executing the command.
+
+  You can limit which apps the cmd runs in by using `mix do` with the `--app`
+  option:
+
+      $ mix do --app app1 --app app2 cmd pwd
+
+  Note the tasks aborts whenever a command exits with a non-zero status.
 
-  Aborts when the first command exits with status different
-  than zero.
+  Outside of umbrella projects, you can pass the `--cd` flag before the command,
+  to specify a directory:
+
+      $ mix cmd --cd "third-party" make
+
+  ## Command line options
+
+    * `--cd` *(since v1.10.4)* - the directory to run the command in
+    * `--shell` *(since v1.19.0)* - perform shell expansion of the arguments
+
+  ## Orphan operating system processes
+
+  Beware that the Erlang VM does not terminate child processes
+  when it shuts down. Therefore, if you use `mix cmd` to start
+  long running processes and then shut down the VM, it is likely
+  that those child processes won't be terminated with the VM.
+
+  A solution is to make sure the child processes listen to the
+  standard input and terminate when standard input is closed.
+  We discuss this topic at length in the "Orphan operating system processes"
+  of the `Port` module documentation.
   """
+
+  @switches [
+    app: :keep,
+    cd: :string,
+    shell: :boolean
+  ]
+
+  @impl true
   def run(args) do
-    Mix.shell.print_app
-    case Mix.shell.cmd(Enum.join(args, " ")) do
-      0 -> :ok
-      s -> exit(s)
+    {opts, args} = OptionParser.parse_head!(args, strict: @switches)
+
+    if args == [] do
+      Mix.raise("No argument was given to mix cmd. Run \"mix help cmd\" for more information")
+    end
+
+    apps =
+      opts
+      |> Keyword.get_values(:app)
+      |> Enum.map(&String.to_atom/1)
+
+    if apps != [] do
+      IO.warn("the --app in mix cmd is deprecated. Use mix do --app instead.")
+    end
+
+    if apps == [] or Mix.Project.config()[:app] in apps do
+      path = hd(args)
+      rest = tl(args)
+
+      arg =
+        cond do
+          Keyword.get(opts, :shell, false) ->
+            Enum.join([path | rest], " ")
+
+          String.contains?(path, ["/", "\\"]) and Path.type(path) != :absolute ->
+            {Path.expand(path, Keyword.get(opts, :cd, ".")), rest}
+
+          true ->
+            {path, rest}
+        end
+
+      cmd_opts = Keyword.take(opts, [:cd])
+
+      case Mix.shell().cmd(arg, cmd_opts) do
+        0 -> :ok
+        status -> exit(status)
+      end
     end
+
+    Mix.Task.reenable("cmd")
   end
 end
diff --git a/lib/mix/lib/mix/tasks/compile.all.ex b/lib/mix/lib/mix/tasks/compile.all.ex
new file mode 100644
index 00000000000..6ab622b3929
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/compile.all.ex
@@ -0,0 +1,126 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Compile.All do
+  use Mix.Task.Compiler
+
+  @moduledoc false
+  @compile {:no_warn_undefined, Logger}
+  @recursive true
+
+  # This is an internal task used by "mix compile" which
+  # is meant to be recursive and be invoked for each child
+  # project.
+
+  @impl true
+  def run(args) do
+    Mix.Project.get!()
+
+    config = Mix.Project.config()
+
+    Mix.Project.with_build_lock(config, fn ->
+      do_run(config, args)
+    end)
+  end
+
+  defp do_run(config, args) do
+    # Compute the app cache if it is stale and we are
+    # not compiling from a dependency.
+    app_cache =
+      if "--from-mix-deps-compile" not in args do
+        Mix.AppLoader.stale_cache(config)
+      end
+
+    # Make sure Mix.Dep is cached to avoid loading dependencies
+    # during compilation. This is also important because we prune
+    # the load paths before compiling, which means any SCM coming
+    # from archives will be removed from the code path.
+    deps = Mix.Dep.cached()
+    apps = compile_apps(config, args)
+
+    {loaded_paths, loaded_modules} =
+      Mix.AppLoader.load_apps(apps, deps, config, {[], []}, fn {app, path}, {paths, mods} ->
+        paths = if path, do: [path | paths], else: paths
+        mods = if app_cache, do: [{app, Application.spec(app, :modules) || []} | mods], else: mods
+        {paths, mods}
+      end)
+
+    # We compute the diff as that will be more efficient
+    # than re-adding common paths several times
+    current_paths = :code.get_path()
+
+    if Keyword.get(config, :prune_code_paths, true) and "--no-prune-code-paths" not in args do
+      Code.delete_paths(current_paths -- loaded_paths)
+    end
+
+    Code.prepend_paths(loaded_paths -- current_paths, cache: true)
+
+    # Add the current compilation path. compile.elixir and compile.erlang
+    # will also add this path, but only if they run, so we always add it
+    # here too. Furthermore, we don't cache it as we may still write to it.
+    compile_path = to_charlist(Mix.Project.compile_path())
+    Code.prepend_path(compile_path)
+
+    {status, diagnostics} =
+      if "--no-compile" in args do
+        Mix.Task.reenable("compile.all")
+        {:noop, []}
+      else
+        # Build the project structure so we can write down compiled files.
+        Mix.Project.build_structure(config)
+
+        config
+        |> Mix.Task.Compiler.compilers()
+        |> Mix.Task.Compiler.run(args)
+      end
+
+    if status == :error and "--return-errors" not in args do
+      exit({:shutdown, 1})
+    end
+
+    if app_cache do
+      Mix.AppLoader.write_cache(app_cache, Map.new(loaded_modules))
+    end
+
+    if "--no-app-loading" not in args do
+      app = config[:app]
+
+      with {:ok, properties} <- Mix.AppLoader.load_app(app, "#{compile_path}/#{app}.app"),
+           false <- "--no-validate-compile-env" in args,
+           [_ | _] = compile_env <- properties[:compile_env],
+           {:error, message} <- Config.Provider.validate_compile_env(compile_env, false) do
+        Mix.raise(message)
+      end
+    end
+
+    {status, diagnostics}
+  end
+
+  @doc """
+  Returns all apps that should be available at compile time.
+  """
+  def compile_apps(config, args) do
+    project = Mix.Project.get!()
+
+    properties =
+      if function_exported?(project, :application, 0), do: project.application(), else: []
+
+    extra =
+      Keyword.get(properties, :included_applications, []) ++
+        Keyword.get(properties, :extra_applications, [])
+
+    {all, optional} =
+      Mix.Utils.project_apps(properties, config, extra, fn apps_opts ->
+        for {app, opts} <- apps_opts do
+          {app, if(Keyword.get(opts, :optional, false), do: :optional, else: :required)}
+        end
+      end)
+
+    if "--no-optional-deps" in args do
+      all -- optional
+    else
+      all
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/compile.app.ex b/lib/mix/lib/mix/tasks/compile.app.ex
index 97656c7da5b..003b1a82edc 100644
--- a/lib/mix/lib/mix/tasks/compile.app.ex
+++ b/lib/mix/lib/mix/tasks/compile.app.ex
@@ -1,187 +1,450 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Compile.App do
-  use Mix.Task
+  use Mix.Task.Compiler
 
   @recursive true
 
   @moduledoc """
-  Writes an .app file.
+  Writes a `.app` file.
 
-  An `.app` file is a file containing Erlang terms that defines
+  A `.app` file is a file containing Erlang terms that defines
   your application. Mix automatically generates this file based on
-  your `mix.exs` configuration. You can learn more about OTP
-  applications by seeing the documentation for the `Application`
-  module.
+  your `mix.exs` configuration.
 
-  In order to generate the `.app` file, Mix expects your application
-  to have both `:app` and `:version` keys. Furthermore, you can
-  configure the generated application by defining an `application`
-  function in your `mix.exs` with the following options:
+  In order to generate the `.app` file, Mix expects your project
+  to have both the `:app` and `:version` keys. Furthermore, you can
+  configure the generated application by defining an `application/0`
+  function in your `mix.exs` that returns a keyword list.
 
-    * `:applications` - all applications your application depends
-      on at runtime. For example, if your application depends on
-      Erlang's `:crypto`, it needs to be added to this list. Most
-      of your dependencies must be added as well (unless they're
-      a development or test dependency). Mix and other tools use this
-      list in order to properly boot your application dependencies
-      before starting the application itself.
+  The most commonly used keys are:
+
+    * `:extra_applications` - a list of OTP applications
+      your application depends on which are not included in `:deps`
+      (usually defined in `deps/0` in your `mix.exs`). For example,
+      here you can declare a dependency on applications that ship
+      with Erlang/OTP or Elixir, like `:crypto` or `:logger`.
+      Optional extra applications can be declared as a tuple, such
+      as `{:ex_unit, :optional}`. Mix guarantees all non-optional
+      applications are started before your application starts.
 
     * `:registered` - the name of all registered processes in the
       application. If your application defines a local GenServer
       with name `MyServer`, it is recommended to add `MyServer`
-      to this list. It is mostly useful to detect conflicts in
+      to this list. It is most useful in detecting conflicts
       between applications that register the same names.
 
-    * `:mod` - specify a module to invoke when the application
-      is started, it must be in the format `{Mod, args}` where
-      args is often an empty list. The module specified here must
-      implement the callbacks defined by the `Application`
-      module.
-
-    * `:env` - default values for the application environment.
+    * `:env` - the default values for the application environment.
       The application environment is one of the most common ways
-      to configure applications.
+      to configure applications. See the `Application` module for
+      mechanisms to read and write to the application environment.
 
-  Let's see an example `application` function:
+  For example:
 
       def application do
-        [mod: {MyApp, []},
-         env: [default: :value],
-         applications: [:crypto]]
+        [
+          extra_applications: [:logger, :crypto, ex_unit: :optional],
+          env: [key: :value],
+          registered: [MyServer]
+        ]
       end
 
-  Besides the options above, `.app` files also expects other
-  options like `:modules` and `:vsn`, but those are automatically
-  filled by Mix.
+  Other options include:
+
+    * `:applications` - all applications your application depends
+      on at runtime. By default, this list is automatically inferred
+      from your dependencies. Mix and other tools use the application
+      list in order to start your dependencies before starting the
+      application itself.
+
+    * `:mod` - specifies a module to invoke when the application
+      is started. It must be in the format `{Mod, args}` where
+      args is often an empty list. The module specified must
+      implement the callbacks defined by the `Application`
+      module.
+
+    * `:start_phases` - specifies a list of phases and their arguments
+      to be called after the application is started. See the "Phases"
+      section below.
+
+    * `:included_applications` - specifies a list of applications
+      that will be included in the application. It is the responsibility of
+      the primary application to start the supervision tree of all included
+      applications, as only the primary application will be started. A process
+      in an included application considers itself belonging to the
+      primary application.
+
+    * `:maxT` - specifies the maximum time the application is allowed to run, in
+      milliseconds. Applications are stopped if `:maxT` is reached, and their
+      top-level supervisor terminated with reason `:normal`. This threshold is
+      technically valid in any resource file, but it is only effective for
+      applications with a callback module. Defaults to `:infinity`.
+
+  Besides the options above, `.app` files also expect other options
+  like `:modules` and `:vsn`, but these are automatically added by Mix.
+  The complete list can be found on [Erlang's application
+  specification](https://www.erlang.org/doc/man/app).
+
+  From Elixir v1.17 onwards, the application .app file is also loaded
+  whenever the task runs.
 
   ## Command line options
 
     * `--force` - forces compilation regardless of modification times
+    * `--compile-path` - where to find `.beam` files and write the
+      resulting `.app` file, defaults to `Mix.Project.compile_path/0`
 
-  """
-  def run(args) do
-    {opts, _, _} = OptionParser.parse(args, switches: [force: :boolean])
+  ## Configuration
 
-    project = Mix.Project.get!
-    config  = Mix.Project.config
+    * `:reliable_dir_mtime` - this task relies on the operating system
+      changing the mtime on a directory whenever a file is added or removed.
+      You can set this option to `false` if your system does not provide
+      reliable mtimes. Defaults to `false` on Windows.
 
-    app     = Keyword.fetch!(config, :app)
-    version = Keyword.fetch!(config, :version)
+  ## Phases
 
-    validate_app(app)
-    validate_version(version)
+  Applications provide a start phases mechanism which will be called,
+  in order, for the application and all included applications. If a phase
+  is not defined for an included application, that application is skipped.
 
-    path = Mix.Project.compile_path
-    mods = modules_from(Path.wildcard('#{path}/*.beam')) |> Enum.sort
+  Let's see an example `MyApp.application/0` function:
 
-    target  = Path.join(path, "#{app}.app")
-    sources = Mix.Project.config_files
+      def application do
+        [
+          start_phases: [init: [], go: [], finish: []],
+          included_applications: [:my_included_app]
+        ]
+      end
 
-    if opts[:force] || Mix.Utils.stale?(sources, [target]) || modules_changed?(mods, target) do
-      best_guess = [
-        vsn: to_char_list(version),
-        modules: mods,
-        applications: []
-      ]
+  And an example `:my_included_app` defines on its `mix.exs` the function:
 
-      properties = if function_exported?(project, :application, 0) do
-        Keyword.merge(best_guess, project.application)
-      else
-        best_guess
+      def application do
+        [
+          mod: {MyIncludedApp, []},
+          start_phases: [go: []]
+        ]
       end
 
-      # Ensure we always prepend the standard application dependencies
-      properties = Keyword.update!(properties, :applications, fn apps ->
-        [:kernel, :stdlib, :elixir] ++ apps
-      end)
+  In this example, the order that the application callbacks are called in is:
+
+      Application.start(MyApp)
+      MyApp.start(:normal, [])
+      MyApp.start_phase(:init, :normal, [])
+      MyApp.start_phase(:go, :normal, [])
+      MyIncludedApp.start_phase(:go, :normal, [])
+      MyApp.start_phase(:finish, :normal, [])
+
+  """
 
-      properties = ensure_correct_properties(app, config, properties)
-      contents   = {:application, app, properties}
+  @impl true
+  def run(args) do
+    {opts, _, _} = OptionParser.parse(args, switches: [force: :boolean, compile_path: :string])
+    project = Mix.Project.get!()
+    config = Mix.Project.config()
+
+    app = Keyword.get(config, :app)
+    version = Keyword.get(config, :version)
+    validate_app!(app)
+    validate_version!(version)
+
+    compile_path = Keyword.get_lazy(opts, :compile_path, &Mix.Project.compile_path/0)
+    target = Path.join(compile_path, "#{app}.app")
+
+    # If configurations changed, we may have changed compile_env.
+    # If compile_path changed, we may have added or removed files.
+    # If the project changed, we may have changed other properties.
+    new_mtime =
+      Mix.Project.config_mtime()
+      |> max(Mix.Utils.last_modified(Mix.Project.project_file()))
+      |> max(Mix.Utils.last_modified(compile_path))
+
+    current_properties = current_app_properties(target)
+
+    {changed?, modules} =
+      cond do
+        opts[:force] || new_mtime > Mix.Utils.last_modified(target) ->
+          {true, nil}
+
+        Keyword.get(config, :reliable_dir_mtime, fn -> not match?({:win32, _}, :os.type()) end) ->
+          {false, nil}
+
+        true ->
+          modules = modules_from(compile_path)
+          {modules != Keyword.get(current_properties, :modules, []), modules}
+      end
 
-      Mix.Project.build_structure(config)
-      File.write!(target, :io_lib.format("~p.", [contents]))
+    if changed? do
+      properties =
+        [
+          description: to_charlist(config[:description] || app),
+          registered: [],
+          vsn: to_charlist(version)
+        ]
+        |> merge_project_application(project)
+        |> handle_extra_applications(config)
+        |> add_compile_env(current_properties)
+        |> add_modules(modules, compile_path)
+
+      contents =
+        case Mix.Utils.consultable({:application, app, properties}) do
+          {:ok, contents} ->
+            contents
+
+          {:error, term, reason} ->
+            Mix.raise(
+              "\"def application\" has a term which cannot be written to .app files: #{inspect(term)} (#{reason})"
+            )
+        end
+
+      :application.unload(app)
+      :application.load({:application, app, properties})
+
+      Mix.Project.ensure_structure()
+      File.write!(target, IO.chardata_to_string([contents, ?.]))
+      File.touch!(target, new_mtime)
+
+      # If we just created the .app file, it will have touched
+      # the directory mtime, so we need to reset it.
+      if current_properties == [] do
+        File.touch!(compile_path, new_mtime)
+      end
 
-      Mix.shell.info "Generated #{app}.app"
-      :ok
+      Mix.shell().info("Generated #{app} app")
+      {:ok, []}
     else
-      :noop
+      :application.load({:application, app, current_properties})
+      {:noop, []}
     end
   end
 
-  defp modules_changed?(mods, target) do
+  defp current_app_properties(target) do
     case :file.consult(target) do
-      {:ok, [ {:application, _app, properties} ]} ->
-        properties[:registered] == mods
-      _ ->
-        false
+      {:ok, [{:application, _app, properties}]} -> properties
+      _ -> []
     end
   end
 
-  defp validate_app(app) when is_atom(app), do: :ok
-  defp validate_app(_), do: raise(Mix.Error, message: "Expected :app to be an atom")
+  defp validate_app!(app) when is_atom(app), do: :ok
 
-  defp validate_version(version) do
-    unless is_binary(version) and match?({:ok, _}, Version.parse(version)) do
-      raise(Mix.Error, message: "Expected :version to be a SemVer version")
+  defp validate_app!(app) do
+    ensure_present!(:app, app)
+    Mix.raise("Expected :app to be an atom, got: #{inspect(app)}")
+  end
+
+  defp validate_version!(version) do
+    ensure_present!(:version, version)
+
+    if not (is_binary(version) and match?({:ok, _}, Version.parse(version))) do
+      Mix.raise(
+        "Expected :version to be a valid Version, got: #{inspect(version)} (see the Version module for more information)"
+      )
     end
   end
 
-  defp modules_from(beams) do
-    Enum.map beams, &(&1 |> Path.basename |> Path.rootname(".beam") |> String.to_atom)
+  defp ensure_present!(name, nil) do
+    Mix.raise("Please ensure mix.exs file has the #{inspect(name)} in the project definition")
   end
 
-  defp ensure_correct_properties(app, config, properties) do
-    properties
-    |> Keyword.put_new(:description, to_char_list(config[:description] || app))
-    |> Keyword.put_new(:registered, [])
-    |> validate_properties
+  defp ensure_present!(_name, _val), do: :ok
+
+  defp modules_from(path) do
+    case File.ls(path) do
+      {:ok, entries} ->
+        Enum.sort(
+          for entry <- entries,
+              String.ends_with?(entry, ".beam"),
+              do: entry |> binary_part(0, byte_size(entry) - 5) |> String.to_atom()
+        )
+
+      {:error, _} ->
+        []
+    end
+  end
+
+  defp merge_project_application(best_guess, project) do
+    if function_exported?(project, :application, 0) do
+      project_application = project.application()
+
+      if not Keyword.keyword?(project_application) do
+        Mix.raise(
+          "Application configuration returned from application/0 should be a keyword list"
+        )
+      end
+
+      Keyword.merge(best_guess, validate_properties!(project_application))
+    else
+      best_guess
+    end
   end
 
-  defp validate_properties(properties) do
-    Enum.each properties, fn
+  defp validate_properties!(properties) do
+    Enum.each(properties, fn
       {:description, value} ->
-        unless is_list(value), do:
-          invalid "Application description (:description) is not a character list (got #{inspect value})"
+        if not is_list(value) do
+          Mix.raise(
+            "Application description (:description) is not a character list, got: " <>
+              inspect(value)
+          )
+        end
+
       {:id, value} ->
-        unless is_list(value), do:
-          invalid "Application id (:id) is not a character list (got #{inspect value} instead)"
+        if not is_list(value) do
+          Mix.raise("Application ID (:id) is not a character list, got: " <> inspect(value))
+        end
+
       {:vsn, value} ->
-        unless is_list(value), do:
-          invalid "Application vsn (:vsn) is not a character list (got #{inspect value} instead)"
+        if not is_list(value) do
+          Mix.raise("Application vsn (:vsn) is not a character list, got: " <> inspect(value))
+        end
+
       {:maxT, value} ->
-        unless value == :infinity or is_integer(value), do:
-          invalid "Application maximum time (:maxT) is not an integer or :infinity (got #{inspect value} instead)"
+        if not (value == :infinity or is_integer(value)) do
+          Mix.raise(
+            "Application maximum time (:maxT) is not an integer or :infinity, got: " <>
+              inspect(value)
+          )
+        end
+
       {:modules, value} ->
-        unless is_list(value) and Enum.all?(value, &is_atom(&1)), do:
-          invalid "Application modules (:modules) should be a list of atoms (got #{inspect value} instead)"
+        if not (is_list(value) and Enum.all?(value, &is_atom(&1))) do
+          Mix.raise(
+            "Application modules (:modules) should be a list of atoms, got: " <> inspect(value)
+          )
+        end
+
       {:registered, value} ->
-        unless is_list(value) and Enum.all?(value, &is_atom(&1)), do:
-          invalid "Application registered processes (:registered) should be a list of atoms (got #{inspect value} instead)"
+        if not (is_list(value) and Enum.all?(value, &is_atom(&1))) do
+          Mix.raise(
+            "Application registered processes (:registered) should be a list of atoms, got: " <>
+              inspect(value)
+          )
+        end
+
       {:included_applications, value} ->
-        unless is_list(value) and Enum.all?(value, &is_atom(&1)), do:
-          invalid "Application included applications (:included_applications) should be a list of atoms (got #{inspect value} instead)"
+        if not (is_list(value) and Enum.all?(value, &is_atom(&1))) do
+          Mix.raise(
+            "Application included applications (:included_applications) should be a list of atoms, got: " <>
+              inspect(value)
+          )
+        end
+
+      {:extra_applications, value} ->
+        if not (is_list(value) and Enum.all?(value, &typed_app?(&1))) do
+          Mix.raise(
+            "Application extra applications (:extra_applications) should be a list of atoms or " <>
+              "{app, :required | :optional} pairs, got: " <> inspect(value)
+          )
+        end
+
       {:applications, value} ->
-        unless is_list(value) and Enum.all?(value, &is_atom(&1)), do:
-          invalid "Application dependencies (:applications) should be a list of atoms (got #{inspect value} instead)"
+        if not (is_list(value) and Enum.all?(value, &typed_app?(&1))) do
+          Mix.raise(
+            "Application applications (:applications) should be a list of atoms or " <>
+              "{app, :required | :optional} pairs, got: " <> inspect(value)
+          )
+        end
+
       {:env, value} ->
-        unless Keyword.keyword?(value), do:
-          invalid "Application dependencies (:env) should be a keyword list (got #{inspect value} instead)"
+        if not Keyword.keyword?(value) do
+          Mix.raise(
+            "Application environment (:env) should be a keyword list, got: " <> inspect(value)
+          )
+        end
+
       {:start_phases, value} ->
-        unless Keyword.keyword?(value), do:
-          invalid "Application start phases (:start_phases) should be a keyword list (got #{inspect value} instead)"
+        if not Keyword.keyword?(value) do
+          Mix.raise(
+            "Application start phases (:start_phases) should be a keyword list, got: " <>
+              inspect(value)
+          )
+        end
+
       {:mod, []} ->
         :ok
+
       {:mod, {module, _args}} when is_atom(module) ->
         :ok
+
       {:mod, value} ->
-        invalid "Application callback module (:mod) should be either [] or {module, start_args} (got #{inspect value} instead)"
+        Mix.raise(
+          "Application callback module (:mod) should be either [] or {module, start_args}, got: " <>
+            inspect(value)
+        )
+
       _ ->
         :ok
+    end)
+
+    properties
+  end
+
+  defp typed_app?(app) when is_atom(app), do: true
+  defp typed_app?({app, type}) when is_atom(app) and type in [:required, :optional], do: true
+  defp typed_app?(_), do: false
+
+  defp add_compile_env(properties, current_properties) do
+    # If someone calls compile.elixir and then compile.app across two
+    # separate OS calls, then the compile_env won't be properly reflected.
+    # This is ok because compile_env is not used for correctness. It is
+    # simply to catch possible errors early.
+    case Mix.ProjectStack.compile_env(nil) do
+      nil -> Keyword.take(current_properties, [:compile_env]) ++ properties
+      [] -> properties
+      compile_env -> Keyword.put(properties, :compile_env, compile_env)
+    end
+  end
+
+  defp add_modules(properties, modules, compile_path) do
+    Keyword.put_new_lazy(properties, :modules, fn -> modules || modules_from(compile_path) end)
+  end
+
+  defp handle_extra_applications(properties, config) do
+    {extra, properties} = Keyword.pop(properties, :extra_applications, [])
+
+    if extra != [] and Keyword.has_key?(properties, :applications) do
+      Mix.shell().error(
+        "both :extra_applications and :applications was found in your mix.exs. " <>
+          "You most likely want to remove the :applications key, as all applications are derived from your dependencies"
+      )
     end
 
+    {all, optional} =
+      Mix.Utils.project_apps(properties, config, extra, fn apps_opts ->
+        apps_from_runtime_prod_deps(properties, apps_opts)
+      end)
+
     properties
+    |> Keyword.put(:applications, all)
+    |> Keyword.put(:optional_applications, optional)
   end
 
-  defp invalid(message) do
-    Mix.raise message
+  defp apps_from_runtime_prod_deps(properties, apps_opts) do
+    included_applications = Keyword.get(properties, :included_applications, [])
+
+    for {app, opts} <- apps_opts,
+        runtime_app?(opts),
+        app not in included_applications,
+        do: {app, if(Keyword.get(opts, :optional, false), do: :optional, else: :required)}
+  end
+
+  defp runtime_app?(opts) do
+    Keyword.get(opts, :runtime, true) and Keyword.get(opts, :app, true) and matching_only?(opts) and
+      matching_target?(opts)
+  end
+
+  defp matching_only?(opts) do
+    case Keyword.fetch(opts, :only) do
+      {:ok, value} -> Mix.env() in List.wrap(value)
+      :error -> true
+    end
+  end
+
+  defp matching_target?(opts) do
+    case Keyword.fetch(opts, :targets) do
+      {:ok, value} -> Mix.target() in List.wrap(value)
+      :error -> true
+    end
   end
 end
diff --git a/lib/mix/lib/mix/tasks/compile.elixir.ex b/lib/mix/lib/mix/tasks/compile.elixir.ex
index f36d0c4448c..b39f1e5a4c1 100644
--- a/lib/mix/lib/mix/tasks/compile.elixir.ex
+++ b/lib/mix/lib/mix/tasks/compile.elixir.ex
@@ -1,100 +1,229 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Compile.Elixir do
-  use Mix.Task
+  use Mix.Task.Compiler
 
   @recursive true
-  @manifest ".compile.elixir"
+  @manifest "compile.elixir"
 
   @moduledoc """
   Compiles Elixir source files.
 
-  Elixir is smart enough to recompile only files that changed
+  Elixir is smart enough to recompile only files that have changed
   and their dependencies. This means if `lib/a.ex` is invoking
-  a function defined over `lib/b.ex`, whenever `lib/b.ex` changes,
-  `lib/a.ex` is also recompiled.
+  a function defined over `lib/b.ex` at compile time, whenever
+  `lib/b.ex` changes, `lib/a.ex` is also recompiled. More details
+  about dependencies between files can be found in the documentation
+  of [`mix xref`](`Mix.Tasks.Xref`).
+
+  Note Elixir considers a file as changed if its source file has
+  changed on disk since the last compilation AND its contents are
+  no longer the same.
+
+  ## `@external_resource`
+
+  If a module depends on external files, those can be annotated
+  with the `@external_resource` module attribute. If these files
+  change, the Elixir module is automatically recompiled.
+
+  ## `__mix_recompile__?/0`
+
+  A module may export a `__mix_recompile__?/0` function that can
+  cause the module to be recompiled using custom rules. For example,
+  to recompile whenever a file is changed in a given directory, you
+  can use a combination of `@external_resource` for existing files
+  and a `__mix_recompile__?/0` check to verify when new entries are
+  added to the directory itself:
+
+      defmodule MyModule do
+        paths = Path.wildcard("*.txt")
+        @paths_hash :erlang.md5(paths)
+
+        for path <- paths do
+          @external_resource path
+        end
 
-  Note it is important to recompile a file dependencies because
-  often there are compilation time dependencies in between them.
+        def __mix_recompile__?() do
+          Path.wildcard("*.txt") |> :erlang.md5() != @paths_hash
+        end
+      end
+
+  Compiler calls `__mix_recompile__?/0` for every module being
+  compiled (or previously compiled) and thus it is very important
+  to do there as little work as possible to not slow down the
+  compilation.
+
+  If module has `@compile {:autoload, false}`, `__mix_recompile__?/0` will
+  not be used.
 
   ## Command line options
 
-    * `--force`         - forces compilation regardless of modification times
-    * `--no-docs`       - do not attach documentation to compiled modules
-    * `--no-debug-info` - do not attach debug info to compiled modules
-    * `--ignore-module-conflict`
-                        - do not emit warnings if a module was previously defined
-    * `--warnings-as-errors`
-                        - treat warnings as errors and return a non-zero exit code
+    * `--all-warnings` (`--no-all-warnings`) - prints all warnings, including previous compilations
+      (default is true except on errors)
+    * `--docs` (`--no-docs`) - attaches (or not) documentation to compiled modules
+    * `--debug-info` (`--no-debug-info`) - attaches (or not) debug info to compiled modules
+    * `--force` - forces compilation regardless of modification times
+    * `--ignore-module-conflict` - does not emit warnings if a module was previously defined
+    * `--long-compilation-threshold N` - sets the "long compilation" threshold
+      (in seconds) to `N` (see the docs for `Kernel.ParallelCompiler.compile/2`)
+    * `--long-verification-threshold N` - sets the "long verification" threshold
+      (in seconds) to `N` (see the docs for `Kernel.ParallelCompiler.compile/2`)
+    * `--no-verification` - disables code verification, such as unused functions,
+      deprecation warnings, and type checking. It must be used solely for debugging
+      alongside `MIX_DEBUG=1`
+    * `--no-check-cwd` - (since v1.19.2) Elixir stores absolute paths in .beam files, which means
+      that relocating the project root triggers a full build. Pass this option if you don't want
+      the current working directory to be checked
+    * `--purge-consolidation-path-if-stale PATH` - deletes and purges modules in the
+      given protocol consolidation path if compilation is required
+    * `--profile` - if set to `time`, outputs timing information of compilation steps
+    * `--tracer` - adds a compiler tracer in addition to any specified in the `mix.exs` file
+    * `--verbose` - prints each file being compiled
+    * `--warnings-as-errors` - exit with non-zero status if compilation has one or more warnings
 
   ## Configuration
 
     * `:elixirc_paths` - directories to find source files.
       Defaults to `["lib"]`.
 
-    * `:elixirc_options` - compilation options that apply
-      to Elixir's compiler, they are: `:ignore_module_conflict`,
-      `:docs` and `:debug_info`. By default, uses the same
-      behaviour as Elixir.
-
-  """
+    * `:elixirc_options` - compilation options that apply to Elixir's compiler.
+      It supports many of the options above  plus the options listed in
+      `Code.put_compiler_option/2`. In case conflicting options are given,
+      the ones given through the command line are used.
 
-  @switches [force: :boolean, docs: :boolean, warnings_as_errors: :boolean,
-             ignore_module_conflict: :boolean, debug_info: :boolean]
+    * `[xref: [exclude: ...]]` - a list of `module` or `{module, function, arity}`
+      that should not be warned on in case on undefined modules or undefined
+      application warnings.
 
-  @doc """
-  Runs this task.
   """
+
+  @switches [
+    force: :boolean,
+    docs: :boolean,
+    consolidate_protocols: :boolean,
+    warnings_as_errors: :boolean,
+    ignore_module_conflict: :boolean,
+    debug_info: :boolean,
+    verbose: :boolean,
+    long_compilation_threshold: :integer,
+    long_verification_threshold: :integer,
+    purge_consolidation_path_if_stale: :string,
+    profile: :string,
+    all_warnings: :boolean,
+    verification: :boolean,
+    tracer: :keep,
+    check_cwd: :boolean
+  ]
+
+  @impl true
   def run(args) do
     {opts, _, _} = OptionParser.parse(args, switches: @switches)
+    {tracers, opts} = pop_tracers(opts)
 
-    project = Mix.Project.config
-    srcs = project[:elixirc_paths]
+    project = Mix.Project.config()
     dest = Mix.Project.compile_path(project)
+    srcs = project[:elixirc_paths]
+
+    if not (is_list(srcs) and Enum.all?(srcs, &is_binary/1)) do
+      Mix.raise(":elixirc_paths should be a list of string paths, got: #{inspect(srcs)}")
+    end
 
     manifest = manifest()
-    configs  = Mix.Project.config_files ++ Mix.Tasks.Compile.Erlang.manifests
+    base = xref_exclude_opts(project[:elixirc_options] || [], project)
+    cache_key = {base, srcs, "--no-optional-deps" in args}
+
+    opts =
+      base
+      |> Keyword.merge(opts)
+      |> tracers_opts(tracers)
+      |> profile_opts()
+
+    opts =
+      if "--no-protocol-consolidation" in args do
+        # TODO: Deprecate me on Elixir v1.23
+        Keyword.put(opts, :consolidate_protocols, false)
+      else
+        opts ++ Keyword.take(project, [:consolidate_protocols])
+      end
+
+    # Having compilations racing with other is most undesired,
+    # so we wrap the compiler in a lock.
+
+    with_logger_app(project, fn ->
+      Mix.Project.with_build_lock(project, fn ->
+        Mix.Compilers.Elixir.compile(
+          manifest,
+          srcs,
+          dest,
+          cache_key,
+          Mix.Tasks.Compile.Erlang.manifests(),
+          Mix.Tasks.Compile.Erlang.modules(),
+          opts
+        )
+      end)
+    end)
+  end
 
-    force = opts[:force] || local_deps_changed?(manifest)
-              || Mix.Utils.stale?(configs, [manifest])
+  @impl true
+  def manifests, do: [manifest()]
+  defp manifest, do: Path.join(Mix.Project.manifest_path(), @manifest)
 
-    result = Mix.Compilers.Elixir.compile(manifest, srcs, [:ex], dest, force, fn ->
-      Code.prepend_path(dest)
-      set_compiler_opts(project, opts, [])
-    end)
+  @impl true
+  def diagnostics do
+    Mix.Compilers.Elixir.diagnostics(manifest())
+  end
 
-    # The Mix.Dep.Lock keeps all the project dependencies. Since Elixir
-    # is a dependency itself, we need to touch the lock so the current
-    # Elixir version, used to compile the files above, is properly stored.
-    unless result == :noop, do: Mix.Dep.Lock.touch
-    result
+  @impl true
+  def clean do
+    dest = Mix.Project.compile_path()
+    Mix.Compilers.Elixir.clean(manifest(), dest)
   end
 
-  @doc """
-  Returns Elixir manifests.
-  """
-  def manifests, do: [manifest]
-  defp manifest, do: Path.join(Mix.Project.manifest_path, @manifest)
+  # Run this operation in compile.elixir as the compiler can be called directly
+  defp with_logger_app(config, fun) do
+    app = Keyword.fetch!(config, :app)
+    logger_config_app = Application.get_env(:logger, :compile_time_application)
+
+    try do
+      Application.put_env(:logger, :compile_time_application, app)
+      fun.()
+    after
+      Application.put_env(:logger, :compile_time_application, logger_config_app)
+    end
+  end
 
-  @doc """
-  Cleans up compilation artifacts.
-  """
-  def clean do
-    Mix.Compilers.Elixir.clean(manifest())
+  defp xref_exclude_opts(opts, project) do
+    exclude = List.wrap(project[:xref][:exclude])
+
+    if exclude == [] do
+      opts
+    else
+      Keyword.update(opts, :no_warn_undefined, exclude, &(List.wrap(&1) ++ exclude))
+    end
   end
 
-  defp set_compiler_opts(project, opts, extra) do
-    opts = Dict.take(opts, Code.available_compiler_options)
-    opts = Keyword.merge(project[:elixirc_options] || [], opts)
-    Code.compiler_options Keyword.merge(opts, extra)
+  defp pop_tracers(opts) do
+    case Keyword.pop_values(opts, :tracer) do
+      {[], opts} ->
+        {[], opts}
+
+      {tracers, opts} ->
+        {Enum.map(tracers, &Module.concat([&1])), opts}
+    end
   end
 
-  defp local_deps_changed?(manifest) do
-    manifest = Path.absname(manifest)
+  defp tracers_opts(opts, tracers) do
+    tracers = tracers ++ Code.get_compiler_option(:tracers)
+    Keyword.update(opts, :tracers, tracers, &(tracers ++ &1))
+  end
 
-    Enum.any?(Mix.Dep.children([]), fn(dep) ->
-      not dep.scm.fetchable? and Mix.Dep.in_dependency(dep, fn(_) ->
-        files = Mix.Project.config_files ++ Mix.Tasks.Compile.manifests
-        Mix.Utils.stale?(files, [manifest])
-      end)
-    end)
+  defp profile_opts(opts) do
+    case Keyword.fetch(opts, :profile) do
+      {:ok, "time"} -> Keyword.put(opts, :profile, :time)
+      {:ok, _} -> Keyword.delete(opts, :profile)
+      :error -> opts
+    end
   end
 end
diff --git a/lib/mix/lib/mix/tasks/compile.erlang.ex b/lib/mix/lib/mix/tasks/compile.erlang.ex
index 0e2da67b4cd..2261c180cb0 100644
--- a/lib/mix/lib/mix/tasks/compile.erlang.ex
+++ b/lib/mix/lib/mix/tasks/compile.erlang.ex
@@ -1,28 +1,29 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Compile.Erlang do
-  use Mix.Task
-  import Mix.Compilers.Erlang
+  use Mix.Task.Compiler
+  alias Mix.Compilers.Erlang
 
   @recursive true
-  @manifest ".compile.erlang"
+  @manifest "compile.erlang"
+  @switches [force: :boolean, verbose: :boolean, all_warnings: :boolean]
 
   @moduledoc """
-  Compile Erlang source files.
+  Compiles Erlang source files.
 
   When this task runs, it will first check the modification times of
-  all files to be compiled and if they haven't been
-  changed since the last compilation, it will not compile
-  them. If any of them have changed, it compiles
-  everything.
-
-  For this reason, the task touches your `:compile_path`
-  directory and sets the modification time to the current
-  time and date at the end of each compilation. You can
-  force compilation regardless of modification times by passing
-  the `--force` option.
+  all files to be compiled and if they haven't been changed since the
+  last compilation, it will not compile them. If any of them have changed,
+  it compiles everything.
 
   ## Command line options
 
+    * `--all-warnings` (`--no-all-warnings`) - prints all warnings, including previous compilations
+      (default is true except on errors)
     * `--force` - forces compilation regardless of modification times
+    * `--verbose` - prints verbose output
 
   ## Configuration
 
@@ -36,74 +37,139 @@ defmodule Mix.Tasks.Compile.Erlang do
     * `:erlc_include_path` - directory for adding include files.
       Defaults to `"include"`.
 
-    * `:erlc_options` - compilation options that apply to Erlang's compiler.
-      `:debug_info` is enabled by default.
+    * `:erlc_options` - compilation options that apply to Erlang's
+      compiler. Defaults to `[]`.
 
-      There are many available options here:
-      http://www.erlang.org/doc/man/compile.html#file-2
-  """
+      For a complete list of options, see `:compile.file/2`.
+      The option `:debug_info` is always added to the end of it.
+      You can disable that using:
+
+          erlc_options: [debug_info: false]
 
-  @doc """
-  Runs this task.
   """
+
+  @impl true
   def run(args) do
-    {opts, _, _} = OptionParser.parse(args, switches: [force: :boolean])
+    {opts, _, _} = OptionParser.parse(args, switches: @switches)
 
-    project      = Mix.Project.config
-    source_paths = project[:erlc_paths]
-    include_path = to_erl_file project[:erlc_include_path]
-    compile_path = to_erl_file Mix.Project.compile_path(project)
-    files        = Mix.Utils.extract_files(source_paths, [:erl])
+    project = Mix.Project.config()
 
+    Mix.Project.with_build_lock(project, fn ->
+      source_paths = project[:erlc_paths]
+      Mix.Compilers.Erlang.assert_valid_erlc_paths(source_paths)
+      files = Mix.Utils.extract_files(source_paths, [:erl])
+      do_run(files, opts, project, source_paths)
+    end)
+  end
+
+  defp do_run([], _, _, _), do: {:noop, []}
+
+  defp do_run(files, opts, project, source_paths) do
+    include_path = Erlang.to_erl_file(project[:erlc_include_path])
+    compile_path = Erlang.to_erl_file(Mix.Project.compile_path(project))
     erlc_options = project[:erlc_options] || []
-    erlc_options = erlc_options ++ [{:outdir, compile_path}, {:i, include_path}, :report]
-    erlc_options = Enum.map erlc_options, fn
-      {kind, dir} when kind in [:i, :outdit] ->
-        {kind, to_erl_file(dir)}
-      opt ->
-        opt
+
+    if not is_list(erlc_options) do
+      Mix.raise(":erlc_options should be a list of options, got: #{inspect(erlc_options)}")
     end
 
-    tuples = files
-             |> scan_sources(include_path, source_paths)
-             |> sort_dependencies
-             |> Enum.map(&annotate_target(&1, compile_path, opts[:force]))
+    erlc_options =
+      erlc_options ++ [:debug_info, :return, :report, outdir: compile_path, i: include_path]
+
+    erlc_options =
+      Enum.map(erlc_options, fn
+        {kind, dir} when kind in [:i, :outdir] -> {kind, Erlang.to_erl_file(dir)}
+        opt -> opt
+      end)
 
-    Mix.Compilers.Erlang.compile(manifest(), tuples, fn
-      input, _output ->
-        file = to_erl_file(Path.rootname(input, ".erl"))
-        :compile.file(file, erlc_options)
+    compile_path = Path.relative_to(compile_path, File.cwd!())
+
+    {erls, tuples} =
+      Enum.unzip(scan_sources(files, include_path, source_paths, compile_path, opts))
+
+    opts = [parallel: MapSet.new(find_parallel(erls))] ++ opts
+
+    Erlang.compile_entries(manifest(), tuples, :erl, :beam, opts, fn input, _output ->
+      # We're purging the module because a previous compiler (for example, Phoenix)
+      # might have already loaded the previous version of it.
+      module = input |> Path.basename(".erl") |> String.to_atom()
+      :code.purge(module)
+      :code.delete(module)
+
+      path = Path.rootname(input, ".erl")
+      file = Erlang.to_erl_file(path)
+
+      case :compile.file(file, erlc_options) do
+        :error ->
+          message =
+            "Compiling Erlang file #{inspect(path)} failed, probably because of invalid :erlc_options"
+
+          Mix.raise(message)
+
+        result ->
+          result
+      end
     end)
   end
 
-  @doc """
-  Returns Erlang manifests.
-  """
-  def manifests, do: [manifest]
-  defp manifest, do: Path.join(Mix.Project.manifest_path, @manifest)
+  @impl true
+  def manifests, do: [manifest()]
+  defp manifest, do: Path.join(Mix.Project.manifest_path(), @manifest)
 
-  @doc """
-  Cleans up compilation artifacts.
-  """
+  @impl true
+  def diagnostics do
+    Mix.Compilers.Erlang.diagnostics(manifest())
+  end
+
+  @impl true
   def clean do
     Mix.Compilers.Erlang.clean(manifest())
   end
 
+  @doc false
+  def modules do
+    for output <- Mix.Compilers.Erlang.outputs(manifest()) do
+      output
+      |> Path.basename()
+      |> Path.rootname()
+      |> String.to_atom()
+    end
+  end
+
   ## Internal helpers
 
-  defp scan_sources(files, include_path, source_paths) do
+  defp scan_sources(files, include_path, source_paths, compile_path, opts) do
     include_paths = [include_path | source_paths]
-    Enum.reduce(files, [], &scan_source(&2, &1, include_paths)) |> Enum.reverse
+
+    files
+    |> Task.async_stream(&scan_source(&1, include_paths, compile_path, opts),
+      timeout: :infinity,
+      ordered: false
+    )
+    |> Enum.flat_map(fn
+      {:ok, {:ok, erl_file, target_tuple}} -> [{erl_file, target_tuple}]
+      {:ok, :error} -> []
+    end)
   end
 
-  defp scan_source(acc, file, include_paths) do
-    erl_file = %{file: file, module: module_from_artifact(file),
-                 behaviours: [], compile: [], includes: [], invalid: false}
-    case :epp.parse_file(to_erl_file(file), include_paths, []) do
+  defp scan_source(file, include_paths, compile_path, opts) do
+    erl_file = %{
+      file: file,
+      module: module_from_artifact(file),
+      behaviours: [],
+      compile: [],
+      includes: [],
+      invalid: false
+    }
+
+    case :epp.parse_file(Erlang.to_erl_file(file), include_paths, []) do
       {:ok, forms} ->
-        [List.foldl(tl(forms), erl_file, &do_form(file, &1, &2)) | acc]
+        erl_file = List.foldl(tl(forms), erl_file, &do_form(file, &1, &2))
+        target_tuple = annotate_target(erl_file, compile_path, opts[:force])
+        {:ok, erl_file, target_tuple}
+
       {:error, _error} ->
-        acc
+        :error
     end
   end
 
@@ -111,51 +177,52 @@ defmodule Mix.Tasks.Compile.Erlang do
     case form do
       {:attribute, _, :file, {include_file, _}} when file != include_file ->
         if File.regular?(include_file) do
-          %{erl | includes: [include_file|erl.includes]}
+          %{erl | includes: [include_file | erl.includes]}
         else
           erl
         end
+
       {:attribute, _, :behaviour, behaviour} ->
-        %{erl | behaviours: [behaviour|erl.behaviours]}
+        %{erl | behaviours: [behaviour | erl.behaviours]}
+
+      {:attribute, _, :behavior, behaviour} ->
+        %{erl | behaviours: [behaviour | erl.behaviours]}
+
+      {:attribute, _, :compile, value} when is_list(value) ->
+        %{erl | compile: value ++ erl.compile}
+
       {:attribute, _, :compile, value} ->
-        %{erl | compile: [value|erl.compile]}
+        %{erl | compile: [value | erl.compile]}
+
       _ ->
         erl
     end
   end
 
-  defp sort_dependencies(erls) do
-    graph = :digraph.new
+  defp find_parallel(erls) do
+    serial = MapSet.new(find_dependencies(erls))
 
-    for erl <- erls do
-      :digraph.add_vertex(graph, erl.module, erl)
-    end
-
-    for erl <- erls do
-      for b <- erl.behaviours, do: :digraph.add_edge(graph, b, erl.module)
-      for c <- erl.compile do
-        case c do
-          {:parse_transform, transform} -> :digraph.add_edge(graph, transform, erl.module)
-          _ -> :ok
-        end
-      end
-    end
+    erls
+    |> Enum.reject(&(&1.module in serial))
+    |> Enum.map(& &1.file)
+  end
 
-    result =
-      case :digraph_utils.topsort(graph) do
-        false -> erls
-        mods  ->
-          for m <- mods, do: elem(:digraph.vertex(graph, m), 1)
-      end
+  defp find_dependencies(erls) do
+    Enum.flat_map(erls, fn erl ->
+      transforms =
+        Enum.flat_map(erl.compile, fn
+          {:parse_transform, transform} -> [transform]
+          _ -> []
+        end)
 
-    :digraph.delete(graph)
-    result
+      transforms ++ erl.behaviours
+    end)
   end
 
   defp annotate_target(erl, compile_path, force) do
-    beam = Path.join(compile_path, "#{erl.module}#{:code.objfile_extension}")
+    beam = Path.join(compile_path, "#{erl.module}.beam")
 
-    if force || Mix.Utils.stale?([erl.file|erl.includes], [beam]) do
+    if force || Mix.Utils.stale?([erl.file | erl.includes], [beam]) do
       {:stale, erl.file, beam}
     else
       {:ok, erl.file, beam}
@@ -163,6 +230,6 @@ defmodule Mix.Tasks.Compile.Erlang do
   end
 
   defp module_from_artifact(artifact) do
-    artifact |> Path.basename |> Path.rootname
+    artifact |> Path.basename() |> Path.rootname() |> String.to_atom()
   end
 end
diff --git a/lib/mix/lib/mix/tasks/compile.ex b/lib/mix/lib/mix/tasks/compile.ex
index d3faeaac587..254691669b5 100644
--- a/lib/mix/lib/mix/tasks/compile.ex
+++ b/lib/mix/lib/mix/tasks/compile.ex
@@ -1,99 +1,233 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Compile do
   use Mix.Task
 
-  @shortdoc "Compile source files"
-  @recursive true
+  @shortdoc "Compiles source files"
+
+  @moduledoc ~S"""
+  The main entry point to compile source files.
 
-  @moduledoc """
-  A meta task that compiles source files.
+  It simply runs the compilers registered in your project and returns
+  a tuple with the compilation status and a list of diagnostics.
 
-  It simply runs the compilers registered in your project. At
-  the end of compilation it ensures load paths are set.
+  Before compiling code, it performs a series of checks to ensure all
+  dependencies are compiled and the project is up to date. Then the
+  code path of your Elixir system is pruned to only contain the dependencies
+  and applications that you have explicitly listed in your `mix.exs`.
 
   ## Configuration
 
-    * `:compilers` - compilers to run, defaults to:
-      `[:leex, :yeec, :erlang, :elixir, :app]`
+    * `:compilers` - compilers to run, defaults to `Mix.compilers/0`,
+      which are `[:erlang, :elixir, :app]`.
+
+    * `:consolidate_protocols` - when `true`, runs protocol
+      consolidation after compiling Elixir. The default value is `true`.
+
+    * `:build_path` - the directory where build artifacts
+      should be written to. This option is intended only for
+      child apps within a larger umbrella application so that
+      each child app can use the common `_build` directory of
+      the parent umbrella. In a non-umbrella context, configuring
+      this has undesirable side-effects (such as skipping some
+      compiler checks) and should be avoided.
+
+    * `:prune_code_paths` - prune code paths before compilation. When true
+      (default), this prunes code paths of applications that are not listed
+      in the project file with dependencies.  When false, this keeps the
+      entirety of Erlang/OTP available when the project starts, including
+      the paths set by the code loader from the `ERL_LIBS` environment as
+      well as explicitly listed by providing `-pa` and `-pz` options
+      to Erlang.
+
+  ## Compilers
+
+  To see documentation for each specific compiler, you must
+  invoke `help` directly for the compiler command:
+
+      $ mix help compile.elixir
+      $ mix help compile.erlang
+
+  You can get a list of all compilers by running:
+
+      $ mix compile --list
 
   ## Command line options
 
-    * `--list`          - list all enabled compilers
-    * `--no-deps-check` - skip checking of dependencies
-    * `--force`         - force compilation
+    * `--all-warnings` (`--no-all-warnings`) - prints all warnings, including previous compilations
+      (default is true except on errors)
+    * `--erl-config` - path to an Erlang term file that will be loaded as Mix config
+    * `--force` - forces compilation. You can also specify `--force-#{compiler}` for each compiler
+      invoked to force specifically that compiler to run (it requires the compiler to respect the
+      `--force` option, which is advised)
+    * `--list` - lists all enabled compilers
+    * `--listeners` - starts Mix listeners (they are started by default,
+      unless `--no-listeners` or `--no-deps-check` are given)
+    * `--no-app-loading` - does not load .app resource file after compilation
+    * `--no-archives-check` - skips checking of archives
+    * `--no-compile` - does not actually compile, only loads code and perform checks
+    * `--no-deps-check` - skips checking of dependencies
+    * `--no-elixir-version-check` - does not check Elixir version
+    * `--no-listeners` - does not start Mix listeners
+    * `--no-optional-deps` - does not compile or load optional deps. Useful for testing
+      if a library still successfully compiles without optional dependencies (which is the
+      default case with dependencies)
+    * `--no-prune-code-paths` - do not prune code paths before compilation, this keeps
+      the entirety of Erlang/OTP available when the project starts
+    * `--no-protocol-consolidation` - skips protocol consolidation
+    * `--no-validate-compile-env` - does not validate the application compile environment
+    * `--return-errors` - returns error status and diagnostics instead of exiting on error
+    * `--warnings-as-errors` - exit with non-zero status if compilation has one or more
+      warnings. Only concerns compilation warnings from the project, not its dependencies.
 
   """
-  def run(["--list"]) do
-    Mix.Task.load_all
 
-    shell   = Mix.shell
-    modules = Mix.Task.all_modules
+  @deprecated "Use Mix.Task.Compiler.compilers/1 instead"
+  defdelegate compilers(config \\ Mix.Project.config()), to: Mix.Task.Compiler
 
-    docs = for module <- modules,
-               task = Mix.Task.task_name(module),
-               match?("compile." <> _, task),
-               doc = Mix.Task.moduledoc(module) do
-      {task, first_line(doc)}
-    end
+  @impl true
+  def run(["--list"]) do
+    # Loadpaths without checks because compilers may be defined in deps.
+    args = [
+      "--no-elixir-version-check",
+      "--no-deps-check",
+      "--no-archives-check",
+      "--no-listeners"
+    ]
+
+    Mix.Task.run("loadpaths", args)
+    Mix.Task.reenable("loadpaths")
+    Mix.Task.reenable("deps.loadpaths")
+
+    # Compilers are tasks, so load all tasks available.
+    _ = Mix.Task.load_all()
+
+    shell = Mix.shell()
+    modules = Mix.Task.all_modules()
+
+    docs =
+      for module <- modules,
+          task = Mix.Task.task_name(module),
+          match?("compile." <> _, task),
+          doc = Mix.Task.moduledoc(module) do
+        {task, first_line(doc)}
+      end
 
-    max = Enum.reduce docs, 0, fn({task, _}, acc) ->
-      max(byte_size(task), acc)
-    end
+    max =
+      Enum.reduce(docs, 0, fn {task, _}, acc ->
+        max(byte_size(task), acc)
+      end)
 
     sorted = Enum.sort(docs)
 
-    Enum.each sorted, fn({task, doc}) ->
-      shell.info format('mix ~-#{max}s # ~ts', [task, doc])
-    end
+    Enum.each(sorted, fn {task, doc} ->
+      shell.info(format(~c"mix ~-#{max}s # ~ts", [task, doc]))
+    end)
 
-    shell.info "\nEnabled compilers: #{Enum.join compilers(), ", "}"
+    consolidate_protocols? = Mix.Project.config()[:consolidate_protocols]
+    compilers = compilers() ++ if(consolidate_protocols?, do: [:protocols], else: [])
+    shell.info("\nEnabled compilers: #{Enum.join(compilers, ", ")}")
+    :ok
   end
 
+  @impl true
   def run(args) do
-    # --no-deps is used only internally. It has not purpose
-    # from Mix.CLI because the CLI itself already loads
-    # dependencies.
-    unless "--no-deps" in args do
-      Mix.Task.run "deps.loadpaths", args
+    Mix.Project.get!()
+
+    Mix.Task.run("loadpaths", args)
+
+    {opts, _, _} = OptionParser.parse(args, switches: [erl_config: :string])
+    load_erl_config(opts)
+
+    {res, diagnostics} =
+      Mix.Task.run("compile.all", args)
+      |> List.wrap()
+      |> Enum.map(
+        &case &1 do
+          :noop -> {:noop, []}
+          {status, diagnostics} -> {status, diagnostics}
+        end
+      )
+      |> Enum.reduce({:noop, []}, &merge_diagnostics/2)
+
+    config = Mix.Project.config()
+
+    # If we are in an umbrella project, now load paths from all children.
+    if apps_paths = Mix.Project.apps_paths(config) do
+      loaded_paths =
+        (Mix.Tasks.Compile.All.compile_apps(config, args) ++ Map.keys(apps_paths))
+        |> Mix.AppLoader.load_apps(Mix.Dep.cached(), config, [], fn
+          {_app, path}, acc -> if path, do: [path | acc], else: acc
+        end)
+
+      # We don't cache umbrella paths as we may write to them
+      Code.prepend_paths(loaded_paths -- :code.get_path())
     end
 
-    Mix.Task.run "loadpaths", args
-
     res =
-      Enum.map(compilers(), fn(compiler) ->
-        List.wrap Mix.Task.run("compile.#{compiler}", args)
-      end)
+      cond do
+        "--no-compile" in args ->
+          Mix.Task.reenable("compile")
+          :noop
 
-    Code.prepend_path Mix.Project.compile_path
-    if Enum.any?(res, &(:ok in &1)), do: :ok, else: :noop
+        Mix.Project.umbrella?(config) ->
+          Mix.Compilers.Protocol.umbrella(args, res)
+
+        true ->
+          res
+      end
+
+    path = Mix.Project.consolidation_path(config)
+
+    with {:ok, protocols} <- File.ls(path) do
+      # We don't cache consolidation path as we may write to it
+      Code.prepend_path(path)
+      Enum.each(protocols, &load_protocol/1)
+    end
+
+    {res, diagnostics}
   end
 
-  @doc """
-  Returns all compilers.
-  """
-  def compilers do
-    Mix.Project.config[:compilers] ||
-      [:yecc, :leex, :erlang, :elixir, :app]
+  defp format(expression, args) do
+    :io_lib.format(expression, args) |> IO.iodata_to_binary()
   end
 
-  @doc """
-  Returns manifests for all compilers.
-  """
-  def manifests do
-    Enum.flat_map(compilers(), fn(compiler) ->
-      module = Mix.Task.get!("compile.#{compiler}")
-      if function_exported?(module, :manifests, 0) do
-        module.manifests
-      else
-        []
+  defp first_line(doc) do
+    String.split(doc, "\n", parts: 2) |> hd() |> String.trim() |> String.trim_trailing(".")
+  end
+
+  defp merge_diagnostics({status1, diagnostics1}, {status2, diagnostics2}) do
+    new_status =
+      cond do
+        status1 == :error or status2 == :error -> :error
+        status1 == :ok or status2 == :ok -> :ok
+        true -> :noop
       end
-    end)
+
+    {new_status, diagnostics1 ++ diagnostics2}
   end
 
-  defp format(expression, args) do
-    :io_lib.format(expression, args) |> IO.iodata_to_binary
+  defp load_erl_config(opts) do
+    if path = opts[:erl_config] do
+      {:ok, terms} = :file.consult(path)
+      Application.put_all_env(terms, persistent: true)
+    end
   end
 
-  defp first_line(doc) do
-    String.split(doc, "\n", parts: 2) |> hd |> String.strip |> String.rstrip(?.)
+  @deprecated "Use Mix.Task.Compiler.manifests/0 instead"
+  defdelegate manifests, to: Mix.Task.Compiler
+
+  defp load_protocol(file) do
+    case file do
+      "Elixir." <> _ ->
+        module = file |> Path.rootname() |> String.to_atom()
+        :code.purge(module)
+        :code.delete(module)
+
+      _ ->
+        :ok
+    end
   end
 end
diff --git a/lib/mix/lib/mix/tasks/compile.leex.ex b/lib/mix/lib/mix/tasks/compile.leex.ex
index 8813ea1680c..deef8dec163 100644
--- a/lib/mix/lib/mix/tasks/compile.leex.ex
+++ b/lib/mix/lib/mix/tasks/compile.leex.ex
@@ -1,12 +1,20 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Compile.Leex do
-  use Mix.Task
+  use Mix.Task.Compiler
   alias Mix.Compilers.Erlang
 
   @recursive true
-  @manifest ".compile.leex"
+  @manifest "compile.leex"
+  @switches [force: :boolean, verbose: :boolean, all_warnings: :boolean]
+
+  # These options can't be controlled with :leex_options.
+  @forced_opts [report: true, return: true]
 
   @moduledoc """
-  Compile Leex source files.
+  Compiles Leex source files.
 
   When this task runs, it will check the modification time of every file, and
   if it has changed, the file will be compiled. Files will be
@@ -14,47 +22,69 @@ defmodule Mix.Tasks.Compile.Leex do
   You can force compilation regardless of modification times by passing
   the `--force` option.
 
+  You must add `compilers: [:leex] ++ Mix.compilers()` to the `def project`
+  section of your `mix.exs` to run this compiler.
+
   ## Command line options
 
+    * `--all-warnings` (`--no-all-warnings`) - prints all warnings, including previous compilations
+      (default is true except on errors)
     * `--force` - forces compilation regardless of modification times
+    * `--verbose` - prints verbose output
 
   ## Configuration
 
     * `:erlc_paths` - directories to find source files. Defaults to `["src"]`.
 
-    * `:leex_options` - compilation options that apply
-      to Leex's compiler. There are many available options
-      here: http://www.erlang.org/doc/man/leex.html#file-2.
+    * `:leex_options` - compilation options that apply to Leex's compiler.
 
-  """
+      For a complete list of options, see `:leex.file/2`.
+      Note that the `:report`, `:return_errors`, and `:return_warnings` options
+      are overridden by this compiler, thus setting them has no effect.
 
-  @doc """
-  Runs this task.
   """
+
+  @impl true
   def run(args) do
-    {opts, _, _} = OptionParser.parse(args, switches: [force: :boolean])
+    {opts, _, _} = OptionParser.parse(args, switches: @switches)
+
+    project = Mix.Project.config()
 
-    project      = Mix.Project.config
     source_paths = project[:erlc_paths]
-    mappings     = Enum.zip(source_paths, source_paths)
-    options      = project[:leex_options] || []
+    Mix.Compilers.Erlang.assert_valid_erlc_paths(source_paths)
+    mappings = Enum.zip(source_paths, source_paths)
+
+    leex_options = project[:leex_options] || []
 
-    Erlang.compile(manifest(), mappings, :xrl, :erl, opts[:force], fn
-      input, output ->
-        options = options ++ [scannerfile: Erlang.to_erl_file(output), report: true]
-        :leex.file(Erlang.to_erl_file(input), options)
+    if not is_list(leex_options) do
+      Mix.raise(":leex_options should be a list of options, got: #{inspect(leex_options)}")
+    end
+
+    opts = [parallel: true, preload: fn -> preload(project) end] ++ opts
+
+    Erlang.compile(manifest(), mappings, :xrl, :erl, opts, fn input, output ->
+      options = leex_options ++ @forced_opts ++ [scannerfile: Erlang.to_erl_file(output)]
+      :leex.file(Erlang.to_erl_file(input), options)
     end)
   end
 
-  @doc """
-  Returns Leex manifests.
-  """
-  def manifests, do: [manifest]
-  defp manifest, do: Path.join(Mix.Project.manifest_path, @manifest)
+  defp preload(project) do
+    # TODO: Remove me in Elixir v2.0
+    if :leex not in List.wrap(project[:compilers]) do
+      Mix.shell().error(
+        "warning: in order to compile .xrl files, you must add \"compilers: [:leex] ++ Mix.compilers()\" to the \"def project\" section of #{project[:app]}'s mix.exs"
+      )
+    end
 
-  @doc """
-  Cleans up compilation artifacts.
-  """
+    Mix.ensure_application!(:parsetools)
+    {:ok, _} = Application.ensure_all_started(:parsetools)
+  end
+
+  @impl true
+  def manifests, do: [manifest()]
+  defp manifest, do: Path.join(Mix.Project.manifest_path(), @manifest)
+
+  @impl true
   def clean do
     Erlang.clean(manifest())
   end
diff --git a/lib/mix/lib/mix/tasks/compile.protocols.ex b/lib/mix/lib/mix/tasks/compile.protocols.ex
index a86b2041c24..943fcabb01c 100644
--- a/lib/mix/lib/mix/tasks/compile.protocols.ex
+++ b/lib/mix/lib/mix/tasks/compile.protocols.ex
@@ -1,73 +1,13 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Compile.Protocols do
+  @moduledoc false
   use Mix.Task
 
-  @recursive true
-
-  @shortdoc "Consolidates all protocols in all paths"
-
-  @moduledoc ~S"""
-  Consolidates all protocols in all paths.
-
-  This module consolidates all protocols in the code path
-  and output the new binary files to the given directory
-  (defaults to "consolidated").
-
-  A new directory will be created with the consolidated
-  protocol versions in the build directory for the given
-  environment. Simply add it to your loadpath to make use
-  of it:
-
-      $ elixir -pa _build/dev/consolidated -S mix run
-
-  You can verify a protocol is consolidated by checking
-  its attributes:
-
-      $ iex -pa _build/dev/consolidated -S mix run
-      iex> Protocol.consolidated?(Enumerable)
-      true
-
-  """
-
-  def run(args) do
-    Mix.Task.run "compile", args
-    {opts, _, _} = OptionParser.parse(args, switches: [output: :string], aliases: [o: :output])
-
-    paths = filter_otp(:code.get_path, :code.lib_dir)
-    paths
-    |> Protocol.extract_protocols
-    |> consolidate(paths, opts[:output] || Path.join(Mix.Project.build_path, "consolidated"))
-
-    :ok
-  end
-
-  defp filter_otp(paths, otp) do
-    Enum.filter(paths, &(not :lists.prefix(&1, otp)))
-  end
-
-  defp consolidate(protocols, paths, output) do
-    File.mkdir_p!(output)
-
-    for protocol <- protocols do
-      impls = Protocol.extract_impls(protocol, paths)
-      maybe_reload(protocol)
-      {:ok, binary} = Protocol.consolidate(protocol, impls)
-      File.write!(Path.join(output, "#{protocol}.beam"), binary)
-      Mix.shell.info "Consolidated #{inspect protocol}"
-    end
-
-    relative = Path.relative_to_cwd(output)
-    Mix.shell.info "Consolidated protocols written to #{relative}"
-  end
-
-  defp maybe_reload(module) do
-    case :code.which(module) do
-      :non_existing ->
-        module
-      file ->
-        unless Path.extname(file) == ".beam" do
-          :code.purge(module)
-          :code.delete(module)
-        end
-    end
+  # TODO: Deprecate me on Elixir v1.23
+  def run(_args) do
+    :noop
   end
 end
diff --git a/lib/mix/lib/mix/tasks/compile.yecc.ex b/lib/mix/lib/mix/tasks/compile.yecc.ex
index 99714a6975f..46650336ea0 100644
--- a/lib/mix/lib/mix/tasks/compile.yecc.ex
+++ b/lib/mix/lib/mix/tasks/compile.yecc.ex
@@ -1,12 +1,20 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Compile.Yecc do
-  use Mix.Task
+  use Mix.Task.Compiler
   alias Mix.Compilers.Erlang
 
   @recursive true
-  @manifest ".compile.yecc"
+  @manifest "compile.yecc"
+  @switches [force: :boolean, verbose: :boolean, all_warnings: :boolean]
+
+  # These options can't be controlled with :yecc_options.
+  @forced_opts [report: true, return: true]
 
   @moduledoc """
-  Compile Yecc source files.
+  Compiles Yecc source files.
 
   When this task runs, it will check the modification time of every file, and
   if it has changed, the file will be compiled. Files will be
@@ -14,47 +22,70 @@ defmodule Mix.Tasks.Compile.Yecc do
   You can force compilation regardless of modification times by passing
   the `--force` option.
 
+  You must add `compilers: [:yecc] ++ Mix.compilers()` in the
+  `def project` section of your `mix.exs` to run this compiler.
+
   ## Command line options
 
+    * `--all-warnings` (`--no-all-warnings`) - prints all warnings, including previous compilations
+      (default is true except on errors)
     * `--force` - forces compilation regardless of modification times
+    * `--verbose` - prints verbose output
 
   ## Configuration
 
     * `:erlc_paths` - directories to find source files. Defaults to `["src"]`.
 
     * `:yecc_options` - compilation options that apply
-      to Yecc's compiler. There are many other available
-      options here: http://www.erlang.org/doc/man/yecc.html#file-1.
+      to Yecc's compiler.
 
-  """
+      For a complete list of options, see `:yecc.file/1`.
+      Note that the `:report`, `:return_errors`, and `:return_warnings` options
+      are overridden by this compiler, thus setting them has no effect.
 
-  @doc """
-  Runs this task.
   """
+
+  @impl true
   def run(args) do
-    {opts, _, _} = OptionParser.parse(args, switches: [force: :boolean])
+    {opts, _, _} = OptionParser.parse(args, switches: @switches)
+
+    project = Mix.Project.config()
 
-    project      = Mix.Project.config
     source_paths = project[:erlc_paths]
-    mappings     = Enum.zip(source_paths, source_paths)
-    options      = project[:yecc_options] || []
+    Mix.Compilers.Erlang.assert_valid_erlc_paths(source_paths)
+    mappings = Enum.zip(source_paths, source_paths)
+
+    yecc_options = project[:yecc_options] || []
 
-    Erlang.compile(manifest(), mappings, :yrl, :erl, opts[:force], fn
-      input, output ->
-        options = options ++ [parserfile: Erlang.to_erl_file(output), report: true]
-        :yecc.file(Erlang.to_erl_file(input), options)
+    if not is_list(yecc_options) do
+      Mix.raise(":yecc_options should be a list of options, got: #{inspect(yecc_options)}")
+    end
+
+    opts = [parallel: true, preload: fn -> preload(project) end] ++ opts
+
+    Erlang.compile(manifest(), mappings, :yrl, :erl, opts, fn input, output ->
+      options = yecc_options ++ @forced_opts ++ [parserfile: Erlang.to_erl_file(output)]
+      :yecc.file(Erlang.to_erl_file(input), options)
     end)
   end
 
-  @doc """
-  Returns Yecc manifests.
-  """
-  def manifests, do: [manifest]
-  defp manifest, do: Path.join(Mix.Project.manifest_path, @manifest)
+  defp preload(project) do
+    # TODO: Remove me in Elixir v2.0
+    if :yecc not in List.wrap(project[:compilers]) do
+      Mix.shell().error(
+        "warning: in order to compile .yrl files, you must add \"compilers: [:yecc] ++ Mix.compilers()\" to the \"def project\" section of #{project[:app]}'s mix.exs"
+      )
+    end
 
-  @doc """
-  Cleans up compilation artifacts.
-  """
+    Mix.ensure_application!(:parsetools)
+    {:ok, _} = Application.ensure_all_started(:parsetools)
+  end
+
+  @impl true
+  def manifests, do: [manifest()]
+  defp manifest, do: Path.join(Mix.Project.manifest_path(), @manifest)
+
+  @impl true
   def clean do
     Erlang.clean(manifest())
   end
diff --git a/lib/mix/lib/mix/tasks/deps.check.ex b/lib/mix/lib/mix/tasks/deps.check.ex
deleted file mode 100644
index f60c5d50736..00000000000
--- a/lib/mix/lib/mix/tasks/deps.check.ex
+++ /dev/null
@@ -1,103 +0,0 @@
-defmodule Mix.Tasks.Deps.Check do
-  use Mix.Task
-
-  import Mix.Dep, only: [loaded: 1, loaded_by_name: 2, format_dep: 1,
-                          format_status: 1, check_lock: 2, ok?: 1]
-
-  @moduledoc """
-  Checks if all dependencies are valid and if not, abort.
-  Prints the invalid dependencies' status before aborting.
-
-  This task is not shown in `mix help` but it is part
-  of the `mix` public API and can be depended on.
-
-  ## Command line options
-
-    * `--no-compile` - do not compile dependencies
-
-  """
-  def run(args) do
-    {opts, _, _} = OptionParser.parse(args)
-    lock = Mix.Dep.Lock.read
-    all  = Enum.map(loaded(env: Mix.env), &check_lock(&1, lock))
-
-    prune_deps(all)
-    {not_ok, compile} = partition_deps(all, [], [])
-
-    cond do
-      not_ok != [] ->
-        show_not_ok(not_ok)
-      compile == [] or opts[:no_compile] ->
-        :ok
-      true ->
-        Mix.Tasks.Deps.Compile.compile(compile, opts)
-        show_not_ok compile
-                    |> Enum.map(& &1.app)
-                    |> loaded_by_name(env: Mix.env)
-                    |> Enum.filter(&(not ok?(&1)))
-    end
-  end
-
-  defp partition_deps([dep|deps], not_ok, compile) do
-    cond do
-      compile?(dep)            -> partition_deps(deps, not_ok, [dep|compile])
-      ok?(dep) and local?(dep) -> partition_deps(deps, not_ok, [dep|compile])
-      ok?(dep)                 -> partition_deps(deps, not_ok, compile)
-      true                     -> partition_deps(deps, [dep|not_ok], compile)
-    end
-  end
-
-  defp partition_deps([], not_ok, compile) do
-    {Enum.reverse(not_ok), Enum.reverse(compile)}
-  end
-
-  defp local?(dep) do
-    not dep.scm.fetchable? and dep.opts[:from_umbrella] != true
-  end
-
-  defp compile?(%Mix.Dep{status: {:elixirlock, _}}), do: true
-  defp compile?(%Mix.Dep{status: {:noappfile, _}}), do: true
-  defp compile?(%Mix.Dep{status: :compile}), do: true
-  defp compile?(%Mix.Dep{}), do: false
-
-  # If the build is per environment, we should be able to look
-  # at all dependencies and remove the builds that no longer
-  # have a dependency defined for them.
-  #
-  # Notice we require the build_path to be nil. If the build_path
-  # is not nil, it means it was set by a parent application and
-  # the parent application should be the one to do the pruning.
-  defp prune_deps(all) do
-    config = Mix.Project.config
-
-    if nil?(config[:build_path]) && config[:build_per_environment] do
-      paths = Mix.Project.build_path(config)
-              |> Path.join("lib/*/ebin")
-              |> Path.wildcard
-              |> List.delete(not Mix.Project.umbrella? && Mix.Project.compile_path(config))
-
-      to_prune = Enum.reduce(all, paths, &(&2 -- Mix.Dep.load_paths(&1)))
-
-      Enum.map(to_prune, fn path ->
-        Code.delete_path(path)
-        File.rm_rf!(path |> Path.dirname)
-      end)
-    end
-  end
-
-  defp show_not_ok([]) do
-    :ok
-  end
-
-  defp show_not_ok(deps) do
-    shell = Mix.shell
-    shell.error "Unchecked dependencies for environment #{Mix.env}:"
-
-    Enum.each deps, fn(dep) ->
-      shell.error "* #{format_dep(dep)}"
-      shell.error "  #{format_status dep}"
-    end
-
-    Mix.raise "Can't continue due to errors on dependencies"
-  end
-end
diff --git a/lib/mix/lib/mix/tasks/deps.clean.ex b/lib/mix/lib/mix/tasks/deps.clean.ex
index 27e147dbbcc..5e59334c80a 100644
--- a/lib/mix/lib/mix/tasks/deps.clean.ex
+++ b/lib/mix/lib/mix/tasks/deps.clean.ex
@@ -1,59 +1,153 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Deps.Clean do
   use Mix.Task
 
-  @shortdoc "Remove the given dependencies' files"
+  @shortdoc "Deletes the given dependencies' files"
 
   @moduledoc """
-  Remove the given dependencies' files.
+  Deletes the given dependencies' files, including build artifacts and fetched
+  sources.
+
+  Since this is a destructive action, cleaning of dependencies
+  only occurs when passing arguments/options:
 
-  Since this is a destructive action, cleaning of all dependencies
-  can only happen by passing the `--all` command line option. It
-  also works accross all environments, unless `--only` is given.
+    * `dep1 dep2` - the names of dependencies to be deleted separated by a space
+    * `--unlock` - also unlocks the deleted dependencies
+    * `--build` - deletes only compiled files (keeps source files)
+    * `--all` - deletes all dependencies
+    * `--unused` - deletes only unused dependencies
+      (i.e. dependencies no longer mentioned in `mix.exs`)
 
-  Clean does not unlock the dependencies, unless `--unlock` is given.
+  By default this task works across all environments,
+  unless `--only` is given which will clean all dependencies
+  for the chosen environment.
   """
-  @switches [unlock: :boolean, all: :boolean, only: :string]
 
+  @switches [unlock: :boolean, all: :boolean, only: :string, unused: :boolean, build: :boolean]
+
+  @impl true
   def run(args) do
-    Mix.Project.get! # Require the project to be available
-    {opts, args, _} = OptionParser.parse(args, switches: @switches)
-
-    cond do
-      opts[:all] ->
-        # Clean all deps by default unless --only is given
-        clean_opts = if only = opts[:only], do: [env: :"#{only}"], else: []
-        apps = Mix.Dep.loaded(clean_opts) |> Enum.map(&(&1.app))
-        do_clean apps, opts
-      args != [] ->
-        do_clean args, opts
-      true ->
-        Mix.raise "mix deps.clean expects dependencies as arguments or " <>
-                                  "the --all option to clean all dependencies"
+    Mix.Project.get!()
+    {opts, apps} = OptionParser.parse!(args, strict: @switches)
+
+    build_path =
+      Mix.Project.build_path()
+      |> Path.dirname()
+      |> Path.join("*#{opts[:only]}/lib")
+
+    deps_path = Mix.Project.deps_path()
+
+    loaded_opts =
+      for {switch, key} <- [only: :env, target: :target],
+          value = opts[switch],
+          do: {key, :"#{value}"}
+
+    loaded_deps = Mix.Dep.Converger.converge(loaded_opts)
+
+    apps_to_clean =
+      cond do
+        opts[:all] ->
+          checked_deps(build_path, deps_path)
+
+        opts[:unused] ->
+          checked_deps(build_path, deps_path) |> filter_loaded(loaded_deps)
+
+        apps != [] ->
+          apps
+
+        true ->
+          Mix.raise(
+            "\"mix deps.clean\" expects dependencies as arguments or " <>
+              "an option indicating which dependencies to clean. " <>
+              "The --all option will clean all dependencies while " <>
+              "the --unused option cleans unused dependencies"
+          )
+      end
+
+    Mix.Project.with_build_lock(fn ->
+      clean_build(apps_to_clean, build_path)
+    end)
+
+    Mix.Project.with_deps_lock(fn ->
+      clean_source(apps_to_clean, loaded_deps, deps_path, opts[:build])
+
+      if opts[:unlock] do
+        Mix.Task.run("deps.unlock", args)
+      else
+        :ok
+      end
+    end)
+  end
+
+  defp checked_deps(build_path, deps_path) do
+    deps_names =
+      for root <- [deps_path, build_path],
+          path <- Path.wildcard(Path.join(root, "*")),
+          File.dir?(path),
+          uniq: true,
+          do: Path.basename(path)
+
+    List.delete(deps_names, to_string(Mix.Project.config()[:app]))
+  end
+
+  defp filter_loaded(apps, deps) do
+    apps -- Enum.map(deps, &Atom.to_string(&1.app))
+  end
+
+  defp maybe_warn_for_invalid_path([], dependency) do
+    Mix.shell().error(
+      "warning: the dependency #{dependency} is not present in the build directory"
+    )
+
+    []
+  end
+
+  defp maybe_warn_for_invalid_path(paths, _dependency) do
+    paths
+  end
+
+  defp maybe_warn_failed_file_deletion(result) do
+    with {:error, reason, file} <- result do
+      Mix.shell().error(
+        "warning: could not delete file #{Path.relative_to_cwd(file)}, " <>
+          "reason: #{:file.format_error(reason)}"
+      )
     end
   end
 
-  defp do_clean(apps, opts) do
-    shell = Mix.shell
-    build = Mix.Project.build_path
-            |> Path.dirname
-            |> Path.join("#{opts[:only] || :*}/lib")
-    deps  = Mix.Project.deps_path
+  defp clean_build(apps, build_path) do
+    shell = Mix.shell()
 
-    Enum.each apps, fn(app) ->
-      shell.info "* Cleaning #{app}"
+    Enum.each(apps, fn app ->
+      shell.info("* Cleaning #{app}")
 
-      build
+      # Remove everything from the build directory of dependencies
+      build_path
       |> Path.join(to_string(app))
-      |> Path.wildcard
-      |> Enum.each(&File.rm_rf!/1)
+      |> Path.wildcard()
+      |> maybe_warn_for_invalid_path(app)
+      |> Enum.map(&(&1 |> File.rm_rf() |> maybe_warn_failed_file_deletion()))
+    end)
+  end
 
-      deps
-      |> Path.join(to_string(app))
-      |> File.rm_rf!
-    end
+  defp clean_source(apps, deps, deps_path, build_only?) do
+    local = for %{scm: scm, app: app} <- deps, not scm.fetchable?(), do: Atom.to_string(app)
 
-    if opts[:unlock] do
-      Mix.Task.run "deps.unlock", apps
-    end
+    Enum.each(apps, fn app ->
+      # Remove everything from the source directory of dependencies.
+      # Skip this step if --build option is specified or if
+      # the dependency is local, i.e., referenced using :path.
+      if build_only? || app in local do
+        :do_not_delete_source
+      else
+        deps_path
+        |> Path.join(to_string(app))
+        |> File.rm_rf()
+        |> maybe_warn_failed_file_deletion()
+      end
+    end)
   end
 end
diff --git a/lib/mix/lib/mix/tasks/deps.compile.ex b/lib/mix/lib/mix/tasks/deps.compile.ex
index 7a2c965be00..33f630f8479 100644
--- a/lib/mix/lib/mix/tasks/deps.compile.ex
+++ b/lib/mix/lib/mix/tasks/deps.compile.ex
@@ -1,168 +1,408 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Deps.Compile do
   use Mix.Task
 
-  @shortdoc "Compile dependencies"
+  @shortdoc "Compiles dependencies"
 
   @moduledoc """
-  Compile dependencies.
+  Compiles dependencies.
 
-  By default, compile all dependencies. A list of dependencies can
-  be given to force the compilation of specific dependencies.
+  By default, this task attempts to compile all dependencies.
+  A list of dependencies can be given to compile multiple
+  dependencies in order.
 
   This task attempts to detect if the project contains one of
   the following files and act accordingly:
 
-    * `mix.exs`      - invokes `mix compile`
+    * `mix.exs` - invokes `mix compile`
     * `rebar.config` - invokes `rebar compile`
-    * `Makefile.win` - invokes `nmake /F Makefile.win` (only on Windows)
-    * `Makefile`     - invokes `make` (except on Windows)
+    * `Makefile.win`- invokes `nmake /F Makefile.win` (only on Windows)
+    * `Makefile` - invokes `gmake` on DragonFlyBSD, FreeBSD, NetBSD, and OpenBSD,
+      invokes `make` on any other operating system (except on Windows)
 
   The compilation can be customized by passing a `compile` option
   in the dependency:
 
       {:some_dependency, "0.1.0", compile: "command to compile"}
 
+  If a list of dependencies is given, Mix will attempt to compile
+  them as is. For example, if project `a` depends on `b`, calling
+  `mix deps.compile a` will compile `a` even if `b` is out of
+  date. This is to allow parts of the dependency tree to be
+  recompiled without propagating those changes upstream. To ensure
+  `b` is included in the compilation step, pass `--include-children`.
+
+  ## Compiling dependencies across multiple OS processes
+
+  If you set the environment variable `MIX_OS_DEPS_COMPILE_PARTITION_COUNT`
+  to a number greater than 1, Mix will start multiple operating system
+  processes to compile your dependencies concurrently.
+
+  While Mix and Rebar compile all files within a given project in parallel,
+  enabling this environment variable can still yield useful gains in several
+  cases, such as when compiling dependencies with native code, dependencies
+  that must download assets, or dependencies where the compilation time is not
+  evenly distributed (for example, one file takes much longer to compile than
+  all others).
+
+  While most configuration in Mix is done via command line flags, this particular
+  environment variable exists because the best number will vary per machine
+  (and often per project too). The environment variable also makes it more accessible
+  to enable concurrent compilation in CI and also during `Mix.install/2` commands.
+
+  ## Command line options
+
+    * `--force` - force compilation of deps
+    * `--skip-umbrella-children` - skips umbrella applications from compiling
+    * `--skip-local-deps` - skips non-remote dependencies, such as path deps, from compiling
+
   """
 
-  import Mix.Dep, only: [loaded: 1, available?: 1, loaded_by_name: 2,
-                         format_dep: 1, make?: 1, mix?: 1, rebar?: 1]
+  @switches [
+    include_children: :boolean,
+    force: :boolean,
+    skip_umbrella_children: :boolean,
+    skip_local_deps: :boolean
+  ]
 
+  @impl true
   def run(args) do
-    Mix.Project.get! # Require the project to be available
+    if "--no-archives-check" not in args do
+      Mix.Task.run("archive.check", args)
+    end
+
+    Mix.Project.get!()
+    config = Mix.Project.config()
+
+    Mix.Project.with_build_lock(config, fn ->
+      deps = Mix.Dep.load_and_cache()
+
+      case OptionParser.parse(args, switches: @switches) do
+        {opts, [], _} ->
+          compile(filter_available_and_local_deps(deps), opts)
 
-    case OptionParser.parse(args) do
-      {opts, [], _} ->
-        compile(Enum.filter(loaded(env: Mix.env), &compilable?/1), opts)
-      {opts, tail, _} ->
-        compile(loaded_by_name(tail, env: Mix.env), opts)
+        {opts, tail, _} ->
+          compile(Mix.Dep.filter_by_name(tail, deps, opts), opts)
+      end
+    end)
+  end
+
+  @doc false
+  def compile(deps, options \\ []) do
+    Mix.Task.run("deps.precompile")
+    force? = Keyword.get(options, :force, false)
+
+    deps =
+      deps
+      |> reject_umbrella_children(options)
+      |> reject_local_deps(options)
+
+    count = System.get_env("MIX_OS_DEPS_COMPILE_PARTITION_COUNT", "0") |> String.to_integer()
+
+    # If all dependencies are local and ok, do not bother starting
+    # processes as it will likely slow everything down.
+    if count > 1 and match?([_, _ | _], deps) and
+         not Enum.all?(deps, &(Mix.Dep.ok?(&1) and not &1.scm.fetchable?())) do
+      Mix.shell().info("mix deps.compile running across #{count} OS processes")
+
+      if Mix.Tasks.Deps.Partition.server(deps, count, force?) do
+        # Each partition will trigger will_recompile but we need to trigger it here too
+        Mix.Task.run("will_recompile")
+      end
+    else
+      config = Mix.Project.deps_config()
+      Enum.each(deps, &compile_single(&1, force?, config))
     end
   end
 
   @doc false
-  def compile(deps, _opts) do
-    shell  = Mix.shell
-    config = Mix.Project.deps_config
-
-    compiled =
-      Enum.map(deps, fn %Mix.Dep{app: app, status: status, opts: opts, scm: scm} = dep ->
-        check_unavailable!(app, status)
-
-        compiled = cond do
-          not nil?(opts[:compile]) ->
-            do_compile dep
-          mix?(dep) ->
-            do_mix dep
-          rebar?(dep) ->
-            do_rebar dep, config
-          make?(dep) ->
-            do_make dep
-          true ->
-            shell.error "Could not compile #{app}, no mix.exs, rebar.config or Makefile " <>
-              "(pass :compile as an option to customize compilation, set it to false to do nothing)"
-        end
-
-        unless mix?(dep), do: build_structure(dep, config)
-        if scm.fetchable?, do: Mix.Dep.Lock.touch(opts[:build])
-        compiled
+  def compile_single(%Mix.Dep{} = dep, force?, config) do
+    %{app: app, status: status, opts: opts, scm: scm} = dep
+    check_unavailable!(app, scm, status)
+
+    # If a dependency was marked as fetched or with an out of date lock
+    # or missing the app file, we always compile it from scratch.
+    if force? or Mix.Dep.compilable?(dep) do
+      File.rm_rf!(Path.join([Mix.Project.build_path(), "lib", Atom.to_string(dep.app)]))
+    end
+
+    compiled? =
+      cond do
+        not is_nil(opts[:compile]) ->
+          do_compile(dep, config)
+
+        Mix.Dep.mix?(dep) ->
+          do_mix(dep, config)
+
+        Mix.Dep.make?(dep) ->
+          do_make(dep, config)
+
+        dep.manager == :rebar3 ->
+          do_rebar3(dep, config)
+
+        true ->
+          Mix.shell().error(
+            "Could not compile #{inspect(app)}, no \"mix.exs\", \"rebar.config\" or \"Makefile\" " <>
+              "(pass :compile as an option to customize compilation, set it to \"false\" to do nothing)"
+          )
+
+          false
+      end
+
+    if compiled? do
+      config
+      |> Mix.Project.build_path()
+      |> Mix.Sync.PubSub.broadcast(fn ->
+        info = %{
+          app: dep.app,
+          scm: dep.scm,
+          manager: dep.manager,
+          os_pid: System.pid()
+        }
+
+        {:dep_compiled, info}
       end)
+    end
 
-    if Enum.any?(compiled), do: Mix.Dep.Lock.touch
-  end
+    # We should touch fetchable dependencies even if they
+    # did not compile otherwise they will always be marked
+    # as stale, even when there is nothing to do.
+    fetchable? = touch_fetchable(scm, opts)
 
-  # All available dependencies can be compiled
-  # except for umbrella applications.
-  defp compilable?(%Mix.Dep{extra: extra} = dep) do
-    available?(dep) and !extra[:umbrella?]
+    if compiled? and fetchable? do
+      Mix.Task.run("will_recompile")
+      true
+    else
+      false
+    end
   end
 
-  defp check_unavailable!(app, {:unavailable, _}) do
-    Mix.raise "Cannot compile dependency #{app} because " <>
-      "it isn't available, run `mix deps.get` first"
+  defp check_unavailable!(app, scm, {:unavailable, path}) do
+    if scm.fetchable?() do
+      Mix.raise(
+        "Cannot compile dependency #{inspect(app)} because " <>
+          "it isn't available, run \"mix deps.get\" first"
+      )
+    else
+      Mix.raise(
+        "Cannot compile dependency #{inspect(app)} because " <>
+          "it isn't available, please ensure the dependency is at " <>
+          inspect(Path.relative_to_cwd(path))
+      )
+    end
   end
 
-  defp check_unavailable!(_, _) do
+  defp check_unavailable!(_, _, _) do
     :ok
   end
 
-  defp do_mix(dep) do
-    Mix.Dep.in_dependency dep, fn _ ->
+  defp touch_fetchable(scm, opts) do
+    if scm.fetchable?() do
+      Mix.Dep.ElixirSCM.update(Path.join(opts[:build], ".mix"), scm, opts[:lock])
+      true
+    else
+      false
+    end
+  end
+
+  defp do_mix(dep, _config) do
+    Mix.Dep.in_dependency(dep, fn _ ->
+      config = Mix.Project.config()
+
+      if req = old_elixir_req(config) do
+        Mix.shell().error(
+          "warning: the dependency #{inspect(dep.app)} requires Elixir #{inspect(req)} " <>
+            "but you are running on v#{System.version()}"
+        )
+      end
+
       try do
-        res = Mix.Task.run("compile", ["--no-deps", "--no-elixir-version-check"])
-        :ok in List.wrap(res)
+        options = ["--from-mix-deps-compile", "--no-warnings-as-errors", "--no-code-path-pruning"]
+        res = Mix.Task.run("compile", options)
+        match?({:ok, _}, res)
       catch
         kind, reason ->
-          stacktrace = System.stacktrace
           app = dep.app
-          Mix.shell.error "could not compile dependency #{app}, mix compile failed. " <>
-            "You can recompile this dependency with `mix deps.compile #{app}` or " <>
-            "update it with `mix deps.update #{app}`"
-          :erlang.raise(kind, reason, stacktrace)
+
+          Mix.shell().error(
+            "could not compile dependency #{inspect(app)}, \"mix compile\" failed. " <>
+              deps_compile_feedback(app)
+          )
+
+          :erlang.raise(kind, reason, __STACKTRACE__)
       end
+    end)
+  end
+
+  defp do_rebar3(%Mix.Dep{opts: opts, manager: manager} = dep, config) do
+    if not Mix.Rebar.available?(manager) do
+      Mix.Tasks.Local.Rebar.run(["--force"])
+    end
+
+    dep_path = opts[:dest]
+    build_path = opts[:build]
+    File.mkdir_p!(build_path)
+
+    # For Rebar3, we need to copy the source/ebin to the target/ebin
+    # before we run the command given that REBAR_BARE_COMPILER_OUTPUT_DIR
+    # writes directly to _build.
+    File.cp_r(Path.join(dep_path, "ebin"), Path.join(build_path, "ebin"))
+
+    # Now establish symlinks to the remaining sources
+    for dir <- ~w(include priv src) do
+      Mix.Utils.symlink_or_copy(Path.join(dep_path, dir), Path.join(build_path, dir))
+    end
+
+    # Build the rebar config and setup the command line
+    config_path = Path.join(build_path, "mix.rebar.config")
+    lib_path = Path.join(config[:deps_build_path], "lib/*/ebin")
+    File.write!(config_path, rebar_config(dep))
+
+    env = [
+      # REBAR_BARE_COMPILER_OUTPUT_DIR is only honored by rebar3 >= 3.14
+      {"REBAR_BARE_COMPILER_OUTPUT_DIR", build_path},
+      {"REBAR_SKIP_PROJECT_PLUGINS", "true"},
+      {"REBAR_CONFIG", config_path},
+      {"REBAR_PROFILE", "prod"},
+      {"TERM", "dumb"}
+    ]
+
+    {exec, args} = Mix.Rebar.rebar_args(:rebar3, ["bare", "compile", "--paths", lib_path])
+
+    if Mix.shell().cmd({exec, args}, opts_for_cmd(dep, config, env)) != 0 do
+      Mix.raise(
+        "Could not compile dependency #{inspect(dep.app)}, \"#{Enum.join([exec | args], " ")}\" command failed. " <>
+          deps_compile_feedback(dep.app)
+      )
+    end
+
+    # Check if we have any new symlinks after compilation
+    for dir <- ~w(include priv src),
+        File.exists?(Path.join(dep_path, dir)) and not File.exists?(Path.join(build_path, dir)) do
+      Mix.Utils.symlink_or_copy(Path.join(dep_path, dir), Path.join(build_path, dir))
     end
+
+    Code.prepend_path(Path.join(build_path, "ebin"), cache: true)
+    true
   end
 
-  defp do_rebar(%Mix.Dep{app: app} = dep, config) do
-    do_command dep, rebar_cmd(app), "compile skip_deps=true deps_dir=#{inspect config[:deps_path]}"
+  defp rebar_config(dep) do
+    dep.extra
+    |> Mix.Rebar.dependency_config()
+    |> Mix.Rebar.serialize_config()
   end
 
-  defp rebar_cmd(app) do
-    Mix.Rebar.rebar_cmd || handle_rebar_not_found(app)
+  defp do_make(dep, config) do
+    command = make_command(dep)
+    shell_cmd!(dep, config, command, [{"IS_DEP", "1"}])
+    build_symlink_structure(dep, config)
+    true
   end
 
-  defp handle_rebar_not_found(app) do
-    shell = Mix.shell
-    shell.info "Could not find rebar, which is needed to build dependency #{inspect app}"
-    shell.info "I can install a local copy which is just used by mix"
+  defp make_command(dep) do
+    makefile_win? = makefile_win?(dep)
 
-    unless shell.yes?("Shall I install rebar?") do
-      Mix.raise "Could not find rebar to compile " <>
-        "dependency #{app}, please ensure rebar is available"
-    end
+    command =
+      case :os.type() do
+        {:win32, _} when makefile_win? ->
+          "nmake /F Makefile.win"
 
-    Mix.Tasks.Local.Rebar.run []
-    Mix.Rebar.local_rebar_cmd || Mix.raise "rebar installation failed"
-  end
+        {:unix, type} when type in [:dragonfly, :freebsd, :netbsd, :openbsd] ->
+          "gmake"
 
-  defp do_make(dep) do
-    if match?({:win32, _}, :os.type) and File.regular?("Makefile.win") do
-      do_command(dep, "nmake /F Makefile.win")
+        _ ->
+          "make"
+      end
+
+    if erlang_mk?(dep) do
+      "#{command} clean && #{command}"
     else
-      do_command(dep, "make")
+      command
     end
   end
 
-  defp do_compile(%Mix.Dep{app: app, opts: opts} = dep) do
+  defp do_compile(%Mix.Dep{opts: opts} = dep, config) do
     if command = opts[:compile] do
-      Mix.shell.info("#{app}: #{command}")
-      do_command(dep, command)
+      shell_cmd!(dep, config, command)
+      build_symlink_structure(dep, config)
+      true
     else
       false
     end
   end
 
-  defp do_command(%Mix.Dep{app: app, opts: opts}, command, extra \\ "") do
-    File.cd! opts[:dest], fn ->
-      if Mix.shell.cmd("#{command} #{extra}") != 0 do
-        Mix.raise "Could not compile dependency #{app}, #{command} command failed. " <>
-          "If you want to recompile this dependency, please run: mix deps.compile #{app}"
-      end
+  defp shell_cmd!(%Mix.Dep{app: app} = dep, config, command, env \\ []) do
+    if Mix.shell().cmd(command, [print_app: true] ++ opts_for_cmd(dep, config, env)) != 0 do
+      Mix.raise(
+        "Could not compile dependency #{inspect(app)}, \"#{command}\" command failed. " <>
+          deps_compile_feedback(app)
+      )
     end
-    true
+
+    :ok
+  end
+
+  defp opts_for_cmd(dep, config, env) do
+    %Mix.Dep{system_env: system_env, opts: opts} = dep
+    env = [{"ERL_LIBS", Path.join(config[:deps_build_path], "lib")} | system_env] ++ env
+    [env: env, cd: opts[:dest]]
+  end
+
+  defp build_symlink_structure(%Mix.Dep{opts: opts}, config) do
+    config = Keyword.put(config, :deps_app_path, opts[:build])
+    Mix.Project.build_structure(config, symlink_ebin: true, source: opts[:dest])
+    Code.prepend_path(Path.join(opts[:build], "ebin"), cache: true)
   end
 
-  defp build_structure(%Mix.Dep{opts: opts} = dep, config) do
-    build_path = Path.dirname(opts[:build])
-    Enum.each Mix.Dep.source_paths(dep), fn source ->
-      app = Path.join(build_path, Path.basename(source))
-      build_structure(source, app, config)
-      Code.prepend_path(Path.join(app, "ebin"))
+  defp old_elixir_req(config) do
+    req = config[:elixir]
+
+    if req && not Version.match?(System.version(), req) do
+      req
     end
   end
 
-  defp build_structure(dest, build, config) do
-    File.cd! dest, fn ->
-      config = Keyword.put(config, :app_path, build)
-      Mix.Project.build_structure(config, symlink_ebin: true)
+  defp erlang_mk?(%Mix.Dep{opts: opts}) do
+    File.regular?(Path.join(opts[:dest], "erlang.mk"))
+  end
+
+  defp makefile_win?(%Mix.Dep{opts: opts}) do
+    File.regular?(Path.join(opts[:dest], "Makefile.win"))
+  end
+
+  defp reject_umbrella_children(deps, options) do
+    if options[:skip_umbrella_children] do
+      Enum.reject(deps, fn %{opts: opts} -> Keyword.get(opts, :from_umbrella) == true end)
+    else
+      deps
+    end
+  end
+
+  defp filter_available_and_local_deps(deps) do
+    Enum.filter(deps, fn dep ->
+      Mix.Dep.available?(dep) or not dep.scm.fetchable?()
+    end)
+  end
+
+  defp reject_local_deps(deps, options) do
+    if options[:skip_local_deps] do
+      Enum.filter(deps, fn %{scm: scm} -> scm.fetchable?() end)
+    else
+      deps
+    end
+  end
+
+  defp deps_compile_feedback(app) do
+    if Mix.install?() do
+      "Errors may have been logged above. You may run Mix.install/2 to try again or " <>
+        "change the arguments to Mix.install/2 to try another version"
+    else
+      "Errors may have been logged above. You can recompile this dependency with " <>
+        "\"mix deps.compile #{app} --force\", update it with \"mix deps.update #{app}\" or " <>
+        "clean it with \"mix deps.clean #{app}\""
     end
   end
 end
diff --git a/lib/mix/lib/mix/tasks/deps.ex b/lib/mix/lib/mix/tasks/deps.ex
index aebed477bab..f17cd078cc2 100644
--- a/lib/mix/lib/mix/tasks/deps.ex
+++ b/lib/mix/lib/mix/tasks/deps.ex
@@ -1,12 +1,16 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Deps do
   use Mix.Task
 
-  import Mix.Dep, only: [loaded: 1, format_dep: 1, format_status: 1, check_lock: 2]
+  import Mix.Dep, only: [format_dep: 1, format_status: 1, check_lock: 1]
 
-  @shortdoc "List dependencies and their status"
+  @shortdoc "Lists dependencies and their status"
 
   @moduledoc ~S"""
-  List all dependencies and their status.
+  Lists all dependencies and their status.
 
   Dependencies must be specified in the `mix.exs` file in one of
   the following formats:
@@ -18,103 +22,194 @@ defmodule Mix.Tasks.Deps do
   Where:
 
     * app is an atom
-    * requirement is a version requirement or a regular expression
+    * requirement is a `Version` requirement or a regular expression
     * opts is a keyword list of options
 
+  For example:
+
+      {:plug, ">= 0.4.0"}
+      {:gettext, git: "https://github.com/elixir-lang/gettext.git", tag: "0.1"}
+      {:local_dependency, path: "path/to/local_dependency"}
+
   By default, dependencies are fetched using the [Hex package manager](https://hex.pm/):
 
       {:plug, ">= 0.4.0"}
 
   By specifying such dependencies, Mix will automatically install
-  Hex (if it wasn't previously installed and download a package
-  suitable to your project).
+  Hex (if it wasn't previously installed) and download a package
+  suitable to your project. Note Hex expects the dependency
+  requirement to always be given and it will warn otherwise.
 
-  Mix also supports git and path dependencies:
+  Mix also supports Git and path dependencies:
 
       {:foobar, git: "https://github.com/elixir-lang/foobar.git", tag: "0.1"}
       {:foobar, path: "path/to/foobar"}
 
   And also in umbrella dependencies:
 
-      {:myapp, in_umbrella: true}
+      {:my_app, in_umbrella: true}
 
   Path and in umbrella dependencies are automatically recompiled by
-  the parent project whenever they change. While fetchable dependencies
-  like git are recompiled only when fetched/updated.
-
-  The dependencies versions are expected to follow Semantic Versioning
-  and the requirements must be specified as defined in the `Version`
-  module.
+  the parent project whenever they change. While fetchable dependencies,
+  like the ones using `:git`, are recompiled only when fetched/updated.
 
-  Below we provide a more detailed look into the available options.
+  The dependencies' versions are expected to be formatted according to
+  Semantic Versioning and the requirements must be specified as defined
+  in the `Version` module.
 
-  ## Mix options
+  ## Options
 
-    * `:app` - when set to false, does not read the app file for this
-      dependency
-
-    * `:env` - the environment to run the dependency on, defaults to :prod
-
-    * `:compile` - a command to compile the dependency, defaults to a mix,
-      rebar or make command
-
-    * `:optional` - the dependency is optional and used only to specify
-      requirements
-
-    * `:only` - the dependency will belong only to the given environments,
-      useful when declaring dev- or test-only dependencies
+  Below we provide a more detailed look into the available options.
 
-    * `:override` - if set to true the dependency will override any other
+  ### Dependency definition options
+
+    * `:app` - when set to `false`, does not read the app file for this
+      dependency. By default, the app file is read
+
+    * `:env` - the environment (as an atom) to run the dependency on.
+      While your current project runs in `:dev` by default, dependencies
+      defaults to `:prod` (except for `:in_umbrella` dependencies, see
+      below)
+
+    * `:compile` - a command (string) to compile the dependency; defaults to a `mix`,
+      `rebar` or `make` command
+
+    * `:optional` - marks the dependency as optional. In such cases, the
+      current project will always include the optional dependency but any
+      other project that depends on the current project won't be forced to
+      use the optional dependency. However, if the other project includes
+      the optional dependency on its own, the requirements and options
+      specified here will also be applied. Optional dependencies will _not_
+      be started by the application. You should consider compiling your
+      projects with the `mix compile --no-optional-deps --warnings-as-errors`
+      during test, to ensure your project compiles without warnings even
+      if optional dependencies are missing
+
+    * `:only` - the dependency is made available only in the given environments,
+      useful when declaring dev- or test-only dependencies; by default the
+      dependency will be available in all environments. The value of this option
+      can either be a single environment (like `:dev`) or a list of environments
+      (like `[:dev, :test]`). Keep in mind that your project runs in the `:dev`
+      environment by default, however, all of your dependencies run in the `:prod`
+      environment (unless the `:env` option above is given)
+
+    * `:targets` - the dependency is made available only for the given targets.
+      By default the dependency will be available in all targets. The value
+      of this option can either be a single target (like `:host`) or a list of
+      targets (like `[:host, :rpi3]`)
+
+    * `:override` - if set to `true` the dependency will override any other
       definitions of itself by other dependencies
 
-  ## Git options (`:git`)
-
-    * `:git`        - the git repository URI
-    * `:github`     - a shortcut for specifying git repos from github, uses `git:`
-    * `:ref`        - the reference to checkout (may be a branch, a commit sha or a tag)
-    * `:branch`     - the git branch to checkout
-    * `:tag`        - the git tag to checkout
-    * `:submodules` - when true, initialize submodules for the repo
-
-  ## Path options (`:path`)
-
-    * `:path`        - the path for the dependency
-    * `:in_umbrella` - when true, sets a path dependency pointing to
-      "../#{app}", sharing the same environment as the current application
-
-  ## mix deps task
-
-  This task lists all dependencies in the following format:
-
-      APP VERSION (SCM)
+    * `:manager` - Mix can also compile Rebar3 and makefile projects
+      and can fetch sub dependencies of Rebar3 projects. Mix will
+      try to infer the type of project but it can be overridden with this
+      option by setting it to `:mix`, `:rebar3`, or `:make`. In case
+      there are conflicting definitions, the first manager in the list above
+      will be picked up. For example, if a dependency is found with `:rebar3`
+      as a manager in different part of the trees, `:rebar3` will be automatically
+      picked. You can find the manager by running `mix deps` and override it by
+      setting the `:override` option in a top-level project.
+
+    * `:runtime` - whether the dependency is part of runtime applications.
+      If the `:applications` key is not provided in `def application` in your
+      `mix.exs` file, Mix will automatically include all dependencies as a runtime
+      application, except if `runtime: false` is given. Defaults to `true`.
+
+    * `:system_env` - an enumerable of key-value tuples of binaries to be set
+      as environment variables when loading or compiling the dependency
+
+  When a project is used as a dependency, it runs by default in the `:prod`
+  environment. Therefore, if your project has dependencies that are only
+  useful in development or testing, you want to specify those dependencies with
+  the `:only` option above. You can also specify `:optional` dependencies
+  in your project, which are not enforced upon users of your library, as outlined
+  above. Finally, the [lockfile](`Mix.Project#module-configuration`) (usually
+  named `mix.lock`) is ignored when a project is used as a dependency.
+
+  ### Git options (`:git`)
+
+    * `:git` - the Git repository URI
+    * `:github` - a shortcut for specifying Git repos from GitHub, uses `:git`
+    * `:ref` - the reference to checkout (may be a branch, a commit SHA or a tag)
+    * `:branch` - the Git branch to checkout
+    * `:tag` - the Git tag to checkout
+    * `:submodules` - when `true`, initialize submodules for the repo
+    * `:sparse` - checkout a single directory inside the Git repository and use it
+      as your Mix dependency. Search "sparse Git checkouts" for more information.
+    * `:subdir` *(since v1.13.0)* - search for the project in the given directory
+      relative to the git checkout. This is similar to `:sparse` option but instead
+      of a doing a sparse checkout it does a full checkout.
+    * `:depth` *(since v1.17.0)* - creates a shallow clone of the Git repository,
+      limiting the history to the specified number of commits. This can significantly
+      improve clone speed for large repositories when full history is not needed.
+      The value must be a positive integer, typically `1`. When using `:depth` with
+      `:ref`, a fully spelled hex object name (a 40-character SHA-1 hash) is required.
+
+  If your Git repository requires authentication, such as basic username:password
+  HTTP authentication via URLs, it can be achieved via Git configuration, keeping
+  the access rules outside of source control.
+
+      $ git config --global url."https://YOUR_USER:YOUR_PASS@example.com/".insteadOf "https://example.com/"
+
+  For more information, see the `git config` documentation:
+  https://git-scm.com/docs/git-config#Documentation/git-config.txt-urlltbasegtinsteadOf
+
+  ### Path options (`:path`)
+
+    * `:path` - the path for the dependency
+    * `:in_umbrella` - when `true`, sets a path dependency pointing to
+      `"../#{app}"`, sharing the same environment as the current application
+
+  ### Hex options (`:hex`)
+
+    * `:hex` - the name of the package, which defaults to the application name
+    * `:repo` - the repository to fetch the package from, used by remote or
+      private repositories. Defaults to the global "hexpm" repository
+    * `:warn_if_outdated` - warn if there is a more recent version of the package
+      published on Hex.pm
+
+  ## Deps task
+
+  `mix deps` task lists all dependencies in the following format:
+
+      APP VERSION (SCM) (MANAGER)
       [locked at REF]
       STATUS
 
+  For dependencies satisfied by Hex, `REF` is the package checksum.
+
+  For dependencies satisfied by git, `REF` is the commit object name,
+  and may include branch or tag information.
+
   It supports the following options:
 
-    * `--all` - check all dependencies, regardless of specified environment
+    * `--all` - lists all dependencies, regardless of specified environment
 
   """
+
+  @impl true
   def run(args) do
-    Mix.Project.get! # Require the project to be available
-    {opts, _, _} = OptionParser.parse(args)
+    Mix.Project.get!()
+    {opts, _, _} = OptionParser.parse(args, switches: [all: :boolean])
+    loaded_opts = if opts[:all], do: [], else: [env: Mix.env(), target: Mix.target()]
 
-    if opts[:all] do
-      loaded_opts = []
-    else
-      loaded_opts = [env: Mix.env]
-    end
+    shell = Mix.shell()
 
-    shell = Mix.shell
-    lock  = Mix.Dep.Lock.read
+    Mix.Dep.Converger.converge(loaded_opts)
+    |> Enum.sort_by(& &1.app)
+    |> Enum.each(fn dep ->
+      %Mix.Dep{scm: scm, manager: manager} = dep
+      dep = check_lock(dep)
+      extra = if manager, do: " (#{manager})", else: ""
+
+      shell.info("* #{format_dep(dep)}#{extra}")
 
-    Enum.each loaded(loaded_opts), fn %Mix.Dep{scm: scm} = dep ->
-      dep = check_lock(dep, lock)
-      shell.info "* #{format_dep(dep)}"
       if formatted = scm.format_lock(dep.opts) do
-        shell.info "  locked at #{formatted}"
+        shell.info("  locked at #{formatted}")
       end
-      shell.info "  #{format_status dep}"
-    end
+
+      shell.info("  #{format_status(dep)}")
+    end)
   end
 end
diff --git a/lib/mix/lib/mix/tasks/deps.get.ex b/lib/mix/lib/mix/tasks/deps.get.ex
index 9f4fd9f8a70..c57b53dad16 100644
--- a/lib/mix/lib/mix/tasks/deps.get.ex
+++ b/lib/mix/lib/mix/tasks/deps.get.ex
@@ -1,33 +1,51 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Deps.Get do
   use Mix.Task
 
-  @shortdoc "Get all out of date dependencies"
+  @shortdoc "Fetches unavailable and out of date dependencies"
 
   @moduledoc """
-  Get all out of date dependencies, i.e. dependencies
-  that are not available or have an invalid lock.
+  Fetches unavailable and out of date dependencies.
 
   ## Command line options
 
-    * `--quiet` - do not output verbose messages
-    * `--only`  - only fetch dependencies for given environment
+    * `--check-locked` - raises if there are pending changes to the lockfile
+    * `--no-archives-check` - does not check archives before fetching deps
+    * `--only` - only fetches dependencies for given environment
+
   """
+
+  @impl true
   def run(args) do
-    Mix.Project.get! # Require the project to be available
-    {opts, rest, _} = OptionParser.parse(args, switches: [quiet: :boolean, only: :string])
+    if "--no-archives-check" not in args do
+      Mix.Task.run("archive.check", args)
+    end
+
+    Mix.Project.get!()
+
+    {opts, _, _} =
+      OptionParser.parse(args, switches: [only: :string, target: :string, check_locked: :boolean])
+
+    Mix.Project.with_deps_lock(fn ->
+      do_run(opts)
+    end)
+  end
 
-    # Fetch all deps by default unless --only is given
-    fetch_opts = if only = opts[:only], do: [env: :"#{only}"], else: []
+  defp do_run(opts) do
+    fetch_opts =
+      for {switch, key} <- [only: :env, target: :target, check_locked: :check_locked],
+          value = opts[switch],
+          do: {key, :"#{value}"}
 
-    apps =
-      if rest != [] do
-        Mix.Dep.Fetcher.by_name(rest, %{}, Mix.Dep.Lock.read, fetch_opts)
-      else
-        Mix.Dep.Fetcher.all(%{}, Mix.Dep.Lock.read, fetch_opts)
-      end
+    apps = Mix.Dep.Fetcher.all(%{}, Mix.Dep.Lock.read(), fetch_opts)
 
-    if apps == [] && !opts[:quiet] do
-      Mix.shell.info "All dependencies up to date"
+    if apps == [] do
+      Mix.shell().info("All dependencies have been fetched")
+    else
+      :ok
     end
   end
 end
diff --git a/lib/mix/lib/mix/tasks/deps.loadpaths.ex b/lib/mix/lib/mix/tasks/deps.loadpaths.ex
index 46cdf72b186..1580b3682f7 100644
--- a/lib/mix/lib/mix/tasks/deps.loadpaths.ex
+++ b/lib/mix/lib/mix/tasks/deps.loadpaths.ex
@@ -1,26 +1,197 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Deps.Loadpaths do
   use Mix.Task
 
+  import Mix.Dep, only: [format_dep: 1, format_status: 1, check_lock: 1]
+
   @moduledoc """
-  Loads all dependencies for the current build.
-  This is invoked directly by `loadpaths` when
-  the CLI boots.
+  Checks, compiles, and loads dependencies.
+
+  If a dependency has been fetched/updated and not yet compiled,
+  it will be automatically compiled. If a dependency is missing
+  or is invalid, its status is printed before aborting.
+
+  Although this task does not show up in `mix help`, it is
+  part of Mix public API and can be depended on.
+
+  ## Configuration
+
+    * `:listeners` - the list of listener modules. For more details
+      see `Mix.Task.Compiler`
 
   ## Command line options
 
-    * `--no-deps-check` - skip dependency check
+    * `--no-archives-check` - does not check archives
+    * `--no-compile` - does not compile even if files require compilation
+    * `--no-deps-check` - does not check or compile deps, only load available ones
+    * `--no-elixir-version-check` - does not check Elixir version
+    * `--no-listeners` - does not start Mix listeners
+    * `--no-optional-deps` - does not compile or load optional deps
+
   """
+
+  @impl true
   def run(args) do
-    unless "--no-deps-check" in args do
-      Mix.Task.run "deps.check", args
+    # Note that we need to ensure the dependencies are compiled first,
+    # before we can start the pub/sub listeners, since those come from
+    # the dependencies. Theoretically, between compiling dependencies
+    # and starting the listeners, there may be a concurrent compilation
+    # of the dependencies, which we would miss, and we would already
+    # have modules from our compilation loaded. To avoid this race
+    # condition we start the pub/sub beforehand and we accumulate all
+    # events until the listeners are started. Alternatively we could
+    # use a lock around compilation and sterning the listeners, however
+    # the added benefit of the current approach is that we consistently
+    # receive events for all dependency compilations. Also, if we ever
+    # decide to start the listeners later (e.g. after loadspaths), the
+    # accumulation approach still works.
+    Mix.PubSub.start()
+
+    if "--no-archives-check" not in args do
+      Mix.Task.run("archive.check", args)
+    end
+
+    config = Mix.Project.config()
+
+    if "--no-elixir-version-check" not in args do
+      check_elixir_version(config)
+    end
+
+    all = Mix.Dep.load_and_cache()
+
+    all =
+      if "--no-optional-deps" in args do
+        for dep <- all, dep.opts[:optional] != true, do: dep
+      else
+        all
+      end
+
+    if "--no-deps-check" not in args do
+      deps_check(config, all, "--no-compile" in args)
+    end
+
+    Code.prepend_paths(Enum.flat_map(all, &Mix.Dep.load_paths/1), cache: true)
+
+    # For now we only allow listeners defined in dependencies,
+    # so we start them right after adding adding deps to the path,
+    # as long as we are sure they have been compiled
+    if "--listeners" in args or
+         ("--no-listeners" not in args and "--no-deps-check" not in args) do
+      Mix.PubSub.start_listeners()
+    end
+
+    :ok
+  end
+
+  defp check_elixir_version(config) do
+    if req = config[:elixir] do
+      case Version.parse_requirement(req) do
+        {:ok, req} ->
+          if not Version.match?(System.version(), req) do
+            raise Mix.ElixirVersionError,
+              target: config[:app] || Mix.Project.get(),
+              expected: req,
+              actual: System.version()
+          end
+
+        :error ->
+          Mix.raise("Invalid Elixir version requirement #{req} in mix.exs file")
+      end
+    end
+  end
+
+  defp deps_check(config, all, no_compile?) do
+    with {:compile, _to_compile} <- deps_check(all, no_compile?) do
+      # We need to compile, we first grab the lock, then, we check
+      # again and compile if still applicable
+      Mix.Project.with_build_lock(config, fn ->
+        all = reload_deps(all)
+
+        with {:compile, to_compile} <- deps_check(all, no_compile?) do
+          Mix.Tasks.Deps.Compile.compile(to_compile)
+
+          to_compile
+          |> reload_deps()
+          |> Enum.filter(&(not Mix.Dep.ok?(&1)))
+          |> show_not_ok!()
+        end
+      end)
+    end
+  end
+
+  defp deps_check(all, no_compile?) do
+    all = Enum.map(all, &check_lock/1)
+    {not_ok, to_compile} = partition(all, [], [])
+
+    cond do
+      not_ok != [] ->
+        show_not_ok!(not_ok)
+
+      to_compile == [] or no_compile? ->
+        :ok
+
+      true ->
+        {:compile, to_compile}
+    end
+  end
+
+  defp partition([dep | deps], not_ok, compile) do
+    cond do
+      Mix.Dep.compilable?(dep) or (Mix.Dep.ok?(dep) and local?(dep)) ->
+        if from_umbrella?(dep) do
+          partition(deps, not_ok, compile)
+        else
+          partition(deps, not_ok, [dep | compile])
+        end
+
+      Mix.Dep.ok?(dep) ->
+        partition(deps, not_ok, compile)
+
+      true ->
+        partition(deps, [dep | not_ok], compile)
     end
+  end
+
+  defp partition([], not_ok, compile) do
+    {Enum.reverse(not_ok), Enum.reverse(compile)}
+  end
+
+  # Children from the umbrella are compiled sequentially by the umbrella project itself.
+  # We could start compiling them as dependencies, and therefore in parallel, but because
+  # `mix compile` in an umbrella is expected to return the diagnostics of all children,
+  # we would need a pass after compilation to compite diagnostics.
+  defp from_umbrella?(dep) do
+    dep.opts[:from_umbrella]
+  end
+
+  defp reload_deps(deps) do
+    deps
+    |> Enum.map(& &1.app)
+    |> Mix.Dep.filter_by_name(Mix.Dep.load_and_cache())
+  end
+
+  # Every local dependency (i.e. that are not fetchable)
+  # are automatically recompiled if they are ok.
+  defp local?(dep) do
+    not dep.scm.fetchable?()
+  end
+
+  defp show_not_ok!([]) do
+    :ok
+  end
+
+  defp show_not_ok!(deps) do
+    shell = Mix.shell()
+    shell.error("Unchecked dependencies for environment #{Mix.env()}:")
 
-    config = Mix.Project.config
+    Enum.each(deps, fn dep ->
+      shell.error("* #{format_dep(dep)}")
+      shell.error("  #{format_status(dep)}")
+    end)
 
-    Mix.Project.build_path(config)
-    |> Path.join("lib/*/ebin")
-    |> Path.wildcard
-    |> List.delete(not Mix.Project.umbrella? && Mix.Project.compile_path(config))
-    |> Enum.each(&Code.prepend_path/1)
+    Mix.raise("Can't continue due to errors on dependencies")
   end
 end
diff --git a/lib/mix/lib/mix/tasks/deps.partition.ex b/lib/mix/lib/mix/tasks/deps.partition.ex
new file mode 100644
index 00000000000..3c28119a298
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/deps.partition.ex
@@ -0,0 +1,283 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Mix.Tasks.Deps.Partition do
+  @moduledoc false
+  use Mix.Task
+
+  ## Server
+
+  def server(deps, count, force?) do
+    {:ok, socket} = :gen_tcp.listen(0, [:binary, packet: :line, active: false])
+
+    try do
+      server(socket, deps, count, force?)
+    after
+      :gen_tcp.close(socket)
+    end
+  end
+
+  defp server(socket, deps, count, force?) do
+    elixir =
+      System.get_env("MIX_OS_DEPS_COMPILE_PARTITION_ELIXIR_EXECUTABLE") ||
+        System.find_executable("elixir") ||
+        raise "cannot find elixir executable for partition compilation"
+
+    {:ok, {_ip, port}} = :inet.sockname(socket)
+    ansi_flag = if IO.ANSI.enabled?(), do: ~c"--color", else: ~c"--no-color"
+    force_flag = if force?, do: ~c"--force", else: ~c"--no-force"
+
+    args = [
+      ansi_flag,
+      ~c"-e",
+      ~c"Mix.Tasks.Deps.Partition.client",
+      ~c"--",
+      force_flag,
+      ~c"--port",
+      Integer.to_charlist(port),
+      ~c"--host",
+      ~c"127.0.0.1",
+      ~c"--config",
+      Mix.ProjectStack.peek() |> :erlang.term_to_binary() |> Base.url_encode64()
+    ]
+
+    options = [
+      :exit_status,
+      :binary,
+      :hide,
+      :use_stdio,
+      :stderr_to_stdout,
+      line: 1_000_000,
+      env: [
+        {~c"MIX_OS_CONCURRENCY_LOCK", ~c"false"},
+        {~c"MIX_ENV", Atom.to_charlist(Mix.env())},
+        {~c"MIX_TARGET", Atom.to_charlist(Mix.target())}
+      ]
+    ]
+
+    ports =
+      Map.new(1..count//1, fn index ->
+        if Mix.debug?() do
+          IO.puts("-> Starting mix deps.partition ##{index}")
+        end
+
+        args = args ++ [~c"--index", Integer.to_charlist(index)]
+        port = Port.open({:spawn_executable, String.to_charlist(elixir)}, [args: args] ++ options)
+
+        {index, port}
+      end)
+
+    clients =
+      Enum.map(1..count//1, fn _ ->
+        with {:ok, client} <- :gen_tcp.accept(socket, 15_000),
+             {:ok, message} <- :gen_tcp.recv(client, 0, 15_000) do
+          :inet.setopts(client, active: true)
+          index = message |> String.trim() |> String.to_integer()
+          %{port: Map.fetch!(ports, index), index: index, socket: client}
+        else
+          error ->
+            logs =
+              Enum.map_join(ports, "\n", fn {index, port} -> close_port(port, "#{index} >") end)
+
+            Mix.raise("""
+            could not start partition dependency compiler, no connection made to TCP port: #{inspect(error)}
+
+            #{logs}
+            """)
+        end
+      end)
+
+    status = Map.new(deps, &{&1.app, :pending})
+    send_deps_and_server_loop(clients, [], deps, status)
+  end
+
+  defp send_deps_and_server_loop(available, busy, deps, status) do
+    {available, busy, deps} = send_deps(available, busy, deps, status)
+    server_loop(available, busy, deps, status)
+  end
+
+  defp send_deps([client | available], busy, deps, status) do
+    case pop_with(deps, fn dep ->
+           Enum.all?(dep.deps, &(Map.get(status, &1.app, :unknown) != :pending))
+         end) do
+      :error ->
+        {[client | available], busy, deps}
+
+      {dep, deps} ->
+        if Mix.debug?() do
+          Mix.shell().info("-- Sending #{dep.app} to mix deps.partition #{client.index}")
+        end
+
+        :gen_tcp.send(client.socket, "#{dep.app}\n")
+        send_deps(available, [client | busy], deps, status)
+    end
+  end
+
+  defp send_deps([], busy, deps, _status) do
+    {[], busy, deps}
+  end
+
+  defp server_loop(available, _busy = [], _deps = [], status) do
+    shutdown_clients(available)
+    Enum.any?(status, &(elem(&1, 1) == true))
+  end
+
+  defp server_loop(available, busy, deps, status) do
+    receive do
+      {:tcp, socket, data} ->
+        [app, compiled?] =
+          data |> String.trim() |> String.split(":") |> Enum.map(&String.to_atom/1)
+
+        deps = Enum.reject(deps, &(&1.app == app))
+        status = Map.replace!(status, app, compiled?)
+        {client, busy} = pop_with(busy, &(&1.socket == socket))
+
+        if Mix.debug?() do
+          Mix.shell().info("-- mix deps.partition #{client.index} compiled #{app}")
+        end
+
+        send_deps_and_server_loop([client | available], busy, deps, status)
+
+      {:tcp_closed, socket} ->
+        tcp_failed!("closed unexpectedly", socket, available, busy)
+
+      {:tcp_error, socket, error} ->
+        tcp_failed!("errored: #{inspect(error)}", socket, available, busy)
+
+      {port, {:data, {eol, data}}} ->
+        with %{index: index} <-
+               Enum.find(busy, &(&1.port == port)) || Enum.find(available, &(&1.port == port)) do
+          terminator = if eol == :eol, do: "\n", else: ""
+          IO.write([Integer.to_string(index), "> ", data, terminator])
+        end
+
+        server_loop(available, busy, deps, status)
+    end
+  end
+
+  defp pop_with(list, fun) do
+    case Enum.split_while(list, &(not fun.(&1))) do
+      {_, []} -> :error
+      {pre, [result | post]} -> {result, pre ++ post}
+    end
+  end
+
+  defp tcp_failed!(message, socket, available, busy) do
+    {%{port: port} = client, busy} = pop_with(busy, &(&1.socket == socket))
+
+    # Let's make sure it has all been written out
+    # but don't wait for more than 5 seconds if it
+    # gets stuck for some unknown reason
+    receive do
+      {^port, {:exit_status, _}} -> :ok
+    after
+      5_000 -> Mix.shell().error("Timed out waiting for port exit #{inspect(port)}")
+    end
+
+    shutdown_clients(available ++ busy ++ [client])
+
+    Mix.raise(
+      "mix deps.partition #{inspect(socket)} #{message} " <>
+        "(set MIX_OS_DEPS_COMPILE_PARTITION_COUNT=1 to run in serial)"
+    )
+  end
+
+  defp shutdown_clients(clients) do
+    Enum.each(clients, fn %{socket: socket, port: port, index: index} ->
+      if Mix.debug?() do
+        IO.puts("-> Closing mix deps.partition ##{index}")
+      end
+
+      _ = :gen_tcp.close(socket)
+      IO.write(close_port(port, "#{index}> "))
+    end)
+  end
+
+  defp close_port(port, prefix) do
+    try do
+      Port.close(port)
+    catch
+      _, _ -> :ok
+    end
+
+    loop_close_port(port, prefix)
+  end
+
+  defp loop_close_port(port, prefix) do
+    receive do
+      {^port, {:data, {:eol, data}}} -> [prefix, data, ?\n | loop_close_port(port, prefix)]
+      {^port, {:data, {:noeol, data}}} -> [data | loop_close_port(port, prefix)]
+      {^port, {:exit_status, _}} -> loop_close_port(port, prefix)
+    after
+      0 -> []
+    end
+  end
+
+  ## Client
+
+  @switches [port: :integer, host: :string, force: :boolean, index: :string, config: :string]
+
+  def client do
+    # If stdin closes, we shutdown the VM
+    spawn(fn ->
+      _ = IO.gets("")
+      System.halt(0)
+    end)
+
+    args = System.argv()
+    {opts, []} = OptionParser.parse!(args, strict: @switches)
+    peek = Keyword.fetch!(opts, :config) |> Base.url_decode64!() |> :erlang.binary_to_term()
+
+    # This is specific to Mix.install/2 and how it handles compile-time config
+    if compile_config = peek.config[:compile_config] do
+      Application.put_all_env(compile_config, persistent: true)
+    end
+
+    partition_args =
+      opts
+      |> Keyword.take([:host, :port, :index, :force])
+      |> OptionParser.to_argv()
+
+    Mix.start()
+    Mix.ProjectStack.push(peek.name, peek.config, peek.file)
+    Mix.CLI.main(["deps.partition" | partition_args], nil)
+  end
+
+  @impl true
+  def run(args) do
+    {opts, []} = OptionParser.parse!(args, strict: @switches)
+    host = Keyword.fetch!(opts, :host)
+    port = Keyword.fetch!(opts, :port)
+    index = Keyword.fetch!(opts, :index)
+    force? = Keyword.get(opts, :force, false)
+
+    {:ok, socket} =
+      :gen_tcp.connect(String.to_charlist(host), port, [:binary, packet: :line, active: false])
+
+    :gen_tcp.send(socket, "#{index}\n")
+
+    try do
+      deps = Mix.Dep.load_and_cache()
+      client_loop(socket, deps, force?, Mix.Project.deps_config())
+    after
+      :gen_tcp.close(socket)
+    end
+  end
+
+  def client_loop(socket, deps, force?, config) do
+    case :gen_tcp.recv(socket, 0, :infinity) do
+      {:ok, app} ->
+        app = app |> String.trim() |> String.to_atom()
+
+        dep =
+          Enum.find(deps, &(&1.app == app)) || raise "could not find dependency #{inspect(app)}"
+
+        compiled? = Mix.Tasks.Deps.Compile.compile_single(dep, force?, config)
+        :ok = :gen_tcp.send(socket, "#{app}:#{compiled?}\n")
+        client_loop(socket, deps, force?, config)
+
+      {:error, :closed} ->
+        :ok
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/deps.precompile.ex b/lib/mix/lib/mix/tasks/deps.precompile.ex
new file mode 100644
index 00000000000..a4843c5d0c1
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/deps.precompile.ex
@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Deps.Precompile do
+  use Mix.Task
+
+  @moduledoc """
+  Extension point for precompiling dependencies.
+
+  This is a task that can be aliased by projects
+  that need to execute certain tasks before
+  compiling dependencies:
+
+      aliases: ["deps.precompile": ["nerves.precompile", "deps.precompile"]]
+
+  """
+
+  @impl true
+  def run(_) do
+    :ok
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/deps.tree.ex b/lib/mix/lib/mix/tasks/deps.tree.ex
new file mode 100644
index 00000000000..398d130ec6c
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/deps.tree.ex
@@ -0,0 +1,182 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Deps.Tree do
+  use Mix.Task
+
+  @shortdoc "Prints the dependency tree"
+  @recursive true
+
+  @moduledoc """
+  Prints the dependency tree.
+
+      $ mix deps.tree
+
+  If no dependency is given, it uses the tree defined in the `mix.exs` file.
+
+  ## Command line options
+
+    * `--only` - the environment to show dependencies for.
+
+    * `--target` - the target to show dependencies for.
+
+    * `--exclude` - exclude dependencies which you do not want to see printed. You can
+      pass this flag multiple times to exclude multiple dependencies.
+
+    * `--umbrella-only` *(since v1.17.0)* - only include the umbrella applications.
+      This is useful when you have an umbrella project and want to see the
+      relationship between the apps in the project.
+
+    * `--format` - can be set to one of either:
+
+      * `pretty` - uses Unicode code points for formatting the tree.
+        This is the default except on Windows.
+
+      * `plain` - does not use Unicode code points for formatting the tree.
+        This is the default on Windows.
+
+      * `dot` - produces a DOT graph description of the dependency tree
+        in `deps_tree.dot` in the current directory.
+        Warning: this will override any previously generated file.
+
+  ## Examples
+
+  Print the dependency tree for the `:test` environment:
+
+      $ mix deps.tree --only test
+
+  Exclude the `:ecto` and `:phoenix` dependencies:
+
+      $ mix deps.tree --exclude ecto --exclude phoenix
+
+  Only print the tree for the `:bandit` and `:phoenix` dependencies:
+
+      $ mix deps.tree --include bandit --include phoenix
+
+  """
+
+  @switches [
+    only: :string,
+    target: :string,
+    exclude: :keep,
+    umbrella_only: :boolean,
+    format: :string
+  ]
+
+  @impl true
+  def run(args) do
+    Mix.Project.get!()
+    {opts, args, _} = OptionParser.parse(args, switches: @switches)
+
+    deps_opts =
+      for {switch, key} <- [only: :env, target: :target],
+          value = opts[switch],
+          do: {key, :"#{value}"}
+
+    deps = Mix.Dep.Converger.converge(deps_opts)
+
+    root =
+      case args do
+        [] ->
+          Mix.Project.config()[:app] ||
+            Mix.raise("no application given and none found in mix.exs file")
+
+        [app] ->
+          app = String.to_atom(app)
+          find_dep(deps, app) || Mix.raise("could not find dependency #{app}")
+      end
+
+    if opts[:format] == "dot" do
+      callback = callback(&format_dot/1, deps, opts)
+      Mix.Utils.write_dot_graph!("deps_tree.dot", "dependency tree", [root], callback, opts)
+
+      """
+      Generated "deps_tree.dot" in the current directory. To generate a PNG:
+
+          dot -Tpng deps_tree.dot -o deps_tree.png
+
+      For more options see http://www.graphviz.org/.
+      """
+      |> String.trim_trailing()
+      |> Mix.shell().info()
+    else
+      callback = callback(&format_tree/1, deps, opts)
+      Mix.Utils.print_tree([root], callback, opts)
+    end
+  end
+
+  defp callback(formatter, deps, opts) do
+    umbrella_only? = Keyword.get(opts, :umbrella_only, false)
+    excluded = Keyword.get_values(opts, :exclude) |> Enum.map(&String.to_atom/1)
+
+    if umbrella_only? && !Mix.Project.parent_umbrella_project_file() do
+      Mix.raise("The --umbrella-only option can only be used in umbrella projects")
+    end
+
+    top_level = Enum.filter(deps, & &1.top_level)
+
+    fn
+      %Mix.Dep{app: app} = dep ->
+        # Do not show dependencies if they were
+        # already shown at the top level
+        deps =
+          if not dep.top_level && find_dep(top_level, app) do
+            []
+          else
+            find_dep(deps, app).deps
+          end
+
+        {formatter.(dep), select_and_sort(deps, excluded, umbrella_only?)}
+
+      app ->
+        {{Atom.to_string(app), nil}, select_and_sort(top_level, excluded, umbrella_only?)}
+    end
+  end
+
+  defp select_and_sort(deps, excluded, umbrella_only?) do
+    deps
+    |> filter_umbrella_only(umbrella_only?)
+    |> Enum.reject(&(&1.app in excluded))
+    |> Enum.sort_by(& &1.app)
+  end
+
+  defp filter_umbrella_only(deps, umbrella_only?) do
+    if umbrella_only? do
+      Enum.filter(deps, fn %Mix.Dep{opts: opts} -> opts[:in_umbrella] end)
+    else
+      deps
+    end
+  end
+
+  defp format_dot(%{app: app, requirement: requirement, opts: opts}) do
+    override =
+      if opts[:override] do
+        " *override*"
+      else
+        ""
+      end
+
+    requirement = requirement && requirement(requirement)
+    {app, "#{requirement}#{override}"}
+  end
+
+  defp format_tree(%{app: app, scm: scm, requirement: requirement, opts: opts}) do
+    override =
+      if opts[:override] do
+        IO.ANSI.format([:bright, " *override*"])
+      else
+        ""
+      end
+
+    requirement = requirement && "#{requirement(requirement)} "
+    {app, "#{requirement}(#{scm.format(opts)})#{override}"}
+  end
+
+  defp requirement(%Regex{} = regex), do: "#{inspect(regex)}"
+  defp requirement(binary) when is_binary(binary), do: binary
+
+  defp find_dep(deps, app) do
+    Enum.find(deps, &(&1.app == app))
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/deps.unlock.ex b/lib/mix/lib/mix/tasks/deps.unlock.ex
index 34d2f5587e5..9bc109578d7 100644
--- a/lib/mix/lib/mix/tasks/deps.unlock.ex
+++ b/lib/mix/lib/mix/tasks/deps.unlock.ex
@@ -1,33 +1,114 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Deps.Unlock do
   use Mix.Task
 
-  @shortdoc "Unlock the given dependencies"
+  @shortdoc "Unlocks the given dependencies"
 
   @moduledoc """
-  Unlock the given dependencies.
+  Unlocks the given dependencies.
+
+  Since this is a destructive action, unlocking dependencies
+  only occurs when passing arguments/options:
+
+    * `dep1 dep2` - the name of dependencies to be unlocked
+    * `--all` - unlocks all dependencies
+    * `--filter` - unlocks only deps matching the given name
+    * `--unused` - unlocks only unused dependencies (no longer mentioned
+      in the `mix.exs` file)
+    * `--check-unused` - checks that the `mix.lock` file has no unused
+      dependencies. This is useful in pre-commit hooks and CI scripts
+      if you want to reject contributions with extra dependencies
 
-  Since this is a destructive action, unlocking of all dependencies
-  can only happen by passing the `--all` command line option.
   """
 
+  @switches [all: :boolean, check_unused: :boolean, unused: :boolean, filter: :string]
+
+  @impl true
   def run(args) do
-    Mix.Project.get! # Require the project to be available
-    {opts, args, _} = OptionParser.parse(args, switches: [unlock: :boolean, all: :boolean])
+    Mix.Project.get!()
+    {opts, apps, _} = OptionParser.parse(args, switches: @switches)
+
+    Mix.Project.with_deps_lock(fn ->
+      do_run(opts, apps)
+    end)
+  end
 
+  defp do_run(opts, apps) do
     cond do
       opts[:all] ->
-        Mix.Dep.Lock.write([])
-      args != [] ->
-        lock =
-          Enum.reduce args, Mix.Dep.Lock.read, fn(arg, lock) ->
-            if is_binary(arg), do: arg = String.to_atom(arg)
-            Map.delete(lock, arg)
-          end
-
-        Mix.Dep.Lock.write(lock)
+        Mix.Dep.Lock.write(%{})
+
+      opts[:check_unused] ->
+        lock = Mix.Dep.Lock.read()
+        unused_apps = unused_apps(lock)
+
+        if unused_apps != [] do
+          Mix.raise("""
+          Unused dependencies in mix.lock file:
+
+          #{Enum.map_join(unused_apps, "\n", fn app -> "  * #{inspect(app)}" end)}
+          """)
+        end
+
+      opts[:unused] ->
+        lock = Mix.Dep.Lock.read()
+        unused_apps = unused_apps(lock)
+
+        if unused_apps != [] do
+          unlock(lock, unused_apps)
+        end
+
+      filter = opts[:filter] ->
+        lock = Mix.Dep.Lock.read()
+        apps = lock |> Map.keys() |> Enum.filter(&(Atom.to_string(&1) =~ filter))
+
+        if apps == [] do
+          Mix.shell().error("warning: no dependencies were matched")
+        else
+          unlock(lock, apps)
+        end
+
+      apps != [] ->
+        lock = Mix.Dep.Lock.read()
+        apps = Enum.map(apps, &String.to_atom/1)
+        unlocked = apps -- Map.keys(lock)
+
+        for app <- unlocked do
+          Mix.shell().error("warning: #{app} dependency is not locked")
+        end
+
+        unlock(lock, apps -- unlocked)
+
       true ->
-        Mix.raise "mix deps.unlock expects dependencies as arguments or " <>
-                                  "the --all option to unlock all dependencies"
+        Mix.raise(
+          "\"mix deps.unlock\" expects dependencies as arguments or " <>
+            "an option indicating which dependencies to unlock. " <>
+            "The --all option will unlock all dependencies while " <>
+            "the --unused option unlocks unused dependencies"
+        )
+    end
+  end
+
+  defp unused_apps(lock) do
+    apps = Mix.Dep.Converger.converge([]) |> Enum.map(& &1.app)
+
+    lock
+    |> Map.drop(apps)
+    |> Map.keys()
+    |> Enum.sort()
+  end
+
+  defp unlock(lock, apps) do
+    if apps != [] do
+      lock |> Map.drop(apps) |> Mix.Dep.Lock.write()
+
+      Mix.shell().info("""
+      Unlocked deps:
+      * #{Enum.join(apps, "\n* ")}
+      """)
     end
   end
 end
diff --git a/lib/mix/lib/mix/tasks/deps.update.ex b/lib/mix/lib/mix/tasks/deps.update.ex
index d5cfaa41f77..4e650a9c8ce 100644
--- a/lib/mix/lib/mix/tasks/deps.update.ex
+++ b/lib/mix/lib/mix/tasks/deps.update.ex
@@ -1,43 +1,84 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Deps.Update do
   use Mix.Task
 
-  @shortdoc "Update the given dependencies"
+  @shortdoc "Updates the given dependencies"
 
   @moduledoc """
-  Update the given dependencies.
+  Updates the given dependencies.
+
+  The given dependencies and the projects they depend on will
+  be unlocked and updated to the latest version according to their
+  version requirements.
 
-  Since this is a destructive action, update of all dependencies
-  can only happen by passing the `--all` command line option.
+  Since this is a destructive action, updating all dependencies
+  only occurs when the `--all` command line option is passed.
 
   All dependencies are automatically recompiled after update.
 
+  ## mix deps.unlock + mix deps.get
+
+  Upgrading a dependency often requires the projects it depends on
+  to upgrade too. If you would rather update a single dependency and
+  not touch its children, you can explicitly unlock the single dependency
+  and run `mix deps.get`:
+
+      $ mix deps.unlock some_dep
+      $ mix deps.get
+
   ## Command line options
 
-    * `--all`  - update all dependencies
-    * `--only` - only fetch dependencies for given environment
+    * `--all` - updates all dependencies
+    * `--only` - only fetches dependencies for given environment
+    * `--target` - only fetches dependencies for given target
+    * `--no-archives-check` - does not check archives before fetching deps
+
   """
+
+  @impl true
   def run(args) do
-    Mix.Project.get! # Require the project to be available
-    {opts, rest, _} = OptionParser.parse(args, switches: [all: :boolean, only: :string])
+    if "--no-archives-check" not in args do
+      Mix.Task.run("archive.check", args)
+    end
 
-    # Fetch all deps by default unless --only is given
-    fetch_opts = if only = opts[:only], do: [env: :"#{only}"], else: []
+    Mix.Project.get!()
+
+    {opts, rest, _} =
+      OptionParser.parse(args, switches: [all: :boolean, only: :string, target: :string])
+
+    Mix.Project.with_deps_lock(fn ->
+      do_run(opts, rest)
+    end)
+  end
+
+  defp do_run(opts, rest) do
+    fetch_opts =
+      for {switch, key} <- [only: :env, target: :target],
+          value = opts[switch],
+          do: {key, :"#{value}"}
 
     cond do
       opts[:all] ->
-        Mix.Dep.Fetcher.all(Mix.Dep.Lock.read, %{}, fetch_opts)
+        Mix.Dep.Fetcher.all(Mix.Dep.Lock.read(), %{}, fetch_opts)
+
       rest != [] ->
-        {old, new} = Dict.split(Mix.Dep.Lock.read, to_app_names(rest))
+        {old, new} = Map.split(Mix.Dep.Lock.read(), to_app_names(rest))
         Mix.Dep.Fetcher.by_name(rest, old, new, fetch_opts)
+
       true ->
-        Mix.raise "mix deps.update expects dependencies as arguments or " <>
-                                  "the --all option to update all dependencies"
+        Mix.raise(
+          "\"mix deps.update\" expects dependencies as arguments or " <>
+            "the --all option to update all dependencies"
+        )
     end
   end
 
   defp to_app_names(given) do
-    Enum.map given, fn(app) ->
+    Enum.map(given, fn app ->
       if is_binary(app), do: String.to_atom(app), else: app
-    end
+    end)
   end
 end
diff --git a/lib/mix/lib/mix/tasks/do.ex b/lib/mix/lib/mix/tasks/do.ex
index 9aa6984827d..ab4cf23e390 100644
--- a/lib/mix/lib/mix/tasks/do.ex
+++ b/lib/mix/lib/mix/tasks/do.ex
@@ -1,41 +1,153 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Do do
   use Mix.Task
 
-  @shortdoc "Executes the tasks separated by comma"
+  @shortdoc "Executes the tasks separated by plus"
 
   @moduledoc """
-  Executes the tasks separated by comma.
+  Executes the tasks separated by `+`, aborting if any task errors.
+
+  Here is an example:
+
+      $ mix do compile --list + deps
+
+  The plus should be followed by at least one space before and after.
 
   ## Examples
 
   The example below prints the available compilers and
   then the list of dependencies.
 
-      mix do compile --list, deps
+      $ mix do compile --list + deps
+
+  Note that the majority of Mix tasks are only executed once
+  per invocation. So for example, the following command will
+  only compile once:
+
+      $ mix do compile + some_other_command + compile
+
+  When `compile` is executed again, Mix will notice the task
+  has already ran, and skip it.
+
+  Inside umbrella projects, you can limit recursive tasks
+  (the ones that run inside every app) by selecting the
+  desired application via the `--app` flag after `do` and
+  before the first task:
+
+      $ mix do --app app1 --app app2 compile --list + deps
+
+  Elixir versions prior to v1.14 used the comma exclusively
+  to separate commands:
+
+      $ mix do compile --list, deps
+
+  Since then, the `+` operator has been introduced as a
+  separator for better support on Windows terminals.
+
+  ## Error handling
+
+  If any task in the list of tasks exits with an error,
+  no subsequent tasks will be run. For instance:
+
+      $ mix do compile + test
+
+  If the compilation step fails, the tests will not be
+  attempted.
+
+  ## Command line options
+
+    * `--app` - limit recursive tasks to the given apps.
+      This option may be given multiple times and must come
+      before any of the tasks.
 
   """
+
+  @impl true
   def run(args) do
-    Enum.each gather_commands(args), fn
-      [task|args] -> Mix.Task.run task, args
-      [] -> Mix.raise "No expression between commas"
+    Mix.Task.reenable("do")
+
+    {apps, args} = extract_apps_from_args(args)
+    show_forgotten_apps_warning(apps)
+
+    Enum.each(gather_commands(args), fn
+      [task | args] ->
+        if apps == [] do
+          Mix.Task.run(task, args)
+        else
+          Mix.Task.run_in_apps(task, apps, args)
+        end
+
+      [] ->
+        Mix.raise("""
+        One of the commands passed to "mix do" is empty. Each command passed to "mix do" must \
+        have at least the task name. These are all invalid:
+
+          mix do
+          mix do my_task +
+          mix do + my_task
+
+        Run "mix help do" for more information.
+        """)
+    end)
+  end
+
+  defp show_forgotten_apps_warning([]), do: nil
+
+  defp show_forgotten_apps_warning(apps) do
+    config = Mix.Project.config()
+
+    if Mix.Project.umbrella?(config) do
+      known_apps = Mix.Project.apps_paths(config)
+
+      for app <- apps, not Map.has_key?(known_apps, app) do
+        Mix.shell().info([:yellow, "warning: could not find application #{inspect(app)}"])
+      end
     end
   end
 
-  defp gather_commands(args) do
-    gather_commands args, [], []
+  defp extract_apps_from_args(args) do
+    {opts, args} = OptionParser.parse_head!(args, strict: [app: :keep])
+
+    apps =
+      opts
+      |> Keyword.get_values(:app)
+      |> Enum.map(&String.to_atom/1)
+
+    {apps, args}
+  end
+
+  @doc false
+  def gather_commands(args) do
+    gather_commands(args, [], [])
+  end
+
+  defp gather_commands([head | rest], current, acc)
+       when binary_part(head, byte_size(head), -1) == "," do
+    IO.warn(
+      "using commas as separators in \"mix do\" is deprecated, use + between commands instead"
+    )
+
+    current =
+      case binary_part(head, 0, byte_size(head) - 1) do
+        "" -> Enum.reverse(current)
+        part -> Enum.reverse([part | current])
+      end
+
+    gather_commands(rest, [], [current | acc])
   end
 
-  defp gather_commands([h|t], current, acc) when binary_part(h, byte_size(h), -1) == "," do
-    part    = binary_part(h, 0, byte_size(h) - 1)
-    current = Enum.reverse([part|current])
-    gather_commands t, [], [current|acc]
+  defp gather_commands(["+" | rest], current, acc) do
+    gather_commands(rest, [], [Enum.reverse(current) | acc])
   end
 
-  defp gather_commands([h|t], current, acc) do
-    gather_commands t, [h|current], acc
+  defp gather_commands([head | rest], current, acc) do
+    gather_commands(rest, [head | current], acc)
   end
 
   defp gather_commands([], current, acc) do
-    Enum.reverse [Enum.reverse(current)|acc]
+    Enum.reverse([Enum.reverse(current) | acc])
   end
-end
\ No newline at end of file
+end
diff --git a/lib/mix/lib/mix/tasks/escript.build.ex b/lib/mix/lib/mix/tasks/escript.build.ex
new file mode 100644
index 00000000000..53629183a9c
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/escript.build.ex
@@ -0,0 +1,484 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Escript.Build do
+  use Mix.Task
+  import Bitwise, only: [|||: 2]
+
+  @shortdoc "Builds an escript for the project"
+  @recursive true
+
+  @moduledoc ~S"""
+  Builds an escript for the project.
+
+  An escript is an executable that can be invoked from the
+  command line. An escript can run on any machine that has
+  Erlang/OTP installed and by default does not require Elixir to
+  be installed, as Elixir is embedded as part of the escript.
+
+  This task guarantees the project and its dependencies are
+  compiled and packages them inside an escript. Before invoking
+  `mix escript.build`, it is only necessary to define a `:escript`
+  key with a `:main_module` option in your `mix.exs` file:
+
+      escript: [main_module: MyApp.CLI]
+
+  Escripts should be used as a mechanism to share scripts between
+  developers and not as a deployment mechanism. For running live
+  systems, consider using `mix run` or building releases. See
+  the `Application` module for more information on systems
+  life cycles.
+
+  All of the configuration defined in `config/config.exs` will
+  be included as part of the escript. `config/runtime.exs` is also
+  included for Elixir escripts. Once the configuration is loaded,
+  this task starts the current application. If this is not desired,
+  set the `:app` configuration to nil.
+
+  This task also removes documentation and debugging chunks from
+  the compiled `.beam` files to reduce the size of the escript.
+  If this is not desired, check the `:strip_beams` option.
+
+  ## Command line options
+
+  Expects the same command line options as `mix compile`.
+
+  ## Configuration
+
+  The following option must be specified in your `mix.exs`
+  under the `:escript` key:
+
+    * `:main_module` - the module to be invoked once the escript starts.
+      The module must contain a function named `main/1` that will receive the
+      command line arguments. By default the arguments are given as a list of
+      binaries, but if project is configured with `language: :erlang` it will
+      be a list of charlists.
+
+  The remaining options can be specified to further customize the escript:
+
+    * `:name` - the name of the generated escript.
+      Defaults to app name.
+
+    * `:path` - the path to write the escript to.
+      Defaults to app name.
+
+    * `:app` - the app that starts with the escript.
+      Defaults to app name. Set it to `nil` if no application should
+      be started.
+
+    * `:strip_beams` - if `true` strips BEAM code in the escript to remove chunks
+      unnecessary at runtime, such as debug information and documentation.
+      Can be set to `[keep: ["Docs", "Dbgi"]]` to strip while keeping some chunks
+      that would otherwise be stripped, like docs, and debug info, for instance.
+      Defaults to `true`.
+
+    * `:embed_elixir` - if `true` embeds Elixir and its children apps
+      (`ex_unit`, `mix`, and the like) mentioned in the `:applications` list inside the
+      `application/0` function in `mix.exs`.
+
+      Defaults to `true` for Elixir projects, `false` for Erlang projects.
+
+      Note: if you set this to `false` for an Elixir project, you will have to add paths to Elixir's
+      `ebin` directories to `ERL_LIBS` environment variable when running the resulting escript, in
+      order for the code loader to be able to find `:elixir` application and its children
+      applications (if they are used).
+
+    * `:shebang` - shebang interpreter directive used to execute the escript.
+      Defaults to `"#! /usr/bin/env escript\n"`.
+
+    * `:comment` - comment line to follow shebang directive in the escript.
+      Defaults to `""`.
+
+    * `:emu_args` - emulator arguments to embed in the escript file.
+      Defaults to `""`.
+
+    * `:include_priv_for` - a list of application names (atoms) specifying
+      applications which priv directory should be included in the resulting
+      escript archive. Currently the expected way of accessing priv files
+      in an escript is via `:escript.extract/2`. Defaults to `[]`.
+
+  There is one project-level option that affects how the escript is generated:
+
+    * `language: :elixir | :erlang` - set it to `:erlang` for Erlang projects
+      managed by Mix. Doing so will ensure Elixir is not embedded by default.
+      Your app will still be started as part of escript loading, with the
+      config used during build.
+
+  ## Example
+
+  In your `mix.exs`:
+
+      defmodule MyApp.MixProject do
+        use Mix.Project
+
+        def project do
+          [
+            app: :my_app,
+            version: "0.0.1",
+            escript: escript()
+          ]
+        end
+
+        def escript do
+          [main_module: MyApp.CLI]
+        end
+      end
+
+  Then define the entrypoint, such as the following in `lib/cli.ex`:
+
+      defmodule MyApp.CLI do
+        def main(_args) do
+          IO.puts("Hello from MyApp!")
+        end
+      end
+
+  """
+
+  @impl true
+  def run(args) do
+    Mix.Project.get!()
+    Mix.Task.run("compile", args)
+
+    project = Mix.Project.config()
+    language = Keyword.get(project, :language, :elixir)
+    escriptize(project, language)
+  end
+
+  defp escriptize(project, language) do
+    escript_opts = project[:escript] || []
+    script_name = Mix.Local.name_for(:escripts, project)
+    filename = escript_opts[:path] || script_name
+    main = escript_opts[:main_module]
+
+    if !main do
+      error_message =
+        "Could not generate escript, please set :main_module " <>
+          "in your project configuration (under :escript option) to a module that implements main/1. " <>
+          "Run \"mix help escript.build\" for more information"
+
+      Mix.raise(error_message)
+    end
+
+    if not Code.ensure_loaded?(main) do
+      error_message =
+        "Could not generate escript, module #{main} defined as " <>
+          ":main_module could not be loaded"
+
+      Mix.raise(error_message)
+    end
+
+    app = Keyword.get(escript_opts, :app, project[:app])
+
+    # Need to keep :strip_beam option for backward compatibility so
+    # check for correct :strip_beams, then :strip_beam, then
+    # use default true if neither are present.
+    strip_options =
+      escript_opts
+      |> Keyword.get_lazy(:strip_beams, fn ->
+        if Keyword.get(escript_opts, :strip_beam, true) do
+          true
+        else
+          IO.warn(
+            ":strip_beam option in escript.build is deprecated. Please use :strip_beams instead"
+          )
+
+          false
+        end
+      end)
+      |> parse_strip_beams_options()
+
+    escript_mod = String.to_atom(Atom.to_string(app) <> "_escript")
+
+    include_priv_for = MapSet.new(escript_opts[:include_priv_for] || [])
+
+    beam_paths =
+      [
+        project_files(project, include_priv_for),
+        deps_files(include_priv_for),
+        core_files(escript_opts, language, include_priv_for)
+      ]
+      |> Stream.concat()
+      |> replace_consolidated_paths(project)
+
+    tuples = gen_main(project, escript_mod, main, app, language) ++ read_beams(beam_paths)
+    tuples = if strip_options, do: strip_beams(tuples, strip_options), else: tuples
+
+    case :zip.create(~c"mem", tuples, [:memory]) do
+      {:ok, {~c"mem", zip}} ->
+        shebang = escript_opts[:shebang] || "#! /usr/bin/env escript\n"
+        comment = build_comment(escript_opts[:comment])
+        emu_args = build_emu_args(escript_opts[:emu_args], escript_mod)
+
+        script = IO.iodata_to_binary([shebang, comment, emu_args, zip])
+        File.mkdir_p!(Path.dirname(filename))
+        File.write!(filename, script)
+        set_perms(filename)
+
+      {:error, error} ->
+        Mix.raise("Error creating escript: #{error}")
+    end
+
+    Mix.shell().info("Generated escript #{filename} with MIX_ENV=#{Mix.env()}")
+    :ok
+  end
+
+  defp project_files(project, include_priv_for) do
+    get_files(Mix.Project.app_path(), project[:app] in include_priv_for)
+  end
+
+  defp get_files(app_path, include_priv?) do
+    paths = Path.wildcard("#{app_path}/ebin/*.{app,beam}")
+
+    paths =
+      if include_priv? do
+        paths ++ (Path.wildcard("#{app_path}/priv/**/*") |> Enum.filter(&File.regular?/1))
+      else
+        paths
+      end
+
+    apps_dir = Path.dirname(app_path)
+
+    for path <- paths do
+      {Path.relative_to(path, apps_dir), path}
+    end
+  end
+
+  defp set_perms(filename) do
+    stat = File.stat!(filename)
+    :ok = File.chmod(filename, stat.mode ||| 0o111)
+  end
+
+  defp deps_files(include_priv_for) do
+    deps = Mix.Dep.cached()
+    Enum.flat_map(deps, fn dep -> get_files(dep.opts[:build], dep.app in include_priv_for) end)
+  end
+
+  defp core_files(escript_opts, language, include_priv_for) do
+    if Keyword.get(escript_opts, :embed_elixir, language == :elixir) do
+      Enum.flat_map([:elixir | extra_apps()], &app_files(&1, include_priv_for))
+    else
+      []
+    end
+  end
+
+  defp extra_apps() do
+    Mix.Project.config()[:app]
+    |> extra_apps_in_app_tree()
+    |> Enum.uniq()
+  end
+
+  defp extra_apps_in_app_tree(app) when app in [:kernel, :stdlib, :elixir] do
+    []
+  end
+
+  # We include hex in here as it is always an archive and it cannot be depended on
+  defp extra_apps_in_app_tree(app) when app in [:eex, :ex_unit, :iex, :logger, :mix, :hex] do
+    [app]
+  end
+
+  defp extra_apps_in_app_tree(app) do
+    _ = Application.load(app)
+
+    case Application.spec(app) do
+      nil ->
+        []
+
+      spec ->
+        applications =
+          Keyword.get(spec, :applications, []) ++ Keyword.get(spec, :included_applications, [])
+
+        Enum.flat_map(applications, &extra_apps_in_app_tree/1)
+    end
+  end
+
+  defp app_files(app, include_priv_for) do
+    case :code.where_is_file(~c"#{app}.app") do
+      :non_existing -> Mix.raise("Could not find application #{app}")
+      file -> get_files(Path.dirname(Path.dirname(file)), app in include_priv_for)
+    end
+  end
+
+  defp read_beams(items) do
+    Enum.map(items, fn {basename, beam_path} ->
+      {String.to_charlist(basename), File.read!(beam_path)}
+    end)
+  end
+
+  defp parse_strip_beams_options(options) do
+    case options do
+      options when is_list(options) -> options
+      true -> []
+      false -> nil
+    end
+  end
+
+  defp strip_beams(tuples, strip_options) do
+    for {basename, maybe_beam} <- tuples do
+      with ".beam" <- Path.extname(basename),
+           {:ok, binary} <- Mix.Release.strip_beam(maybe_beam, strip_options) do
+        {basename, binary}
+      else
+        _ -> {basename, maybe_beam}
+      end
+    end
+  end
+
+  defp replace_consolidated_paths(files, config) do
+    # We could write modules to a consolidated/ directory and prepend
+    # it to code path using VM args. However, when Erlang Escript
+    # boots, it prepends all second-level ebin/ directories to the
+    # path, so the unconsolidated modules would take precedence.
+    #
+    # Instead of writing consolidated/ into the archive, we replace
+    # the protocol modules with their consolidated version in their
+    # usual location. As a side benefit, this reduces the Escript
+    # file size, since we do not include the unconsolidated modules.
+
+    if config[:consolidate_protocols] do
+      consolidation_path = Mix.Project.consolidation_path(config)
+
+      consolidated =
+        consolidation_path
+        |> Path.join("*")
+        |> Path.wildcard()
+        |> Map.new(fn path -> {Path.basename(path), path} end)
+
+      for {zip_path, path} <- files do
+        {zip_path, consolidated[Path.basename(path)] || path}
+      end
+    else
+      files
+    end
+  end
+
+  defp build_comment(user_comment) do
+    "%% #{user_comment}\n"
+  end
+
+  defp build_emu_args(user_args, escript_mod) do
+    "%%! -escript main #{escript_mod} #{user_args}\n"
+  end
+
+  defp gen_main(project, name, module, app, language) do
+    config_path = project[:config_path]
+
+    compile_config =
+      if File.regular?(config_path) do
+        config = Config.Reader.read!(config_path, env: Mix.env(), target: Mix.target())
+        Macro.escape(config)
+      else
+        []
+      end
+
+    runtime_path = config_path |> Path.dirname() |> Path.join("runtime.exs")
+
+    runtime_config =
+      if File.regular?(runtime_path) do
+        File.read!(runtime_path)
+      end
+
+    module_body =
+      quote do
+        @spec main(OptionParser.argv()) :: any
+        def main(args) do
+          unquote(main_body_for(language, module, compile_config, runtime_config))
+        end
+
+        defp load_config(config) do
+          each_fun = fn {app, kw} ->
+            set_env_fun = fn {k, v} -> :application.set_env(app, k, v, persistent: true) end
+            :lists.foreach(set_env_fun, kw)
+          end
+
+          :lists.foreach(each_fun, config)
+          :ok
+        end
+
+        defp start_app() do
+          unquote(start_app_for(app))
+        end
+
+        defp io_error(message) do
+          :io.put_chars(:standard_error, message)
+        end
+      end
+
+    {:module, ^name, binary, _} = Module.create(name, module_body, Macro.Env.location(__ENV__))
+    [{~c"#{name}.beam", binary}]
+  end
+
+  defp main_body_for(:elixir, module, compile_config, runtime_config) do
+    config =
+      if runtime_config do
+        quote do
+          runtime_config =
+            Config.Reader.eval!(
+              "config/runtime.exs",
+              unquote(runtime_config),
+              env: unquote(Mix.env()),
+              target: unquote(Mix.target()),
+              imports: :disabled
+            )
+
+          Config.Reader.merge(unquote(compile_config), runtime_config)
+        end
+      else
+        compile_config
+      end
+
+    quote do
+      case :application.ensure_all_started(:elixir) do
+        {:ok, _} ->
+          args = Enum.map(args, &List.to_string(&1))
+          System.argv(args)
+          load_config(unquote(config))
+          start_app()
+          Kernel.CLI.run(fn _ -> unquote(module).main(args) end)
+
+        error ->
+          io_error(["ERROR! Failed to start Elixir.\n", :io_lib.format(~c"error: ~p~n", [error])])
+          :erlang.halt(1)
+      end
+    end
+  end
+
+  defp main_body_for(:erlang, module, compile_config, _runtime_config) do
+    quote do
+      load_config(unquote(compile_config))
+      start_app()
+      unquote(module).main(args)
+    end
+  end
+
+  defp start_app_for(nil) do
+    :ok
+  end
+
+  defp start_app_for(app) do
+    quote do
+      case :application.ensure_all_started(unquote(app)) do
+        {:ok, _} ->
+          :ok
+
+        {:error, {app, reason}} ->
+          formatted_error =
+            case :code.ensure_loaded(Application) do
+              {:module, Application} -> Application.format_error(reason)
+              {:error, _} -> :io_lib.format(~c"~p", [reason])
+            end
+
+          error_message = [
+            "ERROR! Could not start application ",
+            :erlang.atom_to_binary(app, :utf8),
+            ": ",
+            formatted_error,
+            ?\n
+          ]
+
+          io_error(error_message)
+          :erlang.halt(1)
+      end
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/escript.ex b/lib/mix/lib/mix/tasks/escript.ex
new file mode 100644
index 00000000000..d805a46e51c
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/escript.ex
@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Escript do
+  use Mix.Task
+
+  @shortdoc "Lists installed escripts"
+
+  @moduledoc ~S"""
+  Lists all installed escripts.
+
+  Escripts are installed at `~/.mix/escripts`. Add that path to your `$PATH` environment variable
+  to be able to run installed escripts from any directory.
+  """
+
+  import Bitwise, only: [|||: 2, &&&: 2]
+
+  @impl true
+  def run(_) do
+    escripts_path = Mix.path_for(:escripts)
+
+    escripts_path
+    |> list_dir()
+    |> Enum.filter(fn filename -> executable?(Path.join(escripts_path, filename)) end)
+    |> print()
+  end
+
+  defp list_dir(path) do
+    case File.ls(path) do
+      {:ok, list} -> list
+      _ -> []
+    end
+  end
+
+  defp executable?(path) do
+    owner_exec_bit = 0o00100
+    group_exec_bit = 0o00010
+    other_exec_bit = 0o00001
+    stat = File.stat!(path)
+
+    case :os.type() do
+      {:win32, _} ->
+        # on win32, the script itself is not executable, but the bat is
+        File.exists?(path <> ".bat") and stat.type == :regular
+
+      _ ->
+        executable_bit = stat.mode &&& (owner_exec_bit ||| group_exec_bit ||| other_exec_bit)
+        executable_bit != 0 and stat.type == :regular and Path.extname(path) != ".bat"
+    end
+  end
+
+  defp print([]) do
+    Mix.shell().info("No escripts currently installed.")
+  end
+
+  defp print(items) do
+    Enum.each(items, fn item -> Mix.shell().info(["* ", item]) end)
+    Mix.shell().info("Escripts installed at: #{Mix.path_for(:escripts)}")
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/escript.install.ex b/lib/mix/lib/mix/tasks/escript.install.ex
new file mode 100644
index 00000000000..86026cf4060
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/escript.install.ex
@@ -0,0 +1,188 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Escript.Install do
+  use Mix.Task
+
+  @shortdoc "Installs an escript locally"
+
+  @moduledoc """
+  Installs an escript locally.
+
+  If no argument is supplied but there is an escript in the project's root directory
+  (created with `mix escript.build`), then the escript will be installed
+  locally. For example:
+
+      $ mix do escript.build + escript.install
+
+  If an argument is provided, it should be a local path to a prebuilt escript,
+  a Git repository, a GitHub repository, or a Hex package.
+
+      $ mix escript.install escript
+      $ mix escript.install path/to/escript
+      $ mix escript.install git https://path/to/git/repo
+      $ mix escript.install git https://path/to/git/repo branch git_branch
+      $ mix escript.install git https://path/to/git/repo tag git_tag
+      $ mix escript.install git https://path/to/git/repo ref git_ref
+      $ mix escript.install github user/project
+      $ mix escript.install github user/project branch git_branch
+      $ mix escript.install github user/project tag git_tag
+      $ mix escript.install github user/project ref git_ref
+      $ mix escript.install hex hex_package
+      $ mix escript.install hex hex_package 1.2.3
+
+  After installation, the escript can be invoked as
+
+      $ ~/.mix/escripts/foo
+
+  For convenience, consider adding `~/.mix/escripts` directory to your
+  `$PATH` environment variable. For more information, check the wikipedia
+  article on PATH: https://en.wikipedia.org/wiki/PATH_(variable)
+
+  ## Command line options
+
+    * `--sha512` - checks the escript matches the given SHA-512 checksum. Only
+      applies to installations via a local path
+
+    * `--force` - forces installation without a shell prompt; primarily
+      intended for automation in build systems like Make
+
+    * `--submodules` - fetches repository submodules before building escript from
+      Git or GitHub
+
+    * `--sparse` - checkout a single directory inside the Git repository and use
+      it as the escript project directory
+
+    * `--app` - specifies a custom app name to be used for building the escript
+      from Git, GitHub, or Hex
+
+    * `--organization` - set this for Hex private packages belonging to an
+      organization
+
+    * `--repo` - set this for self-hosted Hex instances, defaults to `hexpm`
+
+  """
+
+  @behaviour Mix.Local.Installer
+
+  # only read and execute permissions
+  @escript_file_mode 0o555
+
+  @switches [
+    force: :boolean,
+    sha512: :string,
+    submodules: :boolean,
+    sparse: :string,
+    app: :string,
+    organization: :string,
+    repo: :string,
+    timeout: :integer
+  ]
+
+  @impl true
+  def run(argv) do
+    Mix.Local.Installer.install(__MODULE__, argv, @switches)
+  end
+
+  @impl true
+  def check_install_spec({:url, _}, _opts) do
+    :ok
+  end
+
+  def check_install_spec(_, _), do: :ok
+
+  @impl true
+  def find_previous_versions(basename) do
+    dst = destination(basename)
+    if File.exists?(dst), do: [dst], else: []
+  end
+
+  @impl true
+  def install(basename, binary, _previous) do
+    dst = destination(basename)
+
+    if escript?(binary) do
+      _ = File.rm(dst)
+      _ = File.rm(dst <> ".bat")
+
+      executable = Path.basename(dst)
+      previous_executable = System.find_executable(executable)
+
+      File.mkdir_p!(Path.dirname(dst))
+      File.write!(dst, binary)
+      File.chmod!(dst, @escript_file_mode)
+      write_bat!(dst <> ".bat", :os.type())
+
+      Mix.shell().info([:green, "* creating ", :reset, Path.relative_to_cwd(dst)])
+      check_discoverability(dst, executable, previous_executable)
+      :ok
+    else
+      Mix.raise("The given path does not point to an escript, installation aborted")
+    end
+  end
+
+  @impl true
+  def build(_spec, _opts) do
+    Mix.Task.run("loadconfig")
+    Mix.Task.run("escript.build", [])
+    Mix.Local.name_for(:escripts, Mix.Project.config())
+  end
+
+  # Helpers
+
+  defp destination(basename) do
+    Path.join(Mix.path_for(:escripts), basename)
+  end
+
+  defp write_bat!(path, {:win32, _}) do
+    File.write!(path, """
+    @echo off
+    @escript "%~dpn0" %*
+    """)
+
+    File.chmod!(path, @escript_file_mode)
+  end
+
+  defp write_bat!(_path, _type) do
+    :ok
+  end
+
+  defp check_discoverability(dst, executable, previous_executable) do
+    current_executable = System.find_executable(executable)
+
+    cond do
+      # If existing executable was changed,
+      # it was overridden
+      previous_executable && previous_executable != current_executable ->
+        Mix.shell().error(
+          "\nwarning: escript #{inspect(executable)} overrides executable " <>
+            "#{inspect(previous_executable)} already in your PATH\n"
+        )
+
+      # If existing executable didn't change but it is not the one we installed,
+      # it is a conflict
+      previous_executable && previous_executable != dst ->
+        Mix.shell().error(
+          "\nwarning: escript #{inspect(executable)} conflicts with executable " <>
+            "#{inspect(previous_executable)} already in your PATH\n"
+        )
+
+      # If current executable is nil or does not match the one we just installed,
+      # PATH is misconfigured
+      current_executable != dst ->
+        Mix.shell().error(
+          "\nwarning: you must append #{inspect(Mix.path_for(:escripts))} " <>
+            "to your PATH if you want to invoke escripts by name\n"
+        )
+
+      true ->
+        :ok
+    end
+  end
+
+  defp escript?(binary) do
+    parts = String.split(binary, "\n", parts: 4)
+    match?(["#!" <> _, _, _, <<80, 75, 3, 4, _::binary>>], parts)
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/escript.uninstall.ex b/lib/mix/lib/mix/tasks/escript.uninstall.ex
new file mode 100644
index 00000000000..1ccd9e4fd50
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/escript.uninstall.ex
@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Escript.Uninstall do
+  use Mix.Task
+
+  @shortdoc "Uninstalls escripts"
+
+  @moduledoc """
+  Uninstalls local escripts:
+
+      $ mix escript.uninstall escript_name
+
+  ## Command line options
+    * `--force` - forces uninstallation without a shell prompt; primarily
+      intended for automation
+  """
+
+  @switches [
+    force: :boolean
+  ]
+
+  @impl true
+  def run(argv) do
+    if path = Mix.Local.Installer.uninstall(Mix.path_for(:escripts), "escript", argv, @switches) do
+      File.rm(path <> ".bat")
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/escriptize.ex b/lib/mix/lib/mix/tasks/escriptize.ex
deleted file mode 100644
index ebd3f051cf2..00000000000
--- a/lib/mix/lib/mix/tasks/escriptize.ex
+++ /dev/null
@@ -1,225 +0,0 @@
-defmodule Mix.Tasks.Escriptize do
-  use Mix.Task
-  use Bitwise, only_operators: true
-
-  @shortdoc "Generates an escript for the project"
-  @recursive true
-
-  @moduledoc ~S"""
-  Generates an escript for the project.
-
-  ## Command line options
-
-    * `--force`      - forces compilation regardless of modification times
-    * `--no-compile` - skips compilation to .beam files
-
-  ## Configuration
-
-  The following option must be specified in your `mix.exs` under `:escript`
-  key:
-
-    * `:main_module` - the module to be invoked once the escript starts.
-      The module must contain a function named `main/1` that will receive the
-      command line arguments as binaries.
-
-  The remaining options can be specified to further customize the escript:
-
-    * `:name` - the name of the generated escript.
-      Defaults to app name.
-
-    * `:path` - the path to write the escript to.
-      Defaults to app name.
-
-    * `:app` - the app to start with the escript.
-      Defaults to app name. Set it to `nil` if no application should
-      be started.
-
-    * `:embed_elixir` - if `true` embed elixir in the escript file.
-      Defaults to `true`.
-
-    * `:embed_extra_apps` - embed additional Elixir applications.
-      if `:embed_elixir` is `true`.
-      Defaults to `[]`.
-
-    * `:shebang` - shebang interpreter directive used to execute the escript.
-      Defaults to `"#! /usr/bin/env escript\n"`.
-
-    * `:comment` - comment line to follow shebang directive in the escript.
-      Defaults to `""`.
-
-    * `:emu_args` - emulator arguments to embed in the escript file.
-      Defaults to `""`.
-
-  ## Example
-
-      defmodule MyApp.Mixfile do
-        def project do
-          [ app: :myapp,
-            version: "0.0.1",
-            escript: escript ]
-        end
-
-        def escript do
-          [ main_module: MyApp.CLI,
-            embed_extra_apps: [:mix] ]
-        end
-      end
-
-  """
-  def run(args) do
-    {opts, _, _} = OptionParser.parse(args, switches: [force: :boolean, no_compile: :boolean])
-
-    # Require the project to be available
-    Mix.Project.get!
-
-    unless opts[:no_compile] do
-      Mix.Task.run :compile, args
-    end
-
-    escriptize(Mix.Project.config, opts[:force])
-  end
-
-  defp escriptize(project, force) do
-    escript_opts = project[:escript] || []
-
-    script_name  = to_string(escript_opts[:name] || project[:app])
-    filename     = escript_opts[:path] || script_name
-    main         = escript_opts[:main_module]
-    embed        = Keyword.get(escript_opts, :embed_elixir, true)
-    app          = Keyword.get(escript_opts, :app, project[:app])
-    files        = project_files()
-
-    escript_mod = String.to_atom(Atom.to_string(app) <> "-escript-main")
-
-    cond do
-      !script_name ->
-        Mix.raise "Could not generate escript, no name given, " <>
-          "set :name escript option or :app in the project settings"
-
-      !main or !Code.ensure_loaded?(main)->
-        Mix.raise "Could not generate escript, please set :main_module " <>
-          "in your project configuration (under `:escript` option) to a module that implements main/1"
-
-      force || Mix.Utils.stale?(files, [filename]) ->
-        tuples = gen_main(escript_mod, main, app) ++ to_tuples(files)
-        tuples = tuples ++ deps_tuples()
-
-        if embed do
-          extra_apps = escript_opts[:embed_extra_apps] || []
-          tuples = Enum.reduce [:elixir|extra_apps], tuples, fn(app, acc) ->
-            app_tuples(app) ++ acc
-          end
-        end
-
-        # We might get duplicate tuples in umbrella projects from applications
-        # sharing the same dependencies
-        tuples = Enum.uniq(tuples, fn {name, _} -> name end)
-
-        case :zip.create 'mem', tuples, [:memory] do
-          {:ok, {'mem', zip}} ->
-            shebang  = escript_opts[:shebang]  || "#! /usr/bin/env escript\n"
-            comment  = build_comment(escript_opts[:comment])
-            emu_args = build_emu_args(escript_opts[:emu_args], escript_mod)
-
-            script = IO.iodata_to_binary([shebang, comment, emu_args, zip])
-
-            File.mkdir_p!(Path.dirname(filename))
-            File.write!(filename, script)
-          {:error, error} ->
-            Mix.shell.error "Error creating escript: #{error}"
-        end
-
-        set_perms(filename)
-        Mix.shell.info "Generated escript #{filename}"
-        :ok
-      true ->
-        :noop
-    end
-  end
-
-  defp project_files do
-    get_files(Mix.Project.app_path)
-  end
-
-  defp deps_tuples do
-    deps = Mix.Dep.loaded(env: Mix.env) || []
-    Enum.reduce(deps, [], fn dep, acc ->
-      get_tuples(dep.opts[:build]) ++ acc
-    end)
-  end
-
-  defp set_perms(filename) do
-    stat = File.stat!(filename)
-    :ok  = :file.change_mode(filename, stat.mode ||| 73)
-  end
-
-  defp app_tuples(app) do
-    case :code.where_is_file('#{app}.app') do
-      :non_existing -> Mix.raise "Could not find application #{app}"
-      file -> get_tuples(Path.dirname(Path.dirname(file)))
-    end
-  end
-
-  defp get_files(app) do
-    Path.wildcard("#{app}/ebin/*.{app,beam}") ++
-      (Path.wildcard("#{app}/priv/**/*") |> Enum.filter(&File.regular?/1))
-  end
-
-  defp get_tuples(app) do
-    get_files(app) |> to_tuples
-  end
-
-  defp to_tuples(files) do
-    for f <- files do
-      {String.to_char_list(Path.basename(f)), File.read!(f)}
-    end
-  end
-
-  defp build_comment(user_comment) do
-    "%% #{user_comment}\n"
-  end
-
-  defp build_emu_args(user_args, escript_mod) do
-    "%%! -escript main #{escript_mod} #{user_args}\n"
-  end
-
-  defp gen_main(name, module, app) do
-    {:module, ^name, binary, _} =
-      defmodule name do
-        @module module
-        @app app
-
-        def main(args) do
-          case :application.start(:elixir) do
-            :ok ->
-              start_app(@app)
-              args = Enum.map(args, &List.to_string(&1))
-              Kernel.CLI.run fn -> @module.main(args) end, true
-            _   ->
-              io_error "Elixir is not in the code path, aborting."
-              System.halt(1)
-          end
-        end
-
-        defp start_app(nil) do
-          :ok
-        end
-
-        defp start_app(app) do
-          case :application.ensure_all_started(app) do
-            {:ok, _} -> :ok
-            {:error, {app, reason}} ->
-              io_error "Could not start application #{app}: " <>
-                Application.format_error(reason)
-              System.halt(1)
-          end
-        end
-
-        defp io_error(message) do
-           IO.puts :stderr, IO.ANSI.escape("%{red, bright} " <> message)
-        end
-      end
-
-    [{'#{name}.beam', binary}]
-  end
-end
diff --git a/lib/mix/lib/mix/tasks/eval.ex b/lib/mix/lib/mix/tasks/eval.ex
new file mode 100644
index 00000000000..6ab98b24029
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/eval.ex
@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Mix.Tasks.Eval do
+  use Mix.Task
+
+  @shortdoc "Evaluates the given code"
+
+  @moduledoc """
+  Evaluates the given code within a configured application.
+
+      $ mix eval "IO.puts(1 + 2)"
+
+  The given code is evaluated after the current application
+  has been configured but without loading or starting them
+  (some applications may be loaded as part of booting but
+  that's not guaranteed). See `mix run` for running your
+  application and scripts within a started application.
+
+  This task is designed to mirror the `bin/my_app eval` command
+  in releases. It is typically used to invoke functions already
+  defined within your application. For example, you may have a
+  module such as:
+
+      defmodule MyApp.ReleaseTasks do
+        def migrate_database do
+          Application.load(:my_app)
+          ...
+        end
+      end
+
+  Once defined, you can invoke this function either via `mix eval` or
+  via `bin/my_app eval` inside a release as follows:
+
+      $ mix eval MyApp.ReleaseTasks.migrate_database
+      $ bin/my_app eval MyApp.ReleaseTasks.migrate_database
+
+  As you can see, the current application has to be either explicitly
+  loaded or started in your tasks, either by calling `Application.load/1`
+  or `Application.ensure_all_started/1`. This gives you full control over
+  the application booting life cycle. For more information, see the
+  `Application` module.
+
+  This task is automatically re-enabled, so it can be called multiple
+  times with different arguments.
+
+  ## Command-line options
+
+    * `--no-archives-check` - does not check archives
+    * `--no-compile` - does not compile even if files require compilation
+    * `--no-deps-check` - does not check dependencies
+    * `--no-elixir-version-check` - does not check the Elixir version from mix.exs
+    * `--no-mix-exs` - allows the command to run even if there is no mix.exs
+
+  """
+
+  @impl true
+  def run(args) do
+    {_opts, head} =
+      OptionParser.parse_head!(
+        args,
+        strict: [
+          mix_exs: :boolean,
+          compile: :boolean,
+          deps_check: :boolean,
+          archives_check: :boolean,
+          elixir_version_check: :boolean
+        ]
+      )
+
+    case head do
+      [to_eval | argv] ->
+        cond do
+          Mix.Project.get() ->
+            Mix.Task.run("app.config", ["--no-app-loading" | args])
+
+          "--no-mix-exs" in args ->
+            :ok
+
+          true ->
+            Mix.raise(
+              "Cannot execute \"mix eval\" without a Mix.Project, " <>
+                "please ensure you are running Mix in a directory with a mix.exs file " <>
+                "or pass the --no-mix-exs option"
+            )
+        end
+
+        old_argv = System.argv()
+
+        try do
+          System.argv(argv)
+
+          Code.eval_string(to_eval)
+          Mix.Task.reenable("eval")
+        after
+          System.argv(old_argv)
+        end
+
+      _ ->
+        Mix.raise(
+          "\"mix eval\" expects a single string to evaluate as argument. " <>
+            "Run \"mix help eval\" for more information"
+        )
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/format.ex b/lib/mix/lib/mix/tasks/format.ex
new file mode 100644
index 00000000000..9f84edc7c71
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/format.ex
@@ -0,0 +1,1086 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Format do
+  use Mix.Task
+
+  @shortdoc "Formats the given files/patterns"
+
+  @moduledoc """
+  Formats the given files and patterns.
+
+      $ mix format mix.exs "lib/**/*.{ex,exs}" "test/**/*.{ex,exs}"
+
+  If any of the files is `-`, then the input is read from stdin and the output
+  is written to stdout.
+
+  ## Formatting options
+
+  The formatter will read a `.formatter.exs` file in the current directory for
+  formatter configuration. Evaluating this file should return a keyword list.
+
+  Here is an example of a `.formatter.exs` file that works as a starting point:
+
+      [
+        inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+      ]
+
+  Besides the options listed in `Code.format_string!/2`, the `.formatter.exs`
+  file supports the following options:
+
+    * `:inputs` (a list of paths and patterns) - specifies the default inputs
+      to be used by this task. For example, `["mix.exs", "{config,lib,test}/**/*.{ex,exs}"]`.
+      Patterns are expanded with `Path.wildcard/2`.
+
+    * `:excludes` (a list of paths and patterns) (since v1.19.0) - specifies the files to exclude from the
+      list of inputs to this task. For example, `["config/runtime.exs", "test/**/*.{ex,exs}"]`.
+      Patterns are expanded with `Path.wildcard/2`.
+
+    * `:plugins` (a list of modules) (since v1.13.0) - specifies a list of
+      modules to customize how the formatter works. See the "Plugins" section
+      below for more information.
+
+    * `:subdirectories` (a list of paths and patterns) - specifies subdirectories
+      that have their own formatting rules. Each subdirectory should have a
+      `.formatter.exs` that configures how entries in that subdirectory should be
+      formatted as. Configuration between `.formatter.exs` are not shared nor
+      inherited. If a `.formatter.exs` lists "lib/app" as a subdirectory, the rules
+      in `.formatter.exs` won't be available in `lib/app/.formatter.exs`.
+      Note that the parent `.formatter.exs` must not specify files inside the "lib/app"
+      subdirectory in its `:inputs` configuration. If this happens, the behaviour of
+      which formatter configuration will be picked is unspecified.
+
+    * `:import_deps` (a list of dependencies as atoms) - specifies a list
+       of dependencies whose formatter configuration will be imported.
+       See the "Importing dependencies configuration" section below for more
+       information.
+
+    * `:export` (a keyword list) - specifies formatter configuration to be exported.
+      See the "Importing dependencies configuration" section below.
+
+  ## Task-specific options
+
+    * `--force` - force formatting to happen on all files, instead of
+      relying on cache.
+
+    * `--check-formatted` - checks that the file is already formatted.
+      This is useful in pre-commit hooks and CI scripts if you want to
+      reject contributions with unformatted code. If the check fails,
+      the formatted contents are not written to disk. Keep in mind
+      that the formatted output may differ between Elixir versions as
+      improvements and fixes are applied to the formatter.
+
+    * `--no-exit` - only valid when used with `--check-formatted`.
+      Pass this if you don't want this Mix task to fail (and return a non-zero exit code),
+      but still want to check for format errors and print them to the console.
+
+    * `--dry-run` - does not save files after formatting.
+
+    * `--dot-formatter` - path to the file with formatter configuration.
+      Defaults to `.formatter.exs` if one is available. See the
+      "Formatting options" section above for more information.
+
+    * `--stdin-filename` - path to the file being formatted on stdin.
+      This is useful if you are using plugins to support custom filetypes such
+      as `.heex`. Without passing this flag, it is assumed that the code being
+      passed via stdin is valid Elixir code. Defaults to `stdin.exs`.
+
+    * `--migrate` - enables the `:migrate` option, which should be able to
+      automatically fix some deprecation warnings but changes the AST.
+      This should be safe in typical projects, but there is a non-zero risk
+      of breaking code for meta-programming heavy projects that relied on a
+      specific AST. We recommend running this task in its separate commit and
+      reviewing its output before committing. See the "Migration formatting"
+      section in `Code.format_string!/2` for more information.
+
+  ## When to format code
+
+  We recommend developers to format code directly in their editors, either
+  automatically when saving a file or via an explicit command or key binding. If
+  such option is not available in your editor of choice, adding the required
+  integration is usually a matter of invoking:
+
+      $ cd $project && mix format $file
+
+  where `$file` refers to the current file and `$project` is the root of your
+  project.
+
+  It is also possible to format code across the whole project by passing a list
+  of patterns and files to `mix format`, as shown at the top of this task
+  documentation. This list can also be set in the `.formatter.exs` file under the
+  `:inputs` key.
+
+  ## Plugins
+
+  It is possible to customize how the formatter behaves. Plugins must implement
+  the `Mix.Tasks.Format` behaviour. For example, imagine that your project uses
+  Markdown in two distinct ways: via a custom `~M` sigil and via files with the
+  `.md` and `.markdown` extensions. A custom plugin would look like this:
+
+      defmodule MixMarkdownFormatter do
+        @behaviour Mix.Tasks.Format
+
+        def features(_opts) do
+          [sigils: [:M], extensions: [".md", ".markdown"]]
+        end
+
+        def format(contents, opts) do
+          # logic that formats markdown
+        end
+      end
+
+  The `opts` passed to `format/2` contains all the formatting options and either:
+
+    * `:sigil` (atom) - the sigil being formatted, e.g. `:M`.
+
+    * `:modifiers` (charlist) - list of sigil modifiers.
+
+    * `:extension` (string) - the extension of the file being formatted, e.g. `".md"`.
+
+  Now any application can use your formatter as follows:
+
+      # .formatter.exs
+      [
+        # Define the desired plugins
+        plugins: [MixMarkdownFormatter, AnotherMarkdownFormatter],
+        # Remember to update the inputs list to include the new extensions
+        inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}", "posts/*.{md,markdown}"]
+      ]
+
+  Notice that, when running the formatter with plugins, your code will be
+  compiled first.
+
+  In addition, the order by which you input your plugins is the format order.
+  So, in the above `.formatter.exs`, the `MixMarkdownFormatter` will format
+  the markdown files and sigils before `AnotherMarkdownFormatter`.
+
+  ## Importing dependencies configuration
+
+  This task supports importing formatter configuration from dependencies.
+
+  A dependency that wants to export formatter configuration needs to have a
+  `.formatter.exs` file at the root of the project. In this file, the dependency
+  can list an `:export` option with configuration to export. For now, only one
+  option is supported under `:export`: `:locals_without_parens` (whose value has
+  the same shape as the value of the `:locals_without_parens` in `Code.format_string!/2`).
+
+  The functions listed under `:locals_without_parens` in the `:export` option of
+  a dependency can be imported in a project by listing that dependency in the
+  `:import_deps` option of the formatter configuration file of the project.
+
+  For example, consider you have a project called `my_app` that depends on another one called `my_dep`.
+  `my_dep` wants to export some configuration, so `my_dep/.formatter.exs`
+  would look like this:
+
+      # my_dep/.formatter.exs
+      [
+        # Regular formatter configuration for my_dep
+        # ...
+
+        export: [
+          locals_without_parens: [some_dsl_call: 2, some_dsl_call: 3]
+        ]
+      ]
+
+  In order to import configuration, `my_app`'s `.formatter.exs` would look like
+  this:
+
+      # my_app/.formatter.exs
+      [
+        import_deps: [:my_dep]
+      ]
+
+  """
+
+  @switches [
+    check_equivalent: :boolean,
+    check_formatted: :boolean,
+    no_exit: :boolean,
+    dot_formatter: :string,
+    dry_run: :boolean,
+    stdin_filename: :string,
+    force: :boolean,
+    migrate: :boolean
+  ]
+
+  @manifest_timestamp "format_timestamp"
+  @manifest_dot_formatter "cached_dot_formatter"
+  @manifest_vsn 2
+
+  @newline "\n"
+  @blank " "
+
+  @separator "|"
+  @cr "↵"
+  @line_num_pad @blank
+
+  @gutter [
+    del: " -",
+    eq: "  ",
+    ins: " +",
+    skip: "  "
+  ]
+
+  @colors [
+    del: [text: :red, space: :red_background],
+    ins: [text: :green, space: :green_background]
+  ]
+
+  @doc """
+  Returns which features this plugin should plug into.
+
+  It receives all options specified in `.formatter.exs`.
+  """
+  @callback features(keyword) :: [sigils: [atom()], extensions: [binary()]]
+
+  @doc """
+  Receives a string to be formatted with options and returns said string.
+
+  It receives all options specified in `.formatter.exs`.
+  """
+  @callback format(String.t(), keyword) :: String.t()
+
+  @impl true
+  def run(all_args) do
+    cwd = File.cwd!()
+    {opts, args} = OptionParser.parse!(all_args, strict: @switches)
+    {dot_formatter, formatter_opts} = eval_dot_formatter(cwd, opts)
+
+    if opts[:check_equivalent] do
+      IO.warn("--check-equivalent has been deprecated and has no effect")
+    end
+
+    if opts[:no_exit] && !opts[:check_formatted] do
+      Mix.raise("--no-exit can only be used together with --check-formatted")
+    end
+
+    {formatter_opts_and_subs, _sources} =
+      eval_deps_and_subdirectories(cwd, dot_formatter, formatter_opts, [dot_formatter], opts)
+
+    formatter_opts_and_subs = load_plugins(formatter_opts_and_subs, opts)
+    files = expand_args(args, cwd, dot_formatter, formatter_opts_and_subs, opts)
+
+    maybe_cache_timestamps(all_args, files, fn files ->
+      files
+      |> Task.async_stream(&format_file(&1, opts), ordered: false, timeout: :infinity)
+      |> Enum.reduce({[], []}, &collect_status/2)
+      |> check!(opts)
+    end)
+  end
+
+  defp maybe_cache_timestamps([], files, fun) do
+    if Mix.Project.get() do
+      # We fetch the time from before we read files so any future
+      # change to files are still picked up by the formatter
+      timestamp = System.os_time(:second)
+      dir = Mix.Project.manifest_path()
+      manifest_timestamp = Path.join(dir, @manifest_timestamp)
+      manifest_dot_formatter = Path.join(dir, @manifest_dot_formatter)
+      last_modified = Mix.Utils.last_modified(manifest_timestamp)
+      sources = [Mix.Project.config_mtime(), manifest_dot_formatter, ".formatter.exs"]
+
+      files =
+        if Mix.Utils.stale?(sources, [last_modified]) do
+          files
+        else
+          Enum.filter(files, fn {file, _opts} ->
+            Mix.Utils.last_modified(file) > last_modified
+          end)
+        end
+
+      try do
+        fun.(files)
+      after
+        File.mkdir_p!(dir)
+        File.touch!(manifest_timestamp, timestamp)
+      end
+    else
+      fun.(files)
+    end
+  end
+
+  defp maybe_cache_timestamps([_ | _], files, fun), do: fun.(files)
+
+  defp load_plugins({formatter_opts, subs}, opts) do
+    plugins = Keyword.get(formatter_opts, :plugins, [])
+
+    if not is_list(plugins) do
+      Mix.raise("Expected :plugins to return a list of modules, got: #{inspect(plugins)}")
+    end
+
+    plugins =
+      if plugins != [] do
+        Keyword.get(opts, :plugin_loader, &plugin_loader/1).(plugins)
+      else
+        []
+      end
+
+    for plugin <- plugins do
+      cond do
+        not Code.ensure_loaded?(plugin) ->
+          Mix.raise("Formatter plugin #{inspect(plugin)} cannot be found")
+
+        not function_exported?(plugin, :features, 1) ->
+          Mix.raise("Formatter plugin #{inspect(plugin)} does not define features/1")
+
+        true ->
+          :ok
+      end
+    end
+
+    sigils =
+      for plugin <- plugins,
+          sigil <- find_sigils_from_plugins(plugin, formatter_opts),
+          do: {sigil, plugin}
+
+    sigils =
+      sigils
+      |> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
+      |> Enum.map(fn {sigil, plugins} ->
+        {sigil,
+         fn input, opts ->
+           Enum.reduce(plugins, input, fn plugin, input ->
+             plugin.format(input, opts ++ formatter_opts)
+           end)
+         end}
+      end)
+
+    {Keyword.put(formatter_opts, :sigils, sigils),
+     Enum.map(subs, fn {path, formatter_opts_and_subs} ->
+       {path, load_plugins(formatter_opts_and_subs, opts)}
+     end)}
+  end
+
+  defp plugin_loader(plugins) do
+    if plugins != [] do
+      Mix.Task.run("loadpaths", [])
+    end
+
+    if not Enum.all?(plugins, &Code.ensure_loaded?/1) do
+      Mix.Task.run("compile", [])
+    end
+
+    plugins
+  end
+
+  @typedoc """
+  Options for `formatter_for_file/2`.
+  """
+  @type formatter_for_file_opts :: [
+          deps_paths: %{atom() => String.t()},
+          dot_formatter: String.t(),
+          plugin_loader: ([module()] -> [module()]),
+          root: String.t()
+        ]
+
+  @doc """
+  Returns a formatter function and the formatter options to
+  be used for the given file.
+
+  The function must be called with the contents of the file
+  to be formatted. Keep in mind that a function is always
+  returned, even if it doesn't match any of the inputs
+  specified in the `formatter.exs`. You can retrieve the
+  `:inputs` from the returned options, alongside the `:root`
+  option, to validate if the returned file matches the given
+  `:root` and `:inputs`.
+
+  ## Options
+
+    * `:deps_paths` (since v1.18.0) - the dependencies path to be used to resolve
+      `import_deps`. It defaults to `Mix.Project.deps_paths`.
+
+    * `:dot_formatter` - use the given file as the `dot_formatter`
+      root. If this option is not specified, it uses the default one.
+      The default one is cached, so use this option only if necessary.
+
+    * `:plugin_loader` (since v1.18.0) - a function that receives a list of plugins,
+      which may or may not yet be loaded, and ensures all of them are
+      loaded. It must return a list of plugins, which is recommended
+      to be the exact same list given as argument. You may choose to
+      skip plugins, but then it means the code will be partially
+      formatted (as in the plugins will be skipped). By default,
+      this function calls `mix loadpaths` and then, if not enough,
+      `mix compile`.
+
+    * `:root` - use the given root as the current working directory.
+  """
+  @doc since: "1.13.0"
+  @spec formatter_for_file(String.t(), formatter_for_file_opts) ::
+          {(String.t() -> String.t()), keyword()}
+  def formatter_for_file(file, opts \\ []) do
+    cwd = Keyword.get_lazy(opts, :root, &File.cwd!/0)
+    {dot_formatter, formatter_opts} = eval_dot_formatter(cwd, opts)
+
+    {formatter_opts_and_subs, _sources} =
+      eval_deps_and_subdirectories(cwd, dot_formatter, formatter_opts, [dot_formatter], opts)
+
+    formatter_opts_and_subs = load_plugins(formatter_opts_and_subs, opts)
+
+    find_formatter_and_opts_for_file(Path.expand(file, cwd), cwd, formatter_opts_and_subs)
+  end
+
+  @doc false
+  @deprecated "Use formatter_for_file/2 instead"
+  def formatter_opts_for_file(file, opts \\ []) do
+    {_, formatter_opts} = formatter_for_file(file, opts)
+    formatter_opts
+  end
+
+  defp eval_dot_formatter(cwd, opts) do
+    {dot_formatter, format_opts} =
+      cond do
+        dot_formatter = opts[:dot_formatter] ->
+          {dot_formatter, eval_file_with_keyword_list(dot_formatter)}
+
+        File.regular?(Path.join(cwd, ".formatter.exs")) ->
+          dot_formatter = Path.join(cwd, ".formatter.exs")
+          {".formatter.exs", eval_file_with_keyword_list(dot_formatter)}
+
+        true ->
+          {".formatter.exs", []}
+      end
+
+    # the --migrate flag overrides settings from the dot formatter
+    {dot_formatter, Keyword.take(opts, [:migrate]) ++ format_opts}
+  end
+
+  # This function reads exported configuration from the imported
+  # dependencies and subdirectories and deals with caching the result
+  # of reading such configuration in a manifest file.
+  defp eval_deps_and_subdirectories(cwd, dot_formatter, formatter_opts, sources, opts) do
+    deps = Keyword.get(formatter_opts, :import_deps, [])
+    subs = Keyword.get(formatter_opts, :subdirectories, [])
+
+    if not is_list(deps) do
+      Mix.raise("Expected :import_deps to return a list of dependencies, got: #{inspect(deps)}")
+    end
+
+    if not is_list(subs) do
+      Mix.raise("Expected :subdirectories to return a list of directories, got: #{inspect(subs)}")
+    end
+
+    if deps == [] and subs == [] do
+      {{formatter_opts, []}, sources}
+    else
+      manifest = Path.join(Mix.Project.manifest_path(), @manifest_dot_formatter)
+
+      {{locals_without_parens, subdirectories}, sources} =
+        maybe_cache_in_manifest(dot_formatter, manifest, fn ->
+          {subdirectories, sources} = eval_subs_opts(subs, cwd, sources, opts)
+          {{eval_deps_opts(deps, opts), subdirectories}, sources}
+        end)
+
+      formatter_opts =
+        Keyword.update(
+          formatter_opts,
+          :locals_without_parens,
+          locals_without_parens,
+          &(locals_without_parens ++ &1)
+        )
+
+      {{formatter_opts, subdirectories}, sources}
+    end
+  end
+
+  defp maybe_cache_in_manifest(dot_formatter, manifest, fun) do
+    cond do
+      is_nil(Mix.Project.get()) or dot_formatter != ".formatter.exs" -> fun.()
+      entry = read_manifest(manifest) -> entry
+      true -> write_manifest!(manifest, fun.())
+    end
+  end
+
+  defp read_manifest(manifest) do
+    with {:ok, binary} <- File.read(manifest),
+         {:ok, {@manifest_vsn, entry, sources}} <- safe_binary_to_term(binary),
+         expanded_sources = Enum.flat_map(sources, &Path.wildcard(&1, match_dot: true)),
+         false <- Mix.Utils.stale?([Mix.Project.config_mtime() | expanded_sources], [manifest]) do
+      {entry, sources}
+    else
+      _ -> nil
+    end
+  end
+
+  defp safe_binary_to_term(binary) do
+    {:ok, :erlang.binary_to_term(binary)}
+  rescue
+    _ -> :error
+  end
+
+  defp write_manifest!(manifest, {entry, sources}) do
+    File.mkdir_p!(Path.dirname(manifest))
+    File.write!(manifest, :erlang.term_to_binary({@manifest_vsn, entry, sources}))
+    {entry, sources}
+  end
+
+  defp eval_deps_opts([], _opts) do
+    []
+  end
+
+  defp eval_deps_opts(deps, opts) do
+    deps_paths = opts[:deps_paths] || Mix.Project.deps_paths()
+
+    if not is_map(deps_paths) do
+      Mix.raise(
+        "Expected :deps_paths to return a map of dependency paths, got: #{inspect(deps_paths)}"
+      )
+    end
+
+    for dep <- deps,
+        dep_path = assert_valid_dep_and_fetch_path(dep, deps_paths),
+        dep_dot_formatter = Path.join(dep_path, ".formatter.exs"),
+        File.regular?(dep_dot_formatter),
+        dep_opts = eval_file_with_keyword_list(dep_dot_formatter),
+        parenless_call <- dep_opts[:export][:locals_without_parens] || [],
+        uniq: true,
+        do: parenless_call
+  end
+
+  defp eval_subs_opts(subs, cwd, sources, opts) do
+    {subs, sources} =
+      Enum.flat_map_reduce(subs, sources, fn sub, sources ->
+        cwd = Path.expand(sub, cwd)
+        {Path.wildcard(cwd), [Path.join(cwd, ".formatter.exs") | sources]}
+      end)
+
+    Enum.flat_map_reduce(subs, sources, fn sub, sources ->
+      sub_formatter = Path.join(sub, ".formatter.exs")
+
+      if File.exists?(sub_formatter) do
+        formatter_opts = eval_file_with_keyword_list(sub_formatter)
+
+        {formatter_opts_and_subs, sources} =
+          eval_deps_and_subdirectories(sub, :in_memory, formatter_opts, sources, opts)
+
+        {[{sub, formatter_opts_and_subs}], sources}
+      else
+        {[], sources}
+      end
+    end)
+  end
+
+  defp assert_valid_dep_and_fetch_path(dep, deps_paths) when is_atom(dep) do
+    with %{^dep => path} <- deps_paths,
+         true <- File.dir?(path) do
+      path
+    else
+      _ ->
+        Mix.raise(
+          "Unknown dependency #{inspect(dep)} given to :import_deps in the formatter configuration. " <>
+            "Make sure the dependency is listed in your mix.exs for environment #{inspect(Mix.env())} " <>
+            "and you have run \"mix deps.get\""
+        )
+    end
+  end
+
+  defp assert_valid_dep_and_fetch_path(dep, _deps_paths) do
+    Mix.raise("Dependencies in :import_deps should be atoms, got: #{inspect(dep)}")
+  end
+
+  defp eval_file_with_keyword_list(path) do
+    {opts, _} = Code.eval_file(path)
+
+    if not Keyword.keyword?(opts) do
+      Mix.raise("Expected #{inspect(path)} to return a keyword list, got: #{inspect(opts)}")
+    end
+
+    opts
+  end
+
+  defp expand_args([], cwd, dot_formatter, formatter_opts_and_subs, _opts) do
+    if no_entries_in_formatter_opts?(formatter_opts_and_subs) do
+      Mix.raise(
+        "Expected one or more files/patterns to be given to mix format " <>
+          "or for a .formatter.exs file to exist with an :inputs or :subdirectories key"
+      )
+    end
+
+    dot_formatter
+    |> expand_dot_inputs(cwd, formatter_opts_and_subs, %{})
+    |> Enum.map(fn {file, {_dot_formatter, formatter_opts}} ->
+      {file, find_formatter_for_file(file, formatter_opts)}
+    end)
+  end
+
+  defp expand_args(files_and_patterns, cwd, _dot_formatter, {formatter_opts, subs}, opts) do
+    files =
+      for file_or_pattern <- files_and_patterns,
+          file <- stdin_or_wildcard(file_or_pattern),
+          uniq: true,
+          do: file
+
+    if files == [] do
+      Mix.raise(
+        "Could not find a file to format. The files/patterns given to command line " <>
+          "did not point to any existing file. Got: #{inspect(files_and_patterns)}"
+      )
+    end
+
+    for file <- files do
+      if file == :stdin do
+        stdin_filename = Path.expand(Keyword.get(opts, :stdin_filename, "stdin.exs"), cwd)
+
+        {formatter, _opts} =
+          find_formatter_and_opts_for_file(stdin_filename, cwd, {formatter_opts, subs})
+
+        {file, formatter}
+      else
+        {formatter, _opts} = find_formatter_and_opts_for_file(file, cwd, {formatter_opts, subs})
+        {file, formatter}
+      end
+    end
+  end
+
+  defp expand_dot_inputs(dot_formatter, cwd, {formatter_opts, subs}, acc) do
+    if no_entries_in_formatter_opts?({formatter_opts, subs}) do
+      Mix.raise("Expected :inputs or :subdirectories key in #{dot_formatter}")
+    end
+
+    excluded_files =
+      formatter_opts[:excludes]
+      |> List.wrap()
+      |> Enum.flat_map(&Path.wildcard(Path.expand(&1, cwd), match_dot: true))
+      |> MapSet.new()
+
+    map =
+      for input <- List.wrap(formatter_opts[:inputs]),
+          file <- Path.wildcard(Path.expand(input, cwd), match_dot: true),
+          file not in excluded_files,
+          do: {file, {dot_formatter, formatter_opts}},
+          into: %{}
+
+    acc =
+      Map.merge(acc, map, fn file, {dot_formatter1, _}, {dot_formatter2, formatter_opts} ->
+        Mix.shell().error(
+          "Both #{dot_formatter1} and #{dot_formatter2} specify the file #{file} in their " <>
+            ":inputs option. To resolve the conflict, the configuration in #{dot_formatter1} " <>
+            "will be ignored. Please change the list of :inputs in one of the formatter files " <>
+            "so only one of them matches #{file}"
+        )
+
+        {dot_formatter2, formatter_opts}
+      end)
+
+    Enum.reduce(subs, acc, fn {sub, formatter_opts_and_subs}, acc ->
+      sub_formatter = Path.join(sub, ".formatter.exs")
+      expand_dot_inputs(sub_formatter, sub, formatter_opts_and_subs, acc)
+    end)
+  end
+
+  defp find_formatter_for_file(file, formatter_opts) do
+    ext = Path.extname(file)
+
+    cond do
+      plugins = find_plugins_for_extension(formatter_opts, ext) ->
+        fn input ->
+          Enum.reduce(plugins, input, fn plugin, input ->
+            plugin.format(input, [extension: ext, file: file] ++ formatter_opts)
+          end)
+        end
+
+      ext in ~w(.ex .exs) ->
+        &elixir_format(&1, [file: file] ++ formatter_opts)
+
+      true ->
+        & &1
+    end
+  end
+
+  defp find_plugins_for_extension(formatter_opts, ext) do
+    plugins = Keyword.get(formatter_opts, :plugins, [])
+
+    plugins =
+      Enum.filter(plugins, fn plugin ->
+        Code.ensure_loaded?(plugin) and function_exported?(plugin, :features, 1) and
+          ext in List.wrap(plugin.features(formatter_opts)[:extensions])
+      end)
+
+    if plugins != [], do: plugins, else: nil
+  end
+
+  defp find_formatter_and_opts_for_file(file, root, formatter_opts_and_subs) do
+    {formatter_opts, root} = recur_formatter_opts_for_file(file, root, formatter_opts_and_subs)
+    {find_formatter_for_file(file, formatter_opts), [root: root] ++ formatter_opts}
+  end
+
+  defp recur_formatter_opts_for_file(file, root, {formatter_opts, subs}) do
+    Enum.find_value(subs, {formatter_opts, root}, fn {sub, formatter_opts_and_subs} ->
+      size = byte_size(sub)
+
+      case file do
+        <<prefix::binary-size(^size), dir_separator, _::binary>>
+        when prefix == sub and dir_separator in [?\\, ?/] ->
+          recur_formatter_opts_for_file(file, sub, formatter_opts_and_subs)
+
+        _ ->
+          nil
+      end
+    end)
+  end
+
+  defp no_entries_in_formatter_opts?({formatter_opts, subs}) do
+    is_nil(formatter_opts[:inputs]) and subs == []
+  end
+
+  defp stdin_or_wildcard("-"), do: [:stdin]
+
+  defp stdin_or_wildcard(path),
+    do: path |> Path.expand() |> Path.wildcard(match_dot: true) |> Enum.filter(&File.regular?/1)
+
+  defp elixir_format(content, formatter_opts) do
+    content
+    |> Code.format_string!(formatter_opts)
+    |> IO.iodata_to_binary()
+    |> case do
+      "" -> ""
+      formatted_content -> IO.iodata_to_binary([formatted_content, ?\n])
+    end
+  end
+
+  defp find_sigils_from_plugins(plugin, formatter_opts) do
+    if Code.ensure_loaded?(plugin) and function_exported?(plugin, :features, 1) do
+      List.wrap(plugin.features(formatter_opts)[:sigils])
+    else
+      []
+    end
+  end
+
+  defp read_file(:stdin), do: IO.stream() |> Enum.to_list() |> IO.iodata_to_binary()
+  defp read_file(file), do: File.read!(file)
+
+  defp format_file({file, formatter}, task_opts) do
+    input = read_file(file)
+    output = formatter.(input)
+    check_formatted? = Keyword.get(task_opts, :check_formatted, false)
+    dry_run? = Keyword.get(task_opts, :dry_run, false)
+
+    cond do
+      check_formatted? ->
+        if input == output, do: :ok, else: {:not_formatted, {file, input, output}}
+
+      dry_run? ->
+        :ok
+
+      true ->
+        write_or_print(file, input, output)
+    end
+  rescue
+    exception ->
+      {:exit, file, exception, __STACKTRACE__}
+  end
+
+  defp write_or_print(file, input, output) do
+    cond do
+      file == :stdin -> IO.write(output)
+      input == output -> :ok
+      true -> File.write!(file, output)
+    end
+
+    :ok
+  end
+
+  defp collect_status({:ok, :ok}, acc), do: acc
+
+  defp collect_status({:ok, {:exit, _, _, _} = exit}, {exits, not_formatted}) do
+    {[exit | exits], not_formatted}
+  end
+
+  defp collect_status({:ok, {:not_formatted, file}}, {exits, not_formatted}) do
+    {exits, [file | not_formatted]}
+  end
+
+  defp check!({[], []}, _task_opts) do
+    :ok
+  end
+
+  defp check!({[{:exit, :stdin, exception, stacktrace} | _], _not_formatted}, _task_opts) do
+    Mix.shell().error("mix format failed for stdin")
+    reraise exception, stacktrace
+  end
+
+  defp check!({[{:exit, file, exception, stacktrace} | _], _not_formatted}, _task_opts) do
+    Mix.shell().error("mix format failed for file: #{Path.relative_to_cwd(file)}")
+    reraise exception, stacktrace
+  end
+
+  defp check!({_exits, [_ | _] = not_formatted}, task_opts) do
+    no_exit? = Keyword.get(task_opts, :no_exit, false)
+
+    message = """
+    The following files are not formatted:
+
+    #{to_diffs(not_formatted)}
+    """
+
+    if no_exit? do
+      Mix.shell().info(message)
+    else
+      Mix.raise("""
+      mix format failed due to --check-formatted.
+      #{message}
+      """)
+    end
+  end
+
+  defp to_diffs(files) do
+    Enum.map_intersperse(files, "\n", fn
+      {:stdin, unformatted, formatted} ->
+        [IO.ANSI.reset(), text_diff_format(unformatted, formatted)]
+
+      {file, unformatted, formatted} ->
+        [
+          IO.ANSI.bright(),
+          IO.ANSI.red(),
+          file,
+          "\n",
+          IO.ANSI.reset(),
+          "\n",
+          text_diff_format(unformatted, formatted)
+        ]
+    end)
+  end
+
+  @doc false
+  def text_diff_format(old, new, opts \\ [])
+
+  def text_diff_format(code, code, _opts), do: []
+
+  def text_diff_format(old, new, opts) do
+    opts = Keyword.validate!(opts, after: 2, before: 2, color: IO.ANSI.enabled?(), line: 1)
+    crs? = String.contains?(old, "\r") || String.contains?(new, "\r")
+
+    old = String.split(old, "\n")
+    new = String.split(new, "\n")
+
+    max = max(length(new), length(old))
+    line_num_digits = max |> Integer.digits() |> length()
+    opts = Keyword.put(opts, :line_num_digits, line_num_digits)
+
+    {line, opts} = Keyword.pop!(opts, :line)
+
+    old
+    |> List.myers_difference(new)
+    |> insert_cr_symbols(crs?)
+    |> diff_to_iodata({line, line}, opts)
+  end
+
+  defp diff_to_iodata(diff, line_nums, opts, iodata \\ [])
+
+  defp diff_to_iodata([], _line_nums, _opts, iodata), do: Enum.reverse(iodata)
+
+  defp diff_to_iodata([{:eq, [""]}], _line_nums, _opts, iodata), do: Enum.reverse(iodata)
+
+  defp diff_to_iodata([{:eq, lines}], line_nums, opts, iodata) do
+    lines_after = Enum.take(lines, opts[:after])
+    iodata = lines(iodata, {:eq, lines_after}, line_nums, opts)
+
+    iodata =
+      case length(lines) > opts[:after] do
+        false -> iodata
+        true -> lines(iodata, :skip, opts)
+      end
+
+    Enum.reverse(iodata)
+  end
+
+  defp diff_to_iodata([{:eq, lines} | diff], {line, line}, opts, [] = iodata) do
+    {start, lines_before} = Enum.split(lines, opts[:before] * -1)
+
+    iodata =
+      case length(lines) > opts[:before] do
+        false -> iodata
+        true -> lines(iodata, :skip, opts)
+      end
+
+    line = line + length(start)
+    iodata = lines(iodata, {:eq, lines_before}, {line, line}, opts)
+
+    line = line + length(lines_before)
+    diff_to_iodata(diff, {line, line}, opts, iodata)
+  end
+
+  defp diff_to_iodata([{:eq, lines} | diff], line_nums, opts, iodata) do
+    case length(lines) > opts[:after] + opts[:before] do
+      true ->
+        {lines1, lines2, lines3} = split(lines, opts[:after], opts[:before] * -1)
+
+        iodata =
+          iodata
+          |> lines({:eq, lines1}, line_nums, opts)
+          |> lines(:skip, opts)
+          |> lines({:eq, lines3}, add_line_nums(line_nums, length(lines1) + length(lines2)), opts)
+
+        line_nums = add_line_nums(line_nums, length(lines))
+
+        diff_to_iodata(diff, line_nums, opts, iodata)
+
+      false ->
+        iodata = lines(iodata, {:eq, lines}, line_nums, opts)
+        line_nums = add_line_nums(line_nums, length(lines))
+
+        diff_to_iodata(diff, line_nums, opts, iodata)
+    end
+  end
+
+  defp diff_to_iodata([{:del, [del]}, {:ins, [ins]} | diff], line_nums, opts, iodata) do
+    iodata = lines(iodata, {:chg, del, ins}, line_nums, opts)
+    diff_to_iodata(diff, add_line_nums(line_nums, 1), opts, iodata)
+  end
+
+  defp diff_to_iodata([{kind, lines} | diff], line_nums, opts, iodata) do
+    iodata = lines(iodata, {kind, lines}, line_nums, opts)
+    line_nums = add_line_nums(line_nums, length(lines), kind)
+
+    diff_to_iodata(diff, line_nums, opts, iodata)
+  end
+
+  defp split(list, count1, count2) do
+    {split1, split2} = Enum.split(list, count1)
+    {split2, split3} = Enum.split(split2, count2)
+    {split1, split2, split3}
+  end
+
+  defp lines(iodata, :skip, opts) do
+    line_num = String.duplicate(@blank, opts[:line_num_digits] * 2 + 1)
+    [[line_num, @gutter[:skip], @separator, @newline] | iodata]
+  end
+
+  defp lines(iodata, {:chg, del, ins}, line_nums, opts) do
+    {del, ins} = line_diff(del, ins, opts)
+
+    [
+      [gutter(line_nums, :ins, opts), ins, @newline],
+      [gutter(line_nums, :del, opts), del, @newline]
+      | iodata
+    ]
+  end
+
+  defp lines(iodata, {kind, lines}, line_nums, opts) do
+    lines
+    |> Enum.with_index()
+    |> Enum.reduce(iodata, fn {line, offset}, iodata ->
+      line_nums = add_line_nums(line_nums, offset, kind)
+      [[gutter(line_nums, kind, opts), colorize(line, kind, false, opts), @newline] | iodata]
+    end)
+  end
+
+  defp gutter(line_nums, kind, opts) do
+    [line_num(line_nums, kind, opts), colorize(@gutter[kind], kind, false, opts), @separator]
+  end
+
+  defp line_num({line_num_old, line_num_new}, :eq, opts) do
+    old =
+      line_num_old
+      |> to_string()
+      |> String.pad_leading(opts[:line_num_digits], @line_num_pad)
+
+    new =
+      line_num_new
+      |> to_string()
+      |> String.pad_leading(opts[:line_num_digits], @line_num_pad)
+
+    [old, @blank, new]
+  end
+
+  defp line_num({line_num_old, _line_num_new}, :del, opts) do
+    old =
+      line_num_old
+      |> to_string()
+      |> String.pad_leading(opts[:line_num_digits], @line_num_pad)
+
+    new = String.duplicate(@blank, opts[:line_num_digits])
+    [old, @blank, new]
+  end
+
+  defp line_num({_line_num_old, line_num_new}, :ins, opts) do
+    old = String.duplicate(@blank, opts[:line_num_digits])
+
+    new =
+      line_num_new
+      |> to_string()
+      |> String.pad_leading(opts[:line_num_digits], @line_num_pad)
+
+    [old, @blank, new]
+  end
+
+  defp line_diff(del, ins, opts) do
+    diff = String.myers_difference(del, ins)
+
+    Enum.reduce(diff, {[], []}, fn
+      {:eq, str}, {del, ins} -> {[del | str], [ins | str]}
+      {:del, str}, {del, ins} -> {[del | colorize(str, :del, true, opts)], ins}
+      {:ins, str}, {del, ins} -> {del, [ins | colorize(str, :ins, true, opts)]}
+    end)
+  end
+
+  defp colorize(str, kind, space?, opts) do
+    if Keyword.fetch!(opts, :color) && Keyword.has_key?(@colors, kind) do
+      color = Keyword.fetch!(@colors, kind)
+
+      if space? do
+        str
+        |> String.split(~r/[\t\s]+/, include_captures: true)
+        |> Enum.map(fn
+          <<start::binary-size(1), _::binary>> = str when start in ["\t", "\s"] ->
+            IO.ANSI.format([color[:space], str])
+
+          str ->
+            IO.ANSI.format([color[:text], str])
+        end)
+      else
+        IO.ANSI.format([color[:text], str])
+      end
+    else
+      str
+    end
+  end
+
+  defp add_line_nums({line_num_old, line_num_new}, lines, kind \\ :eq) do
+    case kind do
+      :eq -> {line_num_old + lines, line_num_new + lines}
+      :ins -> {line_num_old, line_num_new + lines}
+      :del -> {line_num_old + lines, line_num_new}
+    end
+  end
+
+  defp insert_cr_symbols(diffs, false), do: diffs
+  defp insert_cr_symbols(diffs, true), do: do_insert_cr_symbols(diffs, [])
+
+  defp do_insert_cr_symbols([], acc), do: Enum.reverse(acc)
+
+  defp do_insert_cr_symbols([{:del, del}, {:ins, ins} | rest], acc) do
+    {del, ins} = do_insert_cr_symbols(del, ins, {[], []})
+    do_insert_cr_symbols(rest, [{:ins, ins}, {:del, del} | acc])
+  end
+
+  defp do_insert_cr_symbols([diff | rest], acc) do
+    do_insert_cr_symbols(rest, [diff | acc])
+  end
+
+  defp do_insert_cr_symbols([left | left_rest], [right | right_rest], {left_acc, right_acc}) do
+    {left, right} = insert_cr_symbol(left, right)
+    do_insert_cr_symbols(left_rest, right_rest, {[left | left_acc], [right | right_acc]})
+  end
+
+  defp do_insert_cr_symbols([], right, {left_acc, right_acc}) do
+    left = Enum.reverse(left_acc)
+    right = right_acc |> Enum.reverse() |> Enum.concat(right)
+    {left, right}
+  end
+
+  defp do_insert_cr_symbols(left, [], {left_acc, right_acc}) do
+    left = left_acc |> Enum.reverse() |> Enum.concat(left)
+    right = Enum.reverse(right_acc)
+    {left, right}
+  end
+
+  defp insert_cr_symbol(left, right) do
+    case {String.ends_with?(left, "\r"), String.ends_with?(right, "\r")} do
+      {bool, bool} -> {left, right}
+      {true, false} -> {String.replace(left, "\r", @cr), right}
+      {false, true} -> {left, String.replace(right, "\r", @cr)}
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/help.ex b/lib/mix/lib/mix/tasks/help.ex
index fcc10d088bb..18e15b2df3f 100644
--- a/lib/mix/lib/mix/tasks/help.ex
+++ b/lib/mix/lib/mix/tasks/help.ex
@@ -1,131 +1,363 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Help do
   use Mix.Task
 
-  @shortdoc "Print help information for tasks"
+  @shortdoc "Prints help information for tasks, aliases, modules, and applications"
 
   @moduledoc """
-  Lists all tasks or prints the documentation for a given task.
+  Prints documentation for tasks, aliases, modules, and applications.
+
+  ## Examples
+
+  Without an explicit argument, this task lists tasks/aliases:
+
+      $ mix help                  - prints all aliases, tasks and their short descriptions
+      $ mix help --search PATTERN - prints all tasks and aliases that contain PATTERN in the name
+      $ mix help --names          - prints all task names and aliases (useful for autocompletion)
+      $ mix help --aliases        - prints all aliases
+
+  You can access documentation for a given task/alias:
+
+      $ mix help TASK/ALIAS       - prints full docs for the given task/alias
 
-  ## Arguments
+  But also for modules, functions, and applications:
 
-      mix help         - prints all tasks and their shortdoc
-      mix help --names - prints all task names
-      mix help TASK    - prints full docs for the given task
+      $ mix help MODULE           - prints the definition for the given module
+      $ mix help MODULE.FUN       - prints the definition for the given module+function
+      $ mix help app:APP          - prints a summary of all public modules in application
 
   ## Colors
 
   When possible, `mix help` is going to use coloring for formatting
-  guides. The formatting can be customized by configuring the Mix
-  application either inside your project (in `config/config.exs`) or
-  by using the local config (in `~/.mix/config.exs`).
+  the help information. The formatting can be customized by configuring
+  the Mix application either inside your project (in `config/config.exs`)
+  or by using the local config (in `~/.mix/config.exs`).
 
-  For example, to disable, one may:
+  For example, to disable color, one may use the configuration:
 
       [mix: [colors: [enabled: false]]]
 
   The available color options are:
 
-    * `:enabled`         - show ANSI formatting (defaults to IO.ANSI.terminal?)
-    * `:doc_code`        — the attributes for code blocks (cyan, bright)
+    * `:enabled`         - shows ANSI formatting (defaults to `IO.ANSI.enabled?/0`)
+    * `:doc_code`        - the attributes for code blocks (cyan, bright)
     * `:doc_inline_code` - inline code (cyan)
     * `:doc_headings`    - h1 and h2 (yellow, bright)
-    * `:doc_title`       — the overall heading for the output (reverse,yellow,bright)
+    * `:doc_title`       - the overall heading for the output (reverse, yellow, bright)
     * `:doc_bold`        - (bright)
     * `:doc_underline`   - (underline)
 
   """
 
+  @impl true
+  def run(argv)
+
   def run([]) do
-    Mix.Task.load_all
+    loadpaths!()
 
-    shell   = Mix.shell
-    modules = Mix.Task.all_modules
+    modules = load_tasks()
+    aliases = load_aliases()
 
-    docs = for module <- modules,
-        doc = Mix.Task.shortdoc(module) do
-      {"mix " <> Mix.Task.task_name(module), doc}
-    end
+    {docs, max} = build_doc_list(modules, aliases)
+
+    display_default_task_doc(max)
+    display_doc_list(docs, max)
+    display_iex_task_doc(max)
+    Mix.shell().info("\nUse \"mix help <TASK>\" for more information on a particular command.")
+  end
 
-    max = Enum.reduce docs, 0, fn({task, _}, acc) ->
-      max(byte_size(task), acc)
+  def run(["--names"]) do
+    loadpaths!()
+
+    tasks = Enum.map(load_tasks(), &Mix.Task.task_name/1)
+
+    aliases =
+      Enum.map(Mix.Project.config()[:aliases], fn {alias_name, _} ->
+        Atom.to_string(alias_name)
+      end)
+
+    for info <- Enum.sort(aliases ++ tasks) do
+      Mix.shell().info(info)
     end
+  end
 
-    display_default_task_doc(max)
+  def run(["--aliases"]) do
+    loadpaths!()
+
+    aliases = load_aliases()
+
+    {docs, max} = build_doc_list([], aliases)
+
+    display_doc_list(docs, max)
+  end
+
+  def run(["--search", pattern]) do
+    loadpaths!()
 
-    Enum.each Enum.sort(docs), fn({task, doc}) ->
-      shell.info format_task(task, max, doc)
+    modules = Enum.filter(load_tasks(), &String.contains?(Mix.Task.task_name(&1), pattern))
+    aliases = Enum.filter(load_aliases(), fn {name, _} -> String.contains?(name, pattern) end)
+
+    {docs, max} = build_doc_list(modules, aliases)
+    display_doc_list(docs, max)
+  end
+
+  def run(["--search"]) do
+    Mix.raise("Unexpected arguments, expected \"mix help --search PATTERN\"")
+  end
+
+  @compile {:no_warn_undefined, IEx.Introspection}
+
+  def run(["app:" <> app]) do
+    loadpaths!()
+
+    app = String.to_atom(app)
+
+    # If the application is not available, attempt to load it from Erlang/Elixir
+    if is_nil(Application.spec(app, :vsn)) do
+      try do
+        Mix.ensure_application!(app)
+      rescue
+        _ ->
+          # Otherwise, it may be a dep or the current project not yet compiled
+          if Mix.Project.get() do
+            Mix.Task.run("compile")
+          end
+      end
     end
 
-    display_iex_task_doc(max)
+    if modules = Application.spec(app, :modules) do
+      for module <- modules,
+          not (module |> Atom.to_string() |> String.starts_with?("Elixir.Mix.Tasks.")),
+          {:docs_v1, _, _, "text/markdown", %{"en" => <<doc::binary>>}, _, _} <-
+            [Code.fetch_docs(module)] do
+        leading = doc |> String.split(["\n\n", "\r\n\r\n"], parts: 2) |> hd()
+        "# #{inspect(module)}\n#{leading}\n"
+      end
+      |> case do
+        [] ->
+          Mix.shell().error("No modules with accessible documentation found for #{app}")
+
+        listing ->
+          docs = listing |> Enum.sort() |> Enum.join()
+          IO.ANSI.Docs.print(docs, "text/markdown", ansi_opts())
+      end
+    else
+      Mix.shell().error("Application #{app} does not exist or is not loaded")
+    end
   end
 
-  def run(["--names"]) do
-    Mix.Task.load_all
-    for module <- Enum.sort(Mix.Task.all_modules),
-                task = Mix.Task.task_name(module) do
-      Mix.shell.info "#{task}"
+  def run([module = <<first, _::binary>>]) when first in ?A..?Z or first == ?: do
+    loadpaths!()
+
+    iex_colors = Application.get_env(:iex, :colors, [])
+    mix_colors = Application.get_env(:mix, :colors, [])
+
+    try do
+      Application.put_env(:iex, :colors, mix_colors)
+
+      module
+      |> Code.string_to_quoted!()
+      |> IEx.Introspection.decompose(__ENV__)
+      |> case do
+        :error -> Mix.raise("Invalid expression: #{module}")
+        decomposition -> decomposition
+      end
+      |> IEx.Introspection.h()
+    after
+      Application.put_env(:iex, :colors, iex_colors)
     end
   end
 
   def run([task]) do
-    module = Mix.Task.get!(task)
-    doc    = Mix.Task.moduledoc(module) || "There is no documentation for this task"
-    opts   = Application.get_env(:mix, :colors)
+    loadpaths!()
+    opts = ansi_opts()
 
-    if ansi_docs?(opts) do
-      opts = [width: width] ++ opts
-      IO.ANSI.Docs.print_heading("mix #{task}", opts)
-      IO.ANSI.Docs.print(doc, opts)
-    else
-      IO.puts "# mix #{task}\n"
-      IO.puts doc
+    for doc <- verbose_doc(task) do
+      print_doc(task, doc, opts)
     end
 
-    IO.puts "Location: #{where_is_file(module)}"
+    :ok
   end
 
   def run(_) do
-    Mix.raise "Unexpected arguments, expected `mix help` or `mix help TASK`"
+    Mix.raise("Unexpected arguments, expected \"mix help\" or \"mix help TASK\"")
+  end
+
+  defp ansi_opts do
+    opts = Application.get_env(:mix, :colors)
+    [width: width(), enabled: ansi_docs?(opts)] ++ opts
+  end
+
+  defp print_doc(task, {doc, location, note}, opts) do
+    IO.ANSI.Docs.print_headings(["mix #{task}"], opts)
+    IO.ANSI.Docs.print(doc, "text/markdown", opts)
+    IO.puts("Location: #{location}")
+    note && IO.puts("") && IO.ANSI.Docs.print(note, "text/markdown", opts)
+  end
+
+  # Loadpaths without checks because tasks may be defined in deps.
+  defp loadpaths! do
+    args = [
+      "--no-elixir-version-check",
+      "--no-deps-check",
+      "--no-archives-check",
+      "--no-listeners"
+    ]
+
+    Mix.Task.run("loadpaths", args)
+    Mix.Task.reenable("loadpaths")
+    Mix.Task.reenable("deps.loadpaths")
+  end
+
+  defp load_tasks() do
+    Enum.filter(Mix.Task.load_all(), &(Mix.Task.moduledoc(&1) != false))
+  end
+
+  defp load_aliases() do
+    aliases = Mix.Project.config()[:aliases]
+
+    Map.new(aliases, fn {alias_name, alias_tasks} -> {Atom.to_string(alias_name), alias_tasks} end)
   end
 
   defp ansi_docs?(opts) do
-    if Keyword.has_key?(opts, :enabled) do
-      opts[:enabled]
-    else
-      IO.ANSI.terminal?
-    end
+    Keyword.get(opts, :enabled, IO.ANSI.enabled?())
   end
 
   defp width() do
     case :io.columns() do
       {:ok, width} -> min(width, 80)
-      {:error, _}  -> 80
+      {:error, _} -> 80
     end
   end
 
   defp format_task(task, max, doc) do
-    String.ljust(task, max) <> " # " <> doc
+    String.pad_trailing(task, max) <> " # " <> doc
   end
 
   defp where_is_file(module) do
-    case :code.where_is_file(Atom.to_char_list(module) ++ '.beam') do
+    case :code.where_is_file(Atom.to_charlist(module) ++ ~c".beam") do
       :non_existing ->
         "not available"
+
       location ->
         location
-        |> Path.dirname
-        |> Path.expand
-        |> Path.relative_to_cwd
+        |> Path.dirname()
+        |> Path.expand()
+        |> Path.relative_to_cwd()
     end
   end
 
   defp display_default_task_doc(max) do
-    Mix.shell.info format_task("mix", max,
-                    "Run the default task (current: mix #{Mix.Project.config[:default_task]})")
+    project = Mix.Project.get()
+
+    default =
+      if function_exported?(project, :cli, 0) do
+        project.cli()[:default_task] || "run"
+      else
+        "run"
+      end
+
+    message = "Runs the default task (current: \"mix #{default}\")"
+    Mix.shell().info(format_task("mix", max, message))
   end
 
   defp display_iex_task_doc(max) do
-    Mix.shell.info format_task("iex -S mix", max,
-                    "Start IEx and run the default task")
+    Mix.shell().info(format_task("iex -S mix", max, "Starts IEx and runs the default task"))
+  end
+
+  defp display_doc_list(docs, max) do
+    Enum.each(Enum.sort(docs), fn {task, doc} ->
+      Mix.shell().info(format_task(task, max, doc))
+    end)
+  end
+
+  defp build_doc_list(modules, aliases) do
+    {task_docs, task_max} = build_task_doc_list(modules)
+    {alias_docs, alias_max} = build_alias_doc_list(aliases)
+    {task_docs ++ alias_docs, max(task_max, alias_max)}
+  end
+
+  defp build_task_doc_list(modules) do
+    Enum.reduce(modules, {[], 0}, fn module, {docs, max} ->
+      if doc = Mix.Task.shortdoc(module) do
+        task = "mix " <> Mix.Task.task_name(module)
+        {[{task, doc} | docs], max(byte_size(task), max)}
+      else
+        {docs, max}
+      end
+    end)
+  end
+
+  defp build_alias_doc_list(aliases) do
+    Enum.reduce(aliases, {[], 0}, fn {alias_name, task}, {docs, max} ->
+      doc = alias_doc(task)
+      task = "mix " <> alias_name
+      {[{task, doc} | docs], max(byte_size(task), max)}
+    end)
+  end
+
+  defp alias_doc(task) do
+    "Alias for " <> format_alias_doc(task)
+  end
+
+  defp format_alias_doc(task), do: Enum.map_join(List.wrap(task), ", ", &format_alias_task/1)
+
+  defp format_alias_task(task) when is_binary(task), do: task
+
+  defp format_alias_task(task) when is_function(task) do
+    info = Function.info(task)
+    name = Atom.to_string(info[:name])
+
+    cond do
+      info[:type] == :remote -> inspect(task)
+      info[:type] == :local and String.contains?(name, "/") -> "a function"
+      true -> "&#{name}/#{info[:arity]}"
+    end
+  end
+
+  # for invalid aliases
+  defp format_alias_task(task), do: inspect(task)
+
+  defp verbose_doc(task) do
+    aliases = load_aliases()
+
+    has_alias? = Map.has_key?(aliases, task)
+    has_task? = Mix.Task.get(task)
+
+    cond do
+      has_alias? and has_task? ->
+        note = "There is also a task named \"#{task}\". The documentation is shown next."
+        [alias_doc(aliases[task], note), task_doc(task)]
+
+      has_alias? ->
+        [alias_doc(aliases[task], nil)]
+
+      true ->
+        [task_doc(task)]
+    end
+  end
+
+  defp alias_doc(task_name, note) do
+    alias_doc = """
+    Alias for
+
+        #{format_alias(task_name)}
+    """
+
+    {alias_doc, "mix.exs", note}
+  end
+
+  defp format_alias(task) do
+    inspect(task, pretty: true, width: 0)
+    |> String.replace("\n", "\n    ")
+  end
+
+  defp task_doc(task) do
+    module = Mix.Task.get!(task)
+    doc = Mix.Task.moduledoc(module) || "There is no documentation for this task"
+    {doc, where_is_file(module), nil}
   end
 end
diff --git a/lib/mix/lib/mix/tasks/iex.ex b/lib/mix/lib/mix/tasks/iex.ex
index 3bc13aa84c0..04e6eeab133 100644
--- a/lib/mix/lib/mix/tasks/iex.ex
+++ b/lib/mix/lib/mix/tasks/iex.ex
@@ -1,11 +1,16 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Iex do
   use Mix.Task
 
   @moduledoc """
-  A task that is simply meant to redirect users to `iex -S mix`.
+  A task that simply instructs users to run `iex -S mix`.
   """
 
+  @impl true
   def run(_) do
-    Mix.raise "To use IEx with Mix, please run: iex -S mix"
+    Mix.raise("To use IEx with Mix, please run \"iex -S mix\"")
   end
 end
diff --git a/lib/mix/lib/mix/tasks/loadconfig.ex b/lib/mix/lib/mix/tasks/loadconfig.ex
index 567da818831..22dff3606c2 100644
--- a/lib/mix/lib/mix/tasks/loadconfig.ex
+++ b/lib/mix/lib/mix/tasks/loadconfig.ex
@@ -1,3 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Loadconfig do
   use Mix.Task
 
@@ -6,27 +10,110 @@ defmodule Mix.Tasks.Loadconfig do
   @moduledoc """
   Loads and persists the given configuration.
 
-  In case no configuration file is given, it
-  loads the project one at "config/config.exs".
+      $ mix loadconfig path/to/config.exs
+
+  Any configuration file loaded with `loadconfig` is treated
+  as a compile-time configuration. This means all application
+  keys are merged into their respective applications, however
+  the values themselves are not deep merged.
 
-  This task is automatically reenabled, so it
-  can be called multiple times to load different
-  configs.
+  `config/config.exs` is **always loaded automatically**
+  by the Mix CLI when it boots. `config/runtime.exs` is loaded
+  automatically by `mix app.config` before starting the current
+  application. Therefore there is no need to load those config
+  files directly.
+
+  This task is automatically re-enabled, so it can be called
+  multiple times to load different configs.
   """
+
+  @reserved_apps [:stdlib, :kernel]
+
+  @impl true
   def run(args) do
-    cond do
-      file = Enum.at(args, 0) ->
-        load file
-      File.regular?("config/config.exs") ->
-        load "config/config.exs"
-      true ->
-        :ok
+    Mix.Task.reenable("loadconfig")
+
+    case args do
+      [] -> load_default()
+      [file] -> load_compile(file)
+    end
+  end
+
+  defp load_default do
+    config_path = Mix.Project.config()[:config_path]
+
+    if config_path != nil and (File.regular?(config_path) or config_path != "config/config.exs") do
+      load_compile(config_path)
+    else
+      []
     end
+  end
+
+  @doc false
+  def read_compile() do
+    Mix.State.read_cache(__MODULE__) || []
+  end
+
+  @doc false
+  # Loads compile-time configuration, they support imports, and are not deep merged.
+  def load_compile(file) do
+    {config, files} = Config.Reader.read_imports!(file, env: Mix.env(), target: Mix.target())
+    Mix.ProjectStack.loaded_config(persist_apps(config, file), files)
+    Mix.State.write_cache(__MODULE__, config)
+  end
 
-    Mix.Task.reenable "loadconfig"
+  @doc false
+  # Loads runtime configuration, they do not support imports, and are deep merged.
+  def load_runtime(file) do
+    config = Config.Reader.read!(file, env: Mix.env(), target: Mix.target(), imports: :disabled)
+    Mix.ProjectStack.loaded_config(persist_apps(hydrate_apps(config), file), [])
+    config
   end
 
-  defp load(file) do
-    Mix.Config.persist Mix.Config.read! file
+  defp hydrate_apps(config) do
+    for {app, pairs} <- config do
+      hd(Config.Reader.merge([{app, Application.get_all_env(app)}], [{app, pairs}]))
+    end
+  end
+
+  defp persist_apps(config, file) do
+    Application.put_all_env(config, persistent: true)
+    apps = Keyword.keys(config)
+
+    case Enum.filter(@reserved_apps, &(&1 in apps)) do
+      [] ->
+        :ok
+
+      reserved_apps ->
+        Mix.shell().error("""
+        Cannot configure base applications: #{inspect(reserved_apps)}
+
+        These applications are already started by the time the configuration
+        executes and these configurations have no effect.
+
+        If you want to configure these applications for a release, you can
+        specify them in your vm.args file:
+
+            -kernel config_key config_value
+
+        Alternatively, if you must configure them dynamically, you can wrap
+        them in a conditional block in your config files:
+
+            if System.get_env("RELEASE_MODE") do
+              config :kernel, ...
+            end
+
+        and then configure your releases to reboot after configuration:
+
+            releases: [
+              my_app: [reboot_system_after_config: true]
+            ]
+
+        This happened when loading #{Path.relative_to_cwd(file)} or
+        one of its imports.
+        """)
+    end
+
+    apps
   end
 end
diff --git a/lib/mix/lib/mix/tasks/loadpaths.ex b/lib/mix/lib/mix/tasks/loadpaths.ex
index d57da8af485..1c5e70bf446 100644
--- a/lib/mix/lib/mix/tasks/loadpaths.ex
+++ b/lib/mix/lib/mix/tasks/loadpaths.ex
@@ -1,39 +1,79 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Loadpaths do
   use Mix.Task
 
   @moduledoc """
   Loads the application and its dependencies paths.
 
+  This task is never directly invoked from the command line,
+  but it is rather used as building block by other tasks.
+
+  Dependencies are checked, compiled, and loaded. Each step
+  can be explicitly disabled with flags.
+
+  ## Configuration
+
+    * `:elixir` - matches the current Elixir version against the
+      given requirement
+
   ## Command line options
 
-    * `--no-elixir-version-check` - do not check elixir version
+    * `--listeners` - starts Mix listeners (they are started by default,
+      unless `--no-listeners` or `--no-deps-check` are given)
+    * `--no-archives-check` - does not check archives
+    * `--no-compile` - does not compile dependencies, only check and load them
+    * `--no-deps-check` - does not check dependencies, only load available ones
+    * `--no-elixir-version-check` - does not check Elixir version
+    * `--no-listeners` - does not start Mix listeners
+    * `--no-optional-deps` - does not compile or load optional deps
 
   """
+  @impl true
   def run(args) do
-    {opts, _, _} = OptionParser.parse(args)
-
-    unless opts[:no_elixir_version_check] do
-      config = Mix.Project.config
-
-      if req = config[:elixir] do
-        case Version.parse_requirement(req) do
-          {:ok, req} ->
-            unless Version.match?(System.version, req) do
-              Mix.raise Mix.ElixirVersionError, target: config[:app] || Mix.Project.get,
-                                                expected: req,
-                                                actual: System.version
-            end
-          :error ->
-            Mix.raise "Invalid Elixir version requirement #{req} in mix.exs file"
-        end
-      end
+    config = Mix.Project.config()
+
+    # --from-mix-deps-compile is used only internally to avoid
+    # recursively checking and loading dependencies that have
+    # already been loaded. It has no purpose from Mix.CLI
+    # because running a task may load deps.
+    if "--from-mix-deps-compile" not in args do
+      Mix.Task.run("deps.loadpaths", args)
+    end
+
+    if config[:app] do
+      load_project(config)
     end
 
-    # Force recompile if we have a version mismatch.
-    # Skip it for umbrella apps since they have no build.
-    old_vsn = Mix.Dep.Lock.elixir_vsn
-    if old_vsn && old_vsn != System.version, do: Mix.Dep.Lock.touch
+    :ok
+  end
+
+  defp load_project(config) do
+    vsn = {System.version(), :erlang.system_info(:otp_release)}
+    scm = config[:build_scm]
+
+    # Erase the app build if we have lock mismatch.
+    # We do this to force full recompilation when
+    # any of SCM or Elixir version changes. Applies
+    # to dependencies and the main project alike.
+    case Mix.Dep.ElixirSCM.read() do
+      {:ok, old_vsn, old_scm, _deps_lock} when old_vsn != vsn or old_scm != scm ->
+        if Mix.debug?() do
+          Mix.shell().info(
+            "-- Recompiling #{inspect(config[:app])} because Erlang/OTP, Elixir, or SCM version changed"
+          )
+        end
+
+        File.rm_rf(Mix.Project.app_path(config))
+        File.rm_rf(Mix.Project.consolidation_path(config))
+
+      _ ->
+        :ok
+    end
 
-    Enum.each Mix.Project.load_paths, &Code.prepend_path(&1)
+    # We don't cache the current application as we may still write to it
+    Code.prepend_path(Mix.Project.compile_path(config))
   end
 end
diff --git a/lib/mix/lib/mix/tasks/local.ex b/lib/mix/lib/mix/tasks/local.ex
index a28a7847357..aa05b715538 100644
--- a/lib/mix/lib/mix/tasks/local.ex
+++ b/lib/mix/lib/mix/tasks/local.ex
@@ -1,33 +1,39 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Local do
   use Mix.Task
 
-  @shortdoc "List local tasks"
+  @shortdoc "Lists tasks installed locally via archives"
 
   @moduledoc """
-  List local tasks.
+  Lists tasks installed locally via archives.
   """
 
+  @impl true
   def run([]) do
-    shell   = Mix.shell
-    modules = Mix.Local.all_tasks
+    shell = Mix.shell()
+    modules = Mix.Local.archives_tasks()
 
-    docs = for module <- modules,
-        Mix.Task.is_task?(module) do
-      {Mix.Task.task_name(module), Mix.Task.shortdoc(module)}
-    end
+    docs =
+      for module <- modules do
+        {Mix.Task.task_name(module), Mix.Task.shortdoc(module)}
+      end
 
-    max = Enum.reduce docs, 0, fn({task, _}, acc) ->
-      max(byte_size(task), acc)
-    end
+    max =
+      Enum.reduce(docs, 0, fn {task, _}, acc ->
+        max(byte_size(task), acc)
+      end)
 
     sorted = Enum.sort(docs)
 
-    Enum.each sorted, fn({task, doc}) ->
-      shell.info format('mix ~-#{max}s # ~ts', [task, doc])
-    end
+    Enum.each(sorted, fn {task, doc} ->
+      shell.info(format(~c"mix ~-#{max}s # ~ts", [task, doc]))
+    end)
   end
 
   defp format(expression, args) do
-    :io_lib.format(expression, args) |> IO.iodata_to_binary
+    :io_lib.format(expression, args) |> IO.iodata_to_binary()
   end
 end
diff --git a/lib/mix/lib/mix/tasks/local.hex.ex b/lib/mix/lib/mix/tasks/local.hex.ex
index 5f51fcc4354..3f8882a5c1d 100644
--- a/lib/mix/lib/mix/tasks/local.hex.ex
+++ b/lib/mix/lib/mix/tasks/local.hex.ex
@@ -1,61 +1,90 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Local.Hex do
   use Mix.Task
 
-  @hex_url "https://hex.pm/installs/hex.ez"
-  @hex_requirement ">= 0.3.0"
+  @hex_list_path "/installs/hex.csv"
+  @hex_archive_path "/installs/[ELIXIR_VERSION]/hex-[HEX_VERSION]-otp-[OTP_RELEASE].ez"
 
-  @shortdoc "Install hex locally"
+  @shortdoc "Installs Hex locally"
 
   @moduledoc """
-  Install hex locally from #{@hex_url}.
+  Installs Hex locally.
+
+      $ mix local.hex [version]
+
+  By default the latest compatible version of Hex will be installed, unless
+  `version` is specified.
 
-      mix local.hex
+  If installing a precompiled Hex does not work, you can compile and install
+  Hex directly with this command:
+
+      $ mix archive.install github hexpm/hex branch latest
 
   ## Command line options
 
     * `--force` - forces installation without a shell prompt; primarily
-      intended for automation in build systems like make
-  """
-  def run(args) do
-    Mix.Tasks.Local.Install.run [@hex_url|args]
-  end
+      intended for automation in build systems like `make`
 
-  @doc false
-  def maybe_install(app) do
-    unless Code.ensure_loaded?(Hex) do
-      shell = Mix.shell
-      shell.info "Could not find hex, which is needed to build dependency #{inspect app}"
+    * `--if-missing` - performs installation only if Hex is not installed yet;
+      intended to avoid repeatedly reinstalling Hex in automation when a script
+      may be run multiple times
 
-      if shell.yes?("Shall I install hex?") do
-        run ["--force"]
-      end
-    end
-  end
+  If both options are set, the shell prompt is skipped and Hex is not
+  re-installed if it was already installed.
+
+  ## Mirrors
 
-  @doc false
-  def maybe_update do
-    if Code.ensure_loaded?(Hex) do
-      unless Version.match?(Hex.version, @hex_requirement) do
-        Mix.shell.info "Mix requires hex #{@hex_requirement} but you have #{Hex.version}"
+  If you want to change the [default mirror](https://builds.hex.pm)
+  used for fetching Hex, set the `HEX_BUILDS_URL` environment variable.
+  """
+  @switches [if_missing: :boolean, force: :boolean]
+  @compile {:no_warn_undefined, {Hex, :version, 0}}
+
+  @impl true
+  def run(argv) do
+    {opts, args} = OptionParser.parse!(argv, switches: @switches)
+    version = List.first(args)
 
-        if Mix.shell.yes?("Shall I abort the current command and update hex?") do
-          run ["--force"]
-          exit(0)
+    should_install? =
+      if Keyword.get(opts, :if_missing, false) do
+        if version do
+          not Code.ensure_loaded?(Hex) or Version.compare(Hex.version(), version) == :gt
+        else
+          not Code.ensure_loaded?(Hex)
         end
+      else
+        true
       end
-    end
+
+    argv =
+      if Keyword.get(opts, :force, false) do
+        ["--force"]
+      else
+        []
+      end
+
+    should_install? && run_install(version, argv)
   end
 
-  @doc false
-  def maybe_start do
-    try do
-      Code.ensure_loaded?(Hex) && Hex.start
-    catch
-      kind, reason ->
-        stacktrace = System.stacktrace
-        Mix.shell.error "Could not start Hex. Try fetching a new version with " <>
-                        "`mix local.hex` or uninstalling it with `mix local.uninstall hex`"
-        :erlang.raise(kind, reason, stacktrace)
-    end
+  defp run_install(version, argv) do
+    hex_url = Mix.Hex.url()
+
+    {elixir_version, hex_version, sha512, otp_release} =
+      Mix.Local.find_matching_versions!("Hex", version, hex_url <> @hex_list_path)
+
+    url =
+      (hex_url <> @hex_archive_path)
+      |> String.replace("[ELIXIR_VERSION]", elixir_version)
+      |> String.replace("[OTP_RELEASE]", otp_release)
+      |> String.replace("[HEX_VERSION]", hex_version)
+
+    # Unload the Hex module we loaded earlier to avoid conflicts when Hex is updated
+    # and then used without restarting the VM
+    :code.purge(Hex)
+
+    Mix.Tasks.Archive.Install.run([url, "--sha512", sha512 | argv])
   end
 end
diff --git a/lib/mix/lib/mix/tasks/local.install.ex b/lib/mix/lib/mix/tasks/local.install.ex
deleted file mode 100644
index 72e317f715e..00000000000
--- a/lib/mix/lib/mix/tasks/local.install.ex
+++ /dev/null
@@ -1,99 +0,0 @@
-defmodule Mix.Tasks.Local.Install do
-  use Mix.Task
-
-  import Mix.Generator, only: [create_file: 2]
-
-  @shortdoc "Install an archive locally"
-
-  @moduledoc """
-  Install an archive locally.
-
-  If no argument is supplied but there is an archive in the root
-  (created with mix archive), then the archive will be installed
-  locally. For example:
-
-      mix do archive, local.install
-
-  The argument can be an archive located at some URL:
-
-      mix local.install http://example.com/foo.ez
-
-  After installed, the tasks in the archive are available locally:
-
-      mix some_task
-
-  ## Command line options
-
-    * `--force` - forces installation without a shell prompt; primarily
-      intended for automation in build systems like make
-
-  """
-
-  def run(argv) do
-    {opts, argv, _} = OptionParser.parse(argv, switches: [force: :boolean])
-
-    if src = List.first(argv) do
-      %URI{path: path} = URI.parse(src)
-
-      case Path.extname(path) do
-        ".ez" -> install_archive(src, opts)
-        _     -> Mix.raise "mix local.install doesn't know how to install #{path}"
-      end
-    else
-      src = Mix.Archive.name(Mix.Project.config[:app], Mix.Project.config[:version])
-
-      if File.exists?(src) do
-        install_archive(src, opts)
-      else
-        Mix.raise "Expected PATH to be given, please use `mix local.install PATH`"
-      end
-    end
-  end
-
-  defp install_archive(src, opts) do
-    previous = previous_versions(src)
-
-    if opts[:force] || should_install?(src, previous) do
-      remove_previous_versions(previous)
-      dest = Mix.Local.archives_path()
-      File.mkdir_p!(dest)
-      archive = Path.join(dest, basename(src))
-      create_file archive, Mix.Utils.read_path!(src)
-      Code.append_path(Mix.Archive.ebin(archive))
-    end
-  end
-
-  defp basename(path) do
-    %URI{path: path} = URI.parse(path)
-    Path.basename(path)
-  end
-
-  defp should_install?(src, []) do
-    Mix.shell.yes?("Are you sure you want to install archive #{src}?")
-  end
-
-  defp should_install?(_src, previous_files) do
-    files = Enum.map_join(previous_files, ", ", &Path.basename/1)
-
-    Mix.shell.yes?("Found existing archives: #{files}.\n" <>
-                   "Are you sure you want to replace them?")
-  end
-
-  defp previous_versions(src) do
-    app = src
-          |> Mix.Archive.dir
-          |> String.split("-")
-          |> List.first
-
-    if app do
-      Mix.Local.archive_files(app)
-    else
-      []
-    end
-  end
-
-  defp remove_previous_versions([]),
-    do: :ok
-  defp remove_previous_versions(previous),
-    do: Enum.each(previous, &File.rm!/1)
-end
diff --git a/lib/mix/lib/mix/tasks/local.rebar.ex b/lib/mix/lib/mix/tasks/local.rebar.ex
index 37a0b5157d0..2c960bef144 100644
--- a/lib/mix/lib/mix/tasks/local.rebar.ex
+++ b/lib/mix/lib/mix/tasks/local.rebar.ex
@@ -1,33 +1,135 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Local.Rebar do
   use Mix.Task
 
-  import Mix.Generator, only: [create_file: 2]
+  @rebar3_list_url "/installs/rebar.csv"
+  @rebar3_escript_url "/installs/[ELIXIR_VERSION]/rebar3-[REBAR_VERSION]-otp-[OTP_RELEASE]"
 
-  @rebar_url "http://s3.hex.pm/rebar"
-  @shortdoc  "Install rebar locally"
+  @shortdoc "Installs Rebar locally"
 
   @moduledoc """
-  Fetch a copy of rebar from the given path or url. It defaults to a
-  rebar copy that ships with Elixir source if available or fetches it
-  from #{@rebar_url}.
+  Fetches a copy of `rebar3` from the given path or URL.
+
+  It defaults to safely download a Rebar copy from Hex's CDN.
+  However, a URL can be given as an argument, usually for an existing
+  local copy of Rebar:
+
+      $ mix local.rebar rebar3 path/to/rebar
+
+  The local copy is stored in your `MIX_HOME` (defaults to `~/.mix`)
+  according to the current Elixir. The installed version of Rebar will
+  be used whenever required by `mix deps.compile`.
+
+  ## Command line options
+
+    * `rebar3 PATH` - specifies a path for `rebar3`
+
+    * `--sha512` - checks the Rebar script matches the given SHA-512 checksum
+
+    * `--force` - forces installation without a shell prompt; primarily
+      intended for automation in build systems like `make`
+
+    * `--if-missing` - performs installation only if not installed yet;
+      intended to avoid repeatedly reinstalling in automation when a script
+      may be run multiple times
 
-  The local copy is stored in your MIX_HOME (defaults to ~/.mix).
-  This version of rebar will be used as required by `mix deps.compile`.
+  ## Mirrors
+
+  If you want to change the [default mirror](https://builds.hex.pm)
+  to use for fetching `rebar` please set the `HEX_BUILDS_URL` environment variable.
   """
 
+  @switches [force: :boolean, sha512: :string, if_missing: :boolean]
+
+  @impl true
   def run(argv) do
-    {_, argv, _} = OptionParser.parse(argv)
-    do_install(case argv do
-      []       -> @rebar_url
-      [path|_] -> path
-    end)
+    {opts, args, _} = OptionParser.parse(argv, switches: @switches)
+
+    case args do
+      ["rebar3", path | _] ->
+        maybe_install_from_path(:rebar3, path, opts)
+
+      [] ->
+        maybe_install_from_s3(:rebar3, @rebar3_list_url, @rebar3_escript_url, opts)
+
+      _ ->
+        Mix.raise(
+          "Invalid arguments given to mix local.rebar: #{inspect(args)}. " <>
+            "To find out the proper call syntax run \"mix help local.rebar\""
+        )
+    end
+  end
+
+  defp maybe_install_from_path(manager, path, opts) do
+    if not skip_install?(manager, opts) do
+      install_from_path(manager, path, opts)
+    end
+  end
+
+  defp maybe_install_from_s3(manager, list_url, escript_url, opts) do
+    if not skip_install?(manager, opts) do
+      install_from_s3(manager, list_url, escript_url, opts)
+    end
+  end
+
+  defp install_from_path(manager, path, opts) do
+    local = Mix.Rebar.local_rebar_path(manager)
+
+    if opts[:force] || Mix.Generator.overwrite?(local) do
+      case Mix.Utils.read_path(path, opts) do
+        {:ok, binary} ->
+          File.mkdir_p!(Path.dirname(local))
+          File.write!(local, binary)
+          File.chmod!(local, 0o755)
+          Mix.shell().info([:green, "* creating ", :reset, Path.relative_to_cwd(local)])
+
+        :badpath ->
+          Mix.raise("Expected #{inspect(path)} to be a local file path")
+
+        {:local, message} ->
+          Mix.raise(message)
+
+        {kind, message} when kind in [:remote, :checksum] ->
+          Mix.raise("""
+          #{message}
+
+          Could not fetch #{manager} at:
+
+              #{path}
+
+          Please download the file above manually to your current directory and run:
+
+              mix local.rebar #{manager} ./#{Path.basename(local)}
+          """)
+      end
+    end
+
+    true
+  end
+
+  defp install_from_s3(manager, list_url, escript_url, opts) do
+    hex_url = Mix.Hex.url()
+    list_url = hex_url <> list_url
+
+    {elixir_version, rebar_version, sha512, otp_release} =
+      Mix.Local.find_matching_versions!("Rebar", _version = nil, list_url)
+
+    url =
+      (hex_url <> escript_url)
+      |> String.replace("[ELIXIR_VERSION]", elixir_version)
+      |> String.replace("[REBAR_VERSION]", rebar_version)
+      |> String.replace("[OTP_RELEASE]", otp_release)
+
+    install_from_path(manager, url, Keyword.put(opts, :sha512, sha512))
   end
 
-  defp do_install(path) do
-    rebar = Mix.Utils.read_path!(path)
-    local_rebar_path = Mix.Rebar.local_rebar_path
-    File.mkdir_p! Path.dirname(local_rebar_path)
-    create_file local_rebar_path, rebar
-    :file.change_mode local_rebar_path, 0755
+  defp skip_install?(manager, opts) do
+    Keyword.get(opts, :if_missing, false) and
+      manager
+      |> Mix.Rebar.local_rebar_path()
+      |> File.exists?()
   end
 end
diff --git a/lib/mix/lib/mix/tasks/local.uninstall.ex b/lib/mix/lib/mix/tasks/local.uninstall.ex
deleted file mode 100644
index 78e825708c1..00000000000
--- a/lib/mix/lib/mix/tasks/local.uninstall.ex
+++ /dev/null
@@ -1,32 +0,0 @@
-defmodule Mix.Tasks.Local.Uninstall do
-  use Mix.Task
-
-  @shortdoc "Uninstall local tasks or archives"
-
-  @moduledoc """
-  Uninstall local tasks:
-
-      mix local.uninstall archive
-
-  """
-
-  def run(argv) do
-    {_, argv, _} = OptionParser.parse(argv)
-    if argv == [] do
-      Mix.raise "No archive was given to uninstall"
-    else
-      Enum.each argv, &do_uninstall(&1)
-    end
-  end
-
-  defp do_uninstall(name) do
-    archives = Mix.Local.archive_files(name)
-
-    if archives == [] do
-      Mix.raise "Could not find a local archive named #{inspect name} "<>
-        "at #{inspect Mix.Local.archives_path}"
-    end
-
-    Enum.each(archives, &File.rm!(&1))
-  end
-end
diff --git a/lib/mix/lib/mix/tasks/new.ex b/lib/mix/lib/mix/tasks/new.ex
index b39df404736..63a5d167492 100644
--- a/lib/mix/lib/mix/tasks/new.ex
+++ b/lib/mix/lib/mix/tasks/new.ex
@@ -1,20 +1,28 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.New do
   use Mix.Task
-
   import Mix.Generator
-  import Mix.Utils, only: [camelize: 1, underscore: 1]
 
-  @shortdoc "Create a new Elixir project"
+  @shortdoc "Creates a new Elixir project"
 
   @moduledoc """
   Creates a new Elixir project.
   It expects the path of the project as argument.
 
-      mix new PATH [--sup] [--module MODULE] [--umbrella]
+      $ mix new PATH [--app APP] [--module MODULE] [--sup] [--umbrella]
 
-  A project at the given PATH  will be created. The
+  A project at the given PATH will be created. The
   application name and module name will be retrieved
-  from the path, unless `--module` is given.
+  from the path, unless `--module` or `--app` is given.
+
+  An `--app` option can be given in order to
+  name the OTP application for the project.
+
+  A `--module` option can be given in order
+  to name the modules in the generated code skeleton.
 
   A `--sup` option can be given to generate an OTP application
   skeleton including a supervision tree. Normally an app is
@@ -25,321 +33,475 @@ defmodule Mix.Tasks.New do
 
   ## Examples
 
-      mix new hello_world
+      $ mix new hello_world
 
   Is equivalent to:
 
-      mix new hello_world --module HelloWorld
+      $ mix new hello_world --module HelloWorld
+
+  To generate an app with a supervision tree and an application callback:
+
+      $ mix new hello_world --sup
 
-  To generate an app with supervisor and application callback:
+  To generate an umbrella application with sub applications:
 
-      mix new hello_world --sup
+      $ mix new hello_world --umbrella
+      $ cd hello_world/apps
+      $ mix new child_app
 
   """
+
+  @switches [
+    app: :string,
+    module: :string,
+    sup: :boolean,
+    umbrella: :boolean
+  ]
+
+  @impl true
   def run(argv) do
-    {opts, argv, _} = OptionParser.parse(argv, switches: [sup: :boolean, umbrella: :boolean])
+    {opts, argv} = OptionParser.parse!(argv, strict: @switches)
 
     case argv do
       [] ->
-        Mix.raise "Expected PATH to be given, please use `mix new PATH`"
-      [path|_] ->
-        name = Path.basename(Path.expand(path))
-        check_project_name!(name)
-        File.mkdir_p!(path)
+        Mix.raise(
+          "Expected PATH to be given. " <>
+            "Use \"mix new PATH\" or run \"mix help new\" for more information"
+        )
+
+      [path | _] ->
+        app = opts[:app] || Path.basename(Path.expand(path))
+        check_application_name!(app, !opts[:app])
+        mod = opts[:module] || Macro.camelize(app)
+        check_mod_name_validity!(mod)
+        check_mod_name_availability!(mod)
+
+        if path != "." do
+          check_directory_existence!(path)
+          File.mkdir_p!(path)
+        end
 
-        File.cd! path, fn ->
+        File.cd!(path, fn ->
           if opts[:umbrella] do
-            do_generate_umbrella(name, path, opts)
+            generate_umbrella(app, mod, path, opts)
           else
-            do_generate(name, path, opts)
+            generate(app, mod, path, opts)
           end
-        end
+        end)
     end
   end
 
-  defp do_generate(app, path, opts) do
-    mod     = opts[:module] || camelize(app)
-    assigns = [app: app, mod: mod, otp_app: otp_app(mod, !!opts[:sup])]
+  defp generate(app, mod, path, opts) do
+    assigns = [
+      app: app,
+      mod: mod,
+      sup_app: sup_app(mod, !!opts[:sup]),
+      version: get_version(System.version())
+    ]
+
+    mod_filename = Macro.underscore(mod)
 
-    create_file "README.md",  readme_template(assigns)
-    create_file ".gitignore", gitignore_text
+    create_file("README.md", readme_template(assigns))
+    create_file(".formatter.exs", formatter_template(assigns))
+    create_file(".gitignore", gitignore_template(assigns))
 
-    if in_umbrella? do
-      create_file "mix.exs", mixfile_apps_template(assigns)
+    if in_umbrella?() do
+      create_file("mix.exs", mix_exs_apps_template(assigns))
     else
-      create_file "mix.exs", mixfile_template(assigns)
+      create_file("mix.exs", mix_exs_template(assigns))
     end
 
-    create_directory "config"
-    create_file "config/config.exs", config_template(assigns)
-
-    create_directory "lib"
+    create_directory("lib")
+    create_file("lib/#{mod_filename}.ex", lib_template(assigns))
 
     if opts[:sup] do
-      create_file "lib/#{app}.ex", lib_sup_template(assigns)
-    else
-      create_file "lib/#{app}.ex", lib_template(assigns)
+      create_file("lib/#{mod_filename}/application.ex", lib_app_template(assigns))
     end
 
-    create_directory "test"
-    create_file "test/test_helper.exs", test_helper_template(assigns)
-    create_file "test/#{app}_test.exs", test_template(assigns)
+    create_directory("test")
+    create_file("test/test_helper.exs", test_helper_template(assigns))
+    create_file("test/#{mod_filename}_test.exs", test_template(assigns))
 
-    Mix.shell.info """
+    """
 
-    Your mix project was created successfully.
-    You can use mix to compile it, test it, and more:
+    Your Mix project was created successfully.
+    You can use "mix" to compile it, test it, and more:
 
-        cd #{path}
-        mix test
+        #{cd_path(path)}mix test
 
-    Run `mix help` for more commands.
+    Run "mix help" for more commands.
     """
+    |> String.trim_trailing()
+    |> Mix.shell().info()
   end
 
-  defp otp_app(_mod, false) do
-    "    [applications: []]"
+  @doc """
+  Returns a list of reserved application names.
+  """
+  def reserved_application_names do
+    # 1. Command line flags with multiple args can conflict with application names
+    # 2. OTP names
+    # 3. Elixir names
+    ~w(boot_var compile config configfd env pa pz path run s setcookie)a ++
+      ~w(otp asn1 common_test compiler crypto debugger dialyzer diameter
+         edoc eldap erl_docgen erl_interface erts et eunit ftp
+         inets jinterface kernel megaco mnesia observer odbc os_mon
+         parsetools public_key reltool runtime_tools sasl snmp ssh
+         ssl stdlib syntax_tools tftp toolbar tools typer wx xmerl)a ++
+      ~w(eex elixir ex_unit iex logger mix)a
   end
 
-  defp otp_app(mod, true) do
-    "    [applications: [],\n     mod: {#{mod}, []}]"
-  end
+  defp sup_app(_mod, false), do: ""
+  defp sup_app(mod, true), do: ",\n      mod: {#{mod}.Application, []}"
+
+  defp cd_path("."), do: ""
+  defp cd_path(path), do: "cd #{path}\n    "
 
-  defp do_generate_umbrella(app, path, _opts) do
-    mod = camelize(app)
-    assigns = [mod: mod]
+  defp generate_umbrella(_app, mod, path, _opts) do
+    assigns = [app: nil, mod: mod]
 
-    create_file ".gitignore", gitignore_text
-    create_file "README.md", readme_template(assigns)
-    create_file "mix.exs", mixfile_umbrella_template(assigns)
+    create_file("README.md", readme_template(assigns))
+    create_file(".formatter.exs", formatter_umbrella_template(assigns))
+    create_file(".gitignore", gitignore_template(assigns))
+    create_file("mix.exs", mix_exs_umbrella_template(assigns))
 
-    create_directory "apps"
+    create_directory("apps")
 
-    create_directory "config"
-    create_file "config/config.exs",
-      config_template(assigns) <> config_umbrella_template(assigns)
+    create_directory("config")
+    create_file("config/config.exs", config_umbrella_template(assigns))
 
-    Mix.shell.info """
+    """
 
     Your umbrella project was created successfully.
     Inside your project, you will find an apps/ directory
     where you can create and host many apps:
 
-        cd #{path}
-        cd apps
+        #{cd_path(path)}cd apps
         mix new my_app
 
-    Commands like `mix compile` and `mix test` when executed
+    Commands like "mix compile" and "mix test" when executed
     in the umbrella project root will automatically run
     for each application in the apps/ directory.
     """
+    |> String.trim_trailing()
+    |> Mix.shell().info()
   end
 
-  defp check_project_name!(name) do
-    unless name =~ ~r/^[a-z][\w_]*$/ do
-      Mix.raise "Project path must start with a letter and have only lowercase letters, numbers and underscore"
+  defp check_application_name!(name, inferred?) do
+    if message = invalid_app(name) || reserved_app(name) do
+      Mix.raise(
+        message <>
+          if inferred? do
+            ". The application name is inferred from the path, if you'd like to " <>
+              "explicitly name the application then use the \"--app APP\" option"
+          else
+            ""
+          end
+      )
     end
   end
 
-  defp in_umbrella? do
-    apps = Path.dirname(File.cwd!)
-
-    try do
-      Mix.Project.in_project(:umbrella_check, "../..", fn _ ->
-        path = Mix.Project.config[:apps_path]
-        path && Path.expand(path) == apps
-      end)
-    catch
-      _, _ -> false
+  defp invalid_app(name) do
+    if not (name =~ ~r/^[a-z][a-z0-9_]*$/) do
+      "Application name must start with a lowercase ASCII letter, followed by " <>
+        "lowercase ASCII letters, numbers, or underscores, got: #{inspect(name)}"
+    end
+  end
+
+  defp reserved_app(name) do
+    atom_name = String.to_atom(name)
+
+    if atom_name in reserved_application_names() or Application.ensure_loaded(atom_name) == :ok do
+      "Cannot use application name #{inspect(name)} because it is already used by Erlang/OTP or Elixir"
+    end
+  end
+
+  defp check_mod_name_validity!(name) do
+    if not (name =~ ~r/^[A-Z]\w*(\.[A-Z]\w*)*$/) do
+      Mix.raise(
+        "Module name must be a valid Elixir alias (for example: Foo.Bar), got: #{inspect(name)}"
+      )
+    end
+  end
+
+  defp check_mod_name_availability!(name) do
+    name = Module.concat(Elixir, name)
+
+    if Code.ensure_loaded?(name) do
+      Mix.raise("Module name #{inspect(name)} is already taken, please choose another name")
     end
   end
 
-   embed_template :readme, """
-   <%= @mod %>
-   <%= String.duplicate("=", String.length(@mod)) %>
+  defp check_directory_existence!(path) do
+    msg = "The directory #{inspect(path)} already exists. Are you sure you want to continue?"
 
-   ** TODO: Add description **
-   """
+    if File.dir?(path) and not Mix.shell().yes?(msg) do
+      Mix.raise("Please select another directory for installation")
+    end
+  end
 
-   embed_text :gitignore, """
-   /_build
-   /deps
-   erl_crash.dump
-   *.ez
-   """
+  defp get_version(version) do
+    {:ok, version} = Version.parse(version)
 
-  embed_template :mixfile, """
-  defmodule <%= @mod %>.Mixfile do
+    "#{version.major}.#{version.minor}" <>
+      case version.pre do
+        [h | _] -> "-#{h}"
+        [] -> ""
+      end
+  end
+
+  defp in_umbrella? do
+    Mix.Project.umbrella?() or
+      (
+        apps = Path.dirname(File.cwd!())
+
+        try do
+          Mix.Project.in_project(:umbrella_check, "../..", fn _ ->
+            path = Mix.Project.config()[:apps_path]
+            path && Path.expand(path) == apps
+          end)
+        catch
+          _, _ -> false
+        end
+      )
+  end
+
+  embed_template(:readme, """
+  # <%= @mod %>
+
+  **TODO: Add description**
+  <%= if @app do %>
+  ## Installation
+
+  If [available in Hex](https://hex.pm/docs/publish), the package can be installed
+  by adding `<%= @app %>` to your list of dependencies in `mix.exs`:
+
+  ```elixir
+  def deps do
+    [
+      {:<%= @app %>, "~> 0.1.0"}
+    ]
+  end
+  ```
+
+  Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc)
+  and published on [HexDocs](https://hexdocs.pm). Once published, the docs can
+  be found at <https://hexdocs.pm/<%= @app %>>.
+  <% end %>
+  """)
+
+  embed_template(:formatter, """
+  # Used by "mix format"
+  [
+    inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+  ]
+  """)
+
+  embed_template(:formatter_umbrella, """
+  # Used by "mix format"
+  [
+    inputs: ["mix.exs", "config/*.exs"],
+    subdirectories: ["apps/*"]
+  ]
+  """)
+
+  embed_template(:gitignore, """
+  # The directory Mix will write compiled artifacts to.
+  /_build/
+
+  # If you run "mix test --cover", coverage assets end up here.
+  /cover/
+
+  # The directory Mix downloads your dependencies sources to.
+  /deps/
+
+  # Where third-party dependencies like ExDoc output generated docs.
+  /doc/
+
+  # Temporary files, for example, from tests.
+  /tmp/
+
+  # If the VM crashes, it generates a dump, let's ignore it too.
+  erl_crash.dump
+
+  # Also ignore archive artifacts (built via "mix archive.build").
+  *.ez
+  <%= if @app do %>
+  # Ignore package tarball (built via "mix hex.build").
+  <%= @app %>-*.tar
+  <% end %>
+  """)
+
+  embed_template(:mix_exs, """
+  defmodule <%= @mod %>.MixProject do
     use Mix.Project
 
     def project do
-      [app: :<%= @app %>,
-       version: "0.0.1",
-       elixir: "~> <%= System.version %>",
-       deps: deps]
+      [
+        app: :<%= @app %>,
+        version: "0.1.0",
+        elixir: "~> <%= @version %>",
+        start_permanent: Mix.env() == :prod,
+        deps: deps()
+      ]
     end
 
-    # Configuration for the OTP application
-    #
-    # Type `mix help compile.app` for more information
+    # Run "mix help compile.app" to learn about applications.
     def application do
-  <%= @otp_app %>
+      [
+        extra_applications: [:logger]<%= @sup_app %>
+      ]
     end
 
-    # Dependencies can be hex.pm packages:
-    #
-    #   {:mydep, "~> 0.3.0"}
-    #
-    # Or git/path repositories:
-    #
-    #   {:mydep, git: "https://github.com/elixir-lang/mydep.git", tag: "0.1"}
-    #
-    # Type `mix help deps` for more examples and options
+    # Run "mix help deps" to learn about dependencies.
     defp deps do
-      []
+      [
+        # {:dep_from_hexpm, "~> 0.3.0"},
+        # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"}
+      ]
     end
   end
-  """
+  """)
 
-  embed_template :mixfile_apps, """
-  defmodule <%= @mod %>.Mixfile do
+  embed_template(:mix_exs_apps, """
+  defmodule <%= @mod %>.MixProject do
     use Mix.Project
 
     def project do
-      [app: :<%= @app %>,
-       version: "0.0.1",
-       deps_path: "../../deps",
-       lockfile: "../../mix.lock",
-       elixir: "~> <%= System.version %>",
-       deps: deps]
+      [
+        app: :<%= @app %>,
+        version: "0.1.0",
+        build_path: "../../_build",
+        config_path: "../../config/config.exs",
+        deps_path: "../../deps",
+        lockfile: "../../mix.lock",
+        elixir: "~> <%= @version %>",
+        start_permanent: Mix.env() == :prod,
+        deps: deps()
+      ]
     end
 
-    # Configuration for the OTP application
-    #
-    # Type `mix help compile.app` for more information
+    # Run "mix help compile.app" to learn about applications.
     def application do
-  <%= @otp_app %>
+      [
+        extra_applications: [:logger]<%= @sup_app %>
+      ]
     end
 
-    # Dependencies can be hex.pm packages:
-    #
-    #   {:mydep, "~> 0.3.0"}
-    #
-    # Or git/path repositories:
-    #
-    #   {:mydep, git: "https://github.com/elixir-lang/mydep.git", tag: "0.1"}
-    #
-    # To depend on another app inside the umbrella:
-    #
-    #   {:myapp, in_umbrella: true}
-    #
-    # Type `mix help deps` for more examples and options
+    # Run "mix help deps" to learn about dependencies.
     defp deps do
-      []
+      [
+        # {:dep_from_hexpm, "~> 0.3.0"},
+        # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"},
+        # {:sibling_app_in_umbrella, in_umbrella: true}
+      ]
     end
   end
-  """
+  """)
 
-  embed_template :mixfile_umbrella, """
-  defmodule <%= @mod %>.Mixfile do
+  embed_template(:mix_exs_umbrella, """
+  defmodule <%= @mod %>.MixProject do
     use Mix.Project
 
     def project do
-      [apps_path: "apps",
-       deps: deps]
+      [
+        apps_path: "apps",
+        version: "0.1.0",
+        start_permanent: Mix.env() == :prod,
+        deps: deps()
+      ]
     end
 
-    # Dependencies can be hex.pm packages:
-    #
-    #   {:mydep, "~> 0.3.0"}
-    #
-    # Or git/path repositories:
+    # Dependencies listed here are available only for this
+    # project and cannot be accessed from applications inside
+    # the apps folder.
     #
-    #   {:mydep, git: "https://github.com/elixir-lang/mydep.git", tag: "0.1"}
-    #
-    # Type `mix help deps` for more examples and options.
-    #
-    # Dependencies listed here are available only for this project
-    # and cannot be accessed from applications inside the apps folder
+    # Run "mix help deps" for examples and options.
     defp deps do
       []
     end
   end
-  """
+  """)
 
-  embed_template :config, ~S"""
-  # This file is responsible for configuring your application
-  # and its dependencies. The Mix.Config module provides functions
-  # to aid in doing so.
-  use Mix.Config
-
-  # Note this file is loaded before any dependency and is restricted
-  # to this project. If another project depends on this project, this
-  # file won't be loaded nor affect the parent project.
+  embed_template(:config_umbrella, ~S"""
+  # This file is responsible for configuring your umbrella
+  # and **all applications** and their dependencies with the
+  # help of the Config module.
+  #
+  # Note that all applications in your umbrella share the
+  # same configuration and dependencies, which is why they
+  # all use the same configuration file. If you want different
+  # configurations or dependencies per app, it is best to
+  # move said applications out of the umbrella.
+  import Config
 
   # Sample configuration:
   #
-  #     config :my_dep,
-  #       key: :value,
-  #       limit: 42
-
-  # It is also possible to import configuration files, relative to this
-  # directory. For example, you can emulate configuration per environment
-  # by uncommenting the line below and defining dev.exs, test.exs and such.
-  # Configuration from the imported file will override the ones defined
-  # here (which is why it is important to import them last).
+  #     config :logger, :default_handler,
+  #       level: :info
   #
-  #     import_config "#{Mix.env}.exs"
-  """
-
-  embed_template :config_umbrella, ~S"""
-
-  # Finally, note that configuration defined in children projects
-  # inside apps/ are not automatically available to the umbrella parent.
-  # They can, however, be easily imported as well:
+  #     config :logger, :default_formatter,
+  #       format: "$date $time [$level] $metadata$message\n",
+  #       metadata: [:user_id]
   #
-  #     import_config "../apps/foo/config/config.exs"
-  #     import_config "../apps/bar/config/config.exs"
-  """
+  """)
 
-  embed_template :lib, """
+  embed_template(:lib, """
   defmodule <%= @mod %> do
+    @moduledoc \"""
+    Documentation for `<%= @mod %>`.
+    \"""
+
+    @doc \"""
+    Hello world.
+
+    ## Examples
+
+        iex> <%= @mod %>.hello()
+        :world
+
+    \"""
+    def hello do
+      :world
+    end
   end
-  """
+  """)
+
+  embed_template(:lib_app, """
+  defmodule <%= @mod %>.Application do
+    # See https://hexdocs.pm/elixir/Application.html
+    # for more information on OTP Applications
+    @moduledoc false
 
-  embed_template :lib_sup, """
-  defmodule <%= @mod %> do
     use Application
 
-    # See http://elixir-lang.org/docs/stable/elixir/Application.html
-    # for more information on OTP Applications
+    @impl true
     def start(_type, _args) do
-      import Supervisor.Spec, warn: false
-
       children = [
-        # Define workers and child supervisors to be supervised
-        # worker(<%= @mod %>.Worker, [arg1, arg2, arg3])
+        # Starts a worker by calling: <%= @mod %>.Worker.start_link(arg)
+        # {<%= @mod %>.Worker, arg}
       ]
 
-      # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
+      # See https://hexdocs.pm/elixir/Supervisor.html
       # for other strategies and supported options
       opts = [strategy: :one_for_one, name: <%= @mod %>.Supervisor]
       Supervisor.start_link(children, opts)
     end
   end
-  """
+  """)
 
-  embed_template :test, """
+  embed_template(:test, """
   defmodule <%= @mod %>Test do
     use ExUnit.Case
+    doctest <%= @mod %>
 
-    test "the truth" do
-      assert 1 + 1 == 2
+    test "greets the world" do
+      assert <%= @mod %>.hello() == :world
     end
   end
-  """
+  """)
 
-  embed_template :test_helper, """
+  embed_template(:test_helper, """
   ExUnit.start()
-  """
+  """)
 end
diff --git a/lib/mix/lib/mix/tasks/profile.cprof.ex b/lib/mix/lib/mix/tasks/profile.cprof.ex
new file mode 100644
index 00000000000..9bca753f133
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/profile.cprof.ex
@@ -0,0 +1,290 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Profile.Cprof do
+  use Mix.Task
+
+  @shortdoc "Profiles the given file or expression with cprof"
+
+  @moduledoc """
+  Profiles the given file or expression using Erlang's `cprof` tool.
+
+  [`:cprof`](`:cprof`) can be useful when you want to discover the bottlenecks related
+  to function calls.
+
+  Before running the code, it invokes the `app.start` task which compiles
+  and loads your project. After that, the target expression is profiled together
+  with all matching function calls, by setting breakpoints containing
+  counters. These can only be set on BEAM code so BIFs cannot be call
+  count traced.
+
+  To profile the code, you can use syntax similar to the `mix run` task:
+
+      $ mix profile.cprof -e Hello.world
+      $ mix profile.cprof -e "[1, 2, 3] |> Enum.reverse |> Enum.map(&Integer.to_string/1)"
+      $ mix profile.cprof my_script.exs arg1 arg2 arg3
+
+  This task is automatically re-enabled, so you can profile multiple times
+  in the same Mix invocation.
+
+  ## Command line options
+
+    * `--matching` - only profile calls matching the given `Module.function/arity` pattern
+    * `--limit` - filters out any results with a call count less than the limit
+    * `--module` - filters out any results not pertaining to the given module
+    * `--eval`, `-e` - evaluate the given code
+    * `--require`, `-r` - requires pattern before running the command
+    * `--parallel`, `-p` - makes all requires parallel
+    * `--no-compile` - does not compile even if files require compilation
+    * `--no-deps-check` - does not check dependencies
+    * `--no-archives-check` - does not check archives
+    * `--no-halt` - does not halt the system after running the command
+    * `--no-start` - does not start applications after compilation
+    * `--no-elixir-version-check` - does not check the Elixir version from mix.exs
+
+  ## Profile output
+
+  Example output:
+                                                                           CNT
+      Total                                                                 15
+      Enum                                                                   6  <--
+        Enum."-map/2-lists^map/1-0-"/2                                       4
+        Enum.reverse/1                                                       1
+        Enum.map/2                                                           1
+      :elixir_compiler                                                       4  <--
+        anonymous fn/1 in :elixir_compiler.__FILE__/1                        3
+        anonymous fn/0 in :elixir_compiler.__FILE__/1                        1
+      String.Chars.Integer                                                   3  <--
+        String.Chars.Integer.to_string/1                                     3
+      :erlang                                                                2  <--
+        :erlang.trace_pattern/3                                              2
+      Profile done over 20229 matching functions
+
+  The default output contains data gathered from all matching functions. The left
+  column structures each module and its total call count trace is presented on the right.
+  Each module has its count discriminated by function below. The `<--` symbol is meant to
+  help visualize where a new module call count begins.
+
+  The first row (Total) is the sum of all function calls. In the last row the number of
+  matching functions that were considered for profiling is presented.
+
+  When `--matching` option is specified, call count tracing will be started only for
+  the functions matching the given pattern:
+
+      String.Chars.Integer                                                   3  <--
+        String.Chars.Integer.to_string/1                                     3
+      Profile done over 1 matching functions
+
+  The pattern can be a module name, such as `String` to count all calls to that module,
+  a call without arity, such as `String.split`, to count all calls to that function
+  regardless of arity, or a call with arity, such as `String.split/3`, to count all
+  calls to that exact module, function and arity.
+
+  ## Caveats
+
+  You should be aware the profiler is stopped as soon as the code has finished running. This
+  may need special attention, when:  running asynchronous code as function calls which were
+  called before the profiler stopped will not be counted; running synchronous code as long
+  running computations and a profiler without a proper MFA trace pattern or filter may
+  lead to a result set which is difficult to comprehend.
+
+  Other caveats are the impossibility to call count trace BIFs, since breakpoints can
+  only be set on BEAM code; functions calls performed by `:cprof` are not traced; the
+  maximum size of a call counter is equal to the host machine's word size
+  (for example, `2_147_483_647` in a 32-bit host).
+  """
+
+  @typedoc """
+  Options for the cprof profiler.
+  """
+  @type profile_opts :: [
+          matching: {module() | :_, atom() | :_, arity() | :_},
+          limit: non_neg_integer(),
+          module: module()
+        ]
+
+  @switches [
+    parallel: :boolean,
+    require: :keep,
+    eval: :keep,
+    config: :keep,
+    matching: :string,
+    halt: :boolean,
+    compile: :boolean,
+    deps_check: :boolean,
+    limit: :integer,
+    module: :string,
+    start: :boolean,
+    archives_check: :boolean,
+    warmup: :boolean,
+    elixir_version_check: :boolean,
+    parallel_require: :keep
+  ]
+
+  @aliases [r: :require, p: :parallel, e: :eval, c: :config]
+
+  @impl true
+  def run(args) do
+    {opts, head} = OptionParser.parse_head!(args, aliases: @aliases, strict: @switches)
+    Mix.Task.reenable("profile.cprof")
+
+    Mix.Tasks.Run.run(
+      ["--no-mix-exs" | args],
+      opts,
+      head,
+      &profile_code(&1, opts),
+      &profile_code(File.read!(&1), opts)
+    )
+  end
+
+  defp profile_code(code_string, opts) do
+    opts = Enum.map(opts, &parse_opt/1)
+
+    content =
+      quote do
+        unquote(__MODULE__).profile(
+          fn ->
+            unquote(Code.string_to_quoted!(code_string))
+          end,
+          unquote(Macro.escape(opts))
+        )
+      end
+
+    # Use compile_quoted since it leaves less noise than eval_quoted
+    Code.compile_quoted(content)
+  end
+
+  defp parse_opt({:matching, matching}) do
+    case Mix.Utils.parse_mfa(matching) do
+      {:ok, [m, f, a]} -> {:matching, {m, f, a}}
+      {:ok, [m, f]} -> {:matching, {m, f, :_}}
+      {:ok, [m]} -> {:matching, {m, :_, :_}}
+      :error -> Mix.raise("Invalid matching pattern: #{matching}")
+    end
+  end
+
+  defp parse_opt({:module, module}), do: {:module, string_to_existing_module(module)}
+  defp parse_opt(other), do: other
+
+  @doc """
+  Allows to programmatically run the `cprof` profiler on expression in `fun`.
+
+  Returns the return value of `fun`.
+
+  ## Options
+
+    * `:matching` - only profile calls matching the given pattern in form of
+      `{module, function, arity}`, where each element may be replaced by `:_`
+      to allow any value
+    * `:limit` - filters out any results with a call count less than the limit
+    * `:module` - filters out any results not pertaining to the given module
+
+  """
+  @spec profile((-> result), profile_opts()) :: result when result: any()
+  def profile(fun, opts \\ []) when is_function(fun, 0) do
+    Mix.ensure_application!(:tools)
+    {return_value, num_matched_functions, analysis_result} = profile_and_analyse(fun, opts)
+    print_output(num_matched_functions, analysis_result)
+    :cprof.stop()
+    return_value
+  end
+
+  defp profile_and_analyse(fun, opts) do
+    if Keyword.get(opts, :warmup, true) do
+      IO.puts("Warmup...")
+      fun.()
+    end
+
+    num_matched_functions =
+      case Keyword.fetch(opts, :matching) do
+        {:ok, matching} -> :cprof.start(matching)
+        :error -> :cprof.start()
+      end
+
+    return_value = apply(fun, [])
+
+    :cprof.pause()
+
+    limit = Keyword.get(opts, :limit)
+    module = Keyword.get(opts, :module)
+
+    analysis_result =
+      case {limit, module} do
+        {nil, nil} ->
+          :cprof.analyse()
+
+        {limit, nil} ->
+          :cprof.analyse(limit)
+
+        {limit, module} ->
+          if limit do
+            :cprof.analyse(module, limit)
+          else
+            :cprof.analyse(module)
+          end
+      end
+
+    {return_value, num_matched_functions, analysis_result}
+  end
+
+  defp string_to_existing_module(":" <> module), do: String.to_existing_atom(module)
+  defp string_to_existing_module(module), do: Module.concat([module])
+
+  defp print_output(num_matched_functions, {all_call_count, mod_analysis_list}) do
+    print_total_row(all_call_count)
+    Enum.each(mod_analysis_list, &print_analysis_result/1)
+    print_number_of_matched_functions(num_matched_functions)
+  end
+
+  defp print_output(num_matched_functions, {_mod, _call_count, _mod_fun_list} = mod_analysis) do
+    print_analysis_result(mod_analysis)
+    print_number_of_matched_functions(num_matched_functions)
+  end
+
+  defp print_number_of_matched_functions(num_matched_functions) do
+    IO.puts("Profile done over #{num_matched_functions} matching functions")
+  end
+
+  defp print_total_row(all_call_count) do
+    IO.puts("")
+    print_row(["s", "s", "s"], ["", "CNT", ""])
+    print_row(["s", "B", "s"], ["Total", all_call_count, ""])
+  end
+
+  defp print_analysis_result({module, total_module_count, module_fun_list}) do
+    module
+    |> Atom.to_string()
+    |> module_name_for_printing()
+    |> print_module(total_module_count, "", "<--")
+
+    Enum.each(module_fun_list, &print_function(&1, "  "))
+  end
+
+  defp print_module(module, count, prefix, suffix) do
+    print_row(["s", "B", "s"], ["#{prefix}#{module}", count, suffix])
+  end
+
+  defp module_name_for_printing("Elixir." <> rest = _module_name), do: rest
+  defp module_name_for_printing(module_name), do: ":" <> module_name
+
+  defp print_function({fun, count}, prefix, suffix \\ "") do
+    print_row(["s", "B", "s"], ["#{prefix}#{function_text(fun)}", count, suffix])
+  end
+
+  defp function_text({module, function, arity}) do
+    Exception.format_mfa(module, function, arity)
+  end
+
+  defp function_text(other), do: inspect(other)
+
+  @columns [-60, 12, 5]
+  defp print_row(formats, data) do
+    Stream.zip(@columns, formats)
+    |> Stream.map(fn {width, format} -> "~#{width}#{format}" end)
+    |> Enum.join()
+    |> :io.format(data)
+
+    IO.puts("")
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/profile.eprof.ex b/lib/mix/lib/mix/tasks/profile.eprof.ex
new file mode 100644
index 00000000000..e4c134a01de
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/profile.eprof.ex
@@ -0,0 +1,344 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Profile.Eprof do
+  use Mix.Task
+
+  @shortdoc "Profiles the given file or expression with eprof"
+
+  @moduledoc """
+  Profiles the given file or expression using Erlang's `eprof` tool.
+
+  [`:eprof`](`:eprof`) provides time information of each function call and can be useful
+  when you want to discover the bottlenecks related to this.
+
+  Before running the code, it invokes the `app.start` task which compiles
+  and loads your project. After that, the target expression is profiled together
+  with all matching function calls using the Erlang trace BIFs. The tracing of
+  the function calls for that is enabled when the profiling is begun, and
+  disabled when profiling is stopped.
+
+  To profile the code, you can use syntax similar to the `mix run` task:
+
+      $ mix profile.eprof -e Hello.world
+      $ mix profile.eprof -e "[1, 2, 3] |> Enum.reverse |> Enum.map(&Integer.to_string/1)"
+      $ mix profile.eprof my_script.exs arg1 arg2 arg3
+
+  This task is automatically re-enabled, so you can profile multiple times
+  in the same Mix invocation.
+
+  ## Command line options
+
+    * `--matching` - only profile calls matching the given `Module.function/arity` pattern
+    * `--calls` - filters out any results with a call count lower than this
+    * `--time` - filters out any results that took lower than specified (in µs)
+    * `--sort` - sorts the results by `time` or `calls` (default: `time`)
+    * `--eval`, `-e` - evaluates the given code
+    * `--require`, `-r` - requires pattern before running the command
+    * `--parallel`, `-p` - makes all requires parallel
+    * `--no-warmup` - skips the warmup step before profiling
+    * `--no-compile` - does not compile even if files require compilation
+    * `--no-deps-check` - does not check dependencies
+    * `--no-archives-check` - does not check archives
+    * `--no-halt` - does not halt the system after running the command
+    * `--no-start` - does not start applications after compilation
+    * `--no-elixir-version-check` - does not check the Elixir version from mix.exs
+
+  ## Profile output
+
+  Example output:
+
+      #                                               CALLS     % TIME µS/CALL
+      Total                                              24 100.0   26    1.08
+      Enum.reduce_range_inc/4                             5  3.85    1    0.20
+      :erlang.make_fun/3                                  1  7.69    2    2.00
+      Enum.each/2                                         1  7.69    2    2.00
+      anonymous fn/0 in :elixir_compiler_0.__FILE__/1     1  7.69    2    2.00
+      :erlang.integer_to_binary/1                         5 15.39    4    0.80
+      :erlang.apply/2                                     1 15.39    4    4.00
+      anonymous fn/3 in Enum.each/2                       5 19.23    5    1.00
+      String.Chars.Integer.to_string/1                    5 23.08    6    1.20
+
+      Profile done over 8 matching functions
+
+  The default output contains data gathered from all matching functions. The first
+  row after the header contains the sums of the partial results and the average time
+  for all the function calls listed. The following rows contain the function call,
+  followed by the number of times that the function was called, then by the percentage
+  of time that the call uses, then the total time for that function in microseconds,
+  and, finally, the average time per call in microseconds.
+
+  When `--matching` option is specified, call count tracing will be started only for
+  the functions matching the given pattern:
+
+      #                                               CALLS     % TIME µS/CALL
+      Total                                               5 100.0    6    1.20
+      String.Chars.Integer.to_string/1                    5 100.0    6    1.20
+
+      Profile done over 1 matching functions
+
+  The pattern can be a module name, such as `String` to count all calls to that module,
+  a call without arity, such as `String.split`, to count all calls to that function
+  regardless of arity, or a call with arity, such as `String.split/3`, to count all
+  calls to that exact module, function and arity.
+
+  ## Caveats
+
+  You should be aware that the code being profiled is running in an anonymous
+  function which is invoked by [`:eprof` module](`:eprof`).
+  Thus, you'll see some additional entries in your profile output. It is also
+  important to note that the profiler is stopped as soon as the code has finished running,
+  and this may need special attention, when: running asynchronous code as function calls which were
+  called before the profiler stopped will not be counted; running synchronous code as long
+  running computations and a profiler without a proper MFA trace pattern or filter may
+  lead to a result set which is difficult to comprehend.
+
+  You should expect a slowdown in your code execution using this tool since `:eprof` has
+  some performance impact on the execution, but the impact is considerably lower than
+  `Mix.Tasks.Profile.Fprof`. If you have a large system try to profile a limited
+  scenario or focus on the main modules or processes. Another alternative is to use
+  `Mix.Tasks.Profile.Cprof` that uses [`:cprof`](`:cprof`) and has a low performance degradation effect.
+  """
+
+  @typedoc """
+  Options for the eprof profiler.
+  """
+  @type profile_opts :: [
+          matching: {module() | :_, atom() | :_, arity() | :_},
+          calls: non_neg_integer(),
+          time: non_neg_integer(),
+          sort: :time | :calls,
+          warmup: boolean(),
+          set_on_spawn: boolean()
+        ]
+
+  @switches [
+    parallel: :boolean,
+    require: :keep,
+    eval: :keep,
+    config: :keep,
+    matching: :string,
+    halt: :boolean,
+    compile: :boolean,
+    deps_check: :boolean,
+    calls: :integer,
+    time: :integer,
+    sort: :string,
+    start: :boolean,
+    archives_check: :boolean,
+    warmup: :boolean,
+    elixir_version_check: :boolean,
+    parallel_require: :keep
+  ]
+
+  @aliases [
+    r: :require,
+    p: :parallel,
+    e: :eval,
+    c: :config
+  ]
+
+  @impl true
+  def run(args) do
+    {opts, head} = OptionParser.parse_head!(args, aliases: @aliases, strict: @switches)
+    Mix.Task.reenable("profile.eprof")
+
+    Mix.Tasks.Run.run(
+      ["--no-mix-exs" | args],
+      opts,
+      head,
+      &profile_code(&1, opts),
+      &profile_code(File.read!(&1), opts)
+    )
+  end
+
+  defp profile_code(code_string, opts) do
+    opts = Enum.map(opts, &parse_opt/1)
+
+    content =
+      quote do
+        unquote(__MODULE__).profile(
+          fn ->
+            unquote(Code.string_to_quoted!(code_string))
+          end,
+          unquote(Macro.escape(opts))
+        )
+      end
+
+    # Use compile_quoted since it leaves less noise than eval_quoted
+    Code.compile_quoted(content)
+  end
+
+  defp parse_opt({:matching, matching}) do
+    case Mix.Utils.parse_mfa(matching) do
+      {:ok, [m, f, a]} -> {:matching, {m, f, a}}
+      {:ok, [m, f]} -> {:matching, {m, f, :_}}
+      {:ok, [m]} -> {:matching, {m, :_, :_}}
+      :error -> Mix.raise("Invalid matching pattern: #{matching}")
+    end
+  end
+
+  defp parse_opt({:sort, "time"}), do: {:sort, :time}
+  defp parse_opt({:sort, "calls"}), do: {:sort, :calls}
+  defp parse_opt({:sort, other}), do: Mix.raise("Invalid sort option: #{other}")
+  defp parse_opt(other), do: other
+
+  @doc """
+  Allows to programmatically run the `eprof` profiler on expression in `fun`.
+
+  Returns the return value of `fun`.
+
+  ## Options
+
+    * `:matching` - only profile calls matching the given pattern in form of
+      `{module, function, arity}`, where each element may be replaced by `:_`
+      to allow any value
+    * `:calls` - filters out any results with a call count lower than this
+    * `:time` - filters out any results that took lower than specified (in µs)
+    * `:sort` - sort the results by `:time` or `:calls` (default: `:time`)
+    * `:warmup` - if the code should be warmed up before profiling (default: `true`)
+    * `:set_on_spawn` - if newly spawned processes should be measured (default: `true`)
+
+  """
+  @spec profile((-> result), profile_opts()) :: result when result: any()
+  def profile(fun, opts \\ []) when is_function(fun, 0) do
+    Mix.ensure_application!(:tools)
+    {return_value, results} = profile_and_analyse(fun, opts)
+    print_output(results)
+    return_value
+  end
+
+  defp profile_and_analyse(fun, opts) do
+    if Keyword.get(opts, :warmup, true) do
+      IO.puts("Warmup...\n")
+      fun.()
+    end
+
+    :eprof.start()
+    matching = Keyword.get(opts, :matching, {:_, :_, :_})
+    set_on_spawn = Keyword.get(opts, :set_on_spawn, true)
+    {:ok, return_value} = :eprof.profile([], fun, matching, set_on_spawn: set_on_spawn)
+
+    results =
+      Enum.map(:eprof.dump(), fn {pid, call_results} ->
+        parsed_calls =
+          call_results
+          |> filter_results(opts)
+          |> sort_results(opts)
+          |> add_totals()
+
+        {pid, parsed_calls}
+      end)
+
+    :eprof.stop()
+
+    {return_value, results}
+  end
+
+  defp filter_results(call_results, opts) do
+    calls_opt = Keyword.get(opts, :calls, 0)
+    time_opt = Keyword.get(opts, :time, 0)
+
+    Enum.filter(call_results, fn {_mfa, {count, time}} ->
+      count >= calls_opt and time >= time_opt
+    end)
+  end
+
+  defp sort_results(call_results, opts) do
+    Enum.sort_by(call_results, sort_function(Keyword.get(opts, :sort, :time)))
+  end
+
+  defp sort_function(:time), do: fn {_mfa, {_count, time}} -> time end
+  defp sort_function(:calls), do: fn {_mfa, {count, _time}} -> count end
+
+  defp add_totals(call_results) do
+    {function_count, call_count, total_time} =
+      Enum.reduce(call_results, {0, 0, 0}, fn {_, {count, time}}, acc ->
+        {function_count, call_count, total_time} = acc
+        {function_count + 1, call_count + count, total_time + time}
+      end)
+
+    {function_count, call_results, call_count, total_time}
+  end
+
+  @header ["#", "CALLS", "%", "TIME", "µS/CALL"]
+
+  defp print_output([]) do
+    print_function_count(0)
+  end
+
+  defp print_output(results) do
+    Enum.each(results, &print_result/1)
+  end
+
+  defp print_result({pid, {function_count, call_results, call_count, total_time}}) do
+    formatted_rows = Enum.map(call_results, &format_row(&1, total_time))
+    formatted_total = format_total(total_time, call_count)
+
+    column_lengths = column_lengths(@header, formatted_rows)
+
+    IO.puts("")
+
+    print_pid_row(pid)
+    print_row(@header, column_lengths)
+    print_row(formatted_total, column_lengths)
+    Enum.each(formatted_rows, &print_row(&1, column_lengths))
+
+    IO.puts("")
+
+    print_function_count(function_count)
+  end
+
+  defp print_pid_row(pid) do
+    IO.puts("Profile results of #{inspect(pid)}")
+  end
+
+  defp format_row({{module, function, arity}, {count, time}}, total_time) do
+    mfa = Exception.format_mfa(module, function, arity)
+    time_percentage = :erlang.float_to_binary(100 * divide(time, total_time), [{:decimals, 2}])
+    time_per_call = :erlang.float_to_binary(divide(time, count), [{:decimals, 2}])
+    count = Integer.to_string(count)
+    time = Integer.to_string(time)
+
+    [mfa, count, time_percentage, time, time_per_call]
+  end
+
+  defp format_total(total_time, total_count) do
+    time_per_call = :erlang.float_to_binary(divide(total_time, total_count), [{:decimals, 2}])
+
+    [
+      "Total",
+      Integer.to_string(total_count),
+      "100.00",
+      Integer.to_string(total_time),
+      time_per_call
+    ]
+  end
+
+  defp divide(_, 0), do: 0.0
+  defp divide(t, n), do: t / n
+
+  defp column_lengths(header, rows) do
+    max_lengths = Enum.map(header, &String.length/1)
+
+    Enum.reduce(rows, max_lengths, fn row, max_lengths ->
+      Enum.zip_with(row, max_lengths, fn cell, length -> String.length(cell) |> max(length) end)
+    end)
+  end
+
+  @format "~-*s ~*s ~*s ~*s ~*s~n"
+
+  defp print_row(row, column_lengths) do
+    to_print =
+      column_lengths
+      |> Stream.zip(Stream.map(row, &String.to_charlist/1))
+      |> Enum.flat_map(&Tuple.to_list/1)
+
+    :io.format(@format, to_print)
+  end
+
+  defp print_function_count(count) do
+    IO.puts("Profile done over #{count} matching functions")
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/profile.fprof.ex b/lib/mix/lib/mix/tasks/profile.fprof.ex
new file mode 100644
index 00000000000..85fb5e3611d
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/profile.fprof.ex
@@ -0,0 +1,340 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Profile.Fprof do
+  use Mix.Task
+
+  @shortdoc "Profiles the given file or expression with fprof"
+
+  @moduledoc """
+  Profiles the given file or expression using Erlang's `fprof` tool.
+
+  [`:fprof`](`:fprof`) can be useful when you want to discover the bottlenecks of a
+  sequential code.
+
+  Before running the code, it invokes the `app.start` task which compiles
+  and loads your project. After that, the target expression is profiled, together
+  with all processes which are spawned by it. Other processes (for example, those
+  residing in the OTP application supervision tree) are not profiled.
+
+  To profile the code, you can use syntax similar to the `mix run` task:
+
+      $ mix profile.fprof -e Hello.world
+      $ mix profile.fprof my_script.exs arg1 arg2 arg3
+
+  This task is automatically re-enabled, so you can profile multiple times
+  in the same Mix invocation.
+
+  ## Command line options
+
+    * `--callers` - prints detailed information about immediate callers and called functions
+    * `--details` - includes profile data for each profiled process
+    * `--sort key` - sorts the output by given key: `acc` (default) or `own`
+    * `--trace-to-file` - uses a file to trace. Can improve performance and memory
+      usage for larger workloads
+    * `--eval`, `-e` - evaluates the given code
+    * `--require`, `-r` - requires pattern before running the command
+    * `--parallel`, `-p` - makes all requires parallel
+    * `--no-compile`    - does not compile even if files require compilation
+    * `--no-deps-check` - does not check dependencies
+    * `--no-archives-check` - does not check archives
+    * `--no-start` - does not start applications after compilation
+    * `--no-elixir-version-check` - does not check the Elixir version from mix.exs
+    * `--no-warmup` - does not execute code once before profiling
+
+  ## Profile output
+
+  Example output:
+      #                                        CNT    ACC (ms)    OWN (ms)
+      Total                                 200279    1972.188    1964.579
+      :fprof.apply_start_stop/4                  0    1972.188       0.012
+      anonymous fn/0 in :elixir_compiler_2       1    1972.167       0.001
+      Test.run/0                                 1    1972.166       0.007
+      Test.do_something/1                        3    1972.131       0.040
+      Test.bottleneck/0                          1    1599.490       0.007
+      ...
+
+  The default output contains data gathered from all profiled processes.
+  All times are wall clock milliseconds. The columns have the following meaning:
+
+    * CNT - total number of invocations of the given function
+    * ACC - total time spent in the function
+    * OWN - time spent in the function, excluding the time of called functions
+
+  The first row (Total) is the sum of all functions executed in all profiled
+  processes. For the given output, we had a total of 200 279 function calls and spent
+  about 2 seconds running the code.
+
+  More detailed information is returned if you provide the `--callers` and
+  `--details` options.
+
+  When `--callers` option is specified, you'll see expanded function entries:
+
+      Mod.caller1/0                             3     200.000       0.017
+      Mod.caller2/0                             2     100.000       0.017
+        Mod.some_function/0                     5     300.000       0.017  <--
+          Mod.called1/0                         4     250.000       0.010
+          Mod.called2/0                         1      50.000       0.030
+
+  Here, the arrow (`<--`) indicates the __marked__ function - the function
+  described by this paragraph. You also see its immediate callers (above) and
+  called functions (below).
+
+  All the values of caller functions describe the marked function. For example,
+  the first row means that `Mod.caller1/0` invoked `Mod.some_function/0` 3 times.
+  200ms of the total time spent in `Mod.some_function/0` was spent processing
+  calls from this particular caller.
+
+  In contrast, the values for the called functions describe those functions, but
+  in the context of the marked function. For example, the last row means that
+  `Mod.called2/0` was called once by `Mod.some_function/0`, and in that case
+  the total time spent in the function was 50ms.
+
+  For a detailed explanation it's worth reading the analysis in
+  [Erlang/OTP documentation for fprof](https://www.erlang.org/doc/man/fprof.html#analysis).
+
+  ## Caveats
+
+  You should be aware that the code being profiled is running in an anonymous
+  function which is invoked by [`:fprof` module](`:fprof`).
+  Thus, you'll see some additional entries in your profile output,
+  such as `:fprof` calls, an anonymous
+  function with high ACC time, or an `:undefined` function which represents
+  the outer caller (non-profiled code which started the profiler).
+
+  Also, keep in mind that profiling might significantly increase the running time
+  of the profiled processes. This might skew your results if, for example, those
+  processes perform some I/O operations, since running time of those operations
+  will remain unchanged, while CPU bound operations of the profiled processes
+  might take significantly longer. Thus, when profiling some intensive program,
+  try to reduce such dependencies, or be aware of the resulting bias.
+
+  Finally, it's advised to profile your program with the `prod` environment, since
+  this should provide more realistic insights into bottlenecks.
+  """
+
+  @typedoc """
+  Options for the fprof profiler.
+  """
+  @type profile_opts :: [
+          callers: boolean(),
+          details: boolean(),
+          sort: :acc | :own,
+          trace_to_file: boolean()
+        ]
+
+  @switches [
+    parallel: :boolean,
+    require: :keep,
+    trace_to_file: :boolean,
+    eval: :keep,
+    config: :keep,
+    compile: :boolean,
+    deps_check: :boolean,
+    start: :boolean,
+    archives_check: :boolean,
+    details: :boolean,
+    callers: :boolean,
+    sort: :string,
+    elixir_version_check: :boolean,
+    warmup: :boolean,
+    parallel_require: :keep
+  ]
+
+  @aliases [r: :require, p: :parallel, e: :eval, c: :config]
+
+  @impl true
+  def run(args) do
+    {opts, head} = OptionParser.parse_head!(args, aliases: @aliases, strict: @switches)
+    Mix.Task.reenable("profile.fprof")
+
+    Mix.Tasks.Run.run(
+      ["--no-mix-exs" | args],
+      opts,
+      head,
+      &profile_code(&1, opts),
+      &profile_code(File.read!(&1), opts)
+    )
+  end
+
+  # Profiling functions
+
+  defp profile_code(code_string, opts) do
+    content =
+      quote do
+        unquote(__MODULE__).profile(
+          fn ->
+            unquote(Code.string_to_quoted!(code_string))
+          end,
+          unquote(Macro.escape(Enum.map(opts, &parse_opt/1)))
+        )
+      end
+
+    # Use compile_quoted since it leaves less noise than eval_quoted
+    Code.compile_quoted(content)
+  end
+
+  defp parse_opt({:sort, "acc"}), do: {:sort, :acc}
+  defp parse_opt({:sort, "own"}), do: {:sort, :own}
+  defp parse_opt({:sort, other}), do: Mix.raise("Invalid sort option: #{other}")
+  defp parse_opt(other), do: other
+
+  @doc """
+  Allows to programmatically run the `fprof` profiler on expression in `fun`.
+
+  Returns the return value of `fun`.
+
+  ## Options
+
+    * `:callers` - prints detailed information about immediate callers and called functions
+    * `:details` - includes profile data for each profiled process
+    * `:sort` - sorts the output by given key: `:acc` (default) or `:own`
+    * `:trace_to_file` - uses a file to trace. Can improve performance and memory
+      usage for larger workloads.
+
+  """
+  @spec profile((-> result), profile_opts()) :: result when result: any()
+  def profile(fun, opts \\ []) when is_function(fun, 0) do
+    Mix.ensure_application!(:runtime_tools)
+    Mix.ensure_application!(:tools)
+    {return_value, analysis_output} = profile_and_analyse(fun, opts)
+    print_output(analysis_output)
+    return_value
+  end
+
+  defp profile_and_analyse(fun, opts) do
+    if Keyword.get(opts, :warmup, true) do
+      IO.puts("Warmup...")
+      fun.()
+    end
+
+    {return_value, file_to_remove} =
+      if Keyword.get(opts, :trace_to_file, false) do
+        trace_file = Path.join(System.tmp_dir!(), "fprof_trace_#{System.os_time()}")
+
+        filename =
+          trace_file
+          |> Path.expand()
+          |> String.to_charlist()
+
+        result = :fprof.apply(fun, [], file: filename)
+        :fprof.profile(file: filename)
+        {result, trace_file}
+      else
+        {:ok, tracer} = :fprof.profile([:start])
+        {:fprof.apply(fun, [], tracer: tracer), nil}
+      end
+
+    {:ok, analyse_dest} = StringIO.open("")
+
+    try do
+      :fprof.analyse(
+        dest: analyse_dest,
+        totals: true,
+        details: Keyword.get(opts, :details, false),
+        callers: Keyword.get(opts, :callers, false),
+        sort: Keyword.get(opts, :sort, :acc)
+      )
+    else
+      :ok ->
+        {_in, analysis_output} = StringIO.contents(analyse_dest)
+        {return_value, String.to_charlist(analysis_output)}
+    after
+      StringIO.close(analyse_dest)
+      if file_to_remove, do: File.rm(file_to_remove)
+    end
+  end
+
+  defp print_output(analysis_output) do
+    {_analysis_options, analysis_output} = next_term(analysis_output)
+    {total_row, analysis_output} = next_term(analysis_output)
+    print_total_row(total_row)
+
+    Stream.unfold(analysis_output, &next_term/1)
+    |> Enum.each(&print_analysis_result/1)
+  end
+
+  defp next_term(charlist) do
+    case :erl_scan.tokens([], charlist, 1) do
+      {:done, result, leftover} ->
+        case result do
+          {:ok, tokens, _} ->
+            {:ok, term} = :erl_parse.parse_term(tokens)
+            {term, leftover}
+
+          {:eof, _} ->
+            nil
+        end
+
+      _ ->
+        nil
+    end
+  end
+
+  defp print_total_row([{:totals, count, acc, own}]) do
+    IO.puts("")
+    print_row(["s", "s", "s", "s", "s"], ["", "CNT", "ACC (ms)", "OWN (ms)", ""])
+    print_row(["s", "B", ".3f", ".3f", "s"], ["Total", count, acc, own, ""])
+  end
+
+  # Represents the "PID" entry
+  defp print_analysis_result([{pid_atom, count, :undefined, own} | info]) do
+    print_process(pid_atom, count, own)
+
+    if spawned_by = info[:spawned_by] do
+      IO.puts("  spawned by #{spawned_by}")
+    end
+
+    if spawned_as = info[:spawned_as] do
+      IO.puts("  as #{function_text(spawned_as)}")
+    end
+
+    if initial_calls = info[:initial_calls] do
+      IO.puts("  initial calls:")
+      Enum.each(initial_calls, &IO.puts("    #{function_text(&1)}"))
+    end
+
+    IO.puts("")
+  end
+
+  # The function entry, when --callers option is provided
+  defp print_analysis_result({callers, function, subcalls}) do
+    IO.puts("")
+    Enum.each(callers, &print_function/1)
+    print_function(function, "  ", "<--")
+    Enum.each(subcalls, &print_function(&1, "    "))
+  end
+
+  # The function entry in the total section, and when --callers option is not
+  # provided
+  defp print_analysis_result({_fun, _count, _acc, _own} = function) do
+    print_function(function, "", "")
+  end
+
+  defp print_process(pid_atom, count, own) do
+    IO.puts([?\n, String.duplicate("-", 100)])
+    print_row(["s", "B", "s", ".3f", "s"], ["#{pid_atom}", count, "", own, ""])
+  end
+
+  defp print_function({fun, count, acc, own}, prefix \\ "", suffix \\ "") do
+    text = "#{prefix}#{function_text(fun)}"
+    print_row(["s", "B", ".3f", ".3f", "s"], [text, count, acc, own, suffix])
+  end
+
+  defp function_text({module, function, arity}) do
+    Exception.format_mfa(module, function, arity)
+  end
+
+  defp function_text(other), do: inspect(other)
+
+  @columns [-60, 10, 12, 12, 5]
+  defp print_row(formats, data) do
+    Stream.zip(@columns, formats)
+    |> Stream.map(fn {width, format} -> "~#{width}#{format}" end)
+    |> Enum.join()
+    |> :io.format(data)
+
+    IO.puts("")
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/profile.tprof.ex b/lib/mix/lib/mix/tasks/profile.tprof.ex
new file mode 100644
index 00000000000..1a266621589
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/profile.tprof.ex
@@ -0,0 +1,479 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+defmodule Mix.Tasks.Profile.Tprof do
+  use Mix.Task
+
+  @shortdoc "Profiles the given file or expression with tprof"
+
+  @moduledoc """
+  Profiles the given file or expression using Erlang's `tprof` tool.
+
+  Requires Erlang/OTP27 or above.
+
+  [`:tprof`](`:tprof`) is an experimental module introduced in Erlang/OTP 27 which
+  provides a unified API for measuring call count, time, and allocation, and aims to
+  replace [`:eprof`](`:eprof`) and [`:cprof`](`:cprof`).
+  It can be useful when you want to discover the bottlenecks related to any of these
+  measurements.
+
+  Before running the code, it invokes the `app.start` task which compiles
+  and loads your project. After that, the target expression is profiled together
+  with all matching function calls using the Erlang trace BIFs. The tracing of
+  the function calls for that is enabled when the profiling is begun, and
+  disabled when profiling is stopped.
+
+  To profile the code, you can use syntax similar to the `mix run` task:
+
+      $ mix profile.tprof -e Hello.world
+      $ mix profile.tprof -e "[1, 2, 3] |> Enum.reverse |> Enum.map(&Integer.to_string/1)"
+      $ mix profile.tprof my_script.exs arg1 arg2 arg3
+
+  By default, tprof uses the `time` type, but you can profile memory too:
+
+      $ mix profile.tprof -e "Enum.map([1, 2, 3], &Integer.to_string/1)" --type memory
+
+  Call count is present with both type `time` and `memory`, but if you only need
+  the call count information, you can use the type `calls` which has the lowest footprint:
+
+      $ mix profile.tprof -e "Enum.map([1, 2, 3], &Integer.to_string/1)" --type calls
+
+  This task is automatically re-enabled, so you can profile multiple times
+  in the same Mix invocation.
+
+  ## Command line options
+
+    * `--matching` - only profile calls matching the given `Module.function/arity` pattern
+    * `--type` - the type of profiling, `calls`, `time` or `memory` (default: `time`)
+    * `--calls` - filters out any results with a call count lower than this
+    * `--time` - filters out any results that took lower than specified (in µs), the `type` needs to be `time`
+    * `--memory` - filters out any results that used less memory than specified (in words), the `type` needs to be `memory`
+    * `--sort` - sorts the results by `calls`, `per_call` or by the value of `type` (default: the value of `type`)
+    * `--report` - returns the per-process breakdown when `process`, or the total for all processes when `total` (default: `process`).
+      Always `total` when `type` is `calls`.
+    * `--eval`, `-e` - evaluates the given code
+    * `--require`, `-r` - requires pattern before running the command
+    * `--parallel`, `-p` - makes all requires parallel
+    * `--no-warmup` - skips the warmup step before profiling
+    * `--no-compile` - does not compile even if files require compilation
+    * `--no-deps-check` - does not check dependencies
+    * `--no-archives-check` - does not check archives
+    * `--no-halt` - does not halt the system after running the command
+    * `--no-set-on-spawn` - does not profile spawned processes
+    * `--no-start` - does not start applications after compilation
+    * `--no-elixir-version-check` - does not check the Elixir version from mix.exs
+
+  ## Profile output
+
+  Example output (`time` type):
+
+      Profile results of #PID<0.107.0>
+      #                                               CALLS      % TIME µS/CALL
+      Total                                              20 100.00    2    0.10
+      String.Chars.Integer.to_string/1                    5   0.00    0    0.00
+      anonymous fn/0 in :elixir_compiler_1.__FILE__/1     1   0.00    0    0.00
+      Enum.each/2                                         1   0.00    0    0.00
+      Enum.reduce_range/5                                 3   0.00    0    0.00
+      :erlang.integer_to_binary/1                         5  50.00    1    0.20
+      anonymous fn/3 in Enum.each/2                       5  50.00    1    0.20
+
+      Profile done over 6 matching functions
+
+  Example output (`memory` type):
+
+      Profile results of #PID<0.107.0>
+      #                           CALLS      % WORDS PER CALL
+      Total                           6 100.00    19     3.17
+      Enum.each/2                     1  21.05     4     4.00
+      :erlang.integer_to_binary/1     5  78.95    15     3.00
+
+      Profile done over 2 matching functions
+
+  Example output (`calls` type)
+
+      Profile results over all processes
+      #                                               CALLS      %
+      Total                                              20 100.00
+      anonymous fn/0 in :elixir_compiler_1.__FILE__/1     1   5.00
+      Enum.each/2                                         1   5.00
+      Enum.reduce_range/5                                 3  15.00
+      :erlang.integer_to_binary/1                         5  25.00
+      String.Chars.Integer.to_string/1                    5  25.00
+      anonymous fn/3 in Enum.each/2                       5  25.00
+
+      Profile done over 6 matching functions
+
+  The default output contains data gathered from all matching functions. The first
+  row after the header contains the sums of the partial results and the average time
+  or memory usage for all the function calls listed.
+  The following rows contain the function call, followed by the number of times that
+  the function was called, then by the percentage of time/memory that the call uses,
+  then the total time/memory for that function in microseconds/words, and, finally,
+  the average time/memory per call in microseconds/words.
+
+  When `--matching` option is specified, call count tracing will be started only for
+  the functions matching the given pattern:
+
+      Profile results of #PID<0.106.0>
+      #                                CALLS      % TIME µS/CALL
+      Total                                5 100.00    1    0.20
+      String.Chars.Integer.to_string/1     5 100.00    1    0.20
+
+      Profile done over 1 matching functions
+
+  The pattern can be a module name, such as `String` to count all calls to that module,
+  a call without arity, such as `String.split`, to count all calls to that function
+  regardless of arity, or a call with arity, such as `String.split/3`, to count all
+  calls to that exact module, function and arity.
+
+  ## Caveats
+
+  You should be aware that the code being profiled is running in an anonymous
+  function which is invoked by [`:tprof` module](`:tprof`).
+  Thus, you'll see some additional entries in your profile output. It is also
+  important to note that the profiler is stopped as soon as the code has finished running,
+  and this may need special attention, when: running asynchronous code as function calls which were
+  called before the profiler stopped will not be counted; running synchronous code as long
+  running computations and a profiler without a proper MFA trace pattern or filter may
+  lead to a result set which is difficult to comprehend.
+
+  You should expect a slowdown in your code execution using this tool since `:tprof` has
+  some performance impact on the execution, but the impact is considerably lower than
+  `Mix.Tasks.Profile.Fprof`. If you have a large system try to profile a limited
+  scenario or focus on the main modules or processes. The `calls` type can also be used,
+  which is more limited but has a lower footprint.
+  """
+
+  @typedoc """
+  Options for the tprof profiler.
+  """
+  @type profile_opts :: [
+          matching: {module() | :_, atom() | :_, arity() | :_},
+          type: :time | :memory | :calls,
+          calls: non_neg_integer(),
+          time: non_neg_integer(),
+          memory: non_neg_integer(),
+          sort: :calls | :per_call | :time | :memory,
+          report: :process | :total,
+          warmup: boolean(),
+          set_on_spawn: boolean()
+        ]
+
+  @switches [
+    parallel: :boolean,
+    require: :keep,
+    eval: :keep,
+    config: :keep,
+    matching: :string,
+    halt: :boolean,
+    compile: :boolean,
+    deps_check: :boolean,
+    type: :string,
+    calls: :integer,
+    time: :integer,
+    memory: :integer,
+    sort: :string,
+    report: :string,
+    start: :boolean,
+    archives_check: :boolean,
+    warmup: :boolean,
+    elixir_version_check: :boolean,
+    parallel_require: :keep,
+    set_on_spawn: :boolean
+  ]
+
+  @aliases [
+    r: :require,
+    p: :parallel,
+    e: :eval,
+    c: :config
+  ]
+
+  @impl true
+  def run(args) do
+    {opts, head} = parse!(args)
+    Mix.Task.reenable("profile.tprof")
+
+    Mix.Tasks.Run.run(
+      ["--no-mix-exs" | args],
+      opts,
+      head,
+      &profile_code(&1, opts),
+      &profile_code(File.read!(&1), opts)
+    )
+  end
+
+  @doc false
+  def parse!(args) do
+    {opts, args} = OptionParser.parse!(args, aliases: @aliases, strict: @switches)
+    {Enum.map(opts, &parse_opt/1), args}
+  end
+
+  defp profile_code(code_string, opts) do
+    content =
+      quote do
+        unquote(__MODULE__).profile(
+          fn ->
+            unquote(Code.string_to_quoted!(code_string))
+          end,
+          unquote(Macro.escape(opts))
+        )
+      end
+
+    # Use compile_quoted since it leaves less noise than eval_quoted
+    Code.compile_quoted(content)
+  end
+
+  defp parse_opt({:matching, matching}) do
+    case Mix.Utils.parse_mfa(matching) do
+      {:ok, [m, f, a]} -> {:matching, {m, f, a}}
+      {:ok, [m, f]} -> {:matching, {m, f, :_}}
+      {:ok, [m]} -> {:matching, {m, :_, :_}}
+      :error -> Mix.raise("Invalid matching pattern: #{matching}")
+    end
+  end
+
+  defp parse_opt({:type, "time"}), do: {:type, :time}
+  defp parse_opt({:type, "calls"}), do: {:type, :calls}
+  defp parse_opt({:type, "memory"}), do: {:type, :memory}
+  defp parse_opt({:type, other}), do: Mix.raise("Invalid type option: #{other}")
+
+  defp parse_opt({:report, "process"}), do: {:report, :process}
+  defp parse_opt({:report, "total"}), do: {:report, :total}
+  defp parse_opt({:report, other}), do: Mix.raise("Invalid report option: #{other}")
+
+  defp parse_opt({:sort, "time"}), do: {:sort, :time}
+  defp parse_opt({:sort, "calls"}), do: {:sort, :calls}
+  defp parse_opt({:sort, "memory"}), do: {:sort, :memory}
+  defp parse_opt({:sort, "per_call"}), do: {:sort, :per_call}
+  defp parse_opt({:sort, other}), do: Mix.raise("Invalid sort option: #{other}")
+  defp parse_opt(other), do: other
+
+  @doc """
+  Allows to programmatically run the `tprof` profiler on expression in `fun`.
+
+  Returns the return value of `fun`.
+
+  ## Options
+
+    * `:matching` - only profile calls matching the given pattern in form of
+      `{module, function, arity}`, where each element may be replaced by `:_`
+      to allow any value
+    * `:type` - the type of profiling, possible values are `:time`, `:memory` or `:calls`,
+      (default: `:time`), see [moduledoc](`Mix.Tasks.Profile.Tprof`) for more information
+
+    * `:calls` - filters out any results with a call count lower than this
+    * `:time` - filters out any results that took lower than specified (in µs),
+      `type` needs to be `:time`
+    * `:memory` - filters out any results that used less memory than specified (in words),
+      `type` needs to be `:memory`
+    * `:sort` - sort the results by `:calls`, `:per_call` or by the value of `type`
+      (default: the value of `type`)
+    * `:report` - returns the per-process breakdown when `:process`, or the total for all
+      processes when `:total` (default: `:process`). Always `:total` when `type` is `:calls`.
+    * `:warmup` - if the code should be warmed up before profiling (default: `true`)
+    * `:set_on_spawn` - if newly spawned processes should be measured (default: `true`)
+
+  """
+  @spec profile((-> result), profile_opts()) :: result when result: any()
+  def profile(fun, opts \\ []) when is_function(fun, 0) do
+    Mix.ensure_application!(:tools)
+    {type, return_value, results} = profile_and_analyse(fun, opts)
+    print_output(type, results)
+    return_value
+  end
+
+  defp profile_and_analyse(fun, opts) do
+    if Keyword.get(opts, :warmup, true) do
+      IO.puts("Warmup...\n")
+      fun.()
+    end
+
+    matching = Keyword.get(opts, :matching, {:_, :_, :_})
+    set_on_spawn = Keyword.get(opts, :set_on_spawn, true)
+    type = Keyword.get(opts, :type, :time)
+    report = Keyword.get(opts, :report, :process)
+
+    sort_by =
+      case Keyword.get(opts, :sort) do
+        nil ->
+          :measurement
+
+        :calls ->
+          :calls
+
+        :per_call ->
+          :measurement_per_call
+
+        ^type ->
+          :measurement
+
+        other ->
+          Mix.raise("Incompatible sort option #{inspect(other)} with type #{inspect(type)}")
+      end
+
+    tprof_type = to_tprof_type(type)
+
+    {return_value, {^tprof_type, traces}} =
+      tprof_module().profile(fun, %{
+        set_on_spawn: set_on_spawn,
+        pattern: matching,
+        type: tprof_type,
+        report: :return
+      })
+
+    inspected = tprof_module().inspect({tprof_type, traces}, report, sort_by)
+
+    results =
+      inspected
+      |> Enum.map(fn {pid, {^tprof_type, measurement_total, call_results}} ->
+        parsed_calls =
+          call_results
+          |> filter_results(type, opts)
+          |> add_totals(measurement_total)
+
+        {pid, parsed_calls}
+      end)
+
+    {type, return_value, results}
+  end
+
+  defp to_tprof_type(:calls), do: :call_count
+  defp to_tprof_type(:time), do: :call_time
+  defp to_tprof_type(:memory), do: :call_memory
+
+  defp filter_results(call_results, type, opts) do
+    calls_opt = Keyword.get(opts, :calls, 0)
+
+    measurement_opt =
+      get_filter_value!(type, Keyword.get(opts, :time), Keyword.get(opts, :memory))
+
+    Enum.filter(call_results, fn {_module, _fa, count, measurement, _, _} ->
+      count >= calls_opt and measurement >= measurement_opt
+    end)
+  end
+
+  defp get_filter_value!(type, time, _memory) when is_integer(time) and type != :time do
+    Mix.raise("Incompatible use of time option with type #{inspect(type)}")
+  end
+
+  defp get_filter_value!(type, _time, memory) when is_integer(memory) and type != :memory do
+    Mix.raise("Incompatible use of memory option with type #{inspect(type)}")
+  end
+
+  defp get_filter_value!(:time, time, nil) when is_integer(time), do: time
+  defp get_filter_value!(:memory, nil, memory) when is_integer(memory), do: memory
+
+  defp get_filter_value!(_, nil, nil), do: 0
+
+  defp add_totals(call_results, measurement_total) do
+    {function_count, calls} =
+      Enum.reduce(call_results, {0, 0}, fn {_mod, _fa, count, _, _, _}, acc ->
+        {function_count, calls} = acc
+        {function_count + 1, calls + count}
+      end)
+
+    {function_count, call_results, calls, measurement_total}
+  end
+
+  defp print_output(_type, []) do
+    print_function_count(0)
+  end
+
+  defp print_output(type, results) do
+    Enum.each(results, &print_result(type, &1))
+  end
+
+  defp print_result(type, {pid, {function_count, call_results, calls, total_measurement}}) do
+    header = header(type)
+
+    formatted_rows = Enum.map(call_results, &format_row/1)
+    formatted_total = format_total(total_measurement, calls)
+
+    column_lengths = column_lengths(header, [formatted_total | formatted_rows])
+
+    IO.puts("")
+
+    print_pid_row(pid)
+    print_row(header, column_lengths, type)
+    print_row(formatted_total, column_lengths, type)
+    Enum.each(formatted_rows, &print_row(&1, column_lengths, type))
+
+    IO.puts("")
+
+    print_function_count(function_count)
+  end
+
+  defp header(:calls), do: ["#", "CALLS", "%"]
+  defp header(:time), do: ["#", "CALLS", "%", "TIME", "µS/CALL"]
+  defp header(:memory), do: ["#", "CALLS", "%", "WORDS", "PER CALL"]
+
+  defp print_pid_row(:all) do
+    IO.puts("Profile results over all processes")
+  end
+
+  defp print_pid_row(pid) when is_pid(pid) do
+    IO.puts("Profile results of #{inspect(pid)}")
+  end
+
+  defp format_row({module, {function, arity}, count, measurement, per_call, percentage}) do
+    mfa = Exception.format_mfa(module, function, arity)
+    percentage = :erlang.float_to_binary(percentage, [{:decimals, 2}])
+    per_call = :erlang.float_to_binary(per_call, [{:decimals, 2}])
+    count = Integer.to_string(count)
+    measurement = Integer.to_string(measurement)
+
+    [mfa, count, percentage, measurement, per_call]
+  end
+
+  defp format_total(total_measurement, total_count) do
+    per_call = :erlang.float_to_binary(divide(total_measurement, total_count), [{:decimals, 2}])
+
+    [
+      "Total",
+      Integer.to_string(total_count),
+      "100.00",
+      Integer.to_string(total_measurement),
+      per_call
+    ]
+  end
+
+  defp divide(_, 0), do: 0.0
+  defp divide(t, n), do: t / n
+
+  defp column_lengths(header, rows) do
+    max_lengths = Enum.map(header, &String.length/1)
+
+    Enum.reduce(rows, max_lengths, fn row, max_lengths ->
+      Enum.zip_with(row, max_lengths, fn cell, length -> String.length(cell) |> max(length) end)
+    end)
+  end
+
+  @call_format "~-*s ~*s ~*s~n"
+  @measurement_format "~-*s ~*s ~*s ~*s ~*s~n"
+
+  defp print_row(row, column_lengths, type) do
+    to_print =
+      column_lengths
+      |> Stream.zip(Stream.map(row, &String.to_charlist/1))
+      |> Enum.flat_map(&Tuple.to_list/1)
+
+    case type do
+      :calls -> :io.format(@call_format, to_print)
+      _ -> :io.format(@measurement_format, to_print)
+    end
+  end
+
+  defp print_function_count(count) do
+    IO.puts("Profile done over #{count} matching functions")
+  end
+
+  # TODO remove once we require Erlang/OTP 27+
+  defp tprof_module do
+    if Code.ensure_loaded?(:tprof) do
+      :tprof
+    else
+      Mix.raise("mix profile.tprof requires Erlang/OTP 27 or above")
+    end
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/release.ex b/lib/mix/lib/mix/tasks/release.ex
new file mode 100644
index 00000000000..b9cc0caa4bf
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/release.ex
@@ -0,0 +1,1510 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Release do
+  use Mix.Task
+
+  @shortdoc "Assembles a self-contained release"
+
+  @moduledoc """
+  Assembles a self-contained release for the current project:
+
+      $ MIX_ENV=prod mix release
+      $ MIX_ENV=prod mix release NAME
+
+  Once a release is assembled, it can be packaged and deployed to a
+  target, as long as the target runs on the same operating system (OS)
+  distribution and version as the machine running the `mix release`
+  command. Windows releases also require Microsoft Visual C++ Runtime.
+
+  A release can be configured in your `mix.exs` file under the `:releases`
+  key inside `def project`:
+
+      def project do
+        [
+          releases: [
+            demo: [
+              include_executables_for: [:unix],
+              applications: [runtime_tools: :permanent]
+            ],
+
+            ...
+          ]
+        ]
+      end
+
+  You can specify multiple releases where the key is the release name
+  and the value is a keyword list with the release configuration.
+  Releasing a certain name is done with:
+
+      $ MIX_ENV=prod mix release demo
+
+  If the given name does not exist, an error is raised.
+
+  If `mix release` is invoked, without specifying a release name, and
+  there are multiple releases configured, an error will be raised
+  unless you set `default_release: NAME` at the root of your project
+  configuration.
+
+  If `mix release` is invoked and there are no releases configured, a
+  release is assembled using the application name and default values.
+
+  ## Why releases?
+
+  Releases allow developers to precompile and package all of their code
+  and the runtime into a single unit. The benefits of releases are:
+
+    * Code preloading. The VM has two mechanisms for loading code:
+      interactive and embedded. By default, it runs in the interactive
+      mode which dynamically loads modules when they are used for the
+      first time. The first time your application calls `Enum.map/2`,
+      the VM will find the `Enum` module and load it. There's a downside:
+      when you start a new server in production, it may need to load
+      many other modules, causing the first requests to have an unusual
+      spike in response time. With releases, the system preloads
+      all modules and guarantees your system is ready to handle requests
+      after booting.
+
+    * Configuration and customization. Releases give developers fine
+      grained control over system configuration and the VM flags used
+      to start the system.
+
+    * Self-contained. A release does not require the source code to be
+      included in your production artifacts. All of the code is precompiled
+      and packaged. Releases do not even require Erlang or Elixir in your
+      servers, as it includes the Erlang VM and its runtime by default.
+      Furthermore, both Erlang and Elixir standard libraries are stripped
+      to bring only the parts you are actually using.
+
+    * Multiple releases. You can assemble different releases with
+      different configuration per application or even with different
+      applications altogether.
+
+    * Management scripts. Releases come with scripts to start, restart,
+      connect to the running system remotely, execute RPC calls, run as
+      daemon, run as a Windows service, and more.
+
+  ## Running the release
+
+  Once a release is assembled, you can start it by calling
+  `bin/RELEASE_NAME start` inside the release. In production, you would do:
+
+      $ MIX_ENV=prod mix release
+      $ _build/prod/rel/my_app/bin/my_app start
+
+  `bin/my_app start` will start the system connected to the current standard
+  input/output, where logs are also written to by default. This is the
+  preferred way to run the system. Many tools, such as `systemd`, platforms
+  as a service, such as Heroku, and many containers platforms, such as Docker,
+  are capable of processing the standard input/output and redirecting
+  the log contents elsewhere. Those tools and platforms also take care
+  of restarting the system in case it crashes.
+
+  You can also execute one-off commands, run the release as a daemon on
+  Unix-like system, or install it as a service on Windows. We will take a
+  look at those next. You can also list all available commands by invoking
+  `bin/RELEASE_NAME`.
+
+  ### One-off commands (eval and rpc)
+
+  If you want to invoke specific modules and functions in your release,
+  you can do so in two ways: using `eval` or `rpc`.
+
+      $ bin/RELEASE_NAME eval "IO.puts(:hello)"
+      $ bin/RELEASE_NAME rpc "IO.puts(:hello)"
+
+  The `eval` command starts its own instance of the VM but without
+  starting any of the applications in the release and without starting
+  distribution. For example, if you need to do some prep work before
+  running the actual system, like migrating your database, `eval` can
+  be a good fit. Just keep in mind any application you may use during
+  eval has to be explicitly started.
+
+  You can start an application by calling `Application.ensure_all_started/1`.
+  From Elixir v1.16, it is guaranteed the applications have been
+  at least loaded. In earlier versions, if you needed to load applications
+  but not start them, you also needed to call `Application.load/1`.
+
+  Another way to run commands is with `rpc`, which will connect to the
+  system currently running and instruct it to execute the given
+  expression. This means you need to guarantee the system was already
+  started and be careful with the instructions you are executing.
+  You can also use `remote` to connect a remote IEx session to the
+  system.
+
+  #### Helper module
+
+  As you operate your system, you may find yourself running some piece of code
+  as a one-off command quite often. You may consider creating a module to group
+  these tasks:
+
+      # lib/my_app/release_tasks.ex
+      defmodule MyApp.ReleaseTasks do
+        def eval_purge_stale_data() do
+          # Eval commands needs to start the app before
+          # Or Application.load(:my_app) if you can't start it
+          Application.ensure_all_started(:my_app)
+
+          # Code that purges stale data
+          ...
+        end
+
+        def rpc_print_connected_users() do
+          # Code that print users connected to the current running system
+          ...
+        end
+      end
+
+  In the example above, we prefixed the function names with the command
+  name used to execute them, but that is entirely optional.
+
+  And to run them:
+
+      $ bin/RELEASE_NAME eval "MyApp.ReleaseTasks.eval_purge_stale_data()"
+      $ bin/RELEASE_NAME rpc "MyApp.ReleaseTasks.rpc_print_connected_users()"
+
+  ### Daemon mode (Unix-like)
+
+  You can run the release in daemon mode with the command:
+
+      $ bin/RELEASE_NAME daemon
+
+  In daemon mode, the system is started on the background via
+  [`run_erl`](https://www.erlang.org/doc/apps/erts/run_erl_cmd.html).
+  You may also want to enable [`:heart`](`:heart`)
+  in daemon mode so it automatically restarts the system in case
+  of crashes. See the generated `releases/RELEASE_VSN/env.sh` file.
+
+  The daemon will write all of its standard output to the `tmp/log/`
+  directory in the release root. You can watch the log file by doing
+  `tail -f tmp/log/erlang.log.1` or similar. Once files get too large,
+  the index suffix will be incremented. A developer can also attach
+  to the standard input of the daemon by invoking `to_erl tmp/pipe/`
+  from the release root. However, note that attaching to the system
+  should be done with extreme care, since the usual commands for
+  exiting an Elixir system, such as hitting Ctrl+C twice or Ctrl+\\,
+  will actually shut down the daemon. Therefore, using
+  `bin/RELEASE_NAME remote` should be preferred, even in daemon mode.
+
+  You can customize the tmp directory used both for logging and for
+  piping in daemon mode by setting the `RELEASE_TMP` environment
+  variable. See the "Customization" section.
+
+  ### Services mode (Windows)
+
+  While daemons are not available on Windows, it is possible to install a
+  released system as a service on Windows with the help of
+  [`erlsrv`](https://www.erlang.org/doc/apps/erts/erlsrv_cmd.html).
+  This can be done by running:
+
+      $ bin/RELEASE_NAME install
+
+  Once installed, the service must be explicitly managed via the `erlsrv`
+  executable, which is included in the `erts-VSN/bin` directory.
+  The service is not started automatically after installing.
+
+  For example, if you have a release named `demo`, you can install
+  the service and then start it from the release root as follows:
+
+      $ bin/demo install
+      $ erts-VSN/bin/erlsrv.exe start demo_demo
+
+  The name of the service is `demo_demo` because the name is built
+  by concatenating the node name with the release name. Since Elixir
+  automatically uses the same name for both, the service will be
+  referenced as `demo_demo`.
+
+  The `install` command must be executed as an administrator.
+
+  ### `bin/RELEASE_NAME` commands
+
+  The following commands are supported by `bin/RELEASE_NAME`:
+
+  ```text
+  start        Starts the system
+  start_iex    Starts the system with IEx attached
+  daemon       Starts the system as a daemon (Unix-like only)
+  daemon_iex   Starts the system as a daemon with IEx attached (Unix-like only)
+  install      Installs this system as a Windows service (Windows only)
+  eval "EXPR"  Executes the given expression on a new, non-booted system
+  rpc "EXPR"   Executes the given expression remotely on the running system
+  remote       Connects to the running system via a remote shell
+  restart      Restarts the running system via a remote command
+  stop         Stops the running system via a remote command
+  pid          Prints the operating system PID of the running system via a remote command
+  version      Prints the release name and version to be booted
+  ```
+
+  ## Deployments
+
+  ### Requirements
+
+  A release is built on a **host**, a machine which contains Erlang, Elixir,
+  and any other dependencies needed to compile your application. A release is
+  then deployed to a **target**, potentially the same machine as the host,
+  but usually separate, and often there are many targets (either multiple
+  instances, or the release is deployed to heterogeneous environments).
+
+  To deploy straight from a host to a separate target, the following must be
+  the same between the host and the target:
+
+    * Target architecture (for example, x86_64 or ARM)
+    * Target vendor + operating system (for example, Windows, Linux, or Darwin/macOS)
+    * Target ABI (for example, musl or gnu)
+
+  This is often represented in the form of target triples, for example,
+  `x86_64-unknown-linux-gnu`, `x86_64-unknown-linux-musl`, `x86_64-apple-darwin`.
+  If you are building on a MacBook (`x86_64-apple-darwin`) and trying to deploy
+  to a typical Ubuntu machine (`x86_64-unknown-linux-gnu`), the release will not
+  work. Instead you should build the release on a `x86_64-unknown-linux-gnu` host.
+
+  Typically, different versions of Erlang VM and Elixir are available for
+  different targets via package managers, precompiled artifacts, and similar.
+  However, to deploy from a host to a separate target, you must also guarantee
+  that any dependency with NIFs (Natively-Implemented Functions) are compiled
+  for the same triplet. As we will see, this can be done in different ways,
+  such as releasing on the target itself, or by using virtual machines or
+  containers, usually as part of your release pipeline.
+
+  In addition to matching the target triple, it is also important that the
+  target has all of the system packages that your application will need at
+  runtime. A common one is the need for OpenSSL when building an application
+  that uses `:crypto` or `:ssl`, which is dynamically linked to the Erlang VM.
+  Project dependencies containing NIFs (natively-implemented functions) may
+  also dynamically link to system libraries, so check those accordingly.
+
+  Of course, some operating systems and package managers can differ between
+  versions, so if your goal is to have full compatibility between host and
+  target, it is best to ensure the operating system and system package manager
+  have the same versions on host and target. This may even be a requirement in
+  some systems, especially so with package managers that try to create fully
+  reproducible environments (Nix, Guix).
+
+  ### Using matching host and target
+
+  There are a couple of ways to guarantee that a release is built on a host with
+  the same properties as the target. A simple option is to fetch the source,
+  compile the code and assemble the release on the target itself. It would
+  be something like this:
+
+      $ git clone remote://path/to/my_app.git my_app_source
+      $ cd my_app_source
+      $ mix deps.get --only prod
+      $ MIX_ENV=prod mix release
+      $ _build/prod/rel/my_app/bin/my_app start
+
+  If you prefer, you can also compile the release to a separate directory,
+  so you can erase all source after the release is assembled:
+
+      $ git clone remote://path/to/my_app.git my_app_source
+      $ cd my_app_source
+      $ mix deps.get --only prod
+      $ MIX_ENV=prod mix release --path ../my_app_release
+      $ cd ../my_app_release
+      $ rm -rf ../my_app_source
+      $ bin/my_app start
+
+  However, this option can be expensive if you have multiple production
+  nodes or if the release assembling process is a long one, as each node
+  needs to individually assemble the release.
+
+  You can automate this process in a couple different ways. One option
+  is to make it part of your Continuous Integration (CI) / Continuous
+  Deployment (CD) pipeline. When you have a CI/CD pipeline, it is common
+  that the machines in your CI/CD pipeline run on the exact same target
+  triple as your production servers (if they don't, they should).
+  In this case, you can assemble the release at the end of your CI/CD
+  pipeline by calling `MIX_ENV=prod mix release` and push the artifact
+  to S3 or any other network storage. To perform the deployment, your
+  production machines can fetch the deployment from the network storage
+  and run `bin/my_app start`.
+
+  ### Using images
+
+  Another mechanism to automate deployments is to use images, such as
+  Amazon Machine Images, or container platforms, such as Docker.
+  For instance, you can use Docker to run locally a system with the
+  exact same target triple as your production servers. Inside the
+  container, you can invoke `MIX_ENV=prod mix release` and build
+  a complete image and/or container with the operating system, all
+  dependencies as well as the releases.
+
+  However, when building such images on your machine, those technologies
+  use emulation which may not interplay well with Erlang VM's JIT
+  (just-in time) compiler. To address this, you can set this environment
+  variable on your build stage:
+
+      ENV ERL_AFLAGS "+JMsingle true"
+
+  ## Shutting down
+
+  Once a system is deployed, shutting down the system can be done by
+  sending SIGINT/SIGTERM to the system, which is what most containers,
+  platforms and tools do, or by explicitly invoking `bin/RELEASE_NAME stop`.
+  Once the system receives the shutdown request, each application and
+  their respective supervision trees will stop, one by one, in the
+  opposite order that they were started.
+
+  ## Customization
+
+  There are a couple ways in which developers can customize the generated
+  artifacts inside a release.
+
+  ### Options
+
+  The following options can be set inside your `mix.exs` on each release definition:
+
+    * `:applications` - a keyword list with application names as keys and their
+      mode as value. By default `:applications` includes the current application and
+      all applications the current application depends on, recursively. You can include
+      new applications or change the mode of existing ones by listing them here.
+
+      The order of the applications given will be preserved as much as possible, with
+      only `:kernel`, `:stdlib`, `:sasl`, and `:elixir` listed before the given application
+      list. The supported values are:
+
+        * `:permanent` (default) - the application is started and the node shuts down
+          if the application terminates, regardless of reason
+        * `:transient` - the application is started and the node shuts down
+          if the application terminates abnormally
+        * `:temporary` - the application is started and the node does not
+          shut down if the application terminates
+        * `:load` - the application is only loaded
+        * `:none` - the application is part of the release but it is neither
+          loaded nor started
+
+      If you change the mode of an application, the mode will apply to all its child
+      applications. However, if an application has two parents, the mode of the parent
+      with highest priority wins (where `:permanent` has the highest priority, according
+      to the list above).
+
+    * `:strip_beams` - controls if BEAM files should have their debug information,
+      documentation chunks, and other non-essential metadata removed. Defaults to
+      `true`. May be set to `false` to disable stripping. Also accepts
+      `[keep: ["Docs", "Dbgi"]]` to keep certain chunks that are usually stripped.
+      You can also set the `:compress` option to true to enable individual
+      compression of BEAM files, although it is typically preferred to compress
+      the whole release instead.
+
+    * `:cookie` - a string representing the Erlang Distribution cookie. If this
+      option is not set, a random cookie is written to the `releases/COOKIE` file
+      when the first release is assembled. At runtime, we will first attempt
+      to fetch the cookie from the `RELEASE_COOKIE` environment variable and
+      then we'll read the `releases/COOKIE` file.
+
+      If you are setting this option manually, we recommend the cookie option
+      to be a long and randomly generated string, such as:
+      `Base.encode32(:crypto.strong_rand_bytes(40))`. We also recommend restricting
+      the characters in the cookie to only alphanumeric characters and underscore.
+
+    * `:validate_compile_env` - by default a release will match all runtime
+      configuration against any configuration that was marked at compile time
+      in your application of its dependencies via the `Application.compile_env/3`
+      function. If there is a mismatch between those, it means your system is
+      misconfigured and unable to boot. You can disable this check by setting
+      this option to false.
+
+    * `:path` - the path the release should be installed to.
+      Defaults to `"_build/MIX_ENV/rel/RELEASE_NAME"`.
+
+    * `:version` - the release version as a string or `{:from_app, app_name}`.
+      Defaults to the current application version. The `{:from_app, app_name}` format
+      can be used to easily reference the application version from another application.
+      This is particularly useful in umbrella applications.
+
+    * `:quiet` - a boolean that controls if releases should write steps to
+      the standard output. Defaults to `false`.
+
+    * `:include_erts` - a boolean, string, or anonymous function of arity zero.
+      If a boolean, it indicates whether the Erlang Runtime System (ERTS), which
+      includes the Erlang VM, should be included in the release. The default is
+      `true`, which is also the recommended value. If a string, it represents
+      the path to an existing ERTS installation. If an anonymous function of
+      arity zero, it's a function that returns any of the above (boolean or string).
+
+      You may also set this option to `false` if you desire to use the ERTS version installed
+      on the target. Note, however, that the ERTS version on the target must have **the
+      exact version** as the ERTS version used when the release is assembled. Setting it to
+      `false` also disables hot code upgrades. Therefore, `:include_erts` should be
+      set to `false` with caution and only if you are assembling the release on the
+      same server that runs it.
+
+    * `:include_executables_for` - a list of atoms detailing for which Operating
+      Systems executable files should be generated for. By default, it is set to
+      `[:unix, :windows]`. You can customize those as follows:
+
+          releases: [
+            demo: [
+              include_executables_for: [:unix] # Or [:windows] or []
+            ]
+          ]
+
+    * `:rel_templates_path` - the path to find template files that are copied to
+      the release, such as `vm.args.eex`, `remote.vm.args.eex`, `env.sh.eex`
+      (or `env.bat.eex`), and `overlays`. Defaults to `"rel"` in the project root.
+
+    * `:overlays` - a list of directories with extra files to be copied
+      as is to the release. The "overlays" directory at `:rel_templates_path`
+      is always included in this list by default (typically at `"rel/overlays"`).
+      See the "Overlays" section for more information.
+
+    * `:steps` - a list of steps to execute when assembling the release. See
+      the "Steps" section for more information.
+
+    * `:skip_mode_validation_for` - a list of application names
+      (atoms) specifying applications to skip strict validation of
+      "unsafe" modes. An "unsafe" case is when a parent application
+      mode is `:permanent` but one of the applications it depends on
+      is set to `:load`. Use this with care, as a release with
+      invalid modes may no longer boot without additional tweaks.
+      Defaults to `[]`.
+
+  Note each release definition can be given as an anonymous function. This
+  is useful if some release attributes are expensive to compute:
+
+      releases: [
+        demo: fn ->
+          [version: @version <> "+" <> git_ref()]
+        end
+      ]
+
+  Besides the options above, it is possible to customize the generated
+  release with custom files, by tweaking the release steps or by running
+  custom options and commands on boot. We will detail both approaches next.
+
+  ### Overlays
+
+  Often it is necessary to copy extra files to the release root after
+  the release is assembled. This can be easily done by placing such
+  files in the `rel/overlays` directory. Any file in there is copied
+  as is to the release root. For example, if you have placed a
+  `rel/overlays/Dockerfile` file, the "Dockerfile" will be copied as
+  is to the release root.
+
+  If you want to specify extra overlay directories, you can do so
+  with the `:overlays` option. If you need to copy files dynamically,
+  see the "Steps" section.
+
+  ### Steps
+
+  It is possible to add one or more steps before and after the release is
+  assembled. This can be done with the `:steps` option:
+
+      releases: [
+        demo: [
+          steps: [&set_configs/1, :assemble, &copy_extra_files/1]
+        ]
+      ]
+
+  The `:steps` option must be a list and it must always include the
+  atom `:assemble`, which does most of the release assembling. You
+  can pass anonymous functions before and after the `:assemble` to
+  customize your release assembling pipeline. Those anonymous functions
+  will receive a `Mix.Release` struct and must return the same or
+  an updated `Mix.Release` struct. It is also possible to build a tarball
+  of the release by passing the `:tar` step anywhere after `:assemble`.
+  If the release `:path` is not configured, the tarball is created in
+  `_build/MIX_ENV/RELEASE_NAME-RELEASE_VSN.tar.gz` Otherwise it is
+  created inside the configured `:path`.
+
+  See `Mix.Release` for more documentation on the struct and which
+  fields can be modified. Note that the `:steps` field itself can be
+  modified and it is updated every time a step is called. Therefore,
+  if you need to execute a command before and after assembling the
+  release, you only need to declare the first steps in your pipeline
+  and then inject the last step into the release struct. The steps
+  field can also be used to verify if the step was set before or
+  after assembling the release.
+
+  ### vm.args and env.sh (env.bat)
+
+  Developers may want to customize the VM flags and environment variables
+  given when the release starts. The simplest way to customize those files
+  is by running `mix release.init`. The Mix task will copy custom
+  `rel/vm.args.eex`, `rel/remote.vm.args.eex`,  `rel/env.sh.eex`, and
+  `rel/env.bat.eex` files to your project root. You can modify those files
+  and they will be evaluated every time you perform a new release. Those
+  files are regular EEx templates and they have a single assign, called
+  `@release`, with the `Mix.Release` struct.
+
+  The `vm.args` and `remote.vm.args` files may contain any of the VM flags
+  accepted by the [`erl` command](https://www.erlang.org/doc/man/erl.html).
+
+  The `env.sh` and `env.bat` is used to set environment variables.
+  In there, you can set vars such as `RELEASE_NODE`, `RELEASE_COOKIE`,
+  and `RELEASE_TMP` to customize your node name, cookie and tmp
+  directory respectively. Whenever `env.sh` or `env.bat` is invoked,
+  the variables `RELEASE_ROOT`, `RELEASE_NAME`, `RELEASE_VSN`, and
+  `RELEASE_COMMAND` have already been set, so you can rely on them.
+  See the section on environment variables for more information.
+
+  Furthermore, while the `vm.args` files are static, you can use
+  `env.sh` and `env.bat` to dynamically set VM options. For example,
+  if you want to make sure the Erlang Distribution listens only on
+  a given port known at runtime, you can set the following:
+
+  ```bash
+  case $RELEASE_COMMAND in
+    start*|daemon*)
+      ELIXIR_ERL_OPTIONS="-kernel inet_dist_listen_min $BEAM_PORT inet_dist_listen_max $BEAM_PORT"
+      export ELIXIR_ERL_OPTIONS
+      ;;
+    *)
+      ;;
+  esac
+  ```
+
+  Note we only set the port on start/daemon commands. If you also limit
+  the port on other commands, such as `rpc`, then you will be unable
+  to establish a remote connection as the port will already be in use
+  by the node.
+
+  On Windows, your `env.bat` would look like this:
+
+  ```bash
+  IF NOT %RELEASE_COMMAND:start=%==%RELEASE_COMMAND% (
+    set ELIXIR_ERL_OPTIONS="-kernel inet_dist_listen_min %BEAM_PORT% inet_dist_listen_max %BEAM_PORT%"
+  )
+  ```
+
+  Inside `env.sh` and `env.bat` files you can access command-line arguments given to release commands.
+  For example, given this `env.sh.eex`:
+
+  ```bash
+  echo $@
+  ```
+
+  or this `env.bat.eex`:
+
+  ```bash
+  echo %*
+  ```
+
+  starting the release with `bin/myapp start --foo bar baz` will print `start --foo bar baz`.
+
+  ### `epmd`-less deployment
+
+  When a distributed Erlang/Elixir node starts, it runs a separate daemon called EPMD
+  (Erlang Port Mapper Daemon) and registers the node name within EPMD. It is possible
+  to skip this additional Operating System process by setting the following flags in
+  your vm.args files:
+
+      # In vm.args.eex
+      -start_epmd false -erl_epmd_port 6789
+
+      # In remote.vm.args.eex
+      -start_epmd false -erl_epmd_port 6789 -dist_listen false
+
+  You can pick any port of your choice.
+
+  ## Application configuration
+
+  Mix provides two mechanisms for configuring the application environment
+  of your application and your dependencies: build-time and runtime. On this
+  section, we will learn how those mechanisms apply to releases. An introduction
+  to this topic can be found in the "Configuration" section of the `Mix` module.
+
+  ### Build-time configuration
+
+  Whenever you invoke a `mix` command, Mix loads the configuration in
+  `config/config.exs`, if said file exists. We say that this configuration
+  is a build-time configuration as it is evaluated whenever you compile your
+  code or whenever you assemble the release.
+
+  In other words, if your configuration does something like:
+
+      import Config
+      config :my_app, :secret_key, System.fetch_env!("MY_APP_SECRET_KEY")
+
+  The `:secret_key` key under `:my_app` will be computed on the
+  host machine, whenever the release is built. Therefore if the machine
+  assembling the release not have access to all environment variables used
+  to run your code, loading the configuration will fail as the environment
+  variable is missing. Luckily, Mix also provides runtime configuration,
+  which should be preferred and we will see next.
+
+  ### Runtime configuration
+
+  To enable runtime configuration in your release, create a file named
+  `config/runtime.exs`:
+
+      import Config
+      config :my_app, :secret_key, System.fetch_env!("MY_APP_SECRET_KEY")
+
+  This file will be executed whenever your Mix project or your release
+  starts.
+
+  Your `config/runtime.exs` file needs to follow three important rules:
+
+    * It MUST `import Config` at the top instead of the deprecated `use Mix.Config`
+    * It MUST NOT import any other configuration file via `import_config`
+    * It MUST NOT access `Mix` in any way, as `Mix` is a build tool and
+      it is not available inside releases
+
+  If a `config/runtime.exs` exists, it will be copied to your release
+  and executed early in the boot process, when only Elixir and Erlang's
+  main applications have been started.
+
+  You can change the path to the runtime configuration file by setting
+  `:runtime_config_path` inside each release configuration. This path is
+  resolved at build time as the given configuration file is always copied
+  to inside the release:
+
+      releases: [
+        demo: [
+          runtime_config_path: ...
+        ]
+      ]
+
+  By setting `:runtime_config_path` to `false` it can be used to prevent
+  a runtime configuration file to be included in the release.
+
+  ### Config providers
+
+  Releases also supports custom mechanisms, called config providers, to load
+  any sort of runtime configuration to the system while it boots. For instance,
+  if you need to access a vault or load configuration from a JSON file, it can
+  be achieved with config providers. The runtime configuration outlined in the
+  previous section is handled by the `Config.Reader` provider. See the
+  `Config.Provider` module for more information and more examples.
+
+  The following options can be set inside your releases key in your `mix.exs`
+  to control how config providers work:
+
+    * `:reboot_system_after_config` - reboot the system after configuration
+      so you can configure system applications, such as `:kernel` and `:stdlib`,
+      in your `config/runtime.exs`. Generally speaking, it is best to configure
+      `:kernel` and `:stdlib` using the `vm.args` file but this option is available
+      for those who need more complex configuration. When set to `true`, the
+      release will first boot in interactive mode to compute a config file and
+      write it to the "tmp" directory. Then it reboots in the configured `RELEASE_MODE`.
+      You can configure the "tmp" directory by setting the `RELEASE_TMP` environment
+      variable, either explicitly or inside your `releases/RELEASE_VSN/env.sh`
+      (or `env.bat` on Windows). Defaults to `true` if using the deprecated
+      `config/releases.exs`, `false` otherwise. Be careful of which libraries you
+      load when setting this option to true, if a library is loaded early during
+      configuration and it includes native code, it may not actually be able to
+      restart cleanly.
+
+    * `:prune_runtime_sys_config_after_boot` - if `:reboot_system_after_config`
+      is set, every time your system boots, the release will write a config file
+      to your tmp directory. These configuration files are generally small.
+      But if you are concerned with disk space or if you have other restrictions,
+      you can ask the system to remove said config files after boot. The downside
+      is that you will no longer be able to restart the system internally (neither
+      via `System.restart/0` nor `bin/RELEASE_NAME restart`). If you need a restart,
+      you will have to terminate the Operating System process and start a new
+      one. Defaults to `false`.
+
+    * `:start_distribution_during_config` - if `:reboot_system_after_config` is
+      set, releases only start the Erlang VM distribution features after the config
+      files are evaluated. You can set it to `true` if you need distribution during
+      configuration. Defaults to `false`.
+
+    * `:config_providers` - a list of tuples with custom config providers.
+      See `Config.Provider` for more information. Defaults to `[]`.
+
+  ### Customization and configuration summary
+
+  Generally speaking, the following files are available for customizing
+  and configuring the running system:
+
+    * `config/config.exs` (and `config/prod.exs`) - provides build-time
+      application configuration, which are executed when the release is
+      assembled
+
+    * `config/runtime.exs` - provides runtime application configuration.
+      It is executed every time your Mix project or your release boots
+      and is further extensible via config providers. If you want to
+      detect you are inside a release, you can check for release specific
+      environment variables, such as `RELEASE_NODE` or `RELEASE_MODE`
+
+    * `rel/vm.args.eex` and `rel/remote.vm.args.eex` - template files that
+      are copied into every release and provides static configuration of the
+      Erlang Virtual Machine and other runtime flags. `vm.args` runs on
+      `start`, `daemon`, and `eval` commands. `remote.vm.args` configures
+      the VM for `remote` and `rpc` commands
+
+    * `rel/env.sh.eex` and `rel/env.bat.eex` - template files that are copied
+      into every release and are executed on every command to set up environment
+      variables, including specific ones to the VM, and the general environment
+
+  ## Directory structure
+
+  A release is organized as follows:
+
+  ```text
+  bin/
+    RELEASE_NAME
+  erts-ERTS_VSN/
+  lib/
+    APP_NAME-APP_VSN/
+      ebin/
+      include/
+      priv/
+  releases/
+    RELEASE_VSN/
+      consolidated/
+      elixir
+      elixir.bat
+      env.bat
+      env.sh
+      iex
+      iex.bat
+      remote.vm.args
+      runtime.exs
+      start.boot
+      start.script
+      start_clean.boot
+      start_clean.script
+      sys.config
+      vm.args
+    COOKIE
+    start_erl.data
+  tmp/
+  ```
+
+  We document this structure for completeness. In practice, developers
+  should not modify any of those files after the release is assembled.
+  Instead use env scripts, custom config provider, overlays, and all
+  other mechanisms described here to configure how your release works.
+
+  ## Environment variables
+
+  The system sets different environment variables. The following variables
+  are set early on and can only be read by `env.sh` and `env.bat`:
+
+    * `RELEASE_ROOT` - points to the root of the release. If the system
+      includes ERTS, then it is the same as `:code.root_dir/0`. This
+      variable is always computed and it cannot be set to a custom value
+
+    * `RELEASE_COMMAND` - the command given to the release, such as `"start"`,
+      `"remote"`, `"eval"`, and so on. This is typically accessed inside `env.sh`
+      and `env.bat` to set different environment variables under different
+      conditions. Note, however, that `RELEASE_COMMAND` has not been
+      validated by the time `env.sh` and `env.bat` are called, so it may
+      be empty or contain invalid values. This variable is always computed
+      and it cannot be set to a custom value
+
+    * `RELEASE_NAME` - the name of the release. It can be set to a custom
+      value when invoking the release
+
+    * `RELEASE_VSN` - the version of the release, otherwise the latest
+      version is used. It can be set to a custom value when invoking the
+      release. The custom value must be an existing release version in
+      the `releases/` directory
+
+    * `RELEASE_PROG` - the command line executable used to start the release
+
+  The following variables can be set before you invoke the release or
+  inside `env.sh` and `env.bat`:
+
+    * `RELEASE_COOKIE` - the release cookie. By default uses the value
+      in `releases/COOKIE`. It can be set to a custom value
+
+    * `RELEASE_NODE` - the release node name, in the format `name` or
+      optionally `name@host` if running in distributed mode. It can be
+      set to a custom value. The name part must be made only of letters,
+      digits, underscores, and hyphens
+
+    * `RELEASE_SYS_CONFIG` - the location of the sys.config file. It can
+      be set to a custom path and it must not include the `.config` extension
+
+    * `RELEASE_VM_ARGS` - the location of the vm.args file. It can be set
+      to a custom path
+
+    * `RELEASE_REMOTE_VM_ARGS` - the location of the remote.vm.args file.
+      It can be set to a custom path
+
+    * `RELEASE_TMP` - the directory in the release to write temporary
+      files to. It can be set to a custom directory. It defaults to
+      `$RELEASE_ROOT/tmp`
+
+    * `RELEASE_MODE` - if the release should load code on demand (interactive)
+      or preload it (embedded). Defaults to "embedded", which increases boot
+      time but it means the runtime will respond faster as it doesn't have to
+      load code. Choose interactive if you need to decrease boot time and reduce
+      memory usage on boot. It applies only to start/daemon/install commands
+
+    * `RELEASE_DISTRIBUTION` - how do we want to run the distribution.
+      May be `name` (long names), `sname` (short names) or `none`
+      (distribution is not started automatically). Defaults to `sname`.
+      When connecting nodes across hosts, you typically want to set
+      this to `name` (required to use IPs as host names)
+
+    * `RELEASE_BOOT_SCRIPT` - the name of the boot script to use when starting
+      the release. This script is used when running commands such as `start` and
+      `daemon`. The boot script is expected to be located at the
+      path `releases/RELEASE_VSN/RELEASE_BOOT_SCRIPT.boot`. Defaults to `start`
+
+    * `RELEASE_BOOT_SCRIPT_CLEAN` - the name of the boot script used when
+      starting the release clean, without your application or its dependencies.
+      This script is used by commands such as `eval`, `rpc`, and `remote`.
+      The boot script is expected to be located at the path
+      `releases/RELEASE_VSN/RELEASE_BOOT_SCRIPT_CLEAN.boot`. Defaults
+      to `start_clean`
+
+  ## Umbrellas
+
+  Releases are well integrated with umbrella projects, allowing you to
+  release one or more subsets of your umbrella children. The only difference
+  between performing a release in the umbrella project compared to a
+  regular application is that umbrellas require you to explicitly list
+  your release and the starting point for each release. For example,
+  imagine this umbrella applications:
+
+  ```text
+  my_app_umbrella/
+    apps/
+      my_app_core/
+      my_app_event_processing/
+      my_app_web/
+  ```
+
+  where both `my_app_event_processing` and `my_app_web` depend on
+  `my_app_core` but they do not depend on each other.
+
+  Inside your umbrella, you can define multiple releases:
+
+      releases: [
+        web_and_event_processing: [
+          applications: [
+            my_app_event_processing: :permanent,
+            my_app_web: :permanent
+          ]
+        ],
+
+        web_only: [
+          applications: [my_app_web: :permanent]
+        ],
+
+        event_processing_only: [
+          applications: [my_app_event_processing: :permanent]
+        ]
+      ]
+
+  Note you don't need to define all applications in `:applications`,
+  only the entry points. Also remember that the recommended mode
+  for all applications in the system is `:permanent`.
+
+  Finally, keep in mind it is not required for you to assemble the
+  release from the umbrella root. You can also assemble the release
+  from each child application individually. Doing it from the root,
+  however, allows you to include two applications that do not depend
+  on each other as part of the same release.
+
+  ## Hot Code Upgrades
+
+  Erlang and Elixir are sometimes known for the capability of upgrading
+  a node that is running in production without shutting down that node.
+  However, this feature is not supported out of the box by Elixir releases.
+
+  The reason we don't provide hot code upgrades is because they are very
+  complicated to perform in practice, as they require careful coding of
+  your processes and applications as well as extensive testing. Given most
+  teams can use other techniques that are language agnostic to upgrade
+  their systems, such as Blue/Green deployments, Canary deployments,
+  Rolling deployments, and others, hot upgrades are rarely a viable
+  option. Let's understand why.
+
+  In a hot code upgrade, you want to update a node from version A to
+  version B. To do so, the first step is to write recipes for every application
+  that changed between those two releases, telling exactly how the application
+  changed between versions, those recipes are called `.appup` files.
+  While some of the steps in building `.appup` files can be automated,
+  not all of them can. Furthermore, each process in the application needs
+  to be explicitly coded with hot code upgrades in mind. Let's see an example.
+  Imagine your application has a counter process as a GenServer:
+
+      defmodule Counter do
+        use GenServer
+
+        def start_link(_) do
+          GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
+        end
+
+        def bump do
+          GenServer.call(__MODULE__, :bump)
+        end
+
+        ## Callbacks
+
+        def init(:ok) do
+          {:ok, 0}
+        end
+
+        def handle_call(:bump, counter) do
+          {:reply, :ok, counter + 1}
+        end
+      end
+
+  You add this process as part of your supervision tree and ship version
+  0.1.0 of your system. Now let's imagine that on version 0.2.0 you added
+  two changes: instead of `bump/0`, that always increments the counter by
+  one, you introduce `bump/1` that passes the exact value to bump the
+  counter. You also change the state, because you want to store the maximum
+  bump value:
+
+      defmodule Counter do
+        use GenServer
+
+        def start_link(_) do
+          GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
+        end
+
+        def bump(by) do
+          GenServer.call(__MODULE__, {:bump, by})
+        end
+
+        ## Callbacks
+
+        def init(:ok) do
+          {:ok, {0, 0}}
+        end
+
+        def handle_call({:bump, by}, {counter, max}) do
+          {:reply, :ok, {counter + by, max(max, by)}}
+        end
+      end
+
+  If you were to perform a hot code upgrade in such an application, it would
+  crash, because in the initial version the state was just a counter
+  but in the new version the state is a tuple. Furthermore, you changed
+  the format of the `call` message from `:bump` to `{:bump, by}` and
+  the process may have both old and new messages temporarily mixed, so
+  we need to handle both. The final version would be:
+
+      defmodule Counter do
+        use GenServer
+
+        def start_link(_) do
+          GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
+        end
+
+        def bump(by) do
+          GenServer.call(__MODULE__, {:bump, by})
+        end
+
+        ## Callbacks
+
+        def init(:ok) do
+          {:ok, {0, 0}}
+        end
+
+        def handle_call(:bump, {counter, max}) do
+          {:reply, :ok, {counter + 1, max(max, 1)}}
+        end
+
+        def handle_call({:bump, by}, {counter, max}) do
+          {:reply, :ok, {counter + by, max(max, by)}}
+        end
+
+        def code_change(_, counter, _) do
+          {:ok, {counter, 0}}
+        end
+      end
+
+  Now you can proceed to list this process in the `.appup` file and
+  hot code upgrade it. This is one of the many steps necessary
+  to perform hot code upgrades and it must be taken into account by
+  every process and application being upgraded in the system.
+  The [`.appup` cookbook](https://www.erlang.org/doc/design_principles/appup_cookbook.html)
+  provides a good reference and more examples.
+
+  Once `.appup`s are created, the next step is to create a `.relup`
+  file with all instructions necessary to update the release itself.
+  Erlang documentation does provide a chapter on
+  [Creating and upgrading a target system](https://www.erlang.org/doc/system_principles/create_target.html).
+  [Learn You Some Erlang has a chapter on hot code upgrades](https://learnyousomeerlang.com/relups).
+
+  Overall, there are many steps, complexities and assumptions made
+  during hot code upgrades, which is ultimately why they are not
+  provided by Elixir out of the box. However, hot code upgrades can
+  still be achieved by teams who desire to implement those steps
+  on top of `mix release` in their projects or as separate libraries.
+
+  ## Command line options
+
+    * `--force` - forces recompilation
+    * `--no-archives-check` - does not check archive
+    * `--no-deps-check` - does not check dependencies
+    * `--no-elixir-version-check` - does not check Elixir version
+    * `--no-compile` - does not compile before assembling the release
+    * `--overwrite` - overwrite existing files instead of prompting the user for action
+    * `--path` - the path of the release
+    * `--quiet` - does not write progress to the standard output
+    * `--version` - the version of the release
+
+  """
+
+  import Mix.Generator
+
+  @switches [
+    overwrite: :boolean,
+    force: :boolean,
+    quiet: :boolean,
+    path: :string,
+    version: :string,
+    compile: :boolean,
+    deps_check: :boolean,
+    archives_check: :boolean,
+    elixir_version_check: :boolean
+  ]
+
+  @aliases [
+    f: :force
+  ]
+
+  @impl true
+  def run(args) do
+    Mix.Project.get!()
+    Mix.Task.run("compile", args)
+    Mix.ensure_application!(:sasl)
+    Mix.ensure_application!(:crypto)
+
+    config = Mix.Project.config()
+
+    release =
+      case OptionParser.parse!(args, strict: @switches, aliases: @aliases) do
+        {overrides, [name]} -> Mix.Release.from_config!(String.to_atom(name), config, overrides)
+        {overrides, []} -> Mix.Release.from_config!(nil, config, overrides)
+        {_, _} -> Mix.raise("Expected \"mix release\" or \"mix release NAME\"")
+      end
+
+    if not File.exists?(release.version_path) or
+         yes?(release, "Release #{release.name}-#{release.version} already exists. Overwrite?") do
+      run_steps(release)
+    end
+  end
+
+  defp yes?(release, message) do
+    release.options[:overwrite] or Mix.shell().yes?(message)
+  end
+
+  defp run_steps(%{steps: [step | steps]} = release) when is_function(step) do
+    case step.(%{release | steps: steps}) do
+      %Mix.Release{} = release ->
+        run_steps(release)
+
+      other ->
+        Mix.raise(
+          "Expected step #{inspect(step)} to return a Mix.Release, got: #{inspect(other)}"
+        )
+    end
+  end
+
+  defp run_steps(%{steps: [:tar | steps]} = release) do
+    %{release | steps: steps} |> make_tar() |> run_steps()
+  end
+
+  defp run_steps(%{steps: [:assemble | steps]} = release) do
+    %{release | steps: steps} |> assemble() |> run_steps()
+  end
+
+  defp run_steps(%{steps: []} = release) do
+    announce(release)
+  end
+
+  defp assemble(release) do
+    config = Mix.Project.config()
+    message = "#{release.name}-#{release.version} on MIX_ENV=#{Mix.env()}"
+    info(release, [:green, "* assembling ", :reset, message])
+
+    # releases/
+    #   VERSION/
+    #     consolidated/
+    #     NAME.rel
+    #     start.boot
+    #     start.script
+    #     start_clean.boot
+    #     start_clean.script
+    #     sys.config
+    # releases/
+    #   COOKIE
+    #   start_erl.data
+    {consolidation_path, release} = build_rel(release, config)
+
+    [
+      # erts-VSN/
+      :erts,
+      # releases/VERSION/consolidated
+      {:consolidated, consolidation_path},
+      # bin/
+      #   RELEASE_NAME
+      #   RELEASE_NAME.bat
+      #   start
+      #   start.bat
+      # releases/
+      #   VERSION/
+      #     elixir
+      #     elixir.bat
+      #     iex
+      #     iex.bat
+      {:executables, Keyword.get(release.options, :include_executables_for, [:unix, :windows])}
+      # lib/APP_NAME-APP_VSN/
+      | Map.keys(release.applications)
+    ]
+    |> Task.async_stream(&copy(&1, release), ordered: false, timeout: :infinity)
+    |> Stream.run()
+
+    copy_overlays(release)
+  end
+
+  defp make_tar(release) do
+    build_path = Mix.Project.build_path()
+
+    dir_path =
+      if release.path == Path.join([build_path, "rel", Atom.to_string(release.name)]) do
+        build_path
+      else
+        release.path
+      end
+
+    out_path = Path.join(dir_path, "#{release.name}-#{release.version}.tar.gz")
+    info(release, [:green, "* building ", :reset, out_path])
+
+    lib_dirs =
+      Enum.reduce(release.applications, [], fn {name, app_config}, acc ->
+        vsn = Keyword.fetch!(app_config, :vsn)
+        [Path.join("lib", "#{name}-#{vsn}") | acc]
+      end)
+
+    erts_dir =
+      case release.erts_source do
+        nil -> []
+        _ -> ["erts-#{release.erts_version}"]
+      end
+
+    release_files =
+      for basename <- File.ls!(Path.join(release.path, "releases")),
+          not File.dir?(Path.join([release.path, "releases", basename])),
+          do: Path.join("releases", basename)
+
+    dirs =
+      ["bin", Path.join("releases", release.version)] ++
+        erts_dir ++ lib_dirs ++ release_files
+
+    files =
+      dirs
+      |> Enum.filter(&File.exists?(Path.join(release.path, &1)))
+      |> Kernel.++(release.overlays)
+      |> Enum.map(&{String.to_charlist(&1), String.to_charlist(Path.join(release.path, &1))})
+
+    File.rm(out_path)
+    :ok = :erl_tar.create(String.to_charlist(out_path), files, [:dereference, :compressed])
+    release
+  end
+
+  # build_rel
+
+  defp build_rel(release, config) do
+    version_path = release.version_path
+    File.rm_rf!(version_path)
+    File.mkdir_p!(version_path)
+    release = maybe_add_config_reader_provider(config, release, version_path)
+
+    consolidation_path =
+      if config[:consolidate_protocols] do
+        Mix.Project.consolidation_path(config)
+      end
+
+    sys_config =
+      if File.regular?(config[:config_path]) do
+        config[:config_path] |> Config.Reader.read!(env: Mix.env(), target: Mix.target())
+      else
+        []
+      end
+
+    vm_args_path = Path.join(version_path, "vm.args")
+    remote_vm_args_path = Path.join(version_path, "remote.vm.args")
+    cookie_path = Path.join(release.path, "releases/COOKIE")
+    start_erl_path = Path.join(release.path, "releases/start_erl.data")
+    config_provider_path = {:system, "RELEASE_SYS_CONFIG", ".config"}
+
+    with :ok <- make_boot_scripts(release, version_path, consolidation_path),
+         :ok <- make_vm_args(release, vm_args_path),
+         :ok <- make_vm_args(release, remote_vm_args_path),
+         :ok <- Mix.Release.make_sys_config(release, sys_config, config_provider_path),
+         :ok <- Mix.Release.make_cookie(release, cookie_path),
+         :ok <- Mix.Release.make_start_erl(release, start_erl_path) do
+      {consolidation_path, release}
+    else
+      {:error, message} ->
+        File.rm_rf!(version_path)
+        Mix.raise(message)
+    end
+  end
+
+  defp maybe_add_config_reader_provider(config, %{options: opts} = release, version_path) do
+    default_path = config[:config_path] |> Path.dirname() |> Path.join("runtime.exs")
+    deprecated_path = config[:config_path] |> Path.dirname() |> Path.join("releases.exs")
+
+    {path, reboot?} =
+      cond do
+        opts[:runtime_config_path] == false ->
+          {false, false}
+
+        path = opts[:runtime_config_path] ->
+          {path, false}
+
+        File.exists?(default_path) ->
+          if File.exists?(deprecated_path) do
+            IO.warn(
+              "both #{inspect(default_path)} and #{inspect(deprecated_path)} have been " <>
+                "found, but only #{inspect(default_path)} will be used"
+            )
+          end
+
+          {default_path, false}
+
+        File.exists?(deprecated_path) ->
+          IO.warn(
+            "config/releases.exs is deprecated, use config/runtime.exs or set :runtime_config_path in your release configuration instead"
+          )
+
+          {deprecated_path, true}
+
+        true ->
+          {nil, false}
+      end
+
+    cond do
+      path ->
+        msg = "#{path} to configure the release at runtime"
+        info(release, [:green, "* using ", :reset, msg])
+        File.cp!(path, Path.join(version_path, "runtime.exs"))
+        init = {:system, "RELEASE_ROOT", "/releases/#{release.version}/runtime.exs"}
+        opts = [path: init, env: Mix.env(), target: Mix.target(), imports: :disabled]
+        release = update_in(release.config_providers, &[{Config.Reader, opts} | &1])
+        update_in(release.options, &Keyword.put_new(&1, :reboot_system_after_config, reboot?))
+
+      release.config_providers == [] and path != false ->
+        skipping("runtime configuration (#{default_path} not found)")
+        release
+
+      true ->
+        release
+    end
+  end
+
+  defp make_boot_scripts(release, version_path, consolidation_path) do
+    prepend_paths =
+      if consolidation_path do
+        ["$RELEASE_LIB/../releases/#{release.version}/consolidated"]
+      else
+        []
+      end
+
+    results =
+      for {boot_name, modes} <- release.boot_scripts do
+        sys_path = Path.join(version_path, Atom.to_string(boot_name))
+
+        with :ok <- Mix.Release.make_boot_script(release, sys_path, modes, prepend_paths) do
+          if boot_name == :start do
+            rel_path = Path.join(Path.dirname(sys_path), "#{release.name}.rel")
+            File.rename!(sys_path <> ".rel", rel_path)
+          else
+            File.rm(sys_path <> ".rel")
+          end
+
+          :ok
+        end
+      end
+
+    Enum.find(results, :ok, &(&1 != :ok))
+  end
+
+  defp make_vm_args(release, path) do
+    vm_args_template = Mix.Release.rel_templates_path(release, "#{Path.basename(path)}.eex")
+
+    if File.exists?(vm_args_template) do
+      copy_template(vm_args_template, path, [release: release], force: true)
+    else
+      File.write!(path, vm_args_template(release: release))
+    end
+
+    :ok
+  end
+
+  defp announce(release) do
+    path = Path.relative_to_cwd(release.path)
+    cmd = "#{path}/bin/#{release.name}"
+
+    info(release, """
+
+    Release created at #{path}
+
+        # To start your system
+        #{cmd} start
+
+    Once the release is running:
+
+        # To connect to it remotely
+        #{cmd} remote
+
+        # To stop it gracefully (you may also send SIGINT/SIGTERM)
+        #{cmd} stop
+
+    To list all commands:
+
+        #{cmd}
+    """)
+  end
+
+  defp info(release, message) do
+    if !release.options[:quiet] do
+      Mix.shell().info(message)
+    end
+  end
+
+  defp skipping(message) do
+    Mix.shell().info([:yellow, "* skipping ", :reset, message])
+  end
+
+  ## Overlays
+
+  defp copy_overlays(release) do
+    target = release.path
+    default = Mix.Release.rel_templates_path(release, "overlays")
+
+    overlays =
+      if File.dir?(default) do
+        [default | List.wrap(release.options[:overlays])]
+      else
+        List.wrap(release.options[:overlays])
+      end
+
+    relative =
+      overlays
+      |> Enum.flat_map(&File.cp_r!(&1, target))
+      |> Enum.uniq()
+      |> List.delete(target)
+      |> Enum.map(&Path.relative_to(&1, target))
+
+    update_in(release.overlays, &(relative ++ &1))
+  end
+
+  ## Copy operations
+
+  defp copy(:erts, release) do
+    _ = Mix.Release.copy_erts(release)
+    :ok
+  end
+
+  defp copy(app, release) when is_atom(app) do
+    Mix.Release.copy_app(release, app)
+  end
+
+  defp copy({:consolidated, consolidation_path}, release) do
+    if consolidation_path do
+      consolidation_target = Path.join(release.version_path, "consolidated")
+      _ = Mix.Release.copy_ebin(release, consolidation_path, consolidation_target)
+    end
+
+    :ok
+  end
+
+  defp copy({:executables, include_executables_for}, release) do
+    elixir_bin_path = Application.app_dir(:elixir, "../../bin")
+    bin_path = Path.join(release.path, "bin")
+    File.mkdir_p!(bin_path)
+
+    for os <- include_executables_for do
+      {env, env_fun, clis} = cli_for(os, release)
+      env_path = Path.join(release.version_path, env)
+      env_template_path = Mix.Release.rel_templates_path(release, env <> ".eex")
+
+      if File.exists?(env_template_path) do
+        copy_template(env_template_path, env_path, [release: release], force: true)
+      else
+        File.write!(env_path, env_fun.(release))
+      end
+
+      for {filename, contents} <- clis do
+        target = Path.join(bin_path, filename)
+        File.write!(target, contents)
+        executable!(target)
+      end
+
+      for {filename, contents_fun} <- elixir_cli_for(os, release) do
+        source = Path.join(elixir_bin_path, filename)
+
+        if File.regular?(source) do
+          target = Path.join(release.version_path, filename)
+          File.write!(target, contents_fun.(source))
+          executable!(target)
+        else
+          skipping("#{filename} for #{os} (bin/#{filename} not found in the Elixir installation)")
+        end
+      end
+    end
+  end
+
+  defp cli_for(:unix, release) do
+    {"env.sh", &env_template(release: &1), [{"#{release.name}", cli_template(release: release)}]}
+  end
+
+  defp cli_for(:windows, release) do
+    {"env.bat", &env_bat_template(release: &1),
+     [{"#{release.name}.bat", cli_bat_template(release: release)}]}
+  end
+
+  defp elixir_cli_for(:unix, release) do
+    [
+      {"elixir",
+       &(&1
+         |> File.read!()
+         |> String.replace(
+           ~s[ -elixir_root "$SCRIPT_PATH"/../lib -pa "$SCRIPT_PATH"/../lib/elixir/ebin ],
+           " "
+         )
+         |> replace_erts_bin(release, ~s["$SCRIPT_PATH"/../../erts-#{release.erts_version}/bin/]))},
+      {"iex", &File.read!/1}
+    ]
+  end
+
+  defp elixir_cli_for(:windows, release) do
+    [
+      {"elixir.bat",
+       &(&1
+         |> File.read!()
+         |> String.replace(
+           ~s[ -elixir_root !SCRIPT_PATH!..\\lib -pa !SCRIPT_PATH!..\\lib\\elixir\\ebin ],
+           " "
+         )
+         |> replace_erts_bin(release, ~s[%~dp0\\..\\..\\erts-#{release.erts_version}\\bin\\]))},
+      {"iex.bat", &File.read!/1}
+    ]
+  end
+
+  @erts_bin [~s[ERTS_BIN="$ERTS_BIN"], ~s[ERTS_BIN=!ERTS_BIN!]]
+
+  defp replace_erts_bin(contents, release, new_path) do
+    if release.erts_source do
+      String.replace(contents, @erts_bin, ~s[ERTS_BIN=#{new_path}])
+    else
+      contents
+    end
+  end
+
+  defp executable!(path), do: File.chmod!(path, 0o755)
+
+  # Helper functions
+
+  defp release_mode(release, env_var) do
+    reboot? = Keyword.get(release.options, :reboot_system_after_config, false)
+
+    if reboot? and release.config_providers != [] do
+      "-elixir config_provider_reboot_mode #{env_var}"
+    else
+      "-mode #{env_var}"
+    end
+  end
+
+  embed_template(:vm_args, Mix.Tasks.Release.Init.vm_args_text(false))
+  embed_template(:env, Mix.Tasks.Release.Init.env_text())
+  embed_template(:cli, Mix.Tasks.Release.Init.cli_text())
+  embed_template(:env_bat, Mix.Tasks.Release.Init.env_bat_text())
+  embed_template(:cli_bat, Mix.Tasks.Release.Init.cli_bat_text())
+end
diff --git a/lib/mix/lib/mix/tasks/release.init.ex b/lib/mix/lib/mix/tasks/release.init.ex
new file mode 100644
index 00000000000..4dfa77f913d
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/release.init.ex
@@ -0,0 +1,514 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Release.Init do
+  use Mix.Task
+
+  @shortdoc "Generates sample files for releases"
+
+  @moduledoc """
+  Generates sample files for releases.
+
+      $ mix release.init
+      * creating rel/vm.args.eex
+      * creating rel/remote.vm.args.eex
+      * creating rel/env.sh.eex
+      * creating rel/env.bat.eex
+  """
+
+  import Mix.Generator
+
+  @switches [
+    force: :boolean,
+    quiet: :boolean
+  ]
+
+  @aliases [
+    force: :f
+  ]
+
+  @impl true
+  def run(args) do
+    {opts, args} = OptionParser.parse!(args, strict: @switches, aliases: @aliases)
+
+    if args != [] do
+      Mix.raise("Expected \"mix release.init\" without arguments, got: #{inspect(args)}")
+    end
+
+    create_file("rel/vm.args.eex", vm_args_text(false), opts)
+    create_file("rel/remote.vm.args.eex", vm_args_text(true), opts)
+    create_file("rel/env.sh.eex", env_text(), opts)
+    create_file("rel/env.bat.eex", env_bat_text(), opts)
+    :ok
+  end
+
+  @doc false
+  def vm_args_text(remote?),
+    do: """
+    ## Customize flags given to the VM: https://www.erlang.org/doc/man/erl.html
+    ## -mode/-name/-sname/-setcookie are configured via env vars, do not set them here
+
+    ## Increase number of concurrent ports/sockets
+    ##+Q 65536
+
+    ## Tweak GC to run more often
+    ##-env ERL_FULLSWEEP_AFTER 10
+
+    ## Enable deployment without epmd
+    ## (requires changing both vm.args and remote.vm.args)
+    ##-start_epmd false -erl_epmd_port 6789#{if(remote?, do: " -dist_listen false")}
+    """
+
+  @doc false
+  def env_text,
+    do: ~S"""
+    #!/bin/sh
+
+    # # Sets and enables heart (recommended only in daemon mode)
+    # case $RELEASE_COMMAND in
+    #   daemon*)
+    #     HEART_COMMAND="$RELEASE_ROOT/bin/$RELEASE_NAME $RELEASE_COMMAND"
+    #     export HEART_COMMAND
+    #     export ELIXIR_ERL_OPTIONS="-heart"
+    #     ;;
+    #   *)
+    #     ;;
+    # esac
+
+    # # Set the release to load code on demand (interactive) instead of preloading (embedded).
+    # export RELEASE_MODE=interactive
+
+    # # Set the release to work across nodes.
+    # # RELEASE_DISTRIBUTION must be "sname" (local), "name" (distributed) or "none".
+    # export RELEASE_DISTRIBUTION=name
+    # export RELEASE_NODE=<%= @release.name %>
+    """
+
+  @doc false
+  def cli_text,
+    do: ~S"""
+    #!/bin/sh
+    set -e
+
+    readlink_f () {
+      cd "$(dirname "$1")" > /dev/null
+      filename="$(basename "$1")"
+      if [ -h "$filename" ]; then
+        readlink_f "$(readlink "$filename")"
+      else
+        echo "$(pwd -P)/$filename"
+      fi
+    }
+
+    SELF=$(readlink_f "$0")
+    RELEASE_ROOT="$(CDPATH='' cd "$(dirname "$SELF")/.." && pwd -P)"
+    export RELEASE_ROOT
+    RELEASE_NAME="${RELEASE_NAME:-"<%= @release.name %>"}"
+    export RELEASE_NAME
+    RELEASE_VSN="${RELEASE_VSN:-"$(cut -d' ' -f2 "$RELEASE_ROOT/releases/start_erl.data")"}"
+    export RELEASE_VSN
+    RELEASE_COMMAND="$1"
+    export RELEASE_COMMAND
+    RELEASE_PROG="${RELEASE_PROG:-"$(echo "$0" | sed 's/.*\///')"}"
+    export RELEASE_PROG
+
+    REL_VSN_DIR="$RELEASE_ROOT/releases/$RELEASE_VSN"
+    . "$REL_VSN_DIR/env.sh"
+
+    RELEASE_COOKIE="${RELEASE_COOKIE:-"$(cat "$RELEASE_ROOT/releases/COOKIE")"}"
+    export RELEASE_COOKIE
+    RELEASE_MODE="${RELEASE_MODE:-"embedded"}"
+    export RELEASE_MODE
+    RELEASE_NODE="${RELEASE_NODE:-"$RELEASE_NAME"}"
+    export RELEASE_NODE
+    RELEASE_TMP="${RELEASE_TMP:-"$RELEASE_ROOT/tmp"}"
+    export RELEASE_TMP
+    RELEASE_VM_ARGS="${RELEASE_VM_ARGS:-"$REL_VSN_DIR/vm.args"}"
+    export RELEASE_VM_ARGS
+    RELEASE_REMOTE_VM_ARGS="${RELEASE_REMOTE_VM_ARGS:-"$REL_VSN_DIR/remote.vm.args"}"
+    export RELEASE_REMOTE_VM_ARGS
+    RELEASE_DISTRIBUTION="${RELEASE_DISTRIBUTION:-"sname"}"
+    export RELEASE_DISTRIBUTION
+    RELEASE_BOOT_SCRIPT="${RELEASE_BOOT_SCRIPT:-"start"}"
+    export RELEASE_BOOT_SCRIPT
+    RELEASE_BOOT_SCRIPT_CLEAN="${RELEASE_BOOT_SCRIPT_CLEAN:-"start_clean"}"
+    export RELEASE_BOOT_SCRIPT_CLEAN
+
+    rand () {
+      dd count=1 bs=2 if=/dev/urandom 2> /dev/null | od -x | awk 'NR==1{print $2}'
+    }
+
+    release_distribution () {
+      case $RELEASE_DISTRIBUTION in
+        none)
+          ;;
+
+        name | sname)
+          echo "--$RELEASE_DISTRIBUTION $1"
+          ;;
+
+        *)
+          echo "ERROR: Expected RELEASE_DISTRIBUTION to be sname, name, or none, got: $RELEASE_DISTRIBUTION" >&2
+          exit 1
+          ;;
+      esac
+    }
+
+    rpc () {
+      exec "$REL_VSN_DIR/elixir" \
+           --hidden --cookie "$RELEASE_COOKIE" \
+           $(release_distribution "rpc-$(rand)-$RELEASE_NODE") \
+           --boot "$REL_VSN_DIR/$RELEASE_BOOT_SCRIPT_CLEAN" \
+           --boot-var RELEASE_LIB "$RELEASE_ROOT/lib" \
+           --vm-args "$RELEASE_REMOTE_VM_ARGS" \
+           --rpc-eval "$RELEASE_NODE" "$1"
+    }
+
+    start () {
+      export_release_sys_config
+      REL_EXEC="$1"
+      shift
+      exec "$REL_VSN_DIR/$REL_EXEC" \
+           --cookie "$RELEASE_COOKIE" \
+           $(release_distribution "$RELEASE_NODE") \
+           --erl "<%= release_mode(@release, "$RELEASE_MODE") %>" \
+           --erl-config "$RELEASE_SYS_CONFIG" \
+           --boot "$REL_VSN_DIR/$RELEASE_BOOT_SCRIPT" \
+           --boot-var RELEASE_LIB "$RELEASE_ROOT/lib" \
+           --vm-args "$RELEASE_VM_ARGS" "$@"
+    }
+
+    export_release_sys_config () {
+      DEFAULT_SYS_CONFIG="${RELEASE_SYS_CONFIG:-"$REL_VSN_DIR/sys"}"
+
+      if grep -q "RUNTIME_CONFIG=true" "$DEFAULT_SYS_CONFIG.config"; then
+        RELEASE_SYS_CONFIG="$RELEASE_TMP/$RELEASE_NAME-$RELEASE_VSN-$(date +%Y%m%d%H%M%S)-$(rand).runtime"
+
+        (mkdir -p "$RELEASE_TMP" && cat "$DEFAULT_SYS_CONFIG.config" >"$RELEASE_SYS_CONFIG.config") || (
+          echo "ERROR: Cannot start release because it could not write $RELEASE_SYS_CONFIG.config" >&2
+          exit 1
+        )
+      else
+        RELEASE_SYS_CONFIG="$DEFAULT_SYS_CONFIG"
+      fi
+
+      export RELEASE_SYS_CONFIG
+    }
+
+    case $1 in
+      start)
+        start "elixir" --no-halt
+        ;;
+
+      start_iex)
+        start "iex"
+        ;;
+
+      daemon)
+        start "elixir" --no-halt --pipe-to "${RELEASE_TMP}/pipe" "${RELEASE_TMP}/log"
+        ;;
+
+      daemon_iex)
+        start "iex" --pipe-to "${RELEASE_TMP}/pipe" "${RELEASE_TMP}/log"
+        ;;
+
+      eval)
+        if [ -z "$2" ]; then
+          echo "ERROR: EVAL expects an expression as argument" >&2
+          exit 1
+        fi
+        script="$2"
+        shift 2
+        export_release_sys_config
+        exec "$REL_VSN_DIR/elixir" \
+           --cookie "$RELEASE_COOKIE" \
+           --erl-config "$RELEASE_SYS_CONFIG" \
+           --boot "$REL_VSN_DIR/$RELEASE_BOOT_SCRIPT_CLEAN" \
+           --boot-var RELEASE_LIB "$RELEASE_ROOT/lib" \
+           --vm-args "$RELEASE_VM_ARGS" --eval "$script" -- "$@"
+        ;;
+
+      remote)
+        exec "$REL_VSN_DIR/iex" \
+             --hidden --cookie "$RELEASE_COOKIE" \
+             $(release_distribution "rem-$(rand)-$RELEASE_NODE") \
+             --boot "$REL_VSN_DIR/$RELEASE_BOOT_SCRIPT_CLEAN" \
+             --boot-var RELEASE_LIB "$RELEASE_ROOT/lib" \
+             --vm-args "$RELEASE_REMOTE_VM_ARGS" \
+             --remsh "$RELEASE_NODE"
+        ;;
+
+      rpc)
+        if [ -z "$2" ]; then
+          echo "ERROR: RPC expects an expression as argument" >&2
+          exit 1
+        fi
+        rpc "$2"
+        ;;
+
+      restart|stop)
+        rpc "System.$1()"
+        ;;
+
+      pid)
+        rpc "IO.puts System.pid()"
+        ;;
+
+      version)
+        echo "$RELEASE_NAME $RELEASE_VSN"
+        ;;
+
+      *)
+        echo "Usage: $(basename "$0") COMMAND [ARGS]
+
+    The known commands are:
+
+        start          Starts the system
+        start_iex      Starts the system with IEx attached
+        daemon         Starts the system as a daemon
+        daemon_iex     Starts the system as a daemon with IEx attached
+        eval \"EXPR\"    Executes the given expression on a new, non-booted system
+        rpc \"EXPR\"     Executes the given expression remotely on the running system
+        remote         Connects to the running system via a remote shell
+        restart        Restarts the running system via a remote command
+        stop           Stops the running system via a remote command
+        pid            Prints the operating system PID of the running system via a remote command
+        version        Prints the release name and version to be booted
+    " >&2
+
+        if [ -n "$1" ]; then
+          echo "ERROR: Unknown command $1" >&2
+          exit 1
+        fi
+        ;;
+    esac
+    """
+
+  @doc false
+  def env_bat_text,
+    do: ~S"""
+    @echo off
+    rem Set the release to load code on demand (interactive) instead of preloading (embedded).
+    rem set RELEASE_MODE=interactive
+
+    rem Set the release to work across nodes.
+    rem RELEASE_DISTRIBUTION must be sname (local), name (distributed) or none.
+    rem set RELEASE_DISTRIBUTION=name
+    rem set RELEASE_NODE=<%= @release.name %>
+    """
+
+  @doc false
+  def cli_bat_text,
+    do: ~S"""
+    @echo off
+    setlocal enabledelayedexpansion
+
+    pushd .
+    pushd "%~dp0\.."
+    set RELEASE_ROOT=%cd%
+    popd
+    popd
+
+    if not defined RELEASE_NAME (set RELEASE_NAME=<%= @release.name %>)
+    if not defined RELEASE_VSN (for /f "tokens=1,2" %%K in ('type "!RELEASE_ROOT!\releases\start_erl.data"') do (set ERTS_VSN=%%K) && (set RELEASE_VSN=%%L))
+    if not defined RELEASE_PROG (set RELEASE_PROG=%~nx0)
+    set RELEASE_COMMAND=%~1
+    set REL_VSN_DIR=!RELEASE_ROOT!\releases\!RELEASE_VSN!
+    call "!REL_VSN_DIR!\env.bat" %*
+
+    if not defined RELEASE_COOKIE (set /p RELEASE_COOKIE=<!RELEASE_ROOT!\releases\COOKIE)
+    if not defined RELEASE_MODE (set RELEASE_MODE=embedded)
+    if not defined RELEASE_NODE (set RELEASE_NODE=!RELEASE_NAME!)
+    if not defined RELEASE_TMP (set RELEASE_TMP=!RELEASE_ROOT!\tmp)
+    if not defined RELEASE_VM_ARGS (set RELEASE_VM_ARGS=!REL_VSN_DIR!\vm.args)
+    if not defined RELEASE_REMOTE_VM_ARGS (set RELEASE_REMOTE_VM_ARGS=!REL_VSN_DIR!\remote.vm.args)
+    if not defined RELEASE_DISTRIBUTION (set RELEASE_DISTRIBUTION=sname)
+    if not defined RELEASE_BOOT_SCRIPT (set RELEASE_BOOT_SCRIPT=start)
+    if not defined RELEASE_BOOT_SCRIPT_CLEAN (set RELEASE_BOOT_SCRIPT_CLEAN=start_clean)
+    if not defined RELEASE_SYS_CONFIG (set RELEASE_SYS_CONFIG=!REL_VSN_DIR!\sys)
+
+    if "!RELEASE_DISTRIBUTION!" == "none" (
+      rem
+    ) else if "!RELEASE_DISTRIBUTION!" == "name" (
+      rem
+    ) else if "!RELEASE_DISTRIBUTION!" == "sname" (
+      rem
+    ) else (
+      echo ERROR: Expected RELEASE_DISTRIBUTION to be sname, name, or none, got: !RELEASE_DISTRIBUTION!
+      exit /B 1
+    )
+
+    if "!RELEASE_MODE!" == "embedded" (
+      rem
+    ) else if "!RELEASE_MODE!" == "interactive" (
+      rem
+    ) else (
+      echo ERROR: Expected RELEASE_MODE to be embedded or interactive, got: !RELEASE_MODE!
+      exit /B 1
+    )
+
+    if "%~1" == "start" (set "REL_EXEC=elixir" && set "REL_EXTRA=--no-halt" && set "REL_GOTO=start")
+    if "%~1" == "start_iex" (set "REL_EXEC=iex" && set "REL_GOTO=start")
+    if "%~1" == "install" (set "REL_GOTO=install")
+    if "%~1" == "eval" (
+      if "%~2" == "" (
+        echo ERROR: EVAL expects an expression as argument
+        exit /B 1
+      )
+      set "REL_GOTO=eval"
+    )
+
+    if not "!REL_GOTO!" == "" (
+      findstr "RUNTIME_CONFIG=true" "!RELEASE_SYS_CONFIG!.config" >nul 2>&1 && (
+        set DEFAULT_SYS_CONFIG=!RELEASE_SYS_CONFIG!
+        set "TIMESTAMP=%TIME::=%"
+        set RELEASE_SYS_CONFIG=!RELEASE_TMP!\!RELEASE_NAME!-!RELEASE_VSN!-!TIMESTAMP!-!RANDOM!.runtime
+        mkdir "!RELEASE_TMP!" >nul 2>&1
+        copy /y "!DEFAULT_SYS_CONFIG!.config" "!RELEASE_SYS_CONFIG!.config" >nul || (
+          echo Cannot start release because it could not write to "!RELEASE_SYS_CONFIG!.config"
+          goto end
+        )
+      )
+
+      goto !REL_GOTO!
+    )
+
+    if "%~1" == "remote" (goto remote)
+    if "%~1" == "version" (goto version)
+    if "%~1" == "stop" (set "REL_RPC=System.stop()" && goto rpc)
+    if "%~1" == "restart" (set "REL_RPC=System.restart()" && goto rpc)
+    if "%~1" == "pid" (set "REL_RPC=IO.puts(System.pid())" && goto rpc)
+    if "%~1" == "rpc" (
+      if "%~2" == "" (
+        echo ERROR: RPC expects an expression as argument
+        exit /B 1
+      )
+      set "REL_RPC=%~2"
+      goto rpc
+    )
+
+    echo Usage: %~nx0 COMMAND [ARGS]
+    echo.
+    echo The known commands are:
+    echo.
+    echo    start        Starts the system
+    echo    start_iex    Starts the system with IEx attached
+    echo    install      Installs this system as a Windows service
+    echo    eval "EXPR"  Executes the given expression on a new, non-booted system
+    echo    rpc "EXPR"   Executes the given expression remotely on the running system
+    echo    remote       Connects to the running system via a remote shell
+    echo    restart      Restarts the running system via a remote command
+    echo    stop         Stops the running system via a remote command
+    echo    pid          Prints the operating system PID of the running system via a remote command
+    echo    version      Prints the release name and version to be booted
+    echo.
+    if not "%~1" == "" (
+      echo ERROR: Unknown command %~1
+      exit /B 1
+    )
+    goto end
+
+    :start
+    if "!RELEASE_DISTRIBUTION!" == "none" (
+      set RELEASE_DISTRIBUTION_FLAG=
+    ) else (
+      set RELEASE_DISTRIBUTION_FLAG=--!RELEASE_DISTRIBUTION! "!RELEASE_NODE!"
+    )
+
+    "!REL_VSN_DIR!\!REL_EXEC!.bat" !REL_EXTRA! ^
+      --cookie "!RELEASE_COOKIE!" ^
+      !RELEASE_DISTRIBUTION_FLAG! ^
+      --erl "<%= release_mode(@release, "!RELEASE_MODE!") %>" ^
+      --erl-config "!RELEASE_SYS_CONFIG!" ^
+      --boot "!REL_VSN_DIR!\!RELEASE_BOOT_SCRIPT!" ^
+      --boot-var RELEASE_LIB "!RELEASE_ROOT!\lib" ^
+      --vm-args "!RELEASE_VM_ARGS!"
+    goto end
+
+    :eval
+    set EVAL=%~2
+    shift
+    :loop
+    shift
+    if not "%1"=="" (
+      set args=%args% %1
+      goto :loop
+    )
+    "!REL_VSN_DIR!\elixir.bat" ^
+      --eval "!EVAL!" ^
+      --cookie "!RELEASE_COOKIE!" ^
+      --erl-config "!RELEASE_SYS_CONFIG!" ^
+      --boot "!REL_VSN_DIR!\!RELEASE_BOOT_SCRIPT_CLEAN!" ^
+      --boot-var RELEASE_LIB "!RELEASE_ROOT!\lib" ^
+      --vm-args "!RELEASE_VM_ARGS!" -- %args%
+    goto end
+
+    :remote
+    if "!RELEASE_DISTRIBUTION!" == "none" (
+      set RELEASE_DISTRIBUTION_FLAG=
+    ) else (
+      set RELEASE_DISTRIBUTION_FLAG=--!RELEASE_DISTRIBUTION! "rem-!RANDOM!-!RELEASE_NODE!"
+    )
+
+    "!REL_VSN_DIR!\iex.bat" ^
+      --hidden --cookie "!RELEASE_COOKIE!" ^
+      !RELEASE_DISTRIBUTION_FLAG! ^
+      --boot "!REL_VSN_DIR!\!RELEASE_BOOT_SCRIPT_CLEAN!" ^
+      --boot-var RELEASE_LIB "!RELEASE_ROOT!\lib" ^
+      --vm-args "!RELEASE_REMOTE_VM_ARGS!" ^
+      --remsh "!RELEASE_NODE!"
+    goto end
+
+    :rpc
+    if "!RELEASE_DISTRIBUTION!" == "none" (
+      set RELEASE_DISTRIBUTION_FLAG=
+    ) else (
+      set RELEASE_DISTRIBUTION_FLAG=--!RELEASE_DISTRIBUTION! "rpc-!RANDOM!-!RELEASE_NODE!"
+    )
+
+    "!REL_VSN_DIR!\elixir.bat" ^
+      --hidden --cookie "!RELEASE_COOKIE!" ^
+      !RELEASE_DISTRIBUTION_FLAG! ^
+      --boot "!REL_VSN_DIR!\!RELEASE_BOOT_SCRIPT_CLEAN!" ^
+      --boot-var RELEASE_LIB "!RELEASE_ROOT!\lib" ^
+      --vm-args "!RELEASE_REMOTE_VM_ARGS!" ^
+      --rpc-eval "!RELEASE_NODE!" "!REL_RPC!"
+    goto end
+
+    :version
+    echo !RELEASE_NAME! !RELEASE_VSN!
+    goto end
+
+    :install
+    if exist !RELEASE_ROOT!\erts-!ERTS_VSN! (
+      set ERLSRV=!RELEASE_ROOT!\erts-!ERTS_VSN!\bin\erlsrv.exe
+    ) else (
+      set ERLSRV=erlsrv.exe
+    )
+
+    if "!RELEASE_DISTRIBUTION!" == "none" (
+      echo ERROR: RELEASE_DISTRIBUTION is required in install command
+      exit /B 1
+    )
+
+    "!ERLSRV!" add "!RELEASE_NAME!_!RELEASE_NAME!" ^
+      -!RELEASE_DISTRIBUTION! "!RELEASE_NODE!" ^
+      -env RELEASE_ROOT="!RELEASE_ROOT!" -env RELEASE_NAME="!RELEASE_NAME!" -env RELEASE_VSN="!RELEASE_VSN!" -env RELEASE_MODE="!RELEASE_MODE!" -env RELEASE_COOKIE="!RELEASE_COOKIE!" -env RELEASE_NODE="!RELEASE_NODE!" -env RELEASE_VM_ARGS="!RELEASE_VM_ARGS!" -env RELEASE_TMP="!RELEASE_TMP!" -env RELEASE_SYS_CONFIG="!RELEASE_SYS_CONFIG!" ^
+      -args "-setcookie !RELEASE_COOKIE! -config ""!RELEASE_SYS_CONFIG!"" <%= release_mode(@release, "!RELEASE_MODE!") %> -boot ""!REL_VSN_DIR!\start"" -boot_var RELEASE_LIB ""!RELEASE_ROOT!\lib"" -args_file ""!REL_VSN_DIR!\vm.args\"""
+    if %ERRORLEVEL% EQU 0 (
+      echo Service installed but not started. From now on, it must be started and stopped by erlsrv:
+      echo.
+      echo     !ERLSRV! start !RELEASE_NAME!_!RELEASE_NAME!
+      echo     !ERLSRV! stop !RELEASE_NAME!_!RELEASE_NAME!
+      echo     !ERLSRV! remove !RELEASE_NAME!_!RELEASE_NAME!
+      echo     !ERLSRV! list
+      echo     !ERLSRV! help
+      echo.
+    )
+    goto end
+
+    :end
+    endlocal
+    """
+end
diff --git a/lib/mix/lib/mix/tasks/run.ex b/lib/mix/lib/mix/tasks/run.ex
index c4f7a8eddcf..e575fe6ae1e 100644
--- a/lib/mix/lib/mix/tasks/run.ex
+++ b/lib/mix/lib/mix/tasks/run.ex
@@ -1,101 +1,221 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.Tasks.Run do
   use Mix.Task
 
-  @shortdoc "Run the given file or expression"
+  @shortdoc "Runs the current application"
 
   @moduledoc """
-  Runs the given file or expression in the context of the application.
+  Runs the current application.
+
+  `mix run` starts the current application dependencies and the
+  application itself. The application will be compiled if it has
+  not been compiled yet or it is outdated.
+
+  `mix run` may also run code in the application context through
+  additional options. For example, to run a script within the
+  current application, you may pass a filename as argument:
+
+      $ mix run my_app_script.exs arg1 arg2 arg3
+
+  Code to be executed can also be passed inline with the `-e` option:
+
+      $ mix run -e "DbUtils.delete_old_records()" -- arg1 arg2 arg3
+
+  In both cases, the command-line arguments for the script or expression
+  are available in `System.argv/0`. This mirrors the command line interface
+  in the `elixir` executable.
+
+  For starting long running systems, one typically passes the `--no-halt`
+  option:
 
-  Before running the code, it invokes the `app.start` task which compiles
-  and loads your project.
+      $ mix run --no-halt
 
-  It is the goal of this task to provide a subset of the functionality
-  existent in the `elixir` executable, including setting up the `System.argv`:
+  The `--no-start` option can also be given and neither the current application
+  nor its dependencies will be started. Alternatively, you may use
+  `mix eval` to evaluate a single expression without starting the current
+  application.
 
-      mix run -e Hello.world
-      mix run my_script.exs arg1 arg2 arg3
+  If you need to pass options to the Elixir executable at the same time
+  you use `mix run`, it can be done as follows:
 
-  Many command line options need to be passed to the `elixir` executable
-  directly, which can be done as follows:
+      $ elixir --sname hello -S mix run --no-halt
 
-      elixir --sname hello -S mix run -e "My.code"
+  This task is automatically re-enabled, so it can be called multiple times
+  with different arguments.
 
-  ## Command line options
+  ## Command-line options
 
-    * `--config`, `-c`  - loads the given configuration file
-    * `--eval`, `-e`    - evaluate the given code
-    * `--require`, `-r` - require pattern before running the command
-    * `--parallel-require`, `-pr`
-                        - requires pattern in parallel
-    * `--no-compile`    - do not compile even if files require compilation
-    * `--no-deps-check` - do not check dependencies
-    * `--no-halt`       - do not halt the system after running the command
-    * `--no-start`      - do not start applications after compilation
+    * `--eval`, `-e` - evaluates the given code
+    * `--listeners` - starts Mix listeners (they are started by default,
+      unless `--no-listeners` or `--no-deps-check` are given)
+    * `--require`, `-r` - executes the given pattern/file
+    * `--parallel`, `-p` - makes all requires parallel
+    * `--preload-modules` - preloads all modules defined in applications
+    * `--no-archives-check` - does not check archives
+    * `--no-compile` - does not compile even if files require compilation
+    * `--no-deps-check` - does not check dependencies
+    * `--no-elixir-version-check` - does not check the Elixir version from mix.exs
+    * `--no-halt` - does not halt the system after running the command
+    * `--no-listeners` - does not start Mix listeners
+    * `--no-mix-exs` - allows the command to run even if there is no mix.exs
+    * `--no-start` - does not start applications after compilation
 
   """
+
+  @typedoc """
+  Options for the internal `run/5` function.
+
+  These options are typically parsed from command-line arguments.
+  """
+  @type run_opts :: [
+          {:parallel_require, String.t()}
+          | {:eval, String.t()}
+          | {:require, String.t()}
+          | {:parallel, boolean()}
+          | {:config, String.t()}
+        ]
+
+  @impl true
   def run(args) do
-    {opts, head, _} = OptionParser.parse_head(args,
-      aliases: [r: :require, pr: :parallel_require, e: :eval, c: :config],
-      switches: [parallel_require: :keep, require: :keep, eval: :keep, config: :keep])
+    {opts, head} =
+      OptionParser.parse_head!(
+        args,
+        aliases: [r: :require, p: :parallel, e: :eval, c: :config],
+        strict: [
+          parallel: :boolean,
+          require: :keep,
+          eval: :keep,
+          config: :keep,
+          mix_exs: :boolean,
+          halt: :boolean,
+          compile: :boolean,
+          deps_check: :boolean,
+          listeners: :boolean,
+          start: :boolean,
+          archives_check: :boolean,
+          elixir_version_check: :boolean,
+          parallel_require: :keep,
+          preload_modules: :boolean
+        ],
+        return_separator: true
+      )
+
+    run(args, opts, head, &Code.eval_string/1, &Code.require_file/1)
+    if not Keyword.get(opts, :halt, true), do: System.no_halt(true)
+    Mix.Task.reenable("run")
+    :ok
+  end
 
-    # Require the project to be available
-    Mix.Project.get!
+  @doc false
+  @spec run(
+          OptionParser.argv(),
+          run_opts,
+          OptionParser.argv(),
+          (String.t() -> term()),
+          (String.t() -> term())
+        ) :: :ok
+  def run(args, opts, head, expr_evaluator, file_evaluator) do
+    opts =
+      Enum.flat_map(opts, fn
+        {:parallel_require, value} ->
+          IO.warn(
+            "the --parallel-require option is deprecated in favour of using " <>
+              "--parallel to make all requires parallel and --require VAL for requiring"
+          )
+
+          [require: value, parallel: true]
+
+        opt ->
+          [opt]
+      end)
 
     {file, argv} =
       case {Keyword.has_key?(opts, :eval), head} do
-        {true, _}  -> {nil, head}
-        {_, [h|t]} -> {h, t}
-        {_, []}    -> {nil, []}
+        {_, ["--" | rest]} -> {nil, rest}
+        {true, _} -> {nil, head}
+        {_, [head | tail]} -> {head, tail}
+        {_, []} -> {nil, []}
       end
 
     System.argv(argv)
-    process_config opts
+    process_config(opts)
 
     # Start app after rewriting System.argv,
-    # but before requiring and evaling
-    Mix.Task.run "app.start", args
-    process_load opts
+    # but before requiring and evaling.
+    cond do
+      Mix.Project.get() ->
+        Mix.Task.run("app.start", args)
+
+      "--no-mix-exs" in args ->
+        :ok
+
+      true ->
+        Mix.raise(
+          "Cannot execute \"mix run\" without a Mix.Project, " <>
+            "please ensure you are running Mix in a directory with a mix.exs file " <>
+            "or pass the --no-mix-exs option"
+        )
+    end
+
+    process_load(opts, expr_evaluator)
 
     if file do
       if File.regular?(file) do
-        Code.require_file(file)
+        file_evaluator.(file)
       else
-        Mix.raise "No such file: #{file}"
+        Mix.raise("No such file: #{file}")
       end
     end
-    if opts[:no_halt], do: :timer.sleep(:infinity)
+
+    :ok
   end
 
   defp process_config(opts) do
-    Enum.each opts, fn
-      {:config, value} ->
-        Mix.Task.run "loadconfig", [value]
-      _ ->
-        :ok
+    for {:config, value} <- opts do
+      # TODO: Remove on v2.0.
+      IO.warn(
+        "the --config flag is deprecated. If you need to handle multiple configurations, " <>
+          "it is preferable to dynamically import them in your config files"
+      )
+
+      Mix.Tasks.Loadconfig.load_compile(value)
     end
+
+    :ok
   end
 
-  defp process_load(opts) do
-    Enum.each opts, fn
-      {:parallel_require, value} ->
-        case filter_patterns(value) do
-          [] ->
-            Mix.raise "No files matched pattern #{inspect value} given to --parallel-require"
-          filtered ->
-            Kernel.ParallelRequire.files(filtered)
+  defp process_load(opts, expr_evaluator) do
+    require_runner =
+      if opts[:parallel] do
+        fn files ->
+          case Kernel.ParallelCompiler.require(files, return_diagnostics: true) do
+            {:ok, _, _} -> :ok
+            {:error, _, _} -> exit({:shutdown, 1})
+          end
         end
+      else
+        fn files -> Enum.each(files, &Code.require_file/1) end
+      end
+
+    Enum.each(opts, fn
       {:require, value} ->
         case filter_patterns(value) do
           [] ->
-            Mix.raise "No files matched pattern #{inspect value} given to --require"
+            Mix.raise("No files matched pattern #{inspect(value)} given to --require")
+
           filtered ->
-            Enum.each(filtered, &Code.require_file(&1))
+            require_runner.(filtered)
         end
+
       {:eval, value} ->
-        Code.eval_string(value)
+        expr_evaluator.(value)
+
       _ ->
         :ok
-    end
+    end)
   end
 
   defp filter_patterns(pattern) do
diff --git a/lib/mix/lib/mix/tasks/test.coverage.ex b/lib/mix/lib/mix/tasks/test.coverage.ex
new file mode 100644
index 00000000000..ed3579be3f6
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/test.coverage.ex
@@ -0,0 +1,411 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Test.Coverage do
+  use Mix.Task
+
+  @moduledoc """
+  Build reports from exported test coverage.
+
+  In this moduledoc, we will describe how the default test
+  coverage works in Elixir and also explore how it is capable
+  of exporting coverage results to group reports from multiple
+  test runs.
+
+  ## Line coverage
+
+  Elixir uses Erlang's [`:cover`](`:cover`) for its default test coverage.
+  Erlang coverage is done by tracking *executable lines of code*.
+  This implies blank lines, code comments,
+  function signatures, and patterns are not necessarily executable and
+  therefore won't be tracked in coverage reports. Code in macros are
+  also often executed at compilation time, and therefore may not be covered.
+  Similarly, Elixir AST literals, such as atoms, are not executable either.
+
+  Let's see an example:
+
+      if some_condition? do
+        do_this()
+      else
+        do_that()
+      end
+
+  In the example above, if your tests exercise both `some_condition? == true`
+  and `some_condition? == false`, all branches will be covered, as they all
+  have executable code. However, the following code
+
+      if some_condition? do
+        do_this()
+      else
+        :default
+      end
+
+  won't ever mark the `:default` branch as covered, as there is no executable
+  code in the `else` branch. Note, however, this issue does not happen on `case`
+  or `cond`, as Elixir is able to mark the clause operator `->` as executable in
+  such corner cases:
+
+      case some_condition? do
+        true ->
+          do_this()
+
+        false ->
+          :default
+      end
+
+  If the code above is tested with both conditions, you should see entries
+  in both branches marked as covered.
+
+  Finally, it is worth discussing that line coverage by itself has its own
+  limitations. For example, take the following code:
+
+      do_this() || do_that()
+
+  Line coverage is not capable of expressing that both `do_this()` and
+  `do_that()` have been executed, since as soon as `do_this()` is executed,
+  the whole line is covered. Other techniques, such as branch coverage,
+  can help spot those cases, but they are not currently supported by the
+  default coverage tool.
+
+  Overall, code coverage can be a great tool for finding flaws in our
+  code (such as functions that haven't been covered) but it can also lead
+  teams into a false sense of security since 100% coverage never means all
+  different executions flows have been asserted, even with the most advanced
+  coverage techniques. It is up to you and your team to specify how much
+  emphasis you want to place on it.
+
+  ## Exporting coverage
+
+  This task can be used when you need to group the coverage
+  across multiple test runs. Let's see some examples.
+
+  ### Example: aggregating partitioned runs
+
+  If you partition your tests across multiple runs,
+  you can unify the report as shown below:
+
+      $ MIX_TEST_PARTITION=1 mix test --partitions 2 --cover
+      $ MIX_TEST_PARTITION=2 mix test --partitions 2 --cover
+      $ mix test.coverage
+
+  This works because the `--partitions` option
+  automatically exports the coverage results.
+
+  ### Example: aggregating coverage reports from all umbrella children
+
+  If you run `mix test.coverage` inside an umbrella,
+  it will automatically gather exported cover results
+  from all umbrella children - as long as the coverage
+  results have been exported, like this:
+
+      # from the umbrella root
+      $ mix test --cover --export-coverage default
+      $ mix test.coverage
+
+  Of course, if you want to actually partition the tests,
+  you can also do:
+
+      # from the umbrella root
+      $ MIX_TEST_PARTITION=1 mix test --partitions 2 --cover
+      $ MIX_TEST_PARTITION=2 mix test --partitions 2 --cover
+      $ mix test.coverage
+
+  On the other hand, if you want partitioned tests but
+  per-app reports, you can do:
+
+      # from the umbrella root
+      $ MIX_TEST_PARTITION=1 mix test --partitions 2 --cover
+      $ MIX_TEST_PARTITION=2 mix test --partitions 2 --cover
+      $ mix cmd mix test.coverage
+
+  When running `test.coverage` from the umbrella root, it
+  will use the `:test_coverage` configuration from the umbrella
+  root.
+
+  Finally, note the coverage itself is not measured across
+  the projects themselves. For example, if project B depends
+  on A, and if there is code in A that is only executed from
+  project B, those lines will not be marked as covered, which
+  is important, as those projects should be developed and tested
+  in isolation.
+
+  ### Other scenarios
+
+  There may be other scenarios where you want to export coverage.
+  For example, you may have broken your test suite into two, one
+  for unit tests and another for integration tests. In such scenarios,
+  you can explicitly use the `--export-coverage` command line option,
+  or the `:export` option under `:test_coverage` in your `mix.exs` file.
+  """
+
+  @shortdoc "Build report from exported test coverage"
+  @default_threshold 90
+
+  @doc false
+  def run(_args) do
+    Mix.Task.run("compile")
+    Mix.ensure_application!(:tools)
+    config = Mix.Project.config()
+    test_coverage = config[:test_coverage] || []
+    {cover_paths, compile_paths} = apps_paths(config, test_coverage)
+    pid = cover_compile(compile_paths)
+
+    case Enum.flat_map(cover_paths, &Path.wildcard(Path.join(&1, "*.coverdata"))) do
+      [] ->
+        Mix.shell().error(
+          "Could not find .coverdata file in any of the paths: " <>
+            Enum.join(cover_paths, ", ")
+        )
+
+      entries ->
+        for entry <- entries do
+          Mix.shell().info("Importing cover results: #{entry}")
+          :ok = :cover.import(String.to_charlist(entry))
+        end
+
+        # Silence analyse import messages emitted by cover
+        {:ok, string_io} = StringIO.open("")
+        Process.group_leader(pid, string_io)
+        Mix.shell().info("")
+        generate_cover_results(test_coverage)
+    end
+  end
+
+  defp apps_paths(config, test_coverage) do
+    output = Keyword.get(test_coverage, :output, "cover")
+
+    if apps_paths = Mix.Project.apps_paths(config) do
+      build_path = Mix.Project.build_path(config)
+      apps_paths = Enum.sort(apps_paths)
+
+      compile_paths =
+        Enum.map(apps_paths, fn {app, _} ->
+          Path.join([build_path, "lib", Atom.to_string(app), "ebin"])
+        end)
+
+      {Enum.map(apps_paths, fn {_, path} -> Path.join(path, output) end), compile_paths}
+    else
+      {[output], [Mix.Project.compile_path(config)]}
+    end
+  end
+
+  @doc false
+  def start(compile_path, opts) do
+    Mix.shell().info("Cover compiling modules ...")
+    Mix.ensure_application!(:tools)
+
+    if Keyword.get(opts, :local_only, true) do
+      :cover.local_only()
+    end
+
+    cover_compile([compile_path])
+
+    if name = opts[:export] do
+      fn ->
+        Mix.shell().info("\nExporting cover results ...\n")
+        export_cover_results(name, opts)
+      end
+    else
+      fn ->
+        Mix.shell().info("\nGenerating cover results ...\n")
+        generate_cover_results(opts)
+      end
+    end
+  end
+
+  defp cover_compile(compile_paths) do
+    _ = :cover.stop()
+    {:ok, pid} = :cover.start()
+
+    for compile_path <- compile_paths do
+      case :cover.compile_beam(beams(compile_path)) do
+        results when is_list(results) ->
+          :ok
+
+        {:error, reason} ->
+          Mix.raise(
+            "Failed to cover compile directory #{inspect(Path.relative_to_cwd(compile_path))} " <>
+              "with reason: #{inspect(reason)}"
+          )
+      end
+    end
+
+    pid
+  end
+
+  # Pick beams from the compile_path but if by any chance it is a protocol,
+  # gets its path from the code server (which will most likely point to
+  # the consolidation directory as long as it is enabled).
+  defp beams(dir) do
+    consolidation_dir = Mix.Project.consolidation_path()
+
+    consolidated =
+      case File.ls(consolidation_dir) do
+        {:ok, files} -> files
+        _ -> []
+      end
+
+    for file <- File.ls!(dir), Path.extname(file) == ".beam" do
+      with true <- file in consolidated,
+           [_ | _] = path <- :code.which(file |> Path.rootname() |> String.to_atom()) do
+        path
+      else
+        _ -> String.to_charlist(Path.join(dir, file))
+      end
+    end
+  end
+
+  defp export_cover_results(name, opts) do
+    output = Keyword.get(opts, :output, "cover")
+    File.mkdir_p!(output)
+
+    case :cover.export(~c"#{output}/#{name}.coverdata") do
+      :ok ->
+        Mix.shell().info("Run \"mix test.coverage\" once all exports complete")
+
+      {:error, reason} ->
+        Mix.shell().error("Export failed with reason: #{inspect(reason)}")
+    end
+  end
+
+  @doc false
+  def generate_cover_results(opts) do
+    {:result, ok, _fail} = :cover.analyse(:coverage, :line)
+    ignore = opts[:ignore_modules] || []
+    modules = Enum.reject(:cover.modules(), &ignored?(&1, ignore))
+
+    if summary_opts = Keyword.get(opts, :summary, true) do
+      summary(ok, modules, summary_opts)
+    end
+
+    html(modules, opts)
+  end
+
+  defp ignored?(mod, ignores) do
+    Enum.any?(ignores, &ignored_any?(mod, &1))
+  end
+
+  defp ignored_any?(mod, %Regex{} = re), do: Regex.match?(re, inspect(mod))
+  defp ignored_any?(mod, other), do: mod == other
+
+  defp html(modules, opts) do
+    output = Keyword.get(opts, :output, "cover")
+    File.mkdir_p!(output)
+
+    modules
+    |> Enum.map(fn mod ->
+      pid = :cover.async_analyse_to_file(mod, ~c"#{output}/#{mod}.html", [:html])
+      Process.monitor(pid)
+    end)
+    |> Enum.each(fn ref ->
+      receive do
+        {:DOWN, ^ref, :process, _pid, _reason} ->
+          :ok
+      end
+    end)
+
+    Mix.shell().info("Generated HTML coverage results in #{inspect(output)} directory")
+  end
+
+  defp summary(results, keep, summary_opts) do
+    {module_results, totals} = gather_coverage(results, keep)
+    module_results = Enum.sort(module_results, :desc)
+    print_summary(module_results, totals, summary_opts)
+
+    if totals < get_threshold(summary_opts) do
+      print_failed_threshold(totals, get_threshold(summary_opts))
+      System.at_exit(fn _ -> exit({:shutdown, 3}) end)
+    end
+
+    :ok
+  end
+
+  defp gather_coverage(results, keep) do
+    keep_set = MapSet.new(keep)
+
+    # When gathering coverage results, we need to skip any
+    # entry with line equal to 0 as those are generated code.
+    #
+    # We may also have multiple entries on the same line.
+    # Each line is only considered once.
+    #
+    # We use ETS for performance, to avoid working with nested maps.
+    table = :ets.new(__MODULE__, [:set, :private])
+
+    try do
+      for {{module, line}, cov} <- results, module in keep_set, line != 0 do
+        case cov do
+          {1, 0} -> :ets.insert(table, {{module, line}, true})
+          {0, 1} -> :ets.insert_new(table, {{module, line}, false})
+        end
+      end
+
+      module_results = for module <- keep, do: {read_cover_results(table, module), module}
+      {module_results, read_cover_results(table, :_)}
+    after
+      :ets.delete(table)
+    end
+  end
+
+  defp read_cover_results(table, module) do
+    covered = :ets.select_count(table, [{{{module, :_}, true}, [], [true]}])
+    not_covered = :ets.select_count(table, [{{{module, :_}, false}, [], [true]}])
+    percentage(covered, not_covered)
+  end
+
+  defp percentage(0, 0), do: 100.0
+  defp percentage(covered, not_covered), do: covered / (covered + not_covered) * 100
+
+  defp print_summary(results, totals, true), do: print_summary(results, totals, [])
+
+  defp print_summary(results, totals, opts) when is_list(opts) do
+    threshold = get_threshold(opts)
+
+    results =
+      results |> Enum.sort() |> Enum.map(fn {coverage, module} -> {coverage, inspect(module)} end)
+
+    name_max_length = results |> Enum.map(&String.length(elem(&1, 1))) |> Enum.max() |> max(10)
+    name_separator = String.duplicate("-", name_max_length)
+
+    Mix.shell().info("| Percentage | #{String.pad_trailing("Module", name_max_length)} |")
+    Mix.shell().info("|------------|-#{name_separator}-|")
+    Enum.each(results, &display(&1, threshold, name_max_length))
+    Mix.shell().info("|------------|-#{name_separator}-|")
+    display({totals, "Total"}, threshold, name_max_length)
+    Mix.shell().info("")
+  end
+
+  defp print_failed_threshold(totals, threshold) do
+    Mix.shell().info("Coverage test failed, threshold not met:\n")
+    Mix.shell().info("    Coverage:  #{format_number(totals, 6)}%")
+    Mix.shell().info("    Threshold: #{format_number(threshold, 6)}%")
+    Mix.shell().info("")
+  end
+
+  defp display({percentage, name}, threshold, pad_length) do
+    Mix.shell().info([
+      "| ",
+      color(percentage, threshold),
+      format_number(percentage, 9),
+      "%",
+      :reset,
+      " | ",
+      String.pad_trailing(name, pad_length),
+      " |"
+    ])
+  end
+
+  defp color(percentage, true), do: color(percentage, @default_threshold)
+  defp color(_, false), do: ""
+  defp color(percentage, threshold) when percentage >= threshold, do: :green
+  defp color(_, _), do: :red
+
+  defp format_number(number, length) when is_integer(number),
+    do: format_number(number / 1, length)
+
+  defp format_number(number, length), do: :io_lib.format("~#{length}.2f", [number])
+
+  defp get_threshold(true), do: @default_threshold
+  defp get_threshold(opts), do: Keyword.get(opts, :threshold, @default_threshold)
+end
diff --git a/lib/mix/lib/mix/tasks/test.ex b/lib/mix/lib/mix/tasks/test.ex
index ab3d1cf7636..c37fdce9e4c 100644
--- a/lib/mix/lib/mix/tasks/test.ex
+++ b/lib/mix/lib/mix/tasks/test.ex
@@ -1,248 +1,1079 @@
-defmodule Mix.Tasks.Test do
-  defmodule Cover do
-    @moduledoc false
-
-    def start(compile_path, opts) do
-      Mix.shell.info "Cover compiling modules ... "
-      :cover.start
-      :cover.compile_beam_directory(compile_path |> to_char_list)
-      output = opts[:output]
-
-      fn() ->
-        Mix.shell.info "\nGenerating cover results ... "
-        File.mkdir_p!(output)
-        Enum.each :cover.modules, fn(mod) ->
-          :cover.analyse_to_file(mod, '#{output}/#{mod}.html', [:html])
-        end
-      end
-    end
-  end
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
+defmodule Mix.Tasks.Test do
   use Mix.Task
 
-  @shortdoc "Run a project's tests"
+  alias Mix.Compilers.Test, as: CT
+
+  @compile {:no_warn_undefined, [IEx, ExUnit, ExUnit.Filters]}
+  @shortdoc "Runs a project's tests"
   @recursive true
 
-  @moduledoc """
-  Run the tests for a project.
+  @moduledoc ~S"""
+  Runs the tests for a project.
 
   This task starts the current application, loads up
-  `test/test_helper.exs` and then requires all files matching the
-  `test/**/_test.exs` pattern in parallel.
+  `test/test_helper.exs` and then, requires all files matching the
+  `test/**/*_test.exs` pattern in parallel.
+
+  A list of files and/or directories can be given after the task
+  name in order to select the files to run:
+
+      $ mix test test/some/particular/file_test.exs
+      $ mix test test/some/particular/dir
+
+  Tests in umbrella projects can be run from the root by specifying
+  the full suite path, including `apps/my_app/test`, in which case
+  recursive tests for other child apps will be skipped completely:
+
+      # To run all tests for my_app from the umbrella root
+      $ mix test apps/my_app/test
+
+      # To run a given test file on my_app from the umbrella root
+      $ mix test apps/my_app/test/some/particular/file_test.exs
+
+  ## Understanding test results
+
+  When you run your test suite, it prints results as they run with
+  a summary at the end, as seen below:
+
+      $ mix test
+      Running ExUnit with seed: 646219, max_cases: 16
+      ...
+
+        1) test greets the world (FooTest)
+           test/foo_test.exs:5
+           Assertion with == failed
+           code:  assert Foo.hello() == :world!
+           left:  :world
+           right: :world!
+           stacktrace:
+             test/foo_test.exs:6: (test)
+
+      ........
 
-  A list of files can be given after the task name in order to select
-  the files to compile:
+      Finished in 0.05 seconds (0.00s async, 0.05s sync)
+      1 doctest, 11 tests, 1 failure
 
-      mix test test/some/particular/file_test.exs
+  For each test, the test suite will print a dot. Failed tests
+  are printed immediately in the format described in the next
+  section.
+
+  After all tests run, we print the suite summary. The first
+  line contains the total time spent on the suite, followed
+  by how much time was spent on async tests (defined with
+  `use ExUnit.Case, async: true`) vs sync ones:
+
+      Finished in 0.05 seconds (0.00s async, 0.05s sync)
+
+  Developers want to minimize the time spent on sync tests
+  whenever possible, as sync tests run serially and async
+  tests run concurrently.
+
+  Finally, how many tests we have run, how many of them
+  failed, how many were invalid, and so on.
+
+  ### Understanding test failures
+
+  First, it contains the failure counter, followed by the test
+  name and the module the test was defined:
+
+      1) test greets the world (FooTest)
+
+  The next line contains the exact location of the test in the
+  `FILE:LINE` format:
+
+      test/foo_test.exs:5
+
+  If you want to re-run only this test, all you need to do is to
+  copy the line above and paste it in front of `mix test`:
+
+      $ mix test test/foo_test.exs:5
+
+  Then we show the error message, code snippet, and general information
+  about the failed test:
+
+      Assertion with == failed
+      code:  assert Foo.hello() == :world!
+      left:  :world
+      right: :world!
+
+  If your terminal supports coloring (see the  "Coloring" section below),
+  a diff is typically shown between `left` and `right` sides. Finally,
+  we print the stacktrace of the failure:
+
+      stacktrace:
+        test/foo_test.exs:6: (test)
 
   ## Command line options
 
-    * `--trace`      - run tests with detailed reporting; automatically sets `--max-cases` to 1
-    * `--max-cases`  - set the maximum number of cases running async
-    * `--cover`      - the directory to include coverage results
-    * `--force`      - forces compilation regardless of modification times
-    * `--no-compile` - do not compile, even if files require compilation
-    * `--no-start`   - do not start applications after compilation
-    * `--no-color`   - disable color in the output
-    * `--include`    - include tests that match the filter
-    * `--exclude`    - exclude tests that match the filter
-    * `--only`       - run only tests that match the filter
-    * `--seed`       - seeds the random number generator used to randomize tests order
-
-  ## Filters
-
-  ExUnit provides tags and filtering functionality that allows developers
+    * `--all-warnings` (`--no-all-warnings`) - prints all warnings, including previous compilations
+      (default is true except on errors)
+
+    * `-b`, `--breakpoints` *(since v1.17.0)* - sets a breakpoint at the beginning
+      of every test. The debugger goes line-by-line and can access all variables
+      and imports (but not local functions). You can press `n` for the next line
+      and `c` for the next test. This automatically sets `--trace`
+
+    * `--color` - enables color in ExUnit formatting results
+
+    * `--cover` - runs coverage tool. See "Coverage" section below
+
+    * `--dry-run` *(since v1.19.0)* - prints which tests would be run based on current options,
+      but does not actually run any tests. This combines with all other options
+      like `--stale`, `--only`, `--exclude`, and so on.
+
+    * `--exclude` - excludes tests that match the filter. This option may be given
+      several times to apply different filters, such as `--exclude ci --exclude slow`.
+      A value can also be provided for the filter such as `--exclude async:true` to only
+      run the sync tests.
+
+    * `--exit-status` - use an alternate exit status to use when the test suite
+      fails (default is 2).
+
+    * `--export-coverage` - the name of the file to export coverage results to.
+      Only has an effect when used with `--cover`
+
+    * `--failed` - runs only tests that failed the last time they ran
+
+    * `--force` - forces compilation regardless of modification times
+
+    * `--formatter` - sets the formatter module that will print the results.
+      Defaults to ExUnit's built-in CLI formatter
+
+    * `--include` - includes tests that match the filter. This option may be given
+      several times to apply different filters, such as `--include ci --include slow`
+
+    * `--listen-on-stdin` - runs tests, and then listens on stdin. It will
+      re-run tests once a newline is received. See the "File system watchers"
+      section below
+
+    * `--max-cases` - sets the maximum number of tests running asynchronously. Only tests from
+      different modules run in parallel. Defaults to twice the number of cores
+
+    * `--max-failures` - the suite stops evaluating tests when this number of test
+      failures is reached. It runs all tests if omitted
+
+    * `--max-requires` - sets the maximum number of test files to compile in parallel.
+      Setting this to `1` will compile test files sequentially.
+
+    * `-n`, `--name-pattern` *(since v1.19.0)* - only run tests with names that match
+      the given regular expression
+
+    * `--no-archives-check` - does not check archives
+
+    * `--no-color` - disables color in the output
+
+    * `--no-compile` - does not compile, even if files require compilation
+
+    * `--no-deps-check` - does not check dependencies
+
+    * `--no-elixir-version-check` - does not check the Elixir version from `mix.exs`
+
+    * `--no-start` - does not start applications after compilation
+
+    * `--only` - runs only tests that match the filter. Such as `--only ci`. A value
+      can also be provided for the filter such as `--only async:true` to only
+      run the async tests.
+
+    * `--partitions` - sets the amount of partitions to split tests in. It must be
+      a number greater than zero. If set to one, it acts a no-op. If more than one,
+      then you must also set the `MIX_TEST_PARTITION` environment variable with the
+      partition to use in the current test run. See the "Operating system process
+      partitioning" section for more information
+
+    * `--preload-modules` - preloads all modules defined in applications
+
+    * `--profile-require time` - profiles the time spent to require test files.
+      Used only for debugging. The test suite does not run
+
+    * `--raise` - immediately raises if the test suite fails, instead of continuing
+      the execution of other Mix tasks
+
+    * `--repeat-until-failure` *(since v1.17.0)* - sets the number of repetitions for running
+      the suite until it fails. This is useful for debugging flaky tests within the same instance
+      of the Erlang VM. For example, `--repeat-until-failure 10000` repeats the test suite
+      up to 10 000 times until the first failure. This can be combined with `--max-failures 1`
+      to immediately stop if one test fails. However, if there is any leftover global state
+      after running the tests, re-running the suite may trigger unrelated failures.
+
+    * `--seed` - seeds the random number generator used to randomize the order of tests;
+      `--seed 0` disables randomization so the tests in a single file will always be ran
+      in the same order they were defined in
+
+    * `--slowest` - prints timing information for the N slowest tests. Includes time spent in
+     `ExUnit.Callbacks.setup/1`. Automatically sets `--trace` and `--preload-modules`
+
+    * `--slowest-modules` *(since v1.17.0)* - prints timing information for the N slowest
+      modules. Includes time spent in `ExUnit.Callbacks.setup/1`. Automatically sets
+      `--trace` and `--preload-modules`
+
+    * `--stale` - runs only tests which reference modules that changed since the
+      last time tests were ran with `--stale`. You can read more about this option
+      in the "The --stale option" section below
+
+    * `--timeout` - sets the timeout for the tests
+
+    * `--trace` - runs tests with detailed reporting. Automatically sets `--max-cases` to `1`.
+      Note that in trace mode test timeouts will be ignored as timeout is set to `:infinity`
+
+    * `--warnings-as-errors` *(since v1.12.0)* - treats compilation warnings (from loading the
+      test suite) as errors and returns an exit status of 1 if the test suite would otherwise
+      pass. If the test suite fails and also include warnings as errors, the exit
+      status returned will be the value of the `--exit-status` option, which
+      defaults to `2`, plus one. Therefore in the default case, this will be exit status `3`.
+
+      Note that failures reported by `--warnings-as-errors` cannot be retried with the
+      `--failed` flag.
+
+      This option only applies to test files. To treat warnings as errors during compilation and
+      during tests, run:
+          MIX_ENV=test mix do compile --warnings-as-errors + test --warnings-as-errors
+
+  ## Configuration
+
+  These configurations can be set in the `def project` section of your `mix.exs`:
+
+    * `:test_coverage` - a set of options to be passed down to the coverage
+      mechanism. See the "Coverage" section for more information
+
+    * `:test_elixirc_options` - the compiler options to used when
+      loading/compiling test files. By default it disables the debug chunk,
+      docs chunk, and module type inference
+
+    * `:test_paths` - list of paths containing test files. Defaults to
+      `["test"]` if the `test` directory exists, otherwise, it defaults to `[]`.
+      It is expected that all test paths contain a `test_helper.exs` file
+
+    * `:test_pattern` - a pattern to find potential test files. Defaults to `"*.{ex,exs}"`.
+
+      Once files are found, they are filtered in two ways:
+
+        * Files that match `:test_load_filters` are loaded
+        * Files that match `:test_ignore_filters` are ignored
+        * All other files emit a warning
+
+      In Elixir versions earlier than 1.19.0, this option defaulted to `*_test.exs`.
+
+    * `:test_load_filters` - a list of files, regular expressions or one-arity
+      functions to restrict which files matched by the `:test_pattern` are loaded.
+      Defaults to `[&String.ends_with?(&1, "_test.exs")]`. Paths are relative to
+      the project root and separated by `/`, even on Windows.
+
+    * `:test_ignore_filters` - a list of files, regular expressions or one-arity
+      functions to ignore by the loader. Any file that is not loaded and not
+      ignored will emit a warning.
+
+      Mix ignores files ending in `_helper.exs` by default, as well as any file
+      included in the project's `:elixirc_paths`. You may choose to disable all
+      warnings by ignoring all files with `[fn _ -> true end]`.
+
+      Paths are relative to the project root and separated by `/`, even on Windows.
+
+  ## Coloring
+
+  Coloring is enabled by default on most Unix terminals. They are also
+  available on Windows consoles from Windows 10, although it must be
+  explicitly enabled for the current user in the registry by running
+  the following command:
+
+      $ reg add HKCU\Console /v VirtualTerminalLevel /t REG_DWORD /d 1
+
+  After running the command above, you must restart your current console.
+
+  ## Tags and filters
+
+  ExUnit provides tags and filtering functionality that allow developers
   to select which tests to run. The most common functionality is to exclude
   some particular tests from running by default in your test helper file:
 
       # Exclude all external tests from running
-      ExUnit.configure exclude: [external: true]
+      ExUnit.configure(exclude: [external: true])
 
   Then, whenever desired, those tests could be included in the run via the
-  `--include` flag:
+  `--include` option:
 
-      mix test --include external:true
+      $ mix test --include external:true
 
-  The example above will run all tests that have the external flag set to
-  true. It is also possible to include all examples that have a given tag,
+  The example above will run all tests that have the external option set to
+  `true`. It is also possible to include all examples that have a given tag,
   regardless of its value:
 
-      mix test --include external
+      $ mix test --include external
 
   Note that all tests are included by default, so unless they are excluded
-  first (either in the test helper or via the `--exclude` option), the
-  `--include` flag has no effect.
+  first (either in the test helper or via the `--exclude` option) the
+  `--include` option has no effect. The order in which filters are applied
+  is also consistent: first all exclusions are computed, then the inclusions.
 
-  For this reason, mix also provides an `--only` option that excludes all
-  tests and includes only the given ones:
+  For convenience, Mix also provides an `--only` option that excludes all tests
+  and includes only the given ones:
 
-      mix test --only external
+      $ mix test --only external
 
-  Which is equivalent to:
+  Which is similar to:
 
-      mix test --include external --exclude test
+      $ mix test --include external --exclude test
 
-  In case a single file is being tested, it is possible pass a specific
-  line number:
+  However, when the `--only` option is used and no tests run, the test run fails.
 
-      mix test test/some/particular/file_test.exs:12
+  In case a single file is being tested, it is possible to pass one or more specific
+  line numbers to run only those given tests:
+
+      $ mix test test/some/particular/file_test.exs:12
 
   Which is equivalent to:
 
-      mix test --only line:12 test/some/particular/file_test.exs
+      $ mix test --exclude test --include line:12 test/some/particular/file_test.exs
 
-  ## Configuration
+  Or:
 
-    * `:test_paths` - list of paths containing test files, defaults to
-      `["test"]`. It is expected all test paths to contain a `test_helper.exs`
-      file.
+      $ mix test test/some/particular/file_test.exs:12:24
 
-    * `:test_pattern` - a pattern to load test files, defaults to `*_test.exs`.
+  Which is equivalent to:
 
-    * `:test_coverage` - a set of options to be passed down to the coverage
-      mechanism.
+      $ mix test --exclude test --include line:12 --include line:24 test/some/particular/file_test.exs
+
+  If a given line starts a `describe` block, that line filter includes all tests
+  within the describe. Otherwise, it runs the closest test on or before the given
+  line number.
 
   ## Coverage
 
-  The `:test_coverage` configuration accepts the following options:
+  Elixir provides built-in line-based test coverage via the `--cover` flag.
+  The test coverages shows which lines of code and in which files were executed
+  during the test run.
+
+  ### Limitations
+
+  Coverage in Elixir has the following limitations:
+
+    * Literals, such as atoms, strings, and numbers, are not traced by coverage.
+      For example, if a function simply returns `:ok`, the atom `:ok` itself is
+      never taken into account by coverage;
 
-    * `:output` - the output for cover results, defaults to `"cover"`
-    * `:tool`   - the coverage tool
+    * Macros, such as the ones defined by `defmacro/2` and `defguard/2`, and code
+      invoked only by macros are never considered as covered, unless they are also
+      invoked during the tests themselves. That's because macros are invoked at
+      compilation time, before the test coverage instrumentation begins;
 
-  By default, a very simple wrapper around OTP's `cover` is used as a tool,
-  but it can be overridden as follows:
+  ### Configuration
 
-      test_coverage: [tool: CoverModule]
+  The `:test_coverage` configures the coverage tool and accepts the following options:
+
+    * `:output` - the output directory for cover results. Defaults to `"cover"`.
+
+    * `:tool` - a module specifying the coverage tool to use.
+
+    * `:summary` - at the end of each coverage run, a summary of each
+      module is printed, with results in red or green depending on whether
+      the percentage is below or above a given threshold. The task will
+      exit with status of 1 if the total coverage is below the threshold.
+      The `:summary` option allows you to customize the summary generation
+      and defaults to `[threshold: 90]`, but it may be set to `false` to
+      disable such reports.
+
+    * `:export` - a filename to export results to instead of generating
+      the coverage result on the fly. The `.coverdata` extension is
+      automatically added to the given file. This option is automatically
+      set via the `--export-coverage` option or when using process partitioning.
+      See `mix test.coverage` to compile a report from multiple exports.
+
+    * `:ignore_modules` - modules to ignore from generating reports and
+      in summaries. It is a list of module names as atoms and regular
+      expressions that are matched against the module names.
+
+    * `:local_only` - by default coverage only tracks local calls,
+      set this option to false if you plan to run coverage across nodes.
+
+  By default, a wrapper around OTP's `cover` is used as the default coverage
+  tool. You can learn more about how it works in the docs for
+  `mix test.coverage`. Your tool of choice can be given as follows:
+
+      def project() do
+        [
+          ...
+          test_coverage: [tool: CoverModule]
+          ...
+        ]
+      end
 
   `CoverModule` can be any module that exports `start/2`, receiving the
-  compilation path and the `test_coverage` options as arguments. It must
-  return an anonymous function of zero arity that will be run after the
-  test suite is done or nil.
+  compilation path and the `test_coverage` options as arguments.
+  It must return either `nil` or an anonymous function of zero arity that
+  will run after the test suite is done.
+
+  ## Operating system process partitioning
+
+  While ExUnit supports the ability to run tests concurrently within the same
+  Elixir instance, it is not always possible to run all tests concurrently. For
+  example, some tests may rely on global resources.
+
+  For this reason, `mix test` supports partitioning the test files across
+  different Elixir instances. This is done by setting the `--partitions` option
+  to an integer, with the number of partitions, and setting the `MIX_TEST_PARTITION`
+  environment variable to control which test partition that particular instance
+  is running. This can also be useful if you want to distribute testing across
+  multiple machines.
+
+  For example, to split a test suite into 4 partitions and run them, you would
+  use the following commands:
+
+      $ MIX_TEST_PARTITION=1 mix test --partitions 4
+      $ MIX_TEST_PARTITION=2 mix test --partitions 4
+      $ MIX_TEST_PARTITION=3 mix test --partitions 4
+      $ MIX_TEST_PARTITION=4 mix test --partitions 4
+
+  The test files are sorted upfront in a round-robin fashion. Note the partition
+  itself is given as an environment variable so it can be accessed in config files
+  and test scripts. For example, it can be used to setup a different database instance
+  per partition in `config/test.exs`.
+
+  If partitioning is enabled and `--cover` is used, no cover reports are generated,
+  as they only contain a subset of the coverage data. Instead, the coverage data
+  is exported to files such as `cover/MIX_TEST_PARTITION.coverdata`. Once you have
+  the results of all partitions inside `cover/`, you can run `mix test.coverage` to
+  get the unified report.
+
+  ## The --stale option
+
+  The `--stale` command line option attempts to run only the test files which
+  reference modules that have changed since the last time you ran this task with
+  `--stale`.
+
+  The first time this task is run with `--stale`, all tests are run and a manifest
+  is generated. On subsequent runs, a test file is marked "stale" if any modules it
+  references (and any modules those modules reference, recursively) were modified
+  since the last run with `--stale`. A test file is also marked "stale" if it has
+  been changed since the last run with `--stale`.
+
+  The `--stale` option is extremely useful for software iteration, allowing you to
+  run only the relevant tests as you perform changes to the codebase.
+
+  ## File-system watchers
+
+  You can integrate `mix test` with file system watchers through the command line
+  via the `--listen-on-stdin` option. For example, you can use [fswatch](https://github.com/emcrisostomo/fswatch)
+  or similar to emit newlines whenever there is a change, which will cause your test
+  suite to re-run:
+
+      $ fswatch lib test | mix test --listen-on-stdin
+
+  This can be combined with the `--stale` option to re-run only the test files that
+  have changed as well as the tests that have gone stale due to changes in `lib`.
+
+  ## Aborting the suite
+
+  It is possible to abort the test suite with `Ctrl+\ `, which sends a SIGQUIT
+  signal to the Erlang VM. ExUnit will intercept this signal to show all tests
+  that have been aborted and print the results collected so far.
+
+  This can be useful in case the suite gets stuck and you don't want to wait
+  until the timeout times passes (which defaults to 30 seconds).
   """
 
-  @switches [force: :boolean, color: :boolean, cover: :boolean,
-             trace: :boolean, max_cases: :integer, include: :keep,
-             exclude: :keep, seed: :integer, only: :keep]
+  @switches [
+    all_warnings: :boolean,
+    breakpoints: :boolean,
+    force: :boolean,
+    color: :boolean,
+    cover: :boolean,
+    export_coverage: :string,
+    trace: :boolean,
+    max_cases: :integer,
+    max_failures: :integer,
+    max_requires: :integer,
+    include: :keep,
+    exclude: :keep,
+    seed: :integer,
+    name_pattern: :regex,
+    only: :keep,
+    compile: :boolean,
+    start: :boolean,
+    timeout: :integer,
+    raise: :boolean,
+    deps_check: :boolean,
+    archives_check: :boolean,
+    elixir_version_check: :boolean,
+    failed: :boolean,
+    stale: :boolean,
+    listen_on_stdin: :boolean,
+    formatter: :keep,
+    slowest: :integer,
+    slowest_modules: :integer,
+    partitions: :integer,
+    preload_modules: :boolean,
+    warnings_as_errors: :boolean,
+    profile_require: :string,
+    exit_status: :integer,
+    repeat_until_failure: :integer,
+    dry_run: :boolean
+  ]
 
-  @cover [output: "cover", tool: Cover]
+  @aliases [b: :breakpoints, n: :name_pattern]
 
+  @cover [output: "cover", tool: Mix.Tasks.Test.Coverage]
+
+  @impl true
   def run(args) do
-    {opts, files, _} = OptionParser.parse(args, switches: @switches)
+    {opts, files} = OptionParser.parse!(args, strict: @switches, aliases: @aliases)
+
+    if not Mix.Task.recursing?() do
+      do_run(opts, args, files)
+    else
+      parent_umbrella = Path.dirname(Mix.Project.parent_umbrella_project_file())
+
+      {files_in_apps_path, files_not_in_apps_path} =
+        files
+        |> Enum.map(&Path.expand(&1, parent_umbrella))
+        |> Enum.map(&Path.relative_to(&1, parent_umbrella))
+        |> Enum.split_with(&String.starts_with?(&1, "apps/"))
+
+      app = Mix.Project.config()[:app]
+      current_app_path = "apps/#{app}/"
+
+      files_in_current_app_path =
+        for file <- files_in_apps_path,
+            String.starts_with?(file, current_app_path) or not relative_app_file_exists?(file),
+            do: String.trim_leading(file, current_app_path)
 
-    unless System.get_env("MIX_ENV") || Mix.env == :test do
-      Mix.raise "mix test is running on environment #{Mix.env}. If you are " <>
-                                "running tests along another task, please set MIX_ENV explicitly"
+      files = files_in_current_app_path ++ files_not_in_apps_path
+
+      if files == [] and files_in_apps_path != [] do
+        :ok
+      else
+        do_run([test_location_relative_path: "apps/#{app}"] ++ opts, args, files)
+      end
     end
+  end
+
+  defp relative_app_file_exists?(file) do
+    {[file], _} = ExUnit.Filters.parse_paths([file])
+    File.exists?(Path.join("../..", file))
+  end
+
+  defp do_run(opts, args, files) do
+    _ = Mix.Project.get!()
+
+    if System.get_env("MIX_ENV") == nil && Mix.env() != :test do
+      Mix.raise("""
+      "mix test" is running in the \"#{Mix.env()}\" environment. If you are \
+      running tests from within another command, you can either:
+
+        1. set MIX_ENV explicitly:
+
+            MIX_ENV=test mix test.another
 
-    Mix.Task.run "deps.loadpaths", args
-    Mix.Task.run "loadpaths", args
+        2. set the :preferred_envs for "def cli" in your mix.exs:
 
-    unless opts[:no_compile] do
-      Mix.Task.run "compile", args
+            def cli do
+              [preferred_envs: ["test.another": :test]]
+            end
+      """)
     end
 
-    project = Mix.Project.config
-    cover   = Keyword.merge(@cover, project[:test_coverage] || [])
+    if opts[:listen_on_stdin] do
+      System.at_exit(fn _ ->
+        IO.gets(:stdio, "")
+        Mix.shell().info("Restarting...")
+        System.restart()
+        Process.sleep(:infinity)
+      end)
+    end
+
+    # Load ExUnit before we compile anything in case we are compiling
+    # helper modules that depend on ExUnit.
+    Application.ensure_loaded(:ex_unit)
+
+    # --warnings-as-errors in test does not pass down to compile,
+    # if you need this, call compile explicitly before.
+    Mix.Task.run("compile", args -- ["--warnings-as-errors"])
+
+    project = Mix.Project.config()
+
+    {partitions, opts} = Keyword.pop(opts, :partitions)
+    partitioned? = is_integer(partitions) and partitions > 1
 
     # Start cover after we load deps but before we start the app.
     cover =
       if opts[:cover] do
-        cover[:tool].start(Mix.Project.compile_path(project), cover)
+        compile_path = Mix.Project.compile_path(project)
+        partition = partitioned? && System.get_env("MIX_TEST_PARTITION")
+
+        cover =
+          @cover
+          |> Keyword.put(:export, opts[:export_coverage] || partition)
+          |> Keyword.merge(project[:test_coverage] || [])
+
+        cover[:tool].start(compile_path, cover)
       end
 
-    # Start the app and configure exunit with command line options
+    # Start the app and configure ExUnit with command line options
     # before requiring test_helper.exs so that the configuration is
-    # available in test_helper.exs. Then configure exunit again so
-    # that command line options override test_helper.exs
-    Mix.shell.print_app
-    Mix.Task.run "app.start", args
-    Application.load(:ex_unit)
+    # available in test_helper.exs
+    Mix.shell().print_app()
+
+    app_start_args =
+      if opts[:slowest] || opts[:slowest_modules] do
+        ["--preload-modules" | args]
+      else
+        args
+      end
+
+    Mix.Task.run("app.start", app_start_args)
+
+    # The test helper may change the Mix.shell(), so revert it whenever we raise and after suite
+    shell = Mix.shell()
+    test_elixirc_options = project[:test_elixirc_options] || []
+
+    {test_elixirc_options, opts} =
+      cond do
+        not Keyword.get(opts, :breakpoints, false) ->
+          {test_elixirc_options, opts}
+
+        IEx.started?() ->
+          {Keyword.put(test_elixirc_options, :debug_info, true), opts}
+
+        true ->
+          Mix.shell().error("you must run \"iex -S mix test\" when using -b/--breakpoints")
+          {test_elixirc_options, Keyword.delete(opts, :breakpoints)}
+      end
+
+    # Configure ExUnit now and then again so the task options override test_helper.exs
+    {ex_unit_opts, allowed_files} = process_ex_unit_opts(opts)
+    ExUnit.configure(ex_unit_opts)
+
+    warnings_as_errors? = Keyword.get(opts, :warnings_as_errors, false)
+    exit_status = Keyword.fetch!(ex_unit_opts, :exit_status)
+
+    # Prepare and extract all files to require and run
+    test_paths = project[:test_paths] || default_test_paths()
+    test_pattern = project[:test_pattern] || "*.{ex,exs}"
+
+    # Warn of deprecated warn configuration
+    if project[:warn_test_pattern] do
+      Mix.shell().info("""
+      warning: the `:warn_test_pattern` configuration is deprecated and will be ignored. \
+      Use `:test_load_filters` and `:test_ignore_filters` instead.
+      """)
+    end
+
+    {test_files, test_opts} =
+      if files != [], do: ExUnit.Filters.parse_paths(files), else: {test_paths, []}
+
+    # get a list of all files in the test folders, which we filter by the test_load_filters
+    {potential_test_files, directly_included_test_files} = extract_files(test_files, test_pattern)
+
+    {load_files, _ignored_files, warn_files} =
+      classify_test_files(shell, potential_test_files, project)
+
+    # ensure that files given as direct argument to mix test are loaded,
+    # even if the test_load_filters don't match
+    load_files =
+      if files != [],
+        do: Enum.uniq(load_files ++ directly_included_test_files),
+        else: load_files
 
-    opts = ex_unit_opts(opts)
-    ExUnit.configure(opts)
+    matched_test_files =
+      load_files
+      |> filter_to_allowed_files(allowed_files)
+      |> filter_by_partition(shell, partitions)
 
-    test_paths = project[:test_paths] || ["test"]
-    Enum.each(test_paths, &require_test_helper(&1))
-    ExUnit.configure(opts)
+    warn_files != [] && warn_misnamed_test_files(warn_files)
 
-    # Finally parse, require and load the files
-    test_files   = parse_files(files, test_paths)
-    test_pattern = project[:test_pattern] || "*_test.exs"
+    try do
+      helper_warned? = Enum.any?(test_paths, &require_test_helper(shell, &1))
+      # test_opts always wins because those are given via args
+      ExUnit.configure(ex_unit_opts |> merge_helper_opts() |> Keyword.merge(test_opts))
 
-    test_files = Mix.Utils.extract_files(test_files, test_pattern)
-    Kernel.ParallelRequire.files(test_files)
+      {CT.require_and_run(matched_test_files, test_paths, test_elixirc_options, opts),
+       helper_warned?}
+    catch
+      kind, reason ->
+        # Also mark the whole suite as failed
+        file = get_manifest_path(opts)
+        ExUnit.Filters.fail_all!(file)
+        :erlang.raise(kind, reason, __STACKTRACE__)
+    else
+      {{:ok, %{excluded: excluded, failures: failures, warnings?: warnings?, total: total}},
+       helper_warned?} ->
+        Mix.shell(shell)
+        cover && cover.()
+
+        cond do
+          warnings_as_errors? and (warnings? or helper_warned?) and failures == 0 ->
+            message =
+              "\nERROR! Test suite aborted after successful execution due to warnings while using the --warnings-as-errors option"
+
+            IO.puts(:stderr, IO.ANSI.format([:red, message]))
+
+            System.at_exit(fn _ ->
+              exit({:shutdown, 1})
+            end)
+
+          failures > 0 and opts[:raise] ->
+            raise_with_shell(shell, "\"mix test\" failed")
 
-    # Run the test suite, coverage tools and register an exit hook
-    %{failures: failures} = ExUnit.run
-    if cover, do: cover.()
+          warnings_as_errors? and warnings? and failures > 0 ->
+            System.at_exit(fn _ ->
+              exit({:shutdown, exit_status + 1})
+            end)
 
-    System.at_exit fn _ ->
-      if failures > 0, do: System.halt(1)
+          failures > 0 ->
+            System.at_exit(fn _ ->
+              exit({:shutdown, exit_status})
+            end)
+
+          excluded == total and Keyword.has_key?(opts, :only) ->
+            nothing_executed(shell, "--only", opts)
+
+          excluded == total and Keyword.has_key?(opts, :name_pattern) ->
+            nothing_executed(shell, "--name-pattern", opts)
+
+          true ->
+            :ok
+        end
+
+      {:noop, _} ->
+        cond do
+          opts[:stale] ->
+            Mix.shell().info("No stale tests")
+
+          opts[:failed] || files == [] ->
+            Mix.shell().info("There are no tests to run")
+
+          true ->
+            message = "Paths given to \"mix test\" did not match any directory/file: "
+            raise_or_error_at_exit(shell, message <> Enum.join(files, ", "), opts)
+        end
+
+        :ok
     end
   end
 
-  @doc false
-  def ex_unit_opts(opts) do
-    opts = opts
-           |> filter_opts(:include)
-           |> filter_opts(:exclude)
-           |> filter_only_opts()
+  # similar to Mix.Utils.extract_files/2, but returns a list of directly included test files,
+  # that should be not filtered by the test_load_filters, e.g.
+  # mix test test/some_file.exs
+  defp extract_files(paths, pattern) do
+    {files, directly_included} =
+      for path <- paths, reduce: {[], []} do
+        {acc, directly_included} ->
+          case :elixir_utils.read_file_type(path) do
+            {:ok, :directory} ->
+              {[Path.wildcard("#{path}/**/#{pattern}") | acc], directly_included}
+
+            {:ok, :regular} ->
+              {[path | acc], [path | directly_included]}
+
+            _ ->
+              {acc, directly_included}
+          end
+      end
+
+    files =
+      files
+      |> List.flatten()
+      |> Enum.uniq()
+
+    {files, directly_included}
+  end
+
+  defp raise_with_shell(shell, message) do
+    Mix.shell(shell)
+    Mix.raise(message)
+  end
+
+  defp nothing_executed(shell, option, opts) do
+    message = "The #{option} option was given to \"mix test\" but no test was executed"
+    raise_or_error_at_exit(shell, message, opts)
+  end
+
+  defp raise_or_error_at_exit(shell, message, opts) do
+    cond do
+      opts[:raise] ->
+        raise_with_shell(shell, message)
+
+      Mix.Task.recursing?() ->
+        Mix.shell().info(message)
+
+      true ->
+        Mix.shell().error(message)
+        System.at_exit(fn _ -> exit({:shutdown, 1}) end)
+    end
+  end
+
+  defp classify_test_files(shell, potential_test_files, project) do
+    test_load_filters = project[:test_load_filters] || [&String.ends_with?(&1, "_test.exs")]
+
+    test_ignore_filters = get_test_ignore_filters(shell, project)
+
+    {to_load, to_ignore, to_warn} =
+      for file <- potential_test_files, reduce: {[], [], []} do
+        {to_load, to_ignore, to_warn} ->
+          cond do
+            any_file_matches?(file, test_load_filters) ->
+              {[file | to_load], to_ignore, to_warn}
 
-    # Set autorun to false because Mix
-    # automatically runs the test suite for us.
-    [autorun: false] ++
-      Dict.take(opts, [:trace, :max_cases, :color, :include, :exclude, :seed])
+            any_file_matches?(file, test_ignore_filters) ->
+              {to_load, [file | to_ignore], to_warn}
+
+            true ->
+              {to_load, to_ignore, [file | to_warn]}
+          end
+      end
+
+    # get the files back in the original order
+    {Enum.reverse(to_load), Enum.reverse(to_ignore), Enum.reverse(to_warn)}
   end
 
-  defp parse_files([], test_paths) do
-    test_paths
+  defp get_test_ignore_filters(shell, project) do
+    elixirc_paths = project[:elixirc_paths] || []
+
+    case Keyword.get(project, :test_ignore_filters, []) do
+      list when is_list(list) ->
+        # ignore any _helper.exs files and files that are compiled (test support files)
+        [
+          &String.ends_with?(&1, "_helper.exs"),
+          fn file -> Enum.any?(elixirc_paths, &String.starts_with?(file, &1)) end
+        ] ++ list
+
+      other ->
+        raise_with_shell(
+          shell,
+          "Invalid configuration for :test_ignore_filters, expected a list, got: #{inspect(other)}"
+        )
+    end
   end
 
-  defp parse_files([single_file], _test_paths) do
-    # Check if the single file path matches test/path/to_test.exs:123, if it does
-    # apply `--only line:123` and trim the trailing :123 part.
-    {single_file, opts} = ExUnit.Filters.parse_path(single_file)
-    ExUnit.configure(opts)
-    [single_file]
+  defp any_file_matches?(file, filters) do
+    Enum.any?(filters, fn filter ->
+      case filter do
+        regex when is_struct(regex, Regex) ->
+          Regex.match?(regex, file)
+
+        binary when is_binary(binary) ->
+          file == binary
+
+        fun when is_function(fun, 1) ->
+          fun.(file)
+      end
+    end)
   end
 
-  defp parse_files(files, _test_paths) do
-    files
+  defp warn_misnamed_test_files(ignored) do
+    Mix.shell().info("""
+    warning: the following files do not match any of the configured \
+    `:test_load_filters` / `:test_ignore_filters`:
+
+    #{Enum.join(ignored, "\n")}
+
+    This might indicate a typo in a test file name (for example, \
+    using "foo_tests.exs" instead of "foo_test.exs").
+
+    See the configuration for `:test_pattern` under `mix help test` \
+    for more information.
+    """)
+  end
+
+  @option_keys [
+    :breakpoints,
+    :trace,
+    :max_cases,
+    :max_failures,
+    :include,
+    :exclude,
+    :seed,
+    :timeout,
+    :formatters,
+    :colors,
+    :slowest,
+    :slowest_modules,
+    :failures_manifest_path,
+    :only_test_ids,
+    :test_location_relative_path,
+    :exit_status,
+    :repeat_until_failure,
+    :dry_run
+  ]
+
+  @doc false
+  def process_ex_unit_opts(opts) do
+    {opts, allowed_files} = manifest_opts(opts)
+
+    opts =
+      opts
+      |> filter_opts(:include)
+      |> filter_opts(:exclude)
+      |> filter_only_and_name_pattern()
+      |> formatter_opts()
+      |> color_opts()
+      |> exit_status_opts()
+      |> Keyword.take(@option_keys)
+      |> default_opts()
+
+    {opts, allowed_files}
+  end
+
+  defp merge_helper_opts(opts) do
+    # The only options that are additive from app env are the excludes
+    value = List.wrap(Application.get_env(:ex_unit, :exclude, []))
+
+    opts
+    |> Keyword.update(:exclude, value, &Enum.uniq(&1 ++ value))
+    |> Keyword.put_new_lazy(:failures_manifest_path, fn -> get_manifest_path([]) end)
+  end
+
+  defp default_opts(opts) do
+    # Set autorun to false because Mix automatically runs the test suite for us.
+    [autorun: false] ++ opts
   end
 
   defp parse_filters(opts, key) do
     if Keyword.has_key?(opts, key) do
       ExUnit.Filters.parse(Keyword.get_values(opts, key))
+    else
+      []
+    end
+  end
+
+  defp filter_only_and_name_pattern(opts) do
+    only = parse_filters(opts, :only)
+    name_patterns = opts |> Keyword.get_values(:name_pattern) |> Enum.map(&{:test, &1})
+
+    case only ++ name_patterns do
+      [] ->
+        opts
+
+      filters ->
+        opts
+        |> Keyword.update(:include, filters, &(filters ++ &1))
+        |> Keyword.update(:exclude, [:test], &[:test | &1])
     end
   end
 
   defp filter_opts(opts, key) do
-    if filters = parse_filters(opts, key) do
-      Keyword.put(opts, key, filters)
+    case parse_filters(opts, key) do
+      [] -> opts
+      filters -> Keyword.put(opts, key, filters)
+    end
+  end
+
+  defp formatter_opts(opts) do
+    if Keyword.has_key?(opts, :formatter) do
+      formatters =
+        opts
+        |> Keyword.get_values(:formatter)
+        |> Enum.map(&Module.concat([&1]))
+
+      Keyword.put(opts, :formatters, formatters)
     else
       opts
     end
   end
 
-  defp filter_only_opts(opts) do
-    if filters = parse_filters(opts, :only) do
-      opts
-      |> Keyword.put_new(:include, [])
-      |> Keyword.put_new(:exclude, [])
-      |> Keyword.update!(:include, &(filters ++ &1))
-      |> Keyword.update!(:exclude, &[:test|&1])
+  @manifest_file_name ".mix_test_failures"
+
+  defp get_manifest_path(opts) do
+    opts[:failures_manifest_path] ||
+      Application.get_env(:ex_unit, :failures_manifest_path) ||
+      Path.join(Mix.Project.manifest_path(), @manifest_file_name)
+  end
+
+  defp manifest_opts(opts) do
+    manifest_file = get_manifest_path(opts)
+
+    if opts[:failed] do
+      if opts[:stale] do
+        Mix.raise("Combining --failed and --stale is not supported.")
+      end
+
+      case ExUnit.Filters.failure_info(manifest_file) do
+        {allowed_files, failed_ids} ->
+          {Keyword.put(opts, :only_test_ids, failed_ids), allowed_files}
+
+        :all ->
+          {opts, nil}
+      end
     else
-      opts
+      {opts, nil}
     end
   end
 
-  defp require_test_helper(dir) do
+  defp filter_to_allowed_files(matched_test_files, nil), do: matched_test_files
+
+  defp filter_to_allowed_files(matched_test_files, %MapSet{} = allowed_files) do
+    Enum.filter(matched_test_files, &MapSet.member?(allowed_files, Path.expand(&1)))
+  end
+
+  defp filter_by_partition(files, _shell, total) when total in [nil, 1],
+    do: files
+
+  defp filter_by_partition(files, shell, total) when total > 1 do
+    partition = System.get_env("MIX_TEST_PARTITION")
+
+    case partition && Integer.parse(partition) do
+      {partition, ""} when partition in 1..total//1 ->
+        partition = partition - 1
+
+        # We sort the files because Path.wildcard does not guarantee
+        # ordering, so different OSes could return a different order,
+        # meaning run across OSes on different partitions could run
+        # duplicate files.
+        for {file, index} <- Enum.with_index(Enum.sort(files)),
+            rem(index, total) == partition,
+            do: file
+
+      _ ->
+        raise_with_shell(
+          shell,
+          "The MIX_TEST_PARTITION environment variable must be set to an integer between " <>
+            "1..#{total} when the --partitions option is set, got: #{inspect(partition)}"
+        )
+    end
+  end
+
+  defp filter_by_partition(_files, shell, total) do
+    raise_with_shell(
+      shell,
+      "--partitions : expected to be positive integer, got #{total}"
+    )
+  end
+
+  defp color_opts(opts) do
+    case Keyword.fetch(opts, :color) do
+      {:ok, enabled?} ->
+        Keyword.put(opts, :colors, enabled: enabled?)
+
+      :error ->
+        opts
+    end
+  end
+
+  defp exit_status_opts(opts) do
+    Keyword.put_new(opts, :exit_status, 2)
+  end
+
+  defp require_test_helper(shell, dir) do
     file = Path.join(dir, "test_helper.exs")
 
     if File.exists?(file) do
-      Code.require_file file
+      {_result, warnings} = Code.with_diagnostics([log: true], fn -> Code.require_file(file) end)
+      warnings != []
+    else
+      raise_with_shell(
+        shell,
+        "Cannot run tests because test helper file #{inspect(file)} does not exist"
+      )
+    end
+  end
+
+  defp default_test_paths do
+    if File.dir?("test") do
+      ["test"]
     else
-      Mix.raise "Cannot run tests because test helper file #{inspect file} does not exist"
+      []
     end
   end
 end
diff --git a/lib/mix/lib/mix/tasks/will_recompile.ex b/lib/mix/lib/mix/tasks/will_recompile.ex
new file mode 100644
index 00000000000..7390aae6ae0
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/will_recompile.ex
@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.WillRecompile do
+  use Mix.Task
+  @moduledoc false
+
+  @doc """
+  Annotates the current project will recompile.
+  """
+  def run(_) do
+    config = Mix.Project.config()
+
+    # Slight reimplementation of `manifest_path` because we need to
+    # get manifests for root and children in umbrella case.
+    paths =
+      if Mix.Project.umbrella?(config) do
+        build = Mix.Project.build_path(config)
+
+        children =
+          Enum.map(Mix.Project.apps_paths(config), fn {app, _} ->
+            Path.join([build, "lib", Atom.to_string(app)])
+          end)
+
+        [build | children]
+      else
+        [Mix.Project.app_path(config)]
+      end
+
+    filename = Mix.ProjectStack.reset_config_mtime()
+
+    for path <- paths do
+      path = Path.join(path, ".mix")
+      File.mkdir_p!(path)
+      File.touch!(Path.join(path, filename))
+    end
+
+    :ok
+  end
+end
diff --git a/lib/mix/lib/mix/tasks/xref.ex b/lib/mix/lib/mix/tasks/xref.ex
new file mode 100644
index 00000000000..40d3742fe0b
--- /dev/null
+++ b/lib/mix/lib/mix/tasks/xref.ex
@@ -0,0 +1,1403 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.Tasks.Xref do
+  use Mix.Task
+
+  import Mix.Compilers.Elixir,
+    only: [read_manifest: 1, source: 1, source: 2, module: 1]
+
+  @shortdoc "Prints cross reference information"
+  @manifest "compile.elixir"
+
+  @moduledoc """
+  Prints cross reference information between modules.
+
+  The `xref` task expects a mode as first argument:
+
+      $ mix xref MODE
+
+  All available modes are discussed below, after a brief
+  introduction to xref.
+
+  This task is automatically re-enabled, so you can print
+  information multiple times in the same Mix invocation.
+
+  ## A brief introduction to xref
+
+  The goal of `xref` is to analyze the dependencies between modules
+  and files. It is most commonly used to find problematic areas where
+  touching one file in a project causes a large subset of the project
+  to recompile. The most common cause of these problems are the so-called
+  "compile-connected" files. Those are files you depend on at compile-time
+  (for example, by invoking its macro or using it in the body of a module)
+  which also have their own dependencies.
+
+  The most harmful form of compile-connected dependencies are the ones
+  that are also in a cycle. Imagine you have files `lib/a.ex`, `lib/b.ex`,
+  and `lib/c.ex` with the following dependencies:
+
+      lib/a.ex
+      └── lib/b.ex (compile)
+            └── lib/c.ex
+                  └── lib/a.ex
+
+  Because you have a compile-time dependency, any of the files `lib/a.ex`,
+  `lib/b.ex`, and `lib/c.ex` depend on will cause `lib/a.ex` to recompile.
+  In other words, whenever you have a cycle, **a change to any file in the
+  cycle will cause all compile-time deps to recompile**. Therefore, your
+  first priority to reduce constant recompilations is to remove them.
+  You can spot them by running:
+
+      $ mix xref graph --format cycles --label compile-connected
+
+  > #### Use the --label option
+  >
+  > The job of `mix xref` is to explore relationships between files
+  > and it is expected that most of your files are either directly
+  > or indirectly connected. For this reason, it is strongly advised
+  > to pass the `--label` option to filter the amount of data,
+  > specifically with `compile-connected` (or `compile`) as values.
+
+  Whenever you find a compile-time dependency, such as `lib/a.ex` pointing
+  to `lib/b.ex`, there are two ways to remove them:
+
+    1. Run `mix xref trace lib/a.ex` to understand where and how `lib/a.ex`
+       depends on `lib/b.ex` at compile time and address it
+
+    2. Or run `mix xref trace lib/b.ex` and make sure it does not depend on
+       any other module in your project because a compile dependency makes
+       those runtime dependencies also compile time by transitivity
+
+  We outline all options for `mix xref trace` and the types of dependencies
+  over the following sections.
+
+  If you don't have compile cycles in your project, that's a good beginning,
+  but you want to avoid any compile-connected dependencies in general, as they
+  may become cycles in the future. To verify the general health of your project,
+  you may run:
+
+      $ mix xref graph --format stats --label compile-connected
+
+  This command will show general information about the project, but focus on
+  compile-connected dependencies. In the stats, you will see the following report:
+
+      Top 10 files with most incoming dependencies:
+        * lib/livebook_web.ex (97)
+        * lib/livebook/config.ex (3)
+        * proto/lib/livebook_proto/deployment_group.pb.ex (2)
+        * lib/livebook_web/plugs/memory_provider.ex (2)
+        * proto/lib/livebook_proto/user_connected.pb.ex (1)
+
+  You can see the first file, "lib/livebook_web.ex", is depended on by 97
+  other files and, because we are using compile-connected, it also means
+  that "lib/livebook_web.ex" itself has its own dependencies. We can find
+  which files depend on "lib/livebook_web.ex" at compile time like this:
+
+      $ mix xref graph --sink lib/livebook_web.ex --label compile --only-nodes
+
+  And you can find the files lib/livebook_web.ex depends on like this:
+
+      $ mix xref graph --source lib/livebook_web.ex --only-nodes
+
+  The trouble here is precisely that, if any of the files in the latter
+  command changes, all of the files in the first command will be recompiled,
+  because compile time dependencies are transitive. As we did with cycles,
+  you can use `mix xref trace` to understand why and how these dependencies
+  exist.
+
+  ### Dependency types
+
+  Elixir tracks three types of dependencies between modules: compile,
+  exports, and runtime. If a module has a compile time dependency on
+  another module, the caller module has to be recompiled whenever the
+  callee changes (or any dependency of the callee changes).
+  Let's see an example:
+
+      # lib/a.ex
+      defmodule A do
+        @hello B.hello()
+        def hello, do: @hello
+      end
+
+      # lib/b.ex
+      defmodule B do
+        def hello, do: "hello"
+        def world, do: C.world()
+      end
+
+      # lib/c.ex
+      defmodule C do
+        def world, do: "world"
+      end
+
+  If `C.world/0` changes, `B` is marked as stale. `B` does not need to
+  be recompiled, because it depends on `C` at runtime, but anything that
+  depends on `B` at compile-time has to recompile, and that includes `A`.
+
+  Compile-time dependencies are typically added when using macros or
+  when invoking functions in the module body (outside of functions).
+  This type of transitive compile-time dependencies, such as `A`
+  depending on `C` at compile-time through `B`, are called compile-connected.
+
+  Export dependencies are compile time dependencies on the module API,
+  namely structs and its public definitions. For example, if you import
+  a module but only use its functions, it is an export dependency. If
+  you use a struct, it is an export dependency too. Export dependencies
+  are only recompiled if the module API changes. Note, however, that compile
+  time dependencies have higher precedence than exports. Therefore if
+  you import a module and use its macros, it is a compile time dependency.
+
+  Runtime dependencies are added whenever you invoke another module
+  inside a function. Modules with runtime dependencies do not have
+  to be compiled when the callee changes, unless there is a transitive
+  compile or an outdated export time dependency between them.
+
+  Over the next sections, we will explain what which `mix xref` command
+  does in detail.
+
+  ## mix xref trace FILE
+
+  Compiles the given file listing all dependencies within the same app.
+  It includes the type and line for each one. Example:
+
+      $ mix xref trace lib/my_app/router.ex
+
+  The `--label` option may be given to keep only certain traces
+  (compile, runtime or export):
+
+      $ mix xref trace lib/my_app/router.ex --label compile
+
+  If you have an umbrella application, we also recommend using the
+  `--include-siblings` flag to see the dependencies from sibling
+  applications. The `trace` command is not currently supported at the
+  umbrella root.
+
+  ### Example
+
+  Imagine the given file lib/b.ex:
+
+      defmodule B do
+        import A
+        A.macro()
+        macro()
+        A.fun()
+        fun()
+        def calls_macro, do: A.macro()
+        def calls_fun, do: A.fun()
+        def calls_struct, do: %A{}
+      end
+
+  `mix xref trace` will print:
+
+      lib/b.ex:2: require A (export)
+      lib/b.ex:3: call A.macro/0 (compile)
+      lib/b.ex:4: import call A.macro/0 (compile)
+      lib/b.ex:5: call A.fun/0 (compile)
+      lib/b.ex:6: import call A.fun/0 (compile)
+      lib/b.ex:7: call A.macro/0 (compile)
+      lib/b.ex:8: call A.fun/0 (runtime)
+      lib/b.ex:9: struct A (export)
+
+  ## mix xref graph
+
+  Emits a file dependency graph where an edge from `A` to `B` indicates
+  that `A` (source) depends on `B` (sink).
+
+      $ mix xref graph --format stats
+
+  For any non-small project, the output of `mix xref graph` itself, without
+  any additional flags, is not useful: once your project grows, it is hard
+  to gather actionable feedback by looking at the graph as a whole. Instead,
+  `mix xref graph` is better used as a "database", which can help you answer
+  queries about your project.
+
+  The following options are accepted:
+
+    * `--exclude` - path to exclude. Can be repeated to exclude multiple paths.
+
+    * `--label` - only shows relationships with the given label.
+      The labels are "compile-connected", "compile", "export" and "runtime".
+      By default, the `--label` option does not change how the graph is computed,
+      it simply filters the printed graph to show only relationships with the given
+      label. However, you can pass `--only-direct` to trim the graph to only the
+      nodes that have the direct relationship given by label.
+
+    * `--group` - provide comma-separated paths to consider as a group. Dependencies
+      from and into multiple files of the group are considered a single dependency.
+      Dependencies between the group elements are ignored. This is useful when you
+      are computing compile and compile-connected dependencies and you want a
+      series of files to be treated as one. The group is printed using the first path,
+      with a `+` suffix. Can be repeated to create multiple groups.
+
+    * `--only-direct` - keeps only files with the direct relationship
+      given by `--label`
+
+    * `--only-nodes` - only shows the node names (no edges).
+      Generally useful with the `--sink` flag
+
+    * `--source` - displays all files that the given source file
+      references (directly or indirectly). Can be repeated to display
+      references from multiple sources.
+
+    * `--sink` - displays all files that reference the given file
+      (directly or indirectly). Can be repeated.
+
+    * `--min-cycle-size` - controls the minimum cycle size on formats
+      like `stats` and `cycles`
+
+    * `--min-cycle-label` - controls the minimum number of dependencies
+      with the given `--label` on a cycle
+
+    * `--format` - can be set to one of:
+
+      * `pretty` - prints the graph to the terminal using Unicode characters.
+        Each prints each file followed by the files it depends on. This is the
+        default except on Windows;
+
+      * `plain` - the same as pretty except ASCII characters are used instead of
+        Unicode characters. This is the default on Windows;
+
+      * `stats` - prints general statistics about the graph;
+
+      * `cycles` - prints all strongly connected cycles in the graph;
+
+      * `dot` - produces a DOT graph description, by default written to `xref_graph.dot`
+        in the current directory.  See the documentation for the `--output` option to
+        learn how to control where the file is written and other related details.
+
+      * `json` *(since v1.19.0)* - produces a JSON file, by default written to
+        `xref_graph.json` in the current directory.  See the documentation for the
+        `--output` option to learn how to control where the file is written and other
+        related details.
+
+        The JSON format is always a two level map of maps. The top level keys
+        specify source files, with their values containing maps whose keys specify
+        sink files and whose values specify the type of relationship, which will
+        be one of `compile`, `export` or `runtime`. Files which have no dependencies
+        will be present in the top level map, and will have empty maps for values.
+
+    * `--output` *(since v1.15.0)* - can be used to override the location of
+      the files created by the `dot` and `json` formats. It can be set to
+
+      * `-` - prints the output to standard output;
+
+      * a path - writes the output graph to the given path
+
+      If the output file already exists then it will be renamed in place
+      to have a `.bak` suffix, possibly overwriting any existing `.bak` file.
+      If this rename fails a fatal exception will be thrown.
+
+  The `--source` and `--sink` options are particularly useful when trying to understand
+  how the modules in a particular file interact with the whole system. You can combine
+  those options with `--label` and `--only-nodes` to get all files that exhibit a certain
+  property, for example:
+
+      # To show all compile-connected relationships
+      $ mix xref graph --label compile-connected
+
+      # To get the tree that depend on lib/foo.ex at compile time
+      $ mix xref graph --label compile --sink lib/foo.ex
+
+      # To get all files that depend on lib/foo.ex at compile time
+      $ mix xref graph --label compile --sink lib/foo.ex --only-nodes
+
+      # To get all paths between two files
+      $ mix xref graph --source lib/foo.ex --sink lib/bar.ex
+
+      # To show general statistics about the graph
+      $ mix xref graph --format stats
+
+      # To show all cycles with at least one compile-time dependency
+      $ mix xref graph --format cycles --label compile-connected
+
+  ### Understanding the printed graph
+
+  When `mix xref graph` runs, it will print a tree of the following
+  format. Imagine the following code:
+
+      # lib/a.ex
+      defmodule A do
+        IO.puts B.hello()
+      end
+
+      # lib/b.ex
+      defmodule B do
+        def hello, do: C.world()
+      end
+
+      # lib/c.ex
+      defmodule C do
+        def world, do: "hello world"
+      end
+
+  It will print:
+
+      $ mix xref graph
+      lib/a.ex
+      └── lib/b.ex (compile)
+      lib/b.ex
+      └── lib/c.ex
+      lib/c.ex
+
+  This tree means that `lib/a.ex` depends on `lib/b.ex` at compile
+  time. And `lib/b.ex` depends on `lib/c.ex` at runtime. This is often
+  problematic because if `lib/c.ex` changes, `lib/a.ex` also has to
+  recompile due to this indirect compile time dependency. When you pass
+  `--label compile`, the graph shows only the compile-time dependencies:
+
+      $ mix xref graph --label compile
+      lib/a.ex
+      └── lib/b.ex (compile)
+
+  The `--label compile` flag removes all non-compile dependencies. However,
+  this can be misleading because having direct compile time dependencies is
+  not necessarily an issue. The biggest concern are the transitive compile
+  time dependencies. You can get all compile time dependencies that cause
+  transitive compile time dependencies by using `--label compile-connected`:
+
+      $ mix xref graph --label compile-connected
+      lib/a.ex
+      └── lib/b.ex (compile)
+
+  The above says `lib/a.ex` depends on `lib/b.ex` and that causes transitive
+  compile time dependencies - as we know, `lib/a.ex` also depends on `lib/c.ex`.
+  We can retrieve those transitive dependencies by passing `lib/b.ex` as
+  `--source` to `mix xref graph`:
+
+      $ mix xref graph --source lib/b.ex
+      lib/b.ex
+      └── lib/c.ex
+
+  Similarly, you can use the `--label compile` and the `--sink` flag to find
+  all compile time dependencies that will recompile once the sink changes:
+
+      $ mix xref graph --label compile --sink lib/c.ex
+      lib/a.ex
+      └── lib/b.ex (compile)
+
+  If you have an umbrella application, we also recommend using the
+  `--include-siblings` flag to see the dependencies from sibling
+  applications. When invoked at the umbrella root, the `graph`
+  command will list all files from all umbrella children, without
+  any namespacing.
+
+  ### Understanding the printed cycle
+
+  If you run `mix xref graph --format cycles`, Elixir will print cycles
+  of shape:
+
+      Cycle of length 3:
+
+          lib/c.ex
+          lib/b.ex
+          lib/a.ex (compile)
+
+  More precisely, `xref` is printing the [strongly connected components](https://en.wikipedia.org/wiki/Strongly_connected_component)
+  in the dependency graph, which is (roughly speaking) the largest set of
+  files which are part of a dependency cycle involving these files.
+
+  For this reason, files may have multiple relationships between them, and
+  therefore the cycles are not printed in order. The label reflects the
+  highest type of relationship between the given file and any other file in
+  the cycle. In the example above, it means `lib/a.ex` depends on something
+  else in the cycle at compile-time.  Those are exactly the type of dependencies
+  we want to avoid, and you can ask `mix xref` to only print graphs with
+  with compile dependencies in them by passing the `--label` flag:
+
+      $ mix xref graph --format cycles --label compile-connected
+
+  ## Shared options
+
+  Those options are shared across all modes:
+
+    * `--fail-above` - generates a failure if the relevant metric is above the
+      given threshold. Applies to all modes except `mix xref graph --format stats`.
+
+    * `--include-siblings` - includes dependencies that have `:in_umbrella` set
+      to true in the current project in the reports. This can be used to find
+      callers or to analyze graphs between projects (it applies only to `trace`
+      subcommand)
+
+    * `--no-compile` - does not compile even if files require compilation
+
+    * `--no-deps-check` - does not check dependencies
+
+    * `--no-archives-check` - does not check archives
+
+    * `--no-elixir-version-check` - does not check the Elixir version from mix.exs
+
+  """
+
+  @switches [
+    archives_check: :boolean,
+    compile: :boolean,
+    deps_check: :boolean,
+    elixir_version_check: :boolean,
+    exclude: :keep,
+    fail_above: :integer,
+    format: :string,
+    group: :keep,
+    include_siblings: :boolean,
+    label: :string,
+    only_nodes: :boolean,
+    only_direct: :boolean,
+    sink: :keep,
+    source: :keep,
+    min_cycle_size: :integer,
+    min_cycle_label: :integer,
+    output: :string
+  ]
+
+  @impl true
+  def run(args) do
+    Mix.Task.run("compile", args)
+    Mix.Task.reenable("xref")
+
+    {opts, args} = OptionParser.parse!(args, strict: @switches)
+
+    case args do
+      ["callers", module] ->
+        no_umbrella!("callers")
+        handle_callers(module, opts)
+
+      ["trace", file] ->
+        no_umbrella!("trace")
+        handle_trace(file, opts)
+
+      ["graph"] ->
+        handle_graph(opts)
+
+      # TODO: Remove on v2.0
+      ["deprecated"] ->
+        Mix.shell().error(
+          "The deprecated check has been moved to the compiler and has no effect now"
+        )
+
+      # TODO: Remove on v2.0
+      ["unreachable"] ->
+        Mix.shell().error(
+          "The unreachable check has been moved to the compiler and has no effect now"
+        )
+
+      _ ->
+        Mix.raise(
+          "No argument was given to xref command. Run \"mix help xref\" for more information"
+        )
+    end
+  end
+
+  defp no_umbrella!(task) do
+    if Mix.Project.umbrella?() do
+      Mix.raise(
+        "mix xref #{task} is not supported in the umbrella root. Please run it inside the umbrella applications instead"
+      )
+    end
+  end
+
+  @doc """
+  Returns a list of information of all the runtime function calls in the project.
+
+  Each item in the list is a map with the following keys:
+
+    * `:callee` - a tuple containing the module, function, and arity of the call
+    * `:line` - an integer representing the line where the function is called
+    * `:file` - a binary representing the file where the function is called
+    * `:caller_module` - the module where the function is called
+
+  This function returns an empty list when used at the root of an umbrella
+  project because there is no compile manifest to extract the function call
+  information from. To get the function calls of each child in an umbrella,
+  execute the function at the root of each individual application.
+  """
+  @deprecated "Use compilation tracers described in the Code module"
+  @spec calls(keyword()) :: [
+          %{
+            callee: {module(), atom(), arity()},
+            line: integer(),
+            file: String.t()
+          }
+        ]
+  def calls(opts \\ []) do
+    for manifest <- manifests(opts),
+        {source, source(modules: modules)} <- read_manifest(manifest) |> elem(1),
+        module <- modules,
+        call <- collect_calls(source, module),
+        do: call
+  end
+
+  defp collect_calls(source, module) do
+    with [_ | _] = path <- :code.which(module),
+         {:ok, {_, [debug_info: debug_info]}} <- :beam_lib.chunks(path, [:debug_info]),
+         {:debug_info_v1, backend, data} <- debug_info,
+         {:ok, %{definitions: defs}} <- backend.debug_info(:elixir_v1, module, data, []),
+         do: walk_definitions(module, source, defs),
+         else: (_ -> [])
+  end
+
+  defp walk_definitions(module, file, definitions) do
+    state = %{
+      file: file,
+      module: module,
+      calls: []
+    }
+
+    state = Enum.reduce(definitions, state, &walk_definition/2)
+    state.calls
+  end
+
+  defp walk_definition({_function, _kind, meta, clauses}, state) do
+    with_file_meta(state, meta, fn state ->
+      Enum.reduce(clauses, state, &walk_clause/2)
+    end)
+  end
+
+  defp with_file_meta(%{file: original_file} = state, meta, fun) do
+    case Keyword.fetch(meta, :file) do
+      {:ok, {meta_file, _}} ->
+        state = fun.(%{state | file: meta_file})
+        %{state | file: original_file}
+
+      :error ->
+        fun.(state)
+    end
+  end
+
+  defp walk_clause({_meta, args, _guards, body}, state) do
+    state = walk_expr(args, state)
+    walk_expr(body, state)
+  end
+
+  # &Mod.fun/arity
+  defp walk_expr({:&, meta, [{:/, _, [{{:., _, [module, fun]}, _, []}, arity]}]}, state)
+       when is_atom(module) and is_atom(fun) do
+    add_call(module, fun, arity, meta, state)
+  end
+
+  # Mod.fun(...)
+  defp walk_expr({{:., _, [module, fun]}, meta, args}, state)
+       when is_atom(module) and is_atom(fun) do
+    state = add_call(module, fun, length(args), meta, state)
+    walk_expr(args, state)
+  end
+
+  # %Module{...}
+  defp walk_expr({:%, meta, [module, {:%{}, _meta, args}]}, state)
+       when is_atom(module) and is_list(args) do
+    state = add_call(module, :__struct__, 0, meta, state)
+    walk_expr(args, state)
+  end
+
+  # Function call
+  defp walk_expr({left, _meta, right}, state) when is_list(right) do
+    state = walk_expr(right, state)
+    walk_expr(left, state)
+  end
+
+  # {x, y}
+  defp walk_expr({left, right}, state) do
+    state = walk_expr(right, state)
+    walk_expr(left, state)
+  end
+
+  # [...]
+  defp walk_expr(list, state) when is_list(list) do
+    Enum.reduce(list, state, &walk_expr/2)
+  end
+
+  defp walk_expr(_other, state) do
+    state
+  end
+
+  defp add_call(module, fun, arity, meta, state) do
+    call = %{
+      callee: {module, fun, arity},
+      caller_module: state.module,
+      file: state.file,
+      line: meta[:line]
+    }
+
+    %{state | calls: [call | state.calls]}
+  end
+
+  ## Modes
+
+  defp handle_callers(module, opts) do
+    module = parse_module(module)
+
+    file_callers =
+      for manifest <- manifests(opts),
+          {source_path, source_entry} <- read_manifest(manifest) |> elem(1),
+          reference = reference(module, source_entry),
+          do: {source_path, reference}
+
+    for {file, type} <- Enum.sort(file_callers) do
+      Mix.shell().info([file, " (", type, ")"])
+    end
+
+    check_failure(:references, length(file_callers), opts[:fail_above])
+  end
+
+  defp handle_trace(file, opts) do
+    set =
+      for app <- apps(opts),
+          modules = Application.spec(app, :modules),
+          module <- modules,
+          into: MapSet.new(),
+          do: module
+
+    new = [ignore_already_consolidated: true, ignore_module_conflict: true, tracers: [__MODULE__]]
+    old = Code.compiler_options(new)
+    ets = :ets.new(__MODULE__, [:named_table, :duplicate_bag, :public])
+    :ets.insert(ets, [{:config, set, trace_label(opts[:label])}])
+
+    try do
+      Code.compile_file(file)
+    else
+      _ ->
+        :ets.delete(ets, :modules)
+
+        traces =
+          try do
+            print_traces(Enum.sort(:ets.lookup_element(__MODULE__, :entry, 2)))
+          rescue
+            _ -> []
+          end
+
+        check_failure(:traces, length(traces), opts[:fail_above])
+    after
+      :ets.delete(ets)
+      Code.compiler_options(old)
+    end
+  end
+
+  defp handle_graph(opts) do
+    label = label_filter(opts[:label])
+
+    {direct_filter, transitive_filter} =
+      if opts[:only_direct], do: {label, :all}, else: {:all, label}
+
+    write_graph(file_references(direct_filter, opts), transitive_filter, opts)
+  end
+
+  ## Callers
+
+  defp parse_module(module) do
+    case Mix.Utils.parse_mfa(module) do
+      {:ok, [module]} -> module
+      _ -> Mix.raise("xref callers MODULE expects a MODULE, got: " <> module)
+    end
+  end
+
+  defp reference(module, source) do
+    cond do
+      module in source(source, :compile_references) -> "compile"
+      module in source(source, :export_references) -> "export"
+      module in source(source, :runtime_references) -> "runtime"
+      true -> nil
+    end
+  end
+
+  ## Trace
+
+  @doc false
+  def trace({:alias_reference, meta, module}, env) when env.module != module do
+    case env do
+      %{function: nil} -> add_trace(:compile, :alias, module, module, meta, env)
+      %{context: nil} -> add_trace(:runtime, :alias, module, module, meta, env)
+      %{} -> :ok
+    end
+  end
+
+  def trace({:require, meta, module, _opts}, env),
+    do: add_trace(require_mode(meta), :require, module, module, meta, env)
+
+  def trace({:struct_expansion, meta, module, _keys}, env),
+    do: add_trace(:export, :struct, module, module, meta, env)
+
+  def trace({:remote_function, meta, module, function, arity}, env),
+    do: add_trace(mode(env), :call, module, {module, function, arity}, meta, env)
+
+  def trace({:remote_macro, meta, module, function, arity}, env),
+    do: add_trace(:compile, :call, module, {module, function, arity}, meta, env)
+
+  def trace({:imported_function, meta, module, function, arity}, env),
+    do: add_trace(mode(env), :import, module, {module, function, arity}, meta, env)
+
+  def trace({:imported_macro, meta, module, function, arity}, env),
+    do: add_trace(:compile, :import, module, {module, function, arity}, meta, env)
+
+  def trace(_event, _env),
+    do: :ok
+
+  defp require_mode(meta), do: if(meta[:from_macro], do: :compile, else: :export)
+
+  defp mode(%{function: nil}), do: :compile
+  defp mode(_), do: :runtime
+
+  defp add_trace(mode, type, module, module_or_mfa, meta, env) do
+    [{:config, modules, label}] = :ets.lookup(__MODULE__, :config)
+
+    if module in modules and (label == nil or mode == label) do
+      line = meta[:line] || env.line
+      :ets.insert(__MODULE__, {:entry, {env.file, line, module_or_mfa, mode, type}})
+    end
+
+    :ok
+  end
+
+  defp print_traces(entries) do
+    # We don't want to show aliases if there is an entry of the same type
+    non_aliases =
+      for {_file, _line, module_or_mfa, mode, type} <- entries,
+          type != :alias,
+          into: %{},
+          do: {{trace_module(module_or_mfa), mode}, []}
+
+    shell = Mix.shell()
+
+    for {file, line, module_or_mfa, mode, type} <- entries,
+        type != :alias or not Map.has_key?(non_aliases, {module_or_mfa, mode}) do
+      shell.info([
+        Exception.format_file_line(Path.relative_to_cwd(file), line),
+        ?\s,
+        trace_type(type),
+        ?\s,
+        format_module_or_mfa(module_or_mfa),
+        " (#{mode})"
+      ])
+
+      :ok
+    end
+  end
+
+  defp trace_type(:import), do: "import call"
+  defp trace_type(other), do: Atom.to_string(other)
+
+  defp trace_label(nil), do: nil
+  defp trace_label("compile"), do: :compile
+  defp trace_label("export"), do: :export
+  defp trace_label("runtime"), do: :runtime
+  defp trace_label(other), do: Mix.raise("Unknown --label #{other} in mix xref trace")
+
+  defp trace_module({m, _, _}), do: m
+  defp trace_module(m), do: m
+
+  defp format_module_or_mfa({m, f, a}), do: Exception.format_mfa(m, f, a)
+  defp format_module_or_mfa(m), do: inspect(m)
+
+  ## Graph
+
+  defp merge_groups(file_references, comma_separated_groups) do
+    for group_paths <- comma_separated_groups,
+        reduce: {file_references, %{}} do
+      {file_references, aliases} ->
+        group_paths
+        |> String.split(",", trim: true)
+        |> check_files(file_references, :group)
+        |> group(file_references, aliases)
+    end
+  end
+
+  @type_order %{
+    compile: 0,
+    export: 1,
+    nil: 2
+  }
+
+  # Group the given paths.
+  # In graph theory vocabulary, this is done by vertex identification
+  # and removal of edges between contracting vertices.
+  defp group(paths, file_references, aliases) do
+    group_name = hd(paths) <> "+"
+    aliases = paths |> Map.new(&{&1, group_name}) |> Map.merge(aliases)
+
+    # Merge the references *from* the paths to group
+    {from_group, file_references} = Map.split(file_references, paths)
+
+    file_references =
+      Map.put(file_references, group_name, merge_references_from_group(from_group))
+
+    # Remap the references *to* the merged group
+    file_references =
+      Map.new(file_references, fn {file, references} ->
+        {file, remap_references_to_group(references, aliases, group_name)}
+      end)
+
+    # Remove the resulting reference from the merged group to itself, if there is one
+    file_references = Map.update!(file_references, group_name, &List.keydelete(&1, group_name, 0))
+
+    {file_references, aliases}
+  end
+
+  # Calculate the references from the merged group by concatenating all the references
+  # from its components; in case of duplicates keep the one with the most important type.
+  defp merge_references_from_group(file_references_to_merge) do
+    file_references_to_merge
+    |> Map.values()
+    |> Enum.concat()
+    |> Enum.sort_by(fn {_ref, type} -> @type_order[type] end)
+    |> Enum.uniq_by(fn {ref, _type} -> ref end)
+    |> Enum.sort()
+  end
+
+  defp remap_references_to_group(references, aliases, group_name) do
+    case Enum.split_with(references, fn {ref, _type} -> Map.has_key?(aliases, ref) end) do
+      {[], _all_references} ->
+        references
+
+      {refs_to_merge, other_refs} ->
+        type =
+          refs_to_merge
+          |> Enum.map(fn {_ref, type} -> type end)
+          |> Enum.min_by(&@type_order[&1])
+
+        Enum.sort([{group_name, type} | other_refs])
+    end
+  end
+
+  defp exclude(file_references, nil), do: file_references
+
+  defp exclude(file_references, excluded) do
+    excluded_set = MapSet.new(excluded)
+
+    file_references
+    |> Map.drop(excluded)
+    |> Map.new(fn {key, list} ->
+      {key, Enum.reject(list, fn {ref, _kind} -> MapSet.member?(excluded_set, ref) end)}
+    end)
+  end
+
+  defp label_filter(nil), do: :all
+  defp label_filter("compile"), do: :compile
+  defp label_filter("export"), do: :export
+  defp label_filter("runtime"), do: nil
+  defp label_filter("compile-connected"), do: :compile_connected
+  defp label_filter(other), do: Mix.raise("Unknown --label #{other} in mix xref graph")
+
+  defp file_references(:compile_connected, _opts) do
+    Mix.raise("Cannot use --only-direct with --label=compile-connected")
+  end
+
+  defp file_references(filter, opts) do
+    module_sources_list =
+      for manifest_path <- manifests(opts),
+          {manifest_modules, manifest_sources} = read_manifest(manifest_path),
+          {module, module(sources: sources)} <- manifest_modules,
+          source_path <- sources,
+          source_entry = manifest_sources[source_path],
+          do: {module, {source_path, source_entry}}
+
+    module_sources = Map.new(module_sources_list)
+
+    Map.new(module_sources_list, fn {current, {file, source_entry}} ->
+      source(
+        runtime_references: runtime,
+        export_references: exports,
+        compile_references: compile
+      ) = source_entry
+
+      compile_references =
+        modules_to_nodes(compile, :compile, current, file, module_sources, filter)
+
+      export_references =
+        modules_to_nodes(exports, :export, current, file, module_sources, filter)
+
+      runtime_references =
+        modules_to_nodes(runtime, nil, current, file, module_sources, filter)
+
+      references =
+        runtime_references
+        |> Map.merge(export_references)
+        |> Map.merge(compile_references)
+        |> Enum.to_list()
+
+      {file, references}
+    end)
+  end
+
+  defp modules_to_nodes(_, label, _, _, _, filter) when filter != :all and label != filter do
+    %{}
+  end
+
+  defp modules_to_nodes(modules, label, current, file, module_sources, _filter) do
+    for module <- modules,
+        module != current,
+        {source_path, _source_entry} <- [module_sources[module]],
+        file != source_path,
+        do: {source_path, label},
+        into: %{}
+  end
+
+  @humanize_option %{
+    group: "Group files",
+    source: "Sources",
+    sink: "Sinks",
+    exclude: "Excluded files"
+  }
+
+  defp get_files(what, opts, file_references, aliases) do
+    files =
+      for file <- Keyword.get_values(opts, what) do
+        Map.get(aliases, file, file)
+      end
+
+    check_files(files, file_references, what)
+  end
+
+  defp check_files(files, file_references, what) do
+    case files -- Map.keys(file_references) do
+      [_ | _] = missing ->
+        Mix.raise("#{@humanize_option[what]} could not be found: #{Enum.join(missing, ", ")}")
+
+      _ ->
+        :ok
+    end
+
+    if files == [], do: nil, else: files
+  end
+
+  defp write_graph(all_references, filter, opts) do
+    {all_references, aliases} = merge_groups(all_references, Keyword.get_values(opts, :group))
+
+    all_references =
+      exclude(all_references, get_files(:exclude, opts, all_references, aliases))
+
+    sources = get_files(:source, opts, all_references, aliases)
+    sinks = get_files(:sink, opts, all_references, aliases)
+
+    file_references =
+      cond do
+        sinks -> sink_tree(all_references, sinks)
+        sources -> source_tree(all_references, sources)
+        true -> all_references
+      end
+
+    {found, count} =
+      case opts[:format] do
+        "dot" ->
+          {roots, callback, count} =
+            roots_and_callback(file_references, filter, sources, sinks, opts)
+
+          file_spec =
+            Mix.Utils.write_dot_graph!(
+              "xref_graph.dot",
+              "xref graph",
+              Enum.sort(roots),
+              callback,
+              opts
+            )
+
+          if file_spec != "-" do
+            png_file_spec = (file_spec |> Path.rootname() |> Path.basename()) <> ".png"
+
+            """
+            Generated "#{Path.relative_to_cwd(file_spec)}". To generate a PNG:
+
+               dot -Tpng #{inspect(file_spec)} -o #{inspect(png_file_spec)}
+
+            For more options see http://www.graphviz.org/.
+            """
+            |> String.trim_trailing()
+            |> Mix.shell().info()
+          end
+
+          {:references, count}
+
+        "stats" ->
+          print_stats(file_references, filter, opts)
+          {:stats, 0}
+
+        "cycles" ->
+          {:cycles, print_cycles(file_references, filter, opts)}
+
+        "json" ->
+          {roots, callback, count} =
+            roots_and_callback(file_references, filter, sources, sinks, opts)
+
+          file_spec =
+            Mix.Utils.write_json_tree!("xref_graph.json", Enum.sort(roots), callback, opts)
+
+          if file_spec != "-" do
+            Mix.shell().info("Generated \"#{file_spec}\".")
+          end
+
+          {:references, count}
+
+        other when other in [nil, "plain", "pretty"] ->
+          {roots, callback, count} =
+            roots_and_callback(file_references, filter, sources, sinks, opts)
+
+          Mix.Utils.print_tree(Enum.sort(roots), callback, opts)
+
+          if sources do
+            # We compute the tree again in case sinks are also given
+            file_references = source_tree(all_references, sources)
+            print_sources_cycles(file_references, sources, opts)
+          end
+
+          {:references, count}
+
+        other ->
+          Mix.raise("Unknown --format #{other} in mix xref graph")
+      end
+
+    check_failure(found, count, opts[:fail_above])
+  end
+
+  defp source_tree(file_references, keys) do
+    keys
+    |> Enum.reduce({%{}, %{}}, fn key, {acc, seen} ->
+      source_tree(file_references, key, acc, seen)
+    end)
+    |> elem(0)
+  end
+
+  defp source_tree(file_references, key, acc, seen) do
+    nodes = file_references[key]
+
+    if is_nil(nodes) or Map.has_key?(seen, key) do
+      {acc, seen}
+    else
+      acc = Map.put(acc, key, nodes)
+      seen = Map.put(seen, key, true)
+
+      Enum.reduce(nodes, {acc, seen}, fn {key, _type}, {acc, seen} ->
+        source_tree(file_references, key, acc, seen)
+      end)
+    end
+  end
+
+  defp sink_tree(file_references, keys) do
+    file_references
+    |> invert_references()
+    |> source_tree(keys)
+    |> invert_references()
+  end
+
+  defp invert_references(file_references) do
+    Enum.reduce(file_references, %{}, fn {file, references}, acc ->
+      Enum.reduce(references, acc, fn {file_reference, type}, acc ->
+        Map.update(acc, file_reference, [{file, type}], &[{file, type} | &1])
+      end)
+    end)
+  end
+
+  defp roots_and_callback(file_references, filter, sources, sinks, opts) do
+    # Filter according to non direct label
+    file_references = transitive_filter(file_references, filter)
+
+    # If a label is given, remove empty root nodes
+    file_references =
+      if opts[:label] do
+        for {_, [_ | _]} = pair <- file_references, into: %{}, do: pair
+      else
+        file_references
+      end
+
+    roots =
+      if sources do
+        Enum.map(sources, &{&1, nil})
+      else
+        file_references
+        |> Map.drop(sinks || [])
+        |> Enum.map(&{elem(&1, 0), nil})
+      end
+
+    callback = fn {file, type} ->
+      children = if opts[:only_nodes], do: [], else: Map.get(file_references, file, [])
+      type = type && "(#{type})"
+      {{file, type}, Enum.sort(children)}
+    end
+
+    {roots, callback, count_references(file_references)}
+  end
+
+  defp count_references(file_references) do
+    Enum.reduce(file_references, 0, fn {_, refs}, total -> total + length(refs) end)
+  end
+
+  defp transitive_filter_fn(file_references, :compile_connected),
+    do: fn {key, type} ->
+      type == :compile and match?([_ | _], file_references[key] || [])
+    end
+
+  defp transitive_filter_fn(_file_references, filter),
+    do: fn {_key, type} -> type == filter end
+
+  defp transitive_filter(file_references, :all), do: file_references
+
+  defp transitive_filter(file_references, filter) do
+    filter_fn = transitive_filter_fn(file_references, filter)
+
+    for {key, children} <- file_references,
+        into: %{},
+        do: {key, Enum.filter(children, filter_fn)}
+  end
+
+  defp print_stats(references, filter, opts) do
+    with_digraph(references, fn graph ->
+      shell = Mix.shell()
+
+      counters =
+        Enum.reduce(references, %{compile: 0, export: 0, nil: 0}, fn {_, deps}, acc ->
+          Enum.reduce(deps, acc, fn {_, value}, acc ->
+            Map.update!(acc, value, &(&1 + 1))
+          end)
+        end)
+
+      shell.info("Tracked files: #{map_size(references)} (nodes)")
+      shell.info("Compile dependencies: #{counters.compile} (edges)")
+      shell.info("Exports dependencies: #{counters.export} (edges)")
+      shell.info("Runtime dependencies: #{counters.nil} (edges)")
+      shell.info("Cycles: #{length(cycles(graph, filter, opts))}")
+
+      outgoing =
+        references
+        |> Enum.map(fn {file, _} -> {out_stats_filter(references, graph, file, filter), file} end)
+        |> Enum.sort(:desc)
+        |> Enum.take(10)
+
+      shell.info("\nTop #{length(outgoing)} files with most outgoing dependencies:")
+      for {count, file} <- outgoing, do: shell.info("  * #{file} (#{count})")
+
+      incoming =
+        references
+        |> Enum.map(fn {file, _} -> {in_stats_filter(references, graph, file, filter), file} end)
+        |> Enum.sort(:desc)
+        |> Enum.take(10)
+
+      shell.info("\nTop #{length(incoming)} files with most incoming dependencies:")
+      for {count, file} <- incoming, do: shell.info("  * #{file} (#{count})")
+    end)
+  end
+
+  defp out_stats_filter(_references, graph, file, :all), do: :digraph.out_degree(graph, file)
+
+  defp out_stats_filter(references, graph, file, filter) do
+    filter_fn = transitive_filter_fn(references, filter)
+
+    graph
+    |> :digraph.out_neighbours(file)
+    |> Enum.count(fn v ->
+      {_edge, _v1, _v2, label} = :digraph.edge(graph, {file, v})
+      filter_fn.({file, label})
+    end)
+  end
+
+  defp in_stats_filter(_references, graph, file, :all), do: :digraph.in_degree(graph, file)
+
+  defp in_stats_filter(references, graph, file, filter) do
+    filter_fn = transitive_filter_fn(references, filter)
+
+    graph
+    |> :digraph.in_neighbours(file)
+    |> Enum.count(fn v ->
+      {_edge, _v1, _v2, label} = :digraph.edge(graph, {v, file})
+      filter_fn.({file, label})
+    end)
+  end
+
+  defp with_digraph(references, callback) do
+    graph = :digraph.new()
+
+    try do
+      for {file, _} <- references do
+        :digraph.add_vertex(graph, file)
+      end
+
+      for {file, deps} <- references, {dep, label} <- deps do
+        :digraph.add_edge(graph, {file, dep}, file, dep, label)
+      end
+
+      callback.(graph)
+    after
+      :digraph.delete(graph)
+    end
+  end
+
+  defp cycles(graph, filter, opts) do
+    # Vertices order in cyclic_strong_components/1 return is arbitrary and changes between
+    # OTP versions, sorting is necessary to make the output stable across versions.
+    cycles =
+      graph
+      |> :digraph_utils.cyclic_strong_components()
+      |> Enum.map(&{length(&1), add_labels(&1, graph)})
+
+    cycles =
+      if min = opts[:min_cycle_size] do
+        Enum.filter(cycles, &(elem(&1, 0) >= min))
+      else
+        cycles
+      end
+
+    min_cycle_label =
+      if integer = opts[:min_cycle_label] do
+        if filter == :all do
+          Mix.raise("--min-cycle-label requires the --label option to be given")
+        end
+
+        integer
+      else
+        1
+      end
+
+    # :compile_connected is the same as :compile
+    if cycle_fn = cycle_filter_fn(filter) do
+      Enum.filter(cycles, fn {_length, cycle} ->
+        Enum.count_until(cycle, cycle_fn, min_cycle_label) == min_cycle_label
+      end)
+    else
+      cycles
+    end
+  end
+
+  # In cycles, a compile connected is compile
+  defp cycle_filter_fn(:all), do: nil
+  defp cycle_filter_fn(:compile_connected), do: cycle_filter_fn(:compile)
+  defp cycle_filter_fn(filter), do: fn {_node, type} -> type == filter end
+
+  defp add_labels(vertices, graph) do
+    set = MapSet.new(vertices)
+
+    vertices
+    |> Enum.map(fn v ->
+      {v,
+       graph
+       |> :digraph.out_neighbours(v)
+       |> cycle_label(set, graph, v, false)}
+    end)
+    |> Enum.sort()
+  end
+
+  defp cycle_label([out | outs], set, graph, v, export?) do
+    case out in set && :digraph.edge(graph, {v, out}) do
+      {_, _, _, :compile} -> :compile
+      {_, _, _, :export} -> cycle_label(outs, set, graph, v, true)
+      _ -> cycle_label(outs, set, graph, v, export?)
+    end
+  end
+
+  defp cycle_label([], _set, _graph, _v, export?) do
+    if export?, do: :export, else: nil
+  end
+
+  defp print_cycles(references, filter, opts) do
+    with_digraph(references, fn graph ->
+      shell = Mix.shell()
+
+      case graph |> cycles(filter, opts) |> Enum.sort(:desc) do
+        [] ->
+          shell.info("No cycles found")
+          0
+
+        cycles ->
+          shell.info("#{length(cycles)} cycles found. Showing them in decreasing size:\n")
+
+          for {length, cycle} <- cycles do
+            meta =
+              cycle
+              |> Enum.reduce({0, 0}, fn
+                {_, :compile}, {compile, export} -> {compile + 1, export}
+                {_, :export}, {compile, export} -> {compile, export + 1}
+                {_, _}, {compile, export} -> {compile, export}
+              end)
+              |> case do
+                {0, 0} ->
+                  ""
+
+                {compile, export} ->
+                  info =
+                    if(compile > 0, do: ["#{compile} compile"], else: []) ++
+                      if(export > 0, do: ["#{export} export"], else: [])
+
+                  " (" <> Enum.join(info, ", ") <> ")"
+              end
+
+            shell.info("Cycle of length #{length}#{meta}:\n")
+
+            for {node, type} <- cycle do
+              shell.info(
+                case type do
+                  :compile -> [:red, "    #{node} (compile)"]
+                  :export -> "    #{node} (export)"
+                  _ -> "    #{node}"
+                end
+              )
+            end
+
+            shell.info("")
+          end
+
+          length(cycles)
+      end
+    end)
+  end
+
+  defp print_sources_cycles(references, sources, opts) do
+    with_digraph(references, fn graph ->
+      shell = Mix.shell()
+
+      graph
+      |> cycles(:compile, opts)
+      |> Enum.sort(:desc)
+      |> Enum.each(fn {length, cycle} ->
+        if source = Enum.find(sources, &List.keymember?(cycle, &1, 0)) do
+          shell.info("""
+
+          WARNING: Source #{source} is part of a cycle of #{length} nodes \
+          and this cycle has a compile dependency. Therefore source and the \
+          whole cycle will recompile whenever any of the files they depend \
+          on change. Run "mix xref graph --format stats --label compile-connected" \
+          to print compilation cycles and "mix help xref" for information on \
+          removing them\
+          """)
+        end
+      end)
+    end)
+  end
+
+  ## Helpers
+
+  defp apps(opts) do
+    siblings =
+      if opts[:include_siblings] do
+        for %{scm: Mix.SCM.Path, opts: opts, app: app} <- Mix.Dep.cached(),
+            opts[:in_umbrella],
+            do: app
+      else
+        []
+      end
+
+    [Mix.Project.config()[:app] | siblings]
+  end
+
+  defp manifests(opts) do
+    siblings =
+      cond do
+        Mix.Project.umbrella?() ->
+          for %{opts: opts} <- Mix.Dep.Umbrella.cached(),
+              do: Path.join([opts[:build], ".mix", @manifest])
+
+        opts[:include_siblings] ->
+          for %{scm: Mix.SCM.Path, opts: opts} <- Mix.Dep.cached(),
+              opts[:in_umbrella],
+              do: Path.join([opts[:build], ".mix", @manifest])
+
+        true ->
+          []
+      end
+
+    [Path.join(Mix.Project.manifest_path(), @manifest) | siblings]
+  end
+
+  defp check_failure(found, count, max_count)
+       when not is_nil(max_count) and count > max_count do
+    Mix.raise("Too many #{found} (found: #{count}, permitted: #{max_count})")
+  end
+
+  defp check_failure(_, _, _) do
+    :ok
+  end
+end
diff --git a/lib/mix/lib/mix/tasks_server.ex b/lib/mix/lib/mix/tasks_server.ex
index 10404809590..4f82f7090ac 100644
--- a/lib/mix/lib/mix/tasks_server.ex
+++ b/lib/mix/lib/mix/tasks_server.ex
@@ -1,36 +1,39 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
 defmodule Mix.TasksServer do
   @moduledoc false
+  @name __MODULE__
 
-  def start_link() do
-    Agent.start_link(fn -> HashSet.new end, name: __MODULE__)
-  end
+  use Agent
 
-  def clear_tasks() do
-    get_and_update fn set ->
-      { set, HashSet.new }
-    end
+  def start_link(_opts) do
+    Agent.start_link(
+      fn -> :ets.new(@name, [:public, :set, :named_table]) end,
+      name: @name
+    )
   end
 
-  def run_task(task, proj) do
-    run_item = { task, proj }
-    get_and_update fn set ->
-      { not(run_item in set), Set.put(set, run_item) }
-    end
+  def run(tuple) do
+    :ets.insert_new(@name, {tuple})
   end
 
-  def put_task(task, proj) do
-    update &Set.put(&1, { task, proj })
+  def put(tuple) do
+    :ets.insert(@name, {tuple})
+    :ok
   end
 
-  def delete_task(task, proj) do
-    update &Set.delete(&1, { task, proj })
+  def get(tuple) do
+    :ets.member(@name, tuple)
   end
 
-  defp get_and_update(fun) do
-    Agent.get_and_update(__MODULE__, fun, 30_000)
+  def delete_many(many) do
+    Enum.each(many, &:ets.delete(@name, &1))
   end
 
-  defp update(fun) do
-    Agent.update(__MODULE__, fun, 30_000)
+  def clear() do
+    :ets.delete_all_objects(@name)
+    :ok
   end
 end
diff --git a/lib/mix/lib/mix/utils.ex b/lib/mix/lib/mix/utils.ex
index 2edbcc4fc5f..cb9205c6a90 100644
--- a/lib/mix/lib/mix/utils.ex
+++ b/lib/mix/lib/mix/utils.ex
@@ -1,48 +1,186 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# NOTE: As this is a utils file it should not contain hard coded files
+# everything should be parameterized.
+
 defmodule Mix.Utils do
-  @moduledoc """
-  Utilities used throughout Mix and tasks.
+  @moduledoc false
+
+  # For bootstrapping purposes
+  @compile {:no_warn_undefined, Logger}
+
+  @doc """
+  Returns the apps of a project with no filtering.
+
+  `compile.all` calls it to extract all compile-time apps.
+  `compile.app` calls it to extract all runtime apps.
   """
+  def project_apps(properties, config, extra, deps_loader) do
+    apps = Keyword.get(properties, :applications) || deps_loader.(deps_opts(config))
+    {all, required, optional} = split_by_type(extra ++ apps)
+    all = Enum.uniq(language_apps(config) ++ Enum.reverse(all))
+    optional = Enum.uniq(Enum.reverse(optional -- required))
+    {all, optional}
+  end
+
+  defp split_by_type(apps) do
+    Enum.reduce(apps, {[], [], []}, fn
+      app, {all, required, optional} when is_atom(app) ->
+        {[app | all], [app | required], optional}
+
+      {app, :required}, {all, required, optional} ->
+        {[app | all], [app | required], optional}
+
+      {app, :optional}, {all, required, optional} ->
+        {[app | all], required, [app | optional]}
+    end)
+  end
+
+  defp language_apps(config) do
+    case Keyword.get(config, :language, :elixir) do
+      :elixir -> [:kernel, :stdlib, :elixir]
+      :erlang -> [:kernel, :stdlib]
+    end
+  end
+
+  defp deps_opts(config) do
+    for config_dep <- Keyword.get(config, :deps, []),
+        do: {elem(config_dep, 0), dep_opts(config_dep)}
+  end
+
+  defp dep_opts({_app, opts}) when is_list(opts), do: opts
+  defp dep_opts({_app, _req, opts}) when is_list(opts), do: opts
+  defp dep_opts(_), do: []
 
   @doc """
-  Get the mix home.
+  Gets the Mix home.
 
-  It defaults to `~/.mix` unless the `MIX_HOME`
-  environment variable is set.
+  It uses the locations `MIX_HOME`, `XDG_DATA_HOME/mix`,
+  `~/.mix` with decreasing priority.
 
   Developers should only store entries in the
   `MIX_HOME` directory which are guaranteed to
-  work accross multiple Elixir versions, as it is
+  work across multiple Elixir versions, as it is
   not recommended to swap the `MIX_HOME` directory
   as configuration and other important data may be
   stored there.
   """
   def mix_home do
-    System.get_env("MIX_HOME") || Path.expand("~/.mix")
+    mix_home_xdg_lookup(:user_data)
+  end
+
+  @doc """
+  Gets possible location of global Mix configuration.
+
+  Possible locations:
+
+     * `MIX_HOME`
+     * `XDG_CONFIG_HOME/mix` (if `MIX_XDG` is set)
+     * `~/.mix`
+
+  """
+  def mix_config do
+    mix_home_xdg_lookup(:user_config)
   end
 
   @doc """
-  Get all paths defined in the MIX_PATH env variable.
+  Gets possible location of Mix cache.
+
+  Possible locations:
+
+   * `XDG_CACHE_HOME/mix` (if `MIX_XDG` is set)
+   * `:filename.basedir(:user_cache, "mix")`
 
-  `MIX_PATH` may contain multiple paths. If on Windows, those
-  paths should be separated by `;`, if on unix systems, use `:`.
   """
-  def mix_paths do
-    if path = System.get_env("MIX_PATH") do
-      String.split(path, path_separator)
+  def mix_cache do
+    if System.get_env("MIX_XDG") in ["1", "true"] do
+      # XDG lookups are only done for linux OS
+      :filename.basedir(:user_cache, "mix", %{os: :linux})
     else
-      []
+      :filename.basedir(:user_cache, "mix")
+    end
+  end
+
+  defp mix_home_xdg_lookup(xdg) do
+    cond do
+      dir = System.get_env("MIX_HOME") ->
+        dir
+
+      System.get_env("MIX_XDG") in ["1", "true"] ->
+        :filename.basedir(xdg, "mix", %{os: :linux})
+
+      true ->
+        Path.expand("~/.mix")
     end
   end
 
-  defp path_separator do
-    case :os.type do
-      {:win32, _} -> ";"
-      {:unix, _}  -> ":"
+  @doc """
+  Parses a string into module, function and arity.
+
+  It returns `{:ok, mfa_list}`, where a `mfa_list` is
+  `[module, function, arity]`, `[module, function]` or `[module]`,
+  or the atom `:error`.
+
+      iex> Mix.Utils.parse_mfa("Foo.bar/1")
+      {:ok, [Foo, :bar, 1]}
+      iex> Mix.Utils.parse_mfa(":foo.bar/1")
+      {:ok, [:foo, :bar, 1]}
+      iex> Mix.Utils.parse_mfa(":foo.bar")
+      {:ok, [:foo, :bar]}
+      iex> Mix.Utils.parse_mfa(":foo")
+      {:ok, [:foo]}
+      iex> Mix.Utils.parse_mfa("Foo")
+      {:ok, [Foo]}
+
+      iex> Mix.Utils.parse_mfa("Foo.")
+      :error
+      iex> Mix.Utils.parse_mfa("Foo.bar.baz")
+      :error
+      iex> Mix.Utils.parse_mfa("Foo.bar/2/2")
+      :error
+
+  """
+  def parse_mfa(mfa) do
+    with {:ok, quoted} <- Code.string_to_quoted(mfa),
+         [_ | _] = mfa_list <- quoted_to_mfa(quoted) do
+      {:ok, mfa_list}
+    else
+      _ -> :error
     end
   end
 
+  defp quoted_to_mfa({:/, _, [dispatch, arity]}) when is_integer(arity) do
+    quoted_to_mf(dispatch, [arity])
+  end
+
+  defp quoted_to_mfa(dispatch) do
+    quoted_to_mf(dispatch, [])
+  end
+
+  defp quoted_to_mf({{:., _, [module, fun]}, _, []}, acc) when is_atom(fun) do
+    quoted_to_m(module, [fun | acc])
+  end
+
+  defp quoted_to_mf(module, acc) do
+    quoted_to_m(module, acc)
+  end
+
+  defp quoted_to_m({:__aliases__, _, aliases}, acc) do
+    [Module.concat(aliases) | acc]
+  end
+
+  defp quoted_to_m(atom, acc) when is_atom(atom) do
+    [atom | acc]
+  end
+
+  defp quoted_to_m(_, _acc) do
+    []
+  end
+
   @doc """
-  Take a `command` name and attempts to load a module
+  Takes a `command` name and attempts to load a module
   with the command name converted to a module name
   in the given `at` scope.
 
@@ -65,48 +203,84 @@ defmodule Mix.Utils do
   compared to the given `targets`.
   """
   def stale?(sources, targets) do
-    Enum.any? stale_stream(sources, targets)
+    Enum.any?(stale_stream(sources, targets))
   end
 
   @doc """
-  Extract all stale `sources` compared to the given `targets`.
+  Extracts all stale `sources` compared to the given `targets`.
   """
   def extract_stale(_sources, []), do: []
   def extract_stale([], _targets), do: []
 
   def extract_stale(sources, targets) do
-    stale_stream(sources, targets) |> Enum.to_list
+    stale_stream(sources, targets) |> Enum.to_list()
+  end
+
+  defp stale_stream(sources, []) do
+    sources
   end
 
   defp stale_stream(sources, targets) do
-    modified_target = targets |> Enum.map(&last_modified(&1)) |> Enum.min
+    modified_target = targets |> Enum.map(&last_modified/1) |> Enum.min()
 
-    Stream.filter(sources, fn(source) ->
+    Stream.filter(sources, fn source ->
       last_modified(source) > modified_target
     end)
   end
 
   @doc """
-  Returns the date the given path was last modified.
+  Returns the date the given path was last modified in posix time.
 
-  If the path does not exist, it returns the unix epoch
+  If the path does not exist, it returns the Unix epoch
   (1970-01-01 00:00:00).
   """
   def last_modified(path)
 
-  def last_modified({{_, _, _}, {_, _, _}} = timestamp) do
+  def last_modified(timestamp) when is_integer(timestamp) do
     timestamp
   end
 
   def last_modified(path) do
-    case File.stat(path) do
-      {:ok, %File.Stat{mtime: mtime}} -> mtime
-      {:error, _} -> {{1970, 1, 1}, {0, 0, 0}}
+    {mtime, _size} = last_modified_and_size(path)
+    mtime
+  end
+
+  @doc """
+  Returns the date the given path was last modified in posix time
+  and the size.
+
+  If the path does not exist, it returns the Unix epoch
+  (1970-01-01 00:00:00).
+  """
+  def last_modified_and_size(path) do
+    now = System.os_time(:second)
+
+    case :elixir_utils.read_posix_mtime_and_size(path) do
+      {:ok, mtime, size} when mtime > now ->
+        message =
+          "warning: mtime (modified time) for #{inspect(path)} was set to the future, resetting to now"
+
+        Mix.shell().error(message)
+        File.touch(path, now)
+        {mtime, size}
+
+      {:ok, mtime, size} ->
+        {mtime, size}
+
+      {:error, _} ->
+        {0, 0}
     end
   end
 
   @doc """
-  Extract files from a list of paths.
+  Prints n files are being compiled with the given extension.
+  """
+  def compiling_n(0, _ext), do: :ok
+  def compiling_n(1, ext), do: Mix.shell().info("Compiling 1 file (.#{ext})")
+  def compiling_n(n, ext), do: Mix.shell().info("Compiling #{n} files (.#{ext})")
+
+  @doc """
+  Extracts files from a list of paths.
 
   `exts_or_pattern` may be a list of extensions or a
   `Path.wildcard/1` pattern.
@@ -124,116 +298,270 @@ defmodule Mix.Utils do
 
   def extract_files(paths, pattern) do
     Enum.flat_map(paths, fn path ->
-      if File.regular?(path), do: [path], else: Path.wildcard("#{path}/**/#{pattern}")
-    end) |> Enum.uniq
+      case :elixir_utils.read_file_type(path) do
+        {:ok, :directory} -> Path.wildcard("#{path}/**/#{pattern}")
+        {:ok, :regular} -> [path]
+        _ -> []
+      end
+    end)
+    |> Enum.uniq()
   end
 
   @doc """
-  Converts the given atom or binary to underscore format.
+  Handles writing the contents to either STDOUT or to a file, as specified
+  by the :output keyword in opts, defaulting to the provided default_file_spec.
 
-  If an atom is given, it is assumed to be an Elixir module,
-  so it is converted to a binary and then processed.
+  If the resolved file specification is "-" then the contents is written to STDOUT,
+  otherwise if the file already exists it is renamed with a ".bak" suffix before
+  the contents is written.  The underlying IO operations will throw an exception
+  if there is an error.
 
-  ## Examples
+  Returns the name of the file written to, or "-" if the output was to STDOUT.
+  This function is made public mostly for testing.
+  """
+  @spec write_according_to_opts!(Path.t(), iodata(), write_opts) :: Path.t()
+  def write_according_to_opts!(default_file_spec, contents, opts) do
+    file_spec = Keyword.get(opts, :output, default_file_spec)
 
-      iex> Mix.Utils.underscore "FooBar"
-      "foo_bar"
+    if file_spec == "-" do
+      IO.write(contents)
+    else
+      if File.exists?(file_spec) do
+        new_file_spec = "#{file_spec}.bak"
+        File.rename!(file_spec, new_file_spec)
+      end
 
-      iex> Mix.Utils.underscore "Foo.Bar"
-      "foo/bar"
+      File.write!(file_spec, contents)
+    end
 
-      iex> Mix.Utils.underscore Foo.Bar
-      "foo/bar"
+    # return the file_spec just in case the caller has a use for it.
+    file_spec
+  end
 
-  In general, `underscore` can be thought of as the reverse of
-  `camelize`, however, in some cases formatting may be lost:
+  @doc """
+  Outputs the given tree according to the callback as a two level
+  map of maps in JSON format.
 
-      Mix.Utils.underscore "SAPExample"  #=> "sap_example"
-      Mix.Utils.camelize   "sap_example" #=> "SapExample"
+  The callback will be invoked for each node and it
+  must return a `{printed, children}` tuple.
 
+  If the `:output` option is `-` then prints to standard output,
+  see write_according_to_opts!/3 for details.
   """
-  def underscore(atom) when is_atom(atom) do
-    "Elixir." <> rest = Atom.to_string(atom)
-    underscore(rest)
+  @spec write_json_tree!(Path.t(), [node], (node -> {formatted_node, [node]}), write_opts) ::
+          Path.t()
+        when node: term()
+  def write_json_tree!(default_file_spec, nodes, callback, opts \\ []) do
+    src_map = build_json_tree(_src_map = %{}, nodes, callback)
+    write_according_to_opts!(default_file_spec, JSON.encode_to_iodata!(src_map), opts)
   end
 
-  def underscore(""), do: ""
+  defp build_json_tree(src_map, [], _callback), do: src_map
 
-  def underscore(<<h, t :: binary>>) do
-    <<to_lower_char(h)>> <> do_underscore(t, h)
-  end
+  defp build_json_tree(src_map, nodes, callback) do
+    Enum.reduce(nodes, src_map, fn node, src_map ->
+      {{name, _}, children} = callback.(node)
+
+      if Map.has_key?(src_map, name) do
+        src_map
+      else
+        sink_map =
+          Enum.reduce(children, %{}, fn {name, info}, sink_map ->
+            info = if info == nil, do: "runtime", else: Atom.to_string(info)
+            Map.put(sink_map, name, info)
+          end)
 
-  defp do_underscore(<<h, t, rest :: binary>>, _) when h in ?A..?Z and not t in ?A..?Z do
-    <<?_, to_lower_char(h), t>> <> do_underscore(rest, t)
+        Map.put(src_map, name, sink_map)
+        |> build_json_tree(children, callback)
+      end
+    end)
   end
 
-  defp do_underscore(<<h, t :: binary>>, prev) when h in ?A..?Z and not prev in ?A..?Z do
-    <<?_, to_lower_char(h)>> <> do_underscore(t, h)
+  @type formatted_node :: {name :: String.Chars.t(), edge_info :: String.Chars.t()}
+
+  @typedoc """
+  Options for `write_according_to_opts!/3`, `write_json_tree!/4`, and `write_dot_graph!/5`.
+  """
+  @type write_opts :: [
+          output: String.t()
+        ]
+
+  @typedoc """
+  Options for `print_tree/3`.
+  """
+  @type print_tree_opts :: [
+          format: String.t()
+        ]
+
+  @typedoc """
+  Options for `read_path/2`.
+  """
+  @type read_path_opts :: [
+          timeout: pos_integer(),
+          sha512: String.t()
+        ]
+
+  @doc """
+  Prints the given tree according to the callback.
+
+  The callback will be invoked for each node and it
+  must return a `{printed, children}` tuple.
+  """
+  @spec print_tree([node], (node -> {formatted_node, [node]}), print_tree_opts) :: :ok
+        when node: term()
+  def print_tree(nodes, callback, opts \\ []) do
+    pretty? =
+      case Keyword.get(opts, :format) do
+        "pretty" -> true
+        "plain" -> false
+        _other -> elem(:os.type(), 0) != :win32
+      end
+
+    print_tree(nodes, _depth = [], _seen = %{}, pretty?, callback)
+    :ok
   end
 
-  defp do_underscore(<<?-, t :: binary>>, _) do
-    <<?_>> <> do_underscore(t, ?-)
+  defp print_tree(nodes, depth, seen, pretty?, callback) do
+    # We perform a breadth first traversal so we always show a dependency
+    # a node with its children as high as possible in tree. This helps avoid
+    # very deep trees.
+    {nodes, seen} =
+      Enum.flat_map_reduce(nodes, seen, fn node, seen ->
+        {{name, info}, children} = callback.(node)
+
+        if Map.has_key?(seen, name) do
+          {[{name, info, []}], seen}
+        else
+          {[{name, info, children}], Map.put(seen, name, true)}
+        end
+      end)
+
+    print_each_node(nodes, depth, seen, pretty?, callback)
   end
 
-  defp do_underscore(<< "..", t :: binary>>, _) do
-    <<"..">> <> underscore(t)
+  defp print_each_node([], _depth, seen, _pretty?, _callback) do
+    seen
   end
 
-  defp do_underscore(<<?.>>, _), do: <<?.>>
+  defp print_each_node([{name, info, children} | nodes], depth, seen, pretty?, callback) do
+    info = if(info, do: " #{info}", else: "")
+    Mix.shell().info("#{depth(pretty?, depth)}#{prefix(pretty?, depth, nodes)}#{name}#{info}")
 
-  defp do_underscore(<<?., t :: binary>>, _) do
-    <<?/>> <> underscore(t)
+    seen = print_tree(children, [nodes != [] | depth], seen, pretty?, callback)
+    print_each_node(nodes, depth, seen, pretty?, callback)
   end
 
-  defp do_underscore(<<h, t :: binary>>, _) do
-    <<to_lower_char(h)>> <> do_underscore(t, h)
-  end
+  defp depth(_pretty?, []), do: ""
+  defp depth(pretty?, depth), do: Enum.reverse(depth) |> tl() |> Enum.map(&entry(pretty?, &1))
 
-  defp do_underscore(<<>>, _) do
-    <<>>
-  end
+  defp entry(false, true), do: "|   "
+  defp entry(false, false), do: "    "
+  defp entry(true, true), do: "│   "
+  defp entry(true, false), do: "    "
 
-  @doc """
-  Converts the given string to CamelCase format.
+  defp prefix(false, [], _), do: ""
+  defp prefix(false, _, []), do: "`-- "
+  defp prefix(false, _, _), do: "|-- "
+  defp prefix(true, [], _), do: ""
+  defp prefix(true, _, []), do: "└── "
+  defp prefix(true, _, _), do: "├── "
 
-  ## Examples
+  @doc """
+  Outputs the given tree according to the callback as a DOT graph.
 
-      iex> Mix.Utils.camelize "foo_bar"
-      "FooBar"
+  The callback will be invoked for each node and it
+  must return a `{printed, children}` tuple.
 
+  If the `:output` option is `-` then prints to standard output,
+  see write_according_to_opts!/3 for details.
   """
-  def camelize(""), do: ""
+  @spec write_dot_graph!(
+          Path.t(),
+          String.t(),
+          [node],
+          (node -> {formatted_node, [node]}),
+          write_opts
+        ) :: Path.t()
+        when node: term()
+  def write_dot_graph!(default_file_spec, title, nodes, callback, opts \\ []) do
+    {dot, _} = build_dot_graph(make_ref(), nodes, MapSet.new(), callback)
+    contents = ["digraph ", quoted(title), " {\n", dot, "}\n"]
+    write_according_to_opts!(default_file_spec, contents, opts)
+  end
+
+  defp build_dot_graph(_parent, [], seen, _callback), do: {[], seen}
 
-  def camelize(<<?_, t :: binary>>) do
-    camelize(t)
+  defp build_dot_graph(parent, [node | nodes], seen, callback) do
+    {{name, edge_info}, children} = callback.(node)
+    key = {parent, name}
+
+    if MapSet.member?(seen, key) do
+      {[], seen}
+    else
+      seen = MapSet.put(seen, key)
+      current = build_dot_current(parent, name, edge_info)
+      {children, seen} = build_dot_graph(name, children, seen, callback)
+      {siblings, seen} = build_dot_graph(parent, nodes, seen, callback)
+      {[current, children | siblings], seen}
+    end
   end
 
-  def camelize(<<h, t :: binary>>) do
-    <<to_upper_char(h)>> <> do_camelize(t)
+  defp build_dot_current(parent, name, edge_info) do
+    edge_info =
+      if edge_info do
+        [" [label=", quoted(edge_info), "]"]
+      else
+        []
+      end
+
+    parent =
+      if is_reference(parent) do
+        []
+      else
+        [quoted(parent), " -> "]
+      end
+
+    ["  ", parent, quoted(name), edge_info, ?\n]
   end
 
-  defp do_camelize(<<?_, ?_, t :: binary>>) do
-    do_camelize(<< ?_, t :: binary >>)
+  defp quoted(data) do
+    string = to_string(data)
+    escape_dot_string(string, <<?">>)
   end
 
-  defp do_camelize(<<?_, h, t :: binary>>) when h in ?a..?z do
-    <<to_upper_char(h)>> <> do_camelize(t)
+  # Escape a string for DOT format according to GraphViz specification https://graphviz.org/doc/info/lang.html
+  # - Only quotes need escaping
+  # - The ending quote should not be escaped (which requires an even of trailing backslashes)
+  defp escape_dot_string(<<?\\, ?\\, rest::binary>>, acc) do
+    escape_dot_string(rest, <<acc::binary, ?\\, ?\\>>)
   end
 
-  defp do_camelize(<<?_>>) do
-    <<>>
+  defp escape_dot_string(<<?", rest::binary>>, acc) do
+    escape_dot_string(rest, <<acc::binary, ?\\, ?">>)
   end
 
-  defp do_camelize(<<?/, t :: binary>>) do
-    <<?.>> <> camelize(t)
+  defp escape_dot_string(<<?\\>>, acc) do
+    <<acc::binary, ?\\, ?\\, ?">>
   end
 
-  defp do_camelize(<<h, t :: binary>>) do
-    <<h>> <> do_camelize(t)
+  defp escape_dot_string(<<char, rest::binary>>, acc) do
+    escape_dot_string(rest, <<acc::binary, char>>)
   end
 
-  defp do_camelize(<<>>) do
-    <<>>
+  defp escape_dot_string(<<>>, acc) do
+    <<acc::binary, ?">>
+  end
+
+  @doc false
+  @deprecated "Use Macro.underscore/1 instead"
+  def underscore(value) do
+    Macro.underscore(value)
+  end
+
+  @doc false
+  @deprecated "Use Macro.camelize/1 instead"
+  def camelize(value) do
+    Macro.camelize(value)
   end
 
   @doc """
@@ -258,8 +586,11 @@ defmodule Mix.Utils do
   end
 
   def module_name_to_command(module, nesting) do
-    t = Regex.split(~r/\./, to_string(module))
-    t |> Enum.drop(nesting) |> Enum.map(&first_to_lower(&1)) |> Enum.join(".")
+    module
+    |> to_string()
+    |> String.split(".")
+    |> Enum.drop(nesting)
+    |> Enum.map_join(".", &Macro.underscore/1)
   end
 
   @doc """
@@ -271,143 +602,279 @@ defmodule Mix.Utils do
       "Compile.Elixir"
 
   """
-  def command_to_module_name(s) do
-    Regex.split(~r/\./, to_string(s)) |>
-      Enum.map(&first_to_upper(&1)) |>
-      Enum.join(".")
+  def command_to_module_name(command) do
+    command
+    |> to_string()
+    |> String.split(".")
+    |> Enum.map_join(".", &Macro.camelize/1)
   end
 
-  defp first_to_upper(<<s, t :: binary>>), do: <<to_upper_char(s)>> <> t
-  defp first_to_upper(<<>>), do: <<>>
-
-  defp first_to_lower(<<s, t :: binary>>), do: <<to_lower_char(s)>> <> t
-  defp first_to_lower(<<>>), do: <<>>
-
-  defp to_upper_char(char) when char in ?a..?z, do: char - 32
-  defp to_upper_char(char), do: char
-
-  defp to_lower_char(char) when char in ?A..?Z, do: char + 32
-  defp to_lower_char(char), do: char
+  @deprecated "Use symlink_or_copy/2"
+  def symlink_or_copy(hard_copy?, source, target) do
+    if hard_copy? do
+      if File.exists?(source) do
+        File.rm_rf!(target)
+        File.cp_r!(source, target)
+      end
+    else
+      symlink_or_copy(source, target)
+    end
+  end
 
   @doc """
-  Symlink directory `source` to `target` or copy it recursively
+  Symlinks directory `source` to `target` or copies it recursively
   in case symlink fails.
 
-  Expect source and target to be absolute paths as it generates
+  In case of conflicts, it copies files only if they have been
+  recently touched.
+
+  Expects source and target to be absolute paths as it generates
   a relative symlink.
   """
+  def symlink_or_copy(path, path) do
+    :ok
+  end
+
   def symlink_or_copy(source, target) do
     if File.exists?(source) do
-      source_list = String.to_char_list(source)
-      case :file.read_link(target) do
-        {:ok, ^source_list} ->
+      # Relative symbolic links on Windows are broken
+      link =
+        case :os.type() do
+          {:win32, _} -> source
+          # We are needing the relative path to the parent dir since we are doing
+          # a symlink
+          _ -> Path.relative_to(source, Path.dirname(target), force: true)
+        end
+
+      case File.read_link(target) do
+        {:ok, ^link} ->
           :ok
+
         {:ok, _} ->
-          File.rm!(target)
-          do_symlink_or_copy(source, target)
+          case File.rm(target) do
+            :ok ->
+              :ok
+
+            {:error, reason} ->
+              reason = IO.iodata_to_binary(:file.format_error(reason))
+
+              Mix.raise("""
+              Cannot remove symlink #{inspect(target)} due to reason: #{reason}"
+
+                * Make sure you have permission to access the _build directory
+                  (you may have the wrong permission if you change users or ran as admin)
+
+                * If you are using Windows, avoid using substitute drives,
+                  as they don't play well with symlinks
+
+                * In case the issue continues, consider removing the _build directory
+              """)
+          end
+
+          do_symlink_or_copy(source, target, link)
+
         {:error, :enoent} ->
-          do_symlink_or_copy(source, target)
+          do_symlink_or_copy(source, target, link)
+
         {:error, _} ->
-          File.rm_rf!(target)
-          do_symlink_or_copy(source, target)
+          if not File.dir?(target) do
+            File.rm_rf!(target)
+          end
+
+          do_symlink_or_copy(source, target, link)
       end
     else
       {:error, :enoent}
     end
   end
 
-  defp do_symlink_or_copy(source, target) do
-    if match? {:win32, _}, :os.type do
-      {:ok, File.cp_r!(source, target)}
-    else
-      symlink_source = make_relative_path(source, target)
-      case :file.make_symlink(symlink_source, target) do
-        :ok -> :ok
-        {:error, _} -> {:ok, File.cp_r!(source, target)}
-      end
+  defp do_symlink_or_copy(source, target, link) do
+    case File.ln_s(link, target) do
+      :ok ->
+        :ok
+
+      {:error, _} ->
+        files =
+          File.cp_r!(source, target,
+            on_conflict: fn orig, dest ->
+              {orig_mtime, orig_size} = last_modified_and_size(orig)
+              {dest_mtime, dest_size} = last_modified_and_size(dest)
+              orig_mtime > dest_mtime or orig_size != dest_size
+            end
+          )
+
+        {:ok, files}
     end
   end
 
-  # Make a relative path in between two paths.
-  # Expects both paths to be fully expanded.
-  defp make_relative_path(source, target) do
-    do_make_relative_path(Path.split(source), Path.split(target))
-  end
+  @doc """
+  Opens and reads content from either a URL or a local file system path.
 
-  defp do_make_relative_path([h|t1], [h|t2]) do
-    do_make_relative_path(t1, t2)
-  end
+  Returns the contents as a `{:ok, binary}`, `:badpath` for invalid
+  paths or `{:local, message}` for local errors and `{:remote, message}`
+  for remote ones.
 
-  defp do_make_relative_path(source, target) do
-    base = List.duplicate("..", max(length(target) - 1, 0))
-    Path.join(base ++ source)
-  end
+  ## Options
 
-  @doc """
-  Opens and reads content from either a URL or a local filesystem path.
+    * `:sha512` - checks against the given SHA-512 checksum. Returns
+      `{:checksum, message}` in case it fails
 
-  Used by tasks like `local.install` and `local.rebar` that support
-  installation either from a URL or a local file.
+    * `:timeout` - times out the request after the given milliseconds.
+      Returns `{:remote, timeout_message}` if it fails. Defaults to 60
+      seconds
 
-  Raises if the given path is not a url, nor a file or if the
-  file or url are invalid.
   """
-  def read_path!(path) do
+  @spec read_path(String.t(), read_path_opts) ::
+          {:ok, binary}
+          | :badpath
+          | {:remote, String.t()}
+          | {:local, String.t()}
+          | {:checksum, String.t()}
+  def read_path(path, opts \\ []) do
     cond do
-      url?(path)  -> read_url(path)
-      file?(path) -> read_file(path)
-      :else       -> Mix.raise "Expected #{path} to be a url or a local file path"
+      url?(path) ->
+        task =
+          Task.async(fn ->
+            with {:ok, binary} <- read_httpc(path) do
+              checksum(binary, opts)
+            end
+          end)
+
+        timeout = Keyword.get(opts, :timeout, 60_000)
+
+        case Task.yield(task, timeout) || Task.shutdown(task, :brutal_kill) do
+          {:ok, result} -> result
+          _ -> {:remote, "request timed out after #{timeout}ms"}
+        end
+
+      file?(path) ->
+        with {:ok, binary} <- read_file(path) do
+          checksum(binary, opts)
+        end
+
+      true ->
+        :badpath
     end
   end
 
+  @checksums [:sha512]
+
+  defp checksum(binary, opts) do
+    Enum.find_value(@checksums, {:ok, binary}, fn hash ->
+      with expected when expected != nil <- opts[hash],
+           actual when actual != expected <- hexhash(binary, hash) do
+        message = """
+        Data does not match the given SHA-512 checksum.
+
+        Expected: #{expected}
+          Actual: #{actual}
+        """
+
+        {:checksum, message}
+      else
+        _ -> nil
+      end
+    end)
+  end
+
+  defp hexhash(binary, hash) do
+    Base.encode16(:crypto.hash(hash, binary), case: :lower)
+  end
+
   defp read_file(path) do
-    File.read!(path)
+    try do
+      {:ok, File.read!(path)}
+    rescue
+      e in [File.Error] -> {:local, Exception.message(e)}
+    end
   end
 
-  defp read_url(path) do
-    :ssl.start
-    :inets.start
+  defp read_httpc(path) do
+    Mix.ensure_application!(:public_key)
+    Mix.ensure_application!(:ssl)
+    Mix.ensure_application!(:inets)
 
-    # Starting a http client profile allows us to scope
-    # the effects of using a http proxy to this function
-    {:ok, pid} = :inets.start(:httpc, [{:profile, :mix}])
+    {:ok, _} = Application.ensure_all_started(:ssl)
+    {:ok, _} = Application.ensure_all_started(:inets)
 
-    headers = [{'user-agent', 'Mix/#{System.version}'}]
+    # Starting an HTTP client profile allows us to scope
+    # the effects of using an HTTP proxy to this function
+    {:ok, _pid} = :inets.start(:httpc, profile: :mix)
+
+    headers = [{~c"user-agent", ~c"Mix/#{System.version()}"}]
     request = {:binary.bin_to_list(path), headers}
 
-    # If a proxy environment variable was supplied add a proxy to httpc
-    if http_proxy = System.get_env("HTTP_PROXY"), do: proxy(http_proxy)
-    if https_proxy = System.get_env("HTTPS_PROXY"), do: proxy(https_proxy)
+    # allow override of system CA certs to support running on managed networks
+    # using an SSL proxy etc. Piggy back on Hex defined environment variable
+    # rather than creating a new one, as these are almost always going to be
+    # set and used together.
+    cacert_opt =
+      case System.get_env("HEX_CACERTS_PATH") do
+        nil -> {:cacerts, :public_key.cacerts_get()}
+        file -> {:cacertfile, file}
+      end
+
+    # Use the system certificates
+    ssl_options = [
+      cacert_opt,
+      verify: :verify_peer,
+      customize_hostname_check: [match_fun: :public_key.pkix_verify_hostname_match_fun(:https)]
+    ]
 
-    # We are using relaxed: true because some clients is returning a Location
+    # We are using relaxed: true because some servers is returning a Location
     # header with relative paths, which does not follow the spec. This would
     # cause the request to fail with {:error, :no_scheme} unless :relaxed
     # is given.
-    case :httpc.request(:get, request, [relaxed: true], [body_format: :binary], :mix) do
+    #
+    # If a proxy environment variable was supplied add a proxy to httpc.
+    http_options = [relaxed: true, ssl: ssl_options] ++ proxy_config(path)
+
+    # Silence the warning from OTP as we verify the contents
+    level = Logger.level()
+    Logger.configure(level: :error)
+
+    try do
+      case httpc_request(request, http_options) do
+        {:error, {:failed_connect, [{:to_address, _}, {inet, _, reason}]}}
+        when inet in [:inet, :inet6] and
+               reason in [:ehostunreach, :enetunreach, :eprotonosupport, :nxdomain] ->
+          :httpc.set_options([ipfamily: fallback(inet)], :mix)
+          request |> httpc_request(http_options) |> httpc_response()
+
+        {:error, {:failed_connect, [{:to_address, _}, {inet, _, reason}]}}
+        when inet in [:inet, :inet6] and elem(reason, 0) == :tls_alert ->
+          http_options = put_in(http_options, [:ssl, :middlebox_comp_mode], false)
+          request |> httpc_request(http_options) |> httpc_response()
+
+        response ->
+          httpc_response(response)
+      end
+    after
+      Logger.configure(level: level)
+      :inets.stop(:httpc, :mix)
+    end
+  end
+
+  defp fallback(:inet), do: :inet6
+  defp fallback(:inet6), do: :inet
+
+  defp httpc_request(request, http_options) do
+    :httpc.request(:get, request, http_options, [body_format: :binary], :mix)
+  end
+
+  defp httpc_response(response) do
+    case response do
       {:ok, {{_, status, _}, _, body}} when status in 200..299 ->
-        body
+        {:ok, body}
+
       {:ok, {{_, status, _}, _, _}} ->
-        Mix.raise "Could not access url #{path}, got status: #{status}"
+        {:remote, "httpc request failed with: {:bad_status_code, #{status}}"}
+
       {:error, reason} ->
-        Mix.raise "Could not access url #{path}, error: #{inspect reason}"
+        {:remote, "httpc request failed with: #{inspect(reason)}"}
     end
-  after
-    :inets.stop(:httpc, :mix)
   end
 
-  defp proxy(proxy) do
-     uri = URI.parse(proxy)
-     :httpc.set_options([{ proxy_scheme(uri.scheme),
-         { { uri.host |> String.to_char_list, uri.port }, [] } }], :mix)
-   end
-
-   defp proxy_scheme(scheme) do
-     case scheme do
-       "http" -> :proxy
-       "https" -> :https_proxy
-     end
-   end
-
   defp file?(path) do
     File.regular?(path)
   end
@@ -415,4 +882,171 @@ defmodule Mix.Utils do
   defp url?(path) do
     URI.parse(path).scheme in ["http", "https"]
   end
+
+  def proxy_config(url) do
+    {http_proxy, https_proxy} = proxy_env()
+
+    proxy_auth(URI.parse(url), http_proxy, https_proxy)
+  end
+
+  defp proxy_env do
+    http_proxy = System.get_env("HTTP_PROXY") || System.get_env("http_proxy")
+    https_proxy = System.get_env("HTTPS_PROXY") || System.get_env("https_proxy")
+    no_proxy = no_proxy_env() |> no_proxy_list()
+
+    {proxy_setup(:http, http_proxy, no_proxy), proxy_setup(:https, https_proxy, no_proxy)}
+  end
+
+  defp no_proxy_env() do
+    System.get_env("NO_PROXY") || System.get_env("no_proxy")
+  end
+
+  defp no_proxy_list(nil) do
+    []
+  end
+
+  defp no_proxy_list(no_proxy) do
+    no_proxy
+    |> String.split(",")
+    |> Enum.map(&String.to_charlist/1)
+  end
+
+  defp proxy_setup(scheme, proxy, no_proxy) do
+    uri = URI.parse(proxy || "")
+
+    if uri.host && uri.port do
+      host = String.to_charlist(uri.host)
+      :httpc.set_options([{proxy_scheme(scheme), {{host, uri.port}, no_proxy}}], :mix)
+    end
+
+    uri
+  end
+
+  defp proxy_scheme(scheme) do
+    case scheme do
+      :http -> :proxy
+      :https -> :https_proxy
+    end
+  end
+
+  defp proxy_auth(%URI{scheme: "http"}, http_proxy, _https_proxy), do: proxy_auth(http_proxy)
+  defp proxy_auth(%URI{scheme: "https"}, _http_proxy, https_proxy), do: proxy_auth(https_proxy)
+
+  defp proxy_auth(nil), do: []
+  defp proxy_auth(%URI{userinfo: nil}), do: []
+
+  defp proxy_auth(%URI{userinfo: auth}) do
+    destructure [user, pass], String.split(auth, ":", parts: 2)
+
+    user = String.to_charlist(user)
+    pass = String.to_charlist(pass || "")
+
+    [proxy_auth: {user, pass}]
+  end
+
+  @doc """
+  Returns the user id of the currently running process.
+
+  The user id is obtained by creating a temporary file and checking
+  it's UID. Note that the UID may be `nil` on non-Unix systems.
+  """
+  def detect_user_id!() do
+    case Mix.State.fetch(:user_id) do
+      {:ok, uid} ->
+        uid
+
+      :error ->
+        dir = System.tmp_dir!()
+        File.mkdir_p!(dir)
+        rand = :crypto.strong_rand_bytes(3) |> Base.url_encode64()
+        path = Path.join(dir, "mix_user_check_#{System.os_time()}_#{rand}")
+
+        uid =
+          try do
+            File.touch!(path)
+            File.stat!(path)
+          else
+            %{uid: :undefined} -> nil
+            %{uid: uid} -> uid
+          after
+            File.rm(path)
+          end
+
+        Mix.State.put(:user_id, uid)
+        uid
+    end
+  end
+
+  @doc """
+  Convert the given terms to a consultable Erlang term.
+  """
+  def consultable(term) do
+    {:ok, to_erl_term(term)}
+  catch
+    {:error, term, reason} -> {:error, term, reason}
+  end
+
+  defp to_erl_term(tuple) when is_tuple(tuple) do
+    [?{, tuple |> Tuple.to_list() |> to_erl_head(), ?}]
+  end
+
+  defp to_erl_term(list) when is_list(list) do
+    if List.ascii_printable?(list) do
+      :io_lib.print(list)
+    else
+      [?[, to_erl_head(list), ?]]
+    end
+  end
+
+  defp to_erl_term(%Regex{re_pattern: {:re_pattern, _, _, _, ref}} = regex)
+       when is_reference(ref) do
+    throw({:error, regex, "you must use the /E modifier to store regexes"})
+  end
+
+  defp to_erl_term(map) when is_map(map) do
+    inner =
+      Enum.map_intersperse(
+        :maps.to_list(:maps.iterator(map, :reversed)),
+        ?,,
+        fn {key, value} -> [to_erl_term(key), "=>", to_erl_term(value)] end
+      )
+
+    [?#, ?{, inner, ?}]
+  end
+
+  defp to_erl_term(map) when is_map(map) do
+    inner =
+      Enum.map_intersperse(
+        :maps.to_list(:maps.iterator(map, :reversed)),
+        ?,,
+        fn {key, value} -> [to_erl_term(key), "=>", to_erl_term(value)] end
+      )
+
+    [?#, ?{, inner, ?}]
+  end
+
+  defp to_erl_term(function) when is_function(function) do
+    fun_info = Function.info(function)
+
+    if fun_info[:type] == :external and fun_info[:env] == [] do
+      :io_lib.print(function)
+    else
+      throw({:error, function, "only functions in the form &Mod.fun/arity are allowed"})
+    end
+  end
+
+  defp to_erl_term(term) when is_reference(term) or is_pid(term) do
+    throw({:error, term, "PIDs and References are not supported"})
+  end
+
+  defp to_erl_term(term) do
+    :io_lib.print(term)
+  end
+
+  defp to_erl_head([]), do: []
+  defp to_erl_head([h | t]), do: [to_erl_term(h) | to_erl_tail(t)]
+
+  defp to_erl_tail([h | t]), do: [?,, to_erl_term(h) | to_erl_tail(t)]
+  defp to_erl_tail([]), do: []
+  defp to_erl_tail(other), do: [?|, to_erl_term(other)]
 end
diff --git a/lib/mix/mix.exs b/lib/mix/mix.exs
index 39f6ee8d8d1..007a3362faf 100644
--- a/lib/mix/mix.exs
+++ b/lib/mix/mix.exs
@@ -1,19 +1,24 @@
-defmodule Mix.Mixfile do
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+defmodule Mix.MixProject do
   use Mix.Project
 
   def project do
-    [app: :mix,
-     build_per_environment: false,
-     version: System.version,
-     escript_main_module: Mix.CLI]
+    [
+      app: :mix,
+      build_per_environment: false,
+      version: System.version(),
+      escript: [main_module: Mix.CLI]
+    ]
   end
 
   def application do
-    [registered: [Mix.TasksServer, Mix.ProjectStack],
-     mod: {Mix, []},
-     env: [shell: Mix.Shell.IO,
-           env: :dev,
-           scm: [Mix.SCM.Git, Mix.SCM.Path],
-           colors: []]]
+    [
+      registered: [Mix.State, Mix.TasksServer, Mix.ProjectStack],
+      mod: {Mix, []},
+      env: [colors: []]
+    ]
   end
 end
diff --git a/lib/mix/test/fixtures/.gitignore b/lib/mix/test/fixtures/.gitignore
index a9a1386193c..6427f8a871e 100644
--- a/lib/mix/test/fixtures/.gitignore
+++ b/lib/mix/test/fixtures/.gitignore
@@ -1,3 +1,11 @@
-git_repo
-deps_on_git_repo
-git_rebar
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+# Remember to update Makefile "clean_residual_files" target for any modifications
+# made in this file.
+/deps_on_git_repo/
+/git_rebar/
+/git_repo/
+/git_sparse_repo/
+/archive/ebin/
diff --git a/lib/mix/test/fixtures/archive/ebin/Elixir.Mix.Tasks.Local.Sample.beam b/lib/mix/test/fixtures/archive/ebin/Elixir.Mix.Tasks.Local.Sample.beam
deleted file mode 100644
index e938712cf40..00000000000
Binary files a/lib/mix/test/fixtures/archive/ebin/Elixir.Mix.Tasks.Local.Sample.beam and /dev/null differ
diff --git a/lib/mix/test/fixtures/archive/invalid-archive-0.1.0.ez b/lib/mix/test/fixtures/archive/invalid-archive-0.1.0.ez
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/lib/mix/test/fixtures/archive/lib/local.sample.ex b/lib/mix/test/fixtures/archive/lib/local.sample.ex
index 0ecafccdc80..2471b86136e 100644
--- a/lib/mix/test/fixtures/archive/lib/local.sample.ex
+++ b/lib/mix/test/fixtures/archive/lib/local.sample.ex
@@ -1,10 +1,10 @@
 defmodule Mix.Tasks.Local.Sample do
   use Mix.Task
 
-  @shortdoc  "A local install sample"
+  @shortdoc "A local install sample"
   @moduledoc "A local install sample"
 
   def run(_) do
-    Mix.shell.info "sample"
+    Mix.shell().info("sample")
   end
-end
\ No newline at end of file
+end
diff --git a/lib/mix/test/fixtures/archive/priv/.dot_file b/lib/mix/test/fixtures/archive/priv/.dot_file
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/lib/mix/test/fixtures/compile_erlang/src/b.erl b/lib/mix/test/fixtures/compile_erlang/src/b.erl
index 05d830f4d69..ab8cb39190f 100644
--- a/lib/mix/test/fixtures/compile_erlang/src/b.erl
+++ b/lib/mix/test/fixtures/compile_erlang/src/b.erl
@@ -1,6 +1,7 @@
 -module(b).
--compile(export_all).
+-export([b/0]).
 
+-callback c() -> term().
 -record(br, {cell=undefined}).
 
-b() -> #br{cell=specified}.
\ No newline at end of file
+b() -> #br{cell=specified}.
diff --git a/lib/mix/test/fixtures/compile_erlang/src/c.erl b/lib/mix/test/fixtures/compile_erlang/src/c.erl
index 78f1022eaa7..62c54b0b4d1 100644
--- a/lib/mix/test/fixtures/compile_erlang/src/c.erl
+++ b/lib/mix/test/fixtures/compile_erlang/src/c.erl
@@ -1,6 +1,7 @@
 -module(c).
--compile(export_all).
+-export([c/0]).
 
 -include("r.hrl").
+-behaviour(b).
 
-c() -> #r{cell=specified}.
\ No newline at end of file
+c() -> #r{cell=specified}.
diff --git a/lib/mix/test/fixtures/compile_listeners/deps/reloader/lib/reloader.ex b/lib/mix/test/fixtures/compile_listeners/deps/reloader/lib/reloader.ex
new file mode 100644
index 00000000000..6584dc5c772
--- /dev/null
+++ b/lib/mix/test/fixtures/compile_listeners/deps/reloader/lib/reloader.ex
@@ -0,0 +1,51 @@
+defmodule Reloader do
+  use GenServer
+
+  def start_link(_opts) do
+    GenServer.start_link(__MODULE__, {})
+  end
+
+  @impl true
+  def init({}) do
+    {:ok, {}}
+  end
+
+  @impl true
+  def handle_info({:modules_compiled, info}, state) do
+    %{
+      modules_diff: %{added: added, changed: changed, removed: removed, timestamp: _timestamp},
+      app: app,
+      scm: scm,
+      os_pid: os_pid
+    } = info
+
+    IO.write("""
+    Received :modules_compiled with
+      added: #{inspect(Enum.sort(added))}, changed: #{inspect(Enum.sort(changed))}, removed: #{inspect(Enum.sort(removed))}
+      app: #{inspect(app)}
+      scm: #{inspect(scm)}
+      os_pid: #{inspect(os_pid)}
+    """)
+
+    {:noreply, state}
+  end
+
+  def handle_info({:dep_compiled, info}, state) do
+    %{
+      app: app,
+      scm: scm,
+      manager: manager,
+      os_pid: os_pid
+    } = info
+
+    IO.write("""
+    Received :dep_compiled with
+      app: #{inspect(app)}
+      scm: #{inspect(scm)}
+      manager: #{inspect(manager)}
+      os_pid: #{inspect(os_pid)}
+    """)
+
+    {:noreply, state}
+  end
+end
diff --git a/lib/mix/test/fixtures/compile_listeners/deps/reloader/mix.exs b/lib/mix/test/fixtures/compile_listeners/deps/reloader/mix.exs
new file mode 100644
index 00000000000..5f6f6b8bd09
--- /dev/null
+++ b/lib/mix/test/fixtures/compile_listeners/deps/reloader/mix.exs
@@ -0,0 +1,16 @@
+defmodule Reloader.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :reloader,
+      version: "0.1.0"
+    ]
+  end
+
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
+  end
+end
diff --git a/lib/mix/test/fixtures/config.exs b/lib/mix/test/fixtures/config.exs
new file mode 100644
index 00000000000..be2b392327d
--- /dev/null
+++ b/lib/mix/test/fixtures/config.exs
@@ -0,0 +1,3 @@
+import Config
+
+config :my_app, :key, :value
diff --git a/lib/mix/test/fixtures/configs/bad_import.exs b/lib/mix/test/fixtures/configs/bad_import.exs
deleted file mode 100644
index 2fce1f4eca8..00000000000
--- a/lib/mix/test/fixtures/configs/bad_import.exs
+++ /dev/null
@@ -1,3 +0,0 @@
-use Mix.Config
-
-import_config "bad_root.exs"
\ No newline at end of file
diff --git a/lib/mix/test/fixtures/configs/bad_root.exs b/lib/mix/test/fixtures/configs/bad_root.exs
deleted file mode 100644
index 18a16f3c9d2..00000000000
--- a/lib/mix/test/fixtures/configs/bad_root.exs
+++ /dev/null
@@ -1 +0,0 @@
-:oops
diff --git a/lib/mix/test/fixtures/configs/good_config.exs b/lib/mix/test/fixtures/configs/good_config.exs
deleted file mode 100644
index 34c8084ccaf..00000000000
--- a/lib/mix/test/fixtures/configs/good_config.exs
+++ /dev/null
@@ -1 +0,0 @@
-[my_app: [key: :value]]
\ No newline at end of file
diff --git a/lib/mix/test/fixtures/deps_cycle/app1/mix.exs b/lib/mix/test/fixtures/deps_cycle/app1/mix.exs
new file mode 100644
index 00000000000..d0d6d3d271c
--- /dev/null
+++ b/lib/mix/test/fixtures/deps_cycle/app1/mix.exs
@@ -0,0 +1,13 @@
+defmodule App1 do
+  use Mix.Project
+
+  def project do
+    [
+      app: :app1,
+      version: "0.1.0",
+      deps: [
+        {:app2, "0.1.0", in_umbrella: true}
+      ]
+    ]
+  end
+end
diff --git a/lib/mix/test/fixtures/deps_cycle/app2/mix.exs b/lib/mix/test/fixtures/deps_cycle/app2/mix.exs
new file mode 100644
index 00000000000..bc201e673cc
--- /dev/null
+++ b/lib/mix/test/fixtures/deps_cycle/app2/mix.exs
@@ -0,0 +1,13 @@
+defmodule App2 do
+  use Mix.Project
+
+  def project do
+    [
+      app: :app2,
+      version: "0.1.0",
+      deps: [
+        {:app1, "0.1.0", in_umbrella: true}
+      ]
+    ]
+  end
+end
diff --git a/lib/mix/test/fixtures/deps_status/_build/dev/lib/nosemver/ebin/nosemver.app b/lib/mix/test/fixtures/deps_status/_build/dev/lib/nosemver/ebin/nosemver.app
new file mode 100644
index 00000000000..bbcfa729b70
--- /dev/null
+++ b/lib/mix/test/fixtures/deps_status/_build/dev/lib/nosemver/ebin/nosemver.app
@@ -0,0 +1,3 @@
+{application, nosemver, [
+  {vsn,"0.7"}
+]}.
\ No newline at end of file
diff --git a/lib/mix/test/fixtures/deps_status/custom/deps_repo/mix.exs b/lib/mix/test/fixtures/deps_status/custom/deps_repo/mix.exs
index 91b8a2106c9..79a64172615 100644
--- a/lib/mix/test/fixtures/deps_status/custom/deps_repo/mix.exs
+++ b/lib/mix/test/fixtures/deps_status/custom/deps_repo/mix.exs
@@ -2,12 +2,12 @@ defmodule DepsRepo do
   use Mix.Project
 
   def project do
+    opts = Process.get(:custom_deps_git_repo_opts) || []
+
     [
       app: :deps_repo,
       version: "0.1.0",
-      deps: [
-        {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo")}
-      ]
+      deps: [{:git_repo, "0.1.0", [git: MixTest.Case.fixture_path("git_repo")] ++ opts}]
     ]
   end
-end
\ No newline at end of file
+end
diff --git a/lib/mix/test/fixtures/deps_status/custom/noscm_repo/mix.exs b/lib/mix/test/fixtures/deps_status/custom/noscm_repo/mix.exs
index 1c182683647..7fa506404ef 100644
--- a/lib/mix/test/fixtures/deps_status/custom/noscm_repo/mix.exs
+++ b/lib/mix/test/fixtures/deps_status/custom/noscm_repo/mix.exs
@@ -2,7 +2,8 @@ defmodule NoSCMRepo do
   use Mix.Project
 
   def project do
-    [ app: :noscm_repo,
+    [
+      app: :noscm_repo,
       version: "0.1.0",
       deps: [
         {:git_repo, "0.1.0"}
diff --git a/lib/mix/test/fixtures/deps_status/custom/raw_repo/lib/raw_repo.ex b/lib/mix/test/fixtures/deps_status/custom/raw_repo/lib/raw_repo.ex
index 6774ba7ddf8..b893d48bc67 100644
--- a/lib/mix/test/fixtures/deps_status/custom/raw_repo/lib/raw_repo.ex
+++ b/lib/mix/test/fixtures/deps_status/custom/raw_repo/lib/raw_repo.ex
@@ -1,5 +1,7 @@
+Application.compile_env(:raw_repo, :compile_env)
+
 defmodule RawRepo do
   def hello do
     "world"
   end
-end
\ No newline at end of file
+end
diff --git a/lib/mix/test/fixtures/deps_status/custom/raw_repo/mix.exs b/lib/mix/test/fixtures/deps_status/custom/raw_repo/mix.exs
index d53b107b8db..9f9aa88a7a8 100644
--- a/lib/mix/test/fixtures/deps_status/custom/raw_repo/mix.exs
+++ b/lib/mix/test/fixtures/deps_status/custom/raw_repo/mix.exs
@@ -1,8 +1,8 @@
-defmodule RawRepo.Mix do
+defmodule RawRepo.MixProject do
   use Mix.Project
 
   def project do
-    Mix.shell.info ":raw_repo env is #{Mix.env}"
+    Mix.shell().info(":raw_repo env is #{Mix.env()}")
     [app: :raw_repo, version: "0.1.0"]
   end
 end
diff --git a/lib/mix/test/fixtures/deps_status/deps/invalidapp/mix.exs b/lib/mix/test/fixtures/deps_status/deps/invalidapp/mix.exs
index 4c26c245b42..3a92fc4fd8d 100644
--- a/lib/mix/test/fixtures/deps_status/deps/invalidapp/mix.exs
+++ b/lib/mix/test/fixtures/deps_status/deps/invalidapp/mix.exs
@@ -1,8 +1,10 @@
-defmodule InvalidApp.Mixfile do
+defmodule InvalidApp.MixProject do
   use Mix.Project
 
   def project do
-    [ app: :invalidapp,
-      version: "1.0" ]
+    [
+      app: :invalidapp,
+      version: "1.0"
+    ]
   end
 end
diff --git a/lib/mix/test/fixtures/deps_status/deps/nosemver/.gitkeep b/lib/mix/test/fixtures/deps_status/deps/nosemver/.gitkeep
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/lib/mix/test/fixtures/deps_status/deps/ok/mix.exs b/lib/mix/test/fixtures/deps_status/deps/ok/mix.exs
index e914a1ee7a1..30c904f52b2 100644
--- a/lib/mix/test/fixtures/deps_status/deps/ok/mix.exs
+++ b/lib/mix/test/fixtures/deps_status/deps/ok/mix.exs
@@ -1,8 +1,16 @@
-defmodule Ok.Mixfile do
+defmodule Ok.MixProject do
   use Mix.Project
 
   def project do
-    [ app: :ok,
-      version: "0.1.0" ]
+    [
+      app: :ok,
+      version: "0.1.0"
+    ]
+  end
+
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
   end
 end
diff --git a/lib/mix/test/fixtures/escript_test/config/config.exs b/lib/mix/test/fixtures/escript_test/config/config.exs
new file mode 100644
index 00000000000..59f8ec133eb
--- /dev/null
+++ b/lib/mix/test/fixtures/escript_test/config/config.exs
@@ -0,0 +1,3 @@
+import Config
+
+config :escript_test, erl_val: "Erlang value"
diff --git a/lib/mix/test/fixtures/escript_test/lib/escript_test.ex b/lib/mix/test/fixtures/escript_test/lib/escript_test.ex
new file mode 100644
index 00000000000..c5b6b4efe34
--- /dev/null
+++ b/lib/mix/test/fixtures/escript_test/lib/escript_test.ex
@@ -0,0 +1,36 @@
+defmodule EscriptTest do
+  def start do
+    :ok = Application.start(:escript_test)
+  end
+
+  def main(["--protocol", protocol]) do
+    IO.puts(Protocol.consolidated?(Module.concat([protocol])))
+  end
+
+  def main(["--nesting"]) do
+    IO.inspect(Application.get_env(:foobar, :nesting, "TEST"))
+  end
+
+  def main(["--app-paths"]) do
+    elixir_path = Application.app_dir(:elixir) |> String.to_charlist()
+    escript_test_path = Application.app_dir(:escript_test) |> String.to_charlist()
+
+    IO.inspect({
+      elixir_path != escript_test_path,
+      match?({:ok, _}, :erl_prim_loader.list_dir(elixir_path)),
+      match?({:ok, _}, :erl_prim_loader.list_dir(escript_test_path))
+    })
+  end
+
+  def main(["--list-priv", app_name]) do
+    # Note: :erl_prim_loader usage with Escript is currently deprecated,
+    # but we use it only in tests for convenience
+
+    app = String.to_atom(app_name)
+    :erl_prim_loader.list_dir(~c"#{:code.lib_dir(app)}/priv") |> IO.inspect()
+  end
+
+  def main(_argv) do
+    IO.puts(Application.get_env(:foobar, :value, "TEST"))
+  end
+end
diff --git a/lib/mix/test/fixtures/escripttest/priv/hello/world.txt b/lib/mix/test/fixtures/escript_test/priv/hello/world.txt
similarity index 100%
rename from lib/mix/test/fixtures/escripttest/priv/hello/world.txt
rename to lib/mix/test/fixtures/escript_test/priv/hello/world.txt
diff --git a/lib/mix/test/fixtures/escript_test/src/escript_test.erl b/lib/mix/test/fixtures/escript_test/src/escript_test.erl
new file mode 100644
index 00000000000..c7b40bdedb6
--- /dev/null
+++ b/lib/mix/test/fixtures/escript_test/src/escript_test.erl
@@ -0,0 +1,10 @@
+-module(escript_test).
+
+-export([start/0, main/1]).
+
+
+start() ->
+    ok = application:start(escript_test).
+
+main(Args) ->
+    io:format("~p", [Args]).
diff --git a/lib/mix/test/fixtures/escripttest/lib/escripttest.ex b/lib/mix/test/fixtures/escripttest/lib/escripttest.ex
deleted file mode 100644
index bb60666e0b0..00000000000
--- a/lib/mix/test/fixtures/escripttest/lib/escripttest.ex
+++ /dev/null
@@ -1,9 +0,0 @@
-defmodule Escripttest do
-  def start do
-    :ok = Application.start(:escripttest)
-  end
-  
-  def main(_args) do
-    IO.puts "TEST"
-  end
-end
diff --git a/lib/mix/test/fixtures/no_mixfile/lib/a.ex b/lib/mix/test/fixtures/no_mixfile/lib/a.ex
index 5a81e4b84b6..c8eb6fa27d2 100644
--- a/lib/mix/test/fixtures/no_mixfile/lib/a.ex
+++ b/lib/mix/test/fixtures/no_mixfile/lib/a.ex
@@ -1,3 +1,2 @@
 defmodule A do
-  
-end
\ No newline at end of file
+end
diff --git a/lib/mix/test/fixtures/no_mixfile/lib/b.ex b/lib/mix/test/fixtures/no_mixfile/lib/b.ex
index faf04809dbf..067ffa22218 100644
--- a/lib/mix/test/fixtures/no_mixfile/lib/b.ex
+++ b/lib/mix/test/fixtures/no_mixfile/lib/b.ex
@@ -1,3 +1,2 @@
 defmodule B do
-  
-end
\ No newline at end of file
+end
diff --git a/lib/mix/test/fixtures/no_mixfile/lib/c.ex b/lib/mix/test/fixtures/no_mixfile/lib/c.ex
deleted file mode 100644
index f998cc3153b..00000000000
--- a/lib/mix/test/fixtures/no_mixfile/lib/c.ex
+++ /dev/null
@@ -1,3 +0,0 @@
-defmodule C do
-  
-end
\ No newline at end of file
diff --git a/lib/mix/test/fixtures/only_deps/mix.exs b/lib/mix/test/fixtures/only_deps/mix.exs
deleted file mode 100644
index 7a10e965a22..00000000000
--- a/lib/mix/test/fixtures/only_deps/mix.exs
+++ /dev/null
@@ -1,8 +0,0 @@
-defmodule OnlyDeps.Mix do
-  use Mix.Project
-
-  def project do
-    [app: :only_deps, version: "0.1.0",
-     deps: [{:git_repo, git: MixTest.Case.fixture_path("git_repo"), only: :other_env}] ]
-  end
-end
diff --git a/lib/mix/test/fixtures/rebar3 b/lib/mix/test/fixtures/rebar3
new file mode 100755
index 00000000000..d9429ef24ca
Binary files /dev/null and b/lib/mix/test/fixtures/rebar3 differ
diff --git a/lib/mix/test/fixtures/rebar_dep/apps/rebar_dep/rebar.config b/lib/mix/test/fixtures/rebar_dep/apps/rebar_dep/rebar.config
deleted file mode 100644
index 5aa4353dc4f..00000000000
--- a/lib/mix/test/fixtures/rebar_dep/apps/rebar_dep/rebar.config
+++ /dev/null
@@ -1 +0,0 @@
-{sub_dirs, ["from_apps_another"]}.
\ No newline at end of file
diff --git a/lib/mix/test/fixtures/rebar_dep/rebar.config b/lib/mix/test/fixtures/rebar_dep/rebar.config
index e2980548ee2..8fef26fd5b8 100644
--- a/lib/mix/test/fixtures/rebar_dep/rebar.config
+++ b/lib/mix/test/fixtures/rebar_dep/rebar.config
@@ -1,5 +1,2 @@
-{sub_dirs, ["apps/*"]}.
-
-{deps, [
-    {git_rebar, "0.1..*", {git, "../../test/fixtures/git_rebar", master}}
-]}.
+{erl_opts, [warnings_as_errors]}.
+{project_plugins, [remove_me]}.
diff --git a/lib/mix/test/fixtures/rebar_dep/rebar.config.script b/lib/mix/test/fixtures/rebar_dep/rebar.config.script
index e15a35f8c84..59bbdcb4ec8 100644
--- a/lib/mix/test/fixtures/rebar_dep/rebar.config.script
+++ b/lib/mix/test/fixtures/rebar_dep/rebar.config.script
@@ -1 +1,9 @@
-CONFIG ++ [{'SCRIPT', SCRIPT}].
+CFG1 = CONFIG ++
+[{'SCRIPT', SCRIPT}] ++
+[{deps, [{git_rebar, "0.1..*", {git, filename:absname("../../test/fixtures/git_rebar"), main}}]}].
+
+case {os:getenv("FILE_FROM_ENV"), os:getenv("CONTENTS_FROM_ENV")} of
+  {false, _} -> ok;
+  {File, Contents} -> file:write_file(File, [Contents])
+end,
+CFG1.
diff --git a/lib/mix/test/fixtures/rebar_dep/apps/rebar_dep/src/rebar_dep.app.src b/lib/mix/test/fixtures/rebar_dep/src/rebar_dep.app.src
similarity index 100%
rename from lib/mix/test/fixtures/rebar_dep/apps/rebar_dep/src/rebar_dep.app.src
rename to lib/mix/test/fixtures/rebar_dep/src/rebar_dep.app.src
diff --git a/lib/mix/test/fixtures/rebar_dep/apps/rebar_dep/src/rebar_dep.erl b/lib/mix/test/fixtures/rebar_dep/src/rebar_dep.erl
similarity index 100%
rename from lib/mix/test/fixtures/rebar_dep/apps/rebar_dep/src/rebar_dep.erl
rename to lib/mix/test/fixtures/rebar_dep/src/rebar_dep.erl
diff --git a/lib/mix/test/fixtures/rebar_override/rebar.config.script b/lib/mix/test/fixtures/rebar_override/rebar.config.script
new file mode 100644
index 00000000000..98fefb465e7
--- /dev/null
+++ b/lib/mix/test/fixtures/rebar_override/rebar.config.script
@@ -0,0 +1,8 @@
+[
+  {deps, [
+    {git_rebar, {git, filename:absname("../../test/fixtures/git_rebar")}}
+  ]},
+  {overrides, [
+    {override, git_rebar, [{deps, [{git_repo, {git, filename:absname("../../test/fixtures/git_repo")}}]}]}
+  ]}
+].
diff --git a/lib/mix/test/fixtures/release_test/config/config.exs b/lib/mix/test/fixtures/release_test/config/config.exs
new file mode 100644
index 00000000000..e6f4c53c3cf
--- /dev/null
+++ b/lib/mix/test/fixtures/release_test/config/config.exs
@@ -0,0 +1,4 @@
+import Config
+
+config :release_test, :static, :was_set
+config :release_test, :encoding, {:_μ, :"£", "£", ~c"£"}
diff --git a/lib/mix/test/fixtures/release_test/lib/release_test.ex b/lib/mix/test/fixtures/release_test/lib/release_test.ex
new file mode 100644
index 00000000000..d8a5d4f755f
--- /dev/null
+++ b/lib/mix/test/fixtures/release_test/lib/release_test.ex
@@ -0,0 +1,47 @@
+defmodule ReleaseTest do
+  use Application
+
+  def start(_type, _args) do
+    cookie = System.get_env("RELEASE_COOKIE")
+    {:ok, [[sys_config]]} = :init.get_argument(:config)
+
+    info = %{
+      app_dir: Application.app_dir(:release_test),
+      cookie_env: cookie,
+      encoding: Application.get_env(:release_test, :encoding),
+      mode: :code.get_mode(),
+      node: node(),
+      protocols_consolidated?: Protocol.consolidated?(Enumerable),
+      release_name: System.get_env("RELEASE_NAME"),
+      release_mode: System.get_env("RELEASE_MODE"),
+      release_node: System.get_env("RELEASE_NODE"),
+      release_root: System.get_env("RELEASE_ROOT"),
+      release_vsn: System.get_env("RELEASE_VSN"),
+      release_prog: System.get_env("RELEASE_PROG"),
+      root_dir: :code.root_dir() |> to_string(),
+      runtime_config: Application.fetch_env(:release_test, :runtime),
+      static_config: Application.fetch_env(:release_test, :static),
+      sys_config_env: System.get_env("RELEASE_SYS_CONFIG"),
+      sys_config_init: to_string(sys_config)
+    }
+
+    path = Path.join(System.get_env("RELEASE_ROOT"), "RELEASE_BOOTED")
+    File.write!(path, :erlang.term_to_binary(info))
+
+    if System.get_env("BOOTED_ONCE") do
+      IO.puts("RESTARTED!!!")
+    else
+      System.put_env("BOOTED_ONCE", "1")
+    end
+
+    if System.get_env("RELEASE_NAME") =~ "permanent" do
+      Supervisor.start_link([], strategy: :one_for_one)
+    else
+      System.halt(0)
+    end
+  end
+
+  def hello_world do
+    IO.puts("hello world")
+  end
+end
diff --git a/lib/mix/test/fixtures/release_test/mix.exs b/lib/mix/test/fixtures/release_test/mix.exs
new file mode 100644
index 00000000000..dd28a28b818
--- /dev/null
+++ b/lib/mix/test/fixtures/release_test/mix.exs
@@ -0,0 +1,17 @@
+defmodule ReleaseTest.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :release_test,
+      version: "0.1.0"
+    ]
+  end
+
+  def application do
+    [
+      extra_applications: [:logger, :runtime_tools],
+      mod: {ReleaseTest, []}
+    ]
+  end
+end
diff --git a/lib/mix/test/fixtures/release_test/priv/hello b/lib/mix/test/fixtures/release_test/priv/hello
new file mode 100644
index 00000000000..04fea06420c
--- /dev/null
+++ b/lib/mix/test/fixtures/release_test/priv/hello
@@ -0,0 +1 @@
+world
\ No newline at end of file
diff --git a/lib/mix/test/fixtures/test_failed/mix.exs b/lib/mix/test/fixtures/test_failed/mix.exs
new file mode 100644
index 00000000000..ef7cc5749e9
--- /dev/null
+++ b/lib/mix/test/fixtures/test_failed/mix.exs
@@ -0,0 +1,11 @@
+defmodule TestFailed.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :test_only_failures,
+      version: "0.0.1",
+      test_load_filters: [~r/.*_test_failed\.exs/]
+    ]
+  end
+end
diff --git a/lib/mix/test/fixtures/test_failed/test/only_failing_test_failed.exs b/lib/mix/test/fixtures/test_failed/test/only_failing_test_failed.exs
new file mode 100644
index 00000000000..5f64077fd3f
--- /dev/null
+++ b/lib/mix/test/fixtures/test_failed/test/only_failing_test_failed.exs
@@ -0,0 +1,5 @@
+defmodule OnlyFailingTest do
+  use ExUnit.Case
+
+  test "fails", do: assert(System.get_env("PASS_FAILING_TESTS"))
+end
diff --git a/lib/mix/test/fixtures/test_failed/test/only_passing_test_failed.exs b/lib/mix/test/fixtures/test_failed/test/only_passing_test_failed.exs
new file mode 100644
index 00000000000..02305056463
--- /dev/null
+++ b/lib/mix/test/fixtures/test_failed/test/only_passing_test_failed.exs
@@ -0,0 +1,7 @@
+IO.puts("loading OnlyPassingTest")
+
+defmodule OnlyPassingTest do
+  use ExUnit.Case
+
+  test "passes", do: assert(1 == 1)
+end
diff --git a/lib/mix/test/fixtures/test_failed/test/passing_and_failing_test_failed.exs b/lib/mix/test/fixtures/test_failed/test/passing_and_failing_test_failed.exs
new file mode 100644
index 00000000000..8f612bb297c
--- /dev/null
+++ b/lib/mix/test/fixtures/test_failed/test/passing_and_failing_test_failed.exs
@@ -0,0 +1,9 @@
+defmodule PassingAndFailingTest do
+  use ExUnit.Case
+
+  @tag :foo
+  test "fails", do: assert(System.get_env("PASS_FAILING_TESTS"))
+
+  @tag :foo
+  test "passes", do: assert(1 == 1)
+end
diff --git a/lib/mix/test/fixtures/test_failed/test/test_helper.exs b/lib/mix/test/fixtures/test_failed/test/test_helper.exs
new file mode 100644
index 00000000000..869559e709e
--- /dev/null
+++ b/lib/mix/test/fixtures/test_failed/test/test_helper.exs
@@ -0,0 +1 @@
+ExUnit.start()
diff --git a/lib/mix/test/fixtures/test_stale/lib/a.ex b/lib/mix/test/fixtures/test_stale/lib/a.ex
new file mode 100644
index 00000000000..d534bf917f1
--- /dev/null
+++ b/lib/mix/test/fixtures/test_stale/lib/a.ex
@@ -0,0 +1,3 @@
+defmodule A do
+  def f, do: :ok
+end
diff --git a/lib/mix/test/fixtures/test_stale/lib/b.ex b/lib/mix/test/fixtures/test_stale/lib/b.ex
new file mode 100644
index 00000000000..2cd8410c8fc
--- /dev/null
+++ b/lib/mix/test/fixtures/test_stale/lib/b.ex
@@ -0,0 +1,3 @@
+defmodule B do
+  def f, do: A.f()
+end
diff --git a/lib/mix/test/fixtures/test_stale/mix.exs b/lib/mix/test/fixtures/test_stale/mix.exs
new file mode 100644
index 00000000000..b5be916638f
--- /dev/null
+++ b/lib/mix/test/fixtures/test_stale/mix.exs
@@ -0,0 +1,11 @@
+defmodule TestStale.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :test_stale,
+      version: "0.0.1",
+      test_load_filters: [fn file -> String.ends_with?(file, "_test_stale.exs") end]
+    ]
+  end
+end
diff --git a/lib/mix/test/fixtures/test_stale/test/a_test_stale.exs b/lib/mix/test/fixtures/test_stale/test/a_test_stale.exs
new file mode 100644
index 00000000000..2251e1d684e
--- /dev/null
+++ b/lib/mix/test/fixtures/test_stale/test/a_test_stale.exs
@@ -0,0 +1,7 @@
+defmodule ATest do
+  use ExUnit.Case
+
+  test "f" do
+    assert A.f() == :ok
+  end
+end
diff --git a/lib/mix/test/fixtures/test_stale/test/b_test_stale.exs b/lib/mix/test/fixtures/test_stale/test/b_test_stale.exs
new file mode 100644
index 00000000000..f7cf745e99e
--- /dev/null
+++ b/lib/mix/test/fixtures/test_stale/test/b_test_stale.exs
@@ -0,0 +1,7 @@
+defmodule BTest do
+  use ExUnit.Case
+
+  test "f" do
+    assert B.f() == :ok
+  end
+end
diff --git a/lib/mix/test/fixtures/test_stale/test/test_helper.exs b/lib/mix/test/fixtures/test_stale/test/test_helper.exs
new file mode 100644
index 00000000000..869559e709e
--- /dev/null
+++ b/lib/mix/test/fixtures/test_stale/test/test_helper.exs
@@ -0,0 +1 @@
+ExUnit.start()
diff --git a/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/bar/mix.exs b/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/bar/mix.exs
index c9e624f6251..ea73f474465 100644
--- a/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/bar/mix.exs
+++ b/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/bar/mix.exs
@@ -1,10 +1,13 @@
-defmodule Bar.Mix do
+defmodule Bar.MixProject do
   use Mix.Project
 
   def project do
-    Mix.shell.info ":bar env is #{Mix.env}"
-    [ app: :bar,
+    Mix.shell().info(":bar env is #{Mix.env()}")
+
+    [
+      app: :bar,
       version: "0.1.0",
-      deps: [ {:foo, in_umbrella: true} ] ]
+      deps: [{:foo, in_umbrella: true}]
+    ]
   end
 end
diff --git a/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/dont_error_on_missing_mixfile/.gitkeep b/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/dont_error_on_missing_mixfile/.gitkeep
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/foo/mix.exs b/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/foo/mix.exs
index c6c5e9d4a68..af4a98a2a6c 100644
--- a/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/foo/mix.exs
+++ b/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/apps/foo/mix.exs
@@ -1,9 +1,12 @@
-defmodule Foo.Mix do
+defmodule Foo.MixProject do
   use Mix.Project
 
   def project do
-    Mix.shell.info ":foo env is #{Mix.env}"
-    [ app: :foo,
-      version: "0.1.0" ]
+    Mix.shell().info(":foo env is #{Mix.env()}")
+
+    [
+      app: :foo,
+      version: "0.1.0"
+    ]
   end
 end
diff --git a/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/mix.exs b/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/mix.exs
index 2717a59e753..705532e0576 100644
--- a/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/mix.exs
+++ b/lib/mix/test/fixtures/umbrella_dep/deps/umbrella/mix.exs
@@ -1,7 +1,11 @@
-defmodule Umbrella.Mixfile do
+defmodule Umbrella.MixProject do
   use Mix.Project
 
   def project do
-    [ apps_path: "apps" ]
+    [apps_path: "apps"]
+  end
+
+  def application do
+    [extra_applications: [:runtime_tools]]
   end
 end
diff --git a/lib/mix/test/fixtures/umbrella_dep/mix.exs b/lib/mix/test/fixtures/umbrella_dep/mix.exs
index 33ab22d445a..99b72b6c7e0 100644
--- a/lib/mix/test/fixtures/umbrella_dep/mix.exs
+++ b/lib/mix/test/fixtures/umbrella_dep/mix.exs
@@ -1,12 +1,17 @@
-defmodule UmbrellaDep.Mixfile do
+defmodule UmbrellaDep.MixProject do
   use Mix.Project
 
   def project do
-    [ app: :umbrella_dep,
-      deps: deps ]
+    [
+      app: :umbrella_dep,
+      version: "0.1.0",
+      deps: deps()
+    ]
   end
 
   defp deps do
-    [ {:umbrella, path: "deps/umbrella"} ]
+    [
+      {:umbrella, path: "deps/umbrella"}
+    ]
   end
 end
diff --git a/lib/mix/test/fixtures/umbrella_test/apps/bar/lib/bar.ex b/lib/mix/test/fixtures/umbrella_test/apps/bar/lib/bar.ex
new file mode 100644
index 00000000000..da047315ec6
--- /dev/null
+++ b/lib/mix/test/fixtures/umbrella_test/apps/bar/lib/bar.ex
@@ -0,0 +1,19 @@
+defmodule Bar do
+  def hello do
+    :world
+  end
+end
+
+defmodule Bar.Ignore do
+  def world do
+    :hello
+  end
+end
+
+defprotocol Bar.Protocol do
+  def to_uppercase(string)
+end
+
+defimpl Bar.Protocol, for: BitString do
+  def to_uppercase(string), do: String.upcase(string)
+end
diff --git a/lib/mix/test/fixtures/umbrella_test/apps/bar/mix.exs b/lib/mix/test/fixtures/umbrella_test/apps/bar/mix.exs
new file mode 100644
index 00000000000..64d5d9fe4a4
--- /dev/null
+++ b/lib/mix/test/fixtures/umbrella_test/apps/bar/mix.exs
@@ -0,0 +1,15 @@
+defmodule Bar.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :bar,
+      version: "0.1.0",
+      # Choose something besides *_test.exs so that these test files don't
+      # get accidentally swept up into the actual Mix test suite.
+      test_load_filters: [~r/.*_tests\.exs/],
+      test_coverage: [ignore_modules: [Bar, ~r/Ignore/]],
+      aliases: [mytask: fn _ -> Mix.shell().info("bar_running") end]
+    ]
+  end
+end
diff --git a/lib/mix/test/fixtures/umbrella_test/apps/bar/test/bar_tests.exs b/lib/mix/test/fixtures/umbrella_test/apps/bar/test/bar_tests.exs
new file mode 100644
index 00000000000..737232d9cba
--- /dev/null
+++ b/lib/mix/test/fixtures/umbrella_test/apps/bar/test/bar_tests.exs
@@ -0,0 +1,20 @@
+defmodule BarTest do
+  use ExUnit.Case
+
+  test "greets the world" do
+    assert Bar.hello() == :world
+  end
+
+  test "world the greets" do
+    assert Bar.Ignore.world() == :hello
+  end
+
+  @tag :maybe_skip
+  test "works with protocols" do
+    assert Bar.Protocol.to_uppercase("foo") == "FOO"
+  end
+
+  test "protocols are consolidated" do
+    assert Protocol.consolidated?(Bar.Protocol)
+  end
+end
diff --git a/lib/mix/test/fixtures/umbrella_test/apps/bar/test/test_helper.exs b/lib/mix/test/fixtures/umbrella_test/apps/bar/test/test_helper.exs
new file mode 100644
index 00000000000..869559e709e
--- /dev/null
+++ b/lib/mix/test/fixtures/umbrella_test/apps/bar/test/test_helper.exs
@@ -0,0 +1 @@
+ExUnit.start()
diff --git a/lib/mix/test/fixtures/umbrella_test/apps/foo/lib/foo.ex b/lib/mix/test/fixtures/umbrella_test/apps/foo/lib/foo.ex
new file mode 100644
index 00000000000..639f784755d
--- /dev/null
+++ b/lib/mix/test/fixtures/umbrella_test/apps/foo/lib/foo.ex
@@ -0,0 +1,5 @@
+defmodule Foo do
+  def hello do
+    :world
+  end
+end
diff --git a/lib/mix/test/fixtures/umbrella_test/apps/foo/mix.exs b/lib/mix/test/fixtures/umbrella_test/apps/foo/mix.exs
new file mode 100644
index 00000000000..4e02cafe1d6
--- /dev/null
+++ b/lib/mix/test/fixtures/umbrella_test/apps/foo/mix.exs
@@ -0,0 +1,14 @@
+defmodule Foo.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :foo,
+      version: "0.1.0",
+      # Choose something besides *_test.exs so that these test files don't
+      # get accidentally swept up into the actual Mix test suite.
+      test_load_filters: [~r/.*_tests\.exs/],
+      aliases: [mytask: fn _ -> Mix.shell().info("foo_running") end]
+    ]
+  end
+end
diff --git a/lib/mix/test/fixtures/umbrella_test/apps/foo/test/foo_tests.exs b/lib/mix/test/fixtures/umbrella_test/apps/foo/test/foo_tests.exs
new file mode 100644
index 00000000000..63eeefbb37b
--- /dev/null
+++ b/lib/mix/test/fixtures/umbrella_test/apps/foo/test/foo_tests.exs
@@ -0,0 +1,7 @@
+defmodule FooTest do
+  use ExUnit.Case
+
+  test "greets the world" do
+    assert Foo.hello() == :world
+  end
+end
diff --git a/lib/mix/test/fixtures/umbrella_test/apps/foo/test/test_helper.exs b/lib/mix/test/fixtures/umbrella_test/apps/foo/test/test_helper.exs
new file mode 100644
index 00000000000..869559e709e
--- /dev/null
+++ b/lib/mix/test/fixtures/umbrella_test/apps/foo/test/test_helper.exs
@@ -0,0 +1 @@
+ExUnit.start()
diff --git a/lib/mix/test/fixtures/umbrella_test/mix.exs b/lib/mix/test/fixtures/umbrella_test/mix.exs
new file mode 100644
index 00000000000..e4756ac03aa
--- /dev/null
+++ b/lib/mix/test/fixtures/umbrella_test/mix.exs
@@ -0,0 +1,9 @@
+defmodule UmbrellaTest.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      apps_path: "apps"
+    ]
+  end
+end
diff --git a/lib/mix/test/mix/aliases_test.exs b/lib/mix/test/mix/aliases_test.exs
new file mode 100644
index 00000000000..4fde3d401dc
--- /dev/null
+++ b/lib/mix/test/mix/aliases_test.exs
@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Mix.AliasesTest do
+  use MixTest.Case
+
+  defmodule Aliases do
+    def project do
+      [
+        aliases: [
+          h: "hello",
+          p: &inspect/1,
+          compile: "hello",
+          cmd: &call_cmd/1,
+          help: ["help", "hello"],
+          "nested.h": [&Mix.shell().info(inspect(&1)), "h foo bar"],
+          invalid_alias: [:not_a_string_or_function]
+        ]
+      ]
+    end
+
+    defp call_cmd(args), do: Mix.Task.run("cmd", args)
+  end
+
+  setup do
+    Mix.Project.push(Aliases)
+    :ok
+  end
+
+  test "runs string aliases" do
+    assert Mix.Task.run("h", []) == "Hello, World!"
+    assert Mix.Task.run("h", []) == :noop
+    assert Mix.Task.run("hello", []) == :noop
+
+    Mix.Task.reenable("h")
+    Mix.Task.reenable("hello")
+    assert Mix.Task.run("h", ["foo", "bar"]) == "Hello, foo bar!"
+  end
+
+  test "runs function aliases" do
+    assert Mix.Task.run("p", []) == "[]"
+    assert Mix.Task.run("p", []) == :noop
+
+    Mix.Task.reenable("p")
+    assert Mix.Task.run("p", ["foo", "bar"]) == "[\"foo\", \"bar\"]"
+  end
+
+  test "runs list aliases" do
+    assert Mix.Task.run("nested.h", ["baz"]) == "Hello, foo bar baz!"
+    assert_received {:mix_shell, :info, ["[]"]}
+  end
+
+  test "fails for invalid aliases" do
+    assert_raise Mix.Error, ~r/Invalid Mix alias format/, fn ->
+      Mix.Task.run("invalid_alias", [])
+    end
+  end
+
+  test "run alias override" do
+    assert Mix.Task.run("compile", []) == "Hello, World!"
+    assert Mix.Task.run("compile", []) == :noop
+  end
+
+  test "run alias override with name-recursion" do
+    assert Mix.Task.rerun("help", []) == "Hello, World!"
+    assert_received {:mix_shell, :info, ["mix test" <> _]}
+
+    # Arguments are passed to the recursive task and not the last one.
+    assert ExUnit.CaptureIO.capture_io(fn ->
+             Mix.Task.rerun("help", ["test"])
+           end) =~ "mix test"
+  end
+
+  test "run alias override with code-recursion" do
+    assert Mix.Task.rerun("cmd", ["echo", "hello"]) == :ok
+    assert_received {:mix_shell, :run, ["hello" <> _]}
+  end
+end
diff --git a/lib/mix/test/mix/archive_test.exs b/lib/mix/test/mix/archive_test.exs
deleted file mode 100644
index eca377eb4c6..00000000000
--- a/lib/mix/test/mix/archive_test.exs
+++ /dev/null
@@ -1,23 +0,0 @@
-Code.require_file "../test_helper.exs", __DIR__
-
-defmodule Mix.ArchiveTest do
-  use MixTest.Case
-
-  doctest Mix.Archive
-
-  test "archive" do
-    in_fixture "archive", fn ->
-      Mix.Archive.create(".", "sample.ez")
-      archive = 'sample.ez'
-      assert File.exists?(archive)
-      assert has_zip_file?(archive, 'sample/priv/not_really_an.so')
-      assert has_zip_file?(archive, 'sample/ebin/Elixir.Mix.Tasks.Local.Sample.beam')
-    end
-  end
-
-  defp has_zip_file?(archive, name) do
-    :zip.list_dir(archive)
-    |> elem(1)
-    |> Enum.find(&match?({:zip_file, ^name, _, _, _, _}, &1))
-  end
-end
diff --git a/lib/mix/test/mix/cli_test.exs b/lib/mix/test/mix/cli_test.exs
index c244340c1d8..71dceae495d 100644
--- a/lib/mix/test/mix/cli_test.exs
+++ b/lib/mix/test/mix/cli_test.exs
@@ -1,64 +1,73 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Mix.CLITest do
   use MixTest.Case
 
-  test "env configs" do
-    in_fixture "no_mixfile", fn ->
-      File.write! "custom.exs", """
+  @moduletag :tmp_dir
+
+  test "default task" do
+    in_fixture("no_mixfile", fn ->
+      File.write!("mix.exs", """
       defmodule P do
         use Mix.Project
         def project, do: [app: :p, version: "0.1.0"]
       end
-      """
-      
-      System.put_env("MIX_ENV", "prod")
-      System.put_env("MIX_EXS", "custom.exs")
-      
-      output = System.cmd ~s(#{elixir_executable} #{mix_executable}) <>
-                          ~s( run -e "IO.inspect {Mix.env, System.argv}" -- 1 2 3)
-      
-      System.delete_env("MIX_ENV")
-      System.delete_env("MIX_EXS")
-      
-      assert output =~ ~s({:prod, ["1", "2", "3"]})
-      assert output =~ "Compiled lib/a.ex"
-    end
+      """)
+
+      mix(~w[])
+      assert File.regular?("_build/dev/lib/p/ebin/Elixir.A.beam")
+    end)
   end
 
-  test "default task" do
-    in_fixture "no_mixfile", fn ->
-      File.write! "mix.exs", """
+  test "custom default task" do
+    in_fixture("no_mixfile", fn ->
+      File.write!("mix.exs", """
       defmodule P do
         use Mix.Project
+        def cli, do: [default_task: "oops"]
         def project, do: [app: :p, version: "0.1.0"]
       end
-      """
-      output = mix ""
-      assert File.regular?("_build/dev/lib/p/ebin/Elixir.A.beam")
-      assert output =~ "Compiled lib/a.ex"
-    end
+      """)
+
+      assert mix(~w[]) =~ "The task \"oops\" could not be found"
+    end)
   end
 
-  test "custom mix.exs" do
-    in_fixture "no_mixfile", fn ->
-      File.write! "mix.exs", """
-      defmodule P do
+  test "Mix.raise/2 can set exit status", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      File.mkdir_p!("lib")
+
+      File.write!("mix.exs", """
+      defmodule MyProject do
         use Mix.Project
-        def project, do: [app: :p]
+
+        def project do
+          [app: :my_project, version: "0.0.1", aliases: aliases()]
+        end
+
+        defp aliases do
+          [
+            custom: &error(&1, exit_status: 99),
+          ]
+        end
+
+        defp error(_args, opts), do: Mix.raise("oops", opts)
       end
-      """
-      output = mix ""
-      assert File.regular?("_build/dev/lib/p/ebin/Elixir.A.beam")
-      assert output =~ "Compiled lib/a.ex"
-    end
+      """)
+
+      assert {_, 99} = mix_code(~w[custom])
+    end)
   end
 
-  test "compiles and invokes simple task from CLI" do
-    in_fixture "no_mixfile", fn ->
+  test "compiles and invokes simple task from CLI", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
       File.mkdir_p!("lib")
 
-      File.write! "mix.exs", """
+      File.write!("mix.exs", """
       defmodule MyProject do
         use Mix.Project
 
@@ -70,88 +79,195 @@ defmodule Mix.CLITest do
           "Hello from MyProject!"
         end
       end
-      """
+      """)
 
-      File.write! "lib/hello.ex", """
-      defmodule Mix.Tasks.Hello do
+      File.write!("lib/hello.ex", """
+      defmodule Mix.Tasks.MyHello do
         use Mix.Task
 
-        @shortdoc "Hello"
+        @shortdoc "Says hello"
 
         def run(_) do
-          IO.puts Mix.Project.get!.hello_world
+          IO.puts(Mix.Project.get!().hello_world())
+          Mix.shell().info("This won't appear")
+          Mix.raise("oops")
         end
       end
-      """
+      """)
 
-      contents = mix("hello")
+      contents = mix(~w[my_hello], [{"MIX_QUIET", "1"}])
       assert contents =~ "Hello from MyProject!\n"
-      assert contents =~ "Compiled lib/hello.ex\n"
-    end
+      refute contents =~ "This won't appear"
+
+      contents = mix(~w[my_hello], [{"MIX_QUIET", "0"}])
+      assert contents =~ "Hello from MyProject!\n"
+      assert contents =~ "This won't appear"
+
+      contents = mix(~w[my_hello], [{"MIX_DEBUG", "1"}])
+      assert contents =~ "-> Running mix my_hello (inside MyProject)"
+      assert contents =~ "** (Mix.Error) oops"
+
+      contents = mix(~w[my_hello], [{"MIX_DEBUG", "0"}])
+      refute contents =~ "-> Running mix my_hello (inside MyProject)"
+      refute contents =~ "** (Mix.Error) oops"
+    end)
   end
 
-  test "no task error" do
-    in_fixture "no_mixfile", fn ->
-      contents = mix("no_task")
-      assert contents =~ "** (Mix) The task no_task could not be found\n"
-    end
+  test "no task error", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      contents = mix(~w[no_task])
+      assert contents =~ "** (Mix) The task \"no_task\" could not be found"
+    end)
   end
 
-  test "--help smoke test" do
-    in_fixture "no_mixfile", fn ->
-      output = mix "--help"
-      assert output =~ ~r/mix compile\s+# Compile source files/
-      refute output =~ "mix invalid"
-    end
+  test "tasks with slashes raise NoTaskError", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      contents = mix(~w[my/task])
+      assert contents =~ "** (Mix) The task \"my/task\" could not be found"
+    end)
   end
 
-  test "--version smoke test" do
-    in_fixture "no_mixfile", fn ->
-      output = mix "--version"
-      assert output =~ ~r/Elixir [0-9\.a-z]+/
-    end
+  test "--help smoke test", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      output = mix(~w[--help])
+      assert output =~ "Mix is a build tool for Elixir"
+      assert output =~ "mix help TASK"
+    end)
   end
 
-  test "new with tests" do
-    in_tmp "new_with_tests", fn ->
-      output = mix "new ."
-      assert output =~ "* creating lib/new_with_tests.ex"
+  test "--version smoke test", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      output = mix(~w[--version])
+      assert output =~ ~r/Erlang.+\n\nMix [0-9\.a-z]+/
+    end)
+  end
 
-      output = mix "test test/new_with_tests_test.exs --cover"
-      assert File.regular?("_build/test/lib/new_with_tests/ebin/Elixir.NewWithTests.beam")
-      assert output =~ "1 tests, 0 failures"
-      assert output =~ "Generating cover results ..."
-      assert File.regular?("cover/Elixir.NewWithTests.html")
-    end
+  test "env var config", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      File.write!("custom.exs", """
+      defmodule P do
+        use Mix.Project
+        def project, do: [app: :p, version: "0.1.0"]
+      end
+      """)
+
+      System.put_env("MIX_ENV", "prod")
+      System.put_env("MIX_TARGET", "rpi")
+      System.put_env("MIX_EXS", "custom.exs")
+
+      inspect = "IO.inspect {Mix.env(), Mix.target(), System.argv()}"
+      output = mix(["run", "-e", inspect, "--", "1", "2", "3"])
+      assert output =~ ~s({:prod, :rpi, ["1", "2", "3"]})
+    end)
+  after
+    System.delete_env("MIX_ENV")
+    System.delete_env("MIX_TARGET")
+    System.delete_env("MIX_EXS")
   end
 
-  test "new --sup with tests" do
-    in_tmp "sup_with_tests", fn ->
-      output = mix "new --sup ."
-      assert output =~ "* creating lib/sup_with_tests.ex"
+  test "cli config", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      File.write!("custom.exs", """
+      defmodule P do
+        use Mix.Project
+        def project, do: [app: :p, version: "0.1.0"]
+        def cli, do: [default_env: :prod, default_target: :rpi]
+      end
+      """)
 
-      output = mix "test"
-      assert File.regular?("_build/test/lib/sup_with_tests/ebin/Elixir.SupWithTests.beam")
-      assert output =~ "1 tests, 0 failures"
-    end
+      System.put_env("MIX_EXS", "custom.exs")
+
+      inspect = "IO.inspect {Mix.env(), Mix.target(), System.argv()}"
+      output = mix(["run", "-e", inspect, "--", "1", "2", "3"])
+      assert output =~ ~s({:prod, :rpi, ["1", "2", "3"]})
+    end)
+  after
+    System.delete_env("MIX_EXS")
   end
 
-  defp mix(args) do
-    System.cmd "#{elixir_executable} #{mix_executable} #{args} #{stderr_on_win}"
+  test "preferred cli config", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      File.write!("custom.exs", """
+      defmodule P do
+        use Mix.Project
+
+        def cli do
+          [
+            default_env: :not_prod,
+            default_target: :not_rpi,
+            preferred_envs: [test_task: :prod],
+            preferred_targets: [test_task: :rpi]
+          ]
+        end
+
+        def project, do: [app: :p, version: "0.1.0"]
+      end
+
+      defmodule Mix.Tasks.TestTask do
+        use Mix.Task
+
+        def run(args) do
+          IO.inspect {Mix.env(), Mix.target(), args}
+        end
+      end
+      """)
+
+      System.put_env("MIX_EXS", "custom.exs")
+
+      output = mix(["test_task", "a", "b", "c"])
+      assert output =~ ~s({:prod, :rpi, ["a", "b", "c"]})
+    end)
+  after
+    System.delete_env("MIX_EXS")
   end
-  
-  defp stderr_on_win do
-    case :os.type do
-      {:win32, _} -> "2>&1"
-      _ -> ""
-    end
+
+  test "env config and target use defaults when empty", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      File.write!("custom.exs", """
+      defmodule P do
+        use Mix.Project
+        def project, do: [app: :p, version: "0.1.0"]
+      end
+      """)
+
+      System.put_env("MIX_ENV", "")
+      System.put_env("MIX_TARGET", "")
+      System.put_env("MIX_EXS", "custom.exs")
+
+      inspect = "IO.inspect {Mix.env(), Mix.target(), System.argv()}"
+      output = mix(["run", "-e", inspect, "--", "a", "b"])
+      assert output =~ ~s({:dev, :host, ["a", "b"]})
+    end)
+  after
+    System.delete_env("MIX_ENV")
+    System.delete_env("MIX_TARGET")
+    System.delete_env("MIX_EXS")
   end
 
-  defp mix_executable do
-    Path.expand("../../../../bin/mix", __DIR__)
+  @tag :cover
+  @tag tmp_dir: "new_with_tests"
+  test "new with tests and cover", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      output = mix(~w[new .])
+      assert output =~ "* creating lib/new_with_tests.ex"
+
+      output = mix(~w[test test/new_with_tests_test.exs --cover])
+      assert File.regular?("_build/test/lib/new_with_tests/ebin/Elixir.NewWithTests.beam")
+      assert output =~ "1 doctest, 1 test, 0 failures"
+      assert output =~ "Generating cover results ..."
+      assert File.regular?("cover/Elixir.NewWithTests.html")
+    end)
   end
 
-  defp elixir_executable do
-    Path.expand("../../../../bin/elixir", __DIR__)
+  @tag tmp_dir: "sup_with_tests"
+  test "new --sup with tests", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      output = mix(~w[new --sup .])
+      assert output =~ "* creating lib/sup_with_tests.ex"
+
+      output = mix(~w[test])
+      assert File.regular?("_build/test/lib/sup_with_tests/ebin/Elixir.SupWithTests.beam")
+      assert output =~ "1 doctest, 1 test, 0 failures"
+    end)
   end
 end
diff --git a/lib/mix/test/mix/config_test.exs b/lib/mix/test/mix/config_test.exs
deleted file mode 100644
index 762f78941a8..00000000000
--- a/lib/mix/test/mix/config_test.exs
+++ /dev/null
@@ -1,77 +0,0 @@
-Code.require_file "../test_helper.exs", __DIR__
-
-defmodule Mix.ConfigTest do
-  use MixTest.Case, async: true
-
-  doctest Mix.Config
-
-  test "config/2" do
-    use Mix.Config
-    assert var!(config, Mix.Config) == []
-
-    config :lager, key: :value
-    assert var!(config, Mix.Config) == [lager: [key: :value]]
-
-    config :lager, other: :value
-    assert var!(config, Mix.Config) == [lager: [other: :value, key: :value]]
-
-    config :lager, key: :other
-    assert var!(config, Mix.Config) == [lager: [key: :other, other: :value]]
-  end
-
-  test "config/3" do
-    use Mix.Config
-
-    config :app, Repo, key: :value
-    assert var!(config, Mix.Config) == [app: [{Repo, key: :value}]]
-
-    config :app, Repo, other: :value
-    assert var!(config, Mix.Config) == [app: [{Repo, other: :value, key: :value}]]
-
-    config :app, Repo, key: :other
-    assert var!(config, Mix.Config) == [app: [{Repo, [key: :other, other: :value]}]]
-  end
-
-  test "import_config/1" do
-    use Mix.Config
-    import_config fixture_path("configs/good_config.exs")
-    assert var!(config, Mix.Config) == [my_app: [key: :value]]
-  end
-
-  test "read!/1" do
-    assert Mix.Config.read!(fixture_path("configs/good_config.exs")) ==
-           [my_app: [key: :value]]
-
-    assert Mix.Config.read!(fixture_path("configs/good_import.exs")) ==
-           [my_app: [key: :value]]
-
-    exception = assert_raise Mix.Config.LoadError, fn ->
-      Mix.Config.read! fixture_path("configs/bad_app.exs")
-    end
-
-    assert Exception.message(exception) =~ ~r"could not load config .*bad_app\.exs\n"
-    assert Exception.message(exception) =~ ~r"expected config for app :sample to return keyword list, got: :oops"
-
-    exception = assert_raise Mix.Config.LoadError, fn ->
-      Mix.Config.read! fixture_path("configs/bad_root.exs")
-    end
-
-    assert Exception.message(exception) =~ ~r"could not load config .*bad_root\.exs\n"
-    assert Exception.message(exception) =~ ~r"expected config file to return keyword list, got: :oops"
-
-    exception = assert_raise Mix.Config.LoadError, fn ->
-      Mix.Config.read! fixture_path("configs/bad_import.exs")
-    end
-
-    assert Exception.message(exception) =~ ~r"could not load config .*bad_root\.exs\n"
-    assert Exception.message(exception) =~ ~r"expected config file to return keyword list, got: :oops"
-  end
-
-  test "persist/1" do
-    assert Application.get_env(:my_app, :key) == nil
-    Mix.Config.persist [my_app: [key: :value]]
-    assert Application.get_env(:my_app, :key) == :value
-  after
-    Application.delete_env(:my_app, :key)
-  end
-end
diff --git a/lib/mix/test/mix/dep/converger_test.exs b/lib/mix/test/mix/dep/converger_test.exs
new file mode 100644
index 00000000000..25f59ea8381
--- /dev/null
+++ b/lib/mix/test/mix/dep/converger_test.exs
@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Dep.ConvergerTest do
+  use MixTest.Case
+
+  describe "topological_sort" do
+    test "raises if there is a cycle in the dependency graph" do
+      app1 = %Mix.Dep{app: :app1}
+      app2 = %Mix.Dep{app: :app2}
+      app3 = %Mix.Dep{app: :app3}
+
+      deps = [
+        # not really part of the cycle, just depend on it
+        %Mix.Dep{app: :app5, deps: [app1, app3]},
+        %Mix.Dep{app: :app4, deps: [app2]},
+
+        # cycle
+        %{app1 | deps: [app2]},
+        %{app2 | deps: [app3]},
+        %{app3 | deps: [app1]}
+      ]
+
+      assert_raise Mix.Error,
+                   "Could not sort dependencies. " <>
+                     "The following dependencies form a cycle: app1, app2, app3",
+                   fn -> Mix.Dep.Converger.topological_sort(deps) end
+    end
+
+    test "raises if an app depends upon itself" do
+      app = %Mix.Dep{app: :self_dependent}
+      deps = [%{app | deps: [app]}]
+
+      assert_raise Mix.Error,
+                   "App self_dependent lists itself as a dependency",
+                   fn -> Mix.Dep.Converger.topological_sort(deps) end
+    end
+  end
+end
diff --git a/lib/mix/test/mix/dep/lock_test.exs b/lib/mix/test/mix/dep/lock_test.exs
index 9ffdedf70c8..010efc15622 100644
--- a/lib/mix/test/mix/dep/lock_test.exs
+++ b/lib/mix/test/mix/dep/lock_test.exs
@@ -1,36 +1,82 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Dep.LockTest do
   use MixTest.Case
 
   setup do
-    Mix.Project.push MixTest.Case.Sample
+    Mix.Project.push(MixTest.Case.Sample)
     :ok
   end
 
-  test "creates new lock and manifest files" do
-    in_fixture "no_mixfile", fn ->
-      Mix.Dep.Lock.write %{foo: :bar}
-      assert File.regular? "mix.lock"
-      assert File.regular? "_build/dev/lib/sample/.compile.lock"
-    end
+  test "creates new lock and manifest files", context do
+    in_tmp(context.test, fn ->
+      Mix.Dep.Lock.write(%{foo: :bar})
+      assert File.regular?("mix.lock")
+      assert File.regular?("_build/dev/lib/sample/.mix/compile.lock")
+    end)
   end
 
-  test "does not touch manifest file there is no change" do
-    in_fixture "no_mixfile", fn ->
-      Mix.Dep.Lock.write %{foo: :bar, bar: :bat}
-      File.rm! "_build/dev/lib/sample/.compile.lock"
+  test "formats each dep on its own line for better conflict handling", context do
+    in_tmp(context.test, fn ->
+      Mix.Dep.Lock.write(%{
+        foo: {:hex, :foo, "0.1.0"},
+        bar: {:hex, :bar, "0.1.0"}
+      })
 
-      Mix.Dep.Lock.write %{bar: :bat, foo: :bar}
-      refute File.regular? "_build/dev/lib/sample/.compile.lock"
-    end
+      assert File.read!("mix.lock") == ~S"""
+             %{
+               "bar": {:hex, :bar, "0.1.0"},
+               "foo": {:hex, :foo, "0.1.0"},
+             }
+             """
+    end)
   end
 
-  test "stores version in manifest" do
-    in_fixture "no_mixfile", fn ->
-      assert nil? Mix.Dep.Lock.elixir_vsn
-      Mix.Dep.Lock.touch
-      assert Mix.Dep.Lock.elixir_vsn == System.version
-    end
+  test "does not touch manifest file there is no change", context do
+    in_tmp(context.test, fn ->
+      Mix.Dep.Lock.write(%{foo: :bar, bar: :bat})
+      File.rm!("_build/dev/lib/sample/.mix/compile.lock")
+
+      Mix.Dep.Lock.write(%{bar: :bat, foo: :bar})
+      refute File.regular?("_build/dev/lib/sample/.mix/compile.lock")
+    end)
+  end
+
+  test "raises a proper error if check_locked opt is true and there are changes", context do
+    in_tmp(context.test, fn ->
+      Mix.Dep.Lock.write(%{foo: :bar})
+
+      Mix.Dep.Lock.write(%{foo: :bar}, check_locked: true)
+
+      assert_raise Mix.Error,
+                   ~r/Your mix\.lock is out of date and must be updated without the --check-locked flag/,
+                   fn ->
+                     Mix.Dep.Lock.write(%{foo: :bar, bar: :bat}, check_locked: true)
+                   end
+    end)
+  end
+
+  test "raises a proper error for merge conflicts", context do
+    in_tmp(context.test, fn ->
+      File.write("mix.lock", ~S"""
+      %{
+        "dep": {:hex, :dep, "0.1.0"},
+      <<<<<<< HEAD
+        "foo": {:hex, :foo, "0.1.0"},
+      =======
+        "bar": {:hex, :bar, "0.1.0"},
+      >>>>>>> foobar
+        "baz": {:hex, :baz, "0.1.0"},
+      }
+      """)
+
+      assert_raise Mix.Error, ~r/Your mix\.lock contains merge conflicts/, fn ->
+        Mix.Dep.Lock.read()
+      end
+    end)
   end
 end
diff --git a/lib/mix/test/mix/dep_test.exs b/lib/mix/test/mix/dep_test.exs
index 735611682fc..38745857019 100644
--- a/lib/mix/test/mix/dep_test.exs
+++ b/lib/mix/test/mix/dep_test.exs
@@ -1,278 +1,1288 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Mix.DepTest do
   use MixTest.Case
 
   defmodule DepsApp do
     def project do
-      [ deps: [
-          {:ok,         "0.1.0", path: "deps/ok"},
+      [
+        app: :deps_app,
+        deps: [
+          {:ok, "0.1.0", path: "deps/ok"},
           {:invalidvsn, "0.2.0", path: "deps/invalidvsn"},
           {:invalidapp, "0.1.0", path: "deps/invalidapp"},
-          {:noappfile,  "0.1.0", path: "deps/noappfile"},
-          {:uncloned,            git: "https://github.com/elixir-lang/uncloned.git"},
-          {:optional,            git: "https://github.com/elixir-lang/optional.git", optional: true}
-        ] ]
+          {:noappfile, "0.1.0", path: "deps/noappfile"},
+          {:uncloned, git: "https://github.com/elixir-lang/uncloned.git"},
+          {:optional, git: "https://github.com/elixir-lang/optional.git", optional: true}
+        ]
+      ]
     end
   end
 
-  defmodule MixVersionApp do
+  defmodule ProcessDepsApp do
     def project do
-      [ deps: [ {:ok, "~> 0.1", path: "deps/ok"} ] ]
+      [app: :process_deps_app, deps: Process.get(:mix_deps)]
     end
   end
 
-  defmodule NoSCMApp do
-    def project do
-      [ deps: [ { :ok, "~> 0.1", not_really: :ok } ] ]
-    end
+  defp with_deps(deps, fun) do
+    Process.put(:mix_deps, deps)
+    Mix.Project.push(ProcessDepsApp)
+    fun.()
+  after
+    Mix.Project.pop()
   end
 
-  defmodule InvalidDepsReq do
-    def project do
-      [ deps: [ {:ok, "+- 0.1.0", path: "deps/ok"} ] ]
-    end
+  defp assert_wrong_dependency(deps) do
+    with_deps(deps, fn ->
+      assert_raise Mix.Error, ~r"Dependency specified in the wrong format", fn ->
+        Mix.Dep.Converger.converge([])
+      end
+    end)
+  end
+
+  test "clear deps cache" do
+    Mix.Project.push(DepsApp)
+
+    Mix.Dep.cached()
+    key = {:cached_deps, DepsApp}
+
+    {env_target, deps} = Mix.State.read_cache(key)
+    assert env_target == {Mix.env(), Mix.target()}
+    assert length(deps) == 6
+
+    Mix.Dep.clear_cached()
+    refute Mix.State.read_cache(key)
   end
 
   test "extracts all dependencies from the given project" do
-    Mix.Project.push DepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DepsApp)
 
-    in_fixture "deps_status", fn ->
-      deps = Mix.Dep.loaded([])
+      deps = Mix.Dep.Converger.converge([])
       assert length(deps) == 6
-      assert Enum.find deps, &match?(%Mix.Dep{app: :ok, status: {:ok, _}}, &1)
-      assert Enum.find deps, &match?(%Mix.Dep{app: :invalidvsn, status: {:invalidvsn, :ok}}, &1)
-      assert Enum.find deps, &match?(%Mix.Dep{app: :invalidapp, status: {:invalidapp, _}}, &1)
-      assert Enum.find deps, &match?(%Mix.Dep{app: :noappfile, status: {:noappfile, _}}, &1)
-      assert Enum.find deps, &match?(%Mix.Dep{app: :uncloned, status: {:unavailable, _}}, &1)
-      assert Enum.find deps, &match?(%Mix.Dep{app: :optional, status: {:unavailable, _}}, &1)
-    end
+      assert Enum.find(deps, &match?(%Mix.Dep{app: :ok, status: {:ok, _}}, &1))
+      assert Enum.find(deps, &match?(%Mix.Dep{app: :invalidvsn, status: {:invalidvsn, :ok}}, &1))
+      assert Enum.find(deps, &match?(%Mix.Dep{app: :invalidapp, status: {:invalidapp, _}}, &1))
+      assert Enum.find(deps, &match?(%Mix.Dep{app: :noappfile, status: {:noappfile, {_, _}}}, &1))
+      assert Enum.find(deps, &match?(%Mix.Dep{app: :uncloned, status: {:unavailable, _}}, &1))
+      assert Enum.find(deps, &match?(%Mix.Dep{app: :optional, status: {:unavailable, _}}, &1))
+    end)
+  end
+
+  test "extracts all dependencies paths/scms from the given project" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DepsApp)
+
+      apps = Mix.Project.deps_apps()
+      assert length(apps) == 6
+      assert :ok in apps
+      assert :uncloned in apps
+
+      paths = Mix.Project.deps_paths()
+      assert map_size(paths) == 6
+      assert paths[:ok] =~ "deps/ok"
+      assert paths[:uncloned] =~ "deps/uncloned"
+
+      scms = Mix.Project.deps_scms()
+      assert map_size(scms) == 6
+      assert scms[:ok] == Mix.SCM.Path
+      assert scms[:uncloned] == Mix.SCM.Git
+    end)
+  end
+
+  test "fails on invalid dependencies" do
+    assert_wrong_dependency([{:ok}])
+    assert_wrong_dependency([{:ok, nil}])
+    assert_wrong_dependency([{:ok, nil, []}])
   end
 
   test "use requirements for dependencies" do
-    Mix.Project.push MixVersionApp
+    deps = [{:ok, "~> 0.1", path: "deps/ok"}]
 
-    in_fixture "deps_status", fn ->
-      deps = Mix.Dep.loaded([])
-      assert Enum.find deps, &match?(%Mix.Dep{app: :ok, status: {:ok, _}}, &1)
-    end
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        deps = Mix.Dep.Converger.converge([])
+        assert Enum.find(deps, &match?(%Mix.Dep{app: :ok, status: {:ok, _}}, &1))
+      end)
+    end)
   end
 
   test "raises when no SCM is specified" do
-    Mix.Project.push NoSCMApp
+    deps = [{:ok, "~> 0.1", not_really: :ok}]
 
-    in_fixture "deps_status", fn ->
-      send self, {:mix_shell_input, :yes?, false}
-      msg = "Could not find a SCM for dependency :ok from Mix.DepTest.NoSCMApp"
-      assert_raise Mix.Error, msg, fn -> Mix.Dep.loaded([]) end
-    end
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        send(self(), {:mix_shell_input, :yes?, false})
+        msg = "Could not find an SCM for dependency :ok from Mix.DepTest.ProcessDepsApp"
+        assert_raise Mix.Error, msg, fn -> Mix.Dep.Converger.converge([]) end
+      end)
+    end)
   end
 
   test "does not set the manager before the dependency was loaded" do
     # It is important to not eagerly set the manager because the dependency
-    # needs to be loaded (i.e. available in the filesystem) in order to get
+    # needs to be loaded (i.e. available in the file system) in order to get
     # the proper manager.
-    Mix.Project.push DepsApp
+    Mix.Project.push(DepsApp)
 
     {_, true, _} =
       Mix.Dep.Converger.converge(false, [], nil, fn dep, acc, lock ->
-        assert nil?(dep.manager)
+        assert is_nil(dep.manager)
         {dep, acc or true, lock}
       end)
   end
 
   test "raises on invalid deps req" do
-    Mix.Project.push InvalidDepsReq
-
-    in_fixture "deps_status", fn ->
-      assert_raise Mix.Error, ~r"Invalid requirement", fn ->
-        Mix.Dep.loaded([])
-      end
-    end
-  end
+    deps = [{:ok, "+- 0.1.0", path: "deps/ok"}]
 
-  defmodule NestedDepsApp do
-    def project do
-      [
-        app: :raw_sample,
-        version: "0.1.0",
-        deps: [
-          {:deps_repo, "0.1.0", path: "custom/deps_repo"}
-        ]
-      ]
-    end
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        assert_raise Mix.Error, ~r"Invalid requirement", fn ->
+          Mix.Dep.Converger.converge([])
+        end
+      end)
+    end)
   end
 
   test "nested deps come first" do
-    Mix.Project.push NestedDepsApp
+    deps = [{:deps_repo, "0.1.0", path: "custom/deps_repo"}]
 
-    in_fixture "deps_status", fn ->
-      assert Enum.map(Mix.Dep.loaded([]), &(&1.app)) == [:git_repo, :deps_repo]
-    end
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        assert Enum.map(Mix.Dep.Converger.converge([]), & &1.app) == [:git_repo, :deps_repo]
+      end)
+    end)
   end
 
   test "nested optional deps are never added" do
-    Mix.Project.push NestedDepsApp
-
-    in_fixture "deps_status", fn ->
-      File.write! "custom/deps_repo/mix.exs", """
-      defmodule DepsRepo do
-        use Mix.Project
-
-        def project do
-          [
-            app: :deps_repo,
-            version: "0.1.0",
-            deps: [
-              {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), optional: true}
-            ]
-          ]
+    deps = [{:deps_repo, "0.1.0", path: "custom/deps_repo"}]
+
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        File.write!("custom/deps_repo/mix.exs", """
+        defmodule DepsRepo do
+          use Mix.Project
+
+          def project do
+            [app: :deps_repo,
+             version: "0.1.0",
+             deps: [{:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), optional: true}]]
+          end
         end
-      end
-      """
+        """)
 
-      assert Enum.map(Mix.Dep.loaded([]), &(&1.app)) == [:deps_repo]
-    end
+        assert Enum.map(Mix.Dep.Converger.converge([]), & &1.app) == [:deps_repo]
+      end)
+    end)
   end
 
-  defmodule ConvergedDepsApp do
-    def project do
-      [
-        app: :raw_sample,
-        version: "0.1.0",
-        deps: [
-          {:deps_repo, "0.1.0", path: "custom/deps_repo"},
-          {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo")}
-        ]
-      ]
+  test "nested deps with convergence" do
+    deps = [
+      {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+      {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo")}
+    ]
+
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        assert Enum.map(Mix.Dep.Converger.converge([]), & &1.app) == [:git_repo, :deps_repo]
+      end)
+    end)
+  end
+
+  test "nested deps with convergence and managers" do
+    Process.put(:custom_deps_git_repo_opts, manager: :make)
+
+    deps = [
+      {:deps_repo, "0.1.0", path: "custom/deps_repo", manager: :rebar3},
+      {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo")}
+    ]
+
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        [dep1, dep2] = Mix.Dep.Converger.converge([])
+        assert dep1.manager == nil
+        assert dep2.manager == :rebar3
+      end)
+    end)
+  end
+
+  test "nested deps with optional matching" do
+    Process.put(:custom_deps_git_repo_opts, optional: true)
+
+    # deps_repo brings git_repo but it is optional
+    deps = [
+      {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+      {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo")}
+    ]
+
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        File.mkdir_p!("custom/deps_repo/lib")
+
+        File.write!("custom/deps_repo/lib/a.ex", """
+        # Check that the child dependency is top_level and optional
+        [%Mix.Dep{app: :git_repo, top_level: true, opts: opts}] = Mix.Dep.cached()
+        true = Keyword.fetch!(opts, :optional)
+        """)
+
+        Mix.Tasks.Deps.Get.run([])
+        Mix.Tasks.Deps.Compile.run([])
+      end)
+    end)
+  end
+
+  test "nested deps with convergence and optional dependencies" do
+    deps = [
+      {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+      {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo")}
+    ]
+
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        File.write!("custom/deps_repo/mix.exs", """
+        defmodule DepsRepo do
+          use Mix.Project
+
+          def project do
+            [app: :deps_repo,
+             version: "0.1.0",
+             deps: [{:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), optional: true}]]
+          end
+        end
+        """)
+
+        assert Enum.map(Mix.Dep.Converger.converge([]), & &1.app) == [:git_repo, :deps_repo]
+      end)
+    end)
+  end
+
+  test "nested deps with optional dependencies and cousin conflict" do
+    deps = [
+      {:deps_repo1, "0.1.0", path: "custom/deps_repo1"},
+      {:deps_repo2, "0.1.0", path: "custom/deps_repo2"}
+    ]
+
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        File.mkdir_p!("custom/deps_repo1")
+
+        File.write!("custom/deps_repo1/mix.exs", """
+        defmodule DepsRepo1 do
+          use Mix.Project
+
+          def project do
+            [app: :deps_repo1,
+             version: "0.1.0",
+             deps: [{:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), optional: true}]]
+          end
+        end
+        """)
+
+        File.mkdir_p!("custom/deps_repo2")
+
+        File.write!("custom/deps_repo2/mix.exs", """
+        defmodule DepsRepo2 do
+          use Mix.Project
+
+          def project do
+            [app: :deps_repo2,
+             version: "0.1.0",
+             deps: [{:git_repo, "0.2.0", path: "somewhere"}]]
+          end
+        end
+        """)
+
+        Mix.Tasks.Deps.run([])
+        assert_received {:mix_shell, :info, ["* deps_repo1" <> _]}
+        assert_received {:mix_shell, :info, ["* deps_repo2" <> _]}
+        assert_received {:mix_shell, :info, ["* git_repo" <> _]}
+
+        assert_received {:mix_shell, :info,
+                         ["  different specs were given for the git_repo app" <> _]}
+      end)
+    end)
+  end
+
+  test "nested deps with optional dependencies and cousin conflict (reverse order)" do
+    deps = [
+      {:deps_repo2, "0.1.0", path: "custom/deps_repo2"},
+      {:deps_repo1, "0.1.0", path: "custom/deps_repo1"}
+    ]
+
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        File.mkdir_p!("custom/deps_repo1")
+
+        File.write!("custom/deps_repo1/mix.exs", """
+        defmodule DepsRepo1 do
+          use Mix.Project
+
+          def project do
+            [app: :deps_repo1,
+             version: "0.1.0",
+             deps: [{:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), optional: true}]]
+          end
+        end
+        """)
+
+        File.mkdir_p!("custom/deps_repo2")
+
+        File.write!("custom/deps_repo2/mix.exs", """
+        defmodule DepsRepo2 do
+          use Mix.Project
+
+          def project do
+            [app: :deps_repo2,
+             version: "0.1.0",
+             deps: [{:git_repo, "0.2.0", path: "somewhere"}]]
+          end
+        end
+        """)
+
+        Mix.Tasks.Deps.run([])
+        assert_received {:mix_shell, :info, ["* deps_repo1" <> _]}
+        assert_received {:mix_shell, :info, ["* deps_repo2" <> _]}
+        assert_received {:mix_shell, :info, ["* git_repo" <> _]}
+
+        assert_received {:mix_shell, :info,
+                         ["  different specs were given for the git_repo app" <> _]}
+      end)
+    end)
+  end
+
+  test "deps with system_env set" do
+    file_path = tmp_path("load dependency with env vars/dep-test")
+    dep_path = tmp_path("rebar_dep")
+
+    system_env = [{"FILE_FROM_ENV", file_path}, {"CONTENTS_FROM_ENV", "contents dep test"}]
+    deps = [{:rebar_dep, path: dep_path, app: false, manager: :rebar3, system_env: system_env}]
+
+    with_deps(deps, fn ->
+      in_tmp("load dependency with env vars", fn ->
+        Mix.Dep.Converger.converge([])
+        assert {:ok, "contents dep test"} = File.read(file_path)
+      end)
+    end)
+  end
+
+  test "diverged with system_env set" do
+    Process.put(:custom_deps_git_repo_opts, system_env: [{"FOO", "BAR"}])
+
+    deps = [
+      {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+      {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo")}
+    ]
+
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        [git_repo, _] = Mix.Dep.Converger.converge([])
+        %{app: :git_repo, status: {:overridden, _}} = git_repo
+      end)
+    end)
+  end
+
+  ## Remote converger
+
+  defmodule IdentityRemoteConverger do
+    @behaviour Mix.RemoteConverger
+
+    def remote?(%Mix.Dep{app: :deps_repo}), do: false
+    def remote?(%Mix.Dep{}), do: true
+    def deps(_dep, _lock), do: []
+    def post_converge, do: :ok
+
+    def converge(deps, lock) do
+      Process.put(:remote_converger, deps)
+      lock
     end
   end
 
-  test "correctly order converged deps" do
-    Mix.Project.push ConvergedDepsApp
+  test "remote converger" do
+    deps = [
+      {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+      {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo")}
+    ]
+
+    with_deps(deps, fn ->
+      Mix.RemoteConverger.register(IdentityRemoteConverger)
+
+      in_fixture("deps_status", fn ->
+        Mix.Tasks.Deps.Get.run([])
+
+        message = "* Getting git_repo (#{fixture_path("git_repo")})"
+        assert_received {:mix_shell, :info, [^message]}
+
+        assert Process.get(:remote_converger)
+      end)
+    end)
+  after
+    Mix.RemoteConverger.register(nil)
+  end
+
+  defmodule DivergingRemoteConverger do
+    @behaviour Mix.RemoteConverger
+
+    def remote?(%Mix.Dep{app: :deps_repo, scm: Mix.SCM.Path}), do: true
+    def remote?(%Mix.Dep{app: :git_repo, scm: Mix.SCM.Path}), do: true
+    def remote?(%Mix.Dep{}), do: false
+    def deps(%Mix.Dep{app: :deps_repo}, _lock), do: [{:git_repo, path: "custom/git_repo"}]
+    def deps(%Mix.Dep{app: :git_repo}, _lock), do: []
+    def post_converge, do: :ok
 
-    in_fixture "deps_status", fn ->
-      assert Enum.map(Mix.Dep.loaded([]), &(&1.app)) == [:git_repo, :deps_repo]
+    def converge(_deps, lock) do
+      lock
+      |> Map.put(:deps_repo, :custom)
+      |> Map.put(:git_repo, :custom)
     end
   end
 
-  test "correctly order converged deps even with optional dependencies" do
-    Mix.Project.push ConvergedDepsApp
+  test "converger detects diverged deps from remote converger" do
+    deps = [
+      {:deps_on_git_repo, "0.2.0", git: MixTest.Case.fixture_path("deps_on_git_repo")},
+      {:deps_repo, "0.1.0", path: "custom/deps_repo"}
+    ]
 
-    in_fixture "deps_status", fn ->
-      File.write! "custom/deps_repo/mix.exs", """
-      defmodule DepsRepo do
-        use Mix.Project
+    with_deps(deps, fn ->
+      Mix.RemoteConverger.register(DivergingRemoteConverger)
 
-        def project do
-          [
-            app: :deps_repo,
-            version: "0.1.0",
-            deps: [
-              {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), optional: true}
-            ]
-          ]
+      in_fixture("deps_status", fn ->
+        assert_raise Mix.Error, fn ->
+          Mix.Tasks.Deps.Get.run([])
         end
-      end
-      """
 
-      assert Enum.map(Mix.Dep.loaded([]), &(&1.app)) == [:git_repo, :deps_repo]
-    end
+        assert_received {:mix_shell, :error, ["Dependencies have diverged:"]}
+      end)
+    end)
+  after
+    Mix.RemoteConverger.register(nil)
   end
 
-  defmodule IdentityRemoteConverger do
+  test "pass dependencies to remote converger in defined order" do
+    deps = [
+      {:ok, "0.1.0", path: "deps/ok"},
+      {:invalidvsn, "0.2.0", path: "deps/invalidvsn"},
+      {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+      {:invalidapp, "0.1.0", path: "deps/invalidapp"},
+      {:noappfile, "0.1.0", path: "deps/noappfile"}
+    ]
+
+    with_deps(deps, fn ->
+      Mix.RemoteConverger.register(IdentityRemoteConverger)
+
+      in_fixture("deps_status", fn ->
+        Mix.Tasks.Deps.Get.run([])
+
+        deps = Process.get(:remote_converger) |> Enum.map(& &1.app)
+        assert deps == [:ok, :invalidvsn, :deps_repo, :invalidapp, :noappfile, :git_repo]
+      end)
+    end)
+  after
+    Mix.RemoteConverger.register(nil)
+  end
+
+  defmodule RaiseRemoteConverger do
     @behaviour Mix.RemoteConverger
 
-    def remote?(_app), do: true
+    def remote?(_app), do: false
+    def deps(_dep, _lock), do: :ok
+    def post_converge, do: :ok
 
     def converge(_deps, lock) do
       Process.put(:remote_converger, true)
       lock
     end
+  end
 
-    def deps(_deps, _lock) do
-      []
-    end
+  test "remote converger is not invoked if deps diverge" do
+    deps = [
+      {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+      {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), only: :test}
+    ]
+
+    with_deps(deps, fn ->
+      Mix.RemoteConverger.register(RaiseRemoteConverger)
+
+      in_fixture("deps_status", fn ->
+        assert_raise Mix.Error, fn ->
+          Mix.Tasks.Deps.Get.run([])
+        end
+
+        assert_received {:mix_shell, :error, ["Dependencies have diverged:"]}
+        refute Process.get(:remote_converger)
+      end)
+    end)
+  after
+    Mix.RemoteConverger.register(nil)
   end
 
-  test "remote converger" do
-    Mix.Project.push ConvergedDepsApp
-    Mix.RemoteConverger.register(IdentityRemoteConverger)
+  test "remote converger is not invoked if deps graph has cycles" do
+    deps = [{:app1, "0.1.0", path: "app1"}, {:app2, "0.1.0", path: "app2"}]
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Get.run([])
+    with_deps(deps, fn ->
+      Mix.RemoteConverger.register(RaiseRemoteConverger)
 
-      message = "* Getting git_repo (#{fixture_path("git_repo")})"
-      assert_received {:mix_shell, :info, [^message]}
+      in_fixture("deps_cycle", fn ->
+        assert_raise Mix.Error, ~r/Could not sort dependencies/, fn ->
+          Mix.Tasks.Deps.Get.run([])
+        end
 
-      assert Process.get(:remote_converger)
-    end
+        refute Process.get(:remote_converger)
+      end)
+    end)
   after
     Mix.RemoteConverger.register(nil)
   end
 
-  defmodule OnlyDeps do
-    def project do
-      [ deps: [ {:foo, github: "elixir-lang/foo"},
-                {:bar, github: "elixir-lang/bar", only: :other_env}  ] ]
-    end
+  defp sorted_keys(map) do
+    map |> Map.keys() |> Enum.sort()
   end
 
-  test "only extract deps matching environment" do
-    Mix.Project.push OnlyDeps
+  test "deps_paths" do
+    deps = [
+      {:abc_repo, "0.1.0", path: "custom/abc_repo"},
+      {:deps_repo, "0.1.0", path: "custom/deps_repo"}
+    ]
 
-    in_fixture "deps_status", fn ->
-      deps = Mix.Dep.loaded([env: :other_env])
-      assert length(deps) == 2
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        # Both orders below are valid after topological sort
+        assert Enum.map(Mix.Dep.Converger.converge([]), & &1.app) in [
+                 [:git_repo, :abc_repo, :deps_repo],
+                 [:abc_repo, :git_repo, :deps_repo]
+               ]
 
-      deps = Mix.Dep.loaded([])
-      assert length(deps) == 2
+        assert sorted_keys(Mix.Project.deps_paths()) == [:abc_repo, :deps_repo, :git_repo]
 
-      deps = Mix.Dep.loaded([env: :prod])
-      assert length(deps) == 1
-      assert Enum.find deps, &match?(%Mix.Dep{app: :foo}, &1)
-    end
+        assert sorted_keys(Mix.Project.deps_paths(depth: 1)) == [:abc_repo, :deps_repo]
+        assert sorted_keys(Mix.Project.deps_paths(depth: 2)) == [:abc_repo, :deps_repo, :git_repo]
+        assert sorted_keys(Mix.Project.deps_paths(depth: 3)) == [:abc_repo, :deps_repo, :git_repo]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:abc_repo])) == [:abc_repo]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:deps_repo])) == [
+                 :deps_repo,
+                 :git_repo
+               ]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:git_repo])) == [:git_repo]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:abc_repo], depth: 1)) == [:abc_repo]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:deps_repo], depth: 1)) == [
+                 :deps_repo
+               ]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:git_repo], depth: 1)) == [:git_repo]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:abc_repo], depth: 2)) == [:abc_repo]
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:git_repo], depth: 2)) == [:git_repo]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:deps_repo], depth: 2)) ==
+                 [:deps_repo, :git_repo]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:abc_repo, :deps_repo])) ==
+                 [:abc_repo, :deps_repo, :git_repo]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:abc_repo, :deps_repo], depth: 1)) ==
+                 [:abc_repo, :deps_repo]
+
+        assert sorted_keys(Mix.Project.deps_paths(parents: [:abc_repo, :deps_repo], depth: 2)) ==
+                 [:abc_repo, :deps_repo, :git_repo]
+      end)
+    end)
   end
 
-  defmodule OnlyChildDeps do
-    def project do
-      [ app: :raw_sample,
-        version: "0.1.0",
-        deps: [ {:only_deps, path: fixture_path("only_deps")} ] ]
+  test "deps_tree" do
+    deps = [
+      {:abc_repo, "0.1.0", path: "custom/abc_repo"},
+      {:deps_repo, "0.1.0", path: "custom/deps_repo"}
+    ]
+
+    with_deps(deps, fn ->
+      in_fixture("deps_status", fn ->
+        # Both orders below are valid after topological sort
+        assert Enum.map(Mix.Dep.Converger.converge([]), & &1.app) in [
+                 [:git_repo, :abc_repo, :deps_repo],
+                 [:abc_repo, :git_repo, :deps_repo]
+               ]
+
+        assert %{abc_repo: [], deps_repo: [:git_repo]} = Mix.Project.deps_tree(depth: 1)
+
+        assert %{abc_repo: [], deps_repo: [:git_repo], git_repo: []} =
+                 Mix.Project.deps_tree(depth: 2)
+
+        assert %{abc_repo: [], deps_repo: [:git_repo], git_repo: []} =
+                 Mix.Project.deps_tree(depth: 3)
+
+        assert %{abc_repo: []} = Mix.Project.deps_tree(parents: [:abc_repo])
+
+        assert %{deps_repo: [:git_repo], git_repo: []} =
+                 Mix.Project.deps_tree(parents: [:deps_repo])
+
+        assert %{git_repo: []} = Mix.Project.deps_tree(parents: [:git_repo])
+
+        assert %{abc_repo: []} = Mix.Project.deps_tree(parents: [:abc_repo], depth: 1)
+        assert %{deps_repo: [:git_repo]} = Mix.Project.deps_tree(parents: [:deps_repo], depth: 1)
+      end)
+    end)
+  end
+
+  describe "only handling" do
+    test "extracts deps matching environment" do
+      deps = [
+        {:foo, github: "elixir-lang/foo"},
+        {:bar, github: "elixir-lang/bar", only: :other_env}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          deps = Mix.Dep.Converger.converge(env: :other_env)
+          assert length(deps) == 2
+
+          deps = Mix.Dep.Converger.converge([])
+          assert length(deps) == 2
+
+          assert [dep] = Mix.Dep.Converger.converge(env: :prod)
+          assert dep.app == :foo
+        end)
+      end)
+    end
+
+    test "fetches parent deps matching specified env" do
+      deps = [{:only, github: "elixir-lang/only", only: [:dev]}]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          Mix.Tasks.Deps.Get.run(["--only", "prod"])
+          refute_received {:mix_shell, :info, ["* Getting" <> _]}
+
+          assert_raise Mix.Error, "Can't continue due to errors on dependencies", fn ->
+            Mix.Tasks.Deps.Loadpaths.run([])
+          end
+
+          Mix.State.clear_cache()
+          Mix.env(:prod)
+          Mix.Tasks.Deps.Loadpaths.run([])
+        end)
+      end)
+    end
+
+    test "selects only prod dependencies on nested deps" do
+      Process.put(:custom_deps_git_repo_opts, only: :test)
+      deps = [{:deps_repo, "0.1.0", path: "custom/deps_repo"}]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:deps_repo] = Enum.map(loaded, & &1.app)
+
+          loaded = Mix.Dep.Converger.converge(env: :test)
+          assert [:deps_repo] = Enum.map(loaded, & &1.app)
+        end)
+      end)
+    end
+
+    test "conflicts on nested deps" do
+      # deps_repo wants all git_repo, git_repo is restricted to only test
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+        {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), only: :test}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [divergedonly: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :dev)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [divergedonly: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :test)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [divergedonly: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          Mix.Tasks.Deps.run([])
+          assert_received {:mix_shell, :info, ["* deps_repo" <> _]}
+          assert_received {:mix_shell, :info, [_]}
+          assert_received {:mix_shell, :info, ["* git_repo" <> _]}
+          assert_received {:mix_shell, :info, [msg]}
+          assert msg =~ "Remove the :only restriction from your dep"
+        end)
+      end)
+    end
+
+    test "does not conflict with optional deps on nested deps" do
+      Process.put(:custom_deps_git_repo_opts, optional: true)
+
+      # deps_repo wants all git_repo, git_repo is restricted to only test
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+        {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), only: :test}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :dev)
+          assert [:deps_repo] = Enum.map(loaded, & &1.app)
+          assert [noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :test)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+        end)
+      end)
+    end
+
+    test "does not conflict with optional deps on nested deps (reverse order)" do
+      Process.put(:custom_deps_git_repo_opts, optional: true)
+
+      # deps_repo wants all git_repo, git_repo is restricted to only test
+      deps = [
+        {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), only: :test},
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :dev)
+          assert [:deps_repo] = Enum.map(loaded, & &1.app)
+          assert [noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :test)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+        end)
+      end)
+    end
+
+    test "does not conflict on valid subsets on nested deps" do
+      # deps_repo wants git_repo for prod, git_repo is restricted to only prod and test
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", only: :prod},
+        {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), only: [:prod, :test]}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :dev)
+          assert [] = Enum.map(loaded, & &1.app)
+
+          loaded = Mix.Dep.Converger.converge(env: :test)
+          assert [:git_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :prod)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+        end)
+      end)
+    end
+
+    test "conflicts on invalid only subset on nested deps" do
+      # deps_repo wants git_repo for dev, git_repo is restricted to only test
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", only: :dev},
+        {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), only: [:test]}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [divergedonly: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :dev)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [divergedonly: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :test)
+          assert [:git_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _] = Enum.map(loaded, & &1.status)
+
+          Mix.Tasks.Deps.run([])
+          assert_received {:mix_shell, :info, ["* deps_repo" <> _]}
+          assert_received {:mix_shell, :info, [_]}
+          assert_received {:mix_shell, :info, ["* git_repo" <> _]}
+          assert_received {:mix_shell, :info, [msg]}
+          assert msg =~ "Ensure you specify at least the same environments in :only in your dep"
+        end)
+      end)
+    end
+
+    test "does not conflict with valid only in both parent and child on nested deps" do
+      Process.put(:custom_deps_git_repo_opts, only: :test)
+
+      # deps_repo has environment set to test so it loads the deps_git_repo set to test too
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", env: :test, only: [:dev, :test]},
+        {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo"), only: :test}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :dev)
+          assert [:deps_repo] = Enum.map(loaded, & &1.app)
+          assert [noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :test)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(env: :prod)
+          assert [] = Enum.map(loaded, & &1.app)
+        end)
+      end)
+    end
+
+    test "converges and diverges when only is not in_upper" do
+      loaded = fn deps ->
+        with_deps(deps, fn ->
+          in_fixture("deps_status", fn ->
+            File.mkdir_p!("custom/other_repo")
+
+            File.write!("custom/other_repo/mix.exs", """
+            defmodule OtherRepo do
+              use Mix.Project
+
+              def project do
+                [app: :other_repo,
+                 version: "0.1.0",
+                 deps: [{:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo")}]]
+              end
+            end
+            """)
+
+            Mix.State.clear_cache()
+            loaded = Mix.Dep.Converger.converge([])
+            Enum.map(loaded, &{&1.app, &1.opts[:only]})
+          end)
+        end)
+      end
+
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", only: :prod},
+        {:other_repo, "0.1.0", path: "custom/other_repo", only: :test}
+      ]
+
+      assert loaded.(deps) == [git_repo: [:test, :prod], other_repo: :test, deps_repo: :prod]
+
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+        {:other_repo, "0.1.0", path: "custom/other_repo", only: :test}
+      ]
+
+      assert loaded.(deps) == [git_repo: nil, other_repo: :test, deps_repo: nil]
+
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", only: :prod},
+        {:other_repo, "0.1.0", path: "custom/other_repo"}
+      ]
+
+      assert loaded.(deps) == [git_repo: nil, other_repo: nil, deps_repo: :prod]
+
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+        {:other_repo, "0.1.0", path: "custom/other_repo"}
+      ]
+
+      assert loaded.(deps) == [git_repo: nil, other_repo: nil, deps_repo: nil]
+
+      Process.put(:custom_deps_git_repo_opts, optional: true)
+
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", only: :prod},
+        {:other_repo, "0.1.0", path: "custom/other_repo", only: :test}
+      ]
+
+      assert loaded.(deps) == [git_repo: :test, other_repo: :test, deps_repo: :prod]
+    end
+
+    test "converges and diverges when only is not specified" do
+      Process.put(:custom_deps_git_repo_opts, only: :test)
+
+      deps = [
+        {:abc_repo, "0.1.0", path: "custom/abc_repo", from_umbrella: true},
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", from_umbrella: true}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          File.mkdir_p!("custom/abc_repo")
+
+          File.write!("custom/abc_repo/mix.exs", """
+          defmodule OtherRepo do
+            use Mix.Project
+
+            def project do
+              [app: :abc_repo,
+               version: "0.1.0",
+               deps: [{:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo")}]]
+            end
+          end
+          """)
+
+          Mix.Tasks.Deps.Get.run([])
+          Mix.Tasks.Deps.Compile.run([])
+          refute_receive {:mix_shell, :error, ["Could not compile :git_repo" <> _]}, 100
+        end)
+      end)
     end
   end
 
-  test "only fetch child deps matching prod env" do
-    Mix.Project.push OnlyChildDeps
+  describe "targets handling" do
+    test "extracts deps matching target" do
+      deps = [
+        {:foo, github: "elixir-lang/foo"},
+        {:bar, github: "elixir-lang/bar", targets: :rpi3}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          deps = Mix.Dep.Converger.converge(target: :rpi3)
+          assert length(deps) == 2
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Get.run([])
-      message = "* Getting git_repo (#{fixture_path("git_repo")})"
-      refute_received {:mix_shell, :info, [^message]}
+          deps = Mix.Dep.Converger.converge([])
+          assert length(deps) == 2
+
+          assert [dep] = Mix.Dep.Converger.converge(target: :host)
+          assert dep.app == :foo
+        end)
+      end)
+    end
+
+    test "fetches parent deps matching specified target" do
+      deps = [{:target, github: "elixir-lang/target", targets: [:host]}]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          Mix.Tasks.Deps.Get.run(["--target", "rpi3"])
+          refute_received {:mix_shell, :info, ["* Getting" <> _]}
+
+          assert_raise Mix.Error, "Can't continue due to errors on dependencies", fn ->
+            Mix.Tasks.Deps.Loadpaths.run([])
+          end
+
+          Mix.State.clear_cache()
+          Mix.target(:rpi3)
+          Mix.Tasks.Deps.Loadpaths.run([])
+        end)
+      end)
+    end
+
+    test "conflicts on nested deps" do
+      # deps_repo wants all git_repo, git_repo is restricted to targets rpi3
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+        {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), targets: :rpi3}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [divergedtargets: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :host)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [divergedtargets: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :rpi3)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [divergedtargets: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          Mix.Tasks.Deps.run([])
+          assert_received {:mix_shell, :info, ["* deps_repo" <> _]}
+          assert_received {:mix_shell, :info, [_]}
+          assert_received {:mix_shell, :info, ["* git_repo" <> _]}
+          assert_received {:mix_shell, :info, [msg]}
+          assert msg =~ "Remove the :targets restriction from your dep"
+        end)
+      end)
+    end
+
+    test "does not conflict with optional deps on nested deps" do
+      Process.put(:custom_deps_git_repo_opts, optional: true)
+
+      # deps_repo wants all git_repo, git_repo is restricted to targets rpi3
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+        {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), targets: :rpi3}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :host)
+          assert [:deps_repo] = Enum.map(loaded, & &1.app)
+          assert [noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :rpi3)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+        end)
+      end)
+    end
+
+    test "does not conflict on valid subsets on nested deps" do
+      # deps_repo wants git_repo for prod, git_repo is restricted to targets bbb and rpi3
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", targets: :rpi3},
+        {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), targets: [:bbb, :rpi3]}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :host)
+          assert [] = Enum.map(loaded, & &1.app)
+
+          loaded = Mix.Dep.Converger.converge(target: :bbb)
+          assert [:git_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :rpi3)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+        end)
+      end)
+    end
+
+    test "conflicts on invalid only subset on nested deps" do
+      # deps_repo wants git_repo for rpi3, git_repo is restricted to only test
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", targets: :host},
+        {:git_repo, "0.2.0", git: MixTest.Case.fixture_path("git_repo"), targets: [:rpi3]}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [divergedtargets: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :host)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [divergedtargets: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :rpi3)
+          assert [:git_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _] = Enum.map(loaded, & &1.status)
+
+          Mix.Tasks.Deps.run([])
+          assert_received {:mix_shell, :info, ["* deps_repo" <> _]}
+          assert_received {:mix_shell, :info, [_]}
+          assert_received {:mix_shell, :info, ["* git_repo" <> _]}
+          assert_received {:mix_shell, :info, [msg]}
+          assert msg =~ "Ensure you specify at least the same targets in :targets in your dep"
+        end)
+      end)
+    end
+
+    test "does not conflict with valid only in both parent and child on nested deps" do
+      Process.put(:custom_deps_git_repo_opts, targets: :bbb)
+
+      # deps_repo has environment set to bbb so it loads the deps_git_repo set to bbb too
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", env: :test, targets: [:host, :bbb]},
+        {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo"), targets: :bbb}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          loaded = Mix.Dep.Converger.converge([])
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :host)
+          assert [:deps_repo] = Enum.map(loaded, & &1.app)
+          assert [noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :bbb)
+          assert [:git_repo, :deps_repo] = Enum.map(loaded, & &1.app)
+          assert [unavailable: _, noappfile: {_, _}] = Enum.map(loaded, & &1.status)
+
+          loaded = Mix.Dep.Converger.converge(target: :rpi3)
+          assert [] = Enum.map(loaded, & &1.app)
+        end)
+      end)
+    end
+
+    test "converges and diverges when only is not in_upper" do
+      loaded = fn deps ->
+        with_deps(deps, fn ->
+          in_fixture("deps_status", fn ->
+            File.mkdir_p!("custom/other_repo")
+
+            File.write!("custom/other_repo/mix.exs", """
+            defmodule OtherRepo do
+              use Mix.Project
+
+              def project do
+                [app: :other_repo,
+                 version: "0.1.0",
+                 deps: [{:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo")}]]
+              end
+            end
+            """)
+
+            Mix.State.clear_cache()
+            loaded = Mix.Dep.Converger.converge([])
+            Enum.map(loaded, &{&1.app, &1.opts[:targets]})
+          end)
+        end)
+      end
+
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", targets: :rpi3},
+        {:other_repo, "0.1.0", path: "custom/other_repo", targets: :bbb}
+      ]
+
+      assert loaded.(deps) == [git_repo: [:bbb, :rpi3], other_repo: :bbb, deps_repo: :rpi3]
+
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+        {:other_repo, "0.1.0", path: "custom/other_repo", targets: :bbb}
+      ]
+
+      assert loaded.(deps) == [git_repo: nil, other_repo: :bbb, deps_repo: nil]
+
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", targets: :rpi3},
+        {:other_repo, "0.1.0", path: "custom/other_repo"}
+      ]
+
+      assert loaded.(deps) == [git_repo: nil, other_repo: nil, deps_repo: :rpi3]
+
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+        {:other_repo, "0.1.0", path: "custom/other_repo"}
+      ]
+
+      assert loaded.(deps) == [git_repo: nil, other_repo: nil, deps_repo: nil]
+
+      Process.put(:custom_deps_git_repo_opts, optional: true)
+
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", targets: :rpi3},
+        {:other_repo, "0.1.0", path: "custom/other_repo", targets: :bbb}
+      ]
+
+      assert loaded.(deps) == [git_repo: :bbb, other_repo: :bbb, deps_repo: :rpi3]
     end
   end
 
-  defmodule OnlyParentDeps do
-    def project do
-      [ app: :raw_sample,
-        version: "0.1.0",
-        deps: [ {:only, github: "elixir-lang/only", only: :dev} ] ]
+  describe "overrides" do
+    test "are not required when there are no conflicts" do
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          File.mkdir_p!("custom/deps_repo/lib")
+
+          File.write!("custom/deps_repo/lib/a.ex", """
+          # Check that the child dependency is top_level
+          [%Mix.Dep{app: :git_repo, top_level: true}] = Mix.Dep.cached()
+          """)
+
+          Mix.Tasks.Deps.Get.run([])
+          Mix.Tasks.Deps.Compile.run([])
+        end)
+      end)
+    end
+
+    test "are required when there are conflicts" do
+      # deps_repo brings git_repo but it is overridden
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+        {:git_repo, ">= 0.0.0", git: MixTest.Case.fixture_path("git_repo"), override: true}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          File.mkdir_p!("custom/deps_repo/lib")
+
+          File.write!("custom/deps_repo/lib/a.ex", """
+          # Check that the overridden requirement shows up in the child dependency
+          [%Mix.Dep{app: :git_repo, requirement: ">= 0.0.0"}] = Mix.Dep.cached()
+          """)
+
+          Mix.Tasks.Deps.Get.run([])
+          Mix.Tasks.Deps.Compile.run([])
+        end)
+      end)
     end
   end
 
-  test "only fetch parent deps matching specified env" do
-    Mix.Project.push OnlyParentDeps
+  describe "app generation" do
+    test "considers runtime from current app on nested deps" do
+      Process.put(:custom_deps_git_repo_opts, runtime: false)
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Get.run(["--only", "prod"])
-      refute_received {:mix_shell, :info, ["* Getting" <> _]}
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo"},
+        {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo")}
+      ]
 
-      assert_raise Mix.Error, "Can't continue due to errors on dependencies", fn ->
-        Mix.Tasks.Deps.Check.run([])
-      end
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          Mix.Tasks.Deps.Compile.run([])
+
+          {:ok, [{:application, :deps_repo, opts}]} =
+            :file.consult("_build/dev/lib/deps_repo/ebin/deps_repo.app")
+
+          assert :git_repo not in Keyword.get(opts, :applications)
+        end)
+      end)
+    end
+
+    test "considers only from current app on nested deps" do
+      Process.put(:custom_deps_git_repo_opts, only: :other)
 
-      Mix.env(:prod)
-      Mix.Tasks.Deps.Check.run([])
+      deps = [
+        {:deps_repo, "0.1.0", path: "custom/deps_repo", from_umbrella: true},
+        {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo"), from_umbrella: true}
+      ]
+
+      with_deps(deps, fn ->
+        in_fixture("deps_status", fn ->
+          Mix.Tasks.Deps.Compile.run([])
+
+          {:ok, [{:application, :deps_repo, opts}]} =
+            :file.consult("_build/dev/lib/deps_repo/ebin/deps_repo.app")
+
+          assert :git_repo not in Keyword.get(opts, :applications)
+        end)
+      end)
     end
   end
 end
diff --git a/lib/mix/test/mix/generator_test.exs b/lib/mix/test/mix/generator_test.exs
index 2370c30557a..e9f9f82522b 100644
--- a/lib/mix/test/mix/generator_test.exs
+++ b/lib/mix/test/mix/generator_test.exs
@@ -1,55 +1,280 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Mix.GeneratorTest do
   use MixTest.Case
 
   import Mix.Generator
 
-  embed_text :foo,     "foo"
-  embed_text :self,    from_file: __ENV__.file
-  embed_template :bar, "<%= @a + @b %>"
+  embed_text(:foo, "foo")
+  embed_text(:self, from_file: __ENV__.file)
+  embed_template(:bar, "<%= @a + @b %>")
+
+  describe "embed_text/2" do
+    test "with contents" do
+      assert foo_text() == "foo"
+    end
 
-  test :embed_text do
-    assert foo_text == "foo"
+    test "from file" do
+      assert self_text() =~ "import Mix.Generator"
+    end
   end
 
-  test :embed_template do
+  test "embed template" do
     assert bar_template(a: 1, b: 2) == "3"
   end
 
-  test :from_file do
-    assert self_text =~ "import Mix.Generator"
+  describe "overwrite?/1" do
+    test "without conflict" do
+      in_tmp("overwrite", fn ->
+        assert overwrite?("foo")
+        refute_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+
+    test "with conflict returning true" do
+      in_tmp("overwrite", fn ->
+        File.write!("foo", "HELLO")
+        send(self(), {:mix_shell_input, :yes?, true})
+
+        assert overwrite?("foo")
+        assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+
+    test "with conflict returning false" do
+      in_tmp("overwrite", fn ->
+        File.write!("foo", "HELLO")
+        send(self(), {:mix_shell_input, :yes?, false})
+
+        refute overwrite?("foo")
+        assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
   end
 
-  test :create_file do
-    in_tmp "create_file", fn ->
-      create_file "foo", "HELLO"
-      assert File.read!("foo") == "HELLO"
-      assert_received {:mix_shell, :info, ["* creating foo"]}
+  describe "overwrite?/2" do
+    test "without conflict" do
+      in_tmp("overwrite", fn ->
+        assert overwrite?("foo", "HELLO")
+        refute_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+
+    test "with same contents" do
+      in_tmp("overwrite", fn ->
+        File.write!("foo", "HELLO")
+        refute overwrite?("foo", "HELLO")
+        refute_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+
+    test "with conflict returning true" do
+      in_tmp("overwrite", fn ->
+        File.write!("foo", "HELLO")
+        send(self(), {:mix_shell_input, :yes?, true})
+
+        assert overwrite?("foo", "WORLD")
+        assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+
+    test "with conflict returning false" do
+      in_tmp("overwrite", fn ->
+        File.write!("foo", "HELLO")
+        send(self(), {:mix_shell_input, :yes?, false})
+
+        refute overwrite?("foo", "WORLD")
+        assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
     end
   end
 
-  test :create_with_conflict_returning_true do
-    in_tmp "create_file", fn ->
-      File.write! "foo", "HELLO"
-      send self, {:mix_shell_input, :yes?, true}
+  describe "create_file/3" do
+    test "creates file" do
+      in_tmp("create_file", fn ->
+        create_file("foo", "HELLO")
+        assert File.read!("foo") == "HELLO"
+        assert_received {:mix_shell, :info, ["* creating foo"]}
+      end)
+    end
+
+    test "with quiet" do
+      in_tmp("create_file", fn ->
+        create_file("foo", "HELLO", quiet: true)
+        assert File.read!("foo") == "HELLO"
+        refute_received {:mix_shell, :info, ["* creating foo"]}
+      end)
+    end
+
+    test "with force" do
+      in_tmp("create_file", fn ->
+        File.write!("foo", "HELLO")
+        create_file("foo", "WORLD", force: true)
+        assert File.read!("foo") == "WORLD"
+
+        refute_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+        assert_received {:mix_shell, :info, ["* creating foo"]}
+      end)
+    end
+
+    test "with same contents" do
+      in_tmp("create_file", fn ->
+        File.write!("foo", "HELLO")
+        create_file("foo", "HELLO")
+        assert File.read!("foo") == "HELLO"
+        refute_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+
+    test "with conflict returning true" do
+      in_tmp("create_file", fn ->
+        File.write!("foo", "HELLO")
+        send(self(), {:mix_shell_input, :yes?, true})
+
+        create_file("foo", "WORLD")
+        assert File.read!("foo") == "WORLD"
+        assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
 
-      create_file "foo", "WORLD"
-      assert File.read!("foo") == "WORLD"
+    test "with conflict returning false" do
+      in_tmp("create_file", fn ->
+        File.write!("foo", "HELLO")
+        send(self(), {:mix_shell_input, :yes?, false})
 
-      assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+        create_file("foo", "WORLD")
+        assert File.read!("foo") == "HELLO"
+        assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+
+    test "with `format_elixir: true`" do
+      in_tmp("create_file", fn ->
+        create_file("foo", "%{ foo:  :bar }", format_elixir: true)
+        assert File.read!("foo") == "%{foo: :bar}\n"
+      end)
     end
   end
 
-  test :create_with_conflict_returning_false do
-    in_tmp "create_file", fn ->
-      File.write! "foo", "HELLO"
-      send self, {:mix_shell_input, :yes?, false}
+  describe "copy_file/3" do
+    test "copies file" do
+      in_tmp("copy_file", fn ->
+        copy_file(__ENV__.file, "foo")
+        assert File.read!("foo") =~ ~s[describe "copy_file/3" do]
+        assert_received {:mix_shell, :info, ["* creating foo"]}
+      end)
+    end
+
+    test "with quiet" do
+      in_tmp("copy_file", fn ->
+        copy_file(__ENV__.file, "foo", quiet: true)
+        assert File.read!("foo") =~ ~s[describe "copy_file/3" do]
+        refute_received {:mix_shell, :info, ["* creating foo"]}
+      end)
+    end
+
+    test "with force" do
+      in_tmp("copy_file", fn ->
+        File.write!("foo", "HELLO")
+        copy_file(__ENV__.file, "foo", force: true)
+        assert File.read!("foo") =~ ~s[describe "copy_file/3" do]
+
+        refute_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+        assert_received {:mix_shell, :info, ["* creating foo"]}
+      end)
+    end
+
+    test "with same contents" do
+      in_tmp("copy_file", fn ->
+        copy_file(__ENV__.file, "foo")
+        copy_file(__ENV__.file, "foo")
+        refute_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+
+    test "with conflict returning true" do
+      in_tmp("copy_file", fn ->
+        File.write!("foo", "HELLO")
+        send(self(), {:mix_shell_input, :yes?, true})
+
+        copy_file(__ENV__.file, "foo")
+        assert File.read!("foo") =~ ~s[describe "copy_file/3" do]
+        assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+
+    test "with conflict returning false" do
+      in_tmp("copy_file", fn ->
+        File.write!("foo", "HELLO")
+        send(self(), {:mix_shell_input, :yes?, false})
+
+        copy_file(__ENV__.file, "foo")
+        assert File.read!("foo") == "HELLO"
+        assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+  end
+
+  describe "copy_template/4" do
+    test "copies template" do
+      in_tmp("copy_template", fn ->
+        copy_template(__ENV__.file, "foo", a: 1, b: 2)
+        assert File.read!("foo") =~ ~s[embed_template(:bar, "3")]
+        assert_received {:mix_shell, :info, ["* creating foo"]}
+      end)
+    end
+
+    test "with quiet" do
+      in_tmp("copy_template", fn ->
+        copy_template(__ENV__.file, "foo", [a: 1, b: 2], quiet: true)
+        assert File.read!("foo") =~ ~s[embed_template(:bar, "3")]
+        refute_received {:mix_shell, :info, ["* creating foo"]}
+      end)
+    end
+
+    test "with force" do
+      in_tmp("copy_template", fn ->
+        File.write!("foo", "HELLO")
+        copy_template(__ENV__.file, "foo", [a: 1, b: 2], force: true)
+        assert File.read!("foo") =~ ~s[embed_template(:bar, "3")]
+
+        refute_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+        assert_received {:mix_shell, :info, ["* creating foo"]}
+      end)
+    end
+
+    test "with same contents" do
+      in_tmp("copy_template", fn ->
+        copy_template(__ENV__.file, "foo", a: 1, b: 2)
+        copy_template(__ENV__.file, "foo", a: 1, b: 2)
+        refute_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
+
+    test "with conflict returning true" do
+      in_tmp("copy_template", fn ->
+        File.write!("foo", "HELLO")
+        send(self(), {:mix_shell_input, :yes?, true})
+
+        copy_template(__ENV__.file, "foo", a: 1, b: 2)
+        assert File.read!("foo") =~ ~s[embed_template(:bar, "3")]
+        assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
+    end
 
-      create_file "foo", "WORLD"
-      assert File.read!("foo") == "HELLO"
+    test "with conflict returning false" do
+      in_tmp("copy_template", fn ->
+        File.write!("foo", "HELLO")
+        send(self(), {:mix_shell_input, :yes?, false})
 
-      assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+        copy_template(__ENV__.file, "foo", a: 1, b: 2)
+        assert File.read!("foo") == "HELLO"
+        assert_received {:mix_shell, :yes?, ["foo already exists, overwrite?"]}
+      end)
     end
   end
 end
diff --git a/lib/mix/test/mix/local/installer_test.exs b/lib/mix/test/mix/local/installer_test.exs
new file mode 100644
index 00000000000..6daf3775bd7
--- /dev/null
+++ b/lib/mix/test/mix/local/installer_test.exs
@@ -0,0 +1,144 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Local.InstallerTest do
+  use MixTest.Case
+
+  test "fetch" do
+    dep_spec = {:git_repo, git: fixture_path("git_repo")}
+
+    fetcher = fn mix_exs ->
+      send(self(), mix_exs)
+      Mix.Task.run("deps.get", [])
+    end
+
+    config =
+      Mix.Local.Installer.fetch(dep_spec, fetcher, fn _mix_exs ->
+        assert Mix.env() == :prod
+        Mix.Project.config()
+      end)
+
+    # Fetcher should run twice
+    assert_receive Mix.Local.Installer.MixProject
+    assert_receive GitRepo.MixProject
+
+    # In package runs once
+    assert Mix.env() == :dev
+    assert config[:app] == :git_repo
+    assert config[:deps_path] =~ ~r/mix-local-installer-fetcher-.*\/deps/
+    assert config[:lockfile] =~ ~r/mix-local-installer-fetcher-.*\/mix.lock/
+  after
+    purge([GitRepo.MixProject, Mix.Local.Installer.MixProject])
+  end
+
+  test "parse_args Git" do
+    args = ["git", "https://example.com/user/repo.git"]
+    opts = [git: "https://example.com/user/repo.git", submodules: nil, sparse: nil]
+
+    assert Mix.Local.Installer.parse_args(args, []) == {:fetcher, {:"new package", opts}}
+  end
+
+  test "parse_args Git branch" do
+    args = ["git", "https://example.com/user/repo.git", "branch", "not_main"]
+
+    opts = [
+      branch: "not_main",
+      git: "https://example.com/user/repo.git",
+      submodules: nil,
+      sparse: nil
+    ]
+
+    assert Mix.Local.Installer.parse_args(args, []) == {:fetcher, {:"new package", opts}}
+  end
+
+  test "parse_args Git ref" do
+    args = ["git", "https://example.com/user/repo.git", "ref", "not_main"]
+
+    opts = [
+      ref: "not_main",
+      git: "https://example.com/user/repo.git",
+      submodules: nil,
+      sparse: nil
+    ]
+
+    assert Mix.Local.Installer.parse_args(args, []) == {:fetcher, {:"new package", opts}}
+  end
+
+  test "parse_args Git tag" do
+    args = ["git", "https://example.com/user/repo.git", "tag", "not_main"]
+
+    opts = [
+      tag: "not_main",
+      git: "https://example.com/user/repo.git",
+      submodules: nil,
+      sparse: nil
+    ]
+
+    assert Mix.Local.Installer.parse_args(args, []) == {:fetcher, {:"new package", opts}}
+  end
+
+  test "parse_args Git submodules" do
+    args = ["git", "https://example.com/user/repo.git"]
+    opts = [git: "https://example.com/user/repo.git", submodules: true, sparse: nil]
+
+    assert Mix.Local.Installer.parse_args(args, submodules: true) ==
+             {:fetcher, {:"new package", opts}}
+  end
+
+  test "parse_args Git sparse" do
+    args = ["git", "https://example.com/user/repo.git"]
+    opts = [git: "https://example.com/user/repo.git", submodules: nil, sparse: "foo"]
+
+    assert Mix.Local.Installer.parse_args(args, sparse: "foo") ==
+             {:fetcher, {:"new package", opts}}
+  end
+
+  test "parse_args Git app" do
+    args = ["git", "https://example.com/user/repo.git"]
+    opts = [git: "https://example.com/user/repo.git", submodules: nil, sparse: nil]
+
+    assert Mix.Local.Installer.parse_args(args, app: "my_app") == {:fetcher, {:my_app, opts}}
+  end
+
+  test "parse_args GitHub" do
+    args = ["github", "user/repo"]
+    opts = [git: "https://github.com/user/repo.git", submodules: nil, sparse: nil]
+
+    assert Mix.Local.Installer.parse_args(args, []) == {:fetcher, {:"new package", opts}}
+  end
+
+  test "parse_args Hex" do
+    assert Mix.Local.Installer.parse_args(["hex", "a_package"], []) ==
+             {:fetcher, {:a_package, ">= 0.0.0", [hex: :a_package, repo: "hexpm"]}}
+  end
+
+  test "parse_args Hex app" do
+    assert Mix.Local.Installer.parse_args(["hex", "a_package"], app: "my_app") ==
+             {:fetcher, {:my_app, ">= 0.0.0", [hex: :a_package, repo: "hexpm"]}}
+  end
+
+  test "parse_args Hex version spec" do
+    assert Mix.Local.Installer.parse_args(["hex", "a_package", "1.0.0"], []) ==
+             {:fetcher, {:a_package, "1.0.0", [hex: :a_package, repo: "hexpm"]}}
+  end
+
+  test "parse_args Hex with organization" do
+    assert Mix.Local.Installer.parse_args(["hex", "a_package"], organization: "my_org") ==
+             {:fetcher, {:a_package, ">= 0.0.0", [hex: :a_package, repo: "hexpm:my_org"]}}
+  end
+
+  test "parse_args Hex with repo" do
+    assert Mix.Local.Installer.parse_args(["hex", "a_package"], repo: "my_repo") ==
+             {:fetcher, {:a_package, ">= 0.0.0", [hex: :a_package, repo: "my_repo"]}}
+  end
+
+  test "parse_args Hex with repo and organization" do
+    opts = [repo: "my_repo", organization: "my_org"]
+
+    assert Mix.Local.Installer.parse_args(["hex", "a_package"], opts) ==
+             {:fetcher, {:a_package, ">= 0.0.0", [hex: :a_package, repo: "my_repo:my_org"]}}
+  end
+end
diff --git a/lib/mix/test/mix/local_test.exs b/lib/mix/test/mix/local_test.exs
new file mode 100644
index 00000000000..e08371e8dc9
--- /dev/null
+++ b/lib/mix/test/mix/local_test.exs
@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Mix.LocalTest do
+  use MixTest.Case
+
+  @csv """
+  1.2.5,ABC,0.9.0,26
+  1.2.3,DEF,1.0.0,26
+  1.2.4,GHI,1.0.0,26
+  """
+
+  @tag :tmp_dir
+  test "select correct versions from csv", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      File.write!("csv", @csv)
+
+      assert {"1.0.0", "1.2.4", "GHI", "26"} =
+               Mix.Local.find_matching_versions!("name", nil, "csv")
+    end)
+  end
+
+  @tag :tmp_dir
+  test "select specific version from csv", %{tmp_dir: tmp_dir} do
+    File.cd!(tmp_dir, fn ->
+      File.write!("csv", @csv)
+
+      assert {"0.9.0", "1.2.5", "ABC", "26"} =
+               Mix.Local.find_matching_versions!("name", "1.2.5", "csv")
+
+      assert {"1.0.0", "1.2.3", "DEF", "26"} =
+               Mix.Local.find_matching_versions!("name", "1.2.3", "csv")
+
+      assert_raise Mix.Error, "Could not find a version of name matching: 1.3.0", fn ->
+        Mix.Local.find_matching_versions!("name", "1.3.0", "csv")
+      end
+    end)
+  end
+end
diff --git a/lib/mix/test/mix/project_test.exs b/lib/mix/test/mix/project_test.exs
index 7aaa7447158..25cf51874ab 100644
--- a/lib/mix/test/mix/project_test.exs
+++ b/lib/mix/test/mix/project_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Mix.ProjectTest do
   use MixTest.Case
@@ -9,13 +13,72 @@ defmodule Mix.ProjectTest do
     end
   end
 
+  test "consolidation_path/1" do
+    config = [apps_path: "apps", build_per_environment: true]
+
+    assert Mix.Project.consolidation_path(config) ==
+             Path.join(File.cwd!(), "_build/dev/consolidated")
+
+    config = [app: :sample, build_per_environment: true]
+
+    assert Mix.Project.consolidation_path(config) ==
+             Path.join(File.cwd!(), "_build/dev/lib/sample/consolidated")
+  end
+
+  describe "build_path/1" do
+    test "considers the environment" do
+      assert Mix.Project.build_path(build_per_environment: true) ==
+               Path.join(File.cwd!(), "_build/dev")
+
+      assert Mix.Project.build_path(build_per_environment: false) ==
+               Path.join(File.cwd!(), "_build/shared")
+    end
+
+    test "considers the target" do
+      Mix.target(:rpi3)
+
+      assert Mix.Project.build_path(build_per_environment: true) ==
+               Path.join(File.cwd!(), "_build/rpi3_dev")
+
+      assert Mix.Project.build_path(build_per_environment: false) ==
+               Path.join(File.cwd!(), "_build/rpi3_shared")
+    end
+
+    test "considers MIX_BUILD_PATH" do
+      System.put_env("MIX_BUILD_PATH", "_build")
+      assert Mix.Project.build_path() == Path.join(File.cwd!(), "_build")
+    after
+      System.delete_env("MIX_BUILD_PATH")
+    end
+
+    test "considers MIX_BUILD_ROOT" do
+      System.put_env("MIX_BUILD_ROOT", "_build_root")
+      assert Mix.Project.build_path() == Path.join(File.cwd!(), "_build_root/dev")
+    after
+      System.delete_env("MIX_BUILD_ROOT")
+    end
+
+    test "considers MIX_DEPS_PATH" do
+      System.put_env("MIX_DEPS_PATH", "test_deps_path")
+      assert Mix.Project.deps_path() == Path.join(File.cwd!(), "test_deps_path")
+    after
+      System.delete_env("MIX_DEPS_PATH")
+    end
+  end
+
+  test "returns mix.exs path" do
+    assert Mix.Project.project_file() == nil
+    Mix.Project.push(SampleProject, "sample")
+    assert Mix.Project.project_file() == "sample"
+  end
+
   test "push and pop projects" do
-    refute Mix.Project.get
+    refute Mix.Project.get()
     Mix.Project.push(SampleProject, "sample")
-    assert Mix.Project.get == SampleProject
+    assert Mix.Project.get() == SampleProject
 
-    assert %{name: SampleProject, config: _, file: "sample"} = Mix.Project.pop
-    assert nil = Mix.Project.pop
+    assert %{name: SampleProject, config: _, file: "sample"} = Mix.Project.pop()
+    assert Mix.Project.pop() == nil
   end
 
   test "does not allow the same project to be pushed twice" do
@@ -27,79 +90,110 @@ defmodule Mix.ProjectTest do
   end
 
   test "allows nil projects to be pushed twice" do
-    Mix.Project.push nil
-    Mix.Project.push nil
-    assert is_map Mix.Project.pop
-    assert is_map Mix.Project.pop
-    assert nil? Mix.Project.pop
+    Mix.Project.push(nil)
+    Mix.Project.push(nil)
+    assert is_map(Mix.Project.pop())
+    assert is_map(Mix.Project.pop())
+    assert is_nil(Mix.Project.pop())
   end
 
   test "retrieves configuration from projects" do
     Mix.Project.push(SampleProject)
-    assert Mix.Project.config[:hello] == "world"
+    assert Mix.Project.config()[:hello] == "world"
   end
 
   test "removes private configuration" do
     Mix.Project.push(SampleProject)
-    assert nil? Mix.Project.config[:app_path]
-  end
-
-  test "retrieves configuration even when a project is not set" do
-    assert Mix.Project.config[:default_task] == "run"
+    assert is_nil(Mix.Project.config()[:deps_app_path])
   end
 
   test "raises an error when trying to retrieve the current project but none is set" do
     assert_raise Mix.NoProjectError, fn ->
-      Mix.Project.get!
+      Mix.Project.get!()
     end
   end
 
   test "builds the project structure" do
-    in_fixture "archive", fn ->
-      config = [app_path: Path.expand("_build/archive")]
+    in_fixture("archive", fn ->
+      config = [deps_app_path: Path.expand("_build/archive")]
       assert Mix.Project.build_structure(config) == :ok
       assert File.dir?("_build/archive/ebin")
-      assert_proj_dir_linked_or_copied("_build/archive/priv", "priv", '../../priv')
-    end
+      assert_proj_dir_linked_or_copied("_build/archive/priv", "priv", ~c"../../priv")
+    end)
+  end
+
+  test "builds the project structure without symlinks" do
+    in_fixture("archive", fn ->
+      config = [deps_app_path: Path.expand("_build/archive")]
+      assert Mix.Project.build_structure(config) == :ok
+      assert File.dir?("_build/archive/ebin")
+      assert {:error, _} = :file.read_link("_build/archive/ebin")
+    end)
   end
 
-  test "builds the project structure with ebin symlink" do
-    in_fixture "archive", fn ->
-      config = [app_path: Path.expand("_build/archive")]
+  test "builds the project structure with symlinks" do
+    in_fixture("archive", fn ->
+      config = [deps_app_path: Path.expand("_build/archive")]
       File.mkdir_p!("include")
 
       assert Mix.Project.build_structure(config, symlink_ebin: true) == :ok
-      assert_proj_dir_linked_or_copied("_build/archive/ebin", "ebin", '../../ebin')
-      assert_proj_dir_linked_or_copied("_build/archive/priv", "priv", '../../priv')
-      assert_proj_dir_linked_or_copied("_build/archive/include", "include", '../../include')
+      assert_proj_dir_linked_or_copied("_build/archive/ebin", "ebin", ~c"../../ebin")
+      assert_proj_dir_linked_or_copied("_build/archive/priv", "priv", ~c"../../priv")
+      assert_proj_dir_linked_or_copied("_build/archive/include", "include", ~c"../../include")
 
       assert Mix.Project.build_structure(config) == :ok
       assert File.dir?("_build/archive/ebin")
-      assert_proj_dir_linked_or_copied("_build/archive/priv", "priv", '../../priv')
-    end
+      assert_proj_dir_linked_or_copied("_build/archive/priv", "priv", ~c"../../priv")
+    end)
   end
 
-  test "config_files" do
-    Mix.Project.push(SampleProject)
+  test "in_project pushes given configuration", context do
+    in_tmp(context.test, fn ->
+      result =
+        Mix.Project.in_project(:foo, ".", [hello: :world], fn _ ->
+          assert Mix.Project.config()[:app] == :foo
+          assert Mix.Project.config()[:hello] == :world
+          :result
+        end)
+
+      assert result == :result
+    end)
+  end
 
-    in_fixture "no_mixfile", fn ->
-      File.mkdir_p!("config")
-      File.write! "config/config.exs", "[]"
-      File.write! "config/dev.exs", "[]"
-      File.write! "config/.exs", "[]"
-
-      files = Mix.Project.config_files
-      assert __ENV__.file in files
-      assert "config/config.exs" in files
-      assert "config/dev.exs" in files
-      refute "config/.exs" in files
-    end
+  test "in_project prints nice error message if fails to load file", context do
+    in_tmp(context.test, fn ->
+      File.write("mix.exs", """
+      raise "oops"
+      """)
+
+      assert_raise RuntimeError, "oops", fn ->
+        Mix.Project.in_project(:hello, ".", [], fn _ ->
+          :ok
+        end)
+      end
+
+      assert_receive {:mix_shell, :error, ["Error while loading project :hello at" <> _]}
+    end)
   end
-  
+
   defp assert_proj_dir_linked_or_copied(source, target, symlink_path) do
     case :file.read_link(source) do
-      {:ok, path} -> assert path == symlink_path
-      {:error, _} -> assert File.ls!(source) == File.ls!(target)
+      {:ok, path} ->
+        case :os.type() do
+          # relative symlink on Windows are broken, see symlink_or_copy/2
+          {:win32, _} ->
+            assert path ==
+                     [source, ~c"..", symlink_path]
+                     |> Path.join()
+                     |> Path.expand()
+                     |> String.to_charlist()
+
+          _ ->
+            assert path == symlink_path
+        end
+
+      {:error, _} ->
+        assert File.ls!(source) == File.ls!(target)
     end
   end
 end
diff --git a/lib/mix/test/mix/rebar_test.exs b/lib/mix/test/mix/rebar_test.exs
index bc509e508e8..0d468cd72ae 100644
--- a/lib/mix/test/mix/rebar_test.exs
+++ b/lib/mix/test/mix/rebar_test.exs
@@ -1,126 +1,291 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Mix.RebarTest do
   use MixTest.Case
 
-  # Have our own path implementation that bypasses some
-  # Path validation checks. We use this just for testing.
-  defmodule MyPath do
-    @behaviour Mix.SCM
+  # rebar_dep and git_rebar are loaded dynamically
+  @compile {:no_warn_undefined, [:rebar_dep, :git_rebar]}
 
-    for {name, arity} <- Mix.SCM.Path.__info__(:functions) do
-      args = tl Enum.map 0..arity, &{:"x#{&1}", [], nil}
-      def unquote(name)(unquote_splicing(args)) do
-        Mix.SCM.Path.unquote(name)(unquote_splicing(args))
-      end
+  defmodule RebarAsDep do
+    def project do
+      [
+        app: :rebar_as_dep,
+        version: "0.1.0",
+        deps: [
+          {:rebar_dep, path: MixTest.Case.tmp_path("rebar_dep"), app: false}
+        ]
+      ]
     end
   end
 
-  setup do
-    available = Mix.SCM.available
-    Application.put_env(:mix, :scm, [Mix.SCM.Git, MyPath])
-    on_exit fn -> Application.put_env(:mix, :scm, available) end
-    :ok
+  defmodule RebarAsDepWithEnv do
+    def project do
+      [
+        app: :rebar_as_dep,
+        version: "0.1.0",
+        deps: [
+          {
+            :rebar_dep,
+            path: MixTest.Case.tmp_path("rebar_dep"),
+            app: false,
+            system_env: [{"FILE_FROM_ENV", "rebar-test-rebar3"}, {"CONTENTS_FROM_ENV", "rebar3"}]
+          }
+        ]
+      ]
+    end
   end
 
-  defmodule RebarAsDep do
+  defmodule RebarOverrideAsDep do
     def project do
-      [ app: :rebar_as_dep,
+      [
+        app: :rebar_as_dep,
         version: "0.1.0",
         deps: [
-          {:rebar_dep, path: MixTest.Case.tmp_path("rebar_dep"), app: false}
+          {
+            :rebar_override,
+            path: MixTest.Case.tmp_path("rebar_override"), app: false
+          }
         ]
       ]
     end
   end
 
-  test "load rebar config" do
-    path = MixTest.Case.tmp_path("rebar_dep")
-    config = Mix.Rebar.load_config(path)
-    assert config[:sub_dirs] == ['apps/*']
-    assert config[:SCRIPT] == 'rebar.config.script'
-  end
+  describe "load_config/1" do
+    test "loads rebar.config" do
+      path = MixTest.Case.fixture_path("rebar_dep")
+      config = Mix.Rebar.load_config(path)
+      assert config[:erl_opts] == [:warnings_as_errors]
+      assert config[:SCRIPT] == ~c"rebar.config.script"
+    end
 
-  test "execute rebar.config.script on dependecy directory" do
-    path = MixTest.Case.fixture_path("rebar_dep_script")
-    config = Mix.Rebar.load_config(path)
-    assert config[:dir] == {:ok, String.to_char_list(path)}
+    test "loads rebar.config.script on dependency directory" do
+      path = MixTest.Case.fixture_path("rebar_dep_script")
+      config = Mix.Rebar.load_config(path)
+      assert config[:dir] == {:ok, String.to_charlist(path)}
+    end
   end
 
-  test "parse rebar dependencies" do
-    config = [deps: [{:git_rebar, '.*',}]]
-    assert [{:git_rebar, ~r".*", [path: "deps/git_rebar"]}] ==
-           Mix.Rebar.deps(config)
+  @git_rebar_charlist ~c"../../test/fixtures/git_rebar"
+  @git_rebar_string "../../test/fixtures/git_rebar"
 
-    config = [deps: [{:git_rebar, '.*',}], deps_dir: "other_dir"]
-    assert [{:git_rebar, ~r".*", [path: "other_dir/git_rebar"]}] ==
-           Mix.Rebar.deps(config)
+  describe "deps/1" do
+    defp parse_dep(dep) do
+      [deps: [dep]] |> Mix.Rebar.deps() |> hd()
+    end
+
+    test "parses Rebar dependencies" do
+      assert parse_dep(:git_rebar) == {:git_rebar, override: true}
+
+      assert parse_dep({:git_rebar, ~c"~> 1.0"}) == {:git_rebar, "~> 1.0", override: true}
+
+      assert parse_dep({:git_rebar, ~c"~> 1.0", {:pkg, :rebar_fork}}) ==
+               {:git_rebar, "~> 1.0", override: true, hex: :rebar_fork}
+
+      assert parse_dep({:git_rebar, {:pkg, :rebar_fork}}) ==
+               {:git_rebar, override: true, hex: :rebar_fork}
+
+      assert parse_dep({:git_rebar, {:git, @git_rebar_charlist, :main}}) ==
+               {:git_rebar, override: true, git: @git_rebar_string, ref: "main"}
+
+      assert {:git_rebar, regex, override: true, git: @git_rebar_string, compile: false} =
+               parse_dep({:git_rebar, ~c"0.1..*", {:git, @git_rebar_charlist}, [:raw]})
+
+      assert Regex.source(regex) == "0.1..*"
+
+      assert {:git_rebar, regex, override: true, git: @git_rebar_string, ref: "main"} =
+               parse_dep({:git_rebar, ~c"0.1..*", {:git, @git_rebar_charlist, :main}})
 
-    config = [deps: [{:git_rebar, '0.1..*', {:git, '../../test/fixtures/git_rebar', :master}}]]
-    assert [{:git_rebar, ~r"0.1..*", [git: "../../test/fixtures/git_rebar", ref: "master"]}] ==
-           Mix.Rebar.deps(config)
+      assert Regex.source(regex) == "0.1..*"
 
-    config = [deps: [{:git_rebar, '0.1..*', {:git, '../../test/fixtures/git_rebar'}, [:raw]}]]
-    assert [{:git_rebar, ~r"0.1..*", [git: "../../test/fixtures/git_rebar", compile: false]}] ==
-           Mix.Rebar.deps(config)
+      assert {:git_rebar, regex, override: true, git: @git_rebar_string, ref: "64691eb"} =
+               parse_dep({:git_rebar, ~c"", {:git, @git_rebar_charlist, {:ref, ~c"64691eb"}}})
+
+      assert Regex.source(regex) == ""
+    end
   end
 
-  test "parse rebar dependencies from rebar.config" do
-    Mix.Project.push(RebarAsDep)
+  describe "apply_overrides/3" do
+    test "applies overrides" do
+      config = [deps: {:git_rebar, ~c"~> 2.0"}]
+      overrides = [{:override, [deps: [{:git_rebar, ~c"~> 1.0"}]]}]
+
+      assert Mix.Rebar.apply_overrides(:foo, config, overrides) ==
+               [deps: [{:git_rebar, ~c"~> 1.0"}], overrides: overrides]
+
+      config = [deps: [{:git_rebar, ~c"~> 2.0"}]]
+      overrides = [{:override, :bar, [deps: [{:git_rebar, ~c"~> 1.0"}]]}]
+
+      assert Mix.Rebar.apply_overrides(:foo, config, overrides) ==
+               [deps: [{:git_rebar, ~c"~> 2.0"}], overrides: overrides]
+
+      config = [deps: [{:git_rebar, ~c"~> 2.0"}]]
+      overrides = [{:override, :foo, [deps: [{:git_rebar, ~c"~> 1.0"}]]}]
+
+      assert Mix.Rebar.apply_overrides(:foo, config, overrides) ==
+               [deps: [{:git_rebar, ~c"~> 1.0"}], overrides: overrides]
+
+      config = [deps: [{:git_rebar, ~c"~> 1.0"}]]
+      overrides = [{:add, :foo, [deps: [{:git_rebar2, ~c"~> 2.0"}]]}]
+
+      assert Mix.Rebar.apply_overrides(:foo, config, overrides) ==
+               [deps: [{:git_rebar2, ~c"~> 2.0"}, {:git_rebar, ~c"~> 1.0"}], overrides: overrides]
+    end
 
-    deps = Mix.Dep.loaded([])
-    assert Enum.find(deps, &match?(%Mix.Dep{app: :rebar_dep}, &1))
+    test "concatenates overrides" do
+      config = [deps: {:git_rebar, ~c"~> 2.0"}, overrides: [{:add, :bar, []}]]
+      overrides = [{:override, [deps: [{:git_rebar, ~c"~> 1.0"}]]}]
 
-    assert Enum.find(deps, fn %Mix.Dep{app: app, opts: opts} ->
-      if app == :git_rebar do
-        assert Enum.find(opts, &match?({:git, "../../test/fixtures/git_rebar"}, &1))
-        assert Enum.find(opts, &match?({:ref, "master"}, &1))
-        true
-      end
-    end)
+      assert Mix.Rebar.apply_overrides(:foo, config, overrides) ==
+               [deps: [{:git_rebar, ~c"~> 1.0"}], overrides: overrides ++ [{:add, :bar, []}]]
+    end
   end
 
-  test "recurs over sub dirs" do
-    path = MixTest.Case.tmp_path("rebar_dep")
+  describe "dependency_config/1" do
+    test "converts Rebar config to dependency config" do
+      config = Mix.Rebar.load_config(fixture_path("rebar_dep"))
+      dep_config = Mix.Rebar.dependency_config(config)
 
-    File.cd! path, fn ->
-     config = Mix.Rebar.load_config(path)
+      assert config[:erl_opts] == [:warnings_as_errors]
+      assert config[:project_plugins] == [:remove_me]
+      assert dep_config[:erl_opts] == []
+      refute dep_config[:project_plugins]
+    end
+  end
 
-      Mix.Rebar.recur(config, fn config ->
-        if config[:sub_dirs] == ['from_apps_another'] do
-          Process.put(:inside_apps_another, true)
-        end
+  describe "integration with Mix" do
+    test "inherits Rebar manager" do
+      Mix.Project.push(RebarAsDep)
+      deps = Mix.Dep.Converger.converge([])
+      assert Enum.all?(deps, &(&1.manager == :rebar3))
+    end
+
+    test "parses Rebar dependencies from rebar.config" do
+      Mix.Project.push(RebarAsDep)
+
+      deps = Mix.Dep.Converger.converge([])
+      assert Enum.all?(deps, &(&1.manager == :rebar3))
+      assert Enum.find(deps, &(&1.app == :rebar_dep))
+
+      assert Enum.find(deps, fn %Mix.Dep{app: app, opts: opts} ->
+               if app == :git_rebar do
+                 assert Enum.find(opts, &match?({:git, _}, &1))
+                 assert Enum.find(opts, &match?({:ref, "main"}, &1))
+                 true
+               end
+             end)
+    end
+
+    test "handles Rebar overrides" do
+      in_tmp("Rebar overrides", fn ->
+        Mix.Project.push(RebarOverrideAsDep)
+
+        Mix.Tasks.Deps.Get.run([])
+
+        assert Mix.Dep.Converger.converge([]) |> Enum.map(& &1.app) ==
+                 [:git_repo, :git_rebar, :rebar_override]
       end)
+    after
+      purge([GitRepo.MixProject])
     end
 
-    unless Process.get(:inside_apps_another) do
-      flunk "Expected inside_apps_another to return true"
+    # We run only on Unix because Windows has a hard time
+    # removing the Rebar executable after executed.
+    @tag :unix
+    test "gets and compiles dependencies" do
+      in_tmp("get and compile dependencies", fn ->
+        Mix.Project.push(RebarAsDep)
+
+        Mix.Tasks.Deps.Get.run([])
+        assert_received {:mix_shell, :info, ["* Getting git_rebar " <> _]}
+
+        Mix.Tasks.Deps.Compile.run([])
+        assert_received {:mix_shell, :run, ["===> Compiling git_rebar\n"]}
+        assert_received {:mix_shell, :run, ["===> Compiling rebar_dep\n"]}
+        assert :git_rebar.any_function() == :ok
+        assert :rebar_dep.any_function() == :ok
+
+        load_paths =
+          Mix.Dep.Converger.converge([])
+          |> Enum.map(&Mix.Dep.load_paths(&1))
+          |> Enum.concat()
+
+        assert File.exists?("_build/dev/lib/rebar_dep/ebin/rebar_dep.beam")
+        assert File.exists?("_build/dev/lib/git_rebar/ebin/git_rebar.beam")
+
+        # Assert we have no .mix/compile.lock as a .mix/compile.lock
+        # means we check for the Elixir version on every command.
+        refute File.exists?("_build/dev/lib/rebar_dep/.mix/compile.lock")
+        refute File.exists?("_build/dev/lib/git_rebar/.mix/compile.lock")
+
+        assert Enum.any?(load_paths, &String.ends_with?(&1, "git_rebar/ebin"))
+        assert Enum.any?(load_paths, &String.ends_with?(&1, "rebar_dep/ebin"))
+      end)
     end
-  end
 
-  test "get and compile dependencies for rebar" do
-    # Use rebar from project root
-    System.put_env("MIX_HOME", MixTest.Case.elixir_root)
-    Mix.Project.push(RebarAsDep)
-
-    in_tmp "get and compile dependencies for rebar", fn ->
-      Mix.Tasks.Deps.Get.run ["--no-compile"]
-      assert_received {:mix_shell, :info, ["* Getting git_rebar (../../test/fixtures/git_rebar)"]}
-
-      Mix.Tasks.Deps.Compile.run []
-      assert_received {:mix_shell, :run, ["==> git_rebar (compile)\n"]}
-      assert_received {:mix_shell, :run, ["==> rebar_dep (compile)\n"]}
-      assert :git_rebar.any_function == :ok
-      assert :rebar_dep.any_function == :ok
-
-      load_paths = Mix.Dep.loaded([])
-        |> Enum.map(&Mix.Dep.load_paths(&1))
-        |> Enum.concat
-
-      assert File.exists?("_build/dev/lib/rebar_dep/ebin/rebar_dep.beam")
-      assert File.exists?("_build/dev/lib/git_rebar/ebin/git_rebar.beam")
-      assert Enum.any?(load_paths, &String.ends_with?(&1, "git_rebar/ebin"))
-      assert Enum.any?(load_paths, &String.ends_with?(&1, "rebar_dep/ebin"))
+    # We run only on Unix because Windows has a hard time
+    # removing the Rebar executable after executed.
+    @tag :unix
+    test "applies variables from :system_env option on config/compilation" do
+      in_tmp("applies variables from system_env", fn ->
+        Mix.Project.push(RebarAsDepWithEnv)
+
+        expected_file = Path.join(tmp_path("rebar_dep"), "rebar-test-rebar3")
+        File.rm(expected_file)
+
+        Mix.Tasks.Deps.Get.run([])
+        Mix.Tasks.Deps.Compile.run([])
+
+        assert {:ok, "rebar3"} = File.read(expected_file)
+      end)
+    end
+
+    # We run only on Unix because Windows has a hard time
+    # removing the Rebar executable after executed.
+    @tag :unix
+    test "gets and compiles dependencies with MIX_REBAR3 with spaces" do
+      in_tmp("rebar3 env with spaces", fn ->
+        File.cp!(Mix.Rebar.local_rebar_path(:rebar3), "rebar3")
+        System.put_env("MIX_REBAR3", Path.absname("rebar3"))
+        assert Mix.Rebar.rebar_args(:rebar3, []) |> elem(0) =~ " "
+
+        Mix.Project.push(RebarAsDep)
+        Mix.Tasks.Deps.Get.run([])
+        assert_received {:mix_shell, :info, ["* Getting git_rebar " <> _]}
+
+        Mix.Tasks.Deps.Compile.run([])
+        assert_received {:mix_shell, :run, ["===> Compiling git_rebar\n"]}
+        assert_received {:mix_shell, :run, ["===> Compiling rebar_dep\n"]}
+      end)
+    after
+      System.delete_env("MIX_REBAR3")
+    end
+
+    test "gets and compiles dependencies with Mix" do
+      in_tmp("get and compile dependencies with Mix", fn ->
+        Mix.Project.push(RebarAsDep)
+
+        File.write!(MixTest.Case.tmp_path("rebar_dep/mix.exs"), """
+        defmodule RebarDep.MixProject do
+          use Mix.Project
+
+          def project do
+            [app: :rebar_dep,
+             version: "0.0.1"]
+          end
+        end
+        """)
+
+        Mix.Tasks.Deps.Compile.run([])
+        assert_received {:mix_shell, :info, ["==> rebar_dep"]}
+        assert_received {:mix_shell, :info, ["Generated rebar_dep app"]}
+        assert File.regular?("_build/dev/lib/rebar_dep/ebin/rebar_dep.app")
+      end)
+    after
+      File.rm(MixTest.Case.tmp_path("rebar_dep/mix.exs"))
     end
   end
 end
diff --git a/lib/mix/test/mix/release_test.exs b/lib/mix/test/mix/release_test.exs
new file mode 100644
index 00000000000..39835dc351d
--- /dev/null
+++ b/lib/mix/test/mix/release_test.exs
@@ -0,0 +1,941 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
+
+defmodule Mix.ReleaseTest do
+  use MixTest.Case
+
+  import Mix.Release
+  doctest Mix.Release
+
+  Application.ensure_loaded(:eex)
+  Application.ensure_loaded(:runtime_tools)
+
+  @erts_version :erlang.system_info(:version)
+  @erts_source Path.join(:code.root_dir(), "erts-#{@erts_version}")
+  @elixir_version Application.spec(:elixir, :vsn)
+  @kernel_version Application.spec(:kernel, :vsn)
+  @runtime_tools_version Application.spec(:runtime_tools, :vsn)
+  @eex_ebin Application.app_dir(:eex, "ebin")
+
+  setup_all do
+    Mix.ensure_application!(:sasl)
+    Mix.ensure_application!(:crypto)
+    :ok
+  end
+
+  setup do
+    File.rm_rf!(tmp_path("mix_release"))
+    File.mkdir_p!(tmp_path("mix_release"))
+    :ok
+  end
+
+  describe "from_config!/3" do
+    test "uses default configuration if no release is specified" do
+      assert %Mix.Release{
+               name: :mix,
+               version: "0.1.0",
+               path: path,
+               version_path: version_path
+             } = from_config!(nil, config(), [])
+
+      assert String.ends_with?(path, "mix_release/_build/dev/rel/mix")
+      assert String.ends_with?(version_path, "mix_release/_build/dev/rel/mix/releases/0.1.0")
+    end
+
+    test "provides default options" do
+      release = from_config!(nil, config(), [])
+      assert release.options == [overwrite: false, quiet: false, strip_beams: true]
+    end
+
+    test "allows overrides" do
+      overrides = [path: "demo", version: "0.2.0", overwrite: true, quiet: true]
+      release = from_config!(nil, config(), overrides)
+
+      assert release.path == Path.absname("demo")
+      assert release.version == "0.2.0"
+      assert release.options[:overwrite]
+      assert release.options[:quiet]
+    end
+
+    test "allows specifying the version from an application" do
+      overrides = [version: {:from_app, :elixir}]
+      release = from_config!(nil, config(), overrides)
+
+      assert release.version == to_string(Application.spec(:elixir, :vsn))
+    end
+
+    test "raises when :from_app is used with an app that doesn't exist" do
+      overrides = [version: {:from_app, :not_valid}]
+
+      assert_raise Mix.Error,
+                   ~r"Could not find version for :not_valid, please make sure the application exists",
+                   fn -> from_config!(nil, config(), overrides) end
+    end
+
+    test "includes applications" do
+      release = from_config!(nil, config(), [])
+      assert release.applications.mix[:path] == to_charlist(Application.app_dir(:mix))
+      refute release.applications.mix[:otp_app?]
+
+      assert release.applications.kernel[:path] == to_charlist(Application.app_dir(:kernel))
+      assert release.applications.kernel[:otp_app?]
+    end
+
+    test "does not include erts in applications" do
+      release = from_config!(nil, config(releases: [foo: [applications: [erts: :permanent]]]), [])
+      assert release.applications[:erts] == nil
+    end
+
+    test "allows release to be given as an anonymous function" do
+      release = from_config!(:foo, config(releases: [foo: fn -> [version: "0.2.0"] end]), [])
+      assert release.name == :foo
+      assert release.version == "0.2.0"
+    end
+
+    test "uses chosen release via the CLI" do
+      release =
+        from_config!(
+          :bar,
+          config(releases: [foo: [version: "0.2.0"], bar: [version: "0.3.0"]]),
+          []
+        )
+
+      assert release.name == :bar
+      assert release.version == "0.3.0"
+      assert String.ends_with?(release.path, "mix_release/_build/dev/rel/bar")
+
+      assert String.ends_with?(
+               release.version_path,
+               "mix_release/_build/dev/rel/bar/releases/0.3.0"
+             )
+    end
+
+    test "uses chosen release via the default_release" do
+      release =
+        from_config!(
+          nil,
+          config(
+            default_release: :bar,
+            releases: [foo: [version: "0.2.0"], bar: [version: "0.3.0"]]
+          ),
+          []
+        )
+
+      assert release.name == :bar
+      assert release.version == "0.3.0"
+      assert String.ends_with?(release.path, "mix_release/_build/dev/rel/bar")
+
+      assert String.ends_with?(
+               release.version_path,
+               "mix_release/_build/dev/rel/bar/releases/0.3.0"
+             )
+    end
+
+    test "raises for multiple releases and no name" do
+      assert_raise Mix.Error,
+                   ~r"\"mix release\" was invoked without a name but there are multiple releases",
+                   fn -> from_config!(nil, config(releases: [foo: [], bar: []]), []) end
+    end
+
+    test "raises for unknown release" do
+      assert_raise Mix.Error, "Unknown release :foo. The available releases are: []", fn ->
+        from_config!(:foo, config(), [])
+      end
+    end
+
+    test "uses the locked version of an app", context do
+      in_tmp(context.test, fn ->
+        # install newer version of the app in the custom ERTS
+        custom_erts_path = Path.join([File.cwd!(), "erts-#{@erts_version}"])
+        File.cp_r!(@erts_source, custom_erts_path)
+
+        ebin_dir = Path.expand(Path.join([custom_erts_path, "..", "lib", "cowboy-2.0.0", "ebin"]))
+        File.mkdir_p!(ebin_dir)
+        app_resource = "{application,cowboy,[{vsn,\"2.0.0\"},{modules,[]},{applications,[]}]}."
+        File.write!(Path.join(ebin_dir, "cowboy.app"), app_resource)
+
+        # install older version of the app in the project dependencies
+        project_path = Path.join(File.cwd!(), "project")
+        build_path = Path.join(project_path, "_build")
+        ebin_dir = Path.join([build_path, "dev", "lib", "cowboy", "ebin"])
+        File.mkdir_p!(ebin_dir)
+        app_resource = "{application,cowboy,[{vsn,\"1.1.2\"},{modules,[]},{applications,[]}]}."
+        File.write!(Path.join(ebin_dir, "cowboy.app"), app_resource)
+
+        File.mkdir_p!(Path.join([project_path, "deps", "cowboy"]))
+        lockfile = Path.join(project_path, "mix.lock")
+
+        File.write!(lockfile, ~S"""
+        %{
+          "cowboy": {:hex, :cowboy, "1.1.2"},
+        }
+        """)
+
+        app_config =
+          config(
+            deps: [{:cowboy, "~> 1.0", path: "deps/cowboy"}],
+            releases: [demo: [include_erts: custom_erts_path, applications: [cowboy: :permanent]]]
+          )
+
+        Mix.Project.in_project(:mix, project_path, app_config, fn _ ->
+          Code.prepend_path(ebin_dir)
+          release = from_config!(nil, app_config, [])
+          assert release.applications.cowboy[:vsn] == ~c"1.1.2"
+        end)
+      end)
+    end
+
+    test "uses the latest version of an app if it is not locked", context do
+      in_tmp(context.test, fn ->
+        test_erts_dir = Path.join(File.cwd!(), "erts-#{@erts_version}")
+        test_libs_dir = Path.join(File.cwd!(), "lib")
+        libs_dir = Path.join(:code.root_dir(), "lib")
+        libs = File.ls!(libs_dir)
+
+        File.cp_r!(@erts_source, test_erts_dir)
+
+        for lib <- libs,
+            source_file <- Path.wildcard(Path.join([libs_dir, lib, "ebin", "*.app"])) do
+          target_dir = Path.join([test_libs_dir, lib, "ebin"])
+          target_file = Path.join(target_dir, Path.basename(source_file))
+
+          File.mkdir_p!(target_dir)
+          File.cp!(source_file, target_file)
+        end
+
+        File.mkdir_p!(Path.join("lib", "compiler-1.0"))
+
+        release = from_config!(nil, config(releases: [demo: [include_erts: test_erts_dir]]), [])
+
+        assert Path.dirname(release.applications.compiler[:path]) == test_libs_dir
+        assert release.applications.compiler[:vsn] != "1.0"
+      end)
+    end
+
+    test "raises on unknown app" do
+      assert_raise Mix.Error, "Could not find application :unknown", fn ->
+        from_config!(nil, config(releases: [demo: [applications: [unknown: :none]]]), [])
+      end
+    end
+
+    test "raises for missing version" do
+      assert_raise Mix.Error, ~r"No :version found", fn ->
+        from_config!(nil, config() |> Keyword.drop([:version]), [])
+      end
+    end
+
+    test "raises for blank version" do
+      assert_raise Mix.Error, ~r"The release :version cannot be an empty string", fn ->
+        from_config!(nil, config(version: ""), [])
+      end
+    end
+
+    test "raises on invalid release names" do
+      assert_raise Mix.Error, ~r"Invalid release name", fn ->
+        from_config!(nil, config(releases: ["invalid name": []]), [])
+      end
+    end
+
+    test "raises on bad steps" do
+      assert_raise Mix.Error,
+                   ~r"The :steps option must be",
+                   fn -> release(steps: :foo) end
+
+      assert_raise Mix.Error,
+                   ~r"The :steps option must contain the atom :assemble once, got: \[\]",
+                   fn -> release(steps: []) end
+
+      assert_raise Mix.Error,
+                   ~r"The :steps option must contain the atom :assemble once",
+                   fn -> release(steps: [:assemble, :assemble]) end
+
+      assert_raise Mix.Error,
+                   ~r"The :tar step must come after :assemble",
+                   fn -> release(steps: [:tar, :assemble]) end
+
+      assert_raise Mix.Error,
+                   ~r"The :steps option can only contain the atom :tar once",
+                   fn -> release(steps: [:assemble, :tar, :tar]) end
+
+      assert_raise Mix.Error,
+                   ~r"The :steps option must be",
+                   fn -> release(steps: [:foo]) end
+    end
+  end
+
+  describe "from_config!/3 + umbrella" do
+    test "cannot infer for umbrella projects" do
+      assert_raise Mix.Error,
+                   ~r"Umbrella projects require releases to be explicitly defined",
+                   fn -> from_config!(nil, config(apps_path: "apps"), []) end
+    end
+
+    test "requires apps for umbrella projects" do
+      assert_raise Mix.Error,
+                   ~r"Umbrella projects require releases to be explicitly defined",
+                   fn -> from_config!(nil, config(apps_path: "apps", releases: [foo: []]), []) end
+    end
+
+    test "builds explicit releases with applications" do
+      config = config(apps_path: "apps", releases: [foo: [applications: [mix: :permanent]]])
+
+      assert %Mix.Release{
+               name: :foo,
+               version: "0.1.0",
+               path: _path,
+               version_path: _version_path
+             } = from_config!(nil, config, [])
+    end
+  end
+
+  describe "from_config!/3 + boot_scripts" do
+    test "generates a start boot script with current application" do
+      release = release([])
+
+      assert release.boot_scripts.start == [
+               kernel: :permanent,
+               stdlib: :permanent,
+               elixir: :permanent,
+               sasl: :permanent,
+               mix: :permanent,
+               iex: :none,
+               compiler: :permanent
+             ]
+    end
+
+    test "includes extra application in order" do
+      # Current app is always last
+      release = release(applications: [eex: :permanent])
+
+      assert release.boot_scripts.start == [
+               kernel: :permanent,
+               stdlib: :permanent,
+               elixir: :permanent,
+               sasl: :permanent,
+               eex: :permanent,
+               mix: :permanent,
+               iex: :none,
+               compiler: :permanent
+             ]
+
+      # Unless explicitly given
+      release = release(applications: [mix: :permanent, eex: :permanent])
+
+      assert release.boot_scripts.start == [
+               kernel: :permanent,
+               stdlib: :permanent,
+               elixir: :permanent,
+               sasl: :permanent,
+               mix: :permanent,
+               eex: :permanent,
+               iex: :none,
+               compiler: :permanent
+             ]
+    end
+
+    test "configures other applications" do
+      release = release(applications: [mix: :temporary])
+      assert release.boot_scripts.start[:mix] == :temporary
+
+      release = release(applications: [iex: :temporary])
+      assert release.boot_scripts.start[:iex] == :temporary
+    end
+
+    test "configures other applications in cascade", context do
+      in_tmp(context.test, fn ->
+        write_app!(
+          "my_sample_mode/ebin/my_sample_mode.app",
+          {:application, :my_sample_mode,
+           applications: [:kernel, :stdlib, :elixir, :runtime_tools, :compiler],
+           description: ~c"my_sample_mode",
+           modules: [],
+           vsn: ~c"1.0.0"}
+        )
+
+        apps = [my_sample_mode: :temporary]
+        release = release(applications: apps)
+        assert release.boot_scripts.start[:my_sample_mode] == :temporary
+        assert release.boot_scripts.start[:runtime_tools] == :temporary
+        assert release.boot_scripts.start[:compiler] == :permanent
+
+        apps = [my_sample_mode: :temporary, elixir: :permanent]
+        release = release(applications: apps)
+        assert release.boot_scripts.start[:my_sample_mode] == :temporary
+        assert release.boot_scripts.start[:runtime_tools] == :temporary
+        assert release.boot_scripts.start[:compiler] == :permanent
+
+        apps = [my_sample_mode: :temporary, runtime_tools: :none, compiler: :none]
+        release = release(applications: apps)
+        assert release.boot_scripts.start[:my_sample_mode] == :temporary
+        assert release.boot_scripts.start[:runtime_tools] == :none
+        assert release.boot_scripts.start[:compiler] == :none
+
+        apps = [my_sample_mode: :temporary, elixir: :permanent, compiler: :none]
+        release = release(applications: apps)
+        assert release.boot_scripts.start[:my_sample_mode] == :temporary
+        assert release.boot_scripts.start[:runtime_tools] == :temporary
+        assert release.boot_scripts.start[:compiler] == :none
+      end)
+    end
+
+    test "generates a start_clean script with only kernel and stdlib starting up" do
+      release = release([])
+
+      assert release.boot_scripts.start_clean == [
+               kernel: :permanent,
+               stdlib: :permanent,
+               elixir: :load,
+               sasl: :load,
+               mix: :load,
+               iex: :none,
+               compiler: :load
+             ]
+    end
+  end
+
+  describe "from_config!/3 + include_erts" do
+    test "when true (default)" do
+      release = release([])
+      assert release.erts_version == @erts_version
+      assert release.erts_source == to_charlist(@erts_source)
+    end
+
+    test "when false" do
+      release = release(include_erts: false)
+      assert release.erts_version == @erts_version
+      assert release.erts_source == nil
+    end
+
+    test "when anonymous function" do
+      release = release(include_erts: fn -> true end)
+      assert release.erts_version == @erts_version
+      assert release.erts_source == to_charlist(@erts_source)
+
+      release = release(include_erts: fn -> false end)
+      assert release.erts_version == @erts_version
+      assert release.erts_source == nil
+    end
+
+    test "with valid path" do
+      release = release(include_erts: @erts_source)
+      assert release.erts_version == @erts_version
+      assert release.erts_source == to_charlist(@erts_source)
+    end
+
+    test "with invalid path" do
+      assert_raise Mix.Error, "Could not find ERTS system at \"bad\"", fn ->
+        release(include_erts: "bad")
+      end
+    end
+  end
+
+  describe "make_boot_script/4" do
+    @boot_script_path tmp_path("mix_release/start")
+
+    test "writes .rel, .boot, and .script files" do
+      release = release([])
+      assert make_boot_script(release, @boot_script_path, release.boot_scripts.start) == :ok
+
+      assert {:ok,
+              [
+                {:release, {~c"demo", ~c"0.1.0"}, {:erts, @erts_version},
+                 [
+                   {:kernel, _, :permanent},
+                   {:stdlib, _, :permanent},
+                   {:elixir, @elixir_version, :permanent},
+                   {:sasl, _, :permanent},
+                   {:mix, @elixir_version, :permanent},
+                   {:iex, @elixir_version, :none},
+                   {:compiler, _, :permanent}
+                 ]}
+              ]} = :file.consult(@boot_script_path <> ".rel")
+
+      assert {:ok, [{:script, {~c"demo", ~c"0.1.0"}, instructions}]} =
+               :file.consult(@boot_script_path <> ".script")
+
+      assert {:path, [~c"$ROOT/lib/kernel-#{@kernel_version}/ebin"]} in instructions
+      assert {:path, [~c"$RELEASE_LIB/elixir-#{@elixir_version}/ebin"]} in instructions
+
+      assert File.read!(@boot_script_path <> ".boot") |> :erlang.binary_to_term() ==
+               {:script, {~c"demo", ~c"0.1.0"}, instructions}
+    end
+
+    test "prepends relevant paths" do
+      release = release([])
+
+      assert make_boot_script(
+               release,
+               @boot_script_path,
+               release.boot_scripts.start,
+               ["$RELEASE_LIB/sample"]
+             ) == :ok
+
+      assert {:ok, [{:script, {~c"demo", ~c"0.1.0"}, instructions}]} =
+               :file.consult(@boot_script_path <> ".script")
+
+      assert {:path, [~c"$ROOT/lib/kernel-#{@kernel_version}/ebin"]} in instructions
+      refute {:path, [~c"$RELEASE_LIB/elixir-#{@elixir_version}/ebin"]} in instructions
+
+      assert {:path, [~c"$RELEASE_LIB/sample", ~c"$RELEASE_LIB/elixir-#{@elixir_version}/ebin"]} in instructions
+
+      assert File.read!(@boot_script_path <> ".boot") |> :erlang.binary_to_term() ==
+               {:script, {~c"demo", ~c"0.1.0"}, instructions}
+    end
+
+    test "works when :load/:none is set at the leaf" do
+      release = release(applications: [mix: :none])
+      assert make_boot_script(release, @boot_script_path, release.boot_scripts.start) == :ok
+      {:ok, [{:release, _, _, rel_apps}]} = :file.consult(@boot_script_path <> ".rel")
+      assert List.keyfind(rel_apps, :mix, 0) == {:mix, @elixir_version, :none}
+    end
+
+    test "works when :load/:none is set at the subtree" do
+      release = release(applications: [mix: :load, elixir: :load, iex: :load])
+      assert make_boot_script(release, @boot_script_path, release.boot_scripts.start) == :ok
+      {:ok, [{:release, _, _, rel_apps}]} = :file.consult(@boot_script_path <> ".rel")
+      assert {:elixir, _, :load} = List.keyfind(rel_apps, :elixir, 0)
+      assert {:iex, _, :load} = List.keyfind(rel_apps, :iex, 0)
+      assert {:mix, _, :load} = List.keyfind(rel_apps, :mix, 0)
+    end
+
+    test "raises on unknown app" do
+      {:error, message} = make_boot_script(release([]), @boot_script_path, unknown: :permanent)
+      assert message =~ "Unknown application :unknown"
+    end
+
+    test "raises on missing dependency" do
+      {:error, message} = make_boot_script(release([]), @boot_script_path, elixir: :permanent)
+
+      assert message =~
+               "Application :elixir is listed in the release boot, but it depends on :kernel, which isn't"
+    end
+
+    test "raises on unknown mode" do
+      {:error, message} = make_boot_script(release([]), @boot_script_path, mix: :what)
+      assert message =~ "Unknown mode :what for :mix"
+    end
+
+    test "raises on bad load/none" do
+      release = release(applications: [kernel: :load])
+      {:error, message} = make_boot_script(release, @boot_script_path, release.boot_scripts.start)
+
+      assert message =~
+               "Application :stdlib has mode :permanent but it depends on :kernel which is set to :load"
+
+      release = release(applications: [elixir: :none])
+      {:error, message} = make_boot_script(release, @boot_script_path, release.boot_scripts.start)
+
+      assert message =~
+               "Application :mix has mode :permanent but it depends on :elixir which is set to :none"
+    end
+
+    test "does not raise on child unsafe mode if parent is in `skip_mode_validation_for`" do
+      # `:mix` is a parent that depends on `:elixir`
+      release = release(applications: [elixir: :load], skip_mode_validation_for: [:mix])
+      assert make_boot_script(release, @boot_script_path, release.boot_scripts.start) == :ok
+      assert make_boot_script(release, @boot_script_path, release.boot_scripts.start_clean) == :ok
+    end
+  end
+
+  describe "make_cookie/1" do
+    @cookie_path tmp_path("mix_release/cookie")
+
+    test "creates a random cookie if no cookie" do
+      assert make_cookie(release([]), @cookie_path) == :ok
+      assert byte_size(File.read!(@cookie_path)) == 56
+    end
+
+    test "uses the given cookie" do
+      release = release(cookie: "abcdefghijk")
+      assert make_cookie(release, @cookie_path) == :ok
+      assert File.read!(@cookie_path) == "abcdefghijk"
+      assert make_cookie(release, @cookie_path) == :ok
+    end
+
+    test "asks to change if the cookie changes" do
+      assert make_cookie(release(cookie: "abcdefghijk"), @cookie_path) == :ok
+
+      send(self(), {:mix_shell_input, :yes?, false})
+      assert make_cookie(release(cookie: "lmnopqrstuv"), @cookie_path) == :ok
+      assert File.read!(@cookie_path) == "abcdefghijk"
+
+      send(self(), {:mix_shell_input, :yes?, true})
+      assert make_cookie(release(cookie: "lmnopqrstuv"), @cookie_path) == :ok
+      assert File.read!(@cookie_path) == "lmnopqrstuv"
+    end
+
+    test "does not ask to change if set to overwrite" do
+      assert make_cookie(release([]), @cookie_path) == :ok
+      send(self(), {:mix_shell_input, :yes?, false})
+      assert make_cookie(release([cookie: "lmnopqrstuv"], overwrite: true), @cookie_path) == :ok
+      assert File.read!(@cookie_path) == "lmnopqrstuv"
+    end
+  end
+
+  describe "make_start_erl/1" do
+    @start_erl_path tmp_path("mix_release/start_erl.data")
+
+    test "writes ERTS and release versions" do
+      assert make_start_erl(release([]), @start_erl_path) == :ok
+      assert File.read!(@start_erl_path) == "#{@erts_version} 0.1.0"
+    end
+  end
+
+  describe "make_sys_config/1" do
+    @sys_config tmp_path("mix_release/_build/dev/rel/demo/releases/0.1.0/sys.config")
+    @providers [{Config.Reader, "/foo/bar/baz"}]
+
+    test "writes the given sys_config" do
+      assert make_sys_config(release([]), [foo: [bar: :baz]], "unused/runtime/path") == :ok
+      contents = File.read!(@sys_config)
+      assert contents =~ "%% RUNTIME_CONFIG=false"
+      {:ok, contents} = :file.consult(@sys_config)
+      assert contents == [[foo: [bar: :baz]]]
+    end
+
+    test "writes sys_config with encoding" do
+      assert make_sys_config(
+               release([]),
+               [encoding: [key: {:_μ, :"£", "£", ~c"£"}]],
+               "unused/runtime/path"
+             ) ==
+               :ok
+
+      {:ok, contents} = :file.consult(@sys_config)
+      assert contents == [[encoding: [key: {:_μ, :"£", "£", ~c"£"}]]]
+    end
+
+    test "writes the given sys_config with config providers" do
+      release = release(config_providers: @providers, reboot_system_after_config: true)
+      assert make_sys_config(release, [kernel: [key: :value]], "/foo/bar/bat") == :ok
+      assert File.read!(@sys_config) =~ "%% RUNTIME_CONFIG=true"
+      {:ok, [config]} = :file.consult(@sys_config)
+      assert %Config.Provider{} = provider = config[:elixir][:config_provider_init]
+      refute provider.prune_runtime_sys_config_after_boot
+      assert provider.extra_config == [kernel: [start_distribution: true]]
+      assert config[:kernel] == [key: :value, start_distribution: false]
+    end
+
+    test "writes the given sys_config without distribution and with pruning" do
+      release =
+        release(
+          config_providers: @providers,
+          reboot_system_after_config: true,
+          start_distribution_during_config: true,
+          prune_runtime_sys_config_after_boot: true
+        )
+
+      assert make_sys_config(release, [kernel: [key: :value]], "/foo/bar/bat") == :ok
+      assert File.read!(@sys_config) =~ "%% RUNTIME_CONFIG=true"
+      {:ok, [config]} = :file.consult(@sys_config)
+      assert %Config.Provider{} = provider = config[:elixir][:config_provider_init]
+      assert provider.reboot_system_after_config
+      assert provider.prune_runtime_sys_config_after_boot
+      assert provider.extra_config == []
+      assert config[:kernel] == [key: :value]
+    end
+
+    test "writes the given sys_config without reboot" do
+      release = release(config_providers: @providers, reboot_system_after_config: false)
+      assert make_sys_config(release, [kernel: [key: :value]], "/foo/bar/bat") == :ok
+      assert File.read!(@sys_config) =~ "%% RUNTIME_CONFIG=false"
+      {:ok, [config]} = :file.consult(@sys_config)
+      assert %Config.Provider{} = provider = config[:elixir][:config_provider_init]
+      refute provider.reboot_system_after_config
+      assert provider.extra_config == []
+      assert config[:kernel] == [key: :value]
+    end
+
+    test "errors on bad config" do
+      assert {:error, "Could not write configuration file " <> _} =
+               make_sys_config(release([]), [foo: [bar: self()]], "unused/runtime/path")
+
+      env = %{__ENV__ | lexical_tracker: self()}
+
+      assert {:error, "Could not write configuration file " <> _} =
+               make_sys_config(release([]), [foo: [bar: env]], "unused/runtime/path")
+    end
+  end
+
+  describe "copy_erts/1" do
+    test "copies to directory" do
+      assert copy_erts(release(include_erts: true))
+      destination = tmp_path("mix_release/_build/dev/rel/demo/erts-#{@erts_version}")
+      assert File.exists?(destination)
+
+      assert File.read!(Path.join(destination, "bin/erl")) =~
+               ~s|ROOTDIR="${ERL_ROOTDIR:-"$(dirname "$(dirname "$BINDIR")")"}|
+
+      if not match?({:win32, _}, :os.type()) do
+        assert File.lstat!(Path.join(destination, "bin/erl")).mode |> rem(0o1000) == 0o755
+      end
+
+      refute File.exists?(Path.join(destination, "bin/erl.ini"))
+      refute File.exists?(Path.join(destination, "doc"))
+
+      # Now we copy from the copy using a string and without src
+      new_destination = tmp_path("mix_release/_build/dev/rel/new_demo/erts-#{@erts_version}")
+      File.rm_rf!(Path.join(destination, "src"))
+
+      release = from_config!(nil, config(releases: [new_demo: [include_erts: destination]]), [])
+      assert copy_erts(release)
+      assert File.exists?(new_destination)
+    end
+
+    test "does not copy when include_erts is false" do
+      refute copy_erts(release(include_erts: false))
+      destination = tmp_path("mix_release/_build/dev/rel/demo/erts-#{@erts_version}")
+      refute File.exists?(destination)
+    end
+  end
+
+  describe "copy_ebin/3" do
+    test "copies and strips beams" do
+      assert copy_ebin(release([]), @eex_ebin, tmp_path("eex_ebin"))
+
+      assert size!(Path.join(@eex_ebin, "Elixir.EEx.beam")) >
+               size!(tmp_path("eex_ebin/Elixir.EEx.beam"))
+    end
+
+    test "copies without stripping beams" do
+      assert copy_ebin(release(strip_beams: false), @eex_ebin, tmp_path("eex_ebin"))
+
+      assert size!(Path.join(@eex_ebin, "Elixir.EEx.beam")) ==
+               size!(tmp_path("eex_ebin/Elixir.EEx.beam"))
+    end
+
+    test "returns false for unknown or empty directories" do
+      source = tmp_path("mix_release")
+      refute copy_ebin(release([]), source, tmp_path("mix_release"))
+      File.mkdir_p!(source)
+      refute copy_ebin(release([]), source, tmp_path("mix_release"))
+    end
+
+    test "preserves file mode" do
+      source = tmp_path("source_ebin")
+      source_so_path = Path.join(source, "libtest_nif.so")
+
+      File.mkdir_p!(source)
+      File.touch!(source_so_path)
+      File.chmod!(source_so_path, 0o755)
+
+      assert copy_ebin(release([]), source, tmp_path("mix_release"))
+
+      assert mode!(source_so_path) == mode!(tmp_path("mix_release/libtest_nif.so"))
+    end
+  end
+
+  describe "copy_app/2" do
+    @release_lib tmp_path("mix_release/_build/dev/rel/demo/lib")
+
+    test "copies and strips beams" do
+      assert copy_app(release(applications: [eex: :permanent]), :eex)
+
+      assert size!(Path.join(@eex_ebin, "Elixir.EEx.beam")) >
+               size!(Path.join(@release_lib, "eex-#{@elixir_version}/ebin/Elixir.EEx.beam"))
+    end
+
+    test "copies without stripping beams" do
+      assert copy_app(release(strip_beams: false, applications: [eex: :permanent]), :eex)
+
+      assert size!(Path.join(@eex_ebin, "Elixir.EEx.beam")) ==
+               size!(Path.join(@release_lib, "eex-#{@elixir_version}/ebin/Elixir.EEx.beam"))
+    end
+
+    test "copies OTP apps" do
+      release = release(applications: [runtime_tools: :permanent])
+      assert copy_app(release, :runtime_tools)
+      assert File.exists?(Path.join(@release_lib, "runtime_tools-#{@runtime_tools_version}/ebin"))
+      assert File.exists?(Path.join(@release_lib, "runtime_tools-#{@runtime_tools_version}/priv"))
+    end
+
+    test "does not copy OTP app if include_erts is false" do
+      release = release(include_erts: false, applications: [runtime_tools: :permanent])
+      refute copy_app(release, :runtime_tools)
+      refute File.exists?(Path.join(@release_lib, "runtime_tools-#{@runtime_tools_version}/ebin"))
+      refute File.exists?(Path.join(@release_lib, "runtime_tools-#{@runtime_tools_version}/priv"))
+    end
+  end
+
+  describe "strip_beam/1" do
+    test "excludes at least docs and dbgi chunks" do
+      {:ok, beam} =
+        Path.join(@eex_ebin, "Elixir.EEx.beam")
+        |> File.read!()
+        |> strip_beam()
+
+      assert {:error, :beam_lib, {:missing_chunk, _, ~c"Dbgi"}} =
+               :beam_lib.chunks(beam, [~c"Dbgi"])
+
+      assert {:error, :beam_lib, {:missing_chunk, _, ~c"Docs"}} =
+               :beam_lib.chunks(beam, [~c"Docs"])
+    end
+
+    test "can keep docs and debug info, if requested" do
+      {:ok, beam} =
+        Path.join(@eex_ebin, "Elixir.EEx.beam")
+        |> File.read!()
+        |> strip_beam(keep: ["Docs", "Dbgi"])
+
+      assert {:ok, {EEx, [{~c"Dbgi", _}]}} = :beam_lib.chunks(beam, [~c"Dbgi"])
+      assert {:ok, {EEx, [{~c"Docs", _}]}} = :beam_lib.chunks(beam, [~c"Docs"])
+    end
+
+    test "strip beams without compression" do
+      {:ok, beam} =
+        Path.join(@eex_ebin, "Elixir.EEx.beam")
+        |> File.read!()
+        |> strip_beam(compress: false)
+
+      assert match?(<<"FOR1", _::binary>>, beam)
+    end
+  end
+
+  describe "included applications" do
+    test "are included in the release", context do
+      in_tmp(context.test, fn ->
+        write_app!(
+          "my_sample1/ebin/my_sample1.app",
+          {:application, :my_sample1,
+           applications: [:kernel, :stdlib, :elixir],
+           description: ~c"my_sample1",
+           modules: [],
+           vsn: ~c"1.0.0",
+           included_applications: [:runtime_tools]}
+        )
+
+        release = release(applications: [my_sample1: :permanent])
+        assert release.boot_scripts.start[:runtime_tools] == :load
+
+        release = release(applications: [my_sample1: :permanent, runtime_tools: :none])
+        assert release.boot_scripts.start[:runtime_tools] == :none
+      end)
+    end
+
+    test "raise on conflict", context do
+      in_tmp(context.test, fn ->
+        write_app!(
+          "my_sample2/ebin/my_sample2.app",
+          {:application, :my_sample2,
+           applications: [:kernel, :stdlib, :elixir, :runtime_tools],
+           description: ~c"my_sample",
+           modules: [],
+           vsn: ~c"1.0.0",
+           included_applications: [:runtime_tools]}
+        )
+
+        assert_raise Mix.Error,
+                     ":runtime_tools is listed both as a regular application and as an included application",
+                     fn -> release(applications: [my_sample2: :permanent]) end
+      end)
+    end
+  end
+
+  describe "optional applications" do
+    test "are ignored if not available", context do
+      in_tmp(context.test, fn ->
+        write_app!(
+          "my_sample3/ebin/my_sample3.app",
+          {:application, :my_sample3,
+           applications: [:kernel, :stdlib, :elixir, :unknown],
+           optional_applications: [:unknown],
+           description: ~c"my_sample3",
+           modules: [],
+           vsn: ~c"1.0.0"}
+        )
+
+        release = release(applications: [my_sample3: :permanent])
+        assert release.boot_scripts.start[:unknown] == nil
+      end)
+    end
+
+    test "are ignored even if mode changes", context do
+      in_tmp(context.test, fn ->
+        write_app!(
+          "has_optional/ebin/has_optional.app",
+          {:application, :has_optional,
+           applications: [:kernel, :stdlib, :elixir, :unknown],
+           optional_applications: [:unknown],
+           description: ~c"has_optional",
+           modules: [],
+           vsn: ~c"1.0.0"}
+        )
+
+        write_app!(
+          "points_as_permanent/ebin/points_as_permanent.app",
+          {:application, :points_as_permanent,
+           applications: [:kernel, :stdlib, :elixir, :has_optional],
+           optional_applications: [:unknown],
+           description: ~c"points_as_permanent",
+           modules: [],
+           vsn: ~c"1.0.0"}
+        )
+
+        write_app!(
+          "points_as_temporary/ebin/points_as_temporary.app",
+          {:application, :points_as_temporary,
+           applications: [:kernel, :stdlib, :elixir, :has_optional],
+           optional_applications: [:unknown],
+           description: ~c"points_as_temporary",
+           modules: [],
+           vsn: ~c"1.0.0"}
+        )
+
+        release =
+          release(
+            applications: [points_as_permanent: :permanent, points_as_temporary: :temporary]
+          )
+
+        assert release.boot_scripts.start[:has_optional] == :permanent
+        assert release.boot_scripts.start[:unknown] == nil
+      end)
+    end
+  end
+
+  defp write_app!(path, app) do
+    dir = Path.dirname(path)
+    File.mkdir_p!(dir)
+    Code.prepend_path(dir)
+    format = :io_lib.format("%% coding: utf-8~n~p.~n", [app])
+    File.write!(path, format)
+  end
+
+  defp size!(path) do
+    File.stat!(path).size
+  end
+
+  defp mode!(path) do
+    File.stat!(path).mode
+  end
+
+  defp release(config, overrides \\ []) do
+    from_config!(nil, config(releases: [demo: config]), overrides)
+  end
+
+  defp config(extra \\ []) do
+    [
+      app: :mix,
+      version: "0.1.0",
+      build_path: tmp_path("mix_release/_build"),
+      build_per_environment: true,
+      config_path: tmp_path("mix_release/config/config.exs")
+    ]
+    |> Keyword.merge(extra)
+  end
+
+  defmodule ReleaseApp do
+    def project do
+      [
+        app: :mix,
+        version: "0.1.0",
+        build_path: tmp_path("mix_release/_build"),
+        build_per_environment: true,
+        config_path: tmp_path("mix_release/config/config.exs")
+      ]
+      |> Keyword.merge(Process.get(:project))
+    end
+  end
+end
diff --git a/lib/mix/test/mix/scm/git_test.exs b/lib/mix/test/mix/scm/git_test.exs
index fc99a4a830c..028382aa11c 100644
--- a/lib/mix/test/mix/scm/git_test.exs
+++ b/lib/mix/test/mix/scm/git_test.exs
@@ -1,25 +1,81 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.SCM.GitTest do
   use MixTest.Case, async: true
 
   test "formats the lock" do
     assert Mix.SCM.Git.format_lock(lock()) == "abcdef0"
-    assert Mix.SCM.Git.format_lock(lock(branch: "master")) == "abcdef0 (branch: master)"
-    assert Mix.SCM.Git.format_lock(lock(tag: "v0.12.0"))   == "abcdef0 (tag: v0.12.0)"
-    assert Mix.SCM.Git.format_lock(lock(ref: "abcdef0"))   == "abcdef0 (ref)"
+    assert Mix.SCM.Git.format_lock(lock(branch: "main")) == "abcdef0 (branch: main)"
+    assert Mix.SCM.Git.format_lock(lock(tag: "v0.12.0")) == "abcdef0 (tag: v0.12.0)"
+    assert Mix.SCM.Git.format_lock(lock(ref: "abcdef0")) == "abcdef0 (ref)"
   end
 
-  test "considers to dep equals if the have the same git and the same opts" do
-    assert Mix.SCM.Git.equal?([git: "foo"], [git: "foo"])
-    refute Mix.SCM.Git.equal?([git: "foo"], [git: "bar"])
+  test "considers two dep equals if the have the same Git and the same opts" do
+    assert Mix.SCM.Git.equal?([git: "foo"], git: "foo")
+    refute Mix.SCM.Git.equal?([git: "foo"], git: "bar")
 
-    assert Mix.SCM.Git.equal?([git: "foo", branch: "master"], [git: "foo", branch: "master"])
-    refute Mix.SCM.Git.equal?([git: "foo", branch: "master"], [git: "foo", branch: "other"])
+    assert Mix.SCM.Git.equal?([git: "foo", branch: "main"], git: "foo", branch: "main")
+    refute Mix.SCM.Git.equal?([git: "foo", branch: "main"], git: "foo", branch: "other")
   end
 
   test "lock should not be taken into account when considering deps equal as the lock is shared" do
-    assert Mix.SCM.Git.equal?([git: "foo", lock: 1], [git: "foo", lock: 2])
+    assert Mix.SCM.Git.equal?([git: "foo", lock: 1], git: "foo", lock: 2)
+  end
+
+  test "get and update should display git checkout options along the url" do
+    opts = [git: "https://github.com/elixir-lang/some_dep.git"]
+
+    assert Mix.SCM.Git.format(opts) ==
+             "https://github.com/elixir-lang/some_dep.git"
+
+    assert Mix.SCM.Git.format(Keyword.put(opts, :tag, "v1")) ==
+             "https://github.com/elixir-lang/some_dep.git - v1"
+
+    assert Mix.SCM.Git.format(Keyword.put(opts, :branch, "b")) ==
+             "https://github.com/elixir-lang/some_dep.git - b"
+
+    assert Mix.SCM.Git.format(Keyword.put(opts, :ref, "abcdef")) ==
+             "https://github.com/elixir-lang/some_dep.git - abcdef"
+  end
+
+  test "redacts username password from urls" do
+    url = "https://username:password@github.com/elixir-lang/some_dep.git"
+    opts = [git: url]
+
+    assert Mix.SCM.Git.format(opts) ==
+             "https://****:****@github.com/elixir-lang/some_dep.git"
+
+    assert_raise Mix.Error, ~r/[*]{4}:[*]{4}/, fn ->
+      Mix.SCM.Git.accepts_options(nil, git: url, branch: "main", branch: "develop")
+    end
+  end
+
+  test "raises about conflicting Git refspec options" do
+    assert_raise Mix.Error, ~r/You should specify only one of branch, ref or tag/, fn ->
+      Mix.SCM.Git.accepts_options(nil, git: "/repo", branch: "main", tag: "0.1.0")
+    end
+
+    assert_raise Mix.Error, ~r/You should specify only one of branch, ref or tag/, fn ->
+      Mix.SCM.Git.accepts_options(nil, git: "/repo", branch: "main", branch: "develop")
+    end
+  end
+
+  test "raises about non-binary Git refspec options" do
+    assert_raise Mix.Error, ~r/A dependency's branch must be a string/, fn ->
+      Mix.SCM.Git.accepts_options(nil, git: "/repo", branch: :main)
+    end
+
+    assert_raise Mix.Error, ~r/A dependency's tag must be a string/, fn ->
+      Mix.SCM.Git.accepts_options(nil, git: "/repo", tag: :stable)
+    end
+
+    assert_raise Mix.Error, ~r/A dependency's ref must be a string/, fn ->
+      Mix.SCM.Git.accepts_options(nil, git: "/repo", ref: :abcdef0123456789)
+    end
   end
 
   defp lock(opts \\ []) do
diff --git a/lib/mix/test/mix/scm_test.exs b/lib/mix/test/mix/scm_test.exs
index 4b04a99ba5f..5053d323fa2 100644
--- a/lib/mix/test/mix/scm_test.exs
+++ b/lib/mix/test/mix/scm_test.exs
@@ -1,21 +1,29 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Mix.SCMTest do
   use MixTest.Case
 
   setup do
-    available = Mix.SCM.available
-    on_exit fn -> Application.put_env(:mix, :scm, available) end
+    available = Mix.SCM.available()
+    on_exit(fn -> Mix.State.put(:scm, available) end)
     :ok
   end
 
-  test "prepends a SCM" do
+  test "prepends an SCM" do
     Mix.SCM.prepend(Hello)
-    assert Enum.at(Mix.SCM.available, 0) == Hello
+    assert Enum.at(Mix.SCM.available(), 0) == Hello
+    Mix.SCM.delete(Hello)
+    assert Hello not in Mix.SCM.available()
   end
 
-  test "appends a SCM" do
+  test "appends an SCM" do
     Mix.SCM.append(Hello)
-    assert Enum.at(Mix.SCM.available, -1) == Hello
+    assert Enum.at(Mix.SCM.available(), -1) == Hello
+    Mix.SCM.delete(Hello)
+    assert Hello not in Mix.SCM.available()
   end
 end
diff --git a/lib/mix/test/mix/shell/io_test.exs b/lib/mix/test/mix/shell/io_test.exs
index 697f53d3da8..12e177597b2 100644
--- a/lib/mix/test/mix/shell/io_test.exs
+++ b/lib/mix/test/mix/shell/io_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Shell.IOTest do
   use MixTest.Case
@@ -8,17 +12,25 @@ defmodule Mix.Shell.IOTest do
 
   test "prints info message to stdio" do
     assert capture_io(fn ->
-      info "hello"
-    end) == "hello\n"
+             info("hello")
+           end) == "hello\n"
   end
 
   test "prints error message to stderr" do
     assert capture_io(:stderr, fn ->
-      error "hello"
-    end) =~ "hello"
+             error("hello")
+           end) =~ "hello"
+  end
+
+  test "raises when device cannot prompt" do
+    Process.group_leader(self(), Process.whereis(:standard_error))
+
+    assert_raise RuntimeError, "Mix.shell().prompt/1 is not supported over this device", fn ->
+      prompt("Ok?")
+    end
   end
 
-  test "asks the user with yes?" do
+  test "asks the user with yes? with implicit default option" do
     assert capture_io("\n", fn -> yes?("Ok?") end) == "Ok? [Yn] "
     assert capture_io("\n", fn -> assert yes?("Ok?") end)
     assert capture_io("Yes", fn -> assert yes?("Ok?") end)
@@ -28,4 +40,58 @@ defmodule Mix.Shell.IOTest do
     assert capture_io("n", fn -> refute yes?("Ok?") end)
     assert capture_io("", fn -> refute yes?("Ok?") end)
   end
+
+  test "asks the user with yes? using :yes as default option" do
+    assert capture_io("\n", fn -> yes?("Ok?", default: :yes) end) == "Ok? [Yn] "
+    assert capture_io("\n", fn -> assert yes?("Ok?", default: :yes) end)
+    assert capture_io("Yes", fn -> assert yes?("Ok?", default: :yes) end)
+    assert capture_io("yes", fn -> assert yes?("Ok?", default: :yes) end)
+    assert capture_io("y", fn -> assert yes?("Ok?", default: :yes) end)
+
+    assert capture_io("n", fn -> refute yes?("Ok?") end)
+    assert capture_io("", fn -> refute yes?("Ok?") end)
+  end
+
+  test "asks the user with yes? using :no as default option" do
+    assert capture_io("\n", fn -> yes?("Ok?", default: :no) end) == "Ok? [yN] "
+    assert capture_io("Yes", fn -> assert yes?("Ok?", default: :no) end)
+    assert capture_io("yes", fn -> assert yes?("Ok?", default: :no) end)
+    assert capture_io("y", fn -> assert yes?("Ok?", default: :no) end)
+
+    assert capture_io("\n", fn -> refute yes?("Ok?", default: :no) end)
+    assert capture_io("n", fn -> refute yes?("Ok?", default: :no) end)
+    assert capture_io("", fn -> refute yes?("Ok?", default: :no) end)
+  end
+
+  test "asks the user with yes? and raise exception where default option is not valid" do
+    message = "expected :default to be either :yes or :no, got: :other"
+
+    assert_raise ArgumentError, message, fn ->
+      capture_io("\n", fn -> yes?("Ok?", default: :other) end)
+    end
+  end
+
+  test "uses default when device cannot read" do
+    Process.group_leader(self(), Process.whereis(:standard_error))
+    assert yes?("Ok?")
+    refute yes?("Ok?", default: :no)
+  end
+
+  test "runs a given command" do
+    nl = os_newline()
+
+    assert capture_io("", fn -> assert cmd("echo hello") == 0 end) == "hello" <> nl
+
+    will_print_sample()
+
+    assert capture_io("", fn -> assert cmd("echo hello", print_app: false) == 0 end) ==
+             "hello" <> nl
+
+    assert capture_io("", fn -> assert cmd("echo hello") == 0 end) == "==> sample\nhello" <> nl
+  end
+
+  defp will_print_sample do
+    Mix.Project.push(nil)
+    Mix.Project.push(MixTest.Case.Sample)
+  end
 end
diff --git a/lib/mix/test/mix/shell/quiet_test.exs b/lib/mix/test/mix/shell/quiet_test.exs
new file mode 100644
index 00000000000..d8cadedee52
--- /dev/null
+++ b/lib/mix/test/mix/shell/quiet_test.exs
@@ -0,0 +1,44 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Shell.QuietTest do
+  use MixTest.Case
+
+  import ExUnit.CaptureIO
+  import Mix.Shell.Quiet
+
+  test "prints nothing to stdio when info is invoked" do
+    assert capture_io(fn -> info("hello") end) == ""
+  end
+
+  test "prints error message to stderr" do
+    assert capture_io(:stderr, fn -> error("hello") end) =~ "hello"
+  end
+
+  test "asks the user with yes?" do
+    assert capture_io("\n", fn -> yes?("Ok?") end) == "Ok? [Yn] "
+    assert capture_io("\n", fn -> assert yes?("Ok?") end)
+    assert capture_io("Yes", fn -> assert yes?("Ok?") end)
+    assert capture_io("yes", fn -> assert yes?("Ok?") end)
+    assert capture_io("y", fn -> assert yes?("Ok?") end)
+
+    assert capture_io("n", fn -> refute yes?("Ok?") end)
+    assert capture_io("", fn -> refute yes?("Ok?") end)
+  end
+
+  test "runs a given command" do
+    assert capture_io("", fn -> assert cmd("echo hello") == 0 end) == ""
+
+    wont_print_sample()
+    assert capture_io("", fn -> assert cmd("echo hello", print_app: false) == 0 end) == ""
+    assert capture_io("", fn -> assert cmd("echo hello") == 0 end) == ""
+  end
+
+  defp wont_print_sample do
+    Mix.Project.push(nil)
+    Mix.Project.push(MixTest.Case.Sample)
+  end
+end
diff --git a/lib/mix/test/mix/shell_test.exs b/lib/mix/test/mix/shell_test.exs
index df9a0335c08..06fe59ad747 100644
--- a/lib/mix/test/mix/shell_test.exs
+++ b/lib/mix/test/mix/shell_test.exs
@@ -1,67 +1,37 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Mix.ShellTest do
   use MixTest.Case
 
-  defp capture_io(somefunc) do
-    ExUnit.CaptureIO.capture_io(somefunc) |> String.replace("\r\n","\n")
-  end
-
-  defp capture_io(from, somefunc) do
-    ExUnit.CaptureIO.capture_io(from, somefunc) |> String.replace("\r\n","\n")
-  end
-
-  setup do
-    on_exit fn ->
-      Mix.shell(Mix.Shell.Process)
-    end
-    :ok
+  defp capture_io(fun) do
+    fun |> ExUnit.CaptureIO.capture_io() |> String.replace("\r\n", "\n")
   end
 
-  test "shell process" do
-    Mix.shell.info "abc"
-    Mix.shell.error "def"
-    assert_received {:mix_shell, :info, ["abc"]}
-    assert_received {:mix_shell, :error, ["def"]}
-
-    send self, {:mix_shell_input, :prompt, "world"}
-    assert Mix.shell.prompt("hello?") == "world"
-    assert_received {:mix_shell, :prompt, ["hello?"]}
+  test "executes cmd with expressions" do
+    Mix.shell(Mix.Shell.IO)
 
-    send self, {:mix_shell_input, :yes?, true}
-    assert Mix.shell.yes?("hello?")
-    assert_received {:mix_shell, :yes?, ["hello?"]}
-
-    assert Mix.shell.cmd("echo first") == 0
-    
-    nl = os_newline
-    assert_received {:mix_shell, :run, ["first" <> ^nl]}
+    assert capture_io(fn ->
+             assert Mix.shell().cmd("echo first && echo second") == 0
+           end)
+           |> String.replace(" \n", "\n") == "first\nsecond\n"
+  after
+    Mix.shell(Mix.Shell.Process)
   end
 
-  test "shell io" do
-    Mix.shell Mix.Shell.IO
-
-    assert capture_io(fn -> Mix.shell.info "abc" end) ==
-           "abc\n"
-
-    assert capture_io(:stderr, fn -> Mix.shell.error "def" end) ==
-           (IO.ANSI.escape "%{red,bright}def") <> "\n"
-
-    assert capture_io("world", fn -> assert Mix.shell.prompt("hello?") == "world" end) ==
-           "hello? "
-
-    assert capture_io("Yes", fn -> assert Mix.shell.yes?("hello?") end) ==
-           "hello? [Yn] "
-
-    assert capture_io(fn -> assert Mix.shell.cmd("echo first") == 0 end) ==
-           "first\n"
-  end
-
-  test "shell cmd supports expressions" do
-    Mix.shell Mix.Shell.IO
-
-    assert (capture_io(fn ->
-      assert Mix.shell.cmd("echo first && echo second") == 0
-    end) |> String.replace(" \n", "\n")) == "first\nsecond\n"
+  test "with :cd" do
+    Mix.shell(Mix.Shell.IO)
+    tmp_dir = System.tmp_dir()
+    File.mkdir_p!(tmp_dir)
+    {pwd, 0} = System.cmd("pwd", [], cd: tmp_dir)
+
+    assert ExUnit.CaptureIO.capture_io(fn ->
+             Mix.shell().cmd("pwd", cd: tmp_dir)
+           end) == pwd
+  after
+    Mix.shell(Mix.Shell.Process)
   end
 end
diff --git a/lib/mix/test/mix/sync/lock_test.exs b/lib/mix/test/mix/sync/lock_test.exs
new file mode 100644
index 00000000000..651b12ed4d8
--- /dev/null
+++ b/lib/mix/test/mix/sync/lock_test.exs
@@ -0,0 +1,192 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Sync.LockTest do
+  use ExUnit.Case, async: true
+
+  alias Mix.Sync.Lock
+
+  @lock_key Atom.to_string(__MODULE__)
+
+  test "executes functions" do
+    assert Lock.with_lock(@lock_key, fn -> :it_works! end) == :it_works!
+    assert Lock.with_lock(@lock_key, fn -> :still_works! end) == :still_works!
+  end
+
+  test "releases lock on error" do
+    assert_raise RuntimeError, fn ->
+      Lock.with_lock(@lock_key, fn -> raise "oops" end)
+    end
+
+    assert Lock.with_lock(@lock_key, fn -> :still_works! end) == :still_works!
+  end
+
+  test "releases lock on exit" do
+    {_pid, ref} =
+      spawn_monitor(fn ->
+        Lock.with_lock(@lock_key, fn -> Process.exit(self(), :kill) end)
+      end)
+
+    assert_receive {:DOWN, ^ref, _, _, _}
+    assert Lock.with_lock(@lock_key, fn -> :still_works! end) == :still_works!
+  end
+
+  test "blocks until released" do
+    parent = self()
+
+    task =
+      Task.async(fn ->
+        Lock.with_lock(@lock_key, fn ->
+          send(parent, :locked)
+          assert_receive :will_lock
+          :it_works!
+        end)
+      end)
+
+    assert_receive :locked
+    send(task.pid, :will_lock)
+    assert Lock.with_lock(@lock_key, fn -> :still_works! end) == :still_works!
+    assert Task.await(task) == :it_works!
+  end
+
+  @tag :capture_log
+  test "blocks until released on error" do
+    parent = self()
+
+    {pid, ref} =
+      spawn_monitor(fn ->
+        Lock.with_lock(@lock_key, fn ->
+          send(parent, :locked)
+          assert_receive :will_lock
+          raise "oops"
+        end)
+      end)
+
+    assert_receive :locked
+    send(pid, :will_lock)
+    assert Lock.with_lock(@lock_key, fn -> :still_works! end) == :still_works!
+    assert_receive {:DOWN, ^ref, _, _, _}
+  end
+
+  test "blocks until released on exit" do
+    parent = self()
+
+    {pid, ref} =
+      spawn_monitor(fn ->
+        Lock.with_lock(@lock_key, fn ->
+          send(parent, :locked)
+          assert_receive :will_not_lock
+        end)
+      end)
+
+    assert_receive :locked
+    Process.exit(pid, :kill)
+    assert Lock.with_lock(@lock_key, fn -> :still_works! end) == :still_works!
+    assert_receive {:DOWN, ^ref, _, _, _}
+  end
+
+  test "schedules and releases on exit" do
+    assert Lock.with_lock(@lock_key, fn ->
+             {pid, ref} =
+               spawn_monitor(fn ->
+                 Lock.with_lock(@lock_key, fn ->
+                   raise "this will never be invoked"
+                 end)
+               end)
+
+             Process.exit(pid, :kill)
+             assert_receive {:DOWN, ^ref, _, _, :killed}
+             :it_works!
+           end) == :it_works!
+
+    assert Lock.with_lock(@lock_key, fn -> :still_works! end) == :still_works!
+  end
+
+  @tag :tmp_dir
+  test "property test with file access", %{tmp_dir: tmp_dir} do
+    # Spawn N concurrent processes incrementing number in a file
+    n = 10
+    number_path = Path.join(tmp_dir, "number.txt")
+
+    File.write!(number_path, "0")
+
+    refs =
+      for _ <- 1..n do
+        spawn_monitor(fn ->
+          Lock.with_lock(@lock_key, fn ->
+            number = number_path |> File.read!() |> String.to_integer()
+            new_number = number + 1
+            File.write!(number_path, Integer.to_string(new_number))
+
+            assert File.read!(number_path) == Integer.to_string(new_number)
+
+            # Terminate without unlocking in random cases
+            case Enum.random(1..2) do
+              1 -> Process.exit(self(), :kill)
+              2 -> :ok
+            end
+          end)
+        end)
+        |> elem(1)
+      end
+
+    await_monitors(refs)
+
+    assert File.read!(number_path) == Integer.to_string(n)
+  end
+
+  test "lock can be acquired multiple times by the same process" do
+    {_pid, ref} =
+      spawn_monitor(fn ->
+        Lock.with_lock(@lock_key, fn ->
+          Lock.with_lock(@lock_key, fn ->
+            Process.exit(self(), :kill)
+          end)
+        end)
+      end)
+
+    assert_receive {:DOWN, ^ref, _, _, _}
+
+    assert Lock.with_lock(@lock_key, fn ->
+             Lock.with_lock(@lock_key, fn ->
+               :still_works!
+             end)
+           end) == :still_works!
+  end
+
+  test "calls :on_taken when the lock is held by a different process" do
+    parent = self()
+
+    {pid, ref} =
+      spawn_monitor(fn ->
+        Lock.with_lock(@lock_key, fn ->
+          send(parent, :locked)
+          assert_receive :will_lock
+        end)
+      end)
+
+    assert_receive :locked
+
+    on_taken = fn os_pid ->
+      send(pid, :will_lock)
+      send(self(), {:on_taken_called, os_pid})
+    end
+
+    assert Lock.with_lock(@lock_key, fn -> :it_works! end, on_taken: on_taken) == :it_works!
+
+    os_pid = System.pid()
+    assert_receive {:on_taken_called, ^os_pid}
+
+    assert_receive {:DOWN, ^ref, _, _, _}
+  end
+
+  defp await_monitors([]), do: :ok
+
+  defp await_monitors(refs) do
+    receive do
+      {:DOWN, ref, _, _, _} -> await_monitors(refs -- [ref])
+    end
+  end
+end
diff --git a/lib/mix/test/mix/sync/pubsub_test.exs b/lib/mix/test/mix/sync/pubsub_test.exs
new file mode 100644
index 00000000000..01a1ca6290e
--- /dev/null
+++ b/lib/mix/test/mix/sync/pubsub_test.exs
@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Sync.PubSubTest do
+  use ExUnit.Case, async: true
+
+  alias Mix.Sync.PubSub
+
+  @pubsub_key inspect(__MODULE__)
+
+  test "delivers broadcast to multiple subscribers for the same key" do
+    parent = self()
+
+    spawn_link(fn ->
+      PubSub.subscribe(@pubsub_key)
+      send(parent, :subscribed1)
+      assert_receive %{event: "event1"}
+      assert_receive %{event: "event2"}
+      send(parent, :done1)
+    end)
+
+    spawn_link(fn ->
+      PubSub.subscribe(@pubsub_key)
+      send(parent, :subscribed2)
+      assert_receive %{event: "event1"}
+      assert_receive %{event: "event2"}
+      send(parent, :done2)
+    end)
+
+    assert_receive :subscribed1
+    assert_receive :subscribed2
+
+    PubSub.broadcast(@pubsub_key, %{event: "event1"})
+    PubSub.broadcast(@pubsub_key, %{event: "event2"})
+
+    assert_receive :done1
+    assert_receive :done2
+  end
+
+  test "delivers broadcast to subscribers for different keys" do
+    parent = self()
+
+    spawn_link(fn ->
+      PubSub.subscribe([@pubsub_key, "1"])
+      send(parent, :subscribed1)
+      assert_receive %{event: "event1"}
+      assert_receive %{event: "event3"}
+      refute_received %{event: "event2"}
+      send(parent, :done1)
+    end)
+
+    spawn_link(fn ->
+      PubSub.subscribe([@pubsub_key, "2"])
+      send(parent, :subscribed2)
+      assert_receive %{event: "event2"}
+      assert_receive %{event: "event3"}
+      refute_received %{event: "event1"}
+      send(parent, :done2)
+    end)
+
+    assert_receive :subscribed1
+    assert_receive :subscribed2
+
+    PubSub.broadcast([@pubsub_key, "1"], %{event: "event1"})
+    PubSub.broadcast([@pubsub_key, "2"], %{event: "event2"})
+    PubSub.broadcast([@pubsub_key, "1"], %{event: "event3"})
+    PubSub.broadcast([@pubsub_key, "2"], %{event: "event3"})
+
+    assert_receive :done1
+    assert_receive :done2
+  end
+
+  test "evaluates lazy message only if there are subscribers" do
+    lazy_message = fn ->
+      send(self(), :lazy1)
+      %{event: "event1"}
+    end
+
+    PubSub.broadcast([@pubsub_key, "lazy"], lazy_message)
+
+    PubSub.subscribe([@pubsub_key, "lazy"])
+
+    lazy_message = fn ->
+      send(self(), :lazy2)
+      %{event: "event2"}
+    end
+
+    PubSub.broadcast([@pubsub_key, "lazy"], lazy_message)
+
+    refute_received :lazy1
+    assert_received :lazy2
+  end
+end
diff --git a/lib/mix/test/mix/task_test.exs b/lib/mix/test/mix/task_test.exs
index 48f08fe8587..3cdb9a1e299 100644
--- a/lib/mix/test/mix/task_test.exs
+++ b/lib/mix/test/mix/task_test.exs
@@ -1,87 +1,328 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-path = MixTest.Case.tmp_path("beams")
-File.rm_rf!(path)
-File.mkdir_p!(path)
-
-write_beam = fn {:module, name, bin, _} ->
-  path
-  |> Path.join(Atom.to_string(name) <> ".beam")
-  |> File.write!(bin)
-end
-
-defmodule Mix.Tasks.Hello do
-  use Mix.Task
-  @shortdoc "This is short documentation, see"
-
-  @moduledoc """
-  A test task.
-  """
-
-  def run(_) do
-    "Hello, World!"
-  end
-end |> write_beam.()
-
-defmodule Mix.Tasks.Invalid do
-end |> write_beam.()
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Mix.TaskTest do
   use MixTest.Case
 
-  setup do
-    Code.prepend_path unquote(path)
-    :ok
+  defmodule SampleProject do
+    def project do
+      [app: :sample, version: "0.0.1"]
+    end
   end
 
-  test :run do
+  test "run/2" do
     assert Mix.Task.run("hello") == "Hello, World!"
     assert Mix.Task.run("hello") == :noop
 
-    assert_raise Mix.NoTaskError, "The task unknown could not be found", fn ->
-      Mix.Task.run("unknown")
+    assert_raise Mix.NoTaskError,
+                 "The task \"unknown\" could not be found\nNote no mix.exs was found in the current directory",
+                 fn -> Mix.Task.run("unknown") end
+
+    message =
+      "The task \"helli\" could not be found. Did you mean \"hello\"?\nNote no mix.exs was found in the current directory"
+
+    assert_raise Mix.NoTaskError, message, fn ->
+      Mix.Task.run("helli")
     end
 
-    assert_raise Mix.InvalidTaskError, "The task invalid does not export run/1", fn ->
+    assert_raise Mix.InvalidTaskError, "The task \"invalid\" does not export run/1", fn ->
       Mix.Task.run("invalid")
     end
+
+    message =
+      "The task \"acronym.http\" could not be found because the module is named " <>
+        "Mix.Tasks.Acronym.HTTP instead of Mix.Tasks.Acronym.Http as expected. " <>
+        "Please rename it and try again"
+
+    assert_raise Mix.NoTaskError, message, fn ->
+      Mix.Task.run("acronym.http")
+    end
+  end
+
+  test "run/2 converts OptionParser.ParseError into Mix errors" do
+    message = ~r"Could not invoke task \"hello\": 1 error found!\n--unknown : Unknown option"
+
+    assert_raise Mix.Error, message, fn ->
+      Mix.Task.run("hello", ["--parser", "--unknown"])
+    end
+
+    Mix.Task.clear()
+
+    message =
+      ~r"Could not invoke task \"hello\": 1 error found!\n--int : Expected type integer, got \"foo\""
+
+    assert_raise Mix.Error, message, fn ->
+      Mix.Task.run("hello", ["--parser", "--int", "foo"])
+    end
+  end
+
+  test "run/2 outputs task debug info if Mix.debug? is true" do
+    Mix.shell(Mix.Shell.IO)
+    Mix.debug(true)
+
+    assert ExUnit.CaptureIO.capture_io(fn -> Mix.Task.run("hello") end) =~
+             ~r"-> Running mix hello\n<- Ran mix hello in \d+ms"
+  after
+    Mix.shell(Mix.Shell.Process)
+    Mix.debug(false)
+  end
+
+  defmodule DepsApp do
+    def project do
+      [
+        app: :raw_sample,
+        version: "0.1.0",
+        deps: [
+          {:raw_repo, "0.1.0", path: "custom/raw_repo"}
+        ]
+      ]
+    end
+  end
+
+  test "run/2 tries to load deps if task is missing" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DepsApp)
+
+      assert_raise Mix.NoTaskError, fn ->
+        Mix.Task.run("task_hello")
+      end
+
+      File.write!("custom/raw_repo/lib/task_hello.ex", """
+      defmodule Mix.Tasks.TaskHello do
+        use Mix.Task
+        def run(_), do: "Hello World v1"
+      end
+      """)
+
+      # Clean up the tasks and update task
+      Mix.Task.clear()
+
+      # Task was found from deps loadpaths
+      assert Mix.Task.run("task_hello") == "Hello World v1"
+
+      # The compile task should not have run yet
+      assert Mix.Task.run("compile") != :noop
+
+      # Clean up the tasks and update task
+      Mix.Task.clear()
+
+      File.write!("custom/raw_repo/lib/task_hello.ex", """
+      defmodule Mix.Tasks.TaskHello do
+        use Mix.Task
+        def run(_), do: "Hello World v2"
+      end
+      """)
+
+      # Simulate starting a new invocation
+      purge([Mix.Tasks.TaskHello])
+      Code.delete_path("_build/dev/lib/raw_repo/ebin")
+      ensure_touched("custom/raw_repo/lib/task_hello.ex")
+
+      # Task is recompiled to v2
+      assert Mix.Task.run("task_hello") == "Hello World v2"
+    end)
+  end
+
+  test "run/2 tries to compile if task is missing", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(SampleProject, "sample")
+
+      assert_raise Mix.NoTaskError, fn ->
+        Mix.Task.run("unknown")
+      end
+
+      # Check if compile task have run
+      refute Mix.TasksServer.run({:task, "compile", Mix.Project.get()})
+    end)
   end
 
-  test :clear do
-    Mix.Task.run("hello")
-    assert {"hello", nil} in Mix.Task.clear
+  test "clear/0" do
+    assert Mix.Task.run("hello") == "Hello, World!"
+    Mix.Task.clear()
+    assert Mix.Task.run("hello") == "Hello, World!"
   end
 
-  test :reenable do
+  test "reenable/1" do
     assert Mix.Task.run("hello") == "Hello, World!"
     Mix.Task.reenable("hello")
     assert Mix.Task.run("hello") == "Hello, World!"
   end
 
-  test :get! do
+  test "reenable/1 for recursive inside umbrella" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        assert [:ok, :ok] = Mix.Task.run("clean")
+        assert [:noop, :noop] = Mix.Task.run("clean")
+
+        Mix.Task.reenable("clean")
+        assert [:ok, :ok] = Mix.Task.run("clean")
+        assert [:noop, :noop] = Mix.Task.run("clean")
+      end)
+    end)
+  end
+
+  test "aliases considered for umbrella apps" do
+    in_fixture("umbrella_test", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        File.mkdir_p!("apps/baz/lib/")
+
+        File.write!("apps/baz/mix.exs", """
+        defmodule Baz.MixProject do
+          use Mix.Project
+
+          def project do
+            [
+              app: :baz,
+              version: "0.1.0",
+              aliases: [help: fn _ -> raise "oops" end]
+            ]
+          end
+        end
+        """)
+
+        File.write!("apps/baz/lib/baz.ex", """
+        defmodule Baz do
+          def hello do
+            :world
+          end
+        end
+        """)
+
+        Mix.Task.run("compile")
+        assert_received {:mix_shell, :info, ["==> foo"]}
+        assert_received {:mix_shell, :info, ["==> bar"]}
+        assert_received {:mix_shell, :info, ["==> baz"]}
+        Mix.shell().flush()
+
+        # A child alias does not overlap an umbrella task
+        assert Mix.Task.run("help") == :ok
+
+        # A missing umbrella alias can be found in children
+        assert [:ok, :ok] = Mix.Task.run("mytask")
+        assert_received {:mix_shell, :info, ["==> foo"]}
+        assert_received {:mix_shell, :info, ["foo_running"]}
+        assert_received {:mix_shell, :info, ["==> bar"]}
+        assert_received {:mix_shell, :info, ["bar_running"]}
+        refute_received {:mix_shell, :info, ["==> baz"]}
+
+        # An unknown task or alias anywhere fails
+        assert_raise Mix.NoTaskError, fn ->
+          Mix.Task.run("completely_unknown")
+        end
+      end)
+    end)
+  end
+
+  test "reenable/1 for recursive inside umbrella child" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        assert [:ok, :ok] = Mix.Task.run("cmd", ["echo", "hello"])
+        assert [:ok, :ok] = Mix.Task.run("cmd", ["echo", "world"])
+
+        assert_received {:mix_shell, :run, ["hello" <> _]}
+        assert_received {:mix_shell, :run, ["world" <> _]}
+        assert_received {:mix_shell, :run, ["hello" <> _]}
+        assert_received {:mix_shell, :run, ["world" <> _]}
+      end)
+    end)
+  end
+
+  test "reenable/1 for non-recursive inside umbrella" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        assert [:ok, :ok] = Mix.Task.run("clean")
+        # loadpaths is not recursive
+        assert :ok = Mix.Task.run("loadpaths")
+      end)
+    end)
+  end
+
+  test "rerun/1" do
+    assert Mix.Task.run("hello") == "Hello, World!"
+    assert Mix.Task.rerun("hello") == "Hello, World!"
+  end
+
+  test "rerun/1 for umbrella" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        assert [:ok, :ok] = Mix.Task.run("clean")
+        assert [:noop, :noop] = Mix.Task.run("clean")
+        assert [:ok, :ok] = Mix.Task.rerun("clean")
+      end)
+    end)
+  end
+
+  test "get!" do
+    Mix.Project.push(MixTest.Case.Sample)
     assert Mix.Task.get!("hello") == Mix.Tasks.Hello
 
-    assert_raise Mix.NoTaskError, "The task unknown could not be found", fn ->
+    assert_raise Mix.NoTaskError, "The task \"unknown\" could not be found", fn ->
       Mix.Task.get!("unknown")
     end
 
-    assert_raise Mix.InvalidTaskError, "The task invalid does not export run/1", fn ->
+    assert_raise Mix.InvalidTaskError, "The task \"invalid\" does not export run/1", fn ->
       Mix.Task.get!("invalid")
     end
   end
 
-  test :all_modules do
-    Mix.Task.load_all
-    modules = Mix.Task.all_modules
+  test "alias?/1" do
+    assert Mix.Task.alias?(:sample) == false
+    assert Mix.Task.alias?("sample") == false
+
+    Mix.Project.push(MixTest.Case.Sample)
+    assert Mix.Task.alias?(:sample) == true
+    assert Mix.Task.alias?("sample") == true
+    assert Mix.Task.alias?("another") == false
+  after
+    Mix.Project.pop()
+  end
+
+  test "all_modules/0" do
+    Mix.Task.load_all()
+    modules = Mix.Task.all_modules()
     assert Mix.Tasks.Hello in modules
     assert Mix.Tasks.Compile in modules
   end
 
-  test :moduledoc do
+  test "moduledoc/1" do
+    Code.prepend_path(MixTest.Case.tmp_path("beams"))
     assert Mix.Task.moduledoc(Mix.Tasks.Hello) == "A test task.\n"
   end
 
-  test :shortdoc do
+  test "shortdoc/1" do
     assert Mix.Task.shortdoc(Mix.Tasks.Hello) == "This is short documentation, see"
   end
+
+  defmodule Elixir.Mix.Tasks.WithRequirement do
+    use Mix.Task
+    @shortdoc "This is short documentation, see"
+    @requirements "help \"compile\""
+
+    @moduledoc """
+    A test task.
+    """
+
+    def run(_args) do
+      "Task with requirements"
+    end
+  end
+
+  test "requirements/1" do
+    assert Mix.Task.requirements(Mix.Tasks.WithRequirement) == ["help \"compile\""]
+  end
+
+  test "@requirements are running during task execution" do
+    assert ExUnit.CaptureIO.capture_io(fn ->
+             assert Mix.Task.run("with_requirement") == "Task with requirements"
+           end) =~ "mix compile"
+
+    Mix.Task.reenable("help")
+
+    assert ExUnit.CaptureIO.capture_io(fn ->
+             assert Mix.Task.run("with_requirement") == :noop
+           end) == ""
+  end
 end
diff --git a/lib/mix/test/mix/tasks/app.config_test.exs b/lib/mix/test/mix/tasks/app.config_test.exs
new file mode 100644
index 00000000000..13b1944cc8a
--- /dev/null
+++ b/lib/mix/test/mix/tasks/app.config_test.exs
@@ -0,0 +1,156 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.App.ConfigTest do
+  use MixTest.Case
+
+  test "loads project configuration" do
+    Process.put(
+      {MixTest.Case.Sample, :application},
+      env: [from_env: :env, from_compile: :env, from_runtime: :env]
+    )
+
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.mkdir_p!("config")
+
+      File.write!("config/config.exs", """
+      import Config
+      config :sample, from_compile: :compile, from_runtime: :compile
+      config :sample, :nested, from_compile: :compile, from_runtime: :compile
+      """)
+
+      File.write!("config/runtime.exs", """
+      import Config
+      config :sample, from_runtime: :runtime
+      config :sample, :nested, from_compile: :compile, from_runtime: :compile
+      """)
+
+      Mix.Task.run("loadconfig")
+      Mix.Task.run("app.config")
+
+      assert Application.get_all_env(:sample) |> Enum.sort() == [
+               from_compile: :compile,
+               from_env: :env,
+               from_runtime: :runtime,
+               nested: [from_compile: :compile, from_runtime: :compile]
+             ]
+    end)
+  after
+    Application.delete_env(:sample, :nested, persistent: true)
+    Application.delete_env(:sample, :from_env, persistent: true)
+    Application.delete_env(:sample, :from_compile, persistent: true)
+    Application.delete_env(:sample, :from_runtime, persistent: true)
+  end
+
+  test "sets config_env() and config_target()" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.mkdir_p!("config")
+
+      File.write!("config/runtime.exs", """
+      import Config
+      config :sample, vars: {config_env(), config_target()}
+      """)
+
+      Mix.Task.run("app.config")
+      assert Application.get_all_env(:sample) == [vars: {:dev, :host}]
+    end)
+  after
+    Application.delete_env(:sample, :vars, persistent: true)
+  end
+
+  test "warns if kernel/stdlib are configured" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.mkdir_p!("config")
+
+      File.write!("config/runtime.exs", """
+      import Config
+      config :kernel, this_wont: :work
+      """)
+
+      Mix.Task.run("loadconfig")
+      Mix.Task.run("app.config")
+
+      assert_received {:mix_shell, :error, ["Cannot configure base applications: [:kernel]" <> _]}
+    end)
+  end
+
+  test "compiles and preloads the project" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      Mix.Task.run("app.config", ["--no-compile"])
+      refute Code.ensure_loaded?(A)
+      refute File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
+      refute File.regular?("_build/dev/lib/sample/ebin/sample.app")
+
+      Mix.Task.rerun("app.config")
+      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
+      assert File.regular?("_build/dev/lib/sample/ebin/sample.app")
+
+      assert Code.ensure_loaded?(A)
+      purge([A])
+
+      Mix.Task.rerun("app.config", [])
+      refute Code.loaded?(A)
+
+      Mix.Task.rerun("app.config", ["--preload-modules"])
+      assert Code.loaded?(A)
+    end)
+  end
+
+  test "start checks for invalid configuration", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      :ok = :application.load({:application, :loaded_sample, [vsn: ~c"1.0.0", env: []]})
+      Mix.ProjectStack.loaded_config([:sample, :unknown_sample, :loaded_sample], [])
+      Mix.Tasks.App.Config.run([])
+
+      assert_received {:mix_shell, :error,
+                       ["You have configured application :unknown_sample" <> _]}
+
+      refute_received {:mix_shell, :error,
+                       ["You have configured application :loaded_sample" <> _]}
+    end)
+  end
+
+  test "validates Elixir version requirement", context do
+    Mix.ProjectStack.post_config(elixir: "~> ~> 0.8.1")
+
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      assert_raise Mix.Error, ~r"Invalid Elixir version requirement", fn ->
+        Mix.Tasks.App.Start.run(["--no-start"])
+      end
+    end)
+  end
+
+  test "validates the Elixir version with requirement", context do
+    Mix.ProjectStack.post_config(elixir: "~> 0.8.1")
+
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      assert_raise Mix.ElixirVersionError, ~r/You're trying to run :sample on Elixir/, fn ->
+        Mix.Tasks.App.Start.run(["--no-start"])
+      end
+    end)
+  end
+
+  test "does not validate the Elixir version with requirement when disabled", context do
+    Mix.ProjectStack.post_config(elixir: "~> 0.8.1")
+
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      Mix.Tasks.App.Start.run(["--no-start", "--no-elixir-version-check"])
+    end)
+  end
+end
diff --git a/lib/mix/test/mix/tasks/app.start_test.exs b/lib/mix/test/mix/tasks/app.start_test.exs
index dc08870afbf..885c7066010 100644
--- a/lib/mix/test/mix/tasks/app.start_test.exs
+++ b/lib/mix/test/mix/tasks/app.start_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.App.StartTest do
   use MixTest.Case
@@ -7,207 +11,179 @@ defmodule Mix.Tasks.App.StartTest do
     def project do
       [app: :app_start_sample, version: "0.1.0"]
     end
-  end
 
-  defmodule WrongElixirProject do
-    def project do
-      [app: :error, version: "0.1.0", elixir: "~> 0.8.1"]
+    def application do
+      [applications: [:logger]]
     end
   end
 
-  defmodule InvalidElixirRequirement do
-    def project do
-      [app: :error, version: "0.1.0", elixir: "~> ~> 0.8.1"]
-    end
-  end
+  @moduletag :capture_log
 
-  setup config do
-    if app = config[:app] do
-      :error_logger.tty(false)
+  test "compiles and starts the project" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(AppStartSample)
 
-      on_exit fn ->
-        :application.stop(app)
-        :application.unload(app)
-        :error_logger.tty(true)
+      assert_raise Mix.Error, fn ->
+        Mix.Task.run("app.start", ["--no-compile"])
       end
-    end
 
-    :ok
-  end
+      refute List.keyfind(Application.started_applications(), :logger, 0)
+      Application.start(:logger)
 
-  test "recompiles project if elixir version changed" do
-    Mix.Project.push MixTest.Case.Sample
+      Mix.Task.reenable("app.config")
+      Mix.Task.reenable("app.start")
+      Mix.Task.run("app.start", ["--no-start"])
+      assert File.regular?("_build/dev/lib/app_start_sample/ebin/Elixir.A.beam")
+      assert File.regular?("_build/dev/lib/app_start_sample/ebin/app_start_sample.app")
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Compile.run []
-      purge [A, B, C]
+      refute Code.loaded?(A)
+      refute List.keyfind(Application.started_applications(), :app_start_sample, 0)
+      assert List.keyfind(Application.started_applications(), :logger, 0)
 
-      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
-      assert System.version == Mix.Dep.Lock.elixir_vsn
+      Mix.Task.reenable("app.config")
+      Mix.Task.reenable("app.start")
+      Mix.Task.run("app.start", [])
+      refute Code.loaded?(A)
+      assert List.keyfind(Application.started_applications(), :app_start_sample, 0)
+      assert List.keyfind(Application.started_applications(), :logger, 0)
+    end)
+  after
+    Application.stop(:app_start_sample)
+  end
 
-      Mix.Task.clear
-      File.write!("_build/dev/lib/sample/.compile.lock", "the_past")
-      File.touch!("_build/dev/lib/sample/.compile.lock", {{2010, 1, 1}, {0, 0, 0}})
+  describe "unit tests" do
+    test "start does nothing if no apps are given" do
+      assert Mix.Tasks.App.Start.start([], :temporary, :serial) == :ok
+    end
 
-      Mix.Tasks.App.Start.run ["--no-start"]
-      assert System.version == Mix.Dep.Lock.elixir_vsn
-      assert File.stat!("_build/dev/lib/sample/.compile.lock").mtime > {{2010, 1, 1}, {0, 0, 0}}
+    test "allows type to be configured" do
+      assert Mix.Tasks.App.Start.type([], permanent: true) == :permanent
+      assert Mix.Tasks.App.Start.type([], temporary: true) == :temporary
+      assert Mix.Tasks.App.Start.type([start_permanent: true], []) == :permanent
+      assert Mix.Tasks.App.Start.type([], []) == :temporary
     end
-  end
 
-  test "compiles and starts the project" do
-    Mix.Project.push AppStartSample
+    defmodule ReturnSample do
+      def project do
+        [app: :return_sample, version: "0.1.0"]
+      end
 
-    in_fixture "no_mixfile", fn ->
-      assert_raise Mix.Error, fn ->
-        Mix.Tasks.App.Start.run ["--no-compile"]
+      def application do
+        Process.get(:application_definition)
       end
+    end
 
-      Mix.Tasks.App.Start.run ["--no-start"]
-      assert File.regular?("_build/dev/lib/app_start_sample/ebin/Elixir.A.beam")
-      assert File.regular?("_build/dev/lib/app_start_sample/ebin/app_start_sample.app")
-      refute List.keyfind(:application.loaded_applications, :app_start_sample, 0)
+    defmodule ReturnApp do
+      use Application
 
-      Mix.Tasks.App.Start.run []
-      assert List.keyfind(:application.loaded_applications, :app_start_sample, 0)
+      def start(_type, return), do: return
     end
-  end
 
-  test "validates the Elixir version requirement" do
-    Mix.Project.push WrongElixirProject
+    test "start points to report on error", context do
+      in_tmp(context.test, fn ->
+        Mix.Project.push(ReturnSample)
 
-    in_fixture "no_mixfile", fn ->
-      assert_raise Mix.ElixirVersionError, ~r/You're trying to run :error on Elixir/, fn ->
-        Mix.Tasks.App.Start.run ["--no-start"]
-      end
-    end
-  end
+        Process.put(:application_definition, mod: {ReturnApp, {:error, :bye}})
+        Mix.Tasks.Compile.run([])
 
-  test "validates invalid Elixir version requirement" do
-    Mix.Project.push InvalidElixirRequirement
+        message =
+          "Could not start application return_sample: " <>
+            "Mix.Tasks.App.StartTest.ReturnApp.start(:normal, {:error, :bye}) " <>
+            "returned an error: :bye"
 
-    in_fixture "no_mixfile", fn ->
-      assert_raise  Mix.Error, ~r"Invalid Elixir version requirement", fn ->
-        Mix.Tasks.App.Start.run ["--no-start"]
-      end
+        assert_raise Mix.Error, message, fn ->
+          Mix.Tasks.App.Start.start([:return_sample], :temporary, :serial)
+        end
+      end)
     end
-  end
 
-  test "does not validate the Elixir version requirement when disabled" do
-    Mix.Project.push WrongElixirProject
+    test "start points to report on exception error", context do
+      in_tmp(context.test, fn ->
+        Mix.Project.push(ReturnSample)
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.App.Start.run ["--no-start", "--no-elixir-version-check"]
-    end
-  end
+        mod = {ReturnApp, {:error, {:badarg, [{ReturnApp, :start, 2, []}]}}}
+        Process.put(:application_definition, mod: mod)
+        Mix.Tasks.Compile.run([])
 
-  test "start does nothing if app is nil" do
-    assert Mix.Tasks.App.Start.start(nil) == :error
-  end
+        message =
+          "Could not start application return_sample: " <>
+            "Mix.Tasks.App.StartTest.ReturnApp.start(:normal, {:error, {:badarg, [{Mix.Tasks.App.StartTest.ReturnApp, :start, 2, []}]}}) " <>
+            "returned an error: an exception was raised:\n" <>
+            "    ** (ArgumentError) argument error\n" <>
+            "        Mix.Tasks.App.StartTest.ReturnApp.start/2"
 
-  defmodule ReturnSample do
-    def project do
-      [app: :return_sample, version: "0.1.0"]
+        assert_raise Mix.Error, message, fn ->
+          Mix.Tasks.App.Start.start([:return_sample], :temporary, :serial)
+        end
+      end)
     end
 
-    def application do
-      Process.get(:application_definition)
-    end
-  end
+    test "start points to report on bad return", context do
+      in_tmp(context.test, fn ->
+        Mix.Project.push(ReturnSample)
 
-  defmodule ReturnApp do
-    use Application
+        Process.put(:application_definition, mod: {ReturnApp, :bad})
+        Mix.Tasks.Compile.run([])
 
-    def start(_type, return), do: return
-  end
+        message =
+          "Could not start application return_sample: " <>
+            "Mix.Tasks.App.StartTest.ReturnApp.start(:normal, :bad) " <>
+            "returned a bad value: :bad"
 
-  @tag app: :return_sample
-  test "start points to report on error" do
-    Mix.Project.push ReturnSample
-    in_fixture "no_mixfile", fn ->
-      Process.put(:application_definition, mod: {ReturnApp, {:error, :bye}})
-      Mix.Tasks.Compile.run []
+        assert_raise Mix.Error, message, fn ->
+          Mix.Tasks.App.Start.start([:return_sample], :temporary, :serial)
+        end
+      end)
+    end
 
-      assert_raise Mix.Error, "Could not start application return_sample: Mix.Tasks.App.StartTest.ReturnApp.start(:normal, {:error, :bye}) returned an error: :bye",
-      fn ->
-        Mix.Tasks.App.Start.start(:return_sample)
+    defmodule ExitSample do
+      def project do
+        [app: :exit_sample, version: "0.1.0"]
       end
-    end
-  end
 
-  @tag app: :return_sample
-  test "start points to report on exception error" do
-    Mix.Project.push ReturnSample
-    in_fixture "no_mixfile", fn ->
-      Process.put(:application_definition, mod: {ReturnApp, {:error,
-          {:badarg, [{ReturnApp, :start, 2, []}] }}})
-      Mix.Tasks.Compile.run []
-
-      assert_raise Mix.Error, "Could not start application return_sample: Mix.Tasks.App.StartTest.ReturnApp.start(:normal, {:error, {:badarg, [{Mix.Tasks.App.StartTest.ReturnApp, :start, 2, []}]}}) returned an error: an exception was raised:\n" <>
-        "    ** (ArgumentError) argument error\n" <>
-        "        Mix.Tasks.App.StartTest.ReturnApp.start/2", fn ->
-      Mix.Tasks.App.Start.start(:return_sample)
+      def application do
+        Process.get(:application_definition)
       end
     end
-  end
 
-  @tag app: :return_sample
-  test "start points to report on bad return" do
-    Mix.Project.push ReturnSample
-    in_fixture "no_mixfile", fn ->
-      Process.put(:application_definition, mod: {ReturnApp, :bad})
-      Mix.Tasks.Compile.run []
+    defmodule ExitApp do
+      use Application
 
-      assert_raise Mix.Error, "Could not start application return_sample: Mix.Tasks.App.StartTest.ReturnApp.start(:normal, :bad) returned a bad value: :bad",
-      fn ->
-        Mix.Tasks.App.Start.start(:return_sample)
-      end
+      def start(_type, reason), do: exit(reason)
     end
-  end
 
-  defmodule ExitSample do
-    def project do
-      [app: :exit_sample, version: "0.1.0"]
-    end
+    test "start points to report on exit", context do
+      in_tmp(context.test, fn ->
+        Mix.Project.push(ExitSample)
 
-    def application do
-      Process.get(:application_definition)
+        Process.put(:application_definition, mod: {ExitApp, :bye})
+        Mix.Tasks.Compile.run([])
+
+        message =
+          "Could not start application exit_sample: exited in: " <>
+            "Mix.Tasks.App.StartTest.ExitApp.start(:normal, :bye)\n" <> "    ** (EXIT) :bye"
+
+        assert_raise Mix.Error, message, fn ->
+          Mix.Tasks.App.Start.start([:exit_sample], :temporary, :serial)
+        end
+      end)
     end
-  end
 
-  defmodule ExitApp do
-    use Application
+    test "start points to report on normal exit", context do
+      in_tmp(context.test, fn ->
+        Mix.Project.push(ExitSample)
 
-    def start(_type, reason), do: exit(reason)
-  end
+        Process.put(:application_definition, mod: {ExitApp, :normal})
+        Mix.Tasks.Compile.run([])
 
-  @tag app: :exit_sample
-  test "start points to report on exit" do
-    Mix.Project.push ExitSample
-    in_fixture "no_mixfile", fn ->
-      Process.put(:application_definition, mod: {ExitApp, :bye})
-      Mix.Tasks.Compile.run []
-
-      assert_raise Mix.Error, "Could not start application exit_sample: exited in: Mix.Tasks.App.StartTest.ExitApp.start(:normal, :bye)\n" <>
-      "    ** (EXIT) :bye",
-         fn ->
-        Mix.Tasks.App.Start.start(:exit_sample)
-      end
-    end
-  end
+        message =
+          "Could not start application exit_sample: exited in: " <>
+            "Mix.Tasks.App.StartTest.ExitApp.start(:normal, :normal)\n" <> "    ** (EXIT) normal"
 
-  @tag app: :exit_sample
-  test "start points to report on normal exit" do
-    Mix.Project.push ExitSample
-    in_fixture "no_mixfile", fn ->
-      Process.put(:application_definition, mod: {ExitApp, :normal})
-      Mix.Tasks.Compile.run []
-
-      assert_raise Mix.Error, "Could not start application exit_sample: exited in: Mix.Tasks.App.StartTest.ExitApp.start(:normal, :normal)\n" <>
-      "    ** (EXIT) normal",
-         fn ->
-        Mix.Tasks.App.Start.start(:exit_sample)
-      end
+        assert_raise Mix.Error, message, fn ->
+          Mix.Tasks.App.Start.start([:exit_sample], :temporary, :serial)
+        end
+      end)
     end
   end
 end
diff --git a/lib/mix/test/mix/tasks/app.tree_test.exs b/lib/mix/test/mix/tasks/app.tree_test.exs
new file mode 100644
index 00000000000..c3d933847c4
--- /dev/null
+++ b/lib/mix/test/mix/tasks/app.tree_test.exs
@@ -0,0 +1,156 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.App.TreeTest do
+  use MixTest.Case
+
+  defmodule AppDepsSample do
+    def project do
+      [app: :test, version: "0.1.0"]
+    end
+
+    def application do
+      [applications: [:logger, :app_deps_sample]]
+    end
+  end
+
+  @tag apps: [:test, :app_deps_sample, :app_deps2_sample, :app_deps3_sample, :app_deps4_sample]
+  test "shows the application tree", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(AppDepsSample)
+
+      load_apps()
+      Mix.Tasks.App.Tree.run(["--format", "pretty"])
+
+      assert_received {:mix_shell, :info, ["test"]}
+      assert_received {:mix_shell, :info, ["├── app_deps_sample"]}
+      assert_received {:mix_shell, :info, ["│   ├── app_deps2_sample"]}
+      assert_received {:mix_shell, :info, ["│   │   └── app_deps4_sample (included)"]}
+      assert_received {:mix_shell, :info, ["│   └── app_deps3_sample"]}
+      assert_received {:mix_shell, :info, ["├── elixir"]}
+      assert_received {:mix_shell, :info, ["└── logger"]}
+      assert_received {:mix_shell, :info, ["    └── elixir"]}
+    end)
+  end
+
+  @tag apps: [:foo, :bar]
+  test "show the application tree for umbrella apps" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Task.run("app.tree", ["--format", "pretty"])
+        assert_received {:mix_shell, :info, ["├── elixir"]}
+        assert_received {:mix_shell, :info, ["foo"]}
+        assert_received {:mix_shell, :info, ["    └── elixir"]}
+      end)
+    end)
+  end
+
+  @tag apps: [:test, :app_deps_sample, :app_deps2_sample, :app_deps3_sample, :app_deps4_sample]
+  test "shows the application tree with optional apps", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(AppDepsSample)
+
+      load_apps([:app_deps2_sample])
+      Mix.Tasks.App.Tree.run(["--format", "pretty"])
+      assert_received {:mix_shell, :info, ["test"]}
+      assert_received {:mix_shell, :info, ["├── app_deps_sample"]}
+      assert_received {:mix_shell, :info, ["│   ├── app_deps2_sample (optional)"]}
+      assert_received {:mix_shell, :info, ["│   │   └── app_deps4_sample (included)"]}
+      assert_received {:mix_shell, :info, ["│   └── app_deps3_sample"]}
+      assert_received {:mix_shell, :info, ["├── elixir"]}
+      assert_received {:mix_shell, :info, ["└── logger"]}
+      assert_received {:mix_shell, :info, ["    └── elixir"]}
+
+      Application.unload(:app_deps2_sample)
+      Mix.Tasks.App.Tree.run(["--format", "pretty"])
+      assert_received {:mix_shell, :info, ["test"]}
+      assert_received {:mix_shell, :info, ["├── app_deps_sample"]}
+      assert_received {:mix_shell, :info, ["│   ├── app_deps2_sample (optional - missing)"]}
+      assert_received {:mix_shell, :info, ["│   └── app_deps3_sample"]}
+      assert_received {:mix_shell, :info, ["├── elixir"]}
+      assert_received {:mix_shell, :info, ["└── logger"]}
+      assert_received {:mix_shell, :info, ["    └── elixir"]}
+    end)
+  end
+
+  @tag apps: [:test, :app_deps_sample, :app_deps2_sample, :app_deps3_sample, :app_deps4_sample]
+  test "shows the given application tree", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(AppDepsSample)
+
+      assert_raise Mix.Error, "could not find application app_deps_sample", fn ->
+        Mix.Tasks.App.Tree.run(["--format", "pretty", "app_deps_sample"])
+      end
+
+      load_apps()
+      Mix.Tasks.App.Tree.run(["--format", "pretty", "app_deps_sample"])
+
+      assert_received {:mix_shell, :info, ["app_deps_sample"]}
+      assert_received {:mix_shell, :info, ["├── app_deps2_sample"]}
+      assert_received {:mix_shell, :info, ["│   └── app_deps4_sample (included)"]}
+      assert_received {:mix_shell, :info, ["└── app_deps3_sample"]}
+    end)
+  end
+
+  @tag apps: [:test, :app_deps_sample, :app_deps2_sample, :app_deps3_sample, :app_deps4_sample]
+  test "shows the application dependency tree excluding applications", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(AppDepsSample)
+
+      load_apps()
+
+      exclude = ["--exclude", "app_deps4_sample", "--exclude", "app_deps3_sample"]
+      Mix.Tasks.App.Tree.run(["--format", "pretty" | exclude])
+
+      assert_received {:mix_shell, :info, ["test"]}
+      assert_received {:mix_shell, :info, ["├── app_deps_sample"]}
+      assert_received {:mix_shell, :info, ["│   └── app_deps2_sample"]}
+      assert_received {:mix_shell, :info, ["├── elixir"]}
+      assert_received {:mix_shell, :info, ["└── logger"]}
+      assert_received {:mix_shell, :info, ["    └── elixir"]}
+    end)
+  end
+
+  @tag apps: [:test, :app_deps_sample, :app_deps2_sample, :app_deps3_sample, :app_deps4_sample]
+  test "shows the application tree in dot form", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(AppDepsSample)
+
+      load_apps()
+      Mix.Tasks.App.Tree.run(["--format", "dot"])
+
+      assert File.read!("app_tree.dot") == """
+             digraph "application tree" {
+               "test"
+               "test" -> "app_deps_sample"
+               "app_deps_sample" -> "app_deps2_sample"
+               "app_deps2_sample" -> "app_deps4_sample" [label="(included)"]
+               "app_deps_sample" -> "app_deps3_sample"
+               "test" -> "elixir"
+               "test" -> "logger"
+               "logger" -> "elixir"
+             }
+             """
+    end)
+  end
+
+  defp load_apps(optional_apps \\ []) do
+    :ok = :application.load({:application, :app_deps4_sample, [vsn: ~c"1.0.0", env: []]})
+    :ok = :application.load({:application, :app_deps3_sample, [vsn: ~c"1.0.0", env: []]})
+
+    opts = [vsn: ~c"1.0.0", env: [], included_applications: [:app_deps4_sample]]
+    :ok = :application.load({:application, :app_deps2_sample, opts})
+
+    opts = [
+      vsn: ~c"1.0.0",
+      env: [],
+      applications: [:app_deps2_sample, :app_deps3_sample],
+      optional_applications: optional_apps
+    ]
+
+    :ok = :application.load({:application, :app_deps_sample, opts})
+  end
+end
diff --git a/lib/mix/test/mix/tasks/archive_test.exs b/lib/mix/test/mix/tasks/archive_test.exs
new file mode 100644
index 00000000000..88c306051aa
--- /dev/null
+++ b/lib/mix/test/mix/tasks/archive_test.exs
@@ -0,0 +1,321 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.ArchiveTest do
+  use MixTest.Case
+
+  defmodule ArchiveProject do
+    def project do
+      [app: :archive, version: "0.1.0", elixir: "~> 0.1.0"]
+    end
+  end
+
+  defmodule ArchiveProject2 do
+    def project do
+      [app: :archive, version: "0.2.0"]
+    end
+  end
+
+  setup do
+    File.rm_rf!(tmp_path("userhome"))
+    System.put_env("MIX_ARCHIVES", tmp_path("userhome/.mix/archives/"))
+    Mix.Project.push(ArchiveProject)
+
+    on_exit(fn ->
+      Mix.Local.remove_archives()
+      System.delete_env("MIX_ARCHIVES")
+    end)
+  end
+
+  test "archive build" do
+    in_fixture("archive", fn ->
+      Mix.Tasks.Archive.Build.run(["--no-elixir-version-check"])
+      message = "Generated archive \"archive-0.1.0.ez\" with MIX_ENV=dev"
+      assert_received {:mix_shell, :info, [^message]}
+      assert File.regular?(~c"archive-0.1.0.ez")
+      assert to_charlist(Mix.Project.consolidation_path()) not in :code.get_path()
+
+      assert_archive_content_default()
+      refute has_in_zip_file?(~c"archive-0.1.0.ez", ~c"archive-0.1.0/priv/.dot_file")
+    end)
+  end
+
+  test "archive build with include-dot-files" do
+    in_fixture("archive", fn ->
+      Mix.Tasks.Archive.Build.run(["--no-elixir-version-check", "--include-dot-files"])
+      message = "Generated archive \"archive-0.1.0.ez\" with MIX_ENV=dev"
+      assert_received {:mix_shell, :info, [^message]}
+      assert File.regular?(~c"archive-0.1.0.ez")
+
+      assert_archive_content_default()
+      assert has_in_zip_file?(~c"archive-0.1.0.ez", ~c"archive-0.1.0/priv/.dot_file")
+    end)
+  end
+
+  def assert_archive_content_default() do
+    assert File.regular?(~c"archive-0.1.0.ez")
+    assert has_in_zip_file?(~c"archive-0.1.0.ez", ~c"archive-0.1.0/.elixir")
+    assert has_in_zip_file?(~c"archive-0.1.0.ez", ~c"archive-0.1.0/priv/not_really_an.so")
+
+    assert has_in_zip_file?(
+             ~c"archive-0.1.0.ez",
+             ~c"archive-0.1.0/ebin/Elixir.Mix.Tasks.Local.Sample.beam"
+           )
+
+    assert has_in_zip_file?(~c"archive-0.1.0.ez", ~c"archive-0.1.0/ebin/archive.app")
+  end
+
+  test "archive install" do
+    in_fixture("archive", fn ->
+      # Build and install archive
+      Mix.Tasks.Archive.Build.run(["--no-elixir-version-check"])
+
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Archive.Install.run([])
+      refute File.regular?(tmp_path("userhome/.mix/archives/archive-0.1.0.ez"))
+      assert File.dir?(tmp_path("userhome/.mix/archives/archive-0.1.0/archive-0.1.0/ebin"))
+
+      # Check that the version warning is printed after installation
+      version_error =
+        "warning: the archive archive-0.1.0 requires Elixir \"~> 0.1.0\" " <>
+          "but you are running on v#{System.version()}"
+
+      assert_received {:mix_shell, :error, [^version_error]}
+
+      archive = tmp_path("userhome/.mix/archives/archive-0.1.0/archive-0.1.0/ebin")
+      assert to_charlist(archive) in :code.get_path()
+
+      # Loading the archive should emit warning again
+      Mix.Local.append_archives()
+      assert_received {:mix_shell, :error, [^version_error]}
+
+      # List archive
+      Mix.Tasks.Local.run([])
+      info = "mix local.sample # A local install sample"
+      assert_received {:mix_shell, :info, [^info]}
+
+      Mix.Tasks.Archive.run([])
+      assert_received {:mix_shell, :info, ["* archive-0.1.0"]}
+
+      # Run archived task
+      Mix.Task.run("local.sample")
+      assert_received {:mix_shell, :info, ["sample"]}
+    end)
+  end
+
+  test "archive install invalid file" do
+    in_fixture("archive", fn ->
+      file_name = "invalid-archive-0.1.0.ez"
+      assert File.regular?(file_name)
+
+      send(self(), {:mix_shell_input, :yes?, true})
+
+      assert_raise Mix.Error, ~r/invalid archive file/, fn ->
+        Mix.Tasks.Archive.Install.run([file_name])
+      end
+    end)
+  end
+
+  test "archive install missing file" do
+    message = ~r[Expected "./unlikely-to-exist-0.1.0.ez" to be a local file path]
+
+    assert_raise Mix.Error, message, fn ->
+      Mix.Tasks.Archive.Install.run(["./unlikely-to-exist-0.1.0.ez"])
+    end
+  end
+
+  test "archive install --force" do
+    in_fixture("archive", fn ->
+      Mix.Tasks.Archive.Build.run(["--no-elixir-version-check"])
+      Mix.Tasks.Archive.Install.run(["--force"])
+
+      message = "Generated archive \"archive-0.1.0.ez\" with MIX_ENV=dev"
+      assert_received {:mix_shell, :info, [^message]}
+
+      Mix.Tasks.Archive.Uninstall.run(["archive-0.1.0", "--force"])
+      refute File.dir?(tmp_path("userhome/.mix/archives/archive-0.1.0/archive-0.1.0/ebin"))
+    end)
+  end
+
+  @compile {:no_warn_undefined, GitRepo.Archive}
+  test "archive.install from Git" do
+    in_fixture("git_repo", fn ->
+      File.mkdir_p!("config")
+
+      File.write!("config/config.exs", """
+      import Config
+      config :git_repo, :archive_config, true
+      """)
+
+      File.write!("lib/git_repo.ex", """
+      require Application
+      true = Application.compile_env!(:git_repo, :archive_config)
+
+      defmodule GitRepo.Archive do
+        @compile {:autoload, true}
+
+        def hello do
+          "World"
+        end
+      end
+      """)
+
+      System.cmd("git", ~w[init])
+      System.cmd("git", ~w[add .])
+      System.cmd("git", ~w[commit -m first-commit])
+
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Archive.Install.run(["git", File.cwd!()])
+      assert GitRepo.Archive.hello() == "World"
+
+      message = "Generated archive \"git_repo-0.1.0.ez\" with MIX_ENV=prod"
+      assert_received {:mix_shell, :info, [^message]}
+
+      refute File.regular?(tmp_path("userhome/.mix/archives/git_repo-0.1.0.ez"))
+      assert File.dir?(tmp_path("userhome/.mix/archives/git_repo-0.1.0/git_repo-0.1.0/ebin"))
+    end)
+  after
+    purge([GitRepo.Archive, GitRepo.MixProject, Mix.Local.Installer.MixProject])
+  end
+
+  test "archive install, update, and uninstall life cycle" do
+    in_fixture("archive", fn ->
+      # Install previous version
+      Mix.Tasks.Archive.Build.run(["--no-elixir-version-check"])
+      assert File.regular?("archive-0.1.0.ez")
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Archive.Install.run([])
+      assert_received {:mix_shell, :error, [_]}
+
+      # Build new version
+      Mix.Project.push(ArchiveProject2)
+      Mix.Tasks.Archive.Build.run(["--no-compile"])
+      assert File.regular?("archive-0.2.0.ez")
+
+      message = "Generated archive \"archive-0.2.0.ez\" with MIX_ENV=dev"
+      assert_received {:mix_shell, :info, [^message]}
+
+      # Install new version
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Archive.Install.run([])
+      refute File.regular?(tmp_path("userhome/.mix/archives/archive-0.2.0.ez"))
+      assert File.dir?(tmp_path("userhome/.mix/archives/archive-0.2.0/archive-0.2.0/ebin"))
+
+      # Re-install current version should not change system
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Archive.Install.run([])
+      refute File.regular?(tmp_path("userhome/.mix/archives/archive-0.2.0.ez"))
+      assert File.dir?(tmp_path("userhome/.mix/archives/archive-0.2.0/archive-0.2.0/ebin"))
+
+      # Try to install a missing version does not remove archive
+      assert_raise Mix.Error, fn ->
+        Mix.Tasks.Archive.Install.run(["./archive-0.0.0.ez"])
+      end
+
+      assert File.dir?(tmp_path("userhome/.mix/archives/archive-0.2.0/archive-0.2.0/ebin"))
+      refute File.regular?(tmp_path("userhome/.mix/archives/archive-0.1.0.ez"))
+
+      # Load archive without warnings because there is no :elixir requirement in mix.exs
+      Mix.Local.append_archives()
+      refute_received {:mix_shell, :error, [_]}
+
+      # Check uninstall confirmation
+      send(self(), {:mix_shell_input, :yes?, false})
+      Mix.Tasks.Archive.Uninstall.run(["archive-0.2.0"])
+      assert File.dir?(tmp_path("userhome/.mix/archives/archive-0.2.0/archive-0.2.0/ebin"))
+
+      # Remove it!
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Archive.Uninstall.run(["archive-0.2.0"])
+      refute File.dir?(tmp_path("userhome/.mix/archives/archive-0.2.0/archive-0.2.0/ebin"))
+
+      # Check old paths are unloaded
+      paths = Enum.map(:code.get_path(), &List.to_string/1)
+      refute tmp_path("userhome/.mix/archives/archive-0.1.0/archive-0.1.0/ebin") in paths
+    end)
+  end
+
+  test "archive uninstall without version" do
+    in_fixture("archive", fn ->
+      Mix.Tasks.Archive.Build.run(["--no-elixir-version-check"])
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Archive.Install.run([])
+
+      send(self(), {:mix_shell_input, :yes?, false})
+      Mix.Tasks.Archive.Uninstall.run(["archive"])
+      assert File.dir?(tmp_path("userhome/.mix/archives/archive-0.1.0/archive-0.1.0/ebin"))
+
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Archive.Uninstall.run(["archive"])
+      refute File.dir?(tmp_path("userhome/.mix/archives/archive-0.1.0/archive-0.1.0/ebin"))
+    end)
+  end
+
+  test "archive checksum" do
+    in_fixture("archive", fn ->
+      Mix.Tasks.Archive.Build.run(["--no-elixir-version-check"])
+      assert File.regular?("archive-0.1.0.ez")
+      send(self(), {:mix_shell_input, :yes?, true})
+
+      # Install with wrong checksum
+      assert_raise Mix.Error, ~r"Data does not match the given SHA-512 checksum", fn ->
+        send(self(), {:mix_shell_input, :yes?, true})
+        Mix.Tasks.Archive.Install.run(["--sha512", "wrong"])
+      end
+
+      # Install with correct checksum
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Archive.Install.run(["--sha512", sha512("archive-0.1.0.ez")])
+      refute File.regular?(tmp_path("userhome/.mix/archives/archive-0.1.0.ez"))
+      assert File.dir?(tmp_path("userhome/.mix/archives/archive-0.1.0/archive-0.1.0/ebin"))
+    end)
+  end
+
+  test "archive check" do
+    # Install the archive
+    in_fixture("archive", fn ->
+      Mix.Tasks.Archive.Build.run(["--no-elixir-version-check"])
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Archive.Install.run([])
+      Application.unload(:archive)
+    end)
+
+    assert_raise Mix.Error, ~r/Expected archive to be in the format/, fn ->
+      archive_check([:archive])
+    end
+
+    assert_raise Mix.Error, ~r/Archive "archive" could not be found/, fn ->
+      archive_check([{:archive, ">= 1.0.0"}])
+    end
+
+    # Load the archive
+    Mix.Local.append_archives()
+
+    message = ~r/Archive \"archive-0.1.0\" does not match requirement >= 1.0.0/
+
+    assert_raise Mix.Error, message, fn ->
+      archive_check([{:archive, ">= 1.0.0"}])
+    end
+
+    archive_check([{:archive, ">= 0.0.0"}])
+  end
+
+  defp archive_check(archives) do
+    Mix.Project.pop()
+    Mix.ProjectStack.post_config(archives: archives)
+    Mix.Project.push(MixTest.Case.Sample)
+    Mix.Tasks.Archive.Check.run([])
+  end
+
+  defp sha512(file) do
+    Base.encode16(:crypto.hash(:sha512, File.read!(file)), case: :lower)
+  end
+
+  defp has_in_zip_file?(archive, name) do
+    {:ok, files} = :zip.list_dir(archive)
+    Enum.find(files, &match?({:zip_file, ^name, _, _, _, _}, &1))
+  end
+end
diff --git a/lib/mix/test/mix/tasks/clean_test.exs b/lib/mix/test/mix/tasks/clean_test.exs
index a0efb4565da..3af7d79328f 100644
--- a/lib/mix/test/mix/tasks/clean_test.exs
+++ b/lib/mix/test/mix/tasks/clean_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.CleanTest do
   use MixTest.Case
@@ -16,42 +20,69 @@ defmodule Mix.Tasks.CleanTest do
     end
   end
 
-  setup do
-    Mix.Project.push Sample
-    :ok
-  end
+  test "cleans the application build" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(Sample)
 
-  test "removes the build application" do
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Compile.run ["--no-deps"]
-      assert File.exists?("_build/dev/lib/sample")
+      File.mkdir_p!("_build/dev/lib/sample/consolidated")
+      File.mkdir_p!("_build/dev/lib/sample")
+      File.mkdir_p!("_build/test/lib/sample")
+      File.mkdir_p!("_build/dev/lib/ok")
 
-      Mix.Tasks.Clean.run []
+      Mix.Tasks.Clean.run([])
+      refute File.exists?("_build/dev/lib/sample/consolidated")
       refute File.exists?("_build/dev/lib/sample")
-    end
+      refute File.exists?("_build/test/lib/sample")
+      assert File.exists?("_build/dev/lib/ok")
+    end)
   end
 
-  test "cleans deps" do
-    in_fixture "deps_status", fn ->
-      assert File.exists?("_build/dev/lib/ok")
-      Mix.Tasks.Clean.run ["--all"]
+  test "cleans dependencies build" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(Sample)
+
+      File.mkdir_p!("_build/dev/lib/ok")
+      File.mkdir_p!("_build/test/lib/ok")
 
+      Mix.Tasks.Clean.run(["--deps", "--only", "dev"])
       refute File.exists?("_build/dev")
-      assert_received {:mix_shell, :info, ["* Cleaning ok"]}
+      assert File.exists?("_build/test")
 
-      # Assert we don't choke on unfetched deps
-      assert_received {:mix_shell, :info, ["* Cleaning unknown"]}
-    end
+      Mix.Tasks.Clean.run(["--deps"])
+      refute File.exists?("_build/test")
+    end)
   end
 
-  test "cleans all deps and builds" do
-    in_fixture "deps_status", fn ->
-      assert File.exists?("_build/dev/lib/ok")
-      Mix.Tasks.Clean.run ["--all"]
+  test "invokes compiler hook defined in project" do
+    Mix.ProjectStack.post_config(compilers: Mix.compilers() ++ [:testc])
 
-      refute File.exists?("_build")
-      assert_received {:mix_shell, :info, ["* Cleaning ok"]}
-      assert_received {:mix_shell, :info, ["* Cleaning unknown"]}
-    end
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/testc.ex", """
+      defmodule Mix.Tasks.Compile.Testc do
+        use Mix.Task.Compiler
+
+        @impl true
+        def run(_args) do
+          Mix.shell().info("Compiling...")
+          :ok
+        end
+
+        @impl true
+        def clean do
+          Mix.shell().info("Cleaning...")
+          :ok
+        end
+      end
+      """)
+
+      Mix.Task.run("compile")
+      assert_received {:mix_shell, :info, ["Compiling..."]}
+      purge([Mix.Tasks.Compile.Testc])
+
+      Mix.Task.run("clean")
+      assert_received {:mix_shell, :info, ["Cleaning..."]}
+    end)
   end
 end
diff --git a/lib/mix/test/mix/tasks/cmd_test.exs b/lib/mix/test/mix/tasks/cmd_test.exs
index db4bf069213..3124ca99008 100644
--- a/lib/mix/test/mix/tasks/cmd_test.exs
+++ b/lib/mix/test/mix/tasks/cmd_test.exs
@@ -1,18 +1,91 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.CmdTest do
   use MixTest.Case
 
+  test "can be called multiple times" do
+    Mix.Task.run("cmd", ["echo", "hello"])
+    assert_received {:mix_shell, :run, ["hello\n"]}
+    Mix.Task.run("cmd", ["echo", "hello world"])
+    assert_received {:mix_shell, :run, ["hello world\n"]}
+  end
+
+  test "can be invoked as a shell" do
+    nl = os_newline()
+    Mix.Task.run("cmd", ["--shell", "echo", "hello"])
+    assert_received {:mix_shell, :run, ["hello" <> ^nl]}
+  end
+
+  @tag :unix
+  test "supports relative paths" do
+    in_tmp("cmd-relative", fn ->
+      File.mkdir_p!("priv")
+      File.write!("priv/world.sh", "#!/bin/sh\necho world")
+      File.chmod!("priv/world.sh", 0o755)
+
+      Mix.Task.run("cmd", ["priv/world.sh"])
+      assert_received {:mix_shell, :run, ["world\n"]}
+
+      Mix.Task.run("cmd", ["--cd", "priv", "./world.sh"])
+      assert_received {:mix_shell, :run, ["world\n"]}
+    end)
+  end
+
   test "runs the command for each app" do
-    in_fixture "umbrella_dep/deps/umbrella", fn ->
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
       Mix.Project.in_project(:umbrella, ".", fn _ ->
-        Mix.Task.run "cmd", ["echo", "hello"]
-        nl = os_newline
+        Mix.Task.run("cmd", ["echo", "hello"])
         assert_received {:mix_shell, :info, ["==> bar"]}
-        assert_received {:mix_shell, :run, ["hello" <> ^nl]}
+        assert_received {:mix_shell, :run, ["hello\n"]}
         assert_received {:mix_shell, :info, ["==> foo"]}
-        assert_received {:mix_shell, :run, ["hello" <> ^nl]}
+        assert_received {:mix_shell, :run, ["hello\n"]}
+      end)
+    end)
+  end
+
+  test "runs the command for a single app specified by app flag" do
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      in_fixture("umbrella_dep/deps/umbrella", fn ->
+        Mix.Project.in_project(:umbrella, ".", fn _ ->
+          Mix.Task.run("cmd", ["--app", "bar", "echo", "hello"])
+          assert_received {:mix_shell, :info, ["==> bar"]}
+          assert_received {:mix_shell, :run, ["hello\n"]}
+          refute_received {:mix_shell, :info, ["==> foo"]}
+          refute_received {:mix_shell, :run, ["hello\n"]}
+        end)
+      end)
+    end)
+  end
+
+  test "runs the command for each app specified by app flag" do
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      in_fixture("umbrella_dep/deps/umbrella", fn ->
+        Mix.Project.in_project(:umbrella, ".", fn _ ->
+          Mix.Task.run("cmd", ["--app", "bar", "--app", "foo", "echo", "hello"])
+          assert_received {:mix_shell, :info, ["==> bar"]}
+          assert_received {:mix_shell, :run, ["hello\n"]}
+          assert_received {:mix_shell, :info, ["==> foo"]}
+          assert_received {:mix_shell, :run, ["hello\n"]}
+        end)
+      end)
+    end)
+  end
+
+  test "only runs the cmd for specified apps and in specific directory" do
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      in_fixture("umbrella_dep/deps/umbrella", fn ->
+        Mix.Project.in_project(:umbrella, ".", fn _ ->
+          Mix.Task.run("cmd", ["--app", "bar", "--cd", "lib", "pwd"])
+          assert_received {:mix_shell, :info, ["==> bar"]}
+          {pwd, 0} = System.cmd("pwd", [], cd: Path.join(["apps", "bar", "lib"]))
+          assert_received {:mix_shell, :run, [^pwd]}
+          refute_received {:mix_shell, :info, ["==> foo"]}
+        end)
       end)
-    end
+    end)
   end
 end
diff --git a/lib/mix/test/mix/tasks/compile.app_test.exs b/lib/mix/test/mix/tasks/compile.app_test.exs
index 3f15c13da74..cf488538f40 100644
--- a/lib/mix/test/mix/tasks/compile.app_test.exs
+++ b/lib/mix/test/mix/tasks/compile.app_test.exs
@@ -1,35 +1,49 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.Compile.AppTest do
   use MixTest.Case
 
-  defmodule CustomProject do
+  defmodule CustomDeps do
     def project do
-      [app: :custom_project, version: "0.2.0"]
+      [app: :custom_deps, version: "0.2.0", deps: deps()]
     end
 
     def application do
-      [maxT: :infinity,
-       applications: [:example_app]]
+      [extra_applications: [:logger], included_applications: [:ok9]]
+    end
+
+    def deps do
+      [
+        {:ok1, path: "../ok"},
+        {:ok2, path: "../ok", only: :prod},
+        {:ok3, path: "../ok", only: :dev},
+        {:ok4, path: "../ok", runtime: true},
+        {:ok5, path: "../ok", runtime: false},
+        {:ok6, path: "../ok", optional: true},
+        {:ok7, path: "../ok", optional: false},
+        {:ok8, path: "../ok", app: false},
+        {:ok9, path: "../ok"},
+        {:ok10, path: "../ok", targets: [:will_never_be_listed]},
+        {:ok11, path: "../ok", targets: [Mix.target()]}
+      ]
     end
   end
 
-  defmodule InvalidProject do
+  defmodule CustomProject do
     def project do
-      [app: :invalid_project, version: "0.3.0"]
+      [
+        app: :custom_project,
+        version: "0.3.0",
+        description: "Some UTF-8 dëscriptión"
+      ]
     end
 
     def application do
-      case Process.get(:error) do
-        :modules -> [modules: :invalid]
-        :maxT -> [maxT: :invalid]
-        :registered -> [registered: ["invalid"]]
-        :included_applications -> [included_applications: ["invalid"]]
-        :applications -> [applications: ["invalid"]]
-        :env -> [env: [:a]]
-        :mod -> [mod: {Mod}]
-        :start_phases -> [start_phases: [:invalid]]
-      end
+      Process.get(:application)
     end
   end
 
@@ -40,73 +54,265 @@ defmodule Mix.Tasks.Compile.AppTest do
   end
 
   test "generates .app file when changes happen" do
-    Mix.Project.push MixTest.Case.Sample
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
 
-    in_fixture "no_mixfile", fn ->
       Mix.Tasks.Compile.Elixir.run([])
-      assert Mix.Tasks.Compile.App.run([]) == :ok
+      assert Mix.Tasks.Compile.App.run([]) == {:ok, []}
 
-      contents = File.read!("_build/dev/lib/sample/ebin/sample.app")
-      assert contents =~ "{application,sample"
-      assert contents =~ "0.1.0"
-      assert contents =~ "'Elixir.A'"
-      assert contents =~ "{applications,[kernel,stdlib,elixir]}"
+      properties = parse_resource_file(:sample)
+      assert Application.spec(:sample, :vsn) == ~c"0.1.0"
+      assert properties[:vsn] == ~c"0.1.0"
+      assert properties[:modules] == [A, B]
+      assert properties[:applications] == [:kernel, :stdlib, :elixir]
+      refute Keyword.has_key?(properties, :compile_env)
 
-      assert Mix.Tasks.Compile.App.run([]) == :noop
-    end
+      Application.unload(:sample)
+      assert Mix.Tasks.Compile.App.run([]) == {:noop, []}
+      assert Application.spec(:sample, :vsn) == ~c"0.1.0"
+    end)
   end
 
-  test "use custom application settings" do
-    Mix.Project.push CustomProject
+  test "generates .app file with compile_env" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.mkdir_p!("config")
+      File.write!("config/config.exs", "[]")
+      Mix.Task.run("loadconfig")
+
+      reset_config = fn ->
+        Mix.ProjectStack.reset_config_mtime()
+        ensure_touched("config/config.exs", "_build/dev/lib/sample/ebin/sample.app")
+      end
+
+      Mix.ProjectStack.compile_env([{:app, :key, :error}])
+      assert Mix.Tasks.Compile.App.run([]) == {:ok, []}
+      assert parse_resource_file(:sample)[:compile_env] == [{:app, :key, :error}]
+
+      # No-op with untouched unset compile_env
+      reset_config.()
+      assert Mix.Tasks.Compile.App.run([]) == {:ok, []}
+      assert parse_resource_file(:sample)[:compile_env] == [{:app, :key, :error}]
+
+      # Recompiles with new compile_env
+      reset_config.()
+      Mix.ProjectStack.compile_env([{:app, :another, :error}])
+      assert Mix.Tasks.Compile.App.run([]) == {:ok, []}
+      assert parse_resource_file(:sample)[:compile_env] == [{:app, :another, :error}]
+
+      # Keeps compile_env if forcing
+      reset_config.()
+      assert Mix.Tasks.Compile.App.run(["--force"]) == {:ok, []}
+      assert parse_resource_file(:sample)[:compile_env] == [{:app, :another, :error}]
+    end)
+  end
+
+  test "uses custom application settings" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(CustomProject)
+      env = [foo: [:one, "two", 3, 4, "฿", &List.flatten/1], bar: [{} | %{foo: :bar}]]
+
+      Process.put(:application,
+        maxT: :infinity,
+        applications: [:example_app, mix: :optional],
+        extra_applications: [:logger, ex_unit: :optional],
+        env: env
+      )
 
-    in_fixture "no_mixfile", fn ->
       Mix.Tasks.Compile.Elixir.run([])
       Mix.Tasks.Compile.App.run([])
-      contents = File.read!("_build/dev/lib/custom_project/ebin/custom_project.app")
-      assert contents =~ "0.2.0"
-      assert contents =~ "{maxT,infinity}"
-      assert contents =~ "{applications,[kernel,stdlib,elixir,example_app]}"
-    end
+
+      properties = parse_resource_file(:custom_project)
+      assert Application.spec(:custom_project, :vsn) == ~c"0.3.0"
+      assert properties[:vsn] == ~c"0.3.0"
+      assert properties[:maxT] == :infinity
+      assert properties[:optional_applications] == [:ex_unit, :mix]
+      assert properties[:description] == ~c"Some UTF-8 dëscriptión"
+
+      assert properties[:applications] ==
+               [:kernel, :stdlib, :elixir, :logger, :ex_unit, :example_app, :mix]
+
+      assert properties[:env] == [
+               foo: [:one, "two", 3, 4, "฿", &List.flatten/1],
+               bar: [{} | %{foo: :bar}]
+             ]
+
+      refute Keyword.has_key?(properties, :extra_applications)
+    end)
   end
 
-  test "application properties validation" do
-    Mix.Project.push InvalidProject
+  test "infers applications" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(CustomDeps)
+
+      Mix.Tasks.Compile.Elixir.run([])
+      Mix.Tasks.Compile.App.run([])
 
-    in_fixture "no_mixfile", fn ->
-      for error <- [:modules, :maxT, :registered, :included_applications,
-                    :applications, :env, :mod, :start_phases] do
-        Process.put(:error, error)
+      properties = parse_resource_file(:custom_deps)
 
-        assert_raise Mix.Error, ~r/:#{error}/, fn ->
-          Mix.Tasks.Compile.App.run([])
-        end
+      assert properties[:applications] ==
+               [:kernel, :stdlib, :elixir, :logger, :ok1, :ok3, :ok4, :ok6, :ok7, :ok11]
+
+      assert properties[:optional_applications] == [:ok6]
+    end)
+  end
+
+  test "validates properties" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(CustomProject)
+
+      Process.put(:application, [:not_a_keyword, applications: []])
+      message = "Application configuration returned from application/0 should be a keyword list"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
       end
-    end
+
+      Process.put(:application, modules: :invalid)
+      message = "Application modules (:modules) should be a list of atoms, got: :invalid"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, maxT: :invalid)
+      message = "Application maximum time (:maxT) is not an integer or :infinity, got: :invalid"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, registered: ["invalid"])
+
+      message =
+        "Application registered processes (:registered) should be a list of atoms, got: [\"invalid\"]"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, extra_applications: ["invalid"])
+
+      message =
+        "Application extra applications (:extra_applications) should be a list of atoms or {app, :required | :optional} pairs, got: [\"invalid\"]"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, included_applications: ["invalid"])
+
+      message =
+        "Application included applications (:included_applications) should be a list of atoms, got: [\"invalid\"]"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, applications: ["invalid"])
+
+      message =
+        "Application applications (:applications) should be a list of atoms or {app, :required | :optional} pairs, got: [\"invalid\"]"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, applications: nil)
+
+      message =
+        "Application applications (:applications) should be a list of atoms or {app, :required | :optional} pairs, got: nil"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, env: [:invalid])
+      message = "Application environment (:env) should be a keyword list, got: [:invalid]"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, mod: {Mod})
+
+      message =
+        "Application callback module (:mod) should be either [] or {module, start_args}, got: {Mod}"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, start_phases: [:invalid])
+
+      message =
+        "Application start phases (:start_phases) should be a keyword list, got: [:invalid]"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, env: [foo: make_ref()])
+
+      message =
+        ~r"\"def application\" has a term which cannot be written to \.app files: #Reference"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+    end)
+  end
+
+  @tag :re_import
+  test "accepts only regexes without a reference" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(CustomProject)
+      Process.put(:application, env: [regex: ~r/foo/])
+
+      assert_raise Mix.Error, ~r/you must use the \/E modifier to store regexes/, fn ->
+        Mix.Tasks.Compile.App.run([])
+      end
+
+      Process.put(:application, env: [exported: ~r/foo/E])
+      Mix.Tasks.Compile.Elixir.run([])
+      Mix.Tasks.Compile.App.run([])
+
+      properties = parse_resource_file(:custom_project)
+      assert properties[:env] == [exported: ~r/foo/E]
+    end)
   end
 
   test ".app contains description and registered (as required by systools)" do
-    Mix.Project.push MixTest.Case.Sample
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
 
-    in_fixture "no_mixfile", fn ->
       Mix.Tasks.Compile.Elixir.run([])
-      assert Mix.Tasks.Compile.App.run([]) == :ok
+      assert Mix.Tasks.Compile.App.run([]) == {:ok, []}
 
-      {:ok, [{_app, _, properties}]} = :file.consult("_build/dev/lib/sample/ebin/sample.app")
+      properties = parse_resource_file(:sample)
       assert properties[:registered] == []
-      assert properties[:description] == 'sample'
+      assert properties[:description] == ~c"sample"
       assert properties[:applications] == [:kernel, :stdlib, :elixir]
 
-      assert Mix.Tasks.Compile.App.run([]) == :noop
-    end
+      assert Mix.Tasks.Compile.App.run([]) == {:noop, []}
+    end)
   end
 
-  test "raise on invalid version" do
-    Mix.Project.push InvalidVsnProject
+  test "raises on invalid version" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(InvalidVsnProject)
+
+      message = ~r"Expected :version to be a valid Version, got: \"0.3\""
 
-    in_fixture "no_mixfile", fn ->
-      assert_raise Mix.Error, "Expected :version to be a SemVer version", fn ->
+      assert_raise Mix.Error, message, fn ->
         Mix.Tasks.Compile.App.run([])
       end
-    end
+    end)
+  end
+
+  defp parse_resource_file(app) do
+    {:ok, [term]} = :file.consult("_build/dev/lib/#{app}/ebin/#{app}.app")
+    {:application, ^app, properties} = term
+    properties
   end
 end
diff --git a/lib/mix/test/mix/tasks/compile.elixir_test.exs b/lib/mix/test/mix/tasks/compile.elixir_test.exs
index 6e82c816933..fdfccdef4b6 100644
--- a/lib/mix/test/mix/tasks/compile.elixir_test.exs
+++ b/lib/mix/test/mix/tasks/compile.elixir_test.exs
@@ -1,181 +1,1943 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.Compile.ElixirTest do
   use MixTest.Case
 
-  setup do
-    Mix.Project.push MixTest.Case.Sample
+  import ExUnit.CaptureIO
+  alias Mix.Task.Compiler.Diagnostic
+
+  @old_time {{2010, 1, 1}, {0, 0, 0}}
+  @elixir_otp_version {System.version(), :erlang.system_info(:otp_release)}
+
+  def trace(event, env) do
+    send(__MODULE__, {event, env})
     :ok
   end
 
-  test "compiles a project" do
-    Mix.Project.pop
-    Mix.ProjectStack.post_config [build_per_environment: false]
-    Mix.Project.push MixTest.Case.Sample
+  defp mtime(path) do
+    File.stat!(path).mtime
+  end
+
+  defp mark_as_old!(path) do
+    mtime = mtime(path)
+    File.touch!(path, @old_time)
+    mtime
+  end
+
+  defp purge_protocol(module) do
+    :code.del_path(:filename.absname(~c"_build/dev/lib/sample/consolidated"))
+    :code.purge(module)
+    :code.delete(module)
+  end
+
+  test "compiles a project without per environment build" do
+    Mix.ProjectStack.post_config(build_per_environment: false)
+
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A, do: :ok
+
+      # Also make sure that we access the ebin directory during compilation
+      true = to_charlist(Mix.Project.compile_path()) in :code.get_path()
+      """)
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Compile.Elixir.run []
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
 
       assert File.regular?("_build/shared/lib/sample/ebin/Elixir.A.beam")
       assert File.regular?("_build/shared/lib/sample/ebin/Elixir.B.beam")
-      assert File.regular?("_build/shared/lib/sample/ebin/Elixir.C.beam")
 
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
-      assert_received {:mix_shell, :info, ["Compiled lib/c.ex"]}
-    end
+    end)
   end
 
   test "compiles a project with per environment build" do
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Compile.Elixir.run []
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A, do: :ok
+
+      # Also make sure that we access the ebin directory during compilation
+      true = to_charlist(Mix.Project.compile_path()) in :code.get_path()
+      """)
+
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
 
       assert File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
       assert File.regular?("_build/dev/lib/sample/ebin/Elixir.B.beam")
-      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.C.beam")
 
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
-      assert_received {:mix_shell, :info, ["Compiled lib/c.ex"]}
-    end
+    end)
   end
 
-  test "does not write beam down on failures" do
-    import ExUnit.CaptureIO
+  test "compiles a project with custom tracer" do
+    Process.register(self(), __MODULE__)
 
-    in_tmp "blank", fn ->
-      File.mkdir_p!("lib")
-      File.write!("lib/a.ex", "raise ~s(oops)")
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      Mix.Tasks.Compile.Elixir.run(["--tracer", "Mix.Tasks.Compile.ElixirTest"])
+      assert_received {{:on_module, _, :none}, %{module: A}}
+      assert_received {{:on_module, _, :none}, %{module: B}}
+    end)
+  after
+    Code.put_compiler_option(:tracers, [])
+  end
+
+  test "compiles a project with a previously set custom tracer" do
+    Process.register(self(), __MODULE__)
+    Code.put_compiler_option(:tracers, [__MODULE__])
+
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      Mix.Tasks.Compile.Elixir.run([])
+      assert_received {{:on_module, _, :none}, %{module: A}}
+      assert_received {{:on_module, _, :none}, %{module: B}}
+    end)
+  after
+    Code.put_compiler_option(:tracers, [])
+  end
+
+  test "recompiles project if elixirc_options changed" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+
+      Mix.Task.clear()
+      Mix.ProjectStack.merge_config(xref: [exclude: [Foo]])
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    end)
+  end
+
+  test "does not recompiles project if cwd changes and --no-check-cwd is given" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      Mix.Project.pop()
+
+      old_cwd = File.cwd!()
+
+      in_tmp("new_cwd", fn ->
+        Mix.Project.push(MixTest.Case.Sample)
+        File.cp_r!(old_cwd, File.cwd!())
+
+        purge([A, B])
+        Mix.Task.clear()
+        assert {:noop, _} = Mix.Tasks.Compile.Elixir.run(["--verbose", "--no-check-cwd"])
+      end)
+    end)
+  end
 
-      capture_io fn ->
-        assert catch_exit(Mix.Tasks.Compile.Elixir.run []) == 1
+  test "recompiles files using Mix.Project if mix.exs changes" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample, __ENV__.file)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        Mix.Project.config()
       end
+      """)
 
-      refute File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
-    end
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      ensure_touched(__ENV__.file, "_build/dev/lib/sample/.mix/compile.elixir")
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Now remove the dependency
+      File.write!("lib/a.ex", """
+      defmodule A do
+      end
+      """)
+
+      ensure_touched(__ENV__.file, "_build/dev/lib/sample/.mix/compile.elixir")
+      File.touch!("_build/dev/lib/sample/.mix/compile.elixir", @old_time)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      assert mtime("_build/dev/lib/sample/.mix/compile.elixir") > @old_time
+
+      ensure_touched(__ENV__.file, "_build/dev/lib/sample/.mix/compile.elixir")
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+    end)
   end
 
-  test "removes old artifact files" do
-    in_fixture "no_mixfile", fn ->
-      assert Mix.Tasks.Compile.Elixir.run([]) == :ok
-      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
+  test "recompiles files when config changes" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      Process.put({MixTest.Case.Sample, :application}, extra_applications: [:logger])
+      File.mkdir_p!("config")
 
-      File.rm!("lib/a.ex")
-      assert Mix.Tasks.Compile.Elixir.run([]) == :ok
-      refute File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
-    end
+      File.write!("lib/a.ex", """
+      defmodule A do
+        _ = Logger.metadata()
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      recompile = fn ->
+        Mix.ProjectStack.pop()
+        Mix.Project.push(MixTest.Case.Sample)
+        ensure_touched("config/config.exs", "_build/dev/lib/sample/.mix/compile.elixir")
+        Mix.Tasks.Loadconfig.load_compile("config/config.exs")
+        Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      end
+
+      # Adding config recompiles
+      File.write!("config/config.exs", """
+      import Config
+      config :logger, :level, :debug
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Changing config recompiles
+      File.write!("config/config.exs", """
+      import Config
+      config :logger, :level, :info
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Removing config recompiles
+      File.write!("config/config.exs", """
+      import Config
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # No-op does not recompile
+      assert recompile.() == {:ok, []}
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Changing self fully recompiles
+      File.write!("config/config.exs", """
+      import Config
+      config :sample, :foo, :bar
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Changing an unknown dependency returns :ok but does not recompile
+      File.write!("config/config.exs", """
+      import Config
+      config :sample, :foo, :bar
+      config :unknown, :unknown, :unknown
+      """)
+    end)
+  after
+    Application.delete_env(:sample, :foo, persistent: true)
   end
 
-  test "compiles only changed files" do
-    in_fixture "no_mixfile", fn ->
-      assert Mix.Tasks.Compile.Elixir.run([]) == :ok
+  defdelegate dbg(code, options, env), to: Macro
+
+  test "recompiles only config files when elixir config changes" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def a, do: dbg(:ok)
+      end
+      """)
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+        def b, do: :ok
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
 
-      Mix.shell.flush
-      purge [A, B, C]
+      # Change the dbg_callback at runtime
+      File.touch!("_build/dev/lib/sample/.mix/compile.elixir", @old_time)
+      Application.put_env(:elixir, :dbg_callback, {__MODULE__, :dbg, []})
 
-      future = {{2020, 1, 1}, {0, 0, 0}}
-      File.touch!("lib/a.ex", future)
-      Mix.Tasks.Compile.Elixir.run []
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      assert mtime("_build/dev/lib/sample/.mix/compile.elixir") > @old_time
+    end)
+  after
+    Application.put_env(:elixir, :dbg_callback, {Macro, :dbg, []})
+  end
+
+  test "recompiles files when config changes export dependencies" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      Process.put({MixTest.Case.Sample, :application}, extra_applications: [:ex_unit])
+      File.mkdir_p!("config")
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def test_struct do
+          %ExUnit.Test{}
+        end
+      end
+      """)
 
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      recompile = fn ->
+        Mix.ProjectStack.pop()
+        Mix.Project.push(MixTest.Case.Sample)
+        ensure_touched("config/config.exs", "_build/dev/lib/sample/.mix/compile.elixir")
+        Mix.Tasks.Loadconfig.load_compile("config/config.exs")
+        Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      end
+
+      # Adding config recompiles
+      File.write!("config/config.exs", """
+      import Config
+      config :ex_unit, :some, :config
+      """)
+
+      assert recompile.() == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
 
-      File.touch!("_build/dev/lib/sample/.compile.elixir", future)
-      assert Mix.Tasks.Compile.Elixir.run([]) == :noop
-    end
+      # Changing config recompiles
+      File.write!("config/config.exs", """
+      import Config
+      config :ex_unit, :some, :another
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Removing config recompiles
+      File.write!("config/config.exs", """
+      import Config
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # No-op does not recompile
+      assert recompile.() == {:ok, []}
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+    end)
+  after
+    Application.delete_env(:ex_unit, :some, persistent: true)
   end
 
-  test "compiles dependent changed modules" do
-    in_fixture "no_mixfile", fn ->
-      File.write!("lib/a.ex", "defmodule A, do: B.module_info")
+  test "recompiles files when config changes with crashes" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      Process.put({MixTest.Case.Sample, :application}, extra_applications: [:logger])
+      File.mkdir_p!("config")
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        require Logger
+        def fun, do: Logger.debug("hello")
+      end
+      """)
 
-      assert Mix.Tasks.Compile.Elixir.run([]) == :ok
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
 
-      Mix.shell.flush
-      purge [A, B, C]
+      recompile = fn ->
+        Mix.ProjectStack.pop()
+        Mix.Project.push(MixTest.Case.Sample)
+        ensure_touched("config/config.exs", "_build/dev/lib/sample/.mix/compile.elixir")
+        Mix.Tasks.Loadconfig.load_compile("config/config.exs")
+        Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      end
 
-      future = {{2020, 1, 1}, {0, 0, 0}}
-      File.touch!("lib/b.ex", future)
-      Mix.Tasks.Compile.Elixir.run []
+      # Adding config recompiles due to macros
+      File.write!("config/config.exs", """
+      import Config
+      config :logger, :compile_time_purge_matching, []
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Inserting a bogus config should crash
+      File.write!("config/config.exs", """
+      import Config
+      config :logger, :compile_time_purge_matching, [level_lower_than: :debug]
+      """)
+
+      ExUnit.CaptureIO.capture_io(:stderr, fn -> assert {:error, _} = recompile.() end)
+
+      # Revering the original config should recompile
+      File.write!("config/config.exs", """
+      import Config
+      config :logger, :compile_time_purge_matching, []
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+    end)
+  after
+    Application.put_env(:logger, :compile_time_purge_matching, [])
+  end
 
+  test "recompiles files when config changes via compile_env" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.mkdir_p!("config")
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        _ = Application.compile_env(:logger, :level)
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
-    end
+
+      recompile = fn ->
+        Mix.ProjectStack.pop()
+        Mix.Project.push(MixTest.Case.Sample)
+        ensure_touched("config/config.exs", "_build/dev/lib/sample/.mix/compile.elixir")
+        Mix.Tasks.Loadconfig.load_compile("config/config.exs")
+        Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      end
+
+      # Adding config recompiles
+      File.write!("config/config.exs", """
+      import Config
+      config :logger, :level, :debug
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Changing config recompiles
+      File.write!("config/config.exs", """
+      import Config
+      config :logger, :level, :info
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Removing config recompiles
+      File.write!("config/config.exs", """
+      import Config
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Changing self fully recompiles
+      File.write!("config/config.exs", """
+      import Config
+      config :sample, :foo, :bar
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Changing an unknown dependency returns :ok but does not recompile
+      File.write!("config/config.exs", """
+      import Config
+      config :sample, :foo, :bar
+      config :unknown, :unknown, :unknown
+      """)
+
+      # We use ensure_touched because an outdated manifest would recompile anyway.
+      assert recompile.() == {:ok, []}
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+    end)
+  after
+    Application.delete_env(:sample, :foo, persistent: true)
   end
 
-  test "compiles dependent changed modules even on removal" do
-    in_fixture "no_mixfile", fn ->
-      File.write!("lib/a.ex", "defmodule A, do: B.module_info")
+  test "recompiles files when lock changes" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      Process.put({MixTest.Case.Sample, :application}, extra_applications: [:logger])
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        _ = Logger.metadata()
+      end
+      """)
 
-      assert Mix.Tasks.Compile.Elixir.run([]) == :ok
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
 
-      Mix.shell.flush
-      purge [A, B, C]
+      recompile = fn ->
+        Mix.ProjectStack.pop()
+        Mix.Project.push(MixTest.Case.Sample)
+        File.touch!("_build/dev/lib/sample/.mix/compile.elixir", @old_time)
+        ensure_touched("mix.lock")
+        ensure_touched("_build/dev/lib/sample/.mix/compile.lock")
+        Mix.Tasks.WillRecompile.run([])
+        Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      end
 
-      File.rm("lib/b.ex")
-      File.write!("lib/a.ex", "defmodule A, do: nil")
-      Mix.Tasks.Compile.Elixir.run []
+      # Adding to lock recompiles
+      File.write!("mix.lock", """
+      %{"logger": :unused}
+      """)
 
+      assert recompile.() == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
-    end
+      assert mtime("_build/dev/lib/sample/.mix/compile.elixir") > @old_time
+
+      # Changing lock recompiles
+      File.write!("mix.lock", """
+      %{"logger": :another}
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      assert mtime("_build/dev/lib/sample/.mix/compile.elixir") > @old_time
+
+      # Removing a lock recompiles
+      File.write!("mix.lock", """
+      %{}
+      """)
+
+      assert recompile.() == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      assert mtime("_build/dev/lib/sample/.mix/compile.elixir") > @old_time
+
+      # Adding an unknown dependency returns :ok but does not recompile
+      File.write!("mix.lock", """
+      %{"unknown": :unknown}
+      """)
+
+      assert recompile.() == {:ok, []}
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+    end)
   end
 
-  test "compiles dependent changed files" do
-    in_fixture "no_mixfile", fn ->
-      File.touch!("lib/a.eex")
+  test "recompiles files using Erlang modules if Erlang manifest changes" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.mkdir_p!("src")
+
+      File.write!("src/foo.erl", """
+      -module(foo).
+      -export([bar/0]).
+      bar() -> ok.
+      """)
+
+      File.write!("src/bar.erl", """
+      -module(bar).
+      -export([baz/0]).
+      baz() -> ok.
+      """)
+
       File.write!("lib/a.ex", """
       defmodule A do
-        @external_resource "lib/a.eex"
-        def a, do: :ok
+        :foo.bar()
       end
       """)
 
-      assert Mix.Tasks.Compile.Elixir.run([]) == :ok
-      Mix.shell.flush
-      purge [A, B, C]
+      assert Mix.Tasks.Compile.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
 
-      File.touch!("lib/a.eex", {{2020, 1, 1}, {0, 0, 0}})
-      assert Mix.Tasks.Compile.Elixir.run([]) == :ok
+      Mix.Task.clear()
+      File.touch!("_build/dev/lib/sample/.mix/compile.elixir", @old_time)
 
+      assert Mix.Tasks.Compile.run(["--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
       refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
-    end
+
+      # Now remove the Erlang file, lib/a.ex must recompile
+      File.rm!("src/foo.erl")
+      File.touch!("_build/dev/lib/sample/.mix/compile.erlang", @old_time)
+
+      Mix.Task.clear()
+      assert Mix.Tasks.Compile.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    end)
   end
 
-  test "recompiles with --force" do
-    in_fixture "no_mixfile", fn ->
-      assert Mix.Tasks.Compile.Elixir.run([]) == :ok
-      purge [A, B, C]
+  test "recompiles project if Elixir version changes" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      Mix.Tasks.Compile.run([])
+      purge([A, B])
 
-      # Now we have a noop
-      assert Mix.Tasks.Compile.Elixir.run([]) == :noop
+      assert File.exists?("_build/dev/lib/sample")
+      assert File.exists?("_build/dev/lib/sample/consolidated")
+      assert Mix.Dep.ElixirSCM.read() == {:ok, @elixir_otp_version, Mix.SCM.Path, nil}
+
+      Mix.Task.clear()
+      File.write!("_build/dev/lib/sample/consolidated/.to_be_removed", "")
+      manifest_data = :erlang.term_to_binary({:v1, "0.0.0", nil})
+      File.write!("_build/dev/lib/sample/.mix/compile.elixir_scm", manifest_data)
+      File.touch!("_build/dev/lib/sample/.mix/compile.elixir_scm", @old_time)
+
+      Mix.Tasks.Compile.run([])
+      assert Mix.Dep.ElixirSCM.read() == {:ok, @elixir_otp_version, Mix.SCM.Path, nil}
+
+      assert mtime("_build/dev/lib/sample/.mix/compile.elixir_scm") > @old_time
+      refute File.exists?("_build/dev/lib/sample/consolidated/.to_be_removed")
+    end)
+  end
+
+  test "recompiles project if scm changes" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      Mix.Tasks.Compile.run(["--verbose"])
+      purge([A, B])
 
-      # --force
-      assert Mix.Tasks.Compile.Elixir.run(["--force"]) == :ok
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
-    end
+      assert Mix.Dep.ElixirSCM.read() == {:ok, @elixir_otp_version, Mix.SCM.Path, nil}
+
+      Mix.Task.clear()
+      manifest_data = :erlang.term_to_binary({1, @elixir_otp_version, :another})
+      File.write!("_build/dev/lib/sample/.mix/compile.elixir_scm", manifest_data)
+      File.touch!("_build/dev/lib/sample/.mix/compile.elixir_scm", @old_time)
+
+      Mix.Tasks.Compile.run([])
+      assert Mix.Dep.ElixirSCM.read() == {:ok, @elixir_otp_version, Mix.SCM.Path, nil}
+
+      assert mtime("_build/dev/lib/sample/.mix/compile.elixir_scm") > @old_time
+    end)
   end
 
-  defmodule SourcePathsProject do
-    def project do
-      [app: :source_paths, elixirc_paths: ["unknown"]]
-    end
+  test "recompiles project if old manifest" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      Mix.Tasks.Compile.run([])
+      purge([A, B])
+
+      manifest = "_build/dev/lib/sample/.mix/compile.elixir"
+
+      File.read!(manifest)
+      |> :erlang.binary_to_term()
+      |> put_elem(0, 9)
+      |> :erlang.term_to_binary()
+      |> then(&File.write!(manifest, &1))
+
+      Mix.Task.clear()
+      assert Mix.Task.run("compile", ["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+    end)
   end
 
-  test "use custom source paths" do
-    Mix.Project.push SourcePathsProject
+  test "recompiles files from path dependencies when its deps change" do
+    # Get Git repo first revision
+    [last, first | _] = get_git_repo_revs("git_repo")
 
-    in_fixture "no_mixfile", fn ->
-      # Nothing to compile with the custom source paths
-      assert Mix.Tasks.Compile.Elixir.run([])
-      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    in_fixture("no_mixfile", fn ->
+      File.mkdir_p!("path_on_git_repo/lib")
+
+      File.write!("path_on_git_repo/mix.exs", """
+      defmodule PathOnGitRepo.MixProject do
+        use Mix.Project
+
+        def project do
+          [
+            app: :path_on_git_repo,
+            version: "0.1.0",
+            deps: [{:git_repo, git: MixTest.Case.fixture_path("git_repo")}]
+          ]
+        end
+      end
+      """)
+
+      File.write!("path_on_git_repo/lib/path_on_hello.ex", """
+      defmodule PathOnGitRepo.Hello do
+        IO.puts("GitRepo is defined: \#{Code.ensure_loaded?(GitRepo)}")
+      end
+      """)
+
+      File.write!("mix.lock", inspect(%{git_repo: {:git, fixture_path("git_repo"), first, []}}))
+      Mix.ProjectStack.post_config(deps: [{:path_on_git_repo, path: "path_on_git_repo"}])
+      Mix.Project.push(MixTest.Case.Sample)
+
+      Mix.Tasks.Deps.Get.run([])
+      assert capture_io(fn -> Mix.Task.run("compile") end) =~ "GitRepo is defined: false"
+
+      Mix.Task.clear()
+      Mix.State.clear_cache()
+      purge([GitRepo.MixProject, PathOnGitRepo.MixProject, PathOnGitRepo.Hello])
+
+      Mix.Tasks.Deps.Update.run(["--all"])
+      assert File.read!("mix.lock") =~ last
+
+      # The lock of sample (the parent app) is the one that changed
+      # but that should mirror on child path dependencies too.
+      ensure_touched(
+        "_build/dev/lib/sample/.mix/compile.lock",
+        "_build/dev/lib/path_on_git_repo/.mix/compile.elixir"
+      )
+
+      assert capture_io(fn -> Mix.Task.run("compile") end) =~ "GitRepo is defined: true"
+    end)
+  after
+    purge([GitRepo, GitRepo.MixProject])
+  end
+
+  test "does not write BEAM files down on failures" do
+    in_tmp("blank", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.mkdir_p!("lib")
+      File.write!("lib/a.ex", "raise ~s(oops)")
+
+      capture_io(:stderr, fn ->
+        assert {:error, [_]} = Mix.Tasks.Compile.Elixir.run([])
+      end)
+
+      refute File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
+    end)
+  end
+
+  test "removes, purges and deletes old artifacts" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
+      assert Code.ensure_loaded?(A)
+
+      File.rm!("lib/a.ex")
+      assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+      refute File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
+      refute Code.ensure_loaded?(A)
+      refute String.contains?(File.read!("_build/dev/lib/sample/.mix/compile.elixir"), "Elixir.A")
+    end)
+  end
+
+  test "recompiles mtime changed files if content changed but not length" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      Mix.shell().flush()
+      purge([A, B])
+
+      same_length_content = "lib/a.ex" |> File.read!() |> String.replace("A", "Z")
+      File.write!("lib/a.ex", same_length_content)
+      future = {{2038, 1, 1}, {0, 0, 0}}
+      File.touch!("lib/a.ex", future)
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+
+      message =
+        "warning: mtime (modified time) for \"lib/a.ex\" was set to the future, resetting to now"
+
+      assert_received {:mix_shell, :error, [^message]}
+
+      message =
+        "warning: mtime (modified time) for \"lib/b.ex\" was set to the future, resetting to now"
+
+      refute_received {:mix_shell, :error, [^message]}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      File.touch!("_build/dev/lib/sample/.mix/compile.elixir", future)
+      assert Mix.Tasks.Compile.Elixir.run([]) == {:noop, []}
+    end)
+  end
+
+  test "does not recompile mtime changed but identical files" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      Mix.shell().flush()
+      purge([A, B])
+
+      future = {{2038, 1, 1}, {0, 0, 0}}
+      File.touch!("lib/a.ex", future)
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+
+      message =
+        "warning: mtime (modified time) for \"lib/a.ex\" was set to the future, resetting to now"
+
+      assert_received {:mix_shell, :error, [^message]}
+
+      message =
+        "warning: mtime (modified time) for \"lib/b.ex\" was set to the future, resetting to now"
+
+      refute_received {:mix_shell, :error, [^message]}
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      File.touch!("_build/dev/lib/sample/.mix/compile.elixir", future)
+      assert Mix.Tasks.Compile.Elixir.run([]) == {:noop, []}
+    end)
+  end
+
+  test "does recompile a file restored after a compile error (and .beam file were deleted)" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      Mix.shell().flush()
+      purge([A, B])
+
+      # Compile with error
+      original_content = File.read!("lib/b.ex")
+      File.write!("lib/b.ex", "this will not compile")
+
+      assert capture_io(:stderr, fn ->
+               {:error, _} = Mix.Tasks.Compile.Elixir.run(["--verbose"])
+             end) =~ "Compilation error in file lib/b.ex"
+
+      assert_received {:mix_shell, :info, ["Compiling 1 file (.ex)"]}
+
+      # Revert change
+      File.write!("lib/b.ex", original_content)
+      future = {{2038, 1, 1}, {0, 0, 0}}
+      File.touch!("lib/b.ex", future)
+
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+
+      message =
+        "warning: mtime (modified time) for \"lib/b.ex\" was set to the future, resetting to now"
+
+      assert_received {:mix_shell, :error, [^message]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    end)
+  end
+
+  test "recompiles size changed files" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      past = @old_time
+      File.touch!("lib/a.ex", past)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      Mix.shell().flush()
+      purge([A, B])
+
+      File.write!("lib/a.ex", File.read!("lib/a.ex") <> "\n")
+      File.touch!("lib/a.ex", past)
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+    end)
+  end
+
+  test "recompiles dependent changed modules" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.write!("lib/a.ex", "defmodule A, do: B.module_info()")
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      Mix.shell().flush()
+      purge([A, B])
+
+      force_recompilation("lib/b.ex")
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+    end)
+  end
+
+  test "recompiles dependent changed modules without beam files" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+        def a, do: A.__info__(:module)
+      end
+      """)
+
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
+      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.B.beam")
+
+      # Compile directly so it does not point to a .beam file
+      Code.put_compiler_option(:ignore_module_conflict, true)
+      Code.compile_file("lib/b.ex")
+
+      force_recompilation("lib/a.ex")
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    end)
+  after
+    Code.put_compiler_option(:ignore_module_conflict, false)
+  end
+
+  test "recompiles dependent changed modules even on removal" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.write!("lib/a.ex", "defmodule A, do: B.module_info()")
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      Mix.shell().flush()
+      purge([A, B])
+
+      File.rm("lib/b.ex")
+      File.write!("lib/a.ex", "defmodule A, do: nil")
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+    end)
+  end
+
+  test "recompiles dependent changed on conflict" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      purge([A, B])
+
+      assert capture_io(:stderr, fn ->
+               File.write!("lib/a.ex", "defmodule B, do: :not_ok")
+               assert {:ok, [_]} = Mix.Tasks.Compile.Elixir.run(["--verbose"])
+               assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+               assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+               purge([A, B])
+             end) =~ "redefining module B"
+
+      capture_io(:stderr, fn ->
+        File.write!("lib/a.ex", "defmodule A, do: :ok")
+        assert {:ok, []} = Mix.Tasks.Compile.Elixir.run(["--verbose"])
+        assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+        assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+        purge([A, B])
+      end)
+    end)
+  end
+
+  test "recompiles dependent changed external resources" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      tmp = tmp_path("c.eex")
+      File.touch!("lib/a.eex")
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        # Listing directories as external resources
+        # is not valid but let's ensure we don't crash
+        @external_resource "lib"
+        @external_resource "lib/a.eex"
+        @external_resource #{inspect(tmp)}
+        def a, do: :ok
+
+        if System.get_env("RAISE_EXTERNAL_RESOURCE") do
+          raise "oops"
+        end
+      end
+      """)
+
+      # Compiles with missing external resources
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:noop, []}
+      Mix.shell().flush()
+      purge([A, B])
+
+      # Update local existing resource timestamp is not enough
+      File.touch!("lib/a.eex", {{2038, 1, 1}, {0, 0, 0}})
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:noop, []}
+
+      # Force recompilation but fail compilation
+      force_recompilation("lib/a.eex")
+      System.put_env("RAISE_EXTERNAL_RESOURCE", "1")
+
+      assert capture_io(:stderr, fn ->
+               assert {:error, [_]} = Mix.Tasks.Compile.Elixir.run(["--verbose"])
+             end) =~ "oops"
+
+      # Delete failure reason, it will now compile for good
+      System.delete_env("RAISE_EXTERNAL_RESOURCE")
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Does not update on old existing resource
+      File.touch!("lib/a.eex", @old_time)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:noop, []}
+      Mix.shell().flush()
+      purge([A, B])
+
+      # Create external resource
+      File.touch!(tmp, {{2038, 1, 1}, {0, 0, 0}})
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Recompiles once resource is deleted
+      File.rm_rf!(tmp)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Recompiles if directories are stale
+      File.touch!("lib", {{2038, 1, 1}, {0, 0, 0}})
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+    end)
+  after
+    File.rm(tmp_path("c.eex"))
+  end
+
+  test "tracks warnings from external resources" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.touch!("lib/a.eex")
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        @external_resource "lib/a.eex"
+        IO.warn("oops", file: Path.absname("lib/a.eex"), line: 13)
+      end
+      """)
+
+      # Compiles with missing external resources
+      file = Path.absname("lib/a.eex")
+      source = Path.absname("lib/a.ex")
+
+      assert capture_io(:stderr, fn ->
+               assert {:ok,
+                       [%Mix.Task.Compiler.Diagnostic{source: ^source, file: ^file, position: 13}]} =
+                        Mix.Tasks.Compile.Elixir.run([])
+
+               assert {:noop,
+                       [%Mix.Task.Compiler.Diagnostic{source: ^source, file: ^file, position: 13}]} =
+                        Mix.Tasks.Compile.Elixir.run(["--all-warnings"])
+             end) =~ "oops"
+
+      purge([A])
+    end)
+  end
+
+  test "recompiles modules with exports tracking" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        defstruct [:foo]
+      end
+      """)
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+        def fun do
+          %A{foo: 1}
+        end
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      purge([A, B])
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        # Some comments
+        defstruct [:foo]
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      purge([A, B])
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        defstruct [:foo, :bar]
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      purge([A, B])
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        defstruct [:foo, bar: 1]
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      purge([A, B])
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        defstruct [:foo, bar: 1]
+        def some_fun, do: :ok
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      purge([A, B])
+
+      # Remove all code, we should now get a compilation error
+      File.write!("lib/a.ex", """
+      """)
+
+      assert capture_io(:stderr, fn ->
+               {:error, _} = Mix.Tasks.Compile.Elixir.run(["--verbose"])
+             end) =~ "A.__struct__/1 is undefined, cannot expand struct A"
+
+      # At the code back and it should work again
+      File.write!("lib/a.ex", """
+      defmodule A do
+        defstruct [:foo, bar: 1]
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      purge([A, B])
+
+      # Removing the file should have the same effect as removing all code
+      File.rm!("lib/a.ex")
+
+      assert capture_io(:stderr, fn ->
+               {:error, _} = Mix.Tasks.Compile.Elixir.run(["--verbose"])
+             end) =~ "A.__struct__/1 is undefined, cannot expand struct A"
+    end)
+  end
+
+  test "recompiles modules with pmap tracking" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      Kernel.ParallelCompiler.pmap([:ok], fn :ok ->
+        defmodule A do
+          def fun, do: :ok
+        end
+      end)
+      """)
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+        A.fun()
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      purge([A, B])
+
+      force_recompilation("lib/a.ex")
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      purge([A, B])
+    end)
+  end
+
+  test "recompiles modules with multiple sources" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def one, do: 1
+      end
+
+      defmodule B do
+        def two, do: 2
+      end
+      """)
+
+      File.write!("lib/b.ex", """
+      B.two()
+
+      defmodule A do
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose", "--ignore-module-conflict"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      refute Code.ensure_loaded?(A) and function_exported?(A, :one, 0)
+
+      Mix.shell().flush()
+      purge([A])
+
+      File.rm("lib/b.ex")
+      Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      assert Code.ensure_loaded?(A) and function_exported?(A, :one, 0)
+    end)
+  end
+
+  test "recompiles with --force" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      purge([A, B])
+
+      # Now we have a noop
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:noop, []}
+
+      # --force
+      assert Mix.Tasks.Compile.Elixir.run(["--force", "--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    end)
+  end
+
+  test "recompiles with --force-elixir" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      assert Mix.Task.run("compile") == {:ok, []}
+      purge([A, B])
+
+      # Now we have a noop
+      Mix.Task.clear()
+      assert Mix.Task.run("compile") == {:noop, []}
+
+      # --force-elixir
+      Mix.Task.clear()
+      assert Mix.Task.run("compile", ["--verbose", "--force-elixir"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    end)
+  end
+
+  test "compiles files with autoload disabled" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        @compile {:autoload, false}
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      purge([A, B])
+    end)
+  end
+
+  test "does not recompile files that are empty or have no code" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.write!("lib/a.ex", "")
+      File.write!("lib/b.ex", "# Just a comment")
+      File.write!("lib/c.ex", "\n\n")
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/c.ex"]}
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:noop, []}
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/c.ex"]}
+    end)
+  end
+
+  test "recompiles modules with __mix_recompile__ check" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def __mix_recompile__?(), do: true
+      end
+      """)
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+        def __mix_recompile__?(), do: false
+      end
+      """)
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiling 2 files (.ex)"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+
+      # Mix recompile should work even if the compile path
+      # was removed and the module purged
+      Code.delete_path(Mix.Project.compile_path())
+      purge([A])
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiling 1 file (.ex)"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      Mix.shell().flush()
+
+      File.rm!("lib/a.ex")
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      refute_received _
+    end)
+  end
+
+  test "recompiles modules with __mix_recompile__ check with crashes" do
+    Agent.start_link(fn -> false end, name: :mix_recompile_raise)
+
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def __mix_recompile__?(), do: Agent.get(:mix_recompile_raise, & &1)
+
+        if Agent.get(:mix_recompile_raise, & &1) do
+          raise "oops"
+        end
+      end
+      """)
+
+      File.touch!("lib/a.ex", @old_time)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:noop, []}
+      assert mtime("lib/a.ex") == @old_time
+
+      Agent.update(:mix_recompile_raise, fn _ -> true end)
+
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        assert {:error, _} = Mix.Tasks.Compile.Elixir.run(["--verbose"])
+      end)
+
+      # After failing to compile and reverting the status, it should still recompile
+      Agent.update(:mix_recompile_raise, fn _ -> false end)
+      assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    end)
+  end
+
+  test "prints warnings from non-stale files with --all-warnings" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def my_fn(unused), do: :ok
+      end
+      """)
+
+      # First compilation should print unused variable warning
+      assert capture_io(:stderr, fn ->
+               Mix.Tasks.Compile.Elixir.run([]) == :ok
+             end) =~ "variable \"unused\" is unused"
+
+      assert capture_io(:stderr, fn ->
+               Mix.Tasks.Compile.Elixir.run([])
+             end) =~ "variable \"unused\" is unused"
+
+      assert capture_io(:stderr, fn ->
+               Mix.Tasks.Compile.Elixir.run(["--no-all-warnings"])
+             end) == ""
+
+      # Should not print warning once fixed
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def my_fn(_unused), do: :ok
+      end
+      """)
+
+      assert capture_io(:stderr, fn ->
+               Mix.Tasks.Compile.Elixir.run(["--all-warnings"])
+             end) == ""
+    end)
+  end
+
+  test "warning from --all-warnings are treated as errors with --warnings-as-errors" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def my_fn(unused), do: :ok
+      end
+      """)
+
+      message = "variable \"unused\" is unused"
+
+      assert capture_io(:stderr, fn ->
+               Mix.Tasks.Compile.Elixir.run([]) == :ok
+             end) =~ message
+
+      # Stale compilation fails due to warnings as errors
+      assert capture_io(:stderr, fn ->
+               catch_exit(Mix.Task.run("compile", ["--all-warnings", "--warnings-as-errors"]))
+             end) =~ message
+
+      Mix.Task.clear()
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+      end
+      """)
+
+      # Recompiling a new file still fails due to warnings as errors
+      assert capture_io(:stderr, fn ->
+               catch_exit(Mix.Task.run("compile", ["--all-warnings", "--warnings-as-errors"]))
+             end) =~ message
+    end)
+  end
+
+  test "returns warning diagnostics" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def my_fn(unused), do: :ok
+      end
+      """)
+
+      file = Path.absname("lib/a.ex")
+
+      message =
+        "variable \"unused\" is unused (if the variable is not meant to be used, prefix it with an underscore)"
+
+      capture_io(:stderr, fn ->
+        assert {:ok, [diagnostic]} = Mix.Tasks.Compile.Elixir.run([])
+
+        assert %Diagnostic{
+                 file: ^file,
+                 source: ^file,
+                 severity: :warning,
+                 position: {2, 13},
+                 compiler_name: "Elixir",
+                 message: ^message
+               } = diagnostic
+      end)
+
+      # Recompiling should return :noop status because nothing is stale,
+      # but also include previous warning diagnostics
+      capture_io(:stderr, fn ->
+        assert {:noop, [diagnostic]} = Mix.Tasks.Compile.Elixir.run([])
+
+        assert %Diagnostic{
+                 file: ^file,
+                 source: ^file,
+                 severity: :warning,
+                 position: {2, 13},
+                 compiler_name: "Elixir",
+                 message: ^message
+               } = diagnostic
+
+        assert [^diagnostic] = Mix.Tasks.Compile.Elixir.diagnostics()
+        assert [^diagnostic] = Mix.Task.Compiler.diagnostics()
+      end)
+    end)
+  end
+
+  test "returns warning diagnostics for external files" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      IO.warn "warning", [{nil, nil, 0, file: ~c"lib/foo.txt", line: 3}]
+      """)
+
+      capture_io(:stderr, fn ->
+        assert {:ok, [diagnostic]} = Mix.Tasks.Compile.Elixir.run([])
+
+        assert %Diagnostic{
+                 file: nil,
+                 severity: :warning,
+                 position: 0,
+                 compiler_name: "Elixir",
+                 message: "warning",
+                 stacktrace: [{nil, nil, 0, [file: ~c"lib/foo.txt", line: 3]}]
+               } = diagnostic
+      end)
+    end)
+  end
+
+  test "returns error diagnostics", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.mkdir_p!("lib")
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+        def unused_var(unused_var), do: :ok
+      end
+      """)
+
+      assert capture_io(:stderr, fn ->
+               assert {:ok, [_diagnostic]} = Mix.Tasks.Compile.Elixir.run([])
+             end) =~ "unused_var"
+
+      file = Path.absname("lib/a.ex")
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def my_fn(), do: $$$
+      end
+      """)
+
+      refute capture_io(:stderr, fn ->
+               purge([B])
+               assert {:error, [_warning, error]} = Mix.Tasks.Compile.Elixir.run([])
+
+               assert %Diagnostic{
+                        file: ^file,
+                        source: ^file,
+                        severity: :error,
+                        position: {2, 20},
+                        message: "** (SyntaxError) invalid syntax found on lib/a.ex:2:" <> _,
+                        compiler_name: "Elixir"
+                      } = error
+             end) =~ "unused_var"
+
+      assert capture_io(:stderr, fn ->
+               purge([B])
+
+               assert {:error, [_warning, _error]} =
+                        Mix.Tasks.Compile.Elixir.run(["--all-warnings"])
+             end) =~ "unused_var"
+    end)
+  end
+
+  test "returns error diagnostics for invalid struct key", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.mkdir_p!("lib")
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def my_fn(), do: %Date{invalid_key: 2020}
+      end
+      """)
+
+      file = Path.absname("lib/a.ex")
+
+      capture_io(:stderr, fn ->
+        assert {:error, [diagnostic]} = Mix.Tasks.Compile.Elixir.run([])
+
+        assert %Diagnostic{
+                 file: ^file,
+                 source: ^file,
+                 severity: :error,
+                 position: 2,
+                 message: "** (KeyError) key :invalid_key not found" <> _,
+                 compiler_name: "Elixir"
+               } = diagnostic
+      end)
+    end)
+  end
+
+  test "returns error diagnostics when deadlocked" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        B.__info__(:module)
+      end
+      """)
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+        A.__info__(:module)
+      end
+      """)
+
+      capture_io(:stderr, fn ->
+        assert {:error, errors} = Mix.Tasks.Compile.Elixir.run([])
+        errors = Enum.sort_by(errors, &Map.get(&1, :file))
+
+        file_a = Path.absname("lib/a.ex")
+        file_b = Path.absname("lib/b.ex")
+
+        assert [
+                 %Diagnostic{file: ^file_a, message: "deadlocked waiting on module B"},
+                 %Diagnostic{file: ^file_b, message: "deadlocked waiting on module A"}
+               ] = errors
+      end)
+    end)
+  end
+
+  test "verify runtime dependent modules that haven't been compiled" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def foo(), do: :ok
+      end
+      """)
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+        def foo(), do: A.foo()
+      end
+      """)
+
+      File.write!("lib/c.ex", """
+      defmodule C do
+        @after_verify __MODULE__
+        def foo(), do: B.foo()
+        def bar(), do: B.bar()
+        def __after_verify__(__MODULE__) do
+          IO.warn("AFTER_VERIFY", __ENV__)
+        end
+      end
+      """)
+
+      output =
+        capture_io(:stderr, fn ->
+          Mix.Tasks.Compile.Elixir.run(["--verbose"])
+        end)
+
+      refute output =~ "A.foo/0 is undefined or private"
+      assert output =~ "B.bar/0 is undefined or private"
+      assert output =~ "AFTER_VERIFY"
+
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      assert_received {:mix_shell, :info, ["Compiled lib/c.ex"]}
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+      end
+      """)
+
+      output =
+        capture_io(:stderr, fn ->
+          Mix.Tasks.Compile.Elixir.run(["--verbose", "--no-all-warnings"])
+        end)
+
+      # Check B due to direct dependency on A
+      assert output =~ "A.foo/0 is undefined or private"
+      refute output =~ "B.bar/0 is undefined or private"
+      refute output =~ "AFTER_VERIFY"
+
+      # Ensure only A was recompiled
+      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/b.ex"]}
+      refute_received {:mix_shell, :info, ["Compiled lib/c.ex"]}
+
+      # We can retrieve all warnings if desired
+      output =
+        capture_io(:stderr, fn ->
+          Mix.Tasks.Compile.Elixir.run(["--verbose", "--all-warnings"])
+        end)
+
+      assert output =~ "A.foo/0 is undefined or private"
+      assert output =~ "B.bar/0 is undefined or private"
+      assert output =~ "AFTER_VERIFY"
+
+      # Now we change B and it must emit an AFTER_VERIFY warning
+      File.write!("lib/b.ex", """
+      defmodule B do
+      end
+      """)
+
+      output =
+        capture_io(:stderr, fn ->
+          Mix.Tasks.Compile.Elixir.run(["--verbose", "--all-warnings"])
+        end)
+
+      assert output =~ "B.foo/0 is undefined or private"
+      assert output =~ "B.bar/0 is undefined or private"
+      assert output =~ "AFTER_VERIFY"
+
+      # But we can also disable verification if we want to
+      output =
+        capture_io(:stderr, fn ->
+          Mix.Tasks.Compile.Elixir.run(["--no-verification", "--force"])
+        end)
+
+      refute output =~ "B.foo/0 is undefined or private"
+      refute output =~ "B.bar/0 is undefined or private"
+      refute output =~ "AFTER_VERIFY"
+    end)
+  end
+
+  defmodule GitApp do
+    def project do
+      [
+        app: :git_app,
+        version: "0.1.0",
+        deps: [
+          {:git_repo, "0.1.0", git: fixture_path("git_repo"), optional: true}
+        ]
+      ]
+    end
+  end
+
+  test "compiles without optional dependencies" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
+      Mix.Tasks.Deps.Get.run([])
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def hello, do: GitRepo.hello()
+      end
+      """)
+
+      assert capture_io(:stderr, fn ->
+               Mix.Tasks.Compile.run(["--no-optional-deps"]) == :ok
+             end) =~ "GitRepo.hello/0 is undefined"
+
+      Mix.Task.clear()
+      assert Mix.Tasks.Compile.run([]) == {:ok, []}
+
+      purge([GitRepo])
+      Mix.Task.clear()
+
+      assert capture_io(:stderr, fn ->
+               Mix.Tasks.Compile.run(["--no-optional-deps"]) == :ok
+             end) =~ "GitRepo.hello/0 is undefined"
+
+      refute Code.ensure_loaded?(GitRepo)
+    end)
+  end
+
+  describe "consolidation protocols" do
+    test "with local protocols", context do
+      in_tmp(context.test, fn ->
+        Mix.Project.push(MixTest.Case.Sample)
+
+        File.mkdir_p!("lib")
+        assert Mix.Task.run("compile")
+
+        # Define a local protocol
+        File.write!("lib/protocol.ex", """
+        defprotocol Compile.Protocol do
+          def foo(a, b)
+        end
+        """)
+
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+        mark_as_old!("_build/dev/lib/sample/consolidated/Elixir.Compile.Protocol.beam")
+
+        # Implement a local protocol
+        File.write!("lib/impl.ex", """
+        defimpl Compile.Protocol, for: Integer do
+          def foo(a, b), do: a + b
+        end
+        """)
+
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+
+        assert mark_as_old!("_build/dev/lib/sample/consolidated/Elixir.Compile.Protocol.beam") !=
+                 @old_time
+
+        # Delete a local implementation
+        File.rm!("lib/impl.ex")
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+
+        assert mark_as_old!("_build/dev/lib/sample/consolidated/Elixir.Compile.Protocol.beam") !=
+                 @old_time
+
+        # Delete a local protocol
+        File.rm!("lib/protocol.ex")
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+        refute File.regular?("_build/dev/lib/sample/consolidated/Elixir.Compile.Protocol.beam")
+      end)
+    end
+
+    test "compiles after converting a protocol into a standard module", context do
+      in_tmp(context.test, fn ->
+        Mix.Project.push(MixTest.Case.Sample)
+
+        File.mkdir_p!("lib")
+        Mix.Task.run("compile")
+        purge_protocol(Compile.Protocol)
+
+        # Define a local protocol
+        File.write!("lib/protocol.ex", """
+        defprotocol Compile.Protocol do
+          def foo(a)
+        end
+
+        defimpl Compile.Protocol, for: Integer do
+          def foo(a), do: a
+        end
+        """)
+
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+        mark_as_old!("_build/dev/lib/sample/consolidated/Elixir.Compile.Protocol.beam")
+        File.rm!("lib/protocol.ex")
+
+        # Define a standard module
+        File.write!("lib/protocol.ex", """
+        defmodule Compile.Protocol do
+        end
+        """)
+
+        purge_protocol(Compile.Protocol)
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+
+        # Delete a local protocol
+        File.rm!("lib/protocol.ex")
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+        refute File.regular?("_build/dev/lib/sample/consolidated/Elixir.Compile.Protocol.beam")
+      end)
+    end
+
+    test "with deps protocols", context do
+      in_tmp(context.test, fn ->
+        Mix.Project.push(MixTest.Case.Sample)
+
+        File.mkdir_p!("lib")
+        Mix.Task.run("compile")
+        purge_protocol(String.Chars)
+        mark_as_old!("_build/dev/lib/sample/consolidated/Elixir.String.Chars.beam")
+
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:noop, []}
+        assert mtime("_build/dev/lib/sample/consolidated/Elixir.String.Chars.beam") == @old_time
+
+        # Implement a deps protocol
+        File.write!("lib/struct.ex", """
+        defmodule Compile.Protocol.Struct do
+          defstruct a: nil
+          defimpl String.Chars do
+            def to_string(_), do: "ok"
+          end
+        end
+        """)
+
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+
+        assert mark_as_old!("_build/dev/lib/sample/consolidated/Elixir.String.Chars.beam") !=
+                 @old_time
+
+        # Delete the local implementation
+        File.rm!("lib/struct.ex")
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:ok, []}
+
+        assert mark_as_old!("_build/dev/lib/sample/consolidated/Elixir.String.Chars.beam") !=
+                 @old_time
+      end)
+    end
+
+    test "keep relative path to their source" do
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(MixTest.Case.Sample)
+        Mix.Task.run("compile")
+
+        # Load consolidated
+        :code.add_patha(~c"_build/dev/lib/sample/consolidated")
+        :code.purge(Enumerable)
+        :code.delete(Enumerable)
+
+        try do
+          Enumerable.impl_for!(:oops)
+        rescue
+          Protocol.UndefinedError ->
+            assert [{_, _, _, [file: ~c"lib/enum.ex"] ++ _} | _] = __STACKTRACE__
+        else
+          _ ->
+            flunk("Enumerable.impl_for!/1 should have failed")
+        after
+          purge_protocol(Enumerable)
+        end
+      end)
+    end
+
+    test "purges consolidation path if asked" do
+      in_fixture("no_mixfile", fn ->
+        File.write!("lib/a.ex", """
+        defmodule A do
+          defstruct []
+        end
+
+        defimpl Collectable, for: A do
+          def into(_), do: fn _, _  -> raise "oops" end
+        end
+        """)
+
+        Mix.Project.push(MixTest.Case.Sample)
+
+        # At this point, it may or may not emit warnings, but we don't care,
+        # we validate both scenarios next.
+        assert {:ok, _} = Mix.Tasks.Compile.run([])
+        assert is_function(Collectable.into(struct(A, [])), 2)
+
+        purge([A, B, Collectable.A])
+        Mix.Task.clear()
+
+        assert capture_io(:stderr, fn ->
+                 {:ok, [_]} = Mix.Tasks.Compile.run(["--force"])
+               end) =~
+                 "the Collectable protocol has already been consolidated"
+
+        purge([A, B, Collectable.A])
+        Mix.Task.clear()
+        consolidation = Mix.Project.consolidation_path()
+        args = ["--force", "--purge-consolidation-path-if-stale", consolidation]
+        assert Mix.Tasks.Compile.run(args) == {:ok, []}
+      end)
     end
   end
 end
diff --git a/lib/mix/test/mix/tasks/compile.erlang_test.exs b/lib/mix/test/mix/tasks/compile.erlang_test.exs
index 4bca6edb462..2cc13d301a5 100644
--- a/lib/mix/test/mix/tasks/compile.erlang_test.exs
+++ b/lib/mix/test/mix/tasks/compile.erlang_test.exs
@@ -1,58 +1,246 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.Compile.ErlangTest do
   use MixTest.Case
   import ExUnit.CaptureIO
 
-  setup do
-    Mix.Project.push MixTest.Case.Sample
+  defmacro position(line, column), do: {line, column}
+
+  setup config do
+    erlc_options = Map.get(config, :erlc_options, [])
+    Mix.ProjectStack.post_config(erlc_options: erlc_options)
+    Mix.Project.push(MixTest.Case.Sample)
     :ok
   end
 
-  test "compilation continues if one file fails to compile" do
-    in_fixture "compile_erlang", fn ->
-      File.write! "src/zzz.erl", """
-      -module(zzz).
-      def zzz(), do: b
-      """
-
-      assert_raise CompileError, fn ->
-        capture_io fn ->
-          Mix.Tasks.Compile.Erlang.run []
-        end
+  @tag erlc_options: [{:d, ~c"foo", ~c"bar"}]
+  test "raises on invalid erlc_options" do
+    in_fixture("compile_erlang", fn ->
+      assert_raise Mix.Error, ~r/Compiling Erlang file ".*" failed/, fn ->
+        capture_io(fn ->
+          Mix.Tasks.Compile.Erlang.run([])
+        end)
       end
-
-      assert File.regular?("_build/dev/lib/sample/ebin/b.beam")
-      assert File.regular?("_build/dev/lib/sample/ebin/c.beam")
-    end
+    end)
   end
 
-  test "compiles src/b.erl and src/c.erl" do
-    in_fixture "compile_erlang", fn ->
-      assert Mix.Tasks.Compile.Erlang.run([]) == :ok
+  test "compiles and cleans src/b.erl and src/c.erl" do
+    in_fixture("compile_erlang", fn ->
+      assert Mix.Tasks.Compile.Erlang.run(["--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled src/b.erl"]}
       assert_received {:mix_shell, :info, ["Compiled src/c.erl"]}
 
       assert File.regular?("_build/dev/lib/sample/ebin/b.beam")
       assert File.regular?("_build/dev/lib/sample/ebin/c.beam")
 
-      assert Mix.Tasks.Compile.Erlang.run([]) == :noop
+      assert Mix.Tasks.Compile.Erlang.run(["--verbose"]) == {:noop, []}
       refute_received {:mix_shell, :info, ["Compiled src/b.erl"]}
 
-      assert Mix.Tasks.Compile.Erlang.run(["--force"]) == :ok
+      assert Mix.Tasks.Compile.Erlang.run(["--force", "--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled src/b.erl"]}
       assert_received {:mix_shell, :info, ["Compiled src/c.erl"]}
-    end
+
+      assert Mix.Tasks.Compile.Erlang.clean()
+      refute File.regular?("_build/dev/lib/sample/ebin/b.beam")
+      refute File.regular?("_build/dev/lib/sample/ebin/c.beam")
+    end)
   end
 
   test "removes old artifact files" do
-    in_fixture "compile_erlang", fn ->
-      assert Mix.Tasks.Compile.Erlang.run([]) == :ok
+    in_fixture("compile_erlang", fn ->
+      assert Mix.Tasks.Compile.Erlang.run([]) == {:ok, []}
       assert File.regular?("_build/dev/lib/sample/ebin/b.beam")
 
       File.rm!("src/b.erl")
-      assert Mix.Tasks.Compile.Erlang.run([]) == :ok
+      assert Mix.Tasks.Compile.Erlang.run([]) == {:ok, []}
       refute File.regular?("_build/dev/lib/sample/ebin/b.beam")
-    end
+    end)
+  end
+
+  test "compilation purges the module" do
+    in_fixture("compile_erlang", fn ->
+      # Create the first version of the module.
+      defmodule :purge_test do
+        def version, do: :v1
+      end
+
+      assert :v1 == :purge_test.version()
+
+      # Create the second version of the module (this time as Erlang source).
+      File.write!("src/purge_test.erl", """
+      -module(purge_test).
+      -export([version/0]).
+      version() -> v2.
+      """)
+
+      assert Mix.Tasks.Compile.Erlang.run([]) == {:ok, []}
+
+      # If the module was not purged on recompilation, this would fail.
+      assert :v2 == :purge_test.version()
+    end)
+  end
+
+  test "continues even if one file fails to compile" do
+    in_fixture("compile_erlang", fn ->
+      file = Path.absname("src/zzz.erl")
+      source = deterministic_source(file)
+
+      File.write!(file, """
+      -module(zzz).
+      def zzz(), do: b
+      """)
+
+      capture_io(fn ->
+        assert {:error, [diagnostic]} = Mix.Tasks.Compile.Erlang.run([])
+
+        assert %Mix.Task.Compiler.Diagnostic{
+                 compiler_name: "erl_parse",
+                 file: ^source,
+                 source: ^source,
+                 message: "syntax error before: zzz",
+                 position: position(2, 5),
+                 severity: :error
+               } = diagnostic
+      end)
+
+      assert File.regular?("_build/dev/lib/sample/ebin/b.beam")
+      assert File.regular?("_build/dev/lib/sample/ebin/c.beam")
+    end)
+  end
+
+  test "saves warnings between builds" do
+    in_fixture("compile_erlang", fn ->
+      file = Path.absname("src/has_warning.erl")
+      source = deterministic_source(file)
+
+      File.write!(file, """
+      -module(has_warning).
+      my_fn() -> ok.
+      """)
+
+      capture_io(fn ->
+        assert {:ok, [diagnostic]} = Mix.Tasks.Compile.Erlang.run([])
+
+        assert %Mix.Task.Compiler.Diagnostic{
+                 file: ^source,
+                 source: ^source,
+                 compiler_name: "erl_lint",
+                 message: "function my_fn/0 is unused",
+                 position: position(2, 1),
+                 severity: :warning
+               } = diagnostic
+
+        capture_io(:stderr, fn ->
+          # Should return warning without recompiling file
+          assert {:noop, [^diagnostic]} = Mix.Tasks.Compile.Erlang.run(["--verbose"])
+          refute_received {:mix_shell, :info, ["Compiled src/has_warning.erl"]}
+
+          assert [^diagnostic] = Mix.Tasks.Compile.Erlang.diagnostics()
+          assert [^diagnostic] = Mix.Task.Compiler.diagnostics()
+
+          # Should not return warning after changing file
+          File.write!(file, """
+          -module(has_warning).
+          -export([my_fn/0]).
+          my_fn() -> ok.
+          """)
+
+          ensure_touched(file)
+          assert {:ok, []} = Mix.Tasks.Compile.Erlang.run([])
+        end)
+      end)
+    end)
+  end
+
+  test "prints warnings from stale files with --all-warnings" do
+    in_fixture("compile_erlang", fn ->
+      file = Path.absname("src/has_warning.erl")
+
+      File.write!(file, """
+      -module(has_warning).
+      my_fn() -> ok.
+      """)
+
+      capture_io(fn -> Mix.Tasks.Compile.Erlang.run([]) end)
+
+      assert capture_io(:stderr, fn ->
+               assert {:noop, _} = Mix.Tasks.Compile.Erlang.run([])
+             end) =~ ~r"has_warning.erl:2:(1:)? warning: function my_fn/0 is unused\n"
+
+      assert capture_io(:stderr, fn ->
+               assert {:noop, _} = Mix.Tasks.Compile.Erlang.run([])
+             end) =~ ~r"has_warning.erl:2:(1:)? warning: function my_fn/0 is unused\n"
+
+      # Should not print old warnings after fixing
+      File.write!(file, """
+      -module(has_warning).
+      """)
+
+      ensure_touched(file)
+
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Compile.Erlang.run(["--all-warnings"])
+        end)
+
+      assert output == ""
+    end)
+  end
+
+  test "returns syntax error from an Erlang file when --return-errors is set" do
+    in_fixture("no_mixfile", fn ->
+      import ExUnit.CaptureIO
+
+      file = Path.absname("src/a.erl")
+      source = deterministic_source(file)
+
+      File.mkdir!("src")
+
+      File.write!(file, """
+      -module(b).
+      def b(), do: b
+      """)
+
+      capture_io(fn ->
+        assert {:error, [diagnostic]} =
+                 Mix.Tasks.Compile.Erlang.run(["--force", "--return-errors"])
+
+        assert %Mix.Task.Compiler.Diagnostic{
+                 compiler_name: "erl_parse",
+                 file: ^source,
+                 source: ^source,
+                 message: "syntax error before: b",
+                 position: position(2, 5),
+                 severity: :error
+               } = diagnostic
+      end)
+
+      refute File.regular?("ebin/Elixir.A.beam")
+      refute File.regular?("ebin/Elixir.B.beam")
+    end)
+  end
+
+  @tag erlc_options: [{:warnings_as_errors, true}]
+  test "adds :debug_info to erlc_options by default" do
+    in_fixture("compile_erlang", fn ->
+      Mix.Tasks.Compile.Erlang.run([])
+
+      binary = File.read!("_build/dev/lib/sample/ebin/b.beam")
+
+      {:ok, {_, [debug_info: {:debug_info_v1, _, {debug_info, _}}]}} =
+        :beam_lib.chunks(binary, [:debug_info])
+
+      assert debug_info != :none
+    end)
+  end
+
+  if :deterministic in :compile.env_compiler_options() do
+    defp deterministic_source(file), do: Path.basename(file)
+  else
+    defp deterministic_source(file), do: file
   end
 end
diff --git a/lib/mix/test/mix/tasks/compile.leex_test.exs b/lib/mix/test/mix/tasks/compile.leex_test.exs
index f312e3cdecb..aa8aebdc528 100644
--- a/lib/mix/test/mix/tasks/compile.leex_test.exs
+++ b/lib/mix/test/mix/tasks/compile.leex_test.exs
@@ -1,53 +1,66 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.Compile.LeexTest do
   use MixTest.Case
   import ExUnit.CaptureIO
 
   setup do
-    Mix.Project.push MixTest.Case.Sample
+    Mix.ProjectStack.post_config(compilers: [:leex | Mix.compilers()])
+    Mix.Project.push(MixTest.Case.Sample)
     :ok
   end
 
   test "compilation continues if one file fails to compile" do
-    in_fixture "compile_leex", fn ->
-      File.write! "src/zzz.xrl", """
+    in_fixture("compile_leex", fn ->
+      file = Path.absname("src/zzz.xrl")
+
+      File.write!(file, """
       oops.
-      """
+      """)
 
-      assert_raise CompileError, fn ->
-        capture_io fn ->
-          Mix.Tasks.Compile.Leex.run ["--force"]
-        end
-      end
+      capture_io(fn ->
+        assert {:error, [diagnostic]} = Mix.Tasks.Compile.Leex.run(["--force"])
+
+        assert %Mix.Task.Compiler.Diagnostic{
+                 compiler_name: "leex",
+                 file: ^file,
+                 source: ^file,
+                 message: "missing Definitions",
+                 position: 1,
+                 severity: :error
+               } = diagnostic
+      end)
 
       assert File.regular?("src/test_ok.erl")
-    end
+    end)
   end
 
   test "compiles src/test_ok.xrl" do
-    in_fixture "compile_leex", fn ->
-      assert Mix.Tasks.Compile.Leex.run([]) == :ok
-
+    in_fixture("compile_leex", fn ->
+      assert Mix.Tasks.Compile.Leex.run(["--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled src/test_ok.xrl"]}
       assert File.regular?("src/test_ok.erl")
 
-      assert Mix.Tasks.Compile.Leex.run([]) == :noop
+      assert Mix.Tasks.Compile.Leex.run(["--verbose"]) == {:noop, []}
       refute_received {:mix_shell, :info, ["Compiled src/test_ok.xrl"]}
 
-      assert Mix.Tasks.Compile.Leex.run(["--force"]) == :ok
+      assert Mix.Tasks.Compile.Leex.run(["--force", "--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled src/test_ok.xrl"]}
-    end
+    end)
   end
 
   test "removes old artifact files" do
-    in_fixture "compile_leex", fn ->
-      assert Mix.Tasks.Compile.Leex.run([]) == :ok
+    in_fixture("compile_leex", fn ->
+      assert Mix.Tasks.Compile.Leex.run([]) == {:ok, []}
       assert File.regular?("src/test_ok.erl")
 
       File.rm!("src/test_ok.xrl")
-      assert Mix.Tasks.Compile.Leex.run([]) == :ok
+      assert Mix.Tasks.Compile.Leex.run([]) == {:ok, []}
       refute File.regular?("src/test_ok.erl")
-    end
+    end)
   end
 end
diff --git a/lib/mix/test/mix/tasks/compile.protocols_test.exs b/lib/mix/test/mix/tasks/compile.protocols_test.exs
deleted file mode 100644
index a9b598db077..00000000000
--- a/lib/mix/test/mix/tasks/compile.protocols_test.exs
+++ /dev/null
@@ -1,22 +0,0 @@
-Code.require_file "../../test_helper.exs", __DIR__
-
-defmodule Mix.Tasks.Compile.ProtocolsTest do
-  use MixTest.Case
-
-  test "compiles and consolidates protocols" do
-    Mix.Project.push MixTest.Case.Sample
-
-    in_fixture "no_mixfile", fn ->
-      assert Mix.Tasks.Compile.Protocols.run([]) == :ok
-      assert_received {:mix_shell, :info, ["Consolidated Enumerable"]}
-
-      assert File.regular? "_build/dev/consolidated/Elixir.Enumerable.beam"
-      purge [Enumerable]
-
-      Code.prepend_path("_build/dev/consolidated")
-      assert Protocol.consolidated?(Enumerable)
-    end
-  after
-    purge [Enumerable]
-  end
-end
diff --git a/lib/mix/test/mix/tasks/compile.yecc_test.exs b/lib/mix/test/mix/tasks/compile.yecc_test.exs
index ac1a7a1344f..65277e7b85d 100644
--- a/lib/mix/test/mix/tasks/compile.yecc_test.exs
+++ b/lib/mix/test/mix/tasks/compile.yecc_test.exs
@@ -1,53 +1,116 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.Compile.YeccTest do
   use MixTest.Case
   import ExUnit.CaptureIO
 
+  defmacro position(line, column), do: {line, column}
+
   setup do
-    Mix.Project.push MixTest.Case.Sample
+    Mix.ProjectStack.post_config(compilers: [:yecc | Mix.compilers()])
+    Mix.Project.push(MixTest.Case.Sample)
     :ok
   end
 
   test "compilation continues if one file fails to compile" do
-    in_fixture "compile_yecc", fn ->
-      File.write! "src/zzz.yrl", """
+    in_fixture("compile_yecc", fn ->
+      file = Path.absname("src/zzz.yrl")
+
+      File.write!(file, """
       oops.
-      """
+      """)
+
+      capture_io(fn ->
+        assert {:error, [diagnostic]} = Mix.Tasks.Compile.Yecc.run(["--force"])
 
-      assert_raise CompileError, fn ->
-        capture_io fn ->
-          Mix.Tasks.Compile.Yecc.run ["--force"]
-        end
-      end
+        assert %Mix.Task.Compiler.Diagnostic{
+                 compiler_name: "yecc",
+                 file: ^file,
+                 source: ^file,
+                 message: message,
+                 position: position(1, 5),
+                 severity: :error
+               } = diagnostic
+
+        assert message =~ "syntax error before: "
+      end)
 
       assert File.regular?("src/test_ok.erl")
-    end
+    end)
+  end
+
+  test "returns warning diagnostics on conflicts" do
+    in_fixture("compile_yecc", fn ->
+      file = Path.absname("src/conflict.yrl")
+
+      File.write!(file, """
+      Nonterminals exp.
+      Terminals number '+'.
+      Rootsymbol exp.
+      exp -> exp '+' exp.
+      exp -> number.
+      """)
+
+      capture_io(fn ->
+        assert {:ok, [diagnostic]} = Mix.Tasks.Compile.Yecc.run(["--force"])
+
+        assert %Mix.Task.Compiler.Diagnostic{
+                 compiler_name: "yecc",
+                 file: ^file,
+                 source: ^file,
+                 message: "conflicts: 1 shift/reduce, 0 reduce/reduce",
+                 position: 0,
+                 severity: :warning
+               } = diagnostic
+      end)
+
+      # Removing parse tools re-add it later even if only to show warnings
+      :code.del_path(:parsetools)
+      purge([:yecc])
+      refute Code.ensure_loaded?(:yecc)
+
+      capture_io(fn ->
+        assert {:noop, [diagnostic]} = Mix.Tasks.Compile.Yecc.run([])
+
+        assert %Mix.Task.Compiler.Diagnostic{
+                 compiler_name: "yecc",
+                 file: ^file,
+                 source: ^file,
+                 message: "conflicts: 1 shift/reduce, 0 reduce/reduce",
+                 position: 0,
+                 severity: :warning
+               } = diagnostic
+      end)
+    end)
   end
 
   test "compiles src/test_ok.yrl" do
-    in_fixture "compile_yecc", fn ->
-      assert Mix.Tasks.Compile.Yecc.run([]) == :ok
+    in_fixture("compile_yecc", fn ->
+      assert Mix.Tasks.Compile.Yecc.run(["--verbose"]) == {:ok, []}
 
       assert_received {:mix_shell, :info, ["Compiled src/test_ok.yrl"]}
       assert File.regular?("src/test_ok.erl")
 
-      assert Mix.Tasks.Compile.Yecc.run([]) == :noop
+      assert Mix.Tasks.Compile.Yecc.run(["--verbose"]) == {:noop, []}
       refute_received {:mix_shell, :info, ["Compiled src/test_ok.yrl"]}
 
-      assert Mix.Tasks.Compile.Yecc.run(["--force"]) == :ok
+      assert Mix.Tasks.Compile.Yecc.run(["--force", "--verbose"]) == {:ok, []}
       assert_received {:mix_shell, :info, ["Compiled src/test_ok.yrl"]}
-    end
+    end)
   end
 
   test "removes old artifact files" do
-    in_fixture "compile_yecc", fn ->
-      assert Mix.Tasks.Compile.Yecc.run([]) == :ok
+    in_fixture("compile_yecc", fn ->
+      assert Mix.Tasks.Compile.Yecc.run([]) == {:ok, []}
       assert File.regular?("src/test_ok.erl")
 
       File.rm!("src/test_ok.yrl")
-      assert Mix.Tasks.Compile.Yecc.run([]) == :ok
+      assert Mix.Tasks.Compile.Yecc.run([]) == {:ok, []}
       refute File.regular?("src/test_ok.erl")
-    end
+    end)
   end
 end
diff --git a/lib/mix/test/mix/tasks/compile_test.exs b/lib/mix/test/mix/tasks/compile_test.exs
index 73cc8828901..d202102790e 100644
--- a/lib/mix/test/mix/tasks/compile_test.exs
+++ b/lib/mix/test/mix/tasks/compile_test.exs
@@ -1,59 +1,553 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.CompileTest do
   use MixTest.Case
 
-  defmodule CustomCompilers do
+  defmacro position(line, column), do: {line, column}
+
+  defmodule DepsApp do
     def project do
-      [compilers: [:elixir, :app, :custom]]
+      [app: :deps_app, version: "0.1.0", deps: [{:ok, "0.1.0", path: "deps/ok"}]]
     end
   end
 
-  setup do
-    Mix.Project.push MixTest.Case.Sample
+  defmodule WrongPath do
+    def project do
+      [app: :apps_path_bug, apps_path: "this_path_does_not_exist"]
+    end
+  end
+
+  setup tags do
+    Mix.ProjectStack.post_config(Map.get(tags, :project, []))
+    Mix.Project.push(MixTest.Case.Sample)
     :ok
   end
 
-  test "mix compile --list with mixfile" do
-    Mix.Tasks.Compile.run ["--list"]
-    assert_received {:mix_shell, :info, ["\nEnabled compilers: yecc, leex, erlang, elixir, app"]}
-    assert_received {:mix_shell, :info, ["mix compile.elixir    # " <> _]}
+  test "compiles --list with mixfile" do
+    Mix.Task.run("compile", ["--list"])
+
+    msg = "\nEnabled compilers: yecc, leex, erlang, elixir, app, protocols"
+    assert_received {:mix_shell, :info, [^msg]}
+
+    assert_received {:mix_shell, :info, ["mix compile.elixir # " <> _]}
   end
 
-  test "mix compile --list with custom mixfile" do
-    Mix.Project.push CustomCompilers
-    Mix.Tasks.Compile.run ["--list"]
-    assert_received {:mix_shell, :info, ["\nEnabled compilers: elixir, app, custom"]}
+  @tag project: [compilers: [:elixir, :app, :custom]]
+  test "compiles --list with custom mixfile" do
+    Mix.Task.run("compile", ["--list"])
+
+    assert_received {:mix_shell, :info,
+                     ["\nEnabled compilers: yecc, leex, elixir, app, custom, protocols"]}
   end
 
-  test "compile a project with mixfile" do
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Compile.run []
+  @tag project: [compilers: [:elixir, :app, :custom]]
+  test "compiles does not require all compilers available on manifest" do
+    assert Mix.Task.Compiler.manifests() |> Enum.map(&Path.basename/1) ==
+             ["compile.yecc", "compile.leex", "compile.elixir"]
+  end
+
+  test "compiles a project with mixfile" do
+    in_fixture("no_mixfile", fn ->
+      assert Mix.Task.run("compile", ["--verbose"]) == {:ok, []}
       assert File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
       assert File.regular?("_build/dev/lib/sample/ebin/sample.app")
       assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
-      assert_received {:mix_shell, :info, ["Generated sample.app"]}
-    end
+      assert_received {:mix_shell, :info, ["Generated sample app"]}
+      assert File.regular?("_build/dev/lib/sample/consolidated/Elixir.Enumerable.beam")
+
+      Mix.Task.clear()
+      assert Mix.Task.run("compile", ["--verbose"]) == {:noop, []}
+      refute_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
+    end)
+  end
+
+  test "compiles a project with cached deps information" do
+    Mix.Project.pop()
+
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DepsApp)
+
+      File.mkdir_p!("lib")
+
+      File.write!("lib/a.ex", """
+      root = File.cwd!()
+      File.cd!("lib", fn ->
+        %{ok: path} = Mix.Project.deps_paths()
+
+        if Path.relative_to(path, root) != "deps/ok" do
+          raise "non cached path"
+        end
+      end)
+      """)
+
+      assert Mix.Task.run("compile", ["--force", "--from-mix-deps-compile"]) == {:ok, []}
+    end)
+  end
+
+  @tag project: [compilers: Mix.compilers() ++ [:my_custom_compiler]]
+  test "compiles a project with custom in-project compiler" do
+    in_fixture("no_mixfile", fn ->
+      File.mkdir_p!("lib")
+
+      File.write!("lib/a.ex", """
+      defmodule Mix.Tasks.Compile.MyCustomCompiler do
+        use Mix.Task.Compiler
+
+        @impl true
+        def run(_args) do
+          Mix.shell().info("Compiling...")
+          :ok
+        end
+      end
+      """)
+
+      assert Mix.Task.run("compile") == {:ok, []}
+      assert_receive {:mix_shell, :info, ["Compiling..."]}
+      Code.delete_path(Mix.Project.compile_path())
+      purge([Mix.Tasks.Compile.MyCustomCompiler])
+      false = Code.ensure_loaded?(Mix.Tasks.Compile.MyCustomCompiler)
+
+      Mix.Task.clear()
+      assert Mix.Task.rerun("compile")
+    end)
+  end
+
+  test "reenables compilers" do
+    in_fixture("no_mixfile", fn ->
+      assert Mix.Tasks.Compile.run(["--verbose"]) == {:ok, []}
+      Mix.shell().flush()
+
+      File.mkdir_p!("lib/foo")
+
+      File.write!("lib/foo/z1.ex", """
+      defmodule Z1 do
+        def ok, do: :ok
+      end
+      """)
+
+      assert :ok = Mix.Task.reenable("compile")
+      assert {:noop, []} = Mix.Task.run("compile")
+      refute File.regular?("_build/dev/lib/sample/ebin/Elixir.Z1.beam")
+
+      assert :ok = Mix.Task.Compiler.reenable([])
+      assert {:noop, []} = Mix.Task.run("compile")
+      refute File.regular?("_build/dev/lib/sample/ebin/Elixir.Z1.beam")
+
+      assert :ok = Mix.Task.Compiler.reenable(["erlang"])
+      assert {:noop, []} = Mix.Task.run("compile")
+      refute File.regular?("_build/dev/lib/sample/ebin/Elixir.Z1.beam")
+
+      assert :ok = Mix.Task.Compiler.reenable()
+      assert {:ok, []} = Mix.Task.run("compile")
+      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.Z1.beam")
+
+      File.write!("lib/foo/z2.ex", """
+      defmodule Z2 do
+        def ko, do: :ko
+      end
+      """)
+
+      assert :ok = Mix.Task.Compiler.reenable([:erlang])
+      assert {:noop, []} = Mix.Task.run("compile")
+      refute File.regular?("_build/dev/lib/sample/ebin/Elixir.Z2.beam")
+
+      assert :ok = Mix.Task.Compiler.reenable([:elixir])
+      assert {:ok, []} = Mix.Task.run(:compile)
+      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.Z2.beam")
+    end)
+  end
+
+  test "recompiles app cache if manifest changes" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Tasks.Compile.run(["--force"])
+      purge([A, B])
+
+      File.rm!("_build/dev/lib/sample/.mix/compile.app_cache")
+      Mix.Task.clear()
+
+      Mix.Tasks.Compile.run(["--force"])
+      assert File.exists?("_build/dev/lib/sample/.mix/compile.app_cache")
+    end)
+  end
+
+  # A.info/0 is loaded dynamically
+  @compile {:no_warn_undefined, {A, :info, 0}}
+
+  test "adds Logger application metadata" do
+    import ExUnit.CaptureLog
+
+    in_fixture("no_mixfile", fn ->
+      Process.put({MixTest.Case.Sample, :application}, extra_applications: [:logger])
+
+      File.write!("lib/a.ex", """
+      defmodule A do
+      require Logger
+      def info, do: Logger.info("hello")
+      end
+      """)
+
+      assert Mix.Task.run("compile", []) == {:ok, []}
+
+      try do
+        assert capture_log([metadata: [:application]], &A.info/0) =~ "application=sample"
+      after
+        purge([A])
+      end
+    end)
+  end
+
+  test "returns errors from compilers when --return-errors is set" do
+    in_fixture("no_mixfile", fn ->
+      File.write!("lib/a.ex", """
+      defmodule A do
+        def my_fn(), do: $$$
+      end
+      """)
+
+      file = Path.absname("lib/a.ex")
+
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        assert {:error, [diagnostic]} = Mix.Task.run("compile", ["--return-errors"])
+
+        assert %Mix.Task.Compiler.Diagnostic{
+                 file: ^file,
+                 source: ^file,
+                 severity: :error,
+                 position: {2, 20},
+                 message: "** (SyntaxError) invalid syntax found on lib/a.ex:2:" <> _,
+                 compiler_name: "Elixir",
+                 details: {:error, %SyntaxError{}}
+               } = diagnostic
+      end)
+    end)
+  end
+
+  test "calling raise inside a macro returns a diagnostic with a position" do
+    in_fixture("no_mixfile", fn ->
+      File.write!("lib/a.ex", """
+      defmodule A do
+        defmacro custom_macro do
+          raise "error"
+        end
+      end
+      """)
+
+      File.write!("lib/b.ex", """
+      defmodule B do
+        require A
+        A.custom_macro()
+      end
+      """)
+
+      file = Path.absname("lib/b.ex")
+
+      ExUnit.CaptureIO.capture_io(:stderr, fn ->
+        assert {:error, [diagnostic]} = Mix.Task.run("compile", ["--return-errors"])
+
+        assert %Mix.Task.Compiler.Diagnostic{
+                 file: ^file,
+                 source: ^file,
+                 severity: :error,
+                 position: 3,
+                 message: "** (RuntimeError) error\n    expanding macro: A.custom_macro/0" <> _,
+                 compiler_name: "Elixir"
+               } = diagnostic
+      end)
+    end)
+  end
+
+  test "skip protocol consolidation when --no-protocol-consolidation" do
+    in_fixture("no_mixfile", fn ->
+      File.rm("_build/dev/lib/sample/.mix/compile.protocols")
+      assert Mix.Task.run("compile", ["--no-protocol-consolidation"]) == {:ok, []}
+      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
+      refute File.regular?("_build/dev/lib/sample/consolidated/Elixir.Enumerable.beam")
+    end)
+  end
+
+  test "loads consolidated protocols even on --no-compile" do
+    in_fixture("no_mixfile", fn ->
+      File.rm("_build/dev/lib/sample/.mix/compile.protocols")
+      consolidated = "_build/dev/lib/sample/consolidated" |> Path.expand() |> to_charlist()
+
+      assert Mix.Task.run("compile") == {:ok, []}
+      assert File.regular?("_build/dev/lib/sample/consolidated/Elixir.Enumerable.beam")
+      assert consolidated in :code.get_path()
+
+      Code.delete_path("_build/dev/lib/sample/consolidated")
+      assert Mix.Task.rerun("compile", ["--no-compile"]) == {:noop, []}
+      assert consolidated in :code.get_path()
+    end)
+  end
+
+  test "loads Mix config with --erl-config" do
+    in_fixture("no_mixfile", fn ->
+      File.write!("mix.config", "{erl_config_app, [{value, true}]}.")
+      assert Mix.Task.run("compile", ["--erl-config", "mix.config"]) == {:ok, []}
+      assert File.regular?("_build/dev/lib/sample/ebin/Elixir.A.beam")
+      assert Application.get_env(:erl_config_app, :value)
+    end)
+  after
+    Application.delete_env(:erl_config_app, :value)
+  end
+
+  test "runs after_compiler callback once" do
+    in_fixture("no_mixfile", fn ->
+      callback = fn result -> send(self(), result) end
+
+      assert Mix.Task.Compiler.after_compiler(:elixir, callback) == :ok
+      assert Mix.Task.rerun("compile", []) == {:ok, []}
+      assert_received {:ok, []}
+
+      Mix.Task.clear()
+      assert Mix.Task.rerun("compile", []) == {:noop, []}
+      refute_received {:noop, []}
+
+      Mix.Task.clear()
+      assert Mix.Task.Compiler.after_compiler(:elixir, callback) == :ok
+      assert Mix.Task.run("compile", []) == {:noop, []}
+      assert_received {:noop, []}
+    end)
+  end
+
+  test "does not crash on a project with bad path" do
+    Mix.Project.pop()
+    Mix.Project.push(WrongPath)
+
+    ExUnit.CaptureIO.capture_io(fn ->
+      assert Mix.Task.run("compile", ["--no-protocol-consolidation"]) == {:noop, []}
+    end)
   end
 
-  test "compile a project with multiple compilers and a syntax error in an erlang file" do
-    in_fixture "no_mixfile", fn ->
-      import ExUnit.CaptureIO
+  test "validates compile_env" do
+    in_fixture("no_mixfile", fn ->
+      File.mkdir_p!("config")
 
-      File.mkdir! "src"
-      File.write! "src/a.erl", """
-      -module(b).
-      def b(), do: b
-      """
-      assert File.regular?("src/a.erl")
+      File.write!("config/config.exs", """
+      import Config
+      config :sample, :hello, System.get_env("MIX_SAMPLE_HELLO")
+      """)
 
-      assert_raise CompileError, fn ->
-        capture_io fn -> Mix.Tasks.Compile.run ["--force"] end
+      File.write!("lib/a.ex", """
+      defmodule A do
+        require Application
+        _ = Application.compile_env(:sample, :hello)
       end
+      """)
+
+      System.put_env("MIX_SAMPLE_HELLO", "compile")
+      Mix.Tasks.Loadconfig.run([])
+      assert Mix.Tasks.Compile.All.run([]) == {:ok, []}
+
+      System.put_env("MIX_SAMPLE_HELLO", "runtime")
+      Mix.Tasks.Loadconfig.run([])
+      Application.unload(:sample)
+
+      assert_raise Mix.Error,
+                   ~r/the application :sample has a different value set for key :hello during runtime compared to compile time/,
+                   fn -> Mix.Tasks.Compile.All.run([]) end
+
+      # Can start if compile env matches
+      System.put_env("MIX_SAMPLE_HELLO", "compile")
+      Mix.Tasks.Loadconfig.run([])
+      assert Mix.Tasks.App.Start.run([]) == :ok
+    end)
+  after
+    System.delete_env("MIX_SAMPLE_HELLO")
+    Application.delete_env(:sample, :hello, persistent: true)
+  end
+
+  test "code path pruning" do
+    Mix.ensure_application!(:parsetools)
+    otp_docs? = match?({:docs_v1, _, _, _, _, _, _}, Code.fetch_docs(:zlib))
+
+    in_fixture("no_mixfile", fn ->
+      assert Mix.Task.run("compile", []) == {:ok, []}
+      assert :code.where_is_file(~c"parsetools.app") == :non_existing
+
+      # Make sure erts is also kept but not loaded
+      assert Application.spec(:erts, :vsn) == nil
+
+      if otp_docs? do
+        assert {:docs_v1, _, _, _, _, _, _} = Code.fetch_docs(:zlib)
+      else
+        IO.warn("Erlang/OTP was not compiled with docs, skipping assertion")
+      end
+    end)
+  end
+
+  test "code path pruning disabled" do
+    Mix.ensure_application!(:parsetools)
+
+    in_fixture("no_mixfile", fn ->
+      assert Mix.Task.run("compile", ["--no-prune-code-paths"]) == {:ok, []}
+      assert is_list(:code.where_is_file(~c"parsetools.app"))
+    end)
+  end
+
+  test "listening to concurrent compilations" do
+    timeout = 2_000
+
+    Mix.Project.pop()
+
+    in_fixture("compile_listeners", fn ->
+      File.write!("mix.exs", """
+        defmodule WithReloader do
+          use Mix.Project
+
+          def project do
+            [
+              app: :with_reloader,
+              version: "0.1.0",
+              deps: [{:reloader, "0.1.0", path: "deps/reloader"}],
+              # Register a listener from a dependency
+              listeners: [Reloader]
+            ]
+          end
+        end
+      """)
+
+      File.mkdir_p!("config")
+
+      File.mkdir_p!("lib")
+
+      File.write!("lib/a.ex", "defmodule A do end")
+      File.write!("lib/b.ex", "defmodule B do end")
+      File.write!("lib/c.ex", "defmodule C do end")
+
+      File.mkdir_p!("src")
+
+      File.write!("src/a.erl", "-module(a).")
+      File.write!("src/b.erl", "-module(b).")
+      File.write!("src/c.erl", "-module(c).")
+
+      # Ensure we can boot without compilation and listeners if desired
+      assert mix(["loadpaths", "--no-compile", "--no-listeners"]) == ""
+
+      # Ensure we can boot only with --no-deps-check if desired
+      assert mix(["loadpaths", "--no-deps-check"]) == ""
+
+      # Now setup dependencies
+      mix(["deps.compile"])
+
+      parent = self()
+
+      spawn_link(fn ->
+        port =
+          mix_port([
+            "run",
+            "--no-halt",
+            "--no-compile",
+            "--no-start",
+            "--eval",
+            ~s/IO.puts("ok"); IO.gets(""); System.halt()/
+          ])
+
+        assert_receive {^port, {:data, "ok\n"}}, timeout
+        send(parent, :mix_started)
+
+        send_port_outputs_to(port, parent)
+      end)
+
+      assert_receive :mix_started, timeout
+
+      # Project compilation
+
+      output = mix(["do", "compile", "+", "eval", "IO.write System.pid"])
+      os_pid = output |> String.split("\n") |> List.last()
+
+      assert_receive {:output, output}, timeout
+
+      assert output == """
+             Received :modules_compiled with
+               added: [:a, :b, :c], changed: [], removed: []
+               app: :with_reloader
+               scm: Mix.SCM.Path
+               os_pid: "#{os_pid}"
+             """
+
+      assert_receive {:output, output}, timeout
+
+      assert output == """
+             Received :modules_compiled with
+               added: [A, B, C], changed: [], removed: []
+               app: :with_reloader
+               scm: Mix.SCM.Path
+               os_pid: "#{os_pid}"
+             """
+
+      # Changed
+      File.write!("lib/a.ex", "defmodule A do @moduledoc false end")
+      File.write!("src/a.erl", "-module(a). -export([a/0]). a() -> ok.")
+      File.touch!("src/a.erl", System.os_time(:second) + 10)
+      # Removed
+      File.rm!("lib/b.ex")
+      File.rm!("src/b.erl")
+      # New
+      File.write!("lib/d.ex", "defmodule D do end")
+      File.write!("src/d.erl", "-module(d).")
+
+      # Project recompilation
+
+      output = mix(["do", "compile", "+", "eval", "IO.write System.pid"])
+      os_pid = output |> String.split("\n") |> List.last()
+
+      assert_receive {:output, output}, timeout
+
+      assert output == """
+             Received :modules_compiled with
+               added: [:d], changed: [:a], removed: [:b]
+               app: :with_reloader
+               scm: Mix.SCM.Path
+               os_pid: "#{os_pid}"
+             """
+
+      assert_receive {:output, output}, timeout
+
+      assert output == """
+             Received :modules_compiled with
+               added: [D], changed: [A], removed: [B]
+               app: :with_reloader
+               scm: Mix.SCM.Path
+               os_pid: "#{os_pid}"
+             """
+
+      # Dependency recompilation
+
+      output = mix(["do", "deps.compile", "--force", "+", "eval", "IO.write System.pid"])
+      os_pid = output |> String.split("\n") |> List.last()
+
+      assert_receive {:output, output}, timeout
+
+      assert output == """
+             Received :modules_compiled with
+               added: [Reloader], changed: [], removed: []
+               app: :reloader
+               scm: Mix.SCM.Path
+               os_pid: "#{os_pid}"
+             """
+
+      assert_receive {:output, output}, timeout
+
+      assert output == """
+             Received :dep_compiled with
+               app: :reloader
+               scm: Mix.SCM.Path
+               manager: :mix
+               os_pid: "#{os_pid}"
+             """
+    end)
+  end
 
-      refute File.regular?("ebin/Elixir.A.beam")
-      refute File.regular?("ebin/Elixir.B.beam")
-      refute File.regular?("ebin/Elixir.C.beam")
+  defp send_port_outputs_to(port, pid) do
+    receive do
+      {^port, {:data, output}} ->
+        send(pid, {:output, output})
+        send_port_outputs_to(port, pid)
     end
   end
 end
diff --git a/lib/mix/test/mix/tasks/deps.git_test.exs b/lib/mix/test/mix/tasks/deps.git_test.exs
index 0adbb2dc0b1..58e52f196e9 100644
--- a/lib/mix/test/mix/tasks/deps.git_test.exs
+++ b/lib/mix/test/mix/tasks/deps.git_test.exs
@@ -1,93 +1,163 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.DepsGitTest do
   use MixTest.Case
 
   defmodule DepsOnGitApp do
     def project do
-      [ app: :deps_on_git_app,
+      [
+        app: :deps_on_git_app,
         version: "0.1.0",
         deps: [
-          {:deps_on_git_repo, "0.2.0", git: MixTest.Case.fixture_path("deps_on_git_repo")}
-        ] ]
+          {:deps_on_git_repo, "0.2.0", git: fixture_path("deps_on_git_repo")}
+        ]
+      ]
     end
   end
 
   defmodule GitApp do
     def project do
-      [ app: :git_app,
+      opts = Process.get(:git_repo_opts) || []
+
+      [
+        app: :git_app,
         version: "0.1.0",
         deps: [
-          {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo")}
-        ] ]
+          {:git_repo, "0.1.0", [git: fixture_path("git_repo")] ++ opts}
+        ]
+      ]
     end
   end
 
   defmodule GitSubmodulesApp do
     def project do
-      [ app: :git_app,
+      [
+        app: :git_app,
         version: "0.1.0",
         deps: [
-          {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo"), submodules: true}
-        ] ]
+          {:git_repo, "0.1.0", git: fixture_path("git_repo"), submodules: true}
+        ]
+      ]
     end
   end
 
   defmodule GitErrorApp do
     def project do
-      [ deps: [
-          {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("not_git_repo")}
-        ] ]
+      [
+        deps: [
+          {:git_repo, "0.1.0", git: fixture_path("not_git_repo")}
+        ]
+      ]
     end
   end
 
-  test "gets and updates git repos with compilation" do
-    Mix.Project.push GitApp
+  test "gets and updates Git repos with compilation" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
       assert_received {:mix_shell, :info, [^message]}
+
       assert File.read!("mix.lock") =~
-             ~r/"git_repo": {:git, #{inspect fixture_path("git_repo")}, "[a-f0-9]+", \[\]}/
+               ~r/"git_repo": {:git, #{inspect(fixture_path("git_repo"))}, "[a-f0-9]+", \[\]}/
 
-      Mix.Tasks.Deps.Update.run ["--all"]
+      Mix.Tasks.Deps.Update.run(["--all"])
       message = "* Updating git_repo (#{fixture_path("git_repo")})"
       assert_received {:mix_shell, :info, [^message]}
-    end
+    end)
+  end
+
+  test "gets and updates Git repos with submodules" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitSubmodulesApp)
+
+      Mix.Tasks.Deps.Get.run([])
+      message = "* Getting git_repo (#{fixture_path("git_repo")})"
+      assert_received {:mix_shell, :info, [^message]}
+      assert File.read!("mix.lock") =~ "submodules: true"
+    end)
+  end
+
+  test "gets with short ref" do
+    [<<short_sha1::binary-size(8), _::binary>>, _ | _] = get_git_repo_revs("git_repo")
+    Process.put(:git_repo_opts, ref: short_sha1)
+
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
+
+      Mix.Tasks.Deps.Get.run([])
+      message = "* Getting git_repo (#{fixture_path("git_repo")} - #{short_sha1})"
+      assert_received {:mix_shell, :info, [^message]}
+
+      refute_received {:mix_shell, :error, _}
+    end)
+  end
+
+  @tag :git_sparse
+  test "gets and updates Git repos with sparse checkout" do
+    Process.put(:git_repo_opts, sparse: "sparse_dir")
+
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
+
+      Mix.Tasks.Deps.Get.run([])
+      message = "* Getting git_repo (#{fixture_path("git_repo")})"
+      assert_received {:mix_shell, :info, [^message]}
+      refute File.exists?("deps/git_repo/mix.exs")
+      assert File.exists?("deps/git_repo/sparse_dir/mix.exs")
+      assert File.read!("mix.lock") =~ "sparse: \"sparse_dir\""
+    end)
+  end
+
+  test "gets and updates Git repos with subdir" do
+    Process.put(:git_repo_opts, subdir: "subdir")
+
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
+
+      Mix.Tasks.Deps.Get.run([])
+      message = "* Getting git_repo (#{fixture_path("git_repo")})"
+      assert_received {:mix_shell, :info, [^message]}
+      assert File.read!("mix.lock") =~ "subdir: \"subdir\""
+    end)
   end
 
   test "handles invalid .git directory" do
-    Mix.Project.push GitApp
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
 
-    in_fixture "no_mixfile", fn ->
       File.mkdir_p!("deps/git_repo/.git")
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
       assert_received {:mix_shell, :info, [^message]}
-    end
+    end)
   end
 
   test "handles missing .git directory" do
-    Mix.Project.push GitApp
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
       assert_received {:mix_shell, :info, [^message]}
       File.rm_rf!("deps/git_repo/.git")
 
       assert_raise Mix.Error, "Can't continue due to errors on dependencies", fn ->
-        Mix.Tasks.Deps.Check.run ["git_repo"]
+        Mix.Tasks.Deps.Loadpaths.run(["git_repo"])
       end
-    end
+    end)
   end
 
   test "gets and updates many levels deep dependencies" do
-    Mix.Project.push DepsOnGitApp
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(DepsOnGitApp)
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
 
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
       assert_received {:mix_shell, :info, [^message]}
@@ -96,124 +166,116 @@ defmodule Mix.Tasks.DepsGitTest do
       assert_received {:mix_shell, :info, [^message]}
 
       assert File.exists?("deps/deps_on_git_repo/mix.exs")
-      assert File.rm("deps/deps_on_git_repo/.fetch") == :ok
       assert File.exists?("deps/git_repo/mix.exs")
-      assert File.rm("deps/git_repo/.fetch") == :ok
 
-      Mix.Tasks.Deps.Update.run ["deps_on_git_repo"]
-      assert File.exists?("deps/deps_on_git_repo/.fetch")
-      assert File.exists?("deps/git_repo/.fetch")
-    end
+      # Compile the dependencies
+      Mix.Tasks.Deps.Compile.run([])
+      assert File.exists?("_build/dev/lib/deps_on_git_repo/.mix/compile.elixir_scm")
+      assert File.exists?("_build/dev/lib/git_repo/.mix/compile.elixir_scm")
+
+      # Now update children and make sure it propagates
+      Mix.Tasks.Deps.Update.run(["git_repo"])
+      refute File.exists?("_build/dev/lib/deps_on_git_repo/.mix/compile.elixir_scm")
+      refute File.exists?("_build/dev/lib/git_repo/.mix/compile.elixir_scm")
+
+      # Clear tasks to recompile Git repo but unload it so...
+      purge([GitRepo])
+      Mix.Task.clear()
+      Mix.Tasks.Deps.Compile.run(["git_repo"])
+      assert File.exists?("_build/dev/lib/git_repo/ebin")
+      Code.delete_path("_build/dev/lib/git_repo/ebin")
+
+      # Deps on Git repo loads it automatically on compile
+      Mix.Task.reenable("deps.loadpaths")
+      Mix.Tasks.Deps.Compile.run(["deps_on_git_repo"])
+      assert File.exists?("_build/dev/lib/deps_on_git_repo/ebin")
+    end)
   after
-    purge [GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
   end
 
-  test "recompiles the project when a dep is fetched" do
-    Mix.Project.push GitApp
-
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Deps.Get.run []
-      assert File.exists?("deps/git_repo/.fetch")
-
-      # We can compile just fine
-      Mix.Tasks.Compile.run []
-      assert_received {:mix_shell, :info, ["Compiled lib/git_repo.ex"]}
-      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
-
-      # Clear up to prepare for the update
-      File.rm("_build/dev/lib/git_repo/ebin/Elixir.GitRepo.beam")
-      File.rm("_build/dev/lib/git_repo/.compile.elixir")
-      File.rm("deps/git_repo/.fetch")
-      Mix.Task.clear
-      Mix.shell.flush
-      purge [A, B, C, GitRepo]
-
-      # Update will mark the update required
-      Mix.Tasks.Deps.Update.run ["git_repo"]
-      assert File.exists?("deps/git_repo/.fetch")
-      ensure_touched("deps/git_repo/.fetch") # Ensure timestamp differs
-
-      # mix deps.compile is required...
-      Mix.Tasks.Deps.run []
-      msg = "  the dependency build is outdated, please run `mix deps.compile`"
-      assert_received {:mix_shell, :info, [^msg]}
+  test "compiles many levels deep dependencies" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(DepsOnGitApp)
 
-      # But also ran automatically
-      Mix.Tasks.Compile.run []
-      assert_received {:mix_shell, :info, ["Compiled lib/git_repo.ex"]}
-      assert_received {:mix_shell, :info, ["Compiled lib/a.ex"]}
-      :ok
-    end
+      Mix.Tasks.Deps.Get.run([])
+      refute File.exists?("_build/dev/lib/deps_on_git_repo")
+      refute File.exists?("_build/dev/lib/git_repo")
+
+      # Compile the parent with children
+      Mix.Tasks.Deps.Compile.run(["deps_on_git_repo", "--include-children"])
+      assert File.exists?("_build/dev/lib/deps_on_git_repo")
+      assert File.exists?("_build/dev/lib/git_repo")
+    end)
   after
-    purge [A, B, C, GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
   end
 
-  test "all up to date dependencies" do
-    Mix.Project.push GitApp
+  test "all dependencies have been fetched" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
       assert_received {:mix_shell, :info, [^message]}
 
-      Mix.Tasks.Deps.Get.run []
-      assert_received {:mix_shell, :info, ["All dependencies up to date"]}
-    end
+      Mix.Tasks.Deps.Get.run([])
+      assert_received {:mix_shell, :info, ["All dependencies have been fetched"]}
+    end)
   after
-    purge [GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
   end
 
   test "updates the lock when the repo updates" do
-    Mix.Project.push GitApp
+    Mix.Project.push(GitApp)
 
-    # Get git repo first revision
-    [last, first|_] = get_git_repo_revs
+    # Get Git repo first revision
+    [last, first | _] = get_git_repo_revs("git_repo")
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Dep.Lock.write [git_repo: {:git, fixture_path("git_repo"), first, []}]
+    in_fixture("no_mixfile", fn ->
+      Mix.Dep.Lock.write(%{git_repo: {:git, fixture_path("git_repo"), first, []}})
 
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       refute File.exists?("deps/git_repo/lib/git_repo.ex")
       assert File.read!("mix.lock") =~ first
 
-      Mix.Tasks.Deps.Update.run ["git_repo"]
+      Mix.Tasks.Deps.Update.run(["git_repo"])
       assert File.exists?("deps/git_repo/lib/git_repo.ex")
       assert File.read!("mix.lock") =~ last
 
-      Mix.Tasks.Deps.Clean.run ["--all"]
+      Mix.Tasks.Deps.Clean.run(["--all"])
       refute File.exists?("deps/git_repo/lib/git_repo.ex")
       assert File.read!("mix.lock") =~ last
 
-      Mix.Tasks.Deps.Clean.run ["--unlock", "--all"]
+      Mix.Tasks.Deps.Clean.run(["--unlock", "--all"])
       refute File.read!("mix.lock") =~ last
-    end
+    end)
   after
-    purge [GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
   end
 
   test "updates the repo when the lock updates" do
-    Mix.Project.push GitApp
-    [last, first|_] = get_git_repo_revs
+    Mix.Project.push(GitApp)
+    [last, first | _] = get_git_repo_revs("git_repo")
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Dep.Lock.write [git_repo: {:git, fixture_path("git_repo"), first, []}]
+    in_fixture("no_mixfile", fn ->
+      Mix.Dep.Lock.write(%{git_repo: {:git, fixture_path("git_repo"), first, []}})
 
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       refute File.exists?("deps/git_repo/lib/git_repo.ex")
       assert File.read!("mix.lock") =~ first
 
       # Update the lock and now we should get an error
-      Mix.Dep.Lock.write [git_repo: {:git, fixture_path("git_repo"), last, []}]
-      assert_raise Mix.Error, fn ->
-        Mix.Tasks.Deps.Check.run []
-      end
+      Mix.Dep.Lock.write(%{git_repo: {:git, fixture_path("git_repo"), last, []}})
+
+      assert_raise Mix.Error, fn -> Mix.Tasks.Deps.Loadpaths.run([]) end
 
       # Flush the errors we got, move to a clean slate
-      Mix.shell.flush
-      Mix.Task.clear
+      Mix.shell().flush()
+      Mix.Task.clear()
 
       # Calling get should update the dependency
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       assert File.exists?("deps/git_repo/lib/git_repo.ex")
       assert File.read!("mix.lock") =~ last
 
@@ -222,31 +284,92 @@ defmodule Mix.Tasks.DepsGitTest do
 
       # Check we got no error
       refute_received {:mix_shell, :error, _}
-    end
+    end)
   after
-    purge [GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
+  end
+
+  @tag :git_sparse
+  test "updates the repo when sparse is turned off" do
+    Process.put(:git_repo_opts, sparse: "sparse_dir")
+
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
+
+      Mix.Tasks.Deps.Get.run([])
+      refute File.exists?("deps/git_repo/lib/git_repo.ex")
+
+      # Flush the errors we got, move to a clean slate
+      Mix.shell().flush()
+      Mix.Task.clear()
+      Process.delete(:git_repo_opts)
+      Mix.Project.pop()
+      Mix.Project.push(GitApp)
+
+      # Calling get should update the dependency
+      Mix.Tasks.Deps.Get.run([])
+      refute File.read!("mix.lock") =~ "sparse_dir"
+      assert File.exists?("deps/git_repo/lib/git_repo.ex")
+
+      message = "* Updating git_repo (#{fixture_path("git_repo")})"
+      assert_received {:mix_shell, :info, [^message]}
+
+      # Check we got no error
+      refute_received {:mix_shell, :error, _}
+    end)
+  end
+
+  @tag :git_sparse
+  test "updates the repo when sparse is turned on" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
+
+      Mix.Tasks.Deps.Get.run([])
+      assert File.exists?("deps/git_repo/lib/git_repo.ex")
+
+      # Flush the errors we got, move to a clean slate
+      Mix.shell().flush()
+      Mix.Task.clear()
+      Process.put(:git_repo_opts, sparse: "sparse_dir")
+      Mix.Project.pop()
+      Mix.Project.push(GitApp)
+
+      # Calling get should update the dependency
+      Mix.Tasks.Deps.Get.run([])
+      assert File.read!("mix.lock") =~ "sparse_dir"
+      refute File.exists?("deps/git_repo/lib/git_repo.ex")
+
+      message = "* Updating git_repo (#{fixture_path("git_repo")})"
+      assert_received {:mix_shell, :info, [^message]}
+
+      # Check we got no error
+      refute_received {:mix_shell, :error, _}
+    end)
   end
 
   test "updates the repo and the lock when the mixfile updates" do
-    Mix.Project.push GitApp
-    [last, first|_] = get_git_repo_revs
+    Mix.Project.push(GitApp)
+    [last, first | _] = get_git_repo_revs("git_repo")
 
-    in_fixture "no_mixfile", fn ->
+    in_fixture("no_mixfile", fn ->
       # Move to the first version
-      Mix.Dep.Lock.write [git_repo: {:git, fixture_path("git_repo"), first, []}]
+      Mix.Dep.Lock.write(%{git_repo: {:git, fixture_path("git_repo"), first, []}})
 
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       assert File.read!("mix.lock") =~ first
 
       # Update the project configuration. It should force an update.
-      refresh deps: [{:git_repo, "0.1.0", git: fixture_path("git_repo"), ref: last}]
+      refresh(deps: [{:git_repo, "0.1.0", git: fixture_path("git_repo"), ref: last}])
+
+      Mix.Tasks.Deps.run([])
+
+      msg =
+        "  lock outdated: the lock is outdated compared to the options in your mix.exs. To fetch locked version run \"mix deps.get\""
 
-      Mix.Tasks.Deps.run []
-      msg = "  lock outdated: the lock is outdated compared to the options in your mixfile"
       assert_received {:mix_shell, :info, [^msg]}
 
       # Check an update was triggered
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       assert File.read!("mix.lock") =~ last
 
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
@@ -254,63 +377,360 @@ defmodule Mix.Tasks.DepsGitTest do
 
       # Check we got no error
       refute_received {:mix_shell, :error, _}
-    end
+    end)
+  after
+    purge([GitRepo, GitRepo.MixProject])
+  end
+
+  test "fetches children on updates" do
+    Mix.Project.push(DepsOnGitApp)
+
+    # Get Git repo first revision
+    [last, first | _] = get_git_repo_revs("deps_on_git_repo")
+
+    in_fixture("no_mixfile", fn ->
+      Mix.Dep.Lock.write(%{deps_on_git_repo: {:git, fixture_path("deps_on_git_repo"), first, []}})
+
+      Mix.Tasks.Deps.Get.run([])
+      assert File.exists?("deps/deps_on_git_repo/mix.exs")
+      refute File.exists?("deps/git_repo/lib/git_repo.ex")
+      assert File.read!("mix.lock") =~ first
+
+      Mix.Task.clear()
+      Mix.State.clear_cache()
+      purge([DepsOnGitRepo.MixProject])
+
+      # Write to the checkout location to ensure it is replaced
+      File.mkdir_p!("deps/deps_on_git_repo/lib")
+      File.write!("deps/deps_on_git_repo/lib/deps_on_git_repo.ex", "# WILL BE OVERRIDDEN")
+
+      Mix.Tasks.Deps.Update.run(["deps_on_git_repo"])
+      assert File.exists?("deps/git_repo/lib/git_repo.ex")
+      assert File.read!("mix.lock") =~ last
+      assert File.read!("deps/deps_on_git_repo/lib/deps_on_git_repo.ex") =~ "GitRepo.hello()"
+      refute File.exists?("_build/dev/lib/git_repo/.mix/compile.elixir_scm")
+    end)
   after
-    purge [GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
+  end
+
+  test "fetches children on get" do
+    Mix.Project.push(DepsOnGitApp)
+
+    # Get Git repo first revision
+    [last, first | _] = get_git_repo_revs("deps_on_git_repo")
+
+    in_fixture("no_mixfile", fn ->
+      Mix.Dep.Lock.write(%{deps_on_git_repo: {:git, fixture_path("deps_on_git_repo"), first, []}})
+
+      Mix.Tasks.Deps.Get.run([])
+      assert File.exists?("deps/deps_on_git_repo/mix.exs")
+      refute File.exists?("deps/git_repo/lib/git_repo.ex")
+      assert File.read!("mix.lock") =~ first
+
+      Mix.Task.clear()
+      Mix.State.clear_cache()
+      purge([DepsOnGitRepo.MixProject])
+
+      # Write to the checkout location to ensure it is replaced
+      File.mkdir_p!("deps/deps_on_git_repo/lib")
+      File.write!("deps/deps_on_git_repo/lib/deps_on_git_repo.ex", "# WILL BE OVERRIDDEN")
+
+      Mix.Dep.Lock.write(%{deps_on_git_repo: {:git, fixture_path("deps_on_git_repo"), last, []}})
+      Mix.Tasks.Deps.Get.run([])
+      assert File.exists?("deps/git_repo/lib/git_repo.ex")
+      assert File.read!("mix.lock") =~ last
+      assert File.read!("deps/deps_on_git_repo/lib/deps_on_git_repo.ex") =~ "GitRepo.hello()"
+      refute File.exists?("_build/dev/lib/git_repo/.mix/compile.elixir_scm")
+    end)
+  after
+    purge([GitRepo, GitRepo.MixProject])
   end
 
   test "does not attempt to compile projects that could not be retrieved" do
-    Mix.Project.push GitErrorApp
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitErrorApp)
 
-    in_fixture "no_mixfile", fn ->
-      exception = assert_raise Mix.Error, fn ->
-        Mix.Tasks.Deps.Get.run []
-      end
-      assert Exception.message(exception) =~ "Command `git clone"
-    end
+      exception = assert_raise Mix.Error, fn -> Mix.Tasks.Deps.Get.run([]) end
+
+      assert Exception.message(exception) =~ "Command \"git --git-dir=.git fetch"
+    end)
   end
 
   test "does not load bad mixfiles on get" do
-    Mix.Project.push GitApp
-    [last, _, bad|_] = get_git_repo_revs
+    Mix.Project.push(GitApp)
+    [last, _, bad | _] = get_git_repo_revs("git_repo")
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Dep.Lock.write [git_repo: {:git, fixture_path("git_repo"), bad, []}]
-      catch_error(Mix.Tasks.Deps.Get.run [])
+    in_fixture("no_mixfile", fn ->
+      Mix.Dep.Lock.write(%{git_repo: {:git, fixture_path("git_repo"), bad, []}})
+      catch_error(Mix.Tasks.Deps.Get.run([]))
 
-      Mix.Dep.Lock.write [git_repo: {:git, fixture_path("git_repo"), last, []}]
-      Mix.Tasks.Deps.Get.run []
+      Mix.Dep.Lock.write(%{git_repo: {:git, fixture_path("git_repo"), last, []}})
+      Mix.Tasks.Deps.Get.run([])
       assert File.read!("mix.lock") =~ last
-    end
+    end)
   after
-    purge [GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
+  end
+
+  test "updates on Git opts change" do
+    in_fixture("no_mixfile", fn ->
+      Mix.Project.push(GitApp)
+
+      Process.put(:git_repo_opts, tag: "without_module")
+      refresh([])
+      Mix.Tasks.Deps.Get.run([])
+      refute File.regular?("deps/git_repo/lib/git_repo.ex")
+
+      Process.put(:git_repo_opts, tag: "with_module")
+      refresh([])
+      Mix.Tasks.Deps.Get.run([])
+      assert File.regular?("deps/git_repo/lib/git_repo.ex")
+    end)
+  after
+    purge([GitRepo, GitRepo.MixProject])
   end
 
   test "does not load bad mixfiles on update" do
-    Mix.Project.push GitApp
-    [last, _, bad|_] = get_git_repo_revs
+    Mix.Project.push(GitApp)
+    [last, _, bad | _] = get_git_repo_revs("git_repo")
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Dep.Lock.write [git_repo: {:git, fixture_path("git_repo"), bad, []}]
-      catch_error(Mix.Tasks.Deps.Get.run [])
+    in_fixture("no_mixfile", fn ->
+      Mix.Dep.Lock.write(%{git_repo: {:git, fixture_path("git_repo"), bad, []}})
+      catch_error(Mix.Tasks.Deps.Get.run([]))
 
-      Mix.Tasks.Deps.Update.run ["git_repo"]
-      Mix.Tasks.Deps.Compile.run ["git_repo"]
+      Mix.Tasks.Deps.Update.run(["git_repo"])
+      Mix.Tasks.Deps.Compile.run(["git_repo"])
       assert File.read!("mix.lock") =~ last
-    end
+    end)
   after
-    purge [GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
+  end
+
+  describe "Git depth option" do
+    @describetag :git_depth
+
+    test "gets and updates Git repos with depth option" do
+      Process.put(:git_repo_opts, depth: 1)
+
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(GitApp)
+
+        Mix.Tasks.Deps.Get.run([])
+        message = "* Getting git_repo (#{fixture_path("git_repo")})"
+        assert_received {:mix_shell, :info, [^message]}
+        assert_shallow("deps/git_repo", 1)
+
+        # Expand depth
+        update_dep(depth: 2)
+        Mix.Tasks.Deps.Get.run([])
+        assert_shallow("deps/git_repo", 2)
+
+        # Reduce depth
+        update_dep(depth: 1)
+        Mix.Tasks.Deps.Get.run([])
+        assert_shallow("deps/git_repo", 1)
+      end)
+    end
+
+    test "with tag" do
+      Process.put(:git_repo_opts, depth: 1, tag: "with_module")
+
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(GitApp)
+
+        Mix.Tasks.Deps.Get.run([])
+        message = "* Getting git_repo (#{fixture_path("git_repo")} - with_module)"
+        assert_received {:mix_shell, :info, [^message]}
+        assert_shallow("deps/git_repo", 1)
+      end)
+    end
+
+    test "with branch" do
+      Process.put(:git_repo_opts, depth: 1, branch: "main")
+
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(GitApp)
+
+        Mix.Tasks.Deps.Get.run([])
+        message = "* Getting git_repo (#{fixture_path("git_repo")} - main)"
+        assert_received {:mix_shell, :info, [^message]}
+        assert_shallow("deps/git_repo", 1)
+      end)
+    end
+
+    test "with ref" do
+      [sha1, _ | _] = get_git_repo_revs("git_repo")
+
+      Process.put(:git_repo_opts, depth: 1, ref: sha1)
+
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(GitApp)
+
+        Mix.Tasks.Deps.Get.run([])
+        message = "* Getting git_repo (#{fixture_path("git_repo")} - #{sha1})"
+        assert_received {:mix_shell, :info, [^message]}
+        assert_shallow("deps/git_repo", 1)
+      end)
+    end
+
+    test "raises with short ref" do
+      # When fetching, Git requires a fully spelled hex object name. We prevent
+      # this failure mode by validating the ref length.
+      #
+      # If Git ever changes such that it can resolve a short ref in a shallow
+      # fetch, we can update our docs and this test to reflect that.
+      #
+      # https://git-scm.com/docs/git-fetch#Documentation/git-fetch.txt-ltrefspecgt
+      # https://stackoverflow.com/a/43136160
+      [<<short_sha1::binary-size(8), _::binary>>, _ | _] = get_git_repo_revs("git_repo")
+
+      Process.put(:git_repo_opts, depth: 1, ref: short_sha1)
+
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(GitApp)
+        exception = assert_raise Mix.Error, fn -> Mix.Tasks.Deps.Get.run([]) end
+        assert Exception.message(exception) =~ "a full commit hash is required"
+      end)
+    end
+
+    test "changing refspec updates retaining depth" do
+      [last, first | _] = get_git_repo_revs("git_repo")
+
+      Process.put(:git_repo_opts, ref: first, depth: 1)
+
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(GitApp)
+
+        Mix.Tasks.Deps.Get.run([])
+        message = "* Getting git_repo (#{fixture_path("git_repo")} - #{first})"
+        assert_received {:mix_shell, :info, [^message]}
+        assert_shallow("deps/git_repo", 1)
+        assert File.read!("mix.lock") =~ first
+
+        # Change refspec
+        update_dep(ref: last, depth: 1)
+        Mix.Tasks.Deps.Get.run([])
+        assert_shallow("deps/git_repo", 1)
+        assert File.read!("mix.lock") =~ last
+      end)
+    end
+
+    test "removing depth retains shallow repository" do
+      # For compatibility and simplicity, we follow Git's behavior and do not
+      # attempt to unshallow an existing repository. This should not be a
+      # problem, because all we guarantee is that the correct source code is
+      # available whenever mix.exs or mix.lock change. If one wanted to have a
+      # full clone, they can always run `deps.clean` and `deps.get` again.
+      Process.put(:git_repo_opts, depth: 1)
+
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(GitApp)
+
+        Mix.Tasks.Deps.Get.run([])
+        message = "* Getting git_repo (#{fixture_path("git_repo")})"
+        assert_received {:mix_shell, :info, [^message]}
+        assert_shallow("deps/git_repo", 1)
+
+        # Remove depth
+        update_dep([])
+        Mix.Tasks.Deps.Get.run([])
+        refute File.read!("mix.lock") =~ "depth:"
+        assert File.exists?("deps/git_repo/.git/shallow")
+
+        assert System.cmd("git", ~w[--git-dir=deps/git_repo/.git rev-list --count HEAD]) ==
+                 {"1\n", 0}
+      end)
+    end
+
+    @tag :git_sparse
+    test "with sparse checkout" do
+      Process.put(:git_repo_opts, sparse: "sparse_dir", depth: 1)
+
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(GitApp)
+
+        Mix.Tasks.Deps.Get.run([])
+        message = "* Getting git_repo (#{fixture_path("git_repo")})"
+        assert_received {:mix_shell, :info, [^message]}
+        assert_shallow("deps/git_repo", 1)
+
+        refute File.exists?("deps/git_repo/mix.exs")
+        assert File.exists?("deps/git_repo/sparse_dir/mix.exs")
+        assert File.read!("mix.lock") =~ "sparse: \"sparse_dir\""
+      end)
+    end
+
+    test "with subdir" do
+      Process.put(:git_repo_opts, subdir: "sparse_dir", depth: 1)
+
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(GitApp)
+
+        Mix.Tasks.Deps.Get.run([])
+        message = "* Getting git_repo (#{fixture_path("git_repo")})"
+        assert_received {:mix_shell, :info, [^message]}
+        assert_shallow("deps/git_repo", 1)
+
+        assert File.exists?("deps/git_repo/mix.exs")
+        assert File.exists?("deps/git_repo/sparse_dir/mix.exs")
+        assert File.read!("mix.lock") =~ "subdir: \"sparse_dir\""
+      end)
+    end
+
+    test "does not affect submodules depth" do
+      # The expectation is that we can add an explicit option in the future,
+      # just like git-clone has `--shallow-submodules`.
+      Process.put(:git_repo_opts, submodules: true, depth: 1)
+
+      in_fixture("no_mixfile", fn ->
+        Mix.Project.push(GitApp)
+
+        Mix.Tasks.Deps.Get.run([])
+        message = "* Getting git_repo (#{fixture_path("git_repo")})"
+        assert_received {:mix_shell, :info, [^message]}
+        assert_shallow("deps/git_repo", 1)
+
+        assert File.read!("mix.lock") =~ "submodules: true"
+        # TODO: assert submodule is not shallow. This would likely require
+        # changes to the fixtures. Apparently, not even the submodules-specific
+        # tests check that the cloned repo contains submodules as expected.
+      end)
+    end
+
+    defp update_dep(git_repo_opts) do
+      # Flush the errors we got, move to a clean slate
+      Mix.shell().flush()
+      Mix.Task.clear()
+      Process.put(:git_repo_opts, git_repo_opts)
+      Mix.Project.pop()
+      Mix.Project.push(GitApp)
+    end
+
+    defp assert_shallow(repo_path, depth) do
+      assert File.read!("mix.lock") =~ "depth: #{depth}"
+
+      # Check if the repository is a shallow clone
+      assert File.exists?(repo_path <> "/.git/shallow")
+
+      # Check the number of commits in the current branch.
+      #
+      # We could consider all branches with `git rev-list --count --all`, as in
+      # practice there should be only a single branch. However, the test fixture
+      # sets up two branches, and that brings us to an interesting situation:
+      # instead of guaranteeing that the `:depth` option would keep the
+      # repository lean even after refspec changes, we only guarantee the number
+      # of commits in the current branch, perhaps leaving more objects around
+      # than strictly necessary. This allows us to keep the implementation
+      # simple, while still providing a reasonable guarantee.
+      assert System.cmd("git", ~w[--git-dir=#{repo_path}/.git rev-list --count HEAD]) ==
+               {"#{depth}\n", 0}
+    end
   end
 
   defp refresh(post_config) do
-    %{name: name, file: file} = Mix.Project.pop
+    %{name: name, file: file} = Mix.Project.pop()
     Mix.ProjectStack.post_config(post_config)
     Mix.Project.push(name, file)
   end
-
-  defp get_git_repo_revs do
-    File.cd! fixture_path("git_repo"), fn ->
-      Regex.split ~r(\r?\n), System.cmd("git log --format=%H")
-    end
-  end
 end
diff --git a/lib/mix/test/mix/tasks/deps.path_test.exs b/lib/mix/test/mix/tasks/deps.path_test.exs
index 708638cea6e..cc42612e98b 100644
--- a/lib/mix/test/mix/tasks/deps.path_test.exs
+++ b/lib/mix/test/mix/tasks/deps.path_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.DepsPathTest do
   use MixTest.Case
@@ -15,40 +19,37 @@ defmodule Mix.Tasks.DepsPathTest do
     end
   end
 
-  test "does not mark for compilation on get/update" do
-    Mix.Project.push DepsApp
-
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Get.run ["--all"]
-      refute File.exists?("custom/raw_repo/.fetch")
+  defmodule MismatchDepsApp do
+    def project do
+      [
+        app: :raw_sample,
+        version: "0.1.0",
+        deps: [
+          {:cooked_repo, "0.1.0", path: "custom/raw_repo"}
+        ]
+      ]
     end
   end
 
-  test "compiles ands runs even if lock does not match" do
-    Mix.Project.push DepsApp
+  @tag apps: [:raw_sample]
+  test "compiles and runs even if lock does not match" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DepsApp)
 
-    in_fixture "deps_status", fn ->
-      Mix.Dep.Lock.write [raw_repo: "abcdef"]
-      Mix.Tasks.Run.run ["-e", "Mix.shell.info RawRepo.hello"]
+      Mix.Dep.Lock.write(%{raw_repo: "abcdef"})
+      Mix.Tasks.Run.run(["-e", "Mix.shell().info RawRepo.hello()"])
       assert_received {:mix_shell, :info, ["==> raw_repo"]}
       assert_received {:mix_shell, :info, ["world"]}
-    end
+    end)
   end
 
-  defmodule InvalidPathDepsApp do
-    def project do
-      [
-        app: :rebar_as_dep,
-        version: "0.1.0",
-        deps: [{:rebar_dep, path: MixTest.Case.tmp_path("rebar_dep")}]
-      ]
-    end
-  end
+  @tag apps: [:raw_sample]
+  test "uses the name of the app, not the path basename" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(MismatchDepsApp)
 
-  test "raises on non-mix path deps" do
-    Mix.Project.push InvalidPathDepsApp
-    assert_raise Mix.Error, ~r/:path option can only be used with mix projects/, fn ->
-      Mix.Tasks.Deps.Get.run []
-    end
+      Mix.Tasks.Deps.Compile.run([])
+      assert File.exists?("_build/dev/lib/cooked_repo/ebin")
+    end)
   end
 end
diff --git a/lib/mix/test/mix/tasks/deps.tree_test.exs b/lib/mix/test/mix/tasks/deps.tree_test.exs
new file mode 100644
index 00000000000..cb974e2e20f
--- /dev/null
+++ b/lib/mix/test/mix/tasks/deps.tree_test.exs
@@ -0,0 +1,167 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.Deps.TreeTest do
+  use MixTest.Case
+
+  defmodule ConvergedDepsApp do
+    def project do
+      [
+        app: :sample,
+        version: "0.1.0",
+        deps: [
+          {:deps_on_git_repo, "0.2.0", git: fixture_path("deps_on_git_repo")},
+          {:git_repo, ">= 0.1.0", git: MixTest.Case.fixture_path("git_repo")}
+        ]
+      ]
+    end
+  end
+
+  defmodule OverriddenDepsApp do
+    def project do
+      [
+        app: :sample,
+        version: "0.1.0",
+        deps: [
+          {:deps_on_git_repo, ~r"0.2.0", git: fixture_path("deps_on_git_repo"), only: :test},
+          {:git_repo, git: MixTest.Case.fixture_path("git_repo"), override: true}
+        ]
+      ]
+    end
+  end
+
+  defmodule UmbrellaApp do
+    def project do
+      [
+        app: :sample,
+        version: "0.1.0",
+        deps: [
+          {:umbrella_dep, in_umbrella: true}
+        ]
+      ]
+    end
+  end
+
+  test "shows the dependency tree", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(ConvergedDepsApp)
+
+      Mix.Tasks.Deps.Tree.run(["--format", "pretty"])
+      assert_received {:mix_shell, :info, ["sample"]}
+      assert_received {:mix_shell, :info, ["├── deps_on_git_repo 0.2.0 (" <> _]}
+      assert_received {:mix_shell, :info, ["└── git_repo >= 0.1.0 (" <> _]}
+
+      Mix.Tasks.Deps.Get.run([])
+      Mix.Tasks.Deps.Tree.run(["--format", "pretty"])
+      assert_received {:mix_shell, :info, ["sample"]}
+      assert_received {:mix_shell, :info, ["├── deps_on_git_repo 0.2.0 (" <> _]}
+      assert_received {:mix_shell, :info, ["│   └── git_repo (" <> _]}
+      assert_received {:mix_shell, :info, ["└── git_repo >= 0.1.0 (" <> _]}
+    end)
+  after
+    purge([DepsOnGitRepo.MixProject, GitRepo.MixProject])
+  end
+
+  test "show the dependency tree for umbrella apps" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Task.run("deps.tree", ["--format", "pretty"])
+        assert_received {:mix_shell, :info, ["foo"]}
+        assert_received {:mix_shell, :info, ["bar"]}
+        assert_received {:mix_shell, :info, ["└── foo (../foo)"]}
+      end)
+    end)
+  end
+
+  test "filters umbrella deps only with --umbrella-only" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Task.run("deps.tree", ["--format", "pretty", "--umbrella-only"])
+        assert_received {:mix_shell, :info, ["foo"]}
+        assert_received {:mix_shell, :info, ["bar"]}
+        assert_received {:mix_shell, :info, ["└── foo (../foo)"]}
+      end)
+    end)
+  end
+
+  test "shows the given dependency", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(ConvergedDepsApp)
+
+      assert_raise Mix.Error, "could not find dependency unknown", fn ->
+        Mix.Tasks.Deps.Tree.run(["--format", "pretty", "unknown"])
+      end
+
+      Mix.Tasks.Deps.Tree.run(["--format", "pretty", "deps_on_git_repo"])
+      assert_received {:mix_shell, :info, ["deps_on_git_repo 0.2.0 (" <> _]}
+      refute_received {:mix_shell, :info, ["└── git_repo (" <> _]}
+    end)
+  end
+
+  test "shows overridden deps", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(OverriddenDepsApp)
+
+      Mix.Tasks.Deps.Tree.run(["--format", "pretty"])
+      assert_received {:mix_shell, :info, ["sample"]}
+      assert_received {:mix_shell, :info, ["└── git_repo (" <> msg]}
+      assert_received {:mix_shell, :info, ["├── deps_on_git_repo ~r/0.2.0/ (" <> _]}
+      assert msg =~ "*override*"
+    end)
+  end
+
+  test "excludes the given deps", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(OverriddenDepsApp)
+
+      Mix.Tasks.Deps.Tree.run(["--format", "pretty", "--exclude", "deps_on_git_repo"])
+      assert_received {:mix_shell, :info, ["sample"]}
+      assert_received {:mix_shell, :info, ["└── git_repo (" <> _]}
+      refute_received {:mix_shell, :info, ["└── deps_on_git_repo ~r/0.2.0/ (" <> _]}
+    end)
+  end
+
+  test "shows a particular environment", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(OverriddenDepsApp)
+
+      Mix.Tasks.Deps.Tree.run(["--format", "pretty", "--only", "prod"])
+      assert_received {:mix_shell, :info, ["sample"]}
+      assert_received {:mix_shell, :info, ["└── git_repo (" <> _]}
+      refute_received {:mix_shell, :info, ["└── deps_on_git_repo ~r/0.2.0/ (" <> _]}
+    end)
+  end
+
+  test "shows the dependency tree in DOT graph format", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(ConvergedDepsApp)
+
+      Mix.Tasks.Deps.Tree.run(["--format", "dot"])
+
+      assert File.read!("deps_tree.dot") == """
+             digraph "dependency tree" {
+               "sample"
+               "sample" -> "deps_on_git_repo" [label="0.2.0"]
+               "sample" -> "git_repo" [label=">= 0.1.0"]
+             }
+             """
+
+      Mix.Tasks.Deps.Get.run([])
+      Mix.Tasks.Deps.Tree.run(["--format", "dot"])
+
+      assert File.read!("deps_tree.dot") == """
+             digraph "dependency tree" {
+               "sample"
+               "sample" -> "deps_on_git_repo" [label="0.2.0"]
+               "deps_on_git_repo" -> "git_repo" [label=""]
+               "sample" -> "git_repo" [label=">= 0.1.0"]
+             }
+             """
+    end)
+  after
+    purge([DepsOnGitRepo.MixProject, GitRepo.MixProject])
+  end
+end
diff --git a/lib/mix/test/mix/tasks/deps_test.exs b/lib/mix/test/mix/tasks/deps_test.exs
index 2c5c3a33578..280e97dbf50 100644
--- a/lib/mix/test/mix/tasks/deps_test.exs
+++ b/lib/mix/test/mix/tasks/deps_test.exs
@@ -1,16 +1,23 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.DepsTest do
   use MixTest.Case
 
   defmodule DepsApp do
     def project do
-      [ app: :deps, version: "0.1.0",
+      [
+        app: :deps,
+        version: "0.1.0",
         deps: [
-          {:ok, "0.1.0",         github: "elixir-lang/ok"},
+          {:ok, "0.1.0", github: "elixir-lang/ok"},
           {:invalidvsn, "0.2.0", path: "deps/invalidvsn"},
           {:invalidapp, "0.1.0", path: "deps/invalidapp"},
-          {:noappfile, "0.1.0",  path: "deps/noappfile"},
+          {:noappfile, "0.1.0", path: "deps/noappfile"},
+          {:nosemver, "~> 0.1", path: "deps/nosemver"}
         ]
       ]
     end
@@ -18,7 +25,9 @@ defmodule Mix.Tasks.DepsTest do
 
   defmodule SuccessfulDepsApp do
     def project do
-      [ app: :sample, version: "0.1.0",
+      [
+        app: :sample,
+        version: "0.1.0",
         deps: [
           {:ok, "0.1.0", path: "deps/ok"}
         ]
@@ -28,53 +37,113 @@ defmodule Mix.Tasks.DepsTest do
 
   defmodule ReqDepsApp do
     def project do
-      [ app: :req_deps, version: "0.1.0",
+      [
+        app: :req_deps,
+        version: "0.1.0",
+        deps: [
+          {:ok, ">= 2.0.0", path: "deps/ok"},
+          {:noappfile, path: "deps/noappfile", app: false},
+          {:apppath, path: "deps/noappfile", app: "../deps/ok/ebin/ok.app"}
+        ]
+      ]
+    end
+  end
+
+  defmodule MissingLocalDepsApp do
+    def project do
+      [
+        app: :missing_local_deps,
+        version: "0.1.0",
         deps: [
-          {:ok, ">= 2.0.0",  path: "deps/ok"},
-          {:noappfile,       path: "deps/noappfile", app: false},
-          {:apppath,         path: "deps/noappfile", app: "../deps/ok/ebin/ok.app"}
+          {:ok, path: "missing/dep"}
         ]
       ]
     end
   end
 
+  defmodule RawRepoDepApp do
+    def project do
+      [
+        app: :raw_sample,
+        version: "0.1.0",
+        deps: [
+          {:raw_repo, "0.1.0", path: "custom/raw_repo"}
+        ]
+      ]
+    end
+  end
+
+  ## deps
+
   test "prints list of dependencies and their status" do
-    Mix.Project.push DepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DepsApp)
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.run []
+      Mix.Tasks.Deps.run([])
+
+      assert_received {:mix_shell, :info, ["* ok (https://github.com/elixir-lang/ok.git) (mix)"]}
+      msg = "  the dependency is not available, run \"mix deps.get\""
+      assert_received {:mix_shell, :info, [^msg]}
 
-      assert_received {:mix_shell, :info, ["* ok (git://github.com/elixir-lang/ok.git)"]}
-      assert_received {:mix_shell, :info, ["  the dependency is not available, run `mix deps.get`"]}
       assert_received {:mix_shell, :info, ["* invalidvsn (deps/invalidvsn)"]}
       assert_received {:mix_shell, :info, ["  the app file contains an invalid version: :ok"]}
-      assert_received {:mix_shell, :info, ["* invalidapp (deps/invalidapp)"]}
-      assert_received {:mix_shell, :info, ["  the app file at _build/dev/lib/invalidapp/ebin/invalidapp.app is invalid"]}
+
+      assert_received {:mix_shell, :info, ["* invalidapp (deps/invalidapp) (mix)"]}
+      msg = "  the app file at \"_build/dev/lib/invalidapp/ebin/invalidapp.app\" is invalid"
+      assert_received {:mix_shell, :info, [^msg]}
+
       assert_received {:mix_shell, :info, ["* noappfile (deps/noappfile)"]}
-      assert_received {:mix_shell, :info, ["  could not find an app file at _build/dev/lib/noappfile/ebin/noappfile.app" <> _]}
-    end
+      assert_received {:mix_shell, :info, ["  could not find an app file at" <> _]}
+
+      assert_received {:mix_shell, :info, ["* nosemver (deps/nosemver)"]}
+      assert_received {:mix_shell, :info, ["  the app file specified a non-Semantic" <> _]}
+    end)
   end
 
   test "prints list of dependencies and their status, including req mismatches and custom apps" do
-    Mix.Project.push ReqDepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(ReqDepsApp)
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.run []
+      Mix.Tasks.Deps.run([])
+
+      assert_received {:mix_shell, :info, ["* ok (deps/ok) (mix)"]}
+      msg = "  the dependency does not match the requirement \">= 2.0.0\", got \"0.1.0\""
+      assert_received {:mix_shell, :info, [^msg]}
 
-      assert_received {:mix_shell, :info, ["* ok (deps/ok)"]}
-      assert_received {:mix_shell, :info, ["  the dependency does not match the requirement \">= 2.0.0\", got \"0.1.0\""]}
-      assert_received {:mix_shell, :info, ["* noappfile (deps/noappfile)"]}
       assert_received {:mix_shell, :info, ["* apppath (deps/noappfile)"]}
-      refute_received {:mix_shell, :info, ["  could not find app file at _build/dev/lib/noappfile/ebin/apppath.app" <> _]}
-      refute_received {:mix_shell, :info, ["  could not find app file at _build/dev/lib/noappfile/ebin/noappfile.app" <> _]}
-    end
+      refute_received {:mix_shell, :info, ["  could not find app file at " <> _]}
+
+      assert_received {:mix_shell, :info, ["* noappfile (deps/noappfile)"]}
+      refute_received {:mix_shell, :info, ["  could not find app file at " <> _]}
+    end)
   end
 
-  test "prints elixir req mismatches" do
-    Mix.Project.push ReqDepsApp
+  test "prints misspelled dependency name hint" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DepsApp)
+
+      other_app_path = Path.join(Mix.Project.build_path(), "lib/noappfile/ebin/other_app.app")
+      File.mkdir_p!(Path.dirname(other_app_path))
+      File.write!(other_app_path, "")
+
+      Mix.Tasks.Deps.run([])
 
-    in_fixture "deps_status", fn ->
-      File.write! "deps/ok/mix.exs", """
+      message =
+        "  could not find an app file at \"_build/dev/lib/noappfile/ebin/noappfile.app\". " <>
+          "Another app file was found in the same directory " <>
+          "\"_build/dev/lib/noappfile/ebin/other_app.app\", " <>
+          "try changing the dependency name to :other_app"
+
+      assert_received {:mix_shell, :info, ["* noappfile (deps/noappfile)"]}
+      assert_received {:mix_shell, :info, [^message]}
+    end)
+  end
+
+  test "prints Elixir req mismatches" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(ReqDepsApp)
+
+      File.write!("deps/ok/mix.exs", """
       defmodule Deps.OkApp do
         use Mix.Project
 
@@ -82,130 +151,287 @@ defmodule Mix.Tasks.DepsTest do
           [elixir: "~> 0.1.0", app: :ok, version: "2.0.0"]
         end
       end
-      """
+      """)
+
+      Mix.Tasks.Deps.Compile.run([:ok])
 
-      Mix.Tasks.Deps.run []
+      msg =
+        "warning: the dependency :ok requires Elixir \"~> 0.1.0\" " <>
+          "but you are running on v#{System.version()}"
 
-      msg = "warning: the dependency ok requires Elixir \"~> 0.1.0\" " <>
-            "but you are running on v#{System.version}"
       assert_received {:mix_shell, :error, [^msg]}
 
-      Mix.Tasks.Deps.Compile.run []
-    end
+      Mix.Tasks.Deps.Compile.run([])
+    end)
   end
 
   test "prints list of dependencies and their lock status" do
-    Mix.Project.push DepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DepsApp)
+
+      File.cd!("deps/ok", fn ->
+        System.cmd("git", ~w[-c core.hooksPath='' init])
+      end)
 
-    in_fixture "deps_status", fn ->
-      File.cd!("deps/ok", fn -> System.cmd("git init") end)
+      Mix.Tasks.Deps.run([])
+      assert_received {:mix_shell, :info, ["* ok (https://github.com/elixir-lang/ok.git) (mix)"]}
 
-      Mix.Tasks.Deps.run []
-      assert_received {:mix_shell, :info, ["* ok (git://github.com/elixir-lang/ok.git)"]}
-      assert_received {:mix_shell, :info, ["  the dependency is not locked"]}
+      msg =
+        "  the dependency is not locked. To generate the \"mix.lock\" file run \"mix deps.get\""
+
+      assert_received {:mix_shell, :info, [^msg]}
 
-      Mix.Dep.Lock.write %{ok: {:git, "git://github.com/elixir-lang/ok.git", "abcdefghi", []}}
-      Mix.Tasks.Deps.run []
+      Mix.Dep.Lock.write(%{ok: {:git, "https://github.com/elixir-lang/ok.git", "abcdefghi", []}})
+      Mix.Tasks.Deps.run([])
 
-      assert_received {:mix_shell, :info, ["* ok (git://github.com/elixir-lang/ok.git)"]}
+      assert_received {:mix_shell, :info, ["* ok (https://github.com/elixir-lang/ok.git) (mix)"]}
       assert_received {:mix_shell, :info, ["  locked at abcdefg"]}
-      assert_received {:mix_shell, :info, ["  lock mismatch: the dependency is out of date"]}
 
-      Mix.Dep.Lock.write [ok: {:git, "git://github.com/elixir-lang/another.git", "abcdefghi", []}]
-      Mix.Tasks.Deps.run []
+      msg =
+        "  lock mismatch: the dependency is out of date. To fetch locked version run \"mix deps.get\""
 
-      assert_received {:mix_shell, :info, ["* ok (git://github.com/elixir-lang/ok.git)"]}
-      assert_received {:mix_shell, :info, ["  lock outdated: the lock is outdated compared to the options in your mixfile"]}
+      assert_received {:mix_shell, :info, [^msg]}
+
+      Mix.Dep.Lock.write(%{
+        ok: {:git, "git://github.com/elixir-lang/another.git", "abcdefghi", []}
+      })
+
+      Mix.Tasks.Deps.run([])
+
+      assert_received {:mix_shell, :info, ["* ok (https://github.com/elixir-lang/ok.git) (mix)"]}
+
+      msg =
+        "  lock outdated: the lock is outdated compared to the options in your mix.exs. To fetch locked version run \"mix deps.get\""
+
+      assert_received {:mix_shell, :info, [^msg]}
+    end)
+  end
+
+  test "cleans and recompiles artifacts if --force is given" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(SuccessfulDepsApp)
+
+      Mix.Tasks.Deps.Compile.run([])
+      File.touch!("_build/dev/lib/ok/clean-me")
+
+      Mix.Tasks.Deps.Compile.run(["--force"])
+      refute File.exists?("_build/dev/lib/ok/clean-me")
+    end)
+  end
+
+  test "compiles deps using os partitions" do
+    System.put_env("MIX_OS_DEPS_COMPILE_PARTITION_COUNT", "2")
+
+    in_fixture("deps_status", fn ->
+      File.write!("mix.exs", """
+      defmodule ParDepsApp do
+        use Mix.Project
+
+        def project do
+          [
+            app: :par_sample,
+            version: "0.1.0",
+            deps: [
+              {:raw_repo, "0.1.0", path: "custom/raw_repo"},
+              {:git_repo, "0.1.0", path: #{inspect(fixture_path("git_repo"))}}
+            ]
+          ]
+        end
+      end
+      """)
+
+      Mix.Project.in_project(:par_sample, ".", fn _ ->
+        output = ExUnit.CaptureIO.capture_io(fn -> Mix.Tasks.Deps.Compile.run([]) end)
+        assert output =~ ~r/\d> Generated git_repo app/
+        assert output =~ ~r/\d> Generated raw_repo app/
+        assert_received {:mix_shell, :info, ["mix deps.compile running across 2 OS processes"]}
+      end)
+    end)
+  after
+    System.delete_env("MIX_OS_DEPS_COMPILE_PARTITION_COUNT")
+  end
+
+  test "doesn't compile any umbrella apps if --skip-umbrella-children is given" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Tasks.Deps.Compile.run(["--skip-umbrella-children"])
+        refute File.exists?("_build/dev/lib/foo/ebin")
+        refute File.exists?("_build/dev/lib/bar/ebin")
+      end)
+    end)
+  end
+
+  test "doesn't compile any path deps if --skip-local-deps is given" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(SuccessfulDepsApp)
+
+      File.rm_rf!("_build/dev/lib/ok/ebin")
+      Mix.Tasks.Deps.Compile.run(["--skip-local-deps"])
+      refute File.exists?("_build/dev/lib/ok/ebin")
+    end)
+  end
+
+  test "checks if local dependencies are available before compiling" do
+    Mix.Project.push(MissingLocalDepsApp)
+
+    error_message =
+      "Cannot compile dependency :ok because it isn't available, please ensure the dependency " <>
+        "is at \"missing/dep\""
+
+    assert_raise Mix.Error, error_message, fn ->
+      Mix.Tasks.Deps.Compile.run([])
     end
   end
 
+  ## deps.loadpaths
+
   test "checks list of dependencies and their status with success" do
-    Mix.Project.push SuccessfulDepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(SuccessfulDepsApp)
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Check.run []
-    end
+      Mix.Tasks.Deps.Loadpaths.run([])
+    end)
   end
 
   test "checks list of dependencies and their status on failure" do
-    Mix.Project.push DepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DepsApp)
 
-    in_fixture "deps_status", fn ->
       assert_raise Mix.Error, fn ->
-        Mix.Tasks.Deps.Check.run []
+        Mix.Tasks.Deps.Loadpaths.run([])
       end
 
-      assert_received {:mix_shell, :error, ["* ok (git://github.com/elixir-lang/ok.git)"]}
-      assert_received {:mix_shell, :error, ["  the dependency is not available, run `mix deps.get`"]}
+      assert_received {:mix_shell, :error, ["* ok (https://github.com/elixir-lang/ok.git)"]}
+      msg = "  the dependency is not available, run \"mix deps.get\""
+      assert_received {:mix_shell, :error, [^msg]}
+
       assert_received {:mix_shell, :error, ["* invalidvsn (deps/invalidvsn)"]}
       assert_received {:mix_shell, :error, ["  the app file contains an invalid version: :ok"]}
+
       assert_received {:mix_shell, :error, ["* invalidapp (deps/invalidapp)"]}
-      assert_received {:mix_shell, :error, ["  the app file at _build/dev/lib/invalidapp/ebin/invalidapp.app is invalid"]}
+      msg = "  the app file at \"_build/dev/lib/invalidapp/ebin/invalidapp.app\" is invalid"
+      assert_received {:mix_shell, :error, [^msg]}
 
       # This one is compiled automatically
       refute_received {:mix_shell, :error, ["* noappfile (deps/noappfile)"]}
-      refute_received {:mix_shell, :error, ["  could not find an app file at _build/dev/lib/noappfile/ebin/noappfile.app" <> _]}
-    end
+      refute_received {:mix_shell, :error, ["  could not find an app file at " <> _]}
+    end)
   end
 
-  test "compiles and prunes builds per environment" do
-    Mix.Project.push SuccessfulDepsApp
+  ## deps.unlock
+
+  test "unlocks all deps", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(DepsApp)
 
-    in_fixture "deps_status", fn ->
-      # Start from scratch!
-      File.rm_rf("_build")
+      Mix.Dep.Lock.write(%{git_repo: "abcdef"})
+      assert Mix.Dep.Lock.read() == %{git_repo: "abcdef"}
+      Mix.Tasks.Deps.Unlock.run(["--all"])
+      assert Mix.Dep.Lock.read() == %{}
+    end)
+  end
 
-      Mix.Tasks.Deps.Compile.run []
-      Mix.Tasks.Deps.Check.run []
-      assert File.exists?("_build/dev/lib/ok/ebin/ok.app")
-      assert File.exists?("_build/dev/lib/ok/priv/sample")
+  test "checks lock file has unused deps with --check-unused", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(DepsApp)
 
-      Mix.Tasks.Compile.run []
-      assert File.exists?("_build/dev/lib/sample/ebin/sample.app")
+      Mix.Dep.Lock.write(%{whatever: "0.2.0", something_else: "1.2.3", ok: "0.1.0"})
+      assert Mix.Dep.Lock.read() == %{whatever: "0.2.0", something_else: "1.2.3", ok: "0.1.0"}
 
-      Mix.ProjectStack.post_config [deps: []]
-      Mix.Project.pop
-      Mix.Project.push SuccessfulDepsApp
+      error = """
+      Unused dependencies in mix.lock file:
 
-      Mix.Tasks.Deps.Check.run []
-      refute File.exists?("_build/dev/lib/ok/ebin/ok.app")
-      assert File.exists?("_build/dev/lib/sample/ebin/sample.app")
-    end
+        * :something_else
+        * :whatever
+      """
+
+      assert_raise Mix.Error, error, fn ->
+        Mix.Tasks.Deps.Unlock.run(["--check-unused"])
+      end
+
+      assert Mix.Dep.Lock.read() == %{whatever: "0.2.0", something_else: "1.2.3", ok: "0.1.0"}
+
+      Mix.Tasks.Deps.Unlock.run(["--unused"])
+      Mix.Tasks.Deps.Unlock.run(["--check-unused"])
+      assert Mix.Dep.Lock.read() == %{ok: "0.1.0"}
+    end)
   end
 
-  test "unlocks all deps" do
-    Mix.Project.push DepsApp
-    in_fixture "no_mixfile", fn ->
-      Mix.Dep.Lock.write %{git_repo: "abcdef"}
-      assert Mix.Dep.Lock.read == %{git_repo: "abcdef"}
-      Mix.Tasks.Deps.Unlock.run ["--all"]
-      assert Mix.Dep.Lock.read == %{}
-    end
+  test "unlocks unused deps", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(DepsApp)
+
+      Mix.Dep.Lock.write(%{whatever: "abcdef", ok: "abcdef"})
+      assert Mix.Dep.Lock.read() == %{whatever: "abcdef", ok: "abcdef"}
+      Mix.Tasks.Deps.Unlock.run(["--unused"])
+      assert Mix.Dep.Lock.read() == %{ok: "abcdef"}
+
+      output = """
+      Unlocked deps:
+      * whatever
+      """
+
+      assert_received {:mix_shell, :info, [^output]}
+    end)
   end
 
-  test "unlocks specific deps" do
-    Mix.Project.push DepsApp
-    in_fixture "no_mixfile", fn ->
-      Mix.Dep.Lock.write %{git_repo: "abcdef", another: "hash"}
-      Mix.Tasks.Deps.Unlock.run ["git_repo", "unknown"]
-      assert Mix.Dep.Lock.read == %{another: "hash"}
-    end
+  test "unlocking a dep that is not locked is a no-op", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(DepsApp)
+      Mix.Tasks.Deps.Unlock.run(["unlocked_dep"])
+
+      assert_received {:mix_shell, :error, ["warning: unlocked_dep dependency is not locked"]}
+      refute_received {:mix_shell, :info, [_]}
+    end)
   end
 
-  ## Deps environment
+  test "unlocks specific deps", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(DepsApp)
 
-  defmodule DepsEnvApp do
-    def project do
-      [
-        app: :raw_sample,
-        version: "0.1.0",
-        deps: [
-          {:raw_repo, "0.1.0", path: "custom/raw_repo"}
-        ]
-      ]
+      Mix.Dep.Lock.write(%{git_repo: "abcdef", another: "hash"})
+      Mix.Tasks.Deps.Unlock.run(["git_repo", "unknown"])
+      assert Mix.Dep.Lock.read() == %{another: "hash"}
+      error = "warning: unknown dependency is not locked"
+      assert_received {:mix_shell, :error, [^error]}
+
+      output = """
+      Unlocked deps:
+      * git_repo
+      """
+
+      assert_received {:mix_shell, :info, [^output]}
+    end)
+  end
+
+  test "unlocks filtered deps", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(DepsApp)
+
+      Mix.Dep.Lock.write(%{git_repo: "abcdef", another: "hash", another_one: "hash"})
+      Mix.Tasks.Deps.Unlock.run(["--filter", "another"])
+      assert Mix.Dep.Lock.read() == %{git_repo: "abcdef"}
+
+      output = """
+      Unlocked deps:
+      * another
+      * another_one
+      """
+
+      assert_received {:mix_shell, :info, [^output]}
+    end)
+  end
+
+  test "fails with message on missing dependencies" do
+    Mix.Project.push(DepsApp)
+
+    assert_raise Mix.Error, ~r/"mix deps\.unlock" expects dependencies as arguments/, fn ->
+      Mix.Tasks.Deps.Unlock.run([])
     end
   end
 
+  ## Deps environment
+
   defmodule CustomDepsEnvApp do
     def project do
       [
@@ -219,25 +445,38 @@ defmodule Mix.Tasks.DepsTest do
   end
 
   test "sets deps env to prod by default" do
-    Mix.Project.push DepsEnvApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(RawRepoDepApp)
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Update.run ["--all"]
+      Mix.Tasks.Deps.Update.run(["--all"])
       assert_received {:mix_shell, :info, [":raw_repo env is prod"]}
-    end
+    end)
   end
 
   test "can customize environment" do
-    Mix.Project.push CustomDepsEnvApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(CustomDepsEnvApp)
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Update.run ["--all"]
+      Mix.Tasks.Deps.Update.run(["--all"])
       assert_received {:mix_shell, :info, [":raw_repo env is dev"]}
-    end
+    end)
   end
 
   ## Nested dependencies
 
+  defmodule ConflictDepsApp do
+    def project do
+      [
+        app: :raw_sample,
+        version: "0.1.0",
+        deps: [
+          {:git_repo, "0.1.0", path: "custom/raw_repo"},
+          {:bad_deps_repo, "0.1.0", path: "custom/bad_deps_repo"}
+        ]
+      ]
+    end
+  end
+
   defmodule DivergedDepsApp do
     def project do
       [
@@ -264,7 +503,7 @@ defmodule Mix.Tasks.DepsTest do
     end
   end
 
-  defmodule OverridenDepsApp do
+  defmodule OverriddenDepsApp do
     def project do
       [
         app: :raw_sample,
@@ -277,7 +516,7 @@ defmodule Mix.Tasks.DepsTest do
     end
   end
 
-  defmodule NonOverridenDepsApp do
+  defmodule NonOverriddenDepsApp do
     def project do
       [
         app: :raw_sample,
@@ -291,38 +530,62 @@ defmodule Mix.Tasks.DepsTest do
   end
 
   test "fails on missing dependencies" do
-    Mix.Project.push SuccessfulDepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(SuccessfulDepsApp)
 
-    in_fixture "deps_status", fn ->
       assert_raise Mix.Error, ~r/Unknown dependency invalid for environment dev/, fn ->
-        Mix.Tasks.Deps.Get.run ["invalid"]
+        Mix.Tasks.Deps.Update.run(["invalid"])
       end
-    end
+    end)
   end
 
-  test "fails on diverged dependencies" do
-    Mix.Project.push DivergedDepsApp
+  @overriding_msg "  the dependency git_repo in mix.exs is overriding a child dependency"
+
+  test "fails on diverged dependencies on get/update" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(ConflictDepsApp, "mix.exs")
 
-    in_fixture "deps_status", fn ->
       assert_raise Mix.Error, fn ->
-        Mix.Tasks.Deps.Check.run []
+        Mix.Tasks.Deps.Loadpaths.run([])
       end
 
-      receive do
-        {:mix_shell, :error, ["  different specs were given for the git_repo app:" <> _ = msg]} ->
-          assert msg =~ "In custom/deps_repo/mix.exs:"
-          assert msg =~ "{:git_repo, \"0.1.0\", [git: #{inspect fixture_path("git_repo")}]}"
-      after
-        0 -> flunk "expected diverged error message"
+      assert_received {:mix_shell, :error, [@overriding_msg <> _]}
+
+      assert_raise Mix.Error, fn ->
+        Mix.Tasks.Deps.Get.run([])
       end
-    end
+
+      assert_received {:mix_shell, :error, [@overriding_msg <> _]}
+
+      assert_raise Mix.Error, fn ->
+        Mix.Tasks.Deps.Update.run(["--all"])
+      end
+
+      assert_received {:mix_shell, :error, [@overriding_msg <> _]}
+    end)
+  end
+
+  test "fails on diverged dependencies on check" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DivergedDepsApp)
+
+      assert_raise Mix.Error, fn ->
+        Mix.Tasks.Deps.Loadpaths.run([])
+      end
+
+      assert_received {:mix_shell, :error, ["  different specs were given" <> _ = received_msg]}
+      assert received_msg =~ "In custom/deps_repo/mix.exs:"
+
+      assert received_msg =~
+               "{:git_repo, \"0.1.0\", [env: :prod, git: #{inspect(fixture_path("git_repo"))}]}"
+    end)
   end
 
   test "fails on diverged dependencies by requirement" do
-    Mix.Project.push ConvergedDepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(ConvergedDepsApp)
 
-    in_fixture "deps_status", fn ->
-      File.write! "custom/deps_repo/mix.exs", """
+      File.write!("custom/deps_repo/mix.exs", """
       defmodule DepsRepo do
         use Mix.Project
 
@@ -336,28 +599,28 @@ defmodule Mix.Tasks.DepsTest do
           ]
         end
       end
-      """
+      """)
 
       assert_raise Mix.Error, fn ->
-        Mix.Tasks.Deps.Get.run []
-        Mix.Tasks.Deps.Check.run []
+        Mix.Tasks.Deps.Get.run([])
+        Mix.Tasks.Deps.Loadpaths.run([])
       end
 
-      receive do
-        {:mix_shell, :error, ["  the dependency git_repo defined" <> _ = msg]} ->
-          assert msg =~ "In custom/deps_repo/mix.exs:"
-          assert msg =~ "{:git_repo, \"0.2.0\", [git: #{inspect fixture_path("git_repo")}]}"
-      after
-        0 -> flunk "expected diverged req error message"
-      end
-    end
+      assert_received {:mix_shell, :error, ["  the dependency git_repo 0.1.0" <> _ = msg]}
+      assert msg =~ "In custom/deps_repo/mix.exs:"
+
+      assert msg =~
+               "{:git_repo, \"0.2.0\", [env: :prod, git: #{inspect(fixture_path("git_repo"))}]}"
+    end)
   end
 
+  @overriding_msg "  the dependency git_repo in custom/deps_repo/mix.exs is overriding"
+
   test "fails on diverged dependencies even when optional" do
-    Mix.Project.push ConvergedDepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(ConvergedDepsApp, "custom/deps_repo/mix.exs")
 
-    in_fixture "deps_status", fn ->
-      File.write! "custom/deps_repo/mix.exs", """
+      File.write!("custom/deps_repo/mix.exs", """
       defmodule DepsRepo do
         use Mix.Project
 
@@ -371,22 +634,22 @@ defmodule Mix.Tasks.DepsTest do
           ]
         end
       end
-      """
+      """)
 
       assert_raise Mix.Error, fn ->
-        Mix.Tasks.Deps.Get.run []
-        Mix.Tasks.Deps.Check.run []
+        Mix.Tasks.Deps.Get.run([])
+        Mix.Tasks.Deps.Loadpaths.run([])
       end
 
-      assert_received {:mix_shell, :error, ["  the dependency git_repo in mix.exs is overriding" <> _]}
-    end
+      assert_received {:mix_shell, :error, [@overriding_msg <> _]}
+    end)
   end
 
   test "works with converged dependencies" do
-    Mix.Project.push ConvergedDepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(ConvergedDepsApp)
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
       assert_received {:mix_shell, :info, [^message]}
 
@@ -394,21 +657,36 @@ defmodule Mix.Tasks.DepsTest do
       # so the message appears just once
       refute_received {:mix_shell, :info, [^message]}
 
-      Mix.Task.clear
-      Mix.Tasks.Deps.Update.run ["--all"]
+      Mix.Task.clear()
+      Mix.Tasks.Deps.Update.run(["--all"])
 
       message = "* Updating git_repo (#{fixture_path("git_repo")})"
       assert_received {:mix_shell, :info, [^message]}
-    end
+    end)
   after
-    purge [GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
+  end
+
+  test "does not check dependencies if --no-deps-check is provided" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(SuccessfulDepsApp)
+
+      Mix.Tasks.Deps.Get.run([])
+      File.rm_rf!("deps/ok")
+
+      assert_raise Mix.Error, fn ->
+        Mix.Tasks.Compile.run([])
+      end
+
+      Mix.Tasks.Compile.run(["--no-deps-check"])
+    end)
   end
 
   test "works with overridden dependencies" do
-    Mix.Project.push OverridenDepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(OverriddenDepsApp)
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Get.run []
+      Mix.Tasks.Deps.Get.run([])
       message = "* Getting git_repo (#{fixture_path("git_repo")})"
       assert_received {:mix_shell, :info, [^message]}
 
@@ -416,58 +694,128 @@ defmodule Mix.Tasks.DepsTest do
       # so the message appears just once
       refute_received {:mix_shell, :info, [^message]}
 
-      Mix.Task.clear
-      Mix.Tasks.Deps.Update.run ["--all"]
+      Mix.Task.clear()
+      Mix.Tasks.Deps.Update.run(["--all"])
 
       message = "* Updating git_repo (#{fixture_path("git_repo")})"
       assert_received {:mix_shell, :info, [^message]}
-    end
+    end)
   after
-    purge [GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
   end
 
   test "converged dependencies errors if not overriding" do
-    Mix.Project.push NonOverridenDepsApp
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(NonOverriddenDepsApp, "custom_mix.exs")
 
-    in_fixture "deps_status", fn ->
       assert_raise Mix.Error, fn ->
-        Mix.Tasks.Deps.Check.run []
+        Mix.Tasks.Deps.Loadpaths.run([])
       end
 
       receive do
-        {:mix_shell, :error, ["  the dependency git_repo in mix.exs" <> _ = msg]} ->
-          assert msg =~ "In mix.exs:"
-          assert msg =~ "{:git_repo, \"0.1.0\", [git: #{inspect fixture_path("git_repo")}]}"
+        {:mix_shell, :error, ["  the dependency git_repo in custom_mix.exs" <> _ = msg]} ->
+          assert msg =~ "In custom_mix.exs:"
+
+          assert msg =~
+                   "{:git_repo, \"0.1.0\", [env: :prod, git: #{inspect(fixture_path("git_repo"))}]}"
       after
-        0 -> flunk "expected overriding error message"
+        0 -> flunk("expected overriding error message")
       end
-    end
+    end)
   after
-    purge [GitRepo, GitRepo.Mix]
+    purge([GitRepo, GitRepo.MixProject])
   end
 
-  test "checks if dependencies are using old elixir version" do
-    Mix.Project.push SuccessfulDepsApp
+  test "checks if dependencies are using old Elixir version" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(SuccessfulDepsApp)
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Compile.run []
-      Mix.Tasks.Deps.Check.run []
+      Mix.Tasks.Deps.Compile.run([])
+      Mix.Tasks.Deps.Loadpaths.run([])
 
       File.mkdir_p!("_build/dev/lib/ok/ebin")
-      File.write!("_build/dev/lib/ok/.compile.lock", "the_future")
-      Mix.Task.clear
+      File.mkdir_p!("_build/dev/lib/ok/.mix")
+      manifest_data = :erlang.term_to_binary({:v1, "the_future", :scm})
+      File.write!("_build/dev/lib/ok/.mix/compile.elixir_scm", manifest_data)
+      Mix.Task.clear()
 
-      msg = "  the dependency is built with an out-of-date elixir version, run `mix deps.compile`"
+      msg =
+        "  the dependency was built with an out-of-date Erlang/Elixir version, run \"mix deps.compile\""
 
-      Mix.Tasks.Deps.run []
+      Mix.Tasks.Deps.run([])
       assert_received {:mix_shell, :info, [^msg]}
 
-      # deps.check will automatically recompiled it
-      Mix.Tasks.Deps.Check.run []
+      # deps.loadpaths will automatically recompile it
+      Mix.Tasks.Deps.Loadpaths.run([])
 
-      Mix.Tasks.Deps.run []
+      Mix.Tasks.Deps.run([])
       refute_received {:mix_shell, :info, [^msg]}
-    end
+    end)
+  end
+
+  test "checks if dependencies are using old scm version" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(SuccessfulDepsApp)
+
+      Mix.Tasks.Deps.Compile.run([])
+      Mix.Tasks.Deps.Loadpaths.run([])
+
+      File.mkdir_p!("_build/dev/lib/ok/ebin")
+      File.mkdir_p!("_build/dev/lib/ok/.mix")
+
+      manifest_data =
+        :erlang.term_to_binary(
+          {2, {System.version(), :erlang.system_info(:otp_release)}, :scm, nil}
+        )
+
+      File.write!("_build/dev/lib/ok/.mix/compile.elixir_scm", manifest_data)
+      Mix.Task.clear()
+
+      msg = "  the dependency was built with another SCM, run \"mix deps.compile\""
+      Mix.Tasks.Deps.run([])
+      assert_received {:mix_shell, :info, [^msg]}
+
+      # deps.loadpaths will automatically recompile it
+      Mix.Tasks.Deps.Loadpaths.run([])
+
+      Mix.Tasks.Deps.run([])
+      refute_received {:mix_shell, :info, [^msg]}
+    end)
+  end
+
+  test "checks if compile env changed" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(RawRepoDepApp)
+      Mix.Tasks.Deps.Loadpaths.run([])
+      assert_receive {:mix_shell, :info, ["Generated raw_repo app"]}
+      assert Application.spec(:raw_repo, :vsn)
+
+      File.mkdir_p!("config")
+
+      File.write!("config/config.exs", """
+      import Config
+      config :raw_repo, :compile_env, :new_value
+      """)
+
+      Application.unload(:raw_repo)
+      Mix.ProjectStack.pop()
+      Mix.Task.clear()
+      Mix.Project.push(RawRepoDepApp)
+      purge([RawRepo])
+      Mix.Tasks.Loadconfig.load_compile("config/config.exs")
+
+      Mix.Tasks.Deps.run([])
+
+      assert_receive {:mix_shell, :info,
+                      ["  the dependency build is outdated, please run \"mix deps.compile\""]}
+
+      Mix.Tasks.Deps.Loadpaths.run([])
+
+      assert_receive {:mix_shell, :info, ["Generated raw_repo app"]}
+      assert Application.spec(:raw_repo, :vsn)
+    end)
+  after
+    Application.delete_env(:raw_repo, :compile_env, persistent: true)
   end
 
   defmodule NonCompilingDeps do
@@ -476,21 +824,19 @@ defmodule Mix.Tasks.DepsTest do
         app: :raw_sample,
         version: "0.1.0",
         deps: [
-          {:deps_repo, "0.1.0", path: "custom/deps_repo", compile: false},
           {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo"), compile: false}
         ]
       ]
     end
   end
 
-  test "does not compile deps that have explicit flag" do
-    Mix.Project.push NonCompilingDeps
+  test "does not compile deps that have explicit option" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(NonCompilingDeps)
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.Compile.run []
-      refute_received {:mix_shell, :info, ["==> deps_repo"]}
+      Mix.Tasks.Deps.Compile.run([])
       refute_received {:mix_shell, :info, ["==> git_repo"]}
-    end
+    end)
   end
 
   defmodule DupDeps do
@@ -507,63 +853,128 @@ defmodule Mix.Tasks.DepsTest do
     end
   end
 
-  test "converges duplicated deps at the same level" do
-    Mix.Project.push DupDeps
+  test "warns and converges duplicated deps at the same level" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(DupDeps)
+
+      Mix.Tasks.Deps.run([])
 
-    in_fixture "deps_status", fn ->
-      Mix.Tasks.Deps.run []
+      msg =
+        "warning: the dependency :ok is duplicated at the top level, please remove one of them"
+
+      assert_received {:mix_shell, :error, [^msg]}
 
-      msg = "* ok 0.1.0 (deps/ok)"
+      msg = "* ok 0.1.0 (deps/ok) (mix)"
       assert_received {:mix_shell, :info, [^msg]}
       refute_received {:mix_shell, :info, [^msg]}
-    end
+    end)
   end
 
+  ## deps.clean
+
   defmodule CleanDepsApp do
     def project do
       [
         app: :raw_sample,
         version: "0.1.0",
         deps: [
-          {:git_repo, ">= 0.1.0", git: MixTest.Case.fixture_path("git_repo")}
+          {:git_repo, ">= 0.1.0", git: MixTest.Case.fixture_path("git_repo")},
+          {:ok, ">= 2.0.0", path: "deps/ok"}
         ]
       ]
     end
   end
 
-  test "clean all deps" do
-    Mix.Project.push CleanDepsApp
+  test "cleans dependencies" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(CleanDepsApp)
 
-    in_fixture "deps_status", fn ->
-      File.mkdir_p!("deps/git_repo")
+      File.mkdir_p!("_build/dev/lib/raw_sample")
       File.mkdir_p!("_build/dev/lib/git_repo")
+      File.mkdir_p!("_build/test/lib/git_repo")
+      File.mkdir_p!("_build/dev/lib/ok")
+      File.mkdir_p!("_build/test/lib/ok")
 
-      message = "mix deps.clean expects dependencies as arguments or " <>
-                "the --all option to clean all dependencies"
+      message =
+        "\"mix deps.clean\" expects dependencies as arguments or " <>
+          "an option indicating which dependencies to clean. " <>
+          "The --all option will clean all dependencies while " <>
+          "the --unused option cleans unused dependencies"
 
       assert_raise Mix.Error, message, fn ->
-        Mix.Tasks.Deps.Clean.run []
+        Mix.Tasks.Deps.Clean.run([])
       end
 
-      Mix.Tasks.Deps.Clean.run ["--all"]
-      refute File.exists?("deps/git_repo")
-    end
+      Mix.Tasks.Deps.Clean.run(["--only", "dev", "--all"])
+      refute File.exists?("_build/dev/lib/git_repo")
+      refute File.exists?("_build/dev/lib/ok")
+      assert File.exists?("_build/test/lib/git_repo")
+      assert File.exists?("_build/dev/lib/raw_sample")
+
+      Mix.Tasks.Deps.Clean.run(["--all"])
+      refute File.exists?("_build/dev/lib/git_repo")
+      refute File.exists?("_build/test/lib/git_repo")
+      assert File.exists?("_build/dev/lib/raw_sample")
+    end)
   end
 
-  test "cleans dependencies" do
-    Mix.Project.push CleanDepsApp
+  test "cleans unused dependencies" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(CleanDepsApp)
 
-    in_fixture "deps_status", fn ->
+      File.mkdir_p!("_build/dev/lib/raw_sample")
+      File.mkdir_p!("deps/git_repo")
       File.mkdir_p!("_build/dev/lib/git_repo")
-      File.mkdir_p!("_build/test/lib/git_repo")
+      File.mkdir_p!("deps/git_repo_unused")
+      File.mkdir_p!("_build/dev/lib/git_repo_unused")
 
-      Mix.Tasks.Deps.Clean.run ["--only", "dev", "--all"]
-      refute File.exists?("_build/dev/lib/git_repo")
-      assert File.exists?("_build/test/lib/git_repo")
+      Mix.Tasks.Deps.Clean.run(["--unused"])
+      assert File.exists?("deps/git_repo")
+      assert File.exists?("_build/dev/lib/git_repo")
+      refute File.exists?("deps/git_repo_unused")
+      refute File.exists?("_build/dev/lib/git_repo_unused")
+      assert File.exists?("_build/dev/lib/raw_sample")
+    end)
+  end
 
-      Mix.Tasks.Deps.Clean.run ["--all"]
-      refute File.exists?("_build/dev/lib/git_repo")
-      refute File.exists?("_build/test/lib/git_repo")
-    end
+  test "cleans dependencies build" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(CleanDepsApp)
+
+      File.mkdir_p!("deps/raw_sample")
+      File.mkdir_p!("_build/dev/lib/raw_sample")
+
+      Mix.Tasks.Deps.Clean.run(["raw_sample", "--build"])
+      assert File.exists?("deps/raw_sample")
+      refute File.exists?("_build/dev/lib/raw_sample")
+    end)
+  end
+
+  test "warns on invalid path on clean dependencies" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(CleanDepsApp)
+
+      File.mkdir_p!("deps/raw_sample")
+      File.mkdir_p!("_build/dev/lib/raw_sample")
+
+      Mix.Tasks.Deps.Clean.run(["raw_sample_with_a_typo"])
+      assert File.exists?("deps/raw_sample")
+
+      msg = "warning: the dependency raw_sample_with_a_typo is not present in the build directory"
+      assert_received {:mix_shell, :error, [^msg]}
+    end)
+  end
+
+  test "does not remove dependency source when using :path" do
+    in_fixture("deps_status", fn ->
+      Mix.Project.push(CleanDepsApp)
+
+      assert File.exists?("deps/ok")
+
+      Mix.Tasks.Deps.Clean.run(["raw_sample", "--all"])
+      refute File.exists?("_build/dev/lib/ok")
+      refute File.exists?("_build/test/lib/ok")
+      assert File.exists?("deps/ok")
+    end)
   end
 end
diff --git a/lib/mix/test/mix/tasks/do_test.exs b/lib/mix/test/mix/tasks/do_test.exs
index 0c7ef442688..7d46eed548a 100644
--- a/lib/mix/test/mix/tasks/do_test.exs
+++ b/lib/mix/test/mix/tasks/do_test.exs
@@ -1,13 +1,151 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.DoTest do
   use MixTest.Case
 
-  test "runs given tasks" do
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Do.run ["compile", "--list,", "help"]
+  import Mix.Tasks.Do, only: [gather_commands: 1]
+
+  test "runs given tasks", context do
+    in_tmp(context.test, fn ->
+      Mix.Tasks.Do.run(["compile", "--list", "+", "help"])
       assert_received {:mix_shell, :info, ["mix help" <> _]}
       assert_received {:mix_shell, :info, ["mix compile.app" <> _]}
+    end)
+  end
+
+  test "raises if a task is empty" do
+    for args <- [~w(), ~w(+), ~w(help +), ~w(+ help)] do
+      assert_raise Mix.Error, ~r"^One of the commands passed to \"mix do\" is empty", fn ->
+        Mix.Tasks.Do.run(args)
+      end
     end
   end
-end
\ No newline at end of file
+
+  test "gather_command returns a list of commands" do
+    assert gather_commands(["help", "+", "compile"]) ==
+             [["help"], ["compile"]]
+
+    assert gather_commands(["help", "+", "compile", "--list"]) ==
+             [["help"], ["compile", "--list"]]
+
+    assert gather_commands(["help", "--list", "+", "compile", "--list"]) ==
+             [["help", "--list"], ["compile", "--list"]]
+  end
+
+  test "gather_command supports deprecated comma commands" do
+    ExUnit.CaptureIO.capture_io(:stderr, fn ->
+      assert gather_commands(["compile", "--list,", "help"]) == [["compile", "--list"], ["help"]]
+      assert gather_commands(["help,", "compile", "--list"]) == [["help"], ["compile", "--list"]]
+
+      assert gather_commands(["compile,", "run", "-e", "IO.puts :hello"]) ==
+               [["compile"], ["run", "-e", "IO.puts :hello"]]
+
+      assert gather_commands(["compile,", "run", "-e", "[1, 2]"]) ==
+               [["compile"], ["run", "-e", "[1, 2]"]]
+
+      assert gather_commands(["test", ",", "help"]) == [["test"], ["help"]]
+    end)
+  end
+
+  test "runs given tasks for a single app specified by app flag" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Tasks.Do.run(~w(--app bar compile --list + cmd echo hello))
+
+        assert_received {:mix_shell, :info, ["==> bar"]}
+        assert_received {:mix_shell, :run, ["hello\n"]}
+        refute_received {:mix_shell, :info, ["==> foo"]}
+        refute_received {:mix_shell, :run, ["hello\n"]}
+      end)
+    end)
+  end
+
+  test "runs given tasks for each app specified by app flag" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Tasks.Do.run(~w(--app bar --app foo compile --list + cmd echo hello))
+
+        assert_received {:mix_shell, :info, ["==> bar"]}
+        assert_received {:mix_shell, :run, ["hello\n"]}
+        assert_received {:mix_shell, :info, ["==> foo"]}
+        assert_received {:mix_shell, :run, ["hello\n"]}
+      end)
+    end)
+  end
+
+  test "runs non-recursive tasks at project root level" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Tasks.Do.run(~w(--app bar --app foo compile --list + help))
+
+        assert_received {:mix_shell, :info, ["mix help" <> _]}
+        assert_received {:mix_shell, :info, ["mix compile.app" <> _]}
+      end)
+    end)
+  end
+
+  test "raises when -app is given but the project is not an umbrella" do
+    assert_raise Mix.Error,
+                 "Could not run \"cmd\" with the --app option because this is not an umbrella project",
+                 fn ->
+                   Mix.Tasks.Do.run(~w(--app bar --app foo cmd echo hello))
+                 end
+  end
+
+  test "runs given aliases for each app specified by app flag" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      aliases = [
+        e: ["cmd echo hello"],
+        p: fn val -> Mix.shell().info(inspect(val)) end
+      ]
+
+      Mix.Project.in_project(:umbrella, ".", [aliases: aliases], fn _ ->
+        Mix.Tasks.Do.run(["compile"])
+        Mix.Tasks.Do.run(["--app", "bar", "--app", "foo", "e", "+", "p", "Foo"])
+
+        assert_received {:mix_shell, :info, ["==> bar"]}
+        assert_received {:mix_shell, :run, ["hello\n"]}
+        assert_received {:mix_shell, :info, ["[\"Foo\"]"]}
+
+        assert_received {:mix_shell, :info, ["==> foo"]}
+        assert_received {:mix_shell, :run, ["hello\n"]}
+        assert_received {:mix_shell, :info, ["[\"Foo\"]"]}
+      end)
+    end)
+  end
+
+  test "runs non-recursive aliases at project root level" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      aliases = [
+        h: "help"
+      ]
+
+      Mix.Project.in_project(:umbrella, ".", [aliases: aliases], fn _ ->
+        Mix.Tasks.Do.run(["--app", "bar", "--app", "foo", "h"])
+
+        assert_received {:mix_shell, :info, ["mix help" <> _]}
+      end)
+    end)
+  end
+
+  test "raise with aliases when -app is given but the project is not an umbrella" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      aliases = [
+        e: ["cmd echo hello"],
+        p: fn val -> Mix.shell().info(inspect(val)) end
+      ]
+
+      Mix.Project.in_project(:foo, "apps/foo", [aliases: aliases], fn _ ->
+        assert_raise Mix.Error,
+                     "Could not run \"e\" with the --app option because this is not an umbrella project",
+                     fn ->
+                       Mix.Tasks.Do.run(~w(--app bar --app foo e + p Foo))
+                     end
+      end)
+    end)
+  end
+end
diff --git a/lib/mix/test/mix/tasks/escript_test.exs b/lib/mix/test/mix/tasks/escript_test.exs
new file mode 100644
index 00000000000..ce363baf95e
--- /dev/null
+++ b/lib/mix/test/mix/tasks/escript_test.exs
@@ -0,0 +1,411 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.EscriptTest do
+  use MixTest.Case
+
+  defmodule Escript do
+    def project do
+      [
+        app: :escript_test,
+        version: "0.0.1",
+        escript: [main_module: EscriptTest, name: "escript_test", embed_elixir: true]
+      ]
+    end
+  end
+
+  defmodule EscriptErlangWithDeps do
+    def project do
+      [
+        app: :escript_test,
+        version: "0.0.1",
+        language: :erlang,
+        escript: [main_module: :escript_test],
+        deps: [{:ok, path: fixture_path("deps_status/deps/ok")}]
+      ]
+    end
+
+    def application do
+      [applications: [], extra_applications: [:crypto, elixir: :optional]]
+    end
+  end
+
+  test "generate escript" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript)
+
+      Mix.Tasks.Escript.Build.run([])
+      assert_received {:mix_shell, :info, ["Generated escript escript_test with MIX_ENV=dev"]}
+      assert System.cmd("escript", ["escript_test"]) == {"TEST\n", 0}
+      assert count_abstract_code("escript_test") == 0
+
+      # Consolidates protocols
+      assert System.cmd("escript", ["escript_test", "--protocol", "Enumerable"]) == {"true\n", 0}
+
+      # Each app has a distinct, valid path
+      assert System.cmd("escript", ["escript_test", "--app-paths"]) == {"{true, true, true}\n", 0}
+
+      # Does not include priv by default
+      assert System.cmd("escript", ["escript_test", "--list-priv", "escript_test"]) ==
+               {":error\n", 0}
+    end)
+  end
+
+  test "generate escript without protocol consolidation" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript, consolidate_protocols: false)
+
+      Mix.Tasks.Escript.Build.run([])
+      assert_received {:mix_shell, :info, ["Generated escript escript_test with MIX_ENV=dev"]}
+      assert System.cmd("escript", ["escript_test"]) == {"TEST\n", 0}
+      assert count_abstract_code("escript_test") == 0
+
+      # Does not consolidate protocols
+      assert System.cmd("escript", ["escript_test", "--protocol", "Enumerable"]) == {"false\n", 0}
+    end)
+  end
+
+  test "generate escript with --no-compile option" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript)
+
+      Mix.Tasks.Compile.run([])
+      purge([EscriptTest])
+
+      Mix.Tasks.Escript.Build.run(["--no-compile"])
+      assert_received {:mix_shell, :info, ["Generated escript escript_test with MIX_ENV=dev"]}
+    end)
+  end
+
+  test "generate escript with compile config" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript)
+
+      File.mkdir_p!("config")
+
+      File.write!("config/config.exs", ~S"""
+      import Config
+      config :foobar, :value, "COMPILE #{config_env()} TARGET #{config_target()}"
+      """)
+
+      Mix.Tasks.Escript.Build.run([])
+      assert_received {:mix_shell, :info, ["Generated escript escript_test with MIX_ENV=dev"]}
+      assert System.cmd("escript", ["escript_test"]) == {"COMPILE dev TARGET host\n", 0}
+    end)
+  end
+
+  test "generate escript with runtime config" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript)
+
+      File.mkdir_p!("config")
+
+      File.write!("config/config.exs", """
+      [foobar: [value: "OLD", nesting: [config: true, runtime: false]]]
+      """)
+
+      File.write!("config/runtime.exs", ~S"""
+      import Config
+      config :foobar, :value, "RUNTIME #{config_env()} TARGET #{config_target()} ARGV #{System.argv()}"
+      config :foobar, :nesting, runtime: true
+      """)
+
+      Mix.Tasks.Escript.Build.run([])
+      assert_received {:mix_shell, :info, ["Generated escript escript_test with MIX_ENV=dev"]}
+
+      assert System.cmd("escript", ["escript_test", "--foo", "--bar"]) ==
+               {"RUNTIME dev TARGET host ARGV --foo--bar\n", 0}
+
+      assert System.cmd("escript", ["escript_test", "--nesting"]) ==
+               {"[config: true, runtime: true]\n", 0}
+    end)
+  end
+
+  test "generate escript with debug information" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript, escript: [main_module: EscriptTest, strip_beams: false])
+
+      Mix.Tasks.Escript.Build.run([])
+
+      msg = "Generated escript escript_test with MIX_ENV=dev"
+      assert_received {:mix_shell, :info, [^msg]}
+
+      assert System.cmd("escript", ["escript_test"]) == {"TEST\n", 0}
+      assert count_abstract_code("escript_test") > 0
+    end)
+  end
+
+  defp count_abstract_code(escript_filename) do
+    escript_filename
+    |> read_beams()
+    |> Enum.count(fn {_, beam} -> get_abstract_code(beam) end)
+  end
+
+  defp read_beams(escript_filename) do
+    # :zip.unzip/2 cannot unzip an escript unless we remove the escript header
+    zip_data = remove_escript_header(File.read!(escript_filename))
+    {:ok, tuples} = :zip.unzip(zip_data, [:memory])
+
+    for {filename, beam} <- tuples, Path.extname(filename) == ".beam" do
+      {filename, beam}
+    end
+  end
+
+  defp remove_escript_header(escript_data) do
+    {offset, _length} = :binary.match(escript_data, "\nPK")
+    zip_start = offset + 1
+    binary_part(escript_data, zip_start, byte_size(escript_data) - zip_start)
+  end
+
+  defp get_abstract_code(beam) do
+    case :beam_lib.chunks(beam, [:abstract_code]) do
+      {:ok, {_, [{:abstract_code, {_, abstract_code}}]}} -> abstract_code
+      _ -> nil
+    end
+  end
+
+  test "generate escript with path" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript,
+        escript: [
+          app: nil,
+          embed_elixir: true,
+          main_module: EscriptTest,
+          path: Path.join("ebin", "escript_test")
+        ]
+      )
+
+      Mix.Tasks.Escript.Build.run([])
+
+      message = "Generated escript ebin/escript_test with MIX_ENV=dev"
+      assert_received {:mix_shell, :info, [^message]}
+
+      assert System.cmd("escript", ["ebin/escript_test"]) == {"TEST\n", 0}
+    end)
+  end
+
+  test "generate escript with deps" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript,
+        escript: [main_module: EscriptTest],
+        deps: [{:ok, path: fixture_path("deps_status/deps/ok")}]
+      )
+
+      Mix.Tasks.Escript.Build.run([])
+
+      message = "Generated escript escript_test with MIX_ENV=dev"
+      assert_received {:mix_shell, :info, [^message]}
+
+      assert System.cmd("escript", ["escript_test"]) == {"TEST\n", 0}
+
+      # Does not include priv for deps by default
+      assert System.cmd("escript", ["escript_test", "--list-priv", "ok"]) == {":error\n", 0}
+    end)
+  after
+    purge([Ok.MixProject])
+  end
+
+  test "generate escript with Erlang and deps" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(EscriptErlangWithDeps)
+
+      Mix.Tasks.Escript.Build.run([])
+
+      message = "Generated escript escript_test with MIX_ENV=dev"
+      assert_received {:mix_shell, :info, [^message]}
+
+      assert System.cmd("escript", ["escript_test", "arg1", "arg2"]) ==
+               {~s(["arg1","arg2"]), 0}
+    end)
+  after
+    purge([Ok.MixProject])
+  end
+
+  test "generate escript with Erlang main module" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript, escript: [main_module: :escript_test])
+
+      Mix.Tasks.Escript.Build.run([])
+
+      message = "Generated escript escript_test with MIX_ENV=dev"
+      assert_received {:mix_shell, :info, [^message]}
+
+      assert System.cmd("escript", ["escript_test", "arg1", "arg2"]) ==
+               {~s([<<"arg1">>,<<"arg2">>]), 0}
+    end)
+  after
+    purge([Ok.MixProject])
+  end
+
+  test "generate escript with priv" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript,
+        escript: [main_module: EscriptTest, include_priv_for: [:escript_test, :ok]],
+        deps: [{:ok, path: fixture_path("deps_status/deps/ok")}]
+      )
+
+      Mix.Tasks.Escript.Build.run([])
+
+      message = "Generated escript escript_test with MIX_ENV=dev"
+      assert_received {:mix_shell, :info, [^message]}
+
+      assert System.cmd("escript", ["escript_test", "--list-priv", "escript_test"]) ==
+               {~s/{:ok, [~c"hello"]}\n/, 0}
+
+      assert System.cmd("escript", ["escript_test", "--list-priv", "ok"]) ==
+               {~s/{:ok, [~c"sample"]}\n/, 0}
+    end)
+  end
+
+  test "escript install and uninstall" do
+    File.rm_rf!(tmp_path(".mix/escripts"))
+
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript)
+
+      # check that no escripts are installed
+      Mix.Tasks.Escript.run([])
+      assert_received {:mix_shell, :info, ["No escripts currently installed."]}
+
+      # build and install our escript
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Escript.Install.run([])
+
+      # check that it shows in the list
+      Mix.Tasks.Escript.run([])
+      assert_received {:mix_shell, :info, ["* escript_test"]}
+      refute_received {:mix_shell, :info, ["* escript_test.bat"]}
+
+      # check uninstall confirmation
+      send(self(), {:mix_shell_input, :yes?, false})
+      Mix.Tasks.Escript.Uninstall.run(["escript_test"])
+      assert File.regular?(tmp_path(".mix/escripts/escript_test"))
+
+      # uninstall the escript
+      send(self(), {:mix_shell_input, :yes?, true})
+      Mix.Tasks.Escript.Uninstall.run(["escript_test"])
+      refute File.regular?(tmp_path(".mix/escripts/escript_test"))
+      refute File.regular?(tmp_path(".mix/escripts/escript_test.bat"))
+
+      # check that no escripts remain
+      Mix.Tasks.Escript.run([])
+      assert_received {:mix_shell, :info, ["No escripts currently installed."]}
+    end)
+  end
+
+  test "escript install and uninstall --force" do
+    File.rm_rf!(tmp_path(".mix/escripts"))
+
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript)
+
+      Mix.Tasks.Escript.Install.run(["--force"])
+
+      # check that it shows in the list
+      Mix.Tasks.Escript.run([])
+      assert_received {:mix_shell, :info, ["* escript_test"]}
+      refute_received {:mix_shell, :info, ["* escript_test.bat"]}
+
+      # uninstall the escript
+      Mix.Tasks.Escript.Uninstall.run(["escript_test", "--force"])
+
+      # check that no escripts remain
+      Mix.Tasks.Escript.run([])
+      assert_received {:mix_shell, :info, ["No escripts currently installed."]}
+    end)
+  end
+
+  test "escript invalid install" do
+    # Install our escript
+    send(self(), {:mix_shell_input, :yes?, true})
+    message = "The given path does not point to an escript, installation aborted"
+
+    assert_raise Mix.Error, message, fn ->
+      Mix.Tasks.Escript.Install.run([__ENV__.file])
+    end
+  end
+
+  test "escript invalid main module" do
+    in_fixture("escript_test", fn ->
+      push_project_with_config(Escript, escript: [main_module: BogusEscriptTest])
+
+      message =
+        "Could not generate escript, module Elixir.BogusEscriptTest defined as :main_module could not be loaded"
+
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Escript.Build.run([])
+      end
+    end)
+  end
+
+  for count <- [1, 2] do
+    test "escript.install from Git (with MIX_OS_DEPS_COMPILE_PARTITION_COUNT=#{count})" do
+      System.put_env("MIX_OS_DEPS_COMPILE_PARTITION_COUNT", "#{unquote(count)}")
+
+      in_fixture("deps_status", fn ->
+        File.mkdir_p!("config")
+        File.mkdir_p!("lib")
+
+        File.write!("config/config.exs", """
+        import Config
+        config :source_repo, :escript_config, true
+        """)
+
+        File.write!("lib/source_repo.ex", """
+        require Application
+        true = Application.compile_env!(:source_repo, :escript_config)
+
+        defmodule SourceRepo.Escript do
+          def main(_argv) do
+            IO.puts("TEST")
+          end
+        end
+        """)
+
+        File.write!("mix.exs", """
+        defmodule SourceRepo.MixProject do
+          use Mix.Project
+
+          def project do
+            [
+              app: :source_repo,
+              version: "0.1.0",
+              escript: [main_module: SourceRepo.Escript],
+              deps: [
+                {:git_repo, path: "#{MixTest.Case.fixture_path("git_repo")}"},
+                {:git_rebar, path: "#{MixTest.Case.fixture_path("git_rebar")}", manager: :rebar3},
+                {:ok, path: "deps/ok"},
+              ]
+            ]
+          end
+        end
+        """)
+
+        System.cmd("git", ~w[init])
+        System.cmd("git", ~w[add .])
+        System.cmd("git", ~w[commit -m "ok"])
+
+        ExUnit.CaptureIO.capture_io(fn ->
+          send(self(), {:mix_shell_input, :yes?, true})
+          Mix.Tasks.Escript.Install.run(["git", File.cwd!()])
+        end)
+
+        assert_received {:mix_shell, :info, ["Generated escript source_repo with MIX_ENV=prod"]}
+
+        escript_path = Path.join([tmp_path(".mix"), "escripts", "source_repo"])
+        assert System.cmd("escript", [escript_path]) == {"TEST\n", 0}
+      end)
+    after
+      System.delete_env("MIX_OS_DEPS_COMPILE_PARTITION_COUNT")
+      purge([SourceRepo.Escript, SourceRepo.MixProject, Mix.Local.Installer.MixProject])
+    end
+  end
+
+  defp push_project_with_config(module, config \\ []) do
+    Mix.ProjectStack.post_config(config)
+    Mix.Project.push(module)
+  end
+end
diff --git a/lib/mix/test/mix/tasks/escriptize_test.exs b/lib/mix/test/mix/tasks/escriptize_test.exs
deleted file mode 100644
index a5839554132..00000000000
--- a/lib/mix/test/mix/tasks/escriptize_test.exs
+++ /dev/null
@@ -1,79 +0,0 @@
-Code.require_file "../../test_helper.exs", __DIR__
-
-defmodule Mix.Tasks.EscriptizeTest do
-  use MixTest.Case
-
-  defmodule Escript do
-    def project do
-      [ app: :escripttest,
-        version: "0.0.1",
-        escript: [
-          main_module: Escripttest,
-          name: "escriptest",
-          embed_elixir: true
-        ]
-      ]
-    end
-  end
-
-  defmodule EscriptWithPath do
-    def project do
-      [ app: :escripttestwithpath,
-        version: "0.0.1",
-        escript: [
-          app: nil,
-          embed_elixir: true,
-          main_module: Escripttest,
-          path: Path.join("ebin", "escripttestwithpath")
-        ]
-      ]
-    end
-  end
-
-  defmodule EscriptWithDeps do
-    def project do
-      [ app: :escripttestwithdeps,
-        version: "0.0.1",
-        escript: [
-          main_module: Escripttest,
-          path: Path.join("ebin", "escripttestwithdeps"),
-        ],
-        deps: [{:ok, path: fixture_path("deps_status/deps/ok")}] ]
-    end
-  end
-
-  test "generate simple escript" do
-    Mix.Project.push Escript
-
-    in_fixture "escripttest", fn ->
-      Mix.Tasks.Escriptize.run []
-      assert_received {:mix_shell, :info, ["Generated escript escriptest"]}
-      assert System.cmd("escript escriptest") == "TEST\n"
-
-      Mix.Tasks.Escriptize.run []
-      refute_received {:mix_shell, :info, ["Generated escript escriptest"]}
-    end
-  end
-
-  test "generate simple escript with path" do
-    Mix.Project.push EscriptWithPath
-
-    in_fixture "escripttest", fn ->
-      Mix.Tasks.Escriptize.run []
-      assert_received {:mix_shell, :info, ["Generated escript ebin/escripttestwithpath"]}
-      assert System.cmd("escript ebin/escripttestwithpath") == "TEST\n"
-    end
-  end
-
-  test "generate escript with deps" do
-    Mix.Project.push EscriptWithDeps
-
-    in_fixture "escripttest", fn ->
-      Mix.Tasks.Escriptize.run []
-      assert_received {:mix_shell, :info, ["Generated escript ebin/escripttestwithdeps"]}
-      assert System.cmd("escript ebin/escripttestwithdeps") == "TEST\n"
-    end
-  after
-    purge [Ok.Mixfile]
-  end
-end
diff --git a/lib/mix/test/mix/tasks/eval_test.exs b/lib/mix/test/mix/tasks/eval_test.exs
new file mode 100644
index 00000000000..8200a7fc865
--- /dev/null
+++ b/lib/mix/test/mix/tasks/eval_test.exs
@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.EvalTest do
+  use MixTest.Case
+
+  setup do
+    Mix.Project.push(MixTest.Case.Sample)
+  end
+
+  test "does not start applications", context do
+    in_tmp(context.test, fn ->
+      expr = "send self(), {:apps, Application.started_applications()}"
+      Mix.Tasks.Eval.run([expr])
+      assert_received {:apps, apps}
+      refute List.keyfind(apps, :sample, 0)
+    end)
+  end
+
+  test "runs multiple commands", context do
+    in_tmp(context.test, fn ->
+      Mix.Tasks.Eval.run(["send self(), {:eval, :foo}"])
+      assert_received {:eval, :foo}
+
+      Mix.Tasks.Eval.run(["send self(), {:eval, :bar}"])
+      assert_received {:eval, :bar}
+    end)
+  end
+
+  test "accepts arguments", context do
+    in_tmp(context.test, fn ->
+      Mix.Tasks.Eval.run(["send self(), {:argv, System.argv()}", "bar", "baz"])
+      assert_received {:argv, ~w[bar baz]}
+    end)
+  end
+
+  test "resets argv to previous value", context do
+    argv = System.argv()
+
+    try do
+      in_tmp(context.test, fn ->
+        System.argv(["foo"])
+
+        Mix.Tasks.Eval.run(["send self(), {:argv, System.argv()}", "bar", "baz"])
+        assert_received {:argv, ~w[bar baz]}
+
+        assert ["foo"] == System.argv()
+      end)
+    after
+      System.argv(argv)
+    end
+  end
+
+  test "runs without mix.exs" do
+    Mix.Project.pop()
+
+    assert_raise Mix.Error, ~r/Cannot execute "mix eval" without a Mix.Project/, fn ->
+      Mix.Tasks.Eval.run(["send self(), {:eval, :foo}"])
+    end
+
+    Mix.Tasks.Eval.run(["--no-mix-exs", "send self(), {:eval, :foo}"])
+    assert_received {:eval, :foo}
+  end
+end
diff --git a/lib/mix/test/mix/tasks/format_test.exs b/lib/mix/test/mix/tasks/format_test.exs
new file mode 100644
index 00000000000..d5d17bbace4
--- /dev/null
+++ b/lib/mix/test/mix/tasks/format_test.exs
@@ -0,0 +1,1394 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.FormatTest do
+  use MixTest.Case
+
+  import ExUnit.CaptureIO
+
+  defmodule FormatWithDepsApp do
+    def project do
+      [
+        app: :format_with_deps,
+        version: "0.1.0",
+        deps: [{:my_dep, "0.1.0", path: "deps/my_dep"}]
+      ]
+    end
+  end
+
+  test "doesn't format empty files into line breaks", context do
+    in_tmp(context.test, fn ->
+      File.write!("a.exs", "")
+      Mix.Tasks.Format.run(["a.exs"])
+      assert File.read!("a.exs") == ""
+
+      File.write!("b.exs", "  \n  \n")
+      Mix.Tasks.Format.run(["b.exs"])
+      assert File.read!("b.exs") == ""
+    end)
+  end
+
+  test "formats the given files", context do
+    in_tmp(context.test, fn ->
+      File.write!("a.ex", """
+      foo bar
+      """)
+
+      Mix.Tasks.Format.run(["a.ex"])
+
+      assert File.read!("a.ex") == """
+             foo(bar)
+             """
+    end)
+  end
+
+  test "formats the given pattern", context do
+    in_tmp(context.test, fn ->
+      File.write!("a.ex", """
+      foo bar
+      """)
+
+      Mix.Tasks.Format.run(["*.ex", "a.ex"])
+
+      assert File.read!("a.ex") == """
+             foo(bar)
+             """
+    end)
+  end
+
+  test "is a no-op if the file is already formatted", context do
+    in_tmp(context.test, fn ->
+      File.write!("a.ex", """
+      foo(bar)
+      """)
+
+      File.touch!("a.ex", {{2010, 1, 1}, {0, 0, 0}})
+      Mix.Tasks.Format.run(["a.ex"])
+      assert File.stat!("a.ex").mtime == {{2010, 1, 1}, {0, 0, 0}}
+    end)
+  end
+
+  test "does not write file to disk on dry-run", context do
+    in_tmp(context.test, fn ->
+      File.write!("a.ex", """
+      foo bar
+      """)
+
+      Mix.Tasks.Format.run(["a.ex", "--dry-run"])
+
+      assert File.read!("a.ex") == """
+             foo bar
+             """
+    end)
+  end
+
+  test "does not try to format a directory that matches a given pattern", context do
+    in_tmp(context.test, fn ->
+      File.mkdir_p!("a.ex")
+
+      assert_raise Mix.Error, ~r"Could not find a file to format", fn ->
+        Mix.Tasks.Format.run(["*.ex"])
+      end
+    end)
+  end
+
+  test "reads file from stdin and prints to stdout", context do
+    in_tmp(context.test, fn ->
+      File.write!("a.ex", """
+      foo bar
+      """)
+
+      output =
+        capture_io("foo( )", fn ->
+          Mix.Tasks.Format.run(["a.ex", "-"])
+        end)
+
+      assert output == """
+             foo()
+             """
+
+      assert File.read!("a.ex") == """
+             foo(bar)
+             """
+    end)
+  end
+
+  test "reads file from stdin and prints to stdout with formatter", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [locals_without_parens: [foo: 1]]
+      """)
+
+      output =
+        capture_io("foo :bar", fn ->
+          Mix.Tasks.Format.run(["-"])
+        end)
+
+      assert output == """
+             foo :bar
+             """
+    end)
+  end
+
+  test "checks if file is formatted with --check-formatted", context do
+    in_tmp(context.test, fn ->
+      File.write!("a.ex", """
+      foo bar
+      """)
+
+      assert_raise Mix.Error, ~r"mix format failed due to --check-formatted", fn ->
+        Mix.Tasks.Format.run(["a.ex", "--check-formatted"])
+      end
+
+      assert File.read!("a.ex") == """
+             foo bar
+             """
+
+      assert Mix.Tasks.Format.run(["a.ex"]) == :ok
+      assert Mix.Tasks.Format.run(["a.ex", "--check-formatted"]) == :ok
+
+      assert File.read!("a.ex") == """
+             foo(bar)
+             """
+    end)
+  end
+
+  test "checks if stdin is formatted with --check-formatted" do
+    assert_raise Mix.Error, ~r"mix format failed due to --check-formatted", fn ->
+      capture_io("foo( )", fn ->
+        Mix.Tasks.Format.run(["--check-formatted", "-"])
+      end)
+    end
+
+    output =
+      capture_io("foo()\n", fn ->
+        Mix.Tasks.Format.run(["--check-formatted", "-"])
+      end)
+
+    assert output == ""
+  end
+
+  test "checks that no error is raised with --check-formatted and --no-exit" do
+    capture_io("foo( )", fn ->
+      Mix.Tasks.Format.run(["--check-formatted", "--no-exit", "-"])
+    end)
+
+    assert_received {:mix_shell, :info, ["The following files are not formatted" <> _]}
+  end
+
+  test "raises an error if --no-exit is passed without --check-formatted" do
+    assert_raise Mix.Error, ~r"--no-exit can only be used together", fn ->
+      Mix.Tasks.Format.run(["--no-exit", "-"])
+    end
+  end
+
+  test "uses inputs and configuration from .formatter.exs", context do
+    in_tmp(context.test, fn ->
+      # We need a project in order to enable caching
+      Mix.Project.push(__MODULE__.FormatWithDepsApp)
+
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["a.ex"],
+        locals_without_parens: [foo: 1]
+      ]
+      """)
+
+      File.write!("a.ex", """
+      foo bar baz
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.ex") == """
+             foo bar(baz)
+             """
+
+      File.write!(".formatter.exs", """
+      [inputs: ["a.ex"]]
+      """)
+
+      ensure_touched(".formatter.exs", "_build/dev/lib/format_with_deps/.mix/format_timestamp")
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.ex") == """
+             foo(bar(baz))
+             """
+    end)
+  end
+
+  test "does not cache inputs from .formatter.exs", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: Path.wildcard("{a,b}.ex"),
+        locals_without_parens: [foo: 1]
+      ]
+      """)
+
+      File.write!("a.ex", """
+      foo bar baz
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.ex") == """
+             foo bar(baz)
+             """
+
+      File.write!("b.ex", """
+      bar baz bat
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("b.ex") == """
+             bar(baz(bat))
+             """
+    end)
+  end
+
+  test "expands patterns in inputs from .formatter.exs", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["{a,.b}.ex"]
+      ]
+      """)
+
+      File.write!("a.ex", """
+      foo bar
+      """)
+
+      File.write!(".b.ex", """
+      foo bar
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.ex") == """
+             foo(bar)
+             """
+
+      assert File.read!(".b.ex") == """
+             foo(bar)
+             """
+    end)
+  end
+
+  test "ignores expanded patterns in excludes from .formatter.exs", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["{a,.b}.ex"],
+        excludes: [".*.{ex,exs}"]
+      ]
+      """)
+
+      File.write!("a.ex", """
+      foo bar
+      """)
+
+      File.write!(".b.ex", """
+      foo bar
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.ex") == """
+             foo(bar)
+             """
+
+      assert File.read!(".b.ex") == """
+             foo bar
+             """
+    end)
+  end
+
+  defmodule Elixir.SigilWPlugin do
+    @behaviour Mix.Tasks.Format
+
+    def features(opts) do
+      assert opts[:from_formatter_exs] == :yes
+      [sigils: [:W]]
+    end
+
+    def format(contents, opts) do
+      assert opts[:from_formatter_exs] == :yes
+      assert opts[:sigil] == :W
+      assert opts[:modifiers] == ~c"abc"
+      assert opts[:line] == 2
+      assert opts[:file] =~ ~r/\/a\.ex$/
+      contents |> String.split(~r/\s/) |> Enum.join("\n")
+    end
+  end
+
+  test "uses sigil plugins from .formatter.exs", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["a.ex"],
+        plugins: [SigilWPlugin],
+        from_formatter_exs: :yes
+      ]
+      """)
+
+      File.write!("a.ex", """
+      if true do
+        ~W'''
+        foo bar baz
+        '''abc
+      end
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.ex") == """
+             if true do
+               ~W'''
+               foo
+               bar
+               baz
+               '''abc
+             end
+             """
+
+      {formatter_function, _options} = Mix.Tasks.Format.formatter_for_file("a.ex")
+
+      assert formatter_function.("""
+             if true do
+               ~W'''
+               foo bar baz
+               '''abc
+             end
+             """) == """
+             if true do
+               ~W'''
+               foo
+               bar
+               baz
+               '''abc
+             end
+             """
+    end)
+  end
+
+  defmodule Elixir.ExtensionWPlugin do
+    @behaviour Mix.Tasks.Format
+
+    def features(opts) do
+      assert opts[:from_formatter_exs] == :yes
+      [extensions: ~w(.w), sigils: [:W]]
+    end
+
+    def format(contents, opts) do
+      assert opts[:from_formatter_exs] == :yes
+      assert opts[:extension] == ".w"
+      assert opts[:file] =~ ~r/\/a\.w$/
+      assert [W: sigil_fun] = opts[:sigils]
+      assert is_function(sigil_fun, 2)
+      contents |> String.split(~r/\s/) |> Enum.join("\n")
+    end
+  end
+
+  defmodule Elixir.NewlineToDotPlugin do
+    @behaviour Mix.Tasks.Format
+
+    def features(opts) do
+      assert opts[:from_formatter_exs] == :yes
+      [extensions: ~w(.w), sigils: [:W]]
+    end
+
+    def format(contents, opts) do
+      assert opts[:from_formatter_exs] == :yes
+
+      cond do
+        opts[:extension] ->
+          assert opts[:extension] == ".w"
+          assert opts[:file] =~ ~r/\/a\.w$/
+          assert [W: sigil_fun] = opts[:sigils]
+          assert is_function(sigil_fun, 2)
+
+        opts[:sigil] ->
+          assert opts[:sigil] == :W
+          assert opts[:inputs] == ["a.ex"]
+          assert opts[:modifiers] == ~c"abc"
+
+        true ->
+          flunk("Plugin not loading in correctly.")
+      end
+
+      contents |> String.replace("\n", ".")
+    end
+  end
+
+  test "uses extension plugins from .formatter.exs", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["a.w"],
+        plugins: [ExtensionWPlugin],
+        from_formatter_exs: :yes
+      ]
+      """)
+
+      File.write!("a.w", """
+      foo bar baz
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.w") == """
+             foo
+             bar
+             baz
+             """
+    end)
+  end
+
+  test "uses multiple plugins from .formatter.exs targeting the same file extension", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["a.w"],
+        plugins: [ExtensionWPlugin, NewlineToDotPlugin],
+        from_formatter_exs: :yes
+      ]
+      """)
+
+      File.write!("a.w", """
+      foo bar baz
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.w") == "foo.bar.baz."
+    end)
+  end
+
+  test "uses multiple plugins from .formatter.exs with the same file extension in declared order",
+       context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["a.w"],
+        plugins: [NewlineToDotPlugin, ExtensionWPlugin],
+        from_formatter_exs: :yes
+      ]
+      """)
+
+      File.write!("a.w", """
+      foo bar baz
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.w") == "foo\nbar\nbaz."
+    end)
+  end
+
+  test "uses multiple plugins from .formatter.exs targeting the same sigil", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["a.ex"],
+        plugins: [NewlineToDotPlugin, SigilWPlugin],
+        from_formatter_exs: :yes
+      ]
+      """)
+
+      File.write!("a.ex", """
+      def sigil_test(assigns) do
+        ~W"foo bar baz\n"abc
+      end
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.ex") == """
+             def sigil_test(assigns) do
+               ~W"foo\nbar\nbaz."abc
+             end
+             """
+    end)
+  end
+
+  test "uses multiple plugins from .formatter.exs with the same sigil in declared order",
+       context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["a.ex"],
+        plugins: [SigilWPlugin, NewlineToDotPlugin],
+        from_formatter_exs: :yes
+      ]
+      """)
+
+      File.write!("a.ex", """
+      def sigil_test(assigns) do
+        ~W"foo bar baz"abc
+      end
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("a.ex") == """
+             def sigil_test(assigns) do
+               ~W"foo.bar.baz"abc
+             end
+             """
+    end)
+  end
+
+  test "customizes plugin loading", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["a.ex"],
+        plugins: [UnknownPlugin],
+      ]
+      """)
+
+      File.write!("a.ex", """
+      foo bar baz
+      """)
+
+      assert_raise Mix.NoProjectError, fn ->
+        Mix.Tasks.Format.formatter_for_file("a.ex")
+      end
+
+      assert_raise Mix.Error, "Formatter plugin UnknownPlugin cannot be found", fn ->
+        Mix.Tasks.Format.formatter_for_file("a.ex", plugin_loader: fn plugins -> plugins end)
+      end
+
+      assert Mix.Tasks.Format.formatter_for_file("a.ex", plugin_loader: fn _plugins -> [] end)
+    end)
+  end
+
+  test "uses extension plugins with --stdin-filename", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        inputs: ["a.w"],
+        plugins: [ExtensionWPlugin],
+        from_formatter_exs: :yes
+      ]
+      """)
+
+      output =
+        capture_io("foo bar baz", fn ->
+          Mix.Tasks.Format.run(["--stdin-filename", Path.join(File.cwd!(), "a.w"), "-"])
+        end)
+
+      assert output ==
+               String.trim("""
+               foo
+               bar
+               baz
+               """)
+    end)
+  end
+
+  test "respects the --migrate flag", context do
+    in_tmp(context.test, fn ->
+      File.write!("a.ex", "unless foo, do: 'bar'\n")
+
+      Mix.Tasks.Format.run(["a.ex"])
+      assert File.read!("a.ex") == "unless foo, do: 'bar'\n"
+
+      Mix.Tasks.Format.run(["a.ex", "--migrate"])
+      assert File.read!("a.ex") == "if !foo, do: ~c\"bar\"\n"
+    end)
+  end
+
+  test "uses inputs and configuration from --dot-formatter", context do
+    in_tmp(context.test, fn ->
+      File.write!("custom_formatter.exs", """
+      [
+        inputs: ["a.ex"],
+        locals_without_parens: [foo: 1]
+      ]
+      """)
+
+      File.write!("a.ex", """
+      foo bar baz
+      """)
+
+      Mix.Tasks.Format.run(["--dot-formatter", "custom_formatter.exs"])
+
+      assert File.read!("a.ex") == """
+             foo bar(baz)
+             """
+    end)
+  end
+
+  test "uses inputs and configuration from :root path", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [
+        locals_without_parens: [foo: 1]
+      ]
+      """)
+
+      File.mkdir_p!("lib")
+
+      File.write!("lib/a.ex", """
+      foo bar baz
+      """)
+
+      root = File.cwd!()
+
+      {formatter_function, options} =
+        File.cd!("lib", fn ->
+          Mix.Tasks.Format.formatter_for_file("lib/a.ex", root: root)
+        end)
+
+      assert formatter_function.("""
+             foo bar baz
+             """) == """
+             foo bar(baz)
+             """
+
+      assert options[:root] == root
+    end)
+  end
+
+  test "reads exported configuration from subdirectories", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [subdirectories: ["li", "lib"]]
+      """)
+
+      # We also create a directory called li to ensure files
+      # from lib won't accidentally match on li.
+      File.mkdir_p!("li")
+      File.mkdir_p!("lib")
+
+      File.write!("li/.formatter.exs", """
+      [inputs: "**/*", locals_without_parens: [other_fun: 2]]
+      """)
+
+      File.write!("lib/.formatter.exs", """
+      [inputs: "a.ex", locals_without_parens: [my_fun: 2]]
+      """)
+
+      # Should hit the formatter
+      {formatter, formatter_opts} = Mix.Tasks.Format.formatter_for_file("lib/extra/a.ex")
+      assert formatter_opts[:root] == Path.expand("lib")
+      assert formatter_opts[:locals_without_parens] == [my_fun: 2]
+      assert formatter.("my_fun 1, 2") == "my_fun 1, 2\n"
+
+      # Another directory should not hit the formatter
+      {formatter, formatter_opts} = Mix.Tasks.Format.formatter_for_file("test/a.ex")
+      assert formatter_opts[:root] == Path.expand(".")
+      assert formatter_opts[:locals_without_parens] == []
+      assert formatter.("my_fun 1, 2") == "my_fun(1, 2)\n"
+
+      File.write!("lib/a.ex", """
+      my_fun :foo, :bar
+      other_fun :baz
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("lib/a.ex") == """
+             my_fun :foo, :bar
+             other_fun(:baz)
+             """
+
+      Mix.Tasks.Format.run(["lib/a.ex"])
+
+      assert File.read!("lib/a.ex") == """
+             my_fun :foo, :bar
+             other_fun(:baz)
+             """
+
+      # No caching without a project
+      manifest_path = Path.join(Mix.Project.manifest_path(), "cached_dot_formatter")
+      refute File.regular?(manifest_path)
+
+      # Caching with a project
+      Mix.Project.push(__MODULE__.FormatWithDepsApp)
+      Mix.Tasks.Format.run(["lib/a.ex"])
+      manifest_path = Path.join(Mix.Project.manifest_path(), "cached_dot_formatter")
+      assert File.regular?(manifest_path)
+
+      # Let's check that the manifest gets updated if it's stale.
+      File.touch!(manifest_path, {{2010, 1, 1}, {0, 0, 0}})
+
+      Mix.Tasks.Format.run(["lib/a.ex"])
+      assert File.stat!(manifest_path).mtime > {{2010, 1, 1}, {0, 0, 0}}
+    end)
+  end
+
+  test "reads exported configuration from dependencies", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(__MODULE__.FormatWithDepsApp)
+
+      File.write!(".formatter.exs", """
+      [import_deps: [:my_dep]]
+      """)
+
+      File.write!("a.ex", """
+      my_fun :foo, :bar
+      """)
+
+      File.mkdir_p!("deps/my_dep/")
+
+      File.write!("deps/my_dep/.formatter.exs", """
+      [export: [locals_without_parens: [my_fun: 2]]]
+      """)
+
+      Mix.Tasks.Format.run(["a.ex"])
+
+      assert File.read!("a.ex") == """
+             my_fun :foo, :bar
+             """
+
+      manifest_path = Path.join(Mix.Project.manifest_path(), "cached_dot_formatter")
+      assert File.regular?(manifest_path)
+
+      # Let's check that the manifest gets updated if it's stale.
+      File.touch!(manifest_path, {{2010, 1, 1}, {0, 0, 0}})
+
+      {_, formatter_opts} = Mix.Tasks.Format.formatter_for_file("a.ex")
+      assert [my_fun: 2] = formatter_opts[:locals_without_parens]
+
+      # Check the deps_path option is respected
+      assert_raise Mix.Error, ~r"Unknown dependency :my_dep given to :import_deps", fn ->
+        # Let's check that the manifest gets updated if it's stale.
+        File.touch!(manifest_path, {{2010, 1, 1}, {0, 0, 0}})
+        Mix.Tasks.Format.formatter_for_file("a.ex", deps_paths: %{})
+      end
+
+      Mix.Tasks.Format.run(["a.ex"])
+      assert File.stat!(manifest_path).mtime > {{2010, 1, 1}, {0, 0, 0}}
+    end)
+  end
+
+  test "reads exported configuration from dependencies and subdirectories", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(__MODULE__.FormatWithDepsApp)
+      format_timestamp = "_build/dev/lib/format_with_deps/.mix/format_timestamp"
+
+      File.mkdir_p!("deps/my_dep/")
+
+      File.write!("deps/my_dep/.formatter.exs", """
+      [export: [locals_without_parens: [my_fun: 2]]]
+      """)
+
+      File.mkdir_p!("lib/sub")
+      File.mkdir_p!("lib/not_used_and_wont_raise")
+
+      File.write!(".formatter.exs", """
+      [subdirectories: ["lib"]]
+      """)
+
+      File.write!("lib/.formatter.exs", """
+      [subdirectories: ["*"]]
+      """)
+
+      File.write!("lib/sub/.formatter.exs", """
+      [inputs: "a.ex", import_deps: [:my_dep]]
+      """)
+
+      File.write!("lib/sub/a.ex", """
+      my_fun :foo, :bar
+      other_fun :baz
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("lib/sub/a.ex") == """
+             my_fun :foo, :bar
+             other_fun(:baz)
+             """
+
+      Mix.Tasks.Format.run(["lib/sub/a.ex"])
+
+      assert File.read!("lib/sub/a.ex") == """
+             my_fun :foo, :bar
+             other_fun(:baz)
+             """
+
+      # Update .formatter.exs, check that file is updated
+      File.write!("lib/sub/.formatter.exs", """
+      [inputs: "a.ex"]
+      """)
+
+      File.touch!("lib/sub/.formatter.exs", {{2038, 1, 1}, {0, 0, 0}})
+      File.touch!(format_timestamp, {{2010, 1, 1}, {0, 0, 0}})
+
+      Mix.Tasks.Format.run([])
+
+      assert File.read!("lib/sub/a.ex") == """
+             my_fun(:foo, :bar)
+             other_fun(:baz)
+             """
+
+      # Add a new entry to "lib" and it also gets picked.
+      File.mkdir_p!("lib/extra")
+
+      File.write!("lib/extra/.formatter.exs", """
+      [inputs: "a.ex", locals_without_parens: [other_fun: 1]]
+      """)
+
+      File.write!("lib/extra/a.ex", """
+      my_fun :foo, :bar
+      other_fun :baz
+      """)
+
+      File.touch!("lib/extra/.formatter.exs", {{2038, 1, 1}, {0, 0, 0}})
+      File.touch!(format_timestamp, {{2010, 1, 1}, {0, 0, 0}})
+
+      Mix.Tasks.Format.run([])
+
+      {_, formatter_opts} = Mix.Tasks.Format.formatter_for_file("lib/extra/a.ex")
+      assert formatter_opts[:root] == Path.expand("lib/extra")
+      assert formatter_opts[:locals_without_parens] == [other_fun: 1]
+
+      assert File.read!("lib/extra/a.ex") == """
+             my_fun(:foo, :bar)
+             other_fun :baz
+             """
+    end)
+  end
+
+  test "validates subdirectories in :subdirectories", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [subdirectories: "oops"]
+      """)
+
+      message = "Expected :subdirectories to return a list of directories, got: \"oops\""
+      assert_raise Mix.Error, message, fn -> Mix.Tasks.Format.run([]) end
+
+      File.write!(".formatter.exs", """
+      [subdirectories: ["lib"]]
+      """)
+
+      File.mkdir_p!("lib")
+
+      File.write!("lib/.formatter.exs", """
+      []
+      """)
+
+      message = "Expected :inputs or :subdirectories key in #{Path.expand("lib/.formatter.exs")}"
+      assert_raise Mix.Error, message, fn -> Mix.Tasks.Format.run([]) end
+    end)
+  end
+
+  test "validates dependencies in :import_deps", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(__MODULE__.FormatWithDepsApp)
+
+      File.write!(".formatter.exs", """
+      [import_deps: [:my_dep]]
+      """)
+
+      message =
+        ~r"Unknown dependency :my_dep given to :import_deps in the formatter configuration"
+
+      assert_raise Mix.Error, message, fn -> Mix.Tasks.Format.run([]) end
+
+      File.write!(".formatter.exs", """
+      [import_deps: [:nonexistent_dep]]
+      """)
+
+      message =
+        ~r"Unknown dependency :nonexistent_dep given to :import_deps in the formatter configuration"
+
+      assert_raise Mix.Error, message, fn -> Mix.Tasks.Format.run([]) end
+    end)
+  end
+
+  test "prints an error on conflicting .formatter.exs files", context do
+    in_tmp(context.test, fn ->
+      File.write!(".formatter.exs", """
+      [inputs: "lib/**/*.{ex,exs}", subdirectories: ["lib", "foo"]]
+      """)
+
+      File.mkdir_p!("lib")
+
+      File.write!("lib/.formatter.exs", """
+      [inputs: "a.ex", locals_without_parens: [my_fun: 2]]
+      """)
+
+      File.mkdir_p!("foo")
+
+      File.write!("foo/.formatter.exs", """
+      [inputs: "../lib/a.ex", locals_without_parens: [my_fun: 2]]
+      """)
+
+      File.write!("lib/a.ex", """
+      my_fun :foo, :bar
+      other_fun :baz
+      """)
+
+      Mix.Tasks.Format.run([])
+
+      message1 =
+        "Both .formatter.exs and #{Path.expand("lib/.formatter.exs")} specify the file " <>
+          "#{Path.expand("lib/a.ex")} in their :inputs option. To resolve the conflict, " <>
+          "the configuration in .formatter.exs will be ignored. Please change the list of " <>
+          ":inputs in one of the formatter files so only one of them matches #{Path.expand("lib/a.ex")}"
+
+      message2 =
+        "Both #{Path.expand("lib/.formatter.exs")} and #{Path.expand("foo/.formatter.exs")} " <>
+          "specify the file #{Path.expand("lib/a.ex")} in their :inputs option. To resolve " <>
+          "the conflict, the configuration in #{Path.expand("lib/.formatter.exs")} " <>
+          "will be ignored. Please change the list of :inputs in one of the formatter files " <>
+          "so only one of them matches #{Path.expand("lib/a.ex")}"
+
+      assert_received {:mix_shell, :error, [^message1]}
+      assert_received {:mix_shell, :error, [^message2]}
+    end)
+  end
+
+  test "raises on invalid arguments", context do
+    in_tmp(context.test, fn ->
+      assert_raise Mix.Error, ~r"Expected one or more files\/patterns to be given", fn ->
+        Mix.Tasks.Format.run([])
+      end
+
+      assert_raise Mix.Error, ~r"Could not find a file to format", fn ->
+        Mix.Tasks.Format.run(["unknown.whatever"])
+      end
+    end)
+  end
+
+  test "raises SyntaxError when parsing invalid source file", context do
+    in_tmp(context.test, fn ->
+      File.write!("a.ex", """
+      defmodule <%= module %>.Bar do end
+      """)
+
+      messages = [
+        "invalid syntax found on a.ex:1:13:",
+        "defmodule <%= module %>.Bar do end",
+        "^",
+        "syntax error before: '='"
+      ]
+
+      e =
+        assert_raise SyntaxError, fn ->
+          Mix.Tasks.Format.run(["a.ex"])
+        end
+
+      output = Exception.format(:error, e, [])
+
+      for msg <- messages do
+        assert output =~ msg
+      end
+
+      assert_received {:mix_shell, :error, ["mix format failed for file: a.ex"]}
+    end)
+  end
+
+  test "raises SyntaxError when parsing invalid stdin", context do
+    in_tmp(context.test, fn ->
+      e =
+        assert_raise SyntaxError, fn ->
+          capture_io("defmodule <%= module %>.Bar do end", fn ->
+            Mix.Tasks.Format.run(["-"])
+          end)
+        end
+
+      messages = [
+        "invalid syntax found on stdin.exs:1:13:",
+        "defmodule <%= module %>.Bar do end",
+        "^",
+        "syntax error before: '='"
+      ]
+
+      output = Exception.format(:error, e, [])
+
+      for msg <- messages do
+        assert output =~ msg
+      end
+
+      assert_received {:mix_shell, :error, ["mix format failed for stdin"]}
+    end)
+  end
+
+  describe "text_diff_format/3" do
+    defp text_diff_format(old, new, opts \\ []) do
+      Mix.Tasks.Format.text_diff_format(old, new, opts) |> IO.iodata_to_binary()
+    end
+
+    test "with unchanged texts" do
+      assert text_diff_format("abc", "abc") == ""
+    end
+
+    test "with one deleted line" do
+      old = "del"
+      new = ""
+
+      assert output = text_diff_format(old, new)
+
+      if IO.ANSI.enabled?() do
+        assert output == "1  \e[31m -\e[0m|\e[31mdel\e[0m\n  1\e[32m +\e[0m|\n"
+      end
+
+      assert text_diff_format(old, new, color: false) == """
+             1   -|del
+               1 +|
+             """
+    end
+
+    test "with one changed line" do
+      old = "one three two"
+      new = "one two three"
+
+      assert output = text_diff_format(old, new)
+
+      if IO.ANSI.enabled?() do
+        assert output ==
+                 """
+                 1  \e[31m -\e[0m|one three\e[31m\e[0m\e[41m \e[0m\e[31mtwo\e[0m
+                   1\e[32m +\e[0m|one t\e[32mwo\e[0m\e[42m \e[0m\e[32mt\e[0mhree
+                 """
+      end
+
+      assert text_diff_format(old, new, color: false) == """
+             1   -|one three two
+               1 +|one two three
+             """
+    end
+
+    test "with one deleted line in the middle" do
+      old = """
+      aaa
+      bbb
+      ccc
+      ddd
+      eee
+      fff
+      ggg
+      """
+
+      new = """
+      aaa
+      bbb
+      ccc
+      eee
+      fff
+      ggg
+      """
+
+      exp = """
+           |
+      2 2  |bbb
+      3 3  |ccc
+      4   -|ddd
+      5 4  |eee
+      6 5  |fff
+           |
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false) == exp
+    end
+
+    test "with multiple deleted lines" do
+      old = """
+      aaa
+      bbb
+      ccc
+      ddd
+      eee
+      fff
+      ggg\
+      """
+
+      new = """
+      aaa
+      ggg\
+      """
+
+      exp = """
+      1 1  |aaa
+      2   -|bbb
+      3   -|ccc
+      4   -|ddd
+      5   -|eee
+      6   -|fff
+      7 2  |ggg
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false) == exp
+    end
+
+    test "with one added line in the middle" do
+      old = """
+      aaa
+      bbb
+      ccc
+      eee
+      fff
+      ggg
+      """
+
+      new = """
+      aaa
+      bbb
+      ccc
+      ddd
+      eee
+      fff
+      ggg
+      """
+
+      exp = """
+           |
+      2 2  |bbb
+      3 3  |ccc
+        4 +|ddd
+      4 5  |eee
+      5 6  |fff
+           |
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false) == exp
+    end
+
+    test "with changed first line" do
+      old = """
+      aaa
+      bbb
+      ccc
+      ddd
+      """
+
+      new = """
+      axa
+      bbb
+      ccc
+      ddd
+      """
+
+      exp = """
+      1   -|aaa
+        1 +|axa
+      2 2  |bbb
+      3 3  |ccc
+           |
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false) == exp
+    end
+
+    test "with changed last line" do
+      old = """
+      aaa
+      bbb
+      ccc
+      ddd
+      """
+
+      new = """
+      aaa
+      bbb
+      ccc
+      dxd
+      """
+
+      exp = """
+           |
+      2 2  |bbb
+      3 3  |ccc
+      4   -|ddd
+        4 +|dxd
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false) == exp
+    end
+
+    test "with changed first and last line" do
+      old = """
+      aaa
+      bbb
+      ccc
+      ddd
+      eee
+      """
+
+      new = """
+      axa
+      bbb
+      ccc
+      ddd
+      exe
+      """
+
+      exp = """
+      1   -|aaa
+        1 +|axa
+      2 2  |bbb
+           |
+      4 4  |ddd
+      5   -|eee
+        5 +|exe
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false, before: 1, after: 1) == exp
+    end
+
+    test "with changed second and second last line" do
+      old = """
+      aaa
+      bbb
+      ccc
+      ddd
+      eee
+      fff
+      ggg
+      hhh
+      iii\
+      """
+
+      new = """
+      aaa
+      bXb
+      ccc
+      ddd
+      eee
+      fff
+      ggg
+      hXh
+      iii\
+      """
+
+      exp = """
+      1 1  |aaa
+      2   -|bbb
+        2 +|bXb
+      3 3  |ccc
+           |
+      7 7  |ggg
+      8   -|hhh
+        8 +|hXh
+      9 9  |iii
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false, before: 1, after: 1) == exp
+    end
+
+    test "colorized added tab" do
+      assert output = text_diff_format("ab", "a\tb")
+
+      if IO.ANSI.enabled?() do
+        assert output =~ "\e[42m\t"
+      end
+    end
+
+    test "colorized deleted tab" do
+      assert output = text_diff_format("a\tb", "ab")
+
+      if IO.ANSI.enabled?() do
+        assert output =~ "\e[41m\t"
+      end
+    end
+
+    test "shows added CR" do
+      old = """
+      aaa
+      bbb
+      """
+
+      new = """
+      aaa\r
+      bbb
+      """
+
+      exp = """
+      1   -|aaa
+        1 +|aaa↵
+      2 2  |bbb
+           |
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false, before: 1, after: 1) == exp
+    end
+
+    test "shows multiple added CRs" do
+      old = """
+      aaa
+      bbb
+      """
+
+      new = """
+      aaa\r
+      bbb\r
+      ccc\r
+      """
+
+      exp = """
+      1   -|aaa
+      2   -|bbb
+        1 +|aaa↵
+        2 +|bbb↵
+        3 +|ccc\r
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false, before: 1, after: 1) == exp
+    end
+
+    test "shows deleted CR" do
+      old = """
+      aaa\r
+      bbb
+      """
+
+      new = """
+      aaa
+      bbb
+      """
+
+      exp = """
+      1   -|aaa↵
+        1 +|aaa
+      2 2  |bbb
+           |
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false, before: 1, after: 1) == exp
+    end
+
+    test "shows multiple deleted CRs" do
+      old = """
+      aaa\r
+      bbb\r
+      """
+
+      new = """
+      aaa
+      bbb
+      ccc
+      """
+
+      exp = """
+      1   -|aaa↵
+      2   -|bbb↵
+        1 +|aaa
+        2 +|bbb
+        3 +|ccc
+      """
+
+      assert text_diff_format(old, new)
+      assert text_diff_format(old, new, color: false) == exp
+    end
+  end
+end
diff --git a/lib/mix/test/mix/tasks/help_test.exs b/lib/mix/test/mix/tasks/help_test.exs
index d11758029c6..3e010ec784e 100644
--- a/lib/mix/test/mix/tasks/help_test.exs
+++ b/lib/mix/test/mix/tasks/help_test.exs
@@ -1,54 +1,388 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.HelpTest do
   use MixTest.Case
 
   import ExUnit.CaptureIO
 
-  test "help lists all tasks" do
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Help.run []
+  test "help lists all tasks", context do
+    in_tmp(context.test, fn ->
+      Mix.Tasks.Help.run([])
       assert_received {:mix_shell, :info, ["mix" <> _]}
       assert_received {:mix_shell, :info, ["mix help" <> _]}
       assert_received {:mix_shell, :info, ["mix compile" <> _]}
-    end
+    end)
   end
 
-  test "help list default task" do
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Help.run []
+  test "help list default task", context do
+    in_tmp(context.test, fn ->
+      Mix.Tasks.Help.run([])
+
+      assert_received {:mix_shell, :info, [output]}
+      assert output =~ ~r/^mix\s+# Runs the default task \(current: \"mix run\"\)/m
+    end)
+  end
 
-      {_, _, [output]} =
-        assert_received {:mix_shell, :info, [_]}
-      assert output =~ ~r/^mix\s+# Run the default task \(current: mix run\)/m
+  defmodule Aliases do
+    def project do
+      [aliases: [h: "hello", c: "compile"]]
     end
   end
 
-  test "help --names" do
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Help.run ["--names"]
+  test "help --names", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(Aliases)
+
+      Mix.Tasks.Help.run(["--names"])
+      assert_received {:mix_shell, :info, ["c"]}
       assert_received {:mix_shell, :info, ["compile"]}
+      assert_received {:mix_shell, :info, ["h"]}
       assert_received {:mix_shell, :info, ["help"]}
-      assert_received {:mix_shell, :info, ["escriptize"]}
+      assert_received {:mix_shell, :info, ["escript.build"]}
+      refute_received {:mix_shell, :info, ["compile.all"]}
+    end)
+  end
+
+  defmodule ComplexAliases do
+    def project do
+      [
+        aliases: [
+          h: "hello",
+          p: &inspect/1,
+          foo: &foo/1,
+          bar: fn _ -> :ok end,
+          help: ["help", "hello"],
+          "nested.h": [&Mix.shell().info(inspect(&1)), "h foo bar"],
+          other: [
+            "format --check-formatted",
+            fn _ -> :ok end,
+            &foo/1,
+            "help"
+          ]
+        ]
+      ]
     end
+
+    defp foo(_), do: :ok
   end
 
-  test "help TASK" do
-    in_fixture "no_mixfile", fn ->
+  test "help lists all aliases", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(ComplexAliases)
+
+      Mix.Tasks.Help.run([])
+
+      assert_received {:mix_shell, :info, ["mix h" <> message]}
+      assert message =~ ~r/# Alias for hello/
+
+      assert_received {:mix_shell, :info, ["mix p" <> message]}
+      assert message =~ ~r/# Alias for &inspect\/1/
+
+      assert_received {:mix_shell, :info, ["mix foo" <> message]}
+      assert message =~ ~r/# Alias for &foo\/1/
+
+      assert_received {:mix_shell, :info, ["mix bar" <> message]}
+      assert message =~ ~r/# Alias for a function/
+
+      assert_received {:mix_shell, :info, ["mix help" <> message]}
+      assert message =~ ~r/# Alias for help, hello/
+
+      assert_received {:mix_shell, :info, ["mix nested.h" <> message]}
+      assert message =~ ~r/# Alias for a function, h foo bar/
+
+      assert_received {:mix_shell, :info, ["mix other" <> message]}
+      assert message =~ ~r/# Alias for format --check-formatted, a function, &foo\/1, help/
+    end)
+  end
+
+  test "help ALIAS", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(ComplexAliases)
+
       output =
-        capture_io fn ->
-          Mix.Tasks.Help.run ["compile"]
-        end
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["h"])
+        end)
+
+      assert output =~ "mix h\n\n"
+      assert output =~ "Alias for\n\n"
+      assert output =~ "    \"hello\"\n"
+      assert output =~ ~r/^Location: mix.exs/m
+
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["p"])
+        end)
+
+      assert output =~ "mix p\n\n"
+      assert output =~ "Alias for\n\n"
+      assert output =~ "    &Kernel.inspect/1\n"
+      assert output =~ ~r/^Location: mix.exs/m
+
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["help"])
+        end)
+
+      assert output =~ "mix help\n\n"
+      assert output =~ "Alias for\n\n"
+      assert output =~ "    [\"help\",\n"
+      assert output =~ "    \"hello\"]\n"
+      assert output =~ ~r/^Location: mix.exs/m
+
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["nested.h"])
+        end)
+
+      assert output =~ "mix nested.h\n\n"
+      assert output =~ "Alias for\n\n"
+      assert output =~ ~r/    \[#Function/
+      assert output =~ ~r/^Location: mix.exs/m
+    end)
+  end
+
+  test "help TASK", context do
+    in_tmp(context.test, fn ->
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["compile"])
+        end)
+
+      assert output =~ "mix compile\n"
+      assert output =~ "## Command line options"
+      assert output =~ ~r/^Location:/m
+
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["compile.all"])
+        end)
+
+      assert output =~ "mix compile.all\n"
+      assert output =~ "There is no documentation for this task"
+    end)
+  end
+
+  defmodule ShadowedAliases do
+    def project do
+      [aliases: [compile: "compile"]]
+    end
+  end
+
+  test "help TASK && ALIAS", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(ShadowedAliases)
+
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["compile"])
+        end)
+
+      assert output =~ "mix compile\n\n"
+      assert output =~ "Alias for\n\n"
+      assert output =~ "\"compile\"\n"
+      assert output =~ ~r/^Location: mix.exs/m
+
+      assert output =~
+               "\nThere is also a task named \"compile\". The documentation is shown next.\n"
 
-      assert output =~ "# mix compile"
       assert output =~ "## Command line options"
       assert output =~ ~r/^Location:/m
+    end)
+  end
+
+  test "help app:APP", context do
+    in_tmp(context.test, fn ->
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["app:iex"])
+        end)
+
+      assert output =~ "# IEx\n\nElixir's interactive shell."
+
+      if System.otp_release() >= "27" do
+        output =
+          capture_io(fn ->
+            Mix.Tasks.Help.run(["app:parsetools"])
+          end)
+
+        assert output =~ "# :leex"
+      end
+    end)
+  end
+
+  test "help app:UNKNOWN", context do
+    in_tmp(context.test, fn ->
+      Mix.Tasks.Help.run(["app:foobar"])
+      assert_received {:mix_shell, :error, ["Application foobar does not exist or is not loaded"]}
+    end)
+  end
+
+  test "help app:APP for current project", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+      File.mkdir_p!("lib")
+
+      File.write!("lib/example.ex", ~s'''
+      defmodule Example do
+        @moduledoc """
+        This is an example module.
+        """
+      end
+      ''')
+
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["app:sample"])
+        end)
+
+      assert output =~ """
+             # Example
+
+             This is an example module.
+             """
+    end)
+  after
+    purge([Example])
+  end
+
+  test "help Elixir MODULE", context do
+    in_tmp(context.test, fn ->
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["Mix"])
+        end)
+
+      assert output =~
+               "Mix is a build tool that provides tasks for creating, compiling, and testing\nElixir projects, managing its dependencies, and more."
+    end)
+  end
+
+  test "help Elixir NESTED MODULE", context do
+    in_tmp(context.test, fn ->
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["IO.ANSI"])
+        end)
+
+      assert output =~ "Functionality to render ANSI escape sequences."
+    end)
+  end
+
+  test "help Erlang MODULE", context do
+    otp_docs? = match?({:docs_v1, _, _, _, _, _, _}, Code.fetch_docs(:math))
+
+    in_tmp(context.test, fn ->
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run([":math"])
+        end)
+
+      if otp_docs? do
+        assert output =~
+                 "This module provides an interface to a number of mathematical"
+      else
+        assert output =~ ":math was not compiled with docs"
+      end
+    end)
+  end
+
+  test "help FUNCTION/0", context do
+    in_tmp(context.test, fn ->
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["DateTime.utc_now()"])
+        end)
+
+      assert output =~ "Returns the current datetime in UTC"
+    end)
+  end
+
+  test "help FUNCTION/1", context do
+    in_tmp(context.test, fn ->
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["Enum.all?/1"])
+        end)
+
+      assert output =~ "Returns `true` if all elements in `enumerable` are truthy."
+    end)
+  end
+
+  test "help NESTED MODULE FUNCTION/3", context do
+    in_tmp(context.test, fn ->
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["IO.ANSI.color/3"])
+        end)
+
+      assert output =~ "Sets the foreground color from individual RGB values"
+    end)
+  end
+
+  test "help ERROR" do
+    assert_raise Mix.Error, "Invalid expression: Foo.bar(~s[baz])", fn ->
+      Mix.Tasks.Help.run(["Foo.bar(~s[baz])"])
+    end
+  end
+
+  test "help --search PATTERN", context do
+    in_tmp(context.test, fn ->
+      Mix.Tasks.Help.run(["--search", "deps"])
+      assert_received {:mix_shell, :info, ["mix deps" <> _]}
+      assert_received {:mix_shell, :info, ["mix deps.clean" <> _]}
+    end)
+
+    in_tmp(context.test, fn ->
+      Mix.Project.push(Aliases)
+
+      Mix.Tasks.Help.run(["--search", "h"])
+      assert_received {:mix_shell, :info, ["mix h" <> message]}
+      assert message =~ ~r/# Alias for hello/
+    end)
+  end
+
+  test "help --search without pattern" do
+    assert_raise Mix.Error, "Unexpected arguments, expected \"mix help --search PATTERN\"", fn ->
+      Mix.Tasks.Help.run(["--search"])
     end
   end
 
+  test "help --search without results", context do
+    in_tmp(context.test, fn ->
+      output =
+        capture_io(fn ->
+          Mix.Tasks.Help.run(["--search", "foo"])
+        end)
+
+      assert output == ""
+    end)
+  end
+
+  test "help --aliases", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(Aliases)
+
+      Mix.Tasks.Help.run(["--aliases"])
+      assert_received {:mix_shell, :info, ["mix h" <> message]}
+      assert message =~ ~r/# Alias for hello/
+
+      assert_received {:mix_shell, :info, ["mix c" <> message]}
+      assert message =~ ~r/# Alias for compile/
+
+      refute_received {:mix_shell, :info, ["mix deps" <> _]}
+    end)
+  end
+
   test "bad arguments" do
-    assert_raise Mix.Error, "Unexpected arguments, expected `mix help` or `mix help TASK`", fn ->
-      Mix.Tasks.Help.run ["foo", "bar"]
+    message = "Unexpected arguments, expected \"mix help\" or \"mix help TASK\""
+
+    assert_raise Mix.Error, message, fn ->
+      Mix.Tasks.Help.run(["foo", "bar"])
     end
   end
 end
diff --git a/lib/mix/test/mix/tasks/iex_test.exs b/lib/mix/test/mix/tasks/iex_test.exs
index d63a6c612cf..10b5c589f3d 100644
--- a/lib/mix/test/mix/tasks/iex_test.exs
+++ b/lib/mix/test/mix/tasks/iex_test.exs
@@ -1,14 +1,19 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
 
-defmodule Mix.Tasks.IexTest do
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.IExTest do
   use MixTest.Case, async: true
 
-  test "raises error message about correct usage" do
-    in_fixture "no_mixfile", fn ->
-      msg = "To use IEx with Mix, please run: iex -S mix"
+  test "raises error message about correct usage", context do
+    in_tmp(context.test, fn ->
+      msg = "To use IEx with Mix, please run \"iex -S mix\""
+
       assert_raise Mix.Error, msg, fn ->
-        Mix.Tasks.Iex.run []
+        Mix.Tasks.Iex.run([])
       end
-    end
+    end)
   end
 end
diff --git a/lib/mix/test/mix/tasks/loadconfig_test.exs b/lib/mix/test/mix/tasks/loadconfig_test.exs
index 43186703e98..715bfc62238 100644
--- a/lib/mix/test/mix/tasks/loadconfig_test.exs
+++ b/lib/mix/test/mix/tasks/loadconfig_test.exs
@@ -1,46 +1,100 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.LoadconfigTest do
   use MixTest.Case
 
-  @apps [:my_app, :other_app]
-
-  setup do
-    on_exit fn ->
-      Enum.each @apps, fn app ->
-        Enum.each Application.get_all_env(app), fn {key, _} ->
-          Application.delete_env(app, key, persistent: true)
-        end
-      end
-    end
-    :ok
-  end
-
-  test "reads and persists project configuration" do
-    Mix.Project.push MixTest.Case.Sample
+  test "reads and persists project configuration", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
 
-    in_fixture "no_mixfile", fn ->
-      write_config """
+      write_config("""
       [my_app: [key: :project]]
-      """
+      """)
 
       assert Application.fetch_env(:my_app, :key) == :error
-      Mix.Task.run "loadconfig", []
+      Mix.Task.run("loadconfig", [])
       assert Application.fetch_env(:my_app, :key) == {:ok, :project}
 
       # App configuration should have lower precedence
-      :ok = :application.load({:application, :my_app, [vsn: '1.0.0', env: [key: :app]]})
+      :ok = :application.load({:application, :my_app, [vsn: ~c"1.0.0", env: [key: :app]]})
       assert Application.fetch_env(:my_app, :key) == {:ok, :project}
 
-      # laodconfig can be called multiple times
+      # loadconfig can be called multiple times
       # Later values should have higher precedence
-      Mix.Task.run "loadconfig", [fixture_path("configs/good_config.exs")]
+      Mix.Task.run("loadconfig", [fixture_path("config.exs")])
       assert Application.fetch_env(:my_app, :key) == {:ok, :value}
-    end
+    end)
+  end
+
+  test "sets config_env() and config_target()", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      write_config("""
+      import Config
+      config :opts_app, :key, {config_env(), config_target()}
+      """)
+
+      assert Application.fetch_env(:opts_app, :key) == :error
+      Mix.Task.run("loadconfig", [])
+      assert Application.fetch_env(:opts_app, :key) == {:ok, {:dev, :host}}
+    end)
+  end
+
+  test "reads from custom config_path", context do
+    Mix.ProjectStack.post_config(config_path: "fresh.config")
+
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      write_config("fresh.config", """
+      [config_app: [key: :value]]
+      """)
+
+      assert Application.fetch_env(:config_app, :key) == :error
+      Mix.Task.run("loadconfig", [])
+      assert Application.fetch_env(:config_app, :key) == {:ok, :value}
+
+      File.rm("fresh.config")
+
+      assert_raise File.Error, ~r"could not read file .*/fresh\.config", fn ->
+        Mix.Task.run("loadconfig", [])
+      end
+    end)
+  end
+
+  test "is a no-op with nil custom config_path" do
+    Mix.ProjectStack.post_config(config_path: nil)
+    assert Mix.Task.run("loadconfig", []) == []
+  end
+
+  test "updates config files and config mtime", context do
+    in_tmp(context.test, fn ->
+      Mix.Project.push(MixTest.Case.Sample)
+
+      mtime = Mix.Project.config_mtime()
+      config = Path.expand("config/config.exs")
+      refute config in Mix.Project.config_files()
+
+      write_config(config, "[]")
+      Mix.Task.run("loadconfig", [config])
+      assert config in Mix.Project.config_files()
+      assert Mix.Project.config_mtime() > mtime
+
+      # Touching it should not have any deadlocks
+      File.touch!(config, {{2038, 1, 1}, {0, 0, 0}})
+      Mix.Task.run("loadconfig", [config])
+      assert config in Mix.Project.config_files()
+      assert Mix.Project.config_mtime() > mtime
+    end)
   end
 
   defp write_config(path \\ "config/config.exs", contents) do
-    File.mkdir_p! Path.dirname(path)
-    File.write! path, contents
+    File.mkdir_p!(Path.dirname(path))
+    File.write!(path, contents)
   end
 end
diff --git a/lib/mix/test/mix/tasks/local_test.exs b/lib/mix/test/mix/tasks/local_test.exs
index b10d2c4c050..8171af14fc9 100644
--- a/lib/mix/test/mix/tasks/local_test.exs
+++ b/lib/mix/test/mix/tasks/local_test.exs
@@ -1,86 +1,29 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.LocalTest do
   use MixTest.Case
 
-  defmodule ArchiveProject do
-    def project do
-      [ app: :archive, version: "0.1.0" ]
-    end
-  end
-
-  defmodule ArchiveProject2 do
-    def project do
-      [ app: :archive, version: "0.2.0" ]
-    end
-  end
-
-  test "archive" do
-    File.rm_rf! tmp_path("userhome")
-    System.put_env "MIX_HOME", tmp_path("userhome/.mix")
-    Mix.Project.push(ArchiveProject)
-
-    in_fixture "archive", fn() ->
-      # Install it!
-      Mix.Tasks.Archive.run []
-      assert File.regular? "archive-0.1.0.ez"
-
-      send self, {:mix_shell_input, :yes?, true}
-      Mix.Tasks.Local.Install.run []
-      assert File.regular? tmp_path("userhome/.mix/archives/archive-0.1.0.ez")
-
-      archive = tmp_path("userhome/.mix/archives/archive-0.1.0.ez/archive-0.1.0/ebin")
-      assert to_char_list(archive) in :code.get_path
-
-      # List it!
-      Mix.Local.append_archives
-      Mix.Tasks.Local.run []
-      assert_received {:mix_shell, :info, ["mix local.sample # A local install sample"]}
-
-      # Run it!
-      Mix.Task.run "local.sample"
-      assert_received {:mix_shell, :info, ["sample"]}
-
-      # Install new version!
-      Mix.Project.push(ArchiveProject2)
-      Mix.Tasks.Archive.run ["--no_compile"]
-      assert File.regular? "archive-0.2.0.ez"
-
-      send self, {:mix_shell_input, :yes?, true}
-      Mix.Tasks.Local.Install.run []
-      assert File.regular? tmp_path("userhome/.mix/archives/archive-0.2.0.ez")
-
-      # We don't do the assertion below on Windows because
-      # the archive is open by Erlang code server and the archive
-      # is not effectively removed until the Erlang process exits.
-      unless match? {:win32, _}, :os.type do
-        refute File.regular? tmp_path("userhome/.mix/archives/archive-0.1.0.ez")
-      end
-
-      Mix.Local.append_archives
-
-      # Remove it!
-      send self, {:mix_shell_input, :yes?, true}
-      Mix.Tasks.Local.Uninstall.run ["archive"]
-      refute File.regular? tmp_path("userhome/.mix/archives/archive-0.2.0.ez")
-    end
-  end
-
   test "MIX_PATH" do
-    File.rm_rf! tmp_path("mixpath")
-    System.put_env "MIX_PATH", tmp_path("mixpath/ebin")
+    File.rm_rf!(tmp_path("mixpath"))
+    System.put_env("MIX_PATH", tmp_path("mixpath/ebin"))
 
-    File.mkdir_p! tmp_path("mixpath/ebin")
-    Mix.Local.append_paths
+    File.mkdir_p!(tmp_path("mixpath/ebin"))
+    Mix.Local.append_paths()
 
     # Install on MIX_PATH manually
-    File.copy! fixture_path("archive/ebin/Elixir.Mix.Tasks.Local.Sample.beam"),
-               tmp_path("mixpath/ebin/Elixir.Mix.Tasks.Local.Sample.beam")
+    File.copy!(
+      fixture_path("archive/ebin/Elixir.Mix.Tasks.Local.Sample.beam"),
+      tmp_path("mixpath/ebin/Elixir.Mix.Tasks.Local.Sample.beam")
+    )
 
     # Run it
-    Mix.Task.run "local.sample"
+    Mix.Task.run("local.sample")
     assert_received {:mix_shell, :info, ["sample"]}
   after
-    purge [Mix.Tasks.Local.Sample]
+    purge([Mix.Tasks.Local.Sample])
   end
 end
diff --git a/lib/mix/test/mix/tasks/new_test.exs b/lib/mix/test/mix/tasks/new_test.exs
index b439dac7800..bd0a9e4bde4 100644
--- a/lib/mix/test/mix/tasks/new_test.exs
+++ b/lib/mix/test/mix/tasks/new_test.exs
@@ -1,102 +1,245 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.NewTest do
   use MixTest.Case
 
   test "new" do
-    in_tmp "new", fn ->
-      Mix.Tasks.New.run ["hello_world", "--bare"]
+    in_tmp("new", fn ->
+      Mix.Tasks.New.run(["hello_world"])
 
-      assert_file "hello_world/mix.exs", fn(file) ->
+      assert_file("hello_world/mix.exs", fn file ->
         assert file =~ "app: :hello_world"
-        assert file =~ "version: \"0.0.1\""
-      end
+        assert file =~ "version: \"0.1.0\""
+      end)
 
-      assert_file "hello_world/README.md", ~r/# HelloWorld/
-      assert_file "hello_world/.gitignore"
+      assert_file("hello_world/README.md", ~r/# HelloWorld\n/)
+      assert_file("hello_world/.gitignore")
 
-      assert_file "hello_world/lib/hello_world.ex",  ~r/defmodule HelloWorld do/
+      assert_file("hello_world/lib/hello_world.ex", ~r/defmodule HelloWorld do/)
+      assert_file("hello_world/test/test_helper.exs", ~r/ExUnit.start()/)
 
-      assert_file "hello_world/test/test_helper.exs", ~r/HelloWorld.start/
-      assert_file "hello_world/test/hello_world_test.exs", ~r/defmodule HelloWorldTest do/
+      assert_file("hello_world/test/hello_world_test.exs", fn file ->
+        assert file =~ ~r/defmodule HelloWorldTest do/
+        assert file =~ "assert HelloWorld.hello() == :world"
+      end)
 
       assert_received {:mix_shell, :info, ["* creating mix.exs"]}
       assert_received {:mix_shell, :info, ["* creating lib/hello_world.ex"]}
-    end
+
+      # Ensure formatting is setup and consistent.
+      File.cd!("hello_world", fn ->
+        Mix.Tasks.Format.run(["--check-formatted"])
+      end)
+    end)
   end
 
   test "new with --sup" do
-    in_tmp "new sup", fn ->
-      Mix.Tasks.New.run ["hello_world", "--sup"]
+    in_tmp("new sup", fn ->
+      Mix.Tasks.New.run(["hello_world", "--sup"])
 
-      assert_file "hello_world/mix.exs", fn(file) ->
+      assert_file("hello_world/mix.exs", fn file ->
         assert file =~ "app: :hello_world"
-        assert file =~ "version: \"0.0.1\""
-        assert file =~ "mod: {HelloWorld, []}"
-      end
+        assert file =~ "version: \"0.1.0\""
+        assert file =~ "mod: {HelloWorld.Application, []}"
+      end)
 
-      assert_file "hello_world/README.md", ~r/# HelloWorld/
-      assert_file "hello_world/.gitignore"
+      assert_file("hello_world/README.md", ~r/# HelloWorld\n/)
+      assert_file("hello_world/.gitignore")
 
-      assert_file "hello_world/lib/hello_world.ex", fn(file) ->
+      assert_file("hello_world/lib/hello_world.ex", fn file ->
         assert file =~ "defmodule HelloWorld do"
+        assert file =~ "def hello do"
+      end)
+
+      assert_file("hello_world/lib/hello_world/application.ex", fn file ->
+        assert file =~ "defmodule HelloWorld.Application do"
         assert file =~ "use Application"
+        assert file =~ "@impl true"
         assert file =~ "Supervisor.start_link(children, opts)"
-      end
+      end)
 
-      assert_file "hello_world/test/test_helper.exs", ~r/HelloWorld.start/
-      assert_file "hello_world/test/hello_world_test.exs", ~r/defmodule HelloWorldTest do/
+      assert_file("hello_world/test/test_helper.exs", ~r/ExUnit.start()/)
+      assert_file("hello_world/test/hello_world_test.exs", ~r/defmodule HelloWorldTest do/)
 
       assert_received {:mix_shell, :info, ["* creating mix.exs"]}
       assert_received {:mix_shell, :info, ["* creating lib/hello_world.ex"]}
-    end
+
+      # Ensure formatting is setup and consistent.
+      File.cd!("hello_world", fn ->
+        Mix.Tasks.Format.run(["--check-formatted"])
+      end)
+    end)
+  end
+
+  test "new with --module uses the module name also for naming the files in lib and test" do
+    in_tmp("new_with_module", fn ->
+      Mix.Tasks.New.run(["hello_world", "--module", "MyTestModule"])
+      assert_file("hello_world/lib/my_test_module.ex", ~r/defmodule MyTestModule do/)
+      assert_file("hello_world/test/my_test_module_test.exs", ~r/defmodule MyTestModuleTest do/)
+    end)
+  end
+
+  test "new with --app" do
+    in_tmp("new app", fn ->
+      Mix.Tasks.New.run(["HELLO_WORLD", "--app", "hello_world"])
+
+      assert_file("HELLO_WORLD/mix.exs", fn file ->
+        assert file =~ "app: :hello_world"
+        assert file =~ "version: \"0.1.0\""
+      end)
+
+      assert_file("HELLO_WORLD/README.md", ~r/# HelloWorld\n/)
+      assert_file("HELLO_WORLD/.gitignore")
+
+      assert_file("HELLO_WORLD/lib/hello_world.ex", ~r/defmodule HelloWorld do/)
+
+      assert_file("HELLO_WORLD/test/test_helper.exs", ~r/ExUnit.start()/)
+      assert_file("HELLO_WORLD/test/hello_world_test.exs", ~r/defmodule HelloWorldTest do/)
+
+      assert_received {:mix_shell, :info, ["* creating mix.exs"]}
+      assert_received {:mix_shell, :info, ["* creating lib/hello_world.ex"]}
+
+      # Ensure formatting is setup and consistent.
+      File.cd!("HELLO_WORLD", fn ->
+        Mix.Tasks.Format.run(["--check-formatted"])
+      end)
+    end)
   end
 
   test "new with --umbrella" do
-    in_tmp "new umbrella", fn ->
-      Mix.Tasks.New.run ["hello_world", "--umbrella"]
+    in_tmp("new umbrella", fn ->
+      Mix.Tasks.New.run(["hello_world", "--umbrella"])
 
-      assert_file "hello_world/mix.exs", fn(file) ->
+      assert_file("hello_world/mix.exs", fn file ->
         assert file =~ "apps_path: \"apps\""
-      end
+      end)
 
-      assert_file "hello_world/README.md", ~r/# HelloWorld/
-      assert_file "hello_world/.gitignore"
+      assert_file("hello_world/README.md", ~r/# HelloWorld\n/)
+      assert_file("hello_world/.gitignore")
 
       assert_received {:mix_shell, :info, ["* creating mix.exs"]}
-    end
+
+      # Ensure formatting is setup and consistent.
+      File.cd!("hello_world", fn ->
+        Mix.Tasks.Format.run(["--check-formatted"])
+      end)
+    end)
+  end
+
+  test "new inside umbrella root" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Tasks.New.run(["apps/hello_world"])
+
+      assert_file("apps/hello_world/mix.exs", fn file ->
+        assert file =~ "deps_path: \"../../deps\""
+        assert file =~ "lockfile: \"../../mix.lock\""
+      end)
+
+      # Ensure formatting is setup and consistent.
+      File.cd!("apps/hello_world", fn ->
+        Mix.Tasks.Format.run(["--check-formatted"])
+      end)
+    end)
   end
 
-  test "new inside umbrella" do
-    in_fixture "umbrella_dep/deps/umbrella", fn ->
-      File.cd! "apps", fn ->
-        Mix.Tasks.New.run ["hello_world"]
+  test "new inside umbrella apps" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      File.cd!("apps", fn ->
+        Mix.Tasks.New.run(["hello_world"])
 
-        assert_file "hello_world/mix.exs", fn(file) ->
+        assert_file("hello_world/mix.exs", fn file ->
           assert file =~ "deps_path: \"../../deps\""
           assert file =~ "lockfile: \"../../mix.lock\""
-        end
-      end
-    end
+        end)
+
+        # Ensure formatting is setup and consistent.
+        File.cd!("hello_world", fn ->
+          Mix.Tasks.Format.run(["--check-formatted"])
+        end)
+      end)
+    end)
   end
 
   test "new with dot" do
-    in_tmp "new_with_dot", fn ->
-      Mix.Tasks.New.run ["."]
-      assert_file "lib/new_with_dot.ex", ~r/defmodule NewWithDot do/
-    end
+    in_tmp("new_with_dot", fn ->
+      Mix.Tasks.New.run(["."])
+      assert_file("lib/new_with_dot.ex", ~r/defmodule NewWithDot do/)
+    end)
   end
 
   test "new with invalid args" do
-    in_tmp "new with invalid args", fn ->
-      assert_raise Mix.Error, "Project path must start with a letter and have only lowercase letters, numbers and underscore", fn ->
-        Mix.Tasks.New.run ["007invalid"]
+    in_tmp("new with an invalid application name", fn ->
+      assert_raise Mix.Error,
+                   ~r"Application name must start with a lowercase ASCII letter",
+                   fn ->
+                     Mix.Tasks.New.run(["007invalid"])
+                   end
+
+      assert_raise Mix.Error,
+                   ~r"Cannot use application name \"tools\" because it is already used by Erlang/OTP or Elixir",
+                   fn ->
+                     Mix.Tasks.New.run(["tools"])
+                   end
+
+      assert_raise Mix.Error,
+                   ~r"Cannot use application name \"pa\" because it is already used by Erlang/OTP or Elixir",
+                   fn ->
+                     Mix.Tasks.New.run(["pa"])
+                   end
+
+      assert_raise Mix.Error,
+                   ~r"followed by lowercase ASCII letters, numbers, or underscores",
+                   fn ->
+                     Mix.Tasks.New.run(["invAlid"])
+                   end
+
+      assert_raise Mix.Error,
+                   ~r"followed by lowercase ASCII letters, numbers, or underscores",
+                   fn ->
+                     Mix.Tasks.New.run(["inválido"])
+                   end
+    end)
+
+    in_tmp("new with an invalid application name from the app option", fn ->
+      assert_raise Mix.Error, ~r"Application name must start with a lowercase ASCII letter", fn ->
+        Mix.Tasks.New.run(["valid", "--app", "007invalid"])
       end
+    end)
 
-      assert_raise Mix.Error, "Expected PATH to be given, please use `mix new PATH`", fn ->
-        Mix.Tasks.New.run []
+    in_tmp("new with an invalid module name from the module options", fn ->
+      assert_raise Mix.Error, ~r"Module name must be a valid Elixir alias", fn ->
+        Mix.Tasks.New.run(["valid", "--module", "not.valid"])
       end
-    end
+    end)
+
+    in_tmp("new with an already taken module name from the module options", fn ->
+      assert_raise Mix.Error, ~r"Module name \w+ is already taken", fn ->
+        Mix.Tasks.New.run(["valid", "--module", "Mix"])
+      end
+    end)
+
+    in_tmp("new without a specified path", fn ->
+      assert_raise Mix.Error,
+                   "Expected PATH to be given. Use \"mix new PATH\" or run \"mix help new\" for more information",
+                   fn ->
+                     Mix.Tasks.New.run([])
+                   end
+    end)
+  end
+
+  test "new with existent directory" do
+    in_tmp("new_with_existent_directory", fn ->
+      File.mkdir_p!("my_app")
+      send(self(), {:mix_shell_input, :yes?, false})
+
+      assert_raise Mix.Error, "Please select another directory for installation", fn ->
+        Mix.Tasks.New.run(["my_app"])
+      end
+    end)
   end
 
   defp assert_file(file) do
@@ -105,8 +248,9 @@ defmodule Mix.Tasks.NewTest do
 
   defp assert_file(file, match) do
     cond do
-      Regex.regex?(match) ->
-        assert_file file, &(&1 =~ match)
+      is_struct(match, Regex) ->
+        assert_file(file, &assert(&1 =~ match))
+
       is_function(match, 1) ->
         assert_file(file)
         match.(File.read!(file))
diff --git a/lib/mix/test/mix/tasks/profile.cprof_test.exs b/lib/mix/test/mix/tasks/profile.cprof_test.exs
new file mode 100644
index 00000000000..b6502442876
--- /dev/null
+++ b/lib/mix/test/mix/tasks/profile.cprof_test.exs
@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.Profile.CprofTest do
+  use MixTest.Case
+
+  import ExUnit.CaptureIO
+  alias Mix.Tasks.Profile.Cprof
+
+  @expr "Enum.each(1..5, &String.Chars.Integer.to_string/1)"
+
+  test "profiles evaluated expression", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Cprof.run(["-e", @expr])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1 *\d/
+    end)
+  end
+
+  test "profiles the script", context do
+    in_tmp(context.test, fn ->
+      profile_script_name = "profile_script.ex"
+
+      File.write!(profile_script_name, @expr)
+
+      assert capture_io(fn ->
+               Cprof.run([profile_script_name])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1 *\d/
+    end)
+  end
+
+  test "filters based on limit", context do
+    in_tmp(context.test, fn ->
+      refute capture_io(fn ->
+               Cprof.run(["--limit", "5", "-e", @expr])
+             end) =~ ~r/:erlang\.trace_pattern\/3 *\d/
+    end)
+  end
+
+  test "filters based on module", context do
+    in_tmp(context.test, fn ->
+      refute capture_io(fn ->
+               Cprof.run(["--module", "Enum", "-e", @expr])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1 *\d/
+    end)
+  end
+
+  test "Module matching", context do
+    in_tmp(context.test, fn ->
+      refute capture_io(fn ->
+               Cprof.run(["--matching", "Enum", "-e", @expr])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1 *\d/
+    end)
+  end
+
+  test "Module.function matching", context do
+    in_tmp(context.test, fn ->
+      refute capture_io(fn ->
+               Cprof.run(["--matching", "Enum.each", "-e", @expr])
+             end) =~ ~r/anonymous fn\/3 in Enum\.each\/2 *\d/
+    end)
+  end
+
+  test "Module.function/arity matching", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Cprof.run(["--matching", "Enum.each/8", "-e", @expr])
+             end) =~ ~r/Profile done over 0 matching functions/
+    end)
+  end
+
+  test "errors on missing files", context do
+    in_tmp(context.test, fn ->
+      msg = "No files matched pattern \"non-existent\" given to --require"
+
+      assert_raise Mix.Error, msg, fn ->
+        capture_io(fn -> Cprof.run(["-r", "non-existent"]) end)
+      end
+
+      assert_raise Mix.Error, msg, fn ->
+        capture_io(fn -> Cprof.run(["-pr", "non-existent"]) end)
+      end
+
+      assert_raise Mix.Error, "No such file: non-existent", fn ->
+        capture_io(fn -> Cprof.run(["non-existent"]) end)
+      end
+
+      File.mkdir_p!("lib")
+
+      assert_raise Mix.Error, "No such file: lib", fn ->
+        capture_io(fn -> Cprof.run(["lib"]) end)
+      end
+    end)
+  end
+
+  test "warmup", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Cprof.run(["-e", @expr])
+             end) =~ "Warmup..."
+
+      refute capture_io(fn ->
+               Cprof.run(["-e", "Enum.each(1..5, fn(_) -> MapSet.new() end)", "--no-warmup"])
+             end) =~ "Warmup..."
+    end)
+  end
+
+  describe ".profile/2" do
+    test "returns the return value of the function call" do
+      capture_io(fn ->
+        assert 42 == Cprof.profile(fn -> 42 end)
+      end)
+    end
+  end
+end
diff --git a/lib/mix/test/mix/tasks/profile.eprof_test.exs b/lib/mix/test/mix/tasks/profile.eprof_test.exs
new file mode 100644
index 00000000000..bcaf30ba35a
--- /dev/null
+++ b/lib/mix/test/mix/tasks/profile.eprof_test.exs
@@ -0,0 +1,127 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.Profile.EprofTest do
+  use MixTest.Case
+
+  import ExUnit.CaptureIO
+  alias Mix.Tasks.Profile.Eprof
+
+  @expr "Enum.each(1..5, &String.Chars.Integer.to_string/1)"
+
+  test "profiles evaluated expression", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Eprof.run(["-e", @expr])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1\s+\d/
+    end)
+  end
+
+  test "profiles evaluated expression in multiple processes", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Eprof.run(["-e", "spawn(fn -> #{@expr} end)"])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1\s+\d/
+    end)
+  end
+
+  test "profiles the script", context do
+    in_tmp(context.test, fn ->
+      profile_script_name = "profile_script.ex"
+      File.write!(profile_script_name, @expr)
+
+      assert capture_io(fn ->
+               Eprof.run([profile_script_name])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1\s+\d/
+    end)
+  end
+
+  test "filters based on count", context do
+    in_tmp(context.test, fn ->
+      refute capture_io(fn ->
+               Eprof.run(["--calls", "5", "-e", @expr])
+             end) =~ ":erlang.apply/2"
+    end)
+  end
+
+  test "sorts based on the calls count", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Eprof.run(["--sort", "calls", "-e", @expr])
+             end) =~ ~r/erlang\.apply\/2.*String\.Chars\.Integer\.to_string\/1/s
+    end)
+  end
+
+  test "Module matching", context do
+    in_tmp(context.test, fn ->
+      refute capture_io(fn ->
+               Eprof.run(["--matching", "Enum", "-e", @expr])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1/
+    end)
+  end
+
+  test "Module.function matching", context do
+    in_tmp(context.test, fn ->
+      refute capture_io(fn ->
+               Eprof.run(["--matching", "Enum.each", "-e", @expr])
+             end) =~ ~r/anonymous fn\/3 in Enum\.each\/2/
+    end)
+  end
+
+  test "Module.function/arity matching", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Eprof.run(["--matching", "Enum.each/8", "-e", @expr])
+             end) =~ ~r/Profile done over 0 matching functions/
+    end)
+  end
+
+  test "errors on missing files", context do
+    in_tmp(context.test, fn ->
+      message = "No files matched pattern \"non-existent\" given to --require"
+
+      assert_raise Mix.Error, message, fn ->
+        capture_io(fn -> Eprof.run(["-r", "non-existent"]) end)
+      end
+
+      message = "No files matched pattern \"non-existent\" given to --require"
+
+      assert_raise Mix.Error, message, fn ->
+        capture_io(fn -> Eprof.run(["-pr", "non-existent"]) end)
+      end
+
+      assert_raise Mix.Error, "No such file: non-existent", fn ->
+        capture_io(fn -> Eprof.run(["non-existent"]) end)
+      end
+
+      File.mkdir_p!("lib")
+
+      assert_raise Mix.Error, "No such file: lib", fn ->
+        capture_io(fn -> Eprof.run(["lib"]) end)
+      end
+    end)
+  end
+
+  test "warmup", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Eprof.run(["-e", @expr])
+             end) =~ "Warmup..."
+
+      refute capture_io(fn ->
+               Eprof.run(["-e", @expr, "--no-warmup"])
+             end) =~ "Warmup..."
+    end)
+  end
+
+  describe ".profile/2" do
+    test "returns the return value of the function call" do
+      capture_io(fn ->
+        assert 42 == Eprof.profile(fn -> 42 end)
+      end)
+    end
+  end
+end
diff --git a/lib/mix/test/mix/tasks/profile.fprof_test.exs b/lib/mix/test/mix/tasks/profile.fprof_test.exs
new file mode 100644
index 00000000000..a138b5a69d4
--- /dev/null
+++ b/lib/mix/test/mix/tasks/profile.fprof_test.exs
@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.Profile.FprofTest do
+  use MixTest.Case
+
+  import ExUnit.CaptureIO
+  alias Mix.Tasks.Profile.Fprof
+
+  test "profiles evaluated expression", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Fprof.run(["-e", "Enum.each(1..5, fn(_) -> MapSet.new(1..3) end)"])
+             end) =~ ~r(MapSet\.new/1 *5 *\d+\.\d{3} *\d+\.\d{3})
+    end)
+  end
+
+  test "profiles the script", context do
+    in_tmp(context.test, fn ->
+      profile_script_name = "profile_script.ex"
+
+      File.write!(profile_script_name, """
+      Enum.each(1..5, fn(_) -> MapSet.new(1..3) end)
+      """)
+
+      assert capture_io(fn ->
+               Fprof.run([profile_script_name])
+             end) =~ ~r(MapSet\.new/1 *5 *\d+\.\d{3} *\d+\.\d{3})
+    end)
+  end
+
+  test "expands callers", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Fprof.run(["-e", "Enum.each(1..5, fn(_) -> MapSet.new(1..3) end)", "--callers"])
+             end) =~ ~r(MapSet\.new/1 *5 *\d+\.\d{3} *\d+\.\d{3} +<--)
+    end)
+  end
+
+  test "writes traces to file", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               expr = "Enum.each(1..5, fn(_) -> MapSet.new(1..3) end)"
+               Fprof.run(["-e", expr, "--trace-to-file"])
+             end) =~ ~r(MapSet\.new/1 *5 *\d+\.\d{3} *\d+\.\d{3})
+    end)
+  end
+
+  test "expands processes", context do
+    in_tmp(context.test, fn ->
+      expr =
+        "spawn(fn -> Process.sleep(:infinity) end); Enum.each(1..5, fn(_) -> MapSet.new(1..3) end)"
+
+      output = capture_io(fn -> Fprof.run(["-e", expr, "--details"]) end)
+      assert output =~ ~r/#{:erlang.pid_to_list(self())} +\d+ +\d+\.\d{3}/
+      assert output =~ ~r/spawned by #{:erlang.pid_to_list(self())}/
+      assert output =~ ~r/as :erlang.apply/
+      assert output =~ ~r/initial calls:/
+    end)
+  end
+
+  test "sort options", context do
+    in_tmp(context.test, fn ->
+      expr = "Enum.each(1..5, fn(_) -> MapSet.new(1..3) end)"
+
+      assert capture_io(fn -> Fprof.run(["-e", expr, "--sort", "acc"]) end) =~
+               ~r(MapSet\.new/1 *5 *\d+\.\d{3} *\d+\.\d{3})
+
+      expr = "Enum.each(1..5, fn(_) -> MapSet.new(1..3) end)"
+
+      assert capture_io(fn -> Fprof.run(["-e", expr, "--sort", "own"]) end) =~
+               ~r(MapSet\.new/1 *5 *\d+\.\d{3} *\d+\.\d{3})
+    end)
+  end
+
+  test "errors on missing files", context do
+    in_tmp(context.test, fn ->
+      message = "No files matched pattern \"non-existent\" given to --require"
+
+      assert_raise Mix.Error, message, fn ->
+        capture_io(fn -> Fprof.run(["-r", "non-existent"]) end)
+      end
+
+      assert_raise Mix.Error, message, fn ->
+        capture_io(fn -> Fprof.run(["-pr", "non-existent"]) end)
+      end
+
+      assert_raise Mix.Error, "No such file: non-existent", fn ->
+        capture_io(fn -> Fprof.run(["non-existent"]) end)
+      end
+
+      File.mkdir_p!("lib")
+
+      assert_raise Mix.Error, "No such file: lib", fn ->
+        capture_io(fn -> Fprof.run(["lib"]) end)
+      end
+    end)
+  end
+
+  test "warmup", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Fprof.run(["-e", "Enum.each(1..5, fn(_) -> MapSet.new(1..3) end)"])
+             end) =~ "Warmup..."
+
+      refute capture_io(fn ->
+               Fprof.run(["-e", "Enum.each(1..5, fn(_) -> MapSet.new(1..3) end)", "--no-warmup"])
+             end) =~ "Warmup..."
+    end)
+  end
+
+  describe ".profile/2" do
+    test "returns the return value of the function call" do
+      capture_io(fn ->
+        assert 42 == Fprof.profile(fn -> 42 end)
+      end)
+    end
+  end
+end
diff --git a/lib/mix/test/mix/tasks/profile.tprof_test.exs b/lib/mix/test/mix/tasks/profile.tprof_test.exs
new file mode 100644
index 00000000000..e33cb1e46a1
--- /dev/null
+++ b/lib/mix/test/mix/tasks/profile.tprof_test.exs
@@ -0,0 +1,189 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.Profile.TprofTest do
+  use MixTest.Case
+
+  import ExUnit.CaptureIO
+  alias Mix.Tasks.Profile.Tprof
+
+  # TODO remove once we require Erlang/OTP 27+
+  @moduletag skip: System.otp_release() < "27"
+
+  @expr "Enum.each(1..5, &String.Chars.Integer.to_string/1)"
+
+  test "profiles evaluated expression", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Tprof.run(["-e", @expr])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1\s+\d/
+    end)
+  end
+
+  test "profiles evaluated expression in multiple processes", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Tprof.run(["-e", "spawn(fn -> #{@expr} end)"])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1\s+\d/
+    end)
+  end
+
+  test "profiles the script", context do
+    in_tmp(context.test, fn ->
+      profile_script_name = "profile_script.ex"
+      File.write!(profile_script_name, @expr)
+
+      assert capture_io(fn ->
+               Tprof.run([profile_script_name])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1\s+\d/
+    end)
+  end
+
+  test "filters based on calls count", context do
+    in_tmp(context.test, fn ->
+      result =
+        capture_io(fn ->
+          Tprof.run(["--calls", "5", "-e", @expr])
+        end)
+
+      assert result =~ "\nString.Chars.Integer.to_string/1"
+      refute result =~ "\nEnum.each/2"
+    end)
+  end
+
+  test "filters based on memory", context do
+    in_tmp(context.test, fn ->
+      result =
+        capture_io(fn ->
+          Tprof.run(["--type", "memory", "--memory", "10", "-e", @expr])
+        end)
+
+      assert result =~ "\n:erlang.integer_to_binary/1"
+      refute result =~ "\nEnum.each/2"
+    end)
+  end
+
+  test "sorts based on calls count", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Tprof.run(["--sort", "calls", "-e", @expr])
+             end) =~ ~r/\nEnum\.each\/2.*\nString\.Chars\.Integer\.to_string\/1/s
+    end)
+  end
+
+  test "sorts based on memory usage", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Tprof.run(["--type", "memory", "--sort", "calls", "-e", @expr])
+             end) =~ ~r/\nEnum\.each\/2.*\n:erlang\.integer_to_binary\/1/s
+    end)
+  end
+
+  test "aggregates totals over all processes", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Tprof.run(["--report", "total", "-e", @expr])
+             end) =~ "Profile results over all processes"
+    end)
+  end
+
+  test "Module matching", context do
+    in_tmp(context.test, fn ->
+      refute capture_io(fn ->
+               Tprof.run(["--matching", "Enum", "-e", @expr])
+             end) =~ ~r/String\.Chars\.Integer\.to_string\/1/
+    end)
+  end
+
+  test "Module.function matching", context do
+    in_tmp(context.test, fn ->
+      refute capture_io(fn ->
+               Tprof.run(["--matching", "Enum.each", "-e", @expr])
+             end) =~ ~r/anonymous fn\/3 in Enum\.each\/2/
+    end)
+  end
+
+  test "Module.function/arity matching", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Tprof.run(["--matching", "Enum.each/8", "-e", @expr])
+             end) =~ ~r/Profile done over 0 matching functions/
+    end)
+  end
+
+  test "errors on missing files", context do
+    in_tmp(context.test, fn ->
+      message = "No files matched pattern \"non-existent\" given to --require"
+
+      assert_raise Mix.Error, message, fn ->
+        capture_io(fn -> Tprof.run(["-r", "non-existent"]) end)
+      end
+
+      message = "No files matched pattern \"non-existent\" given to --require"
+
+      assert_raise Mix.Error, message, fn ->
+        capture_io(fn -> Tprof.run(["-pr", "non-existent"]) end)
+      end
+
+      assert_raise Mix.Error, "No such file: non-existent", fn ->
+        capture_io(fn -> Tprof.run(["non-existent"]) end)
+      end
+
+      File.mkdir_p!("lib")
+
+      assert_raise Mix.Error, "No such file: lib", fn ->
+        capture_io(fn -> Tprof.run(["lib"]) end)
+      end
+    end)
+  end
+
+  test "warmup", context do
+    in_tmp(context.test, fn ->
+      assert capture_io(fn ->
+               Tprof.run(["-e", @expr])
+             end) =~ "Warmup..."
+
+      refute capture_io(fn ->
+               Tprof.run(["-e", @expr, "--no-warmup"])
+             end) =~ "Warmup..."
+    end)
+  end
+
+  test "errors on incompatible options", context do
+    in_tmp(context.test, fn ->
+      message = "Incompatible sort option :memory with type :time"
+
+      assert_raise Mix.Error, message, fn ->
+        capture_io(fn -> Tprof.run(["-e", @expr, "--sort", "memory"]) end)
+      end
+
+      message = "Incompatible sort option :time with type :calls"
+
+      assert_raise Mix.Error, message, fn ->
+        capture_io(fn -> Tprof.run(["-e", @expr, "--type", "calls", "--sort", "time"]) end)
+      end
+
+      message = "Incompatible use of memory option with type :time"
+
+      assert_raise Mix.Error, message, fn ->
+        capture_io(fn -> Tprof.run(["-e", @expr, "--time", "1", "--memory", "2"]) end)
+      end
+
+      message = "Incompatible use of time option with type :calls"
+
+      assert_raise Mix.Error, message, fn ->
+        capture_io(fn -> Tprof.run(["-e", @expr, "--type", "calls", "--time", "1"]) end)
+      end
+    end)
+  end
+
+  describe ".profile/2" do
+    test "returns the return value of the function call" do
+      capture_io(fn ->
+        assert 42 == Tprof.profile(fn -> 42 end)
+      end)
+    end
+  end
+end
diff --git a/lib/mix/test/mix/tasks/release.init_test.exs b/lib/mix/test/mix/tasks/release.init_test.exs
new file mode 100644
index 00000000000..32f4278fda4
--- /dev/null
+++ b/lib/mix/test/mix/tasks/release.init_test.exs
@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.Release.InitTest do
+  use MixTest.Case
+
+  test "copies templates as is" do
+    in_tmp("release_init", fn ->
+      Mix.Task.run("release.init", [])
+      assert_received {:mix_shell, :info, ["* creating rel/vm.args.eex"]}
+      assert_received {:mix_shell, :info, ["* creating rel/remote.vm.args.eex"]}
+      assert_received {:mix_shell, :info, ["* creating rel/env.sh.eex"]}
+      assert_received {:mix_shell, :info, ["* creating rel/env.bat.eex"]}
+
+      assert File.exists?("rel/vm.args.eex")
+      assert File.exists?("rel/remote.vm.args.eex")
+      assert File.exists?("rel/env.sh.eex")
+      assert File.exists?("rel/env.bat.eex")
+    end)
+  end
+
+  test "can be set to --force and --quiet" do
+    in_tmp("release_init", fn ->
+      Mix.Task.run("release.init", ["--force", "--quiet"])
+      Mix.Task.run("release.init", ["--force", "--quiet"])
+      refute_received {:mix_shell, :info, ["* creating rel/vm.args.eex"]}
+      refute_received {:mix_shell, :info, ["* creating rel/remote.vm.args.eex"]}
+      refute_received {:mix_shell, :info, ["* creating rel/env.sh.eex"]}
+      refute_received {:mix_shell, :info, ["* creating rel/env.bat.eex"]}
+    end)
+  end
+
+  test "raises on bad input" do
+    assert_raise OptionParser.ParseError,
+                 ~r"--unknown : Unknown option",
+                 fn -> Mix.Tasks.Release.Init.run(["--unknown"]) end
+
+    assert_raise Mix.Error,
+                 ~r/Expected "mix release.init" without arguments, got: \["foo", "bar"\]/,
+                 fn -> Mix.Tasks.Release.Init.run(["foo", "bar"]) end
+  end
+end
diff --git a/lib/mix/test/mix/tasks/release_test.exs b/lib/mix/test/mix/tasks/release_test.exs
new file mode 100644
index 00000000000..414802821ce
--- /dev/null
+++ b/lib/mix/test/mix/tasks/release_test.exs
@@ -0,0 +1,849 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.ReleaseTest do
+  use MixTest.Case
+
+  @erts_version :erlang.system_info(:version)
+  @hostname :inet_db.gethostname()
+
+  defmacrop release_node(name), do: :"#{name}@#{@hostname}"
+
+  describe "customize" do
+    test "env, vm.args and overlays templates" do
+      in_fixture("release_test", fn ->
+        Mix.Project.in_project(:release_test, ".", fn _ ->
+          File.mkdir_p!("rel/overlays/empty/directory")
+          File.write!("rel/overlays/hello", "world")
+
+          for file <- ~w(rel/vm.args.eex rel/remote.vm.args.eex rel/env.sh.eex rel/env.bat.eex) do
+            File.write!(file, """
+            #{file} FOR <%= @release.name %>
+            """)
+          end
+
+          root = Path.absname("_build/dev/rel/release_test")
+          Mix.Task.run("release")
+          assert_received {:mix_shell, :info, ["* assembling release_test-0.1.0 on MIX_ENV=dev"]}
+
+          assert root |> Path.join("releases/0.1.0/env.sh") |> File.read!() ==
+                   "rel/env.sh.eex FOR release_test\n"
+
+          assert root |> Path.join("releases/0.1.0/env.bat") |> File.read!() ==
+                   "rel/env.bat.eex FOR release_test\n"
+
+          assert root |> Path.join("releases/0.1.0/vm.args") |> File.read!() ==
+                   "rel/vm.args.eex FOR release_test\n"
+
+          assert root |> Path.join("releases/0.1.0/remote.vm.args") |> File.read!() ==
+                   "rel/remote.vm.args.eex FOR release_test\n"
+
+          assert root |> Path.join("empty/directory") |> File.dir?()
+          assert root |> Path.join("hello") |> File.read!() == "world"
+        end)
+      end)
+    end
+
+    test "env, vm.args and overlays templates with custom rel_templates_path" do
+      in_fixture("release_test", fn ->
+        config = [
+          releases: [
+            release_test: [rel_templates_path: "custom_rel"]
+          ]
+        ]
+
+        Mix.Project.in_project(:release_test, ".", config, fn _ ->
+          File.mkdir_p!("custom_rel/overlays/empty/directory")
+          File.write!("custom_rel/overlays/hello", "world")
+
+          for file <-
+                ~w(custom_rel/vm.args.eex custom_rel/remote.vm.args.eex custom_rel/env.sh.eex custom_rel/env.bat.eex) do
+            File.write!(file, """
+            #{file} FOR <%= @release.name %>
+            """)
+          end
+
+          root = Path.absname("_build/dev/rel/release_test")
+          Mix.Task.run("release")
+          assert_received {:mix_shell, :info, ["* assembling release_test-0.1.0 on MIX_ENV=dev"]}
+
+          assert root |> Path.join("releases/0.1.0/env.sh") |> File.read!() ==
+                   "custom_rel/env.sh.eex FOR release_test\n"
+
+          assert root |> Path.join("releases/0.1.0/env.bat") |> File.read!() ==
+                   "custom_rel/env.bat.eex FOR release_test\n"
+
+          assert root |> Path.join("releases/0.1.0/vm.args") |> File.read!() ==
+                   "custom_rel/vm.args.eex FOR release_test\n"
+
+          assert root |> Path.join("releases/0.1.0/remote.vm.args") |> File.read!() ==
+                   "custom_rel/remote.vm.args.eex FOR release_test\n"
+
+          assert root |> Path.join("empty/directory") |> File.dir?()
+          assert root |> Path.join("hello") |> File.read!() == "world"
+        end)
+      end)
+    end
+
+    test "custom overlays" do
+      in_fixture("release_test", fn ->
+        config = [releases: [release_test: [overlays: "rel/another"]]]
+
+        Mix.Project.in_project(:release_test, ".", config, fn _ ->
+          File.mkdir_p!("rel/overlays")
+          File.write!("rel/overlays/hello", "world")
+          File.write!("rel/overlays/original", "kept")
+
+          File.mkdir_p!("rel/another/empty/directory")
+          File.write!("rel/another/hello", "override")
+
+          root = Path.absname("_build/dev/rel/release_test")
+          Mix.Task.rerun("release", ["--overwrite"])
+
+          assert root |> Path.join("empty/directory") |> File.dir?()
+          assert root |> Path.join("hello") |> File.read!() == "override"
+          assert root |> Path.join("original") |> File.read!() == "kept"
+        end)
+      end)
+    end
+
+    test "steps" do
+      in_fixture("release_test", fn ->
+        last_step = fn release ->
+          send(self(), {:last_step, release})
+          release
+        end
+
+        first_step = fn release ->
+          send(self(), {:first_step, release})
+          update_in(release.steps, &(&1 ++ [last_step]))
+        end
+
+        config = [releases: [demo: [steps: [first_step, :assemble]]]]
+
+        Mix.Project.in_project(:release_test, ".", config, fn _ ->
+          Mix.Task.run("release")
+          assert_received {:mix_shell, :info, ["* assembling demo-0.1.0 on MIX_ENV=dev"]}
+
+          # Discard info messages from inbox for upcoming assertions
+          Mix.shell().flush(& &1)
+
+          {:messages,
+           [
+             {:first_step, %Mix.Release{steps: [:assemble]}},
+             {:last_step, %Mix.Release{steps: []}}
+           ]} = Process.info(self(), :messages)
+        end)
+      end)
+    end
+
+    test "include_executables_for and strip_beams" do
+      in_fixture("release_test", fn ->
+        config = [
+          releases: [
+            release_test: [
+              include_executables_for: [],
+              strip_beams: [keep: "Docs"]
+            ]
+          ]
+        ]
+
+        Mix.Project.in_project(:release_test, ".", config, fn _ ->
+          root = Path.absname("_build/dev/rel/release_test")
+          Mix.Task.run("release")
+          assert_received {:mix_shell, :info, ["* assembling release_test-0.1.0 on MIX_ENV=dev"]}
+
+          beam =
+            File.read!(Path.join(root, "lib/release_test-0.1.0/ebin/Elixir.ReleaseTest.beam"))
+
+          assert {:ok, {_, [{~c"Docs", _}]}} = :beam_lib.chunks(beam, [~c"Docs"])
+          assert {:error, _, _} = :beam_lib.chunks(beam, [~c"Dbgi"])
+
+          refute root |> Path.join("bin/start") |> File.exists?()
+          refute root |> Path.join("bin/start.bat") |> File.exists?()
+          refute root |> Path.join("releases/0.1.0/elixir") |> File.exists?()
+          refute root |> Path.join("releases/0.1.0/elixir.bat") |> File.exists?()
+          refute root |> Path.join("releases/0.1.0/iex") |> File.exists?()
+          refute root |> Path.join("releases/0.1.0/iex.bat") |> File.exists?()
+        end)
+      end)
+    end
+  end
+
+  describe "errors" do
+    test "requires a matching name" do
+      in_fixture("release_test", fn ->
+        Mix.Project.in_project(:release_test, ".", fn _ ->
+          assert_raise Mix.Error, ~r"Unknown release :unknown", fn ->
+            Mix.Task.run("release", ["unknown"])
+          end
+        end)
+      end)
+    end
+  end
+
+  describe "tar" do
+    test "with default options" do
+      in_fixture("release_test", fn ->
+        config = [releases: [demo: [steps: [:assemble, :tar]]]]
+
+        Mix.Project.in_project(:release_test, ".", config, fn _ ->
+          root = Path.absname("_build/#{Mix.env()}/rel/demo")
+
+          ignored_app_path = Path.join([root, "lib", "ignored_app-0.1.0", "ebin"])
+          File.mkdir_p!(ignored_app_path)
+          File.touch(Path.join(ignored_app_path, "ignored_app.app"))
+
+          ignored_release_path = Path.join([root, "releases", "ignored_dir"])
+          File.mkdir_p!(ignored_release_path)
+          File.touch(Path.join(ignored_release_path, "ignored"))
+
+          # Overlays
+          File.mkdir_p!("rel/overlays/empty/directory")
+          File.write!("rel/overlays/hello", "world")
+
+          Mix.Task.run("release")
+          tar_path = Path.expand(Path.join([root, "..", "..", "demo-0.1.0.tar.gz"]))
+          message = "* building #{tar_path}"
+          assert_received {:mix_shell, :info, [^message]}
+          assert File.exists?(tar_path)
+
+          {:ok, files} = String.to_charlist(tar_path) |> :erl_tar.table([:compressed])
+
+          files = Enum.map(files, &to_string/1)
+          files_with_versions = File.ls!(Path.join(root, "lib"))
+
+          assert "bin/demo" in files
+          assert "releases/0.1.0/sys.config" in files
+          assert "releases/0.1.0/vm.args" in files
+          assert "releases/0.1.0/remote.vm.args" in files
+          assert "releases/COOKIE" in files
+          assert "releases/start_erl.data" in files
+          assert "hello" in files
+          assert "empty/directory" in files
+          assert Enum.any?(files, &(&1 =~ "erts"))
+          assert Enum.any?(files, &(&1 =~ "stdlib"))
+
+          for dir <- files_with_versions -- ["ignored_app-0.1.0"] do
+            [name | _] = String.split(dir, "-")
+            assert "lib/#{dir}/ebin/#{name}.app" in files
+          end
+
+          refute "lib/ignored_app-0.1.0/ebin/ignored_app.app" in files
+          refute "releases/ignored_dir/ignored" in files
+        end)
+      end)
+    end
+
+    test "without ERTS and custom path" do
+      in_fixture("release_test", fn ->
+        config = [
+          releases: [demo: [include_erts: false, path: "tmp/rel", steps: [:assemble, :tar]]]
+        ]
+
+        Mix.Project.in_project(:release_test, ".", config, fn _ ->
+          Mix.Task.run("release")
+          tar_path = Path.expand(Path.join(["tmp", "rel", "demo-0.1.0.tar.gz"]))
+          message = "* building #{tar_path}"
+          assert_received {:mix_shell, :info, [^message]}
+          assert File.exists?(tar_path)
+
+          {:ok, files} = String.to_charlist(tar_path) |> :erl_tar.table([:compressed])
+          files = Enum.map(files, &to_string/1)
+
+          assert "bin/demo" in files
+          refute Enum.any?(files, &(&1 =~ "erts"))
+          refute Enum.any?(files, &(&1 =~ "stdlib"))
+        end)
+      end)
+    end
+
+    test "without ERTS when a previous build included ERTS" do
+      in_fixture("release_test", fn ->
+        config = [releases: [demo: [include_erts: false, steps: [:assemble, :tar]]]]
+
+        Mix.Project.in_project(:release_test, ".", config, fn _ ->
+          root = Path.absname("_build/#{Mix.env()}/rel/demo")
+
+          erts_dir_from_previous_build =
+            Path.absname("_build/#{Mix.env()}/rel/demo/erts-#{@erts_version}")
+
+          File.mkdir_p!(erts_dir_from_previous_build)
+
+          Mix.Task.run("release")
+          tar_path = Path.expand(Path.join([root, "..", "..", "demo-0.1.0.tar.gz"]))
+          message = "* building #{tar_path}"
+          assert_received {:mix_shell, :info, [^message]}
+          assert File.exists?(tar_path)
+
+          {:ok, files} = String.to_charlist(tar_path) |> :erl_tar.table([:compressed])
+          files = Enum.map(files, &to_string/1)
+
+          assert "bin/demo" in files
+          refute Enum.any?(files, &(&1 =~ "erts"))
+          refute Enum.any?(files, &(&1 =~ "stdlib"))
+        end)
+      end)
+    end
+  end
+
+  test "assembles a bootable release with ERTS" do
+    in_fixture("release_test", fn ->
+      Mix.Project.in_project(:release_test, ".", fn _ ->
+        root = Path.absname("_build/dev/rel/release_test")
+
+        # Assert command
+        Mix.Task.run("release")
+        assert_received {:mix_shell, :info, ["* assembling release_test-0.1.0 on MIX_ENV=dev"]}
+
+        assert_received {:mix_shell, :info,
+                         ["\nRelease created at _build/dev/rel/release_test\n" <> _]}
+
+        assert_received {:mix_shell, :info, ["* skipping runtime configuration" <> _]}
+
+        # Assert structure
+        assert root |> Path.join("erts-#{@erts_version}") |> File.exists?()
+        assert root |> Path.join("lib/release_test-0.1.0/ebin") |> File.exists?()
+        assert root |> Path.join("lib/release_test-0.1.0/priv/hello") |> File.exists?()
+        assert root |> Path.join("releases/COOKIE") |> File.exists?()
+        assert root |> Path.join("releases/start_erl.data") |> File.exists?()
+        assert root |> Path.join("releases/0.1.0/release_test.rel") |> File.exists?()
+        assert root |> Path.join("releases/0.1.0/sys.config") |> File.exists?()
+        assert root |> Path.join("releases/0.1.0/env.sh") |> File.exists?()
+        assert root |> Path.join("releases/0.1.0/env.bat") |> File.exists?()
+        assert root |> Path.join("releases/0.1.0/vm.args") |> File.exists?()
+        assert root |> Path.join("releases/0.1.0/remote.vm.args") |> File.exists?()
+
+        assert root
+               |> Path.join("releases/0.1.0/sys.config")
+               |> File.read!() =~ "RUNTIME_CONFIG=false"
+
+        assert root
+               |> Path.join("lib/release_test-0.1.0/priv")
+               |> File.read_link()
+               |> elem(0) == :error
+
+        cookie = File.read!(Path.join(root, "releases/COOKIE"))
+
+        # Assert runtime
+        open_port(Path.join(root, "bin/release_test"), [~c"start"])
+
+        assert %{
+                 app_dir: app_dir,
+                 cookie_env: ^cookie,
+                 encoding: {:_μ, :"£", "£", ~c"£"},
+                 mode: :embedded,
+                 node: release_node("release_test"),
+                 protocols_consolidated?: true,
+                 release_name: "release_test",
+                 release_node: "release_test",
+                 release_prog: "release_test" <> ext,
+                 release_root: release_root,
+                 release_vsn: "0.1.0",
+                 root_dir: root_dir,
+                 runtime_config: :error,
+                 static_config: {:ok, :was_set},
+                 sys_config_env: sys_config_env,
+                 sys_config_init: sys_config_init
+               } = wait_until_decoded(Path.join(root, "RELEASE_BOOTED"))
+
+        if match?({:win32, _}, :os.type()) do
+          # `RELEAS~1` is the DOS path name (8 character) for the `release_test` directory
+          assert app_dir =~ ~r"_build/dev/rel/(release_test|RELEAS~1)/lib/release_test-0\.1\.0$"
+          assert release_root =~ ~r"_build\\dev\\rel\\(release_test|RELEAS~1)$"
+          assert root_dir =~ ~r"_build/dev/rel/(release_test|RELEAS~1)$"
+          assert String.ends_with?(sys_config_env, "releases\\0.1.0\\sys")
+          assert String.ends_with?(sys_config_init, "releases\\0.1.0\\sys")
+          assert ext == ".bat"
+        else
+          assert app_dir == Path.join(root, "lib/release_test-0.1.0")
+          assert release_root == root
+          assert root_dir == root
+          assert sys_config_env == Path.join(root, "releases/0.1.0/sys")
+          assert sys_config_init == Path.join(root, "releases/0.1.0/sys")
+          assert ext == ""
+        end
+      end)
+    end)
+  end
+
+  test "assembles a rebootable release with runtime configuration" do
+    in_fixture("release_test", fn ->
+      config = [releases: [runtime_config: [reboot_system_after_config: true]]]
+
+      Mix.Project.in_project(:release_test, ".", config, fn _ ->
+        File.write!("config/config.exs", """
+        #{File.read!("config/config.exs")}
+        config :release_test, :runtime, keep: :static, override: :static
+        """)
+
+        File.write!("config/runtime.exs", """
+        import Config
+
+        if System.get_env("RELEASE_MODE") == nil do
+          raise "file should not be loaded while assembling release"
+        end
+
+        # Ensure app has been loaded
+        [_ | _] = Application.spec(:release_test, :modules)
+
+        config :release_test, :runtime,
+          override: :runtime,
+          config_env: config_env(),
+          config_target: config_target(),
+          mode: :code.get_mode()
+
+        config :release_test, :encoding, {:runtime, :_μ, :"£", "£", ~c"£"}
+        """)
+
+        root = Path.absname("_build/dev/rel/runtime_config")
+
+        # Assert command
+        Mix.Task.run("release", ["runtime_config"])
+        assert_received {:mix_shell, :info, ["* assembling runtime_config-0.1.0 on MIX_ENV=dev"]}
+
+        assert_received {:mix_shell, :info,
+                         ["* using config/runtime.exs to configure the release at runtime"]}
+
+        # Assert structure
+        assert root
+               |> Path.join("releases/0.1.0/sys.config")
+               |> File.read!() =~ "RUNTIME_CONFIG=true"
+
+        # Make sys.config read-only and it should still boot
+        assert root
+               |> Path.join("releases/0.1.0/sys.config")
+               |> File.chmod(0o555) == :ok
+
+        # Assert runtime
+        open_port(Path.join(root, "bin/runtime_config"), [~c"start"])
+
+        assert %{
+                 encoding: {:runtime, :_μ, :"£", "£", ~c"£"},
+                 mode: :embedded,
+                 node: release_node("runtime_config"),
+                 protocols_consolidated?: true,
+                 release_name: "runtime_config",
+                 release_mode: "embedded",
+                 release_node: "runtime_config",
+                 release_prog: "runtime_config" <> ext,
+                 release_vsn: "0.1.0",
+                 runtime_config:
+                   {:ok,
+                    [
+                      keep: :static,
+                      override: :runtime,
+                      config_env: :dev,
+                      config_target: :host,
+                      mode: :interactive
+                    ]},
+                 static_config: {:ok, :was_set},
+                 sys_config_env: sys_config_env,
+                 sys_config_init: sys_config_init
+               } = wait_until_decoded(Path.join(root, "RELEASE_BOOTED"))
+
+        if match?({:win32, _}, :os.type()) do
+          assert sys_config_env =~ "tmp\\runtime_config-0.1.0"
+          assert sys_config_init =~ "tmp\\runtime_config-0.1.0"
+          assert ext == ".bat"
+        else
+          assert sys_config_env =~ "tmp/runtime_config-0.1.0"
+          assert sys_config_init =~ "tmp/runtime_config-0.1.0"
+          assert ext == ""
+        end
+      end)
+    end)
+  end
+
+  test "assembles a bootable release without distribution" do
+    in_fixture("release_test", fn ->
+      config = [releases: [no_dist: []]]
+
+      Mix.Project.in_project(:release_test, ".", config, fn _ ->
+        root = Path.absname("_build/dev/rel/no_dist")
+        Mix.Task.run("release", ["no_dist"])
+
+        open_port(Path.join(root, "bin/no_dist"), [~c"start"], [
+          {~c"RELEASE_DISTRIBUTION", ~c"none"}
+        ])
+
+        assert %{
+                 mode: :embedded,
+                 node: :nonode@nohost,
+                 protocols_consolidated?: true,
+                 release_name: "no_dist",
+                 release_node: "no_dist",
+                 release_vsn: "0.1.0"
+               } = wait_until_decoded(Path.join(root, "RELEASE_BOOTED"))
+      end)
+    end)
+  end
+
+  test "assembles a release without ERTS and with custom options" do
+    in_fixture("release_test", fn ->
+      config = [releases: [demo: [include_erts: false, cookie: "abcdefghijk"]]]
+
+      Mix.Project.in_project(:release_test, ".", config, fn _ ->
+        root = Path.absname("demo")
+
+        Mix.Task.run("release", ["demo", "--path", "demo", "--version", "0.2.0", "--quiet"])
+        refute_received {:mix_shell, :info, ["* assembling " <> _]}
+        refute_received {:mix_shell, :info, ["\nRelease created " <> _]}
+
+        # Assert structure
+        assert root |> Path.join("bin/demo") |> File.exists?()
+        refute root |> Path.join("erts-#{@erts_version}") |> File.exists?()
+        assert root |> Path.join("lib/release_test-0.1.0/ebin") |> File.exists?()
+        assert root |> Path.join("lib/release_test-0.1.0/priv/hello") |> File.exists?()
+        assert root |> Path.join("releases/COOKIE") |> File.exists?()
+        assert root |> Path.join("releases/start_erl.data") |> File.exists?()
+        assert root |> Path.join("releases/0.2.0/demo.rel") |> File.exists?()
+        assert root |> Path.join("releases/0.2.0/sys.config") |> File.exists?()
+        assert root |> Path.join("releases/0.2.0/vm.args") |> File.exists?()
+        assert root |> Path.join("releases/0.2.0/remote.vm.args") |> File.exists?()
+
+        # Assert runtime
+        open_port(Path.join(root, "bin/demo"), [~c"start"])
+
+        assert %{
+                 app_dir: app_dir,
+                 cookie_env: "abcdefghijk",
+                 mode: :embedded,
+                 node: release_node("demo"),
+                 protocols_consolidated?: true,
+                 release_name: "demo",
+                 release_node: "demo",
+                 release_prog: "demo" <> ext,
+                 release_root: release_root,
+                 release_vsn: "0.2.0",
+                 root_dir: root_dir,
+                 runtime_config: :error,
+                 static_config: {:ok, :was_set}
+               } = wait_until_decoded(Path.join(root, "RELEASE_BOOTED"))
+
+        if match?({:win32, _}, :os.type()) do
+          assert String.ends_with?(app_dir, "demo/lib/release_test-0.1.0")
+          assert String.ends_with?(release_root, "demo")
+          assert ext == ".bat"
+        else
+          assert app_dir == Path.join(root, "lib/release_test-0.1.0")
+          assert release_root == root
+          assert ext == ""
+        end
+
+        assert root_dir == :code.root_dir() |> to_string()
+      end)
+    end)
+  end
+
+  test "validates compile_env" do
+    in_fixture("release_test", fn ->
+      # Let's also use a non standard config_path.
+      config = [releases: [compile_env_config: []], config_path: "different_config/config.exs"]
+
+      File.write!("lib/compile_env.ex", """
+      require Application
+      _ = Application.compile_env(:release_test, :static)
+      """)
+
+      File.mkdir_p!("different_config")
+      File.cp!("config/config.exs", "different_config/config.exs")
+
+      File.write!("different_config/runtime.exs", """
+      import Config
+      config :release_test, :static, String.to_atom(System.get_env("RELEASE_STATIC"))
+      """)
+
+      Mix.Project.in_project(:release_test, ".", config, fn _ ->
+        Mix.Task.run("loadconfig", [])
+
+        root = Path.absname("_build/dev/rel/compile_env_config")
+        Mix.Task.run("release", ["compile_env_config"])
+
+        assert {output, _} =
+                 System.cmd(Path.join(root, "bin/compile_env_config"), ["start"],
+                   stderr_to_stdout: true,
+                   env: [{"RELEASE_STATIC", "runtime"}]
+                 )
+
+        assert output =~
+                 "ERROR! the application :release_test has a different value set for key :static during runtime compared to compile time"
+
+        # But now it does
+        env = [{~c"RELEASE_STATIC", ~c"was_set"}]
+        open_port(Path.join(root, "bin/compile_env_config"), [~c"start"], env)
+        assert %{} = wait_until_decoded(Path.join(root, "RELEASE_BOOTED"))
+      end)
+    end)
+  end
+
+  test "does not validate compile_env if opted out" do
+    in_fixture("release_test", fn ->
+      config = [releases: [no_compile_env_config: [validate_compile_env: false]]]
+
+      File.write!("lib/compile_env.ex", """
+      require Application
+      _ = Application.compile_env(:release_test, :static)
+      """)
+
+      Mix.Project.in_project(:release_test, ".", config, fn _ ->
+        Mix.Task.run("loadconfig", [])
+
+        File.write!("config/runtime.exs", """
+        import Config
+        config :release_test, :static, String.to_atom(System.get_env("RELEASE_STATIC"))
+        config :release_test, :runtime, mode: :code.get_mode()
+        """)
+
+        root = Path.absname("_build/dev/rel/no_compile_env_config")
+        Mix.Task.run("release", ["no_compile_env_config"])
+
+        # It boots with mismatched config
+        env = [{~c"RELEASE_STATIC", ~c"runtime"}]
+        open_port(Path.join(root, "bin/no_compile_env_config"), [~c"start"], env)
+
+        assert %{
+                 mode: :embedded,
+                 runtime_config: {:ok, [mode: :embedded]},
+                 static_config: {:ok, :runtime}
+               } =
+                 wait_until_decoded(Path.join(root, "RELEASE_BOOTED"))
+      end)
+    end)
+  end
+
+  @tag :epmd
+  test "executes rpc instructions" do
+    in_fixture("release_test", fn ->
+      config = [releases: [permanent1: [include_erts: false]]]
+
+      # We write the compile env to guarantee rpc still works
+      File.write!("lib/compile_env.ex", """
+      require Application
+      _ = Application.compile_env(:release_test, :static)
+      """)
+
+      Mix.Project.in_project(:release_test, ".", config, fn _ ->
+        Mix.Task.run("loadconfig", [])
+
+        # For compile env to be validated, we need a config/runtime.exs
+        File.write!("config/runtime.exs", """
+        import Config
+        """)
+
+        root = Path.absname("_build/dev/rel/permanent1")
+        Mix.Task.run("release")
+        script = Path.join(root, "bin/permanent1")
+
+        env = [{"RELEASE_DISTRIBUTION", "name"}, {"RELEASE_NODE", "permanent1@127.0.0.1"}]
+        open_port(script, [~c"start"], env)
+        wait_until_decoded(Path.join(root, "RELEASE_BOOTED"))
+
+        assert System.cmd(script, ["rpc", "ReleaseTest.hello_world()"], env: env) ==
+                 {"hello world\n", 0}
+
+        assert {pid, 0} = System.cmd(script, ["pid"], env: env)
+        assert pid != "\n"
+
+        assert System.cmd(script, ["stop"], env: env) == {"", 0}
+      end)
+    end)
+  end
+
+  test "runs eval and version commands" do
+    # In some Windows setups (mostly with Docker), `System.cmd/3` fails because
+    # the path to the command/executable and one or more arguments contain spaces.
+    tmp_dir = Path.join(inspect(__MODULE__), "runs_eval_and_version_commands")
+
+    in_fixture("release_test", tmp_dir, fn ->
+      config = [releases: [eval: [include_erts: false, cookie: "abcdefghij"]]]
+
+      Mix.Project.in_project(:release_test, ".", config, fn _ ->
+        File.write!("config/runtime.exs", """
+        import Config
+
+        config :release_test, :runtime, [mode: :code.get_mode()]
+
+        # Ensure app has been loaded
+        [_ | _] = Application.spec(:release_test, :modules)
+        """)
+
+        root = Path.absname("_build/dev/rel/eval")
+        Mix.Task.run("release")
+
+        script = Path.join(root, "bin/eval")
+        {version, 0} = System.cmd(script, ["version"])
+        assert String.trim_trailing(version) == "eval 0.1.0"
+        refute File.exists?(Path.join(root, "RELEASE_BOOTED"))
+
+        {hello_world, 0} = System.cmd(script, ["eval", "IO.puts :hello_world"])
+        assert String.trim_trailing(hello_world) == "hello_world"
+        refute File.exists?(Path.join(root, "RELEASE_BOOTED"))
+
+        {hello_world, 0} =
+          System.cmd(script, ["eval", "IO.inspect(System.argv( ))", "a", "b", "c"])
+
+        assert String.trim_trailing(hello_world) == ~S(["a", "b", "c"])
+        refute File.exists?(Path.join(root, "RELEASE_BOOTED"))
+
+        open_port(script, [~c"eval", ~c"Application.ensure_all_started(:release_test)"])
+
+        assert %{
+                 cookie_env: "abcdefghij",
+                 mode: :interactive,
+                 node: :nonode@nohost,
+                 protocols_consolidated?: true,
+                 release_name: "eval",
+                 release_node: "eval",
+                 release_prog: "eval" <> ext,
+                 release_root: release_root,
+                 release_vsn: "0.1.0",
+                 runtime_config: {:ok, [mode: :interactive]},
+                 static_config: {:ok, :was_set}
+               } = wait_until_decoded(Path.join(root, "RELEASE_BOOTED"))
+
+        if match?({:win32, _}, :os.type()) do
+          assert String.ends_with?(release_root, "eval")
+          assert ext == ".bat"
+        else
+          assert release_root == root
+          assert ext == ""
+        end
+      end)
+    end)
+  end
+
+  @tag :unix
+  test "runs in daemon mode" do
+    in_fixture("release_test", fn ->
+      config = [releases: [permanent2: [include_erts: false, cookie: "abcdefghij"]]]
+
+      Mix.Project.in_project(:release_test, ".", config, fn _ ->
+        root = Path.absname("_build/dev/rel/permanent2")
+        Mix.Task.run("release")
+
+        script = Path.join(root, "bin/permanent2")
+        env = [{"RELEASE_DISTRIBUTION", "name"}, {"RELEASE_NODE", "permanent2@127.0.0.1"}]
+        open_port(script, [~c"daemon_iex"], env)
+
+        assert %{
+                 app_dir: app_dir,
+                 cookie_env: "abcdefghij",
+                 mode: :embedded,
+                 node: :"permanent2@127.0.0.1",
+                 protocols_consolidated?: true,
+                 release_name: "permanent2",
+                 release_node: "permanent2@127.0.0.1",
+                 release_root: ^root,
+                 release_vsn: "0.1.0",
+                 root_dir: root_dir,
+                 runtime_config: :error,
+                 static_config: {:ok, :was_set},
+                 sys_config_env: sys_config_env,
+                 sys_config_init: sys_config_init
+               } = wait_until_decoded(Path.join(root, "RELEASE_BOOTED"))
+
+        assert app_dir == Path.join(root, "lib/release_test-0.1.0")
+        assert root_dir == :code.root_dir() |> to_string()
+        assert sys_config_env == Path.join(root, "releases/0.1.0/sys")
+        assert sys_config_init == Path.join(root, "releases/0.1.0/sys")
+
+        assert wait_until(fn ->
+                 File.read!(Path.join(root, "tmp/log/erlang.log.1")) =~
+                   "iex(permanent2@127.0.0.1)1> "
+               end)
+
+        assert System.cmd(script, ["rpc", "ReleaseTest.hello_world()"], env: env) ==
+                 {"hello world\n", 0}
+
+        assert System.cmd(script, ["restart"], env: env) == {"", 0}
+
+        assert wait_until(fn ->
+                 File.read!(Path.join(root, "tmp/log/erlang.log.1")) =~
+                   "RESTARTED!!!"
+               end)
+
+        assert System.cmd(script, ["stop"], env: env) == {"", 0}
+      end)
+    end)
+  end
+
+  test "requires confirmation if release already exists unless overwriting" do
+    in_fixture("release_test", fn ->
+      Mix.Project.in_project(:release_test, ".", fn _ ->
+        Mix.Task.rerun("release")
+        assert_received {:mix_shell, :info, ["* assembling release_test-0.1.0 on MIX_ENV=dev"]}
+
+        send(self(), {:mix_shell_input, :yes?, false})
+        Mix.Task.rerun("release")
+        refute_received {:mix_shell, :info, ["* assembling release_test-0.1.0 on MIX_ENV=dev"]}
+
+        assert_received {:mix_shell, :yes?,
+                         ["Release release_test-0.1.0 already exists. Overwrite?"]}
+
+        Mix.Task.rerun("release", ["--overwrite"])
+        assert_received {:mix_shell, :info, ["* assembling release_test-0.1.0 on MIX_ENV=dev"]}
+      end)
+    end)
+  end
+
+  @tag :unix
+  test "works properly with an absolute symlink to release" do
+    in_fixture("release_test", fn ->
+      Mix.Project.in_project(:release_test, ".", fn _ ->
+        Mix.Task.run("release")
+
+        File.ln_s!(
+          Path.absname("_build/#{Mix.env()}/rel/release_test/bin/release_test"),
+          Path.absname("release_test")
+        )
+
+        script = Path.absname("release_test")
+        {hello_world, 0} = System.cmd(script, ["eval", "IO.puts :hello_world"])
+        assert String.trim_trailing(hello_world) == "hello_world"
+      end)
+    end)
+  end
+
+  @tag :unix
+  test "works properly with a relative symlink to release" do
+    in_fixture("release_test", fn ->
+      Mix.Project.in_project(:release_test, ".", fn _ ->
+        Mix.Task.run("release")
+
+        File.mkdir!("bin")
+        File.ln_s!("../_build/#{Mix.env()}/rel/release_test/bin/release_test", "bin/release_test")
+
+        script = Path.absname("bin/release_test")
+        {hello_world, 0} = System.cmd(script, ["eval", "IO.puts :hello_world"])
+        assert String.trim_trailing(hello_world) == "hello_world"
+      end)
+    end)
+  end
+
+  defp open_port(command, args, env \\ []) do
+    env = for {k, v} <- env, do: {to_charlist(k), to_charlist(v)}
+    Port.open({:spawn_executable, to_charlist(command)}, [:hide, args: args, env: env])
+  end
+
+  defp wait_until_decoded(file) do
+    wait_until(fn ->
+      case File.read(file) do
+        {:ok, bin} when byte_size(bin) > 0 -> :erlang.binary_to_term(bin)
+        _ -> nil
+      end
+    end)
+  end
+
+  defp wait_until(fun) do
+    if value = fun.() do
+      value
+    else
+      Process.sleep(10)
+      wait_until(fun)
+    end
+  end
+end
diff --git a/lib/mix/test/mix/tasks/run_test.exs b/lib/mix/test/mix/tasks/run_test.exs
index 5425b857159..6b385c9c4c3 100644
--- a/lib/mix/test/mix/tasks/run_test.exs
+++ b/lib/mix/test/mix/tasks/run_test.exs
@@ -1,103 +1,157 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.RunTest do
   use MixTest.Case
 
-  import ExUnit.CaptureIO
-
-  defmodule GetApp do
-    def project do
-      [ app: :get_app,
-        version: "0.1.0",
-        deps: [
-          {:git_repo, "0.1.0", git: MixTest.Case.fixture_path("git_repo")}
-        ] ]
-    end
-  end
-
   setup do
-    Mix.Project.push MixTest.Case.Sample
+    Mix.Project.push(MixTest.Case.Sample)
   end
 
-  test "loads configuration" do
-    in_fixture "no_mixfile", fn ->
-      assert capture_io(fn ->
-        Mix.Task.run "run",
-          ["--config", fixture_path("configs/good_config.exs"),
-           "--eval", "IO.puts Application.get_env(:my_app, :key)"]
-      end) == "value\n"
-    end
-  after
-    Application.delete_env(:my_app, :key)
-  end
-
-  test "run requires files before evaling commands" do
+  test "run requires files before evaling commands", context do
     git_repo = fixture_path("git_repo/lib/git_repo.ex")
 
-    in_fixture "no_mixfile", fn ->
-      Mix.Tasks.Run.run ["-r", git_repo, "-e", "send self, {:hello, GitRepo.hello}"]
+    in_tmp(context.test, fn ->
+      Mix.Tasks.Run.run(["-r", git_repo, "-e", "send self(), {:hello, GitRepo.hello()}"])
       assert_received {:hello, "World"}
 
-      Mix.Tasks.Run.run ["-pr", git_repo, "-e", "send self, {:hello, GitRepo.hello}"]
+      Mix.Tasks.Run.run(["-pr", git_repo, "-e", "send self(), {:hello, GitRepo.hello()}"])
       assert_received {:hello, "World"}
-    end
+    end)
   after
-    purge [GitRepo]
+    purge([GitRepo])
   end
 
-  test "run errors on missing files" do
-    git_repo = fixture_path("git_repo/lib/git_repo.ex")
+  test "does not start applications on --no-start", context do
+    in_tmp(context.test, fn ->
+      expr = "send self(), {:apps, Application.started_applications()}"
+      Mix.Tasks.Run.run(["--no-start", "-e", expr])
+
+      assert_received {:apps, apps}
+      refute List.keyfind(apps, :sample, 0)
+      Mix.Task.clear()
+
+      Mix.Tasks.Run.run(["-e", expr])
+      assert_received {:apps, apps}
+      assert List.keyfind(apps, :sample, 0)
+    end)
+  end
+
+  test "run errors on missing files", context do
+    in_tmp(context.test, fn ->
+      message = "No files matched pattern \"non-existent\" given to --require"
 
-    in_fixture "no_mixfile", fn ->
-      assert_raise Mix.Error, "No files matched pattern \"non-existent\" given to --require", fn ->
-        Mix.Tasks.Run.run ["-r", "non-existent"]
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Run.run(["-r", "non-existent"])
       end
 
-      assert_raise Mix.Error, "No files matched pattern \"non-existent\" given to --parallel-require", fn ->
-        Mix.Tasks.Run.run ["-pr", "non-existent"]
+      assert_raise Mix.Error, message, fn ->
+        Mix.Tasks.Run.run(["-pr", "non-existent"])
       end
 
       assert_raise Mix.Error, "No such file: non-existent", fn ->
-        Mix.Tasks.Run.run ["non-existent"]
+        Mix.Tasks.Run.run(["non-existent"])
       end
 
-      assert File.dir?("lib")
+      File.mkdir_p!("lib")
+
       assert_raise Mix.Error, "No such file: lib", fn ->
-        Mix.Tasks.Run.run ["lib"]
+        Mix.Tasks.Run.run(["lib"])
       end
-    end
+    end)
   after
-    purge [GitRepo]
+    purge([GitRepo])
   end
 
-  test "run rewrites System.argv" do
-    in_fixture "no_mixfile", fn ->
+  test "run rewrites System.argv", context do
+    in_tmp(context.test, fn ->
       file = "argv.exs"
+      expr = "send self(), {:argv, System.argv()}"
+
+      File.write!(file, expr)
 
-      File.write! file, "send self, {:argv, System.argv}"
       unload_file = fn ->
-        Code.unload_files [Path.expand(file)]
+        Code.unrequire_files([Path.expand(file)])
       end
 
-      Mix.Tasks.Run.run [file]
+      Mix.Tasks.Run.run([file])
       assert_received {:argv, []}
 
       unload_file.()
-      Mix.Tasks.Run.run [file, "foo", "-e", "bar"]
+      Mix.Tasks.Run.run([file, "foo", "-e", "bar"])
       assert_received {:argv, ["foo", "-e", "bar"]}
 
       unload_file.()
-      Mix.Tasks.Run.run ["-e", "send self, {:argv, System.argv}", file, "foo", "-x", "bar"]
+      Mix.Tasks.Run.run([file, "foo", "--", "bar"])
+      assert_received {:argv, ["foo", "--", "bar"]}
+
+      unload_file.()
+      Mix.Tasks.Run.run([file, "--custom-opt", "foo", "--", "bar"])
+      assert_received {:argv, ["--custom-opt", "foo", "--", "bar"]}
+
+      unload_file.()
+      Mix.Tasks.Run.run(["-e", expr, file, "foo", "-x", "bar"])
       assert_received {:argv, [^file, "foo", "-x", "bar"]}
 
       unload_file.()
-      Mix.Tasks.Run.run [
-        "-e", "send self, :evaled",
-        "-e", "send self, {:argv, System.argv}",
-        "--no-compile", file, "-x", "bar"
-      ]
+
+      send_evaled = "send self(), :evaled"
+      Mix.Tasks.Run.run(["-e", send_evaled, "-e", expr, "--no-compile", file, "-x", "bar"])
+
       assert_received :evaled
       assert_received {:argv, [^file, "-x", "bar"]}
+    end)
+  end
+
+  defmodule AppArgvSample do
+    def project do
+      [app: :app_argv_sample, version: "0.1.0"]
+    end
+
+    def application do
+      send(self(), {:argv, System.argv()})
+      [extra_applications: [:logger]]
+    end
+  end
+
+  describe "rewrite System.argv without file arg" do
+    setup do
+      Mix.Project.pop()
+      Mix.Project.push(AppArgvSample)
+      :ok
+    end
+
+    test "no args" do
+      in_fixture("no_mixfile", fn ->
+        Mix.Tasks.Run.run(["--"])
+        assert_received {:argv, []}
+      end)
+    end
+
+    test "multiple args" do
+      in_fixture("no_mixfile", fn ->
+        Mix.Tasks.Run.run(["--", "foo", "bar"])
+        assert_received {:argv, ["foo", "bar"]}
+      end)
+    end
+
+    test "with opts" do
+      in_fixture("no_mixfile", fn ->
+        Mix.Tasks.Run.run(["--no-start", "--", "foo", "bar"])
+        assert_received {:argv, ["foo", "bar"]}
+      end)
+    end
+
+    test "with eval" do
+      in_fixture("no_mixfile", fn ->
+        expr = "send self(), {:test, :argv}"
+        Mix.Tasks.Run.run(["-e", expr, "--", "foo"])
+        assert_received {:argv, ["foo"]}
+        assert_received {:test, :argv}
+      end)
     end
   end
 end
diff --git a/lib/mix/test/mix/tasks/test_test.exs b/lib/mix/test/mix/tasks/test_test.exs
index 59fa20b0078..58de9b0f08a 100644
--- a/lib/mix/test/mix/tasks/test_test.exs
+++ b/lib/mix/test/mix/tasks/test_test.exs
@@ -1,28 +1,838 @@
-Code.require_file "../../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.TestTest do
   use MixTest.Case
 
-  import Mix.Tasks.Test, only: [ex_unit_opts: 1]
+  describe "ex_unit_opts/1" do
+    test "returns ex unit options" do
+      assert filtered_ex_unit_opts(unknown: "ok", seed: 13) == [seed: 13]
+    end
+
+    test "returns includes and excludes" do
+      included = [include: [:focus, key: "val"]]
+      assert filtered_ex_unit_opts(include: "focus", include: "key:val") == included
+
+      excluded = [exclude: [:focus, key: "val"]]
+      assert filtered_ex_unit_opts(exclude: "focus", exclude: "key:val") == excluded
+    end
+
+    test "translates :only into includes and excludes" do
+      assert filtered_ex_unit_opts(only: "focus") == [include: [:focus], exclude: [:test]]
+
+      only = [include: [:focus, :special], exclude: [:test]]
+      assert filtered_ex_unit_opts(only: "focus", include: "special") == only
+    end
+
+    test "translates :name_pattern into includes and excludes" do
+      assert [include: [test: hello_regex, test: world_regex], exclude: [:test]] =
+               filtered_ex_unit_opts(name_pattern: ~r/hello/, name_pattern: ~r/world/)
+
+      assert Regex.match?(hello_regex, "hello")
+      refute Regex.match?(hello_regex, "world")
+      refute Regex.match?(world_regex, "hello")
+      assert Regex.match?(world_regex, "world")
+    end
+
+    test "translates :color into list containing an enabled key-value pair" do
+      assert filtered_ex_unit_opts(color: false) == [colors: [enabled: false]]
+      assert filtered_ex_unit_opts(color: true) == [colors: [enabled: true]]
+    end
+
+    test "translates :formatter into list of modules" do
+      assert filtered_ex_unit_opts(formatter: "A.B") == [formatters: [A.B]]
+    end
+
+    test "accepts custom :exit_status" do
+      assert {:exit_status, 5} in ex_unit_opts(exit_status: 5, failures_manifest_path: "foo.bar")
+    end
+
+    test "includes some default options" do
+      assert ex_unit_opts(failures_manifest_path: "foo.bar") == [
+               autorun: false,
+               exit_status: 2,
+               failures_manifest_path: "foo.bar"
+             ]
+    end
+
+    defp ex_unit_opts(opts) do
+      {ex_unit_opts, _allowed_files} = Mix.Tasks.Test.process_ex_unit_opts(opts)
+      ex_unit_opts
+    end
+
+    defp filtered_ex_unit_opts(opts) do
+      opts
+      |> Keyword.put(:failures_manifest_path, "foo.bar")
+      |> ex_unit_opts()
+      |> Keyword.drop([:failures_manifest_path, :autorun, :exit_status])
+    end
+  end
+
+  describe "--stale" do
+    test "runs all tests for first run, then none on second" do
+      in_fixture("test_stale", fn ->
+        assert_stale_run_output("2 tests, 0 failures")
+
+        assert_stale_run_output("""
+        No stale tests
+        """)
+      end)
+    end
+
+    test "runs tests that depend on modified modules" do
+      in_fixture("test_stale", fn ->
+        assert_stale_run_output("2 tests, 0 failures")
+
+        set_all_mtimes()
+        force_recompilation("lib/b.ex")
+
+        assert_stale_run_output("1 test, 0 failures")
+
+        set_all_mtimes()
+        force_recompilation("lib/a.ex")
+
+        assert_stale_run_output("2 tests, 0 failures")
+      end)
+    end
+
+    test "doesn't write manifest when there are failures" do
+      in_fixture("test_stale", fn ->
+        assert_stale_run_output("2 tests, 0 failures")
 
-  test "ex_unit_opts returns ex unit options" do
-    assert ex_unit_opts([unknown: "ok", seed: 13]) ==
-           [autorun: false, seed: 13]
+        set_all_mtimes()
+
+        File.write!("lib/b.ex", """
+        defmodule B do
+          def f, do: :error
+        end
+        """)
+
+        assert_stale_run_output("1 test, 1 failure")
+
+        assert_stale_run_output("1 test, 1 failure")
+      end)
+    end
+
+    test "runs tests that have changed" do
+      in_fixture("test_stale", fn ->
+        assert_stale_run_output("2 tests, 0 failures")
+
+        set_all_mtimes()
+        File.touch!("test/a_test_stale.exs")
+
+        assert_stale_run_output("1 test, 0 failures")
+      end)
+    end
+
+    test "runs tests that have changed test_helpers" do
+      in_fixture("test_stale", fn ->
+        assert_stale_run_output("2 tests, 0 failures")
+
+        set_all_mtimes()
+        File.touch!("test/test_helper.exs")
+
+        assert_stale_run_output("2 tests, 0 failures")
+      end)
+    end
+
+    test "runs all tests no matter what with --force" do
+      in_fixture("test_stale", fn ->
+        assert_stale_run_output("2 tests, 0 failures")
+
+        assert_stale_run_output(~w[--force], "2 tests, 0 failures")
+      end)
+    end
   end
 
-  test "ex_unit_opts returns includes and excludes" do
-    assert ex_unit_opts([include: "focus", include: "key:val"]) ==
-           [autorun: false, include: [:focus, key: "val"]]
+  describe "--cover" do
+    @describetag :cover
+    test "reports the coverage of each app's modules in an umbrella" do
+      in_fixture("umbrella_test", fn ->
+        # This fixture by default results in coverage above the default threshold
+        # which should result in an exit status of 0.
+        assert {output, 0} = mix_code(["test", "--cover"])
+        assert output =~ "4 tests, 0 failures"
+
+        # For bar, we do regular --cover and also test protocols
+        assert output =~ """
+               Generating cover results ...
+
+               | Percentage | Module                 |
+               |------------|------------------------|
+               |    100.00% | Bar.Protocol           |
+               |    100.00% | Bar.Protocol.BitString |
+               |------------|------------------------|
+               |    100.00% | Total                  |
+               """
+
+        assert output =~ "1 test, 0 failures"
+
+        # For foo, we do regular --cover and test it does not include bar
+        assert output =~ """
+               Generating cover results ...
+
+               | Percentage | Module     |
+               |------------|------------|
+               |    100.00% | Foo        |
+               |------------|------------|
+               |    100.00% | Total      |
+               """
+
+        # We skip a test in bar to force coverage below the default threshold
+        # which should result in an exit status of 1.
+        assert {output, code} = mix_code(["test", "--cover", "--exclude", "maybe_skip"])
+
+        assert output =~ """
+               Coverage test failed, threshold not met:
+
+                   Coverage:    0.00%
+                   Threshold:  90.00%
+               """
+
+        assert code == 3
+      end)
+    end
+
+    test "supports unified reports by using test.coverage" do
+      in_fixture("umbrella_test", fn ->
+        assert mix(["test", "--export-coverage", "default", "--cover"]) =~
+                 "Run \"mix test.coverage\" once all exports complete"
+
+        assert mix(["test.coverage"]) =~ """
+               Importing cover results: apps/bar/cover/default.coverdata
+               Importing cover results: apps/foo/cover/default.coverdata
 
-    assert ex_unit_opts([exclude: "focus", exclude: "key:val"]) ==
-           [autorun: false, exclude: [:focus, key: "val"]]
+               | Percentage | Module                 |
+               |------------|------------------------|
+               |    100.00% | Bar                    |
+               |    100.00% | Bar.Ignore             |
+               |    100.00% | Bar.Protocol           |
+               |    100.00% | Bar.Protocol.BitString |
+               |    100.00% | Foo                    |
+               |------------|------------------------|
+               |    100.00% | Total                  |
+               """
+      end)
+    end
   end
 
-  test "ex_unit_opts translates only into includes and excludes" do
-    assert ex_unit_opts([only: "focus"]) ==
-           [autorun: false, exclude: [:test], include: [:focus]]
+  describe "--failed" do
+    test "loads only files with failures and runs just the failures" do
+      in_fixture("test_failed", fn ->
+        loading_only_passing_test_msg = "loading OnlyPassingTest"
+
+        # Run `mix test` once to record failures...
+        output = mix(["test"])
+        assert output =~ loading_only_passing_test_msg
+        assert output =~ "4 tests, 2 failures"
+
+        # `mix test --failed` runs only failed tests and avoids loading files with no failures
+        output = mix(["test", "--failed"])
+        refute output =~ loading_only_passing_test_msg
+        assert output =~ "2 tests, 2 failures"
+
+        # `mix test --failed` can be applied to a directory or file
+        output = mix(["test", "test/passing_and_failing_test_failed.exs", "--failed"])
+        assert output =~ "1 test, 1 failure"
+
+        # Plus line
+        output = mix(["test", "test/passing_and_failing_test_failed.exs:5", "--failed"])
+        assert output =~ "1 test, 1 failure"
+
+        if windows?() do
+          output = mix(["test", "test\\passing_and_failing_test_failed.exs:5", "--failed"])
+          assert output =~ "1 test, 1 failure"
+        end
+
+        # `--failed` composes with an `--only` filter by running the intersection.
+        # Of the failing tests, 1 is tagged with `@tag :foo`.
+        # Of the passing tests, 1 is tagged with `@tag :foo`.
+        # But only the failing test with that tag should run.
+        output = mix(["test", "--failed", "--only", "foo"])
+        assert output =~ "1 test, 1 failure (1 excluded)"
+
+        # Run again to give it a chance to record as passed
+        System.put_env("PASS_FAILING_TESTS", "true")
+        assert mix(["test", "--failed"]) =~ "2 tests, 0 failures"
+
+        # Nothing should get run if we try it again since everything is passing.
+        assert mix(["test", "--failed"]) =~ "There are no tests to run"
+
+        # When everything is passing and a file is passed, we return the proper message
+        output = mix(["test", "test/passing_and_failing_test_failed.exs", "--failed"])
+        assert output =~ "There are no tests to run"
+        refute output =~ "does not match"
+
+        # `--failed` and `--stale` cannot be combined
+        output = mix(["test", "--failed", "--stale"])
+        assert output =~ "Combining --failed and --stale is not supported"
+      end)
+    after
+      System.delete_env("PASS_FAILING_TESTS")
+    end
+
+    test "marks the whole suite as failed on compilation error" do
+      in_fixture("test_failed", fn ->
+        File.write!("test/passing_and_failing_test_failed.exs", "raise ~s(oops)")
+
+        output = mix(["test"])
+        assert output =~ "** (RuntimeError) oops"
+
+        output = mix(["test", "--failed"])
+        assert output =~ "** (RuntimeError) oops"
+      end)
+    end
+  end
+
+  describe "--listen-on-stdin" do
+    test "runs tests after input" do
+      in_fixture("test_stale", fn ->
+        port = mix_port(~w[test --stale --listen-on-stdin])
+
+        assert receive_until_match(port, "0 failures", "") =~ "2 tests"
+
+        Port.command(port, "\n")
+
+        assert receive_until_match(port, "Restarting...", "") =~ "Restarting..."
+      end)
+    end
+  end
+
+  describe "--partitions" do
+    @tag :cover
+    test "splits tests into partitions (with coverage)" do
+      in_fixture("test_stale", fn ->
+        assert mix(["test", "--partitions", "3", "--cover"], [{"MIX_TEST_PARTITION", "1"}]) =~
+                 "1 test, 0 failures"
+
+        assert mix(["test", "--partitions", "3", "--cover"], [{"MIX_TEST_PARTITION", "2"}]) =~
+                 "1 test, 0 failures"
+
+        assert mix(["test", "--partitions", "3", "--cover"], [{"MIX_TEST_PARTITION", "3"}]) =~
+                 "There are no tests to run"
+
+        assert File.regular?("cover/1.coverdata")
+        assert File.regular?("cover/2.coverdata")
+        refute File.regular?("cover/3.coverdata")
+
+        assert mix(["test.coverage"]) == """
+               Importing cover results: cover/1.coverdata
+               Importing cover results: cover/2.coverdata
+
+               | Percentage | Module     |
+               |------------|------------|
+               |    100.00% | A          |
+               |    100.00% | B          |
+               |------------|------------|
+               |    100.00% | Total      |
+
+               Generated HTML coverage results in \"cover\" directory
+               """
+      end)
+    end
+
+    test "raises when no partition is given even with Mix.shell() change" do
+      in_fixture("test_stale", fn ->
+        File.write!("test/test_helper.exs", """
+        Mix.shell(Mix.Shell.Process)
+        ExUnit.start()
+        """)
+
+        assert_run_output(
+          ["--partitions", "4"],
+          "The MIX_TEST_PARTITION environment variable must be set"
+        )
+      end)
+    end
+
+    test "do not raise if partitions flag is set to 1 and no partition given" do
+      in_fixture("test_stale", fn ->
+        assert mix(["test", "--partitions", "1"], []) =~
+                 "2 tests, 0 failures"
+
+        assert mix(["test", "--partitions", "1"], [{"MIX_TEST_PARTITION", ""}]) =~
+                 "2 tests, 0 failures"
+
+        assert mix(["test", "--partitions", "1"], [{"MIX_TEST_PARTITION", "1"}]) =~
+                 "2 tests, 0 failures"
+      end)
+    end
+
+    test "raise if partitions is set to non-positive value" do
+      in_fixture("test_stale", fn ->
+        File.write!("test/test_helper.exs", """
+        Mix.shell(Mix.Shell.Process)
+        ExUnit.start()
+        """)
+
+        assert_run_output(
+          ["--partitions", "0"],
+          "--partitions : expected to be positive integer, got 0"
+        )
+
+        assert_run_output(
+          ["--partitions", "-1"],
+          "--partitions : expected to be positive integer, got -1"
+        )
+      end)
+    end
+
+    test "runs after_suite with partitions with no tests" do
+      in_fixture("test_stale", fn ->
+        File.write!("test/test_helper.exs", """
+        ExUnit.after_suite(fn _stats -> IO.puts("AFTER SUITE") end)
+        ExUnit.start()
+        """)
+
+        assert mix(["test", "--partitions", "3"], [{"MIX_TEST_PARTITION", "3"}]) =~ """
+               AFTER SUITE
+               There are no tests to run
+               """
+      end)
+    end
+  end
+
+  describe "logs and errors" do
+    test "logs test absence for a project with no test paths" do
+      in_fixture("test_stale", fn ->
+        File.rm_rf!("test")
+        assert_run_output("There are no tests to run")
+
+        File.mkdir_p!("test")
+        File.write!("test/test_helper.exs", "ExUnit.start()")
+        assert_run_output("There are no tests to run")
+      end)
+    end
+
+    test "raises when no test runs even with Mix.shell() change" do
+      in_fixture("test_stale", fn ->
+        File.write!("test/test_helper.exs", """
+        Mix.shell(Mix.Shell.Process)
+        ExUnit.start()
+        """)
+
+        assert_run_output(
+          ["--only", "unknown"],
+          "The --only option was given to \"mix test\" but no test was executed"
+        )
+      end)
+    end
+
+    test "runs multiple test files if line numbers are given" do
+      in_fixture("test_stale", fn ->
+        assert_run_output(
+          ["test/a_test_stale.exs:2", "test/b_test_stale.exs:4"],
+          """
+          Excluding tags: [:test]
+          Including tags: [location: {"test/a_test_stale.exs", 2}, location: {"test/b_test_stale.exs", 4}]
+          """
+        )
+      end)
+    end
+
+    test "umbrella with file path" do
+      in_fixture("umbrella_test", fn ->
+        # Run false positive test first so at least the code is compiled
+        # and we can perform more aggressive assertions later
+        output = mix(["test", "apps/unknown_app/test"])
+
+        assert output =~ """
+               ==> bar
+               Paths given to "mix test" did not match any directory/file: apps/unknown_app/test
+               """
+
+        assert output =~ """
+               ==> foo
+               Paths given to "mix test" did not match any directory/file: apps/unknown_app/test
+               """
+
+        output = mix(["test", "apps/bar/test/bar_tests.exs"])
+
+        assert output =~ "==> bar"
+        assert output =~ "...."
+
+        refute output =~ "==> foo"
+        refute output =~ "Paths given to \"mix test\" did not match any directory/file"
+
+        output = mix(["test", "./apps/bar/test/bar_tests.exs"])
+
+        assert output =~ "==> bar"
+        assert output =~ "...."
+
+        refute output =~ "==> foo"
+        refute output =~ "Paths given to \"mix test\" did not match any directory/file"
+
+        output = mix(["test", Path.expand("apps/bar/test/bar_tests.exs")])
+
+        assert output =~ "==> bar"
+        assert output =~ "...."
+
+        refute output =~ "==> foo"
+        refute output =~ "Paths given to \"mix test\" did not match any directory/file"
+
+        output = mix(["test", "apps/bar/test/bar_tests.exs:10"])
+
+        assert output =~ "==> bar"
+
+        assert output =~ """
+               Excluding tags: [:test]
+               Including tags: [location: {"test/bar_tests.exs", 10}]
+
+               .
+               """
+
+        refute output =~ "==> foo"
+        refute output =~ "Paths given to \"mix test\" did not match any directory/file"
+
+        casing =
+          if windows?() do
+            "apps\\bar\\test\\bar_tests.exs:5"
+          else
+            "apps/bar/test/bar_tests.exs:5"
+          end
+
+        output = mix(["test", "apps/foo/test/foo_tests.exs:9", casing])
+
+        assert output =~ """
+               Excluding tags: [:test]
+               Including tags: [location: {"test/foo_tests.exs", 9}]
+               """
+
+        assert output =~ "1 test, 0 failures\n"
+
+        assert output =~ """
+               Excluding tags: [:test]
+               Including tags: [location: {"test/bar_tests.exs", 5}]
+               """
+
+        assert output =~ "1 test, 0 failures (3 excluded)\n"
+      end)
+    end
+  end
+
+  describe "--warnings-as-errors" do
+    test "fail with exit status 1 if warning in tests but tests pass" do
+      in_fixture("test_stale", fn ->
+        msg =
+          "Test suite aborted after successful execution due to warnings while using the --warnings-as-errors option"
+
+        refute mix(["test", "--warnings-as-errors"]) =~ msg
+
+        File.write!("lib/warning.ex", """
+        unused_compile_var = 1
+        """)
+
+        File.write!("test/warning_test_stale.exs", """
+        defmodule WarningTest do
+          use ExUnit.Case
+
+          test "warning" do
+            unused_test_var = 1
+          end
+        end
+        """)
+
+        {output, exit_status} =
+          mix_code(["test", "--warnings-as-errors", "test/warning_test_stale.exs"])
+
+        assert output =~ "variable \"unused_compile_var\" is unused"
+        assert output =~ "variable \"unused_test_var\" is unused"
+        assert output =~ msg
+        assert exit_status == 1
+      end)
+    end
+
+    test "fail with --exit-status + 1 if warning in tests and tests fail" do
+      in_fixture("test_stale", fn ->
+        File.write!("test/warning_test_warnings_as_errors_and_failures.exs", """
+        defmodule WarningsAsErrorsAndFailuresTest do
+          use ExUnit.Case
+
+          test "warning and failure" do
+            unused_test_var = 1
+            assert false
+          end
+        end
+        """)
+
+        {output, exit_status} =
+          mix_code([
+            "test",
+            "--warnings-as-errors",
+            "--exit-status",
+            "42",
+            "test/warning_test_warnings_as_errors_and_failures.exs"
+          ])
+
+        assert output =~ "variable \"unused_test_var\" is unused"
+        assert output =~ "1 failure"
+
+        assert exit_status == 43
+      end)
+    end
+
+    test "mark failed tests" do
+      in_fixture("test_failed", fn ->
+        File.write!("test/warning_test_failed.exs", """
+        defmodule WarningTest do
+          use ExUnit.Case
+
+          test "warning" do
+            unused_var = 123
+          end
+        end
+        """)
+
+        output = mix(["test", "--warnings-as-errors"])
+        assert output =~ "2 failures"
+        refute output =~ "Test suite aborted after successful execution"
+        output = mix(["test", "--failed"])
+        assert output =~ "2 failures"
+      end)
+    end
+
+    test "fail with exit status 1 if warning in test_helper.exs" do
+      in_fixture("test_stale", fn ->
+        File.write!("test/test_helper.exs", """
+        unused_var = 123
+
+        ExUnit.start()
+        """)
+
+        msg =
+          "Test suite aborted after successful execution due to warnings while using the --warnings-as-errors option"
+
+        {output, exit_status} = mix_code(["test", "--warnings-as-errors"])
+
+        assert output =~ "variable \"unused_var\" is unused"
+        assert output =~ msg
+        assert exit_status == 1
+      end)
+    end
+  end
+
+  describe "--exit-status" do
+    test "returns custom exit status" do
+      in_fixture("test_failed", fn ->
+        {output, exit_status} = mix_code(["test", "--exit-status", "5"])
+        assert output =~ "2 failures"
+        assert exit_status == 5
+      end)
+    end
+  end
+
+  describe "--max-requires" do
+    test "runs tests with --max-requires 1" do
+      # this is only a smoke test to ensure that tests run with --max-requires 1
+      # it does not test the concurrency behavior
+      in_fixture("test_stale", fn ->
+        output = mix(["test", "--max-requires", "1"])
+        assert output =~ "0 failures"
+      end)
+    end
+  end
+
+  describe "test_load_filters and test_ignore_filters" do
+    test "warns of files that are not loaded and don't match test_ignore_filters" do
+      in_tmp("test_warn", fn ->
+        File.write!("mix.exs", """
+        defmodule TestWarn.MixProject do
+          use Mix.Project
+
+          def project do
+            [
+              app: :test_warn,
+              version: "0.0.1",
+              test_load_filters: [~r/.*_tests\.exs/],
+              test_ignore_filters: [
+                "test/test_helper.exs",
+                ~r/ignored_regex/,
+                fn file -> file == "test/ignored_file.exs" end
+              ]
+            ]
+          end
+        end
+        """)
+
+        File.mkdir!("test")
+
+        File.write!("test/a_tests.exs", """
+        defmodule ATests do
+          use ExUnit.Case
+
+          test "dummy" do
+            assert true
+          end
+        end
+        """)
+
+        File.write!("test/test_helper.exs", "ExUnit.start()")
+        File.touch("test/a_missing.exs")
+        File.touch("test/a_tests.ex")
+        File.touch("test/ignored_file.exs")
+        File.touch("test/ignored_regex.exs")
+        File.write!("test/other_file.txt", "this is not a test file")
+
+        output = mix(["test"])
+
+        # This test relies on the files present in the test_warn fixture.
+        #
+        # We test that we don't warn about a_tests.exs, as it already matches the load pattern.
+        # Similarly, we ignore the empty but present ignored_file.exs and ignored_regex.exs.
+        # other_file.txt does not match the test_pattern and is ignored from the beginning.
+        #
+        # Therefore, we expect to get a warning for a_missing.exs and a_tests.ex.
+        assert output =~ """
+               the following files do not match any of the configured `:test_load_filters` / `:test_ignore_filters`:
+
+               test/a_missing.exs
+               test/a_tests.ex
+
+               This might indicate a typo\
+               """
+
+        # the dummy test ran successfully
+        assert output =~ "1 test, 0 failures"
+      end)
+    end
+
+    test "does not warn when test_ignore_filters are disabled" do
+      in_tmp("test_warn", fn ->
+        File.write!("mix.exs", """
+        defmodule TestWarn.MixProject do
+          use Mix.Project
+
+          def project do
+            [
+              app: :test_warn,
+              version: "0.0.1",
+              test_load_filters: [~r/.*_tests\.exs/],
+              test_ignore_filters: [fn _ -> true end]
+            ]
+          end
+        end
+        """)
+
+        File.mkdir!("test")
+
+        File.write!("test/a_tests.exs", """
+        defmodule ATests do
+          use ExUnit.Case
+
+          test "dummy" do
+            assert true
+          end
+        end
+        """)
+
+        File.write!("test/test_helper.exs", "ExUnit.start()")
+        File.touch("test/a_missing.exs")
+        File.touch("test/a_tests.ex")
+        File.touch("test/ignored_file.exs")
+        File.touch("test/ignored_regex.exs")
+        File.write!("test/other_file.txt", "this is not a test file")
+
+        output = mix(["test"])
+
+        refute output =~ "the following files do not match"
+
+        # the dummy test ran successfully
+        assert output =~ "1 test, 0 failures"
+      end)
+    end
+  end
+
+  describe "--dry-run" do
+    test "works with --stale" do
+      in_fixture("test_stale", fn ->
+        File.write!("test/dry_run_one_test_stale.exs", """
+        defmodule DryRunOneTest do
+          use ExUnit.Case
+
+          test "new test" do
+            assert true
+          end
+        end
+        """)
+
+        File.write!("test/dry_run_two_test_stale.exs", """
+        defmodule DryRunTwoTest do
+          use ExUnit.Case
+
+          @tag :skip
+          test "skipped test" do
+            assert true
+          end
+        end
+        """)
+
+        output = mix(["test", "--dry-run", "--stale"])
+        assert output =~ "Tests that would be executed:"
+        assert output =~ "test/a_test_stale.exs:4"
+        assert output =~ "test/b_test_stale.exs:4"
+        assert output =~ "test/dry_run_one_test_stale.exs:4"
+        refute output =~ "test/dry_run_two_test_stale.exs:5"
+        assert output =~ "1 test, 0 failures, 1 skipped"
+
+        # Tests should still be marked as stale
+        output = mix(["test", "--dry-run", "--stale"])
+        assert output =~ "1 test, 0 failures, 1 skipped"
+      end)
+    end
+
+    test "works with --failed" do
+      in_fixture("test_failed", fn ->
+        output = mix(["test"])
+        assert output =~ "4 tests, 2 failures"
+
+        output = mix(["test", "--dry-run", "--failed"])
+        assert output =~ "Tests that would be executed:"
+        assert output =~ "test/only_failing_test_failed.exs:4"
+        assert output =~ "test/passing_and_failing_test_failed.exs:5"
+        assert output =~ "0 tests, 0 failures"
+
+        # Force the tests to pass, verify dry-run doesn't actually run them
+        System.put_env("PASS_FAILING_TESTS", "true")
+        output = mix(["test", "--dry-run", "--failed"])
+        assert output =~ "0 tests, 0 failures"
+      end)
+    after
+      System.delete_env("PASS_FAILING_TESTS")
+    end
+  end
+
+  defp receive_until_match(port, expected, acc) do
+    receive do
+      {^port, {:data, output}} ->
+        acc = acc <> output
+
+        if output =~ expected do
+          acc
+        else
+          receive_until_match(port, expected, acc)
+        end
+    after
+      15_000 ->
+        raise """
+        nothing received from port after 15s.
+        Expected: #{inspect(expected)}
+        Got: #{inspect(acc)}
+        """
+    end
+  end
+
+  defp set_all_mtimes(time \\ {{2010, 1, 1}, {0, 0, 0}}) do
+    Enum.each(Path.wildcard("**", match_dot: true), &File.touch!(&1, time))
+  end
+
+  defp assert_stale_run_output(opts \\ [], expected) do
+    assert_run_output(["--stale" | opts], expected)
+  end
 
-    assert ex_unit_opts([only: "focus", include: "special"]) ==
-           [autorun: false, exclude: [:test], include: [:focus, :special]]
+  defp assert_run_output(opts \\ [], expected) do
+    assert mix(["test" | opts]) =~ expected
   end
 end
diff --git a/lib/mix/test/mix/tasks/will_recompile_test.exs b/lib/mix/test/mix/tasks/will_recompile_test.exs
new file mode 100644
index 00000000000..f6c6ddf900d
--- /dev/null
+++ b/lib/mix/test/mix/tasks/will_recompile_test.exs
@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.WillRecompileTest do
+  use MixTest.Case
+
+  test "marks current project to recompile" do
+    in_fixture("deps_status/deps/ok", fn ->
+      Mix.Project.in_project(:ok, ".", fn _ ->
+        refute File.exists?("_build/dev/lib/ok/.mix/compile.lock")
+        Mix.Task.run("will_recompile")
+        assert File.exists?("_build/dev/lib/ok/.mix/compile.lock")
+      end)
+    end)
+  end
+
+  test "marks all projects in umbrella to recompile including the root itself" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        refute File.exists?("_build/dev/.mix/compile.lock")
+        refute File.exists?("_build/dev/lib/foo/.mix/compile.lock")
+        refute File.exists?("_build/dev/lib/bar/.mix/compile.lock")
+        Mix.Task.run("will_recompile")
+        assert File.exists?("_build/dev/.mix/compile.lock")
+        assert File.exists?("_build/dev/lib/foo/.mix/compile.lock")
+        assert File.exists?("_build/dev/lib/bar/.mix/compile.lock")
+      end)
+    end)
+  end
+end
diff --git a/lib/mix/test/mix/tasks/xref_test.exs b/lib/mix/test/mix/tasks/xref_test.exs
new file mode 100644
index 00000000000..a12b4c849ef
--- /dev/null
+++ b/lib/mix/test/mix/tasks/xref_test.exs
@@ -0,0 +1,1351 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../../test_helper.exs", __DIR__)
+
+defmodule Mix.Tasks.XrefTest do
+  use MixTest.Case
+
+  import ExUnit.CaptureIO
+
+  setup_all do
+    previous = Application.get_env(:elixir, :ansi_enabled, false)
+    Application.put_env(:elixir, :ansi_enabled, false)
+    on_exit(fn -> Application.put_env(:elixir, :ansi_enabled, previous) end)
+  end
+
+  setup do
+    Mix.Project.push(MixTest.Case.Sample)
+    :ok
+  end
+
+  describe "calls/1" do
+    test "returns all function calls" do
+      files = %{
+        "lib/a.ex" => """
+        defmodule A do
+          def a, do: A.a()
+          def a(arg), do: A.a(arg)
+          def c, do: B.a()
+        end
+        """,
+        "lib/b.ex" => """
+        defmodule B do
+          def a, do: nil
+        end
+        """
+      }
+
+      output = [
+        %{callee: {A, :a, 0}, caller_module: A, file: "lib/a.ex", line: 2},
+        %{callee: {A, :a, 1}, caller_module: A, file: "lib/a.ex", line: 3},
+        %{callee: {B, :a, 0}, caller_module: A, file: "lib/a.ex", line: 4}
+      ]
+
+      assert_all_calls(files, output)
+    end
+
+    test "returns function call inside expanded macro" do
+      files = %{
+        "lib/a.ex" => """
+        defmodule A do
+          defmacro a_macro(x) do
+            quote do
+              A.b(unquote(x))
+            end
+          end
+          def b(x), do: x
+        end
+        """,
+        "lib/b.ex" => """
+        defmodule B do
+          require A
+          def a, do: A.a_macro(1)
+        end
+        """
+      }
+
+      output = [
+        %{callee: {A, :b, 1}, caller_module: B, file: "lib/b.ex", line: 3},
+        %{
+          callee: {:elixir_quote, :shallow_validate_ast, 1},
+          caller_module: A,
+          file: "lib/a.ex",
+          line: 4
+        }
+      ]
+
+      assert_all_calls(files, output)
+    end
+
+    defp assert_all_calls(files, expected, after_compile \\ fn -> :ok end) do
+      in_fixture("no_mixfile", fn ->
+        generate_files(files)
+
+        Mix.Task.run("compile")
+        after_compile.()
+        xref = String.to_atom("Elixir.Mix.Tasks.Xref")
+        assert Enum.sort(xref.calls()) == Enum.sort(expected)
+      end)
+    end
+  end
+
+  describe "mix xref callers MODULE" do
+    @callers_files %{
+      "lib/a.ex" => """
+      defmodule A do
+        def a, do: :ok
+      end
+      """,
+      "lib/b.ex" => """
+      defmodule B do
+        def b, do: A.a()
+      end
+      """
+    }
+
+    @callers_output """
+    Compiling 2 files (.ex)
+    Generated sample app
+    lib/b.ex (runtime)
+    """
+
+    test "prints callers of specified Module" do
+      assert_callers("A", @callers_files, @callers_output)
+    end
+
+    test "filter by compile-connected label with fail-above" do
+      message = "Too many references (found: 1, permitted: 0)"
+
+      assert_raise Mix.Error, message, fn ->
+        assert_callers(~w[--fail-above 0], "A", @callers_files, @callers_output)
+      end
+    end
+
+    test "handles aliases" do
+      files = %{
+        "lib/a.ex" => """
+        defmodule A do
+          alias Enum, as: E
+
+          def a(a, b), do: E.map(a, b)
+
+          @file "lib/external_source.ex"
+          def b() do
+            alias Enum, as: EE
+            EE.map([], &EE.flatten/1)
+          end
+        end
+        """
+      }
+
+      output = """
+      Compiling 2 files (.ex)
+      Generated sample app
+      lib/a.ex (runtime)
+      """
+
+      assert_callers("Enum", files, output)
+    end
+
+    test "handles imports" do
+      files = %{
+        "lib/a.ex" => ~S"""
+        defmodule A do
+          import Integer
+          &is_even/1
+        end
+        """,
+        "lib/b.ex" => ~S"""
+        defmodule B do
+          import Integer
+          parse("1")
+        end
+        """
+      }
+
+      output = """
+      Compiling 2 files (.ex)
+      Generated sample app
+      lib/a.ex (compile)
+      lib/b.ex (compile)
+      """
+
+      assert_callers("Integer", files, output)
+    end
+
+    test "no argument gives error" do
+      in_fixture("no_mixfile", fn ->
+        message =
+          "No argument was given to xref command. Run \"mix help xref\" for more information"
+
+        assert_raise Mix.Error, message, fn ->
+          assert Mix.Task.run("xref", ["callers"]) == :error
+        end
+      end)
+    end
+
+    test "callers: gives nice error for quotable but invalid callers spec" do
+      in_fixture("no_mixfile", fn ->
+        message = "xref callers MODULE expects a MODULE, got: Module.func(arg)"
+
+        assert_raise Mix.Error, message, fn ->
+          Mix.Task.run("xref", ["callers", "Module.func(arg)"])
+        end
+      end)
+    end
+
+    test "gives nice error for unquotable callers spec" do
+      in_fixture("no_mixfile", fn ->
+        message = "xref callers MODULE expects a MODULE, got: %"
+
+        assert_raise Mix.Error, message, fn ->
+          Mix.Task.run("xref", ["callers", "%"])
+        end
+      end)
+    end
+
+    defp assert_callers(args \\ [], module, files, expected) do
+      in_fixture("no_mixfile", fn ->
+        for {file, contents} <- files do
+          File.write!(file, contents)
+        end
+
+        capture_io(:stderr, fn ->
+          assert Mix.Task.run("xref", args ++ ["callers", module]) == :ok
+        end)
+
+        assert ^expected = receive_until_no_messages([])
+      end)
+    end
+  end
+
+  describe "mix xref trace FILE" do
+    test "shows labelled traces" do
+      files = %{
+        "lib/a.ex" => ~S"""
+        defmodule A do
+          defstruct [:foo, :bar]
+          defmacro macro, do: :ok
+          def fun, do: :ok
+        end
+        """,
+        "lib/b.ex" => ~S"""
+        defmodule B do
+          import A
+          A.macro()
+          macro()
+          A.fun()
+          fun()
+          def calls_macro, do: A.macro()
+          def calls_fun, do: A.fun()
+          def calls_struct, do: %A{}
+        end
+        """
+      }
+
+      output = """
+      Compiling 2 files (.ex)
+      Generated sample app
+      lib/b.ex:2: require A (export)
+      lib/b.ex:3: call A.macro/0 (compile)
+      lib/b.ex:4: import call A.macro/0 (compile)
+      lib/b.ex:5: call A.fun/0 (compile)
+      lib/b.ex:6: import call A.fun/0 (compile)
+      lib/b.ex:7: call A.macro/0 (compile)
+      lib/b.ex:8: call A.fun/0 (runtime)
+      lib/b.ex:9: struct A (export)
+      """
+
+      assert_trace("lib/b.ex", files, output)
+    end
+
+    test "ignores dependencies from patterns and guards" do
+      files = %{
+        "lib/a.ex" => ~S"""
+        defmodule A do
+          defstruct [:foo, :bar]
+        end
+        """,
+        "lib/b.ex" => ~S"""
+        defmodule B do
+          def pattern(A), do: true
+          def guard(a) when is_struct(a, A), do: true
+        end
+        """
+      }
+
+      output = """
+      Compiling 2 files (.ex)
+      Generated sample app
+      """
+
+      assert_trace("lib/b.ex", files, output)
+    end
+
+    test "shows traces for module callbacks" do
+      files = %{
+        "lib/a.ex" => ~S"""
+        defmodule A do
+          @before_compile :"Elixir.B"
+          @after_compile :"Elixir.B"
+          @after_verify :"Elixir.B"
+        end
+        """,
+        "lib/b.ex" => ~S"""
+        defmodule B do
+          defmacro __before_compile__(_env), do: :ok
+          defmacro __after_compile__(_env, _binary), do: :ok
+          def __after_verify__(_module), do: :ok
+        end
+        """
+      }
+
+      output = """
+      Compiling 2 files (.ex)
+      Generated sample app
+      lib/a.ex:1: call B.__after_compile__/2 (compile)
+      lib/a.ex:1: call B.__after_verify__/1 (compile)
+      lib/a.ex:1: call B.__before_compile__/1 (compile)
+      """
+
+      assert_trace("lib/a.ex", files, output)
+    end
+
+    test "shows module with `@behaviour` calling `behaviour_info/1`" do
+      files = %{
+        "lib/a.ex" => ~S"""
+        defmodule A do
+          @callback fun() :: integer
+        end
+        """,
+        "lib/b.ex" => ~S"""
+        defmodule B do
+          @behaviour :"Elixir.A"
+          def fun, do: 42
+        end
+        """
+      }
+
+      output = """
+      Compiling 2 files (.ex)
+      Generated sample app
+      lib/b.ex:1: call A.behaviour_info/1 (runtime)
+      """
+
+      assert_trace("lib/b.ex", files, output)
+    end
+
+    test "filters per label" do
+      files = %{
+        "lib/a.ex" => ~S"""
+        defmodule A do
+          defmacro macro, do: :ok
+          def fun, do: :ok
+        end
+        """,
+        "lib/b.ex" => ~S"""
+        defmodule B do
+          require A
+          def calls_macro, do: A.macro()
+          def calls_fun, do: A.fun()
+        end
+        """
+      }
+
+      output = """
+      Compiling 2 files (.ex)
+      Generated sample app
+      lib/b.ex:3: call A.macro/0 (compile)
+      """
+
+      assert_trace(~w[--label compile], "lib/b.ex", files, output)
+    end
+
+    test "fails if above limit per label" do
+      files = %{
+        "lib/a.ex" => ~S"""
+        defmodule A do
+          defmacro macro, do: :ok
+          def fun, do: :ok
+        end
+        """,
+        "lib/b.ex" => ~S"""
+        defmodule B do
+          require A
+          def calls_macro, do: A.macro()
+          def calls_fun, do: A.fun()
+        end
+        """
+      }
+
+      output = """
+      Compiling 2 files (.ex)
+      Generated sample app
+      lib/b.ex:3: call A.macro/0 (compile)
+      """
+
+      message = "Too many traces (found: 1, permitted: 0)"
+
+      assert_raise Mix.Error, message, fn ->
+        assert_trace(~w[--label compile --fail-above 0], "lib/b.ex", files, output)
+      end
+    end
+
+    defp assert_trace(args \\ [], file, files, expected) do
+      in_fixture("no_mixfile", fn ->
+        for {file, contents} <- files do
+          File.write!(file, contents)
+        end
+
+        capture_io(:stderr, fn ->
+          assert Mix.Task.run("xref", args ++ ["trace", file]) == :ok
+        end)
+
+        assert receive_until_no_messages([]) == expected
+      end)
+    end
+  end
+
+  describe "mix xref graph" do
+    test "basic usage" do
+      assert_graph("""
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      lib/b.ex
+      |-- lib/a.ex
+      |-- lib/c.ex
+      `-- lib/e.ex (compile)
+      lib/c.ex
+      `-- lib/d.ex (compile)
+      lib/d.ex
+      `-- lib/e.ex
+      lib/e.ex
+      """)
+    end
+
+    test "stats" do
+      assert_graph(["--format", "stats"], """
+      Tracked files: 5 (nodes)
+      Compile dependencies: 3 (edges)
+      Exports dependencies: 0 (edges)
+      Runtime dependencies: 3 (edges)
+      Cycles: 1
+
+      Top 5 files with most outgoing dependencies:
+        * lib/b.ex (3)
+        * lib/d.ex (1)
+        * lib/c.ex (1)
+        * lib/a.ex (1)
+        * lib/e.ex (0)
+
+      Top 5 files with most incoming dependencies:
+        * lib/e.ex (2)
+        * lib/d.ex (1)
+        * lib/c.ex (1)
+        * lib/b.ex (1)
+        * lib/a.ex (1)
+      """)
+    end
+
+    test "stats with compile label" do
+      assert_graph(["--format", "stats", "--label", "compile"], """
+      Tracked files: 5 (nodes)
+      Compile dependencies: 3 (edges)
+      Exports dependencies: 0 (edges)
+      Runtime dependencies: 3 (edges)
+      Cycles: 1
+
+      Top 5 files with most outgoing dependencies:
+        * lib/c.ex (1)
+        * lib/b.ex (1)
+        * lib/a.ex (1)
+        * lib/e.ex (0)
+        * lib/d.ex (0)
+
+      Top 5 files with most incoming dependencies:
+        * lib/e.ex (1)
+        * lib/d.ex (1)
+        * lib/b.ex (1)
+        * lib/c.ex (0)
+        * lib/a.ex (0)
+      """)
+    end
+
+    test "stats with compile-connected label" do
+      assert_graph(["--format", "stats", "--label", "compile-connected"], """
+      Tracked files: 5 (nodes)
+      Compile dependencies: 3 (edges)
+      Exports dependencies: 0 (edges)
+      Runtime dependencies: 3 (edges)
+      Cycles: 1
+
+      Top 5 files with most outgoing dependencies:
+        * lib/c.ex (1)
+        * lib/b.ex (1)
+        * lib/a.ex (1)
+        * lib/e.ex (0)
+        * lib/d.ex (0)
+
+      Top 5 files with most incoming dependencies:
+        * lib/d.ex (1)
+        * lib/b.ex (1)
+        * lib/e.ex (0)
+        * lib/c.ex (0)
+        * lib/a.ex (0)
+      """)
+    end
+
+    test "cycles" do
+      assert_graph(["--format", "cycles"], """
+      1 cycles found. Showing them in decreasing size:
+
+      Cycle of length 2 (1 compile):
+
+          lib/a.ex (compile)
+          lib/b.ex
+
+      """)
+    end
+
+    test "cycles with compile label require at least one of such type" do
+      assert_graph(["--format", "cycles", "--label", "compile"], """
+      1 cycles found. Showing them in decreasing size:
+
+      Cycle of length 2 (1 compile):
+
+          lib/a.ex (compile)
+          lib/b.ex
+
+      """)
+    end
+
+    test "cycles with compile-connected label is the same as compile" do
+      assert_graph(["--format", "cycles", "--label", "compile-connected"], """
+      1 cycles found. Showing them in decreasing size:
+
+      Cycle of length 2 (1 compile):
+
+          lib/a.ex (compile)
+          lib/b.ex
+
+      """)
+    end
+
+    test "cycles with `--fail-above`" do
+      message = "Too many cycles (found: 1, permitted: 0)"
+
+      assert_raise Mix.Error, message, fn ->
+        assert_graph(["--format", "cycles", "--fail-above", "0"], """
+        1 cycles found. Showing them in decreasing size:
+
+        Cycle of length 2 (1 compile):
+
+            lib/a.ex (compile)
+            lib/b.ex
+
+        """)
+      end
+    end
+
+    test "cycles with min_cycle_label matching actual length" do
+      assert_graph(["--format", "cycles", "--label", "compile", "--min-cycle-label", "1"], """
+      1 cycles found. Showing them in decreasing size:
+
+      Cycle of length 2 (1 compile):
+
+          lib/a.ex (compile)
+          lib/b.ex
+
+      """)
+    end
+
+    test "cycles with min_cycle_size matching actual length" do
+      assert_graph(["--format", "cycles", "--min-cycle-size", "2"], """
+      1 cycles found. Showing them in decreasing size:
+
+      Cycle of length 2 (1 compile):
+
+          lib/a.ex (compile)
+          lib/b.ex
+
+      """)
+    end
+
+    test "cycles with min_cycle_label greater than actual length" do
+      assert_graph(["--format", "cycles", "--label", "compile", "--min-cycle-label", "2"], """
+      No cycles found
+      """)
+    end
+
+    test "cycles with min_cycle_size greater than actual length" do
+      assert_graph(["--format", "cycles", "--min-cycle-size", "3"], """
+      No cycles found
+      """)
+    end
+
+    test "unknown label" do
+      assert_raise Mix.Error, "Unknown --label bad in mix xref graph", fn ->
+        assert_graph(["--label", "bad"], "")
+      end
+    end
+
+    test "unknown format" do
+      assert_raise Mix.Error, "Unknown --format bad in mix xref graph", fn ->
+        assert_graph(["--format", "bad"], "")
+      end
+    end
+
+    test "exclude many" do
+      assert_graph(~w[--exclude lib/c.ex --exclude lib/b.ex], """
+      lib/a.ex
+      lib/d.ex
+      `-- lib/e.ex
+      lib/e.ex
+      """)
+    end
+
+    test "exclude one" do
+      assert_graph(~w[--exclude lib/d.ex], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      lib/b.ex
+      |-- lib/a.ex
+      |-- lib/c.ex
+      `-- lib/e.ex (compile)
+      lib/c.ex
+      lib/e.ex
+      """)
+    end
+
+    @abc_linear_files %{
+      "lib/a.ex" => "defmodule A, do: def(a, do: B.b())",
+      "lib/b.ex" => "defmodule B, do: def(b, do: C.c())",
+      "lib/c.ex" => "defmodule C, do: def(c, do: true)"
+    }
+
+    test "exclude one from linear case" do
+      assert_graph(
+        ~w[--exclude lib/b.ex],
+        """
+        lib/a.ex
+        lib/c.ex
+        """,
+        files: @abc_linear_files
+      )
+    end
+
+    test "exclude one with source from linear case" do
+      assert_graph(
+        ~w[--exclude lib/b.ex --source lib/a.ex],
+        """
+        lib/a.ex
+        """,
+        files: @abc_linear_files
+      )
+    end
+
+    test "invalid exclude" do
+      assert_raise Mix.Error, "Excluded files could not be found: lib/a2.ex, lib/a3.ex", fn ->
+        assert_graph(~w[--exclude lib/a2.ex --exclude lib/a.ex --exclude lib/a3.ex], "")
+      end
+    end
+
+    test "only nodes" do
+      assert_graph(~w[--only-nodes], """
+      lib/a.ex
+      lib/b.ex
+      lib/c.ex
+      lib/d.ex
+      lib/e.ex
+      """)
+    end
+
+    test "only nodes with compile direct label" do
+      assert_graph(~w[--label compile --only-direct --only-nodes], """
+      lib/a.ex
+      lib/b.ex
+      lib/c.ex
+      """)
+    end
+
+    test "filter by compile label" do
+      assert_graph(~w[--label compile], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      lib/b.ex
+      `-- lib/e.ex (compile)
+      lib/c.ex
+      `-- lib/d.ex (compile)
+      """)
+    end
+
+    test "filter by compile-connected label" do
+      assert_graph(~w[--label compile-connected], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      lib/c.ex
+      `-- lib/d.ex (compile)
+      """)
+    end
+
+    test "filter by compile-connected label with exclusions" do
+      assert_graph(~w[--label compile-connected --exclude lib/e.ex], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      """)
+    end
+
+    test "filter by compile-connected label with fail-above" do
+      message = "Too many references (found: 2, permitted: 1)"
+
+      assert_raise Mix.Error, message, fn ->
+        assert_graph(~w[--label compile-connected --fail-above 1], """
+        lib/a.ex
+        `-- lib/b.ex (compile)
+        lib/c.ex
+        `-- lib/d.ex (compile)
+        """)
+      end
+    end
+
+    test "exclude many with fail-above" do
+      message = "Too many references (found: 1, permitted: 0)"
+
+      assert_raise Mix.Error, message, fn ->
+        assert_graph(~w[--exclude lib/c.ex --exclude lib/b.ex --fail-above 0], """
+        lib/a.ex
+        lib/d.ex
+        `-- lib/e.ex
+        lib/e.ex
+        """)
+      end
+    end
+
+    test "filter by compile direct label" do
+      assert_graph(~w[--label compile --only-direct], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      lib/b.ex
+      `-- lib/e.ex (compile)
+      lib/c.ex
+      `-- lib/d.ex (compile)
+      """)
+    end
+
+    test "filter by runtime label" do
+      assert_graph(~w[--label runtime], """
+      lib/b.ex
+      |-- lib/a.ex
+      `-- lib/c.ex
+      lib/d.ex
+      `-- lib/e.ex
+      """)
+    end
+
+    test "sources" do
+      assert_graph(
+        ~w[--source lib/a.ex --source lib/c.ex],
+        """
+        lib/a.ex
+        `-- lib/b.ex (compile)
+            |-- lib/a.ex
+            |-- lib/c.ex
+            `-- lib/e.ex (compile)
+        lib/c.ex
+        `-- lib/d.ex (compile)
+            `-- lib/e.ex
+
+        WARNING: Source lib/a.ex is part of a cycle of 2 nodes and this cycle has a compile \
+        dependency. Therefore source and the whole cycle will recompile whenever any of the \
+        files they depend on change. Run "mix xref graph --format stats --label compile-connected" \
+        to print compilation cycles and "mix help xref" for information on removing them
+        """,
+        warnings: true
+      )
+    end
+
+    test "source with compile label" do
+      assert_graph(~w[--source lib/a.ex --label compile], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+          `-- lib/e.ex (compile)
+      """)
+    end
+
+    test "source with compile-connected label" do
+      assert_graph(~w[--source lib/a.ex --label compile-connected], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      """)
+    end
+
+    test "source with compile direct label" do
+      assert_graph(~w[--source lib/a.ex --label compile --only-direct], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+          `-- lib/e.ex (compile)
+      """)
+    end
+
+    test "invalid sources" do
+      assert_raise Mix.Error, "Sources could not be found: lib/a2.ex, lib/a3.ex", fn ->
+        assert_graph(~w[--source lib/a2.ex --source lib/a.ex --source lib/a3.ex], "")
+      end
+    end
+
+    test "sink" do
+      assert_graph(~w[--sink lib/e.ex], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      lib/b.ex
+      |-- lib/a.ex
+      |-- lib/c.ex
+      `-- lib/e.ex (compile)
+      lib/c.ex
+      `-- lib/d.ex (compile)
+      lib/d.ex
+      `-- lib/e.ex
+      """)
+    end
+
+    test "sink with compile label" do
+      assert_graph(~w[--sink lib/e.ex --label compile], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      lib/b.ex
+      `-- lib/e.ex (compile)
+      lib/c.ex
+      `-- lib/d.ex (compile)
+      """)
+    end
+
+    test "sink with compile-connected label" do
+      assert_graph(~w[--sink lib/e.ex --label compile-connected], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      lib/c.ex
+      `-- lib/d.ex (compile)
+      """)
+    end
+
+    test "sink with compile direct label" do
+      assert_graph(~w[--sink lib/e.ex --label compile --only-direct], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+      lib/b.ex
+      `-- lib/e.ex (compile)
+      """)
+    end
+
+    test "multiple sinks" do
+      assert_graph(~w[--sink lib/a.ex --sink lib/c.ex], """
+      lib/b.ex
+      |-- lib/a.ex
+      |   `-- lib/b.ex (compile)
+      `-- lib/c.ex
+      """)
+    end
+
+    test "multiple sinks with only nodes" do
+      assert_graph(~w[--sink lib/a.ex --sink lib/c.ex --sink lib/e.ex --only-nodes], """
+      lib/b.ex
+      lib/d.ex
+      """)
+    end
+
+    test "invalid sink" do
+      assert_raise Mix.Error, "Sinks could not be found: lib/b2.ex, lib/b3.ex", fn ->
+        assert_graph(~w[--sink lib/b2.ex --sink lib/b.ex --sink lib/b3.ex], "")
+      end
+    end
+
+    test "sink and source" do
+      assert_graph(~w[--source lib/a.ex --sink lib/b.ex], """
+      lib/a.ex
+      `-- lib/b.ex (compile)
+          `-- lib/a.ex
+      """)
+    end
+
+    test "with dynamic module" do
+      in_fixture("no_mixfile", fn ->
+        File.write!("lib/a.ex", """
+        B.define()
+        """)
+
+        File.write!("lib/b.ex", """
+        defmodule B do
+          def define do
+            defmodule A do
+            end
+          end
+        end
+        """)
+
+        assert Mix.Task.run("xref", ["graph", "--format", "dot"]) == :ok
+
+        assert File.read!("xref_graph.dot") === """
+               digraph "xref graph" {
+                 "lib/a.ex"
+                 "lib/a.ex" -> "lib/b.ex" [label="(compile)"]
+                 "lib/b.ex"
+               }
+               """
+
+        assert Mix.Task.run("xref", ["graph", "--format", "json", "--output", "xref_graph.json"]) ==
+                 :ok
+
+        assert File.read!("xref_graph.json") ===
+                 String.trim_trailing("""
+                 {"lib/a.ex":{"lib/b.ex":"compile"},"lib/b.ex":{}}
+                 """)
+      end)
+    end
+
+    test "with export" do
+      in_fixture("no_mixfile", fn ->
+        File.write!("lib/a.ex", """
+        defmodule A do
+          def fun do
+            %B{}
+          end
+        end
+        """)
+
+        File.write!("lib/b.ex", """
+        defmodule B do
+          defstruct []
+        end
+        """)
+
+        assert Mix.Task.run("xref", ["graph", "--format", "dot"]) == :ok
+
+        assert File.read!("xref_graph.dot") === """
+               digraph "xref graph" {
+                 "lib/a.ex"
+                 "lib/a.ex" -> "lib/b.ex" [label="(export)"]
+                 "lib/b.ex"
+               }
+               """
+
+        assert Mix.Task.run("xref", ["graph", "--format", "json", "--output", "xref_graph.json"]) ==
+                 :ok
+
+        assert File.read!("xref_graph.json") ===
+                 String.trim_trailing("""
+                 {"lib/a.ex":{"lib/b.ex":"export"},"lib/b.ex":{}}
+                 """)
+      end)
+    end
+
+    test "with export to a custom file" do
+      in_fixture("no_mixfile", fn ->
+        File.write!("lib/a.ex", """
+        defmodule A do
+          def fun, do: :ok
+        end
+        """)
+
+        File.write!("lib/b.ex", """
+        defmodule B do
+          defstruct []
+        end
+        """)
+
+        assert Mix.Task.run("xref", ["graph", "--format", "dot", "--output", "custom.dot"]) == :ok
+
+        assert File.read!("custom.dot") === """
+               digraph "xref graph" {
+                 "lib/a.ex"
+                 "lib/b.ex"
+               }
+               """
+      end)
+    end
+
+    test "with export to stdout" do
+      in_fixture("no_mixfile", fn ->
+        File.write!("lib/a.ex", """
+        defmodule A do
+          def fun, do: :ok
+        end
+        """)
+
+        File.write!("lib/b.ex", """
+        defmodule B do
+          defstruct []
+        end
+        """)
+
+        output =
+          capture_io(fn ->
+            assert Mix.Task.run("xref", ["graph", "--format", "json", "--output", "-"]) == :ok
+          end)
+
+        assert output ===
+                 String.trim_trailing("""
+                 {"lib/a.ex":{},"lib/b.ex":{}}
+                 """)
+
+        output =
+          capture_io(fn ->
+            assert Mix.Task.run("xref", ["graph", "--format", "dot", "--output", "-"]) == :ok
+          end)
+
+        assert output === """
+               digraph "xref graph" {
+                 "lib/a.ex"
+                 "lib/b.ex"
+               }
+               """
+      end)
+    end
+
+    test "with mixed cyclic dependencies" do
+      in_fixture("no_mixfile", fn ->
+        File.write!("lib/a.ex", """
+        defmodule A.Using do
+          defmacro __using__(_), do: 42
+        end
+
+        defmodule A do
+          B
+
+          def foo do
+            :foo
+          end
+        end
+        """)
+
+        File.write!("lib/b.ex", """
+        defmodule B do
+          # Let's also test that we track literal atom behaviours
+          use :"Elixir.A.Using"
+
+          def foo do
+            A.foo()
+          end
+        end
+        """)
+
+        assert Mix.Task.run("xref", ["graph", "--format", "dot"]) == :ok
+
+        assert File.read!("xref_graph.dot") === """
+               digraph "xref graph" {
+                 "lib/a.ex"
+                 "lib/a.ex" -> "lib/b.ex" [label="(compile)"]
+                 "lib/b.ex" -> "lib/a.ex" [label="(compile)"]
+                 "lib/b.ex"
+               }
+               """
+
+        assert Mix.Task.run("xref", ["graph", "--format", "json"]) ==
+                 :ok
+
+        assert File.read!("xref_graph.json") ===
+                 String.trim_trailing("""
+                 {"lib/a.ex":{"lib/b.ex":"compile"},"lib/b.ex":{"lib/a.ex":"compile"}}
+                 """)
+      end)
+    end
+
+    test "generates reports from the umbrella root" do
+      Mix.Project.pop()
+
+      in_fixture("umbrella_dep/deps/umbrella", fn ->
+        Mix.Project.in_project(:umbrella, ".", fn _ ->
+          File.write!("apps/bar/lib/bar.ex", """
+          defmodule Bar do
+            def bar do
+              Foo.foo()
+            end
+          end
+          """)
+
+          Mix.Task.run("compile")
+          Mix.shell().flush()
+
+          Mix.Tasks.Xref.run(["graph", "--format", "stats", "--include-siblings"])
+
+          assert receive_until_no_messages([]) == """
+                 Tracked files: 2 (nodes)
+                 Compile dependencies: 0 (edges)
+                 Exports dependencies: 0 (edges)
+                 Runtime dependencies: 1 (edges)
+                 Cycles: 0
+
+                 Top 2 files with most outgoing dependencies:
+                   * lib/bar.ex (1)
+                   * lib/foo.ex (0)
+
+                 Top 2 files with most incoming dependencies:
+                   * lib/foo.ex (1)
+                   * lib/bar.ex (0)
+                 """
+        end)
+      end)
+    end
+
+    test "generates reports considering siblings inside umbrellas" do
+      Mix.Project.pop()
+
+      in_fixture("umbrella_dep/deps/umbrella", fn ->
+        Mix.Project.in_project(:bar, "apps/bar", fn _ ->
+          File.write!("lib/bar.ex", """
+          defmodule Bar do
+            def bar do
+              Foo.foo()
+            end
+          end
+          """)
+
+          Mix.Task.run("compile")
+          Mix.shell().flush()
+
+          Mix.Tasks.Xref.run(["graph", "--format", "stats", "--include-siblings"])
+
+          assert receive_until_no_messages([]) == """
+                 Tracked files: 2 (nodes)
+                 Compile dependencies: 0 (edges)
+                 Exports dependencies: 0 (edges)
+                 Runtime dependencies: 1 (edges)
+                 Cycles: 0
+
+                 Top 2 files with most outgoing dependencies:
+                   * lib/bar.ex (1)
+                   * lib/foo.ex (0)
+
+                 Top 2 files with most incoming dependencies:
+                   * lib/foo.ex (1)
+                   * lib/bar.ex (0)
+                 """
+
+          Mix.Tasks.Xref.run(["callers", "Foo"])
+
+          assert receive_until_no_messages([]) == """
+                 lib/bar.ex (runtime)
+                 """
+        end)
+      end)
+    end
+
+    test "skip project compilation with --no-compile" do
+      in_fixture("no_mixfile", fn ->
+        File.write!("lib/a.ex", """
+        defmodule A do
+          def a, do: :ok
+        end
+        """)
+
+        Mix.Tasks.Xref.run(["graph", "--no-compile"])
+        refute receive_until_no_messages([]) =~ "lib/a.ex"
+      end)
+    end
+
+    test "group with multiple unconnected files" do
+      assert_graph(~w[--group lib/a.ex,lib/c.ex,lib/e.ex], """
+      lib/a.ex+
+      |-- lib/b.ex (compile)
+      `-- lib/d.ex (compile)
+      lib/b.ex
+      `-- lib/a.ex+ (compile)
+      lib/d.ex
+      `-- lib/a.ex+
+      """)
+    end
+
+    test "group with directly dependent files and cycle" do
+      assert_graph(["--group", "lib/a.ex,lib/b.ex,"], """
+      lib/a.ex+
+      |-- lib/c.ex
+      `-- lib/e.ex (compile)
+      lib/c.ex
+      `-- lib/d.ex (compile)
+      lib/d.ex
+      `-- lib/e.ex
+      lib/e.ex
+      """)
+    end
+
+    test "multiple groups" do
+      assert_graph(~w[--group lib/a.ex,lib/b.ex --group lib/c.ex,lib/e.ex], """
+      lib/a.ex+
+      `-- lib/c.ex+ (compile)
+      lib/c.ex+
+      `-- lib/d.ex (compile)
+      lib/d.ex
+      `-- lib/c.ex+
+      """)
+    end
+
+    test "group with sink" do
+      assert_graph(~w[--group lib/a.ex,lib/c.ex,lib/e.ex --sink lib/e.ex], """
+      lib/b.ex
+      `-- lib/a.ex+ (compile)
+          |-- lib/b.ex (compile)
+          `-- lib/d.ex (compile)
+      lib/d.ex
+      `-- lib/a.ex+
+      """)
+    end
+
+    test "dot with cycle" do
+      assert_graph_dot(
+        ~w[],
+        """
+        digraph "xref graph" {
+          "lib/a.ex"
+          "lib/a.ex" -> "lib/b.ex" [label="(compile)"]
+          "lib/b.ex" -> "lib/a.ex"
+          "lib/b.ex" -> "lib/c.ex"
+          "lib/c.ex" -> "lib/d.ex" [label="(compile)"]
+          "lib/d.ex" -> "lib/e.ex"
+          "lib/b.ex" -> "lib/e.ex" [label="(compile)"]
+          "lib/b.ex"
+          "lib/c.ex"
+          "lib/d.ex"
+          "lib/e.ex"
+        }
+        """
+      )
+    end
+
+    test "json with cycle" do
+      assert_graph_json(
+        ~w[],
+        """
+        { "lib/a.ex": { "lib/b.ex": "compile" },
+          "lib/b.ex": { "lib/a.ex": "runtime",
+                        "lib/c.ex": "runtime",
+                        "lib/e.ex": "compile" },
+          "lib/c.ex": { "lib/d.ex": "compile" },
+          "lib/d.ex": { "lib/e.ex": "runtime" },
+          "lib/e.ex": { } }
+        """,
+        # make it easier to read the expected output
+        strip_ws: true
+      )
+    end
+
+    @default_files %{
+      "lib/a.ex" => """
+      defmodule A do
+        def a, do: :ok
+        B.b2()
+      end
+      """,
+      "lib/b.ex" => """
+      defmodule B do
+        def b1, do: A.a() == C.c()
+        def b2, do: :ok
+        :e.e()
+      end
+      """,
+      "lib/c.ex" => """
+      defmodule C do
+        def c, do: :ok
+        :d.d()
+      end
+      """,
+      "lib/d.ex" => """
+      defmodule :d do
+        def d, do: :ok
+        def e, do: :e.e()
+      end
+      """,
+      "lib/e.ex" => """
+      defmodule :e do
+        def e, do: :ok
+      end
+      """
+    }
+
+    defp assert_graph_json(args, expected, opts) do
+      assert_graph_io("json", args, expected, opts)
+    end
+
+    defp assert_graph_dot(args, expected, opts \\ []) do
+      assert_graph_io("dot", args, expected, opts)
+    end
+
+    # note that we trim_trailing on expected and output
+    # we also support :strip_ws in opts, which removes all
+    # whitespace from expected (but not output!) before performing
+    # the test.
+    defp assert_graph_io(format, args, expected, opts) do
+      in_fixture("no_mixfile", fn ->
+        Enum.each(opts[:files] || @default_files, fn {path, content} ->
+          File.write!(path, content)
+        end)
+
+        output =
+          String.trim_trailing(
+            capture_io(fn ->
+              assert Mix.Task.run(
+                       "xref",
+                       args ++ ["graph", "--format", format, "--output", "-"]
+                     ) == :ok
+            end)
+          )
+
+        expected =
+          if opts[:strip_ws],
+            do: Regex.replace(~r/\s+/, expected, "", global: true),
+            else: String.trim_trailing(expected)
+
+        assert output === expected
+      end)
+    end
+
+    defp assert_graph(args \\ [], expected, opts \\ []) do
+      in_fixture("no_mixfile", fn ->
+        nb_files =
+          Enum.count(opts[:files] || @default_files, fn {path, content} ->
+            File.write!(path, content)
+          end)
+
+        assert Mix.Task.run("xref", args ++ ["graph"]) == :ok
+        first_line = "Compiling #{nb_files} files (.ex)"
+
+        assert [
+                 ^first_line,
+                 "Generated sample app" | result
+               ] = receive_until_no_messages([]) |> String.split("\n")
+
+        result =
+          if Keyword.get(opts, :warnings, false) do
+            result
+          else
+            Enum.take_while(result, &(not String.starts_with?(&1, "WARNING: ")))
+          end
+
+        assert result |> Enum.join("\n") |> normalize_graph_output() == expected
+      end)
+    end
+
+    defp normalize_graph_output(graph) do
+      graph
+      |> String.replace("├──", "|--")
+      |> String.replace("└──", "`--")
+      |> String.replace("│", "|")
+    end
+  end
+
+  ## Helpers
+
+  defp receive_until_no_messages(acc) do
+    receive do
+      {:mix_shell, :info, [line]} -> receive_until_no_messages([acc, line | "\n"])
+    after
+      0 -> IO.iodata_to_binary(acc)
+    end
+  end
+
+  defp generate_files(files) do
+    for {file, contents} <- files do
+      File.write!(file, contents)
+    end
+  end
+end
diff --git a/lib/mix/test/mix/umbrella_test.exs b/lib/mix/test/mix/umbrella_test.exs
index 69ad94d70de..a1ec1164f00 100644
--- a/lib/mix/test/mix/umbrella_test.exs
+++ b/lib/mix/test/mix/umbrella_test.exs
@@ -1,177 +1,666 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Mix.UmbrellaTest do
   use MixTest.Case
 
+  test "apps_paths and parent_umbrella_project_file" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      assert Mix.Project.apps_paths() == nil
+      assert Mix.Project.parent_umbrella_project_file() == nil
+
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        assert Mix.Project.apps_paths() == %{bar: "apps/bar", foo: "apps/foo"}
+        assert Mix.Project.parent_umbrella_project_file() == nil
+
+        assert_received {:mix_shell, :error,
+                         ["warning: path \"apps/dont_error_on_missing_mixfile\"" <> _]}
+
+        refute_received {:mix_shell, :error, ["warning: path \"apps/dont_error_on_files\"" <> _]}
+      end)
+    end)
+  end
+
+  test "apps_paths with selection" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", [apps: [:foo, :bar]], fn _ ->
+        File.mkdir_p!("apps/errors")
+        File.write!("apps/errors/mix.exs", "raise :oops")
+        assert Mix.Project.apps_paths() == %{bar: "apps/bar", foo: "apps/foo"}
+      end)
+    end)
+  end
+
+  test "umbrella app dir and the app name defined in mix.exs should be equal" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        File.write!("apps/bar/mix.exs", """
+        defmodule Bar.MixProject do
+          use Mix.Project
+
+          def project do
+            [app: :baz,
+             version: "0.1.0",
+             deps: []]
+          end
+        end
+        """)
+
+        assert_raise Mix.Error, ~r/^Umbrella app :baz is located at directory bar/, fn ->
+          Mix.Task.run("deps")
+        end
+      end)
+    end)
+  end
+
   test "compiles umbrella" do
-    in_fixture "umbrella_dep/deps/umbrella", fn ->
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
       Mix.Project.in_project(:umbrella, ".", fn _ ->
-        Mix.Task.run "deps"
-        assert_received {:mix_shell, :info, ["* bar (apps/bar)"]}
-        assert_received {:mix_shell, :info, ["* foo (apps/foo)"]}
+        Mix.Task.run("deps")
+        assert_received {:mix_shell, :info, ["* bar (apps/bar) (mix)"]}
+        assert_received {:mix_shell, :info, ["* foo (apps/foo) (mix)"]}
 
         # Ensure we can compile and run checks
-        Mix.Task.run "deps.compile"
-        Mix.Task.run "deps.check"
-        Mix.Task.run "compile"
+        Mix.Task.run("deps.compile")
+        Mix.Task.run("deps.loadpaths")
+        Mix.Task.run("compile")
+
+        # Extra applications are picked even for umbrellas
+        assert :code.where_is_file(~c"runtime_tools.app") != :non_existing
+        assert :code.where_is_file(~c"observer.app") == :non_existing
 
         assert_received {:mix_shell, :info, ["==> bar"]}
-        assert_received {:mix_shell, :info, ["Compiled lib/bar.ex"]}
-        assert_received {:mix_shell, :info, ["Generated bar.app"]}
+        assert_received {:mix_shell, :info, ["Generated bar app"]}
+        assert File.regular?("_build/dev/lib/bar/ebin/Elixir.Bar.beam")
         assert_received {:mix_shell, :info, ["==> foo"]}
-        assert_received {:mix_shell, :info, ["Compiled lib/foo.ex"]}
-        assert_received {:mix_shell, :info, ["Generated foo.app"]}
+        assert_received {:mix_shell, :info, ["Generated foo app"]}
+        assert File.regular?("_build/dev/lib/foo/ebin/Elixir.Foo.beam")
 
         # Ensure foo was loaded and in the same env as Mix.env
         assert_received {:mix_shell, :info, [":foo env is dev"]}
         assert_received {:mix_shell, :info, [":bar env is dev"]}
 
-        Mix.Task.clear
-        Mix.Task.run "app.start", ["--no-compile"]
+        # Ensure we can compile --force
+        Mix.Task.clear()
+        Mix.Task.run("compile", ["--force"])
+        assert_received {:mix_shell, :info, ["Generated foo app"]}
+        assert_received {:mix_shell, :info, ["Generated bar app"]}
+
+        # Ensure we can start even with --no-compile
+        Mix.Task.clear()
+        Mix.Task.run("app.start", ["--no-compile"])
       end)
-    end
+    end)
+  end
+
+  test "compiles umbrella with protocol consolidation" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Task.run("compile", ["--verbose"])
+        assert_received {:mix_shell, :info, ["Generated bar app"]}
+        assert_received {:mix_shell, :info, ["Generated foo app"]}
+        assert File.regular?("_build/dev/consolidated/Elixir.Enumerable.beam")
+        purge([Enumerable])
+
+        assert Mix.Tasks.App.Start.run([])
+        assert Protocol.consolidated?(Enumerable)
+      end)
+    end)
+  end
+
+  test "recursively compiles umbrella with protocol consolidation" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        defmodule Elixir.Mix.Tasks.Umbrella.Recur do
+          use Mix.Task
+          @recursive true
+
+          def run(_) do
+            assert Mix.Task.recursing?()
+            Mix.Task.run("compile", ["--verbose"])
+          end
+        end
+
+        Mix.Task.run("umbrella.recur")
+        assert_received {:mix_shell, :info, ["Generated bar app"]}
+        assert_received {:mix_shell, :info, ["Generated foo app"]}
+        assert File.regular?("_build/dev/consolidated/Elixir.Enumerable.beam")
+        purge([Enumerable])
+
+        assert Mix.Tasks.App.Start.run([])
+        assert Protocol.consolidated?(Enumerable)
+      end)
+    end)
   end
 
   defmodule UmbrellaDeps do
     def project do
-      [apps_path: "apps",
-       deps: [{:some_dep, path: "deps/some_dep"}]]
+      [apps_path: "apps", deps: [{:some_dep, path: "deps/some_dep"}]]
     end
   end
 
   test "loads umbrella dependencies" do
-    Mix.Project.push UmbrellaDeps
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.push(UmbrellaDeps)
 
-    in_fixture "umbrella_dep/deps/umbrella", fn ->
       File.mkdir_p!("deps/some_dep/ebin")
       File.mkdir_p!("_build/dev/lib/some_dep/ebin")
       File.mkdir_p!("_build/dev/lib/foo/ebin")
       File.mkdir_p!("_build/dev/lib/bar/ebin")
 
-      Mix.Task.run "deps.loadpaths", ["--no-deps-check"]
-      Mix.Task.run "loadpaths", ["--no-elixir-version-check"]
-      assert to_char_list(Path.expand("_build/dev/lib/some_dep/ebin")) in :code.get_path
-      assert to_char_list(Path.expand("_build/dev/lib/foo/ebin")) in :code.get_path
-      assert to_char_list(Path.expand("_build/dev/lib/bar/ebin")) in :code.get_path
-    end
+      Mix.Task.run("loadpaths", ["--no-deps-check", "--no-elixir-version-check"])
+      assert to_charlist(Path.expand("_build/dev/lib/some_dep/ebin")) in :code.get_path()
+      assert to_charlist(Path.expand("_build/dev/lib/foo/ebin")) in :code.get_path()
+      assert to_charlist(Path.expand("_build/dev/lib/bar/ebin")) in :code.get_path()
+    end)
+  end
+
+  test "loads umbrella child dependencies in all environments" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        File.write!("apps/bar/mix.exs", """
+        defmodule Bar.MixProject do
+          use Mix.Project
+
+          def project do
+            [app: :bar,
+             version: "0.1.0",
+             deps: [{:git_repo, git: MixTest.Case.fixture_path("git_repo"), only: :other}]]
+          end
+        end
+        """)
+
+        # Does not fetch when filtered
+        Mix.Tasks.Deps.Get.run(["--only", "dev"])
+        refute_received {:mix_shell, :info, ["* Getting git_repo" <> _]}
+
+        # But works across all environments
+        Mix.Tasks.Deps.Get.run([])
+        assert_received {:mix_shell, :info, ["* Getting git_repo" <> _]}
+
+        # Does not show by default
+        Mix.Tasks.Deps.run([])
+        refute_received {:mix_shell, :info, ["* git_repo" <> _]}
+
+        # But shows on proper environment
+        Mix.env(:other)
+        Mix.Tasks.Deps.run([])
+        assert_received {:mix_shell, :info, ["* git_repo " <> _]}
+      end)
+    end)
+  after
+    Mix.env(:test)
+  end
+
+  test "loads umbrella child optional dependencies" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        File.write!("apps/bar/mix.exs", """
+        defmodule Bar.MixProject do
+          use Mix.Project
+
+          def project do
+            [app: :bar,
+             version: "0.1.0",
+             deps: [{:git_repo, git: MixTest.Case.fixture_path("git_repo"), optional: true}]]
+          end
+        end
+        """)
+
+        Mix.Tasks.Deps.run([])
+        assert_received {:mix_shell, :info, ["* git_repo " <> _]}
+      end)
+    end)
+  end
+
+  test "loads umbrella sibling dependencies with :in_umbrella" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        File.write!("apps/bar/mix.exs", """
+        defmodule Bar.MixProject do
+          use Mix.Project
+
+          def project do
+            [app: :bar,
+             version: "0.1.0",
+             deps: [{:foo, in_umbrella: true}]]
+          end
+        end
+        """)
+
+        # Running from umbrella should not cause conflicts
+        Mix.Tasks.Deps.Get.run([])
+        Mix.Tasks.Run.run([])
+      end)
+    end)
+  end
+
+  test "conflicts with umbrella sibling dependencies in :in_umbrella" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        File.write!("apps/bar/mix.exs", """
+        defmodule Bar.MixProject do
+          use Mix.Project
+
+          def project do
+            [app: :bar,
+             version: "0.1.0",
+             deps: [{:foo, in_umbrella: true, env: :unknown}]]
+          end
+        end
+        """)
+
+        assert_raise Mix.Error, fn ->
+          Mix.Tasks.Deps.Get.run([])
+        end
+
+        assert_received {:mix_shell, :error, ["Dependencies have diverged:"]}
+
+        assert_received {:mix_shell, :error,
+                         ["  the dependency foo in mix.exs is overriding a child" <> message]}
+
+        assert message =~ "Please remove the conflicting options from your definition"
+      end)
+    end)
+  end
+
+  test "list deps for umbrella as dependency" do
+    in_fixture("umbrella_dep", fn ->
+      Mix.Project.in_project(:umbrella_dep, ".", fn _ ->
+        Mix.Task.run("deps")
+        assert_received {:mix_shell, :info, ["* umbrella (deps/umbrella) (mix)"]}
+        assert_received {:mix_shell, :info, ["* foo (apps/foo) (mix)"]}
+      end)
+    end)
+  end
+
+  # Bar.bar is loaded dynamically
+  @compile {:no_warn_undefined, {Bar, :bar, 0}}
+
+  test "compile for umbrella as dependency" do
+    in_fixture("umbrella_dep", fn ->
+      Mix.Project.in_project(:umbrella_dep, ".", fn _ ->
+        Mix.Task.run("compile")
+        assert Bar.bar() == "hello world"
+      end)
+    end)
   end
 
   defmodule CycleDeps do
     def project do
-      [app: :umbrella_dep,
-       deps: [
-         {:bar, path: "deps/umbrella/apps/bar"},
-         {:umbrella, path: "deps/umbrella"}
-       ]]
+      [
+        app: :umbrella_dep,
+        deps: [
+          {:bar, path: "deps/umbrella/apps/bar"},
+          {:umbrella, path: "deps/umbrella"}
+        ]
+      ]
     end
   end
 
   test "handles dependencies with cycles" do
-    Mix.Project.push CycleDeps
+    in_fixture("umbrella_dep", fn ->
+      Mix.Project.push(CycleDeps)
 
-    in_fixture "umbrella_dep", fn ->
-      assert Enum.map(Mix.Dep.loaded([]), & &1.app) == [:foo, :bar, :umbrella]
-    end
+      assert Enum.map(Mix.Dep.Converger.converge([]), & &1.app) == [:foo, :bar, :umbrella]
+    end)
   end
 
   test "handles dependencies with cycles and overridden deps" do
-    in_fixture "umbrella_dep/deps/umbrella", fn ->
-      Mix.Project.in_project :umbrella, ".", fn _ ->
-        File.write! "apps/foo/mix.exs", """
-        defmodule Foo.Mix do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        File.write!("apps/foo/mix.exs", """
+        defmodule Foo.MixProject do
           use Mix.Project
 
           def project do
             # Ensure we have the proper environment
-            :dev = Mix.env
+            :dev = Mix.env()
 
-            [ app: :foo,
-              version: "0.1.0",
-              deps: [{:bar, in_umbrella: true}] ]
+            [app: :foo,
+             version: "0.1.0",
+             deps: [{:bar, in_umbrella: true}]]
           end
         end
-        """
+        """)
 
-        File.write! "apps/bar/mix.exs", """
-        defmodule Bar.Mix do
+        File.write!("apps/bar/mix.exs", """
+        defmodule Bar.MixProject do
           use Mix.Project
 
           def project do
             # Ensure we have the proper environment
-            :dev = Mix.env
+            :dev = Mix.env()
 
-            [ app: :bar,
-              version: "0.1.0",
-              deps: [{:a, path: "deps/a"},
-                     {:b, path: "deps/b"}] ]
+            [app: :bar,
+             version: "0.1.0",
+             deps: [{:a, path: "deps/a"},
+                    {:b, path: "deps/b"}]]
           end
         end
-        """
+        """)
 
-        assert Enum.map(Mix.Dep.loaded([]), & &1.app) == [:a, :b, :bar, :foo]
-      end
-    end
+        assert Enum.map(Mix.Dep.Converger.converge([]), & &1.app) == [:a, :b, :bar, :foo]
+      end)
+    end)
   end
 
-  test "list deps for umbrella as dependency" do
-    in_fixture("umbrella_dep", fn ->
-      Mix.Project.in_project(:umbrella_dep, ".", fn _ ->
-        Mix.Task.run "deps"
-        assert_received {:mix_shell, :info, ["* umbrella (deps/umbrella)"]}
-        assert_received {:mix_shell, :info, ["* foo (apps/foo)"]}
+  test "uses dependency aliases" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        File.write!("apps/bar/mix.exs", """
+        defmodule Bar.MixProject do
+          use Mix.Project
+
+          def project do
+            [app: :bar,
+             version: "0.1.0",
+             aliases: ["compile.elixir": fn _ -> Mix.shell().info "no compile bar" end]]
+          end
+        end
+        """)
+
+        Mix.Task.run("compile", ["--verbose"])
+        assert_receive {:mix_shell, :info, ["no compile bar"]}
+        refute_receive {:mix_shell, :info, ["Compiled lib/bar.ex"]}, 100
       end)
     end)
   end
 
-  test "compile for umbrella as dependency" do
-    in_fixture "umbrella_dep", fn ->
-      Mix.Project.in_project(:umbrella_dep, ".", fn _ ->
-        Mix.Task.run "deps.compile"
-        assert "hello world" == Bar.bar
+  test "halts when sibling fails to compile" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        File.write!("apps/foo/lib/foo.ex", "raise ~s[oops]")
+
+        ExUnit.CaptureIO.capture_io(:stderr, fn ->
+          assert catch_exit(Mix.Task.run("compile", ["--verbose"]))
+        end)
+
+        refute_received {:mix_shell, :info, ["Generated foo app"]}
+        refute_received {:mix_shell, :info, ["Generated bar app"]}
+        refute Code.ensure_loaded?(Bar)
       end)
-    end
+    end)
   end
 
-  test "recompiles after path dependency changes" do
+  test "recompiles when compile-time path dependencies change" do
     in_fixture("umbrella_dep/deps/umbrella/apps", fn ->
       Mix.Project.in_project(:bar, "bar", fn _ ->
-        Mix.Task.run "compile"
-        assert Mix.Tasks.Compile.Elixir.run([]) == :noop
-        assert_receive {:mix_shell, :info, ["Compiled lib/foo.ex"]}
+        Mix.Task.run("compile", [])
+
+        # Add compile time dependency
+        File.write!("lib/bar.ex", "defmodule Bar, do: Foo.foo()")
+
+        Mix.Task.clear()
+        assert Mix.Task.run("compile", ["--verbose"]) == {:ok, []}
         assert_receive {:mix_shell, :info, ["Compiled lib/bar.ex"]}
-        purge [Foo, Bar]
-        Mix.Task.clear
 
-        # Ensure we can measure a timestamp difference
-        ensure_touched("../foo/lib/foo.ex",
-                       File.stat!("_build/dev/lib/bar/.compile.lock").mtime)
+        # Compile-time dependencies are recompiled
+        File.write!("../foo/lib/foo.ex", File.read!("../foo/lib/foo.ex") <> "\n")
+        ensure_touched("../foo/lib/foo.ex", "_build/dev/lib/bar/.mix/compile.elixir")
+
+        Mix.Task.clear()
+        assert Mix.Task.run("compile", ["--verbose"]) == {:ok, []}
+        assert_received {:mix_shell, :info, ["Compiled lib/bar.ex"]}
+      end)
+
+      # Now let's add a new file to foo
+      Mix.Project.in_project(:foo, "foo", fn _ ->
+        File.write!("lib/foo_bar.ex", """
+        defmodule Foo.Bar do
+          def baz, do: "from bar"
+        end
+        """)
+
+        Mix.Task.clear()
+        assert Mix.Tasks.Compile.run(["--verbose", "--ignore-module-conflict"]) == {:ok, []}
+        Application.unload(:foo)
+        Application.load(:foo)
+      end)
+
+      # And bar can use it without warnings
+      Mix.Project.in_project(:bar, "bar", fn _ ->
+        File.write!("lib/bar.ex", "defmodule Bar, do: Foo.Bar.baz()")
+
+        mtime = File.stat!("_build/dev/lib/bar/.mix/compile.elixir").mtime
+        ensure_touched("_build/dev/lib/foo/.mix/compile.elixir", mtime)
+        ensure_touched("_build/dev/lib/foo/ebin/foo.app", mtime)
+        ensure_touched("lib/bar.ex", mtime)
 
-        Mix.Task.run "compile"
-        assert Mix.Tasks.Compile.Elixir.run([]) == :noop
-        assert_receive {:mix_shell, :info, ["Compiled lib/foo.ex"]}
+        assert Mix.Tasks.Compile.Elixir.run(["--verbose"]) == {:ok, []}
         assert_receive {:mix_shell, :info, ["Compiled lib/bar.ex"]}
-        purge [Foo, Bar]
       end)
     end)
   end
 
-  defmodule Selective do
-    def project do
-      [apps_path: "apps",
-       apps: [:foo, :bar]]
-    end
+  test "recompiles after struct path dependency changes" do
+    in_fixture("umbrella_dep/deps/umbrella/apps", fn ->
+      Mix.Project.in_project(:bar, "bar", fn _ ->
+        File.write!("../foo/lib/foo.ex", "defmodule Foo, do: defstruct [:bar]")
+
+        # Add struct dependency
+        File.write!("lib/bar.ex", """
+        defmodule Bar do
+          def foo_bar?(%Foo{bar: true}), do: true
+        end
+        """)
+
+        Mix.Task.run("compile", ["--verbose"])
+        assert_received {:mix_shell, :info, ["Compiled lib/bar.ex"]}
+
+        # Does not recompiles if export dependency does not change
+        File.write!("../foo/lib/foo.ex", File.read!("../foo/lib/foo.ex") <> "\n")
+        ensure_touched("../foo/lib/foo.ex", "_build/dev/lib/bar/.mix/compile.elixir")
+
+        Mix.Task.clear()
+        assert Mix.Task.run("compile", ["--verbose"]) == {:ok, []}
+        refute_received {:mix_shell, :info, ["Compiled lib/bar.ex"]}
+
+        # Recompiles if export dependency changes
+        File.write!("../foo/lib/foo.ex", "defmodule Foo, do: defstruct [:bar, :baz]")
+        ensure_touched("../foo/lib/foo.ex", "_build/dev/lib/bar/.mix/compile.elixir")
+
+        Mix.Task.clear()
+        assert Mix.Task.run("compile", ["--verbose"]) == {:ok, []}
+        assert_received {:mix_shell, :info, ["Compiled lib/bar.ex"]}
+
+        # Recompiles if export dependency is removed
+        File.write!("../foo/lib/foo.ex", "")
+        ensure_touched("../foo/lib/foo.ex", "_build/dev/lib/bar/.mix/compile.elixir")
+        Mix.Task.clear()
+
+        ExUnit.CaptureIO.capture_io(:stderr, fn ->
+          assert {:error, _} = Mix.Task.run("compile", ["--verbose", "--return-errors"])
+        end)
+      end)
+    end)
+  end
+
+  test "recompiles after compile through runtime path dependency changes" do
+    in_fixture("umbrella_dep/deps/umbrella/apps", fn ->
+      Mix.Project.in_project(:bar, "bar", fn _ ->
+        File.write!("../foo/lib/foo.bar.ex", """
+        defmodule Foo.Bar do
+          def hello, do: Foo.Baz.hello()
+        end
+        """)
+
+        File.write!("../foo/lib/foo.baz.ex", """
+        defmodule Foo.Baz do
+          def hello, do: "from bar"
+        end
+        """)
+
+        # Add compile time to Foo.Bar
+        File.write!("lib/bar.ex", "defmodule Bar, do: Foo.Bar.hello()")
+        Mix.Task.run("compile", ["--verbose"])
+        assert_received {:mix_shell, :info, ["Compiled lib/bar.ex"]}
+
+        # Recompiles for due to compile dependency via runtime dependencies
+        File.write!("../foo/lib/foo.baz.ex", File.read!("../foo/lib/foo.baz.ex") <> "\n")
+        ensure_touched("../foo/lib/foo.ex", "_build/dev/lib/bar/.mix/compile.elixir")
+
+        Mix.Task.clear()
+        assert Mix.Task.run("compile", ["--verbose"]) == {:ok, []}
+        assert_received {:mix_shell, :info, ["Compiled lib/bar.ex"]}
+      end)
+    end)
   end
 
-  test "can select which apps to use" do
+  test "reverifies when path dependency is added" do
+    in_fixture("umbrella_dep/deps/umbrella/apps", fn ->
+      Mix.Project.in_project(:bar, "bar", [deps: []], fn _ ->
+        File.write!("lib/bar.ex", """
+        defmodule Bar do
+          def foo, do: Foo.foo()
+        end
+        """)
+
+        assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
+                 Mix.Task.run("compile", ["--verbose"])
+               end) =~ "Foo.foo/0 is undefined"
+
+        refute Code.ensure_loaded?(Foo)
+        assert_receive {:mix_shell, :info, ["Compiled lib/bar.ex"]}
+      end)
+
+      Mix.Task.clear()
+
+      Mix.Project.in_project(:bar, "bar", fn _ ->
+        Mix.Task.run("deps.compile")
+        assert Mix.Task.run("compile", ["--verbose", "--all-warnings"]) == {:ok, []}
+      end)
+    end)
+  end
+
+  test "reloads app in app cache if .app changes" do
+    in_fixture("umbrella_dep/deps/umbrella/apps", fn ->
+      deps = [{:foo, in_umbrella: true}]
+
+      Mix.Project.in_project(:bar, "bar", [deps: deps], fn _ ->
+        Mix.Task.run("compile", ["--verbose"])
+
+        File.write!("../foo/lib/foo.ex", """
+        defmodule Foo.VeryNew do
+          def hello, do: :ok
+        end
+        """)
+
+        File.write!("lib/bar.ex", """
+        defmodule Bar.VeryNew do
+          def hello, do: Foo.VeryNew.hello()
+        end
+        """)
+
+        Mix.Task.clear()
+        Application.unload(:foo)
+        ensure_touched("../foo/lib/foo.ex", "_build/dev/lib/bar/.mix/compile.app_cache")
+
+        assert Mix.Task.run("compile", ["--verbose"]) == {:ok, []}
+        assert_receive {:mix_shell, :info, ["Compiled lib/bar.ex"]}
+      end)
+    end)
+  end
+
+  test "reconsolidates after path dependency changes" do
+    in_fixture("umbrella_dep/deps/umbrella/apps", fn ->
+      Mix.Project.in_project(:bar, "bar", fn _ ->
+        # Add a protocol dependency
+        File.write!("../foo/lib/foo.ex", """
+        defprotocol Foo do
+          def foo(arg)
+        end
+        defimpl Foo, for: List do
+          def foo(list), do: list
+        end
+        """)
+
+        Mix.Task.run("compile")
+        assert File.regular?("_build/dev/lib/bar/consolidated/Elixir.Foo.beam")
+        assert Mix.Tasks.Compile.Elixir.run([]) == {:noop, []}
+
+        # Mark protocol as outdated
+        File.touch!("_build/dev/lib/bar/consolidated/Elixir.Foo.beam", {{2010, 1, 1}, {0, 0, 0}})
+        force_recompilation("../foo/lib/foo.ex")
+        ensure_touched("../foo/lib/foo.ex", "_build/dev/lib/bar/.mix/compile.elixir")
+        Mix.Task.clear()
+        Mix.Task.run("compile")
+
+        # Check new timestamp
+        mtime = File.stat!("_build/dev/lib/bar/consolidated/Elixir.Foo.beam").mtime
+        assert mtime > {{2010, 1, 1}, {0, 0, 0}}
+      end)
+    end)
+  end
+
+  test "reconsolidates using umbrella parent information on shared _build" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      File.write!("apps/bar/lib/bar.ex", """
+      defprotocol Bar do
+        def bar(arg)
+      end
+      defimpl Bar, for: List do
+        def bar(list), do: list
+      end
+      """)
+
+      Mix.Project.in_project(:foo, "apps/foo", [build_path: "../../_build"], fn _ ->
+        Mix.Task.run("compile.protocols")
+        refute Code.ensure_loaded?(Bar)
+      end)
+
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Task.run("compile")
+        assert Protocol.consolidated?(Bar)
+      end)
+    end)
+  end
+
+  test "reconsolidates using umbrella child information on shared _build" do
+    in_fixture("umbrella_dep/deps/umbrella", fn ->
+      File.write!("apps/bar/lib/bar.ex", """
+      defprotocol Bar do
+        def foo(arg)
+      end
+      defimpl Bar, for: List do
+        def foo(list), do: list
+      end
+      """)
+
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        Mix.Task.run("compile.protocols")
+      end)
+
+      # Emulate the dependency being removed
+      Mix.Project.in_project(:foo, "apps/foo", [build_path: "../../_build", deps: []], fn _ ->
+        File.rm_rf("../../_build/dev/lib/bar")
+        Mix.Task.run("compile.protocols")
+      end)
+    end)
+  end
+
+  test "apps cannot refer to themselves as a dep" do
     in_fixture("umbrella_dep/deps/umbrella", fn ->
-      Mix.Project.push Selective
+      Mix.Project.in_project(:umbrella, ".", fn _ ->
+        File.write!("apps/bar/mix.exs", """
+        defmodule Bar.MixProject do
+          use Mix.Project
 
-      File.mkdir_p! "apps/errors/lib"
-      File.write! "apps/errors/lib/always_fail.ex", "raise ~s[oops]"
+          def project do
+            [app: :bar,
+             version: "0.1.0",
+             deps: [{:bar, in_umbrella: true}]]
+          end
+        end
+        """)
 
-      assert Mix.Task.run("compile.elixir") == [:ok, :ok]
-      assert_received {:mix_shell, :info, ["Compiled lib/bar.ex"]}
-      assert_received {:mix_shell, :info, ["Compiled lib/foo.ex"]}
+        assert_raise Mix.Error, "App bar lists itself as a dependency", fn ->
+          Mix.Task.run("deps.get", ["--verbose"]) == [:ok, :ok]
+        end
+      end)
     end)
   end
 end
diff --git a/lib/mix/test/mix/utils_test.exs b/lib/mix/test/mix/utils_test.exs
index d8a3b905da9..8c88e7331cc 100644
--- a/lib/mix/test/mix/utils_test.exs
+++ b/lib/mix/test/mix/utils_test.exs
@@ -1,4 +1,8 @@
-Code.require_file "../test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("../test_helper.exs", __DIR__)
 
 defmodule Mix.Tasks.Cheers do
 end
@@ -7,96 +11,339 @@ defmodule Mix.UtilsTest do
   use MixTest.Case
   doctest Mix.Utils
 
-  test :command_to_module do
-    assert Mix.Utils.command_to_module("cheers", Mix.Tasks)   == {:module, Mix.Tasks.Cheers}
+  setup do
+    Mix.ensure_application!(:inets)
+
+    # Store state before test
+    mix_home = System.get_env("MIX_HOME")
+
+    # Clear all variables to get a reproducible test
+    System.delete_env("MIX_HOME")
+    System.delete_env("MIX_XDG")
+
+    # Reset Env Variables
+    on_exit(fn ->
+      System.put_env("MIX_HOME", mix_home)
+      System.delete_env("MIX_XDG")
+    end)
+  end
+
+  test "command to module" do
+    assert Mix.Utils.command_to_module("cheers", Mix.Tasks) == {:module, Mix.Tasks.Cheers}
     assert Mix.Utils.command_to_module("unknown", Mix.Tasks) == {:error, :nofile}
   end
 
-  test :module_name_to_command do
-    assert Mix.Utils.module_name_to_command(Mix.Tasks.Foo, 2)       == "foo"
-    assert Mix.Utils.module_name_to_command("Mix.Tasks.Foo", 2)     == "foo"
+  test "module name to command" do
+    assert Mix.Utils.module_name_to_command(Mix.Tasks.Foo, 2) == "foo"
+    assert Mix.Utils.module_name_to_command("Mix.Tasks.Foo", 2) == "foo"
     assert Mix.Utils.module_name_to_command("Mix.Tasks.Foo.Bar", 2) == "foo.bar"
+    assert Mix.Utils.module_name_to_command("Mix.Tasks.FooBar.Bing", 2) == "foo_bar.bing"
+    assert Mix.Utils.module_name_to_command("Mix.Tasks.FooBar.BingBang", 2) == "foo_bar.bing_bang"
   end
 
-  test :command_to_module_name do
-    assert Mix.Utils.command_to_module_name("foo")     == "Foo"
+  test "command to module name" do
+    assert Mix.Utils.command_to_module_name("foo") == "Foo"
     assert Mix.Utils.command_to_module_name("foo.bar") == "Foo.Bar"
+    assert Mix.Utils.command_to_module_name("foo_bar.baz") == "FooBar.Baz"
+    assert Mix.Utils.command_to_module_name("foo_bar.baz_bing") == "FooBar.BazBing"
   end
 
-  test :underscore do
-    assert Mix.Utils.underscore("foo") == "foo"
-    assert Mix.Utils.underscore("foo_bar") == "foo_bar"
-    assert Mix.Utils.underscore("Foo") == "foo"
-    assert Mix.Utils.underscore("FooBar") == "foo_bar"
-    assert Mix.Utils.underscore("FOOBar") == "foo_bar"
-    assert Mix.Utils.underscore("FooBAR") == "foo_bar"
-    assert Mix.Utils.underscore("FoBaZa") == "fo_ba_za"
-    assert Mix.Utils.underscore("Foo.Bar") == "foo/bar"
-    assert Mix.Utils.underscore(Foo.Bar) == "foo/bar"
-    assert Mix.Utils.underscore("") == ""
-    assert Mix.Utils.underscore("..") == ".."
-    assert Mix.Utils.underscore("/..") == "/.."
-    assert Mix.Utils.underscore("foo/../bar") == "foo/../bar"
-  end
-
-  test :camelize do
-    assert Mix.Utils.camelize("Foo") == "Foo"
-    assert Mix.Utils.camelize("FooBar") == "FooBar"
-    assert Mix.Utils.camelize("foo") == "Foo"
-    assert Mix.Utils.camelize("foo_bar") == "FooBar"
-    assert Mix.Utils.camelize("foo_") == "Foo"
-    assert Mix.Utils.camelize("_foo") == "Foo"
-    assert Mix.Utils.camelize("foo__bar") == "FooBar"
-    assert Mix.Utils.camelize("foo/bar") == "Foo.Bar"
-    assert Mix.Utils.camelize("") == ""
-  end
-
-  test :extract_files do
-    files = Mix.Utils.extract_files [Path.join(fixture_path, "archive")], "*.ex"
+  test "extract files" do
+    files = Mix.Utils.extract_files([Path.join(fixture_path(), "archive")], "*.ex")
     assert length(files) == 1
     assert Path.basename(hd(files)) == "local.sample.ex"
   end
 
-  test :extract_stale do
-    time = {{2030, 1, 1}, {0, 0, 0}}
+  test "extract files with empty string returns empty list" do
+    assert Mix.Utils.extract_files([""], ".ex") == []
+  end
+
+  test "extract stale" do
+    # 2038-01-01 00:00:00
+    time = 2_145_916_800
     assert Mix.Utils.extract_stale([__ENV__.file], [time]) == []
 
-    time = {{2000, 1, 1}, {0, 0, 0}}
+    # 2000-01-01 00:00:00
+    time = 946_684_800
     assert Mix.Utils.extract_stale([__ENV__.file], [time]) == [__ENV__.file]
 
     assert Mix.Utils.extract_stale([__ENV__.file], [__ENV__.file]) == []
   end
 
-  test :symlink_or_copy do
-    in_fixture "archive", fn ->
+  test "handles missing target files" do
+    assert Mix.Utils.stale?([__ENV__.file], []) == true
+  end
+
+  test "symlink or copy" do
+    in_fixture("archive", fn ->
       File.mkdir_p!("_build/archive")
       result = Mix.Utils.symlink_or_copy(Path.expand("ebin"), Path.expand("_build/archive/ebin"))
       assert_ebin_symlinked_or_copied(result)
-    end
+    end)
   end
 
-  test :symlink_or_copy_removes_previous_directories do
-    in_fixture "archive", fn ->
+  test "symlink or copy removes previous directories" do
+    in_fixture("archive", fn ->
       File.mkdir_p!("_build/archive/ebin")
       result = Mix.Utils.symlink_or_copy(Path.expand("ebin"), Path.expand("_build/archive/ebin"))
       assert_ebin_symlinked_or_copied(result)
-    end
+    end)
   end
 
-  test :symlink_or_copy_erases_wrong_symblinks do
-    in_fixture "archive", fn ->
+  @tag :unix
+  test "symlink or copy erases wrong symlinks" do
+    in_fixture("archive", fn ->
       File.mkdir_p!("_build/archive")
-      Mix.Utils.symlink_or_copy(Path.expand("priv"), Path.expand("_build/archive/ebin"))
-      result = Mix.Utils.symlink_or_copy(Path.expand("ebin"), Path.expand("_build/archive/ebin"))
+      build_ebin = Path.expand("_build/archive/ebin")
+      Mix.Utils.symlink_or_copy(Path.expand("priv"), build_ebin)
+
+      result = Mix.Utils.symlink_or_copy(Path.expand("ebin"), build_ebin)
       assert_ebin_symlinked_or_copied(result)
+    end)
+  end
+
+  test "proxy_config reads from env and returns credentials" do
+    assert Mix.Utils.proxy_config("http://example.com") == []
+
+    System.put_env("http_proxy", "http://nopass@example.com")
+    assert Mix.Utils.proxy_config("http://example.com") == [proxy_auth: {~c"nopass", ~c""}]
+
+    System.put_env("HTTP_PROXY", "http://my:proxy@example.com")
+    assert Mix.Utils.proxy_config("http://example.com") == [proxy_auth: {~c"my", ~c"proxy"}]
+
+    System.put_env("https_proxy", "https://another:proxy@example.com")
+    assert Mix.Utils.proxy_config("https://example.com") == [proxy_auth: {~c"another", ~c"proxy"}]
+
+    System.put_env("HTTPS_PROXY", "https://example.com")
+    assert Mix.Utils.proxy_config("https://example.com") == []
+  after
+    System.delete_env("http_proxy")
+    System.delete_env("https_proxy")
+  end
+
+  # 10.0.0.0 is a non-routable address
+  test "read_path timeouts requests" do
+    # If the request finishes for a reason, it will fail due to the checksum.
+    case Mix.Utils.read_path("http://10.0.0.0/", timeout: 0) do
+      {:remote, "request timed out after 0ms"} -> :ok
+      {:checksum, "fetching from URIs require a checksum to be given"} -> :ok
+    end
+  end
+
+  describe "mix_home/0" do
+    test "prefers MIX_HOME over MIX_XDG" do
+      System.put_env("MIX_HOME", "mix_home")
+      System.put_env("MIX_XDG", "true")
+      assert "mix_home" = Mix.Utils.mix_home()
+    end
+
+    @tag :unix
+    test "falls back to XDG_DATA_HOME/mix when MIX_XDG is set" do
+      System.put_env("MIX_XDG", "1")
+      assert Mix.Utils.mix_home() == :filename.basedir(:user_data, "mix", %{os: :linux})
+    end
+
+    test "falls back to $HOME/.mix" do
+      assert Path.expand("~/.mix") == Mix.Utils.mix_home()
+    end
+  end
+
+  describe "mix_config/0" do
+    test "prefers MIX_HOME over MIX_XDG" do
+      System.put_env("MIX_HOME", "mix_home")
+      System.put_env("MIX_XDG", "true")
+      assert "mix_home" = Mix.Utils.mix_config()
+    end
+
+    @tag :unix
+    test "falls back to XDG_CONFIG_HOME/mix when MIX_XDG is set" do
+      System.put_env("MIX_XDG", "1")
+      assert Mix.Utils.mix_config() == :filename.basedir(:user_config, "mix", %{os: :linux})
+    end
+
+    test "falls back to $HOME/.mix" do
+      assert Path.expand("~/.mix") == Mix.Utils.mix_config()
+    end
+  end
+
+  describe "mix_cache/0" do
+    @tag :unix
+    test "prefers XDG_CACHE_HOME/mix when MIX_XDG is set" do
+      System.put_env("MIX_XDG", "1")
+      assert Mix.Utils.mix_cache() == :filename.basedir(:user_cache, "mix", %{os: :linux})
+    end
+
+    test "falls back to user cache dir" do
+      assert Mix.Utils.mix_cache() == :filename.basedir(:user_cache, "mix")
+    end
+  end
+
+  describe "write_according_to_opts/3" do
+    test "verify that file writes with backups work as expected" do
+      test_out = "test.out"
+      test_out_bak = "test.out.bak"
+      hello_world = "Hello World!"
+      new_hello_world = "New Hello World!"
+      default_out = "default.out"
+
+      # ignore any error from this call.
+      in_tmp("write to default file", fn ->
+        # no optional override - write to the specified default file
+        assert Mix.Utils.write_according_to_opts!(test_out, [hello_world], []) == test_out
+        assert File.read!(test_out) == hello_world
+
+        # no optional override - write to the specified default file again, with old file backed up
+        assert Mix.Utils.write_according_to_opts!(test_out, [new_hello_world], []) == test_out
+        assert File.read!(test_out) == new_hello_world
+        assert File.read!(test_out_bak) == hello_world
+      end)
+
+      in_tmp("write to optional file override", fn ->
+        # with optional override - write to the specified default file
+        assert Mix.Utils.write_according_to_opts!(default_out, [hello_world], output: test_out) ==
+                 test_out
+
+        assert File.read!(test_out) == hello_world
+
+        # with optional override - write to the specified default file again, with old file backed up
+        assert Mix.Utils.write_according_to_opts!(default_out, [new_hello_world],
+                 output: test_out
+               ) ==
+                 test_out
+
+        assert File.read!(test_out) == new_hello_world
+        assert File.read!(test_out_bak) == hello_world
+      end)
+    end
+
+    test "verify that writing to STDOUT works as expected" do
+      output =
+        ExUnit.CaptureIO.capture_io(fn ->
+          Mix.Utils.write_according_to_opts!("the_file.txt", ["some text"], output: "-")
+        end)
+
+      assert output == "some text"
+
+      refute File.exists?("the_file.txt")
+    end
+  end
+
+  describe "write_dot_graph!/4" do
+    test "preserves newlines and other control characters" do
+      in_tmp("dot_newlines", fn ->
+        callback = fn node -> {{node, nil}, []} end
+
+        Mix.Utils.write_dot_graph!("graph.dot", "graph", ["foo \nbar\r\nbaz"], callback, [])
+
+        assert File.read!("graph.dot") == """
+               digraph "graph" {
+                 "foo 
+               bar\r
+               baz"
+               }
+               """
+      end)
+    end
+
+    test "quote and backslash combinations" do
+      in_tmp("dot_complex", fn ->
+        callback = fn node -> {{node, nil}, []} end
+
+        test_cases = [
+          # "fo"o" -> "fo\"o"
+          {"fo\"o", "fo\\\"o"},
+          # "fo\"o" -> "fo\\\"o"
+          {"fo\\\"o", "fo\\\\\"o"},
+          # "fo\o" -> "fo\o"
+          {"fo\\o", "fo\\o"},
+          # "fo\\o" -> "fo\\o"
+          {"fo\\\\o", "fo\\\\o"},
+          # "fo\\\o" -> "fo\\\o"
+          {"fo\\\\\\o", "fo\\\\\\o"}
+        ]
+
+        Enum.each(test_cases, fn {input, expected} ->
+          Mix.Utils.write_dot_graph!("graph.dot", "graph", [input], callback, [])
+          content = File.read!("graph.dot")
+          assert content == "digraph \"graph\" {\n  \"#{expected}\"\n}\n"
+        end)
+      end)
+    end
+
+    test "escapes backslash at end of string" do
+      in_tmp("dot_end_backslash", fn ->
+        callback = fn node -> {{node, nil}, []} end
+
+        test_cases = [
+          # "fo\" -> "fo\\" (add backslash)
+          {"fo\\", "fo\\\\"},
+          # "fo\\" -> "fo\\" (already valid)
+          {"fo\\\\", "fo\\\\"},
+          # "fo\\\" -> "fo\\\\" (add backslash)
+          {"fo\\\\\\", "fo\\\\\\\\"}
+        ]
+
+        Enum.each(test_cases, fn {input, expected} ->
+          Mix.Utils.write_dot_graph!("graph.dot", "graph", [input], callback, [])
+          content = File.read!("graph.dot")
+          assert content == "digraph \"graph\" {\n  \"#{expected}\"\n}\n"
+        end)
+      end)
+    end
+
+    test "handles empty strings" do
+      in_tmp("dot_empty", fn ->
+        callback = fn node -> {{node, nil}, []} end
+
+        Mix.Utils.write_dot_graph!("graph.dot", "graph", [""], callback, [])
+
+        assert File.read!("graph.dot") == """
+               digraph "graph" {
+                 ""
+               }
+               """
+      end)
+    end
+
+    test "handles edge labels with escaping" do
+      in_tmp("dot_edge_labels", fn ->
+        callback = fn node -> {{node, "edge \"label\""}, []} end
+
+        Mix.Utils.write_dot_graph!("graph.dot", "graph", ["node"], callback, [])
+
+        assert File.read!("graph.dot") == """
+               digraph "graph" {
+                 "node" [label="edge \\"label\\""]
+               }
+               """
+      end)
     end
   end
 
   defp assert_ebin_symlinked_or_copied(result) do
     case result do
-      {:ok, paths} -> assert Path.expand("_build/archive/ebin") in paths
-      :ok -> assert :file.read_link("_build/archive/ebin") == {:ok, '../../ebin'}
-      _ -> flunk "expected symlink_or_copy to return :ok or {:ok, list_of_paths}, got: #{inspect result}"
+      {:ok, paths} ->
+        assert Path.expand("_build/archive/ebin") in paths
+
+      :ok ->
+        expected_link =
+          case :os.type() do
+            # relative symlink on Windows are broken, see symlink_or_copy/2
+            {:win32, _} ->
+              "ebin" |> Path.expand() |> String.to_charlist()
+
+            _ ->
+              ~c"../../ebin"
+          end
+
+        {:ok, actual_link} = :file.read_link("_build/archive/ebin")
+        assert actual_link == expected_link
+
+      _ ->
+        msg =
+          "expected symlink_or_copy to return :ok or {:ok, list_of_paths}, got: #{inspect(result)}"
+
+        flunk(msg)
     end
   end
 end
diff --git a/lib/mix/test/mix_test.exs b/lib/mix/test/mix_test.exs
index 97e492f5d33..0cd19896b03 100644
--- a/lib/mix/test/mix_test.exs
+++ b/lib/mix/test/mix_test.exs
@@ -1,15 +1,584 @@
-Code.require_file "test_helper.exs", __DIR__
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("test_helper.exs", __DIR__)
 
 defmodule MixTest do
   use MixTest.Case
 
-  test :shell do
-    assert Mix.shell == Mix.Shell.Process
+  test "shell" do
+    assert Mix.shell() == Mix.Shell.Process
   end
 
-  test :env do
-    assert Mix.env == :dev
+  test "env" do
+    assert Mix.env() == :dev
     Mix.env(:prod)
-    assert Mix.env == :prod
+    assert Mix.env() == :prod
+  end
+
+  test "debug" do
+    refute Mix.debug?()
+    Mix.debug(true)
+    assert Mix.debug?()
+    Mix.debug(false)
+  end
+
+  describe "install" do
+    @describetag :tmp_dir
+
+    setup %{tmp_dir: tmp_dir} do
+      System.put_env("MIX_INSTALL_DIR", Path.join(tmp_dir, "installs"))
+    end
+
+    setup :test_project
+
+    test "default options", %{tmp_dir: tmp_dir} do
+      Mix.install([
+        {:install_test, path: Path.join(tmp_dir, "install_test")}
+      ])
+
+      assert File.dir?(Path.join(tmp_dir, "installs"))
+
+      assert Protocol.consolidated?(InstallTest.Protocol)
+
+      assert_received {:mix_shell, :info, ["==> install_test"]}
+      assert_received {:mix_shell, :info, ["Compiling 2 files (.ex)"]}
+      assert_received {:mix_shell, :info, ["Generated install_test app"]}
+      refute_received _
+
+      assert Application.app_dir(:crypto) =~ "crypto"
+      assert List.keyfind(Application.started_applications(), :install_test, 0)
+      assert apply(InstallTest, :hello, []) == :world
+    end
+
+    test "with start_applications: false", %{tmp_dir: tmp_dir} do
+      Mix.install(
+        [
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ],
+        start_applications: false
+      )
+
+      assert List.keyfind(Application.loaded_applications(), :install_test, 0)
+      refute List.keyfind(Application.started_applications(), :install_test, 0)
+    end
+
+    test "with runtime: false", %{tmp_dir: tmp_dir} do
+      Mix.install([
+        {:install_test, path: Path.join(tmp_dir, "install_test"), runtime: false}
+      ])
+
+      assert File.dir?(Path.join(tmp_dir, "installs"))
+      assert_received {:mix_shell, :info, ["==> install_test"]}
+      assert_received {:mix_shell, :info, ["Compiling 2 files (.ex)"]}
+      assert_received {:mix_shell, :info, ["Generated install_test app"]}
+      refute_received _
+
+      refute List.keyfind(Application.started_applications(), :install_test, 0)
+    end
+
+    test "works with same deps twice", %{tmp_dir: tmp_dir} do
+      Mix.install([
+        {:install_test, path: Path.join(tmp_dir, "install_test")}
+      ])
+
+      Mix.install([
+        {:install_test, path: Path.join(tmp_dir, "install_test")}
+      ])
+    end
+
+    test "errors on Elixir version mismatch", %{tmp_dir: tmp_dir} do
+      assert_raise Mix.Error, ~r"Mix.install/2 declared it supports only Elixir ~> 2.0", fn ->
+        Mix.install(
+          [
+            {:install_test, path: Path.join(tmp_dir, "install_test")}
+          ],
+          elixir: "~> 2.0"
+        )
+      end
+    end
+
+    test "errors with same deps and force", %{tmp_dir: tmp_dir} do
+      Mix.install([
+        {:install_test, path: Path.join(tmp_dir, "install_test")}
+      ])
+
+      assert_raise Mix.Error, ~r"Mix.install/2 can only be called", fn ->
+        Mix.install(
+          [
+            {:install_test, path: Path.join(tmp_dir, "install_test")}
+          ],
+          force: true
+        )
+      end
+    end
+
+    test "errors with different deps in the same VM", %{tmp_dir: tmp_dir} do
+      Mix.install([
+        {:install_test, path: Path.join(tmp_dir, "install_test")}
+      ])
+
+      assert_raise Mix.Error, ~r"Mix.install/2 can only be called", fn ->
+        Mix.install([
+          {:install_test, path: Path.join(tmp_dir, "install_test")},
+          :foo
+        ])
+      end
+    end
+
+    test "install after errors", %{tmp_dir: tmp_dir} do
+      assert_raise Mix.Error, "Can't continue due to errors on dependencies", fn ->
+        Mix.install([
+          {:bad, path: Path.join(tmp_dir, "bad")}
+        ])
+      end
+
+      Mix.install([
+        {:install_test, path: Path.join(tmp_dir, "install_test")}
+      ])
+
+      assert apply(InstallTest, :hello, []) == :world
+    end
+
+    test "consolidate_protocols: false", %{tmp_dir: tmp_dir} do
+      Mix.install(
+        [
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ],
+        consolidate_protocols: false
+      )
+
+      refute Protocol.consolidated?(InstallTest.Protocol)
+    end
+
+    test ":config and :system_env", %{tmp_dir: tmp_dir} do
+      Mix.install(
+        [
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ],
+        config: [unknown_app: [foo: :bar]],
+        system_env: %{"MIX_INSTALL_FOO" => "BAR", MIX_INSTALL_BAZ: "BAT"}
+      )
+
+      assert Application.fetch_env!(:unknown_app, :foo) == :bar
+      assert System.fetch_env!("MIX_INSTALL_FOO") == "BAR"
+      assert System.fetch_env!("MIX_INSTALL_BAZ") == "BAT"
+    after
+      System.delete_env("MIX_INSTALL_FOO")
+      System.delete_env("MIX_INSTALL_BAZ")
+      Application.delete_env(:unknown_app, :foo, persistent: true)
+    end
+
+    test ":config_path with application name", %{tmp_dir: tmp_dir} do
+      config_path = Path.join(tmp_dir, "install_test/config/config.exs")
+      config_path |> Path.dirname() |> File.mkdir_p!()
+
+      File.write!(config_path, """
+      import Config
+      config :myapp, :foo, 1
+      """)
+
+      Mix.install(
+        [
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ],
+        config_path: :install_test
+      )
+
+      assert Application.fetch_env!(:myapp, :foo) == 1
+    after
+      Application.delete_env(:myapp, :foo)
+    end
+
+    test ":config_path", %{tmp_dir: tmp_dir} do
+      config_path = Path.join(tmp_dir, "config.exs")
+
+      File.write!(config_path, """
+      import Config
+      config :myapp, :foo, 1
+      """)
+
+      Mix.install(
+        [
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ],
+        config_path: config_path
+      )
+
+      assert Application.fetch_env!(:myapp, :foo) == 1
+    after
+      Application.delete_env(:myapp, :foo)
+    end
+
+    test ":config_path and runtime config", %{tmp_dir: tmp_dir} do
+      config_path = Path.join(tmp_dir, "config.exs")
+
+      File.write!(config_path, """
+      import Config
+      config :myapp, :foo, 1
+      """)
+
+      File.write!(Path.join(tmp_dir, "runtime.exs"), """
+      import Config
+      config :myapp, :bar, 2
+      """)
+
+      Mix.install(
+        [
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ],
+        config_path: config_path
+      )
+
+      assert Application.fetch_env!(:myapp, :foo) == 1
+      assert Application.fetch_env!(:myapp, :bar) == 2
+    after
+      Application.delete_env(:myapp, :foo)
+      Application.delete_env(:myapp, :bar)
+    end
+
+    test ":config_path that does not exist" do
+      assert_raise File.Error, ~r/bad.exs": no such file or directory/, fn ->
+        Mix.install([], config_path: "bad.exs")
+      end
+    end
+
+    defmodule GitApp do
+      def project do
+        [
+          app: :git_app,
+          version: "0.1.0",
+          deps: [
+            {:git_repo, "0.1.0", [git: fixture_path("git_repo")]}
+          ]
+        ]
+      end
+    end
+
+    test ":lockfile with first build", %{tmp_dir: tmp_dir} do
+      Mix.Project.push(GitApp)
+      [_latest_rev, rev | _] = get_git_repo_revs("git_repo")
+      lockfile = Path.join(tmp_dir, "lock")
+      Mix.Dep.Lock.write(%{git_repo: {:git, fixture_path("git_repo"), rev, []}}, file: lockfile)
+      Mix.ProjectStack.pop()
+
+      Mix.install(
+        [
+          {:git_repo, git: fixture_path("git_repo")}
+        ],
+        lockfile: lockfile
+      )
+
+      assert_received {:mix_shell, :info, ["* Getting git_repo " <> _]}
+
+      install_project_dir = Mix.install_project_dir()
+      assert File.read!(Path.join(install_project_dir, "mix.lock")) =~ rev
+    end
+
+    test ":lockfile merging", %{tmp_dir: tmp_dir} do
+      [rev1, rev2 | _] = get_git_repo_revs("git_repo")
+
+      Mix.install([
+        {:git_repo, git: fixture_path("git_repo")}
+      ])
+
+      assert_received {:mix_shell, :info, ["* Getting git_repo " <> _]}
+
+      install_project_dir = Mix.install_project_dir()
+      assert File.read!(Path.join(install_project_dir, "mix.lock")) =~ rev1
+
+      Mix.Project.push(GitApp)
+      lockfile = Path.join(tmp_dir, "lock")
+      Mix.Dep.Lock.write(%{git_repo: {:git, fixture_path("git_repo"), rev2, []}}, file: lockfile)
+      Mix.ProjectStack.pop()
+
+      Mix.install(
+        [
+          {:git_repo, git: fixture_path("git_repo")}
+        ],
+        lockfile: lockfile
+      )
+
+      assert File.read!(Path.join(install_project_dir, "mix.lock")) =~ rev1
+    end
+
+    test ":lockfile with application name", %{tmp_dir: tmp_dir} do
+      lockfile = Path.join(tmp_dir, "install_test/mix.lock")
+      lockfile |> Path.dirname() |> File.mkdir_p!()
+      Mix.Project.push(GitApp)
+      [_latest_rev, rev | _] = get_git_repo_revs("git_repo")
+      Mix.Dep.Lock.write(%{git_repo: {:git, fixture_path("git_repo"), rev, []}}, file: lockfile)
+      Mix.ProjectStack.pop()
+
+      Mix.install(
+        [
+          {:install_test, path: Path.join(tmp_dir, "install_test")},
+          {:git_repo, git: fixture_path("git_repo")}
+        ],
+        lockfile: :install_test
+      )
+
+      assert_received {:mix_shell, :info, ["* Getting git_repo " <> _]}
+      install_project_dir = Mix.install_project_dir()
+      assert File.read!(Path.join(install_project_dir, "mix.lock")) =~ rev
+    end
+
+    test ":lockfile that does not exist" do
+      assert_raise File.Error, ~r/bad": no such file or directory/, fn ->
+        Mix.install([], lockfile: "bad")
+      end
+    end
+
+    test "using restore dir", %{tmp_dir: tmp_dir} do
+      with_cleanup(fn ->
+        Mix.install([
+          {:git_repo, git: fixture_path("git_repo")}
+        ])
+
+        assert_received {:mix_shell, :info, ["* Getting git_repo " <> _]}
+        assert_received {:mix_shell, :info, ["==> git_repo"]}
+        assert_received {:mix_shell, :info, ["Compiling 1 file (.ex)"]}
+        assert_received {:mix_shell, :info, ["Generated git_repo app"]}
+        refute_received _
+
+        install_project_dir = Mix.install_project_dir()
+        build_lib_path = Path.join([install_project_dir, "_build", "dev", "lib"])
+        deps_path = Path.join([install_project_dir, "deps"])
+
+        assert File.ls!(build_lib_path) |> Enum.sort() == ["git_repo", "mix_install"]
+        assert File.ls!(deps_path) == ["git_repo"]
+
+        System.put_env("MIX_INSTALL_RESTORE_PROJECT_DIR", install_project_dir)
+      end)
+
+      # Adding a dependency
+
+      with_cleanup(fn ->
+        Mix.install([
+          {:git_repo, git: fixture_path("git_repo")},
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ])
+
+        assert_received {:mix_shell, :info, ["==> install_test"]}
+        assert_received {:mix_shell, :info, ["Compiling 2 files (.ex)"]}
+        assert_received {:mix_shell, :info, ["Generated install_test app"]}
+        refute_received _
+
+        install_project_dir = Mix.install_project_dir()
+        build_lib_path = Path.join([install_project_dir, "_build", "dev", "lib"])
+        deps_path = Path.join([install_project_dir, "deps"])
+
+        assert File.ls!(build_lib_path) |> Enum.sort() ==
+                 ["git_repo", "install_test", "mix_install"]
+
+        assert File.ls!(deps_path) == ["git_repo"]
+
+        System.put_env("MIX_INSTALL_RESTORE_PROJECT_DIR", install_project_dir)
+      end)
+
+      # Removing a dependency
+
+      with_cleanup(fn ->
+        Mix.install([
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ])
+
+        refute_received _
+
+        install_project_dir = Mix.install_project_dir()
+        build_lib_path = Path.join([install_project_dir, "_build", "dev", "lib"])
+        deps_path = Path.join([install_project_dir, "deps"])
+
+        assert File.ls!(build_lib_path) |> Enum.sort() == ["install_test", "mix_install"]
+        assert File.ls!(deps_path) == []
+      end)
+    after
+      System.delete_env("MIX_INSTALL_RESTORE_PROJECT_DIR")
+    end
+
+    test "using restore dir removes consolidated files when not needed", %{tmp_dir: tmp_dir} do
+      with_cleanup(fn ->
+        Mix.install([
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ])
+
+        install_project_dir = Mix.install_project_dir()
+        build_lib_path = Path.join([install_project_dir, "_build", "dev", "lib"])
+        build_project_path = Path.join(build_lib_path, "mix_install")
+
+        assert File.ls!(build_project_path) |> Enum.sort() == [".mix", "consolidated", "ebin"]
+
+        System.put_env("MIX_INSTALL_RESTORE_PROJECT_DIR", install_project_dir)
+      end)
+
+      with_cleanup(fn ->
+        Mix.install(
+          [
+            {:install_test, path: Path.join(tmp_dir, "install_test")}
+          ],
+          consolidate_protocols: false
+        )
+
+        install_project_dir = Mix.install_project_dir()
+        build_lib_path = Path.join([install_project_dir, "_build", "dev", "lib"])
+        build_project_path = Path.join(build_lib_path, "mix_install")
+
+        assert File.ls!(build_project_path) |> Enum.sort() == [".mix", "ebin"]
+      end)
+    after
+      System.delete_env("MIX_INSTALL_RESTORE_PROJECT_DIR")
+    end
+
+    test "custom compilers", %{tmp_dir: tmp_dir} do
+      File.mkdir_p!("#{tmp_dir}/install_test/lib/mix/tasks/compile/")
+
+      File.write!("#{tmp_dir}/install_test/lib/mix/tasks/compile/install_test.ex", """
+      defmodule Mix.Tasks.Compile.InstallTest do
+        use Mix.Task.Compiler
+
+        def run(_args) do
+          Mix.shell().info("Hello from custom compiler!")
+
+          :noop
+        end
+      end
+      """)
+
+      Mix.install(
+        [
+          {:install_test, path: Path.join(tmp_dir, "install_test")}
+        ],
+        compilers: [:elixir, :install_test]
+      )
+
+      assert File.dir?(Path.join(tmp_dir, "installs"))
+
+      assert Protocol.consolidated?(InstallTest.Protocol)
+
+      assert_received {:mix_shell, :info, ["==> install_test"]}
+      assert_received {:mix_shell, :info, ["Compiling 3 files (.ex)"]}
+      assert_received {:mix_shell, :info, ["Generated install_test app"]}
+      assert_received {:mix_shell, :info, ["==> mix_install"]}
+      assert_received {:mix_shell, :info, ["Hello from custom compiler!"]}
+      refute_received _
+
+      assert List.keyfind(Application.started_applications(), :install_test, 0)
+      assert apply(InstallTest, :hello, []) == :world
+    end
+
+    test "installed?", %{tmp_dir: tmp_dir} do
+      refute Mix.installed?()
+
+      Mix.install([
+        {:install_test, path: Path.join(tmp_dir, "install_test")}
+      ])
+
+      assert Mix.installed?()
+    end
+
+    test "in_install_project", %{tmp_dir: tmp_dir} do
+      Mix.install([
+        {:install_test, path: Path.join(tmp_dir, "install_test")}
+      ])
+
+      Mix.in_install_project(fn ->
+        config = Mix.Project.config()
+        assert [{:install_test, [path: _]}] = config[:deps]
+      end)
+    end
+
+    test "in_install_project recompile", %{tmp_dir: tmp_dir} do
+      Mix.install([
+        {:install_test, path: Path.join(tmp_dir, "install_test")}
+      ])
+
+      File.write!("#{tmp_dir}/install_test/lib/install_test.ex", """
+      defmodule InstallTest do
+        def hello do
+          :universe
+        end
+      end
+      """)
+
+      Mix.in_install_project(fn ->
+        Mix.Task.run("compile")
+        assert apply(InstallTest, :hello, []) == :universe
+      end)
+    end
+
+    defp test_project(%{tmp_dir: tmp_dir}) do
+      path = :code.get_path()
+
+      on_exit(fn ->
+        :code.set_path(path)
+        cleanup_deps()
+      end)
+
+      Mix.State.put(:installed, nil)
+
+      File.mkdir_p!("#{tmp_dir}/install_test/lib")
+
+      File.write!("#{tmp_dir}/install_test/mix.exs", """
+      defmodule InstallTest.MixProject do
+        use Mix.Project
+
+        def project do
+          [
+            app: :install_test,
+            version: "0.1.0"
+          ]
+        end
+      end
+      """)
+
+      File.write!("#{tmp_dir}/install_test/lib/install_test.ex", """
+      defmodule InstallTest do
+        def hello do
+          :world
+        end
+      end
+      """)
+
+      File.write!("#{tmp_dir}/install_test/lib/install_test_protocol.ex", """
+      defprotocol InstallTest.Protocol do
+        def foo(x)
+      end
+      """)
+
+      [tmp_dir: tmp_dir]
+    end
+
+    defp with_cleanup(fun) do
+      path = :code.get_path()
+
+      try do
+        fun.()
+      after
+        :code.set_path(path)
+        cleanup_deps()
+
+        Mix.State.clear_cache()
+        Mix.State.put(:installed, nil)
+      end
+    end
+
+    defp cleanup_deps() do
+      purge([
+        GitRepo,
+        GitRepo.MixProject,
+        InstallTest,
+        InstallTest.MixProject,
+        InstallTest.Protocol
+      ])
+
+      ExUnit.CaptureLog.capture_log(fn ->
+        Application.stop(:git_repo)
+        Application.unload(:git_repo)
+
+        Application.stop(:install_test)
+        Application.unload(:install_test)
+      end)
+    end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/mix/test/test_helper.exs b/lib/mix/test/test_helper.exs
index 6fc3219aa4f..671e4e0f5b1 100644
--- a/lib/mix/test/test_helper.exs
+++ b/lib/mix/test/test_helper.exs
@@ -1,15 +1,78 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+home = Path.expand("../tmp/.home", __DIR__)
+File.mkdir_p!(home)
+System.put_env("HOME", home)
+
+mix = Path.expand("../tmp/.mix", __DIR__)
+File.mkdir_p!(mix)
+System.put_env("MIX_HOME", mix)
+
+# Load protocols to make sure they are not unloaded during tests
+[Collectable, Enumerable, Inspect, String.Chars, List.Chars]
+|> Enum.each(& &1.__protocol__(:module))
+
+## Setup Mix
+
 Mix.start()
 Mix.shell(Mix.Shell.Process)
+Application.put_env(:mix, :colors, enabled: false)
+Application.put_env(:logger, :default_handler, false)
+
+## Setup ExUnit
+
+os_exclude = if match?({:win32, _}, :os.type()), do: [unix: true], else: [windows: true]
+epmd_exclude = if match?({:win32, _}, :os.type()), do: [epmd: true], else: []
+
+git_exclude =
+  Mix.SCM.Git.unsupported_options()
+  |> Enum.map(fn
+    :sparse -> {:git_sparse, true}
+    :depth -> {:git_depth, true}
+  end)
+
+{line_exclude, line_include} =
+  if line = System.get_env("LINE"), do: {[:test], [line: line]}, else: {[], []}
+
+cover_exclude =
+  if :deterministic in :compile.env_compiler_options() do
+    [:cover]
+  else
+    []
+  end
+
+# OTP 28.1+
+re_import_exclude =
+  if Code.ensure_loaded?(:re) and function_exported?(:re, :import, 1) do
+    []
+  else
+    [:re_import]
+  end
 
-ExUnit.start [trace: "--trace" in System.argv]
+Code.require_file("../../elixir/scripts/cover_record.exs", __DIR__)
+CoverageRecorder.maybe_record("mix")
+
+ExUnit.start(
+  trace: !!System.get_env("TRACE"),
+  exclude:
+    epmd_exclude ++
+      os_exclude ++ git_exclude ++ line_exclude ++ cover_exclude ++ re_import_exclude,
+  include: line_include,
+  assert_receive_timeout: String.to_integer(System.get_env("ELIXIR_ASSERT_TIMEOUT", "300"))
+)
 
 defmodule MixTest.Case do
   use ExUnit.CaseTemplate
 
   defmodule Sample do
     def project do
-      [ app: :sample,
-        version: "0.1.0" ]
+      [app: :sample, version: "0.1.0", aliases: [sample: "compile"]]
+    end
+
+    def application do
+      Process.get({__MODULE__, :application}) || []
     end
   end
 
@@ -19,22 +82,28 @@ defmodule MixTest.Case do
     end
   end
 
+  @apps Enum.map(Application.loaded_applications(), &elem(&1, 0))
+
   setup do
-    on_exit fn ->
+    on_exit(fn ->
+      Application.start(:logger)
       Mix.env(:dev)
-      Mix.Task.clear
-      Mix.Shell.Process.flush
-      Mix.ProjectStack.clear_cache
-      Mix.ProjectStack.clear_stack
-      System.put_env("MIX_HOME", tmp_path(".mix"))
-      delete_tmp_paths
-    end
+      Mix.target(:host)
+      Mix.Task.clear()
+      Mix.Shell.Process.flush()
+      Mix.State.clear_cache()
+      Mix.ProjectStack.clear_stack()
+      delete_tmp_paths()
+
+      for {app, _, _} <- Application.loaded_applications(), app not in @apps do
+        Application.stop(app)
+        Application.unload(app)
+      end
 
-    :ok
-  end
+      :ok
+    end)
 
-  def elixir_root do
-    Path.expand("../../..", __DIR__)
+    :ok
   end
 
   def fixture_path do
@@ -42,7 +111,7 @@ defmodule MixTest.Case do
   end
 
   def fixture_path(extension) do
-    Path.join fixture_path, extension
+    Path.join(fixture_path(), remove_colons(extension))
   end
 
   def tmp_path do
@@ -50,27 +119,39 @@ defmodule MixTest.Case do
   end
 
   def tmp_path(extension) do
-    Path.join tmp_path, extension
+    Path.join(tmp_path(), remove_colons(extension))
+  end
+
+  defp remove_colons(term) do
+    term
+    |> to_string()
+    |> String.replace(":", "")
   end
 
   def purge(modules) do
-    Enum.each modules, fn(m) ->
-      :code.delete(m)
+    Enum.each(modules, fn m ->
       :code.purge(m)
-    end
+      :code.delete(m)
+    end)
   end
 
   def in_tmp(which, function) do
     path = tmp_path(which)
-    File.rm_rf! path
-    File.mkdir_p! path
-    File.cd! path, function
+    File.rm_rf!(path)
+    File.mkdir_p!(path)
+    File.cd!(path, function)
   end
 
   defmacro in_fixture(which, block) do
-    module   = inspect __CALLER__.module
-    function = Atom.to_string elem(__CALLER__.function, 0)
-    tmp      = Path.join(module, function)
+    module = inspect(__CALLER__.module)
+
+    function =
+      case __CALLER__.function do
+        {name, _arity} -> Atom.to_string(name)
+        nil -> raise "expected in_fixture/2 to be called from a function"
+      end
+
+    tmp = Path.join(module, function)
 
     quote do
       unquote(__MODULE__).in_fixture(unquote(which), unquote(tmp), unquote(block))
@@ -78,172 +159,378 @@ defmodule MixTest.Case do
   end
 
   def in_fixture(which, tmp, function) do
-    src  = fixture_path(which)
-    dest = tmp_path(tmp)
-    flag = tmp_path |> String.to_char_list
+    src = fixture_path(which)
+    dest = tmp_path(String.replace(tmp, ":", "_"))
+    flag = String.to_charlist(tmp_path())
 
     File.rm_rf!(dest)
     File.mkdir_p!(dest)
     File.cp_r!(src, dest)
 
-    get_path = :code.get_path
-    previous = :code.all_loaded
+    get_path = :code.get_path()
+    previous = :code.all_loaded()
 
     try do
-      File.cd! dest, function
+      File.cd!(dest, function)
     after
       :code.set_path(get_path)
-      Enum.each (:code.all_loaded -- previous), fn {mod, file} ->
-        if is_list(file) and :lists.prefix(flag, file) do
-          purge [mod]
-        end
+
+      for {mod, file} <- :code.all_loaded() -- previous,
+          file == [] or (is_list(file) and List.starts_with?(file, flag)) do
+        purge([mod])
       end
     end
   end
 
   def ensure_touched(file) do
-    ensure_touched(file, File.stat!(file).mtime)
+    ensure_touched(file, file)
   end
 
-  def ensure_touched(file, current) do
+  def ensure_touched(file, current) when is_binary(current) do
+    case File.stat(current) do
+      {:ok, %{mtime: mtime}} -> ensure_touched(file, mtime)
+      {:error, _} -> File.touch!(file)
+    end
+  end
+
+  def ensure_touched(file, current) when is_tuple(current) do
     File.touch!(file)
-    unless File.stat!(file).mtime > current do
+    mtime = File.stat!(file).mtime
+
+    if mtime <= current do
+      seconds =
+        :calendar.datetime_to_gregorian_seconds(current) -
+          :calendar.datetime_to_gregorian_seconds(mtime)
+
+      Process.sleep(seconds * 1000)
       ensure_touched(file, current)
     end
   end
 
-  def os_newline do
-    case :os.type do
-      {:win32, _} -> "\r\n"
-      _ -> "\n"
-    end
+  if match?({:win32, _}, :os.type()) do
+    def windows?, do: true
+    def os_newline, do: "\r\n"
+  else
+    def windows?, do: false
+    def os_newline, do: "\n"
   end
 
-  defp delete_tmp_paths do
-    tmp = tmp_path |> String.to_char_list
-    to_remove = Enum.filter :code.get_path, fn(path) -> :string.str(path, tmp) != 0 end
-    Enum.map to_remove, &(:code.del_path(&1))
+  def mix(args, envs \\ []) when is_list(args) do
+    mix_code(args, envs) |> elem(0)
   end
-end
 
-## Copy fixtures to tmp
+  def mix_code(args, envs \\ []) when is_list(args) do
+    args = ["-r", mix_executable(), "--" | args]
+    System.cmd(elixir_executable(), args, stderr_to_stdout: true, env: envs)
+  end
+
+  def mix_port(args, envs \\ []) when is_list(args) do
+    Port.open({:spawn_executable, elixir_executable()}, [
+      {:args, ["-r", mix_executable(), "--" | args]},
+      {:env, envs},
+      :binary,
+      :use_stdio,
+      :stderr_to_stdout
+    ])
+  end
 
-source = MixTest.Case.fixture_path("rebar_dep")
-dest = MixTest.Case.tmp_path("rebar_dep")
-File.mkdir_p!(dest)
-File.cp_r!(source, dest)
+  def force_recompilation(file) do
+    File.write!(file, File.read!(file) <> "\n")
+  end
 
-## Generate git repo fixtures
+  def mix_executable do
+    Path.expand("../../../bin/mix", __DIR__)
+  end
+
+  def elixir_executable do
+    Path.expand("../../../bin/elixir", __DIR__)
+  end
+
+  defp delete_tmp_paths do
+    tmp = tmp_path() |> String.to_charlist()
+    for path <- :code.get_path(), :string.str(path, tmp) != 0, do: :code.del_path(path)
+  end
+
+  def get_git_repo_revs(repo) do
+    File.cd!(fixture_path(repo), fn ->
+      Regex.split(~r/\r?\n/, System.cmd("git", ["log", "--format=%H"]) |> elem(0), trim: true)
+    end)
+  end
+end
 
-# Git repo
+# Prepare and clear environment variables
+System.put_env(
+  "MIX_OS_DEPS_COMPILE_PARTITION_ELIXIR_EXECUTABLE",
+  MixTest.Case.elixir_executable()
+)
+
+# Clear environment variables that may affect tests
+Enum.each(
+  ~w(http_proxy https_proxy HTTP_PROXY HTTPS_PROXY) ++
+    ~w(MIX_ENV MIX_OS_DEPS_COMPILE_PARTITION_COUNT MIX_TARGET) ++
+    ~w(XDG_DATA_HOME XDG_CONFIG_HOME),
+  &System.delete_env/1
+)
+
+## Set up Rebar fixtures
+
+rebar3_source = System.get_env("REBAR3") || Path.expand("fixtures/rebar3", __DIR__)
+[major, minor | _] = String.split(System.version(), ".")
+version_dir = "#{major}-#{minor}-otp-#{System.otp_release()}"
+rebar3_target = Path.join([mix, "elixir", version_dir, "rebar3"])
+File.mkdir_p!(Path.dirname(rebar3_target))
+File.cp!(rebar3_source, rebar3_target)
+
+fixtures = ~w(rebar_dep rebar_override)
+
+Enum.each(fixtures, fn fixture ->
+  source = MixTest.Case.fixture_path(fixture)
+  dest = MixTest.Case.tmp_path(fixture)
+  File.mkdir_p!(dest)
+  File.cp_r!(source, dest)
+end)
+
+## Set up Git fixtures
+
+System.cmd("git", ~w[config --global user.email mix@example.com])
+System.cmd("git", ~w[config --global user.name mix-repo])
+System.cmd("git", ~w[config --global init.defaultBranch not-main])
+
+### Git repo
 target = Path.expand("fixtures/git_repo", __DIR__)
 
-unless File.dir?(target) do
+if not File.dir?(target) do
   File.mkdir_p!(Path.join(target, "lib"))
 
-  File.write! Path.join(target, "mix.exs"), """
+  File.write!(Path.join(target, "mix.exs"), """
   ## Auto-generated fixture
   raise "I was not supposed to be loaded"
-  """
+  """)
 
-  File.cd! target, fn ->
-    System.cmd("git init")
-    System.cmd("git config user.email \"mix@example.com\"")
-    System.cmd("git config user.name \"Mix Repo\"")
-    System.cmd("git add .")
-    System.cmd("git commit -m \"bad\"")
-  end
+  File.cd!(target, fn ->
+    System.cmd("git", ~w[init])
+    System.cmd("git", ~w[add .])
+    System.cmd("git", ~w[commit -m "bad"])
+    System.cmd("git", ~w[checkout -q -b main])
+    System.cmd("git", ~w[symbolic-ref HEAD refs/heads/main])
+  end)
 
-  File.write! Path.join(target, "mix.exs"), """
+  File.write!(Path.join(target, "mix.exs"), """
   ## Auto-generated fixture
-  defmodule GitRepo.Mix do
+  defmodule GitRepo.MixProject do
     use Mix.Project
 
     def project do
-      [app: :git_repo, version: "0.1.0"]
+      [
+        app: :git_repo,
+        version: "0.1.0"
+      ]
     end
   end
-  """
+  """)
 
-  File.cd! target, fn ->
-    System.cmd("git add .")
-    System.cmd("git commit -m \"ok\"")
-  end
+  File.cd!(target, fn ->
+    System.cmd("git", ~w[add .])
+    System.cmd("git", ~w[commit -m "ok"])
+    System.cmd("git", ~w[tag without_module])
+  end)
 
-  File.write! Path.join(target, "lib/git_repo.ex"), """
+  File.write!(Path.join(target, "lib/git_repo.ex"), """
   ## Auto-generated fixture
   defmodule GitRepo do
     def hello do
       "World"
     end
   end
-  """
+  """)
+
+  ## Sparse
+  subdir = Path.join(target, "sparse_dir")
+  File.mkdir_p!(Path.join(subdir, "lib"))
+
+  File.write!(Path.join(subdir, "mix.exs"), """
+  ## Auto-generated fixture
+  defmodule GitSparseRepo.MixProject do
+    use Mix.Project
+
+    def project do
+      [
+        app: :git_sparse_repo,
+        version: "0.1.0"
+      ]
+    end
+  end
+  """)
 
-  File.cd! target, fn ->
-    System.cmd("git add .")
-    System.cmd("git commit -m \"lib\"")
+  File.write!(Path.join(subdir, "lib/git_sparse_repo.ex"), """
+  ## Auto-generated fixture
+  defmodule GitSparseRepo do
+    def hello do
+      "World"
+    end
   end
+  """)
+
+  File.cd!(target, fn ->
+    System.cmd("git", ~w[add .])
+    System.cmd("git", ~w[commit -m "lib"])
+    System.cmd("git", ~w[tag with_module])
+  end)
 end
 
-# Deps on git repo
+### Deps on Git repo
 target = Path.expand("fixtures/deps_on_git_repo", __DIR__)
 
-unless File.dir?(target) do
+if not File.dir?(target) do
   File.mkdir_p!(Path.join(target, "lib"))
 
-  File.write! Path.join(target, "mix.exs"), """
+  File.write!(Path.join(target, "mix.exs"), """
   ## Auto-generated fixture
-  defmodule DepsOnGitRepo.Mix do
+  defmodule DepsOnGitRepo.MixProject do
     use Mix.Project
 
     def project do
-      [ app: :deps_on_git_repo,
-        version: "0.2.0",
-        deps: [{:git_repo, git: MixTest.Case.fixture_path("git_repo")}] ]
+      [
+        app: :deps_on_git_repo,
+        version: "0.1.0",
+      ]
     end
   end
-  """
+  """)
 
-  File.cd! target, fn ->
-    System.cmd("git init")
-    System.cmd("git config user.email \"mix@example.com\"")
-    System.cmd("git config user.name \"Mix Repo\"")
-    System.cmd("git add .")
-    System.cmd("git commit -m \"ok\"")
+  File.cd!(target, fn ->
+    System.cmd("git", ~w[init])
+    System.cmd("git", ~w[add .])
+    System.cmd("git", ~w[commit -m without-dep])
+    System.cmd("git", ~w[checkout -q -b main])
+    System.cmd("git", ~w[symbolic-ref HEAD refs/heads/main])
+  end)
+
+  File.write!(Path.join(target, "mix.exs"), """
+  ## Auto-generated fixture
+  defmodule DepsOnGitRepo.MixProject do
+    use Mix.Project
+
+    def project do
+      [
+        app: :deps_on_git_repo,
+        version: "0.2.0",
+        deps: [
+          {:git_repo, git: MixTest.Case.fixture_path("git_repo")}
+        ]
+      ]
+    end
   end
+  """)
+
+  File.write!(Path.join(target, "lib/deps_on_git_repo.ex"), """
+  ## Auto-generated fixture
+  GitRepo.hello()
+  """)
+
+  File.cd!(target, fn ->
+    System.cmd("git", ~w[add .])
+    System.cmd("git", ~w[commit -m with-dep])
+  end)
 end
 
-# Git rebar
+# Git Rebar
 target = Path.expand("fixtures/git_rebar", __DIR__)
 
-unless File.dir?(target) do
+if not File.dir?(target) do
+  File.mkdir_p!(Path.join(target, "ebin"))
   File.mkdir_p!(Path.join(target, "src"))
 
-  File.write! Path.join([target, "src", "git_rebar.app.src"]), """
+  # This is used to test that the built-in ebin is ignored.
+  File.write!(Path.join(target, "ebin/.unused"), """
+  """)
+
+  File.write!(Path.join(target, "src/git_rebar.app.src"), """
   {application, git_rebar,
     [
       {vsn, "0.1.0"}
     ]}.
-  """
+  """)
 
-  File.write! Path.join([target, "src", "git_rebar.erl"]), """
+  File.write!(Path.join(target, "src/git_rebar.erl"), """
   -module(git_rebar).
+  -export([any_function/0]).
+  any_function() -> ok.
+  """)
+
+  File.cd!(target, fn ->
+    System.cmd("git", ~w[init])
+    System.cmd("git", ~w[add .])
+    System.cmd("git", ~w[commit -m "ok"])
+    System.cmd("git", ~w[checkout -q -b main])
+    System.cmd("git", ~w[symbolic-ref HEAD refs/heads/main])
+  end)
+end
 
-  -export ([any_function/0]).
+Enum.each([:invalidapp, :invalidvsn, :noappfile, :nosemver, :ok], fn dep ->
+  File.mkdir_p!(Path.expand("fixtures/deps_status/deps/#{dep}/.git", __DIR__))
+end)
 
-  any_function() ->
-      ok.
+### Archive ebin
+target = Path.expand("fixtures/archive", __DIR__)
+
+if not File.dir?(Path.join(target, "ebin")) do
+  File.mkdir_p!(Path.join(target, "ebin"))
+
+  File.write!(Path.join([target, "ebin", "local_sample.app"]), """
+  {application,local_sample,
+    [
+      {modules,['Elixir.Mix.Tasks.Local.Sample']},
+      {applications,[kernel,stdlib,elixir]}
+    ]
+  }.
+  """)
+
+  [{name, bin}] = Code.compile_file("lib/local.sample.ex", target)
+
+  File.write!(Path.join([target, "ebin", Atom.to_string(name) <> ".beam"]), bin)
+end
+
+## Generate helper modules
+
+path = MixTest.Case.tmp_path("beams")
+File.rm_rf!(path)
+File.mkdir_p!(path)
+
+write_beam = fn {:module, name, bin, _} ->
+  path
+  |> Path.join(Atom.to_string(name) <> ".beam")
+  |> File.write!(bin)
+end
+
+defmodule Mix.Tasks.Hello do
+  use Mix.Task
+  @shortdoc "This is short documentation, see"
+
+  @moduledoc """
+  A test task.
   """
 
-  File.cd! target, fn ->
-    System.cmd("git init")
-    System.cmd("git config user.email \"mix@example.com\"")
-    System.cmd("git config user.name \"Mix Repo\"")
-    System.cmd("git add .")
-    System.cmd("git commit -m \"ok\"")
+  def run([]) do
+    "Hello, World!"
   end
+
+  def run(["--parser" | args]) do
+    OptionParser.parse!(args, strict: [int: :integer])
+  end
+
+  def run(args) do
+    "Hello, #{Enum.join(args, " ")}!"
+  end
+end
+|> write_beam.()
+
+defmodule Mix.Tasks.Invalid do
 end
+|> write_beam.()
 
-Enum.each [:invalidapp, :invalidvsn, :noappfile, :ok], fn(dep) ->
-  File.mkdir_p! Path.expand("fixtures/deps_status/deps/#{dep}/.git", __DIR__)
+defmodule Mix.Tasks.Acronym.HTTP do
+  use Mix.Task
+  def run(_), do: "An HTTP Task"
 end
+|> write_beam.()
diff --git a/man/common b/man/common
new file mode 100644
index 00000000000..fb1e1125da6
--- /dev/null
+++ b/man/common
@@ -0,0 +1,117 @@
+.\" SPDX-License-Identifier: Apache-2.0
+.\" SPDX-FileCopyrightText: 2021 The Elixir Team
+.\" SPDX-FileCopyrightText: 2012 Plataformatec
+.It Fl h , -help
+Displays the help message to the standard error (stderr) and exits.
+.It Fl v , -version
+Displays the Elixir version to the standard output (stdout) and exits.
+.It Fl e , -eval Ar expression
+Evaluates the specified expression
+.Pq see the Fl -rpc-eval No option .
+.It Fl r Ar file
+Requires the specified file. In other words, the file is checked for existence at the start of
+.Nm .
+.It Fl S Ar script
+Runs the specified script.
+.It Fl pa Ar directory
+Adds the specified directory to the beginning of the code path. If the directory already exists, it will be removed from its old position and put to the beginning.
+.Pp
+See also the function
+.Sy Code.prepend_path/1 .
+.It Fl pr Ar file
+Does the same thing as
+.Fl r
+.Pq see above
+but in parallel.
+.It Fl pz Ar directory
+Adds the specified directory to the end of the code path. If the directory already exists, it will be neither removed from its old position nor put to the end.
+.Pp
+See also the function
+.Sy Code.append_path/1 .
+.It Fl -app Ar application
+Starts the specified application and all its dependencies.
+.It Fl -boot Ar file
+Specifies the name of the boot file,
+.Ar file Ns .boot, which is used to start the system. Unless File contains an absolute path, the system searches for Ar file Ns .boot in the current and $ROOT/bin directories.
+.Pp
+Defaults to $ROOT/bin/start.boot.
+.Pp
+The option is equivalent to Erlang's
+.Fl boot .
+.It Fl -boot-var Ar var Ar dir
+If the boot script contains a path variable
+.Ar var
+other than $ROOT, this variable is expanded to
+.Ar dir .
+Used when applications are installed in another directory than $ROOT/lib.
+.Pp
+The option is equivalent to Erlang's
+.Fl boot_var .
+.Pp
+See also the function
+.Sy :systools.make_script/1,2 No in SASL .
+.It Fl -erl Ar parameters
+Serves the same purpose as ELIXIR_ERL_OPTIONS
+.Pq see the Sy ENVIRONMENT No section
+.It Fl -erl-config Ar file
+Specifies the name of a configuration file,
+.Ar file Ns .config, which is used to configure applications. Note that the configuration file must be written in Erlang.
+.Pp
+The option is equivalent to Erlang's
+.Fl config .
+.It Fl -cookie Ar value
+Specifies the magic cookie value. If the value isn't specified via the option when the node starts, it will be taken from the file
+.Pa ~/.erlang.cookie
+.Pq see the Sy FILES No section .
+Distributed nodes can interact with each other only when their magic cookies are equal.
+.Pp
+See also the function
+.Sy Node.set_cookie/2 .
+.It Fl -hidden
+Starts a hidden node.
+.Pp
+Connections between nodes are transitive. For example, if node A is connected to node B, and node B is connected to node C, then node A is connected to node C. The option
+.Fl -hidden
+allows creating a node which can be connected to another node, escaping redundant connections.
+.Pp
+The function
+.Sy Node.list/0
+allows getting the list of nodes connected to the target node; however, the list won't include hidden nodes. Depending on the input parameter, the function
+.Sy Node.list/1
+allows getting the list which contains only hidden nodes
+.Pq the parameter Ar :hidden
+or both hidden and not hidden nodes
+.Pq the parameter Ar :connected .
+.It Fl -logger-otp-reports Ar val
+Enables or disables OTP reporting
+.Pq Ar val No can be either true or false .
+.It Fl -logger-sasl-reports Ar val
+Enables or disables SASL reporting
+.Pq Ar val No can be either true or false .
+.It Fl -sname Ar name
+Gives a node a short name and starts it. Short names take the form of
+.Ar name Ns
+@host, where host is the name of the target host
+.Pq Xr hostname 1
+which runs the node. The nodes with short names can interact with each other only in the same local network.
+.It Fl -name Ar name
+Gives a node a long name and starts it. Long names take the form of
+.Ar name Ns
+@host, where host is the IP address of the host which runs the node. In contrast to the nodes with short names, the nodes with long names aren't limited by boundaries of a local network
+.Pq see above .
+.It Fl -pipe-to Ar pipedir Ar logdir
+Starts the Erlang VM as a named
+.Ar pipedir
+and
+.Ar logdir
+.Pq only for Unix-like operating systems .
+.It Fl -rpc-eval Ar node Ar expression
+Evaluates the specified expression on the specified node
+.Pq see the Fl -eval No option .
+.It Fl -vm-args Ar file
+Reads the command-line arguments from
+.Ar file
+and passes them to the Erlang VM.
+.Pp
+The option is equivalent to Erlang's
+.Fl args_file .
diff --git a/man/elixir.1.in b/man/elixir.1.in
new file mode 100644
index 00000000000..ceb20930540
--- /dev/null
+++ b/man/elixir.1.in
@@ -0,0 +1,63 @@
+.\" SPDX-License-Identifier: Apache-2.0
+.\" SPDX-FileCopyrightText: 2021 The Elixir Team
+.\" SPDX-FileCopyrightText: 2012 Plataformatec
+.Dd February 3, 2019
+.Dt ELIXIR 1
+.Os
+.Sh NAME
+.Nm elixir
+.Nd The Elixir script runner
+.Sh SYNOPSIS
+.Nm
+.Op Ar OPTIONS
+.Ar
+.Sh DESCRIPTION
+The program starts the runtime system typically for the execution of one or more scripts. It is similar to
+.Xr iex 1 ,
+but
+.Nm
+exits when the executed script does.
+.Sh OPTIONS
+Note that many of the options mentioned here were borrowed from the Erlang shell, therefore
+.Xr erl 1
+can be used as an additional source of information on the options.
+.Bl -tag -width Ds
+{COMMON}
+.It Fl -no-halt
+Does not halt the Erlang VM after execution.
+.It Fl -
+Separates the options passed to the compiler from the options passed to the executed code.
+.El
+.Sh NOTES
+The following options can be given more than once:
+.Fl -boot-var Ns , Fl -erl-config Ns , Fl -eval Ns , Fl -rpc-eval Ns .
+.Sh ENVIRONMENT
+.Bl -tag -width Ds
+.It Ev ELIXIR_ERL_OPTIONS
+Allows passing parameters to the Erlang runtime.
+.El
+.Sh FILES
+.Bl -tag -width Ds
+.It Pa ~/.erlang.cookie
+Stores the magic cookie value which is used only when it wasn't specified via the option
+.Fl -cookie
+.Pq see above .
+If the file doesn't exist when a node starts, it will be created.
+.El
+.Sh SEE ALSO
+.Xr elixirc 1 ,
+.Xr iex 1 ,
+.Xr mix 1
+.Sh AUTHOR
+.Bl -tag -width Ds
+.It Elixir is maintained by The Elixir Team.
+.It This manual page was contributed by Evgeny Golyshev.
+.It Copyright (c) 2012 Plataformatec.
+.It Copyright (c) 2021 The Elixir Team.
+.El
+.Sh INTERNET RESOURCES
+.Bl -tag -width Ds
+.It Main website: https://elixir-lang.org
+.It Documentation: https://elixir-lang.org/docs.html
+.It Package manager: https://hex.pm
+.El
diff --git a/man/elixirc.1 b/man/elixirc.1
new file mode 100644
index 00000000000..f0585105870
--- /dev/null
+++ b/man/elixirc.1
@@ -0,0 +1,60 @@
+.\" SPDX-License-Identifier: Apache-2.0
+.\" SPDX-FileCopyrightText: 2021 The Elixir Team
+.\" SPDX-FileCopyrightText: 2012 Plataformatec
+.Dd April 10, 2015
+.Dt ELIXIRC 1
+.Os
+.Sh NAME
+.Nm elixirc
+.Nd The Elixir compiler
+.Sh SYNOPSIS
+.Nm
+.Op Ar OPTIONS
+.Ar
+.Sh DESCRIPTION
+The compiler is intended for compilation one or more files containing the Elixir source code. The files should have the extension
+.Em .ex .
+.Sh OPTIONS
+.Bl -tag -width Ds
+.It Fl o Ar directory
+Places the output file in the specified directory. If the directory is not specified via the option, the current working directory will be used for the purpose.
+.It Fl -erl Ar parameters
+Serves the same purpose as ELIXIR_ERL_OPTIONS
+.Pq see the Sy ENVIRONMENT No section .
+.It Fl -ignore-module-conflict
+Disables warnings when a module was previously defined.
+.It Fl -no-debug-info
+Disables producing debugging information.
+.It Fl -no-docs
+Disables generating documentation.
+.It Fl -warnings-as-errors
+Makes all warnings into errors.
+.It Fl -verbose
+Activates verbose mode.
+.It Fl -
+Separates the options passed to the compiler from the options passed to the executed code.
+.El
+.Sh ENVIRONMENT
+.Bl -tag -width Ds
+.It Ev ELIXIR_ERL_OPTIONS
+Allows passing parameters to the Erlang runtime.
+.It Ev ERL_COMPILER_OPTIONS
+Allows passing parameters to the Erlang compiler
+.Pq see Xr erlc 1 .
+.El
+.Sh SEE ALSO
+.Xr elixir 1 ,
+.Xr iex 1 ,
+.Xr mix 1
+.Sh AUTHOR
+.Bl -tag -width Ds
+.It Elixir is maintained by The Elixir Team.
+.It This manual page was contributed by Evgeny Golyshev.
+.It Copyright (c) 2012 Plataformatec.
+.It Copyright (c) 2021 The Elixir Team.
+.El
+.Sh INTERNET RESOURCES
+.Bl -tag -width Ds
+.It Main website: https://elixir-lang.org
+.It Documentation: https://elixir-lang.org/docs.html
+.El
diff --git a/man/iex.1.in b/man/iex.1.in
new file mode 100644
index 00000000000..044c2d831a6
--- /dev/null
+++ b/man/iex.1.in
@@ -0,0 +1,72 @@
+.\" SPDX-License-Identifier: Apache-2.0
+.\" SPDX-FileCopyrightText: 2021 The Elixir Team
+.\" SPDX-FileCopyrightText: 2012 Plataformatec
+.Dd February 3, 2019
+.Dt IEX 1
+.Os
+.Sh NAME
+.Nm iex
+.Nd The Elixir shell
+.Sh SYNOPSIS
+.Nm
+.Op Ar OPTIONS
+.Sh DESCRIPTION
+The interactive shell is used for evaluation, debugging and introspection of the Elixir runtime system. It is also possible to use the program for testing the work of small pieces of code escaping the stage of saving the code in a file.
+.Sh OPTIONS
+Note that many of the options mentioned here were borrowed from the Erlang shell, therefore
+.Xr erl 1
+can be used as an additional source of information on the options.
+.Bl -tag -width Ds
+{COMMON}
+.It Fl -dot-iex Ar file
+Loads the specified file instead of
+.Pa .iex.exs
+.Pq see the Sy FILES No section .
+.It Fl -remsh Ar node
+Connects to the specified node which was started with the
+.Fl -sname
+or
+.Fl -name
+options
+.Pq see above .
+.It Fl -
+Separates the options passed to the compiler from the options passed to the executed code.
+.El
+.Sh NOTES
+The following options can be given more than once:
+.Fl -boot-var Ns , Fl -erl-config Ns , Fl -eval Ns , Fl -rpc-eval Ns .
+.Sh ENVIRONMENT
+.Bl -tag -width Ds
+.It Ev ELIXIR_ERL_OPTIONS
+Allows passing parameters to the Erlang runtime.
+.El
+.Sh FILES
+.Bl -tag -width Ds
+.It Pa ~/.erlang.cookie
+Stores the magic cookie value which is used only when it wasn't specified via the option
+.Fl -cookie
+.Pq see above .
+If the file doesn't exist when a node starts, it will be created.
+.It Pa .iex.exs
+After
+.Nm
+starts, it seeks the file
+.Pa .iex.exs
+and, in a case of success, executes the code from the file in the context of the shell. At first the search starts in the current working directory; then, if necessary, it continues in the home directory.
+.El
+.Sh SEE ALSO
+.Xr elixir 1 ,
+.Xr elixirc 1 ,
+.Xr mix 1
+.Sh AUTHOR
+.Bl -tag -width Ds
+.It Elixir is maintained by The Elixir Team.
+.It This manual page was contributed by Evgeny Golyshev.
+.It Copyright (c) 2012 Plataformatec.
+.It Copyright (c) 2021 The Elixir Team.
+.El
+.Sh INTERNET RESOURCES
+.Bl -tag -width Ds
+.It Main website: https://elixir-lang.org
+.It Documentation: https://elixir-lang.org/docs.html
+.El
diff --git a/man/mix.1 b/man/mix.1
new file mode 100644
index 00000000000..cf839b0bba8
--- /dev/null
+++ b/man/mix.1
@@ -0,0 +1,152 @@
+.\" SPDX-License-Identifier: Apache-2.0
+.\" SPDX-FileCopyrightText: 2021 The Elixir Team
+.\" SPDX-FileCopyrightText: 2012 Plataformatec
+.Dd May 27, 2015
+.Dt MIX 1
+.Os
+.Sh NAME
+.Nm mix
+.Nd The software project management tool
+.Sh SYNOPSIS
+.Nm
+.Op Ar TASK
+.Op Ar project_name
+.Nm elixir
+.Op Ar OPTIONS
+.Fl S Nm
+.Op Ar TASK
+.Op Ar project_name
+.Sh DESCRIPTION
+.Nm
+is intended for both organizing code into projects and their maintenance. For the latter the tool offers some advanced features like dependency management, packaging, preparing documentation, testing and so on.
+.Pp
+Have a look at the
+.Sy SYNOPSIS
+section and the second way of running
+.Nm
+it offers. The point is that the tool is none other than the Elixir script, therefore it can be invoked via
+.Xr elixir 1
+in the same way as any other script. It's useful when you want to run
+.Nm
+with particular options.
+.Sh DEFINITIONS
+All the
+.Nm
+functionality is represented by a set of tasks. A
+.Em task
+is a piece of code written in Elixir and intended for solving a particular problem. Like programs, many tasks accept input parameters and/or support options which slightly modify their behavior, but others do not. There are two types of tasks: those that are available after installation this or that archive
+.Pq local tasks
+and those that are offered by
+.Nm
+.Pq built-in tasks .
+The
+.Sy run
+task will be executed by default if none other has been specified.
+.Pp
+In spite of the fact that the greater part of
+.Nm
+is tasks, the man page doesn't contain the help information related to each of them because
+.Nm
+is self-descriptive. Thus, using the
+.Sy help
+task, you can get both the full list of local/built-in tasks and the information related to a particular task.
+.Pp
+An
+.Em archive ,
+in terms of Erlang/OTP, is the ZIP file with the
+.Em .ez
+extension which contains a precompiled OTP application with all its dependencies\~[1].
+.Pp
+An
+.Em application
+is an entity that helps to combine sets of components into a single unit to simplify their reusing in other systems\~[2].
+.Sh ENVIRONMENT
+.Bl -tag -width Ds
+.It Ev MIX_ARCHIVES
+Allows specifying the directory into which the archives should be installed
+.Pq see Sy mix help archive.install .
+The
+.Em ~/.mix/archives
+directory is used for this purpose by default.
+.It Ev MIX_DEBUG
+When set, outputs debug information about each task before running it.
+.It Ev MIX_ENV
+Allows specifying which environment should be used. The
+.Em dev
+environment is used by default if none other has been specified.
+.Pp
+Sometimes you have to use a particular set of configuration parameter values or perform particular steps when you compile or run a project
+.Pq or in some other cases .
+The
+.Nm
+environments allow grouping values of configuration parameters and steps to switch between them by specifying the necessary environment via MIX_ENV.
+.It Ev MIX_TARGET
+Allows specifying which target should be used. The
+.Em host
+target is used by default if none other has been specified.
+.It Ev MIX_EXS
+Allows changing the full path to the
+.Em mix.exs
+file
+.Pq see Sy FILES No section .
+The most obvious use case is to have more than one copy of
+.Em mix.exs
+in a project, but it's worth noting that MIX_EXS should be used only if the
+.Nm
+environments
+.Pq see above
+are not enough to solve the problem.
+.It Ev MIX_HOME
+path to Mix's home directory, stores configuration files and scripts used by Mix
+.It MIX_INSTALL_DIR
+Specifies directory where Mix.install/2 keeps installs cache
+.It MIX_INSTALL_FORCE
+Runs Mix.install/2 with empty install cache
+.It Ev MIX_PATH
+Allows expanding the code path. If the MIX_PATH environment variable has a value which consists of multiple paths, they must be colon-separated
+.Pq for Unix-like operating systems
+or semicolon-separated
+.Pq for Windows .
+.Pp
+As mentioned above, there are two types of tasks: local and built-in. These tasks are always visible for
+.Nm
+because the directories, in which they are located, are a part of code path. If a task belongs to neither the one type nor the other, MIX_PATH helps you say to
+.Nm
+where it should search the task.
+.It Ev MIX_QUIET
+When set, does not print information messages to the terminal.
+.El
+.Sh FILES
+.Bl -tag -width Ds
+.It mix.exs
+Contains the most significant information related to the project, such as its name, version, list of dependencies and so on. As a rule, the file is named
+.Em mix.exs
+and located at the top of the project's source tree, but you can change the full path to it using the MIX_EXS environment variable
+.Pq see the Sy ENVIRONMENT No section .
+.It mix.lock
+Allows locking down the project dependencies with a proper version range before performing any updates. It is useful when you know that your project is incompatible with newer versions of certain dependencies. The file is located at the top of the project's source tree as well as
+.Em mix.exs
+.Pq see above .
+.El
+.Sh REFERENCES
+.Bl -tag -width Ds
+.It [1] https://www.erlang.org/doc/man/code.html#id103620
+.It [2] https://www.erlang.org/doc/design_principles/applications.html
+.El
+.Sh SEE ALSO
+.Xr elixir 1 ,
+.Xr elixirc 1 ,
+.Xr iex 1
+.Sh AUTHOR
+.Bl -tag -width Ds
+.It Elixir is maintained by The Elixir Team.
+.It This manual page was contributed by Evgeny Golyshev.
+.It Copyright (c) 2012 Plataformatec.
+.It Copyright (c) 2021 The Elixir Team.
+.El
+.Sh INTERNET RESOURCES
+.Bl -tag -width Ds
+.It Main website: https://elixir-lang.org
+.It Documentation: https://elixir-lang.org/docs.html
+.It Package manager: https://hex.pm
+.El
diff --git a/project.spdx.yml b/project.spdx.yml
new file mode 100644
index 00000000000..9d4ebc57455
--- /dev/null
+++ b/project.spdx.yml
@@ -0,0 +1,192 @@
+SPDXID: "SPDXRef-DOCUMENT"
+spdxVersion: "SPDX-2.2"
+creationInfo:
+  created: "2025-02-05T12:29:35Z"
+  creators:
+  - "Organization: The Elixir Team"
+  licenseListVersion: "3.9"
+name: "elixir"
+dataLicense: "CC0-1.0"
+documentNamespace: "https://github.com/elixir-lang/elixir"
+documentDescribes:
+- "SPDXRef-Project-elixir-lang"
+packages:
+- SPDXID: "SPDXRef-Project-elixir-lang"
+  summary: "Elixir is a dynamic, functional language for building scalable and maintainable applications"
+  copyrightText: "Copyright (c) 2012 Plataformatec. Copyright (c) 2021 The Elixir Team. All Rights Reserved."
+  downloadLocation: "git+https://github.com/elixir-lang/elixir.git"
+  filesAnalyzed: false
+  homepage: "https://elixir-lang.org/"
+  licenseConcluded: "Apache-2.0 AND LicenseRef-scancode-unicode AND LicenseRef-elixir-trademark-policy"
+  licenseDeclared: "Apache-2.0 AND LicenseRef-scancode-unicode AND LicenseRef-elixir-trademark-policy"
+  name: "elixir-lang"
+  originator: "Organization: The Elixir Team"
+  supplier: "Organization: The Elixir Team"
+  packageFileName: "."
+  externalRefs:
+    - referenceCategory: PACKAGE-MANAGER
+      referenceType: "purl"
+      referenceLocator: "pkg:github/elixir-lang/elixir"
+      comment: "GitHub PURL"
+  # elixir-version-insert
+- SPDXID: "SPDXRef-Package-eex"
+  summary: "Elixir is a dynamic, functional language for building scalable and maintainable applications"
+  copyrightText: "Copyright (c) 2012 Plataformatec. Copyright (c) 2021 The Elixir Team. All Rights Reserved."
+  downloadLocation: "git+https://github.com/elixir-lang/elixir.git#lib/eex"
+  filesAnalyzed: false
+  homepage: "https://elixir-lang.org/"
+  licenseConcluded: "Apache-2.0"
+  licenseDeclared: "Apache-2.0"
+  name: "eex"
+  originator: "Organization: The Elixir Team"
+  supplier: "Organization: The Elixir Team"
+  packageFileName: "./lib/eex"
+  externalRefs:
+    - referenceCategory: PACKAGE-MANAGER
+      referenceType: "purl"
+      referenceLocator: "pkg:otp/eex"
+      comment: "OTP PURL"
+  # elixir-version-insert
+- SPDXID: "SPDXRef-Package-elixir"
+  summary: "Elixir is a dynamic, functional language for building scalable and maintainable applications"
+  copyrightText: "Copyright (c) 2012 Plataformatec. Copyright (c) 2021 The Elixir Team. All Rights Reserved."
+  downloadLocation: "git+https://github.com/elixir-lang/elixir.git#lib/elixir"
+  filesAnalyzed: false
+  homepage: "https://elixir-lang.org/"
+  licenseConcluded: "Apache-2.0 AND LicenseRef-scancode-unicode"
+  licenseDeclared: "Apache-2.0 AND LicenseRef-scancode-unicode"
+  name: "elixir"
+  originator: "Organization: The Elixir Team"
+  supplier: "Organization: The Elixir Team"
+  packageFileName: "./lib/elixir"
+  externalRefs:
+    - referenceCategory: PACKAGE-MANAGER
+      referenceType: "purl"
+      referenceLocator: "pkg:otp/elixir"
+      comment: "OTP PURL"
+  # elixir-version-insert
+- SPDXID: "SPDXRef-Package-exunit"
+  summary: "Elixir is a dynamic, functional language for building scalable and maintainable applications"
+  copyrightText: "Copyright (c) 2012 Plataformatec. Copyright (c) 2021 The Elixir Team. All Rights Reserved."
+  downloadLocation: "git+https://github.com/elixir-lang/elixir.git#lib/ex_unit"
+  filesAnalyzed: false
+  homepage: "https://elixir-lang.org/"
+  licenseConcluded: "Apache-2.0"
+  licenseDeclared: "Apache-2.0"
+  name: "exunit"
+  originator: "Organization: The Elixir Team"
+  supplier: "Organization: The Elixir Team"
+  packageFileName: "./lib/ex_unit"
+  externalRefs:
+    - referenceCategory: PACKAGE-MANAGER
+      referenceType: "purl"
+      referenceLocator: "pkg:otp/ex_unit"
+      comment: "OTP PURL"
+  # elixir-version-insert
+- SPDXID: "SPDXRef-Package-iex"
+  summary: "Elixir is a dynamic, functional language for building scalable and maintainable applications"
+  copyrightText: "Copyright (c) 2012 Plataformatec. Copyright (c) 2021 The Elixir Team. All Rights Reserved."
+  downloadLocation: "git+https://github.com/elixir-lang/elixir.git#lib/iex"
+  filesAnalyzed: false
+  homepage: "https://elixir-lang.org/"
+  licenseConcluded: "Apache-2.0"
+  licenseDeclared: "Apache-2.0"
+  name: "iex"
+  originator: "Organization: The Elixir Team"
+  supplier: "Organization: The Elixir Team"
+  packageFileName: "./lib/iex"
+  externalRefs:
+    - referenceCategory: PACKAGE-MANAGER
+      referenceType: "purl"
+      referenceLocator: "pkg:otp/iex"
+      comment: "OTP PURL"
+  # elixir-version-insert
+- SPDXID: "SPDXRef-Package-logger"
+  summary: "Elixir is a dynamic, functional language for building scalable and maintainable applications"
+  copyrightText: "Copyright (c) 2012 Plataformatec. Copyright (c) 2021 The Elixir Team. All Rights Reserved."
+  downloadLocation: "git+https://github.com/elixir-lang/elixir.git/lib/logger"
+  filesAnalyzed: false
+  homepage: "https://elixir-lang.org/"
+  licenseConcluded: "Apache-2.0"
+  licenseDeclared: "Apache-2.0"
+  name: "logger"
+  originator: "Organization: The Elixir Team"
+  supplier: "Organization: The Elixir Team"
+  packageFileName: "./lib/logger"
+  externalRefs:
+    - referenceCategory: PACKAGE-MANAGER
+      referenceType: "purl"
+      referenceLocator: "pkg:otp/logger"
+      comment: "OTP PURL"
+  # elixir-version-insert
+- SPDXID: "SPDXRef-Package-mix"
+  summary: "Elixir is a dynamic, functional language for building scalable and maintainable applications"
+  copyrightText: "Copyright (c) 2012 Plataformatec. Copyright (c) 2021 The Elixir Team. All Rights Reserved."
+  downloadLocation: "git+https://github.com/elixir-lang/elixir.git#lib/mix"
+  filesAnalyzed: false
+  homepage: "https://elixir-lang.org/"
+  licenseConcluded: "Apache-2.0"
+  licenseDeclared: "Apache-2.0"
+  name: "mix"
+  originator: "Organization: The Elixir Team"
+  supplier: "Organization: The Elixir Team"
+  packageFileName: "./lib/mix"
+  externalRefs:
+    - referenceCategory: PACKAGE-MANAGER
+      referenceType: "purl"
+      referenceLocator: "pkg:otp/mix"
+      comment: "OTP PURL"
+  # elixir-version-insert
+- SPDXID: "SPDXRef-Project-erlang"
+  description: "Erlang is a programming language and runtime system for building massively scalable soft real-time systems with requirements on high availability."
+  copyrightText: "Copyright Ericsson AB 2010-2024. All Rights Reserved."
+  downloadLocation: "git+https://github.com/erlang/otp.git"
+  filesAnalyzed: false
+  homepage: "https://www.erlang.org/"
+  licenseConcluded: "Apache-2.0"
+  licenseDeclared: "Apache-2.0"
+  name: "erlang"
+  originator: "Organization: Ericsson AB"
+  supplier: "Organization: Ericsson AB"
+  externalRefs:
+    - referenceCategory: PACKAGE-MANAGER
+      referenceType: "purl"
+      referenceLocator: "pkg:github/erlang/otp"
+      comment: "GitHub PURL"
+relationships:
+- spdxElementId: "SPDXRef-Project-elixir-lang"
+  relatedSpdxElement: "SPDXRef-Package-eex"
+  relationshipType: "STATIC_LINK" # Should be CONTAINS, issue with ORT
+- spdxElementId: "SPDXRef-Project-elixir-lang"
+  relatedSpdxElement: "SPDXRef-Package-elixir"
+  relationshipType: "STATIC_LINK" # Should be CONTAINS, issue with ORT
+- spdxElementId: "SPDXRef-Project-elixir-lang"
+  relatedSpdxElement: "SPDXRef-Package-exunit"
+  relationshipType: "STATIC_LINK" # Should be CONTAINS, issue with ORT
+- spdxElementId: "SPDXRef-Project-elixir-lang"
+  relatedSpdxElement: "SPDXRef-Package-iex"
+  relationshipType: "STATIC_LINK" # Should be CONTAINS, issue with ORT
+- spdxElementId: "SPDXRef-Project-elixir-lang"
+  relatedSpdxElement: "SPDXRef-Package-logger"
+  relationshipType: "STATIC_LINK" # Should be CONTAINS, issue with ORT
+- spdxElementId: "SPDXRef-Project-elixir-lang"
+  relatedSpdxElement: "SPDXRef-Package-mix"
+  relationshipType: "STATIC_LINK" # Should be CONTAINS, issue with ORT
+- spdxElementId: "SPDXRef-Package-elixir"
+  relatedSpdxElement: "SPDXRef-Project-erlang"
+  relationshipType: "RUNTIME_DEPENDENCY_OF"
+- spdxElementId: "SPDXRef-Package-eex"
+  relatedSpdxElement: "SPDXRef-Package-elixir"
+  relationshipType: "STATIC_LINK"
+- spdxElementId: "SPDXRef-Package-exunit"
+  relatedSpdxElement: "SPDXRef-Package-elixir"
+  relationshipType: "STATIC_LINK"
+- spdxElementId: "SPDXRef-Package-iex"
+  relatedSpdxElement: "SPDXRef-Package-elixir"
+  relationshipType: "STATIC_LINK"
+- spdxElementId: "SPDXRef-Package-logger"
+  relatedSpdxElement: "SPDXRef-Package-elixir"
+  relationshipType: "STATIC_LINK"
+- spdxElementId: "SPDXRef-Package-mix"
+  relatedSpdxElement: "SPDXRef-Package-elixir"
+  relationshipType: "STATIC_LINK"
diff --git a/rebar b/rebar
deleted file mode 100755
index f28a1d353e5..00000000000
Binary files a/rebar and /dev/null differ
diff --git a/rebar.config b/rebar.config
deleted file mode 100644
index 444ebef8ce9..00000000000
--- a/rebar.config
+++ /dev/null
@@ -1,21 +0,0 @@
-%% Using elixir as a rebar dependency
-
-%% This configuration file only exists so Elixir can be used
-%% as a rebar dependency, the same happens for the file
-%% src/elixir.app.src.
-
-%% In practice, Elixir is structured as OTP where many applications
-%% are placed in the lib directory. Since this structure is not
-%% supported by default by rebar, after adding Elixir as a dependency
-%% you need to explicitly add it to lib_dirs:
-%%
-%%   {lib_dirs, [
-%%     "deps/elixir/lib"
-%%   ]}.
-%%
-
-%% Run make as the proper compilation step
-{post_hooks, [{compile,"make compile"}]}.
-
-%% This prevents rebar_elixir_plugin from recompiling Elixir
-{ex_opts, [{src_dirs, [".PHONY"]}]}.
diff --git a/src/elixir.app.src b/src/elixir.app.src
deleted file mode 100644
index 2006fe1de53..00000000000
--- a/src/elixir.app.src
+++ /dev/null
@@ -1,11 +0,0 @@
-{application, elixir,
-[{description, "elixir"},
- {vsn, "0.14.3-dev"},
- {modules, [
-	elixir
-  ]},
- {registered, [elixir_code_server]},
- {applications, [kernel,stdlib]},
- {mod, {elixir,[]}},
- {env, [{uri, #{}}]}
-]}.